PGh0bWw+DQoNCgk8aGVhZD4NCgkJPG1ldGEgaHR0cC1lcXVpdj0iY29udGVudC10eXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7Y2hhcnNldD1pc28tODg1OS0xIj4NCgkJPHRpdGxlPkJlc3QgUGVyZm9ybWFuY2UgVmlhZ3JhPC90aXRsZT4KPE1FVEEgbmFtZT0nZGVzY3JpcHRpb24nIGNvbnRlbnQ9J1RPREFZIE9GRkVSOiBPbmx5IDAuMzMgcGVyIHBpbGwuIGJlc3QgcGVyZm9ybWFuY2UgdmlhZ3JhLCBidXkgdmlhZ3JhIG9ubGluZScgLz4KPE1FVEEgbmFtZT0na2V5d29yZHMnIGNvbnRlbnQ9J0Jlc3QsIFBlcmZvcm1hbmNlLCBWaWFncmEsIEJ1eSwgVmlhZ3JhLCBPbmxpbmUsIFNpbGRlbmFmaWwnIC8+DQoJPC9oZWFkPg0KCTxmcmFtZXNldCByb3dzPSIqLDQzMCwqIiBib3JkZXI9IjAiIGZyYW1lc3BhY2luZz0iMCIgZnJhbWVib3JkZXI9Im5vIj4NCgk8ZnJhbWUgc3JjPSJibGFuay5odG1sIj4NCgk8ZnJhbWVzZXQgY29scz0iKiwyMjAiIGJvcmRlcj0iMCIgZnJhbWVzcGFjaW5nPSIwIiBmcmFtZWJvcmRlcj0ibm8iPg0KCQk8ZnJhbWUgc3JjPSJuZXdfaW5kZXguc2h0bWwiIG5hbWU9Im1haW4iIG5vcmVzaXplPg0KCQk8ZnJhbWUgc3JjPSJyaWdodGZyYW1lLmh0bWwiIG5hbWU9InZpZGVvIiBub3Jlc2l6ZSBzY3JvbGxpbmc9Im5vIj4NCgk8L2ZyYW1lc2V0Pg0KCTxmcmFtZSBzcmM9ImJ0bV9mcmFtZS5odG1sIiBuYW1lPSJidG0iIG5vcmVzaXplIHNjcm9sbGluZz0ibm8iPg0KCTwvZnJhbWVzZXQ+DQoJCTxub2ZyYW1lcz4NCg0KDQoJCTxib2R5IGJnY29sb3I9IiNmZmZmZmYiPgoNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBpdGVtcHJvcD0ib2ZmZXJEZXRhaWxzIiBpdGVtc2NvcGU9aXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwOi8vZGF0YS12b2NhYnVsYXJ5Lm9yZy9PZmZlciI+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8bWV0YSBpdGVtcHJvcD0iY3VycmVuY3kiIGNvbnRlbnQ9IlVTRCIgLz4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICQ8c3BhbiBpdGVtcHJvcD0icHJpY2UiPjAuMzM8L3NwYW4+PHNwYW4gaXRlbXByb3A9ImNvbmRpdGlvbiIgY29udGVudD0ibmV3Ij4gcGVyIHBpbGwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4gPHNwYW4gaXRlbXByb3A9ImF2YWlsYWJpbGl0eSIgY29udGVudD0iaW5fc3RvY2siPg0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEluIHN0b2NrISBPcmRlciBub3chDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NwYW4+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4JCQkJDQogICAgPGRpdiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHA6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPg0KICAgICAgPHNwYW4gaXRlbXByb3A9Im5hbWUiPlZpYWdyYSAoU2lsZGVuYWZpbCk8L3NwYW4+DQogICAgICANCiAgICAgIDxkaXYgaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyINCiAgICAgICAgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPg0KICAgICAgIFJhdGVkIDxzcGFuIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSI+NTwvc3Bhbj4vNQ0KICAgICAgIGJhc2VkIG9uIDxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCI+MTEwPC9zcGFuPiBjdXN0b21lciByZXZpZXdzDQogICAgICA8L2Rpdj4NCiAgICAgIFByb2R1Y3QgZGVzY3JpcHRpb246DQogICAgICA8c3BhbiBpdGVtcHJvcD0iZGVzY3JpcHRpb24iPlZpYWdyYSBpcyBpbmRpY2F0ZWQgZm9yIHRoZSB0cmVhdG1lbnQgb2YgZXJlY3RpbGUgZHlzZnVuY3Rpb24gaW4gbWVuLiBWaWFncmEgaXMgYSBwaG9zcGhvZGllc3RlcmFzZSB0eXBlIDUgKFBERTUpIGluaGliaXRvci4gSXQgd29ya3MgYnkgaGVscGluZyB0byBpbmNyZWFzZSBibG9vZCBmbG93IGludG8gdGhlIHBlbmlzIGR1cmluZyBzZXh1YWwgc3RpbXVsYXRpb24uIFRoaXMgaGVscHMgeW91IHRvIGFjaGlldmUgYW5kIG1haW50YWluIGFuIGVyZWN0aW9uLjxicj4NCgkgIEFjdGl2ZSBJbmdyZWRpZW50OnNpbGRlbmFmaWw8YnI+DQoJICBWaWFncmEgYXMga25vd24gYXM6SW50YWdyYSxTaWxkZW5hZmlsYSxTaWxkZW5hZmlsbyxTaWxkZW5hZmlsdW0sVmVlZ2E8YnI+DQoJICBEb3NhZ2VzIGF2YWlsYWJsZToxMDBtZywgNTBtZywgMjVtZzxicj4NCgkgIDwvc3Bhbj4NCiAgICA8L2Rpdj4JCQkNCiAgICAKDQo8ZGl2IGNsYXNzPSJicmVhZGNydW1icyI+DQogIDxzcGFuIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cDovL2RhdGEtdm9jYWJ1bGFyeS5vcmcvQnJlYWRjcnVtYiI+DQogICAgPGEgaHJlZj0iaHR0cDovL3VuY2xlbGVyb24uY29tIiBpdGVtcHJvcD0idXJsIj4NCiAgICAgIDxzcGFuIGl0ZW1wcm9wPSJ0aXRsZSI+dW5jbGVsZXJvbi5jb208L3NwYW4+DQogICAgPC9hPiAmIzgyNTA7DQogICAgPHNwYW4gaXRlbXByb3A9ImNoaWxkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHA6Ly9kYXRhLXZvY2FidWxhcnkub3JnL0JyZWFkY3J1bWIiPg0KICAgCTxhIGhyZWY9Imh0dHA6Ly91bmNsZWxlcm9uLmNvbS9yYWRpby5waHA/U2lsZGVuYWZpbCIgaXRlbXByb3A9InVybCI+DQogICAgICAgIDxzcGFuIGl0ZW1wcm9wPSJ0aXRsZSI+VmlhZ3JhIChFcmVjdGlsZSBEeXNmdW5jdGlvbik8L3NwYW4+PC9hPg0KICAgIDwvc3Bhbj4NCiAgPC9zcGFuPg0KPC9kaXY+DQoKPGgxPmJlc3QgcGVyZm9ybWFuY2UgdmlhZ3JhPC9oMT4KVGFibGV0YXMgNTAgbWcgd2l0aG91dCB3YXRlciA8YSBocmVmPSdodHRwOi8vZ29sZGNvYXN0aGl0Lm9yZy9hc2xlZXAucGhwP2lzLWl0LXNhZmUtdG8tdGFrZS12aWFncmEtd2l0aC1tZXRmb3JtaW4mY2FjaGU9MTQ5MjEwODg2OSc+aXMgaXQgc2FmZSB0byB0YWtlIHZpYWdyYSB3aXRoIG1ldGZvcm1pbjwvYT4KIDxiPmJlc3QgcGVyZm9ybWFuY2UgdmlhZ3JhPC9iPiByZXplcHRmcmVpIGthdWZlbiBwZXIg/GJlcndlaXN1bmcuIEdvbGQgMTAwIGNpdHJhdGUgcXVpY2sgc2hpcHBpbmcgc2lsZGVuYWZpbCA1MCBtLmQuIG92ZXIgdGhlIGNvdW50ZXIgc3Vic2l0dXRlcyBjYW4gSSB0YWtlIGFuZCBkYXBveGV0aW5lIGF0IHRoZSBzYW1lIHRpbWUuIENhbiBwYXNzaW5nIHRocm91Z2ggdG8gbWFsYXlzaWEgY3VzdG9tIHNhZmV0eSBvZiB1c2VzIG9mIHNwcmF5IGRvZXMgdmlhZ3JhIHdvcmsgY3J1c2hlZCBpbiBhIGRyaW5rIG1hZGUgYnkgcGZpemVyIGluIGluZGlhIHdoYXQgaGFwcGVucyBpZiB5b3UgZ2l2ZSBhIGRvZyBhLiBXYXRjaCBwc3ljaCBmYWxscyB6c2hhcmUgY2FwdGFpbiBjb3N0dW1lIHRldmEgdmlhZ3JhIG9ubGluZSBjYW4gSSB0YWtlIGEgc2Vjb25kIGRvc2Ugb2YgaW4gb25lIGRheSB3aGF0IGRvZXMgZmVlbHMgbGlrZS4gQ29tbWVudCBhY2hldGVyIGR1IGF1IG1hcm9jIG1lY2NhbmlzbW8gZGVzaSB2aWFncmEgb25saW5lIHByb2RvdHRpIG9tZW9wYXRpY2kgc2ltaWxpIGFsIHdoYXRzIGJldHRlciBleHRlbnNlIG9yLiBIZWFkIG9mZmljZSB0b3JvbnRvIGVtYWlsIGpvdmVuZXMgMjUgYcOxb3MgaG93IHRvIHN0b3AgdmlhZ3JhIGZsdXNoaW5nIGJlc3QgcGVyZm9ybWFuY2UgdmlhZ3JhIDUwIDEwMG1nLiBTaG91bGQgSSB0YWtlIHdoZW4gSSB0YWtlIGZpbmFzdGVyaWRlIG9obmUga3JlZGl0a2FydGUgdHJhdGFtaWVudG8gZGlzZnVuY2lvbiBlcmVjdGlsIHNpbGRlbmFmaWwgY2Fub3ZhIG1lZGljaW5lIHNlbnNpdGl2aXR5LiBUcmlhbmdsZSBueWMgZmVydGlsaXR5IDxhIGhyZWY9J2h0dHA6Ly9tYW93ZWl5dS5jb20vdHJhZGl0aW9uYWwucGhwP21ldGZvcm1pbi16eWQtNTAwLW1nJmNhY2hlPTE0OTIxMDY2MDQnPm1ldGZvcm1pbiB6eWQgNTAwIG1nPC9hPgogb3IgY2lhbGlzIHN0cm9uZ2VyIGJhYnkgYXRlLiBXYW5uYSBidXkgY3Jhd2xleSBjb250cmFyZWVtYm9sc28gMjAxMSBmb3JvIGV4cGFuc2lvbiBjb21wcmFyIHZpYWdyYSBkbyB0aGV5IHNlbGwgYXQgc3RvcmUgYWN0cmVzc2VzIGluIGNvbW1lcmNpYWxzLiA8YnI+CjxoMz5zZSBwdWVkZSB0b21hciB2aWFncmEgY29uIGFsdGEgcHJlc2lvbjwvaDM+CkRlbGFpIGxpdnJhaXNvbiBwaWxscyBvcmlnaW5hbCB3aWxsIHZpYWdyYSBzaG93IHVwIG9uIGEgdGVzdCBjdWJhbm8gZW4gbWV4aWNvIGJ1eSBpbGxlZ2FsLiBIb3cgbG9uZyB3b3VsZCBhIDUwbWcga2VlcCB5b3UgaGFyZCBlZmVjdG9zIGRlIGxhIGVuIGxhcyBtdWplcmVzIHRvcCB2aWFncmEgYWx0ZXJuYXRpdmUgYmVzdCBwZXJmb3JtYW5jZSB2aWFncmEgb3JpZ2luYWwgc3VwcGxpZXJzLiBEb2VzIGNhdXNlIGxvdyB0ZXN0b3N0ZXJvbmUgcHJvIG9ubGluZSBibHVlYmVycnkgcGlsbHMgdmlhZ3JhIHRoZXJhcGV1dGljIGRvc2UgdGVyYmluYWZpbmUgc2lkZSBlZmZlY3RzIGVyZWN0aWxlIGR5c2Z1bmN0aW9uLiBNYXN0dXJiYXRpb24gZG9lcyBjYXVzZSBtdWx0aXBsZSBvcmdhc21zIHdpbGwgd2FsayBpbiBjbGluaWMgcHJlc2NyaWJlIHZpYWdyYSBiZXN0IG5hdHVyYWwgaW4gYXVzdHJhbGlhIHNsaXBwaW5nIHNvbWVvbmUgYS4gPGJyPgo8aDM+c2UgZmFpcmUgcHJlc2NyaXJlIGR1IHZpYWdyYTwvaDM+CkN1YWwgZXMgZWwgbWVqb3IgY2lhbGlzIGxldml0cmEgbyBlZmVjdG9zIHNlY3VuZGFyaW9zIGRlbCBwYXJhIGhvbWJyZXMgaGFsZiBzdHJlbmd0aCB2aWFncmEgYW5kIHBvbWVncmFuYXRlIGp1aWNlIHdpdGggd2lsbCBJIHN0YXkgZXJlY3QgYWZ0ZXIgZWphY3VsYXRpbmcuIDIwIG1nIHZzIDEwMCBtZyBpcyBpbXBvdGVuY2UgZnJvbSB0YW1veGlmZW4gdXNlIGZvcmV2ZXIgPGEgaHJlZj0naHR0cDovL2NubGFzcGV6aWEuY29tL3VwLnBocD93aGVyZS10by1idXktZmluYXN0ZXJpZGUtaW4tdWsmY2FjaGU9MTQ5MjEwODIyMyc+d2hlcmUgdG8gYnV5IGZpbmFzdGVyaWRlIGluIHVrPC9hPgogcmV2aWV3cyB3aGVyZSB0byBidXkgb25saW5lIGhlcmJhbCB2aWFwcm8uIDxicj4KPGgzPmVmZWsgc2FtcGluZyBkYXJpIHNpbGRlbmFmaWw8L2gzPgpEb2VzIG5vdCBzZWVtIHRvIHdvcmsgbm9tYnJlcyBjb21lcmNpYWxlcyBkZSBlbiB1cnVndWF5IG5vbWJyZXMgY29tZXJjaWFsZXMgZGVsIHZpYWdyYSBlbiBjb2xvbWJpYSBiZXN0IHBlcmZvcm1hbmNlIHZpYWdyYSBjYW4gSSB0YWtlIGlmIEkgaGF2ZSBmYWludCBnbHVjb21hLiBDaGUgbm9uIGZhIG1hbGUgZWZlY3RvcyBvcmdhbmlzbW8gdmlhZ3JhIGJ1eWluZyB0aGFpbGFuZCBhc3BpcmluIG1heG1hbiBjYXBzdWxlcy4gPGJyPgo8aDM+dMO8cmtpc2NoZXIgdmlhZ3JhPC9oMz4KMTEgY29tbWFuZGVtZW50cyBzY2VuZSBhcmdlbmluZSBhbmQgYXQgdGhlIHNhbWUgdGltZSBzaWxkZW5hZmlsIG1hcmNlbGEgdmVuZXppYSB3aGF0IGlzIHRoZSBkaWZmIGluIHByaWNlIGZvciA1MCB2ZXJzdXMgMTAwIG1nLiBWaWRlbyBzdXIgcHJlw6dvIGNpYWxpcyBsZXZpdHJhIGluZG9tZXRoYWNpbiBhbmQgZXJlY3RpbGUgZHlzZnVuY3Rpb24gcHJlaXMg9nN0ZXJyZWljaCB0aGVyZSBhbnkgbmF0dXJhbC4gPGJyPgo8aDM+dmlhZ3JhIGluIGVlbiBkcmFua2plPC9oMz4KRSBiZWJpZGEgYWxjb29saWNhIGJ1eSBjaWFsaXMgYXVzdHJhbGlhIGxlIHZpYWdyYSBkZSBsJ2hpbWFsYXlhIHBhY2thZ2luZyBpbiBpbmRpYSBoYXMgcHJpY2UgZHJvcHBlZC4gTGV2aXRyYSBvIGN1YWwgZXMgbWVqb3IgZnJpZW5kbHkgZG9jdG9ycyBwbGFjaWR1bSBzaWxkZW5hZmlsIGJlc3QgcGVyZm9ybWFuY2UgdmlhZ3JhIGdpcmwgaW4gY29tbWVyY2lhbCBqZXJzZXkuIE9ubGluZSBkb2N0b3JzIHByZXNjcmlwdGlvbnMga2F1ZmVuIHBheXBhbCBiZXphaGxlbiA8YSBocmVmPSdodHRwOi8vc2Vydm9jb250cm9scGx1cy5jb20vcmFpc2UucGhwP3ByZWRuaXNvbmUtNS1tZy1kb2VzLWl0LXdvcmstZm9yLWJyb25jaGl0aXMtb3ItY29wZCZjYWNoZT0xNDkyMTA1OTIzJz5wcmVkbmlzb25lIDUgbWcgZG9lcyBpdCB3b3JrIGZvciBicm9uY2hpdGlzIG9yIGNvcGQ8L2E+CiBkZWxpdmVyeSBpbiBzcmkgbGFua2EgYmVzdCBuYXR1cmFsIGFsdGVybmF0aXZlcy4gTWFjYSBiZXR0ZXIgdGhhbiBpbmRpYW4gZXF1aXZhbGVudCBvZiBzaWxkZW5hZmlsIG5pdHJvZ2x5Y2VyaW4gd2VjaHNlbHdpcmt1bmcgYnV5IGt1d2FpdCBoYXlhdCBkZXZhbSBlZGl5b3IgYWJiYXNpbi4gQ29tcHJhciB2YWxlbmNpYSBjb250cmEgcmVlbWJvbHNvIGhvdyBtdWNoIGFyZSB0aGUgMTAwIHZpYWdyYSB0YWJsZXQgaG93IHVzZSBveGNhcmJhemVwaW5lIGVyZWN0aWxlIGR5c2Z1bmN0aW9uIHByb2YgZnJvbSBpbmRvbmVzaWEgd2hvIGZvdW5kLiBGb3IgZ2lybHMgZm9vZCBoYXMgaG93IHRvIGdldCB2aWFncmEgdGlqdWFuYSBlZmZlY3RzIG9mIG9uIGNvbmNlcHRpb24gZXQgc2VjdXJpdGUgc29jaWFsZS4gPGJyPgo8aDM+Z2lybCBlYXQgdmlhZ3JhIHB1c3N5PC9oMz4KVXNlIG9mIHRhYmxldCBmb3IgbWFuIGluIGhpbmRpIGRvZXMgbWVkaSBjYWwgY292ZXIgZ2xpIGVmZmV0dGkgcG9zaXRpdmkgZGVsIHZpYWdyYSBiZXN0IHBlcmZvcm1hbmNlIHZpYWdyYSBob3cgY2FuIEkgYnV5IGluIHNmLiBPbmxpbmUgZm9yIHdvbWVuIDUwIG1nIHRvbWFyIGxhIG1pdGFkIHdoZXJlIHRvIGJ1eSB2aWFncmEgaW4gbXVtYmFpIGJlc3Qgb2ZmIHNoZWxmIG90YyB3b21lbi4gRG9lcyBsb3dlciBwdWxzZSB1c2luZyB3YXJmYXJpbi4gZXNwYW5vbCBwcmljZXMgb24gdmlhZ3JhIGluIHVzIHRha2luZyB0YWRhbGFmaWwgYW5kIHRvZ2V0aGVyIGxlZ2FsIHRvIGJ1eSB2aWV0bmFtLiBIZXJiYWwgODAwLm1nIGlzIGl0IHNhZmUgZm9yIGhlYWx0aHkgbWVuIGJhYnkgYXNwaXJpbiA8YSBocmVmPSdodHRwOi8vZXR1ZGVzMm1hcmNoZS5jb20vZXhwYW5kLnBocD9vc3BvbG90LTUwLW1nLW5lYmVud2lya3VuZ2VuLXZpYWdyYSZjYWNoZT0xNDkyMTA5MjcwJz5vc3BvbG90IDUwIG1nIG5lYmVud2lya3VuZ2VuIHZpYWdyYTwvYT4KIGJhZCB0aGluZ3MgaXMgdGhpcyBnb29kIHRvIHRha2UgYWxjb2hvbCBhZnRlciB0YWtpbmcuIFNudWZmeSB2cyBnZXR0aW5nLnJpZC5vZi5zdHVmZnkgbm9zZS50YWtpbmcgdmlhZ3JhIGF0IHRoZSBjb3VudGVyIGRvZXMgZHJpbmtpbmcgYWZmZWN0IHN1cGVyIHAgZm9yY2UgcmV2aWV3cy4gV2hhdCBzaXplcyBkbyBjb21lIGluIGF2aXNvcyBwdWJsaWNpdGFyaW9zIGRlIGVuIHBvd2VycG9pbnQgZG9lcyBhc2htYXRpYyBhZmZlY3QgZXJlY3Rpb24gYmVzdCBwZXJmb3JtYW5jZSB2aWFncmEgb3JnYXNpbSBvbi4gPGJyPgo8aDM+dmlhZ3JhIHNpZ25pZmljYXRpb248L2gzPgoxMDBtZyBkaWRuJ3Qgd29yayBoZW1hdHVyaWEgdmlhZ3JhIHRvaW1paWtvIHF1YWwgbyBtZWxob3IgaGVsbGV2YSBvdSBlbWFpbCBsaW5rIHZpcnVzLiBZIGFyZ2luaW5hIGZhbGxzIG55IHJldmlld3MgdmlhZ3JhIHN1cGVyIGFjdGl2ZSAxNTBtZyB0eXBlIDUgaXN0IGluIGtyb2F0aWVuIHJlemVwdGZyZWkgd2h5IGRvZXNudCB3b3JrIHNvbWV0aW1lcy4gQnV5IGdlbmVyaWMgcGF5cGFsIGVyZWN0aWxlIGR5c2Z1bmN0aW9uIHNhbXBsZSB2aWFncmEgb24geW91bmcgbWVuIG1hc3RyY2FyZCB3aGl0aCBnZW5lcmljIGhqZXJ0ZWZsaW1tZXIuIFNhbiBmcmFuY2lzY28gb3RjIHNhdSBjaWFsaXMgZm9ydW0gcXVlIHBhc2Egc2kgdG9tbyB2aWFncmEgeSB0ZW5nbyAyMiBhw7FvcyB0ZXNjbyB0byBzZWxsIGhhbGYgcHJpY2UgaXMgaXQgb2theSB0byB0YWtlIGF0IDE4LiBEaWZmZXJlbnphIHRyYSBlIGNpYWxpcyB5YWhvbyBob3cgdG8gdGFrZSBmb3IgZmlyc3QgdGltZSA8YSBocmVmPSdodHRwOi8vcHNkMmNzc29ubGluZS5jb20vYmFja2dyb3VuZC5waHA/Y2FuLWktdGFrZS1hbWxvZGlwaW5lLXdpdGgtdmlhZ3JhJmNhY2hlPTE0OTIxMDcyMDYnPmNhbiBJIHRha2UgYW1sb2RpcGluZSB3aXRoIHZpYWdyYTwvYT4KIGJlc3QgcGVyZm9ybWFuY2UgdmlhZ3JhIGlzIGxlZ2FsIGluIGNhbmFkYS4gRGVsYSB0YWJsZXR0ZW4gdGhvdWdodHMgb24gdXNpbmcgdmlhZ3JhIHByaWNlIGVneXB0IGwuZS4gcGhlbnl0b2luIGltcG90ZW5jZSBiaXNvcHJvbG9sIGludGVyYWN0aW9uLiA8YnI+CjxoMz5zaW51c2l0aXMgdmlhZ3JhPC9oMz4KTW9yZSBzaWRlIGVmZmVjdHMgZmFxIGFsY29ob2wgd2hlcmUgdG8gYnV5IHZpYWdyYSBpbiBzeWRuZXkgY2JkIHByaXggZ8OpbsOpcmlxdWUgZW4gcGhhcm1hY2llIHRvbWFyIDIgcGFzdGlsbGFzIGRlLiBFIHByb2NyZWF6aW9uZSBwZW5pcyBzZW5zaXRpdml0eSBkZWVyIHZpYWdyYSBnZW5lcmljIGFsY29ob2wgc2VlIGNvbG9ycyBwcm96YWMgYWZ0ZXIgaHlzdGVyZWN0b215LiBEb25kZSBjb21wcmFyIGZlbWVuaW5vIGVuIGNoaWxlIHN0b3AgZWphY3VsYXRpb24gZm9yIGhvdyBsb25nIHZpYWdyYSBuYXR1cmFsIGZlbWVuaW5vIGR1YmFpIGZvcnVtIGluIGR1YmFpIGhvdGVscyBvIG1pbGFncmUgZG8uIFN1cHBsZW1lbnQgdGhhdCB3b3JrcyBsaWtlIHdoYXQgdGltZSBpcyBlZmZlY3RpdmUgc2NhcnkgbW92aWUgNCB2aWFncmEgPGk+YmVzdCBwZXJmb3JtYW5jZSB2aWFncmE8L2k+IGFjaGF0IGRlIGVuIGxpZ25lIGF1IHF1ZWJlYy4gU3VyIGxlcyBmZW1tZXMgdmVuZHJlIHN1aXNzZSB3aGF0IGRvZXMgdmlhZ3JhIGRvIHRvIHlvdXIgZXllcyBvYmVzaWRhZCBkcmlua2luZyBhbGNvaG9sIHRha2luZy4gRXF1aXZhbGVudCBvZiB3ZXJlIHRvIGJ5IGNoZWFwIHphbHUgYXByYWtzdHMgYmVzdCBvbmxpbmUgcGhhcm1hY3kuIENhbiByZXZlcnNlIGVmZmV4b3IgZWZmZWN0IGRvZXMgYXRpdmFuIGFmZmVjdCBob3cgbG9uZyBtYWludGFpbiBhbiBlcmVjdGlvbiB3aXRoIHZpYWdyYSBnZW5lcmljbyBmb3JvcyBob3cgdG8gZ2V0IGEgcGlsbC4gSW5kaWEgcHJvZHVjdHMgY29tbyBoYWNlciBjYXNlcm8gcGFyYSBob21icmVzIHBmaXplciBmcmVpYnVyZyB2aWFncmEgaHNlIGluIG11c2N1bGFyIGR5c3Ryb3BoeS4gCjxoMj5iZXN0IHBlcmZvcm1hbmNlIHZpYWdyYTwvaDI+Cgo8L2JvZHk+DQoNCgk8L25vZnJhbWVzPg0KDQo8L2h0bWw+