PCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiI+CjxodG1sPgo8aGVhZD4KPG1ldGEgbmFtZT0iY29weXJpZ2h0IiBjb250ZW50PSJDb3B5cmlnaHQgKGMpIDIwMDctMjAwOCBJbm5vb3ByYWN0IEluZm9ybWF0aW9uc3N5c3RlbWUgR21iSC4gVGhpcyBwYWdlIGlzIG1hZGUgYXZhaWxhYmxlIHVuZGVyIGxpY2Vuc2UuIEZvciBmdWxsIGRldGFpbHMgc2VlIHRoZSBMRUdBTCBpbiB0aGUgZG9jdW1lbnRhdGlvbiBib29rIHRoYXQgY29udGFpbnMgdGhpcyBwYWdlLiIgPgo8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyI+Cjx0aXRsZT5DdXN0b20gd2lkZ2V0czwvdGl0bGU+CjxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vc3R5bGUuY3NzIiBjaGFyc2V0PSJJU08tODg1OS0xIiB0eXBlPSJ0ZXh0L2NzcyI+CjwvaGVhZD4KPGJvZHk+CiAgPGgxPkhvdyB0byBjcmVhdGUgYSBjdXN0b20gd2lkZ2V0PzwvaDE+IAogIAogIDxwPkNyZWF0aW5nIGN1c3RvbSB3aWRnZXRzIGluIFJBUCBpcyBhIGhvdCB0b3BpYyBhbmQgd2Ugc2VlIHRoZSBuZWVkIHRvCiAgY292ZXIgdGhpcyBpbiBhbiBhcnRpY2xlIHdoaWNoIHlvdSBhcmUganVzdCByZWFkaW5nIGhlcmUuIFRoZSBtYWluIHByb2JsZW0KICBpcyB0aGUgZGlzdHJpYnV0ZWQgbmF0dXJlIG9mIFJBUCB3aGljaCByZXF1aXJlcyB0aGF0IGFsbCBjb21wb25lbnRzIG9mIHlvdXIKICBjdXN0b20gd2lkZ2V0IGhhdmUgdG8gcGxheSB0b2dldGhlciBhbmQgaGF2ZSBzb21lIGRpZmZlcmVudCBhc3BlY3RzIHRoYW4KICBjdXN0b20gd2lkZ2V0cyBpbiBTV1QuPC9wPgogIAogIDxwPgogIFlvdSBzaG91bGQgYmUgYXdhcmUgb2YgdGhlIGZhY3QgdGhhdCB0aGVyZSBhcmUgdHdvIGRpZmZlcmVudCB0eXBlcyBvZiBjdXN0b20gd2lkZ2V0cy4KICBPbiB0aGUgb25lIHNpZGUgd2UgaGF2ZSBjb21wb3VuZGVkIHdpZGdldHMgd2hpY2ggaXMganVzdCBhbiBhZ2dsb21lcmF0aW9uIG9mIGFscmVhZHkKICBleGlzdGluZyB3aWRnZXRzLiBBcyB0aGlzIHdvdWxkIGJlIGRvbmUgaW4gdGhlIHNhbWUgd2F5IGxpa2UgU1dUIHdlJ2xsIG9ubHkgY2FyZSBhYm91dAogIHJlYWwgY3VzdG9tIHdpZGdldHMgKHlvdSBjb3VsZCB1c2UgdGhlIHRlcm0gIm93bmVyIGRyYXduIiBpbiB0aGlzIGNhc2UpLgogIDwvcD4KICAKICA8cD4KICBUaGVyZSBhcmUgZGlmZmVyZW50IHRhc2tzIHRvIGNyZWF0ZSBhIG5ldyBjdXN0b20gd2lkZ2V0IHdoaWNoIHdpbGwgYmUgY292ZXJlZCBoZXJlOgogIDx1bD4KICAJPGxpPmNyZWF0ZSBhIHdpZGdldCB3aGljaCB3aWxsIGJlIHVzZWQgb24gdGhlIHNlcnZlcjwvbGk+CiAgCTxsaT5jcmVhdGUgdGhlIGphdmFzY3JpcHQgbGlicmFyaWVzIG5lZWRlZCBieSB0aGUgY3VzdG9tIHdpZGdldDwvbGk+CiAgCTxsaT5jcmVhdGUgYW4gYWRhcHRlciB0byBjb25uZWN0IHRoZSB3aWRnZXQgd2l0aCB0aGUgUkFQIGxpZmVjeWNsZTwvbGk+CiAgCTxsaT5yZWdpc3RlciB0aGUgamF2YXNjcmlwdCBmaWxlczwvbGk+CiAgPC91bD4KICA8L3A+CiAgCiAgPHA+QXMgYW4gZXhlbXBsYXJ5IHdpZGdldCBpbXBsZW1lbnRhdGlvbiB3ZSB3aWxsIHVzZSBhIGNvbXBvbmVudCB0byBzaG93IHNwZWNpZmljCiAgbG9jYXRpb25zIGluIGEgbWFwLiBCZWhpbmQgdGhlIHNjZW5lcyB3ZSB3aWxsIHVzZSB0aGUgcHVibGljIEFQSSBvZiBHb29nbGUgbWFwcy4gTGV0J3MKICBzdGFydCB3aXRoIG91ciBmaXJzdCB0YXNrIC0gdGhlIHNlcnZlci1zaWRlIHdpZGdldCBpbXBsZW1lbnRhdGlvbi48L3A+CiAgCiAgPGgzPkNyZWF0aW5nIHRoZSB3aWRnZXQ8L2gzPgogIAogIDxwPgogIFRvIGhhdmUgYSBjbGVhciBsaW5lIGJldHdlZW4geW91ciBhcHBsaWNhdGlvbiBhbmQgeW91ciB3aWRnZXRzIHdlJ2xsIGNyZWF0ZSBhIG5ldyBwbHVnLWluCiAgcHJvamVjdCBjYWxsZWQgPGNvZGU+b3JnLmVjbGlwc2UucmFwLmRlbW8uZ21hcHM8L2NvZGU+LiBXZSBkb24ndCBuZWVkIGFueSBhZGRpdGlvbmFsCiAgYXNwZWN0cyBsaWtlIGFuIFJDUCBhcHBsaWNhdGlvbiBvciBhbiBhY3RpdmF0b3IuCiAgPC9wPgogIDxpbWcgc3JjPSIuLi8uLi9pbWFnZXMvY3VzdG9tLXdpZGdldC9uZXdwcm9qZWN0LnBuZyI+CiAgCiAgPHA+CiAgVGhlIGZpcnN0IHN0ZXAgaXMgdG8gY3JlYXRlIGEgamF2YSBjbGFzcyAtIHRoZSB3aWRnZXQgaXRzZWxmIC0gdG8gdGFsayB0byB0aGUgZGV2ZWxvcGVyIGxpa2UKICBldmVyeSBvdGhlciB3aWRnZXQuIEluIG91ciBjYXNlIHdlIHdpbGwgY2FsbCBpdCA8Y29kZT5HTWFwLmphdmE8L2NvZGU+IGluIHBsYWNlIGl0IGludG8gdGhlCiAgPGNvZGU+b3JnLmVjbGlwc2UucmFwLmdtYXBzPC9jb2RlPiBwYWNrYWdlLiBBcyBzdXBlciBjbGFzcyB3ZSB1c2UgPGNvZGU+b3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlPC9jb2RlPgogIHRvIGhhdmUgdG8gaGF2ZSBhIHByb3BlciBiYXNlIGNsYXNzIHdoaWNoIGludGVyYWN0cyB3aXRoIHRoZSByZXN0IG9mIFNXVC4gVG8gc3RvcmUgdGhlIGFkZHJlc3Mgd2hpY2gKICB3aWxsIGJlIHNob3duIG9uIHRoZSBtYXAsIHdlIGNyZWF0ZSBhIG5ldyBmaWVsZCBpbiB0aGUgPGNvZGU+R01hcDwvY29kZT4gY2xhc3MgY2FsbGVkIDxjb2RlPmFkZHJlc3M8L2NvZGU+CiAgYW5kIHdpbGwgZ2VuZXJhdGUgdGhlIGNvcnJlc3BvbmRpbmcgc2V0dGVyIGFuZCBnZXR0ZXIuIFRoZSBzZXR0ZXIgLSA8Y29kZT5zZXRBZHJlc3MoIFN0cmluZyApPC9jb2RlPiAtIHNob3VsZAogIGNoZWNrIGZvciA8Y29kZT5udWxsPC9jb2RlPiB2YWx1ZXMgYW5kIHJlcGxhY2luZyA8Y29kZT5udWxsPC9jb2RlPiB3aXRoIGFuIGVtcHR5IHN0cmluZyBpbnN0ZWFkLiBJdAogIHNob3VsZCBsb29rIGxpa2UgdGhpcyBpbiB0aGUgZW5kOgogIDxwcmU+CiAgPGNvZGU+CiAgcHVibGljIHZvaWQgc2V0QWRkcmVzcyggU3RyaW5nIGFkZHJlc3MgKSB7CiAgICBpZiggYWRkcmVzcyA9PSBudWxsICkgewogICAgICB0aGlzLmFkZHJlc3MgPSAiIjsKICAgIH0gZWxzZSB7CiAgICAgIHRoaXMuYWRkcmVzcyA9IGFkZHJlc3M7CiAgICB9CiAgfQogIDwvY29kZT4KICA8L3ByZT4KICA8cD4KICBUbyBoYXZlIGFuIGV4YW1wbGUgZm9yIHRoZSBvdGhlciB3YXkgYXJvdW5kIC0gZnJvbSBjbGllbnQgdG8gc2VydmVyIC0gd2UgaW50cm9kdWNlIGFub3RoZXIKICBmaWVsZCBjYWxsZWQgPGNvZGU+Y2VudGVyTG9jYXRpb248L2NvZGU+IHRvIGdldCB0aGUgY3VycmVudCBsb2NhdGlvbiBvZiB0aGUgbWFwIHdoZW4gdGhlCiAgdXNlciBtb3ZlcyBpdCBhcm91bmQuIFRoaXMgaXMgZG9uZSBieSBhZGRpbmcgYSBuZXcgZmllbGQgdG8gdGhlIGNsYXNzIHRvZ2V0aGVyIHdpdGggaXRzCiAgZ2V0dGVyIGFuZCBzZXR0ZXI6CiAgPC9wPgogIDxwcmU+CiAgPGNvZGU+CiAgcHJpdmF0ZSBTdHJpbmcgY2VudGVyTG9jYXRpb247CiAgCiAgcHVibGljIHZvaWQgc2V0Q2VudGVyTG9jYXRpb24oIFN0cmluZyBsb2NhdGlvbiApIHsKICAgIHRoaXMuY2VudGVyTG9jYXRpb24gPSBsb2NhdGlvbjsKICB9CiAgCiAgcHVibGljIFN0cmluZyBnZXRDZW50ZXJMb2NhdGlvbigpIHsKICAgIHJldHVybiB0aGlzLmNlbnRlckxvY2F0aW9uOwogIH0KICA8L2NvZGU+CiAgPC9wcmU+CiAgPHA+CiAgQWRkaXRpb25hbGx5IHdlIG92ZXJyaWRlIHRoZSA8Y29kZT5zZXRMYXlvdXQoTGF5b3V0KTwvY29kZT4gbWV0aG9kIG9mIDxjb2RlPkNvbXBvc2l0ZTwvY29kZT4KICB3aXRoIGFuIGVtcHR5IG1ldGhvZCBhcyBvdXIgY3VzdG9tIHdpZGdldCBkb2VzIG5vdCBjb250YWluIGFueSBvdGhlciB3aWRnZXRzLgogIFRoYXQncyBhbGwgZm9yIG5vdyAtIHRoaXMgaXMgYWxsIG5lZWRlZCBieSB0aGUgZGV2ZWxvcGVycyB3aG8gd2FudCB0byB1c2Ugb3VyIHRoZSBjdXN0b20gd2lkZ2V0LgogIE5vdyBpdCBnZXRzIGludGVyZXN0aW5nIGFzIHdlIGhhdmUgdG8gd29yayBvdXQgdGhlIGphdmFzY3JpcHQgc2lkZSBvZiBvdXIgd2lkZ2V0LgogIDwvcD4KCiAgPGgzPkNsaWVudC1zaWRlIGltcGxlbWVudGF0aW9uPC9oMz4KICAKICA8cD4KICBPbiB0aGUgY2xpZW50IHNpZGUgb3VyIHdpZGdldCBpcyBqdXN0IGEgamF2YXNjcmlwdCBjbGFzcyBkZWZpbmVkIHdpdGggdGhlCiAgPGEgaHJlZj0iaHR0cDovL3Fvb3hkb28ub3JnL2RvY3VtZW50YXRpb24vMC43L2NsYXNzX2RlY2xhcmF0aW9uIj5xb294ZG9vIHN5bnRheDwvYT4uCiAgQXMgc3VwZXIgY2xhc3Mgd2UgbmVlZCB0byB1c2UgYXQgbGVhc3QKICA8YSBocmVmPSJodHRwOi8vZGVtby5xb294ZG9vLm9yZy9jdXJyZW50L2FwaXZpZXdlci8jcXgudWkuY29yZS5XaWRnZXQiPnF4LnVpLmNvcmUuV2lkZ2V0PC9hPi4KICBUbyBoYXZlIGFuIGVhc2llciBsaWZlIHdlIHdpbGwgZGlyZWN0bHkgdXNlIG9uZSBvZiB0aGUKICA8YSBocmVmPSJodHRwOi8vcW9veGRvby5vcmcvZG9jdW1lbnRhdGlvbi8wLjcvbGF5b3V0X21hbmFnZXIiPnFvb3hkb28gbGF5b3V0IG1hbmFnZXJzPC9hPgogIGFzIGJhc2Ugb2Ygb3VyIHdpZGdldC4gVGhlIGNvZGUgZm9yIHRoZSBuZXcgcW9veGRvbyBjbGFzcyB0b2dldGhlciB3aXRoIHFvb3hkb29zCiAgPGNvZGU+Q2FudmFzTGF5b3V0PC9jb2RlPiBhcyBzdXBlciBjbGFzcyB3aWxsIGxvb2sgbGlrZSB0aGlzOgogIDxwcmU+CiAgPGNvZGU+CiAgcXguQ2xhc3MuZGVmaW5lKCAib3JnLmVjbGlwc2UucmFwLmdtYXBzLkdNYXAiLCB7CiAgZXh0ZW5kOiBxeC51aS5sYXlvdXQuQ2FudmFzTGF5b3V0LAogIAkJLy8gLi4uCiAgICB9CiAgfSApOwogIDwvY29kZT4KICA8L3ByZT4KICBUaGUgZmlyc3QgdGhpbmcgd2UgbmVlZCB0byBjcmVhdGUgaXMgdGhlIGNvbnN0cnVjdG9yIGZvciB0aGF0IGNsYXNzIGluIG9yZGVyIHRvIGluaXRpYWxpemUgb3VyIHdpZGdldCBwcm9wZXJseS4KICBBcyBwYXJhbWV0ZXIgd2UgaGF2ZSBhbiA8Y29kZT5pZDwvY29kZT4gd2hpY2ggd2lsbCBiZSBwYXNzZWQgdG8gdGhlIHdpZGdldCBieSB1cyBpbiBhIGxhdGVyIHN0ZXAuCiAgVGhlIGZpcnN0IGxpbmUgaXMgYSBiYXNlIGNhbGwgd2hpY2ggaXMgdGhlIHNhbWUgYXMgc3VwZXIgaW4gYSBqYXZhIGVudmlyb25tZW50LgogIEZvciBub3cgd2UgcG9wdWxhdGUgdGhlIDxjb2RlPmlkPC9jb2RlPiB0byB0aGUgYnJvd3NlcnMgRE9NIGJ5IGFkZGluZyBhIG5ldyBIVE1MIGF0dHJpYnV0ZSB3aXRoIDxjb2RlPnNldEh0bWxBdHRyaWJ1dGU8L2NvZGU+LgogIFlvdSBzZWUgc29tZSBHb29nbGUgTWFwcy1zcGVjaWZpYyBjYWxscyBoZXJlIHdoaWNoIGFyZSBqdXN0IHRoZXJlIHRvIGluaXRpYWxpemUgdGhlIEdvb2dsZSBNYXBzCiAgc3Vic3lzdGVtLiBTZWUgdGhlCiAgPGEgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9hcGlzL2FqYXgvZG9jdW1lbnRhdGlvbiI+R29vZ2xlIE1hcHMgQVBJIERvY3VtZW50YXRpb248L2E+CiAgZm9yIG1vcmUgaW5mb3JtYXRpb24uCiAgVGhlIHR3byA8YSBocmVmPSJodHRwOi8vcW9veGRvby5vcmcvZG9jdW1lbnRhdGlvbi8wLjcvdXNpbmdfZXZlbnRzIj5ldmVudCBsaXN0ZW5lcnM8L2E+IGZvciB0aGUKICBxb294ZG9vIHdpZGdldCB3aWxsIHRha2UgY2FyZSBmb3IgdGhlIHNpemUgY2FsY3VsYXRpb25zLiBUaGlzIG1lYW5zIHRoYXQgd2hlbmV2ZXIgdGhlIHNlcnZlcgogIHNldHMgYSBuZXcgc2l6ZSBmb3IgdGhlIHdpZGdldCB3ZSBjYXJlIGFib3V0IG91ciB3aWRnZXQgdG8gbGF5IG91dCBldmVyeXRoaW5nIGluc2lkZQogIChpbiB0aGlzIGNhc2UgdGhlIG1hcCkgY29ycmVjdGx5LgogIFRoZSBjYWxsZWQgbWV0aG9kIDxjb2RlPl9kb1Jlc2l6ZTwvY29kZT4gd2lsbCBiZSBpbXBsZW1lbnRlZCBsYXRlci4KICA8cHJlPgogIDxjb2RlPgogIHF4LkNsYXNzLmRlZmluZSggIm9yZy5lY2xpcHNlLnJhcC5nbWFwcy5HTWFwIiwgewogIGV4dGVuZDogcXgudWkubGF5b3V0LkNhbnZhc0xheW91dCwKICA8Yj4KCSAgY29uc3RydWN0OiBmdW5jdGlvbiggaWQgKSB7CgkgICAgdGhpcy5iYXNlKCBhcmd1bWVudHMgKTsKCSAgICB0aGlzLnNldEh0bWxBdHRyaWJ1dGUoICJpZCIsIGlkICk7CgkgICAgdGhpcy5faWQgPSBpZDsKCSAgICB0aGlzLl9tYXAgPSBudWxsOwoJICAgIGlmKCBHQnJvd3NlcklzQ29tcGF0aWJsZSgpICkgewoJICAgICAgdGhpcy5fZ2VvY29kZXIgPSBuZXcgR0NsaWVudEdlb2NvZGVyKCk7CgkgICAgICB0aGlzLmFkZEV2ZW50TGlzdGVuZXIoICJjaGFuZ2VIZWlnaHQiLCB0aGlzLl9kb1Jlc2l6ZSwgdGhpcyApOwoJICAgICAgdGhpcy5hZGRFdmVudExpc3RlbmVyKCAiY2hhbmdlV2lkdGgiLCB0aGlzLl9kb1Jlc2l6ZSwgdGhpcyApOyAKCSAgICB9CgkgIH0KICA8L2I+ICAKICAgIH0KICB9ICk7CiAgPC9jb2RlPgogIDwvcHJlPiAgCiAgCiAgVG8gc2F2ZSB0aGUgYWRkcmVzcyBvZiB0aGUgd2lkZ2V0IHNvbWV3aGVyZSB3ZSB1c2UgdGhlCiAgPGEgaHJlZj0iaHR0cDovL3Fvb3hkb28ub3JnL2RvY3VtZW50YXRpb24vMC43L3Byb3BlcnRpZXMiPnByb3BlcnR5IHN5c3RlbTwvYT4gb2YgcW9veGRvby4KICBBZGRpbmcgYSBuZXcgcHJvcGVydHkgd2lsbCBsb29rIGxpa2UgdGhpczoKICA8cHJlPgogIDxjb2RlPgogIHF4LkNsYXNzLmRlZmluZSggIm9yZy5lY2xpcHNlLnJhcC5nbWFwcy5HTWFwIiwgewogIGV4dGVuZDogcXgudWkubGF5b3V0LkNhbnZhc0xheW91dCwKICAgICAgY29uc3RydWN0OiBmdW5jdGlvbiggaWQgKSB7CiAgICAgICAgLy8gLi4uCiAgICAgIH08Yj4sICAvLyA8LS0gY29tbWEgYWRkZWQsIHNlZSBqYXZhc2NyaXB0IHN5bnRheCByZWZlcmVuY2UKCSAgCiAgICAgIHByb3BlcnRpZXMgOiB7CiAgICAgICAgYWRkcmVzcyA6IHsKICAgICAgICAgIGluaXQgOiAiIiwKICAgICAgICAgIGFwcGx5IDogImxvYWQiCiAgICAgICAgfQogICAgICB9CiAgICAgIDwvYj4KICAgIH0KICB9ICk7CiAgPC9jb2RlPgogIDwvcHJlPgogIFFvb3hkb28gd2lsbCBhdXRvbWF0aWNhbGx5IGdlbmVyYXRlIHRoZSBjb3JyZXNwb25kaW5nIHNldHRlciBhbmQgZ2V0dGVyIGF0IHJ1bnRpbWUgZm9yIHVzLgogIFNvIGlmIHdlIHdhbnQgdG8gcmVhZCB0aGUgY3VycmVudCBhZGRyZXNzIG9mIG91ciBjbGllbnQtc2lkZSB3aWRnZXQgd2UganVzdCBuZWVkIHRvIGNhbGwKICA8Y29kZT5nZXRBZHJlc3M8L2NvZGU+IG9uIGEgb3VyIGNsaWVudC1zaWRlIEdNYXAgb2JqZWN0LiBBcyB5b3Ugc2VlIGluIHRoZSA8Y29kZT5hcHBseTwvY29kZT4gYXR0cmlidXRlCiAgb2YgeW91ciBhZGRyZXNzIHByb3BlcnR5IHRoZSBtZXRob2QgPGNvZGU+bG9hZDwvY29kZT4gd2lsbCBiZSBjYWxsZWQgd2hlbiB0aGUgdmFsdWUgb2YgdGhlCiAgcHJvcGVydHkgY2hhbmdlcy4gU28gbGV0J3MgaW1wbGVtZW50IGl0OgogIAogIDxwcmU+CiAgPGNvZGU+CiAgcXguQ2xhc3MuZGVmaW5lKCAib3JnLmVjbGlwc2UucmFwLmdtYXBzLkdNYXAiLCB7CiAgZXh0ZW5kOiBxeC51aS5sYXlvdXQuQ2FudmFzTGF5b3V0LAogICAgICBjb25zdHJ1Y3Q6IGZ1bmN0aW9uKCBpZCApIHsKICAgICAgICAvLyAuLi4KICAgICAgfQoJICAKICAgICAgcHJvcGVydGllcyA6IHsKICAgICAgICAvLyAuLi4KICAgICAgfTxiPiwgIC8vIDwtLSBjb21tYSBhZGRlZCwgc2VlIGphdmFzY3JpcHQgc3ludGF4IHJlZmVyZW5jZQogICAgICAKICAgICAgX2RvQWN0aXZhdGUgOiBmdW5jdGlvbigpIHsKICAgICAgICB2YXIgc2hlbGwgPSBudWxsOwogICAgICAgIHZhciBwYXJlbnQgPSB0aGlzLmdldFBhcmVudCgpOwogICAgICAgIHdoaWxlKCBzaGVsbCA9PSBudWxsICYmIHBhcmVudCAhPSBudWxsICkgewogICAgICAgICAgaWYoIHBhcmVudC5jbGFzc25hbWUgPT0gIm9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLlNoZWxsIiApIHsKICAgICAgICAgICAgc2hlbGwgPSBwYXJlbnQ7CiAgICAgICAgICB9CiAgICAgICAgICBwYXJlbnQgPSBwYXJlbnQuZ2V0UGFyZW50KCk7CiAgICAgICAgfQogICAgICAgIGlmKCBzaGVsbCAhPSBudWxsICkgewogICAgICAgICAgc2hlbGwuc2V0QWN0aXZlQ2hpbGQoIHRoaXMgKTsKICAgICAgICB9CiAgICAgIH0sCiAgICAgIAogICAgICBsb2FkIDogZnVuY3Rpb24oKSB7CiAgICAgICAgdmFyIGN1cnJlbnQgPSB0aGlzLmdldEFkZHJlc3MoKTsKICAgICAgICBpZiggR0Jyb3dzZXJJc0NvbXBhdGlibGUoKSAmJiBjdXJyZW50ICE9IG51bGwgJiYgY3VycmVudCAhPSAiIiApIHsKICAgICAgICAgIHF4LnVpLmNvcmUuV2lkZ2V0LmZsdXNoR2xvYmFsUXVldWVzKCk7CiAgICAgICAgICBpZiggdGhpcy5fbWFwID09IG51bGwgKSB7CiAgICAgICAgICAgIHRoaXMuX21hcCA9IG5ldyBHTWFwMiggZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIHRoaXMuX2lkICkgKTsKICAgICAgICAgICAgdGhpcy5fbWFwLmFkZENvbnRyb2woIG5ldyBHU21hbGxNYXBDb250cm9sKCkgKTsKICAgICAgICAgICAgdGhpcy5fbWFwLmFkZENvbnRyb2woIG5ldyBHTWFwVHlwZUNvbnRyb2woKSApOwogICAgICAgICAgICBHRXZlbnQuYmluZCggdGhpcy5fbWFwLCAiY2xpY2siLCB0aGlzLCB0aGlzLl9kb0FjdGl2YXRlICk7CiAgICAgICAgICAgIEdFdmVudC5iaW5kKCB0aGlzLl9tYXAsICJtb3ZlZW5kIiwgdGhpcywgdGhpcy5fb25NYXBNb3ZlICk7CiAgICAgICAgICAgIAogICAgICAgICAgfQogICAgICAgICAgdmFyIG1hcCA9IHRoaXMuX21hcDsKICAgICAgICAgIG1hcC5jbGVhck92ZXJsYXlzKCk7CiAgICAgICAgICB0aGlzLl9nZW9jb2Rlci5nZXRMYXRMbmcoCiAgICAgICAgICAgIGN1cnJlbnQsCiAgICAgICAgICAgIGZ1bmN0aW9uKCBwb2ludCApIHsKICAgICAgICAgICAgICBpZiggIXBvaW50ICkgewogICAgICAgICAgICAgICAgYWxlcnQoICInIiArIGN1cnJlbnQgKyAiJyBub3QgZm91bmQiICk7CiAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIG1hcC5zZXRDZW50ZXIoIHBvaW50LCAxMyApOwogICAgICAgICAgICAgICAgdmFyIG1hcmtlciA9IG5ldyBHTWFya2VyKCBwb2ludCApOwogICAgICAgICAgICAgICAgbWFwLmFkZE92ZXJsYXkoIG1hcmtlciApOwogICAgICAgICAgICAgICAgbWFya2VyLm9wZW5JbmZvV2luZG93SHRtbCggY3VycmVudCApOwogICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgICAgKTsKICAgICAgICB9CiAgICAgIH0sCiAgICAgIAogICAgICBfb25NYXBNb3ZlIDogZnVuY3Rpb24oKSB7CiAgICAgICAgaWYoICFvcmdfZWNsaXBzZV9yYXBfcnd0X0V2ZW50VXRpbF9zdXNwZW5kICkgewogICAgICAgICAgdmFyIHdtID0gb3JnLmVjbGlwc2Uuc3d0LldpZGdldE1hbmFnZXIuZ2V0SW5zdGFuY2UoKTsKICAgICAgICAgIHZhciBnbWFwSWQgPSB3bS5maW5kSWRCeVdpZGdldCggdGhpcyApOwogICAgICAgICAgdmFyIGNlbnRlciA9IHRoaXMuX21hcC5nZXRDZW50ZXIoKS50b1N0cmluZygpOwogICAgICAgICAgdmFyIHJlcSA9IG9yZy5lY2xpcHNlLnN3dC5SZXF1ZXN0LmdldEluc3RhbmNlKCk7CiAgICAgICAgICByZXEuYWRkUGFyYW1ldGVyKCBnbWFwSWQgKyAiLmNlbnRlckxvY2F0aW9uIiwgY2VudGVyICk7CiAgICAgICAgfQogICAgICB9LAogICAgCiAgICAgIF9kb1Jlc2l6ZSA6IGZ1bmN0aW9uKCkgewogICAgICAgIHF4LnVpLmNvcmUuV2lkZ2V0LmZsdXNoR2xvYmFsUXVldWVzKCk7CiAgICAgICAgaWYoIHRoaXMuX21hcCAhPSBudWxsICkgewogICAgICAgICAgdGhpcy5fbWFwLmNoZWNrUmVzaXplKCk7CiAgICAgICAgfQogICAgICB9ICAgICAgCiAgICAgIDwvYj4KICAgIH0KICB9ICk7CiAgPC9jb2RlPgogIDwvcHJlPgogIDxwPgogIFRoZXJlIGlzIGEgbGl0dGxlIGhhY2sgaW52b2x2ZWQgd2hpY2ggaXMgZWFzaWx5IGV4cGxhaW5lZC4gV2UgbmVlZCB0byBsaXN0ZW4gdG8gY2xpY2sKICBldmVudHMgaW4gdGhlIG1hcCBhbmQgY29ubmVjdCB0aGVtIHdpdGggb3VyIDxjb2RlPl9kb0FjdGl2YXRlPC9jb2RlPiBtZXRob2QgdG8gYWN0aXZhdGUKICB0aGUgY3VycmVudCBzaGVsbC4gVGhpcyBpcyBuZWVkZWQgYmVjYXVzZSBHb29nbGUgTWFwcyBBUEkgaXMgaW1wbGVtZW50ZWQgd2l0aCBhbiBJRnJhbWUKICBhbmQgY3VycmVudCBicm93c2VyIGdlbmVyYXRpb25zIHNlbmQgZXZlbnRzIG9ubHkgdG8gdGhlaXIgZG9jdW1lbnQuIFRoZSBJRnJhbWUgaXMgaGFuZGxlZAogIGFzIGEgc2VwYXJhdGUgZG9jdW1lbnQgYW5kIHRodXMgd2UgY2Fubm90IGNhdGNoIHRoZSBldmVudHMgdG8gbGV0IHRoZSBzaGVsbCBiZSBhY3RpdmF0ZWQgd2l0aAogIHRoZSBzdGFuZGFyZCBtZWNoYW5pc20uIFRoaXMgaXMgb2Jzb2xldGUgZm9yIGN1c3RvbSB3aWRnZXRzIHdpdGhvdXQgSUZyYW1lcy4KICA8L3A+CiAgPHA+CiAgVGhlIG90aGVyIGV2ZW50IGxpc3RlbmVyIGZvciB0aGUgPGNvZGU+bW92ZWVuZDwvY29kZT4gZXZlbnQgd2lsbCB0cmlnZ2VyIGEgZnVuY3Rpb24gdG8gc2VuZAogIHRoZSBjdXJyZW50IGxvY2F0aW9uIG9mIHRoZSBtYXAgdG8gdGhlIHNlcnZlci4gVGhlcmVmb3JlIHdlIG5lZWQgdG8gZ2V0IHRoZSBJZCAtIHdoaWNoIGlzCiAgYWxsb2NhdGVkIGJ5IFJBUCAtIG9mIHRoZSBjdXJyZW50IHdpZGdldCAgYW5kIG9idGFpbmVkIHZpYSB0aGUgV2lkZ2V0TWFuYWdlciBvbiB0aGUgY2xpZW50IHNpZGUuCiAgVGhlbiB3ZSB1c2UgdGhlIGN1cnJlbnQgPGNvZGU+UmVxdWVzdDwvY29kZT4gb2JqZWN0IHRvIGFkZCBhIG5ldyBwYXJhbWV0ZXIgd2hpY2ggd2lsbCBiZQogIHByb2Nlc3NlZCBsYXRlciBhdCB0aGUgc2VydmVyIHNpZGUuIElmIHlvdSB3YW50IHRvIGltbWVkaWF0ZWx5IHNlbmQgdGhlIHBhcmFtZXRlciB0byB0aGUgc2VydmVyCiAgdXNlIDxjb2RlPnJlcS5zZW5kKCk8L2NvZGU+LiBCdXQgYXMgd2UgZG9uJ3QgbmVlZCB0aGlzIGZvciBub3cgd2UganVzdCBhZGQgdGhlIHBhcmFtZXRlcgogIHRvIHRoZSByZXF1ZXN0IG9iamVjdCBhbmQgaXQgd2lsbCBiZSB0cmFuc2ZlcmVkIGF1dG9tYXRpY2FsbHkgdG8gdGhlIHNlcnZlciB3aXRoIHRoZSBuZXh0IHJlcXVlc3QuCiAgPC9wPgogIDxwPgogIE9rLCB3ZSdyZSBhbG1vc3QgZG9uZSB3aXRoIG91ciBjbGllbnQtc2lkZSBpbXBsZW1lbnRhdGlvbi4gQnV0IHRoZSBrZXkgcGFydCBvZiB0aGUgd2hvbGUgd2lkZ2V0CiAgaXMgc3RpbGwgbWlzc2luZzogdGhlIHBpZWNlIGJldHdlZW4gdGhlIHNlcnZlciBhbmQgdGhlIGNsaWVudC4KICA8L3A+CiAgPHAgc3R5bGU9ImJvcmRlcjoxcHggZG90dGVkIGdyZXk7Ij48c3Ryb25nPk5vdGU6PC9zdHJvbmc+IFRoZSBxb294ZG9vIGJ1aWxkIHdoaWNoIGdldHMgZGVsaXZlcmVkIHdpdGggUkFQIGlzIDxzdHJvbmc+bm90PC9zdHJvbmc+CiAgdGhlIHNhbWUgcW9veGRvbyB5b3UnbGwgZmluZCBvbiB0aGVpciB3ZWJwYWdlLiBXZSBzdHJpcHBlZCBpdCBkb3duIHRvIGhhdmUgdGhlCiAgYmVzdCBtaXggYmV0d2VlbiBuZWVkZWQgZnVuY3Rpb25hbGl0eSBhbmQgc2l6ZS4gU28gdGhlcmUgbWF5IGJlIGNsYXNzZXMgd2hpY2ggYXJlCiAgYXZhaWxhYmxlIGluIHBsYWluIHFvb3hkb28gYnV0IG5vdCBpbiB0aGUgdmVyc2lvbiBvZiBSQVAuPC9wPgoKICA8aDM+RmlsbGluZyB0aGUgZ2FwIGJldHdlZW4gY2xpZW50IGFuZCBzZXJ2ZXI8L2gzPgogIDxwPgogIEluIG91ciBjdXJyZW50IHNpdHVhdGlvbiB3ZSBoYXZlIGFscmVhZHkgZG9uZSB0d28gaW1wb3J0YW50IHRhc2tzOiB0aGUgc2VydmVyLSBhbmQgdGhlIGNsaWVudC1zaWRlCiAgd2lkZ2V0LiBOb3cgd2UgbmVlZCB0byBjb25uZWN0IGVhY2ggb3RoZXIgaW4gb3JkZXIgdG8gY29udHJvbCB0aGUgd2lkZ2V0IG9uIHRoZSBjbGllbnQgYnkKICBjYWxsaW5nIGl0IG9uIHRoZSBzZXJ2ZXIgKHdoZXJlIG91ciBhcHBsaWNhdGlvbiBsaXZlcykuCiAgSW4gUkFQIC0gbW9yZSBwcmVjaXNlbHkgaW4gUldUIC0gd2UgaGF2ZSBhIGNvbmNlcHQgY2FsbGVkIHRoZSAiTGlmZSBDeWNsZSIuIFdpdGggZWFjaCByZXF1ZXN0CiAgZnJvbSB0aGUgY2xpZW50IHRoZSBsaWZlIGN5Y2xlIG9uIHRoZSBzZXJ2ZXIgc2lkZSB3aWxsIGJlIGV4ZWN1dGVkLiBJdCBpcyByZXNwb25zaWJsZSB0byBwcm9jZXNzCiAgYWxsIGNoYW5nZXMgYW5kIGV2ZW50cyBmcm9tIHRoZSBjbGllbnQgYW5kIGluIHRoZSBlbmQgaXQgd2lsbCBzZW5kIGJhY2sgYSByZXNwb25zZSB0byB0aGUgY2xpZW50CiAgd2hhdCB0byBkbyAobW9zdGx5IGhpZGUvc2hvdyB3aWRnZXRzLCB1cGRhdGUgZGF0YSwgZXRjKS4KICBUaGUgbGlmZSBjeWNsZSBpdHNlbGYgaXMgc3BsaXR0ZWQgdXAgaW4gc2V2ZXJhbCBwaGFzZXMgd2hpY2ggYXJlIGV4ZWN1dGVkIGluIGEgc3BlY2lmaWMgb3JkZXIuCiAgPC9wPgogIDx0YWJsZSBib3JkZXI9IjEiPgogICAgPHRyPgogICAgICAgIDx0aD5QaGFzZTwvdGg+CiAgICAgICAgPHRoPkRlc2NyaXB0aW9uPC90aD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPlJlYWREYXRhPC90ZD4KICAgICAgICA8dGQ+VGhpcyBpcyByZXNwb25zaWJsZSB0byByZWFkIHRoZSB2YWx1ZXMgc2VuZGVkIGZyb20gdGhlIGNsaWVudCBsaWtlIG9jY3VycmVkIGV2ZW50cy4KICAgICAgICBBdCB0aGUgZW5kIG9mIHRoaXMgcGhhc2UsIGFsbCB3aWRnZXQgYXR0cmlidXRlcyBhcmUgaW4gc3luYyBhZ2FpbiB3aXRoIHRoZSB2YWx1ZXMgb24gdGhlIGNsaWVudC4KICAgICAgICBUaGUgYXR0cmlidXRlcyBhcmUgcHJlc2VydmVkIGZvciBsYXRlciB1c2UuPC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPlByb2Nlc3NBY3Rpb248L3RkPgogICAgICAgIDx0ZD5Qcm9jZXNzQWN0aW9uIGlzIHJlc3BvbnNpYmxlIGZvciBkaXNwYXRjaGluZyB0aGUgZXZlbnRzIHRvIHRoZSB3aWRnZXRzLiBBdHRyaWJ1dGVzIG1heQogICAgICAgIGNoYW5nZSBpbiB0aGlzIHBoYXNlIGFzIGEgcmVzcG9uc2UgZm9yIHRoZSBldmVudHMuPC90ZD4KICAgIDwvdHI+CiAgICA8dHI+CiAgICAgICAgPHRkPlJlbmRlcjwvdGQ+CiAgICAgICAgPHRkPkF0IHRoZSBlbmQgb2YgdGhlIGxpZmVjeWNsZSBldmVyeSBjaGFuZ2Ugd2lsbCBiZSByZW5kZXJlZCB0byB0aGUgY2xpZW50LjxiciAvPgogICAgICAgIEJlIGF3YXJlIHRoYXQgb25seSB2YWx1ZXMgd2hpY2ggYXJlIGRpZmZlcmVudCB0aGFuIHRoZXJlIHByZXNlcnZlZCBvbmVzIGFyZSBzZW5kIHRvCiAgICAgICAgdGhlIGNsaWVudCAobWVhbnM6IG9ubHkgdGhlIGRlbHRhKS48L3RkPgogICAgPC90cj4KICA8L3RhYmxlPgogIDxwPgogIFRvIHBhcnRpY2lwYXRlIGluIHRoZSBsaWZlIGN5Y2xlIC0gd2hhdCBpcyB3aGF0IHdlIHdhbnQgdG8gZG8gd2l0aCBvdXIgY3VzdG9tIHdpZGdldCAtCiAgd2UgbmVlZCB0byBwcm92aWRlIGEgTGlmZSBDeWNsZSBBZGFwdGVyIChMQ0EpLiBUaGVyZSBhcmUgbm93IHR3byB3YXlzIHRvIGNvbm5lY3QgdGhlIExDQQogIHdpdGggb3VyIHdpZGdldC4gT24gdGhlIG9uZSBoYW5kIHNpZGUgd2UgY2FuIHJldHVybiBpdCBkaXJlY3RseSB3aGVuIHNvbWVvbmUgYXNrcyBvdXIgd2lkZ2V0CiAgd2l0aCA8Y29kZT5nZXRBZGFwdGVyPC9jb2RlPiB0byBwcm92aWRlIGEgTENBLiBUaGlzIGNhbiBiZSBkb25lIGJ5IGltcGxlbWVudGluZyB0aGUKICA8Y29kZT5nZXRBZGFwdGVyPC9jb2RlPiBtZXRob2QgaW4gb3VyIG93biB3aWRnZXQgbGlrZSB0aGlzOgogIDxwcmU+CiAgPGNvZGU+CiAgLi4uCiAgcHVibGljIE9iamVjdCBnZXRBZGFwdGVyKCBDbGFzcyBhZGFwdGVyICkgewogICAgT2JqZWN0IHJlc3VsdDsKICAgIGlmKCBhZGFwdGVyID09IElMaWZlQ3ljbGVBZGFwdGVyLmNsYXNzICkgewogICAgICByZXN1bHQgPSBuZXcgTXlDdXN0b21XaWRnZXRMQ0EoKTsKICAgIH0gZWxzZSB7CiAgICAgIHJlc3VsdCA9IHN1cGVyLmdldEFkYXB0ZXIoIGFkYXB0ZXIgKTsKICAgIH0KICAgIHJldHVybiByZXN1bHQ7CiAgfQogIC4uLgogIDwvcHJlPgogIDwvY29kZT4KICBUaGUgcHJlZmVycmVkIHdheSBpcyB0byBsZXQgUkFQIGRvIHRoaXMgaXRzZWxmIGJ5IGNyZWF0aW5nIHRoZSBMQ0EgY2xhc3MgaW4gYSBwYWNrYWdlIGNhbGxlZAogIDx3aWRnZXRwYWNrYWdlPi5pbnRlcm5hbC48d2lkZ2V0bmFtZT5raXQuPHdpZGdldG5hbWU+TENBLiBUaGUgb3JkZXIgb2YgdGhlIGludGVybmFsCiAgZG9lcyBub3QgcGxheSB0aGUgYmlnIHJvbGUuIFRoZSBpbXBvcnRhbnQgdGhpbmcgaXMgdG8gaGF2ZSBpbnRlcm5hbCBpbiB0aGUgcGFja2FnZQogIG5hbWUsIHRoZSBwYWNrYWdlIHdpdGggdGhlIExDQSBpcyBjYWxsZWQgPHdpZGdldG5hbWU+a2l0IGFuZCB0aGUgTENBIGl0c2VsZiBpcyAKICBjYWxsZWQgPHdpZGdldG5hbWU+TENBLjxiciAvPgogIEhlcmUgYSBsaXR0bGUgZXhhbXBsZTo8YnIgLz4KICBPdXIgd2lkZ2V0IGlzIDxjb2RlPm9yZy5lY2xpcHNlLnJhcC5nbWFwcy5HTWFwPC9jb2RlPjxiciAvPgogIFRoZW4gb3VyIExDQSBzaG91bGQgYmUgbmFtZWQgPGNvZGU+b3JnLmVjbGlwc2UucmFwLmludGVybmFsLmdtYXBzLmdtYXBraXQuR01hcExDQTwvY29kZT48YnIgLz4KICBUaGUgTENBIGNsYXNzIGl0c2VsZiBuZWVkcyB0byBoYXZlIDxjb2RlPm9yZy5lY2xpcHNlLnJ3dC5saWZlY3ljbGUuQWJzdHJhY3RXaWRnZXRMQ0E8L2NvZGU+CiAgYXMgc3VwZXIgY2xhc3MgdG8gb3ZlcnJpZGUgc29tZSBvZiB0aGUgbmVlZGVkIG1ldGhvZHMuIEl0J3MgZW5vdWdoIHRvIGhhdmUgdGhlIExDQSBpbXBsZW1lbnQKICA8Y29kZT5JV2lkZ2V0TGlmZUN5Y2xlQWRhcHRlcjwvY29kZT4gYnV0IHdlIHJlY29tbWVuZCB0byB1c2UgPGNvZGU+QWJzdHJhY3RXaWRnZXRMQ0E8L2NvZGU+LgogIFdlJ2xsIGp1c3Qgc2hvdyB5b3UgYSBsaXR0bGUKICBvdmVydmlldyBvZiB0aGUgbWV0aG9kcyBhbmQgdGhlaXIgcm9sZSBhbmQgdGhlbiBnbyBmdXJ0aGVyIHRvIGltcGxlbWVudCBhIHdvcmtpbmcgTENBIGZvciBvdXIgR01hcHMgd2lkZ2V0LgogIDwvcD4KICA8dGFibGUgYm9yZGVyPSIxIj4KICAgIDx0cj4KICAgICAgICA8dGg+TWV0aG9kIG5hbWU8L3RoPgogICAgICAgIDx0aD5EZXNjcmlwdGlvbjwvdGg+CiAgICA8L3RyPgogICAgPHRyPgogICAgICAgIDx0ZD48Y29kZT5yZW5kZXJJbml0aWFsaXphdGlvbihXaWRnZXQpPC9jb2RlPjwvdGQ+CiAgICAgICAgPHRkPlRoaXMgbWV0aG9kIGlzIGNhbGxlZCB0byBpbml0aWFsaXplIHlvdXIgd2lkZ2V0LiBOb3JtYWxseSB5b3Ugd2lsbCAKICAgICAgICB0ZWxsIFJBUCB3aGljaCBjbGllbnQtc2lkZSBjbGFzcyB0byB1c2UgYW5kIGhvdyBpdCBpcyBpbml0aWFsaXplZCAKICAgICAgICAodGhpbmsgb2Ygc3R5bGUgYml0cyk8L3RkPgogICAgPC90cj4KICAgIDx0cj4KICAgICAgICA8dGQ+PGNvZGU+cHJlc2VydmVWYWx1ZXMoV2lkZ2V0KTwvY29kZT48L3RkPgogICAgICAgIDx0ZD5IZXJlIHdlIGhhdmUgdG8gcHJlc2VydmUgb3VyIHZhbHVlcyBzbyB3ZSBjYW4gc2VlIGF0IHRoZSBlbmQgb2YgCiAgICAgICAgdGhlIGxpZmVjeWNsZSBpZiBzb21ldGhpbmcgaGFzIGNoYW5nZXMgZHVyaW5nIHRoZSBwcm9jZXNzIGFjdGlvbiAKICAgICAgICBwaGFzZS48L3RkPgogICAgPC90cj4KICAgIDx0cj4KICAgICAgICA8dGQ+PGNvZGU+cmVuZGVyQ2hhbmdlcyhXaWRnZXQpPC9jb2RlPjwvdGQ+CiAgICAgICAgPHRkPlRoYXQncyB0aGUgbW9zdCBpbnRlcmVzdGluZyBwYXJ0LiBXZSBuZWVkIHRvIHN5bmMgdGhlIGF0dHJpYnV0ZXMgb2YgdGhlCiAgICAgICAgd2lkZ2V0IG9uIHRoZSBzZXJ2ZXIgd2l0aCB0aGUgdGhlIGNsaWVudC1zaWRlIGltcGxlbWVudGF0aW9uIGJ5IHNlbmRpbmcKICAgICAgICB0aGUgY2hhbmdlcyB0byB0aGUgY2xpZW50LjwvdGQ+CiAgICA8L3RyPgogICAgPHRyPgogICAgICAgIDx0ZD48Y29kZT5yZW5kZXJEaXNwb3NlKFdpZGdldCk8L2NvZGU+PC90ZD4KICAgICAgICA8dGQ+WW91IGNhbiB0aWR5IHVwIHNldmVyYWwgdGhpbmdzIGhlcmUgYmVmb3JlIHRoZSB3aWRnZXQgZ2V0cyBkaXNwb3NlZCAKICAgICAgICBvZiBvbiB0aGUgY2xpZW50LjwvdGQ+CiAgICA8L3RyPgogIDwvdGFibGU+CiAgPHA+CiAgQWZ0ZXIgaGF2aW5nIGEgYnJpZWYgb3ZlcnZpZXcgb2YgdGhlIHByaW5jaXBsZXMgb2YgdGhlIExpZmUgQ3ljbGUgQWRhcHRlciBsZXQncyBzdGFydAogIGJ5IGltcGxlbWVudGluZyB0aGUgTENBIGZvciBvdXIgR01hcCB3aWRnZXQuCiAgQWZ0ZXIgY3JlYXRpbmcgdGhlIExDQSBjbGFzcyAtIHdoaWNoIGV4dGVuZHMgQWJzdHJhY3RXaWRnZXRMQ0EgLSB3ZSB3aWxsIGZpbGwgdGhlIGludGVyZXN0aW5nCiAgbWV0aG9kcyB3aXRoIHNvbWUgbG9naWMuIEZpcnN0IGNvbWVzIHRoZSBpbml0aWFsaXphdGlvbi4KICA8L3A+CiAgPHByZT4KICA8Y29kZT4KICBwdWJsaWMgdm9pZCByZW5kZXJJbml0aWFsaXphdGlvbiggV2lkZ2V0IHdpZGdldCApIHRocm93cyBJT0V4Y2VwdGlvbiB7CiAgICBKU1dyaXRlciB3cml0ZXIgPSBKU1dyaXRlci5nZXRXcml0ZXJGb3IoIHdpZGdldCApOwogICAgU3RyaW5nIGlkID0gV2lkZ2V0VXRpbC5nZXRJZCggd2lkZ2V0ICk7CiAgICB3cml0ZXIubmV3V2lkZ2V0KCAib3JnLmVjbGlwc2UucmFwLmdtYXBzLkdNYXAiLCBuZXcgT2JqZWN0W10geyBpZCB9ICk7CiAgICB3cml0ZXIuc2V0KCAiYXBwZWFyYW5jZSIsICJjb21wb3NpdGUiICk7CiAgICB3cml0ZXIuc2V0KCAib3ZlcmZsb3ciLCAiaGlkZGVuIiApOwogICAgQ29udHJvbExDQVV0aWwud3JpdGVTdHlsZUZsYWdzKCAoIEdNYXAgKXdpZGdldCApOwogIH0KICA8L2NvZGU+CiAgPC9wcmU+CiAgPHA+CiAgQmFzaWNhbGx5IHRoZSBjbGFzcyA8Y29kZT5KU1dyaXRlcjwvY29kZT4gaXMgcmVzcG9uc2libGUgZm9yIHRyYW5zZm9ybWluZyBvdXIgamF2YSBjYWxscwogIGFuZCBzZXR0ZXJzIGludG8gdGhlIGNvcnJlc3BvbmRpbmcgamF2YXNjcmlwdCB3aGljaCBnZXRzIHRyYW5zZmVyZWQgdG8gdGhlIGNsaWVudC4KICBUaGUgPGNvZGU+SlNXcml0ZXI8L2NvZGU+IGlzIGFsc28gcmVzcG9uc2libGUgdG8gb25seSB3cml0ZSBvdXQgY2hhbmdlcyB3aGljaCBhcmUgZGlmZmVyZW50CiAgdGhhbiB0aGVpciBwcmVzZXJ2ZWQgdmFsdWUuIEZvciBlYWNoIHdpZGdldCB5b3UgaGF2ZSBhbiBvd24gPGNvZGU+SlNXcml0ZXI8L2NvZGU+IGluc3RhbmNlCiAgc28gUkFQIGNhbiBkZWNpZGUgdG8gd2hpY2ggd2lkZ2V0IHRoZSBjYWxsIGJlbG9uZ3MuCiAgQXMgeW91IGNhbiBzZWUgaW4gdGhlIHNuaXBwZXQsIDxjb2RlPkpTV3JpdGVyI25ld1dpZGdldDwvY29kZT4gaXMgY2FsbGVkIHRvIGNyZWF0ZSBhIG5ldyB3aWRnZXQKICBvbiB0aGUgY2xpZW50IHNpZGUuIFRoZSBzZWNvbmQgcGFyYW1ldGVycyBpcyBhbiBhcnJheSBvZiA8Y29kZT5PYmplY3Q8L2NvZGU+cyB3aGljaCBhcmUKICBwYXNzZWQgdG8gdGhlIGNvbnN0cnVjdG9yIG9mIHRoZSBxb294ZG9vIGNsYXNzIChzZWUgYWJvdmUpLgogIFdpdGggPGNvZGU+SlNXcml0ZXIjc2V0PC9jb2RlPiB5b3UgY2FuIGVhc2lseSBzZXQgZGlmZmVyZW50IGF0dHJpYnV0ZXMgb2YgeW91ciBxb294ZG9vIG9iamVjdC4KICBUaGlzIGNvdWxkIGFsc28gYmUgZG9uZSBpbiBKYXZhc2NyaXB0IGFuZCBpcyBqdXN0IGEgc2hvd2Nhc2UgaW4gaGVyZS4KICBUaGUgbmV4dCBzdGVwIGlzIHRvIHByZXNlcnZlIG91ciB2YWx1ZXMgdGhlcmV3aXRoIFJBUCBjYW4gZGVjaWRlIGluIHRoZSBuZXh0IHJlcXVlc3QgaWYgdGhlcmUKICBoYXMgc29tZXRoaW5nIGNoYW5nZWQgaW4gdGhlIG1lYW50aW1lLiBBcyB3ZSBqdXN0IGhhdmUgdGhlIGFkZHJlc3Mgd2hpY2ggY291bGQgY2hhbmdlIHRoaXMgaXMKICByZWxhdGl2ZSBzdHJhaWdodCBmb3J3YXJkLgogIDwvcD4KICA8cHJlPgogIDxjb2RlPgogIHByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBQUk9QX0FERFJFU1MgPSAiYWRkcmVzcyI7CiAgCiAgcHVibGljIHZvaWQgcHJlc2VydmVWYWx1ZXMoIFdpZGdldCB3aWRnZXQgKSB7CiAgICBDb250cm9sTENBVXRpbC5wcmVzZXJ2ZVZhbHVlcyggKCBDb250cm9sICl3aWRnZXQgKTsKICAgIElXaWRnZXRBZGFwdGVyIGFkYXB0ZXIgPSBXaWRnZXRVdGlsLmdldEFkYXB0ZXIoIHdpZGdldCApOwogICAgYWRhcHRlci5wcmVzZXJ2ZSggUFJPUF9BRERSRVNTLCAoICggR01hcCApd2lkZ2V0ICkuZ2V0QWRkcmVzcygpICk7CiAgfQogIDwvY29kZT4KICA8L3ByZT4KICA8cD4KICBGaXJzdCB3ZSB1c2UgPGNvZGU+Q29udHJvbExDQVV0aWwjcHJlc2VydmVWYWx1ZXM8L2NvZGU+IHRvIGhhdmUgbW9zdCBvZiB0aGUgd29yayBkb25lCiAgYnkgdGhlIGZyYW1ld29yay4gSXQncyByZXNwb25zaWJsZSBmb3IgcHJlc2VydmluZyB2YWx1ZXMgbGlrZSB0b29sdGlwLCB0YWJpbmRleCwgc2l6ZSwgZXRjLgogIFNvIHdlIG9ubHkgbmVlZCB0byBjYXJlIGFib3V0IHRoZSB0aGluZ3MgaW1wbGVtZW50ZWQgaW4gb3VyIHdpZGdldC4KICBXZSBqdXN0IHJlcXVlc3QgYSBzbyBjYWxsZWQgPGNvZGU+SVdpZGdldEFkYXB0ZXI8L2NvZGU+IHdoaWNoIGlzIHJlc3BvbnNpYmxlIGZvciBkaWZmZXJlbnQKICBhc3BlY3RzIGluIHRoZSBsaWZlY3ljbGUgb2YgYSB3aWRnZXQuIEluIHRoaXMgY2FzZSB3ZSBvbmx5IHVzZSBpdCB0byBwcmVzZXJ2ZSB0aGUgPGNvZGU+YWRkcmVzczwvY29kZT4gdmFsdWUKICB3aXRoIGEgcHJlZGVmaW5lZCBrZXkgKDxjb2RlPlBST1BfQURSRVNTPC9jb2RlPikgdG8gYXNzb2NpYXRlIGl0IGxhdGVyLgogIDwvcD4KICA8cD4KICBUaGUgZm9sbG93aW5nIHN0ZXAgaXMgb25lIG9mIG1vc3QgaW50ZXJlc3RpbmcgcGFydHMgb2YgeW91ciBsaWZlY3ljbGUgYWRhcHRlciAtIHRoZQogIDxjb2RlPnJlbmRlckNoYW5nZXM8L2NvZGU+IG1ldGhvZC4gQXMgc2FpZCBiZWZvcmUgaXQgaXMgcmVzcG9uc2libGUgdG8gd3JpdGUgZXZlcnkKICBjaGFuZ2UgdG8gdGhlIG91dGdvaW5nIHN0cmVhbSB3aGljaCBpcyBleGVjdXRlZCBvbiB0aGUgY2xpZW50LiBMZXQncyB0YWtlIGEgbG9vayBhdCB0aGUKICBpbXBsZW1lbnRhdGlvbjoKICAKICA8L3A+CiAgPHByZT4KICA8Y29kZT4KICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgSlNfUFJPUF9BRERSRVNTID0gImFkZHJlc3MiOwogIAogIHB1YmxpYyB2b2lkIHJlbmRlckNoYW5nZXMoIFdpZGdldCB3aWRnZXQgKSB0aHJvd3MgSU9FeGNlcHRpb24gewogICAgR01hcCBnbWFwID0gKCBHTWFwICl3aWRnZXQ7CiAgICBDb250cm9sTENBVXRpbC53cml0ZUNoYW5nZXMoIGdtYXAgKTsKICAgIEpTV3JpdGVyIHdyaXRlciA9IEpTV3JpdGVyLmdldFdyaXRlckZvciggd2lkZ2V0ICk7CiAgICB3cml0ZXIuc2V0KCBQUk9QX0FERFJFU1MsIEpTX1BST1BfQUREUkVTUywgZ21hcC5nZXRBZGRyZXNzKCkgKTsKICB9CiAgPC9jb2RlPgogIDwvcHJlPgoKICA8cD4KICBBZ2FpbiB3ZSB1c2UgdGhlIDxjb2RlPkNvbnRyb2xMQ0FVdGlsPC9jb2RlPiB0byB3cml0ZSB0aGUgY2hhbmdlcyB3aGljaCBhcmUgaW1wbGVtZW50ZWQgb24KICA8Y29kZT5Db250cm9sPC9jb2RlPiBhbmQgdGh1cyB3ZSBzaG91bGQgbm90IGNhcmUgd2hhdCdzIGJlaGluZCBpdCAoZm9yIHRob3NlIHdobyByZWFsbHkgd2FudCB0byBrbm93IGl0IC0gCiAgaXQncyB0aGUgc2FtZSBhcyBwcmVzZXJ2aW5nIHRoZSB2YWx1ZXMgbGlrZSB0b29sdGlwLCB0YWJpbmRleCwgc2l6ZSwgZXRjKS4KICBMaWtlIGluIHRoZSB3aWRnZXQgaW5pdGlhbGl6YXRpb24gd2UgaGF2ZSB0byByZW5kZXIgc29tZXRoaW5nIGFuZCB0aGVyZWZvcmUgd2UKICBuZWVkIHRvIG9idGFpbiB0aGUgY29ycmVzcG9uZGluZyA8Y29kZT5KU1dyaXRlcjwvY29kZT4gaW5zdGFuY2UgZm9yIG91ciB3aWRnZXQuIFdlIG5lZWQgdG8gdXNlCiAgPGNvZGU+SlNXcml0ZXIjc2V0PC9jb2RlPiB0byBzZXQgYSBzcGVjaWZpYyBhdHRyaWJ1dGUgdG8gdGhlIHdpZGdldCBpbnN0YW5jZSBvbiB0aGUgY2xpZW50LXNpZGUuCiAgVGhlcmUgYXJlIG1hbnkgZGlmZmVyZW50IDxjb2RlPnNldDwvY29kZT4gaW1wbGVtZW50YXRpb25zIGF2YWlsYWJsZSBmb3IgZXZlcnkgbmVlZC4gVGhlIG9uZSB1c2VkCiAgaGVyZSBpcyBzaW1wbGU6IFdlIHBhc3MgdGhlIGtleSBmb3IgdGhlIHByZXNlcnZlZCB2YWx1ZSB0byB0aGUgbWV0aG9kIHNvIFJBUCBjYW4gY2hlY2sgaWYgdGhlcmUgaGFzCiAgc29tZXRoaW5nIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QgdGltZSBpdCB3YXMgcHJlc2VydmVkLCB3ZSBwYXNzIHRoZSBuYW1lIG9mIHRoZSBjbGllbnQtc2lkZSBhdHRyaWJ1dGUKICB3aGljaCBnZXRzIHRyYW5zZm9ybWVkIGludG8gInNldCoiIGFuZCBsYXN0IGJ1dCBub3QgbGVhc3QgdGhlIHZhbHVlIGZvciB0aGlzIHNldHRlci4KICBBcyB3ZSBjYW4gc2VlLCB0aGUgbmFtZSBvZiB0aGUgamF2YXNjcmlwdCBhdHRyaWJ1dGUgKDxjb2RlPkpTX1BST1BfQURSRVNTPC9jb2RlPikgd2lsbCBjYWxsIHRoZSBtZXRob2QKICA8Y29kZT5zZXRBZHJlc3M8L2NvZGU+IG9uIHRoZSBjb3JyZXNwb25kaW5nIHdpZGdldCBpbnN0YW5jZSBvbiB0aGUgY2xpZW50LiBJZiB5b3Ugd29uZGVyIHdoZXJlIHRoaXMKICBtZXRob2QgaXMsIHRha2UgYSBsb29rIGF0IHRoZSBxb294ZG9vIHByb3BlcnR5IHN5c3RlbS4gVGhlIGFkZHJlc3MgcHJvcGVydHkgb2Ygb3VyIHdpZGdldCB3aWxsIGJlIHRyYW5zZm9ybWVkCiAgYnkgcW9veGRvbyBpbnRvIGEgc2V0KiBhbmQgZ2V0KiBtZXRob2RzIGF0IHJ1bnRpbWUuCiAgPC9wPgogIDxwPgogIE5vdyB3ZSBuZWVkIHRvIHByb2Nlc3MgdGhlIGFjdGlvbnMgdHJhbnNmZXJlZCB0byB0aGUgc2VydmVyIChhdCBsZWFzdCBpZiB0aGVyZSBhcmUgYW55KS4KICBXZSBzZWUgaW4gdGhlIDxjb2RlPkdNYXAuanM8L2NvZGU+IHRoYXQgaWYgdGhlIHVzZXIgbW92ZXMgdGhlIG1hcCBhIG5ldyBwYXJhbWV0ZXIgY2FsbGVkCiAgPGNvZGU+Y2VudGVyTG9jYXRpb248L2NvZGU+IHdpbGwgYmUgYXR0YWNoZWQgdG8gdGhlIGN1cnJlbnQgcmVxdWVzdCBhbmQgdHJhbnNmZXJlZCB0byB0aGUKICBzZXJ2ZXIuIFRvIHJlYWQgYW5kIHByb2Nlc3MgaXQgdGhlIDxjb2RlPnJlYWREYXRhPC9jb2RlPiBtZXRob2Qgb2YgdGhlIExDQSBpcyB1c2VkLgogIDwvcD4KICA8cHJlPgogIDxjb2RlPgogIHByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBQQVJBTV9DRU5URVIgPSAiY2VudGVyTG9jYXRpb24iOwogIAogIHB1YmxpYyB2b2lkIHJlYWREYXRhKCBXaWRnZXQgd2lkZ2V0ICkgewogICAgR01hcCBtYXAgPSAoIEdNYXAgKXdpZGdldDsKICAgIFN0cmluZyBsb2NhdGlvbiA9IFdpZGdldExDQVV0aWwucmVhZFByb3BlcnR5VmFsdWUoIG1hcCwgUEFSQU1fQ0VOVEVSICk7CiAgICBtYXAuc2V0Q2VudGVyTG9jYXRpb24oIGxvY2F0aW9uICk7CiAgfQogIDwvY29kZT4KICA8L3ByZT4KICA8cD4KICBBcyB5b3UgY2FuIHNlZSwgaXQncyByZWFsbHkgZWFzeS4gWW91IGp1c3QgbmVlZCB0byBhc2sgdGhlIDxjb2RlPldpZGdldExDQVV0aWwjcmVhZFByb3BlcnR5VmFsdWU8L2NvZGU+CiAgZm9yIHRoZSBwYXJhbWV0ZXIgYW5kIHBhc3MgaXQgdG8gdGhlIHNlcnZlci1zaWRlIHdpZGdldCBpbXBsZW1lbnRhdGlvbi4gSWYgeW91IHdvbmRlciB3aHkgdGhlIAogIGNlbnRlciBsb2NhdGlvbiBkb2VzIG5vdCBnZXQgd3JpdHRlbiBpbiB0aGUgPGNvZGU+cmVuZGVyQ2hhbmdlczwvY29kZT4gbWV0aG9kIHdlIGltcGxlbWVudGVkIGFib3ZlOgogIFRoaXMgd2lsbCBiZSB5b3VyIHRhc2sgYXQgdGhlIGVuZCBvZiB0aGUgdHV0b3JpYWwuCiAgTm9ybWFsbHkgeW91IHdvbid0IGhhdmUgcHVibGljIG1ldGhvZHMgZm9yIGF0dHJpYnV0ZXMgd2hpY2ggYXJlIG5vdCBjaGFuZ2VhYmxlIHByb2dyYW1tYXRpY2FsbHkuCiAgRm9yIHRoaXMgeW91IHdvdWxkIHVzZSBhbiBhZGFwdGVyIG9yIGFub3RoZXIgbWVjaGFuaXNtIHRvIGltcGxlbWVudCB0aGUgc2V0dGVyIGJlaGluZCB0aGUgc2NlbmVzLgogIEF0IHRoZSBlbmQgb2YgdGhlIHR1dG9yaWFsIGl0IGlzIHlvdXIgdGFzayBoaWRlIHRoZSBwdWJsaWMgPGNvZGU+c2V0Q2VudGVyTG9jYXRpb248L2NvZGU+CiAgbWV0aG9kIG9mIHRoZSA8Y29kZT5HTWFwPC9jb2RlPiB3aWRnZXQgb3IgLSBldmVuIGJldHRlciAtIHRvIGltcGxlbWVudCB0aGUgcmVuZGVyaW5nIG9mCiAgdGhlIGNlbnRlciBsb2NhdGlvbiB5b3Vyc2VsZi4gCiAgPC9wPgogIDxwPgogIFRoZSBsYXN0IHN0ZXAgaXMgdG8gaW1wbGVtZW50IHRoZSB3YXkgb3VyIHdpZGdldCBpcyBkaXNwb3NlZCBvbiB0aGUgY2xpZW50LiBOb3JtYWxseSB0aGVyZSBpcyBubwogIG5lZWQgdG8gY2FyZSBmb3IgYW55dGhpbmcgZWxzZSBhbmQgdGhpcyBpcyBhbHNvIHRoZSBjYXNlIHdpdGggb3VyIEdNYXAgd2lkZ2V0LiBJZiB5b3UgcmVhbGx5IGhhdmUKICB0byBkbyBhbnkgb3RoZXIgc3R1ZmYgbGlrZSBjYWxsaW5nIHNwZWNpZmljIG1ldGhvZHMgYmVmb3JlIHRoZSB3aWRnZXQgaXMgZGlzcG9zZWQgeW91IHNob3VsZCBkbyBpdAogIGhlcmUuCiAgPC9wPgogIDxwcmU+CiAgPGNvZGU+CiAgcHVibGljIHZvaWQgcmVuZGVyRGlzcG9zZSggV2lkZ2V0IHdpZGdldCApIHRocm93cyBJT0V4Y2VwdGlvbiB7CiAgICBKU1dyaXRlciB3cml0ZXIgPSBKU1dyaXRlci5nZXRXcml0ZXJGb3IoIHdpZGdldCApOwogICAgd3JpdGVyLmRpc3Bvc2UoKTsKICB9CiAgPC9jb2RlPgogIDwvcHJlPgogIDxwPgogIFRoZXJlIGFyZSBub3cgdHdvIGFkZGl0aW9uYWwgbWV0aG9kcyBjYWxsZWQgPGNvZGU+Y3JlYXRlUmVzZXRIYW5kbGVyQ2FsbHM8L2NvZGU+IGFuZAogIDxjb2RlPmdldFR5cGVQb29sSWQ8L2NvZGU+LiBUaGVzZSB3ZXJlIGludHJvZHVjZWQgYnkgYSBtZWNoYW5pc20gdGhhdCBoZWxwcyB0byBzb2Z0ZW4gdGhlIG1hc3NpdmUKICBtZW1vcnkgY29uc3VtcHRpb24gb24gdGhlIGNsaWVudC4gTWFueSBvZiB0aGUgY2xpZW50LXNpZGUgd2lkZ2V0cyBhcmUgbm90IHRocm93biBhd2F5CiAgYW55bW9yZSwgYnV0IGtlcHQgaW4gYW4gb2JqZWN0IHBvb2wgZm9yIGxhdGVyIHJldXNlLiBFc3BlY2lhbGx5IHdpdGggbG9uZy1ydW5uaW5nCiAgYXBwbGljYXRpb25zIGluIHRoZSBJbnRlcm5ldCBFeHBsb3JlciBicm93c2VyLCB0aGlzIGNhbiBtYWtlIGEgaHVnZSBkaWZmZXJlbmNlLiBQbGVhc2UKICBub3RlIHRoYXQgdGhpcyB0b3BpYyBpcyB3b3JrIGluIHByb2dyZXNzIGFuZCwgZGVzcGl0ZSBleHRlbnNpdmUKICB0ZXN0aW5nLCBtaWdodCBsZWFkIHRvIGVycm9ycyB1bmRlciBkaWZmZXJlbnQgY2lyY3Vtc3RhbmNlcy4gV2UgcmVjb21tZW5kIG5vdCB0byB1c2UgdGhpcwogIGluIHlvdXIgY3VzdG9tIHdpZGdldHMuCiAgPC9wPgoKICA8aDM+UmVnaXN0ZXJpbmcgdGhlIGphdmFzY3JpcHQgZmlsZXM8L2gzPgogIExvYWRpbmcgdGhlIGNsaWVudCBhcHBsaWNhdGlvbiAod2l0aCBvdXIgd2lkZ2V0KSBpbiBhIGJyb3dzZXIgd2lsbCBzdGlsbCBsZWFkIHRvIHByb2JsZW1zCiAgYXMgbm9ib2R5IGtub3dzIGFib3V0IHRoZSBqYXZhc2NyaXB0IHJlc291cmNlcyBhbmQgd2hlcmUgdG8gZmluZCB0aGVtLiBXZSBjYW4gZml4IHRoaXMKICBieSB1c2luZyB0aGUgPGNvZGU+b3JnLmVjbGlwc2UucmFwLnVpLnJlc291cmNlczwvY29kZT4gZXh0ZW5zaW9uIHBvaW50LiBXZSBhZGQgdHdvIG5ldyBleHRlbnNpb25zLAogIG9uZSBmb3Igb3VyIGN1c3RvbSB3aWRnZXQgamF2YXNjcmlwdCBmaWxlIGFuZCBvbmUgZm9yIHRoZSBleHRlcm5hbCBqYXZhc2NyaXB0IGxpYnJhcnkgb2YgR29vZ2xlCiAgTWFwcy4KICA8L3A+CiAgPHByZT4KICA8Y29kZT4KICAmbHQ7cGx1Z2luJmd0OwogICAgJmx0O2V4dGVuc2lvbgogICAgICBpZD0ib3JnLmVjbGlwc2UucmFwLmdtYXBzLmdtYXAiCiAgICAgIHBvaW50PSJvcmcuZWNsaXBzZS5yYXAudWkucmVzb3VyY2VzIiZndDsKICAgICAgICAmbHQ7cmVzb3VyY2UgY2xhc3M9Im9yZy5lY2xpcHNlLnJhcC5nbWFwcy5HTWFwUmVzb3VyY2UiLyZndDsKICAgICAgICAmbHQ7cmVzb3VyY2UgY2xhc3M9Im9yZy5lY2xpcHNlLnJhcC5nbWFwcy5HTWFwQVBJUmVzb3VyY2UiLyZndDsKICAgICZsdDsvZXh0ZW5zaW9uJmd0OwogICZsdDsvcGx1Z2luJmd0OwogIDwvY29kZT4KICA8L3ByZT4KICA8cD4KICBCb3RoIGNsYXNzZXMgcmVmZXIgdG8gYW4gaW1wbGVtZW50YXRpb24gb2YgPGNvZGU+b3JnLmVjbGlwc2Uucnd0LnJlc291cmNlcy5JUmVzb3VyY2U8L2NvZGU+LgogIFRoZSBmaXJzdCBvbmUgLSBvdXIgY3VzdG9tIHdpZGdldCBpdHNlbGYgLSBpcyByZWFsbHkgZWFzeSB0byBpbXBsZW1lbnQuIFdlIGp1c3QgbmVlZCB0byB0ZWxsCiAgUkFQIHRoYXQgaXQgaXMgYSBqYXZhc2NyaXB0IGZpbGUsIHdoZXJlIGl0IGNhbiBmaW5kIHRoZSBmaWxlIGFuZCB3aGljaCBjaGFyc2V0IHRvIHVzZS4gU28gdGhlCiAgPGNvZGU+SVJlc291cmNlPjwvY29kZT4gaW1wbGVtZW50YXRpb24gZm9yIHRoZSB3aWRnZXQgamF2YXNjcmlwdCBjb3VsZCBsb29rIGxpa2UgdGhpczoKICA8L3A+CiAgPHByZT4KICA8Y29kZT4KICBwdWJsaWMgY2xhc3MgR01hcFJlc291cmNlIGltcGxlbWVudHMgSVJlc291cmNlIHsKICAKICAgIHB1YmxpYyBTdHJpbmcgZ2V0Q2hhcnNldCgpIHsKICAgICAgcmV0dXJuICJJU08tODg1OS0xIjsKICAgIH0KICAKICAgIHB1YmxpYyBDbGFzc0xvYWRlciBnZXRMb2FkZXIoKSB7CiAgICAgIHJldHVybiB0aGlzLmdldENsYXNzKCkuZ2V0Q2xhc3NMb2FkZXIoKTsKICAgIH0KICAKICAgIHB1YmxpYyBSZWdpc3Rlck9wdGlvbnMgZ2V0T3B0aW9ucygpIHsKICAgICAgcmV0dXJuIFJlZ2lzdGVyT3B0aW9ucy5WRVJTSU9OX0FORF9DT01QUkVTUzsKICAgIH0KICAKICAgIHB1YmxpYyBTdHJpbmcgZ2V0TG9jYXRpb24oKSB7CiAgICAgIHJldHVybiAib3JnL2VjbGlwc2UvcmFwL2dtYXBzL0dNYXAuanMiOwogICAgfQogIAogICAgcHVibGljIGJvb2xlYW4gaXNKU0xpYnJhcnkoKSB7CiAgICAgIHJldHVybiB0cnVlOwogICAgfQogIAogICAgcHVibGljIGJvb2xlYW4gaXNFeHRlcm5hbCgpIHsKICAgICAgcmV0dXJuIGZhbHNlOwogICAgfQogIH0KICA8L2NvZGU+CiAgPC9wcmU+CiAgPHA+CiAgRm9yIHRoZSBjaGFyc2V0IHdlIG5lZWQgdG8gcmV0dXJuIGEgc3RyaW5nIHRvIGRlc2NyaWJlIHRoZSBjaGFyc2V0LiBJZiB5b3UncmUgbm90IHN1cmUKICB5b3UgY2FuIHVzZSBvZiB0aGUgY29uc3RhbnRzIGRlZmluZWQgaW4gPGNvZGU+b3JnLmVjbGlwc2Uucnd0LmludGVybmFsLnV0aWwuSFRNTDwvY29kZT4gYnV0IGJlCiAgYXdhcmUgdGhhdCB0aGlzIGlzIGludGVybmFsLiBUaGUgPGNvZGU+Z2V0T3B0aW9uczwvY29kZT4gbWV0aG9kIHNwZWNpZmllcyBpZiB0aGUgZmlsZSBzaG91bGQKICBiZSBkZWxpdmVyZWQgd2l0aCBhbnkgc3BlY2lhbCB0cmVhdG1lbnQuIFBvc3NpYmxlIHdheXMgYXJlIDxjb2RlPk5PTkU8L2NvZGU+LCA8Y29kZT5WRVJTSU9OPC9jb2RlPiwKICA8Y29kZT5DT01QUkVTUzwvY29kZT4gYW5kIDxjb2RlPlZFUlNJT05fQU5EX0NPTVBSRVNTPC9jb2RlPi4gPGNvZGU+VkVSU0lPTjwvY29kZT4gbWVhbnMgdGhhdAogIFJBUCB3aWxsIGFwcGVuZCBhIGhhc2ggdmFsdWUgb2YgdGhlIGZpbGUgaXRzZWxmIHRvIHRlbGwgdGhlIGJyb3dzZXIgaWYgaGUgc2hvdWxkIHVzZSBhbiBhbHJlYWR5CiAgY2FjaGVkIHZlcnNpb24gb3IgcmVsb2FkIHRoZSBmaWxlIGZyb20gdGhlIHNlcnZlci4gV2l0aCB0aGUgPGNvZGU+Q09NUFJFU1M8L2NvZGU+IG9wdGlvbiBSQVAgd2lsbAogIHJlbW92ZSBhbGwgdW5uZWNlc3Nhcnkgc3R1ZmYgbGlrZSBibGFuayBsaW5lcyBvciBjb21tZW50cyBmcm9tIHRoZSBqYXZhc2NyaXB0IGZpbGUgaW4gb3JkZXIKICB0byBzYXZlIGJhbmR3aWR0aCBhbmQgcGFyc2UgdGltZS4gCiAgUmVtb3RlIGZpbGVzIGxpa2Ugb3VyIG5leHQgdGFzayAtIHRoZSBHb29nbGUgTWFwcyBsaWJyYXJ5IC0gYXJlIGhhbmRsZWQgYSBsaXR0bGUgYml0IGRpZmZlcmVudC4KICA8L3A+CiAgPHByZT4KICA8Y29kZT4KICBwdWJsaWMgY2xhc3MgR01hcEFQSVJlc291cmNlIGltcGxlbWVudHMgSVJlc291cmNlIHsKICAKICAgIHByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBLRVlfU1lTVEVNX1BST1BFUlRZID0gIm9yZy5lY2xpcHNlLnJhcC5nbWFwcy5rZXkiOwogICAgCiAgICAvLyBrZXkgZm9yIGxvY2FsaG9zdCByYXAgZGV2ZWxvcG1lbnQgb24gcG9ydCA5MDkwCiAgICBwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgS0VZX0xPQ0FMSE9TVAogICAgPSAiQUJRSUFBQUFqRTZpdEgtOVdBLTh5Slo3c1p3bXBSUXo1SkoyelBpM1lJOUpEV0JGRiIKICAgICAgICArICI2TlNzeGhlNEJTZmVuaTVWVVN4M2RRYzhtSUVrblNpRzlFd2FRIjsKICAgIAogICAgcHJpdmF0ZSBTdHJpbmcgbG9jYXRpb247CiAgICAKICAgIHB1YmxpYyBTdHJpbmcgZ2V0Q2hhcnNldCgpIHsKICAgICAgcmV0dXJuICJJU08tODg1OS0xIjsKICAgIH0KICAKICAgIHB1YmxpYyBDbGFzc0xvYWRlciBnZXRMb2FkZXIoKSB7CiAgICAgIHJldHVybiB0aGlzLmdldENsYXNzKCkuZ2V0Q2xhc3NMb2FkZXIoKTsKICAgIH0KICAKICAgIHB1YmxpYyBSZWdpc3Rlck9wdGlvbnMgZ2V0T3B0aW9ucygpIHsKICAgICAgcmV0dXJuIFJlZ2lzdGVyT3B0aW9ucy5WRVJTSU9OOwogICAgfQogIAogICAgcHVibGljIFN0cmluZyBnZXRMb2NhdGlvbigpIHsKICAgICAgaWYoIGxvY2F0aW9uID09IG51bGwgKSB7CiAgICAgICAgU3RyaW5nIGtleSA9IFN5c3RlbS5nZXRQcm9wZXJ0eSggS0VZX1NZU1RFTV9QUk9QRVJUWSApOwogICAgICAgIGlmKCBrZXkgPT0gbnVsbCApIHsKICAgICAgICAgIGtleSA9IEtFWV9MT0NBTEhPU1Q7CiAgICAgICAgfQogICAgICAgIGxvY2F0aW9uID0gImh0dHA6Ly9tYXBzLmdvb2dsZS5jb20vbWFwcz9maWxlPWFwaSZ2PTIma2V5PSIgKyBrZXk7IAogICAgICB9CiAgICAgIHJldHVybiBsb2NhdGlvbjsKICAgIH0KICAKICAgIHB1YmxpYyBib29sZWFuIGlzSlNMaWJyYXJ5KCkgewogICAgICByZXR1cm4gdHJ1ZTsKICAgIH0KICAKICAgIHB1YmxpYyBib29sZWFuIGlzRXh0ZXJuYWwoKSB7CiAgICAgIHJldHVybiB0cnVlOwogICAgfQogIH0KICA8L2NvZGU+CiAgPC9wcmU+CiAgPHA+CiAgVG8gdGVsbCBSQVAgdG8gbG9hZCBleHRlcm5hbCByZXNvdXJjZXMgd2UganVzdCBuZWVkIHRvIHJldHVybiA8Y29kZT50cnVlPC9jb2RlPiBpbgogIDxjb2RlPmlzRXh0ZXJuYWw8L2NvZGU+LiBUaGUgbG9jYXRpb24gc2hvdWxkIGJlIGEgdmFsaWQgVVJMIHdoZXJlIHRoZSByZXNvdXJjZSByZXNpZGVzLgogIEluIHRoaXMgY2FzZSBpdCdzIGxvYWRlZCBmcm9tIHRoZSBHb29nbGUgTWFwcyBzZXJ2ZXIgd2l0aCBhIHNwZWNpYWwgQVBJIGtleS4gVGhpcyBpcyBzcGVjaWZpYwogIGZvciB0aGUgR29vZ2xlIE1hcHMgd2lkZ2V0IGFuZCBpcyBub3QgbmVlZGVkIGJ5IG90aGVyIHdpZGdldHMuIElmIHlvdSdyZSBwbGFubmluZyB0byB1c2UKICBvciBleHRlbmQgdGhpcyBzYW1wbGUgd2lkZ2V0IHdlIGVuY291cmFnZSB5b3UgdG8gZ2V0IHlvdXIgPGEgaHJlZj0iaHR0cDovL3d3dy5nb29nbGUuY29tL2FwaXMvbWFwcy9zaWdudXAuaHRtbCI+CiAgb3duIEFQSSBrZXk8L2E+IGZvciBHb29nbGUgYXMgdGhpcyBrZXkKICB3aWxsIG9ubHkgd29yayBvbiBodHRwOi8vbG9jYWxob3N0OjkwOTAvcmFwLiBXaXRoIGV2ZXJ5IG90aGVyIGNvbWJpbmF0aW9uIG9mIGhvc3QsIHBvcnQgb3IKICBzZXJ2bGV0TmFtZSB5b3UgbmVlZCB0byBvYnRhaW4gYSBuZXcga2V5LiBBZGRpdGlvbmFsbHkgd2UgaW1wbGVtZW50ZWQgYSBzeXN0ZW0gcHJvcGVydHkKICB0byBkZWZpbmUgdGhlIGtleSB3aXRob3V0IHJlY29tcGlsaW5nIHRoZSB3aWRnZXQuCiAgPGJyIC8+CiAgV2UndmUganVzdCBmaW5pc2hlZCBvdXIgY3VzdG9tIHdpZGdldCBhbmQgb3VyIHByb2plY3Qgc3RydWN0dXJlIHNob3VsZCBsb29rIGxpa2UgdGhpcyBpZiB3ZSBoYXZlIGRvbmUgZXZlcnl0aGluZyByaWdodC4KICA8L3A+CiAgPGltZyBzcmM9Ii4uLy4uL2ltYWdlcy9jdXN0b20td2lkZ2V0L3Byb2plY3QucG5nIj4KICAKICA8aDM+VGVzdCB0aGUgd2lkZ2V0PC9oMz4gIAogIDxwPgogIEluIG9yZGVyIHRvIHRlc3QgdGhlIHdpZGdldCB3ZSB3aWxsIGNyZWF0ZSBhIG5ldyBwbHVnLWluIHByb2plY3Qgd2l0aCB0aGUgZm9sbG93aW5nIGVudHJ5cG9pbnQ6CiAgPC9wPgogIDxwcmU+CiAgPGNvZGU+CiAgcHVibGljIGNsYXNzIEdNYXBEZW1vIGltcGxlbWVudHMgSUVudHJ5UG9pbnQgewoKICAgIHB1YmxpYyBpbnQgY3JlYXRlVUkoKSB7CiAgICAgIERpc3BsYXkgZGlzcGxheSA9IG5ldyBEaXNwbGF5KCk7CiAgICAgIFNoZWxsIHNoZWxsID0gbmV3IFNoZWxsKCBkaXNwbGF5LCBTV1QuU0hFTExfVFJJTSApOwogICAgICBzaGVsbC5zZXRMYXlvdXQoIG5ldyBGaWxsTGF5b3V0KCkgKTsKICAgICAgc2hlbGwuc2V0VGV4dCggIkdNYXBzIERlbW8iICk7CiAgICAgIAogICAgICBHTWFwIG1hcCA9IG5ldyBHTWFwKCBzaGVsbCwgU1dULk5PTkUgKTsKICAgICAgbWFwLnNldEFkZHJlc3MoICJTdGVwaGFuaWVuc3RyYd9lIDIwLCBLYXJsc3J1aGUiICk7CiAgCiAgICAgIHNoZWxsLnNldFNpemUoIDMwMCwgMzAwICk7CiAgICAgIHNoZWxsLm9wZW4oKTsKICAgICAgd2hpbGUoICFzaGVsbC5pc0Rpc3Bvc2VkKCkgKSB7CiAgICAgICAgaWYoICFkaXNwbGF5LnJlYWRBbmREaXNwYXRjaCgpICkgewogICAgICAgICAgZGlzcGxheS5zbGVlcCgpOwogICAgICAgIH0KICAgICAgfQogICAgICByZXR1cm4gMDsKICAgIH0KICB9CiAgPC9jb2RlPgogIDwvcHJlPgogIDxwPgogIERvbid0IGZvcmdldCB0byBhZGQgPGNvZGU+b3JnLmVjbGlwc2UucmFwLnVpPC9jb2RlPiBhbmQgdGhlIEdNYXAgd2lkZ2V0IHByb2plY3QgYXMgZGVwZW5kZW5jaWVzLgogIFRoZW4gd2UgbmVlZCB0byByZWdpc3RlciBvdXIgZW50cnkgcG9pbnQgdmlhIHRoZSA8Y29kZT5vcmcuZWNsaXBzZS5yYXAudWkuZW50cnlwb2ludDwvY29kZT4uIElmCiAgZXZlcnl0aGluZyB3ZW50IHdlbGwgb3VyIGRlbW8gc2hvdWxkIGxvb2sgbGlrZSB0aGlzIGFmdGVyIHN0YXJ0aW5nIHRoZSBzZXJ2ZXI6CiAgPC9wPgogIDxpbWcgc3JjPSIuLi8uLi9pbWFnZXMvY3VzdG9tLXdpZGdldC9kZW1vLnBuZyI+CiAgPHA+CiAgQnV0IHRoZXJlIHdhcyBtb3JlOiB0aGUgY2VudGVyIGxvY2F0aW9uIHdlIHNlbmRlZCB0byB0aGUgc2VydmVyLiBUbyByZWFkIGl0IG91dCwgd2UgZXh0ZW5kIHRoZSBzYW1wbGUKICB3aXRoIGEgbmV3IGJ1dHRvbjoKICA8L3A+CiAgPHByZT4KICA8Y29kZT4KICBwdWJsaWMgY2xhc3MgR01hcERlbW8gaW1wbGVtZW50cyBJRW50cnlQb2ludCB7CgogICAgcHVibGljIGludCBjcmVhdGVVSSgpIHsKICAgICAgRGlzcGxheSBkaXNwbGF5ID0gbmV3IERpc3BsYXkoKTsKICAgICAgZmluYWwgU2hlbGwgc2hlbGwgPSBuZXcgU2hlbGwoIGRpc3BsYXksIFNXVC5TSEVMTF9UUklNICk7CiAgICAgIHNoZWxsLnNldExheW91dCggbmV3IEZpbGxMYXlvdXQoKSApOwogICAgICBzaGVsbC5zZXRUZXh0KCAiR01hcHMgRGVtbyIgKTsKICAgICAgCiAgICAgIEdNYXAgbWFwID0gbmV3IEdNYXAoIHNoZWxsLCBTV1QuTk9ORSApOwogICAgICBtYXAuc2V0QWRkcmVzcyggIlN0ZXBoYW5pZW5zdHJh32UgMjAsIEthcmxzcnVoZSIgKTsKICAKICAgICAgQnV0dG9uIGJ1dHRvbiA9IG5ldyBCdXR0b24oIHNoZWxsLCBTV1QuUFVTSCApOwogICAgICBidXR0b24uc2V0VGV4dCggIlRlbGwgbWUgd2hlcmUgSSBhbSEiICk7CiAgICAgIGJ1dHRvbi5hZGRTZWxlY3Rpb25MaXN0ZW5lciggbmV3IFNlbGVjdGlvbkFkYXB0ZXIoKSB7CiAgICAgICAgcHVibGljIHZvaWQgd2lkZ2V0U2VsZWN0ZWQoIFNlbGVjdGlvbkV2ZW50IGUgKSB7CiAgICAgICAgICBTdHJpbmcgbXNnID0gIllvdSBhcmUgaGVyZTogIiArIG1hcC5nZXRDZW50ZXJMb2NhdGlvbigpIAogICAgICAgICAgTWVzc2FnZURpYWxvZy5vcGVuSW5mb3JtYXRpb24oIHNoZWxsLCAiR01hcCBEZW1vIiwgbXNnICk7CiAgICAgICAgfQogICAgICB9KTsKICAgICAgCiAgICAgIHNoZWxsLnNldFNpemUoIDMwMCwgMzAwICk7CiAgICAgIHNoZWxsLm9wZW4oKTsKICAgICAgd2hpbGUoICFzaGVsbC5pc0Rpc3Bvc2VkKCkgKSB7CiAgICAgICAgaWYoICFkaXNwbGF5LnJlYWRBbmREaXNwYXRjaCgpICkgewogICAgICAgICAgZGlzcGxheS5zbGVlcCgpOwogICAgICAgIH0KICAgICAgfQogICAgICByZXR1cm4gMDsKICAgIH0KICB9CiAgPC9jb2RlPgogIDwvcHJlPgogIDxwPgogIEFmdGVyIGEgY2xpY2sgb24gdGhlIGJ1dHRvbiB0aGUgY3VycmVudCBsb2NhdGlvbiB3aWxsIGJlIHNlbmRlZCB0byB0aGUgc2VydmVyICh0b2dldGhlcgogIHdpdGggdGhlIHNlbGVjdGlvbiBldmVudCBvZiB0aGUgYnV0dG9uKSwgYXBwbGllZCB0byB0aGUgd2lkZ2V0IHdpdGggdGhlIGhlbHAgb2Ygb3VyIExDQQogIGFuZCBzaG93biBieSB0aGUgTWVzc2FnZURpYWxvZy4gR3JlYXQhCiAgPC9wPgogIAogIDxoMz5BbmQgbm93PzwvaDM+CiAgPHA+CiAgWW91IGNvbXBsZXRlZCB5b3VyIGZpcnN0IGN1c3RvbSB3aWRnZXQgLSBjb25ncmF0dWxhdGlvbnMhPGJyIC8+CiAgQmVmb3JlIGltcGxlbWVudGluZyBhIGhlYXZ5IGN1c3RvbSBjb250cm9sIHdlIGxpa2UgdG8gZ2l2ZSB5b3Ugc29tZSB0YXNrcyB0byBwbGF5IGFyb3VuZAogIHdpdGggdGhlIEdNYXAgd2lkZ2V0LgogIDx1bD4KICAgIDxsaT5JbXBsZW1lbnQgdGhlIHJlbmRlcmluZyBmb3IgdGhlIGNlbnRlciBsb2NhdGlvbiB0byBwcm9ncmFtbWF0aWNhbGx5IHNldCBpdDwvbGk+CiAgICA8bGk+QWRkIHN1cHBvcnQgZm9yIDxhIGhyZWY9Imh0dHA6Ly93d3cuZ29vZ2xlLmNvbS9hcGlzL21hcHMvZG9jdW1lbnRhdGlvbi9vdmVybGF5cy5odG1sIj5tYXJrZXJzPC9hPjwvbGk+CiAgICA8bGk+SW1wbGVtZW50IG90aGVyIG5pY2UgdGhpbmdzIGJ5IGNvbm5lY3RpbmcgR29vZ2xlIE1hcHMgd2l0aCBSQVA8L2xpPgogIDwvdWw+CiAgV2UgYXJlIGRlbGlnaHQgaW4gc2VlaW5nIHdoYXQgeW91IGNhbiBkbyB3aXRoIHRoaXMgbGl0dGxlIHdpZGdldC4gSWYgeW91IAogIGhhdmUgcHJvYmxlbXMsIHRha2UgYSBsb29rIGF0IGFsbCB0aGUgTENBcyBhbHJlYWR5IHByb3ZpZGVkIGJ5IFJBUC4gSXQncyAKICBub3QgYmxhY2sgbWFnaWMuCiAgPC9wPgogIAogIDxoMz5Ucm91Ymxlc2hvb3Rpbmc8L2gzPgogIDxwPgogIFRoZXJlIG1heSBiZSB0aW1lcyB3aGVyZSB5b3UgbmVlZCB0byB0cmFjayBkb3duIGEgamF2YXNjcmlwdCBlcnJvciBpbiB5b3VyIGN1c3RvbSB3aWRnZXQuCiAgQXMgdGhlIHRvb2xpbmcgc3VwcG9ydCBmb3IgamF2YXNjcmlwdCBpcyBub3QgdGhhdCBtYXR1cmUgYXMgZm9yIGphdmEgd2UgcHJvdmlkZSBzb21lCiAgbGl0dGxlIHVuZGVydGFrZXMgdG8gaGVscCB5b3UgZGVidWdnaW5nIHlvdXIgY3VzdG9tIHdpZGdldC4KICA8cD4KICA8aDQ+Q2xpZW50IGxpYnJhcnkgdmFyaWFudHM8L2g0PgogIEFzIHdlIGRvIG1hbnkgaW1wcm92ZW1lbnRzIHJlZ2FyZGluZyBzcGVlZCBvZiB0aGUgdW5kZXJseWluZyBxb294ZG9vIGxpYnJhcnkgdGhlCiAgbm9ybWFsbHkgdXNlZCBqYXZhc2NyaXB0IGZyYWdtZW50IGlzIGNvbXByZXNzZWQgYW5kIGNsZWFuZWQgZnJvbSBhbnkgY29tbWVudCBpbiB0aGUKICBjb2RlLiBBcyBpdCBpcyBlYXNpZXIgdG8gZGV2ZWxvcCB3aXRoIGEgZnVsbC1ibG93biB2ZXJzaW9uIG9mIHFvb3hkb28gdG8gZGVidWcKICBpdCB5b3UgY2FuIHNwZWNpZnkgPGNvZGU+LURvcmcuZWNsaXBzZS5yd3QuY2xpZW50TGlicmFyeVZhcmlhbnQ9REVCVUc8L2NvZGU+IGFzCiAgVk0gcGFyYW1ldGVyLgogIDxoND5DbGllbnQgbG9nIGxldmVsPC9oND4KICA8cD4KICBUbyBzZWUgZGVidWcgbWVzc2FnZXMgYW5kIGV4Y2VwdGlvbnMgd2hpY2ggb2NjdXJlZCBkdXJpbmcgamF2YXNjcmlwdCBleGVjdXRpb24KICB5b3UgY2FuIHR1cm4gb24gdGhlIGNsaWVudC1zaWRlIGRlYnVnZ2luZyBtb2RlIHdpdGgKICA8Y29kZT4tRG9yZy5lY2xpcHNlLnJ3dC5jbGllbnRMb2dMZXZlbD0mbHQ7TEVWRUwmZ3Q7PC9jb2RlPiB3aGVyZSA8Y29kZT4mbHQ7TEVWRUwmZ3Q7PC9jb2RlPgogIGlzIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoKICA8L3A+CiAgPHVsPgoJICA8bGk+T0ZGPC9saT4KCSAgPGxpPkFMTDwvbGk+CgkgIDxsaT5XQVJOSU5HPC9saT4KCSAgPGxpPklORk88L2xpPgoJICA8bGk+U0VWRVJFPC9saT4KCSAgPGxpPkZJTkU8L2xpPgoJICA8bGk+RklORVI8L2xpPgoJICA8bGk+RklORVNUPC9saT4KICA8L3VsPgogIDxwPgogIFdoZW4gZGV2ZWxvcGluZyBjdXN0b20gd2lkZ2V0IHdlIHJlY29tbWVuZCB0byB1c2UgdGhlIGxldmVsIDxjb2RlPkFMTDwvY29kZT4gdG8KICBzZWUgZXZlcnkgZGVidWcgbWVzc2FnZS4KICA8L3A+CjwvYm9keT4KPC9odG1sPg==