LyoKICogQ29weXJpZ2h0IChjKSAyMDAzLCAyMDA0IElCTSBDb3Jwb3JhdGlvbiBhbmQgb3RoZXJzLgogKiBBbGwgcmlnaHRzIHJlc2VydmVkLiAgIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQ29tbW9uIFB1YmxpYyBMaWNlbnNlIHYxLjAKICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwKICoKICogQ29udHJpYnV0b3JzOgogKiAgIElCTSAtIEluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgogKgogKiAkSWQ6IFN0cnVjdHVyYWxGZWF0dXJlQWN0aW9uLmphdmEsdiAxLjMgMjAwNC8wNi8wNiAwMTozNTowMyBraHVzc2V5IEV4cCAkCiAqLwpwYWNrYWdlIG9yZy5lY2xpcHNlLnVtbDI7CgppbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi51dGlsLkVMaXN0OwoKaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5lY29yZS5FQ2xhc3M7CgovKioKICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KICogQSByZXByZXNlbnRhdGlvbiBvZiB0aGUgbW9kZWwgb2JqZWN0ICc8ZW0+PGI+U3RydWN0dXJhbCBGZWF0dXJlIEFjdGlvbjwvYj48L2VtPicuCiAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgogKgogKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KICogVGhpcyBhYnN0cmFjdCBhY3Rpb24gY2xhc3Mgc3RhdGljYWxseSBzcGVjaWZpZXMgdGhlIHN0cnVjdHVyYWwgZmVhdHVyZSBiZWluZyBhY2Nlc3NlZC4gVGhlIG9iamVjdCB0byBhY2Nlc3MgaXMgc3BlY2lmaWVkIGR5bmFtaWNhbGx5LCBieSByZWZlcnJpbmcgdG8gYW4gaW5wdXQgcGluIG9uIHdoaWNoIHRoZSBvYmplY3Qgd2lsbCBiZSBwbGFjZWQgYXQgcnVudGltZS4gVGhlIHR5cGUgb2YgdGhlIHZhbHVlIG9mIHRoaXMgcGluIGlzIHRoZSBjbGFzc2lmaWVyIHRoYXQgb3ducyB0aGUgc3BlY2lmaWVkIHN0cnVjdHVyYWwgZmVhdHVyZSwgYW5kIHRoZSB2YWx1ZZJzIG11bHRpcGxpY2l0eSBpcyAxLi4xLiAKICogPCEtLSBlbmQtbW9kZWwtZG9jIC0tPgogKgogKiA8cD4KICogVGhlIGZvbGxvd2luZyBmZWF0dXJlcyBhcmUgc3VwcG9ydGVkOgogKiA8dWw+CiAqICAgPGxpPntAbGluayBvcmcuZWNsaXBzZS51bWwyLlN0cnVjdHVyYWxGZWF0dXJlQWN0aW9uI2dldFN0cnVjdHVyYWxGZWF0dXJlIDxlbT5TdHJ1Y3R1cmFsIEZlYXR1cmU8L2VtPn08L2xpPgogKiAgIDxsaT57QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5TdHJ1Y3R1cmFsRmVhdHVyZUFjdGlvbiNnZXRPYmplY3QgPGVtPk9iamVjdDwvZW0+fTwvbGk+CiAqIDwvdWw+CiAqIDwvcD4KICoKICogQHNlZSBvcmcuZWNsaXBzZS51bWwyLlVNTDJQYWNrYWdlI2dldFN0cnVjdHVyYWxGZWF0dXJlQWN0aW9uKCkKICogQG1vZGVsIGFic3RyYWN0PSJ0cnVlIgogKiBAZ2VuZXJhdGVkCiAqLwpwdWJsaWMgaW50ZXJmYWNlIFN0cnVjdHVyYWxGZWF0dXJlQWN0aW9uIGV4dGVuZHMgQWN0aW9uewoJLyoqCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAZ2VuZXJhdGVkCgkgKi8KCVN0cmluZyBjb3B5cmlnaHQgPSAiQ29weXJpZ2h0IChjKSAyMDAzLCAyMDA0IElCTSBDb3Jwb3JhdGlvbiBhbmQgb3RoZXJzLiI7IC8vJE5PTi1OTFMtMSQKCgkvKioKCSAqIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSAnPGVtPjxiPlN0cnVjdHVyYWwgRmVhdHVyZTwvYj48L2VtPicgcmVmZXJlbmNlLgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDxwPgoJICogSWYgdGhlIG1lYW5pbmcgb2YgdGhlICc8ZW0+U3RydWN0dXJhbCBGZWF0dXJlPC9lbT4nIHJlZmVyZW5jZSBpc24ndCBjbGVhciwKCSAqIHRoZXJlIHJlYWxseSBzaG91bGQgYmUgbW9yZSBvZiBhIGRlc2NyaXB0aW9uIGhlcmUuLi4KCSAqIDwvcD4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogPCEtLSBiZWdpbi1tb2RlbC1kb2MgLS0+CgkgKiBTdHJ1Y3R1cmFsIGZlYXR1cmUgdG8gYmUgcmVhZC4KCSAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KCSAqIEByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAnPGVtPlN0cnVjdHVyYWwgRmVhdHVyZTwvZW0+JyByZWZlcmVuY2UuCgkgKiBAc2VlICNzZXRTdHJ1Y3R1cmFsRmVhdHVyZShTdHJ1Y3R1cmFsRmVhdHVyZSkKCSAqIEBzZWUgb3JnLmVjbGlwc2UudW1sMi5VTUwyUGFja2FnZSNnZXRTdHJ1Y3R1cmFsRmVhdHVyZUFjdGlvbl9TdHJ1Y3R1cmFsRmVhdHVyZSgpCgkgKiBAbW9kZWwgcmVxdWlyZWQ9InRydWUiCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCVN0cnVjdHVyYWxGZWF0dXJlIGdldFN0cnVjdHVyYWxGZWF0dXJlKCk7CgoJLyoqCgkgKiBTZXRzIHRoZSB2YWx1ZSBvZiB0aGUgJ3tAbGluayBvcmcuZWNsaXBzZS51bWwyLlN0cnVjdHVyYWxGZWF0dXJlQWN0aW9uI2dldFN0cnVjdHVyYWxGZWF0dXJlIDxlbT5TdHJ1Y3R1cmFsIEZlYXR1cmU8L2VtPn0nIHJlZmVyZW5jZS4KCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBwYXJhbSB2YWx1ZSB0aGUgbmV3IHZhbHVlIG9mIHRoZSAnPGVtPlN0cnVjdHVyYWwgRmVhdHVyZTwvZW0+JyByZWZlcmVuY2UuCgkgKiBAc2VlICNnZXRTdHJ1Y3R1cmFsRmVhdHVyZSgpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCXZvaWQgc2V0U3RydWN0dXJhbEZlYXR1cmUoU3RydWN0dXJhbEZlYXR1cmUgdmFsdWUpOwoKCS8qKgoJICogUmV0dXJucyB0aGUgdmFsdWUgb2YgdGhlICc8ZW0+PGI+T2JqZWN0PC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPHA+CgkgKiBJZiB0aGUgbWVhbmluZyBvZiB0aGUgJzxlbT5PYmplY3Q8L2VtPicgY29udGFpbm1lbnQgcmVmZXJlbmNlIGlzbid0IGNsZWFyLAoJICogdGhlcmUgcmVhbGx5IHNob3VsZCBiZSBtb3JlIG9mIGEgZGVzY3JpcHRpb24gaGVyZS4uLgoJICogPC9wPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiA8IS0tIGJlZ2luLW1vZGVsLWRvYyAtLT4KCSAqIChTcGVjaWFsaXplZCBmcm9tIEFjdGlvbjppbnB1dCkgR2l2ZXMgdGhlIGlucHV0IHBpbiBmcm9tIHdoaWNoIHRoZSBvYmplY3Qgd2hvc2Ugc3RydWN0dXJhbCBmZWF0dXJlIGlzIHRvIGJlIHJlYWQgb3Igd3JpdHRlbiBpcyBvYnRhaW5lZC4KCSAqIDwhLS0gZW5kLW1vZGVsLWRvYyAtLT4KCSAqIEByZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSAnPGVtPk9iamVjdDwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UuCgkgKiBAc2VlICNzZXRPYmplY3QoSW5wdXRQaW4pCgkgKiBAc2VlIG9yZy5lY2xpcHNlLnVtbDIuVU1MMlBhY2thZ2UjZ2V0U3RydWN0dXJhbEZlYXR1cmVBY3Rpb25fT2JqZWN0KCkKCSAqIEBtb2RlbCBjb250YWlubWVudD0idHJ1ZSIgcmVxdWlyZWQ9InRydWUiCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUlucHV0UGluIGdldE9iamVjdCgpOwoKCS8qKgoJICogU2V0cyB0aGUgdmFsdWUgb2YgdGhlICd7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5TdHJ1Y3R1cmFsRmVhdHVyZUFjdGlvbiNnZXRPYmplY3QgPGVtPk9iamVjdDwvZW0+fScgY29udGFpbm1lbnQgcmVmZXJlbmNlLgoJICogPCEtLSBiZWdpbi11c2VyLWRvYyAtLT4KCSAqIDwhLS0gZW5kLXVzZXItZG9jIC0tPgoJICogQHBhcmFtIHZhbHVlIHRoZSBuZXcgdmFsdWUgb2YgdGhlICc8ZW0+T2JqZWN0PC9lbT4nIGNvbnRhaW5tZW50IHJlZmVyZW5jZS4KCSAqIEBzZWUgI2dldE9iamVjdCgpCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCXZvaWQgc2V0T2JqZWN0KElucHV0UGluIHZhbHVlKTsKCiAgICAvKioKICAgICAqIENyZWF0ZXMgYSB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5JbnB1dFBpbn0gYW5kIHNldHMgdGhlICc8ZW0+PGI+T2JqZWN0PC9iPjwvZW0+JyBjb250YWlubWVudCByZWZlcmVuY2UuCgkgKiA8IS0tIGJlZ2luLXVzZXItZG9jIC0tPgoJICogPCEtLSBlbmQtdXNlci1kb2MgLS0+CgkgKiBAcGFyYW0gZUNsYXNzIFRoZSBFY29yZSBjbGFzcyBvZiB0aGUge0BsaW5rIG9yZy5lY2xpcHNlLnVtbDIuSW5wdXRQaW59IHRvIGNyZWF0ZS4KCSAqIEByZXR1cm4gVGhlIG5ldyB7QGxpbmsgb3JnLmVjbGlwc2UudW1sMi5JbnB1dFBpbn0uCgkgKiBAc2VlICNnZXRPYmplY3QoKQoJICogQGdlbmVyYXRlZAogICAgICovCiAgICBJbnB1dFBpbiBjcmVhdGVPYmplY3QoRUNsYXNzIGVDbGFzcyk7CiAgICAgCgkvKioKCSAqIDwhLS0gYmVnaW4tdXNlci1kb2MgLS0+CgkgKiA8IS0tIGVuZC11c2VyLWRvYyAtLT4KCSAqIEBtb2RlbCBwYXJhbWV0ZXJzPSIiCgkgKiBAZ2VuZXJhdGVkCgkgKi8KCUVMaXN0IGdldElucHV0cygpOwoKfSAvLyBTdHJ1Y3R1cmFsRmVhdHVyZUFjdGlvbgo=