PGh0bWw+PGhlYWQ+DQo8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2RlZmF1bHRfc3R5bGUuY3NzIj4NCjx0aXRsZT5FY2xpcHNlIEZvdW5kYXRpb248L3RpdGxlPg0KPC9oZWFkPg0KPGJvZHkgdGV4dD0iIzAwMDAwMCIgYmdjb2xvcj0iI2ZmZmZmZiIgbGluaz0iIzAwMDBlZSIgdmxpbms9IiM1NTFhOGIiIGFsaW5rPSIjZmYwMDAwIj4NCjx0YWJsZSBib3JkZXI9MCBjZWxsc3BhY2luZz01IGNlbGxwYWRkaW5nPTIgd2lkdGg9IjEwMCUiID4NCiAgPHRyPiANCiAgICA8dGQgYWxpZ249bGVmdCB3aWR0aD0iNzIlIj4gPGZvbnQgY2xhc3M9aW5kZXh0b3A+Jm5ic3A7SlNSMjIwLU9STSA8L2ZvbnQ+PGJyPg0KICAgIDxmb250IGNsYXNzPWluZGV4c3ViPiZuYnNwOyA8L2ZvbnQ+PC90ZD4NCiAgICA8dGQgd2lkdGg9IjI4JSI+PGltZyBzcmM9Ii4uLy4uL2ltYWdlcy9JZGVhLmpwZyIgaGVpZ2h0PTg2IHdpZHRoPTEyMD48L3RkPg0KICA8L3RyPg0KPC90YWJsZT4NCjx0YWJsZSBib3JkZXI9MCBjZWxsc3BhY2luZz01IGNlbGxwYWRkaW5nPTIgd2lkdGg9IjEwMCUiID4NCiAgPHRyPiANCiAgICA8dGQgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMDA4MEMwIj48Yj48Zm9udCBjb2xvcj0iI0ZGRkZGRiIgZmFjZT0iQXJpYWwsSGVsdmV0aWNhIj5QcmVzcyByZWxlYXNlPC9mb250PjwvYj48L3RkPg0KICA8L3RyPg0KICA8dHI+IA0KICAgIDx0ZD4gDQogICAgICA8aDEgQUxJR049IkNFTlRFUiI+PGI+PHNwYW4gc3R5bGU9J2ZvbnQtc2l6ZToxNi4wcHQ7Zm9udC1mYW1pbHk6QXJpYWw7IlRpbWVzIE5ldyBSb21hbiInPjxiPiANCiAgICAgICAgPGJyPg0KICAgICAgICBFY2xpcHNlIEZvdW5kYXRpb24gYW5kIFZlcnNhbnQgQW5ub3VuY2UgQXBwcm92YWwgb2YgPGJyPg0KICAgICAgICBFY2xpcHNlIEpTUjIyMC1PUk0gUHJvamVjdCA8L2I+PC9zcGFuPjwvYj48L2gxPg0KICAgICAgPGRpdiBhbGlnbj0iY2VudGVyIj4gDQogICAgICAgIDx1bD4NCiAgICAgICAgICA8bGk+IA0KICAgICAgICAgICAgPGRpdiBhbGlnbj0ibGVmdCI+PGVtPlByb2plY3QgdG8gRGVsaXZlciBPYmplY3QtUmVsYXRpb25hbCBNYXBwaW5nIA0KICAgICAgICAgICAgICBUb29saW5nIEZyYW1ld29yayBpbiBFY2xpcHNlPC9lbT48L2Rpdj4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9kaXY+DQogICAgICA8UD48Yj5PdHRhd2EgYW5kIEZyZW1vbnQsIENhbGlmb3JuaWEsIEp1bHkgMjIsIDIwMDU8L2I+IC0gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgDQogICAgICAgIGFuIG9wZW4gc291cmNlIGNvbW11bml0eSBjb21taXR0ZWQgdG8gdGhlIGRldmVsb3BtZW50IG9mIGEgdW5pdmVyc2FsIGRldmVsb3BtZW50IA0KICAgICAgICBwbGF0Zm9ybSwgYW5kIFZlcnNhbnQgQ29ycG9yYXRpb24gKE5BU0RBUTogVlNOVCksIGFuIGluZHVzdHJ5IGxlYWRlciBpbiANCiAgICAgICAgc3BlY2lhbGl6ZWQgZGF0YSBtYW5hZ2VtZW50IGFuZCBkYXRhIHBlcnNpc3RlbmNlIHNvZnR3YXJlLCB0b2RheSBhbm5vdW5jZWQgDQogICAgICAgIHRoYXQgdGhlIEpTUjIyMC1PUk0gUHJvamVjdCBwcm9wb3NlZCBieSBWZXJzYW50IGluIE1hcmNoIG9mIHRoaXMgeWVhciANCiAgICAgICAgaGFzIGJlZW4gYXBwcm92ZWQgYnkgRWNsaXBzZS4gVGhlIEVjbGlwc2UgSlNSMjIwLU9STSBQcm9qZWN0IHdpbGwgcHJvZHVjZSANCiAgICAgICAgc3RhbmRhcmRzLWJhc2VkLCBvYmplY3QtcmVsYXRpb25hbCBtYXBwaW5nIGRlc2lnbi10aW1lIHRvb2xpbmcgaW4gRWNsaXBzZS4gDQogICAgICAgIEpTUjIyMCBpcyB0aGUgc3BlY2lmaWNhdGlvbiBkZWZpbmluZyB0aGUgc3RhbmRhcmQgZm9yIG9iamVjdC1yZWxhdGlvbmFsIA0KICAgICAgICBtYXBwaW5nIChPUk0pIGluIEphdmEuIE9iamVjdC1yZWxhdGlvbmFsIG1hcHBpbmcgaGFzIGVtZXJnZWQgaW4gdGhlIGxhc3QgDQogICAgICAgIHllYXIgYXMgYSBjcml0aWNhbCBtaXNzaW5nIHBpZWNlIG9mIHNvZnR3YXJlIGFyY2hpdGVjdHVyZSBpbiB0aGUgZHJpdmUgDQogICAgICAgIHRvIG1ha2UgdGhlIEphdmEgMiBFbnRlcnByaXNlIEVkaXRpb24gKEoyRUUpIHBsYXRmb3JtIG1vcmUgcG93ZXJmdWwgYW5kIA0KICAgICAgICBlYXNpZXIgdG8gcHJvZ3JhbS4gVGhlIEVjbGlwc2UgSlNSMjIwLU9STSBQcm9qZWN0IGlzIGRlc2lnbmVkIHRvIGJyaW5nIA0KICAgICAgICBjb21tb24gdG9vbGluZyB0byB0aGUgSmF2YSBhbmQgRWNsaXBzZSBjb21tdW5pdHkgdG8gZXhwYW5kIHByb2dyYW1taW5nIA0KICAgICAgICBwcm9kdWN0aXZpdHkgYW5kIHRoZSB2YWx1ZSBvZiBFY2xpcHNlLjwvcD4NCiAgICAgIDxQPiZxdW90O1RoZSBjcmVhdGlvbiBvZiB0aGUgSlNSMjIwLU9STSBwcm9qZWN0IGlzIGFuIGltcG9ydGFudCBtaWxlc3RvbmUgDQogICAgICAgIGZvciB0aGUgRWNsaXBzZSBjb21tdW5pdHkmcXVvdDssIHNhaWQgTWlrZSBNaWxpbmtvdmljaCwgZXhlY3V0aXZlIGRpcmVjdG9yIA0KICAgICAgICBvZiB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCBJbmMuICZxdW90O1RoaXMgcHJvamVjdCB3aWxsIHByb3ZpZGUgYSBjb21tb24gDQogICAgICAgIGZyYW1ld29yayBmb3IgZGVsaXZlcmluZyBwcm9kdWN0aXZpdHkgYW5kIGNvbnNpc3RlbmN5IGluIHRoZSBpbXBvcnRhbnQgDQogICAgICAgIGFyZWEgb2Ygb2JqZWN0LXJlbGF0aW9uYWwgbWFwcGluZy4mcXVvdDs8L3A+DQogICAgICA8cD5UaGUgZ29hbCBvZiB0aGUgSlNSMjIwLU9STSBQcm9qZWN0IGlzIHRvIHByb3ZpZGUgdmlzdWFsIGRldmVsb3BtZW50IHRvb2xzIA0KICAgICAgICB0aGF0IGZhY2lsaXRhdGUgcm91bmQtdHJpcCBlbmdpbmVlcmluZyB3aGVuIHVzaW5nIHRoZSBKU1IgMjIwIChFSkIgMy4wIA0KICAgICAgICBwZXJzaXN0ZW5jZSkgYW5kIEpTUiAyNDMgKEphdmEgRGF0YSBPYmplY3RzKSBhcHByb2FjaGVzIHRvIHBlcnNpc3RlbmNlLiANCiAgICAgICAgSXQgd2lsbCBwcm92aWRlIGFuIGltcGxlbWVudGF0aW9uIHRoYXQgaXMgZXh0ZW5zaWJsZSB0byBhY2NvbW1vZGF0ZSBvdGhlciANCiAgICAgICAgcGVyc2lzdGVuY2Ugc3RhbmRhcmRzIGFuZCBjYW4gYmUgZXh0ZW5kZWQgdG8gZ2VuZXJhdGUgYXJ0aWZhY3RzIGZvciBhbHRlcm5hdGl2ZSANCiAgICAgICAgb2JqZWN0LXJlbGF0aW9uYWwgbWFwcGluZyBydW50aW1lcy4gVGhpcyBwcm9qZWN0IGludGVybmFsbHkgdXNlcyB0aGUgRWNsaXBzZSANCiAgICAgICAgTW9kZWxpbmcgRnJhbWV3b3JrIGFuZCB0aGUgRWNsaXBzZSBEYXRhIFRvb2xzIFByb2plY3QgU2NoZW1hIE1vZGVsIGZvciANCiAgICAgICAgY29uc2lzdGVuY3kgd2l0aCB0aGUgRWNsaXBzZSBmcmFtZXdvcmssIHdoaWNoIGVhc2VzIGludGVncmF0aW9uIGFuZCBhZG9wdGlvbiANCiAgICAgICAgaW4gb3RoZXIgcHJvamVjdHMuIDwvcD4NCiAgICAgIDxwPiZxdW90O0kgYW0gcGxlYXNlZCB0aGUgSlNSMjIwLU9STSBQcm9qZWN0IGlzIHRyYW5zaXRpb25pbmcgdG8gdGhpcyBuZXcgDQogICAgICAgIHBoYXNlIGluIHRoZSBFY2xpcHNlIGRldmVsb3BtZW50IHByb2Nlc3MsJnF1b3Q7IHNhaWQgUm9iZXJ0IEdyZWVuZSwgdmljZSANCiAgICAgICAgcHJlc2lkZW50IG9mIHByb2R1Y3Qgc3RyYXRlZ3kgYXQgVmVyc2FudC4gJnF1b3Q7SXQgc29saWRpZmllcyBWZXJzYW50J3MgDQogICAgICAgIGNvbW1pdG1lbnQgdG8gdGhlIEVjbGlwc2UgY29tbXVuaXR5IGFuZCBtb3ZlcyB0aGUgRWNsaXBzZSBQbGF0Zm9ybSBvbmUgDQogICAgICAgIHN0ZXAgY2xvc2VyIHRvIHByb3ZpZGluZyBpbXBvcnRhbnQgT1JNIHRvb2xpbmcgZm9yIHRoaXMgY3JpdGljYWwgdGVjaG5vbG9neSANCiAgICAgICAgc2VnbWVudCwmcXVvdDsgR3JlZW5lIGFkZGVkLiAmcXVvdDtUaGUgbWVtYmVycyBvZiB0aGUgSlNSMjIwLU9STSBQcm9qZWN0IA0KICAgICAgICBhcmUgbG9va2luZyBmb3J3YXJkIHRvIHRoZSBmaXJzdCBtaWxlc3RvbmUgcmVsZWFzZSBpbiBlYXJseSBBdWd1c3Qgd2hlbiANCiAgICAgICAgdGhlIEVjbGlwc2UgY29tbXVuaXR5IHdpbGwgYmUgaW4gYSBwb3NpdGlvbiB0byB0YWtlIGFkdmFudGFnZSBvZiB0aGlzIA0KICAgICAgICBuZXcgdGVjaG5vbG9neSBhcHByb2FjaC4gVGhlIGZpcnN0IG1pbGVzdG9uZSB3aWxsIGRlbGl2ZXIgRm9yd2FyZCwgYW5kIA0KICAgICAgICBNZWV0LWluLXRoZS1NaWRkbGUgbWFwcGluZyBmb3IgSlNSMjIwIHJ1bnRpbWVzLiBFY2xpcHNlIGRldmVsb3BlcnMgb2YgDQogICAgICAgIEphdmEgYXBwbGljYXRpb25zIHVzaW5nIHJlbGF0aW9uYWwgZGF0YWJhc2UgdGVjaG5vbG9neSB3aWxsIGZpbmFsbHkgYmVnaW4gDQogICAgICAgIHRvIGVuam95IHRoZSBlYXNlIG9mIGRldmVsb3BtZW50IGxvbmcgcHJvbWlzZWQgaW4gdGhlIGVtZXJnaW5nIEpTUjIyMCANCiAgICAgICAgc3BlY2lmaWNhdGlvbi4mcXVvdDs8L3A+DQogICAgICA8cD5Sb2JlcnQgR3JlZW5lIGlzIHRoZSBwcm9qZWN0IGxlYWQgZm9yIHRoZSBFY2xpcHNlIEpTUjIyMC1PUk0gUHJvamVjdC4gDQogICAgICAgIFNjb3R0IEFtYmxlciwgYSBsZWFkaW5nIGF1dGhvcml0eSBvbiBvYmplY3QtcmVsYXRpb25hbCBtYXBwaW5nIGhhcyBqb2luZWQgDQogICAgICAgIHRoZSBwcm9qZWN0IGFzIGEgZGV2ZWxvcGVyIGFuZCBhcmNoaXRlY3R1cmFsIGFkdmlzb3IuIERpcmsgTGUgUm91eCwgYSANCiAgICAgICAgY29tbWl0dGVyIG9uIHRoaXMgcHJvamVjdCwgd2FzIGFsc28gYXBwcm92ZWQgYXMgYSBjb21taXR0ZXIgdG8gdGhlIEVjbGlwc2UgDQogICAgICAgIFdlYiBUb29scyBQbGF0Zm9ybSBQcm9qZWN0IGFja25vd2xlZGdpbmcgdGhpcyBwcm9qZWN0J3MgY29kZSBhbmQgYXJjaGl0ZWN0dXJhbCANCiAgICAgICAgY29udHJpYnV0aW9ucyB0byB0aGUgc2hhcmVkIGZyYW1ld29ya3MuPC9wPg0KICAgICAgPHA+JnF1b3Q7VGhlIEpTUjIyMC1PUk0gUHJvamVjdCBpcyBhbiBpbXBvcnRhbnQgbmV3IGFkZGl0aW9uIHRvIHRoZSBFY2xpcHNlIA0KICAgICAgICBUZWNobm9sb2d5IFByb2plY3QsJnF1b3Q7IHNhaWQgSm9obiBHcmFoYW0sIG9mIFN5YmFzZSwgd2hvIGlzIHRoZSBQcm9qZWN0IA0KICAgICAgICBNYW5hZ2VtZW50IENvbW1pdHRlZSBsZWFkIGZvciB0aGUgRWNsaXBzZSBEYXRhIFRvb2xzIFBsYXRmb3JtIFByb2plY3QuIA0KICAgICAgICAmcXVvdDtKU1IyMjAtT1JNIHdpbGwgaGVscCBpbnN1cmUgdGhhdCB3ZSBtZWV0IHRoZSBuZWVkcyBvZiB0aGUgY29tbXVuaXR5IA0KICAgICAgICBieSBwcm92aWRpbmcgaW1wb3J0YW50IHRvb2xzIGluIHRoZSBhcmVhIG9mIG9iamVjdC1yZWxhdGlvbmFsIG1hcHBpbmcuIA0KICAgICAgICBUbyBhaWQgaW4gdGhpcyB0YXNrLCBYaWFvIFdhbmcsIGZyb20gU3liYXNlLCBoYXMgam9pbmVkIHRoZSBwcm9qZWN0IGFzIA0KICAgICAgICBhbiBhcmNoaXRlY3QuJnF1b3Q7PC9wPg0KICAgICAgPHA+Rm9yIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gb24gdGhlIEVjbGlwc2UgSlNSMjIwLU9STSBQcm9qZWN0LCBwbGVhc2UgDQogICAgICAgIHZpc2l0IHRoZSBwcm9qZWN0IGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvcHJvcG9zYWxzL2VjbGlwc2UtanNyMjIwLW9ybS8iIHRhcmdldD0iX3RvcCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9wcm9wb3NhbHMvZWNsaXBzZS1qc3IyMjAtb3JtLzwvYT48L3A+DQogICAgICA8cD48L3A+DQogICAgPC90ZD4NCiAgPC90cj4NCjwvdGFibGU+DQoNCjx0YWJsZSB3aWR0aD0iMTAwJSIgY2VsbHNwYWNpbmc9MCBjZWxscGFkZGluZz0zIGFsaWduPWNlbnRlcj4NCgkJPHRyIGJnY29sb3I9IiM5OTk5OTkiPg0KCQkNCiAgICA8dGQgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMDA4MEMwIj48Yj48Zm9udCBjb2xvcj0iI0ZGRkZGRiIgZmFjZT0iQXJpYWwsSGVsdmV0aWNhIj5BYm91dCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uPC9mb250PjwvYj48L3RkPg0KCQk8L1RSPg0KCQk8VFI+DQoJCTx0ZCBhbGlnbj1sZWZ0Pg0KCQk8VEFCTEUgIHdpZHRoPSIxMDAlIiBDRUxMU1BBQ0lORz0wIENFTExQQURESU5HPTM+DQoJCTx0cj4NCgkJICA8dGQ+IA0KICAgICAgICAgICAgPFA+IEVjbGlwc2UgaXMgYW4gb3BlbiBzb3VyY2UgY29tbXVuaXR5IHdob3NlIHByb2plY3RzIGFyZSBmb2N1c2VkIA0KICAgICAgICAgICAgICBvbiBwcm92aWRpbmcgYW4gZXh0ZW5zaWJsZSBkZXZlbG9wbWVudCBwbGF0Zm9ybSBhbmQgYXBwbGljYXRpb24gDQogICAgICAgICAgICAgIGZyYW1ld29ya3MgZm9yIGJ1aWxkaW5nIHNvZnR3YXJlLiBFY2xpcHNlIHByb3ZpZGVzIGV4dGVuc2libGUgdG9vbHMgDQogICAgICAgICAgICAgIGFuZCBmcmFtZXdvcmtzIHRoYXQgc3BhbiB0aGUgc29mdHdhcmUgZGV2ZWxvcG1lbnQgbGlmZWN5Y2xlLCBpbmNsdWRpbmcgDQogICAgICAgICAgICAgIHN1cHBvcnQgZm9yIG1vZGVsaW5nLCBsYW5ndWFnZSBkZXZlbG9wbWVudCBlbnZpcm9ubWVudHMgZm9yIEphdmEsIA0KICAgICAgICAgICAgICBDL0MrKyBhbmQgb3RoZXJzLCB0ZXN0aW5nIGFuZCBwZXJmb3JtYW5jZSwgYnVzaW5lc3MgaW50ZWxsaWdlbmNlLCANCiAgICAgICAgICAgICAgcmljaCBjbGllbnQgYXBwbGljYXRpb25zIGFuZCBlbWJlZGRlZCBkZXZlbG9wbWVudC4gQSBsYXJnZSwgdmlicmFudCANCiAgICAgICAgICAgICAgZWNvc3lzdGVtIG9mIG1ham9yIHRlY2hub2xvZ3kgdmVuZG9ycywgaW5ub3ZhdGl2ZSBzdGFydC11cHMsIHVuaXZlcnNpdGllcyANCiAgICAgICAgICAgICAgYW5kIHJlc2VhcmNoIGluc3RpdHV0aW9ucyBhbmQgaW5kaXZpZHVhbHMgZXh0ZW5kLCBjb21wbGVtZW50IGFuZCANCiAgICAgICAgICAgICAgc3VwcG9ydCB0aGUgRWNsaXBzZSBQbGF0Zm9ybS48L3A+DQogICAgICAgICAgICA8UD4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBhIG5vdC1mb3ItcHJvZml0LCBtZW1iZXIgc3VwcG9ydGVkIGNvcnBvcmF0aW9uIHRoYXQgaG9zdHMgdGhlIEVjbGlwc2UgcHJvamVjdHMuIEZ1bGwgZGV0YWlscyBvZiBFY2xpcHNlIGFuZCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGFyZSBhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy8iIHRhcmdldD0iX3RvcCI+d3d3LmVjbGlwc2Uub3JnPC9hPiA8L3A+PC90ZD4NCgkJPC90cj4NCiAgICAgICAgPC90YWJsZT48L3RhYmxlPqANCjx0YWJsZSB3aWR0aD0iMTAwJSIgY2VsbHNwYWNpbmc9MCBjZWxscGFkZGluZz0zIGFsaWduPWNlbnRlcj4NCgkJPHRyIGJnY29sb3I9IiM5OTk5OTkiPg0KCQkNCiAgICA8dGQgYWxpZ249ImxlZnQiIHZhbGlnbj0idG9wIiBiZ2NvbG9yPSIjMDA4MEMwIj48Yj48Zm9udCBjb2xvcj0iI0ZGRkZGRiIgZmFjZT0iQXJpYWwsSGVsdmV0aWNhIj5BYm91dCANCiAgICAgIFZlcnNhbnQgQ29ycG9yYXRpb248L2ZvbnQ+PC9iPjwvdGQ+DQoJCTwvVFI+DQoJCTxUUj4NCgkJPHRkIGFsaWduPWxlZnQ+DQoJCTxUQUJMRSAgd2lkdGg9IjEwMCUiIENFTExTUEFDSU5HPTAgQ0VMTFBBRERJTkc9Mz4NCgkJPHRyPg0KCQkgIDx0ZD4gDQogICAgICAgICAgICA8UD4gVmVyc2FudCBDb3Jwb3JhdGlvbiAoTkFTREFROiBWU05UKSBpcyBhbiBpbmR1c3RyeSBsZWFkZXIgaW4gc3BlY2lhbGl6ZWQgDQogICAgICAgICAgICAgIGRhdGEgbWFuYWdlbWVudCBhbmQgb3BlbiBkYXRhIGFjY2VzcyBzb2Z0d2FyZS4gVXNpbmcgVmVyc2FudCdzIHNvbHV0aW9ucywgDQogICAgICAgICAgICAgIGN1c3RvbWVycyBjdXQgaGFyZHdhcmUgY29zdHMsIHNwZWVkIGFuZCBzaW1wbGlmeSBkZXZlbG9wbWVudCwgc2lnbmlmaWNhbnRseSANCiAgICAgICAgICAgICAgcmVkdWNlIGFkbWluaXN0cmF0aW9uIGNvc3RzLCBhbmQgZGVsaXZlciBwcm9kdWN0cyB3aXRoIGEgc3Ryb25nIA0KICAgICAgICAgICAgICBjb21wZXRpdGl2ZSBlZGdlLiBWZXJzYW50J3Mgc29sdXRpb25zIGFyZSBkZXBsb3llZCBpbiBhIHdpZGUgYXJyYXkgDQogICAgICAgICAgICAgIG9mIGluZHVzdHJpZXMgaW5jbHVkaW5nIHRlbGVjb21tdW5pY2F0aW9ucywgZmluYW5jaWFsIHNlcnZpY2VzLCANCiAgICAgICAgICAgICAgdHJhbnNwb3J0YXRpb24sIG1hbnVmYWN0dXJpbmcsIGFuZCBkZWZlbnNlLiBXaXRoIG92ZXIgNTAsMDAwIGluc3RhbGxhdGlvbnMsIA0KICAgICAgICAgICAgICBWZXJzYW50IGhhcyBiZWVuIGEgaGlnaGx5IHJlbGlhYmxlIHBhcnRuZXIgZm9yIG92ZXIgMTUgeWVhcnMgZm9yIA0KICAgICAgICAgICAgICBHbG9iYWwgMjAwMCBjb21wYW5pZXMgc3VjaCBhcyBCcml0aXNoIEFpcndheXMsIFVTIEdvdmVybm1lbnQsIEZpbmFuY2lhbCANCiAgICAgICAgICAgICAgVGltZXMsIElCTSwgYW5kIE1DSS4gRm9yIG1vcmUgaW5mb3JtYXRpb24sIGNhbGwgNTEwLTc4OS0xNTAwIG9yIA0KICAgICAgICAgICAgICB2aXNpdCA8YSBocmVmPSJodHRwOi8vd3d3LnZlcnNhbnQuY29tIiB0YXJnZXQ9Il9ibGFuayI+d3d3LnZlcnNhbnQuY29tPC9hPi48L3A+DQogICAgICAgICAgICA8L3RkPg0KCQk8L3RyPg0KICAgICAgICA8L3RhYmxlPjwvdGFibGU+oA0KCTx0YWJsZSB3aWR0aD0iMTAwJSIgY2VsbHNwYWNpbmc9MCBjZWxscGFkZGluZz0zIGFsaWduPWNlbnRlcj4NCgkJPHRyIGJnY29sb3I9IiM5OTk5OTkiPg0KICAgIDx0ZCBhbGlnbj0ibGVmdCIgdmFsaWduPSJ0b3AiIGJnY29sb3I9IiMwMDgwQzAiPjxiPjxmb250IGNvbG9yPSIjRkZGRkZGIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPk1lZGlhIA0KICAgICAgY29udGFjdHM8L2ZvbnQ+PC9iPjwvdGQ+DQoJCTwvVFI+DQo8L3RhYmxlPg0KCQkNCjx0YWJsZSB3aWR0aD0iMTAwJSIgYm9yZGVyPSIwIiBjZWxsc3BhY2luZz0iNSI+DQogIDx0cj4NCiAgICA8dGQgd2lkdGg9IjUzJSIgPiANCiAgICAgIDxkaXYgYWxpZ249ImNlbnRlciI+VmVyc2FudCBQUiBDb250YWN0Ojxicj4NCiAgICAgICAgSnVsaWUgTydHcmFkeTxicj4NCiAgICAgICAgTydHcmFkeSBDb21tdW5pY2F0aW9ucywgTExDPGJyPg0KICAgICAgICA2NTAtMjY5LTk5ODk8YnI+DQogICAgICAgIDxhIGhyZWY9Im1haWx0bzpqdWxpZUBvZ3JhZHljb21tdW5pY2F0aW9ucy5jb20iPmp1bGllQG9ncmFkeWNvbW11bmljYXRpb25zLmNvbTwvYT48L2Rpdj4NCiAgICA8L3RkPg0KICAgIDx0ZCB3aWR0aD0iNDclIiA+IA0KICAgICAgPGRpdiBhbGlnbj0iY2VudGVyIj4gDQogICAgICAgIDxwPkNoYW50YWwgWWFuZyBmb3IgRWNsaXBzZTxicj4NCiAgICAgICAgICBTY2h3YXJ0eiBDb21tdW5pY2F0aW9uczxicj4NCiAgICAgICAgICA3ODEtNjg0LTA3NzA8YnI+DQogICAgICAgICAgPGEgaHJlZj0ibWFpbHRvOmVjbGlwc2VAc2Nod2FydHotcHIuY29tIj5lY2xpcHNlQHNjaHdhcnR6LXByLmNvbTwvYT48YnI+DQogICAgICAgIDwvcD4NCiAgICAgICAgPC9kaXY+DQogICAgPC90ZD4NCiAgPC90cj4NCjwvdGFibGU+DQoJCTxUQUJMRSAgd2lkdGg9IjEwMCUiIENFTExTUEFDSU5HPTAgQ0VMTFBBRERJTkc9Mz4NCgkJPHRyPg0KCQkgIDx0ZD4gDQogICAgICAgICAgICA8aHIgd2lkdGg9Ijg1JSI+DQogICAgICA8UD5CcmFuZCBvciBwcm9kdWN0IG5hbWVzIGFyZSByZWdpc3RlcmVkIHRyYWRlbWFya3Mgb3IgdHJhZGVtYXJrcyBvZiB0aGVpciANCiAgICAgICAgcmVzcGVjdGl2ZSBob2xkZXJzLiBFY2xpcHNlIGlzIGEgdHJhZGVtYXJrIG9mIEVjbGlwc2UgRm91bmRhdGlvbiBJbmMuIEphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3MgDQogICAgICAgIG9yIHJlZ2lzdGVyZWQgdHJhZGVtYXJrcyBvZiBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIGluIHRoZSBVbml0ZWQgU3RhdGVzIA0KICAgICAgICBhbmQgb3RoZXIgY291bnRyaWVzLjxicj4NCiAgICAgIDwvUD4NCjxociB3aWR0aD0iODUlIj4NCiAgICAgIDxwPkZvcndhcmQgTG9va2luZyBTdGF0ZW1lbnRzIEludm9sdmUgUmlza3MgYW5kIFVuY2VydGFpbnRpZXMgPC9wPg0KICAgICAgPHA+VGhpcyBwcmVzcyByZWxlYXNlIGNvbnRhaW5zIGZvcndhcmQtbG9va2luZyBzdGF0ZW1lbnRzIHdpdGhpbiB0aGUgbWVhbmluZyANCiAgICAgICAgb2YgU2VjdGlvbiAyN0Egb2YgdGhlIFNlY3VyaXRpZXMgQWN0IG9mIDE5MzMgYW5kIFNlY3Rpb24gMjFFIG9mIHRoZSBTZWN1cml0aWVzIA0KICAgICAgICBFeGNoYW5nZSBBY3Qgb2YgMTkzNCwgYW5kIGlzIHN1YmplY3QgdG8gdGhlIHNhZmUgaGFyYm9yIGNyZWF0ZWQgYnkgdGhvc2UgDQogICAgICAgIHNlY3Rpb25zLiBUaGVzZSBmb3J3YXJkLWxvb2tpbmcgc3RhdGVtZW50cyBpbmNsdWRlLCBidXQgYXJlIG5vdCBsaW1pdGVkIA0KICAgICAgICB0bywgc3RhdGVtZW50cyBhYm91dCBWZXJzYW50J3MgaW52b2x2ZW1lbnQgaW4gdGhlIEVjbGlwc2UgY29tbXVuaXR5LCBpdHMgDQogICAgICAgIG9wZW4gc291cmNlIGluaXRpYXRpdmVzLCBhbmQgdGhlIHBvdGVudGlhbCBvdXRjb21lcyBvZiB0aGVzZSBhY3Rpdml0aWVzLiANCiAgICAgICAgSW52ZXN0b3JzIGFyZSBjYXV0aW9uZWQgdGhhdCBhbnkgc3VjaCBmb3J3YXJkLWxvb2tpbmcgc3RhdGVtZW50cyBhcmUgbm90IA0KICAgICAgICBndWFyYW50ZWVzIG9mIGZ1dHVyZSBwZXJmb3JtYW5jZSwgdGhlc2UgZm9yd2FyZC1sb29raW5nIHN0YXRlbWVudHMgaW52b2x2ZSANCiAgICAgICAgcmlza3MgYW5kIHVuY2VydGFpbnRpZXMsIGFuZCB0aGVyZSBhcmUgaW1wb3J0YW50IGZhY3RvcnMgdGhhdCBjb3VsZCBjYXVzZSANCiAgICAgICAgb3VyIGFjdHVhbCByZXN1bHRzIHRvIGRpZmZlciBtYXRlcmlhbGx5IGZyb20gdGhvc2UgaW4gdGhlIGZvcndhcmQtbG9va2luZyANCiAgICAgICAgc3RhdGVtZW50cy4gVGhlc2UgZmFjdG9ycyBpbmNsdWRlLCB3aXRob3V0IGxpbWl0YXRpb246IHRoYXQgVmVyc2FudCBtYXkgDQogICAgICAgIG5vdCBhY2hpZXZlIG9yIG1haW50YWluIHRoZSBsZWFkZXJzaGlwIHJvbGUgb2YgdGhpcyBFY2xpcHNlIHByb2plY3Q7IHRoYXQgDQogICAgICAgIGFueSBzdWNoIHBvc2l0aW9uIG9idGFpbmVkIG1heSBub3QgcmVtYWluIGludGFjdCBpbiB0aGUgZnV0dXJlOyB0aGF0IG9iamVjdC1yZWxhdGlvbmFsIA0KICAgICAgICBtYXBwaW5nIG1heSBub3QgYmUgYSBjcml0aWNhbCBtaXNzaW5nIGFyY2hpdGVjdHVyYWwgY29tcG9uZW50OyB0aGUgcG9zc2liaWxpdHkgDQogICAgICAgIHRoYXQgdGhlcmUgbWF5IGJlIHNoaWZ0IHdpdGggSmF2YSBwcm9ncmFtbWVycyBhd2F5IGZyb20gb2JqZWN0LXJlbGF0aW9uYWwgDQogICAgICAgIG1hcHBpbmc7IHRoZSBwb3NzaWJpbGl0eSB0aGF0IEVjbGlwc2UgYW5kIG9wZW4gc291cmNlIHNvZnR3YXJlIG1heSBsb3NlIA0KICAgICAgICBpdHMgZ3Jvd2luZyBwb3B1bGFyaXR5IGluIHRoZSBKYXZhIGNvbW11bml0eTsgdGhhdCBhZG9wdGlvbiByYXRlcyBmb3IgDQogICAgICAgIHRoaXMgdGVjaG5vbG9neSBtYXkgbm90IGNvbnRpbnVlIGludG8gdGhlIGZ1dHVyZTsgdGhlIHBvc3NpYmlsaXR5IG9mIGRlbGF5cyANCiAgICAgICAgaW4gcmVsZWFzZSBvZiB0aGUgcHJvZHVjdDsgdGhhdCBwcm9kdWN0IHJlZmluZW1lbnRzIG1heSBiZSBuZWNlc3NhcnksIA0KICAgICAgICBpbmNsdWRpbmcgdGhlIHBvc3NpYmlsaXRpZXMgb2YgaW5oZXJlbnQgYnVncyBhbmQgZXJyb3JzOyB0aGF0IHVzZXJzIG1heSANCiAgICAgICAgbm90IHJlYWxpemUgdGhlIGFudGljaXBhdGVkIHJlc3VsdHMgYW5kIGV4cGVyaWVuY2UgdW5mb3Jlc2VlbiBwcm9ibGVtczsgDQogICAgICAgIGFsb25nIHdpdGggdGhlIHBvc3NpYmlsaXR5IHRoYXQgdGhlcmUgbWF5IG5vdCBiZSBhIGRyYW1hdGljIGV4cGFuc2lvbiANCiAgICAgICAgb2YgVmVyc2FudCdzIHZpc2liaWxpdHkgaW50byB0aGUgSmF2YSBjb21tdW5pdHkgYW5kIGEgY29ycmVzcG9uZGluZyBpbmNyZWFzZSANCiAgICAgICAgaW4gZGlyZWN0IGludGVyYWN0aW9uIHdpdGggSmF2YSBjb21tdW5pdHkgZGV2ZWxvcGVycy4gVGhlIGZvcndhcmQtbG9va2luZyANCiAgICAgICAgc3RhdGVtZW50cyBpbmNsdWRlZCBpbiB0aGlzIHByZXNzIHJlbGVhc2UgYXJlIG1hZGUgb25seSBhcyBvZiB0aGUgZGF0ZSANCiAgICAgICAgb2YgdGhpcyBwcmVzcyByZWxlYXNlOyB0aGUgQ29tcGFueSBhc3N1bWVzIG5vIG9ibGlnYXRpb24gdG8gcHVibGljbHkgdXBkYXRlIA0KICAgICAgICBhbnkgZm9yd2FyZC1sb29raW5nIHN0YXRlbWVudC4gSW52ZXN0b3JzIGFyZSBjYXV0aW9uZWQgbm90IHRvIHBsYWNlIHVuZHVlIA0KICAgICAgICByZWxpYW5jZSBvbiBmb3J3YXJkLWxvb2tpbmcgc3RhdGVtZW50cy4gQWRkaXRpb25hbCBpbmZvcm1hdGlvbiBjb25jZXJuaW5nIA0KICAgICAgICBmYWN0b3JzIHRoYXQgY291bGQgY2F1c2UgcmVzdWx0cyB0byBkaWZmZXIgY2FuIGJlIGZvdW5kIGluIHRoZSBDb21wYW55J3MgDQogICAgICAgIGZpbGluZ3Mgd2l0aCB0aGUgU2VjdXJpdGllcyBhbmQgRXhjaGFuZ2UgQ29tbWlzc2lvbiwgaW5jbHVkaW5nIHRoZSBDb21wYW55J3MgDQogICAgICAgIG1vc3QgcmVjZW50IFJlcG9ydHMgb24gRm9ybSAxMC1LIGFuZCBGb3JtIDEwLVEgbWFkZSB3aXRoIHRoZSBTZWN1cml0aWVzIA0KICAgICAgICBhbmQgRXhjaGFuZ2UgQ29tbWlzc2lvbi48L3A+DQogICAgICA8cD5WZXJzYW50IGlzIGEgcmVnaXN0ZXJlZCB0cmFkZW1hcmsgb3IgdHJhZGVtYXJrIG9mIFZlcnNhbnQgQ29ycG9yYXRpb24gDQogICAgICAgIGluIHRoZSBVbml0ZWQgU3RhdGVzIGFuZC9vciBvdGhlciBjb3VudHJpZXMuIEFsbCBvdGhlciBwcm9kdWN0cyBhcmUgYSANCiAgICAgICAgcmVnaXN0ZXJlZCB0cmFkZW1hcmsgb3IgdHJhZGVtYXJrIG9mIHRoZWlyIHJlc3BlY3RpdmUgY29tcGFueSBpbiB0aGUgVW5pdGVkIA0KICAgICAgICBTdGF0ZXMgYW5kL29yIG90aGVyIGNvdW50cmllcy4gPGJyPg0KICAgICAgPC9wPg0KICAgICAgPGhyIHdpZHRoPSI4NSUiPg0KICAgICAgPHA+Jm5ic3A7IDwvcD4NCiAgICA8L3RkPg0KCQk8L3RyPg0KICAgICAgICA8L3RhYmxlPqAgICAgICAgIA0KoA0KPC9ib2R5PjwvaHRtbD4NCg==