LyoKICogQ29weXJpZ2h0IChjKSAyMDAzLCAyMDA0IElCTSBDb3Jwb3JhdGlvbiBhbmQgb3RoZXJzLgogKiBBbGwgcmlnaHRzIHJlc2VydmVkLiAgIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQ29tbW9uIFB1YmxpYyBMaWNlbnNlIHYxLjAKICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwKICoKICogQ29udHJpYnV0b3JzOgogKiAgIElCTSAtIEluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgogKgogKiAkSWQ6IENvbXBvbmVudC5qYXZhLHYgMS41IDIwMDQvMTAvMDEgMTk6MzY6Mjkga2h1c3NleSBFeHAgJAogKi8KcGFja2FnZSBvcmcuZWNsaXBzZS51bWwyOwoKaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5jb21tb24udXRpbC5FTGlzdDsKCmltcG9ydCBvcmcuZWNsaXBzZS5lbWYuZWNvcmUuRUNsYXNzOwoKLyoqCiAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CiAqIEEgcmVwcmVzZW50YXRpb24gb2YgdGhlIG1vZGVsIG9iamVjdCAnPGVtPjxiPkNvbXBvbmVudDwvYj48L2VtPicuCiAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgogKgogKiA8cD4KICogVGhlIGZvbGxvd2luZyBmZWF0dXJlcyBhcmUgc3VwcG9ydGVkOgogKiA8dWw+CiAqICAgPGxpPntAbGluayBvcmcuZWNsaXBzZS51bWwyLkNvbXBvbmVudCNpc0luZGlyZWN0bHlJbnN0YW50aWF0ZWQgPGVtPklzIEluZGlyZWN0bHkgSW5zdGFudGlhdGVkPC9lbT59PC9saT4KICogICA8bGk+e0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuQ29tcG9uZW50I2dldFJlcXVpcmVkcyA8ZW0+UmVxdWlyZWQ8L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5Db21wb25lbnQjZ2V0UHJvdmlkZWRzIDxlbT5Qcm92aWRlZDwvZW0+fTwvbGk+CiAqICAgPGxpPntAbGluayBvcmcuZWNsaXBzZS51bWwyLkNvbXBvbmVudCNnZXRSZWFsaXphdGlvbnMgPGVtPlJlYWxpemF0aW9uPC9lbT59PC9saT4KICogICA8bGk+e0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuQ29tcG9uZW50I2dldE93bmVkTWVtYmVycyA8ZW0+T3duZWQgTWVtYmVyPC9lbT59PC9saT4KICogPC91bD4KICogPC9wPgogKgogKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0Q29tcG9uZW50KCkKICogQG1vZGVsIAogKiBAZ2VuZXJhdGVkCiAqLwpwdWJsaWMgaW50ZXJmYWNlIENvbXBvbmVudCBleHRlbmRzIG9yZy5lY2xpcHNlLnVtbDIuQ2xhc3N7CgkvKioKCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBnZW5lcmF0ZWQKCSAqLwoJU3RyaW5nIGNvcHlyaWdodCA9ICJDb3B5cmlnaHQgKGMpIDIwMDMsIDIwMDQgSUJNIENvcnBvcmF0aW9uIGFuZCBvdGhlcnMuIjsgLy8kTk9OLU5MUy0xJAoKCS8qKgoJICogUmV0dXJucyB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+PGI+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2I+PC9lbT4nIGF0dHJpYnV0ZS4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8cD4KCSAqIElmIHRoZSBtZWFuaW5nIG9mIHRoZSAnPGVtPklzIEluZGlyZWN0bHkgSW5zdGFudGlhdGVkPC9lbT4nIGF0dHJpYnV0ZSBpc24ndCBjbGVhciwKCSAqIHRoZXJlIHJlYWxseSBzaG91bGQgYmUgbW9yZSBvZiBhIGRlc2NyaXB0aW9uIGhlcmUuLi4KCSAqIDwvcD4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiB7ZGVmYXVsdCA9IHRydWV9IFRoZSBraW5kIG9mIGluc3RhbnRpYXRpb24gdGhhdCBhcHBsaWVzIHRvIGEgQ29tcG9uZW50LiBJZiBmYWxzZSwgdGhlIGNvbXBvbmVudCBpcyBpbnN0YW50aWF0ZWQgYXMgYW4gYWRkcmVzc2FibGUgb2JqZWN0LiBJZiB0cnVlLCB0aGUgQ29tcG9uZW50IGlzIGRlZmluZWQgYXQgZGVzaWduLXRpbWUsIGJ1dCBhdCBydW50aW1lIChvciBleGVjdXRpb24tdGltZSkgYW4gb2JqZWN0IHNwZWNpZmllZCBieSB0aGUgQ29tcG9uZW50IGRvZXMgbm90IGV4aXN0LCB0aGF0IGlzLCB0aGUgY29tcG9uZW50IGlzIGluc3RhbnRpYXRlZCBpbmRpcmVjdGx5LCB0aHJvdWdoIHRoZSBpbnN0YW50aWF0aW9uIG9mIGl0cyByZWFsaXppbmcgY2xhc3NpZmllcnMgb3IgcGFydHMuIFNldmVyYWwgc3RhbmRhcmQgc3RlcmVvdHlwZXMgdXNlIHRoaXMgbWV0YSBhdHRyaWJ1dGUsIGUuZy4gq3NwZWNpZmljYXRpb24sIKtmb2N1c7ssIKtzdWJzeXN0ZW0guy4KCSAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KCSAqIEByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAnPGVtPklzIEluZGlyZWN0bHkgSW5zdGFudGlhdGVkPC9lbT4nIGF0dHJpYnV0ZS4KCSAqIEBzZWUgI3NldElzSW5kaXJlY3RseUluc3RhbnRpYXRlZChib29sZWFuKQoJICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLlVNTDJQYWNrYWdlI2dldENvbXBvbmVudF9Jc0luZGlyZWN0bHlJbnN0YW50aWF0ZWQoKQoJICogQG1vZGVsIGRhdGFUeXBlPSJvcmcuZWNsaXBzZS51bWwyLkJvb2xlYW4iIHZvbGF0aWxlPSJ0cnVlIgoJICogQGdlbmVyYXRlZAoJICovCglib29sZWFuIGlzSW5kaXJlY3RseUluc3RhbnRpYXRlZCgpOwoKCS8qKgoJICogU2V0cyB0aGUgdmFsdWUgb2YgdGhlICd7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5Db21wb25lbnQjaXNJbmRpcmVjdGx5SW5zdGFudGlhdGVkIDxlbT5JcyBJbmRpcmVjdGx5IEluc3RhbnRpYXRlZDwvZW0+fScgYXR0cmlidXRlLgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIHZhbHVlIHRoZSBuZXcgdmFsdWUgb2YgdGhlICc8ZW0+SXMgSW5kaXJlY3RseSBJbnN0YW50aWF0ZWQ8L2VtPicgYXR0cmlidXRlLgoJICogQHNlZSAjaXNJbmRpcmVjdGx5SW5zdGFudGlhdGVkKCkKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJdm9pZCBzZXRJc0luZGlyZWN0bHlJbnN0YW50aWF0ZWQoYm9vbGVhbiB2YWx1ZSk7CgoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5SZXF1aXJlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiBUaGUgbGlzdCBjb250ZW50cyBhcmUgb2YgdHlwZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5JbnRlcmZhY2V9LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDxwPgoJICogSWYgdGhlIG1lYW5pbmcgb2YgdGhlICc8ZW0+UmVxdWlyZWQ8L2VtPicgcmVmZXJlbmNlIGxpc3QgaXNuJ3QgY2xlYXIsCgkgKiB0aGVyZSByZWFsbHkgc2hvdWxkIGJlIG1vcmUgb2YgYSBkZXNjcmlwdGlvbiBoZXJlLi4uCgkgKiA8L3A+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAnPGVtPlJlcXVpcmVkPC9lbT4nIHJlZmVyZW5jZSBsaXN0LgoJICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLlVNTDJQYWNrYWdlI2dldENvbXBvbmVudF9SZXF1aXJlZCgpCgkgKiBAbW9kZWwgdHlwZT0ib3JnLmVjbGlwc2UudW1sMi5JbnRlcmZhY2UiIHRyYW5zaWVudD0idHJ1ZSIgY2hhbmdlYWJsZT0iZmFsc2UiIHZvbGF0aWxlPSJ0cnVlIiBkZXJpdmVkPSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3QgZ2V0UmVxdWlyZWRzKCk7CgogICAgLyoqCiAgICAgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgZnJvbSB0aGUgJzxlbT48Yj5SZXF1aXJlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gdW5xdWFsaWZpZWROYW1lIFRoZSB1bnF1YWxpZmllZCBuYW1lIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5JbnRlcmZhY2V9IHRvIHJldHJpZXZlLgoJICogQHJldHVybiBUaGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuSW50ZXJmYWNlfSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAc2VlICNnZXRSZXF1aXJlZHMoKQoJICogQGdlbmVyYXRlZAogICAgICovCiAgICBJbnRlcmZhY2UgZ2V0UmVxdWlyZWQoU3RyaW5nIHVucXVhbGlmaWVkTmFtZSk7CiAgICAgIAoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5Qcm92aWRlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiBUaGUgbGlzdCBjb250ZW50cyBhcmUgb2YgdHlwZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5JbnRlcmZhY2V9LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDxwPgoJICogSWYgdGhlIG1lYW5pbmcgb2YgdGhlICc8ZW0+UHJvdmlkZWQ8L2VtPicgcmVmZXJlbmNlIGxpc3QgaXNuJ3QgY2xlYXIsCgkgKiB0aGVyZSByZWFsbHkgc2hvdWxkIGJlIG1vcmUgb2YgYSBkZXNjcmlwdGlvbiBoZXJlLi4uCgkgKiA8L3A+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAnPGVtPlByb3ZpZGVkPC9lbT4nIHJlZmVyZW5jZSBsaXN0LgoJICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLlVNTDJQYWNrYWdlI2dldENvbXBvbmVudF9Qcm92aWRlZCgpCgkgKiBAbW9kZWwgdHlwZT0ib3JnLmVjbGlwc2UudW1sMi5JbnRlcmZhY2UiIHRyYW5zaWVudD0idHJ1ZSIgY2hhbmdlYWJsZT0iZmFsc2UiIHZvbGF0aWxlPSJ0cnVlIiBkZXJpdmVkPSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3QgZ2V0UHJvdmlkZWRzKCk7CgogICAgLyoqCiAgICAgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLkludGVyZmFjZX0gd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgZnJvbSB0aGUgJzxlbT48Yj5Qcm92aWRlZDwvYj48L2VtPicgcmVmZXJlbmNlIGxpc3QuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gdW5xdWFsaWZpZWROYW1lIFRoZSB1bnF1YWxpZmllZCBuYW1lIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5JbnRlcmZhY2V9IHRvIHJldHJpZXZlLgoJICogQHJldHVybiBUaGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuSW50ZXJmYWNlfSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAc2VlICNnZXRQcm92aWRlZHMoKQoJICogQGdlbmVyYXRlZAogICAgICovCiAgICBJbnRlcmZhY2UgZ2V0UHJvdmlkZWQoU3RyaW5nIHVucXVhbGlmaWVkTmFtZSk7CiAgICAgIAoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5SZWFsaXphdGlvbjwvYj48L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiBUaGUgbGlzdCBjb250ZW50cyBhcmUgb2YgdHlwZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5SZWFsaXphdGlvbn0uCgkgKiBJdCBpcyBiaWRpcmVjdGlvbmFsIGFuZCBpdHMgb3Bwb3NpdGUgaXMgJ3tAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9uI2dldEFic3RyYWN0aW9uIDxlbT5BYnN0cmFjdGlvbjwvZW0+fScuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPHA+CgkgKiBJZiB0aGUgbWVhbmluZyBvZiB0aGUgJzxlbT5SZWFsaXphdGlvbjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdCBpc24ndCBjbGVhciwKCSAqIHRoZXJlIHJlYWxseSBzaG91bGQgYmUgbW9yZSBvZiBhIGRlc2NyaXB0aW9uIGhlcmUuLi4KCSAqIDwvcD4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+UmVhbGl6YXRpb248L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGxpc3QuCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0Q29tcG9uZW50X1JlYWxpemF0aW9uKCkKCSAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi5SZWFsaXphdGlvbiNnZXRBYnN0cmFjdGlvbgoJICogQG1vZGVsIHR5cGU9Im9yZy5lY2xpcHNlLnVtbDIuUmVhbGl6YXRpb24iIG9wcG9zaXRlPSJhYnN0cmFjdGlvbiIgY29udGFpbm1lbnQ9InRydWUiIHZvbGF0aWxlPSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3QgZ2V0UmVhbGl6YXRpb25zKCk7CgogICAgLyoqCiAgICAgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSBmcm9tIHRoZSAnPGVtPjxiPlJlYWxpemF0aW9uPC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSB1bnF1YWxpZmllZE5hbWUgVGhlIHVucXVhbGlmaWVkIG5hbWUgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSB0byByZXRyaWV2ZS4KCSAqIEByZXR1cm4gVGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSB3aXRoIHRoZSBzcGVjaWZpZWQgbmFtZSwgb3IgPGNvZGU+bnVsbDwvY29kZT4uCgkgKiBAc2VlICNnZXRSZWFsaXphdGlvbnMoKQoJICogQGdlbmVyYXRlZAogICAgICovCiAgICBSZWFsaXphdGlvbiBnZXRSZWFsaXphdGlvbihTdHJpbmcgdW5xdWFsaWZpZWROYW1lKTsKICAgICAgCiAgICAvKioKICAgICAqIENyZWF0ZXMgYSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5SZWFsaXphdGlvbn0gYW5kIGFwcGVuZHMgaXQgdG8gdGhlICc8ZW0+PGI+UmVhbGl6YXRpb248L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIGVDbGFzcyBUaGUgRWNvcmUgY2xhc3Mgb2YgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlJlYWxpemF0aW9ufSB0byBjcmVhdGUuCgkgKiBAcmV0dXJuIFRoZSBuZXcge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUmVhbGl6YXRpb259LgoJICogQHNlZSAjZ2V0UmVhbGl6YXRpb25zKCkKCSAqIEBnZW5lcmF0ZWQKICAgICAqLwogICAgUmVhbGl6YXRpb24gY3JlYXRlUmVhbGl6YXRpb24oRUNsYXNzIGVDbGFzcyk7CgoJLyoqCgkgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgJzxlbT48Yj5Pd25lZCBNZW1iZXI8L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogVGhlIGxpc3QgY29udGVudHMgYXJlIG9mIHR5cGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUGFja2FnZWFibGVFbGVtZW50fS4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8cD4KCSAqIElmIHRoZSBtZWFuaW5nIG9mIHRoZSAnPGVtPk93bmVkIE1lbWJlcjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdCBpc24ndCBjbGVhciwKCSAqIHRoZXJlIHJlYWxseSBzaG91bGQgYmUgbW9yZSBvZiBhIGRlc2NyaXB0aW9uIGhlcmUuLi4KCSAqIDwvcD4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHJldHVybiB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+T3duZWQgTWVtYmVyPC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLlVNTDJQYWNrYWdlI2dldENvbXBvbmVudF9Pd25lZE1lbWJlcigpCgkgKiBAbW9kZWwgdHlwZT0ib3JnLmVjbGlwc2UudW1sMi5QYWNrYWdlYWJsZUVsZW1lbnQiIGNvbnRhaW5tZW50PSJ0cnVlIiBvcmRlcmVkPSJmYWxzZSIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3QgZ2V0T3duZWRNZW1iZXJzKCk7CgogICAgLyoqCiAgICAgKiBSZXRyaWV2ZXMgdGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0gd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUgZnJvbSB0aGUgJzxlbT48Yj5Pd25lZCBNZW1iZXI8L2I+PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZSBsaXN0LgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIHVucXVhbGlmaWVkTmFtZSBUaGUgdW5xdWFsaWZpZWQgbmFtZSBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuUGFja2FnZWFibGVFbGVtZW50fSB0byByZXRyaWV2ZS4KCSAqIEByZXR1cm4gVGhlIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0gd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUsIG9yIDxjb2RlPm51bGw8L2NvZGU+LgoJICogQHNlZSAjZ2V0T3duZWRNZW1iZXJzKCkKCSAqIEBnZW5lcmF0ZWQKICAgICAqLwogICAgUGFja2FnZWFibGVFbGVtZW50IGdldE93bmVkTWVtYmVyKFN0cmluZyB1bnF1YWxpZmllZE5hbWUpOwogICAgICAKICAgIC8qKgogICAgICogQ3JlYXRlcyBhIHtAbGluayBvcmcuZWNsaXBzZS51bWwyLlBhY2thZ2VhYmxlRWxlbWVudH0gYW5kIGFwcGVuZHMgaXQgdG8gdGhlICc8ZW0+PGI+T3duZWQgTWVtYmVyPC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UgbGlzdC4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSBlQ2xhc3MgVGhlIEVjb3JlIGNsYXNzIG9mIHRoZSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5QYWNrYWdlYWJsZUVsZW1lbnR9IHRvIGNyZWF0ZS4KCSAqIEByZXR1cm4gVGhlIG5ldyB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5QYWNrYWdlYWJsZUVsZW1lbnR9LgoJICogQHNlZSAjZ2V0T3duZWRNZW1iZXJzKCkKCSAqIEBnZW5lcmF0ZWQKICAgICAqLwogICAgUGFja2FnZWFibGVFbGVtZW50IGNyZWF0ZU93bmVkTWVtYmVyKEVDbGFzcyBlQ2xhc3MpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQG1vZGVsIHBhcmFtZXRlcnM9IiIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3QgZ2V0T3duZWRFbGVtZW50cygpOwoKCS8qKgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQG1vZGVsIHBhcmFtZXRlcnM9IiIKCSAqIEBnZW5lcmF0ZWQKCSAqLwoJRUxpc3QgZ2V0Q2xpZW50RGVwZW5kZW5jaWVzKCk7Cgp9IC8vIENvbXBvbmVudAo=