PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSI/Pgo8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+CjxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiBsYW5nPSJlcyIgeG1sOmxhbmc9ImVzIj48aGVhZD4KPG1ldGEgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgLz4KPCEtLQogICAgICAgIFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYCiAgICAgICAgICAgICAgVGhpcyBmaWxlIGlzIGdlbmVyYXRlZCBmcm9tIHhtbCBzb3VyY2U6IERPIE5PVCBFRElUCiAgICAgICAgWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFgKICAgICAgLS0+Cjx0aXRsZT5HbG9zYXJpbyAtIFNlcnZpZG9yIEhUVFAgQXBhY2hlIFZlcnNp824gMi41PC90aXRsZT4KPGxpbmsgaHJlZj0iLi9zdHlsZS9jc3MvbWFudWFsLmNzcyIgcmVsPSJzdHlsZXNoZWV0IiBtZWRpYT0iYWxsIiB0eXBlPSJ0ZXh0L2NzcyIgdGl0bGU9Ik1haW4gc3R5bGVzaGVldCIgLz4KPGxpbmsgaHJlZj0iLi9zdHlsZS9jc3MvbWFudWFsLWxvb3NlLTEwMHBjLmNzcyIgcmVsPSJhbHRlcm5hdGUgc3R5bGVzaGVldCIgbWVkaWE9ImFsbCIgdHlwZT0idGV4dC9jc3MiIHRpdGxlPSJObyBTaWRlYmFyIC0gRGVmYXVsdCBmb250IHNpemUiIC8+CjxsaW5rIGhyZWY9Ii4vc3R5bGUvY3NzL21hbnVhbC1wcmludC5jc3MiIHJlbD0ic3R5bGVzaGVldCIgbWVkaWE9InByaW50IiB0eXBlPSJ0ZXh0L2NzcyIgLz48bGluayByZWw9InN0eWxlc2hlZXQiIHR5cGU9InRleHQvY3NzIiBocmVmPSIuL3N0eWxlL2Nzcy9wcmV0dGlmeS5jc3MiIC8+CjxzY3JpcHQgc3JjPSIuL3N0eWxlL3NjcmlwdHMvcHJldHRpZnkubWluLmpzIiB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgo8L3NjcmlwdD4KCjxsaW5rIGhyZWY9Ii4vaW1hZ2VzL2Zhdmljb24uaWNvIiByZWw9InNob3J0Y3V0IGljb24iIC8+PC9oZWFkPgo8Ym9keSBpZD0ibWFudWFsLXBhZ2UiIGNsYXNzPSJuby1zaWRlYmFyIj48ZGl2IGlkPSJwYWdlLWhlYWRlciI+CjxwIGNsYXNzPSJtZW51Ij48YSBocmVmPSIuL21vZC8iPk3zZHVsb3M8L2E+IHwgPGEgaHJlZj0iLi9tb2QvcXVpY2tyZWZlcmVuY2UuaHRtbCI+RGlyZWN0aXZhczwvYT4gfCA8YSBocmVmPSJodHRwOi8vd2lraS5hcGFjaGUub3JnL2h0dHBkL0ZBUSI+UHJlZ3VudGFzIEZyZWN1ZW50ZXM8L2E+IHwgPGEgaHJlZj0iLi9nbG9zc2FyeS5odG1sIj5HbG9zYXJpbzwvYT4gfCA8YSBocmVmPSIuL3NpdGVtYXAuaHRtbCI+TWFwYSBkZWwgc2l0aW8gd2ViPC9hPjwvcD4KPHAgY2xhc3M9ImFwYWNoZSI+VmVyc2nzbiAyLjUgZGVsIFNlcnZpZG9yIEhUVFAgQXBhY2hlPC9wPgo8aW1nIGFsdD0iIiBzcmM9Ii4vaW1hZ2VzL2ZlYXRoZXIucG5nIiAvPjwvZGl2Pgo8ZGl2IGNsYXNzPSJ1cCI+PGEgaHJlZj0iLi8iPjxpbWcgdGl0bGU9IiZsdDstIiBhbHQ9IiZsdDstIiBzcmM9Ii4vaW1hZ2VzL2xlZnQuZ2lmIiAvPjwvYT48L2Rpdj4KPGRpdiBpZD0icGF0aCI+CjxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy8iPkFwYWNoZTwvYT4gJmd0OyA8YSBocmVmPSJodHRwOi8vaHR0cGQuYXBhY2hlLm9yZy8iPlNlcnZpZG9yIEhUVFA8L2E+ICZndDsgPGEgaHJlZj0iaHR0cDovL2h0dHBkLmFwYWNoZS5vcmcvZG9jcy8iPkRvY3VtZW50YWNp8248L2E+ICZndDsgPGEgaHJlZj0iLi8iPlZlcnNp824gMi41PC9hPjwvZGl2PjxkaXYgaWQ9InBhZ2UtY29udGVudCI+PGRpdiBpZD0icHJlYW1ibGUiPjxoMT5HbG9zYXJpbzwvaDE+CjxkaXYgY2xhc3M9InRvcGxhbmciPgo8cD48c3Bhbj5JZGlvbWFzIGRpc3BvbmlibGVzOiA8L3NwYW4+PGEgaHJlZj0iLi9kZS9nbG9zc2FyeS5odG1sIiBocmVmbGFuZz0iZGUiIHJlbD0iYWx0ZXJuYXRlIiB0aXRsZT0iRGV1dHNjaCI+Jm5ic3A7ZGUmbmJzcDs8L2E+IHwKPGEgaHJlZj0iLi9lbi9nbG9zc2FyeS5odG1sIiBocmVmbGFuZz0iZW4iIHJlbD0iYWx0ZXJuYXRlIiB0aXRsZT0iRW5nbGlzaCI+Jm5ic3A7ZW4mbmJzcDs8L2E+IHwKPGEgaHJlZj0iLi9lcy9nbG9zc2FyeS5odG1sIiB0aXRsZT0iRXNwYfFvbCI+Jm5ic3A7ZXMmbmJzcDs8L2E+IHwKPGEgaHJlZj0iLi9mci9nbG9zc2FyeS5odG1sIiBocmVmbGFuZz0iZnIiIHJlbD0iYWx0ZXJuYXRlIiB0aXRsZT0iRnJhbudhaXMiPiZuYnNwO2ZyJm5ic3A7PC9hPiB8CjxhIGhyZWY9Ii4vamEvZ2xvc3NhcnkuaHRtbCIgaHJlZmxhbmc9ImphIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IkphcGFuZXNlIj4mbmJzcDtqYSZuYnNwOzwvYT4gfAo8YSBocmVmPSIuL2tvL2dsb3NzYXJ5Lmh0bWwiIGhyZWZsYW5nPSJrbyIgcmVsPSJhbHRlcm5hdGUiIHRpdGxlPSJLb3JlYW4iPiZuYnNwO2tvJm5ic3A7PC9hPiB8CjxhIGhyZWY9Ii4vdHIvZ2xvc3NhcnkuaHRtbCIgaHJlZmxhbmc9InRyIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IlT8cmvnZSI+Jm5ic3A7dHImbmJzcDs8L2E+PC9wPgo8L2Rpdj4KCgk8cD7Jc3RlIGdsb3NhcmlvIGRlZmluZSBsYXMgdGVybWlub2xvZ+1hcyBt4XMgY29tdW5lcwoJcmVsYWNpb25hZGEgY29uIEFwYWNoZSBlbiBwYXJ0aWN1bGFyLCB5IGNvbiBsb3Mgc2Vydmlkb3JlcyB3ZWIgZW4KCWdlbmVyYWwuIEVuIGxvcyBlbmxhY2VzIHF1ZSBoYXkgYXNvY2lhZG9zIGEgY2FkYSB06XJtaW5vIHNlIHB1ZWRlCgllbmNvbnRyYXIgaW5mb3JtYWNp824gbeFzIGRldGFsbGFkYSBkZSBjYWRhIHVuby48L3A+Cgk8L2Rpdj4KPGRpdiBjbGFzcz0idG9wIj48YSBocmVmPSIjcGFnZS1oZWFkZXIiPjxpbWcgYWx0PSJ0b3AiIHNyYz0iLi9pbWFnZXMvdXAuZ2lmIiAvPjwvYT48L2Rpdj4KPGRpdiBjbGFzcz0ic2VjdGlvbiI+CjxoMj48YSBuYW1lPSJkZWZpbml0aW9ucyIgaWQ9ImRlZmluaXRpb25zIj5EZWZpbmljaW9uZXM8L2E+PC9oMj4KCQk8ZGw+CgkJPGR0PjxhIG5hbWU9ImFsZ29yaXRobSIgaWQ9ImFsZ29yaXRobSI+QWxnb3JpdG1vPC9hPjwvZHQ+CgkJPGRkPlVuIHByb2Nlc28gZGVmaW5pZG8gc2luIGFtYmln/GVkYWRlcyBvIHVuIGNvbmp1bnRvIGRlIHJlZ2xhcyAKCQlwYXJhIHNvbHVjaW9uYXIgdW4gcHJvYmxlbWEgZW4gdW4gbvptZXJvIGZpbml0byBkZSBwYXNvcy4KCQlMb3MgYWxnb3JpdG1vcyBwYXJhIGVuY3JpcHRhciBzZSBsbGFtYW4KCQlub3JtYWxtZW50ZSA8ZGZuPmFsZ29yaXRtb3MgZGUgY2lmcmFkbzwvZGZuPi4KCQk8L2RkPgoKCgkJPGR0PjxhIG5hbWU9ImNpcGhlciIgaWQ9ImNpcGhlciI+QWxnb3JpdG1vIGRlIGNpZnJhZG8sIChDaXBoZXIpLiA8L2E+PC9kdD4KCQk8ZGQ+RXMgdW4gYWxnb3JpdG1vIG8gc2lzdGVtYSBkZSBlbmNyaXB0YWRvIGRlIGluZm9ybWFjafNuLiAKCQlFamVtcGxvcyBkZSBlc3RvcyBhbGdvcml0bW9zIHNvbiBERVMsIElERUEsIFJDNCwgZXRjLjxiciAvPgoJCUNvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvIFNTTC9UTFM8L2E+PC9kZD4KCgkJPGR0PjxhIG5hbWU9ImF1dGhlbnRpY2F0aW9uIiBpZD0iYXV0aGVudGljYXRpb24iPkF1dGVudGljYWNp824uPC9hPjwvZHQ+CgkJPGRkPkxhIGlkZW50aWZpY2FjafNuIHBvc2l0aXZhIGRlIHVuYSBlbnRpZGFkIGRlIHJlZCB0YWwgY29tbyB1bgoJCXNlcnZpZG9yLCB1biBjbGllbnRlLCBvIHVuIHVzdWFyaW8uPGJyIC8+IAoJCUNvbnN1bHRlOiA8YSBocmVmPSJob3d0by9hdXRoLmh0bWwiPkF1dGVudGlmaWNhY2nzbiwgQXV0b3JpemFjafNuLCAKCQl5IENvbnRyb2wgZGUgQWNjZXNvPC9hPjwvZGQ+CgoKCQk8ZHQ+PGEgbmFtZT0iY2VydGlmaWNhdGlvbmF1dGhvcml0eSIgaWQ9ImNlcnRpZmljYXRpb25hdXRob3JpdHkiPkF1dG9yaWRhZCBDZXJ0aWZpY2Fkb3JhLjwvYT4gPGEgbmFtZT0iY2EiPihDQSk8L2E+PC9kdD4gPGRkPkVzIHVuYSBlbnRpZGFkIGV4dGVybmEgZGUgY29uZmlhbnphIGN1eW8gZmluCgkJZXMgZmlybWFyIGNlcnRpZmljYWRvcyBwYXJhIGxhcyBlbnRpZGFkZXMgZGUgcmVkIHF1ZSBoYSBhdXRlbnRpZmljYWRvCgkJdXNhbmRvIG1lZGlvcyBzZWd1cm9zLiBPdHJhcyBlbnRpZGFkZXMgZGUgcmVkIHB1ZWRlbiB2ZXJpZmljYXIgbGEKCQlmaXJtYSBwYXJhIGNvbXByb2JhciBxdWUgdW5hIEF1dG9yaWRhZCBDZXJ0aWZpY2Fkb3JhIGhhIGF1dGVudGlmaWNhZG8KCQlhbCBwb3NlZWRvciBkZWwgY2VydGlmaWNhZG8uPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvCgkJU1NML1RMUzwvYT48L2RkPgoKCgkJPGR0PjxhIG5hbWU9ImhlYWRlciIgaWQ9ImhlYWRlciI+Q2FiZWNlcmEuPC9hPjwvZHQ+IDxkZD5FcyBsYSBwYXJ0ZSBkZSBsYQoJCXBldGljafNuIHkgbGEgcmVzcHVlc3RhIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNodHRwIiB0aXRsZT0idmVyIGdsb3NhcmlvIj5IVFRQPC9hPiBxdWUgc2UKCQllbnbtYSBhbnRlcyBkZWwgY29udGVuaWRvIHByb3BpYW1lbnRlIGRpY2hvLCB5IHF1ZSBjb250aWVuZQoJCW1ldGEtaW5mb3JtYWNp824gZGVzY3JpYmllbmRvIGVsIGNvbnRlbmlkby48L2RkPgoKCQk8ZHQ+PGEgbmFtZT0iY2VydGlmaWNhdGUiIGlkPSJjZXJ0aWZpY2F0ZSI+Q2VydGlmaWNhZG8uPC9hPjwvZHQ+CgkJPGRkPlVuYSBpbmZvcm1hY2nzbiBxdWUgc2UgYWxtYWNlbmEgcGFyYSBhdXRlbnRpY2FyIGVudGlkYWRlcwoJCWRlIHJlZCB0YWxlcyBjb21vIHVuIHNlcnZpZG9yIG8gdW4gY2xpZW50ZS4gVW4gY2VydGlmaWNhZG8KCQljb250aWVuZSBwaWV6YXMgZGUgaW5mb3JtYWNp824gWC41MDkgc29icmUgc3UgcG9zZWVkb3IKCQkobGxhbWFkbyBzdWpldG8pIHkgc29icmUgbGEgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2NlcnRpZmljYXRpb25hdXRob3JpdHkiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPkF1dG9yaWRhZCBDZXJ0aWZpY2Fkb3JhPC9hPgoJCShsbGFtYWRhIGVsIGVtaXNvcikgcXVlIGxvIGZpcm1hLCBt4XMgbGEgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI3B1YmxpY2tleSIgdGl0bGU9InZlciBnbG9zYXJpbyI+Y2xhdmUgcPpibGljYTwvYT4gZGVsIHByb3BpZXRhcmlvIHkgbGEgZmlybWEgZGUKCQlsYSBBQyhBdXRvcmlkYWQgQ2VydGlmaWNhZG9yYSkuIExhcyBlbnRpZGFkZXMgZGUgcmVkIHZlcmlmaWNhbiBsYXMgZmlybWFzIHVzYW5kbwoJCWNlcnRpZmljYWRvcyBkZSBsYXMgQUMuPGJyIC8+CgkJQ29uc3VsdGU6IDxhIGhyZWY9InNzbC8iPkVuY3JpcHRhZG8gU1NML1RMUzwvYT4KCQk8L2RkPgoKCgoJCTxkdD48YSBuYW1lPSJwdWJsaWNrZXkiIGlkPSJwdWJsaWNrZXkiPkNsYXZlIFD6YmxpY2EuPC9hPjwvZHQ+IAoJCTxkZD5MYSBjbGF2ZSBkaXNwb25pYmxlCgkJcPpibGljYW1lbnRlIGVuIHVuIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNwdWJsaWNrZXljcnlwdG9ncmFwaHkiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPnNpc3RlbWEKCQljcmlwdG9ncuFmaWNvIGRlIENsYXZlIFD6YmxpY2E8L2E+LCB1c2FkbyBwYXJhIGVuY3JpcHRhcgoJCW1lbnNhamVzIGRlc3RpbmFkb3MgYSBzdSBwcm9waWV0YXJpbyB5IHBhcmEgZGVzZW5jcmlwdGFyIGZpcm1hcyBoZWNoYXMKCQlwb3Igc3UgcHJvcGlldGFyaW8uPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvCgkJU1NML1RMUzwvYT48L2RkPgoKCgoJCTxkdD48YSBuYW1lPSJwcml2YXRla2V5IiBpZD0icHJpdmF0ZWtleSI+Q2xhdmUgUHJpdmFkYS48L2E+PC9kdD4KCQk8ZGQ+TGEgY2xhdmUgc2VjcmV0YQoJCWRlIHVuIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNwdWJsaWNrZXljcnlwdG9ncmFwaHkiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPlNpc3RlbWEgY3JpcHRvZ3LhZmljbyBkZQoJCUNsYXZlIFD6YmxpY2E8L2E+LCB1c2FkYSBwYXJhIGRlc2VuY3JpcHRhciBsb3MgbWVuc2FqZXMgZW50cmFudGVzCgkJeSBmaXJtYXIgbG9zIHNhbGllbnRlcy48YnIgLz4gQ29uc3VsdGU6IDxhIGhyZWY9InNzbC8iPkVuY3JpcHRhZG8KCQlTU0wvVExTPC9hPjwvZGQ+CgoKCQk8ZHQ+PGEgbmFtZT0iY29ubmVjdCIgaWQ9ImNvbm5lY3QiPkNPTk5FQ1Q8L2E+PC9kdD4gPGRkPlVuIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNtZXRob2QiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPm3pdG9kbzwvYT4gZGUgSFRUUCBwYXJhIGhhY2VyIHByb3h5IGEgY2FuYWxlcyBkZQoJCWRhdG9zIHNpbiB1c2FyIEhUVFAuIFB1ZWRlIHVzYXJzZSBwYXJhIGVuY2Fwc3VsYXIgb3Ryb3MgcHJvdG9jb2xvcywKCQl0YWxlcyBjb21vIGVsIHByb3RvY29sbyBTU0wuPC9kZD4KCgoKCQk8ZHQ+PGEgbmFtZT0iY29udGV4dCIgaWQ9ImNvbnRleHQiPkNvbnRleHRvPC9hPjwvZHQ+IDxkZD5VbiDhcmVhIGVuIGxvcwoJCTxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNjb25maWd1cmF0aW9uZmlsZSIgdGl0bGU9InZlciBnbG9zYXJpbyI+ZmljaGVyb3MgZGUgY29uZmlndXJhY2nzbjwvYT4KCQlkb25kZSBlc3ThbiBwZXJtaXRpZG9zIGNpZXJ0b3MgdGlwb3MgZGUgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2RpcmVjdGl2ZSIgdGl0bGU9InZlciBnbG9zYXJpbyI+ZGlyZWN0aXZhczwvYT4uPGJyIC8+CgkJQ29uc3VsdGU6IDxhIGhyZWY9Im1vZC9kaXJlY3RpdmUtZGljdC5odG1sI0NvbnRleHQiPlTpcm1pbm9zIAoJCXVzYWRvcyBwYXJhIGRlc2NyaWJpciBsYXMgZGlyZWN0aXZhcyBkZSBBcGFjaGU8L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJhY2Nlc3Njb250cm9sIiBpZD0iYWNjZXNzY29udHJvbCI+Q29udHJvbCBkZSBBY2Nlc28uPC9hPjwvZHQ+IAoJCTxkZD5MYQoJCXJlc3RyaWNjafNuIGVuIGVsIGFjY2VzbyBhbCBlbnRvcm5vIGRlIHVuYSByZWQuIEVuIGVsIGNvbnRleHRvIGRlCgkJQXBhY2hlIHNpZ25pZmljYSBub3JtYWxtZW50ZSBsYSByZXN0cmljY2nzbiBlbiBlbCBhY2Nlc28gYQoJCWNpZXJ0YXMgPGVtPlVSTHM8L2VtPi48YnIgLz4gCgkJQ29uc3VsdGU6IDxhIGhyZWY9Imhvd3RvL2F1dGguaHRtbCI+QXV0ZW50aWZpY2FjafNuLCBBdXRvcml6YWNp824sIHkKCQlDb250cm9sIGRlIEFjY2VzbzwvYT48L2RkPgoKCgkJPGR0PjxhIG5hbWU9InN5bW1ldHJpY2NyeXB0b3BocmFwaHkiPkNyaXB0b2dyYWbtYQoJCVNpbel0cmljYTwvYT48L2R0PiA8ZGQ+RWwgZXN0dWRpbyB5IGFwbGljYWNp824gZGUKCQk8ZW0+QWxnb3JpdG1vcyBkZSBDaWZyYWRvPC9lbT4gcXVlIHVzYW4gdW5hIHNvbGEgY2xhdmUgc2VjcmV0YSB0YW50bwoJCXBhcmEgY2lmcmFyIGNvbW8gcGFyYSBkZXNjaWZyYXIuPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvIFNTTC9UTFM8L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJkaXJlY3RpdmUiIGlkPSJkaXJlY3RpdmUiPkRpcmVjdGl2YTwvYT48L2R0PgoJCTxkZD5VbiBjb21hbmRvIGRlCgkJY29uZmlndXJhY2nzbiBxdWUgY29udHJvbGEgdW5vIG8gbeFzIGFzcGVjdG9zIGRlbAoJCWNvbXBvcnRhbWllbnRvIGRlIEFwYWNoZS4gIExhcyBkaXJlY3RpdmFzIHNlIHBvbmVuIGVuIGVsIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNjb25maWd1cmF0aW9uZmlsZSIgdGl0bGU9InZlciBnbG9zYXJpbyI+RmljaGVybyBkZSBDb25maWd1cmFjafNuPC9hPjxiciAvPgoJCUNvbnN1bHRlOiA8YSBocmVmPSJtb2QvZGlyZWN0aXZlcy5odG1sIj7NbmRpY2UgZGUKCQlEaXJlY3RpdmFzPC9hPjwvZGQ+CgoJCTxkdD48YSBuYW1lPSJjb25maWd1cmF0aW9uZGlyZWN0aXZlIiBpZD0iY29uZmlndXJhdGlvbmRpcmVjdGl2ZSI+RGlyZWN0aXZhcyBkZQoJCWNvbmZpZ3VyYWNp824uPC9hPjwvZHQ+IDxkZD5Db25zdWx0ZTogPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2RpcmVjdGl2ZSIgdGl0bGU9InZlciBnbG9zYXJpbyI+RGlyZWN0aXZhczwvYT48L2RkPgoKCQk8ZHQ+PGEgbmFtZT0iYXBhY2hlcG9ydGFibGVydW50aW1lIiBpZD0iYXBhY2hlcG9ydGFibGVydW50aW1lIj5FbnRvcm5vIFBvcnRhYmxlIGRlIHRpZW1wbyBkZSBlamVjdWNp824gZGUgQXBhY2hlLCA8L2E+IDxhIG5hbWU9ImFwciIgaWQ9ImFwciI+KEFQUiwgQXBhY2hlIFBvcnRhYmxlIFJ1bnRpbWUpPC9hPjwvZHQ+CgkJPGRkPkVzIHVuIGNvbmp1bnRvIGRlIGxpYnJlcu1hcyBxdWUgcHJvdmVlbiBsYXMgaW50ZXJmYWNlcyBi4XNpY2FzIAoJCWVudHJlIGVsIHNlcnZpZG9yIHkgZWwgc2lzdGVtYSBvcGVyYXRpdm8uIEVsIGRlc2Fycm9sbG8gZGUgQVBSIGVzIAoJCXBhcmFsZWxvIGFsIGRlbCBTZXJ2aWRvciBIVFRQIEFwYWNoZSwgY29tbyB1biBwcm95ZWN0byBpbmRlcGVuZGllbnRlLiAKCQlQdWVkZXMgdmlzaXRhciBlbCBwcm95ZWN0byBlbjo8YnIgLz4KCQk8YSBocmVmPSJodHRwOi8vYXByLmFwYWNoZS5vcmcvIj5BcGFjaGUgUG9ydGFibGUgUnVudGltZQoJCVByb2plY3Q8L2E+CgkJPC9kZD4KCgkJPGR0PjxhIG5hbWU9ImV4cG9ydC1jcmlwcGxlZCIgaWQ9ImV4cG9ydC1jcmlwcGxlZCI+RXhwb3J0LUNyaXBwbGVkPC9hPjwvZHQ+CgkJPGRkPkRpc21pbnVjafNuIGRlIGxhIGZvcnRhbGV6YSBjcmlwdG9ncuFmaWNhICh5IHNlZ3VyaWRhZCkKCQlwYXJhIGN1bXBsaXIgY29uIGxhcyBSZWd1bGFjaW9uZXMgc29icmUgRXhwb3J0YWNp824gZGUgbGEKCQlBZG1pbmlzdHJhY2nzbiBkZSBsb3MgRXN0YWRvcyBVbmlkb3MgKEVBUikuIEVsIHNvZnR3YXJlCgkJY3JpcHRvZ3LhZmljbyBFeHBvcnQtY3JpcHBsZWQgZXN04SBsaW1pdGFkbyBhIHVuYSBjbGF2ZSBkZQoJCXBlcXVl8W8gdGFtYfFvLCBkZSB0YWwgbWFuZXJhIHF1ZSBlbCA8ZW0+dGV4dG8gY2lmcmFkbzwvZW0+CgkJcXVlIHNlIGNvbnNpZ3VlIGNvbiDpbCwgcHVlZGUgZGVzY2lmcmFyc2UgcG9yIG1lZGlvIGRlIGZ1ZXJ6YSBicnV0YS48YnIgLz4gQ29uc3VsdGU6IDxhIGhyZWY9InNzbC8iPkVuY3JpcHRhZG8gU1NML1RMUzwvYT48L2RkPgoKCgkJPGR0PjxhIG5hbWU9InJlZ3VsYXJleHByZXNpb24iIGlkPSJyZWd1bGFyZXhwcmVzaW9uIj5FeHByZXNpb25lcyBSZWd1bGFyZXM8L2E+IAoJCTxhIG5hbWU9InJlZ2V4Ij4oUmVnZXgpPC9hPjwvZHQ+IDxkZD5VbmEgZm9ybWEgZGUgZGVzY3JpYmlyIHVuIHBhdHLzbiBlbiB1biAKCQl0ZXh0byAtIHBvciBlamVtcGxvLCAidG9kYXMgbGFzIHBhbGFicmFzIHF1ZSBlbXBpZXphbiBjb24gbGEgbGV0cmEgIkEiCgkJbyAidG9kb3MgbG9zIG76bWVyb3MgZGUgdGVs6WZvbm8gcXVlIGNvbnRpZW5lbiAxMAoJCWTtZ2l0b3MiIG8gaW5jbHVzbyAiVG9kYXMgbGFzIGZyYXNlcyBlbnRyZSBjb21hcywgeSBxdWUgbm8KCQljb250ZW5nYW4gbmluZ3VuYSBsZXRyYSBRIi4gTGFzIEV4cHJlc2lvbmVzIFJlZ3VsYXJlcyBzb24g+nRpbGVzIGVuCgkJQXBhY2hlIHBvcnF1ZSBwZXJtaXRlbiBhcGxpY2FyIGNpZXJ0b3MgYXRyaWJ1dG9zIGEgY29sZWNjaW9uZXMgZGUKCQlmaWNoZXJvcyBvIHJlY3Vyc29zIGRlIHVuYSBmb3JtYSBmbGV4aWJsZSAtIHBvciBlamVtcGxvLCB0b2RvcyBsb3MKCQlhcmNoaXZvcyAuZ2lmIHkgLmpwZyBxdWUgZXN06W4gZW4gZWwgZGlyZWN0b3JpbyAiaW3hZ2VuZXMiCgkJcG9kcu1hbiBzZXIgZXNjcml0b3MgY29tbyAiPGNvZGU+L2ltYWdlcy8uKihqcGd8Z2lmKSQ8L2NvZGU+Ii4KCQlFbiBsb3MgbHVnYXJlcyBkb25kZSBleHByZXNpb25lcyByZWd1bGFyZXMgc2UgdXRpbGl6YW4gcGFyYSByZWVtcGxhemFyCgkJY2FkZW5hcywgbGFzIHZhcmlhYmxlcyBlc3BlY2lhbGVzICQgMSAuLi4gJCA5IGNvbnRpZW5lbiAKCQlyZWZlcmVuY2lhcyBpbnZlcnNhIGxhcyBwYXJ0ZXMgYWdydXBhZGFzIChlbnRyZSBwYXLpbnRlc2lzKSAKCQlkZSBsYSBleHByZXNp824gY29pbmNpZGVudGUuIExhIHZhcmlhYmxlIGVzcGVjaWFsICQgMCBjb250aWVuZSAKCQl1bmEgcmVmZXJlbmNpYSBpbnZlcnNhIGEgdG9kbyBlbCBlamVtcGxhciBkZSBsYSBleHByZXNp824uCgkJUGFyYSBlc2NyaWJpciB1biBz7W1ib2xvIGRlIGRvbGFyIGxpdGVyYWwgZW4gdW5hIHN1c3RpdHVjafNuIGRlCgkJdW5hIGNhZGVuYSwgc2UgcHVlZGUgZXNjYXBhciB1c2FuZG8gIlwiLiBIaXN083JpY2FtZW50ZSwgbGEgdmFyaWFibGUgJmFtcDsKCQlzZSBwb2TtYSB1c2FyIGNvbW8gdW4gYWxpYXMgYSAkMCBlbiBhbGd1bm9zIHNpdGlvcy4gCgkJRXN0byB5YSBubyBlc3RhIHNvcG9ydGFkbyBkZXNkZSBsYSB2ZXJzafNuIDIuMy42LgoJCUFwYWNoZSB1c2EgRXhwcmVzaW9uZXMgUmVndWxhcmVzIGNvbXBhdGlibGVzIGNvbiBQZXJsIGdyYWNpYXMgYSBsYQoJCWxpYnJlcu1hIDxhIGhyZWY9Imh0dHA6Ly93d3cucGNyZS5vcmcvIj5QQ1JFPC9hPi4KCQlQdWVkZXMgZW5jb250cmFyIG3hcyBkb2N1bWVudGFjafNuIHNvYnJlIGxhcyBleHByZXNpb25lcyByZWd1bGFyZXMgCgkJZGUgUENSRSB5IHN1IHNpbnRheGlzIGVuIGVzYSBw4WdpbmEgbyBlbiBsYQoJCTxhIGhyZWY9Imh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvUENSRSI+V2lraXBlZGlhPC9hPi48L2RkPgoKCgoJCTxkdD48YSBuYW1lPSJjb25maWd1cmF0aW9uZmlsZSIgaWQ9ImNvbmZpZ3VyYXRpb25maWxlIj5GaWNoZXJvIGRlIENvbmZpZ3VyYWNp824uPC9hPjwvZHQ+CgkJPGRkPlVuIGZpY2hlcm8gZGUgdGV4dG8gcXVlIGNvbnRpZW5lIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNkaXJlY3RpdmUiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPkRpcmVjdGl2YXM8L2E+IHF1ZSBjb250cm9sYW4gbGEgY29uZmlndXJhY2nzbgoJCWRlIEFwYWNoZS48YnIgLz4gQ29uc3VsdGU6IDxhIGhyZWY9ImNvbmZpZ3VyaW5nLmh0bWwiPkZpY2hlcm9zIGRlCgkJQ29uZmlndXJhY2nzbjwvYT48L2RkPgoKCgkJPGR0PjxhIG5hbWU9Imh0YWNjZXNzIiBpZD0iaHRhY2Nlc3MiPi5odGFjY2VzczwvYT48L2R0PiAKCQk8ZGQ+VW4gPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2NvbmZpZ3VyYXRpb25maWxlIiB0aXRsZT0idmVyIGdsb3NhcmlvIj5maWNoZXJvIGRlIGNvbmZpZ3VyYWNp8248L2E+IHF1ZSBzZQoJCXBvbmUgZGVudHJvIGRlIGxhIGVzdHJ1Y3R1cmEgZGUgZGlyZWN0b3Jpb3MgZGVsIHNpdGlvIHdlYiB5IGFwbGljYSA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuL2dsb3NzYXJ5Lmh0bWwjZGlyZWN0aXZlIiB0aXRsZT0idmVyIGdsb3NhcmlvIj5kaXJlY3RpdmFzPC9hPiBkZSBjb25maWd1cmFjafNuIGFsIGRpcmVjdG9yaW8KCQllbiBlbCBxdWUgZXN04SB5IGEgc3VzIHN1YmRpcmVjdG9yaW9zLiBBIHBlc2FyIGRlIHN1IG5vbWJyZSwgZXN0ZQoJCWZpY2hlcm8gcHVlZGUgY29udGVuZXIgY3VhbHF1aWVyIHRpcG8gZGUgZGlyZWN0aXZhcywgbm8gc29sbwoJCWRpcmVjdGl2YXMgZGUgY29udHJvbCBkZSBhY2Nlc28uPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJjb25maWd1cmluZy5odG1sIj5GaWNoZXJvcyBkZSBDb25maWd1cmFjafNuPC9hPiBwYXJhIG3hcyBpbmZvcm1hY2nzbi48L2RkPgoKCQk8ZHQ+PGEgbmFtZT0iaHR0cGQuY29uZiIgaWQ9Imh0dHBkLmNvbmYiPmh0dHBkLmNvbmY8L2E+PC9kdD4KCQk8ZGQ+RXMgZWwgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2NvbmZpZ3VyYXRpb25maWxlIiB0aXRsZT0idmVyIGdsb3NhcmlvIj5maWNoZXJvIGRlIGNvbmZpZ3VyYWNp8248L2E+IHByaW5jaXBhbAoJCWRlIEFwYWNoZS4gU3UgdWJpY2FjafNuIHBvciBkZWZlY3RvIGVzCgkJPGNvZGU+L3Vzci9sb2NhbC9hcGFjaGUyL2NvbmYvaHR0cGQuY29uZjwvY29kZT4sIHBlcm8gcHVlZGUgbW92ZXJzZQoJCXVzYW5kbyBvcGNpb25lcyBkZSBjb25maWd1cmFjafNuIGFsIGNvbXBpbGFyIG8gYWwgaW5pY2lhcgoJCUFwYWNoZS48YnIgLz4gQ29uc3VsdGU6IDxhIGhyZWY9ImNvbmZpZ3VyaW5nLmh0bWwiPkZpY2hlcm9zIGRlCgkJQ29uZmlndXJhY2nzbjwvYT48L2RkPgoKCQk8ZHQ+PGEgbmFtZT0iZmlsdGVyIiBpZD0iZmlsdGVyIj5GaWx0cm88L2E+PC9kdD4KCQk8ZGQ+VW4gcHJvY2VzbyBxdWUgc2UgYXBsaWNhIGEgbGEKCQlpbmZvcm1hY2nzbiBxdWUgZXMgZW52aWFkYSBvIHJlY2liaWRhIHBvciBlbCBzZXJ2aWRvci4gTG9zCgkJZmljaGVyb3MgZGUgZW50cmFkYSBwcm9jZXNhbiBsYSBpbmZvcm1hY2nzbiBlbnZpYWRhIHBvciB1bgoJCWNsaWVudGUgYWwgc2Vydmlkb3IsIG1pZW50cmFzIHF1ZSBsb3MgZmlsdHJvcyBkZSBzYWxpZGEgcHJvY2VzYW4gbGEKCQlpbmZvcm1hY2nzbiBlbiBlbCBzZXJ2aWRvciBhbnRlcyBkZSBlbnZp4XJzZWxhIGFsCgkJY2xpZW50ZS4gUG9yIGVqZW1wbG8sIGVsIGZpbHRybyBkZSBzYWxpZGEgPGNvZGU+SU5DTFVERVM8L2NvZGU+CgkJcHJvY2VzYSBkb2N1bWVudG9zIHBhcmEgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI3NzaSIgdGl0bGU9InZlciBnbG9zYXJpbyI+U2VydmVyIFNpZGUgSW5jbHVkZXM8L2E+LjxiciAvPgoJCUNvbnN1bHRlOiA8YSBocmVmPSJmaWx0ZXIuaHRtbCI+RmlsdHJvczwvYT48L2RkPgoKCgoJCTxkdD48YSBuYW1lPSJkaWdpdGFsc2lnbmF0dXJlIiBpZD0iZGlnaXRhbHNpZ25hdHVyZSI+RmlybWEgRGlnaXRhbDwvYT48L2R0PgoJCTxkZD5VbiBibG9xdWUgZGUKCQl0ZXh0byBlbmNyaXB0YWRvIHF1ZSB2ZXJpZmljYSBsYSB2YWxpZGV6IGRlIHVuIGNlcnRpZmljYWRvIG8gZGUgb3RybwoJCWZpY2hlcm8uIFVuYSA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuL2dsb3NzYXJ5Lmh0bWwjY2VydGlmaWNhdGlvbmF1dGhvcml0eSIgdGl0bGU9InZlciBnbG9zYXJpbyI+QXV0b3JpZGFkCgkJQ2VydGlmaWNhZG9yYTwvYT4gY3JlYSB1bmEgZmlybWEgZ2VuZXJhbmRvIHVuIGhhc2ggYSBwYXJ0aXIgZGUgbGEKCQk8ZW0+Q2xhdmUgUPpibGljYTwvZW0+IHF1ZSBsbGV2YSBpbmNvcnBvcmFkYSBlbiB1bgoJCTxlbT5DZXJ0aWZpY2FkbzwvZW0+LCBkZXNwdelzIGVuY3JpcHRhbmRvIGVsIGhhc2ggY29uIHN1IHByb3BpYQoJCTxlbT5DbGF2ZSBQcml2YWRhPC9lbT4uIFNvbG8gbGFzIGNsYXZlcyBw+mJsaWNhcyBkZSBsYXMgQ0FzCgkJcHVlZGVuIGRlc2VuY3JpcHRhciBsYSBmaXJtYSwgdmVyaWZpY2FuZG8gcXVlIGxhIENBIGhhIGF1dGVudGlmaWNhZG8gYQoJCWxhIGVudGlkYWQgZGUgcmVkIHByb3BpZXRhcmlhIGRlbCA8ZW0+Q2VydGlmaWNhZG88L2VtPi48YnIgLz4KCQlDb25zdWx0ZTogPGEgaHJlZj0ic3NsLyI+RW5jcmlwdGFkbyBTU0wvVExTPC9hPjwvZGQ+CgoJCTxkdD48YSBuYW1lPSJoYW5kbGVyIiBpZD0iaGFuZGxlciI+SGFuZGxlcjwvYT48L2R0PiAKCQk8ZGQ+RXMgdW5hIHJlcHJlc2VudGFjafNuCgkJaW50ZXJuYSBkZSBBcGFjaGUgZGUgdW5hIGFjY2nzbiBhIHNlciBlamVjdXRhZGEgY3VhbmRvIHNlIGxsYW1hIGEKCQl1biBmaWNoZXJvLiBHZW5lcmFsbWVudGUsIGxvcyBmaWNoZXJvcyB0aWVuZW4gdW4gaGFuZGxlciAobWFuZWphZG9yKQoJCWltcGztY2l0bywgYmFzYWRvIGVuIGVsIHRpcG8gZGUgZmljaGVyby4gTm9ybWFsbWVudGUsIHRvZG9zIGxvcwoJCWZpY2hlcm9zIHNvbiBzaW1wbGVtZW50ZSBzZXJ2aWRvcyBwb3IgZWwgc2Vydmlkb3IsIHBlcm8gc29icmUgYWxndW5vcwoJCXRpcG9zIGRlIGZpY2hlcm9zIHNlIGVqZWN1dGFuIGFjY2lvbmVzIGNvbXBsZW1lbnRhcmlhcy4gIFBvciBlamVtcGxvLAoJCWVsIGhhbmRsZXIgPGNvZGU+Y2dpLXNjcmlwdDwvY29kZT4gZGVzaWduYSBsb3MgZmljaGVyb3MgYSBzZXIKCQlwcm9jZXNhZG9zIGNvbW8gPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2NnaSIgdGl0bGU9InZlciBnbG9zYXJpbyI+Q0dJczwvYT4uPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJoYW5kbGVyLmh0bWwiPlVzbyBkZSBIYW5kbGVycyBlbiBBcGFjaGU8L2E+PC9kZD4KCgkJPGR0PjxhIG5hbWU9ImFwYWNoZWV4dGVuc2lvbnRvb2wiIGlkPSJhcGFjaGVleHRlbnNpb250b29sIj5IZXJyYW1pZW50YSBkZSBleHRlbnNp824gZGUKCQlBcGFjaGUuPC9hPiA8YSBuYW1lPSJhcHhzIiBpZD0iYXB4cyI+KGFweHMpPC9hPjwvZHQ+CgkJPGRkPkVzIHVuIHNjcmlwdCBlc2NyaXRvIGVuIFBlcmwgcXVlIGF5dWRhIGEgY29tcGlsYXIgZWwgY/NkaWdvCgkJZnVlbnRlIGRlIGFsZ3Vub3MgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI21vZHVsZSIgdGl0bGU9InZlciBnbG9zYXJpbyI+bfNkdWxvczwvYT4gcGFyYSAKCQljb252ZXJ0aXJsb3MgZW4gT2JqZXRvcyBEaW7hbWljb3MgQ29tcGFydGlkb3MgKDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNkc28uaHRtbCIgdGl0bGU9InZlciBnbG9zYXJpbyI+RFNPPC9hPnMpCgkJeSBheXVkYSBhIGluc3RhbGFybG9zIGVuIGVsIFNlcnZpZG9yIFdlYiBkZSBBcGFjaGUuPGJyIC8+IAoJCUNvbnN1bHRlOiBNYW51YWwgZGU6IDxjb2RlIGNsYXNzPSJwcm9ncmFtIj48YSBocmVmPSIuL3Byb2dyYW1zL2FweHMuaHRtbCI+YXB4czwvYT48L2NvZGU+PC9kZD4KCgoKCQk8ZHQ+PGEgbmFtZT0iaGFzaCIgaWQ9Imhhc2giPkhhc2g8L2E+PC9kdD4KCQk8ZGQ+QWxnb3JpdG1vIG1hdGVt4XRpY28gZGUgdW4gc29sbyBzZW50aWRvIGUgaXJyZXZlcnNpYmxlLCBxdWUgZ2VuZXJhCgkJdW4gc3RyaW5nIGRlIHVuYSBkZXRlcm1pbmFkYSBsb25naXR1ZCBkZSBvdHJvIHN0cmluZyBkZSAKCQljdWFscXVpZXIgdGFtYfFvLiBEaWZlcmVudGVzIGVudHJhZGFzIGRhcuFuIGRpZmVyZW50ZXMgaGFzaGVzIAoJCShkZXBlbmRpZW5kbyBkZSBsYSBmdW5jafNuIGhhaC4pIAoJCTwvZGQ+CgoKCgoKCQk8ZHQ+PGEgbmFtZT0idmlydHVhbGhvc3RpbmciPkhvc3RpbmcgVmlydHVhbDwvYT48L2R0PiA8ZGQ+U2UgdHJhdGEgZGUKCQlzZXJ2aXIgZGlmZXJlbnRlcyBzaXRpb3Mgd2ViIGNvbiB1bmEgc29sYSBlbnRpZGFkIGRlIEFwYWNoZS4gIDxlbT5FbAoJCWhvc3RpbmcgdmlydHVhbCBkZSBJUHM8L2VtPiBkaWZlcmVuY2lhIGxvcyBzaXRpb3Mgd2ViIGJhc2FuZG9zZSBlbiBzdXMKCQlkaXJlY2Npb25lcyBJUCwgbWllbnRyYXMgcXVlIGVsIDxlbT5ob3N0aW5nIHZpcnR1YWwgYmFzYWRvIGVuCgkJbm9tYnJlczwvZW0+IHVzYSBzb2xvIGVsIG5vbWJyZSBkZWwgaG9zdCB5IGRlIGVzdGEgbWFuZXJhIHB1ZWRlIGFsb2phcgoJCW11Y2hvcyBzaXRpb3Mgd2ViIGNvbiBsYSBtaXNtYSBkaXJlY2Np824gSVAuPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJ2aG9zdHMvIj5Eb2N1bWVudGFjafNuIHNvYnJlIEhvc3RpbmcgVmlydHVhbCBlbgoJCUFwYWNoZTwvYT48L2RkPgoKCgkJPGR0PjxhIG5hbWU9InVuaWZvcm1yZXNvdXJjZWlkZW50aWZpZXIiPklkZW50aWZpY2Fkb3IgZGUgUmVjdXJzb3MKCQlVbmlmb3JtZTwvYT4gPGEgbmFtZT0iVVJJIj4oVVJJKTwvYT48L2R0PiA8ZGQ+VW5hIGNhZGVuYSBkZSBjYXJhY3RlcmVzCgkJY29tcGFjdGEgcGFyYSBpZGVudGlmaWNhciB1biByZWN1cnNvIGbtc2ljbyBvIGFic3RyYWN0by4gIFNlCgkJZGVmaW5lIGZvcm1hbG1lbnRlIGVuIGxhIDxhIGhyZWY9Imh0dHA6Ly93d3cuaWV0Zi5vcmcvcmZjL3JmYzIzOTYudHh0Ij5SRkMgMjM5NjwvYT4uICBMb3MgVVJJcyBxdWUKCQlzZSB1c2FuIGVuIHdvcmxkLXdpZGUgd2ViIHNlIHJlZmllcmVuIG5vcm1hbG1lbnRlIGNvbW8gPGEgaHJlZj0iI3VybCI+VVJMczwvYT4uPC9kZD4KCgoKCgkJPGR0PjxhIG5hbWU9InNlcnZlcm5hbWVpbmRpY2F0aW9uIiBpZD0ic2VydmVybmFtZWluZGljYXRpb24iPkluZGljYWRvciBkZWwgTm9tYnJlIGRlbCBzZXJ2aWRvcjwvYT4KCQk8YSBuYW1lPSJzbmkiIGlkPSJzbmkiPiBTZXJ2ZXIgTmFtZSBJbmRpY2F0aW9uIChTTkkpIDwvYT48L2R0PgoJCTxkZD5VbmEgZnVuY2nzbiBTU0wgcXVlIHBlcm1pdGUgcGFzYXIgZWwgbm9tYnJlIGRlIGhvc3QgZGVsIHNlcnZpZG9yIGRlc2VhZG8gCgkJZW4gZWwgbWVuc2FqZSBpbmljaWFsIGRlbCBwcm90b2NvbG8gZGUgZW5sYWNlIFNTTCwgcGFyYSBxdWUgZWwgc2Vydmlkb3Igd2ViIAoJCXB1ZWRhIHNlbGVjY2lvbmFyIGxhIGNvbmZpZ3VyYWNp824gY29ycmVjdGEgZGVsIGhvc3QgdmlydHVhbCBwYXJhIHVzYXIgZW4gZWwgCgkJcHJvY2VzYW1pZW50byBkZWwgcHJvdG9jb2xvIGRlIGVubGFjZSBTU0wuIFNlIGHxYWRp8yBhIFNTTCAKCQljb24gbGFzIGV4dGVuc2lvbmVzIFRMUyBlbiBlbCBSRkMgMzU0Ni4gIDxiciAvPgoJCVNlZTogPGEgaHJlZj0ic3NsL3NzbF9mYXEuaHRtbCI+dGhlIFNTTCBGQVE8L2E+CgkJYW5kIDxhIGhyZWY9Imh0dHA6Ly93d3cuaWV0Zi5vcmcvcmZjL3JmYzM1NDYudHh0Ij5SRkMgMzU0NjwvYT4KCQk8L2RkPgoKCgoKCQk8ZHQ+PGEgbmFtZT0iY29tbW9uZ2F0ZXdheWludGVyZmFjZSIgaWQ9ImNvbW1vbmdhdGV3YXlpbnRlcmZhY2UiPkludGVyZmF6IGRlIFBhc2FyZWxhIENvbfpuLjwvYT4gPGEgbmFtZT0iY2dpIj4gQ29tbW9uIEdhdGV3YXkgSW50ZXJmYWNlIChDR0kpPC9hPjwvZHQ+CgkJPGRkPlVuYSBkZWZpbmljafNuIGVzdOFuZGFyIHBhcmEKCQl1biBpbnRlcmZheiBlbnRyZSB1biBzZXJ2aWRvciB3ZWIgeSB1biBwcm9ncmFtYSBleHRlcm5vIHF1ZSBwZXJtaXRlCgkJaGFjZXIgcGV0aWNpb25lcyBkZSBzZXJ2aWNpbyBhIGxvcyBwcm9ncmFtYXMgZXh0ZXJub3MuICBFc3RlIGludGVyZmF6CgkJZXN0YSBkZWZpbmlkbyBlbiBlbCAgPGEgaHJlZj0iaHR0cDovL3d3dy5pZXRmLm9yZy9yZmMvcmZjMzg3NSI+UkZDLTM4NzU8L2E+LjxiciAvPgoJCUNvbnN1bHRlOiA8YSBocmVmPSJob3d0by9jZ2kuaHRtbCI+Q29udGVuaWRvIERpbuFtaWNvIGNvbiBDR0k8L2E+CgkJPC9kZD4KCgkJPGR0PjxhIG5hbWU9InVuaWZvcm1yZXNvdXJjZWxvY2F0b3IiPkxvY2FsaXphZG9yIGRlIFJlY3Vyc29zCgkJVW5pZm9ybWU8L2E+IDxhIG5hbWU9InVybCI+KFVSTCk8L2E+PC9kdD4KCQk8ZGQ+RWwgbm9tYnJlIGRlIHVuIHJlY3Vyc28KCQllbiBJbnRlcm5ldC4gIEVzIGxhIG1hbmVyYSBpbmZvcm1hbCBkZSBkZWNpciBsbyBxdWUgZm9ybWFsbWVudGUgc2UKCQlsbGFtYSB1biA8YSBocmVmPSIjdW5pZm9ybXJlc291cmNlaWRlbnRpZmllciI+SWRlbnRpZmljYWRvciBkZQoJCVJlY3Vyc29zIFVuaWZvcm1lPC9hPi4gIExhcyBVUkxzIGVzdOFuIGNvbXB1ZXN0YXMgbm9ybWFsbWVudGUgcG9yCgkJdW4gZXNxdWVtYSwgdGFsIGNvbW8gPGNvZGU+aHR0cDwvY29kZT4gbyA8Y29kZT5odHRwczwvY29kZT4sIHVuIG5vbWJyZQoJCWRlIGhvc3QsIHkgdW5hIHJ1dGEuICBVbmEgVVJMIHBhcmEgZXN0YSBw4WdpbmEgZXMKCQk8Y29kZT5odHRwOi8vaHR0cGQuYXBhY2hlLm9yZy9kb2NzL3RydW5rL2dsb3NzYXJ5Lmh0bWw8L2NvZGU+LjwvZGQ+CgoKCQk8ZHQ+PGEgbmFtZT0ibW9kdWxlIiBpZD0ibW9kdWxlIj5N82R1bG88L2E+PC9kdD4KCQk8ZGQ+VW5hIHBhcnRlIGluZGVwZW5kaWVudGUKCQlkZSB1biBwcm9ncmFtYS4gTGEgbWF5b3IgcGFydGUgZGUgbGEgZnVuY2lvbmFsaWRhZCBkZSBBcGFjaGUKCQllc3ThIGNvbnRlbmlkYSBlbiBt82R1bG9zIHF1ZSBwdWVkZW4gaW5jbHVpcnNlIG8gZXhjbHVpcnNlLgoJCUxvcyBt82R1bG9zIHF1ZSBzZSBjb21waWxhbiBjb24gZWwgYmluYXJpbyA8Y29kZSBjbGFzcz0icHJvZ3JhbSI+PGEgaHJlZj0iLi9wcm9ncmFtcy9odHRwZC5odG1sIj5odHRwZDwvYT48L2NvZGU+ZGUgQXBhY2hlIHNlCgkJbGxhbWFuIDxlbT5t82R1bG9zIGVzdOF0aWNvczwvZW0+LCBtaWVudHJhcyBxdWUgbG9zIHF1ZSBzZQoJCWFsbWFjZW5hbiBkZSBmb3JtYSBzZXBhcmFkYSB5IHB1ZWRlbiBzZXIgY2FyZ2Fkb3MgZGUgZm9ybWEgb3BjaW9uYWwsCgkJc2UgbGxhbWFuIDxlbT5t82R1bG9zIGRpbuFtaWNvczwvZW0+IG8gPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2RzbyIgdGl0bGU9InZlciBnbG9zYXJpbyI+RFNPczwvYT4uCgkJTG9zIG3zZHVsb3MgcXVlIGVzdOFuIGluY2x1aWRvcyBwb3IgZGVmZWN0byBkZSBsbGFtYW4KCQk8ZW0+bfNkdWxvcyBiYXNlPC9lbT4uICBIYXkgbXVjaG9zIG3zZHVsb3MgZGlzcG9uaWJsZXMgcGFyYQoJCUFwYWNoZSBxdWUgbm8gc2UgZGlzdHJpYnV5ZW4gY29uIGxhIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCN0YXJiYWxsIiB0aXRsZT0idmVyIGdsb3NhcmlvIj50YXJiYWxsPC9hPiBkZWwKCQlTZXJ2aWRvciBIVFRQIEFwYWNoZS4gIEVzdG9zIG3zZHVsb3Mgc29uIGxsYW1hZG9zCgkJPGVtPm3zZHVsb3MgZGUgdGVyY2Vyb3M8L2VtPi48YnIgLz4gQ29uc3VsdGU6IDxhIGhyZWY9Im1vZC8iPs1uZGljZSBkZSBN82R1bG9zPC9hPjwvZGQ+CgoKCQk8ZHQ+PGEgbmFtZT0ibWV0aG9kIiBpZD0ibWV0aG9kIj5N6XRvZG88L2E+PC9kdD4gCgkJPGRkPkVuIGVsIGNvbnRleHRvIGRlIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNodHRwIiB0aXRsZT0idmVyIGdsb3NhcmlvIj5IVFRQPC9hPiwgZXMgdW5hIGFjY2nzbiBhIGVqZWN1dGFyIHNvYnJlIHVuIHJlY3Vyc28sCgkJZXNwZWNpZmljYWRvIGVuIGxhIGztbmVhcyBkZSBwZXRpY2nzbiBwb3IgZWwgY2xpZW50ZS4KCQlBbGd1bm9zIGRlIGxvcyBt6XRvZG9zIGRpc3BvbmlibGVzIGVuIEhUVFAgc29uIDxjb2RlPkdFVDwvY29kZT4sCgkJPGNvZGU+UE9TVDwvY29kZT4sIHkgPGNvZGU+UFVUPC9jb2RlPi48L2RkPgoKCQk8ZHQ+PGEgbmFtZT0ibWVzc2FnZWRpZ2VzdCIgaWQ9Im1lc3NhZ2VkaWdlc3QiPk1lbnNhamUgUmVzdW1lbiAoTWVzc2FnZSBEaWdlc3QpPC9hPjwvZHQ+IAoJCTxkZD5VbiBoYXNoIGRlIHVuCgkJbWVuc2FqZSwgZWwgY3VhbCBwdWRlIHNlciB1c2FkbyBwYXJhIHZlcmlmaWNhciBxdWUgZWwgY29udGVuaWRvIGRlbAoJCW1lbnNhamUgbm8gaGEgc2lkbyBhbHRlcmFkbyBkdXJhbnRlIGxhIHRyYW5zbWlzafNuLjxiciAvPgoJCUNvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvIFNTTC9UTFM8L2E+PC9kZD4KCgkJPGR0PjxhIG5hbWU9Im1pbWUtdHlwZSIgaWQ9Im1pbWUtdHlwZSI+TUlNRS10eXBlPC9hPjwvZHQ+IAoJCTxkZD5VbmEgbWFuZXJhIGRlIGRlc2NyaWJpcgoJCWVsIHRpcG8gZGUgZG9jdW1lbnRvIGEgc2VyIHRyYW5zbWl0aWRvLiAgU3Ugbm9tYnJlIHZpZW5lIGRlbCBoZWNobyBkZQoJCXF1ZSBzdSBmb3JtYXRvIHNlIHRvbWEgZGUgbGFzIEV4dGVuc2lvbmVzIGRlbCAiTXVsdGlwdXJwb3NlIEludGVybmV0CgkJTWFpbCIuICBDb25zaXN0ZSBlbiBkb3MgY29tcG9uZW50ZXMsIHVubyBwcmluY2lwYWwgeSBvdHJvIHNlY3VuZGFyaW8sCgkJc2VwYXJhZG9zIHBvciB1bmEgYmFycmEuICBBbGd1bm9zIGVqZW1wbG9zIHNvbiA8Y29kZT50ZXh0L2h0bWw8L2NvZGU+LAoJCTxjb2RlPmltYWdlL2dpZjwvY29kZT4sIHkgPGNvZGU+YXBwbGljYXRpb24vb2N0ZXQtc3RyZWFtPC9jb2RlPi4gIEVuCgkJSFRUUCwgZWwgdGlwbyBNSU1FIHNlIHRyYW5zbWl0ZSBlbiBsYSA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuL2dsb3NzYXJ5Lmh0bWwjaGVhZGVyIiB0aXRsZT0idmVyIGdsb3NhcmlvIj5jYWJlY2VyYTwvYT4KCQlkZWwgPGNvZGU+VGlwbyBDb250ZW5pZG88L2NvZGU+LjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0ibW9kL21vZF9taW1lLmh0bWwiPm1vZF9taW1lPC9hPjwvZGQ+CgoJCTxkdD48YSBuYW1lPSJtb2R1bGVtYWdpY251bWJlciIgaWQ9Im1vZHVsZW1hZ2ljbnVtYmVyIj5N82R1bG8gZGVsIE76bWVybyBN4WdpY288L2E+CgkJKDxhIG5hbWU9Im1tbiI+TU1OIE1vZHVsZSBNYWdpYwoJCU51bWJlcjwvYT4pPC9kdD4gPGRkPiBFbCBt82R1bG8gZGVsIG76bWVybwoJCW3hZ2ljbyBlcyB1bmEgY29uc3RhbnRlIGRlZmluaWRhIGVuIGVsIGPzZGlnbwoJCWZ1ZW50ZSBkZSBBcGFjaGUgcXVlIGVzdOEgYXNvY2lhZG8gY29uIGxhIGNvbXBhdGliaWxpZGFkIGJpbmFyaWEKCQlkZSBsb3MgbfNkdWxvcy4gRXNlIG76bWVybyBjYW1iaWEgY3VhbmRvIGNhbWJpYW4gbGFzCgkJZXN0cnVjdHVyYXMgaW50ZXJuYXMgZGUgQXBhY2hlLCBsYXMgbGxhbWFkYXMgYSBmdW5jaW9uZXMgeSBvdHJhcwoJCXBhcnRlcyBzaWduaWZpY2F0aXZhcyBkZSBsYSBpbnRlcmZheiBkZSBwcm9ncmFtYWNp824gZGUgbWFuZXJhCgkJcXVlIGxhIGNvbXBhdGliaWxpZGFkIGJpbmFyaWEgbm8gcHVlZGUgZ2FyYW50aXphcnNlIHNpbiBjYW1iaWFybG8uICBTaQoJCWNhbWJpYSBlbCBu+m1lcm8gbeFnaWNvIGRlIG3zZHVsbywgdG9kb3MgbG9zCgkJbfNkdWxvcyBkZSB0ZXJjZXJvcyB0aWVuZW4gcXVlIHNlciBhbCBtZW5vcyByZWNvbXBpbGFkb3MsIHkKCQlhbGd1bmFzIHZlY2VzLCBpbmNsdXNvIGhheSBxdWUgaW50cm9kdWNpciBsaWdlcmFzIG1vZGlmaWNhY2lvbmVzIHBhcmEKCQlxdWUgZnVuY2lvbmVuIGNvbiBsYSBudWV2YSB2ZXJzafNuIGRlIEFwYWNoZSA8L2RkPgoKCgkJPGR0PjxhIG5hbWU9ImZ1bGx5LXF1YWxpZmllZGRvbWFpbi1uYW1lIiBpZD0iZnVsbHktcXVhbGlmaWVkZG9tYWluLW5hbWUiPk5vbWJyZSBkZSBkb21pbmlvCgkJY29tcGxldGFtZW50ZSBxdWFsaWZpY2FkbzwvYT4gPGEgbmFtZT0iZnFkbiI+KEZRRE4pPC9hPjwvZHQ+IAoJCTxkZD5FbAoJCW5vbWJyZSD6bmljbyBkZSB1bmEgZW50aWRhZCBkZSByZWQsIHF1ZSBjb25zaXN0ZSBlbiB1biBub21icmUgZGUKCQlob3N0IHkgdW4gbm9tYnJlIGRlIGRvbWluaW8gcXVlIHB1ZWRlIHRyYWR1Y2lyc2UgYSB1bmEgZGlyZWNjafNuCgkJSVAuIFBvciBlamVtcGxvLCA8Y29kZT53d3c8L2NvZGU+IGVzIHVuIG5vbWJyZSBkZSBob3N0LAoJCTxjb2RlPmV4YW1wbGUuY29tPC9jb2RlPiBlcyB1biBub21icmUgZGUgZG9taW5pbywgeQoJCTxjb2RlPnd3dy5leGFtcGxlLmNvbTwvY29kZT4gZXMgdW4gbm9tYnJlIGRlIGRvbWluaW8gY29tcGxldGFtZW50ZQoJCXF1YWxpZmljYWRvLjwvZGQ+CgoJCTxkdD48YSBuYW1lPSJkeW5hbWljc2hhcmVkb2JqZWN0IiBpZD0iZHluYW1pY3NoYXJlZG9iamVjdCI+T2JqZXRvcyBEaW7hbWljb3MKCQlDb21wYXJ0aWRvczwvYT4gPGEgbmFtZT0iZHNvIj4oRFNPLCBkaW5hbWljIHNoYXJlZCBvYmplY3RzKTwvYT48L2R0PgoJCTxkZD5Mb3MgPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI21vZHVsZSIgdGl0bGU9InZlciBnbG9zYXJpbyI+TfNkdWxvczwvYT4gY29tcGlsYWRvcyBkZSBmb3JtYSBzZXBhcmFkYSBhbAoJCWJpbmFyaW8gaHR0cGQgZGUgQXBhY2hlIHNlIHB1ZWRlbiBjYXJnYXIgc2Vn+m4gc2UgbmVjZXNpdGVuLjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0iZHNvLmh0bWwiPlNvcG9ydGUgZGUgT2JqZXRvcyBEaW7hbWljb3MKCQlDb21wYXJ0aWRvczwvYT48L2RkPgoKCgkJPGR0PjxhIG5hbWU9Im9wZW5zc2wiIGlkPSJvcGVuc3NsIj5PcGVuU1NMPC9hPjwvZHQ+CgkJPGRkPkVsIHRvb2xraXQgT3BlbiBTb3VyY2UgcGFyYSBTU0wvVExTPGJyIC8+CgkJVmVyOiA8YSBocmVmPSJodHRwOi8vd3d3Lm9wZW5zc2wub3JnLyI+aHR0cDovL3d3dy5vcGVuc3NsLm9yZy88L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJwYXNzcGhyYXNlIj5QYXNzIFBocmFzZSBvIGZyYXNlIGRlIGNvbnRyYXNl8WE8L2E+PC9kdD4gCgkJPGRkPkxhIHBhbGFicmEgbyBmcmFzZQoJCXF1ZSBwcm90ZWdlIGxvcyBhcmNoaXZvcyBkZSBjbGF2ZSBwcml2YWRhLiAgRXZpdGEgcXVlIHVzdWFyaW9zIG5vCgkJYXV0b3JpemFkb3MgbG9zIGVuY3JpcHRlbi4gTm9ybWFsbWVudGUgZXMgc29sbyBsYSBjbGF2ZSBkZQoJCWVuY3JpcHRhZG8vZGVzZW5jcmlwdGFkbyB1c2FkYSBwb3IgbG9zIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNjaXBoZXIiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPkFsZ29yaXRtb3MgZGUKCQlDaWZyYWRvPC9hPi48YnIgLz4gQ29uc3VsdGU6IDxhIGhyZWY9InNzbC8iPkVuY3JpcHRhZG8KCQlTU0wvVExTPC9hPjwvZGQ+CgoJCTxkdD48YSBuYW1lPSJjZXJ0aWZpY2F0c2lnbmluZ3JlcXVlc3QiIGlkPSJjZXJ0aWZpY2F0c2lnbmluZ3JlcXVlc3QiPlBldGljafNuIGRlIGZpcm1hIGRlCgkJQ2VydGlmaWNhZG8uPC9hPiA8YSBuYW1lPSJjc3IiPihDU1IpPC9hPjwvZHQ+IAoJCTxkZD5FcyBsYSBwZXRpY2nzbiBhCgkJdW5hIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNjZXJ0aWZpY2F0aW9uYXV0aG9yaXR5IiB0aXRsZT0idmVyIGdsb3NhcmlvIj5BdXRvcmlkYWQgQ2VydGlmaWNhZG9yYTwvYT4gcGFyYQoJCXF1ZSBmaXJtZSB1biA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuL2dsb3NzYXJ5Lmh0bWwjY2VydGlmaWNhdGUiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPmNlcnRpZmljYWRvPC9hPiBh+m4gc2luCgkJZmlybWFyLiBMYSBBdXRvcmlkYWQgQ2VydGlmaWNhZG9yYSBmaXJtYSBlbCA8ZW0+Q2VydGlmaWNhZG88L2VtPiBjb24KCQlsYSA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuL2dsb3NzYXJ5Lmh0bWwjcHJpdmF0ZWtleSIgdGl0bGU9InZlciBnbG9zYXJpbyI+Q2xhdmUgUHJpdmFkYTwvYT4gZGUgc3UgCgkJPGVtPmNlcnRpZmljYWRvPC9lbT4uIFVuYSB2ZXogcXVlIGVsIENTUiBlc3ThIGZpcm1hZG8sIHNlIAoJCWNvbnZpZXJ0ZSBlbiB1biBhdXTpbnRpY28gY2VydGlmaWNhZG8uPGJyIC8+IAoJCUNvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvIFNTTC9UTFM8L2E+PC9kZD4KCgoKCQk8ZHQ+PGEgbmFtZT0iaHlwZXJ0ZXh0dHJhbnNmZXJwcm90b2NvbCIgaWQ9Imh5cGVydGV4dHRyYW5zZmVycHJvdG9jb2wiPlByb3RvY29sbyBkZSBUcmFuc2ZlcmVuY2lhIGRlCgkJSGlwZXJ0ZXh0bzwvYT4gPGEgbmFtZT0iaHR0cCI+KEhUVFApPC9hPjwvZHQ+IAoJCTxkZD5FcyBlbCBwcm90b2NvbG8gZGUKCQl0cmFuc21pc2nzbiBlc3ThZGFyIHVzYWRvIGVuIGxhIFdvcmxkIFdpZGUgV2ViLiAgQXBhY2hlCgkJaW1wbGVtZW50YSBsYSB2ZXJzafNuIDEuMSBkZSBlc3RlIHByb3RvY29sbywgYWwgcXVlIHNlIGhhY2UKCQlyZWZlcmVuY2lhIGNvbW8gSFRUUC8xLjEgeSBkZWZpbmlkbyBwb3IgZWwgPGEgaHJlZj0iaHR0cDovL2lldGYub3JnL3JmYy9yZmMyNjE2LnR4dCI+UkZDIDI2MTY8L2E+LjwvZGQ+CgoJCTxkdD48YSBuYW1lPSJodHRwcyIgaWQ9Imh0dHBzIj5IVFRQUzwvYT48L2R0PgoJCTxkZD5Qcm90b2NvbG8gZGUgdHJhbnNmZXJlbmNpYSBkZQoJCUhpcGVydGV4dG8gKFNlZ3VybyksIGVzIGVsIG1lY2FuaXNtbyBkZSBjb211bmljYWNp824gZW5jcmlwdGFkbwoJCWVzdOFuZGFyIGVuIFdvcmxkIFdpZGUgV2ViLiBFbiByZWFsaWRhZCBlcyBIVFRQIHNvYnJlIDxhIGNsYXNzPSJnbG9zc2FyeWxpbmsiIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCNzc2wiIHRpdGxlPSJ2ZXIgZ2xvc2FyaW8iPlNTTDwvYT4uPGJyIC8+IENvbnN1bHRlOiA8YSBocmVmPSJzc2wvIj5FbmNyaXB0YWRvCgkJU1NML1RMUzwvYT48L2RkPgoKCQk8ZHQ+PGEgbmFtZT0icHJveHkiIGlkPSJwcm94eSI+UHJveHk8L2E+PC9kdD4gPGRkPlVuIHNlcnZpZG9yIGludGVybWVkaW8gcXVlIHNlCgkJcG9uZSBlbnRyZSBlbCBjbGllbnRlIHkgZWwgPGVtPnNlcnZpZG9yIGRlIG9yaWdlbjwvZW0+LiAgQWNlcHRhIGxhcwoJCXBldGljaW9uZXMgZGUgbG9zIGNsaWVudGVzLCBsYXMgdHJhbnNtaXRlIGFsIHNlcnZpZG9yIGRlIG9yaWdlbiwgeQoJCWRlc3B16XMgZGV2dWVsdmUgbGEgcmVzcHVlc3RhIGRlbCBzZXJ2aWRvciBkZSBvcmlnZW4gYWwKCQljbGllbnRlLiBTaSB2YXJpb3MgY2xpZW50ZXMgcGlkZW4gZWwgbWlzbW8gY29udGVuaWRvLCBlbCBwcm94eSBzaXJ2ZQoJCWVsIGNvbnRlbmlkbyBkZXNkZSBzdSBjYWNo6SwgZW4gbHVnYXIgZGUgcGVkaXJsbyBjYWRhIHZleiBxdWUgbG8KCQluZWNlc2l0YSBhbCBzZXJ2aWRvciBkZSBvcmlnZW4sIHJlZHVjaWVuZG8gY29uIGVzdG8gZWwgdGllbXBvIGRlCgkJcmVzcHVlc3RhLjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0ibW9kL21vZF9wcm94eS5odG1sIj5tb2RfcHJveHk8L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJyZXZlcnNlcHJveHkiIGlkPSJyZXZlcnNlcHJveHkiPlByb3h5IEludmVyc288L2E+PC9kdD4KCQk8ZGQ+RXMgdW4gc2Vydmlkb3IKCQk8YSBocmVmPSJwcm94eSI+cHJveHk8L2E+IHF1ZSBzZSBwcmVzZW50YSBhbCBjbGllbnRlIGNvbW8gc2kgZnVlcmEgdW4KCQk8ZW0+c2Vydmlkb3IgZGUgb3JpZ2VuPC9lbT4uICBFcyD6dGlsIHBhcmEgZXNjb25kZXIgZWwKCQlhdXTpbnRpY28gc2Vydmlkb3IgZGUgb3JpZ2VuIGEgbG9zIGNsaWVudGVzIHBvciBjdWVzdGlvbmVzIGRlCgkJc2VndXJpZGFkLCBvIHBhcmEgZXF1aWxpYnJhciBsYSBjYXJnYS48L2RkPgoKCgkJPGR0PjxhIG5hbWU9InNlY3VyZXNvY2tldHNsYXllciIgaWQ9InNlY3VyZXNvY2tldHNsYXllciI+U1NMLCBDYXBhIGRlIENvbmV4afNuIFNlZ3VyYSA8L2E+IDxhIG5hbWU9InNzbCI+U2VjdXJlIFNvY2tldHMgTGF5ZXIoU1NMKTwvYT48L2R0PiA8ZGQ+RXMgdW4gcHJvdG9jb2xvIGNyZWFkbyBwb3IgTmV0c2NhcGUKCQlDb21tdW5pY2F0aW9ucyBDb3Jwb3JhdGlvbiBwYXJhIGxhIGF1dGVudGljYWNp824gZW4KCQljb211bmljYWNpb25lcyBlbiBnZW5lcmFsIHkgZW5jcmlwdGFkbyBzb2JyZSByZWRlcyBUQ1AvSVAuIFN1CgkJYXBsaWNhY2nzbiBt4XMgcG9wdWxhciBlcyBlbiA8ZW0+SFRUUFM8L2VtPiwgZWplbXBsby46IGVsIFByb3RvY29sbyBkZQoJCVRyYW5zZmVyZW5jaWEgZGUgSGlwZXJ0ZXh0byAoSFRUUCkgc29icmUgU1NMLjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0ic3NsLyI+RW5jcmlwdGFkbyBTU0wvVExTPC9hPjwvZGQ+CgoKCQk8ZHQ+PGEgbmFtZT0ic3NsZWF5IiBpZD0ic3NsZWF5Ij5TU0xlYXk8L2E+PC9kdD4gPGRkPkxhIGltcGxlbWVudGFjafNuCgkJb3JpZ2luYWwgZGUgbGEgbGlicmVy7WEgU1NML1RMUyBkZXNhcnJvbGxhZGEgcG9yIEVyaWMKCQlBLiBZb3VuZzwvZGQ+CgoKCgkJPGR0PjxhIG5hbWU9InNlcnZlcnNpZGVpbmNsdWRlcyIgaWQ9InNlcnZlcnNpZGVpbmNsdWRlcyI+U2VydmVyIFNpZGUgSW5jbHVkZXM8L2E+IDxhIG5hbWU9InNzaSI+KFNTSSk8L2E+PC9kdD4gPGRkPlVuYSB06WNuaWNhIHBhcmEgaW5jbHVpciBkaXJlY3RpdmFzIGRlCgkJcHJvY2VzbyBlbiBhcmNoaXZvcyBIVE1MLjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0iaG93dG8vc3NpLmh0bWwiPkludHJvZHVjY2nzbiBhIFNlcnZlciBTaWRlCgkJSW5jbHVkZXM8L2E+PC9kZD4KCgoKCQk8ZHQ+PGEgbmFtZT0ic2Vzc2lvbiIgaWQ9InNlc3Npb24iPlNlc2nzbjwvYT48L2R0PiA8ZGQ+SW5mb3JtYWNp824gZGVsCgkJY29udGV4dG8gZGUgdW5hIGNvbXVuaWNhY2nzbiBlbiBnZW5lcmFsLjwvZGQ+CgoKCQk8ZHQ+PGEgbmFtZT0icHVibGlja2V5Y3J5cHRvZ3JhcGh5IiBpZD0icHVibGlja2V5Y3J5cHRvZ3JhcGh5Ij5TaXN0ZW1hIENyaXB0b2dy4WZpY28gZGUgQ2xhdmUKCQlQ+mJsaWNhPC9hPjwvZHQ+IDxkZD5FbCBlc3R1ZGlvIHkgYXBsaWNhY2nzbiBkZSBzaXN0ZW1hcyBkZQoJCWVuY3JpcHRhZG8gYXNpbel0cmljb3MsIHF1ZSB1c2EgdW5hIGNsYXZlIHBhcmEgZW5jcmlwdGFyIHkgb3RyYQoJCXBhcmEgZGVzZW5jcmlwdGFyLiBVbmEgY2xhdmUgZGUgY2FkYSB1bm8gZGUgZXN0b3MgdGlwb3MgY29uc3RpdHV5ZSB1bgoJCXBhciBkZSBjbGF2ZXMuIFRhbWJp6W4gc2UgbGxhbWEgQ3JpcHRvZ3JhZu1hIEFzaW3pdHJpY2EuPGJyIC8+CgkJQ29uc3VsdGU6IDxhIGhyZWY9InNzbC8iPiBFbmNyaXB0YWRvIFNTTC9UTFM8L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJzdWJyZXF1ZXN0IiBpZD0ic3VicmVxdWVzdCI+U3ViY29uc3VsdGE8L2E+PC9kdD4KCQk8ZGQ+QXBhY2hlIHByb3BvcmNpb25hIHVuYSBBUEkgZGUgc3ViY29uc3VsdGFzZCBhIGxvcyBt82R1bG9zLAoJCXF1ZSBwZXJtaXRlbiBhIG90cm9zIHNpc3RlbWFzIGRlIGZpY2hlcm9zIG8gcGF0aHMgZGUgVVJMIHNlciBwYXJjaWFsIG8gdG90YWxtZW50ZSBldmFsdWFkb3MKCQlwb3IgZWwgc2Vydmlkb3IuIFVuIGVqZW1wbG8gZGUgbG9zIHF1ZSB1c2FuIGVzdGEgQVBJIHNlcu1hCgkJPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi9tb2QvbW9kX2Rpci5odG1sI2RpcmVjdG9yeWluZGV4Ij5EaXJlY3RvcnlJbmRleDwvYT48L2NvZGU+LAoJCTxjb2RlIGNsYXNzPSJtb2R1bGUiPjxhIGhyZWY9Ii4vbW9kL21vZF9hdXRvaW5kZXguaHRtbCI+bW9kX2F1dG9pbmRleDwvYT48L2NvZGU+LCB5IDxjb2RlIGNsYXNzPSJtb2R1bGUiPjxhIGhyZWY9Ii4vbW9kL21vZF9pbmNsdWRlLmh0bWwiPm1vZF9pbmNsdWRlPC9hPjwvY29kZT4uCgkJPC9kZD4KCgkJPGR0PjxhIG5hbWU9InRhcmJhbGwiIGlkPSJ0YXJiYWxsIj5UYXJiYWxsPC9hPjwvZHQ+IDxkZD5VbiBncnVwbyBkZSBmaWNoZXJvcwoJCXB1ZXN0b3MgZW4gdW4gc29sbyBwYXF1ZXRlIHVzYW5kbyBsYSB1dGlsaWRhZCA8Y29kZT50YXI8L2NvZGU+LiAgTGFzCgkJZGlzdHJpYnVjaW9uZXMgQXBhY2hlIHNlIGFsbWFjZW5hbiBlbiBmaWNoZXJvcyBjb21wcmltaWRvcyBjb24gdGFyIG8KCQljb24gcGt6aXAuPC9kZD4KCgkJPGR0PjxhIG5hbWU9ImNpcGhlcnRleHQiIGlkPSJjaXBoZXJ0ZXh0Ij5UZXh0byBjaWZyYWRvLjwvYT48L2R0PiAKCQk8ZGQ+RWwgcmVzdWx0YWRvIGRlCgkJaGFiZXIgYXBsaWNhZG8gYSB1biA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuL2dsb3NzYXJ5Lmh0bWwjcGxhaW50ZXh0IiB0aXRsZT0idmVyIGdsb3NhcmlvIj50ZXh0byBwbGFubzwvYT4gdW4gPGEgY2xhc3M9Imdsb3NzYXJ5bGluayIgaHJlZj0iLi9nbG9zc2FyeS5odG1sI2NpcGhlciIgdGl0bGU9InZlciBnbG9zYXJpbyI+YWxnb3JpdG1vIGRlIGNpZnJhZG88L2E+LjxiciAvPiBDb25zdWx0YXI6IDxhIGhyZWY9InNzbC8iPkVuY3JpcHRhZG8gU1NML1RMUzwvYT48L2RkPgoKCgoJCTxkdD48YSBuYW1lPSJwbGFpbnRleHQiIGlkPSJwbGFpbnRleHQiPlRleHRvIHBsYW5vPC9hPjwvZHQ+CgkJPGRkPlVuIHRleHRvIG5vIGVuY3JpcHRhZG8uPC9kZD4KCgoJCTxkdD48YSBuYW1lPSJ0cmFuc3BvcnRsYXllcnNlY3VyaXR5IiBpZD0idHJhbnNwb3J0bGF5ZXJzZWN1cml0eSI+VHJhbnNwb3J0IAoJCQlMYXllciBTZWN1cml0eTwvYT4gPGEgbmFtZT0idGxzIj4oVExTKTwvYT48L2R0PiA8ZGQ+RXMgZWwgc3VjZXNvciBkZWwgcHJvdG9jb2xvIFNTTCwgY3JlYWRvCgkJcG9yIGVsICJJbnRlcm5ldCBFbmdpbmVlcmluZyBUYXNrIEZvcmNlIiAoSUVURikgcGFyYSBsYQoJCWF1dGVudGlmaWNhY2nzbiBlbiBjb211bmljYWNpb25lcyBlbiBnZW5lcmFsIHkgZW5jcmlwdGFkbyBzb2JyZQoJCXJlZGVzIFRDUC9JUC4gTGEgdmVyc2nzbiAxIGRlIFRMUyBlcyBjYXNpIGlk6W50aWNhIGEgbGEKCQl2ZXJzafNuIDMgZGUgU1NMLjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0ic3NsLyI+RW5jcmlwdGFkbwoJCVNTTC9UTFM8L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJlbnZpcm9ubWVudHZhcmlhYmxlIiBpZD0iZW52aXJvbm1lbnR2YXJpYWJsZSI+VmFyaWFibGUgZGUgRW50b3JubzwvYT4gPGEgbmFtZT0iZW52LXZhcmlhYmxlIj4oZW52LXZhcmlhYmxlKTwvYT48L2R0PiAKCQk8ZGQ+VmFyaWFibGVzIHF1ZQoJCWdlc3Rpb25hbiBlbCBzaGVsbCBkZWwgc2lzdGVtYSBvcGVyYXRpdm8geSBxdWUgc2UgdXNhbiBwYXJhIGd1YXJkYXIKCQlpbmZvcm1hY2nzbiB5IHBhcmEgbGEgY29tdW5pY2FjafNuIGVudHJlIHByb2dyYW1hcy4gIEFwYWNoZQoJCXRhbWJp6W4gY29udGllbmUgdmFyaWFibGVzIGludGVybmFzIHF1ZSBzb24gcmVmZXJpZGFzIGNvbW8KCQl2YXJpYWJsZXMgZGUgZW50b3JubywgcGVybyBxdWUgc29uIGFsbWFjZW5hZGFzIGVuIGxhcyBlc3RydWN0dXJhcwoJCWludGVybmFzIGRlIEFwYWNoZSwgZW4gbHVnYXIgZGUgZW4gZWwgZW50b3JubyBkZWwgc2hlbGwuPGJyIC8+CgkJQ29uc3VsdGU6IDxhIGhyZWY9ImVudi5odG1sIj5WYXJpYWJsZXMgZGUgZW50b3JubyBkZSBBcGFjaGU8L2E+PC9kZD4KCgoJCTxkdD48YSBuYW1lPSJ4LjUwOSIgaWQ9InguNTA5Ij5YLjUwOTwvYT48L2R0PiA8ZGQ+VW4gZXNxdWVtYSBkZSBjZXJ0aWZpY2FkbyBkZQoJCWF1dGVudGlmaWNhY2nzbiByZWNvbWVuZGFkbyBwb3IgbGEgSW50ZXJuYXRpb25hbAoJCVRlbGVjb21tdW5pY2F0aW9uIFVuaW9uIChJVFUtVCkgcXVlIHNlIHVzYSBlbiBsYSBhdXRlbnRpZmljYWNp824KCQlTU0wvVExTLjxiciAvPiBDb25zdWx0ZTogPGEgaHJlZj0ic3NsLyI+RW5jcmlwdGFkbyBTU0wvVExTPC9hPjwvZGQ+CgoJCTwvZGw+Cgk8L2Rpdj48L2Rpdj4KPGRpdiBjbGFzcz0iYm90dG9tbGFuZyI+CjxwPjxzcGFuPklkaW9tYXMgZGlzcG9uaWJsZXM6IDwvc3Bhbj48YSBocmVmPSIuL2RlL2dsb3NzYXJ5Lmh0bWwiIGhyZWZsYW5nPSJkZSIgcmVsPSJhbHRlcm5hdGUiIHRpdGxlPSJEZXV0c2NoIj4mbmJzcDtkZSZuYnNwOzwvYT4gfAo8YSBocmVmPSIuL2VuL2dsb3NzYXJ5Lmh0bWwiIGhyZWZsYW5nPSJlbiIgcmVsPSJhbHRlcm5hdGUiIHRpdGxlPSJFbmdsaXNoIj4mbmJzcDtlbiZuYnNwOzwvYT4gfAo8YSBocmVmPSIuL2VzL2dsb3NzYXJ5Lmh0bWwiIHRpdGxlPSJFc3Bh8W9sIj4mbmJzcDtlcyZuYnNwOzwvYT4gfAo8YSBocmVmPSIuL2ZyL2dsb3NzYXJ5Lmh0bWwiIGhyZWZsYW5nPSJmciIgcmVsPSJhbHRlcm5hdGUiIHRpdGxlPSJGcmFu52FpcyI+Jm5ic3A7ZnImbmJzcDs8L2E+IHwKPGEgaHJlZj0iLi9qYS9nbG9zc2FyeS5odG1sIiBocmVmbGFuZz0iamEiIHJlbD0iYWx0ZXJuYXRlIiB0aXRsZT0iSmFwYW5lc2UiPiZuYnNwO2phJm5ic3A7PC9hPiB8CjxhIGhyZWY9Ii4va28vZ2xvc3NhcnkuaHRtbCIgaHJlZmxhbmc9ImtvIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IktvcmVhbiI+Jm5ic3A7a28mbmJzcDs8L2E+IHwKPGEgaHJlZj0iLi90ci9nbG9zc2FyeS5odG1sIiBocmVmbGFuZz0idHIiIHJlbD0iYWx0ZXJuYXRlIiB0aXRsZT0iVPxya+dlIj4mbmJzcDt0ciZuYnNwOzwvYT48L3A+CjwvZGl2PjxkaXYgY2xhc3M9InRvcCI+PGEgaHJlZj0iI3BhZ2UtaGVhZGVyIj48aW1nIHNyYz0iLi9pbWFnZXMvdXAuZ2lmIiBhbHQ9InRvcCIgLz48L2E+PC9kaXY+PGRpdiBjbGFzcz0ic2VjdGlvbiI+PGgyPjxhIGlkPSJjb21tZW50c19zZWN0aW9uIiBuYW1lPSJjb21tZW50c19zZWN0aW9uIj5Db21lbnRhcmlvczwvYT48L2gyPjxkaXYgY2xhc3M9Indhcm5pbmciPjxzdHJvbmc+Tm90aWNlOjwvc3Ryb25nPjxiciAvPlRoaXMgaXMgbm90IGEgUSZhbXA7QSBzZWN0aW9uLiBDb21tZW50cyBwbGFjZWQgaGVyZSBzaG91bGQgYmUgcG9pbnRlZCB0b3dhcmRzIHN1Z2dlc3Rpb25zIG9uIGltcHJvdmluZyB0aGUgZG9jdW1lbnRhdGlvbiBvciBzZXJ2ZXIsIGFuZCBtYXkgYmUgcmVtb3ZlZCBhZ2FpbiBieSBvdXIgbW9kZXJhdG9ycyBpZiB0aGV5IGFyZSBlaXRoZXIgaW1wbGVtZW50ZWQgb3IgY29uc2lkZXJlZCBpbnZhbGlkL29mZi10b3BpYy4gUXVlc3Rpb25zIG9uIGhvdyB0byBtYW5hZ2UgdGhlIEFwYWNoZSBIVFRQIFNlcnZlciBzaG91bGQgYmUgZGlyZWN0ZWQgYXQgZWl0aGVyIG91ciBJUkMgY2hhbm5lbCwgI2h0dHBkLCBvbiBGcmVlbm9kZSwgb3Igc2VudCB0byBvdXIgPGEgaHJlZj0iaHR0cDovL2h0dHBkLmFwYWNoZS5vcmcvbGlzdHMuaHRtbCI+bWFpbGluZyBsaXN0czwvYT4uPC9kaXY+CjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij48IS0tLy8tLT48IVtDREFUQVsvLz48IS0tCnZhciBjb21tZW50c19zaG9ydG5hbWUgPSAnaHR0cGQnOwp2YXIgY29tbWVudHNfaWRlbnRpZmllciA9ICdodHRwOi8vaHR0cGQuYXBhY2hlLm9yZy9kb2NzL3RydW5rL2dsb3NzYXJ5Lmh0bWwnOwooZnVuY3Rpb24odywgZCkgewogICAgaWYgKHcubG9jYXRpb24uaG9zdG5hbWUudG9Mb3dlckNhc2UoKSA9PSAiaHR0cGQuYXBhY2hlLm9yZyIpIHsKICAgICAgICBkLndyaXRlKCc8ZGl2IGlkPSJjb21tZW50c190aHJlYWQiPjxcL2Rpdj4nKTsKICAgICAgICB2YXIgcyA9IGQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7CiAgICAgICAgcy50eXBlID0gJ3RleHQvamF2YXNjcmlwdCc7CiAgICAgICAgcy5hc3luYyA9IHRydWU7CiAgICAgICAgcy5zcmMgPSAnaHR0cHM6Ly9jb21tZW50cy5hcGFjaGUub3JnL3Nob3dfY29tbWVudHMubHVhP3NpdGU9JyArIGNvbW1lbnRzX3Nob3J0bmFtZSArICcmcGFnZT0nICsgY29tbWVudHNfaWRlbnRpZmllcjsKICAgICAgICAoZC5nZXRFbGVtZW50c0J5VGFnTmFtZSgnaGVhZCcpWzBdIHx8IGQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoJ2JvZHknKVswXSkuYXBwZW5kQ2hpbGQocyk7CiAgICB9CiAgICBlbHNlIHsKICAgICAgICBkLndyaXRlKCc8ZGl2IGlkPSJjb21tZW50c190aHJlYWQiPkNvbW1lbnRzIGFyZSBkaXNhYmxlZCBmb3IgdGhpcyBwYWdlIGF0IHRoZSBtb21lbnQuPFwvZGl2PicpOwogICAgfQp9KSh3aW5kb3csIGRvY3VtZW50KTsKLy8tLT48IV1dPjwvc2NyaXB0PjwvZGl2PjxkaXYgaWQ9ImZvb3RlciI+CjxwIGNsYXNzPSJhcGFjaGUiPkNvcHlyaWdodCAyMDE2IFRoZSBBcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbi48YnIgLz5MaWNlbmNpYSBiYWpvIGxvcyB06XJtaW5vcyBkZSBsYSA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPkFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMDwvYT4uPC9wPgo8cCBjbGFzcz0ibWVudSI+PGEgaHJlZj0iLi9tb2QvIj5N82R1bG9zPC9hPiB8IDxhIGhyZWY9Ii4vbW9kL3F1aWNrcmVmZXJlbmNlLmh0bWwiPkRpcmVjdGl2YXM8L2E+IHwgPGEgaHJlZj0iaHR0cDovL3dpa2kuYXBhY2hlLm9yZy9odHRwZC9GQVEiPlByZWd1bnRhcyBGcmVjdWVudGVzPC9hPiB8IDxhIGhyZWY9Ii4vZ2xvc3NhcnkuaHRtbCI+R2xvc2FyaW88L2E+IHwgPGEgaHJlZj0iLi9zaXRlbWFwLmh0bWwiPk1hcGEgZGVsIHNpdGlvIHdlYjwvYT48L3A+PC9kaXY+PHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPjwhLS0vLy0tPjwhW0NEQVRBWy8vPjwhLS0KaWYgKHR5cGVvZihwcmV0dHlQcmludCkgIT09ICd1bmRlZmluZWQnKSB7CiAgICBwcmV0dHlQcmludCgpOwp9Ci8vLS0+PCFdXT48L3NjcmlwdD4KPC9ib2R5PjwvaHRtbD4=