PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMCBUcmFuc2l0aW9uYWwvL0VOIj4KPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA2NylodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2FydGljbGVzL3RyZWV2aWV3ZXItY2cvVHJlZVZpZXdlckFydGljbGUuaHRtIC0tPgo8SFRNTD48SEVBRD48VElUTEU+QnVpbGRpbmcgYWRtaW5pc3RyYXRpdmUgYXBwbGljYXRpb25zIGluIEVjbGlwc2U8L1RJVExFPgo8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2RlZmF1bHRfc3R5bGUuY3NzIj4KPE1FVEEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+CjxNRVRBIGNvbnRlbnQ9Ik1TSFRNTCA1LjUwLjQ5MTUuNTAwIiBuYW1lPUdFTkVSQVRPUj48L0hFQUQ+CjxCT0RZIHZMaW5rPSM4MDAwODAgbGluaz0jMDAwMGZmPgo8RElWIGFsaWduPXJpZ2h0PiZuYnNwOyA8Rk9OVCBmYWNlPSJUaW1lcyBOZXcgUm9tYW4sIFRpbWVzLCBzZXJpZiIgCnNpemU9Mj5Db3B5cmlnaHQgJmNvcHk7IDIwMDQgSUJNIENvcnBvcmF0aW9uLjwvRk9OVD4gCjxUQUJMRSBjZWxsU3BhY2luZz0wIGNlbGxQYWRkaW5nPTIgd2lkdGg9IjEwMCUiIGJvcmRlcj0wPgogIDxUQk9EWT4KICA8VFI+CiAgICA8VEQgdkFsaWduPXRvcCBhbGlnbj1sZWZ0IGJnQ29sb3I9IzAwODBjMCBjb2xTcGFuPTI+PEI+PEZPTlQgCiAgICAgIGZhY2U9QXJpYWwsSGVsdmV0aWNhPjxGT05UIGNvbG9yPSNmZmZmZmY+Jm5ic3A7RWNsaXBzZSBDb3JuZXIgCiAgICAgIEFydGljbGU8L0ZPTlQ+PC9GT05UPjwvQj48L1REPjwvVFI+PC9UQk9EWT48L1RBQkxFPjwvRElWPgo8RElWIGFsaWduPWxlZnQ+CjxIMT48SU1HIGhlaWdodD04NiBzcmM9ImltYWdlcy9JZGVhLmpwZyIgd2lkdGg9MTIwPjwvSDE+PC9ESVY+CjxQPiZuYnNwOzwvUD4KPEgxIGFsaWduPWNlbnRlcj5CdWlsZGluZyBhZG1pbmlzdHJhdGl2ZSBhcHBsaWNhdGlvbnMgaW4gRWNsaXBzZTwvSDE+CjxCTE9DS1FVT1RFPjxCPlN1bW1hcnk8L0I+IDxCUj5FY2xpcHNlIGlzIG1vc3QgY29tbW9ubHkgdXNlZCBhcyBhIHBsYXRmb3JtIGZvciB0b29scyB0aGF0IGFsbG93IHRoZSB1c2VyIHRvIGNvbnN0cnVjdCBvciBhc3NlbWJsZSBhbiBlbmQgcHJvZHVjdCBvdXQgb2YgZGV2ZWxvcG1lbnQgcmVzb3VyY2VzLiBJdCBpcyBsZXNzIHVzdWFsIHRvIHVzZSBFY2xpcHNlIGFzIGFuIGFkbWluaXN0cmF0aXZlIHRvb2wgZm9yIG1vbml0b3JpbmcgZXhpc3RpbmcgcnVudGltZSBzeXN0ZW1zIG9yIGFwcGxpY2F0aW9ucy4gVGhpcyBhcnRpY2xlIHdpbGwgZGVzY3JpYmUgc29tZSBvZiB0aGUgaXNzdWVzIHRoYXQgYXJpc2UgaW4gdGhpcyBjYXNlIGFuZCBpbGx1c3RyYXRlICAgIHBvc3NpYmxlIHNvbHV0aW9ucy4KSXQgIHdpbGwgc2hvdyB5b3UgY2FuIGJ1aWxkIGFuIEVjbGlwc2UgcGVyc3BlY3RpdmUgZGVkaWNhdGVkIHRvIHRoZSBtb25pdG9yaW5nIHRhc2suIFJ1bm5pbmcgcHJvY2Vzc2VzIGFyZSBzaG93biBpbiBhIGRlZGljYXRlZCB2aWV3IHdoaWNoIGFsd2F5cyByZWZsZWN0cyB0aGVpciBjdXJyZW50IHN0YXRlLiBZb3UgY2FuIHN0YXJ0L3N0b3AgdGhlIHByb2Nlc3MsIG1hbmFnZSBjb25uZWN0aW9ucywgaW52b2tlIG9wZXJhdGlvbnMgdGhhdCB0aGUgc2VydmVyIGV4cG9zZXMsIGV4YW1pbmUgc2VydmVyIG91dHB1dCBhbmQgdmlldyBldmVudHMgZ2VuZXJhdGVkIGJ5IHRoZSBydW5uaW5nIGFwcGxpY2F0aW9ucy4KICA8UD48Qj5CeSBEb2luYSBLbGluZ2VyIGFuZCBDaHJpcyBNYXJrZXMsIElCTSBVSzwvQj4gKGRrbGluZ2VyQHVrLmlibS5jb20sIGNtYXJrZXNAdWsuaWJtLmNvbSk8QlI+CiAgICBOb3ZlbWJlciAxMiwgMjAwNDwvUD4KPC9CTE9DS1FVT1RFPgo8SFIgd2lkdGg9IjEwMCUiPgoKPEgyPkludHJvZHVjdGlvbjwvSDI+CjxQPkVjbGlwc2UgaXMgbWFpbmx5IGEgZGV2ZWxvcG1lbnQgZW52aXJvbm1lbnQ6IHlvdSBjcmVhdGUgYXBwbGljYXRpb25zIGFuZCBydW4gdGhlbS4gVGFrZSB0aGUgSmF2YTxTVVA+VE08L1NVUD4gRGV2ZWxvcG1lbnQgVG9vbGtpdCBjb21wb25lbnQ6CmFwcGxpY2F0aW9ucyBhcmUgc3RvcmVkIGluIEphdmEgcGFja2FnZXMgYW5kIGNsYXNzZXMgd2hpY2ggY29ycmVzcG9uZCB0byBkaXJlY3RvcmllcyBhbmQgZmlsZXMgd2l0aCAuamF2YSBleHRlbnNpb24gcmVzcGVjdGl2ZWx5LiBUaGUgYXBwbGljYXRpb25zIGFyZQpidWlsdCB1c2luZyB0aGUgSmF2YSBjb21waWxlciBhbmQgIHRoZW4gZXhlY3V0ZWQuIFByb2plY3RzIGFyZSBob2xkZXJzIGZvciB0aGUgdmFyaW91cyBmaWxlcyB0aGF0IGFyZSBzdG9yZWQgaW4gdGhlCndvcmtzcGFjZS4gRGVwZW5kaW5nIG9mIHRoZSBuYXR1cmUgb2YgdGhlIGZpbGUsIGEgZGlmZmVyZW50IHR5cGUgb2YKYnVpbGRlciBpcyBhcHBsaWVkIHRvIHRoZW0uPHA+CkFkbWluaXN0cmF0aW9uIGFwcGxpY2F0aW9ucyBhcmUgZnVuZGFtZW50YWxseSBkaWZmZXJlbnQuIEluIHRoaXMgY2FzZSwKdGhlIHVzZXIgaW50ZXJhY3RzIHdpdGggZXhpc3RpbmcgYXBwbGljYXRpb25zIHRoYXQgdHlwaWNhbGx5IHJ1biBvdXRzaWRlIG9mIHRoZSBFY2xpcHNlCkpWTSwgICAgIHBvc3NpYmx5IG9uIGEgcmVtb3RlIG1hY2hpbmUuIFdlIHdpbGwgIHJlZmVyIHRvIHRoZXNlCmV4dGVybmFsIGFwcGxpY2F0aW9ucyBhcyA8Qj5zZXJ2ZXJzPC9CPiwgIHNpbmNlIHRoZXkgdHlwaWNhbGx5ICBwZXJmb3JtIHNvbWUgZnVuY3Rpb24gb24KYmVoYWxmIG9mIHNvbWUgY2xpZW50LiBUaGUgc2VydmVycyBhbHJlYWR5IGV4aXN0LCB0aG91Z2ggdGhleSBjYW4gYmUgbWFkZSB0byBydW4gZnJvbSBFY2xpcHNlIG9yIGV2ZW4gZGV2ZWxvcGVkIGZyb20gdGhlIHNhbWUgd29ya3NwYWNlLgpPZnRlbiBzZXJ2ZXJzIGFyZSBhZG1pbmlzdGVyZWQgYnkgYSBicm93c2VyLWJhc2VkIGFwcGxpY2F0aW9uLiBJbiB0aGlzIGFydGljbGUsIHdlIHdpbGwgc2hvdyB5b3UgaG93IGl0IGNhbiBiZSBkb25lIHVzaW5nIEVjbGlwc2UuPC9QPgo8SDI+U2VydmVyIGFkbWluaXN0cmF0aW9uIHNhbXBsZTwvSDI+Cgo8UD5XZSB3aWxsIHNob3cgaG93ICB5b3UgY2FuIHVzZSBFY2xpcHNlIHRvIG1hbmFnZSBleHRlcm5hbCBzZXJ2ZXJzLiBPdXIgc2VydmVyIGlzIGEgc2ltcGxlIAogcGhvbmUgZGlyZWN0b3J5ICB0aGF0IGhvbGRzIGRhdGEgYWJvdXQgcGVvcGxlIGFuZCB0aGVpciBwaG9uZSBudW1iZXJzLiBUaGUgCjxBIGhyZWY9IiNzZXJ2ZXJTZWN0aW9uIj5zZXJ2ZXI8L0E+IGV4cG9zZXMgb3BlcmF0aW9ucyB0byBhZGQgbmV3IGVudHJpZXMsIHF1ZXJ5IHRoZSBsaXN0IG9mIGVudHJpZXMgYW5kIGZpbmQgb3V0IGhvdyBtYW55IHlvdSBoYXZlLjxQPlRvIHNlZSB0aGUgc2FtcGxlIGluIGFjdGlvbiB5b3UnbGwgbmVlZCB0byA8QQoJaHJlZj0ibW9uaXRvclBsdWdpbi5qYXIiPmRvd25sb2FkPC9BPiAgIGl0IGFuZCAgaW5zdGFsbCBpdCBhcyBhIHBsdWctaW4gb24gRWNsaXBzZSAzLjAgYW5kIHRoZW4gc3RhcnQgdGhlIHdvcmtiZW5jaCBhbmQgb3BlbiB0aGUgTW9uaXRvciBwZXJzcGVjdGl2ZS4gCkluIGZpZ3VyZSAxIHlvdSBjYW4gc2VlIHRoZSBzYW1wbGUgd2hlbiBhIGZldyBzZXJ2ZXJzIGhhdmUgYmVlbiBkZWZpbmVkIGFuZCBkYXRhIGVudHJpZXMgaGF2ZSBiZWVuIGFkZGVkLjwvUD4KPFAgYWxpZ249ImNlbnRlciI+PGltZyBib3JkZXI9IjAiCglzcmM9ImltYWdlcy9zYW1wbGUxLmpwZyI+PEJSPgogIEZpZ3VyZSAxLiBNb25pdG9yIHNhbXBsZSBpbiBhY3Rpb24gPC9QPgoKPFA+CkluIHRoZSBzZXJ2ZXJzIHZpZXcsIHRoZSBpY29ucyBpbmRpY2F0ZSB0aGUgc3RhdGUgb2YgdGhlIHNlcnZlcnM6IGEgcmVkIHNxdWFyZSBzaG93cyB0aGUgc2VydmVyIGJlaW5nIHVuYXZhaWxhYmxlLCBhIGdyZWVuIHRyaWFuZ2xlICBzaG93cyBhbiBhY3RpdmUgc2VydmVyLiBUaGUgc3RhdGUgaXMga2VwdCB1cCB0byBkYXRlIGJ5IHBvbGxpbmcgZXZlcnkgdGVuIHNlY29uZHMuIFRvIGNyZWF0ZSBhIG5ldyBzZXJ2ZXIgZW50cnksIHN0YXJ0IHRoZSBOZXcgQ29ubmVjdGlvbiB3aXphcmQgZnJvbSB0aGUgICBwdWxsZG93biBtZW51IG9mIHRoZSBsb2NhbCB0b29sYmFyIG9mIHRoZSBTZXJ2ZXJzIHZpZXcgKGhpZ2hsaWdodGVkIGluIGZpZ3VyZSAxKTo8L1A+CjxESVYgYWxpZ249ImNlbnRlciI+PElNRyBib3JkZXI9IjAiCglzcmM9ImltYWdlcy9uZXdTZXJ2ZXJXaXphcmQuZ2lmIj48QlI+RmlndXJlIDIuIERlZmluZSBhIG5ldyBzZXJ2ZXIKPC9ESVY+CjxQPgpTcGVjaWZ5ICBhIG5hbWUsIGEgaG9zdCwgIGEgcG9ydCBudW1iZXIgICBhbmQgd2hldGhlciB5b3UgY2FuIHN0YXJ0IGFuZCBzdG9wICB0aGUgc2VydmVyIGZyb20gdGhlIHdvcmtiZW5jaC4gU3RhcnQgdGhlIHNlcnZlciBieSBzZWxlY3RpbmcgdGhlIFN0YXJ0IG9wdGlvbiBmcm9tIHRoZSBjb250ZXh0IG1lbnUgKEZpZ3VyZSAzKS4gQWRkICBhIGZldyBuZXcgZW50cmllcy4gWW91IGNhbiBzZWUgdGhlIHNlcnZlciBvdXRwdXQgaW4gdGhlIGNvbnNvbGUgdmlldy4gV2hlbiB5b3Ugc2VsZWN0IGEgc2VydmVyLCB0aGUgbnVtYmVyIG9mICBlbnRyaWVzIGlzIHNob3duIGluIHRoZSBzdGF0dXMgbGluZSBhbmQgdGhlIGNvbnRlbnQgaW4gdGhlIGRldGFpbCB2aWV3IGluIHRoZSByaWdodCBoYW5kIHNpZGUuPC9QPgo8UCBhbGlnbj0iY2VudGVyIj48SU1HIGJvcmRlcj0iMCIKCXNyYz0iaW1hZ2VzL3NlcnZlck9wZXJhdGlvbnMuanBnIj48QlI+RmlndXJlIDMuIEludm9raW5nIG9wZXJhdGlvbnMgb24gdGhlIHNlcnZlcgo8L1A+Cgo8UD4KVGhlIHNhbXBsZSBzaG93cyBob3cgeW91IGNhbiBtb25pdG9yIHRoZSBzdGF0ZSBvZiAgYSBydW5uaW5nIHN5c3RlbSBhbmQgcmVwb3J0IGJhY2sgaW4gIHRoZSBNb25pdG9yIExvZyB2aWV3IGV2ZW50cyByZWxhdGVkIHRvIHRoZSBzdGF0ZSBvZiB0aGUgc2VydmVyLiBBZGQgZW50cmllcyB1bnRpbCB0aGUgbWF4aW11bSBudW1iZXIgb2YgZW50cmllcyBpcyByZWFjaGVkIGFuZCB5b3UgY2FuIHNlZSB0aGUgZXZlbnQgcmVwb3J0ZWQgaW4gdGhlIGxvZyAuIFlvdSBjYW4gbW9kaWZ5IHRoZSBzZXJ2ZXIgcHJlZmVyZW5jZXMgZm9yIHRoZSByZWZyZXNoIGludGVydmFsIGFuZCBtYXhpbXVtIG51bWJlciBvZiBlbnRyaWVzLjwvUD4KPFAgYWxpZ249ImNlbnRlciI+IDxJTUcgYm9yZGVyPSIwIiBzcmM9ImltYWdlcy9wcmVmZXJlbmNlcy5naWYiPjxCUj5GaWd1cmUgNC4gU2VydmVyIHByZWZlcmVuY2VzCjwvUD4KCgo8SDI+TW9kZWxsaW5nIHRoZSBzZXJ2ZXIgd29ybGQ8L0gyPgo8UD4KRnJvbSB0aGUgcG9pbnQgb2YgdmlldyBvZiBhbiBhZG1pbmlzdHJhdGl2ZSBhcHBsaWNhdGlvbiwgdGhlIHdvcmxkIGlzIGNvbXBvc2VkIG9mIHRoZSB0YXJnZXQgc3lzdGVtcyBiZWluZyBhZG1pbmlzdGVyZWQgdG9nZXRoZXIgd2l0aCB0aGUgZW52aXJvbm1lbnQgb2YgdGhlIGFwcGxpY2F0aW9uIGl0c2VsZi4gIFRoZSBmaWd1cmUgYmVsb3cgc2hvd3MgdGhlIHRhcmdldCBzZXJ2ZXJzIHJ1bm5pbmcgZWl0aGVyIG9uIGEgZGlmZmVyZW50IGhvc3Qgb3Igb24gdGhlIHNhbWUgbWFjaGluZSB3aXRoIHRoZSBFY2xpcHNlIHdvcmtiZW5jaCwgdGhvdWdoIGluIGEgZGlmZmVyZW50IEpWTS48L1A+CjxQIGFsaWduPSJjZW50ZXIiPjxJTUcgYm9yZGVyPSIwIiBzcmM9ImltYWdlcy9zZXJ2ZXJzLmdpZiI+CjxCUj4KRmlndXJlIDUuIFdvcmtiZW5jaCBhbmQgdGFyZ2V0IHNlcnZlcnM8L1A+Cgo8UD4KVGhlIGFwcGxpY2F0aW9uIHJlcXVpcmVzIGFuIGludGVybmFsIHJlcHJlc2VudGF0aW9uIG9yIG1vZGVsIG9mIHRoZSB0YXJnZXQgc3lzdGVtcywgd2hpY2ggaXMgdXNlZCB0byBob2xkIGluZm9ybWF0aW9uIGFib3V0IHRoZWlyIHN0YXRlIGFuZCBhdHRyaWJ1dGVzLiBJbiBvdXIgZXhhbXBsZSwgd2UgbW9kZWwgaW5kaXZpZHVhbCB0YXJnZXQgc3lzdGVtcyB1c2luZyBpbnN0YW5jZXMgb2YgU2VydmVyRWxlbWVudC4gVGhlIFNlcnZlckVsZW1lbnQgY2xhc3MgZW5jYXBzdWxhdGVzIGluc3RhbmNlIHZhcmlhYmxlcyAoZXhwb3NlZCBieSBhY2Nlc3NvciBtZXRob2RzKSByZWxhdGluZyB0byB0aGUgdGFyZ2V0IHNlcnZlcidzIGxvY2F0aW9uIGFuZCBhIHNuYXBzaG90IG9mIGl0cyBtb3N0IHJlY2VudGx5IG9ic2VydmVkIGNvbmRpdGlvbjogPC9QPgo8QkxPQ0tRVU9URT48UFJFPjxDT0RFPnB1YmxpYyBjbGFzcyBTZXJ2ZXJFbGVtZW50IGltcGxlbWVudHMgSUFkYXB0YWJsZSwgSVdvcmtiZW5jaEFkYXB0ZXIgCnsgCjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzEuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+IC8vIFRhcmdldCBzZXJ2ZXIgbG9jYXRpb24KICBTdHJpbmcgbmFtZTsJCiAgU3RyaW5nIGhvc3RuYW1lOwogIGludCBwb3J0OwogIGJvb2xlYW4gbG9jYWw7CiAgCjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzIuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+ICAvLyBUYXJnZXQgc2VydmVyIHN0YXRlCiAgYm9vbGVhbiBhbGl2ZTsKICBib29sZWFuIGZ1bGw7CiAgCgo8SU1HIGhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18zLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPlBob25lQm9va0NsaWVudCBjb25uZWN0aW9uCjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzQuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+U2VydmVyTGF1bmNoZXIgbGF1bmNoZXI7CgogIC4uLgp9PC9DT0RFPjwvUFJFPjwvQkxPQ0tRVU9URT4KPFA+ClRoZSBsb2NhdGlvbiBpbmZvcm1hdGlvbiAoPENPREU+PElNRyBoZWlnaHQ9IjEzIgoJc3JjPSJpbWFnZXMvdGFnXzEuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+PC9DT0RFPikgaXMgdXNlZCB3aGVuIHdlIGVzdGFibGlzaCBhIGNvbm5lY3Rpb24gdG8gaW50ZXJhY3Qgd2l0aCB0aGUgdGFyZ2V0IHN5c3RlbS4gVGhlc2UgYXR0cmlidXRlcyBhcmUgYWxzbyBleHBvc2VkIGFzIHByb3BlcnRpZXMgb2YgdGhlIG9iamVjdCB1c2luZyB0aGUgUGhvbmVCb29rU2VydmVyUHJvcGVydHlTb3VyY2UgY2xhc3MsIHdoaWNoIGFsbG93cyB1cyB0byBwbHVnIGludG8gdGhlIHN0YW5kYXJkIFByb3BlcnRpZXMgdmlldyBpbiB0aGUgd29ya2JlbmNoLiA8UD4KVGhlIGFsaXZlIGFuZCBmdWxsIGF0dHJpYnV0ZXMgKDxDT0RFPjxJTUcgaGVpZ2h0PSIxMyIKCXNyYz0iaW1hZ2VzL3RhZ18yLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPjwvQ09ERT4pIGFyZSB1cGRhdGVkIGFzIGEgcmVzdWx0IG9mICB0aGUgbGlzdGVuaW5nICBvbiB0aGUgdGFyZ2V0IHNlcnZlciwgYW5kIGFmZmVjdCB0aGUgd2F5IHdlIGRpc3BsYXkgdGhlIHNlcnZlciBlbnRyeSBpbiB0aGUgU2VydmVyc1ZpZXcgdXNpbmcgIHN0YXJ0ZWQgb3Igc3RvcHBlZCBpY29ucy4KPFA+CgpUaGUgU2VydmVyRWxlbWVudCBjbGFzcyBlbmNhcHN1bGF0ZXMgYSBQaG9uZUJvb2tDbGllbnQgaW5zdGFuY2UgKDxDT0RFPjxJTUcKCWhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18zLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPjwvQ09ERT4pLCB3aGljaCBpcyB0aGUgYWN0dWFsIG9iamVjdCB1c2VkIHRvIGNvbW11bmljYXRlIHdpdGggdGhlIHNlcnZlciBhbmQgaGFuZGxlIHRoZSBuZXR3b3JrIG9wZXJhdGlvbnMgaW52b2x2ZWQgaW4gdGFsa2luZyB0byB0aGUgc2VydmVyIChpbiBvdXIgY2FzZSwgYSBzaW1wbGUgSFRUUCBzZXJ2ZXIpLiAKPFA+CkFuIG9wdGlvbmFsIFNlcnZlckxhdW5jaGVyICBmaWVsZCg8Q09ERT48SU1HIGhlaWdodD0iMTMiCglzcmM9ImltYWdlcy90YWdfNC5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj48L0NPREU+KSBpcyB1c2VkICBmb3IgaW52b2tpbmcgdGhlIHNlcnZlciBhcHBsaWNhdGlvbiBvbiB0aGUgbG9jYWwgc3lzdGVtLiBXZSdsbCBjb3ZlciB0aGUgU2VydmVyTGF1bmNoZXIgaW4gbW9yZSBkZXRhaWwgaW4gdGhlIGxhdW5jaGluZyBzZXJ2ZXJzCjxBIGhyZWY9IiNsYXVuY2hTZXJ2ZXJTZWN0aW9uIj5zZWN0aW9uPC9BPgpsYXRlciBpbiB0aGUgYXJ0aWNsZS48UD4KU2luY2Ugb3VyIHNhbXBsZSBhcHBsaWNhdGlvbiBhbGxvd3MgdGhlIGFkbWluaXN0cmF0b3IgdG8gaW50ZXJhY3Qgd2l0aCBtb3JlIHRoYW4gb25lIHRhcmdldCBzZXJ2ZXIsIHdlIHVzZSB0aGUgU2VydmVyc01vZGVsIGNsYXNzIHRvIGJyaW5nIHRvZ2V0aGVyIG11bHRpcGxlIGluc3RhbmNlcyBvZiBTZXJ2ZXJFbGVtZW50IGFzIGEgbGlzdC4gIFRoZSBpbnRlcmFjdGlvbiBvZiB0aGVzZSBjbGFzc2VzIGlzIGRlc2NyaWJlZCBpbiB0aGUgZm9sbG93aW5nIGRpYWdyYW06CjwvUD4KPFAgYWxpZ249ImNlbnRlciI+IAo8SU1HIGJvcmRlcj0iMCIgc3JjPSJpbWFnZXMvY2xhc3NEaWFncmFtTWFpbi5naWYiPjxCUj5GaWd1cmUgNi4gU2VydmVyIG1vZGVsCjwvUD4KPFA+IFdlIG5leHQgbG9vayBpbnRvIGhvdyB0byBzZXJpYWxpemUgIHN1Y2ggYSBtb2RlbC4KPC9QPgo8SDI+IFJlcHJlc2VudGluZyByZW1vdGUgcmVzb3VyY2VzIGluIHRoZSB3b3Jrc3BhY2U8L0gyPgo8SDM+QmV5b25kIHRoZSB3b3Jrc3BhY2U8L0gzPgo8UD5XaGVuIHdlJ3JlIHVzaW5nIHRoZSBFY2xpcHNlIHdvcmtiZW5jaCB0byBkZXZlbG9wIGFwcGxpY2F0aW9ucywgdGhlCnJlc291cmNlcyB3ZSB3b3JrIHdpdGggYXJlIGdlbmVyYWxseSBsb2NhbC4gVGhlIHNvdXJjZSBmaWxlcyB3ZSBjcmVhdGUKcmVzaWRlIGluIHRoZSB3b3Jrc3BhY2UgLS0gZXZlbiBpZiB3ZSB1c2UgYSByZXBvc2l0b3J5IHRvIHNoYXJlIHRoZW0Kd2l0aCBvdGhlciBkZXZlbG9wZXJzIC0tIGFuZCB0aGUgYnVpbHQgb3V0cHV0IG9mIGEgcHJvamVjdCBsaWtld2lzZQpyZW1haW5zIGxvY2FsLiA8UD4KQnkgY29udHJhc3QsIHdoZW4gb3VyIHRhc2sgaXMgdG8gbW9uaXRvciBhbmQgYWRtaW5pc3RlcgpyZW1vdGUgc3lzdGVtcywgdGhlIGNvbnRlbnQgd2UgbmVlZCB0byBkaXNwbGF5IGluIHRoZSB2aWV3cyB3ZSB1c2UKbXVzdCBiZSByZXRyaWV2ZWQgYWNyb3NzIHRoZSBuZXR3b3JrLiAoV2UnbGwgZGVhbCB3aXRoIGlzc3VlcyBvZgonbGl2ZW5lc3MnIDxBCglocmVmPSIjbW9uaXRvcmluZ1NlY3Rpb24iPmxhdGVyPC9BPiBvbiBpbiB0aGUKYXJ0aWNsZS4pPFA+CkluIG91ciBleGFtcGxlLCB0aGUgU2VydmVyRWxlbWVudCBpcyB0aGUgY2xhc3MgdGhhdCAgcmVwcmVzZW50cyB0aGUgcmVtb3RlIHN5c3RlbSAgYW5kIGlzIHBlcnNpc3RlZCBsb2NhbGx5LiAgSW4gb3VyIGV4YW1wbGUsIHdlIHByb3ZpZGUgYSB2aWV3LCBQaG9uZUJvb2tTZXJ2ZXJzTGlzdFZpZXcsICB3aGljaCBpcyByZWFsbHkgYSBOYXZpZ2F0b3IgZm9yIHNlcnZlcnMuIDwvUD4KCjxQPkF0IHRoaXMgcG9pbnQsIHdlIGhhdmUgdG8gZGVjaWRlIHdoZXJlIHRvIApzdG9yZSB0aGUgY29ubmVjdGlvbiBpbmZvcm1hdGlvbiByZXByZXNlbnRpbmcgcmVtb3RlIHN5c3RlbXMuIFdlIGNhbiBzdG9yZSB0aGVtOiAKIDxVTD4KIDxMST4KYXMKbm9ybWFsIHdvcmtzcGFjZSByZXNvdXJjZXMgaW4gYSBmaWxlIG9mIGNlcnRhaW4gdHlwZS4gPEJSPgpUaGV5IHNob3cgdXAgaW4gdGhlIE5hdmlnYXRvciB2aWV3IGFuZCBjYW4gYmUgbW9kaWZpZWQgYnkgYW4gZWRpdG9yIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGZpbGUgdHlwZS4gPC9MST4KCQoJPExJPgogYXMgZGF0YSBzcGVjaWZpYyBhbmQgcHJpdmF0ZSB0byBvdXIgcGx1Zy1pbiAgPEJSPgpUaGUgcGx1Zy1pbiBtZXRhZGF0YQphcmVhIGlzIGF2YWlsYWJsZSBmb3IgdGhpcyBwdXJwb3NlLiBUaGlzIGFyZWEgY2FuJ3QgYmUgc2VlbgppbiB0aGUgTmF2aWdhdG9yIHZpZXcsIHNvIHdlIG5lZWQgdG8gcHJvdmlkZSBhIHNwZWNpYWxpemVkIHZpZXcgdG8gZGlzcGxheSBhIHJlcHJlc2VudGF0aW9uIG9mIHRoaXMgY29udGVudC4KPC9MST4gCjwvVUw+CldlJ3ZlIGNob3NlbiB0aGUgc2Vjb25kIG9wdGlvbiBhYm92ZSwgdGhvdWdoIGJvdGggYXJlIHZhbGlkIGFwcHJvYWNoZXMuCkluY2lkZW50YWxseSwgaWYgeW91J3ZlIGJlZW4gdXNpbmcgdGhlIENWUyBSZXBvc2l0b3J5IEV4cGxvcmluZwpwZXJzcGVjdGl2ZSwgeW91J3ZlIGFscmVhZHkgYmVlbiB3b3JraW5nIHdpdGggYW4gZXhhbXBsZSBvZiB0aGUgc2Vjb25kCmFwcHJvYWNoLiBUaGUgaW1wbGljYXRpb25zIG9mIHRoZSB0d28gYXBwcm9hY2hlcyBhcmUgY29udHJhc3RlZCBiZWxvdy4KPFA+CjxUQUJMRSBib3JkZXI9IjEiPgoJPFRCT0RZPgoJCTxUUj4KCQkJPFREIHdpZHRoPSI0NzciPjxCPlVzaW5nIHdvcmtzcGFjZSByZXNvdXJjZXM8L0I+PC9URD4KCQkJPFREIHdpZHRoPSI0NzciPjxCPlVzaW5nIHByaXZhdGUgcmVzb3VyY2UgaW5mb3JtYXRpb24gKHBsdWctaW4KCQkJbWV0YWRhdGEpPC9CPjwvVEQ+CgkJPC9UUj4KCQk8VFI+CgkJCTxURCB3aWR0aD0iNDc3Ij5SZXNvdXJjZXMgKHJlcHJlc2VudGF0aW9ucyBvZiByZW1vdGUgc3lzdGVtcykgYXJlCgkJCXZpc2libGUgaW4gdGhlIE5hdmlnYXRvciwgYW5kIGFyZSBhdmFpbGFibGUgdG8gb3RoZXIgRWNsaXBzZSB0b29sczwvVEQ+CgkJCTxURCB3aWR0aD0iNDc3Ij5SZXNvdXJjZXMgYXJlIHZpc2libGUgb25seSB2aWEgZGVkaWNhdGVkIHBsdWctaW4gY29kZQoJCQkoc3BlY2lhbGl6ZWQgdmlld3MgZXRjLik8L1REPgoJCTwvVFI+CgkJPFRSPgoJCQk8VEQgd2lkdGg9IjQ3NyI+UmVwcmVzZW50YXRpb25zIG9mIHJlbW90ZSBzeXN0ZW1zIGNyZWF0ZWQgd2l0aCBOZXcKCQkJd2l6YXJkIChjb250cmlidXRpb24gdG8gb3JnLmVjbGlwc2UudWkuTmV3V2l6YXJkcyk8L1REPgoJCQk8VEQgd2lkdGg9IjQ3NyI+UmVwcmVzZW50YXRpb25zIG9mIHJlbW90ZSBzeXN0ZW1zIGNyZWF0ZWQgYnkgYSB1c2VyCgkJCWFjdGlvbiBwcm92aWRlZCBieSBwbHVnLWluIGNvZGU8L1REPgoJCTwvVFI+CgkJPFRSPgoJCQk8VEQgd2lkdGg9IjQ3NyI+J0NvbnRlbnQnIG9mIHJlbW90ZSBzeXN0ZW1zIGlzIGFjY2Vzc2VkIHVzaW5nIGFuCgkJCUVkaXRvcjwvVEQ+CgkJCTxURCB3aWR0aD0iNDc3Ij5Db250ZW50IGlzIGFjY2Vzc2VkIHVzaW5nIHNwZWNpYWxpemVkIHZpZXdzPC9URD4KCQk8L1RSPgoJCTxUUj4KCQkJPFREIHdpZHRoPSI0NzciPk11bHRpcGxlIGVkaXRvciBpbnN0YW5jZXMgY2FuIGJlIHVzZWQgdG8gd29yayB3aXRoCgkJCW11bHRpcGxlIHJlbW90ZSBzeXN0ZW1zIHNpbXVsdGFuZW91c2x5PC9URD4KCQkJPFREIHdpZHRoPSI0NzciPlZpZXcgbXVzdCBzcGVjaWZpY2FsbHkgYWNjb21tb2RhdGUgd29ya2luZyB3aXRoCgkJCW11bHRpcGxlIHJlbW90ZSBzeXN0ZW1zIGlmIHRoaXMgaXMgZGVzaXJlZDwvVEQ+CgkJPC9UUj4KCQk8VFI+CgkJCTxURCB3aWR0aD0iNDc3Ij5Db250ZW50IGNhbiBhcHBlYXIgd2l0aG91dCBjdXN0b21pemluZyBhbnkKCQkJcGVyc3BlY3RpdmU8L1REPgoJCQk8VEQgd2lkdGg9IjQ3NyI+RXhpc3RpbmcgcGVyc3BlY3RpdmUgbXVzdCBiZSBjdXN0b21pemVkIGJ5IHVzZXIgKGUuZy4KCQkJV2luZG93IC0mZ3Q7IFNob3cgVmlldykgb3IgYSBzcGVjaWFsaXplZCBwZXJzcGVjdGl2ZSBwcm92aWRlZDwvVEQ+CgkJPC9UUj4KCTwvVEJPRFk+CjwvVEFCTEU+CjxIMj4gUGVyc2lzdGluZyBzZXJ2ZXIgcmVmZXJlbmNlczwvSDI+CjxQPlRoZSAubWV0YWRhdGEgZGlyZWN0b3J5IG9mIGEgd29ya3NwYWNlIGlzIGNvbnNpZGVyZWQgdG8gYmUgYSAiYmxhY2sKYm94IiB3aGVyZSBpbXBvcnRhbnQgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHdvcmtzcGFjZSBzdHJ1Y3R1cmUsIHN1Y2ggYXMKYSBwcm9qZWN0J3MgcmVmZXJlbmNlcyBvciBhIHJlc291cmNlJ3MgcHJvcGVydGllcywgYXJlIHR5cGljYWxseSBzdG9yZWQuCiBUaGUgbm9uLXdvcmtzcGFjZQpyZXNvdXJjZXMgYXJlIHN0b3JlZCBvbiBhIHBlciBwbHVnLWluIGJhc2lzLCB0eXBpY2FsbHkgYWxsIGluIG9uZSBmaWxlLgo8UD4KSW4gb3VyIGV4YW1wbGUsIHRoZSAicmVzb3VyY2VzIiB0aGF0IHdlIHdhbnQgdG8gcGVyc2lzdCBhcmUgU2VydmVyRWxlbWVudCBvYmplY3RzLCBvciwgbW9yZSBwcmVjaXNlbHksIHRob3NlIGF0dHJpYnV0ZXMgICAgbmVlZGVkIHRvIGVzdGFibGlzaCBhIHNlc3Npb24gd2l0aCB0aGUgcmVtb3RlIHByb2Nlc3MgYW5kIGludGVyYWN0IHdpdGggaXQgLS0gbmFtZSwgaG9zdCwgIHBvcnQgYW5kIHRoZSBpc0xvY2FsIGF0dHJpYnV0ZS4gVGhlIG90aGVyIGF0dHJpYnV0ZXMgb2YgdGhlIFNlcnZlckVsZW1lbnQgd2hpY2ggZGVzY3JpYmUgdGhlIHN0YXRlIG9mIHRoZSBzZXJ2ZXIgYXQgb25lIG1vbWVudCBhcmUgdHJhbnNpZW50IGFuZCBhcmUgbm90IHNhdmVkLjxQPgpJbgovd29ya3NwYWNlLy5tZXRhZGF0YS8ucGx1Z2lucy9Nb25pdG9yUHJvamVjdC9jb25uZWN0aW9uLnhtbCB3ZSBzYXZlCmluZm9ybWF0aW9uIGFib3V0IGNvbm5lY3Rpb25zIGluIGFuIFhNTCBmb3JtYXQ6PC9QPgo8QkxPQ0tRVU9URT48UFJFPjxDT0RFPiZsdDtNb25pdG9yJmd0OyAKICAgICZsdDtTZXJ2ZXIgSG9zdD0iMTM0LjQ1Ni44ODguOTkiIDxTUEFOCgljbGFzcz0ibSI+ICAgSXNMb2NhbD0gInRydWUiIDwvU1BBTj4KCQk8U1BBTiBjbGFzcz0idCI+PC9TUEFOPk5hbWU9Ik15Q29ubmVjdGlvbiIgUG9ydD0iNjAwIiAvJmd0OyAKICAgICZsdDtTZXJ2ZXIgSG9zdD0iMzM0LjU1My42MzYuNDQiIDxTUEFOIGNsYXNzPSJ0Ij5Jc0xvY2FsPC9TUEFOPjxTUEFOCgljbGFzcz0ibSI+PSI8L1NQQU4+dHJ1ZTxTUEFOIGNsYXNzPSJtIj4iPC9TUEFOPjxTUEFOIGNsYXNzPSJ0Ij4gPC9TUEFOPgoJCU5hbWU9Ik90aGVyQ29ubmVjdGlvbiIgUG9ydD0iNjAwIiAvJmd0OyAKICAgICZsdDtTZXJ2ZXIgSG9zdD0iMjIzLjIyMy42NjIuNTUiIDxTUEFOIGNsYXNzPSJ0Ij5Jc0xvY2FsPC9TUEFOPjxTUEFOCgljbGFzcz0ibSI+PSI8L1NQQU4+ZmFsc2U8U1BBTiBjbGFzcz0ibSI+IjwvU1BBTj48U1BBTiBjbGFzcz0idCI+IDwvU1BBTj4KCQlOYW1lPSJEb21haW5Db25uZWN0aW9uIiBQb3J0PSI0MDAiIC8mZ3Q7IAombHQ7L01vbml0b3ImZ3Q7PC9DT0RFPjwvUFJFPjwvQkxPQ0tRVU9URT4KPFA+VGhlIHNlcmlhbGl6YXRpb24gb2Ygb3VyIHNlcnZlciBtb2RlbCBpcyBhY2hpZXZlZCBpbiB0aGUgZm9sbG93aW5nIHN0ZXBzOjwvUD4KPFVMPgoJPExJPmNvbnN0cnVjdCB0aGUgamF2YS5pby5GaWxlIG9iamVjdCByZXByZXNlbnRpbmcgdGhlIGZpbGUgd2hlcmUgdGhlICAgICBzZXJ2ZXIgZWxlbWVudHMgYXJlIHRvIGJlIHNhdmVkIDxCUj5XZSB1c2UgdGhlIGdldFN0YXRlTG9jYXRpb24gbWV0aG9kIG9uIG91ciBwbHVnLWluIHRvIHJldHVybiB0aGUgbG9jYXRpb24KaW4gdGhlIGxvY2FsIGZpbGUgc3lzdGVtIG9mIHRoZSBwbHVnLWluIHN0YXRlIGFyZWEgZm9yIHRoaXMgcGx1Zy1pbiAoPElNRwoJCWhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18xLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPikuPEJMT0NLUVVPVEU+PFBSRT48SU1HIGhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18xLmdpZiIKCXdpZHRoPSIyNCIgYm9yZGVyPSIwIj48Q09ERT4gRmlsZSBjb25uZWN0aW9uRmlsZSA9IE1vbml0b3JQcm9qZWN0UGx1Z2luLmdldERlZmF1bHQoKS5nZXRTdGF0ZUxvY2F0aW9uKCkuYXBwZW5kKDxGT05UCgkJY29sb3I9IiMwMDAwZmYiPiZxdW90O2Nvbm5lY3Rpb24ueG1sJnF1b3Q7PC9GT05UPikudG9GaWxlKCk7CjxDT0RFPiAgIGlmICghY29ubmVjdGlvbkZpbGUuZXhpc3RzKCkpIGNvbm5lY3Rpb25GaWxlLmNyZWF0ZU5ld0ZpbGUoKTs8L0NPREU+PC9DT0RFPjwvUFJFPjwvQkxPQ0tRVU9URT4KCQoJCgk8L0xJPgoJPExJPm9uIHN0YXJ0LXVwIHJlYWQgdGhlIGNvbnRlbnQgb2YgdGhlIGZpbGUgdG8gYnVpbGQgdGhlIGNvbm5lY3Rpb24gbW9kZWw8QlI+CgkKCVdlIHVzZSBYTUxNZW1lbnRvIGZvciBlYXN5IG1hbmlwdWxhdGlvbiBvZiB0aGUgWE1MIGZpbGUuCglXZSBjcmVhdGUgYSBmaWxlIHJlYWRlciBmb3IgdGhlIGNvbm5lY3Rpb24gZmlsZSBhbmQgYW4gWE1MTWVtZW50byBvYmplY3QgZnJvbSB0aGUKCXJlYWRlciAoPENPREU+PElNRyBoZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfMi5naWYiIHdpZHRoPSIyNCIKCQlib3JkZXI9IjAiPjwvQ09ERT4pIGNvcnJlc3BvbmRpbmcgdG8gdGhlIDxDT0RFPiZsdDtNb25pdG9yJmd0OzwvQ09ERT4gdGFnLiBGcm9tIHRoZSBwYXJlbnQgSU1lbWVudG8gb2JqZWN0LCB3ZSBleHRyYWN0IHRoZSBjaGlsZHJlbiBlbnRyaWVzIGZvciBlYWNoIFNlcnZlci4gKAoJPENPREU+PElNRyBoZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfMy5naWYiIHdpZHRoPSIyNCIKCQlib3JkZXI9IjAiPjwvQ09ERT4gKS4gV2UgY2FuIG5vdyBleHRyYWN0IHRoZSBhdHRyaWJ1dGVzIG9mIHRoZSBjb25uZWN0aW9uIGFuZCBpbml0aWFsaXplIHRoZSBpbi1tZW1vcnkgbW9kZWwuPEJMT0NLUVVPVEU+PFBSRT48Q09ERT4gICBGaWxlUmVhZGVyIHJlYWRlciA9IG5ldyBGaWxlUmVhZGVyKGNvbm5lY3Rpb25GaWxlKTsKPElNRwoJCWhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18yLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPiBtZW1lbnRvID0gWE1MTWVtZW50by5jcmVhdGVSZWFkUm9vdChyZWFkZXIpOwo8SU1HIGhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18zLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPiBJTWVtZW50b1tdIGNoaWxkcmVuID1tZW1lbnRvLmdldENoaWxkcmVuKDxGT05UCgkJY29sb3I9IiM4MDAwZmYiPiZxdW90O1NlcnZlciZxdW90OzwvRk9OVD4pOwogICBmb3IgKGludCBpID0gMDsgaSAmbHQ7IGNoaWxkcmVuLmxlbmd0aDsgaSsrKSB7CglTdHJpbmcgbmFtZSA9IGNoaWxkcmVuW2ldLmdldFN0cmluZyg8Rk9OVCBjb2xvcj0iIzAwMDBmZiI+JnF1b3Q7TmFtZSZxdW90OzwvRk9OVD4pOwoJLy9leHRyYWN0IGFsbCBhdHRyaWJ1dGVzIGFuZCBidWlsZCB0aGUgc2VydmVycyBtb2RlbCAKICAgIH08L0NPREU+PC9QUkU+PC9CTE9DS1FVT1RFPgoJPC9MST4KCTxMST53aGVuIGNsb3NpbmcgdGhlIGNvbm5lY3Rpb24gdmlldywgc2VyaWFsaXplIHRoZSBjb25uZWN0aW9ucyBmcm9tIHRoZSBtb2RlbCB0byB0aGUgZmlsZS48L0xJPgo8UD4gV2UgY3JlYXRlIGFuIFhNTE1lbWVudG8gY29ycmVzcG9uZGluZyB0byBvdXIgPENPREU+Jmx0O01vbml0b3ImZ3Q7PC9DT0RFPiByb290ICg8Q09ERT48SU1HCgkJaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzQuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+PC9DT0RFPikuIFdlIGl0ZXJhdGUgdGhyb3VnaCAgdGhlIG1vZGVsIGFuZCBjcmVhdGUgYSBjaGlsZCBtZW1lbnRvIGZvciBlYWNoIHNlcnZlciAgKDxDT0RFPjxJTUcKCQloZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfNS5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj48L0NPREU+KSBhbmQgc2V0IGl0cyBhdHRyaWJ1dGVzLiBJbiB0aGUgZW5kLCB3ZSBzYXZlIHRoZSBYTUxNZW1lbnRvIGRhdGEgc3RydWN0dXJlIHRvIHRoZSBmaWxlCnVzaW5nIGEgZmlsZSB3cml0ZXIoPENPREU+PElNRyBoZWlnaHQ9IjEzIgoJCXNyYz0iaW1hZ2VzL3RhZ182LmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPjwvQ09ERT4pLjwvUD4KPEJMT0NLUVVPVEU+PFBSRT48Q09ERT4KICAgSXRlcmF0b3IgaXRlcmF0b3IgPSBtb2RlbC5nZXRDb250ZW50KCkuaXRlcmF0b3IoKQo8SU1HIGhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ180LmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPiBYTUxNZW1lbnRvIG1lbWVudG8gPSBYTUxNZW1lbnRvLmNyZWF0ZVdyaXRlUm9vdCg8Rk9OVCBjb2xvcj0iIzAwMDBmZiI+JnF1b3Q7TW9uaXRvciZxdW90OzwvRk9OVD4pOwkJCiAgIHdoaWxlIChpdGVyYXRvci5oYXNOZXh0KCkpIHsKCURpcmVjdG9yeUNvbm5lY3Rpb24gY29ubiA9KChEaXJlY3RvcnlWaWV3RWxlbWVudClpdGVyYXRvci5uZXh0KCkpLmdldENvbm5lY3Rpb24oKTsKPElNRyBoZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfNS5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj4gICAgICBJTWVtZW50byBjaGlsZCA9IG1lbWVudG8uY3JlYXRlQ2hpbGQoPEZPTlQgY29sb3I9IiMwMDAwZmYiPiZxdW90O1NlcnZlciZxdW90OzwvRk9OVD4pOwoJY2hpbGQucHV0U3RyaW5nKDxGT05UIGNvbG9yPSIjMDAwMGZmIj4mcXVvdDtOYW1lJnF1b3Q7PC9GT05UPiwgY29ubi5nZXROYW1lKCkpOwoJLy8gdGhlIHNhbWUgZm9yIGFsbCBhdHRyaWJ1dGVzCgogICB9CjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzYuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+IFdyaXRlciB3cml0ZXIgPSBuZXcgRmlsZVdyaXRlcihjb25uZWN0aW9uRmlsZSk7CiAgIG1lbWVudG8uc2F2ZSh3cml0ZXIpOwk8L0NPREU+PC9QUkU+PC9CTE9DS1FVT1RFPgoKPC9VTD4KPEgyPgk8QSBuYW1lPSJtb25pdG9yaW5nU2VjdGlvbiI+PC9BPk1vbml0b3JpbmcgYW5kIGV2ZW50IG5vdGlmaWNhdGlvbnMJPC9IMj4KPEgzPklzICB0aGUgc2VydmVyIHN0aWxsIHRoZXJlPzwvSDM+CjxQPkEga2V5IGluZ3JlZGllbnQgaW4gbW9uaXRvcmluZyBydW5uaW5nIHN5c3RlbXMgb3IgcHJvY2Vzc2VzIGlzCmtub3dpbmcgd2hldGhlciBvciBub3QgdGhleSdyZSBpbiBhIG5vcm1hbCwgaGVhbHRoeSBzdGF0ZS4gSW4gdGhlIG1vc3QKYmFzaWMgc2l0dWF0aW9ucywgaXQgY2FuIGJlIGVub3VnaCBqdXN0IHRvIGtub3cgd2hldGhlciBhIHNlcnZlciBpcwpydW5uaW5nIG9yIHN0b3BwZWQsIGJ1dCB0eXBpY2FsbHkgdGhlcmUgYXJlIGEgbnVtYmVyIG9mIG90aGVyIHBvdGVudGlhbApjb25kaXRpb25zIC0tIHdoaWNoIGRlcGVuZCB1cG9uIHRoZSB0eXBlIG9mIHN5c3RlbSBiZWluZyBtb25pdG9yZWQgLS0KdGhhdCBhbiBhZG1pbmlzdHJhdG9yIGlzIGludGVyZXN0ZWQgaW4uIFJhdGhlciB0aGFuIGhhdmluZyB0byBnbyBhbmQKcHJvLWFjdGl2ZWx5IHF1ZXJ5IHRoZSBzdGF0ZSBvZiB0aGUgc2VydmVyLCBpdCdzIHVzZWZ1bCB0byBoYXZlIGEKY29udGludW91cyBpbmRpY2F0aW9uIG9mIGl0cyBoZWFsdGgsIG11Y2ggbGlrZSB0aGUgZGFzaGJvYXJkIGluIHlvdXIKY2FyLiBZb3UgY2FuIHRlbGwgYXQgYSBnbGFuY2UgaWYgYWxsJ3Mgd2VsbCwgYW5kIG9ubHkgcGVlayB1bmRlciB0aGUKaG9vZCBpZiBzb21ldGhpbmcgbGlnaHRzIHVwIHRoYXQgdGVsbHMgeW91IHRoZXJlJ3MgYSBwcm9ibGVtLiAoV2VsbCwKdGhhdCdzIHRoZSB0aGVvcnkhKQogPC9QPgogPFA+VGhlIHNlcnZlciB2aWV3IGlzIG91ciBkYXNoYm9hcmQgZGlzcGxheSBzaG93aW5nIGF0IGEgcXVpY2sgZ2xhbmNlIHRoZSBzdGF0ZSBvZiB0aGUgcnVubmluZyBhcHBsaWNhdGlvbnMuIEhvdyB0aGlzICAgaXMgcHV0IHRvZ2V0aGVyIGlzIGNhcHR1cmVkIGluIHRoZSBjbGFzcyBkaWFncmFtIGZyb20gRmlndXJlIDcuIFRoZSB2aWV3IHVzZXMgdGhlIG1vZGVsIGZvciBpdHMgbGFiZWwgYW5kIGNvbnRlbnQgcHJvdmlkZXIuIFRoZSBzZXJ2ZXIgbW9kZWwgdXNlcyBhIGJhY2tncm91bmQgdGhyZWFkIHRvIGNvbnRpbnVhbGx5IHBvbGwgdGhlIHRhcmdldCBzZXJ2ZXJzIGZvciB3aGljaCBpdCBjb250YWlucyByZWZlcmVuY2VzLiBXaGVuIGEgY2hhbmdlIG9jY3VycyBpbiB0aGUgc3RhdGUgcmVwcmVzZW50ZWQgYnkgdGhlIG1vZGVsLCBpdCBnZW5lcmF0ZXMgYSBTZXJ2ZXJFdmVudCB0byBub3RpZnkgbGlzdGVuZXJzIG9mIHRoZSBjaGFuZ2UuIFRoZSBTZXJ2ZXJMaXN0VmlldyByZWdpc3RlcnMgaXRzZWxmIGFzIGEgU2VydmVyTGlzdGVuZXIgaW4gb3JkZXIgdG8gcmVjZWl2ZSB0aGVzZSBub3RpZmljYXRpb25zLjwvUD4KPFA+VGhlIHNlcnZlciB2aWV3ICAgbmVlZHMgdG8gYmUgdXAtdG8tZGF0ZTsgYSBkYXNoYm9hcmQgdGhhdCBzaG93cyB5b3VyIHBldHJvbCB0YW5rIGZ1bGwgd2hlbiB5b3UgYXJlIGRvd24gdG8gdGhlIGxhc3QgZHJvcHMgaXMgb2Ygbm90IG11Y2ggdXNlLiBIZW5jZSB0aGUgdmlldyBuZWVkcyB0byBiZSBhIHNlcnZlciBsaXN0ZW5lciB0byByZWFjdCB0byB0aGUgY2hhbmdlcy4gVGhlIFNlcnZlckxpc3RlbmVyIGludGVyZmFjZSBkZWZpbmVzIHRoZSBmb2xsb3dpbmcgbWV0aG9kczo8L1A+CjxCTE9DS1FVT1RFPjxQUkU+CnZvaWQgc2VydmVyU3RhcnRlZChTZXJ2ZXJFdmVudCBldmVudCkKdm9pZCBzZXJ2ZXJTdG9wcGVkKFNlcnZlckV2ZW50IGV2ZW50KQp2b2lkIHNlcnZlclVwZGF0ZShTZXJ2ZXJFdmVudCBldmVudCkKdm9pZCBzZXJ2ZXJFcnJvcihTZXJ2ZXJFdmVudCBldmVudCk8L1BSRT48L0JMT0NLUVVPVEU+CjxQIGFsaWduPSJjZW50ZXIiPjxJTUcgYm9yZGVyPSIwIiBzcmM9ImltYWdlcy9jbGFzc0RpYWdyYW1EZXRhaWwuZ2lmIj48QlI+CkZpZ3VyZSA3LiBDbGFzcyBkaWFncmFtIDwvUD4KPFA+VGhlIHdheSB0aGUgY29ubmVjdGlvbiBvYmplY3Qgd29ya3MgZGVwZW5kcyB1cG9uIHRoZSBuYXR1cmUgb2YKdGhlIHNlcnZlci4gT3VyIGV4YW1wbGUgdXNlcyBhbiBIVFRQIHNlcnZlciB3aGljaCBleHBlY3RzIGNvbm5lY3Rpb25zIHRvCmJlIHNob3J0LWxpdmVkIChpLmUuIGl0IGlzIGNvbm5lY3Rpb25sZXNzKSwgYW5kIHRoYXQgbWVhbnMgd2UgbmVlZCB0bwpwZXJmb3JtIGEgJ25vcm1hbCcgaW50ZXJhY3Rpb24gd2l0aCB0aGUgc2VydmVyIGluIG9yZGVyIHRvIGRldGVybWluZSBpZgppdCdzIHN0aWxsIHRoZXJlLiBXZSB3b24ndCBpbGx1c3RyYXRlIHRoZSBIVFRQIHByb3RvY29sIGhhbmRsaW5nIGhlcmUgLS0gdGhhdCdzIGltcGxlbWVudGVkIGluIHRoZSBQaG9uZUJvb2tDbGllbnQgY2xhc3MuPFA+ClRoZSBTZXJ2ZXJMaXN0TW9kZWwgICBrZWVwcyB1cC10by1kYXRlIHdpdGggdGhlIHN0YXRlIG9mIHRoZSB0YXJnZXQgc2VydmVycyBpdCBrbm93cyBhYm91dCBieSBoYXZpbmcgYSBtb25pdG9yIHRocmVhZCBjbGFzcyBydW5uaW5nIGluIHRoZSBiYWNrZ3JvdW5kIGFuZCBleGFtaW5pbmcgZWFjaCBzZXJ2ZXIgZWxlbWVudCBpbiB0dXJuLiBUaGUgaW50ZXJhY3Rpb24gZm9yICBvbmUgU2VydmVyRWxlbWVudCBpcyBzaG93biBpbiB0aGUgY29kZSBzbmlwcGV0IGZyb20gYmVsb3cuIEZvciB0aGUgc2VydmVyIGVsZW1lbnQsIHdlIG9idGFpbiBpdHMgUGhvbmVCb29rQ2xpZW50ICAgICBpbiBvcmRlciB0byAgaW52b2tlIGl0cyAgbWV0aG9kIHRoYXQgdGVsbHMgdXMgaG93IG1hbnkgZW50cmllcyAgIHRoZSBzZXJ2ZXIgY29udGFpbnMoPENPREU+PElNRwoJaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzEuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+PC9DT0RFPikuIFRoZXJlIGFyZSB0d28gcmVhc29ucyBmb3IgaW52b2tpbmcgdGhpcyBtZXRob2QuIElmIHdlIGdldCBhbnkgYW5zd2VyIGF0IGFsbCB0aGUgc2VydmVyIGlzIHJ1bm5pbmcuICBXZSB1c2UgdGhlIHJldHVybiB2YWx1ZSAoPENPREU+PElNRwoJaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzIuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+PC9DT0RFPikgdG8gZGV0ZXJtaW5lIGlmIHRoZSBzZXJ2ZXIgaXMgZnVsbC4gSWYgd2UgZ2V0IGFuIElPRXhjZXB0aW9uICg8Q09ERT48SU1HCgloZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfMy5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj48L0NPREU+KSAsIHRoZSBzZXJ2ZXIgaXMgc3RvcHBlZC48UD4KVGhlIHJlc3BvbnNlIGZyb20gdGhlIHNlcnZlciBpcyB1c2VkIHRvIGdlbmVyYXRlIGV2ZW50cyBmb3IgcmVnaXN0ZXJlZCBsaXN0ZW5lcnMgKGkuZS4gdGhlIHNlcnZlcnMgdmlldyksIHVzaW5nIHRoZSBub3RpZnlTdGFydGVkIGFuZCBub3RpZnlVcGRhdGUgbWV0aG9kcy48L1A+CjxCTE9DS1FVT1RFPjxQUkU+CiAgICAgICBTZXJ2ZXJFbGVtZW50IGVsZW1lbnQgPSAuLjsgCiAgICAgICB0cnkgIHsgCiAgICAgICAgIFBob25lQm9va0NsaWVudCBjbGllbnQgPSBlbGVtZW50LmdldFBob25lQm9va0NsaWVudCgpOyAKPElNRyBoZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfMS5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj4gICAgICAgaW50IGNvdW50ID0gY2xpZW50LmdldEVudHJ5Q291bnQgKCk7IAogICAgICAgICBpZiAoZWxlbWVudC5pc0FsaXZlICgpID09IGZhbHNlKSAgeyAKICAgICAgICAgICAgZWxlbWVudC5zZXRBbGl2ZSAodHJ1ZSk7IAogICAgICAgICAgICBub3RpZnlTdGFydGVkIChuZXcgU2VydmVyRXZlbnQgKCZxdW90O1NlcnZlciBzdGFydGVkJnF1b3Q7LCBJU3RhdHVzLklORk8sIGVsZW1lbnQuZ2V0TmFtZSgpKSk7IAogICAgICAgICB9IAo8SU1HIGhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18yLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPiAgICAgICBpZiAoZWxlbWVudC5pc0Z1bGwgKCkgPT0gZmFsc2UgJmFtcDsmYW1wOyBjb3VudCAmZ3Q7PSBtYXhFbnRyaWVzKSB7IAogICAgICAgICAgICAgZWxlbWVudC5zZXRGdWxsICh0cnVlKTsgCiAgICAgICAgICAgICBub3RpZnlVcGRhdGUgKG5ldyBTZXJ2ZXJFdmVudCAoJnF1b3Q7TWF4IG51bWJlciBvZiBlbnRyaWVzIHJlYWNoZWQmcXVvdDssIElTdGF0dXMuV0FSTklORywgZWxlbWVudC5nZXROYW1lICgpKSk7IAogICAgICAgICB9IGVsc2UgZWxlbWVudC5zZXRGdWxsKGZhbHNlKTsgCiAgICAgfSBjYXRjaCAoSU9FeGNlcHRpb24gZSkgeyAKPElNRyBoZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfMy5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj4gICAgICAgaWYgKGVsZW1lbnQuaXNBbGl2ZSAoKSA9PSB0cnVlKSB7IAogICAgICAgICAgICAgZWxlbWVudC5zZXRBbGl2ZSAoZmFsc2UpOyAKICAgICAgICAgICAgIG5vdGlmeVN0YXJ0ZWQgKG5ldyBTZXJ2ZXJFdmVudCAoJnF1b3Q7U2VydmVyIHN0b3BwZWQgKCZxdW90OyArIGUudG9TdHJpbmcgKCkgKyAnKScsIElTdGF0dXMuSU5GTywgIGVsZW1lbnQuZ2V0TmFtZSAoKSkpOyAKICAgICAgICAgfTwvUFJFPjwvQkxPQ0tRVU9URT4KPFA+Rm9yIHNlcnZlcnMgdGhhdCBhcmUgY29ubmVjdGlvbi1vcmllbnRlZCAoZXhwZWN0CmNsaWVudHMgdG8gcmVtYWluIGNvbm5lY3RlZCBpbmRlZmluaXRlbHkpLCBpdCBtYXkgYmUgc3VmZmljaWVudCBzaW1wbHkKdG8gYXNzdW1lIHRoYXQgYXMgbG9uZyBhcyB0aGUgY29ubmVjdGlvbiBoYXNuJ3QgYmVlbiBicm9rZW4sIHRoZSBzZXJ2ZXIKaXMgc3RpbGwgYXZhaWxhYmxlLiBGb3IgY2FzZXMgd2hlcmUgd2Ugd2FudCB0byB1c2UgbW9yZSBkZXRhaWxlZApjcml0ZXJpYSB0byBkZXRlcm1pbmUgdGhlIGhlYWx0aCBvZiBhIHNlcnZlciwgb3VyIGNvbm5lY3Rpb24gb2JqZWN0IHdpbGwKbmVlZCB0byBpbnRlcmFjdCB3aXRoIHRoZSByZW1vdGUgc3lzdGVtIGFuZCBwZXJmb3JtIHRoZSBuZWNlc3NhcnkKb3BlcmF0aW9ucyB0byBkZXRlcm1pbmUgdGhhdCBzdGF0ZS4KPEgzPkhvdyBpcyB0aGUgc2VydmVyIGRvaW5nPzwvSDM+Cgk8UD5JbiBhZGRpdGlvbiB0byBjaGVja2luZyB3aGV0aGVyIGEgc2VydmVyIGlzIHN0aWxsIHJ1bm5pbmcgb3Igbm90LCB0aGUgYWRtaW5pc3RyYXRvciBtaWdodCB3YW50IHRvIGdldCBtb3JlIGRldGFpbHMgYWJvdXQgdGhlIHdlbGwgYmVpbmcgb2YgYSBydW5uaW5nIGFwcGxpY2F0aW9uLiBPbmUgd2F5IG9mIGRvaW5nIHRoaXMgaXMgYnkgZXhhbWluaW5nIHRoZSBNb25pdG9yIExvZyB2aWV3LjxCUj5UaGlzIHZpZXcgcmVjb3JkcyBub3RpZmljYXRpb25zIGZyb20gdGhlIHNlcnZlcgoJc2VudCBpbiB0aGUgc2hhcGUgb2YgYSBTZXJ2ZXJFdmVudC4gVGhlIHZpZXcgaXMgY29uc2lzdGVudCB3aXRoIHRoZSBFcnJvckxvZyBvZiB0aGUgUERFIHBsdWctaW4gYW5kIGl0IHdyYXBzIGEgVGFibGVWaWV3ZXIuIFRoZSBlbnRyaWVzCglhcmUgb2Ygb3VyIG93biB0eXBlIFNlcnZlckxvZ0VudHJ5LCB3aGljaCB3cmFwcyB2YXJpb3VzIGRldGFpbHMgYWJvdXQgdGhlIGV2ZW50LCBzdWNoIGFzIHRoZSBzZXZlcml0eSwKCWRldGFpbGVkIG1lc3NhZ2UsIGNvZGUsIHNlcnZlciBuYW1lLiA8QlI+SW4gb3VyIGV4YW1wbGUsIHRoZSB0eXBlIG9mIGV2ZW50cyB0aGF0IGFyZSByZWNvcmRlZCBhcmUgIHNlcnZlciBzdGFydGVkIGFuZCBzdG9wcGVkLCBhbmQgYW4gYWxhcm0gZXZlbnQuIEZvciBpbGx1c3RyYXRpb24gcHVycG9zZXMsIHdlIGhhdmUgZGVmaW5lZCBhIChjb25maWd1cmFibGUpIGxpbWl0IG9mICB0ZW4gZW50cmllcwphcyBtYXhpbXVtIHRvIGJlIGhlbGQgYnkgYSBzZXJ2ZXIgYW5kIHdlIGNhbiBzZWUgdGhlIGV2ZW50IGJlaW5nIHJlcG9ydGVkIHdoZW4gdGhpcyBudW1iZXIgaXMgcmVhY2hlZC4gPC9QPgo8UCBhbGlnbj0iY2VudGVyIj48aW1nIGJvcmRlcj0iMCIgc3JjPSJpbWFnZXMvbG9nVmlldy5qcGciPjxCUj4KICBGaWd1cmUgOC4gTW9uaXRvciBsb2cgdmlldyA8L1A+CjxQPgpUaGUgZXZlbnRzIGFyZSAgZ2VuZXJhdGVkIGJ5IHRoZSBiYWNrZ3JvdW5kIHRocmVhZCBvZiB0aGUgc2VydmVyIG1vZGVsIHRoYXQgbW9uaXRvcnMgdGhlIHJlbW90ZSBzZXJ2ZXJzLiAgIElmIG9uZSBvZiB0aGUgc2VydmVycyBpcyBraWxsZWQgZXh0ZXJuYWxseSB5b3UgY2FuIHNlZSB0aGUgc2VydmVyJ3Mgc3RhdGUgYmVpbmcgdXBkYXRlZCB0byBzdG9wIGFuZCBhIHN0b3BwZWQgZXZlbnQgYmVpbmcgZ2VuZXJhdGVkLjwvUD48UD4gVGhpbmtpbmcgYmFjayB0byB0aGUgZGFzaGJvYXJkLCAgIGlmIGEgd2FybmluZyByZWQgbGlnaHQgc2hvd3MgYW4gdW51c3VhbCBjb25kaXRpb24sIHRoZXJlJ3MgdXN1YWxseSBmdXJ0aGVyIGludmVzdGlnYXRpb24gcmVxdWlyZWQuIFRoZSBleHBlcmllbmNlZCBtZWNoYW5pYyAgd2FudHMgdG8gb3BlbiB0aGUgaG9vZCB0byBzZWUgdGhlIGludGVybmFsIHdvcmtpbmdzIG9mCnRoZSBydW5uaW5nIHN5c3RlbS4gSW4gb3VyIGV4YW1wbGUsICB3aGVuIHRoZSAgc2VydmVyIGFuZCB0aGUgbG9nIHZpZXdzIHByb3ZpZGUgYW4gaW5kaWNhdGlvbiBvZiBhIHByb2JsZW0sIHRoZSBhZG1pbmlzdHJhdG9yIG1pZ2h0IHdhbnQgdG8KZGlnIGRlZXBlciB0byBjaGVjayB0aGUgc3RhdGUgb2YgdGhlIHNlcnZlci4gPFA+CkluIG91ciBleGFtcGxlIHdlIGhhdmUgdGhlIFNlcnZlckNvbnRlbnRWaWV3IGluIHRoZSByaWdodCBoYW5kIG9mIHRoZQpwZXJzcGVjdGl2ZS4gVGhpcyBzaG93cyB0aGUgZGV0YWlscyBvZiBvdXIgUGhvbmVCb29rU2VydmVyLCBuYW1lbHkgdGhlCm5hbWVzIGFuZCBwaG9uZSBudW1iZXJzICBjb3JyZXNwb25kaW5nIHRvIHRoZSBzZXJ2ZXIKc2VsZWN0ZWQgaW4gdGhlIFNlcnZlcnMgdmlldy4gSWYgdGhlIHNlcnZlciBpcyBzdG9wcGVkLCB0aGVyZSBpcyBubwpkZXRhaWxlZCBjb250ZW50LjwvUD4KPEgyPjxBIG5hbWU9ImxhdW5jaFNlcnZlclNlY3Rpb24iPjwvQT5MYXVuY2hpbmcgc2VydmVyIGluc3RhbmNlcwk8L0gyPgo8UD4KV2hlbiBkZXZlbG9waW5nIGFwcGxpY2F0aW9ucyBkZXN0aW5lZCB0byBydW4gaW4gYSBzZXJ2ZXIgZW52aXJvbm1lbnQsIGl0knMgdXNlZnVsIHRvIGhhdmUgYW4gaW5zdGFuY2Ugb2YgdGhlIHRhcmdldCBzZXJ2ZXIgdW5kZXIgdGhlCmNvbnRyb2wgb2YgdGhlIGRldmVsb3BtZW50IGVudmlyb25tZW50LiBUaGlzIGFsbG93cyB0aGUgZGV2ZWxvcG1lbnQgZW52aXJvbm1lbnQgliBpLmUuIHRoZSB3b3JrYmVuY2ggliB0byBiZSB0aGUgc2luZ2xlIHBvaW50IG9mCmNvbnRyb2wgZm9yIHJ1bm5pbmcgdGhlIGFwcGxpY2F0aW9uIHVuZGVyIGRldmVsb3BtZW50LiAoSWYgdGhlIHNlcnZlciBpdHNlbGYgaXMgdGhlIGFwcGxpY2F0aW9uIGJlaW5nIGRldmVsb3BlZCwgdGhlIHBpY3R1cmUgY2hhbmdlcyBhCmxpdHRsZS4pIEEgc2FtcGxlIHVzZSBpcyBhIHRlc3QgZW52aXJvbm1lbnQsIHRob3VnaCB0aGlzIGZ1bmN0aW9uIGlzIG5vdCBsaW1pdGVkIHRvIGl0LjxQPgpJZiB0aGUgc2VydmVyIGlzIGEgc2VwYXJhdGUsIGV4aXN0aW5nIGFwcGxpY2F0aW9uLCB3ZSBuZWVkIGEgd2F5IG9mIGxhdW5jaGluZyBpdCBmcm9tIHRoZSB3b3JrYmVuY2ggd2hpbGUgbWFraW5nIGl0cyBvdXRwdXQgdmlzaWJsZSB0byB0aGUgZGV2ZWxvcGVyLiBJbiBvcmRlciB0byBkbyB0aGlzIHdlIHVzZSB0aGUgZnJhbWV3b3JrIGRlc2NyaWJlZCBpbiA8QQoJaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9hcnRpY2xlcy9BcnRpY2xlLUphdmEtbGF1bmNoL2xhdW5jaGluZy1qYXZhLmh0bWwiPkxhdW5jaGluZwpKYXZhIEFwcGxpY2F0aW9uIHByb2dyYW1tYXRpY2FsbHk8L0E+Lgo8SDM+ClRoZSBTZXJ2ZXJMYXVuY2hlciBjbGFzcwo8L0gzPgo8UD4KQW4gaW5zdGFuY2Ugb2YgYSBzZXJ2ZXIgbGF1bmNoZXIgaXMgYXNzb2NpYXRlZCB3aXRoIGVhY2ggc2VydmVyIGluc3RhbmNlIHRoYXSScyBkZWZpbmVkIGFzIGxvY2FsLiAoVGhlIGxvY2FsIHByb3BlcnR5IGV4aXN0cyBpbiBvcmRlciBmb3IgdXMKdG8gZGV0ZXJtaW5lIHdoZXRoZXIgb3Igbm90IHdlIGNhbiBsYXVuY2ggdGhlIGRlZmluZWQgc2VydmVyIGFzIGEgbG9jYWwgcHJvY2Vzcy4pLgogVGhlIGxhdW5jaGVyIGlzIHNldCBvbiB0aGUgPFNBTVA+c3RhcnQ8L1NBTVA+IG1ldGhvZCBvb2YgdGhlIFNlcnZlckVsZW1lbnQgYW5kIG51bGxlZCB1cCBvbiB0aGUgPFNBTVA+c3RvcDwvU0FNUD4KYW5kIGlzIHVzZWQgdG8gZGV0ZXJtaW5lIHRoZSBzdGFydGVkL3N0b3BwZWQgc3RhdHVzLiBUaGUgc3RlcHMgbmVjZXNzYXJ5IHRvIGxhdW5jaCBvdXIgcGhvbmUgc2VydmVyIGFyZSBkZXRhaWxlZCBiZWxvdzo8L1A+CjxVTD4KCTxMST5nZXRzIHRoZSBsYXVuY2ggbWFuYWdlciA8Q09ERT48SU1HIGhlaWdodD0iMTMiCgkJc3JjPSJpbWFnZXMvdGFnXzEuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+PC9DT0RFPjwvTEk+Cgk8TEk+Y29uc3RydWN0cyBhIGxhdW5jaCBjb25maWd1cmF0aW9uIHR5cGUgYW5kIGNvcHkgPENPREU+PElNRwoJCWhlaWdodD0iMTMiIHNyYz0iaW1hZ2VzL3RhZ18yLmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPjwvQ09ERT48L0xJPgoJPExJPnNldCB0aGUgYXR0cmlidXRlcyBhbmQgY2xhc3NwYXRoIDxDT0RFPjxJTUcgaGVpZ2h0PSIxMyIKCQlzcmM9ImltYWdlcy90YWdfMy5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj48L0NPREU+PC9MST4KCTxMST5sYXVuY2ggdGhlIGNvbmZpZ3VyYXRpb24gPENPREU+PElNRyBoZWlnaHQ9IjEzIgoJCXNyYz0iaW1hZ2VzL3RhZ180LmdpZiIgd2lkdGg9IjI0IiBib3JkZXI9IjAiPjwvQ09ERT48L0xJPgo8L1VMPgo8QkxPQ0tRVU9URT48UFJFPgpwdWJsaWMgSUxhdW5jaCBsYXVuY2ggKFN0cmluZyBtYWluQ2xhc3NuYW1lLCBTdHJpbmcgYXJncykgdGhyb3dzIElPRXhjZXB0aW9uLCBDb3JlRXhjZXB0aW9uIHsKPElNRyBoZWlnaHQ9IjEzIiBzcmM9ImltYWdlcy90YWdfMS5naWYiIHdpZHRoPSIyNCIgYm9yZGVyPSIwIj4gIElMYXVuY2hNYW5hZ2VyIG1hbmFnZXIgPSBEZWJ1Z1BsdWdpbi5nZXREZWZhdWx0ICgpLmdldExhdW5jaE1hbmFnZXIgKCk7CiAgICBJTGF1bmNoQ29uZmlndXJhdGlvblR5cGUgdHlwZSA9IG1hbmFnZXIuZ2V0TGF1bmNoQ29uZmlndXJhdGlvblR5cGUgCgkJCShJSmF2YUxhdW5jaENvbmZpZ3VyYXRpb25Db25zdGFudHMuSURfSkFWQV9BUFBMSUNBVElPTik7CjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzIuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+ICBJTGF1bmNoQ29uZmlndXJhdGlvbldvcmtpbmdDb3B5IGNvbmZpZyA9IHR5cGUubmV3SW5zdGFuY2UgKG51bGwsIG1haW5DbGFzc25hbWUpOwoJCQogICAgY29uZmlnLnNldEF0dHJpYnV0ZSAoSUphdmFMYXVuY2hDb25maWd1cmF0aW9uQ29uc3RhbnRzLkFUVFJfTUFJTl9UWVBFX05BTUUsIG1haW5DbGFzc25hbWUpOwogICAgY29uZmlnLnNldEF0dHJpYnV0ZSAoSUphdmFMYXVuY2hDb25maWd1cmF0aW9uQ29uc3RhbnRzLkFUVFJfUFJPR1JBTV9BUkdVTUVOVFMsIGFyZ3MpOwkJCjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzMuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+ICBzZXRDbGFzc3BhdGggKGNvbmZpZyk7CjxJTUcgaGVpZ2h0PSIxMyIgc3JjPSJpbWFnZXMvdGFnXzQuZ2lmIiB3aWR0aD0iMjQiIGJvcmRlcj0iMCI+ICByZXR1cm4gY29uZmlnLmxhdW5jaCAoSUxhdW5jaE1hbmFnZXIuUlVOX01PREUsIG5ldyBOdWxsUHJvZ3Jlc3NNb25pdG9yICgpKTsKfTwvUFJFPgo8UD5UaGUgPENPREU+c2V0Q2xhc3NwYXRoPC9DT0RFPiBtZXRob2QgY3JlYXRlcyB0aGUgbGlzdCBvZiBjbGFzc3BhdGggZW50cmllcyBieSBhZGRpbmcgdGhlIEpWTSBhbmQgYWxsIHRoZSByZXF1aXJlZCBwbHVnLWlucyBhbmQgbGlicmFyaWVzLiBGb3IgbW9yZSBkZXRhaWxzLCBzZWUgdGhlIGNvZGUuPC9QPgo8L0JMT0NLUVVPVEU+CgoJPEgyPlR5aW5nIGl0IGFsbCB0b2dldGhlcjwvSDI+CgkKCTxIMz5UaGUgbW9uaXRvciBwZXJzcGVjdGl2ZTwvSDM+Cgk8UD5BZG1pdHRlZGx5IGl0IGlzIGEgYmFkIGlkZWEgdG8gY3JlYXRlIHlvdXIgb3duIHBlcnNwZWN0aXZlIGluCglFY2xpcHNlLCB5b3Ugc2hvdWxkIGFpbSB0byByZXVzZSB0aGUgZXhpc3Rpbmcgb25lcy4gV2UgbWFkZSBhbgoJZXhjZXB0aW9uIGZvciB0aGlzIGFydGljbGUsIGJlY2F1c2Ugbm8gZXhpc3RpbmcgcGVyc3BlY3RpdmUgc2VlbSB0bwoJcXVpdGUgZml0IHdpdGggdGhlIHRhc2sgb2YgYWRtaW5pc3RlcmluZyBvYmplY3RzIGFuZCBmb3IgaWxsdXN0cmF0aW9uCglwdXJwb3NlLiA8UD4KCVdlIHVzZSB0aGUgPENPREU+b3JnLmVjbGlwc2UudWkucGVyc3BlY3RpdmVzPC9DT0RFPiBleHRlbnNpb24gcG9pbnQsCglnaXZpbmcgaXQgdGhlIGNsYXNzIGF0dHJpYnV0ZSB3aGljaCBtdXN0IGltcGxlbWVudCB0aGUgPENPREU+b3JnLmVjbGlwc2UudWkuSVBlcnNwZWN0aXZlRmFjdG9yeTwvQ09ERT4KCWludGVyZmFjZS4gVGhlIDxDT0RFPmNyZWF0ZUxheW91dDwvQ09ERT4gbWV0aG9kIGFycmFuZ2VzIHRoZSB2aWV3cyB0aGF0CglhcmUgcmVsZXZhbnQgdG8gb3VyIG1vbml0b3JpbmcgYXBwbGljYXRpb24uIFRoZSBsYXlvdXQgaXMgZGVmaW5lZAoJYXJvdW5kIHRoZSBlZGl0b3IgYXJlYSh0b3AtcmlnaHQgcGFydCkuIFdlIGRvbid0IGFjdHVhbGx5IGhhdmUgYW55dGhpbmcKCXRvIGVkaXQgc28gbWFrZSB0aGUgZWRpdG9yIGFyZWEgbm90IHZpc2libGUuIFRvIHRoZSBsZWZ0IG9mIGl0LCB0aGVyZQoJaXMgdGhlIHNlcnZlcnMgdmlldy4gUmVwbGFjaW5nIHRoZSBlZGl0b3IgYXJlYSBpcyBhIHZpZXcgdGhhdCBzaG93cwoJdGhlICBjb250ZW50IG9mIHRoZSBzZWxlY3RlZCBzZXJ2ZXIuIEF0IHRoZSBib3R0b20gb2YgdGhlIHBhZ2UsIHdlIHNob3cKCXRoZSBtb25pdG9yIHZpZXcgYW5kIGJlbG93IHRoZSBwcm9wZXJ0eSB2aWV3IAoJYW5kIHRoZSBjb25zb2xlIHZpZXcuPC9QPgoJPEgzPlNlcnZlciBwcmVmZXJlbmNlczwvSDM+Cgk8UD5XZSB1c2UgPENPREU+b3JnLmVjbGlwc2UudWkucHJlZmVyZW5jZVBhZ2VzPC9DT0RFPiBleHRlbnNpb24gcG9pbnQKCXdpdGggIDxDT0RFPlNlcnZlclByZWZlcmVuY2VQYWdlPC9DT0RFPiBhcyBpdHMgY2xhc3MgYXR0cmlidXRlIAoJdG8gZGVmaW5lIHR3byBvZiB0aGUgY29uZmlndXJhdGlvbiBhdHRyaWJ1dGVzIG9mIHRoZSBzZXJ2ZXIuIE9uZSBvZgoJdGhlbSBpcyBzcGVjaWZpYyB0byBvdXIgc2VydmVyLCB0aGUgbWF4aW11bSBudW1iZXIgb2YgZW50cmllcyB0aGF0IHRoZQoJcGhvbmUgZGlyZWN0b3J5IGFjY2VwdHMuIEFmdGVyIHRoaXMgbnVtYmVyIGlzIHJlYWNoZWQsIGFsYXJtcyBhcmUgc2VudAoJdG8gdGhlIGxvZyB2aWV3IGlmIG1vcmUgZW50cmllcyBhcmUgYWRkZWQuIDxQPgoJVGhlIHNlY29uZCBwYXJhbWV0ZXIgaXMgbW9yZSBnZW5lcmljIGFuZCBjb3VsZCBiZSB1c2VkIGZvciBvdGhlcgoJc2VydmVycy4gSXQgZGVzY3JpYmVzIHRoZSByZWZyZXNoIGludGVydmFsIHRoYXQgdGhlIHNhbXBsZSB1c2VzIGFyZSB0bwoJbWFpbnRhaW4gdGhlIHN0YXR1cyBvZiB0aGUgY29ubmVjdGlvbnMgdXAgdG8gZGF0ZS4gVGhlIGxpbmUgZnJvbSBiZWxvdyBpcyB1c2VkIHRvIGV4dHJhY3QgdGhlIHByZWZlcnJlZCB2YWx1ZSBvZiBhIHBhcmFtZXRlciBmcm9tIHRoZSBwcmVmZXJlbmNlIHN0b3JlIGFzc29jaWF0ZWQgd2l0aCBvdXIgcGx1Zy1pbi48UD4KPENPREU+U2VydmVyc1BsdWdpbi5nZXREZWZhdWx0KCkuZ2V0UHJlZmVyZW5jZVN0b3JlKCkuZ2V0SW50KCJNQVhJTVVNX0VOVFJJRVMiKTwvQ09ERT48L1A+CgoKCTxIMj48QSBuYW1lPSJzZXJ2ZXJTZWN0aW9uIj5TZXJ2ZXI8L0E+PC9IMj4KCTxQIGFsaWduPSJsZWZ0Ij5UaGUgc2VydmVyIHdlJ3ZlIHN1cHBsaWVkIGluIG91ciBleGFtcGxlIGlzIGEgc2ltcGxlIEhUVFAgc2VydmVyIHJlcHJlc2VudGluZyBhIHBob25lIGJvb2suIFRoZSBzZXJ2ZXIgaG9sZHMgYSBzZXQgb2YgcGhvbmUgbnVtYmVyIGVudHJpZXMgaW4gYSBQcm9wZXJ0aWVzIG9iamVjdCwgYW5kIHN1cHBvcnRzIGEgaGFuZGZ1bCBvZiBIVFRQIHJlcXVlc3RzIHRvIHF1ZXJ5IGFuZCB1cGRhdGUgdGhlIGNvbnRlbnQuIFRoZSByZXF1ZXN0cyBzdXBwb3J0ZWQgYXJlCjxVTD4KCTxMST48Q09ERT4vbG9va3VwP25hbWU9bmFtZTwvQ09ERT46IHJldHVybnMgdGhlIHBob25lIG51bWJlciBlbnRyeSBmb3IgdGhlIGdpdmVuIG5hbWU8L0xJPgoJPExJPjxDT0RFPi9yZW1vdmU/bmFtZT1uYW1lPC9DT0RFPjogcmVtb3ZlcyB0aGUgcGhvbmUgbnVtYmVyIGVudHJ5IGZvciB0aGUgZ2l2ZW4gbmFtZTwvTEk+Cgk8TEk+PENPREU+L3VwZGF0ZT9uYW1lPW5hbWUmYW1wO3ZhbHVlPXZhbHVlPC9DT0RFPjogY3JlYXRlcyBvciB1cGRhdGVzIHRoZSBwaG9uZSBudW1iZXIgZW50cnkgZm9yIHRoZSBnaXZlbiBuYW1lPC9MST4KCTxMST48Q09ERT4vY291bnQ8L0NPREU+OiByZXR1cm5zIHRoZSBudW1iZXIgb2YgcGhvbmUgbnVtYmVyIGVudHJpZXMgc3RvcmVkIGluIHRoZSBzZXJ2ZXI8L0xJPgoJPExJPjxDT0RFPi9pbmZvPC9DT0RFPjogcmV0dXJucyBhIHZlcnNpb24gc3RyaW5nPC9MST4KCTxMST48Q09ERT4vPC9DT0RFPjogcmV0dXJucyB0aGUgc2VydmVyJ3Mgc2V0IG9mIGVudHJpZXM8L1VMPgo8UD4gTXVjaCBvZiB0aGUgc2VydmVyJ3MgY29kZSBpcyB0aGVyZSBzaW1wbHkgdG8gaW1wbGVtZW50IGp1c3QgZW5vdWdoIG9mIHRoZSAKICBIVFRQIDEuMSBwcm90b2NvbCB0byBzdXBwb3J0IHRoZSBuZWNlc3Nhcnkgb3BlcmF0aW9ucy4gV2UgdXNlIGEgUGhvbmVCb29rQ2xpZW50IAogIG9iamVjdCB0byBjb25zdHJ1Y3QgdGhlIG5lY2Vzc2FyeSBxdWVyaWVzIGFuZCBoYW5kbGUgdGhlIHJlc3BvbnNlcy4gQSBqYXZhLm5ldC5VUkxDb25uZWN0aW9uIAogIHByb3ZpZGVzIHRoZSBjbGllbnQtc2lkZSBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgSFRUUCBwcm90b2NvbCwgYW5kIHRoZSBQaG9uZUJvb2tDbGllbnQgCiAgc2ltcGx5IGNyZWF0ZXMgVVJMQ29ubmVjdGlvbiBpbnN0YW5jZXMgd2l0aCB0aGUgYXBwcm9wcmlhdGUgcmVxdWVzdCBVUkkgZm9yIAogIGVhY2ggb3BlcmF0aW9uLjwvUD4KPEgyPjxBIG5hbWU9InJlc291cmNlU2VjdGlvbiI+PC9BPlJlc291cmNlczwvSDI+Cgo8UD4gPEEgaHJlZj0ibW9uaXRvclBsdWdpbi5qYXIiPk1vbml0b3Igc2FtcGxlPC9BPjwvUD4KPFA+PFNNQUxMPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYW5kIGxvZ29zIGFyZSB0cmFkZW1hcmtzIG9yCnJlZ2lzdGVyZWQgdHJhZGVtYXJrcyBvZiBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIGluIHRoZSBVbml0ZWQgU3RhdGVzLApvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguIDxCUj4KT3RoZXIgY29tcGFueSwgcHJvZHVjdCBvciBzZXJ2aWNlIG5hbWVzIG1heSBiZSB0cmFkZW1hcmtzIG9yIHNlcnZpY2UgbWFya3Mgb2Ygb3RoZXJzCjwvU01BTEw+CjwvUD4KPC9CT0RZPjwvSFRNTD4K