LyoKICogQ29weXJpZ2h0IChjKSAyMDAzLCAyMDA1IElCTSBDb3Jwb3JhdGlvbiBhbmQgb3RoZXJzLgogKiBBbGwgcmlnaHRzIHJlc2VydmVkLiAgIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCiAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CiAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCiAqCiAqIENvbnRyaWJ1dG9yczoKICogICBJQk0gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KICoKICogJElkOiBDb21wb25lbnQuamF2YSx2IDEuMTIgMjAwNS8xMS8wOSAyMjo1MzowOSBraHVzc2V5IEV4cCAkCiAqLwpwYWNrYWdlIG9yZy5lY2xpcHNlLnVtbDI7CgppbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi51dGlsLkVMaXN0OwoKaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5lY29yZS5FQ2xhc3M7CgovKioKICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KICogQSByZXByZXNlbnRhdGlvbiBvZiB0aGUgbW9kZWwgb2JqZWN0ICc8ZW0+PGI+Q29tcG9uZW50PC9iPjwvZW0+Jy4KICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CiAqCiAqIDxwPgogKiBUaGUgZm9sbG93aW5nIGZlYXR1cmVzIGFyZSBzdXBwb3J0ZWQ6CiAqIDx1bD4KICogICA8bGk+e0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuQ29tcG9uZW50I2lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCA8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5Db21wb25lbnQjZ2V0UmVxdWlyZWRzIDxlbT5SZXF1aXJlZDwvZW0+fTwvbGk+CiAqICAgPGxpPntAbGluayBvcmcuZWNsaXBzZS51bWwyLkNvbXBvbmVudCNnZXRQcm92aWRlZHMgPGVtPlByb3ZpZGVkPC9lbT59PC9saT4KICogICA8bGk+e0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuQ29tcG9uZW50I2dldFJlYWxpemF0aW9ucyA8ZW0+UmVhbGl6YXRpb248L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5Db21wb25lbnQjZ2V0T3duZWRNZW1iZXJzIDxlbT5Pd25lZCBNZW1iZXI8L2VtPn08L2xpPgogKiA8L3VsPgogKiA8L3A+CiAqCiAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi5VTUwyUGFja2FnZSNnZXRDb21wb25lbnQoKQogKiBAbW9kZWwKICogQGdlbmVyYXRlZAogKi8KcHVibGljIGludGVyZmFjZSBDb21wb25lbnQgZXh0ZW5kcyBvcmcuZWNsaXBzZS51bWwyLkNsYXNzewoJLyoqCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAZ2VuZXJhdGVkCgkgKi8KCVN0cmluZyBjb3B5cmlnaHQgPSAiQ29weXJpZ2h0IChjKSBJQk0gQ29ycG9yYXRpb24gYW5kIG90aGVycy4iOyAvLyROT04tTkxTLTEkCgoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5JcyBJbmRpcmVjdGx5IEluc3RhbnRpYXRlZDwvYj48L2VtPicgYXR0cmlidXRlLgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDxwPgoJICogSWYgdGhlIG1lYW5pbmcgb2YgdGhlICc8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPicgYXR0cmlidXRlIGlzbid0IGNsZWFyLAoJICogdGhlcmUgcmVhbGx5IHNob3VsZCBiZSBtb3JlIG9mIGEgZGVzY3JpcHRpb24gaGVyZS4uLgoJICogPC9wPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KCSAqIHtkZWZhdWx0ID0gdHJ1ZX0gVGhlIGtpbmQgb2YgaW5zdGFudGlhdGlvbiB0aGF0IGFwcGxpZXMgdG8gYSBDb21wb25lbnQuIElmIGZhbHNlLCB0aGUgY29tcG9uZW50IGlzIGluc3RhbnRpYXRlZCBhcyBhbiBhZGRyZXNzYWJsZSBvYmplY3QuIElmIHRydWUsIHRoZSBDb21wb25lbnQgaXMgZGVmaW5lZCBhdCBkZXNpZ24tdGltZSwgYnV0IGF0IHJ1bnRpbWUgKG9yIGV4ZWN1dGlvbi10aW1lKSBhbiBvYmplY3Qgc3BlY2lmaWVkIGJ5IHRoZSBDb21wb25lbnQgZG9lcyBub3QgZXhpc3QsIHRoYXQgaXMsIHRoZSBjb21wb25lbnQgaXMgaW5zdGFudGlhdGVkIGluZGlyZWN0bHksIHRocm91Z2ggdGhlIGluc3RhbnRpYXRpb24gb2YgaXRzIHJlYWxpemluZyBjbGFzc2lmaWVycyBvciBwYXJ0cy4gU2V2ZXJhbCBzdGFuZGFyZCBzdGVyZW90eXBlcyB1c2UgdGhpcyBtZXRhIGF0dHJpYnV0ZSwgZS5nLiCrc3BlY2lmaWNhdGlvbiwgq2ZvY3Vzuywgq3N1YnN5c3RlbSC7LgoJICogPCEtLSBlbmQtbW9kZWwtZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPicgYXR0cmlidXRlLgoJICogQHNlZSAjc2V0SXNJbmRpcmVjdGx5SW5zdGFudGlhdGVkKGJvb2xlYW4pCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0Q29tcG9uZW50X0lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCgpCgkgKiBAbW9kZWwgZGF0YVR5cGU9Im9yZy5lY2xpcHNlLnVtbDIuQm9vbGVhbiIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJYm9vbGVhbiBpc0luZGlyZWN0bHlJbnN0YW50aWF0ZWQoKTsKCgkvKioKCSAqIFNldHMgdGhlIHZhbHVlIG9mIHRoZSAne0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuQ29tcG9uZW50I2lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCA8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPn0nIGF0dHJpYnV0ZS4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSB2YWx1ZSB0aGUgbmV3IHZhbHVlIG9mIHRoZSAnPGVtPklzIEluZGlyZWN0bHkgSW5zdGFudGlhdGVkPC9lbT4nIGF0dHJpYnV0ZS4KCSAqIEBzZWUgI2lzSW5kaXJlY3RseUluc3RhbnRpYXRlZCgpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCXZvaWQgc2V0SXNJbmRpcmVjdGx5SW5zdGFudGlhdGVkKGJvb2xlYW4gdmFsdWUpOwoKCgkvKioKCSAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSAnPGVtPjxiPlJlcXVpcmVkPC9iPjwvZW0+JyByZWZlcmVuY2UgbGlzdC4KCSAqIFRoZSBsaXN0IGNvbnRlbnRzIGFyZSBvZiB0eXBlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0uCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPHA+CgkgKiBJZiB0aGUgbWVhbmluZyBvZiB0aGUgJzxlbT5SZXF1aXJlZDwvZW0+JyByZWZlcmVuY2UgbGlzdCBpc24ndCBjbGVhciwKCSAqIHRoZXJlIHJlYWxseSBzaG91bGQgYmUgbW9yZSBvZiBhIGRlc2NyaXB0aW9uIGhlcmUuLi4KCSAqIDwvcD4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+UmVxdWlyZWQ8L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0Q29tcG9uZW50X1JlcXVpcmVkKCkKCSAqIEBtb2RlbCB0eXBlPSJvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZSIgdHJhbnNpZW50PSJ0cnVlIiBjaGFuZ2VhYmxlPSJmYWxzZSIgdm9sYXRpbGU9InRydWUiIGRlcml2ZWQ9InRydWUiIG9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglFTGlzdCBnZXRSZXF1aXJlZHMoKTsKCgoJLyoqCgkgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZnJvbSB0aGUgJzxlbT48Yj5SZXF1aXJlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gbmFtZSBUaGUgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuSW50ZXJmYWNlfSB0byByZXRyaWV2ZS4KCSAqIEByZXR1cm4gVGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0UmVxdWlyZWRzKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwogICAgSW50ZXJmYWNlIGdldFJlcXVpcmVkKFN0cmluZyBuYW1lKTsKCgkvKioKCSAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSAnPGVtPjxiPlByb3ZpZGVkPC9iPjwvZW0+JyByZWZlcmVuY2UgbGlzdC4KCSAqIFRoZSBsaXN0IGNvbnRlbnRzIGFyZSBvZiB0eXBlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0uCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPHA+CgkgKiBJZiB0aGUgbWVhbmluZyBvZiB0aGUgJzxlbT5Qcm92aWRlZDwvZW0+JyByZWZlcmVuY2UgbGlzdCBpc24ndCBjbGVhciwKCSAqIHRoZXJlIHJlYWxseSBzaG91bGQgYmUgbW9yZSBvZiBhIGRlc2NyaXB0aW9uIGhlcmUuLi4KCSAqIDwvcD4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+UHJvdmlkZWQ8L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0Q29tcG9uZW50X1Byb3ZpZGVkKCkKCSAqIEBtb2RlbCB0eXBlPSJvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZSIgdHJhbnNpZW50PSJ0cnVlIiBjaGFuZ2VhYmxlPSJmYWxzZSIgdm9sYXRpbGU9InRydWUiIGRlcml2ZWQ9InRydWUiIG9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglFTGlzdCBnZXRQcm92aWRlZHMoKTsKCgoJLyoqCgkgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZnJvbSB0aGUgJzxlbT48Yj5Qcm92aWRlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gbmFtZSBUaGUgJzxlbT48Yj5OYW1lPC9iPjwvZW0+JyBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuSW50ZXJmYWNlfSB0byByZXRyaWV2ZS4KCSAqIEByZXR1cm4gVGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0UHJvdmlkZWRzKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwogICAgSW50ZXJmYWNlIGdldFByb3ZpZGVkKFN0cmluZyBuYW1lKTsKCgkvKioKCSAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSAnPGVtPjxiPlJlYWxpemF0aW9uPC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIFRoZSBsaXN0IGNvbnRlbnRzIGFyZSBvZiB0eXBlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufS4KCSAqIEl0IGlzIGJpZGlyZWN0aW9uYWwgYW5kIGl0cyBvcHBvc2l0ZSBpcyAne0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUmVhbGl6YXRpb24jZ2V0QWJzdHJhY3Rpb24gPGVtPkFic3RyYWN0aW9uPC9lbT59Jy4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8cD4KCSAqIElmIHRoZSBtZWFuaW5nIG9mIHRoZSAnPGVtPlJlYWxpemF0aW9uPC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0IGlzbid0IGNsZWFyLAoJICogdGhlcmUgcmVhbGx5IHNob3VsZCBiZSBtb3JlIG9mIGEgZGVzY3JpcHRpb24gaGVyZS4uLgoJICogPC9wPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT5SZWFsaXphdGlvbjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi5VTUwyUGFja2FnZSNnZXRDb21wb25lbnRfUmVhbGl6YXRpb24oKQoJICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9uI2dldEFic3RyYWN0aW9uCgkgKiBAbW9kZWwgdHlwZT0ib3JnLmVjbGlwc2UudW1sMi5SZWFsaXphdGlvbiIgb3Bwb3NpdGU9ImFic3RyYWN0aW9uIiBjb250YWlubWVudD0idHJ1ZSIgb3JkZXJlZD0iZmFsc2UiCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUVMaXN0IGdldFJlYWxpemF0aW9ucygpOwoKCgkvKioKCSAqIFJldHJpZXZlcyB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUmVhbGl6YXRpb259IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nIGZyb20gdGhlICc8ZW0+PGI+UmVhbGl6YXRpb248L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSB0byByZXRyaWV2ZS4KCSAqIEByZXR1cm4gVGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSB3aXRoIHRoZSBzcGVjaWZpZWQgJzxlbT48Yj5OYW1lPC9iPjwvZW0+Jywgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAc2VlICNnZXRSZWFsaXphdGlvbnMoKQoJICogQGdlbmVyYXRlZAoJICovCiAgICBSZWFsaXphdGlvbiBnZXRSZWFsaXphdGlvbihTdHJpbmcgbmFtZSk7CgoJLyoqCgkgKiBDcmVhdGVzIGEge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUmVhbGl6YXRpb259IGFuZCBhcHBlbmRzIGl0IHRvIHRoZSAnPGVtPjxiPlJlYWxpemF0aW9uPC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSBlQ2xhc3MgVGhlIEVjb3JlIGNsYXNzIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5SZWFsaXphdGlvbn0gdG8gY3JlYXRlLgoJICogQHJldHVybiBUaGUgbmV3IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufS4KCSAqIEBzZWUgI2dldFJlYWxpemF0aW9ucygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KICAgIFJlYWxpemF0aW9uIGNyZWF0ZVJlYWxpemF0aW9uKEVDbGFzcyBlQ2xhc3MpOwoKCS8qKgoJICogQ3JlYXRlcyBhIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSBhbmQgYXBwZW5kcyBpdCB0byB0aGUgJzxlbT48Yj5SZWFsaXphdGlvbjwvYj48L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcmV0dXJuIFRoZSBuZXcge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUmVhbGl6YXRpb259LgoJICogQHNlZSAjZ2V0UmVhbGl6YXRpb25zKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwogICAgUmVhbGl6YXRpb24gY3JlYXRlUmVhbGl6YXRpb24oKTsKCgkvKioKCSAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSAnPGVtPjxiPk93bmVkIE1lbWJlcjwvYj48L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiBUaGUgbGlzdCBjb250ZW50cyBhcmUgb2YgdHlwZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5QYWNrYWdlYWJsZUVsZW1lbnR9LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDxwPgoJICogSWYgdGhlIG1lYW5pbmcgb2YgdGhlICc8ZW0+T3duZWQgTWVtYmVyPC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0IGlzbid0IGNsZWFyLAoJICogdGhlcmUgcmVhbGx5IHNob3VsZCBiZSBtb3JlIG9mIGEgZGVzY3JpcHRpb24gaGVyZS4uLgoJICogPC9wPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcmV0dXJuIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT5Pd25lZCBNZW1iZXI8L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0Q29tcG9uZW50X093bmVkTWVtYmVyKCkKCSAqIEBtb2RlbCB0eXBlPSJvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudCIgY29udGFpbm1lbnQ9InRydWUiIG9yZGVyZWQ9ImZhbHNlIgoJICogQGdlbmVyYXRlZAoJICovCglFTGlzdCBnZXRPd25lZE1lbWJlcnMoKTsKCgoJLyoqCgkgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0gd2l0aCB0aGUgc3BlY2lmaWVkICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgZnJvbSB0aGUgJzxlbT48Yj5Pd25lZCBNZW1iZXI8L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIG5hbWUgVGhlICc8ZW0+PGI+TmFtZTwvYj48L2VtPicgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0gdG8gcmV0cmlldmUuCgkgKiBAcmV0dXJuIFRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5QYWNrYWdlYWJsZUVsZW1lbnR9IHdpdGggdGhlIHNwZWNpZmllZCAnPGVtPjxiPk5hbWU8L2I+PC9lbT4nLCBvciA8Y29kZT5udWxsPC9jb2RlPi4KCSAqIEBzZWUgI2dldE93bmVkTWVtYmVycygpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KICAgIE5hbWVkRWxlbWVudCBnZXRPd25lZE1lbWJlcihTdHJpbmcgbmFtZSk7CgogICAgLyoqCiAgICAgKiBDcmVhdGVzIGEge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUGFja2FnZWFibGVFbGVtZW50fSBhbmQgYXBwZW5kcyBpdCB0byB0aGUgJzxlbT48Yj5Pd25lZCBNZW1iZXI8L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIGVDbGFzcyBUaGUgRWNvcmUgY2xhc3Mgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0gdG8gY3JlYXRlLgoJICogQHJldHVybiBUaGUgbmV3IHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0uCgkgKiBAc2VlICNnZXRPd25lZE1lbWJlcnMoKQoJICogQGdlbmVyYXRlZCBOT1QKICAgICAqLwogICAgUGFja2FnZWFibGVFbGVtZW50IGNyZWF0ZU93bmVkTWVtYmVyKEVDbGFzcyBlQ2xhc3MpOwoKCS8vIDwhLS0gYmVnaW4tY3VzdG9tLW9wZXJhdGlvbnMgLS0+CgoJLyoqCgkgKiBDcmVhdGVzIGEobikgKGFic3RyYWN0KSBjbGFzcyB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBhcyBhbiBvd25lZCBtZW1iZXIKCSAqIG9mIHRoaXMgY29tcG9uZW50LgoJICogCgkgKiBAcGFyYW0gbmFtZQoJICogICAgICAgICAgICBUaGUgbmFtZSBmb3IgdGhlIG93bmVkIGNsYXNzLgoJICogQHBhcmFtIGlzQWJzdHJhY3QKCSAqICAgICAgICAgICAgV2hldGhlciB0aGUgb3duZWQgY2xhc3Mgc2hvdWxkIGJlIGFic3RyYWN0LgoJICogQHJldHVybiBUaGUgbmV3IGNsYXNzLgoJICogQGV4Y2VwdGlvbiBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24KCSAqICAgICAgICAgICAgICAgIElmIHRoZSBuYW1lIGlzIGVtcHR5LgoJICovCglvcmcuZWNsaXBzZS51bWwyLkNsYXNzIGNyZWF0ZU93bmVkQ2xhc3MoU3RyaW5nIG5hbWUsIGJvb2xlYW4gaXNBYnN0cmFjdCk7CgoJLyoqCgkgKiBDcmVhdGVzIGFuIGVudW1lcmF0aW9uIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lIGFzIGFuIG93bmVkIG1lbWJlciBvZiB0aGlzCgkgKiBjb21wb25lbnQuCgkgKiAKCSAqIEBwYXJhbSBuYW1lCgkgKiAgICAgICAgICAgIFRoZSBuYW1lIGZvciB0aGUgb3duZWQgZW51bWVyYXRpb24uCgkgKiBAcmV0dXJuIFRoZSBuZXcgZW51bWVyYXRpb24uCgkgKiBAZXhjZXB0aW9uIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbgoJICogICAgICAgICAgICAgICAgSWYgdGhlIG5hbWUgaXMgZW1wdHkuCgkgKi8KCUVudW1lcmF0aW9uIGNyZWF0ZU93bmVkRW51bWVyYXRvbihTdHJpbmcgbmFtZSk7CgoJLyoqCgkgKiBDcmVhdGVzIGEgcGFja2FnZSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBhcyBhbiBvd25lZCBtZW1iZXIgb2YgdGhpcwoJICogY29tcG9uZW50LgoJICogCgkgKiBAcGFyYW0gbmFtZQoJICogICAgICAgICAgICBUaGUgbmFtZSBmb3IgdGhlIG93bmVkIHBhY2thZ2UuCgkgKiBAcmV0dXJuIFRoZSBuZXcgcGFja2FnZS4KCSAqIEBleGNlcHRpb24gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uCgkgKiAgICAgICAgICAgICAgICBJZiB0aGUgbmFtZSBpcyBlbXB0eS4KCSAqLwoJb3JnLmVjbGlwc2UudW1sMi5QYWNrYWdlIGNyZWF0ZU93bmVkUGFja2FnZShTdHJpbmcgbmFtZSk7CgoJLyoqCgkgKiBDcmVhdGVzIGEgcHJpbWl0aXZlIHR5cGUgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgYXMgYW4gb3duZWQgbWVtYmVyIG9mCgkgKiB0aGlzIGNvbXBvbmVudC4KCSAqIAoJICogQHBhcmFtIG5hbWUKCSAqICAgICAgICAgICAgVGhlIG5hbWUgZm9yIHRoZSBvd25lZCBwcmltaXRpdmUgdHlwZS4KCSAqIEByZXR1cm4gVGhlIG5ldyBwcmltaXRpdmUgdHlwZS4KCSAqIEBleGNlcHRpb24gSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uCgkgKiAgICAgICAgICAgICAgICBJZiB0aGUgbmFtZSBpcyBlbXB0eS4KCSAqLwoJUHJpbWl0aXZlVHlwZSBjcmVhdGVPd25lZFByaW1pdGl2ZVR5cGUoU3RyaW5nIG5hbWUpOwoKCS8vIDwhLS0gZW5kLWN1c3RvbS1vcGVyYXRpb25zIC0tPgoKfSAvLyBDb21wb25lbnQK