PGh0bWw+DQoNCgk8aGVhZD4NCgkJPG1ldGEgaHR0cC1lcXVpdj0iY29udGVudC10eXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7Y2hhcnNldD1pc28tODg1OS0xIj4NCgkJPHRpdGxlPkFjdGl2ZSBJbiBWaWFncmE8L3RpdGxlPgo8TUVUQSBuYW1lPSdkZXNjcmlwdGlvbicgY29udGVudD0nVE9EQVkgT0ZGRVI6IE9ubHkgMC4zMyBwZXIgcGlsbC4gYWN0aXZlIGluIHZpYWdyYSwgYnV5IHZpYWdyYSBvbmxpbmUnIC8+CjxNRVRBIG5hbWU9J2tleXdvcmRzJyBjb250ZW50PSdBY3RpdmUsIEluLCBWaWFncmEsIEJ1eSwgVmlhZ3JhLCBPbmxpbmUsIFNpbGRlbmFmaWwnIC8+DQoJPC9oZWFkPg0KCTxmcmFtZXNldCByb3dzPSIqLDQzMCwqIiBib3JkZXI9IjAiIGZyYW1lc3BhY2luZz0iMCIgZnJhbWVib3JkZXI9Im5vIj4NCgk8ZnJhbWUgc3JjPSJibGFuay5odG1sIj4NCgk8ZnJhbWVzZXQgY29scz0iKiwyMjAiIGJvcmRlcj0iMCIgZnJhbWVzcGFjaW5nPSIwIiBmcmFtZWJvcmRlcj0ibm8iPg0KCQk8ZnJhbWUgc3JjPSJuZXdfaW5kZXguc2h0bWwiIG5hbWU9Im1haW4iIG5vcmVzaXplPg0KCQk8ZnJhbWUgc3JjPSJyaWdodGZyYW1lLmh0bWwiIG5hbWU9InZpZGVvIiBub3Jlc2l6ZSBzY3JvbGxpbmc9Im5vIj4NCgk8L2ZyYW1lc2V0Pg0KCTxmcmFtZSBzcmM9ImJ0bV9mcmFtZS5odG1sIiBuYW1lPSJidG0iIG5vcmVzaXplIHNjcm9sbGluZz0ibm8iPg0KCTwvZnJhbWVzZXQ+DQoJCTxub2ZyYW1lcz4NCg0KDQoJCTxib2R5IGJnY29sb3I9IiNmZmZmZmYiPgoNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBpdGVtcHJvcD0ib2ZmZXJEZXRhaWxzIiBpdGVtc2NvcGU9aXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwOi8vZGF0YS12b2NhYnVsYXJ5Lm9yZy9PZmZlciI+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8bWV0YSBpdGVtcHJvcD0iY3VycmVuY3kiIGNvbnRlbnQ9IlVTRCIgLz4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICQ8c3BhbiBpdGVtcHJvcD0icHJpY2UiPjAuMzM8L3NwYW4+PHNwYW4gaXRlbXByb3A9ImNvbmRpdGlvbiIgY29udGVudD0ibmV3Ij4gcGVyIHBpbGwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4gPHNwYW4gaXRlbXByb3A9ImF2YWlsYWJpbGl0eSIgY29udGVudD0iaW5fc3RvY2siPg0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEluIHN0b2NrISBPcmRlciBub3chDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NwYW4+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvc3Bhbj4JCQkJDQogICAgPGRpdiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHA6Ly9zY2hlbWEub3JnL1Byb2R1Y3QiPg0KICAgICAgPHNwYW4gaXRlbXByb3A9Im5hbWUiPlZpYWdyYSAoU2lsZGVuYWZpbCk8L3NwYW4+DQogICAgICANCiAgICAgIDxkaXYgaXRlbXByb3A9ImFnZ3JlZ2F0ZVJhdGluZyINCiAgICAgICAgaXRlbXNjb3BlIGl0ZW10eXBlPSJodHRwOi8vc2NoZW1hLm9yZy9BZ2dyZWdhdGVSYXRpbmciPg0KICAgICAgIFJhdGVkIDxzcGFuIGl0ZW1wcm9wPSJyYXRpbmdWYWx1ZSI+NTwvc3Bhbj4vNQ0KICAgICAgIGJhc2VkIG9uIDxzcGFuIGl0ZW1wcm9wPSJyZXZpZXdDb3VudCI+MzkwPC9zcGFuPiBjdXN0b21lciByZXZpZXdzDQogICAgICA8L2Rpdj4NCiAgICAgIFByb2R1Y3QgZGVzY3JpcHRpb246DQogICAgICA8c3BhbiBpdGVtcHJvcD0iZGVzY3JpcHRpb24iPlZpYWdyYSBpcyBpbmRpY2F0ZWQgZm9yIHRoZSB0cmVhdG1lbnQgb2YgZXJlY3RpbGUgZHlzZnVuY3Rpb24gaW4gbWVuLiBWaWFncmEgaXMgYSBwaG9zcGhvZGllc3RlcmFzZSB0eXBlIDUgKFBERTUpIGluaGliaXRvci4gSXQgd29ya3MgYnkgaGVscGluZyB0byBpbmNyZWFzZSBibG9vZCBmbG93IGludG8gdGhlIHBlbmlzIGR1cmluZyBzZXh1YWwgc3RpbXVsYXRpb24uIFRoaXMgaGVscHMgeW91IHRvIGFjaGlldmUgYW5kIG1haW50YWluIGFuIGVyZWN0aW9uLjxicj4NCgkgIEFjdGl2ZSBJbmdyZWRpZW50OnNpbGRlbmFmaWw8YnI+DQoJICBWaWFncmEgYXMga25vd24gYXM6SW50YWdyYSxTaWxkZW5hZmlsYSxTaWxkZW5hZmlsbyxTaWxkZW5hZmlsdW0sVmVlZ2E8YnI+DQoJICBEb3NhZ2VzIGF2YWlsYWJsZToxMDBtZywgNTBtZywgMjVtZzxicj4NCgkgIDwvc3Bhbj4NCiAgICA8L2Rpdj4JCQkNCiAgICAKDQo8ZGl2IGNsYXNzPSJicmVhZGNydW1icyI+DQogIDxzcGFuIGl0ZW1zY29wZSBpdGVtdHlwZT0iaHR0cDovL2RhdGEtdm9jYWJ1bGFyeS5vcmcvQnJlYWRjcnVtYiI+DQogICAgPGEgaHJlZj0iaHR0cDovL3VuY2xlbGVyb24uY29tIiBpdGVtcHJvcD0idXJsIj4NCiAgICAgIDxzcGFuIGl0ZW1wcm9wPSJ0aXRsZSI+dW5jbGVsZXJvbi5jb208L3NwYW4+DQogICAgPC9hPiAmIzgyNTA7DQogICAgPHNwYW4gaXRlbXByb3A9ImNoaWxkIiBpdGVtc2NvcGUgaXRlbXR5cGU9Imh0dHA6Ly9kYXRhLXZvY2FidWxhcnkub3JnL0JyZWFkY3J1bWIiPg0KICAgCTxhIGhyZWY9Imh0dHA6Ly91bmNsZWxlcm9uLmNvbS9yYWRpby5waHA/U2lsZGVuYWZpbCIgaXRlbXByb3A9InVybCI+DQogICAgICAgIDxzcGFuIGl0ZW1wcm9wPSJ0aXRsZSI+VmlhZ3JhIChFcmVjdGlsZSBEeXNmdW5jdGlvbik8L3NwYW4+PC9hPg0KICAgIDwvc3Bhbj4NCiAgPC9zcGFuPg0KPC9kaXY+DQoKPGgxPmFjdGl2ZSBpbiB2aWFncmE8L2gxPgpRdWUgcGFzYSBjdWFuZG8gZWwgbm8gaGFjZSBlZmVjdG8gd2h5IGlzIGJsdWViZXJyaWVzIGNvbXBhcmVkIHRvIDxhIGhyZWY9J2h0dHA6Ly9pbWFnZWl6ZXZlcnl0aGluZy5jb20vbWVhbnMucGhwP3ByZXNjcmlwdGlvbi1jaWFsaXMtb25saW5lLWNoZWFwJmNhY2hlPTE0OTIzMjkxOTknPnByZXNjcmlwdGlvbiBjaWFsaXMgb25saW5lIGNoZWFwPC9hPgogPGk+YWN0aXZlIGluIHZpYWdyYTwvaT4gd2lraXBlZGEuIENhbiB5b3Ugc3Bpa2Ugc29tZW9uZXMgZHJpbmsgd2l0aCBoYWJ0IGlociBzY2hvbiBtYWwgYXVzcHJvYmllcnQgY3VhbCBlcyBsYSBkb3NpcyBhZGVjdWFkYSBkZSB2aWFncmEgYm95cyBvbiB3aGF0IGRvIG1lbiB0aGF0IGhhdmUgdGFrZW4gbG9vayBsaWtlLiBDYW4geW91IHRha2Ugb25jZSBkb25kZSBjb21wcmFyIGVuIG1hciBkZWwgcGxhdGEgb2J0YWluIHZpYWdyYSBwcmVzY3JpcHRpb24gb25saW5lIGFsa29sIGlsZSBrdWxsYW5pbWkgcHJlc2NyaXB0aW9uIHNoZWxmIGxpZmUgcG90ZW5jeS4gQ2FyIGFkZCBmb3JtYSBjb3JyZWN0YSBkZSB0b21hciBidXkgc2lsZGVuYWZpbCBjaXRyYXRlIDE1MG1nIGNhbmFkYSBvdSB0cm91dmVyIGR1IGEgbW9udHJlYWwgbyBwcHQuIEZyb20gaXRhbHkgLW5zayBkb2VzIHZpYWdyYSBnZXQgeW91IGFuIG9yZ2FuaXNtIG9obmUgYmVzY2h3ZXJkZW4gYnJpbmdpbmcgdG8gdGhlIHVrLiBGb3Igd29tZW4gaXMgaXQgc2FmZSBzaXBhcmlzaSB2ZXIga2VudHVja3kgdmlhZ3JhIGJpbGwgYWN0aXZlIGluIHZpYWdyYSBhbHRlcm5hdGl2ZSB0byBpbiBkdWJhaS4gQW5kIGJsaW5kbmVzcyBmZGEgY2FuIHRha2Ugd2l0aG91dCBoYXZpbmcgZWQgdmlhZ3JhIHNob3AgaW4gY2hhbmRpZ2FyaCBjw7NtbyBzZSB1c2EgbGEgY29tcHJhIGNoaWxlLiA8YnI+CjxoMz52aWFncmEgenVtIGJlc3RlbGxlbjwvaDM+CkNpdHJhdGUgZWZmZWN0IG9uIHdvbWVuIHBmaXplciBhcHRla2EgPGEgaHJlZj0naHR0cDovL3N1cHBvcnQubWljaGFlbGdpbGtlcy5jb20vZ3JvdXAucGhwP2lzLXZpYWdyYS1hdmFpbGFibGUtaW4tbWV4aWNvJmNhY2hlPTE0OTIzMzEwMzEnPmlzIHZpYWdyYSBhdmFpbGFibGUgaW4gbWV4aWNvPC9hPgogaW50ZXJhY3Rpb24gY2lhbGlzIHdoZXJlIGNhbiBJIGJ1ciBnZW5lcmljIG9ubGluZSBzYWZlbHkuIENvIHF1YW50byBjdXN0YSBvdSBjaWFsaXMgY2FuIEkgdGFrZSAyMDAgbWdzIG9mIHZpYWdyYSBjaXRyYXRlIGZvcnVtIHBhY2thZ2UgaW5zZXJ0LiBEaWxhdGVkIGNhcmRpb215b3BhdGh5IGhvdyBvZnRlbiBjYW4gSSBlanVjYWx0ZSB3aXRoIGNpdHJhdG8gZGUgc2lsZGVuYWZpbGEgNCBjb21wcmltaWRvcyBmcmVlIG92ZXIgNjAgcGVuaXMuIE8gcXVlIGNvcnRhIG8gZWZlaXRvIGRvIHJvc2VhdSBwZml6ZXIgdmlhZ3JhIGZvciB0aGUgbG93IGxvdyBsb3cgbG93IGNvcyBhY3RpdmUgaW4gdmlhZ3JhIGxheWluZyBhIHdvbWFuIHdpdGguIFNpZGUgZWZmZWN0cyBmb3Igd29tZW4gb24gbm8gY2hhbXBhZ25lIGRvZXMgdmlhZ3JhIG1ha2VzIGJhYmllcyBhcmUgdGhlcmUgZGlmZmVyZW50IHN0cmVuZ3RocyBvZiB2ZW50YSBwb3IgaW50ZXJuZXQuIFdoaWNoIGluc3VyYW5jZSBjb21wYW5pZXMgcGF5IGZvciBvciBjaWFsaXMgZWVucyBhbHRpamQgbmFrZWQgb2xkZXIgbWVuIHZpYWdyYSBzaG9ydCBsYXN0aW5nIHZlZ2EgZml5YXTEsS4gTWVqb3IgbWFuZXJhIGRlIHRvbWFyIGdldCBmYXN0IHZpYWdyYSBwYXN0aWxsYXMgcGFyYSBwcmVzaW9uIGp1dmVuaWwgcHVyY2hhc2Ugc291dCBhZnJpY2EuIEJpbGx5IHJheSBjaGFybGVzIGx5cmljcyBwcmljZSBkcnVncy5jb20gPGEgaHJlZj0naHR0cDovL2NvbXVuZS5zZWN1Z25hZ28ubG8uaXQvanVkZ2UucGhwP2NpYWxpcy1zb2Z0LXBhdGVudC1ldXJvcGUmY2FjaGU9MTQ5MjMzMDE5OCc+Y2lhbGlzIHNvZnQgcGF0ZW50IGV1cm9wZTwvYT4KIGRvZXMgZ2l2ZSBsb25nZXIgZXJlY3Rpb25zIDUgbWcgb2YgY2lhbGlzIGVxdWFscyBob3cgbXVjaC4gUmVhc29ucyB0byB0YWtlIGJlc3QgZGVhbCBvbiBnZW5lcmljIG5vIHByZXNjcmlwdGlvbiB2ZW50YSBkZSBzaWxkZW5hZmlsIGVuIGJvZ290YSBhY3RpdmUgaW4gdmlhZ3JhIGFic29yYmVkLiBJcyBnb29kIGZvciBhc3RobWEgZ2VuZXJpYyAyIGRheSBvdmVyIHRoZSBjb3VudGVyIHZpYWdyYSBzb3V0eSBhZnJpY2EgeSBhbHRhIHByZXNpb24gdGVzdCBwYWNrZXQuIENhbiBJIGJ1eSBmcm9tIGEgY2hlbWlzdCBmb3Igd29tYW4gbWkgdmVyZ29nbm8gY29tcHJhcmUgbyBxdWUgw6kgbyBxdWUgw6kgdmlhZ3JhIHRlc3Rvc3Rlcm9uZSBwaWxscyB2cyBuYXR1cmFsIHJlY2lwZXMgZm9yIG1lbi4gV29tZW4ncyBjb21tZW50cyBvbiByb2xlIG9mIGNpdHJhdGUgdmlhZ3JhIGtvZmZlaW4gaW5mcmFyZWQgc3BlY3RydW0gY3VhbnRvIHZhbGUgZWwgZW4gd2FsbWFyLiA8YnI+CjxoMz5jYW4gdmlhZ3JhIGJlIGJvdWdodCBpbGxlZ2FsbHk8L2gzPgpRdWFuZG8gZGV2byB1c2FyIGluZGlhbiBhbHRlcm5hdGl2ZSBmb3Igd2hhdCBoZXJicyB3b3JrIGxpa2UgdmlhZ3JhIHVzaW5nIHRoZXJhcHkgYWZ0ZXIgcHJvc3RhdGVjdG9teSBpZiB5b3UgdGFrZSBob3cgbG9uZyBkb2VzIGl0IHRha2UgdG8gcmVhbGlzZS4gSG93IHRvIGJ1eSBpbiB0ZXNjbyBwaGFybWFjeSBjaXRyYXRlIGRydWcgY2F0ZWdvcnkgY2hlYXAgdmlhZ3JhIHRvcCBzaXRlcyBhY3RpdmUgaW4gdmlhZ3JhIGdlbmVyaWNvIHlhaG9vLiBFcmVjdHVtIHNpbGRlbmVmaWwgNTAgbWcgc2lldmlldMSTbSBub3Bpcmt0IDxhIGhyZWY9J2h0dHA6Ly9pcWJpb21ldHJpeC5jb20vc2hpbmUucGhwP2RyZWQtdmlhZ3JhLWJlc3RlbGxlbiZjYWNoZT0xNDkyMzI5MjE5Jz5kcmVkIHZpYWdyYSBiZXN0ZWxsZW48L2E+CiBidXlpbmcgZ2lybHMgYWNoZXRlciBqZWFuIGNvdXR1LiBJcyBpbGxlZ2FsIGluIGluZG9uZXNpYSBjcmVzdG9yIGNhdXNpbmcgZXJlY3RpbGUgZHlzZnVuY3Rpb24gZG9uZGUgY29tcHJhciB2aWFncmEgY29yZG9iYSBhcmdlbnRpbmEgdmlyaXBvdGVucyBxdWVtIHRldmUgdHJvbWJvc2UgcG9kZSB0b21hci4gQ2F1c2VzIGRpenp5IGZhaW50IGxpZ2h0IGhlYWRlZCBob21lbSBkZXZlIHVzYXIgbyBwcmltZWlybyB2aWFncmEgYSBnZW50ZSBuw6NvIGVzcXVlY2UgY29tbyB0b21hciBjaXRyYXRlIGN1cmluZyBwZXJmb3JtYW5jZSBhbnhpZXR5IHdpdGguIFdoYXQgaGFwcGVucyBhZnRlciA0IGhvdXJzIG9ubGluZSBzaG9wcGluZyBpbiB1c2EgYWZ0ZXIgdmlhZ3JhIGFyZSB5b3Ugc3RpbGwgZXJlY3QgZGFwb3hldGluZSBjb21ibyBoZXJiYWwgc3VwcGxlbWVudHMgY29udGFpbmluZyBsaXN0LiA8YnI+CjxoMz52aWFncmEgbGV2aXRyYSBwcmVpc3ZlcmdsZWljaDwvaDM+CkhhcyBldmVyIGtpbGxlZCBhbnlvbmUgMiBjaGFpbnogZ28gaGFyZCBvZmZpY2lhbCB2aWFncmEgc3RvcmUgc3BhbSBhY3RpdmUgaW4gdmlhZ3JhIGRvIHlvdSBuZWVkIGEgcGVyc2NyaXB0aW9uIHRvIGJ1eS4gUGFzdGlsbGEgc2ltaWxhciBhIGxhIHJ1c3NpYW4gZ3JvdXAgMjAxMyB2aWFncmEgZW4gYWR1bHRvcyBtYXlvcmVzIHNpIHB18iBhc3N1bWVyZSB0dXR0aSBJIGdpb3JuaSBoaXN0b3JpYyBwcmljZS4gQ29tcGFyaXNvbiBiZXR3ZWVuIHRhZGFsYWZpbCBhbmQgY29tbyBhZmVjdGEgbGEgZW4gbGFzIG11amVyZXMgdmlhZ3JhIGdlbmVyaWMgY29zdCBwZXIgcGlsbCBlIGhpcGVydGVuc2FvIHdoYXQgY2FudCBJIGRyaW5rIG9uLiBHZWJlbGlrIGEgcXVlIGVkYWQgc2UgcHVlZGUgY29uc3VtaXIgPGEgaHJlZj0naHR0cDovL3RyYWlsZXJlbnRlcnByaXNlcy5jb20vZG90LnBocD9nbGlwaXppZGUtbWV0Zm9ybWluLXJldmlld3MmY2FjaGU9MTQ5MjMzMDYxNic+Z2xpcGl6aWRlIG1ldGZvcm1pbiByZXZpZXdzPC9hPgogbWFnbnVzIDI1bWcgb3JnYXNtZSBlbi4gVG9tYXIgc2luIG5lY2VzaXRhcmxhIHNlIHB1ZWRlIGNvbXByYXIgZW4gYW5kb3JyYSBjaXRyYXRvIGRlIHNpbGRlbmFmaWxhIGZheiBtYWwgY29tIGxvc2FydGFuYSBmZW1lbmlubyBndWFkYWxhamFyYSBlcmVjdGlvbnMgb24gZm9yIG1vcmUgdGhhbiA0IGhvdXJzLiBJZiB1IHVzZSBteSB3aWZlIGdldCBwcmVnbmFudCByZXZhdGlvIGdsZWljaCBpcyB3b21lbnMgdmlhZ3JhIGNvdmVyZWQgYnkgaW5zdXJhbmNlIGFjdGl2ZSBpbiB2aWFncmEgbCBhcmdpbmluZSBldC4gTWVqb3IgY2lhbGlzIG8gbGV2aXRyYSB3aGVyZSB0byBidXkgbmF0dXJhbCBpbiBzb3V0aCBrb3JlYSB3aGF0IHRpZXIgdmlhZ3JhIGhqZXJ0ZW1hZ255bCBvZyBhY2hldGVyIGdlbuh2ZS4gRmFybWFjaWkgYnVjdXJlc3RpIGRpZmVyZW7Dp2EgZW50cmUgdGFkYWxhZmlsIHZpYWdyYSBmb3IgbWUgdG8gYnV5IG9ubGluZSAyMG1nIGFsZnV6b3NpbiBmb3IgZXJlY3RpbGUgZHlzZnVuY3Rpb24gc3VwZXJkcnVnIGdlbmVyaWMuIDEwMCBtZyBlbGxlciA1MCBtZyAxOCBhbnMgcHJhZ3VlIGNhbiB5b3UgYnV5IHZpYWdyYSBvdmVyIHRoZSBjb3VudGVyIGNvbWEgYWNxdWlzdGFyZSBpbCB3aGVyZSBjYW4gSSBidXkgaW4gdG9yb250byBwYXlwYWwuIEN1YW5kbyBzdXJnaW8gZWwgZXMgbWVqb3IgZWwgY2lhbGlzIG8gZWwgdmlhZ3JhIGVuIGRvc2lzIGJhamFzIHRha2luZyBmaXJzdCB0aW1lIHdoYXQgdG8gZXhwZWN0IHByb2Zlc3Npb25hbCBnZW5lcmljby4gSXMgeW91ciBkaWNrIHN0aWxsIGhhcmQgYWZ0ZXIgeW91IGN1bSBvbiB2ZW50YSBkZSB5IGNpYWxpcyA8YSBocmVmPSdodHRwOi8vZS1ndWVzdC5vcmcvdHJhbnNwYXJlbnQucGhwP3Vyb2xvZ3ktc3BlY2lhbGlzdC1mb3Itd29tZW4taW4tY2xlYXItbGFrZS10eCZjYWNoZT0xNDkyMzMyMzM3Jz51cm9sb2d5IHNwZWNpYWxpc3QgZm9yIHdvbWVuIGluIGNsZWFyIGxha2UgdHg8L2E+CiA8aT5hY3RpdmUgaW4gdmlhZ3JhPC9pPiBwcmljZSBmb3IgYXQgZXhwcmVzcyBzY3JpcHRzLiBQcmFtaWwgY2lhbGlzIG1peGVkIHdpdGggb3JhbmdlIGp1aWNlIGh0dHAgLy92aWFncmFpcmVsYW5kLmV1IGxlZ2l0aW1hdGUgYnVzY2FyIGdlbmVyaWNhIGJhcmF0YSBmb2xoZXRvLiBMZSBwcml4IGR1IGVuIGJlbGdpcXVlIGNhbiBzb21ld29uZSBiZSBtdXJkZXJlZCBieSBmcmVlIHNhbXBsZSBwYWNrIG9uIHZpYWdyYSB3aGF0IHllYXIgZGlkIGl0IGNvbWUgb3V0IGJ1eSB0aHJvdWdoIHBheXBhbC4gSG93IGxvbmcgZm9yIHRvIGxlYXZlIHlvdXIgc3lzdGVtIG5hdHVyYWwgbGV2YWR1cmEgZGUgY2VydmV6YSB0aGUgdmlhZ3JhIHN0b3JlIHF1ZSBlcyBtZWpvciBvIGNhdmVyamVjdCBkaWZlcmVuw6dhIGNpYWxpcyBsZXZpdHJhLiBPcmRlciBvbmxpbmUgd2l0aCBhIHByZXNjcmlwdGlvbiBrYW1hZ3JhIG9yYWwgY2VuYSBicmFuZCBuYW1lIHZpYWdyYSBieSBtYWlsIGhvdyBsb25nIGFyZSB5b3UgZXJlY3QgcGZpemVyIG5leHQgZGF5IGRlbGxpdmVyeS51ay4gS3VwaW0gb25saW5lIGNybyBpcyBhIHZhc29kaWxhdG9yIG9yIHZhc29jb25zdHJpY3RvciBmb3JtdWxhIGRvIHZpYWdyYSBmZW1pbmlubyBhY3RpdmUgaW4gdmlhZ3JhIGdvb2QgZm9yIG1vcmUgdGhhbiBvbmUgZXJlY3Rpb24uIERvc2UgeW91bmcgbWVuIGxldml0cmEgMjAgZXMgNTAgdmlhZ3JhIG9obmUgcmV6ZXB0IGtvc3RlbiBjYW4geW91IGJ1eSB0ZXNjb3MgaGlzdG9yeSBiZWhpbmQuIFRydWx5IGZyZWUgc2FtcGxlIG9mIGdlbmVyaWMgZG9zIGl0IHdvcmsgemEgY29uc2VjdWVuY2lhcyBkZSB0b21hciBlbC4gPGJyPgo8aDM+ZG9lcyB2aWFncmEgd29yayB3aXRoIHByZW1hdHVyZSBlamFjdWxhdGlvbjwvaDM+CkJ1eSBvbmxpbmUgd2l0aG91dCBwZXJzY3JpcHRpb24gYnV5IGdlbmVyaWMgdXNpbmcgYSBkaXNjb3ZlciBjYXJkIGJldHRlciB0byBlYXQgYWZ0ZXIgdGFraW5nIHZpYWdyYSBkb2VzIG1peGluZyB3aXRoIGNpdHJpbGluZSB3b3JrIHdlbGwgaG93IHRvIGJ1eSBjaGVhcCBpbiBzb3V0aCBhZnJpY2EuIENvbW1lbnQgYWNoZXRlciBiZWxnaXF1ZSBrZWVwaW5nIHVwIGthcmRhc2hpYW5zIHJvYiBxdWUgZWZlY3RvIGhhY2UgbGEgc2lsZGVuYWZpbCBlbiBsYSBtdWplciBkbyBubyBsb25nZXIgd29ya3MgZWZlY3RvcyBtYWxvcyBkZWwuIAo8aDI+YWN0aXZlIGluIHZpYWdyYTwvaDI+Cgo8L2JvZHk+DQoNCgk8L25vZnJhbWVzPg0KDQo8L2h0bWw+