IwojICBUaGlzIGlzIHRoZSBtYWluIGkxOG4gcmVzb3VyY2UgZmlsZSBmb3IgSlNQV2lraSBpbnRlcm5hbAojICBjb2RlLCB0aGUgc28tY2FsbGVkIGNvcmUgY29kZS4KIwoKIyBEZWNpc2lvbnM6IHswfT10YXNrIG93bmVyOyB7MX09cmVxdWVzdGVyOyB7Mi05fT1hZGRpdGlvbmFsIG1lc3NhZ2UgYXJndW1lbnRzIGZvciB3b3JrZmxvdwpkZWNpc2lvbi5lZGl0V2lraUFwcHJvdmFsPU11b2trYWEgc2l2dWEgezJ9CgojIFNlY3VyaXR5CgpzZWN1cml0eS5lcnJvci5ub2FjY2Vzcy5sb2dnZWQ9U2ludWxsYSBlaSBvbGUgcOTkc3nkIHJlc3Vyc3NpaW4gJnF1b3Q7ezB9JnF1b3Q7LiAgSGFsdWF0a28ga2lyamF1dHVhIHRvaXNlbmEga+R5dHTkauRu5D8Kc2VjdXJpdHkuZXJyb3Iubm9hY2Nlc3M9U2ludWxsYSBlaSBvbGUgcOTkc3nkIHJlc3Vyc3NpaW4gJnF1b3Q7ezB9JnF1b3Q7LiAgT2xlIGh5duQsIGphIGtpcmphdWR1IGVuc2luIHNpc+Tkbi4Kc2VjdXJpdHkuZXJyb3Iud3JvbmdpcD1Zcml0ZXR0aWluIGzkaGV0dOTkIHZpZXN0aSBlcmkgb3NvaXR0ZWVzdGEga3VpbiBtaW5uZSBzaXZ1IGFsdW5wZXJpbiBvbGkgbORoZXRldHR5IQoKc2VjdXJpdHkuZXJyb3IuY3JlYXRlcHJvZmlsZWJlZm9yZWxvZ2luPVNpbnVuIG9uIGtpcmphdWR1dHRhdmEgZW5uZW4ga3VpbiBsdW90IHByb2ZpaWxpbgpzZWN1cml0eS5lcnJvci5ibGFua3Bhc3N3b3JkPVNhbGFzYW5hIGVpIHZvaSBvbGxhIHR5aGrkCnNlY3VyaXR5LmVycm9yLnBhc3N3b3Jkbm9tYXRjaD1TYWxhc2FuYW4gdmFybWlzdHVzIGVpIHTkc23kbm55dCBpdHNlIHNhbGFzYW5hbiBrYW5zc2EKCnNlY3VyaXR5LmVycm9yLmlsbGVnYWxmdWxsbmFtZT1Lb2tvIG5pbWkgJnF1b3Q7ezB9JnF1b3Q7IGVpIG9sZSBzYWxsaXR0dQpzZWN1cml0eS5lcnJvci5pbGxlZ2FsbG9naW5uYW1lPUtpcmphdXR1bWlzbmltaSAmcXVvdDt7MH0mcXVvdDsgZWkgb2xlIHNhbGxpdHR1CgojIFRoZXNlIHNob3VsZCByb3VnaGx5IG1hdGNoIHdoYXRldmVyIGlzIHVzZWQgaW4gZGVmYXVsdC5wcm9wZXJ0aWVzIGZvciBVc2VyUHJvZmlsZS5qc3AKc2VjdXJpdHkudXNlci5sb2dpbm5hbWU9S+R5dHTkauR0dW51cwpzZWN1cml0eS51c2VyLmZ1bGxuYW1lPU5pbWkKc2VjdXJpdHkudXNlci5lbWFpbD1T5Ghr9nBvc3Rpb3NvaXRlCgojIFJlbmFtaW5nCgpyZW5hbWUuZW1wdHk9VHloauQgc2l2dW5uaW1pLiAgUGFpbmEgc2VsYWltZXNpICJUYWthaXNpbiIgLXBhaW5pa2V0dGEgamEgdOR5dOQgbG9tYWtrZWVzZWVuIHV1c2kgbmltaS4KcmVuYW1lLmVycm9yLnRpdGxlPVZpcmhlIHNpdnVuIG5pbWXkbWlzZXNz5ApyZW5hbWUuZXJyb3IucmVhc29uPVN5eToKcmVuYW1lLmlkZW50aWNhbD1VdWRlbiBzaXZ1biBuaW1pIHNhbWEga3VpbiB2YW5oYW4uICBQYWluYSBzZWxhaW1lc2kgIlRha2Fpc2luIiAtcGFpbmlrZXR0YSBqYSB2YWloZGEgbG9tYWtrZWVzZWVuIHV1c2kgbmltaS4KcmVuYW1lLmV4aXN0cz1TaXZ1ICJ7MH0iIG9uIGpvIG9sZW1hc3NhLiBQYWluYSBzZWxhaW1lc2kgIlRha2Fpc2luIiAtcGFpbmlrZXR0YSBqYSB05Hl05CBsb21ha2tlZXNlZW4gdXVzaSBuaW1pLCB0YWkgcG9pc3RhIHNpdnUgInswfSIgZW5zaW4uCnJlbmFtZS51bmtub3duZXJyb3I9VHVudGVtYXRvbiBo5HJq9iAoezB9KQoKIyBMb3N0cGFzc3dvcmQKCiMgMCA9IGxvZ2luIG5hbWUsIDEgPSBwYXNzd29yZCwgMiA9IFVSTCwgMyA9IEFwcGxpY2F0aW9uIG5hbWUgKGFzIHNpZ25hdHVyZSkKIyBUaGlzIGlzIHBsYWluIHRleHQsIG5vdCBIVE1MLgpsb3N0cHdkLm5ld3Bhc3N3b3JkLmVtYWlsPVV1c2kgc2FsYXNhbmFzaSB0dW5udWtzZWxsZSAiezB9IiBvbiAiezF9IiBcCiAgICAgICAgICAgICAgICAgICAgXG5cblZvaXQga+R5dHTk5CBzaXTkIG1lbmVt5Gxs5CBvc29pdHRlZXNlZW4gezJ9LlxuXG4tLSBUZXJ2ZWlzaW4sIHszfQpsb3N0cHdkLm5ld3Bhc3N3b3JkLnN1YmplY3Q9ezB9OiBVdXNpIHNhbGFzYW5hc2kKbG9zdHB3ZC5ub3VzZXI9S+R5dHTkauTkIHRhaSBz5Ghr9nBvc3Rpb3NvaXRldHRhICYjMzk7ezB9JiMzOTsgZWkgbPZ5ZGV0dHkuCmxvc3Rwd2Qubm9tYWlsPUrkcmplc3RlbG3kdmlyaGU6IGVuIHZvaW51dCBs5GhldHTk5CBz5Ghr9nBvc3RpYS4gIE9saXNpdGtvIG5paW4ga2lsdHRpLCBldHTkIGlsbW9pdHRhaXNpdCBhc2lhc3RhIHlsbORwaWRvbGxlPwpsb3N0cHdkLmVtYWlsZWQ9VXVzaSBzYWxhc2FuYSBvbiBs5GhldGV0dHkgc+Roa/Zwb3N0aXRzZS4KCmxvc3Rwd2QucmVzZXQudGl0bGU9UHl5ZOQgdXVzaSBzYWxhc2FuYQpsb3N0cHdkLnJlc2V0LnVuYWJsZT1FbiB2b2ludXQgbHVvZGEgdXV0dGEgc2FsYXNhbmFhLiAgT2xlIGh5duQsIGphIHlyaXTkIHV1ZGVsbGVlbi4KCmxvc3Rwd2QucmVzZXQuYmx1cmI9VW5vaGRpdGtvIHRhaSBodWtrYXNpdGtvIHNhbGFzYW5hc2k/ICBLaXJqb2l0YSBr5Hl0dORq5HR1bm51a3Nlc2kgdGFpIHPkaGv2cG9zdGlvc29pdHRlZXNpIHNhYWRha3Nlc2kgdXVkZW46Cmxvc3Rwd2QucmVzZXQuc3VibWl0PVV1c2kgc2FsYXNhbmEhCgojIFRyYWRpdGlvbmFsRGlmZlByb3ZpZGVyCgpkaWZmLnRyYWRpdGlvbmFsLmFkZGVkPVJpdmlsbGUgezB9IGxpc+R0dGlpbiB7MX0KZGlmZi50cmFkaXRpb25hbC5jaGFuZ2VkPVJpdmlsdOQgezB9IGFsa2FlbiBtdXV0ZXR0aWluIHsxfQpkaWZmLnRyYWRpdGlvbmFsLnJlbW92ZWQ9Uml2aWx05CB7MH0gYWxrYWVuIHBvaXN0ZXR0aWluIHsxfQpkaWZmLnRyYWRpdGlvbmFsLm9uZWxpbmU9eWtzaSByaXZpCmRpZmYudHJhZGl0aW9uYWwubGluZXM9ezJ9IHJpdmnkCgojIElucHV0VmFsaWRhdG9yCgp2YWxpZGF0ZS51bnNhZmVjaGFycz17MH0gZWkgc2FhIHNpc+RsdOTkIHNldXJhYXZpYSBtZXJra2Vq5DogezF9CnZhbGlkYXRlLmludmFsaWRlbWFpbD17MH0gZWkgb2xlIHNhbGxpdHVzc2EgbXVvZG9zc2EKdmFsaWRhdGUuY2FudGJlbnVsbD17MH0gZWkgc2FhIG9sbGEgdHloauQKCiMgVXNlclByb2ZpbGVUYWcKCnVzZXJwcm9maWxlLm5vZ3JvdXBzPSh0eWhq5CkKdXNlcnByb2ZpbGUubm9yb2xlcz0odHloauQpCgojIE5ld0dyb3VwLmpzcApuZXdncm91cC5leGlzdHM9UnlobeQgezB9IG9uIGpvIG9sZW1hc3NhLiBZcml05CBqb3RhaW4gdG9pc3RhIG5pbWXkLgoKIyBMb2dpbi5qc3AKCmxvZ2luLmVycm9yLmNhcHNsb2NrPVZpcmhlZWxsaW5lbiBr5Hl0dORq5HR1bm51cyB0YWkgc2FsYXNhbmEgKHRhcmtpc3RhIENhcHMgTG9jay1u5HBw5GltZXNpIHRpbGEhKQpsb2dpbi5lcnJvci5wYXNzd29yZD1WaXJoZWVsbGluZW4ga+R5dHTkauR0dW5udXMgdGFpIHNhbGFzYW5hCmxvZ2luLmVycm9yLm5vYWNjZXNzPVZhbGl0ZXR0YXZhc3RpIHNpbnVsbGEgZWkgbuR5dOQgb2xldmFuIHDk5HN55CBoYWx1YW1hbGxlc2kgc2l2dWxsZS4gIFBhaG9pdHRlbHVtbWUuCgojIEpTUFdpa2lNYXJrdXBQYXJzZXIKbWFya3VwcGFyc2VyLmVycm9yLmludmFsaWRzZXQgPSBWaXJoZWVsbGluZW4gU0VULWxhdXNla2U6IHswfQptYXJrdXBwYXJzZXIuZXJyb3Iubm9pbnRlcndpa2lyZWYgPSBJbnRlcndpa2ktbGlua2tp5CB3aWtpbGxlIG5pbWVsdOQgInswfSIgZWkgbPZ5dHlueXQgYXNldHVrc2lzdGEhCm1hcmt1cHBhcnNlci5lcnJvci5wYXJzZXJmYWlsdXJlID0gSuRzZW5ueXN2aXJoZTogezB9Cm1hcmt1cHBhcnNlci5lcnJvci5qYXZhc2NyaXB0YXR0ZW1wdCA9IFlyaXR5cyB0dWxvc3RhYSBKYXZhc2NyaXB0LWtpZWx05CBoYXZhaXR0dSEKbWFya3VwcGFyc2VyLmxpbmsuY3JlYXRlID0gTHVvICJ7MH0iCgojIEluc3RhbGxlcgppbnN0YWxsLmluc3RhbGxlci5kZWZhdWx0LmFwcG5hbWUgPSBNdW5XaWtpCmluc3RhbGwuaW5zdGFsbGVyLmRlZmF1bHQucGFnZWRpciA9IExhaXRhIGFzZXR1a3NldCBrdW50b29uOgppbnN0YWxsLmluc3RhbGxlci5wcm9wcy5ub3RzYXZlZCA9IEFzZXR1a3NpYSBlaSB2b2l0dSB0YWxsZW50YWE6IHswfS4gIEtvcGlvaSBhbGxhIG9sZXZhIHRpZWRvc3RvIGpzcHdpa2kucHJvcGVydGllcy10aWVkb3N0b2tzZXNpLiB7MX0KaW5zdGFsbC5pbnN0YWxsZXIucHJvcHMuc2F2ZWQgPSBVdWRldCBhc2V0dWtzZXNpIG9uIHRhbGxlbm5ldHR1LiAgT2xlIGh5duQsIGphIGvkeW5uaXN05CBzZXJ2bGV0LXltcORyaXN09nNpIHV1ZGVsbGVlbi4gIEtlbGFhIHNpdnVhIGhpZW1hbiBhbGFzcORpbiBu5Ghk5GtzZXNpIHV1ZGVuIGpzcHdpa2kucHJvcGVydGllcyAtYXNldHVzdGllZG9zdG9zaS4KaW5zdGFsbC5pbnN0YWxsZXIudW5hYmxlLnJlYWQucHJvcHMgPSBFbiB2b2ludXQgbHVrZWEgYXNldHVrc2lhOiB7MH0KaW5zdGFsbC5pbnN0YWxsZXIudmFsaWRhdGUuYXBwbmFtZSA9IFNpbnVuIG9uIG3k5HJpdGVsdOR25CB3aWtpbGxlc2kgbmltaS4KaW5zdGFsbC5pbnN0YWxsZXIudmFsaWRhdGUuYmFzZXVybCA9IFNpbnVuIG9uIG3k5HJpdGVsdOR25CBwZXJ1cy1VUkwgdORsbGUgd2lraWxsZS4KaW5zdGFsbC5pbnN0YWxsZXIudmFsaWRhdGUubG9nZGlyID0gU2ludW4gb24gbeTkcml0ZWx05HbkIGhha2VtaXN0byBsb2tlaWxsZS4KaW5zdGFsbC5pbnN0YWxsZXIudmFsaWRhdGUucGFnZWRpciA9IFNpbnVuIG9uIG3k5HJpdGVsdOR25CBoYWtlbWlzdG8sIG1pbm5lIHNpdnV0IGphIGxpaXR0ZWV0IHRhbGxlbm5ldGFhbi4KaW5zdGFsbC5pbnN0YWxsZXIudmFsaWRhdGUud29ya2RpciA9IFNpbnVuIG9uIG3k5HJpdGVsdOR25CB0efZoYWtlbWlzdG8uCmluc3RhbGwuanNwLmFkdi5zZXR0aW5ncy5sb2dmaWxlLmRlc2MgPSBNaWhpbiBoYWtlbWlzdG9vbiBsb2dpdGllZG9zdG90IHR1bGlzaSBzaWpvaXR0YWE/Cmluc3RhbGwuanNwLmFkdi5zZXR0aW5ncy5sb2dmaWxlLmxhYmVsID0gTG9raXRpZWRvc3RvdAppbnN0YWxsLmpzcC5hZHYuc2V0dGluZ3MudGl0bGUgPSBFZGlzdHluZWVtbeR0IGFzZXR1a3NldAppbnN0YWxsLmpzcC5hZHYuc2V0dGluZ3Mud29ya2Rpci5kZXNjID0gVORt5CBvbiBoYWtlbWlzdG8sIGpvbm5lIHbkbGltdWlzdGl0IGphIG11dXQgduRsaWFpa2Fpc2V0IHRpZWRvc3RvdCBzaWpvaXRldGFhbi4KaW5zdGFsbC5qc3AuYWR2LnNldHRpbmdzLndvcmtkaXIubGFiZWwgPSBUefZoYWtlbWlzdG8KaW5zdGFsbC5qc3AuYmFzaWNzLmFwcG5hbWUuZGVzYyA9IE1pa+Qgd2lraXNpIG5pbWVrc2kgdHVsZWU/ICBOaW1lbiBrYW5uYXR0YWEgb2xsYSBtZWxrbyBseWh5dC4KaW5zdGFsbC5qc3AuYmFzaWNzLmFwcG5hbWUubGFiZWwgPSBTb3ZlbGx1a3NlbiBuaW1pCmluc3RhbGwuanNwLmJhc2ljcy5iYXNldXJsLmRlc2MgPSBPbGUgaHl25CwgamEga2Vycm8sIG1pa+QgVVJMIHdpa2lsbGUgdHVsZWUuCmluc3RhbGwuanNwLmJhc2ljcy5iYXNldXJsLmxhYmVsID0gUGVydXMtVVJMCmluc3RhbGwuanNwLmJhc2ljcy5wYWdlLnN0b3JhZ2UuZGVzYyA9IEpTUFdpa2kgdGFsbGVudGFhIHdpa2lzaXZ1dCBqYSBsaWl0ZXRpZWRvc3RvdCBvbGV0dWtzZW5hIHTkaORuIGhha2VtaXN0b29uLiAgSm9zIGhha2VtaXN0b2EgZWkgb2xlIG9sZW1hc3NhLCBzZSBsdW9kYWFuLgppbnN0YWxsLmpzcC5iYXNpY3MucGFnZS5zdG9yYWdlLmxhYmVsID0gVGFsbGVubnVzaGFrZW1pc3RvCmluc3RhbGwuanNwLmJhc2ljcy50aXRsZSA9IFBlcnVzYXNpYXQKaW5zdGFsbC5qc3AuaW5zdGFsbC5lcnJvciA9IEVuIHZvaW51dCB0YWxsZW50YWEgYXNldHVrc2lhOiAKaW5zdGFsbC5qc3AuaW5zdGFsbC5pbmZvID0gSHl2aeQgdXV0aXNpYSAKaW5zdGFsbC5qc3AuaW5zdGFsbC5tc2cuYWRtaW4ubm90ZXhpc3RzID0gT25rbyB05G3kIGVuc2ltbeRpbmVuIGtlcnRhIGt1biBhamF0IGFzZW5udXNvaGplbG1hYT8gIEpvcyBreWxs5Cwgc2ludW4gb24gc3l5dOQgdGlldOTkLCBldHTkIGt1bmhhbiBKU1BXaWtpIG9uIHRhcmtpc3RhbnV0IGphIHRhbGxlbnRhbnV0IGFzZXR1a3Nlc2ksIHRhcnZpdHNldCB5bGzkcGl05GrkbiBvaWtldWRldCBw5ORzdORrc2VzaSB05GjkbiBhc2VubnVzb2hqZWxtYWFuIGvkc2lrc2kgdXVkZWxsZWVuLiAgVORsbOQgZXN0ZXTk5G4gc2UsIGV0dOQgc2F0dW5uYWlzZXQgaWhtaXNldCBlaXbkdCByaWtvIHdpa2nkc2kuICAgCmluc3RhbGwuanNwLmluc3RhbGwubXNnLnJuZC5wd2QgPSBLb3NrYSB5bGzkcGl05GrkbiB0dW5udXN0YSBlaSBvbGx1dCB2aWVs5CBvbGVtYXNzYSwgIEpTUFdpa2kgbG9pIHNpbnVsbGUgc2VsbGFpc2VuLiAgVm9pdCB2YWlodGFhIHTkbeRuIHNhbGFzYW5hbiBtefZoZW1taW4sIHRpZXRlbmtpbi4gIFlsbORwaXTkauRuIHR1bm51cyBvbiB7MH0gamEgc2FsYXNhbmEgb24gezF9LiAgT2xlIGh5duQsIGphIGtpcmpvaXRhIG7kbeQgeWz2cywgamEgcGlk5CB2YXJtYXNzYSBwYWlrYXNzYS4gIEpTUFdpa2kgbG9pIG159nMgd2lraXJ5aG3kbiwgam9ua2EgbmltaSBvbiB7Mn0sIGpvc3NhIHTkbeQga+R5dHTkauQgb24uCmluc3RhbGwuanNwLmluc3RhbGwud2FybmluZyA9IFZhcm9pdHVzOiAKaW5zdGFsbC5qc3AuaW5zdHIuZGVzYyA9IEt1biBrbGlra2FhdCA8ZW0+THVvIGFzZXR1a3NldCE8L2VtPiwgYXNlbm51c29oamVsbWEga2lyam9pdHRhYSBhc2V0dWtzZXNpIHRpZWRvc3Rvb24gPGNvZGU+ezB9PC9jb2RlPi4gIFNlIGx1byBtefZzIHlsbORwaXTkauRuIHR1bm51a3NlbiBqYSBzaWxsZSBzYWxhc2FuYW4sIHNla+QgbXn2cyB5bGzkcGl05GppZW4gb21hbiByeWht5G4uIAppbnN0YWxsLmpzcC5pbnN0ci5zdWJtaXQgPSBMdW8gYXNldHVrc2V0IQppbnN0YWxsLmpzcC5pbnRyby5wMSA9IFRlcnZldHVsb2EhICBU5G3kIHNpdnUgYXV0dGFhIHNpbnVhIEpTUFdpa2luIGFzZW5udWtzZW4gaGFua2FsaWVuIHZhaWhlaWRlbiBvaGl0dGFtaXNlc3NhLiAgSm9zIG7kZXQgdORt5G4gc2l2dW4sIG9sZXQgam8gb25uaXN0dW5lZXN0aSB0ZWhueXQgZW5zaW1t5GlzZXQgYXNldHVrc2V0IG9pa2VpbiBzYWFkYWtzZXNpIEpTUFdpa2luIHRvaW1pbWFhbiBzZXJ2bGV0LXltcORyaXN09nNz5HNpLgppbnN0YWxsLmpzcC5pbnRyby5wMiA9IFNldXJhYXZha3NpIHNpbnVuIG9uIHRlaHTkduQgam9pdGFpbiBhc2V0dWtzaWEuICBLdW4gcGFpbmF0IEx1byBhc2V0dWtzZXQsIGFzZW5udXNwYWtldGlzc2Egb2xsdXQgPGNvZGU+anNwd2lraS5wcm9wZXJ0aWVzPC9jb2RlPiBtdXV0ZXRhYW4gdGVrZW1pZXNpIGFzZXR1c3RlbiBtdWthaXNlc3RpLCB0YWkgam9zIHNpdOQgZWkgbPZ5ZHksIGx1b2RhYW4gdXVzaS4KaW5zdGFsbC5qc3AuaW50cm8ucDMgPSBU5G3kIGFzZW5udXNvaGplbG1hIG9uIHRhcmtvaXRldHR1IGzkaGlubuQgbmlpbGxlLCBqb3RrYSB2YWluIGhhbHVhdmF0IHDk5HN05CBub3BlYXN0aSBsaWlra2VlbGxlLiAgSm9zIGhhbHVhdCBhc2VudGFhIEpTUFdpa2luIG9zYWtzaSBvbGVtYXNzYW9sZXZhYSBq5HJqZXN0ZWxt5ORzaSwgc2ludW4ga2FubmF0dGFhIG11b2thdGEgPGNvZGU+anNwd2lraS5wcm9wZXJ0aWVzPC9jb2RlPiAtdGllZG9zdG9hIHN1b3JhYW4uICBM9nlk5HQgZXNpbWVya2tpdGllZG9zdG9uIGhha2VtaXN0b3N0YSA8Y29kZT53aWtpaGFrZW1pc3RvL1dFQi1JTkYvPC9jb2RlPi4KaW5zdGFsbC5qc3AuaW50cm8udGl0bGUgPSBKU1BXaWtpbiBhc2VubnVzb2hqZWxtYQppbnN0YWxsLmpzcC5zZWN1cml0eS5hZG1hY2NvdW50LmVuYWJsZWQgPSBPbGVtYXNzYQppbnN0YWxsLmpzcC5zZWN1cml0eS5hZG1hY2NvdW50LmVuYWJsZWQuZGVzYyA9IFTkbGxlIHdpa2lsbGUgb24gbHVvdHUgeWxs5HBpdORq5G4gdHVubnVzIG5pbWVsdOQgPHN0cm9uZz5hZG1pbjwvc3Ryb25nPiwgam9rYSBrdXVsdXUgcnlobeTkbiA8c3Ryb25nPkFkbWluPC9zdHJvbmc+LiAgSlNQV2lraW4gb2xldHVzdHVydmFtYWxsaSBhbnRhYSB05G3kbiByeWht5G4gauRzZW5pbGxlIGthaWtraXZvaXZhbiA8Y29kZT5BbGxQZXJtaXNzaW9uPC9jb2RlPiAtbHV2YW4ganNwd2lraS5wb2xpY3ktdGllZG9zdG9zc2EuLgppbnN0YWxsLmpzcC5zZWN1cml0eS5hZG1hY2NvdW50LmxhYmVsID0gWWxs5HBpdORq5G4gdHVubnVzCmluc3RhbGwuanNwLnNlY3VyaXR5LmFkbWFjY291bnQubm90ZW5hYmxlZCA9IEVpIG9sZW1hc3NhCmluc3RhbGwuanNwLnNlY3VyaXR5LmFkbWFjY291bnQubm90ZW5hYmxlZC5kZXNjID0gVORsbGUgd2lraWxsZSBlaSBpbG1laXNlc3RpIG9sZSBsdW90dSB5bGzkcGl05GrkbiB0dW5udXN0YS4gS3VuIHBhaW5hdCA8ZW0+VGVlIGFzZXR1a3NldCE8L2VtPiwgc2ludWxsZSBsdW9kYWFuIHNlbGxhaW5lbi4KaW5zdGFsbC5qc3Auc2VjdXJpdHkuc2VjLmNvbmYuZGVzYyA9IEpTUFdpa2kga+R5dHTk5CBvbGV0dWtzZW5hIEpBQVMtauRyamVzdGVsbeTkIGhhbGxpdGFrc2VlbiBw5ORzeeQgZXJpIHJlc3Vyc3NlaWhpbi4gIEpvcyBvbGV0IGx1b251dCBqb2l0YWluIG11aXRhIHR1cnZhcmFqb2l0dGVpdGEgc2VydmxldC1hbHVzdGFhc2kgamEgPGNvZGU+d2ViLnhtbDwvY29kZT4gLXRpZWRvc3Rvb3NpLCBuaWluIEpTUFdpa2kgdG9raSBvc2FhIG159nMga+R5dHTk5CBuaWl05C4gIEpvcyBwb2lzdGF0IEpBQVNpbiBr5Hl09nN05CwgSlNQV2lraSBlaSBlaGvkIHbkbHR05G3kdHTkIHRvaW1pIG5paW5rdWluIG9sZXR0YWlzaXQsIG11dHRhIGpvc2t1cyBzZSBzYWF0dGFhIG9sbGEgaHn2ZHlsbGlzdOQgdmlyaGVlbmV0c2ludORtaWVsZXNz5C4KaW5zdGFsbC5qc3Auc2VjdXJpdHkuc2VjLmNvbmYubGFiZWwgPSBUdXJ2YWxsaXN1dXNhc2V0dWtzZXQKaW5zdGFsbC5qc3Auc2VjdXJpdHkuc2VjLmNvbmYub3B0MSA9IEpBQVMgamEgc2VydmxldC1hbHVzdGFuIHR1cnZhauRyamVzdGVsbeQgKG9sZXR1cykKaW5zdGFsbC5qc3Auc2VjdXJpdHkuc2VjLmNvbmYub3B0MiA9IFNlcnZsZXQtYWx1c3RhbiB0dXJ2YWrkcmplc3RlbG3kCmluc3RhbGwuanNwLnNlY3VyaXR5LnRpdGxlID0gVHVydmFq5HJqZXN0ZWxt5AppbnN0YWxsLmpzcC50aXRsZSA9IEpTUFdpa2luIGFzZW5udXNvaGplbG1hCmluc3RhbGwuanNwLnZhbGlkYXRlZC5uZXcucHJvcHMgPSBU5HNz5CB1dXNpIGpzcHdpa2kucHJvcGVydGllcyAtdGllZG9zdG9zaS4KCiMgQ2FwdGNoYS5qc3AKCmNhcHRjaGEuYXNpcnJhLmFkb3B0Lm1lID0gQWRvcHRvaSBtaW51dApjYXB0Y2hhLmFzaXJyYS5wbGVhc2Uuc2VsZWN0ID0gT2xlIGh5duQgamEgdmFsaXRzZSBrYWlra2kga2lzc2FuIGt1dmF0OgpjYXB0Y2hhLmRlc2NyaXB0aW9uID0gRXDkaWxlbW1lIHNpbnVhIHJvYm90aWtzaSB0YWkgcm9za2Fwb3N0aXR0YWpha3NpLiAgVm9pc2l0a28geXN05HbkbGxpc2VzdGkgcG9pbWlhIGtpc3NhbiBrdXZhdCBzZXVyYWF2aXN0YSBrdXZpc3RhLCBqb3R0YSB0aWVk5G1tZSwgZXR05CBvbGV0IGh5duQgaWhtaW5lbj8KY2FwdGNoYS5qcy5odW1hbmNoZWNrY29tcGxldGUuYWxlcnQgPSBPbGUgaHl25CBqYSB2YWxpdHNlIHZhaW4ga2lzc29qZW4ga3V2YXQuCmNhcHRjaGEuc3VibWl0ID0gVmFsbWlzCmNhcHRjaGEuYXNpcnJhLmEuZ2V0LmNoYWxsZW5nZSA9IEhhZSB1dWRldCBrdXZhdApjYXB0Y2hhLmFzaXJyYS5hLndoYXRzdGhpcyA9IEjkaD8KCg==