LyoKICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDEyIElCTSBDb3Jwb3JhdGlvbiwgQ0VBLCBhbmQgb3RoZXJzLgogKiBBbGwgcmlnaHRzIHJlc2VydmVkLiAgIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCiAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CiAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCiAqCiAqIENvbnRyaWJ1dG9yczoKICogICBJQk0gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KICogICBLZW5uIEh1c3NleSAoQ0VBKSAtIDMyNzAzOSwgMzUxNzc0LCAzNTE3NzcKICoKICovCnBhY2thZ2Ugb3JnLmVjbGlwc2UudW1sMi51bWw7CgppbXBvcnQgamF2YS51dGlsLk1hcDsKaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5jb21tb24udXRpbC5EaWFnbm9zdGljQ2hhaW47CmltcG9ydCBvcmcuZWNsaXBzZS5lbWYuY29tbW9uLnV0aWwuRUxpc3Q7CgppbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmVjb3JlLkVDbGFzczsKCi8qKgogKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgogKiBBIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBtb2RlbCBvYmplY3QgJzxlbT48Yj5Db21wb25lbnQ8L2I+PC9lbT4nLgogKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KICoKICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CiAqIEluIHRoZSBuYW1lc3BhY2Ugb2YgYSBjb21wb25lbnQsIGFsbCBtb2RlbCBlbGVtZW50cyB0aGF0IGFyZSBpbnZvbHZlZCBpbiBvciByZWxhdGVkIHRvIGl0cyBkZWZpbml0aW9uIGFyZSBlaXRoZXIgb3duZWQgb3IgaW1wb3J0ZWQgZXhwbGljaXRseS4gVGhpcyBtYXkgaW5jbHVkZSwgZm9yIGV4YW1wbGUsIHVzZSBjYXNlcyBhbmQgZGVwZW5kZW5jaWVzIChlLmcuIG1hcHBpbmdzKSwgcGFja2FnZXMsIGNvbXBvbmVudHMsIGFuZCBhcnRpZmFjdHMuCiAqIEEgY29tcG9uZW50IHJlcHJlc2VudHMgYSBtb2R1bGFyIHBhcnQgb2YgYSBzeXN0ZW0gdGhhdCBlbmNhcHN1bGF0ZXMgaXRzIGNvbnRlbnRzIGFuZCB3aG9zZSBtYW5pZmVzdGF0aW9uIGlzIHJlcGxhY2VhYmxlIHdpdGhpbiBpdHMgZW52aXJvbm1lbnQuCiAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KICoKICogPHA+CiAqIFRoZSBmb2xsb3dpbmcgZmVhdHVyZXMgYXJlIHN1cHBvcnRlZDoKICogPHVsPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50I2lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCA8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50I2dldFBhY2thZ2VkRWxlbWVudHMgPGVtPlBhY2thZ2VkIEVsZW1lbnQ8L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50I2dldFByb3ZpZGVkcyA8ZW0+UHJvdmlkZWQ8L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50I2dldFJlYWxpemF0aW9ucyA8ZW0+UmVhbGl6YXRpb248L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50I2dldFJlcXVpcmVkcyA8ZW0+UmVxdWlyZWQ8L2VtPn08L2xpPgogKiA8L3VsPgogKiA8L3A+CiAqCiAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi51bWwuVU1MUGFja2FnZSNnZXRDb21wb25lbnQoKQogKiBAbW9kZWwKICogQGdlbmVyYXRlZAogKi8KcHVibGljIGludGVyZmFjZSBDb21wb25lbnQKCQlleHRlbmRzIG9yZy5lY2xpcHNlLnVtbDIudW1sLkNsYXNzIHsKCgkvKioKCSAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSAnPGVtPjxiPklzIEluZGlyZWN0bHkgSW5zdGFudGlhdGVkPC9iPjwvZW0+JyBhdHRyaWJ1dGUuCgkgKiBUaGUgZGVmYXVsdCB2YWx1ZSBpcyA8Y29kZT4idHJ1ZSI8L2NvZGU+LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBpc0luZGlyZWN0bHlJbnN0YW50aWF0ZWQgOiBCb29sZWFuIHtkZWZhdWx0ID0gdHJ1ZX0gVGhlIGtpbmQgb2YgaW5zdGFudGlhdGlvbiB0aGF0IGFwcGxpZXMgdG8gYSBDb21wb25lbnQuIElmIGZhbHNlLCB0aGUgY29tcG9uZW50IGlzIGluc3RhbnRpYXRlZCBhcyBhbiBhZGRyZXNzYWJsZSBvYmplY3QuIElmIHRydWUsIHRoZSBDb21wb25lbnQgaXMgZGVmaW5lZCBhdCBkZXNpZ24tdGltZSwgYnV0IGF0IHJ1bi10aW1lIChvciBleGVjdXRpb24tdGltZSkgYW4gb2JqZWN0IHNwZWNpZmllZCBieSB0aGUgQ29tcG9uZW50IGRvZXMgbm90IGV4aXN0LCB0aGF0IGlzLCB0aGUgY29tcG9uZW50IGlzIGluc3RhbnRpYXRlZCBpbmRpcmVjdGx5LCB0aHJvdWdoIHRoZSBpbnN0YW50aWF0aW9uIG9mIGl0cyByZWFsaXppbmcgY2xhc3NpZmllcnMgb3IgcGFydHMuIFNldmVyYWwgc3RhbmRhcmQgc3RlcmVvdHlwZXMgdXNlIHRoaXMgbWV0YSBhdHRyaWJ1dGUgKGUuZy4sIMdzcGVjaWZpY2F0aW9uyCwgx2ZvY3VzyCwgx3N1YnN5c3RlbcgpLgoJICogPCEtLSBlbmQtbW9kZWwtZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPicgYXR0cmlidXRlLgoJICogQHNlZSAjc2V0SXNJbmRpcmVjdGx5SW5zdGFudGlhdGVkKGJvb2xlYW4pCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIudW1sLlVNTFBhY2thZ2UjZ2V0Q29tcG9uZW50X0lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCgpCgkgKiBAbW9kZWwgZGVmYXVsdD0idHJ1ZSIgZGF0YVR5cGU9Im9yZy5lY2xpcHNlLnVtbDIudHlwZXMuQm9vbGVhbiIgcmVxdWlyZWQ9InRydWUiIG9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglib29sZWFuIGlzSW5kaXJlY3RseUluc3RhbnRpYXRlZCgpOwoKCS8qKgoJICogU2V0cyB0aGUgdmFsdWUgb2YgdGhlICd7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50I2lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCA8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPn0nIGF0dHJpYnV0ZS4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSB2YWx1ZSB0aGUgbmV3IHZhbHVlIG9mIHRoZSAnPGVtPklzIEluZGlyZWN0bHkgSW5zdGFudGlhdGVkPC9lbT4nIGF0dHJpYnV0ZS4KCSAqIEBzZWUgI2lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCgpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCXZvaWQgc2V0SXNJbmRpcmVjdGx5SW5zdGFudGlhdGVkKGJvb2xlYW4gdmFsdWUpOwoKCS8qKgoJICogUmV0dXJucyB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+PGI+UmVxdWlyZWQ8L2I+PC9lbT4nIHJlZmVyZW5jZSBsaXN0LgoJICogVGhlIGxpc3QgY29udGVudHMgYXJlIG9mIHR5cGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0uCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KCSAqIFRoZSBpbnRlcmZhY2VzIHRoYXQgdGhlIGNvbXBvbmVudCByZXF1aXJlcyBmcm9tIG90aGVyIGNvbXBvbmVudHMgaW4gaXRzIGVudmlyb25tZW50IGluIG9yZGVyIHRvIGJlIGFibGUgdG8gb2ZmZXIgaXRzIGZ1bGwgc2V0IG9mIHByb3ZpZGVkIGZ1bmN0aW9uYWxpdHkuIFRoZXNlIGludGVyZmFjZXMgbWF5IGJlIHVzZWQgYnkgdGhlIENvbXBvbmVudCBvciBhbnkgb2YgaXRzIHJlYWxpemluZ0NsYXNzaWZpZXJzLCBvciB0aGV5IG1heSBiZSB0aGUgSW50ZXJmYWNlcyB0aGF0IGFyZSByZXF1aXJlZCBieSBpdHMgcHVibGljIFBvcnRzLgoJICogPCEtLSBlbmQtbW9kZWwtZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+UmVxdWlyZWQ8L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIudW1sLlVNTFBhY2thZ2UjZ2V0Q29tcG9uZW50X1JlcXVpcmVkKCkKCSAqIEBtb2RlbCB0cmFuc2llbnQ9InRydWUiIGNoYW5nZWFibGU9ImZhbHNlIiB2b2xhdGlsZT0idHJ1ZSIgZGVyaXZlZD0idHJ1ZSIgb3JkZXJlZD0iZmFsc2UiCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUVMaXN0PEludGVyZmFjZT4gZ2V0UmVxdWlyZWRzKCk7CgoJLyoqCgkgKiBSZXRyaWV2ZXMgdGhlIGZpcnN0IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5JbnRlcmZhY2V9IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nIGZyb20gdGhlICc8ZW0+PGI+UmVxdWlyZWQ8L2I+PC9lbT4nIHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5JbnRlcmZhY2V9IHRvIHJldHJpZXZlLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEByZXR1cm4gVGhlIGZpcnN0IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5JbnRlcmZhY2V9IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEBzZWUgI2dldFJlcXVpcmVkcygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUludGVyZmFjZSBnZXRSZXF1aXJlZChTdHJpbmcgbmFtZSk7CgoJLyoqCgkgKiBSZXRyaWV2ZXMgdGhlIGZpcnN0IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5JbnRlcmZhY2V9IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nIGZyb20gdGhlICc8ZW0+PGI+UmVxdWlyZWQ8L2I+PC9lbT4nIHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5JbnRlcmZhY2V9IHRvIHJldHJpZXZlLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEBwYXJhbSBpZ25vcmVDYXNlIFdoZXRoZXIgdG8gaWdub3JlIGNhc2UgaW4ge0BsaW5rIGphdmEubGFuZy5TdHJpbmd9IGNvbXBhcmlzb25zLgoJICogQHJldHVybiBUaGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0UmVxdWlyZWRzKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJSW50ZXJmYWNlIGdldFJlcXVpcmVkKFN0cmluZyBuYW1lLCBib29sZWFuIGlnbm9yZUNhc2UpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBBIGNvbXBvbmVudCBjYW5ub3QgbmVzdCBjbGFzc2lmaWVycy4KCSAqIHNlbGYubmVzdGVkQ2xhc3NpZmllci0+aXNFbXB0eSgpCgkgKiBAcGFyYW0gZGlhZ25vc3RpY3MgVGhlIGNoYWluIG9mIGRpYWdub3N0aWNzIHRvIHdoaWNoIHByb2JsZW1zIGFyZSB0byBiZSBhcHBlbmRlZC4KCSAqIEBwYXJhbSBjb250ZXh0IFRoZSBjYWNoZSBvZiBjb250ZXh0LXNwZWNpZmljIGluZm9ybWF0aW9uLgoJICogPCEtLSBlbmQtbW9kZWwtZG9jIC0tPgoJICogQG1vZGVsCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCWJvb2xlYW4gdmFsaWRhdGVOb05lc3RlZENsYXNzaWZpZXJzKERpYWdub3N0aWNDaGFpbiBkaWFnbm9zdGljcywKCQkJTWFwPE9iamVjdCwgT2JqZWN0PiBjb250ZXh0KTsKCgkvKioKCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIDwhLS0gYmVnaW4tbW9kZWwtZG9jIC0tPgoJICogY29tcG9uZW50IG5lc3RlZCBpbiBhIENsYXNzIGNhbm5vdCBoYXZlIGFueSBwYWNrYWdlZCBlbGVtZW50cy4KCSAqIChub3Qgc2VsZi5jbGFzcy0+aXNFbXB0eSgpKSBpbXBsaWVzIHNlbGYucGFja2FnZWRFbGVtZW50LT5pc0VtcHR5KCkKCSAqIEBwYXJhbSBkaWFnbm9zdGljcyBUaGUgY2hhaW4gb2YgZGlhZ25vc3RpY3MgdG8gd2hpY2ggcHJvYmxlbXMgYXJlIHRvIGJlIGFwcGVuZGVkLgoJICogQHBhcmFtIGNvbnRleHQgVGhlIGNhY2hlIG9mIGNvbnRleHQtc3BlY2lmaWMgaW5mb3JtYXRpb24uCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAbW9kZWwKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJYm9vbGVhbiB2YWxpZGF0ZU5vUGFja2FnZWRFbGVtZW50cyhEaWFnbm9zdGljQ2hhaW4gZGlhZ25vc3RpY3MsCgkJCU1hcDxPYmplY3QsIE9iamVjdD4gY29udGV4dCk7CgoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5Qcm92aWRlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiBUaGUgbGlzdCBjb250ZW50cyBhcmUgb2YgdHlwZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuSW50ZXJmYWNlfS4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIDwhLS0gYmVnaW4tbW9kZWwtZG9jIC0tPgoJICogVGhlIGludGVyZmFjZXMgdGhhdCB0aGUgY29tcG9uZW50IGV4cG9zZXMgdG8gaXRzIGVudmlyb25tZW50LiBUaGVzZSBpbnRlcmZhY2VzIG1heSBiZSBSZWFsaXplZCBieSB0aGUgQ29tcG9uZW50IG9yIGFueSBvZiBpdHMgcmVhbGl6aW5nQ2xhc3NpZmllcnMsIG9yIHRoZXkgbWF5IGJlIHRoZSBJbnRlcmZhY2VzIHRoYXQgYXJlIHByb3ZpZGVkIGJ5IGl0cyBwdWJsaWMgUG9ydHMuCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAcmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT5Qcm92aWRlZDwvZW0+JyByZWZlcmVuY2UgbGlzdC4KCSAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi51bWwuVU1MUGFja2FnZSNnZXRDb21wb25lbnRfUHJvdmlkZWQoKQoJICogQG1vZGVsIHRyYW5zaWVudD0idHJ1ZSIgY2hhbmdlYWJsZT0iZmFsc2UiIHZvbGF0aWxlPSJ0cnVlIiBkZXJpdmVkPSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3Q8SW50ZXJmYWNlPiBnZXRQcm92aWRlZHMoKTsKCgkvKioKCSAqIFJldHJpZXZlcyB0aGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZnJvbSB0aGUgJzxlbT48Yj5Qcm92aWRlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gbmFtZSBUaGUgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0gdG8gcmV0cmlldmUsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHJldHVybiBUaGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0UHJvdmlkZWRzKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJSW50ZXJmYWNlIGdldFByb3ZpZGVkKFN0cmluZyBuYW1lKTsKCgkvKioKCSAqIFJldHJpZXZlcyB0aGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZnJvbSB0aGUgJzxlbT48Yj5Qcm92aWRlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gbmFtZSBUaGUgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkludGVyZmFjZX0gdG8gcmV0cmlldmUsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHBhcmFtIGlnbm9yZUNhc2UgV2hldGhlciB0byBpZ25vcmUgY2FzZSBpbiB7QGxpbmsgamF2YS5sYW5nLlN0cmluZ30gY29tcGFyaXNvbnMuCgkgKiBAcmV0dXJuIFRoZSBmaXJzdCB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuSW50ZXJmYWNlfSB3aXRoIHRoZSBzcGVjaWZpZWQgJzxlbT48Yj5OYW1lPC9iPjwvZW0+Jywgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAc2VlICNnZXRQcm92aWRlZHMoKQoJICogQGdlbmVyYXRlZAoJICovCglJbnRlcmZhY2UgZ2V0UHJvdmlkZWQoU3RyaW5nIG5hbWUsIGJvb2xlYW4gaWdub3JlQ2FzZSk7CgoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5QYWNrYWdlZCBFbGVtZW50PC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIFRoZSBsaXN0IGNvbnRlbnRzIGFyZSBvZiB0eXBlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5QYWNrYWdlYWJsZUVsZW1lbnR9LgoJICogPHA+CgkgKiBUaGlzIGZlYXR1cmUgc3Vic2V0cyB0aGUgZm9sbG93aW5nIGZlYXR1cmVzOgoJICogPHVsPgoJICogICA8bGk+J3tAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5OYW1lc3BhY2UjZ2V0T3duZWRNZW1iZXJzKCkgPGVtPk93bmVkIE1lbWJlcjwvZW0+fSc8L2xpPgoJICogPC91bD4KCSAqIDwvcD4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIDwhLS0gYmVnaW4tbW9kZWwtZG9jIC0tPgoJICogVGhlIHNldCBvZiBQYWNrYWdlYWJsZUVsZW1lbnRzIHRoYXQgYSBDb21wb25lbnQgb3ducy4gSW4gdGhlIG5hbWVzcGFjZSBvZiBhIGNvbXBvbmVudCwgYWxsIG1vZGVsIGVsZW1lbnRzIHRoYXQgYXJlIGludm9sdmVkIGluIG9yIHJlbGF0ZWQgdG8gaXRzIGRlZmluaXRpb24gbWF5IGJlIG93bmVkIG9yIGltcG9ydGVkIGV4cGxpY2l0bHkuIFRoZXNlIG1heSBpbmNsdWRlIGUuZy4gQ2xhc3NlcywgSW50ZXJmYWNlcywgQ29tcG9uZW50cywgUGFja2FnZXMsIFVzZSBjYXNlcywgRGVwZW5kZW5jaWVzIChlLmcuIG1hcHBpbmdzKSwgYW5kIEFydGlmYWN0cy4KCSAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KCSAqIEByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAnPGVtPlBhY2thZ2VkIEVsZW1lbnQ8L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIudW1sLlVNTFBhY2thZ2UjZ2V0Q29tcG9uZW50X1BhY2thZ2VkRWxlbWVudCgpCgkgKiBAbW9kZWwgY29udGFpbm1lbnQ9InRydWUiIHJlc29sdmVQcm94aWVzPSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3Q8UGFja2FnZWFibGVFbGVtZW50PiBnZXRQYWNrYWdlZEVsZW1lbnRzKCk7CgoJLyoqCgkgKiBDcmVhdGVzIGEgbmV3IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5QYWNrYWdlYWJsZUVsZW1lbnR9LCB3aXRoIHRoZSBzcGVjaWZpZWQgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JywgYW5kIGFwcGVuZHMgaXQgdG8gdGhlICc8ZW0+PGI+UGFja2FnZWQgRWxlbWVudDwvYj48L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gbmFtZSBUaGUgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBmb3IgdGhlIG5ldyB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuUGFja2FnZWFibGVFbGVtZW50fSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAcGFyYW0gZUNsYXNzIFRoZSBFY29yZSBjbGFzcyBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLlBhY2thZ2VhYmxlRWxlbWVudH0gdG8gY3JlYXRlLgoJICogQHJldHVybiBUaGUgbmV3IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5QYWNrYWdlYWJsZUVsZW1lbnR9LgoJICogQHNlZSAjZ2V0UGFja2FnZWRFbGVtZW50cygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCVBhY2thZ2VhYmxlRWxlbWVudCBjcmVhdGVQYWNrYWdlZEVsZW1lbnQoU3RyaW5nIG5hbWUsIEVDbGFzcyBlQ2xhc3MpOwoKCS8qKgoJICogUmV0cmlldmVzIHRoZSBmaXJzdCB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuUGFja2FnZWFibGVFbGVtZW50fSB3aXRoIHRoZSBzcGVjaWZpZWQgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBmcm9tIHRoZSAnPGVtPjxiPlBhY2thZ2VkIEVsZW1lbnQ8L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5QYWNrYWdlYWJsZUVsZW1lbnR9IHRvIHJldHJpZXZlLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEByZXR1cm4gVGhlIGZpcnN0IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5QYWNrYWdlYWJsZUVsZW1lbnR9IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEBzZWUgI2dldFBhY2thZ2VkRWxlbWVudHMoKQoJICogQGdlbmVyYXRlZAoJICovCglQYWNrYWdlYWJsZUVsZW1lbnQgZ2V0UGFja2FnZWRFbGVtZW50KFN0cmluZyBuYW1lKTsKCgkvKioKCSAqIFJldHJpZXZlcyB0aGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLlBhY2thZ2VhYmxlRWxlbWVudH0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZnJvbSB0aGUgJzxlbT48Yj5QYWNrYWdlZCBFbGVtZW50PC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSBuYW1lIFRoZSAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuUGFja2FnZWFibGVFbGVtZW50fSB0byByZXRyaWV2ZSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAcGFyYW0gaWdub3JlQ2FzZSBXaGV0aGVyIHRvIGlnbm9yZSBjYXNlIGluIHtAbGluayBqYXZhLmxhbmcuU3RyaW5nfSBjb21wYXJpc29ucy4KCSAqIEBwYXJhbSBlQ2xhc3MgVGhlIEVjb3JlIGNsYXNzIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuUGFja2FnZWFibGVFbGVtZW50fSB0byByZXRyaWV2ZSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAcGFyYW0gY3JlYXRlT25EZW1hbmQgV2hldGhlciB0byBjcmVhdGUgYSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuUGFja2FnZWFibGVFbGVtZW50fSBvbiBkZW1hbmQgaWYgbm90IGZvdW5kLgoJICogQHJldHVybiBUaGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLlBhY2thZ2VhYmxlRWxlbWVudH0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0UGFja2FnZWRFbGVtZW50cygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCVBhY2thZ2VhYmxlRWxlbWVudCBnZXRQYWNrYWdlZEVsZW1lbnQoU3RyaW5nIG5hbWUsIGJvb2xlYW4gaWdub3JlQ2FzZSwKCQkJRUNsYXNzIGVDbGFzcywgYm9vbGVhbiBjcmVhdGVPbkRlbWFuZCk7CgoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5SZWFsaXphdGlvbjwvYj48L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiBUaGUgbGlzdCBjb250ZW50cyBhcmUgb2YgdHlwZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb259LgoJICogSXQgaXMgYmlkaXJlY3Rpb25hbCBhbmQgaXRzIG9wcG9zaXRlIGlzICd7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb24jZ2V0QWJzdHJhY3Rpb24gPGVtPkFic3RyYWN0aW9uPC9lbT59Jy4KCSAqIDxwPgoJICogVGhpcyBmZWF0dXJlIHN1YnNldHMgdGhlIGZvbGxvd2luZyBmZWF0dXJlczoKCSAqIDx1bD4KCSAqICAgPGxpPid7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuRWxlbWVudCNnZXRPd25lZEVsZW1lbnRzKCkgPGVtPk93bmVkIEVsZW1lbnQ8L2VtPn0nPC9saT4KCSAqIDwvdWw+CgkgKiA8L3A+CgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KCSAqIFRoZSBzZXQgb2YgUmVhbGl6YXRpb25zIG93bmVkIGJ5IHRoZSBDb21wb25lbnQuIFJlYWxpemF0aW9ucyByZWZlcmVuY2UgdGhlIENsYXNzaWZpZXJzIG9mIHdoaWNoIHRoZSBDb21wb25lbnQgaXMgYW4gYWJzdHJhY3Rpb247IGkuZS4sIHRoYXQgcmVhbGl6ZSBpdHMgYmVoYXZpb3IuCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAcmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT5SZWFsaXphdGlvbjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi51bWwuVU1MUGFja2FnZSNnZXRDb21wb25lbnRfUmVhbGl6YXRpb24oKQoJICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLnVtbC5Db21wb25lbnRSZWFsaXphdGlvbiNnZXRBYnN0cmFjdGlvbgoJICogQG1vZGVsIG9wcG9zaXRlPSJhYnN0cmFjdGlvbiIgY29udGFpbm1lbnQ9InRydWUiIHJlc29sdmVQcm94aWVzPSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3Q8Q29tcG9uZW50UmVhbGl6YXRpb24+IGdldFJlYWxpemF0aW9ucygpOwoKCS8qKgoJICogQ3JlYXRlcyBhIG5ldyB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb259LCB3aXRoIHRoZSBzcGVjaWZpZWQgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JywgYW5kIGFwcGVuZHMgaXQgdG8gdGhlICc8ZW0+PGI+UmVhbGl6YXRpb248L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZm9yIHRoZSBuZXcge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkNvbXBvbmVudFJlYWxpemF0aW9ufSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAcmV0dXJuIFRoZSBuZXcge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkNvbXBvbmVudFJlYWxpemF0aW9ufS4KCSAqIEBzZWUgI2dldFJlYWxpemF0aW9ucygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUNvbXBvbmVudFJlYWxpemF0aW9uIGNyZWF0ZVJlYWxpemF0aW9uKFN0cmluZyBuYW1lKTsKCgkvKioKCSAqIFJldHJpZXZlcyB0aGUgZmlyc3Qge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIudW1sLkNvbXBvbmVudFJlYWxpemF0aW9ufSB3aXRoIHRoZSBzcGVjaWZpZWQgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBmcm9tIHRoZSAnPGVtPjxiPlJlYWxpemF0aW9uPC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSBuYW1lIFRoZSAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb259IHRvIHJldHJpZXZlLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEByZXR1cm4gVGhlIGZpcnN0IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5Db21wb25lbnRSZWFsaXphdGlvbn0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0UmVhbGl6YXRpb25zKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJQ29tcG9uZW50UmVhbGl6YXRpb24gZ2V0UmVhbGl6YXRpb24oU3RyaW5nIG5hbWUpOwoKCS8qKgoJICogUmV0cmlldmVzIHRoZSBmaXJzdCB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb259IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nIGZyb20gdGhlICc8ZW0+PGI+UmVhbGl6YXRpb248L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLnVtbC5Db21wb25lbnRSZWFsaXphdGlvbn0gdG8gcmV0cmlldmUsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHBhcmFtIGlnbm9yZUNhc2UgV2hldGhlciB0byBpZ25vcmUgY2FzZSBpbiB7QGxpbmsgamF2YS5sYW5nLlN0cmluZ30gY29tcGFyaXNvbnMuCgkgKiBAcGFyYW0gY3JlYXRlT25EZW1hbmQgV2hldGhlciB0byBjcmVhdGUgYSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb259IG9uIGRlbWFuZCBpZiBub3QgZm91bmQuCgkgKiBAcmV0dXJuIFRoZSBmaXJzdCB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi51bWwuQ29tcG9uZW50UmVhbGl6YXRpb259IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEBzZWUgI2dldFJlYWxpemF0aW9ucygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUNvbXBvbmVudFJlYWxpemF0aW9uIGdldFJlYWxpemF0aW9uKFN0cmluZyBuYW1lLCBib29sZWFuIGlnbm9yZUNhc2UsCgkJCWJvb2xlYW4gY3JlYXRlT25EZW1hbmQpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBDcmVhdGVzIGEobikgKGFic3RyYWN0KSBjbGFzcyB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBhcyBhIHBhY2thZ2VkIGVsZW1lbnQgb2YgdGhpcyBjb21wb25lbnQuCgkgKiBAcGFyYW0gbmFtZSBUaGUgbmFtZSBmb3IgdGhlIG5ldyBjbGFzcywgb3IgbnVsbC4KCSAqIEBwYXJhbSBpc0Fic3RyYWN0IFdoZXRoZXIgdGhlIG5ldyBjbGFzcyBzaG91bGQgYmUgYWJzdHJhY3QuCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAbW9kZWwgcmVxdWlyZWQ9InRydWUiIG9yZGVyZWQ9ImZhbHNlIiBuYW1lRGF0YVR5cGU9Im9yZy5lY2xpcHNlLnVtbDIudHlwZXMuU3RyaW5nIiBuYW1lUmVxdWlyZWQ9InRydWUiIG5hbWVPcmRlcmVkPSJmYWxzZSIgaXNBYnN0cmFjdERhdGFUeXBlPSJvcmcuZWNsaXBzZS51bWwyLnR5cGVzLkJvb2xlYW4iIGlzQWJzdHJhY3RSZXF1aXJlZD0idHJ1ZSIgaXNBYnN0cmFjdE9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglvcmcuZWNsaXBzZS51bWwyLnVtbC5DbGFzcyBjcmVhdGVPd25lZENsYXNzKFN0cmluZyBuYW1lLCBib29sZWFuIGlzQWJzdHJhY3QpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBDcmVhdGVzIGEgZW51bWVyYXRpb24gd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYXMgYSBwYWNrYWdlZCBlbGVtZW50IG9mIHRoaXMgY29tcG9uZW50LgoJICogQHBhcmFtIG5hbWUgVGhlIG5hbWUgZm9yIHRoZSBuZXcgZW51bWVyYXRpb24sIG9yIG51bGwuCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAbW9kZWwgcmVxdWlyZWQ9InRydWUiIG9yZGVyZWQ9ImZhbHNlIiBuYW1lRGF0YVR5cGU9Im9yZy5lY2xpcHNlLnVtbDIudHlwZXMuU3RyaW5nIiBuYW1lUmVxdWlyZWQ9InRydWUiIG5hbWVPcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRW51bWVyYXRpb24gY3JlYXRlT3duZWRFbnVtZXJhdGlvbihTdHJpbmcgbmFtZSk7CgoJLyoqCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KCSAqIENyZWF0ZXMgYSBwcmltaXRpdmUgdHlwZSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBhcyBhIHBhY2thZ2VkIGVsZW1lbnQgb2YgdGhpcyBjb21wb25lbnQuCgkgKiBAcGFyYW0gbmFtZSBUaGUgbmFtZSBmb3IgdGhlIG5ldyBwcmltaXRpdmUgdHlwZSwgb3IgbnVsbC4KCSAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KCSAqIEBtb2RlbCByZXF1aXJlZD0idHJ1ZSIgb3JkZXJlZD0iZmFsc2UiIG5hbWVEYXRhVHlwZT0ib3JnLmVjbGlwc2UudW1sMi50eXBlcy5TdHJpbmciIG5hbWVSZXF1aXJlZD0idHJ1ZSIgbmFtZU9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglQcmltaXRpdmVUeXBlIGNyZWF0ZU93bmVkUHJpbWl0aXZlVHlwZShTdHJpbmcgbmFtZSk7CgoJLyoqCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KCSAqIENyZWF0ZXMgYW4gaW50ZXJmYWNlIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIGFzIGEgcGFja2FnZWQgZWxlbWVudCBvZiB0aGlzIGNvbXBvbmVudC4KCSAqIEBwYXJhbSBuYW1lIFRoZSBuYW1lIGZvciB0aGUgbmV3IGludGVyZmFjZSwgb3IgbnVsbC4KCSAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KCSAqIEBtb2RlbCByZXF1aXJlZD0idHJ1ZSIgb3JkZXJlZD0iZmFsc2UiIG5hbWVEYXRhVHlwZT0ib3JnLmVjbGlwc2UudW1sMi50eXBlcy5TdHJpbmciIG5hbWVSZXF1aXJlZD0idHJ1ZSIgbmFtZU9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglJbnRlcmZhY2UgY3JlYXRlT3duZWRJbnRlcmZhY2UoU3RyaW5nIG5hbWUpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBVdGlsaXR5IHJldHVybmluZyB0aGUgc2V0IG9mIHJlYWxpemVkIGludGVyZmFjZXMgb2YgYSBjb21wb25lbnQuCgkgKiByZXN1bHQgPSAoY2xhc3NpZmllci5jbGllbnREZXBlbmRlbmN5LT4KCSAqIHNlbGVjdChkZXBlbmRlbmN5fGRlcGVuZGVuY3kub2NsSXNLaW5kT2YoUmVhbGl6YXRpb24pIGFuZCBkZXBlbmRlbmN5LnN1cHBsaWVyLm9jbElzS2luZE9mKEludGVyZmFjZSkpKS0+CgkgKiBjb2xsZWN0KGRlcGVuZGVuY3l8ZGVwZW5kZW5jeS5jbGllbnQpCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAbW9kZWwgb3JkZXJlZD0iZmFsc2UiIGNsYXNzaWZpZXJSZXF1aXJlZD0idHJ1ZSIgY2xhc3NpZmllck9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglFTGlzdDxJbnRlcmZhY2U+IHJlYWxpemVkSW50ZXJmYWNlcyhDbGFzc2lmaWVyIGNsYXNzaWZpZXIpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBVdGlsaXR5IHJldHVybmluZyB0aGUgc2V0IG9mIHVzZWQgaW50ZXJmYWNlcyBvZiBhIGNvbXBvbmVudC4KCSAqIHJlc3VsdCA9IChjbGFzc2lmaWVyLnN1cHBsaWVyRGVwZW5kZW5jeS0+CgkgKiBzZWxlY3QoZGVwZW5kZW5jeXxkZXBlbmRlbmN5Lm9jbElzS2luZE9mKFVzYWdlKSBhbmQgZGVwZW5kZW5jeS5zdXBwbGllci5vY2xJc0tpbmRPZihpbnRlcmZhY2UpKSktPgoJICogY29sbGVjdChkZXBlbmRlbmN5fGRlcGVuZGVuY3kuc3VwcGxpZXIpCgkgKiA8IS0tIGVuZC1tb2RlbC1kb2MgLS0+CgkgKiBAbW9kZWwgb3JkZXJlZD0iZmFsc2UiIGNsYXNzaWZpZXJSZXF1aXJlZD0idHJ1ZSIgY2xhc3NpZmllck9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglFTGlzdDxJbnRlcmZhY2U+IHVzZWRJbnRlcmZhY2VzKENsYXNzaWZpZXIgY2xhc3NpZmllcik7Cgp9IC8vIENvbXBvbmVudAo=