PHN0eWxlPjpyb290ey0tYXo6IzFkMzE1NTstLWF6bTojMmU0ZjhhOy0tYXpjOiM0YTdjYzc7LS1kb3I6I2JmOTAwMDstLWRvcmM6I2UwYWEwMDstLWJnOiNmMGYyZjY7LS1iZ3c6I2ZmZjstLWJyZDojYzhkMGUwOy0tdHh0OiMxYTFhMmU7LS10eHRtOiM0YTRhNmE7LS1vazojZDRlZGRhOy0tb2tiOiMxYTdhM2E7LS13YXJuOiNmZmYzY2Q7LS13YXJuYjojODU2NDA0Oy0tZXJyOiNmOGQ3ZGE7LS1lcnJiOiM4NDIwMjk7fSp7Ym94LXNpemluZzpib3JkZXItYm94O21hcmdpbjowO3BhZGRpbmc6MDt9Ym9keXtmb250LWZhbWlseTonSUJNIFBsZXggU2Fucycsc2Fucy1zZXJpZjtiYWNrZ3JvdW5kOnZhcigtLWJnKTtjb2xvcjp2YXIoLS10eHQpO30ud3JhcHttYXgt

d2lkdGg6MTAwMHB4O21hcmdpbjowIGF1dG87cGFkZGluZzoyMHB4IDE2cHg7fS5zZWN7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO2JvcmRlcjoxLjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6OHB4O3BhZGRpbmc6MjBweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zZWMgaDN7Zm9udC1zaXplOjExcHg7Zm9udC13ZWlnaHQ6NzAwO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouN3B4O2NvbG9yOnZhcigtLWF6KTttYXJnaW4tYm90dG9tOjE0cHg7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4O30uc2VjIGgzOjphZnRlcntjb250ZW50OicnO2ZsZXg6MTtoZWlnaHQ6MXB4O2JhY2tncm91bmQ6dmFyKC0t

YnJkKTt9Lmcye2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjtnYXA6MTBweDt9Lmcze2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmciAxZnI7Z2FwOjEwcHg7fS5nNHtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOjFmciAxZnIgMWZyIDFmcjtnYXA6MTBweDt9LmZsZHtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDozcHg7fS5mbGQgbGFiZWx7Zm9udC1zaXplOjEwcHg7Zm9udC13ZWlnaHQ6NjAwO2NvbG9yOnZhcigtLXR4dG0pO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouNXB4O30uZmxkIGlucHV0LC5mbGQgc2VsZWN0e2JvcmRlcjox

LjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6NHB4O3BhZGRpbmc6N3B4IDlweDtmb250LXNpemU6MTJweDtmb250LWZhbWlseTppbmhlcml0O2NvbG9yOnZhcigtLXR4dCk7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO30uZmxkIC51bntmb250LXNpemU6OXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi10b3A6MXB4O30ubm90YXtiYWNrZ3JvdW5kOiNlOGYwZmU7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkIHZhcigtLWF6Yyk7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5ub3RhLXd7YmFja2dyb3VuZDojZmZmM2NkO2JvcmRlci1s

ZWZ0OjNweCBzb2xpZCB2YXIoLS1kb3JjKTtwYWRkaW5nOjdweCAxMXB4O2ZvbnQtc2l6ZToxMHB4O2JvcmRlci1yYWRpdXM6MCA0cHggNHB4IDA7bWFyZ2luLWJvdHRvbToxMHB4O2xpbmUtaGVpZ2h0OjEuNjt9Lm5vdGEtcntiYWNrZ3JvdW5kOiNmOGQ3ZGE7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkICNkYzM1NDU7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5idG4tY2FsY3tiYWNrZ3JvdW5kOnZhcigtLWF6KTtjb2xvcjojZmZmO2JvcmRlcjpub25lO2JvcmRlci1yYWRpdXM6NnB4O3BhZGRpbmc6MTNweCAyOHB4O2ZvbnQtc2l6ZToxM3B4

O2ZvbnQtd2VpZ2h0OjcwMDtjdXJzb3I6cG9pbnRlcjt3aWR0aDoxMDAlO21hcmdpbi10b3A6NnB4O30uYnRuLXBkZntiYWNrZ3JvdW5kOnZhcigtLWRvcmMpO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzo5cHggMjJweDtmb250LXNpemU6MTJweDtmb250LXdlaWdodDo3MDA7Y3Vyc29yOnBvaW50ZXI7bWFyZ2luLXRvcDoxMHB4O30jcmVzdWx0YWRve2Rpc3BsYXk6bm9uZTttYXJnaW4tdG9wOjE2cHg7fS5zZW17ZGlzcGxheTpncmlkO2dyaWQtdGVtcGxhdGUtY29sdW1uczpyZXBlYXQoOCwxZnIpO2dhcDo2cHg7bWFyZ2luLWJvdHRvbToxNHB4O30uc2VtMntkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5z

OnJlcGVhdCg0LDFmcik7Z2FwOjZweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zaXRlbXtib3JkZXItcmFkaXVzOjdweDtwYWRkaW5nOjlweCA1cHg7dGV4dC1hbGlnbjpjZW50ZXI7fS5zbGJse2ZvbnQtc2l6ZTo3LjVweDtmb250LXdlaWdodDo3MDA7dGV4dC10cmFuc2Zvcm06dXBwZXJjYXNlO2xldHRlci1zcGFjaW5nOi4zcHg7bWFyZ2luLWJvdHRvbTo0cHg7bGluZS1oZWlnaHQ6MS4zO30uc3ZhbHtmb250LXNpemU6MTRweDtmb250LXdlaWdodDo3MDA7Zm9udC1mYW1pbHk6J0lCTSBQbGV4IE1vbm8nLG1vbm9zcGFjZTt9LnNyZXF7Zm9udC1zaXplOjdweDttYXJnaW4tdG9wOjJweDtvcGFjaXR5Oi44O30ub2stc3tiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xv

cjp2YXIoLS1va2IpO30ud2Fybi1ze2JhY2tncm91bmQ6dmFyKC0td2Fybik7Y29sb3I6dmFyKC0td2FybmIpO30uZXJyLXN7YmFja2dyb3VuZDp2YXIoLS1lcnIpO2NvbG9yOnZhcigtLWVycmIpO30ubWVte2JhY2tncm91bmQ6I2Y4ZjlmYztib3JkZXI6MXB4IHNvbGlkIHZhcigtLWJyZCk7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxOHB4O2ZvbnQtc2l6ZToxMXB4O2xpbmUtaGVpZ2h0OjEuOTtmb250LWZhbWlseTonSUJNIFBsZXggTW9ubycsbW9ub3NwYWNlO3doaXRlLXNwYWNlOnByZS13cmFwO2NvbG9yOnZhcigtLXR4dCk7bWFyZ2luLXRvcDoxMnB4O30ubWVtIGg0e2ZvbnQtZmFtaWx5OidJQk0gUGxleCBTYW5zJyxzYW5zLXNlcmlmO2ZvbnQtc2l6

ZToxMXB4O2ZvbnQtd2VpZ2h0OjcwMDtjb2xvcjp2YXIoLS1heik7bWFyZ2luOjE0cHggMCA0cHg7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgdmFyKC0tYnJkKTtwYWRkaW5nLWJvdHRvbToycHg7fS5hbGVydGF7YmFja2dyb3VuZDojZjhkN2RhO2JvcmRlcjoxcHggc29saWQgI2Y1YzZjYjtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4O2NvbG9yOiM4NDIwMjk7bWFyZ2luOjRweCAwO30uc3Vie2ZvbnQtc2l6ZToxMXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi1ib3R0b206MTRweDt9QG1lZGlhKG1heC13aWR0aDo3MDBweCl7LmczLC5nNHtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjt9LnNlbXtncmlkLXRl

bXBsYXRlLWNvbHVtbnM6cmVwZWF0KDQsMWZyKTt9LnNlbTJ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOnJlcGVhdCgyLDFmcik7fX1AbWVkaWEgcHJpbnR7LmJ0bi1jYWxjLC5idG4tcGRmLC5zZWM6bm90KCNzZWMtcmVzKXtkaXNwbGF5Om5vbmUhaW1wb3J0YW50O30jcmVzdWx0YWRve2Rpc3BsYXk6YmxvY2shaW1wb3J0YW50O31ib2R5e2JhY2tncm91bmQ6I2ZmZjt9Lm1lbXtib3JkZXI6bm9uZTtwYWRkaW5nOjA7Zm9udC1zaXplOjEwcHg7fX08L3N0eWxlPgoKPGRpdiBjbGFzcz0id3JhcCI+CjxoMj5NdXJvIGRlIEFycmltbyAmIzgyMTI7IENvbmNyZXRvIEFybWFkbzwvaDI+CjxwIGNsYXNzPSJzdWIiPk5CUiA2MTE4OjIwMjMgJiMxODM7IE5CUiA2MTIwOjIw

MTkgJiMxODM7IE5CUiAxMTY4MjoyMDA5ICYjMTgzOyBOQlIgNjEyMjoyMDIyIHwgVmVyaWZpY2HDp8O1ZXMgY29tcGxldGFzPC9wPgo8ZGl2IGNsYXNzPSJub3RhIj4mIzk4ODg7JiM2NTAzOTsgPHN0cm9uZz5FeGNsdXNpdm8gcGFyYSBlbmdlbmhlaXJvcyBoYWJpbGl0YWRvcy48L3N0cm9uZz4gUmVzdWx0YWRvcyBkZXZlbSBzZXIgdmFsaWRhZG9zIGUgYXNzaW5hZG9zIChBUlQvUlJUKS4gTsOjbyBzdWJzdGl0dWkgbGF1ZG8gZ2VvdMOpY25pY28uPC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzEyODE5MzsgSWRlbnRpZmljYcOnw6NvPC9oMz48ZGl2IGNsYXNzPSJnMyI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+T2JyYSAvIFByb2pldG88L2xh

YmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0ib2JyYSIgcGxhY2Vob2xkZXI9Ik5vbWUgLyBsb2NhbGl6YcOnw6NvIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5SZXNwb25zw6F2ZWwgVMOpY25pY288L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0icmVzcCIgcGxhY2Vob2xkZXI9IkVuZy4gTm9tZSDigJQgQ1JFQS9DQVUgbsKwIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5OwrAgUmVnaXN0cm8gKENSRUEvQ0FVKTwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJjcmVhIiBwbGFjZWhvbGRlcj0iQ1JFQS1YWCAwMDAwMDAiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkRhdGE8L2xhYmVsPjxpbnB1dCB0

eXBlPSJkYXRlIiBpZD0iZGF0YV9jYWxjIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5SZXZpc8OjbzwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJyZXYiIHZhbHVlPSJSMDAiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkxhdWRvIEdlb3TDqWNuaWNvIE7CsDwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJsYXVkbyIgcGxhY2Vob2xkZXI9IkV4OiBTRy0yMDI0LTA0NSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+QVJUIC8gUlJUIE7CsDwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJhcnQiIHBsYWNlaG9sZGVyPSJOwrAgQVJUIG91IFJSVCI+PC9kaXY+CjwvZGl2PjwvZGl2PgoKPGRpdiBj

bGFzcz0ic2VjIj48aDM+JiMxMjgyMDg7IEdlb21ldHJpYTwvaDM+CjxkaXYgY2xhc3M9Im5vdGEtdyI+JiMxMjgyMDM7IFByb3BvcsOnw6NvIHJlY29tZW5kYWRhOiBCID0gMCw1MEggYSAwLDcwSDwvZGl2Pgo8ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+QWx0dXJhIHRvdGFsIEggKG0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iSCIgdmFsdWU9IjMuMCIgc3RlcD0iMC4wNSIgbWluPSIwLjUiPjxzcGFuIGNsYXNzPSJ1biI+aW5jbHVpbmRvIGVtYnV0aW1lbnRvPC9zcGFuPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkVtYnV0aW1lbnRvIEhlbSAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIi

IGlkPSJIZW0iIHZhbHVlPSIwLjUiIHN0ZXA9IjAuMDUiIG1pbj0iMC4zIj48c3BhbiBjbGFzcz0idW4iPm3DrW46IG1heChILzEwOyAwLDUwbSk8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RXNwLiBmdXN0ZSB0b3BvIHR0IChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InRfdG9wbyIgdmFsdWU9IjAuMjAiIHN0ZXA9IjAuMDEiIG1pbj0iMC4xMCI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RXNwLiBmdXN0ZSBiYXNlIHRiIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InRfYmFzZSIgdmFsdWU9IjAuMzAiIHN0ZXA9IjAuMDEiIG1pbj0iMC4xNSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0i

ZmxkIj48bGFiZWw+TGFyZ3VyYSBzYXBhdGEgQiAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJCIiB2YWx1ZT0iMi4xMCIgc3RlcD0iMC4wNSIgbWluPSIwLjUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlDDqSBkaWFudGVpcm8gQjEgKG0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iQjEiIHZhbHVlPSIwLjQwIiBzdGVwPSIwLjA1IiBtaW49IjAuMDUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkVzcC4gc2FwYXRhIGhzIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImhzIiB2YWx1ZT0iMC4zNSIgc3RlcD0iMC4wNSIgbWluPSIwLjIwIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJm

bGQiPjxsYWJlbD5JbmNsaW5hw6fDo28gYXRlcnJvICYjOTQ2OyAowrApPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iYmV0YSIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCIgbWF4PSIzMCI+PC9kaXY+CjwvZGl2PjwvZGl2PgoKPGRpdiBjbGFzcz0ic2VjIj48aDM+JiMxMTAxNTsmIzY1MDM5OyBDYXJyZWdhbWVudG9zPC9oMz48ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+VGlwbyBzb2JyZWNhcmdhPC9sYWJlbD48c2VsZWN0IGlkPSJ0aXBvX3NjIj4KICAgIDxvcHRpb24gdmFsdWU9InVuaWZvcm1lIj5EaXN0cmlidcOtZGEgdW5pZm9ybWU8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9ImNvbmNlbnRyYWRhIj5D

b25jZW50cmFkYSAoQm91c3NpbmVzcSk8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9Im5lbmh1bWEiPlNlbSBzb2JyZWNhcmdhPC9vcHRpb24+CiAgPC9zZWxlY3Q+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+cSAoa04vbcKyKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InEiIHZhbHVlPSIxMCIgc3RlcD0iMSIgbWluPSIwIj48c3BhbiBjbGFzcz0idW4iPk5CUiA2MTIwPC9zcGFuPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkNhcmdhIGNvbmMuIFAgKGtOL20pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iUF9jb25jIiB2YWx1ZT0iMCIgc3RlcD0iMSIgbWluPSIwIj48c3BhbiBjbGFzcz0idW4iPnBh

cmEgQm91c3NpbmVzcTwvc3Bhbj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5EaXN0w6JuY2lhIGFvIG11cm8gZCAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJkaXN0X3NjIiB2YWx1ZT0iMCIgc3RlcD0iMC4xIiBtaW49IjAiPjxzcGFuIGNsYXNzPSJ1biI+cGFyYSBCb3Vzc2luZXNxPC9zcGFuPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KCjxkaXYgY2xhc3M9InNlYyI+PGgzPiYjMTI3NzU3OyBQYXLDom1ldHJvcyBHZW90w6ljbmljb3M8L2gzPgo8ZGl2IGNsYXNzPSJub3RhLXciPiYjMTI4MjAzOyBQYXLDom1ldHJvcyBvYnJpZ2F0b3JpYW1lbnRlIG9idGlkb3MgZGUgbGF1ZG8gZ2VvdMOpY25pY28gKFNQVC90cmlheGlhbCkuIExh

dWRvIE7CsCBkZXZlIHNlciBpbmZvcm1hZG8gYWNpbWEuPC9kaXY+CjxkaXYgY2xhc3M9Imc0Ij4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5TVUNTPC9sYWJlbD48c2VsZWN0IGlkPSJzdWNzIj48b3B0aW9uIHZhbHVlPSJTVyI+U1cg4oCUIEFyZWlhIGJlbSBncmFkLjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNQIj5TUCDigJQgQXJlaWEgbWFsIGdyYWQuPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iU00iIHNlbGVjdGVkPlNNIOKAlCBBcmVpYSBzaWx0b3NhPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iU0MiPlNDIOKAlCBBcmVpYSBhcmdpbG9zYTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9Ik1MIj5NTCDigJQgU2lsdGU8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJD

TCI+Q0wg4oCUIEFyZ2lsYSBiYWl4YSBwbC48L29wdGlvbj48b3B0aW9uIHZhbHVlPSJDSCI+Q0gg4oCUIEFyZ2lsYSBhbHRhIHBsLjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IkdXIj5HVyDigJQgUGVkcmVndWxobzwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk4tU1BUIHJlZmVyw6puY2lhPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ibnNwdCIgdmFsdWU9IjE1IiBzdGVwPSIxIiBtaW49IjEiPjxzcGFuIGNsYXNzPSJ1biI+dmFsb3IgbcOpZGlvIHpvbmEgYXRpdmE8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+JiM5NDc7cyAoa04vbcKzKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51

bWJlciIgaWQ9ImdhbWFfcyIgdmFsdWU9IjE4IiBzdGVwPSIwLjUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTY2OyAowrApPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icGhpIiB2YWx1ZT0iMzAiIHN0ZXA9IjEiIG1pbj0iMTAiIG1heD0iNDUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPmMgKGtOL23Csik8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJjb2VzIiB2YWx1ZT0iMCIgc3RlcD0iMSIgbWluPSIwIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD4mIzk1NjsgYXRyaXRvIGJhc2U8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJtdSIgdmFsdWU9IjAuNTUiIHN0ZXA9

IjAuMDUiIG1pbj0iMC4yIiBtYXg9IjAuOSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+TsOtdmVsIGQnw6FndWEgTncgKG0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iTnciIHZhbHVlPSIwIiBzdGVwPSIwLjEiIG1pbj0iMCI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RHJlbmFnZW08L2xhYmVsPjxzZWxlY3QgaWQ9ImRyZW5hZ2VtIj4KICAgIDxvcHRpb24gdmFsdWU9ImRyZW5vX2dlb3RleHRpbCI+R2VvdMOqeHRpbCAoTnc9MCk8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9ImRyZW5vX2JyaXRhIj5Ccml0YSArIFBWQyAoTnc9MCk8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9ImJhcmJhY2FzIj5CYXJi

YWPDo3MgKDUwJSBOdyk8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9InNlbV9kcmVubyI+U2VtIGRyZW5vIChOdyB0b3RhbCk8L29wdGlvbj4KICA8L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5ydSAocHJlc3PDo28gZGUgcG9yb3MpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icnUiIHZhbHVlPSIwIiBzdGVwPSIwLjA1IiBtaW49IjAiIG1heD0iMC41Ij48c3BhbiBjbGFzcz0idW4iPkJpc2hvcDogMD1zZWNvOyAwLjM9dMOtcC48L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+JiM5NjM7YWRtIChrTi9twrIpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ic2lnYWRtIiB2YWx1ZT0i

MTUwIiBzdGVwPSIxMCI+PHNwYW4gY2xhc3M9InVuIj5zZSBvcmlnZW09ZGlyZXRvPC9zcGFuPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk9yaWdlbSBjYXAuIGNhcmdhPC9sYWJlbD48c2VsZWN0IGlkPSJvcmlnX3EiPgogICAgPG9wdGlvbiB2YWx1ZT0iY2FsY3VsbyI+Q2FsY3VsYXIgKFRlcnphZ2hpKTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iZGlyZXRvIj5JbmZvcm1hciBkaXJldGFtZW50ZTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPmtzIChrTi9twrMpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ia3MiIHZhbHVlPSIyMDAwMCIgc3RlcD0iMTAwMCI+PHNwYW4gY2xh

c3M9InVuIj5jb2VmLiByZWHDp8OjbyBzb2xvPC9zcGFuPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KCjxkaXYgY2xhc3M9InNlYyI+PGgzPiYjMTI3OTU5OyYjNjUwMzk7IE1hdGVyaWFpcyDigJQgTkJSIDYxMTg6MjAyMzwvaDM+CjxkaXYgaWQ9ImF2aXNvX2ZjayIgY2xhc3M9Im5vdGEtciI+PC9kaXY+CjxkaXYgY2xhc3M9Imc0Ij4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DbGFzc2UgYWdyZXNzaXZpZGFkZTwvbGFiZWw+PHNlbGVjdCBpZD0iYWdyZXNzIiBvbmNoYW5nZT0iYXR1YWxpemFyQ29iKCkiPgogICAgPG9wdGlvbiB2YWx1ZT0iSSI+SSDigJQgRnJhY2E8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJJSSIgc2VsZWN0ZWQ+SUkg4oCUIE1vZGVyYWRhPC9v

cHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSJJSUkiPklJSSDigJQgRm9ydGU8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJJViI+SVYg4oCUIE11aXRvIGZvcnRlPC9vcHRpb24+CiAgPC9zZWxlY3Q+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+ZmNrIChNUGEpPC9sYWJlbD48c2VsZWN0IGlkPSJmY2siIG9uY2hhbmdlPSJ2YWxpZGFyRmNrKCkiPgogICAgPG9wdGlvbiB2YWx1ZT0iMjAiPkMyMDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjI1IiBzZWxlY3RlZD5DMjU8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9IjMwIj5DMzA8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIzNSI+QzM1PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iNDAiPkM0MDwvb3B0aW9u

PgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkHDp288L2xhYmVsPjxzZWxlY3QgaWQ9ImFjbyI+CiAgICA8b3B0aW9uIHZhbHVlPSI1MDAiPkNBLTUwICg1MDAgTVBhKTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iNjAwIj5DQS02MCAoNjAwIE1QYSk8L29wdGlvbj4KICA8L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD4mIzk0NztjPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZ2MiIHZhbHVlPSIxLjQiIHN0ZXA9IjAuMDUiPjxzcGFuIGNsYXNzPSJ1biI+TkJSIDYxMTggdGFiLjEyLjE8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+JiM5NDc7czwvbGFiZWw+

PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImdzIiB2YWx1ZT0iMS4xNSIgc3RlcD0iMC4wNSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Q29icmltZW50byBub21pbmFsIChtbSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJjb2IiIHZhbHVlPSI0MCIgc3RlcD0iNSIgbWluPSIyMCI+PHNwYW4gY2xhc3M9InVuIiBpZD0iY29iX3JlZiI+Q0EgSUk6IG3DrW4gNDBtbTwvc3Bhbj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD4mIzk2NjsgYmFycmEgZnVzdGUgKG1tKTwvbGFiZWw+PHNlbGVjdCBpZD0iZGlhbV9mIj4KICAgIDxvcHRpb24gdmFsdWU9IjEwIj4xMDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjEyLjUiPjEyLjU8

L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9IjE2IiBzZWxlY3RlZD4xNjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjIwIj4yMDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjI1Ij4yNTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTY2OyBiYXJyYSBzYXBhdGEgKG1tKTwvbGFiZWw+PHNlbGVjdCBpZD0iZGlhbV9zIj4KICAgIDxvcHRpb24gdmFsdWU9IjEwIj4xMDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjEyLjUiPjEyLjU8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9IjE2IiBzZWxlY3RlZD4xNjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjIwIj4yMDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjI1Ij4yNTwv

b3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTQ3O2NvbmMgKGtOL23Csyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJnYW1hX2MiIHZhbHVlPSIyNSIgc3RlcD0iMC41Ij48L2Rpdj4KPC9kaXY+PC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzk4ODE7JiM2NTAzOTsgQ1MgTcOtbmltb3Mg4oCUIE5CUiAxMTY4MjoyMDA5PC9oMz48ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Q1MgdG9tYmFtZW50byBtw61uLjwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImNzdF9taW4iIHZhbHVlPSIyLjAwIiBzdGVwPSIwLjA1Ij48c3BhbiBjbGFzcz0idW4iPnRh

Yi4xIE5CUiAxMTY4Mjwvc3Bhbj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DUyBkZXNsaXphbWVudG8gbcOtbi48L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJjc2RfbWluIiB2YWx1ZT0iMS41MCIgc3RlcD0iMC4wNSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Q1MgcnVwdC4gY2lyY3VsYXIgbcOtbi48L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJjc3JfbWluIiB2YWx1ZT0iMS41MCIgc3RlcD0iMC4wNSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Wm9uYSBzw61zbWljYTwvbGFiZWw+PHNlbGVjdCBpZD0iYWdfc2lzIj4KICAgIDxvcHRpb24gdmFsdWU9IjAiIHNlbGVjdGVkPk7Do28g

YXBsaWPDoXZlbDwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iMC4wMjUiPlpvbmEgMSAoMCwwMjVnKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjAuMDUiPlpvbmEgMiAoMCwwNWcpPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSIwLjEwIj5ab25hIDMgKDAsMTBnKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjAuMTUiPlpvbmEgNCAoMCwxNWcpPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSIwLjMwIj5ab25hIDUgKDAsMzBnKTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2Pgo8L2Rpdj48L2Rpdj4KCjxidXR0b24gY2xhc3M9ImJ0bi1jYWxjIiBvbmNsaWNrPSJjYWxjTkJSKCkiPiYjOTY1NDsgQ0FMQ1VMQVIgRSBESU1FTlNJT05BUiDigJQgTkJSIDYx

MTg8L2J1dHRvbj4KPGRpdiBpZD0iYWxlcnRhc19kaXYiIHN0eWxlPSJtYXJnaW4tdG9wOjEwcHg7Ij48L2Rpdj4KCjxkaXYgaWQ9InJlc3VsdGFkbyI+CjxkaXYgY2xhc3M9InNlYyIgaWQ9InNlYy1yZXMiPgogIDxoMz4mIzEyODY4MDsgVmVyaWZpY2HDp8O1ZXMgR2VvdMOpY25pY2FzPC9oMz4KICA8ZGl2IGNsYXNzPSJzZW0iIGlkPSJzZW1fZ2VvIj48L2Rpdj4KICA8aDMgc3R5bGU9Im1hcmdpbi10b3A6OHB4OyI+JiMxMjc5NTk7JiM2NTAzOTsgVmVyaWZpY2HDp8O1ZXMgRXN0cnV0dXJhaXM8L2gzPgogIDxkaXYgY2xhc3M9InNlbSIgaWQ9InNlbV9lc3QiPjwvZGl2PgogIDxoMyBzdHlsZT0ibWFyZ2luLXRvcDo4cHg7Ij5BbGVydGFzIC8gQWxlcnRzPC9o

Mz48ZGl2IGlkPSJhbGVydGFzX3JlcyI+PC9kaXY+CiAgPGgzIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPiYjMTI4MjAzOyBNZW1vcmlhbCBkZSBDw6FsY3VsbyDigJQgTkJSIDYxMTgvNjEyMC8xMTY4MjwvaDM+CiAgPGJ1dHRvbiBjbGFzcz0iYnRuLXBkZiIgb25jbGljaz0id2luZG93LnByaW50KCkiPiYjMTI4NDI0OyYjNjUwMzk7IEV4cG9ydGFyIFBERjwvYnV0dG9uPgogIDxkaXYgY2xhc3M9Im1lbSIgaWQ9Im1lbW9yaWFsIj48L2Rpdj4KPC9kaXY+PC9kaXY+CjwvZGl2PgoKPHNjcmlwdD4KdmFyIENPQl9NSU49e0k6e0MyMDoyNSxDMjU6MjUsQzMwOjIwLEMzNToyMCxDNDA6MjB9LElJOntDMjA6MzUsQzI1OjMwLEMzMDoyNSxDMzU6MjUsQzQwOjI1fSxJ

SUk6e0MyMDpudWxsLEMyNTo0NSxDMzA6NDAsQzM1OjM1LEM0MDozNX0sSVY6e0MyMDpudWxsLEMyNTpudWxsLEMzMDo1MCxDMzU6NDUsQzQwOjQ1fX07CnZhciBGQ0tfTUlOPXtJOjIwLElJOjI1LElJSTozMCxJVjozNX07CgpmdW5jdGlvbiBhdHVhbGl6YXJDb2IoKXsKICB2YXIgYWdyPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhZ3Jlc3MnKS52YWx1ZTsKICB2YXIgZmNrPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdmY2snKS52YWx1ZTsKICB2YXIgY2xzPSdDJytmY2s7CiAgdmFyIG1uPUNPQl9NSU5bYWdyXT9DT0JfTUlOW2Fncl1bY2xzXTpudWxsOwogIHZhciByZWY9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvYl9yZWYnKTsKICBpZihtbil7CiAg

ICByZWYudGV4dENvbnRlbnQ9J0NBICcrYWdyKyc6IG1pbiAnK21uKydtbSAoTkJSIDYxMTggdGFiLjcuMiknOwogICAgdmFyIGNvYkVsPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb2InKTsKICAgIGlmKCtjb2JFbC52YWx1ZTxtbikgY29iRWwudmFsdWU9bW47CiAgfSBlbHNlIHsKICAgIHJlZi50ZXh0Q29udGVudD0nSU5DT01QQVRJVkVMIGNvbSBDQSAnK2FncisnIFx1MjAxNCBhdW1lbnRlIGZjayc7CiAgfQp9CgpmdW5jdGlvbiB2YWxpZGFyRmNrKCl7CiAgdmFyIGFncj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWdyZXNzJykudmFsdWU7CiAgdmFyIGZjaz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2ZjaycpLnZhbHVlOwogIHZhciBtbj1GQ0tf

TUlOW2Fncl18fDIwOwogIHZhciBkaXY9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2F2aXNvX2ZjaycpOwogIGlmKGZjazxtbil7CiAgICBkaXYuc3R5bGUuZGlzcGxheT0nYmxvY2snOwogICAgZGl2LnRleHRDb250ZW50PSdFUlJPOiBmY2s9JytmY2srJ01QYSBpbnN1ZmljaWVudGUgcGFyYSBDQSAnK2FncisnLiBNaW5pbW86IEMnK21uKycgKE5CUiA2MTE4IHRhYi42LjEpJzsKICB9IGVsc2UgewogICAgZGl2LnN0eWxlLmRpc3BsYXk9J25vbmUnOwogIH0KICBhdHVhbGl6YXJDb2IoKTsKfQoKZnVuY3Rpb24gdG9SYWQoZCl7cmV0dXJuIGQqTWF0aC5QSS8xODA7fQpmdW5jdGlvbiB0b0RlZyhyKXtyZXR1cm4gcioxODAvTWF0aC5QSTt9CmZ1bmN0aW9uIGZt

dCh2LGQpe2Q9KGQ9PT11bmRlZmluZWQpPzM6ZDtyZXR1cm4gTnVtYmVyKHYpLnRvRml4ZWQoZCk7fQoKZnVuY3Rpb24gY2FwYVRlcnphZ2hpKHBoaV9kZWcsYyxnYW1hX3MsRGYsQil7CiAgdmFyIHA9dG9SYWQocGhpX2RlZyk7CiAgdmFyIE5xPU1hdGguZXhwKE1hdGguUEkqTWF0aC50YW4ocCkpKk1hdGgucG93KE1hdGgudGFuKE1hdGguUEkvNCtwLzIpLDIpOwogIHZhciBOYz0oTnEtMSkvTWF0aC50YW4ocCk7CiAgdmFyIE5nPTIqKE5xKzEpKk1hdGgudGFuKHApOwogIHZhciBxMD1nYW1hX3MqRGY7CiAgdmFyIHF1bHQ9YypOYytxMCpOcSswLjUqZ2FtYV9zKkIqTmc7CiAgcmV0dXJuIHtxdWx0OnF1bHQscWFkbTpxdWx0LzMsTnE6TnEsTmM6TmMsTmc6Tmcs

cTA6cTB9Owp9CgpmdW5jdGlvbiBib3Vzc2luZXNxKFAsZCxIKXsKICBpZihkPD0wfHxQPD0wKSByZXR1cm4ge0VoOjAseWE6SC8yfTsKICB2YXIgRWg9KFAvTWF0aC5QSSkqKEgqZCpkLyhkKmQrSCpIKStNYXRoLmF0YW4oSC9kKSk7CiAgcmV0dXJuIHtFaDpFaCx5YTpILzJ9Owp9CgpmdW5jdGlvbiBzdWdlcmlyQmFycmEoQXNfbW0yX20sZGlhbV9wcmVmKXsKICB2YXIgYmFycmFzPVt7ZDo4LGE6NTAuM30se2Q6MTAsYTo3OC41fSx7ZDoxMi41LGE6MTIyLjd9LHtkOjE2LGE6MjAxLjF9LHtkOjIwLGE6MzE0LjJ9LHtkOjI1LGE6NDkwLjl9XTsKICB2YXIgcmVzdWx0YWRvPW51bGw7CiAgZm9yKHZhciBpPTA7aTxiYXJyYXMubGVuZ3RoO2krKyl7CiAgICB2YXIg

Yj1iYXJyYXNbaV07CiAgICBpZihkaWFtX3ByZWYmJmIuZCE9ZGlhbV9wcmVmKSBjb250aW51ZTsKICAgIHZhciBlc3BjPU1hdGguZmxvb3IoYi5hL0FzX21tMl9tKjEwMCkqMTA7CiAgICBpZihlc3BjPj02MCYmZXNwYzw9MjAwKXtyZXN1bHRhZG89e3R4dDoncGhpJytiLmQrJ2MvJytNYXRoLm1pbihlc3BjLDIwMCkrJ21tJyxhcmVhOmIuYSoxMDAwL01hdGgubWluKGVzcGMsMjAwKSxkaWFtOmIuZCxlc3BjOk1hdGgubWluKGVzcGMsMjAwKX07YnJlYWs7fQogIH0KICBpZighcmVzdWx0YWRvKXsKICAgIGZvcih2YXIgaT0wO2k8YmFycmFzLmxlbmd0aDtpKyspewogICAgICB2YXIgYj1iYXJyYXNbaV07CiAgICAgIHZhciBlc3BjPU1hdGguZmxvb3IoYi5hL0Fz

X21tMl9tKjEwMCkqMTA7CiAgICAgIGlmKGVzcGM+PTYwJiZlc3BjPD0yMDApe3Jlc3VsdGFkbz17dHh0OidwaGknK2IuZCsnYy8nK01hdGgubWluKGVzcGMsMjAwKSsnbW0nLGFyZWE6Yi5hKjEwMDAvTWF0aC5taW4oZXNwYywyMDApLGRpYW06Yi5kLGVzcGM6TWF0aC5taW4oZXNwYywyMDApfTticmVhazt9CiAgICB9CiAgfQogIHJldHVybiByZXN1bHRhZG98fHt0eHQ6J3BoaTI1Yy8xMDBtbScsYXJlYTo0OTA5LGRpYW06MjUsZXNwYzoxMDB9Owp9CgpmdW5jdGlvbiBjYWxjTkJSKCl7CiAgdmFyIG9icmE9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ29icmEnKS52YWx1ZXx8JyhuYW8gaW5mb3JtYWRvKSc7CiAgdmFyIHJlc3A9ZG9jdW1lbnQuZ2V0RWxlbWVu

dEJ5SWQoJ3Jlc3AnKS52YWx1ZXx8JyhuYW8gaW5mb3JtYWRvKSc7CiAgdmFyIGNyZWE9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NyZWEnKS52YWx1ZXx8JyhuYW8gaW5mb3JtYWRvKSc7CiAgdmFyIGRhdGFfYz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZGF0YV9jYWxjJykudmFsdWV8fG5ldyBEYXRlKCkudG9JU09TdHJpbmcoKS5zbGljZSgwLDEwKTsKICB2YXIgcmV2PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXYnKS52YWx1ZXx8J1IwMCc7CiAgdmFyIGxhdWRvPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdsYXVkbycpLnZhbHVlfHwnKG5hbyBpbmZvcm1hZG8pJzsKICB2YXIgYXJ0PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhcnQnKS52YWx1

ZXx8JyhuYW8gaW5mb3JtYWRvKSc7CgogIHZhciBIPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnSCcpLnZhbHVlOwogIHZhciBIZW09K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdIZW0nKS52YWx1ZTsKICB2YXIgdF90b3A9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0X3RvcG8nKS52YWx1ZTsKICB2YXIgdF9iYXM9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0X2Jhc2UnKS52YWx1ZTsKICB2YXIgQj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0InKS52YWx1ZTsKICB2YXIgQjE9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdCMScpLnZhbHVlOwogIHZhciBocz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2hzJykudmFsdWU7CiAgdmFyIGJldGE9

K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdiZXRhJykudmFsdWU7CgogIHZhciB0aXBvX3NjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0aXBvX3NjJykudmFsdWU7CiAgdmFyIHFfc29iPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncScpLnZhbHVlOwogIHZhciBQX2NvbmM9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdQX2NvbmMnKS52YWx1ZTsKICB2YXIgZGlzdF9zYz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Rpc3Rfc2MnKS52YWx1ZTsKCiAgdmFyIHN1Y3M9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3N1Y3MnKS52YWx1ZTsKICB2YXIgbnNwdD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ25zcHQnKS52YWx1ZTsKICB2YXIgZ2FtYV9zPStk

b2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ2FtYV9zJykudmFsdWU7CiAgdmFyIHBoaV9kZWc9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdwaGknKS52YWx1ZTsKICB2YXIgY29lcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvZXMnKS52YWx1ZTsKICB2YXIgbXU9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdtdScpLnZhbHVlOwogIHZhciBOdz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ053JykudmFsdWU7CiAgdmFyIGRyZW49ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RyZW5hZ2VtJykudmFsdWU7CiAgdmFyIHJ1PStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncnUnKS52YWx1ZTsKICB2YXIgc2lnYWRtX2lucD0rZG9jdW1lbnQuZ2V0RWxlbWVu

dEJ5SWQoJ3NpZ2FkbScpLnZhbHVlOwogIHZhciBvcmlnX3E9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ29yaWdfcScpLnZhbHVlOwogIHZhciBrcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2tzJykudmFsdWU7CgogIHZhciBhZ3Jlc3M9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2FncmVzcycpLnZhbHVlOwogIHZhciBmY2s9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdmY2snKS52YWx1ZTsKICB2YXIgZnlrPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWNvJykudmFsdWU7CiAgdmFyIGdjPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ2MnKS52YWx1ZTsKICB2YXIgZ3NfYWNvPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ3MnKS52YWx1ZTsK

ICB2YXIgY29iX21tPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29iJykudmFsdWU7CiAgdmFyIGNvYj1jb2JfbW0vMTAwMDsKICB2YXIgZGlhbV9mPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZGlhbV9mJykudmFsdWU7CiAgdmFyIGRpYW1fcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RpYW1fcycpLnZhbHVlOwogIHZhciBnYW1hX2M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdnYW1hX2MnKS52YWx1ZTsKCiAgdmFyIENTVF9NSU49K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjc3RfbWluJykudmFsdWU7CiAgdmFyIENTRF9NSU49K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjc2RfbWluJykudmFsdWU7CiAgdmFyIENTUl9NSU49K2RvY3Vt

ZW50LmdldEVsZW1lbnRCeUlkKCdjc3JfbWluJykudmFsdWU7CiAgdmFyIGFnPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWdfc2lzJykudmFsdWU7CgogIHZhciBhbGVydGFzPVtdOwoKICAvLyBcdTI1MDBcdTI1MDAgVmFsaWRhXHUwMGU3XHUwMGY1ZXMgbm9ybWF0aXZhcyBcdTI1MDBcdTI1MDAKICB2YXIgSGVtX21pbj1NYXRoLm1heCgwLjUwLEgvMTApOwogIGlmKEhlbTxIZW1fbWluKSBhbGVydGFzLnB1c2goJ0VSUk86IEhlbT0nK2ZtdChIZW0sMikrJ20gPCBtaW5pbW89JytmbXQoSGVtX21pbiwyKSsnbSAobWF4KEgvMTA7MCw1MG0pIFx1MjAxNCBOQlIgMTE2ODIpJyk7CiAgdmFyIEJIPUIvSDsKICBpZihCSDwwLjQwKSBhbGVydGFzLnB1c2goJ0FW

SVNPOiBCL0g9JytmbXQoQkgsMikrJyA8IDAsNDAgXHUyMDE0IHByZS1kaW1lbnNpb25hbWVudG8gaW5hZGVxdWFkbyAodGlwaWNvIDAsNUggYSAwLDdIKScpOwogIGlmKEJIPjAuODUpIGFsZXJ0YXMucHVzaCgnSU5GTzogQi9IPScrZm10KEJILDIpKycgPiAwLDg1IFx1MjAxNCB2ZXJpZmljYXIgZWNvbm9taWNpZGFkZScpOwogIHZhciBmY2tfbWluPUZDS19NSU5bYWdyZXNzXXx8MjA7CiAgaWYoZmNrPGZja19taW4pIGFsZXJ0YXMucHVzaCgnRVJSTzogZmNrPScrZmNrKydNUGEgYWJhaXhvIGRvIG1pbmltbyBDJytmY2tfbWluKycgcGFyYSBDQSAnK2FncmVzcysnIChOQlIgNjExOCB0YWIuNi4xKScpOwogIHZhciBjb2JfbWluX3RibD1DT0JfTUlOW2FncmVz

c10/Q09CX01JTlthZ3Jlc3NdWydDJytmY2tdOm51bGw7CiAgdmFyIGNvYl9taW49Y29iX21pbl90Ymx8fDk5OTsKICBpZihjb2JfbWluX3RibD09PW51bGwpIGFsZXJ0YXMucHVzaCgnRVJSTzogQ29tYmluYWNhbyBDQSAnK2FncmVzcysnICsgQycrZmNrKycgaW5jb21wYXRpdmVsIFx1MjAxNCBhdW1lbnRlIGZjayAoTkJSIDYxMTgpJyk7CiAgZWxzZSBpZihjb2JfbW08Y29iX21pbikgYWxlcnRhcy5wdXNoKCdFUlJPOiBDb2JyaW1lbnRvICcrY29iX21tKydtbSA8IG1pbmltbyAnK2NvYl9taW4rJ21tIHBhcmEgQ0EgJythZ3Jlc3MrJyBDJytmY2srJyAoTkJSIDYxMTggdGFiLjcuMiknKTsKICBpZihkcmVuPT09J3NlbV9kcmVubycpIGFsZXJ0YXMucHVzaCgn

Q1JJVElDTzogU2VtIGRyZW5hZ2VtIFx1MjAxNCBzdWJwcmVzc2FvIHRvdGFsIGNvbnNpZGVyYWRhLiBOQlIgMTE2ODIgXHUwMGE3NS42IGV4aWdlIHNpc3RlbWEgZGUgZHJlbmFnZW0uJyk7CiAgaWYoZHJlbj09PSdiYXJiYWNhcycpIGFsZXJ0YXMucHVzaCgnQVZJU086IEJhcmJhY2FzIFx1MjAxNCBlZmljaWVuY2lhIDUwJSBkZSBOdy4gRXNwZWNpZmljYXIgZXNwYWNhbWVudG8gPD0gMiwwbSBlIGRpYW1ldHJvID49IDc1bW0gKE5CUiAxMTY4MiBcdTAwYTc1LjYuMiknKTsKICB2YXIgQl9jYWxjPUItQjEtdF9iYXM7CiAgaWYoQl9jYWxjPDAuMSkgYWxlcnRhcy5wdXNoKCdFUlJPOiBDYWxjYW5oYXIgQmM9JytmbXQoQl9jYWxjLDMpKydtIGludmFsaWRvIFx1

MjAxNCB2ZXJpZmlxdWUgQiwgQjEgZSBlc3Blc3N1cmEgZG8gZnVzdGUnKTsKCiAgLy8gXHUyNTAwXHUyNTAwIFJlc2lzdFx1MDBlYW5jaWFzIFx1MjUwMFx1MjUwMAogIHZhciBmY2Q9ZmNrL2djOwogIHZhciBmeWQ9ZnlrL2dzX2FjbzsKICB2YXIgZmN0bT0oZmNrPD01MCk/MC4zKk1hdGgucG93KGZjaywyLzMpOjIuMTIqTWF0aC5sb2coMStmY2svMTApOwogIHZhciBmY3RrX2luZj0wLjcqZmN0bTsKICB2YXIgZmN0ZD1mY3RrX2luZi9nYzsKICB2YXIgRWM9KGZjazw9NTApPzU2MDAqTWF0aC5zcXJ0KGZjayk6MjE1MDAqTWF0aC5wb3coZmNrLzEwKzEuMjUsMS8zKTsKCiAgLy8gXHUyNTAwXHUyNTAwIEdlb21ldHJpYSBcdTI1MDBcdTI1MDAKICB2YXIgSF9m

dXN0ZT1ILWhzOwogIHZhciB0X21lZD0odF90b3ArdF9iYXMpLzI7CgogIC8vIFx1MjUwMFx1MjUwMCBOdyBlZmV0aXZvIFx1MjUwMFx1MjUwMAogIHZhciBOd19lZmY9Tnc7CiAgaWYoZHJlbj09PSdkcmVub19nZW90ZXh0aWwnfHxkcmVuPT09J2RyZW5vX2JyaXRhJykgTndfZWZmPTA7CiAgaWYoZHJlbj09PSdiYXJiYWNhcycpIE53X2VmZj1OdyowLjU7CiAgdmFyIFVfc3ViPTAsVV95YT0wOwogIGlmKE53X2VmZj4wJiZOd19lZmY8PUgpe1Vfc3ViPTAuNSoxMCpOd19lZmYqTndfZWZmO1VfeWE9TndfZWZmLzM7fQoKICAvLyBcdTI1MDBcdTI1MDAgQ291bG9tYiBcdTI1MDBcdTI1MDAKICB2YXIgcGhpPXRvUmFkKHBoaV9kZWcpLGJldGFSPXRvUmFkKGJldGEp

LGRlbHRhPXBoaSoyLzM7CiAgdmFyIEthX249TWF0aC5wb3coTWF0aC5zaW4oTWF0aC5QSS8yK3BoaSksMik7CiAgdmFyIEthX2Q9TWF0aC5wb3coTWF0aC5zaW4oTWF0aC5QSS8yKSwyKSpNYXRoLnNpbihNYXRoLlBJLzItZGVsdGEpOwogIHZhciBLYV9zcXI9TWF0aC5zcXJ0KE1hdGguc2luKHBoaStkZWx0YSkqTWF0aC5zaW4ocGhpLWJldGFSKS8oTWF0aC5zaW4oTWF0aC5QSS8yLWRlbHRhKSpNYXRoLnNpbihNYXRoLlBJLzIrYmV0YVIpKSk7CiAgdmFyIEthPUthX24vKEthX2QqTWF0aC5wb3coMStLYV9zcXIsMikpOwogIHZhciBLYV9yYW5rPU1hdGgucG93KE1hdGgudGFuKE1hdGguUEkvNC1waGkvMiksMik7CgogIC8vIEVtcHV4byBzb2xvCiAgdmFyIEVh

X2Rpc3Q9MC41KkthKmdhbWFfcypIKkg7CiAgdmFyIHlhX2Rpc3Q9SC8zOwogIHZhciBFYWhfZD1FYV9kaXN0Kk1hdGguY29zKGRlbHRhKTsKICB2YXIgRWF2X2Q9RWFfZGlzdCpNYXRoLnNpbihkZWx0YSk7CgogIC8vIEVtcHV4byBzb2JyZWNhcmdhCiAgdmFyIEVhaF9xPTAsRWF2X3E9MCx5YV9xPUgvMixFYV9xX3ZhbD0wOwogIGlmKHRpcG9fc2MhPT0nbmVuaHVtYScmJnFfc29iPjApewogICAgRWFfcV92YWw9S2EqcV9zb2IqSDsKICAgIEVhaF9xPUVhX3FfdmFsKk1hdGguY29zKGRlbHRhKTsKICAgIEVhdl9xPUVhX3FfdmFsKk1hdGguc2luKGRlbHRhKTsKICB9CgogIC8vIEJvdXNzaW5lc3EKICB2YXIgRWFoX2JvPTAseWFfYm89SC8yOwogIGlmKHRpcG9f

c2M9PT0nY29uY2VudHJhZGEnJiZQX2NvbmM+MCYmZGlzdF9zYz4wKXsKICAgIHZhciBibz1ib3Vzc2luZXNxKFBfY29uYyxkaXN0X3NjLEgpOwogICAgRWFoX2JvPWJvLkVoOyB5YV9ibz1iby55YTsKICB9CiAgdmFyIEVhdl90b3Q9RWF2X2QrRWF2X3E7CgogIC8vIFx1MjUwMFx1MjUwMCBQcmVzc1x1MDBlM28gcGFzc2l2YSBubyBwXHUwMGU5IFx1MjUwMFx1MjUwMAogIC8vIEtwIFJhbmtpbmUgKGNvbnNlcnZhZG9yIFx1MjAxNCBuXHUwMGUzbyBjb25zaWRlcmEgXHUwM2I0KQogIHZhciBLcD1NYXRoLnBvdyhNYXRoLnRhbihNYXRoLlBJLzQrcGhpLzIpLDIpOwogIHZhciBFcD0wLjUqS3AqZ2FtYV9zKkhlbSpIZW07IC8vIGtOL20KICAvLyBFcCBuXHUwMGUz

byBcdTAwZTkgaW5jbHVcdTAwZWRkbyBuYSBlc3RhYmlsaWRhZGUgcG9yIGRlZmF1bHQgKGNvbnNlcnZhZG9yKQogIC8vIG1hcyBcdTAwZTkgY2FsY3VsYWRvIGUgZXhpYmlkbyBubyBtZW1vcmlhbAoKICAvLyBcdTI1MDBcdTI1MDAgUGVzb3MgcHJcdTAwZjNwcmlvcyBcdTI1MDBcdTI1MDAKICB2YXIgV19mdXN0ZT1nYW1hX2MqKHRfdG9wK3RfYmFzKS8yKkhfZnVzdGU7CiAgdmFyIHhfZnVzdGU9QjErdF9iYXMtKHRfYmFzLXRfdG9wKS8zOwogIHZhciBXX3NhcD1nYW1hX2MqQipoczsKICB2YXIgeF9zYXA9Qi8yOwogIHZhciBXX3NvbG89Z2FtYV9zKkJfY2FsYypIX2Z1c3RlOwogIHZhciB4X3NvbG89Qi1CX2NhbGMvMjsKICB2YXIgV19wZT1nYW1hX3MqQjEq

SGVtOwogIHZhciB4X3BlPUIxLzI7CiAgdmFyIHhfZWF2PUI7CgogIHZhciBWX3RvdGFsPVdfZnVzdGUrV19zYXArV19zb2xvK1dfcGUrRWF2X3RvdDsKCiAgLy8gXHUyNTAwXHUyNTAwIE1vbWVudG9zIFx1MjUwMFx1MjUwMAogIHZhciBNX2VzdD1XX2Z1c3RlKnhfZnVzdGUrV19zYXAqeF9zYXArV19zb2xvKnhfc29sbytXX3BlKnhfcGUrRWF2X3RvdCp4X2VhdjsKICB2YXIgTV90b21iPShFYWhfZCp5YV9kaXN0KSsoRWFoX3EqeWFfcSkrKEVhaF9ibyp5YV9ibykrKFVfc3ViKlVfeWEpOwoKICAvLyBcdTI1MDBcdTI1MDAgMS4gVG9tYmFtZW50byBcdTI1MDBcdTI1MDAKICB2YXIgQ1NfdG9tYj1NX2VzdC9NYXRoLm1heChNX3RvbWIsMC4wMDEpOwoKICAvLyBc

dTI1MDBcdTI1MDAgMi4gRGVzbGl6YW1lbnRvIChzZW0gRXAgXHUyMDE0IGNvbnNlcnZhZG9yKSBcdTI1MDBcdTI1MDAKICB2YXIgRkhfcmVzPW11KlZfdG90YWwrY29lcypCOwogIHZhciBGSF9hdGl2PUVhaF9kK0VhaF9xK0VhaF9ibytVX3N1YjsKICB2YXIgQ1NfZGVzbD1GSF9yZXMvTWF0aC5tYXgoRkhfYXRpdiwwLjAwMSk7CiAgLy8gRGVzbGl6YW1lbnRvIGNvbSBFcCAoaW5mb3JtYXRpdm8pCiAgdmFyIENTX2Rlc2xfRXA9KEZIX3JlcytFcCkvTWF0aC5tYXgoRkhfYXRpdiwwLjAwMSk7CgogIC8vIFx1MjUwMFx1MjUwMCAzLiBDYXBhY2lkYWRlIGRlIGNhcmdhIFx1MjUwMFx1MjUwMAogIHZhciB4Uj0oTV9lc3QtTV90b21iKS9WX3RvdGFsOwogIHZhciBl

X2V4Yz1NYXRoLmFicyhCLzIteFIpOwogIHZhciBlX21heD1CLzY7CiAgdmFyIG9rX2V4Yz1lX2V4Yzw9ZV9tYXg7CiAgdmFyIEJfZWZmPUItMiplX2V4YzsKICB2YXIgcV9tZWQ9Vl90b3RhbC9COwogIHZhciBxX21heD1WX3RvdGFsL0IqKDErNiplX2V4Yy9CKTsKICB2YXIgcV9taW49Vl90b3RhbC9CKigxLTYqZV9leGMvQik7CiAgaWYocV9taW48MCkgYWxlcnRhcy5wdXNoKCdFUlJPOiBxX21pbj0nK2ZtdChxX21pbiwyKSsnIGtOL20yIDwgMCBcdTIwMTQgVFJBQ0FPIE5BIEJBU0UuIFJlZGVzZW5oYXIgZ2VvbWV0cmlhLicpOwogIHZhciB0ZXo9Y2FwYVRlcnphZ2hpKHBoaV9kZWcsY29lcyxnYW1hX3MsSGVtLEJfZWZmKTsKICB2YXIgc2lnYWRtX3Vzbz1v

cmlnX3E9PT0nY2FsY3Vsbyc/dGV6LnFhZG06c2lnYWRtX2lucDsKICB2YXIgb2tfY2FwPXFfbWF4PD1zaWdhZG1fdXNvOwogIGlmKCFva19jYXApIGFsZXJ0YXMucHVzaCgnRVJSTzogcV9tYXg9JytmbXQocV9tYXgsMikrJyBrTi9tMiA+IHNpZ2FkbT0nK2ZtdChzaWdhZG1fdXNvLDIpKycga04vbTInKTsKCiAgLy8gXHUyNTAwXHUyNTAwIFJlY2FscXVlIFx1MjUwMFx1MjUwMAogIHZhciBEZWx0YV9xPU1hdGgubWF4KHFfbWF4LWdhbWFfcypIZW0sMCk7CiAgdmFyIHJlY19tbT1waGlfZGVnPj0yNT9EZWx0YV9xL25zcHQqQl9lZmYqMTAqMjpEZWx0YV9xKkJfZWZmL2tzKjEwMDA7CgogIC8vIFx1MjUwMFx1MjUwMCA0LiBCaXNob3Agc2ltcGxpZmljYWRvIFx1

MjUwMFx1MjUwMAogIC8vIDUgY1x1MDBlZHJjdWxvcyBjb20gZmF0b3IgZGUgcG9yb3MgcnUKICB2YXIgQ1NfYmlzaG9wPTk5OwogIHZhciBjYW5kaWRhdG9zPVt7eGM6QiowLjEseWM6SCoxLjIsUjpIKjEuM30se3hjOjAseWM6SCoxLjUsUjpIKjEuNn0se3hjOkIqMC4yLHljOkgsUjpIKjEuMX0se3hjOi1CKjAuMSx5YzpIKjEuMyxSOkgqMS40fSx7eGM6QiowLjMseWM6SCowLjgsUjpIKjAuOTV9XTsKICBmb3IodmFyIGNpPTA7Y2k8Y2FuZGlkYXRvcy5sZW5ndGg7Y2krKyl7CiAgICB2YXIgY2M9Y2FuZGlkYXRvc1tjaV07CiAgICB2YXIgbl9mYXQ9OCxzb21hX3I9MCxzb21hX209MDsKICAgIHZhciBkYW5nPU1hdGguUEkvbl9mYXQ7CiAgICBmb3IodmFyIGZp

PTA7Zmk8bl9mYXQ7ZmkrKyl7CiAgICAgIHZhciBhbmc9LU1hdGguUEkvMitmaSpkYW5nK2RhbmcvMjsKICAgICAgdmFyIHhpPWNjLnhjK2NjLlIqTWF0aC5zaW4oYW5nKTsKICAgICAgdmFyIHppPWNjLnljLWNjLlIqTWF0aC5jb3MoYW5nKTsKICAgICAgaWYoemk8MHx8emk+SCkgY29udGludWU7CiAgICAgIHZhciBiaT1jYy5SKmRhbmcqTWF0aC5jb3MoYW5nKTsKICAgICAgdmFyIGhpPU1hdGgubWF4KDAsSC16aSk7CiAgICAgIHZhciBXaT1nYW1hX3MqaGkqYmk7CiAgICAgIHZhciBOaT1XaSpNYXRoLmNvcyhhbmcpOwogICAgICB2YXIgdWk9cnUqV2kvTWF0aC5tYXgoYmksMC4wMDEpKk1hdGguY29zKGFuZyk7CiAgICAgIHNvbWFfcis9KGNvZXMqYmkrKE5p

LXVpKSpNYXRoLnRhbihwaGkpKTsKICAgICAgc29tYV9tKz1XaSpNYXRoLnNpbihhbmcpOwogICAgfQogICAgdmFyIGNzX2k9c29tYV9yL01hdGgubWF4KHNvbWFfbSwwLjAwMSk7CiAgICBpZihjc19pPjAmJmNzX2k8Q1NfYmlzaG9wKSBDU19iaXNob3A9Y3NfaTsKICB9CiAgQ1NfYmlzaG9wPU1hdGgubWF4KENTX2Jpc2hvcCwwLjUpOwoKICAvLyBcdTI1MDBcdTI1MDAgNS4gU1x1MDBlZHNtaWNhIChNb25vbm9iZS1Pa2FiZSkgXHUyNTAwXHUyNTAwCiAgdmFyIENTX3RvbWJfc2lzPTAsQ1NfZGVzbF9zaXM9MDsKICBpZihhZz4wKXsKICAgIHZhciBraD1hZyowLjU7CiAgICB2YXIgZFBhZT0wLjM3NSpraCpnYW1hX3MqSCpIOwogICAgdmFyIHlhX3Npcz0wLjYq

SDsKICAgIENTX3RvbWJfc2lzPU1fZXN0L01hdGgubWF4KE1fdG9tYitkUGFlKnlhX3NpcywwLjAwMSk7CiAgICBDU19kZXNsX3Npcz1GSF9yZXMvTWF0aC5tYXgoRkhfYXRpditkUGFlLDAuMDAxKTsKICAgIGlmKENTX3RvbWJfc2lzPDEuMSkgYWxlcnRhcy5wdXNoKCdTSVNNSUNPOiBDU3RvbWI9JytmbXQoQ1NfdG9tYl9zaXMsMykrJyA8IDEsMTAgKE5CUiAxNTQyMSknKTsKICAgIGlmKENTX2Rlc2xfc2lzPDEuMSkgYWxlcnRhcy5wdXNoKCdTSVNNSUNPOiBDU2Rlc2w9JytmbXQoQ1NfZGVzbF9zaXMsMykrJyA8IDEsMTAgKE5CUiAxNTQyMSknKTsKICB9CgogIC8vIFx1MjUwMFx1MjUwMCBEaW1lbnNpb25hbWVudG8gZXN0cnV0dXJhbCBcdTI1MDBcdTI1MDAK

ICAvLyBcdTAzYjNmID0gMSw0IHBhcmEgYVx1MDBlN1x1MDBlM28gdmFyaVx1MDBlMXZlbCAoZW1wdXhvKSBcdTIwMTQgTkJSIDYxMTggXHUwMGE3MTEuNwogIHZhciBnZj0xLjQ7CgogIC8vIEZvclx1MDBlN2Egbm9ybWFsIG5vIGZ1c3RlOiBwZXNvIGRvIGZ1c3RlICsgc29sbyBzb2JyZSBlbGUgKGZsZXhvLWNvbXByZXNzXHUwMGUzbykKICB2YXIgTl9mdXN0ZT1XX2Z1c3RlOyAvLyBrTi9tIChwZXNvIHByXHUwMGYzcHJpbyBkbyBmdXN0ZSBlbSBjb21wcmVzc1x1MDBlM28pCiAgdmFyIHNpZ21hX249Tl9mdXN0ZS8odF9iYXMpOyAvLyBrTi9tMiAodGVuc1x1MDBlM28gbm9ybWFsIG1cdTAwZTlkaWEgbm8gZnVzdGUpCgogIC8vIEZVU1RFIFx1MjAxNCBmbGV4

by1jb21wcmVzc1x1MDBlM28gKHNlXHUwMGU3XHUwMGUzbyBuYSBiYXNlKQogIHZhciBkX2Z1c3RlPXRfYmFzLWNvYi1kaWFtX2YvMTAwMC8yOwogIHZhciBNZl9mdXN0ZT1nZiooRWFoX2QqKEhfZnVzdGUvMykrRWFoX3EqKEhfZnVzdGUvMikrRWFoX2JvKihIX2Z1c3RlLzIpKTsKICB2YXIgTmRfZnVzdGU9Z2YqTl9mdXN0ZTsgLy8gZm9yXHUwMGU3YSBub3JtYWwgZGUgY1x1MDBlMWxjdWxvCgogIC8vIE1vbWVudG8gcmVkdXppZG8gY29tIHJlZHVcdTAwZTdcdTAwZTNvIHBvciBmb3JcdTAwZTdhIG5vcm1hbCAoTkJSIDYxMTggXHUyMDE0IGNvbXByZXNzXHUwMGUzbyByZWR1eiBleGlnXHUwMGVhbmNpYSkKICB2YXIgZV9mYXQ9TWZfZnVzdGUvTWF0aC5tYXgo

TmRfZnVzdGUsMC4wMDEpOyAvLyBleGNlbnRyaWNpZGFkZQogIHZhciBNZl9lZj1NZl9mdXN0ZTsgLy8gbWFudFx1MDBlOW0gTWQgb3JpZ2luYWwgKGEgZm9yXHUwMGU3YSBub3JtYWwgYWxpdmlhLCBlbnRcdTAwZTNvIHVzYXIgTWQgc2VtIHJlZHVcdTAwZTdcdTAwZTNvIFx1MDBlOSBjb25zZXJ2YWRvcikKCiAgdmFyIGtNZD1NZl9lZioxMDAwLygxMDAwKmRfZnVzdGUqMTAwMCpkX2Z1c3RlKjEwMDAqZmNkKTsKICB2YXIgeGRfZj0oMS1NYXRoLnNxcnQoTWF0aC5tYXgoMS0yKmtNZCwwLjAwMSkpKS8wLjg7CiAgaWYoeGRfZj4wLjQ1KXsKICAgIGFsZXJ0YXMucHVzaCgnRlVTVEU6IHgvZD0nK2ZtdCh4ZF9mLDMpKycgPiAwLDQ1IFx1MjAxNCBEb21pbmlvIDQu

IEF1bWVudGFyIHNlY2FvIG91IGFybWFkdXJhIGR1cGxhIChOQlIgNjExOCBcdTAwYTcxNC42LjQuMykuJyk7CiAgfQogIHZhciBkb21pbmlvX2Y9eGRfZjwwLjI1OT8nMiAodHJhY2FvIHB1cmEpJzp4ZF9mPDAuNDU/JzMgKGZsZXhvLXRyYWNhbyknOic0IC0gdmVyaWZpY2FyJzsKICB2YXIgQXNfZnVzdGU9TWF0aC5tYXgoTWZfZWYqMWU2LygwLjg3KmZ5ZCpkX2Z1c3RlKjEwMDApLDApOwogIHZhciBBc19taW5fZj1NYXRoLm1heCgwLjAwMTUqMTAwMCp0X2JhcyoxMDAwLGZjdG0vZnlrKjEwMDAqZF9mdXN0ZSoxMDAwKTsKICB2YXIgQXNfZnVzdGVfZmluPU1hdGgubWF4KEFzX2Z1c3RlLEFzX21pbl9mKTsKCiAgLy8gQXJtYWR1cmEgZGUgZGlzdHJpYnVpXHUw

MGU3XHUwMGUzbyBob3Jpem9udGFsIFx1MjAxNCBOQlIgNjExOCBcdTAwYTcxNy4zLjUgKDIwJSBkYSBwcmluY2lwYWwsIG1pbiByaG89MCwxNSUpCiAgdmFyIEFzX2Rpc3RyPU1hdGgubWF4KDAuMjAqQXNfZnVzdGVfZmluLDAuMDAxNSpIX2Z1c3RlKjEwMDAqdF9tZWQqMTAwMC9IX2Z1c3RlKTsKICBBc19kaXN0cj1NYXRoLm1heChBc19kaXN0ciw5MCk7IC8vIG1pbiA5MCBtbTIvbQoKICAvLyBDaXNhbGhhbWVudG8gZnVzdGUgXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzE3LjQgTW9kZWxvIEkKICB2YXIgVmRfZj1nZiooRWFoX2QrRWFoX3ErRWFoX2JvKTsKICB2YXIgVlJkMV9mPSgwLjI3L2djKSpNYXRoLnBvdyhmY2ssMS8zKSpkX2Z1c3RlKjEwMDAqMTAwMC8x

MDAwOwogIHZhciBva19jaXNfZj1WZF9mPD1WUmQxX2Y7CiAgLy8gRXN0cmlib3Mgc2UgbmVjZXNzXHUwMGUxcmlvCiAgdmFyIEFzX2VzdHJpYm9zPTAsc19lc3RyaWJvcz0yMDA7CiAgaWYoIW9rX2Npc19mKXsKICAgIGFsZXJ0YXMucHVzaCgnRlVTVEU6IFZkPScrZm10KFZkX2YsMikrJyBrTi9tID4gVlJkMT0nK2ZtdChWUmQxX2YsMikrJyBrTi9tIFx1MjAxNCBFU1RSSUJPUyBuZWNlc3NhcmlvcycpOwogICAgLy8gQXJtYWR1cmEgdHJhbnN2ZXJzYWwgbVx1MDBlZG5pbWEgXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzE3LjQuMS4yCiAgICB2YXIgcmhvX3N3X21pbj0wLjIqZmN0bS9meWQ7IC8vIE5CUiA2MTE4IGVxLjE3LjUKICAgIEFzX2VzdHJpYm9zPXJob19z

d19taW4qdF9iYXMqMTAwMDsgLy8gbW0yL20gKGVzdHJpYm8gZG9pcyByYW1vcykKICAgIEFzX2VzdHJpYm9zPU1hdGgubWF4KEFzX2VzdHJpYm9zLDUwKTsgLy8gbWluIHBoaTZjLzIwMAogICAgc19lc3RyaWJvcz1NYXRoLm1pbigyMDAsTWF0aC5mbG9vcigwLjYqZF9mdXN0ZSoxMDAwLzEwKSoxMCk7IC8vIHMgPD0gMCw2ZAogIH0KCiAgLy8gRXNiZWx0ZXogXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzE1CiAgdmFyIGxlX2Y9MipIX2Z1c3RlOwogIHZhciBpX2Y9dF9tZWQvTWF0aC5zcXJ0KDEyKTsKICB2YXIgbGFtYj1sZV9mL2lfZjsKICBpZihsYW1iPjM1KSBhbGVydGFzLnB1c2goJ0ZVU1RFOiBsYW1iZGE9JytmbXQobGFtYiwxKSsnID4gMzUgXHUyMDE0IGVm

ZWl0b3MgZGUgMmEgb3JkZW0gb2JyaWdhdG9yaW9zIChOQlIgNjExOCBcdTAwYTcxNS44KScpOwoKICAvLyBBbmNvcmFnZW0gXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzkuMwogIHZhciBmYmQ9Mi4yNSoxLjAqMS4wKmZjdGQ7CiAgdmFyIGxiX2Jhcz0oZGlhbV9mLzQpKihmeWQvZmJkKTsKICB2YXIgbGJfZj1NYXRoLm1heChsYl9iYXMqKEFzX2Z1c3RlL01hdGgubWF4KEFzX2Z1c3RlX2ZpbiwxKSksTWF0aC5tYXgoMC4zKmxiX2JhcywxMCpkaWFtX2YsMTAwKSk7CgogIC8vIFNBUEFUQSBcdTIwMTQgQ2FsY2FuaGFyIChmbGV4XHUwMGUzbykKICB2YXIgZF9zYXA9aHMtY29iLWRpYW1fcy8xMDAwLzI7CiAgdmFyIHFfY2FsY19zYXA9Z2FtYV9zKkhfZnVzdGU7CiAg

dmFyIE1mX3NhcF9jPWdmKnFfY2FsY19zYXAqQl9jYWxjKkJfY2FsYy8yOwogIHZhciBBc19zYXBfYz1NYXRoLm1heChNZl9zYXBfYyoxZTYvKDAuODcqZnlkKmRfc2FwKjEwMDApLDApOwogIHZhciBBc19taW5fc2M9TWF0aC5tYXgoMC4wMDE1KjEwMDAqaHMqMTAwMCxmY3RtL2Z5ayoxMDAwKmRfc2FwKjEwMDApOwogIHZhciBBc19zYXBfY19maW49TWF0aC5tYXgoQXNfc2FwX2MsQXNfbWluX3NjKTsKCiAgLy8gU0FQQVRBIFx1MjAxNCBDYWxjYW5oYXIgKGNpc2FsaGFtZW50byBcdTIwMTQgTkJSIDYxMTggXHUwMGE3MTkgXHUyMDE0IGNvcnRhbnRlIHVuaWRpcmVjaW9uYWwpCiAgdmFyIFZkX2NhbGM9Z2YqcV9jYWxjX3NhcCpCX2NhbGM7IC8vIGtOL20KICB2

YXIgVlJkMV9jYWxjPSgwLjI3L2djKSpNYXRoLnBvdyhmY2ssMS8zKSpkX3NhcCoxMDAwKjEwMDAvMTAwMDsKICB2YXIgb2tfY2lzX2NhbGM9VmRfY2FsYzw9VlJkMV9jYWxjOwogIGlmKCFva19jaXNfY2FsYykgYWxlcnRhcy5wdXNoKCdDQUxDQU5IQVI6IFZkPScrZm10KFZkX2NhbGMsMikrJyBrTi9tID4gVlJkMT0nK2ZtdChWUmQxX2NhbGMsMikrJyBrTi9tIFx1MjAxNCBhdW1lbnRhciBocyBvdSBhcm1hZHVyYSB0cmFuc3ZlcnNhbCcpOwoKICAvLyBTQVBBVEEgXHUyMDE0IFBcdTAwZTkgZGlhbnRlaXJvIChmbGV4XHUwMGUzbykKICB2YXIgcV9wZV9tZWQ9KHFfbWF4K01hdGgubWF4KHFfbWluLDApKS8yOwogIHZhciBxX3BlX2xpcT1NYXRoLm1heChxX3Bl

X21lZC1nZipnYW1hX2MqaHMsMCk7CiAgdmFyIE1mX3NhcF9wPWdmKnFfcGVfbGlxKkIxKkIxLzI7CiAgdmFyIEFzX3NhcF9wPU1hdGgubWF4KE1mX3NhcF9wKjFlNi8oMC44NypmeWQqZF9zYXAqMTAwMCksMCk7CiAgdmFyIEFzX3NhcF9wX2Zpbj1NYXRoLm1heChBc19zYXBfcCxBc19taW5fc2MpOwoKICAvLyBTQVBBVEEgXHUyMDE0IFBcdTAwZTkgZGlhbnRlaXJvIChjaXNhbGhhbWVudG8pCiAgdmFyIFZkX3BlPWdmKnFfcGVfbGlxKkIxOwogIHZhciBva19jaXNfcGU9VmRfcGU8PVZSZDFfY2FsYzsKICBpZighb2tfY2lzX3BlKSBhbGVydGFzLnB1c2goJ1BFIERJQU5URUlSTzogVmQ9JytmbXQoVmRfcGUsMikrJyBrTi9tID4gVlJkMT0nK2ZtdChWUmQxX2Nh

bGMsMikrJyBrTi9tIFx1MjAxNCBhdW1lbnRhciBocycpOwoKICAvLyBBbmNvcmFnZW0gc2FwYXRhCiAgdmFyIGxiX3NjPU1hdGgubWF4KGxiX2JhcyooQXNfc2FwX2MvTWF0aC5tYXgoQXNfc2FwX2NfZmluLDEpKSxNYXRoLm1heCgwLjMqbGJfYmFzLDEwKmRpYW1fcywxMDApKTsKCiAgLy8gQmFycmFzCiAgdmFyIGFybV9mPXN1Z2VyaXJCYXJyYShBc19mdXN0ZV9maW4sZGlhbV9mKTsKICB2YXIgYXJtX2Q9c3VnZXJpckJhcnJhKEFzX2Rpc3RyLDgpOwogIHZhciBhcm1fc2M9c3VnZXJpckJhcnJhKEFzX3NhcF9jX2ZpbixkaWFtX3MpOwogIHZhciBhcm1fc3A9c3VnZXJpckJhcnJhKEFzX3NhcF9wX2ZpbixkaWFtX3MpOwoKICAvLyBcdTI1MDBcdTI1MDAgU0VN

XHUwMGMxRk9STyBcdTI1MDBcdTI1MDAKICBmdW5jdGlvbiBzSXRlbShsYmwsdmFsLHJlcSxleHRyYSl7CiAgICB2YXIgcj12YWwvcmVxOwogICAgdmFyIGNscz1yPj0xLjE1Pydvay1zJzoocj49MS4wPyd3YXJuLXMnOidlcnItcycpOwogICAgdmFyIGljPXI+PTEuMTU/J09LJzoocj49MS4wPydBVlMnOidOT0snKTsKICAgIHJldHVybiAnPGRpdiBjbGFzcz0ic2l0ZW0gJytjbHMrJyI+PGRpdiBjbGFzcz0ic2xibCI+JytsYmwrJzwvZGl2PjxkaXYgY2xhc3M9InN2YWwiPicraWMrJyAnK2ZtdCh2YWwsMikrJzwvZGl2PjxkaXYgY2xhc3M9InNyZXEiPm1pbjonK2ZtdChyZXEsMikrKGV4dHJhPycgJytleHRyYTonJykrJzwvZGl2PjwvZGl2Pic7CiAgfQogIGRv

Y3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZW1fZ2VvJykuaW5uZXJIVE1MPQogICAgc0l0ZW0oJ1RvbWJhbWVudG8nLENTX3RvbWIsQ1NUX01JTikrCiAgICBzSXRlbSgnRGVzbGl6YW1lbnRvJyxDU19kZXNsLENTRF9NSU4pKwogICAgc0l0ZW0oJ0NhcC5DYXJnYVxucTw9c2lnYWRtJyxzaWdhZG1fdXNvL01hdGgubWF4KHFfbWF4LDAuMDEpLDEuMCwncT0nK2ZtdChxX21heCwxKSsna04nKSsKICAgIHNJdGVtKCdFeGNlbnRyLlxuZTw9Qi82JyxlX21heC9NYXRoLm1heChlX2V4YywwLjAwMSksMS4wLCdlPScrZm10KGVfZXhjLDMpKydtJykrCiAgICBzSXRlbSgnQmlzaG9wXG5DU3InLENTX2Jpc2hvcCxDU1JfTUlOKTsKICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ

ZCgnc2VtX2VzdCcpLmlubmVySFRNTD0KICAgIHNJdGVtKCdGdXN0ZVxueC9kPD0wLDQ1JywwLjQ1L01hdGgubWF4KHhkX2YsMC4wMDEpLDEuMCwneGQ9JytmbXQoeGRfZiwzKSkrCiAgICBzSXRlbSgnQ29ydC5GdXN0ZVxuVmQ8PVZSZDEnLFZSZDFfZi9NYXRoLm1heChWZF9mLDAuMDAxKSwxLjAsJ1ZkPScrZm10KFZkX2YsMSkrJ2tOJykrCiAgICBzSXRlbSgnQ29ydC5DYWxjLlxuVmQ8PVZSZDEnLFZSZDFfY2FsYy9NYXRoLm1heChNYXRoLm1heChWZF9jYWxjLFZkX3BlKSwwLjAwMSksMS4wLCdWZD0nK2ZtdChNYXRoLm1heChWZF9jYWxjLFZkX3BlKSwxKSsna04nKSsKICAgIHNJdGVtKCdFbWJ1dGltLlxuSGVtPj1taW4nLEhlbS9IZW1fbWluLDEuMCwnbWlu

PScrZm10KEhlbV9taW4sMikrJ20nKTsKCiAgLy8gQWxlcnRhcwogIHZhciBhZGl2PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhbGVydGFzX2RpdicpOwogIGFkaXYuaW5uZXJIVE1MPScnOwogIGFsZXJ0YXMuZm9yRWFjaChmdW5jdGlvbihhKXsKICAgIHZhciBjbHM9YS5pbmRleE9mKCdFUlJPJyk9PT0wfHxhLmluZGV4T2YoJ0NSSVRJQ08nKT09PTA/J2FsZXJ0YSc6YS5pbmRleE9mKCdBVklTTycpPT09MD8nYXZpc28nOidpbmZvLWJveCc7CiAgICBhZGl2LmlubmVySFRNTCs9JzxkaXYgY2xhc3M9IicrY2xzKyciPicrYSsnPC9kaXY+JzsKICB9KTsKCiAgLy8gXHUyNTAwXHUyNTAwIE1FTU9SSUFMIFx1MjUwMFx1MjUwMAogIHZhciBTRVA9Jz0nLnJlcGVh

dCg1Nik7CiAgdmFyIHNlcD0nLS0tJy5yZXBlYXQoMTgpOwogIHZhciBtZW09Jyc7CiAgbWVtKz0nPGg0PicrU0VQKyc8L2g0Pic7CiAgbWVtKz0nTUVNT1JJQUwgREUgQ0FMQ1VMT1xuTVVSTyBERSBBUlJJTU8gRU0gQ09OQ1JFVE8gQVJNQURPXG5OQlIgNjExODoyMDIzIHwgTkJSIDYxMjA6MjAxOSB8IE5CUiAxMTY4MjoyMDA5IHwgTkJSIDYxMjI6MjAyMlxuJzsKICBtZW0rPSc8aDQ+JytTRVArJzwvaDQ+JzsKICBtZW0rPSdPYnJhICAgICAgICAgICAgICAgOiAnK29icmErJ1xuJzsKICBtZW0rPSdSZXNwLiBUZWNuaWNvICAgICAgOiAnK3Jlc3ArJ1xuJzsKICBtZW0rPSdSZWcuIFByb2Zpc3Npb25hbCAgOiAnK2NyZWErJ1xuJzsKICBtZW0rPSdEYXRhIC8g

UmV2aXNhbyAgICAgOiAnK2RhdGFfYysnIC8gJytyZXYrJ1xuJzsKICBtZW0rPSdMYXVkbyBHZW90ZWNuaWNvICAgOiAnK2xhdWRvKydcbic7CiAgbWVtKz0nQVJUIC8gUlJUICAgICAgICAgIDogJythcnQrJ1xuXG4nOwoKICBtZW0rPSc8aDQ+MS4gREFET1MgR0VPTUVUUklDT1M8L2g0Pic7CiAgbWVtKz0nICBIICAgPSAnK2ZtdChIKSsnbSAgSGVtID0gJytmbXQoSGVtKSsnbSAgW21pbj0nK2ZtdChIZW1fbWluLDIpKydtICcrKEhlbT49SGVtX21pbj8nT0snOidJTlNVRicpKyddICBIZnVzdGUgPSAnK2ZtdChIX2Z1c3RlKSsnbVxuJzsKICBtZW0rPScgIEIgICA9ICcrZm10KEIpKydtICBCL0ggPSAnK2ZtdChCSCwyKSsnICBCMSA9ICcrZm10KEIxKSsnbSAg

QmMgPSAnK2ZtdChCX2NhbGMsMykrJ20gIGhzID0gJytmbXQoaHMpKydtXG4nOwogIG1lbSs9JyAgdHQgID0gJytmbXQodF90b3ApKydtICB0YiA9ICcrZm10KHRfYmFzKSsnbSAgdG1lZCA9ICcrZm10KHRfbWVkLDMpKydtXG4nOwogIG1lbSs9JyAgYmV0YSA9ICcrZm10KGJldGEsMSkrJ28gIHFfc29iID0gJytmbXQocV9zb2IsMSkrJyBrTi9tMiAgdGlwbzogJyt0aXBvX3NjKydcblxuJzsKCiAgbWVtKz0nPGg0PjIuIENBUlJFR0FNRU5UT1M8L2g0Pic7CiAgaWYodGlwb19zYz09PSd1bmlmb3JtZScpIG1lbSs9JyAgU29icmVjYXJnYSBkaXN0cmlidWlkYTogcSA9ICcrZm10KHFfc29iLDEpKycga04vbTIgKE5CUiA2MTIwKVxuJzsKICBpZih0aXBvX3NjPT09

J2NvbmNlbnRyYWRhJyYmUF9jb25jPjApIG1lbSs9JyAgQ2FyZ2EgY29uY2VudHJhZGE6IFAgPSAnK2ZtdChQX2NvbmMsMSkrJyBrTi9tIEAgZCA9ICcrZm10KGRpc3Rfc2MsMSkrJ20gKEJvdXNzaW5lc3EpXG4gIEVhaChCb3Vzc2luZXNxKSA9ICcrZm10KEVhaF9ibywzKSsnIGtOL21cbic7CiAgaWYodGlwb19zYz09PSduZW5odW1hJykgbWVtKz0nICBTZW0gc29icmVjYXJnYSBhcGxpY2FkYS5cbic7CiAgbWVtKz0nXG4nOwoKICBtZW0rPSc8aDQ+My4gUEFSQU1FVFJPUyBHRU9URUNOSUNPUzwvaDQ+JzsKICBtZW0rPScgIExhdWRvIE4uICA6ICcrbGF1ZG8rJyAgfCAgU1VDUzogJytzdWNzKycgIHwgIE4tU1BUOiAnK25zcHQrJ1xuJzsKICBtZW0rPScgIGdh

bWFfcyA9ICcrZm10KGdhbWFfcywxKSsnIGtOL20zICBwaGkgPSAnK2ZtdChwaGlfZGVnLDEpKydvICBjID0gJytmbXQoY29lcywxKSsnIGtOL20yXG4nOwogIG1lbSs9JyAgbXUgPSAnK2ZtdChtdSwzKSsnICBOdyA9ICcrZm10KE53LDIpKydtICBOd19lZmYgPSAnK2ZtdChOd19lZmYsMikrJ20gIFNpc3RlbWE6ICcrZHJlbisnXG4nOwogIG1lbSs9JyAgcnUocG9yb3MpID0gJytmbXQocnUsMykrJyAga3MgPSAnK2ZtdChrcywwKSsnIGtOL20zXG4nOwogIGlmKE53X2VmZj4wKSBtZW0rPScgIFVfc3ViID0gMS8yICogZ3cgKiBOd14yID0gMCw1KjEwKicrZm10KE53X2VmZiwyKSsnXjIgPSAnK2ZtdChVX3N1YiwzKSsnIGtOL20gQCB5YT0nK2ZtdChVX3lhLDMp

KydtXG4nOwogIG1lbSs9J1xuJzsKCiAgbWVtKz0nPGg0PjQuIENBUEFDSURBREUgREUgQ0FSR0EgXHUyMDE0IFRFUlpBR0hJL01FWUVSSE9GPC9oND4nOwogIG1lbSs9JyAgRGYgPSBIZW0gPSAnK2ZtdChIZW0sMikrJ20gIEJcJyA9IEItMmUgPSAnK2ZtdChCX2VmZiw0KSsnbSAoYXJlYSBlZmV0aXZhKVxuJzsKICBtZW0rPScgIE5xID0gZXhwKHBpKnRhbihwaGkpKSp0YW5eMig0NStwaGkvMikgPSAnK2ZtdCh0ZXouTnEsMykrJ1xuJzsKICBtZW0rPScgIE5jID0gKE5xLTEpL3RhbihwaGkpICAgICAgICAgICAgICAgICAgID0gJytmbXQodGV6Lk5jLDMpKydcbic7CiAgbWVtKz0nICBOZyA9IDIqKE5xKzEpKnRhbihwaGkpICAgICAgICAgICAgICAgICA9ICcr

Zm10KHRlei5OZywzKSsnXG4nOwogIG1lbSs9JyAgcTAgPSBnYW1hX3MqRGYgPSAnK2ZtdChnYW1hX3MsMSkrJyonK2ZtdChIZW0sMikrJyA9ICcrZm10KHRlei5xMCwzKSsnIGtOL20yXG4nOwogIG1lbSs9JyAgcXVsdCA9IGMqTmMgKyBxMCpOcSArIDAsNSpnYW1hX3MqQlwnKk5nXG4nOwogIG1lbSs9JyAgICAgICA9ICcrZm10KGNvZXMsMSkrJyonK2ZtdCh0ZXouTmMsMykrJyArICcrZm10KHRlei5xMCwzKSsnKicrZm10KHRlei5OcSwzKSsnICsgMCw1KicrZm10KGdhbWFfcywxKSsnKicrZm10KEJfZWZmLDMpKycqJytmbXQodGV6Lk5nLDMpKydcbic7CiAgbWVtKz0nICAgICAgID0gJytmbXQodGV6LnF1bHQsMikrJyBrTi9tMlxuJzsKICBtZW0rPScgIHFh

ZG0gPSBxdWx0LzMgPSAnK2ZtdCh0ZXoucWFkbSwyKSsnIGtOL20yICAoRlM9Mylcbic7CiAgbWVtKz0nICBzaWdhZG1fdXNhZG8gPSAnK2ZtdChzaWdhZG1fdXNvLDIpKycga04vbTJcblxuJzsKCiAgbWVtKz0nPGg0PjUuIE1BVEVSSUFJUyBcdTIwMTQgTkJSIDYxMTg6MjAyMzwvaDQ+JzsKICBtZW0rPScgIENsYXNzZSBkZSBhZ3Jlc3NpdmlkYWRlIDogQ0EgJythZ3Jlc3MrJ1xuJzsKICBtZW0rPScgIGZjayA9ICcrZmNrKycgTVBhICBbbWluIENBICcrYWdyZXNzKyc6IEMnK2Zja19taW4rJyAnKyhmY2s+PWZja19taW4/J09LJzonRkFMSEEnKSsnXVxuJzsKICBtZW0rPScgIGZjZCA9IGZjay9nYyA9ICcrZmNrKycvJytnYysnID0gJytmbXQoZmNkLDIpKycg

TVBhXG4nOwogIG1lbSs9JyAgZmN0bSA9IDAsMzAqZmNrXigyLzMpID0gJytmbXQoZmN0bSwzKSsnIE1QYVxuJzsKICBtZW0rPScgIGZjdGssaW5mID0gMCw3MCpmY3RtICA9ICcrZm10KGZjdGtfaW5mLDMpKycgTVBhXG4nOwogIG1lbSs9JyAgZmN0ZCA9IGZjdGssaW5mL2djICAgID0gJytmbXQoZmN0ZCwzKSsnIE1QYVxuJzsKICBtZW0rPScgIEVjIChzZWNhbnRlKSAgICAgICAgICA9ICcrZm10KEVjLDApKycgTVBhXG4nOwogIG1lbSs9JyAgZnlrID0gJytmeWsrJyBNUGEgIC0+IGZ5ZCA9ICcrZnlrKycvJytnc19hY28rJyA9ICcrZm10KGZ5ZCwyKSsnIE1QYVxuJzsKICBtZW0rPScgIENvYnJpbWVudG8gbm9taW5hbCA9ICcrZm10KGNvYl9tbSwwKSsnIG1t

ICBbbWluIENBICcrYWdyZXNzKycgQycrZmNrKyc6ICcrY29iX21pbisnbW0gJysoY29iX21tPj1jb2JfbWluPydPSyc6J0ZBTEhBJykrJ11cblxuJzsKCiAgbWVtKz0nPGg0PjYuIENPRUZJQ0lFTlRFIERFIFBSRVNTQU8gQVRJVkEgXHUyMDE0IENPVUxPTUIgKE5CUiAxMTY4Mik8L2g0Pic7CiAgbWVtKz0nICBkZWx0YSA9IDIvMypwaGkgPSAnK2ZtdCh0b0RlZyhkZWx0YSksMykrJ28gIGJldGEgPSAnK2ZtdChiZXRhLDEpKydvXG4nOwogIG1lbSs9JyAgS2EgKENvdWxvbWIpICA9ICcrZm10KEthLDUpKydcbic7CiAgbWVtKz0nICBLYSAoUmFua2luZSkgID0gdGFuXjIoNDUtcGhpLzIpID0gJytmbXQoS2FfcmFuayw1KSsnICBbcmVmZXJlbmNpYV1cbic7CiAg

bWVtKz0nICBLcCAoUmFua2luZSkgID0gdGFuXjIoNDUrcGhpLzIpID0gJytmbXQoS3AsNSkrJyAgW3ByZXNzYW8gcGFzc2l2YV1cblxuJzsKCiAgbWVtKz0nPGg0PjcuIEZPUkNBUyBBVFVBTlRFUzwvaDQ+JzsKICBtZW0rPScgIEVNUFVYTyBETyBTT0xPICh0cmlhbmd1bGFyKTpcbic7CiAgbWVtKz0nICAgIEVhID0gMS8yKkthKmdhbWFfcypIXjIgPSAwLDUqJytmbXQoS2EsNCkrJyonK2ZtdChnYW1hX3MsMSkrJyonK2ZtdChILDIpKydeMiA9ICcrZm10KEVhX2Rpc3QsMykrJyBrTi9tXG4nOwogIG1lbSs9JyAgICBFYWggPSAnK2ZtdChFYWhfZCwzKSsnIGtOL20gIEAgeWEgPSBILzMgPSAnK2ZtdCh5YV9kaXN0LDMpKydtXG4nOwogIG1lbSs9JyAgICBFYXYg

PSAnK2ZtdChFYXZfZCwzKSsnIGtOL20gIChjb21wb25lbnRlIHZlcnRpY2FsIFx1MjAxNCBDb3Vsb21iKVxuXG4nOwogIGlmKHRpcG9fc2MhPT0nbmVuaHVtYScmJnFfc29iPjApewogICAgbWVtKz0nICBFTVBVWE8gU09CUkVDQVJHQSAocT0nK2ZtdChxX3NvYiwxKSsnIGtOL20yKTpcbic7CiAgICBtZW0rPScgICAgRWEocSkgPSBLYSpxKkggPSAnK2ZtdChFYV9xX3ZhbCwzKSsnIGtOL21cbic7CiAgICBtZW0rPScgICAgRWFoKHEpID0gJytmbXQoRWFoX3EsMykrJyBrTi9tICBAIHlhID0gSC8yID0gJytmbXQoeWFfcSwzKSsnbVxuJzsKICAgIG1lbSs9JyAgICBFYXYocSkgPSAnK2ZtdChFYXZfcSwzKSsnIGtOL21cblxuJzsKICB9CiAgaWYodGlwb19zYz09

PSdjb25jZW50cmFkYScmJlBfY29uYz4wKXsKICAgIG1lbSs9JyAgQk9VU1NJTkVTUSAoUD0nK2ZtdChQX2NvbmMsMSkrJyBrTi9tIEAgZD0nK2ZtdChkaXN0X3NjLDEpKydtKTpcbic7CiAgICBtZW0rPScgICAgRWFoID0gKFAvcGkpKihIKmReMi8oZF4yK0heMikrYXRhbihIL2QpKSA9ICcrZm10KEVhaF9ibywzKSsnIGtOL21cblxuJzsKICB9CiAgaWYoTndfZWZmPjApIG1lbSs9JyAgU1VCUFJFU1NBTzogVSA9IDEvMipndypOd19lZmZeMiA9ICcrZm10KFVfc3ViLDMpKycga04vbSAgQCB5YSA9ICcrZm10KFVfeWEsMykrJ21cblxuJzsKICBtZW0rPScgIFBSRVNTQU8gUEFTU0lWQSBOTyBQRSAoUmFua2luZSwgbmFvIHVzYWRhIG5hIGVzdGFiaWxpZGFkZSBc

dTIwMTQgY29uc2VydmFkb3IpOlxuJzsKICBtZW0rPScgICAgS3AgPSB0YW5eMig0NStwaGkvMikgPSAnK2ZtdChLcCw0KSsnXG4nOwogIG1lbSs9JyAgICBFcCA9IDEvMipLcCpnYW1hX3MqSGVtXjIgPSAwLDUqJytmbXQoS3AsNCkrJyonK2ZtdChnYW1hX3MsMSkrJyonK2ZtdChIZW0sMikrJ14yID0gJytmbXQoRXAsMykrJyBrTi9tXG4nOwogIG1lbSs9JyAgICBOT1RBOiBJbmNsdWktbGEgYXVtZW50YXJpYSBDU2Rlc2wgZGUgJytmbXQoQ1NfZGVzbCwzKSsnIHBhcmEgJytmbXQoQ1NfZGVzbF9FcCwzKSsnXG4nOwogIG1lbSs9JyAgICAgICAgICBPbWlzc2FvIGUgY29uc2VydmFkb3JhIChOQlIgMTE2ODIgXHUwMGE3NS41IFx1MjAxNCB2ZXJpZmljYXIgY29t

IGVuZ2VuaGVpcm8gZ2VvdGVjbmljbylcblxuJzsKICBtZW0rPScgIFBFU09TIFBST1BSSU9TOlxuJzsKICBtZW0rPScgICAgV19mdXN0ZSA9IGdjKih0dCt0YikvMipIZiA9ICcrZm10KGdhbWFfYywxKSsnKicrZm10KHRfbWVkLDMpKycqJytmbXQoSF9mdXN0ZSwzKSsnID0gJytmbXQoV19mdXN0ZSwzKSsnIGtOL20gIHgxPScrZm10KHhfZnVzdGUsMykrJ21cbic7CiAgbWVtKz0nICAgIFdfc2FwICAgPSBnYypCKmhzICAgICAgICAgPSAnK2ZtdChnYW1hX2MsMSkrJyonK2ZtdChCLDMpKycqJytmbXQoaHMsMykrJyAgID0gJytmbXQoV19zYXAsMykrJyBrTi9tICB4Mj0nK2ZtdCh4X3NhcCwzKSsnbVxuJzsKICBtZW0rPScgICAgV19zb2xvICA9IGdzKkJjKkhm

ICAgICAgICA9ICcrZm10KGdhbWFfcywxKSsnKicrZm10KEJfY2FsYywzKSsnKicrZm10KEhfZnVzdGUsMykrJyA9ICcrZm10KFdfc29sbywzKSsnIGtOL20gIHgzPScrZm10KHhfc29sbywzKSsnbVxuJzsKICBtZW0rPScgICAgV19wZSAgICA9IGdzKkIxKkhlbSAgICAgICA9ICcrZm10KGdhbWFfcywxKSsnKicrZm10KEIxLDMpKycqJytmbXQoSGVtLDMpKycgICA9ICcrZm10KFdfcGUsMykrJyBrTi9tICB4ND0nK2ZtdCh4X3BlLDMpKydtXG4nOwogIG1lbSs9JyAgICBFYXZfdG90ID0gICAgICAgICAgICAgICAgICAgJytmbXQoRWF2X3RvdCwzKSsnIGtOL20gIHg9JytmbXQoeF9lYXYsMykrJ21cbic7CiAgbWVtKz0nICAgIFNVTV9WICAgPSAgICAgICAgICAg

ICAgICAgICAnK2ZtdChWX3RvdGFsLDMpKycga04vbVxuXG4nOwoKICBtZW0rPSc8aDQ+OC4gVE9NQkFNRU5UTyAocmVmOiBwb250YSBkaWFudGVpcmEpPC9oND4nOwogIG1lbSs9JyAgTW9tZW50b3MgRVNUQUJJTElaQU5URVM6XG4nOwogIG1lbSs9JyAgICBNKFcxKSA9ICcrZm10KFdfZnVzdGUsMykrJyonK2ZtdCh4X2Z1c3RlLDMpKycgPSAnK2ZtdChXX2Z1c3RlKnhfZnVzdGUsMykrJyBrTm0vbVxuJzsKICBtZW0rPScgICAgTShXMikgPSAnK2ZtdChXX3NhcCwzKSsnKicrZm10KHhfc2FwLDMpKycgICA9ICcrZm10KFdfc2FwKnhfc2FwLDMpKycga05tL21cbic7CiAgbWVtKz0nICAgIE0oVzMpID0gJytmbXQoV19zb2xvLDMpKycqJytmbXQoeF9zb2xvLDMp

KycgID0gJytmbXQoV19zb2xvKnhfc29sbywzKSsnIGtObS9tXG4nOwogIG1lbSs9JyAgICBNKFc0KSA9ICcrZm10KFdfcGUsMykrJyonK2ZtdCh4X3BlLDMpKycgICAgPSAnK2ZtdChXX3BlKnhfcGUsMykrJyBrTm0vbVxuJzsKICBtZW0rPScgICAgTShFdikgPSAnK2ZtdChFYXZfdG90LDMpKycqJytmbXQoeF9lYXYsMykrJyAgPSAnK2ZtdChFYXZfdG90KnhfZWF2LDMpKycga05tL21cbic7CiAgbWVtKz0nICAgIFNVTV9NZXN0ID0gJytmbXQoTV9lc3QsMykrJyBrTm0vbVxuXG4nOwogIG1lbSs9JyAgTW9tZW50b3MgVE9NQkFET1JFUzpcbic7CiAgbWVtKz0nICAgIE0oRWFoX3NvbG8pID0gJytmbXQoRWFoX2QsMykrJyonK2ZtdCh5YV9kaXN0LDMpKycgPSAn

K2ZtdChFYWhfZCp5YV9kaXN0LDMpKycga05tL21cbic7CiAgaWYodGlwb19zYyE9PSduZW5odW1hJyYmcV9zb2I+MCkgbWVtKz0nICAgIE0oRWFoX3EpICAgID0gJytmbXQoRWFoX3EsMykrJyonK2ZtdCh5YV9xLDMpKycgICA9ICcrZm10KEVhaF9xKnlhX3EsMykrJyBrTm0vbVxuJzsKICBpZihOd19lZmY+MCkgbWVtKz0nICAgIE0oVSkgICAgICAgID0gJytmbXQoVV9zdWIsMykrJyonK2ZtdChVX3lhLDMpKycgICA9ICcrZm10KFVfc3ViKlVfeWEsMykrJyBrTm0vbVxuJzsKICBtZW0rPScgICAgU1VNX010b21iID0gJytmbXQoTV90b21iLDMpKycga05tL21cblxuJzsKICBtZW0rPScgIENTdG9tYiA9ICcrZm10KE1fZXN0LDMpKycvJytmbXQoTV90b21iLDMp

KycgPSAnK2ZtdChDU190b21iLDMpKycgIFttaW46ICcrQ1NUX01JTi50b0ZpeGVkKDIpKyddICAnKyhDU190b21iPj1DU1RfTUlOPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcblxuJzsKCiAgbWVtKz0nPGg0PjkuIERFU0xJWkFNRU5UTzwvaDQ+JzsKICBtZW0rPScgIGdmX2VtcHV4byA9IDEsNDAgKGFjYW8gdmFyaWF2ZWwgXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzExLjcpXG4nOwogIG1lbSs9JyAgRnJlc2lzdCA9IG11KlNVTV9WICsgYypCID0gJytmbXQobXUsMykrJyonK2ZtdChWX3RvdGFsLDMpKycgKyAnK2ZtdChjb2VzLDEpKycqJytmbXQoQiwzKSsnID0gJytmbXQoRkhfcmVzLDMpKycga04vbVxuJzsKICBtZW0rPScgIEZhdGl2ICAgPSBFYWhf

c29sbyArIEVhaF9xICsgRWFoX2JvICsgVV9zdWIgPSAnK2ZtdChGSF9hdGl2LDMpKycga04vbVxuJzsKICBtZW0rPScgIENTZGVzbCAgPSAnK2ZtdChGSF9yZXMsMykrJy8nK2ZtdChGSF9hdGl2LDMpKycgPSAnK2ZtdChDU19kZXNsLDMpKycgIFttaW46ICcrQ1NEX01JTi50b0ZpeGVkKDIpKyddICAnKyhDU19kZXNsPj1DU0RfTUlOPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBDU2Rlc2wgKGNvbSBFcCkgPSAoJytmbXQoRkhfcmVzLDMpKycrJytmbXQoRXAsMykrJykvJytmbXQoRkhfYXRpdiwzKSsnID0gJytmbXQoQ1NfZGVzbF9FcCwzKSsnICBbaW5mb3JtYXRpdm9dXG5cbic7CgogIG1lbSs9JzxoND4xMC4gQ0FQQUNJREFE

RSBERSBDQVJHQSBFIERJU1RSSUJVSUNBTyBOQSBCQVNFPC9oND4nOwogIG1lbSs9JyAgeFIgPSAoU1VNX01lc3QgLSBTVU1fTXRvbWIpL1NVTV9WID0gKCcrZm10KE1fZXN0LDMpKyctJytmbXQoTV90b21iLDMpKycpLycrZm10KFZfdG90YWwsMykrJyA9ICcrZm10KHhSLDQpKydtXG4nOwogIG1lbSs9JyAgZSAgPSB8Qi8yIC0geFJ8ID0gfCcrZm10KEIvMiwzKSsnIC0gJytmbXQoeFIsNCkrJ3wgPSAnK2ZtdChlX2V4Yyw0KSsnbVxuJzsKICBtZW0rPScgIGVsaW0gPSBCLzYgPSAnK2ZtdChlX21heCw0KSsnbSAgJysob2tfZXhjPydOVUNMRU8gQ0VOVFJBTCBPSyc6J0ZPUkEgRE8gTlVDTEVPJykrJ1xuJzsKICBtZW0rPSIgIEInID0gQiAtIDJlID0gIitmbXQo

Ql9lZmYsNCkrJ20gIChhcmVhIGVmZXRpdmEgcGFyYSBjYXBhY2lkYWRlIGRlIGNhcmdhKVxuXG4nOwogIG1lbSs9JyAgcV9tZWQgPSBTVU1fVi9CICAgICAgICAgICA9ICcrZm10KHFfbWVkLDMpKycga04vbTJcbic7CiAgbWVtKz0nICBxX21heCA9IChTVU1fVi9CKSooMSs2ZS9CKT0gJytmbXQocV9tYXgsMykrJyBrTi9tMicrKHFfbWluPDA/JyAgW1RSQUNBTyBOQSBCQVNFIV0nOicnKSsnXG4nOwogIG1lbSs9JyAgcV9taW4gPSAoU1VNX1YvQikqKDEtNmUvQik9ICcrZm10KHFfbWluLDMpKycga04vbTJcbic7CiAgbWVtKz0nICBzaWdhZG1fdXNvID0gJytmbXQoc2lnYWRtX3VzbywyKSsnIGtOL20yXG4nOwogIG1lbSs9JyAgcV9tYXggPD0gc2lnYWRtPyAn

K2ZtdChxX21heCwyKSsnIDw9ICcrZm10KHNpZ2FkbV91c28sMikrJyAgJysob2tfY2FwPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcblxuJzsKICBtZW0rPScgIFJFQ0FMUVVFIEVTVElNQURPIChOQlIgNjEyMjoyMDIyKTpcbic7CiAgbWVtKz0nICAgIE1ldG9kbzogJysocGhpX2RlZz49MjU/J1NjaG1lcnRtYW5uIChhcmVpYSwgTi1TUFQ9Jytuc3B0KycpJzonQ29lZi4gcmVhY2FvIChhcmdpbGEsIGtzPScra3MrJyBrTi9tMyknKSsnXG4nOwogIG1lbSs9JyAgICBEZWx0YV9xIGxpcS4gPSBxX21heCAtIGdzKkhlbSA9ICcrZm10KERlbHRhX3EsMikrJyBrTi9tMlxuJzsKICBtZW0rPScgICAgUmVjYWxxdWUgZXN0aW1hZG8gcmhvIH4gJytmbXQocmVj

X21tLDEpKycgbW1cbic7CiAgbWVtKz0nICAgIEFWSVNPOiBFc3RpbWF0aXZhIGluZGljYXRpdmEuIEFuYWxpc2UgY29tcGxldGEgb2JyaWdhdG9yaWEgKE5CUiA2MTIyOjIwMjIpLlxuXG4nOwoKICBtZW0rPSc8aDQ+MTEuIEVTVEFCSUxJREFERSBHTE9CQUwgXHUyMDE0IEJJU0hPUCBTSU1QTElGSUNBRE88L2g0Pic7CiAgbWVtKz0nICBBbmFsaXNlIGNvbSA1IGNpcmN1bG9zIGRlIGJ1c2NhIFx1MjAxNCBCaXNob3AgU2ltcGxpZmljYWRvIGNvbSBwYXJhbWV0cm8gcnVcbic7CiAgbWVtKz0nICBydSA9ICcrZm10KHJ1LDMpKycgIChwcmVzc2FvIGRlIHBvcm9zIFx1MjAxNCAwPXNlY28sIDAsMz10aXBpY28sIDAsNT1zYXR1cmFkbylcbic7CiAgbWVtKz0nICBD

U19CaXNob3BfbWluID0gJytmbXQoQ1NfYmlzaG9wLDMpKycgIFttaW46ICcrQ1NSX01JTi50b0ZpeGVkKDIpKyddICAnKyhDU19iaXNob3A+PUNTUl9NSU4/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIE5PVEE6IFBhcmEgcHJvamV0byBleGVjdXRpdm8sIHJlYWxpemFyIGFuYWxpc2UgQmlzaG9wIGNvbXBsZXRhIGNvbSBzb2Z0d2FyZVxuJzsKICBtZW0rPScgIGdlb3RlY25pY28gKFNMT1BFL1csIEdlb1N0dWRpbywgUGxheGlzKSBpbmNsdWluZG8gY2lyY3Vsb3MgcHJvZnVuZG9zIHNvYiBzYXBhdGEuXG5cbic7CgogIGlmKGFnPjApewogICAgbWVtKz0nPGg0PjEyLiBWRVJJRklDQUNBTyBTSVNNSUNBIFx1MjAxNCBNT05PTk9C

RS1PS0FCRSAoTkJSIDE1NDIxKTwvaDQ+JzsKICAgIG1lbSs9JyAgYWcgPSAnK2ZtdChhZywzKSsnZyAga2ggPSBhZyowLDUgPSAnK2ZtdChhZyowLjUsNCkrJ1xuJzsKICAgIG1lbSs9JyAgRGVsdGFQYWUgKE1vbm9ub2JlLU9rYWJlKSB+IDAsMzc1KmtoKmdzKkheMiA9ICcrZm10KDAuMzc1KmFnKjAuNSpnYW1hX3MqSCpILDMpKycga04vbSAgQCAwLDZIXG4nOwogICAgbWVtKz0nICBDU3RvbWIoc2lzbWljbykgPSAnK2ZtdChDU190b21iX3NpcywzKSsnICBbbWluOiAxLDEwXSAgJysoQ1NfdG9tYl9zaXM+PTEuMT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogICAgbWVtKz0nICBDU2Rlc2woc2lzbWljbykgPSAnK2ZtdChDU19kZXNsX3Npcywz

KSsnICBbbWluOiAxLDEwXSAgJysoQ1NfZGVzbF9zaXM+PTEuMT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG5cbic7CiAgfQoKICBtZW0rPSc8aDQ+MTMuIERJTUVOU0lPTkFNRU5UTyBETyBGVVNURSBcdTIwMTQgTkJSIDYxMTg6MjAyMzwvaDQ+JzsKICBtZW0rPScgIFNlY2FvIGNyaXRpY2E6IGJhc2UgZG8gZnVzdGUgKGVuZ2FzdGFtZW50byBuYSBzYXBhdGEpXG5cbic7CiAgbWVtKz0nICBGT1JDQVMgREUgQ0FMQ1VMTyAoZ2Y9JytnZi50b0ZpeGVkKDEpKydwYXJhIGFjYW8gdmFyaWF2ZWwgXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzExLjcpOlxuJzsKICBtZW0rPScgICAgTWRfZnVzdGUgPSBnZiooRWFoX2QqSGYvMyArIEVhaF9xKkhmLzIpID0gJytn

Zi50b0ZpeGVkKDEpKycqKCcrZm10KEVhaF9kLDMpKycqJytmbXQoSF9mdXN0ZS8zLDMpKycrJytmbXQoRWFoX3EsMykrJyonK2ZtdChIX2Z1c3RlLzIsMykrJylcbic7CiAgbWVtKz0nICAgIE1kX2Z1c3RlID0gJytmbXQoTWZfZnVzdGUsMykrJyBrTm0vbVxuJzsKICBtZW0rPScgICAgTmRfZnVzdGUgPSBnZipXX2Z1c3RlID0gJytnZi50b0ZpeGVkKDEpKycqJytmbXQoV19mdXN0ZSwzKSsnID0gJytmbXQoTmRfZnVzdGUsMykrJyBrTi9tICAoY29tcHJlc3Nhbylcbic7CiAgbWVtKz0nICAgIEV4Y2VudHJpY2lkYWRlID0gTWQvTmQgPSAnK2ZtdChlX2ZhdCw0KSsnbVxuJzsKICBtZW0rPScgICAgTk9UQTogRm9yY2Egbm9ybWFsIGFsaXZpYSBhIHRyYWNhbyBc

dTIwMTQgZGltZW5zaW9uYW1lbnRvIHBlbGEgZmxleGFvIHB1cmEgZSBjb25zZXJ2YWRvclxuXG4nOwogIG1lbSs9JyAgRkxFWEFPIChzaW1wbGVzIFx1MjAxNCBjb25zZXJ2YWRvcik6XG4nOwogIG1lbSs9JyAgICBkID0gdGIgLSBjb2IgLSBwaGkvMiA9ICcrZm10KHRfYmFzLDMpKycgLSAnK2ZtdChjb2IsMykrJyAtICcrZm10KGRpYW1fZi8xMDAwLzIsNCkrJyA9ICcrZm10KGRfZnVzdGUsNCkrJ21cbic7CiAgbWVtKz0nICAgIGtNZCA9IE1kLyhiKmReMipmY2QpID0gJytmbXQoTWZfZWYqMTAwMCwxKSsnLygxMDAwKicrZm10KGRfZnVzdGUqMTAwMCwxKSsnXjIqJytmbXQoZmNkLDIpKycpID0gJytmbXQoa01kLDUpKydcbic7CiAgbWVtKz0nICAgIHgvZCA9

ICgxLXNxcnQoMS0yKmtNZCkpLzAsOCA9ICcrZm10KHhkX2YsNCkrJyAgLT4gRG9taW5pbzogJytkb21pbmlvX2YrJ1xuJzsKICBtZW0rPScgICAgQXMscmVxID0gTWQvKDAsODcqZnlkKmQpID0gJytmbXQoTWZfZWYqMWU2LDApKycvKDAsODcqJytmbXQoZnlkLDIpKycqJytmbXQoZF9mdXN0ZSoxMDAwLDEpKycpID0gJytmbXQoQXNfZnVzdGUsMSkrJyBtbTIvbVxuJzsKICBtZW0rPScgICAgQXMsbWluID0gbWF4KDAsMTUlKmIqaCA7IGZjdG0vZnlrKmIqZCkgPSAnK2ZtdChBc19taW5fZiwxKSsnIG1tMi9tICAoTkJSIDYxMTggdGFiLjE3LjMpXG4nOwogIG1lbSs9JyAgICBBcyxhZG90ID0gJytmbXQoQXNfZnVzdGVfZmluLDEpKycgbW0yL20gIC0+ICAnK2Fy

bV9mLnR4dCsnXG5cbic7CiAgbWVtKz0nICBBUk1BRFVSQSBIT1JJWk9OVEFMIChkaXN0cmlidWljYW8gXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzE3LjMuNSk6XG4nOwogIG1lbSs9JyAgICBBcyxkaXN0ciA+PSBtYXgoMjAlKkFzX3ByaW5jIDsgMCwxNSUqYipoKSA9ICcrZm10KEFzX2Rpc3RyLDEpKycgbW0yL21cbic7CiAgbWVtKz0nICAgIEFkb3RhZG86ICcrYXJtX2QudHh0KydcblxuJzsKICBtZW0rPScgIENJU0FMSEFNRU5UTyAoTW9kZWxvIEkgXHUyMDE0IE5CUiA2MTE4IFx1MDBhNzE3LjQpOlxuJzsKICBtZW0rPScgICAgVmQgPSBnZiooRWFoX2QgKyBFYWhfcSArIEVhaF9ibykgPSAnK2dmLnRvRml4ZWQoMSkrJyonK2ZtdChFYWhfZCtFYWhfcStFYWhf

Ym8sMykrJyA9ICcrZm10KFZkX2YsMykrJyBrTi9tXG4nOwogIG1lbSs9JyAgICBWUmQxID0gKDAsMjcvZ2MpKmZja14oMS8zKSpkKmIgPSAnK2ZtdChWUmQxX2YsMykrJyBrTi9tXG4nOwogIG1lbSs9JyAgICAnK2ZtdChWZF9mLDMpKycgPD0gJytmbXQoVlJkMV9mLDMpKyc/ICAnKyhva19jaXNfZj8nU0lNIFx1MjAxNCBzZW0gYXJtYWR1cmEgdHJhbnN2ZXJzYWwnOidOQU8gXHUyMDE0IEVTVFJJQk9TIE9CUklHQVRPUklPUycpKydcbic7CiAgaWYoIW9rX2Npc19mKXsKICAgIG1lbSs9JyAgICBBcyxlc3RyaWJvcyA9IHJob19zd19taW4qYncgPSAnK2ZtdChBc19lc3RyaWJvcywxKSsnIG1tMi9tICAocmFtb3MgZHVwbG9zKVxuJzsKICAgIG1lbSs9JyAgICBz

X21heCA9IDAsNipkID0gJytmbXQoc19lc3RyaWJvcywwKSsnIG1tICAoTkJSIDYxMTggXHUwMGE3MTcuNC4xLjMpXG4nOwogIH0KICBtZW0rPSdcbic7CiAgbWVtKz0nICBFU0JFTFRFWiAoTkJSIDYxMTggXHUwMGE3MTUpOlxuJzsKICBtZW0rPScgICAgbGUgPSAyKkhmID0gJytmbXQobGVfZiwzKSsnbSAgKGJhbGFuY28gY29tIGVuZ2FzdGFtZW50bylcbic7CiAgbWVtKz0nICAgIGkgID0gdG1lZC9zcXJ0KDEyKSA9ICcrZm10KGlfZiw0KSsnbVxuJzsKICBtZW0rPScgICAgbGFtYmRhID0gbGUvaSA9ICcrZm10KGxhbWIsMSkrKGxhbWI+MzU/JyAgPiAzNSBcdTIwMTQgMmEgb3JkZW0gT0JSSUdBVE9SSUEgKFx1MDBhNzE1LjgpJzonICA8PSAzNSBcdTIwMTQg

ZGlzcGVuc2FkbycpKydcblxuJzsKICBtZW0rPScgIEFOQ09SQUdFTSAoTkJSIDYxMTggXHUwMGE3OS4zKTpcbic7CiAgbWVtKz0nICAgIGZiZCA9IDIsMjUqZXRhMSpldGEyKmZjdGQgPSAyLDI1KjEsMCoxLDAqJytmbXQoZmN0ZCwzKSsnID0gJytmbXQoZmJkLDMpKycgTVBhXG4nOwogIG1lbSs9JyAgICBsYixiYXMgPSAocGhpLzQpKihmeWQvZmJkKSA9ICgnK2ZtdChkaWFtX2YsMSkrJy80KSooJytmbXQoZnlkLDIpKycvJytmbXQoZmJkLDMpKycpID0gJytmbXQobGJfYmFzLDEpKycgbW1cbic7CiAgbWVtKz0nICAgIGxiLG5lYyA+PSAnK2ZtdChsYl9mLDEpKycgbW0gPSAnK2ZtdChsYl9mLzEwMDAsMykrJ20gKGFuY29yYWdlbSBuYSBzYXBhdGEpXG5cbic7

CgogIG1lbSs9JzxoND4xNC4gRElNRU5TSU9OQU1FTlRPIERBIFNBUEFUQTwvaDQ+JzsKICBtZW0rPScgIGRfc2FwID0gaHMgLSBjb2IgLSBwaGkvMiA9ICcrZm10KGhzLDMpKycgLSAnK2ZtdChjb2IsMykrJyAtICcrZm10KGRpYW1fcy8xMDAwLzIsNCkrJyA9ICcrZm10KGRfc2FwLDQpKydtXG5cbic7CiAgbWVtKz0nICAoYSkgQ0FMQ0FOSEFSIFx1MjAxNCBNb21lbnRvIGZsZXRvciAoYXRlcnJvIHNvYnJlIGNhbGNhbmhhcik6XG4nOwogIG1lbSs9JyAgICBxX3NvbG8gPSBncypIZiA9ICcrZm10KGdhbWFfcywxKSsnKicrZm10KEhfZnVzdGUsMykrJyA9ICcrZm10KHFfY2FsY19zYXAsMykrJyBrTi9tMlxuJzsKICBtZW0rPScgICAgTWQsY2FsYyA9IGdmKnFf

c29sbypCY14yLzIgPSAnK2dmLnRvRml4ZWQoMSkrJyonK2ZtdChxX2NhbGNfc2FwLDMpKycqJytmbXQoQl9jYWxjLDMpKydeMi8yID0gJytmbXQoTWZfc2FwX2MsMykrJyBrTm0vbVxuJzsKICBtZW0rPScgICAgQXMscmVxID0gJytmbXQoQXNfc2FwX2MsMSkrJyBtbTIvbSAgIEFzLG1pbiA9ICcrZm10KEFzX21pbl9zYywxKSsnIG1tMi9tXG4nOwogIG1lbSs9JyAgICBBcyxhZG90ID0gJytmbXQoQXNfc2FwX2NfZmluLDEpKycgbW0yL20gIC0+ICAnK2FybV9zYy50eHQrJyAoZmFjZSBpbmZlcmlvcilcbic7CiAgbWVtKz0nICAgIGxiLG5lYyA9ICcrZm10KGxiX3NjLDEpKycgbW0gPSAnK2ZtdChsYl9zYy8xMDAwLDMpKydtXG5cbic7CiAgbWVtKz0nICAoYSkg

Q0FMQ0FOSEFSIFx1MjAxNCBDaXNhbGhhbWVudG8gKE5CUiA2MTE4IFx1MDBhNzE5IFx1MjAxNCBjb3J0YW50ZSB1bmlkaXJlY2lvbmFsKTpcbic7CiAgbWVtKz0nICAgIFZkID0gZ2YqcV9zb2xvKkJjID0gJytnZi50b0ZpeGVkKDEpKycqJytmbXQocV9jYWxjX3NhcCwzKSsnKicrZm10KEJfY2FsYywzKSsnID0gJytmbXQoVmRfY2FsYywzKSsnIGtOL21cbic7CiAgbWVtKz0nICAgIFZSZDEgPSAnK2ZtdChWUmQxX2NhbGMsMykrJyBrTi9tXG4nOwogIG1lbSs9JyAgICAnK2ZtdChWZF9jYWxjLDMpKycgPD0gJytmbXQoVlJkMV9jYWxjLDMpKyc/ICAnKyhva19jaXNfY2FsYz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EgXHUyMDE0IGF1bWVudGFyIGhzJykrJ1xu

XG4nOwogIG1lbSs9JyAgKGIpIFBFIERJQU5URUlSTyBcdTIwMTQgTW9tZW50byBmbGV0b3IgKHJlYWNhbyBkbyBzb2xvKTpcbic7CiAgbWVtKz0nICAgIHFfcGVfbWVkID0gKHFtYXggKyBtYXgocW1pbiwwKSkvMiA9ICcrZm10KHFfcGVfbWVkLDMpKycga04vbTJcbic7CiAgbWVtKz0nICAgIHFfcGVfbGlxID0gcV9wZV9tZWQgLSBnZipnYypocyA9ICcrZm10KHFfcGVfbWVkLDMpKycgLSAnK2dmLnRvRml4ZWQoMSkrJyonK2ZtdChnYW1hX2MsMSkrJyonK2ZtdChocywzKSsnID0gJytmbXQocV9wZV9saXEsMykrJyBrTi9tMlxuJzsKICBtZW0rPScgICAgTWQscGUgPSBnZipxX3BlX2xpcSpCMV4yLzIgPSAnK2dmLnRvRml4ZWQoMSkrJyonK2ZtdChxX3BlX2xp

cSwzKSsnKicrZm10KEIxLDMpKydeMi8yID0gJytmbXQoTWZfc2FwX3AsMykrJyBrTm0vbVxuJzsKICBtZW0rPScgICAgQXMsYWRvdCA9ICcrZm10KEFzX3NhcF9wX2ZpbiwxKSsnIG1tMi9tICAtPiAgJythcm1fc3AudHh0KycgKGZhY2Ugc3VwZXJpb3IsIHBlKVxuXG4nOwogIG1lbSs9JyAgKGIpIFBFIERJQU5URUlSTyBcdTIwMTQgQ2lzYWxoYW1lbnRvOlxuJzsKICBtZW0rPScgICAgVmQgPSBnZipxX3BlX2xpcSpCMSA9ICcrZ2YudG9GaXhlZCgxKSsnKicrZm10KHFfcGVfbGlxLDMpKycqJytmbXQoQjEsMykrJyA9ICcrZm10KFZkX3BlLDMpKycga04vbVxuJzsKICBtZW0rPScgICAgVlJkMSA9ICcrZm10KFZSZDFfY2FsYywzKSsnIGtOL21cbic7CiAgbWVt

Kz0nICAgICcrZm10KFZkX3BlLDMpKycgPD0gJytmbXQoVlJkMV9jYWxjLDMpKyc/ICAnKyhva19jaXNfcGU/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBIFx1MjAxNCBhdW1lbnRhciBocycpKydcblxuJzsKICBtZW0rPScgIChjKSBBUk1BRFVSQSBUUkFOU1ZFUlNBTCAoZGlzdHJpYnVpY2FvKTpcbic7CiAgbWVtKz0nICAgIEFzLHRyYW5zID49IDIwJSpBcyxjYWxjYW5oYXIgPSAnK2ZtdCgwLjIqQXNfc2FwX2NfZmluLDEpKycgbW0yL20gKGVtIGNhZGEgZGlyZWNhbylcblxuJzsKCiAgbWVtKz0nPGg0PjE1LiBRVUFEUk8gREUgQVJNQURVUkFTPC9oND4nOwogIG1lbSs9JyAgRlVTVEU6XG4nOwogIG1lbSs9JyAgICBQcmluY2lwYWwgKHZlcnRpY2FsLCBmYWNl

IGF0ZXJybykgOiAnK2FybV9mLnR4dCsnIChBcz0nK2ZtdChhcm1fZi5hcmVhLDEpKycgbW0yL20pXG4nOwogIG1lbSs9JyAgICBEaXN0cmlidWljYW8gKGhvcml6b250YWwpICAgICAgICAgIDogJythcm1fZC50eHQrJyAgKE5CUiA2MTE4IFx1MDBhNzE3LjMuNSlcbic7CiAgaWYoIW9rX2Npc19mKSBtZW0rPScgICAgRXN0cmlib3MgKHRyYW5zdmVyc2FsKSAgICAgICAgICAgICA6IHBoaTZjLycrZm10KHNfZXN0cmlib3MsMCkrJ21tIG91ICcrZm10KEFzX2VzdHJpYm9zLDEpKycgbW0yL21cbic7CiAgZWxzZSBtZW0rPScgICAgRXN0cmlib3MgICAgICAgICAgICAgICAgICAgICAgICAgICA6IG5hbyBuZWNlc3NhcmlvcyAoVmQ8PVZSZDEpXG4nOwogIG1lbSs9

JyAgICBBbmNvcmFnZW0gbmEgc2FwYXRhICAgICAgICAgICAgICAgIDogbGIgPj0gJytmbXQobGJfZiwxKSsnIG1tID0gJytmbXQobGJfZi8xMDAwLDMpKydtXG5cbic7CiAgbWVtKz0nICBTQVBBVEE6XG4nOwogIG1lbSs9JyAgICBDYWxjYW5oYXIgKGluZmVyaW9yLCBsb25naXR1ZGluYWwpIDogJythcm1fc2MudHh0KycgKEFzPScrZm10KEFzX3NhcF9jX2ZpbiwxKSsnIG1tMi9tKVxuJzsKICBtZW0rPScgICAgQ2FsY2FuaGFyIGFuY29yYWdlbSBubyBmdXN0ZSAgICAgICA6IGxiID49ICcrZm10KGxiX3NjLDEpKycgbW1cbic7CiAgbWVtKz0nICAgIFBlIGRpYW50ZWlybyAoc3VwZXJpb3IsIGxvbmdpdC4pICAgOiAnK2FybV9zcC50eHQrJyAoQXM9JytmbXQo

QXNfc2FwX3BfZmluLDEpKycgbW0yL20pXG4nOwogIG1lbSs9JyAgICBUcmFuc3ZlcnNhbCAoZGlzdHJpYnVpY2FvKSAgICAgICAgIDogQXMgPj0gJytmbXQoMC4yKkFzX3NhcF9jX2ZpbiwxKSsnIG1tMi9tXG5cbic7CgogIG1lbSs9JzxoND4xNi4gUkVTVU1PIERBUyBWRVJJRklDQUNPRVM8L2g0Pic7CiAgbWVtKz0nICBUb21iYW1lbnRvICAgICAgICAgIDogJytmbXQoQ1NfdG9tYiwzKSsnID49ICcrQ1NUX01JTi50b0ZpeGVkKDIpKycgICcrKENTX3RvbWI+PUNTVF9NSU4/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIERlc2xpemFtZW50byAgICAgICAgOiAnK2ZtdChDU19kZXNsLDMpKycgPj0gJytDU0RfTUlOLnRvRml4ZWQo

MikrJyAgJysoQ1NfZGVzbD49Q1NEX01JTj8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgQ2FwLiBjYXJnYSAgICAgICAgICA6IHFfbWF4PScrZm10KHFfbWF4LDIpKycgPD0gc2lnYWRtPScrZm10KHNpZ2FkbV91c28sMikrJyAgJysob2tfY2FwPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBFeGNlbnRyaWNpZGFkZSAgICAgIDogZT0nK2ZtdChlX2V4Yyw0KSsnbSA8PSBCLzY9JytmbXQoZV9tYXgsNCkrJ20gICcrKG9rX2V4Yz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgRW1idXRpbWVudG8gICAgICAgICA6IEhlbT0nK2ZtdChIZW0sMikrJ20gPj0gJytmbXQoSGVt

X21pbiwyKSsnbSAgJysoSGVtPj1IZW1fbWluPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBSdXB0dXJhIGNpcmN1bGFyICAgIDogQ1M9JytmbXQoQ1NfYmlzaG9wLDMpKycgPj0gJytDU1JfTUlOLnRvRml4ZWQoMikrJyAgJysoQ1NfYmlzaG9wPj1DU1JfTUlOPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBGdXN0ZSBcdTIwMTQgeC9kICAgICAgICAgOiAnK2ZtdCh4ZF9mLDQpKycgPD0gMCw0NSAgJysoeGRfZjw9MC40NT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgRnVzdGUgXHUyMDE0IGNvcnRhbnRlICAgIDogVmQ9JytmbXQoVmRfZiwyKSsnIDw9IFZSZDE9Jytm

bXQoVlJkMV9mLDIpKycga04vbSAgJysob2tfY2lzX2Y/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENhbGNhbmhhciBcdTIwMTQgY29ydGFudGU6IFZkPScrZm10KFZkX2NhbGMsMikrJyA8PSBWUmQxPScrZm10KFZSZDFfY2FsYywyKSsnIGtOL20gICcrKG9rX2Npc19jYWxjPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBQZSBkaWFudC4gXHUyMDE0IGNvcnRhbnRlOiBWZD0nK2ZtdChWZF9wZSwyKSsnIDw9IFZSZDE9JytmbXQoVlJkMV9jYWxjLDIpKycga04vbSAgJysob2tfY2lzX3BlPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgaWYoYWc+MCl7CiAgICBtZW0rPScgIFRvbWJh

bWVudG8gc2lzbWljbyAgOiAnK2ZtdChDU190b21iX3NpcywzKSsnID49IDEsMTAgICcrKENTX3RvbWJfc2lzPj0xLjE/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICAgIG1lbSs9JyAgRGVzbGl6LiBzaXNtaWNvICAgICA6ICcrZm10KENTX2Rlc2xfc2lzLDMpKycgPj0gMSwxMCAgJysoQ1NfZGVzbF9zaXM+PTEuMT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIH0KICBtZW0rPSdcbic7CiAgaWYoYWxlcnRhcy5sZW5ndGg+MCl7CiAgICBtZW0rPSc8aDQ+MTcuIEFMRVJUQVMgRSBOQU8tQ09ORk9STUlEQURFUzwvaDQ+JzsKICAgIGFsZXJ0YXMuZm9yRWFjaChmdW5jdGlvbihhKXttZW0rPScgIFshXSAnK2ErJ1xuJzt9KTsKICAg

IG1lbSs9J1xuJzsKICB9CiAgbWVtKz0nJytTRVArJ1xuJzsKICBtZW0rPSdOb3JtYXM6IE5CUiA2MTE4OjIwMjMgfCBOQlIgNjEyMDoyMDE5IHwgTkJSIDExNjgyOjIwMDkgfCBOQlIgNjEyMjoyMDIyXG4nOwogIG1lbSs9J0VzdGUgbWVtb3JpYWwgZGV2ZSBzZXIgdmVyaWZpY2FkbyBlIGFzc2luYWRvIHBlbG8gZW5nZW5oZWlybyByZXNwb25zYXZlbC5cbic7CiAgbWVtKz0nJytTRVArJ1xuJzsKCiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ21lbW9yaWFsJykuaW5uZXJIVE1MPW1lbTsKICB2YXIgX2FyPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhbGVydGFzX3JlcycpO2lmKF9hcil7X2FyLmlubmVySFRNTD1hbGVydGFzLmxlbmd0aD9hbGVydGFzLm1h

cChmdW5jdGlvbihhKXtyZXR1cm4gJzxkaXYgY2xhc3M9ImFsZXJ0YSI+WyFdICcrYSsnPC9kaXY+Jzt9KS5qb2luKCcnKTonPGRpdiBzdHlsZT0iYmFja2dyb3VuZDp2YXIoLS1vayk7Y29sb3I6dmFyKC0tb2tiKTtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4OyI+U2VtIGFsZXJ0YXMgaWRlbnRpZmljYWRvcy48L2Rpdj4nO30KICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0YWRvJykuc3R5bGUuZGlzcGxheT0nYmxvY2snOwogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRhZG8nKS5zY3JvbGxJbnRvVmlldyh7YmVoYXZpb3I6J3Ntb290aCd9KTsKfQoKd2luZG93Lm9ubG9hZD1mdW5jdGlvbigp

ewogIHZhciB0b2RheT1uZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7CiAgdmFyIGRjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkYXRhX2NhbGMnKTsKICBpZihkYyYmIWRjLnZhbHVlKSBkYy52YWx1ZT10b2RheTsKICBhdHVhbGl6YXJDb2IoKTsKfTsKPC9zY3JpcHQ+Cg==

PHN0eWxlPjpyb290ey0tYXo6IzFkMzE1NTstLWF6bTojMmU0ZjhhOy0tYXpjOiM0YTdjYzc7LS1kb3I6I2JmOTAwMDstLWRvcmM6I2UwYWEwMDstLWJnOiNmMGYyZjY7LS1iZ3c6I2ZmZjstLWJyZDojYzhkMGUwOy0tdHh0OiMxYTFhMmU7LS10eHRtOiM0YTRhNmE7LS1vazojZDRlZGRhOy0tb2tiOiMxYTdhM2E7LS13YXJuOiNmZmYzY2Q7LS13YXJuYjojODU2NDA0Oy0tZXJyOiNmOGQ3ZGE7LS1lcnJiOiM4NDIwMjk7fSp7Ym94LXNpemluZzpib3JkZXItYm94O21hcmdpbjowO3BhZGRpbmc6MDt9Ym9keXtmb250LWZhbWlseTonSUJNIFBsZXggU2Fucycsc2Fucy1zZXJpZjtiYWNrZ3JvdW5kOnZhcigtLWJnKTtjb2xvcjp2YXIoLS10eHQpO30ud3JhcHttYXgt

d2lkdGg6MTAwMHB4O21hcmdpbjowIGF1dG87cGFkZGluZzoyMHB4IDE2cHg7fS5zZWN7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO2JvcmRlcjoxLjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6OHB4O3BhZGRpbmc6MjBweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zZWMgaDN7Zm9udC1zaXplOjExcHg7Zm9udC13ZWlnaHQ6NzAwO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouN3B4O2NvbG9yOnZhcigtLWF6KTttYXJnaW4tYm90dG9tOjE0cHg7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4O30uc2VjIGgzOjphZnRlcntjb250ZW50OicnO2ZsZXg6MTtoZWlnaHQ6MXB4O2JhY2tncm91bmQ6dmFyKC0t

YnJkKTt9Lmcye2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjtnYXA6MTBweDt9Lmcze2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmciAxZnI7Z2FwOjEwcHg7fS5nNHtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOjFmciAxZnIgMWZyIDFmcjtnYXA6MTBweDt9LmZsZHtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDozcHg7fS5mbGQgbGFiZWx7Zm9udC1zaXplOjEwcHg7Zm9udC13ZWlnaHQ6NjAwO2NvbG9yOnZhcigtLXR4dG0pO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouNXB4O30uZmxkIGlucHV0LC5mbGQgc2VsZWN0e2JvcmRlcjox

LjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6NHB4O3BhZGRpbmc6N3B4IDlweDtmb250LXNpemU6MTJweDtmb250LWZhbWlseTppbmhlcml0O2NvbG9yOnZhcigtLXR4dCk7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO30uZmxkIC51bntmb250LXNpemU6OXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi10b3A6MXB4O30ubm90YXtiYWNrZ3JvdW5kOiNlOGYwZmU7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkIHZhcigtLWF6Yyk7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5ub3RhLXd7YmFja2dyb3VuZDojZmZmM2NkO2JvcmRlci1s

ZWZ0OjNweCBzb2xpZCB2YXIoLS1kb3JjKTtwYWRkaW5nOjdweCAxMXB4O2ZvbnQtc2l6ZToxMHB4O2JvcmRlci1yYWRpdXM6MCA0cHggNHB4IDA7bWFyZ2luLWJvdHRvbToxMHB4O2xpbmUtaGVpZ2h0OjEuNjt9Lm5vdGEtcntiYWNrZ3JvdW5kOiNmOGQ3ZGE7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkICNkYzM1NDU7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5idG4tY2FsY3tiYWNrZ3JvdW5kOnZhcigtLWF6KTtjb2xvcjojZmZmO2JvcmRlcjpub25lO2JvcmRlci1yYWRpdXM6NnB4O3BhZGRpbmc6MTNweCAyOHB4O2ZvbnQtc2l6ZToxM3B4

O2ZvbnQtd2VpZ2h0OjcwMDtjdXJzb3I6cG9pbnRlcjt3aWR0aDoxMDAlO21hcmdpbi10b3A6NnB4O30uYnRuLXBkZntiYWNrZ3JvdW5kOnZhcigtLWRvcmMpO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzo5cHggMjJweDtmb250LXNpemU6MTJweDtmb250LXdlaWdodDo3MDA7Y3Vyc29yOnBvaW50ZXI7bWFyZ2luLXRvcDoxMHB4O30jcmVzdWx0YWRve2Rpc3BsYXk6bm9uZTttYXJnaW4tdG9wOjE2cHg7fS5zZW17ZGlzcGxheTpncmlkO2dyaWQtdGVtcGxhdGUtY29sdW1uczpyZXBlYXQoOCwxZnIpO2dhcDo2cHg7bWFyZ2luLWJvdHRvbToxNHB4O30uc2VtMntkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5z

OnJlcGVhdCg0LDFmcik7Z2FwOjZweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zaXRlbXtib3JkZXItcmFkaXVzOjdweDtwYWRkaW5nOjlweCA1cHg7dGV4dC1hbGlnbjpjZW50ZXI7fS5zbGJse2ZvbnQtc2l6ZTo3LjVweDtmb250LXdlaWdodDo3MDA7dGV4dC10cmFuc2Zvcm06dXBwZXJjYXNlO2xldHRlci1zcGFjaW5nOi4zcHg7bWFyZ2luLWJvdHRvbTo0cHg7bGluZS1oZWlnaHQ6MS4zO30uc3ZhbHtmb250LXNpemU6MTRweDtmb250LXdlaWdodDo3MDA7Zm9udC1mYW1pbHk6J0lCTSBQbGV4IE1vbm8nLG1vbm9zcGFjZTt9LnNyZXF7Zm9udC1zaXplOjdweDttYXJnaW4tdG9wOjJweDtvcGFjaXR5Oi44O30ub2stc3tiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xv

cjp2YXIoLS1va2IpO30ud2Fybi1ze2JhY2tncm91bmQ6dmFyKC0td2Fybik7Y29sb3I6dmFyKC0td2FybmIpO30uZXJyLXN7YmFja2dyb3VuZDp2YXIoLS1lcnIpO2NvbG9yOnZhcigtLWVycmIpO30ubWVte2JhY2tncm91bmQ6I2Y4ZjlmYztib3JkZXI6MXB4IHNvbGlkIHZhcigtLWJyZCk7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxOHB4O2ZvbnQtc2l6ZToxMXB4O2xpbmUtaGVpZ2h0OjEuOTtmb250LWZhbWlseTonSUJNIFBsZXggTW9ubycsbW9ub3NwYWNlO3doaXRlLXNwYWNlOnByZS13cmFwO2NvbG9yOnZhcigtLXR4dCk7bWFyZ2luLXRvcDoxMnB4O30ubWVtIGg0e2ZvbnQtZmFtaWx5OidJQk0gUGxleCBTYW5zJyxzYW5zLXNlcmlmO2ZvbnQtc2l6

ZToxMXB4O2ZvbnQtd2VpZ2h0OjcwMDtjb2xvcjp2YXIoLS1heik7bWFyZ2luOjE0cHggMCA0cHg7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgdmFyKC0tYnJkKTtwYWRkaW5nLWJvdHRvbToycHg7fS5hbGVydGF7YmFja2dyb3VuZDojZjhkN2RhO2JvcmRlcjoxcHggc29saWQgI2Y1YzZjYjtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4O2NvbG9yOiM4NDIwMjk7bWFyZ2luOjRweCAwO30uc3Vie2ZvbnQtc2l6ZToxMXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi1ib3R0b206MTRweDt9QG1lZGlhKG1heC13aWR0aDo3MDBweCl7LmczLC5nNHtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjt9LnNlbXtncmlkLXRl

bXBsYXRlLWNvbHVtbnM6cmVwZWF0KDQsMWZyKTt9LnNlbTJ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOnJlcGVhdCgyLDFmcik7fX1AbWVkaWEgcHJpbnR7LmJ0bi1jYWxjLC5idG4tcGRmLC5zZWM6bm90KCNzZWMtcmVzKXtkaXNwbGF5Om5vbmUhaW1wb3J0YW50O30jcmVzdWx0YWRve2Rpc3BsYXk6YmxvY2shaW1wb3J0YW50O31ib2R5e2JhY2tncm91bmQ6I2ZmZjt9Lm1lbXtib3JkZXI6bm9uZTtwYWRkaW5nOjA7Zm9udC1zaXplOjEwcHg7fX08L3N0eWxlPgoKPGRpdiBjbGFzcz0id3JhcCI+CjxoMj5NdXJvIGRlIEFycmltbyAmIzgyMTI7IEImIzIzMzt0b24gQXJtJiMyMzM7IC8gQ29uY3JldG8gQXJtYWRvPC9oMj4KPHAgY2xhc3M9InN1YiI+RU4gMTk5Ny0x

OjIwMDQrQTE6MjAxMyAmIzE4MzsgRU4gMTk5Mi0xLTE6MjAwNCAmIzE4MzsgRU4gMTk5MDoyMDAyICYjMTgzOyBFTiAxOTk4LTU6MjAwNCB8IERBMSDigJQgQzErQzI8L3A+CjxkaXYgY2xhc3M9Im5vdGEiPiYjOTg4ODsmIzY1MDM5OyA8c3Ryb25nPlVzZSBieSBsaWNlbnNlZCBlbmdpbmVlcnMgb25seS48L3N0cm9uZz4gUmVzdWx0cyBtdXN0IGJlIHZlcmlmaWVkIGFuZCBzZWFsZWQgYnkgdGhlIGVuZ2luZWVyIG9mIHJlY29yZC48L2Rpdj4KCjxkaXYgY2xhc3M9InNlYyI+PGgzPiYjMTI4MTkzOyBJZGVudGlmaWNhdGlvbjwvaDM+PGRpdiBjbGFzcz0iZzMiPgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlByb2plY3QgLyBPYnJhPC9sYWJlbD48aW5wdXQg

dHlwZT0idGV4dCIgaWQ9Im9icmEiIHBsYWNlaG9sZGVyPSJQcm9qZWN0IG5hbWUgLyBsb2NhdGlvbiI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RW5naW5lZXIgLyBFbmdlbmhlaXJvPC9sYWJlbD48aW5wdXQgdHlwZT0idGV4dCIgaWQ9InJlc3AiIHBsYWNlaG9sZGVyPSJFbmcuIE5hbWUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkxpY2Vuc2UgLyBSZWcuIFByb2Zpc3Npb25hbDwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJjcmVhIiBwbGFjZWhvbGRlcj0iTGljZW5zZSBOby4gLyBDUkVBIC8gSW5nZW5pZXVyLU5yLiI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RGF0ZTwvbGFiZWw+PGlucHV0IHR5

cGU9ImRhdGUiIGlkPSJkYXRhX2NhbGMiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlJldi48L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0icmV2IiB2YWx1ZT0iUjAwIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5HZW90ZWNoIFJlcG9ydDwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJsYXVkbyIgcGxhY2Vob2xkZXI9IlJlcG9ydCBOby4iPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkFSVCAvIFJSVCAvIFN0YW1wIE5vLjwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJhcnQiIHBsYWNlaG9sZGVyPSJBUlQgLyBSUlQgLyBJbmcuS2FtbWVyLU5yLiI+PC9kaXY+CjwvZGl2PjwvZGl2PgoKPGRp

diBjbGFzcz0ic2VjIj48aDM+JiMxMjgyMDg7IEdlb21ldHJ5PC9oMz48ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+SCB0b3RhbCAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJIIiB2YWx1ZT0iMy4wIiBzdGVwPSIwLjA1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5FbWJlZG1lbnQgSGVtIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkhlbSIgdmFsdWU9IjAuNSIgc3RlcD0iMC4wNSI+PHNwYW4gY2xhc3M9InVuIj5taW46IG1heChILzEwOzAsNTBtKTwvc3Bhbj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5TdGVtIHRvcCB0dCAobSk8L2xhYmVsPjxpbnB1dCB0

eXBlPSJudW1iZXIiIGlkPSJ0X3RvcG8iIHZhbHVlPSIwLjIwIiBzdGVwPSIwLjAxIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5TdGVtIGJhc2UgdGIgKG0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0idF9iYXNlIiB2YWx1ZT0iMC4zMCIgc3RlcD0iMC4wMSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Rm9vdGluZyB3aWR0aCBCIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkIiIHZhbHVlPSIyLjEwIiBzdGVwPSIwLjA1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Ub2UgQjEgKG0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iQjEiIHZhbHVlPSIwLjQwIiBzdGVw

PSIwLjA1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Gb290aW5nIGRlcHRoIGhzIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImhzIiB2YWx1ZT0iMC4zNSIgc3RlcD0iMC4wNSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+QmFja2ZpbGwgc2xvcGUgJiM5NDY7ICjCsCk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJiZXRhIiB2YWx1ZT0iMCIgc3RlcD0iMSIgbWluPSIwIiBtYXg9IjMwIj48L2Rpdj4KPC9kaXY+PC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzExMDE1OyYjNjUwMzk7IExvYWRzPC9oMz48ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+U3VyY2hh

cmdlIHR5cGU8L2xhYmVsPjxzZWxlY3QgaWQ9InRpcG9fc2MiPgogICAgPG9wdGlvbiB2YWx1ZT0idW5pZm9ybWUiPlVuaWZvcm0gZGlzdC48L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9ImNvbmNlbnRyYWRhIj5Qb2ludCBsb2FkIChCb3Vzc2luZXNxKTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0ibmVuaHVtYSI+Tm9uZTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPnEgKGtOL20mIzE3ODspPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icSIgdmFsdWU9IjEwIiBzdGVwPSIxIiBtaW49IjAiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTY4OyYjODMyMDsgY29tYmluYXRp

b24gZmFjdG9yPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icHNpMCIgdmFsdWU9IjAuNyIgc3RlcD0iMC4wNSIgbWluPSIwIiBtYXg9IjEuMCI+PHNwYW4gY2xhc3M9InVuIj5FTiAxOTkwIEExOiB0cmFmZmljPTAsNjsgc3RvcmFnZT0xLDA8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+UCBwb2ludCBsb2FkIChrTi9tKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IlBfY29uYyIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCI+PHNwYW4gY2xhc3M9InVuIj5Cb3Vzc2luZXNxPC9zcGFuPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkRpc3RhbmNlIGQgKG0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVt

YmVyIiBpZD0iZGlzdF9zYyIgdmFsdWU9IjAiIHN0ZXA9IjAuMSIgbWluPSIwIj48L2Rpdj4KPC9kaXY+PC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzEyNzc1NzsgR2VvdGVjaG5pY2FsIFBhcmFtZXRlcnM8L2gzPjxkaXYgY2xhc3M9Imc0Ij4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5TVUNTPC9sYWJlbD48c2VsZWN0IGlkPSJzdWNzIj48b3B0aW9uIHZhbHVlPSJTVyI+U1c8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJTUCI+U1A8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJTTSIgc2VsZWN0ZWQ+U008L29wdGlvbj48b3B0aW9uIHZhbHVlPSJDTCI+Q0w8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJDSCI+Q0g8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4K

ICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5OLVNQVDwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9Im5zcHQiIHZhbHVlPSIxNSIgc3RlcD0iMSIgbWluPSIxIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD4mIzk0NztrIChrTi9tJiMxNzk7KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImdhbWFfcyIgdmFsdWU9IjE4IiBzdGVwPSIwLjUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTY2O2sgKMKwKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InBoaSIgdmFsdWU9IjMwIiBzdGVwPSIxIiBtaW49IjEwIiBtYXg9IjQ1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5jayAoa04v

bSYjMTc4Oyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJjb2VzIiB2YWx1ZT0iMCIgc3RlcD0iMSIgbWluPSIwIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD4mIzk0ODsvJiM5NjY7IHJhdGlvPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZGVsdGFfciIgdmFsdWU9IjAuNjY3IiBzdGVwPSIwLjA1IiBtaW49IjAuNSIgbWF4PSIxLjAiPjxzcGFuIGNsYXNzPSJ1biI+d2FsbC1zb2lsIGZyaWN0aW9uPC9zcGFuPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk53IChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9Ik53IiB2YWx1ZT0iMCIgc3RlcD0iMC4xIiBtaW49IjAiPjwvZGl2PgogIDxkaXYg

Y2xhc3M9ImZsZCI+PGxhYmVsPkRyYWluYWdlPC9sYWJlbD48c2VsZWN0IGlkPSJkcmVuIj4KICAgIDxvcHRpb24gdmFsdWU9Im9rIj5GaWx0ZXIgZHJhaW4gKE53PTApPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSJiYXJiYWNhcyI+V2VlcCBob2xlcyAoNTAlIE53KTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0ic2VtIj5ObyBkcmFpbiAoZnVsbCBOdyk8L29wdGlvbj4KICA8L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5ydSAocG9yZSBwcmVzc3VyZSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJydSIgdmFsdWU9IjAiIHN0ZXA9IjAuMDUiIG1pbj0iMCIgbWF4PSIwLjUiPjxzcGFuIGNsYXNzPSJ1biI+Qmlz

aG9wOiAwPWRyeTsgMC4zPXR5cGljYWw8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+UmxpbSAoa04vbSYjMTc4Oyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJSbGltIiB2YWx1ZT0iMTUwIiBzdGVwPSIxMCI+PHNwYW4gY2xhc3M9InVuIj5pZiBkaXJlY3QgaW5wdXQ8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+UmxpbSBzb3VyY2U8L2xhYmVsPjxzZWxlY3QgaWQ9Im9yaWdfcSI+CiAgICA8b3B0aW9uIHZhbHVlPSJjYWxjdWxvIj5UZXJ6YWdoaSAoY2FsYy4pPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSJkaXJldG8iPkRpcmVjdCBpbnB1dDwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2Pgog

IDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPmtzIChrTi9tJiMxNzk7KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImtzIiB2YWx1ZT0iMjAwMDAiIHN0ZXA9IjEwMDAiPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KCjxkaXYgY2xhc3M9InNlYyI+PGgzPiYjMTI3OTU5OyYjNjUwMzk7IE1hdGVyaWFscyDigJQgRU4gMTk5Mi0xLTE8L2gzPgo8ZGl2IGlkPSJhdmlzb19leHBvIiBjbGFzcz0ibm90YS1yIiBzdHlsZT0iZGlzcGxheTpub25lOyI+PC9kaXY+CjxkaXYgY2xhc3M9Imc0Ij4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5FeHBvc3VyZSBjbGFzczwvbGFiZWw+PHNlbGVjdCBpZD0iZXhwbyIgb25jaGFuZ2U9InZhbGlkYXJFeHBvKCkiPgogICAgPG9w

dGlvbiB2YWx1ZT0iWEMxIj5YQzEgKGRyeSk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJYQzIiIHNlbGVjdGVkPlhDMiAod2V0L3JhcmVseSBkcnkpPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSJYQzMiPlhDMyAobW9kZXJhdGUgaHVtaWRpdHkpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iWEM0Ij5YQzQgKGN5Y2xpYyB3ZXQvZHJ5KTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iWEQxIj5YRDEgKGNobG9yaWRlcywgbW9kZXJhdGUpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iWFMxIj5YUzEgKG1hcmluZSBhaXIpPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSJYUzIiPlhTMiAoc3VibWVyZ2VkKTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxk

aXYgY2xhc3M9ImZsZCI+PGxhYmVsPmZjayAoTVBhKTwvbGFiZWw+PHNlbGVjdCBpZD0iZmNrIiBvbmNoYW5nZT0idmFsaWRhckV4cG8oKSI+CiAgICA8b3B0aW9uIHZhbHVlPSIyMCI+QzIwLzI1PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMjUiIHNlbGVjdGVkPkMyNS8zMDwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iMzAiPkMzMC8zNzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjM1Ij5DMzUvNDU8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI0MCI+QzQwLzUwPC9vcHRpb24+CiAgPC9zZWxlY3Q+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+ZnlrIChNUGEpPC9sYWJlbD48c2VsZWN0IGlkPSJmeWsiPgogICAgPG9wdGlvbiB2YWx1ZT0iNTAwIiBz

ZWxlY3RlZD5CNTAwQjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjYwMCI+QjYwMDwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTQ3O0M8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJnYyIgdmFsdWU9IjEuNSIgc3RlcD0iMC4wNSI+PHNwYW4gY2xhc3M9InVuIj5FTiAxOTkyIHRhYi4yLjFOPC9zcGFuPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPiYjOTQ3O1M8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJncyIgdmFsdWU9IjEuMTUiIHN0ZXA9IjAuMDUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkNvdmVyIG5vbS4gKG1tKTwvbGFiZWw+PGlucHV0IHR5

cGU9Im51bWJlciIgaWQ9ImNvYiIgdmFsdWU9IjQwIiBzdGVwPSI1IiBtaW49IjIwIj48c3BhbiBjbGFzcz0idW4iIGlkPSJjb2JfcmVmX2UiPlhDMjogbWluIDI1bW08L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+JiMyMTY7IHN0ZW0gYmFyIChtbSk8L2xhYmVsPjxzZWxlY3QgaWQ9ImRpYW1fZiI+PG9wdGlvbiB2YWx1ZT0iMTAiPjEwPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMTIiPjEyPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMTYiIHNlbGVjdGVkPjE2PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMjAiPjIwPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMjUiPjI1PC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxk

Ij48bGFiZWw+JiMyMTY7IGZ0ZyBiYXIgKG1tKTwvbGFiZWw+PHNlbGVjdCBpZD0iZGlhbV9zIj48b3B0aW9uIHZhbHVlPSIxMCI+MTA8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIxMiI+MTI8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIxNiIgc2VsZWN0ZWQ+MTY8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIyMCI+MjA8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD4mIzk0Nztjb25jIChrTi9tJiMxNzk7KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImdhbWFfYyIgdmFsdWU9IjI1IiBzdGVwPSIwLjUiPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KCjxkaXYgY2xhc3M9InNlYyI+PGgzPiYjOTg4MTsmIzY1MDM5OyBTZWlz

bWljIC8gUyYjMjM3O3NtaWNvPC9oMz48ZGl2IGNsYXNzPSJnMyI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+U2Vpc21pYyB6b25lIChhZy9nKTwvbGFiZWw+PHNlbGVjdCBpZD0iYWciPgogICAgPG9wdGlvbiB2YWx1ZT0iMCIgc2VsZWN0ZWQ+Tm9uLXNlaXNtaWM8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9IjAuMDUiPmFnPTAsMDVnPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC4xMCI+YWc9MCwxMGc8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9IjAuMTUiPmFnPTAsMTVnPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC4yNSI+YWc9MCwyNWc8L29wdGlvbj4KICA8L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DUyBydXB0

LiBjaXJjLiBtaW4uPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iY3NyX21pbiIgdmFsdWU9IjEuNTAiIHN0ZXA9IjAuMDUiPjxzcGFuIGNsYXNzPSJ1biI+RU4gMTk5Ny0xIMKnMTEuNTwvc3Bhbj48L2Rpdj4KPC9kaXY+PC9kaXY+Cgo8YnV0dG9uIGNsYXNzPSJidG4tY2FsYyIgb25jbGljaz0iY2FsY0V1cm8oKSI+JiM5NjU0OyBDQUxDVUxBVEUg4oCUIEVVUk9DT0RFIERBMSAoQzErQzIpPC9idXR0b24+CjxkaXYgaWQ9ImFsZXJ0YXNfZGl2IiBzdHlsZT0ibWFyZ2luLXRvcDoxMHB4OyI+PC9kaXY+Cgo8ZGl2IGlkPSJyZXN1bHRhZG8iPgo8ZGl2IGNsYXNzPSJzZWMiIGlkPSJzZWMtcmVzIj4KICA8aDM+JiMxMjg2ODA7IEdFTyBDaGVja3MgKERB

MSk8L2gzPjxkaXYgY2xhc3M9InNlbSIgaWQ9InNlbV9nZW8iPjwvZGl2PgogIDxoMyBzdHlsZT0ibWFyZ2luLXRvcDo4cHg7Ij4mIzEyNzk1OTsmIzY1MDM5OyBTVFIgQ2hlY2tzIChFTiAxOTkyKTwvaDM+PGRpdiBjbGFzcz0ic2VtIiBpZD0ic2VtX2VzdCI+PC9kaXY+CiAgPGgzIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPkFsZXJ0YXMgLyBBbGVydHM8L2gzPjxkaXYgaWQ9ImFsZXJ0YXNfcmVzIj48L2Rpdj4KICA8aDMgc3R5bGU9Im1hcmdpbi10b3A6OHB4OyI+JiMxMjgyMDM7IENhbGN1bGF0aW9uIE1lbW8g4oCUIEVOIDE5OTcgLyBFTiAxOTkyPC9oMz4KICA8YnV0dG9uIGNsYXNzPSJidG4tcGRmIiBvbmNsaWNrPSJ3aW5kb3cucHJpbnQoKSI+JiMxMjg0

MjQ7JiM2NTAzOTsgRXhwb3J0IFBERjwvYnV0dG9uPgogIDxkaXYgY2xhc3M9Im1lbSIgaWQ9Im1lbW9yaWFsIj48L2Rpdj4KPC9kaXY+PC9kaXY+CjwvZGl2PgoKPHNjcmlwdD4KLy8gRU4gMTk5Mi0xLTEgVGFibGUgNC40TiBcdTIwMTQgbWluIGNvdmVyIGJ5IGV4cG9zdXJlIGNsYXNzCnZhciBDT1ZfTUlOX0VOPXtYQzE6MTUsWEMyOjI1LFhDMzoyNSxYQzQ6MzAsWEQxOjM1LFhTMTozNSxYUzI6NDB9OwovLyBFTiAxOTkyLTEtMSBUYWJsZSBFLjFOIFx1MjAxNCBtaW4gZmNrIGJ5IGV4cG9zdXJlCnZhciBGQ0tfTUlOX0VOPXtYQzE6MjAsWEMyOjI1LFhDMzozMCxYQzQ6MzAsWEQxOjM1LFhTMTozNSxYUzI6NDB9OwoKZnVuY3Rpb24gdmFsaWRhckV4cG8oKXsK

ICB2YXIgZXhwbz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZXhwbycpLnZhbHVlOwogIHZhciBmY2s9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdmY2snKS52YWx1ZTsKICB2YXIgY29iX21tPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29iJykudmFsdWU7CiAgdmFyIGNvdl9taW49Q09WX01JTl9FTltleHBvXXx8MTU7CiAgdmFyIGZja19taW49RkNLX01JTl9FTltleHBvXXx8MjA7CiAgdmFyIHJlZj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29iX3JlZl9lJyk7CiAgcmVmLnRleHRDb250ZW50PWV4cG8rJzogbWluIGNvdmVyICcrY292X21pbisnbW0sIG1pbiBmY2sgQycrZmNrX21pbisnIChFTiAxOTkyLTEtMSknOwogIHZhciBkaXY9ZG9jdW1l

bnQuZ2V0RWxlbWVudEJ5SWQoJ2F2aXNvX2V4cG8nKTsKICB2YXIgbXNncz1bXTsKICBpZihmY2s8ZmNrX21pbikgbXNncy5wdXNoKCdmY2s9JytmY2srJ01QYSBiZWxvdyBtaW4gQycrZmNrX21pbisnIGZvciAnK2V4cG8rJyAoRU4gMTk5Mi0xLTEgVGFibGUgRS4xTiknKTsKICBpZihjb2JfbW08Y292X21pbikgbXNncy5wdXNoKCdDb3ZlciAnK2NvYl9tbSsnbW0gYmVsb3cgbWluICcrY292X21pbisnbW0gZm9yICcrZXhwbysnIChFTiAxOTkyLTEtMSBUYWJsZSA0LjROKScpOwogIGlmKG1zZ3MubGVuZ3RoKXtkaXYuc3R5bGUuZGlzcGxheT0nYmxvY2snO2Rpdi5pbm5lckhUTUw9bXNncy5qb2luKCc8YnI+Jyk7fQogIGVsc2UgZGl2LnN0eWxlLmRpc3BsYXk9

J25vbmUnOwp9CgpmdW5jdGlvbiB0b1JhZChkKXtyZXR1cm4gZCpNYXRoLlBJLzE4MDt9CmZ1bmN0aW9uIHRvRGVnKHIpe3JldHVybiByKjE4MC9NYXRoLlBJO30KZnVuY3Rpb24gZm10KHYsZCl7ZD0oZD09PXVuZGVmaW5lZCk/MzpkO3JldHVybiBOdW1iZXIodikudG9GaXhlZChkKTt9CgpmdW5jdGlvbiBib3Vzc2luZXNxKFAsZCxIKXsKICBpZihkPD0wfHxQPD0wKSByZXR1cm4ge0VoOjAseWE6SC8yfTsKICByZXR1cm4ge0VoOihQL01hdGguUEkpKihIKmQqZC8oZCpkK0gqSCkrTWF0aC5hdGFuKEgvZCkpLHlhOkgvMn07Cn0KCmZ1bmN0aW9uIGNhcGFUZXJ6YWdoaShwaGlfZGVnLGMsZ3MsRGYsQil7CiAgdmFyIHA9dG9SYWQocGhpX2RlZyksTnE9TWF0aC5l

eHAoTWF0aC5QSSpNYXRoLnRhbihwKSkqTWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80K3AvMiksMiksTmM9KE5xLTEpL01hdGgudGFuKHApLE5nPTIqKE5xKzEpKk1hdGgudGFuKHApOwogIHZhciBxMD1ncypEZixxdWx0PWMqTmMrcTAqTnErMC41KmdzKkIqTmc7CiAgcmV0dXJuIHtxdWx0OnF1bHQscWFkbTpxdWx0LzMsTnE6TnEsTmM6TmMsTmc6TmcscTA6cTB9Owp9CgpmdW5jdGlvbiBzdWdlcmlyQmFycmEoQXMsZHApewogIHZhciBCPVt7ZDo4LGE6NTAuM30se2Q6MTAsYTo3OC41fSx7ZDoxMixhOjExMy4xfSx7ZDoxNixhOjIwMS4xfSx7ZDoyMCxhOjMxNC4yfSx7ZDoyNSxhOjQ5MC45fV07CiAgZm9yKHZhciBpPTA7aTxCLmxlbmd0aDtpKyspe3ZhciBi

PUJbaV07aWYoZHAmJmIuZCE9ZHApY29udGludWU7dmFyIHM9TWF0aC5mbG9vcihiLmEvQXMqMTAwKSoxMDtpZihzPj02MCYmczw9MjAwKXJldHVybiB7dHh0OidcdTAwZDgnK2IuZCsnQCcrTWF0aC5taW4ocywyMDApKydtbScsYXJlYTpiLmEqMTAwMC9NYXRoLm1pbihzLDIwMCksZGlhbTpiLmR9O30KICBmb3IodmFyIGk9MDtpPEIubGVuZ3RoO2krKyl7dmFyIGI9QltpXTt2YXIgcz1NYXRoLmZsb29yKGIuYS9BcyoxMDApKjEwO2lmKHM+PTYwJiZzPD0yMDApcmV0dXJuIHt0eHQ6J1x1MDBkOCcrYi5kKydAJytNYXRoLm1pbihzLDIwMCkrJ21tJyxhcmVhOmIuYSoxMDAwL01hdGgubWluKHMsMjAwKSxkaWFtOmIuZH07fQogIHJldHVybiB7dHh0OidcdTAwZDgy

NUAxMDBtbScsYXJlYTo0OTA5LGRpYW06MjV9Owp9CgpmdW5jdGlvbiBjYWxjRXVybygpewogIHZhciBvYnJhPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdvYnJhJykudmFsdWV8fCcobi9hKSc7CiAgdmFyIHJlc3A9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3AnKS52YWx1ZXx8JyhuL2EpJzsKICB2YXIgY3JlYT1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY3JlYScpLnZhbHVlfHwnKG4vYSknOwogIHZhciBkYXRhX2M9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RhdGFfY2FsYycpLnZhbHVlfHxuZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7CiAgdmFyIHJldj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmV2JykudmFsdWV8fCdS

MDAnOwogIHZhciBsYXVkbz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGF1ZG8nKS52YWx1ZXx8JyhuL2EpJzsKICB2YXIgYXJ0X25yPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhcnQnKT8oZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2FydCcpLnZhbHVlfHwnKG4vYSknKTonKG4vYSknOwogIHZhciBIPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnSCcpLnZhbHVlLEhlbT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0hlbScpLnZhbHVlOwogIHZhciB0X3RvcD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3RfdG9wbycpLnZhbHVlLHRfYmFzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndF9iYXNlJykudmFsdWU7CiAgdmFyIEI9K2RvY3VtZW50Lmdl

dEVsZW1lbnRCeUlkKCdCJykudmFsdWUsQjE9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdCMScpLnZhbHVlOwogIHZhciBocz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2hzJykudmFsdWUsYmV0YT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2JldGEnKS52YWx1ZTsKICB2YXIgdGlwb19zYz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGlwb19zYycpLnZhbHVlLHFfc29iPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncScpLnZhbHVlOwogIHZhciBwc2kwPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncHNpMCcpLnZhbHVlOwogIHZhciBQX2NvbmM9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdQX2NvbmMnKS52YWx1ZSxkaXN0X3NjPStkb2N1bWVu

dC5nZXRFbGVtZW50QnlJZCgnZGlzdF9zYycpLnZhbHVlOwogIHZhciBzdWNzPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzdWNzJykudmFsdWUsbnNwdD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ25zcHQnKS52YWx1ZTsKICB2YXIgZ2FtYV9zPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ2FtYV9zJykudmFsdWUscGhpX2RlZz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3BoaScpLnZhbHVlOwogIHZhciBjb2VzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29lcycpLnZhbHVlLGRlbHRhX3I9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkZWx0YV9yJykudmFsdWU7CiAgdmFyIE53PStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnTncnKS52YWx1

ZSxkcmVuPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkcmVuJykudmFsdWU7CiAgdmFyIHJ1PStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncnUnKS52YWx1ZTsKICB2YXIgUmxpbV9pbnA9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdSbGltJykudmFsdWUsb3JpZ19xPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdvcmlnX3EnKS52YWx1ZTsKICB2YXIga3M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdrcycpLnZhbHVlOwogIHZhciBleHBvPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdleHBvJykudmFsdWUsZmNrPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZmNrJykudmFsdWU7CiAgdmFyIGZ5az0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Z5aycp

LnZhbHVlLGdjPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ2MnKS52YWx1ZTsKICB2YXIgZ3NfYWNvPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ3MnKS52YWx1ZSxjb2JfbW09K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb2InKS52YWx1ZTsKICB2YXIgY29iPWNvYl9tbS8xMDAwLGRpYW1fZj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RpYW1fZicpLnZhbHVlLGRpYW1fcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RpYW1fcycpLnZhbHVlOwogIHZhciBnYW1hX2M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdnYW1hX2MnKS52YWx1ZTsKICB2YXIgYWc9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhZycpLnZhbHVlLENTUl9NSU49K2Rv

Y3VtZW50LmdldEVsZW1lbnRCeUlkKCdjc3JfbWluJykudmFsdWU7CgogIHZhciBhbGVydGFzPVtdOwogIHZhciBIZW1fbWluPU1hdGgubWF4KDAuNTAsSC8xMCk7CiAgaWYoSGVtPEhlbV9taW4pIGFsZXJ0YXMucHVzaCgnSGVtPScrZm10KEhlbSwyKSsnbSA8IG1pbj0nK2ZtdChIZW1fbWluLDIpKydtIChFTiAxOTk3LTEgXHUwMGE3Ni40KScpOwogIHZhciBCSD1CL0g7CiAgaWYoQkg8MC40MCkgYWxlcnRhcy5wdXNoKCdCL0g9JytmbXQoQkgsMikrJyA8IDAuNDAgXHUyMDE0IHVuZGVyc2l6ZWQgYmFzZScpOwogIGlmKGRyZW49PT0nc2VtJykgYWxlcnRhcy5wdXNoKCdOTyBEUkFJTkFHRSBcdTIwMTQgZnVsbCBoeWRyb3N0YXRpYy4gRU4gMTk5Ny0xIFx1MDBh

NzYuNS40Jyk7CiAgdmFyIEJfY2FsYz1CLUIxLXRfYmFzOwogIGlmKEJfY2FsYzwwLjEpIGFsZXJ0YXMucHVzaCgnSGVlbCBCYz0nK2ZtdChCX2NhbGMsMykrJ20gaW52YWxpZCBcdTIwMTQgY2hlY2sgZ2VvbWV0cnknKTsKICB2YXIgY292X21pbj1DT1ZfTUlOX0VOW2V4cG9dfHwxNTsKICB2YXIgZmNrX21pbl9lPUZDS19NSU5fRU5bZXhwb118fDIwOwogIGlmKGZjazxmY2tfbWluX2UpIGFsZXJ0YXMucHVzaCgnZmNrPScrZmNrKydNUGEgPCBtaW4gQycrZmNrX21pbl9lKycgZm9yICcrZXhwbysnIChFTiAxOTkyLTEtMSBUYWJsZSBFLjFOKScpOwogIGlmKGNvYl9tbTxjb3ZfbWluKSBhbGVydGFzLnB1c2goJ0NvdmVyICcrY29iX21tKydtbSA8IG1pbiAnK2Nv

dl9taW4rJ21tIGZvciAnK2V4cG8rJyAoRU4gMTk5Mi0xLTEgVGFibGUgNC40TiknKTsKCiAgLy8gTWF0ZXJpYWxzIEVOIDE5OTIKICB2YXIgZmNkPWZjayowLjg1L2djLGZ5ZD1meWsvZ3NfYWNvOwogIHZhciBmY3RtPShmY2s8PTUwKT8wLjMqTWF0aC5wb3coZmNrLDIvMyk6Mi4xMipNYXRoLmxvZygxK2Zjay8xMCk7CiAgdmFyIGZjdGtfaW5mPTAuNypmY3RtLGZjdGQ9ZmN0a19pbmYvZ2M7CiAgdmFyIEVjPShmY2s8PTUwKT8yMjAwMCpNYXRoLnBvdyhmY2svMTAsMC4zKTozMDAwMDsKCiAgdmFyIEhfZnVzdGU9SC1ocyx0X21lZD0odF90b3ArdF9iYXMpLzI7CiAgdmFyIE53X2VmZj1OdzsKICBpZihkcmVuPT09J29rJykgTndfZWZmPTA7CiAgaWYoZHJlbj09

PSdiYXJiYWNhcycpIE53X2VmZj1OdyowLjU7CiAgdmFyIFVfc3ViPTAsVV95YT0wOwogIGlmKE53X2VmZj4wJiZOd19lZmY8PUgpe1Vfc3ViPTAuNSoxMCpOd19lZmYqTndfZWZmO1VfeWE9TndfZWZmLzM7fQoKICB2YXIgcGhpPXRvUmFkKHBoaV9kZWcpLGJldGFSPXRvUmFkKGJldGEpOwogIHZhciBLcD1NYXRoLnBvdyhNYXRoLnRhbihNYXRoLlBJLzQrcGhpLzIpLDIpOwogIHZhciBFcD0wLjUqS3AqZ2FtYV9zKkhlbSpIZW07CgogIC8vIERBMSBcdTIwMTQgYm90aCBjb21iaW5hdGlvbnMKICBmdW5jdGlvbiBjYWxjQ29tYihnRyxnUSxncGhpLGdjX3MsbGFiZWwpewogICAgdmFyIHBoaV9kPU1hdGguYXRhbihNYXRoLnRhbihwaGkpL2dwaGkpOwogICAgdmFy

IGNfZD1jb2VzL2djX3M7CiAgICB2YXIgZGVsdGFfZD1waGlfZCpkZWx0YV9yOwogICAgdmFyIEthX249TWF0aC5wb3coTWF0aC5zaW4oTWF0aC5QSS8yK3BoaV9kKSwyKTsKICAgIHZhciBLYV9kMj1NYXRoLnBvdyhNYXRoLnNpbihNYXRoLlBJLzIpLDIpKk1hdGguc2luKE1hdGguUEkvMi1kZWx0YV9kKTsKICAgIHZhciBLYV9zPU1hdGguc3FydChNYXRoLnNpbihwaGlfZCtkZWx0YV9kKSpNYXRoLnNpbihwaGlfZC1iZXRhUikvKE1hdGguc2luKE1hdGguUEkvMi1kZWx0YV9kKSpNYXRoLnNpbihNYXRoLlBJLzIrYmV0YVIpKSk7CiAgICB2YXIgS2E9S2Ffbi8oS2FfZDIqTWF0aC5wb3coMStLYV9zLDIpKTsKICAgIHZhciBLYV9yYW5rPU1hdGgucG93KE1hdGgu

dGFuKE1hdGguUEkvNC1waGlfZC8yKSwyKTsgLy8gUmFua2luZSByZWZlcmVuY2UgKGRlbHRhPTApCiAgICB2YXIgRWFfZz1nRyowLjUqS2EqZ2FtYV9zKkgqSDsKICAgIHZhciBFYWhfZz1FYV9nKk1hdGguY29zKGRlbHRhX2QpLEVhdl9nPUVhX2cqTWF0aC5zaW4oZGVsdGFfZCk7CiAgICB2YXIgcV9kPXRpcG9fc2MhPT0nbmVuaHVtYSc/Z1EqcHNpMCpxX3NvYjowOwogICAgdmFyIEVhaF9xPUthKnFfZCpIKk1hdGguY29zKGRlbHRhX2QpLEVhdl9xPUthKnFfZCpIKk1hdGguc2luKGRlbHRhX2QpOwogICAgdmFyIGJvPXRpcG9fc2M9PT0nY29uY2VudHJhZGEnP2JvdXNzaW5lc3EoUF9jb25jLGRpc3Rfc2MsSCk6e0VoOjAseWE6SC8yfTsKICAgIHZhciBFYWhf

Ym89Z1EqYm8uRWg7CiAgICB2YXIgRXY9RWF2X2crRWF2X3E7CiAgICB2YXIgV2Y9Z0cqZ2FtYV9jKnRfbWVkKkhfZnVzdGUseGY9QjErdF9iYXMvMjsKICAgIHZhciBXcz1nRypnYW1hX2MqQipocyx4cz1CLzI7CiAgICB2YXIgV3NvPWdHKmdhbWFfcypCX2NhbGMqSF9mdXN0ZSx4c289Qi1CX2NhbGMvMjsKICAgIHZhciBXcGU9Z0cqZ2FtYV9zKkIxKkhlbSx4cGU9QjEvMjsKICAgIHZhciBWPVdmK1dzK1dzbytXcGUrRXY7CiAgICB2YXIgTWU9V2YqeGYrV3MqeHMrV3NvKnhzbytXcGUqeHBlK0V2KkI7CiAgICB2YXIgTXQ9KEVhaF9nK0VhaF9ibykqKEgvMykrRWFoX3EqKEgvMikrVV9zdWIqVV95YTsKICAgIHZhciBDU190PU1lL01hdGgubWF4KE10LDAuMDAx

KTsKICAgIHZhciBGcj1NYXRoLnRhbihwaGlfZCkqVitjX2QqQjsKICAgIHZhciBGYT1FYWhfZytFYWhfcStFYWhfYm8rVV9zdWI7CiAgICB2YXIgQ1NfZD1Gci9NYXRoLm1heChGYSwwLjAwMSk7CiAgICB2YXIgeFI9KE1lLU10KS9WLGU9TWF0aC5hYnMoQi8yLXhSKSxCZWZmPUItMiplOwogICAgdmFyIHFtYXg9Vi9CKigxKzYqZS9CKSxxbWluPVYvQiooMS02KmUvQik7CiAgICByZXR1cm4ge0thOkthLHBoaV9kOnRvRGVnKHBoaV9kKSxjX2Q6Y19kLEVhaF9nOkVhaF9nLEVhaF9xOkVhaF9xLEVhaF9ibzpFYWhfYm8sRWF2X2c6RWF2X2csRXY6RXYsVjpWLE1lOk1lLE10Ok10LENTX3Q6Q1NfdCxGcjpGcixGYTpGYSxDU19kOkNTX2QseFI6eFIsZTplLEJlZmY6

QmVmZixxbWF4OnFtYXgscW1pbjpxbWluLGxhYmVsOmxhYmVsLHBoaV9kX3ZhbDpwaGlfZCxjX2RfdmFsOmNfZCxnRzpnRyxnUTpnUSxxX2Q6cV9kfTsKICB9CgogIHZhciByMT1jYWxjQ29tYigxLjM1LDEuNTAsMS4wLDEuMCwnQzEgKFNUUiknKTsKICB2YXIgcjI9Y2FsY0NvbWIoMS4wLDEuMzAsMS4yNSwxLjI1LCdDMiAoR0VPKScpOwogIHZhciB0b21iX2dvdj1NYXRoLm1pbihyMS5DU190LHIyLkNTX3QpOwogIHZhciBkZXNsX2dvdj1NYXRoLm1pbihyMS5DU19kLHIyLkNTX2QpOwogIHZhciBxbWF4X2dvdj1NYXRoLm1heChyMS5xbWF4LHIyLnFtYXgpOwogIHZhciBxbWluX2dvdj1NYXRoLm1pbihyMS5xbWluLHIyLnFtaW4pOwogIHZhciBCZWZmX2dvdj1N

YXRoLm1pbihyMS5CZWZmLHIyLkJlZmYpOwogIHZhciBlX2dvdj1NYXRoLm1heChyMS5lLHIyLmUpOwoKICBpZih0b21iX2dvdjwxLjApIGFsZXJ0YXMucHVzaCgnU1RBQklMSVRZOiBPdmVydHVybmluZyBDUz0nK2ZtdCh0b21iX2dvdiwzKSsnIDwgMS4wJyk7CiAgaWYoZGVzbF9nb3Y8MS4wKSBhbGVydGFzLnB1c2goJ1NUQUJJTElUWTogU2xpZGluZyBDUz0nK2ZtdChkZXNsX2dvdiwzKSsnIDwgMS4wJyk7CiAgaWYocW1pbl9nb3Y8MCkgYWxlcnRhcy5wdXNoKCdCRUFSSU5HOiBxX21pbj0nK2ZtdChxbWluX2dvdiwyKSsnIGtOL20yIDwgMCBcdTIwMTQgdGVuc2lvbiBhdCBiYXNlJyk7CgogIC8vIFRlcnphZ2hpIHdpdGggQicKICB2YXIgdGV6PWNhcGFUZXJ6

YWdoaShwaGlfZGVnLGNvZXMsZ2FtYV9zLEhlbSxCZWZmX2dvdik7CiAgdmFyIFJsaW1fdXNvPW9yaWdfcT09PSdjYWxjdWxvJz90ZXoucWFkbTpSbGltX2lucDsKICBpZihxbWF4X2dvdj5SbGltX3VzbykgYWxlcnRhcy5wdXNoKCdCRUFSSU5HOiBxX21heD0nK2ZtdChxbWF4X2dvdiwyKSsnID4gUmxpbT0nK2ZtdChSbGltX3VzbywyKSsnIGtOL20yJyk7CgogIC8vIFJlY2FscXVlCiAgdmFyIERlbHRhX3E9TWF0aC5tYXgocW1heF9nb3YtZ2FtYV9zKkhlbSwwKTsKICB2YXIgcmVjX21tPXBoaV9kZWc+PTI1P0RlbHRhX3EvbnNwdCpCZWZmX2dvdioxMCoyOkRlbHRhX3EqQmVmZl9nb3Yva3MqMTAwMDsKCiAgLy8gQmlzaG9wIHdpdGggcnUgKDUgY2lyY2xlcykK

ICB2YXIgQ1NfYmlzaG9wPTk5OwogIHZhciBjYW5kcz1be3hjOkIqMC4xLHljOkgqMS4yLFI6SCoxLjN9LHt4YzowLHljOkgqMS41LFI6SCoxLjZ9LHt4YzpCKjAuMix5YzpILFI6SCoxLjF9LHt4YzotQiowLjEseWM6SCoxLjMsUjpIKjEuNH0se3hjOkIqMC4zLHljOkgqMC44LFI6SCowLjk1fV07CiAgZm9yKHZhciBjaT0wO2NpPGNhbmRzLmxlbmd0aDtjaSsrKXsKICAgIHZhciBjYz1jYW5kc1tjaV07dmFyIHNyPTAsc209MDt2YXIgZGFuZz1NYXRoLlBJLzg7CiAgICBmb3IodmFyIGZpPTA7Zmk8ODtmaSsrKXt2YXIgYW5nPS1NYXRoLlBJLzIrZmkqZGFuZytkYW5nLzI7dmFyIHhpPWNjLnhjK2NjLlIqTWF0aC5zaW4oYW5nKTt2YXIgemk9Y2MueWMtY2MuUipN

YXRoLmNvcyhhbmcpO2lmKHppPDB8fHppPkgpIGNvbnRpbnVlO3ZhciBiaT1jYy5SKmRhbmcqTWF0aC5jb3MoYW5nKTt2YXIgaGk9TWF0aC5tYXgoMCxILXppKTt2YXIgV2k9Z2FtYV9zKmhpKmJpO3ZhciBOaT1XaSpNYXRoLmNvcyhhbmcpO3ZhciB1aT1ydSpXaS9NYXRoLm1heChiaSwwLjAwMSkqTWF0aC5jb3MoYW5nKTtzcis9KGNvZXMqYmkrKE5pLXVpKSpNYXRoLnRhbih0b1JhZChwaGlfZGVnKSkpO3NtKz1XaSpNYXRoLnNpbihhbmcpO30KICAgIHZhciBjc2k9c3IvTWF0aC5tYXgoc20sMC4wMDEpOwogICAgaWYoY3NpPjAmJmNzaTxDU19iaXNob3ApIENTX2Jpc2hvcD1jc2k7CiAgfQogIENTX2Jpc2hvcD1NYXRoLm1heChDU19iaXNob3AsMC41KTsKICBp

ZihDU19iaXNob3A8Q1NSX01JTikgYWxlcnRhcy5wdXNoKCdHTE9CQUwgU1RBQklMSVRZOiBCaXNob3AgQ1M9JytmbXQoQ1NfYmlzaG9wLDMpKycgPCBtaW49JytDU1JfTUlOLnRvRml4ZWQoMikrJyAoRU4gMTk5Ny0xIFx1MDBhNzExLjUpJyk7CgogIC8vIFNcdTAwZWRzbWljYSBFTiAxOTk4LTUKICB2YXIgQ1N0X3Npcz0wLENTZF9zaXM9MDsKICBpZihhZz4wKXsKICAgIHZhciBraD1hZyowLjU7CiAgICB2YXIgZFBhZT0wLjM3NSpraCpnYW1hX3MqSCpIOwogICAgQ1N0X3Npcz1yMi5NZS9NYXRoLm1heChyMi5NdCtkUGFlKjAuNipILDAuMDAxKTsKICAgIENTZF9zaXM9cjIuRnIvTWF0aC5tYXgocjIuRmErZFBhZSwwLjAwMSk7CiAgICBpZihDU3Rfc2lzPDEu

MCkgYWxlcnRhcy5wdXNoKCdTRUlTTUlDIChFTiAxOTk4LTUpOiBPdmVydHVybmluZyBDUz0nK2ZtdChDU3Rfc2lzLDMpKycgPCAxLjAnKTsKICAgIGlmKENTZF9zaXM8MS4wKSBhbGVydGFzLnB1c2goJ1NFSVNNSUMgKEVOIDE5OTgtNSk6IFNsaWRpbmcgQ1M9JytmbXQoQ1NkX3NpcywzKSsnIDwgMS4wJyk7CiAgfQoKICAvLyBTdHJ1Y3R1cmFsIFx1MjAxNCBDMSBnb3Zlcm5zIFNUUgogIHZhciBkX2Y9dF9iYXMtY29iLWRpYW1fZi8xMDAwLzI7CiAgdmFyIE1kX2Y9cjEuRWFoX2cqKEhfZnVzdGUvMykrcjEuRWFoX3EqKEhfZnVzdGUvMikrcjEuRWFoX2JvKihIX2Z1c3RlLzIpOwogIHZhciBOZF9mPTEuMzUqZ2FtYV9jKnRfbWVkKkhfZnVzdGU7IC8vIGF4aWFs

IGNvbXByZXNzaW9uIEMxCiAgLy8gSW50ZXJhY3Rpb246IE1kIHJlZHVjZWQgYnkgTiAoY29uc2VydmF0aXZlOiB1c2UgTWQgd2l0aG91dCByZWR1Y3Rpb24pCiAgdmFyIGtNZD1NZF9mKjEwMDAvKDEwMDAqZF9mKjEwMDAqZF9mKjEwMDAqZmNkKTsKICB2YXIgeGQ9KDEtTWF0aC5zcXJ0KE1hdGgubWF4KDEtMiprTWQsMC4wMDEpKSkvMC44OwogIGlmKHhkPjAuNDUpIGFsZXJ0YXMucHVzaCgnU1RFTTogeC9kPScrZm10KHhkLDMpKycgPiAwLjQ1IFx1MjAxNCBEb21haW4gNCwgY2hlY2sgZHVjdGlsaXR5IChFTiAxOTkyIFx1MDBhNzYuMi4zKScpOwogIHZhciBBc19mPU1hdGgubWF4KE1kX2YqMWU2LygwLjg3KmZ5ZCpkX2YqMTAwMCksMCk7CiAgdmFyIEFzX21p

bl9mPU1hdGgubWF4KDAuMjYqZmN0bS9meWsqMTAwMCpkX2YqMTAwMCwwLjAwMTMqMTAwMCpkX2YqMTAwMCk7CiAgdmFyIEFzX2ZfZmluPU1hdGgubWF4KEFzX2YsQXNfbWluX2YpOwogIHZhciBBc19kaXN0cj1NYXRoLm1heCgwLjIwKkFzX2ZfZmluLDAuMDAxKjEwMDAqdF9tZWQqMTAwMCk7CiAgLy8gU2hlYXIKICB2YXIgVkVkPXIxLkVhaF9nK3IxLkVhaF9xK3IxLkVhaF9ibzsKICB2YXIgVlJkYz0oMC4xOC9nYykqTWF0aC5wb3coZmNrLDEvMykqZF9mKjEwMDAqMTAwMC8xMDAwOwogIHZhciBva19jaXM9VkVkPD1WUmRjOwogIGlmKCFva19jaXMpIGFsZXJ0YXMucHVzaCgnU1RFTSBTSEVBUjogVkVkPScrZm10KFZFZCwyKSsnID4gVlJkLGM9JytmbXQoVlJk

YywyKSsnIGtOL20gXHUyMDE0IHN0aXJydXBzIHJlcXVpcmVkIChFTiAxOTkyIFx1MDBhNzkuMi4yKScpOwogIC8vIFNsZW5kZXJuZXNzCiAgdmFyIGxlPTIqSF9mdXN0ZSxsYW1iPWxlLygodF90b3ArdF9iYXMpLzIvTWF0aC5zcXJ0KDEyKSk7CiAgaWYobGFtYj4zNSkgYWxlcnRhcy5wdXNoKCdTVEVNOiBsYW1iZGE9JytmbXQobGFtYiwxKSsnID4gMzUgXHUyMDE0IDJuZCBvcmRlciBlZmZlY3RzIHJlcXVpcmVkIChFTiAxOTkyIFx1MDBhNzUuOCknKTsKICAvLyBBbmNob3JhZ2UgRU4gMTk5MiBcdTAwYTc4LjQKICB2YXIgZmJkX2U9Mi4yNSpmY3RkOwogIHZhciBsYl9iYXM9ZGlhbV9mLyg0KSooZnlkL2ZiZF9lKTsKICB2YXIgbGJfZj1NYXRoLm1heChsYl9i

YXMqKEFzX2YvTWF0aC5tYXgoQXNfZl9maW4sMSkpLE1hdGgubWF4KDAuMypsYl9iYXMsMTAqZGlhbV9mLDEwMCkpOwogIC8vIEZvb3RpbmcKICB2YXIgZF9zPWhzLWNvYi1kaWFtX3MvMTAwMC8yOwogIHZhciBNZF9zYz0xLjM1KmdhbWFfcypIX2Z1c3RlKkJfY2FsYypCX2NhbGMvMjsKICB2YXIgQXNfc2M9TWF0aC5tYXgoTWRfc2MqMWU2LygwLjg3KmZ5ZCpkX3MqMTAwMCksMCk7CiAgdmFyIEFzX21pbl9zPU1hdGgubWF4KDAuMjYqZmN0bS9meWsqMTAwMCpkX3MqMTAwMCwwLjAwMTMqMTAwMCpkX3MqMTAwMCk7CiAgdmFyIEFzX3NjX2Zpbj1NYXRoLm1heChBc19zYyxBc19taW5fcyk7CiAgdmFyIFZkX2NhbGM9MS4zNSpnYW1hX3MqSF9mdXN0ZSpCX2NhbGM7

CiAgdmFyIFZSZGNfcz0oMC4xOC9nYykqTWF0aC5wb3coZmNrLDEvMykqZF9zKjEwMDAqMTAwMC8xMDAwOwogIHZhciBva19jaXNfcz1WZF9jYWxjPD1WUmRjX3M7CiAgaWYoIW9rX2Npc19zKSBhbGVydGFzLnB1c2goJ0hFRUwgRk9PVElORzogVkVkPScrZm10KFZkX2NhbGMsMikrJyA+IFZSZCxjPScrZm10KFZSZGNfcywyKSsnIGtOL20gXHUyMDE0IGluY3JlYXNlIGhzIChFTiAxOTkyIFx1MDBhNzYuMiknKTsKICAvLyBUb2UKICB2YXIgcV9wZT0ocjEucW1heCtNYXRoLm1heChyMS5xbWluLDApKS8yOwogIHZhciBxX3BlX2xpcT1NYXRoLm1heChxX3BlLTEuMzUqZ2FtYV9jKmhzLDApOwogIHZhciBNZF9zcD0xLjM1KnFfcGVfbGlxKkIxKkIxLzI7CiAgdmFy

IEFzX3NwPU1hdGgubWF4KE1kX3NwKjFlNi8oMC44NypmeWQqZF9zKjEwMDApLDApOwogIHZhciBBc19zcF9maW49TWF0aC5tYXgoQXNfc3AsQXNfbWluX3MpOwogIHZhciBWZF9wZT0xLjM1KnFfcGVfbGlxKkIxOwogIHZhciBva19jaXNfcD1WZF9wZTw9VlJkY19zOwogIGlmKCFva19jaXNfcCkgYWxlcnRhcy5wdXNoKCdUT0UgRk9PVElORzogVkVkPScrZm10KFZkX3BlLDIpKycgPiBWUmQsYz0nK2ZtdChWUmRjX3MsMikrJyBrTi9tIFx1MjAxNCBpbmNyZWFzZSBocycpOwogIHZhciBsYl9zYz1NYXRoLm1heChsYl9iYXMqKEFzX3NjL01hdGgubWF4KEFzX3NjX2ZpbiwxKSksTWF0aC5tYXgoMC4zKmxiX2JhcywxMCpkaWFtX3MsMTAwKSk7CiAgdmFyIGFmPXN1

Z2VyaXJCYXJyYShBc19mX2ZpbixkaWFtX2YpLGFkPXN1Z2VyaXJCYXJyYShBc19kaXN0ciw4KSxhc2M9c3VnZXJpckJhcnJhKEFzX3NjX2ZpbixkaWFtX3MpLGFzcD1zdWdlcmlyQmFycmEoQXNfc3BfZmluLGRpYW1fcyk7CgogIC8vIFNlbWFwaG9yZQogIGZ1bmN0aW9uIHNJKGxibCx2YWwscmVxLGV4KXt2YXIgcj12YWwvcmVxLGNscz1yPj0xLjE1Pydvay1zJzoocj49MT8nd2Fybi1zJzonZXJyLXMnKSxpYz1yPj0xLjE1PydPSyc6KHI+PTE/J0FWUyc6J05PSycpO3JldHVybiAnPGRpdiBjbGFzcz0ic2l0ZW0gJytjbHMrJyI+PGRpdiBjbGFzcz0ic2xibCI+JytsYmwrJzwvZGl2PjxkaXYgY2xhc3M9InN2YWwiPicraWMrJyAnK2ZtdCh2YWwsMikrJzwvZGl2

PjxkaXYgY2xhc3M9InNyZXEiPm1pbjonK2ZtdChyZXEsMikrKGV4PycgJytleDonJykrJzwvZGl2PjwvZGl2Pic7fQogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZW1fZ2VvJykuaW5uZXJIVE1MPQogICAgc0koJ092ZXJ0dXJuLlxuREExIGdvdi4nLHRvbWJfZ292LDEuMCkrc0koJ1NsaWRpbmdcbkRBMSBnb3YuJyxkZXNsX2dvdiwxLjApKwogICAgc0koJ0JlYXJpbmdcbnE8PVJsaW0nLFJsaW1fdXNvL01hdGgubWF4KHFtYXhfZ292LDAuMDEpLDEuMCwncT0nK2ZtdChxbWF4X2dvdiwxKSsna04nKSsKICAgIHNJKCdFY2NlbnRyaWMuXG5lPD1CLzYnLEIvNi9NYXRoLm1heChlX2dvdiwwLjAwMSksMS4wLCdlPScrZm10KGVfZ292LDMpKydtJykrCiAgICBz

SSgnQmlzaG9wXG5DU3InLENTX2Jpc2hvcCxDU1JfTUlOKTsKICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc2VtX2VzdCcpLmlubmVySFRNTD0KICAgIHNJKCdTdGVtXG54L2Q8PTAuNDUnLDAuNDUvTWF0aC5tYXgoeGQsMC4wMDEpLDEuMCwneGQ9JytmbXQoeGQsMykpKwogICAgc0koJ1N0ZW0gU2hlYXJcblZFZDw9VlJkYycsVlJkYy9NYXRoLm1heChWRWQsMC4wMDEpLDEuMCkrCiAgICBzSSgnSGVlbCBTaGVhclxuVkVkPD1WUmRjJyxWUmRjX3MvTWF0aC5tYXgoTWF0aC5tYXgoVmRfY2FsYyxWZF9wZSksMC4wMDEpLDEuMCkrCiAgICBzSSgnRW1iZWRtZW50XG5IZW0+PW1pbicsSGVtL0hlbV9taW4sMS4wKTsKCiAgdmFyIGFkaXY9ZG9jdW1lbnQuZ2V0RWxl

bWVudEJ5SWQoJ2FsZXJ0YXNfZGl2Jyk7YWRpdi5pbm5lckhUTUw9Jyc7CiAgYWxlcnRhcy5mb3JFYWNoKGZ1bmN0aW9uKGEpe2FkaXYuaW5uZXJIVE1MKz0nPGRpdiBjbGFzcz0iYWxlcnRhIj4nK2ErJzwvZGl2Pic7fSk7CgogIC8vIE1lbW9yaWFsCiAgdmFyIFNFUD0nPScucmVwZWF0KDU2KSxzZXA9Jy0nLnJlcGVhdCg1Nik7CiAgdmFyIG1lbT0nPGg0PicrU0VQKyc8L2g0Pic7CiAgbWVtKz0nQ0FMQ1VMQVRJT04gTUVNTyBcdTIwMTQgUkVUQUlOSU5HIFdBTEwgXHUyMDE0IFJFSU5GT1JDRUQgQ09OQ1JFVEVcbkVOIDE5OTctMToyMDA0K0ExOjIwMTMgfCBFTiAxOTkyLTEtMToyMDA0IHwgRU4gMTk5MDoyMDAyIHwgRU4gMTk5OC01OjIwMDRcbkFwcHJvYWNo

IERBMSBcdTIwMTQgQ29tYmluYXRpb25zIEMxIChTVFIpICsgQzIgKEdFTylcbic7CiAgbWVtKz0nPGg0PicrU0VQKyc8L2g0Pic7CiAgbWVtKz0nUHJvamVjdCAgICA6ICcrb2JyYSsnXG5FbmdpbmVlciAgIDogJytyZXNwKydcbkxpY2Vuc2UgICAgOiAnK2NyZWErJyAgQVJUL1N0YW1wOiAnK2FydF9ucisnXG5EYXRlIC8gUmV2IDogJytkYXRhX2MrJyAvICcrcmV2Kydcbkdlb3RlY2ggICAgOiAnK2xhdWRvKydcblxuJzsKCiAgbWVtKz0nPGg0PjEuIEdFT01FVFJZPC9oND4nOwogIG1lbSs9JyAgSD0nK0grJ20gIEhlbT0nK0hlbSsnbSBbbWluPScrZm10KEhlbV9taW4sMikrJ20gJysoSGVtPj1IZW1fbWluPydPSyc6J0ZBSUwnKSsnXVxuJzsKICBtZW0rPScg

IEI9JytCKydtICBCL0g9JytmbXQoQkgsMikrJyAgQjE9JytCMSsnbSAgQmM9JytmbXQoQl9jYWxjLDMpKydtICBocz0nK2hzKydtXG4nOwogIG1lbSs9JyAgdHQ9Jyt0X3RvcCsnbSAgdGI9Jyt0X2JhcysnbSAgYmV0YT0nK2JldGErJ29cblxuJzsKCiAgbWVtKz0nPGg0PjIuIExPQURTICYgQ09NQklOQVRJT04gRkFDVE9SUyAoRU4gMTk5MCk8L2g0Pic7CiAgbWVtKz0nICBTdXJjaGFyZ2UgdHlwZTogJyt0aXBvX3NjKydcbic7CiAgaWYodGlwb19zYyE9PSduZW5odW1hJykgbWVtKz0nICBxX2sgPSAnK2ZtdChxX3NvYiwxKSsnIGtOL20yICBwc2kwID0gJytmbXQocHNpMCwyKSsnICAoRU4gMTk5MCBBbm5leCBBKVxuJzsKICBtZW0rPScgIC0+IHFfZChDMSkg

PSBnUSpwc2kwKnFfayA9IDEuNTAqJytmbXQocHNpMCwyKSsnKicrZm10KHFfc29iLDEpKycgPSAnK2ZtdChyMS5xX2QsMykrJyBrTi9tMlxuJzsKICBtZW0rPScgIC0+IHFfZChDMikgPSBnUSpwc2kwKnFfayA9IDEuMzAqJytmbXQocHNpMCwyKSsnKicrZm10KHFfc29iLDEpKycgPSAnK2ZtdChyMi5xX2QsMykrJyBrTi9tMlxuXG4nOwoKICBtZW0rPSc8aDQ+My4gR0VPVEVDSE5JQ0FMIFBBUkFNRVRFUlM8L2g0Pic7CiAgbWVtKz0nICBTVUNTPScrc3VjcysnICBOLVNQVD0nK25zcHQrJyAgZ2s9JytnYW1hX3MrJyBrTi9tMyAgcGhpX2s9JytwaGlfZGVnKydvICBjX2s9Jytjb2VzKycga04vbTJcbic7CiAgbWVtKz0nICBkZWx0YS9waGk9JytkZWx0YV9yKycg

IE53PScrTncrJ20gIE53X2VmZj0nK2ZtdChOd19lZmYsMikrJ20gIERyYWluYWdlOiAnK2RyZW4rJ1xuJzsKICBtZW0rPScgIHJ1PScrcnUrJyAga3M9JytrcysnIGtOL20zXG4nOwogIGlmKE53X2VmZj4wKSBtZW0rPScgIFUgPSAwLjUqZ3cqTndfZWZmXjIgPSAnK2ZtdChVX3N1YiwzKSsnIGtOL20gQCB5YT0nK2ZtdChVX3lhLDMpKydtXG4nOwogIG1lbSs9J1xuJzsKCiAgbWVtKz0nPGg0PjQuIEJFQVJJTkcgQ0FQQUNJVFkgXHUyMDE0IFRFUlpBR0hJIChFTiAxOTk3LTEgXHUwMGE3Ni41LjIpPC9oND4nOwogIG1lbSs9JyAgQlwnID0gQi0yZV9nb3YgPSAnK2ZtdChCZWZmX2dvdiw0KSsnbSAgRGY9JytIZW0rJ21cbic7CiAgbWVtKz0nICBOcT0nK2ZtdCh0

ZXouTnEsMykrJyAgTmM9JytmbXQodGV6Lk5jLDMpKycgIE5nPScrZm10KHRlei5OZywzKSsnXG4nOwogIG1lbSs9JyAgcXVsdCA9ICcrZm10KHRlei5xdWx0LDIpKycga04vbTIgICBSbGltID0gcXVsdC8zID0gJytmbXQodGV6LnFhZG0sMikrJyBrTi9tMlxuJzsKICBtZW0rPScgIFJsaW1fdXNlZCA9ICcrZm10KFJsaW1fdXNvLDIpKycga04vbTJcblxuJzsKCiAgbWVtKz0nPGg0PjUuIE1BVEVSSUFMUyBcdTIwMTQgRU4gMTk5Mi0xLTE8L2g0Pic7CiAgbWVtKz0nICBFeHBvc3VyZTogJytleHBvKycgfCBmY2s9JytmY2srJyBNUGEgW21pbiBDJytmY2tfbWluX2UrJyAnKyhmY2s+PWZja19taW5fZT8nT0snOidGQUlMJykrJ11cbic7CiAgbWVtKz0nICBmY2Qg

PSBhbHBoYV9jYypmY2svZ0MgPSAwLjg1KicrZmNrKycvJytnYysnID0gJytmbXQoZmNkLDIpKycgTVBhXG4nOwogIG1lbSs9JyAgZmN0bSA9ICcrZm10KGZjdG0sMykrJyBNUGEgICBmY3RkID0gJytmbXQoZmN0ZCwzKSsnIE1QYVxuJzsKICBtZW0rPScgIEVjID0gJytmbXQoRWMsMCkrJyBNUGFcbic7CiAgbWVtKz0nICBmeWs9JytmeWsrJyBNUGEgLT4gZnlkPScrZnlrKycvJytnc19hY28rJyA9ICcrZm10KGZ5ZCwyKSsnIE1QYVxuJzsKICBtZW0rPScgIENvdmVyID0gJytjb2JfbW0rJ21tIFttaW4gJytjb3ZfbWluKydtbSBmb3IgJytleHBvKycgJysoY29iX21tPj1jb3ZfbWluPydPSyc6J0ZBSUwnKSsnXVxuXG4nOwoKICBtZW0rPSc8aDQ+Ni4gRU4gMTk5

Ny0xIFx1MjAxNCBERVNJR04gQVBQUk9BQ0ggMSAoREExKTwvaDQ+JzsKICBtZW0rPScgIEMxIChTVFIpOiBnRz0xLjM1ICBnUT0xLjUwKnBzaTAgIGdwaGk9MS4wICBnY1wnPTEuMCAgPC0gZ292ZXJucyBzdHJ1Y3R1cmFsXG4nOwogIG1lbSs9JyAgQzIgKEdFTyk6IGdHPTEuMDAgIGdRPTEuMzAqcHNpMCAgZ3BoaT0xLjI1IGdjXCc9MS4yNSA8LSBnb3Zlcm5zIGdlb3RlY2huaWNhbFxuXG4nOwogIFtyMSxyMl0uZm9yRWFjaChmdW5jdGlvbihyKXsKICAgIG1lbSs9JyAgLS0tICcrci5sYWJlbCsnIC0tLVxuJzsKICAgIG1lbSs9JyAgcGhpX2Q9JytmbXQoci5waGlfZCwzKSsnbyAgY19kPScrZm10KHIuY19kLDMpKycga04vbTIgIEthPScrZm10KHIuS2EsNCkr

J1xuJzsKICAgIG1lbSs9JyAgRWFoX2dyYXY9JytmbXQoci5FYWhfZywzKSsnIGtOL20gIEVhaF9xPScrZm10KHIuRWFoX3EsMykrJyBrTi9tICBFYWhfYm89JytmbXQoci5FYWhfYm8sMykrJyBrTi9tXG4nOwogICAgbWVtKz0nICBFYXY9JytmbXQoci5FdiwzKSsnIGtOL20gIFNVTV9WPScrZm10KHIuViwzKSsnIGtOL21cbic7CiAgICBtZW0rPScgIFNVTV9NZXN0PScrZm10KHIuTWUsMykrJyBrTm0vbSAgU1VNX010b21iPScrZm10KHIuTXQsMykrJyBrTm0vbVxuJzsKICAgIG1lbSs9JyAgQ1NfdG9tYj0nK2ZtdChyLkNTX3QsMykrJyAgQ1NfZGVzbD0nK2ZtdChyLkNTX2QsMykrJ1xuJzsKICAgIG1lbSs9JyAgeFI9JytmbXQoci54Uiw0KSsnbSAgZT0nK2Zt

dChyLmUsNCkrJ20gIEJcJz0nK2ZtdChyLkJlZmYsMykrJ21cbic7CiAgICBtZW0rPScgIHFfbWF4PScrZm10KHIucW1heCwzKSsnIGtOL20yICBxX21pbj0nK2ZtdChyLnFtaW4sMykrJyBrTi9tMlxuXG4nOwogIH0pOwoKICBtZW0rPSc8aDQ+Ny4gR09WRVJOSU5HIFZBTFVFUyAod29yc3Qgb2YgQzEgYW5kIEMyKTwvaDQ+JzsKICBtZW0rPScgIENTX3RvbWJfZ292ID0gbWluKCcrZm10KHIxLkNTX3QsMykrJywnK2ZtdChyMi5DU190LDMpKycpID0gJytmbXQodG9tYl9nb3YsMykrJyAgPj0gMS4wICAnKyh0b21iX2dvdj49MT8nVkVSSUZJRVMnOidGQUlMUycpKydcbic7CiAgbWVtKz0nICBDU19kZXNsX2dvdiA9IG1pbignK2ZtdChyMS5DU19kLDMpKycsJytm

bXQocjIuQ1NfZCwzKSsnKSA9ICcrZm10KGRlc2xfZ292LDMpKycgID49IDEuMCAgJysoZGVzbF9nb3Y+PTE/J1ZFUklGSUVTJzonRkFJTFMnKSsnXG4nOwogIG1lbSs9JyAgcV9tYXhfZ292ICAgPSAnK2ZtdChxbWF4X2dvdiwzKSsnIGtOL20yIDw9IFJsaW09JytmbXQoUmxpbV91c28sMikrJyBrTi9tMiAgJysocW1heF9nb3Y8PVJsaW1fdXNvPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIEJcJ19nb3YgICAgICA9ICcrZm10KEJlZmZfZ292LDMpKydtICBlX2dvdj0nK2ZtdChlX2dvdiw0KSsnbSAgQi82PScrZm10KEIvNiw0KSsnbSAgJysoZV9nb3Y8PUIvNj8nVkVSSUZJRVMnOidGQUlMUycpKydcbic7CiAgbWVtKz0nICBTZXR0bGVtZW50

IGVzdGltYXRlOiB+ICcrZm10KHJlY19tbSwxKSsnIG1tXG4nOwogIG1lbSs9JyAgUGFzc2l2ZSByZXNpc3RhbmNlIChub3QgdXNlZCk6IEVwPScrZm10KEVwLDMpKycga04vbSBcdTIwMTQgY29uc2VydmF0aXZlIG9taXNzaW9uXG5cbic7CgogIG1lbSs9JzxoND44LiBHTE9CQUwgU1RBQklMSVRZIFx1MjAxNCBCSVNIT1AgKEVOIDE5OTctMSBcdTAwYTcxMS41KTwvaDQ+JzsKICBtZW0rPScgIDUtY2lyY2xlIHNlYXJjaCAgcnU9JytydSsnICBDU19CaXNob3BfbWluPScrZm10KENTX2Jpc2hvcCwzKSsnICBtaW49JytDU1JfTUlOLnRvRml4ZWQoMikrJyAgJysoQ1NfYmlzaG9wPj1DU1JfTUlOPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIE5P

VEU6IEZ1bGwgYW5hbHlzaXMgd2l0aCBHZW9TdHVkaW8vUGxheGlzIHJlcXVpcmVkIGZvciBjb25zdHJ1Y3Rpb24gZG9jdW1lbnRzLlxuXG4nOwoKICBpZihhZz4wKXsKICAgIG1lbSs9JzxoND45LiBTRUlTTUlDIFx1MjAxNCBFTiAxOTk4LTU8L2g0Pic7CiAgICBtZW0rPScgIGFnPScrYWcrJ2cgIGtofjAuNWFnICBNLU8gaW5jcmVtZW50OiBEZWx0YVBhZX4nK2ZtdCgwLjM3NSphZyowLjUqZ2FtYV9zKkgqSCwzKSsnIGtOL21cbic7CiAgICBtZW0rPScgIENTX3RvbWIoc2Vpcyk9JytmbXQoQ1N0X3NpcywzKSsnICBDU19kZXNsKHNlaXMpPScrZm10KENTZF9zaXMsMykrJyAgW21pbiAxLjAwXVxuXG4nOwogIH0KCiAgbWVtKz0nPGg0PjEwLiBTVEVNIERFU0lH

TiBcdTIwMTQgRU4gMTk5Mi0xLTEgKERBMS1DMSBnb3Zlcm5zIFNUUik8L2g0Pic7CiAgbWVtKz0nICBBeGlhbCBjb21wcmVzc2lvbjogTmQgPSAxLjM1KmdhbWFfYyp0bWVkKkhmID0gJytmbXQoTmRfZiwzKSsnIGtOL20gKHNlbGYtd2VpZ2h0KVxuJzsKICBtZW0rPScgIC0+IFN0ZW0gaXMgaW4gY29tYmluZWQgYmVuZGluZyArIGNvbXByZXNzaW9uIChmbGV4by1jb21wcmVzc2lvbilcbic7CiAgbWVtKz0nICAtPiBDb25zZXJ2YXRpdmU6IGRpbWVuc2lvbiBmb3IgZmxleHVyZSBhbG9uZSAoTiByZWR1Y2VzIEFzIHJlcXVpcmVtZW50KVxuXG4nOwogIG1lbSs9JyAgTUVkID0gRWFoX2cqSGYvMyArIEVhaF9xKkhmLzIgPSAnK2ZtdChNZF9mLDMpKycga05tL21c

bic7CiAgbWVtKz0nICBkID0gJytmbXQoZF9mLDQpKydtICAga01kID0gJytmbXQoa01kLDUpKycgICB4L2QgPSAnK2ZtdCh4ZCw0KSsnICAtPiAnKyh4ZDwwLjI1OT8nRG9tYWluIDInOnhkPDAuNDU/J0RvbWFpbiAzJzonRG9tYWluIDQgV0FSTicpKydcbic7CiAgbWVtKz0nICBBcyxyZXEgPSAnK2ZtdChBc19mLDEpKycgbW0yL20gICBBcyxtaW4oRU45LjIuMS4xKSA9ICcrZm10KEFzX21pbl9mLDEpKycgbW0yL21cbic7CiAgbWVtKz0nICBBcyxhZG90ID0gJytmbXQoQXNfZl9maW4sMSkrJyBtbTIvbSAgLT4gJythZi50eHQrJ1xuJzsKICBtZW0rPScgIEhvcml6LiBkaXN0cmlidXRpb24gKEVOIDE5OTIgXHUwMGE3OS4zLjEpOiBBcyA+PSAyMCUqQXMsbWFp

biA9ICcrZm10KEFzX2Rpc3RyLDEpKycgbW0yL20gLT4gJythZC50eHQrJ1xuJzsKICBtZW0rPScgIFZFZD0nK2ZtdChWRWQsMykrJyBrTi9tICBWUmQsYz0nK2ZtdChWUmRjLDMpKycga04vbSAgJysob2tfY2lzPydObyBzdGlycnVwcyc6J1NUSVJSVVBTIFJFUVVJUkVEIFx1MjAxNCBFTiAxOTkyIFx1MDBhNzkuMi4yJykrJ1xuJzsKICBtZW0rPScgIFNsZW5kZXJuZXNzOiBsZT0nK2ZtdChsZSwzKSsnbSAgbGFtYmRhPScrZm10KGxhbWIsMSkrKGxhbWI+MzU/JyA+IDM1IFdBUk4nOicgPD0gMzUgT0snKSsnXG4nOwogIG1lbSs9JyAgQW5jaG9yYWdlIChFTiAxOTkyIFx1MDBhNzguNCk6IGZiZD0yLjI1KmZjdGQ9JytmbXQoZmJkX2UsMykrJyBNUGEgIGxiX25l

YyA+PSAnK2ZtdChsYl9mLDEpKycgbW1cblxuJzsKCiAgbWVtKz0nPGg0PjExLiBGT09USU5HIERFU0lHTjwvaDQ+JzsKICBtZW0rPScgIGRfc2FwID0gJytmbXQoZF9zLDQpKydtXG5cbic7CiAgbWVtKz0nICBIRUVMOlxuJzsKICBtZW0rPScgICAgTUVkID0gMS4zNSpncypIZipCY14yLzIgPSAnK2ZtdChNZF9zYywzKSsnIGtObS9tXG4nOwogIG1lbSs9JyAgICBBcyxhZG90ID0gJytmbXQoQXNfc2NfZmluLDEpKycgbW0yL20gLT4gJythc2MudHh0KycgKGJvdHRvbSlcbic7CiAgbWVtKz0nICAgIFZFZD0nK2ZtdChWZF9jYWxjLDIpKycga04vbSAgVlJkLGM9JytmbXQoVlJkY19zLDIpKycga04vbSAgJysob2tfY2lzX3M/J09LJzonRkFJTCcpKydcbic7CiAg

bWVtKz0nICAgIEFuY2hvcmFnZSBsYl9uZWMgPj0gJytmbXQobGJfc2MsMSkrJyBtbVxuXG4nOwogIG1lbSs9JyAgVE9FOlxuJzsKICBtZW0rPScgICAgTUVkID0gMS4zNSpxX3BlX2xpcSpCMV4yLzIgPSAnK2ZtdChNZF9zcCwzKSsnIGtObS9tXG4nOwogIG1lbSs9JyAgICBBcyxhZG90ID0gJytmbXQoQXNfc3BfZmluLDEpKycgbW0yL20gLT4gJythc3AudHh0KycgKHRvcClcbic7CiAgbWVtKz0nICAgIFZFZD0nK2ZtdChWZF9wZSwyKSsnIGtOL20gIFZSZCxjPScrZm10KFZSZGNfcywyKSsnIGtOL20gICcrKG9rX2Npc19wPydPSyc6J0ZBSUwnKSsnXG5cbic7CgogIG1lbSs9JzxoND4xMi4gUkVJTkZPUkNFTUVOVCBTQ0hFRFVMRTwvaDQ+JzsKICBtZW0rPScg

IFNURU0gOiAnK2FmLnR4dCsnICh2ZXJ0aWNhbCBtYWluKSArICcrYWQudHh0KycgKGhvcml6b250YWwgZGlzdC4pXG4nOwogIG1lbSs9JyAgSEVFTCA6ICcrYXNjLnR4dCsnIGJvdHRvbSBsb25naXR1ZGluYWwgIGxiID49ICcrZm10KGxiX3NjLDEpKycgbW1cbic7CiAgbWVtKz0nICBUT0UgIDogJythc3AudHh0KycgdG9wIGxvbmdpdHVkaW5hbFxuJzsKICBtZW0rPScgIFRSQU5TVkVSU0U6IEFzID49IDIwJSpBc19oZWVsID0gJytmbXQoMC4yKkFzX3NjX2ZpbiwxKSsnIG1tMi9tXG5cbic7CgogIG1lbSs9JzxoND4xMy4gU1VNTUFSWTwvaDQ+JzsKICBtZW0rPScgIE92ZXJ0dXJuaW5nIEMxL0MyIDogJytmbXQodG9tYl9nb3YsMykrJyA+PSAxLjAgICcrKHRv

bWJfZ292Pj0xPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIFNsaWRpbmcgQzEvQzIgICAgIDogJytmbXQoZGVzbF9nb3YsMykrJyA+PSAxLjAgICcrKGRlc2xfZ292Pj0xPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIEJlYXJpbmcgY2FwYWNpdHkgIDogcV9tYXg9JytmbXQocW1heF9nb3YsMikrJyA8PSBSbGltPScrZm10KFJsaW1fdXNvLDIpKycgICcrKHFtYXhfZ292PD1SbGltX3Vzbz8nVkVSSUZJRVMnOidGQUlMUycpKydcbic7CiAgbWVtKz0nICBFY2NlbnRyaWNpdHkgICAgICA6IGU9JytmbXQoZV9nb3YsNCkrJ20gPD0gQi82PScrZm10KEIvNiw0KSsnbSAgJysoZV9nb3Y8PUIvNj8nVkVSSUZJRVMnOidGQUlMUycp

Kydcbic7CiAgbWVtKz0nICBFbWJlZG1lbnQgICAgICAgICA6IEhlbT0nK2ZtdChIZW0sMikrJ20gPj0gJytmbXQoSGVtX21pbiwyKSsnbSAgJysoSGVtPj1IZW1fbWluPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIEJpc2hvcCAoRU4xOTk3KSAgIDogQ1M9JytmbXQoQ1NfYmlzaG9wLDMpKycgPj0gJytDU1JfTUlOLnRvRml4ZWQoMikrJyAgJysoQ1NfYmlzaG9wPj1DU1JfTUlOPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIFN0ZW0geC9kICAgICAgICAgIDogJytmbXQoeGQsNCkrJyA8PSAwLjQ1ICAnKyh4ZDw9MC40NT8nVkVSSUZJRVMnOidGQUlMUycpKydcbic7CiAgbWVtKz0nICBTdGVtIHNoZWFyICAgICAgICA6IFZF

ZD0nK2ZtdChWRWQsMikrJyBrTi9tICAnKyhva19jaXM/J1ZFUklGSUVTJzonU1RJUlJVUFMnKSsnXG4nOwogIG1lbSs9JyAgSGVlbCBzaGVhciAgICAgICAgOiBWRWQ9JytmbXQoVmRfY2FsYywyKSsnIGtOL20gICcrKG9rX2Npc19zPydWRVJJRklFUyc6J0ZBSUxTJykrJ1xuJzsKICBtZW0rPScgIFRvZSBzaGVhciAgICAgICAgIDogVkVkPScrZm10KFZkX3BlLDIpKycga04vbSAgJysob2tfY2lzX3A/J1ZFUklGSUVTJzonRkFJTFMnKSsnXG4nOwogIGlmKGFnPjApIG1lbSs9JyAgU2Vpc21pYyAoRU4xOTk4LTUpOiB0b21iPScrZm10KENTdF9zaXMsMykrJyBkZXNsPScrZm10KENTZF9zaXMsMykrJ1xuJzsKICBtZW0rPSdcbic7CiAgaWYoYWxlcnRhcy5sZW5n

dGgpe21lbSs9JzxoND4xNC4gQUxFUlRTPC9oND4nO2FsZXJ0YXMuZm9yRWFjaChmdW5jdGlvbihhKXttZW0rPScgIFshXSAnK2ErJ1xuJzt9KTttZW0rPSdcbic7fQogIG1lbSs9JycrU0VQKydcbic7CiAgbWVtKz0nU3RhbmRhcmRzOiBFTiAxOTk3LTE6MjAwNCtBMToyMDEzIHwgRU4gMTk5Mi0xLTE6MjAwNCB8IEVOIDE5OTA6MjAwMiB8IEVOIDE5OTgtNToyMDA0XG4nOwogIG1lbSs9JycrU0VQKydcbic7CgogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdtZW1vcmlhbCcpLmlubmVySFRNTD1tZW07CiAgdmFyIF9hcj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWxlcnRhc19yZXMnKTtpZihfYXIpe19hci5pbm5lckhUTUw9YWxlcnRhcy5sZW5ndGg/YWxl

cnRhcy5tYXAoZnVuY3Rpb24oYSl7cmV0dXJuICc8ZGl2IGNsYXNzPSJhbGVydGEiPlshXSAnK2ErJzwvZGl2Pic7fSkuam9pbignJyk6JzxkaXYgc3R5bGU9ImJhY2tncm91bmQ6dmFyKC0tb2spO2NvbG9yOnZhcigtLW9rYik7Ym9yZGVyLXJhZGl1czo1cHg7cGFkZGluZzo4cHggMTJweDtmb250LXNpemU6MTFweDsiPlNlbSBhbGVydGFzLjwvZGl2Pic7fQogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRhZG8nKS5zdHlsZS5kaXNwbGF5PSdibG9jayc7CiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdGFkbycpLnNjcm9sbEludG9WaWV3KHtiZWhhdmlvcjonc21vb3RoJ30pOwp9CndpbmRvdy5vbmxvYWQ9ZnVuY3Rpb24oKXsKICB2YXIg

ZGM9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RhdGFfY2FsYycpOwogIGlmKGRjJiYhZGMudmFsdWUpIGRjLnZhbHVlPW5ldyBEYXRlKCkudG9JU09TdHJpbmcoKS5zbGljZSgwLDEwKTsKICB2YWxpZGFyRXhwbygpOwp9Owo8L3NjcmlwdD4K

PHN0eWxlPjpyb290ey0tYXo6IzFkMzE1NTstLWF6bTojMmU0ZjhhOy0tYXpjOiM0YTdjYzc7LS1kb3I6I2JmOTAwMDstLWRvcmM6I2UwYWEwMDstLWJnOiNmMGYyZjY7LS1iZ3c6I2ZmZjstLWJyZDojYzhkMGUwOy0tdHh0OiMxYTFhMmU7LS10eHRtOiM0YTRhNmE7LS1vazojZDRlZGRhOy0tb2tiOiMxYTdhM2E7LS13YXJuOiNmZmYzY2Q7LS13YXJuYjojODU2NDA0Oy0tZXJyOiNmOGQ3ZGE7LS1lcnJiOiM4NDIwMjk7fSp7Ym94LXNpemluZzpib3JkZXItYm94O21hcmdpbjowO3BhZGRpbmc6MDt9Ym9keXtmb250LWZhbWlseTonSUJNIFBsZXggU2Fucycsc2Fucy1zZXJpZjtiYWNrZ3JvdW5kOnZhcigtLWJnKTtjb2xvcjp2YXIoLS10eHQpO30ud3JhcHttYXgt

d2lkdGg6MTAwMHB4O21hcmdpbjowIGF1dG87cGFkZGluZzoyMHB4IDE2cHg7fS5zZWN7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO2JvcmRlcjoxLjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6OHB4O3BhZGRpbmc6MjBweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zZWMgaDN7Zm9udC1zaXplOjExcHg7Zm9udC13ZWlnaHQ6NzAwO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouN3B4O2NvbG9yOnZhcigtLWF6KTttYXJnaW4tYm90dG9tOjE0cHg7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4O30uc2VjIGgzOjphZnRlcntjb250ZW50OicnO2ZsZXg6MTtoZWlnaHQ6MXB4O2JhY2tncm91bmQ6dmFyKC0t

YnJkKTt9Lmcye2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjtnYXA6MTBweDt9Lmcze2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmciAxZnI7Z2FwOjEwcHg7fS5nNHtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOjFmciAxZnIgMWZyIDFmcjtnYXA6MTBweDt9LmZsZHtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDozcHg7fS5mbGQgbGFiZWx7Zm9udC1zaXplOjEwcHg7Zm9udC13ZWlnaHQ6NjAwO2NvbG9yOnZhcigtLXR4dG0pO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouNXB4O30uZmxkIGlucHV0LC5mbGQgc2VsZWN0e2JvcmRlcjox

LjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6NHB4O3BhZGRpbmc6N3B4IDlweDtmb250LXNpemU6MTJweDtmb250LWZhbWlseTppbmhlcml0O2NvbG9yOnZhcigtLXR4dCk7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO30uZmxkIC51bntmb250LXNpemU6OXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi10b3A6MXB4O30ubm90YXtiYWNrZ3JvdW5kOiNlOGYwZmU7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkIHZhcigtLWF6Yyk7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5ub3RhLXd7YmFja2dyb3VuZDojZmZmM2NkO2JvcmRlci1s

ZWZ0OjNweCBzb2xpZCB2YXIoLS1kb3JjKTtwYWRkaW5nOjdweCAxMXB4O2ZvbnQtc2l6ZToxMHB4O2JvcmRlci1yYWRpdXM6MCA0cHggNHB4IDA7bWFyZ2luLWJvdHRvbToxMHB4O2xpbmUtaGVpZ2h0OjEuNjt9Lm5vdGEtcntiYWNrZ3JvdW5kOiNmOGQ3ZGE7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkICNkYzM1NDU7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5idG4tY2FsY3tiYWNrZ3JvdW5kOnZhcigtLWF6KTtjb2xvcjojZmZmO2JvcmRlcjpub25lO2JvcmRlci1yYWRpdXM6NnB4O3BhZGRpbmc6MTNweCAyOHB4O2ZvbnQtc2l6ZToxM3B4

O2ZvbnQtd2VpZ2h0OjcwMDtjdXJzb3I6cG9pbnRlcjt3aWR0aDoxMDAlO21hcmdpbi10b3A6NnB4O30uYnRuLXBkZntiYWNrZ3JvdW5kOnZhcigtLWRvcmMpO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzo5cHggMjJweDtmb250LXNpemU6MTJweDtmb250LXdlaWdodDo3MDA7Y3Vyc29yOnBvaW50ZXI7bWFyZ2luLXRvcDoxMHB4O30jcmVzdWx0YWRve2Rpc3BsYXk6bm9uZTttYXJnaW4tdG9wOjE2cHg7fS5zZW17ZGlzcGxheTpncmlkO2dyaWQtdGVtcGxhdGUtY29sdW1uczpyZXBlYXQoOCwxZnIpO2dhcDo2cHg7bWFyZ2luLWJvdHRvbToxNHB4O30uc2VtMntkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5z

OnJlcGVhdCg0LDFmcik7Z2FwOjZweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zaXRlbXtib3JkZXItcmFkaXVzOjdweDtwYWRkaW5nOjlweCA1cHg7dGV4dC1hbGlnbjpjZW50ZXI7fS5zbGJse2ZvbnQtc2l6ZTo3LjVweDtmb250LXdlaWdodDo3MDA7dGV4dC10cmFuc2Zvcm06dXBwZXJjYXNlO2xldHRlci1zcGFjaW5nOi4zcHg7bWFyZ2luLWJvdHRvbTo0cHg7bGluZS1oZWlnaHQ6MS4zO30uc3ZhbHtmb250LXNpemU6MTRweDtmb250LXdlaWdodDo3MDA7Zm9udC1mYW1pbHk6J0lCTSBQbGV4IE1vbm8nLG1vbm9zcGFjZTt9LnNyZXF7Zm9udC1zaXplOjdweDttYXJnaW4tdG9wOjJweDtvcGFjaXR5Oi44O30ub2stc3tiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xv

cjp2YXIoLS1va2IpO30ud2Fybi1ze2JhY2tncm91bmQ6dmFyKC0td2Fybik7Y29sb3I6dmFyKC0td2FybmIpO30uZXJyLXN7YmFja2dyb3VuZDp2YXIoLS1lcnIpO2NvbG9yOnZhcigtLWVycmIpO30ubWVte2JhY2tncm91bmQ6I2Y4ZjlmYztib3JkZXI6MXB4IHNvbGlkIHZhcigtLWJyZCk7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxOHB4O2ZvbnQtc2l6ZToxMXB4O2xpbmUtaGVpZ2h0OjEuOTtmb250LWZhbWlseTonSUJNIFBsZXggTW9ubycsbW9ub3NwYWNlO3doaXRlLXNwYWNlOnByZS13cmFwO2NvbG9yOnZhcigtLXR4dCk7bWFyZ2luLXRvcDoxMnB4O30ubWVtIGg0e2ZvbnQtZmFtaWx5OidJQk0gUGxleCBTYW5zJyxzYW5zLXNlcmlmO2ZvbnQtc2l6

ZToxMXB4O2ZvbnQtd2VpZ2h0OjcwMDtjb2xvcjp2YXIoLS1heik7bWFyZ2luOjE0cHggMCA0cHg7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgdmFyKC0tYnJkKTtwYWRkaW5nLWJvdHRvbToycHg7fS5hbGVydGF7YmFja2dyb3VuZDojZjhkN2RhO2JvcmRlcjoxcHggc29saWQgI2Y1YzZjYjtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4O2NvbG9yOiM4NDIwMjk7bWFyZ2luOjRweCAwO30uc3Vie2ZvbnQtc2l6ZToxMXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi1ib3R0b206MTRweDt9QG1lZGlhKG1heC13aWR0aDo3MDBweCl7LmczLC5nNHtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjt9LnNlbXtncmlkLXRl

bXBsYXRlLWNvbHVtbnM6cmVwZWF0KDQsMWZyKTt9LnNlbTJ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOnJlcGVhdCgyLDFmcik7fX1AbWVkaWEgcHJpbnR7LmJ0bi1jYWxjLC5idG4tcGRmLC5zZWM6bm90KCNzZWMtcmVzKXtkaXNwbGF5Om5vbmUhaW1wb3J0YW50O30jcmVzdWx0YWRve2Rpc3BsYXk6YmxvY2shaW1wb3J0YW50O31ib2R5e2JhY2tncm91bmQ6I2ZmZjt9Lm1lbXtib3JkZXI6bm9uZTtwYWRkaW5nOjA7Zm9udC1zaXplOjEwcHg7fX08L3N0eWxlPgoKPGRpdiBjbGFzcz0id3JhcCI+CjxoMj5SZXRhaW5pbmcgV2FsbCAmIzgyMTI7IFJlaW5mb3JjZWQgQ29uY3JldGU8L2gyPgo8cCBjbGFzcz0ic3ViIj5BQ0kgMzE4LTE5ICYjMTgzOyBBU0NFIDctMjIg

JiMxODM7IElCQyAyMDIxIHwgVVNEIFN0cmVuZ3RoIERlc2lnbiArIEFTRCBTdGFiaWxpdHk8L3A+CjxkaXYgY2xhc3M9Im5vdGEiPiYjOTg4ODsmIzY1MDM5OyA8c3Ryb25nPkZvciB1c2UgYnkgbGljZW5zZWQgZW5naW5lZXJzIG9ubHkuPC9zdHJvbmc+IFJlc3VsdHMgbXVzdCBiZSByZXZpZXdlZCBhbmQgc2VhbGVkIGJ5IHRoZSBlbmdpbmVlciBvZiByZWNvcmQgcGVyIElCQyByZXF1aXJlbWVudHMuPC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzEyODE5MzsgUHJvamVjdCBJbmZvcm1hdGlvbjwvaDM+PGRpdiBjbGFzcz0iZzMiPgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlByb2plY3QgTmFtZTwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlk

PSJvYnJhIiBwbGFjZWhvbGRlcj0iUHJvamVjdCAvIExvY2F0aW9uIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5FbmdpbmVlciBvZiBSZWNvcmQ8L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0icmVzcCIgcGxhY2Vob2xkZXI9IlBFIE5hbWUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkxpY2Vuc2UgLyBQRSBTdGFtcCBOby48L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0iY3JlYSIgcGxhY2Vob2xkZXI9IlBFIExpY2Vuc2UgTm8uIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5EYXRlPC9sYWJlbD48aW5wdXQgdHlwZT0iZGF0ZSIgaWQ9ImRhdGFfY2FsYyI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxk

Ij48bGFiZWw+UmV2LjwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJyZXYiIHZhbHVlPSJSMDAiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkdlb3RlY2huaWNhbCBSZXBvcnQ8L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0ibGF1ZG8iIHBsYWNlaG9sZGVyPSJSZXBvcnQgTm8uIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5QZXJtaXQgLyBKb2IgTm8uPC9sYWJlbD48aW5wdXQgdHlwZT0idGV4dCIgaWQ9InBlcm1pdCIgcGxhY2Vob2xkZXI9IiI+PC9kaXY+CjwvZGl2PjwvZGl2PgoKPGRpdiBjbGFzcz0ic2VjIj48aDM+JiMxMjgyMDg7IEdlb21ldHJ5IChVUyBDdXN0b21hcnkpPC9oMz4KPGRpdiBjbGFzcz0ibm90

YS13Ij4mIzEyODIwMzsgUmVjb21tZW5kZWQ6IEIgPSAwLjVIIHRvIDAuN0guIFR5cGljYWwgc3RlbSB0aGlja25lc3MgYXQgYmFzZTogSC8xMiB0byBILzEwLjwvZGl2Pgo8ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+VG90YWwgaGVpZ2h0IEggKGZ0KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkgiIHZhbHVlPSIxMC4wIiBzdGVwPSIwLjUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkVtYmVkbWVudCBIZW0gKGZ0KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkhlbSIgdmFsdWU9IjEuNSIgc3RlcD0iMC4yNSI+PHNwYW4gY2xhc3M9InVuIj5taW46IG1heCgxLjVmdDsgSC8xMCk8L3Nw

YW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+U3RlbSB0b3AgKGZ0KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InRfdG9wbyIgdmFsdWU9IjAuNjciIHN0ZXA9IjAuMDUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlN0ZW0gYmFzZSAoZnQpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0idF9iYXNlIiB2YWx1ZT0iMS4wIiBzdGVwPSIwLjA1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Gb290aW5nIHdpZHRoIEIgKGZ0KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkIiIHZhbHVlPSI3LjAiIHN0ZXA9IjAuNSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+VG9l

IEIxIChmdCk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJCMSIgdmFsdWU9IjEuMzMiIHN0ZXA9IjAuMjUiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkZvb3RpbmcgZGVwdGggaGYgKGZ0KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImhzIiB2YWx1ZT0iMS4xNyIgc3RlcD0iMC4xIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5CYWNrZmlsbCBzbG9wZSAmIzk0NjsgKGRlZyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJiZXRhIiB2YWx1ZT0iMCIgc3RlcD0iMSIgbWluPSIwIiBtYXg9IjMwIj48L2Rpdj4KPC9kaXY+PC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzExMDE1OyYjNjUw

Mzk7IExvYWRzPC9oMz48ZGl2IGNsYXNzPSJnNCI+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+U3VyY2hhcmdlIHR5cGU8L2xhYmVsPjxzZWxlY3QgaWQ9InRpcG9fc2MiPgogICAgPG9wdGlvbiB2YWx1ZT0idW5pZm9ybWUiPlVuaWZvcm0gZGlzdHJpYnV0ZWQ8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9ImNvbmNlbnRyYWRhIj5Qb2ludCBsb2FkIChCb3Vzc2luZXNxKTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0ibmVuaHVtYSI+Tm8gc3VyY2hhcmdlPC9vcHRpb24+CiAgPC9zZWxlY3Q+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+cSAocHNmKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InEiIHZhbHVlPSIyMDAiIHN0

ZXA9IjUwIiBtaW49IjAiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlBvaW50IGxvYWQgUCAobGIvZnQpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iUF9jb25jIiB2YWx1ZT0iMCIgc3RlcD0iMTAwIiBtaW49IjAiPjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkRpc3RhbmNlIGQgKGZ0KTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImRpc3Rfc2MiIHZhbHVlPSIwIiBzdGVwPSIwLjUiIG1pbj0iMCI+PC9kaXY+CjwvZGl2PjwvZGl2PgoKPGRpdiBjbGFzcz0ic2VjIj48aDM+JiMxMjc3NTc7IEdlb3RlY2huaWNhbCBQYXJhbWV0ZXJzPC9oMz4KPGRpdiBjbGFzcz0ibm90YS13Ij4mIzEyODIwMzsgUGFyYW1l

dGVycyBtdXN0IGJlIG9idGFpbmVkIGZyb20gYSBnZW90ZWNobmljYWwgaW52ZXN0aWdhdGlvbiByZXBvcnQgKEFTVE0gRDE1ODYgU1BUIG9yIHRyaWF4aWFsKS48L2Rpdj4KPGRpdiBjbGFzcz0iZzQiPgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlVTQ1M8L2xhYmVsPjxzZWxlY3QgaWQ9InN1Y3MiPjxvcHRpb24gdmFsdWU9IlNXIj5TVzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNQIj5TUDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNNIiBzZWxlY3RlZD5TTTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNDIj5TQzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9Ik1MIj5NTDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IkNMIj5DTDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9

IkNIIj5DSDwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk42MCBTUFQ8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJuc3B0IiB2YWx1ZT0iMTUiIHN0ZXA9IjEiIG1pbj0iMSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+VW5pdCB3dCAmIzk0NztzIChwY2YpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZ2FtYV9zIiB2YWx1ZT0iMTE1IiBzdGVwPSI1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5GcmljdGlvbiBhbmdsZSAmIzk2NjsgKGRlZyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJwaGkiIHZhbHVlPSIzMCIgc3RlcD0iMSIgbWluPSIxMCIg

bWF4PSI0NSI+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Q29oZXNpb24gYyAocHNmKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImNvZXMiIHZhbHVlPSIwIiBzdGVwPSI1MCIgbWluPSIwIj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5CYXNlIGZyaWN0aW9uICYjOTU2OzwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9Im11IiB2YWx1ZT0iMC41NSIgc3RlcD0iMC4wNSIgbWluPSIwLjIiIG1heD0iMC45Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5XYXRlciB0YWJsZSAoZnQpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iTnciIHZhbHVlPSIwIiBzdGVwPSIwLjUiIG1pbj0iMCI+

PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RHJhaW5hZ2U8L2xhYmVsPjxzZWxlY3QgaWQ9ImRyZW4iPgogICAgPG9wdGlvbiB2YWx1ZT0ib2siPkZpbHRlciBmYWJyaWMvcGlwZSBkcmFpbjwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0id2VlcCI+V2VlcCBob2xlcyAoNTAlIE53KTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0ic2VtIj5ObyBkcmFpbiAoZnVsbCBOdyk8L29wdGlvbj4KICA8L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5ydSAocG9yZSBwcmVzc3VyZSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJydSIgdmFsdWU9IjAiIHN0ZXA9IjAuMDUiIG1pbj0iMCIgbWF4PSIwLjUiPjxzcGFu

IGNsYXNzPSJ1biI+QmlzaG9wOiAwPWRyeTsgMC4zPXR5cGljYWw8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+cWEgc291cmNlPC9sYWJlbD48c2VsZWN0IGlkPSJvcmlnX3EiPgogICAgPG9wdGlvbiB2YWx1ZT0iY2FsY3VsbyI+Q2FsY3VsYXRlIChUZXJ6YWdoaSk8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9ImRpcmV0byI+U3BlY2lmeSBxYSBkaXJlY3RseTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPnFhIChwc2YpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icWFfaW5wIiB2YWx1ZT0iMzAwMCIgc3RlcD0iNTAwIj48c3BhbiBjbGFzcz0idW4iPmlmIGRpcmVjdCBp

bnB1dDwvc3Bhbj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5rcyAocGNpKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImtzIiB2YWx1ZT0iNTAiIHN0ZXA9IjEwIj48c3BhbiBjbGFzcz0idW4iPmNsYXk6MTAtNDA7IHNhbmQ6NDAtMjAwPC9zcGFuPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KCjxkaXYgY2xhc3M9InNlYyI+PGgzPiYjMTI3OTU5OyYjNjUwMzk7IE1hdGVyaWFscyDigJQgQUNJIDMxOC0xOTwvaDM+CjxkaXYgaWQ9ImF2aXNvX2V4cG8iIGNsYXNzPSJub3RhLXIiIHN0eWxlPSJkaXNwbGF5Om5vbmU7Ij48L2Rpdj4KPGRpdiBjbGFzcz0iZzQiPgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkV4cG9zdXJlIGNhdGVnb3J5PC9s

YWJlbD48c2VsZWN0IGlkPSJleHBvIiBvbmNoYW5nZT0idmFsaWRhckV4cG8oKSI+CiAgICA8b3B0aW9uIHZhbHVlPSJGMCIgc2VsZWN0ZWQ+RjAg4oCUIG5vdCBleHBvc2VkIHRvIGZyZWV6ZTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iVzAiPlcwIOKAlCBub3QgaW4gY29udGFjdCB3LyB3YXRlcjwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iVzEiPlcxIOKAlCBpbiBjb250YWN0LCBsb3cgcGVybS48L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9IlcyIj5XMiDigJQgaW4gY29udGFjdCwgYWRkaXRpb25hbDwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iUzEiPlMxIOKAlCBtb2RlcmF0ZSBzdWxmYXRlPC9vcHRpb24+CiAgICA8b3B0aW9uIHZh

bHVlPSJTMiI+UzIg4oCUIHNldmVyZSBzdWxmYXRlPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSJDMSI+QzEg4oCUIGxvdyBjaGxvcmlkZTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iQzIiPkMyIOKAlCBtb2RlcmF0ZSBjaGxvcmlkZTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPmYnYyAocHNpKTwvbGFiZWw+PHNlbGVjdCBpZD0iZmNrIiBvbmNoYW5nZT0idmFsaWRhckV4cG8oKSI+CiAgICA8b3B0aW9uIHZhbHVlPSIzMDAwIj4zMDAwIHBzaTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjQwMDAiIHNlbGVjdGVkPjQwMDAgcHNpPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSI1MDAwIj41MDAwIHBz

aTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjYwMDAiPjYwMDAgcHNpPC9vcHRpb24+CiAgPC9zZWxlY3Q+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+ZnkgKHBzaSk8L2xhYmVsPjxzZWxlY3QgaWQ9ImZ5ayI+CiAgICA8b3B0aW9uIHZhbHVlPSI2MDAwMCIgc2VsZWN0ZWQ+R3JhZGUgNjAgKDYwIGtzaSk8L29wdGlvbj4KICAgIDxvcHRpb24gdmFsdWU9Ijc1MDAwIj5HcmFkZSA3NSAoNzUga3NpKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjgwMDAwIj5HcmFkZSA4MCAoODAga3NpKTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPnBoaV9mbGV4dXJlPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBp

ZD0icGhpX2YiIHZhbHVlPSIwLjkwIiBzdGVwPSIwLjA1Ij48c3BhbiBjbGFzcz0idW4iPkFDSSAyMS4yLjE8L3NwYW4+PC9kaXY+CiAgPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+cGhpX3NoZWFyPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icGhpX3YiIHZhbHVlPSIwLjc1IiBzdGVwPSIwLjA1Ij48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DbGVhciBjb3ZlciAoaW4pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iY29iIiB2YWx1ZT0iMy4wIiBzdGVwPSIwLjUiIG1pbj0iMS41Ij48c3BhbiBjbGFzcz0idW4iIGlkPSJjb2JfcmVmX2EiPm1pbiAzIiBiZWxvdyBncmFkZTwvc3Bhbj48L2Rpdj4KICA8ZGl2IGNsYXNzPSJm

bGQiPjxsYWJlbD5TdGVtIGJhciBzaXplPC9sYWJlbD48c2VsZWN0IGlkPSJkaWFtX2YiPjxvcHRpb24gdmFsdWU9IjQiPiM0PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iNSI+IzU8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI2Ij4jNjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjciPiM3PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iOCIgc2VsZWN0ZWQ+Izg8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI5Ij4jOTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjEwIj4jMTA8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Gb290aW5nIGJhciBzaXplPC9sYWJlbD48c2VsZWN0IGlkPSJkaWFtX3MiPjxvcHRpb24gdmFsdWU9IjQiPiM0PC9v

cHRpb24+PG9wdGlvbiB2YWx1ZT0iNSI+IzU8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI2Ij4jNjwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjciPiM3PC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iOCIgc2VsZWN0ZWQ+Izg8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KICA8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Db25jLiB1bml0IHd0IChwY2YpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZ2FtYV9jIiB2YWx1ZT0iMTUwIiBzdGVwPSI1Ij48L2Rpdj4KPC9kaXY+PC9kaXY+Cgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz4mIzk4ODE7JiM2NTAzOTsgU2Vpc21pYyAvIFN0YWJpbGl0eTwvaDM+PGRpdiBjbGFzcz0iZzMiPgogIDxkaXYgY2xhc3M9ImZsZCI+PGxh

YmVsPlNlaXNtaWMgU3MgKGcpPC9sYWJlbD48c2VsZWN0IGlkPSJhZyI+CiAgICA8b3B0aW9uIHZhbHVlPSIwIiBzZWxlY3RlZD5Ob24tc2Vpc21pYyAvIFNEQyBBPC9vcHRpb24+CiAgICA8b3B0aW9uIHZhbHVlPSIwLjEwIj5Tcz0wLjEwZyAoU0RDIEIpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC4yNSI+U3M9MC4yNWcgKFNEQyBDKTwvb3B0aW9uPgogICAgPG9wdGlvbiB2YWx1ZT0iMC41MCI+U3M9MC41MGcgKFNEQyBEKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjEuMDAiPlNzPTEuMDBnIChTREMgRC9FKTwvb3B0aW9uPgogIDwvc2VsZWN0PjwvZGl2PgogIDxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkdsb2JhbCBzdGFiaWxpdHkgQ1MgbWluPC9sYWJlbD48

aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iY3NyX21pbiIgdmFsdWU9IjEuNTAiIHN0ZXA9IjAuMDUiPjxzcGFuIGNsYXNzPSJ1biI+QVNDRSA3IC8gSUJDIG1pbiAxLjU8L3NwYW4+PC9kaXY+CjwvZGl2PjwvZGl2PgoKPGJ1dHRvbiBjbGFzcz0iYnRuLWNhbGMiIG9uY2xpY2s9ImNhbGNBQ0koKSI+JiM5NjU0OyBDQUxDVUxBVEUg4oCUIEFDSSAzMTgtMTkgLyBBU0NFIDctMjI8L2J1dHRvbj4KPGRpdiBpZD0iYWxlcnRhc19kaXYiIHN0eWxlPSJtYXJnaW4tdG9wOjEwcHg7Ij48L2Rpdj4KCjxkaXYgaWQ9InJlc3VsdGFkbyI+CjxkaXYgY2xhc3M9InNlYyIgaWQ9InNlYy1yZXMiPgogIDxoMz4mIzEyODY4MDsgU3RhYmlsaXR5IENoZWNrcyAoQVNEKTwvaDM+PGRp

diBjbGFzcz0ic2VtIiBpZD0ic2VtX2dlbyI+PC9kaXY+CiAgPGgzIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPiYjMTI3OTU5OyYjNjUwMzk7IFN0cnVjdHVyYWwgQ2hlY2tzIChVU0QpPC9oMz48ZGl2IGNsYXNzPSJzZW0iIGlkPSJzZW1fZXN0Ij48L2Rpdj4KICA8aDMgc3R5bGU9Im1hcmdpbi10b3A6OHB4OyI+QWxlcnRhcyAvIEFsZXJ0czwvaDM+PGRpdiBpZD0iYWxlcnRhc19yZXMiPjwvZGl2PgogIDxoMyBzdHlsZT0ibWFyZ2luLXRvcDo4cHg7Ij4mIzEyODIwMzsgQ2FsY3VsYXRpb24gTWVtbyDigJQgQUNJIDMxOCAvIEFTQ0UgNzwvaDM+CiAgPGJ1dHRvbiBjbGFzcz0iYnRuLXBkZiIgb25jbGljaz0id2luZG93LnByaW50KCkiPiYjMTI4NDI0OyYjNjUw

Mzk7IEV4cG9ydCBQREY8L2J1dHRvbj4KICA8ZGl2IGNsYXNzPSJtZW0iIGlkPSJtZW1vcmlhbCI+PC9kaXY+CjwvZGl2PjwvZGl2Pgo8L2Rpdj4KCjxzY3JpcHQ+Ci8vIEFDSSAzMTgtMTkgVGFibGUgMTkuMy4zLjEgXHUyMDE0IG1pbiBmJ2MgYnkgZXhwb3N1cmUKdmFyIEZDS19NSU5fQUNJPXtGMDoyNTAwLFcwOjI1MDAsVzE6MzAwMCxXMjo0MDAwLFMxOjMwMDAsUzI6NDUwMCxDMTozMDAwLEMyOjQwMDB9OwovLyBBQ0kgMzE4LTE5IFRhYmxlIDIwLjYuMS4zIFx1MjAxNCBtaW4gY2xlYXIgY292ZXIKdmFyIENPVl9NSU5fQUNJPXtGMDoyLFcwOjIsVzE6MixXMjozLFMxOjIsUzI6MyxDMToyLEMyOjN9OwoKZnVuY3Rpb24gdmFsaWRhckV4cG8oKXsKICB2YXIg

ZXhwbz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZXhwbycpLnZhbHVlOwogIHZhciBmY2tfcHNpPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZmNrJykudmFsdWU7CiAgdmFyIGNvYl9pbj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvYicpLnZhbHVlOwogIHZhciBmY19taW49RkNLX01JTl9BQ0lbZXhwb118fDI1MDA7CiAgdmFyIGNvdl9taW49Q09WX01JTl9BQ0lbZXhwb118fDI7CiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvYl9yZWZfYScpLnRleHRDb250ZW50PWV4cG8rJzogbWluIGNvdmVyICcrY292X21pbisnaW4sIG1pbiBmXCdjICcrZmNfbWluKydwc2kgKEFDSSAzMTgtMTkpJzsKICB2YXIgZGl2PWRvY3VtZW50LmdldEVsZW1lbnRC

eUlkKCdhdmlzb19leHBvJyksbXNncz1bXTsKICBpZihmY2tfcHNpPGZjX21pbikgbXNncy5wdXNoKCJmJ2M9IitmY2tfcHNpKyJwc2kgYmVsb3cgbWluICIrZmNfbWluKyJwc2kgZm9yICIrZXhwbysiIChBQ0kgMzE4LTE5IFRhYmxlIDE5LjMuMy4xKSIpOwogIGlmKGNvYl9pbjxjb3ZfbWluKSBtc2dzLnB1c2goIkNvdmVyICIrY29iX2luKyJpbiBiZWxvdyBtaW4gIitjb3ZfbWluKyJpbiBmb3IgIitleHBvKyIgKEFDSSAzMTgtMTkgVGFibGUgMjAuNi4xLjMpIik7CiAgaWYobXNncy5sZW5ndGgpe2Rpdi5zdHlsZS5kaXNwbGF5PSdibG9jayc7ZGl2LmlubmVySFRNTD1tc2dzLmpvaW4oJzxicj4nKTt9CiAgZWxzZSBkaXYuc3R5bGUuZGlzcGxheT0nbm9uZSc7

Cn0KCmZ1bmN0aW9uIHRvUmFkKGQpe3JldHVybiBkKk1hdGguUEkvMTgwO30KZnVuY3Rpb24gZm10KHYsZCl7ZD0oZD09PXVuZGVmaW5lZCk/MzpkO3JldHVybiBOdW1iZXIodikudG9GaXhlZChkKTt9Cgp2YXIgQkFSU19VUz17NDowLjIwLDU6MC4zMSw2OjAuNDQsNzowLjYwLDg6MC43OSw5OjEuMDAsMTA6MS4yNywxMToxLjU2fTsKZnVuY3Rpb24gc0JhclVTKEFzX2luMl9mdCxwcmVmKXsKICB2YXIgc2l6ZXM9WzQsNSw2LDcsOCw5LDEwLDExXTsKICBmb3IodmFyIGk9MDtpPHNpemVzLmxlbmd0aDtpKyspe3ZhciBuPXNpemVzW2ldO2lmKHByZWYmJm4hPXByZWYpY29udGludWU7dmFyIGE9QkFSU19VU1tuXSxzcD1NYXRoLmZsb29yKGEvQXNfaW4yX2Z0KjEy

KTtpZihzcD49NiYmc3A8PTE4KXJldHVybiB7dHh0OicjJytuKydAJytNYXRoLm1pbihzcCwxOCkrJ2luJyxhcmVhOmEqMTIvTWF0aC5taW4oc3AsMTgpLG51bTpufTt9CiAgZm9yKHZhciBpPTA7aTxzaXplcy5sZW5ndGg7aSsrKXt2YXIgbj1zaXplc1tpXTt2YXIgYT1CQVJTX1VTW25dLHNwPU1hdGguZmxvb3IoYS9Bc19pbjJfZnQqMTIpO2lmKHNwPj02JiZzcDw9MTgpcmV0dXJuIHt0eHQ6JyMnK24rJ0AnK01hdGgubWluKHNwLDE4KSsnaW4nLGFyZWE6YSoxMi9NYXRoLm1pbihzcCwxOCksbnVtOm59O30KICByZXR1cm4ge3R4dDonIzEwQDZpbicsYXJlYTpCQVJTX1VTWzEwXSoyLG51bToxMH07Cn0KCmZ1bmN0aW9uIGJvdXNzaW5lc3FVUyhQLGQsSCl7CiAg

aWYoZDw9MHx8UDw9MCkgcmV0dXJuIHtFaDowLHlhOkgvMn07CiAgcmV0dXJuIHtFaDooUC9NYXRoLlBJKSooSCpkKmQvKGQqZCtIKkgpK01hdGguYXRhbihIL2QpKSx5YTpILzJ9Owp9CgpmdW5jdGlvbiBjYXBhVGV6VVMocGhpX2RlZyxjLGdzLERmLEIpewogIHZhciBwPXRvUmFkKHBoaV9kZWcpLE5xPU1hdGguZXhwKE1hdGguUEkqTWF0aC50YW4ocCkpKk1hdGgucG93KE1hdGgudGFuKE1hdGguUEkvNCtwLzIpLDIpLE5jPShOcS0xKS9NYXRoLnRhbihwKSxOZz0yKihOcSsxKSpNYXRoLnRhbihwKTsKICB2YXIgcTA9Z3MqRGYscXVsdD1jKk5jK3EwKk5xKzAuNSpncypCKk5nOwogIHJldHVybiB7cXVsdDpxdWx0LHFhOnF1bHQvMyxOcTpOcSxOYzpOYyxOZzpO

ZyxxMDpxMH07Cn0KCmZ1bmN0aW9uIGNhbGNBQ0koKXsKICB2YXIgb2JyYT1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnb2JyYScpLnZhbHVlfHwnKG4vYSknOwogIHZhciByZXNwPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXNwJykudmFsdWV8fCcobi9hKSc7CiAgdmFyIGNyZWE9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NyZWEnKS52YWx1ZXx8JyhuL2EpJzsKICB2YXIgZGF0YV9jPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkYXRhX2NhbGMnKS52YWx1ZXx8bmV3IERhdGUoKS50b0lTT1N0cmluZygpLnNsaWNlKDAsMTApOwogIHZhciByZXY9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3JldicpLnZhbHVlfHwnUjAwJzsKICB2YXIgbGF1ZG89ZG9j

dW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2xhdWRvJykudmFsdWV8fCcobi9hKSc7CiAgdmFyIHBlcm1pdD1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncGVybWl0JykudmFsdWV8fCcobi9hKSc7CiAgdmFyIEg9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdIJykudmFsdWUsSGVtPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnSGVtJykudmFsdWU7CiAgdmFyIHRfdG9wPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndF90b3BvJykudmFsdWUsdF9iYXM9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0X2Jhc2UnKS52YWx1ZTsKICB2YXIgQj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0InKS52YWx1ZSxCMT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0IxJyku

dmFsdWU7CiAgdmFyIGhzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnaHMnKS52YWx1ZSxiZXRhPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYmV0YScpLnZhbHVlOwogIHZhciB0aXBvX3NjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0aXBvX3NjJykudmFsdWUscV9zb2I9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdxJykudmFsdWU7CiAgdmFyIFBfY29uYz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ1BfY29uYycpLnZhbHVlLGRpc3Rfc2M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkaXN0X3NjJykudmFsdWU7CiAgdmFyIHN1Y3M9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3N1Y3MnKS52YWx1ZSxuc3B0PStkb2N1bWVudC5nZXRFbGVtZW50

QnlJZCgnbnNwdCcpLnZhbHVlOwogIHZhciBnYW1hX3M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdnYW1hX3MnKS52YWx1ZSxwaGlfZGVnPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncGhpJykudmFsdWU7CiAgdmFyIGNvZXM9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb2VzJykudmFsdWUsbXU9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdtdScpLnZhbHVlOwogIHZhciBOdz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ053JykudmFsdWUsZHJlbj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHJlbicpLnZhbHVlOwogIHZhciBydT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3J1JykudmFsdWU7CiAgdmFyIG9yaWdfcT1kb2N1bWVudC5nZXRF

bGVtZW50QnlJZCgnb3JpZ19xJykudmFsdWUscWFfaW5wPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncWFfaW5wJykudmFsdWU7CiAgdmFyIGtzX3BjaT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2tzJykudmFsdWU7CiAgdmFyIGV4cG89ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2V4cG8nKS52YWx1ZTsKICB2YXIgZmNrX3BzaT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2ZjaycpLnZhbHVlLGZ5a19wc2k9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdmeWsnKS52YWx1ZTsKICB2YXIgcGhpX2Y9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdwaGlfZicpLnZhbHVlLHBoaV92PStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncGhpX3YnKS52YWx1ZTsK

ICB2YXIgY29iX2luPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29iJykudmFsdWUsZ2FtYV9jPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ2FtYV9jJykudmFsdWU7CiAgdmFyIGRpYW1fZj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RpYW1fZicpLnZhbHVlLGRpYW1fcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RpYW1fcycpLnZhbHVlOwogIHZhciBhZz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2FnJykudmFsdWUsQ1NSX01JTj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nzcl9taW4nKS52YWx1ZTsKCiAgdmFyIGFsZXJ0YXM9W107CiAgdmFyIEhlbV9taW49TWF0aC5tYXgoMS41LEgvMTApOwogIGlmKEhlbTxIZW1fbWluKSBhbGVy

dGFzLnB1c2goJ0VNQkVETUVOVDogSGVtPScrZm10KEhlbSwyKSsnZnQgPCBtaW49JytmbXQoSGVtX21pbiwyKSsnZnQgKG1heCgxLjVmdDtILzEwKSknKTsKICB2YXIgQkg9Qi9IOwogIGlmKEJIPDAuNDApIGFsZXJ0YXMucHVzaCgnQi9IPScrZm10KEJILDIpKycgPCAwLjQwIFx1MjAxNCB1bmRlcnNpemVkIGJhc2UgKHR5cGljYWwgMC41SC0wLjdIKScpOwogIGlmKGRyZW49PT0nc2VtJykgYWxlcnRhcy5wdXNoKCdOTyBEUkFJTkFHRSBcdTIwMTQgZnVsbCBoeWRyb3N0YXRpYy4gSUJDIFx1MDBhNzE4MDcgcmVxdWlyZXMgZHJhaW5hZ2UuJyk7CiAgdmFyIEJfY2FsYz1CLUIxLXRfYmFzOwogIGlmKEJfY2FsYzwwLjEpIGFsZXJ0YXMucHVzaCgnR0VPTUVUUlk6

IEhlZWwgQmM9JytmbXQoQl9jYWxjLDIpKydmdCBpbnZhbGlkIFx1MjAxNCBjaGVjayBCLCBCMSwgc3RlbScpOwogIHZhciBmY19taW49RkNLX01JTl9BQ0lbZXhwb118fDI1MDA7CiAgdmFyIGNvdl9taW49Q09WX01JTl9BQ0lbZXhwb118fDI7CiAgaWYoZmNrX3BzaTxmY19taW4pIGFsZXJ0YXMucHVzaCgiTUFURVJJQUw6IGYnYz0iK2Zja19wc2krInBzaSA8IG1pbiAiK2ZjX21pbisicHNpIGZvciAiK2V4cG8rIiAoQUNJIDMxOC0xOSBUYWJsZSAxOS4zLjMuMSkiKTsKICBpZihjb2JfaW48Y292X21pbikgYWxlcnRhcy5wdXNoKCdDT1ZFUjogJytjb2JfaW4rJ2luIDwgbWluICcrY292X21pbisnaW4gZm9yICcrZXhwbysnIChBQ0kgMzE4LTE5IFRhYmxlIDIw

LjYuMS4zKScpOwoKICB2YXIgcGhpPXRvUmFkKHBoaV9kZWcpLGJldGFSPXRvUmFkKGJldGEpLGRlbHRhPXBoaSoyLzM7CiAgdmFyIEthX249TWF0aC5wb3coTWF0aC5zaW4oTWF0aC5QSS8yK3BoaSksMik7CiAgdmFyIEthX2Q9TWF0aC5wb3coTWF0aC5zaW4oTWF0aC5QSS8yKSwyKSpNYXRoLnNpbihNYXRoLlBJLzItZGVsdGEpOwogIHZhciBLYV9zPU1hdGguc3FydChNYXRoLnNpbihwaGkrZGVsdGEpKk1hdGguc2luKHBoaS1iZXRhUikvKE1hdGguc2luKE1hdGguUEkvMi1kZWx0YSkqTWF0aC5zaW4oTWF0aC5QSS8yK2JldGFSKSkpOwogIHZhciBLYT1LYV9uLyhLYV9kKk1hdGgucG93KDErS2FfcywyKSk7CiAgdmFyIEthX3Jhbms9TWF0aC5wb3coTWF0aC50

YW4oTWF0aC5QSS80LXBoaS8yKSwyKTsKICB2YXIgS3A9TWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80K3BoaS8yKSwyKTsKCiAgdmFyIE53X2VmZj1OdzsKICBpZihkcmVuPT09J29rJykgTndfZWZmPTA7CiAgaWYoZHJlbj09PSd3ZWVwJykgTndfZWZmPU53KjAuNTsKICB2YXIgVV9zdWI9MCxVX3lhPTA7CiAgaWYoTndfZWZmPjAmJk53X2VmZjw9SCl7VV9zdWI9MC41KjYyLjQqTndfZWZmKk53X2VmZjtVX3lhPU53X2VmZi8zO30KICB2YXIgRXA9MC41KktwKmdhbWFfcypIZW0qSGVtOwoKICB2YXIgRWFfZz0wLjUqS2EqZ2FtYV9zKkgqSDsKICB2YXIgRWFoX2c9RWFfZypNYXRoLmNvcyhkZWx0YSksRWF2X2c9RWFfZypNYXRoLnNpbihkZWx0YSk7CiAgdmFy

IEVhaF9xPXRpcG9fc2MhPT0nbmVuaHVtYScmJnFfc29iPjA/S2EqcV9zb2IqSCpNYXRoLmNvcyhkZWx0YSk6MDsKICB2YXIgRWF2X3E9dGlwb19zYyE9PSduZW5odW1hJyYmcV9zb2I+MD9LYSpxX3NvYipIKk1hdGguc2luKGRlbHRhKTowOwogIHZhciBibz10aXBvX3NjPT09J2NvbmNlbnRyYWRhJz9ib3Vzc2luZXNxVVMoUF9jb25jLGRpc3Rfc2MsSCk6e0VoOjAseWE6SC8yfTsKICB2YXIgRWFoX2JvPWJvLkVoOwogIHZhciBFYXZfdG90PUVhdl9nK0Vhdl9xOwogIHZhciBIX2Z1c3RlPUgtaHMsdF9tZWQ9KHRfdG9wK3RfYmFzKS8yOwogIHZhciBXX2Y9Z2FtYV9jKnRfbWVkKkhfZnVzdGUseGY9QjErdF9iYXMvMjsKICB2YXIgV19zPWdhbWFfYypCKmhzLHhz

PUIvMjsKICB2YXIgV19zbz1nYW1hX3MqQl9jYWxjKkhfZnVzdGUseHNvPUItQl9jYWxjLzI7CiAgdmFyIFdfcGU9Z2FtYV9zKkIxKkhlbSx4cGU9QjEvMjsKICB2YXIgVj1XX2YrV19zK1dfc28rV19wZStFYXZfdG90OwogIHZhciBNZT1XX2YqeGYrV19zKnhzK1dfc28qeHNvK1dfcGUqeHBlK0Vhdl90b3QqQjsKICB2YXIgTXQ9RWFoX2cqKEgvMykrRWFoX3EqKEgvMikrRWFoX2JvKihILzIpK1Vfc3ViKlVfeWE7CiAgdmFyIEZTb3Q9TWUvTWF0aC5tYXgoTXQsMC4wMDEpOwogIHZhciBGcj1tdSpWK2NvZXMqQixGYT1FYWhfZytFYWhfcStFYWhfYm8rVV9zdWI7CiAgdmFyIEZTc2w9RnIvTWF0aC5tYXgoRmEsMC4wMDEpOwogIHZhciBGU3NsX0VwPShGcitFcCkv

TWF0aC5tYXgoRmEsMC4wMDEpOwogIHZhciB4Uj0oTWUtTXQpL1YsZT1NYXRoLmFicyhCLzIteFIpLEJlZmY9Qi0yKmU7CiAgdmFyIHFfbWF4PVYvQiooMSs2KmUvQikscV9taW49Vi9CKigxLTYqZS9CKTsKICBpZihGU290PDIuMCkgYWxlcnRhcy5wdXNoKCdPVkVSVFVSTklORzogRlNvdD0nK2ZtdChGU290LDMpKycgPCAyLjAgKEFTQ0UgNy0yMiknKTsKICBpZihGU3NsPDEuNSkgYWxlcnRhcy5wdXNoKCdTTElESU5HOiBGU3NsPScrZm10KEZTc2wsMykrJyA8IDEuNScpOwogIGlmKHFfbWluPDApIGFsZXJ0YXMucHVzaCgnQkVBUklORzogcV9taW49JytmbXQocV9taW4sMCkrJ3BzZiA8IDAgXHUyMDE0IHRlbnNpb24gYXQgYmFzZSwgcmVkZXNpZ24gZ2VvbWV0

cnknKTsKICBpZihlPkIvNikgYWxlcnRhcy5wdXNoKCdFQ0NFTlRSSUNJVFk6IGU9JytmbXQoZSwzKSsnZnQgPiBCLzY9JytmbXQoQi82LDMpKydmdCBcdTIwMTQgcmVzdWx0YW50IG91dHNpZGUga2VybicpOwoKICB2YXIgdGV6PWNhcGFUZXpVUyhwaGlfZGVnLGNvZXMsZ2FtYV9zLEhlbSxCZWZmKTsKICB2YXIgcWFfdXNlPW9yaWdfcT09PSdjYWxjdWxvJz90ZXoucWE6cWFfaW5wOwogIGlmKHFfbWF4PnFhX3VzZSkgYWxlcnRhcy5wdXNoKCdCRUFSSU5HOiBxX21heD0nK2ZtdChxX21heCwwKSsncHNmID4gcWE9JytmbXQocWFfdXNlLDApKydwc2YnKTsKCiAgdmFyIERlbHRhX3E9TWF0aC5tYXgocV9tYXgtZ2FtYV9zKkhlbSwwKTsKICB2YXIgcmVjX2luPXBo

aV9kZWc+PTI1P0RlbHRhX3EvMTAwMCpCZWZmKjEyKjIvbnNwdDpEZWx0YV9xLzEwMDAvKGtzX3BjaSoxNDQpKjEwMDA7CgogIC8vIEJpc2hvcCB3aXRoIHJ1CiAgdmFyIENTX2Jpc2hvcD05OTsKICB2YXIgY2FuZHM9W3t4YzpCKjAuMSx5YzpIKjEuMixSOkgqMS4zfSx7eGM6MCx5YzpIKjEuNSxSOkgqMS42fSx7eGM6QiowLjIseWM6SCxSOkgqMS4xfSx7eGM6LUIqMC4xLHljOkgqMS4zLFI6SCoxLjR9LHt4YzpCKjAuMyx5YzpIKjAuOCxSOkgqMC45NX1dOwogIGZvcih2YXIgY2k9MDtjaTxjYW5kcy5sZW5ndGg7Y2krKyl7CiAgICB2YXIgY2M9Y2FuZHNbY2ldO3ZhciBzcj0wLHNtPTA7dmFyIGRhbmc9TWF0aC5QSS84OwogICAgZm9yKHZhciBmaT0wO2ZpPDg7

ZmkrKyl7dmFyIGFuZz0tTWF0aC5QSS8yK2ZpKmRhbmcrZGFuZy8yO3ZhciB4aTI9Y2MueGMrY2MuUipNYXRoLnNpbihhbmcpO3ZhciB6aT1jYy55Yy1jYy5SKk1hdGguY29zKGFuZyk7aWYoemk8MHx8emk+SCkgY29udGludWU7dmFyIGJpPWNjLlIqZGFuZypNYXRoLmNvcyhhbmcpO3ZhciBoaT1NYXRoLm1heCgwLEgtemkpO3ZhciBXaT1nYW1hX3MqaGkqYmk7dmFyIE5pPVdpKk1hdGguY29zKGFuZyk7dmFyIHVpPXJ1KldpL01hdGgubWF4KGJpLDAuMDAxKSpNYXRoLmNvcyhhbmcpO3NyKz0oY29lcypiaSsoTmktdWkpKk1hdGgudGFuKHBoaSkpO3NtKz1XaSpNYXRoLnNpbihhbmcpO30KICAgIHZhciBjc2k9c3IvTWF0aC5tYXgoc20sMC4wMDEpOwogICAgaWYo

Y3NpPjAmJmNzaTxDU19iaXNob3ApIENTX2Jpc2hvcD1jc2k7CiAgfQogIENTX2Jpc2hvcD1NYXRoLm1heChDU19iaXNob3AsMC41KTsKICBpZihDU19iaXNob3A8Q1NSX01JTikgYWxlcnRhcy5wdXNoKCdHTE9CQUwgU1RBQklMSVRZOiBCaXNob3AgQ1M9JytmbXQoQ1NfYmlzaG9wLDMpKycgPCBtaW49JytDU1JfTUlOLnRvRml4ZWQoMikrJyAoQVNDRSA3IC8gSUJDKScpOwoKICAvLyBTZWlzbWljIE0tTwogIHZhciBGU290X3Npcz0wLEZTc2xfc2lzPTA7CiAgaWYoYWc+MCl7CiAgICB2YXIga2g9YWcqMC41LGRQYWU9MC4zNzUqa2gqZ2FtYV9zKkgqSDsKICAgIEZTb3Rfc2lzPU1lL01hdGgubWF4KE10K2RQYWUqMC42KkgsMC4wMDEpOwogICAgRlNzbF9zaXM9

RnIvTWF0aC5tYXgoRmErZFBhZSwwLjAwMSk7CiAgICBpZihGU290X3NpczwxLjEpIGFsZXJ0YXMucHVzaCgnU0VJU01JQzogRlNvdD0nK2ZtdChGU290X3NpcywzKSsnIDwgMS4xMCAoQVNDRSA3LTIyIFx1MDBhNzExKScpOwogICAgaWYoRlNzbF9zaXM8MS4xKSBhbGVydGFzLnB1c2goJ1NFSVNNSUM6IEZTc2w9JytmbXQoRlNzbF9zaXMsMykrJyA8IDEuMTAnKTsKICB9CgogIC8vIEFDSSBVU0QgXHUyMDE0IHN0ZW0KICB2YXIgZF9zdD10X2JhcyoxMi1jb2JfaW4tQkFSU19VU1tkaWFtX2ZdLzI7CiAgLy8gQXhpYWwgY29tcHJlc3Npb24gaW4gc3RlbTogTnUgPSB3ZWlnaHQgb2Ygc3RlbSAoREwpCiAgdmFyIE51X3N0PTEuMipnYW1hX2MqdF9tZWQqSF9mdXN0

ZTsgLy8gbGIvZnQgKGZhY3RvcmVkIERMKQogIHZhciBNdV9zdD0xLjYqKEVhaF9nKihIX2Z1c3RlLzMpK0VhaF9xKihIX2Z1c3RlLzIpK0VhaF9ibyooSF9mdXN0ZS8yKSk7CiAgLy8gTWluIGVjY2VudHJpY2l0eTogdXNlIE11IGFsb25lIChOdSByZWR1Y2VzIHJlcS4gXHUyMDE0IGNvbnNlcnZhdGl2ZSB0byBpZ25vcmUpCiAgdmFyIFJuPU11X3N0KjEyLyhwaGlfZioxMipkX3N0KmRfc3QpOwogIHZhciByaG89MC44NSpmY2tfcHNpL2Z5a19wc2kqKDEtTWF0aC5zcXJ0KE1hdGgubWF4KDEtMipSbi8oMC44NSpmY2tfcHNpKSwwLjAwMDEpKSk7CiAgdmFyIHJob19taW49TWF0aC5tYXgoMypNYXRoLnNxcnQoZmNrX3BzaSkvZnlrX3BzaSwyMDAvZnlrX3BzaSk7

CiAgdmFyIEFzX3N0PXJobyoxMipkX3N0LEFzX21pbl9zdD1yaG9fbWluKjEyKmRfc3QsQXNfdXNlX3N0PU1hdGgubWF4KEFzX3N0LEFzX21pbl9zdCk7CiAgLy8gVCZTIHRyYW5zdmVyc2UKICB2YXIgQXNfdHM9MC4wMDE4KjEyKnRfYmFzKjEyOwogIC8vIERldmVsb3BtZW50IGxlbmd0aCAoc2ltcGxpZmllZCBBQ0kgMjUuNC4yLjMpCiAgdmFyIGxkX3N0PWZ5a19wc2kvKDIwKk1hdGguc3FydChmY2tfcHNpKSkqQkFSU19VU1tkaWFtX2ZdKjEyOwogIC8vIFN0ZW0gc2hlYXIKICB2YXIgVnVfc3Q9MS42KihFYWhfZytFYWhfcStFYWhfYm8pLzEwMDA7IC8vIGtpcHMvZnQKICB2YXIgcGhpVmNfc3Q9cGhpX3YqMipNYXRoLnNxcnQoZmNrX3BzaSkqMTIqZF9zdC8x

MDAwOwogIHZhciBva19jaXNfc3Q9VnVfc3Q8PXBoaVZjX3N0OwogIGlmKCFva19jaXNfc3QpIGFsZXJ0YXMucHVzaCgnU1RFTSBTSEVBUjogVnU9JytmbXQoVnVfc3QsMykrJ2svZnQgPiBwaGlWYz0nK2ZtdChwaGlWY19zdCwzKSsnay9mdCBcdTIwMTQgc3RpcnJ1cHMgcmVxdWlyZWQgKEFDSSAyMi41KScpOwogIHZhciB4ZF9zdD1Bc191c2Vfc3QqZnlrX3BzaS8oMC44NSpmY2tfcHNpKjEyKmRfc3QpOwogIGlmKHhkX3N0PjAuMzc1KSBhbGVydGFzLnB1c2goJ1NURU06IGMvZD0nK2ZtdCh4ZF9zdCwzKSsnID4gMC4zNzUgXHUyMDE0IHRlbnNpb24tY29udHJvbGxlZCBsaW1pdCAoQUNJIDIxLjIuMiknKTsKICAvLyBTbGVuZGVybmVzcwogIHZhciBsYW1iX3N0

PUhfZnVzdGUqMTIvTWF0aC5taW4odF90b3AsdF9iYXMpL01hdGguc3FydCgxMik7CiAgLy8gRm9vdGluZyBcdTIwMTQgaGVlbAogIHZhciBkX2Z0PWhzKjEyLWNvYl9pbi1CQVJTX1VTW2RpYW1fc10vMjsKICB2YXIgV3VfaGVlbD0xLjIqZ2FtYV9zKkhfZnVzdGUrMS42KnFfc29iOwogIHZhciBNdV9oZWVsPVd1X2hlZWwqQl9jYWxjKkJfY2FsYy8yLzEwMDA7IC8vIGtpcC5mdC9mdAogIHZhciBSbl9oPU11X2hlZWwqMTIvKHBoaV9mKjEyKmRfZnQqZF9mdCk7CiAgdmFyIHJob19oPTAuODUqZmNrX3BzaS9meWtfcHNpKigxLU1hdGguc3FydChNYXRoLm1heCgxLTIqUm5faC8oMC44NSpmY2tfcHNpKSwwLjAwMDEpKSk7CiAgdmFyIEFzX2hlZWw9TWF0aC5tYXgo

cmhvX2gqMTIqZF9mdCxBc19taW5fc3QpOwogIC8vIEhlZWwgc2hlYXIKICB2YXIgVnVfaGVlbD1XdV9oZWVsKkJfY2FsYy8xMDAwOyAvLyBraXBzL2Z0CiAgdmFyIHBoaVZjX2Z0PXBoaV92KjIqTWF0aC5zcXJ0KGZja19wc2kpKjEyKmRfZnQvMTAwMDsKICB2YXIgb2tfY2lzX2hlZWw9VnVfaGVlbDw9cGhpVmNfZnQ7CiAgaWYoIW9rX2Npc19oZWVsKSBhbGVydGFzLnB1c2goJ0hFRUwgU0hFQVI6IFZ1PScrZm10KFZ1X2hlZWwsMykrJ2svZnQgPiBwaGlWYz0nK2ZtdChwaGlWY19mdCwzKSsnay9mdCBcdTIwMTQgaW5jcmVhc2UgZm9vdGluZyBkZXB0aCAoQUNJIDIyLjUpJyk7CiAgLy8gRm9vdGluZyBcdTIwMTQgdG9lCiAgdmFyIHFfdG9lPShxX21heCtNYXRo

Lm1heChxX21pbiwwKSkvMjsKICB2YXIgV3VfdG9lPTEuMipxX3RvZS0xLjIqZ2FtYV9jKmhzOwogIHZhciBNdV90b2U9TWF0aC5tYXgoV3VfdG9lLDApKkIxKkIxLzIvMTAwMDsKICB2YXIgUm5fdD1NdV90b2UqMTIvKHBoaV9mKjEyKmRfZnQqZF9mdCk7CiAgdmFyIHJob190PTAuODUqZmNrX3BzaS9meWtfcHNpKigxLU1hdGguc3FydChNYXRoLm1heCgxLTIqUm5fdC8oMC44NSpmY2tfcHNpKSwwLjAwMDEpKSk7CiAgdmFyIEFzX3RvZT1NYXRoLm1heChyaG9fdCoxMipkX2Z0LEFzX21pbl9zdCk7CiAgdmFyIFZ1X3RvZT1NYXRoLm1heChXdV90b2UsMCkqQjEvMTAwMDsKICB2YXIgb2tfY2lzX3RvZT1WdV90b2U8PXBoaVZjX2Z0OwogIGlmKCFva19jaXNfdG9l

KSBhbGVydGFzLnB1c2goJ1RPRSBTSEVBUjogVnU9JytmbXQoVnVfdG9lLDMpKydrL2Z0ID4gcGhpVmM9JytmbXQocGhpVmNfZnQsMykrJ2svZnQgXHUyMDE0IGluY3JlYXNlIGZvb3RpbmcgZGVwdGgnKTsKICB2YXIgbGRfZnQ9ZnlrX3BzaS8oMjAqTWF0aC5zcXJ0KGZja19wc2kpKSpCQVJTX1VTW2RpYW1fc10qMTI7CiAgdmFyIGFzdD1zQmFyVVMoQXNfdXNlX3N0LGRpYW1fZiksYXRzPXNCYXJVUyhBc190cyw0KSxhaD1zQmFyVVMoQXNfaGVlbCxkaWFtX3MpLGF0PXNCYXJVUyhBc190b2UsZGlhbV9zKTsKCiAgZnVuY3Rpb24gc0kobGJsLHZhbCxyZXEsZXgpe3ZhciByPXZhbC9yZXEsY2xzPXI+PTEuMTU/J29rLXMnOihyPj0xPyd3YXJuLXMnOidlcnItcycp

LGljPXI+PTEuMTU/J09LJzoocj49MT8nQVZTJzonTk9LJyk7cmV0dXJuICc8ZGl2IGNsYXNzPSJzaXRlbSAnK2NscysnIj48ZGl2IGNsYXNzPSJzbGJsIj4nK2xibCsnPC9kaXY+PGRpdiBjbGFzcz0ic3ZhbCI+JytpYysnICcrZm10KHZhbCwyKSsnPC9kaXY+PGRpdiBjbGFzcz0ic3JlcSI+bWluOicrZm10KHJlcSwyKSsoZXg/JyAnK2V4OicnKSsnPC9kaXY+PC9kaXY+Jzt9CiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3NlbV9nZW8nKS5pbm5lckhUTUw9CiAgICBzSSgnT3ZlcnR1cm5pbmdcbkZTb3QnLEZTb3QsMi4wKStzSSgnU2xpZGluZ1xuRlNzbCcsRlNzbCwxLjUpKwogICAgc0koJ0JlYXJpbmdcbnE8PXFhJyxxYV91c2UvTWF0aC5tYXgocV9tYXgs

MC4wMSksMS4wLCdxPScrZm10KHFfbWF4LDApKydwc2YnKSsKICAgIHNJKCdFY2NlbnRyaWMuXG5lPD1CLzYnLEIvNi9NYXRoLm1heChlLDAuMDAxKSwxLjAsJ2U9JytmbXQoZSwyKSsnZnQnKSsKICAgIHNJKCdCaXNob3BcbkNTcicsQ1NfYmlzaG9wLENTUl9NSU4pOwogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZW1fZXN0JykuaW5uZXJIVE1MPQogICAgc0koJ1N0ZW0gRmxleC5cbnhkPD0wLjM3NScsMC4zNzUvTWF0aC5tYXgoeGRfc3QsMC4wMDEpLDEuMCwneGQ9JytmbXQoeGRfc3QsMykpKwogICAgc0koJ1N0ZW0gU2hlYXJcblZ1PD1waGlWYycscGhpVmNfc3QvTWF0aC5tYXgoVnVfc3QsMC4wMDEpLDEuMCkrCiAgICBzSSgnRnRnIFNoZWFyXG5IZWVs

K1RvZScscGhpVmNfZnQvTWF0aC5tYXgoTWF0aC5tYXgoVnVfaGVlbCxWdV90b2UpLDAuMDAxKSwxLjApKwogICAgc0koJ0VtYmVkbWVudFxuSGVtPj1taW4nLEhlbS9IZW1fbWluLDEuMCk7CgogIHZhciBhZGl2PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhbGVydGFzX2RpdicpO2FkaXYuaW5uZXJIVE1MPScnOwogIGFsZXJ0YXMuZm9yRWFjaChmdW5jdGlvbihhKXthZGl2LmlubmVySFRNTCs9JzxkaXYgY2xhc3M9ImFsZXJ0YSI+JythKyc8L2Rpdj4nO30pOwoKICB2YXIgU0VQPSc9Jy5yZXBlYXQoNTYpOwogIHZhciBtZW09JzxoND4nK1NFUCsnPC9oND4nOwogIG1lbSs9J0NBTENVTEFUSU9OIE1FTU8gXHUyMDE0IFJFVEFJTklORyBXQUxMIFx1MjAxNCBS

RUlORk9SQ0VEIENPTkNSRVRFXG5BQ0kgMzE4LTE5IHwgQVNDRSA3LTIyIHwgSUJDIDIwMjFcbic7CiAgbWVtKz0nPGg0PicrU0VQKyc8L2g0Pic7CiAgbWVtKz0nUHJvamVjdCAgIDogJytvYnJhKydcbkVPUiAgICAgICA6ICcrcmVzcCsnXG5QRSBMaWNlbnNlOiAnK2NyZWErJ1xuRGF0ZS9SZXYgIDogJytkYXRhX2MrJyAvICcrcmV2Kydcbkdlb3RlY2ggICA6ICcrbGF1ZG8rJyAgUGVybWl0OiAnK3Blcm1pdCsnXG5cbic7CgogIG1lbSs9JzxoND4xLiBHRU9NRVRSWTwvaDQ+JzsKICBtZW0rPScgIEg9JytIKydmdCAgSGVtPScrSGVtKydmdCBbbWluPScrZm10KEhlbV9taW4sMikrJ2Z0ICcrKEhlbT49SGVtX21pbj8nT0snOidGQUlMJykrJ11cbic7CiAgbWVt

Kz0nICBCPScrQisnZnQgQi9IPScrZm10KEJILDIpKycgIEIxPScrQjErJ2Z0ICBIZWVsPScrZm10KEJfY2FsYywyKSsnZnQgIGhmPScraHMrJ2Z0XG4nOwogIG1lbSs9JyAgU3RlbTogdG9wPScrdF90b3ArJ2Z0IGJhc2U9Jyt0X2JhcysnZnQgIGJldGE9JytiZXRhKydkZWdcblxuJzsKCiAgbWVtKz0nPGg0PjIuIEdFT1RFQ0hOSUNBTCBQQVJBTUVURVJTPC9oND4nOwogIG1lbSs9JyAgVVNDUz0nK3N1Y3MrJyAgTjYwPScrbnNwdCsnICBncz0nK2dhbWFfcysncGNmICBwaGk9JytwaGlfZGVnKydkZWcgIGM9Jytjb2VzKydwc2Zcbic7CiAgbWVtKz0nICBtdT0nK211KycgIE53PScrTncrJ2Z0ICBOd19lZmY9JytmbXQoTndfZWZmLDIpKydmdCAgRHJhaW5hZ2U6

ICcrZHJlbisnXG4nOwogIG1lbSs9JyAgcnU9JytydSsnICBrcz0nK2tzX3BjaSsncGNpXG4nOwogIGlmKE53X2VmZj4wKSBtZW0rPScgIFUgPSAwLjUqZ3cqTndfZWZmXjIgPSAnK2ZtdChVX3N1YiwxKSsnIGxiL2Z0IEAgeWE9JytmbXQoVV95YSwyKSsnZnRcbic7CiAgbWVtKz0nXG4nOwoKICBtZW0rPSc8aDQ+My4gQkVBUklORyBDQVBBQ0lUWSBcdTIwMTQgVEVSWkFHSEk8L2g0Pic7CiAgbWVtKz0iICBCJz0iK2ZtdChCZWZmLDMpKydmdCAgRGY9JytIZW0rJ2Z0XG4nOwogIG1lbSs9JyAgTnE9JytmbXQodGV6Lk5xLDMpKycgIE5jPScrZm10KHRlei5OYywzKSsnICBOZz0nK2ZtdCh0ZXouTmcsMykrJ1xuJzsKICBtZW0rPScgIHF1bHQ9JytmbXQodGV6LnF1

bHQsMCkrJ3BzZiAgcWE9cXVsdC8zPScrZm10KHRlei5xYSwwKSsncHNmICBxYV91c2VkPScrZm10KHFhX3VzZSwwKSsncHNmXG5cbic7CgogIG1lbSs9JzxoND40LiBNQVRFUklBTFMgXHUyMDE0IEFDSSAzMTgtMTk8L2g0Pic7CiAgbWVtKz0nICBFeHBvc3VyZTogJytleHBvKyJcbiI7CiAgbWVtKz0iICBmJ2MgPSAiK2Zja19wc2krIiBwc2kgW21pbiAiK2ZjX21pbisncHNpIGZvciAnK2V4cG8rJyAnKyhmY2tfcHNpPj1mY19taW4/J09LJzonRkFJTCcpKyddXG4nOwogIG1lbSs9JyAgZnkgID0gJytmeWtfcHNpKycgcHNpXG4nOwogIG1lbSs9JyAgcGhpX2Y9JytwaGlfZisnICBwaGlfdj0nK3BoaV92Kydcbic7CiAgbWVtKz0nICBDb3ZlciA9ICcrY29iX2lu

KycgaW4gW21pbiAnK2Nvdl9taW4rJ2luIGZvciAnK2V4cG8rJyAnKyhjb2JfaW4+PWNvdl9taW4/J09LJzonRkFJTCcpKyddXG4nOwogIG1lbSs9JyAgZ2FtbWFfYyA9ICcrZ2FtYV9jKycgcGNmXG5cbic7CgogIG1lbSs9JzxoND41LiBFQVJUSCBQUkVTU1VSRSBcdTIwMTQgQ09VTE9NQiArIFJBTktJTkUgUkVGRVJFTkNFPC9oND4nOwogIG1lbSs9JyAgZGVsdGEgPSAyLzMqcGhpID0gJytmbXQoZGVsdGEqMTgwL01hdGguUEksMikrJ2RlZ1xuJzsKICBtZW0rPScgIEthIChDb3Vsb21iLCB1c2VkKSA9ICcrZm10KEthLDQpKydcbic7CiAgbWVtKz0nICBLYSAoUmFua2luZSwgcmVmLikgPSB0YW5eMig0NS1waGkvMikgPSAnK2ZtdChLYV9yYW5rLDQpKydcbic7

CiAgbWVtKz0nICBLcCAoUmFua2luZSkgICAgICAgPSB0YW5eMig0NStwaGkvMikgPSAnK2ZtdChLcCw0KSsnICBbcGFzc2l2ZV1cblxuJzsKICBtZW0rPScgIFBhKHNvaWwpID0gMC41KkthKmdzKkheMiA9ICcrZm10KEVhX2csMSkrJyBsYi9mdCAgRWFoPScrZm10KEVhaF9nLDEpKycgQCBILzM9JytmbXQoSC8zLDIpKydmdFxuJzsKICBtZW0rPScgIFBhKHN1cmNoKT0gS2EqcSpIICAgICAgICA9ICcrZm10KEthKnFfc29iKkgsMSkrJyBsYi9mdCAgRWFoPScrZm10KEVhaF9xLDEpKycgQCBILzJcbic7CiAgaWYoTndfZWZmPjApIG1lbSs9JyAgVShoeWRyb3N0KSA9ICcrZm10KFVfc3ViLDEpKycgbGIvZnQgQCBOdy8zPScrZm10KFVfeWEsMikrJ2Z0XG4nOwog

IG1lbSs9JyAgRXAocGFzc2l2ZSxub3QgdXNlZCkgPSAwLjUqS3AqZ3MqSGVtXjIgPSAnK2ZtdChFcCwxKSsnIGxiL2Z0XG4nOwogIG1lbSs9JyAgLT4gSW5jbHVkaW5nIEVwIHdvdWxkIGluY3JlYXNlIEZTc2wgZnJvbSAnK2ZtdChGU3NsLDMpKycgdG8gJytmbXQoRlNzbF9FcCwzKSsnIFtpbmZvcm1hdGl2ZV1cblxuJzsKCiAgbWVtKz0nPGg0PjYuIFNUQUJJTElUWSBDSEVDS1MgKEFTRCBcdTIwMTQgdW5mYWN0b3JlZCk8L2g0Pic7CiAgbWVtKz0nICBTVU1fVj0nK2ZtdChWLDEpKycgbGIvZnQgIFNVTV9NUj0nK2ZtdChNZSwxKSsnIGxiLmZ0L2Z0ICBTVU1fTU89JytmbXQoTXQsMSkrJyBsYi5mdC9mdFxuJzsKICBtZW0rPScgIEZTb3QgPSBTVU1fTVIvU1VN

X01PID0gJytmbXQoRlNvdCwzKSsnICA+PSAyLjAgICcrKEZTb3Q+PTI/J09LJzonRkFJTCcpKydcbic7CiAgbWVtKz0nICBGU3NsID0gRnIvRmEgPSAnK2ZtdChGU3NsLDMpKycgID49IDEuNSAgJysoRlNzbD49MS41PydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgeFI9JytmbXQoeFIsMykrJ2Z0ICBlPScrZm10KGUsMykrJ2Z0ICBCLzY9JytmbXQoQi82LDMpKydmdCAgJysoZTw9Qi82PydJTiBLRVJOJzonT1VUIE9GIEtFUk4nKSsnXG4nOwogIG1lbSs9IiAgQic9IitmbXQoQmVmZiwzKSsnZnRcbic7CiAgbWVtKz0nICBxX21heD0nK2ZtdChxX21heCwwKSsncHNmICBxX21pbj0nK2ZtdChxX21pbiwwKSsncHNmICBxYT0nK2ZtdChxYV91c2UsMCkrJ3Bz

ZiAgJysocV9tYXg8PXFhX3VzZT8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIFNldHRsZW1lbnQgZXN0aW1hdGU6IH4gJytmbXQocmVjX2luLDMpKycgaW4gIChmdWxsIGFuYWx5c2lzIHBlciBBU0NFIDQwIHJlcXVpcmVkKVxuXG4nOwoKICBtZW0rPSc8aDQ+Ny4gR0xPQkFMIFNUQUJJTElUWSBcdTIwMTQgQklTSE9QIFNJTVBMSUZJRUQgKEFTQ0UgNyAvIElCQyByZXEuKTwvaDQ+JzsKICBtZW0rPScgIDUtY2lyY2xlIHNlYXJjaCAgcnU9JytydSsnXG4nOwogIG1lbSs9JyAgQ1NfQmlzaG9wID0gJytmbXQoQ1NfYmlzaG9wLDMpKycgID49ICcrQ1NSX01JTi50b0ZpeGVkKDIpKycgICcrKENTX2Jpc2hvcD49Q1NSX01JTj8nT0snOidGQUlMJykrJ1xuJzsK

ICBtZW0rPScgIE5PVEU6IEZ1bGwgQmlzaG9wL1NwZW5jZXIgYW5hbHlzaXMgd2l0aCBHZW9TdHVkaW8vUGxheGlzIHJlcXVpcmVkIGZvciBDRHMuXG5cbic7CgogIGlmKGFnPjApewogICAgbWVtKz0nPGg0PjguIFNFSVNNSUMgXHUyMDE0IE1PTk9OT0JFLU9LQUJFIChBU0NFIDctMjIgXHUwMGE3MTEpPC9oND4nOwogICAgbWVtKz0nICBTcz0nK2FnKydnICBraH4wLjVTcz0nK2ZtdChhZyowLjUsMykrJ2dcbic7CiAgICBtZW0rPScgIERlbHRhUGFlIH4gMC4zNzUqa2gqZ3MqSF4yID0gJytmbXQoMC4zNzUqYWcqMC41KmdhbWFfcypIKkgsMCkrJyBsYi9mdCBAIDAuNkhcbic7CiAgICBtZW0rPScgIEZTb3Qoc2Vpcyk9JytmbXQoRlNvdF9zaXMsMykrJyAgRlNz

bChzZWlzKT0nK2ZtdChGU3NsX3NpcywzKSsnICBbbWluIDEuMTBdXG5cbic7CiAgfQoKICBtZW0rPSc8aDQ+OS4gU1RFTSBERVNJR04gXHUyMDE0IEFDSSAzMTgtMTkgKFVTRCk8L2g0Pic7CiAgbWVtKz0iICBmJ2M9IitmY2tfcHNpKydwc2kgIGZ5PScrZnlrX3BzaSsncHNpXG4nOwogIG1lbSs9JyAgQXhpYWwgY29tcHJlc3Npb24gKHNlbGYtd2VpZ2h0KTogTnU9MS4yKmdjKnRtZWQqSGYgPSAnK2ZtdChOdV9zdCwxKSsnIGxiL2Z0XG4nOwogIG1lbSs9JyAgLT4gQ29uc2VydmF0aXZlbHksIGRpbWVuc2lvbiBmb3IgZmxleHVyZSBhbG9uZSAoTnUgcmVkdWNlcyByZXF1aXJlbWVudClcblxuJzsKICBtZW0rPScgIE11ID0gMS42KihFYWgqSGYvMytFYWhfcSpI

Zi8yKSA9ICcrZm10KE11X3N0LDEpKycgbGIuZnQvZnRcbic7CiAgbWVtKz0nICBkID0gJytmbXQoZF9zdCwyKSsnIGluICAgUm4gPSAnK2ZtdChSbiwxKSsnIHBzaVxuJzsKICBtZW0rPScgIHJobyA9ICcrZm10KHJobyw2KSsnICAgYy9kID0gJytmbXQoeGRfc3QsNCkrKHhkX3N0PjAuMzc1PycgPiAwLjM3NSBXQVJOJzonIDw9IDAuMzc1IE9LJykrJ1xuJzsKICBtZW0rPScgIEFzLHJlcSA9ICcrZm10KEFzX3N0LDMpKycgaW4yL2Z0ICAgQXMsbWluID0gJytmbXQoQXNfbWluX3N0LDMpKycgaW4yL2Z0XG4nOwogIG1lbSs9JyAgQXMsdXNlID0gJytmbXQoQXNfdXNlX3N0LDMpKycgaW4yL2Z0ICAtPiAnK2FzdC50eHQrJ1xuJzsKICBtZW0rPScgIFQmUyAodHJh

bnN2ZXJzZSwgZWEuIGZhY2UpOiAnK2ZtdChBc190cywzKSsnIGluMi9mdCAtPiAnK2F0cy50eHQrJyAoQUNJIDI0LjQuMy4yKVxuJzsKICBtZW0rPScgIERldmVsb3BtZW50IGxlbmd0aCBsZCA+PSAnK2ZtdChsZF9zdCwxKSsnIGluID0gJytmbXQobGRfc3QvMTIsMikrJyBmdCAgKEFDSSAyNS40LjIuMylcbic7CiAgbWVtKz0nICBWdT0nK2ZtdChWdV9zdCwzKSsnay9mdCAgcGhpVmM9JytmbXQocGhpVmNfc3QsMykrJ2svZnQgICcrKG9rX2Npc19zdD8nTm8gc3RpcnJ1cHMnOidTVElSUlVQUyBSRVFVSVJFRCcpKydcblxuJzsKCiAgbWVtKz0nPGg0PjEwLiBGT09USU5HIERFU0lHTiBcdTIwMTQgQUNJIDMxOC0xOTwvaDQ+JzsKICBtZW0rPScgIGRfZnRnID0g

JytmbXQoZF9mdCwyKSsnIGluXG5cbic7CiAgbWVtKz0nICBIRUVMIChib3R0b20gcmVpbmZvcmNlbWVudCk6XG4nOwogIG1lbSs9JyAgICBXdSA9IDEuMipncypIZiArIDEuNipxID0gJytmbXQoV3VfaGVlbCwxKSsnIHBzZlxuJzsKICBtZW0rPScgICAgTXUgPSBXdSpCY14yLzIgPSAnK2ZtdChNdV9oZWVsLDMpKycga2lwLmZ0L2Z0XG4nOwogIG1lbSs9JyAgICBBcyx1c2UgPSAnK2ZtdChBc19oZWVsLDMpKycgaW4yL2Z0ICAtPiAnK2FoLnR4dCsnXG4nOwogIG1lbSs9JyAgICBWdSA9IFd1KkJjID0gJytmbXQoVnVfaGVlbCwzKSsnay9mdCAgcGhpVmMgPSAnK2ZtdChwaGlWY19mdCwzKSsnay9mdCAgJysob2tfY2lzX2hlZWw/J09LJzonRkFJTCcpKydcbic7

CiAgbWVtKz0nICAgIERldmVsb3BtZW50IGxlbmd0aCBsZCA+PSAnK2ZtdChsZF9mdCwxKSsnIGluICAoQUNJIDI1LjQuMi4zKVxuXG4nOwogIG1lbSs9JyAgVE9FICh0b3AgcmVpbmZvcmNlbWVudCBcdTIwMTQgbmV0IHVwd2FyZCByZWFjdGlvbik6XG4nOwogIG1lbSs9JyAgICBxX3RvZV9hdmcgPSAnK2ZtdChxX3RvZSwwKSsnIHBzZiAgIFd1X25ldCA9ICcrZm10KFd1X3RvZSwxKSsnIHBzZlxuJzsKICBtZW0rPScgICAgTXUgPSBXdV9uZXQqQjFeMi8yID0gJytmbXQoTXVfdG9lLDMpKycga2lwLmZ0L2Z0XG4nOwogIG1lbSs9JyAgICBBcyx1c2UgPSAnK2ZtdChBc190b2UsMykrJyBpbjIvZnQgIC0+ICcrYXQudHh0KycgKHRvcCBmYWNlKVxuJzsKICBtZW0r

PScgICAgVnUgPSBXdSpCMSA9ICcrZm10KFZ1X3RvZSwzKSsnay9mdCAgcGhpVmMgPSAnK2ZtdChwaGlWY19mdCwzKSsnay9mdCAgJysob2tfY2lzX3RvZT8nT0snOidGQUlMJykrJ1xuXG4nOwogIG1lbSs9JyAgVFJBTlNWRVJTRSAoZGlzdHJpYnV0aW9uL3RlbXBlcmF0dXJlIFx1MjAxNCBBQ0kgMjQuNC4zLjIgLyA3LjYuMSk6XG4nOwogIG1lbSs9JyAgICBBcyA+PSAwLjAwMTgqYipoID0gJytmbXQoQXNfdHMsMykrJyBpbjIvZnQgIC0+ICcrYXRzLnR4dCsnIGVhY2ggZmFjZVxuXG4nOwoKICBtZW0rPSc8aDQ+MTEuIFJFSU5GT1JDRU1FTlQgU0NIRURVTEU8L2g0Pic7CiAgbWVtKz0nICBTVEVNIDogJythc3QudHh0KycgdmVydC4gKG1haW4pICsgJythdHMu

dHh0KycgaG9yaXouIChUJlMpICBsZD49JytmbXQobGRfc3QvMTIsMikrJ2Z0XG4nOwogIG1lbSs9JyAgSEVFTCA6ICcrYWgudHh0KycgYm90dG9tIGxvbmdpdHVkaW5hbCAgbGQ+PScrZm10KGxkX2Z0LzEyLDIpKydmdFxuJzsKICBtZW0rPScgIFRPRSAgOiAnK2F0LnR4dCsnIHRvcCBsb25naXR1ZGluYWxcbic7CiAgbWVtKz0nICBUUkFOU1Y6ICcrYXRzLnR4dCsnIGVhLiBmYWNlIChzaHJpbmthZ2UpXG5cbic7CgogIG1lbSs9JzxoND4xMi4gU1VNTUFSWTwvaDQ+JzsKICBtZW0rPScgIE92ZXJ0dXJuaW5nIEZTb3QgOiAnK2ZtdChGU290LDMpKycgPj0gMi4wICAnKyhGU290Pj0yPydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgU2xpZGluZyBGU3NsICAg

ICA6ICcrZm10KEZTc2wsMykrJyA+PSAxLjUgICcrKEZTc2w+PTEuNT8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIEJlYXJpbmcgcWEgICAgICAgOiBxX21heD0nK2ZtdChxX21heCwwKSsncHNmIDw9IHFhPScrZm10KHFhX3VzZSwwKSsncHNmICAnKyhxX21heDw9cWFfdXNlPydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgRWNjZW50cmljaXR5ICAgICA6IGU9JytmbXQoZSwzKSsnZnQgPD0gQi82PScrZm10KEIvNiwzKSsnZnQgICcrKGU8PUIvNj8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIEVtYmVkbWVudCAgICAgICAgOiBIZW09JytmbXQoSGVtLDIpKydmdCA+PSAnK2ZtdChIZW1fbWluLDIpKydmdCAgJysoSGVtPj1IZW1fbWluPydPSyc6

J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgQmlzaG9wICAgICAgICAgICA6IENTPScrZm10KENTX2Jpc2hvcCwzKSsnID49ICcrQ1NSX01JTi50b0ZpeGVkKDIpKycgICcrKENTX2Jpc2hvcD49Q1NSX01JTj8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIFN0ZW0gZmxleHVyZSAgICAgOiBjL2Q9JytmbXQoeGRfc3QsMykrJyA8PSAwLjM3NSAgJysoeGRfc3Q8PTAuMzc1PydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgU3RlbSBzaGVhciAgICAgICA6IFZ1PScrZm10KFZ1X3N0LDMpKycgPD0gcGhpVmM9JytmbXQocGhpVmNfc3QsMykrJ2svZnQgICcrKG9rX2Npc19zdD8nT0snOidTVElSUlVQUycpKydcbic7CiAgbWVtKz0nICBIZWVsIHNoZWFyICAgICAg

IDogVnU9JytmbXQoVnVfaGVlbCwzKSsnIDw9IHBoaVZjPScrZm10KHBoaVZjX2Z0LDMpKydrL2Z0ICAnKyhva19jaXNfaGVlbD8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIFRvZSBzaGVhciAgICAgICAgOiBWdT0nK2ZtdChWdV90b2UsMykrJyA8PSBwaGlWYz0nK2ZtdChwaGlWY19mdCwzKSsnay9mdCAgJysob2tfY2lzX3RvZT8nT0snOidGQUlMJykrJ1xuJzsKICBpZihhZz4wKSBtZW0rPScgIFNlaXNtaWMgICAgICAgICAgOiBGU290PScrZm10KEZTb3Rfc2lzLDMpKycgRlNzbD0nK2ZtdChGU3NsX3NpcywzKSsnIFttaW4gMS4xMF1cbic7CiAgbWVtKz0nXG4nOwogIGlmKGFsZXJ0YXMubGVuZ3RoKXttZW0rPSc8aDQ+MTMuIEFMRVJUUzwvaDQ+Jzth

bGVydGFzLmZvckVhY2goZnVuY3Rpb24oYSl7bWVtKz0nICBbIV0gJythKydcbic7fSk7bWVtKz0nXG4nO30KICBtZW0rPScnK1NFUCsnXG4nOwogIG1lbSs9J1N0YW5kYXJkczogQUNJIDMxOC0xOSB8IEFTQ0UgNy0yMiB8IElCQyAyMDIxXG4nOwogIG1lbSs9J1Jlc3VsdHMgbXVzdCBiZSByZXZpZXdlZCBhbmQgc2VhbGVkIGJ5IGEgbGljZW5zZWQgcHJvZmVzc2lvbmFsIGVuZ2luZWVyLlxuJzsKICBtZW0rPScnK1NFUCsnXG4nOwoKICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbWVtb3JpYWwnKS5pbm5lckhUTUw9bWVtOwogIHZhciBfYXI9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2FsZXJ0YXNfcmVzJyk7aWYoX2FyKXtfYXIuaW5uZXJIVE1MPWFsZXJ0

YXMubGVuZ3RoP2FsZXJ0YXMubWFwKGZ1bmN0aW9uKGEpe3JldHVybiAnPGRpdiBjbGFzcz0iYWxlcnRhIj5bIV0gJythKyc8L2Rpdj4nO30pLmpvaW4oJycpOic8ZGl2IHN0eWxlPSJiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xvcjp2YXIoLS1va2IpO2JvcmRlci1yYWRpdXM6NXB4O3BhZGRpbmc6OHB4IDEycHg7Zm9udC1zaXplOjExcHg7Ij5TZW0gYWxlcnRhcy48L2Rpdj4nO30KICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0YWRvJykuc3R5bGUuZGlzcGxheT0nYmxvY2snOwogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRhZG8nKS5zY3JvbGxJbnRvVmlldyh7YmVoYXZpb3I6J3Ntb290aCd9KTsKfQp3aW5kb3cub25sb2FkPWZ1bmN0

aW9uKCl7CiAgdmFyIGRjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkYXRhX2NhbGMnKTsKICBpZihkYyYmIWRjLnZhbHVlKSBkYy52YWx1ZT1uZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7CiAgdmFsaWRhckV4cG8oKTsKfTsKPC9zY3JpcHQ+Cg==

PHN0eWxlPjpyb290ey0tYXo6IzFkMzE1NTstLWF6bTojMmU0ZjhhOy0tYXpjOiM0YTdjYzc7LS1kb3I6I2JmOTAwMDstLWRvcmM6I2UwYWEwMDstLWJnOiNmMGYyZjY7LS1iZ3c6I2ZmZjstLWJyZDojYzhkMGUwOy0tdHh0OiMxYTFhMmU7LS10eHRtOiM0YTRhNmE7LS1vazojZDRlZGRhOy0tb2tiOiMxYTdhM2E7LS13YXJuOiNmZmYzY2Q7LS13YXJuYjojODU2NDA0Oy0tZXJyOiNmOGQ3ZGE7LS1lcnJiOiM4NDIwMjk7fSp7Ym94LXNpemluZzpib3JkZXItYm94O21hcmdpbjowO3BhZGRpbmc6MDt9Ym9keXtmb250LWZhbWlseTonSUJNIFBsZXggU2Fucycsc2Fucy1zZXJpZjtiYWNrZ3JvdW5kOnZhcigtLWJnKTtjb2xvcjp2YXIoLS10eHQpO30ud3JhcHttYXgt

d2lkdGg6MTAwMHB4O21hcmdpbjowIGF1dG87cGFkZGluZzoyMHB4IDE2cHg7fS5zZWN7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO2JvcmRlcjoxLjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6OHB4O3BhZGRpbmc6MjBweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zZWMgaDN7Zm9udC1zaXplOjExcHg7Zm9udC13ZWlnaHQ6NzAwO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouN3B4O2NvbG9yOnZhcigtLWF6KTttYXJnaW4tYm90dG9tOjE0cHg7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4O30uc2VjIGgzOjphZnRlcntjb250ZW50OicnO2ZsZXg6MTtoZWlnaHQ6MXB4O2JhY2tncm91bmQ6dmFyKC0t

YnJkKTt9Lmcye2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjtnYXA6MTBweDt9Lmcze2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmciAxZnI7Z2FwOjEwcHg7fS5nNHtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOjFmciAxZnIgMWZyIDFmcjtnYXA6MTBweDt9LmZsZHtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDozcHg7fS5mbGQgbGFiZWx7Zm9udC1zaXplOjEwcHg7Zm9udC13ZWlnaHQ6NjAwO2NvbG9yOnZhcigtLXR4dG0pO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouNXB4O30uZmxkIGlucHV0LC5mbGQgc2VsZWN0e2JvcmRlcjox

LjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6NHB4O3BhZGRpbmc6N3B4IDlweDtmb250LXNpemU6MTJweDtmb250LWZhbWlseTppbmhlcml0O2NvbG9yOnZhcigtLXR4dCk7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO30uZmxkIC51bntmb250LXNpemU6OXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi10b3A6MXB4O30ubm90YXtiYWNrZ3JvdW5kOiNlOGYwZmU7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkIHZhcigtLWF6Yyk7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5ub3RhLXd7YmFja2dyb3VuZDojZmZmM2NkO2JvcmRlci1s

ZWZ0OjNweCBzb2xpZCB2YXIoLS1kb3JjKTtwYWRkaW5nOjdweCAxMXB4O2ZvbnQtc2l6ZToxMHB4O2JvcmRlci1yYWRpdXM6MCA0cHggNHB4IDA7bWFyZ2luLWJvdHRvbToxMHB4O2xpbmUtaGVpZ2h0OjEuNjt9LmJ0bi1jYWxje2JhY2tncm91bmQ6dmFyKC0tYXopO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxM3B4IDI4cHg7Zm9udC1zaXplOjEzcHg7Zm9udC13ZWlnaHQ6NzAwO2N1cnNvcjpwb2ludGVyO3dpZHRoOjEwMCU7bWFyZ2luLXRvcDo2cHg7fS5idG4tcGRme2JhY2tncm91bmQ6dmFyKC0tZG9yYyk7Y29sb3I6I2ZmZjtib3JkZXI6bm9uZTtib3JkZXItcmFkaXVzOjZweDtwYWRkaW5nOjlweCAyMnB4O2Zv

bnQtc2l6ZToxMnB4O2ZvbnQtd2VpZ2h0OjcwMDtjdXJzb3I6cG9pbnRlcjttYXJnaW4tdG9wOjEwcHg7fSNyZXN1bHRhZG97ZGlzcGxheTpub25lO21hcmdpbi10b3A6MTZweDt9LnNlbXtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOnJlcGVhdCg4LDFmcik7Z2FwOjZweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zaXRlbXtib3JkZXItcmFkaXVzOjdweDtwYWRkaW5nOjlweCA1cHg7dGV4dC1hbGlnbjpjZW50ZXI7fS5zbGJse2ZvbnQtc2l6ZTo3LjVweDtmb250LXdlaWdodDo3MDA7dGV4dC10cmFuc2Zvcm06dXBwZXJjYXNlO2xldHRlci1zcGFjaW5nOi4zcHg7bWFyZ2luLWJvdHRvbTo0cHg7bGluZS1oZWlnaHQ6MS4zO30uc3ZhbHtmb250LXNp

emU6MTRweDtmb250LXdlaWdodDo3MDA7Zm9udC1mYW1pbHk6J0lCTSBQbGV4IE1vbm8nLG1vbm9zcGFjZTt9LnNyZXF7Zm9udC1zaXplOjdweDttYXJnaW4tdG9wOjJweDtvcGFjaXR5Oi44O30ub2stc3tiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xvcjp2YXIoLS1va2IpO30ud2Fybi1ze2JhY2tncm91bmQ6dmFyKC0td2Fybik7Y29sb3I6dmFyKC0td2FybmIpO30uZXJyLXN7YmFja2dyb3VuZDp2YXIoLS1lcnIpO2NvbG9yOnZhcigtLWVycmIpO30ubWVte2JhY2tncm91bmQ6I2Y4ZjlmYztib3JkZXI6MXB4IHNvbGlkIHZhcigtLWJyZCk7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxOHB4O2ZvbnQtc2l6ZToxMXB4O2xpbmUtaGVpZ2h0OjEuOTtmb250LWZh

bWlseTonSUJNIFBsZXggTW9ubycsbW9ub3NwYWNlO3doaXRlLXNwYWNlOnByZS13cmFwO2NvbG9yOnZhcigtLXR4dCk7bWFyZ2luLXRvcDoxMnB4O30ubWVtIGg0e2ZvbnQtZmFtaWx5OidJQk0gUGxleCBTYW5zJyxzYW5zLXNlcmlmO2ZvbnQtc2l6ZToxMXB4O2ZvbnQtd2VpZ2h0OjcwMDtjb2xvcjp2YXIoLS1heik7bWFyZ2luOjE0cHggMCA0cHg7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgdmFyKC0tYnJkKTtwYWRkaW5nLWJvdHRvbToycHg7fS5hbGVydGF7YmFja2dyb3VuZDojZjhkN2RhO2JvcmRlcjoxcHggc29saWQgI2Y1YzZjYjtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4O2NvbG9yOiM4NDIwMjk7bWFyZ2lu

OjRweCAwO31AbWVkaWEobWF4LXdpZHRoOjcwMHB4KXsuZzMsLmc0e2dyaWQtdGVtcGxhdGUtY29sdW1uczoxZnIgMWZyO30uc2Vte2dyaWQtdGVtcGxhdGUtY29sdW1uczpyZXBlYXQoNCwxZnIpO319QG1lZGlhIHByaW50ey5idG4tY2FsYywuYnRuLXBkZiwuc2VjOm5vdCgjc2VjLXJlcyl7ZGlzcGxheTpub25lIWltcG9ydGFudDt9I3Jlc3VsdGFkb3tkaXNwbGF5OmJsb2NrIWltcG9ydGFudDt9Ym9keXtiYWNrZ3JvdW5kOiNmZmY7fS5tZW17Ym9yZGVyOm5vbmU7cGFkZGluZzowO2ZvbnQtc2l6ZToxMHB4O319PC9zdHlsZT4KPGRpdiBjbGFzcz0id3JhcCI+CjxoMj5NdXJvIGRlIEFycmltbyBlbSBBbHZlbmFyaWEgRXN0cnV0dXJhbCBkZSBCbG9jb3M8L2gy

Pgo8cCBzdHlsZT0iZm9udC1zaXplOjExcHg7Y29sb3I6dmFyKC0tdHh0bSk7bWFyZ2luLWJvdHRvbToxNHB4OyI+TkJSIDE1OTYxLTE6MjAxMSB8IE5CUiA2MTIwOjIwMTkgfCBOQlIgMTE2ODI6MjAwOSB8IE11cm8gZGUgZ3JhdmlkYWRlIOKAlCB2ZXJpZmljYWNvZXMgY29tcGxldGFzPC9wPgo8ZGl2IGNsYXNzPSJub3RhLXciPkFURU5DQU86IERlc3RpbmFkbyBleGNsdXNpdmFtZW50ZSBhIGVuZ2VuaGVpcm9zIGhhYmlsaXRhZG9zLiBIIHJlY29tZW5kYWRvIG1lbm9yIG91IGlndWFsIGEgMywwbSBzZW0gYXJtYWR1cmEuIEFjaW1hIGRpc3NvIGNvbnN1bHRhciBOQlIgMTE2ODIgc2VjYW8gNi4zLjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz5JZGVudGlm

aWNhY2FvPC9oMz48ZGl2IGNsYXNzPSJnMyI+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk9icmE8L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0ib2JyYSIgcGxhY2Vob2xkZXI9Ik5vbWUgZG8gcHJvamV0byI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlJlc3BvbnNhdmVsIFRlY25pY288L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0icmVzcCIgcGxhY2Vob2xkZXI9IkVuZy4gTm9tZSAtIENSRUEvQ0FVIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RGF0YTwvbGFiZWw+PGlucHV0IHR5cGU9ImRhdGUiIGlkPSJkYXRhX2NhbGMiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5SZXZpc2FvPC9sYWJlbD48aW5wdXQg

dHlwZT0idGV4dCIgaWQ9InJldiIgdmFsdWU9IlIwMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkxhdWRvIEdlb3RlY25pY288L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0ibGF1ZG8iIHBsYWNlaG9sZGVyPSJFeDogU0ctMjAyNC0wNDUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5BUlQgLyBSUlQ8L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0iYXJ0IiBwbGFjZWhvbGRlcj0iTnVtZXJvIEFSVCBvdSBSUlQiPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KPGRpdiBjbGFzcz0ic2VjIj48aDM+R2VvbWV0cmlhPC9oMz4KPGRpdiBjbGFzcz0ibm90YSI+UHJvcG9yY2FvIHJlY29tZW5kYWRhOiBCYiBlbnRyZSAwLDVIIGUgMCw3SC4g

QmxvY28gcGFkcmFvIDM5eDE5Y20g4oCUIGRpbWVuc2lvbmFyIGVtIG11bHRpcGxvcyBkZSAwLDE5NW0gKG1laW8gYmxvY28pLjwvZGl2Pgo8ZGl2IGNsYXNzPSJnNCI+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkFsdHVyYSB0b3RhbCBIIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkgiIHZhbHVlPSIyLjUiIHN0ZXA9IjAuMSIgbWluPSIwLjUiIG1heD0iNC4wIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RW1idXRpbWVudG8gSGVtIChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkhlbSIgdmFsdWU9IjAuNSIgc3RlcD0iMC4wNSI+PHNwYW4gY2xhc3M9InVuIj5taW46IG1heChILzEwOyAwLDUwbSk8L3NwYW4+

PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkxhcmd1cmEgYmFzZSBCYiAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJCYiIgdmFsdWU9IjEuNTYiIHN0ZXA9IjAuMTk1Ij48c3BhbiBjbGFzcz0idW4iPm11bHRpcGxvIGRlIDAsMTk1bTwvc3Bhbj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+TGFyZ3VyYSB0b3BvIEJ0IChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9IkJ0IiB2YWx1ZT0iMC4zOSIgc3RlcD0iMC4xOTUiPjxzcGFuIGNsYXNzPSJ1biI+bWluOiAxIGJsb2NvID0gMCwzOW08L3NwYW4+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkluY2xpbi4gZmFjZSB0YXJkb3ogYm0gKGdyYXVzKTwv

bGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImJldGFfbSIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCIgbWF4PSIxNSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkluY2xpbmFjYW8gYXRlcnJvIGIgKGdyYXVzKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImJldGEiIHZhbHVlPSIwIiBzdGVwPSIxIiBtaW49IjAiIG1heD0iMjUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Tb2JyZWNhcmdhIHEgKGtOL20yKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InEiIHZhbHVlPSI1IiBzdGVwPSIxIiBtaW49IjAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5UaXBvIHNvYnJlY2FyZ2E8L2xhYmVs

PjxzZWxlY3QgaWQ9InRpcG9fc2MiPjxvcHRpb24gdmFsdWU9InVuaWZvcm1lIj5EaXN0cmlidWlkYTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9Im5lbmh1bWEiPlNlbSBzb2JyZWNhcmdhPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjwvZGl2PjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz5BbHZlbmFyaWEg4oCUIE5CUiAxNTk2MS0xOjIwMTE8L2gzPgo8ZGl2IGNsYXNzPSJub3RhIj5mayA9IGZwa14wLDg1IHggZmprXjAsMTUgeCAwLDg1IChOQlIgMTU5NjEgZXEuMSkuIEdyYXV0ZWFtZW50byBhdW1lbnRhIGZrIGUgcGVzbyBwcm9wcmlvLjwvZGl2Pgo8ZGl2IGNsYXNzPSJnNCI+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlRpcG8gZGUgYmxvY288L2xhYmVs

PjxzZWxlY3QgaWQ9ImJsb2NvIj48b3B0aW9uIHZhbHVlPSIwLjE0Ij4xNGNtICgzOXgxOXgxNCk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIwLjE5IiBzZWxlY3RlZD4xOWNtICgzOXgxOXgxOSk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIwLjI0Ij4yNGNtICgzOXgxOXgyNCk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIwLjI5Ij4yOWNtICgzOXgxOXgyOSk8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+ZnBrIGJsb2NvIChNUGEpPC9sYWJlbD48c2VsZWN0IGlkPSJmcGsiPjxvcHRpb24gdmFsdWU9IjQiPjQgTVBhPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iNiIgc2VsZWN0ZWQ+NiBNUGE8L29wdGlvbj48b3B0aW9uIHZhbHVl

PSI4Ij44IE1QYTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjEwIj4xMCBNUGE8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+ZmprIGFyZ2FtYXNzYSAoTVBhKTwvbGFiZWw+PHNlbGVjdCBpZD0iZmprIj48b3B0aW9uIHZhbHVlPSI0IiBzZWxlY3RlZD5NNCAoNCBNUGEpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iOCI+TTggKDggTVBhKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjEyIj5NMTIgKDEyIE1QYSk8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RXNwLiBqdW50YSAobW0pPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZXNwX2oiIHZhbHVlPSIxMiIgc3RlcD0iMSIg

bWluPSI4IiBtYXg9IjE1Ij48c3BhbiBjbGFzcz0idW4iPk5CUiAxNTk2MTogMTArLTJtbTwvc3Bhbj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+SW5kaWNlIGRlIHZhemlvcyAoJSk8L2xhYmVsPjxzZWxlY3QgaWQ9InZhemlvcyI+PG9wdGlvbiB2YWx1ZT0iMzAiPjMwJSAoc29saWRvKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjQwIiBzZWxlY3RlZD40MCUgKHBhZHJhbyk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI1MCI+NTAlIChsZXZlKTwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5KdW50YSB2ZXJ0aWNhbCBwcmVlbmNoaWRhPC9sYWJlbD48c2VsZWN0IGlkPSJqdW50YV92Ij48b3B0aW9uIHZhbHVlPSJu

YW8iIHNlbGVjdGVkPk5hbyAoZnZrIHJlZHV6aWRvKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9InNpbSI+U2ltIChmdmsgcGxlbm8pPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkdyYXV0ZWFtZW50bzwvbGFiZWw+PHNlbGVjdCBpZD0iZ3JhdXRlYW1lbnRvIj48b3B0aW9uIHZhbHVlPSJuYW8iIHNlbGVjdGVkPlNlbSBncmF1dGVhbWVudG88L29wdGlvbj48b3B0aW9uIHZhbHVlPSJwYXJjaWFsIj5QYXJjaWFsICg1MCUpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0idG90YWwiPlRvdGFsICgxMDAlKTwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5nYW1tYV9hbHYgKGtOL20zKTwvbGFi

ZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImdhbHYiIHZhbHVlPSIxNCIgc3RlcD0iMC41IiBtaW49IjEwIj48c3BhbiBjbGFzcz0idW4iPmJsb2NvIGNvbmNyZXRvOiAxMi0xNjwvc3Bhbj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RHJlbmFnZW0gdGFyZG96PC9sYWJlbD48c2VsZWN0IGlkPSJkcmVuYWdlbSI+PG9wdGlvbiB2YWx1ZT0iZHJlbm9fYnJpdGEiPkJyaXRhICsgdHVibyBQVkM8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJkcmVub19nZW90ZXh0aWwiPk1hbnRhIGdlb3RleHRpbDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9ImJhcmJhY2FzIj5Tb21lbnRlIGJhcmJhY2FzPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0ic2VtX2RyZW5vIj5TZW0g

ZHJlbmFnZW08L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+QmFyYmFjYXM8L2xhYmVsPjxzZWxlY3QgaWQ9ImJhcmJhY2FzIj48b3B0aW9uIHZhbHVlPSIwLjUsMS4wIj5waGk3NW1tIEAgMSwwbTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjAuNSwxLjUiPnBoaTc1bW0gQCAxLDVtPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC41LDIuMCI+cGhpNzVtbSBAIDIsMG08L29wdGlvbj48b3B0aW9uIHZhbHVlPSIxLDk5Ij5TZW0gKGNhbGN1bGFyIFUpPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjwvZGl2PjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz5QYXJhbWV0cm9zIEdlb3RlY25pY29zPC9oMz48ZGl2IGNsYXNzPSJnNCI+

CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlNVQ1M8L2xhYmVsPjxzZWxlY3QgaWQ9InN1Y3MiPjxvcHRpb24gdmFsdWU9IlNXIj5TVzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNQIj5TUDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNNIiBzZWxlY3RlZD5TTTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IlNDIj5TQzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IkNMIj5DTDwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IkNIIj5DSDwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5OLVNQVCByZWZlcmVuY2lhPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ibnNwdCIgdmFsdWU9IjE1IiBzdGVwPSIxIiBtaW49IjEiPjwvZGl2Pgo8

ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5nYW1tYV9zIChrTi9tMyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJncyIgdmFsdWU9IjE4IiBzdGVwPSIwLjUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5waGkgKGdyYXVzKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InBoaSIgdmFsdWU9IjMwIiBzdGVwPSIxIiBtaW49IjEwIiBtYXg9IjQ1Ij48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+YyAoa04vbTIpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iY29lcyIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPm11IGJhc2U8L2xhYmVsPjxpbnB1dCB0

eXBlPSJudW1iZXIiIGlkPSJtdSIgdmFsdWU9IjAuNTAiIHN0ZXA9IjAuMDUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5zaWdtYV9hZG0gKGtOL20yKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InNpZ2FkbSIgdmFsdWU9IjEyMCIgc3RlcD0iMTAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5PcmlnZW0gc2lnbWFfYWRtPC9sYWJlbD48c2VsZWN0IGlkPSJvcmlnX3EiPjxvcHRpb24gdmFsdWU9ImNhbGN1bG8iPkNhbGN1bGFyIChUZXJ6YWdoaSk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJkaXJldG8iPkluZm9ybWFyIGRpcmV0YW1lbnRlPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVs

Pk53IChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9Ik53IiB2YWx1ZT0iMCIgc3RlcD0iMC4xIiBtaW49IjAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5rcyAoa04vbTMpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ia3MiIHZhbHVlPSIyMDAwMCIgc3RlcD0iMTAwMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlpvbmEgc2lzbWljYSAoYWcvZyk8L2xhYmVsPjxzZWxlY3QgaWQ9ImFnIj48b3B0aW9uIHZhbHVlPSIwIiBzZWxlY3RlZD5OYW8gYXBsaWNhdmVsPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC4wMjUiPmFnPTAsMDI1Zzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjAuMDUiPmFnPTAsMDVnPC9vcHRp

b24+PG9wdGlvbiB2YWx1ZT0iMC4xMCI+YWc9MCwxMGc8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPC9kaXY+PC9kaXY+CjxkaXYgY2xhc3M9InNlYyI+PGgzPkNTIE1pbmltb3Mg4oCUIE5CUiAxMTY4MjwvaDM+PGRpdiBjbGFzcz0iZzMiPgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DUyB0b21iYW1lbnRvIG1pbi48L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJjc3RfbWluIiB2YWx1ZT0iMi4wIiBzdGVwPSIwLjEiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DUyBkZXNsaXphbWVudG8gbWluLjwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImNzZF9taW4iIHZhbHVlPSIxLjUiIHN0ZXA9IjAuMSI+PC9kaXY+CjxkaXYgY2xh

c3M9ImZsZCI+PGxhYmVsPkNTIHJ1cHR1cmEgY2lyY3VsYXIgbWluLjwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImNzcl9taW4iIHZhbHVlPSIxLjUiIHN0ZXA9IjAuMSI+PC9kaXY+CjwvZGl2PjwvZGl2Pgo8YnV0dG9uIGNsYXNzPSJidG4tY2FsYyIgb25jbGljaz0iY2FsY0Jsb2NvTkJSKCkiPkNhbGN1bGFyIE11cm8gZW0gQmxvY28g4oCUIE5CUjwvYnV0dG9uPgo8ZGl2IGlkPSJyZXN1bHRhZG8iPjxkaXYgY2xhc3M9InNlYyIgaWQ9InNlYy1yZXMiPgo8aDM+VmVyaWZpY2Fjb2VzIGRlIEVzdGFiaWxpZGFkZSBlIEFsdmVuYXJpYTwvaDM+CjxkaXYgY2xhc3M9InNlbSIgaWQ9InNlbWFmb3JvIj48L2Rpdj4KPGgzIHN0eWxlPSJtYXJnaW4tdG9w

OjhweDsiPkFsZXJ0YXM8L2gzPjxkaXYgaWQ9ImFsZXJ0YXNfcmVzIj48L2Rpdj4KPGgzIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPk1lbW9yaWFsIGRlIENhbGN1bG88L2gzPgo8YnV0dG9uIGNsYXNzPSJidG4tcGRmIiBvbmNsaWNrPSJ3aW5kb3cucHJpbnQoKSI+RXhwb3J0YXIgUERGPC9idXR0b24+CjxkaXYgY2xhc3M9Im1lbSIgaWQ9Im1lbW9yaWFsIj48L2Rpdj4KPC9kaXY+PC9kaXY+PC9kaXY+CjxzY3JpcHQ+CmZ1bmN0aW9uIHRvUmFkKGQpe3JldHVybiBkKk1hdGguUEkvMTgwO30KZnVuY3Rpb24gZm10KHYsZCl7cmV0dXJuIE51bWJlcih2KS50b0ZpeGVkKGQ9PT11bmRlZmluZWQ/MzpkKTt9CmZ1bmN0aW9uIGNhcGFUZXoocGQsYyxncyxEZixCKXsK

ICB2YXIgcD10b1JhZChwZCksTnE9TWF0aC5leHAoTWF0aC5QSSpNYXRoLnRhbihwKSkqTWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80K3AvMiksMiksTmM9KE5xLTEpL01hdGgudGFuKHApLE5nPTIqKE5xKzEpKk1hdGgudGFuKHApLHEwPWdzKkRmLHF1bHQ9YypOYytxMCpOcSswLjUqZ3MqQipOZzsKICByZXR1cm57cXVsdDpxdWx0LHFhZG06cXVsdC8zLE5xOk5xLE5jOk5jLE5nOk5nfTt9CmZ1bmN0aW9uIGNhbGNCbG9jb05CUigpewogIHZhciBvYnJhPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdvYnJhJykudmFsdWV8fCcobi9pKSc7CiAgdmFyIHJlc3A9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3AnKS52YWx1ZXx8JyhuL2kpJzsKICB2YXIgZGM9

ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RhdGFfY2FsYycpLnZhbHVlfHxuZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7CiAgdmFyIHJldj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmV2JykudmFsdWV8fCdSMDAnOwogIHZhciBsYXVkbz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGF1ZG8nKS52YWx1ZXx8JyhuL2kpJzsKICB2YXIgYXJ0PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhcnQnKS52YWx1ZXx8JyhuL2kpJzsKICB2YXIgSD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0gnKS52YWx1ZTsKICB2YXIgSGVtPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnSGVtJykudmFsdWU7CiAgdmFyIEJiPStkb2N1bWVudC5nZXRFbGVt

ZW50QnlJZCgnQmInKS52YWx1ZTsKICB2YXIgQnQ9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdCdCcpLnZhbHVlOwogIHZhciBiZXRhX209K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdiZXRhX20nKS52YWx1ZTsKICB2YXIgYmV0YT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2JldGEnKS52YWx1ZTsKICB2YXIgcT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3EnKS52YWx1ZTsKICB2YXIgdGlwb19zYz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGlwb19zYycpLnZhbHVlOwogIHZhciBibF90PStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYmxvY28nKS52YWx1ZTsKICB2YXIgZnBrPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZnBrJykudmFsdWU7

CiAgdmFyIGZqaz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2ZqaycpLnZhbHVlOwogIHZhciBlc3Bfaj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2VzcF9qJykudmFsdWU7CiAgdmFyIHZhemlvcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3ZhemlvcycpLnZhbHVlOwogIHZhciBqdW50YV92PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdqdW50YV92JykudmFsdWU7CiAgdmFyIGdyYXV0PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdncmF1dGVhbWVudG8nKS52YWx1ZTsKICB2YXIgZ2Fsdl9iYXNlPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ2FsdicpLnZhbHVlOwogIHZhciBkcmVuYWdlbT1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHJlbmFn

ZW0nKS52YWx1ZTsKICB2YXIgYmFyYlN0cj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYmFyYmFjYXMnKS52YWx1ZS5zcGxpdCgnLCcpOwogIHZhciBzdWNzPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzdWNzJykudmFsdWU7CiAgdmFyIG5zcHQ9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCduc3B0JykudmFsdWU7CiAgdmFyIGdzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ3MnKS52YWx1ZTsKICB2YXIgcGhpX2RlZz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3BoaScpLnZhbHVlOwogIHZhciBjb2VzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29lcycpLnZhbHVlOwogIHZhciBtdT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ211JykudmFs

dWU7CiAgdmFyIHNpZ2FkbV9pbnA9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzaWdhZG0nKS52YWx1ZTsKICB2YXIgb3JpZ19xPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdvcmlnX3EnKS52YWx1ZTsKICB2YXIgTnc9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdOdycpLnZhbHVlOwogIHZhciBrcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2tzJykudmFsdWU7CiAgdmFyIGFnPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWcnKS52YWx1ZTsKICB2YXIgQ1NUX01JTj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NzdF9taW4nKS52YWx1ZTsKICB2YXIgQ1NEX01JTj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NzZF9taW4nKS52YWx1ZTsKICB2

YXIgQ1NSX01JTj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Nzcl9taW4nKS52YWx1ZTsKICB2YXIgYWxlcnRhcz1bXTsKICAvLyBHcmF1dGVhbWVudG86IGFqdXN0YSBwZXNvIGUgZmsKICB2YXIgZ3JhdXRfZmF0b3JfZms9Z3JhdXQ9PT0ndG90YWwnPzEuMTU6KGdyYXV0PT09J3BhcmNpYWwnPzEuMDc6MS4wKTsKICB2YXIgZ2Fsdj1ncmF1dD09PSd0b3RhbCc/Z2Fsdl9iYXNlKzIuMDooZ3JhdXQ9PT0ncGFyY2lhbCc/Z2Fsdl9iYXNlKzEuMDpnYWx2X2Jhc2UpOwogIC8vIEVtYnV0aW1lbnRvIG1pbmltbyBOQlIgMTE2ODIgaXRlbSA1LjQKICB2YXIgSGVtX21pbj1NYXRoLm1heCgwLjUwLEgvMTApOwogIGlmKEhlbTxIZW1fbWluKSBhbGVydGFzLnB1c2go

J0VNQlVUSU1FTlRPOiBIZW09JytmbXQoSGVtLDIpKydtIDwgbWluPScrZm10KEhlbV9taW4sMikrJ20gKE5CUiAxMTY4MiBpdGVtIDUuNCknKTsKICBpZihIPjMuMCkgYWxlcnRhcy5wdXNoKCdBTFRVUkE6IEg9JytIKydtID4gMywwbSBcdTIwMTQgTkJSIDExNjgyIHNlY2FvIDYuMyByZWNvbWVuZGEgY29uY3JldG8gYXJtYWRvIHBhcmEgbXVybyBlbSBibG9jbyBzZW0gYXJtYWR1cmEnKTsKICB2YXIgQkg9QmIvSDsKICBpZihCSDwwLjQwKSBhbGVydGFzLnB1c2goJ1BST1BPUkNBTzogQmIvSD0nK2ZtdChCSCwyKSsnIDwgMCw0MCBcdTIwMTQgYmFzZSBpbnN1ZmljaWVudGUnKTsKICBpZihCdDwwLjM5KSBhbGVydGFzLnB1c2goJ0xBUkdVUkEgVE9QTzogQnQ9

JytmbXQoQnQsMikrJ20gPCAwLDM5bSBcdTIwMTQgbWluaW1vIDEgYmxvY28gKE5CUiAxNTk2MS0xIGl0ZW0gOC4xKScpOwogIGlmKGVzcF9qPDh8fGVzcF9qPjE1KSBhbGVydGFzLnB1c2goJ0pVTlRBOiBlc3Blc3N1cmEgJytlc3BfaisnbW0gZm9yYSBkZSAxMCstMm1tIChOQlIgMTU5NjEtMSBpdGVtIDguMiknKTsKICBpZihkcmVuYWdlbT09PSdzZW1fZHJlbm8nKSBhbGVydGFzLnB1c2goJ0RSRU5BR0VNOiBBVVNFTlRFIFx1MjAxNCByaXNjbyBjcml0aWNvLiBOQlIgMTE2ODIgaXRlbSA1LjYgZXhpZ2Ugc2lzdGVtYSBkZSBkcmVuYWdlbScpOwogIC8vIE5CUiAxNTk2MS0xIGVxLigxKTogZmsgPSBmcGteMCw4NSB4IGZqa14wLDE1IHggMCw4NQogIHZhciBm

YXRvcl9qdW50YT1qdW50YV92PT09J3NpbSc/MS4wOjAuOTA7IC8vIGp1bnRhIHZlcnRpY2FsIG5hbyBwcmVlbmNoaWRhIHJlZHV6IGZ2ayAoTkJSIDE1OTYxIGl0ZW0gNy4yLjIpCiAgdmFyIGZhdG9yX3Zhemlvcz0xLjAtKHZhemlvcy00MCkvMTAwKjAuMTU7CiAgdmFyIGZrX2Jhc2U9TWF0aC5wb3coZnBrLDAuODUpKk1hdGgucG93KGZqaywwLjE1KSowLjg1OwogIHZhciBmaz1ma19iYXNlKmZhdG9yX2p1bnRhKmZhdG9yX3ZhemlvcypncmF1dF9mYXRvcl9mazsKICB2YXIgZmtfbGltPU1hdGgubWluKGZrLDAuNzUqZnBrKTsKICB2YXIgZ2FtbWFfbT0xLjU7IC8vIE5CUiAxNTk2MS0xIGl0ZW0gOS4xCiAgdmFyIGZkPWZrX2xpbS9nYW1tYV9tOwogIC8vIGZ2

ayBOQlIgMTU5NjEtMSBpdGVtIDcuMjogZnZrID0gZnZrMCArIDAsNCpzaWdtYQogIC8vIGZ2azAgPSAwLDEwIE1QYSBzZW0ganVudGEgdmVydGljYWw7IDAsMTUgTVBhIGNvbSBqdW50YSB2ZXJ0aWNhbCBwcmVlbmNoaWRhCiAgdmFyIGZ2azA9anVudGFfdj09PSdzaW0nPzAuMTU6MC4xMDsKICAvLyBFbXB1eG8gXHUyMDE0IFJhbmtpbmUgKGRlbHRhPTAsIGNvbnNlcnZhZG9yIHBhcmEgYWx2ZW5hcmlhIHNlbSBkcmVubykKICB2YXIgcGhpPXRvUmFkKHBoaV9kZWcpOwogIHZhciBLYV9yYW5rPU1hdGgucG93KE1hdGgudGFuKE1hdGguUEkvNC1waGkvMiksMik7CiAgLy8gQ291bG9tYiBjb20gZGVsdGE9cGhpLzMgcGFyYSByZWZlcmVuY2lhCiAgdmFyIGRlbHRh

X2M9cGhpLzM7CiAgdmFyIEthX2NfbnVtPU1hdGgucG93KE1hdGguc2luKE1hdGguUEkvMitwaGkpLDIpOwogIHZhciBLYV9jX2Rlbj1NYXRoLnBvdyhNYXRoLnNpbihNYXRoLlBJLzIpLDIpKk1hdGguc2luKE1hdGguUEkvMi1kZWx0YV9jKSpNYXRoLnBvdygxK01hdGguc3FydChNYXRoLnNpbihwaGkrZGVsdGFfYykqTWF0aC5zaW4ocGhpLXRvUmFkKGJldGEpKS8oTWF0aC5zaW4oTWF0aC5QSS8yLWRlbHRhX2MpKk1hdGguc2luKE1hdGguUEkvMit0b1JhZChiZXRhKSkpKSwyKTsKICB2YXIgS2FfY291bG9tYj1LYV9jX251bS9LYV9jX2RlbjsKICB2YXIgS2E9S2FfcmFuazsgLy8gUmFua2luZSB1dGlsaXphZG8gKGNvbnNlcnZhZG9yKQogIC8vIFN1YnByZXNz

YW8KICB2YXIgTndfZWZmPU53OwogIGlmKGRyZW5hZ2VtPT09J2RyZW5vX2JyaXRhJ3x8ZHJlbmFnZW09PT0nZHJlbm9fZ2VvdGV4dGlsJykgTndfZWZmPTA7CiAgaWYoZHJlbmFnZW09PT0nYmFyYmFjYXMnKSBOd19lZmY9TncqKDEuMC0rYmFyYlN0clswXSk7CiAgdmFyIFVfc3ViPTAsVV95YT0wOwogIGlmKE53X2VmZj4wJiZOd19lZmY8PUgpe1Vfc3ViPTAuNSoxMCpOd19lZmYqTndfZWZmO1VfeWE9TndfZWZmLzM7fQogIC8vIFByZXNzYW8gcGFzc2l2YSBubyBwZSAoTkJSIDExNjgyIGl0ZW0gNS41KSBcdTIwMTQgY2FsY3VsYWRhIG1hcyBOQU8gdXNhZGEgKGNvbnNlcnZhZG9yKQogIHZhciBLcD1NYXRoLnBvdyhNYXRoLnRhbihNYXRoLlBJLzQrcGhpLzIp

LDIpOwogIHZhciBFcD0wLjUqS3AqZ3MqSGVtKkhlbTsKICAvLyBGb3JjYXMKICB2YXIgRWFfZz0wLjUqS2EqZ3MqSCpIOwogIHZhciBFYXZfZz1FYV9nKk1hdGguc2luKHRvUmFkKGJldGFfbSkpOyAvLyBjb21wb25lbnRlIHZlcnRpY2FsIChmYWNlIGluY2xpbmFkYSkKICB2YXIgRWFoX2c9RWFfZypNYXRoLmNvcyh0b1JhZChiZXRhX20pKTsKICB2YXIgRWFfcT10aXBvX3NjIT09J25lbmh1bWEnP0thKnEqSDowOwogIHZhciBFYXZfcT1FYV9xKk1hdGguc2luKHRvUmFkKGJldGFfbSkpOwogIHZhciBFYWhfcT1FYV9xKk1hdGguY29zKHRvUmFkKGJldGFfbSkpOwogIHZhciBFYWg9RWFoX2crRWFoX3ErVV9zdWI7CiAgdmFyIEVhdj1FYXZfZytFYXZfcTsKICAv

LyBHZW9tZXRyaWEgbXVybyB0cmFwZXppbwogIHZhciBBbT0oQmIrQnQpLzIqSDsKICB2YXIgeGNnX3RyYXA9QmIvMyooQmIrMipCdCkvKEJiK0J0KTsKICB2YXIgV209Z2FsdipBbTsgLy8gcGVzbyBtdXJvCiAgdmFyIEJjPUJiLUJ0OyAvLyBkaWZlcmVuY2EgYmFzZS10b3BvCiAgdmFyIFdzPWdzKihCYy8yKSpIOyAvLyBwZXNvIHNvbG8gc29icmUgZGVncmF1CiAgdmFyIHhzPUJiLUJjLzM7CiAgdmFyIFY9V20rV3MrRWF2OyAvLyBmb3JjYSB2ZXJ0aWNhbCB0b3RhbAogIHZhciBNZT1XbSp4Y2dfdHJhcCtXcyp4cytFYXYqQmI7IC8vIG1vbWVudG9zIGVzdGFiaWxpemFudGVzCiAgdmFyIE10PUVhaF9nKihILzMpK0VhaF9xKihILzIpK1Vfc3ViKlVfeWE7IC8v

IG1vbWVudG9zIHRvbWJhbnRlcwogIC8vIFRvbWJhbWVudG8KICB2YXIgQ1N0PU1lL01hdGgubWF4KE10LDAuMDAxKTsKICAvLyBEZXNsaXphbWVudG8KICB2YXIgRnI9bXUqVitjb2VzKkJiOyAvLyByZXNpc3RlbmNpYSBhbyBkZXNsaXphbWVudG8KICB2YXIgQ1NkPUZyL01hdGgubWF4KEVhaCwwLjAwMSk7CiAgLy8gRXhjZW50cmljaWRhZGUgZSBCIGVmZXRpdm8gKE5CUiA2MTIyIGl0ZW0gNy4zKQogIHZhciB4Uj0oTWUtTXQpL1Y7CiAgdmFyIGU9TWF0aC5hYnMoQmIvMi14Uik7CiAgdmFyIEJlZmY9QmItMiplOyAvLyBCIGVmZXRpdm8KICB2YXIgZV9saW09QmIvNjsgLy8gbnVjbGVvIGNlbnRyYWwgKDEvMyBsYXJndXJhID0gMS82IGRlIGNhZGEgbGFkbykK

ICBpZihlPmVfbGltKSBhbGVydGFzLnB1c2goJ0VYQ0VOVFJJQ0lEQURFOiBlPScrZm10KGUsNCkrJ20gPiBCLzY9JytmbXQoZV9saW0sNCkrJ20gXHUyMDE0IHRlbmNhbyBkZSB0cmFjYW8gbmEgYmFzZSAoTkJSIDYxMjIgaXRlbSA3LjMpJyk7CiAgLy8gUHJlc3NvZXMgbmEgYmFzZSBjb20gQiBlZmV0aXZvCiAgdmFyIHFtYXhfZT1WL0JlZmY7IC8vIHByZXNzYW8gdW5pZm9ybWUgZW0gQiBlZmV0aXZvCiAgdmFyIHFtYXg9Vi9CYiooMSs2KmUvQmIpOyAvLyBmb3JtdWxhIGNsYXNzaWNhCiAgdmFyIHFtaW49Vi9CYiooMS02KmUvQmIpOwogIGlmKHFtaW48MCkgYWxlcnRhcy5wdXNoKCdCQVNFOiBxX21pbj0nK2ZtdChxbWluLDIpKydrTi9tMiA8IDAgXHUyMDE0

IFRSQUNBTyBOQSBCQVNFLiBSZWRlc2VuaGFyIGdlb21ldHJpYS4nKTsKICAvLyBDYXBhY2lkYWRlIGRlIGNhcmdhIFx1MjAxNCBUZXJ6YWdoaSBjb20gQiBlZmV0aXZvCiAgdmFyIHRlej1jYXBhVGV6KHBoaV9kZWcsY29lcyxncyxIZW0sQmVmZik7CiAgdmFyIHNpZ2FkbV91c289b3JpZ19xPT09J2NhbGN1bG8nP3Rlei5xYWRtOnNpZ2FkbV9pbnA7CiAgaWYocW1heD5zaWdhZG1fdXNvKSBhbGVydGFzLnB1c2goJ0NBUEFDSURBREUgQ0FSR0E6IHFfbWF4PScrZm10KHFtYXgsMikrJ2tOL20yID4gc2lnbWFfYWRtPScrZm10KHNpZ2FkbV91c28sMikrJ2tOL20yJyk7CiAgLy8gUHJlc3NhbyBuYSBiYXNlIHBhcmEgdmVyaWZpY2FjYW8gYWx2ZW5hcmlhCiAgdmFy

IHNpZ21hX2Jhc2U9Vi9CYis2KihNZS1NdC0oVipCYi8yKSkvKEJiKkJiKTsgLy8ga1BhCiAgaWYoc2lnbWFfYmFzZTwwKSBzaWdtYV9iYXNlPTA7CiAgLy8gZnZrIGNvbSBzaWdtYSByZWFsCiAgdmFyIGZ2a19iYXNlPU1hdGgubWluKGZ2azArMC40KnNpZ21hX2Jhc2UvMTAwMCwwLjA2NSpmcGspOyAvLyBNUGEKICB2YXIgZnZkX2Jhc2U9ZnZrX2Jhc2UvZ2FtbWFfbTsKICB2YXIgdGF1X2Jhc2U9RWFoL0JiLzEwMDA7IC8vIE1QYQogIHZhciBva19jaXNfYmFzZT10YXVfYmFzZTw9ZnZkX2Jhc2U7CiAgLy8gVGVuc2FvIGRlIGNvbXByZXNzYW8gbmEgYmFzZQogIHZhciBzaWdtYV9jb21wPXNpZ21hX2Jhc2UvMTAwMDsgLy8gTVBhCiAgdmFyIG9rX2NvbXA9c2ln

bWFfY29tcDw9ZmQ7CiAgaWYoIW9rX2NvbXApIGFsZXJ0YXMucHVzaCgnQ09NUFJFU1NBTzogc2lnbWE9JytmbXQoc2lnbWFfY29tcCoxMDAwLDEpKydrUGEgPiBmZD0nK2ZtdChmZCoxMDAwLDEpKydrUGEgKE5CUiAxNTk2MS0xIGl0ZW0gOS4xKScpOwogIGlmKCFva19jaXNfYmFzZSkgYWxlcnRhcy5wdXNoKCdDSVNBTEhBTUVOVE8gQkFTRTogdGF1PScrZm10KHRhdV9iYXNlKjEwMDAsMikrJ2tQYSA+IGZ2ZD0nK2ZtdChmdmRfYmFzZSoxMDAwLDIpKydrUGEgKE5CUiAxNTk2MS0xIGl0ZW0gNy4yKScpOwogIC8vIEluY2xpbmFjYW8gZGEgcmVzdWx0YW50ZSBuYSBqdW50YSBiYXNlCiAgdmFyIHRoZXRhX3Jlcz1NYXRoLmF0YW4oRWFoL1YpKjE4MC9NYXRoLlBJ

OwogIHZhciB0aGV0YV9saW09TWF0aC5hdGFuKGZ2ZF9iYXNlLyhNYXRoLm1heChzaWdtYV9iYXNlLDAuMDAxKS8xMDAwKSkqMTgwL01hdGguUEk7CiAgdmFyIG9rX3RoZXRhPXRoZXRhX3Jlczw9dGhldGFfbGltOwogIGlmKCFva190aGV0YSkgYWxlcnRhcy5wdXNoKCdJTkNMSU5BQ0FPIERBIFJFU1VMVEFOVEU6IHRoZXRhPScrZm10KHRoZXRhX3JlcywxKSsnZGVnID4gdGhldGFfbGltPScrZm10KHRoZXRhX2xpbSwxKSsnZGVnIFx1MjAxNCBpbnN0YWJpbGlkYWRlIGludGVybmEgKE5CUiAxNTk2MS0xIGl0ZW0gNy4yLjEpJyk7CiAgLy8gVmVyaWZpY2FjYW8gZGUganVudGFzIGludGVybWVkaWFyaWFzIChOQlIgMTU5NjEtMSBpdGVtIDcuMi4yKQogIC8vIFNl

Y2FvIGEgSC8yCiAgdmFyIEgyPUgvMjsKICB2YXIgRWFoX0gyPTAuNSpLYSpncypIMipIMisodGlwb19zYyE9PSduZW5odW1hJz9LYSpxKkgyOjApOwogIHZhciBBbV9IMj0oQmIrQnQpLzIqSDIrKEJ0KSooSC1IMikqMDsgLy8gdHJhcGV6aW8gZGUgSDIKICB2YXIgQnRfSDI9QnQrKEJiLUJ0KSooSC1IMikvSDsgLy8gbGFyZ3VyYSBuYSBzZWNhbyBIMgogIHZhciBBbTI9KEJ0X0gyK0J0KS8yKkgyOwogIHZhciBXbV9IMj1nYWx2KkFtMjsKICB2YXIgV3NfSDI9Z3MqKChCdF9IMi1CdCkvMikqSDI7CiAgdmFyIFZfSDI9V21fSDIrV3NfSDI7CiAgdmFyIHNpZ21hX0gyPVZfSDIvQnRfSDIqMTAwMDsgLy8ga1BhIChwcmVzc2FvIG1lZGlhIG5hIHNlY2FvIEgyKQog

IHZhciBmdmtfSDI9TWF0aC5taW4oZnZrMCswLjQqc2lnbWFfSDIvMTAwMCwwLjA2NSpmcGspOwogIHZhciBmdmRfSDI9ZnZrX0gyL2dhbW1hX207CiAgdmFyIHRhdV9IMj1FYWhfSDIvQnRfSDIvMTAwMDsKICB2YXIgb2tfY2lzX0gyPXRhdV9IMjw9ZnZkX0gyOwogIGlmKCFva19jaXNfSDIpIGFsZXJ0YXMucHVzaCgnQ0lTQUxIQU1FTlRPIEgvMjogdGF1PScrZm10KHRhdV9IMioxMDAwLDIpKydrUGEgPiBmdmQ9JytmbXQoZnZkX0gyKjEwMDAsMikrJ2tQYSBcdTIwMTQganVudGEgYSBILzIgY3JpdGljYSAoTkJSIDE1OTYxLTEgaXRlbSA3LjIuMiknKTsKICAvLyBTZWNhbyBhIEgvMwogIHZhciBIMz1ILzM7CiAgdmFyIEVhaF9IMz0wLjUqS2EqZ3MqSDMqSDMr

KHRpcG9fc2MhPT0nbmVuaHVtYSc/S2EqcSpIMzowKTsKICB2YXIgQnRfSDM9QnQrKEJiLUJ0KSooSC1IMykvSDsKICB2YXIgQW0zPShCdF9IMytCdCkvMipIMzsKICB2YXIgV21fSDM9Z2FsdipBbTM7CiAgdmFyIFZfSDM9V21fSDM7CiAgdmFyIHNpZ21hX0gzPVZfSDMvQnRfSDMqMTAwMDsKICB2YXIgZnZrX0gzPU1hdGgubWluKGZ2azArMC40KnNpZ21hX0gzLzEwMDAsMC4wNjUqZnBrKTsKICB2YXIgZnZkX0gzPWZ2a19IMy9nYW1tYV9tOwogIHZhciB0YXVfSDM9RWFoX0gzL0J0X0gzLzEwMDA7CiAgdmFyIG9rX2Npc19IMz10YXVfSDM8PWZ2ZF9IMzsKICBpZighb2tfY2lzX0gzKSBhbGVydGFzLnB1c2goJ0NJU0FMSEFNRU5UTyBILzM6IHRhdT0nK2ZtdCh0

YXVfSDMqMTAwMCwyKSsna1BhID4gZnZkPScrZm10KGZ2ZF9IMyoxMDAwLDIpKydrUGEgXHUyMDE0IGp1bnRhIGEgSC8zIGNyaXRpY2EnKTsKICAvLyBSdXB0dXJhIGNpcmN1bGFyIHNpbXBsaWZpY2FkYSAoQmlzaG9wIGV4cGVkaXRvIFx1MjAxNCA1IGNpcmN1bG9zKQogIHZhciBDU19jaXJjPTk5OTsKICBmb3IodmFyIGljPTA7aWM8NTtpYysrKXsKICAgIHZhciBSYz1IKigwLjcraWMqMC4xKTsKICAgIHZhciBGbV9jPTAuNSpncypIKkgqTWF0aC5zaW4odG9SYWQoNDUtcGhpX2RlZy8yKSkvTWF0aC50YW4ocGhpKTsKICAgIHZhciBGcl9jPTAuNSpncypIKkgqTWF0aC5jb3ModG9SYWQoNDUtcGhpX2RlZy8yKSkrY29lcypIL01hdGguY29zKHRvUmFkKDQ1LXBo

aV9kZWcvMikpOwogICAgdmFyIENTX2M9RnJfYy9NYXRoLm1heChGbV9jLDAuMDAxKSpNYXRoLnNxcnQoUmMvKDAuOCpIKSk7CiAgICBpZihDU19jPENTX2NpcmMpIENTX2NpcmM9Q1NfYzsKICB9CiAgaWYoQ1NfY2lyYzxDU1JfTUlOKSBhbGVydGFzLnB1c2goJ1JVUFRVUkEgQ0lSQ1VMQVI6IENTPScrZm10KENTX2NpcmMsMykrJyA8ICcrQ1NSX01JTisnIChOQlIgMTE2ODIgaXRlbSA1LjcpJyk7CiAgLy8gU2lzbWljYSBcdTIwMTQgTW9ub25vYmUtT2thYmUKICB2YXIgQ1N0X3Npcz0wLENTZF9zaXM9MDsKICBpZihhZz4wKXsKICAgIHZhciBraD0wLjUqYWc7CiAgICB2YXIgZFBhZT0wLjM3NSpraCpncypIKkg7CiAgICB2YXIgeWFfcz0wLjYqSDsKICAgIENT

dF9zaXM9TWUvKE10K2RQYWUqeWFfcyk7CiAgICBDU2Rfc2lzPUZyLyhFYWgrZFBhZSk7CiAgICBpZihDU3Rfc2lzPDEuMSkgYWxlcnRhcy5wdXNoKCdTSVNNSUNBOiBDU190b21iPScrZm10KENTdF9zaXMsMykrJyA8IDEsMTAgKE5CUiAxMTY4MiBpdGVtIDUuOCknKTsKICAgIGlmKENTZF9zaXM8MS4xKSBhbGVydGFzLnB1c2goJ1NJU01JQ0E6IENTX2Rlc2w9JytmbXQoQ1NkX3NpcywzKSsnIDwgMSwxMCcpOwogIH0KICAvLyBSZWNhbHF1ZSBlc3RpbWFkbwogIHZhciBEZWx0YV9xPU1hdGgubWF4KHFtYXgtZ3MqSGVtLDApOwogIHZhciByZWNfbW09cGhpX2RlZz49MjU/RGVsdGFfcSpCZWZmKjEwKjIvbnNwdDpEZWx0YV9xKkJlZmYva3MqMTAwMDsKICAvLyBT

ZW1hZm9ybwogIGZ1bmN0aW9uIHNJKGxibCx2YWwscmVxLGV4LGludil7CiAgICB2YXIgcmF0aW89aW52PyhyZXEvTWF0aC5tYXgodmFsLDAuMDAwMSkpOih2YWwvTWF0aC5tYXgocmVxLDAuMDAwMSkpOwogICAgdmFyIGNscz1yYXRpbz49MS4xNT8nb2stcyc6KHJhdGlvPj0xLjA/J3dhcm4tcyc6J2Vyci1zJyk7CiAgICB2YXIgaWM9cmF0aW8+PTEuMTU/J09LICc6KHJhdGlvPj0xLjA/J09LISc6J0ZBSUwnKTsKICAgIHJldHVybiAnPGRpdiBjbGFzcz0ic2l0ZW0gJytjbHMrJyI+PGRpdiBjbGFzcz0ic2xibCI+JytsYmwrJzwvZGl2PjxkaXYgY2xhc3M9InN2YWwiPicraWMrJzwvZGl2PjxkaXYgY2xhc3M9InNyZXEiPicrZm10KHZhbCwyKSsoZXg/JyB8ICcr

ZXg6JycpKyc8L2Rpdj48L2Rpdj4nOwogIH0KICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc2VtYWZvcm8nKS5pbm5lckhUTUw9CiAgICBzSSgnVG9tYmFtZW50b1xuQ1MnLENTdCxDU1RfTUlOLCc+JytDU1RfTUlOKSsKICAgIHNJKCdEZXNsaXphbWVudG9cbkNTJyxDU2QsQ1NEX01JTiwnPicrQ1NEX01JTikrCiAgICBzSSgnQ2FwLkNhcmdhXG5xKGtOL20yKScsc2lnYWRtX3VzbyxxbWF4LCc8PScrZm10KHNpZ2FkbV91c28sMCksdHJ1ZSkrCiAgICBzSSgnRXhjZW50ci5cbmUobSknLGVfbGltLGUsJ0IvNj0nK2ZtdChlX2xpbSwzKSx0cnVlKSsKICAgIHNJKCdDb21wcmVzc2FvXG5iYXNlKGtQYSknLGZkKjEwMDAsc2lnbWFfYmFzZSwnPD0nK2ZtdChmZCox

MDAwLDEpLHRydWUpKwogICAgc0koJ0Npc2FsaC5cbmJhc2UnLGZ2ZF9iYXNlKjEwMDAsdGF1X2Jhc2UqMTAwMCwnPD0nK2ZtdChmdmRfYmFzZSoxMDAwLDIpLHRydWUpKwogICAgc0koJ0luY2xpbi5cbnJlc3VsdC4nLHRoZXRhX2xpbSx0aGV0YV9yZXMsJ2xpbT0nK2ZtdCh0aGV0YV9saW0sMSkrJ2cnLHRydWUpKwogICAgc0koJ1J1cHQuXG5jaXJjdWxhcicsQ1NfY2lyYyxDU1JfTUlOLCc+JytDU1JfTUlOKTsKICAvLyBBbGVydGFzCiAgdmFyIGFkcj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWxlcnRhc19yZXMnKTsKICBhZHIuaW5uZXJIVE1MPWFsZXJ0YXMubGVuZ3RoP2FsZXJ0YXMubWFwKGZ1bmN0aW9uKGEpe3JldHVybiAnPGRpdiBjbGFzcz0iYWxl

cnRhIj4nK2ErJzwvZGl2Pic7fSkuam9pbignJyk6JzxkaXYgc3R5bGU9ImJhY2tncm91bmQ6dmFyKC0tb2spO2NvbG9yOnZhcigtLW9rYik7Ym9yZGVyLXJhZGl1czo1cHg7cGFkZGluZzo4cHggMTJweDtmb250LXNpemU6MTFweDsiPlNlbSBhbGVydGFzIG5vcm1hdGl2b3MgaWRlbnRpZmljYWRvcy48L2Rpdj4nOwogIC8vIE1lbW9yaWFsCiAgdmFyIFNFUD0nPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSc7CiAgdmFyIHNlcD0nLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSc7CiAgdmFyIG1lbT0nPGg0PicrU0VQKyc8L2g0

Pic7CiAgbWVtKz0nICBNRU1PUklBTCBERSBDQUxDVUxPXG4gIE1VUk8gREUgQVJSSU1PIEVNIEFMVkVOQVJJQSBFU1RSVVRVUkFMIChCTE9DT1MpXG4gIE5CUiAxNTk2MS0xOjIwMTEgfCBOQlIgNjEyMDoyMDE5IHwgTkJSIDExNjgyOjIwMDlcbjxoND4nK1NFUCsnPC9oND5cbic7CiAgbWVtKz0nICBPYnJhICAgICA6ICcrb2JyYSsnXG4gIFJlc3AuVGVjLjogJytyZXNwKydcbiAgRGF0YSAgICAgOiAnK2RjKycgIFJldi46ICcrcmV2KydcbiAgTGF1ZG8gICAgOiAnK2xhdWRvKycgIEFSVC9SUlQ6ICcrYXJ0KydcblxuJzsKICBtZW0rPSc8aDQ+MS4gR0VPTUVUUklBPC9oND4nOwogIG1lbSs9JyAgSD0nK0grJ20gIEhlbT0nK0hlbSsnbSBbbWluPScrZm10KEhl

bV9taW4sMikrJ20gJysoSGVtPj1IZW1fbWluPydPSyc6J0ZBSUwnKSsnXVxuJzsKICBtZW0rPScgIEJiPScrQmIrJ20gIEJ0PScrQnQrJ20gIEJiL0g9JytmbXQoQkgsMikrJyAnKyhCSD49MC40PydPSyc6J0FURU4nKSsnXG4nOwogIG1lbSs9JyAgYmV0YV9tdXJvPScrYmV0YV9tKydkZWcgIGJldGFfYXRlcnJvPScrYmV0YSsnZGVnXG4nOwogIG1lbSs9JyAgQXJlYSBkbyBtdXJvIEFtPShCYitCdCkvMipIPScrZm10KEFtLDQpKydtMlxuXG4nOwogIG1lbSs9JzxoND4yLiBBTFZFTkFSSUEgXHUyMDE0IE5CUiAxNTk2MS0xOjIwMTE8L2g0Pic7CiAgbWVtKz0nICBCbG9jbzogMzl4MTl4JytmbXQoYmxfdCoxMDAsMCkrJ2NtICBJbmRpY2UgdmF6aW9zOiAnK3Zh

emlvcysnJSAgRXNwLmp1bnRhOiAnK2VzcF9qKydtbVxuJzsKICBtZW0rPScgIEp1bnRhIHZlcnRpY2FsOiAnK2p1bnRhX3YrJyAgR3JhdXRlYW1lbnRvOiAnK2dyYXV0Kydcbic7CiAgbWVtKz0nICBmcGs9JytmcGsrJ01QYSAgZmprPScrZmprKydNUGEgIGdhbW1hX2Fsdj0nK2ZtdChnYWx2LDEpKydrTi9tM1xuJzsKICBtZW0rPScgIGZhdG9yX2p1bnRhPScrZm10KGZhdG9yX2p1bnRhLDIpKycgIGZhdG9yX3Zhemlvcz0nK2ZtdChmYXRvcl92YXppb3MsMykrJyAgZmF0b3JfZ3JhdXQ9JytmbXQoZ3JhdXRfZmF0b3JfZmssMykrJ1xuJzsKICBtZW0rPScgIGZrID0gZnBrXjAsODUqZmprXjAsMTUqMCw4NSpmaipmdipmZ1xuJzsKICBtZW0rPScgICAgID0gJytm

cGsrJ14wLDg1KicrZmprKydeMCwxNSowLDg1KicrZm10KGZhdG9yX2p1bnRhLDIpKycqJytmbXQoZmF0b3JfdmF6aW9zLDMpKycqJytmbXQoZ3JhdXRfZmF0b3JfZmssMykrJ1xuJzsKICBtZW0rPScgICAgID0gJytmbXQoZmssMykrJ01QYSAgPT4gZmssbGltPW1pbihmaywwLDc1KmZwayk9JytmbXQoZmtfbGltLDMpKydNUGFcbic7CiAgbWVtKz0nICBmZCA9IGZrLGxpbS9nYW1tYV9tID0gJytmbXQoZmtfbGltLDMpKycvJytnYW1tYV9tKycgPSAnK2ZtdChmZCw0KSsnTVBhID0gJytmbXQoZmQqMTAwMCwyKSsna1BhXG4nOwogIG1lbSs9JyAgZnZrMCA9ICcrZnZrMCsnIE1QYSAoJysoIGp1bnRhX3Y9PT0nc2ltJz8nanVudGEgdmVydGljYWwgcHJlZW5jaGlk

YSc6J3NlbSBqdW50YSB2ZXJ0aWNhbCcpKycgXHUyMDE0IE5CUiAxNTk2MS0xIGl0ZW0gNy4yKVxuXG4nOwogIG1lbSs9JzxoND4zLiBQQVJBTUVUUk9TIEdFT1RFQ05JQ09TPC9oND4nOwogIG1lbSs9JyAgU1VDUz0nK3N1Y3MrJyAgTi1TUFQ9Jytuc3B0KycgIGdhbW1hX3M9Jytncysna04vbTMgIHBoaT0nK3BoaV9kZWcrJ2RlZyAgYz0nK2NvZXMrJ2tOL20yXG4nOwogIG1lbSs9JyAgbXVfYmFzZT0nK211KycgIE53PScrTncrJ20gIE53X2VmZj0nK2ZtdChOd19lZmYsMikrJ20gIERyZW5hZ2VtOiAnK2RyZW5hZ2VtKydcbic7CiAgaWYoTndfZWZmPjApIG1lbSs9JyAgVSA9IDAsNSpnYW1tYV93Kk53X2VmZl4yID0gJytmbXQoVV9zdWIsMykrJ2tOL20gIEAg

eWE9JytmbXQoVV95YSwzKSsnbVxuJzsKICBtZW0rPSdcbic7CiAgbWVtKz0nPGg0PjQuIENBUEFDSURBREUgREUgQ0FSR0EgXHUyMDE0IFRFUlpBR0hJIChjb20gQiBlZmV0aXZvKTwvaDQ+JzsKICBtZW0rPScgIE5xPScrZm10KHRlei5OcSwzKSsnICBOYz0nK2ZtdCh0ZXouTmMsMykrJyAgTmdhbW1hPScrZm10KHRlei5OZywzKSsnXG4nOwogIG1lbSs9JyAgQl9lZmV0aXZvID0gQi0yZSA9ICcrZm10KEJiLDMpKyctMionK2ZtdChlLDQpKycgPSAnK2ZtdChCZWZmLDQpKydtXG4nOwogIG1lbSs9JyAgcXVsdD1jKk5jK3FzKkRmKk5xKzAsNSpncypCKk5nID0gJytmbXQodGV6LnF1bHQsMikrJ2tOL20yXG4nOwogIG1lbSs9JyAgcWFkbSA9IHF1bHQvMyA9ICcr

Zm10KHRlei5xYWRtLDIpKydrTi9tMlxuJzsKICBtZW0rPScgIHNpZ21hX2FkbSB1dGlsaXphZG8gPSAnK2ZtdChzaWdhZG1fdXNvLDIpKydrTi9tMlxuXG4nOwogIG1lbSs9JzxoND41LiBDT0VGSUNJRU5URSBERSBQUkVTU0FPIEFUSVZBPC9oND4nOwogIG1lbSs9JyAgS2EgKFJhbmtpbmUsIGRlbHRhPTApID0gdGFuXjIoNDUtcGhpLzIpID0gJytmbXQoS2FfcmFuayw0KSsnIFtVVElMSVpBRE8gLSBjb25zZXJ2YWRvcl1cbic7CiAgbWVtKz0nICBLYSAoQ291bG9tYiwgZGVsdGE9cGhpLzMpID0gJytmbXQoS2FfY291bG9tYiw0KSsnIFtyZWZlcmVuY2lhXVxuJzsKICBtZW0rPScgIERpZmVyZW5jYTogJysoKChLYV9yYW5rLUthX2NvdWxvbWIpL0thX2NvdWxv

bWIpKjEwMCkudG9GaXhlZCgxKSsnJSAoUmFua2luZSBtYWlzIGNvbnNlcnZhZG9yKVxuXG4nOwogIG1lbSs9JzxoND42LiBGT1JDQVMgQVRVQU5URVM8L2g0Pic7CiAgbWVtKz0nICBFYV9nICA9IDAsNSpLYSpncypIXjIgPSAnK2ZtdChFYV9nLDMpKydrTi9tICBFYWg9JytmbXQoRWFoX2csMykrJyBFYXY9JytmbXQoRWF2X2csMykrJ2tOL21cbic7CiAgaWYodGlwb19zYyE9PSduZW5odW1hJykgbWVtKz0nICBFYV9xICA9IEthKnEqSCAgICAgICA9ICcrZm10KEVhX3EsMykrJ2tOL20gIEVhaD0nK2ZtdChFYWhfcSwzKSsnIEVhdj0nK2ZtdChFYXZfcSwzKSsna04vbVxuJzsKICBtZW0rPScgIEVhaCB0b3RhbCA9ICcrZm10KEVhaCwzKSsna04vbSAgRWF2IHRv

dGFsID0gJytmbXQoRWF2LDMpKydrTi9tXG4nOwogIG1lbSs9JyAgV20gPSBnYW1tYV9hbHYqQW0gPSAnK2ZtdChnYWx2LDEpKycqJytmbXQoQW0sNCkrJyA9ICcrZm10KFdtLDMpKydrTi9tICBAIHhjZz0nK2ZtdCh4Y2dfdHJhcCwzKSsnbVxuJzsKICBtZW0rPScgIFdzIChzb2xvIHNvYnJlIGRlZ3JhdSkgPSAnK2ZtdChXcywzKSsna04vbSAgQCB4cz0nK2ZtdCh4cywzKSsnbVxuJzsKICBtZW0rPScgIFYgPSBXbSArIFdzICsgRWF2ID0gJytmbXQoViwzKSsna04vbVxuJzsKICBtZW0rPScgIFByZXNzYW8gcGFzc2l2YSBubyBwZSBFcCA9ICcrZm10KEVwLDMpKydrTi9tIFtjYWxjdWxhZGEgbWFzIE5BTyB1dGlsaXphZGEgXHUyMDE0IGNvbnNlcnZhZG9yLCBO

QlIgMTE2ODIgaXRlbSA1LjVdXG5cbic7CiAgbWVtKz0nPGg0PjcuIFRPTUJBTUVOVE8gKE5CUiAxMTY4MiBpdGVtIDUuMyk8L2g0Pic7CiAgbWVtKz0nICBNUiA9IFdtKnhjZyArIFdzKnhzICsgRWF2KkJiID0gJytmbXQoTWUsMykrJ2tObS9tXG4nOwogIG1lbSs9JyAgTVQgPSBFYWhfZyooSC8zKSArIEVhaF9xKihILzIpJysoIFVfc3ViPjA/JytVKnlhJzonJykrJyA9ICcrZm10KE10LDMpKydrTm0vbVxuJzsKICBtZW0rPScgIENTX3RvbWIgPSBNUi9NVCA9ICcrZm10KENTdCwzKSsnID49ICcrQ1NUX01JTisnICAnKyhDU3Q+PUNTVF9NSU4/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuXG4nOwogIG1lbSs9JzxoND44LiBERVNMSVpBTUVOVE8gKE5C

UiAxMTY4MiBpdGVtIDUuNCk8L2g0Pic7CiAgbWVtKz0nICBGciA9IG11KlYgKyBjKkJiID0gJytmbXQobXUsMikrJyonK2ZtdChWLDMpKycrJytjb2VzKycqJytmbXQoQmIsMykrJyA9ICcrZm10KEZyLDMpKydrTi9tXG4nOwogIG1lbSs9JyAgQ1NfZGVzbCA9IEZyL0VhaCA9ICcrZm10KENTZCwzKSsnID49ICcrQ1NEX01JTisnICAnKyhDU2Q+PUNTRF9NSU4/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuXG4nOwogIG1lbSs9JzxoND45LiBDQVBBQ0lEQURFIERFIENBUkdBIEUgRVhDRU5UUklDSURBREU8L2g0Pic7CiAgbWVtKz0nICB4UiA9IChNUi1NVCkvViA9ICcrZm10KHhSLDQpKydtXG4nOwogIG1lbSs9JyAgZSAgPSB8QmIvMiAtIHhSfCA9ICcr

Zm10KGUsNCkrJ20gIGVfbGltPUJiLzY9JytmbXQoZV9saW0sNCkrJ20gICcrKGU8PWVfbGltPydPSyc6J0ZBSUwgXHUyMDE0IFRSQUNBTyBOQSBCQVNFJykrJ1xuJzsKICBtZW0rPScgIEJfZWZldGl2byA9IEJiIC0gMmUgPSAnK2ZtdChCZWZmLDQpKydtIChOQlIgNjEyMiBpdGVtIDcuMylcbic7CiAgbWVtKz0nICBxX21heCA9IFYvQmIqKDErNmUvQmIpID0gJytmbXQocW1heCwzKSsna04vbTJcbic7CiAgbWVtKz0nICBxX21pbiA9IFYvQmIqKDEtNmUvQmIpID0gJytmbXQocW1pbiwzKSsna04vbTJcbic7CiAgbWVtKz0nICBzaWdtYV9hZG0gPSAnK2ZtdChzaWdhZG1fdXNvLDIpKydrTi9tMiAgJysocW1heDw9c2lnYWRtX3Vzbz8nVkVSSUZJQ0EnOidOQU8g

VkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgUmVjYWxxdWUgZXN0aW1hZG8gPSAnK2ZtdChyZWNfbW0sMSkrJ21tIChOQlIgNjEyMilcblxuJzsKICBtZW0rPSc8aDQ+MTAuIFZFUklGSUNBQ0FPIERBIEFMVkVOQVJJQSBcdTIwMTQgTkJSIDE1OTYxLTE6MjAxMTwvaDQ+JzsKICBtZW0rPScgIC0tLSBKVU5UQSBEQSBCQVNFIC0tLVxuJzsKICBtZW0rPScgIHNpZ21hX2Jhc2UgPSBWL0JiICsgNiooTVItTVQtVipCYi8yKS9CYl4yID0gJytmbXQoc2lnbWFfYmFzZSwyKSsna1BhID0gJytmbXQoc2lnbWFfYmFzZS8xMDAwLDUpKydNUGFcbic7CiAgbWVtKz0nICBzaWdtYV9jb21wIDw9IGZkIDogJytmbXQoc2lnbWFfY29tcCoxMDAwLDIpKydrUGEgPD0gJytmbXQo

ZmQqMTAwMCwyKSsna1BhICAnKyhva19jb21wPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKycgIChOQlIgMTU5NjEtMSBpdGVtIDkuMSlcbic7CiAgbWVtKz0nICBmdmswPScrZnZrMCsnTVBhICBmdms9bWluKCcrZnZrMCsnKzAsNConK2ZtdChzaWdtYV9iYXNlLzEwMDAsNCkrJywwLDA2NSonK2ZwaysnKT0nK2ZtdChmdmtfYmFzZSw0KSsnTVBhXG4nOwogIG1lbSs9JyAgZnZkID0gZnZrL2dhbW1hX20gPSAnK2ZtdChmdmtfYmFzZSw0KSsnLycrZ2FtbWFfbSsnID0gJytmbXQoZnZkX2Jhc2UsNCkrJ01QYVxuJzsKICBtZW0rPScgIHRhdSA9IEVhaC9CYiA9ICcrZm10KEVhaCwzKSsnLycrZm10KEJiLDMpKycgPSAnK2ZtdCh0YXVfYmFzZSoxMDAwLDMpKydr

UGEgPSAnK2ZtdCh0YXVfYmFzZSw1KSsnTVBhXG4nOwogIG1lbSs9JyAgdGF1IDw9IGZ2ZCA6ICcrZm10KHRhdV9iYXNlKjEwMDAsMykrJ2tQYSA8PSAnK2ZtdChmdmRfYmFzZSoxMDAwLDMpKydrUGEgICcrKG9rX2Npc19iYXNlPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKycgIChOQlIgMTU5NjEtMSBpdGVtIDcuMilcbic7CiAgbWVtKz0nICBJbmNsaW5hY2FvIGRhIHJlc3VsdGFudGUgdGhldGEgPSBhcmN0YW4oRWFoL1YpID0gJytmbXQodGhldGFfcmVzLDIpKydkZWdcbic7CiAgbWVtKz0nICB0aGV0YV9saW0gPSBhcmN0YW4oZnZkL3NpZ21hKSA9ICcrZm10KHRoZXRhX2xpbSwyKSsnZGVnICAnKyhva190aGV0YT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJ

Q0EnKSsnICAoTkJSIDE1OTYxLTEgaXRlbSA3LjIuMSlcblxuJzsKICBtZW0rPScgIC0tLSBKVU5UQSBJTlRFUk1FRElBUklBIGEgSC8yID0gJytmbXQoSDIsMikrJ20gLS0tXG4nOwogIG1lbSs9JyAgTGFyZ3VyYSBuYSBzZWNhbyBILzI6IEJ0X0gyID0gJytmbXQoQnRfSDIsMykrJ21cbic7CiAgbWVtKz0nICBFYWgoSC8yKSA9ICcrZm10KEVhaF9IMiwzKSsna04vbSAgc2lnbWFfSDIgPSAnK2ZtdChzaWdtYV9IMiwyKSsna1BhXG4nOwogIG1lbSs9JyAgZnZkKEgvMikgPSAnK2ZtdChmdmRfSDIsNCkrJ01QYSAgdGF1KEgvMikgPSAnK2ZtdCh0YXVfSDIqMTAwMCwzKSsna1BhICAnKyhva19jaXNfSDI/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuXG4n

OwogIG1lbSs9JyAgLS0tIEpVTlRBIElOVEVSTUVESUFSSUEgYSBILzMgPSAnK2ZtdChIMywyKSsnbSAtLS1cbic7CiAgbWVtKz0nICBMYXJndXJhIG5hIHNlY2FvIEgvMzogQnRfSDMgPSAnK2ZtdChCdF9IMywzKSsnbVxuJzsKICBtZW0rPScgIEVhaChILzMpID0gJytmbXQoRWFoX0gzLDMpKydrTi9tICBzaWdtYV9IMyA9ICcrZm10KHNpZ21hX0gzLDIpKydrUGFcbic7CiAgbWVtKz0nICBmdmQoSC8zKSA9ICcrZm10KGZ2ZF9IMyw0KSsnTVBhICB0YXUoSC8zKSA9ICcrZm10KHRhdV9IMyoxMDAwLDMpKydrUGEgICcrKG9rX2Npc19IMz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG5cbic7CiAgbWVtKz0nICBCYXJiYWNhczogJytkb2N1bWVudC5nZXRF

bGVtZW50QnlJZCgnYmFyYmFjYXMnKS5vcHRpb25zW2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdiYXJiYWNhcycpLnNlbGVjdGVkSW5kZXhdLnRleHQrJ1xuJzsKICBtZW0rPScgIEVzcGFjYW1lbnRvIG1heGltbzogMiwwbSAgRGlhbWV0cm8gbWluaW1vOiA3NW1tIChOQlIgMTE2ODIgaXRlbSA1LjYuMilcblxuJzsKICBtZW0rPSc8aDQ+MTEuIEVTVEFCSUxJREFERSBHTE9CQUwgXHUyMDE0IFJVUFRVUkEgQ0lSQ1VMQVIgRVhQRURJVEE8L2g0Pic7CiAgbWVtKz0nICBDU19jaXJjIH4gJytmbXQoQ1NfY2lyYywzKSsnID49ICcrQ1NSX01JTisnICAnKyhDU19jaXJjPj1DU1JfTUlOPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKycgKE5CUiAxMTY4MiBpdGVt

IDUuNylcbic7CiAgbWVtKz0nICBBVEVOQ0FPOiBSZWFsaXphciBhbmFsaXNlIEJpc2hvcCBjb21wbGV0YSBwYXJhIHByb2pldG8gZXhlY3V0aXZvLlxuXG4nOwogIGlmKGFnPjApewogICAgbWVtKz0nPGg0PjEyLiBWRVJJRklDQUNBTyBTSVNNSUNBIChOQlIgMTE2ODIgaXRlbSA1LjgpPC9oND4nOwogICAgbWVtKz0nICBhZz0nK2FnKydnICBraD0wLDUqYWc9JytmbXQoMC41KmFnLDQpKycgIGRQYWU9MCwzNzUqa2gqZ3MqSF4yPScrZm10KDAuMzc1KjAuNSphZypncypIKkgsMykrJ2tOL21cbic7CiAgICBtZW0rPScgIENTX3RvbWIoc2lzKT0nK2ZtdChDU3Rfc2lzLDMpKycgIENTX2Rlc2woc2lzKT0nK2ZtdChDU2Rfc2lzLDMpKydcblxuJzsKICB9CiAgbWVt

Kz0nPGg0PlJFU1VNTyBEQVMgVkVSSUZJQ0FDT0VTPC9oND4nOwogIG1lbSs9JyAgVG9tYmFtZW50byAgOiBDUz0nK2ZtdChDU3QsMykrJyA+PSAnK0NTVF9NSU4rJyAgJysoQ1N0Pj1DU1RfTUlOPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBEZXNsaXphbWVudG86IENTPScrZm10KENTZCwzKSsnID49ICcrQ1NEX01JTisnICAnKyhDU2Q+PUNTRF9NSU4/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENhcC5DYXJnYSAgIDogcT0nK2ZtdChxbWF4LDIpKycgPD0gJytmbXQoc2lnYWRtX3VzbywyKSsna04vbTIgICcrKHFtYXg8PXNpZ2FkbV91c28/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xu

JzsKICBtZW0rPScgIEV4Y2VudHIuICAgIDogZT0nK2ZtdChlLDQpKycgPD0gQi82PScrZm10KGVfbGltLDQpKydtICAnKyhlPD1lX2xpbT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgQ29tcHJlc3NhbyAgOiAnK2ZtdChzaWdtYV9jb21wKjEwMDAsMSkrJ2tQYSA8PSBmZD0nK2ZtdChmZCoxMDAwLDEpKydrUGEgICcrKG9rX2NvbXA/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENpc2FsaC5iYXNlIDogJytmbXQodGF1X2Jhc2UqMTAwMCwyKSsna1BhIDw9IGZ2ZD0nK2ZtdChmdmRfYmFzZSoxMDAwLDIpKydrUGEgICcrKG9rX2Npc19iYXNlPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7

CiAgbWVtKz0nICBJbmNsLnJlc3VsdC46ICcrZm10KHRoZXRhX3JlcywxKSsnZGVnIDw9ICcrZm10KHRoZXRhX2xpbSwxKSsnZGVnICAnKyhva190aGV0YT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgQ2lzYWxoLkgvMiAgOiAnK2ZtdCh0YXVfSDIqMTAwMCwyKSsna1BhIDw9IGZ2ZD0nK2ZtdChmdmRfSDIqMTAwMCwyKSsna1BhICAnKyhva19jaXNfSDI/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENpc2FsaC5ILzMgIDogJytmbXQodGF1X0gzKjEwMDAsMikrJ2tQYSA8PSBmdmQ9JytmbXQoZnZkX0gzKjEwMDAsMikrJ2tQYSAgJysob2tfY2lzX0gzPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScp

Kydcbic7CiAgbWVtKz0nICBSdXB0LmNpcmMuICA6IENTPScrZm10KENTX2NpcmMsMykrJyA+PSAnK0NTUl9NSU4rJyAgJysoQ1NfY2lyYz49Q1NSX01JTj8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgRW1idXRpbWVudG8gOiBIZW09JytmbXQoSGVtLDIpKydtID49ICcrZm10KEhlbV9taW4sMikrJ20gICcrKEhlbT49SGVtX21pbj8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG5cbic7CiAgaWYoYWxlcnRhcy5sZW5ndGgpe21lbSs9JzxoND5BTEVSVEFTIEUgTkFPLUNPTkZPUk1JREFERVM8L2g0Pic7YWxlcnRhcy5mb3JFYWNoKGZ1bmN0aW9uKGEpe21lbSs9JyAgWyFdICcrYSsnXG4nO30pO21lbSs9J1xuJzt9CiAgbWVt

Kz0nJytTRVArJ1xuJzsKICBtZW0rPSdOb3JtYXM6IE5CUiAxNTk2MS0xOjIwMTEgfCBOQlIgNjEyMDoyMDE5IHwgTkJSIDExNjgyOjIwMDkgfCBOQlIgNjEyMjoyMDIyXG4nOwogIG1lbSs9JycrU0VQKydcbic7CiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ21lbW9yaWFsJykuaW5uZXJIVE1MPW1lbTsKICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0YWRvJykuc3R5bGUuZGlzcGxheT0nYmxvY2snOwogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRhZG8nKS5zY3JvbGxJbnRvVmlldyh7YmVoYXZpb3I6J3Ntb290aCd9KTsKfQp3aW5kb3cub25sb2FkPWZ1bmN0aW9uKCl7CiAgdmFyIGRjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdk

YXRhX2NhbGMnKTsKICBpZihkYyYmIWRjLnZhbHVlKSBkYy52YWx1ZT1uZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7Cn07Cjwvc2NyaXB0Pg==

PHN0eWxlPjpyb290ey0tYXo6IzFkMzE1NTstLWF6bTojMmU0ZjhhOy0tYXpjOiM0YTdjYzc7LS1kb3I6I2JmOTAwMDstLWRvcmM6I2UwYWEwMDstLWJnOiNmMGYyZjY7LS1iZ3c6I2ZmZjstLWJyZDojYzhkMGUwOy0tdHh0OiMxYTFhMmU7LS10eHRtOiM0YTRhNmE7LS1vazojZDRlZGRhOy0tb2tiOiMxYTdhM2E7LS13YXJuOiNmZmYzY2Q7LS13YXJuYjojODU2NDA0Oy0tZXJyOiNmOGQ3ZGE7LS1lcnJiOiM4NDIwMjk7fSp7Ym94LXNpemluZzpib3JkZXItYm94O21hcmdpbjowO3BhZGRpbmc6MDt9Ym9keXtmb250LWZhbWlseTonSUJNIFBsZXggU2Fucycsc2Fucy1zZXJpZjtiYWNrZ3JvdW5kOnZhcigtLWJnKTtjb2xvcjp2YXIoLS10eHQpO30ud3JhcHttYXgt

d2lkdGg6MTAwMHB4O21hcmdpbjowIGF1dG87cGFkZGluZzoyMHB4IDE2cHg7fS5zZWN7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO2JvcmRlcjoxLjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6OHB4O3BhZGRpbmc6MjBweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zZWMgaDN7Zm9udC1zaXplOjExcHg7Zm9udC13ZWlnaHQ6NzAwO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouN3B4O2NvbG9yOnZhcigtLWF6KTttYXJnaW4tYm90dG9tOjE0cHg7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4O30uc2VjIGgzOjphZnRlcntjb250ZW50OicnO2ZsZXg6MTtoZWlnaHQ6MXB4O2JhY2tncm91bmQ6dmFyKC0t

YnJkKTt9Lmcye2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjtnYXA6MTBweDt9Lmcze2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmciAxZnI7Z2FwOjEwcHg7fS5nNHtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOjFmciAxZnIgMWZyIDFmcjtnYXA6MTBweDt9LmZsZHtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDozcHg7fS5mbGQgbGFiZWx7Zm9udC1zaXplOjEwcHg7Zm9udC13ZWlnaHQ6NjAwO2NvbG9yOnZhcigtLXR4dG0pO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouNXB4O30uZmxkIGlucHV0LC5mbGQgc2VsZWN0e2JvcmRlcjox

LjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6NHB4O3BhZGRpbmc6N3B4IDlweDtmb250LXNpemU6MTJweDtmb250LWZhbWlseTppbmhlcml0O2NvbG9yOnZhcigtLXR4dCk7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO30uZmxkIC51bntmb250LXNpemU6OXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi10b3A6MXB4O30ubm90YXtiYWNrZ3JvdW5kOiNlOGYwZmU7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkIHZhcigtLWF6Yyk7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5ub3RhLXd7YmFja2dyb3VuZDojZmZmM2NkO2JvcmRlci1s

ZWZ0OjNweCBzb2xpZCB2YXIoLS1kb3JjKTtwYWRkaW5nOjdweCAxMXB4O2ZvbnQtc2l6ZToxMHB4O2JvcmRlci1yYWRpdXM6MCA0cHggNHB4IDA7bWFyZ2luLWJvdHRvbToxMHB4O2xpbmUtaGVpZ2h0OjEuNjt9LmJ0bi1jYWxje2JhY2tncm91bmQ6dmFyKC0tYXopO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxM3B4IDI4cHg7Zm9udC1zaXplOjEzcHg7Zm9udC13ZWlnaHQ6NzAwO2N1cnNvcjpwb2ludGVyO3dpZHRoOjEwMCU7bWFyZ2luLXRvcDo2cHg7fS5idG4tcGRme2JhY2tncm91bmQ6dmFyKC0tZG9yYyk7Y29sb3I6I2ZmZjtib3JkZXI6bm9uZTtib3JkZXItcmFkaXVzOjZweDtwYWRkaW5nOjlweCAyMnB4O2Zv

bnQtc2l6ZToxMnB4O2ZvbnQtd2VpZ2h0OjcwMDtjdXJzb3I6cG9pbnRlcjttYXJnaW4tdG9wOjEwcHg7fSNyZXN1bHRhZG97ZGlzcGxheTpub25lO21hcmdpbi10b3A6MTZweDt9LnNlbXtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOnJlcGVhdCg4LDFmcik7Z2FwOjZweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zaXRlbXtib3JkZXItcmFkaXVzOjdweDtwYWRkaW5nOjlweCA1cHg7dGV4dC1hbGlnbjpjZW50ZXI7fS5zbGJse2ZvbnQtc2l6ZTo3LjVweDtmb250LXdlaWdodDo3MDA7dGV4dC10cmFuc2Zvcm06dXBwZXJjYXNlO2xldHRlci1zcGFjaW5nOi4zcHg7bWFyZ2luLWJvdHRvbTo0cHg7bGluZS1oZWlnaHQ6MS4zO30uc3ZhbHtmb250LXNp

emU6MTRweDtmb250LXdlaWdodDo3MDA7Zm9udC1mYW1pbHk6J0lCTSBQbGV4IE1vbm8nLG1vbm9zcGFjZTt9LnNyZXF7Zm9udC1zaXplOjdweDttYXJnaW4tdG9wOjJweDtvcGFjaXR5Oi44O30ub2stc3tiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xvcjp2YXIoLS1va2IpO30ud2Fybi1ze2JhY2tncm91bmQ6dmFyKC0td2Fybik7Y29sb3I6dmFyKC0td2FybmIpO30uZXJyLXN7YmFja2dyb3VuZDp2YXIoLS1lcnIpO2NvbG9yOnZhcigtLWVycmIpO30ubWVte2JhY2tncm91bmQ6I2Y4ZjlmYztib3JkZXI6MXB4IHNvbGlkIHZhcigtLWJyZCk7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxOHB4O2ZvbnQtc2l6ZToxMXB4O2xpbmUtaGVpZ2h0OjEuOTtmb250LWZh

bWlseTonSUJNIFBsZXggTW9ubycsbW9ub3NwYWNlO3doaXRlLXNwYWNlOnByZS13cmFwO2NvbG9yOnZhcigtLXR4dCk7bWFyZ2luLXRvcDoxMnB4O30ubWVtIGg0e2ZvbnQtZmFtaWx5OidJQk0gUGxleCBTYW5zJyxzYW5zLXNlcmlmO2ZvbnQtc2l6ZToxMXB4O2ZvbnQtd2VpZ2h0OjcwMDtjb2xvcjp2YXIoLS1heik7bWFyZ2luOjE0cHggMCA0cHg7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgdmFyKC0tYnJkKTtwYWRkaW5nLWJvdHRvbToycHg7fS5hbGVydGF7YmFja2dyb3VuZDojZjhkN2RhO2JvcmRlcjoxcHggc29saWQgI2Y1YzZjYjtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4O2NvbG9yOiM4NDIwMjk7bWFyZ2lu

OjRweCAwO31AbWVkaWEobWF4LXdpZHRoOjcwMHB4KXsuZzMsLmc0e2dyaWQtdGVtcGxhdGUtY29sdW1uczoxZnIgMWZyO30uc2Vte2dyaWQtdGVtcGxhdGUtY29sdW1uczpyZXBlYXQoNCwxZnIpO319QG1lZGlhIHByaW50ey5idG4tY2FsYywuYnRuLXBkZiwuc2VjOm5vdCgjc2VjLXJlcyl7ZGlzcGxheTpub25lIWltcG9ydGFudDt9I3Jlc3VsdGFkb3tkaXNwbGF5OmJsb2NrIWltcG9ydGFudDt9Ym9keXtiYWNrZ3JvdW5kOiNmZmY7fS5tZW17Ym9yZGVyOm5vbmU7cGFkZGluZzowO2ZvbnQtc2l6ZToxMHB4O319PC9zdHlsZT4KPGRpdiBjbGFzcz0id3JhcCI+CjxoMj5NdXIgZGUgU291dGVuZW1lbnQgZW4gTWFjb25uZXJpZSAvIE11cm8gZW0gQmxvY29zPC9o

Mj4KPHAgc3R5bGU9ImZvbnQtc2l6ZToxMXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi1ib3R0b206MTRweDsiPkVOIDE5OTctMToyMDA0K0ExOjIwMTMgfCBFTiAxOTk2LTEtMToyMDA1IHwgRU4gMTk5MDoyMDAyIHwgREExIEMxK0MyIOKAlCBBbWJhcyBhcyBjb21iaW5hY29lczwvcD4KPGRpdiBjbGFzcz0ibm90YS13Ij5FbmdlbmhlaXJvL0luZ2VuaWV1ciByZXNwb25zYXZlbC4gSCByZWNvbWVuZGFkbyBtZW5vciBvdSBpZ3VhbCBhIDNtIHNlbSBhcm1hZHVyYS4gREExIHJlcXVlciBDMSAoU1RSKSBlIEMyIChHRU8pLjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz5JZGVudGlmaWNhdGlvbiAvIElkZW50aWZpY2FjYW88L2gzPjxkaXYgY2xhc3M9Imcz

Ij4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+UHJvamV0IC8gT2JyYTwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJvYnJhIiBwbGFjZWhvbGRlcj0iTm9tZSBkbyBwcm9qZXRvIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+SW5nZW5pZXVyIC8gRW5nZW5oZWlybzwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJyZXNwIiBwbGFjZWhvbGRlcj0iTm9tZSAtIFJlZ2lzdHJvIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RGF0ZSAvIERhdGE8L2xhYmVsPjxpbnB1dCB0eXBlPSJkYXRlIiBpZD0iZGMiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5SZXYuPC9sYWJlbD48aW5wdXQgdHlwZT0idGV4dCIgaWQ9InJldiIg

dmFsdWU9IlIwMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlJhcHBvcnQgR2VvdGVjaG5pcXVlPC9sYWJlbD48aW5wdXQgdHlwZT0idGV4dCIgaWQ9ImxhdWRvIiBwbGFjZWhvbGRlcj0iUmVmLiBMYXVkbyI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk4uIFJlZ2lzdHJvIC8gTGljZW5jZTwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJsaWNlbmNlIiBwbGFjZWhvbGRlcj0iQ1JFQSAvIE9FIC8gSW5nLkthbW1lciI+PC9kaXY+CjwvZGl2PjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWMiPjxoMz5HZW9tZXRyaWUgLyBHZW9tZXRyaWE8L2gzPjxkaXYgY2xhc3M9Imc0Ij4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+SCB0b3RhbCAobSk8

L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJIIiB2YWx1ZT0iMi41IiBzdGVwPSIwLjEiIG1pbj0iMC41IiBtYXg9IjQuMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkhlbSAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJIZW0iIHZhbHVlPSIwLjUiIHN0ZXA9IjAuMDUiPjxzcGFuIGNsYXNzPSJ1biI+bWluIEgvMTAgPj0gMCw1bTwvc3Bhbj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+QmFzZSBCYiAobSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJCYiIgdmFsdWU9IjEuNTYiIHN0ZXA9IjAuMTAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Tb21tZXQgQnQgKG0pPC9sYWJlbD48

aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iQnQiIHZhbHVlPSIwLjM5IiBzdGVwPSIwLjEwIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+SW5jbGluLiBmYWNlIG11ciBibSAoZGVnKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImJldGFfbSIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCIgbWF4PSIxNSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkluY2xpbi4gcmVtYmxhaSBiIChkZWcpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iYmV0YSIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCIgbWF4PSIyNSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlN1cmNoYXJnZSBxIChrTi9tMik8L2xhYmVsPjxp

bnB1dCB0eXBlPSJudW1iZXIiIGlkPSJxIiB2YWx1ZT0iNSIgc3RlcD0iMSIgbWluPSIwIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+VHlwZSBzdXJjaGFyZ2U8L2xhYmVsPjxzZWxlY3QgaWQ9InRpcG9fc2MiPjxvcHRpb24gdmFsdWU9InVuaWZvcm1lIj5EaXN0cmlidWVlPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0ibmVuaHVtYSI+U2FucyBzdXJjaGFyZ2U8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPC9kaXY+PC9kaXY+CjxkaXYgY2xhc3M9InNlYyI+PGgzPk1hY29ubmVyaWUg4oCUIEVOIDE5OTYtMS0xOjIwMDU8L2gzPgo8ZGl2IGNsYXNzPSJub3RhIj5FTiAxOTk2LTEtMSBlcS4oMy4xKTogZmsgPSBLICogZmJrXjAsNyAqIGZtXjAsMyAobW9y

dGllciBnZW5lcmFsIHB1cnBvc2UpLiBHcm91dGVhZ2UgYXVnbWVudGUgZmsgZXQgcG9pZHMuPC9kaXY+CjxkaXYgY2xhc3M9Imc0Ij4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+ZmJrIGJsb2MgKE1QYSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJmYmsiIHZhbHVlPSI2IiBzdGVwPSIxIiBtaW49IjIiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5mbSBtb3J0aWVyIChNUGEpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZm0iIHZhbHVlPSI1IiBzdGVwPSIxIiBtaW49IjIiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5FcC4gam9pbnQgKG1tKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImVzcF9q

IiB2YWx1ZT0iMTIiIHN0ZXA9IjEiIG1pbj0iNiIgbWF4PSIxNSI+PHNwYW4gY2xhc3M9InVuIj5FTiAxOTk2OiAxMCstMm1tPC9zcGFuPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5JbmRpY2UgdmlkZXMgKCUpPC9sYWJlbD48c2VsZWN0IGlkPSJ2YXppb3MiPjxvcHRpb24gdmFsdWU9IjMwIj4zMCUgKHNvbGlkZSk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI0MCIgc2VsZWN0ZWQ+NDAlIChzdGFuZGFyZCk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSI1MCI+NTAlIChsZWdlcik8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Sm9pbnQgdmVydGljYWwgcmVtcGxpPC9sYWJlbD48c2VsZWN0IGlkPSJqdW50YV92Ij48

b3B0aW9uIHZhbHVlPSJuYW8iIHNlbGVjdGVkPk5vbiAoZnZrIHJlZHVpdCk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJzaW0iPk91aSAoZnZrIHBsZWluKTwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Hcm91dGFnZSAvIEdyYXV0ZWFtZW50bzwvbGFiZWw+PHNlbGVjdCBpZD0iZ3JhdXRlYW1lbnRvIj48b3B0aW9uIHZhbHVlPSJuYW8iIHNlbGVjdGVkPlNhbnMgZ3JvdXRhZ2U8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJwYXJjaWFsIj5QYXJ0aWVsICg1MCUpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0idG90YWwiPlRvdGFsICgxMDAlKTwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5n

YW1tYV9NIChFTiAxOTk2IE5BKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImdNIiB2YWx1ZT0iMi4wIiBzdGVwPSIwLjEiPjxzcGFuIGNsYXNzPSJ1biI+MiwwIG5vcm1hbDsgMSw3IHN1cGVydi48L3NwYW4+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPmdhbW1hX2FsdiAoa04vbTMpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZ2FsdiIgdmFsdWU9IjE0IiBzdGVwPSIwLjUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5EcmFpbmFnZSAvIERyZW5hZ2VtPC9sYWJlbD48c2VsZWN0IGlkPSJkcmVuIj48b3B0aW9uIHZhbHVlPSJvayI+RHJlbm8gZWZmaWNhY2U8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJiYXJiYWNh

cyI+QmFyYmFjYXMgKDUwJSBOdyk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJzZW0iPlNhbnMgZHJhaW5hZ2U8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPC9kaXY+PC9kaXY+CjxkaXYgY2xhc3M9InNlYyI+PGgzPlNvbCAvIFNvbG88L2gzPjxkaXYgY2xhc3M9Imc0Ij4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+U1VDUzwvbGFiZWw+PHNlbGVjdCBpZD0ic3VjcyI+PG9wdGlvbiB2YWx1ZT0iU1ciPlNXPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iU1AiPlNQPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iU00iIHNlbGVjdGVkPlNNPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iQ0wiPkNMPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iQ0giPkNIPC9vcHRpb24+PC9zZWxlY3Q+

PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk4tU1BUPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ibnNwdCIgdmFsdWU9IjE1IiBzdGVwPSIxIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Z2FtbWFfayAoa04vbTMpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZ3NrIiB2YWx1ZT0iMTgiIHN0ZXA9IjAuNSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPnBoaV9rIChkZWcpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icGhpIiB2YWx1ZT0iMzAiIHN0ZXA9IjEiIG1pbj0iMTAiIG1heD0iNDUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5jX2sgKGtOL20yKTwvbGFiZWw+PGlucHV0

IHR5cGU9Im51bWJlciIgaWQ9ImNvZXMiIHZhbHVlPSIwIiBzdGVwPSIxIiBtaW49IjAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5tdSBiYXNlPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ibXUiIHZhbHVlPSIwLjUwIiBzdGVwPSIwLjA1Ij48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+UmxpbSAoa04vbTIpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iUmxpbSIgdmFsdWU9IjEyMCIgc3RlcD0iMTAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Tb3VyY2UgUmxpbTwvbGFiZWw+PHNlbGVjdCBpZD0ib3JpZ19xIj48b3B0aW9uIHZhbHVlPSJjYWxjdWxvIj5UZXJ6YWdoaSAoY2FsY3VsZSk8L29wdGlv

bj48b3B0aW9uIHZhbHVlPSJkaXJldG8iPlNwZWNpZmllPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPk53IChtKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9Ik53IiB2YWx1ZT0iMCIgc3RlcD0iMC4xIiBtaW49IjAiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5rcyAoa04vbTMpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0ia3MiIHZhbHVlPSIyMDAwMCIgc3RlcD0iMTAwMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlpvbmUgc2lzbWlxdWUgYWcvZzwvbGFiZWw+PHNlbGVjdCBpZD0iYWciPjxvcHRpb24gdmFsdWU9IjAiIHNlbGVjdGVkPk5vbiBzaXNtaXF1ZTwvb3B0

aW9uPjxvcHRpb24gdmFsdWU9IjAuMDUiPmFnPTAsMDVnPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC4xMCI+YWc9MCwxMGc8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIwLjE1Ij5hZz0wLDE1Zzwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8L2Rpdj48L2Rpdj4KPGJ1dHRvbiBjbGFzcz0iYnRuLWNhbGMiIG9uY2xpY2s9ImNhbGNCbG9jb0V1cm8oKSI+Q2FsY3VsZXIgLyBDYWxjdWxhciDigJQgRU4gMTk5NyArIEVOIDE5OTYgKERBMSBDMStDMik8L2J1dHRvbj4KPGRpdiBpZD0icmVzdWx0YWRvIj48ZGl2IGNsYXNzPSJzZWMiIGlkPSJzZWMtcmVzIj4KPGgzPlJlc3VsdGF0cyAvIFJlc3VsdGFkb3Mg4oCUIERBMSBDMSBldCBDMjwvaDM+CjxkaXYgY2xhc3M9InNl

bSIgaWQ9InNlbWFmb3JvIj48L2Rpdj4KPGgzIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPkFsZXJ0ZXMgLyBBbGVydGFzPC9oMz48ZGl2IGlkPSJhbGVydGFzX3JlcyI+PC9kaXY+CjxoMyBzdHlsZT0ibWFyZ2luLXRvcDo4cHg7Ij5Ob3RlIGRlIENhbGN1bCAvIE1lbW9yaWFsPC9oMz4KPGJ1dHRvbiBjbGFzcz0iYnRuLXBkZiIgb25jbGljaz0id2luZG93LnByaW50KCkiPkV4cG9ydGVyIFBERjwvYnV0dG9uPgo8ZGl2IGNsYXNzPSJtZW0iIGlkPSJtZW1vcmlhbCI+PC9kaXY+CjwvZGl2PjwvZGl2PjwvZGl2Pgo8c2NyaXB0PgpmdW5jdGlvbiB0b1JhZChkKXtyZXR1cm4gZCpNYXRoLlBJLzE4MDt9CmZ1bmN0aW9uIGZtdCh2LGQpe3JldHVybiBOdW1iZXIodiku

dG9GaXhlZChkPT09dW5kZWZpbmVkPzM6ZCk7fQpmdW5jdGlvbiBjYXBhVGV6KHBkLGMsZ3MsRGYsQil7CiAgdmFyIHA9dG9SYWQocGQpLE5xPU1hdGguZXhwKE1hdGguUEkqTWF0aC50YW4ocCkpKk1hdGgucG93KE1hdGgudGFuKE1hdGguUEkvNCtwLzIpLDIpLE5jPShOcS0xKS9NYXRoLnRhbihwKSxOZz0yKihOcSsxKSpNYXRoLnRhbihwKSxxMD1ncypEZixxdWx0PWMqTmMrcTAqTnErMC41KmdzKkIqTmc7CiAgcmV0dXJue3F1bHQ6cXVsdCxxYWRtOnF1bHQvMyxOcTpOcSxOYzpOYyxOZzpOZ307fQpmdW5jdGlvbiBjYWxjQmxvY29FdXJvKCl7CiAgdmFyIG9icmE9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ29icmEnKS52YWx1ZXx8JyhuL3MpJzsKICB2YXIg

cmVzcD1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzcCcpLnZhbHVlfHwnKG4vcyknOwogIHZhciBkY192PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkYycpLnZhbHVlfHxuZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7CiAgdmFyIHJldj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmV2JykudmFsdWV8fCdSMDAnOwogIHZhciBsYXVkbz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGF1ZG8nKS52YWx1ZXx8JyhuL3MpJzsKICB2YXIgbGljZW5jZT1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGljZW5jZScpLnZhbHVlfHwnKG4vcyknOwogIHZhciBIPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnSCcpLnZhbHVlOwogIHZhciBIZW09

K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdIZW0nKS52YWx1ZTsKICB2YXIgQmI9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdCYicpLnZhbHVlOwogIHZhciBCdD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0J0JykudmFsdWU7CiAgdmFyIGJldGFfbT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2JldGFfbScpLnZhbHVlOwogIHZhciBiZXRhPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYmV0YScpLnZhbHVlOwogIHZhciBxPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncScpLnZhbHVlOwogIHZhciB0aXBvX3NjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0aXBvX3NjJykudmFsdWU7CiAgdmFyIGZiaz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo

J2ZiaycpLnZhbHVlOwogIHZhciBmbV9tPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZm0nKS52YWx1ZTsKICB2YXIgZXNwX2o9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdlc3BfaicpLnZhbHVlOwogIHZhciB2YXppb3M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd2YXppb3MnKS52YWx1ZTsKICB2YXIganVudGFfdj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnanVudGFfdicpLnZhbHVlOwogIHZhciBncmF1dD1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ3JhdXRlYW1lbnRvJykudmFsdWU7CiAgdmFyIGdNPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ00nKS52YWx1ZTsKICB2YXIgZ2Fsdl9iYXNlPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgn

Z2FsdicpLnZhbHVlOwogIHZhciBkcmVuPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkcmVuJykudmFsdWU7CiAgdmFyIHN1Y3M9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3N1Y3MnKS52YWx1ZTsKICB2YXIgbnNwdD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ25zcHQnKS52YWx1ZTsKICB2YXIgZ3NrPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ3NrJykudmFsdWU7CiAgdmFyIHBoaV9rPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncGhpJykudmFsdWU7CiAgdmFyIGNfaz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvZXMnKS52YWx1ZTsKICB2YXIgbXU9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdtdScpLnZhbHVlOwogIHZhciBSbGltX2lu

cD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ1JsaW0nKS52YWx1ZTsKICB2YXIgb3JpZ19xPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdvcmlnX3EnKS52YWx1ZTsKICB2YXIgTnc9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdOdycpLnZhbHVlOwogIHZhciBrcz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2tzJykudmFsdWU7CiAgdmFyIGFnPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWcnKS52YWx1ZTsKICB2YXIgYWxlcnRhcz1bXTsKICAvLyBHcmF1dGVhbWVudG8KICB2YXIgZ3JhdXRfZms9Z3JhdXQ9PT0ndG90YWwnPzEuMTU6KGdyYXV0PT09J3BhcmNpYWwnPzEuMDc6MS4wKTsKICB2YXIgZ2Fsdj1ncmF1dD09PSd0b3RhbCc/Z2Fsdl9iYXNl

KzIuMDooZ3JhdXQ9PT0ncGFyY2lhbCc/Z2Fsdl9iYXNlKzEuMDpnYWx2X2Jhc2UpOwogIC8vIEVtYnV0aW1lbnRvIG1pbiBFTiAxOTk3LTEgc2VjdGlvbiA2LjQKICB2YXIgSGVtX21pbj1NYXRoLm1heCgwLjUwLEgvMTApOwogIGlmKEhlbTxIZW1fbWluKSBhbGVydGFzLnB1c2goJ0VNQlVUSU1FTlRPOiBIZW09JytmbXQoSGVtLDIpKydtIDwgbWluPScrZm10KEhlbV9taW4sMikrJ20gKEVOIDE5OTctMSBpdGVtIDYuNCknKTsKICBpZihIPjMuMCkgYWxlcnRhcy5wdXNoKCdIQVVURVVSOiBIPScrSCsnbSA+IDNtIFx1MjAxNCBFTiAxOTk2LTEtMSBpdGVtIDUuNTogZW52aXNhZ2VyIGJldG9uIGFybWUnKTsKICBpZihCdDwwLjMwKSBhbGVydGFzLnB1c2goJ1NP

TU1FVDogQnQ9JytmbXQoQnQsMikrJ20gPCAwLDMwbSBcdTIwMTQgbWluIHJlY29tbWFuZGUnKTsKICBpZihlc3Bfajw2fHxlc3Bfaj4xNSkgYWxlcnRhcy5wdXNoKCdKT0lOVDogJytlc3BfaisnbW0gaG9ycyAxMCstMm1tIChFTiAxOTk2LTEtMSBpdGVtIDguMS41KScpOwogIGlmKGRyZW49PT0nc2VtJykgYWxlcnRhcy5wdXNoKCdEUkFJTkFHRSBBQlNFTlQgXHUyMDE0IHJpc3F1ZSBjcml0aXF1ZS4gRU4gMTk5Ny0xIGl0ZW0gNi41LjQnKTsKICAvLyBFTiAxOTk2LTEtMSBlcS4oMy4xKTogZmsgPSBLICogZmJrXmFscGhhICogZm1eYmV0YQogIC8vIEs9MCw1NSAoR1AgbW9ydGFyLCBHcm91cCAxKSwgYWxwaGE9MCw3LCBiZXRhPTAsMwogIHZhciBLX2VuPTAu

NTU7CiAgdmFyIGZrX2VuPUtfZW4qTWF0aC5wb3coZmJrLDAuNykqTWF0aC5wb3coZm1fbSwwLjMpOwogIHZhciBmYXRvcl92YXppb3M9MS4wLSh2YXppb3MtNDApLzEwMCowLjE1OwogIHZhciBmaz1ma19lbipmYXRvcl92YXppb3MqZ3JhdXRfZms7CiAgdmFyIGZkX2Fsdj1may9nTTsgLy8gRU4gMTk5Ni0xLTEgaXRlbSAyLjQuMwogIC8vIGZ2ayBFTiAxOTk2LTEtMSBpdGVtIDMuNi4yCiAgdmFyIGZ2azA9anVudGFfdj09PSdzaW0nPzAuMTU6MC4xMDsgLy8gTVBhCiAgLy8gU3VicHJlc3NhbwogIHZhciBOd19lZmY9Tnc7CiAgaWYoZHJlbj09PSdvaycpIE53X2VmZj0wOwogIGlmKGRyZW49PT0nYmFyYmFjYXMnKSBOd19lZmY9TncqMC41OwogIHZhciBVX3N1

Yj0wLFVfeWE9MDsKICBpZihOd19lZmY+MCYmTndfZWZmPD1IKXtVX3N1Yj0wLjUqMTAqTndfZWZmKk53X2VmZjtVX3lhPU53X2VmZi8zO30KICAvLyBQcmVzc2FvIHBhc3NpdmEgRU4gMTk5Ny0xIGl0ZW0gNi41LjMgXHUyMDE0IGNhbGN1bGFkYSBtYXMgbmFvIHV0aWxpemFkYQogIHZhciBwaGlfa19yPXRvUmFkKHBoaV9rKTsKICB2YXIgS3A9TWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80K3BoaV9rX3IvMiksMik7CiAgdmFyIEVwPTAuNSpLcCpnc2sqSGVtKkhlbTsKICAvLyBEQTEgXHUyMDE0IENvbWJpbmFjb2VzIEMxIChTVFIsIGdhbW1hX3BoaT0xLDApIGUgQzIgKEdFTywgZ2FtbWFfcGhpPTEsMjUpCiAgLy8gRU4gMTk5Ny0xIFRhYmVsYSBBLjQ6IEMx

OiBnRz0xLDM1IGdRPTEsNTAgZ3BoaT0xLDAgZ2M9MSwwCiAgLy8gICAgICAgICAgICAgICAgICAgICAgICBDMjogZ0c9MSwwICBnUT0xLDMwIGdwaGk9MSwyNSBnYz0xLDI1CiAgZnVuY3Rpb24gY2FsY0NvbWIoZ0csZ1EsZ3BoaSxnY19zLGxhYmVsKXsKICAgIHZhciBwaGlfZD1NYXRoLmF0YW4oTWF0aC50YW4ocGhpX2tfcikvZ3BoaSk7CiAgICB2YXIgY19kPWNfay9nY19zOwogICAgLy8gS2EgUmFua2luZSBjb20gcGhpX2QgKGNvbnNlcnZhZG9yIHBhcmEgYWx2ZW5hcmlhKQogICAgdmFyIEthX3I9TWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80LXBoaV9kLzIpLDIpOwogICAgLy8gS2EgQ291bG9tYiBjb20gZGVsdGE9cGhpX2QvMyBwYXJhIHJlZmVyZW5j

aWEKICAgIHZhciBkZWx0YV9kPXBoaV9kLzMrdG9SYWQoYmV0YV9tKTsKICAgIHZhciBLYV9jX249TWF0aC5wb3coTWF0aC5zaW4oTWF0aC5QSS8yK3BoaV9kKSwyKTsKICAgIHZhciBLYV9jX3NxPU1hdGguc3FydChNYXRoLnNpbihwaGlfZCtkZWx0YV9kKSpNYXRoLnNpbihwaGlfZC10b1JhZChiZXRhKSkvKE1hdGguc2luKE1hdGguUEkvMi1kZWx0YV9kKSpNYXRoLnNpbihNYXRoLlBJLzIrdG9SYWQoYmV0YSkpKSk7CiAgICB2YXIgS2FfYz1LYV9jX24vKE1hdGgucG93KE1hdGguc2luKE1hdGguUEkvMiksMikqTWF0aC5zaW4oTWF0aC5QSS8yLWRlbHRhX2QpKk1hdGgucG93KDErS2FfY19zcSwyKSk7CiAgICB2YXIgS2E9S2FfcjsgLy8gUmFua2luZSB1dGls

aXphZG8KICAgIC8vIEZvcmNhcyBjb20gS2FfciAocGhpX2QpCiAgICB2YXIgRWFfZz1nRyowLjUqS2EqZ3NrKkgqSDsKICAgIHZhciBFYXZfZz1FYV9nKk1hdGguc2luKHRvUmFkKGJldGFfbSkpOwogICAgdmFyIEVhaF9nPUVhX2cqTWF0aC5jb3ModG9SYWQoYmV0YV9tKSk7CiAgICB2YXIgRWFfcT10aXBvX3NjIT09J25lbmh1bWEnP2dRKkthKnEqSDowOwogICAgdmFyIEVhdl9xPUVhX3EqTWF0aC5zaW4odG9SYWQoYmV0YV9tKSk7CiAgICB2YXIgRWFoX3E9RWFfcSpNYXRoLmNvcyh0b1JhZChiZXRhX20pKTsKICAgIHZhciBFYWg9RWFoX2crRWFoX3ErVV9zdWI7CiAgICB2YXIgRWF2PUVhdl9nK0Vhdl9xOwogICAgdmFyIEFtPShCYitCdCkvMipIOwogICAg

dmFyIHhjZz1CYi8zKihCYisyKkJ0KS8oQmIrQnQpOwogICAgdmFyIEJjPUJiLUJ0OwogICAgdmFyIFdtPWdHKmdhbHYqQW07CiAgICB2YXIgV3M9Z0cqZ3NrKihCYy8yKSpIOwogICAgdmFyIHhzPUJiLUJjLzM7CiAgICB2YXIgVj1XbStXcytFYXY7CiAgICB2YXIgTWU9V20qeGNnK1dzKnhzK0VhdipCYjsKICAgIHZhciBNdD1FYWhfZyooSC8zKStFYWhfcSooSC8yKStVX3N1YipVX3lhOwogICAgdmFyIENTX3Q9TWUvTWF0aC5tYXgoTXQsMC4wMDEpOwogICAgdmFyIEZyPU1hdGgudGFuKHBoaV9kKSpWK2NfZCpCYjsKICAgIHZhciBDU19kPUZyL01hdGgubWF4KEVhaCwwLjAwMSk7CiAgICB2YXIgeFI9KE1lLU10KS9WOwogICAgdmFyIGU9TWF0aC5hYnMoQmIv

Mi14Uik7CiAgICB2YXIgQmVmZj1NYXRoLm1heChCYi0yKmUsMC4xKTsKICAgIHZhciBxbWF4PVYvQmIqKDErNiplL0JiKTsKICAgIHZhciBxbWluPVYvQmIqKDEtNiplL0JiKTsKICAgIHJldHVybntLYV9yOkthX3IsS2FfYzpLYV9jLHBoaV9kX2RlZzpwaGlfZCoxODAvTWF0aC5QSSxjX2Q6Y19kLAogICAgICAgICAgIEVhaDpFYWgsRWF2OkVhdixFYWhfZzpFYWhfZyxFYWhfcTpFYWhfcSxFYXZfZzpFYXZfZywKICAgICAgICAgICBWOlYsTWU6TWUsTXQ6TXQsQ1NfdDpDU190LEZyOkZyLENTX2Q6Q1NfZCwKICAgICAgICAgICB4Ujp4UixlOmUsQmVmZjpCZWZmLHFtYXg6cW1heCxxbWluOnFtaW4sCiAgICAgICAgICAgV206V20sV3M6V3MseGNnOnhjZyx4czp4

cyxsYWJlbDpsYWJlbCxnRzpnRyxnUTpnUSxncGhpOmdwaGksCiAgICAgICAgICAgc2lnbWFfYmFzZTpWL0JiLEFtOkFtfTsKICB9CiAgdmFyIGMxPWNhbGNDb21iKDEuMzUsMS41MCwxLjAsMS4wLCdEQTEtQzEgKFNUUiknKTsKICB2YXIgYzI9Y2FsY0NvbWIoMS4wLDEuMzAsMS4yNSwxLjI1LCdEQTEtQzIgKEdFTyknKTsKICAvLyBHb3Zlcm5hIGNhZGEgdmVyaWZpY2FjYW8KICB2YXIgQ1NfdF9nb3Y9TWF0aC5taW4oYzEuQ1NfdCxjMi5DU190KTsKICB2YXIgQ1NfZF9nb3Y9TWF0aC5taW4oYzEuQ1NfZCxjMi5DU19kKTsKICB2YXIgcW1heF9nb3Y9TWF0aC5tYXgoYzEucW1heCxjMi5xbWF4KTsKICB2YXIgcW1pbl9nb3Y9TWF0aC5taW4oYzEucW1pbixjMi5x

bWluKTsKICB2YXIgZV9nb3Y9TWF0aC5tYXgoYzEuZSxjMi5lKTsKICB2YXIgQmVmZl9nb3Y9TWF0aC5taW4oYzEuQmVmZixjMi5CZWZmKTsKICB2YXIgVl9nb3Y9YzIuVjsgLy8gR0VPIGdvdmVybmEgY2FwYWNpZGFkZSBkZSBjYXJnYQogIHZhciBFYWhfZ292PU1hdGgubWF4KGMxLkVhaCxjMi5FYWgpOwogIGlmKENTX3RfZ292PDEuMCkgYWxlcnRhcy5wdXNoKCdUT01CRU1FTlQ6IENTPScrZm10KENTX3RfZ292LDMpKycgPCAxLDAgKEVOIDE5OTctMSBpdGVtIDIuNC43KScpOwogIGlmKENTX2RfZ292PDEuMCkgYWxlcnRhcy5wdXNoKCdHTElTU0VNRU5UOiBDUz0nK2ZtdChDU19kX2dvdiwzKSsnIDwgMSwwIChFTiAxOTk3LTEgaXRlbSA2LjUuMyknKTsKICBp

ZihxbWluX2dvdjwwKSBhbGVydGFzLnB1c2goJ0JBU0U6IHFfbWluPScrZm10KHFtaW5fZ292LDIpKydrTi9tMiA8IDAgXHUyMDE0IHRyYWN0aW9uIGEgbGEgYmFzZSEnKTsKICBpZihlX2dvdj5CYi82KSBhbGVydGFzLnB1c2goJ0VYQ0VOVFJJQ0lURTogZT0nK2ZtdChlX2dvdiw0KSsnbSA+IEIvNj0nK2ZtdChCYi82LDQpKydtIChFTiAxOTk3LTEgaXRlbSA2LjUuNCknKTsKICAvLyBDYXBhY2lkYWRlIGRlIGNhcmdhIGNvbSBCJyBlZmV0aXZvCiAgdmFyIHRlej1jYXBhVGV6KHBoaV9rLGNfayxnc2ssSGVtLEJlZmZfZ292KTsKICB2YXIgUmxpbV91c289b3JpZ19xPT09J2NhbGN1bG8nP3Rlei5xYWRtOlJsaW1faW5wOwogIGlmKHFtYXhfZ292PlJsaW1fdXNv

KSBhbGVydGFzLnB1c2goJ1BPUlRBTkNFOiBxX21heD0nK2ZtdChxbWF4X2dvdiwyKSsnID4gUmxpbT0nK2ZtdChSbGltX3VzbywyKSsna04vbTInKTsKICAvLyBWZXJpZmljYWNhbyBhbHZlbmFyaWEgKEMxIGdvdmVybmEgU1RSKQogIHZhciBzaWdtYV9iYXNlX2MxPWMxLlYvQmI7IC8vIHByZXNzYW8gbWVkaWEgKE1QYSBxdWFuZG8gLzEwMDApCiAgdmFyIHNpZ21hX2Jhc2Vfa1BhPVZfZ292L0JiKigxKzYqZV9nb3YvQmIpOwogIHZhciBzaWdtYV9jb21wPXNpZ21hX2Jhc2Vfa1BhLzEwMDA7IC8vIE1QYQogIHZhciBva19jb21wPXNpZ21hX2NvbXA8PWZkX2FsdjsKICBpZighb2tfY29tcCkgYWxlcnRhcy5wdXNoKCdDT01QUkVTU0lPTiAoQzEtU1RSKTogc2ln

bWE9JytmbXQoc2lnbWFfY29tcCoxMDAwLDEpKydrUGEgPiBmZD0nK2ZtdChmZF9hbHYqMTAwMCwxKSsna1BhIChFTiAxOTk2LTEtMSBpdGVtIDYuMS4yKScpOwogIC8vIENpc2FsaGFtZW50byBiYXNlIChDMSkKICB2YXIgZnZrX2Jhc2U9TWF0aC5taW4oZnZrMCswLjQqc2lnbWFfYmFzZV9rUGEvMTAwMCwwLjA2NSpmYmspOwogIHZhciBmdmRfYmFzZT1mdmtfYmFzZS9nTTsKICB2YXIgdGF1X2Jhc2U9YzEuRWFoL0JiLzEwMDA7CiAgdmFyIG9rX2Npcz10YXVfYmFzZTw9ZnZkX2Jhc2U7CiAgaWYoIW9rX2NpcykgYWxlcnRhcy5wdXNoKCdDSVNBSUxMRU1FTlQgQkFTRSAoQzEtU1RSKTogdGF1PScrZm10KHRhdV9iYXNlKjEwMDAsMikrJ2tQYSA+IGZ2ZD0nK2Zt

dChmdmRfYmFzZSoxMDAwLDIpKydrUGEgKEVOIDE5OTYtMS0xIGl0ZW0gNi41KScpOwogIC8vIEluY2xpbmFjYW8gcmVzdWx0YW50ZSBuYSBqdW50YQogIHZhciB0aGV0YV9yZXM9TWF0aC5hdGFuKGMxLkVhaC9jMS5WKSoxODAvTWF0aC5QSTsKICB2YXIgdGhldGFfbGltPU1hdGguYXRhbihmdmRfYmFzZS8oTWF0aC5tYXgoc2lnbWFfYmFzZV9rUGEsMC4wMDEpLzEwMDApKSoxODAvTWF0aC5QSTsKICB2YXIgb2tfdGhldGE9dGhldGFfcmVzPD10aGV0YV9saW07CiAgaWYoIW9rX3RoZXRhKSBhbGVydGFzLnB1c2goJ0lOQ0xJTkFJU09OIFJFU1VMVEFOVEU6IHRoZXRhPScrZm10KHRoZXRhX3JlcywxKSsnZGVnID4gdGhldGFfbGltPScrZm10KHRoZXRhX2xpbSwx

KSsnZGVnIChFTiAxOTk2LTEtMSBpdGVtIDYuMS4yLjEpJyk7CiAgLy8gSnVudGFzIGludGVybWVkaWFyaWFzIChFTiAxOTk2LTEtMSBpdGVtIDYuNS4yKQogIHZhciBIMj1ILzIsSDM9SC8zOwogIGZ1bmN0aW9uIGNoZWNrSnVudGEoaGksbGJsKXsKICAgIHZhciBFYWhfaT0wLjUqYzEuS2Ffcipnc2sqaGkqaGkrKHRpcG9fc2MhPT0nbmVuaHVtYSc/YzEuZ1EqYzEuS2FfcipxKmhpOjApOwogICAgdmFyIEJ0X2k9QnQrKEJiLUJ0KSooSC1oaSkvSDsKICAgIHZhciBBbV9pPShCdF9pK0J0KS8yKmhpOwogICAgdmFyIFZfaT1nYWx2KkFtX2k7CiAgICB2YXIgc2lnX2k9Vl9pL0J0X2k7CiAgICB2YXIgZnZrX2k9TWF0aC5taW4oZnZrMCswLjQqc2lnX2kvMTAwMCww

LjA2NSpmYmspOwogICAgdmFyIGZ2ZF9pPWZ2a19pL2dNOwogICAgdmFyIHRhdV9pPUVhaF9pL0J0X2kvMTAwMDsKICAgIHZhciBvaz10YXVfaTw9ZnZkX2k7CiAgICBpZighb2spIGFsZXJ0YXMucHVzaCgnQ0lTQUlMTEVNRU5UICcrbGJsKyc6IHRhdT0nK2ZtdCh0YXVfaSoxMDAwLDIpKydrUGEgPiBmdmQ9JytmbXQoZnZkX2kqMTAwMCwyKSsna1BhIChFTiAxOTk2LTEtMSBpdGVtIDYuNS4yKScpOwogICAgcmV0dXJue0VhaF9pOkVhaF9pLEJ0X2k6QnRfaSxzaWdfaTpzaWdfaSxmdmRfaTpmdmRfaSx0YXVfaTp0YXVfaSxvazpva307CiAgfQogIHZhciBqMj1jaGVja0p1bnRhKEgyLCdILzI9JytmbXQoSDIsMikrJ20nKTsKICB2YXIgajM9Y2hlY2tKdW50YShI

MywnSC8zPScrZm10KEgzLDIpKydtJyk7CiAgLy8gQmlzaG9wIGV4cGVkaXRvCiAgdmFyIENTX2NpcmM9OTk5OwogIGZvcih2YXIgaWM9MDtpYzw1O2ljKyspewogICAgdmFyIEZtX2M9MC41KmdzaypIKkgqTWF0aC5zaW4odG9SYWQoNDUtcGhpX2svMikpL01hdGgudGFuKHBoaV9rX3IpOwogICAgdmFyIEZyX2M9MC41KmdzaypIKkgqTWF0aC5jb3ModG9SYWQoNDUtcGhpX2svMikpK2NfaypIL01hdGguY29zKHRvUmFkKDQ1LXBoaV9rLzIpKTsKICAgIHZhciBSYz1IKigwLjcraWMqMC4xKTsKICAgIHZhciBDU19jPUZyX2MvTWF0aC5tYXgoRm1fYywwLjAwMSkqTWF0aC5zcXJ0KFJjLygwLjgqSCkpOwogICAgaWYoQ1NfYzxDU19jaXJjKSBDU19jaXJjPUNTX2M7

CiAgfQogIGlmKENTX2NpcmM8MS41KSBhbGVydGFzLnB1c2goJ1NUQUJJTElURSBHTE9CQUxFOiBDUz0nK2ZtdChDU19jaXJjLDMpKycgPCAxLDUgKEVOIDE5OTctMSBpdGVtIDExLjUpJyk7CiAgLy8gU2lzbWljYSBFTiAxOTk4LTUKICB2YXIgQ1N0X3Npcz0wLENTZF9zaXM9MDsKICBpZihhZz4wKXsKICAgIHZhciBkUGFlPTAuMzc1KmFnKjAuNSpnc2sqSCpIOwogICAgdmFyIHlhX3M9MC42Kkg7CiAgICBDU3Rfc2lzPWMyLk1lLyhjMi5NdCtkUGFlKnlhX3MpOwogICAgQ1NkX3Npcz1jMi5Gci8oYzIuRWFoK2RQYWUpOwogICAgaWYoQ1N0X3NpczwxLjApIGFsZXJ0YXMucHVzaCgnU0lTTUlRVUUgKEVOIDE5OTgtNSk6IENTX3RvbWI9JytmbXQoQ1N0X3Npcywz

KSsnIDwgMSwwJyk7CiAgICBpZihDU2Rfc2lzPDEuMCkgYWxlcnRhcy5wdXNoKCdTSVNNSVFVRSAoRU4gMTk5OC01KTogQ1NfZGVzbD0nK2ZtdChDU2Rfc2lzLDMpKycgPCAxLDAnKTsKICB9CiAgLy8gUmVjYWxxdWUKICB2YXIgRGVsdGFfcT1NYXRoLm1heChxbWF4X2dvdi1nc2sqSGVtLDApOwogIHZhciByZWNfbW09cGhpX2s+PTI1P0RlbHRhX3EqQmVmZl9nb3YqMTAqMi9uc3B0OkRlbHRhX3EqQmVmZl9nb3Yva3MqMTAwMDsKICAvLyBTZW1hZm9ybwogIGZ1bmN0aW9uIHNJKGxibCx2YWwscmVxLGV4LGludil7CiAgICB2YXIgcmF0aW89aW52PyhyZXEvTWF0aC5tYXgodmFsLDAuMDAwMSkpOih2YWwvTWF0aC5tYXgocmVxLDAuMDAwMSkpOwogICAgdmFyIGNs

cz1yYXRpbz49MS4xNT8nb2stcyc6KHJhdGlvPj0xLjA/J3dhcm4tcyc6J2Vyci1zJyk7CiAgICB2YXIgaWM9cmF0aW8+PTEuMTU/J09LICc6KHJhdGlvPj0xLjA/J09LISc6J0ZBSUwnKTsKICAgIHJldHVybiAnPGRpdiBjbGFzcz0ic2l0ZW0gJytjbHMrJyI+PGRpdiBjbGFzcz0ic2xibCI+JytsYmwrJzwvZGl2PjxkaXYgY2xhc3M9InN2YWwiPicraWMrJzwvZGl2PjxkaXYgY2xhc3M9InNyZXEiPicrZm10KHZhbCwyKSsoZXg/JyB8ICcrZXg6JycpKyc8L2Rpdj48L2Rpdj4nOwogIH0KICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc2VtYWZvcm8nKS5pbm5lckhUTUw9CiAgICBzSSgnVG9tYmVtZW50XG5DMStDMicsQ1NfdF9nb3YsMS4wLCc+MSwwJykrCiAg

ICBzSSgnR2xpc3NlbWVudFxuQzErQzInLENTX2RfZ292LDEuMCwnPjEsMCcpKwogICAgc0koJ1BvcnRhbmNlXG5SbGltJyxSbGltX3VzbyxxbWF4X2dvdiwncT0nK2ZtdChxbWF4X2dvdiwxKSx0cnVlKSsKICAgIHNJKCdFeGNlbnRyLlxuZShtKScsQmIvNixlX2dvdiwnQi82PScrZm10KEJiLzYsMyksdHJ1ZSkrCiAgICBzSSgnQ29tcHJlc3MuXG5FTjE5OTYnLGZkX2FsdioxMDAwLHNpZ21hX2NvbXAqMTAwMCwnZmQ9JytmbXQoZmRfYWx2KjEwMDAsMSkrJ2tQYScsdHJ1ZSkrCiAgICBzSSgnQ2lzYWlsbC5cbmpvaW50JyxmdmRfYmFzZSoxMDAwLHRhdV9iYXNlKjEwMDAsJ2Z2ZD0nK2ZtdChmdmRfYmFzZSoxMDAwLDIpLHRydWUpKwogICAgc0koJ0luY2xpbi5c

bnJlc3VsdC4nLHRoZXRhX2xpbSx0aGV0YV9yZXMsJ2xpbT0nK2ZtdCh0aGV0YV9saW0sMSkrJ2cnLHRydWUpKwogICAgc0koJ1N0YWJpbGl0ZVxuZ2xvYmFsZScsQ1NfY2lyYywxLjUsJz4xLDUnKTsKICAvLyBBbGVydGFzCiAgdmFyIGFkcj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWxlcnRhc19yZXMnKTsKICBhZHIuaW5uZXJIVE1MPWFsZXJ0YXMubGVuZ3RoP2FsZXJ0YXMubWFwKGZ1bmN0aW9uKGEpe3JldHVybiAnPGRpdiBjbGFzcz0iYWxlcnRhIj4nK2ErJzwvZGl2Pic7fSkuam9pbignJyk6JzxkaXYgc3R5bGU9ImJhY2tncm91bmQ6dmFyKC0tb2spO2NvbG9yOnZhcigtLW9rYik7Ym9yZGVyLXJhZGl1czo1cHg7cGFkZGluZzo4cHggMTJweDtmb250

LXNpemU6MTFweDsiPkF1Y3VuZSBhbGVydGUgLyBTZW0gYWxlcnRhcy48L2Rpdj4nOwogIC8vIE1lbW9yaWFsCiAgdmFyIFNFUD0nPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSc7CiAgdmFyIG1lbT0nPGg0PicrU0VQKyc8L2g0Pic7CiAgbWVtKz0nICBOT1RFIERFIENBTENVTCBcdTIwMTQgTVVSIE1BQ09OTkVSSUUgRU4gQkxPQ1MgLyBNRU1PUklBTCBNVVJPIEJMT0NPU1xuJzsKICBtZW0rPScgIEVOIDE5OTctMToyMDA0K0ExOjIwMTMgfCBFTiAxOTk2LTEtMToyMDA1IHwgRU4gMTk5MDoyMDAyIHwgRU4gMTk5OC01OjIwMDRcbjxoND4nK1NFUCsnPC9oND5cbic7CiAgbWVtKz0nICBQcm9q

ZXQvT2JyYTogJytvYnJhKycgIHwgIEluZy4vRW5nLjogJytyZXNwKycgIHwgIExpY2VuY2UvUmVnLjogJytsaWNlbmNlKydcbic7CiAgbWVtKz0nICBEYXRlOiAnK2RjX3YrJyAgUmV2LjogJytyZXYrJyAgfCAgUmFwcG9ydCBnZW90ZWNobi46ICcrbGF1ZG8rJ1xuXG4nOwogIG1lbSs9JzxoND4xLiBHRU9NRVRSSUUgLyBHRU9NRVRSSUE8L2g0Pic7CiAgbWVtKz0nICBIPScrSCsnbSAgSGVtPScrSGVtKydtIFttaW49JytmbXQoSGVtX21pbiwyKSsnbSAnKyhIZW0+PUhlbV9taW4/J09LJzonRkFJTCcpKyddXG4nOwogIG1lbSs9JyAgQmI9JytCYisnbSAgQnQ9JytCdCsnbSAgQmIvSD0nK2ZtdChCYi9ILDIpKydcbic7CiAgbWVtKz0nICBiZXRhX211cm89Jyti

ZXRhX20rJ2RlZyAgYmV0YV9hdGVycm89JytiZXRhKydkZWcgIHE9JytxKydrTi9tMlxuXG4nOwogIG1lbSs9JzxoND4yLiBFTiAxOTk2LTEtMToyMDA1IFx1MjAxNCBSRVNJU1RBTkNFIE1BQ09OTkVSSUU8L2g0Pic7CiAgbWVtKz0nICBmYms9JytmYmsrJ01QYSAgZm09JytmbV9tKydNUGEgIGdhbW1hX009JytnTSsnICBqb2ludD0nK2VzcF9qKydtbSAgdmlkZXM9Jyt2YXppb3MrJyVcbic7CiAgbWVtKz0nICBKb2ludCB2ZXJ0aWNhbDogJytqdW50YV92KycgIEdyb3V0YWdlOiAnK2dyYXV0Kydcbic7CiAgbWVtKz0nICBmdmswID0gJytmdmswKycgTVBhIChFTiAxOTk2LTEtMSBpdGVtIDMuNi4yIFx1MjAxNCBqb2ludCB2ZXJ0aWNhbCAnKyhqdW50YV92PT09

J3NpbSc/J3JlbXBsaSc6J25vbiByZW1wbGknKSsnKVxuJzsKICBtZW0rPScgIEs9MCw1NSAoR1AgbW9ydGFyLCBHcm91cCAxIFx1MjAxNCBFTiAxOTk2LTEtMSBUYWJsZSAzLjMpXG4nOwogIG1lbSs9JyAgZmsgPSBLICogZmJrXjAsNyAqIGZtXjAsMyAqIGZfdmlkZXMgKiBmX2dyb3V0XG4nOwogIG1lbSs9JyAgICAgPSAwLDU1ICogJytmYmsrJ14wLDcgKiAnK2ZtX20rJ14wLDMgKiAnK2ZtdChmYXRvcl92YXppb3MsMykrJyAqICcrZm10KGdyYXV0X2ZrLDMpKycgPSAnK2ZtdChmaywzKSsnTVBhXG4nOwogIG1lbSs9JyAgZmQgPSBmay9nYW1tYV9NID0gJytmbXQoZmssMykrJy8nK2dNKycgPSAnK2ZtdChmZF9hbHYsNCkrJ01QYSA9ICcrZm10KGZkX2Fsdiox

MDAwLDIpKydrUGFcblxuJzsKICBtZW0rPSc8aDQ+My4gVEVSWkFHSEkgXHUyMDE0IFBPUlRBTkNFIC8gQ0FQQUNJREFERSBDQVJHQSAoYXZlYyBCIGVmZXRpdm8pPC9oND4nOwogIG1lbSs9JyAgcGhpX2s9JytwaGlfaysnZGVnICBjX2s9JytjX2srJ2tOL20yICBEZj0nK0hlbSsnbSAgQl9lZmV0aXZvPScrZm10KEJlZmZfZ292LDQpKydtXG4nOwogIG1lbSs9JyAgTnE9JytmbXQodGV6Lk5xLDMpKycgIE5jPScrZm10KHRlei5OYywzKSsnICBOZ2FtbWE9JytmbXQodGV6Lk5nLDMpKydcbic7CiAgbWVtKz0nICBxdWx0PScrZm10KHRlei5xdWx0LDIpKydrTi9tMiAgcWFkbT0nK2ZtdCh0ZXoucWFkbSwyKSsna04vbTIgIFJsaW1fdXNvPScrZm10KFJsaW1fdXNv

LDIpKydrTi9tMlxuJzsKICBtZW0rPScgIEVwIChwYXNzaWYgcGllZCkgPSAwLDUqS3AqZ3MqSGVtXjIgPSAnK2ZtdChFcCwzKSsna04vbSBbTk9OIHV0aWxpc2UgXHUyMDE0IGNvbnNlcnZhdGV1ciwgRU4gMTk5Ny0xIGl0ZW0gNi41LjNdXG5cbic7CiAgbWVtKz0nPGg0PjQuIERBMS1DMSAoU1RSOiBnYW1tYV9HPTEsMzUgZ2FtbWFfUT0xLDUwIGdhbW1hX3BoaT0xLDApPC9oND4nOwogIG1lbSs9JyAgcGhpX2Q9JytmbXQoYzEucGhpX2RfZGVnLDMpKydkZWcgIGNfZD0nK2ZtdChjMS5jX2QsMykrJ2tOL20yXG4nOwogIG1lbSs9JyAgS2EoUmFua2luZSxwaGlfZCk9JytmbXQoYzEuS2Ffciw0KSsnICBLYShDb3Vsb21iLHJlZik9JytmbXQoYzEuS2FfYyw0KSsn

XG4nOwogIG1lbSs9JyAgRWFoPScrZm10KGMxLkVhaCwzKSsna04vbSAgRWF2PScrZm10KGMxLkVhdiwzKSsna04vbVxuJzsKICBtZW0rPScgIFY9JytmbXQoYzEuViwzKSsna04vbSAgTWU9JytmbXQoYzEuTWUsMykrJ2tObS9tICBNdD0nK2ZtdChjMS5NdCwzKSsna05tL21cbic7CiAgbWVtKz0nICBDU190b21iPScrZm10KGMxLkNTX3QsMykrJyAgQ1NfZGVzbD0nK2ZtdChjMS5DU19kLDMpKycgIGU9JytmbXQoYzEuZSw0KSsnbSAgcV9tYXg9JytmbXQoYzEucW1heCwyKSsna04vbTJcblxuJzsKICBtZW0rPSc8aDQ+NS4gREExLUMyIChHRU86IGdhbW1hX0c9MSwwIGdhbW1hX1E9MSwzMCBnYW1tYV9waGk9MSwyNSk8L2g0Pic7CiAgbWVtKz0nICBwaGlfZD0n

K2ZtdChjMi5waGlfZF9kZWcsMykrJ2RlZyAgY19kPScrZm10KGMyLmNfZCwzKSsna04vbTJcbic7CiAgbWVtKz0nICBLYShSYW5raW5lLHBoaV9kKT0nK2ZtdChjMi5LYV9yLDQpKycgIEthKENvdWxvbWIscmVmKT0nK2ZtdChjMi5LYV9jLDQpKydcbic7CiAgbWVtKz0nICBFYWg9JytmbXQoYzIuRWFoLDMpKydrTi9tICBFYXY9JytmbXQoYzIuRWF2LDMpKydrTi9tXG4nOwogIG1lbSs9JyAgVj0nK2ZtdChjMi5WLDMpKydrTi9tICBNZT0nK2ZtdChjMi5NZSwzKSsna05tL20gIE10PScrZm10KGMyLk10LDMpKydrTm0vbVxuJzsKICBtZW0rPScgIENTX3RvbWI9JytmbXQoYzIuQ1NfdCwzKSsnICBDU19kZXNsPScrZm10KGMyLkNTX2QsMykrJyAgZT0nK2ZtdChj

Mi5lLDQpKydtICBxX21heD0nK2ZtdChjMi5xbWF4LDIpKydrTi9tMlxuXG4nOwogIG1lbSs9JzxoND42LiBWQUxPUkVTIEdPVkVSTkFOVEVTIChwaW9yIGRlIEMxIGUgQzIpPC9oND4nOwogIG1lbSs9JyAgQ1NfdG9tYiA9IG1pbignK2ZtdChjMS5DU190LDMpKycsICcrZm10KGMyLkNTX3QsMykrJykgPSAnK2ZtdChDU190X2dvdiwzKSsoQ1NfdF9nb3Y+PTE/JyBWRVJJRklDQSc6JyBOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgQ1NfZGVzbCA9IG1pbignK2ZtdChjMS5DU19kLDMpKycsICcrZm10KGMyLkNTX2QsMykrJykgPSAnK2ZtdChDU19kX2dvdiwzKSsoQ1NfZF9nb3Y+PTE/JyBWRVJJRklDQSc6JyBOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1l

bSs9JyAgZV9nb3YgICA9IG1heCgnK2ZtdChjMS5lLDQpKycsICcrZm10KGMyLmUsNCkrJykgPSAnK2ZtdChlX2dvdiw0KSsnbSAgQi82PScrZm10KEJiLzYsNCkrJ20gICcrKGVfZ292PD1CYi82PydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBxX21heCAgID0gbWF4KCcrZm10KGMxLnFtYXgsMikrJywgJytmbXQoYzIucW1heCwyKSsnKSA9ICcrZm10KHFtYXhfZ292LDIpKydrTi9tMiA8PSBSbGltPScrZm10KFJsaW1fdXNvLDIpKycgICcrKHFtYXhfZ292PD1SbGltX3Vzbz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgUmVjYWxxdWUvVGFzc2VtZW50IH4gJytmbXQocmVjX21tLDEpKydtbVxuXG4n

OwogIG1lbSs9JzxoND43LiBWRVJJRklDQVRJT05TIE1BQ09OTkVSSUUgXHUyMDE0IEVOIDE5OTYtMS0xIChDMSBnb3Zlcm5hIFNUUik8L2g0Pic7CiAgbWVtKz0nICBzaWdtYV9iYXNlID0gJytmbXQoc2lnbWFfYmFzZV9rUGEsMikrJ2tQYSA9ICcrZm10KHNpZ21hX2NvbXAsNSkrJ01QYVxuJzsKICBtZW0rPScgIGZkID0gZmsvZ2FtbWFfTSA9ICcrZm10KGZkX2Fsdiw0KSsnTVBhID0gJytmbXQoZmRfYWx2KjEwMDAsMikrJ2tQYVxuJzsKICBtZW0rPScgIENvbXByZXNzYW86ICcrZm10KHNpZ21hX2NvbXAqMTAwMCwyKSsna1BhIDw9ICcrZm10KGZkX2FsdioxMDAwLDIpKydrUGEgICcrKG9rX2NvbXA/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJyAgKEVO

IDE5OTYtMS0xIGl0ZW0gNi4xLjIpXG5cbic7CiAgbWVtKz0nICBmdmswPScrZnZrMCsnTVBhICBmdms9bWluKCcrZnZrMCsnKzAsNConK2ZtdChzaWdtYV9iYXNlX2tQYS8xMDAwLDQpKycsIDAsMDY1KicrZmJrKycpPScrZm10KGZ2a19iYXNlLDQpKydNUGFcbic7CiAgbWVtKz0nICBmdmQ9ZnZrL2dhbW1hX009JytmbXQoZnZkX2Jhc2UsNCkrJ01QYVxuJzsKICBtZW0rPScgIHRhdV9iYXNlPUVhaC9CYj0nK2ZtdChjMS5FYWgsMykrJy8nK2ZtdChCYiwzKSsnPScrZm10KHRhdV9iYXNlKjEwMDAsMykrJ2tQYT0nK2ZtdCh0YXVfYmFzZSw1KSsnTVBhXG4nOwogIG1lbSs9JyAgQ2lzYWlsbGVtZW50IGJhc2U6ICcrZm10KHRhdV9iYXNlKjEwMDAsMykrJ2tQYSA8

PSAnK2ZtdChmdmRfYmFzZSoxMDAwLDMpKydrUGEgICcrKG9rX2Npcz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnICAoRU4gMTk5Ni0xLTEgaXRlbSA2LjUpXG5cbic7CiAgbWVtKz0nICBJbmNsaW5haXNvbiByZXN1bHRhbnRlOiB0aGV0YT0nK2ZtdCh0aGV0YV9yZXMsMikrJ2RlZyAgdGhldGFfbGltPScrZm10KHRoZXRhX2xpbSwyKSsnZGVnICAnKyhva190aGV0YT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnICAoRU4gMTk5Ni0xLTEgaXRlbSA2LjEuMi4xKVxuXG4nOwogIG1lbSs9JyAgSm9pbnQgaW50ZXJtZWRpYWlyZSBhIEgvMj0nK2ZtdChIMiwyKSsnbTogQnQ9JytmbXQoajIuQnRfaSwzKSsnbSAgdGF1PScrZm10KGoyLnRhdV9pKjEwMDAs

MikrJ2tQYSA8PSBmdmQ9JytmbXQoajIuZnZkX2kqMTAwMCwyKSsna1BhICAnKyhqMi5vaz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgSm9pbnQgaW50ZXJtZWRpYWlyZSBhIEgvMz0nK2ZtdChIMywyKSsnbTogQnQ9JytmbXQoajMuQnRfaSwzKSsnbSAgdGF1PScrZm10KGozLnRhdV9pKjEwMDAsMikrJ2tQYSA8PSBmdmQ9JytmbXQoajMuZnZkX2kqMTAwMCwyKSsna1BhICAnKyhqMy5vaz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG5cbic7CiAgbWVtKz0nPGg0PjguIFNUQUJJTElURSBHTE9CQUxFIChFTiAxOTk3LTEgaXRlbSAxMS41KTwvaDQ+JzsKICBtZW0rPScgIENTX2NpcmMgfiAnK2ZtdChDU19jaXJjLDMpKycg

Pj0gMSw1ICAnKyhDU19jaXJjPj0xLjU/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIEFUVEVOVElPTjogUmVhbGlzZXIgYW5hbHlzZSBCaXNob3AgY29tcGxldGUgcG91ciBkb2N1bWVudHMgZGUgY29uc3RydWN0aW9uLlxuXG4nOwogIGlmKGFnPjApewogICAgbWVtKz0nPGg0PjkuIFNFSVNNRSAoRU4gMTk5OC01OjIwMDQpPC9oND4nOwogICAgbWVtKz0nICBhZz0nK2FnKydnICBDU190b21iKHNpcyk9JytmbXQoQ1N0X3NpcywzKSsnICBDU19kZXNsKHNpcyk9JytmbXQoQ1NkX3NpcywzKSsnXG5cbic7CiAgfQogIG1lbSs9JzxoND5SRVNVTUUgLyBSRVNVTU88L2g0Pic7CiAgbWVtKz0nICBUb21iZW1lbnQgQzErQzI6IENTPScr

Zm10KENTX3RfZ292LDMpKycgPj0gMSwwICAnKyhDU190X2dvdj49MS4wPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBHbGlzc2VtZW50IEMxK0MyOiBDUz0nK2ZtdChDU19kX2dvdiwzKSsnID49IDEsMCAgJysoQ1NfZF9nb3Y+PTEuMD8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgUG9ydGFuY2U6IHE9JytmbXQocW1heF9nb3YsMikrJyA8PSBSbGltPScrZm10KFJsaW1fdXNvLDIpKydrTi9tMiAgJysocW1heF9nb3Y8PVJsaW1fdXNvPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBFeGNlbnRyaWNpdGU6IGU9JytmbXQoZV9nb3YsNCkrJyA8PSBCLzY9JytmbXQoQmIv

Niw0KSsnbSAgJysoZV9nb3Y8PUJiLzY/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENvbXByZXNzYW86ICcrZm10KHNpZ21hX2NvbXAqMTAwMCwxKSsna1BhIDw9IGZkPScrZm10KGZkX2FsdioxMDAwLDEpKydrUGEgICcrKG9rX2NvbXA/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENpc2FsaC5iYXNlOiB0YXU9JytmbXQodGF1X2Jhc2UqMTAwMCwyKSsna1BhIDw9IGZ2ZD0nK2ZtdChmdmRfYmFzZSoxMDAwLDIpKydrUGEgICcrKG9rX2Npcz8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgSW5jbC5yZXN1bHQuOiAnK2ZtdCh0aGV0YV9yZXMsMSkrJ2RlZyA8PSAnK2Zt

dCh0aGV0YV9saW0sMSkrJ2RlZyAgJysob2tfdGhldGE/J1ZFUklGSUNBJzonTkFPIFZFUklGSUNBJykrJ1xuJzsKICBtZW0rPScgIENpc2FsaC5ILzI6ICcrKGoyLm9rPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKycgIENpc2FsaC5ILzM6ICcrKGozLm9rPydWRVJJRklDQSc6J05BTyBWRVJJRklDQScpKydcbic7CiAgbWVtKz0nICBFc3RhYi5nbG9iYWw6IENTPScrZm10KENTX2NpcmMsMykrJyA+PSAxLDUgICcrKENTX2NpcmM+PTEuNT8nVkVSSUZJQ0EnOidOQU8gVkVSSUZJQ0EnKSsnXG4nOwogIG1lbSs9JyAgRW1idXRpbWVudG86IEhlbT0nK2ZtdChIZW0sMikrJ20gPj0gJytmbXQoSGVtX21pbiwyKSsnbSAgJysoSGVtPj1IZW1fbWluPydWRVJJRklD

QSc6J05BTyBWRVJJRklDQScpKydcblxuJzsKICBpZihhbGVydGFzLmxlbmd0aCl7bWVtKz0nPGg0PkFMRVJURVMgLyBBTEVSVEFTPC9oND4nO2FsZXJ0YXMuZm9yRWFjaChmdW5jdGlvbihhKXttZW0rPScgIFshXSAnK2ErJ1xuJzt9KTttZW0rPSdcbic7fQogIG1lbSs9JycrU0VQKydcbic7CiAgbWVtKz0nTm9ybWVzOiBFTiAxOTk3LTE6MjAwNCtBMToyMDEzIHwgRU4gMTk5Ni0xLTE6MjAwNSB8IEVOIDE5OTA6MjAwMiB8IEVOIDE5OTgtNToyMDA0XG4nOwogIG1lbSs9JycrU0VQKydcbic7CiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ21lbW9yaWFsJykuaW5uZXJIVE1MPW1lbTsKICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0YWRvJykuc3R5

bGUuZGlzcGxheT0nYmxvY2snOwogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRhZG8nKS5zY3JvbGxJbnRvVmlldyh7YmVoYXZpb3I6J3Ntb290aCd9KTsKfQp3aW5kb3cub25sb2FkPWZ1bmN0aW9uKCl7CiAgdmFyIGQ9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2RjJyk7CiAgaWYoZCYmIWQudmFsdWUpIGQudmFsdWU9bmV3IERhdGUoKS50b0lTT1N0cmluZygpLnNsaWNlKDAsMTApOwp9Owo8L3NjcmlwdD4=

PHN0eWxlPjpyb290ey0tYXo6IzFkMzE1NTstLWF6bTojMmU0ZjhhOy0tYXpjOiM0YTdjYzc7LS1kb3I6I2JmOTAwMDstLWRvcmM6I2UwYWEwMDstLWJnOiNmMGYyZjY7LS1iZ3c6I2ZmZjstLWJyZDojYzhkMGUwOy0tdHh0OiMxYTFhMmU7LS10eHRtOiM0YTRhNmE7LS1vazojZDRlZGRhOy0tb2tiOiMxYTdhM2E7LS13YXJuOiNmZmYzY2Q7LS13YXJuYjojODU2NDA0Oy0tZXJyOiNmOGQ3ZGE7LS1lcnJiOiM4NDIwMjk7fSp7Ym94LXNpemluZzpib3JkZXItYm94O21hcmdpbjowO3BhZGRpbmc6MDt9Ym9keXtmb250LWZhbWlseTonSUJNIFBsZXggU2Fucycsc2Fucy1zZXJpZjtiYWNrZ3JvdW5kOnZhcigtLWJnKTtjb2xvcjp2YXIoLS10eHQpO30ud3JhcHttYXgt

d2lkdGg6MTAwMHB4O21hcmdpbjowIGF1dG87cGFkZGluZzoyMHB4IDE2cHg7fS5zZWN7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO2JvcmRlcjoxLjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6OHB4O3BhZGRpbmc6MjBweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zZWMgaDN7Zm9udC1zaXplOjExcHg7Zm9udC13ZWlnaHQ6NzAwO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouN3B4O2NvbG9yOnZhcigtLWF6KTttYXJnaW4tYm90dG9tOjE0cHg7ZGlzcGxheTpmbGV4O2FsaWduLWl0ZW1zOmNlbnRlcjtnYXA6OHB4O30uc2VjIGgzOjphZnRlcntjb250ZW50OicnO2ZsZXg6MTtoZWlnaHQ6MXB4O2JhY2tncm91bmQ6dmFyKC0t

YnJkKTt9Lmcye2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmcjtnYXA6MTBweDt9Lmcze2Rpc3BsYXk6Z3JpZDtncmlkLXRlbXBsYXRlLWNvbHVtbnM6MWZyIDFmciAxZnI7Z2FwOjEwcHg7fS5nNHtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOjFmciAxZnIgMWZyIDFmcjtnYXA6MTBweDt9LmZsZHtkaXNwbGF5OmZsZXg7ZmxleC1kaXJlY3Rpb246Y29sdW1uO2dhcDozcHg7fS5mbGQgbGFiZWx7Zm9udC1zaXplOjEwcHg7Zm9udC13ZWlnaHQ6NjAwO2NvbG9yOnZhcigtLXR4dG0pO3RleHQtdHJhbnNmb3JtOnVwcGVyY2FzZTtsZXR0ZXItc3BhY2luZzouNXB4O30uZmxkIGlucHV0LC5mbGQgc2VsZWN0e2JvcmRlcjox

LjVweCBzb2xpZCB2YXIoLS1icmQpO2JvcmRlci1yYWRpdXM6NHB4O3BhZGRpbmc6N3B4IDlweDtmb250LXNpemU6MTJweDtmb250LWZhbWlseTppbmhlcml0O2NvbG9yOnZhcigtLXR4dCk7YmFja2dyb3VuZDp2YXIoLS1iZ3cpO30uZmxkIC51bntmb250LXNpemU6OXB4O2NvbG9yOnZhcigtLXR4dG0pO21hcmdpbi10b3A6MXB4O30ubm90YXtiYWNrZ3JvdW5kOiNlOGYwZmU7Ym9yZGVyLWxlZnQ6M3B4IHNvbGlkIHZhcigtLWF6Yyk7cGFkZGluZzo3cHggMTFweDtmb250LXNpemU6MTBweDtib3JkZXItcmFkaXVzOjAgNHB4IDRweCAwO21hcmdpbi1ib3R0b206MTBweDtsaW5lLWhlaWdodDoxLjY7fS5ub3RhLXd7YmFja2dyb3VuZDojZmZmM2NkO2JvcmRlci1s

ZWZ0OjNweCBzb2xpZCB2YXIoLS1kb3JjKTtwYWRkaW5nOjdweCAxMXB4O2ZvbnQtc2l6ZToxMHB4O2JvcmRlci1yYWRpdXM6MCA0cHggNHB4IDA7bWFyZ2luLWJvdHRvbToxMHB4O2xpbmUtaGVpZ2h0OjEuNjt9LmJ0bi1jYWxje2JhY2tncm91bmQ6dmFyKC0tYXopO2NvbG9yOiNmZmY7Ym9yZGVyOm5vbmU7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxM3B4IDI4cHg7Zm9udC1zaXplOjEzcHg7Zm9udC13ZWlnaHQ6NzAwO2N1cnNvcjpwb2ludGVyO3dpZHRoOjEwMCU7bWFyZ2luLXRvcDo2cHg7fS5idG4tcGRme2JhY2tncm91bmQ6dmFyKC0tZG9yYyk7Y29sb3I6I2ZmZjtib3JkZXI6bm9uZTtib3JkZXItcmFkaXVzOjZweDtwYWRkaW5nOjlweCAyMnB4O2Zv

bnQtc2l6ZToxMnB4O2ZvbnQtd2VpZ2h0OjcwMDtjdXJzb3I6cG9pbnRlcjttYXJnaW4tdG9wOjEwcHg7fSNyZXN1bHRhZG97ZGlzcGxheTpub25lO21hcmdpbi10b3A6MTZweDt9LnNlbXtkaXNwbGF5OmdyaWQ7Z3JpZC10ZW1wbGF0ZS1jb2x1bW5zOnJlcGVhdCg4LDFmcik7Z2FwOjZweDttYXJnaW4tYm90dG9tOjE0cHg7fS5zaXRlbXtib3JkZXItcmFkaXVzOjdweDtwYWRkaW5nOjlweCA1cHg7dGV4dC1hbGlnbjpjZW50ZXI7fS5zbGJse2ZvbnQtc2l6ZTo3LjVweDtmb250LXdlaWdodDo3MDA7dGV4dC10cmFuc2Zvcm06dXBwZXJjYXNlO2xldHRlci1zcGFjaW5nOi4zcHg7bWFyZ2luLWJvdHRvbTo0cHg7bGluZS1oZWlnaHQ6MS4zO30uc3ZhbHtmb250LXNp

emU6MTRweDtmb250LXdlaWdodDo3MDA7Zm9udC1mYW1pbHk6J0lCTSBQbGV4IE1vbm8nLG1vbm9zcGFjZTt9LnNyZXF7Zm9udC1zaXplOjdweDttYXJnaW4tdG9wOjJweDtvcGFjaXR5Oi44O30ub2stc3tiYWNrZ3JvdW5kOnZhcigtLW9rKTtjb2xvcjp2YXIoLS1va2IpO30ud2Fybi1ze2JhY2tncm91bmQ6dmFyKC0td2Fybik7Y29sb3I6dmFyKC0td2FybmIpO30uZXJyLXN7YmFja2dyb3VuZDp2YXIoLS1lcnIpO2NvbG9yOnZhcigtLWVycmIpO30ubWVte2JhY2tncm91bmQ6I2Y4ZjlmYztib3JkZXI6MXB4IHNvbGlkIHZhcigtLWJyZCk7Ym9yZGVyLXJhZGl1czo2cHg7cGFkZGluZzoxOHB4O2ZvbnQtc2l6ZToxMXB4O2xpbmUtaGVpZ2h0OjEuOTtmb250LWZh

bWlseTonSUJNIFBsZXggTW9ubycsbW9ub3NwYWNlO3doaXRlLXNwYWNlOnByZS13cmFwO2NvbG9yOnZhcigtLXR4dCk7bWFyZ2luLXRvcDoxMnB4O30ubWVtIGg0e2ZvbnQtZmFtaWx5OidJQk0gUGxleCBTYW5zJyxzYW5zLXNlcmlmO2ZvbnQtc2l6ZToxMXB4O2ZvbnQtd2VpZ2h0OjcwMDtjb2xvcjp2YXIoLS1heik7bWFyZ2luOjE0cHggMCA0cHg7Ym9yZGVyLWJvdHRvbToxcHggc29saWQgdmFyKC0tYnJkKTtwYWRkaW5nLWJvdHRvbToycHg7fS5hbGVydGF7YmFja2dyb3VuZDojZjhkN2RhO2JvcmRlcjoxcHggc29saWQgI2Y1YzZjYjtib3JkZXItcmFkaXVzOjVweDtwYWRkaW5nOjhweCAxMnB4O2ZvbnQtc2l6ZToxMXB4O2NvbG9yOiM4NDIwMjk7bWFyZ2lu

OjRweCAwO31AbWVkaWEobWF4LXdpZHRoOjcwMHB4KXsuZzMsLmc0e2dyaWQtdGVtcGxhdGUtY29sdW1uczoxZnIgMWZyO30uc2Vte2dyaWQtdGVtcGxhdGUtY29sdW1uczpyZXBlYXQoNCwxZnIpO319QG1lZGlhIHByaW50ey5idG4tY2FsYywuYnRuLXBkZiwuc2VjOm5vdCgjc2VjLXJlcyl7ZGlzcGxheTpub25lIWltcG9ydGFudDt9I3Jlc3VsdGFkb3tkaXNwbGF5OmJsb2NrIWltcG9ydGFudDt9Ym9keXtiYWNrZ3JvdW5kOiNmZmY7fS5tZW17Ym9yZGVyOm5vbmU7cGFkZGluZzowO2ZvbnQtc2l6ZToxMHB4O319PC9zdHlsZT4KPGRpdiBjbGFzcz0id3JhcCI+CjxoMj5DTVUgTWFzb25yeSBSZXRhaW5pbmcgV2FsbDwvaDI+CjxwIHN0eWxlPSJmb250LXNpemU6

MTFweDtjb2xvcjp2YXIoLS10eHRtKTttYXJnaW4tYm90dG9tOjE0cHg7Ij5UTVMgNDAyLTIyIChNU0pDKSB8IEFTQ0UgNy0yMiB8IElCQyAyMDIxIHwgQVNEIE1ldGhvZCDigJQgR3Jhdml0eSBDTVUgV2FsbDwvcD4KPGRpdiBjbGFzcz0ibm90YS13Ij5Gb3IgbGljZW5zZWQgZW5naW5lZXJzIG9ubHkuIE1heCBIIHJlY29tbWVuZGVkIDEwZnQgdW5yZWluZm9yY2VkLiBBYm92ZSAxMGZ0OiByZWluZm9yY2VkIENNVSBvciBSQyB3YWxsIHBlciBUTVMgNDAyIENoYXB0ZXIgOS48L2Rpdj4KPGRpdiBjbGFzcz0ic2VjIj48aDM+UHJvamVjdCBJbmZvcm1hdGlvbjwvaDM+PGRpdiBjbGFzcz0iZzMiPgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Qcm9qZWN0IE5hbWU8

L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0ib2JyYSIgcGxhY2Vob2xkZXI9IlByb2plY3QgLyBMb2NhdGlvbiI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkVuZ2luZWVyIG9mIFJlY29yZDwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJyZXNwIiBwbGFjZWhvbGRlcj0iUEUgTmFtZSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkRhdGU8L2xhYmVsPjxpbnB1dCB0eXBlPSJkYXRlIiBpZD0iZGMiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5SZXYuPC9sYWJlbD48aW5wdXQgdHlwZT0idGV4dCIgaWQ9InJldiIgdmFsdWU9IlIwMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkdlb3RlY2huaWNhbCBS

ZXBvcnQ8L2xhYmVsPjxpbnB1dCB0eXBlPSJ0ZXh0IiBpZD0ibGF1ZG8iIHBsYWNlaG9sZGVyPSJSZXBvcnQgTm8uIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+UEUgTGljZW5zZSBOby4gLyBTdGFtcDwvbGFiZWw+PGlucHV0IHR5cGU9InRleHQiIGlkPSJsaWNlbmNlIiBwbGFjZWhvbGRlcj0iU3RhdGUgUEUgTGljZW5zZSBOby4iPjwvZGl2Pgo8L2Rpdj48L2Rpdj4KPGRpdiBjbGFzcz0ic2VjIj48aDM+R2VvbWV0cnkgKFVTIEN1c3RvbWFyeSk8L2gzPgo8ZGl2IGNsYXNzPSJub3RhIj5SZWNvbW1lbmRlZDogQiA9IDAuNUggdG8gMC43SC4gV2FsbCBiYXR0ZXIgaW5jcmVhc2VzIEVhdiwgaW1wcm92aW5nIHN0YWJpbGl0eS48L2Rpdj4KPGRpdiBj

bGFzcz0iZzQiPgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Ub3RhbCBoZWlnaHQgSCAoZnQpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iSCIgdmFsdWU9IjguMCIgc3RlcD0iMC41Ij48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RW1iZWRtZW50IEhlbSAoZnQpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iSGVtIiB2YWx1ZT0iMS41IiBzdGVwPSIwLjI1Ij48c3BhbiBjbGFzcz0idW4iPm1pbjogbWF4KDEuNWZ0OyBILzEwKTwvc3Bhbj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+QmFzZSB3aWR0aCBCIChmdCk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJCYiIgdmFsdWU9IjUuMCIgc3RlcD0iMC4z

MyI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlRvcCB3aWR0aCBCdCAoZnQpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iQnQiIHZhbHVlPSIxLjMzIiBzdGVwPSIwLjMzIj48c3BhbiBjbGFzcz0idW4iPm1pbiAxIENNVSA9IDEuMzNmdDwvc3Bhbj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+V2FsbCBiYXR0ZXIgYm0gKGRlZyk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJiZXRhX20iIHZhbHVlPSIwIiBzdGVwPSIxIiBtaW49IjAiIG1heD0iMTUiPjxzcGFuIGNsYXNzPSJ1biI+ZmFjZSBiYXR0ZXIgdG93YXJkcyBmaWxsPC9zcGFuPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5CYWNrZmlsbCBzbG9w

ZSBiIChkZWcpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iYmV0YSIgdmFsdWU9IjAiIHN0ZXA9IjEiIG1pbj0iMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlN1cmNoYXJnZSBxIChwc2YpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0icSIgdmFsdWU9IjEwMCIgc3RlcD0iNTAiIG1pbj0iMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlN1cmNoYXJnZSB0eXBlPC9sYWJlbD48c2VsZWN0IGlkPSJ0aXBvX3NjIj48b3B0aW9uIHZhbHVlPSJ1bmlmb3JtZSI+VW5pZm9ybTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9Im5lbmh1bWEiPk5vbmU8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPC9kaXY+PC9kaXY+CjxkaXYg

Y2xhc3M9InNlYyI+PGgzPk1hc29ucnkg4oCUIFRNUyA0MDItMjI8L2gzPgo8ZGl2IGNsYXNzPSJub3RhIj5mJ20gY29tcHV0ZWQgZnJvbSB1bml0IHN0cmVuZ3RoIGFuZCBtb3J0YXIgcGVyIFRNUyA0MDItMjIgVGFibGUgMi4zLjIuMSB3aGVuIHBvc3NpYmxlLiBHcm91dGluZyBpbmNyZWFzZXMgZidtIGFuZCB1bml0IHdlaWdodC48L2Rpdj4KPGRpdiBjbGFzcz0iZzQiPgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5DTVUgdW5pdCB0eXBlPC9sYWJlbD48c2VsZWN0IGlkPSJjbXUiPjxvcHRpb24gdmFsdWU9IjgiPjgtaW4gQ01VICgxLjMzZnQpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMTAiPjEwLWluIENNVSAoMC44M2Z0KTwvb3B0aW9uPjxvcHRpb24gdmFs

dWU9IjEyIj4xMi1pbiBDTVUgKDEuMDBmdCk8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Zm0gc3BlY2lmaWVkIChwc2kpPC9sYWJlbD48aW5wdXQgdHlwZT0ibnVtYmVyIiBpZD0iZm1fcHNpIiB2YWx1ZT0iMjAwMCIgc3RlcD0iNTAwIiBtaW49IjEwMDAiPjxzcGFuIGNsYXNzPSJ1biI+VE1TIDQwMiBUYWJsZSAyLjMuMi4xPC9zcGFuPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Nb3J0YXIgdHlwZTwvbGFiZWw+PHNlbGVjdCBpZD0ibW9ydGFyIj48b3B0aW9uIHZhbHVlPSJNIj5UeXBlIE0gKDI1MDBwc2kpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iUyIgc2VsZWN0ZWQ+VHlwZSBTICgxODAwcHNpKTwvb3B0

aW9uPjxvcHRpb24gdmFsdWU9Ik4iPlR5cGUgTiAoNzUwcHNpKTwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Kb2ludCB0aGlja25lc3MgKGluKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImVzcF9qIiB2YWx1ZT0iMC4zNzUiIHN0ZXA9IjAuMDYyNSIgbWluPSIwLjI1IiBtYXg9IjAuNSI+PHNwYW4gY2xhc3M9InVuIj5UTVM6IDMvOGluIHN0YW5kYXJkPC9zcGFuPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Wb2lkIHJhdGlvICglKTwvbGFiZWw+PHNlbGVjdCBpZD0idmF6aW9zIj48b3B0aW9uIHZhbHVlPSIyNSI+MjUlIChzb2xpZC9ncm91dGVkKTwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjQw

IiBzZWxlY3RlZD40MCUgKHN0ZCBob2xsb3cpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iNTUiPjU1JSAobGlnaHR3ZWlnaHQpPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkdyb3V0aW5nPC9sYWJlbD48c2VsZWN0IGlkPSJncmF1dGVhbWVudG8iPjxvcHRpb24gdmFsdWU9Im5hbyIgc2VsZWN0ZWQ+VW5ncm91dGVkPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0icGFyY2lhbCI+UGFydGlhbGx5IGdyb3V0ZWQgKDUwJSk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJ0b3RhbCI+RnVsbHkgZ3JvdXRlZDwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5Vbml0IHd0IGdhbW1hX20gKHBjZik8L2xh

YmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJnYWx2IiB2YWx1ZT0iOTAiIHN0ZXA9IjUiPjxzcGFuIGNsYXNzPSJ1biI+aG9sbG93IH44NTsgZ3JvdXRlZCB+MTI1PC9zcGFuPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5IZWFkIGpvaW50IGZpbGxlZDwvbGFiZWw+PHNlbGVjdCBpZD0ianVudGFfdiI+PG9wdGlvbiB2YWx1ZT0ibmFvIiBzZWxlY3RlZD5ObyAocmVkdWNlcyBmdik8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJzaW0iPlllcyAoZnVsbCBmdik8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+RHJhaW5hZ2U8L2xhYmVsPjxzZWxlY3QgaWQ9ImRyZW4iPjxvcHRpb24gdmFsdWU9Im9rIj5GaWx0ZXIg

ZmFicmljICsgZHJhaW48L29wdGlvbj48b3B0aW9uIHZhbHVlPSJ3ZWVwIj5XZWVwIGhvbGVzIG9ubHkgKDUwJSk8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJzZW0iPk5vIGRyYWluYWdlICh3b3JzdCk8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPC9kaXY+PC9kaXY+CjxkaXYgY2xhc3M9InNlYyI+PGgzPkdlb3RlY2huaWNhbDwvaDM+PGRpdiBjbGFzcz0iZzQiPgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5VU0NTPC9sYWJlbD48c2VsZWN0IGlkPSJzdWNzIj48b3B0aW9uIHZhbHVlPSJTVyI+U1c8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJTUCI+U1A8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJTTSIgc2VsZWN0ZWQ+U008L29wdGlvbj48b3B0aW9uIHZhbHVlPSJD

TCI+Q0w8L29wdGlvbj48b3B0aW9uIHZhbHVlPSJDSCI+Q0g8L29wdGlvbj48L3NlbGVjdD48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+TjYwIFNQVDwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9Im5zcHQiIHZhbHVlPSIxNSIgc3RlcD0iMSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlVuaXQgd3QgZ3MgKHBjZik8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJncyIgdmFsdWU9IjExNSIgc3RlcD0iNSI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkZyaWN0aW9uIGFuZ2xlIHBoaSAoZGVnKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InBoaSIgdmFsdWU9IjMwIiBzdGVwPSIxIj48L2Rpdj4K

PGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+Q29oZXNpb24gYyAocHNmKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9ImNvZXMiIHZhbHVlPSIwIiBzdGVwPSI1MCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPkJhc2UgZnJpY3Rpb24gbXU8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJtdSIgdmFsdWU9IjAuNTAiIHN0ZXA9IjAuMDUiPjwvZGl2Pgo8ZGl2IGNsYXNzPSJmbGQiPjxsYWJlbD5BbGxvdy4gYmVhcmluZyBxYSAocHNmKTwvbGFiZWw+PGlucHV0IHR5cGU9Im51bWJlciIgaWQ9InFhIiB2YWx1ZT0iMjUwMCIgc3RlcD0iNTAwIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+cWEgc291cmNlPC9sYWJlbD48c2Vs

ZWN0IGlkPSJvcmlnX3EiPjxvcHRpb24gdmFsdWU9ImNhbGN1bG8iPkNhbGN1bGF0ZSAoVGVyemFnaGkpPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iZGlyZXRvIj5TcGVjaWZ5IHFhPC9vcHRpb24+PC9zZWxlY3Q+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPldhdGVyIHRhYmxlIGRlcHRoIChmdCk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJOdyIgdmFsdWU9IjAiIHN0ZXA9IjAuNSIgbWluPSIwIj48L2Rpdj4KPGRpdiBjbGFzcz0iZmxkIj48bGFiZWw+a3MgKHBjaSk8L2xhYmVsPjxpbnB1dCB0eXBlPSJudW1iZXIiIGlkPSJrcyIgdmFsdWU9IjUwIiBzdGVwPSIxMCI+PC9kaXY+CjxkaXYgY2xhc3M9ImZsZCI+PGxhYmVsPlNlaXNtaWMg

U3MgKGcpPC9sYWJlbD48c2VsZWN0IGlkPSJhZyI+PG9wdGlvbiB2YWx1ZT0iMCIgc2VsZWN0ZWQ+Tm9uLXNlaXNtaWM8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIwLjEwIj5Tcz0wLjEwZzwvb3B0aW9uPjxvcHRpb24gdmFsdWU9IjAuMjUiPlNzPTAuMjVnPC9vcHRpb24+PG9wdGlvbiB2YWx1ZT0iMC41MCI+U3M9MC41MGc8L29wdGlvbj48b3B0aW9uIHZhbHVlPSIxLjAwIj5Tcz0xLjAwZzwvb3B0aW9uPjwvc2VsZWN0PjwvZGl2Pgo8L2Rpdj48L2Rpdj4KPGJ1dHRvbiBjbGFzcz0iYnRuLWNhbGMiIG9uY2xpY2s9ImNhbGNCbG9jb0FDSSgpIj5DQUxDVUxBVEUg4oCUIFRNUyA0MDItMjIgLyBBU0NFIDctMjI8L2J1dHRvbj4KPGRpdiBpZD0icmVzdWx0YWRvIj48

ZGl2IGNsYXNzPSJzZWMiIGlkPSJzZWMtcmVzIj4KPGgzPlN0YWJpbGl0eSBhbmQgTWFzb25yeSBDaGVja3M8L2gzPgo8ZGl2IGNsYXNzPSJzZW0iIGlkPSJzZW1hZm9ybyI+PC9kaXY+CjxoMyBzdHlsZT0ibWFyZ2luLXRvcDo4cHg7Ij5BbGVydHM8L2gzPjxkaXYgaWQ9ImFsZXJ0YXNfcmVzIj48L2Rpdj4KPGgzIHN0eWxlPSJtYXJnaW4tdG9wOjhweDsiPkNhbGN1bGF0aW9uIE1lbW8g4oCUIFRNUyA0MDItMjIgLyBBU0NFIDctMjI8L2gzPgo8YnV0dG9uIGNsYXNzPSJidG4tcGRmIiBvbmNsaWNrPSJ3aW5kb3cucHJpbnQoKSI+RXhwb3J0IFBERjwvYnV0dG9uPgo8ZGl2IGNsYXNzPSJtZW0iIGlkPSJtZW1vcmlhbCI+PC9kaXY+CjwvZGl2PjwvZGl2PjwvZGl2

Pgo8c2NyaXB0PgpmdW5jdGlvbiB0b1JhZChkKXtyZXR1cm4gZCpNYXRoLlBJLzE4MDt9CmZ1bmN0aW9uIGZtdCh2LGQpe3JldHVybiBOdW1iZXIodikudG9GaXhlZChkPT09dW5kZWZpbmVkPzM6ZCk7fQpmdW5jdGlvbiBjYXBhVGV6X3VzKHBkLGMsZ3MsRGYsQil7CiAgdmFyIHA9dG9SYWQocGQpLE5xPU1hdGguZXhwKE1hdGguUEkqTWF0aC50YW4ocCkpKk1hdGgucG93KE1hdGgudGFuKE1hdGguUEkvNCtwLzIpLDIpLE5jPShOcS0xKS9NYXRoLnRhbihwKSxOZz0yKihOcSsxKSpNYXRoLnRhbihwKSxxMD1ncypEZixxdWx0PWMqTmMrcTAqTnErMC41KmdzKkIqTmc7CiAgcmV0dXJue3F1bHQ6cXVsdCxxYTpxdWx0LzMsTnE6TnEsTmM6TmMsTmc6Tmd9O30KZnVu

Y3Rpb24gY2FsY0Jsb2NvQUNJKCl7CiAgdmFyIG9icmE9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ29icmEnKS52YWx1ZXx8JyhuL3MpJzsKICB2YXIgcmVzcD1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzcCcpLnZhbHVlfHwnKG4vcyknOwogIHZhciBkY192PWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdkYycpLnZhbHVlfHxuZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7CiAgdmFyIHJldj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmV2JykudmFsdWV8fCdSMDAnOwogIHZhciBsYXVkbz1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbGF1ZG8nKS52YWx1ZXx8JyhuL3MpJzsKICB2YXIgbGljZW5jZT1kb2N1bWVudC5nZXRFbGVtZW50

QnlJZCgnbGljZW5jZScpLnZhbHVlfHwnKG4vcyknOwogIHZhciBIPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnSCcpLnZhbHVlOwogIHZhciBIZW09K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdIZW0nKS52YWx1ZTsKICB2YXIgQmI9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdCYicpLnZhbHVlOwogIHZhciBCdD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ0J0JykudmFsdWU7CiAgdmFyIGJldGFfbT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2JldGFfbScpLnZhbHVlOwogIHZhciBiZXRhPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYmV0YScpLnZhbHVlOwogIHZhciBxPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgncScpLnZhbHVlOwogIHZh

ciB0aXBvX3NjPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0aXBvX3NjJykudmFsdWU7CiAgdmFyIGNtdV9pbj0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NtdScpLnZhbHVlOwogIHZhciBmbV9wc2k9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdmbV9wc2knKS52YWx1ZTsKICB2YXIgbW9ydGFyPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdtb3J0YXInKS52YWx1ZTsKICB2YXIgZXNwX2pfaW49K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdlc3BfaicpLnZhbHVlOwogIHZhciB2YXppb3M9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd2YXppb3MnKS52YWx1ZTsKICB2YXIgZ3JhdXQ9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2dyYXV0ZWFtZW50bycp

LnZhbHVlOwogIHZhciBnYWx2X2Jhc2U9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdnYWx2JykudmFsdWU7CiAgdmFyIGp1bnRhX3Y9ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2p1bnRhX3YnKS52YWx1ZTsKICB2YXIgZHJlbj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZHJlbicpLnZhbHVlOwogIHZhciBzdWNzPWRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzdWNzJykudmFsdWU7CiAgdmFyIG5zcHQ9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCduc3B0JykudmFsdWU7CiAgdmFyIGdzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZ3MnKS52YWx1ZTsKICB2YXIgcGhpX2RlZz0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3BoaScpLnZhbHVlOwogIHZh

ciBjb2VzPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnY29lcycpLnZhbHVlOwogIHZhciBtdT0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ211JykudmFsdWU7CiAgdmFyIHFhX2lucD0rZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3FhJykudmFsdWU7CiAgdmFyIG9yaWdfcT1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnb3JpZ19xJykudmFsdWU7CiAgdmFyIE53PStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnTncnKS52YWx1ZTsKICB2YXIga3NfcGNpPStkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgna3MnKS52YWx1ZTsKICB2YXIgYWc9K2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdhZycpLnZhbHVlOwogIHZhciBhbGVydGFzPVtdOwogIC8vIEdyb3V0aW5n

IGFkanVzdG1lbnRzCiAgdmFyIGdyYXV0X2ZtPWdyYXV0PT09J3RvdGFsJz8xLjIwOihncmF1dD09PSdwYXJjaWFsJz8xLjEwOjEuMCk7IC8vIFRNUyA0MDIgVGFibGUgMi4zLjIuMQogIHZhciBnYWx2PWdyYXV0PT09J3RvdGFsJz8xMjU6KGdyYXV0PT09J3BhcmNpYWwnP2dhbHZfYmFzZSsxMDpnYWx2X2Jhc2UpOwogIC8vIGYnbSBmcm9tIHVuaXQgKyBtb3J0YXIgcGVyIFRNUyA0MDItMjIgVGFibGUgMi4zLjIuMQogIC8vIFNpbXBsaWZpZWQ6IGZtIHNwZWNpZmllZCBkaXJlY3RseSBidXQgc2hvdyB2ZXJpZmljYXRpb24gbm90ZQogIHZhciBmbV9lZmY9Zm1fcHNpKmdyYXV0X2ZtOyAvLyBncm91dGluZyBlZmZlY3Qgb24gZidtCiAgdmFyIG1vcnRhcl9wc2k9

eydNJzoyNTAwLCdTJzoxODAwLCdOJzo3NTB9W21vcnRhcl18fDE4MDA7CiAgLy8gVE1TIDQwMiBTZWN0aW9uIDkuMS45OiBmJ20gPD0gMC4zNSpmbV91bml0IChub3QgYXZhaWxhYmxlKSArIDAuNjUqZm1fbW9ydGFyIGNvbnRleHQKICAvLyBVc2Ugc3BlY2lmaWVkIGYnbSB3aXRoIGdyb3V0aW5nIGZhY3RvcgogIC8vIEFsbG93YWJsZSBzdHJlc3NlcyBUTVMgNDAyLTIyIEFTRCAoU2VjdGlvbiA4LjIpCiAgdmFyIEZhX2FsbG93PTAuMjUqZm1fZWZmOyAvLyBwc2kgXHUyMDE0IGFsbG93YWJsZSBheGlhbCBjb21wcmVzc2l2ZSBzdHJlc3MKICB2YXIgRnZfYWxsb3c9MS41Kk1hdGguc3FydChmbV9lZmYpOyAvLyBwc2kgXHUyMDE0IGFsbG93YWJsZSBzaGVhciAo

dW5yZWluZm9yY2VkKSBUTVMgNDAyIGVxLig4LTI5KQogIC8vIEFsbG93YWJsZSBmbGV4dXJhbCB0ZW5zaW9uIFRNUyA0MDItMjIgVGFibGUgOC4yLjQKICB2YXIgRnRfdGFibGU9eydNJzoyNSwnUyc6MTksJ04nOjExfVttb3J0YXJdfHwxOTsgLy8gcHNpIChub3JtYWwgdG8gYmVkIGpvaW50cykKICAvLyBKb2ludCB0aGlja25lc3MgY2hlY2sgVE1TIDQwMiBTZWN0aW9uIDkuMS45LjUKICBpZihlc3Bfal9pbjwwLjI1fHxlc3Bfal9pbj4wLjUpIGFsZXJ0YXMucHVzaCgnSk9JTlQgVEhJQ0tORVNTOiAnK2VzcF9qX2luKycgaW4gb3V0c2lkZSAzLzggaW4gKCsvLTEvOCBpbikgcGVyIFRNUyA0MDItMjIgU2VjIDkuMS45LjUnKTsKICAvLyBFbWJlZG1lbnQgbWlu

CiAgdmFyIEhlbV9taW49TWF0aC5tYXgoMS41LEgvMTApOwogIGlmKEhlbTxIZW1fbWluKSBhbGVydGFzLnB1c2goJ0VNQkVETUVOVDogSGVtPScrZm10KEhlbSwyKSsnZnQgPCBtaW49JytmbXQoSGVtX21pbiwyKSsnZnQgKEFTQ0UgNy0yMiknKTsKICBpZihIPjEwKSBhbGVydGFzLnB1c2goJ0hFSUdIVDogSD0nK0grJ2Z0ID4gMTBmdCBcdTIwMTQgVE1TIDQwMjogY29uc2lkZXIgcmVpbmZvcmNlZCBDTVUgKENoYXB0ZXIgOSkgb3IgUkMgd2FsbCcpOwogIGlmKEJ0PDEuMCkgYWxlcnRhcy5wdXNoKCdUT1AgV0lEVEg6IEJ0PScrZm10KEJ0LDIpKydmdCA8IDEuMGZ0IFx1MjAxNCBtaW4gMSBDTVUgdW5pdCcpOwogIGlmKEJiL0g8MC40MCkgYWxlcnRhcy5wdXNo

KCdQUk9QT1JUSU9OOiBCL0g9JytmbXQoQmIvSCwyKSsnIDwgMC40MCBcdTIwMTQgdW5kZXJzaXplZCBiYXNlJyk7CiAgaWYoZHJlbj09PSdzZW0nKSBhbGVydGFzLnB1c2goJ05PIERSQUlOQUdFIFx1MjAxNCBmdWxsIGh5ZHJvc3RhdGljIHByZXNzdXJlLiBJQkMgU2VjdGlvbiAxODA3LjQgcmVxdWlyZXMgZHJhaW5hZ2UgZm9yIG1hc29ucnkgd2FsbHMuJyk7CiAgLy8gU3VicHJlc3N1cmUKICB2YXIgTndfZWZmPU53OwogIGlmKGRyZW49PT0nb2snKSBOd19lZmY9MDsKICBpZihkcmVuPT09J3dlZXAnKSBOd19lZmY9TncqMC41OwogIHZhciBVX3N1Yj0wLFVfeWE9MDsKICBpZihOd19lZmY+MCYmTndfZWZmPD1IKXtVX3N1Yj0wLjUqNjIuNCpOd19lZmYqTndf

ZWZmO1VfeWE9TndfZWZmLzM7fQogIC8vIFBhc3NpdmUgcmVzaXN0YW5jZSAoQVNDRSA3LTIyIFNlY3Rpb24gMTEuOCkgXHUyMDE0IGNvbXB1dGVkLCBub3QgdXNlZCAoY29uc2VydmF0aXZlKQogIHZhciBwaGlfcj10b1JhZChwaGlfZGVnKTsKICB2YXIgS3A9TWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80K3BoaV9yLzIpLDIpOwogIHZhciBFcD0wLjUqS3AqZ3MqSGVtKkhlbTsgLy8gbGIvZnQKICAvLyBLYSBSYW5raW5lIGFuZCBDb3Vsb21iCiAgdmFyIEthX3Jhbms9TWF0aC5wb3coTWF0aC50YW4oTWF0aC5QSS80LXBoaV9yLzIpLDIpOwogIHZhciBkZWx0YV9jPXBoaV9yLzM7CiAgdmFyIEthX2Nfbj1NYXRoLnBvdyhNYXRoLnNpbihNYXRoLlBJLzIrcGhp

X3IpLDIpOwogIHZhciBLYV9jX3NxPU1hdGguc3FydChNYXRoLnNpbihwaGlfcitkZWx0YV9jKSpNYXRoLnNpbihwaGlfci10b1JhZChiZXRhKSkvKE1hdGguc2luKE1hdGguUEkvMi1kZWx0YV9jKSpNYXRoLnNpbihNYXRoLlBJLzIrdG9SYWQoYmV0YSkpKSk7CiAgdmFyIEthX2NvdWxvbWI9S2FfY19uLyhNYXRoLnBvdyhNYXRoLnNpbihNYXRoLlBJLzIpLDIpKk1hdGguc2luKE1hdGguUEkvMi1kZWx0YV9jKSpNYXRoLnBvdygxK0thX2Nfc3EsMikpOwogIHZhciBLYT1LYV9yYW5rOyAvLyBSYW5raW5lIHVzZWQgKGNvbnNlcnZhdGl2ZSBmb3IgdW5yZWluZm9yY2VkIG1hc29ucnkpCiAgLy8gRm9yY2VzCiAgdmFyIEVhX2c9MC41KkthKmdzKkgqSDsgLy8gbGIv

ZnQKICB2YXIgRWF2X2c9RWFfZypNYXRoLnNpbih0b1JhZChiZXRhX20pKTsKICB2YXIgRWFoX2c9RWFfZypNYXRoLmNvcyh0b1JhZChiZXRhX20pKTsKICB2YXIgRWFfcT10aXBvX3NjIT09J25lbmh1bWEnP0thKnEqSDowOwogIHZhciBFYXZfcT1FYV9xKk1hdGguc2luKHRvUmFkKGJldGFfbSkpOwogIHZhciBFYWhfcT1FYV9xKk1hdGguY29zKHRvUmFkKGJldGFfbSkpOwogIHZhciBFYWg9RWFoX2crRWFoX3ErVV9zdWI7CiAgdmFyIEVhdj1FYXZfZytFYXZfcTsKICAvLyBHZW9tZXRyeQogIHZhciBBbT0oQmIrQnQpLzIqSDsKICB2YXIgeGNnPUJiLzMqKEJiKzIqQnQpLyhCYitCdCk7CiAgdmFyIEJjPUJiLUJ0OwogIHZhciBXbT1nYWx2KkFtOyAvLyBsYi9m

dAogIHZhciBXcz1ncyooQmMvMikqSDsKICB2YXIgeHM9QmItQmMvMzsKICB2YXIgVj1XbStXcytFYXY7CiAgdmFyIE1lPVdtKnhjZytXcyp4cytFYXYqQmI7CiAgdmFyIE10PUVhaF9nKihILzMpK0VhaF9xKihILzIpK1Vfc3ViKlVfeWE7CiAgLy8gU3RhYmlsaXR5IEFTRAogIHZhciBGU290PU1lL01hdGgubWF4KE10LDAuMDAxKTsKICB2YXIgRnJfcz1tdSpWK2NvZXMqQmI7CiAgdmFyIEZTc2w9RnJfcy9NYXRoLm1heChFYWgsMC4wMDEpOwogIC8vIEVjY2VudHJpY2l0eSBhbmQgZWZmZWN0aXZlIEIKICB2YXIgeFI9KE1lLU10KS9WOwogIHZhciBlPU1hdGguYWJzKEJiLzIteFIpOwogIHZhciBlX2xpbT1CYi82OwogIHZhciBCZWZmPU1hdGgubWF4KEJiLTIq

ZSwwLjEpOyAvLyBmdCBcdTIwMTQgZWZmZWN0aXZlIGJlYXJpbmcgd2lkdGgKICBpZihlPmVfbGltKSBhbGVydGFzLnB1c2goJ0VDQ0VOVFJJQ0lUWTogZT0nK2ZtdChlLDMpKydmdCA+IEIvNj0nK2ZtdChlX2xpbSwzKSsnZnQgXHUyMDE0IHRlbnNpb24gYXQgYmFzZSAoQVNDRSA3KScpOwogIHZhciBxbWF4PVYvQmIqKDErNiplL0JiKTsgLy8gcHNmCiAgdmFyIHFtaW49Vi9CYiooMS02KmUvQmIpOwogIGlmKHFtaW48MCkgYWxlcnRhcy5wdXNoKCdCRUFSSU5HOiBxX21pbj0nK2ZtdChxbWluLDApKydwc2YgPCAwIFx1MjAxNCB0ZW5zaW9uIGF0IGJhc2UuIFJlZGVzaWduIGdlb21ldHJ5LicpOwogIC8vIFRlcnphZ2hpIHdpdGggQicKICB2YXIgdGV6PWNhcGFU

ZXpfdXMocGhpX2RlZyxjb2VzLGdzLEhlbSxCZWZmKTsKICB2YXIgcWFfdXNlPW9yaWdfcT09PSdjYWxjdWxvJz90ZXoucWE6cWFfaW5wOwogIGlmKHFtYXg+cWFfdXNlKSBhbGVydGFzLnB1c2goJ0JFQVJJTkc6IHFfbWF4PScrZm10KHFtYXgsMCkrJ3BzZiA+IHFhPScrZm10KHFhX3VzZSwwKSsncHNmJyk7CiAgLy8gTWFzb25yeSBzdHJlc3MgY2hlY2tzIEFTRCBcdTIwMTQgVE1TIDQwMi0yMgogIC8vIEF2ZXJhZ2UgY29tcHJlc3NpdmUgc3RyZXNzIChheGlhbCArIGJlbmRpbmcgYXQgYmFzZSkKICB2YXIgZmFfYXZnPVYvKEJiKjEyKTsgLy8gcHNpIChwZXIgMS1mdCB3aWR0aCwgQmIgaW4gZnQgLT4gYXJlYSA9IEJiKjEyIGluXjIvZnQpCiAgdmFyIFNfYmFz

ZT1NYXRoLnBvdyhCYioxMiwyKS82OyAvLyBpbl4zL2Z0IChzZWN0aW9uIG1vZHVsdXMgb2YgMS1mdC13aWRlIHN0cmlwKQogIHZhciBNYmFzZV9pbmxiPU10KjEyOyAvLyBpbi1sYi9mdAogIHZhciBmYl9mbGV4PU1iYXNlX2lubGIvU19iYXNlOyAvLyBwc2kgKGZsZXh1cmFsIHN0cmVzcykKICB2YXIgZmFfbmV0PWZhX2F2Zy1mYl9mbGV4OyAvLyBuZXQgY29tcHJlc3NpdmUgc3RyZXNzICh0ZW5zaW9uIHNpZGUpOyBuZWdhdGl2ZSA9IHRlbnNpb24KICB2YXIgb2tfY29tcD1mYV9hdmc8PUZhX2FsbG93OwogIGlmKCFva19jb21wKSBhbGVydGFzLnB1c2goJ0FYSUFMIENPTVBSRVNTSU9OOiBmYT0nK2ZtdChmYV9hdmcsMSkrJ3BzaSA+IEZhPScrZm10KEZhX2Fs

bG93LDEpKydwc2kgKFRNUyA0MDItMjIgU2VjIDguMi40KScpOwogIGlmKGZhX25ldDwtRnRfdGFibGUpIGFsZXJ0YXMucHVzaCgnRkxFWFVSQUwgVEVOU0lPTjogbmV0IHRlbnNpb249JytmbXQoTWF0aC5hYnMoZmFfbmV0KSwxKSsncHNpID4gRnQ9JytGdF90YWJsZSsncHNpIFx1MjAxNCByZWluZm9yY2VtZW50IHJlcXVpcmVkIChUTVMgNDAyLTIyIFNlYyA4LjIuNCwgVGFibGUgOC4yLjQpJyk7CiAgLy8gU2hlYXIgVE1TIDQwMi0yMiBTZWN0aW9uIDguMy41CiAgdmFyIGZ2X2FjdD1FYWgvKEJiKjEyKTsgLy8gcHNpIChzaGVhciBvbiBob3Jpem9udGFsIGNyb3NzLXNlY3Rpb24pCiAgdmFyIG9rX3NoZWFyPWZ2X2FjdDw9RnZfYWxsb3c7CiAgaWYoIW9rX3No

ZWFyKSBhbGVydGFzLnB1c2goJ1NIRUFSOiBmdj0nK2ZtdChmdl9hY3QsMSkrJ3BzaSA+IEZ2PScrZm10KEZ2X2FsbG93LDEpKydwc2kgXHUyMDE0IHJlaW5mb3JjZW1lbnQgcmVxdWlyZWQgKFRNUyA0MDItMjIgU2VjIDguMy41KScpOwogIC8vIFJlc3VsdGFudCBpbmNsaW5hdGlvbiBhbmdsZSBjaGVjayBUTVMgNDAyLTIyIFNlY3Rpb24gOC4zLjUKICB2YXIgdGhldGFfcmVzPU1hdGguYXRhbihFYWgvVikqMTgwL01hdGguUEk7CiAgdmFyIEZ2X2FsbG93X3dpdGhfTj1NYXRoLm1pbihGdl9hbGxvdyswLjQ1KmZhX2F2ZyxGdl9hbGxvdyoxLjUpOyAvLyB3aXRoIGNvbXByZXNzaW9uCiAgdmFyIHRoZXRhX2xpbT1NYXRoLmF0YW4oRnZfYWxsb3dfd2l0aF9OL01h

dGgubWF4KGZhX2F2ZywxKSkqMTgwL01hdGguUEk7CiAgdmFyIG9rX3RoZXRhPXRoZXRhX3Jlczw9dGhldGFfbGltOwogIGlmKCFva190aGV0YSkgYWxlcnRhcy5wdXNoKCdSRVNVTFRBTlQgSU5DTElOQVRJT046IHRoZXRhPScrZm10KHRoZXRhX3JlcywxKSsnZGVnID4gbGltaXQ9JytmbXQodGhldGFfbGltLDEpKydkZWcgKFRNUyA0MDItMjIgU2VjIDguMy41KScpOwogIC8vIEludGVybWVkaWF0ZSBqb2ludCBjaGVja3MKICBmdW5jdGlvbiBjaGVja0pvaW50KGhpLGxibCl7CiAgICB2YXIgRWFoX2k9MC41KkthKmdzKmhpKmhpKyh0aXBvX3NjIT09J25lbmh1bWEnP0thKnEqaGk6MCk7CiAgICB2YXIgQnRfaT1CdCsoQmItQnQpKihILWhpKS9IOwogICAgdmFy

IEFtX2k9KEJ0X2krQnQpLzIqaGk7CiAgICB2YXIgVl9pPWdhbHYqQW1faTsKICAgIHZhciBmYV9pPVZfaS8oQnRfaSoxMik7CiAgICB2YXIgRnZfaT1NYXRoLm1pbigxLjUqTWF0aC5zcXJ0KGZtX2VmZikrMC40NSpmYV9pLDIuNSpNYXRoLnNxcnQoZm1fZWZmKSk7CiAgICB2YXIgZnZfaT1FYWhfaS8oQnRfaSoxMik7CiAgICB2YXIgb2s9ZnZfaTw9RnZfYWxsb3c7CiAgICBpZighb2spIGFsZXJ0YXMucHVzaCgnU0hFQVIgQVQgJytsYmwrJzogZnY9JytmbXQoZnZfaSwxKSsncHNpID4gRnY9JytmbXQoRnZfYWxsb3csMSkrJ3BzaSAoVE1TIDQwMi0yMiBTZWMgOC4zLjUpJyk7CiAgICByZXR1cm57QnRfaTpCdF9pLEVhaF9pOkVhaF9pLGZhX2k6ZmFfaSxGdl9p

OkZ2X2ksZnZfaTpmdl9pLG9rOm9rfTsKICB9CiAgdmFyIGoyPWNoZWNrSm9pbnQoSC8yLCdILzI9JytmbXQoSC8yLDEpKydmdCcpOwogIHZhciBqMz1jaGVja0pvaW50KEgvMywnSC8zPScrZm10KEgvMywxKSsnZnQnKTsKICAvLyBHbG9iYWwgc3RhYmlsaXR5IFx1MjAxNCBCaXNob3AgZXhwZWRpZW50CiAgdmFyIENTX2NpcmM9OTk5OwogIGZvcih2YXIgaWM9MDtpYzw1O2ljKyspewogICAgdmFyIEZtX2M9MC41KmdzKkgqSCpNYXRoLnNpbih0b1JhZCg0NS1waGlfZGVnLzIpKS9NYXRoLnRhbihwaGlfcik7CiAgICB2YXIgRnJfYz0wLjUqZ3MqSCpIKk1hdGguY29zKHRvUmFkKDQ1LXBoaV9kZWcvMikpK2NvZXMqSC9NYXRoLmNvcyh0b1JhZCg0NS1waGlfZGVn

LzIpKTsKICAgIHZhciBSYz1IKigwLjcraWMqMC4xKTsKICAgIHZhciBDU19jPUZyX2MvTWF0aC5tYXgoRm1fYywwLjAwMSkqTWF0aC5zcXJ0KFJjLygwLjgqSCkpOwogICAgaWYoQ1NfYzxDU19jaXJjKSBDU19jaXJjPUNTX2M7CiAgfQogIGlmKENTX2NpcmM8MS41KSBhbGVydGFzLnB1c2goJ0dMT0JBTCBTVEFCSUxJVFk6IENTPScrZm10KENTX2NpcmMsMykrJyA8IDEuNSAoSUJDIDIwMjEgLyBBU0NFIDctMjIpJyk7CiAgLy8gU2Vpc21pYyBcdTIwMTQgTW9ub25vYmUtT2thYmUgKEFTQ0UgNy0yMiBDaGFwdGVyIDExKQogIHZhciBGU290X3Npcz0wLEZTc2xfc2lzPTA7CiAgaWYoYWc+MCl7CiAgICB2YXIga2g9MC40KmFnOyAvLyBBU0NFIDctMjIgRXEuKDEx

LjgtNykKICAgIHZhciBkUGFlPTAuMzc1KmtoKmdzKkgqSDsgLy8gbGIvZnQgTW9ub25vYmUtT2thYmUgaW5jcmVtZW50CiAgICB2YXIgeWFfcz0wLjYqSDsKICAgIEZTb3Rfc2lzPU1lLyhNdCtkUGFlKnlhX3MpOwogICAgRlNzbF9zaXM9RnJfcy8oRWFoK2RQYWUpOwogICAgaWYoRlNvdF9zaXM8MS4xKSBhbGVydGFzLnB1c2goJ1NFSVNNSUM6IEZTb3Q9JytmbXQoRlNvdF9zaXMsMykrJyA8IDEuMSAoQVNDRSA3LTIyKScpOwogICAgaWYoRlNzbF9zaXM8MS4xKSBhbGVydGFzLnB1c2goJ1NFSVNNSUM6IEZTc2w9JytmbXQoRlNzbF9zaXMsMykrJyA8IDEuMSAoQVNDRSA3LTIyKScpOwogIH0KICAvLyBTZXR0bGVtZW50IGVzdGltYXRlCiAgdmFyIERlbHRhX3E9

TWF0aC5tYXgocW1heC1ncypIZW0sMCk7CiAgdmFyIHNldF9pbj1waGlfZGVnPj0yNT9EZWx0YV9xLzEwMDAqQmVmZioxMioyL25zcHQ6RGVsdGFfcS8xMDAwLyhrc19wY2kqMTQ0KSoxMDAwOwogIC8vIFNlbWFmb3JvCiAgZnVuY3Rpb24gc0kobGJsLHZhbCxyZXEsZXgsaW52KXsKICAgIHZhciByYXRpbz1pbnY/KHJlcS9NYXRoLm1heCh2YWwsMC4wMDAxKSk6KHZhbC9NYXRoLm1heChyZXEsMC4wMDAxKSk7CiAgICB2YXIgY2xzPXJhdGlvPj0xLjE1Pydvay1zJzoocmF0aW8+PTEuMD8nd2Fybi1zJzonZXJyLXMnKTsKICAgIHZhciBpYz1yYXRpbz49MS4xNT8nT0sgJzoocmF0aW8+PTEuMD8nT0shJzonRkFJTCcpOwogICAgcmV0dXJuICc8ZGl2IGNsYXNzPSJz

aXRlbSAnK2NscysnIj48ZGl2IGNsYXNzPSJzbGJsIj4nK2xibCsnPC9kaXY+PGRpdiBjbGFzcz0ic3ZhbCI+JytpYysnPC9kaXY+PGRpdiBjbGFzcz0ic3JlcSI+JytmbXQodmFsLDIpKyhleD8nIHwgJytleDonJykrJzwvZGl2PjwvZGl2Pic7CiAgfQogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzZW1hZm9ybycpLmlubmVySFRNTD0KICAgIHNJKCdPdmVydHVybmluZ1xuRlNvdCcsRlNvdCwyLjAsJz4yLjAnKSsKICAgIHNJKCdTbGlkaW5nXG5GU3NsJyxGU3NsLDEuNSwnPjEuNScpKwogICAgc0koJ0JlYXJpbmdcbnFhKHBzZiknLHFhX3VzZSxxbWF4LCdxPScrZm10KHFtYXgsMCksdHJ1ZSkrCiAgICBzSSgnRWNjZW50cmljLlxuZShmdCknLGVfbGltLGUs

J0IvNj0nK2ZtdChlX2xpbSwzKSx0cnVlKSsKICAgIHNJKCdBeGlhbFxuZmEocHNpKScsRmFfYWxsb3csZmFfYXZnLCdGYT0nK2ZtdChGYV9hbGxvdywxKSx0cnVlKSsKICAgIHNJKCdTaGVhclxuZnYocHNpKScsRnZfYWxsb3csZnZfYWN0LCdGdj0nK2ZtdChGdl9hbGxvdywxKSx0cnVlKSsKICAgIHNJKCdSZXN1bHQuXG5hbmdsZScsdGhldGFfbGltLHRoZXRhX3JlcywnbGltPScrZm10KHRoZXRhX2xpbSwxKSsnZycsdHJ1ZSkrCiAgICBzSSgnR2xvYmFsXG5zdGFiLicsQ1NfY2lyYywxLjUsJz4xLjUnKTsKICAvLyBBbGVydGFzCiAgdmFyIGFkcj1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYWxlcnRhc19yZXMnKTsKICBhZHIuaW5uZXJIVE1MPWFsZXJ0YXMu

bGVuZ3RoP2FsZXJ0YXMubWFwKGZ1bmN0aW9uKGEpe3JldHVybiAnPGRpdiBjbGFzcz0iYWxlcnRhIj4nK2ErJzwvZGl2Pic7fSkuam9pbignJyk6JzxkaXYgc3R5bGU9ImJhY2tncm91bmQ6dmFyKC0tb2spO2NvbG9yOnZhcigtLW9rYik7Ym9yZGVyLXJhZGl1czo1cHg7cGFkZGluZzo4cHggMTJweDtmb250LXNpemU6MTFweDsiPk5vIGFsZXJ0cyBpZGVudGlmaWVkLjwvZGl2Pic7CiAgLy8gTWVtb3JpYWwKICB2YXIgU0VQPSc9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09JzsKICB2YXIgbWVtPSc8aDQ+JytTRVArJzwvaDQ+JzsKICBtZW0rPScgIENBTENVTEFUSU9OIE1FTU8gXHUyMDE0IENN

VSBNQVNPTlJZIFJFVEFJTklORyBXQUxMXG4gIFRNUyA0MDItMjIgKE1TSkMpIHwgQVNDRSA3LTIyIHwgSUJDIDIwMjFcbjxoND4nK1NFUCsnPC9oND5cbic7CiAgbWVtKz0nICBQcm9qZWN0IDogJytvYnJhKycgIHwgIEVPUjogJytyZXNwKycgIHwgIFBFIExpY2Vuc2U6ICcrbGljZW5jZSsnXG4nOwogIG1lbSs9JyAgRGF0ZSAgICA6ICcrZGNfdisnICBSZXYuOiAnK3JldisnICB8ICBHZW90ZWNoIFJlcG9ydDogJytsYXVkbysnXG5cbic7CiAgbWVtKz0nPGg0PjEuIEdFT01FVFJZPC9oND4nOwogIG1lbSs9JyAgSD0nK0grJ2Z0ICBIZW09JytIZW0rJ2Z0IFttaW49JytmbXQoSGVtX21pbiwyKSsnZnQgJysoSGVtPj1IZW1fbWluPydPSyc6J0ZBSUwnKSsnXVxu

JzsKICBtZW0rPScgIEI9JytCYisnZnQgIEJ0PScrQnQrJ2Z0ICBCL0g9JytmbXQoQmIvSCwyKSsnICBiYXR0ZXI9JytiZXRhX20rJ2RlZyAgc2xvcGU9JytiZXRhKydkZWdcblxuJzsKICBtZW0rPSc8aDQ+Mi4gTUFTT05SWSBcdTIwMTQgVE1TIDQwMi0yMjwvaDQ+JzsKICBtZW0rPScgIENNVTogJytjbXVfaW4rJy1pbiAgTW9ydGFyOiBUeXBlICcrbW9ydGFyKycgKCcrbW9ydGFyX3BzaSsncHNpKSAgSm9pbnQ6ICcrZXNwX2pfaW4rJyIgIFZvaWRzOiAnK3ZhemlvcysnJVxuJzsKICBtZW0rPScgIEdyb3V0aW5nOiAnK2dyYXV0KycgIEhlYWQgam9pbnRzIGZpbGxlZDogJytqdW50YV92Kydcbic7CiAgbWVtKz0nICBmXCdtIHNwZWNpZmllZCA9ICcrZm1fcHNp

KycgcHNpICBHcm91dGluZyBmYWN0b3IgPSAnK2ZtdChncmF1dF9mbSwyKSsnXG4nOwogIG1lbSs9JyAgZm0gZWZmZWN0aXZlID0gJytmbXQoZm1fZWZmLDApKycgcHNpIChwZXIgVE1TIDQwMi0yMiBUYWJsZSAyLjMuMi4xIHdpdGggZ3JvdXRpbmcpXG4nOwogIG1lbSs9JyAgQWxsb3dhYmxlIHN0cmVzc2VzIChBU0QsIFRNUyA0MDItMjIgU2VjdGlvbiA4LjIpOlxuJzsKICBtZW0rPScgICAgRmEgPSAwLjI1KmZtX2VmZiA9ICcrZm10KEZhX2FsbG93LDEpKycgcHNpIChheGlhbCBjb21wcmVzc2lvbilcbic7CiAgbWVtKz0nICAgIEZ2ID0gMS41KnNxcnQoZlwnbSkgPSAnK2ZtdChGdl9hbGxvdywxKSsnIHBzaSAoc2hlYXIsIHVucmVpbmZvcmNlZClcbic7CiAg

bWVtKz0nICAgIEZ0ID0gJytGdF90YWJsZSsnIHBzaSAoZmxleHVyYWwgdGVuc2lvbiwgVHlwZSAnK21vcnRhcisnIG1vcnRhciwgVGFibGUgOC4yLjQpXG5cbic7CiAgbWVtKz0nPGg0PjMuIEJFQVJJTkcgQ0FQQUNJVFkgXHUyMDE0IFRFUlpBR0hJICh3aXRoIEIgZWZmZWN0aXZlKTwvaDQ+JzsKICBtZW0rPScgIEJfZWZmID0gQi0yZSA9ICcrZm10KEJiLDIpKyctMionK2ZtdChlLDMpKycgPSAnK2ZtdChCZWZmLDMpKydmdFxuJzsKICBtZW0rPScgIE5xPScrZm10KHRlei5OcSwzKSsnICBOYz0nK2ZtdCh0ZXouTmMsMykrJyAgTmdhbW1hPScrZm10KHRlei5OZywzKSsnXG4nOwogIG1lbSs9JyAgcXVsdD0nK2ZtdCh0ZXoucXVsdCwwKSsncHNmICBxYT1xdWx0

LzM9JytmbXQodGV6LnFhLDApKydwc2YgIHFhX3VzZT0nK2ZtdChxYV91c2UsMCkrJ3BzZlxuXG4nOwogIG1lbSs9JzxoND40LiBFQVJUSCBQUkVTU1VSRTwvaDQ+JzsKICBtZW0rPScgIEthIChSYW5raW5lLCBkZWx0YT0wKSA9IHRhbl4yKDQ1LXBoaS8yKSA9ICcrZm10KEthX3JhbmssNCkrJyBbVVNFRCBcdTIwMTQgY29uc2VydmF0aXZlXVxuJzsKICBtZW0rPScgIEthIChDb3Vsb21iLCBkZWx0YT1waGkvMykgPSAnK2ZtdChLYV9jb3Vsb21iLDQpKycgW3JlZmVyZW5jZSwgJysoKChLYV9yYW5rLUthX2NvdWxvbWIpL0thX2NvdWxvbWIpKjEwMCkudG9GaXhlZCgxKSsnJSBtb3JlIGNvbnNlcnZhdGl2ZV1cbic7CiAgbWVtKz0nICBQYV9zb2lsID0gMC41Kkth

KmdzKkheMiA9ICcrZm10KEVhX2csMSkrJyBsYi9mdCAgRWFoPScrZm10KEVhaF9nLDEpKycgRWF2PScrZm10KEVhdl9nLDEpKycgbGIvZnRcbic7CiAgaWYodGlwb19zYyE9PSduZW5odW1hJykgbWVtKz0nICBQYV9zdXJjaCA9IEthKnEqSCA9ICcrZm10KEVhX3EsMSkrJyBsYi9mdCAgRWFoPScrZm10KEVhaF9xLDEpKycgRWF2PScrZm10KEVhdl9xLDEpKycgbGIvZnRcbic7CiAgaWYoVV9zdWI+MCkgbWVtKz0nICBVX2h5ZHJvICA9IDAuNSpndypOd19lZmZeMiA9ICcrZm10KFVfc3ViLDEpKycgbGIvZnQgQCBILzM9JytmbXQoVV95YSwyKSsnZnRcbic7CiAgbWVtKz0nICBFcCAocGFzc2l2ZSBhdCB0b2UpID0gMC41KktwKmdzKkhlbV4yID0gJytmbXQoRXAs

MSkrJyBsYi9mdCBbTk9UIHVzZWQgXHUyMDE0IGNvbnNlcnZhdGl2ZSBwZXIgQVNDRSA3LTIyIFNlYyAxMS44XVxuXG4nOwogIG1lbSs9JzxoND41LiBTVEFCSUxJVFkgKEFTRCBcdTIwMTQgdW5mYWN0b3JlZCBsb2Fkcyk8L2g0Pic7CiAgbWVtKz0nICBXX3dhbGw9JytmbXQoV20sMSkrJyBsYi9mdCBAIHhjZz0nK2ZtdCh4Y2csMykrJ2Z0XG4nOwogIG1lbSs9JyAgV19zb2lsPScrZm10KFdzLDEpKycgbGIvZnQgQCB4cz0nK2ZtdCh4cywzKSsnZnRcbic7CiAgbWVtKz0nICBWID0gV193YWxsICsgV19zb2lsICsgRWF2ID0gJytmbXQoViwxKSsnIGxiL2Z0XG4nOwogIG1lbSs9JyAgTVI9JytmbXQoTWUsMSkrJyAgTU89JytmbXQoTXQsMSkrJyBsYi1mdC9mdFxu

JzsKICBtZW0rPScgIEZTb3QgPSBNUi9NTyA9ICcrZm10KEZTb3QsMykrJyA+PSAyLjAgICcrKEZTb3Q+PTI/J09LJzonRkFJTCcpKydcbic7CiAgbWVtKz0nICBGU3NsID0gRnIvRWFoID0gJytmbXQoRlNzbCwzKSsnID49IDEuNSAgJysoRlNzbD49MS41PydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgeFI9JytmbXQoeFIsMykrJ2Z0ICBlPScrZm10KGUsMykrJ2Z0ICBlX2xpbT1CLzY9JytmbXQoZV9saW0sMykrJ2Z0ICAnKyhlPD1lX2xpbT8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIHFfbWF4PScrZm10KHFtYXgsMCkrJ3BzZiAgcV9taW49JytmbXQocW1pbiwwKSsncHNmICBxYT0nK2ZtdChxYV91c2UsMCkrJ3BzZiAgJysocW1heDw9cWFfdXNl

PydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgU2V0dGxlbWVudCB+ICcrZm10KHNldF9pbiwzKSsnIGluXG5cbic7CiAgbWVtKz0nPGg0PjYuIFRNUyA0MDItMjIgTUFTT05SWSBTVFJFU1MgQ0hFQ0tTIChBU0QpPC9oND4nOwogIG1lbSs9JyAgZmEgKGF2ZXJhZ2UgYXhpYWwpID0gVi8oQioxMikgPSAnK2ZtdChWLDEpKycvKCcrZm10KEJiKjEyLDEpKycpID0gJytmbXQoZmFfYXZnLDIpKycgcHNpXG4nOwogIG1lbSs9JyAgZmEgPD0gRmE6ICcrZm10KGZhX2F2ZywxKSsnIDw9ICcrZm10KEZhX2FsbG93LDEpKycgcHNpICAnKyhva19jb21wPydPSyc6J0ZBSUwgXHUyMDE0IFJFSU5GLiBSRVFVSVJFRCcpKycgKFRNUyA0MDItMjIgU2VjIDguMi40KVxuXG4n

OwogIG1lbSs9JyAgZmIgKGZsZXh1cmFsIGF0IGJhc2UpID0gTU8qMTIvUyA9ICcrZm10KE10LDEpKycqMTIvJytmbXQoU19iYXNlLDEpKycgPSAnK2ZtdChmYl9mbGV4LDIpKycgcHNpXG4nOwogIG1lbSs9JyAgZmFfbmV0ID0gZmEgLSBmYiA9ICcrZm10KGZhX2F2ZywyKSsnIC0gJytmbXQoZmJfZmxleCwyKSsnID0gJytmbXQoZmFfbmV0LDIpKycgcHNpICAobmVnYXRpdmUgPSB0ZW5zaW9uKVxuJzsKICBpZihmYV9uZXQ8MCkgbWVtKz0nICBGbGV4dXJhbCB0ZW5zaW9uID0gJytmbXQoTWF0aC5hYnMoZmFfbmV0KSwyKSsnIHBzaSAgRnQ9JytGdF90YWJsZSsnIHBzaSAgJysoTWF0aC5hYnMoZmFfbmV0KTw9RnRfdGFibGU/J09LJzonRkFJTCBcdTIwMTQgUkVJ

TkYuIFJFUVVJUkVEJykrJyAgKFRNUyA0MDItMjIgVGFibGUgOC4yLjQpXG5cbic7CiAgZWxzZSBtZW0rPScgIE5vIG5ldCB0ZW5zaW9uIGF0IGJhc2VcblxuJzsKICBtZW0rPScgIGZ2IChzaGVhcikgPSBFYWgvKEIqMTIpID0gJytmbXQoRWFoLDEpKycvKCcrZm10KEJiKjEyLDEpKycpID0gJytmbXQoZnZfYWN0LDIpKycgcHNpXG4nOwogIG1lbSs9JyAgZnYgPD0gRnY6ICcrZm10KGZ2X2FjdCwyKSsnIDw9ICcrZm10KEZ2X2FsbG93LDEpKycgcHNpICAnKyhva19zaGVhcj8nT0snOidGQUlMIFx1MjAxNCBSRUlORi4gUkVRVUlSRUQnKSsnICAoVE1TIDQwMi0yMiBTZWMgOC4zLjUpXG5cbic7CiAgbWVtKz0nICBSZXN1bHRhbnQgaW5jbGluYXRpb246IHRoZXRh

ID0gYXJjdGFuKEVhaC9WKSA9ICcrZm10KHRoZXRhX3JlcywyKSsnZGVnICBsaW1pdD0nK2ZtdCh0aGV0YV9saW0sMikrJ2RlZyAgJysob2tfdGhldGE/J09LJzonRkFJTCcpKycgIChUTVMgNDAyLTIyIFNlYyA4LjMuNSlcblxuJzsKICBtZW0rPScgIEludGVybWVkaWF0ZSBqb2ludCBhdCBILzI9JytmbXQoSC8yLDEpKydmdDogQnQ9JytmbXQoajIuQnRfaSwzKSsnZnQgIGZ2PScrZm10KGoyLmZ2X2ksMikrJ3BzaSA8PSBGdj0nK2ZtdChGdl9hbGxvdywxKSsncHNpICAnKyhqMi5vaz8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIEludGVybWVkaWF0ZSBqb2ludCBhdCBILzM9JytmbXQoSC8zLDEpKydmdDogQnQ9JytmbXQoajMuQnRfaSwzKSsnZnQgIGZ2

PScrZm10KGozLmZ2X2ksMikrJ3BzaSA8PSBGdj0nK2ZtdChGdl9hbGxvdywxKSsncHNpICAnKyhqMy5vaz8nT0snOidGQUlMJykrJ1xuXG4nOwogIG1lbSs9JzxoND43LiBHTE9CQUwgU1RBQklMSVRZIChCaXNob3AgZXhwZWRpZW50KTwvaDQ+JzsKICBtZW0rPScgIENTIH4gJytmbXQoQ1NfY2lyYywzKSsnID49IDEuNSAgJysoQ1NfY2lyYz49MS41PydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgTk9URTogRnVsbCBCaXNob3Agb3IgU3BlbmNlciBhbmFseXNpcyByZXF1aXJlZCBmb3IgY29uc3RydWN0aW9uIGRvY3VtZW50cyAoSUJDIDIwMjEpLlxuXG4nOwogIGlmKGFnPjApewogICAgbWVtKz0nPGg0PjguIFNFSVNNSUMgXHUyMDE0IE1PTk9OT0JFLU9L

QUJFIChBU0NFIDctMjIgU2VjIDExLjgpPC9oND4nOwogICAgbWVtKz0nICBTcz0nK2FnKydnICBraD0wLjQqU3M9JytmbXQoMC40KmFnLDQpKydcbic7CiAgICBtZW0rPScgIGRQYWUgPSAwLjM3NSpraCpncypIXjIgPSAnK2ZtdCgwLjM3NSowLjQqYWcqZ3MqSCpILDEpKycgbGIvZnRcbic7CiAgICBtZW0rPScgIEZTb3Qoc2Vpc21pYyk9JytmbXQoRlNvdF9zaXMsMykrJyAgRlNzbChzZWlzbWljKT0nK2ZtdChGU3NsX3NpcywzKSsnXG5cbic7CiAgfQogIG1lbSs9JzxoND5TVU1NQVJZPC9oND4nOwogIG1lbSs9JyAgT3ZlcnR1cm5pbmcgIDogRlNvdD0nK2ZtdChGU290LDMpKycgPj0gMi4wICAnKyhGU290Pj0yPydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9

JyAgU2xpZGluZyAgICAgIDogRlNzbD0nK2ZtdChGU3NsLDMpKycgPj0gMS41ICAnKyhGU3NsPj0xLjU/J09LJzonRkFJTCcpKydcbic7CiAgbWVtKz0nICBCZWFyaW5nICAgICAgOiBxPScrZm10KHFtYXgsMCkrJ3BzZiA8PSBxYT0nK2ZtdChxYV91c2UsMCkrJ3BzZiAgJysocW1heDw9cWFfdXNlPydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgRWNjZW50cmljaXR5IDogZT0nK2ZtdChlLDMpKydmdCA8PSBCLzY9JytmbXQoZV9saW0sMykrJ2Z0ICAnKyhlPD1lX2xpbT8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIEF4aWFsIGZhICAgICA6ICcrZm10KGZhX2F2ZywxKSsnIDw9ICcrZm10KEZhX2FsbG93LDEpKydwc2kgICcrKG9rX2NvbXA/J09LJzon

RkFJTCcpKydcbic7CiAgbWVtKz0nICBTaGVhciBmdiAgICAgOiAnK2ZtdChmdl9hY3QsMikrJyA8PSAnK2ZtdChGdl9hbGxvdywxKSsncHNpICAnKyhva19zaGVhcj8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIFJlc3VsdC4gYW5nbGU6ICcrZm10KHRoZXRhX3JlcywxKSsnZGVnIDw9ICcrZm10KHRoZXRhX2xpbSwxKSsnZGVnICAnKyhva190aGV0YT8nT0snOidGQUlMJykrJ1xuJzsKICBtZW0rPScgIEpvaW50IEgvMiAgICA6ICcrKGoyLm9rPydPSyc6J0ZBSUwnKSsnICBKb2ludCBILzM6ICcrKGozLm9rPydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgR2xvYmFsIHN0YWIuIDogQ1M9JytmbXQoQ1NfY2lyYywzKSsnID49IDEuNSAgJysoQ1NfY2ly

Yz49MS41PydPSyc6J0ZBSUwnKSsnXG4nOwogIG1lbSs9JyAgRW1iZWRtZW50ICAgIDogJytmbXQoSGVtLDIpKydmdCA+PSAnK2ZtdChIZW1fbWluLDIpKydmdCAgJysoSGVtPj1IZW1fbWluPydPSyc6J0ZBSUwnKSsnXG5cbic7CiAgaWYoYWxlcnRhcy5sZW5ndGgpe21lbSs9JzxoND5BTEVSVFM8L2g0Pic7YWxlcnRhcy5mb3JFYWNoKGZ1bmN0aW9uKGEpe21lbSs9JyAgWyFdICcrYSsnXG4nO30pO21lbSs9J1xuJzt9CiAgbWVtKz0nJytTRVArJ1xuJzsKICBtZW0rPSdTdGFuZGFyZHM6IFRNUyA0MDItMjIgfCBBU0NFIDctMjIgfCBJQkMgMjAyMVxuJzsKICBtZW0rPSdSZXN1bHRzIHNoYWxsIGJlIHJldmlld2VkIGFuZCBzZWFsZWQgYnkgYSBsaWNlbnNlZCBQ

RS5cbic7CiAgbWVtKz0nJytTRVArJ1xuJzsKICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbWVtb3JpYWwnKS5pbm5lckhUTUw9bWVtOwogIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHRhZG8nKS5zdHlsZS5kaXNwbGF5PSdibG9jayc7CiAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdGFkbycpLnNjcm9sbEludG9WaWV3KHtiZWhhdmlvcjonc21vb3RoJ30pOwp9CndpbmRvdy5vbmxvYWQ9ZnVuY3Rpb24oKXsKICB2YXIgZD1kb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZGMnKTsKICBpZihkJiYhZC52YWx1ZSkgZC52YWx1ZT1uZXcgRGF0ZSgpLnRvSVNPU3RyaW5nKCkuc2xpY2UoMCwxMCk7Cn07Cjwvc2NyaXB0Pg==