IyBMb2NhbGl6ZWQgZXJyb3IgbWVzc2FnZXMgZm9yIGdudS5yZWdleHAsIGluIEl0YWxpYW4uCiMgJElkOiBNZXNzYWdlc0J1bmRsZV9pdC5wcm9wZXJ0aWVzLHYgMS4xIDIwMDYvMDcvMTkgMTk6NDc6MDcgcmFiYml0NzggRXhwICQKIyBNZXNzYWdnaSBpdGFsaWFuaSBwZXIgZ251LnJlZ2V4cC4KIwojIEF0dGVuemlvbmU6IFF1ZXN0YSB0cmFkdXppb25lIGZ1IHNjcml0dG8gZGEgdW4gaXRhbG8tYW1lcmljYW5vLgojCVBlciBmYXZvcmUgY29ycmVnZ2V0ZSBsJ2l0YWxpYW5vIGJlc3RlbW1pYXRvIGUgbWFuZGF0ZSBpIHBhdGNoCiMJYWwgbGlzdG8gPGNsYXNzcGF0aCBhdCBnbnUgZG90IG9yZz4uCiMKIyBAYXV0aG9yIFN0ZXZlbiBBdWdhcnQgPHN0ZXZlIGF0IHdhdHNvbiBkb3QgaWJtIGRvdCBjb20+LCA8c3RldmUgYXQgYXVnYXJ0IGRvdCBjb20+CgojIFByZWZpeCBmb3IgUkVFeGNlcHRpb24gbWVzc2FnZXMKZXJyb3IucHJlZml4PUFsIGluZGljZSB7MH0gbmVsIG1vZGVsbG8gZGVsbCcnZXNwcmVzc2lvbmUgcmVndWxhcmU6CgojIFJFRXhjZXB0aW9uIChwYXJzZSBlcnJvcikgbWVzc2FnZXMKcmVwZWF0LmFzc2VydGlvbj1sJydlbGVtZW50byByaXBldHV0byBoYSBsYXJnaGV6emEgemVybwpyZXBlYXQuY2hhaW5lZD1wcm92YSBkaSByaXBldGVyZSB1biBlbGVtZW50byBnaeAgcmlwZXR1dG8KcmVwZWF0Lm5vLnRva2VuPXF1YW50aWZpY2F0b3JlICg/Kit7fSkgc2VuemEgZWxlbWVudG8gcHJlY2VkZW50ZQpyZXBlYXQuZW1wdHkudG9rZW49bCcnZWxlbWVudG8gcmlwZXR1dG8gcHXyIGVzc2VyZSB2dW90bwp1bm1hdGNoZWQuYnJhY2U9cGFyZW50ZXNpIHF1YWRyYSBzZW56YSBjb3JyaXNwb25kZW50ZQp1bm1hdGNoZWQuYnJhY2tldD1ncmFmZmEgc2VuemEgY29ycmlzcG9uZGVudGUKdW5tYXRjaGVkLnBhcmVuPXBhcmVudGVzaSBzZW56YSBjb3JyaXNwb25kZW50ZQppbnRlcnZhbC5uby5lbmQ9bGEgZmluZSBkJydpbnRlcnZhbGxvIOggaW1wcmV2aXN0YSAKY2xhc3Mubm8uZW5kPWxhIGZpbmUgZGVsbGEgY2xhc3NlIGRpIGNhcmF0dGVyaSDoIGltcHJldmlzdGEKc3ViZXhwci5uby5lbmQ9bGEgZmluZSBkZWwgc3ViLWVzcHJlc3Npb25lIOggaW1wcmV2aXN0YQppbnRlcnZhbC5vcmRlcj1pbCB2YWxvcmUgbWluaW1vIGQnJ2ludGVydmFsbG8g6CBwafogZ3JhbmRlIGRlbCBzdW8gdmFsb3JlIG1hc3NpbW8KaW50ZXJ2YWwuZXJyb3I9bCcnaW50ZXJ2YWxsbyDoIHZ1b3RvIG8gY29udGllbmUgY2FyYXR0ZXJpIGltcGVybWVzc2liaWxpCiMgIE5vbiBzbyBjb21lIHNpIGRpY2UgImJhY2tzbGFzaCIgaW4gaXRhbGlhbm8uCmVuZHMud2l0aC5iYWNrc2xhc2g9aWwgbW9kZWxsbyBmaW5pc2NlIGNvbiB1biBiYWNrc2xhc2ggKGlsIGNhcmF0dGVyZSAiXCIpCgojIFJFU3ludGF4IG1lc3NhZ2UKc3ludGF4LmZpbmFsPUxhIHNpbnRhc3NpIOggZGljaGlhcmF0YSAiZmluYWwiIChmaW5hbGUpIGUgbm9uIHNpIHB18iBtb2RpZmljYXJsYQo=