PD9waHAKCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9hcHAuY2xhc3MucGhwIik7CXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL25hdi5jbGFzcy5waHAiKTsgCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL21lbnUuY2xhc3MucGhwIik7IAkkQXBwIAk9IG5ldyBBcHAoKTsJJE5hdgk9IG5ldyBOYXYoKTsJJE1lbnUgCT0gbmV3IE1lbnUoKTsJCWluY2x1ZGUoIl9wcm9qZWN0Q29tbW9uLnBocCIpOyAgICAjIEFsbCBvbiB0aGUgc2FtZSBsaW5lIHRvIHVuY2x1dHRlciB0aGUgdXNlcidzIGRlc2t0b3AnCgoJCgkjCgkjIEJlZ2luOiBwYWdlLXNwZWNpZmljIHNldHRpbmdzLiAgQ2hhbmdlIHRoZXNlLiAKCSRwYWdlVGl0bGUgCQk9ICJFY2xpcHNlQ29uIDIwMTIgR29sZCBTcG9uc29ycyBBbm5vdW5jZWQiOwoJJHBhZ2VLZXl3b3Jkcwk9ICAiZWNsaXBzZSwgZm91bmRhdGlvbiwgZWNsaXBzZWNvbiwgZ29sZCBzcG9uc29ycywgZWNsaXBzZSBjb25mZXJlbmNlLCBhZ2lsZSBhbG0iOwoJJHBhZ2VBdXRob3IJCT0gIkNocmlzdG9waGVyIEd1aW5kb24iOwoJCgkjIEFkZCBwYWdlLXNwZWNpZmljIE5hdiBiYXJzIGhlcmUKCSMgRm9ybWF0IGlzIExpbmsgdGV4dCwgbGluayBVUkwgKGNhbiBiZSBodHRwOi8vd3d3LnNvbWVvdGhlcnNpdGUuY29tLyksIHRhcmdldCAoX3NlbGYsIF9ibGFuaykKCSMgJE5hdi0+YWRkQ3VzdG9tTmF2KCJNeSBMaW5rIiwgIm15cGFnZS5waHAiLCAiX3NlbGYiKTsKCSMgJE5hdi0+YWRkQ3VzdG9tTmF2KCJHb29nbGUiLCAiaHR0cDovL3d3dy5nb29nbGUuY29tLyIsICJfYmxhbmsiKTsKCgkjIEVuZDogcGFnZS1zcGVjaWZpYyBzZXR0aW5ncwoJIwoJCgkjIFBhc3RlIHlvdXIgSFRNTCBjb250ZW50IGJldHdlZW4gdGhlIEVPSFRNTCBtYXJrZXJzIQkKCSRodG1sID0gPDw8RU9IVE1MCgk8c3R5bGU+CgkJLnBhZGRlZGxpc3QgbGkgewlwYWRkaW5nLWJvdHRvbTo3cHg7CX0KCTwvc3R5bGU+CgkKPGRpdiBpZD0ibWFpbmNvbnRlbnQiPgoJPGRpdiBpZD0ibWlkY29sdW1uIj4KCQoJCTxoMT4kcGFnZVRpdGxlPC9oMT4KPGJyLz4KCTxwPjxzdHJvbmc+T3R0YXdhLCBDYW5hZGEgliBKYW51YXJ5LCAyNSwgMjAxMjwvc3Ryb25nPiCWIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgcGxlYXNlZCB0byBhbm5vdW5jZSB0aGUgR29sZCBzcG9uc29ycyBmb3IgdGhlIHVwY29taW5nIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAxMiIgdGFyZ2V0PSJfYmxhbmsiPkVjbGlwc2VDb24gMjAxMjwvYT4gY29uZmVyZW5jZSBpbiBSZXN0b24sIFZpcmdpbmlhIG9uIE1hcmNoIDI2LTI5LCAyMDEyLiAgIEFjdHVhdGUsIElCTSwgT3JhY2xlLCBSZWQgSGF0IGFuZCBTQVAgaGF2ZSBhbGwgYWdyZWVkIHRvIGJlIHRoZSBwcmVtaWVyIHNwb25zb3JzIG9mIHRoZSBhbm51YWwgRWNsaXBzZSBjb21tdW5pdHkgZXZlbnQuPC9wPgoKPHA+k1dlIGFyZSB0aHJpbGxlZCB0byBoYXZlIEFjdHVhdGUsIElCTSwgT3JhY2xlLCBSZWQgSGF0IGFuZCBTQVAgYmUgR29sZCBzcG9uc29ycyBmb3IgRWNsaXBzZUNvbiyUIGV4cGxhaW5zIE1pa2UgTWlsaW5rb3ZpY2gsIEV4ZWN1dGl2ZSBEaXJlY3RvciBvZiB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLiAgk1RoZSBjb21wYW5pZXMgYXJlIGxlYWRlcnMgaW4gdGhlIEVjbGlwc2UgY29tbXVuaXR5IGFuZCB3ZSB3ZWxjb21lIHRoZWlyIG9uZ29pbmcgc3VwcG9ydC6UPC9wPgoKPHA+RWNsaXBzZUNvbiAyMDEyIGlzIGEgNCBkYXkgdGVjaG5pY2FsIGNvbmZlcmVuY2UgZmVhdHVyaW5nIDEyMCBzZXNzaW9uIGFuZCAxNiB0dXRvcmlhbHMuICBUaGlzIHllYXIgdGhlIGNvbmZlcmVuY2UgZmVhdHVyZXMgdHJhY2tzIG9uIERvbWFpbiBTcGVjaWZpYyBMYW5ndWFnZXMsIE1vZGVsaW5nLCBFY2xpcHNlUlQsIEVjbGlwc2UgNCwgTW9iaWxlIGFuZCBFbWJlZGRlZCBEZXZlbG9wbWVudC4gICBBIG5ldyBjby1sb2NhdGVkIGNvbmZlcmVuY2UsIEFnaWxlIEFMTSBDb25uZWN0LCBoYXMgYmVlbiBhZGRlZCB0byB0aGUgcHJvZ3JhbSB3aGljaCB3aWxsIGZvY3VzIG9uIHRoZSB0b29scyBhbmQgcHJhY3RpY2VzIGFjcm9zcyB0aGUgZW50aXJlIHNvZnR3YXJlIGRldmVsb3BtZW50IGxpZmVjeWNsZS48L3A+ICAgCgo8cD5SZWdpc3RyYXRpb24gZm9yIEVjbGlwc2VDb24gYW5kIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAxMi9hZ2lsZWFsbSIgdGFyZ2V0PSJfYmxhbmsiPkFnaWxlIEFMTSBDb25uZWN0PC9hPiBpcyBub3cgb3Blbi4gICBQZW9wbGUgdGhhdCByZWdpc3RlciBieSBGZWJydWFyeSAxNCwgMjAxMiByZWNlaXZlIGFuIGVhcmx5IHJlZ2lzdHJhdGlvbiBkaXNjb3VudC4gIFNwb25zb3JzaGlwIG9wcG9ydHVuaXRpZXMgYXJlIGFsc28gc3RpbGwgYXZhaWxhYmxlIGZvciBjb21wYW5pZXMgdG8gc3BvdGxpZ2h0IHRoZWlyIHByb2R1Y3RzIHRvIHRoZSBFY2xpcHNlIGFuZCBBZ2lsZSBBTE0gY29tbXVuaXR5LiA8L3A+CgoKPHA+PHN0cm9uZz5BYm91dCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uPC9zdHJvbmc+PGJyLz4KRWNsaXBzZSBpcyBhbiBvcGVuIHNvdXJjZSBjb21tdW5pdHksIHdob3NlIHByb2plY3RzIGFyZSBmb2N1c2VkIG9uIGJ1aWxkaW5nIGFuIG9wZW4gZGV2ZWxvcG1lbnQgcGxhdGZvcm0gY29tcHJpc2VkIG9mIGV4dGVuc2libGUgZnJhbWV3b3JrcywgdG9vbHMgYW5kIHJ1bnRpbWVzIGZvciBidWlsZGluZywgZGVwbG95aW5nIGFuZCBtYW5hZ2luZyBzb2Z0d2FyZSBhY3Jvc3MgdGhlIGxpZmVjeWNsZS4gQSBsYXJnZSwgdmlicmFudCBlY29zeXN0ZW0gb2YgbWFqb3IgdGVjaG5vbG9neSB2ZW5kb3JzLCBpbm5vdmF0aXZlIHN0YXJ0LXVwcywgdW5pdmVyc2l0aWVzIGFuZCByZXNlYXJjaCBpbnN0aXR1dGlvbnMgYW5kIGluZGl2aWR1YWxzIGV4dGVuZCwgY29tcGxlbWVudCBhbmQgc3VwcG9ydCB0aGUgRWNsaXBzZSBQbGF0Zm9ybS48L3A+Cgo8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGEgbm90LWZvci1wcm9maXQsIG1lbWJlciBzdXBwb3J0ZWQgY29ycG9yYXRpb24gdGhhdCBob3N0cyB0aGUgRWNsaXBzZSBwcm9qZWN0cy4gRnVsbCBkZXRhaWxzIG9mIEVjbGlwc2UgYW5kIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gYXJlIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyIgdGFyZ2V0PSJfYmxhbmsiPnd3dy5lY2xpcHNlLm9yZzwvYT4uPC9wPgoKPHA+QWxsIGNvbXBhbnkvcHJvZHVjdCBuYW1lcyBhbmQgc2VydmljZSBtYXJrcyBtYXkgYmUgdHJhZGVtYXJrcyBvciByZWdpc3RlcmVkIHRyYWRlbWFya3Mgb2YgdGhlaXIgcmVzcGVjdGl2ZSBjb21wYW5pZXMuPC9wPgoJCQoKICAKCgk8L2Rpdj4KCgoJPGRpdiBpZD0icmlnaHRjb2x1bW4iPgoJCTxkaXYgY2xhc3M9InNpZGVpdGVtIj4KCQkJPGg2PlJlbGF0ZWQgTGlua3M8L2g2PgoJCQk8dWw+CgkJCQk8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDEyIiB0YXJnZXQ9Il9ibGFuayI+RWNsaXBzZUNvbiAyMDEyPC9hPjwvbGk+CgkJCTwvdWw+CgkJPC9kaXY+Cgk8L2Rpdj4JCgo8L2Rpdj4KIAoKRU9IVE1MOwoJJGh0bWwgPSBtYl9jb252ZXJ0X2VuY29kaW5nKCRodG1sLCAiSFRNTC1FTlRJVElFUyIsICJJU08tODg1OS0xIik7CgkkcGFnZVRpdGxlID0gbWJfY29udmVydF9lbmNvZGluZygkcGFnZVRpdGxlLCAiSFRNTC1FTlRJVElFUyIsICJJU08tODg1OS0xIik7CgkjIEdlbmVyYXRlIHRoZSB3ZWIgcGFnZQoJJEFwcC0+Z2VuZXJhdGVQYWdlKCR0aGVtZSwgJE1lbnUsICROYXYsICRwYWdlQXV0aG9yLCAkcGFnZUtleXdvcmRzLCAkcGFnZVRpdGxlLCAkaHRtbCk7Cj8+CgoKCg==