PCEtLSBzYXZlZCBmcm9tIHVybD0oMDAyMilodHRwOi8vaW50ZXJuZXQuZS1tYWlsIC0tPg0KPCFkb2N0eXBlIGh0bWwgcHVibGljICItLy93M2MvL2R0ZCBodG1sIDQuMCB0cmFuc2l0aW9uYWwvL2VuIj4NCjxodG1sPg0KPGhlYWQ+DQogICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4NCiAgIDxtZXRhIG5hbWU9IkF1dGhvciIgY29udGVudD0iRWNsaXBzZSBQcm9qZWN0Ij4NCiAgIDx0aXRsZT5Ub3dhcmRzIE1vcmUgRmxleGlibGUgUHJvamVjdCBTdHJ1Y3R1cmU8L3RpdGxlPg0KICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9kZWZhdWx0X3N0eWxlLmNzcyIgdHlwZT0idGV4dC9jc3MiPg0KPC9oZWFkPg0KPGJvZHkgYmdjb2xvcj0iI0ZGRkZGRiIgPg0KDQo8ZGl2IGFsaWduPSJsZWZ0Ij4gDQogIDxoMT4gVG93YXJkcyBNb3JlIEZsZXhpYmxlIFByb2plY3QgU3RydWN0dXJlPC9oMT4NCjwvZGl2Pg0KPGJsb2NrcXVvdGU+IA0KICA8cD48Yj5TdW1tYXJ5PC9iPiA8YnI+DQogIEVjbGlwc2UgcmVxdWlyZXMgdGhhdCB0aGUgY29udGVudHMgb2YgZWFjaCBwcm9qZWN0IGJlIHN0b3JlZCBpbiBhIHNpbmdsZSBkaXJlY3Rvcnkgb24gZGlzay4NCiAgRXZlcnkgZmlsZSBhbmQgZm9sZGVyIGluIHRoYXQgZGlyZWN0b3J5IHRyZWUgb24gZGlzayBtdXN0IGJlbG9uZyB0byB0aGUgcHJvamVjdCBpbiB0aGUgd29ya3NwYWNlLg0KICBUaGlzIHJlc3RyaWN0aW9uIG1ha2VzIGl0IGRpZmZpY3VsdCB0byB1c2UgRWNsaXBzZSBpbiBjb25qdW5jdGlvbiB3aXRoIHRvb2xzIHRoYXQgaGF2ZSBzcGVjaWZpYyBsYXlvdXQNCiAgcmVxdWlyZW1lbnRzIGZvciB0aGVpciBmaWxlcywgb3Igd2l0aCB1c2VycyB3aG8gaGF2ZSBsZWdhY3kgZmlsZSBiYXNlIGxheW91dHMgdGhhdCB0aGV5IG5lZWQNCiAgdG8gbWFpbnRhaW4uIFdlIHdvdWxkIGxpa2UgdG8gaW1wcm92ZSB0aGUgc2l0dWF0aW9uIGZvciB0aGUgMi4xIHJlbGVhc2Ugb2YNCiAgRWNsaXBzZS4gVGhlcmUgaXMgYSBzZXBhcmF0ZSwgZmlyc3QgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9lY2xpcHNlL2RldmVsb3BtZW50L2luZmxleGlibGUtcHJvamVjdHMtcHJvYmxlbS5odG1sIj5kb2N1bWVudA0KICBkZXNjcmliaW5nIHRoZSBuYXR1cmUgb2YgdGhlIHByb2JsZW08L2E+LiBUaGlzIGRvY3VtZW50IGV4cGxvcmVzIHRoZSBzcGFjZSBvZg0KICBwb3RlbnRpYWwgc29sdXRpb25zLCB3aXRob3V0IGRyaWxsaW5nIGRvd24gaW50byB0aGUgZGV0YWlscyBvZiBhbnkgb2YgdGhlbS48YnI+PGJyPg0KICAgIExhc3QgTW9kaWZpZWQ6IDE0OjAwIE9jdG9iZXIgNCwgMjAwMjwvcD4NCjwvYmxvY2txdW90ZT4NCjxwPkluIHRoaXMgZG9jdW1lbnQgd2UgZXhwbG9yZSB0aGUgc3BhY2Ugb2YgcG90ZW50aWFsIHNvbHV0aW9ucywgdG8gYmV0dGVyDQp1bmRlcnN0YW5kIHdoZXJlIHRoZSB2YXJpb3VzIGFzcGVjdHMgb2YgdGhlIHByb2JsZW0gY2FuIGFuZCBjYW5ub3QgYmUgYWRkcmVzc2VkLg0KQWx0aG91Z2ggbXVjaCBvZiB0aGUgZGlzY3Vzc2lvbiB3aWxsIGNlbnRlciBhcm91bmQgSmF2YSwgdGhlIHByb2JsZW1zIGFyZSBsaWtlbHkgbm90DQpjb25maW5lZCB0bw0KSmF2YSBhbmQgd2lsbCBhZmZlY3QgdG9vbHMgZm9yIG90aGVyIGxhbmd1YWdlcy4gSW4gbW9zdCBjYXNlcywgd2Ugd2lsbCBoYXZlIHRoZSBvcHRpb24gb2YgYWRkcmVzc2luZyB0aGUgcHJvYmxlbSBhdCB0aGUgSkRUDQpsZXZlbCB3aXRob3V0IGNoYW5naW5nIHRoZSBFY2xpcHNlIFBsYXRmb3JtLiBUaGlzIGhhcyBpdHMgcHJvcyBhbmQgY29ucy4gUHJvOg0KdGhlIHNvbHV0aW9uIGNhbiBiZSBzcGVjaWFsaXplZCBmb3IgSmF2YS4gQ29uOiBUaGUgc29sdXRpb24gd291bGQgbm90IGFwcGx5IHRvIEMNCnRvb2xzLCBmb3IgZXhhbXBsZS4gT24gdGhlIG90aGVyIGhhbmQsIGFkZHJlc3NpbmcgdGhlIHByb2JsZW0gYXQgdGhlIGxldmVsIG9mDQp0aGUgRWNsaXBzZSBQbGF0Zm9ybSBhbHNvIGhhcyBpdHMgcHJvcyBhbmQgY29ucy4gUHJvOiBUaGUgc29sdXRpb24gd291bGQgYXBwbHkNCnRvIEMgdG9vbHMsIGV0Yy4gQ29uOiBUaGUgY2hhbmdlIG1heSBpbXBhY3QgYWxsIHRvb2xzIGFuZCB1c2Vycy4gQWxsIHRoaXMgbXVzdCBiZQ0KZmFjdG9yZWQgaW4gdG8gdGhlIGRlY2lzaW9uLW1ha2luZyBwcm9jZXNzLjwvcD4NCjxwPkluIHRoZSBmaW5hbCBkZWNpc2lvbiwgd2UgbWF5IG9ubHkgYmUgYWJsZSB0byBhZGRyZXNzIGEgc3Vic2V0IG9mIHRoZQ0KcHJvYmxlbXMuIEJ1dCBoZXJlIHdlIHByb2NlZWQgd2l0aCBhbiB1bmxpbWl0ZWQgYnVkZ2V0IGZvciBleHBsb3JhdGlvbi48L3A+DQo8aDI+UHJvcyBvZiB0aGUgY3VycmVudCBFY2xpcHNlPC9oMj4NCjxwPkFsdGhvdWdoIHRoZSByZXN0cmljdGlvbnMgb24gdGhlIHN0cnVjdHVyZSBvZiBFY2xpcHNlIHByb2plY3RzIG1heSBjb21lDQphY3Jvc3MgYXMgaW5mbGV4aWJsZSB0byBzb21lLCB0aGUgY3VycmVudCBzY2hlbWUgaGFzIHNldmVyYWwgaW1wb3J0YW50IHZpcnR1ZXM6PC9wPg0KPHVsPg0KICA8bGk+U2luZ2xlLXJvb3RlZCBFY2xpcHNlIHByb2plY3QgaXMgc2ltcGxlIHRvIGV4cGxhaW4gdG8gdXNlcnMgYW5kIHBsdWctaW4NCiAgICB3cml0ZXJzIGFsaWtlOiBBbGwgb2YgYSBwcm9qZWN0J3MgZmlsZXMgYXJlIGluIGEgc2luZ2xlIGZpbGUgc3lzdGVtDQogICAgc3ViZGlyZWN0b3J5LiBFbmQgb2Ygc3RvcnkuPC9saT4NCiAgPGxpPkFsbC1pbmNsdXNpdmUgRWNsaXBzZSBwcm9qZWN0IG1lYW5zIHRoYXQgdGhlIHByb2plY3QgcmVzb3VyY2UgdHJlZSBpcyBhbg0KICAgIGFjY3VyYXRlIGluLW1lbW9yeSBtb2RlbCBvZiB0aGUgY29ycmVzcG9uZGluZyB0cmVlIG9mIGZpbGVzIGluIHRoZSBmaWxlDQogICAgc3lzdGVtLiBQbHVnLWlucyBjYW4gcXVpY2tseSB0cmF2ZXJzZSB0aGUgaW4tbWVtb3J5IHRyZWUgd2l0aG91dCBoYXZpbmcgdG8NCiAgICBtYWtlIGV4cGVuc2l2ZSBPUyBmaWxlIElPIGNhbGxzLiBUb29scyB0aGF0IG9wZXJhdGUgZGlyZWN0bHkgaW4gdGhlIGZpbGUNCiAgICBzeXN0ZW0gY2FuIGJlIHJlYWRpbHkgaW50ZWdyYXRlZCBpbnRvIEVjbGlwc2Ugd2l0aCB0aGUgYWZ0ZXItdGhlLWZhY3QNCiAgICBhcHBsaWNhdGlvbiBvZiBhIHNpbXBsZSByZWZyZXNoIG1lY2hhbmlzbSB0byByZXN5bmNocm9uaXplcyB0aGUgcmVzb3VyY2UNCiAgICB0cmVlIHdpdGggdGhlIGZpbGUgc3lzdGVtLjwvbGk+DQogIDxsaT5Ob24tb3ZlcmxhcHBpbmcgRWNsaXBzZSBwcm9qZWN0cyBpcyBzaW1wbGUuIFRoZSBtYXBwaW5nIGZyb20gZmlsZXMgaW4gdGhlDQogICAgZmlsZSBzeXN0ZW0gdG8gZmlsZXMgaW4gdGhlIHdvcmtzcGFjZSByZXNvdXJjZSB0cmVlIGlzIDEtMSwgYWxsb3dpbmcNCiAgICB1bmFtYmlndW91cyBsb29rdXAgb2YgYSByZXNvdXJjZSBnaXZlbiBhIGZpbGUgc3lzdGVtIHBhdGguIElmIHByb2plY3RzDQogICAgb3ZlcmxhcCwgdGhhdCBtYXBwaW5nIGJlY29tZXMgMS1tYW55IChtdWx0aXBsZSBkaXN0aW5jdCByZXNvdXJjZSBoYW5kbGVzIG1hcA0KICAgIHRvIHRoZSBzYW1lIGZpbGUpLjwvbGk+DQo8L3VsPg0KPGgyPldoYXQgZG8gb3RoZXIgSURFcyBkbz88L2gyPg0KPHA+DQo8Yj5OZXRCZWFucyAzLjQgKDwvYj5hbmQgU3VumSBPTkUgU3R1ZGlvLCBmb3JtZXJseSBGb3J0ZZkgZm9yIEphdmGZKTwvcD4NCiAgICA8dWw+DQogICAgICA8bGk+UHJvamVjdHMgYXJlIG11bHRpLXJvb3RlZCBhdCB0aGUgdG9wLWxldmVsLjwvbGk+DQogICAgICA8bGk+VG8gdXNlIHNvdXJjZXMgYW5kIGxpYnJhcmllcyBpbiBJREUgdGhleSBtdXN0IGJlIG1vdW50ZWQgYXMNCiAgICAgICAgZmlsZXN5c3RlbXMuPC9saT4NCiAgICAgIDxsaT5GaWxlc3lzdGVtIGNhbiBiZSBhIGxvY2FsIGZvbGRlciwgYW4gYXJjaGl2ZSwgb3Igc29tZXRoaW5nIGZyb20gVkNNLjwvbGk+DQogICAgICA8bGk+RmlsZXN5c3RlbXMgYXJlIGFsbC1pbmNsdXNpdmUgYnkgZGVmYXVsdC4NCiAgICAgICAgPHVsPg0KICAgICAgICAgIDxsaT5SZWd1bGFyIGV4cHJlc3Npb24gZXhjbHVzaW9uIHJ1bGVzIHN0YXRlZCBhdCBmaWxlc3lzdGVtIHJvb3QuPC9saT4NCiAgICAgICAgICA8bGk+KFJlZnJlc2ggcmF0ZSBhbHNvIHNldCBhdCBmaWxlc3lzdGVtIHJvb3Q7IGRlZmF1bHRzIHRvIDE1DQogICAgICAgICAgICBzLikmbmJzcDs8L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9saT4NCiAgICAgIDxsaT5Qcm9qZWN0cyBwcm92aWRlIGNvbnRleHQgZm9yIHNvdXJjZSBmaWxlcywgY29tcGlsYXRpb24sIGFuZCBleGVjdXRpb24uPC9saT4NCiAgICAgIDxsaT5BbGwgd29yayBkb25lIGluIGFuIG9wZW4gcHJvamVjdC48L2xpPg0KICAgICAgPGxpPkRlZmF1bHQgcHJvamVjdCBpZiBub25lIHNwZWNpZmllZC48L2xpPg0KICAgICAgPGxpPkNhbiBkZWZpbmUgbmV3IHByb2plY3RzLjwvbGk+DQogICAgICA8bGk+T25seSBvbmUgcHJvamVjdCBvcGVuIGF0IGEgdGltZS48L2xpPg0KICAgICAgPGxpPkZpbGVzeXN0ZW1zIGNhbiBiZSBtb3VudGVkIGludG8gcHJvamVjdHMuPC9saT4NCiAgICAgIDxsaT5GaWxlc3lzdGVtcyBjYW4gb3ZlcmxhcCBiZXR3ZWVuIHByb2plY3RzLjwvbGk+DQogICAgICA8bGk+RmlsZXN5c3RlbXMgY2FuIG92ZXJsYXAgZXZlbiB3aXRoaW4gcHJvamVjdHMuPC9saT4NCiAgICAgIDxsaT5Qcm9qZWN0IGxldmVsIGNvbnRyb2wgb2YgbG9jYXRpb24gb2YgZ2VuZXJhdGVkIGNsYXNzIGZpbGVzLg0KICAgICAgICA8dWw+DQogICAgICAgICAgPGxpPk5leHQgdG8gc291cmNlIGZpbGUgKGRlZmF1bHQpLjwvbGk+DQogICAgICAgICAgPGxpPk91dHB1dCB0byBzcGVjaWZpYyBmaWxlc3lzdGVtLjwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgIDwvdWw+DQo8Yj5JbnRlbGxpSiBJREVBIDIuNjwvYj4NCiAgICA8dWw+DQogICAgICA8bGk+UHJvamVjdHMgYXJlIG11bHRpLXJvb3RlZCBhdCB0aGUgdG9wLWxldmVsLjwvbGk+DQogICAgICA8bGk+Um9vdHMgYXJlIGRpcmVjdG9yaWVzIG9yIEpBUnMgaW4gZmlsZSBzeXN0ZW0uDQogICAgICAgIDx1bD4NCiAgICAgICAgICA8bGk+QXV0b21hZ2ljYWxseSBjb21wdXRlcyBjb3JyZWN0IHNvdXJjZSBmb2xkZXIgYmFzZWQgb24gd2hlcmUgaXQNCiAgICAgICAgICAgIGZpbmRzIEphdmEgc291cmNlIGZpbGVzPC9saT4NCiAgICAgICAgPC91bD4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+QWxsIGZpbGVzIHVuZGVyIHJvb3QgZGlyZWN0b3J5IGFyZSBpbmNsdWRlZCBpbiBwcm9qZWN0LjwvbGk+DQogICAgICA8bGk+PGk+UmVtb3ZlPC9pPiBhIHJvb3QgZnJvbSBwcm9qZWN0OyA8aT5kZWxldGU8L2k+IGEgZmlsZSBvciBmb2xkZXIgZnJvbQ0KICAgICAgICBhIHJvb3QuPC9saT4NCiAgICAgIDxsaT5JbmZvIGFib3V0IHByb2plY3QgaXMga2VwdCBpbiBzZXBhcmF0ZSBwcm9qZWN0IGNvbmZpZ3VyYXRpb24gZmlsZQ0KICAgICAgICBuYW1lZCAmbHQ7UHJvamVjdE5hbWUmZ3Q7LmlwcjwvbGk+DQogICAgICA8bGk+UHJvamVjdCBoYXMgY29tcGlsZXIgb3B0aW9uIGZvciBpZ25vcmluZyBzcGVjaWZpZWQgZmlsZXMgb3INCiAgICAgICAgc3ViZGlyZWN0b3JpZXMuPC9saT4NCiAgICAgIDxsaT5Xb3Jrc3BhY2UgY29uc2lzdHMgb2YgYSBzaW5nbGUgb3BlbiBwcm9qZWN0LjwvbGk+DQogICAgICA8bGk+RGVmYXVsdCBwcm9qZWN0IGlmIG5vbmUgc3BlY2lmaWVkLjwvbGk+DQogICAgICA8bGk+Q2FuIGRlZmluZSBuZXcgcHJvamVjdHMuPC9saT4NCiAgICAgIDxsaT5Pbmx5IG9uZSBwcm9qZWN0IG9wZW4gYXQgYSB0aW1lLg0KICAgICAgICA8dWw+DQogICAgICAgICAgPGxpPkJ1dCB5b3UgY2FuIHJ1biBtdWx0aXBsZSBpbnN0YW5jZXMgb2YgSURFIGF0IHNhbWUgdGltZS48L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9saT4NCiAgICAgIDxsaT5TZXBhcmF0ZSBwcm9qZWN0cyBhcmUgZnJlZSB0byBvdmVybGFwIChubyBzcGVjaWFsIHN1cHBvcnQpLjwvbGk+DQogICAgICA8bGk+V2l0aGluIGEgcHJvamVjdCwgc2VwYXJhdGUgcm9vdHMgbWF5IG92ZXJsYXAuPC9saT4NCiAgICAgIDxsaT5Tb3VyY2UgZmlsZXMgYXBwZWFyaW5nIHVuZGVyIG1vcmUgdGhhbiBvbmUgcm9vdCBnZW5lcmF0ZSBjb21waWxlDQogICAgICAgIGVycm9ycy4NCiAgICAgICAgPHVsPg0KICAgICAgICAgIDxsaT5DYW5ub3QgYmUgcmVtZWRpZWQgd2l0aCBjb21waWxlciBvcHRpb24uPC9saT4NCiAgICAgICAgPC91bD4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+T25lIG91dHB1dCBmb2xkZXIgcGVyIHByb2plY3QuDQogICAgICAgIDx1bD4NCiAgICAgICAgICA8bGk+TG9jYXRpb24gb2YgZ2VuZXJhdGVkIGNsYXNzIGZpbGVzIGlzIGEgcHJvamVjdCBwcm9wZXJ0eS48L2xpPg0KICAgICAgICAgIDxsaT4oQnV0Li4uSURFQSAzLjAgaXMgbW9yZSBmbGV4aWJsZTogZGlmZmVyZW50IG91dHB1dCBmb2xkZXIgZm9yIGVhY2gNCiAgICAgICAgICAgIHNvdXJjZSBmb2xkZXIpPC9saT4NCiAgICAgICAgPC91bD4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCjxiPlRvZ2V0aGVyriBDb250cm9sQ2VudGVymSA2LjAuMTwvYj4gDQogICAgPHVsPg0KICAgICAgPGxpPlByb2plY3RzIGFyZSBtdWx0aS1yb290ZWQgYXQgdGhlIHRvcC1sZXZlbC48L2xpPg0KICAgICAgPGxpPlJvb3RzIGFyZSBkaXJlY3RvcmllcyBvciBKQVJzIGluIGZpbGUgc3lzdGVtLjwvbGk+DQogICAgICA8bGk+Um9vdHMgYXJlIGFkZGVkIGFuZCByZW1vdmVkIG9ubHkgaW4gcHJvamVjdCBwcm9wZXJ0aWVzIGRpYWxvZy48L2xpPg0KICAgICAgPGxpPkFsbCBmaWxlcyB1bmRlciByb290IGRpcmVjdG9yeSBhcmUgaW5jbHVkZWQgaW4gcHJvamVjdCB1bmxlc3MgZXhjbHVkZWQNCiAgICAgICAgYnkgYSAmcXVvdDtza2lwIHBhdGgmcXVvdDsgZW50cnkuPC9saT4NCiAgICAgIDxsaT5JbmZvIGFib3V0IHByb2plY3QgaXMga2VwdCBpbiBzZXBhcmF0ZSBwcm9qZWN0IGZpbGUgbmFtZWQNCiAgICAgICAgJmx0O1Byb2plY3ROYW1lJmd0Oy50cHIuPC9saT4NCiAgICAgIDxsaT5Qcm9qZWN0IGZpbGUgaXMga2VwdCBpbiBwcmltYXJ5IHJvb3QgZGlyZWN0b3J5IGFsb25nIHdpdGggb3RoZXINCiAgICAgICAgcHJvamVjdC1sZXZlbCBwcm9wZXJ0eSBmaWxlcy48L2xpPg0KICAgICAgPGxpPldvcmtzcGFjZSBjb25zaXN0cyBvZiBhIHNpbmdsZSBvcGVuIHByb2plY3QuPC9saT4NCiAgICAgIDxsaT5DYW4gZGVmaW5lIG5ldyBwcm9qZWN0cy48L2xpPg0KICAgICAgPGxpPk9ubHkgb25lIHByb2plY3Qgb3BlbiBhdCBhIHRpbWUuDQogICAgICAgIDx1bD4NCiAgICAgICAgICA8bGk+QnV0IHlvdSBjYW4gcnVuIG11bHRpcGxlIGluc3RhbmNlcyBvZiBJREUgYXQgc2FtZSB0aW1lLjwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgICAgPGxpPlNlcGFyYXRlIHByb2plY3RzIGFyZSBmcmVlIHRvIG92ZXJsYXAgKG5vIHNwZWNpYWwgc3VwcG9ydCkuPC9saT4NCiAgICAgIDxsaT5XaXRoaW4gYSBwcm9qZWN0LCBzZXBhcmF0ZSByb290cyBtYXkgb3ZlcmxhcC48L2xpPg0KICAgICAgPGxpPlNvdXJjZSBmaWxlcyBhcHBlYXJpbmcgdW5kZXIgbW9yZSB0aGFuIG9uZSByb290IGdlbmVyYXRlIGNvbXBpbGUNCiAgICAgICAgZXJyb3JzLg0KICAgICAgICA8dWw+DQogICAgICAgICAgPGxpPkNhbiBiZSByZW1lZGllZCB3aXRoICZxdW90O3NraXAgcGF0aCZxdW90OyBmZWF0dXJlLjwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgICAgPGxpPkxvY2F0aW9uIG9mIGdlbmVyYXRlZCBjbGFzcyBmaWxlcyBpcyBpbnRlcm5hbCBhbmQgdW5zcGVjaWZpZWQuPC9saT4NCiAgICA8L3VsPg0KPGI+TWljcm9zb2Z0IFZpc3VhbCBTdHVkaW8gLk5FVDwvYj4NCiAgICA8dWw+DQogICAgICA8bGk+UHJvamVjdHMgYXJlIHNpbmdsZS1yb290ZWQuPC9saT4NCiAgICAgIDxsaT5GaWxlIGluY2x1c2lvbiBpcyBpbmhlcmVudGx5IHNlbGVjdGl2ZS4NCiAgICAgICAgPHVsPg0KICAgICAgICAgIDxsaT5UaGVyZSBhcmUgSW5jbHVkZSBpbiBQcm9qZWN0IGFuZCBFeGNsdWRlIGZyb20gUHJvamVjdCBtZW51IGl0ZW1zLjwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgICAgPGxpPldvcmtzcGFjZSBjb25zaXN0cyBvZiBzZXZlcmFsIHByb2plY3RzIChjb2xsZWN0ZWQgaW50byBzb2x1dGlvbnMpLjwvbGk+DQogICAgICA8bGk+W1RCRCAtIHdoZXRoZXIgcHJvamVjdHMgYXJlIGFsbG93ZWQgdG8gY29pbmNpZGUgb3Igb3ZlcmxhcF08L2xpPg0KICAgIDwvdWw+DQo8cD4NCjxiPkJvcmxhbmSuIEpCdWlsZGVymTwvYj4gJm5ic3A7PC9wPg0KPHA+W1RoaXMgc2VjdGlvbiBpcyBpbmNvbXBsZXRlLl08L3A+DQo8dWw+DQogIDxsaT5Qcm9qZWN0cyBhcmUgbXVsdGktcm9vdGVkIGF0IHRoZSB0b3AtbGV2ZWwuPC9saT4NCiAgPGxpPkZvciBlYWNoIHNwZWNpZmllZCByb290LCBhbGwtaW5jbHVzaXZlIGlzIHRoZSBkZWZhdWx0IHBvc2l0aW9uLCB3aXRoIHNvbWUNCiAgICAgICAgZmlsdGVyaW5nIG1lY2hhbmlzbXMuPC9saT4NCiAgPGxpPldvcmtzcGFjZSBjb25zaXN0cyBvZiBhIHNpbmdsZSBwcm9qZWN0LjwvbGk+DQogIDxsaT5TZXBhcmF0ZSBwcm9qZWN0cyBhcmUgZnJlZSB0byBvdmVybGFwIChubyBzcGVjaWFsIHN1cHBvcnQpLjwvbGk+DQogIDxsaT5XaXRoaW4gYSBwcm9qZWN0LCBzZXBhcmF0ZSByb290cyBtYXkgb3ZlcmxhcDsgZHVwbGljYXRlIGZpbGVzIGFyZQ0KICAgICAgICBhbGxvd2VkLjwvbGk+DQogIDxsaT5TaW5nbGUgb3V0cHV0IGZvbGRlciBwZXIgcHJvamVjdC48L2xpPg0KPC91bD4NCjxoMj5JbXByb3ZpbmcgdGhlIE91dHB1dCBGb2xkZXI8L2gyPg0KPHA+SG93IGNvdWxkIHdlIGNoYW5nZSBFY2xpcHNlIHRvIG1ha2UgdGhlIEphdmEgb3V0cHV0IGZvbGRlciBtb3JlIGZsZXhpYmxlPzwvcD4NCjxwPkhlcmUgYXJlIHNvbWUgb3B0aW9ucyAoaW4gbm8gcGFydGljdWxhciBvcmRlcik6PC9wPg0KPHA+PGI+T3B0aW9uIFAtMTwvYj46IENoYW5nZSBKRFQgdG8gYWxsb3cgdGhlIG91dHB1dCBmb2xkZXIgdG8gYmUgZXh0ZXJuYWwgdG8NCnRoZSB3b3Jrc3BhY2UuPC9wPg0KPHA+SkRUIGFsbG93cyBsaWJyYXJ5IEpBUnMgdG8gYmUgZWl0aGVyIGxvY2FsIHRvIGEgSmF2YSBwcm9qZWN0IChzcGVjaWZpZWQgYnkNCndvcmtzcGFjZSBwYXRoKSBvciBleHRlcm5hbCB0byB0aGUgd29ya3NwYWNlIChzcGVjaWZpZWQgYnkgYW4gYWJzb2x1dGUgZmlsZQ0Kc3lzdGVtIHBhdGgpLiBTbyBvbmUgb3B0aW9uIGlzIHRvIGJlIHNpbWlsYXJseSBmbGV4aWJsZSB3aXRoIHRoZSBsb2NhdGlvbiBvZiBhDQpKYXZhIHByb2plY3QncyBvdXRwdXQgZm9sZGVyLjwvcD4NCjxwPlRoaXMgd291bGQgZW50YWlsIGNoYW5naW5nIEpEVCBDb3JlIEFQSSBhcyB3ZWxsIGFzIEpEVCBVSSwgYnV0IGNvdWxkIGxpa2VseQ0KYmUgZG9uZSBpbiBhIG5vbi1icmVha2luZyBmYXNoaW9uLjwvcD4NCjxwPlRoZSBjaGllZiBkcmF3YmFjayBvZiB0aGlzIGFwcHJvYWNoIGlzIHRoYXQgdGhlcmUgd291bGQgYmUgbm8gcmVzb3VyY2UgZGVsdGFzDQpmb3IgdHJhY2tpbmcgY2hhbmdlcyB0byBmaWxlcyBpbiBhIHByb2plY3QncyBvdXRwdXQgZm9sZGVyIGluIHRoZSBjYXNlIHdoZXJlIGl0DQp3YXMgZXh0ZXJuYWwgdG8gdGhlIHdvcmtzcGFjZS4gVGhpcyB3b3VsZCBoYXZlIHNlcmlvdXMgcmVwZXJjdXNzaW9ucyBpbiBhdCBsZWFzdA0KdGhyZWUgYXJlYXM6IChhKSB0aGUgSkRUIGRlYnVnZ2VyJ3MgSG90U3dhcCBmYWNpbGl0eSByZWxpZXMgb24gcmVzb3VyY2UgZGVsdGFzIHRvDQpjbGFzcyBmaWxlcyBpbiB0aGUgb3V0cHV0IGZvbGRlcjsgKGIpIHRoZSBKYXZhIGluY3JlbWVudGFsIHByb2plY3QgYnVpbGRlciB1c2VzDQpidWlsZGVyLXN1cHBsaWVkIHJlc291cmNlIGRlbHRhcyB0byB0cmFjayBjaGFuZ2VzIHRvIGNsYXNzIGZpbGVzIGluIGRlcGVuZGVudA0KcHJvamVjdHMsIGFuZCAoYykgb3RoZXIgaW5jcmVtZW50YWwgcHJvamVjdCBidWlsZGVycyBvbiB0aGUgc2FtZSBwcm9qZWN0IHdvdWxkDQpiZSB1bmFibGUgdG8gdHJhY2sgY2hhbmdlcyB0byBhbnl0aGluZyBpbiB0aGUgb3V0cHV0IGZvbGRlciBhcyB3ZWxsLiBXaXRob3V0IHJlc291cmNlIGRlbHRhcywgaXQgaXMgaGFyZCB0byBzZWUgaG93IGVpdGhlciBjb3VsZCBiZQ0Kc3VwcG9ydGVkLjwvcD4NCjxwPkEgc21hbGxlciBkcmF3YmFjayBpcyB0aGF0IGFueSBjb2RlIHRoYXQgY3JlYXRlcyBhbmQgcmVhZHMgY2xhc3MgZmlsZXMgaW4gdGhlDQpvdXRwdXQgZm9sZGVyIHdvdWxkIGhhdmUgdG8gYmUgd3JpdHRlbiBpbiBzdWNoIGEgd2F5IHRoYXQgaXQgY291bGQgZGVhbCB3aXRoDQpyZXNvdXJjZXMgaW4gdGhlIHdvcmtzcGFjZSAodXNpbmcgcmVzb3VyY2UgaGFuZGxlcyBwcm92aWRlZCBieSB0aGUgd29ya3NwYWNlDQpBUEkpIGFuZCBvdXRzaWRlIHRoZSB3b3Jrc3BhY2UgKHVzaW5nIGphdmEuaW8uRmlsZSBBUEkgZGlyZWN0bHkpLjwvcD4NCjxwPjxiPk9wdGlvbiBQLTI8L2I+OiBDaGFuZ2UgRWNsaXBzZSBQbGF0Zm9ybSB3b3Jrc3BhY2UgdG8gYWxsb3cgYXJiaXRyYXJ5DQpkaXJlY3RvcnkgaW4gdGhlIGZpbGUgc3lzdGVtIHRvIGJlICZxdW90O21vdW50ZWQmcXVvdDsgYXMgYSBmb2xkZXIgaW5zaWRlIGENCnByb2plY3QuPC9wPg0KPHA+QSB1c2VyIHdvdWxkIHRoZW4gYmUgYWJsZSB0byBtb3VudCBhbiBleHRlcm5hbCBmaWxlIHN5c3RlbSBzdWJkaXJlY3RvcnkgaW50bw0KdGhlaXIgSmF2YSBwcm9qZWN0LCBhbmQgZGVzaWduYXRlIHRoZWlyIG91dHB1dCBmb2xkZXIgYXQgKG9yIGJlbG93KSB0aGF0IG1vdW50DQpwb2ludC4gVGhlIG5ldCBlZmZlY3QgaXMgdGhhdCB0aGUgZ2VuZXJhdGVkIGNsYXNzIGZpbGVzIHdvdWxkIGJlIHdyaXR0ZW4NCmRpcmVjdGx5IHRvIHRoZSBkZXNpcmVkIGxvY2F0aW9uLiBBcyBsb25nIGFzIG1vdW50ZWQgc3ViZGlyZWN0b3JpZXMgYXJlDQpjb25zaWRlcmVkIHRvIGJlIGEgcmVndWxhciBwYXJ0IG9mIHRoZSBwcm9qZWN0J3MgZmlsZSwgdGhlIHJlZ3VsYXIgcmVzb3VyY2UgQVBJDQphbmQgcmVzb3VyY2UgZGVsdGFzIGFwcGx5LiBKRFQgd291bGQgbm90IGV2ZW4gbmVlZCB0byBiZSBhd2FyZSB0aGF0IHRoZSBvdXRwdXQNCmZvbGRlciB3YXMgc2VwYXJhdGVkIGZyb20gdGhlIHJlc3Qgb2YgdGhlIHByb2plY3QncyBmaWxlcy48L3A+DQo8cD5UaGUgcHJvcyBhbmQgY29ucyBvZiB0aGlzIGFwcHJvYWNoIGFyZSBjaGllZmx5IHRob3NlIG9mIG1vdW50IHBvaW50cw0KZ2VuZXJhbGx5IChjb3ZlcmVkIGJlbG93KS48L3A+DQo8cD5QREUgbGF1bmNoZXMgYSBydW50aW1lDQp3b3JrYmVuY2ggd2l0aCBhIHNwZWNpYWwgY29tbWFuZCBsaW5lIG9wdGlvbiBzcGVjaWZ5aW5nIG9uZSBvciBtb3JlDQpwbHVnLWluLXJlbGF0aXZlIHBhdGhzIChlLmcuLCAtZGV2IGJpbikgdGhhdCBhcmUgdG8gYmUgaW5jbHVkZWQgb24gZWFjaCBwbHVnLWluDQpjbGFzcyBsb2FkZXIncyBjbGFzcyBwYXRoLiBQREUgaW5jbHVkZXMgdGhlIHByb2plY3QtcmVsYXRpdmUgcGF0aHMgb2YgYWxsIG91dHB1dA0KZm9sZGVyczsgdGhpcyBpcyBqdXN0IHRoZSBwYXRoICZxdW90O2JpbiZxdW90OyB3aGVuIGFsbCBwbHVnLWluIHByb2plY3RzIGxvY2F0ZQ0KdGhlaXIgb3V0cHV0IGZvbGRlciBpbiB0aGUgZGVmYXVsdCBsb2NhdGlvbi4gSWYgYW4gZXh0ZXJuYWwgZGlyZWN0b3J5IGlzIG1vdW50ZWQNCmFzIGEgSmF2YSBwcm9qZWN0J3Mgb3V0cHV0IGZvbGRlciwgdGhlIGV4aXN0aW5nIEVjbGlwc2UgUGxhdGZvcm0gQ29yZSBSdW50aW1lDQptZWNoYW5pc21zIHdvdWxkIG5lZWQgdG8gYmUgcmV2YW1wZWQgdG8gYWxsb3cgUERFIHRvIHN1cHBseSBhbiBhYnNvbHV0ZSBmaWxlDQpzeXN0ZW0gcGF0aCBmb3IgZWFjaCBwbHVnLWluLjwvcD4NCjxwPlNvbWUgb3RoZXIgb2JzZXJ2YXRpb25zOjwvcD4NCjx1bD4NCiAgPGxpPkpEVCBtYXJrcyB0aGUgb3V0cHV0IGZvbGRlciBhcyBjb250YWluaW5nICZxdW90O2Rlcml2ZWQmcXVvdDsgcmVzb3VyY2VzLA0KICAgIGFuZCByZXBvc2l0b3J5IHByb3ZpZGVycyB0ZW5kIHRvIGlnbm9yZSByZXNvdXJjZXMgbWFya2VkIGFzDQogICAgJnF1b3Q7ZGVyaXZlZCZxdW90Oy4gVGhpcyBtZWFucyB0aGF0IGl0IHByb2JhYmx5IGRvZXMgbm90IG1hdHRlciB3aGV0aGVyIGENCiAgICBtb3VudGVkIGZvbGRlciBpcyBjb25zaWRlcmVkIHBhcnQgb2YgdGhlIHByb2plY3QgZm9yIFZDTSBwdXJwb3Nlcy48L2xpPg0KICA8bGk+SWYgdGhlIEpEVCBVSSBleHBvc2VzIHRoZSBzdXBwb3J0IGZvciBtb3VudGluZyB0aGUgb3V0cHV0IGZvbGRlciwgdGhlcmUNCiAgICB3b3VsZCBiZSBubyBuZWVkIHRvIHByb3ZpZGUgZ2VuZXJpYyBtb3VudCBzdXBwb3J0IGluIHRoZSBXb3JrYmVuY2ggVUkuIFRoaXMNCiAgICB3b3VsZCBhbGxvdyB0aGUgY29tcGxpY2F0aW5nIG5hdHVyZSBvZiBtb3VudCBwb2ludHMgdG8gYmUgY29uZmluZWQgdG8gdGhlDQogICAgdHlwZXMgb2YgcHJvamVjdHMgdGhhdCBhcmUgcHJlcGFyZWQgZm9yIHRoZW0uPC9saT4NCjwvdWw+DQo8cD48Yj5PcHRpb24gUC0zPC9iPjogQWR2b2NhdGUgdXNlIG9mIE9TLWxldmVsIHN5bWxpbmtzLiA8L3A+DQo8cD5Vbml4IGZpbGUgc3lzdGVtIGhhdmUgc3ltbGlua3MsIGFuZCBXaW5kb3dzIDIwMDAgTlRGUyBoYXMgYW4gdW5zdXBwb3J0ZWQNCmZlYXR1cmUgY2FsbGVkIDxhIGhyZWY9Imh0dHA6Ly93d3cuc3lzaW50ZXJuYWxzLmNvbS9udHcyay9zb3VyY2UvbWlzYy5zaHRtbCNqdW5jdGlvbiI+anVuY3Rpb25zPC9hPi4gVGhlc2UNCmZpbGUgc3lzdGVtIG1lY2hhbmlzbXMgYWxsb3cgYSBkaXJlY3RvcnkgaW4gb25lIHBhcnQgb2YgdGhlIGZpbGUgc3lzdGVtIHRvIGJlDQpsaW5rZWQgaW4gdG8gc29tZXdoZXJlIGVsc2UuIEZvciBleGFtcGxlLCBpZiB0aGUgcHJvamVjdCByb290IGRpcmVjdG9yeSBvZg0KUHJvamVjdDEgaXMgQzovbXl3cy9wcm9qZWN0MSBhbmQgdGhlIEphdmEgb3V0cHV0IGZvbGRlciBpcyBpbiBpdHMgc3RhbmRhcmQNCmxvY2F0aW9uLCBhIHN5bWxpbmsgZnJvbSBDOi9teXdzL3Byb2plY3QxL2JpbiB0byBDOi90b21jYXQvd2ViYXBwcy9teXRlc3QvV0VCLUlORi9jbGFzc2VzDQplbnN1cmVzIHRoYXQgdGhlIGZpbGVzIGluIHRoZSBvdXRwdXQgZm9sZGVyIGFyZSBjcmVhdGVkIGRpcmVjdGx5IGluIHRoZSB3ZWINCnNlcnZlcidzIHN1YmRpcmVjdG9yeS4gPC9wPg0KPHA+VGhlIGFkdmFudGFnZSBvZiB0aGlzIG9wdGlvbiBpcyB0aGF0IHRoZSB1c2VyIGNhbiBjcmVhdGUgdGhpcyBhcnJhbmdlbWVudA0KdXNpbmcgZXhpc3RpbmcgT1Mtc3BlY2lmaWMgdG9vbHMsIGFuZCBkb2VzIG5vdCByZXF1aXJlIGV4cGxpY2l0IHN1cHBvcnQgZnJvbSB0aGUNCkVjbGlwc2UuIFNvIHRoaXMgb3B0aW9uIGlzIGFscmVhZHkgc3VwcG9ydGVkIGluIDIuMC4gPC9wPg0KPHA+T3BlcmF0aW5nIHN5c3RlbXMmbmJzcDsgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHN5bWxpbmtzIHRoYXQgbWFrZSB0aGlzIG9wdGlvbiBsZXNzDQp3b3JrYWJsZSBmb3Igc29tZSBwdXJwb3Nlcy4gRm9yIGluc3RhbmNlLCBOVEZTIGp1bmN0aW9ucyB3b3JrIG9uIFdpbmRvd3MNCjIwMDAgb3IgYmV0dGVyLCBhbmQgb25seSB3b3JrIHdpdGhpbg0KYW5kIGJldHdlZW4gbG9jYWwgZHJpdmVzLiBGdXJ0aGVybW9yZSwganVuY3Rpb25zIGFyZSBhbiB1bnN1cHBvcnRlZCBmZWF0dXJlLiA8L3A+DQo8cD48Yj5PcHRpb24gUC00PC9iPjogQWR2b2NhdGUgdXNlIG9mIGV4dGVybmFsIHRvb2wgYnVpbGRlcnMgZm9yIGNvcHlpbmcgdGhlIG91dHB1dCBmb2xkZXIgdG8gYW4NCmV4dGVybmFsIGxvY2F0aW9uLiA8L3A+DQo8cD5FY2xpcHNlIGFsbG93cyB0aGUgdXNlciB0byBhZGQgQW50LXNjcmlwdGVkIHN0ZXBzIGFzIGFuIGV4dGVybmFsIHRvb2wNCmJ1aWxkZXIuIENvcGluZyBuZXcgYW5kIGNoYW5nZWQgZmlsZXMgZnJvbSB0aGUgb3V0cHV0IGZvbGRlciB0byBhbm90aGVyIGxvY2F0aW9uDQpjYW4gYmUgZG9uZSB3aXRoIG9uZSBBbnQgY29tbWFuZC4gPC9wPg0KPHA+VGhpcyBvcHRpb24gaXMgbG93LXRlY2ggYW5kIHdvcmtzIGluIEVjbGlwc2UgMi4wOyBob3dldmVyLCBpdCBvbmx5IGVuc3VyZXMNCnRoYXQgdGhlIGZpbGVzIGluIHRoZSBvdXRwdXQgZm9sZGVyIGVuZCB1cCBpbiB0aGUgZGVzaXJlZCBsb2NhdGlvbjsgaXQgZG9lcyBub3QNCnJlZHVjZSB0aGUgbmV0d29yayB0cmFmZmljIHdoZW4gdGhlIHByb2plY3QncyBmaWxlcyBhcmUgc3RvcmVkIG9uIGEgbmV0d29yaw0KZHJpdmUuIDwvcD4NCjxwPjxiPk9wdGlvbiBRLTEgKG9ydGhvZ29uYWwpPC9iPjogQWxsb3cgb25lIG91dHB1dCBmb2xkZXIgcGVyIHNvdXJjZSBmb2xkZXIuIDwvcD4NCjxwPk9ydGhvZ29uYWwgdG8gdGhlIG90aGVyIG9wdGlvbnMsIGZsZXhpYmlsaXR5IGNvdWxkIGJlIGltcHJvdmVkIGJ5IGFsbG93aW5nDQpkaWZmZXJlbnQgb3V0cHV0IGZvbGRlcnMgdG8gYmUgc3BlY2lmaWVkIGZvciBlYWNoIHNvdXJjZSBmb2xkZXIuIEluIG90aGVyIHdvcmRzLA0KYWxsb3dpbmcgdGhlIG91dHB1dCBmb2xkZXIgY291bGQgYmUgcGFydGl0aW9uZWQgYWxvbmcgc291cmNlIGZvbGRlciBsaW5lcy4gVGhlDQpjaGFuZ2VzIGFsbG93cywgZm9yIGV4YW1wbGUsIGEgc2luZ2xlIEphdmEgcHJvamVjdCB0byBjb250YWluIGJvdGggcHJvZHVjdA0Kc291cmNlIGNvZGUgYW5kIHRlc3Qgc3VpdGVzIHBhcnRpdGlvbmVkIGludG8gc2VwYXJhdGUgc291cmNlIGFuZCBvdXRwdXQNCmZvbGRlcnMuJm5ic3A7IDwvcD4NCjxwPlRoZSBhZGRpdGlvbmFsIG91dHB1dCBmb2xkZXJzIHdvdWxkIG5lZWQgdG8gZmluZCB0aGVpciB3YXkgb250byB0aGUgcnVudGltZQ0KY2xhc3MgcGF0aCwgYW5kIHRoZSBkZWJ1Z2dlciB3b3VsZCBuZWVkIHRvIGtub3cgaG93IHRvIG1hcCBmcm9tIGdlbmVyYXRlZCBjbGFzcw0KZmlsZSB0byBzb3VyY2UgZmlsZS4gTmVpdGhlciBzaG91bGQgYmUgYSBwcm9ibGVtLiA8L3A+DQo8cD5UaGlzIGNoYW5nZSB3b3VsZCBicmVhayBleGlzdGluZyBjbGllbnRzIHRoYXQgYXNzdW1lIHRoYXQgYWxsIGdlbmVyYXRlZCBjbGFzcw0KZmlsZXMgZm9yIGEgSmF2YSBwcm9qZWN0IGFyZSBpbiBhIHNpbmdsZSBvdXRwdXQgZm9sZGVyLiA8L3A+DQo8aDM+QXNzZXNzbWVudCA8L2gzPg0KPHVsPg0KICA8bGk+UC0xIGlzIGEgbm9uLXN0YXJ0ZXIuPC9saT4NCiAgPGxpPlAtMiBpcyBwcm9taXNpbmcsIGJ1dCByZXF1aXJlcyBjaGFuZ2VzIHRvIHRoZSBFY2xpcHNlIFBsYXRmb3JtLiZuYnNwOzwvbGk+DQogIDxsaT5QLTMgcmVxdWlyZXMgbm8gd29yayBidXQgaXMgb25seSBhIHBhcnRpYWwgc29sdXRpb24uPC9saT4NCiAgPGxpPlAtNCByZXF1aXJlcyBubyB3b3JrIGJ1dCBpcyBvbmx5IGEgcGFydGlhbCBzb2x1dGlvbi48L2xpPg0KPC91bD4NCjxoMj5BbGxvd2luZyBNdWx0aS1yb290ZWQgUHJvamVjdHM8L2gyPg0KPHA+SG93IGNvdWxkIHdlIGNoYW5nZSBFY2xpcHNlIHRvIG1ha2UgSmF2YSBwcm9qZWN0cyAoc291cmNlIGZvbGRlcnMgaW4NCnBhcnRpY3VsYXIpIGJlIG11bHRpLXJvb3RlZCByYXRoZXIgdGhhbiBzaW5nbGUtcm9vdGVkPzwvcD4NCjxwPkhlcmUgYXJlIHNvbWUgb3B0aW9ucyAoaW4gbm8gcGFydGljdWxhciBvcmRlcik6PC9wPg0KPHA+PGI+T3B0aW9uIE0tMTwvYj46IENoYW5nZSBKRFQgdG8gYWxsb3cgYSBKYXZhIHByb2plY3Qgc291cmNlIGZvbGRlciB0byBsaWUNCmluc2lkZSBhbm90aGVyIHByb2plY3QsIG9yIHRvIGxpZSBvdXRzaWRlIHRoZSB3b3Jrc3BhY2UuPC9wPg0KPHA+SXQgd291bGQgYmUgcmVsYXRpdmVseSBzdHJhaWdodGZvcndhcmQgdG8gYWxsb3cgYSBzb3VyY2UgZm9sZGVyIGZvciBhIEphdmENCnByb2plY3QgdG8gbGllIGluc2lkZSBhIGRpZmZlcmVudCBKYXZhIHByb2plY3QuIEJlY2F1c2UgdGhlc2UgZmlsZXMgYXJlIHN0aWxsDQppbnNpZGUgdGhlIHdvcmtzcGFjZSwgcmVzb3VyY2UgZGVsdGFzIGNhbiBzdGlsbCBiZSB1c2VkIGZvciB1cGRhdGluZyB0aGUgSmF2YQ0KbW9kZWwgYW5kIHRyaWdnZXJpbmcgcmVjb21waWxhdGlvbi48L3A+DQo8cD5TdXBwb3J0aW5nIGEgc291cmNlIGZvbGRlciBvdXRzaWRlIHRoZSB3b3Jrc3BhY2UgZW50aXJlbHkgd291bGQgaGF2ZSBtYW55IG9mDQp0aGUgc2FtZSBwcm9ibGVtcyBhcyB3aXRoIGV4dGVybmFsIG91dHB1dCBmb2xkZXJzLiBUaGVzZSBmaWxlcyB3b3VsZCBuZWVkIHRvIGJlDQphY2Nlc3NlZCB3aXRoIGphdmEuaW8uRmlsZSBBUEkgKG5vdCByZXNvdXJjZSBoYW5kbGVzKSwgYW5kIHRoZXJlIHdvdWxkIGJlIG5vDQpyZXNvdXJjZSBkZWx0YXMgZm9yIHVwZGF0aW5nIHRoZSBKYXZhIG1vZGVsIG9yIHRyaWdnZXJpbmcgcmVjb21waWxhdGlvbi48L3A+DQo8cD48Yj5PcHRpb24gTS0yPC9iPjogQ2hhbmdlIEVjbGlwc2UgUGxhdGZvcm0gdG8gJnF1b3Q7bW91bnQmcXVvdDsgYSBmaWxlIHN5c3RlbQ0KZGlyZWN0b3J5IGFzIGEgcHJvamVjdCBmb2xkZXIuPC9wPg0KPHA+V2Ugd291bGQgYWRkIGEgbmV3IHdvcmtzcGFjZSBjb25jZXB0IG9mIG1vdW50IHBvaW50cywgYW5kIGFsbG93IGEgZGlyZWN0b3J5DQppbiB0aGUgZmlsZSBzeXN0ZW0gdG8gYmUgZ3JhZnRlZCBpbnRvIGEgcHJvamVjdCdzIHJlc291cmNlIHRyZWUuIEZvciBleGFtcGxlLA0KbW91bnRpbmcgQzovSmF2YVNvdXJjZXMgYXQgL1Byb2plY3QxL3NyYyB3b3VsZCBtZWFuIHRoYXQgdGhlIGZpbGVzIGFuZCBmb2xkZXJzDQp1bmRlciAvUHJvamVjdDEvc3JjIGFyZSBzdG9yZWQgdW5kZXIgdGhlIHN1YmRpcmVjdG9yeSBDOi9KYXZhU291cmNlczsgZS5nLiwgdGhlDQpmaWxlIEM6L0phdmFTb3VyY2VzL2NvbS9leGFtcGxlL0VnZy5qYXZhIHdvdWxkIGFwcGVhciBpbiB0aGUgd29ya3NwYWNlIGF0IHRoZQ0KcmVzb3VyY2UgcGF0aCAvUHJvamVjdDEvc3JjL2NvbS9leGFtcGxlL0VnZy5qYXZhLiBBbnkgcHJvamVjdCBmaWxlcyBub3QgYmVsb3cgYQ0KbW91bnQgcG9pbnQgd291bGQgYmUgaGVsZCB3aXRoaW4gdGhlIHByb2plY3QncyByb290IGRpcmVjdG9yeSwgYXMgdGhleSBhcmUNCmN1cnJlbnRseS4gVG9vbHMgdGhhdCBuYXZpZ2F0ZSB0aGUgcmVzb3VyY2UgdHJlZSB1c2luZyB0aGUgd29ya3NwYWNlIEFQSSBuZWVkDQpub3QgYmUgYXdhcmUgb2YgdGhlIGZpbGUncyBsb2NhdGlvbi4mbmJzcDs8L3A+DQo8cD5JdCB3b3VsZCBhbHNvIGJlIHBvc3NpYmxlIHRvIGFsbG93IGEgcG9ydGlvbiBvZiBvbmUgcHJvamVjdCdzIHJlc291cmNlIHRyZWUNCnRvIGJlIGRpcmVjdGx5IGdyYWZ0ZWQgaW50byBhbm90aGVyIChpbnN0ZWFkIG9mIGRvaW5nIHRoaXMgaW5kaXJlY3RseSB0aHJvdWdoIHRoZSBmaWxlIHN5c3RlbSkuDQpUaGlzIGltcGxpZXMgc29tZSBmb3JtIG9mIG92ZXJsYXAgYmUgYWxsb3dlZC48L3A+DQo8cD4NCldpdGggdGhlIGFiaWxpdHkgdG8gbW91bnQgYSBmaWxlIHN5c3RlbSBkaXJlY3RvcnkgaW50byB0aGUgcm9vdCBvZiBhIHByb2plY3QsIGENCkphdmEgcHJvamVjdCBjYW4gaGF2ZSBpdHMgc291cmNlIGZvbGRlcnMgaW4gZGlmZmVyZW50IGxvY2F0aW9ucyBvbiBkaXNrLg0KPC9wPg0KPHA+DQpUaGlzIHdvdWxkIGJlIGEgYnJlYWtpbmcgY2hhbmdlIGZvciBjbGllbnRzIG9mIHRoZSB3b3Jrc3BhY2UgYmVjYXVzZSBpdCBhbHRlcnMgdGhlIGN1cnJlbnQgDQppbXBsaWNpdCB1bmRlcnN0YW5kaW5nIHRoYXQgYWxsIHByb2plY3QgY29udGVudHMgYXJlIHN0b3JlZCBpbiBvbmUgZmlsZSBzeXN0ZW0NCnN1YnRyZWUuIEhvd2V2ZXIsIGl0IHNob3VsZCBiZSBwb3NzaWJsZSB0byBtaW5pbWl6ZSB0aGUgZWZmZWN0cyBvZiB0aGlzIGJyZWFrYWdlDQphbmQgcHJvdmlkZSBnb29kIGNvbXBhdGliaWxpdHkgd2l0aCBleGlzdGluZyAyLjAgdG9vbHMgYW5kIHRlYW0gKFZDTSkgcHJvdmlkZXJzLiZuYnNwOw0KPC9wPg0KPHA+PGI+T3B0aW9uIE0tMzwvYj46IEFkdm9jYXRlIHVzZSBvZiBPUy1sZXZlbCBzeW1saW5rcy4gPC9wPg0KPHA+VGhlIHVzZSBvZiBzeW1saW5rcyBpcyBkaXNjdXNzZWQgYWJvdmUgKE91dHB1dCBGb2xkZXIsIE9wdGlvbiBQLTMpLiBUaGVzZSBhcmUNCnRoZSBmaWxlIHN5c3RlbSBlcXVpdmFsZW50cyBvZiB0aGUgbW91bnQgcG9pbnRzIGluIE9wdGlvbiBNLTIuIDwvcD4NCjxwPlRoZSBhZHZhbnRhZ2Ugb2YgdGhpcyBvcHRpb24gaXMgdGhhdCB0aGUgdXNlciBjYW4gY3JlYXRlIHRoaXMgYXJyYW5nZW1lbnQNCnVzaW5nIGV4aXN0aW5nIE9TLXNwZWNpZmljIHRvb2xzLCBhbmQgZG9lcyBub3QgcmVxdWlyZSBleHBsaWNpdCBzdXBwb3J0IGZyb20gdGhlDQpFY2xpcHNlLiBTbyB0aGlzIG9wdGlvbiBpcyBhbHJlYWR5IHN1cHBvcnRlZCBpbiAyLjAuIDwvcD4NCjxwPk9wZXJhdGluZyBzeXN0ZW1zJm5ic3A7IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiBzeW1saW5rcyB0aGF0IG1ha2UgdGhpcyBvcHRpb24gbGVzcw0Kd29ya2FibGUgZm9yIHNvbWUgcHVycG9zZXMuIEZvciBpbnN0YW5jZSwgTlRGUyBqdW5jdGlvbnMgd29yayBvbiBXaW5kb3dzDQoyMDAwIG9yIGJldHRlciwgYW5kIG9ubHkgd29yayB3aXRoaW4NCmFuZCBiZXR3ZWVuIGxvY2FsIGRyaXZlcy4gRnVydGhlcm1vcmUsIGp1bmN0aW9ucyBhcmUgYW4gdW5zdXBwb3J0ZWQgZmVhdHVyZS4gPC9wPg0KPGgzPkFzc2Vzc21lbnQgPC9oMz4NCjx1bD4NCiAgPGxpPk0tMSBpcyBhIG5vbi1zdGFydGVyLjwvbGk+DQogIDxsaT5NLTIgaXMgcHJvbWlzaW5nLCBidXQgcmVxdWlyZXMgY2hhbmdlcyB0byB0aGUgRWNsaXBzZSBQbGF0Zm9ybSAoc2FtZQ0KICAgIGNoYW5nZSBhcyBQLTIpLiZuYnNwOzwvbGk+DQogIDxsaT5NLTMgcmVxdWlyZXMgbm8gd29yayBidXQgaXMgb25seSBhIHBhcnRpYWwgc29sdXRpb24uPC9saT4NCjwvdWw+DQo8aDI+QWxsb3dpbmcgU2VsZWN0aXZpdHk8L2gyPg0KPHA+SG93IGNvdWxkIHdlIGNoYW5nZSBFY2xpcHNlIHRvIG1ha2UgdGhlIEphdmEgc291cmNlIGZvbGRlcnMgc2VsZWN0aXZlIHJhdGhlcg0KdGhhbiBhbGwtaW5jbHVzaXZlPzwvcD4NCjxwPkhlcmUgYXJlIHNvbWUgb3B0aW9ucyAoaW4gbm8gcGFydGljdWxhciBvcmRlcik6PC9wPg0KPHA+PGI+T3B0aW9uIFMtMTwvYj46IENoYW5nZSBFY2xpcHNlIFBsYXRmb3JtIHRvIGFkZCBzdXBwb3J0IGZvciByZXNvdXJjZSB3b3JraW5nIHNldHMgd2l0aCB0aGUgY2FwYWJpbGl0eSB0byBicm93c2UgYW5kIG1hbmlwdWxhdGUgYSBzdWJzZXQgb2YgdGhlIHdvcmtzcGFjZSB3aGVyZSBjZXJ0YWluIGZpbGVzIGFuZCBmb2xkZXJzIGFyZSBleGNsdWRlZC48L3A+DQo8cD5UaGlzIG9wdGlvbiBkb2VzIG5vdCBpbnZvbHZlIGNoYW5naW5nIHRoZSBuYXR1cmUgb2YgdGhlIHdvcmtzcGFjZSByZXNvdXJjZQ0KdHJlZSBhbmQgaXRzIHJlbGF0aW9uIHRvIHRoZSBmaWxlIHN5c3RlbS4gSXQgc2ltcGx5IGFkZHMgd2F5cyB0byBwcm92aWRlDQpmaWx0ZXJlZCB2aWV3cyBvZiB0aGF0IHJlc291cmNlIHRyZWUuPC9wPg0KPHA+QSBKYXZhIHByb2plY3Qgc291cmNlIGZvbGRlciBpcyBjdXJyZW50bHkgc3BlY2lmaWVkIHdpdGggYSBwcm9qZWN0LXJlbGF0aXZlDQpmb2xkZXIgcGF0aC4gQWxsICouamF2YSBzb3VyY2UgZmlsZXMgZm91bmQgaW4gdGhlIHByb2plY3Qgc3VidHJlZSBhcmUNCmF1dG9tYXRpY2FsbHkgaW5jbHVkZWQgaW4gdGhlIEphdmEgbW9kZWwgYW5kIG9uIHRoZSBKYXZhIGNvbXBpbGVyJ3MgY2xhc3MNCnBhdGguIFRoZSBzb3VyY2UgZm9sZGVyIHNwZWNpZmljYXRpb24gY291bGQgYmUgZW5oYW5jZWQgdG8gcGVybWl0IHRoZSB1c2VyIHRvDQpzcGVjaWZ5IHdoaWNoIGZpbGVzIGFuZCBmb2xkZXJzIHRvIGV4Y2x1ZGUgKHRoaW5rIDxhIGhyZWY9Imh0dHA6Ly9qYWthcnRhLmFwYWNoZS5vcmcvYW50L21hbnVhbC9Db3JlVHlwZXMvZmlsZXNldC5odG1sIj5BbnQNCmZpbGVzZXRzPC9hPikuPC9wPg0KPHA+VGhlIHNvdXJjZSBmb2xkZXJzIG9mIGEgSmF2YSBwcm9qZWN0IGFyZSBub3QgY3VycmVudGx5IGFsbG93ZWQgdG8gY29pbmNpZGUgb3INCm90aGVyd2lzZSBvdmVybGFwLiBTb21lIHJlbGF4YXRpb24gb2YgdGhpcyBydWxlIGlzIHJlcXVpcmVkIHRvIGhhbmRsZSB0aGUgY2FzZSB3aGVyZSBhIHNvdXJjZSBmb2xkZXINCmNvbnRhaW5pbmcgdGVzdHMgaXMgbmVzdGVkIGluc2lkZSB0aGUgbWFpbiBzb3VyY2UgZm9sZGVyICg8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2VjbGlwc2UvZGV2ZWxvcG1lbnQvaW5mbGV4aWJsZS1wcm9qZWN0cy1wcm9ibGVtLmh0bWwiPkV4YW1wbGUNCjM8L2E+KS4gT25lIHJlbGF4YXRpb24gaXMgdG8gYWxsb3cgc291cmNlIGZvbGRlcnMgdG8gY29pbmNpZGUgb3Igb3ZlcmxhcCBidXQgdXNlIHRoZSBtZWNoYW5pc20gZm9yIGV4Y2x1ZGluZw0KZmlsZXMgdG8gcHJldmVudCB0aGUgc2FtZSBmaWxlIGZyb20gYmVpbmcgaW5jbHVkZWQgaW4gYm90aCBzb3VyY2UgZm9sZGVycy48L3A+DQo8cD5UaGlzIG9wdGlvbiB3b3VsZCBlbnRhaWwgY2hhbmdpbmcgRWNsaXBzZSBQbGF0Zm9ybSBDb3JlIHRvIHByb3ZpZGUgaW5mcmFzdHJ1Y3R1cmUsIHBvc3NpYmx5IGluIHRoZSBmb3JtIG9mIGEgcnVsZS1iYXNlZCByZXNvdXJjZQ0KdmlzaXRvci4gV2Ugd291bGQgZXhwbG9yZSBhIHBvc3NpYmxlIGNvbm5lY3Rpb24gdG8gdGhlIGV4aXN0aW5nIFVJIG5vdGlvbiBvZiB3b3JraW5nIHNldHMuIEpEVCBDb3JlIEFQSQ0KYW5kIEpEVCBVSSB3b3VsZCBuZWVkIHRvIGNoYW5nZSBhcyB3ZWxsLCBidXQgY291bGQNCmxpa2VseSBiZSBkb25lIGluIGEgbm9uLWJyZWFraW5nIG1hbm5lciBieSBhZGRpbmcgd29ya2luZyBzZXRzIHRvDQpjbGFzc3BhdGggZW50cmllcyAoPGEgaHJlZj0iaHR0cDovL2Rldi5lY2xpcHNlLm9yZzo4MDgwL2hlbHAvY29udGVudC9oZWxwOi9vcmcuZWNsaXBzZS5qZHQuZG9jLmlzdi9yZWZlcmVuY2UvYXBpL29yZy9lY2xpcHNlL2pkdC9jb3JlL0lDbGFzc3BhdGhFbnRyeS5odG1sIj5JQ2xhc3NwYXRoRW50cnk8L2E+KQ0KYW5kIHJldmFtcGluZyB0aGUgcnVsZXMgZm9yIGxlZ2FsIHNvdXJjZSBmb2xkZXIgb3ZlcmxhcC48L3A+DQo8cD48Yj5PcHRpb24gUy0yIChvcnRob2dvbmFsKTwvYj46IENoYW5nZSBKRFQgdG8gYWxsb3cgb3ZlcmxhcHBpbmcgc291cmNlIGZvbGRlcnMgYnV0DQphdXRvbWF0aWNhbGx5IGV4Y2x1ZGUgdGhlIG92ZXJsYXBwZWQgcG9ydGlvbiBmcm9tIHRoZSBwYXJlbnQuPC9wPg0KPHA+QSBkaWZmZXJlbnQgYXBwcm9hY2ggaXMgdG8gcHJvdmlkZSB0aGUga2luZCBvZiBzZWxlY3Rpdml0eSByZXF1aXJlZCB0byBoYW5kbGUNCmNhc2VzIGxpa2Ugd2hlcmUgYSBzb3VyY2UgZm9sZGVyDQpjb250YWluaW5nIHRlc3RzIGlzIG5lc3RlZCBpbnNpZGUgdGhlIG1haW4gc291cmNlIGZvbGRlciAoPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9lY2xpcHNlL2RldmVsb3BtZW50L2luZmxleGlibGUtcHJvamVjdHMtcHJvYmxlbS5odG1sIj5FeGFtcGxlDQozPC9hPikuIFRoZSBzb2x1dGlvbiBpcyB0byBhbGxvdyB0aGUgb3ZlcmxhcCwgYnV0IGF1dG9tYXRpY2FsbHkgZXhjbHVkZSB0aGUNCmZpbGVzIGFjY291bnRlZCBmb3IgYnkgdGhlIG1vcmUgc3BlY2lmaWMgZm9sZGVyIGZyb20gdGhlIGxlc3Mgc3BlY2lmaWMgb25lLiBGb3INCmV4YW1wbGUsIGlmIC9zcmMvIGFuZCAvc3JjL3Rlc3RzLyBhcyBib3RoIHNwZWNpZmllZCBhcyBzb3VyY2UgZm9sZGVycywgZmlsZXMNCnVuZGVyIC9zcmMvdGVzdHMvIHdvdWxkIG9ubHkgYXBwZWFyIHVuZGVyIHRoZSBsYXR0ZXIgc291cmNlIGZvbGRlciwgYW5kIHRoZQ0KZm9ybWVyIHNvdXJjZSBmb2xkZXIgd291bGQgYWN0IGFzIGlmIGl0IGhhZCBubyBjaGlsZCBuYW1lZCB0ZXN0cy48L3A+DQo8cD5UaGlzIG9wdGlvbiB3b3VsZCBpbnZvbHZlIGEgbm9uLWJyZWFraW5nIGNoYW5nZSB0byBKRFQgdG8gcmVtb3ZlIHRoZSBjdXJyZW50DQpyZXN0cmljdGlvbnMgdGhhdCBwcm9oaWJpdCBvdmVybGFwIGFuZCBkZWZpbmUgaG93IG92ZXJsYXBwaW5nIHNvdXJjZSBmb2xkZXJzIGFyZQ0KaW50ZXJwcmV0ZWQuIFRoaXMgb3B0aW9uIGlzIG9ydGhvZ29uYWwgdG8gdGhlIG90aGVyIHNlbGVjdGl2aXR5IG9wdGlvbnMsIGFuZA0KY291bGQgYmUgZG9uZSBpbiBjb25qdW5jdGlvbiB3aXRoIGFueSBvZiB0aGVtLjwvcD4NCjxwPjxiPk9wdGlvbiBTLTM8L2I+OiBSYWRpY2FsbHkgY2hhbmdlIHRoZSBFY2xpcHNlIFBsYXRmb3JtIHBvbGljeSBmb3IgYWRkaW5nIGFuZCByZW1vdmluZw0KZmlsZXMgZnJvbSB0aGUgd29ya3NwYWNlLjwvcD4NCjxwPlRoZSB3b3Jrc3BhY2UgZm9sZGVyIHJlZnJlc2ggb3BlcmF0aW9uICg8YSBocmVmPSJodHRwOi8vZGV2LmVjbGlwc2Uub3JnOjgwODAvaGVscC9jb250ZW50L2hlbHA6L29yZy5lY2xpcHNlLnBsYXRmb3JtLmRvYy5pc3YvcmVmZXJlbmNlL2FwaS9vcmcvZWNsaXBzZS9jb3JlL3Jlc291cmNlcy9JUmVzb3VyY2UuaHRtbCNyZWZyZXNoTG9jYWwiPklSZXNvdXJjZS5yZWZyZXNoTG9jYWw8L2E+KSBhdXRvbWF0aWNhbGx5IGNyZWF0ZXMgZW50cmllcyBpbiB0aGUgd29ya3NwYWNlIHJlc291cmNlIHRyZWUNCmZvciBuZXdseSBkaXNjb3ZlcmVkIGZpbGVzIGFuZCBmb2xkZXJzIG91dCBpbiB0aGUgZmlsZSBzeXN0ZW0sIGFuZCBkaXNjYXJkcw0KZW50cmllcyBmb3IgYW55IGZpbGVzIGFuZCBmb2xkZXJzIHRoYXQgYXJlIG5vIGxvbmdlciBwcmVzZW50IGluIHRoZSBmaWxlIHN5c3RlbS4NCihUaGlzIHJlZnJlc2ggYWN0aW9uIGlzIGFsc28gaW1wbGljaXQgaW4gYSBudW1iZXIgb2Ygd29ya3NwYWNlIG9wZXJhdGlvbnMgd2hlbg0KdGhlIGZvcmNlIGZsYWcgaXMgdXNlZCkuIFRoaXMgY2hhcmFjdGVyaXN0aWMgbWFrZXMgYSBwcm9qZWN0J3Mgd29ya3NwYWNlDQpyZXNvdXJjZSB0cmVlIGEgbW9yZS1vci1sZXNzIGZhaXRoZnVsIG1pcnJvciBvZiB0aGUgcHJvamVjdCdzIHN1YnRyZWUgaW4gdGhlDQpmaWxlIHN5c3RlbS4gVGhpcyBnaXZlcyB3b3Jrc3BhY2UgcHJvamVjdHMgdGhlaXIgYWxsLWluY2x1c2l2ZSBmZWVsLjwvcD4NCjxwPlRoZXJlIGFyZSBvdGhlciBJREVzIChpbmNsdWRpbmcgVmlzdWFsIFN0dWRpbyAubmV0KSB0aGF0IGFsbG93IHRoZSB1c2VyIHRvDQpjb250cm9sIHdoaWNoIGZpbGVzIGFuZCBmb2xkZXJzIGJlbG9uZyBpbiBhIHByb2plY3Q7IG90aGVyIGZpbGVzIGFuZCBmb2xkZXJzIG1heQ0KZXhpc3QgaW4gdGhlIGxvY2FsIGZpbGUgc3lzdGVtLCBidXQgYXJlIHNpbXBseSBpZ25vcmVkIGJ5IHRoZSBJREUgaWYgbm90IGZsYWdnZWQNCmFzIGJlbG9uZ2luZyB0byB0aGUgcHJvamVjdC4gVGhpcyBjaGFyYWN0ZXJpc3RpYyBtZWFucyB0aGF0IHRoZSBJREUncyBub3Rpb24gb2YNCnByb2plY3QgaXMgbW9yZSBsaWtlIGEgJnF1b3Q7dmlldyZxdW90OyBvbnRvIGZpbGVzIGluIHRoZSBmaWxlIHN5c3RlbS4gVGhpcw0KYWx0ZXJuYXRlIGNvbmNlcHRpb24gb2Ygd29ya3NwYWNlIGNvdWxkIGJlIGFjaGlldmVkIGJ5IGNoYW5naW5nIEVjbGlwc2UgcG9saWN5DQpzbyB0aGF0IGZpbGUgYW5kIGZvbGRlciBlbnRyaWVzIGFyZSBuZXZlciBhZGRlZCB0byBvciByZW1vdmVkIGZyb20gdGhlIHJlc291cmNlDQp0cmVlIGR1ZSB0byBhIHJlZnJlc2ggb3BlcmF0aW9uOyBuZXcgQVBJIHdvdWxkIGJlIGFkZGVkIHNvIHRoYXQgZW50cmllcyBjb3VsZCBiZQ0KYWRkZWQgb3IgcmVtb3ZlZCBleHBsaWNpdGx5LiBUaGlzIHdvdWxkIGdpdmUgd29ya3NwYWNlIHByb2plY3RzIGEgc2VsZWN0aXZlDQpmZWVsLjwvcD4NCjxwPk9uIHRoZSBwbHVzIHNpZGUsIHRoZSByZXNvdXJjZSB0cmVlIHdvdWxkIGJlIHNtYWxsZXIgaWYgc29tZSBmaWxlcyBhbmQNCmZvbGRlcnMgd2VyZSB0byBiZSBleGNsdWRlZCwgYW5kIHRoaXMgd291bGQgaW1wcm92ZSBwZXJmb3JtYW5jZS4gSXQgd291bGQgYWxzbw0KcmVkdWNlIHdvcmtzcGFjZSBjbHV0dGVyIGFuZCBtYWtlIEVjbGlwc2UgYmVoYXZlIG1vcmUgbGlrZSBjZXJ0YWluIG90aGVyIHBvcHVsYXINCklERXMgKFZpc3VhbCBTdHVkaW8gLk5FVCkuPC9wPg0KPHA+VGhlIGRvd25zaWRlIG9mIHRoaXMgb3B0aW9uIGlzIHRoYXQgaXQgaXMgaW1wb3NzaWJsZSB0byBkbyB3aGlsZSBtYWludGFpbmluZw0KY29tcGF0aWJpbGl0eS4gQ29uc2lkZXIgYW4gZXhpc3RpbmcgdG9vbCB0aGF0IGlzIGNhbGxpbmcgSVJlc291cmNlLnJlZnJlc2hMb2NhbA0KdG8gY2F1c2UgZmlsZXMgY3JlYXRlZCBkaXJlY3RseSBpbiB0aGUgZmlsZSBzeXN0ZW0gdG8gYXBwZWFyIGluIHRoZSB3b3Jrc3BhY2UgKGENCmNvbW1vbiBwcm9ibGVtIHdoZW4gYnJpZGdpbmcgZXh0ZXJuYWwgcHJvZ3JhbXMgdG8gRWNsaXBzZSkuIENoYW5naW5nIHRoZQ0Kc2VtYW50aWNzIG9mIElSZXNvdXJjZS5yZWZyZXNoTG9jYWwgc28gdGhhdCBpdCBkb2VzIG5vdCBkaXNjb3ZlciBuZXcgZmlsZXMgd291bGQNCmNsZWFybHkgYnJlYWsgdGhpcyB0b29sLiBPbiB0aGUgb3RoZXIgaGFuZCwgaWYgdGhlIHNlbWFudGljcyBvZg0KSVJlc291cmNlLnJlZnJlc2hMb2NhbCBpcyBub3QgY2hhbmdlZCwgdGhlbiBydW5uaW5nIHRoaXMgdG9vbCB3b3VsZA0KYXV0b21hdGljYWxseSBhZG1pdCBmaWxlcyB0byB0aGUgd29ya3NwYWNlLCBldmVuIGFnYWluc3QgdGhlIHVzZXIncyB3aXNoZXMuDQpFaXRoZXIgcGF0aCBsZWFkcyB0byBhIGRpZmZlcmVudCBraW5kIG9mIGJyZWFrYWdlLjwvcD4NCjxwPjxiPk9wdGlvbiBTLTQ8L2I+OiBBZGQgRWNsaXBzZSBQbGF0Zm9ybSBtZWNoYW5pc20gdG8gcHJldmVudCByZWZyZXNoTG9jYWwgZnJvbQ0KYWRkaW5nIGNlcnRhaW4gZmlsZXMgdG8gdGhlIHdvcmtzcGFjZSByZXNvdXJjZSB0cmVlLjwvcD4NCjxwPkFub3RoZXIgb3B0aW9uIGlzIHRvIGNoYW5nZSB0aGUgRWNsaXBzZSBQbGF0Zm9ybSByZWZyZXNoIG1lY2hhbmlzbSBpcyBhIG1vcmUNCm1vZGVzdCB3YXkgdG8gcHJvdmlkZSBhIHdheSB0byBzZWxlY3RpdmVseSBleGNsdWRlIGZpbGVzLiBJZiB0aGUgcmVmcmVzaA0Kb3BlcmF0aW9uIHdhcyBnb3Zlcm5lZCBieSBleGNsdXNpb24gcnVsZXMsIGl0IHdvdWxkIGJlIHBvc3NpYmxlIGZvciB0aGUgdXNlciB0bw0KZXhwbGljaXRseSBwcmV2ZW50IGNlcnRhaW4gZmlsZXMgYW5kIGZvbGRlcnMgaW4gdGhlIGZpbGUgc3lzdGVtIGZyb20gYmVpbmcgYWRkZWQNCmF1dG9tYXRpY2FsbHkgdG8gdGhlIHdvcmtzcGFjZS4gQnkgZGVmYXVsdCwgdGhlcmUgd291bGQgYmUgbm8gZXhjbHVzaW9uIHJ1bGVzLA0KYW5kIHRoZSB3b3Jrc3BhY2Ugd291bGQgYmVoYXZlIGV4YWN0bHkgYXMgaW4gMi4wLiBJZiB0aGUgdXNlciBpbmRpY2F0ZXMgdGhhdCBhDQpwYXJ0aWN1bGFyIGZpbGUgb3IgZm9sZGVyIGlzIHRvIGJlIGV4Y2x1ZGVkLCB0aGUgcmVmcmVzaCBvcGVyYXRpb24gd291bGQgbmV2ZXINCmFkZCBpdCB0byB0aGUgcmVzb3VyY2UgdHJlZSwgZXZlbiBpZiB0aGUgZmlsZSBvciBmb2xkZXIgZXhpc3RzIGluIHRoZSBmaWxlDQpzeXN0ZW0uIFRoaXMgd291bGQgZ2l2ZSB3b3Jrc3BhY2UgcHJvamVjdHMgYW4gaW5pdGlhbGx5IGFsbC1pbmNsdXNpdmUgZmVlbCB3aGljaA0KY291bGQgYmUgbWFkZSBtb3JlIHNlbGVjdGl2ZSBhcyByZXF1aXJlZC48L3A+DQo8cD5OZXcgQVBJIHdvdWxkIGJlIHJlcXVpcmVkIHRvIGNoYW5nZSB0aGUgZXhjbHVzaW9uIHJ1bGUgc2V0LCB0byBleHBsaWNpdGx5IGFkZA0KYSBmaWxlIG9yIGZvbGRlciB0byB0aGUgcmVzb3VyY2UgdHJlZSBldmVuIGlmIG9uIHRoZSBleGNsdWRlZCBsaXN0LCBhbmQgdG8NCnJlbW92ZSBhIGZpbGUgb3IgZm9sZGVyIGZyb20gdGhlIHJlc291cmNlIHRyZWUgd2l0aG91dCBkZWxldGluZyB0aGUgZmlsZSBpbiB0aGUNCmZpbGUgc3lzdGVtLiBUaGUgc2VtYW50aWNzIG9mIElSZXNvdXJjZS5yZWZyZXNoTG9jYWwgd291bGQgbm90IGhhdmUgdG8gY2hhbmdlIGluDQphIGJyZWFraW5nIHdheS4gQSBwcm9qZWN0J3Mgd29ya3NwYWNlDQpyZXNvdXJjZSB0cmVlIGlzIGEgbW9yZS1vci1sZXNzIGZhaXRoZnVsIG1pcnJvciBvZiB0aGUgcHJvamVjdCdzIHN1YnRyZWUgaW4gdGhlDQpmaWxlIHN5c3RlbSBleGNlcHQgZm9yIHRoZSBmaWxlcyBhbmQgZm9sZGVycyB0aGF0IHRoZSB1c2VyIGhhcyBleHBsaWNpdGx5IHRha2VuDQpvZmYgdGhlIHRhYmxlLjwvcD4NCjxwPk9uIHRoZSBwbHVzIHNpZGUsIHRoZSByZXNvdXJjZSB0cmVlIHdvdWxkIGJlIHNtYWxsZXIgaWYgc29tZSBmaWxlcyBhbmQNCmZvbGRlcnMgd2VyZSB0byBiZSBleGNsdWRlZCwgYW5kIHRoaXMgd291bGQgaW1wcm92ZSBwZXJmb3JtYW5jZS4gSXQgd291bGQgYWxzbw0KcmVkdWNlIHdvcmtzcGFjZSBjbHV0dGVyIGFuZCBtYWtlIEVjbGlwc2UgYmVoYXZlIG1vcmUgbGlrZSBjZXJ0YWluIG90aGVyIHBvcHVsYXINCklERXMuIE9uIHRoZSBtaW51cyBzaWRlLCBpdCBkb2VzIG1lYW4gdGhhdCBpbi1tZW1vcnkgd29ya3NwYWNlIHJlc291cmNlIHRyZWUgaXMNCm5vdCBxdWl0ZSBhcyBmYWl0aGZ1bCBhJm5ic3A7bWlycm9yIG9mIHRoZSBmaWxlIHN5c3RlbS48L3A+DQo8cD48Yj5PcHRpb24gUy01PC9iPjogQWRkIEVjbGlwc2UgUGxhdGZvcm0gbWVjaGFuaXNtIHRvIGhpZGUgY2VydGFpbiBmaWxlcyBpbiB0aGUgd29ya3NwYWNlIHJlc291cmNlDQp0cmVlLjwvcD4NCjxwPiBFY2xpcHNlIFBsYXRmb3JtIDIuMCBoYXMgYSAmcXVvdDt0ZWFtIHByaXZhdGUgbWVtYmVyJnF1b3Q7IG1lY2hhbmlzbSBmb3INCmhpZGluZyBjZXJ0YWluIHJlc291cmNlcy4gVGhlc2UgcmVzb3VyY2VzIGFyZSByZXByZXNlbnRlZCBieSBlbnRyaWVzIGluIHRoZQ0Kd29ya3NwYWNlIHJlc291cmNlIHRyZWUsIGJ1dCBhcmUgZXhwbGljaXRseSBtYXJrZWQgYXMgaGlkZGVuIHNvIHRoYXQgY2xpZW50cw0Kd2lsbCBub3Qgc2VlIHRoZXNlIHJlc291cmNlcyB1bmxlc3MgdGhleSBhc2sgdG8gc2VlIHRoZW0uIEltYWdpbmUgdGhhdCB0aGlzDQptZWNoYW5pc20gd2FzIGdlbmVyYWxpemVkIGFuZCBleHRlbmRlZCBzbyB0aGF0IG90aGVyIHJlc291cmNlcyBjb3VsZCBiZQ0Kc2ltaWxhcmx5IGhpZGRlbiBmcm9tIGNsaWVudHMgdGhhdCBkbyBub3QgYXNrIGZvciB0aGVtLiBCeSBkZWZhdWx0LCB0aGVyZSB3b3VsZCBiZSBubw0KaGlkZGVuIGZpbGVzLA0KYW5kIHRoZSB3b3Jrc3BhY2Ugd291bGQgYmVoYXZlIGV4YWN0bHkgYXMgaW4gMi4wLiBUaGUgcmVmcmVzaCBvcGVyYXRpb24gd291bGQNCmF1dG9tYXRpY2FsbHkgYWRkIGFuZCByZW1vdmUgZmlsZXMgYXMgaW4gMi4wLiBUaGUgdXNlciBjb3VsZCBleHBsaWNpdGx5IGNvbnRyb2wNCndoZXRoZXIgdGhleSB3ZXJlIG1hcmtlZCBhcyBoaWRkZW4sIGFuZCB3aGV0aGVyIGhpZGRlbiBmaWxlcyB3ZXJlIHNob3duIGluIHRoZQ0KVUkuIFRoaXMgd291bGQgZ2l2ZSB3b3Jrc3BhY2UgcHJvamVjdHMgYW4gYWxsLWluY2x1c2l2ZSBmZWVsDQp3aGljaCB0aGUgdXNlcg0KY291bGQgbWFrZSBtb3JlIHNlbGVjdGl2ZSBhcyByZXF1aXJlZC48L3A+DQo8cD5OZXcgQVBJIHdvdWxkIGJlIHJlcXVpcmVkIHRvIGNoYW5nZSB0aGUgaGlkZGVuIGZsYWcgYW5kIHRvIGluY2x1ZGUgb3IgZXhjbHVkZQ0KaGlkZGVuIHJlc291cmNlcyB3aGVuIG5hdmlnYXRpbmcgdGhlIHdvcmtzcGFjZS4gVGhlIHNlbWFudGljcyBvZiBJUmVzb3VyY2UucmVmcmVzaExvY2FsIHdvdWxkIG5vdCBoYXZlIHRvIGNoYW5nZS4gQSBwcm9qZWN0J3Mgd29ya3NwYWNlDQpyZXNvdXJjZSB0cmVlIGlzIGEgbW9yZS1vci1sZXNzIGZhaXRoZnVsIG1pcnJvciBvZiB0aGUgcHJvamVjdCdzIHN1YnRyZWUgaW4gdGhlDQpmaWxlIHN5c3RlbSBleGNlcHQgZm9yIHRoZSBmaWxlcyBhbmQgZm9sZGVycyB0aGF0IHRoZSB1c2VyIGhhcyBleHBsaWNpdGx5IHRha2VuDQpvZmYgdGhlIHRhYmxlLjwvcD4NCjxoMz5Bc3Nlc3NtZW50IDwvaDM+DQo8dWw+DQogIDxsaT5TLTEgaXMgcHJvbWlzaW5nLjwvbGk+DQogIDxsaT5TLTIgaXMgYWxzbyBwcm9taXNpbmc7IGl0IHByb3ZpZGVzIGxlc3MgZmxleGliaWxpdHkgdGhhdCBTLTEsIGJ1dCBpcyBhbHNvDQogICAgc2ltcGxlciBhbGwgYXJvdW5kLjwvbGk+DQogIDxsaT5TLTMgaXMgYSBub24tc3RhcnRlci48L2xpPg0KICA8bGk+Uy00IGlzIHByb21pc2luZy48L2xpPg0KICA8bGk+Uy01IGlzIHByb21pc2luZy48L2xpPg0KPC91bD4NCjxoMj5BbGxvd2luZyBPdmVybGFwPC9oMj4NCjxwPkhvdyBjb3VsZCB3ZSBjaGFuZ2UgRWNsaXBzZSB0byBhbGxvdyBKYXZhIHNvdXJjZSBmb2xkZXJzIHRvIG92ZXJsYXA/PC9wPg0KPHA+SGVyZSBhcmUgc29tZSBvcHRpb25zIChpbiBubyBwYXJ0aWN1bGFyIG9yZGVyKTo8L3A+DQo8cD48Yj5PcHRpb24gVi0xPC9iPjogQ2hhbmdlIEpEVCB0byBhbGxvdyBvdmVybGFwIHdpdGhpbiBhIHByb2plY3QncyBzb3VyY2UNCmZvbGRlcnMuPC9wPg0KPHA+VGhpcyBvcHRpb24gaXMgZGlzY3Vzc2VkIGluIFMtMSBhbmQgUy0yLjwvcD4NCjxwPjxiPk9wdGlvbiBWLTI8L2I+OiBBbGxvdyAmcXVvdDttb3VudGVkJnF1b3Q7IGZpbGUgc3lzdGVtIGRpcmVjdG9yaWVzIHRvDQpvdmVybGFwLjwvcD4NCjxwPk9uZSBvZiB0aGUgZGVzaWduIGRldGFpbHMgb2Ygb3B0aW9uIE0tMiBpcyB3aGV0aGVyIHRvIGFsbG93IG1vdW50ZWQNCmRpcmVjdG9yaWVzIHRvIG92ZXJsYXAsIGVpdGhlciB3aXRoaW4gYSBzaW5nbGUgcHJvamVjdCBvciBhY3Jvc3MgYWxsIHByb2plY3RzIGluDQp0aGUgd29ya3NwYWNlLiZuYnNwOzwvcD4NCjxwPiBUaGUgc2ltcGxlIGludGVycHJldGF0aW9uIG9mIG92ZXJsYXBwaW5nIG1vdW50IHBvaW50cyB3b3VsZCBtZWFuIHRoYXQgdGhlIHNhbWUgZmlsZSBvbg0KZGlzayBtaWdodCBoYXZlIG11bHRpcGxlIGRpc3RpbmN0IHJlc291cmNlIGhhbmRsZXMuIFRoaXMgd291bGQgY3JlYXRlIGEgc2VtYW50aWMNCnByb2JsZW0gZm9yIHRoZSBJV29ya3NwYWNlUm9vdC5nZXRDb250YWluZXIvRmlsZUZvckxvY2F0aW9uIEFQSSBtZXRob2RzIHdoaWNoDQpwcmVzdXBwb3NlIHRoYXQgdGhlcmUgaXMgYXQgbW9zdCBvbmUgcmVzb3VyY2UgaGFuZGxlIGZvciBhbnkgY2FuZGlkYXRlIGZpbGUgc3lzdGVtIHBhdGguPC9wPg0KPHA+T3RoZXIgaXNzdWVzIGlmIHR3byByZXNvdXJjZXMgL1AxL0Zvby50eHQgYW5kIC9QMi9Gb28udHh0IGNvcnJlc3BvbmQgdG8gdGhlDQpzYW1lIGZpbGUgQzovU291cmNlcy9Gb28udHh0OjwvcD4NCjx1bD4NCiAgPGxpPlJlZnJlc2g6IERvZXMgcmVmcmVzaGluZyBvbmUgcmVzb3VyY2UgYWxzbyByZWZyZXNoIHRoZSBvdGhlcj88L2xpPg0KICA8bGk+VkNNOiBIb3cgdG8gZGVjaWRlIHdoaWNoIHByb2plY3QgaXMgcmVzcG9uc2libGUgZm9yIFZDTT88L2xpPg0KPC91bD4NCjxoMz5Bc3Nlc3NtZW50IDwvaDM+DQo8dWw+DQogIDxsaT5WLTEgaXMgcHJvbWlzaW5nLjwvbGk+DQogIDxsaT5WLTIgaXMgcHJvbWlzaW5nLCBidXQgaGFzIHNvbWUgQVBJIGJyZWFrYWdlLCBhbmQgc29tZSBzZW1hbnRpYyBxdWVzdGlvbnMNCiAgICB0aGF0IG5lZWQgdG8gYmUgd29ya2VkIHRocm91Z2guPC9saT4NCjwvdWw+DQo8cD5PcHRpb25zIFYtMSBhbmQgVi0yIGFyZSBub3QgbmVjZXNzYXJpbHkgbXV0dWFsbHkgZXhjbHVzaXZlLiAgVGhlcmUgbWF5IGJlIHJlYXNvbiB0byBhbGxvdyBvdmVybGFwcGluZyBzb3VyY2UgZm9sZGVycyByZWdhcmRsZXNzIG9mIG1vdW50IHBvaW50cywgYW5kIHZpY2UtdmVyc2EuPC9wPg0KPC9ib2R5Pg0KPC9odG1sPg==