PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiI+CjxodG1sPgo8aGVhZD4KPHRpdGxlPkVjbGlwc2UgU3RhbmRhcmQgVG9wLUxldmVsIENoYXJ0ZXIgdjEuMDwvdGl0bGU+CjxsaW5rIHR5cGU9InRleHQvY3NzIiByZWw9InN0eWxlc2hlZXQiIGhyZWY9IgpodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2RlZmF1bHRfc3R5bGUuY3NzIj4KPHRpdGxlPkVjbGlwc2UgUmVzZWFyY2ggUHJvamVjdCBUb3AtTGV2ZWw8L3RpdGxlPgo8L2hlYWQ+Cjxib2R5IHRleHQ9IiMwMDAwMDAiIGJnY29sb3I9IiNmZmZmZmYiIGxpbms9IiMwMDAwRUUiIHZsaW5rPSIKIzU1MUE4QiIgYWxpbms9IiNmZjAwMDAiPgoKPHRhYmxlIGNlbGxzcGFjaW5nPSI1IiBjZWxscGFkZGluZz0iMiIgd2lkdGg9IjEwMCUiIGJvcmRlcj0iMCI+Cgo8dGJvZHk+Cjx0cj4KPHRkIHZhbGlnbj0idG9wIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBDMCIgY29sc3Bhbj0iMyI+CjxiPjxzcGFuIHN0eWxlPSJmb250LXNpemU6MTAuMHB0O2ZvbnQtZmFtaWx5OkFyaWFsOwptc28tZmFyZWFzdC1mb250LWZhbWlseTomcXVvdDtUaW1lcyBOZXcgUm9tYW4mcXVvdDs7Y29sb3I6d2hpdGU7bXNvLWFuc2ktbGFuZ3VhZ2U6RU4tVVM7Cm1zby1mYXJlYXN0LWxhbmd1YWdlOktPO21zby1iaWRpLWxhbmd1YWdlOkFSLVNBIj5UaGUgRWNsaXBzZSBSZXNlYXJjaCBQcm9qZWN0IJYKVG9wLUxldmVsIFByb2plY3QgQ2hhcnRlciCWIFRoZSBFY2xpcHNlIEZvdW5kYXRpb248L3NwYW4+PC9iPjwvdGQ+CjwvdHI+Cgo8dHI+Cjx0ZCBjb2xzcGFuPSIzIj4KPHA+PGI+T3ZlcnZpZXc8YnI+CjwvYj5UaGUgRWNsaXBzZSBSZXNlYXJjaCBUb3AgTGV2ZWwgUHJvamVjdCAodGhlICZxdW90O0VjbGlwc2UgUmVzZWFyY2gKUHJvamVjdCZxdW90OykgaXMgYW4gb3BlbiBzb3VyY2Ugc29mdHdhcmUgcmVzZWFyY2ggcHJvamVjdCwgd2hpY2ggZW5jYXBzdWxhdGVzCnR3byByZWxhdGVkIGFjdGl2aXR5IHN0cmVhbXMsIGVhY2ggb2Ygd2hpY2ggaXMgYmFzZWQgb24gb3IgdXNlcyB0aGUgRWNsaXBzZQpQbGF0Zm9ybSBhbmQvb3IgY29kZSBmcm9tIG90aGVyIEVjbGlwc2UgVG9wIExpbmUgUHJvamVjdHM6Jm5ic3A7PC9wPgo8b2w+CiAgPGxpPgogICAgPHA+cmVzZWFyY2ggcHJvamVjdHMgc3BvbnNvcmVkIGJ5IHVuaXZlcnNpdGllcywgcHVibGljIGFuZCBwcml2YXRlIHJlc2VhcmNoCiAgICBpbnN0aXR1dGVzLCBhbmQgb3RoZXIgZXhwbG9yYXRvcnkgaW52ZXN0aWdhdGlvbnMgKCZxdW90O1Jlc2VhcmNoCiAgICBTdHJlYW0mcXVvdDspOyZuYnNwOzwvcD4KICA8L2xpPgogIDxsaT4KICAgIDxwPmRldmVsb3BtZW50IG9mIGVkdWNhdGlvbmFsIG1hdGVyaWFscywgdGVhY2hpbmcgYWlkcyBhbmQgY291cnNld2FyZQogICAgKCZxdW90O0VkdWNhdGlvbiBTdHJlYW0mcXVvdDspPC9wPgogIDwvbGk+Cjwvb2w+CjxwPjxiPk1pc3Npb248L2I+PGJyPgpUaGUgbWlzc2lvbiBvZiB0aGUgRWNsaXBzZSBSZXNlYXJjaCBQcm9qZWN0IGlzIHRvIGZvc3RlciBncmVhdGVyIGNvbW11bml0eQphd2FyZW5lc3MgYW5kIHVuZGVyc3RhbmRpbmcgb2YgRWNsaXBzZSAoRWR1Y2F0aW9uIFN0cmVhbSksIGFuZCB0byBlbmNvdXJhZ2UgdGhlCnVzZSBvZiBFY2xpcHNlIHNvZnR3YXJlIGFzIGEgcGxhdGZvcm0gZm9yIHJlc2VhcmNoLCBlc3BlY2lhbGx5IGluIGRvbWFpbnMgc3VjaAphcyBwcm9ncmFtbWluZyBsYW5ndWFnZXMsIHRvb2xzLCBhbmQgZGV2ZWxvcG1lbnQgZW52aXJvbm1lbnRzIHRoYXQgYXJlIHJlbGV2YW50CnRvIG90aGVyIEVjbGlwc2UgVG9wIExpbmUgUHJvamVjdHMgKFJlc2VhcmNoIFN0cmVhbSkuIEJ5IHNvIGRvaW5nLCB0aGUgRWNsaXBzZQpSZXNlYXJjaCBQcm9qZWN0IHdpbGwgY3JlYXRlIG9wcG9ydHVuaXRpZXMgZm9yIHJlc2VhcmNoZXJzLCBhY2FkZW1pY3MsIGFuZAplZHVjYXRvcnMgdG8gcGxheSBhIHNpZ25pZmljYW50IHJvbGUgd2l0aGluIHRoZSBFY2xpcHNlIGNvbW11bml0eS48L3A+CjxwPjxiPlNjb3BlPC9iPjxicj4KVGhlIHNjb3BlIG9mIHRoZSBFY2xpcHNlIFJlc2VhcmNoIFByb2plY3Qgd2lsbCBlbmNvbXBhc3MgYSB3aWRlIHZhcmlldHkgb2Ygc21hbGwKcHJvamVjdHMsIHJhdGhlciB0aGFuIGEgZmV3IGxhcmdlIG9uZXMuIFdoaWxlIGFudGljaXBhdGluZyBlbm9ybW91cyBkaXZlcnNpdHkgaW4KdGhlIGNvbnRlbnQgb2YgdGhlc2UgYWN0aXZpdGllcywgZnJvbSBhIHByb2Nlc3Mtb3JpZW50ZWQgdmlld3BvaW50IHRoZXkgd2lsbCBhbGwKc2hhcmUgaW1wb3J0YW50IGNvbW1vbiBjaGFyYWN0ZXJpc3RpY3MsIHdoaWNoIGFyZ3VlcyBmb3IgYSBjb21tb24gYXBwcm9hY2ggdG8KbWFuYWdlbWVudDo8L3A+Cjx1bD4KICA8bGk+Rm9jdXMgb24gcHJlLWNvbXBldGl0aXZlIGRldmVsb3BtZW50IGFuZCByZXNlYXJjaDwvbGk+CiAgPGxpPlVzZSBvZiBpbmZvcm1hbCBkZXZlbG9wbWVudCBwcm9jZXNzZXM8L2xpPgogIDxsaT5GbHVpZCBwcm9qZWN0IHRyYWNraW5nIGR1ZSB0byBmcmVxdWVudCBwbGFuIGNoYW5nZXM8L2xpPgogIDxsaT5GbGV4aWJsZSBtaWxlc3RvbmVzIHdoaWNoIGFkYXB0IGJhc2VkIG9uIHBhcnRpYWwgcmVzdWx0czwvbGk+CiAgPGxpPlNtYWxsIHRlYW1zPC9saT4KICA8bGk+UmVzb3VyY2UgY29tbWl0bWVudHMgdGVudGF0aXZlLCBkdWUgdG8gdm9sdW50ZWVyIGxhYm9yIG9yIGxhY2sgb2Ygc3BvbnNvcgogICAgZnVuZGluZzwvbGk+CiAgPGxpPkRldmVsb3BtZW50IG9mdGVuIGNyb3NzLWN1dHMgdGhlIHNjb3BlIG9mIHNldmVyYWwgb3RoZXIgRWNsaXBzZSBGb3VuZGF0aW9uCiAgICBQcm9qZWN0czwvbGk+CiAgPGxpPkxpbWl0ZWQgbGlmZXNwYW4gZHVlIHRvIGludGVudCB0byBleHBsb3JlIGFuZCB2YWxpZGF0ZSBhbiBpZGVhLCB0aGVuCiAgICBncmFkdWF0ZSBvciBkaXNiYW5kPC9saT4KPC91bD4KPHA+VGhlIEVjbGlwc2UgUmVzZWFyY2ggUHJvamVjdCBzZXJ2ZXMgYXMgYSBzaW5nbGUgcG9pbnQgb2YgZm9jdXMgZm9yIHN1Y2gKdGVhbXMsIGFuZCBwcm92aWRlcyB0aGVtIHdpdGggYSBob21lIHdpdGhpbiB0aGUgRWNsaXBzZSBjb21tdW5pdHksIHRvIGVuY291cmFnZQpjb21tdW5pY2F0aW9uLCBhbmQgd2hlcmUgYXBwcm9wcmlhdGUsIGNvbGxhYm9yYXRpb24gYW5kIGNvb3JkaW5hdGlvbi4gUHJvdmlkaW5nCmNvbW1vbiBtYW5hZ2VtZW50IGZvciB0aGVzZSBQcm9qZWN0cyBmYWNpbGl0YXRlcyBtYXhpbXVtIHNoYXJpbmcgYW5kIGNyZWF0aW9uIG9mCmNvbW1vbiBjb21wb25lbnRzLCBhbmQgYXZvaWRzIHJlZHVuZGFudCBlZmZvcnRzLiBJbiBtYW55IGNhc2VzIHN1Y2Nlc3NmdWwKUmVzZWFyY2ggUHJvamVjdHMgd2lsbCBldm9sdmUgaW50byBpbmN1YmF0b3JzIGluIEVjbGlwc2UgVGVjaG5vbG9neSBQcm9qZWN0LiA8L3A+CjxwPlRoZSBFZHVjYXRpb24gU3RyZWFtIHBsYXlzIGEgdml0YWwgcm9sZSBpbiBwcm9tb3RpbmcgdGhlIHVzZSBvZiB0aGUgRWNsaXBzZQpQbGF0Zm9ybS4gQnkgbWFraW5nIGhpZ2ggcXVhbGl0eSBlZHVjYXRpb25hbCBtYXRlcmlhbHMgZnJlZWx5IGF2YWlsYWJsZSwgd2UgYm90aAplbmFibGUgc2VsZi1lZHVjYXRpb24gYnkgaW5kaXZpZHVhbCB1c2VycywgYW5kIGZhY2lsaXRhdGUgdGhlIGluY29ycG9yYXRpb24gb2YKRWNsaXBzZS1yZWxhdGVkIG1hdGVyaWFscyBpbnRvIHVuaXZlcnNpdHkgY291cnNlcyBhbmQgY29tbWVyY2lhbCBlZHVjYXRpb25hbApvZmZlcmluZ3MuPC9wPgo8cD48Yj5PdGhlciBUZXJtczxicj4KPC9iPlRoaXMgQ2hhcnRlciBpbmhlcml0cyBhbGwgdGVybXMgbm90IG90aGVyd2lzZSBkZWZpbmVkIGhlcmVpbiBmcm9tIHRoZSAmcXVvdDs8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL29yZy9wcm9jZXNzZXMvRWNsaXBzZV9TdGFuZGFyZF9Ub3BMZXZlbF9DaGFydGVyX3YxLjAuaHRtbCI+RWNsaXBzZQpTdGFuZGFyZCBDaGFydGVyIHYxLjA8L2E+JnF1b3Q7LiBUaGlzIGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNlY3Rpb25zCm9uIHRoZSBQcm9ncmFtIE1hbmFnZW1lbnQgQ29tbWl0dGVlLCBSb2xlcywgUHJvamVjdCBPcmdhbml6YXRpb24sIFRoZQpEZXZlbG9wbWVudCBQcm9jZXNzLCBhbmQgTGljZW5zaW5nLjwvcD4KPHA+PGI+UHJvamVjdCBNYW5hZ2VtZW50IENvbW1pdHRlZSA8YnI+CjwvYj5DaGFuZ2VzIGZyb20gdGhlICZxdW90OzxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvb3JnL3Byb2Nlc3Nlcy9FY2xpcHNlX1N0YW5kYXJkX1RvcExldmVsX0NoYXJ0ZXJfdjEuMC5odG1sIj5FY2xpcHNlClN0YW5kYXJkIENoYXJ0ZXIgdjEuMDwvYT4mcXVvdDsgYXJlOjwvcD4KPHVsPgogIDxsaT5Qcm92aWRpbmcgdGhlIGxlYWRlcnNoaXAgYW5kIHZpc2lvbiB0byBndWlkZSB0aGUgUHJvamVjdCdzIG92ZXJhbGwKICAgIGRpcmVjdGlvbiBpbiBhIG1hbm5lciBjb25zaXN0ZW50IHdpdGggdGhlIDxzdHJpa2U+RWNsaXBzZSBGb3VuZGF0aW9uCiAgICBBcmNoaXRlY3R1cmFsIFJvYWRtYXA8L3N0cmlrZT4gRWNsaXBzZSBGb3VuZGF0aW9uJ3MgZ29hbHMuIDwvbGk+CjwvdWw+CjxwPjxiPlRoZSBEZXZlbG9wbWVudCBQcm9jZXNzIDxicj4KPC9iPkNoYW5nZXMgZnJvbSB0aGUgJnF1b3Q7PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9vcmcvcHJvY2Vzc2VzL0VjbGlwc2VfU3RhbmRhcmRfVG9wTGV2ZWxfQ2hhcnRlcl92MS4wLmh0bWwiPkVjbGlwc2UKU3RhbmRhcmQgQ2hhcnRlciB2MS4wPC9hPiZxdW90OyBhcmU6IDwvcD4KPHA+UmVzZWFyY2ggcHJvamVjdHMgdHlwaWNhbGx5IGRvIG5vdCBoYXZlIGFzIHdlbGwtZGVmaW5lZCBkZXZlbG9wbWVudCBwbGFucyBhcwpwcm9kdWN0IHByb2plY3RzIGRvLiBIb3dldmVyLCBpdCBpcyBzdGlsbCBpbXBvcnRhbnQgdGhhdCBQcm9qZWN0cyB1bmRlciB0aGUKUmVzZWFyY2ggVG9wLUxldmVsIFByb2plY3QgaGF2ZSBhIGRlZmluZWQgYW5kIHB1YmxpY2x5IGF2YWlsYWJsZSByZWxlYXNlIHBsYW4gc28KYXMgdG8gaGVscCBpbnRlcmVzdGVkIHBhcnRpZXMgdHJhY2sgdGhlIHByb2dyZXNzIG9mIHRoZSByZXNlYXJjaC4KPC90ZD4KPC90cj4KPC90Ym9keT4KPC90YWJsZT4KCjwvYm9keT4KPC9odG1sPgoKPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiI+Cg==