KiBOWFAgU2VtaWNvbmR1Y3RvcnMgUE41NDQgTkZDIENvbnRyb2xsZXIKClJlcXVpcmVkIHByb3BlcnRpZXM6Ci0gY29tcGF0aWJsZTogU2hvdWxkIGJlICJueHAscG41NDQtaTJjIi4KLSBjbG9jay1mcmVxdWVuY3k6IEmyQyB3b3JrIGZyZXF1ZW5jeS4KLSByZWc6IGFkZHJlc3Mgb24gdGhlIGJ1cwotIGludGVycnVwdC1wYXJlbnQ6IHBoYW5kbGUgZm9yIHRoZSBpbnRlcnJ1cHQgZ3BpbyBjb250cm9sbGVyCi0gaW50ZXJydXB0czogR1BJTyBpbnRlcnJ1cHQgdG8gd2hpY2ggdGhlIGNoaXAgaXMgY29ubmVjdGVkCi0gZW5hYmxlLWdwaW9zOiBPdXRwdXQgR1BJTyBwaW4gdXNlZCBmb3IgZW5hYmxpbmcvZGlzYWJsaW5nIHRoZSBQTjU0NAotIGZpcm13YXJlLWdwaW9zOiBPdXRwdXQgR1BJTyBwaW4gdXNlZCB0byBlbnRlciBmaXJtd2FyZSBkb3dubG9hZCBtb2RlCgpPcHRpb25hbCBTb0MgU3BlY2lmaWMgUHJvcGVydGllczoKLSBwaW5jdHJsLW5hbWVzOiBDb250YWlucyBvbmx5IG9uZSB2YWx1ZSAtICJkZWZhdWx0Ii4KLSBwaW50Y3RybC0wOiBTcGVjaWZpZXMgdGhlIHBpbiBjb250cm9sIGdyb3VwcyB1c2VkIGZvciB0aGlzIGNvbnRyb2xsZXIuCgpFeGFtcGxlIChmb3IgQVJNLWJhc2VkIEJlYWdsZUJvbmUgd2l0aCBQTjU0NCBvbiBJMkMyKToKCiZpMmMyIHsKCglzdGF0dXMgPSAib2theSI7CgoJcG41NDQ6IHBuNTQ0QDI4IHsKCgkJY29tcGF0aWJsZSA9ICJueHAscG41NDQtaTJjIjsKCgkJcmVnID0gPDB4Mjg+OwoJCWNsb2NrLWZyZXF1ZW5jeSA9IDw0MDAwMDA+OwoKCQlpbnRlcnJ1cHQtcGFyZW50ID0gPCZncGlvMT47CgkJaW50ZXJydXB0cyA9IDwxNyBHUElPX0FDVElWRV9ISUdIPjsKCgkJZW5hYmxlLWdwaW9zID0gPCZncGlvMyAyMSBHUElPX0FDVElWRV9ISUdIPjsKCQlmaXJtd2FyZS1ncGlvcyA9IDwmZ3BpbzMgMTkgR1BJT19BQ1RJVkVfSElHSD47Cgl9Owp9Owo=