PD9waHAgIAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL2FwcC5jbGFzcy5waHAiKTsJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbmF2LmNsYXNzLnBocCIpOyAJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbWVudS5jbGFzcy5waHAiKTsgCSRBcHAgCT0gbmV3IEFwcCgpOwkkTmF2CT0gbmV3IE5hdigpOwkkTWVudSAJPSBuZXcgTWVudSgpOwkJaW5jbHVkZSgkQXBwLT5nZXRQcm9qZWN0Q29tbW9uKCkpOyAgICAjIEFsbCBvbiB0aGUgc2FtZSBsaW5lIHRvIHVuY2x1dHRlciB0aGUgdXNlcidzIGRlc2t0b3AnCgokcGFnZVRpdGxlIAkJPSAiIjsKJHBhZ2VLZXl3b3Jkcwk9ICIiOwokcGFnZUF1dGhvcgkJPSAiIjsKCm9iX3N0YXJ0KCk7Cj8+CiAgICA8ZGl2IGlkPSJtYWluY29udGVudCI+Cgk8ZGl2IGlkPSJtaWRjb2x1bW4iPgoKPGgxPkVjbGlwc2UgTW9kZWwtdG8tTW9kZWwgVHJhbnNmb3JtYXRpb24gKE0yTSkgUHJvamVjdCBQcm9wb3NhbDwvaDE+CjwvcD4KPD9waHAKaW5jbHVkZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL3Byb2plY3RzL2ZyYWdtZW50cy9wcm9wb3NhbC1wYWdlLWhlYWRlci5waHAiKTsKZ2VuZXJhdGVfaGVhZGVyKCJNb2RlbC10by1Nb2RlbCBUcmFuc2Zvcm1hdGlvbiIpOwo/PgoKPHA+UHJvcG9zYWwgVXBkYXRlZDogMzAgT2N0b2JlciAyMDA2PC9wPgoKPGgyPkludHJvZHVjdGlvbjwvaDI+Cgo8cD4KCVRoZSBNb2RlbC10by1Nb2RlbCBUcmFuc2Zvcm1hdGlvbiAoTTJNKSBQcm9qZWN0IGlzIGEgcHJvcG9zZWQgb3BlbiBzb3VyY2UgcHJvamVjdCB1bmRlciB0aGUgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9tb2RlbGluZy8iPkVjbGlwc2UgTW9kZWxpbmcgUHJvamVjdDwvYT4uCjwvcD4KCjxwPgoJVGhpcyBwcm9wb3NhbCBpcyBpbiB0aGUgUHJvamVjdCBQcmUtUHJvcG9zYWwgUGhhc2UgKGFzIGRlZmluZWQgaW4gdGhlIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvcHJvamVjdHMvZGV2X3Byb2Nlc3MvIj5FY2xpcHNlIERldmVsb3BtZW50IFByb2Nlc3M8L2E+IGRvY3VtZW50KSBhbmQgaXMgd3JpdHRlbiB0byBkZWNsYXJlIGl0cyBpbnRlbnQgYW5kIHNjb3BlLiBUaGlzIHByb3Bvc2FsIGlzIHdyaXR0ZW4gdG8gc29saWNpdCBhZGRpdGlvbmFsIHBhcnRpY2lwYXRpb24gYW5kIGlucHV0IGZyb20gdGhlIEVjbGlwc2UgY29tbXVuaXR5LiBZb3UgYXJlIGludml0ZWQgdG8gY29tbWVudCBhbmQvb3Igam9pbiB0aGUgcHJvamVjdC4gUGxlYXNlIHNlbmQgYWxsIGZlZWRiYWNrIHRvIHRoZSA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL25ld3Nwb3J0YWwvdGhyZWFkLnBocD9ncm91cD1lY2xpcHNlLm1vZGVsaW5nLm0ybSI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9uZXdzcG9ydGFsL3RocmVhZC5waHA/Z3JvdXA9ZWNsaXBzZS5tb2RlbGluZy5tMm08L2E+IG5ld3Nncm91cC4KPC9wPgoKPHA+CglUaGlzIHByb3Bvc2FsIGZvY3VzZXMgb24gbW9kZWwtdG8tbW9kZWwgdHJhbnNmb3JtYXRpb24sIHdoaWxlIG1vZGVsLXRvLXRleHQgdHJhbnNmb3JtYXRpb24gKE0yVCkgaXMgY292ZXJlZCBieSB0aGUgTTJUIHByb2plY3QgcHJvcG9zYWwuCjwvcD4KCjxoMj5CYWNrZ3JvdW5kPC9oMj4KCjxwPgoJTW9kZWwtdG8tbW9kZWwgdHJhbnNmb3JtYXRpb24gaXMgYSBrZXkgYXNwZWN0IG9mIG1vZGVsLWRyaXZlbiBkZXZlbG9wbWVudCAoTUREKS6gIFRoZXJlIGFyZSBtYW55IGV4aXN0aW5nIHRlY2hub2xvZ2llcyBmb3IgbW9kZWwtdG8tbW9kZWwgdHJhbnNmb3JtYXRpb24sIGluY2x1ZGluZyBpbXBsZW1lbnRhdGlvbnMgZm91bmQgd2l0aGluIHRoZSBFY2xpcHNlIE1vZGVsaW5nIFByb2plY3QsIHN1Y2ggYXMgdGhlIEFUTCBjb21wb25lbnQgb2YgdGhlIEdNVCBwcm9qZWN0LqAgCjwvcD4KCjxwPgoJTW9kZWwtdG8tbW9kZWwgdHJhbnNmb3JtYXRpb25zIGFyZSBiZWluZyBzdGFuZGFyZGl6ZWQgYnkgdGhlIE9NRyBpbiB0aGUgTU9GIFF1ZXJ5LCBWaWV3LCBUcmFuc2Zvcm1hdGlvbiBzdGFuZGFyZC4gVGhpcyBzdGFuZGFyZCByZWFjaGVkIHRoZSBmaW5hbCBhZG9wdGVkIHN0YXRlIGFuZCBpcyBiZWluZyBmaW5hbGl6ZWQuIEJlY2F1c2UgdGhlIHN1cHBvcnQgb2YgbW9kZWxpbmcgc3RhbmRhcmRzIGlzIGFuIGVsZW1lbnQgb2YgdGhlIEVjbGlwc2UgTW9kZWxpbmcgUHJvamVjdCBjaGFydGVyLCB0aGUgUVZUIHN0YW5kYXJkIGlzIGludGVncmFsIHBhcnQgb2YgdGhpcyBwcm9qZWN0Lgo8L3A+Cgo8aDM+QVRMPC9oMz4KCjxwPgoJQVRMIChBdGxhcyBUcmFuc2Zvcm1hdGlvbiBMYW5ndWFnZSkgaXMgY3VycmVudGx5IGEgY29tcG9uZW50IG9mIHRoZSA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2dtdC8iPkdNVCBwcm9qZWN0PC9hPi4gQVRMIGlzIGEgaHlicmlkIGxhbmd1YWdlIChhIG1peCBvZiBkZWNsYXJhdGl2ZSBhbmQgaW1wZXJhdGl2ZSBjb25zdHJ1Y3Rpb25zKSBkZXNpZ25lZCB0byBleHByZXNzIG1vZGVsIHRyYW5zZm9ybWF0aW9ucy4gQVRMIGlzIGRlc2NyaWJlZCBieSBhbiBhYnN0cmFjdCBzeW50YXggKGEgTU9GIG1ldGEtbW9kZWwpLCBhbmQgYSB0ZXh0dWFsIGNvbmNyZXRlIHN5bnRheC4gQSB0cmFuc2Zvcm1hdGlvbiBtb2RlbCBpbiBBVEwgaXMgZXhwcmVzc2VkIGFzIGEgc2V0IG9mIHRyYW5zZm9ybWF0aW9uIHJ1bGVzLiBUaGUgcmVjb21tZW5kZWQgc3R5bGUgb2YgcHJvZ3JhbW1pbmcgaXMgZGVjbGFyYXRpdmUuIAo8L3A+Cgo8cD4KCUFuIGluaXRpYWwgbGlicmFyeSBvZiBBVEwgdHJhbnNmb3JtYXRpb25zIGlzIGF2YWlsYWJsZSBhdDogPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9nbXQvYXRsL2F0bFRyYW5zZm9ybWF0aW9ucy8iPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvZ210L2F0bC9hdGxUcmFuc2Zvcm1hdGlvbnMvPC9hPi4gCkFueSB1c2VyIGlzIHdlbGNvbWUgdG8gY29udHJpYnV0ZSB0byB0aGlzIGxpYnJhcnkgYXMgb3BlbiBzb3VyY2UgdW5kZXIgdGhlIEVQTCBMaWNlbnNlLiBUaGUgZG9jdW1lbnRhdGlvbiBvbiBBVEwgaXMgYXZhaWxhYmxlIGZyb206IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvZ210L2F0bC9kb2MvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2dtdC9hdGwvZG9jLzwvYT4uIEFkZGl0aW9uYWwgaW5mb3JtYXRpb24gbWF5IGFsc28gYmUgZm91bmQgYXQ6IDxhIGhyZWY9Imh0dHA6Ly93d3cuc2NpZW5jZXMudW5pdi1uYW50ZXMuZnIvbGluYS9hdGwvIj5odHRwOi8vd3d3LnNjaWVuY2VzLnVuaXYtbmFudGVzLmZyL2xpbmEvYXRsLzwvYT4uIEFUTCBpcyBhIFFWVC1saWtlIGxhbmd1YWdlIGJ1dCBpcyBub3QsIGluIHRoZSBwcmVzZW50IHN0YXRlLCAxMDAlIGNvbXBhdGlibGUgd2l0aCB0aGUgMTIgbGV2ZWxzIG9mIGNvbXBsaWFuY2Ugc3RhdGVkIGluIHRoZSBPTUcgZG9jdW1lbnQuIEEgY29tcGFyYXRpdmUgZGVzY3JpcHRpb24gb2YgQVRMIGFuZCBRVlQgbWF5IGJlIGZvdW5kIGF0OiA8YSBocmVmPSJodHRwOi8vd3d3LnNjaWVuY2VzLnVuaXYtbmFudGVzLmZyL2xpbmEvYXRsL2JpYmxpb2dyYXBoeS9TQUMwNmEiPmh0dHA6Ly93d3cuc2NpZW5jZXMudW5pdi1uYW50ZXMuZnIvbGluYS9hdGwvYmlibGlvZ3JhcGh5L1NBQzA2YTwvYT4uCjwvcD4KCjxwPgpDdXJyZW50bHkgdGhlIG1haW4gQVRMIG1haWxpbmcgbGlzdCBpcyBydW5uaW5nIHVuZGVyIFlhaG9vIGdyb3VwczogPGEgaHJlZj0iaHR0cDovL3RlY2guZ3JvdXBzLnlhaG9vLmNvbS9ncm91cC9hdGxfZGlzY3Vzc2lvbi8iPmh0dHA6Ly90ZWNoLmdyb3Vwcy55YWhvby5jb20vZ3JvdXAvYXRsX2Rpc2N1c3Npb24vPC9hPi4gSG93ZXZlciwgYXMgc29vbiBhcyB0aGUgTTJNIHByb2plY3QgaXMgYWN0aXZlLCB0aGlzIGxpc3Qgd2lsbCBtaWdyYXRlIHRvIGFuIEVjbGlwc2UgbGlzdC4KPC9wPgoKPHA+CkFUTCBpcyBiYXNlZCBvbiBhIHRyYW5zZm9ybWF0aW9uIHZpcnR1YWwgbWFjaGluZS4gSXRzIGFyY2hpdGVjdHVyZSBpcyB2ZXJ5IG1vZHVsYXIgc28gdGhhdCBpdCBjYW4gZXZvbHZlIGJ5IGFkZGluZyBuZXcgZnVuY3Rpb25hbGl0aWVzIG9yIGJ1aWxkaW5nIGluIGltcHJvdmVkIHBlcmZvcm1hbmNlLiBUaGUgY29tcGxldGUgY29kZSBvZiB0aGUgdmlydHVhbCBtYWNoaW5lIGlzIGF2YWlsYWJsZS4gVGhlIGRvY3VtZW50YXRpb24gb2YgdGhlIGNvbnRyb2wgbWFjaGluZSAoZGVzY3JpcHRpb24gb2YgYnl0ZWNvZGVzKSB3aWxsIGFsc28gYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIE0yTSBwcm9qZWN0LiBBbHNvIGF2YWlsYWJsZSBpcyB0aGUgY29tcGxldGUgZGV2ZWxvcG1lbnQgZW52aXJvbm1lbnQuCjwvcD4KCjxwPgoJSXQgaXMgYW50aWNpcGF0ZWQgdGhhdCBzZXZlcmFsIGJyaWRnZXMgbWF5IGJlIGVzdGFibGlzaGVkIGJldHdlZW4gQVRMIGFuZCB2YXJpb3VzIG90aGVyIHRyYW5zZm9ybWF0aW9uIGxhbmd1YWdlcy4KPC9wPgoKPGgzPlFWVDwvaDM+Cgo8cD4KCVFWVCBhZGRyZXNzZXMgdGhlIG5lZWQgZm9yIHN0YW5kYXJkaXppbmcgdGhlIHdheSB0cmFuc2Zvcm1hdGlvbnMgYXJlIGFjaGlldmVkIGJldHdlZW4gbW9kZWxzIHdob3NlIGxhbmd1YWdlcyBhcmUgZGVmaW5lZCB1c2luZyBNT0YuoEluIGFkZGl0aW9uLCBRVlQgb2ZmZXJzIGEgc3RhbmRhcmQgd2F5IG9mIHF1ZXJ5aW5nIE1PRiBtb2RlbHMsIGFuZCBjcmVhdGluZyB2aWV3cyBvbnRvIHRoZXNlIG1vZGVscy4gVGhpcyBpcyBzaW1pbGFyIHRvIHRoZSBuZWVkIGZvciBYU0xUIGZvciBYTUwsIHdoZXJlIGFuIFhTTFQgc2NyaXB0IGRlZmluZXMgdGhlIG1hcHBpbmcgYmV0d2VlbiBhIHBhaXIgb2YgRFREcyBhbmQgZGljdGF0ZXMgaG93IFhNTHMgKGNvbXBsaWFudCB3aXRoIHRoZSBEVERzKSBhcmUgdHJhbnNmb3JtZWQuCjwvcD4KCjxwPgoJUXVlcmllcyBvbiBNT0YgbW9kZWxzIGFyZSByZXF1aXJlZCBib3RoIHRvIGZpbHRlciBhbmQgc2VsZWN0IGVsZW1lbnRzIGZyb20gYSBtb2RlbCBvbiBhbiBhZC1ob2MgYmFzaXMsIGFzIHdlbGwgYXMgdG8gc2VsZWN0IGVsZW1lbnRzIHRoYXQgYXJlIHRoZSBzb3VyY2VzIGZvciB0cmFuc2Zvcm1hdGlvbnMuIFRoaXMgaXMgc2ltaWxhciB0byB0aGUgbmVlZCBmb3IgWHBhdGggd2l0aGluIFhTTFQuCjwvcD4KCjxwPgoJVGhlIFFWVCBzcGVjaWZpY2F0aW9uIGRlZmluZXMgdGhyZWUgbGFuZ3VhZ2VzLCB0d28gZGVjbGFyYXRpdmUgYW5kIG9uZSBpbXBlcmF0aXZlOgoJPHVsPgoJCTxsaT4KCQkJUmVsYXRpb25zOiBBIHVzZXItZnJpZW5kbHkgUmVsYXRpb25zIG1ldGEgbW9kZWwgYW5kIGxhbmd1YWdlIHdoaWNoIHN1cHBvcnRzIGNvbXBsZXggb2JqZWN0IHBhdHRlcm4gbWF0Y2hpbmcgYW5kIG9iamVjdCB0ZW1wbGF0ZSBjcmVhdGlvbi4gVHJhY2VzIGJldHdlZW4gbW9kZWwgZWxlbWVudHMgaW52b2x2ZWQgaW4gYSB0cmFuc2Zvcm1hdGlvbiBhcmUgY3JlYXRlZCBpbXBsaWNpdGx5LgoJCTwvbGk+CgkJPGxpPgoJCQlDb3JlOiBBIENvcmUgbWV0YSBtb2RlbCBhbmQgbGFuZ3VhZ2UgZGVmaW5lZCB1c2luZyBtaW5pbWFsIGV4dGVuc2lvbnMgdG8gRU1PRiBhbmQgT0NMLiBBbGwgdHJhY2UgY2xhc3NlcyBhcmUgZXhwbGljaXRseSBkZWZpbmVkIGFzIE1PRiBtb2RlbHMsIGFuZCB0cmFjZSBpbnN0YW5jZSBjcmVhdGlvbiBhbmQgZGVsZXRpb24gaXMgZGVmaW5lZCBpbiB0aGUgc2FtZSB3YXkgYXMgdGhlIGNyZWF0aW9uIGFuZCBkZWxldGlvbiBvZiBhbnkgb3RoZXIgb2JqZWN0LgoJCTwvbGk+CgkJPGxpPgoJCQlPcGVyYXRpb25hbDogYW4gaW1wZXJhdGl2ZSBsYW5ndWFnZS4KCQk8L2xpPgoJPC91bD4KPC9wPgoKPGgyPkRlc2NyaXB0aW9uPC9oMj4KCjxwPgoJVGhlIE0yTSBwcm9qZWN0IHdpbGwgZGVsaXZlciBhIGZyYW1ld29yayBmb3IgbW9kZWwtdG8tbW9kZWwgdHJhbnNmb3JtYXRpb24gbGFuZ3VhZ2VzLqBUaGUgY29yZSBwYXJ0IGlzIHRoZSB0cmFuc2Zvcm1hdGlvbiBpbmZ0cmFzdHJ1Y3R1cmUuIFRyYW5zZm9ybWF0aW9ucyBhcmUgZXhlY3V0ZWQgYnkgdHJhbnNmb3JtYXRpb24gZW5naW5lcyB0aGF0IGFyZSBwbHVnZ2VkIGludG8gdGhlIGluZnJhc3RydWN0dXJlLiBUaGVyZSBhcmUgdGhyZWUgdHJhbnNmb3JtYXRpb24gZW5naW5lcyB0aGF0IGFyZSBkZXZlbG9wZWQgaW4gdGhlIHNjb3BlIG9mIHRoaXMgcHJvamVjdC4gRWFjaCBvZiB0aGUgdGhyZWUgcmVwcmVzZW50cyBhIGRpZmZlcmVudCBjYXRlZ29yeSwgd2hpY2ggdmFsaWRhdGVzIHRoZSBmdW5jdGlvbmFsaXR5IG9mIHRoZSBpbmZyYXN0cnVjdHVyZSBmcm9tIG11bHRpcGxlIGNvbnRleHRzLgo8L3A+Cgo8cD4KCVRoZSB0aHJlZSBhcmU6Cgk8b2w+CgkJPGxpPgoJCQlBVEwKCQk8L2xpPgoJCTxsaT4KCQkJUHJvY2VkdXJhbCBRVlQgKE9wZXJhdGlvbmFsKQoJCTwvbGk+CgkJPGxpPgoJCQlEZWNsYXJhdGl2ZSBRVlQgKENvcmUgYW5kIFJlbGF0aW9uYWwpCgkJPC9saT4KCTwvb2w+CjwvcD4KCjxwPgoJQW4gZXhlbXBsYXJ5IGltcGxlbWVudGF0aW9uIHdpbGwgYmUgZm9yIHRoZSBRVlQgQ29yZSBsYW5ndWFnZSwgdXNpbmcgRU1GIGFzIGltcGxlbWVudGF0aW9uIG9mIEVzc2VudGlhbCBNT0YgYW5kIHRoZSBPQ0wgaW1wbGVtZW50YXRpb24gZnJvbSB0aGUgT0NMIHN1YnByb2plY3QuoCBUaGUgbWFpbiBkZWxpdmVyYWJsZSBmb3IgdGhpcyBwYXJ0IG9mIHRoZSBwcm9qZWN0IHdpbGwgYmUgYW4gZXhlY3V0aW9uIGVuZ2luZSB0aGF0IHN1cHBvcnRzIHRyYW5zZm9ybWF0aW9ucy6gIFRoZSBlbmdpbmUgd2lsbCBleGVjdXRlIHRoZSBDb3JlIGxhbmd1YWdlIGluIGVpdGhlciBpbnRlcnByZXRlZCBvciBjb21waWxlZCBmb3JtLgo8L3A+Cgo8cD4KCUZvbGxvd2luZyBDb3JlLCB0aGUgTTJNIHByb2plY3Qgd2lsbCBwcm92aWRlIGFuIGltcGxlbWVudGF0aW9uIG9mIHRoZSBRVlQgUmVsYXRpb25zIGxhbmd1YWdlLCBiYXNlZCBvbiB0aGUgUVZUIENvcmUgZXhlY3V0aW9uIGVuZ2luZSwgRU1GIGFuZCBPQ0wuoCBGb3IgYm90aCBsYW5ndWFnZXMgZnVsbCBsYW5ndWFnZSBzdXBwb3J0IHdpbGwgYmUgZGVsaXZlcmVkLgo8L3A+Cgo8cD4KCUNvbmNyZXRlIGV4YW1wbGVzIHdpbGwgYmUgZGV2ZWxvcGVkIGFzIHBhcnQgb2YgdGhlIHByb2plY3QuoCBUaGUgQVRMIHByb2plY3QgYWxyZWFkeSBoYXMgYSBwdWJsaXNoZWQgc2V0IG9mIGV4YW1wbGUgdHJhbnNmb3JtYXRpb25zLCB3aGljaCB3aWxsIGJlIGNvbXBsZW1lbnRlZCBieSBhIHNldCBvZiBRVlQgdHJhbnNmb3JtYXRpb24gZGVmaW5pdGlvbnMuCjwvcD4KCjxwPgoJRm9sbG93LW9uIGRldmVsb3BtZW50IHBoYXNlcyB3aWxsIGFjY29tbW9kYXRlIGNvbW11bml0eSBmZWVkYmFjayBhbmQgdGhlIGtub3dsZWRnZSBnYWluZWQgZHVyaW5nIHRoZSBpbml0aWFsIGRldmVsb3BtZW50IHBoYXNlLgo8L3A+Cgo8aDI+T3JnYW5pemF0aW9uPC9oMj4KCjxwPgoJV2UgcHJvcG9zZSB0aGF0IHRoaXMgcHJvamVjdCBiZSB1bmRlcnRha2VuIGFzIHBhcnQgb2YgdGhlIEVjbGlwc2UgTW9kZWxpbmcgUHJvamVjdC4gSXQgdXNlcyBFTUYgYW5kIE9DTCBhbmQgcHJvdmlkZXMgY2FwYWJpbGl0aWVzIGZvciBRdWVyeWluZywgVmlld2luZyBhbmQgVHJhbnNmb3JtaW5nIEVNRiBtb2RlbHMuoCBUaGUgcHJvamVjdCB3aWxsIGluaXRpYWxseSBiZSBjb21wcmlzZWQgb2YgaW5mcmFzdHJ1Y3R1cmUsIEFUTCwgcHJvY2VkdXJhbCBRVlQgYW5kIGRlY2xhcmF0aXZlIFFWVCBjb21wb25lbnRzLgo8L3A+Cgo8aDM+SW5pdGlhbCBjb250cmlidXRpb25zPC9oMz4KCjxwPgoJVGhlIEFUTCBjb21wb25lbnQgd2lsbCBtaWdyYXRlIHRvIE0yTSBmcm9tIEdNVCwgd2hlcmWgaW5mb3JtYXRpb24gb24gQVRMIGNhbiBiZSBmb3VuZCBhcyBjYW4gYSBsaXN0IG9mIHRyYW5zZm9ybWF0aW9uIGRlZmluaXRpb25zIGZvciBjb21tb24gZG9tYWluIG1vZGVscy4KPC9wPgoKPHA+CglCb3JsYW5kJ3MgVG9nZXRoZXIgQXJjaGl0ZWN0IG1vZGVsaW5nIHByb2R1Y3QgaGFzIGFuIGltcGxlbWVudGF0aW9uIG9mIFFWVCB3aGljaCBpcyBiZWluZyByZXZpZXdlZCBmb3IgY29udHJpYnV0aW9uLqAgQSBjdXJyZW50IGRlcGVuZGVuY3kgb24gdGhlIEtlbnQgT0NMIGxpYnJhcnkgd2lsbCBuZWVkIHRvIGJlIHByb2Nlc3NlZCBmb3IgdGhpcmQgcGFydHkgaW5jbHVzaW9uLCBhbmQgd2lsbCB1bHRpbWF0ZWx5IGJlIHJlcGxhY2VkIGJ5IHRoZSBNRFQgT0NMIGltcGxlbWVudGF0aW9uLgo8L3A+Cgo8aDM+SW5pdGlhbCBjb21taXR0ZXJzPC9oMz4KCjxwPgoJVGhlIGZvbGxvd2luZyBjb21wYW5pZXMgd2lsbCBjb250cmlidXRlIGNvbW1pdHRlcnMgdG8gZ2V0IHRoZSBwcm9qZWN0IHN0YXJ0ZWQ6Cgk8dWw+CgkJPGxpPgoJCQlJTlJJQSAtIEFUTCBjb21wb25lbnQKCQkJPHVsPgoJCQkJPGxpPgoJCQkJCUZy6WTpcmljIEpvdWF1bHQgKHByb3Bvc2VkIHByb2plY3QgbGVhZCkKCQkJCTwvbGk+CgkJCQk8bGk+CgkJCQkJRnJlZGR5IEFsbGlsYWlyZSAKCQkJCTwvbGk+CgkJCTwvdWw+CgkJPC9saT4KCQk8bGk+CgkJCUJvcmxhbmQgKDxhIGhyZWY9Imh0dHA6Ly93d3cuYm9ybGFuZC5jb20vIj53d3cuYm9ybGFuZC5jb208L2E+KQoJCQk8dWw+CgkJCQk8bGk+CgkJCQkJUmFkZWsgRHZvcmFrIChwcm9jZWR1cmFsIFFWVCBjb21wb25lbnQgbGVhZCkKCQkJCTwvbGk+CgkJCQk8bGk+CgkJCQkJQWxla3NhbmRyIElnZGFsb3YgCgkJCQk8L2xpPgoJCQkJPGxpPgoJCQkJCVNlcmdleSBCb3lrbyAKCQkJCTxsaT4KCQkJPC91bD4KCQk8L2xpPgoJCTxsaT4KCQkJQ29tcHV3YXJlICg8YSBocmVmPSJodHRwOi8vd3d3LmNvbXB1d2FyZS5jb20vIj53d3cuY29tcHV3YXJlLmNvbTwvYT4pCgkJCTx1bD4KCQkJCTxsaT4KCQkJCQlQZXRlciBCcmFrZXIgKEluZnJhc3RydWN0dXJlIGFuZCBkZWNsYXJhdGl2ZSBRVlQgY29tcG9uZW50IGxlYWQpCgkJCQk8L2xpPgoJCQkJPGxpPgoJCQkJCVdpbSBCYXN0IAoJCQkJPC9saT4KCQkJCTxsaT4KCQkJCQlSb25hbGQgS3JpamdzaGVsZCAKCQkJCTwvbGk+CgkJCTwvdWw+CgkJPC9saT4KCTwvdWw+CjwvcD4KCjxoMz5JbnRlcmVzdGVkIHBhcnRpZXM8L2gzPgoKPHA+CglUaGUgZm9sbG93aW5nIGNvbXBhbmllcy9pbmRpdmlkdWFscyBoYXZlIGV4cHJlc3NlZCBpbnRlcmVzdCBpbiB0aGUgcHJvamVjdDoKCTx1bD4KCQk8bGk+CgkJCUlCTSA8YSBocmVmPSJodHRwOi8vd3d3LmlibS5jb20vIj53d3cuaWJtLmNvbTwvYT4KCQk8L2xpPgoJCTxsaT4KCQkJVW5pc3lzIDxhIGhyZWY9Imh0dHA6Ly93d3cudW5pc3lzLmNvbS8iPnd3dy51bmlzeXMuY29tPC9hPgoJCTwvbGk+CgkJPGxpPgoJCQlGcmFuY2UgVGVsZWNvbSA8YSBocmVmPSJodHRwOi8vd3d3LmZyYW5jZXRlbGVjb20uY29tLyI+d3d3LmZyYW5jZXRlbGVjb20uY29tPC9hPgoJCTwvbGk+CgkJPGxpPgoJCQlTb2Z0d2FyZSBFbmdpbmVlcmluZywgVW5pdmVyc2l0eSBvZiBUd2VudGUsIHRoZSBOZXRoZXJsYW5kcyA8YSBocmVmPSJodHRwOi8vdHJlc2UuY3MudXR3ZW50ZS5ubC8iPnRyZXNlLmNzLnV0d2VudGUubmw8L2E+CgkJPC9saT4KCQk8bGk+CgkJCVNvZnR3YXJlIENvbXBvc2l0aW9uIGFuZCBNb2RlbGluZyBMYWJvcmF0b3J5LCBVbml2ZXJzaXR5IG9mIEFsYWJhbWEgYXQgQmlybWluZ2hhbSA8YSBocmVmPSJodHRwOi8vd3d3LmNpcy51YWIuZWR1L3NvZnRjb20iPnd3dy5jaXMudWFiLmVkdS9zb2Z0Y29tPC9hPgoJCTwvbGk+CgkJPGxpPgoJCQlHaW92YW5uaSBUb3N0byAKCQk8L2xpPgoJPC91bD4KPC9wPgoKPGgzPlBhcnRpY2lwYXRpb248L2gzPgoKPHA+CglDcml0aWNhbCB0byB0aGUgc3VjY2VzcyBvZiB0aGlzIHByb2plY3QgaXMgcGFydGljaXBhdGlvbiBvZiBkZXZlbG9wZXJzIGluIHRoZSBtb2RlbGluZyBhcHBsaWNhdGlvbiBkZXZlbG9wbWVudCBjb21tdW5pdHkuIFdlIGludGVuZCB0byByZWFjaCBvdXQgdG8gdGhpcyBjb21tdW5pdHkgYW5kIGVubGlzdCB0aGUgc3VwcG9ydCBvZiB0aG9zZSBpbnRlcmVzdGVkIGluIG1ha2luZyBhIHN1Y2Nlc3Mgb2YgdGhlIE1vZGVsLXRvLU1vZGVsIFRyYW5zZm9ybWF0aW9uIHByb2plY3QuIFdlIGFsc28gYW50aWNpcGF0ZSB0aGF0IHNldmVyYWwgaW5kdXN0cnkgdmVydGljYWxzIHdpbGwgaGF2ZSBhbiBpbnRlcmVzdCBpbiBNMk0sIGFuZCB3aWxsIHRoZXJlZm9yZSBjb250YWN0IHRoZXNlIGNvbXBhbmllcyBhbmQgYXNzb2NpYXRlZCBzdGFuZGFyZCBvcmdhbml6YXRpb25zLiBPdGhlcndpc2UsIHdlIGFzayBpbnRlcmVzdGVkIHBhcnRpZXMgdG8gY29udGFjdCB0aGUgTTJNIG5ld3Nncm91cCB0byBleHByZXNzIGludGVyZXN0IGluIGNvbnRyaWJ1dGluZyB0byB0aGUgcHJvamVjdC4KPC9wPgoKICAgICAgPC9kaXY+CiAgPC9kaXY+Cjw/cGhwCgkkaHRtbCA9IG9iX2dldF9jb250ZW50cygpOwoJb2JfZW5kX2NsZWFuKCk7CgoJIyBHZW5lcmF0ZSB0aGUgd2ViIHBhZ2UKCSRBcHAtPmdlbmVyYXRlUGFnZSgkdGhlbWUsICRNZW51LCAkTmF2LCAkcGFnZUF1dGhvciwgJHBhZ2VLZXl3b3JkcywgJHBhZ2VUaXRsZSwgJGh0bWwpOwo/Pgo=