IyEgL2Jpbi9zaAouICIke3NyY2Rpcj0ufS9pbml0LnNoIjsgcGF0aF9wcmVwZW5kXyAuIC4uL3NyYwoKIyBUZXN0IG9mIGdldHRleHQgZmFjaWxpdGllcyBpbiB0aGUgZ3VpbGUgaW1wbGVtZW50YXRpb24gb2YgU2NoZW1lLgojIEFzc3VtZXMgYW4gZnJfRlIgbG9jYWxlIGlzIGluc3RhbGxlZC4KIyBBc3N1bWVzIHRoZSBmb2xsb3dpbmcgcGFja2FnZXMgYXJlIGluc3RhbGxlZDogZ3VpbGUuCgpjYXQgPDxcRU9GID4gcHJvZy5zY20KKHVzZS1tb2R1bGVzIChpY2UtOSBmb3JtYXQpKQoKKHNldGxvY2FsZSBMQ19BTEwgIiIpCih0ZXh0ZG9tYWluICJwcm9nIikKKGJpbmR0ZXh0ZG9tYWluICJwcm9nIiAiLiIpCgooZGVmaW5lIG4gKHN0cmluZy0+bnVtYmVyIChsaXN0LXJlZiAoY29tbWFuZC1saW5lKSAxKSkpCgooZm9ybWF0ICN0ICJ+QX4lIiAoZ2V0dGV4dCAiJ1lvdXIgY29tbWFuZCwgcGxlYXNlPycsIGFza2VkIHRoZSB3YWl0ZXIuIikpCgooZm9ybWF0ICN0ICJ+QD9+JSIgKG5nZXR0ZXh0ICJhIHBpZWNlIG9mIGNha2UiICJ+RCBwaWVjZXMgb2YgY2FrZSIgbikgbikKCihmb3JtYXQgI3QgIn5BfiUiIChmb3JtYXQgI2YgKGdldHRleHQgIn5BIGlzIHJlcGxhY2VkIGJ5IH5BLiIpICJGRiIgIkVVUiIpKQpFT0YKCjogJHtYR0VUVEVYVD14Z2V0dGV4dH0KJHtYR0VUVEVYVH0gLW8gcHJvZy50bXAgLS1vbWl0LWhlYWRlciAtLW5vLWxvY2F0aW9uIHByb2cuc2NtIHx8IEV4aXQgMQpMQ19BTEw9QyB0ciAtZCAnXHInIDwgcHJvZy50bXAgPiBwcm9nLnBvdCB8fCBFeGl0IDEKCmNhdCA8PEVPRiA+IHByb2cub2sKbXNnaWQgIidZb3VyIGNvbW1hbmQsIHBsZWFzZT8nLCBhc2tlZCB0aGUgd2FpdGVyLiIKbXNnc3RyICIiCgojLCBzY2hlbWUtZm9ybWF0Cm1zZ2lkICJhIHBpZWNlIG9mIGNha2UiCm1zZ2lkX3BsdXJhbCAifkQgcGllY2VzIG9mIGNha2UiCm1zZ3N0clswXSAiIgptc2dzdHJbMV0gIiIKCiMsIHNjaGVtZS1mb3JtYXQKbXNnaWQgIn5BIGlzIHJlcGxhY2VkIGJ5IH5BLiIKbXNnc3RyICIiCkVPRgoKOiAke0RJRkY9ZGlmZn0KJHtESUZGfSBwcm9nLm9rIHByb2cucG90IHx8IEV4aXQgMQoKY2F0IDw8XEVPRiA+IGZyLnBvCm1zZ2lkICIiCm1zZ3N0ciAiIgoiQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PUlTTy04ODU5LTFcbiIKIlBsdXJhbC1Gb3JtczogbnBsdXJhbHM9MjsgcGx1cmFsPShuID4gMSk7XG4iCgptc2dpZCAiJ1lvdXIgY29tbWFuZCwgcGxlYXNlPycsIGFza2VkIHRoZSB3YWl0ZXIuIgptc2dzdHIgIqtWb3RyZSBjb21tYW5kZSwgcydpbCB2b3VzIHBsYWl0uywgZGl0IGxlIGdhcudvbi4iCgojIExlcyBnYXRlYXV4IGFsbGVtYW5kcyBzb250IGxlcyBtZWlsbGV1cnMgZHUgbW9uZGUuCiMsIHNjaGVtZS1mb3JtYXQKbXNnaWQgImEgcGllY2Ugb2YgY2FrZSIKbXNnaWRfcGx1cmFsICJ+RCBwaWVjZXMgb2YgY2FrZSIKbXNnc3RyWzBdICJ1biBtb3JjZWF1IGRlIGdhdGVhdSIKbXNnc3RyWzFdICJ+RCBtb3JjZWF1eCBkZSBnYXRlYXUiCgojIFJldmVyc2UgdGhlIGFyZ3VtZW50cy4KIywgc2NoZW1lLWZvcm1hdAptc2dpZCAifkEgaXMgcmVwbGFjZWQgYnkgfkEuIgptc2dzdHIgIn4xQCp+QSByZW1wbGFjZSB+MEAqfkEuIgpFT0YKCjogJHtNU0dNRVJHRT1tc2dtZXJnZX0KJHtNU0dNRVJHRX0gLXEgLW8gZnIucG8udG1wIGZyLnBvIHByb2cucG90IHx8IEV4aXQgMQpMQ19BTEw9QyB0ciAtZCAnXHInIDwgZnIucG8udG1wID4gZnIucG8ubmV3IHx8IEV4aXQgMQoKOiAke0RJRkY9ZGlmZn0KJHtESUZGfSBmci5wbyBmci5wby5uZXcgfHwgRXhpdCAxCgp0ZXN0IC1kIGZyIHx8IG1rZGlyIGZyCnRlc3QgLWQgZnIvTENfTUVTU0FHRVMgfHwgbWtkaXIgZnIvTENfTUVTU0FHRVMKCjogJHtNU0dGTVQ9bXNnZm10fQoke01TR0ZNVH0gLW8gZnIvTENfTUVTU0FHRVMvcHJvZy5tbyBmci5wbwoKIyBUZXN0IGZvciBwcmVzZW5jZSBvZiBndWlsZSB2ZXJzaW9uIDIuMCBvciBuZXdlci4KKGd1aWxlIC0tdmVyc2lvbikgPi9kZXYvbnVsbCAyPi9kZXYvbnVsbCBcCiAgfHwgeyBlY2hvICJTa2lwcGluZyB0ZXN0OiBndWlsZSBub3QgZm91bmQiOyBFeGl0IDc3OyB9CmNhc2UgYGd1aWxlIC0tdmVyc2lvbiB8IHNlZCAtZSAxcSB8IHNlZCAtZSAncy9eW14wLTldKi8vJ2AgaW4KICAwLiogfCAxLiogKQogICAgZWNobyAiU2tpcHBpbmcgdGVzdDogZ3VpbGUgdmVyc2lvbiB0b28gb2xkIjsgRXhpdCA3Nzs7CmVzYWMKCiMgVGVzdCB3aGljaCBvZiB0aGUgZnJfRlIgbG9jYWxlcyBhcmUgaW5zdGFsbGVkLgo6ICR7TE9DQUxFX0ZSPWZyX0ZSfQo6ICR7TE9DQUxFX0ZSX1VURjg9ZnJfRlIuVVRGLTh9CmlmIHRlc3QgJExPQ0FMRV9GUiAhPSBub25lOyB0aGVuCiAgTENfQUxMPSRMT0NBTEVfRlIgLi4vdGVzdGxvY2FsZQogIGNhc2UgJD8gaW4KICAgIDApIDs7CiAgICA3NykgTE9DQUxFX0ZSPW5vbmU7OwogICAgKikgRXhpdCAxOzsKICBlc2FjCmZpCmlmIHRlc3QgJExPQ0FMRV9GUl9VVEY4ICE9IG5vbmU7IHRoZW4KICBMQ19BTEw9JExPQ0FMRV9GUl9VVEY4IC4uL3Rlc3Rsb2NhbGUKICBjYXNlICQ/IGluCiAgICAwKSA7OwogICAgNzcpIExPQ0FMRV9GUl9VVEY4PW5vbmU7OwogICAgKikgRXhpdCAxOzsKICBlc2FjCmZpCmlmIHRlc3QgJExPQ0FMRV9GUiA9IG5vbmUgJiYgdGVzdCAkTE9DQUxFX0ZSX1VURjggPSBub25lOyB0aGVuCiAgaWYgdGVzdCAtZiAvdXNyL2Jpbi9sb2NhbGVkZWY7IHRoZW4KICAgIGVjaG8gIlNraXBwaW5nIHRlc3Q6IG5vIGZyZW5jaCBsb2NhbGUgaXMgaW5zdGFsbGVkIgogIGVsc2UKICAgIGVjaG8gIlNraXBwaW5nIHRlc3Q6IG5vIGZyZW5jaCBsb2NhbGUgaXMgc3VwcG9ydGVkIgogIGZpCiAgRXhpdCA3NwpmaQoKOiAke0RJRkY9ZGlmZn0KY2F0IDw8XEVPRiA+IHByb2cub2sKq1ZvdHJlIGNvbW1hbmRlLCBzJ2lsIHZvdXMgcGxhaXS7LCBkaXQgbGUgZ2Fy529uLgoyIG1vcmNlYXV4IGRlIGdhdGVhdQpFVVIgcmVtcGxhY2UgRkYuCkVPRgpjYXQgPDxcRU9GID4gcHJvZy5va3UKwqtWb3RyZSBjb21tYW5kZSwgcydpbCB2b3VzIHBsYWl0wrssIGRpdCBsZSBnYXLDp29uLgoyIG1vcmNlYXV4IGRlIGdhdGVhdQpFVVIgcmVtcGxhY2UgRkYuCkVPRgoKOiAke0xPQ0FMRV9GUj1mcl9GUn0KOiAke0xPQ0FMRV9GUl9VVEY4PWZyX0ZSLlVURi04fQppZiB0ZXN0ICRMT0NBTEVfRlIgIT0gbm9uZTsgdGhlbgogIHByZXBhcmVfbG9jYWxlXyBmciAkTE9DQUxFX0ZSCiAgTEFOR1VBR0U9IExDX0FMTD0kTE9DQUxFX0ZSIGd1aWxlIC1zIHByb2cuc2NtIDIgPiBwcm9nLm91dCAyPnByb2cuZXJyIHx8IHsgY2F0IHByb2cuZXJyIDE+JjI7IEV4aXQgMTsgfQogIGdyZXAgLXYgJ147OzsnIHByb2cuZXJyIDE+JjIKICAke0RJRkZ9IHByb2cub2sgcHJvZy5vdXQgfHwgRXhpdCAxCmZpCmlmIHRlc3QgJExPQ0FMRV9GUl9VVEY4ICE9IG5vbmU7IHRoZW4KICBwcmVwYXJlX2xvY2FsZV8gZnIgJExPQ0FMRV9GUl9VVEY4CiAgTEFOR1VBR0U9IExDX0FMTD0kTE9DQUxFX0ZSX1VURjggZ3VpbGUgLXMgcHJvZy5zY20gMiA+IHByb2cub3V0IDI+cHJvZy5lcnIgfHwgeyBjYXQgcHJvZy5lcnIgMT4mMjsgRXhpdCAxOyB9CiAgZ3JlcCAtdiAnXjs7OycgcHJvZy5lcnIgMT4mMgogICR7RElGRn0gcHJvZy5va3UgcHJvZy5vdXQgfHwgRXhpdCAxCmZpCgpFeGl0IDAK