|
Equipment Store
Welcome to Go-Gear, part of the Go Travel Sites! We are proud to offer a full range of outdoor recreation products in association with our partner, Backcountry.com. Click on any category below to browse hundreds of quality products for sale online.
| PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9vdXRkb29yX2dlYXIuaHRtbCIgY2xhc3M9IndzX2NydW1iX3RyYWlsIj5TaG9wPC9hPjxmb250IGNsYXNzPSJ3c19jcnVtYl9iZXR3ZWVuIj4gJmd0OyA8L2ZvbnQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9DLTExL01lbmFwb3NzLUNsb3RoaW5nLmh0bWwiIGNsYXNzPSJ3c19jcnVtYl90cmFpbCI+TWVuJmFwb3M7cyBDbG90aGluZzwvYT48Zm9udCBjbGFzcz0id3NfY3J1bWJfYmV0d2VlbiI+ICZndDsgPC9mb250PjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUy0xMV8yMC9NZW5hcG9zcy1KYWNrZXRzLmh0bWwiIGNsYXNzPSJ3c19jcnVtYl90cmFpbCI+TWVuJmFwb3M7cyBKYWNrZXRzPC9hPjxmb250IGNsYXNzPSJ3c19jcnVtYl9iZXR3ZWVuIj4gJmd0OyA8L2ZvbnQ+PGZvbnQgY2xhc3M9IndzX2NydW1iX2N1cnJlbnQiPk1lbiZhcG9zO3MgVGVjaG5pY2FsIFNoZWxsczwvZm9udD48aDMgY2xhc3M9IndzX3BhZ2VfaGVhZGluZyI+TWVuJmFwb3M7cyBUZWNobmljYWwgU2hlbGxzPC9oMz48dGFibGUgYm9yZGVyPTAgY2VsbHBhZGRpbmc9NSBjZWxsc3BhY2luZz0wIHdpZHRoPTk5JT4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNTA0L0FscGhhLVNWLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbHBoYSBTViBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9BUkMvQVJDMDUwNC9BU1ZCTFUuanBnIiBib3JkZXI9IjAiIGFsdD0iQWxwaGEgU1YgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQVJDMDUwNC9BbHBoYS1TVi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWxwaGEgU1YgSmFja2V0IC0gTWVuJmFwb3M7cyI+QXJjJ3Rlcnl4IEFscGhhIFNWIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5XYXRlcnByb29mIGJyZWF0aGFibGUgR29yZS1UZXggUHJvIG1hdGVyaWFsIGhlbHBzIHRoZSBBcmMmYXBvczt0ZXJ5eCBNZW4mYXBvcztzIEFscGhhIFNWIEphY2tldCBibG9jayB0aGUgYnVybGllc3Qgc3Rvcm1zIHdoaWxlIHJlaW5mb3JjZW1lbnRzIGhhbmRsZSB0aGUgYWJ1c2VzIG9mIGxpZmUgaW4gdGhlIGFscGluZSB3b3JsZC4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kNTk4Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNTA0L0FscGhhLVNWLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbHBoYSBTViBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1BUkMwNTA0JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0FSQzA1MDQvQXJjdGVyeXgtQWxwaGEtU1YtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJXYXRlcnByb29mIGJyZWF0aGFibGUgR29yZS1UZXggUHJvIG1hdGVyaWFsIGhlbHBzIHRoZSBBcmMmYXBvczt0ZXJ5eCBNZW4mYXBvcztzIEFscGhhIFNWIEphY2tldCBibG9jayB0aGUgYnVybGllc3Qgc3Rvcm1zIHdoaWxlIHJlaW5mb3JjZW1lbnRzIGhhbmRsZSB0aGUgYWJ1c2VzIG9mIGxpZmUgaW4gdGhlIGFscGluZSB3b3JsZC4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNTA2L1RoZXRhLVNWLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaGV0YSBTViBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9BUkMvQVJDMDUwNi9BQllCTC5qcGciIGJvcmRlcj0iMCIgYWx0PSJUaGV0YSBTViBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNTA2L1RoZXRhLVNWLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaGV0YSBTViBKYWNrZXQgLSBNZW4mYXBvcztzIj5BcmMndGVyeXggVGhldGEgU1YgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkluIGFkZGl0aW9uIHRvIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBHb3JlLVRleCBQcm8gbWF0ZXJpYWwsIEFyYyZhcG9zO3Rlcnl4IGdhdmUgdGhlIE1lbiZhcG9zO3MgVGhldGEgU1YgSmFja2V0IGFuIGV4dHJhLWxvbmcgY3V0IHRvIHByb3ZpZGUgZXZlbiBtb3JlIHByb3RlY3Rpb24gaW4gaG9ycmVuZG91cyB3ZWF0aGVyLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ1NDkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0FSQzA1MDYvVGhldGEtU1YtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRoZXRhIFNWIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUFSQzA1MDYmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvQVJDMDUwNi9BcmN0ZXJ5eC1UaGV0YS1TVi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkluIGFkZGl0aW9uIHRvIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBHb3JlLVRleCBQcm8gbWF0ZXJpYWwsIEFyYyZhcG9zO3Rlcnl4IGdhdmUgdGhlIE1lbiZhcG9zO3MgVGhldGEgU1YgSmFja2V0IGFuIGV4dHJhLWxvbmcgY3V0IHRvIHByb3ZpZGUgZXZlbiBtb3JlIHByb3RlY3Rpb24gaW4gaG9ycmVuZG91cyB3ZWF0aGVyLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0FSQzA2ODUvQmV0YS1MVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQmV0YSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9BUkMvQVJDMDY4NS9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJCZXRhIExUIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0FSQzA2ODUvQmV0YS1MVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQmV0YSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzIj5BcmMndGVyeXggQmV0YSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIEFyYyZhcG9zO3Rlcnl4IE1lbiZhcG9zO3MgQmV0YSBMVCBKYWNrZXQgZ2l2ZXMgeW91IHRoZSBsaWdodHdlaWdodCBjb25zdHJ1Y3Rpb24geW91IHdhbnQgZm9yIGZhc3QtYW5kLWxpZ2h0IGFscGluZSBhc3NlbnRzIHdpdGhvdXQgc2FjcmlmaWNpbmcgYW55IG9mIHRoZSB3ZWF0aGVyIHByb3RlY3Rpb24geW91IG5lZWQgZm9yIGxpZmUgaW4gdGhlIG1vdW50YWlucy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ0OTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0FSQzA2ODUvQmV0YS1MVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQmV0YSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1BUkMwNjg1JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0FSQzA2ODUvQXJjdGVyeXgtQmV0YS1MVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSBBcmMmYXBvczt0ZXJ5eCBNZW4mYXBvcztzIEJldGEgTFQgSmFja2V0IGdpdmVzIHlvdSB0aGUgbGlnaHR3ZWlnaHQgY29uc3RydWN0aW9uIHlvdSB3YW50IGZvciBmYXN0LWFuZC1saWdodCBhbHBpbmUgYXNzZW50cyB3aXRob3V0IHNhY3JpZmljaW5nIGFueSBvZiB0aGUgd2VhdGhlciBwcm90ZWN0aW9uIHlvdSBuZWVkIGZvciBsaWZlIGluIHRoZSBtb3VudGFpbnMuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNjk5L0FscGhhLUxULUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbHBoYSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9BUkMvQVJDMDY5OS9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJBbHBoYSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNjk5L0FscGhhLUxULUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbHBoYSBMVCBKYWNrZXQgLSBNZW4mYXBvcztzIj5BcmMndGVyeXggQWxwaGEgTFQgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSBBcmMmYXBvczt0ZXJ5eCBNZW4mYXBvcztzIEFscGhhIExUIEphY2tldCBmaWdodHMgb2ZmIHRoZSB3b3JzdCBtb3VudGFpbiB3ZWF0aGVyIHRoYW5rcyB0byB0aHJlZS1sYXllciwgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIEdvcmUtVGV4IFBybyBTaGVsbCBmYWJyaWMsIGJ1dCBvbmx5IGFkZHMgMTIuOSBvdW5jZXMgdG8geW91ciBwYWNrLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDQ5OC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQVJDMDY5OS9BbHBoYS1MVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWxwaGEgTFQgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9QVJDMDY5OSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9BUkMwNjk5L0FyY3Rlcnl4LUFscGhhLUxULUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIEFyYyZhcG9zO3Rlcnl4IE1lbiZhcG9zO3MgQWxwaGEgTFQgSmFja2V0IGZpZ2h0cyBvZmYgdGhlIHdvcnN0IG1vdW50YWluIHdlYXRoZXIgdGhhbmtzIHRvIHRocmVlLWxheWVyLCB3YXRlcnByb29mIGJyZWF0aGFibGUgR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYywgYnV0IG9ubHkgYWRkcyAxMi45IG91bmNlcyB0byB5b3VyIHBhY2suIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNzc1L1RoZXRhLUFSLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaGV0YSBBUiBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9BUkMvQVJDMDc3NS9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJUaGV0YSBBUiBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNzc1L1RoZXRhLUFSLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaGV0YSBBUiBKYWNrZXQgLSBNZW4mYXBvcztzIj5BcmMndGVyeXggVGhldGEgQVIgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkF0IHRoaXMgcG9pbnQsIHdlZCBoYXZlIHRob3VnaHQgQXJjdGVyeXggY291bGRudCBmaW5kIHlldCBhbm90aGVyIHdheSB0byBpbXByb3ZlIG9uIHRoZSBNZW5zIFRoZXRhIEFSdGhpcyB3YXRlcnByb29mIGJyZWF0aGFibGUgR29yZS1UZXggUHJvIFNoZWxsIGphY2tldCBhbHJlYWR5IGhhcyBzbyBtdWNoIGdvaW5nIGZvciBpdC4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kNDc0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNzc1L1RoZXRhLUFSLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaGV0YSBBUiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1BUkMwNzc1JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0FSQzA3NzUvQXJjdGVyeXgtVGhldGEtQVItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJBdCB0aGlzIHBvaW50LCB3ZWQgaGF2ZSB0aG91Z2h0IEFyY3Rlcnl4IGNvdWxkbnQgZmluZCB5ZXQgYW5vdGhlciB3YXkgdG8gaW1wcm92ZSBvbiB0aGUgTWVucyBUaGV0YSBBUnRoaXMgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIEdvcmUtVGV4IFBybyBTaGVsbCBqYWNrZXQgYWxyZWFkeSBoYXMgc28gbXVjaCBnb2luZyBmb3IgaXQuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQkNDMDE0NS9TdG9pYy0yMC1TaGVsbC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdG9pYyAyLjAgU2hlbGwgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9CQ0MvQkNDMDE0NS9DUi5qcGciIGJvcmRlcj0iMCIgYWx0PSJTdG9pYyAyLjAgU2hlbGwgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CQ0MwMTQ1L1N0b2ljLTIwLVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlN0b2ljIDIuMCBTaGVsbCAtIE1lbiZhcG9zO3MiPkJhY2tjb3VudHJ5LmNvbSBTdG9pYyAyLjAgU2hlbGwgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIFN0b2ljIDIuMCBTaGVsbCB0YWtlcyBldmVyeXRoaW5nIHdldmUgbGVhcm5lZCBhYm91dCBmaXQgYW5kIGZ1bmN0aW9uIGFuZCBkaXN0aWxscyBpdCBpbnRvIGphY2tldCBmb3JtLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDIyOS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDEwOS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQkNDMDE0NS9TdG9pYy0yMC1TaGVsbC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdG9pYyAyLjAgU2hlbGwgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1CQ0MwMTQ1JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0JDQzAxNDUvQmFja2NvdW50cnljb20tU3RvaWMtMjAtU2hlbGwtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSBTdG9pYyAyLjAgU2hlbGwgdGFrZXMgZXZlcnl0aGluZyB3ZXZlIGxlYXJuZWQgYWJvdXQgZml0IGFuZCBmdW5jdGlvbiBhbmQgZGlzdGlsbHMgaXQgaW50byBqYWNrZXQgZm9ybS4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CQ0MwMTc3L1N0b2ljLWVWZW50LVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlN0b2ljIGVWZW50IFNoZWxsIC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQkNDL0JDQzAxNzcvQ1kuanBnIiBib3JkZXI9IjAiIGFsdD0iU3RvaWMgZVZlbnQgU2hlbGwgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CQ0MwMTc3L1N0b2ljLWVWZW50LVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlN0b2ljIGVWZW50IFNoZWxsIC0gTWVuJmFwb3M7cyI+QmFja2NvdW50cnkuY29tIFN0b2ljIGVWZW50IFNoZWxsIC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPk1vc3Qgd2F0ZXJwcm9vZiBhbmQgd2luZHByb29mIGZhYnJpY3MgYXJlIGdyZWF0dW50aWwgeW91IHR1cm4gaW50byBhIHN0aWZsaW5nIHNhdW5hIG9uIHRoZSBza2luIHRyYWNrLiBUaGUgZXh0cmVtZWx5LWJyZWF0aGFibGUgQmFja2NvdW50cnkuY29tIE1lbnMgU3RvaWMgZVZlbnQgU2hlbGwgc3RhbmRzIHVwIHRvIE1vdGhlciBOYXR1cmUgYW5kIGV4cGVscyBzd2VhdHkgZnVuayBsaWtlIGEgYmVlci1iaW5naW5nIHVuZGVyY2xhc3NtYW4uIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzM5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTg2Ljk3PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CQ0MwMTc3L1N0b2ljLWVWZW50LVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlN0b2ljIGVWZW50IFNoZWxsIC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9QkNDMDE3NyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9CQ0MwMTc3L0JhY2tjb3VudHJ5Y29tLVN0b2ljLWVWZW50LVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJNb3N0IHdhdGVycHJvb2YgYW5kIHdpbmRwcm9vZiBmYWJyaWNzIGFyZSBncmVhdHVudGlsIHlvdSB0dXJuIGludG8gYSBzdGlmbGluZyBzYXVuYSBvbiB0aGUgc2tpbiB0cmFjay4gVGhlIGV4dHJlbWVseS1icmVhdGhhYmxlIEJhY2tjb3VudHJ5LmNvbSBNZW5zIFN0b2ljIGVWZW50IFNoZWxsIHN0YW5kcyB1cCB0byBNb3RoZXIgTmF0dXJlIGFuZCBleHBlbHMgc3dlYXR5IGZ1bmsgbGlrZSBhIGJlZXItYmluZ2luZyB1bmRlcmNsYXNzbWFuLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JSRzAwMDEvQXR0cml0aW9uLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBdHRyaXRpb24gSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQlJHL0JSRzAwMDEvQkxBLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkF0dHJpdGlvbiBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CUkcwMDAxL0F0dHJpdGlvbi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQXR0cml0aW9uIEphY2tldCAtIE1lbiZhcG9zO3MiPkJlcmdoYXVzIEF0dHJpdGlvbiBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIEJlcmdoYXVzIEF0dHJpdGlvbiBKYWNrZXQgdXRpbGl6ZXMgem9uZS1yZWluZm9yY2VkIDMtcGx5IEdvcmUtVGV4IFBybyBTaGVsbCBmYWJyaWMgdG8gZW5zdXJlIHlvdSB3b24mYXBvczt0IGJlIGFtb25nIHRob3NlIGxlZnQgYmVoaW5kLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDQ5OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDM5OS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlJHMDAwMS9BdHRyaXRpb24tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkF0dHJpdGlvbiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1CUkcwMDAxJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0JSRzAwMDEvQmVyZ2hhdXMtQXR0cml0aW9uLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIEJlcmdoYXVzIEF0dHJpdGlvbiBKYWNrZXQgdXRpbGl6ZXMgem9uZS1yZWluZm9yY2VkIDMtcGx5IEdvcmUtVGV4IFBybyBTaGVsbCBmYWJyaWMgdG8gZW5zdXJlIHlvdSB3b24mYXBvczt0IGJlIGFtb25nIHRob3NlIGxlZnQgYmVoaW5kLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JSRzAwMDgvVGVtcGVyYW5jZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGVtcGVyYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9CUkcvQlJHMDAwOC9CTEEuanBnIiBib3JkZXI9IjAiIGFsdD0iVGVtcGVyYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CUkcwMDA4L1RlbXBlcmFuY2UtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRlbXBlcmFuY2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+QmVyZ2hhdXMgVGVtcGVyYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+TGlnaHQsIHRvdWdoLCBhbmQgZWZmaWNpZW50LCB0aGUgQmVyZ2hhdXMgVGVtcGVyYW5jZSBKYWNrZXQgdXNlcyAzLWxheWVyIEdvcmUtVGV4IFBybyBTaGVsbCB0byBmdWxmaWxsIGl0cyByb2xlIGFzIGEgc2Vhc29uZWQgYWxwaW5lIHdhcnJpb3IuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzQ5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjc5Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CUkcwMDA4L1RlbXBlcmFuY2UtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRlbXBlcmFuY2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9QlJHMDAwOCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9CUkcwMDA4L0JlcmdoYXVzLVRlbXBlcmFuY2UtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJMaWdodCwgdG91Z2gsIGFuZCBlZmZpY2llbnQsIHRoZSBCZXJnaGF1cyBUZW1wZXJhbmNlIEphY2tldCB1c2VzIDMtbGF5ZXIgR29yZS1UZXggUHJvIFNoZWxsIHRvIGZ1bGZpbGwgaXRzIHJvbGUgYXMgYSBzZWFzb25lZCBhbHBpbmUgd2Fycmlvci4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CUkcwMDEyL01lcmEtUGVhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTWVyYSBQZWFrIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0JSRy9CUkcwMDEyL0RBTUlCTE1JLmpwZyIgYm9yZGVyPSIwIiBhbHQ9Ik1lcmEgUGVhayBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CUkcwMDEyL01lcmEtUGVhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTWVyYSBQZWFrIEphY2tldCAtIE1lbiZhcG9zO3MiPkJlcmdoYXVzIE1lcmEgUGVhayBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+QmVyZ2hhdXMgYnJpbmdzIGJhY2sgYSBjbGFzc2ljIHdpdGggdGhlIHJlZGVzaWduZWQgTWVyYSBQZWFrIEphY2tldCwgYSB0cnVlIDQtc2Vhc29uIG91dGRvb3IgZm91bC13ZWF0aGVyIHNoZWxsIHdpdGggdHJhZGl0aW9uYWwgZ29vZCBsb29rcyBhbmQgc2lnbmF0dXJlIEJlcmdoYXVzIGZ1bmN0aW9uLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDM0OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDI3OS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlJHMDAxMi9NZXJhLVBlYWstSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik1lcmEgUGVhayBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1CUkcwMDEyJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0JSRzAwMTIvQmVyZ2hhdXMtTWVyYS1QZWFrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iQmVyZ2hhdXMgYnJpbmdzIGJhY2sgYSBjbGFzc2ljIHdpdGggdGhlIHJlZGVzaWduZWQgTWVyYSBQZWFrIEphY2tldCwgYSB0cnVlIDQtc2Vhc29uIG91dGRvb3IgZm91bC13ZWF0aGVyIHNoZWxsIHdpdGggdHJhZGl0aW9uYWwgZ29vZCBsb29rcyBhbmQgc2lnbmF0dXJlIEJlcmdoYXVzIGZ1bmN0aW9uLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JVUjIxODIvMkwtR29yZVRleC1TaGVsdGVyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSIyTCBHb3JlLVRleCBTaGVsdGVyIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0JVUi9CVVIyMTgyL0JLV1NQLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IjJMIEdvcmUtVGV4IFNoZWx0ZXIgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMjE4Mi8yTC1Hb3JlVGV4LVNoZWx0ZXItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IjJMIEdvcmUtVGV4IFNoZWx0ZXIgSmFja2V0IC0gTWVuJmFwb3M7cyI+QnVydG9uIDJMIEdvcmUtVGV4IFNoZWx0ZXIgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRocm93IHRoZSBCdXJ0b24gTWVucyAyTCBHb3JlLVRleCBTaGVsdGVyIEphY2tldCBzaHJlZCBpbnNpZGUgeW91ciBvd24gd2VhdGhlci1wcm9vZiwgbW91bnRhaW4tc2lkZSBzaGVsdGVyLiBUd28tbGF5ZXIgR29yZS1UZXggcHJvdGVjdGlvbiwgZnVsbHkgdGFwZWQgc2VhbXMsIGFuZCBCdXJ0b25zIENyb3NzZmxvdyB2ZW50aW5nIGNyZWF0ZSBhIHdlYXRoZXItcHJvb2Ygc3VpdCBvZiBhcm1vciB3b3J0aHkgb2YgdG9kYXlzIGFybXkgb2Ygc2hyZWRkZXJzLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzM5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTY5Ljk4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIyMTgyLzJMLUdvcmVUZXgtU2hlbHRlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iMkwgR29yZS1UZXggU2hlbHRlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1CVVIyMTgyJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0JVUjIxODIvQnVydG9uLTJMLUdvcmVUZXgtU2hlbHRlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRocm93IHRoZSBCdXJ0b24gTWVucyAyTCBHb3JlLVRleCBTaGVsdGVyIEphY2tldCBzaHJlZCBpbnNpZGUgeW91ciBvd24gd2VhdGhlci1wcm9vZiwgbW91bnRhaW4tc2lkZSBzaGVsdGVyLiBUd28tbGF5ZXIgR29yZS1UZXggcHJvdGVjdGlvbiwgZnVsbHkgdGFwZWQgc2VhbXMsIGFuZCBCdXJ0b25zIENyb3NzZmxvdyB2ZW50aW5nIGNyZWF0ZSBhIHdlYXRoZXItcHJvb2Ygc3VpdCBvZiBhcm1vciB3b3J0aHkgb2YgdG9kYXlzIGFybXkgb2Ygc2hyZWRkZXJzLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwMy9BSy0zTC1Hb3JldGV4LUhvdmVyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAzTCBHb3JlLXRleCBIb3ZlciBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9CVVIvQlVSMzEwMy9GT1guanBnIiBib3JkZXI9IjAiIGFsdD0iQUsgM0wgR29yZS10ZXggSG92ZXIgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwMy9BSy0zTC1Hb3JldGV4LUhvdmVyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAzTCBHb3JlLXRleCBIb3ZlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5CdXJ0b24gQUsgM0wgR29yZS10ZXggSG92ZXIgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPldoZW4gdGhlIGhlbGljb3B0ZXIgcmVzdHMgaXRzIHNraWRzIG9uIHRoZSBzbm93eSByaWRnZWxpbmUsIHppcCB1cCB5b3VyIEJ1cnRvbiBNZW5zIEFLIDNMIEhvdmVyIEphY2tldCwgdW5sb2FkLCBhbmQgIHN0cmFwIGluLiBUaGlzIGJvbWJwcm9vZiBqYWNrZXQga2VlcHMgdGhlIHdlYXRoZXIgb3V0LjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDU1OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwMy9BSy0zTC1Hb3JldGV4LUhvdmVyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAzTCBHb3JlLXRleCBIb3ZlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1CVVIzMTAzJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0JVUjMxMDMvQnVydG9uLUFLLTNMLUdvcmV0ZXgtSG92ZXItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJXaGVuIHRoZSBoZWxpY29wdGVyIHJlc3RzIGl0cyBza2lkcyBvbiB0aGUgc25vd3kgcmlkZ2VsaW5lLCB6aXAgdXAgeW91ciBCdXJ0b24gTWVucyBBSyAzTCBIb3ZlciBKYWNrZXQsIHVubG9hZCwgYW5kICBzdHJhcCBpbi4gVGhpcyBib21icHJvb2YgamFja2V0IGtlZXBzIHRoZSB3ZWF0aGVyIG91dC4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JVUjMxMDYvQUstMkwtR29yZXRleC1TdGFnZ2VyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAyTCBHb3JlLXRleCBTdGFnZ2VyIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0JVUi9CVVIzMTA2L0FHQS5qcGciIGJvcmRlcj0iMCIgYWx0PSJBSyAyTCBHb3JlLXRleCBTdGFnZ2VyIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JVUjMxMDYvQUstMkwtR29yZXRleC1TdGFnZ2VyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAyTCBHb3JlLXRleCBTdGFnZ2VyIEphY2tldCAtIE1lbiZhcG9zO3MiPkJ1cnRvbiBBSyAyTCBHb3JlLXRleCBTdGFnZ2VyIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgQUsgMkwgU3RhZ2dlciBKYWNrZXQuIEZlYXR1cmluZyBHb3JlLVRleCBQZXJmb3JtYW5jZSBTaGVsbCBhbmQgQnVydG9ucyBBTFMgbGluaW5nLCB0aGlzIGNvbWZvcnRhYmxlLCBib21iZXIgcGllY2Ugd2lsbCBrZWVwIHlvdSByaWRpbmcgZHJ5IGFuZCBzdG9rZWQgb24gdGhlIHN0b3JtIGRheXMgdGhhdCBrZWVwIG1vc3QgcGVvcGxlIGluZG9vcnMuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDM2OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwNi9BSy0yTC1Hb3JldGV4LVN0YWdnZXItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFLIDJMIEdvcmUtdGV4IFN0YWdnZXIgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9QlVSMzEwNiZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9CVVIzMTA2L0J1cnRvbi1BSy0yTC1Hb3JldGV4LVN0YWdnZXItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgQUsgMkwgU3RhZ2dlciBKYWNrZXQuIEZlYXR1cmluZyBHb3JlLVRleCBQZXJmb3JtYW5jZSBTaGVsbCBhbmQgQnVydG9ucyBBTFMgbGluaW5nLCB0aGlzIGNvbWZvcnRhYmxlLCBib21iZXIgcGllY2Ugd2lsbCBrZWVwIHlvdSByaWRpbmcgZHJ5IGFuZCBzdG9rZWQgb24gdGhlIHN0b3JtIGRheXMgdGhhdCBrZWVwIG1vc3QgcGVvcGxlIGluZG9vcnMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwNy9BSy0yTC1KdXNzaS1Hb3JldGV4LUFub3Jhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQUsgMkwgSnVzc2kgR29yZS10ZXggQW5vcmFrIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0JVUi9CVVIzMTA3L0hFQS5qcGciIGJvcmRlcj0iMCIgYWx0PSJBSyAyTCBKdXNzaSBHb3JlLXRleCBBbm9yYWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwNy9BSy0yTC1KdXNzaS1Hb3JldGV4LUFub3Jhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQUsgMkwgSnVzc2kgR29yZS10ZXggQW5vcmFrIEphY2tldCAtIE1lbiZhcG9zO3MiPkJ1cnRvbiBBSyAyTCBKdXNzaSBHb3JlLXRleCBBbm9yYWsgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkp1c3NpIE9rc2FubmVuIHNwZW5kcyByaWRpY3Vsb3VzIGFtb3VudHMgb2YgdGltZSBpbiB0aGUgYmlnIG1vdW50YWlucywgc28gaGUgZGVzaWduZWQgdGhlIEJ1cnRvbiBNZW5zIEFLIDJMIEp1c3NpIEFub3JhayBKYWNrZXQgdG8gaGFuZGxlIHRoZSBoYXJzaGVzdCBlbnZpcm9ubWVudHMuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzQ5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIzMTA3L0FLLTJMLUp1c3NpLUdvcmV0ZXgtQW5vcmFrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAyTCBKdXNzaSBHb3JlLXRleCBBbm9yYWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9QlVSMzEwNyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9CVVIzMTA3L0J1cnRvbi1BSy0yTC1KdXNzaS1Hb3JldGV4LUFub3Jhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9Ikp1c3NpIE9rc2FubmVuIHNwZW5kcyByaWRpY3Vsb3VzIGFtb3VudHMgb2YgdGltZSBpbiB0aGUgYmlnIG1vdW50YWlucywgc28gaGUgZGVzaWduZWQgdGhlIEJ1cnRvbiBNZW5zIEFLIDJMIEp1c3NpIEFub3JhayBKYWNrZXQgdG8gaGFuZGxlIHRoZSBoYXJzaGVzdCBlbnZpcm9ubWVudHMuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIzMTA5L0FLLTJMLUdvcmV0ZXgtQ3ljbGljLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAyTCBHb3JlLXRleCBDeWNsaWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQlVSL0JVUjMxMDkvQUtPU09SLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkFLIDJMIEdvcmUtdGV4IEN5Y2xpYyBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIzMTA5L0FLLTJMLUdvcmV0ZXgtQ3ljbGljLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBSyAyTCBHb3JlLXRleCBDeWNsaWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+QnVydG9uIEFLIDJMIEdvcmUtdGV4IEN5Y2xpYyBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+R29yZS1UZXggUGVyZm9ybWFuY2UgZmFicmljIGFuZCBmdWxseSB0YXBlZCBzZWFtcyBnaXZlIHRoZSBCdXJ0b24gTWVucyBBSyAyTCBDeWNsaWMgSmFja2V0IGEgbGV2ZWwgb2YgbW9pc3R1cmUgcHJvdGVjdGlvbiB0aGF0IGVhc2lseSBoYW5kbGVzIHRoZSBiaWdnZXN0IHBlYWtzLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDMzOS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQlVSMzEwOS9BSy0yTC1Hb3JldGV4LUN5Y2xpYy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQUsgMkwgR29yZS10ZXggQ3ljbGljIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUJVUjMxMDkmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvQlVSMzEwOS9CdXJ0b24tQUstMkwtR29yZXRleC1DeWNsaWMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJHb3JlLVRleCBQZXJmb3JtYW5jZSBmYWJyaWMgYW5kIGZ1bGx5IHRhcGVkIHNlYW1zIGdpdmUgdGhlIEJ1cnRvbiBNZW5zIEFLIDJMIEN5Y2xpYyBKYWNrZXQgYSBsZXZlbCBvZiBtb2lzdHVyZSBwcm90ZWN0aW9uIHRoYXQgZWFzaWx5IGhhbmRsZXMgdGhlIGJpZ2dlc3QgcGVha3MuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIzMTE3LzJMLUdvcmV0ZXgtU2hlbHRlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iMkwgR29yZS10ZXggU2hlbHRlciBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9CVVIvQlVSMzExNy9DSEwuanBnIiBib3JkZXI9IjAiIGFsdD0iMkwgR29yZS10ZXggU2hlbHRlciBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIzMTE3LzJMLUdvcmV0ZXgtU2hlbHRlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iMkwgR29yZS10ZXggU2hlbHRlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5CdXJ0b24gMkwgR29yZS10ZXggU2hlbHRlciBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIEJ1cnRvbiBNZW5zIDJMIEdUWCBTaGVsdGVyIEphY2tldCBwYWNrcyB0aGUgdG9wLXNoZWxmIHdlYXRoZXIgcHJvdGVjdGlvbiBvZiBmdWxseSB3YXRlcnByb29mIGFuZCB1bHRyYS1icmVhdGhhYmxlIEdvcmUtVGV4IFBlcmZvcm1hbmNlIGZhYnJpYy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzNjkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JVUjMxMTcvMkwtR29yZXRleC1TaGVsdGVyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSIyTCBHb3JlLXRleCBTaGVsdGVyIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUJVUjMxMTcmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvQlVSMzExNy9CdXJ0b24tMkwtR29yZXRleC1TaGVsdGVyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIEJ1cnRvbiBNZW5zIDJMIEdUWCBTaGVsdGVyIEphY2tldCBwYWNrcyB0aGUgdG9wLXNoZWxmIHdlYXRoZXIgcHJvdGVjdGlvbiBvZiBmdWxseSB3YXRlcnByb29mIGFuZCB1bHRyYS1icmVhdGhhYmxlIEdvcmUtVGV4IFBlcmZvcm1hbmNlIGZhYnJpYy4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JVUjMxMTgvU2hyaWtlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTaHJpa2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQlVSL0JVUjMxMTgvVFJVQksuanBnIiBib3JkZXI9IjAiIGFsdD0iU2hyaWtlIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0JVUjMxMTgvU2hyaWtlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTaHJpa2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+QnVydG9uIFNocmlrZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+UHVsbCBvbiB0aGUgQnVydG9uIE1lbnMgU2hyaWtlIFNub3dib2FyZGluZyBKYWNrZXQgYW5kIHB1c2ggd29ycmllcyBhYm91dCB3ZXQgd2VhdGhlciB0byB0aGUgYmFjayBvZiB5b3VyIG1pbmQuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzU5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9CVVIzMTE4L1NocmlrZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2hyaWtlIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUJVUjMxMTgmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvQlVSMzExOC9CdXJ0b24tU2hyaWtlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iUHVsbCBvbiB0aGUgQnVydG9uIE1lbnMgU2hyaWtlIFNub3dib2FyZGluZyBKYWNrZXQgYW5kIHB1c2ggd29ycmllcyBhYm91dCB3ZXQgd2VhdGhlciB0byB0aGUgYmFjayBvZiB5b3VyIG1pbmQuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DREcwMDE1L1RvZmluby1Cb21iZXItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRvZmlubyBCb21iZXIgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQ0RHL0NERzAwMTUvRVNCTC5qcGciIGJvcmRlcj0iMCIgYWx0PSJUb2Zpbm8gQm9tYmVyIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0NERzAwMTUvVG9maW5vLUJvbWJlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVG9maW5vIEJvbWJlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5DYW5hZGEgR29vc2UgVG9maW5vIEJvbWJlciBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIFRvZmlubyBCb21iZXIgSmFja2V0IGlzIGEgMy1wbHkgd2F0ZXJwcm9vZiB0ZWNobmljYWwgc2hlbGwgZnJvbSB0aGUgZXh0cmVtZS13ZWF0aGVyIGV4cGVkaXRpb24gZ3VydXMgYXQgQ2FuYWRhIEdvb3NlLiAgICAgPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNDkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxMzkuOTg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0NERzAwMTUvVG9maW5vLUJvbWJlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVG9maW5vIEJvbWJlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1DREcwMDE1JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0NERzAwMTUvQ2FuYWRhLUdvb3NlLVRvZmluby1Cb21iZXItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgVG9maW5vIEJvbWJlciBKYWNrZXQgaXMgYSAzLXBseSB3YXRlcnByb29mIHRlY2huaWNhbCBzaGVsbCBmcm9tIHRoZSBleHRyZW1lLXdlYXRoZXIgZXhwZWRpdGlvbiBndXJ1cyBhdCBDYW5hZGEgR29vc2UuICAgICAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0NERzAwMTcvTm9ydGgtQmF5LUV4cGVkaXRpb24tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik5vcnRoIEJheSBFeHBlZGl0aW9uIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0NERy9DREcwMDE3L0pFQksuanBnIiBib3JkZXI9IjAiIGFsdD0iTm9ydGggQmF5IEV4cGVkaXRpb24gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ0RHMDAxNy9Ob3J0aC1CYXktRXhwZWRpdGlvbi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTm9ydGggQmF5IEV4cGVkaXRpb24gSmFja2V0IC0gTWVuJmFwb3M7cyI+Q2FuYWRhIEdvb3NlIE5vcnRoIEJheSBFeHBlZGl0aW9uIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5PdXRkb29yc21lbiBzZWVraW5nIGxvbmdlciBjb3ZlcmFnZSBhbmQgbGFzdGluZyBkdXJhYmlsaXR5IGluIGEgZm91bCB3ZWF0aGVyIHNoZWxsIG5lZWQgbG9vayBubyBmdXJ0aGVyIHRoYW4gdGhlIENhbmFkYSBHb29zZSBNZW4mYXBvcztzIE5vcnRoIEJheSBFeHBlZGl0aW9uIEphY2tldC4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0ODkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxOTUuOTg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0NERzAwMTcvTm9ydGgtQmF5LUV4cGVkaXRpb24tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik5vcnRoIEJheSBFeHBlZGl0aW9uIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUNERzAwMTcmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvQ0RHMDAxNy9DYW5hZGEtR29vc2UtTm9ydGgtQmF5LUV4cGVkaXRpb24tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJPdXRkb29yc21lbiBzZWVraW5nIGxvbmdlciBjb3ZlcmFnZSBhbmQgbGFzdGluZyBkdXJhYmlsaXR5IGluIGEgZm91bCB3ZWF0aGVyIHNoZWxsIG5lZWQgbG9vayBubyBmdXJ0aGVyIHRoYW4gdGhlIENhbmFkYSBHb29zZSBNZW4mYXBvcztzIE5vcnRoIEJheSBFeHBlZGl0aW9uIEphY2tldC4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DTFYwNDU1L0tvdmVuLVBsdXMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IktvdmVuIFBsdXMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQ0xWMDQ1NS5qcGciIGJvcmRlcj0iMCIgYWx0PSJLb3ZlbiBQbHVzIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0NMVjA0NTUvS292ZW4tUGx1cy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iS292ZW4gUGx1cyBKYWNrZXQgLSBNZW4mYXBvcztzIj5DbG91ZHZlaWwgS292ZW4gUGx1cyBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIENsb3VkdmVpbCBNZW5zIEtvdmVuIFBsdXMgSmFja2V0IGlzIGEgdmVyc2F0aWxlLCByZWFjdGl2ZSBzaGVsbCBqYWNrZXQgZm9yIGFsbCB0aGluZ3MgYWxwaW5lLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzk5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzE5Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DTFYwNDU1L0tvdmVuLVBsdXMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IktvdmVuIFBsdXMgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9Q0xWMDQ1NSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9DTFYwNDU1L0Nsb3VkdmVpbC1Lb3Zlbi1QbHVzLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIENsb3VkdmVpbCBNZW5zIEtvdmVuIFBsdXMgSmFja2V0IGlzIGEgdmVyc2F0aWxlLCByZWFjdGl2ZSBzaGVsbCBqYWNrZXQgZm9yIGFsbCB0aGluZ3MgYWxwaW5lLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ0xWMDQ1OC9TaGFkb3ctUGVhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2hhZG93IFBlYWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQ0xWL0NMVjA0NTgvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iU2hhZG93IFBlYWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ0xWMDQ1OC9TaGFkb3ctUGVhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2hhZG93IFBlYWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+Q2xvdWR2ZWlsIFNoYWRvdyBQZWFrIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5Ib3Agb24gdGhlIGxpZnQgb3IgaGVhZCB1cCB0aGUgc2tpbiB0cmFjayB3aXRoIHRoZSBDbG91ZHZlaWwgTWVucyBTaGFkb3cgUGVhayBKYWNrZXQgYXMgeW91ciBmb3VsLXdlYXRoZXIgaW5zdXJhbmNlIHBvbGljeS48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDM0OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDI3OS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ0xWMDQ1OC9TaGFkb3ctUGVhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2hhZG93IFBlYWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9Q0xWMDQ1OCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9DTFYwNDU4L0Nsb3VkdmVpbC1TaGFkb3ctUGVhay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkhvcCBvbiB0aGUgbGlmdCBvciBoZWFkIHVwIHRoZSBza2luIHRyYWNrIHdpdGggdGhlIENsb3VkdmVpbCBNZW5zIFNoYWRvdyBQZWFrIEphY2tldCBhcyB5b3VyIGZvdWwtd2VhdGhlciBpbnN1cmFuY2UgcG9saWN5LiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ09MMTc0Mi9Ib3QtU2hvdC1TaGVsbC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJIb3QgU2hvdCBTaGVsbCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0NPTC9DT0wxNzQyL0JLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkhvdCBTaG90IFNoZWxsIC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ09MMTc0Mi9Ib3QtU2hvdC1TaGVsbC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJIb3QgU2hvdCBTaGVsbCAtIE1lbiZhcG9zO3MiPkNvbHVtYmlhIEhvdCBTaG90IFNoZWxsIC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkNvbHVtYmlhIGdhdmUgdGhlIE1lbnMgSG90IFNob3QgU2hlbGwgZnVsbHkgdGFwZWQgc2VhbXMgdG8gc2VhbCB0aGUgT21uaS1UZWNoIEVudGh1c2UgZmFicmljIGFuZCBrZWVwIHlvdSBmcm9tIGdldHRpbmcgc29ha2VkIGV2ZW4gaW4gbmFzdHkgd2VhdGhlci48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDE1OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDc5Ljk4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DT0wxNzQyL0hvdC1TaG90LVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkhvdCBTaG90IFNoZWxsIC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9Q09MMTc0MiZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9DT0wxNzQyL0NvbHVtYmlhLUhvdC1TaG90LVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJDb2x1bWJpYSBnYXZlIHRoZSBNZW5zIEhvdCBTaG90IFNoZWxsIGZ1bGx5IHRhcGVkIHNlYW1zIHRvIHNlYWwgdGhlIE9tbmktVGVjaCBFbnRodXNlIGZhYnJpYyBhbmQga2VlcCB5b3UgZnJvbSBnZXR0aW5nIHNvYWtlZCBldmVuIGluIG5hc3R5IHdlYXRoZXIuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DT0wxNzcxL1dheXBvaW50LUlJLVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IldheXBvaW50IElJIFNoZWxsIC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQ09ML0NPTDE3NzEvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iV2F5cG9pbnQgSUkgU2hlbGwgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DT0wxNzcxL1dheXBvaW50LUlJLVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IldheXBvaW50IElJIFNoZWxsIC0gTWVuJmFwb3M7cyI+Q29sdW1iaWEgV2F5cG9pbnQgSUkgU2hlbGwgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIENvbHVtYmlhIE1lbnMgV2F5cG9pbnQgSUkgU2hlbGwgcHJvdmlkZXMgZnVsbHkgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIHByb3RlY3Rpb24gZm9yIGFueSBkYXkgb2YgdGhlIHllYXIuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ5OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDc5Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DT0wxNzcxL1dheXBvaW50LUlJLVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IldheXBvaW50IElJIFNoZWxsIC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9Q09MMTc3MSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9DT0wxNzcxL0NvbHVtYmlhLVdheXBvaW50LUlJLVNoZWxsLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgQ29sdW1iaWEgTWVucyBXYXlwb2ludCBJSSBTaGVsbCBwcm92aWRlcyBmdWxseSB3YXRlcnByb29mIGJyZWF0aGFibGUgcHJvdGVjdGlvbiBmb3IgYW55IGRheSBvZiB0aGUgeWVhci4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0VJRDAwMTAvR2FzaGVyYnJ1bS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iR2FzaGVyYnJ1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9FSUQwMDEwLmpwZyIgYm9yZGVyPSIwIiBhbHQ9Ikdhc2hlcmJydW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfRUlEMDAxMC9HYXNoZXJicnVtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJHYXNoZXJicnVtIEphY2tldCAtIE1lbiZhcG9zO3MiPkVpZGVyIEdhc2hlcmJydW0gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkJ1aWx0IHRvIHdpdGhzdGFuZCB0aGUgZXh0cmVtZSBhbHBpbmUgY29uZGl0aW9ucyBvZiBpdHMgbmFtZXNha2UgcGVhaywgdGhlIEVpZGVyIE1lbnMgR2FzaGVyYnJ1bSBKYWNrZXQgZmVhdHVyZXMgM0wgR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYyBmb3IgdW5jb21wcm9taXNpbmcgcHJvdGVjdGlvbiBhbmQgYnJlYXRoYWJpbGl0eS48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDU5OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDQ0OS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfRUlEMDAxMC9HYXNoZXJicnVtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJHYXNoZXJicnVtIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUVJRDAwMTAmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvRUlEMDAxMC9FaWRlci1HYXNoZXJicnVtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iQnVpbHQgdG8gd2l0aHN0YW5kIHRoZSBleHRyZW1lIGFscGluZSBjb25kaXRpb25zIG9mIGl0cyBuYW1lc2FrZSBwZWFrLCB0aGUgRWlkZXIgTWVucyBHYXNoZXJicnVtIEphY2tldCBmZWF0dXJlcyAzTCBHb3JlLVRleCBQcm8gU2hlbGwgZmFicmljIGZvciB1bmNvbXByb21pc2luZyBwcm90ZWN0aW9uIGFuZCBicmVhdGhhYmlsaXR5LiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfR09MMDI5Mi9TcGVjdHJlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTcGVjdHJlIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0dPTC9HT0wwMjkyL0ZPRy5qcGciIGJvcmRlcj0iMCIgYWx0PSJTcGVjdHJlIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0dPTDAyOTIvU3BlY3RyZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3BlY3RyZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Hb0xpdGUgU3BlY3RyZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VG91cmluZyBjYW4gYmUgYSB0cmlja3kgYWN0aXZpdHkgdG8gcGxhbiBmb3IsIGJ1dCB0aGVyZXMgbm8gZG91YnQgdGhhdCB5b3UgbmVlZCBhIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBzaGVsbC4gVGhhdHMgd2hlcmUgdGhlIEdvTGl0ZSBNZW5zIFNwZWN0cmUgSmFja2V0IGNvbWVzIGluLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDI3NC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDEzNy40ODwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfR09MMDI5Mi9TcGVjdHJlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTcGVjdHJlIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUdPTDAyOTImaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvR09MMDI5Mi9Hb0xpdGUtU3BlY3RyZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRvdXJpbmcgY2FuIGJlIGEgdHJpY2t5IGFjdGl2aXR5IHRvIHBsYW4gZm9yLCBidXQgdGhlcmVzIG5vIGRvdWJ0IHRoYXQgeW91IG5lZWQgYSB3YXRlcnByb29mIGJyZWF0aGFibGUgc2hlbGwuIFRoYXRzIHdoZXJlIHRoZSBHb0xpdGUgTWVucyBTcGVjdHJlIEphY2tldCBjb21lcyBpbi4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9HUkQwMDM1L0dsaXNzYWRlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJHbGlzc2FkZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9HUkQvR1JEMDAzNS9SVVMuanBnIiBib3JkZXI9IjAiIGFsdD0iR2xpc3NhZGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfR1JEMDAzNS9HbGlzc2FkZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iR2xpc3NhZGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+R3JvdW5kIEdsaXNzYWRlIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5Gb3IgYmlnIGRheXMgaW4gdGhlIGJhY2tjb3VudHJ5IHdoZXJlIHNraWluZyBhbmQgY2xpbWJpbmcgYXJlIG9uIHRoZSBhZ2VuZGEsIHRoZSBHcm91bmQgTWVucyBHbGlzc2FkZSBKYWNrZXQgZ2l2ZXMgeW91IHRoZSBkdXJhYmxlIHdlYXRoZXIgcHJvdGVjdGlvbiB5b3UgbmVlZCB0byByZWFjaCB0aGUgc3VtbWl0IGFuZCBjdXQgdHVybnMgYWxsIHRoZSB3YXkgYmFjayBkb3duLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDI5OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDExOS45ODwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfR1JEMDAzNS9HbGlzc2FkZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iR2xpc3NhZGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9R1JEMDAzNSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9HUkQwMDM1L0dyb3VuZC1HbGlzc2FkZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkZvciBiaWcgZGF5cyBpbiB0aGUgYmFja2NvdW50cnkgd2hlcmUgc2tpaW5nIGFuZCBjbGltYmluZyBhcmUgb24gdGhlIGFnZW5kYSwgdGhlIEdyb3VuZCBNZW5zIEdsaXNzYWRlIEphY2tldCBnaXZlcyB5b3UgdGhlIGR1cmFibGUgd2VhdGhlciBwcm90ZWN0aW9uIHlvdSBuZWVkIHRvIHJlYWNoIHRoZSBzdW1taXQgYW5kIGN1dCB0dXJucyBhbGwgdGhlIHdheSBiYWNrIGRvd24uICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfSE9MMDE1Ni9BbnRvbi0zTC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQW50b24gM0wgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvSE9ML0hPTDAxNTYvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iQW50b24gM0wgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfSE9MMDE1Ni9BbnRvbi0zTC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQW50b24gM0wgSmFja2V0IC0gTWVuJmFwb3M7cyI+SG9sZGVuIEFudG9uIDNMIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5Mb29rIG5vIGZ1cnRoZXIgZm9yIHRoZSBtb3RoZXIgb2YgSG9sZGVuIEphY2tldCB0ZWNoLCB0aGUgSG9sZGVuIE1lbnMgQW50b24gM0wgSmFja2V0LiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDQ3OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDQzMS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfSE9MMDE1Ni9BbnRvbi0zTC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQW50b24gM0wgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9SE9MMDE1NiZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9IT0wwMTU2L0hvbGRlbi1BbnRvbi0zTC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9Ikxvb2sgbm8gZnVydGhlciBmb3IgdGhlIG1vdGhlciBvZiBIb2xkZW4gSmFja2V0IHRlY2gsIHRoZSBIb2xkZW4gTWVucyBBbnRvbiAzTCBKYWNrZXQuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfSFlIMDM0MC9PZGluLU1vdW50YWluLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJPZGluIE1vdW50YWluIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0hZSC9IWUgwMzQwL0VCLmpwZyIgYm9yZGVyPSIwIiBhbHQ9Ik9kaW4gTW91bnRhaW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfSFlIMDM0MC9PZGluLU1vdW50YWluLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJPZGluIE1vdW50YWluIEphY2tldCAtIE1lbiZhcG9zO3MiPkhlbGx5IEhhbnNlbiBPZGluIE1vdW50YWluIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5CcmluZyBmdWxsLXN0cmV0Y2gsIHdhdGVycHJvb2YsIHByZWNpc2lvbiBjb25zdHJ1Y3Rpb24gb24geW91ciBuZXh0IGdsb2JlLXNwYW5uaW5nIGV4cGVkaXRpb24gd2l0aCB0aGUgSGVsbHkgSGFuc2VuIE1lbiZhcG9zO3MgT2RpbiBNb3VudGFpbiBKYWNrZXQuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNDk5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzk5Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9IWUgwMzQwL09kaW4tTW91bnRhaW4tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik9kaW4gTW91bnRhaW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9SFlIMDM0MCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9IWUgwMzQwL0hlbGx5LUhhbnNlbi1PZGluLU1vdW50YWluLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iQnJpbmcgZnVsbC1zdHJldGNoLCB3YXRlcnByb29mLCBwcmVjaXNpb24gY29uc3RydWN0aW9uIG9uIHlvdXIgbmV4dCBnbG9iZS1zcGFubmluZyBleHBlZGl0aW9uIHdpdGggdGhlIEhlbGx5IEhhbnNlbiBNZW4mYXBvcztzIE9kaW4gTW91bnRhaW4gSmFja2V0LiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0hZSDAzNTIvVmVyZ2xhcy0zTC1YUC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVmVyZ2xhcyAzTCBYUCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9IWUgvSFlIMDM1Mi9CUklCTC5qcGciIGJvcmRlcj0iMCIgYWx0PSJWZXJnbGFzIDNMIFhQIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0hZSDAzNTIvVmVyZ2xhcy0zTC1YUC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVmVyZ2xhcyAzTCBYUCBKYWNrZXQgLSBNZW4mYXBvcztzIj5IZWxseSBIYW5zZW4gVmVyZ2xhcyAzTCBYUCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIEhlbGx5IEhhbnNlbiBNZW5zIFZlcmdsYXMgM0wgWFAgSmFja2V0IGxpdmVzIGZvciBpY3kgY291bG9pcnMsIGRlZXAgcG93ZGVyIGRheXMsIGFuZCBoYXJzaCBtb3VudGFpbiBjb25kaXRpb25zLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDM5OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDMxOS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfSFlIMDM1Mi9WZXJnbGFzLTNMLVhQLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJWZXJnbGFzIDNMIFhQIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUhZSDAzNTImaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvSFlIMDM1Mi9IZWxseS1IYW5zZW4tVmVyZ2xhcy0zTC1YUC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSBIZWxseSBIYW5zZW4gTWVucyBWZXJnbGFzIDNMIFhQIEphY2tldCBsaXZlcyBmb3IgaWN5IGNvdWxvaXJzLCBkZWVwIHBvd2RlciBkYXlzLCBhbmQgaGFyc2ggbW91bnRhaW4gY29uZGl0aW9ucy4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9JRE0wMDAxLzNMLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSIzTCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9JRE0vSURNMDAwMS9CUklXSC5qcGciIGJvcmRlcj0iMCIgYWx0PSIzTCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9JRE0wMDAxLzNMLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSIzTCBKYWNrZXQgLSBNZW4mYXBvcztzIj5JZGlvbSAzTCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+RnVsbHkgdGFwZWQgc2VhbXMsIHRocmVlLWxheWVyIGNvbnN0cnVjdGlvbiwgd2F0ZXJwcm9vZiB6aXBwZXJzLCBhbmQgY2xlYW4gbGluZXMgc2V0IHRoZSBJZGlvbSBNZW5zIDNMIEphY2tldCBhcGFydCBmcm9tIGV2ZXJ5dGhpbmcgZWxzZSBvbiB0aGUgbW91bnRhaW4uPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ1OTkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQyMzkuOTg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0lETTAwMDEvM0wtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IjNMIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PUlETTAwMDEmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvSURNMDAwMS9JZGlvbS0zTC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkZ1bGx5IHRhcGVkIHNlYW1zLCB0aHJlZS1sYXllciBjb25zdHJ1Y3Rpb24sIHdhdGVycHJvb2YgemlwcGVycywgYW5kIGNsZWFuIGxpbmVzIHNldCB0aGUgSWRpb20gTWVucyAzTCBKYWNrZXQgYXBhcnQgZnJvbSBldmVyeXRoaW5nIGVsc2Ugb24gdGhlIG1vdW50YWluLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfS0FWMDE5OC9GcmVlLTItQmUtVFNoaXJ0LS1TaG9ydFNsZWV2ZS0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJGcmVlIDIgQmUgVC1TaGlydCAtIFNob3J0LVNsZWV2ZSAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0tBVi9LQVYwMTk4L0NBUi5qcGciIGJvcmRlcj0iMCIgYWx0PSJGcmVlIDIgQmUgVC1TaGlydCAtIFNob3J0LVNsZWV2ZSAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0tBVjAxOTgvRnJlZS0yLUJlLVRTaGlydC0tU2hvcnRTbGVldmUtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iRnJlZSAyIEJlIFQtU2hpcnQgLSBTaG9ydC1TbGVldmUgLSBNZW4mYXBvcztzIj5LYXZ1IEZyZWUgMiBCZSBULVNoaXJ0IC0gU2hvcnQtU2xlZXZlIC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkV4ZXJjaXNlIGFsbCB5b3VyIGZyZWVkb21zIHdoZW4geW91IHB1bGwgb24gdGhlIEtBVlUgTWVucyBGcmVlIDIgQmUgVC1TaGlydC4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQyNS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDIwLjc2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9LQVYwMTk4L0ZyZWUtMi1CZS1UU2hpcnQtLVNob3J0U2xlZXZlLS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkZyZWUgMiBCZSBULVNoaXJ0IC0gU2hvcnQtU2xlZXZlIC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9S0FWMDE5OCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9LQVYwMTk4L0thdnUtRnJlZS0yLUJlLVRTaGlydC0tU2hvcnRTbGVldmUtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkV4ZXJjaXNlIGFsbCB5b3VyIGZyZWVkb21zIHdoZW4geW91IHB1bGwgb24gdGhlIEtBVlUgTWVucyBGcmVlIDIgQmUgVC1TaGlydC4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQU0wMTEyL0FsdmVyc3RvbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFsdmVyc3RvbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUFNL01BTTAxMTIvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iQWx2ZXJzdG9uZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQU0wMTEyL0FsdmVyc3RvbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFsdmVyc3RvbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TWFtbXV0IEFsdmVyc3RvbmUgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRydXN0IHRoZSBNYW1tdXQgTWVucyBBbHZlcnN0b25lIHRvIGtlZXAgeW91IGRyeSBhbmQgY29tZm9ydGFibGUgd2hlbiB5b3VyZSBvdXQgaW4gdGhlIG1vdW50YWlucy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQxOTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxMTkuMzc8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BTTAxMTIvQWx2ZXJzdG9uZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWx2ZXJzdG9uZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NQU0wMTEyJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01BTTAxMTIvTWFtbXV0LUFsdmVyc3RvbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUcnVzdCB0aGUgTWFtbXV0IE1lbnMgQWx2ZXJzdG9uZSB0byBrZWVwIHlvdSBkcnkgYW5kIGNvbWZvcnRhYmxlIHdoZW4geW91cmUgb3V0IGluIHRoZSBtb3VudGFpbnMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTIyMS9BbHBpbmlzdC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWxwaW5pc3QgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUFSL01BUjEyMjEvQktGSS5qcGciIGJvcmRlcj0iMCIgYWx0PSJBbHBpbmlzdCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxMjIxL0FscGluaXN0LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbHBpbmlzdCBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgQWxwaW5pc3QgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPllvdSByZWFsbHkgcHV0IHlvdXIgZXF1aXBtZW50IGFuZCBjbG90aGVzIHRvIHRoZSB0ZXN0IG9uIG1vdW50YWluZWVyaW5nLCByb2NrIGNsaW1iaW5nLCBhbmQgYmFja3BhY2tpbmcgdHJla3MsIHdoaWNoIGlzIHdoeSB0aGUgTWFybW90IE1lbnMgQWxwaW5pc3QgSmFja2V0IGlzIHJpZ2h0IHVwIHlvdXIgc25vdy1maWxsZWQsIGhpZ2gtYWx0aXR1ZGUgYWxsZXkuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNDc0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjM3LjQ4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxMjIxL0FscGluaXN0LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbHBpbmlzdCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NQVIxMjIxJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01BUjEyMjEvTWFybW90LUFscGluaXN0LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iWW91IHJlYWxseSBwdXQgeW91ciBlcXVpcG1lbnQgYW5kIGNsb3RoZXMgdG8gdGhlIHRlc3Qgb24gbW91bnRhaW5lZXJpbmcsIHJvY2sgY2xpbWJpbmcsIGFuZCBiYWNrcGFja2luZyB0cmVrcywgd2hpY2ggaXMgd2h5IHRoZSBNYXJtb3QgTWVucyBBbHBpbmlzdCBKYWNrZXQgaXMgcmlnaHQgdXAgeW91ciBzbm93LWZpbGxlZCwgaGlnaC1hbHRpdHVkZSBhbGxleS4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxMjI3L1RvcnJlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUb3JyZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTIyNy9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJUb3JyZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxMjI3L1RvcnJlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUb3JyZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgVG9ycmUgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkluc3BpcmVkIGJ5IHRoZSBmaWVyY2UgYW5kIHVucHJlZGljdGFibGUgc3Rvcm1zIG9mIFBhdGFnb25pYSZhcG9zO3MgZm9yZWJvZGluZyBwZWFrcywgdGhlIE1hcm1vdCBNZW5zIFRvcnJlIEphY2tldCBwcm92aWRlcyBjb21wbGV0ZSB3YXRlcnByb29mIGFuZCBicmVhdGhhYmxlIHByb3RlY3Rpb24gdGhhbmtzIHRvIGR1cmFibGUgR29yZS1UZXggUGVyZm9ybWFuY2UgU2hlbGwgZmFicmljLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDQyNC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDMzOS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTIyNy9Ub3JyZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVG9ycmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUFSMTIyNyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NQVIxMjI3L01hcm1vdC1Ub3JyZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9Ikluc3BpcmVkIGJ5IHRoZSBmaWVyY2UgYW5kIHVucHJlZGljdGFibGUgc3Rvcm1zIG9mIFBhdGFnb25pYSZhcG9zO3MgZm9yZWJvZGluZyBwZWFrcywgdGhlIE1hcm1vdCBNZW5zIFRvcnJlIEphY2tldCBwcm92aWRlcyBjb21wbGV0ZSB3YXRlcnByb29mIGFuZCBicmVhdGhhYmxlIHByb3RlY3Rpb24gdGhhbmtzIHRvIGR1cmFibGUgR29yZS1UZXggUGVyZm9ybWFuY2UgU2hlbGwgZmFicmljLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjEyMjkvUGFsbGlzYWRlcy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iUGFsbGlzYWRlcyBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTIyOS9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJQYWxsaXNhZGVzIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjEyMjkvUGFsbGlzYWRlcy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iUGFsbGlzYWRlcyBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgUGFsbGlzYWRlcyBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIE1hcm1vdCBNZW5zIFBhbGxpc2FkZXMgSmFja2V0IGluY2x1ZGVzIGEgcmVtb3ZhYmxlIGhlbG1ldCBhbmQgcmVtb3ZhYmxlIHBvd2RlciBza2lydCB0byBwcm92aWRlIHlvdSB0aGUgdmVyc2F0aWxpdHkgZm9yIGFueXRoaW5nIGZyb20gbW91bnRhaW5lZXJpbmcgdG8gYmFja2NvdW50cnkgc2tpaW5nLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMjg0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjI3Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxMjI5L1BhbGxpc2FkZXMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlBhbGxpc2FkZXMgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUFSMTIyOSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NQVIxMjI5L01hcm1vdC1QYWxsaXNhZGVzLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIE1hcm1vdCBNZW5zIFBhbGxpc2FkZXMgSmFja2V0IGluY2x1ZGVzIGEgcmVtb3ZhYmxlIGhlbG1ldCBhbmQgcmVtb3ZhYmxlIHBvd2RlciBza2lydCB0byBwcm92aWRlIHlvdSB0aGUgdmVyc2F0aWxpdHkgZm9yIGFueXRoaW5nIGZyb20gbW91bnRhaW5lZXJpbmcgdG8gYmFja2NvdW50cnkgc2tpaW5nLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTIzMC9SZWQtQmFua3MtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlJlZCBCYW5rcyBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTIzMC9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJSZWQgQmFua3MgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTIzMC9SZWQtQmFua3MtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlJlZCBCYW5rcyBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgUmVkIEJhbmtzIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5MYW5kZmlsbHMgYXJlIG5vdCByYWQsIGFuZCBuZWl0aGVyIGlzIGdldHRpbmcgd2V0IGFuZCB1bmNvbWZvcnRhYmxlIGluIHRoZSBiYWNrY291bnRyeS4gTWFybW90IHRhY2tsZWQgYm90aCBpc3N1ZXMgYW5kIG1hZGUgdGhlIE1lbnMgUmVkIEJhbmtzIEphY2tldCB3aXRoIHJlY3ljbGVkLCB3YXRlcnByb29mIGJyZWF0aGFibGUgVXBDeWNsZSBmYWJyaWMuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMjI0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kODkuOTg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjEyMzAvUmVkLUJhbmtzLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJSZWQgQmFua3MgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUFSMTIzMCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NQVIxMjMwL01hcm1vdC1SZWQtQmFua3MtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJMYW5kZmlsbHMgYXJlIG5vdCByYWQsIGFuZCBuZWl0aGVyIGlzIGdldHRpbmcgd2V0IGFuZCB1bmNvbWZvcnRhYmxlIGluIHRoZSBiYWNrY291bnRyeS4gTWFybW90IHRhY2tsZWQgYm90aCBpc3N1ZXMgYW5kIG1hZGUgdGhlIE1lbnMgUmVkIEJhbmtzIEphY2tldCB3aXRoIHJlY3ljbGVkLCB3YXRlcnByb29mIGJyZWF0aGFibGUgVXBDeWNsZSBmYWJyaWMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTQyMS9PcmFjbGUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik9yYWNsZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTQyMS9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJPcmFjbGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTQyMS9PcmFjbGUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik9yYWNsZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgT3JhY2xlIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgTWFybW90IE1lbnMgT3JhY2xlIEphY2tldCBjYW50IHByZWRpY3QgdGhlIHN0b3JteSBmdXR1cmUsIGJ1dCBpdHMgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIFByZUNpcCBQbHVzIHNoZWxsIGZhYnJpYyBjYW4gY2VydGFpbmx5IHByb3RlY3QgeW91IGZyb20gaXQuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMTY0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTE0Ljk5PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNDIxL09yYWNsZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iT3JhY2xlIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU1BUjE0MjEmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTUFSMTQyMS9NYXJtb3QtT3JhY2xlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIE1hcm1vdCBNZW5zIE9yYWNsZSBKYWNrZXQgY2FudCBwcmVkaWN0IHRoZSBzdG9ybXkgZnV0dXJlLCBidXQgaXRzIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBQcmVDaXAgUGx1cyBzaGVsbCBmYWJyaWMgY2FuIGNlcnRhaW5seSBwcm90ZWN0IHlvdSBmcm9tIGl0LiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjE0MjQvVHJvbGwtV2FsbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVHJvbGwgV2FsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTQyNC9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJUcm9sbCBXYWxsIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjE0MjQvVHJvbGwtV2FsbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVHJvbGwgV2FsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgVHJvbGwgV2FsbCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIE1hcm1vdCBNZW5zIFRyb2xsIFdhbGwgSmFja2V0IGhvbGRzIG9mZiBidXJseSBtb3VudGFpbiB3ZWF0aGVyIHdpdGggd2F0ZXJwcm9vZiBicmVhdGhhYmxlIEdvcmUtVGV4IFBybyBmYWJyaWMgdG8gaGVscCB5b3Ugc3RheSBkcnkgYW5kIGNvbWZvcnRhYmxlLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNDQ5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzU5Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNDI0L1Ryb2xsLVdhbGwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRyb2xsIFdhbGwgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUFSMTQyNCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NQVIxNDI0L01hcm1vdC1Ucm9sbC1XYWxsLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIE1hcm1vdCBNZW5zIFRyb2xsIFdhbGwgSmFja2V0IGhvbGRzIG9mZiBidXJseSBtb3VudGFpbiB3ZWF0aGVyIHdpdGggd2F0ZXJwcm9vZiBicmVhdGhhYmxlIEdvcmUtVGV4IFBybyBmYWJyaWMgdG8gaGVscCB5b3Ugc3RheSBkcnkgYW5kIGNvbWZvcnRhYmxlLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTUxMC9TcGlyZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3BpcmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUFSL01BUjE1MTAvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iU3BpcmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUFSMTUxMC9TcGlyZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3BpcmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TWFybW90IFNwaXJlIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgTWFybW90IE1lbnMgU3BpcmUgSmFja2V0IGlzIGEgcXVpdmVyLW9mLW9uZSBqYWNrZXQgZm9yIGFueSBpbmNsZW1lbnQtd2VhdGhlciBhY3Rpdml0eS4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNzQuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzMzcuNDY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjE1MTAvU3BpcmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlNwaXJlIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU1BUjE1MTAmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTUFSMTUxMC9NYXJtb3QtU3BpcmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgTWFybW90IE1lbnMgU3BpcmUgSmFja2V0IGlzIGEgcXVpdmVyLW9mLW9uZSBqYWNrZXQgZm9yIGFueSBpbmNsZW1lbnQtd2VhdGhlciBhY3Rpdml0eS4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTEzL1RhbWFyYWNrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUYW1hcmFjayBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTUxMy9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJUYW1hcmFjayBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTEzL1RhbWFyYWNrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUYW1hcmFjayBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgVGFtYXJhY2sgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPk1hcm1vdCBpbnRyaWNhdGVseSBjcmFmdGVkIHRoZSBNZW5zIFRhbWFyYWNrIEphY2tldCB3aXRoIGV4Y2VsbGVudCB3YXRlcnByb29maW5nLCBmdWxseSB0YXBlZCBzZWFtcywgbGFzZXItY3V0IHdhdGVyLXJlc2lzdGFudCB6aXBwZXJzLCBhIHBvd2RlciBza2lydCwgYW5kIGFydGljdWxhdGVkIGFybXMgdG8gYW5zd2VyIHRoZSBjYWxsIG9mIHNraSBkdXR5LjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMjI0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTc5Ljk5PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTEzL1RhbWFyYWNrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUYW1hcmFjayBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NQVIxNTEzJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01BUjE1MTMvTWFybW90LVRhbWFyYWNrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iTWFybW90IGludHJpY2F0ZWx5IGNyYWZ0ZWQgdGhlIE1lbnMgVGFtYXJhY2sgSmFja2V0IHdpdGggZXhjZWxsZW50IHdhdGVycHJvb2ZpbmcsIGZ1bGx5IHRhcGVkIHNlYW1zLCBsYXNlci1jdXQgd2F0ZXItcmVzaXN0YW50IHppcHBlcnMsIGEgcG93ZGVyIHNraXJ0LCBhbmQgYXJ0aWN1bGF0ZWQgYXJtcyB0byBhbnN3ZXIgdGhlIGNhbGwgb2Ygc2tpIGR1dHkuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTE0L1N0b3JtLUZyb250LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdG9ybSBGcm9udCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMTUxNC9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJTdG9ybSBGcm9udCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTE0L1N0b3JtLUZyb250LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdG9ybSBGcm9udCBKYWNrZXQgLSBNZW4mYXBvcztzIj5NYXJtb3QgU3Rvcm0gRnJvbnQgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZXJlcyBubyBuZWVkIGZvciBhIGNsb3NldCBmdWxsIG9mIGphY2tldHN0aGUgTWFybW90IE1lbnMgU3Rvcm0gRnJvbnQgSmFja2V0IGlzIGEgcXVpdmVyLW9mLW9uZSBzaGVsbCBmb3IgZXZlcnl0aGluZyBmcm9tIHNraSB0b3VyaW5nIHRvIHN1bW1lciBiYWNrcGFja2luZy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTg5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTE0L1N0b3JtLUZyb250LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdG9ybSBGcm9udCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NQVIxNTE0JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01BUjE1MTQvTWFybW90LVN0b3JtLUZyb250LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlcmVzIG5vIG5lZWQgZm9yIGEgY2xvc2V0IGZ1bGwgb2YgamFja2V0c3RoZSBNYXJtb3QgTWVucyBTdG9ybSBGcm9udCBKYWNrZXQgaXMgYSBxdWl2ZXItb2Ytb25lIHNoZWxsIGZvciBldmVyeXRoaW5nIGZyb20gc2tpIHRvdXJpbmcgdG8gc3VtbWVyIGJhY2twYWNraW5nLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjE1NjcvTWFpbmxpbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik1haW5saW5lIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL01BUi9NQVIxNTY3L0JLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9Ik1haW5saW5lIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjE1NjcvTWFpbmxpbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik1haW5saW5lIEphY2tldCAtIE1lbiZhcG9zO3MiPk1hcm1vdCBNYWlubGluZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+WW91dmUgc2NvdXRlZCB5b3VyIHJvdXRlLCBhbmQgbm93IGl0cyB0aW1lIHRvIGRyb3AgaW53aXRoIHRoZSBNYXJtb3QgTWVucyBNYWlubGluZSBKYWNrZXQsIHlvdSBjYW4gZm9yZ2V0IGFib3V0IHNub3cgYW5kIHdlYXRoZXIgYW5kIGZvY3VzIG9uIHRoZSBzdGVlcCB0dXJucyBiZWxvdyB5b3UuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzQ5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzE0Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIxNTY3L01haW5saW5lLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNYWlubGluZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NQVIxNTY3JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01BUjE1NjcvTWFybW90LU1haW5saW5lLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iWW91dmUgc2NvdXRlZCB5b3VyIHJvdXRlLCBhbmQgbm93IGl0cyB0aW1lIHRvIGRyb3AgaW53aXRoIHRoZSBNYXJtb3QgTWVucyBNYWlubGluZSBKYWNrZXQsIHlvdSBjYW4gZm9yZ2V0IGFib3V0IHNub3cgYW5kIHdlYXRoZXIgYW5kIGZvY3VzIG9uIHRoZSBzdGVlcCB0dXJucyBiZWxvdyB5b3UuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDkwOS9UZXJyYS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGVycmEgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUhXL01IVzA5MDkvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iVGVycmEgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDkwOS9UZXJyYS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGVycmEgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW91bnRhaW4gSGFyZHdlYXIgVGVycmEgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSB1bHRyYWxpZ2h0LCBzdXBlci1mdW5jdGlvbmFsIE1vdW50YWluIEhhcmR3ZWFyIE1lbnMgVGVycmEgSmFja2V0IGhhcyBiZWNvbWUgYSB0b3AgcGljayBmb3Igd29ybGQgcmVub3duZWQgYWxwaW5pc3RzIGxpa2UgS2V2aW4gTWFob25leSBmb3IgYSBnb29kIHJlYXNvbi48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDM0OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDE5Mi40NzwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDkwOS9UZXJyYS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGVycmEgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUhXMDkwOSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NSFcwOTA5L01vdW50YWluLUhhcmR3ZWFyLVRlcnJhLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIHVsdHJhbGlnaHQsIHN1cGVyLWZ1bmN0aW9uYWwgTW91bnRhaW4gSGFyZHdlYXIgTWVucyBUZXJyYSBKYWNrZXQgaGFzIGJlY29tZSBhIHRvcCBwaWNrIGZvciB3b3JsZCByZW5vd25lZCBhbHBpbmlzdHMgbGlrZSBLZXZpbiBNYWhvbmV5IGZvciBhIGdvb2QgcmVhc29uLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDk1MC9WZXJ0aWNhbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVmVydGljYWwgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUhXL01IVzA5NTAvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iVmVydGljYWwgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDk1MC9WZXJ0aWNhbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVmVydGljYWwgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW91bnRhaW4gSGFyZHdlYXIgVmVydGljYWwgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPllvdXIgaW50ZXJuZXQgaG9tZSBwYWdlIGlzIHRoZSBhdmFsYW5jaGUgcmVwb3J0IGFuZCB5b3UgZHJlYW0gYWJvdXQgZGVlcCBwb3dkZXIgYWxsIHllYXIgbG9uZy4gV2VyZSBwcmV0dHkgc3VyZSB0aGUgTW91bnRhaW4gSGFyZHdlYXIgTWVucyBWZXJ0aWNhbCBKYWNrZXQgaXMgZm9yIHlvdS4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0OTQuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzOTUuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01IVzA5NTAvVmVydGljYWwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlZlcnRpY2FsIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU1IVzA5NTAmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTUhXMDk1MC9Nb3VudGFpbi1IYXJkd2Vhci1WZXJ0aWNhbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IllvdXIgaW50ZXJuZXQgaG9tZSBwYWdlIGlzIHRoZSBhdmFsYW5jaGUgcmVwb3J0IGFuZCB5b3UgZHJlYW0gYWJvdXQgZGVlcCBwb3dkZXIgYWxsIHllYXIgbG9uZy4gV2VyZSBwcmV0dHkgc3VyZSB0aGUgTW91bnRhaW4gSGFyZHdlYXIgTWVucyBWZXJ0aWNhbCBKYWNrZXQgaXMgZm9yIHlvdS4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSFcxMTc2L0NvaGVzaW9uLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJDb2hlc2lvbiBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NSFcvTUhXMTE3Ni9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJDb2hlc2lvbiBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSFcxMTc2L0NvaGVzaW9uLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJDb2hlc2lvbiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3VudGFpbiBIYXJkd2VhciBDb2hlc2lvbiBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIE1vdW50YWluIEhhcmR3ZWFyIE1lbnMgQ29oZXNpb24gSmFja2V0IGZhbGxzIGluIHVuZGVyIHRoZSBvbmUtcG91bmQgbWFyayBhbmQgcHJvdmlkZXMgdGhlIHdlYXRoZXIgcHJvdGVjdGlvbiB5b3UgbmVlZCBmb3IgYWxwaW5lIGFzc2F1bHRzLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMTc0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTM5Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSFcxMTc2L0NvaGVzaW9uLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJDb2hlc2lvbiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NSFcxMTc2JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01IVzExNzYvTW91bnRhaW4tSGFyZHdlYXItQ29oZXNpb24tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgTW91bnRhaW4gSGFyZHdlYXIgTWVucyBDb2hlc2lvbiBKYWNrZXQgZmFsbHMgaW4gdW5kZXIgdGhlIG9uZS1wb3VuZCBtYXJrIGFuZCBwcm92aWRlcyB0aGUgd2VhdGhlciBwcm90ZWN0aW9uIHlvdSBuZWVkIGZvciBhbHBpbmUgYXNzYXVsdHMuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSFcxMzE3L0FtYWxnYW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFtYWxnYW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUhXL01IVzEzMTcvR1JJLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkFtYWxnYW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMTMxNy9BbWFsZ2FtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbWFsZ2FtIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vdW50YWluIEhhcmR3ZWFyIEFtYWxnYW0gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoYW5rcyB0byBhIEdvcmUtVGV4IFBlcmZvcm1hbmNlIFNoZWxsIGxhbWluYXRlIHRoZSBNb3VudGFpbiBIYXJkd2VhciBNZW5zIEFtYWxnYW0gSmFja2V0IHN0YW5kcyB1cCB0byBldmVyeXRoaW5nIGZyb20gUGFjaWZpYyBOb3J0aHdlc3Qgc3F1YWxscyB0byBFYXN0IENvYXN0IGRvd25wb3Vycy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDMyNC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDI1OS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMTMxNy9BbWFsZ2FtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbWFsZ2FtIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU1IVzEzMTcmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTUhXMTMxNy9Nb3VudGFpbi1IYXJkd2Vhci1BbWFsZ2FtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhhbmtzIHRvIGEgR29yZS1UZXggUGVyZm9ybWFuY2UgU2hlbGwgbGFtaW5hdGUgdGhlIE1vdW50YWluIEhhcmR3ZWFyIE1lbnMgQW1hbGdhbSBKYWNrZXQgc3RhbmRzIHVwIHRvIGV2ZXJ5dGhpbmcgZnJvbSBQYWNpZmljIE5vcnRod2VzdCBzcXVhbGxzIHRvIEVhc3QgQ29hc3QgZG93bnBvdXJzLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMTM1Mi9CZXJ5bGxpdW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJlcnlsbGl1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NSFcvTUhXMTM1Mi9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJCZXJ5bGxpdW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMTM1Mi9CZXJ5bGxpdW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJlcnlsbGl1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3VudGFpbiBIYXJkd2VhciBCZXJ5bGxpdW0gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkZvciBzZXJpb3VzIG1vdW50YWluIGV4cGVkaXRpb25zIHdoZXJlIGVwaWMgY29uZGl0aW9ucyBhcmUgYWxsIGJ1dCBndWFyYW50ZWVkLCB0aGUgTW91bnRhaW4gSGFyZHdlYXIgTWVucyBCZXJ5bGxpdW0gSmFja2V0IGZlYXR1cmVzIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBHb3JlLVRleCBQcm8gU2hlbGwgZmFicmljIGZvciBjb21wbGV0ZSBhbmQgdXR0ZXIgcHJvdGVjdGlvbiBmcm9tIHRoZSBlbGVtZW50cy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0NzQuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzNzkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01IVzEzNTIvQmVyeWxsaXVtLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJCZXJ5bGxpdW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUhXMTM1MiZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NSFcxMzUyL01vdW50YWluLUhhcmR3ZWFyLUJlcnlsbGl1bS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkZvciBzZXJpb3VzIG1vdW50YWluIGV4cGVkaXRpb25zIHdoZXJlIGVwaWMgY29uZGl0aW9ucyBhcmUgYWxsIGJ1dCBndWFyYW50ZWVkLCB0aGUgTW91bnRhaW4gSGFyZHdlYXIgTWVucyBCZXJ5bGxpdW0gSmFja2V0IGZlYXR1cmVzIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBHb3JlLVRleCBQcm8gU2hlbGwgZmFicmljIGZvciBjb21wbGV0ZSBhbmQgdXR0ZXIgcHJvdGVjdGlvbiBmcm9tIHRoZSBlbGVtZW50cy4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSFcxMzUzL0Nhcm5pYy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQ2FybmljIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL01IVy9NSFcxMzUzL0dSQS5qcGciIGJvcmRlcj0iMCIgYWx0PSJDYXJuaWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMTM1My9DYXJuaWMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkNhcm5pYyBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3VudGFpbiBIYXJkd2VhciBDYXJuaWMgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoYW5rcyB0byBpdHMgdWx0cmFsaWdodCB0aHJlZS1sYXllciBUZXJyYSBTaGVsbCBmYWJyaWMgYW5kIHdlbGRlZCBzZWFtcywgdGhlIE1vdW50YWluIEhhcmR3ZWFyIE1lbnMgQ2FybmljIEphY2tldCBzZWFscyBvdXQgaGFyc2ggd2VhdGhlciBjb25kaXRpb25zIHdpdGhvdXQgd2VpZ2hpbmcgeW91IGRvd24gb24gbGlnaHQtYW5kLWZhc3QgYWxwaW5lIGNsaW1icy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNDkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQyNzkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01IVzEzNTMvQ2FybmljLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJDYXJuaWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUhXMTM1MyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NSFcxMzUzL01vdW50YWluLUhhcmR3ZWFyLUNhcm5pYy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoYW5rcyB0byBpdHMgdWx0cmFsaWdodCB0aHJlZS1sYXllciBUZXJyYSBTaGVsbCBmYWJyaWMgYW5kIHdlbGRlZCBzZWFtcywgdGhlIE1vdW50YWluIEhhcmR3ZWFyIE1lbnMgQ2FybmljIEphY2tldCBzZWFscyBvdXQgaGFyc2ggd2VhdGhlciBjb25kaXRpb25zIHdpdGhvdXQgd2VpZ2hpbmcgeW91IGRvd24gb24gbGlnaHQtYW5kLWZhc3QgYWxwaW5lIGNsaW1icy4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSUwwMDAxL09yaWdpbi1Qcm8tR29yZVRleC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iT3JpZ2luIFBybyBHb3JlLVRleCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NSUwvTUlMMDAwMS9CTEFNRVQuanBnIiBib3JkZXI9IjAiIGFsdD0iT3JpZ2luIFBybyBHb3JlLVRleCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSUwwMDAxL09yaWdpbi1Qcm8tR29yZVRleC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iT3JpZ2luIFBybyBHb3JlLVRleCBKYWNrZXQgLSBNZW4mYXBvcztzIj5NaWxsZXQgT3JpZ2luIFBybyBHb3JlLVRleCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIE1pbGxldCBNZW5zIE9yaWdpbiBQcm8gR1RYIEphY2tldCBnaXZlcyB5b3UgYm9tYnByb29mIHdlYXRoZXIgcHJvdGVjdGlvbiB3aXRoIGZ1bGwgZnJlZWRvbSBvZiBtb3ZlbWVudCB0aGFua3MgdG8gR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYyBhbmQgTWlsbGV0cyBFcmdvbm9taWMgRmxleCBDb21mb3J0IGNvbnN0cnVjdGlvbi4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ1MDkuODU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ0MDcuODg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01JTDAwMDEvT3JpZ2luLVByby1Hb3JlVGV4LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJPcmlnaW4gUHJvIEdvcmUtVGV4IEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU1JTDAwMDEmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTUlMMDAwMS9NaWxsZXQtT3JpZ2luLVByby1Hb3JlVGV4LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIE1pbGxldCBNZW5zIE9yaWdpbiBQcm8gR1RYIEphY2tldCBnaXZlcyB5b3UgYm9tYnByb29mIHdlYXRoZXIgcHJvdGVjdGlvbiB3aXRoIGZ1bGwgZnJlZWRvbSBvZiBtb3ZlbWVudCB0aGFua3MgdG8gR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYyBhbmQgTWlsbGV0cyBFcmdvbm9taWMgRmxleCBDb21mb3J0IGNvbnN0cnVjdGlvbi4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSUwwMDA0L0FlcmlhbC1NYXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFlcmlhbCBNYXggSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUlML01JTDAwMDQvR1JFQ0IuanBnIiBib3JkZXI9IjAiIGFsdD0iQWVyaWFsIE1heCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSUwwMDA0L0FlcmlhbC1NYXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFlcmlhbCBNYXggSmFja2V0IC0gTWVuJmFwb3M7cyI+TWlsbGV0IEFlcmlhbCBNYXggSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkN1dCB5b3VyIHBhY2sgd2VpZ2h0IHdoaWxlIHN0YXlpbmcgcHJvdGVjdGVkIG9uIGxpZ2h0LWFuZC1mYXN0IGFscGluZSBjbGltYnMgd2hlbiB5b3UgemlwIHVwIHRoZSBNaWxsZXQgTWVucyBBZXJpYWwgTWF4IEphY2tldC4gVGhhbmtzIHRvIGR1cmFibHkgd2F0ZXJwcm9vZiBhbmQgYnJlYXRoYWJsZSBHb3JlLVRleCBQYWNsaXRlIGZhYnJpYywgeW91IHN0YXkgZHJ5IGFuZCBjb21mb3J0YWJsZSB3aXRob3V0IHRoZSBhZGRlZCBidWxrIG9mIGhlYXZpZXIgc2hlbGwgamFja2V0cy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNDkuODU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxNzQuOTM8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01JTDAwMDQvQWVyaWFsLU1heC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWVyaWFsIE1heCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NSUwwMDA0JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01JTDAwMDQvTWlsbGV0LUFlcmlhbC1NYXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJDdXQgeW91ciBwYWNrIHdlaWdodCB3aGlsZSBzdGF5aW5nIHByb3RlY3RlZCBvbiBsaWdodC1hbmQtZmFzdCBhbHBpbmUgY2xpbWJzIHdoZW4geW91IHppcCB1cCB0aGUgTWlsbGV0IE1lbnMgQWVyaWFsIE1heCBKYWNrZXQuIFRoYW5rcyB0byBkdXJhYmx5IHdhdGVycHJvb2YgYW5kIGJyZWF0aGFibGUgR29yZS1UZXggUGFjbGl0ZSBmYWJyaWMsIHlvdSBzdGF5IGRyeSBhbmQgY29tZm9ydGFibGUgd2l0aG91dCB0aGUgYWRkZWQgYnVsayBvZiBoZWF2aWVyIHNoZWxsIGphY2tldHMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUlMMDEyNC9SYWRpa2FsLUdvcmVUZXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlJhZGlrYWwgR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUlML01JTDAxMjQvQlJJQkxVLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlJhZGlrYWwgR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUlMMDEyNC9SYWRpa2FsLUdvcmVUZXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlJhZGlrYWwgR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7cyI+TWlsbGV0IFJhZGlrYWwgR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlB1cmUsIGFscGluZSBwcm90ZWN0aW9uIGlzIHRoZSBuYW1lIG9mIHRoZSBnYW1lIHdpdGggdGhlIE1pbGxldCBNZW5zIFJhZGlrYWwgR29yZS1UZXggSmFja2V0LiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDU1NC44NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDM4OC40MDwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUlMMDEyNC9SYWRpa2FsLUdvcmVUZXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlJhZGlrYWwgR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUlMMDEyNCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NSUwwMTI0L01pbGxldC1SYWRpa2FsLUdvcmVUZXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJQdXJlLCBhbHBpbmUgcHJvdGVjdGlvbiBpcyB0aGUgbmFtZSBvZiB0aGUgZ2FtZSB3aXRoIHRoZSBNaWxsZXQgTWVucyBSYWRpa2FsIEdvcmUtVGV4IEphY2tldC4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSUwwMTI3L0FlcmlhbC1NYXgtRVZPLUdvcmVUZXgtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkFlcmlhbCBNYXggRVZPIEdvcmUtVGV4IEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL01JTC9NSUwwMTI3L0NCLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkFlcmlhbCBNYXggRVZPIEdvcmUtVGV4IEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01JTDAxMjcvQWVyaWFsLU1heC1FVk8tR29yZVRleC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWVyaWFsIE1heCBFVk8gR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7cyI+TWlsbGV0IEFlcmlhbCBNYXggRVZPIEdvcmUtVGV4IEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5XaGVuIHlvdSBhcmVudCB3aWxsaW5nIHRvIHNhY3JpZmljZSBwcm90ZWN0aW9uIG9yIGxpZ2h0IHdlaWdodCBpbiB0aGUgYWxwaW5lLCBicmluZyBhbG9uZyB0aGUgTWlsbGV0IE1lbnMgQWVyaWFsIE1heCBHb3JlLVRleCBKYWNrZXQuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNzQuODU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQyNjIuNDA8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01JTDAxMjcvQWVyaWFsLU1heC1FVk8tR29yZVRleC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWVyaWFsIE1heCBFVk8gR29yZS1UZXggSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TUlMMDEyNyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NSUwwMTI3L01pbGxldC1BZXJpYWwtTWF4LUVWTy1Hb3JlVGV4LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iV2hlbiB5b3UgYXJlbnQgd2lsbGluZyB0byBzYWNyaWZpY2UgcHJvdGVjdGlvbiBvciBsaWdodCB3ZWlnaHQgaW4gdGhlIGFscGluZSwgYnJpbmcgYWxvbmcgdGhlIE1pbGxldCBNZW5zIEFlcmlhbCBNYXggR29yZS1UZXggSmFja2V0LiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTU5UMDAxNS9TdXBlckZseS1YVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3VwZXItRmx5IFhUIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL01OVC9NTlQwMDE1L0FMUFJFRC5qcGciIGJvcmRlcj0iMCIgYWx0PSJTdXBlci1GbHkgWFQgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTU5UMDAxNS9TdXBlckZseS1YVC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3VwZXItRmx5IFhUIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vbnRhbmUgU3VwZXItRmx5IFhUIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIE1vbnRhbmUgTWVucyBTdXBlci1GbHkgWFQgSmFja2V0IHByb3ZpZGVzIG1heGltdW0gcHJvdGVjdGlvbiBhZ2FpbnN0IHRoZSBlbGVtZW50cyBkdXJpbmcgeW91ciBjbGltYmluZyBleHBlZGl0aW9uIG9yIGJhY2twYWNraW5nIHRyaXAuIERlc2lnbmVkIHNwZWNpZmljYWxseSBmb3IgbW91bnRhaW4gcmVzY3VlcywgcG9sYXIgZXhwZWRpdGlvbnMsIGFuZCBjbGltYmluZyB0cmlwcywgdGhlIFhUIHNwb3J0cyBwaXZvdGFsIGZlYXR1cmVzIGZvciBzdWNoIHZlbnR1cmVzLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNTA0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMzc4LjcxPC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NTlQwMDE1L1N1cGVyRmx5LVhULUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdXBlci1GbHkgWFQgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TU5UMDAxNSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NTlQwMDE1L01vbnRhbmUtU3VwZXJGbHktWFQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIE1vbnRhbmUgTWVucyBTdXBlci1GbHkgWFQgSmFja2V0IHByb3ZpZGVzIG1heGltdW0gcHJvdGVjdGlvbiBhZ2FpbnN0IHRoZSBlbGVtZW50cyBkdXJpbmcgeW91ciBjbGltYmluZyBleHBlZGl0aW9uIG9yIGJhY2twYWNraW5nIHRyaXAuIERlc2lnbmVkIHNwZWNpZmljYWxseSBmb3IgbW91bnRhaW4gcmVzY3VlcywgcG9sYXIgZXhwZWRpdGlvbnMsIGFuZCBjbGltYmluZyB0cmlwcywgdGhlIFhUIHNwb3J0cyBwaXZvdGFsIGZlYXR1cmVzIGZvciBzdWNoIHZlbnR1cmVzLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTU5UMDAxNi9lVmVudC1IYWxvLVN0cmV0Y2gtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9ImVWZW50IEhhbG8gU3RyZXRjaCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NTlQvTU5UMDAxNi9CTEEuanBnIiBib3JkZXI9IjAiIGFsdD0iZVZlbnQgSGFsbyBTdHJldGNoIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01OVDAwMTYvZVZlbnQtSGFsby1TdHJldGNoLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJlVmVudCBIYWxvIFN0cmV0Y2ggSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9udGFuZSBlVmVudCBIYWxvIFN0cmV0Y2ggSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlppcCB1cCB0aGUgTW9udGFuZSBNZW5zIGVWZW50IEhhbG8gU3RyZXRjaCBKYWNrZXQgYW5kIHJpc2UgYWJvdmUgaGVsbGFjaW91cyB3ZWF0aGVyLiBUaGUgSGFsb3Mgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIGVWZW50IGZhYnJpYyBpcyB0aGUgY2hhbWVsZW9uIG9mIG91dGVyd2VhciBmYWJyaWNzLCByZWFkeSB0byBhZGp1c3QgdG8gdGhlIG1vc3Qgc3VkZGVuIG9mIHdlYXRoZXIgY2hhbmdlcy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0MzkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzMjkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01OVDAwMTYvZVZlbnQtSGFsby1TdHJldGNoLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJlVmVudCBIYWxvIFN0cmV0Y2ggSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TU5UMDAxNiZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NTlQwMDE2L01vbnRhbmUtZVZlbnQtSGFsby1TdHJldGNoLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iWmlwIHVwIHRoZSBNb250YW5lIE1lbnMgZVZlbnQgSGFsbyBTdHJldGNoIEphY2tldCBhbmQgcmlzZSBhYm92ZSBoZWxsYWNpb3VzIHdlYXRoZXIuIFRoZSBIYWxvcyB3YXRlcnByb29mIGJyZWF0aGFibGUgZVZlbnQgZmFicmljIGlzIHRoZSBjaGFtZWxlb24gb2Ygb3V0ZXJ3ZWFyIGZhYnJpY3MsIHJlYWR5IHRvIGFkanVzdCB0byB0aGUgbW9zdCBzdWRkZW4gb2Ygd2VhdGhlciBjaGFuZ2VzLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01OVDAwMTcvU3VwZXJGbHktSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlN1cGVyLUZseSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NTlQvTU5UMDAxNy9BTFBSRC5qcGciIGJvcmRlcj0iMCIgYWx0PSJTdXBlci1GbHkgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTU5UMDAxNy9TdXBlckZseS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3VwZXItRmx5IEphY2tldCAtIE1lbiZhcG9zO3MiPk1vbnRhbmUgU3VwZXItRmx5IEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgTW9udGFuZSBNZW5zIFN1cGVyLUZseSBKYWNrZXQgZG9lc250IGxpa2UgdG8gYnJhZywgYnV0IHdoZW4gd2F0ZXJwcm9vZiBicmVhdGhhYmxlIGVWZW50IGZhYnJpYywgZnVsbHkgdGFwZWQgc2VhbXMsIGFuZCBsaWdodHdlaWdodCBkZXNpZ24gY29tZSB0b2dldGhlciB0byBtYWtlIGEgYm9tYnByb29mIHNoZWxsLCBpdHMgaGFyZCBub3QgdG8uIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzg5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTk0Ljk4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NTlQwMDE3L1N1cGVyRmx5LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdXBlci1GbHkgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TU5UMDAxNyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NTlQwMDE3L01vbnRhbmUtU3VwZXJGbHktSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgTW9udGFuZSBNZW5zIFN1cGVyLUZseSBKYWNrZXQgZG9lc250IGxpa2UgdG8gYnJhZywgYnV0IHdoZW4gd2F0ZXJwcm9vZiBicmVhdGhhYmxlIGVWZW50IGZhYnJpYywgZnVsbHkgdGFwZWQgc2VhbXMsIGFuZCBsaWdodHdlaWdodCBkZXNpZ24gY29tZSB0b2dldGhlciB0byBtYWtlIGEgYm9tYnByb29mIHNoZWxsLCBpdHMgaGFyZCBub3QgdG8uICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTU5UMDAyMC9MaXRlU3BlZWQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkxpdGUtU3BlZWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTU5UL01OVDAwMjAvRUxFQkxVQkwuanBnIiBib3JkZXI9IjAiIGFsdD0iTGl0ZS1TcGVlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NTlQwMDIwL0xpdGVTcGVlZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTGl0ZS1TcGVlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb250YW5lIExpdGUtU3BlZWQgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSBNb250YW5lIE1lbnMgTGl0ZS1TcGVlZCBKYWNrZXRzIGV4Y2VwdGlvbmFsbHkgbGlnaHR3ZWlnaHQgZGVzaWduIGtlZXBzIHlvdSBkcnkgd2l0aG91dCB3ZWlnaGluZyB5b3UgZG93bi4gVGhpcyB3aW5kcHJvb2YsIHdhdGVyLXJlc2lzdGFudCBqYWNrZXQgd2VpZ2hzIGluIGF0IDZveiBhbmQgc3Rvd3MgYXdheSBpbiBhbiBpbmNsdWRlZCBzdHVmZiBzYWMgd2hlbiB0aGUgc2tpZXMgY2xlYXIuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ5OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDc0Ljk2PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NTlQwMDIwL0xpdGVTcGVlZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTGl0ZS1TcGVlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NTlQwMDIwJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01OVDAwMjAvTW9udGFuZS1MaXRlU3BlZWQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgTW9udGFuZSBNZW5zIExpdGUtU3BlZWQgSmFja2V0cyBleGNlcHRpb25hbGx5IGxpZ2h0d2VpZ2h0IGRlc2lnbiBrZWVwcyB5b3UgZHJ5IHdpdGhvdXQgd2VpZ2hpbmcgeW91IGRvd24uIFRoaXMgd2luZHByb29mLCB3YXRlci1yZXNpc3RhbnQgamFja2V0IHdlaWdocyBpbiBhdCA2b3ogYW5kIHN0b3dzIGF3YXkgaW4gYW4gaW5jbHVkZWQgc3R1ZmYgc2FjIHdoZW4gdGhlIHNraWVzIGNsZWFyLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTVRCMDEwMC9UaHVuZGVyaGVhZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGh1bmRlcmhlYWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTVRCL01UQjAxMDAvQkkuanBnIiBib3JkZXI9IjAiIGFsdD0iVGh1bmRlcmhlYWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTVRCMDEwMC9UaHVuZGVyaGVhZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGh1bmRlcmhlYWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9udEJlbGwgVGh1bmRlcmhlYWQgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSBNb250QmVsbCBNZW5zIFRodW5kZXJoZWFkIEphY2tldCBnaXZlcyB5b3Ugbm90aGluZyBidXQgdW5jb21wcm9taXNpbmcgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIHByb3RlY3Rpb24gZm9yIHRoZSBiYWNrY291bnRyeSB0aGFua3MgdG8gaXRzIHN0cmVhbWxpbmVkIGRlc2lnbiBhbmQgR29yZS1UZXggc2hlbGwgZmFicmljLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDI5OC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDIzOS4xNjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTVRCMDEwMC9UaHVuZGVyaGVhZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGh1bmRlcmhlYWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9TVRCMDEwMCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9NVEIwMTAwL01vbnRCZWxsLVRodW5kZXJoZWFkLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIE1vbnRCZWxsIE1lbnMgVGh1bmRlcmhlYWQgSmFja2V0IGdpdmVzIHlvdSBub3RoaW5nIGJ1dCB1bmNvbXByb21pc2luZyB3YXRlcnByb29mIGJyZWF0aGFibGUgcHJvdGVjdGlvbiBmb3IgdGhlIGJhY2tjb3VudHJ5IHRoYW5rcyB0byBpdHMgc3RyZWFtbGluZWQgZGVzaWduIGFuZCBHb3JlLVRleCBzaGVsbCBmYWJyaWMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTlJBMDA0MS9OYXJ2aWstR29yZVRleC1Db21mb3J0LVNoZWxsLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJOYXJ2aWsgR29yZS1UZXggQ29tZm9ydCBTaGVsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9OUkEvTlJBMDA0MS9DQVYuanBnIiBib3JkZXI9IjAiIGFsdD0iTmFydmlrIEdvcmUtVGV4IENvbWZvcnQgU2hlbGwgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTlJBMDA0MS9OYXJ2aWstR29yZVRleC1Db21mb3J0LVNoZWxsLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJOYXJ2aWsgR29yZS1UZXggQ29tZm9ydCBTaGVsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Ob3Jy+G5hIE5hcnZpayBHb3JlLVRleCBDb21mb3J0IFNoZWxsIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5DdXQgZG93biBvbiBidWxrIGFuZCBzdGF5IHByb3RlY3RlZCB3aGVuIHlvdSB3ZWFyIHRoZSBOb3JybmEgTWVuJmFwb3M7cyBOYXJ2aWsgQ29tZm9ydHdlbGQgR29yZS1UZXggSmFja2V0IGludG8gdGhlIGJhY2tjb3VudHJ5LiBOb3Jyb25hIHVzZWQgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIEdvcmUtVGV4IFNvZnQgU2hlbGwgdG8ga2VlcCB5b3UgY29tZm9ydGFibGUgd2l0aG91dCByZXN0cmljdGluZyBtb3ZlbWVudC48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDU2OC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDI4NC40ODwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTlJBMDA0MS9OYXJ2aWstR29yZVRleC1Db21mb3J0LVNoZWxsLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJOYXJ2aWsgR29yZS1UZXggQ29tZm9ydCBTaGVsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1OUkEwMDQxJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL05SQTAwNDEvTm9ycm5hLU5hcnZpay1Hb3JlVGV4LUNvbWZvcnQtU2hlbGwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJDdXQgZG93biBvbiBidWxrIGFuZCBzdGF5IHByb3RlY3RlZCB3aGVuIHlvdSB3ZWFyIHRoZSBOb3JybmEgTWVuJmFwb3M7cyBOYXJ2aWsgQ29tZm9ydHdlbGQgR29yZS1UZXggSmFja2V0IGludG8gdGhlIGJhY2tjb3VudHJ5LiBOb3Jyb25hIHVzZWQgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIEdvcmUtVGV4IFNvZnQgU2hlbGwgdG8ga2VlcCB5b3UgY29tZm9ydGFibGUgd2l0aG91dCByZXN0cmljdGluZyBtb3ZlbWVudC4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X05SQTAwNTAvVHJvbGx2ZWdnZW4tRHJpMy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVHJvbGx2ZWdnZW4gRHJpMyBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9OUkEvTlJBMDA1MC9DQVYuanBnIiBib3JkZXI9IjAiIGFsdD0iVHJvbGx2ZWdnZW4gRHJpMyBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9OUkEwMDUwL1Ryb2xsdmVnZ2VuLURyaTMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRyb2xsdmVnZ2VuIERyaTMgSmFja2V0IC0gTWVuJmFwb3M7cyI+Tm9ycvhuYSBUcm9sbHZlZ2dlbiBEcmkzIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5QdWxsIG9uIHRoZSBOb3JybmEgTWVucyBUcm9sbHZlZ2dlbiBEcmkzIEphY2tldCBhbmQgZ2V0IGxpZ2h0d2VpZ2h0IHByb3RlY3Rpb24gdGhhdCBob2xkcyB1cCB0byB0aGUgcmlnb3JzIG9mIGFscGluZSBjbGltYmluZy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDQzOC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDE3NS41ODwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTlJBMDA1MC9Ucm9sbHZlZ2dlbi1EcmkzLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUcm9sbHZlZ2dlbiBEcmkzIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU5SQTAwNTAmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTlJBMDA1MC9Ob3JybmEtVHJvbGx2ZWdnZW4tRHJpMy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlB1bGwgb24gdGhlIE5vcnJuYSBNZW5zIFRyb2xsdmVnZ2VuIERyaTMgSmFja2V0IGFuZCBnZXQgbGlnaHR3ZWlnaHQgcHJvdGVjdGlvbiB0aGF0IGhvbGRzIHVwIHRvIHRoZSByaWdvcnMgb2YgYWxwaW5lIGNsaW1iaW5nLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTlJBMDA4OC9GYWxrZXRpbmQtR29yZVRleC1Qcm8tU2hlbGwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkZhbGtldGluZCBHb3JlLVRleCBQcm8gU2hlbGwgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTlJBL05SQTAwODgvQ0FWLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkZhbGtldGluZCBHb3JlLVRleCBQcm8gU2hlbGwgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTlJBMDA4OC9GYWxrZXRpbmQtR29yZVRleC1Qcm8tU2hlbGwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkZhbGtldGluZCBHb3JlLVRleCBQcm8gU2hlbGwgSmFja2V0IC0gTWVuJmFwb3M7cyI+Tm9ycvhuYSBGYWxrZXRpbmQgR29yZS1UZXggUHJvIFNoZWxsIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5KdWRnaW5nIGJ5IHRoZSBOb3Jyb25hIE1lbnMgRmFsa2V0aW5kIEdvcmUtVGV4IFBybyBTaGVsbCwgd2UgY2FuIHNlZSB0aGF0IHRoZSBOb3J3ZWdpYW5zIHRha2UgdGhlaXIgd2VhdGhlciBwcm90ZWN0aW9uIHZlcnkgc2VyaW91c2x5LiBUaGlzIGxpZ2h0d2VpZ2h0LCB3YXRlcnByb29mIGJyZWF0aGFibGUgc2hlbGwgc2VhbHMgb3V0IG1vaXN0dXJlIHdpdGhvdXQgcmVzdHJpY3RpbmcgeW91IGluIGZ1bGwtb24gYWxwaW5lIGNvbmRpdGlvbnMuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNDk4Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjQ5LjQ4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9OUkEwMDg4L0ZhbGtldGluZC1Hb3JlVGV4LVByby1TaGVsbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iRmFsa2V0aW5kIEdvcmUtVGV4IFBybyBTaGVsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1OUkEwMDg4JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL05SQTAwODgvTm9ycm5hLUZhbGtldGluZC1Hb3JlVGV4LVByby1TaGVsbC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9Ikp1ZGdpbmcgYnkgdGhlIE5vcnJvbmEgTWVucyBGYWxrZXRpbmQgR29yZS1UZXggUHJvIFNoZWxsLCB3ZSBjYW4gc2VlIHRoYXQgdGhlIE5vcndlZ2lhbnMgdGFrZSB0aGVpciB3ZWF0aGVyIHByb3RlY3Rpb24gdmVyeSBzZXJpb3VzbHkuIFRoaXMgbGlnaHR3ZWlnaHQsIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBzaGVsbCBzZWFscyBvdXQgbW9pc3R1cmUgd2l0aG91dCByZXN0cmljdGluZyB5b3UgaW4gZnVsbC1vbiBhbHBpbmUgY29uZGl0aW9ucy4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9PRFIwNTc0L01lbnRvci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTWVudG9yIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL09EUi9PRFIwNTc0L0FCWS5qcGciIGJvcmRlcj0iMCIgYWx0PSJNZW50b3IgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfT0RSMDU3NC9NZW50b3ItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik1lbnRvciBKYWNrZXQgLSBNZW4mYXBvcztzIj5PdXRkb29yIFJlc2VhcmNoIE1lbnRvciBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+S25pZ2h0cyB3ZWFyIGNoYWlubWFpbCBhcm1vciwgYmVla2VlcGVycyB3ZWFyIHRob3NlIGZ1bm55IHdoaXRlIHN1aXRzLCBhbmQgdGhvc2UgdmVudHVyaW5nIGludG8gc2VyaW91cyBhbHBpbmUgY29uZGl0aW9ucyB3ZWFyIHRoZSBPdXRkb29yIFJlc2VhcmNoIE1lbnMgTWVudG9yIEphY2tldC4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0MjQuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzMzkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X09EUjA1NzQvTWVudG9yLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNZW50b3IgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9T0RSMDU3NCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9PRFIwNTc0L091dGRvb3ItUmVzZWFyY2gtTWVudG9yLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iS25pZ2h0cyB3ZWFyIGNoYWlubWFpbCBhcm1vciwgYmVla2VlcGVycyB3ZWFyIHRob3NlIGZ1bm55IHdoaXRlIHN1aXRzLCBhbmQgdGhvc2UgdmVudHVyaW5nIGludG8gc2VyaW91cyBhbHBpbmUgY29uZGl0aW9ucyB3ZWFyIHRoZSBPdXRkb29yIFJlc2VhcmNoIE1lbnMgTWVudG9yIEphY2tldC4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxMjU5L1N0cmV0Y2gtRWxlbWVudC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3RyZXRjaCBFbGVtZW50IEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1BBVC9QQVQxMjU5L0JLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlN0cmV0Y2ggRWxlbWVudCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxMjU5L1N0cmV0Y2gtRWxlbWVudC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3RyZXRjaCBFbGVtZW50IEphY2tldCAtIE1lbiZhcG9zO3MiPlBhdGFnb25pYSBTdHJldGNoIEVsZW1lbnQgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlBhdGFnb25pYSB0b29rIHRoZSBzdHJldGNoaW5lc3MgYW5kIGJyZWF0aGFiaWxpdHkgb2YgYSBzb2Z0c2hlbGwgYW5kIHRoZSB3YXRlcnByb29mIGJhcnJpZXIgb2YgYSBoYXJkc2hlbGwgYW5kIG1hZGUgdGhlIE1lbnMgU3RyZXRjaCBFbGVtZW50IEphY2tldCBmb3IgeW91ciBhbHBpbmUgcHVyc3VpdHMuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNDUwLjAwPC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kNDA1LjAwPC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxMjU5L1N0cmV0Y2gtRWxlbWVudC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3RyZXRjaCBFbGVtZW50IEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PVBBVDEyNTkmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvUEFUMTI1OS9QYXRhZ29uaWEtU3RyZXRjaC1FbGVtZW50LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iUGF0YWdvbmlhIHRvb2sgdGhlIHN0cmV0Y2hpbmVzcyBhbmQgYnJlYXRoYWJpbGl0eSBvZiBhIHNvZnRzaGVsbCBhbmQgdGhlIHdhdGVycHJvb2YgYmFycmllciBvZiBhIGhhcmRzaGVsbCBhbmQgbWFkZSB0aGUgTWVucyBTdHJldGNoIEVsZW1lbnQgSmFja2V0IGZvciB5b3VyIGFscGluZSBwdXJzdWl0cy4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxNDQzL1N0cmV0Y2gtQXNjZW50LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdHJldGNoIEFzY2VudCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9QQVQvUEFUMTQ0My9BTkkuanBnIiBib3JkZXI9IjAiIGFsdD0iU3RyZXRjaCBBc2NlbnQgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfUEFUMTQ0My9TdHJldGNoLUFzY2VudC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3RyZXRjaCBBc2NlbnQgSmFja2V0IC0gTWVuJmFwb3M7cyI+UGF0YWdvbmlhIFN0cmV0Y2ggQXNjZW50IEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5Gcm9tIHRoZSB0b3dlcmluZyBzcGlyZXMgb2YgUGF0YWdvbmlhIHRvIHRoZSB1bmZvcmdpdmluZyBwZWFrcyBvZiB0aGUgSGltYWxheWFzLCB0aGUgUGF0YWdvbmlhIE1lbnMgU3RyZXRjaCBBc2NlbnQgSmFja2V0IGdpdmVzIHlvdSB1bnBhcmFsbGVsZWQgd2VhdGhlciBwcm90ZWN0aW9uIGZvciB0aGUgdmVydGljYWwgd29ybGQuIDwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzAwLjAwPC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjQwLjAwPC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxNDQzL1N0cmV0Y2gtQXNjZW50LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTdHJldGNoIEFzY2VudCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1QQVQxNDQzJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1BBVDE0NDMvUGF0YWdvbmlhLVN0cmV0Y2gtQXNjZW50LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iRnJvbSB0aGUgdG93ZXJpbmcgc3BpcmVzIG9mIFBhdGFnb25pYSB0byB0aGUgdW5mb3JnaXZpbmcgcGVha3Mgb2YgdGhlIEhpbWFsYXlhcywgdGhlIFBhdGFnb25pYSBNZW5zIFN0cmV0Y2ggQXNjZW50IEphY2tldCBnaXZlcyB5b3UgdW5wYXJhbGxlbGVkIHdlYXRoZXIgcHJvdGVjdGlvbiBmb3IgdGhlIHZlcnRpY2FsIHdvcmxkLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1BBVDE1NzYvU3BlZWQtQXNjZW50LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTcGVlZCBBc2NlbnQgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvUEFUL1BBVDE1NzYvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iU3BlZWQgQXNjZW50IEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1BBVDE1NzYvU3BlZWQtQXNjZW50LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJTcGVlZCBBc2NlbnQgSmFja2V0IC0gTWVuJmFwb3M7cyI+UGF0YWdvbmlhIFNwZWVkIEFzY2VudCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+QXMgdGhlIHdhcm1lc3Qgd2luZC0gYW5kIHdhdGVyLXJlc2lzdGFudCBzb2Z0c2hlbGwgaW4gdGhlIFBhdGFnb25pYSBsaW5lLCB0aGUgTWVucyBTcGVlZCBBc2NlbnQgSmFja2V0IGlzIGJ1aWx0IGZvciB0ZWNobmljYWwgd2ludGVyIHB1cnN1aXRzIHdoZXJlIHN0cmV0Y2ggYW5kIGluc3VsYXRpb24gYXJlbnQganVzdCBuaWNlLCB0aGV5cmUgZXNzZW50aWFsLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDM3NS4wMDwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDMzNy41MDwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfUEFUMTU3Ni9TcGVlZC1Bc2NlbnQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlNwZWVkIEFzY2VudCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1QQVQxNTc2JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1BBVDE1NzYvUGF0YWdvbmlhLVNwZWVkLUFzY2VudC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkFzIHRoZSB3YXJtZXN0IHdpbmQtIGFuZCB3YXRlci1yZXNpc3RhbnQgc29mdHNoZWxsIGluIHRoZSBQYXRhZ29uaWEgbGluZSwgdGhlIE1lbnMgU3BlZWQgQXNjZW50IEphY2tldCBpcyBidWlsdCBmb3IgdGVjaG5pY2FsIHdpbnRlciBwdXJzdWl0cyB3aGVyZSBzdHJldGNoIGFuZCBpbnN1bGF0aW9uIGFyZW50IGp1c3QgbmljZSwgdGhleXJlIGVzc2VudGlhbC4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxNTc4L1NoZWx0ZXItU3RvbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlNoZWx0ZXIgU3RvbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvUEFUL1BBVDE1NzgvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iU2hlbHRlciBTdG9uZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9QQVQxNTc4L1NoZWx0ZXItU3RvbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlNoZWx0ZXIgU3RvbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+UGF0YWdvbmlhIFNoZWx0ZXIgU3RvbmUgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkRlc2lnbmVkIGZvciBicnV0YWwgY29uZGl0aW9ucyBpbiB1bmZvcmdpdmluZyBtb3VudGFpbiBlbnZpcm9ubWVudHMsIHRoZSBQYXRhZ29uaWEgTWVucyBTaGVsdGVyIFN0b25lIEphY2tldCBnaXZlcyB5b3UgdWx0cmEtZHVyYWJsZSB3ZWF0aGVyIHByb3RlY3Rpb24gdGhhbmtzIHRvIGl0cyBIMk5vIHdhdGVycHJvb2YgYnJlYXRoYWJsZSBiYXJyaWVyIGFuZCByZWluZm9yY2VkLCBzdHJldGNoLXdvdmVuIGZhYnJpYy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNzUuMDA8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzMzcuNTA8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1BBVDE1NzgvU2hlbHRlci1TdG9uZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2hlbHRlciBTdG9uZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1QQVQxNTc4JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1BBVDE1NzgvUGF0YWdvbmlhLVNoZWx0ZXItU3RvbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJEZXNpZ25lZCBmb3IgYnJ1dGFsIGNvbmRpdGlvbnMgaW4gdW5mb3JnaXZpbmcgbW91bnRhaW4gZW52aXJvbm1lbnRzLCB0aGUgUGF0YWdvbmlhIE1lbnMgU2hlbHRlciBTdG9uZSBKYWNrZXQgZ2l2ZXMgeW91IHVsdHJhLWR1cmFibGUgd2VhdGhlciBwcm90ZWN0aW9uIHRoYW5rcyB0byBpdHMgSDJObyB3YXRlcnByb29mIGJyZWF0aGFibGUgYmFycmllciBhbmQgcmVpbmZvcmNlZCwgc3RyZXRjaC13b3ZlbiBmYWJyaWMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfUUtTNDY2OS9UcmF2aXMtUmljZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVHJhdmlzIFJpY2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvUUtTL1FLUzQ2NjkvUkVELmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlRyYXZpcyBSaWNlIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1FLUzQ2NjkvVHJhdmlzLVJpY2UtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlRyYXZpcyBSaWNlIEphY2tldCAtIE1lbiZhcG9zO3MiPlF1aWtzaWx2ZXIgVHJhdmlzIFJpY2UgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRSaWNlIGRvZXNudCBkbyBhbnl0aGluZyBoYWxmLWFzc2VkLCBhbmQgaGlzIFF1aWtzaWx2ZXIgTWVucyBUcmF2aXMgUmljZSBKYWNrZXQgcmVmbGVjdHMgaGlzIHBhc3Npb24gZm9yIHBlcmZlY3Rpb24uIFdpdGggc3VwZXJsYXRpdmUgd2F0ZXJwcm9vZiBwcm90ZWN0aW9uIGFuZCB0aGUgc2lnbmF0dXJlIHN0eWxlIG9mIHRoZSBzYXZpb3Igb2Ygc25vd2JvYXJkaW5nLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDIzNC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfUUtTNDY2OS9UcmF2aXMtUmljZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVHJhdmlzIFJpY2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9UUtTNDY2OSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9RS1M0NjY5L1F1aWtzaWx2ZXItVHJhdmlzLVJpY2UtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUUmljZSBkb2VzbnQgZG8gYW55dGhpbmcgaGFsZi1hc3NlZCwgYW5kIGhpcyBRdWlrc2lsdmVyIE1lbnMgVHJhdmlzIFJpY2UgSmFja2V0IHJlZmxlY3RzIGhpcyBwYXNzaW9uIGZvciBwZXJmZWN0aW9uLiBXaXRoIHN1cGVybGF0aXZlIHdhdGVycHJvb2YgcHJvdGVjdGlvbiBhbmQgdGhlIHNpZ25hdHVyZSBzdHlsZSBvZiB0aGUgc2F2aW9yIG9mIHNub3dib2FyZGluZy4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1JBQjAwMTUvTGF0b2stQWxwaW5lLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJMYXRvayBBbHBpbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvUkFCL1JBQjAwMTUvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iTGF0b2sgQWxwaW5lIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1JBQjAwMTUvTGF0b2stQWxwaW5lLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJMYXRvayBBbHBpbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+UmFiIExhdG9rIEFscGluZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+RGVzaWduZWQgZm9yIGxpZ2h0d2VpZ2h0IGFscGluZSBjbGltYnMgYW5kIG1vZGVyYXRlIHN1bW1lciBtb3VudGFpbmVlcmluZywgdGhlIFJhYiBNZW5zIExhdG9rIEFscGluZSBKYWNrZXQgaXMgYSBtYXN0ZXJwaWVjZSBvZiBtaW5pbWFsaXNtLiAgPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQyOTkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQyMzkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1JBQjAwMTUvTGF0b2stQWxwaW5lLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJMYXRvayBBbHBpbmUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9UkFCMDAxNSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9SQUIwMDE1L1JhYi1MYXRvay1BbHBpbmUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJEZXNpZ25lZCBmb3IgbGlnaHR3ZWlnaHQgYWxwaW5lIGNsaW1icyBhbmQgbW9kZXJhdGUgc3VtbWVyIG1vdW50YWluZWVyaW5nLCB0aGUgUmFiIE1lbnMgTGF0b2sgQWxwaW5lIEphY2tldCBpcyBhIG1hc3RlcnBpZWNlIG9mIG1pbmltYWxpc20uICAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1JBQjAwMTYvTGF0b2stSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkxhdG9rIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1JBQi9SQUIwMDE2L0RBUlNLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkxhdG9rIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1JBQjAwMTYvTGF0b2stSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkxhdG9rIEphY2tldCAtIE1lbiZhcG9zO3MiPlJhYiBMYXRvayBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+Rm9yIGJ1cmx5IGV4cGVkaXRpb25zLCB3aW50ZXIgYWxwaW5pc20sIGFuZCB0aG9zZSB3aG8gcGxhbiBvbiBlbmNvdW50ZXJpbmcgdGhlIHdvcnN0IHdlYXRoZXIgaW1hZ2luYWJsZSwgUmFiIGRlc2lnbmVkIHRoZSBNZW5zIExhdG9rIEphY2tldC4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzNzQuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQyOTkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1JBQjAwMTYvTGF0b2stSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkxhdG9rIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PVJBQjAwMTYmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvUkFCMDAxNi9SYWItTGF0b2stSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJGb3IgYnVybHkgZXhwZWRpdGlvbnMsIHdpbnRlciBhbHBpbmlzbSwgYW5kIHRob3NlIHdobyBwbGFuIG9uIGVuY291bnRlcmluZyB0aGUgd29yc3Qgd2VhdGhlciBpbWFnaW5hYmxlLCBSYWIgZGVzaWduZWQgdGhlIE1lbnMgTGF0b2sgSmFja2V0LiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1NFUzA3NTAvUGxleHVzLVBpbm5hY2xlLTNQbHktQm9hLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJQbGV4dXMgUGlubmFjbGUgMy1QbHkgQm9hIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1NFUy9TRVMwNzUwL0JLV09SUFJJLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlBsZXh1cyBQaW5uYWNsZSAzLVBseSBCb2EgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfU0VTMDc1MC9QbGV4dXMtUGlubmFjbGUtM1BseS1Cb2EtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlBsZXh1cyBQaW5uYWNsZSAzLVBseSBCb2EgSmFja2V0IC0gTWVuJmFwb3M7cyI+Njg2IFBsZXh1cyBQaW5uYWNsZSAzLVBseSBCb2EgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSA2ODYgUGxleHVzIFBpbm5hY2xlIDMtUGx5IEJPQSBKYWNrZXQgYnJpbmdzIEJPQSBmaXQgdGVjaG5vbG9neSBhYm92ZSB0aGUgd2Fpc3QuICA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ0MDAuMDA8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1NFUzA3NTAvUGxleHVzLVBpbm5hY2xlLTNQbHktQm9hLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJQbGV4dXMgUGlubmFjbGUgMy1QbHkgQm9hIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PVNFUzA3NTAmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvU0VTMDc1MC82ODYtUGxleHVzLVBpbm5hY2xlLTNQbHktQm9hLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIDY4NiBQbGV4dXMgUGlubmFjbGUgMy1QbHkgQk9BIEphY2tldCBicmluZ3MgQk9BIGZpdCB0ZWNobm9sb2d5IGFib3ZlIHRoZSB3YWlzdC4gICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfU0VTMDc1Mi9QbGV4dXMtR2FtbWEtMjVQbHktSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlBsZXh1cyBHYW1tYSAyLjUtUGx5IEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1NFUy9TRVMwNzUyL0JLVEVYLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlBsZXh1cyBHYW1tYSAyLjUtUGx5IEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1NFUzA3NTIvUGxleHVzLUdhbW1hLTI1UGx5LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJQbGV4dXMgR2FtbWEgMi41LVBseSBKYWNrZXQgLSBNZW4mYXBvcztzIj42ODYgUGxleHVzIEdhbW1hIDIuNS1QbHkgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSA2ODYgTWVucyBQbGV4dXMgR2FtbWEgMi41LVBseSBKYWNrZXQgaXMgYSByb2xlIG1vZGVsIGZvciBtaW5pbWFsaXN0aWMgYnV0IHViZXIgdGVjaG5pY2FsIGphY2tldHMgZXZlcnl3aGVyZS4gTGlnaHR3ZWlnaHQgYnV0IHN0aWxsIGJvbWJwcm9vZiwgd2l0aCBhbGwgdGhlIGZlYXR1cmVzIHlvdWxsIGV2ZXIgbmVlZCwgeW91bGwgYmUgaGFyZCBwcmVzc2VkIHRvIGZpbmQgYW5vdGhlciBqYWNrZXQgdGhhdCBjb21wYXJlcy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjgwLjAwPC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9TRVMwNzUyL1BsZXh1cy1HYW1tYS0yNVBseS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iUGxleHVzIEdhbW1hIDIuNS1QbHkgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9U0VTMDc1MiZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9TRVMwNzUyLzY4Ni1QbGV4dXMtR2FtbWEtMjVQbHktSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgNjg2IE1lbnMgUGxleHVzIEdhbW1hIDIuNS1QbHkgSmFja2V0IGlzIGEgcm9sZSBtb2RlbCBmb3IgbWluaW1hbGlzdGljIGJ1dCB1YmVyIHRlY2huaWNhbCBqYWNrZXRzIGV2ZXJ5d2hlcmUuIExpZ2h0d2VpZ2h0IGJ1dCBzdGlsbCBib21icHJvb2YsIHdpdGggYWxsIHRoZSBmZWF0dXJlcyB5b3VsbCBldmVyIG5lZWQsIHlvdWxsIGJlIGhhcmQgcHJlc3NlZCB0byBmaW5kIGFub3RoZXIgamFja2V0IHRoYXQgY29tcGFyZXMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfU0lDMDAyMS9Cb21ic2hlbGwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJvbWJzaGVsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9TSUMvU0lDMDAyMS9CTEEuanBnIiBib3JkZXI9IjAiIGFsdD0iQm9tYnNoZWxsIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1NJQzAwMjEvQm9tYnNoZWxsLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJCb21ic2hlbGwgSmFja2V0IC0gTWVuJmFwb3M7cyI+U3RvaWMgQm9tYnNoZWxsIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgdW5kYXVudGVkIFN0b2ljIEJvbWJzaGVsbCBKYWNrZXQgc2lnbnMgb24gZm9yIHN1bW1pdCBwdXNoZXMsIGh1dC10by1odXQgdG91cnMsIGFuZCBhbnl0aGluZyBiZXR3ZWVuLiBTbGlnaHRseSBzdHJldGNoeSwgMy1sYXllciBCb21ic2hlbGwgbWF0ZXJpYWwgb2ZmZXJzIHNoZWx0ZXIgZnJvbSByaWRnZWxpbmUgZ2FsZXMgYW5kIHdoaXBwaW5nIHNwaW4gZHJpZnQsIHdoaWxlIHRodW1iLWhvbGVkIGhhbmQgZ2FpdGVycyBhbmQgYSBmdWxseS1hZGp1c3RhYmxlIGhvb2QgZW5zdXJlIGEgY29tcGxldGUgc2VhbCBmcm9tIHRoZSBlbGVtZW50cy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDI1OS4wMDwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDIwNy4yMDwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfU0lDMDAyMS9Cb21ic2hlbGwtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJvbWJzaGVsbCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1TSUMwMDIxJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1NJQzAwMjEvU3RvaWMtQm9tYnNoZWxsLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIHVuZGF1bnRlZCBTdG9pYyBCb21ic2hlbGwgSmFja2V0IHNpZ25zIG9uIGZvciBzdW1taXQgcHVzaGVzLCBodXQtdG8taHV0IHRvdXJzLCBhbmQgYW55dGhpbmcgYmV0d2Vlbi4gU2xpZ2h0bHkgc3RyZXRjaHksIDMtbGF5ZXIgQm9tYnNoZWxsIG1hdGVyaWFsIG9mZmVycyBzaGVsdGVyIGZyb20gcmlkZ2VsaW5lIGdhbGVzIGFuZCB3aGlwcGluZyBzcGluIGRyaWZ0LCB3aGlsZSB0aHVtYi1ob2xlZCBoYW5kIGdhaXRlcnMgYW5kIGEgZnVsbHktYWRqdXN0YWJsZSBob29kIGVuc3VyZSBhIGNvbXBsZXRlIHNlYWwgZnJvbSB0aGUgZWxlbWVudHMuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkYzNTMwL01vdW50YWluLUxpZ2h0LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNb3VudGFpbiBMaWdodCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9UTkYvVE5GMzUzMC9BTkVHTi5qcGciIGJvcmRlcj0iMCIgYWx0PSJNb3VudGFpbiBMaWdodCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkYzNTMwL01vdW50YWluLUxpZ2h0LUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNb3VudGFpbiBMaWdodCBKYWNrZXQgLSBNZW4mYXBvcztzIj5UaGUgTm9ydGggRmFjZSBNb3VudGFpbiBMaWdodCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIE5vcnRoIEZhY2UgTWVuJmFwb3M7cyBNb3VudGFpbiBMaWdodCBKYWNrZXQgaXMgYSB3YXRlcnByb29mIGJyZWF0aGFibGUgc2hlbGwgdGhhdCBoYXMgeW91ciBiYWNrIHdoZW4gaXQmYXBvcztzIHlvdSB2ZXJzdXMgdGhlIGVsZW1lbnRzLiBUaGUgR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYyB3b24mYXBvczt0IGJhY2sgZG93biBkdXJpbmcgd2V0IHdpbnRlciBzdG9ybXMuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQyOTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQyMzkuMTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1RORjM1MzAvTW91bnRhaW4tTGlnaHQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9Ik1vdW50YWluIExpZ2h0IEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PVRORjM1MzAmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvVE5GMzUzMC9UaGUtTm9ydGgtRmFjZS1Nb3VudGFpbi1MaWdodC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSBOb3J0aCBGYWNlIE1lbiZhcG9zO3MgTW91bnRhaW4gTGlnaHQgSmFja2V0IGlzIGEgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIHNoZWxsIHRoYXQgaGFzIHlvdXIgYmFjayB3aGVuIGl0JmFwb3M7cyB5b3UgdmVyc3VzIHRoZSBlbGVtZW50cy4gVGhlIEdvcmUtVGV4IFBybyBTaGVsbCBmYWJyaWMgd29uJmFwb3M7dCBiYWNrIGRvd24gZHVyaW5nIHdldCB3aW50ZXIgc3Rvcm1zLiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GMzUzMy9BbGxpYW5jZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQWxsaWFuY2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvVE5GL1RORjM1MzMvQkFCTC5qcGciIGJvcmRlcj0iMCIgYWx0PSJBbGxpYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkYzNTMzL0FsbGlhbmNlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbGxpYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5UaGUgTm9ydGggRmFjZSBBbGxpYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+SWYgeW91ciB3aW50ZXIgb3V0Zml0cyB1c3VhbGx5IGluY2x1ZGUgYSB0b3VyaW5nIGJhY2twYWNrIG9yIGEgY2xpbWJpbmcgaGFybmVzcywgZ3JhYiBUaGUgTm9ydGggRmFjZSBNZW4mYXBvcztzIEFsbGlhbmNlIEphY2tldC4gVGhpcyBkdXJhYmxlIHNvZnRzaGVsbCZhcG9zO3Mgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIGZhYnJpYyBmaWdodHMgdGhlIGVsZW1lbnRzLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDE0OC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDU5LjU4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkYzNTMzL0FsbGlhbmNlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJBbGxpYW5jZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkYzNTMzJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjM1MzMvVGhlLU5vcnRoLUZhY2UtQWxsaWFuY2UtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJJZiB5b3VyIHdpbnRlciBvdXRmaXRzIHVzdWFsbHkgaW5jbHVkZSBhIHRvdXJpbmcgYmFja3BhY2sgb3IgYSBjbGltYmluZyBoYXJuZXNzLCBncmFiIFRoZSBOb3J0aCBGYWNlIE1lbiZhcG9zO3MgQWxsaWFuY2UgSmFja2V0LiBUaGlzIGR1cmFibGUgc29mdHNoZWxsJmFwb3M7cyB3YXRlcnByb29mIGJyZWF0aGFibGUgZmFicmljIGZpZ2h0cyB0aGUgZWxlbWVudHMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDAxNS9TZXJhYy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2VyYWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvVE5GL1RORjQwMTUvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iU2VyYWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDAxNS9TZXJhYy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU2VyYWMgSmFja2V0IC0gTWVuJmFwb3M7cyI+VGhlIE5vcnRoIEZhY2UgU2VyYWMgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSB3YXRlcnByb29mIGJyZWF0aGFibGUgR29yZS1UZXggUGFjTGl0ZSBmYWJyaWMgaW4gVGhlIE5vcnRoIEZhY2UgU2VyYWMgSmFja2V0IGlzIHNvIGxpZ2h0d2VpZ2h0LCB5b3UgbWlnaHQgbm90IGV2ZW4gbm90aWNlIHlvdSZhcG9zO3JlIHdlYXJpbmcgYSBqYWNrZXQgKGV4Y2VwdCB0aGF0IHlvdXIgdG9yc28gYW5kIGhlYWQgc3RheSBwZXJmZWN0bHkgZHJ5IGR1cmluZyBtb3VudGFpbiByYWluIHNxdWFsbHMpLiAgPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzOTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxOTkuNDg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1RORjQwMTUvU2VyYWMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlNlcmFjIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PVRORjQwMTUmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvVE5GNDAxNS9UaGUtTm9ydGgtRmFjZS1TZXJhYy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSB3YXRlcnByb29mIGJyZWF0aGFibGUgR29yZS1UZXggUGFjTGl0ZSBmYWJyaWMgaW4gVGhlIE5vcnRoIEZhY2UgU2VyYWMgSmFja2V0IGlzIHNvIGxpZ2h0d2VpZ2h0LCB5b3UgbWlnaHQgbm90IGV2ZW4gbm90aWNlIHlvdSZhcG9zO3JlIHdlYXJpbmcgYSBqYWNrZXQgKGV4Y2VwdCB0aGF0IHlvdXIgdG9yc28gYW5kIGhlYWQgc3RheSBwZXJmZWN0bHkgZHJ5IGR1cmluZyBtb3VudGFpbiByYWluIHNxdWFsbHMpLiAgIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDE2L1N0cmV0Y2gtRGlhZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3RyZXRjaCBEaWFkIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1RORi9UTkY0MDE2L0JLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlN0cmV0Y2ggRGlhZCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDE2L1N0cmV0Y2gtRGlhZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iU3RyZXRjaCBEaWFkIEphY2tldCAtIE1lbiZhcG9zO3MiPlRoZSBOb3J0aCBGYWNlIFN0cmV0Y2ggRGlhZCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+SWYgeW91ciBzdW1taXQgcHVzaCBvZnRlbiBpbmNsdWRlcyBjbGltYmluZywgc3dlYXRpbmcsIGFuZCB1bnByZWRpY3RhYmxlIHdlYXRoZXIsIFRoZSBOb3J0aCBGYWNlIE1lbnMgU3RyZXRjaCBEaWFkIEphY2tldCB3aWxsIGJlIGEgc3VwZXItbGlnaHQsIGhhbmR5IGFkZGl0aW9uIHRvIHlvdXIgcGFjay4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQxOTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ5OS40ODwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDAxNi9TdHJldGNoLURpYWQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlN0cmV0Y2ggRGlhZCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkY0MDE2JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjQwMTYvVGhlLU5vcnRoLUZhY2UtU3RyZXRjaC1EaWFkLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iSWYgeW91ciBzdW1taXQgcHVzaCBvZnRlbiBpbmNsdWRlcyBjbGltYmluZywgc3dlYXRpbmcsIGFuZCB1bnByZWRpY3RhYmxlIHdlYXRoZXIsIFRoZSBOb3J0aCBGYWNlIE1lbnMgU3RyZXRjaCBEaWFkIEphY2tldCB3aWxsIGJlIGEgc3VwZXItbGlnaHQsIGhhbmR5IGFkZGl0aW9uIHRvIHlvdXIgcGFjay4gIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDE3L1RyaXVtcGgtQW5vcmFrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUcml1bXBoIEFub3JhayBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9UTkYvVE5GNDAxNy9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJUcml1bXBoIEFub3JhayBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDE3L1RyaXVtcGgtQW5vcmFrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUcml1bXBoIEFub3JhayBKYWNrZXQgLSBNZW4mYXBvcztzIj5UaGUgTm9ydGggRmFjZSBUcml1bXBoIEFub3JhayBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+QnkgdXNpbmcgYSB1bmlxdWUgdHdvLXBhbmVsIGNvbnN0cnVjdGlvbiwgVGhlIE5vcnRoIEZhY2Ugd2FzIGFibGUgdG8gcmVtb3ZlIGV2ZXJ5IHVubmVjZXNzYXJ5IHNlYW0gZnJvbSB0aGUgTWVuJmFwb3M7cyBUcml1bXBoIEFub3JhayBhbmQgbG93ZXIgaXRzIHdlaWdodCB0byBhbiBpbmNyZWRpYmxlIDUuNG96LjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMTc4Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTA3LjM3PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDE3L1RyaXVtcGgtQW5vcmFrLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUcml1bXBoIEFub3JhayBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkY0MDE3JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjQwMTcvVGhlLU5vcnRoLUZhY2UtVHJpdW1waC1Bbm9yYWstSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJCeSB1c2luZyBhIHVuaXF1ZSB0d28tcGFuZWwgY29uc3RydWN0aW9uLCBUaGUgTm9ydGggRmFjZSB3YXMgYWJsZSB0byByZW1vdmUgZXZlcnkgdW5uZWNlc3Nhcnkgc2VhbSBmcm9tIHRoZSBNZW4mYXBvcztzIFRyaXVtcGggQW5vcmFrIGFuZCBsb3dlciBpdHMgd2VpZ2h0IHRvIGFuIGluY3JlZGlibGUgNS40b3ouIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDI1L1RpdGFuLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaXRhbiBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9UTkYvVE5GNDAyNS9BU1BHUkUuanBnIiBib3JkZXI9IjAiIGFsdD0iVGl0YW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDAyNS9UaXRhbi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVGl0YW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+VGhlIE5vcnRoIEZhY2UgVGl0YW4gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSBOb3J0aCBGYWNlIE1lbnMgVGl0YW4gSmFja2V0IHJlaWducyBzdXByZW1lIG92ZXIgd2V0IHdlYXRoZXIgYW5kIG5vbi1icmVhdGhhYmxlIG91dGVyd2Vhci4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjQ4Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MDI1L1RpdGFuLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJUaXRhbiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkY0MDI1JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjQwMjUvVGhlLU5vcnRoLUZhY2UtVGl0YW4tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgTm9ydGggRmFjZSBNZW5zIFRpdGFuIEphY2tldCByZWlnbnMgc3VwcmVtZSBvdmVyIHdldCB3ZWF0aGVyIGFuZCBub24tYnJlYXRoYWJsZSBvdXRlcndlYXIuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDI5Mi9NYW1tYXR1cy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTWFtbWF0dXMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvVE5GL1RORjQyOTIvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iTWFtbWF0dXMgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDI5Mi9NYW1tYXR1cy1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTWFtbWF0dXMgSmFja2V0IC0gTWVuJmFwb3M7cyI+VGhlIE5vcnRoIEZhY2UgTWFtbWF0dXMgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlNpZGV3YXlzLWJsb3dpbmcgc25vdywgcG91bmRpbmcgd2luZCwgYW5kIHNvdWwtY3J1c2hpbmcgcmFpbmp1c3QgYW5vdGhlciBkYXkgYXQgdGhlIG9mZmljZSBmb3IgVGhlIE5vcnRoIEZhY2UgTWVucyBNYW1tYXR1cyBKYWNrZXQuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kNTQ4Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0MjkyL01hbW1hdHVzLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNYW1tYXR1cyBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkY0MjkyJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjQyOTIvVGhlLU5vcnRoLUZhY2UtTWFtbWF0dXMtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJTaWRld2F5cy1ibG93aW5nIHNub3csIHBvdW5kaW5nIHdpbmQsIGFuZCBzb3VsLWNydXNoaW5nIHJhaW5qdXN0IGFub3RoZXIgZGF5IGF0IHRoZSBvZmZpY2UgZm9yIFRoZSBOb3J0aCBGYWNlIE1lbnMgTWFtbWF0dXMgSmFja2V0LiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDI5My9IZWF0aGVuLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJIZWF0aGVuIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1RORi9UTkY0MjkzL0JLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkhlYXRoZW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDI5My9IZWF0aGVuLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJIZWF0aGVuIEphY2tldCAtIE1lbiZhcG9zO3MiPlRoZSBOb3J0aCBGYWNlIEhlYXRoZW4gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkJ1aWx0IHdpdGggR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYyBmb3IgdWx0aW1hdGUgd2VhdGhlciBwcm90ZWN0aW9uIG9uIGxpZ2h0LWFuZC1mYXN0IGNsaW1iaW5nIG1pc3Npb25zLCBUaGUgTm9ydGggRmFjZSBNZW5zIEhlYXRoZW4gSmFja2V0IGlzIHlvdXIgc2VjcmV0IHdlYXBvbiBhZ2FpbnN0IGhhcnNoIGFscGluZSBjb25kaXRpb25zLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzOTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1RORjQyOTMvSGVhdGhlbi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iSGVhdGhlbiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkY0MjkzJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjQyOTMvVGhlLU5vcnRoLUZhY2UtSGVhdGhlbi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkJ1aWx0IHdpdGggR29yZS1UZXggUHJvIFNoZWxsIGZhYnJpYyBmb3IgdWx0aW1hdGUgd2VhdGhlciBwcm90ZWN0aW9uIG9uIGxpZ2h0LWFuZC1mYXN0IGNsaW1iaW5nIG1pc3Npb25zLCBUaGUgTm9ydGggRmFjZSBNZW5zIEhlYXRoZW4gSmFja2V0IGlzIHlvdXIgc2VjcmV0IHdlYXBvbiBhZ2FpbnN0IGhhcnNoIGFscGluZSBjb25kaXRpb25zLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1RORjQ2MTQvVmFyaXVzLUd1aWRlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJWYXJpdXMgR3VpZGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvVE5GL1RORjQ2MTQvQVNQR1JFLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlZhcml1cyBHdWlkZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9UTkY0NjE0L1Zhcml1cy1HdWlkZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVmFyaXVzIEd1aWRlIEphY2tldCAtIE1lbiZhcG9zO3MiPlRoZSBOb3J0aCBGYWNlIFZhcml1cyBHdWlkZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIE5vcnRoIEZhY2UgTWVuJmFwb3M7cyBWYXJpdXMgR3VpZGUgSmFja2V0IGhhbmRsZXMgd2VhdGhlciBhYnVzZSBsaWtlIGEgcHJvIHdpdGhvdXQgZmVlbGluZyBsaWtlIGEgY3JpbmtseS1vbCZhcG9zOyBzdGlmZi4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQxOTguOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxNTkuMTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1RORjQ2MTQvVmFyaXVzLUd1aWRlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJWYXJpdXMgR3VpZGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9VE5GNDYxNCZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9UTkY0NjE0L1RoZS1Ob3J0aC1GYWNlLVZhcml1cy1HdWlkZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSBOb3J0aCBGYWNlIE1lbiZhcG9zO3MgVmFyaXVzIEd1aWRlIEphY2tldCBoYW5kbGVzIHdlYXRoZXIgYWJ1c2UgbGlrZSBhIHBybyB3aXRob3V0IGZlZWxpbmcgbGlrZSBhIGNyaW5rbHktb2wmYXBvczsgc3RpZmYuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDYxNS9Jbmx1eC1JbnN1bGF0ZWQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IklubHV4IEluc3VsYXRlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9UTkYvVE5GNDYxNS9BU1BHUkUuanBnIiBib3JkZXI9IjAiIGFsdD0iSW5sdXggSW5zdWxhdGVkIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1RORjQ2MTUvSW5sdXgtSW5zdWxhdGVkLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJJbmx1eCBJbnN1bGF0ZWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+VGhlIE5vcnRoIEZhY2UgSW5sdXggSW5zdWxhdGVkIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5aaXAgdXAgVGhlIE5vcnRoIEZhY2UgTWVucyBJbmx1eCBJbnN1bGF0ZWQgSmFja2V0IGZvciB0aG9zZSBlc3BlY2lhbGx5IGNoaWxseSBkYXlzIG9uIHRoZSBtb3VudGFpbi4gVGhlIEh5VmVudCAyTCB3b250IGxlYXZlIHlvdSBzb3BwaW5nIHdldCB3aGVuIHlvdSBkaXZlIGludG8gdGhlIGZyZXNobHkgZmFsbGVuIHBvdy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDE5OC45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDE1OS4xNjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfVE5GNDYxNS9Jbmx1eC1JbnN1bGF0ZWQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IklubHV4IEluc3VsYXRlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1UTkY0NjE1JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1RORjQ2MTUvVGhlLU5vcnRoLUZhY2UtSW5sdXgtSW5zdWxhdGVkLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iWmlwIHVwIFRoZSBOb3J0aCBGYWNlIE1lbnMgSW5sdXggSW5zdWxhdGVkIEphY2tldCBmb3IgdGhvc2UgZXNwZWNpYWxseSBjaGlsbHkgZGF5cyBvbiB0aGUgbW91bnRhaW4uIFRoZSBIeVZlbnQgMkwgd29udCBsZWF2ZSB5b3Ugc29wcGluZyB3ZXQgd2hlbiB5b3UgZGl2ZSBpbnRvIHRoZSBmcmVzaGx5IGZhbGxlbiBwb3cuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9XU0IwMDI4L1BlYWstdG8tQ3JlZWstSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlBlYWsgdG8gQ3JlZWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvV1NCL1dTQjAwMjgvQksuanBnIiBib3JkZXI9IjAiIGFsdD0iUGVhayB0byBDcmVlayBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9XU0IwMDI4L1BlYWstdG8tQ3JlZWstSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlBlYWsgdG8gQ3JlZWsgSmFja2V0IC0gTWVuJmFwb3M7cyI+V2VzdGJlYWNoIFBlYWsgdG8gQ3JlZWsgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPk5hbWVkIGFmdGVyIHRoZSBsZWdlbmRhcnkgV2hpc3RsZXIgcnVuLCB0aGUgV2VzdGJlYWNoIE1lbnMgUGVhayB0byBDcmVlayBKYWNrZXQgZmVhdHVyZXMgZHluYW1pYyB3ZWF0aGVyIHByb3RlY3Rpb24gZm9yIGNvbWZvcnRhYmxlIHJpZGluZyBpbiBhbnkgY29uZGl0aW9ucy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0NzMuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQxODkuNTg8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1dTQjAwMjgvUGVhay10by1DcmVlay1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iUGVhayB0byBDcmVlayBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1XU0IwMDI4JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1dTQjAwMjgvV2VzdGJlYWNoLVBlYWstdG8tQ3JlZWstSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJOYW1lZCBhZnRlciB0aGUgbGVnZW5kYXJ5IFdoaXN0bGVyIHJ1biwgdGhlIFdlc3RiZWFjaCBNZW5zIFBlYWsgdG8gQ3JlZWsgSmFja2V0IGZlYXR1cmVzIGR5bmFtaWMgd2VhdGhlciBwcm90ZWN0aW9uIGZvciBjb21mb3J0YWJsZSByaWRpbmcgaW4gYW55IGNvbmRpdGlvbnMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfV1RDMDAxMy9WYXBvci1GWC1Ib29kZWQtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IlZhcG9yIEZYIEhvb2RlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9XVEMwMDEzLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IlZhcG9yIEZYIEhvb2RlZCBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9XVEMwMDEzL1ZhcG9yLUZYLUhvb2RlZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iVmFwb3IgRlggSG9vZGVkIEphY2tldCAtIE1lbiZhcG9zO3MiPldlc3Rjb21iIFZhcG9yIEZYIEhvb2RlZCBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+VGhlIFdlc3Rjb21iIE1lbnMgVmFwb3IgRlggSG9vZHkgSmFja2V0IGN1dHMgdGhlIHdlaWdodHksIGZyaXZvbG91cyBleHRyYXMgYW5kIGdpdmVzIHlvdSBzdHJlYW1saW5lZCBwcm90ZWN0aW9uIGFuZCBwZXJmb3JtYW5jZSB0aGFua3MgdG8gZVZlbnQgd2F0ZXJwcm9vZiBicmVhdGhhYmxlIGZhYnJpYy4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ1NDkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ0MzkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1dUQzAwMTMvVmFwb3ItRlgtSG9vZGVkLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJWYXBvciBGWCBIb29kZWQgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9V1RDMDAxMyZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9XVEMwMDEzL1dlc3Rjb21iLVZhcG9yLUZYLUhvb2RlZC1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IlRoZSBXZXN0Y29tYiBNZW5zIFZhcG9yIEZYIEhvb2R5IEphY2tldCBjdXRzIHRoZSB3ZWlnaHR5LCBmcml2b2xvdXMgZXh0cmFzIGFuZCBnaXZlcyB5b3Ugc3RyZWFtbGluZWQgcHJvdGVjdGlvbiBhbmQgcGVyZm9ybWFuY2UgdGhhbmtzIHRvIGVWZW50IHdhdGVycHJvb2YgYnJlYXRoYWJsZSBmYWJyaWMuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfV1RDMDAyMi9DcnVpc2VyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJDcnVpc2VyIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL1dUQy9XVEMwMDIyL0JLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9IkNydWlzZXIgSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfV1RDMDAyMi9DcnVpc2VyLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJDcnVpc2VyIEphY2tldCAtIE1lbiZhcG9zO3MiPldlc3Rjb21iIENydWlzZXIgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPldlc3Rjb21iIGRpZCBhd2F5IHdpdGggYWxsIGV4dHJhbmVvdXMgZmVhdHVyZXNpbmNsdWRpbmcgdGhlIGZyb250IHppcHBlcnRvIGtlZXAgd2VpZ2h0IGRvd24gd2hpbGUgc3RpbGwgbWFraW5nIHRoZSBNZW5zIENydWlzZXIgSmFja2V0IHRvdWdoIGVub3VnaCBmb3IgdGhlIG1vdW50YWlucy48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzNDkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1dUQzAwMjIvQ3J1aXNlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQ3J1aXNlciBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1XVEMwMDIyJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL1dUQzAwMjIvV2VzdGNvbWItQ3J1aXNlci1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9Ildlc3Rjb21iIGRpZCBhd2F5IHdpdGggYWxsIGV4dHJhbmVvdXMgZmVhdHVyZXNpbmNsdWRpbmcgdGhlIGZyb250IHppcHBlcnRvIGtlZXAgd2VpZ2h0IGRvd24gd2hpbGUgc3RpbGwgbWFraW5nIHRoZSBNZW5zIENydWlzZXIgSmFja2V0IHRvdWdoIGVub3VnaCBmb3IgdGhlIG1vdW50YWlucy4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01IVzA2NzMvRXNjYXBlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJFc2NhcGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvTUhXL01IVzA2NzMvQkxJQ0UuanBnIiBib3JkZXI9IjAiIGFsdD0iRXNjYXBlIEphY2tldCAtIE1lbiZhcG9zO3MiPjwvYT48L3RkPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01IVzA2NzMvRXNjYXBlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJFc2NhcGUgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW91bnRhaW4gSGFyZHdlYXIgRXNjYXBlIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5MZWF2ZSB0aGUgY2l0eSBjb21tb3Rpb24gYmVoaW5kIHlvdSBhbmQgaGVhZCBpbnRvIHRoZSBiYWNrY291bnRyeSB3aXRoIHRoZSBNb3VudGFpbiBIYXJkd2VhciBNZW4mYXBvcztzIEVzY2FwZSBKYWNrZXQuIEdvcmUtVGV4IFBlcmZvcm1hbmNlIFNoZWxsIGJsb2NrcyBvdXQgc25vdyBhbmQgd2F0ZXIgd2hldGhlciB5b3Ugc2tpLCBjbGltYiBpY2UsIG9yIG9wdCBmb3IgYW4gYWxwaW5lIGFzY2VudC48L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3NfcHJpY2VfbGFiZWwiPlJldGFpbDo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19wcmljZSI+JDI0OS45NTwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlX2xhYmVsIj5PdXIgUHJpY2U6PC9mb250PiA8Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZSI+JDE5OS45NjwvZm9udD48L25vYnI+PC9wPgoJCTxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDY3My9Fc2NhcGUtSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkVzY2FwZSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NSFcwNjczJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01IVzA2NzMvTW91bnRhaW4tSGFyZHdlYXItRXNjYXBlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iTGVhdmUgdGhlIGNpdHkgY29tbW90aW9uIGJlaGluZCB5b3UgYW5kIGhlYWQgaW50byB0aGUgYmFja2NvdW50cnkgd2l0aCB0aGUgTW91bnRhaW4gSGFyZHdlYXIgTWVuJmFwb3M7cyBFc2NhcGUgSmFja2V0LiBHb3JlLVRleCBQZXJmb3JtYW5jZSBTaGVsbCBibG9ja3Mgb3V0IHNub3cgYW5kIHdhdGVyIHdoZXRoZXIgeW91IHNraSwgY2xpbWIgaWNlLCBvciBvcHQgZm9yIGFuIGFscGluZSBhc2NlbnQuIj5CdXkgTm93PC9hPjwvcD4KCQk8L3RkPgoJPC90cj4KCTx0cj48dGQgY29sc3Bhbj0zIGNsYXNzPSJ3c19zZXBlcmF0b3IiPiZuYnNwOzwvdGQ+PC90cj4KCTx0cj4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNTExL0JldGEtQVItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJldGEgQVIgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvQVJDL0FSQzA1MTEvQVouanBnIiBib3JkZXI9IjAiIGFsdD0iQmV0YSBBUiBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9BUkMwNTExL0JldGEtQVItSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJldGEgQVIgSmFja2V0IC0gTWVuJmFwb3M7cyI+QXJjJ3Rlcnl4IEJldGEgQVIgSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPkFyYyZhcG9zO3Rlcnl4IGNyZWF0ZWQgdGhlIE1lbiZhcG9zO3MgQmV0YSBBUiBKYWNrZXQgZm9yIG1vdW50YWluZWVycyBhbmQgc2tpZXJzIHdobyB3YW50IHRoZSBwZXJmb3JtYW5jZSBvZiBHb3JlLVRleCBQcm8gYW5kIHRvcC1ub3RjaCBkdXJhYmlsaXR5IHdpdGhvdXQgYSBsYXVuZHJ5IGxpc3Qgb2YgdW4tbmVlZGVkIGZlYXR1cmVzLiA8L3A+PC90ZD4KCQk8dGQ+CQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ0MjQuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0FSQzA1MTEvQmV0YS1BUi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQmV0YSBBUiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1BUkMwNTExJmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0FSQzA1MTEvQXJjdGVyeXgtQmV0YS1BUi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9IkFyYyZhcG9zO3Rlcnl4IGNyZWF0ZWQgdGhlIE1lbiZhcG9zO3MgQmV0YSBBUiBKYWNrZXQgZm9yIG1vdW50YWluZWVycyBhbmQgc2tpZXJzIHdobyB3YW50IHRoZSBwZXJmb3JtYW5jZSBvZiBHb3JlLVRleCBQcm8gYW5kIHRvcC1ub3RjaCBkdXJhYmlsaXR5IHdpdGhvdXQgYSBsYXVuZHJ5IGxpc3Qgb2YgdW4tbmVlZGVkIGZlYXR1cmVzLiAiPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X0NMVjAyMTkvS292ZW4tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IktvdmVuIEphY2tldCAtIE1lbiZhcG9zO3MiPjxpbWcgc3JjPSJodHRwOi8vY29udGVudC5iYWNrY291bnRyeS5jb20vaW1hZ2VzL2l0ZW1zL3NtYWxsL0NMVi9DTFYwMjE5L0NBSkUuanBnIiBib3JkZXI9IjAiIGFsdD0iS292ZW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfQ0xWMDIxOS9Lb3Zlbi1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iS292ZW4gSmFja2V0IC0gTWVuJmFwb3M7cyI+Q2xvdWR2ZWlsIEtvdmVuIEphY2tldCAtIE1lbiZhcG9zO3M8L2E+PHAgY2xhc3M9ImRlc2NyaXB0aW9uIj5UaGUgQ2xvdWR2ZWlsIE1lbiZhcG9zO3MgS292ZW4gSmFja2V0IG9mZmVycyB3YXRlcnRpZ2h0IHByb3RlY3Rpb24gZm9yIGhhcmRjb3JlIGZhbnMgb2YgdGhlIGJhY2tjb3VudHJ5LiBUaGlzIHNoZWxsJmFwb3M7cyBDbG91ZGJ1cnN0IFN0cmV0Y2ggRVYzIGZhYnJpYyBhbGxvd3MgeW91ciBzd2VhdHkgZXhoYXVzdCB0byBlc2NhcGUgYmVmb3JlIHlvdSBnZXQgY2xhbW15LjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kMzI5Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMTMxLjk4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9DTFYwMjE5L0tvdmVuLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJLb3ZlbiBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1DTFYwMjE5JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL0NMVjAyMTkvQ2xvdWR2ZWlsLUtvdmVuLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2J1eV9ub3ciIGFsdD0iVGhlIENsb3VkdmVpbCBNZW4mYXBvcztzIEtvdmVuIEphY2tldCBvZmZlcnMgd2F0ZXJ0aWdodCBwcm90ZWN0aW9uIGZvciBoYXJkY29yZSBmYW5zIG9mIHRoZSBiYWNrY291bnRyeS4gVGhpcyBzaGVsbCZhcG9zO3MgQ2xvdWRidXJzdCBTdHJldGNoIEVWMyBmYWJyaWMgYWxsb3dzIHlvdXIgc3dlYXR5IGV4aGF1c3QgdG8gZXNjYXBlIGJlZm9yZSB5b3UgZ2V0IGNsYW1teS4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjA4NzQvRXh1bS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iRXh1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NQVIvTUFSMDg3NC9CRUxDSVQuanBnIiBib3JkZXI9IjAiIGFsdD0iRXh1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NQVIwODc0L0V4dW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkV4dW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+TWFybW90IEV4dW0gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPldoZW4gZGFyayBjbG91ZHMgbG9vbSBhbmQgcmlkZ2VsaW5lIHdpbmRzIGhvd2wsIHlvdSZhcG9zO2xsIGJlIGdsYWQgeW91JmFwb3M7cmUgd2VhcmluZyB0aGUgTWFybW90IEV4dW0gSmFja2V0LiBXaXRoIEdvcmUtVGV4IFBybyAzLWxheWVyIGZhYnJpYyBhbmQgR2FsZSBGb3JjZSBob29kLCB0aGUgRXh1bSBwcm92aWRlcyBhIGJvbWJwcm9vZiBzdG9ybSBmb3J0cmVzcyB0aGF0IHN0YW5kcyB1cCB0byB0aGUgbmFzdGllc3Qgd2VhdGhlci4gPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQzOTkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQzMTkuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X01BUjA4NzQvRXh1bS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iRXh1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3JlIEluZm88L2E+PC9wPgo8cD48YSBocmVmPSJodHRwOi8vYWZmaWxpYXRlLmJhY2tjb3VudHJ5LmNvbS90cmFjay93c19idXkucGw/dWlkPSZhaWQ9MSZ3aWQ9OTgmdHQ9REYmZHQ9UCZkdj1NQVIwODc0JmlwPSZyZWY9JnVybD1odHRwOi8vd3d3LnRrcWxoY2UuY29tL2NsaWNrLTE2MzI4MzUtMTA0MzQ3MTY/VVJMPWh0dHA6Ly93d3cuYmFja2NvdW50cnkuY29tL3N0b3JlL01BUjA4NzQvTWFybW90LUV4dW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJXaGVuIGRhcmsgY2xvdWRzIGxvb20gYW5kIHJpZGdlbGluZSB3aW5kcyBob3dsLCB5b3UmYXBvcztsbCBiZSBnbGFkIHlvdSZhcG9zO3JlIHdlYXJpbmcgdGhlIE1hcm1vdCBFeHVtIEphY2tldC4gV2l0aCBHb3JlLVRleCBQcm8gMy1sYXllciBmYWJyaWMgYW5kIEdhbGUgRm9yY2UgaG9vZCwgdGhlIEV4dW0gcHJvdmlkZXMgYSBib21icHJvb2Ygc3Rvcm0gZm9ydHJlc3MgdGhhdCBzdGFuZHMgdXAgdG8gdGhlIG5hc3RpZXN0IHdlYXRoZXIuICI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+Cgk8dHI+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDY2Ny9CZXJ5bGxpdW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJlcnlsbGl1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj48aW1nIHNyYz0iaHR0cDovL2NvbnRlbnQuYmFja2NvdW50cnkuY29tL2ltYWdlcy9pdGVtcy9zbWFsbC9NSFcvTUhXMDY2Ny9CSy5qcGciIGJvcmRlcj0iMCIgYWx0PSJCZXJ5bGxpdW0gSmFja2V0IC0gTWVuJmFwb3M7cyI+PC9hPjwvdGQ+CgkJPHRkPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ28tdXRhaC5jb20vYmMvZ2Vhci5waHAvUC0xMV8yMF8xMDAwMDAxMjRfTUhXMDY2Ny9CZXJ5bGxpdW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYm9keV9saW5rIiBhbHQ9IkJlcnlsbGl1bSBKYWNrZXQgLSBNZW4mYXBvcztzIj5Nb3VudGFpbiBIYXJkd2VhciBCZXJ5bGxpdW0gSmFja2V0IC0gTWVuJmFwb3M7czwvYT48cCBjbGFzcz0iZGVzY3JpcHRpb24iPlRoZSBNb3VudGFpbiBIYXJkd2VhciBNZW4mYXBvcztzIEJlcnlsbGl1bSBKYWNrZXQgcHJvdmlkZXMgeW91IHdpdGggdGhlIGFydGljdWxhdGVkIGN1dCwgd2F0ZXJwcm9vZiBmYWJyaWMsIGFuZCB3aWNraW5nIHByb3BlcnRpZXMgeW91IG5lZWQgZm9yIGEgbXVsdGktcGl0Y2ggaWNlIGNsaW1iLjwvcD48L3RkPgoJCTx0ZD4JCTxwPjxub2JyPjxmb250IGNsYXNzPSJ3c19wcmljZV9sYWJlbCI+UmV0YWlsOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3ByaWNlIj4kNDc0Ljk1PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2VfbGFiZWwiPk91ciBQcmljZTo8L2ZvbnQ+IDxmb250IGNsYXNzPSJ3c19zYWxlX3ByaWNlIj4kMjM3LjQ4PC9mb250Pjwvbm9icj48L3A+CgkJPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9NSFcwNjY3L0JlcnlsbGl1bS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iQmVyeWxsaXVtIEphY2tldCAtIE1lbiZhcG9zO3MiPk1vcmUgSW5mbzwvYT48L3A+CjxwPjxhIGhyZWY9Imh0dHA6Ly9hZmZpbGlhdGUuYmFja2NvdW50cnkuY29tL3RyYWNrL3dzX2J1eS5wbD91aWQ9JmFpZD0xJndpZD05OCZ0dD1ERiZkdD1QJmR2PU1IVzA2NjcmaXA9JnJlZj0mdXJsPWh0dHA6Ly93d3cudGtxbGhjZS5jb20vY2xpY2stMTYzMjgzNS0xMDQzNDcxNj9VUkw9aHR0cDovL3d3dy5iYWNrY291bnRyeS5jb20vc3RvcmUvTUhXMDY2Ny9Nb3VudGFpbi1IYXJkd2Vhci1CZXJ5bGxpdW0tSmFja2V0LS1NZW5hcG9zcy5odG1sIiBjbGFzcz0id3NfYnV5X25vdyIgYWx0PSJUaGUgTW91bnRhaW4gSGFyZHdlYXIgTWVuJmFwb3M7cyBCZXJ5bGxpdW0gSmFja2V0IHByb3ZpZGVzIHlvdSB3aXRoIHRoZSBhcnRpY3VsYXRlZCBjdXQsIHdhdGVycHJvb2YgZmFicmljLCBhbmQgd2lja2luZyBwcm9wZXJ0aWVzIHlvdSBuZWVkIGZvciBhIG11bHRpLXBpdGNoIGljZSBjbGltYi4iPkJ1eSBOb3c8L2E+PC9wPgoJCTwvdGQ+Cgk8L3RyPgoJPHRyPjx0ZCBjb2xzcGFuPTMgY2xhc3M9IndzX3NlcGVyYXRvciI+Jm5ic3A7PC90ZD48L3RyPgoJPHRyPgoJCTx0ZD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1dUQzAwMDUvTWlyYWdlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNaXJhZ2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+PGltZyBzcmM9Imh0dHA6Ly9jb250ZW50LmJhY2tjb3VudHJ5LmNvbS9pbWFnZXMvaXRlbXMvc21hbGwvV1RDL1dUQzAwMDUvQkxLLmpwZyIgYm9yZGVyPSIwIiBhbHQ9Ik1pcmFnZSBKYWNrZXQgLSBNZW4mYXBvcztzIj48L2E+PC90ZD4KCQk8dGQ+PGEgaHJlZj0iaHR0cDovL3d3dy5nby11dGFoLmNvbS9iYy9nZWFyLnBocC9QLTExXzIwXzEwMDAwMDEyNF9XVEMwMDA1L01pcmFnZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19ib2R5X2xpbmsiIGFsdD0iTWlyYWdlIEphY2tldCAtIE1lbiZhcG9zO3MiPldlc3Rjb21iIE1pcmFnZSBKYWNrZXQgLSBNZW4mYXBvcztzPC9hPjxwIGNsYXNzPSJkZXNjcmlwdGlvbiI+TWFueSB3YXRlcnByb29mIHNoZWxscyBkb24mYXBvczt0IGJyZWF0aGUgd29ydGggYSBkYW1uLiBUaGUgV2VzdGNvbWIgTWVuJmFwb3M7cyBNaXJhZ2UgSmFja2V0IGhhcyBlVmVudCBmYWJyaWMgdGhhdCBibG9ja3MgbW9pc3R1cmUgYW5kIGJyZWF0aGVzIGxpa2UgY3JhenkuPC9wPjwvdGQ+CgkJPHRkPgkJPHA+PG5vYnI+PGZvbnQgY2xhc3M9IndzX3ByaWNlX2xhYmVsIj5SZXRhaWw6PC9mb250PiA8Zm9udCBjbGFzcz0id3NfcHJpY2UiPiQ0NDkuOTU8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48bm9icj48Zm9udCBjbGFzcz0id3Nfc2FsZV9wcmljZV9sYWJlbCI+T3VyIFByaWNlOjwvZm9udD4gPGZvbnQgY2xhc3M9IndzX3NhbGVfcHJpY2UiPiQ0MDQuOTY8L2ZvbnQ+PC9ub2JyPjwvcD4KCQk8cD48YSBocmVmPSJodHRwOi8vd3d3LmdvLXV0YWguY29tL2JjL2dlYXIucGhwL1AtMTFfMjBfMTAwMDAwMTI0X1dUQzAwMDUvTWlyYWdlLUphY2tldC0tTWVuYXBvc3MuaHRtbCIgY2xhc3M9IndzX2JvZHlfbGluayIgYWx0PSJNaXJhZ2UgSmFja2V0IC0gTWVuJmFwb3M7cyI+TW9yZSBJbmZvPC9hPjwvcD4KPHA+PGEgaHJlZj0iaHR0cDovL2FmZmlsaWF0ZS5iYWNrY291bnRyeS5jb20vdHJhY2svd3NfYnV5LnBsP3VpZD0mYWlkPTEmd2lkPTk4JnR0PURGJmR0PVAmZHY9V1RDMDAwNSZpcD0mcmVmPSZ1cmw9aHR0cDovL3d3dy50a3FsaGNlLmNvbS9jbGljay0xNjMyODM1LTEwNDM0NzE2P1VSTD1odHRwOi8vd3d3LmJhY2tjb3VudHJ5LmNvbS9zdG9yZS9XVEMwMDA1L1dlc3Rjb21iLU1pcmFnZS1KYWNrZXQtLU1lbmFwb3NzLmh0bWwiIGNsYXNzPSJ3c19idXlfbm93IiBhbHQ9Ik1hbnkgd2F0ZXJwcm9vZiBzaGVsbHMgZG9uJmFwb3M7dCBicmVhdGhlIHdvcnRoIGEgZGFtbi4gVGhlIFdlc3Rjb21iIE1lbiZhcG9zO3MgTWlyYWdlIEphY2tldCBoYXMgZVZlbnQgZmFicmljIHRoYXQgYmxvY2tzIG1vaXN0dXJlIGFuZCBicmVhdGhlcyBsaWtlIGNyYXp5LiI+QnV5IE5vdzwvYT48L3A+CgkJPC90ZD4KCTwvdHI+Cgk8dHI+PHRkIGNvbHNwYW49MyBjbGFzcz0id3Nfc2VwZXJhdG9yIj4mbmJzcDs8L3RkPjwvdHI+CjwvdGFibGU+ |
|
