ZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL0Fubm90YXRpb25EZWZpbml0aW9uLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9Bbm5vdGF0aW9uRGVmaW5pdGlvbi5qYXZhCmluZGV4IDg5YTgyY2QuLjkzMzYyMTIgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL0Fubm90YXRpb25EZWZpbml0aW9uLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2Fubm90YXRpb25zL2NvcmUvQW5ub3RhdGlvbkRlZmluaXRpb24uamF2YQpAQCAtMjEsMjMgKzIxLDMwIEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuaW5pdGlhbGl6YXRpb24uSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcjsKIAogLyoqCi0gKiAKKyAqIEFuIDxjb2RlPkFubm90YXRpb25EZWZpbml0aW9uPC9jb2RlPiBpcyBhIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBpbmZvcm1hdGlvbiBjb250cmlidXRlZCB0aHJvdWdoIHRoZQorICogPGNvZGU+b3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuYW5ub3RhdGlvbkRlZmluaXRpb248L2NvZGU+LAorICogPGNvZGU+b3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuYW5ub3RhdGlvbkNhdGVnb3J5PC9jb2RlPiBhbmQKKyAqIDxjb2RlPm9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLmFubm90YXRpb25Jbml0aWFsaXplcjwvY29kZT4gZXh0ZW5zaW9uIHBvaW50cy4KKyAqIGZvciBhIDxjb2RlPmphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb248L2NvZGU+IGNsYXNzLgogICogPHA+Ci0gKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyIAotICogZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZyBzdGFiaWxpdHkuIEl0IGlzIGJlaW5nIG1hZGUgYXZhaWxhYmxlIGF0IAotICogdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20gcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyAKKyAqIEl0IHN1cHBsaWVzIHRoZSBhbm5vdGF0aW9uIGNsYXNzIG5hbWUsIGl0cyBhbm5vdGF0aW9uIGNhdGVnb3J5LCB0aGUgYXBwbGljYWJsZSB0YXJnZXRzIGZvciB0aGUgYW5ub3RhdGlvbgorICogYW5kIGFuIDxjb2RlPklBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXI8L2NvZGU+IHRvIGluaXRpYWxpemUgdGhlIGFubm90YXRpb25zIGVsZW1lbnQtdmFsdWUgcGFpcnMuCisgKiA8L3A+CisgKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyCisgKiBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nIHN0YWJpbGl0eS4gSXQgaXMgYmVpbmcgbWFkZSBhdmFpbGFibGUgYXQKKyAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMKICAqIHRoaXMgQVBJIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KICAqIDwvcD4KICAqLwotcHVibGljIGNsYXNzIEFubm90YXRpb25EZWZpbml0aW9uIHsKK3B1YmxpYyBmaW5hbCBjbGFzcyBBbm5vdGF0aW9uRGVmaW5pdGlvbiB7CiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFUVF9DTEFTUyA9ICJjbGFzcyI7IC8vJE5PTi1OTFMtMSQKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQVRUX05BTUUgPSAibmFtZSI7IC8vJE5PTi1OTFMtMSQKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQVRUX1JFU1RSSUNURURfVE8gPSAicmVzdHJpY3RlZFRvIjsgLy8kTk9OLU5MUy0xJAotICAgIAorCiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFU1RSSUNURURfVE9fQ0xBU1NfT05MWSA9ICJDTEFTU19PTkxZIjsKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUkVTVFJJQ1RFRF9UT19JTlRFUkZBQ0VfT05MWSA9ICJJTlRFUkZBQ0VfT05MWSI7CiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFU1RSSUNURURfVE9fRU5VTV9PTkxZID0gIkVOVU1fT05MWSI7Ci0gICAgCisKICAgICBwcml2YXRlIElDb25maWd1cmF0aW9uRWxlbWVudCBjb25maWd1cmF0aW9uRWxlbWVudDsKICAgICBwcml2YXRlIFN0cmluZyBjYXRlZ29yeTsKICAgICBwcml2YXRlIFN0cmluZyBhbm5vdGF0aW9uQ2xhc3NOYW1lOwpAQCAtNDksNDQgKzU2LDgxIEBACiAgICAgcHJpdmF0ZSBib29sZWFuIGludGVyZmFjZU9ubHk7CiAgICAgcHJpdmF0ZSBib29sZWFuIGNsYXNzT25seTsKICAgICBwcml2YXRlIGJvb2xlYW4gZW51bU9ubHk7Ci0gICAgCisKKyAgICAvKioKKyAgICAgKiBDb25zdHJ1Y3RzIGFuIDxjb2RlPkFubm90YXRpb25EZWZpbml0aW9uPC9jb2RlPiB1c2luZyBpbmZvcm1hdGlvbiBmcm9tIHRoZQorICAgICAqIDxjb2RlPm9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLmFubm90YXRpb25EZWZpbml0aW9uPC9jb2RlPiBleHRlbnNpb24gcG9pbnQgYW5kIGNhdGVnb3J5IG5hbWUuCisgICAgICogQHBhcmFtIGNvbmZpZ3VyYXRpb25FbGVtZW50IHRoZSA8Y29kZT5hbm5vdGF0aW9uPC9jb2RlPiBlbGVtZW50IGZyb20gdGhlIDxjb2RlPm9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLmFubm90YXRpb25EZWZpbml0aW9uPC9jb2RlPiBleHRlbnNpb24gcG9pbnQKKyAgICAgKiBAcGFyYW0gY2F0ZWdvcnkgdGhlIGNhdGVnb3J5IG5hbWUKKyAgICAgKi8KICAgICBwdWJsaWMgQW5ub3RhdGlvbkRlZmluaXRpb24oSUNvbmZpZ3VyYXRpb25FbGVtZW50IGNvbmZpZ3VyYXRpb25FbGVtZW50LCBTdHJpbmcgY2F0ZWdvcnkpIHsKICAgICAgICAgdGhpcy5jb25maWd1cmF0aW9uRWxlbWVudCA9IGNvbmZpZ3VyYXRpb25FbGVtZW50OwogICAgICAgICB0aGlzLmNhdGVnb3J5ID0gY2F0ZWdvcnk7Ci0gICAgICAgIAorCiAgICAgICAgIHRoaXMuYW5ub3RhdGlvbkNsYXNzTmFtZSA9IEFubm90YXRpb25zTWFuYWdlci5nZXRBdHRyaWJ1dGVWYWx1ZShjb25maWd1cmF0aW9uRWxlbWVudCwgQVRUX0NMQVNTKTsKICAgICAgICAgdGhpcy5uYW1lID0gQW5ub3RhdGlvbnNNYW5hZ2VyLmdldEF0dHJpYnV0ZVZhbHVlKGNvbmZpZ3VyYXRpb25FbGVtZW50LCBBVFRfTkFNRSk7Ci0gICAgICAgIHRoaXMucmVzdGljdGVkVG8gPSBBbm5vdGF0aW9uc01hbmFnZXIuZ2V0QXR0cmlidXRlVmFsdWUoY29uZmlndXJhdGlvbkVsZW1lbnQsIAorICAgICAgICB0aGlzLnJlc3RpY3RlZFRvID0gQW5ub3RhdGlvbnNNYW5hZ2VyLmdldEF0dHJpYnV0ZVZhbHVlKGNvbmZpZ3VyYXRpb25FbGVtZW50LAogICAgICAgICAgICAgICAgIEFUVF9SRVNUUklDVEVEX1RPKTsKICAgICAgICAgdGhpcy5jbGFzc09ubHkgPSByZXN0aWN0ZWRUby5lcXVhbHMoUkVTVFJJQ1RFRF9UT19DTEFTU19PTkxZKTsKICAgICAgICAgdGhpcy5pbnRlcmZhY2VPbmx5ID0gcmVzdGljdGVkVG8uZXF1YWxzKFJFU1RSSUNURURfVE9fSU5URVJGQUNFX09OTFkpOwogICAgICAgICB0aGlzLmVudW1Pbmx5ID0gcmVzdGljdGVkVG8uZXF1YWxzKFJFU1RSSUNURURfVE9fRU5VTV9PTkxZKTsKICAgICB9Ci0gICAgICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgYW5ub3RhdGlvbiBuYW1lLgorICAgICAqIEByZXR1cm4gdGhlIGFubm90YXRpb24gbmFtZS4KKyAgICAgKi8KICAgICBwdWJsaWMgU3RyaW5nIGdldE5hbWUoKSB7CiAgICAgICAgIHJldHVybiBuYW1lOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqIFJldHVybnMgdGhlIGNhdGVnb3J5IHRoZSBhbm5vdGF0aW9uIGJlbG9uZ3MgdG8uCisgICAgICogQHJldHVybiB0aGUgYW5ub3RhdGlvbiBjYXRlZ29yeS4KKyAgICAgKi8KICAgICBwdWJsaWMgU3RyaW5nIGdldENhdGVnb3J5KCkgewogICAgICAgICByZXR1cm4gY2F0ZWdvcnk7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgZnVsbHkgcXVhbGlmaWVkIGNsYXNzIG5hbWUgb2YgdGhlIGFubm90YXRpb24uCisgICAgICogQHJldHVybiB0aGUgZnVsbHkgcXVhbGlmaWVkIGNsYXNzIG5hbWUgb2YgdGhlIGFubm90YXRpb24uCisgICAgICovCiAgICAgcHVibGljIFN0cmluZyBnZXRBbm5vdGF0aW9uQ2xhc3NOYW1lKCkgewogICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkNsYXNzTmFtZTsKICAgICB9Ci0gICAgCisKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHdoZXRoZXIgdGhlIGFubm90YXRpb24gaXMgcmVzdHJpY3RlZCB0byBjbGFzcyB0eXBlcy4KKyAgICAgKiBAcmV0dXJuIDxjb2RlPnRydWU8L2NvZGU+IGlmIHRoZSBhbm5vdGF0aW9uIGlzIHJlc3RyaWN0ZWQgdG8gY2xhc3NlcyBvbmx5LgorICAgICAqLwogICAgIHB1YmxpYyBib29sZWFuIGlzQ2xhc3NPbmx5KCkgewogICAgICAgICByZXR1cm4gY2xhc3NPbmx5OwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqIFJldHVybnMgd2hldGhlciB0aGUgYW5ub3RhdGlvbiBpcyByZXN0cmljdGVkIHRvIGludGVyZmFjZSB0eXBlcy4KKyAgICAgKiBAcmV0dXJuIDxjb2RlPnRydWU8L2NvZGU+IGlmIHRoZSBhbm5vdGF0aW9uIGlzIHJlc3RyaWN0ZWQgdG8gaW50ZXJmYWNlcyBvbmx5LgorICAgICAqLwogICAgIHB1YmxpYyBib29sZWFuIGlzSW50ZXJmYWNlT25seSgpIHsKICAgICAgICAgcmV0dXJuIGludGVyZmFjZU9ubHk7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyB3aGV0aGVyIHRoZSBhbm5vdGF0aW9uIGlzIHJlc3RyaWN0ZWQgdG8gZW51bSB0eXBlcy4KKyAgICAgKiBAcmV0dXJuIDxjb2RlPnRydWU8L2NvZGU+IGlmIHRoZSBhbm5vdGF0aW9uIGlzIHJlc3RyaWN0ZWQgdG8gZW51bXMgb25seS4KKyAgICAgKi8KICAgICBwdWJsaWMgYm9vbGVhbiBpc0VudW1Pbmx5KCkgewogICAgICAgICByZXR1cm4gZW51bU9ubHk7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgYW5ub3RhdGlvbiBjbGFzcyBhcyBzcGVjaWZpZWQgYnkgdGhlIDxjb2RlPmNsYXNzPC9jb2RlPiBhdHRyaWJ1dGUgb2YgdGhlCisgICAgICogPGNvZGU+YW5ub3RhdGlvbjxhbm5vdGF0aW9uPiBlbGVtZW50IGluIHRoZSA8Y29kZT5vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5hbm5vdGF0aW9uRGVmaW5pdGlvbjwvY29kZT4KKyAgICAgKiBleHRlbnNpb24gcG9pbnQuCisgICAgICoKKyAgICAgKiBAcmV0dXJuIHRoZSBhbm5vdGF0aW9uIGNsYXNzCisgICAgICovCiAgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCiAgICAgcHVibGljIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBnZXRBbm5vdGF0aW9uQ2xhc3MoKSB7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uQ2xhc3MgPT0gbnVsbCkgewpAQCAtMTAyLDMyICsxNDYsNTEgQEAKICAgICAgICAgfQogICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkNsYXNzOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqIFJldHVybnMgYSBsaXN0IG9mIDxjb2RlPkVsZW1lbnRUeXBlPC9jb2RlPiB0aGF0IHNwZWNpZnkgdGhlIEphdmEgZWxlbWVudHMgdG8gd2hpY2ggdGhlIGFubm90YXRpb24KKyAgICAgKiBjYW4gYmUgYXBwbGllZC4KKyAgICAgKiA8cD4KKyAgICAgKiBUaGUgPGNvZGU+RWxlbWVudFR5cGU8L2NvZGU+IGFyZSByZXRyaWV2ZWQgZnJvbSB0aGUgYW5ub3RhdGlvbnMKKyAgICAgKiA8Y29kZT5qYXZhLmxhbmcuYW5ub3RhdGlvbi5UYXJnZXQ8L2NvZGU+IG1ldGEtYW5ub3RhdGlvbiB0eXBlLiBUaGlzIGxpc3QgY2FuIGJlIGZpbHRlcmVkIHVzaW5nCisgICAgICogdGhlIDxjb2RlPnRhcmdldEZpbHRlcjwvY29kZT4gZWxlbWVudCBvbiB0aGUKKyAgICAgKiA8Y29kZT5vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5hbm5vdGF0aW9uRGVmaW5pdGlvbjwvY29kZT4gZXh0ZW5zaW9uIHBvaW50IHdoZW4gZGVmaW5pbmcKKyAgICAgKiB0aGUgYW5ub3RhdGlvbi4KKyAgICAgKiA8L3A+CisgICAgICogQHJldHVybiBhIGxpc3Qgb2YgPGNvZGU+RWxlbWVudFR5cGU8L2NvZGU+CisgICAgICovCiAgICAgcHVibGljIExpc3Q8RWxlbWVudFR5cGU+IGdldFRhcmdldHMoKSB7CiAgICAgICAgIGlmICh0YXJnZXRzID09IG51bGwpIHsKICAgICAgICAgCXRhcmdldHMgPSBuZXcgTGlua2VkTGlzdDxFbGVtZW50VHlwZT4oKTsKLSAgICAgICAgCQorCiAgICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbiA9IGdldEFubm90YXRpb25DbGFzcygpOwogICAgICAgICAgICAgaWYgKGFubm90YXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgCVRhcmdldCB0YXJnZXQgPSBhbm5vdGF0aW9uLmdldEFubm90YXRpb24oVGFyZ2V0LmNsYXNzKTsKICAgICAgICAgICAgIAlpZiAodGFyZ2V0ICE9IG51bGwpIHsKICAgICAgICAgICAgIAkgICAgdGFyZ2V0cy5hZGRBbGwoQXJyYXlzLmFzTGlzdCh0YXJnZXQudmFsdWUoKSkpOwotICAgICAgICAgICAgCSAgICAKKwogICAgICAgICAgICAgICAgICAgICBMaXN0PEVsZW1lbnRUeXBlPiBmaWx0ZXJlZFRhcmdldHMgPSBBbm5vdGF0aW9uc01hbmFnZXIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZ2V0RmlsdGVyZWRUYXJnZXRzKGNvbmZpZ3VyYXRpb25FbGVtZW50KTsKICAgICAgICAgICAgICAgICAgICAgaWYgKHRhcmdldHMuY29udGFpbnNBbGwoZmlsdGVyZWRUYXJnZXRzKSAmJiBmaWx0ZXJlZFRhcmdldHMuc2l6ZSgpIDwgdGFyZ2V0cy5zaXplKCkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldHMucmVtb3ZlQWxsKGZpbHRlcmVkVGFyZ2V0cyk7CiAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIAl9IAorICAgICAgICAgICAgCX0KICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gdGFyZ2V0czsKICAgICB9Ci0gICAgCisKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHRoZSBhbm5vdGF0aW9ucyBhdHRyaWJ1dGUgaW5pdGlhbGl6ZXIgYXMgc3BlY2lmaWVkIGluIHRoZQorICAgICAqIDxjb2RlPm9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLmFubm90YXRpb25Jbml0aWFsaXplcjwvY29kZT4gZXh0ZW5zaW9uIHBvaW50IG9yIG51bGwgaWYgbm8KKyAgICAgKiBpbml0aWFsaXplciBjYW4gYmUgZm91bmQuCisgICAgICoKKyAgICAgKiBAcmV0dXJuIHRoZSA8Y29kZT5JQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyPC9jb2RlPgorICAgICAqLwogICAgIHB1YmxpYyBJQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGdldEFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcigpIHsKICAgICAgICAgaWYgKGFubm90YXRpb25Jbml0aWFsaXplciA9PSBudWxsKSB7CiAgICAgICAgICAgICB0cnkgewotICAgICAgICAgICAgICAgIElDb25maWd1cmF0aW9uRWxlbWVudCBjb25maWd1cmF0aW9uRWxlbWVudCA9IAorICAgICAgICAgICAgICAgIElDb25maWd1cmF0aW9uRWxlbWVudCBjb25maWd1cmF0aW9uRWxlbWVudCA9CiAgICAgICAgICAgICAgICAgICAgIEFubm90YXRpb25zTWFuYWdlci5nZXRBbm5vdGF0aW9uSW5pdGlhbGl6ZXJDYWNoZSgpLmdldChnZXRBbm5vdGF0aW9uQ2xhc3NOYW1lKCkpOwogICAgICAgICAgICAgICAgIGlmIChjb25maWd1cmF0aW9uRWxlbWVudCAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgICAgIGFubm90YXRpb25Jbml0aWFsaXplciA9IChJQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyKWNvbmZpZ3VyYXRpb25FbGVtZW50CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9Bbm5vdGF0aW9uc0NvcmUuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL0Fubm90YXRpb25zQ29yZS5qYXZhCmluZGV4IDM2ZTc1NDYuLmMyOTk3MDMgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL0Fubm90YXRpb25zQ29yZS5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL0Fubm90YXRpb25zQ29yZS5qYXZhCkBAIC0zNCwxMSArMzQsMTEgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uU3RyaW5nTGl0ZXJhbDsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uVHlwZUxpdGVyYWw7CiAvKioKLSAqIAorICogVXRpbGl0eSBjbGFzcyBmb3IgY3JlYXRpbmcgYW5ub3RhdGlvbnMgYW5kIG1lbWJlciB2YWx1ZSBwYWlycy4KICAqIDxwPgotICogPHN0cm9uZz5Qcm92aXNpb25hbCBBUEk6PC9zdHJvbmc+IFRoaXMgY2xhc3MvaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbCB1bmRlciAKLSAqIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcgc3RhYmlsaXR5LiBJdCBpcyBiZWluZyBtYWRlIGF2YWlsYWJsZSBhdCAKLSAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgCisgKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyCisgKiBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nIHN0YWJpbGl0eS4gSXQgaXMgYmVpbmcgbWFkZSBhdmFpbGFibGUgYXQKKyAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMKICAqIHRoaXMgQVBJIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KICAqIDwvcD4KICAqLwpAQCAtNDYsMTMgKzQ2LDIwIEBACiAKICAgICBwcml2YXRlIEFubm90YXRpb25zQ29yZSgpIHsKICAgICB9Ci0gICAgCi0gICAgcHVibGljIHN0YXRpYyBOb3JtYWxBbm5vdGF0aW9uIGNyZWF0ZU5vcm1hbEFubm90YXRpb24oQVNUIGFzdCwgU3RyaW5nIGFubm90YXRpb25OYW1lLCBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycykgewogCisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5Ob3JtYWxBbm5vdGF0aW9uPC9jb2RlPi4KKyAgICAgKgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSBhbm5vdGF0aW9uLgorICAgICAqIEBwYXJhbSBhbm5vdGF0aW9uTmFtZSB0aGUgbmFtZSBvZiB0aGUgYW5ub3RhdGlvbi4KKyAgICAgKiBAcGFyYW0gbWVtYmVyVmFsdWVQYWlycyBhIGxpc3Qgb2YgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPiB0byBhZGQgdG8gdGhlIDxjb2RlPk5vcm1hbEFubm90YXRpb248L2NvZGU+LgorICAgICAqIEByZXR1cm4gYSBub3JtYWwgYW5ub3RhdGlvbiB3aXRoIHRoZSBnaXZlbiBtZW1iZXIgdmFsdWUgcGFpcnMuCisgICAgICovCisgICAgcHVibGljIHN0YXRpYyBOb3JtYWxBbm5vdGF0aW9uIGNyZWF0ZU5vcm1hbEFubm90YXRpb24oQVNUIGFzdCwgU3RyaW5nIGFubm90YXRpb25OYW1lLCBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycykgewogICAgICAgICBOb3JtYWxBbm5vdGF0aW9uIGFubm90YXRpb24gPSBhc3QubmV3Tm9ybWFsQW5ub3RhdGlvbigpOwotICAgICAgICAKKwogICAgICAgICBOYW1lIGFubm90YXRpb25UeXBlTmFtZSA9IGFzdC5uZXdOYW1lKGFubm90YXRpb25OYW1lKTsKLSAgICAgICAgCisKICAgICAgICAgYW5ub3RhdGlvbi5zZXRUeXBlTmFtZShhbm5vdGF0aW9uVHlwZU5hbWUpOwogCiAgICAgICAgIGlmIChtZW1iZXJWYWx1ZVBhaXJzICE9IG51bGwpIHsKQEAgLTY0LDMzICs3MSw1NSBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+U2luZ2xlTWVtYmVyQW5ub3RhdGlvbjwvY29kZT4uCisgICAgICoKKyAgICAgKiBAcGFyYW0gYXN0IHRoZSA8Y29kZT5BU1Q8L2NvZGU+IHRoYXQgd2lsbCBiZSB1c2VkIHRvIGNyZWF0ZSB0aGUgYW5ub3RhdGlvbi4KKyAgICAgKiBAcGFyYW0gYW5ub3RhdGlvbk5hbWUgdGhlIG5hbWUgb2YgdGhlIGFubm90YXRpb24uCisgICAgICogQHBhcmFtIHZhbHVlIHRoZSA8Y29kZT5FeHByZXNzaW9uPC9jb2RlPiB0byBzZXQgYXMgdGhlIDxjb2RlPlNpbmdsZU1lbWJlckFubm90YXRpb248L2NvZGU+IHZhbHVlLgorICAgICAqIEByZXR1cm4gYSBzaW5nbGUgbWVtYmVyIGFubm90YXRpb24gd2l0aCB0aGUgZ2l2ZW4gdmFsdWUuCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBTaW5nbGVNZW1iZXJBbm5vdGF0aW9uIGNyZWF0ZVNpbmdsZU1lbWJlckFubm90YXRpb24oQVNUIGFzdCwgU3RyaW5nIGFubm90YXRpb25OYW1lLCBFeHByZXNzaW9uIHZhbHVlKSB7CiAgICAgICAgIFNpbmdsZU1lbWJlckFubm90YXRpb24gYW5ub3RhdGlvbiA9IGFzdC5uZXdTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKCk7Ci0gICAgICAgIAorCiAgICAgICAgIE5hbWUgYW5ub3RhdGlvblR5cGVOYW1lID0gYXN0Lm5ld05hbWUoYW5ub3RhdGlvbk5hbWUpOwotICAgICAgICAKKwogICAgICAgICBhbm5vdGF0aW9uLnNldFR5cGVOYW1lKGFubm90YXRpb25UeXBlTmFtZSk7CiAKICAgICAgICAgaWYgKHZhbHVlICE9IG51bGwpIHsKICAgICAgICAgCXZhbHVlID0gKEV4cHJlc3Npb24pRXhwcmVzc2lvbi5jb3B5U3VidHJlZShhc3QsIHZhbHVlKTsKICAgICAgICAgCWFubm90YXRpb24uc2V0VmFsdWUodmFsdWUpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uOwogICAgIH0KIAorICAgIC8qKgorICAgICAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TWFya2VyQW5ub3RhdGlvbjwvY29kZT4uCisgICAgICoKKyAgICAgKiBAcGFyYW0gYXN0IHRoZSA8Y29kZT5BU1Q8L2NvZGU+IHRoYXQgd2lsbCBiZSB1c2VkIHRvIGNyZWF0ZSB0aGUgYW5ub3RhdGlvbi4KKyAgICAgKiBAcGFyYW0gYW5ub3RhdGlvbk5hbWUgdGhlIG5hbWUgb2YgdGhlIGFubm90YXRpb24uCisgICAgICogQHJldHVybiBhIG1hcmtlciBhbm5vdGF0aW9uLgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgTWFya2VyQW5ub3RhdGlvbiBjcmVhdGVNYXJrZXJBbm5vdGF0aW9uKEFTVCBhc3QsIFN0cmluZyBhbm5vdGF0aW9uTmFtZSkgewogICAgICAgICBNYXJrZXJBbm5vdGF0aW9uIGFubm90YXRpb24gPSBhc3QubmV3TWFya2VyQW5ub3RhdGlvbigpOwotICAgICAgICAKKwogICAgICAgICBOYW1lIGFubm90YXRpb25UeXBlTmFtZSA9IGFzdC5uZXdOYW1lKGFubm90YXRpb25OYW1lKTsKLSAgICAgICAgCisKICAgICAgICAgYW5ub3RhdGlvbi5zZXRUeXBlTmFtZShhbm5vdGF0aW9uVHlwZU5hbWUpOwogCiAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uOwogICAgIH0KIAotCisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+LgorICAgICAqCisgICAgICogQHBhcmFtIGFzdCB0aGUgPGNvZGU+QVNUPC9jb2RlPiB0aGF0IHdpbGwgYmUgdXNlZCB0byBjcmVhdGUgdGhlIDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4uCisgICAgICogQHBhcmFtIG5hbWUgdGhlIG5hbWUgb2YgdGhlIDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4uCisgICAgICogQHBhcmFtIGV4cHJlc3Npb24gdGhlIDxjb2RlPkV4cHJlc3Npb248L2NvZGU+IHRvIHNldCBhcyB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPiB2YWx1ZS4KKyAgICAgKiBAcmV0dXJuIGEgbmV3IDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4gd2l0aCB0aGUgZ2l2ZW4gbmFtZSBhbmQgdmFsdWUuCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBNZW1iZXJWYWx1ZVBhaXIgY3JlYXRlTWVtYmVyVmFsdWVQYWlyKEFTVCBhc3QsIFN0cmluZyBuYW1lLCBFeHByZXNzaW9uIGV4cHJlc3Npb24pIHsKICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIG1lbWJlclZhbHVlUGFpciA9IGFzdC5uZXdNZW1iZXJWYWx1ZVBhaXIoKTsKICAgICAgICAgbWVtYmVyVmFsdWVQYWlyLnNldE5hbWUoYXN0Lm5ld1NpbXBsZU5hbWUobmFtZSkpOwpAQCAtOTgsNDEgKzEyNyw5NiBAQAogICAgICAgICByZXR1cm4gbWVtYmVyVmFsdWVQYWlyOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgTWVtYmVyVmFsdWVQYWlyIGNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihBU1QgYXN0LCBTdHJpbmcgbmFtZSwgT2JqZWN0IHZhbHVlKSB7CisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggYSA8Y29kZT5TdHJpbmdMaXRlcmFsPC9jb2RlPiB2YWx1ZS4KKyAgICAgKgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+LgorICAgICAqIEBwYXJhbSBuYW1lIHRoZSBuYW1lIG9mIHRoZSA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+LgorICAgICAqIEBwYXJhbSB2YWx1ZSB0aGUgPGNvZGU+U3RyaW5nPC9jb2RlPiB2YWx1ZS4KKyAgICAgKiBAcmV0dXJuIGEgbmV3IDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4gd2l0aCB0aGUgZ2l2ZW4gbmFtZSBhbmQgdmFsdWUuCisgICAgICovCisgICAgcHVibGljIHN0YXRpYyBNZW1iZXJWYWx1ZVBhaXIgY3JlYXRlU3RyaW5nTWVtYmVyVmFsdWVQYWlyKEFTVCBhc3QsIFN0cmluZyBuYW1lLCBTdHJpbmcgdmFsdWUpIHsKICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIHN0cmluZ01lbWJlclZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVNZW1iZXJWYWx1ZVBhaXIoYXN0LCBuYW1lLAogICAgICAgICAgICAgICAgIEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdMaXRlcmFsKGFzdCwgdmFsdWUudG9TdHJpbmcoKSkpOwogCiAgICAgICAgIHJldHVybiBzdHJpbmdNZW1iZXJWYWx1ZVBhaXI7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBNZW1iZXJWYWx1ZVBhaXIgY3JlYXRlQm9vbGVhbk1lbWJlclZhbHVlUGFpcihBU1QgYXN0LCBTdHJpbmcgbmFtZSwgT2JqZWN0IHZhbHVlKSB7CisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggYSA8Y29kZT5Cb29sZWFuTGl0ZXJhbDwvY29kZT4gdmFsdWUuCisgICAgICoKKyAgICAgKiBAcGFyYW0gYXN0IHRoZSA8Y29kZT5BU1Q8L2NvZGU+IHRoYXQgd2lsbCBiZSB1c2VkIHRvIGNyZWF0ZSB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gbmFtZSB0aGUgbmFtZSBvZiB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gdmFsdWUgdGhlIDxjb2RlPkJvb2xlYW48L2NvZGU+IHZhbHVlLgorICAgICAqIEByZXR1cm4gYSBuZXcgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPiB3aXRoIHRoZSBnaXZlbiBuYW1lIGFuZCB2YWx1ZS4KKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIE1lbWJlclZhbHVlUGFpciBjcmVhdGVCb29sZWFuTWVtYmVyVmFsdWVQYWlyKEFTVCBhc3QsIFN0cmluZyBuYW1lLCBCb29sZWFuIHZhbHVlKSB7CiAgICAgICAgIE1lbWJlclZhbHVlUGFpciBib29sZWFuVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU1lbWJlclZhbHVlUGFpcihhc3QsIG5hbWUsIEFubm90YXRpb25zQ29yZQotICAgICAgICAgICAgICAgIC5jcmVhdGVCb29sZWFuTGl0ZXJhbChhc3QsICgoQm9vbGVhbil2YWx1ZSkuYm9vbGVhblZhbHVlKCkpKTsKKyAgICAgICAgICAgICAgICAuY3JlYXRlQm9vbGVhbkxpdGVyYWwoYXN0LCB2YWx1ZS5ib29sZWFuVmFsdWUoKSkpOwogCiAgICAgICAgIHJldHVybiBib29sZWFuVmFsdWVQYWlyOwogICAgIH0KLSAgICAKLSAgICBwdWJsaWMgc3RhdGljIE1lbWJlclZhbHVlUGFpciBjcmVhdGVOdW1iZXJNZW1iZXJWYWx1ZVBhaXIoQVNUIGFzdCwgU3RyaW5nIG5hbWUsIE9iamVjdCB2YWx1ZSkgewotICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgcHJpbWl0aXZlVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU1lbWJlclZhbHVlUGFpcihhc3QsIG5hbWUsIAorCisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggYSA8Y29kZT5OdW1iZXJMaXRlcmFsPC9jb2RlPiB2YWx1ZS4KKyAgICAgKgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+LgorICAgICAqIEBwYXJhbSBuYW1lIHRoZSBuYW1lIG9mIHRoZSA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+LgorICAgICAqIEBwYXJhbSB2YWx1ZSB0aGUgPGNvZGU+U3RyaW5nPC9jb2RlPiB2YWx1ZSByZXByZXNlbnRpbmcgdGhlIG51bWJlci4KKyAgICAgKiBAcmV0dXJuIGEgbmV3IDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4gd2l0aCB0aGUgZ2l2ZW4gbmFtZSBhbmQgdmFsdWUuCisgICAgICovCisgICAgcHVibGljIHN0YXRpYyBNZW1iZXJWYWx1ZVBhaXIgY3JlYXRlTnVtYmVyTWVtYmVyVmFsdWVQYWlyKEFTVCBhc3QsIFN0cmluZyBuYW1lLCBTdHJpbmcgdmFsdWUpIHsKKyAgICAgICAgTWVtYmVyVmFsdWVQYWlyIHByaW1pdGl2ZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVNZW1iZXJWYWx1ZVBhaXIoYXN0LCBuYW1lLAogICAgICAgICAgICAgICAgIEFubm90YXRpb25zQ29yZS5jcmVhdGVOdW1iZXJMaXRlcmFsKGFzdCwgdmFsdWUudG9TdHJpbmcoKSkpOwogICAgICAgICByZXR1cm4gcHJpbWl0aXZlVmFsdWVQYWlyOwogICAgIH0KLSAgICAKLSAgICBwdWJsaWMgc3RhdGljIE1lbWJlclZhbHVlUGFpciBjcmVhdGVFbnVtTWVtYmVyVmFsdWVQYWlyKEFTVCBhc3QsIFN0cmluZyBjbGFzc05hbWUsIFN0cmluZyBuYW1lLCAKKworICAgIC8qKgorICAgICAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPiB3aXRoIGEgPGNvZGU+TmFtZTwvY29kZT4gdmFsdWUuCisgICAgICoKKyAgICAgKiBAcGFyYW0gYXN0IHRoZSA8Y29kZT5BU1Q8L2NvZGU+IHRoYXQgd2lsbCBiZSB1c2VkIHRvIGNyZWF0ZSB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gbmFtZSB0aGUgbmFtZSBvZiB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gdmFsdWUgdGhlIGVudW0gdmFsdWUuCisgICAgICogQHJldHVybiBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggdGhlIGdpdmVuIG5hbWUgYW5kIHZhbHVlLgorICAgICAqLworICAgIHB1YmxpYyBzdGF0aWMgTWVtYmVyVmFsdWVQYWlyIGNyZWF0ZUVudW1NZW1iZXJWYWx1ZVBhaXIoQVNUIGFzdCwgU3RyaW5nIGNsYXNzTmFtZSwgU3RyaW5nIG5hbWUsCiAgICAgICAgICAgICBPYmplY3QgdmFsdWUpIHsKLSAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTWVtYmVyVmFsdWVQYWlyKGFzdCwgbmFtZSwgY3JlYXRlRW51bUxpdGVyYWwoYXN0LCBjbGFzc05hbWUsIHZhbHVlKSk7ICAgICAgICAKKyAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTWVtYmVyVmFsdWVQYWlyKGFzdCwgbmFtZSwgY3JlYXRlRW51bUxpdGVyYWwoYXN0LCBjbGFzc05hbWUsIHZhbHVlKSk7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggYSA8Y29kZT5UeXBlTGl0ZXJhbDwvY29kZT4gdmFsdWUuCisgICAgICoKKyAgICAgKiBAcGFyYW0gYXN0IHRoZSA8Y29kZT5BU1Q8L2NvZGU+IHRoYXQgd2lsbCBiZSB1c2VkIHRvIGNyZWF0ZSB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gbmFtZSB0aGUgbmFtZSBvZiB0aGUgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gdmFsdWUgdGhlIHR5cGUgdmFsdWUuCisgICAgICogQHJldHVybiBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggdGhlIGdpdmVuIG5hbWUgYW5kIHZhbHVlLgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgTWVtYmVyVmFsdWVQYWlyIGNyZWF0ZVR5cGVNZW1iZXJWYWx1ZVBhaXIoQVNUIGFzdCwgU3RyaW5nIG5hbWUsIE9iamVjdCB2YWx1ZSkgewogICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU1lbWJlclZhbHVlUGFpcihhc3QsIG5hbWUsCiAgICAgICAgICAgICAgICAgY3JlYXRlVHlwZUxpdGVyYWwoYXN0LCB2YWx1ZSkpOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TWVtYmVyVmFsdWVQYWlyPC9jb2RlPiB3aXRoIGFuIDxjb2RlPkFycmF5SW5pdGlhbGl6ZXI8L2NvZGU+IHZhbHVlLgorICAgICAqCisgICAgICogQHBhcmFtIGFzdCB0aGUgPGNvZGU+QVNUPC9jb2RlPiB0aGF0IHdpbGwgYmUgdXNlZCB0byBjcmVhdGUgdGhlIDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4uCisgICAgICogQHBhcmFtIG1ldGhvZAorICAgICAqIEBwYXJhbSB2YWx1ZXMgYW4gYXJyYXkgb2YgPGNvZGU+T2JqZWN0PC9jb2RlPiB2YWx1ZXMuCisgICAgICogQHJldHVybiBhIG5ldyA8Y29kZT5NZW1iZXJWYWx1ZVBhaXI8L2NvZGU+IHdpdGggdGhlIGdpdmVuIG5hbWUgYW5kIGFycmF5IG9mIHZhbHVlcy4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIE1lbWJlclZhbHVlUGFpciBjcmVhdGVBcnJheU1lbWJlclZhbHVlUGFpcihBU1QgYXN0LCBNZXRob2QgbWV0aG9kLCBPYmplY3RbXSB2YWx1ZXMpIHsKLSAgICAgICAgcmV0dXJuIEFubm90YXRpb25zQ29yZS5jcmVhdGVNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZXRob2QuZ2V0TmFtZSgpLCBjcmVhdGVBcnJheVZhbHVlTGl0ZXJhbChhc3QsIAorICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU1lbWJlclZhbHVlUGFpcihhc3QsIG1ldGhvZC5nZXROYW1lKCksIGNyZWF0ZUFycmF5VmFsdWVMaXRlcmFsKGFzdCwKICAgICAgICAgICAgICAgICBtZXRob2QsIHZhbHVlcykpOwotICAgICB9Ci0gICAgCisgICAgfQorCisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5BcnJheUluaXRpYWxpemVyPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gYXN0IHRoZSA8Y29kZT5BU1Q8L2NvZGU+IHRoYXQgd2lsbCBiZSB1c2VkIHRvIGNyZWF0ZSB0aGUgPGNvZGU+QXJyYXlJbml0aWFsaXplcjwvY29kZT4uCisgICAgICogQHBhcmFtIG1ldGhvZAorICAgICAqIEBwYXJhbSB2YWx1ZXMgYW4gYXJyYXkgb2YgPGNvZGU+T2JqZWN0PC9jb2RlPiB2YWx1ZXMuCisgICAgICogQHJldHVybiBhIG5ldyA8Y29kZT5BcnJheUluaXRpYWxpemVyPC9jb2RlPi4KKyAgICAgKi8KICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKICAgICBwdWJsaWMgc3RhdGljIEFycmF5SW5pdGlhbGl6ZXIgY3JlYXRlQXJyYXlWYWx1ZUxpdGVyYWwoQVNUIGFzdCwgTWV0aG9kIG1ldGhvZCwgT2JqZWN0W10gdmFsdWVzKSB7CiAgICAgICAgIEFycmF5SW5pdGlhbGl6ZXIgYXJyYXlJbml0aWFsaXplciA9IGFzdC5uZXdBcnJheUluaXRpYWxpemVyKCk7CkBAIC0xNDEsNyArMjI1LDcgQEAKICAgICAgICAgICAgICAgICAvL1RPRE8gSGFuZGxlIHRoaXMgc2l0dWF0aW9uLiBBcmlzZXMgd2hlbiBhbm5vdGF0aW9ucyBhcmUgc3BlY2lmaWVkIGFzIGRlZmF1bHRzIGluIGFycmF5IGluaXRpYWxpemVycwogICAgICAgICAgICAgfQogICAgICAgICAgICAgaWYgKHZhbHVlIGluc3RhbmNlb2YgTGlzdCkgewotICAgICAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MgPSAKKyAgICAgICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbkNsYXNzID0KICAgICAgICAgICAgICAgICAgKENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPikgbWV0aG9kLmdldFJldHVyblR5cGUoKS5nZXRDb21wb25lbnRUeXBlKCk7CiAKICAgICAgICAgICAgICAgICBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycyA9IG5ldyBBcnJheUxpc3Q8TWVtYmVyVmFsdWVQYWlyPigpOwpAQCAtMTQ5LDcgKzIzMyw3IEBACiAgICAgICAgICAgICAgICAgTGlzdDxNYXA8U3RyaW5nLCBPYmplY3Q+PiB2YWx1ZXNMaXN0ID0gKExpc3Q8TWFwPFN0cmluZywgT2JqZWN0Pj4pIHZhbHVlOwogICAgICAgICAgICAgICAgIEl0ZXJhdG9yPE1hcDxTdHJpbmcsIE9iamVjdD4+IHZhbHVlc0l0ZXJhdG9yID0gdmFsdWVzTGlzdC5pdGVyYXRvcigpOwogICAgICAgICAgICAgICAgIHdoaWxlICh2YWx1ZXNJdGVyYXRvci5oYXNOZXh0KCkpIHsKLSAgICAgICAgICAgICAgICAgICAgTWFwPFN0cmluZywgT2JqZWN0PiBhbm5vdGF0aW9uTWFwID0gKE1hcDxTdHJpbmcsIE9iamVjdD4pIHZhbHVlc0l0ZXJhdG9yLm5leHQoKTsKKyAgICAgICAgICAgICAgICAgICAgTWFwPFN0cmluZywgT2JqZWN0PiBhbm5vdGF0aW9uTWFwID0gdmFsdWVzSXRlcmF0b3IubmV4dCgpOwogICAgICAgICAgICAgICAgICAgICBTZXQ8RW50cnk8U3RyaW5nLCBPYmplY3Q+PiBlbnRyeVNldCA9IGFubm90YXRpb25NYXAuZW50cnlTZXQoKTsKICAgICAgICAgICAgICAgICAgICAgSXRlcmF0b3I8TWFwLkVudHJ5PFN0cmluZywgT2JqZWN0Pj4gaXRlcmF0b3IgPSBlbnRyeVNldC5pdGVyYXRvcigpOwogICAgICAgICAgICAgICAgICAgICB3aGlsZSAoaXRlcmF0b3IuaGFzTmV4dCgpKSB7CkBAIC0xNjIsMTEgKzI0NiwxMSBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDbGFzczw/PiByZXR1cm5UeXBlID0gYW5ub3RhdGlvbk1ldGhvZC5nZXRSZXR1cm5UeXBlKCk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChyZXR1cm5UeXBlLmVxdWFscyhTdHJpbmcuY2xhc3MpKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChjcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZW1iZXJOYW1lLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZSkpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZS50b1N0cmluZygpKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuZXF1YWxzKEJvb2xlYW4uVFlQRSkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKGNyZWF0ZUJvb2xlYW5NZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZW1iZXJOYW1lLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZSkpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoQm9vbGVhbikgbWVtYmVyVmFsdWUpKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAocmV0dXJuVHlwZS5lcXVhbHMoQ2xhc3MuY2xhc3MpKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgY2xhc3NOYW1lID0gbWVtYmVyVmFsdWUudG9TdHJpbmcoKTsKQEAgLTE3NCwxMyArMjU4LDEzIEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY2xhc3NOYW1lID0gY2xhc3NOYW1lLnN1YnN0cmluZygwLCBjbGFzc05hbWUubGFzdEluZGV4T2YoIi4iKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTWVtYmVyVmFsdWVQYWlyKGFzdCwgbWVtYmVyTmFtZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY3JlYXRlVHlwZUxpdGVyYWwoYXN0LCBjbGFzc05hbWUpKSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNyZWF0ZVR5cGVMaXRlcmFsKGFzdCwgY2xhc3NOYW1lKSkpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CiAvLyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuaXNQcmltaXRpdmUoKSkgewogLy8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChnZXROdW1iZXJNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZW1iZXJOYW1lLCBtZW1iZXJWYWx1ZSkpOwogLy8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgCisKICAgICAgICAgICAgICAgICAgICAgICAgIH0gY2F0Y2ggKFNlY3VyaXR5RXhjZXB0aW9uIHNlKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQW5ub3RhdGlvbnNDb3JlUGx1Z2luLmxvZyhzZSk7CiAgICAgICAgICAgICAgICAgICAgICAgICB9IGNhdGNoIChOb1N1Y2hNZXRob2RFeGNlcHRpb24gbnNtZSkgewpAQCAtMjA2LDcgKzI5MCwxNSBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBhcnJheUluaXRpYWxpemVyOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+TmFtZTwvY29kZT4gdG8gcmVwcmVzZW50IGFuIGVudW0gbGl0ZXJhbCB2YWx1ZS4KKyAgICAgKgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5OYW1lPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gY2xhc3NOYW1lIHRoZSBmdWxseSBxdWFsaWZpZWQgbmFtZSBvZiB0aGUgRU5VTSBjbGFzcy4KKyAgICAgKiBAcGFyYW0gdmFsdWUgdGhlIEVOVU0gdmFsdWUuCisgICAgICogQHJldHVybiBhIG5ldyA8Y29kZT5OYW1lPC9jb2RlPi4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIE5hbWUgY3JlYXRlRW51bUxpdGVyYWwoQVNUIGFzdCwgU3RyaW5nIGNsYXNzTmFtZSwgT2JqZWN0IHZhbHVlKSB7CiAgICAgICAgIFF1YWxpZmllZE5hbWUgZW51bU5hbWUgPSBudWxsOwogICAgICAgICBTaW1wbGVOYW1lIGVudW1DbGFzc05hbWUgPSBhc3QubmV3U2ltcGxlTmFtZSh2YWx1ZS5nZXRDbGFzcygpLmdldFNpbXBsZU5hbWUoKSk7CkBAIC0yMjksNiArMzIxLDEzIEBACiAgICAgICAgIHJldHVybiBlbnVtTmFtZTsKICAgICB9CiAKKyAgICAvKioKKyAgICAgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlR5cGVMaXRlcmFsPC9jb2RlPi4KKyAgICAgKgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5UeXBlTGl0ZXJhbDwvY29kZT4uCisgICAgICogQHBhcmFtIHZhbHVlIGEgPGNvZGU+Q2xhc3M8L2NvZGU+IG9yIGEgPGNvZGU+U3RyaW5nPC9jb2RlPiBmcm9tIHdoaWNoIHRvIGNyZWF0ZSB0aGUgPGNvZGU+VHlwZUxpdGVyYWw8L2NvZGU+LgorICAgICAqIEByZXR1cm4gYSBuZXcgPGNvZGU+VHlwZUxpdGVyYWw8L2NvZGU+IG9yIG51bGwgaXQgdGhlIHZhbHVlIGlzIG5vdCBvZiB0eXBlIDxjb2RlPkNsYXNzPC9jb2RlPiBvciA8Y29kZT5TdHJpbmc8L2NvZGU+LgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgVHlwZUxpdGVyYWwgY3JlYXRlVHlwZUxpdGVyYWwoQVNUIGFzdCwgT2JqZWN0IHZhbHVlKSB7CiAgICAgICAgIFR5cGVMaXRlcmFsIHR5cGVMaXRlcmFsID0gbnVsbDsKICAgICAgICAgaWYgKHZhbHVlIGluc3RhbmNlb2YgQ2xhc3MpIHsKQEAgLTI0MCwxMCArMzM5LDE3IEBACiAgICAgICAgIHJldHVybiB0eXBlTGl0ZXJhbDsKICAgICB9CiAKKyAgICAvKioKKyAgICAgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlR5cGVMaXRlcmFsPC9jb2RlPgorICAgICAqCisgICAgICogQHBhcmFtIGFzdCB0aGUgPGNvZGU+QVNUPC9jb2RlPiB0aGF0IHdpbGwgYmUgdXNlZCB0byBjcmVhdGUgdGhlIDxjb2RlPlR5cGVMaXRlcmFsPC9jb2RlPgorICAgICAqIEBwYXJhbSB2YWx1ZSB0aGUgY2xhc3MgdmFsdWUKKyAgICAgKiBAcmV0dXJuIGEgbmV3IDxjb2RlPlR5cGVMaXRlcmFsPC9jb2RlPgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgVHlwZUxpdGVyYWwgY3JlYXRlVHlwZUxpdGVyYWwoQVNUIGFzdCwgQ2xhc3M8Pz4gdmFsdWUpIHsKICAgICAgICAgVHlwZUxpdGVyYWwgdHlwZUxpdGVyYWwgPSBhc3QubmV3VHlwZUxpdGVyYWwoKTsKIAotICAgICAgICBDbGFzczw/PiBhQ2xhc3MgPSAoQ2xhc3M8Pz4pdmFsdWU7CisgICAgICAgIENsYXNzPD8+IGFDbGFzcyA9IHZhbHVlOwogICAgICAgICBTaW1wbGVOYW1lIGNsYXNzTmFtZSA9IGFzdC5uZXdTaW1wbGVOYW1lKGFDbGFzcy5nZXRTaW1wbGVOYW1lKCkpOwogCiAgICAgICAgIGlmIChhQ2xhc3MuaXNNZW1iZXJDbGFzcygpKSB7CkBAIC0yNTUsNiArMzYxLDEzIEBACiAgICAgICAgIHJldHVybiBjcmVhdGVUeXBlTGl0ZXJhbChhc3QsIHZhbHVlLmdldENhbm9uaWNhbE5hbWUoKSk7CiAgICAgfQogCisgICAgLyoqCisgICAgICogQ3JlYXRlcyBhIG5ldyA8Y29kZT5UeXBlTGl0ZXJhbDwvY29kZT4KKyAgICAgKgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5UeXBlTGl0ZXJhbDwvY29kZT4KKyAgICAgKiBAcGFyYW0gdmFsdWUgdGhlIG5hbWUgb2YgY2xhc3MKKyAgICAgKiBAcmV0dXJuIGEgbmV3IDxjb2RlPlR5cGVMaXRlcmFsPC9jb2RlPgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgVHlwZUxpdGVyYWwgY3JlYXRlVHlwZUxpdGVyYWwoQVNUIGFzdCwgU3RyaW5nIHZhbHVlKSB7CiAgICAgICAgIFR5cGVMaXRlcmFsIHR5cGVMaXRlcmFsID0gYXN0Lm5ld1R5cGVMaXRlcmFsKCk7CiAKQEAgLTI3MywxNyArMzg2LDM2IEBACiAgICAgICAgIHJldHVybiB0eXBlTGl0ZXJhbDsKICAgICB9CiAKKyAgICAvKioKKyAgICAgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPlN0cmluZ0xpdGVyYWw8L2NvZGU+LgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5TdHJpbmdMaXRlcmFsPC9jb2RlPi4KKyAgICAgKiBAcGFyYW0gbGl0ZXJhbFZhbHVlIHRoZSBzdHJpbmcgdmFsdWUuCisgICAgICogQHJldHVybiBhIG5ldyA8Y29kZT5TdHJpbmdMaXRlcmFsPC9jb2RlPi4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIFN0cmluZ0xpdGVyYWwgY3JlYXRlU3RyaW5nTGl0ZXJhbChBU1QgYXN0LCBTdHJpbmcgbGl0ZXJhbFZhbHVlKSB7CiAgICAgICAgIFN0cmluZ0xpdGVyYWwgc3RyaW5nTGl0ZXJhbCA9IGFzdC5uZXdTdHJpbmdMaXRlcmFsKCk7CiAgICAgICAgIHN0cmluZ0xpdGVyYWwuc2V0TGl0ZXJhbFZhbHVlKGxpdGVyYWxWYWx1ZSk7CiAgICAgICAgIHJldHVybiBzdHJpbmdMaXRlcmFsOwogICAgIH0KIAorICAgIC8qKgorICAgICAqIENyZWF0ZXMgYSBuZXcgPGNvZGU+Qm9vbGVhbkxpdGVyYWw8L2NvZGU+LgorICAgICAqIEBwYXJhbSBhc3QgdGhlIDxjb2RlPkFTVDwvY29kZT4gdGhhdCB3aWxsIGJlIHVzZWQgdG8gY3JlYXRlIHRoZSA8Y29kZT5Cb29sZWFuTGl0ZXJhbDwvY29kZT4uCisgICAgICogQHBhcmFtIHZhbHVlIHRoZSBib29sZWFuIHZhbHVlLgorICAgICAqIEByZXR1cm4gYSBuZXcgPGNvZGU+Qm9vbGVhbkxpdGVyYWw8L2NvZGU+LgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgQm9vbGVhbkxpdGVyYWwgY3JlYXRlQm9vbGVhbkxpdGVyYWwoQVNUIGFzdCwgYm9vbGVhbiB2YWx1ZSkgewogICAgICAgICBCb29sZWFuTGl0ZXJhbCBib29sZWFuTGl0ZXJhbCA9IGFzdC5uZXdCb29sZWFuTGl0ZXJhbCh2YWx1ZSk7CiAgICAgICAgIHJldHVybiBib29sZWFuTGl0ZXJhbDsKICAgICB9Ci0gICAgCisKKyAgICAvKioKKyAgICAgKiBDcmVhdGVzIGEgbmV3IDxjb2RlPk51bWJlckxpdGVyYWw8L2NvZGU+LgorICAgICAqCisgICAgICogQHBhcmFtIGFzdCB0aGUgPGNvZGU+QVNUPC9jb2RlPiB0aGF0IHdpbGwgYmUgdXNlZCB0byBjcmVhdGUgdGhlIDxjb2RlPk51bWJlckxpdGVyYWw8L2NvZGU+LgorICAgICAqIEBwYXJhbSB2YWx1ZSB0aGUgbnVtYmVyIHZhbHVlLgorICAgICAqIEByZXR1cm4gYSBuZXcgPGNvZGU+TnVtYmVyTGl0ZXJhbDwvY29kZT4uCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBOdW1iZXJMaXRlcmFsIGNyZWF0ZU51bWJlckxpdGVyYWwoQVNUIGFzdCwgU3RyaW5nIHZhbHVlKSB7CiAgICAgICAgIE51bWJlckxpdGVyYWwgcHJpbWl0aXZlTGl0ZXJhbCA9IGFzdC5uZXdOdW1iZXJMaXRlcmFsKCk7CiAgICAgICAgIHByaW1pdGl2ZUxpdGVyYWwuc2V0VG9rZW4odmFsdWUpOwpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2Fubm90YXRpb25zL2NvcmUvQW5ub3RhdGlvbnNNYW5hZ2VyLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9Bbm5vdGF0aW9uc01hbmFnZXIuamF2YQppbmRleCA0NmYxMTJlLi5lMGNhNWZjIDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9Bbm5vdGF0aW9uc01hbmFnZXIuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9Bbm5vdGF0aW9uc01hbmFnZXIuamF2YQpAQCAtMzcsMjAgKzM3LDI0IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuaW5pdGlhbGl6YXRpb24uSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcjsKIAogLyoqCi0gKiAKKyAqIE1hbmFnZXMgdGhlIGFubm90YXRpb24gY2F0ZWdvcmllcywgZGVmaW5pdGlvbnMsIHByb2Nlc3NvcnMgYW5kIGluaXRpYWxpemVycyBjb250cmlidXRlZCB0aHJvdWdoIHRoZQorICogPGNvZGU+b3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuYW5ub3RhdGlvbkRlZmluaXRpb248L2NvZGU+LAorICogPGNvZGU+b3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuYW5ub3RhdGlvbkNhdGVnb3J5PC9jb2RlPiwKKyAqIDxjb2RlPm9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLmFubm90YXRpb25Jbml0aWFsaXplcjwvY29kZT4gYW5kCisgKiA8Y29kZT5vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5hbm5vdGF0aW9uUHJvY2Vzc29yPC9jb2RlPiBleHRlbnNpb24gcG9pbnRzLgogICogPHA+Ci0gKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyIAotICogZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZyBzdGFiaWxpdHkuIEl0IGlzIGJlaW5nIG1hZGUgYXZhaWxhYmxlIGF0IAotICogdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20gcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyAKKyAqIDxzdHJvbmc+UHJvdmlzaW9uYWwgQVBJOjwvc3Ryb25nPiBUaGlzIGNsYXNzL2ludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwgdW5kZXIKKyAqIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcgc3RhYmlsaXR5LiBJdCBpcyBiZWluZyBtYWRlIGF2YWlsYWJsZSBhdAorICogdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20gcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcwogICogdGhpcyBBUEkgd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgogICogPC9wPgogICovCiBwdWJsaWMgZmluYWwgY2xhc3MgQW5ub3RhdGlvbnNNYW5hZ2VyIHsKLSAgICBwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBBTk5PVEFUSU9OX0RFRklOSVRJT04gPSAiYW5ub3RhdGlvbkRlZmluaXRpb24iOyAvLyROT04tTkxTLTEkCi0gICAgcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQU5OT1RBVElPTl9DQVRFR09SWSA9ICJhbm5vdGF0aW9uQ2F0ZWdvcnkiOyAvLyROT04tTkxTLTEkCi0gICAgcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQU5OT1RBVElPTl9JTklUSUFMSVpFUiA9ICJhbm5vdGF0aW9uSW5pdGlhbGl6ZXIiOyAvLyROT04tTkxTLTEkCi0gICAgcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQU5OT1RBVElPTl9QUk9DRVNTT1IgPSAiYW5ub3RhdGlvblByb2Nlc3NvciI7IC8vJE5PTi1OTFMtMSQKLSAgICBwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBBTk5PVEFUSU9OID0gImFubm90YXRpb24iOyAvLyROT04tTkxTLTEkCisgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFOTk9UQVRJT05fREVGSU5JVElPTiA9ICJhbm5vdGF0aW9uRGVmaW5pdGlvbiI7IC8vJE5PTi1OTFMtMSQKKyAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQU5OT1RBVElPTl9DQVRFR09SWSA9ICJhbm5vdGF0aW9uQ2F0ZWdvcnkiOyAvLyROT04tTkxTLTEkCisgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFOTk9UQVRJT05fSU5JVElBTElaRVIgPSAiYW5ub3RhdGlvbkluaXRpYWxpemVyIjsgLy8kTk9OLU5MUy0xJAorICAgIHByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBBTk5PVEFUSU9OX1BST0NFU1NPUiA9ICJhbm5vdGF0aW9uUHJvY2Vzc29yIjsgLy8kTk9OLU5MUy0xJAorICAgIHByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBBTk5PVEFUSU9OID0gImFubm90YXRpb24iOyAvLyROT04tTkxTLTEkCiAKICAgICBwcml2YXRlIHN0YXRpYyBMaXN0PEFubm90YXRpb25EZWZpbml0aW9uPiBhbm5vdGF0aW9uQ2FjaGUgPSBudWxsOwogICAgIHByaXZhdGUgc3RhdGljIE1hcDxTdHJpbmcsIFN0cmluZz4gYW5ub3RhdGlvbkNhdGVnb3J5Q2FjaGUgPSBudWxsOwpAQCAtNjQsMTcgKzY4LDIzIEBACiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFUVF9JRCA9ICJpZCI7IC8vJE5PTi1OTFMtMSQKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQVRUX05BTUUgPSAibmFtZSI7IC8vJE5PTi1OTFMtMSQKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgQVRUX0NBVEVHT1JZID0gImNhdGVnb3J5IjsgLy8kTk9OLU5MUy0xJAotICAgIAorCiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEVMRU1fVEFSR0VUX0ZJTFRFUiA9ICJ0YXJnZXRGaWx0ZXIiOyAvLyROT04tTkxTLTEkCiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEFUVF9UQVJHRVQgPSAidGFyZ2V0IjsgLy8kTk9OLU5MUy0xJAogCiAgICAgcHJpdmF0ZSBBbm5vdGF0aW9uc01hbmFnZXIoKSB7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyBhIGxpc3Qgb2YgPGNvZGU+QW5ub3RhdGlvbkRlZmluaXRpb248L2NvZGU+IGNvbnN0cnVjdGVkIGZyb20gY29udHJpYnV0aW9ucyB0byB0aGUKKyAgICAgKiA8Y29kZT5vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5hbm5vdGF0aW9uRGVmaW5pdGlvbjwvY29kZT4gZXh0ZW5zaW9uIHBvaW50LgorICAgICAqCisgICAgICogQHJldHVybiBhIGxpc3Qgb2YgPGNvZGU+QW5ub3RhdGlvbkRlZmluaXRpb248L2NvZGU+LgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgc3luY2hyb25pemVkIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+IGdldEFubm90YXRpb25zKCkgewogICAgICAgICBpZiAoYW5ub3RhdGlvbkNhY2hlID09IG51bGwpIHsKICAgICAgICAgICAgIGFubm90YXRpb25DYWNoZSA9IG5ldyBBcnJheUxpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+KCk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgSUV4dGVuc2lvblBvaW50IGV4dGVuc2lvblBvaW50ID0gUGxhdGZvcm0uZ2V0RXh0ZW5zaW9uUmVnaXN0cnkoKS5nZXRFeHRlbnNpb25Qb2ludCgKICAgICAgICAgICAgICAgICAgICAgQW5ub3RhdGlvbnNDb3JlUGx1Z2luLlBMVUdJTl9JRCwgQU5OT1RBVElPTl9ERUZJTklUSU9OKTsKICAgICAgICAgICAgIGlmIChleHRlbnNpb25Qb2ludCAhPSBudWxsKSB7CkBAIC04Miw3ICs5Miw3IEBACiAgICAgICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBlbGVtZW50cy5sZW5ndGg7IGkrKykgewogICAgICAgICAgICAgICAgICAgICBJQ29uZmlndXJhdGlvbkVsZW1lbnQgZWxlbWVudCA9IGVsZW1lbnRzW2ldOwogICAgICAgICAgICAgICAgICAgICBpZiAoZWxlbWVudC5nZXROYW1lKCkuZXF1YWxzKEFOTk9UQVRJT04pKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA9IG5ldyBBbm5vdGF0aW9uRGVmaW5pdGlvbihlbGVtZW50LCAKKyAgICAgICAgICAgICAgICAgICAgICAgIEFubm90YXRpb25EZWZpbml0aW9uIGFubm90YXRpb25EZWZpbml0aW9uID0gbmV3IEFubm90YXRpb25EZWZpbml0aW9uKGVsZW1lbnQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdldEFubm90YXRpb25DYXRlZ29yeShnZXRBdHRyaWJ1dGVWYWx1ZShlbGVtZW50LCBBVFRfQ0FURUdPUlkpKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uQ2FjaGUuYWRkKGFubm90YXRpb25EZWZpbml0aW9uKTsKICAgICAgICAgICAgICAgICAgICAgfQpAQCAtOTIsMjYgKzEwMiwzNyBAQAogICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkNhY2hlOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgT2JqZWN0W10gZ2V0QW5ub3RhdGlvbnMoT2JqZWN0IGVsZW1lbnQpIHsKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIGEgbGlzdCBvZiBhbGwgdGhlIGNvbnRyaWJ1dGVkIDxjb2RlPmphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb248L2NvZGU+IHRoYXQgdGFyZ2V0IHRoZSBnaXZlbiBqYXZhIGVsZW1lbnQgdHlwZS4KKyAgICAgKgorICAgICAqIEBwYXJhbSBlbGVtZW50IG9uZSBvZgorICAgICAqIDxsaT5vcmcuZWNsaXBzZS5qZHQuY29yZS5JUGFja2FnZURlY2xhcmF0aW9uPC9saT4KKyAgICAgKiA8bGk+b3JnLmVjbGlwc2UuamR0LmNvcmUuSVR5cGU8L2xpPgorICAgICAqIDxsaT5vcmcuZWNsaXBzZS5qZHQuY29yZS5JRmllbGQ8L2xpPgorICAgICAqIDxsaT5vcmcuZWNsaXBzZS5qZHQuY29yZS5JTWV0aG9kPC9saT4KKyAgICAgKiA8bGk+b3JnLmVjbGlwc2UuamR0LmNvcmUuSUxvY2FsVmFyaWFibGU8L2xpPgorICAgICAqCisgICAgICogQHJldHVybiBhIGxpc3Qgb2YgPGNvZGU+amF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbjwvY29kZT4KKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIExpc3Q8Q2xhc3M8PyBleHRlbmRzIEFubm90YXRpb24+PiBnZXRBbm5vdGF0aW9ucyhPYmplY3QgZWxlbWVudCkgewogICAgICAgICBMaXN0PENsYXNzPD8gZXh0ZW5kcyBBbm5vdGF0aW9uPj4gYW5ub3RhdGlvbnMgPSBuZXcgQXJyYXlMaXN0PENsYXNzPD8gZXh0ZW5kcyBBbm5vdGF0aW9uPj4oKTsKLSAgICAgICAgCisKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+IGFubm90YXRpb25EZWZpbml0aW9ucyA9IGdldEFsbEFubm90YXRpb25zRm9yRWxlbWVudChlbGVtZW50KTsKLSAgICAgICAgCisKICAgICAgICAgICAgIGZpbHRlckFubm90YXRpb25zTGlzdChlbGVtZW50LCBhbm5vdGF0aW9uRGVmaW5pdGlvbnMpOwotICAgICAgICAKKwogICAgICAgICAgICAgZm9yIChBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA6IGFubm90YXRpb25EZWZpbml0aW9ucykgewogICAgICAgICAgICAgICAgIGFubm90YXRpb25zLmFkZChhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXRBbm5vdGF0aW9uQ2xhc3MoKSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKICAgICAgICAgICAgIEFubm90YXRpb25zQ29yZVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKLSAgICAgICAgfSAgCi0gICAgICAgIHJldHVybiBhbm5vdGF0aW9ucy50b0FycmF5KCk7ICAgICAKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gYW5ub3RhdGlvbnM7CiAgICAgfQotICAgIAotICAgIHByaXZhdGUgc3RhdGljIHN5bmNocm9uaXplZCBNYXA8U3RyaW5nLCBBbm5vdGF0aW9uRGVmaW5pdGlvbj4gCi0gICAgICAgICAgICBnZXRBbm5vdGF0aW9uVG9DbGFzc05hbWVEZWZpbml0aW9uTWFwKCkgewotICAgICAgICAgICAgCisKKyAgICBwcml2YXRlIHN0YXRpYyBzeW5jaHJvbml6ZWQgTWFwPFN0cmluZywgQW5ub3RhdGlvbkRlZmluaXRpb24+IGdldEFubm90YXRpb25Ub0NsYXNzTmFtZURlZmluaXRpb25NYXAoKSB7CisKICAgICAgICAgaWYgKGFubm90YXRpb25DbGFzc05hbWVUb0RlZmluaXRpb25NYXAgPT0gbnVsbCkgewogICAgICAgICAgICAgTGlzdDxBbm5vdGF0aW9uRGVmaW5pdGlvbj4gYW5ub3RhdGlvbkRlZmluaXRpb25zID0gZ2V0QW5ub3RhdGlvbnMoKTsKIApAQCAtMTI0LDI2ICsxNDUsMjYgQEAKICAgICAgICAgfQogICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkNsYXNzTmFtZVRvRGVmaW5pdGlvbk1hcDsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIHN0YXRpYyBzeW5jaHJvbml6ZWQgTWFwPFN0cmluZywgQW5ub3RhdGlvbkRlZmluaXRpb24+IGdldFNpbXBsZU5hbWVUb0RlZmluaXRpb25NYXAoKSB7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uU2ltcGxlTmFtZVRvRGVmaW5pdGlvbk1hcCA9PSBudWxsKSB7CiAgICAgICAgICAgICBMaXN0PEFubm90YXRpb25EZWZpbml0aW9uPiBhbm5vdGF0aW9uRGVmaW5pdGlvbnMgPSBnZXRBbm5vdGF0aW9ucygpOwogCiAgICAgICAgICAgICBhbm5vdGF0aW9uU2ltcGxlTmFtZVRvRGVmaW5pdGlvbk1hcCA9IG5ldyBIYXNoTWFwPFN0cmluZywgQW5ub3RhdGlvbkRlZmluaXRpb24+KCk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgZm9yIChBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA6IGFubm90YXRpb25EZWZpbml0aW9ucykgewogICAgICAgICAgICAgICAgIGFubm90YXRpb25TaW1wbGVOYW1lVG9EZWZpbml0aW9uTWFwLnB1dChhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXROYW1lKCksIGFubm90YXRpb25EZWZpbml0aW9uKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gYW5ub3RhdGlvblNpbXBsZU5hbWVUb0RlZmluaXRpb25NYXA7CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSBzdGF0aWMgc3luY2hyb25pemVkIE1hcDxTdHJpbmcsIEFubm90YXRpb25EZWZpbml0aW9uPiBnZXRRdWFsaWZpZWROYW1lVG9EZWZpbml0aW9uTWFwKCkgewogICAgICAgICBpZiAoYW5ub3RhdGlvblF1YWxpZmllZE5hbWVUb0RlZmluaXRpb25NYXAgPT0gbnVsbCkgewogICAgICAgICAgICAgTGlzdDxBbm5vdGF0aW9uRGVmaW5pdGlvbj4gYW5ub3RhdGlvbkRlZmluaXRpb25zID0gZ2V0QW5ub3RhdGlvbnMoKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhbm5vdGF0aW9uUXVhbGlmaWVkTmFtZVRvRGVmaW5pdGlvbk1hcCA9IG5ldyBIYXNoTWFwPFN0cmluZywgQW5ub3RhdGlvbkRlZmluaXRpb24+KCk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgZm9yIChBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA6IGFubm90YXRpb25EZWZpbml0aW9ucykgewogICAgICAgICAgICAgICAgIGFubm90YXRpb25RdWFsaWZpZWROYW1lVG9EZWZpbml0aW9uTWFwLnB1dChhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXRBbm5vdGF0aW9uQ2xhc3NOYW1lKCksCiAgICAgICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uRGVmaW5pdGlvbik7CkBAIC0xNTEsNyArMTcyLDEyIEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGFubm90YXRpb25RdWFsaWZpZWROYW1lVG9EZWZpbml0aW9uTWFwOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqCisgICAgICogQHBhcmFtIGVsZW1lbnQKKyAgICAgKiBAcmV0dXJuIDxjb2RlPjwvY29kZT4KKyAgICAgKi8KICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKICAgICBwdWJsaWMgc3RhdGljIEFubm90YXRpb25EZWZpbml0aW9uIGdldEFubm90YXRpb25EZWZpbml0aW9uRm9yQ2xhc3MoT2JqZWN0IGVsZW1lbnQpIHsKICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBDbGFzcyAmJiAoKENsYXNzPD8+KWVsZW1lbnQpLmlzQW5ub3RhdGlvbigpKSB7CkBAIC0xNjAsMzUgKzE4Niw1OSBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqCisgICAgICogQHBhcmFtIG5hbWUKKyAgICAgKiBAcmV0dXJuIDxjb2RlPjwvY29kZT4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIElBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgZ2V0QW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyRm9yTmFtZShOYW1lIG5hbWUpIHsKICAgICAgICAgaWYgKG5hbWUgIT0gbnVsbCkgewogICAgICAgICAgICAgaWYgKG5hbWUuaXNTaW1wbGVOYW1lKCkgJiYgZ2V0U2ltcGxlTmFtZVRvRGVmaW5pdGlvbk1hcCgpLmNvbnRhaW5zS2V5KCgoU2ltcGxlTmFtZSkgbmFtZSkuZ2V0SWRlbnRpZmllcigpKSkgewotICAgICAgICAgICAgICAgIHJldHVybiBnZXRTaW1wbGVOYW1lVG9EZWZpbml0aW9uTWFwKCkuZ2V0KCgoU2ltcGxlTmFtZSkgbmFtZSkuZ2V0SWRlbnRpZmllcigpKS5nZXRBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIoKTsJCisgICAgICAgICAgICAgICAgcmV0dXJuIGdldFNpbXBsZU5hbWVUb0RlZmluaXRpb25NYXAoKS5nZXQoKChTaW1wbGVOYW1lKSBuYW1lKS5nZXRJZGVudGlmaWVyKCkpLmdldEFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcigpOwogICAgICAgICAgICAgfSBlbHNlIGlmIChuYW1lLmlzUXVhbGlmaWVkTmFtZSgpICYmIGdldFF1YWxpZmllZE5hbWVUb0RlZmluaXRpb25NYXAoKS5jb250YWluc0tleShuYW1lLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgpKSkgewogICAgICAgICAgICAgICAgIHJldHVybiBnZXRRdWFsaWZpZWROYW1lVG9EZWZpbml0aW9uTWFwKCkuZ2V0KG5hbWUuZ2V0RnVsbHlRdWFsaWZpZWROYW1lKCkpLmdldEFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcigpOwogICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KLSAgICAKLSAgICBwdWJsaWMgc3RhdGljIEFubm90YXRpb25EZWZpbml0aW9uIGdldEFubm90YXRpb25EZWZpbml0aW9uRm9yQ2xhc3MoQ2xhc3M8PyBleHRlbmRzIEFubm90YXRpb24+IAorCisgICAgLyoqCisgICAgICoKKyAgICAgKiBAcGFyYW0gYW5ub3RhdGlvbkNsYXNzCisgICAgICogQHJldHVybiA8Y29kZT48L2NvZGU+CisgICAgICovCisgICAgcHVibGljIHN0YXRpYyBBbm5vdGF0aW9uRGVmaW5pdGlvbiBnZXRBbm5vdGF0aW9uRGVmaW5pdGlvbkZvckNsYXNzKENsYXNzPD8gZXh0ZW5kcyBBbm5vdGF0aW9uPgogICAgICAgICAgICAgYW5ub3RhdGlvbkNsYXNzKSB7CiAgICAgICAgIHJldHVybiBnZXRBbm5vdGF0aW9uVG9DbGFzc05hbWVEZWZpbml0aW9uTWFwKCkuZ2V0KGFubm90YXRpb25DbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpOwogICAgIH0KLSAgICAKKworICAgIC8qKgorICAgICAqCisgICAgICogQHBhcmFtIGNhbm9uaWNhbE5hbWUKKyAgICAgKiBAcmV0dXJuIDxjb2RlPjwvY29kZT4KKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIEFubm90YXRpb25EZWZpbml0aW9uIGdldEFubm90YXRpb25EZWZpbml0aW9uRm9yQ2xhc3MoU3RyaW5nIGNhbm9uaWNhbE5hbWUpIHsKKyAgICAgICAgcmV0dXJuIGdldEFubm90YXRpb25Ub0NsYXNzTmFtZURlZmluaXRpb25NYXAoKS5nZXQoY2Fub25pY2FsTmFtZSk7CisgICAgfQorCisgICAgLyoqCisgICAgICoKKyAgICAgKiBAcGFyYW0gY2F0ZWdvcnlOYW1lCisgICAgICogQHJldHVybiA8Y29kZT48L2NvZGU+CisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBzeW5jaHJvbml6ZWQgTGlzdDxBbm5vdGF0aW9uRGVmaW5pdGlvbj4gZ2V0QW5ub3RhdGlvbnNCeUNhdGVnb3J5KFN0cmluZyBjYXRlZ29yeU5hbWUpIHsKICAgICAgICAgaWYgKGFubm90YXRpb25zQnlDYXRlZ29yeU1hcCA9PSBudWxsKSB7CiAgICAgICAgICAgICBhbm5vdGF0aW9uc0J5Q2F0ZWdvcnlNYXAgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+PigpOwogICAgICAgICAgICAgZm9yIChBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA6IGdldEFubm90YXRpb25zKCkpIHsKLSAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+IGFubm90YXRpb25EZWZpbml0aW9uTGlzdCA9IGFubm90YXRpb25zQnlDYXRlZ29yeU1hcC5nZXQoCiAgICAgICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXRDYXRlZ29yeSgpKTsKLSAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uRGVmaW5pdGlvbkxpc3QgPT0gbnVsbCkgewogICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uRGVmaW5pdGlvbkxpc3QgPSBuZXcgQXJyYXlMaXN0PEFubm90YXRpb25EZWZpbml0aW9uPigpOwogICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uRGVmaW5pdGlvbkxpc3QuYWRkKGFubm90YXRpb25EZWZpbml0aW9uKTsKLSAgICAgICAgICAgICAgICAgICAgYW5ub3RhdGlvbnNCeUNhdGVnb3J5TWFwLnB1dChhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXRDYXRlZ29yeSgpLCAKKyAgICAgICAgICAgICAgICAgICAgYW5ub3RhdGlvbnNCeUNhdGVnb3J5TWFwLnB1dChhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXRDYXRlZ29yeSgpLAogICAgICAgICAgICAgICAgICAgICAJCWFubm90YXRpb25EZWZpbml0aW9uTGlzdCk7CiAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICAgICAgICAgIH0KQEAgLTE5OCwxMyArMjQ4LDE3IEBACiAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uc0J5Q2F0ZWdvcnlNYXAuZ2V0KGNhdGVnb3J5TmFtZSk7CiAgICAgfQogCisgICAgLyoqCisgICAgICoKKyAgICAgKiBAcmV0dXJuIDxjb2RlPjwvY29kZT4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIExpc3Q8U3RyaW5nPiBnZXRBbm5vdGF0aW9uQ2F0ZWdvcmllcygpIHsKICAgICAgICAgcmV0dXJuIEFycmF5cy5hc0xpc3QoZ2V0QW5ub3RhdGlvbkNhdGVnb3J5Q2FjaGUoKS52YWx1ZXMoKS50b0FycmF5KAogICAgICAgICAgICAgICAgIG5ldyBTdHJpbmdbZ2V0QW5ub3RhdGlvbkNhdGVnb3J5Q2FjaGUoKS5zaXplKCldKSk7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0QW5ub3RhdGlvbkNhdGVnb3J5KFN0cmluZyBjYXRlZ29yeUlkKSB7Ci0gICAgICAgIHJldHVybiBnZXRBbm5vdGF0aW9uQ2F0ZWdvcnlDYWNoZSgpLmdldChjYXRlZ29yeUlkKTsgICAgICAgIAorICAgIHByaXZhdGUgc3RhdGljIFN0cmluZyBnZXRBbm5vdGF0aW9uQ2F0ZWdvcnkoU3RyaW5nIGNhdGVnb3J5SWQpIHsKKyAgICAgICAgcmV0dXJuIGdldEFubm90YXRpb25DYXRlZ29yeUNhY2hlKCkuZ2V0KGNhdGVnb3J5SWQpOwogICAgIH0KIAogICAgIHByaXZhdGUgc3RhdGljIHN5bmNocm9uaXplZCBNYXA8U3RyaW5nLCBTdHJpbmc+IGdldEFubm90YXRpb25DYXRlZ29yeUNhY2hlKCkgewpAQCAtMjEzLDQ0ICsyNjcsNTIgQEAKICAgICAgICAgfQogCiAgICAgICAgIGFubm90YXRpb25DYXRlZ29yeUNhY2hlID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KCk7Ci0gICAgICAgIAorCiAgICAgICAgIElFeHRlbnNpb25Qb2ludCBleHRlbnNpb25Qb2ludCA9IFBsYXRmb3JtLmdldEV4dGVuc2lvblJlZ2lzdHJ5KCkuZ2V0RXh0ZW5zaW9uUG9pbnQoCiAgICAgICAgICAgICAgICAgQW5ub3RhdGlvbnNDb3JlUGx1Z2luLlBMVUdJTl9JRCwgQU5OT1RBVElPTl9DQVRFR09SWSk7CiAgICAgICAgIGlmIChleHRlbnNpb25Qb2ludCAhPSBudWxsKSB7CiAgICAgICAgICAgICBJQ29uZmlndXJhdGlvbkVsZW1lbnRbXSBlbGVtZW50cyA9IGV4dGVuc2lvblBvaW50LmdldENvbmZpZ3VyYXRpb25FbGVtZW50cygpOwogICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBlbGVtZW50cy5sZW5ndGg7IGkrKykgewogICAgICAgICAgICAgICAgIElDb25maWd1cmF0aW9uRWxlbWVudCBlbGVtZW50ID0gZWxlbWVudHNbaV07Ci0gICAgICAgICAgICAgICAgYW5ub3RhdGlvbkNhdGVnb3J5Q2FjaGUucHV0KGdldEF0dHJpYnV0ZVZhbHVlKGVsZW1lbnQsIEFUVF9JRCksIAorICAgICAgICAgICAgICAgIGFubm90YXRpb25DYXRlZ29yeUNhY2hlLnB1dChnZXRBdHRyaWJ1dGVWYWx1ZShlbGVtZW50LCBBVFRfSUQpLAogICAgICAgICAgICAgICAgICAgICAgICAgZ2V0QXR0cmlidXRlVmFsdWUoZWxlbWVudCwgQVRUX05BTUUpKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkNhdGVnb3J5Q2FjaGU7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICoKKyAgICAgKiBAcmV0dXJuIDxjb2RlPjwvY29kZT4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIHN5bmNocm9uaXplZCBNYXA8U3RyaW5nLCBJQ29uZmlndXJhdGlvbkVsZW1lbnQ+IGdldEFubm90YXRpb25Jbml0aWFsaXplckNhY2hlKCkgewogICAgICAgICBpZiAoYW5ub3RhdGlvbkluaXRpYWxpemVyQ2FjaGUgIT0gbnVsbCkgewogICAgICAgICAgICAgcmV0dXJuIGFubm90YXRpb25Jbml0aWFsaXplckNhY2hlOwogICAgICAgICB9CiAKICAgICAgICAgYW5ub3RhdGlvbkluaXRpYWxpemVyQ2FjaGUgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIElDb25maWd1cmF0aW9uRWxlbWVudD4oKTsKLSAgICAgICAgCisKICAgICAgICAgSUV4dGVuc2lvblBvaW50IGV4dGVuc2lvblBvaW50ID0gUGxhdGZvcm0uZ2V0RXh0ZW5zaW9uUmVnaXN0cnkoKS5nZXRFeHRlbnNpb25Qb2ludCgKICAgICAgICAgICAgICAgICBBbm5vdGF0aW9uc0NvcmVQbHVnaW4uUExVR0lOX0lELCBBTk5PVEFUSU9OX0lOSVRJQUxJWkVSKTsKICAgICAgICAgaWYgKGV4dGVuc2lvblBvaW50ICE9IG51bGwpIHsKICAgICAgICAgICAgIElDb25maWd1cmF0aW9uRWxlbWVudFtdIGVsZW1lbnRzID0gZXh0ZW5zaW9uUG9pbnQuZ2V0Q29uZmlndXJhdGlvbkVsZW1lbnRzKCk7CiAgICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGVsZW1lbnRzLmxlbmd0aDsgaSsrKSB7CiAgICAgICAgICAgICAgICAgSUNvbmZpZ3VyYXRpb25FbGVtZW50IGVsZW1lbnQgPSBlbGVtZW50c1tpXTsKLSAgICAgICAgICAgICAgICBhbm5vdGF0aW9uSW5pdGlhbGl6ZXJDYWNoZS5wdXQoZ2V0QXR0cmlidXRlVmFsdWUoZWxlbWVudCwgQU5OT1RBVElPTiksIAorICAgICAgICAgICAgICAgIGFubm90YXRpb25Jbml0aWFsaXplckNhY2hlLnB1dChnZXRBdHRyaWJ1dGVWYWx1ZShlbGVtZW50LCBBTk5PVEFUSU9OKSwKICAgICAgICAgICAgICAgICAgICAgICAgIGVsZW1lbnQpOwogICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uSW5pdGlhbGl6ZXJDYWNoZTsKICAgICB9Ci0gICAgCisKKyAgICAvKioKKyAgICAgKgorICAgICAqIEByZXR1cm4gPGNvZGU+PC9jb2RlPgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgc3luY2hyb25pemVkIE1hcDxTdHJpbmcsIExpc3Q8SUNvbmZpZ3VyYXRpb25FbGVtZW50Pj4gZ2V0QW5ub3RhdGlvblByb2Nlc3NvcnNDYWNoZSgpIHsKICAgICAgICAgaWYgKGFubm90YXRpb25Qcm9jZXNzb3JDYWNoZSA9PSBudWxsKSB7CiAgICAgICAgICAgICBhbm5vdGF0aW9uUHJvY2Vzc29yQ2FjaGUgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIExpc3Q8SUNvbmZpZ3VyYXRpb25FbGVtZW50Pj4oKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBJRXh0ZW5zaW9uUG9pbnQgZXh0ZW5zaW9uUG9pbnQgPSBQbGF0Zm9ybS5nZXRFeHRlbnNpb25SZWdpc3RyeSgpLmdldEV4dGVuc2lvblBvaW50KAogICAgICAgICAgICAgICAgICAgICBBbm5vdGF0aW9uc0NvcmVQbHVnaW4uUExVR0lOX0lELCBBTk5PVEFUSU9OX1BST0NFU1NPUik7CiAgICAgICAgICAgICBpZiAoZXh0ZW5zaW9uUG9pbnQgIT0gbnVsbCkgewpAQCAtMjYwLDcgKzMyMiw3IEBACiAgICAgICAgICAgICAgICAgICAgIGlmIChlbGVtZW50LmdldE5hbWUoKS5lcXVhbHNJZ25vcmVDYXNlKCJwcm9jZXNzb3IiKSkgewogICAgICAgICAgICAgICAgICAgICAgICAgU3RyaW5nIGFubm90YXRpb25LZXkgPSBnZXRBdHRyaWJ1dGVWYWx1ZShlbGVtZW50LCBBTk5PVEFUSU9OKTsKICAgICAgICAgICAgICAgICAgICAgICAgIExpc3Q8SUNvbmZpZ3VyYXRpb25FbGVtZW50PiBjb25maWd1cmF0aW9uRWxlbWVudHMgPSBhbm5vdGF0aW9uUHJvY2Vzc29yQ2FjaGUuZ2V0KAotICAgICAgICAgICAgICAgICAgICAgICAgCQlhbm5vdGF0aW9uS2V5KTsgCisgICAgICAgICAgICAgICAgICAgICAgICAJCWFubm90YXRpb25LZXkpOwogICAgICAgICAgICAgICAgICAgICAgICAgaWYgKGNvbmZpZ3VyYXRpb25FbGVtZW50cyA9PSBudWxsKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uZmlndXJhdGlvbkVsZW1lbnRzID0gbmV3IEFycmF5TGlzdDxJQ29uZmlndXJhdGlvbkVsZW1lbnQ+KCk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uZmlndXJhdGlvbkVsZW1lbnRzLmFkZChlbGVtZW50KTsKQEAgLTI3NSw2ICszMzcsMTIgQEAKICAgICAgICAgcmV0dXJuIGFubm90YXRpb25Qcm9jZXNzb3JDYWNoZTsKICAgICB9CiAKKyAgICAvKioKKyAgICAgKgorICAgICAqIEBwYXJhbSBjb25maWd1cmF0aW9uRWxlbWVudAorICAgICAqIEBwYXJhbSBhdHRyaWJ1dGVOYW1lCisgICAgICogQHJldHVybgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldEF0dHJpYnV0ZVZhbHVlKElDb25maWd1cmF0aW9uRWxlbWVudCBjb25maWd1cmF0aW9uRWxlbWVudCwgU3RyaW5nIGF0dHJpYnV0ZU5hbWUpIHsKICAgICAgICAgU3RyaW5nIGF0dHJpYnV0ZSA9IGNvbmZpZ3VyYXRpb25FbGVtZW50LmdldEF0dHJpYnV0ZShhdHRyaWJ1dGVOYW1lKTsKICAgICAgICAgaWYgKGF0dHJpYnV0ZSAhPSBudWxsKSB7CkBAIC0yODIsNyArMzUwLDEyIEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICoKKyAgICAgKiBAcGFyYW0gY29uZmlndXJhdGlvbkVsZW1lbnQKKyAgICAgKiBAcmV0dXJuCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBMaXN0PEVsZW1lbnRUeXBlPiBnZXRGaWx0ZXJlZFRhcmdldHMoSUNvbmZpZ3VyYXRpb25FbGVtZW50IGNvbmZpZ3VyYXRpb25FbGVtZW50KSB7CiAgICAgICAgIExpc3Q8RWxlbWVudFR5cGU+IHRhcmdldHMgPSBuZXcgQXJyYXlMaXN0PEVsZW1lbnRUeXBlPig3KTsKICAgICAgICAgdHJ5IHsKQEAgLTI5NywxMyArMzcwLDEzIEBACiAgICAgICAgIHJldHVybiB0YXJnZXRzOwogICAgIH0KIAotICAgIHByaXZhdGUgc3RhdGljIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+IGdldEFsbEFubm90YXRpb25zRm9yRWxlbWVudChPYmplY3QgZWxlbWVudCkgCisgICAgcHJpdmF0ZSBzdGF0aWMgTGlzdDxBbm5vdGF0aW9uRGVmaW5pdGlvbj4gZ2V0QWxsQW5ub3RhdGlvbnNGb3JFbGVtZW50KE9iamVjdCBlbGVtZW50KQogICAgICAgICAgICAgdGhyb3dzIEphdmFNb2RlbEV4Y2VwdGlvbiB7Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSVBhY2thZ2VEZWNsYXJhdGlvbikgewogICAgICAgICAgICAgcmV0dXJuIGdldEFubm90YXRpb25zRm9yRWxlbWVudFR5cGUoRWxlbWVudFR5cGUuUEFDS0FHRSk7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJVHlwZSkgewogICAgICAgICAgICAgSVR5cGUgdHlwZSA9IChJVHlwZSkgZWxlbWVudDsKICAgICAgICAgICAgIGlmICh0eXBlLmlzQW5ub3RhdGlvbigpKSB7CkBAIC0zMTEsMTUgKzM4NCwxNSBAQAogICAgICAgICAgICAgfQogICAgICAgICAgICAgcmV0dXJuIGdldEFubm90YXRpb25zRm9yRWxlbWVudFR5cGUoRWxlbWVudFR5cGUuVFlQRSk7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJRmllbGQpIHsKICAgICAgICAgICAgIHJldHVybiBnZXRBbm5vdGF0aW9uc0ZvckVsZW1lbnRUeXBlKEVsZW1lbnRUeXBlLkZJRUxEKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElNZXRob2QpIHsKICAgICAgICAgICAgIHJldHVybiBnZXRBbm5vdGF0aW9uc0ZvckVsZW1lbnRUeXBlKEVsZW1lbnRUeXBlLk1FVEhPRCk7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uKSB7CiAgICAgICAgICAgICByZXR1cm4gZ2V0QW5ub3RhdGlvbnNGb3JFbGVtZW50VHlwZShFbGVtZW50VHlwZS5QQVJBTUVURVIpOwogICAgICAgICB9CkBAIC0zMzEsMzIgKzQwNCwzMiBAQAogICAgICAgICBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElBbm5vdGF0aW9uKSB7CiAgICAgICAgICAgICByZXR1cm4gZ2V0QW5ub3RhdGlvbnNGb3JFbGVtZW50VHlwZShFbGVtZW50VHlwZS5BTk5PVEFUSU9OX1RZUEUpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIHN0YXRpYyBMaXN0PEFubm90YXRpb25EZWZpbml0aW9uPiBnZXRBbm5vdGF0aW9uc0ZvckVsZW1lbnRUeXBlKEVsZW1lbnRUeXBlIGVsZW1lbnRUeXBlKSB7CiAgICAgICAgIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+IGFubm90YXRpb25EZWZpbml0aW9ucyA9IG5ldyBBcnJheUxpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+KCk7Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChhbm5vdGF0aW9uQ2FjaGUgPT0gbnVsbCkgewogICAgICAgICAgICAgZ2V0QW5ub3RhdGlvbnMoKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBmb3IgKEFubm90YXRpb25EZWZpbml0aW9uIGFubm90YXRpb25EZWZpbml0aW9uIDogYW5ub3RhdGlvbkNhY2hlKSB7Ci0gICAgICAgICAgICBpZiAoYW5ub3RhdGlvbkRlZmluaXRpb24uZ2V0VGFyZ2V0cygpLmNvbnRhaW5zKGVsZW1lbnRUeXBlKSAmJiAKKyAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uRGVmaW5pdGlvbi5nZXRUYXJnZXRzKCkuY29udGFpbnMoZWxlbWVudFR5cGUpICYmCiAgICAgICAgICAgICAgICAgICAgICFpc0RlcHJlY2F0ZWQoYW5ub3RhdGlvbkRlZmluaXRpb24pKSB7CiAgICAgICAgICAgICAgICAgYW5ub3RhdGlvbkRlZmluaXRpb25zLmFkZChhbm5vdGF0aW9uRGVmaW5pdGlvbik7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGFubm90YXRpb25EZWZpbml0aW9uczsKICAgICB9Ci0gICAgCi0gICAgcHJpdmF0ZSBzdGF0aWMgdm9pZCBmaWx0ZXJBbm5vdGF0aW9uc0xpc3QoT2JqZWN0IGVsZW1lbnQsIAorCisgICAgcHJpdmF0ZSBzdGF0aWMgdm9pZCBmaWx0ZXJBbm5vdGF0aW9uc0xpc3QoT2JqZWN0IGVsZW1lbnQsCiAgICAgICAgIExpc3Q8QW5ub3RhdGlvbkRlZmluaXRpb24+IGFubm90YXRpb25EZWZpbml0aW9ucykgdGhyb3dzIEphdmFNb2RlbEV4Y2VwdGlvbiB7CiAgICAgICAgIEl0ZXJhdG9yPEFubm90YXRpb25EZWZpbml0aW9uPiBhbm5vdGF0aW9uSXRlciA9IGFubm90YXRpb25EZWZpbml0aW9ucy5pdGVyYXRvcigpOwogICAgICAgICB3aGlsZSAoYW5ub3RhdGlvbkl0ZXIuaGFzTmV4dCgpKSB7CiAgICAgICAgICAgICBBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA9IGFubm90YXRpb25JdGVyLm5leHQoKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElUeXBlKSB7CiAgICAgICAgICAgICAgICAgSVR5cGUgdHlwZSA9IChJVHlwZSkgZWxlbWVudDsKICAgICAgICAgICAgICAgICBpZiAoaXNDbGFzc1Jlc3RyaWN0ZWQodHlwZSwgYW5ub3RhdGlvbkRlZmluaXRpb24pCkBAIC0zODEsNyArNDU0LDcgQEAKICAgICAgICAgICAgICAgICAgICAgYW5ub3RhdGlvbkl0ZXIucmVtb3ZlKCk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSUZpZWxkKSB7CiAgICAgICAgICAgICAgICAgaWYoaXNDbGFzc1Jlc3RyaWN0ZWQoKElGaWVsZCkgZWxlbWVudCwgYW5ub3RhdGlvbkRlZmluaXRpb24pCiAgICAgICAgICAgICAgICAgICAgICAgICB8fCBpc0ludGVyZmFjZVJlc3RyaWN0ZWQoKElGaWVsZCkgZWxlbWVudCwgYW5ub3RhdGlvbkRlZmluaXRpb24pCkBAIC0zOTEsNyArNDY0LDcgQEAKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gaXNDbGFzc1Jlc3RyaWN0ZWQoSUphdmFFbGVtZW50IGphdmFFbGVtZW50LAogICAgIAkJQW5ub3RhdGlvbkRlZmluaXRpb24gYW5ub3RhdGlvbkRlZmluaXRpb24pIHRocm93cyBKYXZhTW9kZWxFeGNlcHRpb24gewogICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuVFlQRSkgewpAQCAtNDA3LDcgKzQ4MCw3IEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gaXNJbnRlcmZhY2VSZXN0cmljdGVkKElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwKICAgICAJCUFubm90YXRpb25EZWZpbml0aW9uIGFubm90YXRpb25EZWZpbml0aW9uKSB0aHJvd3MgSmF2YU1vZGVsRXhjZXB0aW9uIHsKICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LlRZUEUpIHsKQEAgLTQyMywyMyArNDk2LDIzIEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gaXNFbnVtUmVzdHJpY3RlZChJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsCiAgICAgCQlBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbikgdGhyb3dzIEphdmFNb2RlbEV4Y2VwdGlvbiB7CiAgICAgICAgIGlmIChqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5UWVBFKSB7Ci0gICAgICAgICAgICByZXR1cm4gISgoSVR5cGUpamF2YUVsZW1lbnQpLmlzRW51bSgpICYmIGFubm90YXRpb25EZWZpbml0aW9uLmlzRW51bU9ubHkoKTsgICAgICAgICAgICAKKyAgICAgICAgICAgIHJldHVybiAhKChJVHlwZSlqYXZhRWxlbWVudCkuaXNFbnVtKCkgJiYgYW5ub3RhdGlvbkRlZmluaXRpb24uaXNFbnVtT25seSgpOwogICAgICAgICB9CiAgICAgICAgIGlmIChqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5NRVRIT0QpIHsKICAgICAgICAgICAgIElUeXBlIHR5cGUgPSAoSVR5cGUpamF2YUVsZW1lbnQuZ2V0UGFyZW50KCk7Ci0gICAgICAgICAgICByZXR1cm4gIXR5cGUuaXNFbnVtKCkgJiYgYW5ub3RhdGlvbkRlZmluaXRpb24uaXNFbnVtT25seSgpOyAgICAgICAgICAgIAorICAgICAgICAgICAgcmV0dXJuICF0eXBlLmlzRW51bSgpICYmIGFubm90YXRpb25EZWZpbml0aW9uLmlzRW51bU9ubHkoKTsKICAgICAgICAgfQogICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuRklFTEQpIHsKICAgICAgICAgICAgIElUeXBlIHR5cGUgPSAoSVR5cGUpamF2YUVsZW1lbnQuZ2V0UGFyZW50KCk7Ci0gICAgICAgICAgICByZXR1cm4gIXR5cGUuaXNFbnVtKCkgJiYgYW5ub3RhdGlvbkRlZmluaXRpb24uaXNFbnVtT25seSgpOyAgICAgICAgICAgIAorICAgICAgICAgICAgcmV0dXJuICF0eXBlLmlzRW51bSgpICYmIGFubm90YXRpb25EZWZpbml0aW9uLmlzRW51bU9ubHkoKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQotICAgIAorCiAgICAgLy9UT0RPIE1vdmUgdGhlIERlcHJlY2F0ZWQgb3B0aW9uIHRvIHByZWZlcmVuY2VzCiAgICAgcHJpdmF0ZSBzdGF0aWMgYm9vbGVhbiBpc0RlcHJlY2F0ZWQoQW5ub3RhdGlvbkRlZmluaXRpb24gYW5ub3RhdGlvbkRlZmluaXRpb24pIHsKICAgICAgICAgQ2xhc3M8Pz4gYW5ub3RhdGlvbkNsYXNzID0gYW5ub3RhdGlvbkRlZmluaXRpb24uZ2V0QW5ub3RhdGlvbkNsYXNzKCk7CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9pbml0aWFsaXphdGlvbi9Bbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL2luaXRpYWxpemF0aW9uL0Fubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCmluZGV4IDc5ZmE5OGYuLmRkN2Y4NGMgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL2luaXRpYWxpemF0aW9uL0Fubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL2luaXRpYWxpemF0aW9uL0Fubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCkBAIC0xOCw2ICsxOCw3IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFTVDsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uRXhwcmVzc2lvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uTWVtYmVyVmFsdWVQYWlyOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5TaW5nbGVNZW1iZXJBbm5vdGF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnRleHQuY29udGVudGFzc2lzdC5Db21wbGV0aW9uUHJvcG9zYWw7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UudGV4dC5jb250ZW50YXNzaXN0LklDb21wbGV0aW9uUHJvcG9zYWw7CiBpbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwpAQCAtMzAsMTcgKzMxLDE3IEBACiAgKiBQcm92aWRlcyBkZWZhdWx0IGltcGxlbWVudGF0aW9ucyBmb3IgYWxsIG1ldGhvZHMuCiAgKiA8L3A+CiAgKiA8cD4KLSAqIDxzdHJvbmc+UHJvdmlzaW9uYWwgQVBJOjwvc3Ryb25nPiBUaGlzIGNsYXNzL2ludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwgdW5kZXIgZGV2ZWxvcG1lbnQgYW5kIAotICogZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nIHN0YWJpbGl0eS4gSXQgaXMgYmVpbmcgbWFkZSBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZSAKLSAqIHRvIHNvbGljaXQgZmVlZGJhY2sgZnJvbSBwaW9uZWVyaW5nIGFkb3B0ZXJzIG9uIHRoZSB1bmRlcnN0YW5kaW5nIHRoYXQgYW55IGNvZGUgdGhhdCB1c2VzIHRoaXMgQVBJIHdpbGwgCisgKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyIGRldmVsb3BtZW50IGFuZAorICogZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nIHN0YWJpbGl0eS4gSXQgaXMgYmVpbmcgbWFkZSBhdmFpbGFibGUgYXQgdGhpcyBlYXJseSBzdGFnZQorICogdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgdGhpcyBBUEkgd2lsbAogICogYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KICAqIDwvcD4KLSAqIAorICoKICovCiBwdWJsaWMgY2xhc3MgQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGltcGxlbWVudHMgSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciB7CiAKICAgICBwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIFN0cmluZyBNSVNTSU5HX0lERU5USUZFUiA9ICIkbWlzc2luZyQiOwotCSAKKwogICAgIHB1YmxpYyBMaXN0PE1lbWJlclZhbHVlUGFpcj4gZ2V0TWVtYmVyVmFsdWVQYWlycyhJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIEFTVCBhc3QsCiAgICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgQW5ub3RhdGlvbj4gYW5ub3RhdGlvbkNsYXNzKSB7CiAgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKQEAgLTUxLDEyICs1MiwxNyBAQAogICAgICAgICByZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7CiAgICAgfQogCi0JcHJvdGVjdGVkIENvbXBsZXRpb25Qcm9wb3NhbCBjcmVhdGVDb21wbGV0aW9uUHJvcG9zYWwoU3RyaW5nIHByb3Bvc2FsLCBFeHByZXNzaW9uIHZhbHVlKSB7CisgICAgcHVibGljIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvclNpbmdsZU1lbWJlckFubm90YXRpb24oSUphdmFFbGVtZW50IGphdmFFbGVtZW50LAorICAgICAgICAgICAgU2luZ2xlTWVtYmVyQW5ub3RhdGlvbiBzaW5nbGVNZW1iZXJBbm5vdGF0aW9uKSB7CisgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKKyAgICB9CisKKyAgICBwcm90ZWN0ZWQgQ29tcGxldGlvblByb3Bvc2FsIGNyZWF0ZUNvbXBsZXRpb25Qcm9wb3NhbChTdHJpbmcgcHJvcG9zYWwsIEV4cHJlc3Npb24gdmFsdWUpIHsKICAgICAgICAgSW1hZ2UgaW1hZ2UgPSBQbGF0Zm9ybVVJLmdldFdvcmtiZW5jaCgpLmdldFNoYXJlZEltYWdlcygpLmdldEltYWdlKG9yZy5lY2xpcHNlLnVpLklTaGFyZWRJbWFnZXMuSU1HX09CSl9GSUxFKTsKICAgICAgICAgcmV0dXJuIGNyZWF0ZUNvbXBsZXRpb25Qcm9wb3NhbChwcm9wb3NhbCwgdmFsdWUsIGltYWdlLCBwcm9wb3NhbCk7Ci0JfQorICAgIH0KIAotICAgIHByb3RlY3RlZCBDb21wbGV0aW9uUHJvcG9zYWwgY3JlYXRlQ29tcGxldGlvblByb3Bvc2FsKFN0cmluZyBwcm9wb3NhbCwgRXhwcmVzc2lvbiB2YWx1ZSwgSW1hZ2UgaW1hZ2UsIAorICAgIHByb3RlY3RlZCBDb21wbGV0aW9uUHJvcG9zYWwgY3JlYXRlQ29tcGxldGlvblByb3Bvc2FsKFN0cmluZyBwcm9wb3NhbCwgRXhwcmVzc2lvbiB2YWx1ZSwgSW1hZ2UgaW1hZ2UsCiAgICAgICAgICAgICBTdHJpbmcgZGlzcGxheVN0cmluZykgewogICAgICAgICBpbnQgcmVwbGFjZW1lbnRPZmZzZXQgPSB2YWx1ZS5nZXRTdGFydFBvc2l0aW9uKCk7CiAgICAgICAgIGludCByZXBsYWNlbWVudExlbmd0aCA9IDA7CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9pbml0aWFsaXphdGlvbi9EZWZhdWx0c0Fubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2Fubm90YXRpb25zL2NvcmUvaW5pdGlhbGl6YXRpb24vRGVmYXVsdHNBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQppbmRleCAzMzkzNzI5Li5iYjQ1N2E3IDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9pbml0aWFsaXphdGlvbi9EZWZhdWx0c0Fubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL2luaXRpYWxpemF0aW9uL0RlZmF1bHRzQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyLmphdmEKQEAgLTIzLDE0ICsyMywxNCBAQAogLyoqCiAgKiBDb25zdHJ1Y3RzIDxjb2RlPk1lbWJlclZhbHVlUGFpcjwvY29kZT4gZnJvbSB0aGUgZGVmYXVsdHMgZm91bmQgaW4gdGhlIHBhc3NlZCBpbiA8Y29kZT5Bbm5vdGF0aW9uPC9jb2RlPi4KICAqIDxwPgotICogPHN0cm9uZz5Qcm92aXNpb25hbCBBUEk6PC9zdHJvbmc+IFRoaXMgY2xhc3MvaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbCB1bmRlciAKLSAqIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcgc3RhYmlsaXR5LiBJdCBpcyBiZWluZyBtYWRlIGF2YWlsYWJsZSBhdCAKLSAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgCisgKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyCisgKiBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nIHN0YWJpbGl0eS4gSXQgaXMgYmVpbmcgbWFkZSBhdmFpbGFibGUgYXQKKyAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMKICAqIHRoaXMgQVBJIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KICAqIDwvcD4KICAqLwogcHVibGljIGNsYXNzIERlZmF1bHRzQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGV4dGVuZHMgQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIHsKLSAgICAKKwogICAgIHB1YmxpYyBEZWZhdWx0c0Fubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcigpIHsKICAgICB9CiAKQEAgLTM5LDExICszOSwxMSBAQAogICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIEFubm90YXRpb24+IGFubm90YXRpb25DbGFzcykgewogICAgICAgICByZXR1cm4gZ2V0TWVtYmVyVmFsdWVQYWlycyhhc3QsIGFubm90YXRpb25DbGFzcyk7CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSBMaXN0PE1lbWJlclZhbHVlUGFpcj4gZ2V0TWVtYmVyVmFsdWVQYWlycyhBU1QgYXN0LAogICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIEFubm90YXRpb24+IGFubm90YXRpb25DbGFzcykgewogICAgICAgICBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycyA9IG5ldyBBcnJheUxpc3Q8TWVtYmVyVmFsdWVQYWlyPigpOwotICAgICAgICAKKwogICAgICAgICBNZXRob2RbXSBkZWNsYXJlZE1ldGhvZHMgPSBhbm5vdGF0aW9uQ2xhc3MuZ2V0RGVjbGFyZWRNZXRob2RzKCk7CiAgICAgICAgIGZvciAoTWV0aG9kIG1ldGhvZCA6IGRlY2xhcmVkTWV0aG9kcykgewogICAgICAgICAgICAgU3RyaW5nIG5hbWUgPSBtZXRob2QuZ2V0TmFtZSgpOwpAQCAtNTUsMzQgKzU1LDM0IEBACiAgICAgICAgICAgICAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5hbWUsIGRlZmF1bHRWYWx1ZS50b1N0cmluZygpKSk7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuZXF1YWxzKEJvb2xlYW4uVFlQRSkpIHsKICAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlycy5hZGQoQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZUJvb2xlYW5NZW1iZXJWYWx1ZVBhaXIoYXN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5hbWUsIEJvb2xlYW4ucGFyc2VCb29sZWFuKGRlZmF1bHRWYWx1ZS50b1N0cmluZygpKSkpOwogICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAKLSAgICAgICAgICAgICAgICBpZiAocmV0dXJuVHlwZS5pc1ByaW1pdGl2ZSgpICYmIChyZXR1cm5UeXBlLmVxdWFscyhCeXRlLlRZUEUpIHx8IHJldHVyblR5cGUuZXF1YWxzKFNob3J0LlRZUEUpIAorCisgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuaXNQcmltaXRpdmUoKSAmJiAocmV0dXJuVHlwZS5lcXVhbHMoQnl0ZS5UWVBFKSB8fCByZXR1cm5UeXBlLmVxdWFscyhTaG9ydC5UWVBFKQogICAgICAgICAgICAgICAgICAgICAgICAgfHwgcmV0dXJuVHlwZS5lcXVhbHMoSW50ZWdlci5UWVBFKSB8fCByZXR1cm5UeXBlLmVxdWFscyhMb25nLlRZUEUpCiAgICAgICAgICAgICAgICAgICAgICAgICB8fCByZXR1cm5UeXBlLmVxdWFscyhGbG9hdC5UWVBFKSB8fCByZXR1cm5UeXBlLmVxdWFscyhEb3VibGUuVFlQRSkpKSB7Ci0gICAgICAgICAgICAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKEFubm90YXRpb25zQ29yZS5jcmVhdGVOdW1iZXJNZW1iZXJWYWx1ZVBhaXIoYXN0LCBuYW1lLCBkZWZhdWx0VmFsdWUpKTsKKyAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlycy5hZGQoQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU51bWJlck1lbWJlclZhbHVlUGFpcihhc3QsIG5hbWUsIGRlZmF1bHRWYWx1ZS50b1N0cmluZygpKSk7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuaXNBcnJheSgpKSB7Ci0gICAgICAgICAgICAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKEFubm90YXRpb25zQ29yZS5jcmVhdGVBcnJheU1lbWJlclZhbHVlUGFpcihhc3QsIG1ldGhvZCwgCisgICAgICAgICAgICAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKEFubm90YXRpb25zQ29yZS5jcmVhdGVBcnJheU1lbWJlclZhbHVlUGFpcihhc3QsIG1ldGhvZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoT2JqZWN0W10pZGVmYXVsdFZhbHVlKSk7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuaXNFbnVtKCkpIHsKLSAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlycy5hZGQoQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZUVudW1NZW1iZXJWYWx1ZVBhaXIoYXN0LCAKKyAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlycy5hZGQoQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZUVudW1NZW1iZXJWYWx1ZVBhaXIoYXN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1ldGhvZC5nZXREZWNsYXJpbmdDbGFzcygpLmdldENhbm9uaWNhbE5hbWUoKSwgbmFtZSwgZGVmYXVsdFZhbHVlKSk7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuZXF1YWxzKENsYXNzLmNsYXNzKSkgewotICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChBbm5vdGF0aW9uc0NvcmUuY3JlYXRlVHlwZU1lbWJlclZhbHVlUGFpcihhc3QsIG5hbWUsIAorICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChBbm5vdGF0aW9uc0NvcmUuY3JlYXRlVHlwZU1lbWJlclZhbHVlUGFpcihhc3QsIG5hbWUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVmYXVsdFZhbHVlKSk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQotICAgICAgICB9ICAgICAgCisgICAgICAgIH0KICAgICAgICAgcmV0dXJuIG1lbWJlclZhbHVlUGFpcnM7CiAgICAgfQogfQpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2Fubm90YXRpb25zL2NvcmUvaW5pdGlhbGl6YXRpb24vSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2Fubm90YXRpb25zL2NvcmUvaW5pdGlhbGl6YXRpb24vSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCmluZGV4IDZlNzllOTEuLmU4ZWEyNTkgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL2luaXRpYWxpemF0aW9uL0lBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS9pbml0aWFsaXphdGlvbi9JQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyLmphdmEKQEAgLTE1LDYgKzE1LDcgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JSmF2YUVsZW1lbnQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFTVDsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uTWVtYmVyVmFsdWVQYWlyOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5TaW5nbGVNZW1iZXJBbm5vdGF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnRleHQuY29udGVudGFzc2lzdC5JQ29tcGxldGlvblByb3Bvc2FsOwogCiAvKioKQEAgLTMzLDUgKzM0LDkgQEAKICAgICAKICAgICBwdWJsaWMgTGlzdDxJQ29tcGxldGlvblByb3Bvc2FsPiBnZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9yTWVtYmVyVmFsdWVQYWlyKElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwKICAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIpOworICAgIAorICAgIHB1YmxpYyBMaXN0PElDb21wbGV0aW9uUHJvcG9zYWw+IGdldENvbXBsZXRpb25Qcm9wb3NhbHNGb3JTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwKKyAgICAgICAgICAgIFNpbmdsZU1lbWJlckFubm90YXRpb24gc2luZ2xlTWVtYmVyQW5ub3RhdGlvbik7CisKICAgICAgICAgCiB9CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvYW5ub3RhdGlvbnMvY29yZS91dGlscy9Bbm5vdGF0aW9uVXRpbHMuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL3V0aWxzL0Fubm90YXRpb25VdGlscy5qYXZhCmluZGV4IDJlNGY0MTIuLmE2NDY4MzUgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL3V0aWxzL0Fubm90YXRpb25VdGlscy5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9hbm5vdGF0aW9ucy9jb3JlL3V0aWxzL0Fubm90YXRpb25VdGlscy5qYXZhCkBAIC0xLDE3ICsxLDE3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogQ29weXJpZ2h0IChjKSAyMDA4IElPTkEgVGVjaG5vbG9naWVzIFBMQworICogQ29weXJpZ2h0IChjKSAyMDA4IElPTkEgVGVjaG5vbG9naWVzIFBMQywgU2hhbmUgQ2xhcmtlCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCiAgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKICAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CiAgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAogICoKICAqIENvbnRyaWJ1dG9yczoKLSAqIElPTkEgVGVjaG5vbG9naWVzIFBMQyAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgorICogICAgSU9OQSBUZWNobm9sb2dpZXMgUExDIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCisgKiAgICBTaGFuZSBDbGFya2UgLSBSZXdyb3RlIEFQSQogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiBwYWNrYWdlIG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLnV0aWxzOwogCiBpbXBvcnQgamF2YS5sYW5nLmFubm90YXRpb24uRWxlbWVudFR5cGU7Ci1pbXBvcnQgamF2YS5sYW5nLmFubm90YXRpb24uVGFyZ2V0OwogaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7CiBpbXBvcnQgamF2YS51dGlsLkFycmF5czsKIGltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKQEAgLTIwLDEyICsyMCw4IEBACiBpbXBvcnQgamF2YS51dGlsLk1hcDsKIGltcG9ydCBqYXZhLnV0aWwuU2V0OwogCi1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5maWxlYnVmZmVycy5GaWxlQnVmZmVyczsKLWltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLmZpbGVidWZmZXJzLklUZXh0RmlsZUJ1ZmZlck1hbmFnZXI7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5maWxlYnVmZmVycy5Mb2NhdGlvbktpbmQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUZpbGU7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQYXRoOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JUHJvZ3Jlc3NNb25pdG9yOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5OdWxsUHJvZ3Jlc3NNb25pdG9yOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklBbm5vdGF0YWJsZTsKQEAgLTQ2LDcgKzQyLDYgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQWJzdHJhY3RUeXBlRGVjbGFyYXRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb25UeXBlRGVjbGFyYXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb25UeXBlTWVtYmVyRGVjbGFyYXRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkJvZHlEZWNsYXJhdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQm9vbGVhbkxpdGVyYWw7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkNoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvcjsKQEAgLTcxLDEzICs2NiwxMyBAQAogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5yZXdyaXRlLkxpc3RSZXdyaXRlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC51aS5Db2RlU3R5bGVDb25maWd1cmF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC51aS5TaGFyZWRBU1RQcm92aWRlcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS50ZXh0LklEb2N1bWVudDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5Bbm5vdGF0aW9uRGVmaW5pdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5Bbm5vdGF0aW9uc0NvcmVQbHVnaW47CitpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuQW5ub3RhdGlvbnNNYW5hZ2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmx0ay5jb3JlLnJlZmFjdG9yaW5nLkNoYW5nZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5JVW5kb01hbmFnZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UubHRrLmNvcmUucmVmYWN0b3JpbmcuUmVmYWN0b3JpbmdDb3JlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmx0ay5jb3JlLnJlZmFjdG9yaW5nLlJlZmFjdG9yaW5nU3RhdHVzOwotaW1wb3J0IG9yZy5lY2xpcHNlLmx0ay5jb3JlLnJlZmFjdG9yaW5nLlRleHRDaGFuZ2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UubHRrLmNvcmUucmVmYWN0b3JpbmcuVGV4dEZpbGVDaGFuZ2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UudGV4dC5lZGl0cy5NdWx0aVRleHRFZGl0OwogaW1wb3J0IG9yZy5lY2xpcHNlLnRleHQuZWRpdHMuVGV4dEVkaXQ7CkBAIC05OCwzNSArOTMsMTIwIEBACiAgKiA8L3A+CiAgKi8KIHB1YmxpYyBmaW5hbCBjbGFzcyBBbm5vdGF0aW9uVXRpbHMgewotICAgIHByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBGT1JNQVRURVJfSU5TRVJUX1NQQUNFX0JFRk9SRV9BU1NJR05NRU5UX09QRVJBVE9SCi0gICAgICAgID0gIm9yZy5lY2xpcHNlLmpkdC5jb3JlLmZvcm1hdHRlci5pbnNlcnRfc3BhY2VfYmVmb3JlX2Fzc2lnbm1lbnRfb3BlcmF0b3IiOyAvLyROT04tTkxTLTEkCi0gICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEZPUk1BVFRFUl9JTlNFUlRfU1BBQ0VfQUZURVJfQVNTSUdOTUVOVF9PUEVSQVRPUgotICAgICAgICA9ICJvcmcuZWNsaXBzZS5qZHQuY29yZS5mb3JtYXR0ZXIuaW5zZXJ0X3NwYWNlX2FmdGVyX2Fzc2lnbm1lbnRfb3BlcmF0b3IiOyAvLyROT04tTkxTLTEkCi0gICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIERPX05PVF9JTlNFUlQgPSAiZG8gbm90IGluc2VydCI7IC8vJE5PTi1OTFMtMSQKLQogCiAgICAgcHJpdmF0ZSBBbm5vdGF0aW9uVXRpbHMoKSB7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBUZXh0RWRpdCBjcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsCi0gICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbikgdGhyb3dzIENvcmVFeGNlcHRpb24geworICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBhZGRJbXBvcnQoSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBTdHJpbmcgcXVhbGlmaWVkTmFtZSkgdGhyb3dzIENvcmVFeGNlcHRpb24geworICAgICAgICBUZXh0RmlsZUNoYW5nZSBjaGFuZ2UgPSBuZXcgVGV4dEZpbGVDaGFuZ2UoIkFkZCBJbXBvcnQiLCAoSUZpbGUpIGphdmFFbGVtZW50LmdldFJlc291cmNlKCkpOworICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOworICAgICAgICBjaGFuZ2Uuc2V0RWRpdChtdWx0aVRleHRFZGl0KTsKKworICAgICAgICBUZXh0RWRpdCBhbm5vdGF0aW9uRWRpdCA9IEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChqYXZhRWxlbWVudCwgcXVhbGlmaWVkTmFtZSk7CisgICAgICAgIGNoYW5nZS5hZGRFZGl0KGFubm90YXRpb25FZGl0KTsKKyAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKKyAgICB9CisKKyAgICBwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlSW1wb3J0KElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwgU3RyaW5nIHF1YWxpZmllZE5hbWUpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKyAgICAgICAgVGV4dEZpbGVDaGFuZ2UgY2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJSZW1vdmUgSW1wb3J0IiwgKElGaWxlKSBqYXZhRWxlbWVudC5nZXRSZXNvdXJjZSgpKTsKKyAgICAgICAgTXVsdGlUZXh0RWRpdCBtdWx0aVRleHRFZGl0ID0gbmV3IE11bHRpVGV4dEVkaXQoKTsKKyAgICAgICAgY2hhbmdlLnNldEVkaXQobXVsdGlUZXh0RWRpdCk7CisKKyAgICAgICAgVGV4dEVkaXQgYW5ub3RhdGlvbkVkaXQgPSBBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlSW1wb3J0VGV4dEVkaXQoamF2YUVsZW1lbnQsIHF1YWxpZmllZE5hbWUpOworICAgICAgICBjaGFuZ2UuYWRkRWRpdChhbm5vdGF0aW9uRWRpdCk7CisgICAgICAgIGFwcGx5Q2hhbmdlKG51bGwsIGNoYW5nZSk7CisgICAgfQorCisgICAgcHVibGljIHN0YXRpYyB2b2lkIGFkZEFubm90YXRpb24oSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBBbm5vdGF0aW9uIGFubm90YXRpb24pIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKyAgICAgICAgVGV4dEZpbGVDaGFuZ2UgY2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJBZGQgYW5ub3RhdGlvbiIsIChJRmlsZSkgamF2YUVsZW1lbnQuZ2V0UmVzb3VyY2UoKSk7CisgICAgICAgIE11bHRpVGV4dEVkaXQgbXVsdGlUZXh0RWRpdCA9IG5ldyBNdWx0aVRleHRFZGl0KCk7CisgICAgICAgIGNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOworCisgICAgICAgIFRleHRFZGl0IGFubm90YXRpb25FZGl0ID0gQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChqYXZhRWxlbWVudCwgYW5ub3RhdGlvbik7CisgICAgICAgIGNoYW5nZS5hZGRFZGl0KGFubm90YXRpb25FZGl0KTsKKyAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKKyAgICB9CisKKyAgICBwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQW5ub3RhdGlvbihJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIEFubm90YXRpb24gYW5ub3RhdGlvbikgdGhyb3dzIENvcmVFeGNlcHRpb24geworICAgICAgICBUZXh0RmlsZUNoYW5nZSBjaGFuZ2UgPSBuZXcgVGV4dEZpbGVDaGFuZ2UoIlJlbW92ZSBhbm5vdGF0aW9uIiwgKElGaWxlKSBqYXZhRWxlbWVudC5nZXRSZXNvdXJjZSgpKTsKKyAgICAgICAgTXVsdGlUZXh0RWRpdCBtdWx0aVRleHRFZGl0ID0gbmV3IE11bHRpVGV4dEVkaXQoKTsKKyAgICAgICAgY2hhbmdlLnNldEVkaXQobXVsdGlUZXh0RWRpdCk7CisKKyAgICAgICAgVGV4dEVkaXQgdGV4dEVkaXQgPSBBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlQW5ub3RhdGlvblRleHRFZGl0KGphdmFFbGVtZW50LCBhbm5vdGF0aW9uKTsKKyAgICAgICAgY2hhbmdlLmFkZEVkaXQodGV4dEVkaXQpOworICAgICAgICBhcHBseUNoYW5nZShudWxsLCBjaGFuZ2UpOworICAgIH0KKworICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBhZGRNZW1iZXJWYWx1ZVBhaXIoTm9ybWFsQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisgICAgICAgIGlmIChhbm5vdGF0aW9uLmdldFJvb3QoKSBpbnN0YW5jZW9mIENvbXBpbGF0aW9uVW5pdCkgeworICAgICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IChDb21waWxhdGlvblVuaXQpIGFubm90YXRpb24uZ2V0Um9vdCgpOworICAgICAgICAgICAgVGV4dEZpbGVDaGFuZ2UgY2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJBZGQgTWVtYmVyIFZhbHVlIFBhaXIiLCAoSUZpbGUpIGNvbXBpbGF0aW9uVW5pdC5nZXRKYXZhRWxlbWVudCgpLmdldFJlc291cmNlKCkpOworICAgICAgICAgICAgTXVsdGlUZXh0RWRpdCBtdWx0aVRleHRFZGl0ID0gbmV3IE11bHRpVGV4dEVkaXQoKTsKKyAgICAgICAgICAgIGNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOworCisgICAgICAgICAgICBUZXh0RWRpdCBhbm5vdGF0aW9uRWRpdCA9IEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRNZW1iZXJWYWx1ZVBhaXJUZXh0RWRpdChhbm5vdGF0aW9uLCBtZW1iZXJWYWx1ZVBhaXIpOworICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoYW5ub3RhdGlvbkVkaXQpOworICAgICAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHB1YmxpYyBzdGF0aWMgdm9pZCByZW1vdmVNZW1iZXJWYWx1ZVBhaXIoTm9ybWFsQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisgICAgICAgIGlmIChhbm5vdGF0aW9uLmdldFJvb3QoKSBpbnN0YW5jZW9mIENvbXBpbGF0aW9uVW5pdCkgeworICAgICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IChDb21waWxhdGlvblVuaXQpIGFubm90YXRpb24uZ2V0Um9vdCgpOworICAgICAgICAgICAgVGV4dEZpbGVDaGFuZ2UgY2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJSZW1vdmUgTWVtYmVyIFZhbHVlIFBhaXIiLCAoSUZpbGUpIGNvbXBpbGF0aW9uVW5pdC5nZXRKYXZhRWxlbWVudCgpLmdldFJlc291cmNlKCkpOworICAgICAgICAgICAgTXVsdGlUZXh0RWRpdCBtdWx0aVRleHRFZGl0ID0gbmV3IE11bHRpVGV4dEVkaXQoKTsKKyAgICAgICAgICAgIGNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOworCisgICAgICAgICAgICBUZXh0RWRpdCBhbm5vdGF0aW9uRWRpdCA9IEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVNZW1iZXJWYWx1ZVBhaXJUZXh0RWRpdChhbm5vdGF0aW9uLCBtZW1iZXJWYWx1ZVBhaXIpOworICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoYW5ub3RhdGlvbkVkaXQpOworICAgICAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHB1YmxpYyBzdGF0aWMgdm9pZCB1cGRhdGVNZW1iZXJWYWx1ZVBhaXIoTWVtYmVyVmFsdWVQYWlyIG1lbWJlclZhbHVlUGFpciwgQVNUTm9kZSB2YWx1ZSkgdGhyb3dzIENvcmVFeGNlcHRpb24geworICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyLmdldFJvb3QoKSBpbnN0YW5jZW9mIENvbXBpbGF0aW9uVW5pdCkgeworICAgICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IChDb21waWxhdGlvblVuaXQpIG1lbWJlclZhbHVlUGFpci5nZXRSb290KCk7CisgICAgICAgICAgICBUZXh0RmlsZUNoYW5nZSBjaGFuZ2UgPSBuZXcgVGV4dEZpbGVDaGFuZ2UoIlVwZGF0ZSBNZW1iZXIgVmFsdWUgUGFpciIsIChJRmlsZSkgY29tcGlsYXRpb25Vbml0LmdldEphdmFFbGVtZW50KCkuZ2V0UmVzb3VyY2UoKSk7CisgICAgICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOworICAgICAgICAgICAgY2hhbmdlLnNldEVkaXQobXVsdGlUZXh0RWRpdCk7CisKKyAgICAgICAgICAgIFRleHRFZGl0IGFubm90YXRpb25FZGl0ID0gQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVVwZGF0ZU1lbWJlclZhbHVlUGFpclRleHRFZGl0KG1lbWJlclZhbHVlUGFpciwgdmFsdWUpOworICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoYW5ub3RhdGlvbkVkaXQpOworICAgICAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHB1YmxpYyBzdGF0aWMgdm9pZCB1cGRhdGVTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKFNpbmdsZU1lbWJlckFubm90YXRpb24gYW5ub3RhdGlvbiwgQVNUTm9kZSB2YWx1ZSkgIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKyAgICAgICAgaWYgKGFubm90YXRpb24uZ2V0Um9vdCgpIGluc3RhbmNlb2YgQ29tcGlsYXRpb25Vbml0KSB7CisgICAgICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gKENvbXBpbGF0aW9uVW5pdCkgYW5ub3RhdGlvbi5nZXRSb290KCk7CisgICAgICAgICAgICBUZXh0RmlsZUNoYW5nZSBjaGFuZ2UgPSBuZXcgVGV4dEZpbGVDaGFuZ2UoIlVwZGF0ZSBTaW5nbGUgTWVtYmVyIEFubm90YXRpb24iLCAoSUZpbGUpIGNvbXBpbGF0aW9uVW5pdC5nZXRKYXZhRWxlbWVudCgpLmdldFJlc291cmNlKCkpOworICAgICAgICAgICAgTXVsdGlUZXh0RWRpdCBtdWx0aVRleHRFZGl0ID0gbmV3IE11bHRpVGV4dEVkaXQoKTsKKyAgICAgICAgICAgIGNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOworCisgICAgICAgICAgICBUZXh0RWRpdCBhbm5vdGF0aW9uRWRpdCA9IEFubm90YXRpb25VdGlscy5jcmVhdGVVcGRhdGVTaW5nbGVNZW1iZXJBbm5vdGF0aW9uVGV4dEVkaXQoYW5ub3RhdGlvbiwgdmFsdWUpOworICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoYW5ub3RhdGlvbkVkaXQpOworICAgICAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHB1YmxpYyBzdGF0aWMgVGV4dEVkaXQgY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBTdHJpbmcgcXVhbGlmaWVkTmFtZSkgdGhyb3dzIENvcmVFeGNlcHRpb24gewogICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKGdldENvbXBpbGF0aW9uVW5pdEZyb21KYXZhRWxlbWVudChqYXZhRWxlbWVudCksIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKLSAgICAgICAgU3RyaW5nIHF1YWxpZmllZE5hbWUgPSBhbm5vdGF0aW9uLmdldENhbm9uaWNhbE5hbWUoKTsKICAgICAgICAgSW1wb3J0UmV3cml0ZSBpbXBvcnRSZXdyaXRlID0gQ29kZVN0eWxlQ29uZmlndXJhdGlvbi5jcmVhdGVJbXBvcnRSZXdyaXRlKGNvbXBpbGF0aW9uVW5pdCwgdHJ1ZSk7CiAgICAgICAgIGltcG9ydFJld3JpdGUuYWRkSW1wb3J0KHF1YWxpZmllZE5hbWUpOwogICAgICAgICByZXR1cm4gaW1wb3J0UmV3cml0ZS5yZXdyaXRlSW1wb3J0cyhudWxsKTsKICAgICB9CiAKICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLSAgICBwdWJsaWMgc3RhdGljIFRleHRFZGl0IGNyZWF0ZVJlbW92ZUltcG9ydFRleHRFZGl0KElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwKLSAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisgICAgcHVibGljIHN0YXRpYyBUZXh0RWRpdCBjcmVhdGVSZW1vdmVJbXBvcnRUZXh0RWRpdChJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIFN0cmluZyBxdWFsaWZpZWROYW1lKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CiAgICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1QoZ2V0Q29tcGlsYXRpb25Vbml0RnJvbUphdmFFbGVtZW50KGphdmFFbGVtZW50KSwgU2hhcmVkQVNUUHJvdmlkZXIuV0FJVF9ZRVMsIG51bGwpOwotICAgICAgICBTdHJpbmcgcXVhbGlmaWVkTmFtZSA9IGFubm90YXRpb24uZ2V0Q2Fub25pY2FsTmFtZSgpOwogICAgICAgICBJbXBvcnRSZXdyaXRlIGltcG9ydFJld3JpdGUgPSBDb2RlU3R5bGVDb25maWd1cmF0aW9uLmNyZWF0ZUltcG9ydFJld3JpdGUoY29tcGlsYXRpb25Vbml0LCB0cnVlKTsKLSAgICAgICAgZmluYWwgU3RyaW5nIGFubm90YXRpb25TaW1wbGVOYW1lID0gYW5ub3RhdGlvbi5nZXRTaW1wbGVOYW1lKCk7CisgICAgICAgIGZpbmFsIFN0cmluZyBhbm5vdGF0aW9uU2ltcGxlTmFtZSA9IHF1YWxpZmllZE5hbWUuc3Vic3RyaW5nKHF1YWxpZmllZE5hbWUubGFzdEluZGV4T2YoIi4iKSArIDEpOwogICAgICAgICBmaW5hbCBMaXN0PFN0cmluZz4gb2NjdXJlbmNlcyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwotICAgICAgICBUYXJnZXQgdGFyZ2V0ID0gYW5ub3RhdGlvbi5nZXRBbm5vdGF0aW9uKFRhcmdldC5jbGFzcyk7Ci0gICAgICAgIExpc3Q8RWxlbWVudFR5cGU+IGVsZW1lbnRUeXBlcyA9IEFycmF5cy5hc0xpc3QodGFyZ2V0LnZhbHVlKCkpOworICAgICAgICBBbm5vdGF0aW9uRGVmaW5pdGlvbiBhbm5vdGF0aW9uRGVmaW5pdGlvbiA9IEFubm90YXRpb25zTWFuYWdlci5nZXRBbm5vdGF0aW9uRGVmaW5pdGlvbkZvckNsYXNzKHF1YWxpZmllZE5hbWUpOworICAgICAgICBMaXN0PEVsZW1lbnRUeXBlPiBlbGVtZW50VHlwZXMgPSBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKKyAgICAgICAgaWYgKGFubm90YXRpb25EZWZpbml0aW9uICE9IG51bGwpIHsKKyAgICAgICAgICAgIGVsZW1lbnRUeXBlcyA9IGFubm90YXRpb25EZWZpbml0aW9uLmdldFRhcmdldHMoKTsKKyAgICAgICAgfQogICAgICAgICBmb3IgKEVsZW1lbnRUeXBlIGVsZW1lbnRUeXBlIDogZWxlbWVudFR5cGVzKSB7CiAgICAgICAgICAgICBpZiAoZWxlbWVudFR5cGUgPT0gRWxlbWVudFR5cGUuUEFDS0FHRSkgewogICAgICAgICAgICAgICAgIGNvbXBpbGF0aW9uVW5pdC5hY2NlcHQobmV3IEFTVFZpc2l0b3IoKSB7CkBAIC0yMzYsMjAgKzMxNiw2IEBACiAgICAgICAgIH0KICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIHZvaWQgYWRkQW5ub3RhdGlvbihJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIEFubm90YXRpb24gYW5ub3RhdGlvbikgdGhyb3dzIENvcmVFeGNlcHRpb24gewotICAgICAgICBUZXh0Q2hhbmdlIGNoYW5nZSA9IEFubm90YXRpb25VdGlscy5jcmVhdGVUZXh0RmlsZUNoYW5nZSgiQWRkIGFubm90YXRpb24iLCAoSUZpbGUpIGphdmFFbGVtZW50LmdldFJlc291cmNlKCkpOwotICAgICAgICBUZXh0RWRpdCBhbm5vdGF0aW9uRWRpdCA9IGNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChqYXZhRWxlbWVudCwgYW5ub3RhdGlvbik7Ci0gICAgICAgIGNoYW5nZS5hZGRFZGl0KGFubm90YXRpb25FZGl0KTsKLSAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKLSAgICB9Ci0KLSAgICBwdWJsaWMgc3RhdGljIHZvaWQgcmVtb3ZlQW5ub3RhdGlvbihJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIEFubm90YXRpb24gYW5ub3RhdGlvbikgdGhyb3dzIENvcmVFeGNlcHRpb24gewotICAgICAgICBUZXh0RWRpdCB0ZXh0RWRpdCA9IGNyZWF0ZVJlbW92ZUFubm90YXRpb25UZXh0RWRpdChqYXZhRWxlbWVudCwgYW5ub3RhdGlvbik7Ci0gICAgICAgIFRleHRDaGFuZ2UgY2hhbmdlID0gQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVRleHRGaWxlQ2hhbmdlKCJBZGQgYW5ub3RhdGlvbiIsIChJRmlsZSkgamF2YUVsZW1lbnQuZ2V0UmVzb3VyY2UoKSk7Ci0gICAgICAgIGNoYW5nZS5hZGRFZGl0KHRleHRFZGl0KTsKLSAgICAgICAgYXBwbHlDaGFuZ2UobnVsbCwgY2hhbmdlKTsKLSAgICB9Ci0KICAgICBwcml2YXRlIHN0YXRpYyB2b2lkIGFwcGx5Q2hhbmdlKElQcm9ncmVzc01vbml0b3IgbW9uaXRvciwgQ2hhbmdlIGNoYW5nZSkgewogICAgICAgICBpZiAoY2hhbmdlID09IG51bGwpIHsKICAgICAgICAgICAgIHJldHVybjsKQEAgLTI4MSwyNCArMzQ3LDYgQEAKICAgICAgICAgfQogICAgIH0KIAotICAgIHByaXZhdGUgc3RhdGljIElEb2N1bWVudCBnZXREb2N1bWVudChJQ29tcGlsYXRpb25Vbml0IHNvdXJjZSkgdGhyb3dzIENvcmVFeGNlcHRpb24gewotICAgICAgICBJVGV4dEZpbGVCdWZmZXJNYW5hZ2VyIGJ1ZmZlck1hbmFnZXIgPSBGaWxlQnVmZmVycy5nZXRUZXh0RmlsZUJ1ZmZlck1hbmFnZXIoKTsKLSAgICAgICAgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yID0gbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKTsKLQotICAgICAgICBJUGF0aCBwYXRoID0gc291cmNlLmdldFJlc291cmNlKCkuZ2V0RnVsbFBhdGgoKTsKLSAgICAgICAgYm9vbGVhbiBjb25uZWN0ZWQgPSBmYWxzZTsKLSAgICAgICAgdHJ5IHsKLSAgICAgICAgICAgIGJ1ZmZlck1hbmFnZXIuY29ubmVjdChwYXRoLCBMb2NhdGlvbktpbmQuSUZJTEUsIG1vbml0b3IpOwotICAgICAgICAgICAgY29ubmVjdGVkID0gdHJ1ZTsKLSAgICAgICAgICAgIElEb2N1bWVudCBkb2N1bWVudCA9IGJ1ZmZlck1hbmFnZXIuZ2V0VGV4dEZpbGVCdWZmZXIocGF0aCwgTG9jYXRpb25LaW5kLklGSUxFKS5nZXREb2N1bWVudCgpOwotICAgICAgICAgICAgcmV0dXJuIGRvY3VtZW50OwotICAgICAgICB9IGZpbmFsbHkgewotICAgICAgICAgICAgaWYgKGNvbm5lY3RlZCkgewotICAgICAgICAgICAgICAgIGJ1ZmZlck1hbmFnZXIuZGlzY29ubmVjdChwYXRoLCBMb2NhdGlvbktpbmQuSUZJTEUsIG1vbml0b3IpOwotICAgICAgICAgICAgfQotICAgICAgICB9Ci0gICAgfQotCiAgICAgcHJpdmF0ZSBzdGF0aWMgVGV4dEVkaXQgY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KElQYWNrYWdlRGVjbGFyYXRpb24gcGFja2FnZURlY2xhcmF0aW9uLCBBbm5vdGF0aW9uIGFubm90YXRpb24pIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKICAgICAgICAgaWYgKHBhY2thZ2VEZWNsYXJhdGlvbiAhPSBudWxsICYmICFpc0Fubm90YXRpb25QcmVzZW50KHBhY2thZ2VEZWNsYXJhdGlvbiwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSkgewogICAgICAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSBnZXRDb21waWxhdGlvblVuaXRGcm9tSmF2YUVsZW1lbnQocGFja2FnZURlY2xhcmF0aW9uKTsKQEAgLTMzMSwyMiArMzc5LDE3IEBACiAgICAgICAgICAgICAgICAgICAgIGxpc3RSZXdyaXRlLnJlbW92ZSgoQW5ub3RhdGlvbikgb2JqZWN0LCBudWxsKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9Ci0KICAgICAgICAgICAgIHJldHVybiByZXdyaXRlci5yZXdyaXRlQVNUKCk7CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIG5ldyBNdWx0aVRleHRFZGl0KCk7CiAgICAgfQogCiAgICAgcHJpdmF0ZSBzdGF0aWMgVGV4dEVkaXQgY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KElUeXBlIHR5cGUsIEFubm90YXRpb24gYW5ub3RhdGlvbikgdGhyb3dzIENvcmVFeGNlcHRpb24gewotICAgICAgICBJQ29tcGlsYXRpb25Vbml0IHNvdXJjZSA9IHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCk7Ci0gICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7CisgICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbih0eXBlKTsKKyAgICAgICAgaWYodHlwZURlY2xhcmF0aW9uICE9IG51bGwgJiYgIWlzQW5ub3RhdGlvblByZXNlbnQodHlwZSwgYW5ub3RhdGlvbikpIHsKKyAgICAgICAgICAgIEFTVFJld3JpdGUgcmV3cml0ZXIgPSBBU1RSZXdyaXRlLmNyZWF0ZSh0eXBlRGVjbGFyYXRpb24uZ2V0QVNUKCkpOwogCi0gICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbihjb21waWxhdGlvblVuaXQsIHR5cGUpOwotICAgICAgICBpZih0eXBlRGVjbGFyYXRpb24gIT0gbnVsbCAmJiAhaXNBbm5vdGF0aW9uUHJlc2VudCh0eXBlRGVjbGFyYXRpb24sIGFubm90YXRpb24pKSB7Ci0gICAgICAgICAgICBBU1RSZXdyaXRlIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoY29tcGlsYXRpb25Vbml0LmdldEFTVCgpKTsKLQotICAgICAgICAgICAgTGlzdFJld3JpdGUgbGlzdFJld3JpdGUgPSByZXdyaXRlci5nZXRMaXN0UmV3cml0ZSh0eXBlRGVjbGFyYXRpb24sCi0gICAgICAgICAgICAgICAgICAgIGdldENoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvckZvclR5cGUodHlwZURlY2xhcmF0aW9uKSk7CisgICAgICAgICAgICBMaXN0UmV3cml0ZSBsaXN0UmV3cml0ZSA9IHJld3JpdGVyLmdldExpc3RSZXdyaXRlKHR5cGVEZWNsYXJhdGlvbiwgZ2V0Q2hpbGRMaXN0UHJvcGVydHlEZXNjcmlwdG9yRm9yVHlwZSh0eXBlRGVjbGFyYXRpb24pKTsKIAogICAgICAgICAgICAgbGlzdFJld3JpdGUuaW5zZXJ0Rmlyc3QoYW5ub3RhdGlvbiwgbnVsbCk7CiAKQEAgLTM1NiwxNSArMzk5LDExIEBACiAgICAgfQogCiAgICAgcHJpdmF0ZSBzdGF0aWMgVGV4dEVkaXQgY3JlYXRlUmVtb3ZlQW5ub3RhdGlvblRleHRFZGl0KElUeXBlIHR5cGUsIEFubm90YXRpb24gYW5ub3RhdGlvbikgdGhyb3dzIENvcmVFeGNlcHRpb24gewotICAgICAgICBJQ29tcGlsYXRpb25Vbml0IHNvdXJjZSA9IHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCk7Ci0gICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7CisgICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbih0eXBlKTsKKyAgICAgICAgaWYgKHR5cGVEZWNsYXJhdGlvbiAhPSBudWxsICYmIGlzQW5ub3RhdGlvblByZXNlbnQodHlwZSwgYW5ub3RhdGlvbikpIHsKKyAgICAgICAgICAgIEFTVFJld3JpdGUgcmV3cml0ZXIgPSBBU1RSZXdyaXRlLmNyZWF0ZSh0eXBlRGVjbGFyYXRpb24uZ2V0QVNUKCkpOwogCi0gICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbihjb21waWxhdGlvblVuaXQsIHR5cGUpOwotICAgICAgICBpZiAodHlwZURlY2xhcmF0aW9uICE9IG51bGwgJiYgaXNBbm5vdGF0aW9uUHJlc2VudCh0eXBlRGVjbGFyYXRpb24sIGFubm90YXRpb24pKSB7Ci0gICAgICAgICAgICBBU1RSZXdyaXRlIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoY29tcGlsYXRpb25Vbml0LmdldEFTVCgpKTsKLQotICAgICAgICAgICAgTGlzdFJld3JpdGUgbGlzdFJld3JpdGUgPSByZXdyaXRlci5nZXRMaXN0UmV3cml0ZSh0eXBlRGVjbGFyYXRpb24sCi0gICAgICAgICAgICAgICAgICAgIGdldENoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvckZvclR5cGUodHlwZURlY2xhcmF0aW9uKSk7CisgICAgICAgICAgICBMaXN0UmV3cml0ZSBsaXN0UmV3cml0ZSA9IHJld3JpdGVyLmdldExpc3RSZXdyaXRlKHR5cGVEZWNsYXJhdGlvbiwgZ2V0Q2hpbGRMaXN0UHJvcGVydHlEZXNjcmlwdG9yRm9yVHlwZSh0eXBlRGVjbGFyYXRpb24pKTsKIAogICAgICAgICAgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCiAgICAgICAgICAgICBMaXN0IG9yaWdpbmFsTGlzdCA9IGxpc3RSZXdyaXRlLmdldE9yaWdpbmFsTGlzdCgpOwpAQCAtMzczLDIyICs0MTIsMTggQEAKICAgICAgICAgICAgICAgICAgICAgbGlzdFJld3JpdGUucmVtb3ZlKChBbm5vdGF0aW9uKW9iamVjdCwgbnVsbCk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQotCiAgICAgICAgICAgICByZXR1cm4gcmV3cml0ZXIucmV3cml0ZUFTVCgpOwogICAgICAgICB9CiAgICAgICAgIHJldHVybiBuZXcgTXVsdGlUZXh0RWRpdCgpOwogICAgIH0KIAogICAgIHByaXZhdGUgc3RhdGljIFRleHRFZGl0IGNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChJTWV0aG9kIG1ldGhvZCwgQW5ub3RhdGlvbiBhbm5vdGF0aW9uKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7Ci0gICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gbWV0aG9kLmdldENvbXBpbGF0aW9uVW5pdCgpOwotICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKHNvdXJjZSwgU2hhcmVkQVNUUHJvdmlkZXIuV0FJVF9ZRVMsIG51bGwpOworICAgICAgICBNZXRob2REZWNsYXJhdGlvbiBtZXRob2REZWNsYXJhdGlvbiA9IGdldE1ldGhvZERlY2xhcmF0aW9uKG1ldGhvZCk7CisgICAgICAgIGlmIChtZXRob2REZWNsYXJhdGlvbiAhPSBudWxsICYmICFpc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgYW5ub3RhdGlvbikpIHsKKyAgICAgICAgICAgIEFTVFJld3JpdGUgcmV3cml0ZXIgPSBBU1RSZXdyaXRlLmNyZWF0ZShtZXRob2REZWNsYXJhdGlvbi5nZXRBU1QoKSk7CiAKLSAgICAgICAgQm9keURlY2xhcmF0aW9uIGJvZHlEZWNsYXJhdGlvbiA9IGdldE1ldGhvZERlY2xhcmF0aW9uKGNvbXBpbGF0aW9uVW5pdCwgbWV0aG9kKTsKLSAgICAgICAgaWYgKGJvZHlEZWNsYXJhdGlvbiAhPSBudWxsICYmICFpc0Fubm90YXRpb25QcmVzZW50KGJvZHlEZWNsYXJhdGlvbiwgYW5ub3RhdGlvbikpIHsKLSAgICAgICAgICAgIEFTVFJld3JpdGUgcmV3cml0ZXIgPSBBU1RSZXdyaXRlLmNyZWF0ZShjb21waWxhdGlvblVuaXQuZ2V0QVNUKCkpOworICAgICAgICAgICAgTGlzdFJld3JpdGUgbGlzdFJld3JpdGUgPSByZXdyaXRlci5nZXRMaXN0UmV3cml0ZShtZXRob2REZWNsYXJhdGlvbiwgIE1ldGhvZERlY2xhcmF0aW9uLk1PRElGSUVSUzJfUFJPUEVSVFkpOwogCi0gICAgICAgICAgICBMaXN0UmV3cml0ZSBsaXN0UmV3cml0ZSA9IHJld3JpdGVyLmdldExpc3RSZXdyaXRlKGJvZHlEZWNsYXJhdGlvbiwKLSAgICAgICAgICAgICAgICAgICAgZ2V0Q2hpbGRMaXN0UHJvcGVydHlEZXNjcmlwdG9yRm9yTWV0aG9kKGJvZHlEZWNsYXJhdGlvbikpOwogICAgICAgICAgICAgbGlzdFJld3JpdGUuaW5zZXJ0QXQoYW5ub3RhdGlvbiwgMCwgbnVsbCk7CiAKICAgICAgICAgICAgIHJldHVybiByZXdyaXRlci5yZXdyaXRlQVNUKCk7CkBAIC0zOTcsMTUgKzQzMiwxMSBAQAogICAgIH0KIAogICAgIHByaXZhdGUgc3RhdGljIFRleHRFZGl0IGNyZWF0ZVJlbW92ZUFubm90YXRpb25UZXh0RWRpdChJTWV0aG9kIG1ldGhvZCwgQW5ub3RhdGlvbiBhbm5vdGF0aW9uKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7Ci0gICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gbWV0aG9kLmdldENvbXBpbGF0aW9uVW5pdCgpOwotICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKHNvdXJjZSwgU2hhcmVkQVNUUHJvdmlkZXIuV0FJVF9ZRVMsIG51bGwpOworICAgICAgICBNZXRob2REZWNsYXJhdGlvbiBtZXRob2REZWNsYXJhdGlvbiA9IGdldE1ldGhvZERlY2xhcmF0aW9uKG1ldGhvZCk7CisgICAgICAgIGlmIChtZXRob2REZWNsYXJhdGlvbiAhPSBudWxsICYmIGlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCBhbm5vdGF0aW9uKSkgeworICAgICAgICAgICAgQVNUUmV3cml0ZSByZXdyaXRlciA9IEFTVFJld3JpdGUuY3JlYXRlKG1ldGhvZERlY2xhcmF0aW9uLmdldEFTVCgpKTsKIAotICAgICAgICBCb2R5RGVjbGFyYXRpb24gYm9keURlY2xhcmF0aW9uID0gZ2V0TWV0aG9kRGVjbGFyYXRpb24oY29tcGlsYXRpb25Vbml0LCBtZXRob2QpOwotICAgICAgICBpZiAoYm9keURlY2xhcmF0aW9uICE9IG51bGwgJiYgaXNBbm5vdGF0aW9uUHJlc2VudChib2R5RGVjbGFyYXRpb24sIGFubm90YXRpb24pKSB7Ci0gICAgICAgICAgICBBU1RSZXdyaXRlIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoY29tcGlsYXRpb25Vbml0LmdldEFTVCgpKTsKLQotICAgICAgICAgICAgTGlzdFJld3JpdGUgbGlzdFJld3JpdGUgPSByZXdyaXRlci5nZXRMaXN0UmV3cml0ZShib2R5RGVjbGFyYXRpb24sCi0gICAgICAgICAgICAgICAgICAgIGdldENoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvckZvck1ldGhvZChib2R5RGVjbGFyYXRpb24pKTsKKyAgICAgICAgICAgIExpc3RSZXdyaXRlIGxpc3RSZXdyaXRlID0gcmV3cml0ZXIuZ2V0TGlzdFJld3JpdGUobWV0aG9kRGVjbGFyYXRpb24sICBNZXRob2REZWNsYXJhdGlvbi5NT0RJRklFUlMyX1BST1BFUlRZKTsKIAogICAgICAgICAgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCiAgICAgICAgICAgICBMaXN0IG9yaWdpbmFsTGlzdCA9IGxpc3RSZXdyaXRlLmdldE9yaWdpbmFsTGlzdCgpOwpAQCAtNDE2LDE4ICs0NDcsMTQgQEAKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIHJldHVybiByZXdyaXRlci5yZXdyaXRlQVNUKCk7CiAgICAgICAgIH0KLQogICAgICAgICByZXR1cm4gbmV3IE11bHRpVGV4dEVkaXQoKTsKICAgICB9CiAKICAgICBwcml2YXRlIHN0YXRpYyBUZXh0RWRpdCBjcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQoSUZpZWxkIGZpZWxkLCBBbm5vdGF0aW9uIGFubm90YXRpb24pIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKLSAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSBmaWVsZC5nZXRDb21waWxhdGlvblVuaXQoKTsKLSAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IFNoYXJlZEFTVFByb3ZpZGVyLmdldEFTVChzb3VyY2UsIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKKyAgICAgICAgRmllbGREZWNsYXJhdGlvbiBmaWVsZERlY2xhcmF0aW9uID0gZ2V0RmllbGREZWNsYXJhdGlvbihmaWVsZCk7CisgICAgICAgIGlmIChmaWVsZERlY2xhcmF0aW9uICE9IG51bGwgJiYgIWlzQW5ub3RhdGlvblByZXNlbnQoZmllbGQsIGFubm90YXRpb24pKSB7CiAKLSAgICAgICAgRmllbGREZWNsYXJhdGlvbiBmaWVsZERlY2xhcmF0aW9uID0gZ2V0RmllbGREZWNsYXJhdGlvbihjb21waWxhdGlvblVuaXQsIGZpZWxkKTsKLSAgICAgICAgaWYgKGZpZWxkRGVjbGFyYXRpb24gIT0gbnVsbCAmJiAhaXNBbm5vdGF0aW9uUHJlc2VudChmaWVsZERlY2xhcmF0aW9uLCBhbm5vdGF0aW9uKSkgewotCi0gICAgICAgICAgICBBU1RSZXdyaXRlIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoY29tcGlsYXRpb25Vbml0LmdldEFTVCgpKTsKKyAgICAgICAgICAgIEFTVFJld3JpdGUgcmV3cml0ZXIgPSBBU1RSZXdyaXRlLmNyZWF0ZShmaWVsZERlY2xhcmF0aW9uLmdldEFTVCgpKTsKIAogICAgICAgICAgICAgTGlzdFJld3JpdGUgbGlzdFJld3JpdGUgPSByZXdyaXRlci5nZXRMaXN0UmV3cml0ZShmaWVsZERlY2xhcmF0aW9uLCBGaWVsZERlY2xhcmF0aW9uLk1PRElGSUVSUzJfUFJPUEVSVFkpOwogICAgICAgICAgICAgbGlzdFJld3JpdGUuaW5zZXJ0QXQoYW5ub3RhdGlvbiwgMCwgbnVsbCk7CkBAIC00MzksMTQgKzQ2Niw5IEBACiAgICAgfQogCiAgICAgcHJpdmF0ZSBzdGF0aWMgVGV4dEVkaXQgY3JlYXRlUmVtb3ZlQW5ub3RhdGlvblRleHRFZGl0KElGaWVsZCBmaWVsZCwgQW5ub3RhdGlvbiBhbm5vdGF0aW9uKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7Ci0gICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gZmllbGQuZ2V0Q29tcGlsYXRpb25Vbml0KCk7Ci0gICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7Ci0KLSAgICAgICAgRmllbGREZWNsYXJhdGlvbiBmaWVsZERlY2xhcmF0aW9uID0gZ2V0RmllbGREZWNsYXJhdGlvbihjb21waWxhdGlvblVuaXQsIGZpZWxkKTsKLQotICAgICAgICBpZiAoZmllbGREZWNsYXJhdGlvbiAhPSBudWxsICYmIGlzQW5ub3RhdGlvblByZXNlbnQoZmllbGREZWNsYXJhdGlvbiwgYW5ub3RhdGlvbikpIHsKLQotICAgICAgICAgICAgQVNUUmV3cml0ZSByZXdyaXRlciA9IEFTVFJld3JpdGUuY3JlYXRlKGNvbXBpbGF0aW9uVW5pdC5nZXRBU1QoKSk7CisgICAgICAgIEZpZWxkRGVjbGFyYXRpb24gZmllbGREZWNsYXJhdGlvbiA9IGdldEZpZWxkRGVjbGFyYXRpb24oZmllbGQpOworICAgICAgICBpZiAoZmllbGREZWNsYXJhdGlvbiAhPSBudWxsICYmIGlzQW5ub3RhdGlvblByZXNlbnQoZmllbGQsIGFubm90YXRpb24pKSB7CisgICAgICAgICAgICBBU1RSZXdyaXRlIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoZmllbGREZWNsYXJhdGlvbi5nZXRBU1QoKSk7CiAKICAgICAgICAgICAgIExpc3RSZXdyaXRlIGxpc3RSZXdyaXRlID0gcmV3cml0ZXIuZ2V0TGlzdFJld3JpdGUoZmllbGREZWNsYXJhdGlvbiwgRmllbGREZWNsYXJhdGlvbi5NT0RJRklFUlMyX1BST1BFUlRZKTsKIApAQCAtNDU3LDEwICs0NzksOCBAQAogICAgICAgICAgICAgICAgICAgICBsaXN0UmV3cml0ZS5yZW1vdmUoKEFubm90YXRpb24pIG9iamVjdCwgbnVsbCk7CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQotCiAgICAgICAgICAgICByZXR1cm4gcmV3cml0ZXIucmV3cml0ZUFTVCgpOwogICAgICAgICB9Ci0KICAgICAgICAgcmV0dXJuIG5ldyBNdWx0aVRleHRFZGl0KCk7CiAgICAgfQogCkBAIC01MDUsMTQgKzUyNSwyNSBAQAogCiAgICAgICAgIGxpc3RSZXdyaXRlLmluc2VydExhc3QobWVtYmVyVmFsdWVQYWlyLCBudWxsKTsKIAotICAgICAgICBpZiAoYW5ub3RhdGlvbi5nZXRSb290KCkgaW5zdGFuY2VvZiBDb21waWxhdGlvblVuaXQpIHsKLSAgICAgICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSAoQ29tcGlsYXRpb25Vbml0KSBhbm5vdGF0aW9uLmdldFJvb3QoKTsKLSAgICAgICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gQW5ub3RhdGlvblV0aWxzLmdldENvbXBpbGF0aW9uVW5pdEZyb21KYXZhRWxlbWVudChjb21waWxhdGlvblVuaXQuZ2V0SmF2YUVsZW1lbnQoKSk7Ci0gICAgICAgICAgICBJRG9jdW1lbnQgZG9jdW1lbnQgPSBnZXREb2N1bWVudChzb3VyY2UpOwotICAgICAgICAgICAgcmV0dXJuIHJld3JpdGVyLnJld3JpdGVBU1QoZG9jdW1lbnQsIGdldE9wdGlvbnMoc291cmNlKSk7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICByZXR1cm4gcmV3cml0ZXIucmV3cml0ZUFTVCgpOworICAgICAgICByZXR1cm4gcmV3cml0ZXIucmV3cml0ZUFTVCgpOworICAgIH0KKworICAgIHB1YmxpYyBzdGF0aWMgVGV4dEVkaXQgY3JlYXRlUmVtb3ZlTWVtYmVyVmFsdWVQYWlyVGV4dEVkaXQoTm9ybWFsQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisgICAgICAgIEFTVFJld3JpdGUgcmV3cml0ZXIgPSBBU1RSZXdyaXRlLmNyZWF0ZShhbm5vdGF0aW9uLmdldEFTVCgpKTsKKworICAgICAgICBMaXN0UmV3cml0ZSBsaXN0UmV3cml0ZSA9IHJld3JpdGVyLmdldExpc3RSZXdyaXRlKGFubm90YXRpb24sIE5vcm1hbEFubm90YXRpb24uVkFMVUVTX1BST1BFUlRZKTsKKworICAgICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKKyAgICAgICAgTGlzdCBvcmlnaW5hbExpc3QgPSBsaXN0UmV3cml0ZS5nZXRPcmlnaW5hbExpc3QoKTsKKyAgICAgICAgZm9yIChPYmplY3Qgb2JqZWN0IDogb3JpZ2luYWxMaXN0KSB7CisgICAgICAgICAgICBpZiAob2JqZWN0IGluc3RhbmNlb2YgTWVtYmVyVmFsdWVQYWlyKSB7CisgICAgICAgICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIG12cCA9IChNZW1iZXJWYWx1ZVBhaXIpIG9iamVjdDsKKyAgICAgICAgICAgICAgICBpZiAobXZwLmdldE5hbWUoKS5nZXRJZGVudGlmaWVyKCkuZXF1YWxzKG1lbWJlclZhbHVlUGFpci5nZXROYW1lKCkuZ2V0SWRlbnRpZmllcigpKSkgeworICAgICAgICAgICAgICAgICAgICBsaXN0UmV3cml0ZS5yZW1vdmUobXZwLCBudWxsKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CiAgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHJld3JpdGVyLnJld3JpdGVBU1QoKTsKICAgICB9CiAKICAgICBwdWJsaWMgc3RhdGljIFRleHRFZGl0IGNyZWF0ZVVwZGF0ZU1lbWJlclZhbHVlUGFpclRleHRFZGl0KE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIsIEFTVE5vZGUgdmFsdWUpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKQEAgLTU1OCw3ICs1ODksOCBAQAogICAgIH0KIAogICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotICAgIHByaXZhdGUgc3RhdGljIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIGdldFR5cGVEZWNsYXJhdGlvbihDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0LCBJVHlwZSB0eXBlKSB7CisgICAgcHVibGljIHN0YXRpYyBBYnN0cmFjdFR5cGVEZWNsYXJhdGlvbiBnZXRUeXBlRGVjbGFyYXRpb24oSVR5cGUgdHlwZSkgeworICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCksIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKICAgICAgICAgTGlzdDxUeXBlRGVjbGFyYXRpb24+IHR5cGVzID0gY29tcGlsYXRpb25Vbml0LnR5cGVzKCk7CiAgICAgICAgIGZvciAoQWJzdHJhY3RUeXBlRGVjbGFyYXRpb24gYWJzdHJhY3RUeXBlRGVjbGFyYXRpb24gOiB0eXBlcykgewogICAgICAgICAgICAgaWYgKGNvbXBhcmVUeXBlTmFtZXMoYWJzdHJhY3RUeXBlRGVjbGFyYXRpb24sIHR5cGUpKSB7CkBAIC01NjksMTkgKzYwMSwxNSBAQAogICAgIH0KIAogICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotICAgIHByaXZhdGUgc3RhdGljIEJvZHlEZWNsYXJhdGlvbiBnZXRNZXRob2REZWNsYXJhdGlvbihDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0LCBJTWV0aG9kIG1ldGhvZCkgewotICAgICAgICBBYnN0cmFjdFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24gPSBnZXRUeXBlRGVjbGFyYXRpb24oY29tcGlsYXRpb25Vbml0LCBtZXRob2QuZ2V0RGVjbGFyaW5nVHlwZSgpKTsKKyAgICBwdWJsaWMgc3RhdGljIE1ldGhvZERlY2xhcmF0aW9uIGdldE1ldGhvZERlY2xhcmF0aW9uKElNZXRob2QgbWV0aG9kKSB7CisgICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbihtZXRob2QuZ2V0RGVjbGFyaW5nVHlwZSgpKTsKICAgICAgICAgaWYgKHR5cGVEZWNsYXJhdGlvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICBMaXN0PEJvZHlEZWNsYXJhdGlvbj4gYm9keURlY2xhcmF0aW9ucyA9IHR5cGVEZWNsYXJhdGlvbi5ib2R5RGVjbGFyYXRpb25zKCk7CiAgICAgICAgICAgICBmb3IgKEJvZHlEZWNsYXJhdGlvbiBib2R5RGVjbGFyYXRpb24gOiBib2R5RGVjbGFyYXRpb25zKSB7CiAgICAgICAgICAgICAgICAgaWYgKGJvZHlEZWNsYXJhdGlvbiBpbnN0YW5jZW9mIE1ldGhvZERlY2xhcmF0aW9uKSB7Ci0gICAgICAgICAgICAgICAgICAgIGlmIChjb21wYXJlTWV0aG9kcygoTWV0aG9kRGVjbGFyYXRpb24pIGJvZHlEZWNsYXJhdGlvbiwgbWV0aG9kKSkgewotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGJvZHlEZWNsYXJhdGlvbjsKLSAgICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICBpZiAoYm9keURlY2xhcmF0aW9uIGluc3RhbmNlb2YgQW5ub3RhdGlvblR5cGVNZW1iZXJEZWNsYXJhdGlvbikgewotICAgICAgICAgICAgICAgICAgICBpZiAoY29tcGFyZU1ldGhvZE5hbWVzKChBbm5vdGF0aW9uVHlwZU1lbWJlckRlY2xhcmF0aW9uKWJvZHlEZWNsYXJhdGlvbiwgbWV0aG9kKSkgewotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGJvZHlEZWNsYXJhdGlvbjsKKyAgICAgICAgICAgICAgICAgICAgTWV0aG9kRGVjbGFyYXRpb24gbWV0aG9kRGVjbGFyYXRpb24gPSAoTWV0aG9kRGVjbGFyYXRpb24pIGJvZHlEZWNsYXJhdGlvbjsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGNvbXBhcmVNZXRob2RzKG1ldGhvZERlY2xhcmF0aW9uLCBtZXRob2QpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gbWV0aG9kRGVjbGFyYXRpb247CiAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CkBAIC01OTAsOCArNjE4LDggQEAKICAgICB9CiAKICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLSAgICBwcml2YXRlIHN0YXRpYyBGaWVsZERlY2xhcmF0aW9uIGdldEZpZWxkRGVjbGFyYXRpb24oQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCwgSUZpZWxkIGZpZWxkKSB7Ci0gICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbihjb21waWxhdGlvblVuaXQsIGZpZWxkLmdldERlY2xhcmluZ1R5cGUoKSk7CisgICAgcHVibGljIHN0YXRpYyBGaWVsZERlY2xhcmF0aW9uIGdldEZpZWxkRGVjbGFyYXRpb24oSUZpZWxkIGZpZWxkKSB7CisgICAgICAgIEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IGdldFR5cGVEZWNsYXJhdGlvbihmaWVsZC5nZXREZWNsYXJpbmdUeXBlKCkpOwogICAgICAgICBpZiAodHlwZURlY2xhcmF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgIExpc3Q8Qm9keURlY2xhcmF0aW9uPiBib2R5RGVjbGFyYXRpb25zID0gdHlwZURlY2xhcmF0aW9uLmJvZHlEZWNsYXJhdGlvbnMoKTsKICAgICAgICAgICAgIGZvciAoQm9keURlY2xhcmF0aW9uIGJvZHlEZWNsYXJhdGlvbiA6IGJvZHlEZWNsYXJhdGlvbnMpIHsKQEAgLTYwNiwyNSArNjM0LDIzIEBACiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAotICAgIHByaXZhdGUgc3RhdGljIEJvZHlEZWNsYXJhdGlvbiBnZXRGaWVsZERlY2xhcmF0aW9uKExpc3Q8Qm9keURlY2xhcmF0aW9uPiBib2R5RGVjbGFyYXRpb25zLCBJRmllbGQgZmllbGQpIHsKLSAgICAgICAgZm9yIChCb2R5RGVjbGFyYXRpb24gYm9keURlY2xhcmF0aW9uIDogYm9keURlY2xhcmF0aW9ucykgewotICAgICAgICAgICAgaWYgKGJvZHlEZWNsYXJhdGlvbiBpbnN0YW5jZW9mIEZpZWxkRGVjbGFyYXRpb24pIHsKLSAgICAgICAgICAgICAgICBpZiAoY29tcGFyZUZpZWxkTmFtZXMoKEZpZWxkRGVjbGFyYXRpb24pYm9keURlY2xhcmF0aW9uLCBmaWVsZCkpIHsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGJvZHlEZWNsYXJhdGlvbjsKKyAgICBwdWJsaWMgc3RhdGljIFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gZ2V0U2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbihJTG9jYWxWYXJpYWJsZSBqYXZhRWxlbWVudCkgeworICAgICAgICBpZiAoamF2YUVsZW1lbnQgaW5zdGFuY2VvZiBJTG9jYWxWYXJpYWJsZSAmJiBqYXZhRWxlbWVudC5nZXRQYXJlbnQoKSBpbnN0YW5jZW9mIElNZXRob2QpIHsKKyAgICAgICAgICAgIElMb2NhbFZhcmlhYmxlIGxvY2FsVmFyaWFibGUgPSBqYXZhRWxlbWVudDsKKyAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gKElNZXRob2QpIGxvY2FsVmFyaWFibGUuZ2V0UGFyZW50KCk7CisgICAgICAgICAgICBNZXRob2REZWNsYXJhdGlvbiBtZXRob2REZWNsYXJhdGlvbiA9IGdldE1ldGhvZERlY2xhcmF0aW9uKG1ldGhvZCk7CisKKyAgICAgICAgICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQorICAgICAgICAgICAgTGlzdDxTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uPiBwYXJhbWV0ZXJzID0gbWV0aG9kRGVjbGFyYXRpb24ucGFyYW1ldGVycygpOworICAgICAgICAgICAgZm9yIChTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uIHNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gOiBwYXJhbWV0ZXJzKSB7CisgICAgICAgICAgICAgICAgaWYgKHNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24uZ2V0TmFtZSgpLmdldElkZW50aWZpZXIoKS5lcXVhbHMobG9jYWxWYXJpYWJsZS5nZXRFbGVtZW50TmFtZSgpKSkgeworICAgICAgICAgICAgICAgICAgICByZXR1cm4gc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbjsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIG51bGw7CiAgICAgfQogCi0gICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0gICAgcHJpdmF0ZSBzdGF0aWMgTWFwIGdldE9wdGlvbnMoSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UpIHsKLSAgICAgICAgTWFwIG9wdGlvbnMgPSBzb3VyY2UuZ2V0SmF2YVByb2plY3QoKS5nZXRPcHRpb25zKHRydWUpOwotICAgICAgICBvcHRpb25zLnB1dChGT1JNQVRURVJfSU5TRVJUX1NQQUNFX0JFRk9SRV9BU1NJR05NRU5UX09QRVJBVE9SLCBET19OT1RfSU5TRVJUKTsKLSAgICAgICAgb3B0aW9ucy5wdXQoRk9STUFUVEVSX0lOU0VSVF9TUEFDRV9BRlRFUl9BU1NJR05NRU5UX09QRVJBVE9SLCBET19OT1RfSU5TRVJUKTsKLSAgICAgICAgcmV0dXJuIG9wdGlvbnM7Ci0gICAgfQotCiAgICAgcHJpdmF0ZSBzdGF0aWMgQ2hpbGRMaXN0UHJvcGVydHlEZXNjcmlwdG9yIGdldENoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvckZvclR5cGUoQWJzdHJhY3RUeXBlRGVjbGFyYXRpb24KICAgICAgICAgICAgIGFic3RyYWN0VHlwZURlY2xhcmF0aW9uKSB7CiAgICAgICAgIENoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvciBjaGlsZExpc3RQcm9wZXJ0eURlc2NyaXB0b3IgPSBudWxsOwpAQCAtNjQwLDI0ICs2NjYsMTEgQEAKICAgICAgICAgcmV0dXJuIGNoaWxkTGlzdFByb3BlcnR5RGVzY3JpcHRvcjsKICAgICB9CiAKLSAgICBwcml2YXRlIHN0YXRpYyBDaGlsZExpc3RQcm9wZXJ0eURlc2NyaXB0b3IgZ2V0Q2hpbGRMaXN0UHJvcGVydHlEZXNjcmlwdG9yRm9yTWV0aG9kKAotICAgICAgICAgICAgQm9keURlY2xhcmF0aW9uIGJvZHlEZWNsYXJhdGlvbikgewotICAgICAgICBpZiAoYm9keURlY2xhcmF0aW9uIGluc3RhbmNlb2YgTWV0aG9kRGVjbGFyYXRpb24pIHsKLSAgICAgICAgICAgIHJldHVybiBNZXRob2REZWNsYXJhdGlvbi5NT0RJRklFUlMyX1BST1BFUlRZOwotICAgICAgICB9Ci0gICAgICAgIGlmIChib2R5RGVjbGFyYXRpb24gaW5zdGFuY2VvZiBBbm5vdGF0aW9uVHlwZU1lbWJlckRlY2xhcmF0aW9uKSB7Ci0gICAgICAgICAgICByZXR1cm4gQW5ub3RhdGlvblR5cGVNZW1iZXJEZWNsYXJhdGlvbi5NT0RJRklFUlMyX1BST1BFUlRZOwotICAgICAgICB9Ci0gICAgICAgIHJldHVybiBudWxsOwotICAgIH0KLQotICAgIHB1YmxpYyBzdGF0aWMgVGV4dEZpbGVDaGFuZ2UgY3JlYXRlVGV4dEZpbGVDaGFuZ2UoU3RyaW5nIHRleHRGaWxlQ2hhbmdlTmFtZSwgSUZpbGUgZmlsZSkgewotICAgICAgICBUZXh0RmlsZUNoYW5nZSB0ZXh0RmlsZUNoYW5nZSA9IG5ldyBUZXh0RmlsZUNoYW5nZSh0ZXh0RmlsZUNoYW5nZU5hbWUsIGZpbGUpOwotICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOwotICAgICAgICB0ZXh0RmlsZUNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOwotICAgICAgICByZXR1cm4gdGV4dEZpbGVDaGFuZ2U7Ci0gICAgfQotCisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgYW5ub3RhdGlvbnMgbmFtZS4KKyAgICAgKiBAcGFyYW0gYW5ub3RhdGlvbgorICAgICAqIEByZXR1cm4gdGhlIGFubm90YXRpb24gbmFtZQorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldEFubm90YXRpb25OYW1lKEFubm90YXRpb24gYW5ub3RhdGlvbikgewogICAgICAgICBOYW1lIGFubm90YXRpb25UeXBlTmFtZSA9IGFubm90YXRpb24uZ2V0VHlwZU5hbWUoKTsKICAgICAgICAgcmV0dXJuIGFubm90YXRpb25UeXBlTmFtZS5nZXRGdWxseVF1YWxpZmllZE5hbWUoKTsKQEAgLTcwNyw4ICs3MjAsNyBAQAogCiAgICAgcHVibGljIHN0YXRpYyBib29sZWFuIGNvbXBhcmVNZXRob2RzKGNvbS5zdW4ubWlycm9yLmRlY2xhcmF0aW9uLk1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZE9uZSwKICAgICAgICAgICAgIGNvbS5zdW4ubWlycm9yLmRlY2xhcmF0aW9uLk1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZFR3bykgewotICAgICAgICByZXR1cm4gY29tcGFyZU1ldGhvZE5hbWVzKG1ldGhvZE9uZSwgbWV0aG9kVHdvKQotICAgICAgICAmJiBjb21wYXJlTWV0aG9kUGFyYW1ldGVyVHlwZXMobWV0aG9kT25lLCBtZXRob2RUd28pOworICAgICAgICByZXR1cm4gY29tcGFyZU1ldGhvZE5hbWVzKG1ldGhvZE9uZSwgbWV0aG9kVHdvKSAmJiBjb21wYXJlTWV0aG9kUGFyYW1ldGVyVHlwZXMobWV0aG9kT25lLCBtZXRob2RUd28pOwogICAgIH0KIAogICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gY29tcGFyZU1ldGhvZE5hbWVzKGNvbS5zdW4ubWlycm9yLmRlY2xhcmF0aW9uLk1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZE9uZSwKQEAgLTczMCwxNSArNzQyLDEwIEBACiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICAgICAgcmV0dXJuIHRydWU7Ci0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogCi0gICAgcHJpdmF0ZSBzdGF0aWMgYm9vbGVhbiBjb21wYXJlTWV0aG9kTmFtZXMoQW5ub3RhdGlvblR5cGVNZW1iZXJEZWNsYXJhdGlvbiBtZW1tYmVyRGVjbGFyYXRpb24sIElNZXRob2QgbWV0aG9kKSB7Ci0gICAgICAgIHJldHVybiBtZW1tYmVyRGVjbGFyYXRpb24uZ2V0TmFtZSgpLmdldElkZW50aWZpZXIoKS5lcXVhbHMobWV0aG9kLmdldEVsZW1lbnROYW1lKCkpOwotICAgIH0KLQogICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQogICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gY29tcGFyZUZpZWxkTmFtZXMoRmllbGREZWNsYXJhdGlvbiBmaWVsZERlY2xhcmF0aW9uLCBJRmllbGQgZmllbGQpIHsKICAgICAgICAgTGlzdDxWYXJpYWJsZURlY2xhcmF0aW9uRnJhZ21lbnQ+IGZyYWdtZW50cyA9IGZpZWxkRGVjbGFyYXRpb24uZnJhZ21lbnRzKCk7CkBAIC03NzcsNDQgKzc4NCwxNyBAQAogICAgICAgICAgICAgcmV0dXJuIGlzQW5ub3RhdGlvblByZXNlbnQoKChJQ29tcGlsYXRpb25Vbml0KWphdmFFbGVtZW50KS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbk5hbWUpOwogICAgICAgICB9CiAKLSAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSBnZXRDb21waWxhdGlvblVuaXRGcm9tSmF2YUVsZW1lbnQoamF2YUVsZW1lbnQpOwotCiAgICAgICAgIGludCBlbGVtZW50VHlwZSA9IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCk7Ci0gICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7CiAKICAgICAgICAgaWYgKGVsZW1lbnRUeXBlID09IElKYXZhRWxlbWVudC5QQUNLQUdFX0RFQ0xBUkFUSU9OCiAgICAgICAgICAgICAgICAgfHwgZWxlbWVudFR5cGUgPT0gSUphdmFFbGVtZW50LlRZUEUKICAgICAgICAgICAgICAgICB8fCBlbGVtZW50VHlwZSA9PSBJSmF2YUVsZW1lbnQuTUVUSE9ECiAgICAgICAgICAgICAgICAgfHwgZWxlbWVudFR5cGUgPT0gSUphdmFFbGVtZW50LkxPQ0FMX1ZBUklBQkxFCiAgICAgICAgICAgICAgICAgfHwgZWxlbWVudFR5cGUgPT0gSUphdmFFbGVtZW50LkZJRUxEKSB7Ci0gICAgICAgICAgICByZXR1cm4gaXNBbm5vdGF0aW9uUHJlc2VudChjb21waWxhdGlvblVuaXQsIGphdmFFbGVtZW50LAotICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uTmFtZSk7Ci0gICAgICAgIH0KLSAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIH0KIAotICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gaXNBbm5vdGF0aW9uUHJlc2VudChCb2R5RGVjbGFyYXRpb24gYm9keURlY2xhcmF0aW9uLCBBbm5vdGF0aW9uIGFubmF0b3RhdGlvblRvQWRkKSB7Ci0gICAgICAgIGJvb2xlYW4gZXhpc3RzID0gZmFsc2U7Ci0gICAgICAgIExpc3Q8SUV4dGVuZGVkTW9kaWZpZXI+IG1vZGlmaWVycyA9IGJvZHlEZWNsYXJhdGlvbi5tb2RpZmllcnMoKTsKLSAgICAgICAgZm9yIChJRXh0ZW5kZWRNb2RpZmllciBleHRlbmRlZE1vZGlmaWVyIDogbW9kaWZpZXJzKSB7Ci0gICAgICAgICAgICBpZiAoZXh0ZW5kZWRNb2RpZmllciBpbnN0YW5jZW9mIEFubm90YXRpb24pIHsKLSAgICAgICAgICAgICAgICBBbm5vdGF0aW9uIGV4aXN0aW5nQW5ub3RhdGlvbiA9IChBbm5vdGF0aW9uKSBleHRlbmRlZE1vZGlmaWVyOwotICAgICAgICAgICAgICAgIGlmIChjb21wYXJlQW5ub3RhdGlvbk5hbWVzKGFubmF0b3RhdGlvblRvQWRkLCBleGlzdGluZ0Fubm90YXRpb24pKSB7Ci0gICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOwotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIH0KLSAgICAgICAgfQotICAgICAgICByZXR1cm4gZXhpc3RzOwotICAgIH0KLQotICAgIHByaXZhdGUgc3RhdGljIGJvb2xlYW4gaXNBbm5vdGF0aW9uUHJlc2VudChDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0LCBJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsCi0gICAgICAgICAgICBTdHJpbmcgYW5ub3RhdGlvbk5hbWUpIHsKLSAgICAgICAgTGlzdDxJRXh0ZW5kZWRNb2RpZmllcj4gbW9kaWZpZXJzID0gZ2V0RXh0ZW5kZWRNb2RpZmllcnMoY29tcGlsYXRpb25Vbml0LCBqYXZhRWxlbWVudCk7Ci0gICAgICAgIGZvciAoSUV4dGVuZGVkTW9kaWZpZXIgZXh0ZW5kZWRNb2RpZmllciA6IG1vZGlmaWVycykgewotICAgICAgICAgICAgaWYgKGV4dGVuZGVkTW9kaWZpZXIuaXNBbm5vdGF0aW9uKCkpIHsKLSAgICAgICAgICAgICAgICBBbm5vdGF0aW9uIGV4aXN0aW5nQW5ub3RhdGlvbiA9IChBbm5vdGF0aW9uKSBleHRlbmRlZE1vZGlmaWVyOwotICAgICAgICAgICAgICAgIGlmIChBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoZXhpc3RpbmdBbm5vdGF0aW9uKS5lcXVhbHMoYW5ub3RhdGlvbk5hbWUpKSB7CisgICAgICAgICAgICBMaXN0PEFubm90YXRpb24+IGFubm90YXRpb25zID0gZ2V0QW5ub3RhdGlvbnMoamF2YUVsZW1lbnQpOworICAgICAgICAgICAgZm9yIChBbm5vdGF0aW9uIGFubm90YXRpb24gOiBhbm5vdGF0aW9ucykgeworICAgICAgICAgICAgICAgIGlmIChBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikuZXF1YWxzKGFubm90YXRpb25OYW1lKSkgewogICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CkBAIC04MjMsMTA1ICs4MDMsNTkgQEAKICAgICB9CiAKICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLSAgICBwdWJsaWMgc3RhdGljIExpc3Q8SUV4dGVuZGVkTW9kaWZpZXI+IGdldEV4dGVuZGVkTW9kaWZpZXJzKENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQsCi0gICAgICAgICAgICBJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQpIHsKKyAgICBwdWJsaWMgc3RhdGljIExpc3Q8QW5ub3RhdGlvbj4gZ2V0QW5ub3RhdGlvbnMoSUphdmFFbGVtZW50IGphdmFFbGVtZW50KSB7CisgICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gQW5ub3RhdGlvblV0aWxzLmdldENvbXBpbGF0aW9uVW5pdEZyb21KYXZhRWxlbWVudChqYXZhRWxlbWVudCk7CisgICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7CiAKICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LlBBQ0tBR0VfREVDTEFSQVRJT04pIHsKICAgICAgICAgICAgIFBhY2thZ2VEZWNsYXJhdGlvbiBwYWNrYWdlRGVjbGFyYXRpb24gPSBjb21waWxhdGlvblVuaXQuZ2V0UGFja2FnZSgpOwogICAgICAgICAgICAgcmV0dXJuIHBhY2thZ2VEZWNsYXJhdGlvbi5hbm5vdGF0aW9ucygpOwogICAgICAgICB9CiAKLSAgICAgICAgSVR5cGUgdHlwZSA9IGNvbXBpbGF0aW9uVW5pdC5nZXRUeXBlUm9vdCgpLmZpbmRQcmltYXJ5VHlwZSgpOwotICAgICAgICBMaXN0PEFic3RyYWN0VHlwZURlY2xhcmF0aW9uPiB0eXBlcyA9IGNvbXBpbGF0aW9uVW5pdC50eXBlcygpOwotICAgICAgICBmb3IgKEFic3RyYWN0VHlwZURlY2xhcmF0aW9uIGFic3RyYWN0VHlwZURlY2xhcmF0aW9uIDogdHlwZXMpIHsKLSAgICAgICAgICAgIGlmIChjb21wYXJlVHlwZU5hbWVzKGFic3RyYWN0VHlwZURlY2xhcmF0aW9uLCB0eXBlKSkgewotICAgICAgICAgICAgICAgIExpc3Q8Qm9keURlY2xhcmF0aW9uPiBib2R5RGVjbGFyYXRpb25zID0gZ2V0Qm9keURlY2xhcmF0aW9uc0ZvclR5cGUoYWJzdHJhY3RUeXBlRGVjbGFyYXRpb24pOwogCi0gICAgICAgICAgICAgICAgQm9keURlY2xhcmF0aW9uIGJvZHlEZWNsYXJhdGlvbiA9IG51bGw7Ci0gICAgICAgICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LlRZUEUpIHsKLSAgICAgICAgICAgICAgICAgICAgYm9keURlY2xhcmF0aW9uID0gYWJzdHJhY3RUeXBlRGVjbGFyYXRpb247Ci0gICAgICAgICAgICAgICAgfQorICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuVFlQRSkgeworICAgICAgICAgICAgSVR5cGUgdHlwZSA9IChJVHlwZSkgamF2YUVsZW1lbnQ7CisgICAgICAgICAgICBBYnN0cmFjdFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0VHlwZURlY2xhcmF0aW9uKHR5cGUpOworICAgICAgICAgICAgcmV0dXJuIGV4dHJhY3RBbm5vdGF0aW9ucyh0eXBlRGVjbGFyYXRpb24ubW9kaWZpZXJzKCkpOworICAgICAgICB9CiAKLSAgICAgICAgICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTUVUSE9EKSB7Ci0gICAgICAgICAgICAgICAgICAgIGJvZHlEZWNsYXJhdGlvbiA9IGdldE1ldGhvZERlY2xhcmF0aW9uKGJvZHlEZWNsYXJhdGlvbnMsIChJTWV0aG9kKSBqYXZhRWxlbWVudCk7Ci0gICAgICAgICAgICAgICAgfQorICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTUVUSE9EKSB7CisgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IChJTWV0aG9kKSBqYXZhRWxlbWVudDsKKyAgICAgICAgICAgIE1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZERlY2xhcmF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldE1ldGhvZERlY2xhcmF0aW9uKG1ldGhvZCk7CisgICAgICAgICAgICByZXR1cm4gZXh0cmFjdEFubm90YXRpb25zKG1ldGhvZERlY2xhcmF0aW9uLm1vZGlmaWVycygpKTsKKyAgICAgICAgfQogCi0gICAgICAgICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LkxPQ0FMX1ZBUklBQkxFKSB7Ci0gICAgICAgICAgICAgICAgICAgIFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbiA9IGdldFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24oKElMb2NhbFZhcmlhYmxlKSBqYXZhRWxlbWVudCk7Ci0gICAgICAgICAgICAgICAgICAgIGlmIChzaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uICE9IG51bGwpIHsKLSAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBzaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uLm1vZGlmaWVycygpOwotICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgfQorICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuRklFTEQpIHsKKyAgICAgICAgICAgIElGaWVsZCBmaWVsZCA9IChJRmllbGQpIGphdmFFbGVtZW50OworICAgICAgICAgICAgRmllbGREZWNsYXJhdGlvbiBmaWVsZERlY2xhcmF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEZpZWxkRGVjbGFyYXRpb24oZmllbGQpOworICAgICAgICAgICAgcmV0dXJuIGV4dHJhY3RBbm5vdGF0aW9ucyhmaWVsZERlY2xhcmF0aW9uLm1vZGlmaWVycygpKTsKKyAgICAgICAgfQogCi0gICAgICAgICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LkZJRUxEKSB7Ci0gICAgICAgICAgICAgICAgICAgIGJvZHlEZWNsYXJhdGlvbiA9IGdldEZpZWxkRGVjbGFyYXRpb24oYm9keURlY2xhcmF0aW9ucywgKElGaWVsZCkgamF2YUVsZW1lbnQpOwotICAgICAgICAgICAgICAgIH0KLQotICAgICAgICAgICAgICAgIHJldHVybiBib2R5RGVjbGFyYXRpb24gIT0gbnVsbCA/IGJvZHlEZWNsYXJhdGlvbi5tb2RpZmllcnMoKSA6IENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOworICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTE9DQUxfVkFSSUFCTEUpIHsKKyAgICAgICAgICAgIFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbiA9IGdldFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24oKElMb2NhbFZhcmlhYmxlKSBqYXZhRWxlbWVudCk7CisgICAgICAgICAgICBpZiAoc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbiAhPSBudWxsKSB7CisgICAgICAgICAgICAgICAgcmV0dXJuIGV4dHJhY3RBbm5vdGF0aW9ucyhzaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uLm1vZGlmaWVycygpKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQorCiAgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gZ2V0U2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbihJTG9jYWxWYXJpYWJsZSBqYXZhRWxlbWVudCkgewotICAgICAgICBpZiAoamF2YUVsZW1lbnQgaW5zdGFuY2VvZiBJTG9jYWxWYXJpYWJsZSAmJiBqYXZhRWxlbWVudC5nZXRQYXJlbnQoKSBpbnN0YW5jZW9mIElNZXRob2QpIHsKLSAgICAgICAgICAgIElMb2NhbFZhcmlhYmxlIGxvY2FsVmFyaWFibGUgPSBqYXZhRWxlbWVudDsKLSAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gKElNZXRob2QpIGxvY2FsVmFyaWFibGUuZ2V0UGFyZW50KCk7Ci0gICAgICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKGdldENvbXBpbGF0aW9uVW5pdEZyb21KYXZhRWxlbWVudChqYXZhRWxlbWVudCksIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKLQotICAgICAgICAgICAgTWV0aG9kRGVjbGFyYXRpb24gbWV0aG9kRGVjbGFyYXRpb24gPSAoTWV0aG9kRGVjbGFyYXRpb24pIGdldE1ldGhvZERlY2xhcmF0aW9uKGNvbXBpbGF0aW9uVW5pdCwgbWV0aG9kKTsKLQotICAgICAgICAgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0gICAgICAgICAgICBMaXN0PFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24+IHBhcmFtZXRlcnMgPSBtZXRob2REZWNsYXJhdGlvbi5wYXJhbWV0ZXJzKCk7Ci0gICAgICAgICAgICBmb3IgKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbiA6IHBhcmFtZXRlcnMpIHsKLSAgICAgICAgICAgICAgICBpZiAoc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbi5nZXROYW1lKCkudG9TdHJpbmcoKS5lcXVhbHMobG9jYWxWYXJpYWJsZS5nZXRFbGVtZW50TmFtZSgpKSkgewotICAgICAgICAgICAgICAgICAgICByZXR1cm4gc2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbjsKLSAgICAgICAgICAgICAgICB9CisgICAgcHJpdmF0ZSBzdGF0aWMgTGlzdDxBbm5vdGF0aW9uPiBleHRyYWN0QW5ub3RhdGlvbnMoTGlzdDxJRXh0ZW5kZWRNb2RpZmllcj4gZXh0ZW5kZWRNb2RpZmllcnMpIHsKKyAgICAgICAgTGlzdDxBbm5vdGF0aW9uPiBhbm5vdGF0aW9ucyA9IG5ldyBBcnJheUxpc3Q8QW5ub3RhdGlvbj4oKTsKKyAgICAgICAgZm9yIChJRXh0ZW5kZWRNb2RpZmllciBleHRlbmRlZE1vZGlmaWVyIDogZXh0ZW5kZWRNb2RpZmllcnMpIHsKKyAgICAgICAgICAgIGlmIChleHRlbmRlZE1vZGlmaWVyLmlzQW5ub3RhdGlvbigpKSB7CisgICAgICAgICAgICAgICAgYW5ub3RhdGlvbnMuYWRkKChBbm5vdGF0aW9uKSBleHRlbmRlZE1vZGlmaWVyKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQotICAgICAgICByZXR1cm4gbnVsbDsKLSAgICB9Ci0KLSAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLSAgICBwcml2YXRlIHN0YXRpYyBMaXN0PEJvZHlEZWNsYXJhdGlvbj4gZ2V0Qm9keURlY2xhcmF0aW9uc0ZvclR5cGUoCi0gICAgICAgICAgICBBYnN0cmFjdFR5cGVEZWNsYXJhdGlvbiBhYnN0cmFjdFR5cGVEZWNsYXJhdGlvbikgewotICAgICAgICBpZiAoYWJzdHJhY3RUeXBlRGVjbGFyYXRpb24gaW5zdGFuY2VvZiBUeXBlRGVjbGFyYXRpb24pIHsKLSAgICAgICAgICAgIFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24gPSAoVHlwZURlY2xhcmF0aW9uKSBhYnN0cmFjdFR5cGVEZWNsYXJhdGlvbjsKLSAgICAgICAgICAgIHJldHVybiB0eXBlRGVjbGFyYXRpb24uYm9keURlY2xhcmF0aW9ucygpOwotICAgICAgICB9Ci0gICAgICAgIGlmIChhYnN0cmFjdFR5cGVEZWNsYXJhdGlvbiBpbnN0YW5jZW9mIEVudW1EZWNsYXJhdGlvbikgewotICAgICAgICAgICAgRW51bURlY2xhcmF0aW9uIGVudW1EZWNsYXJhdGlvbiA9IChFbnVtRGVjbGFyYXRpb24pIGFic3RyYWN0VHlwZURlY2xhcmF0aW9uOwotICAgICAgICAgICAgcmV0dXJuIGVudW1EZWNsYXJhdGlvbi5ib2R5RGVjbGFyYXRpb25zKCk7Ci0gICAgICAgIH0KLSAgICAgICAgaWYgKGFic3RyYWN0VHlwZURlY2xhcmF0aW9uIGluc3RhbmNlb2YgQW5ub3RhdGlvblR5cGVEZWNsYXJhdGlvbikgewotICAgICAgICAgICAgQW5ub3RhdGlvblR5cGVEZWNsYXJhdGlvbiBhbm5vdGF0aW9uVHlwZURlY2xhcmF0aW9uID0KLSAgICAgICAgICAgICAgICAoQW5ub3RhdGlvblR5cGVEZWNsYXJhdGlvbikgYWJzdHJhY3RUeXBlRGVjbGFyYXRpb247Ci0gICAgICAgICAgICByZXR1cm4gYW5ub3RhdGlvblR5cGVEZWNsYXJhdGlvbi5ib2R5RGVjbGFyYXRpb25zKCk7Ci0gICAgICAgIH0KLSAgICAgICAgcmV0dXJuIENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOwotICAgIH0KLQotICAgIHByaXZhdGUgc3RhdGljIE1ldGhvZERlY2xhcmF0aW9uIGdldE1ldGhvZERlY2xhcmF0aW9uKExpc3Q8Qm9keURlY2xhcmF0aW9uPiBib2R5RGVjbGFyYXRpb25zLCBJTWV0aG9kIG1ldGhvZCkgewotICAgICAgICBmb3IgKEJvZHlEZWNsYXJhdGlvbiBib2R5RGVjbGFyYXRpb24gOiBib2R5RGVjbGFyYXRpb25zKSB7Ci0gICAgICAgICAgICBpZiAoYm9keURlY2xhcmF0aW9uIGluc3RhbmNlb2YgTWV0aG9kRGVjbGFyYXRpb24pIHsKLSAgICAgICAgICAgICAgICBpZiAoY29tcGFyZU1ldGhvZHMoKE1ldGhvZERlY2xhcmF0aW9uKWJvZHlEZWNsYXJhdGlvbiwgbWV0aG9kKSkgewotICAgICAgICAgICAgICAgICAgICByZXR1cm4gKE1ldGhvZERlY2xhcmF0aW9uKSBib2R5RGVjbGFyYXRpb247Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgfQotICAgICAgICAgICAgaWYgKGJvZHlEZWNsYXJhdGlvbiBpbnN0YW5jZW9mIEFubm90YXRpb25UeXBlTWVtYmVyRGVjbGFyYXRpb24pIHsKLSAgICAgICAgICAgICAgICBpZiAoY29tcGFyZU1ldGhvZE5hbWVzKChBbm5vdGF0aW9uVHlwZU1lbWJlckRlY2xhcmF0aW9uKWJvZHlEZWNsYXJhdGlvbiwgbWV0aG9kKSkgewotICAgICAgICAgICAgICAgICAgICByZXR1cm4gKE1ldGhvZERlY2xhcmF0aW9uKSBib2R5RGVjbGFyYXRpb247Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgfQotICAgICAgICB9Ci0gICAgICAgIHJldHVybiBudWxsOworICAgICAgICByZXR1cm4gYW5ub3RhdGlvbnM7CiAgICAgfQogCiAgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCiAgICAgcHVibGljIHN0YXRpYyBMaXN0PFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24+IGdldFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb25zKGZpbmFsIElNZXRob2QgbWV0aG9kKSB7CiAgICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gbWV0aG9kLmdldENvbXBpbGF0aW9uVW5pdCgpOwogICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKHNvdXJjZSwgU2hhcmVkQVNUUHJvdmlkZXIuV0FJVF9ZRVMsIG51bGwpOwotICAgICAgICBmaW5hbCBMaXN0PFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24+IHBhcmFtZXRlcnMgPSBuZXcgQXJyYXlMaXN0KCk7CisgICAgICAgIGZpbmFsIExpc3Q8U2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbj4gcGFyYW1ldGVycyA9IG5ldyBBcnJheUxpc3Q8U2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbj4oKTsKICAgICAgICAgY29tcGlsYXRpb25Vbml0LmFjY2VwdChuZXcgQVNUVmlzaXRvcigpIHsKICAgICAgICAgICAgIEBPdmVycmlkZQogICAgICAgICAgICAgcHVibGljIGJvb2xlYW4gdmlzaXQoTWV0aG9kRGVjbGFyYXRpb24gbWV0aG9kRGVjbGFyYXRpb24pIHsKQEAgLTk1OCwzMiArODkyLDkgQEAKICAgICAgICAgcmV0dXJuIG51bGw7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0U3RyaW5nVmFsdWUoQW5ub3RhdGlvbk1pcnJvciBtaXJyb3IsIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB7Ci0gICAgICAgIEFubm90YXRpb25WYWx1ZSBhbm5vdGF0aW9uVmFsdWUgPSBnZXRBbm5vdGF0aW9uVmFsdWUobWlycm9yLCBhdHRyaWJ1dGVOYW1lKTsKLSAgICAgICAgaWYgKGFubm90YXRpb25WYWx1ZSAhPSBudWxsKSB7Ci0gICAgICAgICAgICByZXR1cm4gYW5ub3RhdGlvblZhbHVlLmdldFZhbHVlKCkudG9TdHJpbmcoKTsKLSAgICAgICAgfQotICAgICAgICByZXR1cm4gbnVsbDsKLSAgICB9Ci0KLSAgICBwdWJsaWMgc3RhdGljIEJvb2xlYW4gZ2V0Qm9vbGVhblZhbHVlKEFubm90YXRpb25NaXJyb3IgbWlycm9yLCBTdHJpbmcgYXR0cmlidXRlTmFtZSkgewotICAgICAgICBTdHJpbmcgdmFsdWUgPSBnZXRTdHJpbmdWYWx1ZShtaXJyb3IsIGF0dHJpYnV0ZU5hbWUpOwotICAgICAgICBpZiAodmFsdWUgIT0gbnVsbCkgewotICAgICAgICAgICAgcmV0dXJuIEJvb2xlYW4udmFsdWVPZih2YWx1ZSk7Ci0gICAgICAgIH0KLSAgICAgICAgcmV0dXJuIG51bGw7Ci0gICAgfQotCi0gICAgcHVibGljIHN0YXRpYyBBbm5vdGF0aW9uVmFsdWUgZ2V0QW5ub3RhdGlvblZhbHVlKEFubm90YXRpb25NaXJyb3IgbWlycm9yLCBTdHJpbmcgYXR0cmlidXRlTmFtZSkgewotICAgICAgICBNYXA8QW5ub3RhdGlvblR5cGVFbGVtZW50RGVjbGFyYXRpb24sIEFubm90YXRpb25WYWx1ZT4gdmFsdWVzID0gbWlycm9yLmdldEVsZW1lbnRWYWx1ZXMoKTsKLSAgICAgICAgU2V0PE1hcC5FbnRyeTxBbm5vdGF0aW9uVHlwZUVsZW1lbnREZWNsYXJhdGlvbiwgQW5ub3RhdGlvblZhbHVlPj4gZW50cnlTZXQgPSB2YWx1ZXMuZW50cnlTZXQoKTsKLSAgICAgICAgZm9yIChNYXAuRW50cnk8QW5ub3RhdGlvblR5cGVFbGVtZW50RGVjbGFyYXRpb24sIEFubm90YXRpb25WYWx1ZT4gZW50cnkgOiBlbnRyeVNldCkgewotICAgICAgICAgICAgQW5ub3RhdGlvblR5cGVFbGVtZW50RGVjbGFyYXRpb24gZWxlbWVudCA9IGVudHJ5LmdldEtleSgpOwotICAgICAgICAgICAgaWYgKGVsZW1lbnQuZ2V0U2ltcGxlTmFtZSgpLmVxdWFscyhhdHRyaWJ1dGVOYW1lKSkgewotICAgICAgICAgICAgICAgIHJldHVybiBlbnRyeS5nZXRWYWx1ZSgpOwotICAgICAgICAgICAgfQotICAgICAgICB9Ci0gICAgICAgIHJldHVybiBudWxsOworICAgIHB1YmxpYyBzdGF0aWMgQW5ub3RhdGlvbiBnZXRBbm5vdGF0aW9uKElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHsKKyAgICAgICAgTGlzdDxBbm5vdGF0aW9uPiBhbm5vdGF0aW9ucyA9IGdldEFubm90YXRpb25zKGphdmFFbGVtZW50KTsKKyAgICAgICAgcmV0dXJuIGdldEFubm90YXRpb24oYW5ub3RhdGlvbnMsIGFubm90YXRpb24pOwogICAgIH0KIAogICAgIHB1YmxpYyBzdGF0aWMgQW5ub3RhdGlvbk1pcnJvciBnZXRBbm5vdGF0aW9uKERlY2xhcmF0aW9uIGRlY2xhcmF0aW9uLApAQCAtMTAwMSwzMSArOTEyLDM4IEBACiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldFN0cmluZ1ZhbHVlKEFubm90YXRpb24gYW5ub3RhdGlvbiwgU3RyaW5nIGF0dHJpYnV0ZU5hbWUpIHsKLSAgICAgICAgaWYgKGFubm90YXRpb24gaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKSB7Ci0gICAgICAgICAgICBFeHByZXNzaW9uIGV4cHJlc3Npb24gPSBnZXRBbm5vdGF0aW9uVmFsdWUoKE5vcm1hbEFubm90YXRpb24pIGFubm90YXRpb24sIGF0dHJpYnV0ZU5hbWUpOwotICAgICAgICAgICAgaWYgKGV4cHJlc3Npb24gIT0gbnVsbCAmJiBleHByZXNzaW9uIGluc3RhbmNlb2YgU3RyaW5nTGl0ZXJhbCkgewotICAgICAgICAgICAgICAgIHJldHVybiAoKFN0cmluZ0xpdGVyYWwpIGV4cHJlc3Npb24pLmdldExpdGVyYWxWYWx1ZSgpOworICAgIHByaXZhdGUgc3RhdGljIEFubm90YXRpb24gZ2V0QW5ub3RhdGlvbihMaXN0PEFubm90YXRpb24+IGFubm90YXRpb25zLAorICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHsKKyAgICAgICAgZm9yIChBbm5vdGF0aW9uIGFzdEFubm90YXRpb24gOiBhbm5vdGF0aW9ucykgeworICAgICAgICAgICAgU3RyaW5nIHR5cGVOYW1lID0gYXN0QW5ub3RhdGlvbi5nZXRUeXBlTmFtZSgpLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgpOworICAgICAgICAgICAgaWYgKHR5cGVOYW1lLmVxdWFscyhhbm5vdGF0aW9uLmdldENhbm9uaWNhbE5hbWUoKSkKKyAgICAgICAgICAgICAgICAgICAgfHwgdHlwZU5hbWUuZXF1YWxzKGFubm90YXRpb24uZ2V0U2ltcGxlTmFtZSgpKSkgeworICAgICAgICAgICAgICAgIHJldHVybiBhc3RBbm5vdGF0aW9uOwogICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldEVudW1WYWx1ZShBbm5vdGF0aW9uIGFubm90YXRpb24sIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB7Ci0gICAgICAgIGlmIChhbm5vdGF0aW9uIGluc3RhbmNlb2YgTm9ybWFsQW5ub3RhdGlvbikgewotICAgICAgICAgICAgRXhwcmVzc2lvbiBleHByZXNzaW9uID0gZ2V0QW5ub3RhdGlvblZhbHVlKChOb3JtYWxBbm5vdGF0aW9uKSBhbm5vdGF0aW9uLCBhdHRyaWJ1dGVOYW1lKTsKLSAgICAgICAgICAgIGlmIChleHByZXNzaW9uICE9IG51bGwgJiYgZXhwcmVzc2lvbiBpbnN0YW5jZW9mIFF1YWxpZmllZE5hbWUpIHsKLSAgICAgICAgICAgICAgICByZXR1cm4gKChRdWFsaWZpZWROYW1lKSBleHByZXNzaW9uKS5nZXROYW1lKCkuZ2V0SWRlbnRpZmllcigpOworICAgIHB1YmxpYyBzdGF0aWMgSUFubm90YXRpb24gZ2V0QW5ub3RhdGlvbihDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbiwKKyAgICAgICAgICAgIElBbm5vdGF0YWJsZSBhbm5vdGF0YWJsZSkgdGhyb3dzIEphdmFNb2RlbEV4Y2VwdGlvbiB7CisgICAgICAgIElBbm5vdGF0aW9uW10gYW5ub3RhdGlvbnMgPSBhbm5vdGF0YWJsZS5nZXRBbm5vdGF0aW9ucygpOworICAgICAgICBmb3IgKElBbm5vdGF0aW9uIGpkdEFubm90YXRpb24gOiBhbm5vdGF0aW9ucykgeworICAgICAgICAgICAgU3RyaW5nIGFubm90YXRpb25OYW1lID0gamR0QW5ub3RhdGlvbi5nZXRFbGVtZW50TmFtZSgpOworICAgICAgICAgICAgaWYgKGFubm90YXRpb25OYW1lLmVxdWFscyhhbm5vdGF0aW9uLmdldENhbm9uaWNhbE5hbWUoKSkKKyAgICAgICAgICAgICAgICAgICAgfHwgYW5ub3RhdGlvbk5hbWUuZXF1YWxzKGFubm90YXRpb24uZ2V0U2ltcGxlTmFtZSgpKSkgeworICAgICAgICAgICAgICAgIHJldHVybiBqZHRBbm5vdGF0aW9uOwogICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgQm9vbGVhbiBnZXRCb29sZWFuVmFsdWUoQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBTdHJpbmcgYXR0cmlidXRlTmFtZSkgewotICAgICAgICBpZiAoYW5ub3RhdGlvbiBpbnN0YW5jZW9mIE5vcm1hbEFubm90YXRpb24pIHsKLSAgICAgICAgICAgIEV4cHJlc3Npb24gZXhwcmVzc2lvbiA9IGdldEFubm90YXRpb25WYWx1ZSgoTm9ybWFsQW5ub3RhdGlvbikgYW5ub3RhdGlvbiwgYXR0cmlidXRlTmFtZSk7Ci0gICAgICAgICAgICBpZiAoZXhwcmVzc2lvbiAhPSBudWxsICYmIGV4cHJlc3Npb24gaW5zdGFuY2VvZiBCb29sZWFuTGl0ZXJhbCkgewotICAgICAgICAgICAgICAgIHJldHVybiBCb29sZWFuLnZhbHVlT2YoKChCb29sZWFuTGl0ZXJhbCkgZXhwcmVzc2lvbikuYm9vbGVhblZhbHVlKCkpOworICAgIHB1YmxpYyBzdGF0aWMgQW5ub3RhdGlvblZhbHVlIGdldEFubm90YXRpb25WYWx1ZShBbm5vdGF0aW9uTWlycm9yIG1pcnJvciwgU3RyaW5nIGF0dHJpYnV0ZU5hbWUpIHsKKyAgICAgICAgTWFwPEFubm90YXRpb25UeXBlRWxlbWVudERlY2xhcmF0aW9uLCBBbm5vdGF0aW9uVmFsdWU+IHZhbHVlcyA9IG1pcnJvci5nZXRFbGVtZW50VmFsdWVzKCk7CisgICAgICAgIFNldDxNYXAuRW50cnk8QW5ub3RhdGlvblR5cGVFbGVtZW50RGVjbGFyYXRpb24sIEFubm90YXRpb25WYWx1ZT4+IGVudHJ5U2V0ID0gdmFsdWVzLmVudHJ5U2V0KCk7CisgICAgICAgIGZvciAoTWFwLkVudHJ5PEFubm90YXRpb25UeXBlRWxlbWVudERlY2xhcmF0aW9uLCBBbm5vdGF0aW9uVmFsdWU+IGVudHJ5IDogZW50cnlTZXQpIHsKKyAgICAgICAgICAgIEFubm90YXRpb25UeXBlRWxlbWVudERlY2xhcmF0aW9uIGVsZW1lbnQgPSBlbnRyeS5nZXRLZXkoKTsKKyAgICAgICAgICAgIGlmIChlbGVtZW50LmdldFNpbXBsZU5hbWUoKS5lcXVhbHMoYXR0cmlidXRlTmFtZSkpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gZW50cnkuZ2V0VmFsdWUoKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gbnVsbDsKQEAgLTEwNDIsMzcgKzk2MCw0NyBAQAogICAgICAgICByZXR1cm4gbnVsbDsKICAgICB9CiAKLSAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKLSAgICBwdWJsaWMgc3RhdGljIEFubm90YXRpb24gZ2V0QW5ub3RhdGlvbihCb2R5RGVjbGFyYXRpb24gYm9keURlY2xhcmF0aW9uLAotICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHsKLQotICAgICAgICByZXR1cm4gZ2V0QW5ub3RhdGlvbihib2R5RGVjbGFyYXRpb24ubW9kaWZpZXJzKCksIGFubm90YXRpb24pOwotICAgIH0KLQotICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotICAgIHB1YmxpYyBzdGF0aWMgQW5ub3RhdGlvbiBnZXRBbm5vdGF0aW9uKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyLAotICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHsKLQotICAgICAgICByZXR1cm4gZ2V0QW5ub3RhdGlvbihwYXJhbWV0ZXIubW9kaWZpZXJzKCksIGFubm90YXRpb24pOwotICAgIH0KLQotICAgIHByaXZhdGUgc3RhdGljIEFubm90YXRpb24gZ2V0QW5ub3RhdGlvbihMaXN0PElFeHRlbmRlZE1vZGlmaWVyPiBtb2RpZmllcnMsCi0gICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbikgewotICAgICAgICBpZiAobW9kaWZpZXJzICE9IG51bGwpIHsKLSAgICAgICAgICAgIGZvciAoSUV4dGVuZGVkTW9kaWZpZXIgZXh0ZW5kZWRNb2RpZmllciA6IG1vZGlmaWVycykgewotICAgICAgICAgICAgICAgIGlmIChleHRlbmRlZE1vZGlmaWVyIGluc3RhbmNlb2YgQW5ub3RhdGlvbikgewotICAgICAgICAgICAgICAgICAgICBBbm5vdGF0aW9uIGFzdEFubm90YXRpb24gPSAoQW5ub3RhdGlvbikgZXh0ZW5kZWRNb2RpZmllcjsKLSAgICAgICAgICAgICAgICAgICAgU3RyaW5nIHR5cGVOYW1lID0gYXN0QW5ub3RhdGlvbi5nZXRUeXBlTmFtZSgpLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgpOwotICAgICAgICAgICAgICAgICAgICBpZiAodHlwZU5hbWUuZXF1YWxzKGFubm90YXRpb24uZ2V0Q2Fub25pY2FsTmFtZSgpKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHx8IHR5cGVOYW1lLmVxdWFscyhhbm5vdGF0aW9uLmdldFNpbXBsZU5hbWUoKSkpIHsKLSAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBhc3RBbm5vdGF0aW9uOwotICAgICAgICAgICAgICAgICAgICB9CisgICAgcHVibGljIHN0YXRpYyBPYmplY3QgZ2V0QW5ub3RhdGlvblZhbHVlKElBbm5vdGF0aW9uIGFubm90YXRpb24sIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB0aHJvd3MgSmF2YU1vZGVsRXhjZXB0aW9uIHsKKyAgICAgICAgSU1lbWJlclZhbHVlUGFpcltdIG1lbWJlclZhbHVlUGFpcnMgPSBhbm5vdGF0aW9uLmdldE1lbWJlclZhbHVlUGFpcnMoKTsKKyAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpcnMubGVuZ3RoID4gMCkgeworICAgICAgICAgICAgZm9yIChJTWVtYmVyVmFsdWVQYWlyIG1lbWJlclZhbHVlUGFpciA6IG1lbWJlclZhbHVlUGFpcnMpIHsKKyAgICAgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyLmdldE1lbWJlck5hbWUoKS5lcXVhbHMoYXR0cmlidXRlTmFtZSkpIHsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gbnVsbDsKICAgICB9CiAKKyAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKKyAgICBwdWJsaWMgc3RhdGljIE1lbWJlclZhbHVlUGFpciBnZXRNZW1iZXJWYWx1ZVBhaXIoTm9ybWFsQW5ub3RhdGlvbiBub3JtYWxBbm5vdGF0aW9uLCBTdHJpbmcgbWVtYmVyTmFtZSkgeworICAgICAgICBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVzUGFpcnMgPSBub3JtYWxBbm5vdGF0aW9uLnZhbHVlcygpOworICAgICAgICBmb3IgKE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIgOiBtZW1iZXJWYWx1ZXNQYWlycykgeworICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpci5nZXROYW1lKCkuZ2V0SWRlbnRpZmllcigpLmVxdWFscyhtZW1iZXJOYW1lKSkgeworICAgICAgICAgICAgICAgIHJldHVybiBtZW1iZXJWYWx1ZVBhaXI7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIG51bGw7CisgICAgfQorCisgICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0U3RyaW5nVmFsdWUoQW5ub3RhdGlvbk1pcnJvciBtaXJyb3IsIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB7CisgICAgICAgIEFubm90YXRpb25WYWx1ZSBhbm5vdGF0aW9uVmFsdWUgPSBnZXRBbm5vdGF0aW9uVmFsdWUobWlycm9yLCBhdHRyaWJ1dGVOYW1lKTsKKyAgICAgICAgaWYgKGFubm90YXRpb25WYWx1ZSAhPSBudWxsKSB7CisgICAgICAgICAgICByZXR1cm4gYW5ub3RhdGlvblZhbHVlLmdldFZhbHVlKCkudG9TdHJpbmcoKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gbnVsbDsKKyAgICB9CisKKyAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRTdHJpbmdWYWx1ZShBbm5vdGF0aW9uIGFubm90YXRpb24sIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB7CisgICAgICAgIGlmIChhbm5vdGF0aW9uIGluc3RhbmNlb2YgTm9ybWFsQW5ub3RhdGlvbikgeworICAgICAgICAgICAgRXhwcmVzc2lvbiBleHByZXNzaW9uID0gZ2V0QW5ub3RhdGlvblZhbHVlKChOb3JtYWxBbm5vdGF0aW9uKSBhbm5vdGF0aW9uLCBhdHRyaWJ1dGVOYW1lKTsKKyAgICAgICAgICAgIGlmIChleHByZXNzaW9uICE9IG51bGwgJiYgZXhwcmVzc2lvbiBpbnN0YW5jZW9mIFN0cmluZ0xpdGVyYWwpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gKChTdHJpbmdMaXRlcmFsKSBleHByZXNzaW9uKS5nZXRMaXRlcmFsVmFsdWUoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICByZXR1cm4gbnVsbDsKKyAgICB9CisKICAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRTdHJpbmdWYWx1ZShJQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBTdHJpbmcgYXR0cmlidXRlTmFtZSkKICAgICB0aHJvd3MgSmF2YU1vZGVsRXhjZXB0aW9uIHsKICAgICAgICAgT2JqZWN0IHZhbHVlID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25WYWx1ZShhbm5vdGF0aW9uLCBhdHRyaWJ1dGVOYW1lKTsKQEAgLTEwODIsMTAgKzEwMTAsMjAgQEAKICAgICAgICAgcmV0dXJuIG51bGw7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0RW51bVZhbHVlKElBbm5vdGF0aW9uIGFubm90YXRpb24sIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB0aHJvd3MgSmF2YU1vZGVsRXhjZXB0aW9uIHsKLSAgICAgICAgU3RyaW5nIHZhbHVlID0gQW5ub3RhdGlvblV0aWxzLmdldFN0cmluZ1ZhbHVlKGFubm90YXRpb24sIGF0dHJpYnV0ZU5hbWUpOwotICAgICAgICBpZiAodmFsdWUgIT0gbnVsbCAmJiB2YWx1ZS5pbmRleE9mKCIuIikgIT0gLTEpIHsKLSAgICAgICAgICAgIHJldHVybiB2YWx1ZS5zdWJzdHJpbmcodmFsdWUubGFzdEluZGV4T2YoIi4iKSArIDEpOworICAgIHB1YmxpYyBzdGF0aWMgQm9vbGVhbiBnZXRCb29sZWFuVmFsdWUoQW5ub3RhdGlvbk1pcnJvciBtaXJyb3IsIFN0cmluZyBhdHRyaWJ1dGVOYW1lKSB7CisgICAgICAgIFN0cmluZyB2YWx1ZSA9IGdldFN0cmluZ1ZhbHVlKG1pcnJvciwgYXR0cmlidXRlTmFtZSk7CisgICAgICAgIGlmICh2YWx1ZSAhPSBudWxsKSB7CisgICAgICAgICAgICByZXR1cm4gQm9vbGVhbi52YWx1ZU9mKHZhbHVlKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gbnVsbDsKKyAgICB9CisKKyAgICBwdWJsaWMgc3RhdGljIEJvb2xlYW4gZ2V0Qm9vbGVhblZhbHVlKEFubm90YXRpb24gYW5ub3RhdGlvbiwgU3RyaW5nIGF0dHJpYnV0ZU5hbWUpIHsKKyAgICAgICAgaWYgKGFubm90YXRpb24gaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKSB7CisgICAgICAgICAgICBFeHByZXNzaW9uIGV4cHJlc3Npb24gPSBnZXRBbm5vdGF0aW9uVmFsdWUoKE5vcm1hbEFubm90YXRpb24pIGFubm90YXRpb24sIGF0dHJpYnV0ZU5hbWUpOworICAgICAgICAgICAgaWYgKGV4cHJlc3Npb24gIT0gbnVsbCAmJiBleHByZXNzaW9uIGluc3RhbmNlb2YgQm9vbGVhbkxpdGVyYWwpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gQm9vbGVhbi52YWx1ZU9mKCgoQm9vbGVhbkxpdGVyYWwpIGV4cHJlc3Npb24pLmJvb2xlYW5WYWx1ZSgpKTsKKyAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gbnVsbDsKICAgICB9CkBAIC0xMDk4LDMwICsxMDM2LDIxIEBACiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgT2JqZWN0IGdldEFubm90YXRpb25WYWx1ZShJQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBTdHJpbmcgYXR0cmlidXRlTmFtZSkKLSAgICB0aHJvd3MgSmF2YU1vZGVsRXhjZXB0aW9uIHsKLSAgICAgICAgSU1lbWJlclZhbHVlUGFpcltdIG1lbWJlclZhbHVlUGFpcnMgPSBhbm5vdGF0aW9uLmdldE1lbWJlclZhbHVlUGFpcnMoKTsKLSAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpcnMubGVuZ3RoID4gMCkgewotICAgICAgICAgICAgZm9yIChJTWVtYmVyVmFsdWVQYWlyIG1lbWJlclZhbHVlUGFpciA6IG1lbWJlclZhbHVlUGFpcnMpIHsKLSAgICAgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyLmdldE1lbWJlck5hbWUoKS5lcXVhbHMoYXR0cmlidXRlTmFtZSkpIHsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpOwotICAgICAgICAgICAgICAgIH0KKyAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRFbnVtVmFsdWUoQW5ub3RhdGlvbiBhbm5vdGF0aW9uLCBTdHJpbmcgYXR0cmlidXRlTmFtZSkgeworICAgICAgICBpZiAoYW5ub3RhdGlvbiBpbnN0YW5jZW9mIE5vcm1hbEFubm90YXRpb24pIHsKKyAgICAgICAgICAgIEV4cHJlc3Npb24gZXhwcmVzc2lvbiA9IGdldEFubm90YXRpb25WYWx1ZSgoTm9ybWFsQW5ub3RhdGlvbikgYW5ub3RhdGlvbiwgYXR0cmlidXRlTmFtZSk7CisgICAgICAgICAgICBpZiAoZXhwcmVzc2lvbiAhPSBudWxsICYmIGV4cHJlc3Npb24gaW5zdGFuY2VvZiBRdWFsaWZpZWROYW1lKSB7CisgICAgICAgICAgICAgICAgcmV0dXJuICgoUXVhbGlmaWVkTmFtZSkgZXhwcmVzc2lvbikuZ2V0TmFtZSgpLmdldElkZW50aWZpZXIoKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgICAgICByZXR1cm4gbnVsbDsKICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIElBbm5vdGF0aW9uIGdldEFubm90YXRpb24oSUFubm90YXRhYmxlIGFubm90YXRhYmxlLAotICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHRocm93cyBKYXZhTW9kZWxFeGNlcHRpb24gewotICAgICAgICBJQW5ub3RhdGlvbltdIGFubm90YXRpb25zID0gYW5ub3RhdGFibGUuZ2V0QW5ub3RhdGlvbnMoKTsKLSAgICAgICAgZm9yIChJQW5ub3RhdGlvbiBqZHRBbm5vdGF0aW9uIDogYW5ub3RhdGlvbnMpIHsKLSAgICAgICAgICAgIFN0cmluZyBhbm5vdGF0aW9uTmFtZSA9IGpkdEFubm90YXRpb24uZ2V0RWxlbWVudE5hbWUoKTsKLSAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uTmFtZS5lcXVhbHMoYW5ub3RhdGlvbi5nZXRDYW5vbmljYWxOYW1lKCkpCi0gICAgICAgICAgICAgICAgICAgIHx8IGFubm90YXRpb25OYW1lLmVxdWFscyhhbm5vdGF0aW9uLmdldFNpbXBsZU5hbWUoKSkpIHsKLSAgICAgICAgICAgICAgICByZXR1cm4gamR0QW5ub3RhdGlvbjsKLSAgICAgICAgICAgIH0KKyAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRFbnVtVmFsdWUoSUFubm90YXRpb24gYW5ub3RhdGlvbiwgU3RyaW5nIGF0dHJpYnV0ZU5hbWUpIHRocm93cyBKYXZhTW9kZWxFeGNlcHRpb24geworICAgICAgICBTdHJpbmcgdmFsdWUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgYXR0cmlidXRlTmFtZSk7CisgICAgICAgIGlmICh2YWx1ZSAhPSBudWxsICYmIHZhbHVlLmluZGV4T2YoIi4iKSAhPSAtMSkgeworICAgICAgICAgICAgcmV0dXJuIHZhbHVlLnN1YnN0cmluZyh2YWx1ZS5sYXN0SW5kZXhPZigiLiIpICsgMSk7CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIG51bGw7CiAgICAgfQotCiB9CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29uc3VtcHRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb25zdW1wdGlvbi9jb3JlL2NvbW1hbmRzL1dTREwySmF2YUNsaWVudENvbW1hbmQuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvbnN1bXB0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhQ2xpZW50Q29tbWFuZC5qYXZhCmluZGV4IDJkZmUyNjUuLjBiNjM3ZDcgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvbnN1bXB0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhQ2xpZW50Q29tbWFuZC5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvbnN1bXB0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhQ2xpZW50Q29tbWFuZC5qYXZhCkBAIC0yMSw2ICsyMSw3IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklBZGFwdGFibGU7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQcm9ncmVzc01vbml0b3I7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklTdGF0dXM7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlBhdGg7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlN0YXR1czsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JSmF2YVByb2plY3Q7CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmN4Zi5jb25zdW1wdGlvbi5jb3JlLkNYRkNvbnN1bXB0aW9uQ29yZVBsdWdpbjsKQEAgLTM1LDcgKzM2LDcgQEAKIC8qKgogICogRXhlY3V0ZXMgdGhlIDxjb2RlPm9yZy5hcGFjaGUuY3hmLnRvb2xzLndzZGx0by5XU0RMVG9KYXZhPC9jb2RlPiBjb21tYW5kIHdpdGggdGhlIGFyZ3VtZW50cwogICogbmVjZXNzYXJ5IHRvIGdlbmVyYXRlIGEgY2xpZW50LgotICogCisgKgogICovCiBwdWJsaWMgY2xhc3MgV1NETDJKYXZhQ2xpZW50Q29tbWFuZCBleHRlbmRzIEFic3RyYWN0RGF0YU1vZGVsT3BlcmF0aW9uIHsKICAgICBwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDWEZfVE9PTF9DTEFTU19OQU1FID0gIm9yZy5hcGFjaGUuY3hmLnRvb2xzLndzZGx0by5XU0RMVG9KYXZhIjsgLy8kTk9OLU5MUy0xJApAQCAtNTYsNyArNTcsNyBAQAogICAgIEBPdmVycmlkZQogICAgIHB1YmxpYyBJU3RhdHVzIGV4ZWN1dGUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yLCBJQWRhcHRhYmxlIGluZm8pIHRocm93cyBFeGVjdXRpb25FeGNlcHRpb24gewogICAgICAgICBJU3RhdHVzIHN0YXR1cyA9IFN0YXR1cy5PS19TVEFUVVM7Ci0gICAgICAgIGphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyID0gbmV3IEphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKG1vZGVsLmdldEphdmFTb3VyY2VGb2xkZXIoKSk7CisgICAgICAgIGphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyID0gbmV3IEphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKG5ldyBQYXRoKG1vZGVsLmdldEphdmFTb3VyY2VGb2xkZXIoKSkpOwogICAgICAgICBSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkuYWRkUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lcihqYXZhUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lciwKICAgICAgICAgICAgICAgICBJUmVzb3VyY2VDaGFuZ2VFdmVudC5QT1NUX0NIQU5HRSk7CiAKZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvbnN1bXB0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhQ2xpZW50RGVmYXVsdGluZ0NvbW1hbmQuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvbnN1bXB0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhQ2xpZW50RGVmYXVsdGluZ0NvbW1hbmQuamF2YQppbmRleCBjYTdlMTY2Li5kNjZlMzg4IDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29uc3VtcHRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb25zdW1wdGlvbi9jb3JlL2NvbW1hbmRzL1dTREwySmF2YUNsaWVudERlZmF1bHRpbmdDb21tYW5kLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNvbnN1bXB0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY29uc3VtcHRpb24vY29yZS9jb21tYW5kcy9XU0RMMkphdmFDbGllbnREZWZhdWx0aW5nQ29tbWFuZC5qYXZhCkBAIC0zMSwxMCArMzEsMTAgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS53c3QuY29tbW9uLmZyYW1ld29ya3MuZGF0YW1vZGVsLkFic3RyYWN0RGF0YU1vZGVsT3BlcmF0aW9uOwogCiAvKioKLSAqIExvYWRzIHRoZSA8Y29kZT5XU0RMMkphdmFEYXRhTW9kZWw8L2NvZGU+IHdpdGggdGhlIHBlcnNpc3RlZCBkZWZhdWx0cyAKKyAqIExvYWRzIHRoZSA8Y29kZT5XU0RMMkphdmFEYXRhTW9kZWw8L2NvZGU+IHdpdGggdGhlIHBlcnNpc3RlZCBkZWZhdWx0cwogICogZnJvbSB0aGUgcHJlZmVyZW5jZXMgYW5kIHdpdGggdGhlIGluaXRpYWwgcnVudGltZSBpbmZvcm1hdGlvbiBzdWNoIGFzIHRoZQogICogc3RhcnRpbmcgcG9pbnQgV1NETCBVUkwuCi0gKiAKKyAqCiAgKi8KIHB1YmxpYyBjbGFzcyBXU0RMMkphdmFDbGllbnREZWZhdWx0aW5nQ29tbWFuZCBleHRlbmRzIEFic3RyYWN0RGF0YU1vZGVsT3BlcmF0aW9uIHsKICAgICBwcml2YXRlIFdTREwySmF2YURhdGFNb2RlbCBtb2RlbDsKQEAgLTc5LDEzICs3OSwxMyBAQAogICAgICAgICBtb2RlbC5zZXRVc2VEZWZhdWx0VmFsdWVzKGNvbnRleHQuaXNVc2VEZWZhdWx0VmFsdWVzKCkpOwogICAgICAgICBtb2RlbC5zZXROb0FkZHJlc3NCaW5kaW5nKGNvbnRleHQuaXNOb0FkZHJlc3NCaW5kaW5nKCkpOwogICAgICAgICBtb2RlbC5zZXRBdXRvTmFtZVJlc29sdXRpb24oY29udGV4dC5pc0F1dG9OYW1lUmVzb2x1dGlvbigpKTsKLSAgICAgICAgCi0gICAgICAgIG1vZGVsLnNldEphdmFTb3VyY2VGb2xkZXIoSkRUVXRpbHMuZ2V0SmF2YVByb2plY3RTb3VyY2VEaXJlY3RvcnlQYXRoKG1vZGVsLmdldFByb2plY3ROYW1lKCkpKTsKKworICAgICAgICBtb2RlbC5zZXRKYXZhU291cmNlRm9sZGVyKEpEVFV0aWxzLmdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChtb2RlbC5nZXRQcm9qZWN0TmFtZSgpKS50b09TU3RyaW5nKCkpOwogCiAgICAgCXRyeSB7CiAgICAgCQlVUkwgd3NkbFVybCA9IG5ldyBVUkwoaW5wdXRVUkwpOwogCQkJbW9kZWwuc2V0V3NkbFVSTCh3c2RsVXJsKTsKLQkJCQorCiAJCQlEZWZpbml0aW9uIGRlZmluaXRpb24gPSBXU0RMVXRpbHMucmVhZFdTREwobW9kZWwuZ2V0V3NkbFVSTCgpKTsKICAgICAgICAgCWlmIChkZWZpbml0aW9uICE9IG51bGwpIHsKICAgICAgICAgCQlTdHJpbmcgdGFyZ2V0TmFtZXNwYWNlID0gZGVmaW5pdGlvbi5nZXRUYXJnZXROYW1lc3BhY2UoKTsKQEAgLTk3LDIyICs5NywyMiBAQAogICAgICAgICAgICAgICAgIGlmICh3c2RsTG9jYXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgICAgICAgICBtb2RlbC5zZXRXc2RsTG9jYXRpb24od3NkbExvY2F0aW9uKTsKICAgICAgICAgICAgICAgICB9Ci0gICAgICAgIAkJCisKICAgICAgICAgCQltb2RlbC5zZXRXc2RsRGVmaW5pdGlvbihkZWZpbml0aW9uKTsKICAgICAgICAgCX0KIAogCQl9IGNhdGNoIChNYWxmb3JtZWRVUkxFeGNlcHRpb24gbXVybGUpIHsKLQkJICAgIHN0YXR1cyA9IG5ldyBTdGF0dXMoSVN0YXR1cy5FUlJPUiwgQ1hGQ29uc3VtcHRpb25Db3JlUGx1Z2luLlBMVUdJTl9JRCwgCisJCSAgICBzdGF0dXMgPSBuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsIENYRkNvbnN1bXB0aW9uQ29yZVBsdWdpbi5QTFVHSU5fSUQsCiAJCSAgICAgICAgICAgIG11cmxlLmdldExvY2FsaXplZE1lc3NhZ2UoKSk7CiAJCQlDWEZDb25zdW1wdGlvbkNvcmVQbHVnaW4ubG9nKHN0YXR1cyk7CiAJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGlvZSkgewotCQkgICAgc3RhdHVzID0gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBDWEZDb25zdW1wdGlvbkNvcmVQbHVnaW4uUExVR0lOX0lELCAKKwkJICAgIHN0YXR1cyA9IG5ldyBTdGF0dXMoSVN0YXR1cy5FUlJPUiwgQ1hGQ29uc3VtcHRpb25Db3JlUGx1Z2luLlBMVUdJTl9JRCwKIAkJICAgIAkJaW9lLmdldExvY2FsaXplZE1lc3NhZ2UoKSk7CiAJCQlDWEZDb25zdW1wdGlvbkNvcmVQbHVnaW4ubG9nKHN0YXR1cyk7CiAJCX0KICAgICAgICAgcmV0dXJuIHN0YXR1czsKICAgICB9Ci0gICAgCisKICAgICBwdWJsaWMgV1NETDJKYXZhRGF0YU1vZGVsIGdldFdTREwySmF2YURhdGFNb2RlbCgpIHsKICAgICAgICAgcmV0dXJuIG1vZGVsOwogICAgIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb25zdW1wdGlvbi91aS93aWRnZXRzL29iamVjdC9KQVhXU1NlbGVjdGlvblRyYW5zZm9ybWVyLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29uc3VtcHRpb24udWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY29uc3VtcHRpb24vdWkvd2lkZ2V0cy9vYmplY3QvSkFYV1NTZWxlY3Rpb25UcmFuc2Zvcm1lci5qYXZhCmluZGV4IDBmMWJkNjEuLjI0MTdlNzggMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb25zdW1wdGlvbi51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb25zdW1wdGlvbi91aS93aWRnZXRzL29iamVjdC9KQVhXU1NlbGVjdGlvblRyYW5zZm9ybWVyLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNvbnN1bXB0aW9uLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvbnN1bXB0aW9uL3VpL3dpZGdldHMvb2JqZWN0L0pBWFdTU2VsZWN0aW9uVHJhbnNmb3JtZXIuamF2YQpAQCAtMTYsMTEgKzE2LDExIEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQYXRoOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklDb21waWxhdGlvblVuaXQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhQ29yZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhTW9kZWxFeGNlcHRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JU3RydWN0dXJlZFNlbGVjdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLlN0cnVjdHVyZWRTZWxlY3Rpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmN4Zi5jb25zdW1wdGlvbi51aS5DWEZDb25zdW1wdGlvblVJUGx1Z2luOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnV0aWxzLkpEVFV0aWxzOwogaW1wb3J0IG9yZy5lY2xpcHNlLndzdC5jb21tYW5kLmludGVybmFsLmVudi5jb3JlLmRhdGEuVHJhbnNmb3JtZXI7CiAKIEBTdXBwcmVzc1dhcm5pbmdzKCJyZXN0cmljdGlvbiIpCkBAIC02Myw3ICs2Myw3IEBACiAgICAgICAgIGlmIChwYXRoLmlzQWJzb2x1dGUoKSkgewogICAgICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgICAgICBJUGF0aCBqYXZhRm9sZGVyUGF0aCA9IHBhdGgucmVtb3ZlTGFzdFNlZ21lbnRzKDEpOwotICAgICAgICAgICAgICAgIElQYWNrYWdlRnJhZ21lbnQgcGFja2FnZUZyYWdtZW50ID0gSkRUVXRpbHMuZ2V0SmF2YVByb2plY3QocHJvamVjdCkuZmluZFBhY2thZ2VGcmFnbWVudCgKKyAgICAgICAgICAgICAgICBJUGFja2FnZUZyYWdtZW50IHBhY2thZ2VGcmFnbWVudCA9IEphdmFDb3JlLmNyZWF0ZShwcm9qZWN0KS5maW5kUGFja2FnZUZyYWdtZW50KAogICAgICAgICAgICAgICAgICAgICAgICAgamF2YUZvbGRlclBhdGgpOwogICAgICAgICAgICAgICAgIHJldHVybiBwYWNrYWdlRnJhZ21lbnQuZ2V0RWxlbWVudE5hbWUoKSArICIuIiArIGphdmFGaWxlTmFtZTsgLy8kTk9OLU5MUy0xJAogICAgICAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY29yZS9yZXNvdXJjZXMvSmF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvcmUvcmVzb3VyY2VzL0phdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyLmphdmEKaW5kZXggNDMyNDE4ZS4uMDNjOGU5OSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY29yZS9yZXNvdXJjZXMvSmF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb3JlL3Jlc291cmNlcy9KYXZhUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lci5qYXZhCkBAIC0yMywyNyArMjMsMjYgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQYXRoOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QYXRoOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5pbnRlcm5hbC5jeGYuY29yZS5DWEZDb3JlUGx1Z2luOwogCiAvKioKICAqIExpc3RlbnMgZm9yIGNoYW5nZXMgdG8gdGhlIDxjb2RlPklKYXZhUHJvamVjdDwvY29kZT4gc3JjIGZvbGRlci4KLSAqIAorICoKICAqLwogcHVibGljIGNsYXNzIEphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyIGltcGxlbWVudHMgSVJlc291cmNlQ2hhbmdlTGlzdGVuZXIgewogICAgIHByaXZhdGUgTGlzdDxJUmVzb3VyY2U+IGNoYW5nZWRSZXNvdXJjZXMgPSBuZXcgQXJyYXlMaXN0PElSZXNvdXJjZT4oKTsKIAotICAgIHByaXZhdGUgU3RyaW5nIHNvdXJjZURpcmVjdG9yeVBhdGg7Ci0gICAgCisgICAgcHJpdmF0ZSBJUGF0aCBzb3VyY2VEaXJlY3RvcnlQYXRoOworCiAgICAgLyoqCiAgICAgICogQ29uc3RydWN0cyBhIEphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyIGluc3RhbmNlLgotICAgICAqIAorICAgICAqCiAgICAgICogQHBhcmFtIHNvdXJjZURpcmVjdG9yeVBhdGgKICAgICAgKi8KLSAgICBwdWJsaWMgSmF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIoU3RyaW5nIHNvdXJjZURpcmVjdG9yeVBhdGgpIHsKKyAgICBwdWJsaWMgSmF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIoSVBhdGggc291cmNlRGlyZWN0b3J5UGF0aCkgewogICAgICAgICB0aGlzLnNvdXJjZURpcmVjdG9yeVBhdGggPSBzb3VyY2VEaXJlY3RvcnlQYXRoOwogICAgIH0KLSAgICAKKwogICAgIHB1YmxpYyB2b2lkIHJlc291cmNlQ2hhbmdlZChJUmVzb3VyY2VDaGFuZ2VFdmVudCBldmVudCkgewogICAgICAgICBpZiAoZXZlbnQuZ2V0VHlwZSgpICE9IElSZXNvdXJjZUNoYW5nZUV2ZW50LlBPU1RfQ0hBTkdFKSB7CiAgICAgICAgICAgICByZXR1cm47CkBAIC01MSw3ICs1MCw3IEBACiAgICAgICAgIElSZXNvdXJjZURlbHRhIHJvb3REZWx0YSA9IGV2ZW50LmdldERlbHRhKCk7CiAKICAgICAgICAgSVdvcmtzcGFjZVJvb3Qgd29ya3NwYWNlUm9vdCA9IFJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5nZXRSb290KCk7Ci0gICAgICAgIElGb2xkZXIgc3JjRm9sZGVyID0gd29ya3NwYWNlUm9vdC5nZXRGb2xkZXIobmV3IFBhdGgoc291cmNlRGlyZWN0b3J5UGF0aCkpOworICAgICAgICBJRm9sZGVyIHNyY0ZvbGRlciA9IHdvcmtzcGFjZVJvb3QuZ2V0Rm9sZGVyKHNvdXJjZURpcmVjdG9yeVBhdGgpOwogICAgICAgICBJUGF0aCBzcmNGb2xkZXJQYXRoID0gc3JjRm9sZGVyLmdldEZ1bGxQYXRoKCk7CiAgICAgICAgIGlmICghc3JjRm9sZGVyUGF0aC5oYXNUcmFpbGluZ1NlcGFyYXRvcigpKSB7CiAgICAgICAgICAgICBzcmNGb2xkZXJQYXRoID0gc3JjRm9sZGVyUGF0aC5hZGRUcmFpbGluZ1NlcGFyYXRvcigpOwpAQCAtNzksNyArNzgsNyBAQAogICAgICAgICAgICAgQ1hGQ29yZVBsdWdpbi5sb2coY2UuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIExpc3Q8SVJlc291cmNlPiBnZXRDaGFuZ2VkUmVzb3VyY2VzKCkgewogICAgICAgICByZXR1cm4gY2hhbmdlZFJlc291cmNlczsKICAgICB9CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb3JlL3V0aWxzL0NYRk1vZGVsVXRpbHMuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvcmUvdXRpbHMvQ1hGTW9kZWxVdGlscy5qYXZhCmluZGV4IDllOTNiYmYuLjBiMjQ1ZGQgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvcmUvdXRpbHMvQ1hGTW9kZWxVdGlscy5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NvcmUvdXRpbHMvQ1hGTW9kZWxVdGlscy5qYXZhCkBAIC0zMSw3ICszMSw2IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSmF2YU1vZGVsRXhjZXB0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5BU1Q7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFTVE5vZGU7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFic3RyYWN0VHlwZURlY2xhcmF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Db21waWxhdGlvblVuaXQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLk1lbWJlclZhbHVlUGFpcjsKQEAgLTU1LDcgKzU0LDcgQEAKIC8qKgogICogUHJvdmlkZXMgdXRpbGl0eSBtZXRob2RzIGZvciB3b3JraW5nIHdpdGggdGhlIENYRiBtb2RlbC4KICAqIEFsc28gc2VydmluZyBhcyBhbiBpbnRlcmltIGNsYXNzIHRvIGFpZCBpbiByZWZhY3RvcmluZyBjb3JlIHV0aWxpdGllcyBpbnRvIGpheHdzIGNvcmUuCi0gKiAKKyAqCiAgKi8KIHB1YmxpYyBmaW5hbCBjbGFzcyBDWEZNb2RlbFV0aWxzIHsKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBWZXJzaW9uIHZfMF8wXzAgPSBuZXcgVmVyc2lvbigiMC4wLjAiKTsKQEAgLTk2LDE4ICs5NSwxOCBAQAogICAgIHByaXZhdGUgQ1hGTW9kZWxVdGlscygpIHsKICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIHZvaWQgZ2V0V2ViU2VydmljZUFubm90YXRpb25DaGFuZ2UoSVR5cGUgdHlwZSwgSmF2YTJXU0RhdGFNb2RlbCBtb2RlbCwgCisgICAgcHVibGljIHN0YXRpYyB2b2lkIGdldFdlYlNlcnZpY2VBbm5vdGF0aW9uQ2hhbmdlKElUeXBlIHR5cGUsIEphdmEyV1NEYXRhTW9kZWwgbW9kZWwsCiAgICAgICAgICAgICBUZXh0RmlsZUNoYW5nZSB0ZXh0RmlsZUNoYW5nZSkgdGhyb3dzIENvcmVFeGNlcHRpb24gewogICAgICAgICBJQ29tcGlsYXRpb25Vbml0IHNvdXJjZSA9IHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCk7Ci0gICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7ICAgICAgICAKKyAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IFNoYXJlZEFTVFByb3ZpZGVyLmdldEFTVChzb3VyY2UsIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKIAogICAgICAgICBBU1QgYXN0ID0gY29tcGlsYXRpb25Vbml0LmdldEFTVCgpOwotICAgICAgICAKLSAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiB3ZWJTZXJ2aWNlQW5ub3RhdGlvbiA9IGdldEFubm90YXRpb24oY29tcGlsYXRpb25Vbml0LCB0eXBlLCBXZWJTZXJ2aWNlLmNsYXNzKTsKKworICAgICAgICBOb3JtYWxBbm5vdGF0aW9uIHdlYlNlcnZpY2VBbm5vdGF0aW9uID0gZ2V0QW5ub3RhdGlvbih0eXBlLCBXZWJTZXJ2aWNlLmNsYXNzKTsKICAgICAgICAgaWYgKHdlYlNlcnZpY2VBbm5vdGF0aW9uICE9IG51bGwgJiYgbW9kZWwuaXNVc2VTZXJ2aWNlRW5kcG9pbnRJbnRlcmZhY2UoKSAmJiB0eXBlLmlzQ2xhc3MoKSkgewogICAgICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIGVuZHBvaW50SW50ZXJmYWNlID0gZ2V0TWVtYmVyVmFsdWVQYWlyKHdlYlNlcnZpY2VBbm5vdGF0aW9uLCBFTkRQT0lOVF9JTlRFUkZBQ0UpOwogICAgICAgICAgICAgaWYgKGVuZHBvaW50SW50ZXJmYWNlICE9IG51bGwgJiYgZW5kcG9pbnRJbnRlcmZhY2UuZ2V0VmFsdWUoKSBpbnN0YW5jZW9mIFN0cmluZ0xpdGVyYWwpIHsKLSAgICAgICAgICAgIAlTdHJpbmdMaXRlcmFsIHN0cmluZ0xpdGVyYWwgPSAoU3RyaW5nTGl0ZXJhbCkgZW5kcG9pbnRJbnRlcmZhY2UuZ2V0VmFsdWUoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmdMaXRlcmFsIHN0cmluZ0xpdGVyYWwgPSAoU3RyaW5nTGl0ZXJhbCkgZW5kcG9pbnRJbnRlcmZhY2UuZ2V0VmFsdWUoKTsKICAgICAgICAgICAgICAgICBpZiAoIXN0cmluZ0xpdGVyYWwuZ2V0TGl0ZXJhbFZhbHVlKCkuZXF1YWxzKG1vZGVsLmdldFNlcnZpY2VFbmRwb2ludEludGVyZmFjZU5hbWUoKSkpIHsKICAgICAgICAgICAgICAgICAgICAgQVNUTm9kZSBuZXdTRUlWYWx1ZSA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdMaXRlcmFsKGFzdCwgbW9kZWwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZ2V0U2VydmljZUVuZHBvaW50SW50ZXJmYWNlTmFtZSgpKTsKQEAgLTEyMiw3ICsxMjEsNyBAQAogICAgICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZE1lbWJlclZhbHVlUGFpclRleHRFZGl0KHdlYlNlcnZpY2VBbm5vdGF0aW9uLCBlbmRwb2ludEludGVyZmFjZVBhaXIpKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgIElBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgYW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyID0gCisgICAgICAgICAgICBJQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciA9CiAgICAgICAgICAgICAgICAgQW5ub3RhdGlvbnNNYW5hZ2VyLmdldEFubm90YXRpb25EZWZpbml0aW9uRm9yQ2xhc3MoV2ViU2VydmljZS5jbGFzcykuCiAgICAgICAgICAgICAgICAgICAgIGdldEFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcigpOwogCkBAIC0xMzAsNyArMTI5LDcgQEAKICAgICAgICAgICAgICAgICAgICAgV2ViU2VydmljZS5jbGFzcyk7CiAKICAgICAgICAgICAgIGlmIChtb2RlbC5pc1VzZVNlcnZpY2VFbmRwb2ludEludGVyZmFjZSgpICYmIHR5cGUuaXNDbGFzcygpKSB7Ci0gICAgICAgICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIGVuZHBvaW50SW50ZXJmYWNlVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsIAorICAgICAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBlbmRwb2ludEludGVyZmFjZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LAogICAgICAgICAgICAgICAgICAgICAgICAgRU5EUE9JTlRfSU5URVJGQUNFLCBtb2RlbC5nZXRTZXJ2aWNlRW5kcG9pbnRJbnRlcmZhY2VOYW1lKCkpOwogICAgICAgICAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKDEsIGVuZHBvaW50SW50ZXJmYWNlVmFsdWVQYWlyKTsKICAgICAgICAgICAgIH0KQEAgLTEzOCwyNCArMTM3LDE3IEBACiAgICAgICAgICAgICBBbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTm9ybWFsQW5ub3RhdGlvbihhc3QsIFdlYlNlcnZpY2UuY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBtZW1iZXJWYWx1ZVBhaXJzKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbikpOwotICAgICAgICB9ICAgICAgICAKKyAgICAgICAgfQogICAgIH0KIAotICAgIEBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQotICAgIHByaXZhdGUgc3RhdGljIE5vcm1hbEFubm90YXRpb24gZ2V0QW5ub3RhdGlvbihDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0LCBJVHlwZSB0eXBlLAotICAgICAgICAgICAgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHsKLSAgICAgICAgTGlzdDxBYnN0cmFjdFR5cGVEZWNsYXJhdGlvbj4gdHlwZXMgPSBjb21waWxhdGlvblVuaXQudHlwZXMoKTsKLSAgICAgICAgZm9yIChBYnN0cmFjdFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24gOiB0eXBlcykgewotICAgICAgICAgICAgaWYgKEFubm90YXRpb25VdGlscy5jb21wYXJlVHlwZU5hbWVzKHR5cGVEZWNsYXJhdGlvbiwgdHlwZSkpIHsKLSAgICAgICAgICAgICAgICBBbm5vdGF0aW9uIGpkdEFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbih0eXBlRGVjbGFyYXRpb24sIGFubm90YXRpb24pOwotICAgICAgICAgICAgICAgIGlmIChqZHRBbm5vdGF0aW9uICE9IG51bGwgJiYgamR0QW5ub3RhdGlvbiBpbnN0YW5jZW9mIE5vcm1hbEFubm90YXRpb24pIHsKLSAgICAgICAgICAgICAgICAgICAgcmV0dXJuIChOb3JtYWxBbm5vdGF0aW9uKSBqZHRBbm5vdGF0aW9uOwotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIH0KKyAgICBwcml2YXRlIHN0YXRpYyBOb3JtYWxBbm5vdGF0aW9uIGdldEFubm90YXRpb24oSVR5cGUgdHlwZSwgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb24pIHsKKyAgICAgICAgQW5ub3RhdGlvbiBqZHRBbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZSwgYW5ub3RhdGlvbik7CisgICAgICAgIGlmIChqZHRBbm5vdGF0aW9uICE9IG51bGwgJiYgamR0QW5ub3RhdGlvbiBpbnN0YW5jZW9mIE5vcm1hbEFubm90YXRpb24pIHsKKyAgICAgICAgICAgIHJldHVybiAoTm9ybWFsQW5ub3RhdGlvbikgamR0QW5ub3RhdGlvbjsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gbnVsbDsKICAgICB9Ci0gICAgCisKICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKICAgICBwcml2YXRlIHN0YXRpYyBNZW1iZXJWYWx1ZVBhaXIgZ2V0TWVtYmVyVmFsdWVQYWlyKE5vcm1hbEFubm90YXRpb24gYW5ub3RhdGlvbiwgU3RyaW5nIG1lbWJlck5hbWUpIHsKICAgICAgICAgTGlzdDxNZW1iZXJWYWx1ZVBhaXI+IG1lbWJlclZhbHVlUGFpcnMgPSBhbm5vdGF0aW9uLnZhbHVlcygpOwpAQCAtMTY3LDggKzE1OSw4IEBACiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBjcmVhdGVNZXRob2RBbm5vdGF0aW9uQ2hhbmdlKElUeXBlIHR5cGUsIElNZXRob2QgbWV0aG9kLCAKLSAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MsIFRleHRGaWxlQ2hhbmdlIHRleHRGaWxlQ2hhbmdlKSAKKyAgICBwdWJsaWMgc3RhdGljIHZvaWQgY3JlYXRlTWV0aG9kQW5ub3RhdGlvbkNoYW5nZShJVHlwZSB0eXBlLCBJTWV0aG9kIG1ldGhvZCwKKyAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MsIFRleHRGaWxlQ2hhbmdlIHRleHRGaWxlQ2hhbmdlKQogICAgICAgICAgICAgICAgIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKICAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSB0eXBlLmdldENvbXBpbGF0aW9uVW5pdCgpOwogICAgICAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKHNvdXJjZSwgU2hhcmVkQVNUUHJvdmlkZXIuV0FJVF9ZRVMsIG51bGwpOwpAQCAtMTgwLDcgKzE3Miw3IEBACiAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIHZvaWQgZ2V0V2ViTWV0aG9kQW5ub3RhdGlvbkNoYW5nZShJVHlwZSB0eXBlLCBJTWV0aG9kIG1ldGhvZCwgCisgICAgcHVibGljIHN0YXRpYyB2b2lkIGdldFdlYk1ldGhvZEFubm90YXRpb25DaGFuZ2UoSVR5cGUgdHlwZSwgSU1ldGhvZCBtZXRob2QsCiAgICAgICAgICAgICBUZXh0RmlsZUNoYW5nZSB0ZXh0RmlsZUNoYW5nZSkgdGhyb3dzIENvcmVFeGNlcHRpb24gewogICAgICAgICBJQ29tcGlsYXRpb25Vbml0IHNvdXJjZSA9IHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCk7CiAgICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7CkBAIC0xOTEsOCArMTgzLDggQEAKIAogICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAgICAgfQotICAgIAotICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBnZXRSZXF1ZXN0V3JhcHBlckFubm90YXRpb25DaGFuZ2UoSVR5cGUgdHlwZSwgSU1ldGhvZCBtZXRob2QsIAorCisgICAgcHVibGljIHN0YXRpYyB2b2lkIGdldFJlcXVlc3RXcmFwcGVyQW5ub3RhdGlvbkNoYW5nZShJVHlwZSB0eXBlLCBJTWV0aG9kIG1ldGhvZCwKICAgICAgICAgICAgIFRleHRGaWxlQ2hhbmdlIHRleHRGaWxlQ2hhbmdlKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CiAgICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gdHlwZS5nZXRDb21waWxhdGlvblVuaXQoKTsKICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IFNoYXJlZEFTVFByb3ZpZGVyLmdldEFTVChzb3VyY2UsIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKQEAgLTIxNSw5ICsyMDcsOSBAQAogCiAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKICAgICB9Ci0gICAgCi0gICAgcHVibGljIHN0YXRpYyB2b2lkIGdldFdlYlBhcmFtQW5ub3RhdGlvbkNoYW5nZShJVHlwZSB0eXBlLCBmaW5hbCBJTWV0aG9kIG1ldGhvZCwgCi0gICAgICAgICAgICBJTG9jYWxWYXJpYWJsZSBwYXJhbWV0ZXIsIFRleHRGaWxlQ2hhbmdlIHRleHRGaWxlQ2hhbmdlKSAKKworICAgIHB1YmxpYyBzdGF0aWMgdm9pZCBnZXRXZWJQYXJhbUFubm90YXRpb25DaGFuZ2UoSVR5cGUgdHlwZSwgZmluYWwgSU1ldGhvZCBtZXRob2QsCisgICAgICAgICAgICBJTG9jYWxWYXJpYWJsZSBwYXJhbWV0ZXIsIFRleHRGaWxlQ2hhbmdlIHRleHRGaWxlQ2hhbmdlKQogICAgICAgICAgICAgdGhyb3dzIENvcmVFeGNlcHRpb24gewogICAgICAgICBJQ29tcGlsYXRpb25Vbml0IHNvdXJjZSA9IHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCk7CiAgICAgICAgIENvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBTaGFyZWRBU1RQcm92aWRlci5nZXRBU1Qoc291cmNlLCBTaGFyZWRBU1RQcm92aWRlci5XQUlUX1lFUywgbnVsbCk7CkBAIC0yMjgsMjcgKzIyMCwyNyBAQAogCiAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChwYXJhbWV0ZXIsIGFubm90YXRpb24pKTsKICAgICB9Ci0gICAgCi0gICAgcHJpdmF0ZSBzdGF0aWMgQW5ub3RhdGlvbiBnZXRBbm5vdGF0aW9uKElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwgQVNUIGFzdCwgCisKKyAgICBwcml2YXRlIHN0YXRpYyBBbm5vdGF0aW9uIGdldEFubm90YXRpb24oSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBBU1QgYXN0LAogICAgICAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MpIHsKLSAgICAgICAgCisKICAgICAgICAgSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciBhbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgPSBBbm5vdGF0aW9uc01hbmFnZXIuCiAgICAgICAgICAgICBnZXRBbm5vdGF0aW9uRGVmaW5pdGlvbkZvckNsYXNzKGFubm90YXRpb25DbGFzcykuZ2V0QW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyKCk7Ci0gICAgICAgIAotICAgICAgICBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycyA9IAorCisgICAgICAgIExpc3Q8TWVtYmVyVmFsdWVQYWlyPiBtZW1iZXJWYWx1ZVBhaXJzID0KICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIuZ2V0TWVtYmVyVmFsdWVQYWlycyhqYXZhRWxlbWVudCwgYXN0LCBhbm5vdGF0aW9uQ2xhc3MpOwotICAgICAgICAKKwogICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU5vcm1hbEFubm90YXRpb24oYXN0LCBhbm5vdGF0aW9uQ2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBtZW1iZXJWYWx1ZVBhaXJzKTsKICAgICB9Ci0gICAgCi0gICAgcHVibGljIHN0YXRpYyB2b2lkIGdldEltcG9ydHNDaGFuZ2UoSUNvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQsIEphdmEyV1NEYXRhTW9kZWwgbW9kZWwsIAorCisgICAgcHVibGljIHN0YXRpYyB2b2lkIGdldEltcG9ydHNDaGFuZ2UoSUNvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQsIEphdmEyV1NEYXRhTW9kZWwgbW9kZWwsCiAgICAgICAgICAgICBUZXh0RmlsZUNoYW5nZSB0ZXh0RmlsZUNoYW5nZSwgYm9vbGVhbiBjbGFzc09ubHkpIHsKICAgICAgICAgdHJ5IHsKLSAgICAgICAgCisKICAgICAgICAgICAgIEltcG9ydFJld3JpdGUgaW1wb3J0UmV3cml0ZSA9IENvZGVTdHlsZUNvbmZpZ3VyYXRpb24uY3JlYXRlSW1wb3J0UmV3cml0ZShjb21waWxhdGlvblVuaXQsIHRydWUpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGltcG9ydFJld3JpdGUuYWRkSW1wb3J0KEFOTk9UQVRJT05fVFlQRU5BTUVfTUFQLmdldChXRUJfU0VSVklDRSkpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGlmICghY2xhc3NPbmx5KSB7CiAgICAgICAgICAgICAgICAgTWFwPElNZXRob2QsIE1hcDxTdHJpbmcsIEJvb2xlYW4+PiBtZXRob2RBbm5vdGF0aW9uTWFwID0gbW9kZWwuZ2V0TWV0aG9kTWFwKCk7CiAgICAgICAgICAgICAgICAgU2V0PEVudHJ5PElNZXRob2QsIE1hcDxTdHJpbmcsIEJvb2xlYW4+Pj4gbWV0aG9kQW5ub3RhdGlvblNldCA9IG1ldGhvZEFubm90YXRpb25NYXAuZW50cnlTZXQoKTsKQEAgLTI1OSw3ICsyNTEsNyBAQAogICAgICAgICAgICAgICAgICAgICAgICAgaWYgKEFOTk9UQVRJT05fVFlQRU5BTUVfTUFQLmNvbnRhaW5zS2V5KG1ldGhvZC5nZXRLZXkoKSkgJiYgbWV0aG9kLmdldFZhbHVlKCkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbXBvcnRSZXdyaXRlLmFkZEltcG9ydChBTk5PVEFUSU9OX1RZUEVOQU1FX01BUC5nZXQobWV0aG9kLmdldEtleSgpKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgIH0gICAgICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICAgICAgaWYgKGltcG9ydFJld3JpdGUuaGFzUmVjb3JkZWRDaGFuZ2VzKCkpIHsKQEAgLTI4Miw3ICsyNzQsNyBAQAogICAgICAgICAgICAgSU1ldGhvZFtdIG1ldGhvZHMgPSB0eXBlLmdldE1ldGhvZHMoKTsKICAgICAgICAgICAgIGZvciAoSU1ldGhvZCBtZXRob2QgOiBtZXRob2RzKSB7CiAgICAgICAgICAgICAgICAgaWYgKHR5cGUuaXNJbnRlcmZhY2UoKSkgewotICAgICAgICAgICAgICAgICAgICBtZXRob2RNYXAucHV0KG1ldGhvZCwgZ2V0QW5ub3RhdGlvbk1hcChtb2RlbCkpOyAgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgICAgIG1ldGhvZE1hcC5wdXQobWV0aG9kLCBnZXRBbm5vdGF0aW9uTWFwKG1vZGVsKSk7CiAgICAgICAgICAgICAgICAgfSBlbHNlIGlmICh0eXBlLmlzQ2xhc3MoKSAmJiBKRFRVdGlscy5pc1B1YmxpY01ldGhvZChtZXRob2QpKSB7CiAgICAgICAgICAgICAgICAgICAgIG1ldGhvZE1hcC5wdXQobWV0aG9kLCBnZXRBbm5vdGF0aW9uTWFwKG1vZGVsKSk7CiAgICAgICAgICAgICAgICAgfQpAQCAtMjkyLDcgKzI4NCw3IEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIG1ldGhvZE1hcDsKICAgICB9Ci0gICAgCisKICAgICBwdWJsaWMgc3RhdGljIE1hcDxTdHJpbmcsIEJvb2xlYW4+IGdldEFubm90YXRpb25NYXAoSmF2YTJXU0RhdGFNb2RlbCBtb2RlbCkgewogICAgICAgICBNYXA8U3RyaW5nLCBCb29sZWFuPiBhbm5vdGF0aW9uZE1hcCA9IG5ldyBIYXNoTWFwPFN0cmluZywgQm9vbGVhbj4oKTsKICAgICAgICAgYW5ub3RhdGlvbmRNYXAucHV0KENYRk1vZGVsVXRpbHMuV0VCX01FVEhPRCwgbW9kZWwuaXNHZW5lcmF0ZVdlYk1ldGhvZEFubm90YXRpb24oKSk7CkBAIC0zMDEsMTEgKzI5MywxMSBAQAogICAgICAgICBhbm5vdGF0aW9uZE1hcC5wdXQoQ1hGTW9kZWxVdGlscy5SRVNQT05TRV9XUkFQUEVSLCBtb2RlbC5pc0dlbmVyYXRlUmVzcG9uc2VXcmFwcGVyQW5ub3RhdGlvbigpKTsKICAgICAgICAgcmV0dXJuIGFubm90YXRpb25kTWFwOwogICAgIH0KLSAgICAKKwogICAgIC8qKgogICAgICAqIENYRiB3c2RsMmphdmEgLWF1dG9OYW1lUmVzb2x1dGlvbiBpcyBzdXBwb3J0ZWQgaW4gdGhlIENYRiAyLjAgc3RyZWFtIGZyb20gMi4wLjcKICAgICAgKiBhbmQgaW4gdGhlIENYRiAyLjEgc3RyZWFtIGZyb20gMi4xLjEgdXAuCi0gICAgICogCisgICAgICoKICAgICAgKiBAcGFyYW0gY3hmUnVudGltZVZlcnNpb24KICAgICAgKiBAcmV0dXJuCiAgICAgICovCkBAIC0zMjYsNyArMzE4LDcgQEAKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIHN0YXRpYyBib29sZWFuIGdldERlZmF1bHRCb29sZWFuVmFsdWUoaW50IGNsYXNzaWZpZXJJRCwgaW50IGZlYXR1cmVJRCkgewogICAgICAgICBPYmplY3QgZGVmYXVsdFZhbHVlID0gbnVsbDsKIApkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY29yZS91dGlscy9Db21tYW5kTGluZVV0aWxzLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb3JlL3V0aWxzL0NvbW1hbmRMaW5lVXRpbHMuamF2YQppbmRleCBhZWQ2OGJhLi41OTc1MGYzIDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb3JlL3V0aWxzL0NvbW1hbmRMaW5lVXRpbHMuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jb3JlL3V0aWxzL0NvbW1hbmRMaW5lVXRpbHMuamF2YQpAQCAtODIsNyArODIsNyBAQAogCiAgICAgcHJpdmF0ZSBDb21tYW5kTGluZVV0aWxzKCkgewogICAgIH0KLSAgICAKKwogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nW10gZ2V0SmF2YTJXU1Byb2dyYW1Bcmd1bWVudHMoSmF2YTJXU0RhdGFNb2RlbCBtb2RlbCkgewogICAgICAgICBMaXN0PFN0cmluZz4gcHJvZ0FyZ3MgPSBuZXcgQXJyYXlMaXN0PFN0cmluZz4oKTsKIApAQCAtMTE1LDcgKzExNSw3IEBACiAgICAgICAgICAgICAgICAgaWYgKG1vZGVsLmlzR2VuZXJhdGVDbGllbnQoKSkgewogICAgICAgICAgICAgICAgICAgICBwcm9nQXJncy5hZGQoR0VOX0NMSUVOVCk7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgaWYgKG1vZGVsLmlzR2VuZXJhdGVTZXJ2ZXIoKSkgewogICAgICAgICAgICAgICAgICAgICBwcm9nQXJncy5hZGQoR0VOX1NFUlZFUik7CiAgICAgICAgICAgICAgICAgfQpAQCAtMTI3LDE0ICsxMjcsMTQgQEAKIAogICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKGNsYXNzTmFtZSk7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIChTdHJpbmdbXSkgcHJvZ0FyZ3MudG9BcnJheShuZXcgU3RyaW5nW3Byb2dBcmdzLnNpemUoKV0pOworICAgICAgICByZXR1cm4gcHJvZ0FyZ3MudG9BcnJheShuZXcgU3RyaW5nW3Byb2dBcmdzLnNpemUoKV0pOwogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgc3RhdGljIFN0cmluZ1tdIGdldFN0YW5kYXJkSmF2YTJXU0RMUHJvZ3JhbUFyZ3VtZW50cyhKYXZhMldTRGF0YU1vZGVsIG1vZGVsKSB7CiAgICAgICAgIFN0cmluZyBwcm9qZWN0TmFtZSA9IG1vZGVsLmdldFByb2plY3ROYW1lKCk7CiAgICAgICAgIExpc3Q8U3RyaW5nPiBwcm9nQXJncyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwogICAgICAgICBwcm9nQXJncy5hZGQoSjJXX0NMQVNTUEFUSCk7Ci0gICAgICAgIHByb2dBcmdzLmFkZChKRFRVdGlscy5nZXRKYXZhUHJvamVjdE91dHB1dERpcmVjdG9yeVBhdGgocHJvamVjdE5hbWUpKTsKKyAgICAgICAgcHJvZ0FyZ3MuYWRkKEpEVFV0aWxzLmdldEphdmFQcm9qZWN0T3V0cHV0RGlyZWN0b3J5UGF0aChwcm9qZWN0TmFtZSkudG9PU1N0cmluZygpKTsKIAogICAgICAgICBwcm9nQXJncy5hZGQoU09VUkNFX0RJUik7CiAgICAgICAgIHByb2dBcmdzLmFkZChGaWxlVXRpbHMuZ2V0VG1wRm9sZGVyKHByb2plY3ROYW1lKSArICIvc3JjIik7IC8vJE5PTi1OTFMtMSQKQEAgLTE0MywxMCArMTQzLDEwIEBACiAgICAgICAgIHByb2dBcmdzLmFkZChGaWxlVXRpbHMuZ2V0VG1wRm9sZGVyKHByb2plY3ROYW1lKSArICIvd3NkbCIpOyAvLyROT04tTkxTLTEkCiAKICAgICAgICAgcHJvZ0FyZ3MuYWRkKENMQVNTX0RJUik7Ci0gICAgICAgIHByb2dBcmdzLmFkZChKRFRVdGlscy5nZXRKYXZhUHJvamVjdE91dHB1dERpcmVjdG9yeVBhdGgocHJvamVjdE5hbWUpKTsKKyAgICAgICAgcHJvZ0FyZ3MuYWRkKEpEVFV0aWxzLmdldEphdmFQcm9qZWN0T3V0cHV0RGlyZWN0b3J5UGF0aChwcm9qZWN0TmFtZSkudG9PU1N0cmluZygpKTsKIAogICAgICAgICBwcm9nQXJncy5hZGQoT1VUX0ZJTEUpOwotICAgICAgICBwcm9nQXJncy5hZGQoKChKYXZhMldTRGF0YU1vZGVsKSBtb2RlbCkuZ2V0V3NkbEZpbGVOYW1lKCkpOworICAgICAgICBwcm9nQXJncy5hZGQobW9kZWwuZ2V0V3NkbEZpbGVOYW1lKCkpOwogCiAgICAgICAgIGlmIChtb2RlbC5pc1NvYXAxMkJpbmRpbmcoKSkgewogICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKElOQ19TT0FQMTIpOwpAQCAtMTU4LDggKzE1OCw4IEBACiAgICAgICAgIGlmIChtb2RlbC5pc1ZlcmJvc2UoKSkgewogICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKFZFUkJPU0UpOwogICAgICAgICB9Ci0gICAgICAgIAotICAgICAgICByZXR1cm4gKFN0cmluZ1tdKSBwcm9nQXJncy50b0FycmF5KG5ldyBTdHJpbmdbcHJvZ0FyZ3Muc2l6ZSgpXSk7CisKKyAgICAgICAgcmV0dXJuIHByb2dBcmdzLnRvQXJyYXkobmV3IFN0cmluZ1twcm9nQXJncy5zaXplKCldKTsKICAgICB9CiAKICAgICBwdWJsaWMgc3RhdGljIFN0cmluZ1tdIGdldFdTREwySmF2YVByb2dyYW1Bcmd1bWVudHMoV1NETDJKYXZhRGF0YU1vZGVsIG1vZGVsKSB7CkBAIC0xNzEsMTcgKzE3MSwxNyBAQAogICAgICAgICAgICAgLy8gQWRkIFN0YW5kYXJkIGFyZ3MKICAgICAgICAgICAgIHByb2dBcmdzLmFkZEFsbChBcnJheXMuYXNMaXN0KENvbW1hbmRMaW5lVXRpbHMuZ2V0U3RhbmRhcmRXU0RMMkphdmFQcm9ncmFtQXJndW1lbnRzKG1vZGVsLAogICAgICAgICAgICAgICAgICAgICBwcm9qZWN0TmFtZSkpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBTdHJpbmcgc2VydmljZU5hbWUgPSBtb2RlbC5nZXRTZXJ2aWNlTmFtZSgpOwogICAgICAgICAgICAgaWYgKHNlcnZpY2VOYW1lICE9IG51bGwgJiYgc2VydmljZU5hbWUubGVuZ3RoKCkgPiAwKSB7CiAgICAgICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKFcySl9TRVJWSUNFX05BTUUpOwogICAgICAgICAgICAgICAgIHByb2dBcmdzLmFkZChzZXJ2aWNlTmFtZSk7CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgaWYgKG1vZGVsLmlzVXNlRGVmYXVsdFZhbHVlcygpKSB7CiAgICAgICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKFcySl9ERUZBVUxUX1ZBTFVFUyk7CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgaWYgKG1vZGVsLmdldEN4ZlJ1bnRpbWVWZXJzaW9uKCkuY29tcGFyZVRvKENYRkNvcmVQbHVnaW4uQ1hGX1ZFUlNJT05fMl8xKSA+PSAwKSB7CiAgICAgICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKFcySl9GUk9OVEVORCk7CiAgICAgICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKG1vZGVsLmdldEZyb250ZW5kKCkuZ2V0TGl0ZXJhbCgpKTsKQEAgLTE5MSw3ICsxOTEsNyBAQAogCiAgICAgICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKFcySl9XU0RMX1ZFUlNJT04pOwogICAgICAgICAgICAgICAgIHByb2dBcmdzLmFkZChtb2RlbC5nZXRXc2RsVmVyc2lvbigpKTsKLSAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgIGlmIChtb2RlbC5pc05vQWRkcmVzc0JpbmRpbmcoKSkgewogICAgICAgICAgICAgICAgICAgICBwcm9nQXJncy5hZGQoVzJKX05PX0FERFJFU1NfQklORElORyk7CiAgICAgICAgICAgICAgICAgfQpAQCAtMTk5LDcgKzE5OSw3IEBACiAKICAgICAgICAgICAgIHByb2dBcmdzLmFkZChtb2RlbC5nZXRXc2RsVVJMKCkudG9FeHRlcm5hbEZvcm0oKSk7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIChTdHJpbmdbXSkgcHJvZ0FyZ3MudG9BcnJheShuZXcgU3RyaW5nW3Byb2dBcmdzLnNpemUoKV0pOworICAgICAgICByZXR1cm4gcHJvZ0FyZ3MudG9BcnJheShuZXcgU3RyaW5nW3Byb2dBcmdzLnNpemUoKV0pOwogICAgIH0KIAogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nW10gZ2V0V1NETDJKYXZhR2VuZXJhdGVDbGllbnRBcmd1bWVudHMoV1NETDJKYXZhRGF0YU1vZGVsIG1vZGVsKSB7CkBAIC0yMTMsMTYgKzIxMywxNiBAQAogICAgICAgICAgICAgLy8gQWRkIFdTTEQySmF2YSBhcmdzCiAgICAgICAgICAgICBwcm9nQXJncy5hZGRBbGwoQXJyYXlzLmFzTGlzdChDb21tYW5kTGluZVV0aWxzLmdldFdTREwySmF2YVByb2dyYW1Bcmd1bWVudHMobW9kZWwpKSk7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIChTdHJpbmdbXSkgcHJvZ0FyZ3MudG9BcnJheShuZXcgU3RyaW5nW3Byb2dBcmdzLnNpemUoKV0pOworICAgICAgICByZXR1cm4gcHJvZ0FyZ3MudG9BcnJheShuZXcgU3RyaW5nW3Byb2dBcmdzLnNpemUoKV0pOwogICAgIH0KLSAgICAKKwogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nW10gZ2V0U3RhbmRhcmRXU0RMMkphdmFQcm9ncmFtQXJndW1lbnRzKFdTREwySmF2YURhdGFNb2RlbCBtb2RlbCwgU3RyaW5nIHByb2plY3ROYW1lKSB7CiAgICAgICAgIExpc3Q8U3RyaW5nPiBwcm9nQXJncyA9IG5ldyBBcnJheUxpc3Q8U3RyaW5nPigpOwogICAgICAgICBwcm9nQXJncy5hZGQoUkVTT1VSQ0VfRElSKTsKICAgICAgICAgcHJvZ0FyZ3MuYWRkKEZpbGVVdGlscy5nZXRUbXBGb2xkZXIocHJvamVjdE5hbWUpICsgIi9zcmMiKTsgLy8kTk9OLU5MUy0xJAogCiAgICAgICAgIHByb2dBcmdzLmFkZChDTEFTU19ESVIpOwotICAgICAgICBwcm9nQXJncy5hZGQoSkRUVXRpbHMuZ2V0SmF2YVByb2plY3RPdXRwdXREaXJlY3RvcnlQYXRoKHByb2plY3ROYW1lKSk7CisgICAgICAgIHByb2dBcmdzLmFkZChKRFRVdGlscy5nZXRKYXZhUHJvamVjdE91dHB1dERpcmVjdG9yeVBhdGgocHJvamVjdE5hbWUpLnRvT1NTdHJpbmcoKSk7CiAKICAgICAgICAgTWFwPFN0cmluZywgU3RyaW5nPiBpbmNsdWRlZE5hbWVzcGFjZXMgPSBtb2RlbC5nZXRJbmNsdWRlZE5hbWVzcGFjZXMoKTsKICAgICAgICAgaWYgKGluY2x1ZGVkTmFtZXNwYWNlcyAhPSBudWxsICYmIG1vZGVsLmdldEluY2x1ZGVkTmFtZXNwYWNlcygpLnNpemUoKSA+IDApIHsKQEAgLTI0Miw3ICsyNDIsNyBAQAogICAgICAgICAgICAgICAgIHByb2dBcmdzLmFkZChiaW5kaW5nRmlsZSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKG1vZGVsLmlzR2VuZXJhdGVTZXJ2ZXIoKSkgewogICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKEdFTl9TRVJWRVIpOwogICAgICAgICB9CkBAIC0yNTQsMTMgKzI1NCwxMyBAQAogICAgICAgICBpZihtb2RlbC5pc1ZhbGlkYXRlKCkpIHsKICAgICAgICAgICAgIHByb2dBcmdzLmFkZChXMkpfVkFMSURBVEVfV1NETCk7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgcHJvZ0FyZ3MuYWRkKFcySl9FWFRfU09BUF9IRUFERVIpOwogICAgICAgICBwcm9nQXJncy5hZGQoQm9vbGVhbi50b1N0cmluZyhtb2RlbC5pc1Byb2Nlc3NTT0FQSGVhZGVycygpKSk7Ci0gICAgICAgIAorCiAgICAgICAgIHByb2dBcmdzLmFkZChXMkpfREVGQVVMVF9OQU1FU1BBQ0UpOwogICAgICAgICBwcm9nQXJncy5hZGQoQm9vbGVhbi50b1N0cmluZyhtb2RlbC5pc0xvYWREZWZhdWx0TmFtZXNwYWNlUGFja2FnZU5hbWVNYXBwaW5nKCkpKTsKLSAgICAgICAgCisKICAgICAgICAgcHJvZ0FyZ3MuYWRkKFcySl9ERUZBVUxUX0VYQ0xVREVfTlMpOwogICAgICAgICBwcm9nQXJncy5hZGQoQm9vbGVhbi50b1N0cmluZyhtb2RlbC5pc0xvYWREZWZhdWx0RXhjbHVkZXNOYW1lcHNhY2VNYXBwaW5nKCkpKTsKIApAQCAtMjc3LDExICsyNzcsMTEgQEAKICAgICAgICAgICAgIHByb2dBcmdzLmFkZChXMkpfV1NETF9MT0NBVElPTik7CiAgICAgICAgICAgICBwcm9nQXJncy5hZGQobW9kZWwuZ2V0V3NkbExvY2F0aW9uKCkpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChtb2RlbC5pc1ZlcmJvc2UoKSkgewogICAgICAgICAgICAgcHJvZ0FyZ3MuYWRkKFZFUkJPU0UpOwogICAgICAgICB9Ci0gICAgICAgIHJldHVybiAoU3RyaW5nW10pIHByb2dBcmdzLnRvQXJyYXkobmV3IFN0cmluZ1twcm9nQXJncy5zaXplKCldKTsKKyAgICAgICAgcmV0dXJuIHByb2dBcmdzLnRvQXJyYXkobmV3IFN0cmluZ1twcm9nQXJncy5zaXplKCldKTsKICAgICB9CiAKICAgICBwcml2YXRlIHN0YXRpYyBTdHJpbmcgZ2V0WEpDQXJncyhXU0RMMkphdmFEYXRhTW9kZWwgbW9kZWwpIHsKQEAgLTMwOSwxMSArMzA5LDExIEBACiAgICAgICAgIH0KIAogICAgICAgICBTdHJpbmcgeGpjQXJnID0geGpjQXJncy50b1N0cmluZygpOwotICAgICAgICB4amNBcmcgPSB4amNBcmcucmVwbGFjZSgnWycsICcgJyk7ICAgICAgICAKKyAgICAgICAgeGpjQXJnID0geGpjQXJnLnJlcGxhY2UoJ1snLCAnICcpOwogICAgICAgICB4amNBcmcgPSB4amNBcmcucmVwbGFjZSgnXScsICcgJyk7Ci0gICAgICAgIAorCiAgICAgICAgIHhqY0FyZyA9IHhqY0FyZy5yZXBsYWNlQWxsKCJcXHMiLCAiIik7IC8vJE5PTi1OTFMtMSQgLy8kTk9OLU5MUy0yJAotICAgICAgICAKKwogICAgICAgICByZXR1cm4geGpjQXJnLnRyaW0oKTsKICAgICB9CiB9CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi9jb3JlL2NvbW1hbmRzL0phdmEyV1NDb21tYW5kLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi9jb3JlL2NvbW1hbmRzL0phdmEyV1NDb21tYW5kLmphdmEKaW5kZXggMDUwMmMwNC4uMzk2YmI3OSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vY29yZS9jb21tYW5kcy9KYXZhMldTQ29tbWFuZC5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL2NvcmUvY29tbWFuZHMvSmF2YTJXU0NvbW1hbmQuamF2YQpAQCAtMjUsNiArMjUsOCBAQAogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JU3RhdHVzOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdGF0dXM7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUphdmFQcm9qZWN0OworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklUeXBlOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFDb3JlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5pbnRlcm5hbC5jeGYuY29yZS5DWEZDb3JlUGx1Z2luOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5pbnRlcm5hbC5jeGYuY29yZS5jb250ZXh0LkphdmEyV1NQZXJzaXN0ZW50Q29udGV4dDsKIGltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuaW50ZXJuYWwuY3hmLmNvcmUubW9kZWwuQ1hGRGF0YU1vZGVsOwpAQCAtNDAsMTAgKzQyLDEwIEBACiBpbXBvcnQgb3JnLmVjbGlwc2Uud3N0LmNvbW1vbi5mcmFtZXdvcmtzLmRhdGFtb2RlbC5BYnN0cmFjdERhdGFNb2RlbE9wZXJhdGlvbjsKIAogLyoqCi0gKiBQcm92aWRlcyBhIHdyYXBwZXIgYXJvdW5kIHRoZSA8Y29kZT5vcmcuYXBhY2hlLmN4Zi50b29scy5qYXZhMndzLkphdmFUb1dTPC9jb2RlPiBvciB0aGUgCisgKiBQcm92aWRlcyBhIHdyYXBwZXIgYXJvdW5kIHRoZSA8Y29kZT5vcmcuYXBhY2hlLmN4Zi50b29scy5qYXZhMndzLkphdmFUb1dTPC9jb2RlPiBvciB0aGUKICAqIDxjb2RlPm9yZy5hcGFjaGUuY3hmLnRvb2xzLmphdmEyd3NkbC5KYXZhVG9XU0RMPC9jb2RlPiBjb21tYW5kIGRlcGVuZGluZyBvbiB0aGUgdmVyc2lvbgogICogb2YgQ1hGIHVzZWQuCi0gKiAKKyAqCiAgKi8KIHB1YmxpYyBjbGFzcyBKYXZhMldTQ29tbWFuZCBleHRlbmRzIEFic3RyYWN0RGF0YU1vZGVsT3BlcmF0aW9uIHsKICAgICBwcml2YXRlIHN0YXRpYyBTdHJpbmcgSkFWQTJXU0RMX1RPT0xfQ0xBU1NfTkFNRSA9ICJvcmcuYXBhY2hlLmN4Zi50b29scy5qYXZhMndzZGwuSmF2YVRvV1NETCI7IC8vJE5PTi1OTFMtMSQKQEAgLTUyLDEwICs1NCwxMCBAQAogCiAgICAgcHJpdmF0ZSBKYXZhMldTRGF0YU1vZGVsIG1vZGVsOwogICAgIHByaXZhdGUgU3RyaW5nIHByb2plY3ROYW1lOwotICAgIAorCiAgICAgcHJpdmF0ZSBKYXZhUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lciBqYXZhUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lcjsKICAgICBwcml2YXRlIFdlYkNvbnRlbnRDaGFuZ2VMaXN0ZW5lciB3ZWJDb250ZW50Q2hhbmdlTGlzdGVuZXI7Ci0gICAgCisKICAgICBwdWJsaWMgSmF2YTJXU0NvbW1hbmQoSmF2YTJXU0RhdGFNb2RlbCBtb2RlbCkgewogICAgICAgICB0aGlzLm1vZGVsID0gbW9kZWw7CiAgICAgICAgIHByb2plY3ROYW1lID0gbW9kZWwuZ2V0UHJvamVjdE5hbWUoKTsKQEAgLTY0LDEzICs2NiwxNCBAQAogICAgIEBPdmVycmlkZQogICAgIHB1YmxpYyBJU3RhdHVzIGV4ZWN1dGUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yLCBJQWRhcHRhYmxlIGluZm8pIHRocm93cyBFeGVjdXRpb25FeGNlcHRpb24gewogICAgICAgICBJU3RhdHVzIHN0YXR1cyA9IFN0YXR1cy5PS19TVEFUVVM7CisgICAgICAgIElUeXBlIHN0YXJ0aW5nUG9pbnQgPSBKRFRVdGlscy5nZXRUeXBlKHByb2plY3ROYW1lLCBtb2RlbC5nZXRKYXZhU3RhcnRpbmdQb2ludCgpKTsKICAgICAgICAgamF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIgPSBuZXcgSmF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIoSkRUVXRpbHMKLSAgICAgICAgICAgICAgICAuZ2V0SmF2YVByb2plY3RTb3VyY2VEaXJlY3RvcnlQYXRoKHByb2plY3ROYW1lLCBtb2RlbC5nZXRKYXZhU3RhcnRpbmdQb2ludCgpKSk7CisgICAgICAgICAgICAgICAgLmdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChzdGFydGluZ1BvaW50KSk7CiAgICAgICAgIHdlYkNvbnRlbnRDaGFuZ2VMaXN0ZW5lciA9IG5ldyBXZWJDb250ZW50Q2hhbmdlTGlzdGVuZXIocHJvamVjdE5hbWUpOwogCi0gICAgICAgIFJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5hZGRSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKGphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyLCAKKyAgICAgICAgUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLmFkZFJlc291cmNlQ2hhbmdlTGlzdGVuZXIoamF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIsCiAgICAgICAgICAgICAgICAgSVJlc291cmNlQ2hhbmdlRXZlbnQuUE9TVF9DSEFOR0UpOwotICAgICAgICBSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkuYWRkUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lcih3ZWJDb250ZW50Q2hhbmdlTGlzdGVuZXIsIAorICAgICAgICBSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkuYWRkUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lcih3ZWJDb250ZW50Q2hhbmdlTGlzdGVuZXIsCiAgICAgICAgICAgICAgICAgSVJlc291cmNlQ2hhbmdlRXZlbnQuUE9TVF9DSEFOR0UpOwogCiAgICAgICAgIGlmIChtb2RlbC5nZXRDeGZSdW50aW1lVmVyc2lvbigpLmNvbXBhcmVUbyhDWEZDb3JlUGx1Z2luLkNYRl9WRVJTSU9OXzJfMSkgPj0gMCkgewpAQCAtODMsMTggKzg2LDE4IEBACiAKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIElQcm9qZWN0IHByb2plY3QgPSBGaWxlVXRpbHMuZ2V0UHJvamVjdChwcm9qZWN0TmFtZSk7Ci0gICAgICAgICAgICBJSmF2YVByb2plY3QgamF2YVByb2plY3QgPSBKRFRVdGlscy5nZXRKYXZhUHJvamVjdChwcm9qZWN0KTsKKyAgICAgICAgICAgIElKYXZhUHJvamVjdCBqYXZhUHJvamVjdCA9IEphdmFDb3JlLmNyZWF0ZShwcm9qZWN0KTsKICAgICAgICAgICAgIExhdW5jaFV0aWxzLmxhdW5jaChqYXZhUHJvamVjdCwgQ1hGX1RPT0xfQ0xBU1NfTkFNRSwgcHJvZ0FyZ3MpOwogICAgICAgICAgICAgRmlsZVV0aWxzLmNvcHlKMldGaWxlc0Zyb21UbXAobW9kZWwpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGlmIChtb2RlbC5pc0dlbmVyYXRlV1NETCgpKSB7CiAgICAgICAgICAgICAJU3ByaW5nVXRpbHMubG9hZFNwcmluZ0NvbmZpZ0luZm9ybWF0aW9uRnJvbVdTREwoKG1vZGVsKSk7CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgaWYgKGlzSW1wbGVtZW50YXRpb25TZWxlY3RlZCgpIHx8IGlzR2VuZXJhdGVTZXJ2ZXIoKSkgewogICAgICAgICAgICAgICAgIFNwcmluZ1V0aWxzLmNyZWF0ZUpBWFdTRW5kcG9pbnQobW9kZWwpOwogICAgICAgICAgICAgfQotICAgICAgICAgICAgCisKICAgICAgICAgfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBjZSkgewogICAgICAgICAgICAgc3RhdHVzID0gY2UuZ2V0U3RhdHVzKCk7CiAgICAgICAgICAgICBDWEZDcmVhdGlvbkNvcmVQbHVnaW4ubG9nKHN0YXR1cyk7CkBAIC0xMTEsNyArMTE0LDcgQEAKICAgICB9CiAKIAlwcml2YXRlIGJvb2xlYW4gaXNJbXBsZW1lbnRhdGlvblNlbGVjdGVkKCkgewotICAgICAgICByZXR1cm4gKG1vZGVsLmdldEZ1bGx5UXVhbGlmaWVkSmF2YUNsYXNzTmFtZSgpICE9IG51bGwgJiYgCisgICAgICAgIHJldHVybiAobW9kZWwuZ2V0RnVsbHlRdWFsaWZpZWRKYXZhQ2xhc3NOYW1lKCkgIT0gbnVsbCAmJgogICAgICAgICAgICAgICAgIG1vZGVsLmdldEZ1bGx5UXVhbGlmaWVkSmF2YUNsYXNzTmFtZSgpLnRyaW0oKS5sZW5ndGgoKSA+IDApOwogICAgIH0KIApAQCAtMTIyLDcgKzEyNSw3IEBACiAJCX0KIAkJcmV0dXJuIGZhbHNlOwogCX0KLSAgICAKKwogICAgIEBPdmVycmlkZQogICAgIHB1YmxpYyBJU3RhdHVzIHVuZG8oSVByb2dyZXNzTW9uaXRvciBtb25pdG9yLCBJQWRhcHRhYmxlIGluZm8pIHRocm93cyBFeGVjdXRpb25FeGNlcHRpb24gewogICAgICAgICBJU3RhdHVzIHN0YXR1cyA9IFN0YXR1cy5PS19TVEFUVVM7CkBAIC0xNDgsNyArMTUxLDcgQEAKICAgICAgICAgbW9kZWwuc2V0R2VuZXJhdGVYU0RJbXBvcnRzKGNvbnRleHQuaXNHZW5lcmF0ZVhTREltcG9ydHMoKSk7CiAgICAgICAgIHJldHVybiBzdGF0dXM7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIENYRkRhdGFNb2RlbCBnZXRDWEZEYXRhTW9kZWwoKSB7CiAgICAgICAgIHJldHVybiBtb2RlbDsKICAgICB9CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi9jb3JlL2NvbW1hbmRzL0phdmEyV1NEZWZhdWx0aW5nQ29tbWFuZC5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vY29yZS9jb21tYW5kcy9KYXZhMldTRGVmYXVsdGluZ0NvbW1hbmQuamF2YQppbmRleCBmYjdkNDk3Li45YTdjMmIzIDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi9jb3JlL2NvbW1hbmRzL0phdmEyV1NEZWZhdWx0aW5nQ29tbWFuZC5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL2NvcmUvY29tbWFuZHMvSmF2YTJXU0RlZmF1bHRpbmdDb21tYW5kLmphdmEKQEAgLTQzLDEzICs0MywxMyBAQAogICAgICAgICAgICAgbW9kZWwuc2V0Q3hmUnVudGltZVZlcnNpb24oY29udGV4dC5nZXRDeGZSdW50aW1lVmVyc2lvbigpKTsKICAgICAgICAgICAgIG1vZGVsLnNldEN4ZlJ1bnRpbWVFZGl0aW9uKGNvbnRleHQuZ2V0Q3hmUnVudGltZUVkaXRpb24oKSk7CiAKLSAgICAgICAgICAgIElUeXBlIHN0YXJ0aW5nUG9pbnRUeXBlID0gZ2V0SmF2YVN0YXJ0aW5nUG9pbnRUeXBlKCk7IAorICAgICAgICAgICAgSVR5cGUgc3RhcnRpbmdQb2ludFR5cGUgPSBnZXRKYXZhU3RhcnRpbmdQb2ludFR5cGUoKTsKICAgICAgICAgICAgIG1vZGVsLnNldFVzZVNlcnZpY2VFbmRwb2ludEludGVyZmFjZShzdGFydGluZ1BvaW50VHlwZS5pc0ludGVyZmFjZSgpKTsKICAgICAgICAgICAgIG1vZGVsLnNldEV4dHJhY3RJbnRlcmZhY2UoZmFsc2UpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIFN0cmluZyBwYWNrYWdlTmFtZSA9IHN0YXJ0aW5nUG9pbnRUeXBlLmdldFBhY2thZ2VGcmFnbWVudCgpLmdldEVsZW1lbnROYW1lKCk7CiAgICAgICAgICAgICBtb2RlbC5zZXRUYXJnZXROYW1lc3BhY2UoSkRUVXRpbHMuZ2V0VGFyZ2V0TmFtZXNwYWNlRnJvbVBhY2thZ2VOYW1lKHBhY2thZ2VOYW1lKSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgbW9kZWwuc2V0QW5ub3RhdGlvblByb2Nlc3NpbmdFbmFibGVkKGNvbnRleHQuaXNBbm5vdGF0aW9uUHJvY2Vzc2luZ0VuYWJsZWQoKSk7CiAgICAgICAgICAgICBtb2RlbC5zZXRHZW5lcmF0ZVdlYk1ldGhvZEFubm90YXRpb24oY29udGV4dC5pc0dlbmVyYXRlV2ViTWV0aG9kQW5ub3RhdGlvbigpKTsKICAgICAgICAgICAgIG1vZGVsLnNldEdlbmVyYXRlV2ViUGFyYW1Bbm5vdGF0aW9uKGNvbnRleHQuaXNHZW5lcmF0ZVdlYlBhcmFtQW5ub3RhdGlvbigpKTsKQEAgLTU3LDcgKzU3LDcgQEAKICAgICAgICAgICAgIG1vZGVsLnNldEdlbmVyYXRlUmVzcG9uc2VXcmFwcGVyQW5ub3RhdGlvbihjb250ZXh0LmlzR2VuZXJhdGVSZXNwb25zZVdyYXBwZXJBbm5vdGF0aW9uKCkpOwogICAgICAgICAgICAgbW9kZWwuc2V0QW5ub3RhdGlvbk1hcChDWEZNb2RlbFV0aWxzLmdldEFubm90YXRpb25NYXAobW9kZWwpKTsKICAgICAgICAgICAgIG1vZGVsLnNldE1ldGhvZE1hcChDWEZNb2RlbFV0aWxzLmdldE1ldGhvZE1hcChzdGFydGluZ1BvaW50VHlwZSwgbW9kZWwpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBtb2RlbC5zZXRHZW5lcmF0ZVhTREltcG9ydHMoY29udGV4dC5pc0dlbmVyYXRlWFNESW1wb3J0cygpKTsKICAgICAgICAgICAgIG1vZGVsLnNldERhdGFiaW5kaW5nKGNvbnRleHQuZ2V0RGF0YWJpbmRpbmcoKSk7CiAgICAgICAgICAgICBtb2RlbC5zZXRGcm9udGVuZChjb250ZXh0LmdldEZyb250ZW5kKCkpOwpAQCAtNjgsOCArNjgsOCBAQAogICAgICAgICAgICAgbW9kZWwuc2V0R2VuZXJhdGVXU0RMKGNvbnRleHQuaXNHZW5lcmF0ZVdTREwoKSk7CiAgICAgICAgICAgICBtb2RlbC5zZXRVc2VTcHJpbmdBcHBsaWNhdGlvbkNvbnRleHQoY29udGV4dC5pc1VzZVNwcmluZ0FwcGxpY2F0aW9uQ29udGV4dCgpKTsKICAgICAgICAgICAgIG1vZGVsLnNldFZlcmJvc2UoY29udGV4dC5pc1ZlcmJvc2UoKSk7Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIFN0cmluZyBjbGFzc05hbWUgPSBKRFRVdGlscy5nZXRDbGFzc05hbWUobW9kZWwuZ2V0UHJvamVjdE5hbWUoKSwgbW9kZWwuZ2V0SmF2YVN0YXJ0aW5nUG9pbnQoKSk7CisKKyAgICAgICAgICAgIFN0cmluZyBjbGFzc05hbWUgPSBnZXRDbGFzc05hbWUobW9kZWwuZ2V0UHJvamVjdE5hbWUoKSwgbW9kZWwuZ2V0SmF2YVN0YXJ0aW5nUG9pbnQoKSk7CiAgICAgICAgICAgICBtb2RlbC5zZXRXc2RsRmlsZU5hbWUoY2xhc3NOYW1lLnRvTG93ZXJDYXNlKCkgKyBXU0RMVXRpbHMuV1NETF9GSUxFX0VYVEVOU0lPTik7CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKICAgICAgICAgICAgIHN0YXR1cyA9IGptZS5nZXRTdGF0dXMoKTsKQEAgLTkxLDEwICs5MSwxNSBAQAogICAgICAgICByZXR1cm4gc3RhcnRpbmdQb2ludFR5cGU7CiAgICAgfQogCisgICAgcHVibGljIFN0cmluZyBnZXRDbGFzc05hbWUoU3RyaW5nIHByb2plY3ROYW1lLCBTdHJpbmcgZnVsbHlRdWFsaWZpZWRDbGFzc05hbWUpIHsKKyAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldFR5cGUoSkRUVXRpbHMuZ2V0SmF2YVByb2plY3QocHJvamVjdE5hbWUpLCBmdWxseVF1YWxpZmllZENsYXNzTmFtZSkKKyAgICAgICAgICAgICAgICAuZ2V0RWxlbWVudE5hbWUoKTsKKyAgICB9CisKICAgICBAT3ZlcnJpZGUKICAgICBwdWJsaWMgSVN0YXR1cyB1bmRvKElQcm9ncmVzc01vbml0b3IgbW9uaXRvciwgSUFkYXB0YWJsZSBpbmZvKSB0aHJvd3MgRXhlY3V0aW9uRXhjZXB0aW9uIHsKICAgICAgICAgSVN0YXR1cyBzdGF0dXMgPSBTdGF0dXMuT0tfU1RBVFVTOwotICAgICAgICAKKwogICAgICAgICByZXR1cm4gc3RhdHVzOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhQ29tbWFuZC5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vY29yZS9jb21tYW5kcy9XU0RMMkphdmFDb21tYW5kLmphdmEKaW5kZXggNTcxYjQ2NC4uMzhmOWRhNSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vY29yZS9jb21tYW5kcy9XU0RMMkphdmFDb21tYW5kLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vY29yZS9jb21tYW5kcy9XU0RMMkphdmFDb21tYW5kLmphdmEKQEAgLTIyLDYgKzIyLDcgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSUFkYXB0YWJsZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVByb2dyZXNzTW9uaXRvcjsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuUGF0aDsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuU3RhdHVzOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklKYXZhUHJvamVjdDsKIGltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuaW50ZXJuYWwuY3hmLmNvcmUubW9kZWwuQ1hGRGF0YU1vZGVsOwpAQCAtMzksMTIgKzQwLDEyIEBACiAKIC8qKgogICogUHJvdmlkZXMgYSB3cmFwcGVyIGFyb3VuZCB0aGUgPGNvZGU+b3JnLmFwYWNoZS5jeGYudG9vbHMud3NkbHRvLldTRExUb0phdmE8L2NvZGU+IGNvbW1hbmQuCi0gKiAKKyAqCiAgKi8KIEBTdXBwcmVzc1dhcm5pbmdzKCJyZXN0cmljdGlvbiIpCiBwdWJsaWMgY2xhc3MgV1NETDJKYXZhQ29tbWFuZCBleHRlbmRzIEFic3RyYWN0RGF0YU1vZGVsT3BlcmF0aW9uIHsKICAgICBwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBDWEZfVE9PTF9DTEFTU19OQU1FID0gIm9yZy5hcGFjaGUuY3hmLnRvb2xzLndzZGx0by5XU0RMVG9KYXZhIjsgLy8kTk9OLU5MUy0xJAotICAgIAorCiAgICAgcHJpdmF0ZSBXU0RMMkphdmFEYXRhTW9kZWwgbW9kZWw7CiAgICAgcHJpdmF0ZSBJV2ViU2VydmljZSB3czsKIApAQCAtNTksNyArNjAsNyBAQAogICAgIEBPdmVycmlkZQogICAgIHB1YmxpYyBJU3RhdHVzIGV4ZWN1dGUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yLCBJQWRhcHRhYmxlIGluZm8pIHRocm93cyBFeGVjdXRpb25FeGNlcHRpb24gewogICAgICAgICBJU3RhdHVzIHN0YXR1cyA9IFN0YXR1cy5PS19TVEFUVVM7Ci0gICAgICAgIGphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyID0gbmV3IEphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKG1vZGVsLmdldEphdmFTb3VyY2VGb2xkZXIoKSk7CisgICAgICAgIGphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyID0gbmV3IEphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKG5ldyBQYXRoKG1vZGVsLmdldEphdmFTb3VyY2VGb2xkZXIoKSkpOwogICAgICAgICB3ZWJDb250ZW50Q2hhbmdlTGlzdGVuZXIgPSBuZXcgV2ViQ29udGVudENoYW5nZUxpc3RlbmVyKG1vZGVsLmdldFByb2plY3ROYW1lKCkpOwogCiAgICAgICAgIFJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5hZGRSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKGphdmFSZXNvdXJjZUNoYW5nZUxpc3RlbmVyLApAQCAtNjgsNyArNjksNyBAQAogICAgICAgICAgICAgICAgIElSZXNvdXJjZUNoYW5nZUV2ZW50LlBPU1RfQ0hBTkdFKTsKIAogICAgICAgICBTdHJpbmcgcHJvamVjdE5hbWUgPSBtb2RlbC5nZXRQcm9qZWN0TmFtZSgpOwotICAgICAgICAKKwogICAgICAgICAvL1RPRE8gcmV2aXNpdAogICAgICAgICB3cy5nZXRXZWJTZXJ2aWNlSW5mbygpLnNldEltcGxVUkxzKG5ldyBTdHJpbmdbXSB7cHJvamVjdE5hbWUgKyAiL0ltcGwuamF2YSJ9KTsgLy8kTk9OLU5MUy0xJAogCkBAIC04OCw3ICs4OSw3IEBACiAgICAgICAgICAgICBDWEZDcmVhdGlvbkNvcmVQbHVnaW4ubG9nKHN0YXR1cyk7CiAgICAgICAgIH0gY2F0Y2ggKElPRXhjZXB0aW9uIGlvZSkgewogICAgICAgICAgICAgc3RhdHVzID0gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBDWEZDcmVhdGlvbkNvcmVQbHVnaW4uUExVR0lOX0lELCBpb2UuZ2V0TG9jYWxpemVkTWVzc2FnZSgpKTsKLSAgICAgICAgICAgIENYRkNyZWF0aW9uQ29yZVBsdWdpbi5sb2coc3RhdHVzKTsgIAorICAgICAgICAgICAgQ1hGQ3JlYXRpb25Db3JlUGx1Z2luLmxvZyhzdGF0dXMpOwogICAgICAgICB9IGZpbmFsbHkgewogICAgICAgICAgICAgUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLnJlbW92ZVJlc291cmNlQ2hhbmdlTGlzdGVuZXIoamF2YVJlc291cmNlQ2hhbmdlTGlzdGVuZXIpOwogICAgICAgICAgICAgUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLnJlbW92ZVJlc291cmNlQ2hhbmdlTGlzdGVuZXIod2ViQ29udGVudENoYW5nZUxpc3RlbmVyKTsKQEAgLTExNiw3ICsxMTcsNyBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBzdGF0dXM7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIENYRkRhdGFNb2RlbCBnZXRDWEZEYXRhTW9kZWwoKSB7CiAgICAgICAgIHJldHVybiBtb2RlbDsKICAgICB9CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi9jb3JlL2NvbW1hbmRzL1dTREwySmF2YURlZmF1bHRpbmdDb21tYW5kLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24uY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi9jb3JlL2NvbW1hbmRzL1dTREwySmF2YURlZmF1bHRpbmdDb21tYW5kLmphdmEKaW5kZXggM2FhMmFlMC4uYjEwNWUyYSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vY29yZS9jb21tYW5kcy9XU0RMMkphdmFEZWZhdWx0aW5nQ29tbWFuZC5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL2NvcmUvY29tbWFuZHMvV1NETDJKYXZhRGVmYXVsdGluZ0NvbW1hbmQuamF2YQpAQCAtNTcsOSArNTcsOSBAQAogICAgIHByaXZhdGUgV1NETDJKYXZhRGF0YU1vZGVsIG1vZGVsOwogICAgIHByaXZhdGUgU3RyaW5nIHByb2plY3ROYW1lOwogICAgIHByaXZhdGUgU3RyaW5nIGlucHV0VVJMOwotICAgIAorCiAgICAgcHJpdmF0ZSBXZWJDb250ZW50Q2hhbmdlTGlzdGVuZXIgd2ViQ29udGVudENoYW5nZUxpc3RlbmVyOwotICAgIAorCiAgICAgcHVibGljIFdTREwySmF2YURlZmF1bHRpbmdDb21tYW5kKFdTREwySmF2YURhdGFNb2RlbCBtb2RlbCwgU3RyaW5nIHByb2plY3ROYW1lLCBTdHJpbmcgaW5wdXRVUkwpIHsKICAgICAgICAgdGhpcy5tb2RlbCA9IG1vZGVsOwogICAgICAgICB0aGlzLnByb2plY3ROYW1lID0gcHJvamVjdE5hbWU7CkBAIC03MCwxMSArNzAsMTEgQEAKICAgICBAU3VwcHJlc3NXYXJuaW5ncyh7ICJ1bmNoZWNrZWQiLCAiZGVwcmVjYXRpb24iIH0pCiAgICAgcHVibGljIElTdGF0dXMgZXhlY3V0ZShJUHJvZ3Jlc3NNb25pdG9yIG1vbml0b3IsIElBZGFwdGFibGUgaW5mbykgdGhyb3dzIEV4ZWN1dGlvbkV4Y2VwdGlvbiB7CiAgICAgCUlTdGF0dXMgc3RhdHVzID0gU3RhdHVzLk9LX1NUQVRVUzsKLSAgICAJCisKICAgICAJd2ViQ29udGVudENoYW5nZUxpc3RlbmVyID0gbmV3IFdlYkNvbnRlbnRDaGFuZ2VMaXN0ZW5lcihwcm9qZWN0TmFtZSk7CiAgICAgCVJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5hZGRSZXNvdXJjZUNoYW5nZUxpc3RlbmVyKHdlYkNvbnRlbnRDaGFuZ2VMaXN0ZW5lciwKICAgICAJICAgICAgICBJUmVzb3VyY2VDaGFuZ2VFdmVudC5QT1NUX0NIQU5HRSk7Ci0gICAgCQorCiAgICAgICAgIFdTREwySmF2YVBlcnNpc3RlbnRDb250ZXh0IGNvbnRleHQgPSBDWEZDb3JlUGx1Z2luLmdldERlZmF1bHQoKS5nZXRXU0RMMkphdmFDb250ZXh0KCk7CiAgICAgICAgIG1vZGVsLnNldEN4ZlJ1bnRpbWVWZXJzaW9uKGNvbnRleHQuZ2V0Q3hmUnVudGltZVZlcnNpb24oKSk7CiAgICAgICAgIG1vZGVsLnNldEN4ZlJ1bnRpbWVFZGl0aW9uKGNvbnRleHQuZ2V0Q3hmUnVudGltZUVkaXRpb24oKSk7CkBAIC0xMDUsNyArMTA1LDcgQEAKICAgICAgICAgbW9kZWwuc2V0QXV0b05hbWVSZXNvbHV0aW9uKGNvbnRleHQuaXNBdXRvTmFtZVJlc29sdXRpb24oKSk7CiAgICAgICAgIG1vZGVsLnNldE5vQWRkcmVzc0JpbmRpbmcoY29udGV4dC5pc05vQWRkcmVzc0JpbmRpbmcoKSk7CiAgICAgICAgIG1vZGVsLnNldFVzZVNwcmluZ0FwcGxpY2F0aW9uQ29udGV4dChjb250ZXh0LmlzVXNlU3ByaW5nQXBwbGljYXRpb25Db250ZXh0KCkpOwotICAgICAgICBtb2RlbC5zZXRKYXZhU291cmNlRm9sZGVyKEpEVFV0aWxzLmdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChtb2RlbC5nZXRQcm9qZWN0TmFtZSgpKSk7CisgICAgICAgIG1vZGVsLnNldEphdmFTb3VyY2VGb2xkZXIoSkRUVXRpbHMuZ2V0SmF2YVByb2plY3RTb3VyY2VEaXJlY3RvcnlQYXRoKG1vZGVsLmdldFByb2plY3ROYW1lKCkpLnRvT1NTdHJpbmcoKSk7CiAKICAgICAJdHJ5IHsKICAgICAJCURlZmluaXRpb24gZGVmaW5pdGlvbiA9IG51bGw7CkBAIC0xNDUsNyArMTQ1LDcgQEAKICAgICAgICAgICAgICAgICAgICAgZm9yIChNYXAuRW50cnkgc2VydmljZUVudHJ5IDogc2VydmljZXNTZXQpIHsKICAgICAgICAgICAgICAgICAgICAgICAgIFNlcnZpY2Ugc2VydmljZSA9IChTZXJ2aWNlKSBzZXJ2aWNlRW50cnkuZ2V0VmFsdWUoKTsKICAgICAgICAgICAgICAgICAgICAgICAgIE1hcCBwb3J0c01hcCA9IHNlcnZpY2UuZ2V0UG9ydHMoKTsKLSAgICAgICAgICAgICAgICAgICAgICAgIFNldDxNYXAuRW50cnk+IHBvcnRzU2V0ID0gcG9ydHNNYXAuZW50cnlTZXQoKTsgICAgICAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICAgICAgICAgIFNldDxNYXAuRW50cnk+IHBvcnRzU2V0ID0gcG9ydHNNYXAuZW50cnlTZXQoKTsKICAgICAgICAgICAgICAgICAgICAgICAgIGZvciAoTWFwLkVudHJ5IHBvcnRFbnRyeSA6IHBvcnRzU2V0KSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUG9ydCBwb3J0ID0gKFBvcnQpIHBvcnRFbnRyeS5nZXRWYWx1ZSgpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBvcnRUeXBlIHBvcnRUeXBlID0gcG9ydC5nZXRCaW5kaW5nKCkuZ2V0UG9ydFR5cGUoKTsKQEAgLTE2MSwyMiArMTYxLDIyIEBACiAgICAgICAgICAgICAJY29waWVyLnNldFRhcmdldEZvbGRlclVSSSh3c2RsRm9sZGVyUGF0aC50b0ZpbGUoKS50b1VSSSgpLnRvU3RyaW5nKCkpOwogICAgICAgICAgICAgCWNvcGllci5zZXRUYXJnZXRGaWxlbmFtZShmaWxlbmFtZSk7CiAgICAgICAgICAgICAJd29ya3NwYWNlLnJ1bihjb3BpZXIsIG1vbml0b3IpOwotICAgICAgICAgICAgCQorCiAgICAgICAgICAgICAJRmlsZSB3c2RsRmlsZSA9IHdzZGxGb2xkZXJQYXRoLmFkZFRyYWlsaW5nU2VwYXJhdG9yKCkuYXBwZW5kKGZpbGVuYW1lKS50b0ZpbGUoKTsKICAgICAJCQltb2RlbC5zZXRXc2RsVVJMKHdzZGxGaWxlLnRvVVJJKCkudG9VUkwoKSk7CiAgICAgICAgIAl9Ci0gICAgICAgIAltb2RlbC5zZXRXc2RsRmlsZU5hbWUoV1NETFV0aWxzLmdldFdTRExGaWxlTmFtZUZyb21VUkwobW9kZWwuZ2V0V3NkbFVSTCgpKSk7Ci0gICAgICAgIAkKKyAgICAgICAgCW1vZGVsLnNldFdzZGxGaWxlTmFtZShnZXRXU0RMRmlsZU5hbWVGcm9tVVJMKG1vZGVsLmdldFdzZGxVUkwoKSkpOworCiAgICAgICAgIAlJUGF0aCB3c2RsTG9jYXRpb25QYXRoID0gbmV3IFBhdGgobW9kZWwuZ2V0V3NkbFVSTCgpLmdldFBhdGgoKSk7CiAgICAgICAgIAl3c2RsTG9jYXRpb25QYXRoID0gd3NkbExvY2F0aW9uUGF0aC5yZW1vdmVGaXJzdFNlZ21lbnRzKFdTRExVdGlscy5nZXRXZWJDb250ZW50Rm9sZGVyKHByb2plY3QpCiAgICAgICAgIAkJCS5nZXRMb2NhdGlvbigpLm1hdGNoaW5nRmlyc3RTZWdtZW50cyh3c2RsTG9jYXRpb25QYXRoKSk7Ci0gICAgICAgIAkKKwogICAgICAgICAJaWYgKHdzZGxMb2NhdGlvblBhdGguZ2V0RGV2aWNlKCkgIT0gbnVsbCkgewogICAgICAgICAJICAgIHdzZGxMb2NhdGlvblBhdGggPSB3c2RsTG9jYXRpb25QYXRoLnNldERldmljZShudWxsKTsKICAgICAgICAgCX0KICAgICAgICAgCW1vZGVsLnNldFdzZGxEZWZpbml0aW9uKGRlZmluaXRpb24pOwogICAgICAgICAJbW9kZWwuc2V0Q29uZmlnV3NkbExvY2F0aW9uKHdzZGxMb2NhdGlvblBhdGgudG9TdHJpbmcoKSk7Ci0gICAgICAgIAkKKwogIAkJfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBjZSkgewogIAkJCXN0YXR1cyA9IGNlLmdldFN0YXR1cygpOwogCQkJQ1hGQ3JlYXRpb25Db3JlUGx1Z2luLmxvZyhzdGF0dXMpOwpAQCAtMTkzLDcgKzE5MywxMiBAQAogCQlSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkucmVtb3ZlUmVzb3VyY2VDaGFuZ2VMaXN0ZW5lcih3ZWJDb250ZW50Q2hhbmdlTGlzdGVuZXIpOwogICAgICAgICByZXR1cm4gc3RhdHVzOwogICAgIH0KLSAgICAKKworICAgIHB1YmxpYyBTdHJpbmcgZ2V0V1NETEZpbGVOYW1lRnJvbVVSTChVUkwgd3NkbFVSTCkgeworICAgICAgICBJUGF0aCB3c2RsUGF0aCA9IG5ldyBQYXRoKHdzZGxVUkwudG9FeHRlcm5hbEZvcm0oKSk7CisgICAgICAgIHJldHVybiB3c2RsUGF0aC5sYXN0U2VnbWVudCgpOworICAgIH0KKwogICAgIHByaXZhdGUgdm9pZCBzZXRXU0RMTG9jYXRpb24oRGVmaW5pdGlvbiBkZWZpbml0aW9uKSB0aHJvd3MgTWFsZm9ybWVkVVJMRXhjZXB0aW9uIHsKICAgICAgICAgU3RyaW5nIHdzZGxMb2NhdGlvbiA9IFdTRExVdGlscy5nZXRXU0RMTG9jYXRpb24oZGVmaW5pdGlvbik7CiAgICAgICAgIGlmICh3c2RsTG9jYXRpb24gIT0gbnVsbCkgewpAQCAtMjExLDcgKzIxNiw3IEBACiAgICAgcHVibGljIFdTREwySmF2YURhdGFNb2RlbCBnZXRXU0RMMkphdmFEYXRhTW9kZWwoKSB7CiAgICAgICAgIHJldHVybiBtb2RlbDsKICAgICB9Ci0gICAgCisKICAgICBAT3ZlcnJpZGUKICAgICBwdWJsaWMgSVN0YXR1cyB1bmRvKElQcm9ncmVzc01vbml0b3IgbW9uaXRvciwgSUFkYXB0YWJsZSBpbmZvKSB0aHJvd3MgRXhlY3V0aW9uRXhjZXB0aW9uIHsKICAgICAgICAgSVN0YXR1cyBzdGF0dXMgPSBTdGF0dXMuT0tfU1RBVFVTOwpAQCAtMjI3LDEwICsyMzIsMTAgQEAKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgbW9kZWwuZ2V0QmluZGluZ0ZpbGVzKCkuY2xlYXIoKTsKICAgICAgICAgbW9kZWwuZ2V0SW5jbHVkZWROYW1lc3BhY2VzKCkuY2xlYXIoKTsKLSAgICAgICAKKwogICAgICAgICByZXR1cm4gc3RhdHVzOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi51aS9NRVRBLUlORi9NQU5JRkVTVC5NRiBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi51aS9NRVRBLUlORi9NQU5JRkVTVC5NRgppbmRleCA4OGM5MGYxLi40OGVhNzk3IDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24udWkvTUVUQS1JTkYvTUFOSUZFU1QuTUYKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLnVpL01FVEEtSU5GL01BTklGRVNULk1GCkBAIC0zNSw3ICszNSw4IEBACiAgamF2YXgud3NkbDtidW5kbGUtdmVyc2lvbj0iWzEuNi4yLDEuNy4wKSIsCiAgb3JnLmVjbGlwc2UudWkuZWRpdG9ycztidW5kbGUtdmVyc2lvbj0iWzMuNC4wLDQuMC4wKSIsCiAgb3JnLmVjbGlwc2Uud3N0LmNvbW1vbi5tb2R1bGVjb3JlO2J1bmRsZS12ZXJzaW9uPSJbMS4xLjAsMS4zLjApIiwKLSBvcmcuZWNsaXBzZS5qZHQuYXB0LmNvcmU7YnVuZGxlLXZlcnNpb249IlszLjMuMTAwLDQuMC4wKSIKKyBvcmcuZWNsaXBzZS5qZHQuYXB0LmNvcmU7YnVuZGxlLXZlcnNpb249IlszLjMuMTAwLDQuMC4wKSIsCisgb3JnLmVjbGlwc2UuY29yZS5maWxlc3lzdGVtO2J1bmRsZS12ZXJzaW9uPSJbMS4yLjAsMi4wLjApIgogQnVuZGxlLUFjdGl2YXRpb25Qb2xpY3k6IGxhenkKIEFudC1WZXJzaW9uOiBBcGFjaGUgQW50IDEuNy4wCiBDcmVhdGVkLUJ5OiAxLjUuMF8xNC1iMDMgKFN1biBNaWNyb3N5c3RlbXMgSW5jLikKZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi91aS93aWRnZXRzL0pBWFdTQW5ub3RhdGVKYXZhV2lkZ2V0LmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGYuY3JlYXRpb24udWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9jeGYvY3JlYXRpb24vdWkvd2lkZ2V0cy9KQVhXU0Fubm90YXRlSmF2YVdpZGdldC5qYXZhCmluZGV4IDI3MmJkMmIuLjhiY2U5MzYgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi91aS93aWRnZXRzL0pBWFdTQW5ub3RhdGVKYXZhV2lkZ2V0LmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL3VpL3dpZGdldHMvSkFYV1NBbm5vdGF0ZUphdmFXaWRnZXQuamF2YQpAQCAtOTEsMjMgKzkxLDIzIEBACiAgICAgcHJpdmF0ZSBUcmVlVmlld2VyQ29sdW1uIHdlYlBhcmFtVmlld2VyQ29sdW1uOwogICAgIHByaXZhdGUgVHJlZVZpZXdlckNvbHVtbiByZXF1ZXN0V3JhcHBlclZpZXdlckNvbHVtbjsKICAgICBwcml2YXRlIFRyZWVWaWV3ZXJDb2x1bW4gcmVzcG9uY2VXcmFwcGVyVmlld2VyQ29sdW1uOwotICAgIAorCiAgICAgcHVibGljIEpBWFdTQW5ub3RhdGVKYXZhV2lkZ2V0KCkgewogICAgIH0KIAogICAgIHB1YmxpYyB2b2lkIHNldEphdmEyV1NEYXRhTW9kZWwoSmF2YTJXU0RhdGFNb2RlbCBtb2RlbCkgewogICAgICAgICB0aGlzLm1vZGVsID0gbW9kZWw7CiAgICAgfQotICAgIAorCiAgICAgQE92ZXJyaWRlCiAgICAgcHVibGljIFdpZGdldERhdGFFdmVudHMgYWRkQ29udHJvbHMoQ29tcG9zaXRlIHBhcmVudCwgTGlzdGVuZXIgc3RhdHVzTGlzdGVuZXIpIHsKICAgICAgICAgU2FzaEZvcm0gc2FzaEZvcm0gPSBuZXcgU2FzaEZvcm0ocGFyZW50LCBTV1QuVkVSVElDQUwgfCBTV1QuU01PT1RIKTsKICAgICAgICAgR3JpZExheW91dCBncmlkTGF5b3V0ID0gbmV3IEdyaWRMYXlvdXQoMSwgdHJ1ZSk7CiAgICAgICAgIHNhc2hGb3JtLnNldExheW91dChncmlkTGF5b3V0KTsKLSAgICAgICAgCisKICAgICAgICAgR3JpZERhdGEgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoU1dULkZJTEwsIFNXVC5GSUxMLCB0cnVlLCB0cnVlKTsKICAgICAgICAgc2FzaEZvcm0uc2V0TGF5b3V0RGF0YShncmlkRGF0YSk7Ci0gICAgICAgIAorCiAgICAgICAgIENvbXBvc2l0ZSBqYXZhVHJlZWNvbXBvc2l0ZSA9IG5ldyBDb21wb3NpdGUoc2FzaEZvcm0sIFNXVC5OT05FKTsKICAgICAgICAgZ3JpZExheW91dCA9IG5ldyBHcmlkTGF5b3V0KDEsIHRydWUpOwogICAgICAgICBqYXZhVHJlZWNvbXBvc2l0ZS5zZXRMYXlvdXQoZ3JpZExheW91dCk7CkBAIC0xOTgsMTUgKzE5OCwxNSBAQAogICAgICAgICAgICAgICAgIGlmIChldmVudC5nZXRTZWxlY3Rpb24oKSBpbnN0YW5jZW9mIElUcmVlU2VsZWN0aW9uKSB7CiAgICAgICAgICAgICAgICAgICAgIElUcmVlU2VsZWN0aW9uIHRyZWVTZWxlY3Rpb24gPSAoVHJlZVNlbGVjdGlvbikgZXZlbnQuZ2V0U2VsZWN0aW9uKCk7CiAgICAgICAgICAgICAgICAgICAgIE9iamVjdCBmaXJzdEVsZW1lbnQgPSB0cmVlU2VsZWN0aW9uLmdldEZpcnN0RWxlbWVudCgpOwotICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgICAgICBJRG9jdW1lbnQgZG9jdW1lbnQgPSBhbm5vdGF0aW9uUHJldmlld1ZpZXdlci5nZXREb2N1bWVudCgpOwotICAgICAgICAgICAgICAgICAgICBGaW5kUmVwbGFjZURvY3VtZW50QWRhcHRlciBmaW5kUmVwbGFjZURvY3VtZW50QWRhcHRlciA9IAorICAgICAgICAgICAgICAgICAgICBGaW5kUmVwbGFjZURvY3VtZW50QWRhcHRlciBmaW5kUmVwbGFjZURvY3VtZW50QWRhcHRlciA9CiAgICAgICAgICAgICAgICAgICAgIAluZXcgRmluZFJlcGxhY2VEb2N1bWVudEFkYXB0ZXIoZG9jdW1lbnQpOwogICAgICAgICAgICAgICAgICAgICB0cnkgewogICAgICAgICAgICAgICAgICAgICAgICAgaWYgKGZpcnN0RWxlbWVudCBpbnN0YW5jZW9mIElUeXBlKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSVR5cGUgc291cmNlVHlwZSA9IChJVHlwZSkgZmlyc3RFbGVtZW50OwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFN0cmluZyBlbGVtZW50TmFtZSA9IHNvdXJjZVR5cGUuZ2V0RWxlbWVudE5hbWUoKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFN0cmluZ0J1aWxkZXIgcmVnZXggPSBuZXcgU3RyaW5nQnVpbGRlcigiXFxicHVibGljXFxXKyg/OlxcdytcXFcrKXsxLDN9PyIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZ2V4LmFwcGVuZChlbGVtZW50TmFtZSk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnZXguYXBwZW5kKCJcXGIiKTsKQEAgLTIxOCwyMiArMjE4LDIyIEBACiAgICAgICAgICAgICAgICAgICAgICAgICB9IGVsc2UgaWYgKGZpcnN0RWxlbWVudCBpbnN0YW5jZW9mIElNZXRob2QpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJTWV0aG9kIHNvdXJjZU1ldGhvZCA9IChJTWV0aG9kKSBmaXJzdEVsZW1lbnQ7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSVR5cGUgc291cmNlVHlwZSA9IChJVHlwZSkgc291cmNlTWV0aG9kLmdldFBhcmVudCgpOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU3RyaW5nIGVsZW1lbnROYW1lID0gc291cmNlTWV0aG9kLmdldEVsZW1lbnROYW1lKCk7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgCisKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmdCdWlsZGVyIHJlZ2V4ID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChzb3VyY2VUeXBlLmlzQ2xhc3MoKSkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWdleC5hcHBlbmQoIlxcYnB1YmxpYyIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAgICAgICAgICAgIAkKKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZ2V4LmFwcGVuZCgiXFxXKyg/OlxcdytcXFcrKXsxLDN9PyIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZ2V4LmFwcGVuZChlbGVtZW50TmFtZSk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnZXguYXBwZW5kKCJcXHMqP1xcKFxccyo/Lio/Iik7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAJCisKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmdbXSBwYXJhbWV0ZXJUeXBlcyA9IHNvdXJjZU1ldGhvZC5nZXRQYXJhbWV0ZXJUeXBlcygpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFN0cmluZ1tdIHBhcmFtdGVyTmFtZXMgPSBzb3VyY2VNZXRob2QuZ2V0UGFyYW1ldGVyTmFtZXMoKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgcGFyYW1ldGVyVHlwZXMubGVuZ3RoOyBpKyspIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnZXguYXBwZW5kKCJcXHMqPyIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgdHlwZU5hbWUgPSBTaWduYXR1cmUudG9TdHJpbmcocGFyYW1ldGVyVHlwZXNbaV0pOwpAQCAtMjQ4LDE0ICsyNDgsMTQgQEAKIAogICAgICAgICAgICAgICAgICAgICAgICAgCUlSZWdpb24gcmVnaW9uID0gZmluZFJlcGxhY2VEb2N1bWVudEFkYXB0ZXIuZmluZCgwLCByZWdleC50b1N0cmluZygpLCB0cnVlLCB0cnVlLAogICAgICAgICAgICAgICAgICAgICAgICAgCSAgICAgICAgZmFsc2UsIHRydWUpOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHJlZ2lvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIElSZWdpb24gZWxlbWVudE5hbWVSZWdpb24gPSBmaW5kUmVwbGFjZURvY3VtZW50QWRhcHRlci5maW5kKAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJCXJlZ2lvbi5nZXRPZmZzZXQoKSwgZWxlbWVudE5hbWUsIHRydWUsIHRydWUsIHRydWUsIGZhbHNlKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKGVsZW1lbnROYW1lUmVnaW9uICE9IG51bGwpIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCWFubm90YXRpb25QcmV2aWV3Vmlld2VyLnNldFNlbGVjdGVkUmFuZ2UoZWxlbWVudE5hbWVSZWdpb24uZ2V0T2Zmc2V0KCksIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJYW5ub3RhdGlvblByZXZpZXdWaWV3ZXIuc2V0U2VsZWN0ZWRSYW5nZShlbGVtZW50TmFtZVJlZ2lvbi5nZXRPZmZzZXQoKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkJZWxlbWVudE5hbWVSZWdpb24uZ2V0TGVuZ3RoKCkpOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYW5ub3RhdGlvblByZXZpZXdWaWV3ZXIucmV2ZWFsUmFuZ2UoZWxlbWVudE5hbWVSZWdpb24uZ2V0T2Zmc2V0KCksIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYW5ub3RhdGlvblByZXZpZXdWaWV3ZXIucmV2ZWFsUmFuZ2UoZWxlbWVudE5hbWVSZWdpb24uZ2V0T2Zmc2V0KCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJCWVsZW1lbnROYW1lUmVnaW9uLmdldExlbmd0aCgpKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KQEAgLTI5Myw5ICsyOTMsOSBAQAogICAgICAgICBncmlkRGF0YS5oZWlnaHRIaW50ID0gMTA7CiAgICAgICAgIGdyaWREYXRhLndpZHRoSGludCA9IDIwMDsKICAgICAgICAgYW5ub3RhdGlvblByZXZpZXdWaWV3ZXIuZ2V0Q29udHJvbCgpLnNldExheW91dERhdGEoZ3JpZERhdGEpOwotICAgICAgICAKKwogICAgICAgICBzYXNoRm9ybS5zZXRXZWlnaHRzKG5ldyBpbnRbXXs1MCwgNTB9KTsKLSAgICAgICAgCisKICAgICAgICAgcmV0dXJuIHRoaXM7CiAgICAgfQogCkBAIC0zMTksMTcgKzMxOSwxNyBAQAogICAgICAgICAgICAgdHlwZSA9SkRUVXRpbHMuZ2V0VHlwZShKRFRVdGlscy5nZXRKYXZhUHJvamVjdChtb2RlbC5nZXRQcm9qZWN0TmFtZSgpKSwgbW9kZWwKICAgICAgICAgICAgICAgICAgICAgLmdldEZ1bGx5UXVhbGlmaWVkSmF2YUNsYXNzTmFtZSgpKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAodHlwZSA9PSBudWxsKSB7CiAgICAgICAgICAgICB0eXBlID0gSkRUVXRpbHMuZ2V0VHlwZShKRFRVdGlscy5nZXRKYXZhUHJvamVjdChtb2RlbC5nZXRQcm9qZWN0TmFtZSgpKSwgbW9kZWwKICAgICAgICAgICAgICAgICAgICAgLmdldEphdmFTdGFydGluZ1BvaW50KCkpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIG1vZGVsLnNldE1ldGhvZE1hcChDWEZNb2RlbFV0aWxzLmdldE1ldGhvZE1hcCh0eXBlLCBtb2RlbCkpOwogCiAgICAgICAgIHJldHVybiB0eXBlOwogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgVHJlZVZpZXdlckNvbHVtbiBjcmVhdGVXZWJNZXRob2RWaWV3ZXJDb2x1bW4oVHJlZVZpZXdlciB0cmVlVmlld2VyKSB7CiAgICAgICAgIHdlYk1ldGhvZFZpZXdlckNvbHVtbiA9IG5ldyBUcmVlVmlld2VyQ29sdW1uKHRyZWVWaWV3ZXIsIFNXVC5DRU5URVIpOwogICAgICAgICBUcmVlQ29sdW1uIHdlYk1ldGhvZENvbHVtbiA9IHdlYk1ldGhvZFZpZXdlckNvbHVtbi5nZXRDb2x1bW4oKTsKQEAgLTM2Niw3ICszNjYsNyBAQAogICAgICAgICBjcmVhdGVSZXF1ZXN0V3JhcHBlckNvbHVtbi5zZXRNb3ZlYWJsZShmYWxzZSk7CiAgICAgICAgIHJlcXVlc3RXcmFwcGVyVmlld2VyQ29sdW1uLnNldExhYmVsUHJvdmlkZXIobmV3IEFubm90YXRpb25Db2x1bW5MYWJlbFByb3ZpZGVyKG1vZGVsLAogICAgICAgICAgICAgICAgIENYRk1vZGVsVXRpbHMuUkVRVUVTVF9XUkFQUEVSLCBnZXRUeXBlKCkpKTsKLSAgICAgICAgcmVxdWVzdFdyYXBwZXJWaWV3ZXJDb2x1bW4uc2V0RWRpdGluZ1N1cHBvcnQobmV3IEFubm90YXRpb25FZGl0aW5nU3VwcG9ydCh0cmVlVmlld2VyLCAKKyAgICAgICAgcmVxdWVzdFdyYXBwZXJWaWV3ZXJDb2x1bW4uc2V0RWRpdGluZ1N1cHBvcnQobmV3IEFubm90YXRpb25FZGl0aW5nU3VwcG9ydCh0cmVlVmlld2VyLAogICAgICAgICAgICAgICAgIENYRk1vZGVsVXRpbHMuUkVRVUVTVF9XUkFQUEVSKSk7CiAgICAgICAgIHJldHVybiByZXF1ZXN0V3JhcHBlclZpZXdlckNvbHVtbjsKICAgICB9CkBAIC0zODMsNyArMzgzLDcgQEAKICAgICAgICAgICAgICAgICBDWEZNb2RlbFV0aWxzLlJFU1BPTlNFX1dSQVBQRVIpKTsKICAgICAgICAgcmV0dXJuIHJlc3BvbmNlV3JhcHBlclZpZXdlckNvbHVtbjsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIHZvaWQgdXBkYXRlTGFiZWxQcm92aWRlcnMoKSB7CiAgICAgICAgIHdlYk1ldGhvZFZpZXdlckNvbHVtbi5zZXRMYWJlbFByb3ZpZGVyKG5ldyBBbm5vdGF0aW9uQ29sdW1uTGFiZWxQcm92aWRlcihtb2RlbCwKICAgICAgICAgICAgICAgICBDWEZNb2RlbFV0aWxzLldFQl9NRVRIT0QsIGdldFR5cGUoKSkpOwpAQCAtMzk0LDE1ICszOTQsMTUgQEAKICAgICAgICAgcmVzcG9uY2VXcmFwcGVyVmlld2VyQ29sdW1uLnNldExhYmVsUHJvdmlkZXIobmV3IEFubm90YXRpb25Db2x1bW5MYWJlbFByb3ZpZGVyKG1vZGVsLAogICAgICAgICAgICAgICAgIENYRk1vZGVsVXRpbHMuUkVTUE9OU0VfV1JBUFBFUiwgZ2V0VHlwZSgpKSk7CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSB2b2lkIGhhbmRsZUFubm90YXRpb24oSVR5cGUgdHlwZSkgewogICAgICAgICB0cnkgewogICAgICAgICAgICAgYW5ub3RhdGlvblByZXZpZXdWaWV3ZXIuc2V0UmVkcmF3KGZhbHNlKTsKIAogICAgICAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSB0eXBlLmdldENvbXBpbGF0aW9uVW5pdCgpOwogICAgICAgICAgICAgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yID0gIG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCk7Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIFRleHRGaWxlQ2hhbmdlIHRleHRGaWxlQ2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJBbm5vdGF0aW9uIENoYW5nZXMiLCAKKworICAgICAgICAgICAgVGV4dEZpbGVDaGFuZ2UgdGV4dEZpbGVDaGFuZ2UgPSBuZXcgVGV4dEZpbGVDaGFuZ2UoIkFubm90YXRpb24gQ2hhbmdlcyIsCiAgICAgICAgICAgICAgICAgICAgIChJRmlsZSljb21waWxhdGlvblVuaXQuZ2V0UmVzb3VyY2UoKSk7CiAgICAgICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2Uuc2V0RWRpdChtdWx0aVRleHRFZGl0KTsKQEAgLTQyNiwxMiArNDI2LDEyIEBACiAgICAgICAgICAgICAgICAgaWYgKG1ldGhvZEFubm90YXRpb25NYXAuZ2V0KENYRk1vZGVsVXRpbHMuV0VCX1BBUkFNKSkgewogCQkJCQlMaXN0PFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24+IHBhcmFtZXRlcnMgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbnMobWV0aG9kKTsKIAkJCQkJZm9yIChTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uIHBhcmFtZXRlciA6IHBhcmFtZXRlcnMpIHsKLQkJCQkJCUNYRk1vZGVsVXRpbHMuZ2V0V2ViUGFyYW1Bbm5vdGF0aW9uQ2hhbmdlKHR5cGUsIG1ldGhvZCwgCisJCQkJCQlDWEZNb2RlbFV0aWxzLmdldFdlYlBhcmFtQW5ub3RhdGlvbkNoYW5nZSh0eXBlLCBtZXRob2QsCiAJCQkJCQkJCShJTG9jYWxWYXJpYWJsZSkgcGFyYW1ldGVyLnJlc29sdmVCaW5kaW5nKCkuZ2V0SmF2YUVsZW1lbnQoKSwgdGV4dEZpbGVDaGFuZ2UpOwogCQkJCQl9Ci0gICAgICAgICAgICAgICAgfSAKKyAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgQ1hGTW9kZWxVdGlscy5nZXRJbXBvcnRzQ2hhbmdlKGNvbXBpbGF0aW9uVW5pdCwgbW9kZWwsIHRleHRGaWxlQ2hhbmdlLCBmYWxzZSk7CiAgICAgICAgICAgICBhbm5vdGF0aW9uUHJldmlld1ZpZXdlci5nZXREb2N1bWVudCgpLnNldCh0ZXh0RmlsZUNoYW5nZS5nZXRQcmV2aWV3Q29udGVudChtb25pdG9yKSk7CiAKQEAgLTQ0MCw3ICs0NDAsNyBAQAogICAgICAgICAgICAgQ1hGQ3JlYXRpb25VSVBsdWdpbi5sb2coY2UuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9IGNhdGNoIChNYWxmb3JtZWRUcmVlRXhjZXB0aW9uIG10ZSkgewogICAgICAgICAgICAgQ1hGQ3JlYXRpb25VSVBsdWdpbi5sb2cobXRlKTsKLSAgICAgICAgfSAKKyAgICAgICAgfQogICAgIH0KIAogICAgIHByaXZhdGUgU291cmNlVmlld2VyIGNyZWF0ZUFubm90YXRpb25QcmV2aWV3ZXIoQ29tcG9zaXRlIHBhcmVudCwgaW50IHN0eWxlcykgewpAQCAtNDU5LDcgKzQ1OSw3IEBACiAgICAgICAgIGFubm90YXRpb25QcmV2aWV3Vmlld2VyLnNldEVkaXRhYmxlKGZhbHNlKTsKIAogCi0gICAgICAgIFN0cmluZyBzb3VyY2UgPSBKRFRVdGlscy5nZXRTb3VyY2VGcm9tVHlwZShnZXRUeXBlKCkpOworICAgICAgICBTdHJpbmcgc291cmNlID0gZ2V0U291cmNlRnJvbVR5cGUoZ2V0VHlwZSgpKTsKICAgICAgICAgSURvY3VtZW50IGRvY3VtZW50ID0gbmV3IERvY3VtZW50KHNvdXJjZSk7CiAKICAgICAgICAgSmF2YVBsdWdpbi5nZXREZWZhdWx0KCkuZ2V0SmF2YVRleHRUb29scygpLnNldHVwSmF2YURvY3VtZW50UGFydGl0aW9uZXIoZG9jdW1lbnQsCkBAIC00NjksNiArNDY5LDE1IEBACiAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uUHJldmlld1ZpZXdlcjsKICAgICB9CiAKKyAgICBwdWJsaWMgU3RyaW5nIGdldFNvdXJjZUZyb21UeXBlKElUeXBlIHR5cGUpIHsKKyAgICAgICAgdHJ5IHsKKyAgICAgICAgICAgIHJldHVybiB0eXBlLmdldENvbXBpbGF0aW9uVW5pdCgpLmdldEJ1ZmZlcigpLmdldENvbnRlbnRzKCk7CisgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKKyAgICAgICAgICAgIENYRkNyZWF0aW9uVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCisgICAgfQorCiAgICAgQE92ZXJyaWRlCiAgICAgcHVibGljIElTdGF0dXMgZ2V0U3RhdHVzKCkgewogICAgICAgICByZXR1cm4gc3RhdHVzOwpAQCAtNDc4LDcgKzQ4Nyw3IEBACiAgICAgICAgIHByaXZhdGUgQ2hlY2tib3hDZWxsRWRpdG9yIGNoZWNrYm94Q2VsbEVkaXRvcjsKIAogICAgICAgICBwcml2YXRlIFN0cmluZyBhbm5vdGF0aW9uS2V5OwotICAgICAgICAKKwogICAgICAgICBwdWJsaWMgQW5ub3RhdGlvbkVkaXRpbmdTdXBwb3J0KFRyZWVWaWV3ZXIgdmlld2VyLCBTdHJpbmcgYW5ub3RhdGlvbktleSkgewogICAgICAgICAgICAgc3VwZXIodmlld2VyKTsKICAgICAgICAgICAgIHRoaXMuYW5ub3RhdGlvbktleSA9IGFubm90YXRpb25LZXk7CkBAIC00ODksNyArNDk4LDcgQEAKICAgICAgICAgcHJvdGVjdGVkIGJvb2xlYW4gY2FuRWRpdChPYmplY3QgZWxlbWVudCkgewogICAgICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJTWV0aG9kKSB7CiAgICAgICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSAoSU1ldGhvZCkgZWxlbWVudDsKLSAgICAgICAgICAgICAgICByZXR1cm4gIUFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHR5cGUuZmluZE1ldGhvZHMobWV0aG9kKVswXSwgCisgICAgICAgICAgICAgICAgcmV0dXJuICFBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudCh0eXBlLmZpbmRNZXRob2RzKG1ldGhvZClbMF0sCiAgICAgICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uS2V5KTsKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zi5jcmVhdGlvbi51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2N4Zi9jcmVhdGlvbi91aS93aWRnZXRzL0phdmEyV1NDbGFzc0NvbmZpZ1dpZGdldC5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL3VpL3dpZGdldHMvSmF2YTJXU0NsYXNzQ29uZmlnV2lkZ2V0LmphdmEKaW5kZXggNWE2ZDdmOC4uYjE2M2JiNiAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL3VpL3dpZGdldHMvSmF2YTJXU0NsYXNzQ29uZmlnV2lkZ2V0LmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmLmNyZWF0aW9uLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvY3hmL2NyZWF0aW9uL3VpL3dpZGdldHMvSmF2YTJXU0NsYXNzQ29uZmlnV2lkZ2V0LmphdmEKQEAgLTEwLDYgKzEwLDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogcGFja2FnZSBvcmcuZWNsaXBzZS5qc3Qud3MuaW50ZXJuYWwuY3hmLmNyZWF0aW9uLnVpLndpZGdldHM7CiAKK2ltcG9ydCBqYXZhLm5ldC5VUkk7CiBpbXBvcnQgamF2YS51dGlsLkFycmF5czsKIGltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKIGltcG9ydCBqYXZhLnV0aWwuTGlzdDsKQEAgLTE3LDExICsxOCwxNiBAQAogCiBpbXBvcnQgamF2YXguandzLldlYlNlcnZpY2U7CiAKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLmZpbGVzeXN0ZW0uRUZTOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUuZmlsZXN5c3RlbS5JRmlsZVN0b3JlOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuU3RhdHVzOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklBbm5vdGF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklDb21waWxhdGlvblVuaXQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSU1ldGhvZDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JUGFja2FnZUZyYWdtZW50OwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklUeXBlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFNb2RlbEV4Y2VwdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5TaWduYXR1cmU7CkBAIC0zNSw2ICs0MSw4IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmN4Zi5jcmVhdGlvbi51aS5DWEZDcmVhdGlvblVJTWVzc2FnZXM7CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmN4Zi5jcmVhdGlvbi51aS5DWEZDcmVhdGlvblVJUGx1Z2luOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5pbnRlcm5hbC5jeGYudWkud2lkZ2V0cy5KYXZhMldTV2lkZ2V0RmFjdG9yeTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuaW50ZXJuYWwuamF4d3MuY29yZS5KQVhXU0NvcmVNZXNzYWdlczsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuaW50ZXJuYWwuamF4d3MuY29yZS5KQVhXU0NvcmVQbHVnaW47CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudXRpbHMuSkRUVXRpbHM7CiBpbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LlNXVDsKIGltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZXZlbnRzLk1vZGlmeUV2ZW50OwpAQCAtNjIsNyArNzAsNyBAQAogICAgIHByaXZhdGUgSVN0YXR1cyBTRUlfU0VMRUNUSU9OX1NUQVRVUyA9IFN0YXR1cy5PS19TVEFUVVM7CiAKICAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgTkFNRSA9ICJuYW1lIjsKLSAgICAKKwogICAgIHByaXZhdGUgaW50IE5VTUJFUl9PRl9QVUJMSUNfTUVUSE9EUzsKICAgICBwcml2YXRlIGludCBOVU1CRVJfT0ZfQ0hFQ0tFRF9NRVRIT0RTOwogICAgIHByaXZhdGUgSU1ldGhvZFtdIHB1YmxpY01ldGhvZHM7CkBAIC03NCw3ICs4Miw3IEBACiAKICAgICBwcml2YXRlIENvbWJvIHNlbGVjdFNFSUNvbWJvOwogICAgIHByaXZhdGUgVGV4dCBzZWlJbnRlcmZhY2VOYW1lVGV4dDsKLSAgICAKKwogICAgIHByaXZhdGUgQ2hlY2tib3hUYWJsZVZpZXdlciBzZWlNZW1iZXJzVG9FeHRyYWN0VGFibGVWaWV3ZXI7CiAgICAgcHJpdmF0ZSBUYWJsZSBzZWlNZW1iZXJzVG9FeHRyYWN0VGFibGU7CiAgICAgcHJpdmF0ZSBCdXR0b24gc2VsZWN0QWxsQnV0dG9uOwpAQCAtMTM1LDcgKzE0Myw3IEBACiAgICAgICAgICAgICAgICAgc3RhdHVzTGlzdGVuZXIuaGFuZGxlRXZlbnQobnVsbCk7CiAgICAgICAgICAgICAgICAgaWYgKCF1c2VTRUkpIHsKICAgICAgICAgICAgICAgICAgICAgbW9kZWwuc2V0U2VydmljZUVuZHBvaW50SW50ZXJmYWNlTmFtZSgiIik7Ci0gICAgICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgICAgIHNlbGVjdFNFSUJ1dHRvbi5zZXRTZWxlY3Rpb24oZmFsc2UpOwogICAgICAgICAgICAgICAgICAgICBlbmFibGVTZWxlY3RTRUlDb250cm9scyhmYWxzZSk7CiAKQEAgLTE0OCw3ICsxNTYsNyBAQAogICAgICAgICBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YShTV1QuRklMTCwgU1dULkNFTlRFUiwgdHJ1ZSwgdHJ1ZSk7CiAgICAgICAgIGdyaWREYXRhLmhvcml6b250YWxTcGFuID0gMzsKICAgICAgICAgdXNlU0VJQnV0dG9uLnNldExheW91dERhdGEoZ3JpZERhdGEpOwotICAgICAgICAKKwogICAgICAgICBMYWJlbCBwYWRkaW5nTGFiZWwgPSBKYXZhMldTV2lkZ2V0RmFjdG9yeS5jcmVhdGVQYWRkaW5nTGFiZWwoY29tcG9zaXRlKTsKICAgICAgICAgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoU1dULkZJTEwsIFNXVC5GSUxMLCB0cnVlLCB0cnVlKTsKICAgICAgICAgZ3JpZERhdGEuaG9yaXpvbnRhbFNwYW4gPSAzOwpAQCAtMTY3LDcgKzE3NSw3IEBACiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICB9KTsKLSAgICAgICAgCisKICAgICAgICAgc2VsZWN0U0VJQnV0dG9uLnNldFNlbGVjdGlvbihmYWxzZSk7CiAgICAgICAgIHNlbGVjdFNFSUJ1dHRvbi5zZXRFbmFibGVkKGZhbHNlKTsKICAgICAgICAgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoU1dULkZJTEwsIFNXVC5GSUxMLCBmYWxzZSwgZmFsc2UpOwpAQCAtMTgxLDcgKzE4OSw3IEBACiAgICAgICAgICAgICAgICAgc3RhdHVzTGlzdGVuZXIuaGFuZGxlRXZlbnQobnVsbCk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0pOwotICAgICAgICAKKwogICAgICAgICBzZWxlY3RTRUlDb21iby5hZGRNb2RpZnlMaXN0ZW5lcihuZXcgTW9kaWZ5TGlzdGVuZXIoKSB7CiAKICAgICAgICAgICAgIHB1YmxpYyB2b2lkIG1vZGlmeVRleHQoTW9kaWZ5RXZlbnQgZXZlbnQpIHsKQEAgLTE5Myw3ICsyMDEsNyBAQAogICAgICAgICBncmlkRGF0YSA9IG5ldyBHcmlkRGF0YShTV1QuRklMTCwgU1dULkZJTEwsIHRydWUsIGZhbHNlKTsKICAgICAgICAgZ3JpZERhdGEuaG9yaXpvbnRhbFNwYW4gPSAxOwogICAgICAgICBzZWxlY3RTRUlDb21iby5zZXRMYXlvdXREYXRhKGdyaWREYXRhKTsKLSAgICAgICAgCisKICAgICAgICAgYnJvd3NlU0VJQnV0dG9uID0gSmF2YTJXU1dpZGdldEZhY3RvcnkuY3JlYXRlQnJvd3NlQnV0dG9uKGNvbXBvc2l0ZSk7CiAKICAgICAgICAgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoU1dULkZJTEwsIFNXVC5GSUxMLCBmYWxzZSwgZmFsc2UpOwpAQCAtMjQ1LDcgKzI1Myw3IEBACiAKICAgICAgICAgZ3JpZERhdGEgPSBuZXcgR3JpZERhdGEoU1dULkZJTEwsIFNXVC5GSUxMLCBmYWxzZSwgZmFsc2UpOwogICAgICAgICBleHRyYWN0U0VJQnV0dG9uLnNldExheW91dERhdGEoZ3JpZERhdGEpOwotICAgICAgICAKKwogICAgICAgICBzZWlJbnRlcmZhY2VOYW1lVGV4dCA9IEphdmEyV1NXaWRnZXRGYWN0b3J5LmNyZWF0ZVNFSUludGVyZmFjZU5hbWVUZXh0KGNvbXBvc2l0ZSk7CiAgICAgICAgIHNlaUludGVyZmFjZU5hbWVUZXh0LmFkZE1vZGlmeUxpc3RlbmVyKG5ldyBNb2RpZnlMaXN0ZW5lcigpIHsKIApAQCAtMjYxLDcgKzI2OSw3IEBACiAKICAgICAgICAgICAgICAgICAgICAgU3RyaW5nIGNvbXBpbGF0aW9uVW5pdE5hbWUgPSBpbnRlcmZhY2VOYW1lICsgIi5qYXZhIjsgLy8kTk9OLU5MUy0xJAogICAgICAgICAgICAgICAgICAgICBKQVZBX1RZUEVfTkFNRV9TVEFUVVMgPSBKRFRVdGlscy52YWxpZGF0ZUphdmFUeXBlTmFtZShtb2RlbC5nZXRQcm9qZWN0TmFtZSgpLCBpbnRlcmZhY2VOYW1lKTsKLSAgICAgICAgICAgICAgICAgICAgSkFWQV9UWVBFX0VYSVNUU19TVEFUVVMgPSBKRFRVdGlscy5jaGVja1R5cGVFeGlzdHMoc3RhcnRpbmdQb2ludFR5cGUsIGNvbXBpbGF0aW9uVW5pdE5hbWUpOworICAgICAgICAgICAgICAgICAgICBKQVZBX1RZUEVfRVhJU1RTX1NUQVRVUyA9IGNoZWNrVHlwZUV4aXN0cyhzdGFydGluZ1BvaW50VHlwZSwgY29tcGlsYXRpb25Vbml0TmFtZSk7CiAgICAgICAgICAgICAgICAgICAgIHVwZGF0ZVNFSVNlbGVjdGlvblN0YXR1cygpOwogICAgICAgICAgICAgICAgICAgICBzdGF0dXNMaXN0ZW5lci5oYW5kbGVFdmVudChudWxsKTsKICAgICAgICAgICAgICAgICB9CkBAIC0yODcsNyArMjk1LDcgQEAKIAogICAgICAgICAgICAgcHVibGljIHZvaWQgY2hlY2tTdGF0ZUNoYW5nZWQoQ2hlY2tTdGF0ZUNoYW5nZWRFdmVudCBldmVudCkgewogICAgICAgICAgICAgICAgIE9iamVjdFtdIGNoZWNrZWRNZXRob2RzID0gc2VpTWVtYmVyc1RvRXh0cmFjdFRhYmxlVmlld2VyLmdldENoZWNrZWRFbGVtZW50cygpOwotICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgTWFwPElNZXRob2QsIE1hcDxTdHJpbmcsIEJvb2xlYW4+PiBtZXRob2RNYXAgPSBuZXcgSGFzaE1hcDxJTWV0aG9kLCBNYXA8U3RyaW5nLCBCb29sZWFuPj4oKTsKICAgICAgICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGNoZWNrZWRNZXRob2RzLmxlbmd0aDsgaSsrKSB7CiAgICAgICAgICAgICAgICAgICAgIG1ldGhvZE1hcC5wdXQoKElNZXRob2QpY2hlY2tlZE1ldGhvZHNbaV0sIG1vZGVsLmdldEFubm90YXRpb25NYXAoKSk7CkBAIC0zODcsNyArMzk1LDcgQEAKIAogICAgICAgICByZXR1cm4gdGhpczsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIHZvaWQgdmFsaWRhdGVTRUlTZWxlY3Rpb24oKSB7CiAgICAgICAgIGlmICghdXNlU0VJQnV0dG9uLmdldFNlbGVjdGlvbigpKSB7CiAgICAgICAgICAgICBTRUlfU0VMRUNUSU9OX1NUQVRVUyA9IFN0YXR1cy5PS19TVEFUVVM7CkBAIC00MTYsOCArNDI0LDggQEAKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgIFNFSV9TRUxFQ1RJT05fU1RBVFVTID0gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBDWEZDcmVhdGlvblVJUGx1Z2luLlBMVUdJTl9JRCwKICAgICAgICAgICAgICAgICBDWEZDcmVhdGlvblVJTWVzc2FnZXMuYmluZChDWEZDcmVhdGlvblVJTWVzc2FnZXMuV0VCU0VSVklDRV9FTlBPSU5USU5URVJGQUNFX05PVF9GT1VORCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxlY3RTRUlDb21iby5nZXRUZXh0KCkpKTsgICAKLSAgICAgICAgfSAgICAgICAgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZWN0U0VJQ29tYm8uZ2V0VGV4dCgpKSk7CisgICAgICAgIH0KICAgICB9CiAKICAgICBwcml2YXRlIFN0cmluZyBnZXRJbXBsZW1lbnRzTWVzc2FnZShJVHlwZSBzZWlUeXBlLCBJTWV0aG9kIHNlaU1ldGhvZCkgewpAQCAtNDQwLDEyICs0NDgsMTIgQEAKICAgICBwcml2YXRlIElTdGF0dXMgdmFsaWRhdGVTRUlBZGRpdGlvbigpIHsKICAgICAgICAgSVN0YXR1cyBzdGF0dXMgPSBTdGF0dXMuT0tfU1RBVFVTOwogICAgICAgICB0cnkgewotICAgICAgICAgICAgSUFubm90YXRpb24gd2ViU2VydmljZSA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKHN0YXJ0aW5nUG9pbnRUeXBlLCBXZWJTZXJ2aWNlLmNsYXNzKTsKKyAgICAgICAgICAgIElBbm5vdGF0aW9uIHdlYlNlcnZpY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihXZWJTZXJ2aWNlLmNsYXNzLCBzdGFydGluZ1BvaW50VHlwZSk7CiAgICAgICAgICAgICBpZiAod2ViU2VydmljZSAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgT2JqZWN0IG5hbWUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvblZhbHVlKHdlYlNlcnZpY2UsIE5BTUUpOwogICAgICAgICAgICAgICAgIGlmIChuYW1lICE9IG51bGwpIHsKICAgICAgICAgICAgICAgICAgICAgc3RhdHVzID0gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBDWEZDcmVhdGlvblVJUGx1Z2luLlBMVUdJTl9JRCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBDWEZDcmVhdGlvblVJTWVzc2FnZXMuSkFWQTJXU19TRUxFQ1RfU0VJX1dFQlNFUlZJQ0VfTkFNRV9BVFRSSUJVVEVfUFJFU0VOVCk7IAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIENYRkNyZWF0aW9uVUlNZXNzYWdlcy5KQVZBMldTX1NFTEVDVF9TRUlfV0VCU0VSVklDRV9OQU1FX0FUVFJJQlVURV9QUkVTRU5UKTsKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKQEAgLTQ1Myw3ICs0NjEsNyBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBzdGF0dXM7CiAgICAgfQotICAgCisKICAgICBwdWJsaWMgdm9pZCBlbmFibGVTZWxlY3RTRUlDb250cm9scyhib29sZWFuIGVuYWJsZSkgewogICAgICAgICBzZWxlY3RTRUlDb21iby5zZXRFbmFibGVkKGVuYWJsZSk7CiAgICAgICAgIGJyb3dzZVNFSUJ1dHRvbi5zZXRFbmFibGVkKGVuYWJsZSk7CkBAIC01MjYsNyArNTM0LDcgQEAKICAgICAgICAgaWYgKFNFSV9TRUxFQ1RJT05fU1RBVFVTLm1hdGNoZXMoSVN0YXR1cy5FUlJPUikpIHsKICAgICAgICAgICAgIHJldHVybiBTRUlfU0VMRUNUSU9OX1NUQVRVUzsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAoU0VJX1NFTEVDVElPTl9TVEFUVVMuZ2V0U2V2ZXJpdHkoKSA+PSBKQVZBX1RZUEVfTkFNRV9TVEFUVVMuZ2V0U2V2ZXJpdHkoKSkgewogICAgICAgICAgICAgcmV0dXJuIFNFSV9TRUxFQ1RJT05fU1RBVFVTOwogICAgICAgICB9CkBAIC01MzgsNCArNTQ2LDMwIEBACiAgICAgICAgIHJldHVybiBKQVZBX1RZUEVfTkFNRV9TVEFUVVM7CiAgICAgfQogCisgICAgcHVibGljIElTdGF0dXMgY2hlY2tUeXBlRXhpc3RzKElUeXBlIHR5cGUsIFN0cmluZyBjb21waWxhdGlvblVuaXROYW1lKSB7CisgICAgICAgIGNvbXBpbGF0aW9uVW5pdE5hbWUgPSBjb21waWxhdGlvblVuaXROYW1lLnRyaW0oKTsKKworICAgICAgICBJUGFja2FnZUZyYWdtZW50IHBhY2thZ2VGcmFnbWVudCA9IHR5cGUuZ2V0UGFja2FnZUZyYWdtZW50KCk7CisgICAgICAgIElDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gcGFja2FnZUZyYWdtZW50LmdldENvbXBpbGF0aW9uVW5pdChjb21waWxhdGlvblVuaXROYW1lKTsKKyAgICAgICAgSVJlc291cmNlIHJlc291cmNlID0gY29tcGlsYXRpb25Vbml0LmdldFJlc291cmNlKCk7CisKKyAgICAgICAgaWYgKHJlc291cmNlLmV4aXN0cygpKSB7CisgICAgICAgICAgICByZXR1cm4gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBKQVhXU0NvcmVQbHVnaW4uUExVR0lOX0lELCBKQVhXU0NvcmVNZXNzYWdlcworICAgICAgICAgICAgICAgICAgICAuYmluZChKQVhXU0NvcmVNZXNzYWdlcy5UWVBFX1dJVEhfTkFNRV9BTFJFQURZX0VYSVNUUywgbmV3IE9iamVjdFtdIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb21waWxhdGlvblVuaXROYW1lLCBwYWNrYWdlRnJhZ21lbnQuZ2V0RWxlbWVudE5hbWUoKSB9KSk7CisgICAgICAgIH0KKyAgICAgICAgVVJJIGxvY2F0aW9uID0gcmVzb3VyY2UuZ2V0TG9jYXRpb25VUkkoKTsKKyAgICAgICAgaWYgKGxvY2F0aW9uICE9IG51bGwpIHsKKyAgICAgICAgICAgIHRyeSB7CisgICAgICAgICAgICAgICAgSUZpbGVTdG9yZSBmaWxlU3RvcmUgPSBFRlMuZ2V0U3RvcmUobG9jYXRpb24pOworICAgICAgICAgICAgICAgIGlmIChmaWxlU3RvcmUuZmV0Y2hJbmZvKCkuZXhpc3RzKCkpIHsKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG5ldyBTdGF0dXMoSVN0YXR1cy5FUlJPUiwgSkFYV1NDb3JlUGx1Z2luLlBMVUdJTl9JRCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBKQVhXU0NvcmVNZXNzYWdlcy5UWVBFX05BTUVfRElGRkVSRU5UX0NBU0VfRVhJU1RTKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9IGNhdGNoIChDb3JlRXhjZXB0aW9uIGNlKSB7CisgICAgICAgICAgICAgICAgSkFYV1NDb3JlUGx1Z2luLmxvZyhjZS5nZXRTdGF0dXMoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIFN0YXR1cy5PS19TVEFUVVM7CisgICAgfQogfQpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdXRpbHMvSkRUVXRpbHMuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3V0aWxzL0pEVFV0aWxzLmphdmEKaW5kZXggMWU2OGE1ZS4uNDA0MjNjNCAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdXRpbHMvSkRUVXRpbHMuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS91dGlscy9KRFRVdGlscy5qYXZhCkBAIC0xMCwxNSArMTAsMTIgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogcGFja2FnZSBvcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS51dGlsczsKIAotaW1wb3J0IGphdmEubmV0LlVSSTsKIGltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OwogaW1wb3J0IGphdmEudXRpbC5BcnJheXM7CiBpbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOwogaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKIGltcG9ydCBqYXZhLnV0aWwuTGlzdDsKIAotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUuZmlsZXN5c3RlbS5FRlM7Ci1pbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5maWxlc3lzdGVtLklGaWxlU3RvcmU7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTI2LDEwICsyMyw5IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQYXRoOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JU3RhdHVzOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5OdWxsUHJvZ3Jlc3NNb25pdG9yOwotaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdGF0dXM7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlBhdGg7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuRmxhZ3M7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUNsYXNzcGF0aEVudHJ5OwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklDb21waWxhdGlvblVuaXQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUphdmFQcm9qZWN0OwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklNZXRob2Q7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVBhY2thZ2VGcmFnbWVudDsKQEAgLTM4LDE1ICszNCwxNCBAQAogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFDb252ZW50aW9uczsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhQ29yZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhTW9kZWxFeGNlcHRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmpheHdzLmNvcmUuSkFYV1NDb3JlTWVzc2FnZXM7CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmpheHdzLmNvcmUuSkFYV1NDb3JlUGx1Z2luOwogCiAvKioKICAqIEpEVCBVdGlsaXR5IGNsYXNzLgogICogPHA+Ci0gKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyIAotICogZGV2ZWxvcG1lbnQgYW5kIGV4cGVjdGVkIHRvIGNoYW5nZSBzaWduaWZpY2FudGx5IGJlZm9yZSByZWFjaGluZyBzdGFiaWxpdHkuIEl0IGlzIGJlaW5nIG1hZGUgYXZhaWxhYmxlIGF0IAotICogdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20gcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcyAKKyAqIDxzdHJvbmc+UHJvdmlzaW9uYWwgQVBJOjwvc3Ryb25nPiBUaGlzIGNsYXNzL2ludGVyZmFjZSBpcyBwYXJ0IG9mIGFuIGludGVyaW0gQVBJIHRoYXQgaXMgc3RpbGwgdW5kZXIKKyAqIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcgc3RhYmlsaXR5LiBJdCBpcyBiZWluZyBtYWRlIGF2YWlsYWJsZSBhdAorICogdGhpcyBlYXJseSBzdGFnZSB0byBzb2xpY2l0IGZlZWRiYWNrIGZyb20gcGlvbmVlcmluZyBhZG9wdGVycyBvbiB0aGUgdW5kZXJzdGFuZGluZyB0aGF0IGFueSBjb2RlIHRoYXQgdXNlcwogICogdGhpcyBBUEkgd2lsbCBhbG1vc3QgY2VydGFpbmx5IGJlIGJyb2tlbiAocmVwZWF0ZWRseSkgYXMgdGhlIEFQSSBldm9sdmVzLgogICogPC9wPgogICovCkBAIC01NSw2ICs1MCwxMSBAQAogICAgIHByaXZhdGUgSkRUVXRpbHMoKSB7CiAgICAgfQogCisgICAgLyoqCisgICAgICogQWRkIGEgPGNvZGU+SUNsYXNzcGF0aEVudHJ5PC9jb2RlPiB0byBhIDxjb2RlPklKYXZhUHJvamVjdDwvY29kZT4KKyAgICAgKiBAcGFyYW0gamF2YVByb2plY3QgdGhlIDxjb2RlPklKYXZhUHJvamVjdDwvY29kZT4gdG8gYWRkIHRoZSBjbGFzc3BhdGggZW50cnkgdG8KKyAgICAgKiBAcGFyYW0gY2xhc3NwYXRoRW50cnkgdGhlIDxjb2RlPklDbGFzc3BhdGhFbnRyeTwvY29kZT4gdG8gYWRkCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyB2b2lkIGFkZFRvQ2xhc3NwYXRoKElKYXZhUHJvamVjdCBqYXZhUHJvamVjdCwgSUNsYXNzcGF0aEVudHJ5IGNsYXNzcGF0aEVudHJ5KSB7CiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICBMaXN0PElDbGFzc3BhdGhFbnRyeT4gY3VycmVudEVudHJpZXMgPSBBcnJheXMuYXNMaXN0KGphdmFQcm9qZWN0LmdldFJhd0NsYXNzcGF0aCgpKTsKQEAgLTcwLDYgKzcwLDExIEBACiAgICAgICAgIH0KICAgICB9CiAKKyAgICAvKioKKyAgICAgKiBSZW1vdmUgYSA8Y29kZT5JQ2xhc3NwYXRoRW50cnk8L2NvZGU+IGZyb20gYSA8Y29kZT5JSmF2YVByb2plY3Q8L2NvZGU+CisgICAgICogQHBhcmFtIGphdmFQcm9qZWN0IHRoZSA8Y29kZT5JSmF2YVByb2plY3Q8L2NvZGU+IHRvIHJlbW92ZSB0aGUgY2xhc3NwYXRoIGVudHJ5IGZyb20KKyAgICAgKiBAcGFyYW0gY2xhc3NwYXRoRW50cnkgdGhlIDxjb2RlPklDbGFzc3BhdGhFbnRyeTwvY29kZT4gdG8gcmVtb3ZlCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyB2b2lkIHJlbW92ZUZyb21DbGFzc3BhdGgoSUphdmFQcm9qZWN0IGphdmFQcm9qZWN0LCBJQ2xhc3NwYXRoRW50cnkgY2xhc3NwYXRoRW50cnkpIHsKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIExpc3Q8SUNsYXNzcGF0aEVudHJ5PiBjdXJyZW50RW50cmllcyA9IEFycmF5cy5hc0xpc3QoamF2YVByb2plY3QuZ2V0UmF3Q2xhc3NwYXRoKCkpOwpAQCAtODQsMTE5ICs4OSw4NSBAQAogICAgICAgICAgICAgSkFYV1NDb3JlUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAgICAgfQotICAgIAotICAgIHB1YmxpYyBzdGF0aWMgSVN0YXR1cyBjaGVja1R5cGVFeGlzdHMoSVR5cGUgdHlwZSwgU3RyaW5nIGNvbXBpbGF0aW9uVW5pdE5hbWUpIHsKLSAgICAgICAgY29tcGlsYXRpb25Vbml0TmFtZSA9IGNvbXBpbGF0aW9uVW5pdE5hbWUudHJpbSgpOwogCi0gICAgICAgIElQYWNrYWdlRnJhZ21lbnQgcGFja2FnZUZyYWdtZW50ID0gdHlwZS5nZXRQYWNrYWdlRnJhZ21lbnQoKTsKLSAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBjb21waWxhdGlvblVuaXQgPSBwYWNrYWdlRnJhZ21lbnQuZ2V0Q29tcGlsYXRpb25Vbml0KGNvbXBpbGF0aW9uVW5pdE5hbWUpOwotICAgICAgICBJUmVzb3VyY2UgcmVzb3VyY2UgPSBjb21waWxhdGlvblVuaXQuZ2V0UmVzb3VyY2UoKTsKLQotICAgICAgICBpZiAocmVzb3VyY2UuZXhpc3RzKCkpIHsKLSAgICAgICAgICAgIHJldHVybiBuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsIEpBWFdTQ29yZVBsdWdpbi5QTFVHSU5fSUQsIEpBWFdTQ29yZU1lc3NhZ2VzCi0gICAgICAgICAgICAgICAgICAgIC5iaW5kKEpBWFdTQ29yZU1lc3NhZ2VzLlRZUEVfV0lUSF9OQU1FX0FMUkVBRFlfRVhJU1RTLCBuZXcgT2JqZWN0W10gewotICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbXBpbGF0aW9uVW5pdE5hbWUsIHBhY2thZ2VGcmFnbWVudC5nZXRFbGVtZW50TmFtZSgpIH0pKTsKLSAgICAgICAgfQotICAgICAgICBVUkkgbG9jYXRpb24gPSByZXNvdXJjZS5nZXRMb2NhdGlvblVSSSgpOwotICAgICAgICBpZiAobG9jYXRpb24gIT0gbnVsbCkgewotICAgICAgICAgICAgdHJ5IHsKLSAgICAgICAgICAgICAgICBJRmlsZVN0b3JlIGZpbGVTdG9yZSA9IEVGUy5nZXRTdG9yZShsb2NhdGlvbik7Ci0gICAgICAgICAgICAgICAgaWYgKGZpbGVTdG9yZS5mZXRjaEluZm8oKS5leGlzdHMoKSkgewotICAgICAgICAgICAgICAgICAgICByZXR1cm4gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLCBKQVhXU0NvcmVQbHVnaW4uUExVR0lOX0lELAotICAgICAgICAgICAgICAgICAgICAgICAgICAgIEpBWFdTQ29yZU1lc3NhZ2VzLlRZUEVfTkFNRV9ESUZGRVJFTlRfQ0FTRV9FWElTVFMpOwotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIH0gY2F0Y2ggKENvcmVFeGNlcHRpb24gY2UpIHsKLSAgICAgICAgICAgICAgICBKQVhXU0NvcmVQbHVnaW4ubG9nKGNlLmdldFN0YXR1cygpKTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQotICAgICAgICByZXR1cm4gU3RhdHVzLk9LX1NUQVRVUzsKLSAgICB9Ci0gICAgCi0gICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0Q2xhc3NOYW1lKFN0cmluZyBwcm9qZWN0TmFtZSwgU3RyaW5nIGZ1bGx5UXVhbGlmaWVkQ2xhc3NOYW1lKSB7Ci0gICAgICAgIHJldHVybiBKRFRVdGlscy5nZXRUeXBlKEpEVFV0aWxzLmdldEphdmFQcm9qZWN0KHByb2plY3ROYW1lKSwgZnVsbHlRdWFsaWZpZWRDbGFzc05hbWUpCi0gICAgICAgICAgICAgICAgLmdldEVsZW1lbnROYW1lKCk7Ci0gICAgfQotCi0gICAgcHVibGljIHN0YXRpYyBJSmF2YVByb2plY3QgZ2V0SmF2YVByb2plY3QoSVByb2plY3QgcHJvamVjdCkgewotICAgICAgICBJSmF2YVByb2plY3QgamF2YVByb2plY3QgPSBKYXZhQ29yZS5jcmVhdGUocHJvamVjdCk7Ci0gICAgICAgIHJldHVybiBqYXZhUHJvamVjdDsKLSAgICB9Ci0KKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHRoZSBKYXZhIHByb2plY3QgY29ycmVzcG9uZGluZyB0byB0aGUgZ2l2ZW4gcHJvamVjdCBuYW1lLgorICAgICAqIEBwYXJhbSBwcm9qZWN0TmFtZSB0aGUgcHJvamVjdCBuYW1lCisgICAgICogQHJldHVybiB0aGUgSmF2YSBwcm9qZWN0IGNvcnJlc3BvbmRpbmcgdG8gdGhlIGdpdmVuIHByb2plY3QgbmFtZQorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgSUphdmFQcm9qZWN0IGdldEphdmFQcm9qZWN0KFN0cmluZyBwcm9qZWN0TmFtZSkgewogICAgICAgICBJUHJvamVjdCBwcm9qZWN0ID0gUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLmdldFJvb3QoKS5nZXRQcm9qZWN0KHByb2plY3ROYW1lKTsKLSAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldEphdmFQcm9qZWN0KHByb2plY3QpOworICAgICAgICByZXR1cm4gSmF2YUNvcmUuY3JlYXRlKHByb2plY3QpOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldEphdmFQcm9qZWN0T3V0cHV0RGlyZWN0b3J5UGF0aChJSmF2YVByb2plY3QgamF2YVByb2plY3QpIHsKLSAgICAgICAgSVBhdGggb3V0cHV0UGF0aDsKLSAgICAgICAgU3RyaW5nIGZ1bGxQYXRoID0gIiI7IC8vJE5PTi1OTFMtMSQKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHRoZSBhYnNvbHV0ZSBwYXRoIGluIHRoZSBsb2NhbCBmaWxlIHN5c3RlbSBvZiB0aGUgZGVmYXVsdCBvdXRwdXQgbG9jYXRpb24gZm9yIHRoZSBnaXZlbiBqYXZhIHByb2plY3QuCisgICAgICogQHBhcmFtIGphdmFQcm9qZWN0IHRoZSBqYXZhIHByb2plY3QKKyAgICAgKiBAcmV0dXJuIHRoZSBhYnNvbHV0ZSBwYXRoIG9mIHRoZSBkZWZhdWx0IG91dHB1dCBmb2xkZXIgZm9yIHRoZSBnaXZlbiBqYXZhIHByb2plY3QKKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIElQYXRoIGdldEphdmFQcm9qZWN0T3V0cHV0RGlyZWN0b3J5UGF0aChJSmF2YVByb2plY3QgamF2YVByb2plY3QpIHsKICAgICAgICAgdHJ5IHsKLSAgICAgICAgICAgIG91dHB1dFBhdGggPSBqYXZhUHJvamVjdC5nZXRPdXRwdXRMb2NhdGlvbigpOwotICAgICAgICAgICAgZnVsbFBhdGggPSBSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkuZ2V0Um9vdCgpLmZpbmRNZW1iZXIob3V0cHV0UGF0aCkuZ2V0TG9jYXRpb24oKQotICAgICAgICAgICAgICAgICAgICAudG9PU1N0cmluZygpOworICAgICAgICAgICAgcmV0dXJuIFJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5nZXRSb290KCkuZmluZE1lbWJlcihqYXZhUHJvamVjdC5nZXRPdXRwdXRMb2NhdGlvbigpKS5nZXRMb2NhdGlvbigpOwogICAgICAgICB9IGNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gam1lKSB7CiAgICAgICAgICAgICBKQVhXU0NvcmVQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIGZ1bGxQYXRoOworICAgICAgICByZXR1cm4gUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLmdldFJvb3QoKS5maW5kTWVtYmVyKGphdmFQcm9qZWN0LmdldFBhdGgoKSkuZ2V0TG9jYXRpb24oKTsKICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRKYXZhUHJvamVjdE91dHB1dERpcmVjdG9yeVBhdGgoU3RyaW5nIHByb2plY3ROYW1lKSB7CisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgYWJzb2x1dGUgcGF0aCBpbiB0aGUgbG9jYWwgZmlsZSBzeXN0ZW0gb2YgdGhlIGRlZmF1bHQgb3V0cHV0IGxvY2F0aW9uIGZvciB0aGUgZ2l2ZW4gamF2YSBwcm9qZWN0IG5hbWUuCisgICAgICogQHBhcmFtIHByb2plY3ROYW1lIHRoZSBuYW1lIG9mIHRoZSBqYXZhIHByb2plY3QKKyAgICAgKiBAcmV0dXJuICB0aGUgYWJzb2x1dGUgcGF0aCBvZiB0aGUgZGVmYXVsdCBvdXRwdXQgZm9sZGVyIGZvciB0aGUgZ2l2ZW4gamF2YSBwcm9qZWN0IG5hbWUKKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIElQYXRoIGdldEphdmFQcm9qZWN0T3V0cHV0RGlyZWN0b3J5UGF0aChTdHJpbmcgcHJvamVjdE5hbWUpIHsKICAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldEphdmFQcm9qZWN0T3V0cHV0RGlyZWN0b3J5UGF0aChKRFRVdGlscy5nZXRKYXZhUHJvamVjdChwcm9qZWN0TmFtZSkpOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChJSmF2YVByb2plY3QgamF2YVByb2plY3QsCi0gICAgICAgICAgICBTdHJpbmcgZnVsbHlRdWFsaWZpZWRDbGFzc05hbWUpIHsKLSAgICAgICAgCi0gICAgICAgIElUeXBlIHR5cGUgPSBKRFRVdGlscy5nZXRUeXBlKGphdmFQcm9qZWN0LCBmdWxseVF1YWxpZmllZENsYXNzTmFtZSk7CisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgZnVsbCwgYWJzb2x1dGUgcGF0aCByZWxhdGl2ZSB0byB0aGUgd29ya3NwYWNlIG9mIHRoZSBzb3VyY2UgZm9sZGVyIHRoYXQgY29udGFpbnMgdGhlIGdpdmVuIHR5cGUuCisgICAgICogQHBhcmFtIHR5cGUgdGhlIDxjb2RlPklUeXBlPC9jb2RlPgorICAgICAqIEByZXR1cm4gdGhlIGFic29sdXRlIHBhdGggb2YgdGhlIGdpdmVuIDxjb2RlPklUeXBlPC9jb2RlPiBzb3VyY2UgZm9sZGVyCisgICAgICovCisgICAgcHVibGljIHN0YXRpYyBJUGF0aCBnZXRKYXZhUHJvamVjdFNvdXJjZURpcmVjdG9yeVBhdGgoSVR5cGUgdHlwZSkgewogICAgICAgICBJUGFja2FnZUZyYWdtZW50IHBhY2thZ2VGcmFnbWVudCA9IHR5cGUuZ2V0UGFja2FnZUZyYWdtZW50KCk7Ci0gICAgICAgIElQYWNrYWdlRnJhZ21lbnRSb290IHBhY2thZ2VGcmFnbWVudFJvb3QgPSAoSVBhY2thZ2VGcmFnbWVudFJvb3QpcGFja2FnZUZyYWdtZW50LmdldFBhcmVudCgpOworICAgICAgICBJUGFja2FnZUZyYWdtZW50Um9vdCBwYWNrYWdlRnJhZ21lbnRSb290ID0gKElQYWNrYWdlRnJhZ21lbnRSb290KSBwYWNrYWdlRnJhZ21lbnQuZ2V0UGFyZW50KCk7CiAgICAgICAgIElSZXNvdXJjZSBzcmNEaXJlY3RvcnlSZXNvdXJjZSA9IHBhY2thZ2VGcmFnbWVudFJvb3QuZ2V0UmVzb3VyY2UoKTsKLSAgICAgICAgcmV0dXJuIHNyY0RpcmVjdG9yeVJlc291cmNlLmdldEZ1bGxQYXRoKCkudG9PU1N0cmluZygpOworICAgICAgICByZXR1cm4gc3JjRGlyZWN0b3J5UmVzb3VyY2UuZ2V0RnVsbFBhdGgoKTsKICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRKYXZhUHJvamVjdFNvdXJjZURpcmVjdG9yeVBhdGgoU3RyaW5nIHByb2plY3ROYW1lLCAKLSAgICAgICAgICAgIFN0cmluZyBmdWxseVF1YWxpZmllZENsYXNzTmFtZSkgewotICAgICAgICByZXR1cm4gSkRUVXRpbHMuZ2V0SmF2YVByb2plY3RTb3VyY2VEaXJlY3RvcnlQYXRoKEpEVFV0aWxzLmdldEphdmFQcm9qZWN0KHByb2plY3ROYW1lKSwKLSAgICAgICAgICAgICAgICBmdWxseVF1YWxpZmllZENsYXNzTmFtZSk7Ci0gICAgfQotCi0gICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0SmF2YVByb2plY3RTb3VyY2VEaXJlY3RvcnlQYXRoKFN0cmluZyBwcm9qZWN0TmFtZSkgeworICAgIC8qKgorICAgICAqIFJldHVybnMgdGhlIGZ1bGwsIGFic29sdXRlIHBhdGggcmVsYXRpdmUgdG8gdGhlIHdvcmtzcGFjZSBvZiB0aGUgZmlyc3Qgc291cmNlIGZvbGRlciBmb3VuZCBpbiB0aGUgamF2YSBwcm9qZWN0IHdpdGggdGhlIGdpdmVuIG5hbWUuCisgICAgICogQHBhcmFtIHByb2plY3ROYW1lIHRoZSBuYW1lIG9mIHRoZSBqYXZhIHByb2plY3QKKyAgICAgKiBAcmV0dXJuIHRoZSBhYnNvbHV0ZSBwYXRoIG9mIHRoZSBmaXJzdCBzb3VyY2UgZm9sZGVyIGZvdW5kIGluIHRoZSBqYXZhIHByb2plY3Qgd2l0aCB0aGUgZ2l2ZW4gbmFtZS4KKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIElQYXRoIGdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChTdHJpbmcgcHJvamVjdE5hbWUpIHsKICAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChKRFRVdGlscy5nZXRKYXZhUHJvamVjdChwcm9qZWN0TmFtZSkpOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldEphdmFQcm9qZWN0U291cmNlRGlyZWN0b3J5UGF0aChJUHJvamVjdCBwcm9qZWN0KSB7Ci0gICAgICAgIHJldHVybiBKRFRVdGlscy5nZXRKYXZhUHJvamVjdFNvdXJjZURpcmVjdG9yeVBhdGgoSkRUVXRpbHMuZ2V0SmF2YVByb2plY3QocHJvamVjdCkpOwotICAgIH0KLSAgICAKLSAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRKYXZhUHJvamVjdFNvdXJjZURpcmVjdG9yeVBhdGgoSUphdmFQcm9qZWN0IGphdmFQcm9qZWN0KSB7CisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgZnVsbCwgYWJzb2x1dGUgcGF0aCByZWxhdGl2ZSB0byB0aGUgd29ya3NwYWNlIG9mIHRoZSBmaXJzdCBzb3VyY2UgZm9sZGVyIGZvdW5kIGluIHRoZSBnaXZlbiBqYXZhIHByb2plY3QuCisgICAgICogQHBhcmFtIGphdmFQcm9qZWN0IHRoZSA8Y29kZT5JSmF2YVByb2plY3Q8L2NvZGU+CisgICAgICogQHJldHVybiB0aGUgYWJzb2x1dGUgcGF0aCBvZiB0aGUgZmlyc3Qgc291cmNlIGZvbGRlciBmb3VuZCBpbiB0aGUgZ2l2ZW4gamF2YSBwcm9qZWN0LgorICAgICAqLworICAgIHB1YmxpYyBzdGF0aWMgSVBhdGggZ2V0SmF2YVByb2plY3RTb3VyY2VEaXJlY3RvcnlQYXRoKElKYXZhUHJvamVjdCBqYXZhUHJvamVjdCkgewogICAgICAgICB0cnkgewogICAgICAgICAgICAgSVBhY2thZ2VGcmFnbWVudFJvb3RbXSBwYWNrYWdlRnJhZ21lbnRSb290cyA9IGphdmFQcm9qZWN0LmdldEFsbFBhY2thZ2VGcmFnbWVudFJvb3RzKCk7CiAgICAgICAgICAgICBJUGFja2FnZUZyYWdtZW50Um9vdCBwYWNrYWdlRnJhZ21lbnRSb290ID0gcGFja2FnZUZyYWdtZW50Um9vdHNbMF07CiAgICAgICAgICAgICBJUmVzb3VyY2Ugc3JjRGlyZWN0b3J5UmVzb3VyY2UgPSBwYWNrYWdlRnJhZ21lbnRSb290LmdldFJlc291cmNlKCk7Ci0gICAgICAgICAgICByZXR1cm4gc3JjRGlyZWN0b3J5UmVzb3VyY2UuZ2V0RnVsbFBhdGgoKS50b09TU3RyaW5nKCk7CisgICAgICAgICAgICByZXR1cm4gc3JjRGlyZWN0b3J5UmVzb3VyY2UuZ2V0RnVsbFBhdGgoKTsKICAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewogICAgICAgICAgICAgSkFYV1NDb3JlUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9Ci0gICAgICAgIHJldHVybiAiIjsgLy8kTk9OLU5MUy0xJAorICAgICAgICByZXR1cm4gbmV3IFBhdGgoIiIpOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldFBhY2thZ2VOYW1lRnJvbUNsYXNzKElKYXZhUHJvamVjdCBqYXZhUHJvamVjdCwgU3RyaW5nIGZ1bGx5UXVhbGlmaWVkQ2xhc3NOYW1lKSB7Ci0gICAgICAgIHJldHVybiBKRFRVdGlscy5nZXRUeXBlKGphdmFQcm9qZWN0LCBmdWxseVF1YWxpZmllZENsYXNzTmFtZSkuZ2V0UGFja2FnZUZyYWdtZW50KCkuZ2V0RWxlbWVudE5hbWUoKTsKLSAgICB9Ci0KLSAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRQYWNrYWdlTmFtZUZyb21DbGFzcyhTdHJpbmcgcHJvamVjdE5hbWUsIFN0cmluZyBmdWxseVF1YWxpZmllZENsYXNzTmFtZSkgewotICAgICAgICByZXR1cm4gSkRUVXRpbHMKLSAgICAgICAgICAgICAgICAuZ2V0UGFja2FnZU5hbWVGcm9tQ2xhc3MoSkRUVXRpbHMuZ2V0SmF2YVByb2plY3QocHJvamVjdE5hbWUpLCBmdWxseVF1YWxpZmllZENsYXNzTmFtZSk7Ci0gICAgfQotCi0gICAgCiAgICAgLyoqCiAgICAgICogSWYgdGhlIGdpdmVuIDxjb2RlPklUeXBlPC9jb2RlPiBpcyBhbiBpbnRlcmZhY2UgYWxsIG1ldGhvZHMgZGVjbGFyZWQgaW4gdGhhdCBpbnRlcmZhY2UgYXJlIHJldHVybmVkLgogICAgICAqIDxwPgotICAgICAqIEFsdGVybmF0aXZlbHkgaWYgdGhlIGdpdmVuIGdpdmVuIDxjb2RlPklUeXBlPC9jb2RlPiBpcyBhIGNsYXNzIG9ubHkgbWV0aG9kcyB0aGF0IGFyZSBleHBsaWNpdGx5IG1hcmtlZAorICAgICAqIEFsdGVybmF0aXZlbHkgaWYgdGhlIGdpdmVuIGdpdmVuIDxjb2RlPklUeXBlPC9jb2RlPiBpcyBhIGNsYXNzLCBvbmx5IG1ldGhvZHMgdGhhdCBhcmUgZXhwbGljaXRseSBtYXJrZWQKICAgICAgKiBwdWJsaWMgYXJlIHJldHVybmVkLgotICAgICAqIAotICAgICAqIEBwYXJhbSB0eXBlIHRoZSB0eXBlCisgICAgICoKKyAgICAgKiBAcGFyYW0gdHlwZSB0aGUgPGNvZGU+SVR5cGU8L2NvZGU+CiAgICAgICogQHJldHVybiB0aGUgcHVibGljIG1ldGhvZHMgZGVjbGFyZWQgaW4gdGhpcyB0eXBlCiAgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBJTWV0aG9kW10gZ2V0UHVibGljTWV0aG9kcyhJVHlwZSB0eXBlKSB7CkBAIC0yMTcsMTYgKzE4OCwxNiBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBwdWJsaWNNZXRob2RzLnRvQXJyYXkobmV3IElNZXRob2RbcHVibGljTWV0aG9kcy5zaXplKCldKTsKICAgICB9Ci0gICAgCi0gICAgcHVibGljIHN0YXRpYyBTdHJpbmcgZ2V0U291cmNlRnJvbVR5cGUoSVR5cGUgdHlwZSkgewotICAgICAgICB0cnkgewotICAgICAgICAgICAgcmV0dXJuIHR5cGUuZ2V0Q29tcGlsYXRpb25Vbml0KCkuZ2V0QnVmZmVyKCkuZ2V0Q29udGVudHMoKTsKLSAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewotICAgICAgICAgICAgSkFYV1NDb3JlUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwotICAgICAgICB9Ci0gICAgICAgIHJldHVybiAiIjsgLy8kTk9OLU5MUy0xJAotICAgIH0KIAorICAgIC8qKgorICAgICAqIENvbnN0cnVjdHMgYSB0YXJnZXQgbmFtZXNwYWNlIHN0cmluZyBmcm9tIHRoZSBnaXZlbiBwYWNrYWdlIG5hbWUgYnkgc3BsaXR0aW5nIHRoZSBkb3QgJy4nIHNlcGFyYXRlZAorICAgICAqIHBhY2thZ2UgbmFtZSwgcmV2ZXJzaW5nIHRoZSBvcmRlciBvZiB0aGUgcGFja2FnZSBuYW1lIHNlZ21lbnRzIGZvbGxvd2VkIGJ5IHByZWZpeGluZyB0aGUgc3RyaW5nIHdpdGgKKyAgICAgKiAnaHR0cDovLycgYW5kIGFwcGVuZGluZyBhIGZvcndhcmQgc2xhc2ggJy8nIHRvIHRoZSBlbmQuCisgICAgICogPHA+RS5nLiwgdGhlIEphdmEgcGFja2FnZSDSY29tLmV4YW1wbGUud3PTIHdvdWxkIHJldHVybiB0aGUgdGFyZ2V0IG5hbWVzcGFjZSDSaHR0cDovL3dzLmV4YW1wbGUuY29tL9MuPC9wPgorICAgICAqIDxwPklmIHRoZSBwYWNrYWdlIG5hbWUgaXMgbnVsbCBvciBpcyBvZiB6ZXJvIGxlbmd0aCAgImh0dHA6Ly9kZWZhdWx0X3BhY2thZ2UvIiBpcyByZXR1cm5lZC48L3A+CisgICAgICogQHBhcmFtIHBhY2thZ2VOYW1lIHRoZSBwYWNrYWdlIG5hbWUKKyAgICAgKiBAcmV0dXJuIHRoZSBkZXJpdmVkIHRhcmdldCBuYW1lc3BhY2UKKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIFN0cmluZyBnZXRUYXJnZXROYW1lc3BhY2VGcm9tUGFja2FnZU5hbWUoU3RyaW5nIHBhY2thZ2VOYW1lKSB7CiAgICAgICAgIGlmIChwYWNrYWdlTmFtZSA9PSBudWxsIHx8IHBhY2thZ2VOYW1lLmxlbmd0aCgpID09IDApIHsKICAgICAgICAgICAgIHJldHVybiAiaHR0cDovL2RlZmF1bHRfcGFja2FnZS8iOyAvLyROT04tTkxTLTEkCkBAIC0yNDksNiArMjIwLDEyIEBACiAgICAgICAgIHJldHVybiB0YXJnZXROYW1lc3BhY2U7CiAgICAgfQogCisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgZmlyc3QgdHlwZSBmb3VuZCBmb2xsb3dpbmcgdGhlIGdpdmVuIGphdmEgcHJvamVjdCdzIGNsYXNzcGF0aCB3aXRoIHRoZSBnaXZlbiBmdWxseSBxdWFsaWZpZWQgbmFtZSBvciBudWxsIGlmIG5vbmUgaXMgZm91bmQuCisgICAgICogQHBhcmFtIGphdmFQcm9qZWN0IHRoZSBnaXZlbiA8Y29kZT5JSmF2YVByb2plY3Q8L2NvZGU+CisgICAgICogQHBhcmFtIGZ1bGx5UXVhbGlmaWVkQ2xhc3NOYW1lIHRoZSBnaXZlbiBmdWxseSBxdWFsaWZpZWQgbmFtZQorICAgICAqIEByZXR1cm4gdGhlIGZpcnN0IHR5cGUgZm91bmQgZm9sbG93aW5nIHRoZSBqYXZhIHByb2plY3QncyBjbGFzc3BhdGggd2l0aCB0aGUgZ2l2ZW4gZnVsbHkgcXVhbGlmaWVkIG5hbWUgb3IgbnVsbCBpZiBub25lIGlzIGZvdW5kCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBJVHlwZSBnZXRUeXBlKElKYXZhUHJvamVjdCBqYXZhUHJvamVjdCwgU3RyaW5nIGZ1bGx5UXVhbGlmaWVkQ2xhc3NOYW1lKSB7CiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICByZXR1cm4gamF2YVByb2plY3QuZmluZFR5cGUoZnVsbHlRdWFsaWZpZWRDbGFzc05hbWUpOwpAQCAtMjU4LDE0ICsyMzUsMjIgQEAKICAgICAgICAgcmV0dXJuIG51bGw7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBJVHlwZSBnZXRUeXBlKElQcm9qZWN0IHByb2plY3QsIFN0cmluZyBmdWxseVF1YWxpZmllZENsYXNzTmFtZSkgewotICAgICAgICByZXR1cm4gSkRUVXRpbHMuZ2V0VHlwZShKRFRVdGlscy5nZXRKYXZhUHJvamVjdChwcm9qZWN0KSwgZnVsbHlRdWFsaWZpZWRDbGFzc05hbWUpOwotICAgIH0KLQorICAgIC8qKgorICAgICAqIFJldHVybnMgdGhlIGZpcnN0IHR5cGUgZm91bmQgd2l0aCB0aGUgZ2l2ZW4gZnVsbHkgcXVhbGlmaWVkIG5hbWUgZm9sbG93aW5nIHRoZSBjbGFzc3BhdGggb2YgdGhlIGphdmEgcHJvamVjdCB3aXRoCisgICAgICogdGhlIGdpdmUgcHJvamVjdCBuYW1lIG9yIG51bGwgaWYgbm9uZSBpcyBmb3VuZC4KKyAgICAgKiBAcGFyYW0gcHJvamVjdE5hbWUgdGhlIG5hbWUgb2YgdGhlIGphdmEgcHJvamVjdAorICAgICAqIEBwYXJhbSBmdWxseVF1YWxpZmllZENsYXNzTmFtZSB0aGUgZ2l2ZW4gZnVsbHkgcXVhbGlmaWVkIG5hbWUKKyAgICAgKiBAcmV0dXJuIHRoZSBmaXJzdCB0eXBlIGZvdW5kIGZvbGxvd2luZyB0aGUgamF2YSBwcm9qZWN0J3MgY2xhc3NwYXRoIHdpdGggdGhlIGdpdmVuIGZ1bGx5IHF1YWxpZmllZCBuYW1lIG9yIG51bGwgaWYgbm9uZSBpcyBmb3VuZAorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgSVR5cGUgZ2V0VHlwZShTdHJpbmcgcHJvamVjdE5hbWUsIFN0cmluZyBmdWxseVF1YWxpZmllZENsYXNzTmFtZSkgewogICAgICAgICByZXR1cm4gSkRUVXRpbHMuZ2V0VHlwZShKRFRVdGlscy5nZXRKYXZhUHJvamVjdChwcm9qZWN0TmFtZSksIGZ1bGx5UXVhbGlmaWVkQ2xhc3NOYW1lKTsKICAgICB9CiAKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHdoZXRoZXIgdGhlIGdpdmVuIHByb2plY3QgaGFzIHRoZSBqYXZhIG5hdHVyZS4KKyAgICAgKiBAcGFyYW0gcHJvamVjdCB0aGUgZ2l2ZW4gcHJvamVjdAorICAgICAqIEByZXR1cm4gPGNvZGU+dHJ1ZTwvY29kZT4gaWYgdGhlIHByb2plY3QgaGFzIHRoZSBqYXZhIG5hdHVyZQorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgYm9vbGVhbiBpc0phdmFQcm9qZWN0KElQcm9qZWN0IHByb2plY3QpIHsKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIHJldHVybiBwcm9qZWN0Lmhhc05hdHVyZShKYXZhQ29yZS5OQVRVUkVfSUQpOwpAQCAtMjc0LDcgKzI1OSwxMiBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9Ci0gICAgCisKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHRydWUgaWYgdGhlIGdpdmVuIG1ldGhvZCBpc24ndCBhIG1haW4gbWV0aG9kIG9yIGNvbnN0cnVjdG9yIGFuZCBpZiBpdCBoYXMgdGhlIHB1YmxpYyBtb2RpZmllci4KKyAgICAgKiBAcGFyYW0gbWV0aG9kIHRoZSBnaXZlbiBtZXRob2QKKyAgICAgKiBAcmV0dXJuIDxjb2RlPnRydWU8L2NvZGU+IGlmIHRoZSBnaXZlbiBtZXRob2QgaXMgcHVibGljCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBib29sZWFuIGlzUHVibGljTWV0aG9kKElNZXRob2QgbWV0aG9kKSB7CiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICByZXR1cm4gRmxhZ3MuaXNQdWJsaWMobWV0aG9kLmdldEZsYWdzKCkpICYmICFtZXRob2QuaXNDb25zdHJ1Y3RvcigpICYmICFtZXRob2QuaXNNYWluTWV0aG9kKCk7CkBAIC0yODQsMTkgKzI3NCwzOSBAQAogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBJU3RhdHVzIHZhbGlkYXRlSmF2YVR5cGVOYW1lKFN0cmluZyBjb21waWxhdGlvblVuaXROYW1lKSB7CisgICAgLyoqCisgICAgICogVmFsaWRhdGVzIHRoZSBnaXZlbiBKYXZhIHR5cGUgbmFtZSwgZWl0aGVyIHNpbXBsZSBvciBxdWFsaWZpZWQsIHVzaW5nIHRoZSB3b3Jrc3BhY2Ugc291cmNlIGFuZCBjb21wbGlhbmNlIGxldmVscy4KKyAgICAgKiBAcGFyYW0gbmFtZSB0aGUgbmFtZSBvZiBhIHR5cGUKKyAgICAgKiBAcmV0dXJuIGEgc3RhdHVzIG9iamVjdCB3aXRoIGNvZGUgSVN0YXR1cy5PSyBpZiB0aGUgZ2l2ZW4gbmFtZSBpcyB2YWxpZCBhcyBhIEphdmEgdHlwZSBuYW1lLCBhIHN0YXR1cyB3aXRoCisgICAgICogY29kZSBJU3RhdHVzLldBUk5JTkcgaW5kaWNhdGluZyB3aHkgdGhlIGdpdmVuIG5hbWUgaXMgZGlzY291cmFnZWQsIG90aGVyd2lzZSBhIHN0YXR1cyBvYmplY3QgaW5kaWNhdGluZyB3aGF0IGlzIHdyb25nIHdpdGggdGhlIG5hbWUKKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIElTdGF0dXMgdmFsaWRhdGVKYXZhVHlwZU5hbWUoU3RyaW5nIG5hbWUpIHsKICAgICAgICAgU3RyaW5nIHNvdXJjZUxldmVsID0gSmF2YUNvcmUuZ2V0T3B0aW9uKEphdmFDb3JlLkNPTVBJTEVSX1NPVVJDRSk7CiAgICAgICAgIFN0cmluZyBjb21wbGlhbmNlTGV2ZWwgPSBKYXZhQ29yZS5nZXRPcHRpb24oSmF2YUNvcmUuQ09NUElMRVJfQ09NUExJQU5DRSk7Ci0gICAgICAgIHJldHVybiBKYXZhQ29udmVudGlvbnMudmFsaWRhdGVKYXZhVHlwZU5hbWUoY29tcGlsYXRpb25Vbml0TmFtZSwgc291cmNlTGV2ZWwsIGNvbXBsaWFuY2VMZXZlbCk7CisgICAgICAgIHJldHVybiBKYXZhQ29udmVudGlvbnMudmFsaWRhdGVKYXZhVHlwZU5hbWUobmFtZSwgc291cmNlTGV2ZWwsIGNvbXBsaWFuY2VMZXZlbCk7CiAgICAgfQogCi0gICAgcHVibGljIHN0YXRpYyBJU3RhdHVzIHZhbGlkYXRlSmF2YVR5cGVOYW1lKFN0cmluZyBwcm9qZWN0TmFtZSwgU3RyaW5nIGNvbXBpbGF0aW9uVW5pdE5hbWUpIHsKKyAgICAvKioKKyAgICAgKiBWYWxpZGF0ZXMgdGhlIGdpdmVuIEphdmEgdHlwZSBuYW1lLCBlaXRoZXIgc2ltcGxlIG9yIHF1YWxpZmllZCwgdXNpbmcgdGhlIGdpdmVuIHByb2plY3RzIHNvdXJjZSBhbmQgY29tcGxpYW5jZSBsZXZlbHMuCisgICAgICogQHBhcmFtIHByb2plY3ROYW1lIHRoZSBuYW1lIG9mIHRoZSBqYXZhIHByb2plY3QKKyAgICAgKiBAcGFyYW0gbmFtZSB0aGUgbmFtZSBvZiBhIHR5cGUKKyAgICAgKiBAcmV0dXJuIGEgc3RhdHVzIG9iamVjdCB3aXRoIGNvZGUgSVN0YXR1cy5PSyBpZiB0aGUgZ2l2ZW4gbmFtZSBpcyB2YWxpZCBhcyBhIEphdmEgdHlwZSBuYW1lLCBhIHN0YXR1cyB3aXRoCisgICAgICogY29kZSBJU3RhdHVzLldBUk5JTkcgaW5kaWNhdGluZyB3aHkgdGhlIGdpdmVuIG5hbWUgaXMgZGlzY291cmFnZWQsIG90aGVyd2lzZSBhIHN0YXR1cyBvYmplY3QgaW5kaWNhdGluZyB3aGF0IGlzIHdyb25nIHdpdGggdGhlIG5hbWUKKyAgICAgKi8KKyAgICBwdWJsaWMgc3RhdGljIElTdGF0dXMgdmFsaWRhdGVKYXZhVHlwZU5hbWUoU3RyaW5nIHByb2plY3ROYW1lLCBTdHJpbmcgbmFtZSkgewogICAgICAgICBJSmF2YVByb2plY3QgamF2YVByb2plY3QgPSBKRFRVdGlscy5nZXRKYXZhUHJvamVjdChwcm9qZWN0TmFtZSk7CiAgICAgICAgIFN0cmluZyBzb3VyY2VMZXZlbCA9IGphdmFQcm9qZWN0LmdldE9wdGlvbihKYXZhQ29yZS5DT01QSUxFUl9TT1VSQ0UsIHRydWUpOwogICAgICAgICBTdHJpbmcgY29tcGxpYW5jZUxldmVsID0gamF2YVByb2plY3QuZ2V0T3B0aW9uKEphdmFDb3JlLkNPTVBJTEVSX0NPTVBMSUFOQ0UsIHRydWUpOwotICAgICAgICByZXR1cm4gSmF2YUNvbnZlbnRpb25zLnZhbGlkYXRlSmF2YVR5cGVOYW1lKGNvbXBpbGF0aW9uVW5pdE5hbWUsIHNvdXJjZUxldmVsLCBjb21wbGlhbmNlTGV2ZWwpOworICAgICAgICByZXR1cm4gSmF2YUNvbnZlbnRpb25zLnZhbGlkYXRlSmF2YVR5cGVOYW1lKG5hbWUsIHNvdXJjZUxldmVsLCBjb21wbGlhbmNlTGV2ZWwpOwogICAgIH0KIAorICAgIC8qKgorICAgICAqIFZhbGlkYXRlIHRoZSBnaXZlbiBwYWNrYWdlIG5hbWUgdXNpbmcgdGhlIGdpdmVuIHByb2plY3RzIHNvdXJjZSBhbmQgY29tcGxpYW5jZSBsZXZlbHMuCisgICAgICogQHBhcmFtIHByb2plY3ROYW1lIHRoZSBuYW1lIG9mIHRoZSBqYXZhIHByb2plY3QKKyAgICAgKiBAcGFyYW0gcGFja2FnZU5hbWUgdGhlIG5hbWUgb2YgYSBwYWNrYWdlCisgICAgICogQHJldHVybiBhIHN0YXR1cyBvYmplY3Qgd2l0aCBjb2RlIElTdGF0dXMuT0sgaWYgdGhlIGdpdmVuIG5hbWUgaXMgdmFsaWQgYXMgYSBwYWNrYWdlIG5hbWUsIG90aGVyd2lzZSBhIHN0YXR1cworICAgICAqIG9iamVjdCBpbmRpY2F0aW5nIHdoYXQgaXMgd3Jvbmcgd2l0aCB0aGUgbmFtZQorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgSVN0YXR1cyB2YWxpZGF0ZVBhY2thZ2VOYW1lKFN0cmluZyBwcm9qZWN0TmFtZSwgU3RyaW5nIHBhY2thZ2VOYW1lKSB7CiAgICAgICAgIElKYXZhUHJvamVjdCBqYXZhUHJvamVjdCA9IEpEVFV0aWxzLmdldEphdmFQcm9qZWN0KHByb2plY3ROYW1lKTsKICAgICAgICAgU3RyaW5nIHNvdXJjZUxldmVsID0gamF2YVByb2plY3QuZ2V0T3B0aW9uKEphdmFDb3JlLkNPTVBJTEVSX1NPVVJDRSwgdHJ1ZSk7CkBAIC0zMDQsNiArMzE0LDEyIEBACiAgICAgICAgIHJldHVybiBKYXZhQ29udmVudGlvbnMudmFsaWRhdGVQYWNrYWdlTmFtZShwYWNrYWdlTmFtZSwgc291cmNlTGV2ZWwsIGNvbXBsaWFuY2VMZXZlbCk7CiAgICAgfQogCisgICAgLyoqCisgICAgICogVmFsaWRhdGVzIHRoZSBnaXZlbiBKYXZhIGlkZW50aWZpZXIgd2l0aCB0aGUgd29ya3NwYWNlIHNvdXJjZSBhbmQgY29tcGxpYW5jZSBsZXZlbHMuCisgICAgICogQHBhcmFtIGlkIHRoZSBKYXZhIGlkZW50aWZpZXIKKyAgICAgKiBAcmV0dXJuIGEgc3RhdHVzIG9iamVjdCB3aXRoIGNvZGUgSVN0YXR1cy5PSyBpZiB0aGUgZ2l2ZW4gaWRlbnRpZmllciBpcyBhIHZhbGlkIEphdmEgaWRlbnRpZmllciwgb3RoZXJ3aXNlCisgICAgICogYSBzdGF0dXMgb2JqZWN0IGluZGljYXRpbmcgd2hhdCBpcyB3cm9uZyB3aXRoIHRoZSBpZGVudGlmaWVyCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBJU3RhdHVzIHZhbGlkYXRlSWRlbnRpZmllcihTdHJpbmcgaWQpIHsKICAgICAgICAgU3RyaW5nIHNvdXJjZUxldmVsID0gSmF2YUNvcmUuZ2V0T3B0aW9uKEphdmFDb3JlLkNPTVBJTEVSX1NPVVJDRSk7CiAgICAgICAgIFN0cmluZyBjb21wbGlhbmNlTGV2ZWwgPSBKYXZhQ29yZS5nZXRPcHRpb24oSmF2YUNvcmUuQ09NUElMRVJfQ09NUExJQU5DRSk7CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS91dGlscy9XU0RMVXRpbHMuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3V0aWxzL1dTRExVdGlscy5qYXZhCmluZGV4IDgyYzRjODIuLjUzMTU0ZjAgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3V0aWxzL1dTRExVdGlscy5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3V0aWxzL1dTRExVdGlscy5qYXZhCkBAIC01Niw5ICs1Niw5IEBACiAvKioKICAqIFdTREwgVXRpbGl0eSBjbGFzcy4KICAqIDxwPgotICogPHN0cm9uZz5Qcm92aXNpb25hbCBBUEk6PC9zdHJvbmc+IFRoaXMgY2xhc3MvaW50ZXJmYWNlIGlzIHBhcnQgb2YgYW4gaW50ZXJpbSBBUEkgdGhhdCBpcyBzdGlsbCB1bmRlciAKLSAqIGRldmVsb3BtZW50IGFuZCBleHBlY3RlZCB0byBjaGFuZ2Ugc2lnbmlmaWNhbnRseSBiZWZvcmUgcmVhY2hpbmcgc3RhYmlsaXR5LiBJdCBpcyBiZWluZyBtYWRlIGF2YWlsYWJsZSBhdCAKLSAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMgCisgKiA8c3Ryb25nPlByb3Zpc2lvbmFsIEFQSTo8L3N0cm9uZz4gVGhpcyBjbGFzcy9pbnRlcmZhY2UgaXMgcGFydCBvZiBhbiBpbnRlcmltIEFQSSB0aGF0IGlzIHN0aWxsIHVuZGVyCisgKiBkZXZlbG9wbWVudCBhbmQgZXhwZWN0ZWQgdG8gY2hhbmdlIHNpZ25pZmljYW50bHkgYmVmb3JlIHJlYWNoaW5nIHN0YWJpbGl0eS4gSXQgaXMgYmVpbmcgbWFkZSBhdmFpbGFibGUgYXQKKyAqIHRoaXMgZWFybHkgc3RhZ2UgdG8gc29saWNpdCBmZWVkYmFjayBmcm9tIHBpb25lZXJpbmcgYWRvcHRlcnMgb24gdGhlIHVuZGVyc3RhbmRpbmcgdGhhdCBhbnkgY29kZSB0aGF0IHVzZXMKICAqIHRoaXMgQVBJIHdpbGwgYWxtb3N0IGNlcnRhaW5seSBiZSBicm9rZW4gKHJlcGVhdGVkbHkpIGFzIHRoZSBBUEkgZXZvbHZlcy4KICAqIDwvcD4KICAqLwpAQCAtNzAsMTAgKzcwLDE3IEBACiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgaW50IFRJTUVPVVQgPSAzMDAwMDsKIAogCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFdTRExfRklMRV9FWFRFTlNJT04gPSAiLndzZGwiOyAvLyROT04tTkxTLTEkCi0JCisKICAgICBwcml2YXRlIFdTRExVdGlscygpIHsKICAgICB9Ci0gICAgICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyBhIDxjb2RlPmphdmF4LndzZGwuRGVmaW5pdGlvbjwvY29kZT4gYnkgcmVhZGluZyB0aGUgV1NETCBkb2N1bWVudCBhdCB0aGUgZ2l2ZW4gVVJMIG9yIG51bGwgaWYgbm9uZSBjYW4gYmUgZm91bmQKKyAgICAgKiBvciBpZiB0aGUgY29ubmVjdGlvbiB0aW1lcyBvdXQuCisgICAgICogQHBhcmFtIHdzZGxVUkwgdGhlIHVybCBvZiB0aGUgd3NkbCBkb2N1bWVudCB0byByZWFkLgorICAgICAqIEByZXR1cm4gdGhlIGRlZmluaXRpb24gZGVzY3JpYmVkIGluIHRoZSB3c2RsIGRvY3VtZW50IHBvaW50ZWQgdG8gYnkgdGhlIGdpdmVuIFVSTC4KKyAgICAgKiBAdGhyb3dzIElPRXhjZXB0aW9uIGlmIGFuIEkvTyBleGNlcHRpb24gb2NjdXJzLgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgRGVmaW5pdGlvbiByZWFkV1NETChVUkwgd3NkbFVSTCkgdGhyb3dzIElPRXhjZXB0aW9uIHsKICAgICAJVVJMQ29ubmVjdGlvbiB1cmxDb25uZWN0aW9uID0gd3NkbFVSTC5vcGVuQ29ubmVjdGlvbigpOwogICAgIAl1cmxDb25uZWN0aW9uLnNldENvbm5lY3RUaW1lb3V0KFRJTUVPVVQpOwpAQCAtOTUsNyArMTAyLDE0IEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIG51bGw7CiAgICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogV3JpdGVzIHRoZSBnaXZlbiA8Y29kZT5qYXZheC53c2RsLkRlZmluaXRpb248L2NvZGU+IHRvIHRoZSB3c2RsIGRvY3VtZW50IGF0IHRoZSBnaXZlbiBVUkwuCisgICAgICogQHBhcmFtIHdzZGxVUkwgdGhlIHVybCBvZiB0aGUgd3NkbCBkb2N1bWVudCB0byB3cml0ZSB0by4KKyAgICAgKiBAcGFyYW0gZGVmaW5pdGlvbiB0aGUgV1NETCBkZWZpbml0aW9uIHRvIGJlIHdyaXR0ZW4uCisgICAgICogQHRocm93cyBJT0V4Y2VwdGlvbiAgaWYgYW4gSS9PIGV4Y2VwdGlvbiBvY2N1cnMuCisgICAgICogQHRocm93cyBDb3JlRXhjZXB0aW9uIGlmIGFuIGV4Y2VwdGlvbiBvY2N1cnMgcmVmcmVzaGluZyB0aGUgZmlsZSBpbiB0aGUgd29ya3NwYWNlIGlmIGl0IGV4aXN0cy4KKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIHZvaWQgd3JpdGVXU0RMKFVSTCB3c2RsVVJMLCBEZWZpbml0aW9uIGRlZmluaXRpb24pIHRocm93cyBJT0V4Y2VwdGlvbiwgQ29yZUV4Y2VwdGlvbiB7CiAgICAgCVVSSSB3c2RsVVJJID0gbnVsbDsKICAgICAgICAgT3V0cHV0U3RyZWFtIHdzZGxPdXRwdXRTdHJlYW0gPSBudWxsOwpAQCAtMTIxLDI4ICsxMzUsNDcgQEAKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KLSAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyA8Y29kZT50cnVlPC9jb2RlPiBpZiB0aGUgZ2l2ZW4gZmlsZSBuYW1lIGNvbnRhaW5zIEFscGhhbnVtZXJpYyBjaGFyYWN0ZXJzLCB1bmRlcnNjb3JlICdfJywKKyAgICAgKiBkYXNoZXMgJy0nIGFuZCBlbmRzIHdpdGggdGhlICcud3NkbCcgZXh0ZW5zaW9uLiBPdGhlcndpc2UgcmV0dXJucyA8Y29kZT5mYWxzZTwvY29kZT4uCisgICAgICogQHBhcmFtIHdzZGxGaWxlTmFtZSB0aGUgd3NkbCBmaWxlIG5hbWUKKyAgICAgKiBAcmV0dXJuIDxjb2RlPnRydWU8L2NvZGU+IGlmIHZhbGlkLCBjb2RlPmZhbHNlPC9jb2RlPiBvdGhlcndpc2UuCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBib29sZWFuIGlzVmFsaWRXU0RMRmlsZU5hbWUoU3RyaW5nIHdzZGxGaWxlTmFtZSkgewotICAgICAgICByZXR1cm4gd3NkbEZpbGVOYW1lICE9IG51bGwgJiYgd3NkbEZpbGVOYW1lLm1hdGNoZXMoV1NETF9GSUxFX05BTUVfUEFUVEVSTik7ICAgICAKKyAgICAgICAgcmV0dXJuIHdzZGxGaWxlTmFtZSAhPSBudWxsICYmIHdzZGxGaWxlTmFtZS5tYXRjaGVzKFdTRExfRklMRV9OQU1FX1BBVFRFUk4pOwogICAgIH0KLSAgICAgICAgCi0gICAgcHVibGljIHN0YXRpYyBJUHJvamVjdCBnZXRQcm9qZWN0KFN0cmluZyBwcm9qZWN0TmFtZSkgeworCisgICAgcHJpdmF0ZSBzdGF0aWMgSVByb2plY3QgZ2V0UHJvamVjdChTdHJpbmcgcHJvamVjdE5hbWUpIHsKICAgICAgICAgcmV0dXJuIFJlc291cmNlc1BsdWdpbi5nZXRXb3Jrc3BhY2UoKS5nZXRSb290KCkuZ2V0UHJvamVjdChwcm9qZWN0TmFtZSk7CiAgICAgfQotICAgICAgICAKLSAgICBwdWJsaWMgc3RhdGljIElGb2xkZXIgZ2V0V2ViQ29udGVudEZvbGRlcihTdHJpbmcgcHJvamVjdE5hbWUpIHsKLSAgICAJcmV0dXJuIFdTRExVdGlscy5nZXRXZWJDb250ZW50Rm9sZGVyKFdTRExVdGlscy5nZXRQcm9qZWN0KHByb2plY3ROYW1lKSk7Ci0gICAgfQotICAgIAorCisgICAgLyoqCisgICAgICogUmV0dXJucyB0aGUgV2ViIENvbnRlbnQgZm9sZGVyIG9mIHRoZSBnaXZlbiBwcm9qZWN0LiBUaGUgcmV0dXJuZWQgcmVzb3VyY2UgbWF5IG5vdCBleGlzdC4KKyAgICAgKiBAcGFyYW0gcHJvamVjdCB0aGUgbmFtZSBvZiB0aGUgd2ViIHByb2plY3QKKyAgICAgKiBAcmV0dXJuIHRoZSB3ZWIgY29udGVudCBmb2xkZXIKKyAgICAgKi8KICAgICBwdWJsaWMgc3RhdGljIElGb2xkZXIgZ2V0V2ViQ29udGVudEZvbGRlcihJUHJvamVjdCBwcm9qZWN0KSB7CiAJCXJldHVybiBSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkuZ2V0Um9vdCgpLmdldEZvbGRlcigKIAkJCQlXU0RMVXRpbHMuZ2V0V2ViQ29udGVudFBhdGgocHJvamVjdCkpOwogCX0KIAorICAgIC8qKgorICAgICAqIFJldHVybnMgdGhlIFdTREwgZm9sZGVyIG9mIHRoZSBwcm9qZWN0IHdpdGggdGhlIGdpdmVuIG5hbWUuIFRoZSBXU0RMIGZvbGRlciBwYXRoIGlzIHRoZSBwcm9qZWN0cyB3ZWIgY29udGVudCBmb2xkZXIKKyAgICAgKiBwYXRoIGFwcGVuZGVkIHdpdGggdGhlICdXU0RMJyBkaXJlY3RvcnkuIFRoZSByZXR1cm5lZCByZXNvdXJjZSBtYXkgbm90IGV4aXN0LgorICAgICAqIEBwYXJhbSBwcm9qZWN0TmFtZSB0aGUgbmFtZSBvZiB0aGUgd2ViIHByb2plY3QKKyAgICAgKiBAcmV0dXJuIHRoZSB3c2RsIGZvbGRlcgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgSUZvbGRlciBnZXRXU0RMRm9sZGVyKFN0cmluZyBwcm9qZWN0TmFtZSkgewogICAgICAgICByZXR1cm4gV1NETFV0aWxzLmdldFdTRExGb2xkZXIoV1NETFV0aWxzLmdldFByb2plY3QocHJvamVjdE5hbWUpKTsKICAgICB9CiAKKyAgICAvKioKKyAgICAgKiBSZXR1cm5zIHRoZSBXU0RMIGZvbGRlciBvZiB0aGUgZ2l2ZW4gcHJvamVjdC4gVGhlIFdTREwgZm9sZGVyIHBhdGggaXMgdGhlIHByb2plY3RzIHdlYiBjb250ZW50IGZvbGRlcgorICAgICAqIHBhdGggYXBwZW5kZWQgd2l0aCB0aGUgJ1dTREwnIGRpcmVjdG9yeS4gVGhlIHJldHVybmVkIHJlc291cmNlIG1heSBub3QgZXhpc3QuCisgICAgICogQHBhcmFtIHByb2plY3ROYW1lIHRoZSBuYW1lIG9mIHRoZSB3ZWIgcHJvamVjdAorICAgICAqIEByZXR1cm4gdGhlIHdzZGwgZm9sZGVyCisgICAgICovCiAgICAgcHVibGljIHN0YXRpYyBJRm9sZGVyIGdldFdTRExGb2xkZXIoSVByb2plY3QgcHJvamVjdCkgewogICAgICAgICBJUGF0aCB3c2RsRm9sZGVyUGF0aCA9IFdTRExVdGlscy5nZXRXZWJDb250ZW50UGF0aChwcm9qZWN0KS5hcHBlbmQoV1NETFV0aWxzLldTRExfRk9MREVSX1BBVEgpOwogICAgICAgICBJRm9sZGVyIHdzZGxGb2xkZXIgPSBSZXNvdXJjZXNQbHVnaW4uZ2V0V29ya3NwYWNlKCkuZ2V0Um9vdCgpLmdldEZvbGRlcih3c2RsRm9sZGVyUGF0aCk7CkBAIC0xNTUsMTggKzE4OCwxNiBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiB3c2RsRm9sZGVyOwogICAgIH0KLSAgICAKLSAgICBwdWJsaWMgc3RhdGljIElQYXRoIGdldFdlYkNvbnRlbnRQYXRoKElQcm9qZWN0IHByb2plY3QpIHsKKworICAgIHByaXZhdGUgc3RhdGljIElQYXRoIGdldFdlYkNvbnRlbnRQYXRoKElQcm9qZWN0IHByb2plY3QpIHsKICAgICAgICAgcmV0dXJuIEoyRUVVdGlscy5nZXRXZWJDb250ZW50UGF0aChwcm9qZWN0KS5hZGRUcmFpbGluZ1NlcGFyYXRvcigpOwogICAgIH0KIAotICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldFdTRExGaWxlTmFtZUZyb21VUkwoVVJMIHdzZGxVUkwpIHsKLSAgICAgICAgSVBhdGggd3NkbFBhdGggPSBuZXcgUGF0aCh3c2RsVVJMLnRvRXh0ZXJuYWxGb3JtKCkpOwotICAgICAgICByZXR1cm4gd3NkbFBhdGgubGFzdFNlZ21lbnQoKTsKLSAgICB9Ci0KICAgICAvKioKLSAgICAgKiB3aWxsIHJldHVybiBvbmUgb2Y6IAorICAgICAqIFJldHVybnMgdGhlIGZpcnN0IDxjb2RlPlNPQVBBZGRyZXNzPC9jb2RlPiBvciA8Y29kZT5TT0FQMTJBZGRyZXNzPC9jb2RlPiBmb3VuZCBpbiB0aGUgZ2l2ZW4KKyAgICAgKiA8Y29kZT5EZWZpbml0aW9uPC9jb2RlPiBvciBudWxsIGlmIG5vbmUgaXMgZm91bmQuCisgICAgICogQHBhcmFtIGRlZmluaXRpb24gdGhlIGdpdmVuIGRlZmluaXRpb24uCisgICAgICogQHJldHVybiByZXR1cm4gb25lIG9mOgogICAgICAqIDxsaT5TT0FQQWRkcmVzczxsaT5TT0FQMTJBZGRyZXNzPGxpPm51bGwgaWYgaXQgY2FuIG5vdCBmaW5kIGEgc29hcCBhZGRyZXNzCiAgICAgICovCiAgICAgQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCkBAIC0xODMsNyArMjE0LDcgQEAKICAgICAgICAgICAgICAgICAgICAgTGlzdCBleHRlbnNpYmlsaXR5RWxlbWVudHMgPSBwb3J0LmdldEV4dGVuc2liaWxpdHlFbGVtZW50cygpOwogICAgICAgICAgICAgICAgICAgICBmb3IgKE9iamVjdCBvYmplY3QgOiBleHRlbnNpYmlsaXR5RWxlbWVudHMpIHsKICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChvYmplY3QgaW5zdGFuY2VvZiBTT0FQQWRkcmVzcyB8fCBvYmplY3QgaW5zdGFuY2VvZiBTT0FQMTJBZGRyZXNzKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIChFeHRlbnNpYmlsaXR5RWxlbWVudCkgb2JqZWN0OyAgICAgIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAoRXh0ZW5zaWJpbGl0eUVsZW1lbnQpIG9iamVjdDsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICB9CkBAIC0xOTIsNiArMjIzLDE0IEBACiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KIAorICAgIC8qKgorICAgICAqIFJldHVybnMgdGhlIGxvY2F0aW9uIFVSSSBmcm9tIHRoZSBmaXJzdCA8Y29kZT5TT0FQQWRkcmVzczwvY29kZT4gb3IgPGNvZGU+U09BUDEyQWRkcmVzczwvY29kZT4gZm91bmQKKyAgICAgKiBpbiB0aGUgZ2l2ZW4gPGNvZGU+RGVmaW5pdGlvbjwvY29kZT4gb3IgbnVsbCBpZiBub25lIGlzIGZvdW5kLiBUaGUgcmV0dXJuZWQgbG9jYXRpb24gVVJJIGlzIGFwcGVuZGVkIHdpdGgKKyAgICAgKiB0aGUgJz93c2RsJyBxdWVyeSBpZiB0aGUgcXVlcnkgd2FzIG5vdCBwcmVzZW50IGluIHRoZSA8Y29kZT5TT0FQQWRkcmVzczwvY29kZT4gb3IgPGNvZGU+U09BUDEyQWRkcmVzczwvY29kZT4gbG9jYXRpb24gVVJJLgorICAgICAqIEBwYXJhbSBkZWZpbml0aW9uIHRoZSBnaXZlbiBkZWZpbnRpb24uCisgICAgICogQHJldHVybiB0aGUgbG9jYXRpb24gVVJJIG9yIHRoZSBmaXJzdCA8Y29kZT5TT0FQQWRkcmVzczwvY29kZT4gb3IgPGNvZGU+U09BUDEyQWRkcmVzczwvY29kZT4gZm91bmQgaW4gdGhlIGdpdmVuIGRlZmluaXRpb24uCisgICAgICogQHRocm93cyBNYWxmb3JtZWRVUkxFeGNlcHRpb24gaWYgYW4gZXJyb3Igb2NjdXJzIHRlc3RpbmcgdGhlIGxvY2F0aW9uIFVSSSBmb3IgYSBxdWVyeSBwYXJ0LgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldFdTRExMb2NhdGlvbihEZWZpbml0aW9uIGRlZmluaXRpb24pIHRocm93cyBNYWxmb3JtZWRVUkxFeGNlcHRpb24gewogCQlFeHRlbnNpYmlsaXR5RWxlbWVudCBleHRlbnNpYmlsaXR5RWxlbWVudCA9IFdTRExVdGlscy5nZXRFbmRwb2ludEFkZHJlc3MoZGVmaW5pdGlvbik7CiAJCWlmIChleHRlbnNpYmlsaXR5RWxlbWVudCAhPSBudWxsKSB7CkBAIC0yMDYsNyArMjQ1LDcgQEAKIAkJfQogCSAgICByZXR1cm4gbnVsbDsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIHN0YXRpYyBTdHJpbmcgZ2V0TG9jYXRpb25VUkkoRXh0ZW5zaWJpbGl0eUVsZW1lbnQgZXh0ZW5zaWJpbGl0eUVsZW1lbnQpIHsKIAkgICAgaWYgKGV4dGVuc2liaWxpdHlFbGVtZW50IGluc3RhbmNlb2YgU09BUEFkZHJlc3MpIHsKICAgICAgICAgICAgIHJldHVybiAoKFNPQVBBZGRyZXNzKSBleHRlbnNpYmlsaXR5RWxlbWVudCkuZ2V0TG9jYXRpb25VUkkoKTsKQEAgLTIxNiw3ICsyNTUsMTQgQEAKICAgICAgICAgfQogCQlyZXR1cm4gIiI7IC8vJE5PTi1OTFMtMSQKICAgICB9Ci0gICAgCisKKyAgICAvKioKKyAgICAgKiBDb25zdHJ1Y3RzIGEgZG90IHNlcGFyYXRlZCBwYWNrYWdlIG5hbWUgZnJvbSBhIGdpdmVuIG5hbWVzcGFjZS4KKyAgICAgKiA8cD5FLmcuLCB0aGUgbmFtZXNwYWNlINJodHRwOi8vd3MuZXhhbXBsZS5jb20v0yB3b3VsZCByZXR1cm4gdGhlIEphdmEgcGFja2FnZSBuYW1lINJjb20uZXhhbXBsZS53c9MuPC9wPgorICAgICAqIDxwPk4uQi4gVGhpcyBtZXRob2QgZG9lcyBub3QgcHJlc2VydmUgJ3d3dycgaW4gdGhlIHJldHVybmVkIHBhY2thZ2UgbmFtZSBpZiBpdCBleGlzdHMgaW4gdGhlIGdpdmVuIG5hbWVzcGFjZS48L3A+CisgICAgICogQHBhcmFtIG5hbWVzcGFjZSB0aGUgZ2l2ZW4gbmFtZS4KKyAgICAgKiBAcmV0dXJuIGEgcGFja2FnZSBuYW1lLgorICAgICAqLwogICAgIHB1YmxpYyBzdGF0aWMgU3RyaW5nIGdldFBhY2thZ2VOYW1lRnJvbU5hbWVzcGFjZShTdHJpbmcgbmFtZXNwYWNlKSB7CiAgICAgICAgIFN0cmluZyBwYWNrYWdlTmFtZSA9ICIiOyAvLyROT04tTkxTLTEkCiAgICAgICAgIHRyeSB7CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2NvbnRlbnRhc3Npc3QvQW5ub3RhdGlvbkNvbXBsZXRpb25Qcm9wb3NhbENvbXB1dGVyLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2NvbnRlbnRhc3Npc3QvQW5ub3RhdGlvbkNvbXBsZXRpb25Qcm9wb3NhbENvbXB1dGVyLmphdmEKaW5kZXggOTI5ZTA0Yy4uZmQ0M2Q1YSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9jb250ZW50YXNzaXN0L0Fubm90YXRpb25Db21wbGV0aW9uUHJvcG9zYWxDb21wdXRlci5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvY29udGVudGFzc2lzdC9Bbm5vdGF0aW9uQ29tcGxldGlvblByb3Bvc2FsQ29tcHV0ZXIuamF2YQpAQCAtMjAsMTIgKzIwLDExIEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUxvY2FsVmFyaWFibGU7DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklNZXRob2Q7DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLkphdmFNb2RlbEV4Y2VwdGlvbjsNCi1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkNvbXBpbGF0aW9uVW5pdDsNCitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb247DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5FeHByZXNzaW9uOw0KLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uSUV4dGVuZGVkTW9kaWZpZXI7DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5NZW1iZXJWYWx1ZVBhaXI7DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Ob3JtYWxBbm5vdGF0aW9uOw0KLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQudWkuU2hhcmVkQVNUUHJvdmlkZXI7DQoraW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5TaW5nbGVNZW1iZXJBbm5vdGF0aW9uOw0KIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQudWkudGV4dC5qYXZhLkNvbnRlbnRBc3Npc3RJbnZvY2F0aW9uQ29udGV4dDsNCiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LnVpLnRleHQuamF2YS5JSmF2YUNvbXBsZXRpb25Qcm9wb3NhbENvbXB1dGVyOw0KIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQudWkudGV4dC5qYXZhLkphdmFDb250ZW50QXNzaXN0SW52b2NhdGlvbkNvbnRleHQ7DQpAQCAtMzcsNzEgKzM2LDcyIEBACiANCiBwdWJsaWMgY2xhc3MgQW5ub3RhdGlvbkNvbXBsZXRpb25Qcm9wb3NhbENvbXB1dGVyIGltcGxlbWVudHMgSUphdmFDb21wbGV0aW9uUHJvcG9zYWxDb21wdXRlciB7DQogDQotCXB1YmxpYyBBbm5vdGF0aW9uQ29tcGxldGlvblByb3Bvc2FsQ29tcHV0ZXIoKSB7DQotCQlzdXBlcigpOw0KLQl9DQorICAgIHB1YmxpYyBBbm5vdGF0aW9uQ29tcGxldGlvblByb3Bvc2FsQ29tcHV0ZXIoKSB7DQorICAgICAgICBzdXBlcigpOw0KKyAgICB9DQogDQotCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQ0KLQlwdWJsaWMgTGlzdCBjb21wdXRlQ29tcGxldGlvblByb3Bvc2FscyhDb250ZW50QXNzaXN0SW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSB7DQotCSAgICBpZiAoY29udGV4dCBpbnN0YW5jZW9mIEphdmFDb250ZW50QXNzaXN0SW52b2NhdGlvbkNvbnRleHQpIHsNCi0JICAgICAgICByZXR1cm4gY29tcHV0ZUNvbXBsZXRpb25Qcm9wb3NhbHMoKEphdmFDb250ZW50QXNzaXN0SW52b2NhdGlvbkNvbnRleHQpIGNvbnRleHQpOw0KLQkgICAgfQ0KLSAJICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsNCi0JfQ0KKyAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikNCisgICAgcHVibGljIExpc3QgY29tcHV0ZUNvbXBsZXRpb25Qcm9wb3NhbHMoQ29udGVudEFzc2lzdEludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgew0KKyAgICAgICAgaWYgKGNvbnRleHQgaW5zdGFuY2VvZiBKYXZhQ29udGVudEFzc2lzdEludm9jYXRpb25Db250ZXh0KSB7DQorICAgICAgICAgICAgcmV0dXJuIGNvbXB1dGVDb21wbGV0aW9uUHJvcG9zYWxzKChKYXZhQ29udGVudEFzc2lzdEludm9jYXRpb25Db250ZXh0KSBjb250ZXh0KTsNCisgICAgICAgIH0NCisgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsNCisgICAgfQ0KIA0KLQlwcml2YXRlIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gY29tcHV0ZUNvbXBsZXRpb25Qcm9wb3NhbHMoSmF2YUNvbnRlbnRBc3Npc3RJbnZvY2F0aW9uQ29udGV4dCBjb250ZXh0KSB7DQorICAgIHByaXZhdGUgTGlzdDxJQ29tcGxldGlvblByb3Bvc2FsPiBjb21wdXRlQ29tcGxldGlvblByb3Bvc2FscyhKYXZhQ29udGVudEFzc2lzdEludm9jYXRpb25Db250ZXh0IGNvbnRleHQpIHsNCiAgICAgICAgIENvbXBsZXRpb25Db250ZXh0IGNvbXBsZXRpb25Db250ZXh0ID0gY29udGV4dC5nZXRDb3JlQ29udGV4dCgpOw0KICAgICAgICAgaW50IHRva2VuU3RhcnQgPSBjb21wbGV0aW9uQ29udGV4dC5nZXRPZmZzZXQoKTsNCi0JICAgIA0KLQkgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSBjb250ZXh0LmdldENvbXBpbGF0aW9uVW5pdCgpOw0KLQkJdHJ5IHsNCi0JCQlJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQgPSBzb3VyY2UuZ2V0RWxlbWVudEF0KHRva2VuU3RhcnQpOw0KLQkJCWlmIChqYXZhRWxlbWVudCAhPSBudWxsKSB7DQotCQkgICAgICAgIA0KLQkJCSAgICBDb21waWxhdGlvblVuaXQgY29tcGlsYXRpb25Vbml0ID0gU2hhcmVkQVNUUHJvdmlkZXIuZ2V0QVNUKHNvdXJjZSwgU2hhcmVkQVNUUHJvdmlkZXIuV0FJVF9ZRVMsIG51bGwpOw0KLQkJCSAgICANCi0JCQkgICAgc3dpdGNoKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkpIHsNCi0JCQkgICAgY2FzZSBJSmF2YUVsZW1lbnQuUEFDS0FHRV9ERUNMQVJBVElPTjoNCi0JCQkgICAgY2FzZSBJSmF2YUVsZW1lbnQuVFlQRToNCi0JCQkgICAgY2FzZSBJSmF2YUVsZW1lbnQuRklFTEQ6DQotCQkJICAgICAgICByZXR1cm4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvckphdmFFbGVtZW50KEFubm90YXRpb25VdGlscy5nZXRFeHRlbmRlZE1vZGlmaWVycygNCi0JCQkgICAgICAgICAgICAgICAgY29tcGlsYXRpb25Vbml0LCBqYXZhRWxlbWVudCksIGphdmFFbGVtZW50LCB0b2tlblN0YXJ0KTsNCi0JCQkgICAgY2FzZSBJSmF2YUVsZW1lbnQuTUVUSE9EOg0KLQkJCSAgICAJSUxvY2FsVmFyaWFibGUgbG9jYWxWYXJpYWJsZSA9IEFubm90YXRpb25VdGlscy5nZXRMb2NhbFZhcmlhYmxlKChJTWV0aG9kKSBqYXZhRWxlbWVudCwgdG9rZW5TdGFydCk7DQotCQkJICAgIAlpZiAobG9jYWxWYXJpYWJsZSAhPSBudWxsKSB7DQotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGdldENvbXBsZXRpb25Qcm9wb3NhbHNGb3JKYXZhRWxlbWVudChBbm5vdGF0aW9uVXRpbHMuZ2V0RXh0ZW5kZWRNb2RpZmllcnMoDQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb21waWxhdGlvblVuaXQsIGxvY2FsVmFyaWFibGUpLCBsb2NhbFZhcmlhYmxlLCB0b2tlblN0YXJ0KTsNCi0JCQkgICAgCX0gIGVsc2Ugew0KLSAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBnZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9ySmF2YUVsZW1lbnQoQW5ub3RhdGlvblV0aWxzLmdldEV4dGVuZGVkTW9kaWZpZXJzKA0KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29tcGlsYXRpb25Vbml0LCBqYXZhRWxlbWVudCksIGphdmFFbGVtZW50LCB0b2tlblN0YXJ0KTsNCisNCisgICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gY29udGV4dC5nZXRDb21waWxhdGlvblVuaXQoKTsNCisgICAgICAgIHRyeSB7DQorICAgICAgICAgICAgSUphdmFFbGVtZW50IGphdmFFbGVtZW50ID0gc291cmNlLmdldEVsZW1lbnRBdCh0b2tlblN0YXJ0KTsNCisgICAgICAgICAgICBpZiAoamF2YUVsZW1lbnQgIT0gbnVsbCkgew0KKyAgICAgICAgICAgICAgICBzd2l0Y2goamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSkgew0KKyAgICAgICAgICAgICAgICBjYXNlIElKYXZhRWxlbWVudC5QQUNLQUdFX0RFQ0xBUkFUSU9OOg0KKyAgICAgICAgICAgICAgICBjYXNlIElKYXZhRWxlbWVudC5UWVBFOg0KKyAgICAgICAgICAgICAgICBjYXNlIElKYXZhRWxlbWVudC5GSUVMRDoNCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBnZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9ySmF2YUVsZW1lbnQoQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25zKA0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBqYXZhRWxlbWVudCksIGphdmFFbGVtZW50LCB0b2tlblN0YXJ0KTsNCisgICAgICAgICAgICAgICAgY2FzZSBJSmF2YUVsZW1lbnQuTUVUSE9EOg0KKyAgICAgICAgICAgICAgICAgICAgSUxvY2FsVmFyaWFibGUgbG9jYWxWYXJpYWJsZSA9IEFubm90YXRpb25VdGlscy5nZXRMb2NhbFZhcmlhYmxlKChJTWV0aG9kKSBqYXZhRWxlbWVudCwgdG9rZW5TdGFydCk7DQorICAgICAgICAgICAgICAgICAgICBpZiAobG9jYWxWYXJpYWJsZSAhPSBudWxsKSB7DQorICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGdldENvbXBsZXRpb25Qcm9wb3NhbHNGb3JKYXZhRWxlbWVudChBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbnMoDQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsb2NhbFZhcmlhYmxlKSwgbG9jYWxWYXJpYWJsZSwgdG9rZW5TdGFydCk7DQorICAgICAgICAgICAgICAgICAgICB9ICBlbHNlIHsNCisgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvckphdmFFbGVtZW50KEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9ucygNCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGphdmFFbGVtZW50KSwgamF2YUVsZW1lbnQsIHRva2VuU3RhcnQpOw0KICAgICAgICAgICAgICAgICAgICAgfQ0KLQkJCSAgICB9DQotCQkJfQ0KLQkJfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgew0KLQkJICAgIEpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7DQotCQl9DQotCQlyZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7DQotCX0NCi0JDQotCXByaXZhdGUgTGlzdDxJQ29tcGxldGlvblByb3Bvc2FsPiBnZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9ySmF2YUVsZW1lbnQoTGlzdDxJRXh0ZW5kZWRNb2RpZmllcj4gbW9kaWZpZXJzLA0KLQkgICAgICAgIElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwgaW50IG9mZnNldCkgew0KLSAgICAgICAgZm9yIChJRXh0ZW5kZWRNb2RpZmllciBleHRlbmRlZE1vZGlmaWVyIDogbW9kaWZpZXJzKSB7DQotICAgICAgICAgICAgaWYgKGV4dGVuZGVkTW9kaWZpZXIuaXNBbm5vdGF0aW9uKCkgJiYgZXh0ZW5kZWRNb2RpZmllciBpbnN0YW5jZW9mIE5vcm1hbEFubm90YXRpb24pIHsNCi0gICAgICAgICAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiBub3JtYWxBbm5vdGF0aW9uID0gKE5vcm1hbEFubm90YXRpb24pIGV4dGVuZGVkTW9kaWZpZXI7DQorICAgICAgICAgICAgICAgIH0NCisgICAgICAgICAgICB9DQorICAgICAgICB9IGNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gam1lKSB7DQorICAgICAgICAgICAgSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsNCisgICAgICAgIH0NCisgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsNCisgICAgfQ0KKw0KKyAgICBwcml2YXRlIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvckphdmFFbGVtZW50KExpc3Q8QW5ub3RhdGlvbj4gYW5ub3RhdGlvbnMsDQorICAgICAgICAgICAgSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBpbnQgb2Zmc2V0KSB7DQorICAgICAgICBmb3IgKEFubm90YXRpb24gYW5ub3RhdGlvbiA6IGFubm90YXRpb25zKSB7DQorICAgICAgICAgICAgaWYgKGFubm90YXRpb24gaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKSB7DQorICAgICAgICAgICAgICAgIE5vcm1hbEFubm90YXRpb24gbm9ybWFsQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSBhbm5vdGF0aW9uOw0KICAgICAgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyID0gZ2V0TWVtYmVyVmFsdWVQYWlyRm9yUG9zaXRpb24obm9ybWFsQW5ub3RhdGlvbiwgb2Zmc2V0KTsNCiAgICAgICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpciAhPSBudWxsKSB7DQotICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvckphdmFFbGVtZW50KG5vcm1hbEFubm90YXRpb24sIG1lbWJlclZhbHVlUGFpciwgDQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvckphdmFFbGVtZW50KG5vcm1hbEFubm90YXRpb24sIG1lbWJlclZhbHVlUGFpciwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgamF2YUVsZW1lbnQpOw0KICAgICAgICAgICAgICAgICB9DQogICAgICAgICAgICAgfQ0KKyAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uIGluc3RhbmNlb2YgU2luZ2xlTWVtYmVyQW5ub3RhdGlvbikgew0KKyAgICAgICAgICAgICAgICBTaW5nbGVNZW1iZXJBbm5vdGF0aW9uIHNpbmdsZU1lbWJlckFubm90YXRpb24gPSAoU2luZ2xlTWVtYmVyQW5ub3RhdGlvbikgYW5ub3RhdGlvbjsNCisgICAgICAgICAgICAgICAgcmV0dXJuIGdldENvbXBsZXRpb25Qcm9wb3NhbHNGb3JKYXZhRWxlbWVudChzaW5nbGVNZW1iZXJBbm5vdGF0aW9uLCBqYXZhRWxlbWVudCk7DQorICAgICAgICAgICAgfQ0KICAgICAgICAgfQ0KICAgICAgICAgcmV0dXJuIENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOw0KICAgICB9DQotCQ0KLQlwcml2YXRlIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvckphdmFFbGVtZW50KE5vcm1hbEFubm90YXRpb24gbm9ybWFsQW5ub3RhdGlvbiwNCi0JICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyLCBJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQpIHsNCisNCisgICAgcHJpdmF0ZSBMaXN0PElDb21wbGV0aW9uUHJvcG9zYWw+IGdldENvbXBsZXRpb25Qcm9wb3NhbHNGb3JKYXZhRWxlbWVudChOb3JtYWxBbm5vdGF0aW9uIGFubm90YXRpb24sDQorICAgICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIG1lbWJlclZhbHVlUGFpciwgSUphdmFFbGVtZW50IGphdmFFbGVtZW50KSB7DQogICAgICAgICBJQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciA9IEFubm90YXRpb25zTWFuYWdlcg0KLSAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyRm9yTmFtZShub3JtYWxBbm5vdGF0aW9uLmdldFR5cGVOYW1lKCkpOw0KKyAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyRm9yTmFtZShhbm5vdGF0aW9uLmdldFR5cGVOYW1lKCkpOw0KICAgICAgICAgaWYgKGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciAhPSBudWxsKSB7DQogICAgICAgICAgICAgcmV0dXJuIGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplci5nZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9yTWVtYmVyVmFsdWVQYWlyKGphdmFFbGVtZW50LA0KICAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlyKTsNCkBAIC0xMDksOCArMTA5LDIwIEBACiAgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsNCiAgICAgfQ0KIA0KLQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikNCi0JcHJpdmF0ZSBNZW1iZXJWYWx1ZVBhaXIgZ2V0TWVtYmVyVmFsdWVQYWlyRm9yUG9zaXRpb24oTm9ybWFsQW5ub3RhdGlvbiBub3JtYWxBbm5vdGF0aW9uLCBpbnQgb2Zmc2V0KSB7DQorICAgIHByaXZhdGUgTGlzdDxJQ29tcGxldGlvblByb3Bvc2FsPiBnZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9ySmF2YUVsZW1lbnQoU2luZ2xlTWVtYmVyQW5ub3RhdGlvbiBhbm5vdGF0aW9uLA0KKyAgICAgICAgICAgIElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCkgew0KKyAgICAgICAgSUFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciBhbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgPSBBbm5vdGF0aW9uc01hbmFnZXINCisgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplckZvck5hbWUoYW5ub3RhdGlvbi5nZXRUeXBlTmFtZSgpKTsNCisgICAgICAgIGlmIChhbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgIT0gbnVsbCkgew0KKyAgICAgICAgICAgIHJldHVybiBhbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIuZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0ZvclNpbmdsZU1lbWJlckFubm90YXRpb24oamF2YUVsZW1lbnQsDQorICAgICAgICAgICAgICAgICAgICBhbm5vdGF0aW9uKTsNCisgICAgICAgIH0NCisgICAgICAgIHJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsNCisgICAgfQ0KKw0KKw0KKyAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikNCisgICAgcHJpdmF0ZSBNZW1iZXJWYWx1ZVBhaXIgZ2V0TWVtYmVyVmFsdWVQYWlyRm9yUG9zaXRpb24oTm9ybWFsQW5ub3RhdGlvbiBub3JtYWxBbm5vdGF0aW9uLCBpbnQgb2Zmc2V0KSB7DQogICAgICAgICBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycyA9IG5vcm1hbEFubm90YXRpb24udmFsdWVzKCk7DQogICAgICAgICBmb3IgKE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIgOiBtZW1iZXJWYWx1ZVBhaXJzKSB7DQogICAgICAgICAgICAgRXhwcmVzc2lvbiB2YWx1ZSA9IG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpOw0KQEAgLTEyMiwyMSArMTM0LDIwIEBACiAgICAgICAgICAgICB9DQogICAgICAgICB9DQogICAgICAgICByZXR1cm4gbnVsbDsNCi0JfQ0KLQkNCi0JQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpDQotCXB1YmxpYyBMaXN0IGNvbXB1dGVDb250ZXh0SW5mb3JtYXRpb24oQ29udGVudEFzc2lzdEludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgew0KLQkJcmV0dXJuIENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOw0KLQl9DQorICAgIH0NCiANCi0JcHVibGljIFN0cmluZyBnZXRFcnJvck1lc3NhZ2UoKSB7DQotCQlyZXR1cm4gbnVsbDsNCi0JfQ0KKyAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikNCisgICAgcHVibGljIExpc3QgY29tcHV0ZUNvbnRleHRJbmZvcm1hdGlvbihDb250ZW50QXNzaXN0SW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSB7DQorICAgICAgICByZXR1cm4gQ29sbGVjdGlvbnMuZW1wdHlMaXN0KCk7DQorICAgIH0NCiANCi0JcHVibGljIHZvaWQgc2Vzc2lvbkVuZGVkKCkgew0KLQl9DQorICAgIHB1YmxpYyBTdHJpbmcgZ2V0RXJyb3JNZXNzYWdlKCkgew0KKyAgICAgICAgcmV0dXJuIG51bGw7DQorICAgIH0NCiANCi0JcHVibGljIHZvaWQgc2Vzc2lvblN0YXJ0ZWQoKSB7DQotCX0NCisgICAgcHVibGljIHZvaWQgc2Vzc2lvbkVuZGVkKCkgew0KKyAgICB9DQogDQorICAgIHB1YmxpYyB2b2lkIHNlc3Npb25TdGFydGVkKCkgew0KKyAgICB9DQogfQ0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvY29ycmVjdGlvbi9KQVhXU1F1aWNrRml4UHJvY2Vzc29yLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2NvcnJlY3Rpb24vSkFYV1NRdWlja0ZpeFByb2Nlc3Nvci5qYXZhCmluZGV4IDAzZTcwMzguLjQxYzczMDEgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvY29ycmVjdGlvbi9KQVhXU1F1aWNrRml4UHJvY2Vzc29yLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9jb3JyZWN0aW9uL0pBWFdTUXVpY2tGaXhQcm9jZXNzb3IuamF2YQpAQCAtODQsMTMgKzg0LDEzIEBACiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICB9Ci0gICAgICAgIAotICAgICAgICByZXR1cm4gKElKYXZhQ29tcGxldGlvblByb3Bvc2FsW10pIHByb3Bvc2Fscy50b0FycmF5KG5ldyBJSmF2YUNvbXBsZXRpb25Qcm9wb3NhbFtwcm9wb3NhbHMuc2l6ZSgpXSk7CisKKyAgICAgICAgcmV0dXJuIHByb3Bvc2Fscy50b0FycmF5KG5ldyBJSmF2YUNvbXBsZXRpb25Qcm9wb3NhbFtwcm9wb3NhbHMuc2l6ZSgpXSk7CiAgICAgfQogCi0gICAgcHJpdmF0ZSB2b2lkIHByb2Nlc3MoSUludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIElQcm9ibGVtTG9jYXRpb24gcHJvYmxlbUxvY2F0aW9uLCAKKyAgICBwcml2YXRlIHZvaWQgcHJvY2VzcyhJSW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2JsZW1Mb2NhdGlvbiBwcm9ibGVtTG9jYXRpb24sCiAgICAgICAgICAgICBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKLSAgICAgICAgCisKICAgICAgICAgU3RyaW5nIHByb2JsZW0gPSBwcm9ibGVtTG9jYXRpb24uZ2V0UHJvYmxlbUFyZ3VtZW50cygpWzFdOwogCiAgICAgICAgIGlmIChwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJTRVJWSUNFX0VOUE9JTlRJTlRFUkZBQ0VfTVVTVF9JTVBMRU1FTlQpKSB7CkBAIC0xMDgsNyArMTA4LDcgQEAKICAgICAgICAgICAgICAgICB8fCBwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJNRVRIT0RfRVhDTFVERV9OT1RfQUxMT1dFRF9PTl9TRUkpKSB7CiAgICAgICAgICAgICBhZGRSZW1vdmVNZW1iZXJWYWx1ZVBhaXJQcm9wb3NhbChjb250ZXh0LCBwcm9ibGVtTG9jYXRpb24sIHByb3Bvc2FscywgZmFsc2UpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJNRVRIT0RfRVhDTFVERV9TUEVDSUZJRURfTk9fT1RIRVJfQVRUUklCVVRFU19BTExPV0VEKSkgewogICAgICAgICAgICAgYWRkUmVtb3ZlTWVtYmVyVmFsdWVQYWlyUHJvcG9zYWwoY29udGV4dCwgcHJvYmxlbUxvY2F0aW9uLCBwcm9wb3NhbHMsIHRydWUpOwogICAgICAgICB9CkBAIC0xNDUsNyArMTQ1LDcgQEAKICAgICAgICAgaWYgKHByb2JsZW0uZXF1YWxzKEpBWFdTQ29yZU1lc3NhZ2VzLldFQlNFUlZJQ0VfV0VCU0VSVklDRVBST1ZJREVSX0NPTUJJTkFUSU9OKSkgewogICAgICAgICAgICAgYWRkUmVtb3ZlQW5ub3RhdGlvblByb3Bvc2FsKGNvbnRleHQsIHByb2JsZW1Mb2NhdGlvbiwgcHJvcG9zYWxzLCBXZWJTZXJ2aWNlUHJvdmlkZXIuY2xhc3MpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5IQU5ETEVSX0NIQUlOX1NPQVBfTUVTU0FHRV9IQU5ETEVSUykpIHsKICAgICAgICAgICAgIGFkZFJlbW92ZUFubm90YXRpb25Qcm9wb3NhbChjb250ZXh0LCBwcm9ibGVtTG9jYXRpb24sIHByb3Bvc2FscywgU09BUE1lc3NhZ2VIYW5kbGVycy5jbGFzcyk7CiAgICAgICAgIH0KQEAgLTE1Myw3ICsxNTMsNyBAQAogICAgICAgICBpZiAocHJvYmxlbS5lcXVhbHMoSkFYV1NDb3JlTWVzc2FnZXMuV0VCU0VSVklDRV9PVkVSUklERV9GSU5BTElaRSkpIHsKICAgICAgICAgICAgIGFkZFJlbW92ZU1ldGhvZFByb3Bvc2FsKGNvbnRleHQsIHByb2JsZW1Mb2NhdGlvbiwgcHJvcG9zYWxzKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAocHJvYmxlbS5lcXVhbHMoSkFYV1NDb3JlTWVzc2FnZXMuV0VCTUVUSE9EX09OTFlfT05fUFVCTElDX01FVEhPRFMpCiAgICAgICAgICAgICAgICAgfHwgcHJvYmxlbS5lcXVhbHMoSkFYV1NDb3JlTWVzc2FnZXMuV0VCTUVUSE9EX05PX1NUQVRJQ19NT0RJRklFUl9BTExPV0VEKQogICAgICAgICAgICAgICAgIHx8IHByb2JsZW0uZXF1YWxzKEpBWFdTQ29yZU1lc3NhZ2VzLldFQk1FVEhPRF9OT19GSU5BTF9NT0RJRklFUl9BTExPV0VEKSkgewpAQCAtMTY2LDI1ICsxNjYsMjUgQEAKICAgICAgICAgfQogCiAgICAgICAgIGlmIChwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJTRVJWSUNFX0VOUE9JTlRJTlRFUkZBQ0VfSU5DT01QQVRJQkxFX1JFVFVSTl9UWVBFKSkgewotICAgICAgICAJYWRkQ2hhbmdlUmV0dXJuVHlwZVByb3Bvc2FsKGNvbnRleHQsIHByb2JsZW1Mb2NhdGlvbiwgcHJvcG9zYWxzKTsKKyAgICAgICAgICAgIGFkZENoYW5nZVJldHVyblR5cGVQcm9wb3NhbChjb250ZXh0LCBwcm9ibGVtTG9jYXRpb24sIHByb3Bvc2Fscyk7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBwcml2YXRlIHZvaWQgYWRkQW5ub3RhdGlvblRvVHlwZVByb3Bvc2FsKElJbnZvY2F0aW9uQ29udGV4dCBjb250ZXh0LCBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMsIAorICAgIHByaXZhdGUgdm9pZCBhZGRBbm5vdGF0aW9uVG9UeXBlUHJvcG9zYWwoSUludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIExpc3Q8SUphdmFDb21wbGV0aW9uUHJvcG9zYWw+IHByb3Bvc2FscywKICAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MpIHsKLSAgICAgICAgCisKICAgICAgICAgU3RyaW5nIGRpc3BsYXlTdHJpbmcgPSBKQVhXU1VJTWVzc2FnZXMuYmluZChKQVhXU1VJTWVzc2FnZXMuQUREX0FOTk9UQVRJT04sIGFubm90YXRpb25DbGFzcy5nZXRTaW1wbGVOYW1lKCkpOwogICAgICAgICBJbWFnZSBpbWFnZSA9IEphdmFQbHVnaW5JbWFnZXMuZ2V0KEphdmFQbHVnaW5JbWFnZXMuSU1HX0NPUlJFQ1RJT05fQ0hBTkdFKTsKICAgICAgICAgcHJvcG9zYWxzLmFkZChuZXcgQWRkQW5ub3RhdGlvblRvVHlwZUNvcnJlY3Rpb25Qcm9wb3NhbChjb250ZXh0LCBhbm5vdGF0aW9uQ2xhc3MsIGRpc3BsYXlTdHJpbmcsIDUsIGltYWdlKSk7CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSB2b2lkIGFkZFJlbW92ZU1ldGhvZFByb3Bvc2FsKElJbnZvY2F0aW9uQ29udGV4dCBjb250ZXh0LCBJUHJvYmxlbUxvY2F0aW9uIHByb2JsZW1Mb2NhdGlvbiwKICAgICAgICAgICAgIExpc3Q8SUphdmFDb21wbGV0aW9uUHJvcG9zYWw+IHByb3Bvc2FscykgewotICAgICAgICAKKwogICAgICAgICBBU1ROb2RlIHNlbGVjdGVkTm9kZSA9IHByb2JsZW1Mb2NhdGlvbi5nZXRDb3ZlcmluZ05vZGUoY29udGV4dC5nZXRBU1RSb290KCkpOwogCiAgICAgICAgIGlmIChzZWxlY3RlZE5vZGUuZ2V0UGFyZW50KCkgaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKSB7Ci0gICAgICAgICAgICBOb3JtYWxBbm5vdGF0aW9uIG5vcm1hbEFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgc2VsZWN0ZWROb2RlLmdldFBhcmVudCgpOyAKKyAgICAgICAgICAgIE5vcm1hbEFubm90YXRpb24gbm9ybWFsQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSBzZWxlY3RlZE5vZGUuZ2V0UGFyZW50KCk7CiAgICAgICAgICAgICBBU1ROb2RlIHBhcmVudE5vZGUgPSBub3JtYWxBbm5vdGF0aW9uLmdldFBhcmVudCgpOwogICAgICAgICAgICAgaWYgKHBhcmVudE5vZGUgaW5zdGFuY2VvZiBNZXRob2REZWNsYXJhdGlvbikgewogICAgICAgICAgICAgICAgIHNlbGVjdGVkTm9kZSA9ICgoTWV0aG9kRGVjbGFyYXRpb24pIHBhcmVudE5vZGUpLmdldE5hbWUoKTsKQEAgLTE5NCw3ICsxOTQsNyBAQAogICAgICAgICAgICAgICAgIHNlbGVjdGVkTm9kZSA9ICgoTWV0aG9kRGVjbGFyYXRpb24pIHNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24uZ2V0UGFyZW50KCkpLmdldE5hbWUoKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAoc2VsZWN0ZWROb2RlIGluc3RhbmNlb2YgU2ltcGxlTmFtZSkgewogICAgICAgICAgICAgU2ltcGxlTmFtZSBtZXRob2ROYW1lID0gKFNpbXBsZU5hbWUpIHNlbGVjdGVkTm9kZTsKICAgICAgICAgICAgIFN0cmluZyBkaXNwbGF5U3RyaW5nID0gSkFYV1NVSU1lc3NhZ2VzLmJpbmQoSkFYV1NVSU1lc3NhZ2VzLlJFTU9WRV9NRVRIT0QsIG1ldGhvZE5hbWUuZ2V0SWRlbnRpZmllcigpKTsKQEAgLTIwNCwyMyArMjA0LDIzIEBACiAgICAgICAgIH0KICAgICB9CiAKLSAgICBwcml2YXRlIHZvaWQgYWRkUmVtb3ZlQW5ub3RhdGlvblByb3Bvc2FsKElJbnZvY2F0aW9uQ29udGV4dCBjb250ZXh0LCBJUHJvYmxlbUxvY2F0aW9uIHByb2JsZW1Mb2NhdGlvbiwgCisgICAgcHJpdmF0ZSB2b2lkIGFkZFJlbW92ZUFubm90YXRpb25Qcm9wb3NhbChJSW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2JsZW1Mb2NhdGlvbiBwcm9ibGVtTG9jYXRpb24sCiAgICAgICAgICAgICBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMsIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uKSB7Ci0JCQorCiAgICAgICAgIEFTVE5vZGUgY292ZXJpbmdOb2RlID0gcHJvYmxlbUxvY2F0aW9uLmdldENvdmVyaW5nTm9kZShjb250ZXh0LmdldEFTVFJvb3QoKSk7CiAgICAgICAgIEFTVE5vZGUgcGFyZW50Tm9kZSA9IGNvdmVyaW5nTm9kZS5nZXRQYXJlbnQoKTsKLSAgICAgICAgCi0JCVN0cmluZyBkaXNwbGF5U3RyaW5nID0gSkFYV1NVSU1lc3NhZ2VzLmJpbmQoSkFYV1NVSU1lc3NhZ2VzLlJFTU9WRV9BTk5PVEFUSU9OLCBhbm5vdGF0aW9uLmdldFNpbXBsZU5hbWUoKSk7CisKKyAgICAgICAgU3RyaW5nIGRpc3BsYXlTdHJpbmcgPSBKQVhXU1VJTWVzc2FnZXMuYmluZChKQVhXU1VJTWVzc2FnZXMuUkVNT1ZFX0FOTk9UQVRJT04sIGFubm90YXRpb24uZ2V0U2ltcGxlTmFtZSgpKTsKICAgICAgICAgSW1hZ2UgaW1hZ2UgPSBQbGF0Zm9ybVVJLmdldFdvcmtiZW5jaCgpLmdldFNoYXJlZEltYWdlcygpLmdldEltYWdlKElTaGFyZWRJbWFnZXMuSU1HX1RPT0xfREVMRVRFKTsKICAgICAgICAgcHJvcG9zYWxzLmFkZChuZXcgUmVtb3ZlQW5ub3RhdGlvbkNvcnJlY3Rpb25Qcm9wb3NhbChjb250ZXh0LCBhbm5vdGF0aW9uLCBwYXJlbnROb2RlLCBkaXNwbGF5U3RyaW5nLCA1LCBpbWFnZSkpOwogICAgIH0KIAotCXByaXZhdGUgdm9pZCBhZGRSZW1vdmVNZW1iZXJWYWx1ZVBhaXJQcm9wb3NhbChJSW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2JsZW1Mb2NhdGlvbiBwcm9ibGVtTG9jYXRpb24sCi0JICAgICAgICBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMsIGJvb2xlYW4gcmVtb3ZlQWxsT3RoZXJNVlBzKSB7Ci0JICAgIAotCQlBU1ROb2RlIGNvdmVyaW5nTm9kZSA9IHByb2JsZW1Mb2NhdGlvbi5nZXRDb3ZlcmluZ05vZGUoY29udGV4dC5nZXRBU1RSb290KCkpOwotCQkKLQkJaWYgKGNvdmVyaW5nTm9kZS5nZXRQYXJlbnQoKSBpbnN0YW5jZW9mIE1lbWJlclZhbHVlUGFpcikgeworICAgIHByaXZhdGUgdm9pZCBhZGRSZW1vdmVNZW1iZXJWYWx1ZVBhaXJQcm9wb3NhbChJSW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2JsZW1Mb2NhdGlvbiBwcm9ibGVtTG9jYXRpb24sCisgICAgICAgICAgICBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMsIGJvb2xlYW4gcmVtb3ZlQWxsT3RoZXJNVlBzKSB7CisKKyAgICAgICAgQVNUTm9kZSBjb3ZlcmluZ05vZGUgPSBwcm9ibGVtTG9jYXRpb24uZ2V0Q292ZXJpbmdOb2RlKGNvbnRleHQuZ2V0QVNUUm9vdCgpKTsKKworICAgICAgICBpZiAoY292ZXJpbmdOb2RlLmdldFBhcmVudCgpIGluc3RhbmNlb2YgTWVtYmVyVmFsdWVQYWlyKSB7CiAgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyID0gKE1lbWJlclZhbHVlUGFpcikgY292ZXJpbmdOb2RlLmdldFBhcmVudCgpOwogICAgICAgICAgICAgU3RyaW5nIGRpc3BsYXlTdHJpbmcgPSBKQVhXU1VJTWVzc2FnZXMuYmluZChKQVhXU1VJTWVzc2FnZXMuUkVNT1ZFX01FTUJFUlZBTFVFUEFJUiwgbWVtYmVyVmFsdWVQYWlyCiAgICAgICAgICAgICAgICAgICAgIC50b1N0cmluZygpKTsKQEAgLTIzMSw4ICsyMzEsOCBAQAogICAgICAgICAgICAgSW1hZ2UgaW1hZ2UgPSBQbGF0Zm9ybVVJLmdldFdvcmtiZW5jaCgpLmdldFNoYXJlZEltYWdlcygpLmdldEltYWdlKElTaGFyZWRJbWFnZXMuSU1HX1RPT0xfREVMRVRFKTsKICAgICAgICAgICAgIHByb3Bvc2Fscy5hZGQobmV3IFJlbW92ZU1lbWJlclZhbHVlUGFpckNvcnJlY3Rpb25Qcm9wb3NhbChjb250ZXh0LCBtZW1iZXJWYWx1ZVBhaXIsCiAgICAgICAgICAgICAgICAgICAgIHJlbW92ZUFsbE90aGVyTVZQcywgZGlzcGxheVN0cmluZywgNSwgaW1hZ2UpKTsKLSAgICAgICAgfQkJCi0JfQorICAgICAgICB9CisgICAgfQogCiAgICAgcHJpdmF0ZSB2b2lkIGFkZFVuaW1wbGVtZW50ZWRNZXRob2RzUHJvcG9zYWwoSUludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIElQcm9ibGVtTG9jYXRpb24gcHJvYmxlbUxvY2F0aW9uLAogICAgICAgICAgICAgTGlzdDxJSmF2YUNvbXBsZXRpb25Qcm9wb3NhbD4gcHJvcG9zYWxzKSB7CkBAIC0yNDQsNjEgKzI0NCw2MSBAQAogICAgICAgICAgICAgQVNUTm9kZSB0eXBlRGVjbGFyYXRpb24gPSB3ZWJTZXJ2aWNlQW5ub3RhdGlvbi5nZXRQYXJlbnQoKTsKIAogICAgICAgICAgICAgU3RyaW5nIGVuZHBvaW50SW50ZXJmYWNlID0gKChTdHJpbmdMaXRlcmFsKSBlbmRwb2ludEludGVyZmFjZVZhbHVlKS5nZXRMaXRlcmFsVmFsdWUoKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBJbWFnZSBpbWFnZSA9IEphdmFQbHVnaW5JbWFnZXMuZ2V0KEphdmFQbHVnaW5JbWFnZXMuSU1HX0NPUlJFQ1RJT05fQ0hBTkdFKTsKICAgICAgICAgICAgIHByb3Bvc2Fscy5hZGQobmV3IEFkZFVuaW1wbGVtZW50ZWRNZXRob2RDb3JyZWN0aW9uUHJvcG9zYWwoY29udGV4dCwgdHlwZURlY2xhcmF0aW9uLCBlbmRwb2ludEludGVyZmFjZSwKICAgICAgICAgICAgICAgICAgICAgSkFYV1NVSU1lc3NhZ2VzLkFERF9VTklNUExFTUVOVEVEX01FVEhPRFMsIDUsIGltYWdlKSk7CiAgICAgICAgIH0KICAgICB9Ci0gICAgCi0JcHJpdmF0ZSB2b2lkIGFkZENoYW5nZU1vZGlmaWVyUHJvcG9zYWwoSUludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIElQcm9ibGVtTG9jYXRpb24gcHJvYmxlbUxvY2F0aW9uLAotCSAgICAgICAgTGlzdDxJSmF2YUNvbXBsZXRpb25Qcm9wb3NhbD4gcHJvcG9zYWxzLCBpbnQgcmVsZXZhbmNlKSB7Ci0JCQorCisgICAgcHJpdmF0ZSB2b2lkIGFkZENoYW5nZU1vZGlmaWVyUHJvcG9zYWwoSUludm9jYXRpb25Db250ZXh0IGNvbnRleHQsIElQcm9ibGVtTG9jYXRpb24gcHJvYmxlbUxvY2F0aW9uLAorICAgICAgICAgICAgTGlzdDxJSmF2YUNvbXBsZXRpb25Qcm9wb3NhbD4gcHJvcG9zYWxzLCBpbnQgcmVsZXZhbmNlKSB7CisKICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGFzdFJvb3QgPSBjb250ZXh0LmdldEFTVFJvb3QoKTsKICAgICAgICAgQVNUTm9kZSBzZWxlY3RlZE5vZGUgPSBwcm9ibGVtTG9jYXRpb24uZ2V0Q292ZXJpbmdOb2RlKGFzdFJvb3QpOwogCi0JCWlmICghKHNlbGVjdGVkTm9kZSBpbnN0YW5jZW9mIFNpbXBsZU5hbWUpKSB7Ci0JCQlyZXR1cm47Ci0JCX0KKyAgICAgICAgaWYgKCEoc2VsZWN0ZWROb2RlIGluc3RhbmNlb2YgU2ltcGxlTmFtZSkpIHsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQogCi0JCUlCaW5kaW5nIGJpbmRpbmcgPSAoKFNpbXBsZU5hbWUpIHNlbGVjdGVkTm9kZSkucmVzb2x2ZUJpbmRpbmcoKTsKLQkJaWYgKGJpbmRpbmcgIT0gbnVsbCkgewotCQkJU3RyaW5nIGJpbmRpbmdOYW1lID0gYmluZGluZy5nZXROYW1lKCk7Ci0JCQlTdHJpbmcgZGlzcGxheVN0cmluZyA9ICIiOwotCQkJCi0JCQlpbnQgZXhjbHVkZWRNb2RpZmllcnMgPSAwOwotCQkJaW50IGluY2x1ZGVkTW9kaWZpZXJzID0gMDsKLQkJCQotICAgICAgICAJU3RyaW5nIHByb2JsZW0gPSBwcm9ibGVtTG9jYXRpb24uZ2V0UHJvYmxlbUFyZ3VtZW50cygpWzFdOworICAgICAgICBJQmluZGluZyBiaW5kaW5nID0gKChTaW1wbGVOYW1lKSBzZWxlY3RlZE5vZGUpLnJlc29sdmVCaW5kaW5nKCk7CisgICAgICAgIGlmIChiaW5kaW5nICE9IG51bGwpIHsKKyAgICAgICAgICAgIFN0cmluZyBiaW5kaW5nTmFtZSA9IGJpbmRpbmcuZ2V0TmFtZSgpOworICAgICAgICAgICAgU3RyaW5nIGRpc3BsYXlTdHJpbmcgPSAiIjsKKworICAgICAgICAgICAgaW50IGV4Y2x1ZGVkTW9kaWZpZXJzID0gMDsKKyAgICAgICAgICAgIGludCBpbmNsdWRlZE1vZGlmaWVycyA9IDA7CisKKyAgICAgICAgICAgIFN0cmluZyBwcm9ibGVtID0gcHJvYmxlbUxvY2F0aW9uLmdldFByb2JsZW1Bcmd1bWVudHMoKVsxXTsKIAogICAgICAgICAgICAgaWYocHJvYmxlbS5lcXVhbHMoSkFYV1NDb3JlTWVzc2FnZXMuV0VCTUVUSE9EX09OTFlfT05fUFVCTElDX01FVEhPRFMpCi0gICAgICAgICAgICAJCXx8IHByb2JsZW0uZXF1YWxzKEpBWFdTQ29yZU1lc3NhZ2VzLldFQlNFUlZJQ0VfRU5QT0lOVElOVEVSRkFDRV9SRURVQ0VEX1ZJU0lCSUxJVFkpKSB7Ci0gICAgCQkJZXhjbHVkZWRNb2RpZmllcnMgPSB+KE1vZGlmaWVyLlBVQkxJQyk7Ci0gICAgCQkJaW5jbHVkZWRNb2RpZmllcnMgPSBNb2RpZmllci5QVUJMSUMgOwotICAgIAkJCWRpc3BsYXlTdHJpbmcgPSBKQVhXU1VJTWVzc2FnZXMuYmluZChKQVhXU1VJTWVzc2FnZXMuQ0hBTkdFX01FVEhPRF9WSVNJQklMSVRZLCAicHVibGljIik7IC8vJE5PTi1OTFMtMSQKKyAgICAgICAgICAgICAgICAgICAgfHwgcHJvYmxlbS5lcXVhbHMoSkFYV1NDb3JlTWVzc2FnZXMuV0VCU0VSVklDRV9FTlBPSU5USU5URVJGQUNFX1JFRFVDRURfVklTSUJJTElUWSkpIHsKKyAgICAgICAgICAgICAgICBleGNsdWRlZE1vZGlmaWVycyA9IH4oTW9kaWZpZXIuUFVCTElDKTsKKyAgICAgICAgICAgICAgICBpbmNsdWRlZE1vZGlmaWVycyA9IE1vZGlmaWVyLlBVQkxJQyA7CisgICAgICAgICAgICAgICAgZGlzcGxheVN0cmluZyA9IEpBWFdTVUlNZXNzYWdlcy5iaW5kKEpBWFdTVUlNZXNzYWdlcy5DSEFOR0VfTUVUSE9EX1ZJU0lCSUxJVFksICJwdWJsaWMiKTsgLy8kTk9OLU5MUy0xJAogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBpZihwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJNRVRIT0RfTk9fRklOQUxfTU9ESUZJRVJfQUxMT1dFRCkpIHsKLSAgICAgICAgICAgIAlleGNsdWRlZE1vZGlmaWVycyA9IE1vZGlmaWVyLkZJTkFMOwotICAgICAgICAgICAgCWRpc3BsYXlTdHJpbmcgPSBKQVhXU1VJTWVzc2FnZXMuYmluZChKQVhXU1VJTWVzc2FnZXMuUkVNT1ZFX0ZJTkFMX01PRElGSUVSLCBiaW5kaW5nTmFtZSk7CisgICAgICAgICAgICAgICAgZXhjbHVkZWRNb2RpZmllcnMgPSBNb2RpZmllci5GSU5BTDsKKyAgICAgICAgICAgICAgICBkaXNwbGF5U3RyaW5nID0gSkFYV1NVSU1lc3NhZ2VzLmJpbmQoSkFYV1NVSU1lc3NhZ2VzLlJFTU9WRV9GSU5BTF9NT0RJRklFUiwgYmluZGluZ05hbWUpOwogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICBpZihwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJNRVRIT0RfTk9fU1RBVElDX01PRElGSUVSX0FMTE9XRUQpKSB7Ci0gICAgICAgICAgICAJZXhjbHVkZWRNb2RpZmllcnMgPSBNb2RpZmllci5TVEFUSUM7Ci0gICAgICAgICAgICAJZGlzcGxheVN0cmluZyA9IEpBWFdTVUlNZXNzYWdlcy5iaW5kKEpBWFdTVUlNZXNzYWdlcy5SRU1PVkVfU1RBVElDX01PRElGSUVSLCBiaW5kaW5nTmFtZSk7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIGlmIChwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJTRVJWSUNFX1BVQkxJQ19BQlNUUkFDVF9GSU5BTCkpIHsKLSAgICAJCQlleGNsdWRlZE1vZGlmaWVycyA9IE1vZGlmaWVyLkFCU1RSQUNUIHwgTW9kaWZpZXIuRklOQUw7Ci0gICAgCQkJZGlzcGxheVN0cmluZyA9IEpBWFdTVUlNZXNzYWdlcy5SRU1PVkVfSUxMRUdBTF9NT0RJRklFUjsKKyAgICAgICAgICAgICAgICBleGNsdWRlZE1vZGlmaWVycyA9IE1vZGlmaWVyLlNUQVRJQzsKKyAgICAgICAgICAgICAgICBkaXNwbGF5U3RyaW5nID0gSkFYV1NVSU1lc3NhZ2VzLmJpbmQoSkFYV1NVSU1lc3NhZ2VzLlJFTU9WRV9TVEFUSUNfTU9ESUZJRVIsIGJpbmRpbmdOYW1lKTsKICAgICAgICAgICAgIH0KIAotCQkJSW1hZ2UgaW1hZ2UgPSBKYXZhUGx1Z2luSW1hZ2VzLmdldChKYXZhUGx1Z2luSW1hZ2VzLklNR19DT1JSRUNUSU9OX0NIQU5HRSk7Ci0JICAgICAgICBwcm9wb3NhbHMuYWRkKG5ldyBDaGFuZ2VNb2RpZmllckNvcnJlY3Rpb25Qcm9wb3NhbChjb250ZXh0LCBiaW5kaW5nLCBpbmNsdWRlZE1vZGlmaWVycywKLSAgICAgICAgICAgICAgICAgICAgZXhjbHVkZWRNb2RpZmllcnMsIGRpc3BsYXlTdHJpbmcsIDUsIGltYWdlKSk7ICAgICAgICAgICAKLQkJfQotCX0KLQkKKyAgICAgICAgICAgIGlmIChwcm9ibGVtLmVxdWFscyhKQVhXU0NvcmVNZXNzYWdlcy5XRUJTRVJWSUNFX1BVQkxJQ19BQlNUUkFDVF9GSU5BTCkpIHsKKyAgICAgICAgICAgICAgICBleGNsdWRlZE1vZGlmaWVycyA9IE1vZGlmaWVyLkFCU1RSQUNUIHwgTW9kaWZpZXIuRklOQUw7CisgICAgICAgICAgICAgICAgZGlzcGxheVN0cmluZyA9IEpBWFdTVUlNZXNzYWdlcy5SRU1PVkVfSUxMRUdBTF9NT0RJRklFUjsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgSW1hZ2UgaW1hZ2UgPSBKYXZhUGx1Z2luSW1hZ2VzLmdldChKYXZhUGx1Z2luSW1hZ2VzLklNR19DT1JSRUNUSU9OX0NIQU5HRSk7CisgICAgICAgICAgICBwcm9wb3NhbHMuYWRkKG5ldyBDaGFuZ2VNb2RpZmllckNvcnJlY3Rpb25Qcm9wb3NhbChjb250ZXh0LCBiaW5kaW5nLCBpbmNsdWRlZE1vZGlmaWVycywKKyAgICAgICAgICAgICAgICAgICAgZXhjbHVkZWRNb2RpZmllcnMsIGRpc3BsYXlTdHJpbmcsIDUsIGltYWdlKSk7CisgICAgICAgIH0KKyAgICB9CisKICAgICBwcml2YXRlIHZvaWQgYWRkQ29uc3RydWN0b3JQcm9wb3NhbChJSW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2JsZW1Mb2NhdGlvbiBwcm9ibGVtTG9jYXRpb24sCiAgICAgICAgICAgICBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMsIGludCByZWxldmFuY2UpIHsKIApAQCAtMzA5LDcgKzMwOSw3IEBACiAgICAgICAgIGlmICh0eXBlQmluZGluZyAhPSBudWxsICYmIHR5cGVCaW5kaW5nLmlzRnJvbVNvdXJjZSgpKSB7CiAgICAgICAgICAgICBTdHJpbmcgZGlzcGxheVN0cmluZyA9IEpBWFdTVUlNZXNzYWdlcy5iaW5kKEpBWFdTVUlNZXNzYWdlcy5DUkVBVEVfQ09OU1RSVUNUT1IsCiAgICAgICAgICAgICAgICAgICAgIHR5cGVCaW5kaW5nLmdldFR5cGVEZWNsYXJhdGlvbigpLmdldE5hbWUoKSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgSW1hZ2UgaW1hZ2UgPSBKYXZhRWxlbWVudEltYWdlUHJvdmlkZXIuZ2V0RGVjb3JhdGVkSW1hZ2UoSmF2YVBsdWdpbkltYWdlcy5ERVNDX01JU0NfUFVCTElDLAogICAgICAgICAgICAgICAgICAgICBKYXZhRWxlbWVudEltYWdlRGVzY3JpcHRvci5DT05TVFJVQ1RPUiwgSmF2YUVsZW1lbnRJbWFnZVByb3ZpZGVyLlNNQUxMX1NJWkUpOwogCkBAIC0zMTcsMjQgKzMxNywyNiBAQAogICAgICAgICAgICAgICAgICAgICBpbWFnZSkpOwogICAgICAgICB9CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSB2b2lkIGFkZENoYW5nZVJldHVyblR5cGVQcm9wb3NhbChJSW52b2NhdGlvbkNvbnRleHQgY29udGV4dCwgSVByb2JsZW1Mb2NhdGlvbiBwcm9ibGVtTG9jYXRpb24sCiAgICAgICAgICAgICBMaXN0PElKYXZhQ29tcGxldGlvblByb3Bvc2FsPiBwcm9wb3NhbHMpIHsKIAotICAgIAlDb21waWxhdGlvblVuaXQgYXN0Um9vdCA9IGNvbnRleHQuZ2V0QVNUUm9vdCgpOworICAgICAgICBDb21waWxhdGlvblVuaXQgYXN0Um9vdCA9IGNvbnRleHQuZ2V0QVNUUm9vdCgpOwogICAgICAgICBBU1ROb2RlIHNlbGVjdGVkTm9kZSA9IHByb2JsZW1Mb2NhdGlvbi5nZXRDb3ZlcmluZ05vZGUoYXN0Um9vdCk7CiAKLQkJaWYgKCEoc2VsZWN0ZWROb2RlIGluc3RhbmNlb2YgU2ltcGxlTmFtZSkpIHsKLQkJCXJldHVybjsKLQkJfQotCQkKLQkJTWV0aG9kRGVjbGFyYXRpb24gaW1wbE1ldGhvZERlY2xhcmF0aW9uID0gKE1ldGhvZERlY2xhcmF0aW9uKSgoU2ltcGxlTmFtZSkgc2VsZWN0ZWROb2RlKS5nZXRQYXJlbnQoKTsKLQkJVHlwZURlY2xhcmF0aW9uIGltcGxUeXBlRGVjbGFyYXRpb24gPSAoVHlwZURlY2xhcmF0aW9uKWltcGxNZXRob2REZWNsYXJhdGlvbi5nZXRQYXJlbnQoKTsKLQkJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24oaW1wbFR5cGVEZWNsYXJhdGlvbiwgV2ViU2VydmljZS5jbGFzcyk7Ci0JCVN0cmluZyBlbmRwb2ludEludGVyZmFjZSA9IEFubm90YXRpb25VdGlscy5nZXRTdHJpbmdWYWx1ZShhbm5vdGF0aW9uLCAiZW5kcG9pbnRJbnRlcmZhY2UiKTsgLy8kTk9OLU5MUy0xJAotCQlTdHJpbmcgZGlzcGxheVN0cmluZyA9IEpBWFdTVUlNZXNzYWdlcy5DSEFOR0VfTUVUSE9EX1JFVFVSTl9UWVBFOwotCQlJbWFnZSBpbWFnZSA9IEphdmFQbHVnaW5JbWFnZXMuZ2V0KEphdmFQbHVnaW5JbWFnZXMuSU1HX0NPUlJFQ1RJT05fQ0hBTkdFKTsKLQkJcHJvcG9zYWxzLmFkZChuZXcgQ2hhbmdlUmV0dXJuVHlwZUNvcnJlY3Rpb25Qcm9wb3NhbChjb250ZXh0LCBpbXBsVHlwZURlY2xhcmF0aW9uLAotCQkJCWltcGxNZXRob2REZWNsYXJhdGlvbiwgZW5kcG9pbnRJbnRlcmZhY2UsIGRpc3BsYXlTdHJpbmcsIDUsIGltYWdlKSk7CisgICAgICAgIGlmICghKHNlbGVjdGVkTm9kZSBpbnN0YW5jZW9mIFNpbXBsZU5hbWUpKSB7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBNZXRob2REZWNsYXJhdGlvbiBpbXBsTWV0aG9kRGVjbGFyYXRpb24gPSAoTWV0aG9kRGVjbGFyYXRpb24pKChTaW1wbGVOYW1lKSBzZWxlY3RlZE5vZGUpLmdldFBhcmVudCgpOworICAgICAgICBUeXBlRGVjbGFyYXRpb24gaW1wbFR5cGVEZWNsYXJhdGlvbiA9IChUeXBlRGVjbGFyYXRpb24paW1wbE1ldGhvZERlY2xhcmF0aW9uLmdldFBhcmVudCgpOworCisgICAgICAgIEFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKGltcGxUeXBlRGVjbGFyYXRpb24ucmVzb2x2ZUJpbmRpbmcoKS5nZXRKYXZhRWxlbWVudCgpLCBXZWJTZXJ2aWNlLmNsYXNzKTsKKworICAgICAgICBTdHJpbmcgZW5kcG9pbnRJbnRlcmZhY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgImVuZHBvaW50SW50ZXJmYWNlIik7IC8vJE5PTi1OTFMtMSQKKyAgICAgICAgU3RyaW5nIGRpc3BsYXlTdHJpbmcgPSBKQVhXU1VJTWVzc2FnZXMuQ0hBTkdFX01FVEhPRF9SRVRVUk5fVFlQRTsKKyAgICAgICAgSW1hZ2UgaW1hZ2UgPSBKYXZhUGx1Z2luSW1hZ2VzLmdldChKYXZhUGx1Z2luSW1hZ2VzLklNR19DT1JSRUNUSU9OX0NIQU5HRSk7CisgICAgICAgIHByb3Bvc2Fscy5hZGQobmV3IENoYW5nZVJldHVyblR5cGVDb3JyZWN0aW9uUHJvcG9zYWwoY29udGV4dCwgaW1wbFR5cGVEZWNsYXJhdGlvbiwKKyAgICAgICAgICAgICAgICBpbXBsTWV0aG9kRGVjbGFyYXRpb24sIGVuZHBvaW50SW50ZXJmYWNlLCBkaXNwbGF5U3RyaW5nLCA1LCBpbWFnZSkpOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvY29ycmVjdGlvbi9SZW1vdmVBbm5vdGF0aW9uQ29ycmVjdGlvblByb3Bvc2FsLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2NvcnJlY3Rpb24vUmVtb3ZlQW5ub3RhdGlvbkNvcnJlY3Rpb25Qcm9wb3NhbC5qYXZhCmluZGV4IDNjMGEwOWEuLjk3MTYyZTggMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvY29ycmVjdGlvbi9SZW1vdmVBbm5vdGF0aW9uQ29ycmVjdGlvblByb3Bvc2FsLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9jb3JyZWN0aW9uL1JlbW92ZUFubm90YXRpb25Db3JyZWN0aW9uUHJvcG9zYWwuamF2YQpAQCAtMjIsMTEgKzIyLDExIEBACiBpbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LmdyYXBoaWNzLkltYWdlOwogCiBwdWJsaWMgY2xhc3MgUmVtb3ZlQW5ub3RhdGlvbkNvcnJlY3Rpb25Qcm9wb3NhbCBleHRlbmRzIEFic3RyYWN0SmF2YUNvcnJlY3Rpb25Qcm9wc29hbCB7Ci0gICAgCisKICAgICBwcml2YXRlIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uOwogICAgIHByaXZhdGUgQVNUTm9kZSBwYXJlbnROb2RlOwotICAgIAotICAgIHB1YmxpYyBSZW1vdmVBbm5vdGF0aW9uQ29ycmVjdGlvblByb3Bvc2FsKElJbnZvY2F0aW9uQ29udGV4dCBpbnZvY2F0aW9uQ29udGV4dCwgCisKKyAgICBwdWJsaWMgUmVtb3ZlQW5ub3RhdGlvbkNvcnJlY3Rpb25Qcm9wb3NhbChJSW52b2NhdGlvbkNvbnRleHQgaW52b2NhdGlvbkNvbnRleHQsCiAgICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbiwgQVNUTm9kZSBwYXJlbnROb2RlLCBTdHJpbmcgZGlzcGxheVN0cmluZywKICAgICAgICAgICAgIGludCByZWxldmFuY2UsIEltYWdlIGltYWdlKSB7CiAgICAgICAgIHN1cGVyKGludm9jYXRpb25Db250ZXh0LCBkaXNwbGF5U3RyaW5nLCByZWxldmFuY2UsIGltYWdlKTsKQEAgLTQyLDIzICs0MiwyMyBAQAogICAgICAgICAgICAgQW5ub3RhdGlvbiBqZHREb21Bbm5vdGF0aW9uID0gKEFubm90YXRpb24pIHBhcmVudE5vZGU7CiAgICAgICAgICAgICByZXdyaXRlci5yZW1vdmUoamR0RG9tQW5ub3RhdGlvbiwgbnVsbCk7CiAgICAgICAgIH0KLSAgICAgICAgCisKICAgICAgICAgaWYgKHBhcmVudE5vZGUgaW5zdGFuY2VvZiBNZXRob2REZWNsYXJhdGlvbikgewogICAgICAgICAgICAgTWV0aG9kRGVjbGFyYXRpb24gbWV0aG9kRGVjbGFyYXRpb24gPSAoTWV0aG9kRGVjbGFyYXRpb24pIHBhcmVudE5vZGU7Ci0gICAgICAgICAgICBBbm5vdGF0aW9uIGpkdERvbUFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihtZXRob2REZWNsYXJhdGlvbiwgYW5ub3RhdGlvbik7CisgICAgICAgICAgICBBbm5vdGF0aW9uIGpkdERvbUFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihtZXRob2REZWNsYXJhdGlvbi5yZXNvbHZlQmluZGluZygpLmdldEphdmFFbGVtZW50KCksIGFubm90YXRpb24pOwogICAgICAgICAgICAgaWYgKGpkdERvbUFubm90YXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgICAgIHJld3JpdGVyLnJlbW92ZShqZHREb21Bbm5vdGF0aW9uLCBudWxsKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAocGFyZW50Tm9kZS5nZXRQYXJlbnQoKSBpbnN0YW5jZW9mIFR5cGVEZWNsYXJhdGlvbikgewogICAgICAgICAgICAgVHlwZURlY2xhcmF0aW9uIHR5cGVEZWNsYXJhdGlvbiA9IChUeXBlRGVjbGFyYXRpb24pIHBhcmVudE5vZGUuZ2V0UGFyZW50KCk7Ci0gICAgICAgICAgICBBbm5vdGF0aW9uIGpkdERvbUFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbih0eXBlRGVjbGFyYXRpb24sIGFubm90YXRpb24pOworICAgICAgICAgICAgQW5ub3RhdGlvbiBqZHREb21Bbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZURlY2xhcmF0aW9uLnJlc29sdmVCaW5kaW5nKCkuZ2V0SmF2YUVsZW1lbnQoKSwgYW5ub3RhdGlvbik7CiAgICAgICAgICAgICBpZiAoamR0RG9tQW5ub3RhdGlvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgcmV3cml0ZXIucmVtb3ZlKGpkdERvbUFubm90YXRpb24sIG51bGwpOwogICAgICAgICAgICAgfQogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIHRleHRDaGFuZ2UuYWRkRWRpdChyZXdyaXRlci5yZXdyaXRlQVNUKCkpOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9pbml0aWFsaXphdGlvbi9CaW5kaW5nVHlwZUF0dHJpYnV0ZUluaXRpYWxpemVyLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL0JpbmRpbmdUeXBlQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQppbmRleCBlYzA3OWRkLi5jYzVhMWYyIDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL0JpbmRpbmdUeXBlQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL0JpbmRpbmdUeXBlQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQpAQCAtMjIsNyArMjIsOSBAQAogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklKYXZhRWxlbWVudDsNCiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSVR5cGU7DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5BU1Q7DQoraW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5FeHByZXNzaW9uOw0KIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uTWVtYmVyVmFsdWVQYWlyOw0KK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uU2luZ2xlTWVtYmVyQW5ub3RhdGlvbjsNCiBpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UudGV4dC5jb250ZW50YXNzaXN0LklDb21wbGV0aW9uUHJvcG9zYWw7DQogaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuU3R5bGVkU3RyaW5nOw0KIGltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5Bbm5vdGF0aW9uc0NvcmU7DQpAQCAtNDIsMTAgKzQ0LDEwIEBACiAgICAgcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEhUVFBfQklORElORyA9ICJqYXZheC54bWwud3MuaHR0cC5IVFRQQmluZGluZyI7IC8vJE5PTi1OTFMtMSQNCiANCiAgICAgcHVibGljIEJpbmRpbmdUeXBlQXR0cmlidXRlSW5pdGlhbGl6ZXIoKSB7DQotICAgICAgICBKQVhXU1VJUGx1Z2luLmdldERlZmF1bHQoKS5nZXRJbWFnZVJlZ2lzdHJ5KCkucHV0KFNPQVBfQklORElORywgDQotICAgICAgICAJCUpBWFdTVUlQbHVnaW4uZ2V0SW1hZ2VEZXNjcmlwdG9yKCJpY29ucy9vYmoxNi9zb2FwYmluZGluZ19vYmouZ2lmIikuY3JlYXRlSW1hZ2UoKSk7IC8vJE5PTi1OTFMtMSQNCi0gICAgICAgIEpBWFdTVUlQbHVnaW4uZ2V0RGVmYXVsdCgpLmdldEltYWdlUmVnaXN0cnkoKS5wdXQoSFRUUF9CSU5ESU5HLCANCi0gICAgICAgIAkJSkFYV1NVSVBsdWdpbi5nZXRJbWFnZURlc2NyaXB0b3IoImljb25zL29iajE2L2h0dHBiaW5kaW5nX29iai5naWYiKS5jcmVhdGVJbWFnZSgpKTsgLy8kTk9OLU5MUy0xJA0KKyAgICAgICAgSkFYV1NVSVBsdWdpbi5nZXREZWZhdWx0KCkuZ2V0SW1hZ2VSZWdpc3RyeSgpLnB1dChTT0FQX0JJTkRJTkcsDQorICAgICAgICAgICAgICAgIEpBWFdTVUlQbHVnaW4uZ2V0SW1hZ2VEZXNjcmlwdG9yKCJpY29ucy9vYmoxNi9zb2FwYmluZGluZ19vYmouZ2lmIikuY3JlYXRlSW1hZ2UoKSk7IC8vJE5PTi1OTFMtMSQNCisgICAgICAgIEpBWFdTVUlQbHVnaW4uZ2V0RGVmYXVsdCgpLmdldEltYWdlUmVnaXN0cnkoKS5wdXQoSFRUUF9CSU5ESU5HLA0KKyAgICAgICAgICAgICAgICBKQVhXU1VJUGx1Z2luLmdldEltYWdlRGVzY3JpcHRvcigiaWNvbnMvb2JqMTYvaHR0cGJpbmRpbmdfb2JqLmdpZiIpLmNyZWF0ZUltYWdlKCkpOyAvLyROT04tTkxTLTEkDQogICAgIH0NCiANCiAgICAgQE92ZXJyaWRlDQpAQCAtNTksMTEgKzYxLDI1IEBACiAgICAgICAgIHJldHVybiBtZW1iZXJWYWx1ZVBhaXJzOw0KICAgICB9DQogDQorICAgIEBPdmVycmlkZQ0KKyAgICBwdWJsaWMgTGlzdDxJQ29tcGxldGlvblByb3Bvc2FsPiBnZXRDb21wbGV0aW9uUHJvcG9zYWxzRm9yU2luZ2xlTWVtYmVyQW5ub3RhdGlvbihJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsDQorICAgICAgICAgICAgU2luZ2xlTWVtYmVyQW5ub3RhdGlvbiBzaW5nbGVNZW1iZXJBbm5vdGF0aW9uKSB7DQorICAgICAgICBMaXN0PElDb21wbGV0aW9uUHJvcG9zYWw+IGNvbXBsZXRpb25Qcm9wb3NhbHMgPSBuZXcgQXJyYXlMaXN0PElDb21wbGV0aW9uUHJvcG9zYWw+KCk7DQorICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuVFlQRSkgew0KKyAgICAgICAgICAgIEV4cHJlc3Npb24gZXhwcmVzc2lvbiA9IHNpbmdsZU1lbWJlckFubm90YXRpb24uZ2V0VmFsdWUoKTsNCisgICAgICAgICAgICBpZiAoZXhwcmVzc2lvbiAhPSBudWxsKSB7DQorICAgICAgICAgICAgICAgIGFkZFF1YWxpZmllZE5hbWVCaW5kaW5nc0NvbXBsZXRpb25Qcm9wb3NhbHMoY29tcGxldGlvblByb3Bvc2FscywgZXhwcmVzc2lvbik7DQorICAgICAgICAgICAgfQ0KKyAgICAgICAgfQ0KKyAgICAgICAgcmV0dXJuIGNvbXBsZXRpb25Qcm9wb3NhbHM7DQorICAgIH0NCisNCisgICAgQE92ZXJyaWRlDQogICAgIHB1YmxpYyBMaXN0PElDb21wbGV0aW9uUHJvcG9zYWw+IGdldENvbXBsZXRpb25Qcm9wb3NhbHNGb3JNZW1iZXJWYWx1ZVBhaXIoSUphdmFFbGVtZW50IGphdmFFbGVtZW50LA0KICAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIpIHsNCiAgICAgICAgIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gY29tcGxldGlvblByb3Bvc2FscyA9IG5ldyBBcnJheUxpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4oKTsNCiAgICAgICAgIGlmIChqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5UWVBFKSB7DQotICAgICAgICAgICAgSVR5cGUgdHlwZSA9IChJVHlwZSkgIGphdmFFbGVtZW50Ow0KKyAgICAgICAgICAgIElUeXBlIHR5cGUgPSAoSVR5cGUpIGphdmFFbGVtZW50Ow0KICAgICAgICAgICAgIFN0cmluZyBtZW1iZXJWYWx1ZVBhaXJOYW1lID0gbWVtYmVyVmFsdWVQYWlyLmdldE5hbWUoKS5nZXRJZGVudGlmaWVyKCk7DQogICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpck5hbWUuZXF1YWxzKFZBTFVFKSkgeyAvLyROT04tTkxTLTEkDQogICAgICAgICAgICAgICAgIFN0cmluZyB2YWx1ZSA9IG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpLnRvU3RyaW5nKCk7DQpAQCAtODIsMjEgKzk4LDI0IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmdWxseVF1YWxpZmllZFR5cGVOYW1lKSk7DQogICAgICAgICAgICAgICAgICAgICB9DQogICAgICAgICAgICAgICAgIH0gZWxzZSB7DQotICAgICAgICAgICAgICAgICAgICBNYXA8U3RyaW5nLCBTdHJpbmc+IGJpbmRpbmdzID0gZ2V0UXVhbGlmaWVkTmFtZUJpbmRpbmdzTWFwKCk7DQotICAgICAgICAgICAgICAgICAgICBJdGVyYXRvcjxNYXAuRW50cnk8U3RyaW5nLCBTdHJpbmc+PiBiaW5kaW5nc0l0ZXIgPSBiaW5kaW5ncy5lbnRyeVNldCgpLml0ZXJhdG9yKCk7DQotICAgICAgICAgICAgICAgICAgICB3aGlsZSAoYmluZGluZ3NJdGVyLmhhc05leHQoKSkgew0KLSAgICAgICAgICAgICAgICAgICAgICAgIE1hcC5FbnRyeTxTdHJpbmcsIFN0cmluZz4gYmluZGluZ0VudHJ5ID0gYmluZGluZ3NJdGVyLm5leHQoKTsNCi0gICAgICAgICAgICAgICAgICAgICAgICBTdHJpbmcgcHJvcG9zYWwgPSBiaW5kaW5nRW50cnkuZ2V0S2V5KCk7DQotICAgICAgICAgICAgICAgICAgICAgICAgSW1hZ2UgaW1hZ2UgPSBKQVhXU1VJUGx1Z2luLmdldERlZmF1bHQoKS5nZXRJbWFnZVJlZ2lzdHJ5KCkuZ2V0KGJpbmRpbmdFbnRyeS5nZXRWYWx1ZSgpKTsNCi0gICAgICAgICAgICAgICAgICAgICAgICBjb21wbGV0aW9uUHJvcG9zYWxzLmFkZChjcmVhdGVDb21wbGV0aW9uUHJvcG9zYWwocHJvcG9zYWwsIG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpLA0KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1hZ2UsIGdldERpc3BsYXlTdHJpbmcocHJvcG9zYWwpKSk7DQotICAgICAgICAgICAgICAgICAgICB9DQorICAgICAgICAgICAgICAgICAgICBhZGRRdWFsaWZpZWROYW1lQmluZGluZ3NDb21wbGV0aW9uUHJvcG9zYWxzKGNvbXBsZXRpb25Qcm9wb3NhbHMsIG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpKTsNCiAgICAgICAgICAgICAgICAgfQ0KICAgICAgICAgICAgICB9DQogICAgICAgICB9DQogICAgICAgICByZXR1cm4gY29tcGxldGlvblByb3Bvc2FsczsNCiAgICAgfQ0KIA0KKyAgICBwcml2YXRlIHZvaWQgYWRkUXVhbGlmaWVkTmFtZUJpbmRpbmdzQ29tcGxldGlvblByb3Bvc2FscyhMaXN0PElDb21wbGV0aW9uUHJvcG9zYWw+IGNvbXBsZXRpb25Qcm9wb3NhbHMsIEV4cHJlc3Npb24gdmFsdWUpIHsNCisgICAgICAgIE1hcDxTdHJpbmcsIFN0cmluZz4gYmluZGluZ3MgPSBnZXRRdWFsaWZpZWROYW1lQmluZGluZ3NNYXAoKTsNCisgICAgICAgIEl0ZXJhdG9yPE1hcC5FbnRyeTxTdHJpbmcsIFN0cmluZz4+IGJpbmRpbmdzSXRlciA9IGJpbmRpbmdzLmVudHJ5U2V0KCkuaXRlcmF0b3IoKTsNCisgICAgICAgIHdoaWxlIChiaW5kaW5nc0l0ZXIuaGFzTmV4dCgpKSB7DQorICAgICAgICAgICAgTWFwLkVudHJ5PFN0cmluZywgU3RyaW5nPiBiaW5kaW5nRW50cnkgPSBiaW5kaW5nc0l0ZXIubmV4dCgpOw0KKyAgICAgICAgICAgIFN0cmluZyBwcm9wb3NhbCA9IGJpbmRpbmdFbnRyeS5nZXRLZXkoKTsNCisgICAgICAgICAgICBJbWFnZSBpbWFnZSA9IEpBWFdTVUlQbHVnaW4uZ2V0RGVmYXVsdCgpLmdldEltYWdlUmVnaXN0cnkoKS5nZXQoYmluZGluZ0VudHJ5LmdldFZhbHVlKCkpOw0KKyAgICAgICAgICAgIGNvbXBsZXRpb25Qcm9wb3NhbHMuYWRkKGNyZWF0ZUNvbXBsZXRpb25Qcm9wb3NhbChwcm9wb3NhbCwgdmFsdWUsIGltYWdlLCBnZXREaXNwbGF5U3RyaW5nKHByb3Bvc2FsKSkpOw0KKyAgICAgICAgfQ0KKyAgICB9DQorDQogICAgIHB1YmxpYyBTdHJpbmcgZ2V0RGVmYXVsdCgpIHsNCiAgICAgICAgIHJldHVybiBTT0FQQmluZGluZy5TT0FQMTFIVFRQX0JJTkRJTkc7DQogICAgIH0NCmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL1JlcXVlc3RXcmFwcGVyQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vUmVxdWVzdFdyYXBwZXJBdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCmluZGV4IDBkMWI4MDguLjY1MDZiMDYgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vUmVxdWVzdFdyYXBwZXJBdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vUmVxdWVzdFdyYXBwZXJBdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCkBAIC0xMTMsNyArMTEzLDcgQEAKICAgICAKICAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldExvY2FsTmFtZShJVHlwZSB0eXBlLCBJTWV0aG9kIG1ldGhvZCkgewogICAgICAgICB0cnkgewotICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKG1ldGhvZCwgV2ViTWV0aG9kLmNsYXNzKTsKKyAgICAgICAgICAgIElBbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihXZWJNZXRob2QuY2xhc3MsIG1ldGhvZCk7CiAgICAgICAgICAgICBpZiAoYW5ub3RhdGlvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgU3RyaW5nIG9wZXJhdGlvbk5hbWUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgT1BFUkFUSU9OX05BTUUpOwogICAgICAgICAgICAgICAgIGlmIChvcGVyYXRpb25OYW1lICE9IG51bGwpIHsKQEAgLTEyMiwxNCArMTIyLDE0IEBACiAgICAgICAgICAgICB9CiAgICAgICAgICAgICByZXR1cm4gbWV0aG9kLmdldEVsZW1lbnROYW1lKCkgKyBBbm5vdGF0aW9uVXRpbHMuYWNjb3VudEZvck92ZXJsb2FkZWRNZXRob2RzKHR5cGUsIG1ldGhvZCk7CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKLSAgICAgICAgCUpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CisgICAgICAgICAgICBKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAgICAgICAgIHJldHVybiAiIjsgLy8kTk9OLU5MUy0xJAogICAgIH0KICAgICAKICAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldFRhcmdldE5hbWVzcGFjZShJVHlwZSB0eXBlKSB7CiAgICAgICAgIHRyeSB7Ci0gICAgICAgICAgICBJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZSwgV2ViU2VydmljZS5jbGFzcyk7CisgICAgICAgICAgICBJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24oV2ViU2VydmljZS5jbGFzcywgdHlwZSk7CiAgICAgICAgICAgICBpZiAoYW5ub3RhdGlvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgU3RyaW5nIHRhcmdldE5hbWVzcGFjZSA9IEFubm90YXRpb25VdGlscy5nZXRTdHJpbmdWYWx1ZShhbm5vdGF0aW9uLCBUQVJHRVRfTkFNRVNQQUNFKTsKICAgICAgICAgICAgICAgICBpZiAodGFyZ2V0TmFtZXNwYWNlICE9IG51bGwgJiYgdGFyZ2V0TmFtZXNwYWNlLmxlbmd0aCgpID4gMCkgewpAQCAtMTM4LDcgKzEzOCw3IEBACiAgICAgICAgICAgICB9CiAgICAgICAgICAgICByZXR1cm4gSkRUVXRpbHMuZ2V0VGFyZ2V0TmFtZXNwYWNlRnJvbVBhY2thZ2VOYW1lKHR5cGUuZ2V0UGFja2FnZUZyYWdtZW50KCkuZ2V0RWxlbWVudE5hbWUoKSk7CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKLSAgICAgICAgCUpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CisgICAgICAgICAgICBKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAgICAgICAgIHJldHVybiAiIjsgLy8kTk9OLU5MUy0xJAogICAgIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vUmVzcG9uc2VXcmFwcGVyQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vUmVzcG9uc2VXcmFwcGVyQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQppbmRleCBmNjUxNTE2Li44ZWVhYzIxIDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL1Jlc3BvbnNlV3JhcHBlckF0dHJpYnV0ZUluaXRpYWxpemVyLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9pbml0aWFsaXphdGlvbi9SZXNwb25zZVdyYXBwZXJBdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCkBAIC0zMSw3ICszMSw3IEBACiAgICAgICAgICAgICByZXR1cm4gZ2V0UGFja2FnZU5hbWUodHlwZSkgKyBtZXRob2ROYW1lLnN1YnN0cmluZygwLCAxKS50b1VwcGVyQ2FzZSgpCiAgICAgICAgICAgICAgICAgKyBtZXRob2ROYW1lLnN1YnN0cmluZygxKSArIEFubm90YXRpb25VdGlscy5hY2NvdW50Rm9yT3ZlcmxvYWRlZE1ldGhvZHModHlwZSwgbWV0aG9kKTsKICAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewotICAgICAgICAJSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKKyAgICAgICAgICAgIEpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCiAgICAgfQpAQCAtMzksNyArMzksNyBAQAogICAgIEBPdmVycmlkZQogICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0TG9jYWxOYW1lKElUeXBlIHR5cGUsIElNZXRob2QgbWV0aG9kKSB7CiAgICAgICAgIHRyeSB7Ci0gICAgICAgICAgICBJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24obWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpOworICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKFdlYk1ldGhvZC5jbGFzcywgbWV0aG9kKTsKICAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgICAgICBTdHJpbmcgb3BlcmF0aW9uTmFtZSA9IEFubm90YXRpb25VdGlscy5nZXRTdHJpbmdWYWx1ZShhbm5vdGF0aW9uLCBPUEVSQVRJT05fTkFNRSk7CiAgICAgICAgICAgICAgICAgaWYgKG9wZXJhdGlvbk5hbWUgIT0gbnVsbCkgewpAQCAtNDksNyArNDksNyBAQAogICAgICAgICAgICAgcmV0dXJuIG1ldGhvZC5nZXRFbGVtZW50TmFtZSgpICsgUkVTUE9OU0VfU1VGRklYIAogICAgICAgICAgICAgICAgICAgICArIEFubm90YXRpb25VdGlscy5hY2NvdW50Rm9yT3ZlcmxvYWRlZE1ldGhvZHModHlwZSwgbWV0aG9kKTsKICAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewotICAgICAgICAJSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKKyAgICAgICAgICAgIEpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuICIiOyAvLyROT04tTkxTLTEkCiAgICAgfQpkaWZmIC0tZ2l0IGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9pbml0aWFsaXphdGlvbi9XZWJQYXJhbUF0dHJpYnV0ZUluaXRpYWxpemVyLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL1dlYlBhcmFtQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQppbmRleCAyZmExYTA5Li5jNjkxNmJjIDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL1dlYlBhcmFtQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQorKysgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL1dlYlBhcmFtQXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQpAQCAtMTksNiArMTksNyBAQAogCiBpbXBvcnQgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbjsKIGltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OworaW1wb3J0IGphdmEudXRpbC5BcnJheXM7CiBpbXBvcnQgamF2YS51dGlsLkxpc3Q7CiAKIGltcG9ydCBqYXZheC5qd3MuV2ViTWV0aG9kOwpAQCAtMjgsNzYgKzI5LDc5IEBACiAKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JSmF2YUVsZW1lbnQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUxvY2FsVmFyaWFibGU7CitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSU1ldGhvZDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JVHlwZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5KYXZhTW9kZWxFeGNlcHRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFTVDsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQm9keURlY2xhcmF0aW9uOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Db21waWxhdGlvblVuaXQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLk1lbWJlclZhbHVlUGFpcjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uTWV0aG9kRGVjbGFyYXRpb247Ci1pbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLlBhY2thZ2VEZWNsYXJhdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uU2luZ2xlVmFyaWFibGVEZWNsYXJhdGlvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uVHlwZURlY2xhcmF0aW9uOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnRleHQuY29udGVudGFzc2lzdC5JQ29tcGxldGlvblByb3Bvc2FsOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLkFubm90YXRpb25zQ29yZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5pbml0aWFsaXphdGlvbi5Bbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUudXRpbHMuQW5ub3RhdGlvblV0aWxzOwogaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5pbnRlcm5hbC5qYXh3cy5jb3JlLnV0aWxzLkpBWFdTVXRpbHM7CitpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmludGVybmFsLmpheHdzLnVpLkpBWFdTVUlQbHVnaW47CiBpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudXRpbHMuSkRUVXRpbHM7CiAKIHB1YmxpYyBjbGFzcyBXZWJQYXJhbUF0dHJpYnV0ZUluaXRpYWxpemVyIGV4dGVuZHMgQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIHsKIAogICAgIEBPdmVycmlkZQotCXB1YmxpYyBMaXN0PE1lbWJlclZhbHVlUGFpcj4gZ2V0TWVtYmVyVmFsdWVQYWlycyhJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsCi0JCQlBU1QgYXN0LCBDbGFzczw/IGV4dGVuZHMgQW5ub3RhdGlvbj4gYW5ub3RhdGlvbkNsYXNzKSB7CisgICAgcHVibGljIExpc3Q8TWVtYmVyVmFsdWVQYWlyPiBnZXRNZW1iZXJWYWx1ZVBhaXJzKElKYXZhRWxlbWVudCBqYXZhRWxlbWVudCwKKyAgICAgICAgICAgIEFTVCBhc3QsIENsYXNzPD8gZXh0ZW5kcyBBbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MpIHsKIAotICAgIAlMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycyA9IG5ldyBBcnJheUxpc3Q8TWVtYmVyVmFsdWVQYWlyPigpOwotICAgIAkKKyAgICAgICAgTGlzdDxNZW1iZXJWYWx1ZVBhaXI+IG1lbWJlclZhbHVlUGFpcnMgPSBuZXcgQXJyYXlMaXN0PE1lbWJlclZhbHVlUGFpcj4oKTsKKwogICAgICAgICBpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTE9DQUxfVkFSSUFCTEUpIHsKLSAgICAgICAgCVNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyID0gQW5ub3RhdGlvblV0aWxzLmdldFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24oKElMb2NhbFZhcmlhYmxlKSBqYXZhRWxlbWVudCk7Ci0gICAgICAgIAlNZW1iZXJWYWx1ZVBhaXIgbmFtZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LCBOQU1FLCBnZXROYW1lKHBhcmFtZXRlcikpOworICAgICAgICAgICAgSUxvY2FsVmFyaWFibGUgcGFyYW1ldGVyID0gKElMb2NhbFZhcmlhYmxlKSBqYXZhRWxlbWVudDsKKyAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBuYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsIE5BTUUsIGdldE5hbWUocGFyYW1ldGVyKSk7CiAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChuYW1lVmFsdWVQYWlyKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gbWVtYmVyVmFsdWVQYWlyczsKLQl9CisgICAgfQogCi0JcHVibGljIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0Zvck1lbWJlclZhbHVlUGFpcihJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsCisgICAgQE92ZXJyaWRlCisgICAgcHVibGljIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gZ2V0Q29tcGxldGlvblByb3Bvc2Fsc0Zvck1lbWJlclZhbHVlUGFpcihJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsCiAgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyKSB7Ci0gICAgICAgIAorCiAgICAgICAgIExpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4gY29tcGxldGlvblByb3Bvc2FscyA9IG5ldyBBcnJheUxpc3Q8SUNvbXBsZXRpb25Qcm9wb3NhbD4oKTsKICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LkxPQ0FMX1ZBUklBQkxFKSB7Ci0gICAgICAgIAlTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uIHBhcmFtZXRlciA9IEFubm90YXRpb25VdGlscy5nZXRTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uKChJTG9jYWxWYXJpYWJsZSkgamF2YUVsZW1lbnQpOwotICAgICAgICAgICAgCisgICAgICAgICAgICBJTG9jYWxWYXJpYWJsZSBwYXJhbWV0ZXIgPSAoSUxvY2FsVmFyaWFibGUpIGphdmFFbGVtZW50OworCiAgICAgICAgICAgICBTdHJpbmcgbWVtYmVyVmFsdWVQYWlyTmFtZSA9IG1lbWJlclZhbHVlUGFpci5nZXROYW1lKCkuZ2V0SWRlbnRpZmllcigpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGlmIChtZW1iZXJWYWx1ZVBhaXJOYW1lLmVxdWFscyhOQU1FKSkgewogICAgICAgICAgICAgICAgIGNvbXBsZXRpb25Qcm9wb3NhbHMuYWRkKGNyZWF0ZUNvbXBsZXRpb25Qcm9wb3NhbChnZXROYW1lKHBhcmFtZXRlciksCi0gICAgICAgICAgICAgICAgCQltZW1iZXJWYWx1ZVBhaXIuZ2V0VmFsdWUoKSkpOworICAgICAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlyLmdldFZhbHVlKCkpKTsKICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyTmFtZS5lcXVhbHMoUEFSVF9OQU1FKSkgewogICAgICAgICAgICAgICAgIGNvbXBsZXRpb25Qcm9wb3NhbHMuYWRkKGNyZWF0ZUNvbXBsZXRpb25Qcm9wb3NhbChnZXRQYXJ0TmFtZShwYXJhbWV0ZXIpLAogICAgICAgICAgICAgICAgICAgICAgICAgbWVtYmVyVmFsdWVQYWlyLmdldFZhbHVlKCkpKTsKICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyTmFtZS5lcXVhbHMoVEFSR0VUX05BTUVTUEFDRSkpIHsKICAgICAgICAgICAgICAgICBjb21wbGV0aW9uUHJvcG9zYWxzLmFkZChjcmVhdGVDb21wbGV0aW9uUHJvcG9zYWwoZ2V0VGFyZ2V0TmFtZXNwYWNlKHBhcmFtZXRlciksCiAgICAgICAgICAgICAgICAgICAgICAgICBtZW1iZXJWYWx1ZVBhaXIuZ2V0VmFsdWUoKSkpOwogICAgICAgICAgICAgfQotICAgICAgICAgICAgCisKICAgICAgICAgfQogICAgICAgICByZXR1cm4gY29tcGxldGlvblByb3Bvc2FsczsKICAgICB9CiAKLSAgICBwcml2YXRlIFN0cmluZyBnZXROYW1lKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyKSB7Ci0gICAgICAgIE1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZERlY2xhcmF0aW9uID0gKE1ldGhvZERlY2xhcmF0aW9uKSBwYXJhbWV0ZXIuZ2V0UGFyZW50KCk7Ci0gICAgICAgIGlmIChoYXNEb2N1bWVudEJhcmVTT0FQQmluZGluZyhtZXRob2REZWNsYXJhdGlvbikpIHsKLSAgICAgICAgICAgIHJldHVybiBnZXRXZWJNZXRob2RPcGVyYXRpb25OYW1lKG1ldGhvZERlY2xhcmF0aW9uKTsKKyAgICBwcml2YXRlIFN0cmluZyBnZXROYW1lKElMb2NhbFZhcmlhYmxlIHBhcmFtZXRlcikgeworICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IChJTWV0aG9kKSBwYXJhbWV0ZXIuZ2V0UGFyZW50KCk7CisgICAgICAgIGlmIChoYXNEb2N1bWVudEJhcmVTT0FQQmluZGluZyhtZXRob2QpKSB7CisgICAgICAgICAgICByZXR1cm4gZ2V0V2ViTWV0aG9kT3BlcmF0aW9uTmFtZShtZXRob2QpOwogICAgICAgICB9Ci0KLSAgICAgICAgTGlzdDw/PiBzaWJsaW5ncyA9IChMaXN0PD8+KSBtZXRob2REZWNsYXJhdGlvbi5nZXRTdHJ1Y3R1cmFsUHJvcGVydHkocGFyYW1ldGVyLmdldExvY2F0aW9uSW5QYXJlbnQoKSk7Ci0gICAgICAgIHJldHVybiBBUkcgKyBzaWJsaW5ncy5pbmRleE9mKHBhcmFtZXRlcik7CisgICAgICAgIHRyeSB7CisgICAgICAgICAgICBMaXN0PFN0cmluZz4gbWV0aG9kTmFtZXMgPSBBcnJheXMuYXNMaXN0KG1ldGhvZC5nZXRQYXJhbWV0ZXJOYW1lcygpKTsKKyAgICAgICAgICAgIHJldHVybiBBUkcgKyBtZXRob2ROYW1lcy5pbmRleE9mKHBhcmFtZXRlci5nZXRFbGVtZW50TmFtZSgpKTsKKyAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgeworICAgICAgICAgICAgSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gcGFyYW1ldGVyLmdldEVsZW1lbnROYW1lKCk7CiAgICAgfQotICAgIAotICAgIHByaXZhdGUgU3RyaW5nIGdldFBhcnROYW1lKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyKSB7CisKKyAgICBwcml2YXRlIFN0cmluZyBnZXRQYXJ0TmFtZShJTG9jYWxWYXJpYWJsZSBwYXJhbWV0ZXIpIHsKICAgICAgICAgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKHBhcmFtZXRlciwKICAgICAgICAgICAgICAgICBXZWJQYXJhbS5jbGFzcyk7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKQEAgLTEwOCwxOSArMTEyLDE4IEBACiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGdldE5hbWUocGFyYW1ldGVyKTsKICAgICB9Ci0gICAgCi0gICAgcHJpdmF0ZSBTdHJpbmcgZ2V0VGFyZ2V0TmFtZXNwYWNlKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyKSB7CisKKyAgICBwcml2YXRlIFN0cmluZyBnZXRUYXJnZXROYW1lc3BhY2UoSUxvY2FsVmFyaWFibGUgcGFyYW1ldGVyKSB7CiAgICAgICAgIGlmIChoYXNEb2N1bWVudFdyYXBwZWRTT0FQQmluZGluZyhwYXJhbWV0ZXIpICYmICFpc0hlYWRlcihwYXJhbWV0ZXIpKSB7CiAgICAgICAgICAgICByZXR1cm4gIiI7ICAvLyROT04tTkxTLTEkCiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIGdldERlZmF1bHRUYXJnZXROYW1lc3BhY2UocGFyYW1ldGVyKTsKICAgICB9CiAKLSAgICBwcml2YXRlIFN0cmluZyBnZXREZWZhdWx0VGFyZ2V0TmFtZXNwYWNlKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyKSB7Ci0gICAgICAgIE1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZERlY2xhcmF0aW9uID0gKE1ldGhvZERlY2xhcmF0aW9uKSBwYXJhbWV0ZXIuZ2V0UGFyZW50KCk7Ci0gICAgICAgIFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24gPSAoVHlwZURlY2xhcmF0aW9uKSBtZXRob2REZWNsYXJhdGlvbi5nZXRQYXJlbnQoKTsKLSAgICAgICAgCi0gICAgICAgIG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbih0eXBlRGVjbGFyYXRpb24sCisgICAgcHJpdmF0ZSBTdHJpbmcgZ2V0RGVmYXVsdFRhcmdldE5hbWVzcGFjZShJTG9jYWxWYXJpYWJsZSBwYXJhbWV0ZXIpIHsKKyAgICAgICAgSU1ldGhvZCBtZXRob2QgPSAoSU1ldGhvZCkgcGFyYW1ldGVyLmdldFBhcmVudCgpOworICAgICAgICBJVHlwZSB0eXBlID0gbWV0aG9kLmdldERlY2xhcmluZ1R5cGUoKTsKKyAgICAgICAgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKHR5cGUsCiAgICAgICAgICAgICAgICAgV2ViU2VydmljZS5jbGFzcyk7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgIFN0cmluZyB0YXJnZXROYW1lc3BhY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgVEFSR0VUX05BTUVTUEFDRSk7CkBAIC0xMjgsMjAgKzEzMSwxMCBAQAogICAgICAgICAgICAgICAgIHJldHVybiB0YXJnZXROYW1lc3BhY2U7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldFRhcmdldE5hbWVzcGFjZUZyb21QYWNrYWdlTmFtZShnZXRQYWNrYWdlTmFtZSh0eXBlRGVjbGFyYXRpb24pKTsKKyAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldFRhcmdldE5hbWVzcGFjZUZyb21QYWNrYWdlTmFtZSh0eXBlLmdldFBhY2thZ2VGcmFnbWVudCgpLmdldEVsZW1lbnROYW1lKCkpOwogICAgIH0KIAotICAgIHByaXZhdGUgU3RyaW5nIGdldFBhY2thZ2VOYW1lKFR5cGVEZWNsYXJhdGlvbiB0eXBlRGVjbGFyYXRpb24pIHsKLSAgICAgICAgaWYgKHR5cGVEZWNsYXJhdGlvbi5pc1BhY2thZ2VNZW1iZXJUeXBlRGVjbGFyYXRpb24oKSkgewotICAgICAgICAgICAgUGFja2FnZURlY2xhcmF0aW9uIHBhY2thZ2VEZWNsYXJhdGlvbiA9ICgoQ29tcGlsYXRpb25Vbml0KSB0eXBlRGVjbGFyYXRpb24uZ2V0UGFyZW50KCkpLmdldFBhY2thZ2UoKTsKLSAgICAgICAgICAgIGlmIChwYWNrYWdlRGVjbGFyYXRpb24gIT0gbnVsbCkgewotICAgICAgICAgICAgICAgIHJldHVybiBwYWNrYWdlRGVjbGFyYXRpb24uZ2V0TmFtZSgpLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgpOwotICAgICAgICAgICAgfSAgICAgICAgICAKLSAgICAgICAgfQotICAgICAgICByZXR1cm4gIiI7IC8vJE5PTi1OTFMtMSQKLSAgICB9Ci0gICAgCi0gICAgcHJpdmF0ZSBib29sZWFuIGlzSGVhZGVyKFNpbmdsZVZhcmlhYmxlRGVjbGFyYXRpb24gcGFyYW1ldGVyKSB7CisgICAgcHJpdmF0ZSBib29sZWFuIGlzSGVhZGVyKElMb2NhbFZhcmlhYmxlIHBhcmFtZXRlcikgewogICAgICAgICBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24ocGFyYW1ldGVyLCBXZWJQYXJhbS5jbGFzcyk7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgIEJvb2xlYW4gaGVhZGVyID0gQW5ub3RhdGlvblV0aWxzLmdldEJvb2xlYW5WYWx1ZShhbm5vdGF0aW9uLCBIRUFERVIpOwpAQCAtMTUyLDE4ICsxNDUsMTYgQEAKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KIAotICAgIHByaXZhdGUgYm9vbGVhbiBoYXNEb2N1bWVudFdyYXBwZWRTT0FQQmluZGluZyhTaW5nbGVWYXJpYWJsZURlY2xhcmF0aW9uIHBhcmFtZXRlcikgewotICAgICAgICBNZXRob2REZWNsYXJhdGlvbiBtZXRob2REZWNsYXJhdGlvbiA9IChNZXRob2REZWNsYXJhdGlvbikgcGFyYW1ldGVyLmdldFBhcmVudCgpOworICAgIHByaXZhdGUgYm9vbGVhbiBoYXNEb2N1bWVudFdyYXBwZWRTT0FQQmluZGluZyhJTG9jYWxWYXJpYWJsZSBwYXJhbWV0ZXIpIHsKKyAgICAgICAgSU1ldGhvZCBtZXRob2QgPSAoSU1ldGhvZCkgcGFyYW1ldGVyLmdldFBhcmVudCgpOwogCi0gICAgICAgIG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihtZXRob2REZWNsYXJhdGlvbiwKKyAgICAgICAgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKG1ldGhvZCwKICAgICAgICAgICAgICAgICBTT0FQQmluZGluZy5jbGFzcyk7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgIHJldHVybiBKQVhXU1V0aWxzLmlzRG9jdW1lbnRXcmFwcGVkKGFubm90YXRpb24pOwogICAgICAgICB9Ci0gICAgICAgIAotICAgICAgICBUeXBlRGVjbGFyYXRpb24gdHlwZURlY2xhcmF0aW9uID0gKFR5cGVEZWNsYXJhdGlvbikgbWV0aG9kRGVjbGFyYXRpb24uZ2V0UGFyZW50KCk7Ci0gICAgICAgIAotICAgICAgICBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQW5ub3RhdGlvbiB0eXBlQW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKHR5cGVEZWNsYXJhdGlvbiwKKworICAgICAgICBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQW5ub3RhdGlvbiB0eXBlQW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKG1ldGhvZC5nZXREZWNsYXJpbmdUeXBlKCksCiAgICAgICAgICAgICAgICAgU09BUEJpbmRpbmcuY2xhc3MpOwogICAgICAgICBpZiAodHlwZUFubm90YXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgcmV0dXJuIEpBWFdTVXRpbHMuaXNEb2N1bWVudFdyYXBwZWQodHlwZUFubm90YXRpb24pOwpAQCAtMTcxLDIyICsxNjIsMjIgQEAKICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQogCi0gICAgcHJpdmF0ZSBib29sZWFuIGhhc0RvY3VtZW50QmFyZVNPQVBCaW5kaW5nKEJvZHlEZWNsYXJhdGlvbiBib2R5RGVjbGFyYXRpb24pIHsKLSAgICAgICAgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKGJvZHlEZWNsYXJhdGlvbiwKKyAgICBwcml2YXRlIGJvb2xlYW4gaGFzRG9jdW1lbnRCYXJlU09BUEJpbmRpbmcoSUphdmFFbGVtZW50IGphdmFFbGVtZW50KSB7CisgICAgICAgIG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihqYXZhRWxlbWVudCwKICAgICAgICAgICAgICAgICBTT0FQQmluZGluZy5jbGFzcyk7CiAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgIHJldHVybiBKQVhXU1V0aWxzLmlzRG9jdW1lbnRCYXJlKGFubm90YXRpb24pOwogICAgICAgICB9Ci0gICAgICAgIGlmIChib2R5RGVjbGFyYXRpb24gaW5zdGFuY2VvZiBNZXRob2REZWNsYXJhdGlvbikgewotICAgICAgICAgICAgTWV0aG9kRGVjbGFyYXRpb24gbWV0aG9kRGVjbGFyYXRpb24gPSAoTWV0aG9kRGVjbGFyYXRpb24pIGJvZHlEZWNsYXJhdGlvbjsKLSAgICAgICAgICAgIHJldHVybiBoYXNEb2N1bWVudEJhcmVTT0FQQmluZGluZygoVHlwZURlY2xhcmF0aW9uKSBtZXRob2REZWNsYXJhdGlvbi5nZXRQYXJlbnQoKSk7CisgICAgICAgIGlmIChqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09ICBJSmF2YUVsZW1lbnQuTUVUSE9EKSB7CisgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IChJTWV0aG9kKSBqYXZhRWxlbWVudDsKKyAgICAgICAgICAgIHJldHVybiBoYXNEb2N1bWVudEJhcmVTT0FQQmluZGluZyhtZXRob2QuZ2V0RGVjbGFyaW5nVHlwZSgpKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogCiAKLSAgICBwcml2YXRlIFN0cmluZyBnZXRXZWJNZXRob2RPcGVyYXRpb25OYW1lKE1ldGhvZERlY2xhcmF0aW9uIG1ldGhvZERlY2xhcmF0aW9uKSB7Ci0gICAgICAgIG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihtZXRob2REZWNsYXJhdGlvbiwKKyAgICBwcml2YXRlIFN0cmluZyBnZXRXZWJNZXRob2RPcGVyYXRpb25OYW1lKElNZXRob2QgbWV0aG9kKSB7CisgICAgICAgIG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihtZXRob2QsCiAgICAgICAgICAgICAgICAgV2ViTWV0aG9kLmNsYXNzKTsKICAgICAgICAgaWYgKGFubm90YXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgU3RyaW5nIG9wZXJhdGlvbk5hbWUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgT1BFUkFUSU9OX05BTUUpOwpAQCAtMTk0LDcgKzE4NSw3IEBACiAgICAgICAgICAgICAgICAgcmV0dXJuIG9wZXJhdGlvbk5hbWU7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KLSAgICAgICAgcmV0dXJuIG1ldGhvZERlY2xhcmF0aW9uLmdldE5hbWUoKS5nZXRJZGVudGlmaWVyKCk7CisgICAgICAgIHJldHVybiBtZXRob2QuZ2V0RWxlbWVudE5hbWUoKTsKICAgICB9CiAKIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vV2ViUmVzdWx0QXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvYW5ub3RhdGlvbnMvaW5pdGlhbGl6YXRpb24vV2ViUmVzdWx0QXR0cmlidXRlSW5pdGlhbGl6ZXIuamF2YQppbmRleCA1NGRkN2ZhLi5iZGY1OTY0IDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL2Fubm90YXRpb25zL2luaXRpYWxpemF0aW9uL1dlYlJlc3VsdEF0dHJpYnV0ZUluaXRpYWxpemVyLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS9hbm5vdGF0aW9ucy9pbml0aWFsaXphdGlvbi9XZWJSZXN1bHRBdHRyaWJ1dGVJbml0aWFsaXplci5qYXZhCkBAIC05OSw3ICs5OSw3IEBACiAKICAgICBwcml2YXRlIFN0cmluZyBnZXRPcGVyYXRpb25OYW1lKElNZXRob2QgbWV0aG9kKSB7CiAgICAgICAgIHRyeSB7Ci0gICAgICAgICAgICBJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24obWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpOworICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKFdlYk1ldGhvZC5jbGFzcywgbWV0aG9kKTsKICAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgICAgICBTdHJpbmcgb3BlcmF0aW9uTmFtZSA9IEFubm90YXRpb25VdGlscy5nZXRTdHJpbmdWYWx1ZShhbm5vdGF0aW9uLCBPUEVSQVRJT05fTkFNRSk7CiAgICAgICAgICAgICAgICAgaWYgKG9wZXJhdGlvbk5hbWUgIT0gbnVsbCkgewpAQCAtMTA3LDE0ICsxMDcsMTQgQEAKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKLSAgICAgICAgCUpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CisgICAgICAgICAgICBKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAgICAgICAgIHJldHVybiBtZXRob2QuZ2V0RWxlbWVudE5hbWUoKTsKICAgICB9CiAKICAgICBwcml2YXRlIGJvb2xlYW4gaGFzRG9jdW1lbnRCYXJlU09BUEJpbmRpbmcoSUFubm90YXRhYmxlIGFubm90YXRhYmxlKSB7CiAgICAgICAgIHRyeSB7Ci0gICAgICAgICAgICBJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24oYW5ub3RhdGFibGUsIFNPQVBCaW5kaW5nLmNsYXNzKTsKKyAgICAgICAgICAgIElBbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihTT0FQQmluZGluZy5jbGFzcywgYW5ub3RhdGFibGUpOwogICAgICAgICAgICAgaWYgKGFubm90YXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgICAgIHJldHVybiBKQVhXU1V0aWxzLmlzRG9jdW1lbnRCYXJlKGFubm90YXRpb24pOwogICAgICAgICAgICAgfQpAQCAtMTIzLDE0ICsxMjMsMTQgQEAKICAgICAgICAgICAgICAgICByZXR1cm4gaGFzRG9jdW1lbnRCYXJlU09BUEJpbmRpbmcoKElUeXBlKSBtZXRob2QuZ2V0UGFyZW50KCkpOwogICAgICAgICAgICAgfQogICAgICAgICB9IGNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gam1lKSB7Ci0gICAgICAgIAlKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOworICAgICAgICAgICAgSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogICAKICAgICBwcml2YXRlIFN0cmluZyBnZXRQYXJ0TmFtZShJTWV0aG9kIG1ldGhvZCkgewogICAgICAgICB0cnkgewotICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKG1ldGhvZCwgV2ViUmVzdWx0LmNsYXNzKTsKKyAgICAgICAgICAgIElBbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihXZWJSZXN1bHQuY2xhc3MsIG1ldGhvZCk7CiAgICAgICAgICAgICBpZiAoYW5ub3RhdGlvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgU3RyaW5nIG5hbWUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgTkFNRSk7CiAgICAgICAgICAgICAgICAgaWYgKG5hbWUgIT0gbnVsbCkgewpAQCAtMTM4LDcgKzEzOCw3IEBACiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQogICAgICAgICB9IGNhdGNoIChKYXZhTW9kZWxFeGNlcHRpb24gam1lKSB7Ci0gICAgICAgIAlKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOworICAgICAgICAgICAgSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZ2V0TmFtZShtZXRob2QpOwogICAgIH0KQEAgLTE1Miw3ICsxNTIsNyBAQAogCiAgICAgcHJpdmF0ZSBib29sZWFuIGhhc0RvY3VtZW50V3JhcHBlZFNPQVBCaW5kaW5nKElBbm5vdGF0YWJsZSBhbm5vdGF0YWJsZSkgewogICAgICAgICB0cnkgewotICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKGFubm90YXRhYmxlLCBTT0FQQmluZGluZy5jbGFzcyk7CisgICAgICAgICAgICBJQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24oU09BUEJpbmRpbmcuY2xhc3MsIGFubm90YXRhYmxlKTsKICAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uICE9IG51bGwpIHsKICAgICAgICAgICAgICAgICByZXR1cm4gSkFYV1NVdGlscy5pc0RvY3VtZW50V3JhcHBlZChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIH0KQEAgLTE2MSwxNCArMTYxLDE0IEBACiAgICAgICAgICAgICAgICAgcmV0dXJuIGhhc0RvY3VtZW50V3JhcHBlZFNPQVBCaW5kaW5nKChJVHlwZSkgbWV0aG9kLmdldFBhcmVudCgpKTsKICAgICAgICAgICAgIH0KICAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewotICAgICAgICAJSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKKyAgICAgICAgICAgIEpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQogICAgIAogICAgIHByaXZhdGUgYm9vbGVhbiBpc0hlYWRlcihJTWV0aG9kIG1ldGhvZCkgewogICAgICAgICB0cnkgewotICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKG1ldGhvZCwgV2ViUmVzdWx0LmNsYXNzKTsKKyAgICAgICAgICAgIElBbm5vdGF0aW9uIGFubm90YXRpb24gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihXZWJSZXN1bHQuY2xhc3MsIG1ldGhvZCk7CiAgICAgICAgICAgICBpZiAoYW5ub3RhdGlvbiAhPSBudWxsKSB7CiAgICAgICAgICAgICAgICAgQm9vbGVhbiBoZWFkZXIgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0Qm9vbGVhblZhbHVlKGFubm90YXRpb24sIEhFQURFUik7CiAgICAgICAgICAgICAgICAgaWYgKGhlYWRlciAhPSBudWxsKSB7CkBAIC0xNzYsNyArMTc2LDcgQEAKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKLSAgICAgICAgCUpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CisgICAgICAgICAgICBKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CkBAIC0xODQsNyArMTg0LDcgQEAKICAgICBwcml2YXRlIFN0cmluZyBnZXREZWZhdWx0VGFyZ2V0TmFtZXNwYWNlKElNZXRob2QgbWV0aG9kKSB7CiAgICAgICAgIElUeXBlIHR5cGUgPSBtZXRob2QuZ2V0RGVjbGFyaW5nVHlwZSgpOwogICAgICAgICB0cnkgewotICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKHR5cGUsIFdlYlNlcnZpY2UuY2xhc3MpOworICAgICAgICAgICAgSUFubm90YXRpb24gYW5ub3RhdGlvbiA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKFdlYlNlcnZpY2UuY2xhc3MsIHR5cGUpOwogICAgICAgICAgICAgaWYgKGFubm90YXRpb24gIT0gbnVsbCkgewogICAgICAgICAgICAgICAgIFN0cmluZyB0YXJnZXROYW1lc3BhY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0U3RyaW5nVmFsdWUoYW5ub3RhdGlvbiwgVEFSR0VUX05BTUVTUEFDRSk7CiAgICAgICAgICAgICAgICAgaWYgKHRhcmdldE5hbWVzcGFjZSAhPSBudWxsKSB7CkBAIC0xOTIsNyArMTkyLDcgQEAKICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICB9CiAgICAgICAgIH0gY2F0Y2ggKEphdmFNb2RlbEV4Y2VwdGlvbiBqbWUpIHsKLSAgICAgICAgCUpBWFdTVUlQbHVnaW4ubG9nKGptZS5nZXRTdGF0dXMoKSk7CisgICAgICAgICAgICBKQVhXU1VJUGx1Z2luLmxvZyhqbWUuZ2V0U3RhdHVzKCkpOwogICAgICAgICB9CiAKICAgICAgICAgcmV0dXJuIEpEVFV0aWxzLmdldFRhcmdldE5hbWVzcGFjZUZyb21QYWNrYWdlTmFtZShnZXRQYWNrYWdlTmFtZSh0eXBlKSk7CmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL3ZpZXdzL0Fubm90YXRpb25zVmFsdWVzRWRpdGluZ1N1cHBvcnQuamF2YSBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvdmlld3MvQW5ub3RhdGlvbnNWYWx1ZXNFZGl0aW5nU3VwcG9ydC5qYXZhCmluZGV4IDQ3MTFhNTIuLjE1MDI3ZDMgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvdmlld3MvQW5ub3RhdGlvbnNWYWx1ZXNFZGl0aW5nU3VwcG9ydC5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvdmlld3MvQW5ub3RhdGlvbnNWYWx1ZXNFZGl0aW5nU3VwcG9ydC5qYXZhCkBAIC0yOSw3ICsyOSw2IEBACiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkFubm90YXRpb247CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLkNvbXBpbGF0aW9uVW5pdDsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uRXhwcmVzc2lvbjsKLWltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uSUV4dGVuZGVkTW9kaWZpZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLk1lbWJlclZhbHVlUGFpcjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uTm9ybWFsQW5ub3RhdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uU2luZ2xlTWVtYmVyQW5ub3RhdGlvbjsKQEAgLTUyLDExICs1MSwxMiBAQAogaW1wb3J0IG9yZy5lY2xpcHNlLmx0ay5jb3JlLnJlZmFjdG9yaW5nLlJlZmFjdG9yaW5nQ29yZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5SZWZhY3RvcmluZ1N0YXR1czsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5UZXh0RmlsZUNoYW5nZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS50ZXh0LmVkaXRzLk11bHRpVGV4dEVkaXQ7CiAKIHB1YmxpYyBjbGFzcyBBbm5vdGF0aW9uc1ZhbHVlc0VkaXRpbmdTdXBwb3J0IGV4dGVuZHMgRWRpdGluZ1N1cHBvcnQgewogICAgIHByaXZhdGUgQW5ub3RhdGlvbnNWaWV3IGFubm90YXRpb25zVmlldzsKICAgICBwcml2YXRlIFRyZWVWaWV3ZXIgdHJlZVZpZXdlcjsKLSAgICAKKwogICAgIHByaXZhdGUgVGV4dENlbGxFZGl0b3IgdGV4dENlbGxFZGl0b3I7CiAgICAgcHJpdmF0ZSBDaGVja2JveENlbGxFZGl0b3IgY2hlY2tib3hDZWxsRWRpdG9yOwogICAgIHByaXZhdGUgQ29tYm9Cb3hDZWxsRWRpdG9yIGNvbWJvQm94Q2VsbEVkaXRvcjsKQEAgLTEwMywxMSArMTAzLDExIEBACiAgICAgICAgICAgICBpZiAocmV0dXJuVHlwZS5lcXVhbHMoQm9vbGVhbi5UWVBFKSkgewogICAgICAgICAgICAgICAgIHJldHVybiBjaGVja2JveENlbGxFZGl0b3I7CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuZXF1YWxzKENsYXNzLmNsYXNzKSkgewogICAgICAgICAgICAgICAgIHJldHVybiBjbGFzc0RpYWxvZ0NlbGxFZGl0b3I7CiAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuaXNBcnJheSgpKSB7CiAgICAgICAgICAgICAgICAgYW5ub3RhdGlvbkFycmF5Q2VsbEVkaXRvci5zZXRNZXRob2QobWV0aG9kKTsKICAgICAgICAgICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkFycmF5Q2VsbEVkaXRvcjsKQEAgLTEzNSw3ICsxMzUsNyBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBEb3VibGUucGFyc2VEb3VibGUoKFN0cmluZykgdmFsdWUpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgIH0gY2F0Y2ggKE51bWJlckZvcm1hdEV4Y2VwdGlvbiBuZmUpIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gSkFYV1NVSU1lc3NhZ2VzLkFOTk9UQVRJT05fRURJVElOR19TVVBQT1JUX05PVF9WQUxJRF9NRVNTQUdFX1BSRUZJWCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gSkFYV1NVSU1lc3NhZ2VzLkFOTk9UQVRJT05fRURJVElOR19TVVBQT1JUX05PVF9WQUxJRF9NRVNTQUdFX1BSRUZJWAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICArIHJldHVyblR5cGUuZ2V0U2ltcGxlTmFtZSgpOwogICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG51bGw7CkBAIC0xNDcsNyArMTQ3LDcgQEAKICAgICAgICAgfQogICAgICAgICByZXR1cm4gY2hlY2tib3hDZWxsRWRpdG9yOwogICAgIH0KLSAgICAKKwogICAgIEBPdmVycmlkZQogICAgIHByb3RlY3RlZCBPYmplY3QgZ2V0VmFsdWUoT2JqZWN0IGVsZW1lbnQpIHsKICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBDbGFzcykgewpAQCAtMTU4LDE0ICsxNTgsMTQgQEAKICAgICAgICAgfQogICAgICAgICByZXR1cm4gbnVsbDsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIE9iamVjdCBnZXRWYWx1ZUZvckNsYXNzKENsYXNzPD8+IGFDbGFzcykgewogICAgICAgICBpZiAodHJlZVZpZXdlci5nZXRJbnB1dCgpIGluc3RhbmNlb2YgSUFubm90YXRhYmxlKSB7CiAgICAgICAgICAgICByZXR1cm4gZ2V0VmFsdWVGb3JDbGFzcyhhQ2xhc3MsIChJQW5ub3RhdGFibGUpIHRyZWVWaWV3ZXIuZ2V0SW5wdXQoKSk7CiAgICAgICAgIH0KICAgICAgICAgcmV0dXJuIEJvb2xlYW4uRkFMU0U7CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSBPYmplY3QgZ2V0VmFsdWVGb3JDbGFzcyhDbGFzczw/PiBhQ2xhc3MsIElBbm5vdGF0YWJsZSBhbm5vdGF0ZWRFbGVtZW50KSB7CiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICBJQW5ub3RhdGlvbltdIGFubm90YXRpb25zID0gYW5ub3RhdGVkRWxlbWVudC5nZXRBbm5vdGF0aW9ucygpOwpAQCAtMTc5LDEwICsxNzksMTAgQEAKICAgICAgICAgICAgIH0KICAgICAgICAgfSBjYXRjaCAoSmF2YU1vZGVsRXhjZXB0aW9uIGptZSkgewogICAgICAgICAgICAgSkFYV1NVSVBsdWdpbi5sb2coam1lLmdldFN0YXR1cygpKTsKLSAgICAgICAgfSAKKyAgICAgICAgfQogICAgICAgICByZXR1cm4gQm9vbGVhbi5GQUxTRTsKICAgICB9Ci0gICAgCisKICAgICBwcml2YXRlIE9iamVjdCBnZXRWYWx1ZUZvck1ldGhvZChNZXRob2QgbWV0aG9kKSB7CiAgICAgICAgIE9iamVjdCB2YWx1ZSA9IG51bGw7CiAgICAgICAgIHRyeSB7CkBAIC0xOTQsNyArMTk0LDcgQEAKICAgICAgICAgfQogICAgICAgICByZXR1cm4gdmFsdWU7CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSBPYmplY3QgZ2V0VmFsdWVGb3JNZXRob2QoTWV0aG9kIG1ldGhvZCwgSUFubm90YXRhYmxlIGFubm90YXRlZEVsZW1lbnQpIHRocm93cyBKYXZhTW9kZWxFeGNlcHRpb24gewogICAgICAgICBDbGFzczw/PiByZXR1cm5UeXBlID0gbWV0aG9kLmdldFJldHVyblR5cGUoKTsKICAgICAgICAgSUFubm90YXRpb25bXSBhbm5vdGF0aW9ucyA9IGFubm90YXRlZEVsZW1lbnQuZ2V0QW5ub3RhdGlvbnMoKTsKQEAgLTIyNCw3ICsyMjQsNyBAQAogICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHJldHVyblR5cGUuZXF1YWxzKENsYXNzLmNsYXNzKSkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBtZW1iZXJWYWx1ZVBhaXIuZ2V0VmFsdWUoKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAgICAgICAgIAorCiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAocmV0dXJuVHlwZS5lcXVhbHMoQm9vbGVhbi5UWVBFKSkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBtZW1iZXJWYWx1ZVBhaXIuZ2V0VmFsdWUoKTsKICAgICAgICAgICAgICAgICAgICAgICAgIH0KQEAgLTI1MCw3ICsyNTAsNyBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgT2JqZWN0IGdldERlZmF1bHRWYWx1ZUZvck1ldGhvZChDbGFzczw/PiByZXR1cm5UeXBlKSB7CiAgICAgICAgIGlmIChyZXR1cm5UeXBlLmVxdWFscyhTdHJpbmcuY2xhc3MpKSB7CiAgICAgICAgICAgICByZXR1cm4gIiI7IC8vJE5PTi1OTFMtMSQKQEAgLTI2OSw3ICsyNjksNyBAQAogICAgICAgICB9CiAgICAgICAgIHJldHVybiBudWxsOwogICAgIH0KLSAgICAgICAgCisKICAgICBAT3ZlcnJpZGUKICAgICBwcm90ZWN0ZWQgdm9pZCBzZXRWYWx1ZShPYmplY3QgZWxlbWVudCwgT2JqZWN0IHZhbHVlKSB7CiAgICAgICAgIGlmICh2YWx1ZSA9PSBudWxsKSB7CkBAIC0yNzgsOSArMjc4LDkgQEAKIAogICAgICAgICB0cnkgewogICAgICAgICAgICAgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBDbGFzcykgewotICAgICAgICAgICAgICAgIENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MgPSAKKyAgICAgICAgICAgICAgICBDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbkNsYXNzID0KICAgICAgICAgICAgICAgICAgICAgQW5ub3RhdGlvbnNNYW5hZ2VyLmdldEFubm90YXRpb25EZWZpbml0aW9uRm9yQ2xhc3MoZWxlbWVudCkuZ2V0QW5ub3RhdGlvbkNsYXNzKCk7Ci0gICAgICAgICAgICAgICAgCisKICAgICAgICAgICAgICAgICBpZiAoYW5ub3RhdGlvbkNsYXNzICE9IG51bGwpIHsKICAgICAgICAgICAgICAgICAgICAgc2V0VmFsdWVGb3JDbGFzcyhhbm5vdGF0aW9uQ2xhc3MsIChCb29sZWFuKSB2YWx1ZSk7CiAgICAgICAgICAgICAgICAgfQpAQCAtMjkwLDUwICsyOTAsNTAgQEAKICAgICAgICAgICAgIH0KICAgICAgICAgfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBjZSkgewogICAgICAgICAgICAgSkFYV1NVSVBsdWdpbi5sb2coY2UuZ2V0U3RhdHVzKCkpOwotICAgICAgICB9IAorICAgICAgICB9CiAgICAgfQotICAgIAotICAgIHByaXZhdGUgdm9pZCBzZXRWYWx1ZUZvckNsYXNzKENsYXNzPD8gZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MsIAorCisgICAgcHJpdmF0ZSB2b2lkIHNldFZhbHVlRm9yQ2xhc3MoQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb25DbGFzcywKICAgICAgICAgICAgIEJvb2xlYW4gYW5ub3RhdGUpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKICAgICAgICAgT2JqZWN0IHZpZXdlcklucHV0ID0gdHJlZVZpZXdlci5nZXRJbnB1dCgpOwogCi0gICAgICAgIElBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgYW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyID0gCisgICAgICAgIElBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgYW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyID0KICAgICAgICAgICAgIEFubm90YXRpb25zTWFuYWdlci5nZXRBbm5vdGF0aW9uRGVmaW5pdGlvbkZvckNsYXNzKGFubm90YXRpb25DbGFzcykuZ2V0QW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyKCk7CiAKICAgICAgICAgaWYgKHZpZXdlcklucHV0IGluc3RhbmNlb2YgSUphdmFFbGVtZW50KSB7CiAgICAgICAgICAgICBzZXRWYWx1ZUZvckNsYXNzKGFubm90YXRpb25DbGFzcywgYW5ub3RhdGUsIChJSmF2YUVsZW1lbnQpIHZpZXdlcklucHV0LCBhbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIpOwogICAgICAgICB9CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSBBbm5vdGF0aW9uIGdldEFubm90YXRpb24oQVNUIGFzdCwgQ2xhc3M8PyBleHRlbmRzIGphdmEubGFuZy5hbm5vdGF0aW9uLkFubm90YXRpb24+IGFubm90YXRpb25DbGFzcywKLSAgICAJCUxpc3Q8TWVtYmVyVmFsdWVQYWlyPiBtZW1iZXJWYWx1ZVBhaXJzKSB7Ci0gICAgCQotICAgIAlBbm5vdGF0aW9uIGFubm90YXRpb24gPSAgbnVsbDsKLSAgICAJaW50IG51bWJlck9mRGVjbGFyZWRNZXRob2RzID0gYW5ub3RhdGlvbkNsYXNzLmdldERlY2xhcmVkTWV0aG9kcygpLmxlbmd0aDsKLSAgICAJaWYgKG51bWJlck9mRGVjbGFyZWRNZXRob2RzID09IDApIHsKLSAgICAJCWFubm90YXRpb24gPSBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTWFya2VyQW5ub3RhdGlvbihhc3QsIGFubm90YXRpb25DbGFzcy5nZXRTaW1wbGVOYW1lKCkpOwotICAgIAl9IGVsc2UgaWYgKG51bWJlck9mRGVjbGFyZWRNZXRob2RzID09IDEpIHsKLSAgICAJCUV4cHJlc3Npb24gdmFsdWUgPSBudWxsOwotCQkJaWYgKG1lbWJlclZhbHVlUGFpcnMgIT0gbnVsbCAmJiBtZW1iZXJWYWx1ZVBhaXJzLnNpemUoKSA9PSAxKSB7Ci0gICAgCQkJTWVtYmVyVmFsdWVQYWlyIG1lbWJlclZhbHVlUGFpciA9IG1lbWJlclZhbHVlUGFpcnMuZ2V0KDApOwotICAgICAgICAJCWlmIChtZW1iZXJWYWx1ZVBhaXIgIT0gbnVsbCkgewotICAgICAgICAJCQl2YWx1ZSA9IG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpOwotICAgICAgICAJCX0KLSAgICAJCX0KLQkJCWlmICh2YWx1ZSAhPSBudWxsKSB7Ci0JCQkJYW5ub3RhdGlvbiA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKGFzdCwgYW5ub3RhdGlvbkNsYXNzLmdldFNpbXBsZU5hbWUoKSwgdmFsdWUpOwotCQkJfSBlbHNlIHsKLSAgICAJICAgICAgICBhbm5vdGF0aW9uID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZU5vcm1hbEFubm90YXRpb24oYXN0LCBhbm5vdGF0aW9uQ2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBtZW1iZXJWYWx1ZVBhaXJzKTsKLQkJCX0KLQkJfSBlbHNlIGlmIChudW1iZXJPZkRlY2xhcmVkTWV0aG9kcyA+IDEpIHsKLSAgICAJCWFubm90YXRpb24gPSBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTm9ybWFsQW5ub3RhdGlvbihhc3QsIGFubm90YXRpb25DbGFzcy5nZXRTaW1wbGVOYW1lKCksIG1lbWJlclZhbHVlUGFpcnMpOwotICAgIAl9Ci0gICAgCQotCQlyZXR1cm4gYW5ub3RhdGlvbjsKLQl9CisgICAgICAgICAgICBMaXN0PE1lbWJlclZhbHVlUGFpcj4gbWVtYmVyVmFsdWVQYWlycykgeworCisgICAgICAgIEFubm90YXRpb24gYW5ub3RhdGlvbiA9ICBudWxsOworICAgICAgICBpbnQgbnVtYmVyT2ZEZWNsYXJlZE1ldGhvZHMgPSBhbm5vdGF0aW9uQ2xhc3MuZ2V0RGVjbGFyZWRNZXRob2RzKCkubGVuZ3RoOworICAgICAgICBpZiAobnVtYmVyT2ZEZWNsYXJlZE1ldGhvZHMgPT0gMCkgeworICAgICAgICAgICAgYW5ub3RhdGlvbiA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVNYXJrZXJBbm5vdGF0aW9uKGFzdCwgYW5ub3RhdGlvbkNsYXNzLmdldFNpbXBsZU5hbWUoKSk7CisgICAgICAgIH0gZWxzZSBpZiAobnVtYmVyT2ZEZWNsYXJlZE1ldGhvZHMgPT0gMSkgeworICAgICAgICAgICAgRXhwcmVzc2lvbiB2YWx1ZSA9IG51bGw7CisgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlycyAhPSBudWxsICYmIG1lbWJlclZhbHVlUGFpcnMuc2l6ZSgpID09IDEpIHsKKyAgICAgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyID0gbWVtYmVyVmFsdWVQYWlycy5nZXQoMCk7CisgICAgICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpciAhPSBudWxsKSB7CisgICAgICAgICAgICAgICAgICAgIHZhbHVlID0gbWVtYmVyVmFsdWVQYWlyLmdldFZhbHVlKCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICAgICAgaWYgKHZhbHVlICE9IG51bGwpIHsKKyAgICAgICAgICAgICAgICBhbm5vdGF0aW9uID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVNpbmdsZU1lbWJlckFubm90YXRpb24oYXN0LCBhbm5vdGF0aW9uQ2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCB2YWx1ZSk7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIGFubm90YXRpb24gPSBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTm9ybWFsQW5ub3RhdGlvbihhc3QsIGFubm90YXRpb25DbGFzcy5nZXRTaW1wbGVOYW1lKCksIG1lbWJlclZhbHVlUGFpcnMpOworICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYgKG51bWJlck9mRGVjbGFyZWRNZXRob2RzID4gMSkgeworICAgICAgICAgICAgYW5ub3RhdGlvbiA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVOb3JtYWxBbm5vdGF0aW9uKGFzdCwgYW5ub3RhdGlvbkNsYXNzLmdldFNpbXBsZU5hbWUoKSwgbWVtYmVyVmFsdWVQYWlycyk7CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4gYW5ub3RhdGlvbjsKKyAgICB9CiAKICAgICBwcml2YXRlIHZvaWQgc2V0VmFsdWVGb3JDbGFzcyhDbGFzczw/IGV4dGVuZHMgamF2YS5sYW5nLmFubm90YXRpb24uQW5ub3RhdGlvbj4gYW5ub3RhdGlvbkNsYXNzLAotICAgICAgICAgICAgQm9vbGVhbiBhbm5vdGF0ZSwgSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBJQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplcikgCisgICAgICAgICAgICBCb29sZWFuIGFubm90YXRlLCBJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIElBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgYW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyKQogICAgICAgICAgICAgICAgIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKICAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0Q29tcGlsYXRpb25Vbml0RnJvbUphdmFFbGVtZW50KGphdmFFbGVtZW50KTsKICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IFNoYXJlZEFTVFByb3ZpZGVyLmdldEFTVChzb3VyY2UsIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKQEAgLTM0NCwzMiArMzQ0LDM0IEBACiAKICAgICAgICAgQW5ub3RhdGlvbiBhbm5vdGF0aW9uID0gZ2V0QW5ub3RhdGlvbihhc3QsIGFubm90YXRpb25DbGFzcywgbWVtYmVyVmFsdWVQYWlycyk7CiAKLSAgICAgICAgVGV4dEZpbGVDaGFuZ2UgdGV4dEZpbGVDaGFuZ2UgPSBBbm5vdGF0aW9uVXRpbHMuY3JlYXRlVGV4dEZpbGVDaGFuZ2UoIkFDIiwgKElGaWxlKSBzb3VyY2UuZ2V0UmVzb3VyY2UoKSk7IC8vJE5PTi1OTFMtMSQKKyAgICAgICAgVGV4dEZpbGVDaGFuZ2UgY2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJBZGQvUmVtb3ZlIEFubm90YXRpb24iLCAoSUZpbGUpIHNvdXJjZS5nZXRSZXNvdXJjZSgpKTsgLy8kTk9OLU5MUy0xJAorICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOworICAgICAgICBjaGFuZ2Uuc2V0RWRpdChtdWx0aVRleHRFZGl0KTsKIAogICAgICAgICBpZiAoYW5ub3RhdGUpIHsKLSAgICAgICAgCWlmIChqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5QQUNLQUdFX0RFQ0xBUkFUSU9OCi0gICAgICAgIAkJCXx8IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LlRZUEUKLSAgICAgICAgCQkJfHwgamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuRklFTEQKLSAgICAgICAgCQkJfHwgamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTUVUSE9ECi0gICAgICAgIAkJCXx8IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LkxPQ0FMX1ZBUklBQkxFKSB7Ci0gICAgICAgIAkJdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KGphdmFFbGVtZW50LCBhbm5vdGF0aW9uKSk7Ci0gICAgICAgIAkJdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoamF2YUVsZW1lbnQsIGFubm90YXRpb25DbGFzcykpOwotICAgICAgICAJfQorICAgICAgICAgICAgaWYgKGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LlBBQ0tBR0VfREVDTEFSQVRJT04KKyAgICAgICAgICAgICAgICAgICAgfHwgamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuVFlQRQorICAgICAgICAgICAgICAgICAgICB8fCBqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5GSUVMRAorICAgICAgICAgICAgICAgICAgICB8fCBqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5NRVRIT0QKKyAgICAgICAgICAgICAgICAgICAgfHwgamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTE9DQUxfVkFSSUFCTEUpIHsKKyAgICAgICAgICAgICAgICBjaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KGphdmFFbGVtZW50LCBhbm5vdGF0aW9uKSk7CisgICAgICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KGphdmFFbGVtZW50LCBhbm5vdGF0aW9uQ2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CisgICAgICAgICAgICB9CiAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgIAlpZiAoamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuUEFDS0FHRV9ERUNMQVJBVElPTgotICAgICAgICAJCQl8fCBqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5UWVBFCi0gICAgICAgIAkJCXx8IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LkZJRUxECi0gICAgICAgIAkJCXx8IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50Lk1FVEhPRAotICAgICAgICAJCQl8fCBqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5MT0NBTF9WQVJJQUJMRSkgewotICAgICAgICAgICAgCXRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVJlbW92ZUFubm90YXRpb25UZXh0RWRpdChqYXZhRWxlbWVudCwgYW5ub3RhdGlvbikpOwotICAgICAgICAJCXRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVJlbW92ZUltcG9ydFRleHRFZGl0KGphdmFFbGVtZW50LCBhbm5vdGF0aW9uQ2xhc3MpKTsKLSAgICAgICAgCX0KKyAgICAgICAgICAgIGlmIChqYXZhRWxlbWVudC5nZXRFbGVtZW50VHlwZSgpID09IElKYXZhRWxlbWVudC5QQUNLQUdFX0RFQ0xBUkFUSU9OCisgICAgICAgICAgICAgICAgICAgIHx8IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LlRZUEUKKyAgICAgICAgICAgICAgICAgICAgfHwgamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuRklFTEQKKyAgICAgICAgICAgICAgICAgICAgfHwgamF2YUVsZW1lbnQuZ2V0RWxlbWVudFR5cGUoKSA9PSBJSmF2YUVsZW1lbnQuTUVUSE9ECisgICAgICAgICAgICAgICAgICAgIHx8IGphdmFFbGVtZW50LmdldEVsZW1lbnRUeXBlKCkgPT0gSUphdmFFbGVtZW50LkxPQ0FMX1ZBUklBQkxFKSB7CisgICAgICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVJlbW92ZUFubm90YXRpb25UZXh0RWRpdChqYXZhRWxlbWVudCwgYW5ub3RhdGlvbikpOworICAgICAgICAgICAgICAgIGNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVJbXBvcnRUZXh0RWRpdChqYXZhRWxlbWVudCwgYW5ub3RhdGlvbkNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOworICAgICAgICAgICAgfQogICAgICAgICB9Ci0gICAgICAgIGV4ZWN1dGVDaGFuZ2UobmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSwgdGV4dEZpbGVDaGFuZ2UpOworICAgICAgICBleGVjdXRlQ2hhbmdlKG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCksIGNoYW5nZSk7CiAgICAgfQotICAKKwogICAgIHByaXZhdGUgTGlzdDxNZW1iZXJWYWx1ZVBhaXI+IGdldE1lbWJlclZhbHVlUGFpcnMoCi0gICAgICAgICAgICBJQW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyIGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciwgSUphdmFFbGVtZW50IGphdmFFbGVtZW50LCBBU1QgYXN0LCAKKyAgICAgICAgICAgIElBbm5vdGF0aW9uQXR0cmlidXRlSW5pdGlhbGl6ZXIgYW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyLCBJSmF2YUVsZW1lbnQgamF2YUVsZW1lbnQsIEFTVCBhc3QsCiAgICAgICAgICAgICBDbGFzczw/ZXh0ZW5kcyBqYXZhLmxhbmcuYW5ub3RhdGlvbi5Bbm5vdGF0aW9uPiBhbm5vdGF0aW9uQ2xhc3MpIHsKICAgICAgICAgaWYgKGFubm90YXRpb25BdHRyaWJ1dGVJbml0aWFsaXplciAhPSBudWxsKSB7CiAgICAgICAgICAgICByZXR1cm4gYW5ub3RhdGlvbkF0dHJpYnV0ZUluaXRpYWxpemVyLmdldE1lbWJlclZhbHVlUGFpcnMoamF2YUVsZW1lbnQsIGFzdCwgYW5ub3RhdGlvbkNsYXNzKTsKQEAgLTM4Myw2MiArMzg1LDY1IEBACiAgICAgICAgICAgICBPYmplY3Qgdmlld2VySW5wdXQgPSB0cmVlVmlld2VyLmdldElucHV0KCk7CiAgICAgICAgICAgICBpZiAodmlld2VySW5wdXQgaW5zdGFuY2VvZiBJQW5ub3RhdGFibGUpIHsKICAgICAgICAgICAgICAgICBzZXRWYWx1ZUZvck1ldGhvZChtZXRob2QsIHZhbHVlLCAoSUphdmFFbGVtZW50KSB2aWV3ZXJJbnB1dCk7Ci0gICAgICAgICAgICB9IAorICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgfQotICAgIAorCiAgICAgcHJpdmF0ZSB2b2lkIHNldFZhbHVlRm9yTWV0aG9kKE1ldGhvZCBtZXRob2QsIE9iamVjdCB2YWx1ZSwgSUphdmFFbGVtZW50IGphdmFFbGVtZW50KSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7Ci0gICAgICAgIElDb21waWxhdGlvblVuaXQgc291cmNlID0gQW5ub3RhdGlvblV0aWxzLmdldENvbXBpbGF0aW9uVW5pdEZyb21KYXZhRWxlbWVudChqYXZhRWxlbWVudCk7ICAgICAgICAKKyAgICAgICAgSUNvbXBpbGF0aW9uVW5pdCBzb3VyY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0Q29tcGlsYXRpb25Vbml0RnJvbUphdmFFbGVtZW50KGphdmFFbGVtZW50KTsKICAgICAgICAgQ29tcGlsYXRpb25Vbml0IGNvbXBpbGF0aW9uVW5pdCA9IFNoYXJlZEFTVFByb3ZpZGVyLmdldEFTVChzb3VyY2UsIFNoYXJlZEFTVFByb3ZpZGVyLldBSVRfWUVTLCBudWxsKTsKICAgICAgICAgQVNUIGFzdCA9IGNvbXBpbGF0aW9uVW5pdC5nZXRBU1QoKTsKIAotICAgICAgICBUZXh0RmlsZUNoYW5nZSB0ZXh0RmlsZUNoYW5nZSA9IEFubm90YXRpb25VdGlscy5jcmVhdGVUZXh0RmlsZUNoYW5nZSgiQUMiLCAoSUZpbGUpIHNvdXJjZS5nZXRSZXNvdXJjZSgpKTsgLy8kTk9OLU5MUy0xJAorICAgICAgICBUZXh0RmlsZUNoYW5nZSBjaGFuZ2UgPSBuZXcgVGV4dEZpbGVDaGFuZ2UoIkFkZC9VcGRhdGUgQW5ub3RhdGlvbiBWYWx1ZSIsIChJRmlsZSkgc291cmNlLmdldFJlc291cmNlKCkpOworICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOworICAgICAgICBjaGFuZ2Uuc2V0RWRpdChtdWx0aVRleHRFZGl0KTsKIAotICAgICAgICBMaXN0PElFeHRlbmRlZE1vZGlmaWVyPiBleHRlbmRlZE1vZGlmaWVycyA9IEFubm90YXRpb25VdGlscy5nZXRFeHRlbmRlZE1vZGlmaWVycyhjb21waWxhdGlvblVuaXQsIGphdmFFbGVtZW50KTsKLSAgICAgICAgZm9yIChJRXh0ZW5kZWRNb2RpZmllciBleHRlbmRlZE1vZGlmaWVyIDogZXh0ZW5kZWRNb2RpZmllcnMpIHsKLQkJCWlmIChleHRlbmRlZE1vZGlmaWVyIGluc3RhbmNlb2YgTm9ybWFsQW5ub3RhdGlvbikgewkJCQkKLQkJCQlOb3JtYWxBbm5vdGF0aW9uIG5vcm1hbEFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgZXh0ZW5kZWRNb2RpZmllcjsKLQkgICAgICAgICAgICBDbGFzczw/PiBkZWNsYXJpbmdDbGFzcyA9IG1ldGhvZC5nZXREZWNsYXJpbmdDbGFzcygpOwotCSAgICAgICAgICAgIFN0cmluZyBhbm5vdGF0aW9uTmFtZSA9IG5vcm1hbEFubm90YXRpb24uZ2V0VHlwZU5hbWUoKS5nZXRGdWxseVF1YWxpZmllZE5hbWUoKTsKLQkgICAgICAgICAgICBpZiAoYW5ub3RhdGlvbk5hbWUuZXF1YWxzKGRlY2xhcmluZ0NsYXNzLmdldFNpbXBsZU5hbWUoKSkgfHwgYW5ub3RhdGlvbk5hbWUuZXF1YWxzKGRlY2xhcmluZ0NsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpIHsKLQkgICAgICAgICAgICAJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCi0JICAgICAgICAgICAgCUxpc3Q8TWVtYmVyVmFsdWVQYWlyPiBtZW1iZXJWYWx1ZVBhaXJzID0gbm9ybWFsQW5ub3RhdGlvbi52YWx1ZXMoKTsKLQkgICAgICAgICAgICAJYm9vbGVhbiBoYXNNZW1iZXJWYWx1ZVBhaXIgPSBmYWxzZTsKLQkgICAgICAgICAgICAgICAgZm9yIChNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyIDogbWVtYmVyVmFsdWVQYWlycykgewotCSAgICAgICAgICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpci5nZXROYW1lKCkuZ2V0SWRlbnRpZmllcigpLmVxdWFscyhtZXRob2QuZ2V0TmFtZSgpKSkgewotCSAgICAgICAgICAgICAgICAgICAgCUFTVE5vZGUgbWVtYmVyVmFsdWUgPSBnZXRNZW1iZXJWYWx1ZVBhaXJWYWx1ZShhc3QsIG1ldGhvZCwgdmFsdWUpOwotCSAgICAgICAgICAgICAgICAgICAgICAgIGlmIChtZW1iZXJWYWx1ZSAhPSBudWxsKSB7Ci0JICAgICAgICAgICAgICAgICAgICAgICAgCXRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVVwZGF0ZU1lbWJlclZhbHVlUGFpclRleHRFZGl0KG1lbWJlclZhbHVlUGFpciwgbWVtYmVyVmFsdWUpKTsKLQkgICAgICAgICAgICAgICAgICAgICAgICAJaGFzTWVtYmVyVmFsdWVQYWlyID0gdHJ1ZTsKLQkgICAgICAgICAgICAgICAgICAgICAgICAJYnJlYWs7Ci0JICAgICAgICAgICAgICAgICAgICAgICAgfQotCSAgICAgICAgICAgICAgICAgICAgfQkJCi0JCQkJCX0KLQkgICAgICAgICAgICAgICAgaWYgKCFoYXNNZW1iZXJWYWx1ZVBhaXIpIHsKLQkgICAgICAgICAgICAgICAgCU1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIgPSBnZXRNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZXRob2QsIHZhbHVlKTsKLQkgICAgICAgICAgICAgICAgICAgIGlmIChtZW1iZXJWYWx1ZVBhaXIgIT0gbnVsbCkgewotCSAgICAgICAgICAgICAgICAgICAgCXRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZE1lbWJlclZhbHVlUGFpclRleHRFZGl0KG5vcm1hbEFubm90YXRpb24sIG1lbWJlclZhbHVlUGFpcikpOwotCSAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOwotCSAgICAgICAgICAgICAgICAgICAgfQotCSAgICAgICAgICAgICAgICB9Ci0JICAgICAgICAgICAgfQotCQkJfSBlbHNlIGlmIChleHRlbmRlZE1vZGlmaWVyIGluc3RhbmNlb2YgU2luZ2xlTWVtYmVyQW5ub3RhdGlvbikgewotCQkJCVNpbmdsZU1lbWJlckFubm90YXRpb24gc2luZ2xlTWVtYmVyQW5ub3RhdGlvbiA9IChTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKSBleHRlbmRlZE1vZGlmaWVyOwotCQkJCUNsYXNzPD8+IGRlY2xhcmluZ0NsYXNzID0gbWV0aG9kLmdldERlY2xhcmluZ0NsYXNzKCk7Ci0JICAgICAgICAgICAgU3RyaW5nIGFubm90YXRpb25OYW1lID0gc2luZ2xlTWVtYmVyQW5ub3RhdGlvbi5nZXRUeXBlTmFtZSgpLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgpOwotCSAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uTmFtZS5lcXVhbHMoZGVjbGFyaW5nQ2xhc3MuZ2V0U2ltcGxlTmFtZSgpKSB8fCBhbm5vdGF0aW9uTmFtZS5lcXVhbHMoZGVjbGFyaW5nQ2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSkgewotCSAgICAgICAgICAgIAlNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyID0gZ2V0TWVtYmVyVmFsdWVQYWlyKGFzdCwgbWV0aG9kLCB2YWx1ZSk7Ci0JICAgICAgICAgICAgCWlmIChtZW1iZXJWYWx1ZVBhaXIgIT0gbnVsbCkgewotCSAgICAgICAgICAgIAkJdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlVXBkYXRlU2luZ2xlTWVtYmVyQW5ub3RhdGlvblRleHRFZGl0KHNpbmdsZU1lbWJlckFubm90YXRpb24sIG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpKSk7Ci0JICAgICAgICAgICAgCQlicmVhazsKLQkgICAgICAgICAgICAJfQotCSAgICAgICAgICAgIH0KLQkgICAgICAgICAgICAKLQkJCX0KLQkJfQotICAgICAgICBleGVjdXRlQ2hhbmdlKG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCksIHRleHRGaWxlQ2hhbmdlKTsKKyAgICAgICAgTGlzdDxBbm5vdGF0aW9uPiBhbm5vdGF0aW9ucyA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9ucyhqYXZhRWxlbWVudCk7CisgICAgICAgIGZvciAoQW5ub3RhdGlvbiBhbm5vdGF0aW9uIDogYW5ub3RhdGlvbnMpIHsKKyAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uIGluc3RhbmNlb2YgTm9ybWFsQW5ub3RhdGlvbikgeworICAgICAgICAgICAgICAgIE5vcm1hbEFubm90YXRpb24gbm9ybWFsQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSBhbm5vdGF0aW9uOworICAgICAgICAgICAgICAgIENsYXNzPD8+IGRlY2xhcmluZ0NsYXNzID0gbWV0aG9kLmdldERlY2xhcmluZ0NsYXNzKCk7CisgICAgICAgICAgICAgICAgU3RyaW5nIGFubm90YXRpb25OYW1lID0gbm9ybWFsQW5ub3RhdGlvbi5nZXRUeXBlTmFtZSgpLmdldEZ1bGx5UXVhbGlmaWVkTmFtZSgpOworICAgICAgICAgICAgICAgIGlmIChhbm5vdGF0aW9uTmFtZS5lcXVhbHMoZGVjbGFyaW5nQ2xhc3MuZ2V0U2ltcGxlTmFtZSgpKSB8fCBhbm5vdGF0aW9uTmFtZS5lcXVhbHMoZGVjbGFyaW5nQ2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSkgeworICAgICAgICAgICAgICAgICAgICBAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKKyAgICAgICAgICAgICAgICAgICAgTGlzdDxNZW1iZXJWYWx1ZVBhaXI+IG1lbWJlclZhbHVlUGFpcnMgPSBub3JtYWxBbm5vdGF0aW9uLnZhbHVlcygpOworICAgICAgICAgICAgICAgICAgICBib29sZWFuIGhhc01lbWJlclZhbHVlUGFpciA9IGZhbHNlOworICAgICAgICAgICAgICAgICAgICBmb3IgKE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIgOiBtZW1iZXJWYWx1ZVBhaXJzKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyLmdldE5hbWUoKS5nZXRJZGVudGlmaWVyKCkuZXF1YWxzKG1ldGhvZC5nZXROYW1lKCkpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgQVNUTm9kZSBtZW1iZXJWYWx1ZSA9IGdldE1lbWJlclZhbHVlUGFpclZhbHVlKGFzdCwgbWV0aG9kLCB2YWx1ZSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlICE9IG51bGwpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVVwZGF0ZU1lbWJlclZhbHVlUGFpclRleHRFZGl0KG1lbWJlclZhbHVlUGFpciwgbWVtYmVyVmFsdWUpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGFzTWVtYmVyVmFsdWVQYWlyID0gdHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIGlmICghaGFzTWVtYmVyVmFsdWVQYWlyKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWVtYmVyVmFsdWVQYWlyID0gZ2V0TWVtYmVyVmFsdWVQYWlyKGFzdCwgbWV0aG9kLCB2YWx1ZSk7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobWVtYmVyVmFsdWVQYWlyICE9IG51bGwpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkTWVtYmVyVmFsdWVQYWlyVGV4dEVkaXQobm9ybWFsQW5ub3RhdGlvbiwgbWVtYmVyVmFsdWVQYWlyKSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgaWYgKGFubm90YXRpb24gaW5zdGFuY2VvZiBTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKSB7CisgICAgICAgICAgICAgICAgU2luZ2xlTWVtYmVyQW5ub3RhdGlvbiBzaW5nbGVNZW1iZXJBbm5vdGF0aW9uID0gKFNpbmdsZU1lbWJlckFubm90YXRpb24pIGFubm90YXRpb247CisgICAgICAgICAgICAgICAgQ2xhc3M8Pz4gZGVjbGFyaW5nQ2xhc3MgPSBtZXRob2QuZ2V0RGVjbGFyaW5nQ2xhc3MoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmcgYW5ub3RhdGlvbk5hbWUgPSBzaW5nbGVNZW1iZXJBbm5vdGF0aW9uLmdldFR5cGVOYW1lKCkuZ2V0RnVsbHlRdWFsaWZpZWROYW1lKCk7CisgICAgICAgICAgICAgICAgaWYgKGFubm90YXRpb25OYW1lLmVxdWFscyhkZWNsYXJpbmdDbGFzcy5nZXRTaW1wbGVOYW1lKCkpIHx8IGFubm90YXRpb25OYW1lLmVxdWFscyhkZWNsYXJpbmdDbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKSB7CisgICAgICAgICAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBtZW1iZXJWYWx1ZVBhaXIgPSBnZXRNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZXRob2QsIHZhbHVlKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKG1lbWJlclZhbHVlUGFpciAhPSBudWxsKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBjaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlVXBkYXRlU2luZ2xlTWVtYmVyQW5ub3RhdGlvblRleHRFZGl0KHNpbmdsZU1lbWJlckFubm90YXRpb24sIG1lbWJlclZhbHVlUGFpci5nZXRWYWx1ZSgpKSk7CisgICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAgICAgZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCBjaGFuZ2UpOwogICAgIH0KLSAgICAKKwogICAgIHByaXZhdGUgQVNUTm9kZSBnZXRNZW1iZXJWYWx1ZVBhaXJWYWx1ZShBU1QgYXN0LCBNZXRob2QgbWV0aG9kLCBPYmplY3QgdmFsdWUpIHsKICAgICAgICAgQ2xhc3M8Pz4gcmV0dXJuVHlwZSA9IG1ldGhvZC5nZXRSZXR1cm5UeXBlKCk7CiAgICAgICAgIGlmIChyZXR1cm5UeXBlLmVxdWFscyhTdHJpbmcuY2xhc3MpKSB7CkBAIC00NTYsMTEgKzQ2MSwxMSBAQAogICAgICAgICBpZiAocmV0dXJuVHlwZS5pc0FycmF5KCkpIHsKICAgICAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlQXJyYXlWYWx1ZUxpdGVyYWwoYXN0LCBtZXRob2QsIChPYmplY3RbXSkgdmFsdWUpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChyZXR1cm5UeXBlLmVxdWFscyhDbGFzcy5jbGFzcykpIHsKICAgICAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlVHlwZUxpdGVyYWwoYXN0LCB2YWx1ZS50b1N0cmluZygpKTsKICAgICAgICAgfQotICAgICAgICAKKwogICAgICAgICBpZiAocmV0dXJuVHlwZS5pc0VudW0oKSkgewogICAgICAgICAgICAgaW50IHNlbGVjdGVkID0gKChJbnRlZ2VyKSB2YWx1ZSkuaW50VmFsdWUoKTsKICAgICAgICAgICAgIGlmIChzZWxlY3RlZCAhPSAtMSkgewpAQCAtNDc0LDEwICs0NzksMTAgQEAKICAgICBwcml2YXRlIE1lbWJlclZhbHVlUGFpciBnZXRNZW1iZXJWYWx1ZVBhaXIoQVNUIGFzdCwgTWV0aG9kIG1ldGhvZCwgT2JqZWN0IHZhbHVlKSB7CiAgICAgICAgIENsYXNzPD8+IHJldHVyblR5cGUgPSBtZXRob2QuZ2V0UmV0dXJuVHlwZSgpOwogICAgICAgICBpZiAocmV0dXJuVHlwZS5lcXVhbHMoU3RyaW5nLmNsYXNzKSkgewotICAgICAgICAgICAgcmV0dXJuIEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZXRob2QuZ2V0TmFtZSgpLCB2YWx1ZSk7CisgICAgICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsIG1ldGhvZC5nZXROYW1lKCksIChTdHJpbmcpIHZhbHVlKTsKICAgICAgICAgfQogICAgICAgICBpZiAocmV0dXJuVHlwZS5lcXVhbHMoQm9vbGVhbi5UWVBFKSkgewotICAgICAgICAgICAgcmV0dXJuIEFubm90YXRpb25zQ29yZS5jcmVhdGVCb29sZWFuTWVtYmVyVmFsdWVQYWlyKGFzdCwgbWV0aG9kLmdldE5hbWUoKSwgdmFsdWUpOworICAgICAgICAgICAgcmV0dXJuIEFubm90YXRpb25zQ29yZS5jcmVhdGVCb29sZWFuTWVtYmVyVmFsdWVQYWlyKGFzdCwgbWV0aG9kLmdldE5hbWUoKSwgKEJvb2xlYW4pIHZhbHVlKTsKICAgICAgICAgfQogICAgICAgICBpZiAocmV0dXJuVHlwZS5pc1ByaW1pdGl2ZSgpCiAgICAgICAgICAgICAgICAgJiYgKHJldHVyblR5cGUuZXF1YWxzKEJ5dGUuVFlQRSkgfHwgcmV0dXJuVHlwZS5lcXVhbHMoU2hvcnQuVFlQRSkKQEAgLTQ4OCw3ICs0OTMsNyBAQAogICAgICAgICBpZiAocmV0dXJuVHlwZS5pc0FycmF5KCkpIHsKICAgICAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlQXJyYXlNZW1iZXJWYWx1ZVBhaXIoYXN0LCBtZXRob2QsIChPYmplY3RbXSkgdmFsdWUpOwogICAgICAgICB9Ci0gICAgICAgIAorCiAgICAgICAgIGlmIChyZXR1cm5UeXBlLmVxdWFscyhDbGFzcy5jbGFzcykpIHsKICAgICAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlVHlwZU1lbWJlclZhbHVlUGFpcihhc3QsIG1ldGhvZC5nZXROYW1lKCksIHZhbHVlLnRvU3RyaW5nKCkpOwogICAgICAgICB9CkBAIC00OTYsNyArNTAxLDcgQEAKICAgICAgICAgaWYgKHJldHVyblR5cGUuaXNFbnVtKCkpIHsKICAgICAgICAgICAgIGludCBzZWxlY3RlZCA9ICgoSW50ZWdlcikgdmFsdWUpLmludFZhbHVlKCk7CiAgICAgICAgICAgICBpZiAoc2VsZWN0ZWQgIT0gLTEpIHsKLSAgICAgICAgICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZUVudW1NZW1iZXJWYWx1ZVBhaXIoYXN0LCAKKyAgICAgICAgICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZUVudW1NZW1iZXJWYWx1ZVBhaXIoYXN0LAogICAgICAgICAgICAgICAgICAgICAgICBtZXRob2QuZ2V0RGVjbGFyaW5nQ2xhc3MoKS5nZXRDYW5vbmljYWxOYW1lKCksIG1ldGhvZC5nZXROYW1lKCksIG1ldGhvZC5nZXRSZXR1cm5UeXBlKCkKICAgICAgICAgICAgICAgICAgICAgICAgIC5nZXRFbnVtQ29uc3RhbnRzKClbc2VsZWN0ZWRdKTsKICAgICAgICAgICAgIH0KZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvdmlld3MvQW5ub3RhdGlvbnNWaWV3Q29udGVudFByb3ZpZGVyLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy51aS9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2ludGVybmFsL2pheHdzL3VpL3ZpZXdzL0Fubm90YXRpb25zVmlld0NvbnRlbnRQcm92aWRlci5qYXZhCmluZGV4IDg5ZTJmMWYuLjRlMjMwNTYgMTAwNzU1Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLnVpL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvaW50ZXJuYWwvamF4d3MvdWkvdmlld3MvQW5ub3RhdGlvbnNWaWV3Q29udGVudFByb3ZpZGVyLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MudWkvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9pbnRlcm5hbC9qYXh3cy91aS92aWV3cy9Bbm5vdGF0aW9uc1ZpZXdDb250ZW50UHJvdmlkZXIuamF2YQpAQCAtMzYsMTEgKzM2LDExIEBACiANCiAJcHVibGljIE9iamVjdFtdIGdldEVsZW1lbnRzKE9iamVjdCBpbnB1dEVsZW1lbnQpIHsNCiAJICAgIGlmIChpbnB1dEVsZW1lbnQgIT0gbnVsbCkgew0KLQkgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc01hbmFnZXIuZ2V0QW5ub3RhdGlvbnMoaW5wdXRFbGVtZW50KTsNCisJICAgICAgICByZXR1cm4gQW5ub3RhdGlvbnNNYW5hZ2VyLmdldEFubm90YXRpb25zKGlucHV0RWxlbWVudCkudG9BcnJheSgpOw0KIAkgICAgfQ0KIAkgICAgcmV0dXJuIG5ldyBPYmplY3RbXSB7fTsNCiAJfQ0KLQkNCisNCiAJcHVibGljIHZvaWQgZGlzcG9zZSgpIHsNCiANCiAJfQ0KZGlmZiAtLWdpdCBhL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGZfdGVzdHMuZmVhdHVyZS9mZWF0dXJlLnhtbCBiL2ZlYXR1cmVzL29yZy5lY2xpcHNlLmpzdC53cy5jeGZfdGVzdHMuZmVhdHVyZS9mZWF0dXJlLnhtbAppbmRleCAyN2Q0NDZjLi5iNzc0ZDYxIDEwMDY0NAotLS0gYS9mZWF0dXJlcy9vcmcuZWNsaXBzZS5qc3Qud3MuY3hmX3Rlc3RzLmZlYXR1cmUvZmVhdHVyZS54bWwKKysrIGIvZmVhdHVyZXMvb3JnLmVjbGlwc2UuanN0LndzLmN4Zl90ZXN0cy5mZWF0dXJlL2ZlYXR1cmUueG1sCkBAIC0yOCwxNyArMjgsNCBAQAogICAgICAgICAgaW5zdGFsbC1zaXplPSIwIgogICAgICAgICAgdmVyc2lvbj0iMC4wLjAiLz4KIAotICAgPHBsdWdpbgotICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIi8+Ci0KLSAgIDxwbHVnaW4KLSAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzIgotICAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKLSAgICAgICAgIGluc3RhbGwtc2l6ZT0iMCIKLSAgICAgICAgIHZlcnNpb249IjAuMC4wIgotICAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgotCiA8L2ZlYXR1cmU+CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4Yi9jb3JlL3Rlc3RzL0Fic3RyYWN0QW5ub3RhdGlvblRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXhiLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXhiL2NvcmUvdGVzdHMvQWJzdHJhY3RBbm5vdGF0aW9uVGVzdC5qYXZhCmluZGV4IGY4ZmM5YTkuLmEwOGU2NmYgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXhiLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXhiL2NvcmUvdGVzdHMvQWJzdHJhY3RBbm5vdGF0aW9uVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXhiLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXhiL2NvcmUvdGVzdHMvQWJzdHJhY3RBbm5vdGF0aW9uVGVzdC5qYXZhCkBAIC0xOSwxMCArMTksMTAgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQ29tcGlsYXRpb25Vbml0OwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5yZXdyaXRlLkFTVFJld3JpdGU7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LnVpLlNoYXJlZEFTVFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLnV0aWxzLkFubm90YXRpb25VdGlsczsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5DaGFuZ2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UubHRrLmNvcmUucmVmYWN0b3JpbmcuUGVyZm9ybUNoYW5nZU9wZXJhdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5UZXh0RmlsZUNoYW5nZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS50ZXh0LmVkaXRzLk11bHRpVGV4dEVkaXQ7CiAKIHB1YmxpYyBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdEFubm90YXRpb25UZXN0IGV4dGVuZHMgVGVzdENhc2UgewogICAgIHByb3RlY3RlZCBUZXN0SmF2YVByb2plY3QgdGVzdEphdmFQcm9qZWN0OwpAQCAtNDUsNyArNDUsOSBAQAogICAgICAgICBhc3QgPSBjb21waWxhdGlvblVuaXQuZ2V0QVNUKCk7CiAgICAgICAgIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoYXN0KTsKICAgICAgICAgYW5ub3RhdGlvbiA9IGdldEFubm90YXRpb24oKTsKLSAgICAgICAgdGV4dEZpbGVDaGFuZ2UgPSBBbm5vdGF0aW9uVXRpbHMuY3JlYXRlVGV4dEZpbGVDaGFuZ2UoIkFDIiwgKElGaWxlKSBzb3VyY2UuZ2V0UmVzb3VyY2UoKSk7CisgICAgICAgIHRleHRGaWxlQ2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJBZGQgYW5ub3RhdGlvbiIsIChJRmlsZSkgc291cmNlLmdldFJlc291cmNlKCkpOworICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOworICAgICAgICB0ZXh0RmlsZUNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOwogICAgIH0KICAgICAKICAgICBwcm90ZWN0ZWQgYm9vbGVhbiBpc0F1dG9CdWlsZGluZ0VuYWJsZWQoKSB7CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4Yi9jb3JlL3Rlc3RzL0FkZEFubm90YXRpb25Ub1BhY2thZ2VUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4Yi9jb3JlL3Rlc3RzL0FkZEFubm90YXRpb25Ub1BhY2thZ2VUZXN0LmphdmEKaW5kZXggNjgwNWY1ZS4uMDE2ZDkxZCAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheGIuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheGIvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9QYWNrYWdlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXhiLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXhiL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvUGFja2FnZVRlc3QuamF2YQpAQCAtNDksMTAgKzQ5LDEwIEBACiAKICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIG5hbWVzcGFjZVZQID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsCiAgICAgICAgICAgICAgICAgIm5hbWVzcGFjZSIsICJ1cmk6dGVzdE5TIik7Ci0gICAgICAgIAorCiAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKGxvY2F0aW9uVlApOwogICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChuYW1lc3BhY2VWUCk7Ci0gICAgICAgIAorCiAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTm9ybWFsQW5ub3RhdGlvbihhc3QsIFhtbFNjaGVtYS5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIG1lbWJlclZhbHVlUGFpcnMpOwogICAgIH0KIApAQCAtNjIsMTAgKzYyLDEwIEBACiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoWG1sU2NoZW1hLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKICAgICAgICAgICAgIElQYWNrYWdlRGVjbGFyYXRpb24gbXlQYWNrYWdlID0gc291cmNlLmdldFBhY2thZ2VEZWNsYXJhdGlvbihnZXRQYWNrYWdlTmFtZSgpKTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobXlQYWNrYWdlKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobXlQYWNrYWdlLCBhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChteVBhY2thZ2UsIFhtbFNjaGVtYS5jbGFzcykpOwotICAgICAgICAgICAgCisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChteVBhY2thZ2UsIFhtbFNjaGVtYS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKKwogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShleGVjdXRlQ2hhbmdlKG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCksIHRleHRGaWxlQ2hhbmdlKSk7CiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobXlQYWNrYWdlLCBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKQEAgLTc0LDUgKzc0LDUgQEAKICAgICAgICAgICAgIGZhaWwoY2UuZ2V0TG9jYWxpemVkTWVzc2FnZSgpKTsKICAgICAgICAgfQogICAgIH0KLSAgICAKKwogfQpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheGIuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheGIvY29yZS90ZXN0cy9SZW1vdmVBbm5vdGF0aW9uRnJvbVBhY2thZ2VUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4Yi9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tUGFja2FnZVRlc3QuamF2YQppbmRleCA4ZDliOWM2Li5mZGFhZDcxIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4Yi9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tUGFja2FnZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4Yi5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4Yi9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tUGFja2FnZVRlc3QuamF2YQpAQCAtNTIsMTAgKzUyLDEwIEBACiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVBbm5vdGF0aW9uVGV4dEVkaXQobXlQYWNrYWdlLCBhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVJbXBvcnRUZXh0RWRpdChteVBhY2thZ2UsIFhtbFNjaGVtYS5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlSW1wb3J0VGV4dEVkaXQobXlQYWNrYWdlLCBYbWxTY2hlbWEuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIGFzc2VydFRydWUoZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCB0ZXh0RmlsZUNoYW5nZSkpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGFzc2VydEZhbHNlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG15UGFja2FnZSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CiAgICAgICAgICAgICBhc3NlcnRGYWxzZShzb3VyY2UuZ2V0SW1wb3J0KFhtbFNjaGVtYS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKICAgICAgICAgfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBjZSkgewpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9BYnN0cmFjdE9uZXdheVZhbGlkYXRpb25UZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0Fic3RyYWN0T25ld2F5VmFsaWRhdGlvblRlc3QuamF2YQppbmRleCA1ZjJhMTY5Li4xOWRlMzA4IDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0Fic3RyYWN0T25ld2F5VmFsaWRhdGlvblRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0Fic3RyYWN0T25ld2F5VmFsaWRhdGlvblRlc3QuamF2YQpAQCAtMTEsNyArMTEsNiBAQAogcGFja2FnZSBvcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS5hbm5vdGF0aW9uLnZhbGlkYXRpb24udGVzdHM7CiAKIGltcG9ydCBqYXZheC5qd3MuT25ld2F5OwotCiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSU1hcmtlcjsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUmVzb3VyY2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuUmVzb3VyY2VzUGx1Z2luOwpAQCAtNDAsMTEgKzM5LDExIEBACiAgICAgcHVibGljIFN0cmluZyBnZXRQYWNrYWdlTmFtZSgpIHsKICAgICAgICAgcmV0dXJuICJjb20uZXhhbXBsZSI7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIGFic3RyYWN0IFN0cmluZyBnZXRFcnJvck1lc3NhZ2UoKTsKLSAgICAKKwogICAgIHB1YmxpYyBhYnN0cmFjdCBJTWV0aG9kIGdldE1ldGhvZFRvVGVzdCgpOwotICAgIAorCiAgICAgcHVibGljIHZvaWQgdGVzdE9uZXdheVJ1bGUoKSB7CiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGFubm90YXRpb24pOwpAQCAtNTMsNyArNTIsNyBAQAogICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBnZXRNZXRob2RUb1Rlc3QoKTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBPbmV3YXkuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgT25ld2F5LmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTYxLDcgKzYwLDggQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKLSAgICAgICAgICAgIAorICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KE9uZXdheS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKKwogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKICAgICAgICAgICAgIElNYXJrZXJbXSBhbGxtYXJrZXJzID0gc291cmNlLmdldFJlc291cmNlKCkuZmluZE1hcmtlcnMoSU1hcmtlci5QUk9CTEVNLCB0cnVlLApkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9BYnN0cmFjdFdlYk1ldGhvZFB1YmxpY1N0YXRpY0ZpbmFsUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvQWJzdHJhY3RXZWJNZXRob2RQdWJsaWNTdGF0aWNGaW5hbFJ1bGVUZXN0LmphdmEKaW5kZXggODIwNjNkMi4uNTFhZThjMSAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9BYnN0cmFjdFdlYk1ldGhvZFB1YmxpY1N0YXRpY0ZpbmFsUnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0Fic3RyYWN0V2ViTWV0aG9kUHVibGljU3RhdGljRmluYWxSdWxlVGVzdC5qYXZhCkBAIC0xMSw3ICsxMSw2IEBACiBwYWNrYWdlIG9yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLmFubm90YXRpb24udmFsaWRhdGlvbi50ZXN0czsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJNZXRob2Q7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC01NSw3ICs1NCw3IEBACiAgICAgcHJvdGVjdGVkIFN0cmluZyBnZXRQYWNrYWdlTmFtZSgpIHsKICAgICAgICAgcmV0dXJuICJjb20uZXhhbXBsZSI7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIGFic3RyYWN0IElNZXRob2QgZ2V0TWV0aG9kVG9UZXNldCgpOwogICAgIHB1YmxpYyBhYnN0cmFjdCBTdHJpbmcgZ2V0RXJyb3JNZXNzYWdlKCk7CiAKQEAgLTY3LDcgKzY2LDcgQEAKICAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gZ2V0TWV0aG9kVG9UZXNldCgpOwogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChtZXRob2QpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFdlYk1ldGhvZC5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBXZWJNZXRob2QuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKIApAQCAtNzUsNiArNzQsNyBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYk1ldGhvZC5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvQWJzdHJhY3RXZWJTZXJ2aWNlUHVibGljQWJzdHJhY3RGaW5hbFJ1bGVUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0Fic3RyYWN0V2ViU2VydmljZVB1YmxpY0Fic3RyYWN0RmluYWxSdWxlVGVzdC5qYXZhCmluZGV4IGVlMDU2NDYuLjg1YjYxOTcgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvQWJzdHJhY3RXZWJTZXJ2aWNlUHVibGljQWJzdHJhY3RGaW5hbFJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9BYnN0cmFjdFdlYlNlcnZpY2VQdWJsaWNBYnN0cmFjdEZpbmFsUnVsZVRlc3QuamF2YQpAQCAtMTQsNyArMTQsNiBAQAogaW1wb3J0IGphdmEudXRpbC5MaXN0OwogCiBpbXBvcnQgamF2YXguandzLldlYlNlcnZpY2U7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC02OCw3ICs2Nyw3IEBACiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGFubm90YXRpb24pOwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKFdlYlNlcnZpY2UuY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgV2ViU2VydmljZS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbikpOwogCkBAIC03Niw2ICs3NSw3IEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQoc291cmNlLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoV2ViU2VydmljZS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvRG9jQmFyZU5vblZvaWROb091dFBhcmFtZXRlcnNSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlTm9uVm9pZE5vT3V0UGFyYW1ldGVyc1J1bGVUZXN0LmphdmEKaW5kZXggYmY5MmY5OC4uNWJmNjQyMiAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlTm9uVm9pZE5vT3V0UGFyYW1ldGVyc1J1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlTm9uVm9pZE5vT3V0UGFyYW1ldGVyc1J1bGVUZXN0LmphdmEKQEAgLTQyLDIzICs0MiwyNCBAQAogCiAgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm5vT3V0IiwgbmV3IFN0cmluZ1tdIHsgIlFTdHJpbmc7IiwKICAgICAgICAgICAgICAgICAgICAgIlFTdHJpbmc7ICJ9KTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MpKTsKLSAgICAgICAgICAgIAorICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKKwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKGV4ZWN1dGVDaGFuZ2UobmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSwgdGV4dEZpbGVDaGFuZ2UpKTsKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKICAgICAgICAgICAgIElNYXJrZXJbXSBhbGxtYXJrZXJzID0gc291cmNlLmdldFJlc291cmNlKCkuZmluZE1hcmtlcnMoSU1hcmtlci5QUk9CTEVNLCB0cnVlLAogICAgICAgICAgICAgICAgICAgICBJUmVzb3VyY2UuREVQVEhfSU5GSU5JVEUpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGFzc2VydEVxdWFscygxLCBhbGxtYXJrZXJzLmxlbmd0aCk7CiAKICAgICAgICAgICAgIElNYXJrZXIgYW5ub3RhdGlvblByb2JsZW1NYXJrZXIgPSBhbGxtYXJrZXJzWzBdOwpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlT25lTm9uSGVhZGVySU5QYXJhbWV0ZXJSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlT25lTm9uSGVhZGVySU5QYXJhbWV0ZXJSdWxlVGVzdC5qYXZhCmluZGV4IDVlMTg5MGEuLjA1Yjg0NTggMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvRG9jQmFyZU9uZU5vbkhlYWRlcklOUGFyYW1ldGVyUnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0RvY0JhcmVPbmVOb25IZWFkZXJJTlBhcmFtZXRlclJ1bGVUZXN0LmphdmEKQEAgLTYyLDcgKzYyLDcgQEAKIAogICAgICAgICAgICAgSU1hcmtlcltdIGFsbG1hcmtlcnMgPSBzb3VyY2UuZ2V0UmVzb3VyY2UoKS5maW5kTWFya2VycyhJTWFya2VyLlBST0JMRU0sIHRydWUsCiAgICAgICAgICAgICAgICAgICAgIElSZXNvdXJjZS5ERVBUSF9JTkZJTklURSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKDEsIGFsbG1hcmtlcnMubGVuZ3RoKTsKIAogICAgICAgICAgICAgSU1hcmtlciBhbm5vdGF0aW9uUHJvYmxlbU1hcmtlciA9IGFsbG1hcmtlcnNbMF07CkBAIC04NCwxMiArODQsMTIgQEAKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwoYW5ub3RhdGlvbik7CiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoU09BUEJpbmRpbmcuY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpOwogCi0gICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm9ubHlPbmVJTiIsIG5ldyBTdHJpbmdbXSB7ICJRU3RyaW5nOyIsIAorICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJvbmx5T25lSU4iLCBuZXcgU3RyaW5nW10geyAiUVN0cmluZzsiLAogICAgICAgICAgICAgICAgICAgICAiUVN0cmluZzsiIH0pOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCkBAIC0xMDIsNyArMTAyLDcgQEAKIAogICAgICAgICAgICAgSU1hcmtlcltdIGFsbG1hcmtlcnMgPSBzb3VyY2UuZ2V0UmVzb3VyY2UoKS5maW5kTWFya2VycyhJTWFya2VyLlBST0JMRU0sIHRydWUsCiAgICAgICAgICAgICAgICAgICAgIElSZXNvdXJjZS5ERVBUSF9JTkZJTklURSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKDEsIGFsbG1hcmtlcnMubGVuZ3RoKTsKIAogICAgICAgICAgICAgSU1hcmtlciBhbm5vdGF0aW9uUHJvYmxlbU1hcmtlciA9IGFsbG1hcmtlcnNbMF07CkBAIC0xMTgsMTggKzExOCwxOCBAQAogICAgICAgICAgICAgZmFpbChpZS5nZXRMb2NhbGl6ZWRNZXNzYWdlKCkpOwogICAgICAgICB9CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIHZvaWQgdGVzdE9ubHlPbmVOb25IZWFkZXJJTlBhcmFtZXRlcldpdGhXZWJQYXJhbXNSdWxlKCkgewogICAgICAgICB0cnkgewogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhTT0FQQmluZGluZy5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSk7CiAKLSAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLmdldE1ldGhvZCgib25lTW9yZSIsIG5ldyBTdHJpbmdbXSB7ICJRU3RyaW5nOyIsIAorICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJvbmVNb3JlIiwgbmV3IFN0cmluZ1tdIHsgIlFTdHJpbmc7IiwKICAgICAgICAgICAgICAgICAgICAgIlFTdHJpbmc7IiB9KTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKIApAQCAtMTM3LDEyICsxMzcsMTMgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKICAgICAgICAgICAgIElNYXJrZXJbXSBhbGxtYXJrZXJzID0gc291cmNlLmdldFJlc291cmNlKCkuZmluZE1hcmtlcnMoSU1hcmtlci5QUk9CTEVNLCB0cnVlLAogICAgICAgICAgICAgICAgICAgICBJUmVzb3VyY2UuREVQVEhfSU5GSU5JVEUpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGFzc2VydEVxdWFscygxLCBhbGxtYXJrZXJzLmxlbmd0aCk7CiAKICAgICAgICAgICAgIElNYXJrZXIgYW5ub3RhdGlvblByb2JsZW1NYXJrZXIgPSBhbGxtYXJrZXJzWzBdOwpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlVm9pZE9uZUlOT25lT3V0UGFyYW1ldGVyUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvRG9jQmFyZVZvaWRPbmVJTk9uZU91dFBhcmFtZXRlclJ1bGVUZXN0LmphdmEKaW5kZXggZmYxNjExMi4uYjU2NTEyMyAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Eb2NCYXJlVm9pZE9uZUlOT25lT3V0UGFyYW1ldGVyUnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0RvY0JhcmVWb2lkT25lSU5PbmVPdXRQYXJhbWV0ZXJSdWxlVGVzdC5qYXZhCkBAIC00NiwxMCArNDYsMTAgQEAKIAogICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJvbmVJbiIsIG5ldyBTdHJpbmdbXSB7ICJRSG9sZGVyPFFTdHJpbmc7PjsiLAogICAgICAgICAgICAgICAgICAgICAiUVN0cmluZzsifSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChtZXRob2QpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFNPQVBCaW5kaW5nLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFNPQVBCaW5kaW5nLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTYyLDcgKzYyLDcgQEAKIAogICAgICAgICAgICAgSU1hcmtlcltdIGFsbG1hcmtlcnMgPSBzb3VyY2UuZ2V0UmVzb3VyY2UoKS5maW5kTWFya2VycyhJTWFya2VyLlBST0JMRU0sIHRydWUsCiAgICAgICAgICAgICAgICAgICAgIElSZXNvdXJjZS5ERVBUSF9JTkZJTklURSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKDEsIGFsbG1hcmtlcnMubGVuZ3RoKTsKIAogICAgICAgICAgICAgSU1hcmtlciBhbm5vdGF0aW9uUHJvYmxlbU1hcmtlciA9IGFsbG1hcmtlcnNbMF07CkBAIC04NiwxMCArODYsMTAgQEAKIAogICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJvbmVPdXQiLCBuZXcgU3RyaW5nW10geyAiUUhvbGRlcjxRU3RyaW5nOz47IiwKICAgICAgICAgICAgICAgICAgICAgIlFIb2xkZXI8UVN0cmluZzs+OyJ9KTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKIApAQCAtOTcsMTIgKzk3LDEzIEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoU09BUEJpbmRpbmcuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCiAgICAgICAgICAgICBJTWFya2VyW10gYWxsbWFya2VycyA9IHNvdXJjZS5nZXRSZXNvdXJjZSgpLmZpbmRNYXJrZXJzKElNYXJrZXIuUFJPQkxFTSwgdHJ1ZSwKICAgICAgICAgICAgICAgICAgICAgSVJlc291cmNlLkRFUFRIX0lORklOSVRFKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoMSwgYWxsbWFya2Vycy5sZW5ndGgpOwogCiAgICAgICAgICAgICBJTWFya2VyIGFubm90YXRpb25Qcm9ibGVtTWFya2VyID0gYWxsbWFya2Vyc1swXTsKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvSG9sZGVyVHlwZVBhcmFtZXRlclJ1bGVUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL0hvbGRlclR5cGVQYXJhbWV0ZXJSdWxlVGVzdC5qYXZhCmluZGV4IDkyNzI4N2QuLjFmN2Q1MTUgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvSG9sZGVyVHlwZVBhcmFtZXRlclJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9Ib2xkZXJUeXBlUGFyYW1ldGVyUnVsZVRlc3QuamF2YQpAQCAtMTEsNyArMTEsNiBAQAogcGFja2FnZSBvcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS5hbm5vdGF0aW9uLnZhbGlkYXRpb24udGVzdHM7CiAKIGltcG9ydCBqYXZheC5qd3MuV2ViU2VydmljZTsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTU1LDggKzU0LDggQEAKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwoYW5ub3RhdGlvbik7CiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoV2ViU2VydmljZS5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgV2ViU2VydmljZS5jbGFzcykpOworCisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIGFubm90YXRpb24pKTsKIApAQCAtNjQsNiArNjMsNyBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1NPQVBCaW5kaW5nRG9jdW1lbnRFbmNvZGVkUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdEb2N1bWVudEVuY29kZWRSdWxlVGVzdC5qYXZhCmluZGV4IGFlMmU2NGMuLmRlZjg0MjAgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdEb2N1bWVudEVuY29kZWRSdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdEb2N1bWVudEVuY29kZWRSdWxlVGVzdC5qYXZhCkBAIC01OCwxMSArNTgsMTEgQEAKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwoYW5ub3RhdGlvbik7CiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoU09BUEJpbmRpbmcuY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLmdldE1ldGhvZCgibXlNZXRob2QiLCBuZXcgU3RyaW5nW10geyAiUVN0cmluZzsiIH0pOwogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChtZXRob2QpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFNPQVBCaW5kaW5nLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFNPQVBCaW5kaW5nLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTcwLDYgKzcwLDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdNaXhlZEJpbmRpbmdzUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdNaXhlZEJpbmRpbmdzUnVsZVRlc3QuamF2YQppbmRleCBmYWM2MThhLi41ODkwMGNlIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1NPQVBCaW5kaW5nTWl4ZWRCaW5kaW5nc1J1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9TT0FQQmluZGluZ01peGVkQmluZGluZ3NSdWxlVGVzdC5qYXZhCkBAIC01Myw3ICs1Myw3IEBACiAKICAgICAgICAgcmV0dXJuIEFubm90YXRpb25zQ29yZS5jcmVhdGVOb3JtYWxBbm5vdGF0aW9uKGFzdCwgU09BUEJpbmRpbmcuY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBtZW1iZXJWYWx1ZVBhaXJzKTsKICAgICB9Ci0gICAgCisKICAgICBAT3ZlcnJpZGUKICAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzQ29udGVudHMoKSB7CiAgICAgICAgIFN0cmluZ0J1aWxkZXIgY2xhc3NDb250ZW50cyA9IG5ldyBTdHJpbmdCdWlsZGVyKCJwYWNrYWdlIGNvbS5leGFtcGxlO1xuXG4iKTsKQEAgLTY0LDE2ICs2NCwxNiBAQAogICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiXG5cdFx0cmV0dXJuIFwidHh0XCI7XG5cdH1cblxufSIpOwogICAgICAgICByZXR1cm4gY2xhc3NDb250ZW50cy50b1N0cmluZygpOwogICAgIH0KLSAgICAKKwogICAgIHB1YmxpYyB2b2lkIHRlc3RTT0FQQmluZGluZ01peGVkQmluZGluZ3NSdWxlKCkgewogICAgICAgICB0cnkgewogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhTT0FQQmluZGluZy5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJteU1ldGhvZCIsIG5ldyBTdHJpbmdbXSB7ICJRU3RyaW5nOyIgfSk7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgU09BUEJpbmRpbmcuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKIApAQCAtODEsNiArODEsNyBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFNPQVBCaW5kaW5nLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkuZXhpc3RzKCkpOwogCiAgICAgICAgICAgICBKb2IuZ2V0Sm9iTWFuYWdlcigpLmpvaW4oUmVzb3VyY2VzUGx1Z2luLkZBTUlMWV9BVVRPX0JVSUxELCBudWxsKTsKIApkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9TT0FQQmluZGluZ1JDUEJhcmVSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9TT0FQQmluZGluZ1JDUEJhcmVSdWxlVGVzdC5qYXZhCmluZGV4IGRkNzRhNTEuLjk4NjI2OTQgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdSQ1BCYXJlUnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1NPQVBCaW5kaW5nUkNQQmFyZVJ1bGVUZXN0LmphdmEKQEAgLTUyLDEzICs1MiwxMyBAQAogCiAgICAgICAgIHJldHVybiBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlTm9ybWFsQW5ub3RhdGlvbihhc3QsIFNPQVBCaW5kaW5nLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgbWVtYmVyVmFsdWVQYWlycyk7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIHZvaWQgdGVzdFNPQVBCaW5kaW5nUlBDQmFyZVJ1bGUoKSB7CiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGFubm90YXRpb24pOwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKFNPQVBCaW5kaW5nLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKLSAgICAgICAgICAgIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBTT0FQQmluZGluZy5jbGFzcykpOworCisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFNPQVBCaW5kaW5nLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTY2LDYgKzY2LDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChzb3VyY2UsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdSUENFbmNvZGVkUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdSUENFbmNvZGVkUnVsZVRlc3QuamF2YQppbmRleCBmYmI0ZjZlLi4wMWIwYTI3IDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1NPQVBCaW5kaW5nUlBDRW5jb2RlZFJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9TT0FQQmluZGluZ1JQQ0VuY29kZWRSdWxlVGVzdC5qYXZhCkBAIC01Nyw4ICs1Nyw4IEBACiAgICAgICAgIHRyeSB7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGFubm90YXRpb24pOwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKFNPQVBCaW5kaW5nLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKLSAgICAgICAgICAgIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBTT0FQQmluZGluZy5jbGFzcykpOworCisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFNPQVBCaW5kaW5nLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTY2LDYgKzY2LDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChzb3VyY2UsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdSUENTdHlsZU9uTWV0aG9kUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvU09BUEJpbmRpbmdSUENTdHlsZU9uTWV0aG9kUnVsZVRlc3QuamF2YQppbmRleCBkNTRjM2U1Li40OTQyNGEwIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1NPQVBCaW5kaW5nUlBDU3R5bGVPbk1ldGhvZFJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9TT0FQQmluZGluZ1JQQ1N0eWxlT25NZXRob2RSdWxlVGVzdC5qYXZhCkBAIC02Miw3ICs2Miw3IEBACiAgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm15TWV0aG9kIiwgbmV3IFN0cmluZ1tdIHsgIlFTdHJpbmc7IiB9KTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCkBAIC03MCw2ICs3MCw3IEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoU09BUEJpbmRpbmcuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYk1ldGhvZENoZWNrRm9yV2ViU2VydmljZVJ1bGVUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYk1ldGhvZENoZWNrRm9yV2ViU2VydmljZVJ1bGVUZXN0LmphdmEKaW5kZXggODEwNTA4Ni4uMDQ0MGM0ZCAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJNZXRob2RDaGVja0ZvcldlYlNlcnZpY2VSdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViTWV0aG9kQ2hlY2tGb3JXZWJTZXJ2aWNlUnVsZVRlc3QuamF2YQpAQCAtMTQsNyArMTQsNiBAQAogaW1wb3J0IGphdmEudXRpbC5MaXN0OwogCiBpbXBvcnQgamF2YXguandzLldlYk1ldGhvZDsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTczLDcgKzcyLDcgQEAKICAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLmdldE1ldGhvZCgibXlNZXRob2QiLCBuZXcgU3RyaW5nWzBdKTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgV2ViTWV0aG9kLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTgxLDYgKzgwLDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChXZWJNZXRob2QuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYk1ldGhvZEV4Y2x1ZGVSdWxlT25JbXBsVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJNZXRob2RFeGNsdWRlUnVsZU9uSW1wbFRlc3QuamF2YQppbmRleCA1MDhjMzZlLi43MGU4OGJhIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYk1ldGhvZEV4Y2x1ZGVSdWxlT25JbXBsVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViTWV0aG9kRXhjbHVkZVJ1bGVPbkltcGxUZXN0LmphdmEKQEAgLTE0LDcgKzE0LDYgQEAKIGltcG9ydCBqYXZhLnV0aWwuTGlzdDsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJNZXRob2Q7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC03OSw3ICs3OCw3IEBACiAgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm15TWV0aG9kIiwgbmV3IFN0cmluZ1swXSk7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgV2ViTWV0aG9kLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFdlYk1ldGhvZC5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCkBAIC04Nyw2ICs4Niw3IEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoV2ViTWV0aG9kLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkuZXhpc3RzKCkpOwogCiAgICAgICAgICAgICBKb2IuZ2V0Sm9iTWFuYWdlcigpLmpvaW4oUmVzb3VyY2VzUGx1Z2luLkZBTUlMWV9BVVRPX0JVSUxELCBudWxsKTsKIApkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJNZXRob2RFeGNsdWRlUnVsZU9uU0VJVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJNZXRob2RFeGNsdWRlUnVsZU9uU0VJVGVzdC5qYXZhCmluZGV4IGQ3OWJmMjEuLjFiODAyNDkgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViTWV0aG9kRXhjbHVkZVJ1bGVPblNFSVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYk1ldGhvZEV4Y2x1ZGVSdWxlT25TRUlUZXN0LmphdmEKQEAgLTE0LDcgKzE0LDYgQEAKIGltcG9ydCBqYXZhLnV0aWwuTGlzdDsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJNZXRob2Q7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC03MCw3ICs2OSw3IEBACiAgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm15TWV0aG9kIiwgbmV3IFN0cmluZ1swXSk7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgV2ViTWV0aG9kLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYk1ldGhvZC5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCkBAIC03OCw2ICs3Nyw3IEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoV2ViTWV0aG9kLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkuZXhpc3RzKCkpOwogCiAgICAgICAgICAgICBKb2IuZ2V0Sm9iTWFuYWdlcigpLmpvaW4oUmVzb3VyY2VzUGx1Z2luLkZBTUlMWV9BVVRPX0JVSUxELCBudWxsKTsKIApkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJQYXJhbU1vZGVIb2xkZXJUeXBlUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViUGFyYW1Nb2RlSG9sZGVyVHlwZVJ1bGVUZXN0LmphdmEKaW5kZXggNjRmZjU3MS4uYTQyM2YwMiAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJQYXJhbU1vZGVIb2xkZXJUeXBlUnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlBhcmFtTW9kZUhvbGRlclR5cGVSdWxlVGVzdC5qYXZhCkBAIC0xNSw3ICsxNSw2IEBACiAKIGltcG9ydCBqYXZheC5qd3MuV2ViUGFyYW07CiBpbXBvcnQgamF2YXguandzLldlYlBhcmFtLk1vZGU7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC00MSw3ICs0MCw3IEBACiAgICAgICAgICAgICAgICAgV2ViUGFyYW0uY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpLCAibW9kZSIsIE1vZGUuT1VUKTsKIAogICAgICAgICBtZW1iZXJWYWx1ZVBhaXJzLmFkZChtb2RlVmFsdWVQYWlyKTsKLSAgICAgICAgCisKICAgICAgICAgcmV0dXJuIEFubm90YXRpb25zQ29yZS5jcmVhdGVOb3JtYWxBbm5vdGF0aW9uKGFzdCwgV2ViUGFyYW0uY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBtZW1iZXJWYWx1ZVBhaXJzKTsKICAgICB9CiAKQEAgLTY5LDIwICs2OCwyMSBAQAogICAgICAgICB0cnkgewogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhXZWJQYXJhbS5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJteU1ldGhvZCIsIG5ldyBTdHJpbmdbXSB7ICJRU3RyaW5nOyIgfSk7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1ldGhvZCk7CiAKICAgICAgICAgICAgIElMb2NhbFZhcmlhYmxlIGxvY2FsVmFyaWFibGUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0TG9jYWxWYXJpYWJsZShtZXRob2QsICJwYXJhbSIpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChsb2NhbFZhcmlhYmxlLCBXZWJQYXJhbS5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobG9jYWxWYXJpYWJsZSwgV2ViUGFyYW0uY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChsb2NhbFZhcmlhYmxlLCBhbm5vdGF0aW9uKSk7CiAKICAgICAgICAgICAgIGFzc2VydFRydWUoZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCB0ZXh0RmlsZUNoYW5nZSkpOwogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KGxvY2FsVmFyaWFibGUsIGFubm90YXRpb24pKTsKLSAgICAgICAgICAgIAorICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlBhcmFtLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkuZXhpc3RzKCkpOworCiAgICAgICAgICAgICBKb2IuZ2V0Sm9iTWFuYWdlcigpLmpvaW4oUmVzb3VyY2VzUGx1Z2luLkZBTUlMWV9BVVRPX0JVSUxELCBudWxsKTsKIAogICAgICAgICAgICAgSU1hcmtlcltdIGFsbG1hcmtlcnMgPSBzb3VyY2UuZ2V0UmVzb3VyY2UoKS5maW5kTWFya2VycyhJTWFya2VyLlBST0JMRU0sIHRydWUsCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VEZWZhdWx0UHVibGljQ29uc3RydWN0b3JSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlRGVmYXVsdFB1YmxpY0NvbnN0cnVjdG9yUnVsZVRlc3QuamF2YQppbmRleCAyOTFiNWFlLi43ZmE4ZmRmIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VEZWZhdWx0UHVibGljQ29uc3RydWN0b3JSdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZURlZmF1bHRQdWJsaWNDb25zdHJ1Y3RvclJ1bGVUZXN0LmphdmEKQEAgLTE0LDcgKzE0LDYgQEAKIGltcG9ydCBqYXZhLnV0aWwuTGlzdDsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJTZXJ2aWNlOwotCiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSU1hcmtlcjsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUmVzb3VyY2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuUmVzb3VyY2VzUGx1Z2luOwpAQCAtNzUsNyArNzQsNyBAQAogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhXZWJTZXJ2aWNlLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIGFubm90YXRpb24pKTsKIApAQCAtODQsNiArODMsOCBAQAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChzb3VyY2UsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKIAorICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CisKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCiAgICAgICAgICAgICBJTWFya2VyW10gYWxsbWFya2VycyA9IHNvdXJjZS5nZXRSZXNvdXJjZSgpLmZpbmRNYXJrZXJzKElNYXJrZXIuUFJPQkxFTSwgdHJ1ZSwKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZU5vRmluYWxpemVNZXRob2RSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlTm9GaW5hbGl6ZU1ldGhvZFJ1bGVUZXN0LmphdmEKaW5kZXggOWRmNWE5Ni4uZDg0YzQzMSAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlTm9GaW5hbGl6ZU1ldGhvZFJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlTm9GaW5hbGl6ZU1ldGhvZFJ1bGVUZXN0LmphdmEKQEAgLTE0LDcgKzE0LDYgQEAKIGltcG9ydCBqYXZhLnV0aWwuTGlzdDsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJTZXJ2aWNlOwotCiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSU1hcmtlcjsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUmVzb3VyY2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuUmVzb3VyY2VzUGx1Z2luOwpAQCAtNzUsNyArNzQsNyBAQAogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhXZWJTZXJ2aWNlLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIGFubm90YXRpb24pKTsKIApAQCAtODMsNiArODIsNyBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb0VuZHBvaW50SW50ZXJmYWNlUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vRW5kcG9pbnRJbnRlcmZhY2VSdWxlVGVzdC5qYXZhCmluZGV4IDQxZDVhN2MuLjIzMGRlMWUgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vRW5kcG9pbnRJbnRlcmZhY2VSdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vRW5kcG9pbnRJbnRlcmZhY2VSdWxlVGVzdC5qYXZhCkBAIC0xNCw3ICsxNCw2IEBACiBpbXBvcnQgamF2YS51dGlsLkxpc3Q7CiAKIGltcG9ydCBqYXZheC5qd3MuV2ViU2VydmljZTsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTM5LDcgKzM4LDcgQEAKICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIGVuZHBvaW50SW50ZXJmYWNlVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsCiAgICAgICAgICAgICAgICAgImVuZHBvaW50SW50ZXJmYWNlIiwgIk15SW50ZXJmYWNlIik7CiAKLSAgICAgICAgTWVtYmVyVmFsdWVQYWlyIHRhcmdldE5hbWVzcGFjZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LCAKKyAgICAgICAgTWVtYmVyVmFsdWVQYWlyIHRhcmdldE5hbWVzcGFjZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LAogICAgICAgICAgICAgICAgICJ0YXJnZXROYW1lc3BhY2UiLCAiaHR0cDovL2V4YW1wbGUuY29tLyIpOwogCiAgICAgICAgIG1lbWJlclZhbHVlUGFpcnMuYWRkKG5hbWVWYWx1ZVBhaXIpOwpAQCAtNjUsMTMgKzY0LDEzIEBACiAgICAgcHJvdGVjdGVkIFN0cmluZyBnZXRQYWNrYWdlTmFtZSgpIHsKICAgICAgICAgcmV0dXJuICJjb20uZXhhbXBsZSI7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIHZvaWQgdGVzdFdlYlNlcnZpY2VTRUlOb0VuZHBvaW50SW50ZXJmYWNlUnVsZSgpIHsKICAgICAgICAgdHJ5IHsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwoYW5ub3RhdGlvbik7CiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoV2ViU2VydmljZS5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgV2ViU2VydmljZS5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTc5LDYgKzc4LDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChzb3VyY2UsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChXZWJTZXJ2aWNlLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkuZXhpc3RzKCkpOwogCiAgICAgICAgICAgICBKb2IuZ2V0Sm9iTWFuYWdlcigpLmpvaW4oUmVzb3VyY2VzUGx1Z2luLkZBTUlMWV9BVVRPX0JVSUxELCBudWxsKTsKIApkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlU0VJTm9PbmV3YXlSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlU0VJTm9PbmV3YXlSdWxlVGVzdC5qYXZhCmluZGV4IDQ4OWExZmUuLmQwYzdmMzcgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vT25ld2F5UnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb09uZXdheVJ1bGVUZXN0LmphdmEKQEAgLTExLDcgKzExLDYgQEAKIHBhY2thZ2Ugb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUuYW5ub3RhdGlvbi52YWxpZGF0aW9uLnRlc3RzOwogCiBpbXBvcnQgamF2YXguandzLk9uZXdheTsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTQwLDcgKzM5LDcgQEAKICAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLmdldE1ldGhvZCgibWV0aG9kT25lIiwgbmV3IFN0cmluZ1tdIHsgIlFTdHJpbmc7IiB9KTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBPbmV3YXkuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgT25ld2F5LmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTQ4LDYgKzQ3LDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChPbmV3YXkuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1BvcnROYW1lUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vUG9ydE5hbWVSdWxlVGVzdC5qYXZhCmluZGV4IGU1OGQ2ODkuLjRmOWYwNDUgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vUG9ydE5hbWVSdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vUG9ydE5hbWVSdWxlVGVzdC5qYXZhCkBAIC0xNCw3ICsxNCw2IEBACiBpbXBvcnQgamF2YS51dGlsLkxpc3Q7CiAKIGltcG9ydCBqYXZheC5qd3MuV2ViU2VydmljZTsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTM2LDEwICszNSwxMCBAQAogCiAgICAgICAgIE1lbWJlclZhbHVlUGFpciBuYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsICJuYW1lIiwgIk15Q2xhc3MiKTsKIAotICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgdGFyZ2V0TmFtZXNwYWNlVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsIAorICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgdGFyZ2V0TmFtZXNwYWNlVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsCiAgICAgICAgICAgICAgICAgInRhcmdldE5hbWVzcGFjZSIsICJodHRwOi8vZXhhbXBsZS5jb20vIik7CiAKLSAgICAgICAgTWVtYmVyVmFsdWVQYWlyIHBvcnROYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsICJwb3J0TmFtZSIsIAorICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgcG9ydE5hbWVWYWx1ZVBhaXIgPSBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlU3RyaW5nTWVtYmVyVmFsdWVQYWlyKGFzdCwgInBvcnROYW1lIiwKICAgICAgICAgIk15Q2xhc3NQb3J0Iik7CiAKICAgICAgICAgbWVtYmVyVmFsdWVQYWlycy5hZGQobmFtZVZhbHVlUGFpcik7CkBAIC02NSwxMyArNjQsMTMgQEAKICAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldFBhY2thZ2VOYW1lKCkgewogICAgICAgICByZXR1cm4gImNvbS5leGFtcGxlIjsKICAgICB9Ci0gICAgCisKICAgICBwdWJsaWMgdm9pZCB0ZXN0V2ViU2VydmljZVNFSU5vUG9ydE5hbWVSdWxlKCkgewogICAgICAgICB0cnkgewogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhXZWJTZXJ2aWNlLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIGFubm90YXRpb24pKTsKIApAQCAtNzksNiArNzgsNyBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1NPQVBCaW5kaW5nUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vU09BUEJpbmRpbmdSdWxlVGVzdC5qYXZhCmluZGV4IGJjMjk2ODIuLmNhZDFiOTkgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vU09BUEJpbmRpbmdSdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vU09BUEJpbmRpbmdSdWxlVGVzdC5qYXZhCkBAIC00MCw3ICs0MCw3IEBACiAgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm15TWV0aG9kIiwgbmV3IFN0cmluZ1tdIHsgIlFTdHJpbmc7IiB9KTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCkBAIC00OCw2ICs0OCw3IEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoU09BUEJpbmRpbmcuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCkBAIC03NSw3ICs3Niw3IEBACiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGFubm90YXRpb24pOwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKFNPQVBCaW5kaW5nLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBTT0FQQmluZGluZy5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBTT0FQQmluZGluZy5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbikpOwogCkBAIC0xMDUsNyArMTA2LDcgQEAKICAgICAgICAgfQogICAgIH0KIAotICAgIAotICAgIAorCisKIAogfQpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlU0VJTm9TZXJ2aWNlTmFtZVJ1bGVUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1NlcnZpY2VOYW1lUnVsZVRlc3QuamF2YQppbmRleCA1MDM3YWNhLi44NjMzNWZiIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1NlcnZpY2VOYW1lUnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1NlcnZpY2VOYW1lUnVsZVRlc3QuamF2YQpAQCAtMTQsNyArMTQsNiBAQAogaW1wb3J0IGphdmEudXRpbC5MaXN0OwogCiBpbXBvcnQgamF2YXguandzLldlYlNlcnZpY2U7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC03MSw3ICs3MCw3IEBACiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGFubm90YXRpb24pOwogICAgICAgICAgICAgYXNzZXJ0RXF1YWxzKFdlYlNlcnZpY2UuY2xhc3MuZ2V0U2ltcGxlTmFtZSgpLCBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgV2ViU2VydmljZS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKIAogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbikpOwogCkBAIC03OSw2ICs3OCw3IEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQoc291cmNlLCBBbm5vdGF0aW9uVXRpbHMKICAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoV2ViU2VydmljZS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vV2ViTWV0aG9kUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vV2ViTWV0aG9kUnVsZVRlc3QuamF2YQppbmRleCBmYTRkMjVlLi5hZTQ5MjA5IDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1dlYk1ldGhvZFJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlU0VJTm9XZWJNZXRob2RSdWxlVGVzdC5qYXZhCkBAIC0xMSw3ICsxMSw2IEBACiBwYWNrYWdlIG9yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLmFubm90YXRpb24udmFsaWRhdGlvbi50ZXN0czsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJNZXRob2Q7Ci0KIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JTWFya2VyOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZTsKIGltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CkBAIC00MCw3ICszOSw3IEBACiAgICAgICAgICAgICBJTWV0aG9kIG1ldGhvZCA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKS5nZXRNZXRob2QoIm15TWV0aG9kIiwgbmV3IFN0cmluZ1tdIHsgIlFTdHJpbmc7IiB9KTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgV2ViTWV0aG9kLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7CiAKQEAgLTQ4LDYgKzQ3LDcgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChtZXRob2QsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChXZWJNZXRob2QuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAKICAgICAgICAgICAgIEpvYi5nZXRKb2JNYW5hZ2VyKCkuam9pbihSZXNvdXJjZXNQbHVnaW4uRkFNSUxZX0FVVE9fQlVJTEQsIG51bGwpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1dlYlBhcmFtUnVsZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vV2ViUGFyYW1SdWxlVGVzdC5qYXZhCmluZGV4IDg5Yjc2M2IuLjU4Yjk0YzkgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vV2ViUGFyYW1SdWxlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vV2ViUGFyYW1SdWxlVGVzdC5qYXZhCkBAIC0xMSw3ICsxMSw2IEBACiBwYWNrYWdlIG9yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLmFubm90YXRpb24udmFsaWRhdGlvbi50ZXN0czsKIAogaW1wb3J0IGphdmF4Lmp3cy5XZWJQYXJhbTsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTQzLDE0ICs0MiwxNSBAQAogCiAgICAgICAgICAgICBJTG9jYWxWYXJpYWJsZSBsb2NhbFZhcmlhYmxlID0gQW5ub3RhdGlvblV0aWxzLmdldExvY2FsVmFyaWFibGUobWV0aG9kLCAiaW4iKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobG9jYWxWYXJpYWJsZSwgV2ViUGFyYW0uY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KGxvY2FsVmFyaWFibGUsIFdlYlBhcmFtLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRBbm5vdGF0aW9uVGV4dEVkaXQobG9jYWxWYXJpYWJsZSwgYW5ub3RhdGlvbikpOwogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKGV4ZWN1dGVDaGFuZ2UobmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSwgdGV4dEZpbGVDaGFuZ2UpKTsKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChsb2NhbFZhcmlhYmxlLCBhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICAKKyAgICAgICAgICAgIGFzc2VydFRydWUoc291cmNlLmdldEltcG9ydChXZWJQYXJhbS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKKwogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKICAgICAgICAgICAgIElNYXJrZXJbXSBhbGxtYXJrZXJzID0gc291cmNlLmdldFJlc291cmNlKCkuZmluZE1hcmtlcnMoSU1hcmtlci5QUk9CTEVNLCB0cnVlLApkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlU0VJTm9XZWJSZXN1bHRSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlU0VJTm9XZWJSZXN1bHRSdWxlVGVzdC5qYXZhCmluZGV4IDJhZjljMDYuLjRiMGYyOGIgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVNFSU5vV2ViUmVzdWx0UnVsZVRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvYW5ub3RhdGlvbi92YWxpZGF0aW9uL3Rlc3RzL1dlYlNlcnZpY2VTRUlOb1dlYlJlc3VsdFJ1bGVUZXN0LmphdmEKQEAgLTExLDcgKzExLDYgQEAKIHBhY2thZ2Ugb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUuYW5ub3RhdGlvbi52YWxpZGF0aW9uLnRlc3RzOwogCiBpbXBvcnQgamF2YXguandzLldlYlJlc3VsdDsKLQogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklNYXJrZXI7CiBpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOwogaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLlJlc291cmNlc1BsdWdpbjsKQEAgLTQwLDcgKzM5LDcgQEAKICAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLmdldE1ldGhvZCgibXlNZXRob2QiLCBuZXcgU3RyaW5nW10geyAiUVN0cmluZzsiIH0pOwogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChtZXRob2QpOwogCi0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChtZXRob2QsIFdlYlJlc3VsdC5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBXZWJSZXN1bHQuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChtZXRob2QsIGFubm90YXRpb24pKTsKIApAQCAtNDgsNiArNDcsNyBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlJlc3VsdC5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS9hbm5vdGF0aW9uL3ZhbGlkYXRpb24vdGVzdHMvV2ViU2VydmljZVdlYlNlcnZpY2VQcm92aWRlckNvRXhpc3RSdWxlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlV2ViU2VydmljZVByb3ZpZGVyQ29FeGlzdFJ1bGVUZXN0LmphdmEKaW5kZXggMDNiNTU4Ni4uMTUwZDM0MCAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlV2ViU2VydmljZVByb3ZpZGVyQ29FeGlzdFJ1bGVUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL2Fubm90YXRpb24vdmFsaWRhdGlvbi90ZXN0cy9XZWJTZXJ2aWNlV2ViU2VydmljZVByb3ZpZGVyQ29FeGlzdFJ1bGVUZXN0LmphdmEKQEAgLTU4LDIwICs1OCwyMCBAQAogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChhbm5vdGF0aW9uKTsKICAgICAgICAgICAgIGFzc2VydEVxdWFscyhXZWJTZXJ2aWNlLmNsYXNzLmdldFNpbXBsZU5hbWUoKSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVBZGRJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEFubm90YXRpb25UZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIGFubm90YXRpb24pKTsKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShleGVjdXRlQ2hhbmdlKG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCksIHRleHRGaWxlQ2hhbmdlKSk7CiAKLSAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQoc291cmNlLCBBbm5vdGF0aW9uVXRpbHMKLSAgICAgICAgICAgICAgICAgICAgLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoV2ViU2VydmljZS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpLmV4aXN0cygpKTsKIAogICAgICAgICAgICAgSm9iLmdldEpvYk1hbmFnZXIoKS5qb2luKFJlc291cmNlc1BsdWdpbi5GQU1JTFlfQVVUT19CVUlMRCwgbnVsbCk7CiAKICAgICAgICAgICAgIElNYXJrZXJbXSBhbGxtYXJrZXJzID0gc291cmNlLmdldFJlc291cmNlKCkuZmluZE1hcmtlcnMoSU1hcmtlci5QUk9CTEVNLCB0cnVlLAogICAgICAgICAgICAgICAgICAgICBJUmVzb3VyY2UuREVQVEhfSU5GSU5JVEUpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGFzc2VydEVxdWFscygxLCBhbGxtYXJrZXJzLmxlbmd0aCk7CiAKICAgICAgICAgICAgIElNYXJrZXIgYW5ub3RhdGlvblByb2JsZW1NYXJrZXIgPSBhbGxtYXJrZXJzWzBdOwpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0Fic3RyYWN0QW5ub3RhdGlvblRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BYnN0cmFjdEFubm90YXRpb25UZXN0LmphdmEKaW5kZXggZTFmZjIyNS4uYmFjMzY0OSAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0Fic3RyYWN0QW5ub3RhdGlvblRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWJzdHJhY3RBbm5vdGF0aW9uVGVzdC5qYXZhCkBAIC0yMSwxMCArMjEsMTAgQEAKIGltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQ29tcGlsYXRpb25Vbml0OwogaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5yZXdyaXRlLkFTVFJld3JpdGU7CiBpbXBvcnQgb3JnLmVjbGlwc2UuamR0LnVpLlNoYXJlZEFTVFByb3ZpZGVyOwotaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLnV0aWxzLkFubm90YXRpb25VdGlsczsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5DaGFuZ2U7CiBpbXBvcnQgb3JnLmVjbGlwc2UubHRrLmNvcmUucmVmYWN0b3JpbmcuUGVyZm9ybUNoYW5nZU9wZXJhdGlvbjsKIGltcG9ydCBvcmcuZWNsaXBzZS5sdGsuY29yZS5yZWZhY3RvcmluZy5UZXh0RmlsZUNoYW5nZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS50ZXh0LmVkaXRzLk11bHRpVGV4dEVkaXQ7CiAKIHB1YmxpYyBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdEFubm90YXRpb25UZXN0IGV4dGVuZHMgVGVzdENhc2UgewogICAgIHByb3RlY3RlZCBUZXN0SmF2YVByb2plY3QgdGVzdEphdmFQcm9qZWN0OwpAQCAtNDcsNyArNDcsOSBAQAogICAgICAgICBhc3QgPSBjb21waWxhdGlvblVuaXQuZ2V0QVNUKCk7CiAgICAgICAgIHJld3JpdGVyID0gQVNUUmV3cml0ZS5jcmVhdGUoYXN0KTsKICAgICAgICAgYW5ub3RhdGlvbiA9IGdldEFubm90YXRpb24oKTsKLSAgICAgICAgdGV4dEZpbGVDaGFuZ2UgPSBBbm5vdGF0aW9uVXRpbHMuY3JlYXRlVGV4dEZpbGVDaGFuZ2UoIkFDIiwgKElGaWxlKSBzb3VyY2UuZ2V0UmVzb3VyY2UoKSk7CisgICAgICAgIHRleHRGaWxlQ2hhbmdlID0gbmV3IFRleHRGaWxlQ2hhbmdlKCJBZGQgYW5ub3RhdGlvbiIsIChJRmlsZSkgc291cmNlLmdldFJlc291cmNlKCkpOworICAgICAgICBNdWx0aVRleHRFZGl0IG11bHRpVGV4dEVkaXQgPSBuZXcgTXVsdGlUZXh0RWRpdCgpOworICAgICAgICB0ZXh0RmlsZUNoYW5nZS5zZXRFZGl0KG11bHRpVGV4dEVkaXQpOwogICAgIH0KICAgICAKICAgICBwcm90ZWN0ZWQgYm9vbGVhbiBpc0F1dG9CdWlsZGluZ0VuYWJsZWQoKSB7CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvRmllbGRUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvRmllbGRUZXN0LmphdmEKaW5kZXggNDBlNTViYi4uYmFjNjkyZSAxMDA2NDQKLS0tIGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0FkZEFubm90YXRpb25Ub0ZpZWxkVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9GaWVsZFRlc3QuamF2YQpAQCAtNjAsNyArNjAsNyBAQAogICAgICAgICAgICAgSUZpZWxkIGZpZWxkID0gc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLmdldEZpZWxkKCJzZXJ2aWNlIik7CiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKGZpZWxkKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoZmllbGQsIFdlYlNlcnZpY2VSZWYuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KGZpZWxkLCBXZWJTZXJ2aWNlUmVmLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KGZpZWxkLCBhbm5vdGF0aW9uKSk7CiAKICAgICAgICAgICAgIGFzc2VydFRydWUoZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCB0ZXh0RmlsZUNoYW5nZSkpOwpAQCAtNzEsNSArNzEsNSBAQAogICAgICAgICAgICAgZmFpbChjZS5nZXRMb2NhbGl6ZWRNZXNzYWdlKCkpOwogICAgICAgICB9CiAgICAgfQotICAgIAorCiB9CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvTWV0aG9kUGFyYW1ldGVyVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0FkZEFubm90YXRpb25Ub01ldGhvZFBhcmFtZXRlclRlc3QuamF2YQppbmRleCBiZDFjNjdjLi5hMTIyOTViIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvTWV0aG9kUGFyYW1ldGVyVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9NZXRob2RQYXJhbWV0ZXJUZXN0LmphdmEKQEAgLTY0LDggKzY0LDggQEAKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAogICAgICAgICAgICAgSUxvY2FsVmFyaWFibGUgbG9jYWxWYXJpYWJsZSAgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0TG9jYWxWYXJpYWJsZShtZXRob2QsICJpIik7Ci0gICAgICAgICAgICAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KGxvY2FsVmFyaWFibGUsIFdlYlBhcmFtLmNsYXNzKSk7CisKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KGxvY2FsVmFyaWFibGUsIFdlYlBhcmFtLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KGxvY2FsVmFyaWFibGUsIGFubm90YXRpb24pKTsKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShleGVjdXRlQ2hhbmdlKG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yKCksIHRleHRGaWxlQ2hhbmdlKSk7CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvTWV0aG9kVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0FkZEFubm90YXRpb25Ub01ldGhvZFRlc3QuamF2YQppbmRleCA5YjFmNTUzLi4xZWZlNjFkIDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvTWV0aG9kVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9NZXRob2RUZXN0LmphdmEKQEAgLTYzLDExICs2MywxMSBAQAogICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCkuZ2V0TWV0aG9kKCJhZGQiLCBuZXcgU3RyaW5nW10geyAiSSIsICJJIiB9KTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwobWV0aG9kKTsKIAotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpKTsKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KG1ldGhvZCwgV2ViTWV0aG9kLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KG1ldGhvZCwgYW5ub3RhdGlvbikpOwogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKGV4ZWN1dGVDaGFuZ2UobmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSwgdGV4dEZpbGVDaGFuZ2UpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb25OYW1lKGFubm90YXRpb24pKSk7CiAgICAgICAgICAgICBhc3NlcnRUcnVlKHNvdXJjZS5nZXRJbXBvcnQoV2ViTWV0aG9kLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkuZXhpc3RzKCkpOwogICAgICAgICB9IGNhdGNoIChDb3JlRXhjZXB0aW9uIGNlKSB7CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkQW5ub3RhdGlvblRvVHlwZVRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9UeXBlVGVzdC5qYXZhCmluZGV4IDZmNTk5NDguLjA0NGZhZDMgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9UeXBlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRBbm5vdGF0aW9uVG9UeXBlVGVzdC5qYXZhCkBAIC03MiwxMSArNzIsMTEgQEAKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwoYW5ub3RhdGlvbik7CiAgICAgICAgICAgICBhc3NlcnRFcXVhbHMoV2ViU2VydmljZS5jbGFzcy5nZXRTaW1wbGVOYW1lKCksIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSk7CiAKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZUFkZEltcG9ydFRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgV2ViU2VydmljZS5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlQWRkQW5ub3RhdGlvblRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbikpOwogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKGV4ZWN1dGVDaGFuZ2UobmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSwgdGV4dEZpbGVDaGFuZ2UpKTsKLSAKKwogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChzb3VyY2UsIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOwogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShzb3VyY2UuZ2V0SW1wb3J0KFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAgICAgICAgIH0gY2F0Y2ggKENvcmVFeGNlcHRpb24gY2UpIHsKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9BZGRNZW1iZXJWYWx1ZVBhaXJUb0Fubm90YXRpb25UZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkTWVtYmVyVmFsdWVQYWlyVG9Bbm5vdGF0aW9uVGVzdC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU2ZmY1MTkKLS0tIC9kZXYvbnVsbAorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvQWRkTWVtYmVyVmFsdWVQYWlyVG9Bbm5vdGF0aW9uVGVzdC5qYXZhCkBAIC0wLDAgKzEsMTMyIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKyAqIENvcHlyaWdodCAoYykgMjAwOSBTaGFuZSBDbGFya2UuDQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscw0KKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMA0KKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0DQorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwNCisgKg0KKyAqIENvbnRyaWJ1dG9yczoNCisgKiAgICBTaGFuZSBDbGFya2UgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24NCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCitwYWNrYWdlIG9yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzOw0KKw0KK2ltcG9ydCBqYXZheC5qd3MuV2ViTWV0aG9kOw0KK2ltcG9ydCBqYXZheC5qd3MuV2ViUGFyYW07DQoraW1wb3J0IGphdmF4Lmp3cy5XZWJTZXJ2aWNlOw0KK2ltcG9ydCBqYXZheC54bWwud3MuV2ViU2VydmljZVJlZjsNCisNCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247DQoraW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklGaWVsZDsNCitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuSUxvY2FsVmFyaWFibGU7DQoraW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklNZXRob2Q7DQoraW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklUeXBlOw0KK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQW5ub3RhdGlvbjsNCitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLk1lbWJlclZhbHVlUGFpcjsNCitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLk5vcm1hbEFubm90YXRpb247DQoraW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLkFubm90YXRpb25zQ29yZTsNCitpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUudXRpbHMuQW5ub3RhdGlvblV0aWxzOw0KKw0KK3B1YmxpYyBjbGFzcyBBZGRNZW1iZXJWYWx1ZVBhaXJUb0Fubm90YXRpb25UZXN0IGV4dGVuZHMgQWJzdHJhY3RBbm5vdGF0aW9uVGVzdCB7DQorDQorCUBPdmVycmlkZQ0KKwlwcm90ZWN0ZWQgQW5ub3RhdGlvbiBnZXRBbm5vdGF0aW9uKCkgew0KKwkgICAgcmV0dXJuIG51bGw7DQorCX0NCisNCisJQE92ZXJyaWRlDQorCXByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NDb250ZW50cygpIHsNCisgICAgICAgIFN0cmluZ0J1aWxkZXIgY2xhc3NDb250ZW50cyA9IG5ldyBTdHJpbmdCdWlsZGVyKCJwYWNrYWdlIGNvbS5leGFtcGxlO1xuXG4iKTsNCisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJpbXBvcnQgamF2YXguandzLldlYlNlcnZpY2U7XG4iKTsNCisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJpbXBvcnQgamF2YXguandzLldlYk1ldGhvZDtcbiIpOw0KKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoImltcG9ydCBqYXZheC5qd3MuV2ViUGFyYW07XG4iKTsNCisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJpbXBvcnQgamF2YXgueG1sLndzLldlYlNlcnZpY2VSZWY7XG5cbiIpOw0KKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIkBXZWJTZXJ2aWNlKClcbiIpOw0KKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoInB1YmxpYyBjbGFzcyBDYWxjdWxhdG9yIHtcblxuIik7DQorICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiXHRAV2ViU2VydmljZVJlZigpXG4iKTsNCisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJcdHB1YmxpYyBTdHJpbmcgbXlGaWVsZDtcblxuIik7DQorICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiXHRAV2ViTWV0aG9kKClcbiIpOw0KKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIlx0cHVibGljIGludCBhZGQoQFdlYlBhcmFtKCkgaW50IGksIGludCBrKSB7Iik7DQorICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiXG5cdFx0cmV0dXJuIGkgKyBrO1xuXHR9XG59Iik7DQorICAgICAgICByZXR1cm4gY2xhc3NDb250ZW50cy50b1N0cmluZygpOw0KKwl9DQorDQorCUBPdmVycmlkZQ0KKwlwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsNCisJCXJldHVybiAiQ2FsY3VsYXRvci5qYXZhIjsNCisJfQ0KKw0KKwlAT3ZlcnJpZGUNCisJcHJvdGVjdGVkIFN0cmluZyBnZXRQYWNrYWdlTmFtZSgpIHsNCisJCXJldHVybiAiY29tLmV4YW1wbGUiOw0KKwl9DQorCQ0KKwlwdWJsaWMgdm9pZCB0ZXN0QWRkTWVtYmVyVmFsdWVQYWlyVG9Bbm5vdGF0aW9uKCkgew0KKyAgICAgICAgdHJ5IHsNCisgICAgICAgICAgICAvL0BXZWJTZXJ2aWNlDQorICAgICAgICAgICAgSVR5cGUgdHlwZSA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKTsNCisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgIldlYlNlcnZpY2UiKSk7DQorICAgICAgICAgICAgQW5ub3RhdGlvbiB3ZWJTZXJ2aWNlID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZSwgV2ViU2VydmljZS5jbGFzcyk7DQorICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbCh3ZWJTZXJ2aWNlKTsNCisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYlNlcnZpY2UgaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKTsNCisNCisgICAgICAgICAgICBOb3JtYWxBbm5vdGF0aW9uIHdlYlNlcnZpY2VBbm5vdGF0aW9uID0gKE5vcm1hbEFubm90YXRpb24pIHdlYlNlcnZpY2U7DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJTZXJ2aWNlQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMCk7DQorICAgICAgICAgICAgICAgICAgICANCisgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbmFtZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LCAibmFtZSIsICJDYWxjdWxhdG9yIik7DQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQorICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLmFkZE1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlQW5ub3RhdGlvbiwgbmFtZVZhbHVlUGFpcik7DQorICAgICAgICAgICAgd2ViU2VydmljZUFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZSwgV2ViU2VydmljZS5jbGFzcyk7DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJTZXJ2aWNlQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMSk7DQorDQorICAgICAgICAgICAgLy9AV2ViU2VydmljZVJlZg0KKyAgICAgICAgICAgIElGaWVsZCBmaWVsZCA9IHR5cGUuZ2V0RmllbGQoIm15RmllbGQiKTsNCisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KGZpZWxkLCAiV2ViU2VydmljZVJlZiIpKTsNCisgICAgICAgICAgICBBbm5vdGF0aW9uIHdlYlNlcnZpY2VSZWYgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihmaWVsZCwgV2ViU2VydmljZVJlZi5jbGFzcyk7DQorICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbCh3ZWJTZXJ2aWNlUmVmKTsNCisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYlNlcnZpY2VSZWYgaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKTsNCisNCisgICAgICAgICAgICBOb3JtYWxBbm5vdGF0aW9uIHdlYlNlcnZpY2VSZWZBbm5vdGF0aW9uID0gKE5vcm1hbEFubm90YXRpb24pIHdlYlNlcnZpY2VSZWY7DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJTZXJ2aWNlUmVmQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMCk7DQorICAgICAgICAgICAgICAgICAgICANCisgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWFwcGVkTmFtZVZhbHVlUGFpciA9IEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdNZW1iZXJWYWx1ZVBhaXIoYXN0LCAibWFwcGVkTmFtZSIsICJteUZpZWxkIik7DQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQorICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLmFkZE1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlUmVmQW5ub3RhdGlvbiwgbWFwcGVkTmFtZVZhbHVlUGFpcik7DQorICAgICAgICAgICAgd2ViU2VydmljZVJlZkFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24oZmllbGQsIFdlYlNlcnZpY2VSZWYuY2xhc3MpOw0KKyAgICAgICAgICAgIGFzc2VydFRydWUod2ViU2VydmljZVJlZkFubm90YXRpb24udmFsdWVzKCkuc2l6ZSgpID09IDEpOw0KKw0KKyAgICAgICAgICAgIC8vQFdlYk1ldGhvZA0KKyAgICAgICAgICAgIElNZXRob2QgbWV0aG9kID0gdHlwZS5nZXRNZXRob2QoImFkZCIsIG5ldyBTdHJpbmdbXSB7ICJJIiwgIkkiIH0pOw0KKyAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQobWV0aG9kLCAiV2ViTWV0aG9kIikpOw0KKyAgICAgICAgICAgIEFubm90YXRpb24gd2ViTWV0aG9kID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24obWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpOw0KKyAgICAgICAgICAgIGFzc2VydE5vdE51bGwod2ViTWV0aG9kKTsNCisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYk1ldGhvZCBpbnN0YW5jZW9mIE5vcm1hbEFubm90YXRpb24pOw0KKw0KKyAgICAgICAgICAgIE5vcm1hbEFubm90YXRpb24gd2ViTWV0aG9kQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSB3ZWJNZXRob2Q7DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJNZXRob2RBbm5vdGF0aW9uLnZhbHVlcygpLnNpemUoKSA9PSAwKTsNCisgICAgICAgICAgICAgICAgICAgIA0KKyAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBvcGVyYXRpb25OYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsICJvcGVyYXRpb25OYW1lIiwgImFkZCIpOw0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA0KKyAgICAgICAgICAgIEFubm90YXRpb25VdGlscy5hZGRNZW1iZXJWYWx1ZVBhaXIod2ViTWV0aG9kQW5ub3RhdGlvbiwgb3BlcmF0aW9uTmFtZVZhbHVlUGFpcik7DQorICAgICAgICAgICAgd2ViTWV0aG9kQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihtZXRob2QsIFdlYk1ldGhvZC5jbGFzcyk7DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJNZXRob2RBbm5vdGF0aW9uLnZhbHVlcygpLnNpemUoKSA9PSAxKTsNCisNCisgICAgICAgICAgICAvL0BXZWJQYXJhbQ0KKyAgICAgICAgICAgIElMb2NhbFZhcmlhYmxlIGxvY2FsVmFyaWFibGUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0TG9jYWxWYXJpYWJsZShtZXRob2QsICJpIik7DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChsb2NhbFZhcmlhYmxlLCAiV2ViUGFyYW0iKSk7DQorICAgICAgICAgICAgQW5ub3RhdGlvbiB3ZWJQYXJhbSA9IEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKGxvY2FsVmFyaWFibGUsIFdlYlBhcmFtLmNsYXNzKTsNCisgICAgICAgICAgICBhc3NlcnROb3ROdWxsKHdlYlBhcmFtKTsNCisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYlBhcmFtIGluc3RhbmNlb2YgTm9ybWFsQW5ub3RhdGlvbik7DQorDQorICAgICAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiB3ZWJQYXJhbUFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgd2ViUGFyYW07DQorICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJQYXJhbUFubm90YXRpb24udmFsdWVzKCkuc2l6ZSgpID09IDApOw0KKyAgICAgICAgICAgICAgICAgICAgDQorICAgICAgICAgICAgTWVtYmVyVmFsdWVQYWlyIHBhcnROYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ01lbWJlclZhbHVlUGFpcihhc3QsICJwYXJ0TmFtZSIsICJpIik7DQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQorICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLmFkZE1lbWJlclZhbHVlUGFpcih3ZWJQYXJhbUFubm90YXRpb24sIHBhcnROYW1lVmFsdWVQYWlyKTsNCisgICAgICAgICAgICB3ZWJQYXJhbUFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24obG9jYWxWYXJpYWJsZSwgV2ViUGFyYW0uY2xhc3MpOw0KKyAgICAgICAgICAgIGFzc2VydFRydWUod2ViUGFyYW1Bbm5vdGF0aW9uLnZhbHVlcygpLnNpemUoKSA9PSAxKTsNCisgICAgICAgIH0gY2F0Y2ggKENvcmVFeGNlcHRpb24gY2UpIHsNCisgICAgICAgICAgICBmYWlsKGNlLmdldExvY2FsaXplZE1lc3NhZ2UoKSk7DQorICAgICAgICB9DQorCX0NCit9DQpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0pBWFdTQ29yZVRlc3RTdWl0ZS5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL0pBWFdTQ29yZVRlc3RTdWl0ZS5qYXZhCmluZGV4IGZmMGEwYjUuLjhiZWJmMTUgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9KQVhXU0NvcmVUZXN0U3VpdGUuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvSkFYV1NDb3JlVGVzdFN1aXRlLmphdmEKQEAgLTE4LDcgKzE4LDcgQEAKICAgICBwdWJsaWMgc3RhdGljIFRlc3Qgc3VpdGUoKSB7CiAgICAgICAgIHJldHVybiBuZXcgSkFYV1NDb3JlVGVzdFN1aXRlKCk7CiAgICAgfQotICAgIAorCiAgICAgcHVibGljIEpBWFdTQ29yZVRlc3RTdWl0ZSgpIHsKICAgICAgICAgc3VwZXIoIkpBWC1XUyBDb3JlIFRlc3RzIik7CiAgICAgICAgIGFkZFRlc3RTdWl0ZShBZGRBbm5vdGF0aW9uVG9UeXBlVGVzdC5jbGFzcyk7CkBAIC0yOCw3ICsyOCwxMSBAQAogICAgICAgICBhZGRUZXN0U3VpdGUoQWRkQW5ub3RhdGlvblRvTWV0aG9kVGVzdC5jbGFzcyk7CiAgICAgICAgIGFkZFRlc3RTdWl0ZShSZW1vdmVBbm5vdGF0aW9uRnJvbU1ldGhvZFRlc3QuY2xhc3MpOwogICAgICAgICBhZGRUZXN0U3VpdGUoQWRkQW5ub3RhdGlvblRvTWV0aG9kUGFyYW1ldGVyVGVzdC5jbGFzcyk7Ci0gICAgICAgIGFkZFRlc3RTdWl0ZShSZW1vdmVBbm5vdGF0aW9uRnJvbU1ldGhvZFBhcmFtZXRlclRlc3QuY2xhc3MpOyAgICAgICAgCisgICAgICAgIGFkZFRlc3RTdWl0ZShSZW1vdmVBbm5vdGF0aW9uRnJvbU1ldGhvZFBhcmFtZXRlclRlc3QuY2xhc3MpOworICAgICAgICBhZGRUZXN0U3VpdGUoQWRkTWVtYmVyVmFsdWVQYWlyVG9Bbm5vdGF0aW9uVGVzdC5jbGFzcyk7CisgICAgICAgIGFkZFRlc3RTdWl0ZShSZW1vdmVNZW1iZXJWYWx1ZVBhaXJUZXN0LmNsYXNzKTsKKyAgICAgICAgYWRkVGVzdFN1aXRlKFVwZGF0ZU1lbWJlclZhbHVlUGFpclRlc3QuY2xhc3MpOworICAgICAgICBhZGRUZXN0U3VpdGUoVXBkYXRlU2luZ2xlTWVtYmVyQW5ub3RhdGlvblRlc3QuY2xhc3MpOwogICAgIH0KLSAgICAKKwogfQpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tRmllbGRUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21GaWVsZFRlc3QuamF2YQppbmRleCA5YjFmMzkzLi40YWJmZGY3IDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21GaWVsZFRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21GaWVsZFRlc3QuamF2YQpAQCAtNTQsMTIgKzU0LDEyIEBACiAKICAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQoZmllbGQsIEFubm90YXRpb25VdGlscwogICAgICAgICAgICAgICAgICAgICAuZ2V0QW5ub3RhdGlvbk5hbWUoYW5ub3RhdGlvbikpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICBhc3NlcnROb3ROdWxsKHNvdXJjZS5nZXRJbXBvcnQoV2ViU2VydmljZVJlZi5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVBbm5vdGF0aW9uVGV4dEVkaXQoZmllbGQsIGFubm90YXRpb24pKTsKLSAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVJlbW92ZUltcG9ydFRleHRFZGl0KGZpZWxkLCBXZWJTZXJ2aWNlUmVmLmNsYXNzKSk7Ci0gICAgICAgICAgICAKKyAgICAgICAgICAgIHRleHRGaWxlQ2hhbmdlLmFkZEVkaXQoQW5ub3RhdGlvblV0aWxzLmNyZWF0ZVJlbW92ZUltcG9ydFRleHRFZGl0KGZpZWxkLCBXZWJTZXJ2aWNlUmVmLmNsYXNzLmdldENhbm9uaWNhbE5hbWUoKSkpOworCiAgICAgICAgICAgICBhc3NlcnRUcnVlKGV4ZWN1dGVDaGFuZ2UobmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSwgdGV4dEZpbGVDaGFuZ2UpKTsKIAogICAgICAgICAgICAgYXNzZXJ0RmFsc2UoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQoZmllbGQsIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOwpkaWZmIC0tZ2l0IGEvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tTWV0aG9kUGFyYW1ldGVyVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tTWV0aG9kUGFyYW1ldGVyVGVzdC5qYXZhCmluZGV4IDgzYjdkMzUuLjkwNzBiMTQgMTAwNjQ0Ci0tLSBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9SZW1vdmVBbm5vdGF0aW9uRnJvbU1ldGhvZFBhcmFtZXRlclRlc3QuamF2YQorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21NZXRob2RQYXJhbWV0ZXJUZXN0LmphdmEKQEAgLTU4LDEyICs1OCwxMiBAQAogCiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KGxvY2FsVmFyaWFibGUsIGFubm90YXRpb24pKTsKICAgICAgICAgICAgIGFzc2VydE5vdE51bGwoc291cmNlLmdldEltcG9ydChXZWJQYXJhbS5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVBbm5vdGF0aW9uVGV4dEVkaXQobG9jYWxWYXJpYWJsZSwgYW5ub3RhdGlvbikpOwotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlSW1wb3J0VGV4dEVkaXQobG9jYWxWYXJpYWJsZSwgV2ViUGFyYW0uY2xhc3MpKTsKLSAgICAgICAgICAgIAorICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlSW1wb3J0VGV4dEVkaXQobG9jYWxWYXJpYWJsZSwgV2ViUGFyYW0uY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CisKICAgICAgICAgICAgIGFzc2VydFRydWUoZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCB0ZXh0RmlsZUNoYW5nZSkpOwotICAgICAgICAgICAgCisKICAgICAgICAgICAgIGFzc2VydEZhbHNlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KGxvY2FsVmFyaWFibGUsIGFubm90YXRpb24pKTsKICAgICAgICAgICAgIGFzc2VydEZhbHNlKHNvdXJjZS5nZXRJbXBvcnQoV2ViUGFyYW0uY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKS5leGlzdHMoKSk7CiAgICAgICAgIH0gY2F0Y2ggKENvcmVFeGNlcHRpb24gY2UpIHsKZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9SZW1vdmVBbm5vdGF0aW9uRnJvbU1ldGhvZFRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9SZW1vdmVBbm5vdGF0aW9uRnJvbU1ldGhvZFRlc3QuamF2YQppbmRleCA4ZGNhNmU3Li5iOTJhMWE0IDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21NZXRob2RUZXN0LmphdmEKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tTWV0aG9kVGVzdC5qYXZhCkBAIC01Niw5ICs1Niw5IEBACiAgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgQW5ub3RhdGlvblV0aWxzCiAgICAgICAgICAgICAgICAgICAgIC5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOwogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChzb3VyY2UuZ2V0SW1wb3J0KFdlYk1ldGhvZC5jbGFzcy5nZXRDYW5vbmljYWxOYW1lKCkpKTsKLSAgICAgICAgICAgIAorCiAgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVBbm5vdGF0aW9uVGV4dEVkaXQobWV0aG9kLCBhbm5vdGF0aW9uKSk7Ci0gICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVJbXBvcnRUZXh0RWRpdChtZXRob2QsIFdlYk1ldGhvZC5jbGFzcykpOworICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlSW1wb3J0VGV4dEVkaXQobWV0aG9kLCBXZWJNZXRob2QuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIGFzc2VydFRydWUoZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCB0ZXh0RmlsZUNoYW5nZSkpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21UeXBlVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZUFubm90YXRpb25Gcm9tVHlwZVRlc3QuamF2YQppbmRleCBiOWM5MzhhLi42OTMzN2Q2IDEwMDY0NAotLS0gYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlQW5ub3RhdGlvbkZyb21UeXBlVGVzdC5qYXZhCisrKyBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9SZW1vdmVBbm5vdGF0aW9uRnJvbVR5cGVUZXN0LmphdmEKQEAgLTU0LDkgKzU0LDkgQEAKIAogICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChzb3VyY2UsIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uTmFtZShhbm5vdGF0aW9uKSkpOwogICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChzb3VyY2UuZ2V0SW1wb3J0KFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7Ci0gICAgICAgICAgICAKKwogICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlQW5ub3RhdGlvblRleHRFZGl0KHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKSwgYW5ub3RhdGlvbikpOwotICAgICAgICAgICAgdGV4dEZpbGVDaGFuZ2UuYWRkRWRpdChBbm5vdGF0aW9uVXRpbHMuY3JlYXRlUmVtb3ZlSW1wb3J0VGV4dEVkaXQoc291cmNlLmZpbmRQcmltYXJ5VHlwZSgpLCBXZWJTZXJ2aWNlLmNsYXNzKSk7CisgICAgICAgICAgICB0ZXh0RmlsZUNoYW5nZS5hZGRFZGl0KEFubm90YXRpb25VdGlscy5jcmVhdGVSZW1vdmVJbXBvcnRUZXh0RWRpdChzb3VyY2UuZmluZFByaW1hcnlUeXBlKCksIFdlYlNlcnZpY2UuY2xhc3MuZ2V0Q2Fub25pY2FsTmFtZSgpKSk7CiAKICAgICAgICAgICAgIGFzc2VydFRydWUoZXhlY3V0ZUNoYW5nZShuZXcgTnVsbFByb2dyZXNzTW9uaXRvcigpLCB0ZXh0RmlsZUNoYW5nZSkpOwogCmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvUmVtb3ZlTWVtYmVyVmFsdWVQYWlyVGVzdC5qYXZhIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZU1lbWJlclZhbHVlUGFpclRlc3QuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44NDAzMmY0Ci0tLSAvZGV2L251bGwKKysrIGIvdGVzdHMvb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHMvc3JjL29yZy9lY2xpcHNlL2pzdC93cy9qYXh3cy9jb3JlL3Rlc3RzL1JlbW92ZU1lbWJlclZhbHVlUGFpclRlc3QuamF2YQpAQCAtMCwwICsxLDY4IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogQ29weXJpZ2h0IChjKSAyMDA5IFNoYW5lIENsYXJrZS4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgU2hhbmUgQ2xhcmtlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHM7CisKK2ltcG9ydCBqYXZheC5qd3MuV2ViU2VydmljZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JVHlwZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQW5ub3RhdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uTWVtYmVyVmFsdWVQYWlyOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Ob3JtYWxBbm5vdGF0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLnV0aWxzLkFubm90YXRpb25VdGlsczsKKworcHVibGljIGNsYXNzIFJlbW92ZU1lbWJlclZhbHVlUGFpclRlc3QgZXh0ZW5kcyBBYnN0cmFjdEFubm90YXRpb25UZXN0IHsKKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBBbm5vdGF0aW9uIGdldEFubm90YXRpb24oKSB7CisgICAgICAgIHJldHVybiBudWxsOworICAgIH0KKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NDb250ZW50cygpIHsKKyAgICAgICAgU3RyaW5nQnVpbGRlciBjbGFzc0NvbnRlbnRzID0gbmV3IFN0cmluZ0J1aWxkZXIoInBhY2thZ2UgY29tLmV4YW1wbGU7XG5cbiIpOworICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiaW1wb3J0IGphdmF4Lmp3cy5XZWJTZXJ2aWNlO1xuXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIkBXZWJTZXJ2aWNlKG5hbWU9XCJDYWxjdWxhdG9yXCIpXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoInB1YmxpYyBjbGFzcyBDYWxjdWxhdG9yIHtcbn0iKTsKKyAgICAgICAgcmV0dXJuIGNsYXNzQ29udGVudHMudG9TdHJpbmcoKTsKKyAgICB9CisKKyAgICBAT3ZlcnJpZGUKKyAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKKyAgICAgICAgcmV0dXJuICJDYWxjdWxhdG9yLmphdmEiOworICAgIH0KKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0UGFja2FnZU5hbWUoKSB7CisgICAgICAgIHJldHVybiAiY29tLmV4YW1wbGUiOworICAgIH0KKworICAgIHB1YmxpYyB2b2lkIHRlc3RSZW1vdmVNZW1iZXJWYWx1ZVBhaXJGcm9tQW5ub3RhdGlvbigpIHsKKyAgICAgICAgdHJ5IHsKKyAgICAgICAgICAgIElUeXBlIHR5cGUgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgIldlYlNlcnZpY2UiKSk7CisgICAgICAgICAgICBBbm5vdGF0aW9uIHdlYlNlcnZpY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbih0eXBlLCBXZWJTZXJ2aWNlLmNsYXNzKTsKKyAgICAgICAgICAgIGFzc2VydE5vdE51bGwod2ViU2VydmljZSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYlNlcnZpY2UgaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKTsKKworICAgICAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiB3ZWJTZXJ2aWNlQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSB3ZWJTZXJ2aWNlOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJTZXJ2aWNlQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMSk7CisKKyAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBuYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvblV0aWxzLmdldE1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlQW5ub3RhdGlvbiwgIm5hbWUiKTsKKworICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLnJlbW92ZU1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlQW5ub3RhdGlvbiwgbmFtZVZhbHVlUGFpcik7CisgICAgICAgICAgICB3ZWJTZXJ2aWNlQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbih0eXBlLCBXZWJTZXJ2aWNlLmNsYXNzKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUod2ViU2VydmljZUFubm90YXRpb24udmFsdWVzKCkuc2l6ZSgpID09IDApOworICAgICAgICB9IGNhdGNoIChDb3JlRXhjZXB0aW9uIGNlKSB7CisgICAgICAgICAgICBmYWlsKGNlLmdldExvY2FsaXplZE1lc3NhZ2UoKSk7CisgICAgICAgIH0KKyAgICB9CisKK30KZGlmZiAtLWdpdCBhL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9VcGRhdGVNZW1iZXJWYWx1ZVBhaXJUZXN0LmphdmEgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvVXBkYXRlTWVtYmVyVmFsdWVQYWlyVGVzdC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI5ZGFmMWEKLS0tIC9kZXYvbnVsbAorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvVXBkYXRlTWVtYmVyVmFsdWVQYWlyVGVzdC5qYXZhCkBAIC0wLDAgKzEsMTU0IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogQ29weXJpZ2h0IChjKSAyMDA5IFNoYW5lIENsYXJrZS4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgU2hhbmUgQ2xhcmtlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHM7CisKK2ltcG9ydCBqYXZheC5qd3MuV2ViTWV0aG9kOworaW1wb3J0IGphdmF4Lmp3cy5XZWJQYXJhbTsKK2ltcG9ydCBqYXZheC5qd3MuV2ViU2VydmljZTsKK2ltcG9ydCBqYXZheC54bWwud3MuV2ViU2VydmljZVJlZjsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5Db3JlRXhjZXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklGaWVsZDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JTG9jYWxWYXJpYWJsZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JTWV0aG9kOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLklUeXBlOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5Bbm5vdGF0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmpkdC5jb3JlLmRvbS5NZW1iZXJWYWx1ZVBhaXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLk5vcm1hbEFubm90YXRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuamR0LmNvcmUuZG9tLlN0cmluZ0xpdGVyYWw7CitpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUuQW5ub3RhdGlvbnNDb3JlOworaW1wb3J0IG9yZy5lY2xpcHNlLmpzdC53cy5hbm5vdGF0aW9ucy5jb3JlLnV0aWxzLkFubm90YXRpb25VdGlsczsKKworcHVibGljIGNsYXNzIFVwZGF0ZU1lbWJlclZhbHVlUGFpclRlc3QgZXh0ZW5kcyBBYnN0cmFjdEFubm90YXRpb25UZXN0IHsKKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBBbm5vdGF0aW9uIGdldEFubm90YXRpb24oKSB7CisgICAgICAgIHJldHVybiBudWxsOworICAgIH0KKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NDb250ZW50cygpIHsKKyAgICAgICAgU3RyaW5nQnVpbGRlciBjbGFzc0NvbnRlbnRzID0gbmV3IFN0cmluZ0J1aWxkZXIoInBhY2thZ2UgY29tLmV4YW1wbGU7XG5cbiIpOworICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiaW1wb3J0IGphdmF4Lmp3cy5XZWJTZXJ2aWNlO1xuIik7CisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJpbXBvcnQgamF2YXguandzLldlYk1ldGhvZDtcbiIpOworICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiaW1wb3J0IGphdmF4Lmp3cy5XZWJQYXJhbTtcbiIpOworICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiaW1wb3J0IGphdmF4LnhtbC53cy5XZWJTZXJ2aWNlUmVmO1xuXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIkBXZWJTZXJ2aWNlKG5hbWU9XCJDYWxjdWxhdG9yXCIpXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoInB1YmxpYyBjbGFzcyBDYWxjdWxhdG9yIHtcblxuIik7CisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJcdEBXZWJTZXJ2aWNlUmVmKG1hcHBlZE5hbWU9XCJteUZpZWxkXCIpXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIlx0cHVibGljIFN0cmluZyBteUZpZWxkO1xuXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIlx0QFdlYk1ldGhvZChvcGVyYXRpb25OYW1lPVwiYWRkXCIpXG4iKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIlx0cHVibGljIGludCBhZGQoQFdlYlBhcmFtKHBhcnROYW1lPVwiaVwiKSBpbnQgaSwgaW50IGspIHsiKTsKKyAgICAgICAgY2xhc3NDb250ZW50cy5hcHBlbmQoIlxuXHRcdHJldHVybiBpICsgaztcblx0fVxufSIpOworICAgICAgICByZXR1cm4gY2xhc3NDb250ZW50cy50b1N0cmluZygpOworICAgIH0KKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NOYW1lKCkgeworICAgICAgICByZXR1cm4gIkNhbGN1bGF0b3IuamF2YSI7CisgICAgfQorCisgICAgQE92ZXJyaWRlCisgICAgcHJvdGVjdGVkIFN0cmluZyBnZXRQYWNrYWdlTmFtZSgpIHsKKyAgICAgICAgcmV0dXJuICJjb20uZXhhbXBsZSI7CisgICAgfQorCisgICAgcHVibGljIHZvaWQgdGVzdFVwZGF0ZU1lbWJlclZhbHVlUGFpcigpIHsKKyAgICAgICAgdHJ5IHsKKyAgICAgICAgICAgIC8vQFdlYlNlcnZpY2UKKyAgICAgICAgICAgIElUeXBlIHR5cGUgPSBzb3VyY2UuZmluZFByaW1hcnlUeXBlKCk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KHNvdXJjZSwgIldlYlNlcnZpY2UiKSk7CisgICAgICAgICAgICBBbm5vdGF0aW9uIHdlYlNlcnZpY2UgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbih0eXBlLCBXZWJTZXJ2aWNlLmNsYXNzKTsKKyAgICAgICAgICAgIGFzc2VydE5vdE51bGwod2ViU2VydmljZSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYlNlcnZpY2UgaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKTsKKworICAgICAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiB3ZWJTZXJ2aWNlQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSB3ZWJTZXJ2aWNlOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJTZXJ2aWNlQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMSk7CisKKyAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBuYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvblV0aWxzLmdldE1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlQW5ub3RhdGlvbiwgIm5hbWUiKTsKKyAgICAgICAgICAgIGFzc2VydE5vdE51bGwobmFtZVZhbHVlUGFpcik7CisgICAgICAgICAgICBTdHJpbmdMaXRlcmFsIG5hbWVWYWx1ZSA9ICAoU3RyaW5nTGl0ZXJhbCkgbmFtZVZhbHVlUGFpci5nZXRWYWx1ZSgpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShuYW1lVmFsdWUuZ2V0TGl0ZXJhbFZhbHVlKCkuZXF1YWxzKCJDYWxjdWxhdG9yIikpOworCisgICAgICAgICAgICBBbm5vdGF0aW9uVXRpbHMudXBkYXRlTWVtYmVyVmFsdWVQYWlyKG5hbWVWYWx1ZVBhaXIsIEFubm90YXRpb25zQ29yZS5jcmVhdGVTdHJpbmdMaXRlcmFsKGFzdCwgIlNjaWVudGlmaWNDYWxjdWxhdG9yIikpOworICAgICAgICAgICAgd2ViU2VydmljZUFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZSwgV2ViU2VydmljZS5jbGFzcyk7CisgICAgICAgICAgICBuYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvblV0aWxzLmdldE1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlQW5ub3RhdGlvbiwgIm5hbWUiKTsKKyAgICAgICAgICAgIG5hbWVWYWx1ZSA9ICAoU3RyaW5nTGl0ZXJhbCkgbmFtZVZhbHVlUGFpci5nZXRWYWx1ZSgpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShuYW1lVmFsdWUuZ2V0TGl0ZXJhbFZhbHVlKCkuZXF1YWxzKCJTY2llbnRpZmljQ2FsY3VsYXRvciIpKTsKKworICAgICAgICAgICAgLy9AV2ViU2VydmljZVJlZgorICAgICAgICAgICAgSUZpZWxkIGZpZWxkID0gdHlwZS5nZXRGaWVsZCgibXlGaWVsZCIpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShBbm5vdGF0aW9uVXRpbHMuaXNBbm5vdGF0aW9uUHJlc2VudChmaWVsZCwgIldlYlNlcnZpY2VSZWYiKSk7CisgICAgICAgICAgICBBbm5vdGF0aW9uIHdlYlNlcnZpY2VSZWYgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihmaWVsZCwgV2ViU2VydmljZVJlZi5jbGFzcyk7CisgICAgICAgICAgICBhc3NlcnROb3ROdWxsKHdlYlNlcnZpY2VSZWYpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJTZXJ2aWNlUmVmIGluc3RhbmNlb2YgTm9ybWFsQW5ub3RhdGlvbik7CisKKyAgICAgICAgICAgIE5vcm1hbEFubm90YXRpb24gd2ViU2VydmljZVJlZkFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgd2ViU2VydmljZVJlZjsKKyAgICAgICAgICAgIGFzc2VydFRydWUod2ViU2VydmljZVJlZkFubm90YXRpb24udmFsdWVzKCkuc2l6ZSgpID09IDEpOworCisgICAgICAgICAgICBNZW1iZXJWYWx1ZVBhaXIgbWFwcGVkTmFtZVZhbHVlUGFpciA9IEFubm90YXRpb25VdGlscy5nZXRNZW1iZXJWYWx1ZVBhaXIod2ViU2VydmljZVJlZkFubm90YXRpb24sICJtYXBwZWROYW1lIik7CisgICAgICAgICAgICBhc3NlcnROb3ROdWxsKG1hcHBlZE5hbWVWYWx1ZVBhaXIpOworICAgICAgICAgICAgU3RyaW5nTGl0ZXJhbCBtYXBwZWROYW1lVmFsdWUgPSAgKFN0cmluZ0xpdGVyYWwpIG1hcHBlZE5hbWVWYWx1ZVBhaXIuZ2V0VmFsdWUoKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUobWFwcGVkTmFtZVZhbHVlLmdldExpdGVyYWxWYWx1ZSgpLmVxdWFscygibXlGaWVsZCIpKTsKKworICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLnVwZGF0ZU1lbWJlclZhbHVlUGFpcihtYXBwZWROYW1lVmFsdWVQYWlyLCBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlU3RyaW5nTGl0ZXJhbChhc3QsICJhbm90aGVyRmllbGQiKSk7CisgICAgICAgICAgICB3ZWJTZXJ2aWNlUmVmQW5ub3RhdGlvbiA9IChOb3JtYWxBbm5vdGF0aW9uKSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihmaWVsZCwgV2ViU2VydmljZVJlZi5jbGFzcyk7CisgICAgICAgICAgICBtYXBwZWROYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvblV0aWxzLmdldE1lbWJlclZhbHVlUGFpcih3ZWJTZXJ2aWNlUmVmQW5ub3RhdGlvbiwgIm1hcHBlZE5hbWUiKTsKKyAgICAgICAgICAgIG1hcHBlZE5hbWVWYWx1ZSA9ICAoU3RyaW5nTGl0ZXJhbCkgbWFwcGVkTmFtZVZhbHVlUGFpci5nZXRWYWx1ZSgpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShtYXBwZWROYW1lVmFsdWUuZ2V0TGl0ZXJhbFZhbHVlKCkuZXF1YWxzKCJhbm90aGVyRmllbGQiKSk7CisKKyAgICAgICAgICAgIC8vQFdlYk1ldGhvZAorICAgICAgICAgICAgSU1ldGhvZCBtZXRob2QgPSB0eXBlLmdldE1ldGhvZCgiYWRkIiwgbmV3IFN0cmluZ1tdIHsgIkkiLCAiSSIgfSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KG1ldGhvZCwgIldlYk1ldGhvZCIpKTsKKyAgICAgICAgICAgIEFubm90YXRpb24gd2ViTWV0aG9kID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24obWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpOworICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbCh3ZWJNZXRob2QpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZSh3ZWJNZXRob2QgaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKTsKKworICAgICAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiB3ZWJNZXRob2RBbm5vdGF0aW9uID0gKE5vcm1hbEFubm90YXRpb24pIHdlYk1ldGhvZDsKKyAgICAgICAgICAgIGFzc2VydFRydWUod2ViTWV0aG9kQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMSk7CisKKyAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBvcGVyYXRpb25OYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvblV0aWxzLmdldE1lbWJlclZhbHVlUGFpcih3ZWJNZXRob2RBbm5vdGF0aW9uLCAib3BlcmF0aW9uTmFtZSIpOworICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChvcGVyYXRpb25OYW1lVmFsdWVQYWlyKTsKKyAgICAgICAgICAgIFN0cmluZ0xpdGVyYWwgb3BlcmF0aW9uTmFtZVZhbHVlID0gIChTdHJpbmdMaXRlcmFsKSBvcGVyYXRpb25OYW1lVmFsdWVQYWlyLmdldFZhbHVlKCk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKG9wZXJhdGlvbk5hbWVWYWx1ZS5nZXRMaXRlcmFsVmFsdWUoKS5lcXVhbHMoImFkZCIpKTsKKworICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLnVwZGF0ZU1lbWJlclZhbHVlUGFpcihvcGVyYXRpb25OYW1lVmFsdWVQYWlyLCBBbm5vdGF0aW9uc0NvcmUuY3JlYXRlU3RyaW5nTGl0ZXJhbChhc3QsICJtdWx0aXBseSIpKTsKKyAgICAgICAgICAgIHdlYk1ldGhvZEFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24obWV0aG9kLCBXZWJNZXRob2QuY2xhc3MpOworICAgICAgICAgICAgb3BlcmF0aW9uTmFtZVZhbHVlUGFpciA9IEFubm90YXRpb25VdGlscy5nZXRNZW1iZXJWYWx1ZVBhaXIod2ViTWV0aG9kQW5ub3RhdGlvbiwgIm9wZXJhdGlvbk5hbWUiKTsKKyAgICAgICAgICAgIG9wZXJhdGlvbk5hbWVWYWx1ZSA9ICAoU3RyaW5nTGl0ZXJhbCkgb3BlcmF0aW9uTmFtZVZhbHVlUGFpci5nZXRWYWx1ZSgpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShvcGVyYXRpb25OYW1lVmFsdWUuZ2V0TGl0ZXJhbFZhbHVlKCkuZXF1YWxzKCJtdWx0aXBseSIpKTsKKworICAgICAgICAgICAgLy9AV2ViUGFyYW0KKyAgICAgICAgICAgIElMb2NhbFZhcmlhYmxlIGxvY2FsVmFyaWFibGUgPSBBbm5vdGF0aW9uVXRpbHMuZ2V0TG9jYWxWYXJpYWJsZShtZXRob2QsICJpIik7CisgICAgICAgICAgICBhc3NlcnRUcnVlKEFubm90YXRpb25VdGlscy5pc0Fubm90YXRpb25QcmVzZW50KGxvY2FsVmFyaWFibGUsICJXZWJQYXJhbSIpKTsKKyAgICAgICAgICAgIEFubm90YXRpb24gd2ViUGFyYW0gPSBBbm5vdGF0aW9uVXRpbHMuZ2V0QW5ub3RhdGlvbihsb2NhbFZhcmlhYmxlLCBXZWJQYXJhbS5jbGFzcyk7CisgICAgICAgICAgICBhc3NlcnROb3ROdWxsKHdlYlBhcmFtKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUod2ViUGFyYW0gaW5zdGFuY2VvZiBOb3JtYWxBbm5vdGF0aW9uKTsKKworICAgICAgICAgICAgTm9ybWFsQW5ub3RhdGlvbiB3ZWJQYXJhbUFubm90YXRpb24gPSAoTm9ybWFsQW5ub3RhdGlvbikgd2ViUGFyYW07CisgICAgICAgICAgICBhc3NlcnRUcnVlKHdlYlBhcmFtQW5ub3RhdGlvbi52YWx1ZXMoKS5zaXplKCkgPT0gMSk7CisKKyAgICAgICAgICAgIE1lbWJlclZhbHVlUGFpciBwYXJ0TmFtZVZhbHVlUGFpciA9IEFubm90YXRpb25VdGlscy5nZXRNZW1iZXJWYWx1ZVBhaXIod2ViUGFyYW1Bbm5vdGF0aW9uLCAicGFydE5hbWUiKTsKKyAgICAgICAgICAgIGFzc2VydE5vdE51bGwocGFydE5hbWVWYWx1ZVBhaXIpOworICAgICAgICAgICAgU3RyaW5nTGl0ZXJhbCBwYXJ0TmFtZVZhbHVlID0gIChTdHJpbmdMaXRlcmFsKSBwYXJ0TmFtZVZhbHVlUGFpci5nZXRWYWx1ZSgpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShwYXJ0TmFtZVZhbHVlLmdldExpdGVyYWxWYWx1ZSgpLmVxdWFscygiaSIpKTsKKworICAgICAgICAgICAgQW5ub3RhdGlvblV0aWxzLnVwZGF0ZU1lbWJlclZhbHVlUGFpcihwYXJ0TmFtZVZhbHVlUGFpciwgQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ0xpdGVyYWwoYXN0LCAiaWlpIikpOworICAgICAgICAgICAgd2ViUGFyYW1Bbm5vdGF0aW9uID0gKE5vcm1hbEFubm90YXRpb24pIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKGxvY2FsVmFyaWFibGUsIFdlYlBhcmFtLmNsYXNzKTsKKyAgICAgICAgICAgIHBhcnROYW1lVmFsdWVQYWlyID0gQW5ub3RhdGlvblV0aWxzLmdldE1lbWJlclZhbHVlUGFpcih3ZWJQYXJhbUFubm90YXRpb24sICJwYXJ0TmFtZSIpOworICAgICAgICAgICAgcGFydE5hbWVWYWx1ZSA9ICAoU3RyaW5nTGl0ZXJhbCkgcGFydE5hbWVWYWx1ZVBhaXIuZ2V0VmFsdWUoKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUocGFydE5hbWVWYWx1ZS5nZXRMaXRlcmFsVmFsdWUoKS5lcXVhbHMoImlpaSIpKTsKKyAgICAgICAgfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBjZSkgeworICAgICAgICAgICAgZmFpbChjZS5nZXRMb2NhbGl6ZWRNZXNzYWdlKCkpOworICAgICAgICB9CisgICAgfQorCit9CmRpZmYgLS1naXQgYS90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvVXBkYXRlU2luZ2xlTWVtYmVyQW5ub3RhdGlvblRlc3QuamF2YSBiL3Rlc3RzL29yZy5lY2xpcHNlLmpzdC53cy5qYXh3cy5jb3JlLnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9qc3Qvd3MvamF4d3MvY29yZS90ZXN0cy9VcGRhdGVTaW5nbGVNZW1iZXJBbm5vdGF0aW9uVGVzdC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI5ZGExNDcKLS0tIC9kZXYvbnVsbAorKysgYi90ZXN0cy9vcmcuZWNsaXBzZS5qc3Qud3MuamF4d3MuY29yZS50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvanN0L3dzL2pheHdzL2NvcmUvdGVzdHMvVXBkYXRlU2luZ2xlTWVtYmVyQW5ub3RhdGlvblRlc3QuamF2YQpAQCAtMCwwICsxLDcwIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogQ29weXJpZ2h0IChjKSAyMDA5IFNoYW5lIENsYXJrZS4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgU2hhbmUgQ2xhcmtlIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2UuanN0LndzLmpheHdzLmNvcmUudGVzdHM7CisKK2ltcG9ydCBqYXZheC54bWwud3MuQmluZGluZ1R5cGU7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JVHlwZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uQW5ub3RhdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uU2luZ2xlTWVtYmVyQW5ub3RhdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5kb20uU3RyaW5nTGl0ZXJhbDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qc3Qud3MuYW5ub3RhdGlvbnMuY29yZS5Bbm5vdGF0aW9uc0NvcmU7CitpbXBvcnQgb3JnLmVjbGlwc2UuanN0LndzLmFubm90YXRpb25zLmNvcmUudXRpbHMuQW5ub3RhdGlvblV0aWxzOworCitwdWJsaWMgY2xhc3MgVXBkYXRlU2luZ2xlTWVtYmVyQW5ub3RhdGlvblRlc3QgZXh0ZW5kcyBBYnN0cmFjdEFubm90YXRpb25UZXN0IHsKKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBBbm5vdGF0aW9uIGdldEFubm90YXRpb24oKSB7CisgICAgICAgIHJldHVybiBudWxsOworICAgIH0KKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0Q2xhc3NDb250ZW50cygpIHsKKyAgICAgICAgU3RyaW5nQnVpbGRlciBjbGFzc0NvbnRlbnRzID0gbmV3IFN0cmluZ0J1aWxkZXIoInBhY2thZ2UgY29tLmV4YW1wbGU7XG5cbiIpOworICAgICAgICBjbGFzc0NvbnRlbnRzLmFwcGVuZCgiaW1wb3J0IGphdmF4LnhtbC53cy5CaW5kaW5nVHlwZTtcblxuIik7CisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJAQmluZGluZ1R5cGUoXCJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93c2RsL3NvYXAvaHR0cFwiKVxuIik7CisgICAgICAgIGNsYXNzQ29udGVudHMuYXBwZW5kKCJwdWJsaWMgY2xhc3MgQ2FsY3VsYXRvciB7XG5cbn0iKTsKKyAgICAgICAgcmV0dXJuIGNsYXNzQ29udGVudHMudG9TdHJpbmcoKTsKKyAgICB9CisKKyAgICBAT3ZlcnJpZGUKKyAgICBwcm90ZWN0ZWQgU3RyaW5nIGdldENsYXNzTmFtZSgpIHsKKyAgICAgICAgcmV0dXJuICJDYWxjdWxhdG9yLmphdmEiOworICAgIH0KKworICAgIEBPdmVycmlkZQorICAgIHByb3RlY3RlZCBTdHJpbmcgZ2V0UGFja2FnZU5hbWUoKSB7CisgICAgICAgIHJldHVybiAiY29tLmV4YW1wbGUiOworICAgIH0KKworICAgIHB1YmxpYyB2b2lkIHRlc3RVcGRhdGVTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKCkgeworICAgICAgICB0cnkgeworICAgICAgICAgICAgSVR5cGUgdHlwZSA9IHNvdXJjZS5maW5kUHJpbWFyeVR5cGUoKTsKKyAgICAgICAgICAgIGFzc2VydFRydWUoQW5ub3RhdGlvblV0aWxzLmlzQW5ub3RhdGlvblByZXNlbnQoc291cmNlLCAiQmluZGluZ1R5cGUiKSk7CisgICAgICAgICAgICBBbm5vdGF0aW9uIGJpbmRpbmdUeXBlID0gQW5ub3RhdGlvblV0aWxzLmdldEFubm90YXRpb24odHlwZSwgQmluZGluZ1R5cGUuY2xhc3MpOworICAgICAgICAgICAgYXNzZXJ0Tm90TnVsbChiaW5kaW5nVHlwZSk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKGJpbmRpbmdUeXBlIGluc3RhbmNlb2YgU2luZ2xlTWVtYmVyQW5ub3RhdGlvbik7CisKKyAgICAgICAgICAgIFNpbmdsZU1lbWJlckFubm90YXRpb24gYmluZGluZ1R5cGVBbm5vdGF0aW9uID0gKFNpbmdsZU1lbWJlckFubm90YXRpb24pIGJpbmRpbmdUeXBlOworICAgICAgICAgICAgU3RyaW5nTGl0ZXJhbCBiaW5kaW5nVHlwZVZhbHVlID0gKFN0cmluZ0xpdGVyYWwpIGJpbmRpbmdUeXBlQW5ub3RhdGlvbi5nZXRWYWx1ZSgpOworICAgICAgICAgICAgYXNzZXJ0VHJ1ZShiaW5kaW5nVHlwZVZhbHVlLmdldExpdGVyYWxWYWx1ZSgpLmVxdWFscygiaHR0cDovL3NjaGVtYXMueG1sc29hcC5vcmcvd3NkbC9zb2FwL2h0dHAiKSk7CisKKyAgICAgICAgICAgIEFubm90YXRpb25VdGlscy51cGRhdGVTaW5nbGVNZW1iZXJBbm5vdGF0aW9uKGJpbmRpbmdUeXBlQW5ub3RhdGlvbiwgQW5ub3RhdGlvbnNDb3JlLmNyZWF0ZVN0cmluZ0xpdGVyYWwoYXN0LCAiaHR0cDovL3d3dy53My5vcmcvMjAwMy8wNS9zb2FwL2JpbmRpbmdzL0hUVFAvIikpOworICAgICAgICAgICAgYmluZGluZ1R5cGVBbm5vdGF0aW9uID0gKFNpbmdsZU1lbWJlckFubm90YXRpb24pIEFubm90YXRpb25VdGlscy5nZXRBbm5vdGF0aW9uKHR5cGUsIEJpbmRpbmdUeXBlLmNsYXNzKTsKKyAgICAgICAgICAgIGJpbmRpbmdUeXBlVmFsdWUgPSAoU3RyaW5nTGl0ZXJhbCkgYmluZGluZ1R5cGVBbm5vdGF0aW9uLmdldFZhbHVlKCk7CisgICAgICAgICAgICBhc3NlcnRUcnVlKGJpbmRpbmdUeXBlVmFsdWUuZ2V0TGl0ZXJhbFZhbHVlKCkuZXF1YWxzKCJodHRwOi8vd3d3LnczLm9yZy8yMDAzLzA1L3NvYXAvYmluZGluZ3MvSFRUUC8iKSk7CisgICAgICAgIH0gY2F0Y2ggKENvcmVFeGNlcHRpb24gY2UpIHsKKyAgICAgICAgICAgIGZhaWwoY2UuZ2V0TG9jYWxpemVkTWVzc2FnZSgpKTsKKyAgICAgICAgfQorICAgIH0KKworfQo=