LyoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogICBDb3B5cmlnaHQgKEMpIDE5OTYtMjAwMywgSW50ZXJuYXRpb25hbCBCdXNpbmVzcyBNYWNoaW5lcyAgICAgICAgICAgICAgICAgKgoqICAgQ29ycG9yYXRpb24gYW5kIG90aGVycy4gIEFsbCBSaWdodHMgUmVzZXJ2ZWQuICAgICAgICAgICAgICAgICAgICAgICAgICAgICoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiovCgovKioKKiBGaWxlIGNvbGwuaAoqIAoqIENyZWF0ZWQgYnk6IEhlbGVuYSBTaGloCioKKiBNb2RpZmljYXRpb24gSGlzdG9yeToKKgoqICBEYXRlICAgICAgICBOYW1lICAgICAgICBEZXNjcmlwdGlvbgoqIDAyLzUvOTcgICAgICBhbGl1ICAgICAgICBNb2RpZmllZCBjcmVhdGVEZWZhdWx0IHRvIGxvYWQgY29sbGF0aW9uIGRhdGEgZnJvbQoqICAgICAgICAgICAgICAgICAgICAgICAgICBiaW5hcnkgZmlsZXMgd2hlbiBwb3NzaWJsZS4gIEFkZGVkIHJlbGF0ZWQgbWV0aG9kcwoqICAgICAgICAgICAgICAgICAgICAgICAgICBjcmVhdGVDb2xsYXRpb25Gcm9tRmlsZSwgY2hvcExvY2FsZSwgY3JlYXRlUGF0aE5hbWUuCiogMDIvMTEvOTcgICAgIGFsaXUgICAgICAgIEFkZGVkIG1lbWJlcnMgYWRkVG9DYWNoZSwgZmluZEluQ2FjaGUsIGFuZCBmZ0NhY2hlLgoqIDAyLzEyLzk3ICAgICBhbGl1ICAgICAgICBNb2RpZmllZCB0byBjcmVhdGUgb2JqZWN0cyBmcm9tIFJ1bGVCYXNlZENvbGxhdG9yIGNhY2hlLgoqICAgICAgICAgICAgICAgICAgICAgICAgICBNb3ZlZCBjYWNoZSBvdXQgb2YgQ29sbGF0aW9uIGNsYXNzLgoqIDAyLzEzLzk3ICAgICBhbGl1ICAgICAgICBNb3ZlZCBzZXZlcmFsIG1ldGhvZHMgb3V0IG9mIHRoaXMgY2xhc3MgYW5kIGludG8KKiAgICAgICAgICAgICAgICAgICAgICAgICAgUnVsZUJhc2VkQ29sbGF0b3IsIHdpdGggbW9kaWZpY2F0aW9ucy4gIE1vZGlmaWVkCiogICAgICAgICAgICAgICAgICAgICAgICAgIGNyZWF0ZURlZmF1bHQoKSB0byBjYWxsIG5ldyBSdWxlQmFzZWRDb2xsYXRvcihMb2NhbGUmKQoqICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdHJ1Y3Rvci4gIEdlbmVyYWwgY2xlYW4gdXAgYW5kIGRvY3VtZW50YXRpb24uCiogMDIvMjAvOTcgICAgIGhlbGVuYSAgICAgIEFkZGVkIGNsb25lLCBvcGVyYXRvcj09LCBvcGVyYXRvciE9LCBvcGVyYXRvcj0sIGNvcHkKKiAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3RydWN0b3IgYW5kIGdldER5bmFtaWNDbGFzc0lELgoqIDAzLzI1Lzk3ICAgICBoZWxlbmEgICAgICBVcGRhdGVkIHdpdGggcGxhdGZvcm0gaW5kZXBlbmRlbnQgZGF0YSB0eXBlcy4KKiAwNS8wNi85NyAgICAgaGVsZW5hICAgICAgQWRkZWQgbWVtb3J5IGFsbG9jYXRpb24gZXJyb3IgZGV0ZWN0aW9uLgoqIDA2LzIwLzk3ICAgICBoZWxlbmEgICAgICBKYXZhIGNsYXNzIG5hbWUgY2hhbmdlLgoqIDA5LzAzLzk3ICAgICBoZWxlbmEgICAgICBBZGRlZCBjcmVhdGVDb2xsYXRpb25LZXlWYWx1ZXMoKS4KKiAwMi8xMC85OCAgICAgZGFtaWJhICAgICAgQWRkZWQgY29tcGFyZSgpIHdpdGggbGVuZ3RoIGFzIHBhcmFtZXRlci4KKiAwNC8yMy85OSAgICAgc3RlcGhlbiAgICAgUmVtb3ZlZCBFRGVjb21wb3NpdGlvbk1vZGUsIG1lcmdlZCB3aXRoCiogICAgICAgICAgICAgICAgICAgICAgICAgIE5vcm1hbGl6ZXI6OkVNb2RlLgoqIDExLzAyLzk5ICAgICBoZWxlbmEgICAgICBDb2xsYXRvciBwZXJmb3JtYW5jZSBlbmhhbmNlbWVudHMuICBFbGltaW5hdGVzIHRoZSAKKiAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyBjb25zdHJ1Y3Rpb24gYW5kIHNwZWNpYWwgY2FzZSBmb3IgTk9fT1AuCiogMTEvMjMvOTkgICAgIHNybCAgICAgICAgIE1vcmUgcGVyZm9ybWFuY2UgZW5oYW5jZW1lbnRzLiBJbmxpbmluZyBvZgoqICAgICAgICAgICAgICAgICAgICAgICAgICBjcml0aWNhbCBhY2Nlc3NvcnMuCiogMDUvMTUvMDAgICAgIGhlbGVuYSAgICAgIEFkZGVkIHZlcnNpb24gaW5mb3JtYXRpb24gQVBJLiAKKiAwMS8yOS8wMSAgICAgc3lud2VlICAgICAgTW9kaWZpZWQgaW50byBhIEMrKyB3cmFwcGVyIHdoaWNoIGNhbGxzIEMgYXBpcyAKKiAgICAgICAgICAgICAgICAgICAgICAgICAgKHVjb2xsLmgpLiAKKi8KCiNpZm5kZWYgQ09MTF9ICiNkZWZpbmUgQ09MTF9ICgojaW5jbHVkZSAidW5pY29kZS91dHlwZXMuaCIKCiNpZiAhVUNPTkZJR19OT19DT0xMQVRJT04KCiNpbmNsdWRlICJ1bmljb2RlL3VvYmplY3QuaCIKI2luY2x1ZGUgInVuaWNvZGUvdWNvbC5oIgojaW5jbHVkZSAidW5pY29kZS9ub3JtbHpyLmgiCiNpbmNsdWRlICJ1bmljb2RlL2xvY2lkLmgiCiNpbmNsdWRlICJ1bmljb2RlL3VuaXNldC5oIgoKVV9OQU1FU1BBQ0VfQkVHSU4KCmNsYXNzIFN0cmluZ0VudW1lcmF0aW9uOwoKLyoqCiAqIEBkcmFmdCBJQ1UgMi42CiAqLwp0eXBlZGVmIGNvbnN0IHZvaWQqIFVSZWdpc3RyeUtleTsKCi8qKgogKiBAZHJhZnQgSUNVMi42CiAqLwpjbGFzcyBDb2xsYXRvckZhY3Rvcnk7CgovKioKKiBAc3RhYmxlIElDVSAyLjAKKi8KY2xhc3MgQ29sbGF0aW9uS2V5OwoKLyoqCiogVGhlIDxjb2RlPkNvbGxhdG9yPC9jb2RlPiBjbGFzcyBwZXJmb3JtcyBsb2NhbGUtc2Vuc2l0aXZlIHN0cmluZyAKKiBjb21wYXJpc29uLjxicj4KKiBZb3UgdXNlIHRoaXMgY2xhc3MgdG8gYnVpbGQgc2VhcmNoaW5nIGFuZCBzb3J0aW5nIHJvdXRpbmVzIGZvciBuYXR1cmFsIAoqIGxhbmd1YWdlIHRleHQuPGJyPgoqIDxlbT5JbXBvcnRhbnQ6IDwvZW0+VGhlIElDVSBjb2xsYXRpb24gc2VydmljZSBoYXMgYmVlbiByZWltcGxlbWVudGVkIAoqIGluIG9yZGVyIHRvIGFjaGlldmUgYmV0dGVyIHBlcmZvcm1hbmNlIGFuZCBVQ0EgY29tcGxpYW5jZS4gCiogRm9yIGRldGFpbHMsIHNlZSB0aGUgCiogPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2N2cy9pY3UvfmNoZWNrb3V0fi9pY3VodG1sL2Rlc2lnbi9jb2xsYXRpb24vSUNVX2NvbGxhdGlvbl9kZXNpZ24uaHRtIj4KKiBjb2xsYXRpb24gZGVzaWduIGRvY3VtZW50PC9hPi4KKiA8cD4KKiA8Y29kZT5Db2xsYXRvcjwvY29kZT4gaXMgYW4gYWJzdHJhY3QgYmFzZSBjbGFzcy4gU3ViY2xhc3NlcyBpbXBsZW1lbnQgCiogc3BlY2lmaWMgY29sbGF0aW9uIHN0cmF0ZWdpZXMuIE9uZSBzdWJjbGFzcywgCiogPGNvZGU+UnVsZUJhc2VkQ29sbGF0b3I8L2NvZGU+LCBpcyBjdXJyZW50bHkgcHJvdmlkZWQgYW5kIGlzIGFwcGxpY2FibGUgCiogdG8gYSB3aWRlIHNldCBvZiBsYW5ndWFnZXMuIE90aGVyIHN1YmNsYXNzZXMgbWF5IGJlIGNyZWF0ZWQgdG8gaGFuZGxlIG1vcmUgCiogc3BlY2lhbGl6ZWQgbmVlZHMuCiogPHA+CiogTGlrZSBvdGhlciBsb2NhbGUtc2Vuc2l0aXZlIGNsYXNzZXMsIHlvdSBjYW4gdXNlIHRoZSBzdGF0aWMgZmFjdG9yeSBtZXRob2QsIAoqIDxjb2RlPmNyZWF0ZUluc3RhbmNlPC9jb2RlPiwgdG8gb2J0YWluIHRoZSBhcHByb3ByaWF0ZSAKKiA8Y29kZT5Db2xsYXRvcjwvY29kZT4gb2JqZWN0IGZvciBhIGdpdmVuIGxvY2FsZS4gWW91IHdpbGwgb25seSBuZWVkIHRvIAoqIGxvb2sgYXQgdGhlIHN1YmNsYXNzZXMgb2YgPGNvZGU+Q29sbGF0b3I8L2NvZGU+IGlmIHlvdSBuZWVkIHRvIAoqIHVuZGVyc3RhbmQgdGhlIGRldGFpbHMgb2YgYSBwYXJ0aWN1bGFyIGNvbGxhdGlvbiBzdHJhdGVneSBvciBpZiB5b3UgbmVlZCB0byAKKiBtb2RpZnkgdGhhdCBzdHJhdGVneS4KKiA8cD4KKiBUaGUgZm9sbG93aW5nIGV4YW1wbGUgc2hvd3MgaG93IHRvIGNvbXBhcmUgdHdvIHN0cmluZ3MgdXNpbmcgdGhlIAoqIDxjb2RlPkNvbGxhdG9yPC9jb2RlPiBmb3IgdGhlIGRlZmF1bHQgbG9jYWxlLgoqIDxibG9ja3F1b3RlPgoqIDxwcmU+CiogXGNvZGUKKiAvLyBDb21wYXJlIHR3byBzdHJpbmdzIGluIHRoZSBkZWZhdWx0IGxvY2FsZQoqIFVFcnJvckNvZGUgc3VjY2VzcyA9IFVfWkVST19FUlJPUjsKKiBDb2xsYXRvciogbXlDb2xsYXRvciA9IENvbGxhdG9yOjpjcmVhdGVJbnN0YW5jZShzdWNjZXNzKTsKKiBpZiAobXlDb2xsYXRvci0+Y29tcGFyZSgiYWJjIiwgIkFCQyIpIDwgMCkKKiAgIGNvdXQgPDwgImFiYyBpcyBsZXNzIHRoYW4gQUJDIiA8PCBlbmRsOwoqIGVsc2UKKiAgIGNvdXQgPDwgImFiYyBpcyBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gQUJDIiA8PCBlbmRsOwoqIFxlbmRjb2RlCiogPC9wcmU+CiogPC9ibG9ja3F1b3RlPgoqIDxwPgoqIFlvdSBjYW4gc2V0IGEgPGNvZGU+Q29sbGF0b3I8L2NvZGU+J3MgPGVtPnN0cmVuZ3RoPC9lbT4gcHJvcGVydHkgdG8gCiogZGV0ZXJtaW5lIHRoZSBsZXZlbCBvZiBkaWZmZXJlbmNlIGNvbnNpZGVyZWQgc2lnbmlmaWNhbnQgaW4gY29tcGFyaXNvbnMuIAoqIEZpdmUgc3RyZW5ndGhzIGFyZSBwcm92aWRlZDogPGNvZGU+UFJJTUFSWTwvY29kZT4sIDxjb2RlPlNFQ09OREFSWTwvY29kZT4sIAoqIDxjb2RlPlRFUlRJQVJZPC9jb2RlPiwgPGNvZGU+UVVBVEVSTkFSWTwvY29kZT4gYW5kIDxjb2RlPklERU5USUNBTDwvY29kZT4uIFRoZSBleGFjdCBhc3NpZ25tZW50IG9mIAoqIHN0cmVuZ3RocyB0byBsYW5ndWFnZSBmZWF0dXJlcyBpcyBsb2NhbGUgZGVwZW5kYW50LiBGb3IgZXhhbXBsZSwgaW4gQ3plY2gsIAoqICJlIiBhbmQgImYiIGFyZSBjb25zaWRlcmVkIHByaW1hcnkgZGlmZmVyZW5jZXMsIHdoaWxlICJlIiBhbmQgIlx1MDBFQSIgYXJlIAoqIHNlY29uZGFyeSBkaWZmZXJlbmNlcywgImUiIGFuZCAiRSIgYXJlIHRlcnRpYXJ5IGRpZmZlcmVuY2VzIGFuZCAiZSIgYW5kICJlIiAKKiBhcmUgaWRlbnRpY2FsLiBUaGUgZm9sbG93aW5nIHNob3dzIGhvdyBib3RoIGNhc2UgYW5kIGFjY2VudHMgY291bGQgYmUgCiogaWdub3JlZCBmb3IgVVMgRW5nbGlzaC4KKiA8YmxvY2txdW90ZT4KKiA8cHJlPgoqIFxjb2RlCiogLy9HZXQgdGhlIENvbGxhdG9yIGZvciBVUyBFbmdsaXNoIGFuZCBzZXQgaXRzIHN0cmVuZ3RoIHRvIFBSSU1BUlkgCiogVUVycm9yQ29kZSBzdWNjZXNzID0gVV9aRVJPX0VSUk9SOwoqIENvbGxhdG9yKiB1c0NvbGxhdG9yID0gCiogICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29sbGF0b3I6OmNyZWF0ZUluc3RhbmNlKExvY2FsZTo6VVMsIHN1Y2Nlc3MpOwoqIHVzQ29sbGF0b3ItPnNldFN0cmVuZ3RoKENvbGxhdG9yOjpQUklNQVJZKTsKKiBpZiAodXNDb2xsYXRvci0+Y29tcGFyZSgiYWJjIiwgIkFCQyIpID09IDApCiogICBjb3V0IDw8IAoqICInYWJjJyBhbmQgJ0FCQycgc3RyaW5ncyBhcmUgZXF1aXZhbGVudCB3aXRoIHN0cmVuZ3RoIFBSSU1BUlkiIDw8IAoqIGVuZGw7CiogXGVuZGNvZGUKKiA8L3ByZT4KKiA8L2Jsb2NrcXVvdGU+CiogPHA+CiogRm9yIGNvbXBhcmluZyBzdHJpbmdzIGV4YWN0bHkgb25jZSwgdGhlIDxjb2RlPmNvbXBhcmU8L2NvZGU+IG1ldGhvZCAKKiBwcm92aWRlcyB0aGUgYmVzdCBwZXJmb3JtYW5jZS4gV2hlbiBzb3J0aW5nIGEgbGlzdCBvZiBzdHJpbmdzIGhvd2V2ZXIsIGl0IAoqIGlzIGdlbmVyYWxseSBuZWNlc3NhcnkgdG8gY29tcGFyZSBlYWNoIHN0cmluZyBtdWx0aXBsZSB0aW1lcy4gSW4gdGhpcyBjYXNlLCAKKiBzb3J0IGtleXMgcHJvdmlkZSBiZXR0ZXIgcGVyZm9ybWFuY2UuIFRoZSA8Y29kZT5nZXRTb3J0S2V5PC9jb2RlPiBtZXRob2RzIAoqIGNvbnZlcnQgYSBzdHJpbmcgdG8gYSBzZXJpZXMgb2YgYnl0ZXMgdGhhdCBjYW4gYmUgY29tcGFyZWQgYml0d2lzZSBhZ2FpbnN0IAoqIG90aGVyIHNvcnQga2V5cyB1c2luZyA8Y29kZT5zdHJjbXAoKTwvY29kZT4uIFNvcnQga2V5cyBhcmUgd3JpdHRlbiBhcyAKKiB6ZXJvLXRlcm1pbmF0ZWQgYnl0ZSBzdHJpbmdzLiBUaGV5IGNvbnNpc3Qgb2Ygc2V2ZXJhbCBzdWJzdHJpbmdzLCBvbmUgZm9yIAoqIGVhY2ggY29sbGF0aW9uIHN0cmVuZ3RoIGxldmVsLCB0aGF0IGFyZSBkZWxpbWl0ZWQgYnkgMHgwMSBieXRlcy4KKiBJZiB0aGUgc3RyaW5nIGNvZGUgcG9pbnRzIGFyZSBhcHBlbmRlZCBmb3IgVUNPTF9JREVOVElDQUwsIHRoZW4gdGhleSBhcmUgCiogcHJvY2Vzc2VkIGZvciBjb3JyZWN0IGNvZGUgcG9pbnQgb3JkZXIgY29tcGFyaXNvbiBhbmQgbWF5IGNvbnRhaW4gMHgwMSAKKiBieXRlcyBidXQgbm90IHplcm8gYnl0ZXMuCiogPC9wPgoqIDxwPgoqIEFuIG9sZGVyIHNldCBvZiBBUElzIHJldHVybnMgYSA8Y29kZT5Db2xsYXRpb25LZXk8L2NvZGU+IG9iamVjdCB0aGF0IHdyYXBzIAoqIHRoZSBzb3J0IGtleSBieXRlcyBpbnN0ZWFkIG9mIHJldHVybmluZyB0aGUgYnl0ZXMgdGhlbXNlbHZlcy4KKiBJdHMgdXNlIGlzIGRlcHJlY2F0ZWQsIGJ1dCBpdCBpcyBzdGlsbCBhdmFpbGFibGUgZm9yIGNvbXBhdGliaWxpdHkgd2l0aCAKKiBKYXZhLgoqIDwvcD4KKiA8cD4KKiA8c3Ryb25nPk5vdGU6PC9zdHJvbmc+IDxjb2RlPkNvbGxhdG9yPC9jb2RlPnMgd2l0aCBkaWZmZXJlbnQgTG9jYWxlLAoqIGFuZCBDb2xsYXRpb25TdHJlbmd0aCBzZXR0aW5ncyB3aWxsIHJldHVybiBkaWZmZXJlbnQgc29ydCAKKiBvcmRlcnMgZm9yIHRoZSBzYW1lIHNldCBvZiBzdHJpbmdzLiBMb2NhbGVzIGhhdmUgc3BlY2lmaWMgY29sbGF0aW9uIHJ1bGVzLCAKKiBhbmQgdGhlIHdheSBpbiB3aGljaCBzZWNvbmRhcnkgYW5kIHRlcnRpYXJ5IGRpZmZlcmVuY2VzIGFyZSB0YWtlbiBpbnRvIAoqIGFjY291bnQsIGZvciBleGFtcGxlLCB3aWxsIHJlc3VsdCBpbiBhIGRpZmZlcmVudCBzb3J0aW5nIG9yZGVyIGZvciBzYW1lIAoqIHN0cmluZ3MuCiogPC9wPgoqIEBzZWUgICAgICAgICBSdWxlQmFzZWRDb2xsYXRvcgoqIEBzZWUgICAgICAgICBDb2xsYXRpb25LZXkKKiBAc2VlICAgICAgICAgQ29sbGF0aW9uRWxlbWVudEl0ZXJhdG9yCiogQHNlZSAgICAgICAgIExvY2FsZQoqIEBzZWUgICAgICAgICBOb3JtYWxpemVyCiogQHZlcnNpb24gICAgIDIuMCAxMS8xNS8wMQoqLwoKY2xhc3MgVV9JMThOX0FQSSBDb2xsYXRvciA6IHB1YmxpYyBVT2JqZWN0IHsKcHVibGljOgoKICAvLyBDb2xsYXRvciBwdWJsaWMgZW51bXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCiAgLyoqCiAgKiBCYXNlIGxldHRlciByZXByZXNlbnRzIGEgcHJpbWFyeSBkaWZmZXJlbmNlLiBTZXQgY29tcGFyaXNvbiBsZXZlbCB0byAKICAqIFBSSU1BUlkgdG8gaWdub3JlIHNlY29uZGFyeSBhbmQgdGVydGlhcnkgZGlmZmVyZW5jZXMuPGJyPgogICogVXNlIHRoaXMgdG8gc2V0IHRoZSBzdHJlbmd0aCBvZiBhIENvbGxhdG9yIG9iamVjdC48YnI+CiAgKiBFeGFtcGxlIG9mIHByaW1hcnkgZGlmZmVyZW5jZSwgImFiYyIgJmx0OyAiYWJkIgogICogCiAgKiBEaWFjcml0aWNhbCBkaWZmZXJlbmNlcyBvbiB0aGUgc2FtZSBiYXNlIGxldHRlciByZXByZXNlbnQgYSBzZWNvbmRhcnkKICAqIGRpZmZlcmVuY2UuIFNldCBjb21wYXJpc29uIGxldmVsIHRvIFNFQ09OREFSWSB0byBpZ25vcmUgdGVydGlhcnkKICAqIGRpZmZlcmVuY2VzLiBVc2UgdGhpcyB0byBzZXQgdGhlIHN0cmVuZ3RoIG9mIGEgQ29sbGF0b3Igb2JqZWN0Ljxicj4KICAqIEV4YW1wbGUgb2Ygc2Vjb25kYXJ5IGRpZmZlcmVuY2UsICLkIiA+PiAiYSIuCiAgKgogICogVXBwZXJjYXNlIGFuZCBsb3dlcmNhc2UgdmVyc2lvbnMgb2YgdGhlIHNhbWUgY2hhcmFjdGVyIHJlcHJlc2VudHMgYQogICogdGVydGlhcnkgZGlmZmVyZW5jZS4gIFNldCBjb21wYXJpc29uIGxldmVsIHRvIFRFUlRJQVJZIHRvIGluY2x1ZGUgYWxsIAogICogY29tcGFyaXNvbiBkaWZmZXJlbmNlcy4gVXNlIHRoaXMgdG8gc2V0IHRoZSBzdHJlbmd0aCBvZiBhIENvbGxhdG9yCiAgKiBvYmplY3QuPGJyPgogICogRXhhbXBsZSBvZiB0ZXJ0aWFyeSBkaWZmZXJlbmNlLCAiYWJjIiAmbHQ7Jmx0OyZsdDsgIkFCQyIuCiAgKgogICogVHdvIGNoYXJhY3RlcnMgYXJlIGNvbnNpZGVyZWQgImlkZW50aWNhbCIgd2hlbiB0aGV5IGhhdmUgdGhlIHNhbWUgdW5pY29kZSAKICAqIHNwZWxsaW5ncy48YnI+CiAgKiBGb3IgZXhhbXBsZSwgIuQiID09ICLkIi4KICAqCiAgKiBVQ29sbGF0aW9uU3RyZW5ndGggaXMgYWxzbyB1c2VkIHRvIGRldGVybWluZSB0aGUgc3RyZW5ndGggb2Ygc29ydCBrZXlzIAogICogZ2VuZXJhdGVkIGZyb20gQ29sbGF0b3Igb2JqZWN0cy4KICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgZW51bSBFQ29sbGF0aW9uU3RyZW5ndGggCiAgewogICAgUFJJTUFSWSAgICA9IDAsCiAgICBTRUNPTkRBUlkgID0gMSwgCiAgICBURVJUSUFSWSAgID0gMiwKICAgIFFVQVRFUk5BUlkgPSAzLAogICAgSURFTlRJQ0FMICA9IDE1CiAgfTsKICAKICAvKioKICAqIExFU1MgaXMgcmV0dXJuZWQgaWYgc291cmNlIHN0cmluZyBpcyBjb21wYXJlZCB0byBiZSBsZXNzIHRoYW4gdGFyZ2V0CiAgKiBzdHJpbmcgaW4gdGhlIGNvbXBhcmUoKSBtZXRob2QuCiAgKiBFUVVBTCBpcyByZXR1cm5lZCBpZiBzb3VyY2Ugc3RyaW5nIGlzIGNvbXBhcmVkIHRvIGJlIGVxdWFsIHRvIHRhcmdldAogICogc3RyaW5nIGluIHRoZSBjb21wYXJlKCkgbWV0aG9kLgogICogR1JFQVRFUiBpcyByZXR1cm5lZCBpZiBzb3VyY2Ugc3RyaW5nIGlzIGNvbXBhcmVkIHRvIGJlIGdyZWF0ZXIgdGhhbgogICogdGFyZ2V0IHN0cmluZyBpbiB0aGUgY29tcGFyZSgpIG1ldGhvZC4KICAqIEBzZWUgQ29sbGF0b3IjY29tcGFyZQogICogQGRlcHJlY2F0ZWQgSUNVIDIuNi4gVXNlIEMgZW51bSBVQ29sbGF0aW9uUmVzdWx0IGRlZmluZWQgaW4gdWNvbC5oCiAgKi8KICBlbnVtIEVDb21wYXJpc29uUmVzdWx0IAogIHsKICAgIExFU1MgPSAtMSwKICAgIEVRVUFMID0gMCwKICAgIEdSRUFURVIgPSAxCiAgfTsKICAKICAvLyBDb2xsYXRvciBwdWJsaWMgZGVzdHJ1Y3RvciAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogIAogIC8qKgogICogRGVzdHJ1Y3RvcgogICogQHN0YWJsZSBJQ1UgMi4wCiAgKi8KICB2aXJ0dWFsIH5Db2xsYXRvcigpOwoKICAvLyBDb2xsYXRvciBwdWJsaWMgbWV0aG9kcyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKICAvKioKICAqIFJldHVybnMgdHJ1ZSBpZiAib3RoZXIiIGlzIHRoZSBzYW1lIGFzICJ0aGlzIgogICogQHBhcmFtIG90aGVyIENvbGxhdG9yIG9iamVjdCB0byBiZSBjb21wYXJlZAogICogQHJldHVybiB0cnVlIGlmIG90aGVyIGlzIHRoZSBzYW1lIGFzIHRoaXMuCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIHZpcnR1YWwgVUJvb2wgb3BlcmF0b3I9PShjb25zdCBDb2xsYXRvciYgb3RoZXIpIGNvbnN0OwoKICAvKioKICAqIFJldHVybnMgdHJ1ZSBpZiAib3RoZXIiIGlzIG5vdCB0aGUgc2FtZSBhcyAidGhpcyIuCiAgKiBAcGFyYW0gb3RoZXIgQ29sbGF0b3Igb2JqZWN0IHRvIGJlIGNvbXBhcmVkCiAgKiBAcmV0dXJuIHRydWUgaWYgb3RoZXIgaXMgbm90IHRoZSBzYW1lIGFzIHRoaXMuCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIHZpcnR1YWwgVUJvb2wgb3BlcmF0b3IhPShjb25zdCBDb2xsYXRvciYgb3RoZXIpIGNvbnN0OwoKICAvKioKICAqIE1ha2VzIGEgc2hhbGxvdyBjb3B5IG9mIHRoZSBjdXJyZW50IG9iamVjdC4KICAqIEByZXR1cm4gYSBjb3B5IG9mIHRoaXMgb2JqZWN0CiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIHZpcnR1YWwgQ29sbGF0b3IqIGNsb25lKHZvaWQpIGNvbnN0ID0gMDsKCiAgLyoqCiAgKiBDcmVhdGVzIHRoZSBDb2xsYXRvciBvYmplY3QgZm9yIHRoZSBjdXJyZW50IGRlZmF1bHQgbG9jYWxlLgogICogVGhlIGRlZmF1bHQgbG9jYWxlIGlzIGRldGVybWluZWQgYnkgTG9jYWxlOjpnZXREZWZhdWx0LgogICogVGhlIFVFcnJvckNvZGUmIGVyciBwYXJhbWV0ZXIgaXMgdXNlZCB0byByZXR1cm4gc3RhdHVzIGluZm9ybWF0aW9uIHRvIHRoZSB1c2VyLgogICogVG8gY2hlY2sgd2hldGhlciB0aGUgY29uc3RydWN0aW9uIHN1Y2NlZWRlZCBvciBub3QsIHlvdSBzaG91bGQgY2hlY2sgdGhlIAogICogdmFsdWUgb2YgVV9TVUNDRVNTKGVycikuICBJZiB5b3Ugd2lzaCBtb3JlIGRldGFpbGVkIGluZm9ybWF0aW9uLCB5b3UgY2FuIAogICogY2hlY2sgZm9yIGluZm9ybWF0aW9uYWwgZXJyb3IgcmVzdWx0cyB3aGljaCBzdGlsbCBpbmRpY2F0ZSBzdWNjZXNzLgogICogVV9VU0lOR19GQUxMQkFDS19FUlJPUiBpbmRpY2F0ZXMgdGhhdCBhIGZhbGwgYmFjayBsb2NhbGUgd2FzIHVzZWQuIEZvcgogICogZXhhbXBsZSwgJ2RlX0NIJyB3YXMgcmVxdWVzdGVkLCBidXQgbm90aGluZyB3YXMgZm91bmQgdGhlcmUsIHNvICdkZScgd2FzCiAgKiB1c2VkLiBVX1VTSU5HX0RFRkFVTFRfRVJST1IgaW5kaWNhdGVzIHRoYXQgdGhlIGRlZmF1bHQgbG9jYWxlIGRhdGEgd2FzCiAgKiB1c2VkOyBuZWl0aGVyIHRoZSByZXF1ZXN0ZWQgbG9jYWxlIG5vciBhbnkgb2YgaXRzIGZhbGwgYmFjayBsb2NhbGVzCiAgKiBjb3VsZCBiZSBmb3VuZC4KICAqIFRoZSBjYWxsZXIgb3ducyB0aGUgcmV0dXJuZWQgb2JqZWN0IGFuZCBpcyByZXNwb25zaWJsZSBmb3IgZGVsZXRpbmcgaXQuCiAgKgogICogQHBhcmFtIGVyciAgICB0aGUgZXJyb3IgY29kZSBzdGF0dXMuCiAgKiBAcmV0dXJuICAgICAgIHRoZSBjb2xsYXRpb24gb2JqZWN0IG9mIHRoZSBkZWZhdWx0IGxvY2FsZS4oZm9yIGV4YW1wbGUsIGVuX1VTKQogICogQHNlZSBMb2NhbGUjZ2V0RGVmYXVsdAogICogQHN0YWJsZSBJQ1UgMi4wCiAgKi8KICBzdGF0aWMgQ29sbGF0b3IqIGNyZWF0ZUluc3RhbmNlKFVFcnJvckNvZGUmICBlcnIpOwoKICAvKioKICAqIEdldHMgdGhlIHRhYmxlLWJhc2VkIGNvbGxhdGlvbiBvYmplY3QgZm9yIHRoZSBkZXNpcmVkIGxvY2FsZS4gVGhlCiAgKiByZXNvdXJjZSBvZiB0aGUgZGVzaXJlZCBsb2NhbGUgd2lsbCBiZSBsb2FkZWQgYnkgUmVzb3VyY2VMb2FkZXIuIAogICogTG9jYWxlOjpFTkdMSVNIIGlzIHRoZSBiYXNlIGNvbGxhdGlvbiB0YWJsZSBhbmQgYWxsIG90aGVyIGxhbmd1YWdlcyBhcmUgCiAgKiBidWlsdCBvbiB0b3Agb2YgaXQgd2l0aCBhZGRpdGlvbmFsIGxhbmd1YWdlLXNwZWNpZmljIG1vZGlmaWNhdGlvbnMuCiAgKiBUaGUgVUVycm9yQ29kZSYgZXJyIHBhcmFtZXRlciBpcyB1c2VkIHRvIHJldHVybiBzdGF0dXMgaW5mb3JtYXRpb24gdG8gdGhlIHVzZXIuCiAgKiBUbyBjaGVjayB3aGV0aGVyIHRoZSBjb25zdHJ1Y3Rpb24gc3VjY2VlZGVkIG9yIG5vdCwgeW91IHNob3VsZCBjaGVjawogICogdGhlIHZhbHVlIG9mIFVfU1VDQ0VTUyhlcnIpLiAgSWYgeW91IHdpc2ggbW9yZSBkZXRhaWxlZCBpbmZvcm1hdGlvbiwgeW91CiAgKiBjYW4gY2hlY2sgZm9yIGluZm9ybWF0aW9uYWwgZXJyb3IgcmVzdWx0cyB3aGljaCBzdGlsbCBpbmRpY2F0ZSBzdWNjZXNzLgogICogVV9VU0lOR19GQUxMQkFDS19FUlJPUiBpbmRpY2F0ZXMgdGhhdCBhIGZhbGwgYmFjayBsb2NhbGUgd2FzIHVzZWQuICBGb3IKICAqIGV4YW1wbGUsICdkZV9DSCcgd2FzIHJlcXVlc3RlZCwgYnV0IG5vdGhpbmcgd2FzIGZvdW5kIHRoZXJlLCBzbyAnZGUnIHdhcwogICogdXNlZC4gIFVfVVNJTkdfREVGQVVMVF9FUlJPUiBpbmRpY2F0ZXMgdGhhdCB0aGUgZGVmYXVsdCBsb2NhbGUgZGF0YSB3YXMKICAqIHVzZWQ7IG5laXRoZXIgdGhlIHJlcXVlc3RlZCBsb2NhbGUgbm9yIGFueSBvZiBpdHMgZmFsbCBiYWNrIGxvY2FsZXMKICAqIGNvdWxkIGJlIGZvdW5kLgogICogVGhlIGNhbGxlciBvd25zIHRoZSByZXR1cm5lZCBvYmplY3QgYW5kIGlzIHJlc3BvbnNpYmxlIGZvciBkZWxldGluZyBpdC4KICAqIEBwYXJhbSBsb2MgICAgVGhlIGxvY2FsZSBJRCBmb3Igd2hpY2ggdG8gb3BlbiBhIGNvbGxhdG9yLgogICogQHBhcmFtIGVyciAgICB0aGUgZXJyb3IgY29kZSBzdGF0dXMuCiAgKiBAcmV0dXJuICAgICAgIHRoZSBjcmVhdGVkIHRhYmxlLWJhc2VkIGNvbGxhdGlvbiBvYmplY3QgYmFzZWQgb24gdGhlIGRlc2lyZWQKICAqICAgICAgICAgICAgICAgbG9jYWxlLgogICogQHNlZSBMb2NhbGUKICAqIEBzZWUgUmVzb3VyY2VMb2FkZXIKICAqIEBzdGFibGUgSUNVIDIuMgogICovCiAgc3RhdGljIENvbGxhdG9yKiBjcmVhdGVJbnN0YW5jZShjb25zdCBMb2NhbGUmIGxvYywgVUVycm9yQ29kZSYgZXJyKTsKCiAgLyoqCiAgICogQ3JlYXRlIGEgQ29sbGF0b3Igd2l0aCBhIHNwZWNpZmljIHZlcnNpb24uCiAgICogVGhpcyBpcyB0aGUgc2FtZSBhcyBjcmVhdGVJbnN0YW5jZShsb2MsIGVycikgZXhjZXB0IHRoYXQgZ2V0VmVyc2lvbigpIG9mCiAgICogdGhlIHJldHVybmVkIG9iamVjdCBpcyBndWFyYW50ZWVkIHRvIGJlIHRoZSBzYW1lIGFzIHRoZSB2ZXJzaW9uCiAgICogcGFyYW1ldGVyLgogICAqIFRoaXMgaXMgZGVzaWduZWQgdG8gYmUgdXNlZCB0byBvcGVuIHRoZSBzYW1lIGNvbGxhdG9yIGZvciBhIGdpdmVuCiAgICogbG9jYWxlIGV2ZW4gd2hlbiBJQ1UgaXMgdXBkYXRlZC4KICAgKiBUaGUgc2FtZSBsb2NhbGUgYW5kIHZlcnNpb24gZ3VhcmFudGVlcyB0aGUgc2FtZSBzb3J0IGtleXMgYW5kCiAgICogY29tcGFyaXNvbiByZXN1bHRzLgogICAqIDxwPgogICAqIE5vdGU6IHRoaXMgQVBJIHdpbGwgYmUgcmVtb3ZlZCBpbiBhIGZ1dHVyZSByZWxlYXNlLiAgVXNlCiAgICogPHR0PmNyZWF0ZUluc3RhbmNlKGNvbnN0IExvY2FsZSYsIFVFcnJvckNvZGUmKSBpbnN0ZWFkLjwvdHQ+PC9wPgogICAqCiAgICogQHBhcmFtIGxvYyBUaGUgbG9jYWxlIElEIGZvciB3aGljaCB0byBvcGVuIGEgY29sbGF0b3IuCiAgICogQHBhcmFtIHZlcnNpb24gVGhlIHJlcXVlc3RlZCBjb2xsYXRvciB2ZXJzaW9uLgogICAqIEBwYXJhbSBlcnIgQSByZWZlcmVuY2UgdG8gYSBVRXJyb3JDb2RlLAogICAqICAgICAgICAgICAgbXVzdCBub3QgaW5kaWNhdGUgYSBmYWlsdXJlIGJlZm9yZSBjYWxsaW5nIHRoaXMgZnVuY3Rpb24uCiAgICogQHJldHVybiBBIHBvaW50ZXIgdG8gYSBDb2xsYXRvciwgb3IgMCBpZiBhbiBlcnJvciBvY2N1cnJlZAogICAqICAgICAgICAgb3IgYSBjb2xsYXRvciB3aXRoIHRoZSByZXF1ZXN0ZWQgdmVyc2lvbiBpcyBub3QgYXZhaWxhYmxlLgogICAqCiAgICogQHNlZSBnZXRWZXJzaW9uCiAgICogQG9ic29sZXRlIElDVSAyLjYKICAgKi8KICBzdGF0aWMgQ29sbGF0b3IgKmNyZWF0ZUluc3RhbmNlKGNvbnN0IExvY2FsZSAmbG9jLCBVVmVyc2lvbkluZm8gdmVyc2lvbiwgVUVycm9yQ29kZSAmZXJyKTsKCiAgLyoqCiAgKiBUaGUgY29tcGFyaXNvbiBmdW5jdGlvbiBjb21wYXJlcyB0aGUgY2hhcmFjdGVyIGRhdGEgc3RvcmVkIGluIHR3bwogICogZGlmZmVyZW50IHN0cmluZ3MuIFJldHVybnMgaW5mb3JtYXRpb24gYWJvdXQgd2hldGhlciBhIHN0cmluZyBpcyBsZXNzIAogICogdGhhbiwgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvIGFub3RoZXIgc3RyaW5nLgogICogQHBhcmFtIHNvdXJjZSB0aGUgc291cmNlIHN0cmluZyB0byBiZSBjb21wYXJlZCB3aXRoLgogICogQHBhcmFtIHRhcmdldCB0aGUgc3RyaW5nIHRoYXQgaXMgdG8gYmUgY29tcGFyZWQgd2l0aCB0aGUgc291cmNlIHN0cmluZy4KICAqIEByZXR1cm4gUmV0dXJucyBhIGJ5dGUgdmFsdWUuIEdSRUFURVIgaWYgc291cmNlIGlzIGdyZWF0ZXIKICAqIHRoYW4gdGFyZ2V0OyBFUVVBTCBpZiBzb3VyY2UgaXMgZXF1YWwgdG8gdGFyZ2V0OyBMRVNTIGlmIHNvdXJjZSBpcyBsZXNzCiAgKiB0aGFuIHRhcmdldAogICogQGRlcHJlY2F0ZWQgSUNVIDIuNiB1c2UgdGhlIG92ZXJsb2FkIHdpdGggVUVycm9yQ29kZSAmCiAgKiovCiAgdmlydHVhbCBFQ29tcGFyaXNvblJlc3VsdCBjb21wYXJlKGNvbnN0IFVuaWNvZGVTdHJpbmcmIHNvdXJjZSwgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFVuaWNvZGVTdHJpbmcmIHRhcmdldCkgY29uc3Q7CgogIC8qKgogICogVGhlIGNvbXBhcmlzb24gZnVuY3Rpb24gY29tcGFyZXMgdGhlIGNoYXJhY3RlciBkYXRhIHN0b3JlZCBpbiB0d28KICAqIGRpZmZlcmVudCBzdHJpbmdzLiBSZXR1cm5zIGluZm9ybWF0aW9uIGFib3V0IHdoZXRoZXIgYSBzdHJpbmcgaXMgbGVzcyAKICAqIHRoYW4sIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byBhbm90aGVyIHN0cmluZy4KICAqIEBwYXJhbSBzb3VyY2UgdGhlIHNvdXJjZSBzdHJpbmcgdG8gYmUgY29tcGFyZWQgd2l0aC4KICAqIEBwYXJhbSB0YXJnZXQgdGhlIHN0cmluZyB0aGF0IGlzIHRvIGJlIGNvbXBhcmVkIHdpdGggdGhlIHNvdXJjZSBzdHJpbmcuCiAgKiBAcGFyYW0gc3RhdHVzIHBvc3NpYmxlIGVycm9yIGNvZGUKICAqIEByZXR1cm4gUmV0dXJucyBhbiBlbnVtIHZhbHVlLiBVQ09MX0dSRUFURVIgaWYgc291cmNlIGlzIGdyZWF0ZXIKICAqIHRoYW4gdGFyZ2V0OyBVQ09MX0VRVUFMIGlmIHNvdXJjZSBpcyBlcXVhbCB0byB0YXJnZXQ7IFVDT0xfTEVTUyBpZiBzb3VyY2UgaXMgbGVzcwogICogdGhhbiB0YXJnZXQKICAqIEBkcmFmdCBJQ1UgMi42CiAgKiovCiAgdmlydHVhbCBVQ29sbGF0aW9uUmVzdWx0IGNvbXBhcmUoY29uc3QgVW5pY29kZVN0cmluZyYgc291cmNlLCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgVW5pY29kZVN0cmluZyYgdGFyZ2V0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVRXJyb3JDb2RlICZzdGF0dXMpIGNvbnN0ID0gMDsKCiAgLyoqCiAgKiBEb2VzIHRoZSBzYW1lIHRoaW5nIGFzIGNvbXBhcmUgYnV0IGxpbWl0cyB0aGUgY29tcGFyaXNvbiB0byBhIHNwZWNpZmllZCAKICAqIGxlbmd0aAogICogQHBhcmFtIHNvdXJjZSB0aGUgc291cmNlIHN0cmluZyB0byBiZSBjb21wYXJlZCB3aXRoLgogICogQHBhcmFtIHRhcmdldCB0aGUgc3RyaW5nIHRoYXQgaXMgdG8gYmUgY29tcGFyZWQgd2l0aCB0aGUgc291cmNlIHN0cmluZy4KICAqIEBwYXJhbSBsZW5ndGggdGhlIGxlbmd0aCB0aGUgY29tcGFyaXNvbiBpcyBsaW1pdGVkIHRvCiAgKiBAcmV0dXJuIFJldHVybnMgYSBieXRlIHZhbHVlLiBHUkVBVEVSIGlmIHNvdXJjZSAodXAgdG8gdGhlIHNwZWNpZmllZCAKICAqICAgICAgICAgbGVuZ3RoKSBpcyBncmVhdGVyIHRoYW4gdGFyZ2V0OyBFUVVBTCBpZiBzb3VyY2UgKHVwIHRvIHNwZWNpZmllZCAKICAqICAgICAgICAgbGVuZ3RoKSBpcyBlcXVhbCB0byB0YXJnZXQ7IExFU1MgaWYgc291cmNlICh1cCB0byB0aGUgc3BlY2lmaWVkIAogICogICAgICAgICBsZW5ndGgpIGlzIGxlc3MgIHRoYW4gdGFyZ2V0LiAgIAogICogQGRlcHJlY2F0ZWQgSUNVIDIuNiB1c2UgdGhlIG92ZXJsb2FkIHdpdGggVUVycm9yQ29kZSAmCiAgKi8KICB2aXJ0dWFsIEVDb21wYXJpc29uUmVzdWx0IGNvbXBhcmUoY29uc3QgVW5pY29kZVN0cmluZyYgc291cmNlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBVbmljb2RlU3RyaW5nJiB0YXJnZXQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludDMyX3QgbGVuZ3RoKSBjb25zdDsKICAgIAogIC8qKgogICogRG9lcyB0aGUgc2FtZSB0aGluZyBhcyBjb21wYXJlIGJ1dCBsaW1pdHMgdGhlIGNvbXBhcmlzb24gdG8gYSBzcGVjaWZpZWQgCiAgKiBsZW5ndGgKICAqIEBwYXJhbSBzb3VyY2UgdGhlIHNvdXJjZSBzdHJpbmcgdG8gYmUgY29tcGFyZWQgd2l0aC4KICAqIEBwYXJhbSB0YXJnZXQgdGhlIHN0cmluZyB0aGF0IGlzIHRvIGJlIGNvbXBhcmVkIHdpdGggdGhlIHNvdXJjZSBzdHJpbmcuCiAgKiBAcGFyYW0gbGVuZ3RoIHRoZSBsZW5ndGggdGhlIGNvbXBhcmlzb24gaXMgbGltaXRlZCB0bwogICogQHBhcmFtIHN0YXR1cyBwb3NzaWJsZSBlcnJvciBjb2RlCiAgKiBAcmV0dXJuIFJldHVybnMgYW4gZW51bSB2YWx1ZS4gVUNPTF9HUkVBVEVSIGlmIHNvdXJjZSAodXAgdG8gdGhlIHNwZWNpZmllZCAKICAqICAgICAgICAgbGVuZ3RoKSBpcyBncmVhdGVyIHRoYW4gdGFyZ2V0OyBVQ09MX0VRVUFMIGlmIHNvdXJjZSAodXAgdG8gc3BlY2lmaWVkIAogICogICAgICAgICBsZW5ndGgpIGlzIGVxdWFsIHRvIHRhcmdldDsgVUNPTF9MRVNTIGlmIHNvdXJjZSAodXAgdG8gdGhlIHNwZWNpZmllZCAKICAqICAgICAgICAgbGVuZ3RoKSBpcyBsZXNzICB0aGFuIHRhcmdldC4gICAKICAqIEBkcmFmdCBJQ1UgMi42CiAgKi8KICB2aXJ0dWFsIFVDb2xsYXRpb25SZXN1bHQgY29tcGFyZShjb25zdCBVbmljb2RlU3RyaW5nJiBzb3VyY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFVuaWNvZGVTdHJpbmcmIHRhcmdldCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50MzJfdCBsZW5ndGgsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVFcnJvckNvZGUgJnN0YXR1cykgY29uc3QgPSAwOwoKICAvKioKICAqIFRoZSBjb21wYXJpc29uIGZ1bmN0aW9uIGNvbXBhcmVzIHRoZSBjaGFyYWN0ZXIgZGF0YSBzdG9yZWQgaW4gdHdvCiAgKiBkaWZmZXJlbnQgc3RyaW5nIGFycmF5cy4gUmV0dXJucyBpbmZvcm1hdGlvbiBhYm91dCB3aGV0aGVyIGEgc3RyaW5nIGFycmF5IAogICogaXMgbGVzcyB0aGFuLCBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gYW5vdGhlciBzdHJpbmcgYXJyYXkuCiAgKiBAcGFyYW0gc291cmNlIHRoZSBzb3VyY2Ugc3RyaW5nIGFycmF5IHRvIGJlIGNvbXBhcmVkIHdpdGguCiAgKiBAcGFyYW0gc291cmNlTGVuZ3RoIHRoZSBsZW5ndGggb2YgdGhlIHNvdXJjZSBzdHJpbmcgYXJyYXkuICBJZiB0aGlzIHZhbHVlCiAgKiAgICAgICAgaXMgZXF1YWwgdG8gLTEsIHRoZSBzdHJpbmcgYXJyYXkgaXMgbnVsbC10ZXJtaW5hdGVkLgogICogQHBhcmFtIHRhcmdldCB0aGUgc3RyaW5nIHRoYXQgaXMgdG8gYmUgY29tcGFyZWQgd2l0aCB0aGUgc291cmNlIHN0cmluZy4KICAqIEBwYXJhbSB0YXJnZXRMZW5ndGggdGhlIGxlbmd0aCBvZiB0aGUgdGFyZ2V0IHN0cmluZyBhcnJheS4gIElmIHRoaXMgdmFsdWUKICAqICAgICAgICBpcyBlcXVhbCB0byAtMSwgdGhlIHN0cmluZyBhcnJheSBpcyBudWxsLXRlcm1pbmF0ZWQuCiAgKiBAcmV0dXJuIFJldHVybnMgYSBieXRlIHZhbHVlLiBHUkVBVEVSIGlmIHNvdXJjZSBpcyBncmVhdGVyIHRoYW4gdGFyZ2V0OyAKICAqICAgICAgICAgRVFVQUwgaWYgc291cmNlIGlzIGVxdWFsIHRvIHRhcmdldDsgTEVTUyBpZiBzb3VyY2UgaXMgbGVzcyB0aGFuIAogICogICAgICAgICB0YXJnZXQKICAqIEBkZXByZWNhdGVkIElDVSAyLjYgdXNlIHRoZSBvdmVybG9hZCB3aXRoIFVFcnJvckNvZGUgJgogICovCiAgdmlydHVhbCBFQ29tcGFyaXNvblJlc3VsdCBjb21wYXJlKGNvbnN0IFVDaGFyKiBzb3VyY2UsIGludDMyX3Qgc291cmNlTGVuZ3RoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBVQ2hhciogdGFyZ2V0LCBpbnQzMl90IHRhcmdldExlbmd0aCkgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0OwoKICAvKioKICAqIFRoZSBjb21wYXJpc29uIGZ1bmN0aW9uIGNvbXBhcmVzIHRoZSBjaGFyYWN0ZXIgZGF0YSBzdG9yZWQgaW4gdHdvCiAgKiBkaWZmZXJlbnQgc3RyaW5nIGFycmF5cy4gUmV0dXJucyBpbmZvcm1hdGlvbiBhYm91dCB3aGV0aGVyIGEgc3RyaW5nIGFycmF5IAogICogaXMgbGVzcyB0aGFuLCBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gYW5vdGhlciBzdHJpbmcgYXJyYXkuCiAgKiBAcGFyYW0gc291cmNlIHRoZSBzb3VyY2Ugc3RyaW5nIGFycmF5IHRvIGJlIGNvbXBhcmVkIHdpdGguCiAgKiBAcGFyYW0gc291cmNlTGVuZ3RoIHRoZSBsZW5ndGggb2YgdGhlIHNvdXJjZSBzdHJpbmcgYXJyYXkuICBJZiB0aGlzIHZhbHVlCiAgKiAgICAgICAgaXMgZXF1YWwgdG8gLTEsIHRoZSBzdHJpbmcgYXJyYXkgaXMgbnVsbC10ZXJtaW5hdGVkLgogICogQHBhcmFtIHRhcmdldCB0aGUgc3RyaW5nIHRoYXQgaXMgdG8gYmUgY29tcGFyZWQgd2l0aCB0aGUgc291cmNlIHN0cmluZy4KICAqIEBwYXJhbSB0YXJnZXRMZW5ndGggdGhlIGxlbmd0aCBvZiB0aGUgdGFyZ2V0IHN0cmluZyBhcnJheS4gIElmIHRoaXMgdmFsdWUKICAqICAgICAgICBpcyBlcXVhbCB0byAtMSwgdGhlIHN0cmluZyBhcnJheSBpcyBudWxsLXRlcm1pbmF0ZWQuCiAgKiBAcGFyYW0gc3RhdHVzIHBvc3NpYmxlIGVycm9yIGNvZGUKICAqIEByZXR1cm4gUmV0dXJucyBhbiBlbnVtIHZhbHVlLiBVQ09MX0dSRUFURVIgaWYgc291cmNlIGlzIGdyZWF0ZXIKICAqIHRoYW4gdGFyZ2V0OyBVQ09MX0VRVUFMIGlmIHNvdXJjZSBpcyBlcXVhbCB0byB0YXJnZXQ7IFVDT0xfTEVTUyBpZiBzb3VyY2UgaXMgbGVzcwogICogdGhhbiB0YXJnZXQKICAqIEBkcmFmdCBJQ1UgMi42CiAgKi8KICB2aXJ0dWFsIFVDb2xsYXRpb25SZXN1bHQgY29tcGFyZShjb25zdCBVQ2hhciogc291cmNlLCBpbnQzMl90IHNvdXJjZUxlbmd0aCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgVUNoYXIqIHRhcmdldCwgaW50MzJfdCB0YXJnZXRMZW5ndGgsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVFcnJvckNvZGUgJnN0YXR1cykgY29uc3QgPSAwOwogIC8qKiAKICAqIFRyYW5zZm9ybXMgdGhlIHN0cmluZyBpbnRvIGEgc2VyaWVzIG9mIGNoYXJhY3RlcnMgdGhhdCBjYW4gYmUgY29tcGFyZWQKICAqIHdpdGggQ29sbGF0aW9uS2V5Ojpjb21wYXJlVG8uIEl0IGlzIG5vdCBwb3NzaWJsZSB0byByZXN0b3JlIHRoZSBvcmlnaW5hbAogICogc3RyaW5nIGZyb20gdGhlIGNoYXJzIGluIHRoZSBzb3J0IGtleS4gIFRoZSBnZW5lcmF0ZWQgc29ydCBrZXkgaGFuZGxlcyAKICAqIG9ubHkgYSBsaW1pdGVkIG51bWJlciBvZiBpZ25vcmFibGUgY2hhcmFjdGVycy4KICAqIDxwPlVzZSBDb2xsYXRpb25LZXk6OmVxdWFscyBvciBDb2xsYXRpb25LZXk6OmNvbXBhcmUgdG8gY29tcGFyZSB0aGUKICAqIGdlbmVyYXRlZCBzb3J0IGtleXMuCiAgKiBJZiB0aGUgc291cmNlIHN0cmluZyBpcyBudWxsLCBhIG51bGwgY29sbGF0aW9uIGtleSB3aWxsIGJlIHJldHVybmVkLgogICogQHBhcmFtIHNvdXJjZSB0aGUgc291cmNlIHN0cmluZyB0byBiZSB0cmFuc2Zvcm1lZCBpbnRvIGEgc29ydCBrZXkuCiAgKiBAcGFyYW0ga2V5IHRoZSBjb2xsYXRpb24ga2V5IHRvIGJlIGZpbGxlZCBpbgogICogQHBhcmFtIHN0YXR1cyB0aGUgZXJyb3IgY29kZSBzdGF0dXMuCiAgKiBAcmV0dXJuIHRoZSBjb2xsYXRpb24ga2V5IG9mIHRoZSBzdHJpbmcgYmFzZWQgb24gdGhlIGNvbGxhdGlvbiBydWxlcy4KICAqIEBzZWUgQ29sbGF0aW9uS2V5I2NvbXBhcmUKICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgdmlydHVhbCBDb2xsYXRpb25LZXkmIGdldENvbGxhdGlvbktleShjb25zdCBVbmljb2RlU3RyaW5nJiAgc291cmNlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ29sbGF0aW9uS2V5JiBrZXksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVRXJyb3JDb2RlJiBzdGF0dXMpIGNvbnN0ID0gMDsKCiAgLyoqIAogICogVHJhbnNmb3JtcyB0aGUgc3RyaW5nIGludG8gYSBzZXJpZXMgb2YgY2hhcmFjdGVycyB0aGF0IGNhbiBiZSBjb21wYXJlZAogICogd2l0aCBDb2xsYXRpb25LZXk6OmNvbXBhcmVUby4gSXQgaXMgbm90IHBvc3NpYmxlIHRvIHJlc3RvcmUgdGhlIG9yaWdpbmFsCiAgKiBzdHJpbmcgZnJvbSB0aGUgY2hhcnMgaW4gdGhlIHNvcnQga2V5LiAgVGhlIGdlbmVyYXRlZCBzb3J0IGtleSBoYW5kbGVzIAogICogb25seSBhIGxpbWl0ZWQgbnVtYmVyIG9mIGlnbm9yYWJsZSBjaGFyYWN0ZXJzLgogICogPHA+VXNlIENvbGxhdGlvbktleTo6ZXF1YWxzIG9yIENvbGxhdGlvbktleTo6Y29tcGFyZSB0byBjb21wYXJlIHRoZQogICogZ2VuZXJhdGVkIHNvcnQga2V5cy4KICAqIDxwPklmIHRoZSBzb3VyY2Ugc3RyaW5nIGlzIG51bGwsIGEgbnVsbCBjb2xsYXRpb24ga2V5IHdpbGwgYmUgcmV0dXJuZWQuCiAgKiBAcGFyYW0gc291cmNlIHRoZSBzb3VyY2Ugc3RyaW5nIHRvIGJlIHRyYW5zZm9ybWVkIGludG8gYSBzb3J0IGtleS4KICAqIEBwYXJhbSBzb3VyY2VMZW5ndGggbGVuZ3RoIG9mIHRoZSBjb2xsYXRpb24ga2V5CiAgKiBAcGFyYW0ga2V5IHRoZSBjb2xsYXRpb24ga2V5IHRvIGJlIGZpbGxlZCBpbgogICogQHBhcmFtIHN0YXR1cyB0aGUgZXJyb3IgY29kZSBzdGF0dXMuCiAgKiBAcmV0dXJuIHRoZSBjb2xsYXRpb24ga2V5IG9mIHRoZSBzdHJpbmcgYmFzZWQgb24gdGhlIGNvbGxhdGlvbiBydWxlcy4KICAqIEBzZWUgQ29sbGF0aW9uS2V5I2NvbXBhcmUKICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgdmlydHVhbCBDb2xsYXRpb25LZXkmIGdldENvbGxhdGlvbktleShjb25zdCBVQ2hhcipzb3VyY2UsIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50MzJfdCBzb3VyY2VMZW5ndGgsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDb2xsYXRpb25LZXkmIGtleSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVFcnJvckNvZGUmIHN0YXR1cykgY29uc3QgPSAwOwogIC8qKgogICogR2VuZXJhdGVzIHRoZSBoYXNoIGNvZGUgZm9yIHRoZSBjb2xsYXRpb24gb2JqZWN0CiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIHZpcnR1YWwgaW50MzJfdCBoYXNoQ29kZSh2b2lkKSBjb25zdCA9IDA7CgogIC8qKgogICogR2V0cyB0aGUgbG9jYWxlIG9mIHRoZSBDb2xsYXRvcgogICoKICAqIEBwYXJhbSB0eXBlIGNhbiBiZSBlaXRoZXIgcmVxdWVzdGVkLCB2YWxpZCBvciBhY3R1YWwgbG9jYWxlLiBGb3IgbW9yZQogICogICAgICAgICAgICAgaW5mb3JtYXRpb24gc2VlIHRoZSBkZWZpbml0aW9uIG9mIFVMb2NEYXRhTG9jYWxlVHlwZSBpbgogICogICAgICAgICAgICAgdWxvYy5oCiAgKiBAcGFyYW0gc3RhdHVzIHRoZSBlcnJvciBjb2RlIHN0YXR1cy4KICAqIEByZXR1cm4gbG9jYWxlIHdoZXJlIHRoZSBjb2xsYXRpb24gZGF0YSBsaXZlcy4gSWYgdGhlIGNvbGxhdG9yCiAgKiAgICAgICAgIHdhcyBpbnN0YW50aWF0ZWQgZnJvbSBydWxlcywgbG9jYWxlIGlzIGVtcHR5LgogICogQHN0YWJsZSBJQ1UgMi4xCiAgKi8KICB2aXJ0dWFsIGNvbnN0IExvY2FsZSBnZXRMb2NhbGUoVUxvY0RhdGFMb2NhbGVUeXBlIHR5cGUsIFVFcnJvckNvZGUmIHN0YXR1cykgY29uc3QgPSAwOwoKICAvKioKICAqIENvbnZlbmllbmNlIG1ldGhvZCBmb3IgY29tcGFyaW5nIHR3byBzdHJpbmdzIGJhc2VkIG9uIHRoZSBjb2xsYXRpb24gcnVsZXMuCiAgKiBAcGFyYW0gc291cmNlIHRoZSBzb3VyY2Ugc3RyaW5nIHRvIGJlIGNvbXBhcmVkIHdpdGguCiAgKiBAcGFyYW0gdGFyZ2V0IHRoZSB0YXJnZXQgc3RyaW5nIHRvIGJlIGNvbXBhcmVkIHdpdGguCiAgKiBAcmV0dXJuIHRydWUgaWYgdGhlIGZpcnN0IHN0cmluZyBpcyBncmVhdGVyIHRoYW4gdGhlIHNlY29uZCBvbmUsCiAgKiAgICAgICAgIGFjY29yZGluZyB0byB0aGUgY29sbGF0aW9uIHJ1bGVzLiBmYWxzZSwgb3RoZXJ3aXNlLgogICogQHNlZSBDb2xsYXRvciNjb21wYXJlCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIFVCb29sIGdyZWF0ZXIoY29uc3QgVW5pY29kZVN0cmluZyYgc291cmNlLCBjb25zdCBVbmljb2RlU3RyaW5nJiB0YXJnZXQpIAogICAgICAgICAgICAgICAgY29uc3Q7CgogIC8qKgogICogQ29udmVuaWVuY2UgbWV0aG9kIGZvciBjb21wYXJpbmcgdHdvIHN0cmluZ3MgYmFzZWQgb24gdGhlIGNvbGxhdGlvbiBydWxlcy4KICAqIEBwYXJhbSBzb3VyY2UgdGhlIHNvdXJjZSBzdHJpbmcgdG8gYmUgY29tcGFyZWQgd2l0aC4KICAqIEBwYXJhbSB0YXJnZXQgdGhlIHRhcmdldCBzdHJpbmcgdG8gYmUgY29tcGFyZWQgd2l0aC4KICAqIEByZXR1cm4gdHJ1ZSBpZiB0aGUgZmlyc3Qgc3RyaW5nIGlzIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byB0aGUgc2Vjb25kIAogICogICAgICAgICBvbmUsIGFjY29yZGluZyB0byB0aGUgY29sbGF0aW9uIHJ1bGVzLiBmYWxzZSwgb3RoZXJ3aXNlLgogICogQHNlZSBDb2xsYXRvciNjb21wYXJlCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIFVCb29sIGdyZWF0ZXJPckVxdWFsKGNvbnN0IFVuaWNvZGVTdHJpbmcmIHNvdXJjZSwgCiAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgVW5pY29kZVN0cmluZyYgdGFyZ2V0KSBjb25zdDsKICAvKioKICAqIENvbnZlbmllbmNlIG1ldGhvZCBmb3IgY29tcGFyaW5nIHR3byBzdHJpbmdzIGJhc2VkIG9uIHRoZSBjb2xsYXRpb24gcnVsZXMuCiAgKiBAcGFyYW0gc291cmNlIHRoZSBzb3VyY2Ugc3RyaW5nIHRvIGJlIGNvbXBhcmVkIHdpdGguCiAgKiBAcGFyYW0gdGFyZ2V0IHRoZSB0YXJnZXQgc3RyaW5nIHRvIGJlIGNvbXBhcmVkIHdpdGguCiAgKiBAcmV0dXJuIHRydWUgaWYgdGhlIHN0cmluZ3MgYXJlIGVxdWFsIGFjY29yZGluZyB0byB0aGUgY29sbGF0aW9uIHJ1bGVzLiAgCiAgKiAgICAgICAgIGZhbHNlLCBvdGhlcndpc2UuCiAgKiBAc2VlIENvbGxhdG9yI2NvbXBhcmUKICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgVUJvb2wgZXF1YWxzKGNvbnN0IFVuaWNvZGVTdHJpbmcmIHNvdXJjZSwgY29uc3QgVW5pY29kZVN0cmluZyYgdGFyZ2V0KSBjb25zdDsKICAgICAgICAKICAvKioKICAqIERldGVybWluZXMgdGhlIG1pbmltdW0gc3RyZW5ndGggdGhhdCB3aWxsIGJlIHVzZSBpbiBjb21wYXJpc29uIG9yCiAgKiB0cmFuc2Zvcm1hdGlvbi4KICAqIDxwPkUuZy4gd2l0aCBzdHJlbmd0aCA9PSBTRUNPTkRBUlksIHRoZSB0ZXJ0aWFyeSBkaWZmZXJlbmNlIGlzIGlnbm9yZWQKICAqIDxwPkUuZy4gd2l0aCBzdHJlbmd0aCA9PSBQUklNQVJZLCB0aGUgc2Vjb25kYXJ5IGFuZCB0ZXJ0aWFyeSBkaWZmZXJlbmNlCiAgKiBhcmUgaWdub3JlZC4KICAqIEByZXR1cm4gdGhlIGN1cnJlbnQgY29tcGFyaXNvbiBsZXZlbC4KICAqIEBzZWUgQ29sbGF0b3Ijc2V0U3RyZW5ndGgKICAqIEBkZXByZWNhdGVkIElDVSAyLjYgVXNlIGdldEF0dHJpYnV0ZShVQ09MX1NUUkVOR1RILi4uKSBpbnN0ZWFkCiAgKi8KICB2aXJ0dWFsIEVDb2xsYXRpb25TdHJlbmd0aCBnZXRTdHJlbmd0aCh2b2lkKSBjb25zdCA9IDA7CiAgCiAgLyoqCiAgKiBTZXRzIHRoZSBtaW5pbXVtIHN0cmVuZ3RoIHRvIGJlIHVzZWQgaW4gY29tcGFyaXNvbiBvciB0cmFuc2Zvcm1hdGlvbi4KICAqIDxwPkV4YW1wbGUgb2YgdXNlOgogICogPHByZT4KICAqICBcY29kZQogICogIFVFcnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogICogIENvbGxhdG9yKm15Q29sbGF0aW9uID0gQ29sbGF0b3I6OmNyZWF0ZUluc3RhbmNlKExvY2FsZTo6VVMsIAogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdGF0dXMpOwogICogIGlmIChVX0ZBSUxVUkUoc3RhdHVzKSkgcmV0dXJuOwogICogIG15Q29sbGF0aW9uLT5zZXRTdHJlbmd0aChDb2xsYXRvcjo6UFJJTUFSWSk7CiAgKiAgLy8gcmVzdWx0IHdpbGwgYmUgImFiYyIgPT0gIkFCQyIKICAqICAvLyB0ZXJ0aWFyeSBkaWZmZXJlbmNlcyB3aWxsIGJlIGlnbm9yZWQKICAqICBDb2xsYXRvcjo6Q29tcGFyaXNvblJlc3VsdCByZXN1bHQgPSBteUNvbGxhdGlvbi0+Y29tcGFyZSgiYWJjIiwgCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIkFCQyIpOwogICogXGVuZGNvZGUgCiAgKiA8L3ByZT4KICAqIEBzZWUgQ29sbGF0b3IjZ2V0U3RyZW5ndGgKICAqIEBwYXJhbSBuZXdTdHJlbmd0aCB0aGUgbmV3IGNvbXBhcmlzb24gbGV2ZWwuCiAgKiBAZGVwcmVjYXRlZCBJQ1UgMi42IFVzZSBzZXRBdHRyaWJ1dGUoVUNPTF9TVFJFTkdUSC4uLikgaW5zdGVhZAogICovCiAgdmlydHVhbCB2b2lkIHNldFN0cmVuZ3RoKEVDb2xsYXRpb25TdHJlbmd0aCBuZXdTdHJlbmd0aCkgPSAwOwoKICAvKioKICAqIEdldCBuYW1lIG9mIHRoZSBvYmplY3QgZm9yIHRoZSBkZXNpcmVkIExvY2FsZSwgaW4gdGhlIGRlc2lyZWQgbGFuZ2F1Z2UKICAqIEBwYXJhbSBvYmplY3RMb2NhbGUgbXVzdCBiZSBmcm9tIGdldEF2YWlsYWJsZUxvY2FsZXMKICAqIEBwYXJhbSBkaXNwbGF5TG9jYWxlIHNwZWNpZmllcyB0aGUgZGVzaXJlZCBsb2NhbGUgZm9yIG91dHB1dAogICogQHBhcmFtIG5hbWUgdGhlIGZpbGwtaW4gcGFyYW1ldGVyIG9mIHRoZSByZXR1cm4gdmFsdWUKICAqIEByZXR1cm4gZGlzcGxheS1hYmxlIG5hbWUgb2YgdGhlIG9iamVjdCBmb3IgdGhlIG9iamVjdCBsb2NhbGUgaW4gdGhlCiAgKiAgICAgICAgIGRlc2lyZWQgbGFuZ3VhZ2UKICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgc3RhdGljIFVuaWNvZGVTdHJpbmcmIGdldERpc3BsYXlOYW1lKGNvbnN0IExvY2FsZSYgb2JqZWN0TG9jYWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBMb2NhbGUmIGRpc3BsYXlMb2NhbGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmIG5hbWUpOwogIC8qKgogICogR2V0IG5hbWUgb2YgdGhlIG9iamVjdCBmb3IgdGhlIGRlc2lyZWQgTG9jYWxlLCBpbiB0aGUgbGFuZ2F1Z2Ugb2YgdGhlCiAgKiBkZWZhdWx0IGxvY2FsZS4KICAqIEBwYXJhbSBvYmplY3RMb2NhbGUgbXVzdCBiZSBmcm9tIGdldEF2YWlsYWJsZUxvY2FsZXMKICAqIEBwYXJhbSBuYW1lIHRoZSBmaWxsLWluIHBhcmFtZXRlciBvZiB0aGUgcmV0dXJuIHZhbHVlCiAgKiBAcmV0dXJuIG5hbWUgb2YgdGhlIG9iamVjdCBmb3IgdGhlIGRlc2lyZWQgbG9jYWxlIGluIHRoZSBkZWZhdWx0IGxhbmd1YWdlCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIHN0YXRpYyBVbmljb2RlU3RyaW5nJiBnZXREaXNwbGF5TmFtZShjb25zdCBMb2NhbGUmIG9iamVjdExvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgbmFtZSk7CgogIC8qKgogICogR2V0IHRoZSBzZXQgb2YgTG9jYWxlcyBmb3Igd2hpY2ggQ29sbGF0aW9ucyBhcmUgaW5zdGFsbGVkLgogICoKICAqIDxwPk5vdGUgdGhpcyBkb2VzIG5vdCBpbmNsdWRlIGxvY2FsZXMgc3VwcG9ydGVkIGJ5IHJlZ2lzdGVyZWQgY29sbGF0b3JzLgogICogSWYgY29sbGF0b3JzIG1pZ2h0IGhhdmUgYmVlbiByZWdpc3RlcmVkLCB1c2UgdGhlIG92ZXJsb2FkIG9mIGdldEF2YWlsYWJsZUxvY2FsZXMKICAqIHRoYXQgcmV0dXJucyBhIFN0cmluZ0VudW1lcmF0aW9uLjwvcD4KICAqCiAgKiBAcGFyYW0gY291bnQgdGhlIG91dHB1dCBwYXJhbWV0ZXIgb2YgbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBsb2NhbGUgbGlzdAogICogQHJldHVybiB0aGUgbGlzdCBvZiBhdmFpbGFibGUgbG9jYWxlcyBmb3Igd2hpY2ggY29sbGF0aW9ucyBhcmUgaW5zdGFsbGVkCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIHN0YXRpYyBjb25zdCBMb2NhbGUqIGdldEF2YWlsYWJsZUxvY2FsZXMoaW50MzJfdCYgY291bnQpOwoKICAvKioKICAgKiBSZXR1cm4gYSBTdHJpbmdFbnVtZXJhdGlvbiBvdmVyIHRoZSBsb2NhbGVzIGF2YWlsYWJsZSBhdCB0aGUgdGltZSBvZiB0aGUgY2FsbCwgCiAgICogaW5jbHVkaW5nIHJlZ2lzdGVyZWQgbG9jYWxlcy4gIElmIGEgc2V2ZXJlIGVycm9yIG9jY3VycyAoc3VjaCBhcyBvdXQgb2YgbWVtb3J5CiAgICogY29uZGl0aW9uKSB0aGlzIHdpbGwgcmV0dXJuIG51bGwuIElmIHRoZXJlIGlzIG5vIGxvY2FsZSBkYXRhLCBhbiBlbXB0eSBlbnVtZXJhdGlvbgogICAqIHdpbGwgYmUgcmV0dXJuZWQuCiAgICogQHJldHVybiBhIFN0cmluZ0VudW1lcmF0aW9uIG92ZXIgdGhlIGxvY2FsZXMgYXZhaWxhYmxlIGF0IHRoZSB0aW1lIG9mIHRoZSBjYWxsCiAgICogQGRyYWZ0IElDVSAyLjYKICAgKi8KICBzdGF0aWMgU3RyaW5nRW51bWVyYXRpb24qIGdldEF2YWlsYWJsZUxvY2FsZXModm9pZCk7CgogIC8qKgogICAqIFJlZ2lzdGVyIGEgbmV3IENvbGxhdG9yLiAgVGhlIGNvbGxhdG9yIHdpbGwgYmUgYWRvcHRlZC4KICAgKiBAcGFyYW0gdG9BZG9wdCB0aGUgQ29sbGF0b3IgaW5zdGFuY2UgdG8gYmUgYWRvcHRlZAogICAqIEBwYXJhbSBsb2NhbGUgdGhlIGxvY2FsZSB3aXRoIHdoaWNoIHRoZSBjb2xsYXRvciB3aWxsIGJlIGFzc29jaWF0ZWQKICAgKiBAcGFyYW0gc3RhdHVzIHRoZSBpbi9vdXQgc3RhdHVzIGNvZGUsIG5vIHNwZWNpYWwgbWVhbmluZ3MgYXJlIGFzc2lnbmVkCiAgICogQHJldHVybiBhIHJlZ2lzdHJ5IGtleSB0aGF0IGNhbiBiZSB1c2VkIHRvIHVucmVnaXN0ZXIgdGhpcyBjb2xsYXRvcgogICAqIEBkcmFmdCBJQ1UgMi42CiAgICovCiAgc3RhdGljIFVSZWdpc3RyeUtleSByZWdpc3Rlckluc3RhbmNlKENvbGxhdG9yKiB0b0Fkb3B0LCBjb25zdCBMb2NhbGUmIGxvY2FsZSwgVUVycm9yQ29kZSYgc3RhdHVzKTsKCiAgLyoqCiAgICogUmVnaXN0ZXIgYSBuZXcgQ29sbGF0b3JGYWN0b3J5LiAgVGhlIGZhY3Rvcnkgd2lsbCBiZSBhZG9wdGVkLgogICAqIEBwYXJhbSB0b0Fkb3B0IHRoZSBDb2xsYXRvckZhY3RvcnkgaW5zdGFuY2UgdG8gYmUgYWRvcHRlZAogICAqIEBwYXJhbSBzdGF0dXMgdGhlIGluL291dCBzdGF0dXMgY29kZSwgbm8gc3BlY2lhbCBtZWFuaW5ncyBhcmUgYXNzaWduZWQKICAgKiBAcmV0dXJuIGEgcmVnaXN0cnkga2V5IHRoYXQgY2FuIGJlIHVzZWQgdG8gdW5yZWdpc3RlciB0aGlzIGNvbGxhdG9yCiAgICogQGRyYWZ0IElDVSAyLjYKICAgKi8KICBzdGF0aWMgVVJlZ2lzdHJ5S2V5IHJlZ2lzdGVyRmFjdG9yeShDb2xsYXRvckZhY3RvcnkqIHRvQWRvcHQsIFVFcnJvckNvZGUmIHN0YXR1cyk7CgogIC8qKgogICAqIFVucmVnaXN0ZXIgYSBwcmV2aW91c2x5LXJlZ2lzdGVyZWQgQ29sbGF0b3Igb3IgQ29sbGF0b3JGYWN0b3J5CiAgICogdXNpbmcgdGhlIGtleSByZXR1cm5lZCBmcm9tIHRoZSByZWdpc3RlciBjYWxsLiAgS2V5IGJlY29tZXMKICAgKiBpbnZhbGlkIGFmdGVyIGEgc3VjY2Vzc2Z1bCBjYWxsIGFuZCBzaG91bGQgbm90IGJlIHVzZWQgYWdhaW4uCiAgICogVGhlIG9iamVjdCBjb3JyZXNwb25kaW5nIHRvIHRoZSBrZXkgd2lsbCBiZSBkZWxldGVkLgogICAqIEBwYXJhbSBrZXkgdGhlIHJlZ2lzdHJ5IGtleSByZXR1cm5lZCBieSBhIHByZXZpb3VzIGNhbGwgdG8gcmVnaXN0ZXJJbnN0YW5jZQogICAqIEBwYXJhbSBzdGF0dXMgdGhlIGluL291dCBzdGF0dXMgY29kZSwgbm8gc3BlY2lhbCBtZWFuaW5ncyBhcmUgYXNzaWduZWQKICAgKiBAcmV0dXJuIFRSVUUgaWYgdGhlIGNvbGxhdG9yIGZvciB0aGUga2V5IHdhcyBzdWNjZXNzZnVsbHkgdW5yZWdpc3RlcmVkCiAgICogQGRyYWZ0IElDVSAyLjYgCiAgICovCiAgc3RhdGljIFVCb29sIHVucmVnaXN0ZXIoVVJlZ2lzdHJ5S2V5IGtleSwgVUVycm9yQ29kZSYgc3RhdHVzKTsKCiAgLyoqCiAgKiBHZXRzIHRoZSB2ZXJzaW9uIGluZm9ybWF0aW9uIGZvciBhIENvbGxhdG9yLiAKICAqIEBwYXJhbSBpbmZvIHRoZSB2ZXJzaW9uICMgaW5mb3JtYXRpb24sIHRoZSByZXN1bHQgd2lsbCBiZSBmaWxsZWQgaW4KICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgdmlydHVhbCB2b2lkIGdldFZlcnNpb24oVVZlcnNpb25JbmZvIGluZm8pIGNvbnN0ID0gMDsKCiAgLyoqCiAgKiBSZXR1cm5zIGEgdW5pcXVlIGNsYXNzIElEIFBPTFlNT1JQSElDQUxMWS4gUHVyZSB2aXJ0dWFsIG1ldGhvZC4KICAqIFRoaXMgbWV0aG9kIGlzIHRvIGltcGxlbWVudCBhIHNpbXBsZSB2ZXJzaW9uIG9mIFJUVEksIHNpbmNlIG5vdCBhbGwgQysrIAogICogY29tcGlsZXJzIHN1cHBvcnQgZ2VudWluZSBSVFRJLiBQb2x5bW9ycGhpYyBvcGVyYXRvcj09KCkgYW5kIGNsb25lKCkgCiAgKiBtZXRob2RzIGNhbGwgdGhpcyBtZXRob2QuCiAgKiBDb25jcmV0ZSBzdWJjbGFzc2VzIG9mIEZvcm1hdCBtdXN0IGltcGxlbWVudCBnZXREeW5hbWljQ2xhc3NJRCgpIGFuZCBhbHNvIAogICogYSBzdGF0aWMgbWV0aG9kIGFuZCBkYXRhIG1lbWJlcjoKICAqICAgc3RhdGljIFVDbGFzc0lEIGdldFN0YXRpY0NsYXNzSUQoKSAKICAqICAgeyAKICAqICAgICAgcmV0dXJuIChVQ2xhc3NJRCkmZmdDbGFzc0lEOyAKICAqICAgfQogICogICBzdGF0aWMgY2hhciBmZ0NsYXNzSUQ7CiAgKiBAcmV0dXJuIFRoZSBjbGFzcyBJRCBmb3IgdGhpcyBvYmplY3QuIEFsbCBvYmplY3RzIG9mIGEgZ2l2ZW4gY2xhc3MgaGF2ZSAKICAqICAgICAgICAgdGhlIHNhbWUgY2xhc3MgSUQuICBPYmplY3RzIG9mIG90aGVyIGNsYXNzZXMgaGF2ZSBkaWZmZXJlbnQgY2xhc3MgCiAgKiAgICAgICAgIElEcy4KICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgdmlydHVhbCBVQ2xhc3NJRCBnZXREeW5hbWljQ2xhc3NJRCh2b2lkKSBjb25zdCA9IDA7CgogIC8qKgogICogVW5pdmVyc2FsIGF0dHJpYnV0ZSBzZXR0ZXIKICAqIEBwYXJhbSBhdHRyIGF0dHJpYnV0ZSB0eXBlIAogICogQHBhcmFtIHZhbHVlIGF0dHJpYnV0ZSB2YWx1ZQogICogQHBhcmFtIHN0YXR1cyB0byBpbmRpY2F0ZSB3aGV0aGVyIHRoZSBvcGVyYXRpb24gd2VudCBvbiBzbW9vdGhseSBvciAKICAqICAgICAgICB0aGVyZSB3ZXJlIGVycm9ycwogICogQHN0YWJsZSBJQ1UgMi4yCiAgKi8KICB2aXJ0dWFsIHZvaWQgc2V0QXR0cmlidXRlKFVDb2xBdHRyaWJ1dGUgYXR0ciwgVUNvbEF0dHJpYnV0ZVZhbHVlIHZhbHVlLCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVFcnJvckNvZGUgJnN0YXR1cykgPSAwOwoKICAvKioKICAqIFVuaXZlcnNhbCBhdHRyaWJ1dGUgZ2V0dGVyCiAgKiBAcGFyYW0gYXR0ciBhdHRyaWJ1dGUgdHlwZQogICogQHBhcmFtIHN0YXR1cyB0byBpbmRpY2F0ZSB3aGV0aGVyIHRoZSBvcGVyYXRpb24gd2VudCBvbiBzbW9vdGhseSBvciAKICAqICAgICAgICB0aGVyZSB3ZXJlIGVycm9ycwogICogQHJldHVybiBhdHRyaWJ1dGUgdmFsdWUKICAqIEBzdGFibGUgSUNVIDIuMgogICovCiAgdmlydHVhbCBVQ29sQXR0cmlidXRlVmFsdWUgZ2V0QXR0cmlidXRlKFVDb2xBdHRyaWJ1dGUgYXR0ciwgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVFcnJvckNvZGUgJnN0YXR1cykgPSAwOwoKICAvKiogCiAgICogU2V0cyB0aGUgdmFyaWFibGUgdG9wIHRvIGEgY29sbGF0aW9uIGVsZW1lbnQgdmFsdWUgb2YgYSBzdHJpbmcgc3VwcGxpZWQuIAogICAqIEBwYXJhbSB2YXJUb3Agb25lIG9yIG1vcmUgKGlmIGNvbnRyYWN0aW9uKSBVQ2hhcnMgdG8gd2hpY2ggdGhlIHZhcmlhYmxlIHRvcCBzaG91bGQgYmUgc2V0CiAgICogQHBhcmFtIGxlbiBsZW5ndGggb2YgdmFyaWFibGUgdG9wIHN0cmluZy4gSWYgLTEgaXQgaXMgY29uc2lkZXJlZCB0byBiZSB6ZXJvIHRlcm1pbmF0ZWQuCiAgICogQHBhcmFtIHN0YXR1cyBlcnJvciBjb2RlLiBJZiBlcnJvciBjb2RlIGlzIHNldCwgdGhlIHJldHVybiB2YWx1ZSBpcyB1bmRlZmluZWQuIEVycm9ycyBzZXQgYnkgdGhpcyBmdW5jdGlvbiBhcmU6IDxicj4KICAgKiAgICBVX0NFX05PVF9GT1VORF9FUlJPUiBpZiBtb3JlIHRoYW4gb25lIGNoYXJhY3RlciB3YXMgcGFzc2VkIGFuZCB0aGVyZSBpcyBubyBzdWNoIGEgY29udHJhY3Rpb248YnI+CiAgICogICAgVV9QUklNQVJZX1RPT19MT05HX0VSUk9SIGlmIHRoZSBwcmltYXJ5IGZvciB0aGUgdmFyaWFibGUgdG9wIGhhcyBtb3JlIHRoYW4gdHdvIGJ5dGVzCiAgICogQHJldHVybiBhIDMyIGJpdCB2YWx1ZSBjb250YWluaW5nIHRoZSB2YWx1ZSBvZiB0aGUgdmFyaWFibGUgdG9wIGluIHVwcGVyIDE2IGJpdHMuIExvd2VyIDE2IGJpdHMgYXJlIHVuZGVmaW5lZAogICAqIEBzdGFibGUgSUNVIDIuMAogICAqLwogIHZpcnR1YWwgdWludDMyX3Qgc2V0VmFyaWFibGVUb3AoY29uc3QgVUNoYXIgKnZhclRvcCwgaW50MzJfdCBsZW4sIFVFcnJvckNvZGUgJnN0YXR1cykgPSAwOwoKICAvKiogCiAgICogU2V0cyB0aGUgdmFyaWFibGUgdG9wIHRvIGEgY29sbGF0aW9uIGVsZW1lbnQgdmFsdWUgb2YgYSBzdHJpbmcgc3VwcGxpZWQuIAogICAqIEBwYXJhbSB2YXJUb3AgYW4gVW5pY29kZVN0cmluZyBzaXplIDEgb3IgbW9yZSAoaWYgY29udHJhY3Rpb24pIG9mIFVDaGFycyB0byB3aGljaCB0aGUgdmFyaWFibGUgdG9wIHNob3VsZCBiZSBzZXQKICAgKiBAcGFyYW0gc3RhdHVzIGVycm9yIGNvZGUuIElmIGVycm9yIGNvZGUgaXMgc2V0LCB0aGUgcmV0dXJuIHZhbHVlIGlzIHVuZGVmaW5lZC4gRXJyb3JzIHNldCBieSB0aGlzIGZ1bmN0aW9uIGFyZTogPGJyPgogICAqICAgIFVfQ0VfTk9UX0ZPVU5EX0VSUk9SIGlmIG1vcmUgdGhhbiBvbmUgY2hhcmFjdGVyIHdhcyBwYXNzZWQgYW5kIHRoZXJlIGlzIG5vIHN1Y2ggYSBjb250cmFjdGlvbjxicj4KICAgKiAgICBVX1BSSU1BUllfVE9PX0xPTkdfRVJST1IgaWYgdGhlIHByaW1hcnkgZm9yIHRoZSB2YXJpYWJsZSB0b3AgaGFzIG1vcmUgdGhhbiB0d28gYnl0ZXMKICAgKiBAcmV0dXJuIGEgMzIgYml0IHZhbHVlIGNvbnRhaW5pbmcgdGhlIHZhbHVlIG9mIHRoZSB2YXJpYWJsZSB0b3AgaW4gdXBwZXIgMTYgYml0cy4gTG93ZXIgMTYgYml0cyBhcmUgdW5kZWZpbmVkCiAgICogQHN0YWJsZSBJQ1UgMi4wCiAgICovCiAgdmlydHVhbCB1aW50MzJfdCBzZXRWYXJpYWJsZVRvcChjb25zdCBVbmljb2RlU3RyaW5nIHZhclRvcCwgVUVycm9yQ29kZSAmc3RhdHVzKSA9IDA7CgogIC8qKiAKICAgKiBTZXRzIHRoZSB2YXJpYWJsZSB0b3AgdG8gYSBjb2xsYXRpb24gZWxlbWVudCB2YWx1ZSBzdXBwbGllZC4gVmFyaWFibGUgdG9wIGlzIHNldCB0byB0aGUgdXBwZXIgMTYgYml0cy4gCiAgICogTG93ZXIgMTYgYml0cyBhcmUgaWdub3JlZC4KICAgKiBAcGFyYW0gdmFyVG9wIENFIHZhbHVlLCBhcyByZXR1cm5lZCBieSBzZXRWYXJpYWJsZVRvcCBvciB1Y29sKWdldFZhcmlhYmxlVG9wCiAgICogQHBhcmFtIHN0YXR1cyBlcnJvciBjb2RlIChub3QgY2hhbmdlZCBieSBmdW5jdGlvbikKICAgKiBAc3RhYmxlIElDVSAyLjAKICAgKi8KICB2aXJ0dWFsIHZvaWQgc2V0VmFyaWFibGVUb3AoY29uc3QgdWludDMyX3QgdmFyVG9wLCBVRXJyb3JDb2RlICZzdGF0dXMpID0gMDsKCiAgLyoqIAogICAqIEdldHMgdGhlIHZhcmlhYmxlIHRvcCB2YWx1ZSBvZiBhIENvbGxhdG9yLiAKICAgKiBMb3dlciAxNiBiaXRzIGFyZSB1bmRlZmluZWQgYW5kIHNob3VsZCBiZSBpZ25vcmVkLgogICAqIEBwYXJhbSBzdGF0dXMgZXJyb3IgY29kZSAobm90IGNoYW5nZWQgYnkgZnVuY3Rpb24pLiBJZiBlcnJvciBjb2RlIGlzIHNldCwgdGhlIHJldHVybiB2YWx1ZSBpcyB1bmRlZmluZWQuCiAgICogQHN0YWJsZSBJQ1UgMi4wCiAgICovCiAgdmlydHVhbCB1aW50MzJfdCBnZXRWYXJpYWJsZVRvcChVRXJyb3JDb2RlICZzdGF0dXMpIGNvbnN0ID0gMDsKCiAgLyoqCiAgICogR2V0IGFuIFVuaWNvZGVTZXQgdGhhdCBjb250YWlucyBhbGwgdGhlIGNoYXJhY3RlcnMgYW5kIHNlcXVlbmNlcyAKICAgKiB0YWlsb3JlZCBpbiB0aGlzIGNvbGxhdG9yLgogICAqIEBwYXJhbSBzdGF0dXMgICAgICBlcnJvciBjb2RlIG9mIHRoZSBvcGVyYXRpb24KICAgKiBAcmV0dXJuIGEgcG9pbnRlciB0byBhIFVuaWNvZGVTZXQgb2JqZWN0IGNvbnRhaW5pbmcgYWxsIHRoZSAKICAgKiAgICAgICAgIGNvZGUgcG9pbnRzIGFuZCBzZXF1ZW5jZXMgdGhhdCBtYXkgc29ydCBkaWZmZXJlbnRseSB0aGFuCiAgICogICAgICAgICBpbiB0aGUgVUNBLiBUaGUgb2JqZWN0IG11c3QgYmUgZGlzcG9zZWQgb2YgYnkgdXNpbmcgZGVsZXRlCiAgICogQGRyYWZ0IElDVSAyLjQKICAgKi8KICB2aXJ0dWFsIFVuaWNvZGVTZXQgKmdldFRhaWxvcmVkU2V0KFVFcnJvckNvZGUgJnN0YXR1cykgY29uc3Q7CgoKICAvKioKICAqIFRocmVhZCBzYWZlIGNsb25pbmcgb3BlcmF0aW9uCiAgKiBAcmV0dXJuIHBvaW50ZXIgdG8gdGhlIG5ldyBjbG9uZSwgdXNlciBzaG91bGQgcmVtb3ZlIGl0LgogICogQHN0YWJsZSBJQ1UgMi4yCiAgKi8KICB2aXJ0dWFsIENvbGxhdG9yKiBzYWZlQ2xvbmUodm9pZCkgPSAwOwoKICAvKioKICAqIEdldCB0aGUgc29ydCBrZXkgYXMgYW4gYXJyYXkgb2YgYnl0ZXMgZnJvbSBhbiBVbmljb2RlU3RyaW5nLgogICogU29ydCBrZXkgYnl0ZSBhcnJheXMgYXJlIHplcm8tdGVybWluYXRlZCBhbmQgY2FuIGJlIGNvbXBhcmVkIHVzaW5nIAogICogc3RyY21wKCkuCiAgKiBAcGFyYW0gc291cmNlIHN0cmluZyB0byBiZSBwcm9jZXNzZWQuCiAgKiBAcGFyYW0gcmVzdWx0IGJ1ZmZlciB0byBzdG9yZSByZXN1bHQgaW4uIElmIE5VTEwsIG51bWJlciBvZiBieXRlcyBuZWVkZWQgCiAgKiAgICAgICAgd2lsbCBiZSByZXR1cm5lZC4KICAqIEBwYXJhbSByZXN1bHRMZW5ndGggbGVuZ3RoIG9mIHRoZSByZXN1bHQgYnVmZmVyLiBJZiBpZiBub3QgZW5vdWdoIHRoZSAKICAqICAgICAgICBidWZmZXIgd2lsbCBiZSBmaWxsZWQgdG8gY2FwYWNpdHkuIAogICogQHJldHVybiBOdW1iZXIgb2YgYnl0ZXMgbmVlZGVkIGZvciBzdG9yaW5nIHRoZSBzb3J0IGtleQogICogQHN0YWJsZSBJQ1UgMi4yCiAgKi8KICB2aXJ0dWFsIGludDMyX3QgZ2V0U29ydEtleShjb25zdCBVbmljb2RlU3RyaW5nJiBzb3VyY2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50OF90KiByZXN1bHQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQzMl90IHJlc3VsdExlbmd0aCkgY29uc3QgPSAwOwoKICAvKioKICAqIEdldCB0aGUgc29ydCBrZXkgYXMgYW4gYXJyYXkgb2YgYnl0ZXMgZnJvbSBhbiBVQ2hhciBidWZmZXIuCiAgKiBTb3J0IGtleSBieXRlIGFycmF5cyBhcmUgemVyby10ZXJtaW5hdGVkIGFuZCBjYW4gYmUgY29tcGFyZWQgdXNpbmcgCiAgKiBzdHJjbXAoKS4KICAqIEBwYXJhbSBzb3VyY2Ugc3RyaW5nIHRvIGJlIHByb2Nlc3NlZC4KICAqIEBwYXJhbSBzb3VyY2VMZW5ndGggbGVuZ3RoIG9mIHN0cmluZyB0byBiZSBwcm9jZXNzZWQuIAogICogICAgICAgIElmIC0xLCB0aGUgc3RyaW5nIGlzIDAgdGVybWluYXRlZCBhbmQgbGVuZ3RoIHdpbGwgYmUgZGVjaWRlZCBieSB0aGUgCiAgKiAgICAgICAgZnVuY3Rpb24uCiAgKiBAcGFyYW0gcmVzdWx0IGJ1ZmZlciB0byBzdG9yZSByZXN1bHQgaW4uIElmIE5VTEwsIG51bWJlciBvZiBieXRlcyBuZWVkZWQgCiAgKiAgICAgICAgd2lsbCBiZSByZXR1cm5lZC4KICAqIEBwYXJhbSByZXN1bHRMZW5ndGggbGVuZ3RoIG9mIHRoZSByZXN1bHQgYnVmZmVyLiBJZiBpZiBub3QgZW5vdWdoIHRoZSAKICAqICAgICAgICBidWZmZXIgd2lsbCBiZSBmaWxsZWQgdG8gY2FwYWNpdHkuIAogICogQHJldHVybiBOdW1iZXIgb2YgYnl0ZXMgbmVlZGVkIGZvciBzdG9yaW5nIHRoZSBzb3J0IGtleQogICogQHN0YWJsZSBJQ1UgMi4yCiAgKi8KICB2aXJ0dWFsIGludDMyX3QgZ2V0U29ydEtleShjb25zdCBVQ2hhcipzb3VyY2UsIGludDMyX3Qgc291cmNlTGVuZ3RoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQ4X3QqcmVzdWx0LCBpbnQzMl90IHJlc3VsdExlbmd0aCkgY29uc3QgPSAwOwoKICAgIC8qKgogICAgICogUHJvZHVjZSBhIGJvdW5kIGZvciBhIGdpdmVuIHNvcnRrZXkgYW5kIGEgbnVtYmVyIG9mIGxldmVscy4KICAgICAqIFJldHVybiB2YWx1ZSBpcyBhbHdheXMgdGhlIG51bWJlciBvZiBieXRlcyBuZWVkZWQsIHJlZ2FyZGxlc3Mgb2YgCiAgICAgKiB3aGV0aGVyIHRoZSByZXN1bHQgYnVmZmVyIHdhcyBiaWcgZW5vdWdoIG9yIGV2ZW4gdmFsaWQuPGJyPgogICAgICogUmVzdWx0aW5nIGJvdW5kcyBjYW4gYmUgdXNlZCB0byBwcm9kdWNlIGEgcmFuZ2Ugb2Ygc3RyaW5ncyB0aGF0IGFyZQogICAgICogYmV0d2VlbiB1cHBlciBhbmQgbG93ZXIgYm91bmRzLiBGb3IgZXhhbXBsZSwgaWYgYm91bmRzIGFyZSBwcm9kdWNlZAogICAgICogZm9yIGEgc29ydGtleSBvZiBzdHJpbmcgInNtaXRoIiwgc3RyaW5ncyBiZXR3ZWVuIHVwcGVyIGFuZCBsb3dlciAKICAgICAqIGJvdW5kcyB3aXRoIG9uZSBsZXZlbCB3b3VsZCBpbmNsdWRlICJTbWl0aCIsICJTTUlUSCIsICJzTWlUaCIuPGJyPgogICAgICogVGhlcmUgYXJlIHR3byB1cHBlciBib3VuZHMgdGhhdCBjYW4gYmUgcHJvZHVjZWQuIElmIFVDT0xfQk9VTkRfVVBQRVIKICAgICAqIGlzIHByb2R1Y2VkLCBzdHJpbmdzIG1hdGNoZWQgd291bGQgYmUgYXMgYWJvdmUuIEhvd2V2ZXIsIGlmIGJvdW5kCiAgICAgKiBwcm9kdWNlZCB1c2luZyBVQ09MX0JPVU5EX1VQUEVSX0xPTkcgaXMgdXNlZCwgdGhlIGFib3ZlIGV4YW1wbGUgd2lsbAogICAgICogYWxzbyBtYXRjaCAiU21pdGhzb25pYW4iIGFuZCBzaW1pbGFyLjxicj4KICAgICAqIEZvciBtb3JlIG9uIHVzYWdlLCBzZWUgZXhhbXBsZSBpbiBjaW50bHRzdC9jYXBpdHN0LmMgaW4gcHJvY2VkdXJlCiAgICAgKiBUZXN0Qm91bmRzLgogICAgICogU29ydCBrZXlzIG1heSBiZSBjb21wYXJlZCB1c2luZyA8VFQ+c3RyY21wPC9UVD4uCiAgICAgKiBAcGFyYW0gc291cmNlIFRoZSBzb3VyY2Ugc29ydGtleS4KICAgICAqIEBwYXJhbSBzb3VyY2VMZW5ndGggVGhlIGxlbmd0aCBvZiBzb3VyY2UsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4gCiAgICAgKiAgICAgICAgICAgICAgICAgICAgIChJZiBhbiB1bm1vZGlmaWVkIHNvcnRrZXkgaXMgcGFzc2VkLCBpdCBpcyBhbHdheXMgbnVsbCAKICAgICAqICAgICAgICAgICAgICAgICAgICAgIHRlcm1pbmF0ZWQpLgogICAgICogQHBhcmFtIGJvdW5kVHlwZSBUeXBlIG9mIGJvdW5kIHJlcXVpcmVkLiBJdCBjYW4gYmUgVUNPTF9CT1VORF9MT1dFUiwgd2hpY2ggCiAgICAgKiAgICAgICAgICAgICAgICAgIHByb2R1Y2VzIGEgbG93ZXIgaW5jbHVzaXZlIGJvdW5kLCBVQ09MX0JPVU5EX1VQUEVSLCB0aGF0IAogICAgICogICAgICAgICAgICAgICAgICBwcm9kdWNlcyB1cHBlciBib3VuZCB0aGF0IG1hdGNoZXMgc3RyaW5ncyBvZiB0aGUgc2FtZSBsZW5ndGggCiAgICAgKiAgICAgICAgICAgICAgICAgIG9yIFVDT0xfQk9VTkRfVVBQRVJfTE9ORyB0aGF0IG1hdGNoZXMgc3RyaW5ncyB0aGF0IGhhdmUgdGhlIAogICAgICogICAgICAgICAgICAgICAgICBzYW1lIHN0YXJ0aW5nIHN1YnN0cmluZyBhcyB0aGUgc291cmNlIHN0cmluZy4KICAgICAqIEBwYXJhbSBub09mTGV2ZWxzICBOdW1iZXIgb2YgbGV2ZWxzIHJlcXVpcmVkIGluIHRoZSByZXN1bHRpbmcgYm91bmQgKGZvciBtb3N0IAogICAgICogICAgICAgICAgICAgICAgICAgIHVzZXMsIHRoZSByZWNvbW1lbmRlZCB2YWx1ZSBpcyAxKS4gU2VlIHVzZXJzIGd1aWRlIGZvciAKICAgICAqICAgICAgICAgICAgICAgICAgICBleHBsYW5hdGlvbiBvbiBudW1iZXIgb2YgbGV2ZWxzIGEgc29ydGtleSBjYW4gaGF2ZS4KICAgICAqIEBwYXJhbSByZXN1bHQgQSBwb2ludGVyIHRvIGEgYnVmZmVyIHRvIHJlY2VpdmUgdGhlIHJlc3VsdGluZyBzb3J0a2V5LgogICAgICogQHBhcmFtIHJlc3VsdExlbmd0aCBUaGUgbWF4aW11bSBzaXplIG9mIHJlc3VsdC4KICAgICAqIEBwYXJhbSBzdGF0dXMgVXNlZCBmb3IgcmV0dXJuaW5nIGVycm9yIGNvZGUgaWYgc29tZXRoaW5nIHdlbnQgd3JvbmcuIElmIHRoZSAKICAgICAqICAgICAgICAgICAgICAgbnVtYmVyIG9mIGxldmVscyByZXF1ZXN0ZWQgaXMgaGlnaGVyIHRoYW4gdGhlIG51bWJlciBvZiBsZXZlbHMKICAgICAqICAgICAgICAgICAgICAgaW4gdGhlIHNvdXJjZSBrZXksIGEgd2FybmluZyAoVV9TT1JUX0tFWV9UT09fU0hPUlRfV0FSTklORykgaXMgCiAgICAgKiAgICAgICAgICAgICAgIGlzc3VlZC4KICAgICAqIEByZXR1cm4gVGhlIHNpemUgbmVlZGVkIHRvIGZ1bGx5IHN0b3JlIHRoZSBib3VuZC4gCiAgICAgKiBAc2VlIHVjb2xfa2V5SGFzaENvZGUKICAgICAqIEBzdGFibGUgSUNVIDIuMQogICAgICovCiAgICBzdGF0aWMgaW50MzJfdCBnZXRCb3VuZChjb25zdCB1aW50OF90ICAgICAgICpzb3VyY2UsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICAgICAgc291cmNlTGVuZ3RoLAogICAgICAgICAgICBVQ29sQm91bmRNb2RlICAgICAgIGJvdW5kVHlwZSwKICAgICAgICAgICAgdWludDMyX3QgICAgICAgICAgICBub09mTGV2ZWxzLAogICAgICAgICAgICB1aW50OF90ICAgICAgICAgICAgICpyZXN1bHQsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICAgICAgcmVzdWx0TGVuZ3RoLAogICAgICAgICAgICBVRXJyb3JDb2RlICAgICAgICAgICZzdGF0dXMpOwoKCnByb3RlY3RlZDoKCiAgLy8gQ29sbGF0b3IgcHJvdGVjdGVkIGNvbnN0cnVjdG9ycyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgogIC8qKgogICogRGVmYXVsdCBjb25zdHJ1Y3Rvci4KICAqIENvbnN0cnVjdG9yIGlzIGRpZmZlcmVudCBmcm9tIHRoZSBvbGQgZGVmYXVsdCBDb2xsYXRvciBjb25zdHJ1Y3Rvci4KICAqIFRoZSB0YXNrIGZvciBkZXRlcm1pbmcgdGhlIGRlZmF1bHQgY29sbGF0aW9uIHN0cmVuZ3RoIGFuZCBub3JtYWxpemF0aW9uIAogICogbW9kZSBpcyBsZWZ0IHRvIHRoZSBjaGlsZCBjbGFzcy4KICAqIEBzdGFibGUgSUNVIDIuMAogICovCiAgQ29sbGF0b3IoKTsKCiAgLyoqCiAgKiBDb25zdHJ1Y3Rvci4KICAqIEVtcHR5IGNvbnN0cnVjdG9yLCBkb2VzIG5vdCBoYW5kbGUgdGhlIGFyZ3VtZW50cy4KICAqIFRoaXMgY29uc3RydWN0b3IgaXMgZG9uZSBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSB3aXRoIDEuNyBhbmQgMS44LgogICogVGhlIHRhc2sgZm9yIGhhbmRsaW5nIHRoZSBhcmd1bWVudCBjb2xsYXRpb24gc3RyZW5ndGggYW5kIG5vcm1hbGl6YXRpb24gCiAgKiBtb2RlIGlzIGxlZnQgdG8gdGhlIGNoaWxkIGNsYXNzLgogICogQHBhcmFtIGNvbGxhdGlvblN0cmVuZ3RoIGNvbGxhdGlvbiBzdHJlbmd0aAogICogQHBhcmFtIGRlY29tcG9zaXRpb25Nb2RlIAogICogQGRlcHJlY2F0ZWQgSUNVIDIuNC4gU3ViY2xhc3NlcyBzaG91bGQgdXNlIHRoZSBkZWZhdWx0IGNvbnN0cnVjdG9yCiAgKiBpbnN0ZWFkIGFuZCBoYW5kbGUgdGhlIHN0cmVuZ3RoIGFuZCBub3JtYWxpemF0aW9uIG1vZGUgdGhlbXNlbHZlcy4KICAqLwogIENvbGxhdG9yKFVDb2xsYXRpb25TdHJlbmd0aCBjb2xsYXRpb25TdHJlbmd0aCwgCiAgICAgICAgICAgVU5vcm1hbGl6YXRpb25Nb2RlIGRlY29tcG9zaXRpb25Nb2RlKTsKICAKICAvKioKICAqIENvcHkgY29uc3RydWN0b3IuCiAgKiBAcGFyYW0gb3RoZXIgQ29sbGF0b3Igb2JqZWN0IHRvIGJlIGNvcGllZCBmcm9tCiAgKiBAc3RhYmxlIElDVSAyLjAKICAqLwogIENvbGxhdG9yKGNvbnN0IENvbGxhdG9yJiBvdGhlcik7CiAgCiAgLy8gQ29sbGF0b3IgcHJvdGVjdGVkIG1ldGhvZHMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCgogLyoqCiAgKiBVc2VkIGludGVybmFsbHkgYnkgcmVnaXN0cmF0b24gdG8gZGVmaW5lIHRoZSByZXF1ZXN0ZWQgYW5kIHZhbGlkIGxvY2FsZXMuCiAgKiBAcGFyYW0gcmVxdWVzdGVkTG9jYWxlIHRoZSByZXF1c3RlZCBsb2NhbGUKICAqIEBwYXJhbSB2YWxpZExvY2FsZSB0aGUgdmFsaWQgbG9jYWxlCiAgKiBAaW50ZXJuYWwKICAqLwogIHZpcnR1YWwgdm9pZCBzZXRMb2NhbGVzKGNvbnN0IExvY2FsZSYgcmVxdWVzdGVkTG9jYWxlLCBjb25zdCBMb2NhbGUmIHZhbGlkTG9jYWxlKTsKCnB1YmxpYzoKICAgLyoqCgkqIHVzZWQgb25seSBieSB1Y29sX29wZW4sIG5vdCBmb3IgcHVibGljIHVzZQoJKiBAaW50ZXJuYWwKCSovCiAgIHN0YXRpYyBVQ29sbGF0b3IqIGNyZWF0ZVVDb2xsYXRvcihjb25zdCBjaGFyKiBsb2MsIFVFcnJvckNvZGUqIHN0YXR1cyk7Cgpwcml2YXRlOgogIC8qKgogICAqIEFzc2lnbm1lbnQgb3BlcmF0b3IuIFByaXZhdGUgZm9yIG5vdy4KICAgKiBAaW50ZXJuYWwKICAgKi8KICBDb2xsYXRvciYgb3BlcmF0b3I9KGNvbnN0IENvbGxhdG9yJiBvdGhlcik7CgogIGZyaWVuZCBjbGFzcyBDRmFjdG9yeTsKICBmcmllbmQgY2xhc3MgU2ltcGxlQ0ZhY3Rvcnk7CiAgZnJpZW5kIGNsYXNzIElDVUNvbGxhdG9yRmFjdG9yeTsKICBmcmllbmQgY2xhc3MgSUNVQ29sbGF0b3JTZXJ2aWNlOwogIHN0YXRpYyBDb2xsYXRvciogbWFrZUluc3RhbmNlKGNvbnN0IExvY2FsZSYgZGVzaXJlZExvY2FsZSwgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVUVycm9yQ29kZSYgc3RhdHVzKTsKCiAgLy8gQ29sbGF0b3IgcHJpdmF0ZSBkYXRhIG1lbWJlcnMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgogIC8qCiAgc3lud2VlIDogcmVtb3ZlZCBhcyBhdHRyaWJ1dGVzIHRvIGJlIGhhbmRsZWQgYnkgY2hpbGQgY2xhc3MKICBVQ29sbGF0aW9uU3RyZW5ndGggIHN0cmVuZ3RoOwogIE5vcm1hbGl6ZXI6OkVNb2RlICBkZWNtcDsKICAqLwogICAgLyogVGhpcyBpcyB1c2VsZXNzIGluZm9ybWF0aW9uICovCi8qICBzdGF0aWMgY29uc3QgVVZlcnNpb25JbmZvIGZWZXJzaW9uOyovCn07CgovKioKICogQSBmYWN0b3J5LCB1c2VkIHdpdGggcmVnaXN0ZXJGYWN0b3J5LCB0aGUgY3JlYXRlcyBtdWx0aXBsZSBjb2xsYXRvcnMgYW5kIHByb3ZpZGVzCiAqIGRpc3BsYXkgbmFtZXMgZm9yIHRoZW0uICBBIGZhY3Rvcnkgc3VwcG9ydHMgc29tZSBudW1iZXIgb2YgbG9jYWxlcy0tIHRoZXNlIGFyZSB0aGUKICogbG9jYWxlcyBmb3Igd2hpY2ggaXQgY2FuIGNyZWF0ZSBjb2xsYXRvcnMuICBUaGUgZmFjdG9yeSBjYW4gYmUgdmlzaWJsZSwgaW4gd2hpY2gKICogY2FzZSB0aGUgc3VwcG9ydGVkIGxvY2FsZXMgd2lsbCBiZSBlbnVtZXJhdGVkIGJ5IGdldEF2YWlsYWJsZUxvY2FsZXMsIG9yIGludmlzaWJsZSwgCiAqIGluIHdoaWNoIHRoZXkgYXJlIG5vdC4gIEludmlzaWJsZSBsb2NhbGVzIGFyZSBzdGlsbCBzdXBwb3J0ZWQsIHRoZXkgYXJlIGp1c3Qgbm90CiAqIGxpc3RlZCBieSBnZXRBdmFpbGFibGVMb2NhbGVzLgogKiA8cD4KICogSWYgc3RhbmRhcmQgbG9jYWxlIGRpc3BsYXkgbmFtZXMgYXJlIHN1ZmZpY2llbnQsIENvbGxhdG9yIGluc3RhbmNlcyBjYW4KICogYmUgcmVnaXN0ZXJlZCB1c2luZyByZWdpc3Rlckluc3RhbmNlIGluc3RlYWQuPC9wPgogKiA8cD4KICogTm90ZTogaWYgdGhlIGNvbGxhdG9ycyBhcmUgdG8gYmUgdXNlZCBmcm9tIEMgQVBJcywgdGhleSBtdXN0IGJlIGluc3RhbmNlcwogKiBvZiBSdWxlQmFzZWRDb2xsYXRvci48L3A+CiAqCiAqIEBkcmFmdCBJQ1UgMi42CiAqLwpjbGFzcyBVX0kxOE5fQVBJIENvbGxhdG9yRmFjdG9yeSA6IHB1YmxpYyBVT2JqZWN0IHsKcHVibGljOgoKICAgIC8qKgogICAgICogUmV0dXJuIHRydWUgaWYgdGhpcyBmYWN0b3J5IGlzIHZpc2libGUuICBEZWZhdWx0IGlzIHRydWUuCiAgICAgKiBJZiBub3QgdmlzaWJsZSwgdGhlIGxvY2FsZXMgc3VwcG9ydGVkIGJ5IHRoaXMgZmFjdG9yeSB3aWxsIG5vdAogICAgICogYmUgbGlzdGVkIGJ5IGdldEF2YWlsYWJsZUxvY2FsZXMuCgkgKiBAcmV0dXJuIHRydWUgaWYgdGhlIGZhY3RvcnkgaXMgdmlzaWJsZS4KICAgICAqLwogICAgdmlydHVhbCBVQm9vbCB2aXNpYmxlKHZvaWQpIGNvbnN0OwoKICAgIC8qKgogICAgICogUmV0dXJuIGEgY29sbGF0b3IgZm9yIHRoZSBwcm92aWRlZCBsb2NhbGUuICBJZiB0aGUgbG9jYWxlCiAgICAgKiBpcyBub3Qgc3VwcG9ydGVkLCByZXR1cm4gTlVMTC4KCSAqIEBwYXJhbSBsb2MgdGhlIGxvY2FsZSBpZGVudGlmeWluZyB0aGUgY29sbGF0b3IgdG8gYmUgY3JlYXRlZC4KCSAqIEByZXR1cm4gYSBuZXcgY29sbGF0b3IgaWYgdGhlIGxvY2FsZSBpcyBzdXBwb3J0ZWQsIG90aGVyd2lzZSBOVUxMLgogICAgICovCiAgICB2aXJ0dWFsIENvbGxhdG9yKiBjcmVhdGVDb2xsYXRvcihjb25zdCBMb2NhbGUmIGxvYykgPSAwOwoKICAgIC8qKgogICAgICogUmV0dXJuIHRoZSBuYW1lIG9mIHRoZSBjb2xsYXRvciBmb3IgdGhlIG9iamVjdExvY2FsZSwgbG9jYWxpemVkIGZvciB0aGUgZGlzcGxheUxvY2FsZS4KICAgICAqIElmIG9iamVjdExvY2FsZSBpcyBub3Qgc3VwcG9ydGVkLCBvciB0aGUgZmFjdG9yeSBpcyBub3QgdmlzaWJsZSwgc2V0IHRoZSByZXN1bHQgc3RyaW5nCiAgICAgKiB0byBib2d1cy4KICAgICAqIEBwYXJhbSBvYmplY3RMb2NhbGUgdGhlIGxvY2FsZSBpZGVudGlmeWluZyB0aGUgY29sbGF0b3IKICAgICAqIEBwYXJhbSBkaXNwbGF5TG9jYWxlIHRoZSBsb2NhbGUgZm9yIHdoaWNoIHRoZSBkaXNwbGF5IG5hbWUgb2YgdGhlIGNvbGxhdG9yIHNob3VsZCBiZSBsb2NhbGl6ZWQKICAgICAqIEBwYXJhbSByZXN1bHQgYW4gb3V0cHV0IHBhcmFtZXRlciBmb3IgdGhlIGRpc3BsYXkgbmFtZSwgc2V0IHRvIGJvZ3VzIGlmIG5vdCBzdXBwb3J0ZWQuCiAgICAgKiBAcmV0dXJuIHRoZSBkaXNwbGF5IG5hbWUKICAgICAqIEBkcmFmdCBJQ1UgMi42CiAgICAgKi8KICAgIHZpcnR1YWwgIFVuaWNvZGVTdHJpbmcmIGdldERpc3BsYXlOYW1lKGNvbnN0IExvY2FsZSYgb2JqZWN0TG9jYWxlLCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IExvY2FsZSYgZGlzcGxheUxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmIHJlc3VsdCk7CiAgICAKICAgIC8qKgogICAgICogUmV0dXJuIGFuIGFycmF5IG9mIGFsbCB0aGUgbG9jYWxlIG5hbWVzIGRpcmVjdGx5IHN1cHBvcnRlZCBieSB0aGlzIGZhY3RvcnkuICAKCSAqIFRoZSBudW1iZXIgb2YgbmFtZXMgaXMgcmV0dXJuZWQgaW4gY291bnQuICBUaGlzIGFycmF5IGlzIG93bmVkIGJ5IHRoZSBmYWN0b3J5LiAgCgkgKiBJdHMgY29udGVudHMgbXVzdCBuZXZlciBjaGFuZ2UuCgkgKiBAcGFyYW0gY291bnQgb3V0cHV0IHBhcmFtZXRlciBmb3IgdGhlIG51bWJlciBvZiBsb2NhbGVzIHN1cHBvcnRlZCBieSB0aGUgZmFjdG9yeQoJICogQHBhcmFtIHN0YXR1cyB0aGUgaW4vb3V0IGVycm9yIGNvZGUKCSAqIEByZXR1cm4gYSBwb2ludGVyIHRvIGFuIGFycmF5IG9mIGNvdW50IFVuaWNvZGVTdHJpbmdzLgogICAgICovCiAgICB2aXJ0dWFsIGNvbnN0IFVuaWNvZGVTdHJpbmcgKiBnZXRTdXBwb3J0ZWRJRHMoaW50MzJfdCAmY291bnQsIFVFcnJvckNvZGUmIHN0YXR1cykgPSAwOwp9OwoKLy8gQ29sbGF0b3IgaW5saW5lIG1ldGhvZHMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCmlubGluZSBVQm9vbCBDb2xsYXRvcjo6b3BlcmF0b3I9PShjb25zdCBDb2xsYXRvciYgb3RoZXIpIGNvbnN0CnsKICByZXR1cm4gKFVCb29sKSh0aGlzID09ICZvdGhlcik7Cn0KCmlubGluZSBVQm9vbCBDb2xsYXRvcjo6b3BlcmF0b3IhPShjb25zdCBDb2xsYXRvciYgb3RoZXIpIGNvbnN0CnsKICByZXR1cm4gKFVCb29sKSEoKnRoaXMgPT0gb3RoZXIpOwp9CgppbmxpbmUgVW5pY29kZVNldCAqQ29sbGF0b3I6OmdldFRhaWxvcmVkU2V0KFVFcnJvckNvZGUgJnN0YXR1cykgY29uc3QKewogIGlmKFVfRkFJTFVSRShzdGF0dXMpKSB7CiAgICByZXR1cm4gTlVMTDsKICB9CiAgLy8gZXZlcnl0aGluZyBjYW4gYmUgY2hhbmdlZAogIHJldHVybiBuZXcgVW5pY29kZVNldCgwLCAweDEwRkZGRik7Cn0KCi8qCnN5bndlZSA6IHJlbW92ZWQgc2luY2UgdGhlcmUncyBubyBhdHRyaWJ1dGUgdG8gYmUgcmV0cmlldmVkIGhlcmUKaW5saW5lIFVDb2xsYXRpb25TdHJlbmd0aCBDb2xsYXRvcjo6Z2V0U3RyZW5ndGgoKSBjb25zdAp7CiAgcmV0dXJuIHN0cmVuZ3RoOwp9CgppbmxpbmUgTm9ybWFsaXplcjo6RU1vZGUgQ29sbGF0b3I6OmdldERlY29tcG9zaXRpb24oKSBjb25zdAp7CiAgcmV0dXJuIGRlY21wOwp9CiovClVfTkFNRVNQQUNFX0VORAoKI2VuZGlmIC8qICNpZiAhVUNPTkZJR19OT19DT0xMQVRJT04gKi8KCiNlbmRpZgo=