PD9waHAgIAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL2FwcC5jbGFzcy5waHAiKTsJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbmF2LmNsYXNzLnBocCIpOyAJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbWVudS5jbGFzcy5waHAiKTsgCSRBcHAgCT0gbmV3IEFwcCgpOwkkTmF2CT0gbmV3IE5hdigpOwkkTWVudSAJPSBuZXcgTWVudSgpOwkJaW5jbHVkZSgiX3Byb2plY3RDb21tb24ucGhwIik7ICAgICMgQWxsIG9uIHRoZSBzYW1lIGxpbmUgdG8gdW5jbHV0dGVyIHRoZSB1c2VyJ3MgZGVza3RvcCcKCQoJIwoJIyBCZWdpbjogcGFnZS1zcGVjaWZpYyBzZXR0aW5ncy4gIENoYW5nZSB0aGVzZS4gCgkkcGFnZVRpdGxlIAkJPSAiQ2FsbGlzdG8gUHJlc3MgUmVsZWFzZSI7CgkkcGFnZUtleXdvcmRzCT0gIiI7CgkkcGFnZUF1dGhvcgkJPSAiSWFuIFNrZXJyZXR0IjsKCQoJIyBBZGQgcGFnZS1zcGVjaWZpYyBOYXYgYmFycyBoZXJlCgkjIEZvcm1hdCBpcyBMaW5rIHRleHQsIGxpbmsgVVJMIChjYW4gYmUgaHR0cDovL3d3dy5zb21lb3RoZXJzaXRlLmNvbS8pLCB0YXJnZXQgKF9zZWxmLCBfYmxhbmspCgkjICROYXYtPmFkZEN1c3RvbU5hdigiTXkgTGluayIsICJteXBhZ2UucGhwIiwgIl9zZWxmIik7CgkjICROYXYtPmFkZEN1c3RvbU5hdigiR29vZ2xlIiwgImh0dHA6Ly93d3cuZ29vZ2xlLmNvbS8iLCAiX2JsYW5rIik7CgoJIyBFbmQ6IHBhZ2Utc3BlY2lmaWMgc2V0dGluZ3MKCSMKCQoJIyBQYXN0ZSB5b3VyIEhUTUwgY29udGVudCBiZXR3ZWVuIHRoZSBFT0hUTUwgbWFya2VycyEJCgkkaHRtbCA9IDw8PEVPSFRNTAo8ZGl2IGlkPSJtYWluY29udGVudCI+Cgk8ZGl2IGlkPSJtaWRjb2x1bW4iPgoJCTxoMT4kcGFnZVRpdGxlPC9oMT4KCQk8aDI+PC9oMj4KCQk8aDIgQUxJR049IkNFTlRFUiI+PHN0cm9uZz5DYWxsaXN0byB6ZWlndCBWb3JoZXJzYWdiYXJrZWl0IGRlciBPcGVuIFNvdXJjZS1Tb2Z0d2FyZWVudHdpY2tsdW5nIGb8ciBHcm/fcHJvamVrdGU8L3N0cm9uZz48L2gyPgoJCTx1bD4KCQk8bGk+RWNsaXBzZSBDb21tdW5pdHkgc3RhcnRldCBtaXQghENhbGxpc3RvkyBlcmZvbGdyZWljaGVuIFN5bmNocm9uLVJlbGVhc2Ugdm9uIHplaG4gT3Blbi1Tb3VyY2UtUHJvamVrdGVuIDwvbGk+CgkJPC91bD4KCQk8cD48c3Ryb25nPk9UVEFXQSwgS0FOQURBIJYgMjYuIEp1bmkgMjAwNiA8L3N0cm9uZz6WIERpZSBFY2xpcHNlIEZvdW5kYXRpb24ga/xuZGlndGUgaGV1dGUgZGFzIAoJCWdsZWljaHplaXRpZ2VuIFJlbGVhc2Ugdm9uIHplaG4gRWNsaXBzZSBPcGVuLVNvdXJjZS1Qcm9qZWt0ZW4gYW4uIERpZXNlcyBiZXNvbmRlcmUgUmVsZWFzZS1FcmVpZ25pcyBuYW1lbnMgCgkJQ2FsbGlzdG8gaXN0IGVpbmVzIGRlciBncvbfdGVuIE11bHRpLVByb2pla3QtUmVsZWFzZXMsIGRhcyBqZSBlaW5lIE9wZW4tU291cmNlLUNvbW11bml0eSB1bnRlcm5vbW1lbiBoYXQuIAoJCURpZSBFY2xpcHNlIEZvdW5kYXRpb24gYmlldGV0IG1pdCCEQ2FsbGlzdG+TIGRpZSBzeW5jaHJvbmUgRWluZvxocnVuZyB2b24gemVobiBFaW56ZWxwcm9qZWt0ZW4sIGRpZSAKCQlBbndlbmRlcm4sIHZvciBhbGxlbSBhdWNoIEVpbnN0ZWlnZXJuLCBkaWUgRWluZvxocnVuZyB2b24gb2ZmZW5lbiBXZXJremV1Z2VuIGVybGVpY2h0ZXJuLiBEaWUgCgkJVmVy9mZmZW50bGljaHVuZyB2b24gQ2FsbGlzdG8ga2VubnplaWNobmV0IGRhcyBkcml0dGUgSmFociBpbiBGb2xnZSwgaW4gZGVtIEVjbGlwc2UgZWluIGdyb99lbiBSZWxlYXNlIAoJCWlubmVyaGFsYiBkZXMgdm9yZ2VnZWJlbmVuIFplaXRwbGFucyBhdXNnZWxpZWZlcnQgaGF0LiBEaWUgUHJvamVrdGUgYXVzIGRlbSBDYWxsaXN0by1SZWxlYXNlIHN0ZWhlbiBhYiBkZW0gCgkJMzAuIEp1bmkgMjAwNiB6dW0gRG93bmxvYWQgdW50ZXIgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZyI+d3d3LmVjbGlwc2Uub3JnL2NhbGxpc3RvPC9hPiBiZXJlaXQuICA8L3A+CgoJCTxwPkNhbGxpc3RvIHN0ZWxsdGUgZWluIHZvbHVtaW72c2VzIFZvcmhhYmVuIGb8ciBkaWUgRWNsaXBzZS1Db21tdW5pdHkgIG1pdCAxMCB2ZXJzY2hpZWRlbmVuIFByb2pla3R0ZWFtcywgCgkJMjYwIEJldGVpbGlndGVuIHVuZCD8YmVyIDcgTWlsbGlvbmVuIENvZGV6ZWlsZW4gZGFyLiAxNSB2ZXJzY2hpZWRlbmUgdW5hYmjkbmdpZ2UgU29mdHdhcmUtQW5iaWV0ZXIgKElTVnMpIAoJCXN0ZWxsZW4gT3Blbi1Tb3VyY2UtRW50d2lja2xlciBhYiwgdW0gYW4gZGVuIGluIENhbGxpc3RvIGVudGhhbHRlbmVuIFByb2pla3RlbiB6dSBhcmJlaXRlbiB1bmQgCgkJZGVtb25zdHJpZXJ0ZW4gZGFtaXQgZGllIHZvbiB6YWhscmVpY2hlbiBBbmJpZXRlcm4gdW50ZXJzdPx0enRlICBnbG9iYWxlIE5hdHVyIGRlciBFY2xpcHNlLUNvbW11bml0eS4gCgkJRGllc2UgRW50d2lja2xlciBhcmJlaXRlbiAgaW4gMTIgdmVyc2NoaWVkZW5lbiBM5G5kZXJuIHdlbHR3ZWl0OiBLYW5hZGEsIFVTQSwgRmlubmxhbmQsIFT8cmtlaSwgQ2hpbmEsIAoJCUZyYW5rcmVpY2gsIFJ1c3NsYW5kLCBUc2NoZWNoaWVuLCBJbmRpZW4sIFNjaHdlaXosIERldXRzY2hsYW5kIHVuZCDWc3RlcnJlaWNoLiAgPC9wPgoKCQk8cD6EQ2FsbGlzdG8gdmVyZGV1dGxpY2h0LCBkYXNzIGRhcyBPcGVuLVNvdXJjZS1FbnR3aWNrbHVuZ3Ntb2RlbGwg5HXfZXJzdCBlcmZvbGdyZWljaCBlaW5lIFBsYXR0Zm9ybSBm/HIgCgkJZGllIFNvZnR3YXJlZW50d2lja2x1bmcgYmVyZWl0c3RlbGxlbiBrYW5ukywgc2FndCBNaWtlIE1pbGlua292aWNoLCBHZXNjaORmdHNm/GhyZXIgZGVyIEVjbGlwc2UgRm91bmRhdGlvbi4gCgkJhEFscyB3aXIgZGFzIENhbGxpc3RvLVJlbGVhc2UgaW0gbGV0enRlbiBKYWhyIHp1bSBlcnN0ZW4gTWFsIHN0YXJ0ZXRlbiwgc3RlbGx0ZSBkaWVzZXIgVmVyc3VjaCwgc28gdmllbGUgCgkJUHJvamVrdGUgenUga29tYmluaWVyZW4sIGVpbiBSaXNpa28gZGFyLiBIZXV0ZSBoYWJlbiBkaWUgRWNsaXBzZS1Qcm9qZWt0ZSBiZXdpZXNlbiwgZGFzcyBlaW5lIHZlcnRlaWx0ZSAKCQlDb21tdW5pdHksIGRpZSBnZW1laW5zYW0gYW4gbWVocmVyZW4gUHJvamVrdGVuIGFyYmVpdGV0IHVuZCBhbiBkZXIgemFobHJlaWNoZSBBbmJpZXRlciBiZXRlaWxpZ3Qgc2luZCwgc2VociAKCQllZmZla3RpdiAgU29mdHdhcmUgaW5uZXJoYWxiIGVpbmVzIHZvcmhlcnNlaGJhcmVuIFplaXRwbGFucyBhdXN6dWxpZWZlcm4ga2Fubi6TPC9wPgoKCQk8cD5FaW4gd2ljaHRpZ2VzIEFubGllZ2VuIHZvbiBDYWxsaXN0byBpc3QgZXMsIFVudGVybmVobWVuIHdpZSBldHdhIElTVnMgb2RlciBFbnRlcnByaXNlLUVudHdpY2tsZXJuIHp1IAoJCWVybfZnbGljaGVuLCBFY2xpcHNlIGFscyBQbGF0dGZvcm0gZvxyIGRpZSBBbndlbmR1bmdzZW50d2lja2x1bmcgZWluZmFjaGVyIHp1IGFkYXB0aWVyZW4uIERpZSBCZW51dHplciAKCQlr9m5uZW4gdm9uIGRlciBtb2R1bGFyZW4gQXJjaGl0ZWt0dXIgdm9uIEVjbGlwc2UgcHJvZml0aWVyZW4gdW5kIGb8ciBkaWUgRXJzdGVsbHVuZyBpaHJlciBBbndlbmR1bmdlbiBlaW5lIAoJCVZpZWx6YWhsIHVudGVyc2NoaWVkbGljaGVyIEVjbGlwc2UtUHJvamVrdGUgaGVyYW56aWVoZW4uIENhbGxpc3RvIHNvcmd0IGb8ciBlaW4gZWluemlnZXMgUmVsZWFzZS1FcmVpZ25pcywgCgkJZGFzIFZlcnNpb25za29tcGF0aWJpbGl05HQgdW5kIFplaXRwbORuZSBzeW5jaHJvbmlzaWVydC4gRGFzIFN5bmNocm9uLVByb2pla3QgaXN0IGplZG9jaCBuaWNodCBhbHMgCgkJZWlnZW5lcywgaW50ZWdyaWVydGVzIFdlcmt6ZXVncGFrZXQgenUgdmVyc3RlaGVuLCBzb25kZXJuIHN0ZWxsdCBlaW5lIGdsZWljaHplaXRpZ2UgVmVy9mZmZW50bGljaHVuZyAKCQl2ZXJzY2hpZWRlbmVyIFByb2pla3RlIGRhciwgZGllIGlocmUgZWlnZW5lIFBsYW51bmcgdW5kIFJvYWRtYXAgYmVpYmVoYWx0ZW4sIGRpZXNlIGplZG9jaCBtaXQgZGVuIGFuZGVyZW4gCgkJUHJvamVrdGVuIGFiZ2VzdGltbXQgaGFiZW4uIFp1IGRlbiBJU1ZzLCBkaWUgcGxhbmVuLCBQcm9qZWt0ZSBhdXMgZGVtIENhbGxpc3RvLVJlbGVhc2UgenUgbnV0emVuLCAKCQlnZWj2cmVuIHouIEIuIEFjdHVhdGUsIEF2YW50U29mdCwgQkVBLCBCb3JsYW5kLCBCdXNpbmVzcyBPYmplY3RzLCBJQk0sIElMT0csIElubm9vcHJhY3QsIEludGFsaW8sIAoJCUludGVydm9pY2UsIEtsb2N3b3JrLCBMYXR0aXgsIExvZ2ljTGlicmFyeSwgTG9tYmFyZGksIEx5bnh3b3JrcywgT3JhY2xlLCBRTlggdW5kIFNjYXBhIFRlY2hub2xvZ2llcy48L3A+CgkJCgkJPHA+Q2FsbGlzdG8gYmVpbmhhbHRldCBkZW4gZnVua3Rpb25hbGVuIEhhdXB0LVJlbGVhc2UgZGVyIGZvbGdlbmRlbiBFY2xpcHNlLVByb2pla3RlOgoJCTx1bD48YnI+CgkJCTxsaT5CdXNpbmVzcyBJbnRlbGxpZ2VuY2UgYW5kIFJlcG9ydGluZyBUb29scyAoQklSVCkgMi4xCgkJCTxsaT5DL0MrKyBJREUgKENEVCkgMy4xCgkJCTxsaT5EYXRhIFRvb2xzIFBsYXRmb3JtIChEVFApIDEuMAoJCQk8bGk+RWNsaXBzZSBNb2RlbGluZyBGcmFtZXdvcmsgKEVNRikgMi4yCgkJCTxsaT5HcmFwaGljYWwgRWRpdG9yIEZyYW1ld29yayAoR0VGKSAzLjIKCQkJPGxpPkdyYXBoaWNhbCBNb2RlbGluZyBGcmFtZXdvcmsgKEdNRikxLjAKCQkJPGxpPkVjbGlwc2UgUHJvamVjdCAzLjIKCQkJPGxpPlRlc3QgYW5kIFBlcmZvcm1hbmNlIFRvb2xzIFBsYXRmb3JtIChUUFRQKSA0LjIsIAoJCQk8bGk+V2ViIFRvb2xzIFBsYXRmb3JtIChXVFApIDEuNQoJCQk8bGk+VmlzdWFsIEVkaXRvciAoVkUpIDEuMi4KCQk8L3VsPgoJCTwvcD4KCgkJPHA+RWluaWdlIGRlciBUZWNobm9sb2dpZS1IaWdobGlnaHRzIGRlciBQcm9qZWt0LVJlbGVhc2VzIHNpbmQgdW50ZXIgYW5kZXJlbToKIAoJCQk8dWw+PGJyPgoJCQk8bGk+PHA+PHN0cm9uZz5OZXVlIFN0YW5kYWxvbmUtT1NHaS1MYXVmemVpdHVtZ2VidW5nOjwvc3Ryb25nPiBEaWUgRW50d2lja2xlciBnZW5pZd9lbiBqZXR6dCBkaWUgCgkJCUZsZXhpYmlsaXTkdCwgZGllIEVjbGlwc2UgT1NHaS1MYXVmemVpdHVtZ2VidW5nIGFscyBTdGFuZGFsb25lLUZyYW1ld29yayBudXR6ZW4genUga/ZubmVuLiBEaWUgCgkJCU9TR2ktTGF1ZnplaXR1bWdlYnVuZywgVGVpbCBkZXMgRWNsaXBzZSBFcXVpbm94LVByb2pla3RzLCBiaWxkZXQgZGllIEdydW5kbGFnZSBkZXIgRWNsaXBzZSBSaWNoIAoJCQlDbGllbnQgUGxhdGZvcm0gKFJDUCkuIEFscyBTdGFuZGFsb25lLUZyYW1ld29yayB3aXJkIHNpZSB2b24gZGVuIEVudHdpY2tsZXJuIGluIGRlbiB1bnRlcnNjaGllZGxpY2hzdGVuIAoJCQlBbndlbmR1bmdzYXJjaGl0ZWt0dXJlbiBlaW5nZXNldHp0ICwgdW50ZXIgYW5kZXJlbSBm/HIgRW1iZWRkZWQtLCBDbGllbnQtIHVuZCBTZXJ2ZXItQW53ZW5kdW5nZW4uPC9wPgoKIAkJCTxsaT48cD48c3Ryb25nPldlYiBTZXJ2aWNlcyBUb29saW5nOjwvc3Ryb25nPkFuZ2Vib3Qgdm9uIFdlcmt6ZXVnZW4sIGRpZSBkYXMgRXJzdGVsbGVuLCBkaWUgV2VpdGVyZ2FiZSAKIAkJCXVuZCBkYXMgUHJvZmlsaW5nIHZvbiBXZWJkaWVuc3RlbiB2ZXJlaW5mYWNoZW4uIE5ldWUgV2Vya3pldWdlIHdlcmRlbiBpbSBXZWIgVG9vbHMgUHJvamVjdCAoV1RQKSBzb3dpZSAKIAkJCWluIGRlciBUZXN0IGFuZCBQZXJmb3JtYW5jZSBUb29scyBQbGF0Zm9ybSAoVFBUUCkgYmVyZWl0Z2VzdGVsbHQuPC9wPgoKCQkJPGxpPjxwPjxzdHJvbmc+TmV1ZXIgUGxhdHRmb3JtLVN1cHBvcnQgZvxyIE9TWCBhdWYgSW50ZWwgdW5kIFByZXZpZXcgZvxyIFdpbmRvd3MgVmlzdGE6PC9zdHJvbmc+ICAKCQkJRWNsaXBzZSBFbnR3aWNrbGVyIGv2bm5lbiBqZXR6dCBBbndlbmR1bmdlbiBlcnN0ZWxsZW4sIGRpZSBhdWYgT1NYIGF1ZiBJbnRlbCBzb3dpZSB1bnRlciBXaW5kb3dzIFZpc3RhIAoJCQlsYXVmZW4uIDwvcD4KCiAJCQk8bGk+PHA+PHN0cm9uZz5SZWxlYXNlIDEuMCB2b24gRFRQIHVuZCBHTUY6PC9zdHJvbmc+RGllIERhdGEgVG9vbHMgUGxhdGZvcm0gKERUUCkgc3RlbGx0IGRpZSBGcmFtZXdvcmtzIAogCQkJZvxyIGRpZSBFcnN0ZWxsdW5nIGRhdGVuemVudHJpc2NoZXIgQW53ZW5kdW5nZW4gYmVyZWl0LiBEYXMgR3JhcGhpY2FsIE1vZGVsaW5nIEZyYW1ld29yayBlcmxlaWNodGV0IGRpZSAKIAkJCUVyc3RlbGx1bmcgdm9uICwgQW53ZW5kdW5nZW4gLCBkaWUgZ3JhZmlzY2hlIEVkaXRvcmVuIGJlaW5oYWx0ZW4uPC9wPgoJCQk8L3VsPgoJCQk8L3A+CgoJCTxwPkRpZSBQcm9qZWt0ZSBhdXMgZGVtIENhbGxpc3RvLVJlbGVhc2Ugc3RlaGVuIGFiIGRlbSAzMC4gSnVuaSAyMDA2IHp1bSBEb3dubG9hZCBiZXJlaXQuIFdlaXRlcmUgCgkJSW5mb3JtYXRpb25lbiBmaW5kZW4gU2llIGltIEludGVybmV0IHVudGVyIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvY2FsbGlzdG8iPnd3dy5lY2xpcHNlLm9yZy9jYWxsaXN0by4gCgkJPC9hPjwvcD4KCQkKCQkKCQk8cD48c3Ryb25nPtxiZXIgZGllIEVjbGlwc2UgRm91bmRhdGlvbjwvc3Ryb25nPjxiciAvPgoJCUVjbGlwc2UgaXN0IGVpbmUgT3BlbiBTb3VyY2UgQ29tbXVuaXR5IG1pdCBGb2t1cyBhdWYgZXJ3ZWl0ZXJiYXJlIFNvZnR3YXJlLUVudHdpY2tsdW5nc3dlcmt6ZXVnZSB1bmQgCgkJQW53ZW5kdW5nc3BsYXR0Zm9ybWVuLiBFY2xpcHNlIHN0ZWxsdCBlaW5lIGVyd2VpdGVyYmFyZSBXZXJremV1Z3BsYXR0Zm9ybSBm/HIgZGVuIGdlc2FtdGVuIExlYmVuc3p5a2x1cyAKCQlkZXIgU29mdHdhcmVlbnR3aWNrbHVuZyBiZXJlaXQgdW5kIGJpZXRldCBXZXJremV1Z2UgZvxyIE1vZGVsbGllcnVuZywgVGVzdCB1bmQgUGVyZm9ybWFuY2UsIEJ1c2luZXNzIAoJCUludGVsbGlnZW5jZSwgRW1iZWRkZWQgRW50d2lja2x1bmcsIElERXMgZvxyIEphdmEsIEMrKyB1bmQgd2VpdGVyZSBTcHJhY2hlbiwgc293aWUgV2Vya3pldWdlIHVuZCBlaW5lIAoJCVBsYXR0Zm9ybSBm/HIgUmljaCBDbGllbnQgQXBwbGlrYXRpb25lbi4gRWluIGdyb99lcyB1bmQgbGViZW5kaWdlcyDWa29zeXN0ZW0gYXVzIGJlZGV1dGVuZGVuIAoJCVRlY2hub2xvZ2llLVVudGVybmVobWVuLCBpbm5vdmF0aXZlbiBTdGFydC1VcHMsIFVuaXZlcnNpdOR0ZW4sIEZvcnNjaHVuZ3NlaW5yaWNodHVuZ2VuIHVuZCBJbmRpdmlkdWVuIAoJCWVyd2VpdGVydCwgZXJn5G56dCB1bmQgdW50ZXJzdPx0enQgZGllIEVjbGlwc2UgUGxhdHRmb3JtLiAKCQkKCQlEaWUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzdCBlaW5lIHZvbiBNaXRnbGllZGVybiAKCQlnZXRyYWdlbmUgZ2VtZWlubvx0emlnZSBPcmdhbmlzYXRpb24gbmFjaCBVUy1SZWNodCB1bmQgc3RlbGx0IGRpZSBJbmZyYXN0cnVrdHVyIHVuZCBEaWVuc3RsZWlzdHVuZ2VuIGb8ciAKCQlFY2xpcHNlIE9wZW4gU291cmNlIFByb2pla3RlIGJlcmVpdC4gQXVzZvxocmxpY2hlIEluZm9ybWF0aW9uZW4genUgRWNsaXBzZSB1bmQgZGVyIEVjbGlwc2UgRm91bmRhdGlvbiBzaW5kIAoJCXVudGVyIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmciPnd3dy5lY2xpcHNlLm9yZzwvYT4gZXJo5Gx0bGljaC4KCQk8L3A+CgkJCQkJCQkKCTwvZGl2PgoKCQkKPC9kaXY+CgoKRU9IVE1MOwoKCgkjIEdlbmVyYXRlIHRoZSB3ZWIgcGFnZQoJJEFwcC0+Z2VuZXJhdGVQYWdlKCR0aGVtZSwgJE1lbnUsICROYXYsICRwYWdlQXV0aG9yLCAkcGFnZUtleXdvcmRzLCAkcGFnZVRpdGxlLCAkaHRtbCk7Cj8+Cgo=