PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMCBUcmFuc2l0aW9uYWwvL0VOIj4NCjxodG1sPg0KPGhlYWQ+DQo8dGl0bGU+RHluYW1pYyB1c2VyIGFzc2lzdGFuY2UgaW4gRWNsaXBzZS1iYXNlZCBhcHBsaWNhdGlvbnM8L3RpdGxlPg0KPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIg0KCWNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPg0KPGxpbmsgaHJlZj0iLi4vYXJ0aWNsZS5jc3MiIHR5cGU9InRleHQvY3NzIiByZWw9InN0eWxlc2hlZXQiPg0KPC9oZWFkPg0KPGJvZHk+DQoNCjxoMT5EeW5hbWljIFVzZXIgQXNzaXN0YW5jZSBpbiBFY2xpcHNlLUJhc2VkIEFwcGxpY2F0aW9uczwvaDE+DQo8ZGl2IGNsYXNzPSJzdW1tYXJ5Ij4NCjxoMj5TdW1tYXJ5PC9oMj4NCjxwPkRldmVsb3BtZW50IGVudmlyb25tZW50cyBoYXZlIGJlY29tZSB2ZXJ5IGNvbXBsZXguIEFzIGEgcmVzdWx0LCBwcm92aWRpbmcgdXNlcnMgd2l0aCANCmNvbnRleHQgcmVsZXZhbnQgYXNzaXN0YW5jZSBpcyBjcml0aWNhbCB0byBoZWxwaW5nIHRoZW0gc3VjY2VlZCB3aXRoIHlvdXIgdG9vbHMgYW5kIA0KYXBwbGljYXRpb25zLiBUaGlzIGFydGljbGUgd2lsbCBpbnRyb2R1Y2UgeW91IHRvIEVjbGlwc2UncyBwb3dlcmZ1bCBEeW5hbWljIEFzc2lzdGFuY2UgDQpmcmFtZXdvcmsgYW5kIHByb3ZpZGUgZXhhbXBsZXMgdGhhdCBpbGx1c3RyYXRlIGhvdyB5b3UgY2FuIHRha2UgZnVsbCBhZHZhbnRhZ2Ugb2YgaXRzIA0KY2FwYWJpbGl0aWVzLjwvcD4NCjxkaXYgY2xhc3M9ImF1dGhvciI+QnkgSm9lIFBlc290LCBJQk0gQ29ycG9yYXRpb247IEplZmYgQW50bGV5LCBJQk0gQ29ycG9yYXRpb247IGFuZCBBYXJvbiBBbGxzYnJvb2ssIElCTSBDb3Jwb3JhdGlvbjwvZGl2Pg0KPGRpdiBjbGFzcz0iY29weXJpZ2h0Ij5Db3B5cmlnaHQgqSAyMDA4IElCTSBDb3Jwb3JhdGlvbiwgU291cmNlIGNvZGUgaW4gdGhpcyBhcnRpY2xlIGlzIG1hZGUgYXZhaWxhYmxlIHVuZGVyIA0KICB0aGUgRVBMLCB2MS4wLCByZW1haW5kZXIgb2YgdGhlIHByZXNlbnRhdGlvbiBpcyBsaWNlbnNlZCB1bmRlciBDcmVhdGl2ZSBDb21tb25zIEF0dC4gTmMgTmQgMi41IGxpY2Vuc2U8YnI+DQombmJzcDs8L2Rpdj4NCjxkaXYgY2xhc3M9ImRhdGUiPk5vdmVtYmVyIDUsIDIwMDg8L2Rpdj4NCjwvZGl2Pg0KDQo8ZGl2IGNsYXNzPSJjb250ZW50Ij4NCgk8aDI+SW50cm9kdWN0aW9uPC9oMj4NCiAgICAgIDxwPkZvciB5ZWFycywgc29mdHdhcmUgZGV2ZWxvcGVycyBoYXZlIGxvb2tlZCBmb3IgYmV0dGVyIHdheXMgdG8gcHJvdmlkZSB1c2VycyB3aXRoIG1vcmUgdGltZWx5IGluZm9ybWF0aW9uIHRvIGhlbHAgdGhlbSBiZSBzdWNjZXNzZnVsLiAgDQogICAgICAgV2h5PyAgSWYgdXNlcnMgaGF2ZSB0byByZWd1bGFybHkgZW5nYWdlIGFuZCBodW50IHRocm91Z2ggYSBsYXJnZSBIZWxwIHN5c3RlbSwgdGhleSdsbCBiZWNvbWUgZnJ1c3RyYXRlZC4gIE9wZW5pbmcgdGhlIEhlbHAgDQogICAgICAgc3lzdGVtIGlzIGFuIG92ZXJ0IGFjdGlvbiB0aGF0IHRoZSB1c2VyIG11c3QgdGFrZSB0byBnZXQgaW5mb3JtYXRpb24uICBCZWNhdXNlIGl0IGlzIGFuIG92ZXJ0IGFjdGlvbiwgaXQgaW50ZXJydXB0cyB0aGUgdXNlcidzIHRhc2suPC9wPg0KICAgICAgPHA+RnJvbSBhIHVzYWJpbGl0eSBwZXJzcGVjdGl2ZSwgaXQgd291bGQgYmUgbXVjaCBtb3JlIGVmZmljaWVudCBmb3IgdGhlIHVzZXIgaWYgY29udGV4dC1yZWxldmFudCBpbmZvcm1hdGlvbiB3ZXJlIGR5bmFtaWNhbGx5IHByZXNlbnRlZCwgDQogICAgICAgIGltbWVkaWF0ZWx5IGF2YWlsYWJsZSwgYW5kIGVhc2lseSB2aXNpYmxlIHdoaWxlIHRoZSB1c2VyIGNvbnRpbnVlcyB0byB3b3JrLiAgSWYgaW5mb3JtYXRpb24gY291bGQgYmUgcHJlc2VudGVkIGluIHRoaXMgZmFzaGlvbiwgdXNlcnMgDQogICAgICAgIHdvdWxkIGJlIGFibGUgdG8gZW5nYWdlIHRhcmdldGVkIGluZm9ybWF0aW9uIHdpdGhvdXQgc2lnbmlmaWNhbnQgZGlzcnVwdGlvbiB0byB0aGVpciB0YXNrcy4gIFRoZSBjaGFsbGVuZ2UgaGFzIGJlZW4gdGhhdCBtZWNoYW5pc21zIA0KICAgICAgICBmb3IgcHJlc2VudGluZyBpbmZvcm1hdGlvbiBpbiB0aGlzIGZhc2hpb24gaGF2ZSBiZWVuIGxhY2tpbmcuICBGb3J0dW5hdGVseSwgdGhlIGxhdGVzdCB2ZXJzaW9ucyBvZiBFY2xpcHNlIGluY2x1ZGUgbmV3IChhbmQgZXZvbHZpbmcpIA0KICAgICAgICBtZWNoYW5pc21zIGZvciBwcm92aWRpbmcgZHluYW1pYyBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwLjwvcD4NCiAgICAgIDxwPlRvIGhlbHAgeW91IHVuZGVyc3RhbmQgYW5kIGxldmVyYWdlIHRoZXNlIG1lY2hhbmlzbXMsIHRoaXMgYXJ0aWNsZSB3aWxsIGJlZ2luIGJ5IHByb3ZpZGluZyBhIGZldyBzaW1wbGUgZXhhbXBsZXMgb2YgdGhlIGJhc2ljIA0KICAgICAgICBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIGZvdW5kIGluIEVjbGlwc2UsIGRpc2N1c3NpbmcgdGhlbSBmcm9tIHRoZSB1c2VyJ3MgcGVyc3BlY3RpdmUuICBOZXh0LCB3ZSdsbCBsb29rIGF0IGEgc2ltcGxlIGV4YW1wbGUgb2YgaG93IHlvdSANCiAgICAgICAgY2FuIHRha2UgYWR2YW50YWdlIG9mIEVjbGlwc2UncyBoZWxwIGZyYW1ld29yayBkaXJlY3RseSwgd2l0aCBubyBhZGRpdGlvbmFsIHByb2dyYW1taW5nIHJlcXVpcmVkLiAgRmluYWxseSwgd2UnbGwgdXNlIGEgc21hbGwgc2FtcGxlIA0KICAgICAgICBhcHBsaWNhdGlvbiAoYmFzZWQgb24gdGhlIHNhbXBsZSBFTUYgTGlicmFyeSBFZGl0b3IpIHRvIGRlc2NyaWJlIGhvdyB5b3UgY2FuIGV4dGVuZCB0aGUgYmFzaWMgY2FwYWJpbGl0aWVzIHByb3ZpZGVkIGJ5IEVjbGlwc2UsIHRoZXJlYnkgDQogICAgICAgIHNpZ25pZmljYW50bHkgaW5jcmVhc2luZyB0aGUgZXh0ZW50IHRvIHdoaWNoIHlvdXIgY2FuIHByb3ZpZGUgZHluYW1pYyBjb250ZXh0LXNlbnNpdGl2ZSBpbmZvcm1hdGlvbi4gIEZvciB0aGlzIGV4YW1wbGUsIHdlIA0KCSAgaW1wbGVtZW50IHRoZSBmb2xsb3dpbmcgbWV0aG9kcyBmcm9tIHRoZSBJQ29udGV4dFByb3ZpZGVyIGNsYXNzOg0KCSAgPHVsPg0KCSAgPGxpPmdldENvbnRleHRDaGFuZ2VNYXNrIC0gVGhpcyBtZXRob2QgcmV0dXJucyBmbGFncyBpbmRpY2F0aW5nIHdoaWNoIHR5cGVzIG9mIGV2ZW50cyBzaG91bGQgdHJpZ2dlciBhIGNvbnRleHQgaGVscCB1cGRhdGUuPC9saT4NCgkgIDxsaT5nZXRDb250ZXh0IC0gVGhpcyBtZXRob2QgcmV0dXJucyBhIGhlbHAgY29udGV4dCBmb3IgdGhlIGdpdmVuIHRhcmdldC4gVGhlIG51bWJlciBvZiB0aW1lcyB0aGlzIG1ldGhvZCB3aWxsIGJlIGNhbGxlZCBkZXBlbmRzIG9uIHRoZSANCgkgIGNvbnRleHQgY2hhbmdlIG1hc2suIFN0YXRpYyBjb250ZXh0IHByb3ZpZGVycyB3aWxsIGJlIGNhbGxlZCBlYWNoIHRpbWUgdGhlIG93bmVyIG9mIHRoZSB0YXJnZXQgaXMgYWN0aXZhdGVkLiBJZiBjaGFuZ2UgdHJpZ2dlcnMgYXJlIHVzZWQsIA0KCSAgdGhlIG1ldGhvZCB3aWxsIGJlIGNhbGxlZCBlYWNoIHRpbWUgdGhlIHRyaWdnZXIgb2NjdXJzLjwvbGk+DQoJICA8bGk+Z2V0U2VhcmNoRXhwcmVzc2lvbiAtIFRoaXMgbWV0aG9kIHJldHVybnMgYSBzZWFyY2ggZXhwcmVzc2lvbiB0aGF0IGZpbmRzIG1vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIGN1cnJlbnQgdGFyZ2V0LiBJdCBjYW4gYmUgdXNlZCB0byANCgkgIHJldHVybiByZXN1bHRzIGZvciB0aGUgRHluYW1pYyBIZWxwIHNlY3Rpb24gb2YgdGhlIEhlbHAgdmlldy4gIFdlIHdpbGwgZGlzY3VzcyB0aGlzIG1ldGhvZCB0b3dhcmRzIHRoZSBlbmQgb2YgdGhlIGFydGljbGUuPC9saT4NCgkgIDwvdWw+DQoJPC9wPg0KDQogICAgICA8aDI+VGhlIFVzZXIncyBFeHBlcmllbmNlIG9mIENvbnRleHQtU2Vuc2l0aXZlIEhlbHAgPC9oMj4NCiAgICAgIDxwPlRoZSBiYXNpYyBpbnRlbnQgb2YgY29udGV4dCBzZW5zaXRpdmUgaGVscCBpcyB0byBiZSBhYmxlIHRvIHByZXNlbnQgdGhlIHVzZXIgd2l0aCBhIHNtYWxsIGFtb3VudCBvZiByZWxldmFudCBpbmZvcm1hdGlvbiBiYXNlZCBvbiB0aGUgDQogICAgICAgIG9iamVjdHMgdGhhdCB0aGV5IGFyZSBjdXJyZW50bHkgZW5nYWdpbmcgd2l0aGluIHRoZSBwcm9kdWN0IHVzZXIgaW50ZXJmYWNlIChVSSkuICBFY2xpcHNlJ3MgYmFzaWMgY29udGV4dC1zZW5zaXRpdmUgaGVscCBjYXBhYmlsaXRpZXMgYWxsb3cgDQogICAgICAgIHlvdSB0byBjcmVhdGUgaW5mb3JtYXRpb24gYWJvdXQgd2l6YXJkIHBhZ2VzLCB2aWV3cywgYW5kIGVkaXRvcnMuICBCeSBkb2luZyBzbywgYXMgdGhlIHVzZXIgbW92ZXMgZnJvbSB2aWV3IHRvIHZpZXcgb3IgZWRpdG9yIHRvIGVkaXRvciwgDQogICAgICAgIHRoZSBpbmZvcm1hdGlvbiBwcmVzZW50ZWQgaW4gdGhlIEhlbHAgdmlldyBjaGFuZ2VzLjwvcD4NCiAgICAgIDxwPlRvIHNlZSB0aGlzIGZvciB5b3Vyc2VsZiwgZm9sbG93IHRoZXNlIHN0ZXBzOg0KICAgICAgICA8b2w+DQogICAgICAgICAgPGxpPk9wZW4geW91ciBFY2xpcHNlIHdvcmtiZW5jaC48L2xpPg0KICAgICAgICAgIDxsaT5Td2l0Y2ggdG8gdGhlIEphdmEgcGVyc3BlY3RpdmUuPC9saT4NCiAgICAgICAgICA8bGk+Q2xpY2sgPGI+SGVscCAmZ3Q7IER5bmFtaWMgSGVscDwvYj4gKHRoZSBIZWxwIHZpZXcgb3BlbnMpLjwvbGk+DQogICAgICAgICAgPGxpPlNlbGVjdCB0aGUgPGI+SGllcmFyY2h5IHZpZXc8L2I+LjwvbGk+DQogICAgICAgIDwvb2w+DQogICAgICA8L3A+DQogICAgICA8cD5JZiB0aGUgZHluYW1pYyBoZWxwIHZpZXcgaXMgeW91ciBkZWZhdWx0IGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgbWVjaGFuaXNtIChXaW5kb3dzICZndDsgUHJlZmVyZW5jZXMgJmd0OyBIZWxwKSwgdGhlIEhlbHAgdmlldyBzaG91bGQgDQogICAgICAgIG5vdyBsb29rIHNvbWV0aGluZyBsaWtlIEZpZ3VyZSAxLjwvcD4gIA0KICAgICAgICA8cD5JZiB5b3Ugc2VsZWN0IHZhcmlvdXMgdmlld3MgYW5kIGVkaXRvcnMgaW4geW91ciB3b3JrYmVuY2gsIHlvdSB3aWxsIG5vdGljZSB0aGF0IHRoZSB0d28gc2VjdGlvbnMgb2YgdGhlIA0KICAgICAgICBIZWxwIHZpZXcgY2hhbmdlLiAgVGhlIHRvcCBzZWN0aW9uLCBBYm91dCBIaWVyYXJjaHkgdmlldywgZGVzY3JpYmVzIHRoZSBIaWVyYXJjaHkgdmlldyBhbmQgcHJvdmlkZXMgYSBmZXcgdGFyZ2V0ZWQgbGlua3Mgd2hlcmUgDQogICAgICAgIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gaXMgYXZhaWxhYmxlLiBUaGUgbmV4dCBzZWN0aW9uLCBjYWxsZWQgRHluYW1pYyBIZWxwLCBwcm92aWRlcyBhIGxvbmdlciBsaXN0IG9mIGxpbmtzLiAgVGhpcyBzZXQgb2YgbGlua3MgaXMgdGhlIHJlc3VsdCANCiAgICAgICAgb2YgYW4gYXV0b21hdGljIHNlYXJjaCBxdWVyeSB0aGF0IGlzIGJ1aWx0IGFuZCBydW4gYnkgdGhlIEVjbGlwc2UgZHluYW1pYyBhc3Npc3RhbmNlIGZyYW1ld29yay4gIFRoZSBiYXNpYyBxdWVyeSBjb21iaW5lcyB0aGUgdmlldyBvciANCiAgICAgICAgZWRpdG9yIG5hbWUsIGFuZCB0aGUgY3VycmVudCBwZXJzcGVjdGl2ZSwgcGVyZm9ybXMgYSBzZWFyY2ggb2YgdGhlIEhlbHAgc3lzdGVtLCBhbmQgcmV0dXJucyB0aGUgdG9wIGl0ZW1zIGZyb20gdGhlIHJlc3VsdHMgbGlzdC48L3A+DQogICAgICANCiAgICAgICAgPGJyIC8+PGEgbmFtZT0iZmlnMSI+PGI+RmlndXJlIDEuIFRoZSBIZWxwIFZpZXc8L2I+PC9hPjxiciAvPg0KICAgICAgICA8aW1nIHNyYz0iaW1hZ2VzL2ZpZ3VyZTEuanBnIiB3aWR0aD0iMjY3IiBoZWlnaHQ9IjQyNiIgYWx0PSJUaGUgSGVscCBWSWV3Ii8+DQogICAgICA8YnIgLz4NCiAgICAgIDxiciAvPg0KICAgICAgPHA+SW4gYWRkaXRpb24gdG8gcHJvdmlkaW5nIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgZm9yIHZpZXdzIGFuZCBlZGl0b3JzLCBpdCBjYW4gYWxzbyBiZSB2ZXJ5IHVzZWZ1bCBmb3Igd2l6YXJkcy4gIFRvIHNlZSB0aGlzIGZvciB5b3Vyc2VsZiwgZm9sbG93DQogICAgICAgIHRoZXNlIHN0ZXBzOg0KICAgICAgICA8b2w+DQogICAgICAgICAgPGxpPlNlbGVjdCA8Yj5GaWxlICZndDsgTmV3ICZndDsgUHJvamVjdDwvYj4uIFRoZSBOZXcgUHJvamVjdCB3aXphcmQgYXBwZWFycy48L2xpPg0KICAgICAgICAgIDxsaT5TZWxlY3QgdGhlIDxiPnF1ZXN0aW9uIG1hcmsgaWNvbjwvYj4gaW4gdGhlIGxvd2VyIGxlZnQgY29ybmVyIG9mIHRoZSB3aXphcmQuICBBIEhlbHAgdmlldyBhcHBlYXJzLCBhdHRhY2hlZCB0byB0aGUgd2l6YXJkLjwvbGk+DQogICAgICAgIDwvb2w+DQogICAgICA8L3A+DQogICAgICA8cD5GaWd1cmUgMiBzaG93cyB0aGUgTmV3IFByb2plY3Qgd2l6YXJkIHdpdGggY29udGV4dC1zZW5zaXRpdmUgaGVscCBvcGVuZWQuPC9wPg0KICAgICAgDQogICAgICAgIDxiciAvPjxhIG5hbWU9ImZpZzIiPjxiPkZpZ3VyZSAyLiBUaGUgTmV3IFByb2plY3QgV2l6YXJkPC9iPjwvYT48YnIgLz4NCiAgICAgICAgPGltZyBzcmM9ImltYWdlcy9maWd1cmUyLmpwZyIgd2lkdGg9IjUzNSIgaGVpZ2h0PSI1MDQiIGFsdD0iVGhlIE5ldyBQcm9qZWN0IFdpemFyZCIvPg0KICAgICAgPGJyIC8+DQogICAgICA8YnIgLz4NCiAgICAgIDxwPlRvIHNlZSBob3cgdGhlIGhlbHAgY29udGVudCBjaGFuZ2VzLCBzZWxlY3QgYSA8Yj5wcm9qZWN0IHR5cGU8L2I+IGZyb20gdGhlIGxpc3QgYW5kIHRoZW4gc2VsZWN0IDxiPk5leHQ8L2I+LiAgVGhlIGhlbHAgb24gdGhlIHNlY29uZCBwYWdlIG9mIA0KICAgICAgICB0aGUgd2l6YXJkIHdpbGwgbm93IGluY2x1ZGUgZWxlbWVudHMgcmVsYXRlZCB0byB0aGUgdHlwZSBvZiBwcm9qZWN0IHNlbGVjdGVkLjwvcD4NCiAgICAgIDxwPkZvciBleGFtcGxlLCBGaWd1cmUgMyBzaG93cyB0aGUgaGVscCBmb3VuZCBvbiBwYWdlIHR3byBvZiB0aGlzIHdpemFyZCwgYXNzdW1pbmcgeW91IHNlbGVjdGVkIGFuIEVjbGlwc2UgTW9kZWxpbmcgRnJhbWV3b3JrIA0KICAgICAgICAoRU1GKSBwcm9qZWN0LiAgVGhlIER5bmFtaWMgSGVscCBzZWN0aW9uIGNoYW5nZXMgdG8gc2hvdyBpdGVtcyB3aGljaCByZWxhdGUgdG8gRU1GIGJhc2VkIHByb2plY3RzLjwvcD4NCiAgICAgIA0KICAgICAgICA8YnIgLz48YSBuYW1lPSJmaWczIj48Yj5GaWd1cmUgMy4gTmV3IEVNRiBQcm9qZWN0PC9iPjwvYT48YnIgLz4NCiAgICAgICAgPGltZyBzcmM9ImltYWdlcy9maWd1cmUzLmpwZyIgd2lkdGg9IjUzMyIgaGVpZ2h0PSI1NzIiIGFsdD0iTmV3IEVNRiBQcm9qZWN0Ii8+DQogICAgICA8YnIgLz4NCiAgICAgIDxiciAvPg0KICAgICAgPHA+VGhlIEhlbHAgdmlldyBjYW4gYmUgcGFydGljdWxhcmx5IHBvd2VyZnVsIGZvciBuZXcgdXNlcnMsIHdobyBvZnRlbiBiZWNvbWUgY29uZnVzZWQgYnkgdGhlIHdpZGUgYXJyYXkgb2Ygdmlld3MsIHBlcnNwZWN0aXZlcywgYW5kIA0KICAgICAgICB3aXphcmRzIHRoYXQgYXJlIGF2YWlsYWJsZS48L3A+DQogICAgICA8cD5UaGUgbmV4dCBzZWN0aW9uIG9mIHRoaXMgYXJ0aWNsZSB3aWxsIGRlc2NyaWJlIGhvdyB5b3UgY2FuIHRha2UgYWR2YW50YWdlIG9mIHRoaXMgYmFzaWMgY2FwYWJpbGl0eS48L3A+DQogICAgICA8cD48YSBuYW1lPSJkMGUzMDkiPjxzcGFuIGNsYXNzPSJhdGl0bGUiPkNyZWF0aW5nIENvbnRleHQtU2Vuc2l0aXZlIEhlbHAgZm9yIFdpemFyZHMsIFZpZXdzIGFuZCBFZGl0b3JzPC9zcGFuPjwvYT48L3A+DQogICAgICA8cD5TaW5jZSBFY2xpcHNlIGhhbmRsZXMgdGhlIGluZnJhc3RydWN0dXJlIGZvciB1cywgd2Ugb25seSBoYXZlIHRvIGRlZmluZSB0aHJlZSB0aGluZ3M6IGEgdW5pcXVlIGlkZW50aWZpZXIgKGtub3duIGFzIGEgY29udGV4dCBJRCksIHRoZSBwbGFjZSANCiAgICAgICAgd2Ugd2FudCBhIHBhcnRpY3VsYXIgY29udGV4dC1zZW5zaXRpdmUgaGVscCB0b3BpYyB0byBiZSBhdmFpbGFibGUsIGFuZCB0aGUgY29udGVudHMgb2YgdGhlIGhlbHAgdG9waWMuICBUaGUgZmlyc3QgdHdvIGFyZSBnZW5lcmFsbHkgZG9uZSBieSBhIGNvZGUgDQogICAgICAgIGRldmVsb3BlciwgYW5kIHRoZSB0aGlyZCBwYXJ0IGlzIGdlbmVyYWxseSBkb25lIGJ5IGEgdXNlciBhc3Npc3RhbmNlIGRldmVsb3BlciBvciBkb2N1bWVudGF0aW9uIHdyaXRlci48L3A+DQogICAgICA8cD5UbyBhdHRhY2ggYSBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIHRvcGljIHRvIGEgd2l6YXJkIHBhZ2UsIGZvciBleGFtcGxlLCB3ZSBmaXJzdCBuZWVkIHRvIGRlZmluZSBhIHVuaXF1ZSBjb250ZXh0IElELiAgQSBjb250ZXh0IElEIGlzIGEgDQogICAgICAgIHN0cmluZyB0aGF0IHNlcnZlcyBhcyBhbiBpZGVudGlmaWVyIGNvbm5lY3RpbmcgdGhlIFVJIGFuZCBhIHBhcnRpY3VsYXIgaGVscCB0b3BpYzsgaXQgY2FuIGNvbnRhaW4gbGV0dGVycywgbnVtYmVycywgYW5kIHRoZSB1bmRlcnNjb3JlIA0KICAgICAgICBjaGFyYWN0ZXIuICBUbyBhbGxvdyB0aGUgaGVscCB0b3BpYyB0byBleGlzdCBpbiBhIHNlcGFyYXRlIHBsdWdpbiAoYW4gYXJyYW5nZW1lbnQgdGhhdCBoYXMgbWFueSBhZHZhbnRhZ2VzKSwgd2UgbmVlZCB0byBtYWtlIHRoZSBjb250ZXh0IA0KICAgICAgICBJRCAiZnVsbHkgcXVhbGlmaWVkLCIgd2hpY2ggbWVhbnMgdGhhdCB3ZSB3YW50IHRvIHByZXBlbmQgdGhlIGNvZGUgcGx1Z2luJ3MgcGx1Z2luIElELjwvcD4gDQogICAgICAgIDxwPlNvLCBmb3Igb3VyIGV4YW1wbGUgd2l6YXJkIHBhZ2UsIHRoZSBmdWxseSBxdWFsaWZpZWQgDQogICAgICAgIGNvbnRleHQgSUQgaXMgIm9yZy5lY2xpcHNlLnVpLmlkZS5uZXdfcHJvamVjdF93aXphcmRfcGFnZV9jb250ZXh0Ii4gIFRoaXMgdmFsdWUgaXMgc2V0IA0KICAgICAgICBpbiBvcmcuZWNsaXBzZS51aS5pbnRlcm5hbC5pZGUvSUlERUhlbHBDb250ZXh0SWRzLmphdmEgKHdoZXJlIHRoZSBzdHJpbmcgSURFV29ya2JlbmNoUGx1Z2luLklERV9XT1JLQkVOQ0ggaXMgDQogICAgICAgIHNldCB0byBlcXVhbCAib3JnLmVjbGlwc2UudWkuaWRlIiwgdGhlIHBsdWdpbiBJRCBmb3IgdGhpcyBjb2RlIHBsdWdpbikuPC9wPiAgICAgIA0KICAgICAgPGJyIC8+PHByZT4gIA0KICAgICAgICBwdWJsaWMgaW50ZXJmYWNlIElJREVIZWxwQ29udGV4dElkcyB7DQogICAgICAgIAlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQUkVGSVggPSBJREVXb3JrYmVuY2hQbHVnaW4uSURFX1dPUktCRU5DSCArICIuIjsNCiAgICAgICAgCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIE5FV19QUk9KRUNUX1dJWkFSRF9QQUdFID0gUFJFRklYDQogICAgICAgIAkrICJuZXdfcHJvamVjdF93aXphcmRfcGFnZV9jb250ZXh0IjsgIA0KICAgICAgPC9wcmU+PGJyIC8+DQogICAgICA8cD5UaGUgZnVsbHkgcXVhbGlmaWVkIGNvbnRleHQgSUQgaXMgbm93IGRlZmluZWQgYW5kIGNvbnRhaW5lZCBpbiBhIHN0cmluZyBuYW1lZCAiSUlERUhlbHBDb250ZXh0SWRzLk5FV19QUk9KRUNUX1dJWkFSRF9QQUdFIi48L3A+DQogICAgICA8cD5UaGUgc2Vjb25kIHN0ZXAgaXMgdG8gYXR0YWNoIHRoZSBjb250ZXh0IElEIHRvIHRoZSB3aXphcmQgcGFnZS4gIEluIHRoZSBXaXphcmROZXdQcm9qZWN0Q3JlYXRpb25QYWdlLmphdmEgZmlsZSB0aGF0IGRlZmluZXMgdGhlIHdpemFyZCBwYWdlLCANCiAgICAgICAgdGhpcyBpcyBkb25lIHdpdGggdGhlIHNldEhlbHAoKSBtZXRob2Q6PC9wPg0KICAgICAgPGJyIC8+PHByZT4NCiAgICAgICAgcHVibGljIGNsYXNzIFdpemFyZE5ld1Byb2plY3RDcmVhdGlvblBhZ2UgZXh0ZW5kcyBXaXphcmRQYWdlIHsNCiAgICAgICAgCS4uLg0KICAgICAgICAJcHVibGljIHZvaWQgY3JlYXRlQ29udHJvbChDb21wb3NpdGUgcGFyZW50KSB7DQogICAgICAgIAlDb21wb3NpdGUgY29tcG9zaXRlID0gbmV3IENvbXBvc2l0ZShwYXJlbnQsIFNXVC5OVUxMKTsNCiAgICAgICAgCS4uLg0KICAgICAgICAJUGxhdGZvcm1VSS5nZXRXb3JrYmVuY2goKS5nZXRIZWxwU3lzdGVtKCkuc2V0SGVscChjb21wb3NpdGUsDQogICAgICAgIAlJSURFSGVscENvbnRleHRJZHMuTkVXX1BST0pFQ1RfV0laQVJEX1BBR0UpOw0KICAgICAgPC9wcmU+PGJyIC8+DQogICAgICA8cD5JZiB5b3UncmUgd29uZGVyaW5nIHdoeSB0aGUgPGNvZGU+c2V0SGVscDwvY29kZT4gbWV0aG9kIGRvZXNuJ3QganVzdCByZWZlciB0byBmdWxseSBxdWFsaWZpZWQgY29udGV4dCBJRCBpdHNlbGYsIGl0IGlzIHBvc3NpYmxlIHRvIA0KICAgICAgICBkbyB0aGF0LCBidXQgaWYgdGhlIGNvZGUgZXZlciB3ZXJlIHRvIG1vdmUgdG8gYSBkaWZmZXJlbnQgcGx1Z2luIG9yIHRoZSBwbHVnaW4gd2VyZSByZW5hbWVkLCBpdCB3b3VsZCBiZSBtb3JlIGRpZmZpY3VsdCB0byBmaW5kIGFuZCBjaGFuZ2UgYWxsIHRoZSANCiAgICAgICAgY29udGV4dCBJRCBkZWNsYXJhdGlvbnMuPC9wPg0KICAgICAgPHA+Tm93IHdlIGp1c3QgbmVlZCB0byBjcmVhdGUgdGhlIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgdG9waWMuICBUaGlzIGZpbmFsIHN0ZXAgaW52b2x2ZXMgdHdvIFhNTCBmaWxlczogYSBwbHVnaW4ueG1sIGZpbGUgYW5kIGEgY29udGV4dHMgZmlsZS4gIA0KICAgICAgICBMZXQncyBsb29rIGF0IHRoZSBjb250ZXh0cyBmaWxlLCBjb250ZXh0c19Xb3JrYmVuY2gueG1sLCBmaXJzdDo8L3A+DQogICAgICA8YnIgLz48cHJlPg0KICAgICAgICAmbHQ7P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJ1dGYtOCI/Jmd0Ow0KICAgICAgICAmbHQ7Y29udGV4dHMmZ3Q7DQogICAgICAgICAgLi4uDQogICAgICAgICAgJmx0O2NvbnRleHQgaWQ9Im5ld19wcm9qZWN0X3dpemFyZF9wYWdlX2NvbnRleHQiJmd0Ow0KICAgICAgICAgICAgJmx0O2Rlc2NyaXB0aW9uJmd0O1RoaXMgd2l6YXJkIGhlbHBzIHlvdSBjcmVhdGUgYSBuZXcgcHJvamVjdCBpbiB0aGUNCiAgICAgICAgICAgICAgd29ya2JlbmNoLiZsdDsvZGVzY3JpcHRpb24mZ3Q7DQogICAgICAgICAgICAmbHQ7dG9waWMgaHJlZj0icmVmZXJlbmNlL3JlZi0zNy5odG0iIGxhYmVsPSJOZXcgUHJvamVjdCBXaXphcmQiLyZndDsNCiAgICAgICAgICAgICZsdDt0b3BpYyBocmVmPSJjb25jZXB0cy9jb25jZXB0cy0xMi5odG0iIGxhYmVsPSJSZXNvdXJjZXMiLyZndDsNCiAgICAgICAgICAgICZsdDt0b3BpYyBocmVmPSJ0YXNrcy90YXNrcy00Mi5odG0iIGxhYmVsPSJDcmVhdGluZyBSZXNvdXJjZXMgLSBQcm9qZWN0cyIvJmd0Ow0KICAgICAgICAgICZsdDsvY29udGV4dCZndDsNCiAgICAgICAgICAuLi4NCiAgICAgICAgJmx0Oy9jb250ZXh0cyZndDs8L3ByZT48YnIgLz4NCiAgICAgIDxwPlRoaXMgc2hvdWxkIGxvb2sgZmFtaWxpYXIuICBBIGNvbnRleHQgZWxlbWVudCBkZWZpbmVzIGEgc2luZ2xlIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgdG9waWMuICBUaGUgY29udGV4dCBJRCBpcyB0aGUgb25lIGRlZmluZWQgaW4gdGhlIA0KICAgICAgICBkZXZlbG9wZXIncyBjb2RlIGFib3ZlIChvbmx5IGl0IGlzIG5vdCBmdWxseSBxdWFsaWZpZWQpLCBhbmQgdGhlIGRlc2NyaXB0aW9uIGFuZCB0b3BpYyBlbGVtZW50cyBjb250YWluIHRoZSB0ZXh0IGFuZCBoeXBlcmxpbmtzIHdlIHNhdyANCiAgICAgICAgaW4gRmlndXJlIDMuICBUaGVyZSdzIG5vdGhpbmcgZWxzZSBpbiBhIGNvbnRleHRzIGZpbGUgYnV0IHRoZXNlICZsdDtjb250ZXh0Jmd0OyBlbGVtZW50cywgYnV0IHlvdSBjYW4gcHV0IGFzIG1hbnkgb2YgdGhlbSBpbiBvbmUgYXMgeW91IHdhbnQuPC9wPg0KICAgICAgPHA+VGhlIGxhc3QgcGllY2Ugb2YgdGhlIHB1enpsZSBpcyBpZGVudGlmeWluZyBvdXIgY29udGV4dHMgZmlsZSBpbiB0aGUgcGx1Z2luLnhtbCBmaWxlICh0aGUgb25lIGluIHRoZSBzYW1lIHBsdWdpbiBhcyBvdXIgY29udGV4dHMgZmlsZSkuICANCiAgICAgICAgVGhhdCBjb2RlIGxvb2tzIGxpa2UgdGhpczo8L3A+DQogICAgICA8YnIgLz48cHJlPg0KICAgICAgICAmbHQ7ZXh0ZW5zaW9uIHBvaW50PSJvcmcuZWNsaXBzZS5oZWxwLmNvbnRleHRzIiZndDsNCiAgICAgICAgICAmbHQ7Y29udGV4dHMgZmlsZT0iY29udGV4dHNfV29ya2JlbmNoLnhtbCIgcGx1Z2luPSJvcmcuZWNsaXBzZS51aS5pZGUiLyZndDsNCiAgICAgICAgJmx0Oy9leHRlbnNpb24mZ3Q7PC9wcmU+PGJyIC8+DQogICAgICA8cD5TaW5jZSB0aGUgY29udGV4dHMgZmlsZSBhbmQgcGx1Z2luLnhtbCBmb3IgdGhpcyB3aXphcmQgZXhpc3QgaW4gYSBzZXBhcmF0ZSBwbHVnaW4gKG9yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy51c2VyKSB0aGFuIHRoZSB3aXphcmQgDQogICAgICAgIGNvZGUgKG9yZy5lY2xpcHNlLnVpLmlkZSksIHRoZSBjb2RlIHBsdWdpbidzIHBsdWdpbiBJRCBtdXN0IGJlIHNwZWNpZmllZCBpbiB0aGUgcGx1Z2luIGF0dHJpYnV0ZSBvZiB0aGUgJmx0O2NvbnRleHRzJmd0OyBlbGVtZW50LjwvcD4NCiAgICAgIDxwPlRoYXQncyBpdCBpbiBhIG51dHNoZWxsLiAgVGhlcmUgYXJlIGFkZGl0aW9uYWwgY29uc2lkZXJhdGlvbnMsIGxpa2UgaG93IHRvIG9yZ2FuaXplIGRvemVucyBvciBldmVuIGh1bmRyZWRzIG9mIHRoZXNlLCBvciBwcm92aWRlIA0KICAgICAgICBOYXRpb25hbCBMYW5ndWFnZSAodHJhbnNsYXRlZCkgdmVyc2lvbnMgb2YgdGhlbSwgYnV0IGlmIHlvdSBhcmNoaXRlY3QgeW91ciBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIGluIHRoaXMgd2F5LCB5b3UncmUgYWxyZWFkeSBzZXQgDQogICAgICAgIHVwIHRvIGhhbmRsZSB0aG9zZSBwcm9ibGVtcyBlYXNpbHkuPC9wPg0KICAgICA8cD5XaGF0IGFib3V0IGF0dGFjaGluZyBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIHRvIG90aGVyIHRoaW5ncywgbGlrZSB2aWV3cyBhbmQgZWRpdG9ycz8gIEFjY29yZGluZyB0byB0aGUgRWNsaXBzZSB1c2VyIGFzc2lzdGFuY2UgDQogICAgICAgb24gdGhlIHN1YmplY3QsIGNvbnRleHQgSURzIGNhbiBiZSBhc3NvY2lhdGVkIHdpdGggYSA8Y29kZT4gQ29udHJvbCwgSUFjdGlvbiwgTWVudSwgb3IgTWVudUl0ZW08L2NvZGU+LiAgKE90aGVyIFVJIA0KICAgICAgIGVsZW1lbnRzIGNhbm5vdCBiZSBhc3NvY2lhdGVkIHdpdGggYSBjb250ZXh0IElEIG9yIGNhbm5vdCByZWNlaXZlIGZvY3VzIGFueXdheSwgc28gYXNzaWduaW5nIGNvbnRleHQgSURzIHRvIHRoZW0gd291bGQgYmUgDQogICAgICAgcG9pbnRsZXNzLikgIFNpbmNlIHZpZXdzLCBlZGl0b3JzLCBhbmQgd2l6YXJkcyBhcmUgc2ltcGx5IGRpZmZlcmVudCB0eXBlcyBvZiBjb250cm9scywgZGVjbGFyaW5nIGNvbnRleHQgSURzIG9uIHZpZXdzIGFuZCBlZGl0b3JzIA0KICAgICAgIGlzIHZpcnR1YWxseSBpZGVudGljYWwgdG8gdGhlICBtZXRob2Qgc2hvd24gYWJvdmUuPC9wPg0KICAgICAgPHA+VGhlIHByaW1hcnkgbGltaXRhdGlvbiBvZiB0aGUgRWNsaXBzZSBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIG1lY2hhbmlzbSBpcyB0aGF0IG9ubHkgY2VydGFpbiB1c2VyIGFjdGlvbnMgd2lsbCBjYXVzZSBhIG5ldyANCiAgICAgICAgY29udGV4dC1zZW5zaXRpdmUgaGVscCB0b3BpYyB0byBiZSBhdXRvbWF0aWNhbGx5IGRpc3BsYXllZCBpbiBhbiBhbHJlYWR5LW9wZW4gSGVscCB2aWV3LiAgRm9yIGV4YW1wbGUsIGNoYW5naW5nIHRoZSBmb2N1cyANCiAgICAgICAgdG8gYSBkaWZmZXJlbnQgdmlldyBpbiB5b3VyIHdvcmtzcGFjZSwgc3dpdGNoaW5nIHRvIGEgZGlmZmVyZW50IHBhZ2UgaW4gYSB3aXphcmQsIG9yIGNsaWNraW5nIGEgdGFiIGluIGEgZGVzY3JpcHRvciBlZGl0b3Igd2lsbCByZXN1bHQgDQogICAgICAgIGluIGZyZXNoIGluZm9ybWF0aW9uLCBidXQgb3RoZXIgYWN0aW9ucywgbGlrZSBtb3ZpbmcgZnJvbSBmaWVsZCB0byBmaWVsZCBpbiBhIHdpemFyZCBwYWdlIG9yIGRlc2NyaXB0b3IgZWRpdG9yLCBvciBjbGlja2luZyBvbiBpdGVtcyANCiAgICAgICAgaW4gYSBncmFwaGljYWwgZWRpdG9yLCBkbyBub3QuPC9wPg0KICAgICAgPHA+VGhpcyBsaW1pdGF0aW9uIGlzIGEgbGVnYWN5IG9mIHRoZSBwcmlvciBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIG1lY2hhbmlzbSwgdGhlICJpbmZvcG9wLCIgd2hpY2ggd2FzIGEgdGVtcG9yYXJ5IHBvcC11cCBib3ggdGhhdCANCiAgICAgICAgZGlzcGxheWVkIHRoZSBjb250ZW50cyBvZiBvbmx5IG9uZSBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIHRvcGljIGFuZCB0aGVuIHdlbnQgYXdheS4gIFRvIGxhdW5jaCBhbiBpbmZvcG9wLCB0aGUgdXNlciBwcmVzc2VkIHRoZSANCiAgICAgICAgRjEga2V5OyB3aGlsZSBzZXBhcmF0ZSBmaWVsZHMgaW4gYSB3aXphcmQgY291bGQgaGF2ZSBzZXBhcmF0ZSBoZWxwcywgdGhlIHVzZXIgaGFkIHRvIHByZXNzIEYxIGluIGVhY2ggZmllbGQgdG8gYWNjZXNzIHRoZW0uICBUaGlzIA0KICAgICAgICBjYXBhYmlsaXR5IHN0aWxsIGV4aXN0cyBpbiB0aGUgSGVscCB2aWV3IOKAkyB0aGF0IGlzLCB0aGUgdXNlciBjYW4gcmVmcmVzaCB0aGUgY29udGV4dC1zZW5zaXRpdmUgaGVscCB0b3BpYyBieSBwcmVzc2luZyBGMSBmcm9tIHdpdGhpbiBhIA0KICAgICAgICBkaWZmZXJlbnQgZm9ybSBmaWVsZCwgYnV0IHdoZW4gdGhlIEhlbHAgdmlldyBpcyBhbHJlYWR5IG9wZW4gYW5kIHN1cHBvc2VkbHkgZHluYW1pYywgdXNlcnMgc2hvdWxkbid0IGJlIGV4cGVjdGVkIHRvIGhhdmUgdG8gZG8gDQogICAgICAgIHRoYXQsIG5vciB3b3VsZCB0aGV5IGxpa2VseSB0aGluayB0by48L3A+DQogICAgICA8cD5BcyB5b3UgaGF2ZSBwcm9iYWJseSBkZWR1Y2VkLCB0aGlzIG1lYW5zIHRoYXQgY2VydGFpbiBVSXMgY291bGQgYmUgc3R1Y2sgZGlzcGxheWluZyB0aGUgc2FtZSBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIHRvcGljIHdoaWxlIA0KICAgICAgICB0aGUgdXNlciBnb2VzIGFib3V0IGEgdmFyaWV0eSBvZiB0YXNrcyBpbnNpZGUgYSB2aWV3IG9yIGFuIGVkaXRvci4gIEhvdyBtYW55IHRpbWVzIHdpbGwgYSB1c2VyIHJlYWQgIkFuIFggZWRpdG9yIGlzIHVzZWQgdG8gZWRpdCBYIA0KICAgICAgICBmaWxlcyIgYmVmb3JlIGRlY2lkaW5nIHRoYXQgdGhlIEhlbHAgdmlldyBpcyBuZWl0aGVyIGR5bmFtaWMgbm9yIGhlbHBmdWw/ICBUaGUgb3RoZXIgZXh0cmVtZS0tb3ZlcmxvYWRpbmcgYSBzaW5nbGUgaGVscCB0b3BpYyBmb3IgYSANCiAgICAgICAgdmlldyBvciBlZGl0b3Igd2l0aCBleHBsYW5hdGlvbnMgb2YgZXZlcnl0aGluZyB0aGUgdXNlciBtaWdodCB3YW50IHRvIGtub3ctLWlzIG5vdCB0aGUgYW5zd2VyLCBlaXRoZXIuICBJbiB0aGF0IGNhc2UsIHRoZSB1c2VyIHdvdWxkIA0KICAgICAgICByZWNvaWwgZnJvbSBpbmZvcm1hdGlvbiBvdmVybG9hZCBhbmQgYmUgYW5ub3llZCBhdCBoYXZpbmcgdG8gaHVudCB0aHJvdWdoIHRoZSB0ZXh0IGZvciB0aGUgZGVzaXJlZCBpbmZvcm1hdGlvbi4gIFRoZSBiZXR0ZXIgc29sdXRpb24gDQogICAgICAgIGlzIHRvIGF1dG9tYXRpY2FsbHkgcHJvdmlkZSB0aGUgcmlnaHQgaW5mb3JtYXRpb24sIGluIHRoZSByaWdodCBhbW91bnQsIGF0IHRoZSByaWdodCB0aW1lLjwvcD4NCiAgICAgIDxoMj5BZGRpbmcgVHJ1bHkgRHluYW1pYyBDb250ZXh0LVNlbnNpdGl2ZSBIZWxwIHRvIGEgU2FtcGxlIEFwcGxpY2F0aW9uPC9oMj4NCiAgICAgIDxwPlRvIGFjaGlldmUgb3VyIGdvYWwgb2YgY3JlYXRpbmcgdHJ1bHkgZHluYW1pYyBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwLCB3aGVyZSB0aGUgSGVscCB2aWV3IHVwZGF0ZXMgd2l0aCBldmVyeSBjb250ZXh0IGNoYW5nZSwgd2UgDQogICAgICAgIG5lZWQgdG8gY3JlYXRlIG91ciBvd24gY29udGV4dCBwcm92aWRlci4gIFRoZSBpbXBsZW1lbnRhdGlvbiBvZiBhIGNvbnRleHQgcHJvdmlkZXIgaXMgc3RyYWlnaHRmb3J3YXJkIGFuZCBwcm92aWRlcyB0d28gbWFqb3IgYmVuZWZpdHM6DQogICAgICAgIDxvbD4NCiAgICAgICAgICA8bGk+SXQgYWRkcmVzc2VzIHRoZSBuZWVkIHRvIGhhdmUgdHJ1bHkgY29udGV4dC1zZW5zaXRpdmUgaGVscC4gIEluIGVmZmVjdCwgdGhlIEhlbHAgdmlldyB3aWxsIGhhdmUgYW4gb3Bwb3J0dW5pdHkgdG8gdXBkYXRlIHdpdGggZXZlcnkgc2VsZWN0aW9uIA0KICAgICAgICAgIGNoYW5nZSBpbiB0aGUgd29ya2JlbmNoLjwvbGk+DQogICAgICAgICAgPGxpPllvdSB3aWxsIGdhaW4gdGhlIGFiaWxpdHkgdG8gcHJvdmlkZSBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIHRvIGEgdmFyaWV0eSBvZiBvYmplY3QgdHlwZXMgYmV5b25kIHRob3NlIHByb3ZpZGVkIGJ5IHRoZSBoZWxwIHN5c3RlbS48L2xpPg0KICAgICAgICA8L29sPg0KICAgICAgPC9wPg0KICAgICAgPHA+VGhlIDxjb2RlPklXb3JrYmVuY2hIZWxwU3lzdGVtLnNldEhlbHA8L2NvZGU+IG1ldGhvZCAod2hpY2ggaXMgbGltaXRlZCB0byB0aGUgdHlwZXMgPGNvZGU+Q29udHJvbCwgSUFjdGlvbiwgDQogICAgICAgIE1lbnUgYW5kIE1lbnVJdGVtPC9jb2RlPikgZmFpbHMgdG8gYWRkcmVzcyBtYW55IG9mIHRoZSBjb21tb24gZWRpdG9yIHdpZGdldCB0eXBlcyBsaWtlIFRyZWVJdGVtIG9yIEdFRiBvYmplY3RzLiBUaGUgbW9yZSByb2J1c3QgDQogICAgICAgIGR5bmFtaWMgY29udGV4dC1zZW5zaXRpdmUgaGVscCB0aGF0IHdlIGRlc2NyaWJlIGluIHRoaXMgc2VjdGlvbiBvZiB0aGUgYXJ0aWNsZSBpcyBidWlsdCB1cG9uIHRoZSBkZWZhdWx0IGhlbHAgZnJhbWV3b3JrIGluZnJhc3RydWN0dXJlIHVzaW5nIA0KICAgICAgICB0aGUgY29udGV4dCBJRCBtYXBwaW5nIHBhdHRlcm4gZGVzY3JpYmVkIGluIHByZXZpb3VzIHNlY3Rpb24uPC9wPg0KICAgICAgPHA+QmV5b25kIHRoZSBzZXR1cCBvZiB0aGUgY29udGV4dCBJRCB3aXRoIGRvY3VtZW50YXRpb24sIHR3byBzdGVwcyBhcmUgcmVxdWlyZWQgdG8gY3JlYXRlIHRoaXMgZHluYW1pYyBoZWxwIGluZnJhc3RydWN0dXJlLiAgRmlyc3QsIGFuIA0KICAgICAgICBpbXBsZW1lbnRhdGlvbiBvZiA8Y29kZT5JQ29udGV4dFByb3ZpZGVyPC9jb2RlPiBtdXN0IGJlIGNyZWF0ZWQgZm9yIHByb3ZpZGluZyBhbiA8Y29kZT5JQ29udGV4dDwvY29kZT4gb2JqZWN0IA0KICAgICAgICBiYXNlZCBvbiB0aGUgdXNlciBzZWxlY3Rpb24uICBTZWNvbmRseSwgdGhlIDxjb2RlPldvcmtiZW5jaFBhcnQ8L2NvZGU+IChFZGl0b3Igb3IgVmlldykgdGhhdCBjb250YWlucyB0aGUgc2VsZWN0aW9uIGJlaW5nIA0KICAgICAgICBhY3RpdmF0ZWQgbmVlZHMgdG8gYWRhcHQgdGhlIG5ldyBjb250ZXh0IHByb3ZpZGVyIGJhc2VkIHVwb24gdGhlIGtleSA8Y29kZT5JQ29udGV4dFByb3ZpZGVyPC9jb2RlPiBjbGFzcy48L3A+ICAgICANCiAgICAgIDxwPkluY2x1ZGVkIHdpdGggdGhpcyBhcnRpY2xlIGlzIGFuIEVjbGlwc2Ugd29ya3NwYWNlIHRoYXQgY29udGFpbnMgYSBjdXN0b20gYXBwbGljYXRpb24gYnVpbHQgb24gdGhlIEVNRiBsaWJyYXJ5IGV4YW1wbGUuICANCiAgICAgICAgPGEgaHJlZj0iQ29udGV4dFNlbnNpdGl2ZUhlbHAuemlwIj5DbGljayBoZXJlPC9hPiB0byBkb3dubG9hZCB0aGUgQ29udGV4dFNlbnNpdGl2ZUhlbHAuemlwIHdvcmtzcGFjZS4gIFVuemlwIHRoZSBDb250ZXh0U2Vuc2l0aXZlSGVscCANCiAgICAgICAgd29ya3NwYWNlLCBhbmQgdGhlbiBzdGFydCBFY2xpcHNlIDMuMiwgb3IgYW55IHByb2R1Y3QgYmFzZWQgb24gRWNsaXBzZSAzLjIsIHN1Y2ggYXMgUmF0aW9uYWwgQXBwbGljYXRpb24gRGV2ZWxvcGVyIG9yIA0KICAgICAgICBSYXRpb25hbCBTb2Z0d2FyZSBBcmNoaXRlY3QuPC9wPiAgDQogICAgICA8cD5UaGUgZXhhbXBsZSBhcHBsaWNhdGlvbiBwcm92aWRlZCBoZXJlIGV4dGVuZHMgdGhlIG9yaWdpbmFsIEVNRiBsaWJyYXJ5IGV4YW1wbGUgKHdoaWNoIHByb3ZpZGVzIGEgYmFzaWMgZWRpdG9yIGZvciBtYW5hZ2luZyBsaWJyYXJ5IGluZm9ybWF0aW9uIHN1Y2ggYXMgYm9va3MgYW5kIHdyaXRlcnMpDQogICAgICAgIHNvIHRoYXQgaXQgbm93ICBpbmNsdWRlcyBkeW5hbWljIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgc2V0IHVwIG9uIHRoZSBsaWJyYXJ5IGFuZCBib29rIG9iamVjdHMgKHN0ZXBzIGZvciBhZGRpbmcgZHluYW1pYyBjb250ZXh0IHNlbnNpdGl2ZSBoZWxwIGZvciB0aGUgDQogICAgICAgIFdyaXRlciBvYmplY3QgYXJlIHByb3ZpZGVkIGxhdGVyIGluIHRoaXMgYXJ0aWNsZSkuPC9wPg0KICAgICAgPHA+VG8gcnVuIHRoZSBzYW1wbGUgYXBwbGljYXRpb246DQogICAgICAgIDxvbD4NCiAgICAgICAgPGxpPjxiPk9wZW48L2I+IHRoZSBDb250ZXh0c2Vuc2l0aXZlSGVscCB3b3Jrc3BhY2UgdXNpbmcgYW55IEVjbGlwc2UgdmVyc2lvbiAzLjIgZW52aXJvbm1lbnQgd2l0aCBFTUYuPC9saT4NCiAgICAgICAgICA8bGk+PGI+T3BlbjwvYj4gZWl0aGVyIHRoZSBKYXZhIG9yIFBsdWctaW4gRGV2ZWxvcG1lbnQgcGVyc3BlY3RpdmVzLjwvbGk+DQogICAgICAgICAgPGxpPlNlbGVjdCB0aGUgTGlicmFyeSBwcm9qZWN0IGFuZCBjbGljayA8Yj5SdW4gJmd0OyBSdW4gQXMgJmd0OyBFY2xpcHNlIEFwcGxpY2F0aW9uLjwvYj4gQW4gRWNsaXBzZSBydW4tdGltZSBlbnZpcm5tZW50IHdpbGwgc3RhcnQuPC9saT4gDQogICAgICAgICAgPGxpPkluIHRoZSBFY2xpcHNlIHJ1bi10aW1lIGVudmlyb25tZW50LCBjbGljayA8Yj5OZXcgJmd0OyBQcm9qZWN0PC9iPi4gIEV4cGFuZCBFY2xpcHNlIE1vZGVsaW5nIEZyYW1ld29yayBhbmQgc2VsZWN0IDxiPkVtcHR5IEVNRiBQcm9qZWN0LjwvYj48L2xpPiAgDQogICAgICAgICAgPGxpPkdpdmUgdGhlIHByb2plY3QgYSBuYW1lIGFuZCBjbGljayA8Yj5GaW5pc2g8L2I+LjwvbGk+DQogICAgICAgICAgPGxpPkluIHRoZSBQYWNrYWdlIEV4cGxvcmVyLCBleHBhbmQgdGhlIHByb2plY3QsIHJpZ2h0LWNsaWNrIG9uIHRoZSBtb2RlbCBmb2xkZXIsIGFuZCBjbGljayA8Yj5OZXcgJmd0OyBPdGhlci48L2I+PC9saT4gIA0KICAgICAgICAgIDxsaT5FeHBhbmQgRXhhbXBsZSBFTUYgTW9kZWwgQ3JlYXRpb24gV2l6YXJkcyBhbmQgc2VsZWN0IDxiPkxpYnJhcnkgTW9kZWw8L2I+LjwvbGk+ICANCiAgICAgICAgICA8bGk+Q2xpY2sgPGI+TmV4dCA8L2I+dHdpY2UuPC9saT4gIA0KICAgICAgICAgIDxsaT5PbiB0aGUgTGlicmFyeSBNb2RlbCBwYWdlLCBzZWxlY3QgPGI+TGlicmFyeTwvYj4gZnJvbSB0aGUgTW9kZWwgT2JqZWN0IGxpc3QgYW5kIGNsaWNrIDxiPkZpbmlzaC48L2I+DQogICAgICAgICBUaGUgTGlicmFyeSBFZGl0b3Igb3BlbnMgd2l0aCB5b3VyIG5ldyBtb2RlbCAoc2VlIEZpZ3VyZSA0KS48L2xpPiANCiAgICAgICAgICA8bGk+UHJlc3MgPGI+RjE8L2I+IGFuZCBlbnN1cmUgdGhlIEhlbHAgdmlldyBpcyBvcGVuIHRvIHRoZSBSZWxhdGVkIFRvcGljcyBwYWdlLjwvbGk+DQogICAgICAgICAgPGxpPlJpZ2h0LWNsaWNrIG9uIHRoZSA8Yj5MaWJyYXJ5IG9iamVjdDwvYj4gaW4gdGhlIGVkaXRvciBhbmQgY2xpY2sgPGI+TmV3IENoaWxkICZndDsgQm9vay48L2I+PC9saT4NCiAgICAgICAgICA8bGk+R2l2ZSB0aGUgbmV3IGJvb2sgcHJvcGVyZXRpZXMuPC9saT4NCiAgICAgICAgPC9vbD4NCiAgICAgIDwvcD4NCiAgICAgIA0KICAgICAgICA8YnIgLz48YSBuYW1lPSJmaWc0Ij48Yj5GaWd1cmUgNC4gVGhlIExpYnJhcnkgRWRpdG9yPC9iPjwvYT48YnIgLz4NCiAgICAgICAgPGltZyBzcmM9ImltYWdlcy9maWd1cmU0LmpwZyIgd2lkdGg9IjU1NCIgaGVpZ2h0PSIzOTAiIGFsdD0iVGhlIExpYnJhcnkgRWRpdG9yIi8+DQogICAgICA8YnIgLz4NCiAgICAgIDxiciAvPg0KICAgICAgPHA+Tm90aWNlIGhvdyBjbGlja2luZyBvbiB0aGUgQm9vayBvYmplY3QgaW4gdGhlIGVkaXRvciBwcm92aWRlcyBhIGRpZmZlcmVudCBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIHRvcGljIGluIHRoZSBIZWxwIHZpZXcgdGhhbiB0aGUgYmFzaWMgDQogICAgICAgIGhlbHAgYWJvdXQgdGhlIGVkaXRvciAoc2VlIEZpZ3VyZSA1KS4gIElmIHlvdSBjcmVhdGUgYSBXcml0ZXIgb2JqZWN0LCBub3RlIHRoYXQgaXQgZG9lcyBub3QgdXBkYXRlIHRoZSBIZWxwIHZpZXcuICBUaGlzIG9iamVjdCBpcyBub3QgaG9va2VkIHVwIHRvIGEgDQogICAgICAgIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgdG9waWMgeWV0OyB3ZSdsbCBkbyB0aGF0IG1hbnVhbGx5IGxhdGVyIGluIHRoZSBhcnRpY2xlLjwvcD4NCiAgICAgIA0KICAgICAgICA8YnIgLz48YSBuYW1lPSJmaWc1Ij48Yj5GaWd1cmUgNS4gU2VsZWN0aW5nIGEgQm9vayBpbiB0aGUgTGlicmFyeSBFZGl0b3I8L2I+PC9hPjxiciAvPg0KICAgICAgICA8aW1nIHNyYz0iaW1hZ2VzL2ZpZ3VyZTUuanBnIiB3aWR0aD0iNTU0IiBoZWlnaHQ9IjM4OSIgYWx0PSJTZWxlY3RpbmcgYSBCb29rIGluIHRoZSBMaWJyYXJ5IEVkaXRvciIvPg0KICAgICAgPGJyIC8+ICANCiAgICAgIDxiciAvPg0KICAgICAgPHA+QmFjayBpbiB0aGUgQ29udGV4dFNlbnNpdGl2ZUhlbHAgd29ya3NwYWNlLCBleGFtaW5lIHRoZSBzYW1wbGUgY29kZSBhbmQgbm90ZSB0aGUgZm9sbG93aW5nIGNoYW5nZXMgd2UgbWFkZSB0byB0aGUgTGlicmFyeSBFZGl0b3IgdG8gDQogICAgICAgIGltcGxlbWVudCBkeW5hbWljIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAuPC9wPiANCiAgICAgIDxwPldlIGFkZGVkIGEgYmFzaWMgcGx1Z2luIGNhbGxlZCAibGlicmFyeS5jc2giIHdpdGggYSBjb250ZXh0LnhtbCBmaWxlIHRoYXQgY29udGFpbnMgYSBjb3VwbGUgb2YgY29udGV4dC1zZW5zaXRpdmUgDQogICAgICAgICBoZWxwIHRvcGljcyB3aXRoIElEcyBsaWtlICJkZWZhdWx0TGlicmFyeUlkLCIgYW5kIHdlIGFkZGVkIGFuIGV4dGVuc2lvbiB0byA8Y29kZT5vcmcuZWNsaXBzZS5oZWxwLmNvbnRleHRzPC9jb2RlPiB0byBkZWZpbmUgdGhlIGNvbnRleHRzLnhtbCwgd2l0aCB0aGUgDQogICAgICAgICBwbHVnaW4gc2V0IHRvICJsaWJyYXJ5Ii48L3A+DQogICAgICA8cD5JbiB0aGUgbGlicmFyeS5lZGl0b3IgcHJvamVjdCwgd2UgYWRkZWQgYSBwbHVnaW4gZGVwZW5kZW5jeSB0byA8Y29kZT5vcmcuZWNsaXBzZS5oZWxwPC9jb2RlPi48L3A+DQogICAgICA8cD5JbiB0aGUgbGlicmFyeS5lZGl0b3IgcHJvamVjdCwgd2UgY3JlYXRlZCBhIG5ldyBjbGFzcyBuYW1lZCA8Y29kZT5MaWJyYXJ5SGVscENvbnRleHRQcm92aWRlcjwvY29kZT4gdGhhdCANCiAgICAgICAgIGltcGxlbWVudHMgPGNvZGU+SUNvbnRleHRQcm92aWRlcjwvY29kZT4gaW4gdGhlIHBhY2thZ2UgPGNvZGU+Y29tLmV4YW1wbGUubGlicmFyeS5oZWxwPC9jb2RlPi48L3A+DQogICAgICA8cD5XZSBpbXBsZW1lbnRlZCB0aGUgbWV0aG9kIDxjb2RlPmdldENvbnRleHRDaGFuZ2VNYXNrPC9jb2RlPjo8L3A+DQogICAgICA8cD4NCiAgICAgICAgICAgIDxiciAvPjxwcmU+ICANCiAgICAgICAgICAgIHB1YmxpYyBpbnQgZ2V0Q29udGV4dENoYW5nZU1hc2soKSB7DQogICAgICAgICAgICAgICByZXR1cm4gSUNvbnRleHRQcm92aWRlci5TRUxFQ1RJT047DQogICAgICAgICAgICB9PC9wcmU+PGJyIC8+DQogICAgICAgICAgPC9wPg0KICAgICAgPHA+V2UgaW1wbGVtZW50ZWQgPGNvZGU+Z2V0Q29udGV4dDwvY29kZT4gdG8gcmV0dXJuIHRoZSA8Y29kZT5JQ29udGV4dDwvY29kZT4gYmFzZWQgdXBvbiB0aGUgRU1GIHNlbGVjdGVkIA0KICAgICAgICBvYmplY3Q6PC9wPg0KICAgICAgICAgICAgPHA+PGJyIC8+PHByZT4gIA0KICAgICAgICAgICAgcHVibGljIElDb250ZXh0IGdldENvbnRleHQoT2JqZWN0IHRhcmdldCkgew0KCQlJU2VsZWN0aW9uIHNlbGVjdGlvbiA9IGVkaXRvci5nZXRTZWxlY3Rpb24oKTsNCgkJaWYgKHNlbGVjdGlvbiBpbnN0YW5jZW9mIFRyZWVTZWxlY3Rpb24pIHsNCgkJCU9iamVjdCBlbGVtZW50ID0gKChUcmVlU2VsZWN0aW9uKXNlbGVjdGlvbikuZ2V0Rmlyc3RFbGVtZW50KCk7DQoJCQlpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEJvb2spIHsNCgkJCQlyZXR1cm4gSGVscFN5c3RlbS5nZXRDb250ZXh0KCJsaWJyYXJ5LmxpYnJhcnlCb29rSWQiKTsNCgkJCX0NCgkJfQ0KICAgICAgICAgICAgICAgcmV0dXJuIEhlbHBTeXN0ZW0uZ2V0Q29udGV4dCgibGlicmFyeS5kZWZhdWx0TGlicmFyeUlkIik7DQogICAgICAgICAgICB9PC9wcmU+PGJyIC8+DQogICAgICAgICAgPC9wPg0KICAgICAgPHA+V2UgaW1wbGVtZW50ZWQgPGNvZGU+Z2V0U2VhcmNoRXhwcmVzc2lvbjwvY29kZT4gdG8gcmV0dXJuIGEgc3RyaW5nIHRoYXQgY2FuIGJlIHVzZWQgZm9yIGR5bmFtaWMgaGVscCBsb29rLXVwOjwvcD4NCiAgICAgICAgICAgIDxwPjxiciAvPjxwcmU+ICANCiAgICAgICAgICAgIHB1YmxpYyBTdHJpbmcgZ2V0U2VhcmNoRXhwcmVzc2lvbihPYmplY3QgdGFyZ2V0KSB7DQogICAgICAgICAgICAgICByZXR1cm4gbnVsbDsNCiAgICAgICAgICAgIH08L3ByZT48YnIgLz4NCiAgICAgICAgICA8L3A+DQogICAgICA8cD5XZSBhZGRlZCBhIGNvbnN0cnVjdG9yIHRoYXQgc3RvcmVzIGEgTGlicmFyeUVkaXRvciBhcyBhIHByb3BlcnR5OjwvcD4NCiAgICAgIDxwPg0KICAgICAgICAgICAgPGJyIC8+PHByZT4gIA0KICAgICAgICAgICAgcHVibGljIExpYnJhcnlIZWxwQ29udGV4dFByb3ZpZGVyKExpYnJhcnlFZGl0b3IgZWRpdG9yKSB7DQogICAgICAgICAgICAgICB0aGlzLmVkaXRvciA9IGVkaXRvcjsNCiAgICAgICAgICAgIH08L3ByZT48YnIgLz4NCiAgICAgICAgICA8L3A+DQogICAgICA8cD5XZSB1cGRhdGVkIHRoZSBlZGl0b3IgdG8gcmV0dXJuIHRoZSBkZWNsYXJlZCBjb250ZXh0IHByb3ZpZGVyICh0aGUgPGNvZGU+Z2V0QWRhcHRlcjwvY29kZT4gbWV0aG9kIGluIExpYnJhcnlFZGl0b3IgaW4gDQogICAgICAgICAgdGhlIGNvbS5leGFtcGxlLmxpYnJhcnkucHJlc2VudGF0aW9uIHBhY2thZ2UpOjwvcD4NCiAgICAgIDxwPg0KICAgICAgICAgICAgPGJyIC8+PHByZT4gIA0KICAgICAgICAgICAgCWVsc2UgaWYgKGtleS5lcXVhbHMoSUNvbnRleHRQcm92aWRlci5jbGFzcykpIHsNCiAgICAgICAgICAgICAgICAgIAlpZiAoY29udGV4dHByb3ZpZGVyID09IG51bGwpDQogICAgICAgICAgICAgICAgICAJCWNvbnRleHRwcm92aWRlciA9IG5ldyBMaWJyYXJ5SGVscENvbnRleHRQcm92aWRlcih0aGlzKTsNCiAgICAgICAgICAgIAkJcmV0dXJuIGNvbnRleHRwcm92aWRlcjsNCiAgICAgICAgICAgIAl9PC9wcmU+PGJyIC8+DQogICAgICAgICAgPC9wPg0KICAgICAgICAgIDxwPldlIGFkZGVkIGltcG9ydCBzdGF0ZW1lbnRzLCBhcyBuZWNlc3NhcnksIHRvIHJlc29sdmUgZXJyb3JzLjwvcD4NCiAgICAgIDxwPkZpbmFsbHksIHdlIHVwZGF0ZWQgdGhlIEVkaXRvciB0byBpbXBsZW1lbnQgPGNvZGU+SUFkYXB0YWJsZTwvY29kZT4gdG8gcmV0dXJuIG91ciBjdXN0b20gcHJvdmlkZXIuPC9wPg0KICAgICAgDQogICAgICA8aDM+QWRkaW5nIER5bmFtaWMgQ29udGV4dCBTZW5zaXRpdmUgSGVscCB0byB0aGUgV3JpdGVyIG9iamVjdDwvaDM+DQogICAgICA8cD5BcyBtZW50aW9uZWQgZWFybGllciwgd2UndmUgbGVmdCByb29tIHRvIGFkZCBkeW5hbWljIGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgdG8gdGhlIFdyaXRlciBvYmplY3QuICBUbyBkbyB0aGF0LCBmb2xsb3cgdGhlc2Ugc3RlcHM6DQogICAgICAgIDxvbD4NCiAgICAgICAgICA8bGk+QWRkIGEgbmV3IGNvbnRleHQtc2Vuc2l0aXZlIGhlbHAgdG9waWMgdG8gY29udGV4dHMueG1sOg0KICAgICAgICAgICAgPGJyIC8+PGJyIC8+PHByZT4NCiAgICAgICAgICAgICZsdDtjb250ZXh0IGlkPSJsaWJyYXJ5V3JpdGVySWQiIHRpdGxlPSJXcml0ZXIiJmd0Ow0KICAgICAgICAgICAgICAmbHQ7ZGVzY3JpcHRpb24mZ3Q7VGhpcyBpcyBjb250ZXh0LXNlbnNpdGl2ZSBoZWxwIGFib3V0IHRoZSB3cml0ZXIuDQogICAgICAgICAgICAgICAgV2l0aG91dCB3cml0ZXJzIHRoZXJlIHdvdWxkIGJlIG5vIGJvb2tzLiZsdDsvZGVzY3JpcHRpb24mZ3Q7DQogICAgICAgICAgICAgICZsdDt0b3BpYyBocmVmPSIuLi9saWJyYXJ5LmRvYy90b3BpY3Mvd3JpdGVycy5odG1sIg0KICAgICAgICAgICAgICAgIGxhYmVsPSJXcml0ZXJzIi8mZ3Q7CQkJCQ0KICAgICAgICAgICAgICAgICZsdDsvY29udGV4dCZndDsgPC9wcmU+PGJyIC8+DQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaT5BZGQgYSBuZXcgPGNvZGU+Z2V0Q29udGV4dDwvY29kZT4gY2FsbCB0byB0aGUgPGNvZGU+Z2V0Q29udGV4dCBtZXRob2Q8L2NvZGU+IGluIExpYnJhcnlIZWxwQ29udGV4dFByb3ZpZGVyOg0KICAgICAgICAgICAgPGJyIC8+PGJyIC8+PHByZT4NCiAgICAgICAgICAgIHB1YmxpYyBJQ29udGV4dCBnZXRDb250ZXh0KE9iamVjdCB0YXJnZXQpIHsNCiAgICAgICAgICAgICAgICAgICAgICBJU2VsZWN0aW9uIHNlbGVjdGlvbiA9IGVkaXRvci5nZXRTZWxlY3Rpb24oKTsNCiAgICAgICAgICAgICAgICAgICAgICBpZiAoc2VsZWN0aW9uIGluc3RhbmNlb2YgVHJlZVNlbGVjdGlvbikgew0KICAgICAgICAgICAgICAgICAgICAgICAgICAgT2JqZWN0IGVsZW1lbnQgPSgoVHJlZVNlbGVjdGlvbilzZWxlY3Rpb24pLmdldEZpcnN0RWxlbWVudCgpOw0KCQkJICAgICAgIGlmIChlbGVtZW50IGluc3RhbmNlb2YgQm9vaykgew0KICAgICAgICAgICAgICAgICAJCSAgIHJldHVybiBIZWxwU3lzdGVtLmdldENvbnRleHQoImxpYnJhcnkubGlicmFyeUJvb2tJZCIpOw0KCQkJICAgICAgIH0NCiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIFdyaXRlcikgew0KICAgICAgICAgICAgCQkgICByZXR1cm4gSGVscFN5c3RlbS5nZXRDb250ZXh0KCJsaWJyYXJ5LmxpYnJhcnlXcml0ZXJJZCIpOw0KICAgICAgICAgICAgICAgIAkgICAgICAgfQ0KCQkJICAgIH0NCiAgICAgICAgICAgIH08L3ByZT48YnIgLz4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaT5BZGQgYW4gaW1wb3J0IHN0YXRlbWVudCBmb3IgPGNvZGU+Y29tLmlibS5saWJyYXJ5LldyaXRlcjwvY29kZT4gYXQgdGhlIHRvcCBvZiB0aGUgZmlsZS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICA8L29sPg0KICAgICAgPC9wPg0KICAgICAgPHA+Tm93LCBydW4gdGhlIHNhbXBsZSBhZ2FpbiBhbmQgc2VsZWN0IHRoZSBXcml0ZXIgb2JqZWN0IChzZWUgRmlndXJlIDYpLiAgVGhlIER5bmFtaWMgSGVscCB2aWV3IHNob3VsZCByZXNwb25kIHRvIHRoZSBzZWxlY3Rpb24gb2YgdGhlIA0KICAgICAgICBXcml0ZXIgb2JqZWN0LjwvcD4NCiAgICAgIA0KICAgICAgPGJyIC8+PGEgbmFtZT0iZmlnNiI+PGI+RmlndXJlIDYuIFNlbGVjdGluZyBhIFdyaXRlciBpbiB0aGUgTGlicmFyeSBFZGl0b3I8L2I+PC9hPjxiciAvPg0KICAgICAgPGltZyBzcmM9ImltYWdlcy9maWd1cmU2LmpwZyIgd2lkdGg9IjU0MCIgaGVpZ2h0PSIzODMiIGFsdD0iU2VsZWN0aW5nIGEgV3JpdGVyIGluIHRoZSBMaWJyYXJ5IEVkaXRvciIvPg0KICAgICAgPGJyIC8+DQogICAgICA8YnIgLz4NCiAgICAgIDxoMz5EeW5hbWljIFNlYXJjaCBSZXN1bHRzPC9oMz4NCiAgICAgIDxwPkZpbmFsbHksIGFzIGEgYm9udXMsIGxldCdzIGRpcmVjdCBvdXIgYXR0ZW50aW9uIHRvIHRoZSBkeW5hbWljIHNlYXJjaCByZXN1bHRzIGluIHRoZSBEeW5hbWljIEhlbHAgcG9ydGlvbiANCiAgICAgICAgb2YgdGhlIEhlbHAgdmlldy4gIE5vcm1hbGx5LCB0aGUgc2VhcmNoIHBhcmFtZXRlcnMgYXJlIHNpbXBseSB0aGUgbmFtZSBvZiB0aGUgdmlldyBvciBlZGl0b3IgYW5kIHRoZSBuYW1lIA0KICAgICAgICBvZiB0aGUgcGVyc3BlY3RpdmUsIHdoaWNoIGFyZSBwYXNzZWQgZHluYW1pY2FsbHkgKGFuZCB1bmRlciB0aGUgY292ZXJzKSB0byB0aGUgSGVscCBzeXN0ZW0ncyBzZWFyY2ggZW5naW5lLiAgDQogICAgICAgIFRvIHNlZSBmb3IgeW91cnNlbGYsIHNjcm9sbCB0aGUgSGVscCB2aWV3IHRvIHRoZSBib3R0b20gYW5kIGNsaWNrICJNb3JlIHJlc3VsdHMuLi4iICBUaGUgc2VhcmNoIHBhcmFtZXRlcnMgdXNlZCANCiAgICAgICAgYXBwZWFyIGluIHRoZSBTZWFyY2ggZXhwcmVzc2lvbiB0ZXh0IGJveC48L3A+DQogICAgICA8cD5XaGlsZSBpdCdzIHBvc3NpYmxlIHRvIGltcHJvdmUgc2VhcmNoIHJlc3VsdHMgYnkgdHJ5aW5nIHRvIG1vZGlmeSBoZWxwIHRvcGljcyB0byB0YWtlIGFkdmFudGFnZSBvZiB0aGUgc2VhcmNoIHRlcm1zIA0KICAgICAgICB0aGF0IGFyZSBhbHJlYWR5IGJlaW5nIHVzZWQsIGEgYmV0dGVyIHNvbHV0aW9uIGlzIHRvIHBhc3MgbW9yZSBzcGVjaWZpYyBzZWFyY2ggdGVybXMuICBUaGUgbmV3IDxjb2RlPkNvbnRleHRQcm92aWRlcjwvY29kZT4gDQogICAgICAgIGNsYXNzIHByb3ZpZGVzIGEgbWV0aG9kIGNhbGxlZCA8Y29kZT5nZXRTZWFyY2hFeHByZXNzaW9uPC9jb2RlPiB3aGljaCBhbGxvd3MgdXMgdG8gZG8gdGhpcy4gIFNpbmNlIA0KICAgICAgICB3ZSd2ZSBnb25lIHRvIHRoZSB0cm91YmxlIG9mIGltcGxlbWVudGluZyBvdXIgb3duIGN1c3RvbSBjb250ZXh0IHByb3ZpZGVyLCB3ZSBjYW4gdXNlIHRoaXMgbWV0aG9kLg0KICAgICAgPC9wPg0KICAgICAgPHA+SW4gdGhlIGZvbGxvd2luZyBtZXRob2QgaW4gPGNvZGU+TGlicmFyeUhlbHBDb250ZXh0UHJvdmlkZXI8L2NvZGU+LCB0aGUgc2VhcmNoIHN0cmluZ3MgdGhhdCBhcmUgcGFzc2VkIHRvIHRoZSBzZWFyY2ggZW5naW5lIGFyZSANCiAgICAgICAgZGV0ZXJtaW5lZCBieSB0aGUgb2JqZWN0IHNlbGVjdGVkLiAgSWYgdGhlIGJvb2sgZWxlbWVudCBpcyBzZWxlY3RlZCwgdGhlIHN0cmluZyAibGlicmFyeSIgYW5kICJib29rIiBhcmUgdGhlIHNlYXJjaCBwYXJhbWV0ZXJzLiAgT3RoZXJ3aXNlLCB0aGUgDQogICAgICAgIGRlZmF1bHQgc2VhcmNoIHBhcmFtZXRlciBpcyAibGlicmFyeSIuPC9wPg0KICAgICAgICA8cD4NCiAgICAgICAgPGJyIC8+PHByZT4NCgkvL0hlcmUgaXMgd2hlcmUgZHluYW1pYyBzZWFyY2ggc3RyaW5nIHZhbHVlcyBhcmUgYWRkZWQNCglwdWJsaWMgU3RyaW5nIGdldFNlYXJjaEV4cHJlc3Npb24oT2JqZWN0IHRhcmdldCkgew0KCQlJU2VsZWN0aW9uIHNlbGVjdGlvbiA9IGVkaXRvci5nZXRTZWxlY3Rpb24oKTsNCgkJaWYgKHNlbGVjdGlvbiBpbnN0YW5jZW9mIFRyZWVTZWxlY3Rpb24pIHsNCgkJCU9iamVjdCBlbGVtZW50ID0gKChUcmVlU2VsZWN0aW9uKXNlbGVjdGlvbikuZ2V0Rmlyc3RFbGVtZW50KCk7DQoJCQlpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEJvb2spIHsNCgkJCQkvLyByZXR1cm4gYSBzZWFyY2ggc3RyaW5nIA0KCQkJCXJldHVybiAiXCJsaWJyYXJ5XCIgKyBcImJvb2tcIiI7DQoJCQl9DQoJCX0NCgkJcmV0dXJuICJsaWJyYXJ5IjsNCgl9PC9wcmU+PGJyIC8+DQogICAgICA8L3A+DQogICAgICA8cD5Ob3RlIHRoYXQgYWx0aG91Z2ggdGhlIHNlYXJjaCB0ZXJtcyBhcmUgaGFyZC1jb2RlZCBpbnRvIHRoZSBKYXZhIGZpbGUgaGVyZSwgdGhlc2Ugc2VhcmNoIGV4cHJlc3Npb25zIGNhbiBiZSBzdHJpbmctc2VwYXJhdGVkIGZvciB0cmFuc2xhdGlvbiBwdXJwb3NlcywgaW4gdGhlIHNhbWUgd2F5IHRoYXQgYW55IHN0cmluZyBpcyBleHRlcm5hbGl6ZWQuPC9wPg0KICAgICAgPHA+QXMgeW91IHJ1biB0aGUgRWNsaXBzZSBhcHBsaWNhdGlvbiB3aXRoIHRoZXNlIGNoYW5nZXMsIHJlbWVtYmVyIHRvIGNsaWNrICJNb3JlIHJlc3VsdHMuLi4iIGF0IHRoZSBib3R0b20gb2YgdGhlIER5bmFtaWMgSGVscCB2aWV3IHNvIHRoYXQgeW91IA0KICAgICAgICBjYW4gc2VlIHdoYXQgc2VhcmNoIHN0cmluZ3MgYXJlIGJlaW5nIHVzZWQuPC9wPg0KCTxoMj5TdW1tYXJ5PC9oMj4NCiAgICAgIDxwPkRldmVsb3BtZW50IGVudmlyb25tZW50cyBldm9sdmUgYXQgYSB2ZXJ5IHJhcGlkIHBhY2UuICBBcyBzb29uIGFzIGEgdXNlciBsZWFybnMgb25lIHRvb2wsIGEgbmV3IHRvb2wgYXJyaXZlcyBhbmQgdGhlIGxlYXJpbmcgcHJvY2VzcyBzdGFydHMgYWdhaW4uICANCiAgICAgICAgQXMgYSB0b29sIGRldmVsb3BlciwgeW91IGNhbiBoZWxwIHlvdXIgdXNlcnMgYnkgdGFraW5nIGFkdmFudGFnZSBvZiBFY2xpcHNlJ3MgY29udGV4dC1zZW5zaXRpdmUgaGVscCBhbmQgRHluYW1pYyBBc3Npc3RhbmNlIGZyYW1ld29yay4gIERvaW5nIHNvIGhlbHBzIA0KICAgICAgICBlbnN1cmUgdGhhdCB5b3VyIHVzZXJzIGNhbiBxdWlja2x5IGZpbmQgaW5mb3JtYXRpb24gYWJvdXQgaG93IHRvIGJlIG1vc3QgZWZmZWN0aXZlLCB3aGljaCB3aWxsIGluY3JlYXNlIHRoZWlyIHNhdGlzZmFjdGlvbiB3aXRoIHlvdXIgdG9vbHMuPC9wPg0KCTwvcD4NCjwvZGl2Pg0KPC9ib2R5Pg0KPC9odG1sPg0K