LyoqKioqKioqKioqKioqKioqKioqIChDKSBDT1BZUklHSFQgMjAwOCBTVE1pY3JvZWxlY3Ryb25pY3MgKioqKioqKioqKioqKioqKioqKioNCiogRmlsZSBOYW1lICAgICAgICAgIDogc3RtMzJmMTB4X3JjYy5jDQoqIEF1dGhvciAgICAgICAgICAgICA6IE1DRCBBcHBsaWNhdGlvbiBUZWFtDQoqIFZlcnNpb24gICAgICAgICAgICA6IFYyLjAuMQ0KKiBEYXRlICAgICAgICAgICAgICAgOiAwNi8xMy8yMDA4DQoqIERlc2NyaXB0aW9uICAgICAgICA6IFRoaXMgZmlsZSBwcm92aWRlcyBhbGwgdGhlIFJDQyBmaXJtd2FyZSBmdW5jdGlvbnMuDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBUSEUgUFJFU0VOVCBGSVJNV0FSRSBXSElDSCBJUyBGT1IgR1VJREFOQ0UgT05MWSBBSU1TIEFUIFBST1ZJRElORyBDVVNUT01FUlMNCiogV0lUSCBDT0RJTkcgSU5GT1JNQVRJT04gUkVHQVJESU5HIFRIRUlSIFBST0RVQ1RTIElOIE9SREVSIEZPUiBUSEVNIFRPIFNBVkUgVElNRS4NCiogQVMgQSBSRVNVTFQsIFNUTUlDUk9FTEVDVFJPTklDUyBTSEFMTCBOT1QgQkUgSEVMRCBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsDQoqIElORElSRUNUIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyBXSVRIIFJFU1BFQ1QgVE8gQU5ZIENMQUlNUyBBUklTSU5HIEZST00gVEhFDQoqIENPTlRFTlQgT0YgU1VDSCBGSVJNV0FSRSBBTkQvT1IgVEhFIFVTRSBNQURFIEJZIENVU1RPTUVSUyBPRiBUSEUgQ09ESU5HDQoqIElORk9STUFUSU9OIENPTlRBSU5FRCBIRVJFSU4gSU4gQ09OTkVDVElPTiBXSVRIIFRIRUlSIFBST0RVQ1RTLg0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCg0KLyogSW5jbHVkZXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCiNpbmNsdWRlICJzdG0zMmYxMHhfcmNjLmgiDQoNCi8qIFByaXZhdGUgdHlwZWRlZiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovDQovKiBQcml2YXRlIGRlZmluZSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLw0KLyogLS0tLS0tLS0tLS0tIFJDQyByZWdpc3RlcnMgYml0IGFkZHJlc3MgaW4gdGhlIGFsaWFzIHJlZ2lvbiAtLS0tLS0tLS0tLSAqLw0KI2RlZmluZSBSQ0NfT0ZGU0VUICAgICAgICAgICAgICAgIChSQ0NfQkFTRSAtIFBFUklQSF9CQVNFKQ0KDQovKiAtLS0gQ1IgUmVnaXN0ZXIgLS0tKi8NCi8qIEFsaWFzIHdvcmQgYWRkcmVzcyBvZiBIU0lPTiBiaXQgKi8NCiNkZWZpbmUgQ1JfT0ZGU0VUICAgICAgICAgICAgICAgICAoUkNDX09GRlNFVCArIDB4MDApDQojZGVmaW5lIEhTSU9OX0JpdE51bWJlciAgICAgICAgICAgMHgwMA0KI2RlZmluZSBDUl9IU0lPTl9CQiAgICAgICAgICAgICAgIChQRVJJUEhfQkJfQkFTRSArIChDUl9PRkZTRVQgKiAzMikgKyAoSFNJT05fQml0TnVtYmVyICogNCkpDQoNCi8qIEFsaWFzIHdvcmQgYWRkcmVzcyBvZiBQTExPTiBiaXQgKi8NCiNkZWZpbmUgUExMT05fQml0TnVtYmVyICAgICAgICAgICAweDE4DQojZGVmaW5lIENSX1BMTE9OX0JCICAgICAgICAgICAgICAgKFBFUklQSF9CQl9CQVNFICsgKENSX09GRlNFVCAqIDMyKSArIChQTExPTl9CaXROdW1iZXIgKiA0KSkNCg0KLyogQWxpYXMgd29yZCBhZGRyZXNzIG9mIENTU09OIGJpdCAqLw0KI2RlZmluZSBDU1NPTl9CaXROdW1iZXIgICAgICAgICAgIDB4MTMNCiNkZWZpbmUgQ1JfQ1NTT05fQkIgICAgICAgICAgICAgICAoUEVSSVBIX0JCX0JBU0UgKyAoQ1JfT0ZGU0VUICogMzIpICsgKENTU09OX0JpdE51bWJlciAqIDQpKQ0KDQovKiAtLS0gQ0ZHUiBSZWdpc3RlciAtLS0qLw0KLyogQWxpYXMgd29yZCBhZGRyZXNzIG9mIFVTQlBSRSBiaXQgKi8NCiNkZWZpbmUgQ0ZHUl9PRkZTRVQgICAgICAgICAgICAgICAoUkNDX09GRlNFVCArIDB4MDQpDQojZGVmaW5lIFVTQlBSRV9CaXROdW1iZXIgICAgICAgICAgMHgxNg0KI2RlZmluZSBDRkdSX1VTQlBSRV9CQiAgICAgICAgICAgIChQRVJJUEhfQkJfQkFTRSArIChDRkdSX09GRlNFVCAqIDMyKSArIChVU0JQUkVfQml0TnVtYmVyICogNCkpDQoNCi8qIC0tLSBCRENSIFJlZ2lzdGVyIC0tLSovDQovKiBBbGlhcyB3b3JkIGFkZHJlc3Mgb2YgUlRDRU4gYml0ICovDQojZGVmaW5lIEJEQ1JfT0ZGU0VUICAgICAgICAgICAgICAgKFJDQ19PRkZTRVQgKyAweDIwKQ0KI2RlZmluZSBSVENFTl9CaXROdW1iZXIgICAgICAgICAgIDB4MEYNCiNkZWZpbmUgQkRDUl9SVENFTl9CQiAgICAgICAgICAgICAoUEVSSVBIX0JCX0JBU0UgKyAoQkRDUl9PRkZTRVQgKiAzMikgKyAoUlRDRU5fQml0TnVtYmVyICogNCkpDQoNCi8qIEFsaWFzIHdvcmQgYWRkcmVzcyBvZiBCRFJTVCBiaXQgKi8NCiNkZWZpbmUgQkRSU1RfQml0TnVtYmVyICAgICAgICAgICAweDEwDQojZGVmaW5lIEJEQ1JfQkRSU1RfQkIgICAgICAgICAgICAgKFBFUklQSF9CQl9CQVNFICsgKEJEQ1JfT0ZGU0VUICogMzIpICsgKEJEUlNUX0JpdE51bWJlciAqIDQpKQ0KDQovKiAtLS0gQ1NSIFJlZ2lzdGVyIC0tLSovDQovKiBBbGlhcyB3b3JkIGFkZHJlc3Mgb2YgTFNJT04gYml0ICovDQojZGVmaW5lIENTUl9PRkZTRVQgICAgICAgICAgICAgICAgKFJDQ19PRkZTRVQgKyAweDI0KQ0KI2RlZmluZSBMU0lPTl9CaXROdW1iZXIgICAgICAgICAgIDB4MDANCiNkZWZpbmUgQ1NSX0xTSU9OX0JCICAgICAgICAgICAgICAoUEVSSVBIX0JCX0JBU0UgKyAoQ1NSX09GRlNFVCAqIDMyKSArIChMU0lPTl9CaXROdW1iZXIgKiA0KSkNCg0KLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSBSQ0MgcmVnaXN0ZXJzIGJpdCBtYXNrIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLw0KLyogQ1IgcmVnaXN0ZXIgYml0IG1hc2sgKi8NCiNkZWZpbmUgQ1JfSFNFQllQX1Jlc2V0ICAgICAgICAgICAoKHUzMikweEZGRkJGRkZGKQ0KI2RlZmluZSBDUl9IU0VCWVBfU2V0ICAgICAgICAgICAgICgodTMyKTB4MDAwNDAwMDApDQojZGVmaW5lIENSX0hTRU9OX1Jlc2V0ICAgICAgICAgICAgKCh1MzIpMHhGRkZFRkZGRikNCiNkZWZpbmUgQ1JfSFNFT05fU2V0ICAgICAgICAgICAgICAoKHUzMikweDAwMDEwMDAwKQ0KI2RlZmluZSBDUl9IU0lUUklNX01hc2sgICAgICAgICAgICgodTMyKTB4RkZGRkZGMDcpDQoNCi8qIENGR1IgcmVnaXN0ZXIgYml0IG1hc2sgKi8NCiNkZWZpbmUgQ0ZHUl9QTExfTWFzayAgICAgICAgICAgICAoKHUzMikweEZGQzBGRkZGKQ0KI2RlZmluZSBDRkdSX1BMTE11bGxfTWFzayAgICAgICAgICgodTMyKTB4MDAzQzAwMDApDQojZGVmaW5lIENGR1JfUExMU1JDX01hc2sgICAgICAgICAgKCh1MzIpMHgwMDAxMDAwMCkNCiNkZWZpbmUgQ0ZHUl9QTExYVFBSRV9NYXNrICAgICAgICAoKHUzMikweDAwMDIwMDAwKQ0KI2RlZmluZSBDRkdSX1NXU19NYXNrICAgICAgICAgICAgICgodTMyKTB4MDAwMDAwMEMpDQojZGVmaW5lIENGR1JfU1dfTWFzayAgICAgICAgICAgICAgKCh1MzIpMHhGRkZGRkZGQykNCiNkZWZpbmUgQ0ZHUl9IUFJFX1Jlc2V0X01hc2sgICAgICAoKHUzMikweEZGRkZGRjBGKQ0KI2RlZmluZSBDRkdSX0hQUkVfU2V0X01hc2sgICAgICAgICgodTMyKTB4MDAwMDAwRjApDQojZGVmaW5lIENGR1JfUFBSRTFfUmVzZXRfTWFzayAgICAgKCh1MzIpMHhGRkZGRjhGRikNCiNkZWZpbmUgQ0ZHUl9QUFJFMV9TZXRfTWFzayAgICAgICAoKHUzMikweDAwMDAwNzAwKQ0KI2RlZmluZSBDRkdSX1BQUkUyX1Jlc2V0X01hc2sgICAgICgodTMyKTB4RkZGRkM3RkYpDQojZGVmaW5lIENGR1JfUFBSRTJfU2V0X01hc2sgICAgICAgKCh1MzIpMHgwMDAwMzgwMCkNCiNkZWZpbmUgQ0ZHUl9BRENQUkVfUmVzZXRfTWFzayAgICAoKHUzMikweEZGRkYzRkZGKQ0KI2RlZmluZSBDRkdSX0FEQ1BSRV9TZXRfTWFzayAgICAgICgodTMyKTB4MDAwMEMwMDApDQoNCi8qIENTUiByZWdpc3RlciBiaXQgbWFzayAqLw0KI2RlZmluZSBDU1JfUk1WRl9TZXQgICAgICAgICAgICAgICgodTMyKTB4MDEwMDAwMDApDQoNCi8qIFJDQyBGbGFnIE1hc2sgKi8NCiNkZWZpbmUgRkxBR19NYXNrICAgICAgICAgICAgICAgICAoKHU4KTB4MUYpDQoNCi8qIFR5cGljYWwgVmFsdWUgb2YgdGhlIEhTSSBpbiBIeiAqLw0KI2RlZmluZSBIU0lfVmFsdWUgICAgICAgICAgICAgICAgICgodTMyKTgwMDAwMDApDQoNCi8qIENJUiByZWdpc3RlciBieXRlIDIgKEJpdHNbMTU6OF0pIGJhc2UgYWRkcmVzcyAqLw0KI2RlZmluZSBDSVJfQllURTJfQUREUkVTUyAgICAgICAgICgodTMyKTB4NDAwMjEwMDkpDQovKiBDSVIgcmVnaXN0ZXIgYnl0ZSAzIChCaXRzWzIzOjE2XSkgYmFzZSBhZGRyZXNzICovDQojZGVmaW5lIENJUl9CWVRFM19BRERSRVNTICAgICAgICAgKCh1MzIpMHg0MDAyMTAwQSkNCg0KLyogQ0ZHUiByZWdpc3RlciBieXRlIDQgKEJpdHNbMzE6MjRdKSBiYXNlIGFkZHJlc3MgKi8NCiNkZWZpbmUgQ0ZHUl9CWVRFNF9BRERSRVNTICAgICAgICAoKHUzMikweDQwMDIxMDA3KQ0KDQovKiBCRENSIHJlZ2lzdGVyIGJhc2UgYWRkcmVzcyAqLw0KI2RlZmluZSBCRENSX0FERFJFU1MgICAgICAgICAgICAgIChQRVJJUEhfQkFTRSArIEJEQ1JfT0ZGU0VUKQ0KDQovKiBUaW1lIG91dCBmb3IgSFNFIHN0YXJ0IHVwICovDQojZGVmaW5lIEhTRVN0YXJ0VXBfVGltZU91dCAgICAgICAgKCh1MTYpMHgwMUZGKQ0KDQovKiBQcml2YXRlIG1hY3JvIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLw0KLyogUHJpdmF0ZSB2YXJpYWJsZXMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCnN0YXRpYyB1YzggQVBCQUhCUHJlc2NUYWJsZVsxNl0gPSB7MCwgMCwgMCwgMCwgMSwgMiwgMywgNCwgMSwgMiwgMywgNCwgNiwgNywgOCwgOX07DQpzdGF0aWMgdWM4IEFEQ1ByZXNjVGFibGVbNF0gPSB7MiwgNCwgNiwgOH07DQoNCnN0YXRpYyB2b2xhdGlsZSBGbGFnU3RhdHVzIEhTRVN0YXR1czsNCnN0YXRpYyB2dTMyIFN0YXJ0VXBDb3VudGVyID0gMDsNCg0KLyogUHJpdmF0ZSBmdW5jdGlvbiBwcm90b3R5cGVzIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCi8qIFByaXZhdGUgZnVuY3Rpb25zIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovDQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0RlSW5pdA0KKiBEZXNjcmlwdGlvbiAgICA6IFJlc2V0cyB0aGUgUkNDIGNsb2NrIGNvbmZpZ3VyYXRpb24gdG8gdGhlIGRlZmF1bHQgcmVzZXQgc3RhdGUuDQoqIElucHV0ICAgICAgICAgIDogTm9uZQ0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfRGVJbml0KHZvaWQpDQp7DQogIC8qIFNldCBIU0lPTiBiaXQgKi8NCiAgUkNDLT5DUiB8PSAodTMyKTB4MDAwMDAwMDE7DQoNCiAgLyogUmVzZXQgU1dbMTowXSwgSFBSRVszOjBdLCBQUFJFMVsyOjBdLCBQUFJFMlsyOjBdLCBBRENQUkVbMTowXSBhbmQgTUNPWzI6MF0gYml0cyAqLw0KICBSQ0MtPkNGR1IgJj0gKHUzMikweEY4RkYwMDAwOw0KICANCiAgLyogUmVzZXQgSFNFT04sIENTU09OIGFuZCBQTExPTiBiaXRzICovDQogIFJDQy0+Q1IgJj0gKHUzMikweEZFRjZGRkZGOw0KDQogIC8qIFJlc2V0IEhTRUJZUCBiaXQgKi8NCiAgUkNDLT5DUiAmPSAodTMyKTB4RkZGQkZGRkY7DQoNCiAgLyogUmVzZXQgUExMU1JDLCBQTExYVFBSRSwgUExMTVVMWzM6MF0gYW5kIFVTQlBSRSBiaXRzICovDQogIFJDQy0+Q0ZHUiAmPSAodTMyKTB4RkY4MEZGRkY7DQoNCiAgLyogRGlzYWJsZSBhbGwgaW50ZXJydXB0cyAqLw0KICBSQ0MtPkNJUiA9IDB4MDAwMDAwMDA7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0hTRUNvbmZpZw0KKiBEZXNjcmlwdGlvbiAgICA6IENvbmZpZ3VyZXMgdGhlIEV4dGVybmFsIEhpZ2ggU3BlZWQgb3NjaWxsYXRvciAoSFNFKS4NCiogICAgICAgICAgICAgICAgICBIU0UgY2FuIG5vdCBiZSBzdG9wcGVkIGlmIGl0IGlzIHVzZWQgZGlyZWN0bHkgb3IgdGhyb3VnaCB0aGUgDQoqICAgICAgICAgICAgICAgICAgUExMIGFzIHN5c3RlbSBjbG9jay4NCiogSW5wdXQgICAgICAgICAgOiAtIFJDQ19IU0U6IHNwZWNpZmllcyB0aGUgbmV3IHN0YXRlIG9mIHRoZSBIU0UuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgb25lIG9mIHRoZSBmb2xsb3dpbmcgdmFsdWVzOg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSFNFX09GRjogSFNFIG9zY2lsbGF0b3IgT0ZGDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19IU0VfT046IEhTRSBvc2NpbGxhdG9yIE9ODQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19IU0VfQnlwYXNzOiBIU0Ugb3NjaWxsYXRvciBieXBhc3NlZCB3aXRoIGV4dGVybmFsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIGNsb2NrDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19IU0VDb25maWcodTMyIFJDQ19IU0UpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfSFNFKFJDQ19IU0UpKTsNCg0KICAvKiBSZXNldCBIU0VPTiBhbmQgSFNFQllQIGJpdHMgYmVmb3JlIGNvbmZpZ3VyaW5nIHRoZSBIU0UgLS0tLS0tLS0tLS0tLS0tLS0tKi8NCiAgLyogUmVzZXQgSFNFT04gYml0ICovDQogIFJDQy0+Q1IgJj0gQ1JfSFNFT05fUmVzZXQ7DQoNCiAgLyogUmVzZXQgSFNFQllQIGJpdCAqLw0KICBSQ0MtPkNSICY9IENSX0hTRUJZUF9SZXNldDsNCg0KICAvKiBDb25maWd1cmUgSFNFIChSQ0NfSFNFX09GRiBpcyBhbHJlYWR5IGNvdmVyZWQgYnkgdGhlIGNvZGUgc2VjdGlvbiBhYm92ZSkgKi8NCiAgc3dpdGNoKFJDQ19IU0UpDQogIHsNCiAgICBjYXNlIFJDQ19IU0VfT046DQogICAgICAvKiBTZXQgSFNFT04gYml0ICovDQogICAgICBSQ0MtPkNSIHw9IENSX0hTRU9OX1NldDsNCiAgICAgIGJyZWFrOw0KICAgICAgDQogICAgY2FzZSBSQ0NfSFNFX0J5cGFzczoNCiAgICAgIC8qIFNldCBIU0VCWVAgYW5kIEhTRU9OIGJpdHMgKi8NCiAgICAgIFJDQy0+Q1IgfD0gQ1JfSFNFQllQX1NldCB8IENSX0hTRU9OX1NldDsNCiAgICAgIGJyZWFrOyAgICAgICAgICAgIA0KICAgICAgDQogICAgZGVmYXVsdDoNCiAgICAgIGJyZWFrOyAgICAgIA0KICB9DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX1dhaXRGb3JIU0VTdGFydFVwDQoqIERlc2NyaXB0aW9uICAgIDogV2FpdHMgZm9yIEhTRSBzdGFydC11cC4NCiogSW5wdXQgICAgICAgICAgOiBOb25lDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IEFuIEVycm9yU3RhdHVzIGVudW11cmF0aW9uIHZhbHVlOg0KKiAgICAgICAgICAgICAgICAgICAgICAgICAtIFNVQ0NFU1M6IEhTRSBvc2NpbGxhdG9yIGlzIHN0YWJsZSBhbmQgcmVhZHkgdG8gdXNlDQoqICAgICAgICAgICAgICAgICAgICAgICAgIC0gRVJST1I6IEhTRSBvc2NpbGxhdG9yIG5vdCB5ZXQgcmVhZHkNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQpFcnJvclN0YXR1cyBSQ0NfV2FpdEZvckhTRVN0YXJ0VXAodm9pZCkNCnsNCiAgRXJyb3JTdGF0dXMgc3RhdHVzID0gRVJST1I7DQoNCiAgLyogV2FpdCB0aWxsIEhTRSBpcyByZWFkeSBhbmQgaWYgVGltZSBvdXQgaXMgcmVhY2hlZCBleGl0ICovDQogIGRvDQogIHsNCiAgICBIU0VTdGF0dXMgPSBSQ0NfR2V0RmxhZ1N0YXR1cyhSQ0NfRkxBR19IU0VSRFkpOw0KICAgIFN0YXJ0VXBDb3VudGVyKys7ICANCiAgfSB3aGlsZSgoSFNFU3RhdHVzID09IFJFU0VUKSAmJiAoU3RhcnRVcENvdW50ZXIgIT0gSFNFU3RhcnRVcF9UaW1lT3V0KSk7DQoNCg0KICBpZiAoUkNDX0dldEZsYWdTdGF0dXMoUkNDX0ZMQUdfSFNFUkRZKSAhPSBSRVNFVCkNCiAgew0KICAgIHN0YXR1cyA9IFNVQ0NFU1M7DQogIH0NCiAgZWxzZQ0KICB7DQogICAgc3RhdHVzID0gRVJST1I7DQogIH0gIA0KDQogIHJldHVybiAoc3RhdHVzKTsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfQWRqdXN0SFNJQ2FsaWJyYXRpb25WYWx1ZQ0KKiBEZXNjcmlwdGlvbiAgICA6IEFkanVzdHMgdGhlIEludGVybmFsIEhpZ2ggU3BlZWQgb3NjaWxsYXRvciAoSFNJKSBjYWxpYnJhdGlvbg0KKiAgICAgICAgICAgICAgICAgIHZhbHVlLg0KKiBJbnB1dCAgICAgICAgICA6IC0gSFNJQ2FsaWJyYXRpb25WYWx1ZTogc3BlY2lmaWVzIHRoZSBjYWxpYnJhdGlvbiB0cmltbWluZyB2YWx1ZS4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIG11c3QgYmUgYSBudW1iZXIgYmV0d2VlbiAwIGFuZCAweDFGLg0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfQWRqdXN0SFNJQ2FsaWJyYXRpb25WYWx1ZSh1OCBIU0lDYWxpYnJhdGlvblZhbHVlKQ0Kew0KICB1MzIgdG1wcmVnID0gMDsNCg0KICAvKiBDaGVjayB0aGUgcGFyYW1ldGVycyAqLw0KICBhc3NlcnRfcGFyYW0oSVNfUkNDX0NBTElCUkFUSU9OX1ZBTFVFKEhTSUNhbGlicmF0aW9uVmFsdWUpKTsNCg0KICB0bXByZWcgPSBSQ0MtPkNSOw0KDQogIC8qIENsZWFyIEhTSVRSSU1bNDowXSBiaXRzICovDQogIHRtcHJlZyAmPSBDUl9IU0lUUklNX01hc2s7DQoNCiAgLyogU2V0IHRoZSBIU0lUUklNWzQ6MF0gYml0cyBhY2NvcmRpbmcgdG8gSFNJQ2FsaWJyYXRpb25WYWx1ZSB2YWx1ZSAqLw0KICB0bXByZWcgfD0gKHUzMilIU0lDYWxpYnJhdGlvblZhbHVlIDw8IDM7DQoNCiAgLyogU3RvcmUgdGhlIG5ldyB2YWx1ZSAqLw0KICBSQ0MtPkNSID0gdG1wcmVnOw0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19IU0lDbWQNCiogRGVzY3JpcHRpb24gICAgOiBFbmFibGVzIG9yIGRpc2FibGVzIHRoZSBJbnRlcm5hbCBIaWdoIFNwZWVkIG9zY2lsbGF0b3IgKEhTSSkuDQoqICAgICAgICAgICAgICAgICAgSFNJIGNhbiBub3QgYmUgc3RvcHBlZCBpZiBpdCBpcyB1c2VkIGRpcmVjdGx5IG9yIHRocm91Z2ggdGhlIA0KKiAgICAgICAgICAgICAgICAgIFBMTCBhcyBzeXN0ZW0gY2xvY2suDQoqIElucHV0ICAgICAgICAgIDogLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBIU0kuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmU6IEVOQUJMRSBvciBESVNBQkxFLg0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfSFNJQ21kKEZ1bmN0aW9uYWxTdGF0ZSBOZXdTdGF0ZSkNCnsNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICAqKHZ1MzIgKikgQ1JfSFNJT05fQkIgPSAodTMyKU5ld1N0YXRlOw0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19QTExDb25maWcNCiogRGVzY3JpcHRpb24gICAgOiBDb25maWd1cmVzIHRoZSBQTEwgY2xvY2sgc291cmNlIGFuZCBtdWx0aXBsaWNhdGlvbiBmYWN0b3IuDQoqICAgICAgICAgICAgICAgICAgVGhpcyBmdW5jdGlvbiBtdXN0IGJlIHVzZWQgb25seSB3aGVuIHRoZSBQTEwgaXMgZGlzYWJsZWQuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfUExMU291cmNlOiBzcGVjaWZpZXMgdGhlIFBMTCBlbnRyeSBjbG9jayBzb3VyY2UuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgb25lIG9mIHRoZSBmb2xsb3dpbmcgdmFsdWVzOg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfUExMU291cmNlX0hTSV9EaXYyOiBIU0kgb3NjaWxsYXRvciBjbG9jayBkaXZpZGVkDQoqICAgICAgICAgICAgICAgICAgICAgICAgIGJ5IDIgc2VsZWN0ZWQgYXMgUExMIGNsb2NrIGVudHJ5DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19QTExTb3VyY2VfSFNFX0RpdjE6IEhTRSBvc2NpbGxhdG9yIGNsb2NrIHNlbGVjdGVkDQoqICAgICAgICAgICAgICAgICAgICAgICAgIGFzIFBMTCBjbG9jayBlbnRyeQ0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfUExMU291cmNlX0hTRV9EaXYyOiBIU0Ugb3NjaWxsYXRvciBjbG9jayBkaXZpZGVkDQoqICAgICAgICAgICAgICAgICAgICAgICAgIGJ5IDIgc2VsZWN0ZWQgYXMgUExMIGNsb2NrIGVudHJ5DQoqICAgICAgICAgICAgICAgICAgLSBSQ0NfUExMTXVsOiBzcGVjaWZpZXMgdGhlIFBMTCBtdWx0aXBsaWNhdGlvbiBmYWN0b3IuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgUkNDX1BMTE11bF94IHdoZXJlIHg6WzIsMTZdDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19QTExDb25maWcodTMyIFJDQ19QTExTb3VyY2UsIHUzMiBSQ0NfUExMTXVsKQ0Kew0KICB1MzIgdG1wcmVnID0gMDsNCg0KICAvKiBDaGVjayB0aGUgcGFyYW1ldGVycyAqLw0KICBhc3NlcnRfcGFyYW0oSVNfUkNDX1BMTF9TT1VSQ0UoUkNDX1BMTFNvdXJjZSkpOw0KICBhc3NlcnRfcGFyYW0oSVNfUkNDX1BMTF9NVUwoUkNDX1BMTE11bCkpOw0KDQogIHRtcHJlZyA9IFJDQy0+Q0ZHUjsNCg0KICAvKiBDbGVhciBQTExTUkMsIFBMTFhUUFJFIGFuZCBQTExNVUxbMzowXSBiaXRzICovDQogIHRtcHJlZyAmPSBDRkdSX1BMTF9NYXNrOw0KDQogIC8qIFNldCB0aGUgUExMIGNvbmZpZ3VyYXRpb24gYml0cyAqLw0KICB0bXByZWcgfD0gUkNDX1BMTFNvdXJjZSB8IFJDQ19QTExNdWw7DQoNCiAgLyogU3RvcmUgdGhlIG5ldyB2YWx1ZSAqLw0KICBSQ0MtPkNGR1IgPSB0bXByZWc7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX1BMTENtZA0KKiBEZXNjcmlwdGlvbiAgICA6IEVuYWJsZXMgb3IgZGlzYWJsZXMgdGhlIFBMTC4NCiogICAgICAgICAgICAgICAgICBUaGUgUExMIGNhbiBub3QgYmUgZGlzYWJsZWQgaWYgaXQgaXMgdXNlZCBhcyBzeXN0ZW0gY2xvY2suDQoqIElucHV0ICAgICAgICAgIDogLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBQTEwuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmU6IEVOQUJMRSBvciBESVNBQkxFLg0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfUExMQ21kKEZ1bmN0aW9uYWxTdGF0ZSBOZXdTdGF0ZSkNCnsNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICAqKHZ1MzIgKikgQ1JfUExMT05fQkIgPSAodTMyKU5ld1N0YXRlOw0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19TWVNDTEtDb25maWcNCiogRGVzY3JpcHRpb24gICAgOiBDb25maWd1cmVzIHRoZSBzeXN0ZW0gY2xvY2sgKFNZU0NMSykuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfU1lTQ0xLU291cmNlOiBzcGVjaWZpZXMgdGhlIGNsb2NrIHNvdXJjZSB1c2VkIGFzIHN5c3RlbQ0KKiAgICAgICAgICAgICAgICAgICAgY2xvY2suIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZyB2YWx1ZXM6DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19TWVNDTEtTb3VyY2VfSFNJOiBIU0kgc2VsZWN0ZWQgYXMgc3lzdGVtIGNsb2NrDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19TWVNDTEtTb3VyY2VfSFNFOiBIU0Ugc2VsZWN0ZWQgYXMgc3lzdGVtIGNsb2NrDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19TWVNDTEtTb3VyY2VfUExMQ0xLOiBQTEwgc2VsZWN0ZWQgYXMgc3lzdGVtIGNsb2NrDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19TWVNDTEtDb25maWcodTMyIFJDQ19TWVNDTEtTb3VyY2UpDQp7DQogIHUzMiB0bXByZWcgPSAwOw0KDQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfU1lTQ0xLX1NPVVJDRShSQ0NfU1lTQ0xLU291cmNlKSk7DQoNCiAgdG1wcmVnID0gUkNDLT5DRkdSOw0KDQogIC8qIENsZWFyIFNXWzE6MF0gYml0cyAqLw0KICB0bXByZWcgJj0gQ0ZHUl9TV19NYXNrOw0KDQogIC8qIFNldCBTV1sxOjBdIGJpdHMgYWNjb3JkaW5nIHRvIFJDQ19TWVNDTEtTb3VyY2UgdmFsdWUgKi8NCiAgdG1wcmVnIHw9IFJDQ19TWVNDTEtTb3VyY2U7DQoNCiAgLyogU3RvcmUgdGhlIG5ldyB2YWx1ZSAqLw0KICBSQ0MtPkNGR1IgPSB0bXByZWc7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0dldFNZU0NMS1NvdXJjZQ0KKiBEZXNjcmlwdGlvbiAgICA6IFJldHVybnMgdGhlIGNsb2NrIHNvdXJjZSB1c2VkIGFzIHN5c3RlbSBjbG9jay4NCiogSW5wdXQgICAgICAgICAgOiBOb25lDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IFRoZSBjbG9jayBzb3VyY2UgdXNlZCBhcyBzeXN0ZW0gY2xvY2suIFRoZSByZXR1cm5lZCB2YWx1ZSBjYW4NCiogICAgICAgICAgICAgICAgICBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZzoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gMHgwMDogSFNJIHVzZWQgYXMgc3lzdGVtIGNsb2NrDQoqICAgICAgICAgICAgICAgICAgICAgICAtIDB4MDQ6IEhTRSB1c2VkIGFzIHN5c3RlbSBjbG9jaw0KKiAgICAgICAgICAgICAgICAgICAgICAgLSAweDA4OiBQTEwgdXNlZCBhcyBzeXN0ZW0gY2xvY2sNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp1OCBSQ0NfR2V0U1lTQ0xLU291cmNlKHZvaWQpDQp7DQogIHJldHVybiAoKHU4KShSQ0MtPkNGR1IgJiBDRkdSX1NXU19NYXNrKSk7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0hDTEtDb25maWcNCiogRGVzY3JpcHRpb24gICAgOiBDb25maWd1cmVzIHRoZSBBSEIgY2xvY2sgKEhDTEspLg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX1NZU0NMSzogZGVmaW5lcyB0aGUgQUhCIGNsb2NrIGRpdmlkZXIuIFRoaXMgY2xvY2sgaXMNCiogICAgICAgICAgICAgICAgICAgIGRlcml2ZWQgZnJvbSB0aGUgc3lzdGVtIGNsb2NrIChTWVNDTEspLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1NZU0NMS19EaXYxOiBBSEIgY2xvY2sgPSBTWVNDTEsNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1NZU0NMS19EaXYyOiBBSEIgY2xvY2sgPSBTWVNDTEsvMg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfU1lTQ0xLX0RpdjQ6IEFIQiBjbG9jayA9IFNZU0NMSy80DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19TWVNDTEtfRGl2ODogQUhCIGNsb2NrID0gU1lTQ0xLLzgNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1NZU0NMS19EaXYxNjogQUhCIGNsb2NrID0gU1lTQ0xLLzE2DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19TWVNDTEtfRGl2NjQ6IEFIQiBjbG9jayA9IFNZU0NMSy82NA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfU1lTQ0xLX0RpdjEyODogQUhCIGNsb2NrID0gU1lTQ0xLLzEyOA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfU1lTQ0xLX0RpdjI1NjogQUhCIGNsb2NrID0gU1lTQ0xLLzI1Ng0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfU1lTQ0xLX0RpdjUxMjogQUhCIGNsb2NrID0gU1lTQ0xLLzUxMg0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfSENMS0NvbmZpZyh1MzIgUkNDX1NZU0NMSykNCnsNCiAgdTMyIHRtcHJlZyA9IDA7DQoNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX1JDQ19IQ0xLKFJDQ19TWVNDTEspKTsNCg0KICB0bXByZWcgPSBSQ0MtPkNGR1I7DQoNCiAgLyogQ2xlYXIgSFBSRVszOjBdIGJpdHMgKi8NCiAgdG1wcmVnICY9IENGR1JfSFBSRV9SZXNldF9NYXNrOw0KDQogIC8qIFNldCBIUFJFWzM6MF0gYml0cyBhY2NvcmRpbmcgdG8gUkNDX1NZU0NMSyB2YWx1ZSAqLw0KICB0bXByZWcgfD0gUkNDX1NZU0NMSzsNCg0KICAvKiBTdG9yZSB0aGUgbmV3IHZhbHVlICovDQogIFJDQy0+Q0ZHUiA9IHRtcHJlZzsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfUENMSzFDb25maWcNCiogRGVzY3JpcHRpb24gICAgOiBDb25maWd1cmVzIHRoZSBMb3cgU3BlZWQgQVBCIGNsb2NrIChQQ0xLMSkuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfSENMSzogZGVmaW5lcyB0aGUgQVBCMSBjbG9jayBkaXZpZGVyLiBUaGlzIGNsb2NrIGlzDQoqICAgICAgICAgICAgICAgICAgICBkZXJpdmVkIGZyb20gdGhlIEFIQiBjbG9jayAoSENMSykuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgb25lIG9mIHRoZSBmb2xsb3dpbmcgdmFsdWVzOg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSENMS19EaXYxOiBBUEIxIGNsb2NrID0gSENMSw0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSENMS19EaXYyOiBBUEIxIGNsb2NrID0gSENMSy8yDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19IQ0xLX0RpdjQ6IEFQQjEgY2xvY2sgPSBIQ0xLLzQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0hDTEtfRGl2ODogQVBCMSBjbG9jayA9IEhDTEsvOA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSENMS19EaXYxNjogQVBCMSBjbG9jayA9IEhDTEsvMTYNCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX1BDTEsxQ29uZmlnKHUzMiBSQ0NfSENMSykNCnsNCiAgdTMyIHRtcHJlZyA9IDA7DQoNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX1JDQ19QQ0xLKFJDQ19IQ0xLKSk7DQoNCiAgdG1wcmVnID0gUkNDLT5DRkdSOw0KDQogIC8qIENsZWFyIFBQUkUxWzI6MF0gYml0cyAqLw0KICB0bXByZWcgJj0gQ0ZHUl9QUFJFMV9SZXNldF9NYXNrOw0KDQogIC8qIFNldCBQUFJFMVsyOjBdIGJpdHMgYWNjb3JkaW5nIHRvIFJDQ19IQ0xLIHZhbHVlICovDQogIHRtcHJlZyB8PSBSQ0NfSENMSzsNCg0KICAvKiBTdG9yZSB0aGUgbmV3IHZhbHVlICovDQogIFJDQy0+Q0ZHUiA9IHRtcHJlZzsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfUENMSzJDb25maWcNCiogRGVzY3JpcHRpb24gICAgOiBDb25maWd1cmVzIHRoZSBIaWdoIFNwZWVkIEFQQiBjbG9jayAoUENMSzIpLg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX0hDTEs6IGRlZmluZXMgdGhlIEFQQjIgY2xvY2sgZGl2aWRlci4gVGhpcyBjbG9jayBpcw0KKiAgICAgICAgICAgICAgICAgICAgZGVyaXZlZCBmcm9tIHRoZSBBSEIgY2xvY2sgKEhDTEspLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0hDTEtfRGl2MTogQVBCMiBjbG9jayA9IEhDTEsNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0hDTEtfRGl2MjogQVBCMiBjbG9jayA9IEhDTEsvMg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSENMS19EaXY0OiBBUEIyIGNsb2NrID0gSENMSy80DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19IQ0xLX0Rpdjg6IEFQQjIgY2xvY2sgPSBIQ0xLLzgNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0hDTEtfRGl2MTY6IEFQQjIgY2xvY2sgPSBIQ0xLLzE2DQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19QQ0xLMkNvbmZpZyh1MzIgUkNDX0hDTEspDQp7DQogIHUzMiB0bXByZWcgPSAwOw0KDQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfUENMSyhSQ0NfSENMSykpOw0KDQogIHRtcHJlZyA9IFJDQy0+Q0ZHUjsNCg0KICAvKiBDbGVhciBQUFJFMlsyOjBdIGJpdHMgKi8NCiAgdG1wcmVnICY9IENGR1JfUFBSRTJfUmVzZXRfTWFzazsNCg0KICAvKiBTZXQgUFBSRTJbMjowXSBiaXRzIGFjY29yZGluZyB0byBSQ0NfSENMSyB2YWx1ZSAqLw0KICB0bXByZWcgfD0gUkNDX0hDTEsgPDwgMzsNCg0KICAvKiBTdG9yZSB0aGUgbmV3IHZhbHVlICovDQogIFJDQy0+Q0ZHUiA9IHRtcHJlZzsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfSVRDb25maWcNCiogRGVzY3JpcHRpb24gICAgOiBFbmFibGVzIG9yIGRpc2FibGVzIHRoZSBzcGVjaWZpZWQgUkNDIGludGVycnVwdHMuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfSVQ6IHNwZWNpZmllcyB0aGUgUkNDIGludGVycnVwdCBzb3VyY2VzIHRvIGJlIGVuYWJsZWQNCiogICAgICAgICAgICAgICAgICAgIG9yIGRpc2FibGVkLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIGFueSBjb21iaW5hdGlvbiBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0lUX0xTSVJEWTogTFNJIHJlYWR5IGludGVycnVwdA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSVRfTFNFUkRZOiBMU0UgcmVhZHkgaW50ZXJydXB0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19JVF9IU0lSRFk6IEhTSSByZWFkeSBpbnRlcnJ1cHQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0lUX0hTRVJEWTogSFNFIHJlYWR5IGludGVycnVwdA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSVRfUExMUkRZOiBQTEwgcmVhZHkgaW50ZXJydXB0DQoqICAgICAgICAgICAgICAgICAgLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBzcGVjaWZpZWQgUkNDIGludGVycnVwdHMuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmU6IEVOQUJMRSBvciBESVNBQkxFLg0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfSVRDb25maWcodTggUkNDX0lULCBGdW5jdGlvbmFsU3RhdGUgTmV3U3RhdGUpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfSVQoUkNDX0lUKSk7DQogIGFzc2VydF9wYXJhbShJU19GVU5DVElPTkFMX1NUQVRFKE5ld1N0YXRlKSk7DQoNCiAgaWYgKE5ld1N0YXRlICE9IERJU0FCTEUpDQogIHsNCiAgICAvKiBQZXJmb3JtIEJ5dGUgYWNjZXNzIHRvIFJDQ19DSVJbMTI6OF0gYml0cyB0byBlbmFibGUgdGhlIHNlbGVjdGVkIGludGVycnVwdHMgKi8NCiAgICAqKHZ1OCAqKSBDSVJfQllURTJfQUREUkVTUyB8PSBSQ0NfSVQ7DQogIH0NCiAgZWxzZQ0KICB7DQogICAgLyogUGVyZm9ybSBCeXRlIGFjY2VzcyB0byBSQ0NfQ0lSWzEyOjhdIGJpdHMgdG8gZGlzYWJsZSB0aGUgc2VsZWN0ZWQgaW50ZXJydXB0cyAqLw0KICAgICoodnU4ICopIENJUl9CWVRFMl9BRERSRVNTICY9ICh1OCl+UkNDX0lUOw0KICB9DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX1VTQkNMS0NvbmZpZw0KKiBEZXNjcmlwdGlvbiAgICA6IENvbmZpZ3VyZXMgdGhlIFVTQiBjbG9jayAoVVNCQ0xLKS4NCiogSW5wdXQgICAgICAgICAgOiAtIFJDQ19VU0JDTEtTb3VyY2U6IHNwZWNpZmllcyB0aGUgVVNCIGNsb2NrIHNvdXJjZS4gVGhpcyBjbG9jaw0KKiAgICAgICAgICAgICAgICAgICAgaXMgZGVyaXZlZCBmcm9tIHRoZSBQTEwgb3V0cHV0Lg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1VTQkNMS1NvdXJjZV9QTExDTEtfMURpdjU6IFBMTCBjbG9jayBkaXZpZGVkIGJ5IDEsNQ0KKiAgICAgICAgICAgICAgICAgICAgICAgICBzZWxlY3RlZCBhcyBVU0IgY2xvY2sgc291cmNlDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19VU0JDTEtTb3VyY2VfUExMQ0xLX0RpdjE6IFBMTCBjbG9jayBzZWxlY3RlZCBhcyBVU0INCiogICAgICAgICAgICAgICAgICAgICAgICAgY2xvY2sgc291cmNlDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19VU0JDTEtDb25maWcodTMyIFJDQ19VU0JDTEtTb3VyY2UpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfVVNCQ0xLX1NPVVJDRShSQ0NfVVNCQ0xLU291cmNlKSk7DQoNCiAgKih2dTMyICopIENGR1JfVVNCUFJFX0JCID0gUkNDX1VTQkNMS1NvdXJjZTsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfQURDQ0xLQ29uZmlnDQoqIERlc2NyaXB0aW9uICAgIDogQ29uZmlndXJlcyB0aGUgQURDIGNsb2NrIChBRENDTEspLg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX1BDTEsyOiBkZWZpbmVzIHRoZSBBREMgY2xvY2sgZGl2aWRlci4gVGhpcyBjbG9jayBpcw0KKiAgICAgICAgICAgICAgICAgICAgZGVyaXZlZCBmcm9tIHRoZSBBUEIyIGNsb2NrIChQQ0xLMikuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgb25lIG9mIHRoZSBmb2xsb3dpbmcgdmFsdWVzOg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfUENMSzJfRGl2MjogQURDIGNsb2NrID0gUENMSzIvMg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfUENMSzJfRGl2NDogQURDIGNsb2NrID0gUENMSzIvNA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfUENMSzJfRGl2NjogQURDIGNsb2NrID0gUENMSzIvNg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfUENMSzJfRGl2ODogQURDIGNsb2NrID0gUENMSzIvOA0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfQURDQ0xLQ29uZmlnKHUzMiBSQ0NfUENMSzIpDQp7DQogIHUzMiB0bXByZWcgPSAwOw0KDQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfQURDQ0xLKFJDQ19QQ0xLMikpOw0KDQogIHRtcHJlZyA9IFJDQy0+Q0ZHUjsNCg0KICAvKiBDbGVhciBBRENQUkVbMTowXSBiaXRzICovDQogIHRtcHJlZyAmPSBDRkdSX0FEQ1BSRV9SZXNldF9NYXNrOw0KDQogIC8qIFNldCBBRENQUkVbMTowXSBiaXRzIGFjY29yZGluZyB0byBSQ0NfUENMSzIgdmFsdWUgKi8NCiAgdG1wcmVnIHw9IFJDQ19QQ0xLMjsNCg0KICAvKiBTdG9yZSB0aGUgbmV3IHZhbHVlICovDQogIFJDQy0+Q0ZHUiA9IHRtcHJlZzsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfTFNFQ29uZmlnDQoqIERlc2NyaXB0aW9uICAgIDogQ29uZmlndXJlcyB0aGUgRXh0ZXJuYWwgTG93IFNwZWVkIG9zY2lsbGF0b3IgKExTRSkuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfTFNFOiBzcGVjaWZpZXMgdGhlIG5ldyBzdGF0ZSBvZiB0aGUgTFNFLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0xTRV9PRkY6IExTRSBvc2NpbGxhdG9yIE9GRg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfTFNFX09OOiBMU0Ugb3NjaWxsYXRvciBPTg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfTFNFX0J5cGFzczogTFNFIG9zY2lsbGF0b3IgYnlwYXNzZWQgd2l0aCBleHRlcm5hbA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBjbG9jaw0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfTFNFQ29uZmlnKHU4IFJDQ19MU0UpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfTFNFKFJDQ19MU0UpKTsNCg0KICAvKiBSZXNldCBMU0VPTiBhbmQgTFNFQllQIGJpdHMgYmVmb3JlIGNvbmZpZ3VyaW5nIHRoZSBMU0UgLS0tLS0tLS0tLS0tLS0tLS0tKi8NCiAgLyogUmVzZXQgTFNFT04gYml0ICovDQogICoodnU4ICopIEJEQ1JfQUREUkVTUyA9IFJDQ19MU0VfT0ZGOw0KDQogIC8qIFJlc2V0IExTRUJZUCBiaXQgKi8NCiAgKih2dTggKikgQkRDUl9BRERSRVNTID0gUkNDX0xTRV9PRkY7DQoNCiAgLyogQ29uZmlndXJlIExTRSAoUkNDX0xTRV9PRkYgaXMgYWxyZWFkeSBjb3ZlcmVkIGJ5IHRoZSBjb2RlIHNlY3Rpb24gYWJvdmUpICovDQogIHN3aXRjaChSQ0NfTFNFKQ0KICB7DQogICAgY2FzZSBSQ0NfTFNFX09OOg0KICAgICAgLyogU2V0IExTRU9OIGJpdCAqLw0KICAgICAgKih2dTggKikgQkRDUl9BRERSRVNTID0gUkNDX0xTRV9PTjsNCiAgICAgIGJyZWFrOw0KICAgICAgDQogICAgY2FzZSBSQ0NfTFNFX0J5cGFzczoNCiAgICAgIC8qIFNldCBMU0VCWVAgYW5kIExTRU9OIGJpdHMgKi8NCiAgICAgICoodnU4ICopIEJEQ1JfQUREUkVTUyA9IFJDQ19MU0VfQnlwYXNzIHwgUkNDX0xTRV9PTjsNCiAgICAgIGJyZWFrOyAgICAgICAgICAgIA0KICAgICAgDQogICAgZGVmYXVsdDoNCiAgICAgIGJyZWFrOyAgICAgIA0KICB9DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0xTSUNtZA0KKiBEZXNjcmlwdGlvbiAgICA6IEVuYWJsZXMgb3IgZGlzYWJsZXMgdGhlIEludGVybmFsIExvdyBTcGVlZCBvc2NpbGxhdG9yIChMU0kpLg0KKiAgICAgICAgICAgICAgICAgIExTSSBjYW4gbm90IGJlIGRpc2FibGVkIGlmIHRoZSBJV0RHIGlzIHJ1bm5pbmcuDQoqIElucHV0ICAgICAgICAgIDogLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBMU0kuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmU6IEVOQUJMRSBvciBESVNBQkxFLg0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfTFNJQ21kKEZ1bmN0aW9uYWxTdGF0ZSBOZXdTdGF0ZSkNCnsNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICAqKHZ1MzIgKikgQ1NSX0xTSU9OX0JCID0gKHUzMilOZXdTdGF0ZTsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfUlRDQ0xLQ29uZmlnDQoqIERlc2NyaXB0aW9uICAgIDogQ29uZmlndXJlcyB0aGUgUlRDIGNsb2NrIChSVENDTEspLg0KKiAgICAgICAgICAgICAgICAgIE9uY2UgdGhlIFJUQyBjbG9jayBpcyBzZWxlY3RlZCBpdCBjYW6SdCBiZSBjaGFuZ2VkIHVubGVzcyB0aGUNCiogICAgICAgICAgICAgICAgICBCYWNrdXAgZG9tYWluIGlzIHJlc2V0Lg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX1JUQ0NMS1NvdXJjZTogc3BlY2lmaWVzIHRoZSBSVEMgY2xvY2sgc291cmNlLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1JUQ0NMS1NvdXJjZV9MU0U6IExTRSBzZWxlY3RlZCBhcyBSVEMgY2xvY2sNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1JUQ0NMS1NvdXJjZV9MU0k6IExTSSBzZWxlY3RlZCBhcyBSVEMgY2xvY2sNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX1JUQ0NMS1NvdXJjZV9IU0VfRGl2MTI4OiBIU0UgY2xvY2sgZGl2aWRlZCBieSAxMjgNCiogICAgICAgICAgICAgICAgICAgICAgICAgc2VsZWN0ZWQgYXMgUlRDIGNsb2NrDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19SVENDTEtDb25maWcodTMyIFJDQ19SVENDTEtTb3VyY2UpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfUlRDQ0xLX1NPVVJDRShSQ0NfUlRDQ0xLU291cmNlKSk7DQoNCiAgLyogU2VsZWN0IHRoZSBSVEMgY2xvY2sgc291cmNlICovDQogIFJDQy0+QkRDUiB8PSBSQ0NfUlRDQ0xLU291cmNlOw0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19SVENDTEtDbWQNCiogRGVzY3JpcHRpb24gICAgOiBFbmFibGVzIG9yIGRpc2FibGVzIHRoZSBSVEMgY2xvY2suDQoqICAgICAgICAgICAgICAgICAgVGhpcyBmdW5jdGlvbiBtdXN0IGJlIHVzZWQgb25seSBhZnRlciB0aGUgUlRDIGNsb2NrIHdhcw0KKiAgICAgICAgICAgICAgICAgIHNlbGVjdGVkIHVzaW5nIHRoZSBSQ0NfUlRDQ0xLQ29uZmlnIGZ1bmN0aW9uLg0KKiBJbnB1dCAgICAgICAgICA6IC0gTmV3U3RhdGU6IG5ldyBzdGF0ZSBvZiB0aGUgUlRDIGNsb2NrLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlOiBFTkFCTEUgb3IgRElTQUJMRS4NCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX1JUQ0NMS0NtZChGdW5jdGlvbmFsU3RhdGUgTmV3U3RhdGUpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19GVU5DVElPTkFMX1NUQVRFKE5ld1N0YXRlKSk7DQoNCiAgKih2dTMyICopIEJEQ1JfUlRDRU5fQkIgPSAodTMyKU5ld1N0YXRlOw0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19HZXRDbG9ja3NGcmVxDQoqIERlc2NyaXB0aW9uICAgIDogUmV0dXJucyB0aGUgZnJlcXVlbmNpZXMgb2YgZGlmZmVyZW50IG9uIGNoaXAgY2xvY2tzLg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX0Nsb2NrczogcG9pbnRlciB0byBhIFJDQ19DbG9ja3NUeXBlRGVmIHN0cnVjdHVyZSB3aGljaA0KKiAgICAgICAgICAgICAgICAgICAgd2lsbCBob2xkIHRoZSBjbG9ja3MgZnJlcXVlbmNpZXMuDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19HZXRDbG9ja3NGcmVxKFJDQ19DbG9ja3NUeXBlRGVmKiBSQ0NfQ2xvY2tzKQ0Kew0KICB1MzIgdG1wID0gMCwgcGxsbXVsbCA9IDAsIHBsbHNvdXJjZSA9IDAsIHByZXNjID0gMDsNCg0KICAvKiBHZXQgU1lTQ0xLIHNvdXJjZSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCiAgdG1wID0gUkNDLT5DRkdSICYgQ0ZHUl9TV1NfTWFzazsNCg0KICBzd2l0Y2ggKHRtcCkNCiAgew0KICAgIGNhc2UgMHgwMDogIC8qIEhTSSB1c2VkIGFzIHN5c3RlbSBjbG9jayAqLw0KICAgICAgUkNDX0Nsb2Nrcy0+U1lTQ0xLX0ZyZXF1ZW5jeSA9IEhTSV9WYWx1ZTsNCiAgICAgIGJyZWFrOw0KDQogICAgY2FzZSAweDA0OiAgLyogSFNFIHVzZWQgYXMgc3lzdGVtIGNsb2NrICovDQogICAgICBSQ0NfQ2xvY2tzLT5TWVNDTEtfRnJlcXVlbmN5ID0gSFNFX1ZhbHVlOw0KICAgICAgYnJlYWs7DQoNCiAgICBjYXNlIDB4MDg6ICAvKiBQTEwgdXNlZCBhcyBzeXN0ZW0gY2xvY2sgKi8NCiAgICAgIC8qIEdldCBQTEwgY2xvY2sgc291cmNlIGFuZCBtdWx0aXBsaWNhdGlvbiBmYWN0b3IgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovDQogICAgICBwbGxtdWxsID0gUkNDLT5DRkdSICYgQ0ZHUl9QTExNdWxsX01hc2s7DQogICAgICBwbGxtdWxsID0gKCBwbGxtdWxsID4+IDE4KSArIDI7DQoNCiAgICAgIHBsbHNvdXJjZSA9IFJDQy0+Q0ZHUiAmIENGR1JfUExMU1JDX01hc2s7DQoNCiAgICAgIGlmIChwbGxzb3VyY2UgPT0gMHgwMCkNCiAgICAgIHsvKiBIU0kgb3NjaWxsYXRvciBjbG9jayBkaXZpZGVkIGJ5IDIgc2VsZWN0ZWQgYXMgUExMIGNsb2NrIGVudHJ5ICovDQogICAgICAgIFJDQ19DbG9ja3MtPlNZU0NMS19GcmVxdWVuY3kgPSAoSFNJX1ZhbHVlID4+IDEpICogcGxsbXVsbDsNCiAgICAgIH0NCiAgICAgIGVsc2UNCiAgICAgIHsvKiBIU0Ugc2VsZWN0ZWQgYXMgUExMIGNsb2NrIGVudHJ5ICovDQoNCiAgICAgICAgaWYgKChSQ0MtPkNGR1IgJiBDRkdSX1BMTFhUUFJFX01hc2spICE9ICh1MzIpUkVTRVQpDQogICAgICAgIHsvKiBIU0Ugb3NjaWxsYXRvciBjbG9jayBkaXZpZGVkIGJ5IDIgKi8NCg0KICAgICAgICAgIFJDQ19DbG9ja3MtPlNZU0NMS19GcmVxdWVuY3kgPSAoSFNFX1ZhbHVlID4+IDEpICogcGxsbXVsbDsNCiAgICAgICAgfQ0KICAgICAgICBlbHNlDQogICAgICAgIHsNCiAgICAgICAgICBSQ0NfQ2xvY2tzLT5TWVNDTEtfRnJlcXVlbmN5ID0gSFNFX1ZhbHVlICogcGxsbXVsbDsNCiAgICAgICAgfQ0KICAgICAgfQ0KICAgICAgYnJlYWs7DQoNCiAgICBkZWZhdWx0Og0KICAgICAgUkNDX0Nsb2Nrcy0+U1lTQ0xLX0ZyZXF1ZW5jeSA9IEhTSV9WYWx1ZTsNCiAgICAgIGJyZWFrOw0KICB9DQoNCiAgLyogQ29tcHV0ZSBIQ0xLLCBQQ0xLMSwgUENMSzIgYW5kIEFEQ0NMSyBjbG9ja3MgZnJlcXVlbmNpZXMgLS0tLS0tLS0tLS0tLS0tLSovDQogIC8qIEdldCBIQ0xLIHByZXNjYWxlciAqLw0KICB0bXAgPSBSQ0MtPkNGR1IgJiBDRkdSX0hQUkVfU2V0X01hc2s7DQogIHRtcCA9IHRtcCA+PiA0Ow0KICBwcmVzYyA9IEFQQkFIQlByZXNjVGFibGVbdG1wXTsNCg0KICAvKiBIQ0xLIGNsb2NrIGZyZXF1ZW5jeSAqLw0KICBSQ0NfQ2xvY2tzLT5IQ0xLX0ZyZXF1ZW5jeSA9IFJDQ19DbG9ja3MtPlNZU0NMS19GcmVxdWVuY3kgPj4gcHJlc2M7DQoNCiAgLyogR2V0IFBDTEsxIHByZXNjYWxlciAqLw0KICB0bXAgPSBSQ0MtPkNGR1IgJiBDRkdSX1BQUkUxX1NldF9NYXNrOw0KICB0bXAgPSB0bXAgPj4gODsNCiAgcHJlc2MgPSBBUEJBSEJQcmVzY1RhYmxlW3RtcF07DQoNCiAgLyogUENMSzEgY2xvY2sgZnJlcXVlbmN5ICovDQogIFJDQ19DbG9ja3MtPlBDTEsxX0ZyZXF1ZW5jeSA9IFJDQ19DbG9ja3MtPkhDTEtfRnJlcXVlbmN5ID4+IHByZXNjOw0KDQogIC8qIEdldCBQQ0xLMiBwcmVzY2FsZXIgKi8NCiAgdG1wID0gUkNDLT5DRkdSICYgQ0ZHUl9QUFJFMl9TZXRfTWFzazsNCiAgdG1wID0gdG1wID4+IDExOw0KICBwcmVzYyA9IEFQQkFIQlByZXNjVGFibGVbdG1wXTsNCg0KICAvKiBQQ0xLMiBjbG9jayBmcmVxdWVuY3kgKi8NCiAgUkNDX0Nsb2Nrcy0+UENMSzJfRnJlcXVlbmN5ID0gUkNDX0Nsb2Nrcy0+SENMS19GcmVxdWVuY3kgPj4gcHJlc2M7DQoNCiAgLyogR2V0IEFEQ0NMSyBwcmVzY2FsZXIgKi8NCiAgdG1wID0gUkNDLT5DRkdSICYgQ0ZHUl9BRENQUkVfU2V0X01hc2s7DQogIHRtcCA9IHRtcCA+PiAxNDsNCiAgcHJlc2MgPSBBRENQcmVzY1RhYmxlW3RtcF07DQoNCiAgLyogQURDQ0xLIGNsb2NrIGZyZXF1ZW5jeSAqLw0KICBSQ0NfQ2xvY2tzLT5BRENDTEtfRnJlcXVlbmN5ID0gUkNDX0Nsb2Nrcy0+UENMSzJfRnJlcXVlbmN5IC8gcHJlc2M7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0FIQlBlcmlwaENsb2NrQ21kDQoqIERlc2NyaXB0aW9uICAgIDogRW5hYmxlcyBvciBkaXNhYmxlcyB0aGUgQUhCIHBlcmlwaGVyYWwgY2xvY2suDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfQUhCUGVyaXBoOiBzcGVjaWZpZXMgdGhlIEFIQiBwZXJpcGhlcmFsIHRvIGdhdGVzIGl0cyBjbG9jay4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSBhbnkgY29tYmluYXRpb24gb2YgdGhlIGZvbGxvd2luZyB2YWx1ZXM6DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19BSEJQZXJpcGhfRE1BMQ0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfQUhCUGVyaXBoX0RNQTINCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0FIQlBlcmlwaF9TUkFNDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19BSEJQZXJpcGhfRkxJVEYNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0FIQlBlcmlwaF9DUkMNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0FIQlBlcmlwaF9GU01DDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19BSEJQZXJpcGhfU0RJTw0KKiAgICAgICAgICAgICAgICAgICAgU1JBTSBhbmQgRkxJVEYgY2xvY2sgY2FuIGJlIGRpc2FibGVkIG9ubHkgZHVyaW5nIHNsZWVwIG1vZGUuDQoqICAgICAgICAgICAgICAgICAgLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBzcGVjaWZpZWQgcGVyaXBoZXJhbCBjbG9jay4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZTogRU5BQkxFIG9yIERJU0FCTEUuDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19BSEJQZXJpcGhDbG9ja0NtZCh1MzIgUkNDX0FIQlBlcmlwaCwgRnVuY3Rpb25hbFN0YXRlIE5ld1N0YXRlKQ0Kew0KICAvKiBDaGVjayB0aGUgcGFyYW1ldGVycyAqLw0KICBhc3NlcnRfcGFyYW0oSVNfUkNDX0FIQl9QRVJJUEgoUkNDX0FIQlBlcmlwaCkpOw0KICBhc3NlcnRfcGFyYW0oSVNfRlVOQ1RJT05BTF9TVEFURShOZXdTdGF0ZSkpOw0KDQogIGlmIChOZXdTdGF0ZSAhPSBESVNBQkxFKQ0KICB7DQogICAgUkNDLT5BSEJFTlIgfD0gUkNDX0FIQlBlcmlwaDsNCiAgfQ0KICBlbHNlDQogIHsNCiAgICBSQ0MtPkFIQkVOUiAmPSB+UkNDX0FIQlBlcmlwaDsNCiAgfQ0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19BUEIyUGVyaXBoQ2xvY2tDbWQNCiogRGVzY3JpcHRpb24gICAgOiBFbmFibGVzIG9yIGRpc2FibGVzIHRoZSBIaWdoIFNwZWVkIEFQQiAoQVBCMikgcGVyaXBoZXJhbCBjbG9jay4NCiogSW5wdXQgICAgICAgICAgOiAtIFJDQ19BUEIyUGVyaXBoOiBzcGVjaWZpZXMgdGhlIEFQQjIgcGVyaXBoZXJhbCB0byBnYXRlcyBpdHMNCiogICAgICAgICAgICAgICAgICAgIGNsb2NrLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIGFueSBjb21iaW5hdGlvbiBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0FQQjJQZXJpcGhfQUZJTywgUkNDX0FQQjJQZXJpcGhfR1BJT0EsIFJDQ19BUEIyUGVyaXBoX0dQSU9CLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMlBlcmlwaF9HUElPQywgUkNDX0FQQjJQZXJpcGhfR1BJT0QsIFJDQ19BUEIyUGVyaXBoX0dQSU9FLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMlBlcmlwaF9HUElPRiwgUkNDX0FQQjJQZXJpcGhfR1BJT0csIFJDQ19BUEIyUGVyaXBoX0FEQzEsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIyUGVyaXBoX0FEQzIsIFJDQ19BUEIyUGVyaXBoX1RJTTEsIFJDQ19BUEIyUGVyaXBoX1NQSTEsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIyUGVyaXBoX1RJTTgsIFJDQ19BUEIyUGVyaXBoX1VTQVJUMSwgUkNDX0FQQjJQZXJpcGhfQURDMywNCiogICAgICAgICAgICAgICAgICAgICAgICAgUkNDX0FQQjJQZXJpcGhfQUxMDQoqICAgICAgICAgICAgICAgICAgLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBzcGVjaWZpZWQgcGVyaXBoZXJhbCBjbG9jay4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZTogRU5BQkxFIG9yIERJU0FCTEUuDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19BUEIyUGVyaXBoQ2xvY2tDbWQodTMyIFJDQ19BUEIyUGVyaXBoLCBGdW5jdGlvbmFsU3RhdGUgTmV3U3RhdGUpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfQVBCMl9QRVJJUEgoUkNDX0FQQjJQZXJpcGgpKTsNCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICBpZiAoTmV3U3RhdGUgIT0gRElTQUJMRSkNCiAgew0KICAgIFJDQy0+QVBCMkVOUiB8PSBSQ0NfQVBCMlBlcmlwaDsNCiAgfQ0KICBlbHNlDQogIHsNCiAgICBSQ0MtPkFQQjJFTlIgJj0gflJDQ19BUEIyUGVyaXBoOw0KICB9DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0FQQjFQZXJpcGhDbG9ja0NtZA0KKiBEZXNjcmlwdGlvbiAgICA6IEVuYWJsZXMgb3IgZGlzYWJsZXMgdGhlIExvdyBTcGVlZCBBUEIgKEFQQjEpIHBlcmlwaGVyYWwgY2xvY2suDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfQVBCMVBlcmlwaDogc3BlY2lmaWVzIHRoZSBBUEIxIHBlcmlwaGVyYWwgdG8gZ2F0ZXMgaXRzDQoqICAgICAgICAgICAgICAgICAgICBjbG9jay4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSBhbnkgY29tYmluYXRpb24gb2YgdGhlIGZvbGxvd2luZyB2YWx1ZXM6DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19BUEIxUGVyaXBoX1RJTTIsIFJDQ19BUEIxUGVyaXBoX1RJTTMsIFJDQ19BUEIxUGVyaXBoX1RJTTQsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIxUGVyaXBoX1RJTTUsIFJDQ19BUEIxUGVyaXBoX1RJTTYsIFJDQ19BUEIxUGVyaXBoX1RJTTcsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIxUGVyaXBoX1dXREcsIFJDQ19BUEIxUGVyaXBoX1NQSTIsIFJDQ19BUEIxUGVyaXBoX1NQSTMsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIxUGVyaXBoX1VTQVJUMiwgUkNDX0FQQjFQZXJpcGhfVVNBUlQzLCBSQ0NfQVBCMVBlcmlwaF9VU0FSVDQsIA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMVBlcmlwaF9VU0FSVDUsIFJDQ19BUEIxUGVyaXBoX0kyQzEsIFJDQ19BUEIxUGVyaXBoX0kyQzIsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIxUGVyaXBoX1VTQiwgUkNDX0FQQjFQZXJpcGhfQ0FOLCBSQ0NfQVBCMVBlcmlwaF9CS1AsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIxUGVyaXBoX1BXUiwgUkNDX0FQQjFQZXJpcGhfREFDLCBSQ0NfQVBCMVBlcmlwaF9BTEwNCiogICAgICAgICAgICAgICAgICAtIE5ld1N0YXRlOiBuZXcgc3RhdGUgb2YgdGhlIHNwZWNpZmllZCBwZXJpcGhlcmFsIGNsb2NrLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlOiBFTkFCTEUgb3IgRElTQUJMRS4NCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX0FQQjFQZXJpcGhDbG9ja0NtZCh1MzIgUkNDX0FQQjFQZXJpcGgsIEZ1bmN0aW9uYWxTdGF0ZSBOZXdTdGF0ZSkNCnsNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX1JDQ19BUEIxX1BFUklQSChSQ0NfQVBCMVBlcmlwaCkpOw0KICBhc3NlcnRfcGFyYW0oSVNfRlVOQ1RJT05BTF9TVEFURShOZXdTdGF0ZSkpOw0KDQogIGlmIChOZXdTdGF0ZSAhPSBESVNBQkxFKQ0KICB7DQogICAgUkNDLT5BUEIxRU5SIHw9IFJDQ19BUEIxUGVyaXBoOw0KICB9DQogIGVsc2UNCiAgew0KICAgIFJDQy0+QVBCMUVOUiAmPSB+UkNDX0FQQjFQZXJpcGg7DQogIH0NCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfQVBCMlBlcmlwaFJlc2V0Q21kDQoqIERlc2NyaXB0aW9uICAgIDogRm9yY2VzIG9yIHJlbGVhc2VzIEhpZ2ggU3BlZWQgQVBCIChBUEIyKSBwZXJpcGhlcmFsIHJlc2V0Lg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX0FQQjJQZXJpcGg6IHNwZWNpZmllcyB0aGUgQVBCMiBwZXJpcGhlcmFsIHRvIHJlc2V0Lg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIGFueSBjb21iaW5hdGlvbiBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0FQQjJQZXJpcGhfQUZJTywgUkNDX0FQQjJQZXJpcGhfR1BJT0EsIFJDQ19BUEIyUGVyaXBoX0dQSU9CLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMlBlcmlwaF9HUElPQywgUkNDX0FQQjJQZXJpcGhfR1BJT0QsIFJDQ19BUEIyUGVyaXBoX0dQSU9FLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMlBlcmlwaF9HUElPRiwgUkNDX0FQQjJQZXJpcGhfR1BJT0csIFJDQ19BUEIyUGVyaXBoX0FEQzEsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIyUGVyaXBoX0FEQzIsIFJDQ19BUEIyUGVyaXBoX1RJTTEsIFJDQ19BUEIyUGVyaXBoX1NQSTEsDQoqICAgICAgICAgICAgICAgICAgICAgICAgIFJDQ19BUEIyUGVyaXBoX1RJTTgsIFJDQ19BUEIyUGVyaXBoX1VTQVJUMSwgUkNDX0FQQjJQZXJpcGhfQURDMywNCiogICAgICAgICAgICAgICAgICAgICAgICAgUkNDX0FQQjJQZXJpcGhfQUxMDQoqICAgICAgICAgICAgICAgICAgLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBzcGVjaWZpZWQgcGVyaXBoZXJhbCByZXNldC4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZTogRU5BQkxFIG9yIERJU0FCTEUuDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19BUEIyUGVyaXBoUmVzZXRDbWQodTMyIFJDQ19BUEIyUGVyaXBoLCBGdW5jdGlvbmFsU3RhdGUgTmV3U3RhdGUpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfQVBCMl9QRVJJUEgoUkNDX0FQQjJQZXJpcGgpKTsNCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICBpZiAoTmV3U3RhdGUgIT0gRElTQUJMRSkNCiAgew0KICAgIFJDQy0+QVBCMlJTVFIgfD0gUkNDX0FQQjJQZXJpcGg7DQogIH0NCiAgZWxzZQ0KICB7DQogICAgUkNDLT5BUEIyUlNUUiAmPSB+UkNDX0FQQjJQZXJpcGg7DQogIH0NCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfQVBCMVBlcmlwaFJlc2V0Q21kDQoqIERlc2NyaXB0aW9uICAgIDogRm9yY2VzIG9yIHJlbGVhc2VzIExvdyBTcGVlZCBBUEIgKEFQQjEpIHBlcmlwaGVyYWwgcmVzZXQuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfQVBCMVBlcmlwaDogc3BlY2lmaWVzIHRoZSBBUEIxIHBlcmlwaGVyYWwgdG8gcmVzZXQuDQoqICAgICAgICAgICAgICAgICAgICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgYW55IGNvbWJpbmF0aW9uIG9mIHRoZSBmb2xsb3dpbmcgdmFsdWVzOg0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfQVBCMVBlcmlwaF9USU0yLCBSQ0NfQVBCMVBlcmlwaF9USU0zLCBSQ0NfQVBCMVBlcmlwaF9USU00LA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMVBlcmlwaF9USU01LCBSQ0NfQVBCMVBlcmlwaF9USU02LCBSQ0NfQVBCMVBlcmlwaF9USU03LA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMVBlcmlwaF9XV0RHLCBSQ0NfQVBCMVBlcmlwaF9TUEkyLCBSQ0NfQVBCMVBlcmlwaF9TUEkzLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMVBlcmlwaF9VU0FSVDIsIFJDQ19BUEIxUGVyaXBoX1VTQVJUMywgUkNDX0FQQjFQZXJpcGhfVVNBUlQ0LCANCiogICAgICAgICAgICAgICAgICAgICAgICAgUkNDX0FQQjFQZXJpcGhfVVNBUlQ1LCBSQ0NfQVBCMVBlcmlwaF9JMkMxLCBSQ0NfQVBCMVBlcmlwaF9JMkMyLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMVBlcmlwaF9VU0IsIFJDQ19BUEIxUGVyaXBoX0NBTiwgUkNDX0FQQjFQZXJpcGhfQktQLA0KKiAgICAgICAgICAgICAgICAgICAgICAgICBSQ0NfQVBCMVBlcmlwaF9QV1IsIFJDQ19BUEIxUGVyaXBoX0RBQywgUkNDX0FQQjFQZXJpcGhfQUxMDQoqICAgICAgICAgICAgICAgICAgLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBzcGVjaWZpZWQgcGVyaXBoZXJhbCBjbG9jay4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZTogRU5BQkxFIG9yIERJU0FCTEUuDQoqIE91dHB1dCAgICAgICAgIDogTm9uZQ0KKiBSZXR1cm4gICAgICAgICA6IE5vbmUNCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQp2b2lkIFJDQ19BUEIxUGVyaXBoUmVzZXRDbWQodTMyIFJDQ19BUEIxUGVyaXBoLCBGdW5jdGlvbmFsU3RhdGUgTmV3U3RhdGUpDQp7DQogIC8qIENoZWNrIHRoZSBwYXJhbWV0ZXJzICovDQogIGFzc2VydF9wYXJhbShJU19SQ0NfQVBCMV9QRVJJUEgoUkNDX0FQQjFQZXJpcGgpKTsNCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICBpZiAoTmV3U3RhdGUgIT0gRElTQUJMRSkNCiAgew0KICAgIFJDQy0+QVBCMVJTVFIgfD0gUkNDX0FQQjFQZXJpcGg7DQogIH0NCiAgZWxzZQ0KICB7DQogICAgUkNDLT5BUEIxUlNUUiAmPSB+UkNDX0FQQjFQZXJpcGg7DQogIH0NCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfQmFja3VwUmVzZXRDbWQNCiogRGVzY3JpcHRpb24gICAgOiBGb3JjZXMgb3IgcmVsZWFzZXMgdGhlIEJhY2t1cCBkb21haW4gcmVzZXQuDQoqIElucHV0ICAgICAgICAgIDogLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBCYWNrdXAgZG9tYWluIHJlc2V0Lg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlOiBFTkFCTEUgb3IgRElTQUJMRS4NCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX0JhY2t1cFJlc2V0Q21kKEZ1bmN0aW9uYWxTdGF0ZSBOZXdTdGF0ZSkNCnsNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX0ZVTkNUSU9OQUxfU1RBVEUoTmV3U3RhdGUpKTsNCg0KICAqKHZ1MzIgKikgQkRDUl9CRFJTVF9CQiA9ICh1MzIpTmV3U3RhdGU7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0Nsb2NrU2VjdXJpdHlTeXN0ZW1DbWQNCiogRGVzY3JpcHRpb24gICAgOiBFbmFibGVzIG9yIGRpc2FibGVzIHRoZSBDbG9jayBTZWN1cml0eSBTeXN0ZW0uDQoqIElucHV0ICAgICAgICAgIDogLSBOZXdTdGF0ZTogbmV3IHN0YXRlIG9mIHRoZSBDbG9jayBTZWN1cml0eSBTeXN0ZW0uLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlOiBFTkFCTEUgb3IgRElTQUJMRS4NCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX0Nsb2NrU2VjdXJpdHlTeXN0ZW1DbWQoRnVuY3Rpb25hbFN0YXRlIE5ld1N0YXRlKQ0Kew0KICAvKiBDaGVjayB0aGUgcGFyYW1ldGVycyAqLw0KICBhc3NlcnRfcGFyYW0oSVNfRlVOQ1RJT05BTF9TVEFURShOZXdTdGF0ZSkpOw0KDQogICoodnUzMiAqKSBDUl9DU1NPTl9CQiA9ICh1MzIpTmV3U3RhdGU7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX01DT0NvbmZpZw0KKiBEZXNjcmlwdGlvbiAgICA6IFNlbGVjdHMgdGhlIGNsb2NrIHNvdXJjZSB0byBvdXRwdXQgb24gTUNPIHBpbi4NCiogSW5wdXQgICAgICAgICAgOiAtIFJDQ19NQ086IHNwZWNpZmllcyB0aGUgY2xvY2sgc291cmNlIHRvIG91dHB1dC4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZyB2YWx1ZXM6DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19NQ09fTm9DbG9jazogTm8gY2xvY2sgc2VsZWN0ZWQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX01DT19TWVNDTEs6IFN5c3RlbSBjbG9jayBzZWxlY3RlZA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfTUNPX0hTSTogSFNJIG9zY2lsbGF0b3IgY2xvY2sgc2VsZWN0ZWQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX01DT19IU0U6IEhTRSBvc2NpbGxhdG9yIGNsb2NrIHNlbGVjdGVkDQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19NQ09fUExMQ0xLX0RpdjI6IFBMTCBjbG9jayBkaXZpZGVkIGJ5IDIgc2VsZWN0ZWQNCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX01DT0NvbmZpZyh1OCBSQ0NfTUNPKQ0Kew0KICAvKiBDaGVjayB0aGUgcGFyYW1ldGVycyAqLw0KICBhc3NlcnRfcGFyYW0oSVNfUkNDX01DTyhSQ0NfTUNPKSk7DQoNCiAgLyogUGVyZm9ybSBCeXRlIGFjY2VzcyB0byBNQ09bMjowXSBiaXRzIHRvIHNlbGVjdCB0aGUgTUNPIHNvdXJjZSAqLw0KICAqKHZ1OCAqKSBDRkdSX0JZVEU0X0FERFJFU1MgPSBSQ0NfTUNPOw0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19HZXRGbGFnU3RhdHVzDQoqIERlc2NyaXB0aW9uICAgIDogQ2hlY2tzIHdoZXRoZXIgdGhlIHNwZWNpZmllZCBSQ0MgZmxhZyBpcyBzZXQgb3Igbm90Lg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX0ZMQUc6IHNwZWNpZmllcyB0aGUgZmxhZyB0byBjaGVjay4NCiogICAgICAgICAgICAgICAgICAgIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSBvbmUgb2YgdGhlIGZvbGxvd2luZyB2YWx1ZXM6DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19GTEFHX0hTSVJEWTogSFNJIG9zY2lsbGF0b3IgY2xvY2sgcmVhZHkNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0ZMQUdfSFNFUkRZOiBIU0Ugb3NjaWxsYXRvciBjbG9jayByZWFkeQ0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfRkxBR19QTExSRFk6IFBMTCBjbG9jayByZWFkeQ0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfRkxBR19MU0VSRFk6IExTRSBvc2NpbGxhdG9yIGNsb2NrIHJlYWR5DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19GTEFHX0xTSVJEWTogTFNJIG9zY2lsbGF0b3IgY2xvY2sgcmVhZHkNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0ZMQUdfUElOUlNUOiBQaW4gcmVzZXQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0ZMQUdfUE9SUlNUOiBQT1IvUERSIHJlc2V0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19GTEFHX1NGVFJTVDogU29mdHdhcmUgcmVzZXQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0ZMQUdfSVdER1JTVDogSW5kZXBlbmRlbnQgV2F0Y2hkb2cgcmVzZXQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0ZMQUdfV1dER1JTVDogV2luZG93IFdhdGNoZG9nIHJlc2V0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19GTEFHX0xQV1JSU1Q6IExvdyBQb3dlciByZXNldA0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBUaGUgbmV3IHN0YXRlIG9mIFJDQ19GTEFHIChTRVQgb3IgUkVTRVQpLg0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCkZsYWdTdGF0dXMgUkNDX0dldEZsYWdTdGF0dXModTggUkNDX0ZMQUcpDQp7DQogIHUzMiB0bXAgPSAwOw0KICB1MzIgc3RhdHVzcmVnID0gMDsNCiAgRmxhZ1N0YXR1cyBiaXRzdGF0dXMgPSBSRVNFVDsNCg0KICAvKiBDaGVjayB0aGUgcGFyYW1ldGVycyAqLw0KICBhc3NlcnRfcGFyYW0oSVNfUkNDX0ZMQUcoUkNDX0ZMQUcpKTsNCg0KICAvKiBHZXQgdGhlIFJDQyByZWdpc3RlciBpbmRleCAqLw0KICB0bXAgPSBSQ0NfRkxBRyA+PiA1Ow0KDQogIGlmICh0bXAgPT0gMSkgICAgICAgICAgICAgICAvKiBUaGUgZmxhZyB0byBjaGVjayBpcyBpbiBDUiByZWdpc3RlciAqLw0KICB7DQogICAgc3RhdHVzcmVnID0gUkNDLT5DUjsNCiAgfQ0KICBlbHNlIGlmICh0bXAgPT0gMikgICAgICAgICAgLyogVGhlIGZsYWcgdG8gY2hlY2sgaXMgaW4gQkRDUiByZWdpc3RlciAqLw0KICB7DQogICAgc3RhdHVzcmVnID0gUkNDLT5CRENSOw0KICB9DQogIGVsc2UgICAgICAgICAgICAgICAgICAgICAgIC8qIFRoZSBmbGFnIHRvIGNoZWNrIGlzIGluIENTUiByZWdpc3RlciAqLw0KICB7DQogICAgc3RhdHVzcmVnID0gUkNDLT5DU1I7DQogIH0NCg0KICAvKiBHZXQgdGhlIGZsYWcgcG9zaXRpb24gKi8NCiAgdG1wID0gUkNDX0ZMQUcgJiBGTEFHX01hc2s7DQoNCiAgaWYgKChzdGF0dXNyZWcgJiAoKHUzMikxIDw8IHRtcCkpICE9ICh1MzIpUkVTRVQpDQogIHsNCiAgICBiaXRzdGF0dXMgPSBTRVQ7DQogIH0NCiAgZWxzZQ0KICB7DQogICAgYml0c3RhdHVzID0gUkVTRVQ7DQogIH0NCg0KICAvKiBSZXR1cm4gdGhlIGZsYWcgc3RhdHVzICovDQogIHJldHVybiBiaXRzdGF0dXM7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqDQoqIEZ1bmN0aW9uIE5hbWUgIDogUkNDX0NsZWFyRmxhZw0KKiBEZXNjcmlwdGlvbiAgICA6IENsZWFycyB0aGUgUkNDIHJlc2V0IGZsYWdzLg0KKiAgICAgICAgICAgICAgICAgIFRoZSByZXNldCBmbGFncyBhcmU6IFJDQ19GTEFHX1BJTlJTVCwgUkNDX0ZMQUdfUE9SUlNULA0KKiAgICAgICAgICAgICAgICAgIFJDQ19GTEFHX1NGVFJTVCwgUkNDX0ZMQUdfSVdER1JTVCwgUkNDX0ZMQUdfV1dER1JTVCwNCiogICAgICAgICAgICAgICAgICBSQ0NfRkxBR19MUFdSUlNUDQoqIElucHV0ICAgICAgICAgIDogTm9uZQ0KKiBPdXRwdXQgICAgICAgICA6IE5vbmUNCiogUmV0dXJuICAgICAgICAgOiBOb25lDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0Kdm9pZCBSQ0NfQ2xlYXJGbGFnKHZvaWQpDQp7DQogIC8qIFNldCBSTVZGIGJpdCB0byBjbGVhciB0aGUgcmVzZXQgZmxhZ3MgKi8NCiAgUkNDLT5DU1IgfD0gQ1NSX1JNVkZfU2V0Ow0KfQ0KDQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KKiBGdW5jdGlvbiBOYW1lICA6IFJDQ19HZXRJVFN0YXR1cw0KKiBEZXNjcmlwdGlvbiAgICA6IENoZWNrcyB3aGV0aGVyIHRoZSBzcGVjaWZpZWQgUkNDIGludGVycnVwdCBoYXMgb2NjdXJyZWQgb3Igbm90Lg0KKiBJbnB1dCAgICAgICAgICA6IC0gUkNDX0lUOiBzcGVjaWZpZXMgdGhlIFJDQyBpbnRlcnJ1cHQgc291cmNlIHRvIGNoZWNrLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0lUX0xTSVJEWTogTFNJIHJlYWR5IGludGVycnVwdA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSVRfTFNFUkRZOiBMU0UgcmVhZHkgaW50ZXJydXB0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19JVF9IU0lSRFk6IEhTSSByZWFkeSBpbnRlcnJ1cHQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0lUX0hTRVJEWTogSFNFIHJlYWR5IGludGVycnVwdA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSVRfUExMUkRZOiBQTEwgcmVhZHkgaW50ZXJydXB0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19JVF9DU1M6IENsb2NrIFNlY3VyaXR5IFN5c3RlbSBpbnRlcnJ1cHQNCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogVGhlIG5ldyBzdGF0ZSBvZiBSQ0NfSVQgKFNFVCBvciBSRVNFVCkuDQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KSVRTdGF0dXMgUkNDX0dldElUU3RhdHVzKHU4IFJDQ19JVCkNCnsNCiAgSVRTdGF0dXMgYml0c3RhdHVzID0gUkVTRVQ7DQoNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX1JDQ19HRVRfSVQoUkNDX0lUKSk7DQoNCiAgLyogQ2hlY2sgdGhlIHN0YXR1cyBvZiB0aGUgc3BlY2lmaWVkIFJDQyBpbnRlcnJ1cHQgKi8NCiAgaWYgKChSQ0MtPkNJUiAmIFJDQ19JVCkgIT0gKHUzMilSRVNFVCkNCiAgew0KICAgIGJpdHN0YXR1cyA9IFNFVDsNCiAgfQ0KICBlbHNlDQogIHsNCiAgICBiaXRzdGF0dXMgPSBSRVNFVDsNCiAgfQ0KDQogIC8qIFJldHVybiB0aGUgUkNDX0lUIHN0YXR1cyAqLw0KICByZXR1cm4gIGJpdHN0YXR1czsNCn0NCg0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiogRnVuY3Rpb24gTmFtZSAgOiBSQ0NfQ2xlYXJJVFBlbmRpbmdCaXQNCiogRGVzY3JpcHRpb24gICAgOiBDbGVhcnMgdGhlIFJDQ5JzIGludGVycnVwdCBwZW5kaW5nIGJpdHMuDQoqIElucHV0ICAgICAgICAgIDogLSBSQ0NfSVQ6IHNwZWNpZmllcyB0aGUgaW50ZXJydXB0IHBlbmRpbmcgYml0IHRvIGNsZWFyLg0KKiAgICAgICAgICAgICAgICAgICAgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIGFueSBjb21iaW5hdGlvbiBvZiB0aGUgZm9sbG93aW5nIHZhbHVlczoNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0lUX0xTSVJEWTogTFNJIHJlYWR5IGludGVycnVwdA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSVRfTFNFUkRZOiBMU0UgcmVhZHkgaW50ZXJydXB0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19JVF9IU0lSRFk6IEhTSSByZWFkeSBpbnRlcnJ1cHQNCiogICAgICAgICAgICAgICAgICAgICAgIC0gUkNDX0lUX0hTRVJEWTogSFNFIHJlYWR5IGludGVycnVwdA0KKiAgICAgICAgICAgICAgICAgICAgICAgLSBSQ0NfSVRfUExMUkRZOiBQTEwgcmVhZHkgaW50ZXJydXB0DQoqICAgICAgICAgICAgICAgICAgICAgICAtIFJDQ19JVF9DU1M6IENsb2NrIFNlY3VyaXR5IFN5c3RlbSBpbnRlcnJ1cHQNCiogT3V0cHV0ICAgICAgICAgOiBOb25lDQoqIFJldHVybiAgICAgICAgIDogTm9uZQ0KKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8NCnZvaWQgUkNDX0NsZWFySVRQZW5kaW5nQml0KHU4IFJDQ19JVCkNCnsNCiAgLyogQ2hlY2sgdGhlIHBhcmFtZXRlcnMgKi8NCiAgYXNzZXJ0X3BhcmFtKElTX1JDQ19DTEVBUl9JVChSQ0NfSVQpKTsNCg0KICAvKiBQZXJmb3JtIEJ5dGUgYWNjZXNzIHRvIFJDQ19DSVJbMjM6MTZdIGJpdHMgdG8gY2xlYXIgdGhlIHNlbGVjdGVkIGludGVycnVwdA0KICAgICBwZW5kaW5nIGJpdHMgKi8NCiAgKih2dTggKikgQ0lSX0JZVEUzX0FERFJFU1MgPSBSQ0NfSVQ7DQp9DQoNCi8qKioqKioqKioqKioqKioqKioqIChDKSBDT1BZUklHSFQgMjAwOCBTVE1pY3JvZWxlY3Ryb25pY3MgKioqKipFTkQgT0YgRklMRSoqKiovDQo=