ZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvRUNMSVBTRV9XRUIucGRmIGIvc3BlY2lhbF9wcm9ncmFtcy9FQ0xJUFNFX1dFQi5wZGYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYxMzk2YzcuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9FQ0xJUFNFX1dFQi5wZGYKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9zcGVjaWFsX3Byb2dyYW1zL2N1c3RvbS1kZWxpdmVyeS1pbnN0YWxsZXItcHJvZ3JhbS5waHAgYi9zcGVjaWFsX3Byb2dyYW1zL2N1c3RvbS1kZWxpdmVyeS1pbnN0YWxsZXItcHJvZ3JhbS5waHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQ2N2Q5NDYuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9jdXN0b20tZGVsaXZlcnktaW5zdGFsbGVyLXByb2dyYW0ucGhwCisrKyAvZGV2L251bGwKQEAgLTEsMTA4ICswLDAgQEAKLTw/cGhwICAJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9hcHAuY2xhc3MucGhwIik7CXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL25hdi5jbGFzcy5waHAiKTsgCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL21lbnUuY2xhc3MucGhwIik7IAkkQXBwIAk9IG5ldyBBcHAoKTsJJE5hdgk9IG5ldyBOYXYoKTsJJE1lbnUgCT0gbmV3IE1lbnUoKTsJCWluY2x1ZGUoIi4uL19wcm9qZWN0Q29tbW9uLnBocCIpOyAgICAjIEFsbCBvbiB0aGUgc2FtZSBsaW5lIHRvIHVuY2x1dHRlciB0aGUgdXNlcidzIGRlc2t0b3AnDQotDQotJHBhZ2VUaXRsZSAJCT0gIkVjbGlwc2UgU3RyYXRlZ2ljIE1lbWJlciBDdXN0b20gRGVsaXZlcnkgSW5zdGFsbGVyIFByb2dyYW0iOw0KLSRwYWdlS2V5d29yZHMJPSAiIjsNCi0kcGFnZUF1dGhvcgkJPSAiIjsNCi0NCi1vYl9zdGFydCgpOw0KLT8+DQotPHN0eWxlIHR5cGU9InRleHQvY3NzIj4NCi1oMiB7DQotYm9yZGVyLWJvdHRvbTogc29saWQNCi19DQotaDMgew0KLWJvcmRlci1ib3R0b206IHRoaW4gZG90dGVkDQotfQ0KLTwvc3R5bGU+DQotDQotICAgIDxkaXYgaWQ9Im1haW5jb250ZW50Ij4NCi0JPGRpdiBpZD0ibWlkY29sdW1uIj4NCi0gICAgICAgIDxoMT48YmlnPkVjbGlwc2UgU3RyYXRlZ2ljIE1lbWJlciBDdXN0b20gRGVsaXZlcnkgSW5zdGFsbGVyIFByb2dyYW08L2JpZz48L2gxPg0KLSAgICAgICAgICANCi0gICAgICAgIDxoMj48Yj48YmlnPkdvYWxzIG9mIHRoaXMgUHJvZ3JhbTwvYmlnPjwvYj48L2gyPg0KLSAgICAgICAgPHA+VGhpcyBwcm9ncmFtIGhhcyB0aHJlZSBtYWluIGdvYWxzOjwvcD4NCi0gICAgICAgIA0KLSAgICAgICAgPG9sPg0KLSAgICAgICAgICAgPGxpPkltcHJvdmUgdGhlIGRvd25sb2FkIGV4cGVyaWVuY2UgZm9yIHVzZXJzLDwvbGk+DQotICAgICAgICAgICA8bGk+SW5jcmVhc2UgdGhlIHZpc2liaWxpdHkgb2YgcHJvamVjdHMsIGVzcGVjaWFsbHkgdGhvc2UgdGhhdCBhcmUgbm90ICJ0aGUgSmF2YSBJREUiIGJ5IHdoaWNoIEVjbGlwc2UgaXMgbW9zdGx5IGtub3duLDwvbGk+DQotICAgICAgICAgICA8bGk+SW5jcmVhc2UgdGhlIHZhbHVlIG9mIHN0cmF0ZWdpYyBtZW1iZXJzaGlwLjwvbGk+DQotICAgICAgICAgIA0KLSAgICAgICAgPC9vbD4NCi0NCi08aDI+UHJvZ3JhbTwvaDI+DQotPHA+T3ZlciB0aGUgbmV4dCBzZXZlcmFsIG1vbnRocyB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHdpbGwgYmUgb2ZmZXJpbmcgdmlzaXRvcnMgdG8gRWNsaXBzZS5vcmcgdGhlIGFiaWxpdHkNCi10byBkb3dubG9hZCBhbmQgaW5zdGFsbCBFY2xpcHNlIHVzaW5nIFdpemFyZCBsYXVuY2hlZCBmcm9tIHRoZSBlY2xpcHNlLm9yZy9kb3dubG9hZHMgcGFnZS4gIFRoaXMgd2lsbA0KLWluaXRpYWxseSBiZSBvZmZlcmVkIHRvIGEgc21hbGwgYXVkaWVuY2UgKHN1Y2ggYXMgIkZyaWVuZCBvZiBFY2xpcHNlIikgYW5kIG92ZXIgdGltZSBvZmZlcmVkIHRvIA0KLWEgYnJvYWRlciBhdWRpZW5jZS4gIFRoZSB3aXphcmQgYWxsb3dzIHRoZSB1c2VyIHRvIA0KLXNlbGVjdCB0aGUgRWNsaXBzZSBwcm9qZWN0cyB0aGV5IHdhbnQgdG8gZG93bmxvYWQgYW5kIGluc3RhbGwuIFVzZXJzIHdpbGwgDQotc3RhcnQgKGZpcnN0IHdpemFyZCBwYWdlKSBieSBzZWxlY3Rpbmcgb25lIGEgc21hbGwgbnVtYmVyIG9mIHN0YW5kYXJkIHBhY2thZ2VzLiBUaGUgc21hbGwgbnVtYmVyIG9mIHN1YnNlcXVlbnQgd2l6YXJkIA0KLXBhZ2VzIHdpbGwgc3RlcCB0aGUgdXNlciB0aHJvdWdoIGNob29zaW5nIGFkZGl0aW9uYWwgZmVhdHVyZXMvcGx1Zy1pbnMgZnJvbSBFY2xpcHNlIHByb2plY3RzIChhbHNvLCB0aGUgdXNlciBjYW4gcmVtb3ZlIA0KLXByZS1zZWxlY3RlZCBkZWZhdWx0IGZlYXR1cmVzIGFkZGVkIGJ5IHRoZSBpbml0aWFsIHBhY2thZ2UgaGUgb3Igc2hlIHNlbGVjdGVkKS4gDQotPC9wPg0KLQ0KLTxwPlRoZSBmaW5hbCB3aXphcmQgcGFnZSB3aWxsIHNob3cgYSBsaXN0IG9mIA0KLXBhcnRpY2lwYXRpbmcgc3RyYXRlZ2ljIG1lbWJlcnMgYXMgd2VsbCBhcyBhICJkb3dubG9hZC1ub3ctd2l0aC1uby1mdXJ0aGVyLWZlYXR1cmVzIiBidXR0b24uIFRoZSBzdHJhdGVnaWMgbWVtYmVycyANCi13aWxsIGJlIGxpc3RlZCBpbiB0aGUgd2l6YXJkIHdpdGggYSBzbWFsbCBjb21wYW55IGxvZ28vaWNvbiBhbmQgYnJpZWYgdGV4dCBleHBsYWluaW5nIHdoYXQgYWRkaXRpb25hbA0KLXNvZnR3YXJlIGlzIGF2YWlsYWJsZSB2aWEgdGhlIFN0cmF0ZWdpYyBNZW1iZXIuPC9wPg0KLQ0KLQ0KLTxwPklmIHRoZSB1c2VyIGNvbnRpbnVlcyB0byBzdHJhdGVnaWMgQ29tcGFueSBYLCB0aGUgd2l6YXJkIHdpbGwgc2VuZCB0aGUgdXNlcidzIHNlbGVjdGlvbnMgdG8gdGhlIG1lbWJlcidzIHdpemFyZCANCi11cmwgKGFzIHNwZWNpZmllZCBieSB0aGUgbWVtYmVyKSBpbiBhIHByZS1kZWZpbmVkIGRhdGEgcGF5bG9hZC4gVGhlIG1lbWJlciB3aWxsIHRoZW4gY29udGludWUgdGhlIHdpemFyZCBhbGxvd2luZyANCi10aGUgdXNlciB0byBhZGQgYWRkaXRpb25hbCBmZWF0dXJlcy9wbHVnLWlucyBmcm9tIHRoZWlyIGxpYnJhcnkuIEF0IHRoZSBlbmQgb2YgdGhlIHdpemFyZCwgdGhlIHVzZXIgDQotcHJlc3NlcyB0aGUgIkRvd25sb2FkIGFuZCBpbnN0YWxsIiBidXR0b24gdG8gZG93bmxvYWQgYW5kIGluc3RhbGwgdGhlIGNvbXBsZXRlIHNldCBvZiBFY2xpcHNlIHByb2plY3RzIChmcm9tIHRoZSANCi1FY2xpcHNlIEZvdW5kYXRpb24ncyB3aXphcmQpIGFuZCB0aGUgbWVtYmVyJ3MgZmVhdHVyZXMvcGx1Zy1pbnMgKGZyb20gdGhlIHRoZWlyIFggd2l6YXJkIGNvbnRpbnVhdGlvbikuIFdlIGV4cGxpY2l0bHkgDQotYWxsb3cgcGFydGljaXBhdGluZyBzdHJhdGVnaWMgbWVtYmVycyB0byBpbmNsdWRlIGJvdGggZnJlZS13YXJlLCB0cmlhbC13YXJlLCBhbmQgcGF5LXdhcmUgZmVhdHVyZXMgYW5kIHBsdWctaW5zIA0KLWluIHRoZSB3aXphcmQsIGkuZS4sIHRoZXJlIGlzIG5vIHJlcXVpcmVtZW50IHRoYXQgdGhlIG1lbWJlcidzIHdpemFyZCBpbmNsdWRlIG9ubHkgb3BlbiBzb3VyY2Ugb3IgZnJlZSBzb2Z0d2FyZS48L3A+DQotDQotPHA+U3RyYXRlZ2ljIE1lbWJlcnMgd2hvIHBhcnRpY2lwYXRlIGluIHRoZSBwcm9ncmFtIGNhbiBleHBlY3QgdG8gc2lnbiBhbiBhZGRpdGlvbmFsIGxlZ2FsIGZvcm0gYWdyZWVpbmcgdGhhdCB0aGUgRm91bmRhdGlvbiANCi1jYW4gZGlzcGxheSB0aGVpciBsb2dvIGFuZC9vciBjb21wYW55IG5hbWUgaW4gdGhlIHdpemFyZC48L3A+DQotDQotDQotPGgzPlBhcnRpY2lwYXRpb248L2gzPgkJDQotPHA+VGhpcyBpcyBhIHRvb2wgc3VwcGxpZWQgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBhbmQgdGh1cyB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHN0YWZmIGFyZSByZXNwb25zaWJsZSBmb3IgY2hvb3NpbmcgDQotdGhlIHRlY2hub2xvZ3kgYmVoaW5kIHRoZSB3aXphcmQgYXMgd2VsbCBhcyB0aGUgaW5pdGlhbCBwYWNrYWdlIG5hbWVzIGFuZCBjb250ZW50IGFuZCB0aGUgc3Vic2VxdWVudCBwYWdlcyBhbmQgd2hpY2ggcHJvamVjdHMgDQotYXJlIGluY2x1ZGVkIG9uIGVhY2ggcGFnZS4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzdGFmZiB3aWxsIHJlcXVlc3QgYWR2aWNlIG9uIHRoZXNlIGRlY2lzaW9ucyBmcm9tIHRoZSBQTUNzIGFuZCBwcm9qZWN0IGxlYWRzLCANCi1idXQgdGhlIGZpbmFsIGRlY2lzaW9ucyBhcmUgdGhvc2Ugb2YgdGhlIEV4ZWN1dGl2ZSBEaXJlY3Rvci48L3A+DQotDQotPHA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBwcm92aWRlcyBkaWZmZXJlbnQgcHJvZ3JhbXMgZm9yIGRpZmZlcmVudCBsZXZlbHMgb2YgbWVtYmVyc2hpcC4gIFRoZSBlY2xpcHNlLm9yZyBkb3dubG9hZHMgcGFnZSBpcyANCi1hIHZhbHVhYmxlIHN0cmF0ZWdpYyBhc3NldCBvZiB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGFuZCB0aHVzIHBhcnRpY2lwYXRpb24gaW4gdGhpcyBwcm9ncmFtIGlzIGxpbWl0ZWQgdG8gU3RyYXRlZ2ljIE1lbWJlcnMgDQotb2YgdGhlIEVjbGlwc2UgRm91bmRhdGlvbi4gPC9wPg0KLQ0KLTxwPlN0cmF0ZWdpYyBNZW1iZXJzIGFyZSBlbGlnaWJsZSB0byBwYXJ0aWNpcGF0ZSBhcyBzb29uIGFzIHRoZXkgYXJlIHZhbGlkIG1lbWJlcnMgYW5kIGFyZSByZW1vdmVkIGZyb20gdGhlIA0KLXByb2dyYW0gYXMgc29vbiBhcyB0aGV5IGFyZSBubyBsb25nZXIgc3RyYXRlZ2ljIG1lbWJlcnMuIFN0cmF0ZWdpYyBtZW1iZXJzIGNhbiBwYXJ0aWNpcGF0ZSBieSBjb250YWN0aW5nIA0KLTxhIGhyZWY9Im1haWx0bzptZW1iZXJzaGlwQGVjbGlwc2Uub3JnIj5tZW1iZXJzaGlwQGVjbGlwc2Uub3JnPC9hPi4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBJVCBzdGFmZiB3aWxsIHByb3ZpZGUgDQotZG9jdW1lbnRhdGlvbiBvbiB0aGUgcGF5bG9hZCBmb3JtYXQgYW5kIHdpbGwgcmVxdWVzdCB0aGUgbWVtYmVyJ3Mgd2l6YXJkIHVybCwgbG9nbywgYW5kIHRhZyBsaW5lLiBBZnRlciANCi12ZXJpZnlpbmcgdGhlIG1lbWJlcidzIHdpemFyZCB1cmwgd2l0aCBhIHNldCBvZiB1bml0IHRlc3RzLCB0aGUgSVQgc3RhZmYgd2lsbCBhZGQgdGhlIG1lbWJlciB0byB0aGUgZmluYWwgDQotd2l6YXJkIHBhZ2UuIFRoZSBJVCBzdGFmZiB3aWxsIHBlcmlvZGljYWxseSAoZXZlcnkgZmV3IG1vbnRocyBvciB3aGVuIGEgYnVnIGlzIGZpbGVkKSBydW4gdGhlIHVuaXQgdGVzdHMgDQotYWdhaW5zdCBhbGwgdGhlIHBhcnRpY2lwYXRpbmcgbWVtYmVycycgd2l6YXJkIHVybHMgYW5kIHdpbGwgcmVtb3ZlIGFueSBmYWlsaW5nIHdpemFyZCB1cmxzIChhbmQgdGhlaXIgY29tcGFueSANCi1sb2dvcywgZXRjKS4gSWYgdGhhdCBoYXBwZW5zLCB0aGUgSVQgc3RhZmYgd2lsbCBub3RpZnkgdGhlIGNvbXBhbnkgY29udGFjdCBhbmQgd29yayB3aXRoIHRoYXQgY29udGFjdCB0byANCi1yZXN0b3JlIHRoZWlyIHBhcnRpY2lwYXRpb24uPC9wPg0KLQ0KLQ0KLTxoMz5EZXBsb3ltZW50IFBsYW48L2gzPg0KLTxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gcGxhbnMgdG8gc3RhcnQgd2l0aCBhIGJldGEgdGVzdCBvZiB0aGlzIHNlcnZpY2UgaW4gZWFybHkgMjAwOS4gV2Ugd2lsbCBsaW1pdCB0aGlzIGJldGEgDQotdGVzdCB0byBGcmllbmRzIG9mIEVjbGlwc2UgLSBub24tRnJpZW5kcyB3aWxsIGJlIHNob3duIGEgIndlJ3JlIGJldGEtdGVzdGluZyBhIG5ldyBzZXJ2aWNlLCBzaWduIHVwIGFzIGEgRnJpZW5kIA0KLXRvIHBhcnRpY2lwYXRlIiwgd2hpbGUgRnJpZW5kcyB3aWxsIHNlZSB0aGUgZG93bmxvYWQgYnV0dG9uLiBXaGVuIGF0IGxlYXN0IHRocmVlIFN0cmF0ZWdpYyBNZW1iZXJzIGFyZSByZWFkeSB0byANCi1wYXJ0aWNpcGF0ZSwgdGhlIEVjbGlwc2UgRm91bmF0aW9uIHdpbGwgZW5hYmxlIHRoZSBmaW5hbCB3aXphcmQgcGFnZSB0byAiYWRkIGFkZGl0aW9uYWwgZmVhdHVyZXMgZnJvbSBDb21wYW55IFggDQotb3IgQ29tcGFueSBZIG9yIGV0Yy4iPC9wPg0KLQ0KLTxwPkFmdGVyIHZlcmlmeWluZyB0aGF0IHRoZSB3aXphcmQgd29ya3MgKHNlcnZlciBsb2FkLCBiYW5kd2lkdGggbG9hZCwgaGFuZG9mZnMgdG8gc2Vjb25kYXJ5IHdpemFyZHMsIGdvb2QgdXNlciANCi1leHBlcmllbmNlLCBldGMpLCB3ZSB3aWxsIGVuYWJsZSB0byB3aXphcmQgZm9yIGEgbGFyZ2VyIGJldGEgdGVzdCAoYW55b25lIHdpdGggYSBidWd6aWxsYSBhY2NvdW50KS4gV2UgYW50aWNpcGF0ZSB0aGlzIA0KLXNlY29uZCBsYXJnZXIgYmV0YSBpbiB0aGUgZWFybHkgc3ByaW5nLjwvcD4NCi0NCi08cD5UaGUgdGhpcmQgc3RlcCBpcyB0byBlbmFibGUgdGhlIHdpemFyZCB3aXRob3V0IHJlc3RyaWN0aW9uLiBXZSBhbnRpY2lwYXRlIHRoaXMgImdvIGxpdmUiIG1pZCAyMDA5LiANCi1JdCBpcyBpbXBvcnRhbnQgZm9yIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gSVQgc3RhZmYgdG8gaGF2ZSB0aGUgZGVwbG95bWVudCBjb21wbGV0ZWQgYXMgc29vbiBhcyBwb3NzaWJsZSANCi1zbyB0aGF0IHdlIGNhbiBkZXRlY3QgYW5kIHJlcGFpciBhbnkgc2NhbGluZyBvciB1c2VyIGludGVyZmFjZSBpc3N1ZXMgbG9uZyBiZWZvcmUgdGhlICJidXN5IHNlYXNvbiIgYmVnaW5zIA0KLShpdCBiZWdpbnMgbGF0ZSBpbiB0aGUgY2FsZW5kYXIgeWVhciBhbmQgdGhlbiBzY2FsZXMgcmFwaWRseSBmcm9tIHRoZXJlIHRocm91Z2ggTTQsIE01LCBFY2xpcHNlQ29uLCB0aGUgUkNzLCANCi1hbmQgdGhlIGFubnVhbCByZWxlYXNlKS48L3A+DQotDQotDQotIDwvZGl2PjwvZGl2Pg0KLTw/cGhwDQotCSRodG1sID0gb2JfZ2V0X2NvbnRlbnRzKCk7DQotCW9iX2VuZF9jbGVhbigpOw0KLQ0KLSAgICAkQXBwLT5zZXRPdXRkYXRlZCgpOw0KLQkjIEdlbmVyYXRlIHRoZSB3ZWIgcGFnZQ0KLQkkQXBwLT5nZW5lcmF0ZVBhZ2UoJHRoZW1lLCAkTWVudSwgJE5hdiwgJHBhZ2VBdXRob3IsICRwYWdlS2V5d29yZHMsICRwYWdlVGl0bGUsICRodG1sKTsNCi0/Pg0KZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvZWNvc3lzdGVtLXdlYnNpdGUtcHJvbW90aW9uLnBocCBiL3NwZWNpYWxfcHJvZ3JhbXMvZWNvc3lzdGVtLXdlYnNpdGUtcHJvbW90aW9uLnBocApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggM2E4NjVkZi4uMDAwMDAwMAotLS0gYS9zcGVjaWFsX3Byb2dyYW1zL2Vjb3N5c3RlbS13ZWJzaXRlLXByb21vdGlvbi5waHAKKysrIC9kZXYvbnVsbApAQCAtMSwxMTggKzAsMCBAQAotPD9waHAgIAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL2FwcC5jbGFzcy5waHAiKTsJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbmF2LmNsYXNzLnBocCIpOyAJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbWVudS5jbGFzcy5waHAiKTsgCSRBcHAgCT0gbmV3IEFwcCgpOwkkTmF2CT0gbmV3IE5hdigpOwkkTWVudSAJPSBuZXcgTWVudSgpOwkJaW5jbHVkZSgiLi4vX3Byb2plY3RDb21tb24ucGhwIik7ICAgICMgQWxsIG9uIHRoZSBzYW1lIGxpbmUgdG8gdW5jbHV0dGVyIHRoZSB1c2VyJ3MgZGVza3RvcCcNCi0NCi0kcGFnZVRpdGxlIAkJPSAiRWNvc3lzdGVtIFdlYnNpdGUgUHJvbW90aW9uIjsNCi0kcGFnZUtleXdvcmRzCT0gIiI7DQotJHBhZ2VBdXRob3IJCT0gIiI7DQotDQotb2Jfc3RhcnQoKTsNCi0/Pg0KLTxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+DQotaDIgew0KLWJvcmRlci1ib3R0b206IHNvbGlkDQotfQ0KLWgzIHsNCi1ib3JkZXItYm90dG9tOiB0aGluIGRvdHRlZA0KLX0NCi08L3N0eWxlPg0KLQ0KLSAgICA8ZGl2IGlkPSJtYWluY29udGVudCI+DQotCTxkaXYgaWQ9Im1pZGNvbHVtbiI+DQotICAgICAgICA8aDE+PGJpZz5FY2xpcHNlLm9yZyBXZWJzaXRlIFByb21vdGlvbiBQcm9ncmFtPC9iaWc+PC9oMT4NCi0gICAgICAgICAgDQotICAgICAgICA8aDI+PGI+PGJpZz5Hb2FscyBvZiB0aGlzIFByb2dyYW08L2JpZz48L2I+PC9oMj4NCi0gICAgICAgIDxwPlRoaXMgcHJvZ3JhbSBoYXMgdHdvIG1haW4gZ29hbHM6PC9wPg0KLSAgICAgICAgDQotICAgICAgICA8b2w+DQotICAgICAgICAgICA8bGk+UHJvdmlkZSB2YWx1ZSB0byBTdHJhdGVnaWMgTWVtYmVyc2hpcCBpbiB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLjwvbGk+DQotICAgICAgICAgICA8bGk+UHJvdmlkZSB2YWx1YWJsZSBhZGRpdGlvbmFsIGluZm9ybWF0aW9uIGFib3V0IG91ciBlY29zeXN0ZW0gdG8gdXNlcnMgb2YgRWNsaXBzZS5vcmcuPC9saT4NCi0gICAgICAgIDwvb2w+DQotDQotICAgICAgICA8cD5UaGlzIHByb2dyYW0gaXMgbWFkZSBwb3NzaWJsZSBieSB0aGUgc3VjY2VzcyBvZiBhIHllYXImIzE1MDtsb25nIHN0dWR5IHJ1bm5pbmcgR29vZ2xlIGFkcyBvbiANCi0gICAgICAgIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZXBsdWdpbmNlbnRyYWwuY29tLyI+RWNsaXBzZSBQbHVnaW4gQ2VudHJhbDwvYT4uICBUaGUNCi0gICAgICAgIGRhdGEgc2hvd2VkIHRoYXQgcHJvbW90aW9ucyBjb3VsZCBiZSB0YXN0ZWZ1bGx5IHBsYWNlZCBvbiBFY2xpcHNlIEZvdW5kYXRpb24gcHJvcGVydGllcyB0byB0aGUgYmVuZWZpdCBvZiBib3RoIG91cg0KLSAgICAgICAgZWNvc3lzdGVtIGFuZCB3ZWJzaXRlIHZpc2l0b3JzIGxvb2tpbmcgZm9yIG1vcmUgaW5mb3JtYXRpb24uPC9wPg0KLSAgICAgICAgDQotICAgICAgICA8aDI+PGI+PGJpZz5Ib3cgRG8gSSBQYXJ0aWNpcGF0ZT88L2JpZz48L2I+PC9oMj4NCi0gICAgICAgIDxwPlRoZXJlIGFyZSB0d28ga2luZHMgb2YgcHJvbW90aW9ucyB0aGF0IHdpbGwgcmFuZG9tbHkgYXBwZWFyIG9uIEVjbGlwc2Uub3JnIC0gdGhvc2Ugc3BlY2lmaWMgdG8gU3RyYXRlZ2ljIE1lbWJlcnMgYW5kIGNvbnRlbnQgcHJvdmlkZWQgYnkgDQotICAgICAgICB0aGUgPGEgaHJlZj0iaHR0cHM6Ly9hZHdvcmRzLmdvb2dsZS5jb20vIj5Hb29nbGUgQWR3b3JkczwvYT4gc2VydmljZS48L3A+DQotICAgICAgICANCi0gICAgICAgIDxoMz5TdHJhdGVnaWMgTWVtYmVyIFByb21vdGlvbjwvaDM+DQotICAgICAgICA8cD5TdHJhdGVnaWMgTWVtYmVycyB3aWxsIGF1dG9tYXRpY2FsbHkgaGF2ZSB0aGVpciBsb2dvIHBsYWNlZCBpbiByb3RhdGlvbiBhcyBhICJGZWF0dXJlZCBNZW1iZXIiIG9mIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24uDQotICAgICAgICBTdHJhdGVnaWMgTWVtYmVycyBhcmUgYWxzbyBhYmxlIGFuZCBlbmNvdXJhZ2VkIHRvIHBsYWNlIGNhbXBhaWduIGFkcyBpbnRvIHRoZWlyIHJvdGF0aW9uIChzZWUgPGEgaHJlZj0iI0ZBUSI+RkFRPC9hPiBiZWxvdyBmb3IgZGV0YWlscykuICBFeHRyYSBpbXByZXNzaW9ucw0KLSAgICAgICAgY2Fubm90IGJlIHB1cmNoYXNlZCBhdCB0aGlzIHRpbWUgYW5kIHRoaXMgcHJvZ3JhbSBpcyBjdXJyZW50bHkgb25seSBhdmFpbGFibGUgdG8gU3RyYXRlZ2ljIE1lbWJlcnMuDQotCQk8L3A+DQotDQotCQk8aDM+T3RoZXIgUHJvbW90aW9uPC9oMz4JCQ0KLQkJPHA+T3RoZXIgbWVtYmVycyBhbmQgbm9uJiMxNTA7bWVtYmVycyBhbGlrZSBhcmUgYWJsZSB0byBwbGFjZSBjb250ZW50IG9uIEVjbGlwc2Uub3JnIHRocm91Z2ggDQotCQl0aGUJPGEgaHJlZj0iaHR0cDovL2Fkd29yZHMuZ29vZ2xlLmNvbS8iPkdvb2dsZSBBZHdvcmRzPC9hPiBzZXJ2aWNlLiAgVG8gdGFyZ2V0IEVjbGlwc2Uub3JnIHdpdGgNCi0JCXlvdXIgYWRzLCBwbGVhc2Ugc2VlIHRoZSBHb29nbGUgYWRzIEZBUSBmb3IgPGEgaHJlZj0iaHR0cDovL2Fkd29yZHMuZ29vZ2xlLmNvbS9zdXBwb3J0L2Jpbi9hbnN3ZXIucHk/aGw9ZW4mYW5zd2VyPTE4MjY1Ij5TaXRlIFRhcmdldGVkIEFkczwvYT4uDQotCQlQbGVhc2UgcmVmZXIgdG8gdGhlIDxhIGhyZWY9Imh0dHA6Ly9hZHdvcmRzLmdvb2dsZS5jb20vIj5Hb29nbGUgQWR3b3JkczwvYT4gc2VydmljZSBmb3IgaGVscCBzZXR0aW5nIHVwIGFuZCBydW5uaW5nIHlvdXINCi0JCUdvb2dsZSBwcm9tb3Rpb25zLiAgVGhlcmUgaXMgbm90aGluZyB5b3UgbmVlZCB0byBkbyB3aXRoIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gcnVuIGNvbnRlbnQgYW5kIHdlIGFyZSB1bmFibGUgdG8gaGVscCANCi0JCXlvdSBwbGFjZSB5b3VyIEdvb2dsZSBjb250ZW50IC0gd29yayB3aXRoIEdvb2dsZSBvbiBhbnkgcXVlc3Rpb25zIHlvdSBtYXkgaGF2ZSBpbmNsdWRpbmcgDQotCQk8YSBocmVmPSJodHRwOi8vYWR3b3Jkcy5nb29nbGUuY29tL3N1cHBvcnQvYmluL2Fuc3dlci5weT9obD1lbiZhbnN3ZXI9NjEwNSI+d2h5IHlvdXIgcHJvbW90aW9ucyBhcmUgbm90IGFwcGVhcmluZzwvYT4uPC9wPg0KLSAgDQotICAgICAgICA8aDI+PGJpZz48Yj48YSBuYW1lPSJGQVEiPjwvYT5GQVE8L2E+PC9iPjwvYmlnPjwvaDI+DQotICAgICAgICAgDQotCQk8Yj5BcyBhIFN0cmF0ZWdpYyBNZW1iZXIsIHdoYXQga2luZCBvZiBjdXN0b20gY2FtcGFpZ25zIGNhbiBJIHJ1bj88L2I+DQotICAgICAgICA8cD5IZXJlIGFyZSB0aGUgc3BlY2lmaWNhdGlvbnMgZm9yIGFsbG93YWJsZSBjb250ZW50Og0KLSAgICAgICAgIDx1bD4NCi0gICAgICAgICAJPGxpPk5vdCBtb3JlIHRoYW4gMjAwcHggd2lkZSBvciAyMDBweCBoaWdoLjwvbGk+DQotICAgICAgICAgCTxsaT5Db250ZW50IG11c3QgYmUgR0lGIChwcmVmZXJyZWQpIG9yIEpQRyBmb3JtYXQgKE5PIEZsYXNoL1NXRiBhdCB0aGlzIHRpbWUpLjwvbGk+DQotICAgICAgICAgCTxsaT5Db250ZW50IG11c3QgYmUgbGVzcyB0aGFuIDIway4gIENvbnRlbnQgYXMgbGFyZ2UgYXMgNDBrIHdpbGwgYmUgYWNjZXB0ZWQgYnV0IHdpbGwgYmUgZ2l2ZW4gcHJvcG9ydGlvbmF0ZWx5IGZld2VyIHJvdGF0aW9ucy48L2xpPg0KLSAgICAgICAgIAk8bGk+SXQgbXVzdCBiZSBjbGVhciB3aGljaCBvcmdhbml6YXRpb24gdGhlIHByb21vdGlvbiBpcyBmcm9tLiAgRm9yIGV4YW1wbGUsIHlvdXIgY29tcGFueSBsb2dvIGFuZC9vciBhbiBvYnZpb3VzIGNvbXBhbnkgYnJhbmQgbXVzdA0KLSAgICAgICAgIAliZSBjbGVhcmx5IG9uIHRoZSBwcm9tb3Rpb24uPC9saT4NCi0gICAgICAgICAJPGxpPkNvbnRlbnQgbXVzdCBmaXQgd2l0aCB0aGUgbG9vayBhbmQgZmVlbCBvZiBFY2xpcHNlLm9yZy4gIFlvdSBkbyA8Yj5ub3Q8L2I+IGhhdmUgdG8gbWF0Y2ggdGhlIGVjbGlwc2Uub3JnDQotICAgICAgICAgCWNvbG9yIHBhbGV0dGUsIGJ1dCBkYXJrIGNvbG9ycywgd2hpdGUgYmFja2dyb3VuZHMsIGJsYWNrcywgYmx1ZXMgYW5kIHB1cnBsZXMgd2lsbCBpbnRlZ3JhdGUgYmVzdC4gIENvbnRlbnQgdGhhdCANCi0gICAgICAgICAJaXMgb2J2aW91c2x5IGZsYXNoeSAoaS5lLiwgZmxhc2hpbmcgcmVkIGJhY2tncm91bmRzKSB3aWxsIG5vdCBiZSBwZXJtaXR0ZWQuPC9saT4NCi0gICAgICAgICAJPGxpPklmIHlvdSB3b3VsZCBsaWtlIHRvIG1hdGNoIHRoZSBFY2xpcHNlLm9yZyBjb2xvciBwYWxldHRlLCBoZXJlIGFyZSBzb21lIGNvbG9yIGNvZGVzIHRvIGhlbHA6IA0KLSAgICAgICAgIAk8YnI+PGltZyBhbGlnbj0iY2VudGVyIiBzcmM9Ii4vcHJvbW90aW9uX3Byb2dyYW0vcGFsZXR0ZS5naWYiPjwvbGk+DQotICAgICAgICA8L3A+DQotDQotICAgICAgIDxicj48Yj5BcyBhbiBlY29jeXN0ZW0gcGFydGljaXBhbnQsIHdoYXQga2luZCBvZiBjb250ZW50IGNhbiBJIHJ1bj88L2I+DQotICAgICAgICA8cD5TdGFuZGFyZCBUZXh0IGFuZCBMaXN0IENvbnRlbnQgd2lsbCBiZSBzZXJ2ZWQgYnkgPGEgaHJlZj0iaHR0cDovL2Fkd29yZHMuZ29vZ2xlLmNvbS8iPkdvb2dsZSBBZHdvcmRzPC9hPi4NCi0gICAgICAgIDwvcD4NCi0NCi0gICAgICAgIDxicj48Yj5Ib3cgb2Z0ZW4gd2lsbCBteSBjb250ZW50IGFwcGVhcj88L2I+DQotICAgICAgICA8cD4NCi0gICAgICAgIFRoZSBFY2xpcHNlLm9yZyBob21lIHBhZ2UgaXMgaGl0IHRlbnMgb2YgdGhvdXNhbmRzIG9mIHRpbWVzIHBlciBkYXkuICBXZSB3aWxsIGV4cGVyaW1lbnQgdG8gZmluZCBhbiBhcHByb3ByaWF0ZSBiYWxhbmNlDQotICAgICAgICBvZiBTdHJhdGVnaWMgTWVtYmVyIGNvbnRlbnQgYW5kIGNvbnRlbnQgaG9zdGVkIGJ5IEdvb2dsZSBBZHdvcmRzIHRocm91Z2hvdXQgMjAwOC4gIFN0cmF0ZWdpYyBtZW1iZXIgYWRzIHdpbGwgYXBwZWFyDQotICAgICAgICByZWxhdGl2ZSB0byBlYWNoIG90aGVyIG9uIGJhc2lzIHdlaWdodGVkIHRvIHJlbGF0aXZlIG1lbWJlcnNoaXAgZHVlcy4NCi0gICAgICAgIDwvcD4NCi0NCi0gICAgICAgICA8YnI+PGI+U2hvdyBtZSBzb21lIGV4YW1wbGVzITwvYj4NCi0gICAgICAgIDxwPg0KLSAgICAgICAgSGVyZSBpcyB3aGVyZSB0aGUgY29udGVudCB3aWxsIGFwcGVhciBvbiBFY2xpcHNlLm9yZzogDQotICAgIAk8YnI+PGltZyBhbGlnbj0iY2VudGVyIiBzcmM9Ii4vcHJvbW90aW9uX3Byb2dyYW0vc2NyZWVuMi5naWYiPg0KLSAgICAJPC9wPg0KLQkNCi0gICAgICAgIDxwPg0KLSAgICAgICAgSGVyZSBpcyBhbiBleGFtcGxlIG9mIHByb21vdGluZyBvdXIgU3RyYXRlZ2ljIE1lbWJlcnM6DQotCQk8YnI+PGltZyBhbGlnbj0iY2VudGVyIiBzcmM9Ii4vcHJvbW90aW9uX3Byb2dyYW0vc2NyZWVuNC5naWYiPg0KLSAgICAgICAgPC9wPg0KLSAgICAgICAgDQotICAgICAgICA8cD4NCi0gICAgICAgIEhlcmUgaXMgYW4gZXhhbXBsZSBvZiBHb29nbGUgY29udGVudCBvbiBFY2xpcHNlLm9yZzoNCi0gICAgICAgIDxicj48aW1nIGFsaWduPSJjZW50ZXIiIHNyYz0iLi9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW4zLmdpZiI+DQotCQk8L3A+DQotCQkNCi0gICAgICAgIDxwPg0KLSAgICAgICAgSGVyZSBpcyBhbiBleGFtcGxlIG9mIGEgU3RyYXRlZ2ljIE1lbWJlciBjYW1wYWlnbjoNCi0gICAgICAgIDxicj48aW1nIGFsaWduPSJjZW50ZXIiIHNyYz0iLi9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW4xLmdpZiI+DQotCSAgICAgIDwvcD4NCi0NCi0JICAgICAgDQotICAgICAgIDxicj48Yj5JIGFtIGEgc3RyYXRlZ2ljIE1lbWJlciwgd2hlcmUgZG8gSSBzZW5kIG15IDIwMHgyMDAgcHJvbW90aW9uPzwvYj4NCi0gICAgICAgPHA+UGxlYXNlIGNvbnRhY3QgbWVtYmVyc2hpcCBhdCBlY2xpcHNlIGRvdCBvcmcuPC9wPg0KLSAJICAgICAgDQotICAgICAgIDxicj48Yj5JIG5lZWQgbW9yZSBpbmZvcm1hdGlvbi48L2I+DQotICAgICAgIDxwPlBsZWFzZSBjb250YWN0IG1lbWJlcnNoaXAgYXQgZWNsaXBzZSBkb3Qgb3JnLjwvcD4NCi0gDQotCQkNCi0gIDwvZGl2PjwvZGl2Pg0KLTw/cGhwDQotCSRodG1sID0gb2JfZ2V0X2NvbnRlbnRzKCk7DQotCW9iX2VuZF9jbGVhbigpOw0KLQ0KLQkjIEdlbmVyYXRlIHRoZSB3ZWIgcGFnZQ0KLQkkQXBwLT5nZW5lcmF0ZVBhZ2UoJHRoZW1lLCAkTWVudSwgJE5hdiwgJHBhZ2VBdXRob3IsICRwYWdlS2V5d29yZHMsICRwYWdlVGl0bGUsICRodG1sKTsNCi0/Pg0KZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvaW5kZXgucGhwIGIvc3BlY2lhbF9wcm9ncmFtcy9pbmRleC5waHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGViYzI3OTUuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9pbmRleC5waHAKKysrIC9kZXYvbnVsbApAQCAtMSw0OCArMCwwIEBACi08P3BocCAgCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vYXBwLmNsYXNzLnBocCIpOwlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9uYXYuY2xhc3MucGhwIik7IAlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9tZW51LmNsYXNzLnBocCIpOyAJJEFwcCAJPSBuZXcgQXBwKCk7CSROYXYJPSBuZXcgTmF2KCk7CSRNZW51IAk9IG5ldyBNZW51KCk7CQlpbmNsdWRlKCIuLi9fcHJvamVjdENvbW1vbi5waHAiKTsgICAgIyBBbGwgb24gdGhlIHNhbWUgbGluZSB0byB1bmNsdXR0ZXIgdGhlIHVzZXIncyBkZXNrdG9wJw0KLQ0KLSRwYWdlVGl0bGUgCQk9ICJFY2xpcHNlIE1lbWJlcnNoaXAgU3BlY2lhbCBQcm9ncmFtcyI7DQotJHBhZ2VLZXl3b3JkcyAJPSAiRWNsaXBzZSwgcHJvZ3JhbXMsIG1lbWJlcnNoaXAsIHByb21vdGlvbiwgYWR2ZXJ0aXNpbmcsIGRpc3Ryb3MsIGRpc3RyaWJ1dGlvbnMsIG1hcmtldGluZyI7DQotJHBhZ2VBdXRob3IJCT0gIkVjbGlwc2UgRm91bmRhdGlvbiI7DQotDQotb2Jfc3RhcnQoKTsNCi0/Pg0KLTxkaXYgaWQ9Im1haW5jb250ZW50Ij4NCi08ZGl2IGlkPSJtaWRjb2x1bW4iPg0KLQ0KLTxoMT48Pz0kcGFnZVRpdGxlPz48L2gxPg0KLQ0KLTxwPg0KLVRoaXMgcGFnZSBsaXN0cyBzb21lIG9mIHRoZSBzcGVjaWFsIHByb2dyYW1zIGF2YWlsYWJsZSB0byBtZW1iZXJzIHRoYXQgcmVxdWlyZSBkZXRhaWxlZCBpbmZvcm1hdGlvbi4gIEZvciBhIG1vcmUgY29tcGxldGUgbGlzdCBvZg0KLW1lbWJlcnNoaXAgYmVuZWZpdHMsIHBsZWFzZSBzZWUgdGhlIDxhIGhyZWY9Ii4uL2JlY29tZV9hX21lbWJlci9iZW5lZml0cy5waHAiPm1lbWJlcnNoaXAgYmVuZWZpdHMgcGFnZTwvYT4uDQotPC9wPg0KLQ0KLTxoMj5Qcm9ncmFtcyBmb3IgU3RyYXRlZ2ljIE1lbWJlcnM8L2gyPg0KLTx1bD4NCi08bGk+PGEgaHJlZj0iZWNvc3lzdGVtLXdlYnNpdGUtcHJvbW90aW9uLnBocCI+RWNvc3lzdGVtIFdlYnNpdGUgUHJvbW90aW9uPC9hPjwvbGk+DQotPC91bD4NCi0NCi08aDI+UHJvZ3JhbXMgZm9yIFN0cmF0ZWdpYyBhbmQgRW50ZXJwcmlzZSBNZW1iZXJzPC9oMj4NCi08dWw+DQotPGxpPjxhIGhyZWY9ImlwemlsbGEucGhwIj5JUCBEYXRhYmFzZSBBY2Nlc3M8L2E+PC9saT4NCi08L3VsPg0KLQ0KLQ0KLTxoMj5Qcm9ncmFtcyBmb3IgU29sdXRpb25zIE1lbWJlcnMgYW5kIEFib3ZlPC9oMj4NCi08dWw+DQotPGxpPjxhIGhyZWY9Im1lbWJlci1kb3dubG9hZHMtcHJvZ3JhbS5waHAiPkRpc3RybyBMaXN0aW5nIG9uIGVjbGlwc2Uub3JnL2Rvd25sb2FkczwvYT48L2xpPg0KLTxsaT48YSBocmVmPSJtYXJrZXRwbGFjZS1saXN0aW5nLnBocCI+TGlzdGluZyBpbiBFY2xpcHNlIE1hcmtldHBsYWNlIENsaWVudCwgYW5kIHByaW9yaXR5IG9uIE1hcmtldHBsYWNlIExpc3RpbmdzPC9hPjwvbGk+DQotPGxpPjxhIGhyZWY9Im1lbWJlcjJtZW1iZXIucGhwIj5NZW1iZXIyTWVtYmVyIE1hcmtldGluZzwvYT48L2xpPg0KLTxsaT48YSBocmVmPSJFQ0xJUFNFX1dFQi5wZGYiPk92ZXJ2aWV3IG9mIGFsbCB3ZWIgcHJvcGVydGllcyBNZW1iZXJzIGNhbiBsZXZlcmFnZTwvYT4gKFBERik8L2xpPg0KLTwvdWw+DQotDQotPC9kaXY+PCEtLSBtaWRjb2x1bW4gLS0+DQotDQotPC9kaXY+PCEtLSBtYWluY29udGVudCAtLT4NCi08P3BocA0KLQkjIFBhc3RlIHlvdXIgSFRNTCBjb250ZW50IGJldHdlZW4gdGhlIEVPSFRNTCBtYXJrZXJzIQ0KLQkkaHRtbCA9IG9iX2dldF9jb250ZW50cygpOw0KLQlvYl9lbmRfY2xlYW4oKTsNCi0NCi0JIyBHZW5lcmF0ZSB0aGUgd2ViIHBhZ2UNCi0JJEFwcC0+Z2VuZXJhdGVQYWdlKE5VTEwsICRNZW51LCAkTmF2LCAkcGFnZUF1dGhvciwgJHBhZ2VLZXl3b3JkcywgJHBhZ2VUaXRsZSwgJGh0bWwpOw0KLT8+DQpkaWZmIC0tZ2l0IGEvc3BlY2lhbF9wcm9ncmFtcy9pcHppbGxhLnBkZiBiL3NwZWNpYWxfcHJvZ3JhbXMvaXB6aWxsYS5wZGYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE0Njk0OGYuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9pcHppbGxhLnBkZgorKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvaXB6aWxsYS5waHAgYi9zcGVjaWFsX3Byb2dyYW1zL2lwemlsbGEucGhwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3YWYxOWFjLi4wMDAwMDAwCi0tLSBhL3NwZWNpYWxfcHJvZ3JhbXMvaXB6aWxsYS5waHAKKysrIC9kZXYvbnVsbApAQCAtMSw4MiArMCwwIEBACi08P3BocCAgCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vYXBwLmNsYXNzLnBocCIpOwlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9uYXYuY2xhc3MucGhwIik7IAlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9tZW51LmNsYXNzLnBocCIpOyAJJEFwcCAJPSBuZXcgQXBwKCk7CSROYXYJPSBuZXcgTmF2KCk7CSRNZW51IAk9IG5ldyBNZW51KCk7CQlpbmNsdWRlKCIuLi9fcHJvamVjdENvbW1vbi5waHAiKTsgICAgIyBBbGwgb24gdGhlIHNhbWUgbGluZSB0byB1bmNsdXR0ZXIgdGhlIHVzZXIncyBkZXNrdG9wJw0KLQ0KLSRwYWdlVGl0bGUgCQk9ICJJUCBEYXRhYmFzZSBBY2Nlc3MiOw0KLSRwYWdlS2V5d29yZHMJPSAiIjsNCi0kcGFnZUF1dGhvcgkJPSAiIjsNCi0NCi1vYl9zdGFydCgpOw0KLT8+DQotPHN0eWxlIHR5cGU9InRleHQvY3NzIj4NCi1oMiB7DQotYm9yZGVyLWJvdHRvbTogc29saWQNCi19DQotaDMgew0KLWJvcmRlci1ib3R0b206IHRoaW4gZG90dGVkDQotfQ0KLTwvc3R5bGU+DQotDQotICAgIDxkaXYgaWQ9Im1haW5jb250ZW50Ij4NCi0JPGRpdiBpZD0ibWlkY29sdW1uIj4NCi0gICAgICAgIDxoMT48YmlnPklQIERhdGFiYXNlIEFjY2VzczwvYmlnPjwvaDE+DQotICAgICAgICAgIA0KLSAgICAgICAgPGgyPjxiPjxiaWc+R29hbHMgb2YgdGhpcyBQcm9ncmFtPC9iaWc+PC9iPjwvaDI+DQotICAgICAgICA8cD5UaGlzIHByb2dyYW0gYWxsb3dzIHVwIHRvIHRocmVlIG5vbi1jb21taXR0ZXJzIGZyb20gU3RyYXRlZ2ljIGFuZCBFbnRlcnByaXNlIG1lbWJlcnMgdG8gYWNjZXNzIHRoZSBFY2xpcHNlIENvbnRyaWJ1dGlvbiBRdWVzdGlvbm5haXJlDQotICAgICAgICBkYXRhYmFzZSwga25vd24gYXMgIklQWmlsbGEiLiAgQ29tbWl0dGVycyBkbyBub3QgbmVlZCBhY2Nlc3MgdG8gdGhpcyBwcm9ncmFtIGFzIHRoZXkgaGF2ZSBhY2Nlc3MgdG8gSVBaaWxsYSBmb3IgdGhlaXIgd29yaw0KLSAgICAgICAgYnkgZGVmYXVsdC4gIE5vbi1jb21taXR0ZXJzLCBzdWNoIGFzIElQIEFuYWx5c3RzIGFuZCBidXNpbmVzcyBkZWNpc2lvbiBtYWtlcnMsIG1heSB3aXNoIHRvIHVzZSBJUFppbGxhIGFzIGEgcmVzb3VyY2UgDQotICAgICAgICBzaW5jZSBpdCBjb250YWlucyBjb252ZXJzYXRpb25zIHJlZ2FyZGluZyBvdmVyIDE1MDAgb3BlbiBzb3VyY2UgbGlicmFyaWVzIGFuZCBpbmRpY2F0aW9ucyB3aGV0aGVyIHRoZXkgYXJlIGFwcHJvdmVkLCANCi0gICAgICAgIG9yIG5vdCwgZm9yIHVzZSBvbiBFY2xpcHNlIHByb2plY3RzLjwvcD4NCi0gICAgICAgIA0KLSAgICAgICAgPGgyPjxiPjxiaWc+SG93IGRvIEkgcGFydGljaXBhdGU/PC9iaWc+PC9iPjwvaDI+DQotICAgICAgICA8cD5UaGVyZSBhcmUgdGhyZWUgc3RlcHMgdG8gcmVjZWl2ZSBJUFppbGxhIGFjY2Vzcy4NCi0gICAgICAgIDxvbD4NCi0gICAgICAgIDxsaT5Zb3UgbXVzdCBwcmludCwgc2lnbiBhbmQgRkFYIHRoZSA8YSBocmVmPSIuL2lwemlsbGEucGRmIj5JUFppbGxhIERhdGFiYXNlIEFjY2VzcyBBZ3JlZW1lbnQ8L2E+IHRvIDIxMiA5MTggMTYxOS4gIElmIHlvdSBiZWxpZXZlDQotICAgICAgICB5b3VyIG9yZ2FuaXphdGlvbiBtYXkgaGF2ZSBhbHJlYWR5IHNpZ25lZCB0aGlzIGRvY3VtZW50LCBjb250YWN0IHVzIGF0IDxhIGhyZWY9Im1haWx0bzptZW1iZXJzaGlwQGVjbGlwc2Uub3JnIj5tZW1iZXJzaGlwQGVjbGlwc2Uub3JnPC9hPiB0byBjb25maXJtLjwvbGk+DQotICAgICAgICA8bGk+WW91IG11c3QgY3JlYXRlIGEgDQotICAgICAgICA8YSBocmVmPSJodHRwczovL2J1Z3MuZWNsaXBzZS5vcmcvYnVncy9jcmVhdGVhY2NvdW50LmNnaSI+YnVnemlsbGEgYWNjb3VudDwvYT4gd2l0aCB0aGUgZW1haWwgYWRkcmVzcyBvZiANCi0gICAgICAgIHRoZSBwZXJzb24geW91IHdpc2ggdG8gaGF2ZSBhY2Nlc3MuPC9saT4NCi0gICAgICAgIDxsaT5GaW5hbGx5LCBlbWFpbCA8YSBocmVmPSJtYWlsdG86bWVtYmVyc2hpcEBlY2xpcHNlLm9yZyI+bWVtYmVyc2hpcEBlY2xpcHNlLm9yZzwvYT4gd2l0aCB0aGUgZm9sbG93aW5nIGluZm9ybWF0aW9uOg0KLSAgICAgICAgPHVsPg0KLSAgICAgICAgICA8bGk+TmFtZSBvZiBwZXJzb24gcmVxdWlyaW5nIGFjY2VzczwvbGk+DQotICAgICAgICAgIDxsaT5FbWFpbCBhZGRyZXNzIHRoYXQgeW91IHVzZWQgdG8gY3JlYXRlIHRoZSA8YSBocmVmPSJodHRwczovL2J1Z3MuZWNsaXBzZS5vcmcvYnVncy9jcmVhdGVhY2NvdW50LmNnaSI+YnVnemlsbGEgYWNjb3VudDwvYT48L2xpPg0KLSAgICAgICAgICA8bGk+Q29udGFjdCBQaG9uZSBOdW1iZXI8L2xpPg0KLSAgICAgICAgICA8bGk+Q29udGFjdCBidXNpbmVzcyBhZGRyZXNzPC9saT4NCi0gICAgICAgIDwvdWw+IA0KLSAgICAgICAgPC9saT4NCi0gICAgICAgIDwvb2w+DQotCQk8L3A+DQotCQkNCi0gICAgICAgICAgDQotICAgICAgICA8aDI+PGJpZz48Yj5GQVE8L2I+PC9iaWc+PC9oMj4NCi0JCTxiPkhvdyBtdWNoIGRvZXMgaXQgY29zdD88L2I+DQotICAgICAgICA8cD5UaGlzIGlzIGEgZnJlZSBzZXJ2aWNlIGZyZWUgZm9yIFN0cmF0ZWdpYyBhbmQgRW50ZXJwcmlzZSBNZW1iZXJzIG9ubHkuDQotICAgICAgICA8L3A+DQotDQotICAgICAgICA8Yj5NeSBDb21wYW55IGhhcyBDb21taXR0ZXJzLCB3aHkgZG8gSSBuZWVkIHRoaXM/PC9iPg0KLSAgICAgICAgPHA+Q29tbWl0dGVycyBhcmUgZW50aXRsZWQgdG8gdXNlIElQWmlsbGEgYXMgaXQgcmVsYXRlcyB0byB0aGVpciBwcm9qZWN0IGFuZCBzcGVjaWZpY2FsbHkgZm9yIHRoZWlyIHdvcmsgYXMgYSBjb21taXR0ZXINCi0gICAgICAgIG9uIGFuIEVjbGlwc2UgUHJvamVjdC4gIFN0cmF0ZWdpYyBhbmQgRW50ZXJwcmlzZSBtZW1iZXJzIG1heSB3aXNoIHRvIGhhdmUgSVAgQW5hbHlzdHMgYW5kIGJ1c2luZXNzIGRlY2lzaW9uIG1ha2Vycw0KLSAgICAgICAgYWxzbyBoYXZlIGFjY2VzcyB0byB0aGlzIGRhdGEuICBJbiBvdGhlciB3b3Jkcywgbm9uLWNvbW1pdHRlcnMgY2FuIGhhdmUgYWNjZXNzIHRvIHRoZSBkYXRhLCBhbmQgY29tbWl0dGVycyBjYW4gDQotICAgICAgICBtYWtlIGludGVybmFsIGJ1c2luZXNzIHVzZSBvZiB0aGUgZGF0YS4NCi0gICAgICAgIDwvcD4NCi0NCi0JCTxiPkhvdyBkbyBJIGxvZ2luPzwvYj4NCi0gICAgICAgIDxwPk9uY2UgeW91ciBhY2NvdW50IGhhcyBiZWVuIGNyZWF0ZWQgYW5kIGNvbmZpcm1lZCBmb2xsb3dpbmcgdGhlIHN0ZXBzIGFib3ZlLCB5b3UgdmlzaXQgDQotICAgICAgICB0aGUgPGEgaHJlZj0iaHR0cHM6Ly9kZXYuZWNsaXBzZS5vcmcvaXB6aWxsYS8iPklQWmlsbGEgTWFpbiBQYWdlPC9hPi4NCi0gICAgICAgIDwvcD4NCi0gICAgICAgIA0KLSAgICAgICAgPGI+RG8geW91IGhhdmUgYW4gZXhhbXBsZSBvZiB0aGUga2luZCBvZiBkYXRhIGF2YWlsYWJsZT88L2I+DQotICAgICAgICA8cD5UaGUgZGF0YWJhc2UgY29udGFpbnMgdGhlIGFwcHJvdmFsIG9yIHJlamVjdGlvbiBvZiBvdmVyIDE1MDAgb3BlbiBzb3VyY2UgbGlicmFyaWVzIHJlcXVlc3RlZCANCi0gICAgICAgIGZvciB1c2UgaW4gRWNsaXBzZSBvcGVuIHNvdXJjZSBwcm9qZWN0cyAtLSBhbmQgdGhlIGNvcnJlc3BvbmRpbmcgY29udmVyc2F0aW9ucyByZWxhdGVkIHRvIHRob3NlDQotICAgICAgICBkZWNpc2lvbnMuICBUaGlzIGluZm9ybWF0aW9uIGNvdWxkIGJlIGhpZ2ggdmFsdWUgdG8gSVAgQW5hbHlzdHMgYW5kIGJ1c2luZXNzIGRlY2lzaW9uIG1ha2Vycw0KLSAgICAgICAgdHJ5aW5nIHRvIGRldGVybWluZSB0aGUgcmlzayBwcm9maWxlIG9mIHVzaW5nIHNvbWUgb3BlbiBzb3VyY2UgbGlicmFyaWVzLg0KLSAgICAgICAgRW1haWwgPGEgaHJlZj0ibWFpbHRvOm1lbWJlcnNoaXBAZWNsaXBzZS5vcmciPm1lbWJlcnNoaXBAZWNsaXBzZS5vcmc8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLg0KLSAgICAgICAgPC9wPg0KLSAgDQotICAgICAgDQotICA8L2Rpdj48L2Rpdj4NCi08P3BocA0KLQkkaHRtbCA9IG9iX2dldF9jb250ZW50cygpOw0KLQlvYl9lbmRfY2xlYW4oKTsNCi0NCi0JIyBHZW5lcmF0ZSB0aGUgd2ViIHBhZ2UNCi0JJEFwcC0+Z2VuZXJhdGVQYWdlKCR0aGVtZSwgJE1lbnUsICROYXYsICRwYWdlQXV0aG9yLCAkcGFnZUtleXdvcmRzLCAkcGFnZVRpdGxlLCAkaHRtbCk7DQotPz4NCmRpZmYgLS1naXQgYS9zcGVjaWFsX3Byb2dyYW1zL21hcmtldHBsYWNlLWxpc3RpbmcucGhwIGIvc3BlY2lhbF9wcm9ncmFtcy9tYXJrZXRwbGFjZS1saXN0aW5nLnBocApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTkwNWY0ZC4uMDAwMDAwMAotLS0gYS9zcGVjaWFsX3Byb2dyYW1zL21hcmtldHBsYWNlLWxpc3RpbmcucGhwCisrKyAvZGV2L251bGwKQEAgLTEsNTMgKzAsMCBAQAotPD9waHAgIAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL2FwcC5jbGFzcy5waHAiKTsJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbmF2LmNsYXNzLnBocCIpOyAJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbWVudS5jbGFzcy5waHAiKTsgCSRBcHAgCT0gbmV3IEFwcCgpOwkkTmF2CT0gbmV3IE5hdigpOwkkTWVudSAJPSBuZXcgTWVudSgpOwkJaW5jbHVkZSgiLi4vX3Byb2plY3RDb21tb24ucGhwIik7ICAgICMgQWxsIG9uIHRoZSBzYW1lIGxpbmUgdG8gdW5jbHV0dGVyIHRoZSB1c2VyJ3MgZGVza3RvcCcKLQotJHBhZ2VUaXRsZSAJCT0gIk1hcmtldHBsYWNlIExpc3RpbmdzIjsKLSRwYWdlS2V5d29yZHMJPSAiIjsKLSRwYWdlQXV0aG9yCQk9ICIiOwotCi1vYl9zdGFydCgpOwotPz4KLTxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+Ci1oMiB7Ci1ib3JkZXItYm90dG9tOiBzb2xpZAotfQotaDMgewotYm9yZGVyLWJvdHRvbTogdGhpbiBkb3R0ZWQKLX0KLTwvc3R5bGU+Ci0KLSAgICA8ZGl2IGlkPSJtYWluY29udGVudCI+Ci0JPGRpdiBpZD0ibWlkY29sdW1uIj4KLSAgICAgICAgPGgxPjxiaWc+RWNsaXBzZSBNYXJrZXRwbGFjZSBMaXN0aW5nczwvYmlnPjwvaDE+Ci0KLSAgICAgICAgPGgyPjxiPjxiaWc+R29hbHMgb2YgdGhpcyBQcm9ncmFtPC9iaWc+PC9iPjwvaDI+Ci0gICAgICAgIDxwPlRoZSBtYWluIGdvYWwgb2YgdGhpcyBwcm9ncmFtIGlzIHRvIG9mZmVyIGEga2V5IGNoYW5uZWwgZm9yIG1lbWJlcnMgdG8gcHJvbW90ZSB0aGVpciBwcm9kdWN0cwotICAgICAgICB0byB0aGUgbWlsbGlvbnMgb2YgZGV2ZWxvcGVycyB3aG8gdXNlIEVjbGlwc2UgSURFJ3MgZXZlcnkgZGF5LiAgU3RhcnRpbmcgd2l0aCB0aGUgSGVsaW9zIHJlbGVhc2UKLSAgICAgICAgaW4gSnVuZSwgMjAxMCwgYSAiTWFya2V0cGxhY2UgQ2xpZW50IiBpcyBpbmNsdWRlZCB3aXRoIGFsbCBwYWNrYWdlcyBkb3dubG9hZGVkIGZyb20gRWNsaXBzZS5vcmcKLSAgICAgICAgdGhhdCBhbGxvd3MgZGV2ZWxvcGVycyB0byBicm93c2UgYW5kIGluc3RhbGwgRWNsaXBzZSBQbHVnaW5zLjwvcD4KLQotICAgICAgICA8cD5FY2xpcHNlIEZvdW5kYXRpb24gU29sdXRpb25zLCBFbnRlcnByaXNlIGFuZCBTdHJhdGVnaWMgTWVtYmVycyBsaXN0aW5ncwotICAgICAgICBtYXkgaGF2ZSB0aGVpciBFY2xpcHNlIE1hcmtldHBsYWNlIGxpc3RpbmdzIGFwcGVhciBpbiB0aGUKLSAgICAgICAgRWNsaXBzZSBNYXJrZXRwbGFjZSBDbGllbnQgV2l6YXJkLgotICAgICAgICBFY2xpcHNlIFNvbHV0aW9ucywgRW50ZXJwcmlzZSBhbmQgU3RyYXRlZ2ljIG1lbWJlcnMgd2lsbCBhbHNvIGhhdmUgdGhlaXIgcmVzdWx0cyBhcHBlYXIgZmlyc3QgKCJGZWF0dXJlZCIpIGluCi0gICAgICAgIGFueSBzZWFyY2ggcmVzdWx0cyBmcm9tIHRoZSBNYXJrZXRwbGFjZSBDbGllbnQgd2ViIGludGVyZmFjZS48L3A+Ci0KLSAgICAgICAgPHA+Rm9yIG1vcmUgaW5mb3JtYXRpb24sIHBsZWFzZSB2aXNpdDoKLSAgICAgICAgPHVsPgotICAgICAgICA8bGk+PGEgaHJlZj0iaHR0cDovL21hcmtldHBsYWNlLmVjbGlwc2Uub3JnLyI+RWNsaXBzZSBNYXJrZXRwbGFjZTwvYT48L2xpPgotICAgICAgICA8bGk+PGEgaHJlZj0iaHR0cDovL21hcmtldHBsYWNlLmVjbGlwc2Uub3JnL2NvbnRlbnQvbWFya2V0cGxhY2UtY2xpZW50LWNvbnRlbnQtaW5jbHVzaW9uLXBvbGljeS8iPk1hcmtldHBsYWNlIENsaWVudCBDb250ZW50IEluY2x1c2lvbiBQb2xpY3k8L2E+PC9saT4KLSAgICAgICAgPGxpPjxhIGhyZWY9Imh0dHA6Ly9tYXJrZXRwbGFjZS5lY2xpcHNlLm9yZy9xdWlja3N0YXJ0Ij5FY2xpcHNlIE1hcmtldHBsYWNlIFF1aWNrc3RhcnQgZm9yIExpc3RpbmcgeW91ciBQcm9kdWN0czwvYT48L2xpPgotICAgICAgICA8L3VsPgotCi0gICAgICAgIDwvcD4KLQotCi0KLQotICA8L2Rpdj48L2Rpdj4KLTw/cGhwCi0JJGh0bWwgPSBvYl9nZXRfY29udGVudHMoKTsKLQlvYl9lbmRfY2xlYW4oKTsKLQotCSMgR2VuZXJhdGUgdGhlIHdlYiBwYWdlCi0JJEFwcC0+Z2VuZXJhdGVQYWdlKE5VTEwsICRNZW51LCAkTmF2LCAkcGFnZUF1dGhvciwgJHBhZ2VLZXl3b3JkcywgJHBhZ2VUaXRsZSwgJGh0bWwpOwotPz4KZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvbWVtYmVyMm1lbWJlci5waHAgYi9zcGVjaWFsX3Byb2dyYW1zL21lbWJlcjJtZW1iZXIucGhwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmMmYyZDA1Li4wMDAwMDAwCi0tLSBhL3NwZWNpYWxfcHJvZ3JhbXMvbWVtYmVyMm1lbWJlci5waHAKKysrIC9kZXYvbnVsbApAQCAtMSw5OCArMCwwIEBACi08P3BocCAgCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vYXBwLmNsYXNzLnBocCIpOwlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9uYXYuY2xhc3MucGhwIik7IAlyZXF1aXJlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvZWNsaXBzZS5vcmctY29tbW9uL3N5c3RlbS9tZW51LmNsYXNzLnBocCIpOyAJJEFwcCAJPSBuZXcgQXBwKCk7CSROYXYJPSBuZXcgTmF2KCk7CSRNZW51IAk9IG5ldyBNZW51KCk7CQlpbmNsdWRlKCIuLi9fcHJvamVjdENvbW1vbi5waHAiKTsgICAgIyBBbGwgb24gdGhlIHNhbWUgbGluZSB0byB1bmNsdXR0ZXIgdGhlIHVzZXIncyBkZXNrdG9wJw0KLQ0KLSRwYWdlVGl0bGUgCQk9ICJNZW1iZXIyTWVtYmVyIjsNCi0kcGFnZUtleXdvcmRzCT0gIiI7DQotJHBhZ2VBdXRob3IJCT0gIiI7DQotDQotb2Jfc3RhcnQoKTsNCi0/Pg0KLTxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+DQotaDIgew0KLWJvcmRlci1ib3R0b206IHNvbGlkDQotfQ0KLWgzIHsNCi1ib3JkZXItYm90dG9tOiB0aGluIGRvdHRlZA0KLX0NCi08L3N0eWxlPg0KLQ0KLSAgICA8ZGl2IGlkPSJtYWluY29udGVudCI+DQotCTxkaXYgaWQ9Im1pZGNvbHVtbiI+DQotICAgICAgICA8aDE+PGJpZz5FY2xpcHNlIE1lbWJlcjJNZW1iZXIgTWFya2V0aW5nIFByb2dyYW08L2JpZz48L2gxPg0KLSAgICAgICAgICANCi0gICAgICAgIDxoMj48Yj48YmlnPkdvYWxzIG9mIHRoaXMgUHJvZ3JhbTwvYmlnPjwvYj48L2gyPg0KLSAgICAgICAgPHA+VGhpcyBwcm9ncmFtIGhhcyB0d28gbWFpbiBnb2Fsczo8L3A+DQotICAgICAgICANCi0gICAgICAgIDxvbD4NCi0gICAgICAgICAgIDxsaT5PZmZlciBhIGNoYW5uZWwgZm9yIG1lbWJlcnMgdG8gcHJvbW90ZSB0aGVpciBwcm9kdWN0cyBhbmQgc2VydmljZXMgZXhjbHVzaXZlbHkgdG8gdGhlIEVjbGlwc2UgTWVtYmVyc2hpcC48L2xpPg0KLSAgICAgICAgICAgPGxpPkFsbG93IG1lbWJlcnMgdG8gYmVuZWZpdCBmcm9tIHByb2R1Y3QgYW5kIHNlcnZpY2Ugc3BlY2lhbCBvZmZlcnMgbm90IGF2YWlsYWJsZSBlbHNld2hlcmUuPC9saT4NCi0gICAgICAgIDwvb2w+DQotDQotICAgICAgICA8cD5UaGlzIHByb2dyYW0gaXMgYWJvdXQgZW5jb3VyYWdpbmcgRWNsaXBzZSBNZW1iZXIgY29tcGFuaWVzIHRvDQotICAgICAgICBpbnRlcmFjdCB3aXRoIGVhY2ggb3RoZXIgYnkgcHJvdmlkaW5nIGEgY2hhbm5lbCB0byBvZmZlciBwcm9kdWN0cyBhbmQNCi0gICAgICAgIHNlcnZpY2VzIHNwZWNpZmljIHRvIEVjbGlwc2UgbWVtYmVycy48L3A+DQotICAgICAgICANCi0gICAgICAgIDxoMj48Yj48YmlnPkhvdyBkbyBJIHBhcnRpY2lwYXRlPzwvYmlnPjwvYj48L2gyPg0KLSAgICAgICAgPHA+RW1haWwgPGEgaHJlZj0ibWFpbHRvOm1lbWJlcjJtZW1iZXJAZWNsaXBzZS5vcmciPm1lbWJlcjJtZW1iZXJAZWNsaXBzZS5vcmc8L2E+IHdpdGggdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbjoNCi0gICAgICAgIDxvbD4NCi0gICAgICAgICAgPGxpPlRpdGxlOiBOb3QgbW9yZSB0aGFuIDQwIENoYXJhY3RlcnM8L2xpPg0KLSAgICAgICAgICA8bGk+Qm9keTogTm90IG1vcmUgdGhhbiAxMDAgQ2hhcmFjdGVyczwvbGk+DQotICAgICAgICAgIDxsaT5VUkwgVGl0bGU6IE5vdCBtb3JlIHRoYW4gMTUgQ2hhcmFjdGVyczwvbGk+DQotICAgICAgICAgIDxsaT5VUkwgVGFyZ2V0PC9saT4NCi0gICAgICAgIDwvb2w+DQotCQk8L3A+DQotCQkNCi0JCSAgICAgIDxwPkV4YW1wbGUgMTo8YnI+DQotPGI+U2F2ZSAyMCUgb2ZmIE1lZ2FDb248L2I+PGJyPg0KLU1lZ2FDb24nMDgsIEh5YXR0IFJlc3Rvbjxicj4NCi1KdW5lIDIwLTI0LiAgTGVhcm4gbmV3PGJyPg0KLU1lZ2EgRmVhdHVyZXMuICBNZWV0IHRoZTxicj4NCi1leHBlcnRzIG9mIE1lZ2EhPGJyPg0KLTxhIGhyZWY9IiI+UmVnaXN0ZXIgTm93Li4uPC9hPjxicj4NCi0NCi0JCTwvcD4JDQotCQkgICAgICA8cD5FeGFtcGxlIDI6PGJyPg0KLTxiPjMzJSBPZmYgTWlzdGEgNC4wPC9iPiA8YnI+DQotVXNlIGNvdXBvbiBjb2RlIEVDTUVNMzM8YnI+DQotYW5kIHNhdmUgMzMlIG9uIGxhdGVzdDxicj4NCi1NaXN0YSByZWxlYXNlLiAgR3JlYXQ8YnI+DQotU29mdHdhcmUgcHJvZHVjdCE8YnI+DQotPGEgaHJlZj0iIj5GcmVlIFRyaWFsLi4uPC9hPjxicj4NCi0NCi0JCSAgICAgIDxwPkV4YW1wbGUgMzo8YnI+DQotPGI+RnJlZSBBZG9wdGlvbiBTdXJ2ZXk8L2I+PGJyPg0KLUp1c3QgcmVsZWFzZWQgMjAwOCB0b29sIHVzZTxicj4NCi10cmVuZHMgc3VydmV5IHJlc3VsdHMuPGJyPg0KLTxhIGhyZWY9IiI+U2VlIFJlc3VsdHMuLi48L2E+PGJyPg0KLQkJPC9wPg0KLSAgICAgICAgICANCi0gICAgICAgIDxoMj48YmlnPjxiPkZBUTwvYj48L2JpZz48L2gyPg0KLQkJPGI+SG93IG11Y2ggZG9lcyBpdCBjb3N0PzwvYj4NCi0gICAgICAgIDxwPlRoaXMgaXMgYSBmcmVlIHNlcnZpY2UgZm9yIEVjbGlwc2UgRm91bmRhdGlvbiBNZW1iZXJzIG9ubHkuDQotICAgICAgICA8L3A+DQotDQotICAgICAgICA8Yj5XaGVuIHdpbGwgbXkgb2ZmZXIgQXBwZWFyPzwvYj4NCi0gICAgICAgIDxwPkVjbGlwc2UgbWVtYmVyc2hpcCBuZXdzbGV0dGVycyBhcmUgcGxhbm5lZCBtb250aGx5LiAgDQotICAgICAgICBUaGVyZSBpcyBsaW1pdGVkIE1lbWJlcjJNZW1iZXINCi0gICAgICAgIHNwYWNlIGF2YWlsYWJsZSBpbiBlYWNoIG5ld3NsZXR0ZXIuICBQcmlvcml0eSB3aWxsIGJlIGdpdmVuIGZpcnN0LWNvbWUtZmlyc3Qtc2VydmUgYmFzaXMuDQotICAgICAgICBZb3Ugd2lsbCBiZSBhZHZpc2VkIHdoZW4geW91IHN1Ym1pdCB5b3VyIGNvbnRlbnQgYW4gZXhwZWN0ZWQgZGF0ZS4NCi0gICAgICAgIDwvcD4NCi0NCi0gICAgICAgIDxiPkNhbiB3ZSBwcm9tb3RlIGEgRnJlZSBQcm9kdWN0L1NlcnZpY2U/PC9iPg0KLSAgICAgICAgPHA+WWVzLCBidXQgb25seSBkZXBlbmRpbmcgb24gc3BhY2UgYXZhaWxhYmlsaXR5IC0tIHByaW9yaXR5IHdpbGwgYmUgZ2l2ZW4gdG8gbWVtYmVyMm1lbWJlciBvZmZlcnMNCi0gICAgICAgIHRoYXQgb2ZmZXIgYSB0YW5naWJsZSBzYXZpbmdzL2JlbmVmaXQgZXhjbHVzaXZlbHkgZm9yIG90aGVyIEVjbGlwc2UgTWVtYmVycy4NCi0gICAgICAgIDwvcD4NCi0NCi0gICAgICAgIDxiPkhvdyBtYW55IHBlb3BsZSByZWNlaXZlIHRoZSBuZXdzbGV0dGVyPzwvYj4NCi0gICAgICAgIDxwPlRoZXJlIGFyZSBhcHByb3hpbWF0ZWx5IDUwMCByZWNlcGllbnRzIG9mIHRoZSBGb3VuZGF0aW9uIE5ld3NsZXR0ZXIuDQotICAgICAgICA8L3A+DQotICAgDQotDQotICAgICAgDQotICA8L2Rpdj48L2Rpdj4NCi08P3BocA0KLQkkaHRtbCA9IG9iX2dldF9jb250ZW50cygpOw0KLQlvYl9lbmRfY2xlYW4oKTsNCi0NCi0JIyBHZW5lcmF0ZSB0aGUgd2ViIHBhZ2UNCi0JJEFwcC0+Z2VuZXJhdGVQYWdlKCR0aGVtZSwgJE1lbnUsICROYXYsICRwYWdlQXV0aG9yLCAkcGFnZUtleXdvcmRzLCAkcGFnZVRpdGxlLCAkaHRtbCk7DQotPz4NCmRpZmYgLS1naXQgYS9zcGVjaWFsX3Byb2dyYW1zL3Byb21vdGlvbl9wcm9ncmFtL3BhbGV0dGUuZ2lmIGIvc3BlY2lhbF9wcm9ncmFtcy9wcm9tb3Rpb25fcHJvZ3JhbS9wYWxldHRlLmdpZgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjU3NzM2ZC4uMDAwMDAwMAotLS0gYS9zcGVjaWFsX3Byb2dyYW1zL3Byb21vdGlvbl9wcm9ncmFtL3BhbGV0dGUuZ2lmCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvc3BlY2lhbF9wcm9ncmFtcy9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW4xLmdpZiBiL3NwZWNpYWxfcHJvZ3JhbXMvcHJvbW90aW9uX3Byb2dyYW0vc2NyZWVuMS5naWYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI5NmFhYjAuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW4xLmdpZgorKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvcHJvbW90aW9uX3Byb2dyYW0vc2NyZWVuMi5naWYgYi9zcGVjaWFsX3Byb2dyYW1zL3Byb21vdGlvbl9wcm9ncmFtL3NjcmVlbjIuZ2lmCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0YzRmNmFjLi4wMDAwMDAwCi0tLSBhL3NwZWNpYWxfcHJvZ3JhbXMvcHJvbW90aW9uX3Byb2dyYW0vc2NyZWVuMi5naWYKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9zcGVjaWFsX3Byb2dyYW1zL3Byb21vdGlvbl9wcm9ncmFtL3NjcmVlbjMuZ2lmIGIvc3BlY2lhbF9wcm9ncmFtcy9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW4zLmdpZgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDM4NWIyMi4uMDAwMDAwMAotLS0gYS9zcGVjaWFsX3Byb2dyYW1zL3Byb21vdGlvbl9wcm9ncmFtL3NjcmVlbjMuZ2lmCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvc3BlY2lhbF9wcm9ncmFtcy9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW40LmdpZiBiL3NwZWNpYWxfcHJvZ3JhbXMvcHJvbW90aW9uX3Byb2dyYW0vc2NyZWVuNC5naWYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI5MTBiYzQuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9wcm9tb3Rpb25fcHJvZ3JhbS9zY3JlZW40LmdpZgorKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvcHVibGljL2ltYWdlcy9zY3JlZW5zaG90LmpwZyBiL3NwZWNpYWxfcHJvZ3JhbXMvcHVibGljL2ltYWdlcy9zY3JlZW5zaG90LmpwZwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmY4OWJiOS4uMDAwMDAwMAotLS0gYS9zcGVjaWFsX3Byb2dyYW1zL3B1YmxpYy9pbWFnZXMvc2NyZWVuc2hvdC5qcGcKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9zcGVjaWFsX3Byb2dyYW1zL3NsaWRlcy9ldmFucy5wZGYgYi9zcGVjaWFsX3Byb2dyYW1zL3NsaWRlcy9ldmFucy5wZGYKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGVjY2IwNTUuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy9zbGlkZXMvZXZhbnMucGRmCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvc3BlY2lhbF9wcm9ncmFtcy92aWRlb3Nwb25zb3JzL3ZpZGVvbGF5b3V0LnBuZyBiL3NwZWNpYWxfcHJvZ3JhbXMvdmlkZW9zcG9uc29ycy92aWRlb2xheW91dC5wbmcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDUwOGIxMmMuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy92aWRlb3Nwb25zb3JzL3ZpZGVvbGF5b3V0LnBuZworKysgL2Rldi9udWxsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL3NwZWNpYWxfcHJvZ3JhbXMvdmlkZW9zcG9uc29ycy92aWRlb2xpc3QucGhwIGIvc3BlY2lhbF9wcm9ncmFtcy92aWRlb3Nwb25zb3JzL3ZpZGVvbGlzdC5waHAKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDI5MzVmYzEuLjAwMDAwMDAKLS0tIGEvc3BlY2lhbF9wcm9ncmFtcy92aWRlb3Nwb25zb3JzL3ZpZGVvbGlzdC5waHAKKysrIC9kZXYvbnVsbApAQCAtMSwxMDYgKzAsMCBAQAotPD9waHAgIAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL2FwcC5jbGFzcy5waHAiKTsJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbmF2LmNsYXNzLnBocCIpOyAJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbWVudS5jbGFzcy5waHAiKTsgCSRBcHAgCT0gbmV3IEFwcCgpOwkkTmF2CT0gbmV3IE5hdigpOwkkTWVudSAJPSBuZXcgTWVudSgpOwkJaW5jbHVkZSgiLi4vX3Byb2plY3RDb21tb24ucGhwIik7ICAgICMgQWxsIG9uIHRoZSBzYW1lIGxpbmUgdG8gdW5jbHV0dGVyIHRoZSB1c2VyJ3MgZGVza3RvcCcNCi0NCi0kcGFnZVRpdGxlIAkJPSAiRWNsaXBzZUNvbiAyMDA5IFZpZGVvIExpc3QiOw0KLSRwYWdlS2V5d29yZHMJPSAiIjsNCi0kcGFnZUF1dGhvcgkJPSAiIjsNCi0NCi1vYl9zdGFydCgpOw0KLT8+DQotPHN0eWxlIHR5cGU9InRleHQvY3NzIj4NCi1oMiB7DQotYm9yZGVyLWJvdHRvbTogc29saWQNCi19DQotaDMgew0KLWJvcmRlci1ib3R0b206IHRoaW4gZG90dGVkDQotfQ0KLTwvc3R5bGU+DQotDQotICAgIDxkaXYgaWQ9Im1haW5jb250ZW50Ij4NCi0JPGRpdiBpZD0ibWlkY29sdW1uIj4NCi0gICAgICAgIDxoMT48YmlnPldlYmNhc3QgU3BvbnNvcnNoaXAgT3Bwb3J0dW5pdHkgLSBUaGUgRWNsaXBzZUNvbiBSZWNvcmRpbmdzPC9iaWc+PC9oMT4NCi0NCi08cD4NCi1TZXZlcmFsIHNlc3Npb25zIGZyb20gRWNsaXBzZUNvbiAyMDA5IHdlcmUgcmVjb3JkZWQgKGF1ZGlvIGFuZCBzbGlkZXMpIGFuZCB3ZSBhcmUgb2ZmZXJpbmcgRWNsaXBzZUNvbiANCi1zcG9uc29ycyBhbmQgRWNsaXBzZSBGb3VuZGF0aW9uIG1lbWJlcnMgdGhlIGFiaWxpdHkgdG8gc3BvbnNvciB0aGUgcHJvZHVjZWQgd2ViY2FzdHMuICANCi1UaGVzZSB3ZWJjYXN0cyB3aWxsIGJlIGhvc3RlZCBvbiA8YSBocmVmPSJodHRwOi8vbGl2ZS5lY2xpcHNlLm9yZyI+bGl2ZS5lY2xpcHNlLm9yZzwvYT4uICBJbiBvcmRlciB0byBoZWxwIHByb21vdGUgdGhlIHdlYmNhc3RzIA0KLW9uIGxpdmUuZWNsaXBzZS5vcmcsIHdlIHdpbGwgcnVuIGEgbWFya2V0aW5nIGNhbXBhaWduIGZyb20gZWNsaXBzZS5vcmcgYW5kL29yIGVjbGlwc2Vjb24ub3JnIHByb21vdGluZyB0aGUgdmlkZW8gYW5kIHlvdXIgc3BvbnNvcnNoaXAuDQotPC9wPg0KLQ0KLTxwPg0KLVNwb25zb3JzaGlwcyBhcmUgJDk5NSBwZXIgd2ViY2FzdCwgb3IgMyBmb3IgJDI1MDAgLS0gYW5kIEVjbGlwc2VDb24gc3BvbnNvcnMgd2lsbCByZWNlaXZlIGEgMTAlIGRpc2NvdW50LiAgVGhlcmUgaXMgZmxleGliaWxpdHkNCi1vbiBkaXNjb3VudHMgZm9yIGJ1bGsgd2ViY2FzdCBzcG9uc29yc2hpcHMgLS0gcGxlYXNlIGNvbnRhY3QgdXMgZm9yIGluZm9ybWF0aW9uLg0KLQ0KLUVjbGlwc2VDb24gc3BvbnNvcnMgaGF2ZSBmaXJzdCBkaWJzIHRocm91Z2ggQXByaWwgMjB0aCwgYWZ0ZXIgd2hpY2ggd2UnbGwgb3BlbiB1cCB0aGUgc3BvbnNvcnNoaXBzIHRvIGFsbCBFY2xpcHNlIG1lbWJlcnMuDQotDQotUGxlYXNlIGNvbnRhY3QgPGEgaHJlZj0ibWFpbHRvOm1lbWJlcnNoaXBAZWNsaXBzZS5vcmciPm1lbWJlcnNoaXBAZWNsaXBzZS5vcmc8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uLg0KLQ0KLTwvcD4NCi0NCi08aDI+V2hhdCB5b3UgZ2V0IHdpdGggeW91ciBzcG9uc29yc2hpcDwvaDI+DQotPGltZyBzcmM9Ii4vdmlkZW9sYXlvdXQucG5nIj4NCi08YnI+DQotPHVsPg0KLTxsaT5TcG9uc29yZWQgYmFubmVyLCBsb2dvIGFuZCB0d28gYWRkaXRpb25hbCBsaW5rcyBvbiB3ZWJjYXN0IHBsYXllcjwvbGk+DQotPGxpPlByb21vdGlvbiBvZiB0aGUgd2ViY2FzdCBhbmQgeW91ciBzcG9uc29yc2hpcCBvbiBlY2xpcHNlLm9yZyBhbmQvb3IgZWNsaXBzZWNvbi5vcmcgdG8gZHJpdmUgdHJhZmZpYyB0byB0aGUgd2ViY2FzdDwvbGk+DQotPGxpPkNvbW11bml0eSBCdWxsZXRpbiBvbiBlY2xpcHNlLm9yZyBub3Rpbmcgc3BvbnNvcnNoaXAgYW5kIHdlYmNhc3QgYXZhaWxhYmlsaXR5PC9saT4NCi08L3VsPg0KLQ0KLQ0KLTxoMj5UaGUgRWNsaXBzZUNvbiBSZWNvcmRpbmdzPC9oMj4gICAgICAgICAgDQotPHRhYmxlPiAgICAgICAgDQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MjI5Ij5Db252ZXJnZW5jZSBpbiBkZXZpY2Ugc29mdHdhcmUgLSBVc2UgdGhlIFRtTCBwcm9qZWN0IHRvIGNyZWF0ZSB0b29scyBmb3IgbW9iaWxlIExpbnV4IGRldmVsb3BlcnM8L2E+PC90ZD48dGQ+CUVyaWMgQ2xvbmluZ2VyLE1hdXJlbiBCcmVubmVyPC90ZD48L3RyPg0KLTx0cj48dGQ+VW5hdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MjU1Ij5FY2xpcHNlIEAgZUJheTwvYT48L3RkPjx0ZD4JCU1pY2hhZWwgR2FscGluPC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+VW5hdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MjU2Ij5HbGFzc0Zpc2ggdjMgYW5kIE9TR2k6IERldmVsb3Bpbmcgb24gRWNsaXBzZSBhbmQgcnVubmluZyB0aGUgZnV0dXJlIEphdmEgRUUgNiBBcHBsaWNhdGlvbiBTZXJ2ZXIgb24gdG9wIG9mIE9TR2kgRXF1aW5veDwvYT48L3RkPjx0ZD4JCUplcm9tZSBEb2NoZXosTHVkb3ZpYyBDaGFtcGVub2lzPC90ZD48L3RyPg0KLTx0cj48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTI2MiI+U2xlZXBpbmcgQXJvdW5kOiBXcml0aW5nIHRvb2xzIHRoYXQgd29yayBpbiBFY2xpcHNlLCBWaXN1YWwgU3R1ZGlvLCBSdWJ5LCBhbmQgdGhlIFdlYjwvYT48L3RkPjx0ZD4JCUplYW4tTWljaGVsIExlbWlldXg8L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5VbmF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD0yNzEiPlBERSBTdGF0ZSBvZiB0aGUgVW5pb248L2E+PC90ZD48dGQ+CQlDaHJpcyBBbmlzemN6eWssQW5kcmV3IE5pZWZlcixEYXJpbiBXcmlnaHQ8L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9Mjk0Ij5CdWlsZGluZyBDb21tdW5pdGllczogVGhlIFJpc2UgYW5kIEZhbGwgYW5kIFJpc2Ugb2YgdGhlIENEVCBQcm9qZWN0PC9hPjwvdGQ+PHRkPgkJRG91ZyBTY2hhZWZlcjwvdGQ+PC90cj4NCi08dHIgQkdDT0xPUj0iI0M3QkNFNiI+PHRkPlVuYXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTMyNCI+UmV2ZXJzZSBkZWJ1Z2dpbmcsIE11bHRpLVByb2Nlc3MgYW5kIE5vbi1zdG9wIGRlYnVnZ2luZyBjb21lIHRvIHRoZSBDRFQ8L2E+PC90ZD48dGQ+CQlGcmFuY29pcyBDaG91aW5hcmQsTWFyYyBLaG91emFtPC90ZD48L3RyPg0KLTx0cj48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTMzMCI+UkFQIG9yIEdXVDogV2hpY2ggSmF2YS1CYXNlZCBBSkFYIFRlY2hub2xvZ3kgSXMgZm9yIFlvdT88L2E+PC90ZD48dGQ+CQlEYW4gUnViZWwsTWFyayBSdXNzZWxsPC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTMzMiI+RXhlY3V0aW5nIEJQTU48L2E+PC90ZD48dGQ+CQlLb2VuIEFlcnM8L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MzM4Ij5NYXggYW5kIEpvaG4ncyBFeGNlbGxlbnQgUGx1Zy1pbiBBZHZlbnR1cmU6IFRoZSBIaWdobGlnaHQgUmVlbDwvYT48L3RkPjx0ZD4JCUpvaG4gR3JhaGFtLE1heCBSeWRhaGwgQW5kZXJzZW48L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MzQ3Ij5QbHVnaW4gcmV1c2UgYW5kIGFkYXB0YXRpb24gd2l0aCBPYmplY3QgVGVhbXM6IERvbid0IHNldHRsZSBmb3IgYSBjb21wcm9taXNlITwvYT48L3RkPjx0ZD4JCVN0ZXBoYW4gSGVycm1hbm48L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MzUzIj5XZWIgdG8gZGVza3RvcCwgZGVza3RvcCB0byB3ZWI8L2E+PC90ZD48dGQ+CQlCb3JpcyBCb2tvd3NraSxTdGV2ZSBOb3J0aG92ZXI8L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5VbmF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD0zNTgiPlRoZSBVbmJlYXJhYmxlIFN0dXBpZGl0eSBvZiBNb2RlbGluZzwvYT48L3RkPjx0ZD4JCVBldGVyIEZyaWVzZTwvdGQ+PC90cj4NCi08dHI+PHRkPlVuYXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTM1OSI+QmVuZGluZyBFY2xpcHNlIHRvIFlvdXIgV2lsbDogRnJvbSBFTlZZL1NtYWxsdGFsayB0byBXcmF0aDwvYT48L3RkPjx0ZD4JCUdhYnJpZWwgQ2FzdHJvPC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTM2MiI+QnVpbGRpbmcgTGlua2VkSW4ncyBOZXh0IEdlbmVyYXRpb24gQXJjaGl0ZWN0dXJlIHdpdGggT1NHSTwvYT48L3RkPjx0ZD4JCVlhbiBQdWphbnRlPC90ZD48L3RyPg0KLTx0cj48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTM2MyI+QWR2YW5jZWQgQklSVCBSZXBvcnQgQ3VzdG9taXphdGlvbjwvYT48L3RkPjx0ZD4JCVZpcmdpbCBEb2Rzb248L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MzcwIj5BbmRyb2lkIGFuZCB0aGUgRWNsaXBzZSBFY29zeXN0ZW08L2E+PC90ZD48dGQ+CQlYYXZpZXIgRHVjcm9oZXQ8L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9MzcyIj5CdWlsZGluZyB5b3VyIGZpcnN0IEpQQSBhcHBsaWNhdGlvbiB3aXRoIERhbGkgSlBBIFRvb2xzPC9hPjwvdGQ+PHRkPgkJTmVpbCBIYXVnZSxTaGF1biBTbWl0aDwvdGQ+PC90cj4NCi08dHIgQkdDT0xPUj0iI0M3QkNFNiI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD0zOTgiPlNNSUxBIC0gbWFrZSBzZW5zZSBvZiB5b3VyIGRhdGE8L2E+PC90ZD48dGQ+CQlJZ29yIE5vdmFrb3ZpYyxTZWJhc3RpYW4gVm9pZ3Q8L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NDAxIj5CbHVlcHJpbnQgU2VydmljZTogRW50ZXJwcmlzZSBQcm9ncmFtbWluZyBNb2RlbCBmb3IgT1NHaTwvYT48L3RkPjx0ZD4JCUNvc3RpbiBMZWF1PC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTQzMCI+RWNsaXBzZSBvbiBSYWlscyBhbmQgUm9ja2V0czwvYT48L3RkPjx0ZD4JCUdpbGxlcyBKLiBJYWNoZWxpbmksTWFyYyBSLiBIb2ZmbWFubixNYXJrIFBvd2VsbDwvdGQ+PC90cj4NCi08dHI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD00MzYiPk5leHQgZ2VuZXJhdGlvbiB0ZXh0dWFsIERTTHMgd2l0aCBYdGV4dDwvYT48L3RkPjx0ZD4JCUphbiBLb2VobmxlaW4sU3ZlbiBFZmZ0aW5nZTwvdGQ+PC90cj4NCi08dHIgQkdDT0xPUj0iI0M3QkNFNiI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD00NDYiPk1peGluZyBFY2xpcHNlIFRlY2hub2xvZ2llcyB0byBjcmVhdGUgRW50ZXJwcmlzZSBSZWFkeSBEYXRhYmFzZS1SQ1AtRnJvbnRlbmRzPC9hPjwvdGQ+PHRkPgkJVGhvbWFzIFNjaGluZGw8L3RkPjwvdHI+DQotPHRyPjx0ZD5VbmF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD00NjMiPmU0IC0gZmxleGlibGUgcmVzb3VyY2VzIGZvciBuZXh0IGdlbmVyYXRpb24gYXBwbGljYXRpb25zIGFuZCB0b29sczwvYT48L3RkPjx0ZD4JCU1hcnRpbiBPYmVyaHViZXI8L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NTI1Ij5XZWIgU2VydmljZXMgVG9vbHMgaW4gdGhlIEVjbGlwc2UgV2ViIFRvb2xzIFBsYXRmb3JtPC9hPjwvdGQ+PHRkPgkJS2F0aHkgQ2hhbjwvdGQ+PC90cj4NCi08dHI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD01MzAiPklQIGZvciBFY2xpcHNlIENvbW1pdHRlcnM8L2E+PC90ZD48dGQ+CQlKYW5ldCBDYW1wYmVsbDwvdGQ+PC90cj4NCi08dHIgQkdDT0xPUj0iI0M3QkNFNiI+PHRkPlVuYXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTU1MiI+QWR2YW5jZWQgVG9waWNzIGluIHRoZSBDb21tb24gTmF2aWdhdG9yIEZyYW1ld29yazwvYT48L3RkPjx0ZD4JIAlGcmFuY2lzIFVwdG9uIElWPC90ZD48L3RyPg0KLTx0cj48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTU2NSI+VGhlIE1vZGVsZWQgVUkgaW4gRWNsaXBzZSBlNDwvYT48L3RkPjx0ZD4JCU1hcmNlbG8gUGF0ZXJub3N0cm8sVGhvbWFzIFNjaGluZGwsQm9yaXMgQm9rb3dza2ksUGF1bCBXZWJzdGVyPC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTU3MyI+RnJvbSBEYXRhIHRvIEludGVsbGlnZW5jZSBpbiAxNyBDbGlja3M8L2E+PC90ZD48dGQ+CQlTZXRoIEdyaW1lcyxTY290dCBSb3NlbmJhdW08L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NTk5Ij5Gcm9tIHNvdXJjZSB0byBhdXRvbWF0ZWQgYnVpbGRzIHdpdGggQnVja21pbnN0ZXIgYW5kIHAyPC9hPjwvdGQ+PHRkPgkJSGVucmlrIExpbmRiZXJnLFRob21hcyBIYWxsZ3JlbjwvdGQ+PC90cj4NCi08dHIgQkdDT0xPUj0iI0M3QkNFNiI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD02MDQiPmU0IFByb2plY3QgaW4gUmV2aWV3PC9hPjwvdGQ+PHRkPgkJTWFydGluIE9iZXJodWJlcixTdGV2ZSBOb3J0aG92ZXIsQmVuIEdhbGJyYWl0aCxKb2NoZW4gS3JhdXNlLEtldmluIE1jR3VpcmU8L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NjEzIj5SdW50aW1lIChyKWV2b2x1dGlvbiBhdCBFY2xpcHNlPC9hPjwvdGQ+PHRkPgkJSmVmZiBNY0FmZmVyPC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTYyOSI+VGFrZSB0aGUgZmF0IG1hbiBvZmYgeW91ciBhcHBsaWNhdGlvbiBhbmQgaXQgd2lsbCBydW4gZmFzdGVyLjwvYT48L3RkPjx0ZD4JCVBhdHJpY2sgRGVtcHNleTwvdGQ+PC90cj4NCi08dHI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD02MzYiPlRoZSBlNCBQcm9ncmFtbWluZyBNb2RlbCBBY3Jvc3MgV2ViIGFuZCBEZXNrdG9wPC9hPjwvdGQ+PHRkPgkJQm9yaXMgQm9rb3dza2k8L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NjQ0Ij5TeW1tZXRyaWMgU2VydmljZSBPcmllbnRlZCBQcm9ncmFtbWluZzwvYT48L3RkPjx0ZD4JCUJKIEhhcmdyYXZlPC90ZD48L3RyPg0KLTx0cj48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTY1NiI+SWRlbnRpdHkgTWFuYWdlbWVudCBpbiBZb3VyIFJDUCBBcHBsaWNhdGlvbiB3aXRoIEhpZ2dpbnM8L2E+PC90ZD48dGQ+CQlHdW5uYXIgV2FnZW5rbmVjaHQsRnJhbmsgR2VyaGFyZHQsSm9jaGVuIEhpbGxlcixNYXJ5IFJ1ZGR5PC90ZD48L3RyPg0KLTx0ciBCR0NPTE9SPSIjQzdCQ0U2Ij48dGQ+QXZhaWxhYmxlPC90ZD48dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlY29uLm9yZy8yMDA5L3Nlc3Npb25zP2lkPTcxOSI+V29ya2luZyBpbiB0aGUgQ2xvdWQ6IERldmVsb3BtZW50LCBEZXBsb3ltZW50IGFuZCBQcm9qZWN0IE1hbmFnZW1lbnQgZm9yIEZvcmNlLmNvbTwvYT48L3RkPjx0ZD4JCURhdmUgQ2Fycm9sbDwvdGQ+PC90cj4NCi08dHI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD03NTMiPkpldHR5IEAgRWNsaXBzZTwvYT48L3RkPjx0ZD4JCUdyZWcgV2lsa2luczwvdGQ+PC90cj4NCi08dHIgQkdDT0xPUj0iI0M3QkNFNiI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD00MzUiPkVjbGlwc2UgU3dvcmRmaXNogiBhbiBvcGVuIHNvdXJjZSBTT0EgcnVudGltZSBmcmFtZXdvcmsgZm9yIHRoZSBlbnRlcnByaXNlPC9hPjwvdGQ+PHRkPk9saXZlciBXb2xmLERpZXRtYXIgV29sejwvdGQ+PC90cj4NCi08dHI+PHRkPkF2YWlsYWJsZTwvdGQ+PHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZWNvbi5vcmcvMjAwOS9zZXNzaW9ucz9pZD0zODMiPkV4cGVyaWVuY2VzIFZpc3VhbGl6aW5nIEFuZHJvaWQgUGVyZm9ybWFuY2UgaW4gRWNsaXBzZSBUUFRQPC9hPjwvdGQ+PHRkPkNocmlzIEVsZm9yZCwgWXVuYW4gSGU8L3RkPjwvdHI+DQotPHRyIEJHQ09MT1I9IiNDN0JDRTYiPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NjEyIj5FbnRlcnByaXNlIEJ1aWxkIFN5c3RlbTogTW9kZWwgRHJpdmVuIEFyY2hpdGVjdHVyZSBvbiBQREUgQnVpbGQgcnVudGltZTwvYT48L3RkPjx0ZD5LYWdhbiBUdXJndXQ8L3RkPjwvdHI+DQotPHRyPjx0ZD5BdmFpbGFibGU8L3RkPjx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Vjb24ub3JnLzIwMDkvc2Vzc2lvbnM/aWQ9NzQ1Ij5FY2xpcHNlIFByb2plY3QgU3BvdGxpZ2h0PC9hPjwvdGQ+PHRkPlZhcmlvdXMgRWNsaXBzZSBQcm9qZWN0IExlYWRlcnM8L3RkPjwvdHI+DQotDQotDQotPC90YWJsZT4gICAgICAgIA0KLSAgICAgICAgDQotDQotPGJyPiA8YnI+DQotICA8L2Rpdj48L2Rpdj4NCi08P3BocA0KLQkkaHRtbCA9IG9iX2dldF9jb250ZW50cygpOw0KLQlvYl9lbmRfY2xlYW4oKTsNCi0NCi0JIyBHZW5lcmF0ZSB0aGUgd2ViIHBhZ2UNCi0JJEFwcC0+Z2VuZXJhdGVQYWdlKCR0aGVtZSwgJE1lbnUsICROYXYsICRwYWdlQXV0aG9yLCAkcGFnZUtleXdvcmRzLCAkcGFnZVRpdGxlLCAkaHRtbCk7DQotPz4NCg==