KmV2YWwudHh0KglGb3IgVmltIHZlcnNpb24gNy4zLiAgTGFzdCBjaGFuZ2U6IDIwMTIgSmFuIDI4CgoKCQkgIFZJTSBSRUZFUkVOQ0UgTUFOVUFMCSAgYnkgQnJhbSBNb29sZW5hYXIKCgpFeHByZXNzaW9uIGV2YWx1YXRpb24JCQkqZXhwcmVzc2lvbiogKmV4cHIqICpFMTUqICpldmFsKgoKVXNpbmcgZXhwcmVzc2lvbnMgaXMgaW50cm9kdWNlZCBpbiBjaGFwdGVyIDQxIG9mIHRoZSB1c2VyIG1hbnVhbCB8dXNyXzQxLnR4dHwuCgpOb3RlOiBFeHByZXNzaW9uIGV2YWx1YXRpb24gY2FuIGJlIGRpc2FibGVkIGF0IGNvbXBpbGUgdGltZS4gIElmIHRoaXMgaGFzIGJlZW4KZG9uZSwgdGhlIGZlYXR1cmVzIGluIHRoaXMgZG9jdW1lbnQgYXJlIG5vdCBhdmFpbGFibGUuCVNlZSB8K2V2YWx8IGFuZAp8bm8tZXZhbC1mZWF0dXJlfC4KCjEuICBWYXJpYWJsZXMJCQl8dmFyaWFibGVzfAogICAgMS4xIFZhcmlhYmxlIHR5cGVzCiAgICAxLjIgRnVuY3Rpb24gcmVmZXJlbmNlcwkJfEZ1bmNyZWZ8CiAgICAxLjMgTGlzdHMJCQkJfExpc3RzfAogICAgMS40IERpY3Rpb25hcmllcwkJCXxEaWN0aW9uYXJpZXN8CiAgICAxLjUgTW9yZSBhYm91dCB2YXJpYWJsZXMJCXxtb3JlLXZhcmlhYmxlc3wKMi4gIEV4cHJlc3Npb24gc3ludGF4CQl8ZXhwcmVzc2lvbi1zeW50YXh8CjMuICBJbnRlcm5hbCB2YXJpYWJsZQkJfGludGVybmFsLXZhcmlhYmxlc3wKNC4gIEJ1aWx0aW4gRnVuY3Rpb25zCQl8ZnVuY3Rpb25zfAo1LiAgRGVmaW5pbmcgZnVuY3Rpb25zCQl8dXNlci1mdW5jdGlvbnN8CjYuICBDdXJseSBicmFjZXMgbmFtZXMJCXxjdXJseS1icmFjZXMtbmFtZXN8CjcuICBDb21tYW5kcwkJCXxleHByZXNzaW9uLWNvbW1hbmRzfAo4LiAgRXhjZXB0aW9uIGhhbmRsaW5nCQl8ZXhjZXB0aW9uLWhhbmRsaW5nfAo5LiAgRXhhbXBsZXMJCQl8ZXZhbC1leGFtcGxlc3wKMTAuIE5vICtldmFsIGZlYXR1cmUJCXxuby1ldmFsLWZlYXR1cmV8CjExLiBUaGUgc2FuZGJveAkJCXxldmFsLXNhbmRib3h8CjEyLiBUZXh0bG9jawkJCXx0ZXh0bG9ja3wKCntWaSBkb2VzIG5vdCBoYXZlIGFueSBvZiB0aGVzZSBjb21tYW5kc30KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoxLiBWYXJpYWJsZXMJCQkJCQkqdmFyaWFibGVzKgoKMS4xIFZhcmlhYmxlIHR5cGVzIH4KCQkJCQkJCSpFNzEyKgpUaGVyZSBhcmUgc2l4IHR5cGVzIG9mIHZhcmlhYmxlczoKCk51bWJlcgkJQSAzMiBvciA2NCBiaXQgc2lnbmVkIG51bWJlci4gIHxleHByLW51bWJlcnwgKk51bWJlcioKCQlFeGFtcGxlczogIC0xMjMgIDB4MTAgIDAxNzcKCkZsb2F0CQlBIGZsb2F0aW5nIHBvaW50IG51bWJlci4gfGZsb2F0aW5nLXBvaW50LWZvcm1hdHwgKkZsb2F0KgoJCXtvbmx5IHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQlFeGFtcGxlczogMTIzLjQ1NiAgMS4xNWUtNiAgLTEuMWUzCgpTdHJpbmcJCUEgTlVMIHRlcm1pbmF0ZWQgc3RyaW5nIG9mIDgtYml0IHVuc2lnbmVkIGNoYXJhY3RlcnMgKGJ5dGVzKS4KCQl8ZXhwci1zdHJpbmd8IEV4YW1wbGVzOiAiYWJcdHh4XCItLSIgICd4LXonJ2EsYycKCkZ1bmNyZWYJCUEgcmVmZXJlbmNlIHRvIGEgZnVuY3Rpb24gfEZ1bmNyZWZ8LgoJCUV4YW1wbGU6IGZ1bmN0aW9uKCJzdHJsZW4iKQoKTGlzdAkJQW4gb3JkZXJlZCBzZXF1ZW5jZSBvZiBpdGVtcyB8TGlzdHwuCgkJRXhhbXBsZTogWzEsIDIsIFsnYScsICdiJ11dCgpEaWN0aW9uYXJ5CUFuIGFzc29jaWF0aXZlLCB1bm9yZGVyZWQgYXJyYXk6IEVhY2ggZW50cnkgaGFzIGEga2V5IGFuZCBhCgkJdmFsdWUuIHxEaWN0aW9uYXJ5fAoJCUV4YW1wbGU6IHsnYmx1ZSc6ICIjMDAwMGZmIiwgJ3JlZCc6ICIjZmYwMDAwIn0KClRoZSBOdW1iZXIgYW5kIFN0cmluZyB0eXBlcyBhcmUgY29udmVydGVkIGF1dG9tYXRpY2FsbHksIGRlcGVuZGluZyBvbiBob3cgdGhleQphcmUgdXNlZC4KCkNvbnZlcnNpb24gZnJvbSBhIE51bWJlciB0byBhIFN0cmluZyBpcyBieSBtYWtpbmcgdGhlIEFTQ0lJIHJlcHJlc2VudGF0aW9uIG9mCnRoZSBOdW1iZXIuICBFeGFtcGxlczoKCU51bWJlciAxMjMJLS0+CVN0cmluZyAiMTIzIiB+CglOdW1iZXIgMAktLT4JU3RyaW5nICIwIiB+CglOdW1iZXIgLTEJLS0+CVN0cmluZyAiLTEiIH4KCQkJCQkJCSpvY3RhbCoKQ29udmVyc2lvbiBmcm9tIGEgU3RyaW5nIHRvIGEgTnVtYmVyIGlzIGRvbmUgYnkgY29udmVydGluZyB0aGUgZmlyc3QgZGlnaXRzCnRvIGEgbnVtYmVyLiAgSGV4YWRlY2ltYWwgIjB4ZjkiIGFuZCBPY3RhbCAiMDE3IiBudW1iZXJzIGFyZSByZWNvZ25pemVkLiAgSWYKdGhlIFN0cmluZyBkb2Vzbid0IHN0YXJ0IHdpdGggZGlnaXRzLCB0aGUgcmVzdWx0IGlzIHplcm8uICBFeGFtcGxlczoKCVN0cmluZyAiNDU2IgktLT4JTnVtYmVyIDQ1NiB+CglTdHJpbmcgIjZiYXIiCS0tPglOdW1iZXIgNiB+CglTdHJpbmcgImZvbyIJLS0+CU51bWJlciAwIH4KCVN0cmluZyAiMHhmMSIJLS0+CU51bWJlciAyNDEgfgoJU3RyaW5nICIwMTAwIgktLT4JTnVtYmVyIDY0IH4KCVN0cmluZyAiLTgiCS0tPglOdW1iZXIgLTggfgoJU3RyaW5nICIrOCIJLS0+CU51bWJlciAwIH4KClRvIGZvcmNlIGNvbnZlcnNpb24gZnJvbSBTdHJpbmcgdG8gTnVtYmVyLCBhZGQgemVybyB0byBpdDogPgoJOmVjaG8gIjAxMDAiICsgMAo8CTY0IH4KClRvIGF2b2lkIGEgbGVhZGluZyB6ZXJvIHRvIGNhdXNlIG9jdGFsIGNvbnZlcnNpb24sIG9yIGZvciB1c2luZyBhIGRpZmZlcmVudApiYXNlLCB1c2UgfHN0cjJucigpfC4KCkZvciBib29sZWFuIG9wZXJhdG9ycyBOdW1iZXJzIGFyZSB1c2VkLiAgWmVybyBpcyBGQUxTRSwgbm9uLXplcm8gaXMgVFJVRS4KCk5vdGUgdGhhdCBpbiB0aGUgY29tbWFuZCA+Cgk6aWYgImZvbyIKImZvbyIgaXMgY29udmVydGVkIHRvIDAsIHdoaWNoIG1lYW5zIEZBTFNFLiAgVG8gdGVzdCBmb3IgYSBub24tZW1wdHkgc3RyaW5nLAp1c2Ugc3RybGVuKCk6ID4KCTppZiBzdHJsZW4oImZvbyIpCjwJCQkJKkU3NDUqICpFNzI4KiAqRTcwMyogKkU3MjkqICpFNzMwKiAqRTczMSoKTGlzdCwgRGljdGlvbmFyeSBhbmQgRnVuY3JlZiB0eXBlcyBhcmUgbm90IGF1dG9tYXRpY2FsbHkgY29udmVydGVkLgoKCQkJCQkJCSpFODA1KiAqRTgwNiogKkU4MDgqCldoZW4gbWl4aW5nIE51bWJlciBhbmQgRmxvYXQgdGhlIE51bWJlciBpcyBjb252ZXJ0ZWQgdG8gRmxvYXQuCU90aGVyd2lzZQp0aGVyZSBpcyBubyBhdXRvbWF0aWMgY29udmVyc2lvbiBvZiBGbG9hdC4gIFlvdSBjYW4gdXNlIHN0cjJmbG9hdCgpIGZvciBTdHJpbmcKdG8gRmxvYXQsIHByaW50ZigpIGZvciBGbG9hdCB0byBTdHJpbmcgYW5kIGZsb2F0Mm5yKCkgZm9yIEZsb2F0IHRvIE51bWJlci4KCgkJCQkJCSpFNzA2KiAqc3RpY2t5LXR5cGUtY2hlY2tpbmcqCllvdSB3aWxsIGdldCBhbiBlcnJvciBpZiB5b3UgdHJ5IHRvIGNoYW5nZSB0aGUgdHlwZSBvZiBhIHZhcmlhYmxlLiAgWW91IG5lZWQKdG8gfDp1bmxldHwgaXQgZmlyc3QgdG8gYXZvaWQgdGhpcyBlcnJvci4gIFN0cmluZyBhbmQgTnVtYmVyIGFyZSBjb25zaWRlcmVkCmVxdWl2YWxlbnQgdGhvdWdoLCBhcyB3ZWxsIGFyZSBGbG9hdCBhbmQgTnVtYmVyLiAgQ29uc2lkZXIgdGhpcyBzZXF1ZW5jZSBvZgpjb21tYW5kczogPgoJOmxldCBsID0gInN0cmluZyIKCTpsZXQgbCA9IDQ0CQkiIGNoYW5nZXMgdHlwZSBmcm9tIFN0cmluZyB0byBOdW1iZXIKCTpsZXQgbCA9IFsxLCAyLCAzXQkiIGVycm9yISAgbCBpcyBzdGlsbCBhIE51bWJlcgoJOmxldCBsID0gNC40CQkiIGNoYW5nZXMgdHlwZSBmcm9tIE51bWJlciB0byBGbG9hdAoJOmxldCBsID0gInN0cmluZyIJIiBlcnJvciEKCgoxLjIgRnVuY3Rpb24gcmVmZXJlbmNlcyB+CgkJCQkJKkZ1bmNyZWYqICpFNjk1KiAqRTcxOCoKQSBGdW5jcmVmIHZhcmlhYmxlIGlzIG9idGFpbmVkIHdpdGggdGhlIHxmdW5jdGlvbigpfCBmdW5jdGlvbi4JSXQgY2FuIGJlIHVzZWQKaW4gYW4gZXhwcmVzc2lvbiBpbiB0aGUgcGxhY2Ugb2YgYSBmdW5jdGlvbiBuYW1lLCBiZWZvcmUgdGhlIHBhcmVudGhlc2lzCmFyb3VuZCB0aGUgYXJndW1lbnRzLCB0byBpbnZva2UgdGhlIGZ1bmN0aW9uIGl0IHJlZmVycyB0by4gIEV4YW1wbGU6ID4KCgk6bGV0IEZuID0gZnVuY3Rpb24oIk15RnVuYyIpCgk6ZWNobyBGbigpCjwJCQkJCQkJKkU3MDQqICpFNzA1KiAqRTcwNyoKQSBGdW5jcmVmIHZhcmlhYmxlIG11c3Qgc3RhcnQgd2l0aCBhIGNhcGl0YWwsICJzOiIsICJ3OiIsICJ0OiIgb3IgImI6Ii4gIFlvdQpjYW5ub3QgaGF2ZSBib3RoIGEgRnVuY3JlZiB2YXJpYWJsZSBhbmQgYSBmdW5jdGlvbiB3aXRoIHRoZSBzYW1lIG5hbWUuCgpBIHNwZWNpYWwgY2FzZSBpcyBkZWZpbmluZyBhIGZ1bmN0aW9uIGFuZCBkaXJlY3RseSBhc3NpZ25pbmcgaXRzIEZ1bmNyZWYgdG8gYQpEaWN0aW9uYXJ5IGVudHJ5LiAgRXhhbXBsZTogPgoJOmZ1bmN0aW9uIGRpY3QuaW5pdCgpIGRpY3QKCTogICBsZXQgc2VsZi52YWwgPSAwCgk6ZW5kZnVuY3Rpb24KClRoZSBrZXkgb2YgdGhlIERpY3Rpb25hcnkgY2FuIHN0YXJ0IHdpdGggYSBsb3dlciBjYXNlIGxldHRlci4gIFRoZSBhY3R1YWwKZnVuY3Rpb24gbmFtZSBpcyBub3QgdXNlZCBoZXJlLiAgQWxzbyBzZWUgfG51bWJlcmVkLWZ1bmN0aW9ufC4KCkEgRnVuY3JlZiBjYW4gYWxzbyBiZSB1c2VkIHdpdGggdGhlIHw6Y2FsbHwgY29tbWFuZDogPgoJOmNhbGwgRm4oKQoJOmNhbGwgZGljdC5pbml0KCkKClRoZSBuYW1lIG9mIHRoZSByZWZlcmVuY2VkIGZ1bmN0aW9uIGNhbiBiZSBvYnRhaW5lZCB3aXRoIHxzdHJpbmcoKXwuID4KCTpsZXQgZnVuYyA9IHN0cmluZyhGbikKCllvdSBjYW4gdXNlIHxjYWxsKCl8IHRvIGludm9rZSBhIEZ1bmNyZWYgYW5kIHVzZSBhIGxpc3QgdmFyaWFibGUgZm9yIHRoZQphcmd1bWVudHM6ID4KCTpsZXQgciA9IGNhbGwoRm4sIG15bGlzdCkKCgoxLjMgTGlzdHMgfgoJCQkJCQkJKkxpc3QqICpMaXN0cyogKkU2ODYqCkEgTGlzdCBpcyBhbiBvcmRlcmVkIHNlcXVlbmNlIG9mIGl0ZW1zLiAgQW4gaXRlbSBjYW4gYmUgb2YgYW55IHR5cGUuICBJdGVtcwpjYW4gYmUgYWNjZXNzZWQgYnkgdGhlaXIgaW5kZXggbnVtYmVyLglJdGVtcyBjYW4gYmUgYWRkZWQgYW5kIHJlbW92ZWQgYXQgYW55CnBvc2l0aW9uIGluIHRoZSBzZXF1ZW5jZS4KCgpMaXN0IGNyZWF0aW9uIH4KCQkJCQkJCSpFNjk2KiAqRTY5NyoKQSBMaXN0IGlzIGNyZWF0ZWQgd2l0aCBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIGl0ZW1zIGluIHNxdWFyZSBicmFja2V0cy4KRXhhbXBsZXM6ID4KCTpsZXQgbXlsaXN0ID0gWzEsIHR3bywgMywgImZvdXIiXQoJOmxldCBlbXB0eWxpc3QgPSBbXQoKQW4gaXRlbSBjYW4gYmUgYW55IGV4cHJlc3Npb24uCVVzaW5nIGEgTGlzdCBmb3IgYW4gaXRlbSBjcmVhdGVzIGEKTGlzdCBvZiBMaXN0czogPgoJOmxldCBuZXN0bGlzdCA9IFtbMTEsIDEyXSwgWzIxLCAyMl0sIFszMSwgMzJdXQoKQW4gZXh0cmEgY29tbWEgYWZ0ZXIgdGhlIGxhc3QgaXRlbSBpcyBpZ25vcmVkLgoKCkxpc3QgaW5kZXggfgoJCQkJCQkJKmxpc3QtaW5kZXgqICpFNjg0KgpBbiBpdGVtIGluIHRoZSBMaXN0IGNhbiBiZSBhY2Nlc3NlZCBieSBwdXR0aW5nIHRoZSBpbmRleCBpbiBzcXVhcmUgYnJhY2tldHMKYWZ0ZXIgdGhlIExpc3QuICBJbmRleGVzIGFyZSB6ZXJvLWJhc2VkLCB0aHVzIHRoZSBmaXJzdCBpdGVtIGhhcyBpbmRleCB6ZXJvLiA+Cgk6bGV0IGl0ZW0gPSBteWxpc3RbMF0JCSIgZ2V0IHRoZSBmaXJzdCBpdGVtOiAxCgk6bGV0IGl0ZW0gPSBteWxpc3RbMl0JCSIgZ2V0IHRoZSB0aGlyZCBpdGVtOiAzCgpXaGVuIHRoZSByZXN1bHRpbmcgaXRlbSBpcyBhIGxpc3QgdGhpcyBjYW4gYmUgcmVwZWF0ZWQ6ID4KCTpsZXQgaXRlbSA9IG5lc3RsaXN0WzBdWzFdCSIgZ2V0IHRoZSBmaXJzdCBsaXN0LCBzZWNvbmQgaXRlbTogMTIKPApBIG5lZ2F0aXZlIGluZGV4IGlzIGNvdW50ZWQgZnJvbSB0aGUgZW5kLiAgSW5kZXggLTEgcmVmZXJzIHRvIHRoZSBsYXN0IGl0ZW0gaW4KdGhlIExpc3QsIC0yIHRvIHRoZSBsYXN0IGJ1dCBvbmUgaXRlbSwgZXRjLiA+Cgk6bGV0IGxhc3QgPSBteWxpc3RbLTFdCQkiIGdldCB0aGUgbGFzdCBpdGVtOiAiZm91ciIKClRvIGF2b2lkIGFuIGVycm9yIGZvciBhbiBpbnZhbGlkIGluZGV4IHVzZSB0aGUgfGdldCgpfCBmdW5jdGlvbi4gIFdoZW4gYW4gaXRlbQppcyBub3QgYXZhaWxhYmxlIGl0IHJldHVybnMgemVybyBvciB0aGUgZGVmYXVsdCB2YWx1ZSB5b3Ugc3BlY2lmeTogPgoJOmVjaG8gZ2V0KG15bGlzdCwgaWR4KQoJOmVjaG8gZ2V0KG15bGlzdCwgaWR4LCAiTk9ORSIpCgoKTGlzdCBjb25jYXRlbmF0aW9uIH4KClR3byBsaXN0cyBjYW4gYmUgY29uY2F0ZW5hdGVkIHdpdGggdGhlICIrIiBvcGVyYXRvcjogPgoJOmxldCBsb25nbGlzdCA9IG15bGlzdCArIFs1LCA2XQoJOmxldCBteWxpc3QgKz0gWzcsIDhdCgpUbyBwcmVwZW5kIG9yIGFwcGVuZCBhbiBpdGVtIHR1cm4gdGhlIGl0ZW0gaW50byBhIGxpc3QgYnkgcHV0dGluZyBbXSBhcm91bmQKaXQuICBUbyBjaGFuZ2UgYSBsaXN0IGluLXBsYWNlIHNlZSB8bGlzdC1tb2RpZmljYXRpb258IGJlbG93LgoKClN1Ymxpc3QgfgoKQSBwYXJ0IG9mIHRoZSBMaXN0IGNhbiBiZSBvYnRhaW5lZCBieSBzcGVjaWZ5aW5nIHRoZSBmaXJzdCBhbmQgbGFzdCBpbmRleCwKc2VwYXJhdGVkIGJ5IGEgY29sb24gaW4gc3F1YXJlIGJyYWNrZXRzOiA+Cgk6bGV0IHNob3J0bGlzdCA9IG15bGlzdFsyOi0xXQkiIGdldCBMaXN0IFszLCAiZm91ciJdCgpPbWl0dGluZyB0aGUgZmlyc3QgaW5kZXggaXMgc2ltaWxhciB0byB6ZXJvLiAgT21pdHRpbmcgdGhlIGxhc3QgaW5kZXggaXMKc2ltaWxhciB0byAtMS4gPgoJOmxldCBlbmRsaXN0ID0gbXlsaXN0WzI6XQkiIGZyb20gaXRlbSAyIHRvIHRoZSBlbmQ6IFszLCAiZm91ciJdCgk6bGV0IHNob3J0bGlzdCA9IG15bGlzdFsyOjJdCSIgTGlzdCB3aXRoIG9uZSBpdGVtOiBbM10KCTpsZXQgb3RoZXJsaXN0ID0gbXlsaXN0WzpdCSIgbWFrZSBhIGNvcHkgb2YgdGhlIExpc3QKCklmIHRoZSBmaXJzdCBpbmRleCBpcyBiZXlvbmQgdGhlIGxhc3QgaXRlbSBvZiB0aGUgTGlzdCBvciB0aGUgc2Vjb25kIGl0ZW0gaXMKYmVmb3JlIHRoZSBmaXJzdCBpdGVtLCB0aGUgcmVzdWx0IGlzIGFuIGVtcHR5IGxpc3QuICBUaGVyZSBpcyBubyBlcnJvcgptZXNzYWdlLgoKSWYgdGhlIHNlY29uZCBpbmRleCBpcyBlcXVhbCB0byBvciBncmVhdGVyIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUgbGlzdCB0aGUKbGVuZ3RoIG1pbnVzIG9uZSBpcyB1c2VkOiA+Cgk6bGV0IG15bGlzdCA9IFswLCAxLCAyLCAzXQoJOmVjaG8gbXlsaXN0WzI6OF0JCSIgcmVzdWx0OiBbMiwgM10KCk5PVEU6IG15bGlzdFtzOmVdIG1lYW5zIHVzaW5nIHRoZSB2YXJpYWJsZSAiczplIiBhcyBpbmRleC4gIFdhdGNoIG91dCBmb3IKdXNpbmcgYSBzaW5nbGUgbGV0dGVyIHZhcmlhYmxlIGJlZm9yZSB0aGUgIjoiLglJbnNlcnQgYSBzcGFjZSB3aGVuIG5lZWRlZDoKbXlsaXN0W3MgOiBlXS4KCgpMaXN0IGlkZW50aXR5IH4KCQkJCQkJCSpsaXN0LWlkZW50aXR5KgpXaGVuIHZhcmlhYmxlICJhYSIgaXMgYSBsaXN0IGFuZCB5b3UgYXNzaWduIGl0IHRvIGFub3RoZXIgdmFyaWFibGUgImJiIiwgYm90aAp2YXJpYWJsZXMgcmVmZXIgdG8gdGhlIHNhbWUgbGlzdC4gIFRodXMgY2hhbmdpbmcgdGhlIGxpc3QgImFhIiB3aWxsIGFsc28KY2hhbmdlICJiYiI6ID4KCTpsZXQgYWEgPSBbMSwgMiwgM10KCTpsZXQgYmIgPSBhYQoJOmNhbGwgYWRkKGFhLCA0KQoJOmVjaG8gYmIKPAlbMSwgMiwgMywgNF0KCk1ha2luZyBhIGNvcHkgb2YgYSBsaXN0IGlzIGRvbmUgd2l0aCB0aGUgfGNvcHkoKXwgZnVuY3Rpb24uICBVc2luZyBbOl0gYWxzbwp3b3JrcywgYXMgZXhwbGFpbmVkIGFib3ZlLiAgVGhpcyBjcmVhdGVzIGEgc2hhbGxvdyBjb3B5IG9mIHRoZSBsaXN0OiBDaGFuZ2luZwphIGxpc3QgaXRlbSBpbiB0aGUgbGlzdCB3aWxsIGFsc28gY2hhbmdlIHRoZSBpdGVtIGluIHRoZSBjb3BpZWQgbGlzdDogPgoJOmxldCBhYSA9IFtbMSwgJ2EnXSwgMiwgM10KCTpsZXQgYmIgPSBjb3B5KGFhKQoJOmNhbGwgYWRkKGFhLCA0KQoJOmxldCBhYVswXVsxXSA9ICdhYWEnCgk6ZWNobyBhYQo8CVtbMSwgYWFhXSwgMiwgMywgNF0gPgoJOmVjaG8gYmIKPAlbWzEsIGFhYV0sIDIsIDNdCgpUbyBtYWtlIGEgY29tcGxldGVseSBpbmRlcGVuZGVudCBsaXN0IHVzZSB8ZGVlcGNvcHkoKXwuICBUaGlzIGFsc28gbWFrZXMgYQpjb3B5IG9mIHRoZSB2YWx1ZXMgaW4gdGhlIGxpc3QsIHJlY3Vyc2l2ZWx5LiAgVXAgdG8gYSBodW5kcmVkIGxldmVscyBkZWVwLgoKVGhlIG9wZXJhdG9yICJpcyIgY2FuIGJlIHVzZWQgdG8gY2hlY2sgaWYgdHdvIHZhcmlhYmxlcyByZWZlciB0byB0aGUgc2FtZQpMaXN0LiAgImlzbm90IiBkb2VzIHRoZSBvcHBvc2l0ZS4gIEluIGNvbnRyYXN0ICI9PSIgY29tcGFyZXMgaWYgdHdvIGxpc3RzIGhhdmUKdGhlIHNhbWUgdmFsdWUuID4KCTpsZXQgYWxpc3QgPSBbMSwgMiwgM10KCTpsZXQgYmxpc3QgPSBbMSwgMiwgM10KCTplY2hvIGFsaXN0IGlzIGJsaXN0CjwJMCA+Cgk6ZWNobyBhbGlzdCA9PSBibGlzdAo8CTEKCk5vdGUgYWJvdXQgY29tcGFyaW5nIGxpc3RzOiBUd28gbGlzdHMgYXJlIGNvbnNpZGVyZWQgZXF1YWwgaWYgdGhleSBoYXZlIHRoZQpzYW1lIGxlbmd0aCBhbmQgYWxsIGl0ZW1zIGNvbXBhcmUgZXF1YWwsIGFzIHdpdGggdXNpbmcgIj09Ii4gIFRoZXJlIGlzIG9uZQpleGNlcHRpb246IFdoZW4gY29tcGFyaW5nIGEgbnVtYmVyIHdpdGggYSBzdHJpbmcgdGhleSBhcmUgY29uc2lkZXJlZApkaWZmZXJlbnQuICBUaGVyZSBpcyBubyBhdXRvbWF0aWMgdHlwZSBjb252ZXJzaW9uLCBhcyB3aXRoIHVzaW5nICI9PSIgb24KdmFyaWFibGVzLiAgRXhhbXBsZTogPgoJZWNobyA0ID09ICI0Igo8CTEgPgoJZWNobyBbNF0gPT0gWyI0Il0KPAkwCgpUaHVzIGNvbXBhcmluZyBMaXN0cyBpcyBtb3JlIHN0cmljdCB0aGFuIGNvbXBhcmluZyBudW1iZXJzIGFuZCBzdHJpbmdzLiAgWW91CmNhbiBjb21wYXJlIHNpbXBsZSB2YWx1ZXMgdGhpcyB3YXkgdG9vIGJ5IHB1dHRpbmcgdGhlbSBpbiBhIGxpc3Q6ID4KCgk6bGV0IGEgPSA1Cgk6bGV0IGIgPSAiNSIKCTplY2hvIGEgPT0gYgo8CTEgPgoJOmVjaG8gW2FdID09IFtiXQo8CTAKCgpMaXN0IHVucGFjayB+CgpUbyB1bnBhY2sgdGhlIGl0ZW1zIGluIGEgbGlzdCB0byBpbmRpdmlkdWFsIHZhcmlhYmxlcywgcHV0IHRoZSB2YXJpYWJsZXMgaW4Kc3F1YXJlIGJyYWNrZXRzLCBsaWtlIGxpc3QgaXRlbXM6ID4KCTpsZXQgW3ZhcjEsIHZhcjJdID0gbXlsaXN0CgpXaGVuIHRoZSBudW1iZXIgb2YgdmFyaWFibGVzIGRvZXMgbm90IG1hdGNoIHRoZSBudW1iZXIgb2YgaXRlbXMgaW4gdGhlIGxpc3QKdGhpcyBwcm9kdWNlcyBhbiBlcnJvci4gIFRvIGhhbmRsZSBhbnkgZXh0cmEgaXRlbXMgZnJvbSB0aGUgbGlzdCBhcHBlbmQgIjsiCmFuZCBhIHZhcmlhYmxlIG5hbWU6ID4KCTpsZXQgW3ZhcjEsIHZhcjI7IHJlc3RdID0gbXlsaXN0CgpUaGlzIHdvcmtzIGxpa2U6ID4KCTpsZXQgdmFyMSA9IG15bGlzdFswXQoJOmxldCB2YXIyID0gbXlsaXN0WzFdCgk6bGV0IHJlc3QgPSBteWxpc3RbMjpdCgpFeGNlcHQgdGhhdCB0aGVyZSBpcyBubyBlcnJvciBpZiB0aGVyZSBhcmUgb25seSB0d28gaXRlbXMuICAicmVzdCIgd2lsbCBiZSBhbgplbXB0eSBsaXN0IHRoZW4uCgoKTGlzdCBtb2RpZmljYXRpb24gfgoJCQkJCQkJKmxpc3QtbW9kaWZpY2F0aW9uKgpUbyBjaGFuZ2UgYSBzcGVjaWZpYyBpdGVtIG9mIGEgbGlzdCB1c2UgfDpsZXR8IHRoaXMgd2F5OiA+Cgk6bGV0IGxpc3RbNF0gPSAiZm91ciIKCTpsZXQgbGlzdGxpc3RbMF1bM10gPSBpdGVtCgpUbyBjaGFuZ2UgcGFydCBvZiBhIGxpc3QgeW91IGNhbiBzcGVjaWZ5IHRoZSBmaXJzdCBhbmQgbGFzdCBpdGVtIHRvIGJlCm1vZGlmaWVkLiAgVGhlIHZhbHVlIG11c3QgYXQgbGVhc3QgaGF2ZSB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSByYW5nZTogPgoJOmxldCBsaXN0WzM6NV0gPSBbMywgNCwgNV0KCkFkZGluZyBhbmQgcmVtb3ZpbmcgaXRlbXMgZnJvbSBhIGxpc3QgaXMgZG9uZSB3aXRoIGZ1bmN0aW9ucy4gIEhlcmUgYXJlIGEgZmV3CmV4YW1wbGVzOiA+Cgk6Y2FsbCBpbnNlcnQobGlzdCwgJ2EnKQkJIiBwcmVwZW5kIGl0ZW0gJ2EnCgk6Y2FsbCBpbnNlcnQobGlzdCwgJ2EnLCAzKQkiIGluc2VydCBpdGVtICdhJyBiZWZvcmUgbGlzdFszXQoJOmNhbGwgYWRkKGxpc3QsICJuZXciKQkJIiBhcHBlbmQgU3RyaW5nIGl0ZW0KCTpjYWxsIGFkZChsaXN0LCBbMSwgMl0pCQkiIGFwcGVuZCBhIExpc3QgYXMgb25lIG5ldyBpdGVtCgk6Y2FsbCBleHRlbmQobGlzdCwgWzEsIDJdKQkiIGV4dGVuZCB0aGUgbGlzdCB3aXRoIHR3byBtb3JlIGl0ZW1zCgk6bGV0IGkgPSByZW1vdmUobGlzdCwgMykJIiByZW1vdmUgaXRlbSAzCgk6dW5sZXQgbGlzdFszXQkJCSIgaWRlbQoJOmxldCBsID0gcmVtb3ZlKGxpc3QsIDMsIC0xKQkiIHJlbW92ZSBpdGVtcyAzIHRvIGxhc3QgaXRlbQoJOnVubGV0IGxpc3RbMyA6IF0JCSIgaWRlbQoJOmNhbGwgZmlsdGVyKGxpc3QsICd2OnZhbCAhfiAieCInKSAgIiByZW1vdmUgaXRlbXMgd2l0aCBhbiAneCcKCkNoYW5naW5nIHRoZSBvcmRlciBvZiBpdGVtcyBpbiBhIGxpc3Q6ID4KCTpjYWxsIHNvcnQobGlzdCkJCSIgc29ydCBhIGxpc3QgYWxwaGFiZXRpY2FsbHkKCTpjYWxsIHJldmVyc2UobGlzdCkJCSIgcmV2ZXJzZSB0aGUgb3JkZXIgb2YgaXRlbXMKCgpGb3IgbG9vcCB+CgpUaGUgfDpmb3J8IGxvb3AgZXhlY3V0ZXMgY29tbWFuZHMgZm9yIGVhY2ggaXRlbSBpbiBhIGxpc3QuICBBIHZhcmlhYmxlIGlzIHNldAp0byBlYWNoIGl0ZW0gaW4gdGhlIGxpc3QgaW4gc2VxdWVuY2UuICBFeGFtcGxlOiA+Cgk6Zm9yIGl0ZW0gaW4gbXlsaXN0Cgk6ICAgY2FsbCBEb2l0KGl0ZW0pCgk6ZW5kZm9yCgpUaGlzIHdvcmtzIGxpa2U6ID4KCTpsZXQgaW5kZXggPSAwCgk6d2hpbGUgaW5kZXggPCBsZW4obXlsaXN0KQoJOiAgIGxldCBpdGVtID0gbXlsaXN0W2luZGV4XQoJOiAgIDpjYWxsIERvaXQoaXRlbSkKCTogICBsZXQgaW5kZXggPSBpbmRleCArIDEKCTplbmR3aGlsZQoKTm90ZSB0aGF0IGFsbCBpdGVtcyBpbiB0aGUgbGlzdCBzaG91bGQgYmUgb2YgdGhlIHNhbWUgdHlwZSwgb3RoZXJ3aXNlIHRoaXMKcmVzdWx0cyBpbiBlcnJvciB8RTcwNnwuICBUbyBhdm9pZCB0aGlzIHw6dW5sZXR8IHRoZSB2YXJpYWJsZSBhdCB0aGUgZW5kIG9mCnRoZSBsb29wLgoKSWYgYWxsIHlvdSB3YW50IHRvIGRvIGlzIG1vZGlmeSBlYWNoIGl0ZW0gaW4gdGhlIGxpc3QgdGhlbiB0aGUgfG1hcCgpfApmdW5jdGlvbiB3aWxsIGJlIGEgc2ltcGxlciBtZXRob2QgdGhhbiBhIGZvciBsb29wLgoKSnVzdCBsaWtlIHRoZSB8OmxldHwgY29tbWFuZCwgfDpmb3J8IGFsc28gYWNjZXB0cyBhIGxpc3Qgb2YgdmFyaWFibGVzLglUaGlzCnJlcXVpcmVzIHRoZSBhcmd1bWVudCB0byBiZSBhIGxpc3Qgb2YgbGlzdHMuID4KCTpmb3IgW2xudW0sIGNvbF0gaW4gW1sxLCAzXSwgWzIsIDhdLCBbMywgMF1dCgk6ICAgY2FsbCBEb2l0KGxudW0sIGNvbCkKCTplbmRmb3IKClRoaXMgd29ya3MgbGlrZSBhIHw6bGV0fCBjb21tYW5kIGlzIGRvbmUgZm9yIGVhY2ggbGlzdCBpdGVtLiAgQWdhaW4sIHRoZSB0eXBlcwptdXN0IHJlbWFpbiB0aGUgc2FtZSB0byBhdm9pZCBhbiBlcnJvci4KCkl0IGlzIGFsc28gcG9zc2libGUgdG8gcHV0IHJlbWFpbmluZyBpdGVtcyBpbiBhIExpc3QgdmFyaWFibGU6ID4KCTpmb3IgW2ksIGo7IHJlc3RdIGluIGxpc3RsaXN0Cgk6ICAgY2FsbCBEb2l0KGksIGopCgk6ICAgaWYgIWVtcHR5KHJlc3QpCgk6ICAgICAgZWNobyAicmVtYWluZGVyOiAiIC4gc3RyaW5nKHJlc3QpCgk6ICAgZW5kaWYKCTplbmRmb3IKCgpMaXN0IGZ1bmN0aW9ucyB+CgkJCQkJCSpFNzE0KgpGdW5jdGlvbnMgdGhhdCBhcmUgdXNlZnVsIHdpdGggYSBMaXN0OiA+Cgk6bGV0IHIgPSBjYWxsKGZ1bmNuYW1lLCBsaXN0KQkiIGNhbGwgYSBmdW5jdGlvbiB3aXRoIGFuIGFyZ3VtZW50IGxpc3QKCTppZiBlbXB0eShsaXN0KQkJCSIgY2hlY2sgaWYgbGlzdCBpcyBlbXB0eQoJOmxldCBsID0gbGVuKGxpc3QpCQkiIG51bWJlciBvZiBpdGVtcyBpbiBsaXN0Cgk6bGV0IGJpZyA9IG1heChsaXN0KQkJIiBtYXhpbXVtIHZhbHVlIGluIGxpc3QKCTpsZXQgc21hbGwgPSBtaW4obGlzdCkJCSIgbWluaW11bSB2YWx1ZSBpbiBsaXN0Cgk6bGV0IHhzID0gY291bnQobGlzdCwgJ3gnKQkiIGNvdW50IG5yIG9mIHRpbWVzICd4JyBhcHBlYXJzIGluIGxpc3QKCTpsZXQgaSA9IGluZGV4KGxpc3QsICd4JykJIiBpbmRleCBvZiBmaXJzdCAneCcgaW4gbGlzdAoJOmxldCBsaW5lcyA9IGdldGxpbmUoMSwgMTApCSIgZ2V0IHRlbiB0ZXh0IGxpbmVzIGZyb20gYnVmZmVyCgk6Y2FsbCBhcHBlbmQoJyQnLCBsaW5lcykJIiBhcHBlbmQgdGV4dCBsaW5lcyBpbiBidWZmZXIKCTpsZXQgbGlzdCA9IHNwbGl0KCJhIGIgYyIpCSIgY3JlYXRlIGxpc3QgZnJvbSBpdGVtcyBpbiBhIHN0cmluZwoJOmxldCBzdHJpbmcgPSBqb2luKGxpc3QsICcsICcpCSIgY3JlYXRlIHN0cmluZyBmcm9tIGxpc3QgaXRlbXMKCTpsZXQgcyA9IHN0cmluZyhsaXN0KQkJIiBTdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgbGlzdAoJOmNhbGwgbWFwKGxpc3QsICciPj4gIiAuIHY6dmFsJykgICIgcHJlcGVuZCAiPj4gIiB0byBlYWNoIGl0ZW0KCkRvbid0IGZvcmdldCB0aGF0IGEgY29tYmluYXRpb24gb2YgZmVhdHVyZXMgY2FuIG1ha2UgdGhpbmdzIHNpbXBsZS4gIEZvcgpleGFtcGxlLCB0byBhZGQgdXAgYWxsIHRoZSBudW1iZXJzIGluIGEgbGlzdDogPgoJOmV4ZSAnbGV0IHN1bSA9ICcgLiBqb2luKG5ybGlzdCwgJysnKQoKCjEuNCBEaWN0aW9uYXJpZXMgfgoJCQkJCQkqRGljdGlvbmFyaWVzKiAqRGljdGlvbmFyeSoKQSBEaWN0aW9uYXJ5IGlzIGFuIGFzc29jaWF0aXZlIGFycmF5OiBFYWNoIGVudHJ5IGhhcyBhIGtleSBhbmQgYSB2YWx1ZS4gIFRoZQplbnRyeSBjYW4gYmUgbG9jYXRlZCB3aXRoIHRoZSBrZXkuICBUaGUgZW50cmllcyBhcmUgc3RvcmVkIHdpdGhvdXQgYSBzcGVjaWZpYwpvcmRlcmluZy4KCgpEaWN0aW9uYXJ5IGNyZWF0aW9uIH4KCQkJCQkJKkU3MjAqICpFNzIxKiAqRTcyMiogKkU3MjMqCkEgRGljdGlvbmFyeSBpcyBjcmVhdGVkIHdpdGggYSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiBlbnRyaWVzIGluIGN1cmx5CmJyYWNlcy4gIEVhY2ggZW50cnkgaGFzIGEga2V5IGFuZCBhIHZhbHVlLCBzZXBhcmF0ZWQgYnkgYSBjb2xvbi4gIEVhY2gga2V5IGNhbgpvbmx5IGFwcGVhciBvbmNlLiAgRXhhbXBsZXM6ID4KCTpsZXQgbXlkaWN0ID0gezE6ICdvbmUnLCAyOiAndHdvJywgMzogJ3RocmVlJ30KCTpsZXQgZW1wdHlkaWN0ID0ge30KPAkJCQkJCQkqRTcxMyogKkU3MTYqICpFNzE3KgpBIGtleSBpcyBhbHdheXMgYSBTdHJpbmcuICBZb3UgY2FuIHVzZSBhIE51bWJlciwgaXQgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYQpTdHJpbmcgYXV0b21hdGljYWxseS4gIFRodXMgdGhlIFN0cmluZyAnNCcgYW5kIHRoZSBudW1iZXIgNCB3aWxsIGZpbmQgdGhlIHNhbWUKZW50cnkuCU5vdGUgdGhhdCB0aGUgU3RyaW5nICcwNCcgYW5kIHRoZSBOdW1iZXIgMDQgYXJlIGRpZmZlcmVudCwgc2luY2UgdGhlCk51bWJlciB3aWxsIGJlIGNvbnZlcnRlZCB0byB0aGUgU3RyaW5nICc0Jy4KCkEgdmFsdWUgY2FuIGJlIGFueSBleHByZXNzaW9uLglVc2luZyBhIERpY3Rpb25hcnkgZm9yIGEgdmFsdWUgY3JlYXRlcyBhCm5lc3RlZCBEaWN0aW9uYXJ5OiA+Cgk6bGV0IG5lc3RkaWN0ID0gezE6IHsxMTogJ2EnLCAxMjogJ2InfSwgMjogezIxOiAnYyd9fQoKQW4gZXh0cmEgY29tbWEgYWZ0ZXIgdGhlIGxhc3QgZW50cnkgaXMgaWdub3JlZC4KCgpBY2Nlc3NpbmcgZW50cmllcyB+CgpUaGUgbm9ybWFsIHdheSB0byBhY2Nlc3MgYW4gZW50cnkgaXMgYnkgcHV0dGluZyB0aGUga2V5IGluIHNxdWFyZSBicmFja2V0czogPgoJOmxldCB2YWwgPSBteWRpY3RbIm9uZSJdCgk6bGV0IG15ZGljdFsiZm91ciJdID0gNAoKWW91IGNhbiBhZGQgbmV3IGVudHJpZXMgdG8gYW4gZXhpc3RpbmcgRGljdGlvbmFyeSB0aGlzIHdheSwgdW5saWtlIExpc3RzLgoKRm9yIGtleXMgdGhhdCBjb25zaXN0IGVudGlyZWx5IG9mIGxldHRlcnMsIGRpZ2l0cyBhbmQgdW5kZXJzY29yZSB0aGUgZm9sbG93aW5nCmZvcm0gY2FuIGJlIHVzZWQgfGV4cHItZW50cnl8OiA+Cgk6bGV0IHZhbCA9IG15ZGljdC5vbmUKCTpsZXQgbXlkaWN0LmZvdXIgPSA0CgpTaW5jZSBhbiBlbnRyeSBjYW4gYmUgYW55IHR5cGUsIGFsc28gYSBMaXN0IGFuZCBhIERpY3Rpb25hcnksIHRoZSBpbmRleGluZyBhbmQKa2V5IGxvb2t1cCBjYW4gYmUgcmVwZWF0ZWQ6ID4KCTplY2hvIGRpY3Qua2V5W2lkeF0ua2V5CgoKRGljdGlvbmFyeSB0byBMaXN0IGNvbnZlcnNpb24gfgoKWW91IG1heSB3YW50IHRvIGxvb3Agb3ZlciB0aGUgZW50cmllcyBpbiBhIGRpY3Rpb25hcnkuCUZvciB0aGlzIHlvdSBuZWVkIHRvCnR1cm4gdGhlIERpY3Rpb25hcnkgaW50byBhIExpc3QgYW5kIHBhc3MgaXQgdG8gfDpmb3J8LgoKTW9zdCBvZnRlbiB5b3Ugd2FudCB0byBsb29wIG92ZXIgdGhlIGtleXMsIHVzaW5nIHRoZSB8a2V5cygpfCBmdW5jdGlvbjogPgoJOmZvciBrZXkgaW4ga2V5cyhteWRpY3QpCgk6ICAgZWNobyBrZXkgLiAnOiAnIC4gbXlkaWN0W2tleV0KCTplbmRmb3IKClRoZSBMaXN0IG9mIGtleXMgaXMgdW5zb3J0ZWQuICBZb3UgbWF5IHdhbnQgdG8gc29ydCB0aGVtIGZpcnN0OiA+Cgk6Zm9yIGtleSBpbiBzb3J0KGtleXMobXlkaWN0KSkKClRvIGxvb3Agb3ZlciB0aGUgdmFsdWVzIHVzZSB0aGUgfHZhbHVlcygpfCBmdW5jdGlvbjogID4KCTpmb3IgdiBpbiB2YWx1ZXMobXlkaWN0KQoJOiAgIGVjaG8gInZhbHVlOiAiIC4gdgoJOmVuZGZvcgoKSWYgeW91IHdhbnQgYm90aCB0aGUga2V5IGFuZCB0aGUgdmFsdWUgdXNlIHRoZSB8aXRlbXMoKXwgZnVuY3Rpb24uICBJdCByZXR1cm5zCmEgTGlzdCBpbiB3aGljaCBlYWNoIGl0ZW0gaXMgYQlMaXN0IHdpdGggdHdvIGl0ZW1zLCB0aGUga2V5IGFuZCB0aGUgdmFsdWU6ID4KCTpmb3IgW2tleSwgdmFsdWVdIGluIGl0ZW1zKG15ZGljdCkKCTogICBlY2hvIGtleSAuICc6ICcgLiB2YWx1ZQoJOmVuZGZvcgoKCkRpY3Rpb25hcnkgaWRlbnRpdHkgfgoJCQkJCQkJKmRpY3QtaWRlbnRpdHkqCkp1c3QgbGlrZSBMaXN0cyB5b3UgbmVlZCB0byB1c2UgfGNvcHkoKXwgYW5kIHxkZWVwY29weSgpfCB0byBtYWtlIGEgY29weSBvZiBhCkRpY3Rpb25hcnkuICBPdGhlcndpc2UsIGFzc2lnbm1lbnQgcmVzdWx0cyBpbiByZWZlcnJpbmcgdG8gdGhlIHNhbWUKRGljdGlvbmFyeTogPgoJOmxldCBvbmVkaWN0ID0geydhJzogMSwgJ2InOiAyfQoJOmxldCBhZGljdCA9IG9uZWRpY3QKCTpsZXQgYWRpY3RbJ2EnXSA9IDExCgk6ZWNobyBvbmVkaWN0WydhJ10KCTExCgpUd28gRGljdGlvbmFyaWVzIGNvbXBhcmUgZXF1YWwgaWYgYWxsIHRoZSBrZXktdmFsdWUgcGFpcnMgY29tcGFyZSBlcXVhbC4gIEZvcgptb3JlIGluZm8gc2VlIHxsaXN0LWlkZW50aXR5fC4KCgpEaWN0aW9uYXJ5IG1vZGlmaWNhdGlvbiB+CgkJCQkJCQkqZGljdC1tb2RpZmljYXRpb24qClRvIGNoYW5nZSBhbiBhbHJlYWR5IGV4aXN0aW5nIGVudHJ5IG9mIGEgRGljdGlvbmFyeSwgb3IgdG8gYWRkIGEgbmV3IGVudHJ5LAp1c2UgfDpsZXR8IHRoaXMgd2F5OiA+Cgk6bGV0IGRpY3RbNF0gPSAiZm91ciIKCTpsZXQgZGljdFsnb25lJ10gPSBpdGVtCgpSZW1vdmluZyBhbiBlbnRyeSBmcm9tIGEgRGljdGlvbmFyeSBpcyBkb25lIHdpdGggfHJlbW92ZSgpfCBvciB8OnVubGV0fC4KVGhyZWUgd2F5cyB0byByZW1vdmUgdGhlIGVudHJ5IHdpdGgga2V5ICJhYWEiIGZyb20gZGljdDogPgoJOmxldCBpID0gcmVtb3ZlKGRpY3QsICdhYWEnKQoJOnVubGV0IGRpY3QuYWFhCgk6dW5sZXQgZGljdFsnYWFhJ10KCk1lcmdpbmcgYSBEaWN0aW9uYXJ5IHdpdGggYW5vdGhlciBpcyBkb25lIHdpdGggfGV4dGVuZCgpfDogPgoJOmNhbGwgZXh0ZW5kKGFkaWN0LCBiZGljdCkKVGhpcyBleHRlbmRzIGFkaWN0IHdpdGggYWxsIGVudHJpZXMgZnJvbSBiZGljdC4gIER1cGxpY2F0ZSBrZXlzIGNhdXNlIGVudHJpZXMKaW4gYWRpY3QgdG8gYmUgb3ZlcndyaXR0ZW4uICBBbiBvcHRpb25hbCB0aGlyZCBhcmd1bWVudCBjYW4gY2hhbmdlIHRoaXMuCk5vdGUgdGhhdCB0aGUgb3JkZXIgb2YgZW50cmllcyBpbiBhIERpY3Rpb25hcnkgaXMgaXJyZWxldmFudCwgdGh1cyBkb24ndApleHBlY3QgIjplY2hvIGFkaWN0IiB0byBzaG93IHRoZSBpdGVtcyBmcm9tIGJkaWN0IGFmdGVyIHRoZSBvbGRlciBlbnRyaWVzIGluCmFkaWN0LgoKV2VlZGluZyBvdXQgZW50cmllcyBmcm9tIGEgRGljdGlvbmFyeSBjYW4gYmUgZG9uZSB3aXRoIHxmaWx0ZXIoKXw6ID4KCTpjYWxsIGZpbHRlcihkaWN0LCAndjp2YWwgPX4gIngiJykKVGhpcyByZW1vdmVzIGFsbCBlbnRyaWVzIGZyb20gImRpY3QiIHdpdGggYSB2YWx1ZSBub3QgbWF0Y2hpbmcgJ3gnLgoKCkRpY3Rpb25hcnkgZnVuY3Rpb24gfgoJCQkJCSpEaWN0aW9uYXJ5LWZ1bmN0aW9uKiAqc2VsZiogKkU3MjUqCldoZW4gYSBmdW5jdGlvbiBpcyBkZWZpbmVkIHdpdGggdGhlICJkaWN0IiBhdHRyaWJ1dGUgaXQgY2FuIGJlIHVzZWQgaW4gYQpzcGVjaWFsIHdheSB3aXRoIGEgZGljdGlvbmFyeS4JRXhhbXBsZTogPgoJOmZ1bmN0aW9uIE15bGVuKCkgZGljdAoJOiAgIHJldHVybiBsZW4oc2VsZi5kYXRhKQoJOmVuZGZ1bmN0aW9uCgk6bGV0IG15ZGljdCA9IHsnZGF0YSc6IFswLCAxLCAyLCAzXSwgJ2xlbic6IGZ1bmN0aW9uKCJNeWxlbiIpfQoJOmVjaG8gbXlkaWN0LmxlbigpCgpUaGlzIGlzIGxpa2UgYSBtZXRob2QgaW4gb2JqZWN0IG9yaWVudGVkIHByb2dyYW1taW5nLiAgVGhlIGVudHJ5IGluIHRoZQpEaWN0aW9uYXJ5IGlzIGEgfEZ1bmNyZWZ8LiAgVGhlIGxvY2FsIHZhcmlhYmxlICJzZWxmIiByZWZlcnMgdG8gdGhlIGRpY3Rpb25hcnkKdGhlIGZ1bmN0aW9uIHdhcyBpbnZva2VkIGZyb20uCgpJdCBpcyBhbHNvIHBvc3NpYmxlIHRvIGFkZCBhIGZ1bmN0aW9uIHdpdGhvdXQgdGhlICJkaWN0IiBhdHRyaWJ1dGUgYXMgYQpGdW5jcmVmIHRvIGEgRGljdGlvbmFyeSwgYnV0IHRoZSAic2VsZiIgdmFyaWFibGUgaXMgbm90IGF2YWlsYWJsZSB0aGVuLgoKCQkJCSpudW1iZXJlZC1mdW5jdGlvbiogKmFub255bW91cy1mdW5jdGlvbioKVG8gYXZvaWQgdGhlIGV4dHJhIG5hbWUgZm9yIHRoZSBmdW5jdGlvbiBpdCBjYW4gYmUgZGVmaW5lZCBhbmQgZGlyZWN0bHkKYXNzaWduZWQgdG8gYSBEaWN0aW9uYXJ5IGluIHRoaXMgd2F5OiA+Cgk6bGV0IG15ZGljdCA9IHsnZGF0YSc6IFswLCAxLCAyLCAzXX0KCTpmdW5jdGlvbiBteWRpY3QubGVuKCkgZGljdAoJOiAgIHJldHVybiBsZW4oc2VsZi5kYXRhKQoJOmVuZGZ1bmN0aW9uCgk6ZWNobyBteWRpY3QubGVuKCkKClRoZSBmdW5jdGlvbiB3aWxsIHRoZW4gZ2V0IGEgbnVtYmVyIGFuZCB0aGUgdmFsdWUgb2YgZGljdC5sZW4gaXMgYSB8RnVuY3JlZnwKdGhhdCByZWZlcmVuY2VzIHRoaXMgZnVuY3Rpb24uCVRoZSBmdW5jdGlvbiBjYW4gb25seSBiZSB1c2VkIHRocm91Z2ggYQp8RnVuY3JlZnwuICBJdCB3aWxsIGF1dG9tYXRpY2FsbHkgYmUgZGVsZXRlZCB3aGVuIHRoZXJlIGlzIG5vIHxGdW5jcmVmfApyZW1haW5pbmcgdGhhdCByZWZlcnMgdG8gaXQuCgpJdCBpcyBub3QgbmVjZXNzYXJ5IHRvIHVzZSB0aGUgImRpY3QiIGF0dHJpYnV0ZSBmb3IgYSBudW1iZXJlZCBmdW5jdGlvbi4KCklmIHlvdSBnZXQgYW4gZXJyb3IgZm9yIGEgbnVtYmVyZWQgZnVuY3Rpb24sIHlvdSBjYW4gZmluZCBvdXQgd2hhdCBpdCBpcyB3aXRoCmEgdHJpY2suICBBc3N1bWluZyB0aGUgZnVuY3Rpb24gaXMgNDIsIHRoZSBjb21tYW5kIGlzOiA+Cgk6ZnVuY3Rpb24gezQyfQoKCkZ1bmN0aW9ucyBmb3IgRGljdGlvbmFyaWVzIH4KCQkJCQkJCSpFNzE1KgpGdW5jdGlvbnMgdGhhdCBjYW4gYmUgdXNlZCB3aXRoIGEgRGljdGlvbmFyeTogPgoJOmlmIGhhc19rZXkoZGljdCwgJ2ZvbycpCSIgVFJVRSBpZiBkaWN0IGhhcyBlbnRyeSB3aXRoIGtleSAiZm9vIgoJOmlmIGVtcHR5KGRpY3QpCQkJIiBUUlVFIGlmIGRpY3QgaXMgZW1wdHkKCTpsZXQgbCA9IGxlbihkaWN0KQkJIiBudW1iZXIgb2YgaXRlbXMgaW4gZGljdAoJOmxldCBiaWcgPSBtYXgoZGljdCkJCSIgbWF4aW11bSB2YWx1ZSBpbiBkaWN0Cgk6bGV0IHNtYWxsID0gbWluKGRpY3QpCQkiIG1pbmltdW0gdmFsdWUgaW4gZGljdAoJOmxldCB4cyA9IGNvdW50KGRpY3QsICd4JykJIiBjb3VudCBuciBvZiB0aW1lcyAneCcgYXBwZWFycyBpbiBkaWN0Cgk6bGV0IHMgPSBzdHJpbmcoZGljdCkJCSIgU3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIGRpY3QKCTpjYWxsIG1hcChkaWN0LCAnIj4+ICIgLiB2OnZhbCcpICAiIHByZXBlbmQgIj4+ICIgdG8gZWFjaCBpdGVtCgoKMS41IE1vcmUgYWJvdXQgdmFyaWFibGVzIH4KCQkJCQkJCSptb3JlLXZhcmlhYmxlcyoKSWYgeW91IG5lZWQgdG8ga25vdyB0aGUgdHlwZSBvZiBhIHZhcmlhYmxlIG9yIGV4cHJlc3Npb24sIHVzZSB0aGUgfHR5cGUoKXwKZnVuY3Rpb24uCgpXaGVuIHRoZSAnIScgZmxhZyBpcyBpbmNsdWRlZCBpbiB0aGUgJ3ZpbWluZm8nIG9wdGlvbiwgZ2xvYmFsIHZhcmlhYmxlcyB0aGF0CnN0YXJ0IHdpdGggYW4gdXBwZXJjYXNlIGxldHRlciwgYW5kIGRvbid0IGNvbnRhaW4gYSBsb3dlcmNhc2UgbGV0dGVyLCBhcmUKc3RvcmVkIGluIHRoZSB2aW1pbmZvIGZpbGUgfHZpbWluZm8tZmlsZXwuCgpXaGVuIHRoZSAnc2Vzc2lvbm9wdGlvbnMnIG9wdGlvbiBjb250YWlucyAiZ2xvYmFsIiwgZ2xvYmFsIHZhcmlhYmxlcyB0aGF0CnN0YXJ0IHdpdGggYW4gdXBwZXJjYXNlIGxldHRlciBhbmQgY29udGFpbiBhdCBsZWFzdCBvbmUgbG93ZXJjYXNlIGxldHRlciBhcmUKc3RvcmVkIGluIHRoZSBzZXNzaW9uIGZpbGUgfHNlc3Npb24tZmlsZXwuCgp2YXJpYWJsZSBuYW1lCQljYW4gYmUgc3RvcmVkIHdoZXJlIH4KbXlfdmFyXzYJCW5vdApNeV9WYXJfNgkJc2Vzc2lvbiBmaWxlCk1ZX1ZBUl82CQl2aW1pbmZvIGZpbGUKCgpJdCdzIHBvc3NpYmxlIHRvIGZvcm0gYSB2YXJpYWJsZSBuYW1lIHdpdGggY3VybHkgYnJhY2VzLCBzZWUKfGN1cmx5LWJyYWNlcy1uYW1lc3wuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMi4gRXhwcmVzc2lvbiBzeW50YXgJCQkJCSpleHByZXNzaW9uLXN5bnRheCoKCkV4cHJlc3Npb24gc3ludGF4IHN1bW1hcnksIGZyb20gbGVhc3QgdG8gbW9zdCBzaWduaWZpY2FudDoKCnxleHByMXwgZXhwcjIgPyBleHByMSA6IGV4cHIxCWlmLXRoZW4tZWxzZQoKfGV4cHIyfAlleHByMyB8fCBleHByMyAuLglsb2dpY2FsIE9SCgp8ZXhwcjN8CWV4cHI0ICYmIGV4cHI0IC4uCWxvZ2ljYWwgQU5ECgp8ZXhwcjR8CWV4cHI1ID09IGV4cHI1CQllcXVhbAoJZXhwcjUgIT0gZXhwcjUJCW5vdCBlcXVhbAoJZXhwcjUgPgkgZXhwcjUJCWdyZWF0ZXIgdGhhbgoJZXhwcjUgPj0gZXhwcjUJCWdyZWF0ZXIgdGhhbiBvciBlcXVhbAoJZXhwcjUgPAkgZXhwcjUJCXNtYWxsZXIgdGhhbgoJZXhwcjUgPD0gZXhwcjUJCXNtYWxsZXIgdGhhbiBvciBlcXVhbAoJZXhwcjUgPX4gZXhwcjUJCXJlZ2V4cCBtYXRjaGVzCglleHByNSAhfiBleHByNQkJcmVnZXhwIGRvZXNuJ3QgbWF0Y2gKCglleHByNSA9PT8gZXhwcjUJCWVxdWFsLCBpZ25vcmluZyBjYXNlCglleHByNSA9PSMgZXhwcjUJCWVxdWFsLCBtYXRjaCBjYXNlCglldGMuCQkJQXMgYWJvdmUsIGFwcGVuZCA/IGZvciBpZ25vcmluZyBjYXNlLCAjIGZvcgoJCQkJbWF0Y2hpbmcgY2FzZQoKCWV4cHI1IGlzIGV4cHI1CQlzYW1lIHxMaXN0fCBpbnN0YW5jZQoJZXhwcjUgaXNub3QgZXhwcjUJZGlmZmVyZW50IHxMaXN0fCBpbnN0YW5jZQoKfGV4cHI1fAlleHByNiArCSBleHByNiAuLgludW1iZXIgYWRkaXRpb24gb3IgbGlzdCBjb25jYXRlbmF0aW9uCglleHByNiAtCSBleHByNiAuLgludW1iZXIgc3VidHJhY3Rpb24KCWV4cHI2IC4JIGV4cHI2IC4uCXN0cmluZyBjb25jYXRlbmF0aW9uCgp8ZXhwcjZ8CWV4cHI3ICoJIGV4cHI3IC4uCW51bWJlciBtdWx0aXBsaWNhdGlvbgoJZXhwcjcgLwkgZXhwcjcgLi4JbnVtYmVyIGRpdmlzaW9uCglleHByNyAlCSBleHByNyAuLgludW1iZXIgbW9kdWxvCgp8ZXhwcjd8CSEgZXhwcjcJCQlsb2dpY2FsIE5PVAoJLSBleHByNwkJCXVuYXJ5IG1pbnVzCgkrIGV4cHI3CQkJdW5hcnkgcGx1cwoKfGV4cHI4fAlleHByOFtleHByMV0JCWJ5dGUgb2YgYSBTdHJpbmcgb3IgaXRlbSBvZiBhIHxMaXN0fAoJZXhwcjhbZXhwcjEgOiBleHByMV0Jc3Vic3RyaW5nIG9mIGEgU3RyaW5nIG9yIHN1Ymxpc3Qgb2YgYSB8TGlzdHwKCWV4cHI4Lm5hbWUJCWVudHJ5IGluIGEgfERpY3Rpb25hcnl8CglleHByOChleHByMSwgLi4uKQlmdW5jdGlvbiBjYWxsIHdpdGggfEZ1bmNyZWZ8IHZhcmlhYmxlCgp8ZXhwcjl8IG51bWJlcgkJCW51bWJlciBjb25zdGFudAoJInN0cmluZyIJCXN0cmluZyBjb25zdGFudCwgYmFja3NsYXNoIGlzIHNwZWNpYWwKCSdzdHJpbmcnCQlzdHJpbmcgY29uc3RhbnQsICcgaXMgZG91YmxlZAoJW2V4cHIxLCAuLi5dCQl8TGlzdHwKCXtleHByMTogZXhwcjEsIC4uLn0JfERpY3Rpb25hcnl8Cgkmb3B0aW9uCQkJb3B0aW9uIHZhbHVlCgkoZXhwcjEpCQkJbmVzdGVkIGV4cHJlc3Npb24KCXZhcmlhYmxlCQlpbnRlcm5hbCB2YXJpYWJsZQoJdmF7cmlhfWJsZQkJaW50ZXJuYWwgdmFyaWFibGUgd2l0aCBjdXJseSBicmFjZXMKCSRWQVIJCQllbnZpcm9ubWVudCB2YXJpYWJsZQoJQHIJCQljb250ZW50cyBvZiByZWdpc3RlciAncicKCWZ1bmN0aW9uKGV4cHIxLCAuLi4pCWZ1bmN0aW9uIGNhbGwKCWZ1bmN7dGl9b24oZXhwcjEsIC4uLikJZnVuY3Rpb24gY2FsbCB3aXRoIGN1cmx5IGJyYWNlcwoKCiIuLiIgaW5kaWNhdGVzIHRoYXQgdGhlIG9wZXJhdGlvbnMgaW4gdGhpcyBsZXZlbCBjYW4gYmUgY29uY2F0ZW5hdGVkLgpFeGFtcGxlOiA+CgkmbnUgfHwgJmxpc3QgJiYgJnNoZWxsID09ICJjc2giCgpBbGwgZXhwcmVzc2lvbnMgd2l0aGluIG9uZSBsZXZlbCBhcmUgcGFyc2VkIGZyb20gbGVmdCB0byByaWdodC4KCgpleHByMQkJCQkJCQkqZXhwcjEqICpFMTA5KgotLS0tLQoKZXhwcjIgPyBleHByMSA6IGV4cHIxCgpUaGUgZXhwcmVzc2lvbiBiZWZvcmUgdGhlICc/JyBpcyBldmFsdWF0ZWQgdG8gYSBudW1iZXIuICBJZiBpdCBldmFsdWF0ZXMgdG8Kbm9uLXplcm8sIHRoZSByZXN1bHQgaXMgdGhlIHZhbHVlIG9mIHRoZSBleHByZXNzaW9uIGJldHdlZW4gdGhlICc/JyBhbmQgJzonLApvdGhlcndpc2UgdGhlIHJlc3VsdCBpcyB0aGUgdmFsdWUgb2YgdGhlIGV4cHJlc3Npb24gYWZ0ZXIgdGhlICc6Jy4KRXhhbXBsZTogPgoJOmVjaG8gbG51bSA9PSAxID8gInRvcCIgOiBsbnVtCgpTaW5jZSB0aGUgZmlyc3QgZXhwcmVzc2lvbiBpcyBhbiAiZXhwcjIiLCBpdCBjYW5ub3QgY29udGFpbiBhbm90aGVyID86LiAgVGhlCm90aGVyIHR3byBleHByZXNzaW9ucyBjYW4sIHRodXMgYWxsb3cgZm9yIHJlY3Vyc2l2ZSB1c2Ugb2YgPzouCkV4YW1wbGU6ID4KCTplY2hvIGxudW0gPT0gMSA/ICJ0b3AiIDogbG51bSA9PSAxMDAwID8gImxhc3QiIDogbG51bQoKVG8ga2VlcCB0aGlzIHJlYWRhYmxlLCB1c2luZyB8bGluZS1jb250aW51YXRpb258IGlzIHN1Z2dlc3RlZDogPgoJOmVjaG8gbG51bSA9PSAxCgk6XAk/ICJ0b3AiCgk6XAk6IGxudW0gPT0gMTAwMAoJOlwJCT8gImxhc3QiCgk6XAkJOiBsbnVtCgpZb3Ugc2hvdWxkIGFsd2F5cyBwdXQgYSBzcGFjZSBiZWZvcmUgdGhlICc6Jywgb3RoZXJ3aXNlIGl0IGNhbiBiZSBtaXN0YWtlbiBmb3IKdXNlIGluIGEgdmFyaWFibGUgc3VjaCBhcyAiYToxIi4KCgpleHByMiBhbmQgZXhwcjMJCQkJCQkqZXhwcjIqICpleHByMyoKLS0tLS0tLS0tLS0tLS0tCgoJCQkJCSpleHByLWJhcmJhciogKmV4cHItJiYqClRoZSAifHwiIGFuZCAiJiYiIG9wZXJhdG9ycyB0YWtlIG9uZSBhcmd1bWVudCBvbiBlYWNoIHNpZGUuICBUaGUgYXJndW1lbnRzCmFyZSAoY29udmVydGVkIHRvKSBOdW1iZXJzLiAgVGhlIHJlc3VsdCBpczoKCgkgaW5wdXQJCQkJIG91dHB1dCB+Cm4xCQluMgkJbjEgfHwgbjIJbjEgJiYgbjIgfgp6ZXJvCQl6ZXJvCQl6ZXJvCQl6ZXJvCnplcm8JCW5vbi16ZXJvCW5vbi16ZXJvCXplcm8Kbm9uLXplcm8JemVybwkJbm9uLXplcm8JemVybwpub24temVybwlub24temVybwlub24temVybwlub24temVybwoKVGhlIG9wZXJhdG9ycyBjYW4gYmUgY29uY2F0ZW5hdGVkLCBmb3IgZXhhbXBsZTogPgoKCSZudSB8fCAmbGlzdCAmJiAmc2hlbGwgPT0gImNzaCIKCk5vdGUgdGhhdCAiJiYiIHRha2VzIHByZWNlZGVuY2Ugb3ZlciAifHwiLCBzbyB0aGlzIGhhcyB0aGUgbWVhbmluZyBvZjogPgoKCSZudSB8fCAoJmxpc3QgJiYgJnNoZWxsID09ICJjc2giKQoKT25jZSB0aGUgcmVzdWx0IGlzIGtub3duLCB0aGUgZXhwcmVzc2lvbiAic2hvcnQtY2lyY3VpdHMiLCB0aGF0IGlzLCBmdXJ0aGVyCmFyZ3VtZW50cyBhcmUgbm90IGV2YWx1YXRlZC4gIFRoaXMgaXMgbGlrZSB3aGF0IGhhcHBlbnMgaW4gQy4gIEZvciBleGFtcGxlOiA+CgoJbGV0IGEgPSAxCgllY2hvIGEgfHwgYgoKVGhpcyBpcyB2YWxpZCBldmVuIGlmIHRoZXJlIGlzIG5vIHZhcmlhYmxlIGNhbGxlZCAiYiIgYmVjYXVzZSAiYSIgaXMgbm9uLXplcm8sCnNvIHRoZSByZXN1bHQgbXVzdCBiZSBub24temVyby4gIFNpbWlsYXJseSBiZWxvdzogPgoKCWVjaG8gZXhpc3RzKCJiIikgJiYgYiA9PSAieWVzIgoKVGhpcyBpcyB2YWxpZCB3aGV0aGVyICJiIiBoYXMgYmVlbiBkZWZpbmVkIG9yIG5vdC4gIFRoZSBzZWNvbmQgY2xhdXNlIHdpbGwKb25seSBiZSBldmFsdWF0ZWQgaWYgImIiIGhhcyBiZWVuIGRlZmluZWQuCgoKZXhwcjQJCQkJCQkJKmV4cHI0KgotLS0tLQoKZXhwcjUge2NtcH0gZXhwcjUKCkNvbXBhcmUgdHdvIGV4cHI1IGV4cHJlc3Npb25zLCByZXN1bHRpbmcgaW4gYSAwIGlmIGl0IGV2YWx1YXRlcyB0byBmYWxzZSwgb3IgMQppZiBpdCBldmFsdWF0ZXMgdG8gdHJ1ZS4KCgkJCSpleHByLT09KiAgKmV4cHItIT0qICAqZXhwci0+KgkgKmV4cHItPj0qCgkJCSpleHByLTwqICAgKmV4cHItPD0qICAqZXhwci09fiogICpleHByLSF+KgoJCQkqZXhwci09PSMqICpleHByLSE9IyogKmV4cHItPiMqICAqZXhwci0+PSMqCgkJCSpleHByLTwjKiAgKmV4cHItPD0jKiAqZXhwci09fiMqICpleHByLSF+IyoKCQkJKmV4cHItPT0/KiAqZXhwci0hPT8qICpleHByLT4/KiAgKmV4cHItPj0/KgoJCQkqZXhwci08PyogICpleHByLTw9PyogKmV4cHItPX4/KiAqZXhwci0hfj8qCgkJCSpleHByLWlzKiAqZXhwci1pc25vdCogKmV4cHItaXMjKiAqZXhwci1pc25vdCMqCgkJCSpleHByLWlzPyogKmV4cHItaXNub3Q/KgoJCXVzZSAnaWdub3JlY2FzZScgICAgbWF0Y2ggY2FzZQkgICBpZ25vcmUgY2FzZSB+CmVxdWFsCQkJPT0JCT09IwkJPT0/Cm5vdCBlcXVhbAkJIT0JCSE9IwkJIT0/CmdyZWF0ZXIgdGhhbgkJPgkJPiMJCT4/CmdyZWF0ZXIgdGhhbiBvciBlcXVhbAk+PQkJPj0jCQk+PT8Kc21hbGxlciB0aGFuCQk8CQk8IwkJPD8Kc21hbGxlciB0aGFuIG9yIGVxdWFsCTw9CQk8PSMJCTw9PwpyZWdleHAgbWF0Y2hlcwkJPX4JCT1+IwkJPX4/CnJlZ2V4cCBkb2Vzbid0IG1hdGNoCSF+CQkhfiMJCSF+PwpzYW1lIGluc3RhbmNlCQlpcwkJaXMjCQlpcz8KZGlmZmVyZW50IGluc3RhbmNlCWlzbm90CQlpc25vdCMJCWlzbm90PwoKRXhhbXBsZXM6CiJhYmMiID09IyAiQWJjIgkgIGV2YWx1YXRlcyB0byAwCiJhYmMiID09PyAiQWJjIgkgIGV2YWx1YXRlcyB0byAxCiJhYmMiID09ICJBYmMiCSAgZXZhbHVhdGVzIHRvIDEgaWYgJ2lnbm9yZWNhc2UnIGlzIHNldCwgMCBvdGhlcndpc2UKCgkJCQkJCQkqRTY5MSogKkU2OTIqCkEgfExpc3R8IGNhbiBvbmx5IGJlIGNvbXBhcmVkIHdpdGggYSB8TGlzdHwgYW5kIG9ubHkgImVxdWFsIiwgIm5vdCBlcXVhbCIgYW5kCiJpcyIgY2FuIGJlIHVzZWQuICBUaGlzIGNvbXBhcmVzIHRoZSB2YWx1ZXMgb2YgdGhlIGxpc3QsIHJlY3Vyc2l2ZWx5LgpJZ25vcmluZyBjYXNlIG1lYW5zIGNhc2UgaXMgaWdub3JlZCB3aGVuIGNvbXBhcmluZyBpdGVtIHZhbHVlcy4KCgkJCQkJCQkqRTczNSogKkU3MzYqCkEgfERpY3Rpb25hcnl8IGNhbiBvbmx5IGJlIGNvbXBhcmVkIHdpdGggYSB8RGljdGlvbmFyeXwgYW5kIG9ubHkgImVxdWFsIiwgIm5vdAplcXVhbCIgYW5kICJpcyIgY2FuIGJlIHVzZWQuICBUaGlzIGNvbXBhcmVzIHRoZSBrZXkvdmFsdWVzIG9mIHRoZSB8RGljdGlvbmFyeXwKcmVjdXJzaXZlbHkuICBJZ25vcmluZyBjYXNlIG1lYW5zIGNhc2UgaXMgaWdub3JlZCB3aGVuIGNvbXBhcmluZyBpdGVtIHZhbHVlcy4KCgkJCQkJCQkqRTY5MyogKkU2OTQqCkEgfEZ1bmNyZWZ8IGNhbiBvbmx5IGJlIGNvbXBhcmVkIHdpdGggYSB8RnVuY3JlZnwgYW5kIG9ubHkgImVxdWFsIiBhbmQgIm5vdAplcXVhbCIgY2FuIGJlIHVzZWQuICBDYXNlIGlzIG5ldmVyIGlnbm9yZWQuCgpXaGVuIHVzaW5nICJpcyIgb3IgImlzbm90IiB3aXRoIGEgfExpc3R8IG9yIGEgfERpY3Rpb25hcnl8IHRoaXMgY2hlY2tzIGlmIHRoZQpleHByZXNzaW9ucyBhcmUgcmVmZXJyaW5nIHRvIHRoZSBzYW1lIHxMaXN0fCBvciB8RGljdGlvbmFyeXwgaW5zdGFuY2UuICBBIGNvcHkKb2YgYSB8TGlzdHwgaXMgZGlmZmVyZW50IGZyb20gdGhlIG9yaWdpbmFsIHxMaXN0fC4gIFdoZW4gdXNpbmcgImlzIiB3aXRob3V0CmEgfExpc3R8IG9yIGEgfERpY3Rpb25hcnl8IGl0IGlzIGVxdWl2YWxlbnQgdG8gdXNpbmcgImVxdWFsIiwgdXNpbmcgImlzbm90IgplcXVpdmFsZW50IHRvIHVzaW5nICJub3QgZXF1YWwiLiAgRXhjZXB0IHRoYXQgYSBkaWZmZXJlbnQgdHlwZSBtZWFucyB0aGUKdmFsdWVzIGFyZSBkaWZmZXJlbnQ6ICI0ID09ICc0JyIgaXMgdHJ1ZSwgIjQgaXMgJzQnIiBpcyBmYWxzZSBhbmQgIjAgaXMgW10iIGlzCmZhbHNlIGFuZCBub3QgYSBlcnJvci4gImlzIyIvImlzbm90IyIgYW5kICJpcz8iLyJpc25vdD8iIGNhbiBiZSB1c2VkIHRvIG1hdGNoCmFuZCBpZ25vcmUgY2FzZS4KCldoZW4gY29tcGFyaW5nIGEgU3RyaW5nIHdpdGggYSBOdW1iZXIsIHRoZSBTdHJpbmcgaXMgY29udmVydGVkIHRvIGEgTnVtYmVyLAphbmQgdGhlIGNvbXBhcmlzb24gaXMgZG9uZSBvbiBOdW1iZXJzLglUaGlzIG1lYW5zIHRoYXQgIjAgPT0gJ3gnIiBpcyBUUlVFLApiZWNhdXNlICd4JyBjb252ZXJ0ZWQgdG8gYSBOdW1iZXIgaXMgemVyby4KCldoZW4gY29tcGFyaW5nIHR3byBTdHJpbmdzLCB0aGlzIGlzIGRvbmUgd2l0aCBzdHJjbXAoKSBvciBzdHJpY21wKCkuICBUaGlzCnJlc3VsdHMgaW4gdGhlIG1hdGhlbWF0aWNhbCBkaWZmZXJlbmNlIChjb21wYXJpbmcgYnl0ZSB2YWx1ZXMpLCBub3QKbmVjZXNzYXJpbHkgdGhlIGFscGhhYmV0aWNhbCBkaWZmZXJlbmNlIGluIHRoZSBsb2NhbCBsYW5ndWFnZS4KCldoZW4gdXNpbmcgdGhlIG9wZXJhdG9ycyB3aXRoIGEgdHJhaWxpbmcgJyMnLCBvciB0aGUgc2hvcnQgdmVyc2lvbiBhbmQKJ2lnbm9yZWNhc2UnIGlzIG9mZiwgdGhlIGNvbXBhcmluZyBpcyBkb25lIHdpdGggc3RyY21wKCk6IGNhc2UgbWF0dGVycy4KCldoZW4gdXNpbmcgdGhlIG9wZXJhdG9ycyB3aXRoIGEgdHJhaWxpbmcgJz8nLCBvciB0aGUgc2hvcnQgdmVyc2lvbiBhbmQKJ2lnbm9yZWNhc2UnIGlzIHNldCwgdGhlIGNvbXBhcmluZyBpcyBkb25lIHdpdGggc3RyaWNtcCgpOiBjYXNlIGlzIGlnbm9yZWQuCgonc21hcnRjYXNlJyBpcyBub3QgdXNlZC4KClRoZSAiPX4iIGFuZCAiIX4iIG9wZXJhdG9ycyBtYXRjaCB0aGUgbGVmdGhhbmQgYXJndW1lbnQgd2l0aCB0aGUgcmlnaHRoYW5kCmFyZ3VtZW50LCB3aGljaCBpcyB1c2VkIGFzIGEgcGF0dGVybi4gIFNlZSB8cGF0dGVybnwgZm9yIHdoYXQgYSBwYXR0ZXJuIGlzLgpUaGlzIG1hdGNoaW5nIGlzIGFsd2F5cyBkb25lIGxpa2UgJ21hZ2ljJyB3YXMgc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eSwgbm8KbWF0dGVyIHdoYXQgdGhlIGFjdHVhbCB2YWx1ZSBvZiAnbWFnaWMnIG9yICdjcG9wdGlvbnMnIGlzLiAgVGhpcyBtYWtlcyBzY3JpcHRzCnBvcnRhYmxlLiAgVG8gYXZvaWQgYmFja3NsYXNoZXMgaW4gdGhlIHJlZ2V4cCBwYXR0ZXJuIHRvIGJlIGRvdWJsZWQsIHVzZSBhCnNpbmdsZS1xdW90ZSBzdHJpbmcsIHNlZSB8bGl0ZXJhbC1zdHJpbmd8LgpTaW5jZSBhIHN0cmluZyBpcyBjb25zaWRlcmVkIHRvIGJlIGEgc2luZ2xlIGxpbmUsIGEgbXVsdGktbGluZSBwYXR0ZXJuCihjb250YWluaW5nIFxuLCBiYWNrc2xhc2gtbikgd2lsbCBub3QgbWF0Y2guICBIb3dldmVyLCBhIGxpdGVyYWwgTkwgY2hhcmFjdGVyCmNhbiBiZSBtYXRjaGVkIGxpa2UgYW4gb3JkaW5hcnkgY2hhcmFjdGVyLiAgRXhhbXBsZXM6CgkiZm9vXG5iYXIiID1+ICJcbiIJZXZhbHVhdGVzIHRvIDEKCSJmb29cbmJhciIgPX4gIlxcbiIJZXZhbHVhdGVzIHRvIDAKCgpleHByNSBhbmQgZXhwcjYJCQkJCQkqZXhwcjUqICpleHByNioKLS0tLS0tLS0tLS0tLS0tCmV4cHI2ICsJIGV4cHI2IC4uCU51bWJlciBhZGRpdGlvbiBvciB8TGlzdHwgY29uY2F0ZW5hdGlvbgkqZXhwci0rKgpleHByNiAtCSBleHByNiAuLglOdW1iZXIgc3VidHJhY3Rpb24JCQkqZXhwci0tKgpleHByNiAuCSBleHByNiAuLglTdHJpbmcgY29uY2F0ZW5hdGlvbgkJCSpleHByLS4qCgpGb3IgfExpc3RzfCBvbmx5ICIrIiBpcyBwb3NzaWJsZSBhbmQgdGhlbiBib3RoIGV4cHI2IG11c3QgYmUgYSBsaXN0LiAgVGhlCnJlc3VsdCBpcyBhIG5ldyBsaXN0IHdpdGggdGhlIHR3byBsaXN0cyBDb25jYXRlbmF0ZWQuCgpleHByNyAqCSBleHByNyAuLglOdW1iZXIgbXVsdGlwbGljYXRpb24JCQkqZXhwci1zdGFyKgpleHByNyAvCSBleHByNyAuLglOdW1iZXIgZGl2aXNpb24JCQkJKmV4cHItLyoKZXhwcjcgJQkgZXhwcjcgLi4JTnVtYmVyIG1vZHVsbwkJCQkqZXhwci0lKgoKRm9yIGFsbCwgZXhjZXB0ICIuIiwgU3RyaW5ncyBhcmUgY29udmVydGVkIHRvIE51bWJlcnMuCkZvciBiaXR3aXNlIG9wZXJhdG9ycyBzZWUgfGFuZCgpfCwgfG9yKCl8IGFuZCB8eG9yKCl8LgoKTm90ZSB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuICIrIiBhbmQgIi4iOgoJIjEyMyIgKyAiNDU2IiA9IDU3OQoJIjEyMyIgLiAiNDU2IiA9ICIxMjM0NTYiCgpTaW5jZSAnLicgaGFzIHRoZSBzYW1lIHByZWNlZGVuY2UgYXMgJysnIGFuZCAnLScsIHlvdSBuZWVkIHRvIHJlYWQ6ID4KCTEgLiA5MCArIDkwLjAKQXM6ID4KCSgxIC4gOTApICsgOTAuMApUaGF0IHdvcmtzLCBzaW5jZSB0aGUgU3RyaW5nICIxOTAiIGlzIGF1dG9tYXRpY2FsbHkgY29udmVydGVkIHRvIHRoZSBOdW1iZXIKMTkwLCB3aGljaCBjYW4gYmUgYWRkZWQgdG8gdGhlIEZsb2F0IDkwLjAuICBIb3dldmVyOiA+CgkxIC4gOTAgKiA5MC4wClNob3VsZCBiZSByZWFkIGFzOiA+CgkxIC4gKDkwICogOTAuMCkKU2luY2UgJy4nIGhhcyBsb3dlciBwcmVjZWRlbmNlIHRoYW4gJyonLiAgVGhpcyBkb2VzIE5PVCB3b3JrLCBzaW5jZSB0aGlzCmF0dGVtcHRzIHRvIGNvbmNhdGVuYXRlIGEgRmxvYXQgYW5kIGEgU3RyaW5nLgoKV2hlbiBkaXZpZGluZyBhIE51bWJlciBieSB6ZXJvIHRoZSByZXN1bHQgZGVwZW5kcyBvbiB0aGUgdmFsdWU6CgkgIDAgLyAwICA9IC0weDgwMDAwMDAwCShsaWtlIE5hTiBmb3IgRmxvYXQpCgkgPjAgLyAwICA9ICAweDdmZmZmZmZmCShsaWtlIHBvc2l0aXZlIGluZmluaXR5KQoJIDwwIC8gMCAgPSAtMHg3ZmZmZmZmZgkobGlrZSBuZWdhdGl2ZSBpbmZpbml0eSkKCShiZWZvcmUgVmltIDcuMiBpdCB3YXMgYWx3YXlzIDB4N2ZmZmZmZmYpCgpXaGVuIHRoZSByaWdodGhhbmQgc2lkZSBvZiAnJScgaXMgemVybywgdGhlIHJlc3VsdCBpcyAwLgoKTm9uZSBvZiB0aGVzZSB3b3JrIGZvciB8RnVuY3JlZnxzLgoKLiBhbmQgJSBkbyBub3Qgd29yayBmb3IgRmxvYXQuICpFODA0KgoKCmV4cHI3CQkJCQkJCSpleHByNyoKLS0tLS0KISBleHByNwkJCWxvZ2ljYWwgTk9UCQkqZXhwci0hKgotIGV4cHI3CQkJdW5hcnkgbWludXMJCSpleHByLXVuYXJ5LS0qCisgZXhwcjcJCQl1bmFyeSBwbHVzCQkqZXhwci11bmFyeS0rKgoKRm9yICchJyBub24temVybyBiZWNvbWVzIHplcm8sIHplcm8gYmVjb21lcyBvbmUuCkZvciAnLScgdGhlIHNpZ24gb2YgdGhlIG51bWJlciBpcyBjaGFuZ2VkLgpGb3IgJysnIHRoZSBudW1iZXIgaXMgdW5jaGFuZ2VkLgoKQSBTdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYSBOdW1iZXIgZmlyc3QuCgpUaGVzZSB0aHJlZSBjYW4gYmUgcmVwZWF0ZWQgYW5kIG1peGVkLglFeGFtcGxlczoKCSEtMQkgICAgPT0gMAoJISE4CSAgICA9PSAxCgktLTkJICAgID09IDkKCgpleHByOAkJCQkJCQkqZXhwcjgqCi0tLS0tCmV4cHI4W2V4cHIxXQkJaXRlbSBvZiBTdHJpbmcgb3IgfExpc3R8CSpleHByLVtdKiAqRTExMSoKCklmIGV4cHI4IGlzIGEgTnVtYmVyIG9yIFN0cmluZyB0aGlzIHJlc3VsdHMgaW4gYSBTdHJpbmcgdGhhdCBjb250YWlucyB0aGUKZXhwcjEndGggc2luZ2xlIGJ5dGUgZnJvbSBleHByOC4gIGV4cHI4IGlzIHVzZWQgYXMgYSBTdHJpbmcsIGV4cHIxIGFzIGEKTnVtYmVyLiAgVGhpcyBkb2Vzbid0IHJlY29nbml6ZSBtdWx0aS1ieXRlIGVuY29kaW5ncywgc2VlIHxieXRlaWR4KCl8IGZvcgphbiBhbHRlcm5hdGl2ZS4KCkluZGV4IHplcm8gZ2l2ZXMgdGhlIGZpcnN0IGNoYXJhY3Rlci4gIFRoaXMgaXMgbGlrZSBpdCB3b3JrcyBpbiBDLiAgQ2FyZWZ1bDoKdGV4dCBjb2x1bW4gbnVtYmVycyBzdGFydCB3aXRoIG9uZSEgIEV4YW1wbGUsIHRvIGdldCB0aGUgY2hhcmFjdGVyIHVuZGVyIHRoZQpjdXJzb3I6ID4KCTpsZXQgYyA9IGdldGxpbmUoIi4iKVtjb2woIi4iKSAtIDFdCgpJZiB0aGUgbGVuZ3RoIG9mIHRoZSBTdHJpbmcgaXMgbGVzcyB0aGFuIHRoZSBpbmRleCwgdGhlIHJlc3VsdCBpcyBhbiBlbXB0eQpTdHJpbmcuICBBIG5lZ2F0aXZlIGluZGV4IGFsd2F5cyByZXN1bHRzIGluIGFuIGVtcHR5IHN0cmluZyAocmVhc29uOiBiYWNrd2FyZHMKY29tcGF0aWJpbGl0eSkuICBVc2UgWy0xOl0gdG8gZ2V0IHRoZSBsYXN0IGJ5dGUuCgpJZiBleHByOCBpcyBhIHxMaXN0fCB0aGVuIGl0IHJlc3VsdHMgdGhlIGl0ZW0gYXQgaW5kZXggZXhwcjEuICBTZWUgfGxpc3QtaW5kZXh8CmZvciBwb3NzaWJsZSBpbmRleCB2YWx1ZXMuICBJZiB0aGUgaW5kZXggaXMgb3V0IG9mIHJhbmdlIHRoaXMgcmVzdWx0cyBpbiBhbgplcnJvci4JRXhhbXBsZTogPgoJOmxldCBpdGVtID0gbXlsaXN0Wy0xXQkJIiBnZXQgbGFzdCBpdGVtCgpHZW5lcmFsbHksIGlmIGEgfExpc3R8IGluZGV4IGlzIGVxdWFsIHRvIG9yIGhpZ2hlciB0aGFuIHRoZSBsZW5ndGggb2YgdGhlCnxMaXN0fCwgb3IgbW9yZSBuZWdhdGl2ZSB0aGFuIHRoZSBsZW5ndGggb2YgdGhlIHxMaXN0fCwgdGhpcyByZXN1bHRzIGluIGFuCmVycm9yLgoKCmV4cHI4W2V4cHIxYSA6IGV4cHIxYl0Jc3Vic3RyaW5nIG9yIHN1Ymxpc3QJCSpleHByLVs6XSoKCklmIGV4cHI4IGlzIGEgTnVtYmVyIG9yIFN0cmluZyB0aGlzIHJlc3VsdHMgaW4gdGhlIHN1YnN0cmluZyB3aXRoIHRoZSBieXRlcwpmcm9tIGV4cHIxYSB0byBhbmQgaW5jbHVkaW5nIGV4cHIxYi4gIGV4cHI4IGlzIHVzZWQgYXMgYSBTdHJpbmcsIGV4cHIxYSBhbmQKZXhwcjFiIGFyZSB1c2VkIGFzIGEgTnVtYmVyLiAgVGhpcyBkb2Vzbid0IHJlY29nbml6ZSBtdWx0aS1ieXRlIGVuY29kaW5ncywgc2VlCnxieXRlaWR4KCl8IGZvciBjb21wdXRpbmcgdGhlIGluZGV4ZXMuCgpJZiBleHByMWEgaXMgb21pdHRlZCB6ZXJvIGlzIHVzZWQuICBJZiBleHByMWIgaXMgb21pdHRlZCB0aGUgbGVuZ3RoIG9mIHRoZQpzdHJpbmcgbWludXMgb25lIGlzIHVzZWQuCgpBIG5lZ2F0aXZlIG51bWJlciBjYW4gYmUgdXNlZCB0byBtZWFzdXJlIGZyb20gdGhlIGVuZCBvZiB0aGUgc3RyaW5nLiAgLTEgaXMKdGhlIGxhc3QgY2hhcmFjdGVyLCAtMiB0aGUgbGFzdCBidXQgb25lLCBldGMuCgpJZiBhbiBpbmRleCBnb2VzIG91dCBvZiByYW5nZSBmb3IgdGhlIHN0cmluZyBjaGFyYWN0ZXJzIGFyZSBvbWl0dGVkLiAgSWYKZXhwcjFiIGlzIHNtYWxsZXIgdGhhbiBleHByMWEgdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBzdHJpbmcuCgpFeGFtcGxlczogPgoJOmxldCBjID0gbmFtZVstMTpdCQkiIGxhc3QgYnl0ZSBvZiBhIHN0cmluZwoJOmxldCBjID0gbmFtZVstMjotMl0JCSIgbGFzdCBidXQgb25lIGJ5dGUgb2YgYSBzdHJpbmcKCTpsZXQgcyA9IGxpbmUoIi4iKVs0Ol0JCSIgZnJvbSB0aGUgZmlmdGggYnl0ZSB0byB0aGUgZW5kCgk6bGV0IHMgPSBzWzotM10JCQkiIHJlbW92ZSBsYXN0IHR3byBieXRlcwo8CgkJCQkJCQkqc3VibGlzdCogKnNsaWNlKgpJZiBleHByOCBpcyBhIHxMaXN0fCB0aGlzIHJlc3VsdHMgaW4gYSBuZXcgfExpc3R8IHdpdGggdGhlIGl0ZW1zIGluZGljYXRlZCBieQp0aGUgaW5kZXhlcyBleHByMWEgYW5kIGV4cHIxYi4JVGhpcyB3b3JrcyBsaWtlIHdpdGggYSBTdHJpbmcsIGFzIGV4cGxhaW5lZApqdXN0IGFib3ZlLCBleGNlcHQgdGhhdCBpbmRleGVzIG91dCBvZiByYW5nZSBjYXVzZSBhbiBlcnJvci4gIEV4YW1wbGVzOiA+Cgk6bGV0IGwgPSBteWxpc3RbOjNdCQkiIGZpcnN0IGZvdXIgaXRlbXMKCTpsZXQgbCA9IG15bGlzdFs0OjRdCQkiIExpc3Qgd2l0aCBvbmUgaXRlbQoJOmxldCBsID0gbXlsaXN0WzpdCQkiIHNoYWxsb3cgY29weSBvZiBhIExpc3QKClVzaW5nIGV4cHI4W2V4cHIxXSBvciBleHByOFtleHByMWEgOiBleHByMWJdIG9uIGEgfEZ1bmNyZWZ8IHJlc3VsdHMgaW4gYW4KZXJyb3IuCgoKZXhwcjgubmFtZQkJZW50cnkgaW4gYSB8RGljdGlvbmFyeXwJCSpleHByLWVudHJ5KgoKSWYgZXhwcjggaXMgYSB8RGljdGlvbmFyeXwgYW5kIGl0IGlzIGZvbGxvd2VkIGJ5IGEgZG90LCB0aGVuIHRoZSBmb2xsb3dpbmcKbmFtZSB3aWxsIGJlIHVzZWQgYXMgYSBrZXkgaW4gdGhlIHxEaWN0aW9uYXJ5fC4gIFRoaXMgaXMganVzdCBsaWtlOgpleHByOFtuYW1lXS4KClRoZSBuYW1lIG11c3QgY29uc2lzdCBvZiBhbHBoYW51bWVyaWMgY2hhcmFjdGVycywganVzdCBsaWtlIGEgdmFyaWFibGUgbmFtZSwKYnV0IGl0IG1heSBzdGFydCB3aXRoIGEgbnVtYmVyLiAgQ3VybHkgYnJhY2VzIGNhbm5vdCBiZSB1c2VkLgoKVGhlcmUgbXVzdCBub3QgYmUgd2hpdGUgc3BhY2UgYmVmb3JlIG9yIGFmdGVyIHRoZSBkb3QuCgpFeGFtcGxlczogPgoJOmxldCBkaWN0ID0geyJvbmUiOiAxLCAyOiAidHdvIn0KCTplY2hvIGRpY3Qub25lCgk6ZWNobyBkaWN0IC4yCgpOb3RlIHRoYXQgdGhlIGRvdCBpcyBhbHNvIHVzZWQgZm9yIFN0cmluZyBjb25jYXRlbmF0aW9uLiAgVG8gYXZvaWQgY29uZnVzaW9uCmFsd2F5cyBwdXQgc3BhY2VzIGFyb3VuZCB0aGUgZG90IGZvciBTdHJpbmcgY29uY2F0ZW5hdGlvbi4KCgpleHByOChleHByMSwgLi4uKQl8RnVuY3JlZnwgZnVuY3Rpb24gY2FsbAoKV2hlbiBleHByOCBpcyBhIHxGdW5jcmVmfCB0eXBlIHZhcmlhYmxlLCBpbnZva2UgdGhlIGZ1bmN0aW9uIGl0IHJlZmVycyB0by4KCgoKCQkJCQkJCSpleHByOSoKbnVtYmVyCi0tLS0tLQpudW1iZXIJCQludW1iZXIgY29uc3RhbnQJCQkqZXhwci1udW1iZXIqIAoJCQkJCQkqaGV4LW51bWJlciogKm9jdGFsLW51bWJlcioKCkRlY2ltYWwsIEhleGFkZWNpbWFsIChzdGFydGluZyB3aXRoIDB4IG9yIDBYKSwgb3IgT2N0YWwgKHN0YXJ0aW5nIHdpdGggMCkuCgoJCQkJCQkqZmxvYXRpbmctcG9pbnQtZm9ybWF0KgpGbG9hdGluZyBwb2ludCBudW1iZXJzIGNhbiBiZSB3cml0dGVuIGluIHR3byBmb3JtczoKCglbLStde059LntNfQoJWy0rXXtOfS57TX1lWy0rXXtleHB9Cgp7Tn0gYW5kIHtNfSBhcmUgbnVtYmVycy4gIEJvdGgge059IGFuZCB7TX0gbXVzdCBiZSBwcmVzZW50IGFuZCBjYW4gb25seQpjb250YWluIGRpZ2l0cy4KWy0rXSBtZWFucyB0aGVyZSBpcyBhbiBvcHRpb25hbCBwbHVzIG9yIG1pbnVzIHNpZ24uCntleHB9IGlzIHRoZSBleHBvbmVudCwgcG93ZXIgb2YgMTAuCk9ubHkgYSBkZWNpbWFsIHBvaW50IGlzIGFjY2VwdGVkLCBub3QgYSBjb21tYS4JTm8gbWF0dGVyIHdoYXQgdGhlIGN1cnJlbnQKbG9jYWxlIGlzLgp7b25seSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgpFeGFtcGxlczoKCTEyMy40NTYKCSswLjAwMDEKCTU1LjAKCS0wLjEyMwoJMS4yMzRlMDMKCTEuMEUtNgoJLTMuMTQxNmUrODgKClRoZXNlIGFyZSBJTlZBTElEOgoJMy4JCWVtcHR5IHtNfQoJMWU0MAkJbWlzc2luZyAue019CgoJCQkJCQkJKmZsb2F0LXBpKiAqZmxvYXQtZSoKQSBmZXcgdXNlZnVsIHZhbHVlcyB0byBjb3B5JnBhc3RlOiA+Cgk6bGV0IHBpID0gMy4xNDE1OTI2NTM1OQoJOmxldCBlICA9IDIuNzE4MjgxODI4NDYKClJhdGlvbmFsZToKQmVmb3JlIGZsb2F0aW5nIHBvaW50IHdhcyBpbnRyb2R1Y2VkLCB0aGUgdGV4dCAiMTIzLjQ1NiIgd2FzIGludGVycHJldGVkIGFzCnRoZSB0d28gbnVtYmVycyAiMTIzIiBhbmQgIjQ1NiIsIGJvdGggY29udmVydGVkIHRvIGEgc3RyaW5nIGFuZCBjb25jYXRlbmF0ZWQsCnJlc3VsdGluZyBpbiB0aGUgc3RyaW5nICIxMjM0NTYiLiAgU2luY2UgdGhpcyB3YXMgY29uc2lkZXJlZCBwb2ludGxlc3MsIGFuZCB3ZQpjb3VsZCBub3QgZmluZCBpdCBpbnRlbnRpb25hbGx5IGJlaW5nIHVzZWQgaW4gVmltIHNjcmlwdHMsIHRoaXMgYmFja3dhcmRzCmluY29tcGF0aWJpbGl0eSB3YXMgYWNjZXB0ZWQgaW4gZmF2b3Igb2YgYmVpbmcgYWJsZSB0byB1c2UgdGhlIG5vcm1hbCBub3RhdGlvbgpmb3IgZmxvYXRpbmcgcG9pbnQgbnVtYmVycy4KCgkJCQkJCSpmbG9hdGluZy1wb2ludC1wcmVjaXNpb24qClRoZSBwcmVjaXNpb24gYW5kIHJhbmdlIG9mIGZsb2F0aW5nIHBvaW50cyBudW1iZXJzIGRlcGVuZHMgb24gd2hhdCAiZG91YmxlIgptZWFucyBpbiB0aGUgbGlicmFyeSBWaW0gd2FzIGNvbXBpbGVkIHdpdGguICBUaGVyZSBpcyBubyB3YXkgdG8gY2hhbmdlIHRoaXMgYXQKcnVudGltZS4KClRoZSBkZWZhdWx0IGZvciBkaXNwbGF5aW5nIGEgfEZsb2F0fCBpcyB0byB1c2UgNiBkZWNpbWFsIHBsYWNlcywgbGlrZSB1c2luZwpwcmludGYoIiVnIiwgZikuICBZb3UgY2FuIHNlbGVjdCBzb21ldGhpbmcgZWxzZSB3aGVuIHVzaW5nIHRoZSB8cHJpbnRmKCl8CmZ1bmN0aW9uLiAgRXhhbXBsZTogPgoJOmVjaG8gcHJpbnRmKCclLjE1ZScsIGF0YW4oMSkpCjwJNy44NTM5ODE2MzM5NzQ0ODNlLTAxCgoKCnN0cmluZwkJCQkJCQkqZXhwci1zdHJpbmcqICpFMTE0KgotLS0tLS0KInN0cmluZyIJCXN0cmluZyBjb25zdGFudAkJKmV4cHItcXVvdGUqCgpOb3RlIHRoYXQgZG91YmxlIHF1b3RlcyBhcmUgdXNlZC4KCkEgc3RyaW5nIGNvbnN0YW50IGFjY2VwdHMgdGhlc2Ugc3BlY2lhbCBjaGFyYWN0ZXJzOgpcLi4uCXRocmVlLWRpZ2l0IG9jdGFsIG51bWJlciAoZS5nLiwgIlwzMTYiKQpcLi4JdHdvLWRpZ2l0IG9jdGFsIG51bWJlciAobXVzdCBiZSBmb2xsb3dlZCBieSBub24tZGlnaXQpClwuCW9uZS1kaWdpdCBvY3RhbCBudW1iZXIgKG11c3QgYmUgZm9sbG93ZWQgYnkgbm9uLWRpZ2l0KQpceC4uCWJ5dGUgc3BlY2lmaWVkIHdpdGggdHdvIGhleCBudW1iZXJzIChlLmcuLCAiXHgxZiIpClx4LglieXRlIHNwZWNpZmllZCB3aXRoIG9uZSBoZXggbnVtYmVyIChtdXN0IGJlIGZvbGxvd2VkIGJ5IG5vbi1oZXggY2hhcikKXFguLglzYW1lIGFzIFx4Li4KXFguCXNhbWUgYXMgXHguClx1Li4uLgljaGFyYWN0ZXIgc3BlY2lmaWVkIHdpdGggdXAgdG8gNCBoZXggbnVtYmVycywgc3RvcmVkIGFjY29yZGluZyB0byB0aGUKCWN1cnJlbnQgdmFsdWUgb2YgJ2VuY29kaW5nJyAoZS5nLiwgIlx1MDJhNCIpClxVLi4uLglzYW1lIGFzIFx1Li4uLgpcYgliYWNrc3BhY2UgPEJTPgpcZQllc2NhcGUgPEVzYz4KXGYJZm9ybWZlZWQgPEZGPgpcbgluZXdsaW5lIDxOTD4KXHIJcmV0dXJuIDxDUj4KXHQJdGFiIDxUYWI+ClxcCWJhY2tzbGFzaApcIglkb3VibGUgcXVvdGUKXDx4eHg+CVNwZWNpYWwga2V5IG5hbWVkICJ4eHgiLiAgZS5nLiAiXDxDLVc+IiBmb3IgQ1RSTC1XLiAgVGhpcyBpcyBmb3IgdXNlCglpbiBtYXBwaW5ncywgdGhlIDB4ODAgYnl0ZSBpcyBlc2NhcGVkLiAgRG9uJ3QgdXNlIDxDaGFyLXh4eHg+IHRvIGdldCBhCgl1dGYtOCBjaGFyYWN0ZXIsIHVzZSBcdXh4eHggYXMgbWVudGlvbmVkIGFib3ZlLgoKTm90ZSB0aGF0ICJceGZmIiBpcyBzdG9yZWQgYXMgdGhlIGJ5dGUgMjU1LCB3aGljaCBtYXkgYmUgaW52YWxpZCBpbiBzb21lCmVuY29kaW5ncy4gIFVzZSAiXHUwMGZmIiB0byBzdG9yZSBjaGFyYWN0ZXIgMjU1IGFjY29yZGluZyB0byB0aGUgY3VycmVudCB2YWx1ZQpvZiAnZW5jb2RpbmcnLgoKTm90ZSB0aGF0ICJcMDAwIiBhbmQgIlx4MDAiIGZvcmNlIHRoZSBlbmQgb2YgdGhlIHN0cmluZy4KCgpsaXRlcmFsLXN0cmluZwkJCQkJCSpsaXRlcmFsLXN0cmluZyogKkUxMTUqCi0tLS0tLS0tLS0tLS0tLQonc3RyaW5nJwkJc3RyaW5nIGNvbnN0YW50CQkJKmV4cHItJyoKCk5vdGUgdGhhdCBzaW5nbGUgcXVvdGVzIGFyZSB1c2VkLgoKVGhpcyBzdHJpbmcgaXMgdGFrZW4gYXMgaXQgaXMuCU5vIGJhY2tzbGFzaGVzIGFyZSByZW1vdmVkIG9yIGhhdmUgYSBzcGVjaWFsCm1lYW5pbmcuICBUaGUgb25seSBleGNlcHRpb24gaXMgdGhhdCB0d28gcXVvdGVzIHN0YW5kIGZvciBvbmUgcXVvdGUuCgpTaW5nbGUgcXVvdGVkIHN0cmluZ3MgYXJlIHVzZWZ1bCBmb3IgcGF0dGVybnMsIHNvIHRoYXQgYmFja3NsYXNoZXMgZG8gbm90IG5lZWQKdG8gYmUgZG91YmxlZC4JVGhlc2UgdHdvIGNvbW1hbmRzIGFyZSBlcXVpdmFsZW50OiA+CglpZiBhID1+ICJcXHMqIgoJaWYgYSA9fiAnXHMqJwoKCm9wdGlvbgkJCQkJCSpleHByLW9wdGlvbiogKkUxMTIqICpFMTEzKgotLS0tLS0KJm9wdGlvbgkJCW9wdGlvbiB2YWx1ZSwgbG9jYWwgdmFsdWUgaWYgcG9zc2libGUKJmc6b3B0aW9uCQlnbG9iYWwgb3B0aW9uIHZhbHVlCiZsOm9wdGlvbgkJbG9jYWwgb3B0aW9uIHZhbHVlCgpFeGFtcGxlczogPgoJZWNobyAidGFic3RvcCBpcyAiIC4gJnRhYnN0b3AKCWlmICZpbnNlcnRtb2RlCgpBbnkgb3B0aW9uIG5hbWUgY2FuIGJlIHVzZWQgaGVyZS4gIFNlZSB8b3B0aW9uc3wuICBXaGVuIHVzaW5nIHRoZSBsb2NhbCB2YWx1ZQphbmQgdGhlcmUgaXMgbm8gYnVmZmVyLWxvY2FsIG9yIHdpbmRvdy1sb2NhbCB2YWx1ZSwgdGhlIGdsb2JhbCB2YWx1ZSBpcyB1c2VkCmFueXdheS4KCgpyZWdpc3RlcgkJCQkJCSpleHByLXJlZ2lzdGVyKiAqQHIqCi0tLS0tLS0tCkByCQkJY29udGVudHMgb2YgcmVnaXN0ZXIgJ3InCgpUaGUgcmVzdWx0IGlzIHRoZSBjb250ZW50cyBvZiB0aGUgbmFtZWQgcmVnaXN0ZXIsIGFzIGEgc2luZ2xlIHN0cmluZy4KTmV3bGluZXMgYXJlIGluc2VydGVkIHdoZXJlIHJlcXVpcmVkLiAgVG8gZ2V0IHRoZSBjb250ZW50cyBvZiB0aGUgdW5uYW1lZApyZWdpc3RlciB1c2UgQCIgb3IgQEAuCVNlZSB8cmVnaXN0ZXJzfCBmb3IgYW4gZXhwbGFuYXRpb24gb2YgdGhlIGF2YWlsYWJsZQpyZWdpc3RlcnMuCgpXaGVuIHVzaW5nIHRoZSAnPScgcmVnaXN0ZXIgeW91IGdldCB0aGUgZXhwcmVzc2lvbiBpdHNlbGYsIG5vdCB3aGF0IGl0CmV2YWx1YXRlcyB0by4gIFVzZSB8ZXZhbCgpfCB0byBldmFsdWF0ZSBpdC4KCgpuZXN0aW5nCQkJCQkJCSpleHByLW5lc3RpbmcqICpFMTEwKgotLS0tLS0tCihleHByMSkJCQluZXN0ZWQgZXhwcmVzc2lvbgoKCmVudmlyb25tZW50IHZhcmlhYmxlCQkJCQkqZXhwci1lbnYqCi0tLS0tLS0tLS0tLS0tLS0tLS0tCiRWQVIJCQllbnZpcm9ubWVudCB2YXJpYWJsZQoKVGhlIFN0cmluZyB2YWx1ZSBvZiBhbnkgZW52aXJvbm1lbnQgdmFyaWFibGUuICBXaGVuIGl0IGlzIG5vdCBkZWZpbmVkLCB0aGUKcmVzdWx0IGlzIGFuIGVtcHR5IHN0cmluZy4KCQkJCQkJKmV4cHItZW52LWV4cGFuZCoKTm90ZSB0aGF0IHRoZXJlIGlzIGEgZGlmZmVyZW5jZSBiZXR3ZWVuIHVzaW5nICRWQVIgZGlyZWN0bHkgYW5kIHVzaW5nCmV4cGFuZCgiJFZBUiIpLiAgVXNpbmcgaXQgZGlyZWN0bHkgd2lsbCBvbmx5IGV4cGFuZCBlbnZpcm9ubWVudCB2YXJpYWJsZXMgdGhhdAphcmUga25vd24gaW5zaWRlIHRoZSBjdXJyZW50IFZpbSBzZXNzaW9uLiAgVXNpbmcgZXhwYW5kKCkgd2lsbCBmaXJzdCB0cnkgdXNpbmcKdGhlIGVudmlyb25tZW50IHZhcmlhYmxlcyBrbm93biBpbnNpZGUgdGhlIGN1cnJlbnQgVmltIHNlc3Npb24uICBJZiB0aGF0CmZhaWxzLCBhIHNoZWxsIHdpbGwgYmUgdXNlZCB0byBleHBhbmQgdGhlIHZhcmlhYmxlLiAgVGhpcyBjYW4gYmUgc2xvdywgYnV0IGl0CmRvZXMgZXhwYW5kIGFsbCB2YXJpYWJsZXMgdGhhdCB0aGUgc2hlbGwga25vd3MgYWJvdXQuICBFeGFtcGxlOiA+Cgk6ZWNobyAkdmVyc2lvbgoJOmVjaG8gZXhwYW5kKCIkdmVyc2lvbiIpClRoZSBmaXJzdCBvbmUgcHJvYmFibHkgZG9lc24ndCBlY2hvIGFueXRoaW5nLCB0aGUgc2Vjb25kIGVjaG9lcyB0aGUgJHZlcnNpb24KdmFyaWFibGUgKGlmIHlvdXIgc2hlbGwgc3VwcG9ydHMgaXQpLgoKCmludGVybmFsIHZhcmlhYmxlCQkJCQkqZXhwci12YXJpYWJsZSoKLS0tLS0tLS0tLS0tLS0tLS0KdmFyaWFibGUJCWludGVybmFsIHZhcmlhYmxlClNlZSBiZWxvdyB8aW50ZXJuYWwtdmFyaWFibGVzfC4KCgpmdW5jdGlvbiBjYWxsCQkqZXhwci1mdW5jdGlvbiogKkUxMTYqICpFMTE4KiAqRTExOSogKkUxMjAqCi0tLS0tLS0tLS0tLS0KZnVuY3Rpb24oZXhwcjEsIC4uLikJZnVuY3Rpb24gY2FsbApTZWUgYmVsb3cgfGZ1bmN0aW9uc3wuCgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjMuIEludGVybmFsIHZhcmlhYmxlCQkJCSppbnRlcm5hbC12YXJpYWJsZXMqICpFNDYxKgoKQW4gaW50ZXJuYWwgdmFyaWFibGUgbmFtZSBjYW4gYmUgbWFkZSB1cCBvZiBsZXR0ZXJzLCBkaWdpdHMgYW5kICdfJy4gIEJ1dCBpdApjYW5ub3Qgc3RhcnQgd2l0aCBhIGRpZ2l0LiAgSXQncyBhbHNvIHBvc3NpYmxlIHRvIHVzZSBjdXJseSBicmFjZXMsIHNlZQp8Y3VybHktYnJhY2VzLW5hbWVzfC4KCkFuIGludGVybmFsIHZhcmlhYmxlIGlzIGNyZWF0ZWQgd2l0aCB0aGUgIjpsZXQiIGNvbW1hbmQgfDpsZXR8LgpBbiBpbnRlcm5hbCB2YXJpYWJsZSBpcyBleHBsaWNpdGx5IGRlc3Ryb3llZCB3aXRoIHRoZSAiOnVubGV0IiBjb21tYW5kCnw6dW5sZXR8LgpVc2luZyBhIG5hbWUgdGhhdCBpcyBub3QgYW4gaW50ZXJuYWwgdmFyaWFibGUgb3IgcmVmZXJzIHRvIGEgdmFyaWFibGUgdGhhdCBoYXMKYmVlbiBkZXN0cm95ZWQgcmVzdWx0cyBpbiBhbiBlcnJvci4KClRoZXJlIGFyZSBzZXZlcmFsIG5hbWUgc3BhY2VzIGZvciB2YXJpYWJsZXMuICBXaGljaCBvbmUgaXMgdG8gYmUgdXNlZCBpcwpzcGVjaWZpZWQgYnkgd2hhdCBpcyBwcmVwZW5kZWQ6CgoJCShub3RoaW5nKSBJbiBhIGZ1bmN0aW9uOiBsb2NhbCB0byBhIGZ1bmN0aW9uOyBvdGhlcndpc2U6IGdsb2JhbAp8YnVmZmVyLXZhcmlhYmxlfCAgICBiOgkgIExvY2FsIHRvIHRoZSBjdXJyZW50IGJ1ZmZlci4KfHdpbmRvdy12YXJpYWJsZXwgICAgdzoJICBMb2NhbCB0byB0aGUgY3VycmVudCB3aW5kb3cuCnx0YWJwYWdlLXZhcmlhYmxlfCAgIHQ6CSAgTG9jYWwgdG8gdGhlIGN1cnJlbnQgdGFiIHBhZ2UuCnxnbG9iYWwtdmFyaWFibGV8ICAgIGc6CSAgR2xvYmFsLgp8bG9jYWwtdmFyaWFibGV8ICAgICBsOgkgIExvY2FsIHRvIGEgZnVuY3Rpb24uCnxzY3JpcHQtdmFyaWFibGV8ICAgIHM6CSAgTG9jYWwgdG8gYSB8OnNvdXJjZXwnZWQgVmltIHNjcmlwdC4KfGZ1bmN0aW9uLWFyZ3VtZW50fCAgYToJICBGdW5jdGlvbiBhcmd1bWVudCAob25seSBpbnNpZGUgYSBmdW5jdGlvbikuCnx2aW0tdmFyaWFibGV8CSAgICAgdjoJICBHbG9iYWwsIHByZWRlZmluZWQgYnkgVmltLgoKVGhlIHNjb3BlIG5hbWUgYnkgaXRzZWxmIGNhbiBiZSB1c2VkIGFzIGEgfERpY3Rpb25hcnl8LiAgRm9yIGV4YW1wbGUsIHRvCmRlbGV0ZSBhbGwgc2NyaXB0LWxvY2FsIHZhcmlhYmxlczogPgoJOmZvciBrIGluIGtleXMoczopCgk6ICAgIHVubGV0IHM6W2tdCgk6ZW5kZm9yCjwKCQkJCQkJKmJ1ZmZlci12YXJpYWJsZSogKmI6dmFyKgpBIHZhcmlhYmxlIG5hbWUgdGhhdCBpcyBwcmVjZWRlZCB3aXRoICJiOiIgaXMgbG9jYWwgdG8gdGhlIGN1cnJlbnQgYnVmZmVyLgpUaHVzIHlvdSBjYW4gaGF2ZSBzZXZlcmFsICJiOmZvbyIgdmFyaWFibGVzLCBvbmUgZm9yIGVhY2ggYnVmZmVyLgpUaGlzIGtpbmQgb2YgdmFyaWFibGUgaXMgZGVsZXRlZCB3aGVuIHRoZSBidWZmZXIgaXMgd2lwZWQgb3V0IG9yIGRlbGV0ZWQgd2l0aAp8OmJkZWxldGV8LgoKT25lIGxvY2FsIGJ1ZmZlciB2YXJpYWJsZSBpcyBwcmVkZWZpbmVkOgoJCQkJCSpiOmNoYW5nZWR0aWNrLXZhcmlhYmxlKiAqY2hhbmdldGljayoKYjpjaGFuZ2VkdGljawlUaGUgdG90YWwgbnVtYmVyIG9mIGNoYW5nZXMgdG8gdGhlIGN1cnJlbnQgYnVmZmVyLiAgSXQgaXMKCQlpbmNyZW1lbnRlZCBmb3IgZWFjaCBjaGFuZ2UuICBBbiB1bmRvIGNvbW1hbmQgaXMgYWxzbyBhIGNoYW5nZQoJCWluIHRoaXMgY2FzZS4gIFRoaXMgY2FuIGJlIHVzZWQgdG8gcGVyZm9ybSBhbiBhY3Rpb24gb25seSB3aGVuCgkJdGhlIGJ1ZmZlciBoYXMgY2hhbmdlZC4gIEV4YW1wbGU6ID4KCQkgICAgOmlmIG15X2NoYW5nZWR0aWNrICE9IGI6Y2hhbmdlZHRpY2sKCQkgICAgOglsZXQgbXlfY2hhbmdlZHRpY2sgPSBiOmNoYW5nZWR0aWNrCgkJICAgIDoJY2FsbCBNeV9VcGRhdGUoKQoJCSAgICA6ZW5kaWYKPAoJCQkJCQkqd2luZG93LXZhcmlhYmxlKiAqdzp2YXIqCkEgdmFyaWFibGUgbmFtZSB0aGF0IGlzIHByZWNlZGVkIHdpdGggInc6IiBpcyBsb2NhbCB0byB0aGUgY3VycmVudCB3aW5kb3cuICBJdAppcyBkZWxldGVkIHdoZW4gdGhlIHdpbmRvdyBpcyBjbG9zZWQuCgoJCQkJCQkqdGFicGFnZS12YXJpYWJsZSogKnQ6dmFyKgpBIHZhcmlhYmxlIG5hbWUgdGhhdCBpcyBwcmVjZWRlZCB3aXRoICJ0OiIgaXMgbG9jYWwgdG8gdGhlIGN1cnJlbnQgdGFiIHBhZ2UsCkl0IGlzIGRlbGV0ZWQgd2hlbiB0aGUgdGFiIHBhZ2UgaXMgY2xvc2VkLiB7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkCndpdGhvdXQgdGhlIHwrd2luZG93c3wgZmVhdHVyZX0KCgkJCQkJCSpnbG9iYWwtdmFyaWFibGUqICpnOnZhcioKSW5zaWRlIGZ1bmN0aW9ucyBnbG9iYWwgdmFyaWFibGVzIGFyZSBhY2Nlc3NlZCB3aXRoICJnOiIuICBPbWl0dGluZyB0aGlzIHdpbGwKYWNjZXNzIGEgdmFyaWFibGUgbG9jYWwgdG8gYSBmdW5jdGlvbi4JQnV0ICJnOiIgY2FuIGFsc28gYmUgdXNlZCBpbiBhbnkgb3RoZXIKcGxhY2UgaWYgeW91IGxpa2UuCgoJCQkJCQkqbG9jYWwtdmFyaWFibGUqICpsOnZhcioKSW5zaWRlIGZ1bmN0aW9ucyBsb2NhbCB2YXJpYWJsZXMgYXJlIGFjY2Vzc2VkIHdpdGhvdXQgcHJlcGVuZGluZyBhbnl0aGluZy4KQnV0IHlvdSBjYW4gYWxzbyBwcmVwZW5kICJsOiIgaWYgeW91IGxpa2UuICBIb3dldmVyLCB3aXRob3V0IHByZXBlbmRpbmcgImw6Igp5b3UgbWF5IHJ1biBpbnRvIHJlc2VydmVkIHZhcmlhYmxlIG5hbWVzLiAgRm9yIGV4YW1wbGUgImNvdW50Ii4gIEJ5IGl0c2VsZiBpdApyZWZlcnMgdG8gInY6Y291bnQiLiAgVXNpbmcgImw6Y291bnQiIHlvdSBjYW4gaGF2ZSBhIGxvY2FsIHZhcmlhYmxlIHdpdGggdGhlCnNhbWUgbmFtZS4KCgkJCQkJCSpzY3JpcHQtdmFyaWFibGUqICpzOnZhcioKSW4gYSBWaW0gc2NyaXB0IHZhcmlhYmxlcyBzdGFydGluZyB3aXRoICJzOiIgY2FuIGJlIHVzZWQuICBUaGV5IGNhbm5vdCBiZQphY2Nlc3NlZCBmcm9tIG91dHNpZGUgb2YgdGhlIHNjcmlwdHMsIHRodXMgYXJlIGxvY2FsIHRvIHRoZSBzY3JpcHQuCgpUaGV5IGNhbiBiZSB1c2VkIGluOgotIGNvbW1hbmRzIGV4ZWN1dGVkIHdoaWxlIHRoZSBzY3JpcHQgaXMgc291cmNlZAotIGZ1bmN0aW9ucyBkZWZpbmVkIGluIHRoZSBzY3JpcHQKLSBhdXRvY29tbWFuZHMgZGVmaW5lZCBpbiB0aGUgc2NyaXB0Ci0gZnVuY3Rpb25zIGFuZCBhdXRvY29tbWFuZHMgZGVmaW5lZCBpbiBmdW5jdGlvbnMgYW5kIGF1dG9jb21tYW5kcyB3aGljaCB3ZXJlCiAgZGVmaW5lZCBpbiB0aGUgc2NyaXB0IChyZWN1cnNpdmVseSkKLSB1c2VyIGRlZmluZWQgY29tbWFuZHMgZGVmaW5lZCBpbiB0aGUgc2NyaXB0ClRodXMgbm90IGluOgotIG90aGVyIHNjcmlwdHMgc291cmNlZCBmcm9tIHRoaXMgb25lCi0gbWFwcGluZ3MKLSBtZW51cwotIGV0Yy4KClNjcmlwdCB2YXJpYWJsZXMgY2FuIGJlIHVzZWQgdG8gYXZvaWQgY29uZmxpY3RzIHdpdGggZ2xvYmFsIHZhcmlhYmxlIG5hbWVzLgpUYWtlIHRoaXMgZXhhbXBsZTogPgoKCWxldCBzOmNvdW50ZXIgPSAwCglmdW5jdGlvbiBNeUNvdW50ZXIoKQoJICBsZXQgczpjb3VudGVyID0gczpjb3VudGVyICsgMQoJICBlY2hvIHM6Y291bnRlcgoJZW5kZnVuY3Rpb24KCWNvbW1hbmQgVGljayBjYWxsIE15Q291bnRlcigpCgpZb3UgY2FuIG5vdyBpbnZva2UgIlRpY2siIGZyb20gYW55IHNjcmlwdCwgYW5kIHRoZSAiczpjb3VudGVyIiB2YXJpYWJsZSBpbgp0aGF0IHNjcmlwdCB3aWxsIG5vdCBiZSBjaGFuZ2VkLCBvbmx5IHRoZSAiczpjb3VudGVyIiBpbiB0aGUgc2NyaXB0IHdoZXJlCiJUaWNrIiB3YXMgZGVmaW5lZCBpcyB1c2VkLgoKQW5vdGhlciBleGFtcGxlIHRoYXQgZG9lcyB0aGUgc2FtZTogPgoKCWxldCBzOmNvdW50ZXIgPSAwCgljb21tYW5kIFRpY2sgbGV0IHM6Y291bnRlciA9IHM6Y291bnRlciArIDEgfCBlY2hvIHM6Y291bnRlcgoKV2hlbiBjYWxsaW5nIGEgZnVuY3Rpb24gYW5kIGludm9raW5nIGEgdXNlci1kZWZpbmVkIGNvbW1hbmQsIHRoZSBjb250ZXh0IGZvcgpzY3JpcHQgdmFyaWFibGVzIGlzIHNldCB0byB0aGUgc2NyaXB0IHdoZXJlIHRoZSBmdW5jdGlvbiBvciBjb21tYW5kIHdhcwpkZWZpbmVkLgoKVGhlIHNjcmlwdCB2YXJpYWJsZXMgYXJlIGFsc28gYXZhaWxhYmxlIHdoZW4gYSBmdW5jdGlvbiBpcyBkZWZpbmVkIGluc2lkZSBhCmZ1bmN0aW9uIHRoYXQgaXMgZGVmaW5lZCBpbiBhIHNjcmlwdC4gIEV4YW1wbGU6ID4KCglsZXQgczpjb3VudGVyID0gMAoJZnVuY3Rpb24gU3RhcnRDb3VudGluZyhpbmNyKQoJICBpZiBhOmluY3IKCSAgICBmdW5jdGlvbiBNeUNvdW50ZXIoKQoJICAgICAgbGV0IHM6Y291bnRlciA9IHM6Y291bnRlciArIDEKCSAgICBlbmRmdW5jdGlvbgoJICBlbHNlCgkgICAgZnVuY3Rpb24gTXlDb3VudGVyKCkKCSAgICAgIGxldCBzOmNvdW50ZXIgPSBzOmNvdW50ZXIgLSAxCgkgICAgZW5kZnVuY3Rpb24KCSAgZW5kaWYKCWVuZGZ1bmN0aW9uCgpUaGlzIGRlZmluZXMgdGhlIE15Q291bnRlcigpIGZ1bmN0aW9uIGVpdGhlciBmb3IgY291bnRpbmcgdXAgb3IgY291bnRpbmcgZG93bgp3aGVuIGNhbGxpbmcgU3RhcnRDb3VudGluZygpLiAgSXQgZG9lc24ndCBtYXR0ZXIgZnJvbSB3aGVyZSBTdGFydENvdW50aW5nKCkgaXMKY2FsbGVkLCB0aGUgczpjb3VudGVyIHZhcmlhYmxlIHdpbGwgYmUgYWNjZXNzaWJsZSBpbiBNeUNvdW50ZXIoKS4KCldoZW4gdGhlIHNhbWUgc2NyaXB0IGlzIHNvdXJjZWQgYWdhaW4gaXQgd2lsbCB1c2UgdGhlIHNhbWUgc2NyaXB0IHZhcmlhYmxlcy4KVGhleSB3aWxsIHJlbWFpbiB2YWxpZCBhcyBsb25nIGFzIFZpbSBpcyBydW5uaW5nLiAgVGhpcyBjYW4gYmUgdXNlZCB0bwptYWludGFpbiBhIGNvdW50ZXI6ID4KCglpZiAhZXhpc3RzKCJzOmNvdW50ZXIiKQoJICBsZXQgczpjb3VudGVyID0gMQoJICBlY2hvICJzY3JpcHQgZXhlY3V0ZWQgZm9yIHRoZSBmaXJzdCB0aW1lIgoJZWxzZQoJICBsZXQgczpjb3VudGVyID0gczpjb3VudGVyICsgMQoJICBlY2hvICJzY3JpcHQgZXhlY3V0ZWQgIiAuIHM6Y291bnRlciAuICIgdGltZXMgbm93IgoJZW5kaWYKCk5vdGUgdGhhdCB0aGlzIG1lYW5zIHRoYXQgZmlsZXR5cGUgcGx1Z2lucyBkb24ndCBnZXQgYSBkaWZmZXJlbnQgc2V0IG9mIHNjcmlwdAp2YXJpYWJsZXMgZm9yIGVhY2ggYnVmZmVyLiAgVXNlIGxvY2FsIGJ1ZmZlciB2YXJpYWJsZXMgaW5zdGVhZCB8Yjp2YXJ8LgoKClByZWRlZmluZWQgVmltIHZhcmlhYmxlczoJCQkqdmltLXZhcmlhYmxlKiAqdjp2YXIqCgoJCQkJCSp2OmJldmFsX2NvbCogKmJldmFsX2NvbC12YXJpYWJsZSoKdjpiZXZhbF9jb2wJVGhlIG51bWJlciBvZiB0aGUgY29sdW1uLCBvdmVyIHdoaWNoIHRoZSBtb3VzZSBwb2ludGVyIGlzLgoJCVRoaXMgaXMgdGhlIGJ5dGUgaW5kZXggaW4gdGhlIHx2OmJldmFsX2xudW18IGxpbmUuCgkJT25seSB2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnYmFsbG9vbmV4cHInIG9wdGlvbi4KCgkJCQkJKnY6YmV2YWxfYnVmbnIqICpiZXZhbF9idWZuci12YXJpYWJsZSoKdjpiZXZhbF9idWZucglUaGUgbnVtYmVyIG9mIHRoZSBidWZmZXIsIG92ZXIgd2hpY2ggdGhlIG1vdXNlIHBvaW50ZXIgaXMuIE9ubHkKCQl2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnYmFsbG9vbmV4cHInIG9wdGlvbi4KCgkJCQkJKnY6YmV2YWxfbG51bSogKmJldmFsX2xudW0tdmFyaWFibGUqCnY6YmV2YWxfbG51bQlUaGUgbnVtYmVyIG9mIHRoZSBsaW5lLCBvdmVyIHdoaWNoIHRoZSBtb3VzZSBwb2ludGVyIGlzLiBPbmx5CgkJdmFsaWQgd2hpbGUgZXZhbHVhdGluZyB0aGUgJ2JhbGxvb25leHByJyBvcHRpb24uCgoJCQkJCSp2OmJldmFsX3RleHQqICpiZXZhbF90ZXh0LXZhcmlhYmxlKgp2OmJldmFsX3RleHQJVGhlIHRleHQgdW5kZXIgb3IgYWZ0ZXIgdGhlIG1vdXNlIHBvaW50ZXIuICBVc3VhbGx5IGEgd29yZCBhcwoJCWl0IGlzIHVzZWZ1bCBmb3IgZGVidWdnaW5nIGEgQyBwcm9ncmFtLiAgJ2lza2V5d29yZCcgYXBwbGllcywKCQlidXQgYSBkb3QgYW5kICItPiIgYmVmb3JlIHRoZSBwb3NpdGlvbiBpcyBpbmNsdWRlZC4gIFdoZW4gb24gYQoJCSddJyB0aGUgdGV4dCBiZWZvcmUgaXQgaXMgdXNlZCwgaW5jbHVkaW5nIHRoZSBtYXRjaGluZyAnWycgYW5kCgkJd29yZCBiZWZvcmUgaXQuICBXaGVuIG9uIGEgVmlzdWFsIGFyZWEgd2l0aGluIG9uZSBsaW5lIHRoZQoJCWhpZ2hsaWdodGVkIHRleHQgaXMgdXNlZC4KCQlPbmx5IHZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgb3B0aW9uLgoKCQkJCQkqdjpiZXZhbF93aW5uciogKmJldmFsX3dpbm5yLXZhcmlhYmxlKgp2OmJldmFsX3dpbm5yCVRoZSBudW1iZXIgb2YgdGhlIHdpbmRvdywgb3ZlciB3aGljaCB0aGUgbW91c2UgcG9pbnRlciBpcy4gT25seQoJCXZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgb3B0aW9uLiAgVGhlIGZpcnN0CgkJd2luZG93IGhhcyBudW1iZXIgemVybyAodW5saWtlIG1vc3Qgb3RoZXIgcGxhY2VzIHdoZXJlIGEKCQl3aW5kb3cgZ2V0cyBhIG51bWJlcikuCgoJCQkJCSp2OmNoYXIqICpjaGFyLXZhcmlhYmxlKgp2OmNoYXIJCUFyZ3VtZW50IGZvciBldmFsdWF0aW5nICdmb3JtYXRleHByJyBhbmQgdXNlZCBmb3IgdGhlIHR5cGVkCgkJY2hhcmFjdGVyIHdoZW4gdXNpbmcgPGV4cHI+IGluIGFuIGFiYnJldmlhdGlvbiB8Om1hcC08ZXhwcj58LgoJCUl0IGlzIGFsc28gdXNlZCBieSB0aGUgfEluc2VydENoYXJQcmV8IGV2ZW50LgoKCQkJKnY6Y2hhcmNvbnZlcnRfZnJvbSogKmNoYXJjb252ZXJ0X2Zyb20tdmFyaWFibGUqCnY6Y2hhcmNvbnZlcnRfZnJvbQoJCVRoZSBuYW1lIG9mIHRoZSBjaGFyYWN0ZXIgZW5jb2Rpbmcgb2YgYSBmaWxlIHRvIGJlIGNvbnZlcnRlZC4KCQlPbmx5IHZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdjaGFyY29udmVydCcgb3B0aW9uLgoKCQkJKnY6Y2hhcmNvbnZlcnRfdG8qICpjaGFyY29udmVydF90by12YXJpYWJsZSoKdjpjaGFyY29udmVydF90bwoJCVRoZSBuYW1lIG9mIHRoZSBjaGFyYWN0ZXIgZW5jb2Rpbmcgb2YgYSBmaWxlIGFmdGVyIGNvbnZlcnNpb24uCgkJT25seSB2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnY2hhcmNvbnZlcnQnIG9wdGlvbi4KCgkJCQkJKnY6Y21kYXJnKiAqY21kYXJnLXZhcmlhYmxlKgp2OmNtZGFyZwlUaGlzIHZhcmlhYmxlIGlzIHVzZWQgZm9yIHR3byBwdXJwb3NlczoKCQkxLiBUaGUgZXh0cmEgYXJndW1lbnRzIGdpdmVuIHRvIGEgZmlsZSByZWFkL3dyaXRlIGNvbW1hbmQuCgkJICAgQ3VycmVudGx5IHRoZXNlIGFyZSAiKytlbmM9IiBhbmQgIisrZmY9Ii4gIFRoaXMgdmFyaWFibGUgaXMKCQkgICBzZXQgYmVmb3JlIGFuIGF1dG9jb21tYW5kIGV2ZW50IGZvciBhIGZpbGUgcmVhZC93cml0ZQoJCSAgIGNvbW1hbmQgaXMgdHJpZ2dlcmVkLiAgVGhlcmUgaXMgYSBsZWFkaW5nIHNwYWNlIHRvIG1ha2UgaXQKCQkgICBwb3NzaWJsZSB0byBhcHBlbmQgdGhpcyB2YXJpYWJsZSBkaXJlY3RseSBhZnRlciB0aGUKCQkgICByZWFkL3dyaXRlIGNvbW1hbmQuCU5vdGU6IFRoZSAiK2NtZCIgYXJndW1lbnQgaXNuJ3QKCQkgICBpbmNsdWRlZCBoZXJlLCBiZWNhdXNlIGl0IHdpbGwgYmUgZXhlY3V0ZWQgYW55d2F5LgoJCTIuIFdoZW4gcHJpbnRpbmcgYSBQb3N0U2NyaXB0IGZpbGUgd2l0aCAiOmhhcmRjb3B5IiB0aGlzIGlzCgkJICAgdGhlIGFyZ3VtZW50IGZvciB0aGUgIjpoYXJkY29weSIgY29tbWFuZC4gIFRoaXMgY2FuIGJlIHVzZWQKCQkgICBpbiAncHJpbnRleHByJy4KCgkJCQkJKnY6Y21kYmFuZyogKmNtZGJhbmctdmFyaWFibGUqCnY6Y21kYmFuZwlTZXQgbGlrZSB2OmNtZGFyZyBmb3IgYSBmaWxlIHJlYWQvd3JpdGUgY29tbWFuZC4gIFdoZW4gYSAiISIKCQl3YXMgdXNlZCB0aGUgdmFsdWUgaXMgMSwgb3RoZXJ3aXNlIGl0IGlzIDAuICBOb3RlIHRoYXQgdGhpcwoJCWNhbiBvbmx5IGJlIHVzZWQgaW4gYXV0b2NvbW1hbmRzLiAgRm9yIHVzZXIgY29tbWFuZHMgfDxiYW5nPnwKCQljYW4gYmUgdXNlZC4KCgkJCQkJKnY6Y291bnQqICpjb3VudC12YXJpYWJsZSoKdjpjb3VudAkJVGhlIGNvdW50IGdpdmVuIGZvciB0aGUgbGFzdCBOb3JtYWwgbW9kZSBjb21tYW5kLiAgQ2FuIGJlIHVzZWQKCQl0byBnZXQgdGhlIGNvdW50IGJlZm9yZSBhIG1hcHBpbmcuICBSZWFkLW9ubHkuCUV4YW1wbGU6ID4KCTptYXAgX3ggOjxDLVU+ZWNobyAidGhlIGNvdW50IGlzICIgLiB2OmNvdW50PENSPgo8CQlOb3RlOiBUaGUgPEMtVT4gaXMgcmVxdWlyZWQgdG8gcmVtb3ZlIHRoZSBsaW5lIHJhbmdlIHRoYXQgeW91CgkJZ2V0IHdoZW4gdHlwaW5nICc6JyBhZnRlciBhIGNvdW50LgoJCVdoZW4gdGhlcmUgYXJlIHR3byBjb3VudHMsIGFzIGluICIzZDJ3IiwgdGhleSBhcmUgbXVsdGlwbGllZCwKCQlqdXN0IGxpa2Ugd2hhdCBoYXBwZW5zIGluIHRoZSBjb21tYW5kLCAiZDZ3IiBmb3IgdGhlIGV4YW1wbGUuCgkJQWxzbyB1c2VkIGZvciBldmFsdWF0aW5nIHRoZSAnZm9ybWF0ZXhwcicgb3B0aW9uLgoJCSJjb3VudCIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjpjb3VudDEqICpjb3VudDEtdmFyaWFibGUqCnY6Y291bnQxCUp1c3QgbGlrZSAidjpjb3VudCIsIGJ1dCBkZWZhdWx0cyB0byBvbmUgd2hlbiBubyBjb3VudCBpcwoJCXVzZWQuCgoJCQkJCQkqdjpjdHlwZSogKmN0eXBlLXZhcmlhYmxlKgp2OmN0eXBlCQlUaGUgY3VycmVudCBsb2NhbGUgc2V0dGluZyBmb3IgY2hhcmFjdGVycyBvZiB0aGUgcnVudGltZQoJCWVudmlyb25tZW50LiAgVGhpcyBhbGxvd3MgVmltIHNjcmlwdHMgdG8gYmUgYXdhcmUgb2YgdGhlCgkJY3VycmVudCBsb2NhbGUgZW5jb2RpbmcuICBUZWNobmljYWw6IGl0J3MgdGhlIHZhbHVlIG9mCgkJTENfQ1RZUEUuICBXaGVuIG5vdCB1c2luZyBhIGxvY2FsZSB0aGUgdmFsdWUgaXMgIkMiLgoJCVRoaXMgdmFyaWFibGUgY2FuIG5vdCBiZSBzZXQgZGlyZWN0bHksIHVzZSB0aGUgfDpsYW5ndWFnZXwKCQljb21tYW5kLgoJCVNlZSB8bXVsdGktbGFuZ3wuCgoJCQkJCSp2OmR5aW5nKiAqZHlpbmctdmFyaWFibGUqCnY6ZHlpbmcJCU5vcm1hbGx5IHplcm8uCVdoZW4gYSBkZWFkbHkgc2lnbmFsIGlzIGNhdWdodCBpdCdzIHNldCB0bwoJCW9uZS4gIFdoZW4gbXVsdGlwbGUgc2lnbmFscyBhcmUgY2F1Z2h0IHRoZSBudW1iZXIgaW5jcmVhc2VzLgoJCUNhbiBiZSB1c2VkIGluIGFuIGF1dG9jb21tYW5kIHRvIGNoZWNrIGlmIFZpbSBkaWRuJ3QKCQl0ZXJtaW5hdGUgbm9ybWFsbHkuIHtvbmx5IHdvcmtzIG9uIFVuaXh9CgkJRXhhbXBsZTogPgoJOmF1IFZpbUxlYXZlICogaWYgdjpkeWluZyB8IGVjaG8gIlxuQUFBQWFhYWFycnJnZ2doaGhoISEhXG4iIHwgZW5kaWYKPAkJTm90ZTogaWYgYW5vdGhlciBkZWFkbHkgc2lnbmFsIGlzIGNhdWdodCB3aGVuIHY6ZHlpbmcgaXMgb25lLAoJCVZpbUxlYXZlIGF1dG9jb21tYW5kcyB3aWxsIG5vdCBiZSBleGVjdXRlZC4KCgkJCQkJKnY6ZXJybXNnKiAqZXJybXNnLXZhcmlhYmxlKgp2OmVycm1zZwlMYXN0IGdpdmVuIGVycm9yIG1lc3NhZ2UuICBJdCdzIGFsbG93ZWQgdG8gc2V0IHRoaXMgdmFyaWFibGUuCgkJRXhhbXBsZTogPgoJOmxldCB2OmVycm1zZyA9ICIiCgk6c2lsZW50ISBuZXh0Cgk6aWYgdjplcnJtc2cgIT0gIiIKCTogIC4uLiBoYW5kbGUgZXJyb3IKPAkJImVycm1zZyIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjpleGNlcHRpb24qICpleGNlcHRpb24tdmFyaWFibGUqCnY6ZXhjZXB0aW9uCVRoZSB2YWx1ZSBvZiB0aGUgZXhjZXB0aW9uIG1vc3QgcmVjZW50bHkgY2F1Z2h0IGFuZCBub3QKCQlmaW5pc2hlZC4gIFNlZSBhbHNvIHx2OnRocm93cG9pbnR8IGFuZCB8dGhyb3ctdmFyaWFibGVzfC4KCQlFeGFtcGxlOiA+Cgk6dHJ5Cgk6ICB0aHJvdyAib29wcyIKCTpjYXRjaCAvLiovCgk6ICBlY2hvICJjYXVnaHQiIHY6ZXhjZXB0aW9uCgk6ZW5kdHJ5CjwJCU91dHB1dDogImNhdWdodCBvb3BzIi4KCgkJCQkJKnY6ZmNzX3JlYXNvbiogKmZjc19yZWFzb24tdmFyaWFibGUqCnY6ZmNzX3JlYXNvbglUaGUgcmVhc29uIHdoeSB0aGUgfEZpbGVDaGFuZ2VkU2hlbGx8IGV2ZW50IHdhcyB0cmlnZ2VyZWQuCgkJQ2FuIGJlIHVzZWQgaW4gYW4gYXV0b2NvbW1hbmQgdG8gZGVjaWRlIHdoYXQgdG8gZG8gYW5kL29yIHdoYXQKCQl0byBzZXQgdjpmY3NfY2hvaWNlIHRvLiAgUG9zc2libGUgdmFsdWVzOgoJCQlkZWxldGVkCQlmaWxlIG5vIGxvbmdlciBleGlzdHMKCQkJY29uZmxpY3QJZmlsZSBjb250ZW50cywgbW9kZSBvciB0aW1lc3RhbXAgd2FzCgkJCQkJY2hhbmdlZCBhbmQgYnVmZmVyIGlzIG1vZGlmaWVkCgkJCWNoYW5nZWQJCWZpbGUgY29udGVudHMgaGFzIGNoYW5nZWQKCQkJbW9kZQkJbW9kZSBvZiBmaWxlIGNoYW5nZWQKCQkJdGltZQkJb25seSBmaWxlIHRpbWVzdGFtcCBjaGFuZ2VkCgoJCQkJCSp2OmZjc19jaG9pY2UqICpmY3NfY2hvaWNlLXZhcmlhYmxlKgp2OmZjc19jaG9pY2UJV2hhdCBzaG91bGQgaGFwcGVuIGFmdGVyIGEgfEZpbGVDaGFuZ2VkU2hlbGx8IGV2ZW50IHdhcwoJCXRyaWdnZXJlZC4gIENhbiBiZSB1c2VkIGluIGFuIGF1dG9jb21tYW5kIHRvIHRlbGwgVmltIHdoYXQgdG8KCQlkbyB3aXRoIHRoZSBhZmZlY3RlZCBidWZmZXI6CgkJCXJlbG9hZAkJUmVsb2FkIHRoZSBidWZmZXIgKGRvZXMgbm90IHdvcmsgaWYKCQkJCQl0aGUgZmlsZSB3YXMgZGVsZXRlZCkuCgkJCWFzawkJQXNrIHRoZSB1c2VyIHdoYXQgdG8gZG8sIGFzIGlmIHRoZXJlCgkJCQkJd2FzIG5vIGF1dG9jb21tYW5kLiAgRXhjZXB0IHRoYXQgd2hlbgoJCQkJCW9ubHkgdGhlIHRpbWVzdGFtcCBjaGFuZ2VkIG5vdGhpbmcKCQkJCQl3aWxsIGhhcHBlbi4KCQkJPGVtcHR5PgkJTm90aGluZywgdGhlIGF1dG9jb21tYW5kIHNob3VsZCBkbwoJCQkJCWV2ZXJ5dGhpbmcgdGhhdCBuZWVkcyB0byBiZSBkb25lLgoJCVRoZSBkZWZhdWx0IGlzIGVtcHR5LiAgSWYgYW5vdGhlciAoaW52YWxpZCkgdmFsdWUgaXMgdXNlZCB0aGVuCgkJVmltIGJlaGF2ZXMgbGlrZSBpdCBpcyBlbXB0eSwgdGhlcmUgaXMgbm8gd2FybmluZyBtZXNzYWdlLgoKCQkJCQkqdjpmbmFtZV9pbiogKmZuYW1lX2luLXZhcmlhYmxlKgp2OmZuYW1lX2luCVRoZSBuYW1lIG9mIHRoZSBpbnB1dCBmaWxlLiAgVmFsaWQgd2hpbGUgZXZhbHVhdGluZzoKCQkJb3B0aW9uCQl1c2VkIGZvciB+CgkJCSdjaGFyY29udmVydCcJZmlsZSB0byBiZSBjb252ZXJ0ZWQKCQkJJ2RpZmZleHByJwlvcmlnaW5hbCBmaWxlCgkJCSdwYXRjaGV4cHInCW9yaWdpbmFsIGZpbGUKCQkJJ3ByaW50ZXhwcicJZmlsZSB0byBiZSBwcmludGVkCgkJQW5kIHNldCB0byB0aGUgc3dhcCBmaWxlIG5hbWUgZm9yIHxTd2FwRXhpc3RzfC4KCgkJCQkJKnY6Zm5hbWVfb3V0KiAqZm5hbWVfb3V0LXZhcmlhYmxlKgp2OmZuYW1lX291dAlUaGUgbmFtZSBvZiB0aGUgb3V0cHV0IGZpbGUuICBPbmx5IHZhbGlkIHdoaWxlCgkJZXZhbHVhdGluZzoKCQkJb3B0aW9uCQl1c2VkIGZvciB+CgkJCSdjaGFyY29udmVydCcJcmVzdWx0aW5nIGNvbnZlcnRlZCBmaWxlICgqKQoJCQknZGlmZmV4cHInCW91dHB1dCBvZiBkaWZmCgkJCSdwYXRjaGV4cHInCXJlc3VsdGluZyBwYXRjaGVkIGZpbGUKCQkoKikgV2hlbiBkb2luZyBjb252ZXJzaW9uIGZvciBhIHdyaXRlIGNvbW1hbmQgKGUuZy4sICI6dwoJCWZpbGUiKSBpdCB3aWxsIGJlIGVxdWFsIHRvIHY6Zm5hbWVfaW4uCVdoZW4gZG9pbmcgY29udmVyc2lvbgoJCWZvciBhIHJlYWQgY29tbWFuZCAoZS5nLiwgIjplIGZpbGUiKSBpdCB3aWxsIGJlIGEgdGVtcG9yYXJ5CgkJZmlsZSBhbmQgZGlmZmVyZW50IGZyb20gdjpmbmFtZV9pbi4KCgkJCQkJKnY6Zm5hbWVfbmV3KiAqZm5hbWVfbmV3LXZhcmlhYmxlKgp2OmZuYW1lX25ldwlUaGUgbmFtZSBvZiB0aGUgbmV3IHZlcnNpb24gb2YgdGhlIGZpbGUuICBPbmx5IHZhbGlkIHdoaWxlCgkJZXZhbHVhdGluZyAnZGlmZmV4cHInLgoKCQkJCQkqdjpmbmFtZV9kaWZmKiAqZm5hbWVfZGlmZi12YXJpYWJsZSoKdjpmbmFtZV9kaWZmCVRoZSBuYW1lIG9mIHRoZSBkaWZmIChwYXRjaCkgZmlsZS4gIE9ubHkgdmFsaWQgd2hpbGUKCQlldmFsdWF0aW5nICdwYXRjaGV4cHInLgoKCQkJCQkqdjpmb2xkZGFzaGVzKiAqZm9sZGRhc2hlcy12YXJpYWJsZSoKdjpmb2xkZGFzaGVzCVVzZWQgZm9yICdmb2xkdGV4dCc6IGRhc2hlcyByZXByZXNlbnRpbmcgZm9sZGxldmVsIG9mIGEgY2xvc2VkCgkJZm9sZC4KCQlSZWFkLW9ubHkgaW4gdGhlIHxzYW5kYm94fC4gfGZvbGQtZm9sZHRleHR8CgoJCQkJCSp2OmZvbGRsZXZlbCogKmZvbGRsZXZlbC12YXJpYWJsZSoKdjpmb2xkbGV2ZWwJVXNlZCBmb3IgJ2ZvbGR0ZXh0JzogZm9sZGxldmVsIG9mIGNsb3NlZCBmb2xkLgoJCVJlYWQtb25seSBpbiB0aGUgfHNhbmRib3h8LiB8Zm9sZC1mb2xkdGV4dHwKCgkJCQkJKnY6Zm9sZGVuZCogKmZvbGRlbmQtdmFyaWFibGUqCnY6Zm9sZGVuZAlVc2VkIGZvciAnZm9sZHRleHQnOiBsYXN0IGxpbmUgb2YgY2xvc2VkIGZvbGQuCgkJUmVhZC1vbmx5IGluIHRoZSB8c2FuZGJveHwuIHxmb2xkLWZvbGR0ZXh0fAoKCQkJCQkqdjpmb2xkc3RhcnQqICpmb2xkc3RhcnQtdmFyaWFibGUqCnY6Zm9sZHN0YXJ0CVVzZWQgZm9yICdmb2xkdGV4dCc6IGZpcnN0IGxpbmUgb2YgY2xvc2VkIGZvbGQuCgkJUmVhZC1vbmx5IGluIHRoZSB8c2FuZGJveHwuIHxmb2xkLWZvbGR0ZXh0fAoKCQkJCQkqdjppbnNlcnRtb2RlKiAqaW5zZXJ0bW9kZS12YXJpYWJsZSoKdjppbnNlcnRtb2RlCVVzZWQgZm9yIHRoZSB8SW5zZXJ0RW50ZXJ8IGFuZCB8SW5zZXJ0Q2hhbmdlfCBhdXRvY29tbWFuZAoJCWV2ZW50cy4gIFZhbHVlczoKCQkJaQlJbnNlcnQgbW9kZQoJCQlyCVJlcGxhY2UgbW9kZQoJCQl2CVZpcnR1YWwgUmVwbGFjZSBtb2RlCgoJCQkJCQkqdjprZXkqICprZXktdmFyaWFibGUqCnY6a2V5CQlLZXkgb2YgdGhlIGN1cnJlbnQgaXRlbSBvZiBhIHxEaWN0aW9uYXJ5fC4gIE9ubHkgdmFsaWQgd2hpbGUKCQlldmFsdWF0aW5nIHRoZSBleHByZXNzaW9uIHVzZWQgd2l0aCB8bWFwKCl8IGFuZCB8ZmlsdGVyKCl8LgoJCVJlYWQtb25seS4KCgkJCQkJCSp2OmxhbmcqICpsYW5nLXZhcmlhYmxlKgp2OmxhbmcJCVRoZSBjdXJyZW50IGxvY2FsZSBzZXR0aW5nIGZvciBtZXNzYWdlcyBvZiB0aGUgcnVudGltZQoJCWVudmlyb25tZW50LiAgVGhpcyBhbGxvd3MgVmltIHNjcmlwdHMgdG8gYmUgYXdhcmUgb2YgdGhlCgkJY3VycmVudCBsYW5ndWFnZS4gIFRlY2huaWNhbDogaXQncyB0aGUgdmFsdWUgb2YgTENfTUVTU0FHRVMuCgkJVGhlIHZhbHVlIGlzIHN5c3RlbSBkZXBlbmRlbnQuCgkJVGhpcyB2YXJpYWJsZSBjYW4gbm90IGJlIHNldCBkaXJlY3RseSwgdXNlIHRoZSB8Omxhbmd1YWdlfAoJCWNvbW1hbmQuCgkJSXQgY2FuIGJlIGRpZmZlcmVudCBmcm9tIHx2OmN0eXBlfCB3aGVuIG1lc3NhZ2VzIGFyZSBkZXNpcmVkCgkJaW4gYSBkaWZmZXJlbnQgbGFuZ3VhZ2UgdGhhbiB3aGF0IGlzIHVzZWQgZm9yIGNoYXJhY3RlcgoJCWVuY29kaW5nLiAgU2VlIHxtdWx0aS1sYW5nfC4KCgkJCQkJCSp2OmxjX3RpbWUqICpsY190aW1lLXZhcmlhYmxlKgp2OmxjX3RpbWUJVGhlIGN1cnJlbnQgbG9jYWxlIHNldHRpbmcgZm9yIHRpbWUgbWVzc2FnZXMgb2YgdGhlIHJ1bnRpbWUKCQllbnZpcm9ubWVudC4gIFRoaXMgYWxsb3dzIFZpbSBzY3JpcHRzIHRvIGJlIGF3YXJlIG9mIHRoZQoJCWN1cnJlbnQgbGFuZ3VhZ2UuICBUZWNobmljYWw6IGl0J3MgdGhlIHZhbHVlIG9mIExDX1RJTUUuCgkJVGhpcyB2YXJpYWJsZSBjYW4gbm90IGJlIHNldCBkaXJlY3RseSwgdXNlIHRoZSB8Omxhbmd1YWdlfAoJCWNvbW1hbmQuICBTZWUgfG11bHRpLWxhbmd8LgoKCQkJCQkJKnY6bG51bSogKmxudW0tdmFyaWFibGUqCnY6bG51bQkJTGluZSBudW1iZXIgZm9yIHRoZSAnZm9sZGV4cHInIHxmb2xkLWV4cHJ8LCAnZm9ybWF0ZXhwcicgYW5kCgkJJ2luZGVudGV4cHInIGV4cHJlc3Npb25zLCB0YWIgcGFnZSBudW1iZXIgZm9yICdndWl0YWJsYWJlbCcKCQlhbmQgJ2d1aXRhYnRvb2x0aXAnLiAgT25seSB2YWxpZCB3aGlsZSBvbmUgb2YgdGhlc2UKCQlleHByZXNzaW9ucyBpcyBiZWluZyBldmFsdWF0ZWQuICBSZWFkLW9ubHkgd2hlbiBpbiB0aGUKCQl8c2FuZGJveHwuCgoJCQkJCSp2Om1vdXNlX3dpbiogKm1vdXNlX3dpbi12YXJpYWJsZSoKdjptb3VzZV93aW4JV2luZG93IG51bWJlciBmb3IgYSBtb3VzZSBjbGljayBvYnRhaW5lZCB3aXRoIHxnZXRjaGFyKCl8LgoJCUZpcnN0IHdpbmRvdyBoYXMgbnVtYmVyIDEsIGxpa2Ugd2l0aCB8d2lubnIoKXwuICBUaGUgdmFsdWUgaXMKCQl6ZXJvIHdoZW4gdGhlcmUgd2FzIG5vIG1vdXNlIGJ1dHRvbiBjbGljay4KCgkJCQkJKnY6bW91c2VfbG51bSogKm1vdXNlX2xudW0tdmFyaWFibGUqCnY6bW91c2VfbG51bQlMaW5lIG51bWJlciBmb3IgYSBtb3VzZSBjbGljayBvYnRhaW5lZCB3aXRoIHxnZXRjaGFyKCl8LgoJCVRoaXMgaXMgdGhlIHRleHQgbGluZSBudW1iZXIsIG5vdCB0aGUgc2NyZWVuIGxpbmUgbnVtYmVyLiAgVGhlCgkJdmFsdWUgaXMgemVybyB3aGVuIHRoZXJlIHdhcyBubyBtb3VzZSBidXR0b24gY2xpY2suCgoJCQkJCSp2Om1vdXNlX2NvbCogKm1vdXNlX2NvbC12YXJpYWJsZSoKdjptb3VzZV9jb2wJQ29sdW1uIG51bWJlciBmb3IgYSBtb3VzZSBjbGljayBvYnRhaW5lZCB3aXRoIHxnZXRjaGFyKCl8LgoJCVRoaXMgaXMgdGhlIHNjcmVlbiBjb2x1bW4gbnVtYmVyLCBsaWtlIHdpdGggfHZpcnRjb2woKXwuICBUaGUKCQl2YWx1ZSBpcyB6ZXJvIHdoZW4gdGhlcmUgd2FzIG5vIG1vdXNlIGJ1dHRvbiBjbGljay4KCgkJCQkJKnY6b2xkZmlsZXMqICpvbGRmaWxlcy12YXJpYWJsZSoKdjpvbGRmaWxlcwlMaXN0IG9mIGZpbGUgbmFtZXMgdGhhdCBpcyBsb2FkZWQgZnJvbSB0aGUgfHZpbWluZm98IGZpbGUgb24KCQlzdGFydHVwLiAgVGhlc2UgYXJlIHRoZSBmaWxlcyB0aGF0IFZpbSByZW1lbWJlcnMgbWFya3MgZm9yLgoJCVRoZSBsZW5ndGggb2YgdGhlIExpc3QgaXMgbGltaXRlZCBieSB0aGUgJyBhcmd1bWVudCBvZiB0aGUKCQkndmltaW5mbycgb3B0aW9uIChkZWZhdWx0IGlzIDEwMCkuCgkJQWxzbyBzZWUgfDpvbGRmaWxlc3wgYW5kIHxjXyM8fC4KCQlUaGUgTGlzdCBjYW4gYmUgbW9kaWZpZWQsIGJ1dCB0aGlzIGhhcyBubyBlZmZlY3Qgb24gd2hhdCBpcwoJCXN0b3JlZCBpbiB0aGUgfHZpbWluZm98IGZpbGUgbGF0ZXIuICBJZiB5b3UgdXNlIHZhbHVlcyBvdGhlcgoJCXRoYW4gU3RyaW5nIHRoaXMgd2lsbCBjYXVzZSB0cm91YmxlLgoJCXtvbmx5IHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCt2aW1pbmZvfCBmZWF0dXJlfQoKCQkJCQkqdjpvcGVyYXRvciogKm9wZXJhdG9yLXZhcmlhYmxlKgp2Om9wZXJhdG9yCVRoZSBsYXN0IG9wZXJhdG9yIGdpdmVuIGluIE5vcm1hbCBtb2RlLiAgVGhpcyBpcyBhIHNpbmdsZQoJCWNoYXJhY3RlciBleGNlcHQgZm9yIGNvbW1hbmRzIHN0YXJ0aW5nIHdpdGggPGc+IG9yIDx6PiwKCQlpbiB3aGljaCBjYXNlIGl0IGlzIHR3byBjaGFyYWN0ZXJzLiAgQmVzdCB1c2VkIGFsb25nc2lkZQoJCXx2OnByZXZjb3VudHwgYW5kIHx2OnJlZ2lzdGVyfC4gIFVzZWZ1bCBpZiB5b3Ugd2FudCB0byBjYW5jZWwKCQlPcGVyYXRvci1wZW5kaW5nIG1vZGUgYW5kIHRoZW4gdXNlIHRoZSBvcGVyYXRvciwgZS5nLjogPgoJCQk6b21hcCBPIDxFc2M+OmNhbGwgTXlNb3Rpb24odjpvcGVyYXRvcik8Q1I+CjwJCVRoZSB2YWx1ZSByZW1haW5zIHNldCB1bnRpbCBhbm90aGVyIG9wZXJhdG9yIGlzIGVudGVyZWQsIHRodXMKCQlkb24ndCBleHBlY3QgaXQgdG8gYmUgZW1wdHkuCgkJdjpvcGVyYXRvciBpcyBub3Qgc2V0IGZvciB8OmRlbGV0ZXwsIHw6eWFua3wgb3Igb3RoZXIgRXgKCQljb21tYW5kcy4KCQlSZWFkLW9ubHkuCgoJCQkJCSp2OnByZXZjb3VudCogKnByZXZjb3VudC12YXJpYWJsZSoKdjpwcmV2Y291bnQJVGhlIGNvdW50IGdpdmVuIGZvciB0aGUgbGFzdCBidXQgb25lIE5vcm1hbCBtb2RlIGNvbW1hbmQuCgkJVGhpcyBpcyB0aGUgdjpjb3VudCB2YWx1ZSBvZiB0aGUgcHJldmlvdXMgY29tbWFuZC4gIFVzZWZ1bCBpZgoJCXlvdSB3YW50IHRvIGNhbmNlbCBWaXN1YWwgb3IgT3BlcmF0b3ItcGVuZGluZyBtb2RlIGFuZCB0aGVuCgkJdXNlIHRoZSBjb3VudCwgZS5nLjogPgoJCQk6dm1hcCAlIDxFc2M+OmNhbGwgTXlGaWx0ZXIodjpwcmV2Y291bnQpPENSPgo8CQlSZWFkLW9ubHkuCgoJCQkJCSp2OnByb2ZpbGluZyogKnByb2ZpbGluZy12YXJpYWJsZSoKdjpwcm9maWxpbmcJTm9ybWFsbHkgemVyby4JU2V0IHRvIG9uZSBhZnRlciB1c2luZyAiOnByb2ZpbGUgc3RhcnQiLgoJCVNlZSB8cHJvZmlsaW5nfC4KCgkJCQkJKnY6cHJvZ25hbWUqICpwcm9nbmFtZS12YXJpYWJsZSoKdjpwcm9nbmFtZQlDb250YWlucyB0aGUgbmFtZSAod2l0aCBwYXRoIHJlbW92ZWQpIHdpdGggd2hpY2ggVmltIHdhcwoJCWludm9rZWQuICBBbGxvd3MgeW91IHRvIGRvIHNwZWNpYWwgaW5pdGlhbGlzYXRpb25zIGZvciAidmlldyIsCgkJImV2aW0iIGV0Yy4sIG9yIGFueSBvdGhlciBuYW1lIHlvdSBtaWdodCBzeW1saW5rIHRvIFZpbS4KCQlSZWFkLW9ubHkuCgoJCQkJCSp2OnJlZ2lzdGVyKiAqcmVnaXN0ZXItdmFyaWFibGUqCnY6cmVnaXN0ZXIJVGhlIG5hbWUgb2YgdGhlIHJlZ2lzdGVyIGluIGVmZmVjdCBmb3IgdGhlIGN1cnJlbnQgbm9ybWFsIG1vZGUKCQljb21tYW5kLiAgSWYgbm9uZSBpcyBzdXBwbGllZCBpdCBpcyB0aGUgZGVmYXVsdCByZWdpc3RlciAnIicsCgkJdW5sZXNzICdjbGlwYm9hcmQnIGNvbnRhaW5zICJ1bm5hbWVkIiBvciAidW5uYW1lZHBsdXMiLCB0aGVuCgkJaXQgaXMgJyonIG9yICcrJy4KCQlBbHNvIHNlZSB8Z2V0cmVnKCl8IGFuZCB8c2V0cmVnKCl8CgoJCQkJCSp2OnNjcm9sbHN0YXJ0KiAqc2Nyb2xsc3RhcnQtdmFyaWFibGUqCnY6c2Nyb2xsc3RhcnQJU3RyaW5nIGRlc2NyaWJpbmcgdGhlIHNjcmlwdCBvciBmdW5jdGlvbiB0aGF0IGNhdXNlZCB0aGUKCQlzY3JlZW4gdG8gc2Nyb2xsIHVwLiAgSXQncyBvbmx5IHNldCB3aGVuIGl0IGlzIGVtcHR5LCB0aHVzIHRoZQoJCWZpcnN0IHJlYXNvbiBpcyByZW1lbWJlcmVkLiAgSXQgaXMgc2V0IHRvICJVbmtub3duIiBmb3IgYQoJCXR5cGVkIGNvbW1hbmQuCgkJVGhpcyBjYW4gYmUgdXNlZCB0byBmaW5kIG91dCB3aHkgeW91ciBzY3JpcHQgY2F1c2VzIHRoZQoJCWhpdC1lbnRlciBwcm9tcHQuCgoJCQkJCSp2OnNlcnZlcm5hbWUqICpzZXJ2ZXJuYW1lLXZhcmlhYmxlKgp2OnNlcnZlcm5hbWUJVGhlIHJlc3VsdGluZyByZWdpc3RlcmVkIHx4MTEtY2xpZW50c2VydmVyfCBuYW1lIGlmIGFueS4KCQlSZWFkLW9ubHkuCgoJCQp2OnNlYXJjaGZvcndhcmQJCQkqdjpzZWFyY2hmb3J3YXJkKiAqc2VhcmNoZm9yd2FyZC12YXJpYWJsZSoKCQlTZWFyY2ggZGlyZWN0aW9uOiAgMSBhZnRlciBhIGZvcndhcmQgc2VhcmNoLCAwIGFmdGVyIGEKCQliYWNrd2FyZCBzZWFyY2guICBJdCBpcyByZXNldCB0byBmb3J3YXJkIHdoZW4gZGlyZWN0bHkgc2V0dGluZwoJCXRoZSBsYXN0IHNlYXJjaCBwYXR0ZXJuLCBzZWUgfHF1b3RlL3wuCgkJTm90ZSB0aGF0IHRoZSB2YWx1ZSBpcyByZXN0b3JlZCB3aGVuIHJldHVybmluZyBmcm9tIGEKCQlmdW5jdGlvbi4gfGZ1bmN0aW9uLXNlYXJjaC11bmRvfC4KCQlSZWFkLXdyaXRlLgoKCQkJCQkqdjpzaGVsbF9lcnJvciogKnNoZWxsX2Vycm9yLXZhcmlhYmxlKgp2OnNoZWxsX2Vycm9yCVJlc3VsdCBvZiB0aGUgbGFzdCBzaGVsbCBjb21tYW5kLiAgV2hlbiBub24temVybywgdGhlIGxhc3QKCQlzaGVsbCBjb21tYW5kIGhhZCBhbiBlcnJvci4gIFdoZW4gemVybywgdGhlcmUgd2FzIG5vIHByb2JsZW0uCgkJVGhpcyBvbmx5IHdvcmtzIHdoZW4gdGhlIHNoZWxsIHJldHVybnMgdGhlIGVycm9yIGNvZGUgdG8gVmltLgoJCVRoZSB2YWx1ZSAtMSBpcyBvZnRlbiB1c2VkIHdoZW4gdGhlIGNvbW1hbmQgY291bGQgbm90IGJlCgkJZXhlY3V0ZWQuICBSZWFkLW9ubHkuCgkJRXhhbXBsZTogPgoJOiFtdiBmb28gYmFyCgk6aWYgdjpzaGVsbF9lcnJvcgoJOiAgZWNobyAnY291bGQgbm90IHJlbmFtZSAiZm9vIiB0byAiYmFyIiEnCgk6ZW5kaWYKPAkJInNoZWxsX2Vycm9yIiBhbHNvIHdvcmtzLCBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkuCgoJCQkJCSp2OnN0YXR1c21zZyogKnN0YXR1c21zZy12YXJpYWJsZSoKdjpzdGF0dXNtc2cJTGFzdCBnaXZlbiBzdGF0dXMgbWVzc2FnZS4gIEl0J3MgYWxsb3dlZCB0byBzZXQgdGhpcyB2YXJpYWJsZS4KCgkJCQkJKnY6c3dhcG5hbWUqICpzd2FwbmFtZS12YXJpYWJsZSoKdjpzd2FwbmFtZQlPbmx5IHZhbGlkIHdoZW4gZXhlY3V0aW5nIHxTd2FwRXhpc3RzfCBhdXRvY29tbWFuZHM6IE5hbWUgb2YKCQl0aGUgc3dhcCBmaWxlIGZvdW5kLiAgUmVhZC1vbmx5LgoKCQkJCQkqdjpzd2FwY2hvaWNlKiAqc3dhcGNob2ljZS12YXJpYWJsZSoKdjpzd2FwY2hvaWNlCXxTd2FwRXhpc3RzfCBhdXRvY29tbWFuZHMgY2FuIHNldCB0aGlzIHRvIHRoZSBzZWxlY3RlZCBjaG9pY2UKCQlmb3IgaGFuZGxpbmcgYW4gZXhpc3Rpbmcgc3dhcCBmaWxlOgoJCQknbycJT3BlbiByZWFkLW9ubHkKCQkJJ2UnCUVkaXQgYW55d2F5CgkJCSdyJwlSZWNvdmVyCgkJCSdkJwlEZWxldGUgc3dhcGZpbGUKCQkJJ3EnCVF1aXQKCQkJJ2EnCUFib3J0CgkJVGhlIHZhbHVlIHNob3VsZCBiZSBhIHNpbmdsZS1jaGFyYWN0ZXIgc3RyaW5nLglBbiBlbXB0eSB2YWx1ZQoJCXJlc3VsdHMgaW4gdGhlIHVzZXIgYmVpbmcgYXNrZWQsIGFzIHdvdWxkIGhhcHBlbiB3aGVuIHRoZXJlIGlzCgkJbm8gU3dhcEV4aXN0cyBhdXRvY29tbWFuZC4gIFRoZSBkZWZhdWx0IGlzIGVtcHR5LgoKCQkJCQkqdjpzd2FwY29tbWFuZCogKnN3YXBjb21tYW5kLXZhcmlhYmxlKgp2OnN3YXBjb21tYW5kCU5vcm1hbCBtb2RlIGNvbW1hbmQgdG8gYmUgZXhlY3V0ZWQgYWZ0ZXIgYSBmaWxlIGhhcyBiZWVuCgkJb3BlbmVkLiAgQ2FuIGJlIHVzZWQgZm9yIGEgfFN3YXBFeGlzdHN8IGF1dG9jb21tYW5kIHRvIGhhdmUKCQlhbm90aGVyIFZpbSBvcGVuIHRoZSBmaWxlIGFuZCBqdW1wIHRvIHRoZSByaWdodCBwbGFjZS4JRm9yCgkJZXhhbXBsZSwgd2hlbiBqdW1waW5nIHRvIGEgdGFnIHRoZSB2YWx1ZSBpcyAiOnRhZyB0YWduYW1lXHIiLgoJCUZvciAiOmVkaXQgK2NtZCBmaWxlIiB0aGUgdmFsdWUgaXMgIjpjbWRcciIuCgoJCQkJKnY6dGVybXJlc3BvbnNlKiAqdGVybXJlc3BvbnNlLXZhcmlhYmxlKgp2OnRlcm1yZXNwb25zZQlUaGUgZXNjYXBlIHNlcXVlbmNlIHJldHVybmVkIGJ5IHRoZSB0ZXJtaW5hbCBmb3IgdGhlIHx0X1JWfAoJCXRlcm1jYXAgZW50cnkuCUl0IGlzIHNldCB3aGVuIFZpbSByZWNlaXZlcyBhbiBlc2NhcGUgc2VxdWVuY2UKCQl0aGF0IHN0YXJ0cyB3aXRoIEVTQyBbIG9yIENTSSBhbmQgZW5kcyBpbiBhICdjJywgd2l0aCBvbmx5CgkJZGlnaXRzLCAnOycgYW5kICcuJyBpbiBiZXR3ZWVuLgoJCVdoZW4gdGhpcyBvcHRpb24gaXMgc2V0LCB0aGUgVGVybVJlc3BvbnNlIGF1dG9jb21tYW5kIGV2ZW50IGlzCgkJZmlyZWQsIHNvIHRoYXQgeW91IGNhbiByZWFjdCB0byB0aGUgcmVzcG9uc2UgZnJvbSB0aGUKCQl0ZXJtaW5hbC4KCQlUaGUgcmVzcG9uc2UgZnJvbSBhIG5ldyB4dGVybSBpczogIjxFc2M+WyBQcCA7IFB2IDsgUGMgYyIuICBQcAoJCWlzIHRoZSB0ZXJtaW5hbCB0eXBlOiAwIGZvciB2dDEwMCBhbmQgMSBmb3IgdnQyMjAuICBQdiBpcyB0aGUKCQlwYXRjaCBsZXZlbCAoc2luY2UgdGhpcyB3YXMgaW50cm9kdWNlZCBpbiBwYXRjaCA5NSwgaXQncwoJCWFsd2F5cyA5NSBvciBiaWdnZXIpLiAgUGMgaXMgYWx3YXlzIHplcm8uCgkJe29ubHkgd2hlbiBjb21waWxlZCB3aXRoIHwrdGVybXJlc3BvbnNlfCBmZWF0dXJlfQoKCQkJCSp2OnRoaXNfc2Vzc2lvbiogKnRoaXNfc2Vzc2lvbi12YXJpYWJsZSoKdjp0aGlzX3Nlc3Npb24JRnVsbCBmaWxlbmFtZSBvZiB0aGUgbGFzdCBsb2FkZWQgb3Igc2F2ZWQgc2Vzc2lvbiBmaWxlLiAgU2VlCgkJfDpta3Nlc3Npb258LiAgSXQgaXMgYWxsb3dlZCB0byBzZXQgdGhpcyB2YXJpYWJsZS4gIFdoZW4gbm8KCQlzZXNzaW9uIGZpbGUgaGFzIGJlZW4gc2F2ZWQsIHRoaXMgdmFyaWFibGUgaXMgZW1wdHkuCgkJInRoaXNfc2Vzc2lvbiIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjp0aHJvd3BvaW50KiAqdGhyb3dwb2ludC12YXJpYWJsZSoKdjp0aHJvd3BvaW50CVRoZSBwb2ludCB3aGVyZSB0aGUgZXhjZXB0aW9uIG1vc3QgcmVjZW50bHkgY2F1Z2h0IGFuZCBub3QKCQlmaW5pc2hlZCB3YXMgdGhyb3duLiAgTm90IHNldCB3aGVuIGNvbW1hbmRzIGFyZSB0eXBlZC4JU2VlCgkJYWxzbyB8djpleGNlcHRpb258IGFuZCB8dGhyb3ctdmFyaWFibGVzfC4KCQlFeGFtcGxlOiA+Cgk6dHJ5Cgk6ICB0aHJvdyAib29wcyIKCTpjYXRjaCAvLiovCgk6ICBlY2hvICJFeGNlcHRpb24gZnJvbSIgdjp0aHJvd3BvaW50Cgk6ZW5kdHJ5CjwJCU91dHB1dDogIkV4Y2VwdGlvbiBmcm9tIHRlc3QudmltLCBsaW5lIDIiCgoJCQkJCQkqdjp2YWwqICp2YWwtdmFyaWFibGUqCnY6dmFsCQlWYWx1ZSBvZiB0aGUgY3VycmVudCBpdGVtIG9mIGEgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fC4JT25seQoJCXZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlIGV4cHJlc3Npb24gdXNlZCB3aXRoIHxtYXAoKXwgYW5kCgkJfGZpbHRlcigpfC4gIFJlYWQtb25seS4KCgkJCQkJKnY6dmVyc2lvbiogKnZlcnNpb24tdmFyaWFibGUqCnY6dmVyc2lvbglWZXJzaW9uIG51bWJlciBvZiBWaW06IE1ham9yIHZlcnNpb24gbnVtYmVyIHRpbWVzIDEwMCBwbHVzCgkJbWlub3IgdmVyc2lvbiBudW1iZXIuICBWZXJzaW9uIDUuMCBpcyA1MDAuICBWZXJzaW9uIDUuMSAoNS4wMSkKCQlpcyA1MDEuICBSZWFkLW9ubHkuICAidmVyc2lvbiIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcwoJCWNvbXBhdGliaWxpdHkuCgkJVXNlIHxoYXMoKXwgdG8gY2hlY2sgaWYgYSBjZXJ0YWluIHBhdGNoIHdhcyBpbmNsdWRlZCwgZS5nLjogPgoJCQlpZiBoYXMoInBhdGNoMTIzIikKPAkJTm90ZSB0aGF0IHBhdGNoIG51bWJlcnMgYXJlIHNwZWNpZmljIHRvIHRoZSB2ZXJzaW9uLCB0aHVzIGJvdGgKCQl2ZXJzaW9uIDUuMCBhbmQgNS4xIG1heSBoYXZlIGEgcGF0Y2ggMTIzLCBidXQgdGhlc2UgYXJlCgkJY29tcGxldGVseSBkaWZmZXJlbnQuCgoJCQkJCSp2Ondhcm5pbmdtc2cqICp3YXJuaW5nbXNnLXZhcmlhYmxlKgp2Ondhcm5pbmdtc2cJTGFzdCBnaXZlbiB3YXJuaW5nIG1lc3NhZ2UuICBJdCdzIGFsbG93ZWQgdG8gc2V0IHRoaXMgdmFyaWFibGUuCgoJCQkJCSp2OndpbmRvd2lkKiAqd2luZG93aWQtdmFyaWFibGUqCnY6d2luZG93aWQJV2hlbiBhbnkgWDExIGJhc2VkIEdVSSBpcyBydW5uaW5nIG9yIHdoZW4gcnVubmluZyBpbiBhCgkJdGVybWluYWwgYW5kIFZpbSBjb25uZWN0cyB0byB0aGUgWCBzZXJ2ZXIgKHwtWHwpIHRoaXMgd2lsbCBiZQoJCXNldCB0byB0aGUgd2luZG93IElELgoJCVdoZW4gYW4gTVMtV2luZG93cyBHVUkgaXMgcnVubmluZyB0aGlzIHdpbGwgYmUgc2V0IHRvIHRoZQoJCXdpbmRvdyBoYW5kbGUuCgkJT3RoZXJ3aXNlIHRoZSB2YWx1ZSBpcyB6ZXJvLgoJCU5vdGU6IGZvciB3aW5kb3dzIGluc2lkZSBWaW0gdXNlIHx3aW5ucigpfC4KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo0LiBCdWlsdGluIEZ1bmN0aW9ucwkJCQkJKmZ1bmN0aW9ucyoKClNlZSB8ZnVuY3Rpb24tbGlzdHwgZm9yIGEgbGlzdCBncm91cGVkIGJ5IHdoYXQgdGhlIGZ1bmN0aW9uIGlzIHVzZWQgZm9yLgoKKFVzZSBDVFJMLV0gb24gdGhlIGZ1bmN0aW9uIG5hbWUgdG8ganVtcCB0byB0aGUgZnVsbCBleHBsYW5hdGlvbi4pCgpVU0FHRQkJCQlSRVNVTFQJREVTQ1JJUFRJT04JfgoKYWJzKCB7ZXhwcn0pCQkJRmxvYXQgb3IgTnVtYmVyICBhYnNvbHV0ZSB2YWx1ZSBvZiB7ZXhwcn0KYWNvcygge2V4cHJ9KQkJCUZsb2F0CWFyYyBjb3NpbmUgb2Yge2V4cHJ9CmFkZCgge2xpc3R9LCB7aXRlbX0pCQlMaXN0CWFwcGVuZCB7aXRlbX0gdG8gfExpc3R8IHtsaXN0fQphbmQoIHtleHByfSwge2V4cHJ9KQkJTnVtYmVyICBiaXR3aXNlIEFORAphcHBlbmQoIHtsbnVtfSwge3N0cmluZ30pCU51bWJlcglhcHBlbmQge3N0cmluZ30gYmVsb3cgbGluZSB7bG51bX0KYXBwZW5kKCB7bG51bX0sIHtsaXN0fSkJCU51bWJlcglhcHBlbmQgbGluZXMge2xpc3R9IGJlbG93IGxpbmUge2xudW19CmFyZ2MoKQkJCQlOdW1iZXIJbnVtYmVyIG9mIGZpbGVzIGluIHRoZSBhcmd1bWVudCBsaXN0CmFyZ2lkeCgpCQkJTnVtYmVyCWN1cnJlbnQgaW5kZXggaW4gdGhlIGFyZ3VtZW50IGxpc3QKYXJndigge25yfSkJCQlTdHJpbmcJe25yfSBlbnRyeSBvZiB0aGUgYXJndW1lbnQgbGlzdAphcmd2KCApCQkJCUxpc3QJdGhlIGFyZ3VtZW50IGxpc3QKYXNpbigge2V4cHJ9KQkJCUZsb2F0CWFyYyBzaW5lIG9mIHtleHByfQphdGFuKCB7ZXhwcn0pCQkJRmxvYXQJYXJjIHRhbmdlbnQgb2Yge2V4cHJ9CmF0YW4yKCB7ZXhwcn0sIHtleHByfSkJCUZsb2F0ICAgYXJjIHRhbmdlbnQgb2Yge2V4cHIxfSAvIHtleHByMn0KYnJvd3NlKCB7c2F2ZX0sIHt0aXRsZX0sIHtpbml0ZGlyfSwge2RlZmF1bHR9KQoJCQkJU3RyaW5nCXB1dCB1cCBhIGZpbGUgcmVxdWVzdGVyCmJyb3dzZWRpcigge3RpdGxlfSwge2luaXRkaXJ9KQlTdHJpbmcJcHV0IHVwIGEgZGlyZWN0b3J5IHJlcXVlc3RlcgpidWZleGlzdHMoIHtleHByfSkJCU51bWJlcglUUlVFIGlmIGJ1ZmZlciB7ZXhwcn0gZXhpc3RzCmJ1Zmxpc3RlZCgge2V4cHJ9KQkJTnVtYmVyCVRSVUUgaWYgYnVmZmVyIHtleHByfSBpcyBsaXN0ZWQKYnVmbG9hZGVkKCB7ZXhwcn0pCQlOdW1iZXIJVFJVRSBpZiBidWZmZXIge2V4cHJ9IGlzIGxvYWRlZApidWZuYW1lKCB7ZXhwcn0pCQlTdHJpbmcJTmFtZSBvZiB0aGUgYnVmZmVyIHtleHByfQpidWZucigge2V4cHJ9KQkJCU51bWJlcglOdW1iZXIgb2YgdGhlIGJ1ZmZlciB7ZXhwcn0KYnVmd2lubnIoIHtleHByfSkJCU51bWJlcgl3aW5kb3cgbnVtYmVyIG9mIGJ1ZmZlciB7ZXhwcn0KYnl0ZTJsaW5lKCB7Ynl0ZX0pCQlOdW1iZXIJbGluZSBudW1iZXIgYXQgYnl0ZSBjb3VudCB7Ynl0ZX0KYnl0ZWlkeCgge2V4cHJ9LCB7bnJ9KQkJTnVtYmVyCWJ5dGUgaW5kZXggb2Yge25yfSd0aCBjaGFyIGluIHtleHByfQpjYWxsKCB7ZnVuY30sIHthcmdsaXN0fSBbLCB7ZGljdH1dKQoJCQkJYW55CWNhbGwge2Z1bmN9IHdpdGggYXJndW1lbnRzIHthcmdsaXN0fQpjZWlsKCB7ZXhwcn0pCQkJRmxvYXQJcm91bmQge2V4cHJ9IHVwCmNoYW5nZW5yKCkJCQlOdW1iZXIJY3VycmVudCBjaGFuZ2UgbnVtYmVyCmNoYXIybnIoIHtleHByfSkJCU51bWJlcglBU0NJSSB2YWx1ZSBvZiBmaXJzdCBjaGFyIGluIHtleHByfQpjaW5kZW50KCB7bG51bX0pCQlOdW1iZXIJQyBpbmRlbnQgZm9yIGxpbmUge2xudW19CmNsZWFybWF0Y2hlcygpCQkJbm9uZQljbGVhciBhbGwgbWF0Y2hlcwpjb2woIHtleHByfSkJCQlOdW1iZXIJY29sdW1uIG5yIG9mIGN1cnNvciBvciBtYXJrCmNvbXBsZXRlKCB7c3RhcnRjb2x9LCB7bWF0Y2hlc30pIG5vbmUJc2V0IEluc2VydCBtb2RlIGNvbXBsZXRpb24KY29tcGxldGVfYWRkKCB7ZXhwcn0pCQlOdW1iZXIJYWRkIGNvbXBsZXRpb24gbWF0Y2gKY29tcGxldGVfY2hlY2soKQkJTnVtYmVyCWNoZWNrIGZvciBrZXkgdHlwZWQgZHVyaW5nIGNvbXBsZXRpb24KY29uZmlybSgge21zZ30gWywge2Nob2ljZXN9IFssIHtkZWZhdWx0fSBbLCB7dHlwZX1dXV0pCgkJCQlOdW1iZXIJbnVtYmVyIG9mIGNob2ljZSBwaWNrZWQgYnkgdXNlcgpjb3B5KCB7ZXhwcn0pCQkJYW55CW1ha2UgYSBzaGFsbG93IGNvcHkgb2Yge2V4cHJ9CmNvcygge2V4cHJ9KQkJCUZsb2F0CWNvc2luZSBvZiB7ZXhwcn0KY29zaCgge2V4cHJ9KQkJCUZsb2F0CWh5cGVyYm9saWMgY29zaW5lIG9mIHtleHByfQpjb3VudCgge2xpc3R9LCB7ZXhwcn0gWywge3N0YXJ0fSBbLCB7aWN9XV0pCgkJCQlOdW1iZXIJIGNvdW50IGhvdyBtYW55IHtleHByfSBhcmUgaW4ge2xpc3R9CmNzY29wZV9jb25uZWN0aW9uKCBbe251bX0gLCB7ZGJwYXRofSBbLCB7cHJlcGVuZH1dXSkKCQkJCU51bWJlcgljaGVja3MgZXhpc3RlbmNlIG9mIGNzY29wZSBjb25uZWN0aW9uCmN1cnNvcigge2xudW19LCB7Y29sfSBbLCB7Y29sYWRkfV0pCgkJCQlOdW1iZXIJbW92ZSBjdXJzb3IgdG8ge2xudW19LCB7Y29sfSwge2NvbGFkZH0KY3Vyc29yKCB7bGlzdH0pCQkJTnVtYmVyCW1vdmUgY3Vyc29yIHRvIHBvc2l0aW9uIGluIHtsaXN0fQpkZWVwY29weSgge2V4cHJ9KQkJYW55CW1ha2UgYSBmdWxsIGNvcHkgb2Yge2V4cHJ9CmRlbGV0ZSgge2ZuYW1lfSkJCU51bWJlcglkZWxldGUgZmlsZSB7Zm5hbWV9CmRpZF9maWxldHlwZSgpCQkJTnVtYmVyCVRSVUUgaWYgRmlsZVR5cGUgYXV0b2NvbW1hbmQgZXZlbnQgdXNlZApkaWZmX2ZpbGxlcigge2xudW19KQkJTnVtYmVyCWRpZmYgZmlsbGVyIGxpbmVzIGFib3V0IHtsbnVtfQpkaWZmX2hsSUQoIHtsbnVtfSwge2NvbH0pCU51bWJlcglkaWZmIGhpZ2hsaWdodGluZyBhdCB7bG51bX0ve2NvbH0KZW1wdHkoIHtleHByfSkJCQlOdW1iZXIJVFJVRSBpZiB7ZXhwcn0gaXMgZW1wdHkKZXNjYXBlKCB7c3RyaW5nfSwge2NoYXJzfSkJU3RyaW5nCWVzY2FwZSB7Y2hhcnN9IGluIHtzdHJpbmd9IHdpdGggJ1wnCmV2YWwoIHtzdHJpbmd9KQkJCWFueQlldmFsdWF0ZSB7c3RyaW5nfSBpbnRvIGl0cyB2YWx1ZQpldmVudGhhbmRsZXIoICkJCQlOdW1iZXIJVFJVRSBpZiBpbnNpZGUgYW4gZXZlbnQgaGFuZGxlcgpleGVjdXRhYmxlKCB7ZXhwcn0pCQlOdW1iZXIJMSBpZiBleGVjdXRhYmxlIHtleHByfSBleGlzdHMKZXhpc3RzKCB7ZXhwcn0pCQkJTnVtYmVyCVRSVUUgaWYge2V4cHJ9IGV4aXN0cwpleHRlbmQoIHtleHByMX0sIHtleHByMn0gWywge2V4cHIzfV0pCgkJCQlMaXN0L0RpY3QgaW5zZXJ0IGl0ZW1zIG9mIHtleHByMn0gaW50byB7ZXhwcjF9CmV4cCgge2V4cHJ9KQkJCUZsb2F0CWV4cG9uZW50aWFsIG9mIHtleHByfQpleHBhbmQoIHtleHByfSBbLCB7ZmxhZ31dKQlTdHJpbmcJZXhwYW5kIHNwZWNpYWwga2V5d29yZHMgaW4ge2V4cHJ9CmZlZWRrZXlzKCB7c3RyaW5nfSBbLCB7bW9kZX1dKQlOdW1iZXIJYWRkIGtleSBzZXF1ZW5jZSB0byB0eXBlYWhlYWQgYnVmZmVyCmZpbGVyZWFkYWJsZSgge2ZpbGV9KQkJTnVtYmVyCVRSVUUgaWYge2ZpbGV9IGlzIGEgcmVhZGFibGUgZmlsZQpmaWxld3JpdGFibGUoIHtmaWxlfSkJCU51bWJlcglUUlVFIGlmIHtmaWxlfSBpcyBhIHdyaXRhYmxlIGZpbGUKZmlsdGVyKCB7ZXhwcn0sIHtzdHJpbmd9KQlMaXN0L0RpY3QgIHJlbW92ZSBpdGVtcyBmcm9tIHtleHByfSB3aGVyZQoJCQkJCXtzdHJpbmd9IGlzIDAKZmluZGRpcigge25hbWV9Wywge3BhdGh9Wywge2NvdW50fV1dKQoJCQkJU3RyaW5nCWZpbmQgZGlyZWN0b3J5IHtuYW1lfSBpbiB7cGF0aH0KZmluZGZpbGUoIHtuYW1lfVssIHtwYXRofVssIHtjb3VudH1dXSkKCQkJCVN0cmluZwlmaW5kIGZpbGUge25hbWV9IGluIHtwYXRofQpmbG9hdDJucigge2V4cHJ9KQkJTnVtYmVyCWNvbnZlcnQgRmxvYXQge2V4cHJ9IHRvIGEgTnVtYmVyCmZsb29yKCB7ZXhwcn0pCQkJRmxvYXQJcm91bmQge2V4cHJ9IGRvd24KZm1vZCgge2V4cHIxfSwge2V4cHIyfSkJCUZsb2F0CXJlbWFpbmRlciBvZiB7ZXhwcjF9IC8ge2V4cHIyfQpmbmFtZWVzY2FwZSgge2ZuYW1lfSkJCVN0cmluZwllc2NhcGUgc3BlY2lhbCBjaGFyYWN0ZXJzIGluIHtmbmFtZX0KZm5hbWVtb2RpZnkoIHtmbmFtZX0sIHttb2RzfSkJU3RyaW5nCW1vZGlmeSBmaWxlIG5hbWUKZm9sZGNsb3NlZCgge2xudW19KQkJTnVtYmVyCWZpcnN0IGxpbmUgb2YgZm9sZCBhdCB7bG51bX0gaWYgY2xvc2VkCmZvbGRjbG9zZWRlbmQoIHtsbnVtfSkJCU51bWJlcglsYXN0IGxpbmUgb2YgZm9sZCBhdCB7bG51bX0gaWYgY2xvc2VkCmZvbGRsZXZlbCgge2xudW19KQkJTnVtYmVyCWZvbGQgbGV2ZWwgYXQge2xudW19CmZvbGR0ZXh0KCApCQkJU3RyaW5nCWxpbmUgZGlzcGxheWVkIGZvciBjbG9zZWQgZm9sZApmb2xkdGV4dHJlc3VsdCgge2xudW19KQkJU3RyaW5nCXRleHQgZm9yIGNsb3NlZCBmb2xkIGF0IHtsbnVtfQpmb3JlZ3JvdW5kKCApCQkJTnVtYmVyCWJyaW5nIHRoZSBWaW0gd2luZG93IHRvIHRoZSBmb3JlZ3JvdW5kCmZ1bmN0aW9uKCB7bmFtZX0pCQlGdW5jcmVmIHJlZmVyZW5jZSB0byBmdW5jdGlvbiB7bmFtZX0KZ2FyYmFnZWNvbGxlY3QoIFt7YXRleGl0fV0pCW5vbmUJZnJlZSBtZW1vcnksIGJyZWFraW5nIGN5Y2xpYyByZWZlcmVuY2VzCmdldCgge2xpc3R9LCB7aWR4fSBbLCB7ZGVmfV0pCWFueQlnZXQgaXRlbSB7aWR4fSBmcm9tIHtsaXN0fSBvciB7ZGVmfQpnZXQoIHtkaWN0fSwge2tleX0gWywge2RlZn1dKQlhbnkJZ2V0IGl0ZW0ge2tleX0gZnJvbSB7ZGljdH0gb3Ige2RlZn0KZ2V0YnVmbGluZSgge2V4cHJ9LCB7bG51bX0gWywge2VuZH1dKQoJCQkJTGlzdAlsaW5lcyB7bG51bX0gdG8ge2VuZH0gb2YgYnVmZmVyIHtleHByfQpnZXRidWZ2YXIoIHtleHByfSwge3Zhcm5hbWV9KQlhbnkJdmFyaWFibGUge3Zhcm5hbWV9IGluIGJ1ZmZlciB7ZXhwcn0KZ2V0Y2hhciggW2V4cHJdKQkJTnVtYmVyCWdldCBvbmUgY2hhcmFjdGVyIGZyb20gdGhlIHVzZXIKZ2V0Y2hhcm1vZCggKQkJCU51bWJlcgltb2RpZmllcnMgZm9yIHRoZSBsYXN0IHR5cGVkIGNoYXJhY3RlcgpnZXRjbWRsaW5lKCkJCQlTdHJpbmcJcmV0dXJuIHRoZSBjdXJyZW50IGNvbW1hbmQtbGluZQpnZXRjbWRwb3MoKQkJCU51bWJlcglyZXR1cm4gY3Vyc29yIHBvc2l0aW9uIGluIGNvbW1hbmQtbGluZQpnZXRjbWR0eXBlKCkJCQlTdHJpbmcJcmV0dXJuIHRoZSBjdXJyZW50IGNvbW1hbmQtbGluZSB0eXBlCmdldGN3ZCgpCQkJU3RyaW5nCXRoZSBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5CmdldGZwZXJtKCB7Zm5hbWV9KQkJU3RyaW5nCWZpbGUgcGVybWlzc2lvbnMgb2YgZmlsZSB7Zm5hbWV9CmdldGZzaXplKCB7Zm5hbWV9KQkJTnVtYmVyCXNpemUgaW4gYnl0ZXMgb2YgZmlsZSB7Zm5hbWV9CmdldGZvbnRuYW1lKCBbe25hbWV9XSkJCVN0cmluZwluYW1lIG9mIGZvbnQgYmVpbmcgdXNlZApnZXRmdGltZSgge2ZuYW1lfSkJCU51bWJlcglsYXN0IG1vZGlmaWNhdGlvbiB0aW1lIG9mIGZpbGUKZ2V0ZnR5cGUoIHtmbmFtZX0pCQlTdHJpbmcJZGVzY3JpcHRpb24gb2YgdHlwZSBvZiBmaWxlIHtmbmFtZX0KZ2V0bGluZSgge2xudW19KQkJU3RyaW5nCWxpbmUge2xudW19IG9mIGN1cnJlbnQgYnVmZmVyCmdldGxpbmUoIHtsbnVtfSwge2VuZH0pCQlMaXN0CWxpbmVzIHtsbnVtfSB0byB7ZW5kfSBvZiBjdXJyZW50IGJ1ZmZlcgpnZXRsb2NsaXN0KCB7bnJ9KQkJTGlzdAlsaXN0IG9mIGxvY2F0aW9uIGxpc3QgaXRlbXMKZ2V0bWF0Y2hlcygpCQkJTGlzdAlsaXN0IG9mIGN1cnJlbnQgbWF0Y2hlcwpnZXRwaWQoKQkJCU51bWJlcglwcm9jZXNzIElEIG9mIFZpbQpnZXRwb3MoIHtleHByfSkJCQlMaXN0CXBvc2l0aW9uIG9mIGN1cnNvciwgbWFyaywgZXRjLgpnZXRxZmxpc3QoKQkJCUxpc3QJbGlzdCBvZiBxdWlja2ZpeCBpdGVtcwpnZXRyZWcoIFt7cmVnbmFtZX0gWywgMV1dKQlTdHJpbmcJY29udGVudHMgb2YgcmVnaXN0ZXIKZ2V0cmVndHlwZSggW3tyZWduYW1lfV0pCVN0cmluZwl0eXBlIG9mIHJlZ2lzdGVyCmdldHRhYnZhcigge25yfSwge3Zhcm5hbWV9KQlhbnkJdmFyaWFibGUge3Zhcm5hbWV9IGluIHRhYiB7bnJ9CmdldHRhYndpbnZhcigge3RhYm5yfSwge3dpbm5yfSwge25hbWV9KQoJCQkJYW55CXtuYW1lfSBpbiB7d2lubnJ9IGluIHRhYiBwYWdlIHt0YWJucn0KZ2V0d2lucG9zeCgpCQkJTnVtYmVyCVggY29vcmQgaW4gcGl4ZWxzIG9mIEdVSSBWaW0gd2luZG93CmdldHdpbnBvc3koKQkJCU51bWJlcglZIGNvb3JkIGluIHBpeGVscyBvZiBHVUkgVmltIHdpbmRvdwpnZXR3aW52YXIoIHtucn0sIHt2YXJuYW1lfSkJYW55CXZhcmlhYmxlIHt2YXJuYW1lfSBpbiB3aW5kb3cge25yfQpnbG9iKCB7ZXhwcn0gWywge2ZsYWd9XSkJU3RyaW5nCWV4cGFuZCBmaWxlIHdpbGRjYXJkcyBpbiB7ZXhwcn0KZ2xvYnBhdGgoIHtwYXRofSwge2V4cHJ9IFssIHtmbGFnfV0pCgkJCQlTdHJpbmcJZG8gZ2xvYih7ZXhwcn0pIGZvciBhbGwgZGlycyBpbiB7cGF0aH0KaGFzKCB7ZmVhdHVyZX0pCQkJTnVtYmVyCVRSVUUgaWYgZmVhdHVyZSB7ZmVhdHVyZX0gc3VwcG9ydGVkCmhhc19rZXkoIHtkaWN0fSwge2tleX0pCQlOdW1iZXIJVFJVRSBpZiB7ZGljdH0gaGFzIGVudHJ5IHtrZXl9Cmhhc2xvY2FsZGlyKCkJCQlOdW1iZXIJVFJVRSBpZiBjdXJyZW50IHdpbmRvdyBleGVjdXRlZCB8OmxjZHwKaGFzbWFwdG8oIHt3aGF0fSBbLCB7bW9kZX0gWywge2FiYnJ9XV0pCgkJCQlOdW1iZXIJVFJVRSBpZiBtYXBwaW5nIHRvIHt3aGF0fSBleGlzdHMKaGlzdGFkZCgge2hpc3Rvcnl9LHtpdGVtfSkJU3RyaW5nCWFkZCBhbiBpdGVtIHRvIGEgaGlzdG9yeQpoaXN0ZGVsKCB7aGlzdG9yeX0gWywge2l0ZW19XSkJU3RyaW5nCXJlbW92ZSBhbiBpdGVtIGZyb20gYSBoaXN0b3J5Cmhpc3RnZXQoIHtoaXN0b3J5fSBbLCB7aW5kZXh9XSkJU3RyaW5nCWdldCB0aGUgaXRlbSB7aW5kZXh9IGZyb20gYSBoaXN0b3J5Cmhpc3Rucigge2hpc3Rvcnl9KQkJTnVtYmVyCWhpZ2hlc3QgaW5kZXggb2YgYSBoaXN0b3J5CmhsZXhpc3RzKCB7bmFtZX0pCQlOdW1iZXIJVFJVRSBpZiBoaWdobGlnaHQgZ3JvdXAge25hbWV9IGV4aXN0cwpobElEKCB7bmFtZX0pCQkJTnVtYmVyCXN5bnRheCBJRCBvZiBoaWdobGlnaHQgZ3JvdXAge25hbWV9Cmhvc3RuYW1lKCkJCQlTdHJpbmcJbmFtZSBvZiB0aGUgbWFjaGluZSBWaW0gaXMgcnVubmluZyBvbgppY29udigge2V4cHJ9LCB7ZnJvbX0sIHt0b30pCVN0cmluZwljb252ZXJ0IGVuY29kaW5nIG9mIHtleHByfQppbmRlbnQoIHtsbnVtfSkJCQlOdW1iZXIJaW5kZW50IG9mIGxpbmUge2xudW19CmluZGV4KCB7bGlzdH0sIHtleHByfSBbLCB7c3RhcnR9IFssIHtpY31dXSkKCQkJCU51bWJlcglpbmRleCBpbiB7bGlzdH0gd2hlcmUge2V4cHJ9IGFwcGVhcnMKaW5wdXQoIHtwcm9tcHR9IFssIHt0ZXh0fSBbLCB7Y29tcGxldGlvbn1dXSkKCQkJCVN0cmluZwlnZXQgaW5wdXQgZnJvbSB0aGUgdXNlcgppbnB1dGRpYWxvZygge3B9IFssIHt0fSBbLCB7Y31dXSkgU3RyaW5nICBsaWtlIGlucHV0KCkgYnV0IGluIGEgR1VJIGRpYWxvZwppbnB1dGxpc3QoIHt0ZXh0bGlzdH0pCQlOdW1iZXIJbGV0IHRoZSB1c2VyIHBpY2sgZnJvbSBhIGNob2ljZSBsaXN0CmlucHV0cmVzdG9yZSgpCQkJTnVtYmVyCXJlc3RvcmUgdHlwZWFoZWFkCmlucHV0c2F2ZSgpCQkJTnVtYmVyCXNhdmUgYW5kIGNsZWFyIHR5cGVhaGVhZAppbnB1dHNlY3JldCgge3Byb21wdH0gWywge3RleHR9XSkgU3RyaW5nICBsaWtlIGlucHV0KCkgYnV0IGhpZGluZyB0aGUgdGV4dAppbnNlcnQoIHtsaXN0fSwge2l0ZW19IFssIHtpZHh9XSkgTGlzdAlpbnNlcnQge2l0ZW19IGluIHtsaXN0fSBbYmVmb3JlIHtpZHh9XQppbnZlcnQoIHtleHByfSkJCQlOdW1iZXIgIGJpdHdpc2UgaW52ZXJ0CmlzZGlyZWN0b3J5KCB7ZGlyZWN0b3J5fSkJTnVtYmVyCVRSVUUgaWYge2RpcmVjdG9yeX0gaXMgYSBkaXJlY3RvcnkKaXNsb2NrZWQoIHtleHByfSkJCU51bWJlcglUUlVFIGlmIHtleHByfSBpcyBsb2NrZWQKaXRlbXMoIHtkaWN0fSkJCQlMaXN0CWtleS12YWx1ZSBwYWlycyBpbiB7ZGljdH0Kam9pbigge2xpc3R9IFssIHtzZXB9XSkJCVN0cmluZwlqb2luIHtsaXN0fSBpdGVtcyBpbnRvIG9uZSBTdHJpbmcKa2V5cygge2RpY3R9KQkJCUxpc3QJa2V5cyBpbiB7ZGljdH0KbGVuKCB7ZXhwcn0pCQkJTnVtYmVyCXRoZSBsZW5ndGggb2Yge2V4cHJ9CmxpYmNhbGwoIHtsaWJ9LCB7ZnVuY30sIHthcmd9KQlTdHJpbmcJY2FsbCB7ZnVuY30gaW4gbGlicmFyeSB7bGlifSB3aXRoIHthcmd9CmxpYmNhbGxucigge2xpYn0sIHtmdW5jfSwge2FyZ30pICBOdW1iZXIgIGlkZW0sIGJ1dCByZXR1cm4gYSBOdW1iZXIKbGluZSgge2V4cHJ9KQkJCU51bWJlcglsaW5lIG5yIG9mIGN1cnNvciwgbGFzdCBsaW5lIG9yIG1hcmsKbGluZTJieXRlKCB7bG51bX0pCQlOdW1iZXIJYnl0ZSBjb3VudCBvZiBsaW5lIHtsbnVtfQpsaXNwaW5kZW50KCB7bG51bX0pCQlOdW1iZXIJTGlzcCBpbmRlbnQgZm9yIGxpbmUge2xudW19CmxvY2FsdGltZSgpCQkJTnVtYmVyCWN1cnJlbnQgdGltZQpsb2coIHtleHByfSkJCQlGbG9hdAluYXR1cmFsIGxvZ2FyaXRobSAoYmFzZSBlKSBvZiB7ZXhwcn0KbG9nMTAoIHtleHByfSkJCQlGbG9hdAlsb2dhcml0aG0gb2YgRmxvYXQge2V4cHJ9IHRvIGJhc2UgMTAKbWFwKCB7ZXhwcn0sIHtzdHJpbmd9KQkJTGlzdC9EaWN0ICBjaGFuZ2UgZWFjaCBpdGVtIGluIHtleHByfSB0byB7ZXhwcn0KbWFwYXJnKCB7bmFtZX1bLCB7bW9kZX0gWywge2FiYnJ9IFssIHtkaWN0fV1dXSkKCQkJCVN0cmluZyBvciBEaWN0CgkJCQkJcmhzIG9mIG1hcHBpbmcge25hbWV9IGluIG1vZGUge21vZGV9Cm1hcGNoZWNrKCB7bmFtZX1bLCB7bW9kZX0gWywge2FiYnJ9XV0pCgkJCQlTdHJpbmcJY2hlY2sgZm9yIG1hcHBpbmdzIG1hdGNoaW5nIHtuYW1lfQptYXRjaCgge2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCgkJCQlOdW1iZXIJcG9zaXRpb24gd2hlcmUge3BhdH0gbWF0Y2hlcyBpbiB7ZXhwcn0KbWF0Y2hhZGQoIHtncm91cH0sIHtwYXR0ZXJufVssIHtwcmlvcml0eX1bLCB7aWR9XV0pCgkJCQlOdW1iZXIJaGlnaGxpZ2h0IHtwYXR0ZXJufSB3aXRoIHtncm91cH0KbWF0Y2hhcmcoIHtucn0pCQkJTGlzdAlhcmd1bWVudHMgb2YgfDptYXRjaHwKbWF0Y2hkZWxldGUoIHtpZH0pCQlOdW1iZXIJZGVsZXRlIG1hdGNoIGlkZW50aWZpZWQgYnkge2lkfQptYXRjaGVuZCgge2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCgkJCQlOdW1iZXIJcG9zaXRpb24gd2hlcmUge3BhdH0gZW5kcyBpbiB7ZXhwcn0KbWF0Y2hsaXN0KCB7ZXhwcn0sIHtwYXR9Wywge3N0YXJ0fVssIHtjb3VudH1dXSkKCQkJCUxpc3QJbWF0Y2ggYW5kIHN1Ym1hdGNoZXMgb2Yge3BhdH0gaW4ge2V4cHJ9Cm1hdGNoc3RyKCB7ZXhwcn0sIHtwYXR9Wywge3N0YXJ0fVssIHtjb3VudH1dXSkKCQkJCVN0cmluZwl7Y291bnR9J3RoIG1hdGNoIG9mIHtwYXR9IGluIHtleHByfQptYXgoIHtsaXN0fSkJCQlOdW1iZXIJbWF4aW11bSB2YWx1ZSBvZiBpdGVtcyBpbiB7bGlzdH0KbWluKCB7bGlzdH0pCQkJTnVtYmVyCW1pbmltdW0gdmFsdWUgb2YgaXRlbXMgaW4ge2xpc3R9Cm1rZGlyKCB7bmFtZX0gWywge3BhdGh9IFssIHtwcm90fV1dKQoJCQkJTnVtYmVyCWNyZWF0ZSBkaXJlY3Rvcnkge25hbWV9Cm1vZGUoIFtleHByXSkJCQlTdHJpbmcJY3VycmVudCBlZGl0aW5nIG1vZGUKbXpldmFsKCB7ZXhwcn0pCQkJYW55CWV2YWx1YXRlIHxNelNjaGVtZXwgZXhwcmVzc2lvbgpuZXh0bm9uYmxhbmsoIHtsbnVtfSkJCU51bWJlcglsaW5lIG5yIG9mIG5vbi1ibGFuayBsaW5lID49IHtsbnVtfQpucjJjaGFyKCB7ZXhwcn0pCQlTdHJpbmcJc2luZ2xlIGNoYXIgd2l0aCBBU0NJSSB2YWx1ZSB7ZXhwcn0Kb3IoIHtleHByfSwge2V4cHJ9KQkJTnVtYmVyICBiaXR3aXNlIE9SCnBhdGhzaG9ydGVuKCB7ZXhwcn0pCQlTdHJpbmcJc2hvcnRlbiBkaXJlY3RvcnkgbmFtZXMgaW4gYSBwYXRoCnBvdygge3h9LCB7eX0pCQkJRmxvYXQJe3h9IHRvIHRoZSBwb3dlciBvZiB7eX0KcHJldm5vbmJsYW5rKCB7bG51bX0pCQlOdW1iZXIJbGluZSBuciBvZiBub24tYmxhbmsgbGluZSA8PSB7bG51bX0KcHJpbnRmKCB7Zm10fSwge2V4cHIxfS4uLikJU3RyaW5nCWZvcm1hdCB0ZXh0CnB1bXZpc2libGUoKQkJCU51bWJlcgl3aGV0aGVyIHBvcHVwIG1lbnUgaXMgdmlzaWJsZQpyYW5nZSgge2V4cHJ9IFssIHttYXh9IFssIHtzdHJpZGV9XV0pCgkJCQlMaXN0CWl0ZW1zIGZyb20ge2V4cHJ9IHRvIHttYXh9CnJlYWRmaWxlKCB7Zm5hbWV9IFssIHtiaW5hcnl9IFssIHttYXh9XV0pCgkJCQlMaXN0CWdldCBsaXN0IG9mIGxpbmVzIGZyb20gZmlsZSB7Zm5hbWV9CnJlbHRpbWUoIFt7c3RhcnR9IFssIHtlbmR9XV0pCUxpc3QJZ2V0IHRpbWUgdmFsdWUKcmVsdGltZXN0cigge3RpbWV9KQkJU3RyaW5nCXR1cm4gdGltZSB2YWx1ZSBpbnRvIGEgU3RyaW5nCnJlbW90ZV9leHByKCB7c2VydmVyfSwge3N0cmluZ30gWywge2lkdmFyfV0pCgkJCQlTdHJpbmcJc2VuZCBleHByZXNzaW9uCnJlbW90ZV9mb3JlZ3JvdW5kKCB7c2VydmVyfSkJTnVtYmVyCWJyaW5nIFZpbSBzZXJ2ZXIgdG8gdGhlIGZvcmVncm91bmQKcmVtb3RlX3BlZWsoIHtzZXJ2ZXJpZH0gWywge3JldHZhcn1dKQoJCQkJTnVtYmVyCWNoZWNrIGZvciByZXBseSBzdHJpbmcKcmVtb3RlX3JlYWQoIHtzZXJ2ZXJpZH0pCVN0cmluZwlyZWFkIHJlcGx5IHN0cmluZwpyZW1vdGVfc2VuZCgge3NlcnZlcn0sIHtzdHJpbmd9IFssIHtpZHZhcn1dKQoJCQkJU3RyaW5nCXNlbmQga2V5IHNlcXVlbmNlCnJlbW92ZSgge2xpc3R9LCB7aWR4fSBbLCB7ZW5kfV0pICBhbnkJcmVtb3ZlIGl0ZW1zIHtpZHh9LXtlbmR9IGZyb20ge2xpc3R9CnJlbW92ZSgge2RpY3R9LCB7a2V5fSkJCWFueQlyZW1vdmUgZW50cnkge2tleX0gZnJvbSB7ZGljdH0KcmVuYW1lKCB7ZnJvbX0sIHt0b30pCQlOdW1iZXIJcmVuYW1lIChtb3ZlKSBmaWxlIGZyb20ge2Zyb219IHRvIHt0b30KcmVwZWF0KCB7ZXhwcn0sIHtjb3VudH0pCVN0cmluZwlyZXBlYXQge2V4cHJ9IHtjb3VudH0gdGltZXMKcmVzb2x2ZSgge2ZpbGVuYW1lfSkJCVN0cmluZwlnZXQgZmlsZW5hbWUgYSBzaG9ydGN1dCBwb2ludHMgdG8KcmV2ZXJzZSgge2xpc3R9KQkJTGlzdAlyZXZlcnNlIHtsaXN0fSBpbi1wbGFjZQpyb3VuZCgge2V4cHJ9KQkJCUZsb2F0CXJvdW5kIG9mZiB7ZXhwcn0Kc2VhcmNoKCB7cGF0dGVybn0gWywge2ZsYWdzfSBbLCB7c3RvcGxpbmV9IFssIHt0aW1lb3V0fV1dXSkKCQkJCU51bWJlcglzZWFyY2ggZm9yIHtwYXR0ZXJufQpzZWFyY2hkZWNsKCB7bmFtZX0gWywge2dsb2JhbH0gWywge3RoaXNibG9ja31dXSkKCQkJCU51bWJlcglzZWFyY2ggZm9yIHZhcmlhYmxlIGRlY2xhcmF0aW9uCnNlYXJjaHBhaXIoIHtzdGFydH0sIHttaWRkbGV9LCB7ZW5kfSBbLCB7ZmxhZ3N9IFssIHtza2lwfSBbLi4uXV1dKQoJCQkJTnVtYmVyCXNlYXJjaCBmb3Igb3RoZXIgZW5kIG9mIHN0YXJ0L2VuZCBwYWlyCnNlYXJjaHBhaXJwb3MoIHtzdGFydH0sIHttaWRkbGV9LCB7ZW5kfSBbLCB7ZmxhZ3N9IFssIHtza2lwfSBbLi4uXV1dKQoJCQkJTGlzdAlzZWFyY2ggZm9yIG90aGVyIGVuZCBvZiBzdGFydC9lbmQgcGFpcgpzZWFyY2hwb3MoIHtwYXR0ZXJufSBbLCB7ZmxhZ3N9IFssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dKQoJCQkJTGlzdAlzZWFyY2ggZm9yIHtwYXR0ZXJufQpzZXJ2ZXIyY2xpZW50KCB7Y2xpZW50aWR9LCB7c3RyaW5nfSkKCQkJCU51bWJlcglzZW5kIHJlcGx5IHN0cmluZwpzZXJ2ZXJsaXN0KCkJCQlTdHJpbmcJZ2V0IGEgbGlzdCBvZiBhdmFpbGFibGUgc2VydmVycwpzZXRidWZ2YXIoIHtleHByfSwge3Zhcm5hbWV9LCB7dmFsfSkJc2V0IHt2YXJuYW1lfSBpbiBidWZmZXIge2V4cHJ9IHRvIHt2YWx9CnNldGNtZHBvcygge3Bvc30pCQlOdW1iZXIJc2V0IGN1cnNvciBwb3NpdGlvbiBpbiBjb21tYW5kLWxpbmUKc2V0bGluZSgge2xudW19LCB7bGluZX0pCU51bWJlcglzZXQgbGluZSB7bG51bX0gdG8ge2xpbmV9CnNldGxvY2xpc3QoIHtucn0sIHtsaXN0fVssIHthY3Rpb259XSkKCQkJCU51bWJlcgltb2RpZnkgbG9jYXRpb24gbGlzdCB1c2luZyB7bGlzdH0Kc2V0bWF0Y2hlcygge2xpc3R9KQkJTnVtYmVyCXJlc3RvcmUgYSBsaXN0IG9mIG1hdGNoZXMKc2V0cG9zKCB7ZXhwcn0sIHtsaXN0fSkJCU51bWJlcglzZXQgdGhlIHtleHByfSBwb3NpdGlvbiB0byB7bGlzdH0Kc2V0cWZsaXN0KCB7bGlzdH1bLCB7YWN0aW9ufV0pCU51bWJlcgltb2RpZnkgcXVpY2tmaXggbGlzdCB1c2luZyB7bGlzdH0Kc2V0cmVnKCB7bn0sIHt2fVssIHtvcHR9XSkJTnVtYmVyCXNldCByZWdpc3RlciB0byB2YWx1ZSBhbmQgdHlwZQpzZXR0YWJ2YXIoIHtucn0sIHt2YXJuYW1lfSwge3ZhbH0pCXNldCB7dmFybmFtZX0gaW4gdGFiIHBhZ2Uge25yfSB0byB7dmFsfQpzZXR0YWJ3aW52YXIoIHt0YWJucn0sIHt3aW5ucn0sIHt2YXJuYW1lfSwge3ZhbH0pICAgIHNldCB7dmFybmFtZX0gaW4gd2luZG93CgkJCQkJe3dpbm5yfSBpbiB0YWIgcGFnZSB7dGFibnJ9IHRvIHt2YWx9CnNldHdpbnZhcigge25yfSwge3Zhcm5hbWV9LCB7dmFsfSkJc2V0IHt2YXJuYW1lfSBpbiB3aW5kb3cge25yfSB0byB7dmFsfQpzaGVsbGVzY2FwZSgge3N0cmluZ30gWywge3NwZWNpYWx9XSkKCQkJCVN0cmluZwllc2NhcGUge3N0cmluZ30gZm9yIHVzZSBhcyBzaGVsbAoJCQkJCWNvbW1hbmQgYXJndW1lbnQKc2ltcGxpZnkoIHtmaWxlbmFtZX0pCQlTdHJpbmcJc2ltcGxpZnkgZmlsZW5hbWUgYXMgbXVjaCBhcyBwb3NzaWJsZQpzaW4oIHtleHByfSkJCQlGbG9hdAlzaW5lIG9mIHtleHByfQpzaW5oKCB7ZXhwcn0pCQkJRmxvYXQJaHlwZXJib2xpYyBzaW5lIG9mIHtleHByfQpzb3J0KCB7bGlzdH0gWywge2Z1bmN9IFssIHtkaWN0fV1dKQoJCQkJTGlzdAlzb3J0IHtsaXN0fSwgdXNpbmcge2Z1bmN9IHRvIGNvbXBhcmUKc291bmRmb2xkKCB7d29yZH0pCQlTdHJpbmcJc291bmQtZm9sZCB7d29yZH0Kc3BlbGxiYWR3b3JkKCkJCQlTdHJpbmcJYmFkbHkgc3BlbGxlZCB3b3JkIGF0IGN1cnNvcgpzcGVsbHN1Z2dlc3QoIHt3b3JkfSBbLCB7bWF4fSBbLCB7Y2FwaXRhbH1dXSkKCQkJCUxpc3QJc3BlbGxpbmcgc3VnZ2VzdGlvbnMKc3BsaXQoIHtleHByfSBbLCB7cGF0fSBbLCB7a2VlcGVtcHR5fV1dKQoJCQkJTGlzdAltYWtlIHxMaXN0fCBmcm9tIHtwYXR9IHNlcGFyYXRlZCB7ZXhwcn0Kc3FydCgge2V4cHJ9KQkJCUZsb2F0CXNxdWFyZSByb290IG9mIHtleHByfQpzdHIyZmxvYXQoIHtleHByfSkJCUZsb2F0CWNvbnZlcnQgU3RyaW5nIHRvIEZsb2F0CnN0cjJucigge2V4cHJ9IFssIHtiYXNlfV0pCU51bWJlcgljb252ZXJ0IFN0cmluZyB0byBOdW1iZXIKc3RyY2hhcnMoIHtleHByfSkJCU51bWJlcgljaGFyYWN0ZXIgbGVuZ3RoIG9mIHRoZSBTdHJpbmcge2V4cHJ9CnN0cmRpc3BsYXl3aWR0aCgge2V4cHJ9IFssIHtjb2x9XSkgTnVtYmVyIGRpc3BsYXkgbGVuZ3RoIG9mIHRoZSBTdHJpbmcge2V4cHJ9CnN0cmZ0aW1lKCB7Zm9ybWF0fVssIHt0aW1lfV0pCVN0cmluZwl0aW1lIGluIHNwZWNpZmllZCBmb3JtYXQKc3RyaWR4KCB7aGF5c3RhY2t9LCB7bmVlZGxlfVssIHtzdGFydH1dKQoJCQkJTnVtYmVyCWluZGV4IG9mIHtuZWVkbGV9IGluIHtoYXlzdGFja30Kc3RyaW5nKCB7ZXhwcn0pCQkJU3RyaW5nCVN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB7ZXhwcn0gdmFsdWUKc3RybGVuKCB7ZXhwcn0pCQkJTnVtYmVyCWxlbmd0aCBvZiB0aGUgU3RyaW5nIHtleHByfQpzdHJwYXJ0KCB7c3JjfSwge3N0YXJ0fVssIHtsZW59XSkKCQkJCVN0cmluZwl7bGVufSBjaGFyYWN0ZXJzIG9mIHtzcmN9IGF0IHtzdGFydH0Kc3RycmlkeCgge2hheXN0YWNrfSwge25lZWRsZX0gWywge3N0YXJ0fV0pCgkJCQlOdW1iZXIJbGFzdCBpbmRleCBvZiB7bmVlZGxlfSBpbiB7aGF5c3RhY2t9CnN0cnRyYW5zKCB7ZXhwcn0pCQlTdHJpbmcJdHJhbnNsYXRlIHN0cmluZyB0byBtYWtlIGl0IHByaW50YWJsZQpzdHJ3aWR0aCgge2V4cHJ9KQkJTnVtYmVyCWRpc3BsYXkgY2VsbCBsZW5ndGggb2YgdGhlIFN0cmluZyB7ZXhwcn0Kc3VibWF0Y2goIHtucn0pCQkJU3RyaW5nCXNwZWNpZmljIG1hdGNoIGluICI6cyIgb3Igc3Vic3RpdHV0ZSgpCnN1YnN0aXR1dGUoIHtleHByfSwge3BhdH0sIHtzdWJ9LCB7ZmxhZ3N9KQoJCQkJU3RyaW5nCWFsbCB7cGF0fSBpbiB7ZXhwcn0gcmVwbGFjZWQgd2l0aCB7c3VifQpzeW5JRCgge2xudW19LCB7Y29sfSwge3RyYW5zfSkJTnVtYmVyCXN5bnRheCBJRCBhdCB7bG51bX0gYW5kIHtjb2x9CnN5bklEYXR0cigge3N5bklEfSwge3doYXR9IFssIHttb2RlfV0pCgkJCQlTdHJpbmcJYXR0cmlidXRlIHt3aGF0fSBvZiBzeW50YXggSUQge3N5bklEfQpzeW5JRHRyYW5zKCB7c3luSUR9KQkJTnVtYmVyCXRyYW5zbGF0ZWQgc3ludGF4IElEIG9mIHtzeW5JRH0Kc3luY29uY2VhbGVkKCB7bG51bX0sIHtjb2x9KQlMaXN0ICAgIGluZm8gYWJvdXQgY29uY2VhbGluZwpzeW5zdGFjaygge2xudW19LCB7Y29sfSkJTGlzdAlzdGFjayBvZiBzeW50YXggSURzIGF0IHtsbnVtfSBhbmQge2NvbH0Kc3lzdGVtKCB7ZXhwcn0gWywge2lucHV0fV0pCVN0cmluZwlvdXRwdXQgb2Ygc2hlbGwgY29tbWFuZC9maWx0ZXIge2V4cHJ9CnRhYnBhZ2VidWZsaXN0KCBbe2FyZ31dKQlMaXN0CWxpc3Qgb2YgYnVmZmVyIG51bWJlcnMgaW4gdGFiIHBhZ2UKdGFicGFnZW5yKCBbe2FyZ31dKQkJTnVtYmVyCW51bWJlciBvZiBjdXJyZW50IG9yIGxhc3QgdGFiIHBhZ2UKdGFicGFnZXdpbm5yKCB7dGFiYXJnfVssIHthcmd9XSkKCQkJCU51bWJlcgludW1iZXIgb2YgY3VycmVudCB3aW5kb3cgaW4gdGFiIHBhZ2UKdGFnbGlzdCgge2V4cHJ9KQkJTGlzdAlsaXN0IG9mIHRhZ3MgbWF0Y2hpbmcge2V4cHJ9CnRhZ2ZpbGVzKCkJCQlMaXN0CXRhZ3MgZmlsZXMgdXNlZAp0ZW1wbmFtZSgpCQkJU3RyaW5nCW5hbWUgZm9yIGEgdGVtcG9yYXJ5IGZpbGUKdGFuKCB7ZXhwcn0pCQkJRmxvYXQJdGFuZ2VudCBvZiB7ZXhwcn0KdGFuaCgge2V4cHJ9KQkJCUZsb2F0CWh5cGVyYm9saWMgdGFuZ2VudCBvZiB7ZXhwcn0KdG9sb3dlcigge2V4cHJ9KQkJU3RyaW5nCXRoZSBTdHJpbmcge2V4cHJ9IHN3aXRjaGVkIHRvIGxvd2VyY2FzZQp0b3VwcGVyKCB7ZXhwcn0pCQlTdHJpbmcJdGhlIFN0cmluZyB7ZXhwcn0gc3dpdGNoZWQgdG8gdXBwZXJjYXNlCnRyKCB7c3JjfSwge2Zyb21zdHJ9LCB7dG9zdHJ9KQlTdHJpbmcJdHJhbnNsYXRlIGNoYXJzIG9mIHtzcmN9IGluIHtmcm9tc3RyfQoJCQkJCXRvIGNoYXJzIGluIHt0b3N0cn0KdHJ1bmMoIHtleHByfSkJCQlGbG9hdAl0cnVuY2F0ZSBGbG9hdCB7ZXhwcn0KdHlwZSgge25hbWV9KQkJCU51bWJlcgl0eXBlIG9mIHZhcmlhYmxlIHtuYW1lfQp1bmRvZmlsZSgge25hbWV9KQkJU3RyaW5nCXVuZG8gZmlsZSBuYW1lIGZvciB7bmFtZX0KdW5kb3RyZWUoKQkJCUxpc3QJdW5kbyBmaWxlIHRyZWUKdmFsdWVzKCB7ZGljdH0pCQkJTGlzdAl2YWx1ZXMgaW4ge2RpY3R9CnZpcnRjb2woIHtleHByfSkJCU51bWJlcglzY3JlZW4gY29sdW1uIG9mIGN1cnNvciBvciBtYXJrCnZpc3VhbG1vZGUoIFtleHByXSkJCVN0cmluZwlsYXN0IHZpc3VhbCBtb2RlIHVzZWQKd2luYnVmbnIoIHtucn0pCQkJTnVtYmVyCWJ1ZmZlciBudW1iZXIgb2Ygd2luZG93IHtucn0Kd2luY29sKCkJCQlOdW1iZXIJd2luZG93IGNvbHVtbiBvZiB0aGUgY3Vyc29yCndpbmhlaWdodCgge25yfSkJCU51bWJlcgloZWlnaHQgb2Ygd2luZG93IHtucn0Kd2lubGluZSgpCQkJTnVtYmVyCXdpbmRvdyBsaW5lIG9mIHRoZSBjdXJzb3IKd2lubnIoIFt7ZXhwcn1dKQkJTnVtYmVyCW51bWJlciBvZiBjdXJyZW50IHdpbmRvdwp3aW5yZXN0Y21kKCkJCQlTdHJpbmcJcmV0dXJucyBjb21tYW5kIHRvIHJlc3RvcmUgd2luZG93IHNpemVzCndpbnJlc3R2aWV3KCB7ZGljdH0pCQlub25lCXJlc3RvcmUgdmlldyBvZiBjdXJyZW50IHdpbmRvdwp3aW5zYXZldmlldygpCQkJRGljdAlzYXZlIHZpZXcgb2YgY3VycmVudCB3aW5kb3cKd2lud2lkdGgoIHtucn0pCQkJTnVtYmVyCXdpZHRoIG9mIHdpbmRvdyB7bnJ9CndyaXRlZmlsZSgge2xpc3R9LCB7Zm5hbWV9IFssIHtiaW5hcnl9XSkKCQkJCU51bWJlcgl3cml0ZSBsaXN0IG9mIGxpbmVzIHRvIGZpbGUge2ZuYW1lfQp4b3IoIHtleHByfSwge2V4cHJ9KQkJTnVtYmVyICBiaXR3aXNlIFhPUgoKYWJzKHtleHByfSkJCQkJCQkJKmFicygpKgoJCVJldHVybiB0aGUgYWJzb2x1dGUgdmFsdWUgb2Yge2V4cHJ9LiAgV2hlbiB7ZXhwcn0gZXZhbHVhdGVzIHRvCgkJYSB8RmxvYXR8IGFicygpIHJldHVybnMgYSB8RmxvYXR8LiAgV2hlbiB7ZXhwcn0gY2FuIGJlCgkJY29udmVydGVkIHRvIGEgfE51bWJlcnwgYWJzKCkgcmV0dXJucyBhIHxOdW1iZXJ8LiAgT3RoZXJ3aXNlCgkJYWJzKCkgZ2l2ZXMgYW4gZXJyb3IgbWVzc2FnZSBhbmQgcmV0dXJucyAtMS4KCQlFeGFtcGxlczogPgoJCQllY2hvIGFicygxLjQ1NikKPAkJCTEuNDU2ICA+CgkJCWVjaG8gYWJzKC01LjQ1NikKPAkJCTUuNDU2ICA+CgkJCWVjaG8gYWJzKC00KQo8CQkJNAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKYWNvcyh7ZXhwcn0pCQkJCQkJCSphY29zKCkqCgkJUmV0dXJuIHRoZSBhcmMgY29zaW5lIG9mIHtleHByfSBtZWFzdXJlZCBpbiByYWRpYW5zLCBhcyBhCgkJfEZsb2F0fCBpbiB0aGUgcmFuZ2Ugb2YgWzAsIHBpXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfCBpbiB0aGUgcmFuZ2UKCQlbLTEsIDFdLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGFjb3MoMCkKPAkJCTEuNTcwNzk2ID4KCQkJOmVjaG8gYWNvcygtMC41KQo8CQkJMi4wOTQzOTUKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmFkZCh7bGlzdH0sIHtleHByfSkJCQkJCSphZGQoKSoKCQlBcHBlbmQgdGhlIGl0ZW0ge2V4cHJ9IHRvIHxMaXN0fCB7bGlzdH0uICBSZXR1cm5zIHRoZQoJCXJlc3VsdGluZyB8TGlzdHwuICBFeGFtcGxlczogPgoJCQk6bGV0IGFsaXN0ID0gYWRkKFsxLCAyLCAzXSwgaXRlbSkKCQkJOmNhbGwgYWRkKG15bGlzdCwgIndvb2RzdG9jayIpCjwJCU5vdGUgdGhhdCB3aGVuIHtleHByfSBpcyBhIHxMaXN0fCBpdCBpcyBhcHBlbmRlZCBhcyBhIHNpbmdsZQoJCWl0ZW0uICBVc2UgfGV4dGVuZCgpfCB0byBjb25jYXRlbmF0ZSB8TGlzdHN8LgoJCVVzZSB8aW5zZXJ0KCl8IHRvIGFkZCBhbiBpdGVtIGF0IGFub3RoZXIgcG9zaXRpb24uCgoKYW5kKHtleHByfSwge2V4cHJ9KQkJCQkJKmFuZCgpKgoJCUJpdHdpc2UgQU5EIG9uIHRoZSB0d28gYXJndW1lbnRzLiAgVGhlIGFyZ3VtZW50cyBhcmUgY29udmVydGVkCgkJdG8gYSBudW1iZXIuICBBIExpc3QsIERpY3Qgb3IgRmxvYXQgYXJndW1lbnQgY2F1c2VzIGFuIGVycm9yLgoJCUV4YW1wbGU6ID4KCQkJOmxldCBmbGFnID0gYW5kKGJpdHMsIDB4ODApCgoKYXBwZW5kKHtsbnVtfSwge2V4cHJ9KQkJCQkJKmFwcGVuZCgpKgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8OiBBcHBlbmQgZWFjaCBpdGVtIG9mIHRoZSB8TGlzdHwgYXMgYQoJCXRleHQgbGluZSBiZWxvdyBsaW5lIHtsbnVtfSBpbiB0aGUgY3VycmVudCBidWZmZXIuCgkJT3RoZXJ3aXNlIGFwcGVuZCB7ZXhwcn0gYXMgb25lIHRleHQgbGluZSBiZWxvdyBsaW5lIHtsbnVtfSBpbgoJCXRoZSBjdXJyZW50IGJ1ZmZlci4KCQl7bG51bX0gY2FuIGJlIHplcm8gdG8gaW5zZXJ0IGEgbGluZSBiZWZvcmUgdGhlIGZpcnN0IG9uZS4KCQlSZXR1cm5zIDEgZm9yIGZhaWx1cmUgKHtsbnVtfSBvdXQgb2YgcmFuZ2Ugb3Igb3V0IG9mIG1lbW9yeSksCgkJMCBmb3Igc3VjY2Vzcy4JRXhhbXBsZTogPgoJCQk6bGV0IGZhaWxlZCA9IGFwcGVuZChsaW5lKCckJyksICIjIFRIRSBFTkQiKQoJCQk6bGV0IGZhaWxlZCA9IGFwcGVuZCgwLCBbIkNoYXB0ZXIgMSIsICJ0aGUgYmVnaW5uaW5nIl0pCjwKCQkJCQkJCSphcmdjKCkqCmFyZ2MoKQkJVGhlIHJlc3VsdCBpcyB0aGUgbnVtYmVyIG9mIGZpbGVzIGluIHRoZSBhcmd1bWVudCBsaXN0IG9mIHRoZQoJCWN1cnJlbnQgd2luZG93LiAgU2VlIHxhcmdsaXN0fC4KCgkJCQkJCQkqYXJnaWR4KCkqCmFyZ2lkeCgpCVRoZSByZXN1bHQgaXMgdGhlIGN1cnJlbnQgaW5kZXggaW4gdGhlIGFyZ3VtZW50IGxpc3QuICAwIGlzCgkJdGhlIGZpcnN0IGZpbGUuICBhcmdjKCkgLSAxIGlzIHRoZSBsYXN0IG9uZS4gIFNlZSB8YXJnbGlzdHwuCgoJCQkJCQkJKmFyZ3YoKSoKYXJndihbe25yfV0pCVRoZSByZXN1bHQgaXMgdGhlIHtucn10aCBmaWxlIGluIHRoZSBhcmd1bWVudCBsaXN0IG9mIHRoZQoJCWN1cnJlbnQgd2luZG93LiAgU2VlIHxhcmdsaXN0fC4gICJhcmd2KDApIiBpcyB0aGUgZmlyc3Qgb25lLgoJCUV4YW1wbGU6ID4KCTpsZXQgaSA9IDAKCTp3aGlsZSBpIDwgYXJnYygpCgk6ICBsZXQgZiA9IGVzY2FwZShmbmFtZWVzY2FwZShhcmd2KGkpKSwgJy4nKQoJOiAgZXhlICdhbWVudSBBcmcuJyAuIGYgLiAnIDplICcgLiBmIC4gJzxDUj4nCgk6ICBsZXQgaSA9IGkgKyAxCgk6ZW5kd2hpbGUKPAkJV2l0aG91dCB0aGUge25yfSBhcmd1bWVudCBhIHxMaXN0fCB3aXRoIHRoZSB3aG9sZSB8YXJnbGlzdHwgaXMKCQlyZXR1cm5lZC4KCmFzaW4oe2V4cHJ9KQkJCQkJCSphc2luKCkqCgkJUmV0dXJuIHRoZSBhcmMgc2luZSBvZiB7ZXhwcn0gbWVhc3VyZWQgaW4gcmFkaWFucywgYXMgYSB8RmxvYXR8CgkJaW4gdGhlIHJhbmdlIG9mIFstcGkvMiwgcGkvMl0uCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwgaW4gdGhlIHJhbmdlCgkJWy0xLCAxXS4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBhc2luKDAuOCkKPAkJCTAuOTI3Mjk1ID4KCQkJOmVjaG8gYXNpbigtMC41KQo8CQkJLTAuNTIzNTk5CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgphdGFuKHtleHByfSkJCQkJCQkqYXRhbigpKgoJCVJldHVybiB0aGUgcHJpbmNpcGFsIHZhbHVlIG9mIHRoZSBhcmMgdGFuZ2VudCBvZiB7ZXhwcn0sIGluCgkJdGhlIHJhbmdlIFstcGkvMiwgK3BpLzJdIHJhZGlhbnMsIGFzIGEgfEZsb2F0fC4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBhdGFuKDEwMCkKPAkJCTEuNTYwNzk3ID4KCQkJOmVjaG8gYXRhbigtNC4wMSkKPAkJCS0xLjMyNjQwNQoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKYXRhbjIoe2V4cHIxfSwge2V4cHIyfSkJCQkJCSphdGFuMigpKgoJCVJldHVybiB0aGUgYXJjIHRhbmdlbnQgb2Yge2V4cHIxfSAvIHtleHByMn0sIG1lYXN1cmVkIGluCgkJcmFkaWFucywgYXMgYSB8RmxvYXR8IGluIHRoZSByYW5nZSBbLXBpLCBwaV0uCgkJe2V4cHIxfSBhbmQge2V4cHIyfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGF0YW4yKC0xLCAxKQo8CQkJLTAuNzg1Mzk4ID4KCQkJOmVjaG8gYXRhbjIoMSwgLTEpCjwJCQkyLjM1NjE5NAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKCQkJCQkJCSpicm93c2UoKSoKYnJvd3NlKHtzYXZlfSwge3RpdGxlfSwge2luaXRkaXJ9LCB7ZGVmYXVsdH0pCgkJUHV0IHVwIGEgZmlsZSByZXF1ZXN0ZXIuICBUaGlzIG9ubHkgd29ya3Mgd2hlbiAiaGFzKCJicm93c2UiKSIKCQlyZXR1cm5zIG5vbi16ZXJvIChvbmx5IGluIHNvbWUgR1VJIHZlcnNpb25zKS4KCQlUaGUgaW5wdXQgZmllbGRzIGFyZToKCQkgICAge3NhdmV9CXdoZW4gbm9uLXplcm8sIHNlbGVjdCBmaWxlIHRvIHdyaXRlCgkJICAgIHt0aXRsZX0JdGl0bGUgZm9yIHRoZSByZXF1ZXN0ZXIKCQkgICAge2luaXRkaXJ9CWRpcmVjdG9yeSB0byBzdGFydCBicm93c2luZyBpbgoJCSAgICB7ZGVmYXVsdH0JZGVmYXVsdCBmaWxlIG5hbWUKCQlXaGVuIHRoZSAiQ2FuY2VsIiBidXR0b24gaXMgaGl0LCBzb21ldGhpbmcgd2VudCB3cm9uZywgb3IKCQlicm93c2luZyBpcyBub3QgcG9zc2libGUsIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCgkJCQkJCQkqYnJvd3NlZGlyKCkqCmJyb3dzZWRpcih7dGl0bGV9LCB7aW5pdGRpcn0pCgkJUHV0IHVwIGEgZGlyZWN0b3J5IHJlcXVlc3Rlci4gIFRoaXMgb25seSB3b3JrcyB3aGVuCgkJImhhcygiYnJvd3NlIikiIHJldHVybnMgbm9uLXplcm8gKG9ubHkgaW4gc29tZSBHVUkgdmVyc2lvbnMpLgoJCU9uIHN5c3RlbXMgd2hlcmUgYSBkaXJlY3RvcnkgYnJvd3NlciBpcyBub3Qgc3VwcG9ydGVkIGEgZmlsZQoJCWJyb3dzZXIgaXMgdXNlZC4gIEluIHRoYXQgY2FzZTogc2VsZWN0IGEgZmlsZSBpbiB0aGUgZGlyZWN0b3J5CgkJdG8gYmUgdXNlZC4KCQlUaGUgaW5wdXQgZmllbGRzIGFyZToKCQkgICAge3RpdGxlfQl0aXRsZSBmb3IgdGhlIHJlcXVlc3RlcgoJCSAgICB7aW5pdGRpcn0JZGlyZWN0b3J5IHRvIHN0YXJ0IGJyb3dzaW5nIGluCgkJV2hlbiB0aGUgIkNhbmNlbCIgYnV0dG9uIGlzIGhpdCwgc29tZXRoaW5nIHdlbnQgd3JvbmcsIG9yCgkJYnJvd3NpbmcgaXMgbm90IHBvc3NpYmxlLCBhbiBlbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuCgpidWZleGlzdHMoe2V4cHJ9KQkJCQkJKmJ1ZmV4aXN0cygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIGlmIGEgYnVmZmVyIGNhbGxlZAoJCXtleHByfSBleGlzdHMuCgkJSWYgdGhlIHtleHByfSBhcmd1bWVudCBpcyBhIG51bWJlciwgYnVmZmVyIG51bWJlcnMgYXJlIHVzZWQuCgkJSWYgdGhlIHtleHByfSBhcmd1bWVudCBpcyBhIHN0cmluZyBpdCBtdXN0IG1hdGNoIGEgYnVmZmVyIG5hbWUKCQlleGFjdGx5LiAgVGhlIG5hbWUgY2FuIGJlOgoJCS0gUmVsYXRpdmUgdG8gdGhlIGN1cnJlbnQgZGlyZWN0b3J5LgoJCS0gQSBmdWxsIHBhdGguCgkJLSBUaGUgbmFtZSBvZiBhIGJ1ZmZlciB3aXRoICdidWZ0eXBlJyBzZXQgdG8gIm5vZmlsZSIuCgkJLSBBIFVSTCBuYW1lLgoJCVVubGlzdGVkIGJ1ZmZlcnMgd2lsbCBiZSBmb3VuZC4KCQlOb3RlIHRoYXQgaGVscCBmaWxlcyBhcmUgbGlzdGVkIGJ5IHRoZWlyIHNob3J0IG5hbWUgaW4gdGhlCgkJb3V0cHV0IG9mIHw6YnVmZmVyc3wsIGJ1dCBidWZleGlzdHMoKSByZXF1aXJlcyB1c2luZyB0aGVpcgoJCWxvbmcgbmFtZSB0byBiZSBhYmxlIHRvIGZpbmQgdGhlbS4KCQlidWZleGlzdHMoKSBtYXkgcmVwb3J0IGEgYnVmZmVyIGV4aXN0cywgYnV0IHRvIHVzZSB0aGUgbmFtZQoJCXdpdGggYSB8OmJ1ZmZlcnwgY29tbWFuZCB5b3UgbWF5IG5lZWQgdG8gdXNlIHxleHBhbmQoKXwuICBFc3AKCQlmb3IgTVMtV2luZG93cyA4LjMgbmFtZXMgaW4gdGhlIGZvcm0gImM6XERPQ1VNRX4xIgoJCVVzZSAiYnVmZXhpc3RzKDApIiB0byB0ZXN0IGZvciB0aGUgZXhpc3RlbmNlIG9mIGFuIGFsdGVybmF0ZQoJCWZpbGUgbmFtZS4KCQkJCQkJCSpidWZmZXJfZXhpc3RzKCkqCgkJT2Jzb2xldGUgbmFtZTogYnVmZmVyX2V4aXN0cygpLgoKYnVmbGlzdGVkKHtleHByfSkJCQkJCSpidWZsaXN0ZWQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBub24temVybyBpZiBhIGJ1ZmZlciBjYWxsZWQKCQl7ZXhwcn0gZXhpc3RzIGFuZCBpcyBsaXN0ZWQgKGhhcyB0aGUgJ2J1Zmxpc3RlZCcgb3B0aW9uIHNldCkuCgkJVGhlIHtleHByfSBhcmd1bWVudCBpcyB1c2VkIGxpa2Ugd2l0aCB8YnVmZXhpc3RzKCl8LgoKYnVmbG9hZGVkKHtleHByfSkJCQkJCSpidWZsb2FkZWQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBub24temVybyBpZiBhIGJ1ZmZlciBjYWxsZWQKCQl7ZXhwcn0gZXhpc3RzIGFuZCBpcyBsb2FkZWQgKHNob3duIGluIGEgd2luZG93IG9yIGhpZGRlbikuCgkJVGhlIHtleHByfSBhcmd1bWVudCBpcyB1c2VkIGxpa2Ugd2l0aCB8YnVmZXhpc3RzKCl8LgoKYnVmbmFtZSh7ZXhwcn0pCQkJCQkJKmJ1Zm5hbWUoKSoKCQlUaGUgcmVzdWx0IGlzIHRoZSBuYW1lIG9mIGEgYnVmZmVyLCBhcyBpdCBpcyBkaXNwbGF5ZWQgYnkgdGhlCgkJIjpscyIgY29tbWFuZC4KCQlJZiB7ZXhwcn0gaXMgYSBOdW1iZXIsIHRoYXQgYnVmZmVyIG51bWJlcidzIG5hbWUgaXMgZ2l2ZW4uCgkJTnVtYmVyIHplcm8gaXMgdGhlIGFsdGVybmF0ZSBidWZmZXIgZm9yIHRoZSBjdXJyZW50IHdpbmRvdy4KCQlJZiB7ZXhwcn0gaXMgYSBTdHJpbmcsIGl0IGlzIHVzZWQgYXMgYSB8ZmlsZS1wYXR0ZXJufCB0byBtYXRjaAoJCXdpdGggdGhlIGJ1ZmZlciBuYW1lcy4JVGhpcyBpcyBhbHdheXMgZG9uZSBsaWtlICdtYWdpYycgaXMKCQlzZXQgYW5kICdjcG9wdGlvbnMnIGlzIGVtcHR5LiAgV2hlbiB0aGVyZSBpcyBtb3JlIHRoYW4gb25lCgkJbWF0Y2ggYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoJCSIiIG9yICIlIiBjYW4gYmUgdXNlZCBmb3IgdGhlIGN1cnJlbnQgYnVmZmVyLCAiIyIgZm9yIHRoZQoJCWFsdGVybmF0ZSBidWZmZXIuCgkJQSBmdWxsIG1hdGNoIGlzIHByZWZlcnJlZCwgb3RoZXJ3aXNlIGEgbWF0Y2ggYXQgdGhlIHN0YXJ0LCBlbmQKCQlvciBtaWRkbGUgb2YgdGhlIGJ1ZmZlciBuYW1lIGlzIGFjY2VwdGVkLiAgSWYgeW91IG9ubHkgd2FudCBhCgkJZnVsbCBtYXRjaCB0aGVuIHB1dCAiXiIgYXQgdGhlIHN0YXJ0IGFuZCAiJCIgYXQgdGhlIGVuZCBvZiB0aGUKCQlwYXR0ZXJuLgoJCUxpc3RlZCBidWZmZXJzIGFyZSBmb3VuZCBmaXJzdC4gIElmIHRoZXJlIGlzIGEgc2luZ2xlIG1hdGNoCgkJd2l0aCBhIGxpc3RlZCBidWZmZXIsIHRoYXQgb25lIGlzIHJldHVybmVkLiAgTmV4dCB1bmxpc3RlZAoJCWJ1ZmZlcnMgYXJlIHNlYXJjaGVkIGZvci4KCQlJZiB0aGUge2V4cHJ9IGlzIGEgU3RyaW5nLCBidXQgeW91IHdhbnQgdG8gdXNlIGl0IGFzIGEgYnVmZmVyCgkJbnVtYmVyLCBmb3JjZSBpdCB0byBiZSBhIE51bWJlciBieSBhZGRpbmcgemVybyB0byBpdDogPgoJCQk6ZWNobyBidWZuYW1lKCIzIiArIDApCjwJCUlmIHRoZSBidWZmZXIgZG9lc24ndCBleGlzdCwgb3IgZG9lc24ndCBoYXZlIGEgbmFtZSwgYW4gZW1wdHkKCQlzdHJpbmcgaXMgcmV0dXJuZWQuID4KCWJ1Zm5hbWUoIiMiKQkJYWx0ZXJuYXRlIGJ1ZmZlciBuYW1lCglidWZuYW1lKDMpCQluYW1lIG9mIGJ1ZmZlciAzCglidWZuYW1lKCIlIikJCW5hbWUgb2YgY3VycmVudCBidWZmZXIKCWJ1Zm5hbWUoImZpbGUyIikJbmFtZSBvZiBidWZmZXIgd2hlcmUgImZpbGUyIiBtYXRjaGVzLgo8CQkJCQkJCSpidWZmZXJfbmFtZSgpKgoJCU9ic29sZXRlIG5hbWU6IGJ1ZmZlcl9uYW1lKCkuCgoJCQkJCQkJKmJ1Zm5yKCkqCmJ1Zm5yKHtleHByfSBbLCB7Y3JlYXRlfV0pCgkJVGhlIHJlc3VsdCBpcyB0aGUgbnVtYmVyIG9mIGEgYnVmZmVyLCBhcyBpdCBpcyBkaXNwbGF5ZWQgYnkKCQl0aGUgIjpscyIgY29tbWFuZC4gIEZvciB0aGUgdXNlIG9mIHtleHByfSwgc2VlIHxidWZuYW1lKCl8CgkJYWJvdmUuCgkJSWYgdGhlIGJ1ZmZlciBkb2Vzbid0IGV4aXN0LCAtMSBpcyByZXR1cm5lZC4gIE9yLCBpZiB0aGUKCQl7Y3JlYXRlfSBhcmd1bWVudCBpcyBwcmVzZW50IGFuZCBub3QgemVybywgYSBuZXcsIHVubGlzdGVkLAoJCWJ1ZmZlciBpcyBjcmVhdGVkIGFuZCBpdHMgbnVtYmVyIGlzIHJldHVybmVkLgoJCWJ1Zm5yKCIkIikgaXMgdGhlIGxhc3QgYnVmZmVyOiA+Cgk6bGV0IGxhc3RfYnVmZmVyID0gYnVmbnIoIiQiKQo8CQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgaGlnaGVzdCBidWZmZXIgbnVtYmVyCgkJb2YgZXhpc3RpbmcgYnVmZmVycy4gIE5vdGUgdGhhdCBub3QgYWxsIGJ1ZmZlcnMgd2l0aCBhIHNtYWxsZXIKCQludW1iZXIgbmVjZXNzYXJpbHkgZXhpc3QsIGJlY2F1c2UgIjpid2lwZW91dCIgbWF5IGhhdmUgcmVtb3ZlZAoJCXRoZW0uICBVc2UgYnVmZXhpc3RzKCkgdG8gdGVzdCBmb3IgdGhlIGV4aXN0ZW5jZSBvZiBhIGJ1ZmZlci4KCQkJCQkJCSpidWZmZXJfbnVtYmVyKCkqCgkJT2Jzb2xldGUgbmFtZTogYnVmZmVyX251bWJlcigpLgoJCQkJCQkJKmxhc3RfYnVmZmVyX25yKCkqCgkJT2Jzb2xldGUgbmFtZSBmb3IgYnVmbnIoIiQiKTogbGFzdF9idWZmZXJfbnIoKS4KCmJ1Zndpbm5yKHtleHByfSkJCQkJCSpidWZ3aW5ucigpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgdGhlIGZpcnN0CgkJd2luZG93IGFzc29jaWF0ZWQgd2l0aCBidWZmZXIge2V4cHJ9LiAgRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9LAoJCXNlZSB8YnVmbmFtZSgpfCBhYm92ZS4JSWYgYnVmZmVyIHtleHByfSBkb2Vzbid0IGV4aXN0IG9yCgkJdGhlcmUgaXMgbm8gc3VjaCB3aW5kb3csIC0xIGlzIHJldHVybmVkLiAgRXhhbXBsZTogPgoKCWVjaG8gIkEgd2luZG93IGNvbnRhaW5pbmcgYnVmZmVyIDEgaXMgIiAuIChidWZ3aW5ucigxKSkKCjwJCVRoZSBudW1iZXIgY2FuIGJlIHVzZWQgd2l0aCB8Q1RSTC1XX3d8IGFuZCAiOndpbmNtZCB3IgoJCXw6d2luY21kfC4KCQlPbmx5IGRlYWxzIHdpdGggdGhlIGN1cnJlbnQgdGFiIHBhZ2UuCgoKYnl0ZTJsaW5lKHtieXRlfSkJCQkJCSpieXRlMmxpbmUoKSoKCQlSZXR1cm4gdGhlIGxpbmUgbnVtYmVyIHRoYXQgY29udGFpbnMgdGhlIGNoYXJhY3RlciBhdCBieXRlCgkJY291bnQge2J5dGV9IGluIHRoZSBjdXJyZW50IGJ1ZmZlci4gIFRoaXMgaW5jbHVkZXMgdGhlCgkJZW5kLW9mLWxpbmUgY2hhcmFjdGVyLCBkZXBlbmRpbmcgb24gdGhlICdmaWxlZm9ybWF0JyBvcHRpb24KCQlmb3IgdGhlIGN1cnJlbnQgYnVmZmVyLiAgVGhlIGZpcnN0IGNoYXJhY3RlciBoYXMgYnl0ZSBjb3VudAoJCW9uZS4KCQlBbHNvIHNlZSB8bGluZTJieXRlKCl8LCB8Z298IGFuZCB8OmdvdG98LgoJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtieXRlX29mZnNldHwKCQlmZWF0dXJlfQoKYnl0ZWlkeCh7ZXhwcn0sIHtucn0pCQkJCQkqYnl0ZWlkeCgpKgoJCVJldHVybiBieXRlIGluZGV4IG9mIHRoZSB7bnJ9J3RoIGNoYXJhY3RlciBpbiB0aGUgc3RyaW5nCgkJe2V4cHJ9LiAgVXNlIHplcm8gZm9yIHRoZSBmaXJzdCBjaGFyYWN0ZXIsIGl0IHJldHVybnMgemVyby4KCQlUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgdXNlZnVsIHdoZW4gdGhlcmUgYXJlIG11bHRpYnl0ZQoJCWNoYXJhY3RlcnMsIG90aGVyd2lzZSB0aGUgcmV0dXJuZWQgdmFsdWUgaXMgZXF1YWwgdG8ge25yfS4KCQlDb21wb3NpbmcgY2hhcmFjdGVycyBhcmUgY291bnRlZCBhcyBhIHNlcGFyYXRlIGNoYXJhY3Rlci4KCQlFeGFtcGxlIDogPgoJCQllY2hvIG1hdGNoc3RyKHN0ciwgIi4iLCBieXRlaWR4KHN0ciwgMykpCjwJCXdpbGwgZGlzcGxheSB0aGUgZm91cnRoIGNoYXJhY3Rlci4gIEFub3RoZXIgd2F5IHRvIGRvIHRoZQoJCXNhbWU6ID4KCQkJbGV0IHMgPSBzdHJwYXJ0KHN0ciwgYnl0ZWlkeChzdHIsIDMpKQoJCQllY2hvIHN0cnBhcnQocywgMCwgYnl0ZWlkeChzLCAxKSkKPAkJSWYgdGhlcmUgYXJlIGxlc3MgdGhhbiB7bnJ9IGNoYXJhY3RlcnMgLTEgaXMgcmV0dXJuZWQuCgkJSWYgdGhlcmUgYXJlIGV4YWN0bHkge25yfSBjaGFyYWN0ZXJzIHRoZSBsZW5ndGggb2YgdGhlIHN0cmluZwoJCWlzIHJldHVybmVkLgoKY2FsbCh7ZnVuY30sIHthcmdsaXN0fSBbLCB7ZGljdH1dKQkJCSpjYWxsKCkqICpFNjk5KgoJCUNhbGwgZnVuY3Rpb24ge2Z1bmN9IHdpdGggdGhlIGl0ZW1zIGluIHxMaXN0fCB7YXJnbGlzdH0gYXMKCQlhcmd1bWVudHMuCgkJe2Z1bmN9IGNhbiBlaXRoZXIgYmUgYSB8RnVuY3JlZnwgb3IgdGhlIG5hbWUgb2YgYSBmdW5jdGlvbi4KCQlhOmZpcnN0bGluZSBhbmQgYTpsYXN0bGluZSBhcmUgc2V0IHRvIHRoZSBjdXJzb3IgbGluZS4KCQlSZXR1cm5zIHRoZSByZXR1cm4gdmFsdWUgb2YgdGhlIGNhbGxlZCBmdW5jdGlvbi4KCQl7ZGljdH0gaXMgZm9yIGZ1bmN0aW9ucyB3aXRoIHRoZSAiZGljdCIgYXR0cmlidXRlLiAgSXQgd2lsbCBiZQoJCXVzZWQgdG8gc2V0IHRoZSBsb2NhbCB2YXJpYWJsZSAic2VsZiIuIHxEaWN0aW9uYXJ5LWZ1bmN0aW9ufAoKY2VpbCh7ZXhwcn0pCQkJCQkJCSpjZWlsKCkqCgkJUmV0dXJuIHRoZSBzbWFsbGVzdCBpbnRlZ3JhbCB2YWx1ZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8KCQl7ZXhwcn0gYXMgYSB8RmxvYXR8IChyb3VuZCB1cCkuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJZWNobyBjZWlsKDEuNDU2KQo8CQkJMi4wICA+CgkJCWVjaG8gY2VpbCgtNS40NTYpCjwJCQktNS4wICA+CgkJCWVjaG8gY2VpbCg0LjApCjwJCQk0LjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKY2hhbmdlbnIoKQkJCQkJCSpjaGFuZ2VucigpKgoJCVJldHVybiB0aGUgbnVtYmVyIG9mIHRoZSBtb3N0IHJlY2VudCBjaGFuZ2UuICBUaGlzIGlzIHRoZSBzYW1lCgkJbnVtYmVyIGFzIHdoYXQgaXMgZGlzcGxheWVkIHdpdGggfDp1bmRvbGlzdHwgYW5kIGNhbiBiZSB1c2VkCgkJd2l0aCB0aGUgfDp1bmRvfCBjb21tYW5kLgoJCVdoZW4gYSBjaGFuZ2Ugd2FzIG1hZGUgaXQgaXMgdGhlIG51bWJlciBvZiB0aGF0IGNoYW5nZS4gIEFmdGVyCgkJcmVkbyBpdCBpcyB0aGUgbnVtYmVyIG9mIHRoZSByZWRvbmUgY2hhbmdlLiAgQWZ0ZXIgdW5kbyBpdCBpcwoJCW9uZSBsZXNzIHRoYW4gdGhlIG51bWJlciBvZiB0aGUgdW5kb25lIGNoYW5nZS4KCmNoYXIybnIoe2V4cHJ9KQkJCQkJCSpjaGFyMm5yKCkqCgkJUmV0dXJuIG51bWJlciB2YWx1ZSBvZiB0aGUgZmlyc3QgY2hhciBpbiB7ZXhwcn0uICBFeGFtcGxlczogPgoJCQljaGFyMm5yKCIgIikJCXJldHVybnMgMzIKCQkJY2hhcjJucigiQUJDIikJCXJldHVybnMgNjUKPAkJVGhlIGN1cnJlbnQgJ2VuY29kaW5nJyBpcyB1c2VkLiAgRXhhbXBsZSBmb3IgInV0Zi04IjogPgoJCQljaGFyMm5yKCLhIikJCXJldHVybnMgMjI1CgkJCWNoYXIybnIoIuEiWzBdKQkJcmV0dXJucyAxOTUKPAkJQSBjb21iaW5pbmcgY2hhcmFjdGVyIGlzIGEgc2VwYXJhdGUgY2hhcmFjdGVyLgoJCXxucjJjaGFyKCl8IGRvZXMgdGhlIG9wcG9zaXRlLgoKY2luZGVudCh7bG51bX0pCQkJCQkJKmNpbmRlbnQoKSoKCQlHZXQgdGhlIGFtb3VudCBvZiBpbmRlbnQgZm9yIGxpbmUge2xudW19IGFjY29yZGluZyB0aGUgQwoJCWluZGVudGluZyBydWxlcywgYXMgd2l0aCAnY2luZGVudCcuCgkJVGhlIGluZGVudCBpcyBjb3VudGVkIGluIHNwYWNlcywgdGhlIHZhbHVlIG9mICd0YWJzdG9wJyBpcwoJCXJlbGV2YW50LiAge2xudW19IGlzIHVzZWQganVzdCBsaWtlIGluIHxnZXRsaW5lKCl8LgoJCVdoZW4ge2xudW19IGlzIGludmFsaWQgb3IgVmltIHdhcyBub3QgY29tcGlsZWQgdGhlIHwrY2luZGVudHwKCQlmZWF0dXJlLCAtMSBpcyByZXR1cm5lZC4KCQlTZWUgfEMtaW5kZW50aW5nfC4KCmNsZWFybWF0Y2hlcygpCQkJCQkJKmNsZWFybWF0Y2hlcygpKgoJCUNsZWFycyBhbGwgbWF0Y2hlcyBwcmV2aW91c2x5IGRlZmluZWQgYnkgfG1hdGNoYWRkKCl8IGFuZCB0aGUKCQl8Om1hdGNofCBjb21tYW5kcy4KCgkJCQkJCQkqY29sKCkqCmNvbCh7ZXhwcn0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBieXRlIGluZGV4IG9mIHRoZSBjb2x1bW4KCQlwb3NpdGlvbiBnaXZlbiB3aXRoIHtleHByfS4gIFRoZSBhY2NlcHRlZCBwb3NpdGlvbnMgYXJlOgoJCSAgICAuCSAgICB0aGUgY3Vyc29yIHBvc2l0aW9uCgkJICAgICQJICAgIHRoZSBlbmQgb2YgdGhlIGN1cnNvciBsaW5lICh0aGUgcmVzdWx0IGlzIHRoZQoJCQkgICAgbnVtYmVyIG9mIGNoYXJhY3RlcnMgaW4gdGhlIGN1cnNvciBsaW5lIHBsdXMgb25lKQoJCSAgICAneAkgICAgcG9zaXRpb24gb2YgbWFyayB4IChpZiB0aGUgbWFyayBpcyBub3Qgc2V0LCAwIGlzCgkJCSAgICByZXR1cm5lZCkKCQlBZGRpdGlvbmFsbHkge2V4cHJ9IGNhbiBiZSBbbG51bSwgY29sXTogYSB8TGlzdHwgd2l0aCB0aGUgbGluZQoJCWFuZCBjb2x1bW4gbnVtYmVyLiBNb3N0IHVzZWZ1bCB3aGVuIHRoZSBjb2x1bW4gaXMgIiQiLCB0byBnZXQKCQl0aGUgbGFzdCBjb2x1bW4gb2YgYSBzcGVjaWZpYyBsaW5lLiAgV2hlbiAibG51bSIgb3IgImNvbCIgaXMKCQlvdXQgb2YgcmFuZ2UgdGhlbiBjb2woKSByZXR1cm5zIHplcm8uCgkJVG8gZ2V0IHRoZSBsaW5lIG51bWJlciB1c2UgfGxpbmUoKXwuICBUbyBnZXQgYm90aCB1c2UKCQl8Z2V0cG9zKCl8LgoJCUZvciB0aGUgc2NyZWVuIGNvbHVtbiBwb3NpdGlvbiB1c2UgfHZpcnRjb2woKXwuCgkJTm90ZSB0aGF0IG9ubHkgbWFya3MgaW4gdGhlIGN1cnJlbnQgZmlsZSBjYW4gYmUgdXNlZC4KCQlFeGFtcGxlczogPgoJCQljb2woIi4iKQkJY29sdW1uIG9mIGN1cnNvcgoJCQljb2woIiQiKQkJbGVuZ3RoIG9mIGN1cnNvciBsaW5lIHBsdXMgb25lCgkJCWNvbCgiJ3QiKQkJY29sdW1uIG9mIG1hcmsgdAoJCQljb2woIiciIC4gbWFya25hbWUpCWNvbHVtbiBvZiBtYXJrIG1hcmtuYW1lCjwJCVRoZSBmaXJzdCBjb2x1bW4gaXMgMS4JMCBpcyByZXR1cm5lZCBmb3IgYW4gZXJyb3IuCgkJRm9yIGFuIHVwcGVyY2FzZSBtYXJrIHRoZSBjb2x1bW4gbWF5IGFjdHVhbGx5IGJlIGluIGFub3RoZXIKCQlidWZmZXIuCgkJRm9yIHRoZSBjdXJzb3IgcG9zaXRpb24sIHdoZW4gJ3ZpcnR1YWxlZGl0JyBpcyBhY3RpdmUsIHRoZQoJCWNvbHVtbiBpcyBvbmUgaGlnaGVyIGlmIHRoZSBjdXJzb3IgaXMgYWZ0ZXIgdGhlIGVuZCBvZiB0aGUKCQlsaW5lLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBvYnRhaW4gdGhlIGNvbHVtbiBpbiBJbnNlcnQgbW9kZTogPgoJCQk6aW1hcCA8RjI+IDxDLU8+OmxldCBzYXZlX3ZlID0gJnZlPENSPgoJCQkJXDxDLU8+OnNldCB2ZT1hbGw8Q1I+CgkJCQlcPEMtTz46ZWNobyBjb2woIi4iKSAuICJcbiIgPEJhcj4KCQkJCVxsZXQgJnZlID0gc2F2ZV92ZTxDUj4KPAoKY29tcGxldGUoe3N0YXJ0Y29sfSwge21hdGNoZXN9KQkJCSpjb21wbGV0ZSgpKiAqRTc4NSoKCQlTZXQgdGhlIG1hdGNoZXMgZm9yIEluc2VydCBtb2RlIGNvbXBsZXRpb24uCgkJQ2FuIG9ubHkgYmUgdXNlZCBpbiBJbnNlcnQgbW9kZS4gIFlvdSBuZWVkIHRvIHVzZSBhIG1hcHBpbmcKCQl3aXRoIENUUkwtUiA9IHxpX0NUUkwtUnwuICBJdCBkb2VzIG5vdCB3b3JrIGFmdGVyIENUUkwtTyBvcgoJCXdpdGggYW4gZXhwcmVzc2lvbiBtYXBwaW5nLgoJCXtzdGFydGNvbH0gaXMgdGhlIGJ5dGUgb2Zmc2V0IGluIHRoZSBsaW5lIHdoZXJlIHRoZSBjb21wbGV0ZWQKCQl0ZXh0IHN0YXJ0LiAgVGhlIHRleHQgdXAgdG8gdGhlIGN1cnNvciBpcyB0aGUgb3JpZ2luYWwgdGV4dAoJCXRoYXQgd2lsbCBiZSByZXBsYWNlZCBieSB0aGUgbWF0Y2hlcy4gIFVzZSBjb2woJy4nKSBmb3IgYW4KCQllbXB0eSBzdHJpbmcuICAiY29sKCcuJykgLSAxIiB3aWxsIHJlcGxhY2Ugb25lIGNoYXJhY3RlciBieSBhCgkJbWF0Y2guCgkJe21hdGNoZXN9IG11c3QgYmUgYSB8TGlzdHwuICBFYWNoIHxMaXN0fCBpdGVtIGlzIG9uZSBtYXRjaC4KCQlTZWUgfGNvbXBsZXRlLWl0ZW1zfCBmb3IgdGhlIGtpbmQgb2YgaXRlbXMgdGhhdCBhcmUgcG9zc2libGUuCgkJTm90ZSB0aGF0IHRoZSBhZnRlciBjYWxsaW5nIHRoaXMgZnVuY3Rpb24geW91IG5lZWQgdG8gYXZvaWQKCQlpbnNlcnRpbmcgYW55dGhpbmcgdGhhdCB3b3VsZCBjYXVzZSBjb21wbGV0aW9uIHRvIHN0b3AuCgkJVGhlIG1hdGNoIGNhbiBiZSBzZWxlY3RlZCB3aXRoIENUUkwtTiBhbmQgQ1RSTC1QIGFzIHVzdWFsIHdpdGgKCQlJbnNlcnQgbW9kZSBjb21wbGV0aW9uLiAgVGhlIHBvcHVwIG1lbnUgd2lsbCBhcHBlYXIgaWYKCQlzcGVjaWZpZWQsIHNlZSB8aW5zLWNvbXBsZXRpb24tbWVudXwuCgkJRXhhbXBsZTogPgoJaW5vcmVtYXAgPEY1PiA8Qy1SPj1MaXN0TW9udGhzKCk8Q1I+CgoJZnVuYyEgTGlzdE1vbnRocygpCgkgIGNhbGwgY29tcGxldGUoY29sKCcuJyksIFsnSmFudWFyeScsICdGZWJydWFyeScsICdNYXJjaCcsCgkJXCAnQXByaWwnLCAnTWF5JywgJ0p1bmUnLCAnSnVseScsICdBdWd1c3QnLCAnU2VwdGVtYmVyJywKCQlcICdPY3RvYmVyJywgJ05vdmVtYmVyJywgJ0RlY2VtYmVyJ10pCgkgIHJldHVybiAnJwoJZW5kZnVuYwo8CQlUaGlzIGlzbid0IHZlcnkgdXNlZnVsLCBidXQgaXQgc2hvd3MgaG93IGl0IHdvcmtzLiAgTm90ZSB0aGF0CgkJYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkIHRvIGF2b2lkIGEgemVybyBiZWluZyBpbnNlcnRlZC4KCmNvbXBsZXRlX2FkZCh7ZXhwcn0pCQkJCSpjb21wbGV0ZV9hZGQoKSoKCQlBZGQge2V4cHJ9IHRvIHRoZSBsaXN0IG9mIG1hdGNoZXMuICBPbmx5IHRvIGJlIHVzZWQgYnkgdGhlCgkJZnVuY3Rpb24gc3BlY2lmaWVkIHdpdGggdGhlICdjb21wbGV0ZWZ1bmMnIG9wdGlvbi4KCQlSZXR1cm5zIDAgZm9yIGZhaWx1cmUgKGVtcHR5IHN0cmluZyBvciBvdXQgb2YgbWVtb3J5KSwKCQkxIHdoZW4gdGhlIG1hdGNoIHdhcyBhZGRlZCwgMiB3aGVuIHRoZSBtYXRjaCB3YXMgYWxyZWFkeSBpbgoJCXRoZSBsaXN0LgoJCVNlZSB8Y29tcGxldGUtZnVuY3Rpb25zfCBmb3IgYW4gZXhwbGFuYXRpb24gb2Yge2V4cHJ9LglJdCBpcwoJCXRoZSBzYW1lIGFzIG9uZSBpdGVtIGluIHRoZSBsaXN0IHRoYXQgJ29tbmlmdW5jJyB3b3VsZCByZXR1cm4uCgpjb21wbGV0ZV9jaGVjaygpCQkJCSpjb21wbGV0ZV9jaGVjaygpKgoJCUNoZWNrIGZvciBhIGtleSB0eXBlZCB3aGlsZSBsb29raW5nIGZvciBjb21wbGV0aW9uIG1hdGNoZXMuCgkJVGhpcyBpcyB0byBiZSB1c2VkIHdoZW4gbG9va2luZyBmb3IgbWF0Y2hlcyB0YWtlcyBzb21lIHRpbWUuCgkJUmV0dXJucyBub24temVybyB3aGVuIHNlYXJjaGluZyBmb3IgbWF0Y2hlcyBpcyB0byBiZSBhYm9ydGVkLAoJCXplcm8gb3RoZXJ3aXNlLgoJCU9ubHkgdG8gYmUgdXNlZCBieSB0aGUgZnVuY3Rpb24gc3BlY2lmaWVkIHdpdGggdGhlCgkJJ2NvbXBsZXRlZnVuYycgb3B0aW9uLgoKCQkJCQkJKmNvbmZpcm0oKSoKY29uZmlybSh7bXNnfSBbLCB7Y2hvaWNlc30gWywge2RlZmF1bHR9IFssIHt0eXBlfV1dXSkKCQlDb25maXJtKCkgb2ZmZXJzIHRoZSB1c2VyIGEgZGlhbG9nLCBmcm9tIHdoaWNoIGEgY2hvaWNlIGNhbiBiZQoJCW1hZGUuICBJdCByZXR1cm5zIHRoZSBudW1iZXIgb2YgdGhlIGNob2ljZS4gIEZvciB0aGUgZmlyc3QKCQljaG9pY2UgdGhpcyBpcyAxLgoJCU5vdGU6IGNvbmZpcm0oKSBpcyBvbmx5IHN1cHBvcnRlZCB3aGVuIGNvbXBpbGVkIHdpdGggZGlhbG9nCgkJc3VwcG9ydCwgc2VlIHwrZGlhbG9nX2NvbnwgYW5kIHwrZGlhbG9nX2d1aXwuCgoJCXttc2d9IGlzIGRpc3BsYXllZCBpbiBhIHxkaWFsb2d8IHdpdGgge2Nob2ljZXN9IGFzIHRoZQoJCWFsdGVybmF0aXZlcy4gIFdoZW4ge2Nob2ljZXN9IGlzIG1pc3Npbmcgb3IgZW1wdHksICImT0siIGlzCgkJdXNlZCAoYW5kIHRyYW5zbGF0ZWQpLgoJCXttc2d9IGlzIGEgU3RyaW5nLCB1c2UgJ1xuJyB0byBpbmNsdWRlIGEgbmV3bGluZS4gIE9ubHkgb24KCQlzb21lIHN5c3RlbXMgdGhlIHN0cmluZyBpcyB3cmFwcGVkIHdoZW4gaXQgZG9lc24ndCBmaXQuCgoJCXtjaG9pY2VzfSBpcyBhIFN0cmluZywgd2l0aCB0aGUgaW5kaXZpZHVhbCBjaG9pY2VzIHNlcGFyYXRlZAoJCWJ5ICdcbicsIGUuZy4gPgoJCQljb25maXJtKCJTYXZlIGNoYW5nZXM/IiwgIiZZZXNcbiZOb1xuJkNhbmNlbCIpCjwJCVRoZSBsZXR0ZXIgYWZ0ZXIgdGhlICcmJyBpcyB0aGUgc2hvcnRjdXQga2V5IGZvciB0aGF0IGNob2ljZS4KCQlUaHVzIHlvdSBjYW4gdHlwZSAnYycgdG8gc2VsZWN0ICJDYW5jZWwiLiAgVGhlIHNob3J0Y3V0IGRvZXMKCQlub3QgbmVlZCB0byBiZSB0aGUgZmlyc3QgbGV0dGVyOiA+CgkJCWNvbmZpcm0oImZpbGUgaGFzIGJlZW4gbW9kaWZpZWQiLCAiJlNhdmVcblNhdmUgJkFsbCIpCjwJCUZvciB0aGUgY29uc29sZSwgdGhlIGZpcnN0IGxldHRlciBvZiBlYWNoIGNob2ljZSBpcyB1c2VkIGFzCgkJdGhlIGRlZmF1bHQgc2hvcnRjdXQga2V5LgoKCQlUaGUgb3B0aW9uYWwge2RlZmF1bHR9IGFyZ3VtZW50IGlzIHRoZSBudW1iZXIgb2YgdGhlIGNob2ljZQoJCXRoYXQgaXMgbWFkZSBpZiB0aGUgdXNlciBoaXRzIDxDUj4uICBVc2UgMSB0byBtYWtlIHRoZSBmaXJzdAoJCWNob2ljZSB0aGUgZGVmYXVsdCBvbmUuICBVc2UgMCB0byBub3Qgc2V0IGEgZGVmYXVsdC4gIElmCgkJe2RlZmF1bHR9IGlzIG9taXR0ZWQsIDEgaXMgdXNlZC4KCgkJVGhlIG9wdGlvbmFsIHt0eXBlfSBhcmd1bWVudCBnaXZlcyB0aGUgdHlwZSBvZiBkaWFsb2cuICBUaGlzCgkJaXMgb25seSB1c2VkIGZvciB0aGUgaWNvbiBvZiB0aGUgR1RLLCBNYWMsIE1vdGlmIGFuZCBXaW4zMgoJCUdVSS4gIEl0IGNhbiBiZSBvbmUgb2YgdGhlc2UgdmFsdWVzOiAiRXJyb3IiLCAiUXVlc3Rpb24iLAoJCSJJbmZvIiwgIldhcm5pbmciIG9yICJHZW5lcmljIi4gIE9ubHkgdGhlIGZpcnN0IGNoYXJhY3RlciBpcwoJCXJlbGV2YW50LiAgV2hlbiB7dHlwZX0gaXMgb21pdHRlZCwgIkdlbmVyaWMiIGlzIHVzZWQuCgoJCUlmIHRoZSB1c2VyIGFib3J0cyB0aGUgZGlhbG9nIGJ5IHByZXNzaW5nIDxFc2M+LCBDVFJMLUMsCgkJb3IgYW5vdGhlciB2YWxpZCBpbnRlcnJ1cHQga2V5LCBjb25maXJtKCkgcmV0dXJucyAwLgoKCQlBbiBleGFtcGxlOiA+CiAgIDpsZXQgY2hvaWNlID0gY29uZmlybSgiV2hhdCBkbyB5b3Ugd2FudD8iLCAiJkFwcGxlc1xuJk9yYW5nZXNcbiZCYW5hbmFzIiwgMikKICAgOmlmIGNob2ljZSA9PSAwCiAgIDoJZWNobyAibWFrZSB1cCB5b3VyIG1pbmQhIgogICA6ZWxzZWlmIGNob2ljZSA9PSAzCiAgIDoJZWNobyAidGFzdGVmdWwiCiAgIDplbHNlCiAgIDoJZWNobyAiSSBwcmVmZXIgYmFuYW5hcyBteXNlbGYuIgogICA6ZW5kaWYKPAkJSW4gYSBHVUkgZGlhbG9nLCBidXR0b25zIGFyZSB1c2VkLiAgVGhlIGxheW91dCBvZiB0aGUgYnV0dG9ucwoJCWRlcGVuZHMgb24gdGhlICd2JyBmbGFnIGluICdndWlvcHRpb25zJy4gIElmIGl0IGlzIGluY2x1ZGVkLAoJCXRoZSBidXR0b25zIGFyZSBhbHdheXMgcHV0IHZlcnRpY2FsbHkuCU90aGVyd2lzZSwgIGNvbmZpcm0oKQoJCXRyaWVzIHRvIHB1dCB0aGUgYnV0dG9ucyBpbiBvbmUgaG9yaXpvbnRhbCBsaW5lLiAgSWYgdGhleQoJCWRvbid0IGZpdCwgYSB2ZXJ0aWNhbCBsYXlvdXQgaXMgdXNlZCBhbnl3YXkuICBGb3Igc29tZSBzeXN0ZW1zCgkJdGhlIGhvcml6b250YWwgbGF5b3V0IGlzIGFsd2F5cyB1c2VkLgoKCQkJCQkJCSpjb3B5KCkqCmNvcHkoe2V4cHJ9KQlNYWtlIGEgY29weSBvZiB7ZXhwcn0uCUZvciBOdW1iZXJzIGFuZCBTdHJpbmdzIHRoaXMgaXNuJ3QKCQlkaWZmZXJlbnQgZnJvbSB1c2luZyB7ZXhwcn0gZGlyZWN0bHkuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgYSBzaGFsbG93IGNvcHkgaXMgY3JlYXRlZC4gIFRoaXMgbWVhbnMKCQl0aGF0IHRoZSBvcmlnaW5hbCB8TGlzdHwgY2FuIGJlIGNoYW5nZWQgd2l0aG91dCBjaGFuZ2luZyB0aGUKCQljb3B5LCBhbmQgdmljZSB2ZXJzYS4gIEJ1dCB0aGUgaXRlbXMgYXJlIGlkZW50aWNhbCwgdGh1cwoJCWNoYW5naW5nIGFuIGl0ZW0gY2hhbmdlcyB0aGUgY29udGVudHMgb2YgYm90aCB8TGlzdHN8LglBbHNvCgkJc2VlIHxkZWVwY29weSgpfC4KCmNvcyh7ZXhwcn0pCQkJCQkJKmNvcygpKgoJCVJldHVybiB0aGUgY29zaW5lIG9mIHtleHByfSwgbWVhc3VyZWQgaW4gcmFkaWFucywgYXMgYSB8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGNvcygxMDApCjwJCQkwLjg2MjMxOSA+CgkJCTplY2hvIGNvcygtNC4wMSkKPAkJCS0wLjY0NjA0MwoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKY29zaCh7ZXhwcn0pCQkJCQkJKmNvc2goKSoKCQlSZXR1cm4gdGhlIGh5cGVyYm9saWMgY29zaW5lIG9mIHtleHByfSBhcyBhIHxGbG9hdHwgaW4gdGhlIHJhbmdlCgkJWzEsIGluZl0uCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gY29zaCgwLjUpCjwJCQkxLjEyNzYyNiA+CgkJCTplY2hvIGNvc2goLTAuNSkKPAkJCS0xLjEyNzYyNgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoJCQpjb3VudCh7Y29tcH0sIHtleHByfSBbLCB7aWN9IFssIHtzdGFydH1dXSkJCQkqY291bnQoKSoKCQlSZXR1cm4gdGhlIG51bWJlciBvZiB0aW1lcyBhbiBpdGVtIHdpdGggdmFsdWUge2V4cHJ9IGFwcGVhcnMKCQlpbiB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IHtjb21wfS4KCQlJZiB7c3RhcnR9IGlzIGdpdmVuIHRoZW4gc3RhcnQgd2l0aCB0aGUgaXRlbSB3aXRoIHRoaXMgaW5kZXguCgkJe3N0YXJ0fSBjYW4gb25seSBiZSB1c2VkIHdpdGggYSB8TGlzdHwuCgkJV2hlbiB7aWN9IGlzIGdpdmVuIGFuZCBpdCdzIG5vbi16ZXJvIHRoZW4gY2FzZSBpcyBpZ25vcmVkLgoKCgkJCQkJCQkqY3Njb3BlX2Nvbm5lY3Rpb24oKSoKY3Njb3BlX2Nvbm5lY3Rpb24oW3tudW19ICwge2RicGF0aH0gWywge3ByZXBlbmR9XV0pCgkJQ2hlY2tzIGZvciB0aGUgZXhpc3RlbmNlIG9mIGEgfGNzY29wZXwgY29ubmVjdGlvbi4gIElmIG5vCgkJcGFyYW1ldGVycyBhcmUgc3BlY2lmaWVkLCB0aGVuIHRoZSBmdW5jdGlvbiByZXR1cm5zOgoJCQkwLCBpZiBjc2NvcGUgd2FzIG5vdCBhdmFpbGFibGUgKG5vdCBjb21waWxlZCBpbiksIG9yCgkJCSAgIGlmIHRoZXJlIGFyZSBubyBjc2NvcGUgY29ubmVjdGlvbnM7CgkJCTEsIGlmIHRoZXJlIGlzIGF0IGxlYXN0IG9uZSBjc2NvcGUgY29ubmVjdGlvbi4KCgkJSWYgcGFyYW1ldGVycyBhcmUgc3BlY2lmaWVkLCB0aGVuIHRoZSB2YWx1ZSBvZiB7bnVtfQoJCWRldGVybWluZXMgaG93IGV4aXN0ZW5jZSBvZiBhIGNzY29wZSBjb25uZWN0aW9uIGlzIGNoZWNrZWQ6CgoJCXtudW19CURlc2NyaXB0aW9uIG9mIGV4aXN0ZW5jZSBjaGVjawoJCS0tLS0tCS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoJCTAJU2FtZSBhcyBubyBwYXJhbWV0ZXJzIChlLmcuLCAiY3Njb3BlX2Nvbm5lY3Rpb24oKSIpLgoJCTEJSWdub3JlIHtwcmVwZW5kfSwgYW5kIHVzZSBwYXJ0aWFsIHN0cmluZyBtYXRjaGVzIGZvcgoJCQl7ZGJwYXRofS4KCQkyCUlnbm9yZSB7cHJlcGVuZH0sIGFuZCB1c2UgZXhhY3Qgc3RyaW5nIG1hdGNoZXMgZm9yCgkJCXtkYnBhdGh9LgoJCTMJVXNlIHtwcmVwZW5kfSwgdXNlIHBhcnRpYWwgc3RyaW5nIG1hdGNoZXMgZm9yIGJvdGgKCQkJe2RicGF0aH0gYW5kIHtwcmVwZW5kfS4KCQk0CVVzZSB7cHJlcGVuZH0sIHVzZSBleGFjdCBzdHJpbmcgbWF0Y2hlcyBmb3IgYm90aAoJCQl7ZGJwYXRofSBhbmQge3ByZXBlbmR9LgoKCQlOb3RlOiBBbGwgc3RyaW5nIGNvbXBhcmlzb25zIGFyZSBjYXNlIHNlbnNpdGl2ZSEKCgkJRXhhbXBsZXMuICBTdXBwb3NlIHdlIGhhZCB0aGUgZm9sbG93aW5nIChmcm9tICI6Y3Mgc2hvdyIpOiA+CgogICMgcGlkICAgIGRhdGFiYXNlIG5hbWUJCQlwcmVwZW5kIHBhdGgKICAwIDI3NjY0ICBjc2NvcGUub3V0CQkJCS91c3IvbG9jYWwKPAoJCUludm9jYXRpb24JCQkJCVJldHVybiBWYWwgfgoJCS0tLS0tLS0tLS0JCQkJCS0tLS0tLS0tLS0gPgoJCWNzY29wZV9jb25uZWN0aW9uKCkJCQkJCTEKCQljc2NvcGVfY29ubmVjdGlvbigxLCAib3V0IikJCQkJMQoJCWNzY29wZV9jb25uZWN0aW9uKDIsICJvdXQiKQkJCQkwCgkJY3Njb3BlX2Nvbm5lY3Rpb24oMywgIm91dCIpCQkJCTAKCQljc2NvcGVfY29ubmVjdGlvbigzLCAib3V0IiwgImxvY2FsIikJCQkxCgkJY3Njb3BlX2Nvbm5lY3Rpb24oNCwgIm91dCIpCQkJCTAKCQljc2NvcGVfY29ubmVjdGlvbig0LCAib3V0IiwgImxvY2FsIikJCQkwCgkJY3Njb3BlX2Nvbm5lY3Rpb24oNCwgImNzY29wZS5vdXQiLCAiL3Vzci9sb2NhbCIpCTEKPApjdXJzb3Ioe2xudW19LCB7Y29sfSBbLCB7b2ZmfV0pCQkJCSpjdXJzb3IoKSoKY3Vyc29yKHtsaXN0fSkKCQlQb3NpdGlvbnMgdGhlIGN1cnNvciBhdCB0aGUgY29sdW1uIChieXRlIGNvdW50KSB7Y29sfSBpbiB0aGUKCQlsaW5lIHtsbnVtfS4gIFRoZSBmaXJzdCBjb2x1bW4gaXMgb25lLgoJCVdoZW4gdGhlcmUgaXMgb25lIGFyZ3VtZW50IHtsaXN0fSB0aGlzIGlzIHVzZWQgYXMgYSB8TGlzdHwKCQl3aXRoIHR3byBvciB0aHJlZSBpdGVtcyB7bG51bX0sIHtjb2x9IGFuZCB7b2ZmfS4gIFRoaXMgaXMgbGlrZQoJCXRoZSByZXR1cm4gdmFsdWUgb2YgfGdldHBvcygpfCwgYnV0IHdpdGhvdXQgdGhlIGZpcnN0IGl0ZW0uCgkJRG9lcyBub3QgY2hhbmdlIHRoZSBqdW1wbGlzdC4KCQlJZiB7bG51bX0gaXMgZ3JlYXRlciB0aGFuIHRoZSBudW1iZXIgb2YgbGluZXMgaW4gdGhlIGJ1ZmZlciwKCQl0aGUgY3Vyc29yIHdpbGwgYmUgcG9zaXRpb25lZCBhdCB0aGUgbGFzdCBsaW5lIGluIHRoZSBidWZmZXIuCgkJSWYge2xudW19IGlzIHplcm8sIHRoZSBjdXJzb3Igd2lsbCBzdGF5IGluIHRoZSBjdXJyZW50IGxpbmUuCgkJSWYge2NvbH0gaXMgZ3JlYXRlciB0aGFuIHRoZSBudW1iZXIgb2YgYnl0ZXMgaW4gdGhlIGxpbmUsCgkJdGhlIGN1cnNvciB3aWxsIGJlIHBvc2l0aW9uZWQgYXQgdGhlIGxhc3QgY2hhcmFjdGVyIGluIHRoZQoJCWxpbmUuCgkJSWYge2NvbH0gaXMgemVybywgdGhlIGN1cnNvciB3aWxsIHN0YXkgaW4gdGhlIGN1cnJlbnQgY29sdW1uLgoJCVdoZW4gJ3ZpcnR1YWxlZGl0JyBpcyB1c2VkIHtvZmZ9IHNwZWNpZmllcyB0aGUgb2Zmc2V0IGluCgkJc2NyZWVuIGNvbHVtbnMgZnJvbSB0aGUgc3RhcnQgb2YgdGhlIGNoYXJhY3Rlci4gIEUuZy4sIGEKCQlwb3NpdGlvbiB3aXRoaW4gYSA8VGFiPiBvciBhZnRlciB0aGUgbGFzdCBjaGFyYWN0ZXIuCgkJUmV0dXJucyAwIHdoZW4gdGhlIHBvc2l0aW9uIGNvdWxkIGJlIHNldCwgLTEgb3RoZXJ3aXNlLgoKCmRlZXBjb3B5KHtleHByfVssIHtub3JlZn1dKQkJCQkqZGVlcGNvcHkoKSogKkU2OTgqCgkJTWFrZSBhIGNvcHkgb2Yge2V4cHJ9LglGb3IgTnVtYmVycyBhbmQgU3RyaW5ncyB0aGlzIGlzbid0CgkJZGlmZmVyZW50IGZyb20gdXNpbmcge2V4cHJ9IGRpcmVjdGx5LgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IGEgZnVsbCBjb3B5IGlzIGNyZWF0ZWQuICBUaGlzIG1lYW5zCgkJdGhhdCB0aGUgb3JpZ2luYWwgfExpc3R8IGNhbiBiZSBjaGFuZ2VkIHdpdGhvdXQgY2hhbmdpbmcgdGhlCgkJY29weSwgYW5kIHZpY2UgdmVyc2EuICBXaGVuIGFuIGl0ZW0gaXMgYSB8TGlzdHwsIGEgY29weSBmb3IgaXQKCQlpcyBtYWRlLCByZWN1cnNpdmVseS4gIFRodXMgY2hhbmdpbmcgYW4gaXRlbSBpbiB0aGUgY29weSBkb2VzCgkJbm90IGNoYW5nZSB0aGUgY29udGVudHMgb2YgdGhlIG9yaWdpbmFsIHxMaXN0fC4KCQlXaGVuIHtub3JlZn0gaXMgb21pdHRlZCBvciB6ZXJvIGEgY29udGFpbmVkIHxMaXN0fCBvcgoJCXxEaWN0aW9uYXJ5fCBpcyBvbmx5IGNvcGllZCBvbmNlLiAgQWxsIHJlZmVyZW5jZXMgcG9pbnQgdG8KCQl0aGlzIHNpbmdsZSBjb3B5LiAgV2l0aCB7bm9yZWZ9IHNldCB0byAxIGV2ZXJ5IG9jY3VycmVuY2Ugb2YgYQoJCXxMaXN0fCBvciB8RGljdGlvbmFyeXwgcmVzdWx0cyBpbiBhIG5ldyBjb3B5LiAgVGhpcyBhbHNvIG1lYW5zCgkJdGhhdCBhIGN5Y2xpYyByZWZlcmVuY2UgY2F1c2VzIGRlZXBjb3B5KCkgdG8gZmFpbC4KCQkJCQkJCQkqRTcyNCoKCQlOZXN0aW5nIGlzIHBvc3NpYmxlIHVwIHRvIDEwMCBsZXZlbHMuICBXaGVuIHRoZXJlIGlzIGFuIGl0ZW0KCQl0aGF0IHJlZmVycyBiYWNrIHRvIGEgaGlnaGVyIGxldmVsIG1ha2luZyBhIGRlZXAgY29weSB3aXRoCgkJe25vcmVmfSBzZXQgdG8gMSB3aWxsIGZhaWwuCgkJQWxzbyBzZWUgfGNvcHkoKXwuCgpkZWxldGUoe2ZuYW1lfSkJCQkJCQkJKmRlbGV0ZSgpKgoJCURlbGV0ZXMgdGhlIGZpbGUgYnkgdGhlIG5hbWUge2ZuYW1lfS4gIFRoZSByZXN1bHQgaXMgYSBOdW1iZXIsCgkJd2hpY2ggaXMgMCBpZiB0aGUgZmlsZSB3YXMgZGVsZXRlZCBzdWNjZXNzZnVsbHksIGFuZCBub24temVybwoJCXdoZW4gdGhlIGRlbGV0aW9uIGZhaWxlZC4KCQlVc2UgfHJlbW92ZSgpfCB0byBkZWxldGUgYW4gaXRlbSBmcm9tIGEgfExpc3R8LgoKCQkJCQkJCSpkaWRfZmlsZXR5cGUoKSoKZGlkX2ZpbGV0eXBlKCkJUmV0dXJucyBub24temVybyB3aGVuIGF1dG9jb21tYW5kcyBhcmUgYmVpbmcgZXhlY3V0ZWQgYW5kIHRoZQoJCUZpbGVUeXBlIGV2ZW50IGhhcyBiZWVuIHRyaWdnZXJlZCBhdCBsZWFzdCBvbmNlLiAgQ2FuIGJlIHVzZWQKCQl0byBhdm9pZCB0cmlnZ2VyaW5nIHRoZSBGaWxlVHlwZSBldmVudCBhZ2FpbiBpbiB0aGUgc2NyaXB0cwoJCXRoYXQgZGV0ZWN0IHRoZSBmaWxlIHR5cGUuIHxGaWxlVHlwZXwKCQlXaGVuIGVkaXRpbmcgYW5vdGhlciBmaWxlLCB0aGUgY291bnRlciBpcyByZXNldCwgdGh1cyB0aGlzCgkJcmVhbGx5IGNoZWNrcyBpZiB0aGUgRmlsZVR5cGUgZXZlbnQgaGFzIGJlZW4gdHJpZ2dlcmVkIGZvciB0aGUKCQljdXJyZW50IGJ1ZmZlci4gIFRoaXMgYWxsb3dzIGFuIGF1dG9jb21tYW5kIHRoYXQgc3RhcnRzCgkJZWRpdGluZyBhbm90aGVyIGJ1ZmZlciB0byBzZXQgJ2ZpbGV0eXBlJyBhbmQgbG9hZCBhIHN5bnRheAoJCWZpbGUuCgpkaWZmX2ZpbGxlcih7bG51bX0pCQkJCQkqZGlmZl9maWxsZXIoKSoKCQlSZXR1cm5zIHRoZSBudW1iZXIgb2YgZmlsbGVyIGxpbmVzIGFib3ZlIGxpbmUge2xudW19LgoJCVRoZXNlIGFyZSB0aGUgbGluZXMgdGhhdCB3ZXJlIGluc2VydGVkIGF0IHRoaXMgcG9pbnQgaW4KCQlhbm90aGVyIGRpZmYnZWQgd2luZG93LiAgVGhlc2UgZmlsbGVyIGxpbmVzIGFyZSBzaG93biBpbiB0aGUKCQlkaXNwbGF5IGJ1dCBkb24ndCBleGlzdCBpbiB0aGUgYnVmZmVyLgoJCXtsbnVtfSBpcyB1c2VkIGxpa2Ugd2l0aCB8Z2V0bGluZSgpfC4gIFRodXMgIi4iIGlzIHRoZSBjdXJyZW50CgkJbGluZSwgIidtIiBtYXJrIG0sIGV0Yy4KCQlSZXR1cm5zIDAgaWYgdGhlIGN1cnJlbnQgd2luZG93IGlzIG5vdCBpbiBkaWZmIG1vZGUuCgpkaWZmX2hsSUQoe2xudW19LCB7Y29sfSkJCQkJKmRpZmZfaGxJRCgpKgoJCVJldHVybnMgdGhlIGhpZ2hsaWdodCBJRCBmb3IgZGlmZiBtb2RlIGF0IGxpbmUge2xudW19IGNvbHVtbgoJCXtjb2x9IChieXRlIGluZGV4KS4gIFdoZW4gdGhlIGN1cnJlbnQgbGluZSBkb2VzIG5vdCBoYXZlIGEKCQlkaWZmIGNoYW5nZSB6ZXJvIGlzIHJldHVybmVkLgoJCXtsbnVtfSBpcyB1c2VkIGxpa2Ugd2l0aCB8Z2V0bGluZSgpfC4gIFRodXMgIi4iIGlzIHRoZSBjdXJyZW50CgkJbGluZSwgIidtIiBtYXJrIG0sIGV0Yy4KCQl7Y29sfSBpcyAxIGZvciB0aGUgbGVmdG1vc3QgY29sdW1uLCB7bG51bX0gaXMgMSBmb3IgdGhlIGZpcnN0CgkJbGluZS4KCQlUaGUgaGlnaGxpZ2h0IElEIGNhbiBiZSB1c2VkIHdpdGggfHN5bklEYXR0cigpfCB0byBvYnRhaW4KCQlzeW50YXggaW5mb3JtYXRpb24gYWJvdXQgdGhlIGhpZ2hsaWdodGluZy4KCmVtcHR5KHtleHByfSkJCQkJCQkqZW1wdHkoKSoKCQlSZXR1cm4gdGhlIE51bWJlciAxIGlmIHtleHByfSBpcyBlbXB0eSwgemVybyBvdGhlcndpc2UuCgkJQSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IGlzIGVtcHR5IHdoZW4gaXQgZG9lcyBub3QgaGF2ZSBhbnkKCQlpdGVtcy4JQSBOdW1iZXIgaXMgZW1wdHkgd2hlbiBpdHMgdmFsdWUgaXMgemVyby4KCQlGb3IgYSBsb25nIHxMaXN0fCB0aGlzIGlzIG11Y2ggZmFzdGVyIHRoYW4gY29tcGFyaW5nIHRoZQoJCWxlbmd0aCB3aXRoIHplcm8uCgplc2NhcGUoe3N0cmluZ30sIHtjaGFyc30pCQkJCSplc2NhcGUoKSoKCQlFc2NhcGUgdGhlIGNoYXJhY3RlcnMgaW4ge2NoYXJzfSB0aGF0IG9jY3VyIGluIHtzdHJpbmd9IHdpdGggYQoJCWJhY2tzbGFzaC4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gZXNjYXBlKCdjOlxwcm9ncmFtIGZpbGVzXHZpbScsICcgXCcpCjwJCXJlc3VsdHMgaW46ID4KCQkJYzpcXHByb2dyYW1cIGZpbGVzXFx2aW0KPAkJQWxzbyBzZWUgfHNoZWxsZXNjYXBlKCl8LgoKCQkJCQkJCSpldmFsKCkqCmV2YWwoe3N0cmluZ30pCUV2YWx1YXRlIHtzdHJpbmd9IGFuZCByZXR1cm4gdGhlIHJlc3VsdC4gIEVzcGVjaWFsbHkgdXNlZnVsIHRvCgkJdHVybiB0aGUgcmVzdWx0IG9mIHxzdHJpbmcoKXwgYmFjayBpbnRvIHRoZSBvcmlnaW5hbCB2YWx1ZS4KCQlUaGlzIHdvcmtzIGZvciBOdW1iZXJzLCBGbG9hdHMsIFN0cmluZ3MgYW5kIGNvbXBvc2l0ZXMgb2YKCQl0aGVtLiAgQWxzbyB3b3JrcyBmb3IgfEZ1bmNyZWZ8cyB0aGF0IHJlZmVyIHRvIGV4aXN0aW5nCgkJZnVuY3Rpb25zLgoKZXZlbnRoYW5kbGVyKCkJCQkJCQkqZXZlbnRoYW5kbGVyKCkqCgkJUmV0dXJucyAxIHdoZW4gaW5zaWRlIGFuIGV2ZW50IGhhbmRsZXIuICBUaGF0IGlzIHRoYXQgVmltIGdvdAoJCWludGVycnVwdGVkIHdoaWxlIHdhaXRpbmcgZm9yIHRoZSB1c2VyIHRvIHR5cGUgYSBjaGFyYWN0ZXIsCgkJZS5nLiwgd2hlbiBkcm9wcGluZyBhIGZpbGUgb24gVmltLiAgVGhpcyBtZWFucyBpbnRlcmFjdGl2ZQoJCWNvbW1hbmRzIGNhbm5vdCBiZSB1c2VkLiAgT3RoZXJ3aXNlIHplcm8gaXMgcmV0dXJuZWQuCgpleGVjdXRhYmxlKHtleHByfSkJCQkJCSpleGVjdXRhYmxlKCkqCgkJVGhpcyBmdW5jdGlvbiBjaGVja3MgaWYgYW4gZXhlY3V0YWJsZSB3aXRoIHRoZSBuYW1lIHtleHByfQoJCWV4aXN0cy4gIHtleHByfSBtdXN0IGJlIHRoZSBuYW1lIG9mIHRoZSBwcm9ncmFtIHdpdGhvdXQgYW55CgkJYXJndW1lbnRzLgoJCWV4ZWN1dGFibGUoKSB1c2VzIHRoZSB2YWx1ZSBvZiAkUEFUSCBhbmQvb3IgdGhlIG5vcm1hbAoJCXNlYXJjaHBhdGggZm9yIHByb2dyYW1zLgkJKlBBVEhFWFQqCgkJT24gTVMtRE9TIGFuZCBNUy1XaW5kb3dzIHRoZSAiLmV4ZSIsICIuYmF0IiwgZXRjLiBjYW4KCQlvcHRpb25hbGx5IGJlIGluY2x1ZGVkLiAgVGhlbiB0aGUgZXh0ZW5zaW9ucyBpbiAkUEFUSEVYVCBhcmUKCQl0cmllZC4JVGh1cyBpZiAiZm9vLmV4ZSIgZG9lcyBub3QgZXhpc3QsICJmb28uZXhlLmJhdCIgY2FuIGJlCgkJZm91bmQuCUlmICRQQVRIRVhUIGlzIG5vdCBzZXQgdGhlbiAiLmV4ZTsuY29tOy5iYXQ7LmNtZCIgaXMKCQl1c2VkLiAgQSBkb3QgYnkgaXRzZWxmIGNhbiBiZSB1c2VkIGluICRQQVRIRVhUIHRvIHRyeSB1c2luZwoJCXRoZSBuYW1lIHdpdGhvdXQgYW4gZXh0ZW5zaW9uLglXaGVuICdzaGVsbCcgbG9va3MgbGlrZSBhCgkJVW5peCBzaGVsbCwgdGhlbiB0aGUgbmFtZSBpcyBhbHNvIHRyaWVkIHdpdGhvdXQgYWRkaW5nIGFuCgkJZXh0ZW5zaW9uLgoJCU9uIE1TLURPUyBhbmQgTVMtV2luZG93cyBpdCBvbmx5IGNoZWNrcyBpZiB0aGUgZmlsZSBleGlzdHMgYW5kCgkJaXMgbm90IGEgZGlyZWN0b3J5LCBub3QgaWYgaXQncyByZWFsbHkgZXhlY3V0YWJsZS4KCQlPbiBNUy1XaW5kb3dzIGFuIGV4ZWN1dGFibGUgaW4gdGhlIHNhbWUgZGlyZWN0b3J5IGFzIFZpbSBpcwoJCWFsd2F5cyBmb3VuZC4gIFNpbmNlIHRoaXMgZGlyZWN0b3J5IGlzIGFkZGVkIHRvICRQQVRIIGl0CgkJc2hvdWxkIGFsc28gd29yayB0byBleGVjdXRlIGl0IHx3aW4zMi1QQVRIfC4KCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyOgoJCQkxCWV4aXN0cwoJCQkwCWRvZXMgbm90IGV4aXN0CgkJCS0xCW5vdCBpbXBsZW1lbnRlZCBvbiB0aGlzIHN5c3RlbQoKCQkJCQkJCSpleGlzdHMoKSoKZXhpc3RzKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gaWYge2V4cHJ9IGlzCgkJZGVmaW5lZCwgemVybyBvdGhlcndpc2UuICBUaGUge2V4cHJ9IGFyZ3VtZW50IGlzIGEgc3RyaW5nLAoJCXdoaWNoIGNvbnRhaW5zIG9uZSBvZiB0aGVzZToKCQkJJm9wdGlvbi1uYW1lCVZpbSBvcHRpb24gKG9ubHkgY2hlY2tzIGlmIGl0IGV4aXN0cywKCQkJCQlub3QgaWYgaXQgcmVhbGx5IHdvcmtzKQoJCQkrb3B0aW9uLW5hbWUJVmltIG9wdGlvbiB0aGF0IHdvcmtzLgoJCQkkRU5WTkFNRQllbnZpcm9ubWVudCB2YXJpYWJsZSAoY291bGQgYWxzbyBiZQoJCQkJCWRvbmUgYnkgY29tcGFyaW5nIHdpdGggYW4gZW1wdHkKCQkJCQlzdHJpbmcpCgkJCSpmdW5jbmFtZQlidWlsdC1pbiBmdW5jdGlvbiAoc2VlIHxmdW5jdGlvbnN8KQoJCQkJCW9yIHVzZXIgZGVmaW5lZCBmdW5jdGlvbiAoc2VlCgkJCQkJfHVzZXItZnVuY3Rpb25zfCkuCgkJCXZhcm5hbWUJCWludGVybmFsIHZhcmlhYmxlIChzZWUKCQkJCQl8aW50ZXJuYWwtdmFyaWFibGVzfCkuCUFsc28gd29ya3MKCQkJCQlmb3IgfGN1cmx5LWJyYWNlcy1uYW1lc3wsIHxEaWN0aW9uYXJ5fAoJCQkJCWVudHJpZXMsIHxMaXN0fCBpdGVtcywgZXRjLiAgQmV3YXJlCgkJCQkJdGhhdCBldmFsdWF0aW5nIGFuIGluZGV4IG1heSBjYXVzZSBhbgoJCQkJCWVycm9yIG1lc3NhZ2UgZm9yIGFuIGludmFsaWQKCQkJCQlleHByZXNzaW9uLiAgRS5nLjogPgoJCQkJCSAgIDpsZXQgbCA9IFsxLCAyLCAzXQoJCQkJCSAgIDplY2hvIGV4aXN0cygibFs1XSIpCjwJCQkJCSAgIDAgPgoJCQkJCSAgIDplY2hvIGV4aXN0cygibFt4eF0iKQo8CQkJCQkgICBFMTIxOiBVbmRlZmluZWQgdmFyaWFibGU6IHh4CgkJCQkJICAgMAoJCQk6Y21kbmFtZQlFeCBjb21tYW5kOiBidWlsdC1pbiBjb21tYW5kLCB1c2VyCgkJCQkJY29tbWFuZCBvciBjb21tYW5kIG1vZGlmaWVyIHw6Y29tbWFuZHwuCgkJCQkJUmV0dXJuczoKCQkJCQkxICBmb3IgbWF0Y2ggd2l0aCBzdGFydCBvZiBhIGNvbW1hbmQKCQkJCQkyICBmdWxsIG1hdGNoIHdpdGggYSBjb21tYW5kCgkJCQkJMyAgbWF0Y2hlcyBzZXZlcmFsIHVzZXIgY29tbWFuZHMKCQkJCQlUbyBjaGVjayBmb3IgYSBzdXBwb3J0ZWQgY29tbWFuZAoJCQkJCWFsd2F5cyBjaGVjayB0aGUgcmV0dXJuIHZhbHVlIHRvIGJlIDIuCgkJCToybWF0Y2gJCVRoZSB8OjJtYXRjaHwgY29tbWFuZC4KCQkJOjNtYXRjaAkJVGhlIHw6M21hdGNofCBjb21tYW5kLgoJCQkjZXZlbnQJCWF1dG9jb21tYW5kIGRlZmluZWQgZm9yIHRoaXMgZXZlbnQKCQkJI2V2ZW50I3BhdHRlcm4JYXV0b2NvbW1hbmQgZGVmaW5lZCBmb3IgdGhpcyBldmVudCBhbmQKCQkJCQlwYXR0ZXJuICh0aGUgcGF0dGVybiBpcyB0YWtlbgoJCQkJCWxpdGVyYWxseSBhbmQgY29tcGFyZWQgdG8gdGhlCgkJCQkJYXV0b2NvbW1hbmQgcGF0dGVybnMgY2hhcmFjdGVyIGJ5CgkJCQkJY2hhcmFjdGVyKQoJCQkjZ3JvdXAJCWF1dG9jb21tYW5kIGdyb3VwIGV4aXN0cwoJCQkjZ3JvdXAjZXZlbnQJYXV0b2NvbW1hbmQgZGVmaW5lZCBmb3IgdGhpcyBncm91cCBhbmQKCQkJCQlldmVudC4KCQkJI2dyb3VwI2V2ZW50I3BhdHRlcm4KCQkJCQlhdXRvY29tbWFuZCBkZWZpbmVkIGZvciB0aGlzIGdyb3VwLAoJCQkJCWV2ZW50IGFuZCBwYXR0ZXJuLgoJCQkjI2V2ZW50CQlhdXRvY29tbWFuZCBmb3IgdGhpcyBldmVudCBpcwoJCQkJCXN1cHBvcnRlZC4KCQlGb3IgY2hlY2tpbmcgZm9yIGEgc3VwcG9ydGVkIGZlYXR1cmUgdXNlIHxoYXMoKXwuCgoJCUV4YW1wbGVzOiA+CgkJCWV4aXN0cygiJnNob3J0bmFtZSIpCgkJCWV4aXN0cygiJEhPU1ROQU1FIikKCQkJZXhpc3RzKCIqc3RyZnRpbWUiKQoJCQlleGlzdHMoIipzOk15RnVuYyIpCgkJCWV4aXN0cygiYnVmY291bnQiKQoJCQlleGlzdHMoIjpNYWtlIikKCQkJZXhpc3RzKCIjQ3Vyc29ySG9sZCIpCgkJCWV4aXN0cygiI0J1ZlJlYWRQcmUjKi5neiIpCgkJCWV4aXN0cygiI2ZpbGV0eXBlaW5kZW50IikKCQkJZXhpc3RzKCIjZmlsZXR5cGVpbmRlbnQjRmlsZVR5cGUiKQoJCQlleGlzdHMoIiNmaWxldHlwZWluZGVudCNGaWxlVHlwZSMqIikKCQkJZXhpc3RzKCIjI0NvbG9yU2NoZW1lIikKPAkJVGhlcmUgbXVzdCBiZSBubyBzcGFjZSBiZXR3ZWVuIHRoZSBzeW1ib2wgKCYvJC8qLyMpIGFuZCB0aGUKCQluYW1lLgoJCVRoZXJlIG11c3QgYmUgbm8gZXh0cmEgY2hhcmFjdGVycyBhZnRlciB0aGUgbmFtZSwgYWx0aG91Z2ggaW4KCQlhIGZldyBjYXNlcyB0aGlzIGlzIGlnbm9yZWQuICBUaGF0IG1heSBiZWNvbWUgbW9yZSBzdHJpY3QgaW4KCQl0aGUgZnV0dXJlLCB0aHVzIGRvbid0IGNvdW50IG9uIGl0IQoJCVdvcmtpbmcgZXhhbXBsZTogPgoJCQlleGlzdHMoIjptYWtlIikKPAkJTk9UIHdvcmtpbmcgZXhhbXBsZTogPgoJCQlleGlzdHMoIjptYWtlIGluc3RhbGwiKQoKPAkJTm90ZSB0aGF0IHRoZSBhcmd1bWVudCBtdXN0IGJlIGEgc3RyaW5nLCBub3QgdGhlIG5hbWUgb2YgdGhlCgkJdmFyaWFibGUgaXRzZWxmLiAgRm9yIGV4YW1wbGU6ID4KCQkJZXhpc3RzKGJ1ZmNvdW50KQo8CQlUaGlzIGRvZXNuJ3QgY2hlY2sgZm9yIGV4aXN0ZW5jZSBvZiB0aGUgImJ1ZmNvdW50IiB2YXJpYWJsZSwKCQlidXQgZ2V0cyB0aGUgdmFsdWUgb2YgImJ1ZmNvdW50IiwgYW5kIGNoZWNrcyBpZiB0aGF0IGV4aXN0cy4KCmV4cCh7ZXhwcn0pCQkJCQkJKmV4cCgpKgoJCVJldHVybiB0aGUgZXhwb25lbnRpYWwgb2Yge2V4cHJ9IGFzIGEgfEZsb2F0fCBpbiB0aGUgcmFuZ2UKCQlbMCwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBleHAoMikKPAkJCTcuMzg5MDU2ID4KCQkJOmVjaG8gZXhwKC0xKQo8CQkJMC4zNjc4NzkKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmV4cGFuZCh7ZXhwcn0gWywge2ZsYWd9XSkJCQkJKmV4cGFuZCgpKgoJCUV4cGFuZCB3aWxkY2FyZHMgYW5kIHRoZSBmb2xsb3dpbmcgc3BlY2lhbCBrZXl3b3JkcyBpbiB7ZXhwcn0uCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZy4gICd3aWxkaWdub3JlY2FzZScgYXBwbGllcy4KCgkJV2hlbiB0aGVyZSBhcmUgc2V2ZXJhbCBtYXRjaGVzLCB0aGV5IGFyZSBzZXBhcmF0ZWQgYnkgPE5MPgoJCWNoYXJhY3RlcnMuICBbTm90ZTogaW4gdmVyc2lvbiA1LjAgYSBzcGFjZSB3YXMgdXNlZCwgd2hpY2gKCQljYXVzZWQgcHJvYmxlbXMgd2hlbiBhIGZpbGUgbmFtZSBjb250YWlucyBhIHNwYWNlXQoKCQlJZiB0aGUgZXhwYW5zaW9uIGZhaWxzLCB0aGUgcmVzdWx0IGlzIGFuIGVtcHR5IHN0cmluZy4JQSBuYW1lCgkJZm9yIGEgbm9uLWV4aXN0aW5nIGZpbGUgaXMgbm90IGluY2x1ZGVkLgoKCQlXaGVuIHtleHByfSBzdGFydHMgd2l0aCAnJScsICcjJyBvciAnPCcsIHRoZSBleHBhbnNpb24gaXMgZG9uZQoJCWxpa2UgZm9yIHRoZSB8Y21kbGluZS1zcGVjaWFsfCB2YXJpYWJsZXMgd2l0aCB0aGVpciBhc3NvY2lhdGVkCgkJbW9kaWZpZXJzLiAgSGVyZSBpcyBhIHNob3J0IG92ZXJ2aWV3OgoKCQkJJQkJY3VycmVudCBmaWxlIG5hbWUKCQkJIwkJYWx0ZXJuYXRlIGZpbGUgbmFtZQoJCQkjbgkJYWx0ZXJuYXRlIGZpbGUgbmFtZSBuCgkJCTxjZmlsZT4JCWZpbGUgbmFtZSB1bmRlciB0aGUgY3Vyc29yCgkJCTxhZmlsZT4JCWF1dG9jbWQgZmlsZSBuYW1lCgkJCTxhYnVmPgkJYXV0b2NtZCBidWZmZXIgbnVtYmVyIChhcyBhIFN0cmluZyEpCgkJCTxhbWF0Y2g+CWF1dG9jbWQgbWF0Y2hlZCBuYW1lCgkJCTxzZmlsZT4JCXNvdXJjZWQgc2NyaXB0IGZpbGUgbmFtZQoJCQk8c2xudW0+CQlzb3VyY2VkIHNjcmlwdCBmaWxlIGxpbmUgbnVtYmVyCgkJCTxjd29yZD4JCXdvcmQgdW5kZXIgdGhlIGN1cnNvcgoJCQk8Y1dPUkQ+CQlXT1JEIHVuZGVyIHRoZSBjdXJzb3IKCQkJPGNsaWVudD4JdGhlIHtjbGllbnRpZH0gb2YgdGhlIGxhc3QgcmVjZWl2ZWQKCQkJCQltZXNzYWdlIHxzZXJ2ZXIyY2xpZW50KCl8CgkJTW9kaWZpZXJzOgoJCQk6cAkJZXhwYW5kIHRvIGZ1bGwgcGF0aAoJCQk6aAkJaGVhZCAobGFzdCBwYXRoIGNvbXBvbmVudCByZW1vdmVkKQoJCQk6dAkJdGFpbCAobGFzdCBwYXRoIGNvbXBvbmVudCBvbmx5KQoJCQk6cgkJcm9vdCAob25lIGV4dGVuc2lvbiByZW1vdmVkKQoJCQk6ZQkJZXh0ZW5zaW9uIG9ubHkKCgkJRXhhbXBsZTogPgoJCQk6bGV0ICZ0YWdzID0gZXhwYW5kKCIlOnA6aCIpIC4gIi90YWdzIgo8CQlOb3RlIHRoYXQgd2hlbiBleHBhbmRpbmcgYSBzdHJpbmcgdGhhdCBzdGFydHMgd2l0aCAnJScsICcjJyBvcgoJCSc8JywgYW55IGZvbGxvd2luZyB0ZXh0IGlzIGlnbm9yZWQuICBUaGlzIGRvZXMgTk9UIHdvcms6ID4KCQkJOmxldCBkb2VzbnR3b3JrID0gZXhwYW5kKCIlOmguYmFrIikKPAkJVXNlIHRoaXM6ID4KCQkJOmxldCBkb2Vzd29yayA9IGV4cGFuZCgiJTpoIikgLiAiLmJhayIKPAkJQWxzbyBub3RlIHRoYXQgZXhwYW5kaW5nICI8Y2ZpbGU+IiBhbmQgb3RoZXJzIG9ubHkgcmV0dXJucyB0aGUKCQlyZWZlcmVuY2VkIGZpbGUgbmFtZSB3aXRob3V0IGZ1cnRoZXIgZXhwYW5zaW9uLiAgSWYgIjxjZmlsZT4iCgkJaXMgIn4vLmNzaHJjIiwgeW91IG5lZWQgdG8gZG8gYW5vdGhlciBleHBhbmQoKSB0byBoYXZlIHRoZQoJCSJ+LyIgZXhwYW5kZWQgaW50byB0aGUgcGF0aCBvZiB0aGUgaG9tZSBkaXJlY3Rvcnk6ID4KCQkJOmVjaG8gZXhwYW5kKGV4cGFuZCgiPGNmaWxlPiIpKQo8CgkJVGhlcmUgY2Fubm90IGJlIHdoaXRlIHNwYWNlIGJldHdlZW4gdGhlIHZhcmlhYmxlcyBhbmQgdGhlCgkJZm9sbG93aW5nIG1vZGlmaWVyLiAgVGhlIHxmbmFtZW1vZGlmeSgpfCBmdW5jdGlvbiBjYW4gYmUgdXNlZAoJCXRvIG1vZGlmeSBub3JtYWwgZmlsZSBuYW1lcy4KCgkJV2hlbiB1c2luZyAnJScgb3IgJyMnLCBhbmQgdGhlIGN1cnJlbnQgb3IgYWx0ZXJuYXRlIGZpbGUgbmFtZQoJCWlzIG5vdCBkZWZpbmVkLCBhbiBlbXB0eSBzdHJpbmcgaXMgdXNlZC4gIFVzaW5nICIlOnAiIGluIGEKCQlidWZmZXIgd2l0aCBubyBuYW1lLCByZXN1bHRzIGluIHRoZSBjdXJyZW50IGRpcmVjdG9yeSwgd2l0aCBhCgkJJy8nIGFkZGVkLgoKCQlXaGVuIHtleHByfSBkb2VzIG5vdCBzdGFydCB3aXRoICclJywgJyMnIG9yICc8JywgaXQgaXMKCQlleHBhbmRlZCBsaWtlIGEgZmlsZSBuYW1lIGlzIGV4cGFuZGVkIG9uIHRoZSBjb21tYW5kIGxpbmUuCgkJJ3N1ZmZpeGVzJyBhbmQgJ3dpbGRpZ25vcmUnIGFyZSB1c2VkLCB1bmxlc3MgdGhlIG9wdGlvbmFsCgkJe2ZsYWd9IGFyZ3VtZW50IGlzIGdpdmVuIGFuZCBpdCBpcyBub24temVyby4gIE5hbWVzIGZvcgoJCW5vbi1leGlzdGluZyBmaWxlcyBhcmUgaW5jbHVkZWQuICBUaGUgIioqIiBpdGVtIGNhbiBiZSB1c2VkIHRvCgkJc2VhcmNoIGluIGEgZGlyZWN0b3J5IHRyZWUuICBGb3IgZXhhbXBsZSwgdG8gZmluZCBhbGwgIlJFQURNRSIKCQlmaWxlcyBpbiB0aGUgY3VycmVudCBkaXJlY3RvcnkgYW5kIGJlbG93OiA+CgkJCTplY2hvIGV4cGFuZCgiKiovUkVBRE1FIikKPAoJCUV4cGFuZCgpIGNhbiBhbHNvIGJlIHVzZWQgdG8gZXhwYW5kIHZhcmlhYmxlcyBhbmQgZW52aXJvbm1lbnQKCQl2YXJpYWJsZXMgdGhhdCBhcmUgb25seSBrbm93biBpbiBhIHNoZWxsLiAgQnV0IHRoaXMgY2FuIGJlCgkJc2xvdywgYmVjYXVzZSBhIHNoZWxsIG11c3QgYmUgc3RhcnRlZC4JU2VlIHxleHByLWVudi1leHBhbmR8LgoJCVRoZSBleHBhbmRlZCB2YXJpYWJsZSBpcyBzdGlsbCBoYW5kbGVkIGxpa2UgYSBsaXN0IG9mIGZpbGUKCQluYW1lcy4JV2hlbiBhbiBlbnZpcm9ubWVudCB2YXJpYWJsZSBjYW5ub3QgYmUgZXhwYW5kZWQsIGl0IGlzCgkJbGVmdCB1bmNoYW5nZWQuICBUaHVzICI6ZWNobyBleHBhbmQoJyRGT09CQVInKSIgcmVzdWx0cyBpbgoJCSIkRk9PQkFSIi4KCgkJU2VlIHxnbG9iKCl8IGZvciBmaW5kaW5nIGV4aXN0aW5nIGZpbGVzLiAgU2VlIHxzeXN0ZW0oKXwgZm9yCgkJZ2V0dGluZyB0aGUgcmF3IG91dHB1dCBvZiBhbiBleHRlcm5hbCBjb21tYW5kLgoKZXh0ZW5kKHtleHByMX0sIHtleHByMn0gWywge2V4cHIzfV0pCQkJKmV4dGVuZCgpKgoJCXtleHByMX0gYW5kIHtleHByMn0gbXVzdCBiZSBib3RoIHxMaXN0c3wgb3IgYm90aAoJCXxEaWN0aW9uYXJpZXN8LgoKCQlJZiB0aGV5IGFyZSB8TGlzdHN8OiBBcHBlbmQge2V4cHIyfSB0byB7ZXhwcjF9LgoJCUlmIHtleHByM30gaXMgZ2l2ZW4gaW5zZXJ0IHRoZSBpdGVtcyBvZiB7ZXhwcjJ9IGJlZm9yZSBpdGVtCgkJe2V4cHIzfSBpbiB7ZXhwcjF9LiAgV2hlbiB7ZXhwcjN9IGlzIHplcm8gaW5zZXJ0IGJlZm9yZSB0aGUKCQlmaXJzdCBpdGVtLiAgV2hlbiB7ZXhwcjN9IGlzIGVxdWFsIHRvIGxlbih7ZXhwcjF9KSB0aGVuCgkJe2V4cHIyfSBpcyBhcHBlbmRlZC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBzb3J0KGV4dGVuZChteWxpc3QsIFs3LCA1XSkpCgkJCTpjYWxsIGV4dGVuZChteWxpc3QsIFsyLCAzXSwgMSkKPAkJV2hlbiB7ZXhwcjF9IGlzIHRoZSBzYW1lIExpc3QgYXMge2V4cHIyfSB0aGVuIHRoZSBudW1iZXIgb2YKCQlpdGVtcyBjb3BpZWQgaXMgZXF1YWwgdG8gdGhlIG9yaWdpbmFsIGxlbmd0aCBvZiB0aGUgTGlzdC4KCQlFLmcuLCB3aGVuIHtleHByM30gaXMgMSB5b3UgZ2V0IE4gbmV3IGNvcGllcyBvZiB0aGUgZmlyc3QgaXRlbQoJCSh3aGVyZSBOIGlzIHRoZSBvcmlnaW5hbCBsZW5ndGggb2YgdGhlIExpc3QpLgoJCVVzZSB8YWRkKCl8IHRvIGNvbmNhdGVuYXRlIG9uZSBpdGVtIHRvIGEgbGlzdC4JVG8gY29uY2F0ZW5hdGUKCQl0d28gbGlzdHMgaW50byBhIG5ldyBsaXN0IHVzZSB0aGUgKyBvcGVyYXRvcjogPgoJCQk6bGV0IG5ld2xpc3QgPSBbMSwgMiwgM10gKyBbNCwgNV0KPAoJCUlmIHRoZXkgYXJlIHxEaWN0aW9uYXJpZXN8OgoJCUFkZCBhbGwgZW50cmllcyBmcm9tIHtleHByMn0gdG8ge2V4cHIxfS4KCQlJZiBhIGtleSBleGlzdHMgaW4gYm90aCB7ZXhwcjF9IGFuZCB7ZXhwcjJ9IHRoZW4ge2V4cHIzfSBpcwoJCXVzZWQgdG8gZGVjaWRlIHdoYXQgdG8gZG86CgkJe2V4cHIzfSA9ICJrZWVwIjoga2VlcCB0aGUgdmFsdWUgb2Yge2V4cHIxfQoJCXtleHByM30gPSAiZm9yY2UiOiB1c2UgdGhlIHZhbHVlIG9mIHtleHByMn0KCQl7ZXhwcjN9ID0gImVycm9yIjogZ2l2ZSBhbiBlcnJvciBtZXNzYWdlCQkqRTczNyoKCQlXaGVuIHtleHByM30gaXMgb21pdHRlZCB0aGVuICJmb3JjZSIgaXMgYXNzdW1lZC4KCgkJe2V4cHIxfSBpcyBjaGFuZ2VkIHdoZW4ge2V4cHIyfSBpcyBub3QgZW1wdHkuICBJZiBuZWNlc3NhcnkKCQltYWtlIGEgY29weSBvZiB7ZXhwcjF9IGZpcnN0LgoJCXtleHByMn0gcmVtYWlucyB1bmNoYW5nZWQuCgkJUmV0dXJucyB7ZXhwcjF9LgoKCmZlZWRrZXlzKHtzdHJpbmd9IFssIHttb2RlfV0pCQkJCSpmZWVka2V5cygpKgoJCUNoYXJhY3RlcnMgaW4ge3N0cmluZ30gYXJlIHF1ZXVlZCBmb3IgcHJvY2Vzc2luZyBhcyBpZiB0aGV5CgkJY29tZSBmcm9tIGEgbWFwcGluZyBvciB3ZXJlIHR5cGVkIGJ5IHRoZSB1c2VyLglUaGV5IGFyZSBhZGRlZAoJCXRvIHRoZSBlbmQgb2YgdGhlIHR5cGVhaGVhZCBidWZmZXIsIHRodXMgaWYgYSBtYXBwaW5nIGlzIHN0aWxsCgkJYmVpbmcgZXhlY3V0ZWQgdGhlc2UgY2hhcmFjdGVycyBjb21lIGFmdGVyIHRoZW0uCgkJVGhlIGZ1bmN0aW9uIGRvZXMgbm90IHdhaXQgZm9yIHByb2Nlc3Npbmcgb2Yga2V5cyBjb250YWluZWQgaW4KCQl7c3RyaW5nfS4KCQlUbyBpbmNsdWRlIHNwZWNpYWwga2V5cyBpbnRvIHtzdHJpbmd9LCB1c2UgZG91YmxlLXF1b3RlcwoJCWFuZCAiXC4uLiIgbm90YXRpb24gfGV4cHItcXVvdGV8LiBGb3IgZXhhbXBsZSwKCQlmZWVka2V5cygiXDxDUj4iKSBzaW11bGF0ZXMgcHJlc3Npbmcgb2YgdGhlIDxFbnRlcj4ga2V5LiBCdXQKCQlmZWVka2V5cygnXDxDUj4nKSBwdXNoZXMgNSBjaGFyYWN0ZXJzLgoJCUlmIHttb2RlfSBpcyBhYnNlbnQsIGtleXMgYXJlIHJlbWFwcGVkLgoJCXttb2RlfSBpcyBhIFN0cmluZywgd2hpY2ggY2FuIGNvbnRhaW4gdGhlc2UgY2hhcmFjdGVyIGZsYWdzOgoJCSdtJwlSZW1hcCBrZXlzLiBUaGlzIGlzIGRlZmF1bHQuCgkJJ24nCURvIG5vdCByZW1hcCBrZXlzLgoJCSd0JwlIYW5kbGUga2V5cyBhcyBpZiB0eXBlZDsgb3RoZXJ3aXNlIHRoZXkgYXJlIGhhbmRsZWQgYXMKCQkJaWYgY29taW5nIGZyb20gYSBtYXBwaW5nLiAgVGhpcyBtYXR0ZXJzIGZvciB1bmRvLAoJCQlvcGVuaW5nIGZvbGRzLCBldGMuCgkJUmV0dXJuIHZhbHVlIGlzIGFsd2F5cyAwLgoKZmlsZXJlYWRhYmxlKHtmaWxlfSkJCQkJCSpmaWxlcmVhZGFibGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBUUlVFIHdoZW4gYSBmaWxlIHdpdGggdGhlCgkJbmFtZSB7ZmlsZX0gZXhpc3RzLCBhbmQgY2FuIGJlIHJlYWQuICBJZiB7ZmlsZX0gZG9lc24ndCBleGlzdCwKCQlvciBpcyBhIGRpcmVjdG9yeSwgdGhlIHJlc3VsdCBpcyBGQUxTRS4gIHtmaWxlfSBpcyBhbnkKCQlleHByZXNzaW9uLCB3aGljaCBpcyB1c2VkIGFzIGEgU3RyaW5nLgoJCUlmIHlvdSBkb24ndCBjYXJlIGFib3V0IHRoZSBmaWxlIGJlaW5nIHJlYWRhYmxlIHlvdSBjYW4gdXNlCgkJfGdsb2IoKXwuCgkJCQkJCQkqZmlsZV9yZWFkYWJsZSgpKgoJCU9ic29sZXRlIG5hbWU6IGZpbGVfcmVhZGFibGUoKS4KCgpmaWxld3JpdGFibGUoe2ZpbGV9KQkJCQkJKmZpbGV3cml0YWJsZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIDEgd2hlbiBhIGZpbGUgd2l0aCB0aGUKCQluYW1lIHtmaWxlfSBleGlzdHMsIGFuZCBjYW4gYmUgd3JpdHRlbi4gIElmIHtmaWxlfSBkb2Vzbid0CgkJZXhpc3QsIG9yIGlzIG5vdCB3cml0YWJsZSwgdGhlIHJlc3VsdCBpcyAwLiAgSWYge2ZpbGV9IGlzIGEKCQlkaXJlY3RvcnksIGFuZCB3ZSBjYW4gd3JpdGUgdG8gaXQsIHRoZSByZXN1bHQgaXMgMi4KCgpmaWx0ZXIoe2V4cHJ9LCB7c3RyaW5nfSkJCQkJCSpmaWx0ZXIoKSoKCQl7ZXhwcn0gbXVzdCBiZSBhIHxMaXN0fCBvciBhIHxEaWN0aW9uYXJ5fC4KCQlGb3IgZWFjaCBpdGVtIGluIHtleHByfSBldmFsdWF0ZSB7c3RyaW5nfSBhbmQgd2hlbiB0aGUgcmVzdWx0CgkJaXMgemVybyByZW1vdmUgdGhlIGl0ZW0gZnJvbSB0aGUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fC4KCQlJbnNpZGUge3N0cmluZ30gfHY6dmFsfCBoYXMgdGhlIHZhbHVlIG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRm9yIGEgfERpY3Rpb25hcnl8IHx2OmtleXwgaGFzIHRoZSBrZXkgb2YgdGhlIGN1cnJlbnQgaXRlbS4KCQlFeGFtcGxlczogPgoJCQk6Y2FsbCBmaWx0ZXIobXlsaXN0LCAndjp2YWwgIX4gIk9MRCInKQo8CQlSZW1vdmVzIHRoZSBpdGVtcyB3aGVyZSAiT0xEIiBhcHBlYXJzLiA+CgkJCTpjYWxsIGZpbHRlcihteWRpY3QsICd2OmtleSA+PSA4JykKPAkJUmVtb3ZlcyB0aGUgaXRlbXMgd2l0aCBhIGtleSBiZWxvdyA4LiA+CgkJCTpjYWxsIGZpbHRlcih2YXIsIDApCjwJCVJlbW92ZXMgYWxsIHRoZSBpdGVtcywgdGh1cyBjbGVhcnMgdGhlIHxMaXN0fCBvciB8RGljdGlvbmFyeXwuCgoJCU5vdGUgdGhhdCB7c3RyaW5nfSBpcyB0aGUgcmVzdWx0IG9mIGV4cHJlc3Npb24gYW5kIGlzIHRoZW4KCQl1c2VkIGFzIGFuIGV4cHJlc3Npb24gYWdhaW4uICBPZnRlbiBpdCBpcyBnb29kIHRvIHVzZSBhCgkJfGxpdGVyYWwtc3RyaW5nfCB0byBhdm9pZCBoYXZpbmcgdG8gZG91YmxlIGJhY2tzbGFzaGVzLgoKCQlUaGUgb3BlcmF0aW9uIGlzIGRvbmUgaW4tcGxhY2UuICBJZiB5b3Ugd2FudCBhIHxMaXN0fCBvcgoJCXxEaWN0aW9uYXJ5fCB0byByZW1haW4gdW5tb2RpZmllZCBtYWtlIGEgY29weSBmaXJzdDogPgoJCQk6bGV0IGwgPSBmaWx0ZXIoY29weShteWxpc3QpLCAndjp2YWwgPX4gIktFRVAiJykKCjwJCVJldHVybnMge2V4cHJ9LCB0aGUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCB0aGF0IHdhcyBmaWx0ZXJlZC4KCQlXaGVuIGFuIGVycm9yIGlzIGVuY291bnRlcmVkIHdoaWxlIGV2YWx1YXRpbmcge3N0cmluZ30gbm8KCQlmdXJ0aGVyIGl0ZW1zIGluIHtleHByfSBhcmUgcHJvY2Vzc2VkLgoKCmZpbmRkaXIoe25hbWV9Wywge3BhdGh9Wywge2NvdW50fV1dKQkJCQkqZmluZGRpcigpKgoJCUZpbmQgZGlyZWN0b3J5IHtuYW1lfSBpbiB7cGF0aH0uICBTdXBwb3J0cyBib3RoIGRvd253YXJkcyBhbmQKCQl1cHdhcmRzIHJlY3Vyc2l2ZSBkaXJlY3Rvcnkgc2VhcmNoZXMuICBTZWUgfGZpbGUtc2VhcmNoaW5nfAoJCWZvciB0aGUgc3ludGF4IG9mIHtwYXRofS4KCQlSZXR1cm5zIHRoZSBwYXRoIG9mIHRoZSBmaXJzdCBmb3VuZCBtYXRjaC4gIFdoZW4gdGhlIGZvdW5kCgkJZGlyZWN0b3J5IGlzIGJlbG93IHRoZSBjdXJyZW50IGRpcmVjdG9yeSBhIHJlbGF0aXZlIHBhdGggaXMKCQlyZXR1cm5lZC4gIE90aGVyd2lzZSBhIGZ1bGwgcGF0aCBpcyByZXR1cm5lZC4KCQlJZiB7cGF0aH0gaXMgb21pdHRlZCBvciBlbXB0eSB0aGVuICdwYXRoJyBpcyB1c2VkLgoJCUlmIHRoZSBvcHRpb25hbCB7Y291bnR9IGlzIGdpdmVuLCBmaW5kIHtjb3VudH0ncyBvY2N1cnJlbmNlIG9mCgkJe25hbWV9IGluIHtwYXRofSBpbnN0ZWFkIG9mIHRoZSBmaXJzdCBvbmUuCgkJV2hlbiB7Y291bnR9IGlzIG5lZ2F0aXZlIHJldHVybiBhbGwgdGhlIG1hdGNoZXMgaW4gYSB8TGlzdHwuCgkJVGhpcyBpcyBxdWl0ZSBzaW1pbGFyIHRvIHRoZSBleC1jb21tYW5kIHw6ZmluZHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmaWxlX2luX3BhdGh8CgkJZmVhdHVyZX0KCmZpbmRmaWxlKHtuYW1lfVssIHtwYXRofVssIHtjb3VudH1dXSkJCQkJKmZpbmRmaWxlKCkqCgkJSnVzdCBsaWtlIHxmaW5kZGlyKCl8LCBidXQgZmluZCBhIGZpbGUgaW5zdGVhZCBvZiBhIGRpcmVjdG9yeS4KCQlVc2VzICdzdWZmaXhlc2FkZCcuCgkJRXhhbXBsZTogPgoJCQk6ZWNobyBmaW5kZmlsZSgidGFncy52aW0iLCAiLjsiKQo8CQlTZWFyY2hlcyBmcm9tIHRoZSBkaXJlY3Rvcnkgb2YgdGhlIGN1cnJlbnQgZmlsZSB1cHdhcmRzIHVudGlsCgkJaXQgZmluZHMgdGhlIGZpbGUgInRhZ3MudmltIi4KCmZsb2F0Mm5yKHtleHByfSkJCQkJCSpmbG9hdDJucigpKgoJCUNvbnZlcnQge2V4cHJ9IHRvIGEgTnVtYmVyIGJ5IG9taXR0aW5nIHRoZSBwYXJ0IGFmdGVyIHRoZQoJCWRlY2ltYWwgcG9pbnQuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgTnVtYmVyLgoJCVdoZW4gdGhlIHZhbHVlIG9mIHtleHByfSBpcyBvdXQgb2YgcmFuZ2UgZm9yIGEgfE51bWJlcnwgdGhlCgkJcmVzdWx0IGlzIHRydW5jYXRlZCB0byAweDdmZmZmZmZmIG9yIC0weDdmZmZmZmZmLiAgTmFOIHJlc3VsdHMKCQlpbiAtMHg4MDAwMDAwMC4KCQlFeGFtcGxlczogPgoJCQllY2hvIGZsb2F0Mm5yKDMuOTUpCjwJCQkzICA+CgkJCWVjaG8gZmxvYXQybnIoLTIzLjQ1KQo8CQkJLTIzICA+CgkJCWVjaG8gZmxvYXQybnIoMS4wZTEwMCkKPAkJCTIxNDc0ODM2NDcgID4KCQkJZWNobyBmbG9hdDJucigtMS4wZTE1MCkKPAkJCS0yMTQ3NDgzNjQ3ICA+CgkJCWVjaG8gZmxvYXQybnIoMS4wZS0xMDApCjwJCQkwCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpmbG9vcih7ZXhwcn0pCQkJCQkJCSpmbG9vcigpKgoJCVJldHVybiB0aGUgbGFyZ2VzdCBpbnRlZ3JhbCB2YWx1ZSBsZXNzIHRoYW4gb3IgZXF1YWwgdG8KCQl7ZXhwcn0gYXMgYSB8RmxvYXR8IChyb3VuZCBkb3duKS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQllY2hvIGZsb29yKDEuODU2KQo8CQkJMS4wICA+CgkJCWVjaG8gZmxvb3IoLTUuNDU2KQo8CQkJLTYuMCAgPgoJCQllY2hvIGZsb29yKDQuMCkKPAkJCTQuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJCgpmbW9kKHtleHByMX0sIHtleHByMn0pCQkJCQkqZm1vZCgpKgoJCVJldHVybiB0aGUgcmVtYWluZGVyIG9mIHtleHByMX0gLyB7ZXhwcjJ9LCBldmVuIGlmIHRoZQoJCWRpdmlzaW9uIGlzIG5vdCByZXByZXNlbnRhYmxlLiAgUmV0dXJucyB7ZXhwcjF9IC0gaSAqIHtleHByMn0KCQlmb3Igc29tZSBpbnRlZ2VyIGkgc3VjaCB0aGF0IGlmIHtleHByMn0gaXMgbm9uLXplcm8sIHRoZQoJCXJlc3VsdCBoYXMgdGhlIHNhbWUgc2lnbiBhcyB7ZXhwcjF9IGFuZCBtYWduaXR1ZGUgbGVzcyB0aGFuCgkJdGhlIG1hZ25pdHVkZSBvZiB7ZXhwcjJ9LiAgSWYge2V4cHIyfSBpcyB6ZXJvLCB0aGUgdmFsdWUKCQlyZXR1cm5lZCBpcyB6ZXJvLiAgVGhlIHZhbHVlIHJldHVybmVkIGlzIGEgfEZsb2F0fC4KCQl7ZXhwcjF9IGFuZCB7ZXhwcjJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gZm1vZCgxMi4zMywgMS4yMikKPAkJCTAuMTMgPgoJCQk6ZWNobyBmbW9kKC0xMi4zMywgMS4yMikKPAkJCS0wLjEzCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB8K2Zsb2F0fCBmZWF0dXJlfQoKCmZuYW1lZXNjYXBlKHtzdHJpbmd9KQkJCQkJKmZuYW1lZXNjYXBlKCkqCgkJRXNjYXBlIHtzdHJpbmd9IGZvciB1c2UgYXMgZmlsZSBuYW1lIGNvbW1hbmQgYXJndW1lbnQuCUFsbAoJCWNoYXJhY3RlcnMgdGhhdCBoYXZlIGEgc3BlY2lhbCBtZWFuaW5nLCBzdWNoIGFzICclJyBhbmQgJ3wnCgkJYXJlIGVzY2FwZWQgd2l0aCBhIGJhY2tzbGFzaC4KCQlGb3IgbW9zdCBzeXN0ZW1zIHRoZSBjaGFyYWN0ZXJzIGVzY2FwZWQgYXJlCgkJIiBcdFxuKj9be2AkXFwlIydcInwhPCIuICBGb3Igc3lzdGVtcyB3aGVyZSBhIGJhY2tzbGFzaAoJCWFwcGVhcnMgaW4gYSBmaWxlbmFtZSwgaXQgZGVwZW5kcyBvbiB0aGUgdmFsdWUgb2YgJ2lzZm5hbWUnLgoJCUEgbGVhZGluZyAnKycgYW5kICc+JyBpcyBhbHNvIGVzY2FwZWQgKHNwZWNpYWwgYWZ0ZXIgfDplZGl0fAoJCWFuZCB8OndyaXRlfCkuICBBbmQgYSAiLSIgYnkgaXRzZWxmIChzcGVjaWFsIGFmdGVyIHw6Y2R8KS4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgZm5hbWUgPSAnK3NvbWUgc3RyJW5nZXxuYW1lJwoJCQk6ZXhlICJlZGl0ICIgLiBmbmFtZWVzY2FwZShmbmFtZSkKPAkJcmVzdWx0cyBpbiBleGVjdXRpbmc6ID4KCQkJZWRpdCBcK3NvbWVcIHN0clwlbmdlXHxuYW1lCgpmbmFtZW1vZGlmeSh7Zm5hbWV9LCB7bW9kc30pCQkJCSpmbmFtZW1vZGlmeSgpKgoJCU1vZGlmeSBmaWxlIG5hbWUge2ZuYW1lfSBhY2NvcmRpbmcgdG8ge21vZHN9LiAge21vZHN9IGlzIGEKCQlzdHJpbmcgb2YgY2hhcmFjdGVycyBsaWtlIGl0IGlzIHVzZWQgZm9yIGZpbGUgbmFtZXMgb24gdGhlCgkJY29tbWFuZCBsaW5lLiAgU2VlIHxmaWxlbmFtZS1tb2RpZmllcnN8LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gZm5hbWVtb2RpZnkoIm1haW4uYyIsICI6cDpoIikKPAkJcmVzdWx0cyBpbjogPgoJCQkvaG9tZS9tb29sL3ZpbS92aW0vc3JjCjwJCU5vdGU6IEVudmlyb25tZW50IHZhcmlhYmxlcyBkb24ndCB3b3JrIGluIHtmbmFtZX0sIHVzZQoJCXxleHBhbmQoKXwgZmlyc3QgdGhlbi4KCmZvbGRjbG9zZWQoe2xudW19KQkJCQkJKmZvbGRjbG9zZWQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLiAgSWYgdGhlIGxpbmUge2xudW19IGlzIGluIGEgY2xvc2VkCgkJZm9sZCwgdGhlIHJlc3VsdCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBmaXJzdCBsaW5lIGluIHRoYXQgZm9sZC4KCQlJZiB0aGUgbGluZSB7bG51bX0gaXMgbm90IGluIGEgY2xvc2VkIGZvbGQsIC0xIGlzIHJldHVybmVkLgoKZm9sZGNsb3NlZGVuZCh7bG51bX0pCQkJCQkqZm9sZGNsb3NlZGVuZCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIuICBJZiB0aGUgbGluZSB7bG51bX0gaXMgaW4gYSBjbG9zZWQKCQlmb2xkLCB0aGUgcmVzdWx0IGlzIHRoZSBudW1iZXIgb2YgdGhlIGxhc3QgbGluZSBpbiB0aGF0IGZvbGQuCgkJSWYgdGhlIGxpbmUge2xudW19IGlzIG5vdCBpbiBhIGNsb3NlZCBmb2xkLCAtMSBpcyByZXR1cm5lZC4KCmZvbGRsZXZlbCh7bG51bX0pCQkJCQkqZm9sZGxldmVsKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGZvbGRsZXZlbCBvZiBsaW5lIHtsbnVtfQoJCWluIHRoZSBjdXJyZW50IGJ1ZmZlci4JRm9yIG5lc3RlZCBmb2xkcyB0aGUgZGVlcGVzdCBsZXZlbCBpcwoJCXJldHVybmVkLiAgSWYgdGhlcmUgaXMgbm8gZm9sZCBhdCBsaW5lIHtsbnVtfSwgemVybyBpcwoJCXJldHVybmVkLiAgSXQgZG9lc24ndCBtYXR0ZXIgaWYgdGhlIGZvbGRzIGFyZSBvcGVuIG9yIGNsb3NlZC4KCQlXaGVuIHVzZWQgd2hpbGUgdXBkYXRpbmcgZm9sZHMgKGZyb20gJ2ZvbGRleHByJykgLTEgaXMKCQlyZXR1cm5lZCBmb3IgbGluZXMgd2hlcmUgZm9sZHMgYXJlIHN0aWxsIHRvIGJlIHVwZGF0ZWQgYW5kIHRoZQoJCWZvbGRsZXZlbCBpcyB1bmtub3duLiAgQXMgYSBzcGVjaWFsIGNhc2UgdGhlIGxldmVsIG9mIHRoZQoJCXByZXZpb3VzIGxpbmUgaXMgdXN1YWxseSBhdmFpbGFibGUuCgoJCQkJCQkJKmZvbGR0ZXh0KCkqCmZvbGR0ZXh0KCkJUmV0dXJucyBhIFN0cmluZywgdG8gYmUgZGlzcGxheWVkIGZvciBhIGNsb3NlZCBmb2xkLiAgVGhpcyBpcwoJCXRoZSBkZWZhdWx0IGZ1bmN0aW9uIHVzZWQgZm9yIHRoZSAnZm9sZHRleHQnIG9wdGlvbiBhbmQgc2hvdWxkCgkJb25seSBiZSBjYWxsZWQgZnJvbSBldmFsdWF0aW5nICdmb2xkdGV4dCcuICBJdCB1c2VzIHRoZQoJCXx2OmZvbGRzdGFydHwsIHx2OmZvbGRlbmR8IGFuZCB8djpmb2xkZGFzaGVzfCB2YXJpYWJsZXMuCgkJVGhlIHJldHVybmVkIHN0cmluZyBsb29rcyBsaWtlIHRoaXM6ID4KCQkJKy0tIDQ1IGxpbmVzOiBhYmNkZWYKPAkJVGhlIG51bWJlciBvZiBkYXNoZXMgZGVwZW5kcyBvbiB0aGUgZm9sZGxldmVsLglUaGUgIjQ1IiBpcwoJCXRoZSBudW1iZXIgb2YgbGluZXMgaW4gdGhlIGZvbGQuICAiYWJjZGVmIiBpcyB0aGUgdGV4dCBpbiB0aGUKCQlmaXJzdCBub24tYmxhbmsgbGluZSBvZiB0aGUgZm9sZC4gIExlYWRpbmcgd2hpdGUgc3BhY2UsICIvLyIKCQlvciAiLyoiIGFuZCB0aGUgdGV4dCBmcm9tIHRoZSAnZm9sZG1hcmtlcicgYW5kICdjb21tZW50c3RyaW5nJwoJCW9wdGlvbnMgaXMgcmVtb3ZlZC4KCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wgZmVhdHVyZX0KCmZvbGR0ZXh0cmVzdWx0KHtsbnVtfSkJCQkJCSpmb2xkdGV4dHJlc3VsdCgpKgoJCVJldHVybnMgdGhlIHRleHQgdGhhdCBpcyBkaXNwbGF5ZWQgZm9yIHRoZSBjbG9zZWQgZm9sZCBhdCBsaW5lCgkJe2xudW19LiAgRXZhbHVhdGVzICdmb2xkdGV4dCcgaW4gdGhlIGFwcHJvcHJpYXRlIGNvbnRleHQuCgkJV2hlbiB0aGVyZSBpcyBubyBjbG9zZWQgZm9sZCBhdCB7bG51bX0gYW4gZW1wdHkgc3RyaW5nIGlzCgkJcmV0dXJuZWQuCgkJe2xudW19IGlzIHVzZWQgbGlrZSB3aXRoIHxnZXRsaW5lKCl8LiAgVGh1cyAiLiIgaXMgdGhlIGN1cnJlbnQKCQlsaW5lLCAiJ20iIG1hcmsgbSwgZXRjLgoJCVVzZWZ1bCB3aGVuIGV4cG9ydGluZyBmb2xkZWQgdGV4dCwgZS5nLiwgdG8gSFRNTC4KCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wgZmVhdHVyZX0KCgkJCQkJCQkqZm9yZWdyb3VuZCgpKgpmb3JlZ3JvdW5kKCkJTW92ZSB0aGUgVmltIHdpbmRvdyB0byB0aGUgZm9yZWdyb3VuZC4JVXNlZnVsIHdoZW4gc2VudCBmcm9tCgkJYSBjbGllbnQgdG8gYSBWaW0gc2VydmVyLiB8cmVtb3RlX3NlbmQoKXwKCQlPbiBXaW4zMiBzeXN0ZW1zIHRoaXMgbWlnaHQgbm90IHdvcmssIHRoZSBPUyBkb2VzIG5vdCBhbHdheXMKCQlhbGxvdyBhIHdpbmRvdyB0byBicmluZyBpdHNlbGYgdG8gdGhlIGZvcmVncm91bmQuICBVc2UKCQl8cmVtb3RlX2ZvcmVncm91bmQoKXwgaW5zdGVhZC4KCQl7b25seSBpbiB0aGUgV2luMzIsIEF0aGVuYSwgTW90aWYgYW5kIEdUSyBHVUkgdmVyc2lvbnMgYW5kIHRoZQoJCVdpbjMyIGNvbnNvbGUgdmVyc2lvbn0KCgpmdW5jdGlvbih7bmFtZX0pCQkJCQkqZnVuY3Rpb24oKSogKkU3MDAqCgkJUmV0dXJuIGEgfEZ1bmNyZWZ8IHZhcmlhYmxlIHRoYXQgcmVmZXJzIHRvIGZ1bmN0aW9uIHtuYW1lfS4KCQl7bmFtZX0gY2FuIGJlIGEgdXNlciBkZWZpbmVkIGZ1bmN0aW9uIG9yIGFuIGludGVybmFsIGZ1bmN0aW9uLgoKCmdhcmJhZ2Vjb2xsZWN0KFt7YXRleGl0fV0pCQkJCSpnYXJiYWdlY29sbGVjdCgpKgoJCUNsZWFudXAgdW51c2VkIHxMaXN0c3wgYW5kIHxEaWN0aW9uYXJpZXN8IHRoYXQgaGF2ZSBjaXJjdWxhcgoJCXJlZmVyZW5jZXMuICBUaGVyZSBpcyBoYXJkbHkgZXZlciBhIG5lZWQgdG8gaW52b2tlIHRoaXMKCQlmdW5jdGlvbiwgYXMgaXQgaXMgYXV0b21hdGljYWxseSBkb25lIHdoZW4gVmltIHJ1bnMgb3V0IG9mCgkJbWVtb3J5IG9yIGlzIHdhaXRpbmcgZm9yIHRoZSB1c2VyIHRvIHByZXNzIGEga2V5IGFmdGVyCgkJJ3VwZGF0ZXRpbWUnLiAgSXRlbXMgd2l0aG91dCBjaXJjdWxhciByZWZlcmVuY2VzIGFyZSBhbHdheXMKCQlmcmVlZCB3aGVuIHRoZXkgYmVjb21lIHVudXNlZC4KCQlUaGlzIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBkZWxldGVkIGEgdmVyeSBiaWcgfExpc3R8IGFuZC9vcgoJCXxEaWN0aW9uYXJ5fCB3aXRoIGNpcmN1bGFyIHJlZmVyZW5jZXMgaW4gYSBzY3JpcHQgdGhhdCBydW5zCgkJZm9yIGEgbG9uZyB0aW1lLgoJCVdoZW4gdGhlIG9wdGlvbmFsIHthdGV4aXR9IGFyZ3VtZW50IGlzIG9uZSwgZ2FyYmFnZQoJCWNvbGxlY3Rpb24gd2lsbCBhbHNvIGJlIGRvbmUgd2hlbiBleGl0aW5nIFZpbSwgaWYgaXQgd2Fzbid0CgkJZG9uZSBiZWZvcmUuICBUaGlzIGlzIHVzZWZ1bCB3aGVuIGNoZWNraW5nIGZvciBtZW1vcnkgbGVha3MuCgpnZXQoe2xpc3R9LCB7aWR4fSBbLCB7ZGVmYXVsdH1dKQkJCSpnZXQoKSoKCQlHZXQgaXRlbSB7aWR4fSBmcm9tIHxMaXN0fCB7bGlzdH0uICBXaGVuIHRoaXMgaXRlbSBpcyBub3QKCQlhdmFpbGFibGUgcmV0dXJuIHtkZWZhdWx0fS4gIFJldHVybiB6ZXJvIHdoZW4ge2RlZmF1bHR9IGlzCgkJb21pdHRlZC4KZ2V0KHtkaWN0fSwge2tleX0gWywge2RlZmF1bHR9XSkKCQlHZXQgaXRlbSB3aXRoIGtleSB7a2V5fSBmcm9tIHxEaWN0aW9uYXJ5fCB7ZGljdH0uICBXaGVuIHRoaXMKCQlpdGVtIGlzIG5vdCBhdmFpbGFibGUgcmV0dXJuIHtkZWZhdWx0fS4gIFJldHVybiB6ZXJvIHdoZW4KCQl7ZGVmYXVsdH0gaXMgb21pdHRlZC4KCgkJCQkJCQkqZ2V0YnVmbGluZSgpKgpnZXRidWZsaW5lKHtleHByfSwge2xudW19IFssIHtlbmR9XSkKCQlSZXR1cm4gYSB8TGlzdHwgd2l0aCB0aGUgbGluZXMgc3RhcnRpbmcgZnJvbSB7bG51bX0gdG8ge2VuZH0KCQkoaW5jbHVzaXZlKSBpbiB0aGUgYnVmZmVyIHtleHByfS4gIElmIHtlbmR9IGlzIG9taXR0ZWQsIGEKCQl8TGlzdHwgd2l0aCBvbmx5IHRoZSBsaW5lIHtsbnVtfSBpcyByZXR1cm5lZC4KCgkJRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9LCBzZWUgfGJ1Zm5hbWUoKXwgYWJvdmUuCgoJCUZvciB7bG51bX0gYW5kIHtlbmR9ICIkIiBjYW4gYmUgdXNlZCBmb3IgdGhlIGxhc3QgbGluZSBvZiB0aGUKCQlidWZmZXIuICBPdGhlcndpc2UgYSBudW1iZXIgbXVzdCBiZSB1c2VkLgoKCQlXaGVuIHtsbnVtfSBpcyBzbWFsbGVyIHRoYW4gMSBvciBiaWdnZXIgdGhhbiB0aGUgbnVtYmVyIG9mCgkJbGluZXMgaW4gdGhlIGJ1ZmZlciwgYW4gZW1wdHkgfExpc3R8IGlzIHJldHVybmVkLgoKCQlXaGVuIHtlbmR9IGlzIGdyZWF0ZXIgdGhhbiB0aGUgbnVtYmVyIG9mIGxpbmVzIGluIHRoZSBidWZmZXIsCgkJaXQgaXMgdHJlYXRlZCBhcyB7ZW5kfSBpcyBzZXQgdG8gdGhlIG51bWJlciBvZiBsaW5lcyBpbiB0aGUKCQlidWZmZXIuICBXaGVuIHtlbmR9IGlzIGJlZm9yZSB7bG51bX0gYW4gZW1wdHkgfExpc3R8IGlzCgkJcmV0dXJuZWQuCgoJCVRoaXMgZnVuY3Rpb24gd29ya3Mgb25seSBmb3IgbG9hZGVkIGJ1ZmZlcnMuICBGb3IgdW5sb2FkZWQgYW5kCgkJbm9uLWV4aXN0aW5nIGJ1ZmZlcnMsIGFuIGVtcHR5IHxMaXN0fCBpcyByZXR1cm5lZC4KCgkJRXhhbXBsZTogPgoJCQk6bGV0IGxpbmVzID0gZ2V0YnVmbGluZShidWZucigibXlmaWxlIiksIDEsICIkIikKCmdldGJ1ZnZhcih7ZXhwcn0sIHt2YXJuYW1lfSkJCQkJKmdldGJ1ZnZhcigpKgoJCVRoZSByZXN1bHQgaXMgdGhlIHZhbHVlIG9mIG9wdGlvbiBvciBsb2NhbCBidWZmZXIgdmFyaWFibGUKCQl7dmFybmFtZX0gaW4gYnVmZmVyIHtleHByfS4gIE5vdGUgdGhhdCB0aGUgbmFtZSB3aXRob3V0ICJiOiIKCQltdXN0IGJlIHVzZWQuCgkJV2hlbiB7dmFybmFtZX0gaXMgZW1wdHkgcmV0dXJucyBhIGRpY3Rpb25hcnkgd2l0aCBhbGwgdGhlCgkJYnVmZmVyLWxvY2FsIHZhcmlhYmxlcy4KCQlUaGlzIGFsc28gd29ya3MgZm9yIGEgZ2xvYmFsIG9yIGJ1ZmZlci1sb2NhbCBvcHRpb24sIGJ1dCBpdAoJCWRvZXNuJ3Qgd29yayBmb3IgYSBnbG9iYWwgdmFyaWFibGUsIHdpbmRvdy1sb2NhbCB2YXJpYWJsZSBvcgoJCXdpbmRvdy1sb2NhbCBvcHRpb24uCgkJRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9LCBzZWUgfGJ1Zm5hbWUoKXwgYWJvdmUuCgkJV2hlbiB0aGUgYnVmZmVyIG9yIHZhcmlhYmxlIGRvZXNuJ3QgZXhpc3QgYW4gZW1wdHkgc3RyaW5nIGlzCgkJcmV0dXJuZWQsIHRoZXJlIGlzIG5vIGVycm9yIG1lc3NhZ2UuCgkJRXhhbXBsZXM6ID4KCQkJOmxldCBidWZtb2RpZmllZCA9IGdldGJ1ZnZhcigxLCAiJm1vZCIpCgkJCTplY2hvICJ0b2RvIG15dmFyID0gIiAuIGdldGJ1ZnZhcigidG9kbyIsICJteXZhciIpCjwKZ2V0Y2hhcihbZXhwcl0pCQkJCQkJKmdldGNoYXIoKSoKCQlHZXQgYSBzaW5nbGUgY2hhcmFjdGVyIGZyb20gdGhlIHVzZXIgb3IgaW5wdXQgc3RyZWFtLgoJCUlmIFtleHByXSBpcyBvbWl0dGVkLCB3YWl0IHVudGlsIGEgY2hhcmFjdGVyIGlzIGF2YWlsYWJsZS4KCQlJZiBbZXhwcl0gaXMgMCwgb25seSBnZXQgYSBjaGFyYWN0ZXIgd2hlbiBvbmUgaXMgYXZhaWxhYmxlLgoJCQlSZXR1cm4gemVybyBvdGhlcndpc2UuCgkJSWYgW2V4cHJdIGlzIDEsIG9ubHkgY2hlY2sgaWYgYSBjaGFyYWN0ZXIgaXMgYXZhaWxhYmxlLCBpdCBpcwoJCQlub3QgY29uc3VtZWQuICBSZXR1cm4gemVybyBpZiBubyBjaGFyYWN0ZXIgYXZhaWxhYmxlLgoKCQlXaXRob3V0IHtleHByfSBhbmQgd2hlbiB7ZXhwcn0gaXMgMCBhIHdob2xlIGNoYXJhY3RlciBvcgoJCXNwZWNpYWwga2V5IGlzIHJldHVybmVkLiAgSWYgaXQgaXMgYW4gOC1iaXQgY2hhcmFjdGVyLCB0aGUKCQlyZXN1bHQgaXMgYSBudW1iZXIuICBVc2UgbnIyY2hhcigpIHRvIGNvbnZlcnQgaXQgdG8gYSBTdHJpbmcuCgkJT3RoZXJ3aXNlIGEgU3RyaW5nIGlzIHJldHVybmVkIHdpdGggdGhlIGVuY29kZWQgY2hhcmFjdGVyLgoJCUZvciBhIHNwZWNpYWwga2V5IGl0J3MgYSBzZXF1ZW5jZSBvZiBieXRlcyBzdGFydGluZyB3aXRoIDB4ODAKCQkoZGVjaW1hbDogMTI4KS4gIFRoaXMgaXMgdGhlIHNhbWUgdmFsdWUgYXMgdGhlIHN0cmluZwoJCSJcPEtleT4iLCBlLmcuLCAiXDxMZWZ0PiIuICBUaGUgcmV0dXJuZWQgdmFsdWUgaXMgYWxzbyBhCgkJU3RyaW5nIHdoZW4gYSBtb2RpZmllciAoc2hpZnQsIGNvbnRyb2wsIGFsdCkgd2FzIHVzZWQgdGhhdCBpcwoJCW5vdCBpbmNsdWRlZCBpbiB0aGUgY2hhcmFjdGVyLgoKCQlXaGVuIHtleHByfSBpcyAxIG9ubHkgdGhlIGZpcnN0IGJ5dGUgaXMgcmV0dXJuZWQuICBGb3IgYQoJCW9uZS1ieXRlIGNoYXJhY3RlciBpdCBpcyB0aGUgY2hhcmFjdGVyIGl0c2VsZiBhcyBhIG51bWJlci4KCQlVc2UgbnIyY2hhcigpIHRvIGNvbnZlcnQgaXQgdG8gYSBTdHJpbmcuCgoJCVVzZSBnZXRjaGFybW9kKCkgdG8gb2J0YWluIGFueSBhZGRpdGlvbmFsIG1vZGlmaWVycy4KCgkJV2hlbiB0aGUgdXNlciBjbGlja3MgYSBtb3VzZSBidXR0b24sIHRoZSBtb3VzZSBldmVudCB3aWxsIGJlCgkJcmV0dXJuZWQuICBUaGUgcG9zaXRpb24gY2FuIHRoZW4gYmUgZm91bmQgaW4gfHY6bW91c2VfY29sfCwKCQl8djptb3VzZV9sbnVtfCBhbmQgfHY6bW91c2Vfd2lufC4gIFRoaXMgZXhhbXBsZSBwb3NpdGlvbnMgdGhlCgkJbW91c2UgYXMgaXQgd291bGQgbm9ybWFsbHkgaGFwcGVuOiA+CgkJCWxldCBjID0gZ2V0Y2hhcigpCgkJCWlmIGMgPT0gIlw8TGVmdE1vdXNlPiIgJiYgdjptb3VzZV93aW4gPiAwCgkJCSAgZXhlIHY6bW91c2Vfd2luIC4gIndpbmNtZCB3IgoJCQkgIGV4ZSB2Om1vdXNlX2xudW0KCQkJICBleGUgIm5vcm1hbCAiIC4gdjptb3VzZV9jb2wgLiAifCIKCQkJZW5kaWYKPAoJCVRoZXJlIGlzIG5vIHByb21wdCwgeW91IHdpbGwgc29tZWhvdyBoYXZlIHRvIG1ha2UgY2xlYXIgdG8gdGhlCgkJdXNlciB0aGF0IGEgY2hhcmFjdGVyIGhhcyB0byBiZSB0eXBlZC4KCQlUaGVyZSBpcyBubyBtYXBwaW5nIGZvciB0aGUgY2hhcmFjdGVyLgoJCUtleSBjb2RlcyBhcmUgcmVwbGFjZWQsIHRodXMgd2hlbiB0aGUgdXNlciBwcmVzc2VzIHRoZSA8RGVsPgoJCWtleSB5b3UgZ2V0IHRoZSBjb2RlIGZvciB0aGUgPERlbD4ga2V5LCBub3QgdGhlIHJhdyBjaGFyYWN0ZXIKCQlzZXF1ZW5jZS4gIEV4YW1wbGVzOiA+CgkJCWdldGNoYXIoKSA9PSAiXDxEZWw+IgoJCQlnZXRjaGFyKCkgPT0gIlw8Uy1MZWZ0PiIKPAkJVGhpcyBleGFtcGxlIHJlZGVmaW5lcyAiZiIgdG8gaWdub3JlIGNhc2U6ID4KCQkJOm5tYXAgZiA6Y2FsbCBGaW5kQ2hhcigpPENSPgoJCQk6ZnVuY3Rpb24gRmluZENoYXIoKQoJCQk6ICBsZXQgYyA9IG5yMmNoYXIoZ2V0Y2hhcigpKQoJCQk6ICB3aGlsZSBjb2woJy4nKSA8IGNvbCgnJCcpIC0gMQoJCQk6ICAgIG5vcm1hbCBsCgkJCTogICAgaWYgZ2V0bGluZSgnLicpW2NvbCgnLicpIC0gMV0gPT0/IGMKCQkJOiAgICAgIGJyZWFrCgkJCTogICAgZW5kaWYKCQkJOiAgZW5kd2hpbGUKCQkJOmVuZGZ1bmN0aW9uCgpnZXRjaGFybW9kKCkJCQkJCQkqZ2V0Y2hhcm1vZCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIgd2hpY2ggaXMgdGhlIHN0YXRlIG9mIHRoZSBtb2RpZmllcnMgZm9yCgkJdGhlIGxhc3Qgb2J0YWluZWQgY2hhcmFjdGVyIHdpdGggZ2V0Y2hhcigpIG9yIGluIGFub3RoZXIgd2F5LgoJCVRoZXNlIHZhbHVlcyBhcmUgYWRkZWQgdG9nZXRoZXI6CgkJCTIJc2hpZnQKCQkJNAljb250cm9sCgkJCTgJYWx0IChtZXRhKQoJCQkxNgltZXRhICh3aGVuIGl0J3MgZGlmZmVyZW50IGZyb20gQUxUKQoJCQkzMgltb3VzZSBkb3VibGUgY2xpY2sKCQkJNjQJbW91c2UgdHJpcGxlIGNsaWNrCgkJCTk2CW1vdXNlIHF1YWRydXBsZSBjbGljayAoPT0gMzIgKyA2NCkKCQkJMTI4CWNvbW1hbmQgKE1hY2ludG9zaCBvbmx5KQoJCU9ubHkgdGhlIG1vZGlmaWVycyB0aGF0IGhhdmUgbm90IGJlZW4gaW5jbHVkZWQgaW4gdGhlCgkJY2hhcmFjdGVyIGl0c2VsZiBhcmUgb2J0YWluZWQuCVRodXMgU2hpZnQtYSByZXN1bHRzIGluICJBIgoJCXdpdGhvdXQgYSBtb2RpZmllci4KCmdldGNtZGxpbmUoKQkJCQkJCSpnZXRjbWRsaW5lKCkqCgkJUmV0dXJuIHRoZSBjdXJyZW50IGNvbW1hbmQtbGluZS4gIE9ubHkgd29ya3Mgd2hlbiB0aGUgY29tbWFuZAoJCWxpbmUgaXMgYmVpbmcgZWRpdGVkLCB0aHVzIHJlcXVpcmVzIHVzZSBvZiB8Y19DVFJMLVxfZXwgb3IKCQl8Y19DVFJMLVJfPXwuCgkJRXhhbXBsZTogPgoJCQk6Y21hcCA8Rjc+IDxDLVw+ZWVzY2FwZShnZXRjbWRsaW5lKCksICcgXCcpPENSPgo8CQlBbHNvIHNlZSB8Z2V0Y21kdHlwZSgpfCwgfGdldGNtZHBvcygpfCBhbmQgfHNldGNtZHBvcygpfC4KCmdldGNtZHBvcygpCQkJCQkJKmdldGNtZHBvcygpKgoJCVJldHVybiB0aGUgcG9zaXRpb24gb2YgdGhlIGN1cnNvciBpbiB0aGUgY29tbWFuZCBsaW5lIGFzIGEKCQlieXRlIGNvdW50LiAgVGhlIGZpcnN0IGNvbHVtbiBpcyAxLgoJCU9ubHkgd29ya3Mgd2hlbiBlZGl0aW5nIHRoZSBjb21tYW5kIGxpbmUsIHRodXMgcmVxdWlyZXMgdXNlIG9mCgkJfGNfQ1RSTC1cX2V8IG9yIHxjX0NUUkwtUl89fC4gIFJldHVybnMgMCBvdGhlcndpc2UuCgkJQWxzbyBzZWUgfGdldGNtZHR5cGUoKXwsIHxzZXRjbWRwb3MoKXwgYW5kIHxnZXRjbWRsaW5lKCl8LgoKZ2V0Y21kdHlwZSgpCQkJCQkJKmdldGNtZHR5cGUoKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgY29tbWFuZC1saW5lIHR5cGUuIFBvc3NpYmxlIHJldHVybiB2YWx1ZXMKCQlhcmU6CgkJICAgIDoJbm9ybWFsIEV4IGNvbW1hbmQKCQkgICAgPglkZWJ1ZyBtb2RlIGNvbW1hbmQgfGRlYnVnLW1vZGV8CgkJICAgIC8JZm9yd2FyZCBzZWFyY2ggY29tbWFuZAoJCSAgICA/CWJhY2t3YXJkIHNlYXJjaCBjb21tYW5kCgkJICAgIEAJfGlucHV0KCl8IGNvbW1hbmQKCQkgICAgLQl8Omluc2VydHwgb3IgfDphcHBlbmR8IGNvbW1hbmQKCQlPbmx5IHdvcmtzIHdoZW4gZWRpdGluZyB0aGUgY29tbWFuZCBsaW5lLCB0aHVzIHJlcXVpcmVzIHVzZSBvZgoJCXxjX0NUUkwtXF9lfCBvciB8Y19DVFJMLVJfPXwuICBSZXR1cm5zIGFuIGVtcHR5IHN0cmluZwoJCW90aGVyd2lzZS4KCQlBbHNvIHNlZSB8Z2V0Y21kcG9zKCl8LCB8c2V0Y21kcG9zKCl8IGFuZCB8Z2V0Y21kbGluZSgpfC4KCgkJCQkJCQkqZ2V0Y3dkKCkqCmdldGN3ZCgpCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSBuYW1lIG9mIHRoZSBjdXJyZW50CgkJd29ya2luZyBkaXJlY3RvcnkuCgpnZXRmc2l6ZSh7Zm5hbWV9KQkJCQkJKmdldGZzaXplKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIHNpemUgaW4gYnl0ZXMgb2YgdGhlCgkJZ2l2ZW4gZmlsZSB7Zm5hbWV9LgoJCUlmIHtmbmFtZX0gaXMgYSBkaXJlY3RvcnksIDAgaXMgcmV0dXJuZWQuCgkJSWYgdGhlIGZpbGUge2ZuYW1lfSBjYW4ndCBiZSBmb3VuZCwgLTEgaXMgcmV0dXJuZWQuCgkJSWYgdGhlIHNpemUgb2Yge2ZuYW1lfSBpcyB0b28gYmlnIHRvIGZpdCBpbiBhIE51bWJlciB0aGVuIC0yCgkJaXMgcmV0dXJuZWQuCgpnZXRmb250bmFtZShbe25hbWV9XSkJCQkJCSpnZXRmb250bmFtZSgpKgoJCVdpdGhvdXQgYW4gYXJndW1lbnQgcmV0dXJucyB0aGUgbmFtZSBvZiB0aGUgbm9ybWFsIGZvbnQgYmVpbmcKCQl1c2VkLiAgTGlrZSB3aGF0IGlzIHVzZWQgZm9yIHRoZSBOb3JtYWwgaGlnaGxpZ2h0IGdyb3VwCgkJfGhsLU5vcm1hbHwuCgkJV2l0aCBhbiBhcmd1bWVudCBhIGNoZWNrIGlzIGRvbmUgd2hldGhlciB7bmFtZX0gaXMgYSB2YWxpZAoJCWZvbnQgbmFtZS4gIElmIG5vdCB0aGVuIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCQlPdGhlcndpc2UgdGhlIGFjdHVhbCBmb250IG5hbWUgaXMgcmV0dXJuZWQsIG9yIHtuYW1lfSBpZiB0aGUKCQlHVUkgZG9lcyBub3Qgc3VwcG9ydCBvYnRhaW5pbmcgdGhlIHJlYWwgbmFtZS4KCQlPbmx5IHdvcmtzIHdoZW4gdGhlIEdVSSBpcyBydW5uaW5nLCB0aHVzIG5vdCBpbiB5b3VyIHZpbXJjIG9yCgkJZ3ZpbXJjIGZpbGUuICBVc2UgdGhlIHxHVUlFbnRlcnwgYXV0b2NvbW1hbmQgdG8gdXNlIHRoaXMKCQlmdW5jdGlvbiBqdXN0IGFmdGVyIHRoZSBHVUkgaGFzIHN0YXJ0ZWQuCgkJTm90ZSB0aGF0IHRoZSBHVEsgMiBHVUkgYWNjZXB0cyBhbnkgZm9udCBuYW1lLCB0aHVzIGNoZWNraW5nCgkJZm9yIGEgdmFsaWQgbmFtZSBkb2VzIG5vdCB3b3JrLgoKZ2V0ZnBlcm0oe2ZuYW1lfSkJCQkJCSpnZXRmcGVybSgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSByZWFkLCB3cml0ZSwgYW5kIGV4ZWN1dGUKCQlwZXJtaXNzaW9ucyBvZiB0aGUgZ2l2ZW4gZmlsZSB7Zm5hbWV9LgoJCUlmIHtmbmFtZX0gZG9lcyBub3QgZXhpc3Qgb3IgaXRzIGRpcmVjdG9yeSBjYW5ub3QgYmUgcmVhZCwgYW4KCQllbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuCgkJVGhlIHJlc3VsdCBpcyBvZiB0aGUgZm9ybSAicnd4cnd4cnd4Iiwgd2hlcmUgZWFjaCBncm91cCBvZgoJCSJyd3giIGZsYWdzIHJlcHJlc2VudCwgaW4gdHVybiwgdGhlIHBlcm1pc3Npb25zIG9mIHRoZSBvd25lcgoJCW9mIHRoZSBmaWxlLCB0aGUgZ3JvdXAgdGhlIGZpbGUgYmVsb25ncyB0bywgYW5kIG90aGVyIHVzZXJzLgoJCUlmIGEgdXNlciBkb2VzIG5vdCBoYXZlIGEgZ2l2ZW4gcGVybWlzc2lvbiB0aGUgZmxhZyBmb3IgdGhpcwoJCWlzIHJlcGxhY2VkIHdpdGggdGhlIHN0cmluZyAiLSIuICBFeGFtcGxlOiA+CgkJCTplY2hvIGdldGZwZXJtKCIvZXRjL3Bhc3N3ZCIpCjwJCVRoaXMgd2lsbCBob3BlZnVsbHkgKGZyb20gYSBzZWN1cml0eSBwb2ludCBvZiB2aWV3KSBkaXNwbGF5CgkJdGhlIHN0cmluZyAicnctci0tci0tIiBvciBldmVuICJydy0tLS0tLS0iLgoKZ2V0ZnRpbWUoe2ZuYW1lfSkJCQkJCSpnZXRmdGltZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBsYXN0IG1vZGlmaWNhdGlvbiB0aW1lIG9mCgkJdGhlIGdpdmVuIGZpbGUge2ZuYW1lfS4gIFRoZSB2YWx1ZSBpcyBtZWFzdXJlZCBhcyBzZWNvbmRzCgkJc2luY2UgMXN0IEphbiAxOTcwLCBhbmQgbWF5IGJlIHBhc3NlZCB0byBzdHJmdGltZSgpLiAgU2VlIGFsc28KCQl8bG9jYWx0aW1lKCl8IGFuZCB8c3RyZnRpbWUoKXwuCgkJSWYgdGhlIGZpbGUge2ZuYW1lfSBjYW4ndCBiZSBmb3VuZCAtMSBpcyByZXR1cm5lZC4KCmdldGZ0eXBlKHtmbmFtZX0pCQkJCQkqZ2V0ZnR5cGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyBhIGRlc2NyaXB0aW9uIG9mIHRoZSBraW5kIG9mCgkJZmlsZSBvZiB0aGUgZ2l2ZW4gZmlsZSB7Zm5hbWV9LgoJCUlmIHtmbmFtZX0gZG9lcyBub3QgZXhpc3QgYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoJCUhlcmUgaXMgYSB0YWJsZSBvdmVyIGRpZmZlcmVudCBraW5kcyBvZiBmaWxlcyBhbmQgdGhlaXIKCQlyZXN1bHRzOgoJCQlOb3JtYWwgZmlsZQkJImZpbGUiCgkJCURpcmVjdG9yeQkJImRpciIKCQkJU3ltYm9saWMgbGluawkJImxpbmsiCgkJCUJsb2NrIGRldmljZQkJImJkZXYiCgkJCUNoYXJhY3RlciBkZXZpY2UJImNkZXYiCgkJCVNvY2tldAkJCSJzb2NrZXQiCgkJCUZJRk8JCQkiZmlmbyIKCQkJQWxsIG90aGVyCQkib3RoZXIiCgkJRXhhbXBsZTogPgoJCQlnZXRmdHlwZSgiL2hvbWUiKQo8CQlOb3RlIHRoYXQgYSB0eXBlIHN1Y2ggYXMgImxpbmsiIHdpbGwgb25seSBiZSByZXR1cm5lZCBvbgoJCXN5c3RlbXMgdGhhdCBzdXBwb3J0IGl0LiAgT24gc29tZSBzeXN0ZW1zIG9ubHkgImRpciIgYW5kCgkJImZpbGUiIGFyZSByZXR1cm5lZC4KCgkJCQkJCQkqZ2V0bGluZSgpKgpnZXRsaW5lKHtsbnVtfSBbLCB7ZW5kfV0pCgkJV2l0aG91dCB7ZW5kfSB0aGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyBsaW5lIHtsbnVtfQoJCWZyb20gdGhlIGN1cnJlbnQgYnVmZmVyLiAgRXhhbXBsZTogPgoJCQlnZXRsaW5lKDEpCjwJCVdoZW4ge2xudW19IGlzIGEgU3RyaW5nIHRoYXQgZG9lc24ndCBzdGFydCB3aXRoIGEKCQlkaWdpdCwgbGluZSgpIGlzIGNhbGxlZCB0byB0cmFuc2xhdGUgdGhlIFN0cmluZyBpbnRvIGEgTnVtYmVyLgoJCVRvIGdldCB0aGUgbGluZSB1bmRlciB0aGUgY3Vyc29yOiA+CgkJCWdldGxpbmUoIi4iKQo8CQlXaGVuIHtsbnVtfSBpcyBzbWFsbGVyIHRoYW4gMSBvciBiaWdnZXIgdGhhbiB0aGUgbnVtYmVyIG9mCgkJbGluZXMgaW4gdGhlIGJ1ZmZlciwgYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoKCQlXaGVuIHtlbmR9IGlzIGdpdmVuIHRoZSByZXN1bHQgaXMgYSB8TGlzdHwgd2hlcmUgZWFjaCBpdGVtIGlzCgkJYSBsaW5lIGZyb20gdGhlIGN1cnJlbnQgYnVmZmVyIGluIHRoZSByYW5nZSB7bG51bX0gdG8ge2VuZH0sCgkJaW5jbHVkaW5nIGxpbmUge2VuZH0uCgkJe2VuZH0gaXMgdXNlZCBpbiB0aGUgc2FtZSB3YXkgYXMge2xudW19LgoJCU5vbi1leGlzdGluZyBsaW5lcyBhcmUgc2lsZW50bHkgb21pdHRlZC4KCQlXaGVuIHtlbmR9IGlzIGJlZm9yZSB7bG51bX0gYW4gZW1wdHkgfExpc3R8IGlzIHJldHVybmVkLgoJCUV4YW1wbGU6ID4KCQkJOmxldCBzdGFydCA9IGxpbmUoJy4nKQoJCQk6bGV0IGVuZCA9IHNlYXJjaCgiXiQiKSAtIDEKCQkJOmxldCBsaW5lcyA9IGdldGxpbmUoc3RhcnQsIGVuZCkKCjwJCVRvIGdldCBsaW5lcyBmcm9tIGFub3RoZXIgYnVmZmVyIHNlZSB8Z2V0YnVmbGluZSgpfAoKZ2V0bG9jbGlzdCh7bnJ9KQkJCQkJKmdldGxvY2xpc3QoKSoKCQlSZXR1cm5zIGEgbGlzdCB3aXRoIGFsbCB0aGUgZW50cmllcyBpbiB0aGUgbG9jYXRpb24gbGlzdCBmb3IKCQl3aW5kb3cge25yfS4gV2hlbiB7bnJ9IGlzIHplcm8gdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuCgkJRm9yIGEgbG9jYXRpb24gbGlzdCB3aW5kb3csIHRoZSBkaXNwbGF5ZWQgbG9jYXRpb24gbGlzdCBpcwoJCXJldHVybmVkLiAgRm9yIGFuIGludmFsaWQgd2luZG93IG51bWJlciB7bnJ9LCBhbiBlbXB0eSBsaXN0IGlzCgkJcmV0dXJuZWQuIE90aGVyd2lzZSwgc2FtZSBhcyB8Z2V0cWZsaXN0KCl8LgoKZ2V0bWF0Y2hlcygpCQkJCQkJKmdldG1hdGNoZXMoKSoKCQlSZXR1cm5zIGEgfExpc3R8IHdpdGggYWxsIG1hdGNoZXMgcHJldmlvdXNseSBkZWZpbmVkIGJ5CgkJfG1hdGNoYWRkKCl8IGFuZCB0aGUgfDptYXRjaHwgY29tbWFuZHMuICB8Z2V0bWF0Y2hlcygpfCBpcwoJCXVzZWZ1bCBpbiBjb21iaW5hdGlvbiB3aXRoIHxzZXRtYXRjaGVzKCl8LCBhcyB8c2V0bWF0Y2hlcygpfAoJCWNhbiByZXN0b3JlIGEgbGlzdCBvZiBtYXRjaGVzIHNhdmVkIGJ5IHxnZXRtYXRjaGVzKCl8LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gZ2V0bWF0Y2hlcygpCjwJCQlbeydncm91cCc6ICdNeUdyb3VwMScsICdwYXR0ZXJuJzogJ1RPRE8nLAoJCQkncHJpb3JpdHknOiAxMCwgJ2lkJzogMX0sIHsnZ3JvdXAnOiAnTXlHcm91cDInLAoJCQkncGF0dGVybic6ICdGSVhNRScsICdwcmlvcml0eSc6IDEwLCAnaWQnOiAyfV0gPgoJCQk6bGV0IG0gPSBnZXRtYXRjaGVzKCkKCQkJOmNhbGwgY2xlYXJtYXRjaGVzKCkKCQkJOmVjaG8gZ2V0bWF0Y2hlcygpCjwJCQlbXSA+CgkJCTpjYWxsIHNldG1hdGNoZXMobSkKCQkJOmVjaG8gZ2V0bWF0Y2hlcygpCjwJCQlbeydncm91cCc6ICdNeUdyb3VwMScsICdwYXR0ZXJuJzogJ1RPRE8nLAoJCQkncHJpb3JpdHknOiAxMCwgJ2lkJzogMX0sIHsnZ3JvdXAnOiAnTXlHcm91cDInLAoJCQkncGF0dGVybic6ICdGSVhNRScsICdwcmlvcml0eSc6IDEwLCAnaWQnOiAyfV0gPgoJCQk6dW5sZXQgbQo8CgpnZXRxZmxpc3QoKQkJCQkJCSpnZXRxZmxpc3QoKSoKCQlSZXR1cm5zIGEgbGlzdCB3aXRoIGFsbCB0aGUgY3VycmVudCBxdWlja2ZpeCBlcnJvcnMuICBFYWNoCgkJbGlzdCBpdGVtIGlzIGEgZGljdGlvbmFyeSB3aXRoIHRoZXNlIGVudHJpZXM6CgkJCWJ1Zm5yCW51bWJlciBvZiBidWZmZXIgdGhhdCBoYXMgdGhlIGZpbGUgbmFtZSwgdXNlCgkJCQlidWZuYW1lKCkgdG8gZ2V0IHRoZSBuYW1lCgkJCWxudW0JbGluZSBudW1iZXIgaW4gdGhlIGJ1ZmZlciAoZmlyc3QgbGluZSBpcyAxKQoJCQljb2wJY29sdW1uIG51bWJlciAoZmlyc3QgY29sdW1uIGlzIDEpCgkJCXZjb2wJbm9uLXplcm86ICJjb2wiIGlzIHZpc3VhbCBjb2x1bW4KCQkJCXplcm86ICJjb2wiIGlzIGJ5dGUgaW5kZXgKCQkJbnIJZXJyb3IgbnVtYmVyCgkJCXBhdHRlcm4Jc2VhcmNoIHBhdHRlcm4gdXNlZCB0byBsb2NhdGUgdGhlIGVycm9yCgkJCXRleHQJZGVzY3JpcHRpb24gb2YgdGhlIGVycm9yCgkJCXR5cGUJdHlwZSBvZiB0aGUgZXJyb3IsICdFJywgJzEnLCBldGMuCgkJCXZhbGlkCW5vbi16ZXJvOiByZWNvZ25pemVkIGVycm9yIG1lc3NhZ2UKCgkJV2hlbiB0aGVyZSBpcyBubyBlcnJvciBsaXN0IG9yIGl0J3MgZW1wdHkgYW4gZW1wdHkgbGlzdCBpcwoJCXJldHVybmVkLiBRdWlja2ZpeCBsaXN0IGVudHJpZXMgd2l0aCBub24tZXhpc3RpbmcgYnVmZmVyCgkJbnVtYmVyIGFyZSByZXR1cm5lZCB3aXRoICJidWZuciIgc2V0IHRvIHplcm8uCgoJCVVzZWZ1bCBhcHBsaWNhdGlvbjogRmluZCBwYXR0ZXJuIG1hdGNoZXMgaW4gbXVsdGlwbGUgZmlsZXMgYW5kCgkJZG8gc29tZXRoaW5nIHdpdGggdGhlbTogPgoJCQk6dmltZ3JlcCAvdGhld29yZC9qZyAqLmMKCQkJOmZvciBkIGluIGdldHFmbGlzdCgpCgkJCTogICBlY2hvIGJ1Zm5hbWUoZC5idWZucikgJzonIGQubG51bSAnPScgZC50ZXh0CgkJCTplbmRmb3IKCgpnZXRyZWcoW3tyZWduYW1lfSBbLCAxXV0pCQkJCSpnZXRyZWcoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUgY29udGVudHMgb2YgcmVnaXN0ZXIKCQl7cmVnbmFtZX0uICBFeGFtcGxlOiA+CgkJCTpsZXQgY2xpcHRleHQgPSBnZXRyZWcoJyonKQo8CQlnZXRyZWcoJz0nKSByZXR1cm5zIHRoZSBsYXN0IGV2YWx1YXRlZCB2YWx1ZSBvZiB0aGUgZXhwcmVzc2lvbgoJCXJlZ2lzdGVyLiAgKEZvciB1c2UgaW4gbWFwcy4pCgkJZ2V0cmVnKCc9JywgMSkgcmV0dXJucyB0aGUgZXhwcmVzc2lvbiBpdHNlbGYsIHNvIHRoYXQgaXQgY2FuCgkJYmUgcmVzdG9yZWQgd2l0aCB8c2V0cmVnKCl8LiAgRm9yIG90aGVyIHJlZ2lzdGVycyB0aGUgZXh0cmEKCQlhcmd1bWVudCBpcyBpZ25vcmVkLCB0aHVzIHlvdSBjYW4gYWx3YXlzIGdpdmUgaXQuCgkJSWYge3JlZ25hbWV9IGlzIG5vdCBzcGVjaWZpZWQsIHx2OnJlZ2lzdGVyfCBpcyB1c2VkLgoKCmdldHJlZ3R5cGUoW3tyZWduYW1lfV0pCQkJCQkqZ2V0cmVndHlwZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHR5cGUgb2YgcmVnaXN0ZXIge3JlZ25hbWV9LgoJCVRoZSB2YWx1ZSB3aWxsIGJlIG9uZSBvZjoKCQkgICAgInYiCQkJZm9yIHxjaGFyYWN0ZXJ3aXNlfCB0ZXh0CgkJICAgICJWIgkJCWZvciB8bGluZXdpc2V8IHRleHQKCQkgICAgIjxDVFJMLVY+e3dpZHRofSIJZm9yIHxibG9ja3dpc2UtdmlzdWFsfCB0ZXh0CgkJICAgIDAJCQlmb3IgYW4gZW1wdHkgb3IgdW5rbm93biByZWdpc3RlcgoJCTxDVFJMLVY+IGlzIG9uZSBjaGFyYWN0ZXIgd2l0aCB2YWx1ZSAweDE2LgoJCUlmIHtyZWduYW1lfSBpcyBub3Qgc3BlY2lmaWVkLCB8djpyZWdpc3RlcnwgaXMgdXNlZC4KCmdldHRhYnZhcih7dGFibnJ9LCB7dmFybmFtZX0pCQkJCSpnZXR0YWJ2YXIoKSoKCQlHZXQgdGhlIHZhbHVlIG9mIGEgdGFiLWxvY2FsIHZhcmlhYmxlIHt2YXJuYW1lfSBpbiB0YWIgcGFnZQoJCXt0YWJucn0uIHx0OnZhcnwKCQlUYWJzIGFyZSBudW1iZXJlZCBzdGFydGluZyB3aXRoIG9uZS4KCQlOb3RlIHRoYXQgdGhlIG5hbWUgd2l0aG91dCAidDoiIG11c3QgYmUgdXNlZC4KCmdldHRhYndpbnZhcih7dGFibnJ9LCB7d2lubnJ9LCB7dmFybmFtZX0pCQkqZ2V0dGFid2ludmFyKCkqCgkJR2V0IHRoZSB2YWx1ZSBvZiB3aW5kb3ctbG9jYWwgdmFyaWFibGUge3Zhcm5hbWV9IGluIHdpbmRvdwoJCXt3aW5ucn0gaW4gdGFiIHBhZ2Uge3RhYm5yfS4KCQlXaGVuIHt2YXJuYW1lfSBzdGFydHMgd2l0aCAiJiIgZ2V0IHRoZSB2YWx1ZSBvZiBhIHdpbmRvdy1sb2NhbAoJCW9wdGlvbi4KCQlUYWJzIGFyZSBudW1iZXJlZCBzdGFydGluZyB3aXRoIG9uZS4gIEZvciB0aGUgY3VycmVudCB0YWJwYWdlCgkJdXNlIHxnZXR3aW52YXIoKXwuCgkJV2hlbiB7d2lubnJ9IGlzIHplcm8gdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuCgkJVGhpcyBhbHNvIHdvcmtzIGZvciBhIGdsb2JhbCBvcHRpb24sIGJ1ZmZlci1sb2NhbCBvcHRpb24gYW5kCgkJd2luZG93LWxvY2FsIG9wdGlvbiwgYnV0IGl0IGRvZXNuJ3Qgd29yayBmb3IgYSBnbG9iYWwgdmFyaWFibGUKCQlvciBidWZmZXItbG9jYWwgdmFyaWFibGUuCgkJV2hlbiB7dmFybmFtZX0gaXMgZW1wdHkgYSBkaWN0aW9uYXJ5IHdpdGggYWxsIHdpbmRvdy1sb2NhbAoJCXZhcmlhYmxlcyBpcyByZXR1cm5lZC4KCQlOb3RlIHRoYXQge3Zhcm5hbWV9IG11c3QgYmUgdGhlIG5hbWUgd2l0aG91dCAidzoiLgoJCUV4YW1wbGVzOiA+CgkJCTpsZXQgbGlzdF9pc19vbiA9IGdldHRhYndpbnZhcigxLCAyLCAnJmxpc3QnKQoJCQk6ZWNobyAibXl2YXIgPSAiIC4gZ2V0dGFid2ludmFyKDMsIDEsICdteXZhcicpCjwKCQkJCQkJCSpnZXR3aW5wb3N4KCkqCmdldHdpbnBvc3goKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgWCBjb29yZGluYXRlIGluIHBpeGVscyBvZgoJCXRoZSBsZWZ0IGhhbmQgc2lkZSBvZiB0aGUgR1VJIFZpbSB3aW5kb3cuICBUaGUgcmVzdWx0IHdpbGwgYmUKCQktMSBpZiB0aGUgaW5mb3JtYXRpb24gaXMgbm90IGF2YWlsYWJsZS4KCgkJCQkJCQkqZ2V0d2lucG9zeSgpKgpnZXR3aW5wb3N5KCkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIFkgY29vcmRpbmF0ZSBpbiBwaXhlbHMgb2YKCQl0aGUgdG9wIG9mIHRoZSBHVUkgVmltIHdpbmRvdy4JVGhlIHJlc3VsdCB3aWxsIGJlIC0xIGlmIHRoZQoJCWluZm9ybWF0aW9uIGlzIG5vdCBhdmFpbGFibGUuCgpnZXR3aW52YXIoe3dpbm5yfSwge3Zhcm5hbWV9KQkJCQkqZ2V0d2ludmFyKCkqCgkJTGlrZSB8Z2V0dGFid2ludmFyKCl8IGZvciB0aGUgY3VycmVudCB0YWJwYWdlLgoJCUV4YW1wbGVzOiA+CgkJCTpsZXQgbGlzdF9pc19vbiA9IGdldHdpbnZhcigyLCAnJmxpc3QnKQoJCQk6ZWNobyAibXl2YXIgPSAiIC4gZ2V0d2ludmFyKDEsICdteXZhcicpCjwKZ2xvYih7ZXhwcn0gWywge2ZsYWd9XSkJCQkJCSpnbG9iKCkqCgkJRXhwYW5kIHRoZSBmaWxlIHdpbGRjYXJkcyBpbiB7ZXhwcn0uICBTZWUgfHdpbGRjYXJkc3wgZm9yIHRoZQoJCXVzZSBvZiBzcGVjaWFsIGNoYXJhY3RlcnMuCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZy4KCQlXaGVuIHRoZXJlIGFyZSBzZXZlcmFsIG1hdGNoZXMsIHRoZXkgYXJlIHNlcGFyYXRlZCBieSA8Tkw+CgkJY2hhcmFjdGVycy4KCQlVbmxlc3MgdGhlIG9wdGlvbmFsIHtmbGFnfSBhcmd1bWVudCBpcyBnaXZlbiBhbmQgaXMgbm9uLXplcm8sCgkJdGhlICdzdWZmaXhlcycgYW5kICd3aWxkaWdub3JlJyBvcHRpb25zIGFwcGx5OiBOYW1lcyBtYXRjaGluZwoJCW9uZSBvZiB0aGUgcGF0dGVybnMgaW4gJ3dpbGRpZ25vcmUnIHdpbGwgYmUgc2tpcHBlZCBhbmQKCQknc3VmZml4ZXMnIGFmZmVjdCB0aGUgb3JkZXJpbmcgb2YgbWF0Y2hlcy4KCQknd2lsZGlnbm9yZWNhc2UnIGFsd2F5cyBhcHBsaWVzLgoJCUlmIHRoZSBleHBhbnNpb24gZmFpbHMsIHRoZSByZXN1bHQgaXMgYW4gZW1wdHkgc3RyaW5nLgoJCUEgbmFtZSBmb3IgYSBub24tZXhpc3RpbmcgZmlsZSBpcyBub3QgaW5jbHVkZWQuCgoJCUZvciBtb3N0IHN5c3RlbXMgYmFja3RpY2tzIGNhbiBiZSB1c2VkIHRvIGdldCBmaWxlcyBuYW1lcyBmcm9tCgkJYW55IGV4dGVybmFsIGNvbW1hbmQuICBFeGFtcGxlOiA+CgkJCTpsZXQgdGFnZmlsZXMgPSBnbG9iKCJgZmluZCAuIC1uYW1lIHRhZ3MgLXByaW50YCIpCgkJCTpsZXQgJnRhZ3MgPSBzdWJzdGl0dXRlKHRhZ2ZpbGVzLCAiXG4iLCAiLCIsICJnIikKPAkJVGhlIHJlc3VsdCBvZiB0aGUgcHJvZ3JhbSBpbnNpZGUgdGhlIGJhY2t0aWNrcyBzaG91bGQgYmUgb25lCgkJaXRlbSBwZXIgbGluZS4JU3BhY2VzIGluc2lkZSBhbiBpdGVtIGFyZSBhbGxvd2VkLgoKCQlTZWUgfGV4cGFuZCgpfCBmb3IgZXhwYW5kaW5nIHNwZWNpYWwgVmltIHZhcmlhYmxlcy4gIFNlZQoJCXxzeXN0ZW0oKXwgZm9yIGdldHRpbmcgdGhlIHJhdyBvdXRwdXQgb2YgYW4gZXh0ZXJuYWwgY29tbWFuZC4KCmdsb2JwYXRoKHtwYXRofSwge2V4cHJ9IFssIHtmbGFnfV0pCQkJKmdsb2JwYXRoKCkqCgkJUGVyZm9ybSBnbG9iKCkgb24gYWxsIGRpcmVjdG9yaWVzIGluIHtwYXRofSBhbmQgY29uY2F0ZW5hdGUKCQl0aGUgcmVzdWx0cy4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gZ2xvYnBhdGgoJnJ0cCwgInN5bnRheC9jLnZpbSIpCjwJCXtwYXRofSBpcyBhIGNvbW1hLXNlcGFyYXRlZCBsaXN0IG9mIGRpcmVjdG9yeSBuYW1lcy4gIEVhY2gKCQlkaXJlY3RvcnkgbmFtZSBpcyBwcmVwZW5kZWQgdG8ge2V4cHJ9IGFuZCBleHBhbmRlZCBsaWtlIHdpdGgKCQl8Z2xvYigpfC4gIEEgcGF0aCBzZXBhcmF0b3IgaXMgaW5zZXJ0ZWQgd2hlbiBuZWVkZWQuCgkJVG8gYWRkIGEgY29tbWEgaW5zaWRlIGEgZGlyZWN0b3J5IG5hbWUgZXNjYXBlIGl0IHdpdGggYQoJCWJhY2tzbGFzaC4gIE5vdGUgdGhhdCBvbiBNUy1XaW5kb3dzIGEgZGlyZWN0b3J5IG1heSBoYXZlIGEKCQl0cmFpbGluZyBiYWNrc2xhc2gsIHJlbW92ZSBpdCBpZiB5b3UgcHV0IGEgY29tbWEgYWZ0ZXIgaXQuCgkJSWYgdGhlIGV4cGFuc2lvbiBmYWlscyBmb3Igb25lIG9mIHRoZSBkaXJlY3RvcmllcywgdGhlcmUgaXMgbm8KCQllcnJvciBtZXNzYWdlLgoJCVVubGVzcyB0aGUgb3B0aW9uYWwge2ZsYWd9IGFyZ3VtZW50IGlzIGdpdmVuIGFuZCBpcyBub24temVybywKCQl0aGUgJ3N1ZmZpeGVzJyBhbmQgJ3dpbGRpZ25vcmUnIG9wdGlvbnMgYXBwbHk6IE5hbWVzIG1hdGNoaW5nCgkJb25lIG9mIHRoZSBwYXR0ZXJucyBpbiAnd2lsZGlnbm9yZScgd2lsbCBiZSBza2lwcGVkIGFuZAoJCSdzdWZmaXhlcycgYWZmZWN0IHRoZSBvcmRlcmluZyBvZiBtYXRjaGVzLgoKCQlUaGUgIioqIiBpdGVtIGNhbiBiZSB1c2VkIHRvIHNlYXJjaCBpbiBhIGRpcmVjdG9yeSB0cmVlLgoJCUZvciBleGFtcGxlLCB0byBmaW5kIGFsbCAiUkVBRE1FLnR4dCIgZmlsZXMgaW4gdGhlIGRpcmVjdG9yaWVzCgkJaW4gJ3J1bnRpbWVwYXRoJyBhbmQgYmVsb3c6ID4KCQkJOmVjaG8gZ2xvYnBhdGgoJnJ0cCwgIioqL1JFQURNRS50eHQiKQo8CQlVcHdhcmRzIHNlYXJjaCBhbmQgbGltaXRpbmcgdGhlIGRlcHRoIG9mICIqKiIgaXMgbm90CgkJc3VwcG9ydGVkLCB0aHVzIHVzaW5nICdwYXRoJyB3aWxsIG5vdCBhbHdheXMgd29yayBwcm9wZXJseS4KCgkJCQkJCQkqaGFzKCkqCmhhcyh7ZmVhdHVyZX0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIDEgaWYgdGhlIGZlYXR1cmUge2ZlYXR1cmV9IGlzCgkJc3VwcG9ydGVkLCB6ZXJvIG90aGVyd2lzZS4gIFRoZSB7ZmVhdHVyZX0gYXJndW1lbnQgaXMgYQoJCXN0cmluZy4gIFNlZSB8ZmVhdHVyZS1saXN0fCBiZWxvdy4KCQlBbHNvIHNlZSB8ZXhpc3RzKCl8LgoKCmhhc19rZXkoe2RpY3R9LCB7a2V5fSkJCQkJCSpoYXNfa2V5KCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSBpZiB8RGljdGlvbmFyeXwge2RpY3R9IGhhcwoJCWFuIGVudHJ5IHdpdGgga2V5IHtrZXl9LiAgWmVybyBvdGhlcndpc2UuCgpoYXNsb2NhbGRpcigpCQkJCQkJKmhhc2xvY2FsZGlyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSB3aGVuIHRoZSBjdXJyZW50CgkJd2luZG93IGhhcyBzZXQgYSBsb2NhbCBwYXRoIHZpYSB8OmxjZHwsIGFuZCAwIG90aGVyd2lzZS4KCmhhc21hcHRvKHt3aGF0fSBbLCB7bW9kZX0gWywge2FiYnJ9XV0pCQkJKmhhc21hcHRvKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSBpZiB0aGVyZSBpcyBhIG1hcHBpbmcgdGhhdAoJCWNvbnRhaW5zIHt3aGF0fSBpbiBzb21ld2hlcmUgaW4gdGhlIHJocyAod2hhdCBpdCBpcyBtYXBwZWQgdG8pCgkJYW5kIHRoaXMgbWFwcGluZyBleGlzdHMgaW4gb25lIG9mIHRoZSBtb2RlcyBpbmRpY2F0ZWQgYnkKCQl7bW9kZX0uCgkJV2hlbiB7YWJicn0gaXMgdGhlcmUgYW5kIGl0IGlzIG5vbi16ZXJvIHVzZSBhYmJyZXZpYXRpb25zCgkJaW5zdGVhZCBvZiBtYXBwaW5ncy4gIERvbid0IGZvcmdldCB0byBzcGVjaWZ5IEluc2VydCBhbmQvb3IKCQlDb21tYW5kLWxpbmUgbW9kZS4KCQlCb3RoIHRoZSBnbG9iYWwgbWFwcGluZ3MgYW5kIHRoZSBtYXBwaW5ncyBsb2NhbCB0byB0aGUgY3VycmVudAoJCWJ1ZmZlciBhcmUgY2hlY2tlZCBmb3IgYSBtYXRjaC4KCQlJZiBubyBtYXRjaGluZyBtYXBwaW5nIGlzIGZvdW5kIDAgaXMgcmV0dXJuZWQuCgkJVGhlIGZvbGxvd2luZyBjaGFyYWN0ZXJzIGFyZSByZWNvZ25pemVkIGluIHttb2RlfToKCQkJbglOb3JtYWwgbW9kZQoJCQl2CVZpc3VhbCBtb2RlCgkJCW8JT3BlcmF0b3ItcGVuZGluZyBtb2RlCgkJCWkJSW5zZXJ0IG1vZGUKCQkJbAlMYW5ndWFnZS1Bcmd1bWVudCAoInIiLCAiZiIsICJ0IiwgZXRjLikKCQkJYwlDb21tYW5kLWxpbmUgbW9kZQoJCVdoZW4ge21vZGV9IGlzIG9taXR0ZWQsICJudm8iIGlzIHVzZWQuCgoJCVRoaXMgZnVuY3Rpb24gaXMgdXNlZnVsIHRvIGNoZWNrIGlmIGEgbWFwcGluZyBhbHJlYWR5IGV4aXN0cwoJCXRvIGEgZnVuY3Rpb24gaW4gYSBWaW0gc2NyaXB0LglFeGFtcGxlOiA+CgkJCTppZiAhaGFzbWFwdG8oJ1xBQkNkb2l0JykKCQkJOiAgIG1hcCA8TGVhZGVyPmQgXEFCQ2RvaXQKCQkJOmVuZGlmCjwJCVRoaXMgaW5zdGFsbHMgdGhlIG1hcHBpbmcgdG8gIlxBQkNkb2l0IiBvbmx5IGlmIHRoZXJlIGlzbid0CgkJYWxyZWFkeSBhIG1hcHBpbmcgdG8gIlxBQkNkb2l0Ii4KCmhpc3RhZGQoe2hpc3Rvcnl9LCB7aXRlbX0pCQkJCSpoaXN0YWRkKCkqCgkJQWRkIHRoZSBTdHJpbmcge2l0ZW19IHRvIHRoZSBoaXN0b3J5IHtoaXN0b3J5fSB3aGljaCBjYW4gYmUKCQlvbmUgb2Y6CQkJCQkqaGlzdC1uYW1lcyoKCQkJImNtZCIJIG9yICI6IgkgIGNvbW1hbmQgbGluZSBoaXN0b3J5CgkJCSJzZWFyY2giIG9yICIvIiAgIHNlYXJjaCBwYXR0ZXJuIGhpc3RvcnkKCQkJImV4cHIiCSBvciAiPSIgICB0eXBlZCBleHByZXNzaW9uIGhpc3RvcnkKCQkJImlucHV0IiAgb3IgIkAiCSAgaW5wdXQgbGluZSBoaXN0b3J5CgkJSWYge2l0ZW19IGRvZXMgYWxyZWFkeSBleGlzdCBpbiB0aGUgaGlzdG9yeSwgaXQgd2lsbCBiZQoJCXNoaWZ0ZWQgdG8gYmVjb21lIHRoZSBuZXdlc3QgZW50cnkuCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlcjogMSBpZiB0aGUgb3BlcmF0aW9uIHdhcyBzdWNjZXNzZnVsLAoJCW90aGVyd2lzZSAwIGlzIHJldHVybmVkLgoKCQlFeGFtcGxlOiA+CgkJCTpjYWxsIGhpc3RhZGQoImlucHV0Iiwgc3RyZnRpbWUoIiVZICViICVkIikpCgkJCTpsZXQgZGF0ZT1pbnB1dCgiRW50ZXIgZGF0ZTogIikKPAkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgpoaXN0ZGVsKHtoaXN0b3J5fSBbLCB7aXRlbX1dKQkJCQkqaGlzdGRlbCgpKgoJCUNsZWFyIHtoaXN0b3J5fSwgaS5lLiBkZWxldGUgYWxsIGl0cyBlbnRyaWVzLiAgU2VlIHxoaXN0LW5hbWVzfAoJCWZvciB0aGUgcG9zc2libGUgdmFsdWVzIG9mIHtoaXN0b3J5fS4KCgkJSWYgdGhlIHBhcmFtZXRlciB7aXRlbX0gZXZhbHVhdGVzIHRvIGEgU3RyaW5nLCBpdCBpcyB1c2VkIGFzIGEKCQlyZWd1bGFyIGV4cHJlc3Npb24uICBBbGwgZW50cmllcyBtYXRjaGluZyB0aGF0IGV4cHJlc3Npb24gd2lsbAoJCWJlIHJlbW92ZWQgZnJvbSB0aGUgaGlzdG9yeSAoaWYgdGhlcmUgYXJlIGFueSkuCgkJVXBwZXIvbG93ZXJjYXNlIG11c3QgbWF0Y2gsIHVubGVzcyAiXGMiIGlzIHVzZWQgfC9cY3wuCgkJSWYge2l0ZW19IGV2YWx1YXRlcyB0byBhIE51bWJlciwgaXQgd2lsbCBiZSBpbnRlcnByZXRlZCBhcwoJCWFuIGluZGV4LCBzZWUgfDpoaXN0b3J5LWluZGV4aW5nfC4gIFRoZSByZXNwZWN0aXZlIGVudHJ5IHdpbGwKCQliZSByZW1vdmVkIGlmIGl0IGV4aXN0cy4KCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlcjogMSBmb3IgYSBzdWNjZXNzZnVsIG9wZXJhdGlvbiwKCQlvdGhlcndpc2UgMCBpcyByZXR1cm5lZC4KCgkJRXhhbXBsZXM6CgkJQ2xlYXIgZXhwcmVzc2lvbiByZWdpc3RlciBoaXN0b3J5OiA+CgkJCTpjYWxsIGhpc3RkZWwoImV4cHIiKQo8CgkJUmVtb3ZlIGFsbCBlbnRyaWVzIHN0YXJ0aW5nIHdpdGggIioiIGZyb20gdGhlIHNlYXJjaCBoaXN0b3J5OiA+CgkJCTpjYWxsIGhpc3RkZWwoIi8iLCAnXlwqJykKPAoJCVRoZSBmb2xsb3dpbmcgdGhyZWUgYXJlIGVxdWl2YWxlbnQ6ID4KCQkJOmNhbGwgaGlzdGRlbCgic2VhcmNoIiwgaGlzdG5yKCJzZWFyY2giKSkKCQkJOmNhbGwgaGlzdGRlbCgic2VhcmNoIiwgLTEpCgkJCTpjYWxsIGhpc3RkZWwoInNlYXJjaCIsICdeJy5oaXN0Z2V0KCJzZWFyY2giLCAtMSkuJyQnKQo8CgkJVG8gZGVsZXRlIHRoZSBsYXN0IHNlYXJjaCBwYXR0ZXJuIGFuZCB1c2UgdGhlIGxhc3QtYnV0LW9uZSBmb3IKCQl0aGUgIm4iIGNvbW1hbmQgYW5kICdobHNlYXJjaCc6ID4KCQkJOmNhbGwgaGlzdGRlbCgic2VhcmNoIiwgLTEpCgkJCTpsZXQgQC8gPSBoaXN0Z2V0KCJzZWFyY2giLCAtMSkKCmhpc3RnZXQoe2hpc3Rvcnl9IFssIHtpbmRleH1dKQkJCQkqaGlzdGdldCgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHRoZSBlbnRyeSB3aXRoIE51bWJlciB7aW5kZXh9IGZyb20KCQl7aGlzdG9yeX0uICBTZWUgfGhpc3QtbmFtZXN8IGZvciB0aGUgcG9zc2libGUgdmFsdWVzIG9mCgkJe2hpc3Rvcnl9LCBhbmQgfDpoaXN0b3J5LWluZGV4aW5nfCBmb3Ige2luZGV4fS4gIElmIHRoZXJlIGlzCgkJbm8gc3VjaCBlbnRyeSwgYW4gZW1wdHkgU3RyaW5nIGlzIHJldHVybmVkLiAgV2hlbiB7aW5kZXh9IGlzCgkJb21pdHRlZCwgdGhlIG1vc3QgcmVjZW50IGl0ZW0gZnJvbSB0aGUgaGlzdG9yeSBpcyB1c2VkLgoKCQlFeGFtcGxlczoKCQlSZWRvIHRoZSBzZWNvbmQgbGFzdCBzZWFyY2ggZnJvbSBoaXN0b3J5LiA+CgkJCTpleGVjdXRlICcvJyAuIGhpc3RnZXQoInNlYXJjaCIsIC0yKQoKPAkJRGVmaW5lIGFuIEV4IGNvbW1hbmQgIjpIIHtudW19IiB0aGF0IHN1cHBvcnRzIHJlLWV4ZWN1dGlvbiBvZgoJCXRoZSB7bnVtfXRoIGVudHJ5IGZyb20gdGhlIG91dHB1dCBvZiB8Omhpc3Rvcnl8LiA+CgkJCTpjb21tYW5kIC1uYXJncz0xIEggZXhlY3V0ZSBoaXN0Z2V0KCJjbWQiLCAwKzxhcmdzPikKPApoaXN0bnIoe2hpc3Rvcnl9KQkJCQkJKmhpc3RucigpKgoJCVRoZSByZXN1bHQgaXMgdGhlIE51bWJlciBvZiB0aGUgY3VycmVudCBlbnRyeSBpbiB7aGlzdG9yeX0uCgkJU2VlIHxoaXN0LW5hbWVzfCBmb3IgdGhlIHBvc3NpYmxlIHZhbHVlcyBvZiB7aGlzdG9yeX0uCgkJSWYgYW4gZXJyb3Igb2NjdXJyZWQsIC0xIGlzIHJldHVybmVkLgoKCQlFeGFtcGxlOiA+CgkJCTpsZXQgaW5wX2luZGV4ID0gaGlzdG5yKCJleHByIikKPApobGV4aXN0cyh7bmFtZX0pCQkJCQkqaGxleGlzdHMoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBub24temVybyBpZiBhIGhpZ2hsaWdodCBncm91cAoJCWNhbGxlZCB7bmFtZX0gZXhpc3RzLiAgVGhpcyBpcyB3aGVuIHRoZSBncm91cCBoYXMgYmVlbgoJCWRlZmluZWQgaW4gc29tZSB3YXkuICBOb3QgbmVjZXNzYXJpbHkgd2hlbiBoaWdobGlnaHRpbmcgaGFzCgkJYmVlbiBkZWZpbmVkIGZvciBpdCwgaXQgbWF5IGFsc28gaGF2ZSBiZWVuIHVzZWQgZm9yIGEgc3ludGF4CgkJaXRlbS4KCQkJCQkJCSpoaWdobGlnaHRfZXhpc3RzKCkqCgkJT2Jzb2xldGUgbmFtZTogaGlnaGxpZ2h0X2V4aXN0cygpLgoKCQkJCQkJCSpobElEKCkqCmhsSUQoe25hbWV9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgSUQgb2YgdGhlIGhpZ2hsaWdodCBncm91cAoJCXdpdGggbmFtZSB7bmFtZX0uICBXaGVuIHRoZSBoaWdobGlnaHQgZ3JvdXAgZG9lc24ndCBleGlzdCwKCQl6ZXJvIGlzIHJldHVybmVkLgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gcmV0cmlldmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIGhpZ2hsaWdodAoJCWdyb3VwLglGb3IgZXhhbXBsZSwgdG8gZ2V0IHRoZSBiYWNrZ3JvdW5kIGNvbG9yIG9mIHRoZQoJCSJDb21tZW50IiBncm91cDogPgoJOmVjaG8gc3luSURhdHRyKHN5bklEdHJhbnMoaGxJRCgiQ29tbWVudCIpKSwgImJnIikKPAkJCQkJCQkqaGlnaGxpZ2h0SUQoKSoKCQlPYnNvbGV0ZSBuYW1lOiBoaWdobGlnaHRJRCgpLgoKaG9zdG5hbWUoKQkJCQkJCSpob3N0bmFtZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSBuYW1lIG9mIHRoZSBtYWNoaW5lIG9uCgkJd2hpY2ggVmltIGlzIGN1cnJlbnRseSBydW5uaW5nLiAgTWFjaGluZSBuYW1lcyBncmVhdGVyIHRoYW4KCQkyNTYgY2hhcmFjdGVycyBsb25nIGFyZSB0cnVuY2F0ZWQuCgppY29udih7ZXhwcn0sIHtmcm9tfSwge3RvfSkJCQkJKmljb252KCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIHRleHQge2V4cHJ9IGNvbnZlcnRlZAoJCWZyb20gZW5jb2Rpbmcge2Zyb219IHRvIGVuY29kaW5nIHt0b30uCgkJV2hlbiB0aGUgY29udmVyc2lvbiBjb21wbGV0ZWx5IGZhaWxzIGFuIGVtcHR5IHN0cmluZyBpcwoJCXJldHVybmVkLiAgV2hlbiBzb21lIGNoYXJhY3RlcnMgY291bGQgbm90IGJlIGNvbnZlcnRlZCB0aGV5CgkJYXJlIHJlcGxhY2VkIHdpdGggIj8iLgoJCVRoZSBlbmNvZGluZyBuYW1lcyBhcmUgd2hhdGV2ZXIgdGhlIGljb252KCkgbGlicmFyeSBmdW5jdGlvbgoJCWNhbiBhY2NlcHQsIHNlZSAiOiFtYW4gMyBpY29udiIuCgkJTW9zdCBjb252ZXJzaW9ucyByZXF1aXJlIFZpbSB0byBiZSBjb21waWxlZCB3aXRoIHRoZSB8K2ljb252fAoJCWZlYXR1cmUuICBPdGhlcndpc2Ugb25seSBVVEYtOCB0byBsYXRpbjEgY29udmVyc2lvbiBhbmQgYmFjawoJCWNhbiBiZSBkb25lLgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gZGlzcGxheSBtZXNzYWdlcyB3aXRoIHNwZWNpYWwgY2hhcmFjdGVycywKCQlubyBtYXR0ZXIgd2hhdCAnZW5jb2RpbmcnIGlzIHNldCB0by4gIFdyaXRlIHRoZSBtZXNzYWdlIGluCgkJVVRGLTggYW5kIHVzZTogPgoJCQllY2hvIGljb252KHV0Zjhfc3RyLCAidXRmLTgiLCAmZW5jKQo8CQlOb3RlIHRoYXQgVmltIHVzZXMgVVRGLTggZm9yIGFsbCBVbmljb2RlIGVuY29kaW5ncywgY29udmVyc2lvbgoJCWZyb20vdG8gVUNTLTIgaXMgYXV0b21hdGljYWxseSBjaGFuZ2VkIHRvIHVzZSBVVEYtOC4gIFlvdQoJCWNhbm5vdCB1c2UgVUNTLTIgaW4gYSBzdHJpbmcgYW55d2F5LCBiZWNhdXNlIG9mIHRoZSBOVUwgYnl0ZXMuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCttdWx0aV9ieXRlfCBmZWF0dXJlfQoKCQkJCQkJCSppbmRlbnQoKSoKaW5kZW50KHtsbnVtfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgaW5kZW50IG9mIGxpbmUge2xudW19IGluIHRoZQoJCWN1cnJlbnQgYnVmZmVyLiAgVGhlIGluZGVudCBpcyBjb3VudGVkIGluIHNwYWNlcywgdGhlIHZhbHVlCgkJb2YgJ3RhYnN0b3AnIGlzIHJlbGV2YW50LiAge2xudW19IGlzIHVzZWQganVzdCBsaWtlIGluCgkJfGdldGxpbmUoKXwuCgkJV2hlbiB7bG51bX0gaXMgaW52YWxpZCAtMSBpcyByZXR1cm5lZC4KCgppbmRleCh7bGlzdH0sIHtleHByfSBbLCB7c3RhcnR9IFssIHtpY31dXSkJCQkqaW5kZXgoKSoKCQlSZXR1cm4gdGhlIGxvd2VzdCBpbmRleCBpbiB8TGlzdHwge2xpc3R9IHdoZXJlIHRoZSBpdGVtIGhhcyBhCgkJdmFsdWUgZXF1YWwgdG8ge2V4cHJ9LiAgVGhlcmUgaXMgbm8gYXV0b21hdGljIGNvbnZlcnNpb24sIHNvCgkJdGhlIFN0cmluZyAiNCIgaXMgZGlmZmVyZW50IGZyb20gdGhlIE51bWJlciA0LiAgQW5kIHRoZSBudW1iZXIKCQk0IGlzIGRpZmZlcmVudCBmcm9tIHRoZSBGbG9hdCA0LjAuICBUaGUgdmFsdWUgb2YgJ2lnbm9yZWNhc2UnCgkJaXMgbm90IHVzZWQgaGVyZSwgY2FzZSBhbHdheXMgbWF0dGVycy4KCQlJZiB7c3RhcnR9IGlzIGdpdmVuIHRoZW4gc3RhcnQgbG9va2luZyBhdCB0aGUgaXRlbSB3aXRoIGluZGV4CgkJe3N0YXJ0fSAobWF5IGJlIG5lZ2F0aXZlIGZvciBhbiBpdGVtIHJlbGF0aXZlIHRvIHRoZSBlbmQpLgoJCVdoZW4ge2ljfSBpcyBnaXZlbiBhbmQgaXQgaXMgbm9uLXplcm8sIGlnbm9yZSBjYXNlLiAgT3RoZXJ3aXNlCgkJY2FzZSBtdXN0IG1hdGNoLgoJCS0xIGlzIHJldHVybmVkIHdoZW4ge2V4cHJ9IGlzIG5vdCBmb3VuZCBpbiB7bGlzdH0uCgkJRXhhbXBsZTogPgoJCQk6bGV0IGlkeCA9IGluZGV4KHdvcmRzLCAidGhlIikKCQkJOmlmIGluZGV4KG51bWJlcnMsIDEyMykgPj0gMAoKCmlucHV0KHtwcm9tcHR9IFssIHt0ZXh0fSBbLCB7Y29tcGxldGlvbn1dXSkJCSppbnB1dCgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHdoYXRldmVyIHRoZSB1c2VyIHR5cGVkIG9uCgkJdGhlIGNvbW1hbmQtbGluZS4gIFRoZSB7cHJvbXB0fSBhcmd1bWVudCBpcyBlaXRoZXIgYSBwcm9tcHQKCQlzdHJpbmcsIG9yIGEgYmxhbmsgc3RyaW5nIChmb3Igbm8gcHJvbXB0KS4gIEEgJ1xuJyBjYW4gYmUgdXNlZAoJCWluIHRoZSBwcm9tcHQgdG8gc3RhcnQgYSBuZXcgbGluZS4KCQlUaGUgaGlnaGxpZ2h0aW5nIHNldCB3aXRoIHw6ZWNob2hsfCBpcyB1c2VkIGZvciB0aGUgcHJvbXB0LgoJCVRoZSBpbnB1dCBpcyBlbnRlcmVkIGp1c3QgbGlrZSBhIGNvbW1hbmQtbGluZSwgd2l0aCB0aGUgc2FtZQoJCWVkaXRpbmcgY29tbWFuZHMgYW5kIG1hcHBpbmdzLglUaGVyZSBpcyBhIHNlcGFyYXRlIGhpc3RvcnkKCQlmb3IgbGluZXMgdHlwZWQgZm9yIGlucHV0KCkuCgkJRXhhbXBsZTogPgoJCQk6aWYgaW5wdXQoIkNvZmZlZSBvciBiZWVyPyAiKSA9PSAiYmVlciIKCQkJOiAgZWNobyAiQ2hlZXJzISIKCQkJOmVuZGlmCjwKCQlJZiB0aGUgb3B0aW9uYWwge3RleHR9IGFyZ3VtZW50IGlzIHByZXNlbnQgYW5kIG5vdCBlbXB0eSwgdGhpcwoJCWlzIHVzZWQgZm9yIHRoZSBkZWZhdWx0IHJlcGx5LCBhcyBpZiB0aGUgdXNlciB0eXBlZCB0aGlzLgoJCUV4YW1wbGU6ID4KCQkJOmxldCBjb2xvciA9IGlucHV0KCJDb2xvcj8gIiwgIndoaXRlIikKCjwJCVRoZSBvcHRpb25hbCB7Y29tcGxldGlvbn0gYXJndW1lbnQgc3BlY2lmaWVzIHRoZSB0eXBlIG9mCgkJY29tcGxldGlvbiBzdXBwb3J0ZWQgZm9yIHRoZSBpbnB1dC4gIFdpdGhvdXQgaXQgY29tcGxldGlvbiBpcwoJCW5vdCBwZXJmb3JtZWQuCVRoZSBzdXBwb3J0ZWQgY29tcGxldGlvbiB0eXBlcyBhcmUgdGhlIHNhbWUgYXMKCQl0aGF0IGNhbiBiZSBzdXBwbGllZCB0byBhIHVzZXItZGVmaW5lZCBjb21tYW5kIHVzaW5nIHRoZQoJCSItY29tcGxldGU9IiBhcmd1bWVudC4JUmVmZXIgdG8gfDpjb21tYW5kLWNvbXBsZXRpb258IGZvcgoJCW1vcmUgaW5mb3JtYXRpb24uICBFeGFtcGxlOiA+CgkJCWxldCBmbmFtZSA9IGlucHV0KCJGaWxlOiAiLCAiIiwgImZpbGUiKQo8CgkJTk9URTogVGhpcyBmdW5jdGlvbiBtdXN0IG5vdCBiZSB1c2VkIGluIGEgc3RhcnR1cCBmaWxlLCBmb3IKCQl0aGUgdmVyc2lvbnMgdGhhdCBvbmx5IHJ1biBpbiBHVUkgbW9kZSAoZS5nLiwgdGhlIFdpbjMyIEdVSSkuCgkJTm90ZTogV2hlbiBpbnB1dCgpIGlzIGNhbGxlZCBmcm9tIHdpdGhpbiBhIG1hcHBpbmcgaXQgd2lsbAoJCWNvbnN1bWUgcmVtYWluaW5nIGNoYXJhY3RlcnMgZnJvbSB0aGF0IG1hcHBpbmcsIGJlY2F1c2UgYQoJCW1hcHBpbmcgaXMgaGFuZGxlZCBsaWtlIHRoZSBjaGFyYWN0ZXJzIHdlcmUgdHlwZWQuCgkJVXNlIHxpbnB1dHNhdmUoKXwgYmVmb3JlIGlucHV0KCkgYW5kIHxpbnB1dHJlc3RvcmUoKXwKCQlhZnRlciBpbnB1dCgpIHRvIGF2b2lkIHRoYXQuICBBbm90aGVyIHNvbHV0aW9uIGlzIHRvIGF2b2lkCgkJdGhhdCBmdXJ0aGVyIGNoYXJhY3RlcnMgZm9sbG93IGluIHRoZSBtYXBwaW5nLCBlLmcuLCBieSB1c2luZwoJCXw6ZXhlY3V0ZXwgb3IgfDpub3JtYWx8LgoKCQlFeGFtcGxlIHdpdGggYSBtYXBwaW5nOiA+CgkJCTpubWFwIFx4IDpjYWxsIEdldEZvbygpPENSPjpleGUgIi8iIC4gRm9vPENSPgoJCQk6ZnVuY3Rpb24gR2V0Rm9vKCkKCQkJOiAgY2FsbCBpbnB1dHNhdmUoKQoJCQk6ICBsZXQgZzpGb28gPSBpbnB1dCgiZW50ZXIgc2VhcmNoIHBhdHRlcm46ICIpCgkJCTogIGNhbGwgaW5wdXRyZXN0b3JlKCkKCQkJOmVuZGZ1bmN0aW9uCgppbnB1dGRpYWxvZyh7cHJvbXB0fSBbLCB7dGV4dH0gWywge2NhbmNlbHJldHVybn1dXSkJCSppbnB1dGRpYWxvZygpKgoJCUxpa2UgfGlucHV0KCl8LCBidXQgd2hlbiB0aGUgR1VJIGlzIHJ1bm5pbmcgYW5kIHRleHQgZGlhbG9ncwoJCWFyZSBzdXBwb3J0ZWQsIGEgZGlhbG9nIHdpbmRvdyBwb3BzIHVwIHRvIGlucHV0IHRoZSB0ZXh0LgoJCUV4YW1wbGU6ID4KCQkJOmxldCBuID0gaW5wdXRkaWFsb2coInZhbHVlIGZvciBzaGlmdHdpZHRoIiwgJnN3KQoJCQk6aWYgbiAhPSAiIgoJCQk6ICBsZXQgJnN3ID0gbgoJCQk6ZW5kaWYKPAkJV2hlbiB0aGUgZGlhbG9nIGlzIGNhbmNlbGxlZCB7Y2FuY2VscmV0dXJufSBpcyByZXR1cm5lZC4gIFdoZW4KCQlvbWl0dGVkIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCQlIaXR0aW5nIDxFbnRlcj4gd29ya3MgbGlrZSBwcmVzc2luZyB0aGUgT0sgYnV0dG9uLiAgSGl0dGluZwoJCTxFc2M+IHdvcmtzIGxpa2UgcHJlc3NpbmcgdGhlIENhbmNlbCBidXR0b24uCgkJTk9URTogQ29tbWFuZC1saW5lIGNvbXBsZXRpb24gaXMgbm90IHN1cHBvcnRlZC4KCmlucHV0bGlzdCh7dGV4dGxpc3R9KQkJCQkJKmlucHV0bGlzdCgpKgoJCXt0ZXh0bGlzdH0gbXVzdCBiZSBhIHxMaXN0fCBvZiBzdHJpbmdzLiAgVGhpcyB8TGlzdHwgaXMKCQlkaXNwbGF5ZWQsIG9uZSBzdHJpbmcgcGVyIGxpbmUuICBUaGUgdXNlciB3aWxsIGJlIHByb21wdGVkIHRvCgkJZW50ZXIgYSBudW1iZXIsIHdoaWNoIGlzIHJldHVybmVkLgoJCVRoZSB1c2VyIGNhbiBhbHNvIHNlbGVjdCBhbiBpdGVtIGJ5IGNsaWNraW5nIG9uIGl0IHdpdGggdGhlCgkJbW91c2UuCUZvciB0aGUgZmlyc3Qgc3RyaW5nIDAgaXMgcmV0dXJuZWQuICBXaGVuIGNsaWNraW5nCgkJYWJvdmUgdGhlIGZpcnN0IGl0ZW0gYSBuZWdhdGl2ZSBudW1iZXIgaXMgcmV0dXJuZWQuICBXaGVuCgkJY2xpY2tpbmcgb24gdGhlIHByb21wdCBvbmUgbW9yZSB0aGFuIHRoZSBsZW5ndGggb2Yge3RleHRsaXN0fQoJCWlzIHJldHVybmVkLgoJCU1ha2Ugc3VyZSB7dGV4dGxpc3R9IGhhcyBsZXNzIHRoYW4gJ2xpbmVzJyBlbnRyaWVzLCBvdGhlcndpc2UKCQlpdCB3b24ndCB3b3JrLglJdCdzIGEgZ29vZCBpZGVhIHRvIHB1dCB0aGUgZW50cnkgbnVtYmVyIGF0CgkJdGhlIHN0YXJ0IG9mIHRoZSBzdHJpbmcuICBBbmQgcHV0IGEgcHJvbXB0IGluIHRoZSBmaXJzdCBpdGVtLgoJCUV4YW1wbGU6ID4KCQkJbGV0IGNvbG9yID0gaW5wdXRsaXN0KFsnU2VsZWN0IGNvbG9yOicsICcxLiByZWQnLAoJCQkJXCAnMi4gZ3JlZW4nLCAnMy4gYmx1ZSddKQoKaW5wdXRyZXN0b3JlKCkJCQkJCQkqaW5wdXRyZXN0b3JlKCkqCgkJUmVzdG9yZSB0eXBlYWhlYWQgdGhhdCB3YXMgc2F2ZWQgd2l0aCBhIHByZXZpb3VzIHxpbnB1dHNhdmUoKXwuCgkJU2hvdWxkIGJlIGNhbGxlZCB0aGUgc2FtZSBudW1iZXIgb2YgdGltZXMgaW5wdXRzYXZlKCkgaXMKCQljYWxsZWQuICBDYWxsaW5nIGl0IG1vcmUgb2Z0ZW4gaXMgaGFybWxlc3MgdGhvdWdoLgoJCVJldHVybnMgMSB3aGVuIHRoZXJlIGlzIG5vdGhpbmcgdG8gcmVzdG9yZSwgMCBvdGhlcndpc2UuCgppbnB1dHNhdmUoKQkJCQkJCSppbnB1dHNhdmUoKSoKCQlQcmVzZXJ2ZSB0eXBlYWhlYWQgKGFsc28gZnJvbSBtYXBwaW5ncykgYW5kIGNsZWFyIGl0LCBzbyB0aGF0CgkJYSBmb2xsb3dpbmcgcHJvbXB0IGdldHMgaW5wdXQgZnJvbSB0aGUgdXNlci4gIFNob3VsZCBiZQoJCWZvbGxvd2VkIGJ5IGEgbWF0Y2hpbmcgaW5wdXRyZXN0b3JlKCkgYWZ0ZXIgdGhlIHByb21wdC4gIENhbgoJCWJlIHVzZWQgc2V2ZXJhbCB0aW1lcywgaW4gd2hpY2ggY2FzZSB0aGVyZSBtdXN0IGJlIGp1c3QgYXMKCQltYW55IGlucHV0cmVzdG9yZSgpIGNhbGxzLgoJCVJldHVybnMgMSB3aGVuIG91dCBvZiBtZW1vcnksIDAgb3RoZXJ3aXNlLgoKaW5wdXRzZWNyZXQoe3Byb21wdH0gWywge3RleHR9XSkJCQkqaW5wdXRzZWNyZXQoKSoKCQlUaGlzIGZ1bmN0aW9uIGFjdHMgbXVjaCBsaWtlIHRoZSB8aW5wdXQoKXwgZnVuY3Rpb24gd2l0aCBidXQKCQl0d28gZXhjZXB0aW9uczoKCQlhKSB0aGUgdXNlcidzIHJlc3BvbnNlIHdpbGwgYmUgZGlzcGxheWVkIGFzIGEgc2VxdWVuY2Ugb2YKCQlhc3Rlcmlza3MgKCIqIikgdGhlcmVieSBrZWVwaW5nIHRoZSBlbnRyeSBzZWNyZXQsIGFuZAoJCWIpIHRoZSB1c2VyJ3MgcmVzcG9uc2Ugd2lsbCBub3QgYmUgcmVjb3JkZWQgb24gdGhlIGlucHV0CgkJfGhpc3Rvcnl8IHN0YWNrLgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHdoYXRldmVyIHRoZSB1c2VyIGFjdHVhbGx5CgkJdHlwZWQgb24gdGhlIGNvbW1hbmQtbGluZSBpbiByZXNwb25zZSB0byB0aGUgaXNzdWVkIHByb21wdC4KCQlOT1RFOiBDb21tYW5kLWxpbmUgY29tcGxldGlvbiBpcyBub3Qgc3VwcG9ydGVkLgoKaW5zZXJ0KHtsaXN0fSwge2l0ZW19IFssIHtpZHh9XSkJCQkqaW5zZXJ0KCkqCgkJSW5zZXJ0IHtpdGVtfSBhdCB0aGUgc3RhcnQgb2YgfExpc3R8IHtsaXN0fS4KCQlJZiB7aWR4fSBpcyBzcGVjaWZpZWQgaW5zZXJ0IHtpdGVtfSBiZWZvcmUgdGhlIGl0ZW0gd2l0aCBpbmRleAoJCXtpZHh9LglJZiB7aWR4fSBpcyB6ZXJvIGl0IGdvZXMgYmVmb3JlIHRoZSBmaXJzdCBpdGVtLCBqdXN0CgkJbGlrZSBvbWl0dGluZyB7aWR4fS4gIEEgbmVnYXRpdmUge2lkeH0gaXMgYWxzbyBwb3NzaWJsZSwgc2VlCgkJfGxpc3QtaW5kZXh8LiAgLTEgaW5zZXJ0cyBqdXN0IGJlZm9yZSB0aGUgbGFzdCBpdGVtLgoJCVJldHVybnMgdGhlIHJlc3VsdGluZyB8TGlzdHwuICBFeGFtcGxlczogPgoJCQk6bGV0IG15bGlzdCA9IGluc2VydChbMiwgMywgNV0sIDEpCgkJCTpjYWxsIGluc2VydChteWxpc3QsIDQsIC0xKQoJCQk6Y2FsbCBpbnNlcnQobXlsaXN0LCA2LCBsZW4obXlsaXN0KSkKPAkJVGhlIGxhc3QgZXhhbXBsZSBjYW4gYmUgZG9uZSBzaW1wbGVyIHdpdGggfGFkZCgpfC4KCQlOb3RlIHRoYXQgd2hlbiB7aXRlbX0gaXMgYSB8TGlzdHwgaXQgaXMgaW5zZXJ0ZWQgYXMgYSBzaW5nbGUKCQlpdGVtLiAgVXNlIHxleHRlbmQoKXwgdG8gY29uY2F0ZW5hdGUgfExpc3RzfC4KCmludmVydCh7ZXhwcn0pCQkJCQkJKmludmVydCgpKgoJCUJpdHdpc2UgaW52ZXJ0LiAgVGhlIGFyZ3VtZW50IGlzIGNvbnZlcnRlZCB0byBhIG51bWJlci4gIEEKCQlMaXN0LCBEaWN0IG9yIEZsb2F0IGFyZ3VtZW50IGNhdXNlcyBhbiBlcnJvci4gIEV4YW1wbGU6ID4KCQkJOmxldCBiaXRzID0gaW52ZXJ0KGJpdHMpCgppc2RpcmVjdG9yeSh7ZGlyZWN0b3J5fSkJCQkJKmlzZGlyZWN0b3J5KCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gd2hlbiBhIGRpcmVjdG9yeQoJCXdpdGggdGhlIG5hbWUge2RpcmVjdG9yeX0gZXhpc3RzLiAgSWYge2RpcmVjdG9yeX0gZG9lc24ndAoJCWV4aXN0LCBvciBpc24ndCBhIGRpcmVjdG9yeSwgdGhlIHJlc3VsdCBpcyBGQUxTRS4gIHtkaXJlY3Rvcnl9CgkJaXMgYW55IGV4cHJlc3Npb24sIHdoaWNoIGlzIHVzZWQgYXMgYSBTdHJpbmcuCgppc2xvY2tlZCh7ZXhwcn0pCQkJCQkqaXNsb2NrZWQoKSogKkU3ODYqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gd2hlbiB7ZXhwcn0gaXMgdGhlCgkJbmFtZSBvZiBhIGxvY2tlZCB2YXJpYWJsZS4KCQl7ZXhwcn0gbXVzdCBiZSB0aGUgbmFtZSBvZiBhIHZhcmlhYmxlLCB8TGlzdHwgaXRlbSBvcgoJCXxEaWN0aW9uYXJ5fCBlbnRyeSwgbm90IHRoZSB2YXJpYWJsZSBpdHNlbGYhICBFeGFtcGxlOiA+CgkJCTpsZXQgYWxpc3QgPSBbMCwgWydhJywgJ2InXSwgMiwgM10KCQkJOmxvY2t2YXIgMSBhbGlzdAoJCQk6ZWNobyBpc2xvY2tlZCgnYWxpc3QnKQkJIiAxCgkJCTplY2hvIGlzbG9ja2VkKCdhbGlzdFsxXScpCSIgMAoKPAkJV2hlbiB7ZXhwcn0gaXMgYSB2YXJpYWJsZSB0aGF0IGRvZXMgbm90IGV4aXN0IHlvdSBnZXQgYW4gZXJyb3IKCQltZXNzYWdlLiAgVXNlIHxleGlzdHMoKXwgdG8gY2hlY2sgZm9yIGV4aXN0ZW5jZS4KCml0ZW1zKHtkaWN0fSkJCQkJCQkqaXRlbXMoKSoKCQlSZXR1cm4gYSB8TGlzdHwgd2l0aCBhbGwgdGhlIGtleS12YWx1ZSBwYWlycyBvZiB7ZGljdH0uICBFYWNoCgkJfExpc3R8IGl0ZW0gaXMgYSBsaXN0IHdpdGggdHdvIGl0ZW1zOiB0aGUga2V5IG9mIGEge2RpY3R9CgkJZW50cnkgYW5kIHRoZSB2YWx1ZSBvZiB0aGlzIGVudHJ5LiAgVGhlIHxMaXN0fCBpcyBpbiBhcmJpdHJhcnkKCQlvcmRlci4KCgpqb2luKHtsaXN0fSBbLCB7c2VwfV0pCQkJCQkqam9pbigpKgoJCUpvaW4gdGhlIGl0ZW1zIGluIHtsaXN0fSB0b2dldGhlciBpbnRvIG9uZSBTdHJpbmcuCgkJV2hlbiB7c2VwfSBpcyBzcGVjaWZpZWQgaXQgaXMgcHV0IGluIGJldHdlZW4gdGhlIGl0ZW1zLiAgSWYKCQl7c2VwfSBpcyBvbWl0dGVkIGEgc2luZ2xlIHNwYWNlIGlzIHVzZWQuCgkJTm90ZSB0aGF0IHtzZXB9IGlzIG5vdCBhZGRlZCBhdCB0aGUgZW5kLiAgWW91IG1pZ2h0IHdhbnQgdG8KCQlhZGQgaXQgdGhlcmUgdG9vOiA+CgkJCWxldCBsaW5lcyA9IGpvaW4obXlsaXN0LCAiXG4iKSAuICJcbiIKPAkJU3RyaW5nIGl0ZW1zIGFyZSB1c2VkIGFzLWlzLiAgfExpc3RzfCBhbmQgfERpY3Rpb25hcmllc3wgYXJlCgkJY29udmVydGVkIGludG8gYSBzdHJpbmcgbGlrZSB3aXRoIHxzdHJpbmcoKXwuCgkJVGhlIG9wcG9zaXRlIGZ1bmN0aW9uIGlzIHxzcGxpdCgpfC4KCmtleXMoe2RpY3R9KQkJCQkJCSprZXlzKCkqCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggYWxsIHRoZSBrZXlzIG9mIHtkaWN0fS4gIFRoZSB8TGlzdHwgaXMgaW4KCQlhcmJpdHJhcnkgb3JkZXIuCgoJCQkJCQkJKmxlbigpKiAqRTcwMSoKbGVuKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGxlbmd0aCBvZiB0aGUgYXJndW1lbnQuCgkJV2hlbiB7ZXhwcn0gaXMgYSBTdHJpbmcgb3IgYSBOdW1iZXIgdGhlIGxlbmd0aCBpbiBieXRlcyBpcwoJCXVzZWQsIGFzIHdpdGggfHN0cmxlbigpfC4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSB8TGlzdHwgaXMKCQlyZXR1cm5lZC4KCQlXaGVuIHtleHByfSBpcyBhIHxEaWN0aW9uYXJ5fCB0aGUgbnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlCgkJfERpY3Rpb25hcnl8IGlzIHJldHVybmVkLgoJCU90aGVyd2lzZSBhbiBlcnJvciBpcyBnaXZlbi4KCgkJCQkJCSpsaWJjYWxsKCkqICpFMzY0KiAqRTM2OCoKbGliY2FsbCh7bGlibmFtZX0sIHtmdW5jbmFtZX0sIHthcmd1bWVudH0pCgkJQ2FsbCBmdW5jdGlvbiB7ZnVuY25hbWV9IGluIHRoZSBydW4tdGltZSBsaWJyYXJ5IHtsaWJuYW1lfQoJCXdpdGggc2luZ2xlIGFyZ3VtZW50IHthcmd1bWVudH0uCgkJVGhpcyBpcyB1c2VmdWwgdG8gY2FsbCBmdW5jdGlvbnMgaW4gYSBsaWJyYXJ5IHRoYXQgeW91CgkJZXNwZWNpYWxseSBtYWRlIHRvIGJlIHVzZWQgd2l0aCBWaW0uICBTaW5jZSBvbmx5IG9uZSBhcmd1bWVudAoJCWlzIHBvc3NpYmxlLCBjYWxsaW5nIHN0YW5kYXJkIGxpYnJhcnkgZnVuY3Rpb25zIGlzIHJhdGhlcgoJCWxpbWl0ZWQuCgkJVGhlIHJlc3VsdCBpcyB0aGUgU3RyaW5nIHJldHVybmVkIGJ5IHRoZSBmdW5jdGlvbi4gIElmIHRoZQoJCWZ1bmN0aW9uIHJldHVybnMgTlVMTCwgdGhpcyB3aWxsIGFwcGVhciBhcyBhbiBlbXB0eSBzdHJpbmcgIiIKCQl0byBWaW0uCgkJSWYgdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBudW1iZXIsIHVzZSBsaWJjYWxsbnIoKSEKCQlJZiB7YXJndW1lbnR9IGlzIGEgbnVtYmVyLCBpdCBpcyBwYXNzZWQgdG8gdGhlIGZ1bmN0aW9uIGFzIGFuCgkJaW50OyBpZiB7YXJndW1lbnR9IGlzIGEgc3RyaW5nLCBpdCBpcyBwYXNzZWQgYXMgYQoJCW51bGwtdGVybWluYXRlZCBzdHJpbmcuCgkJVGhpcyBmdW5jdGlvbiB3aWxsIGZhaWwgaW4gfHJlc3RyaWN0ZWQtbW9kZXwuCgoJCWxpYmNhbGwoKSBhbGxvd3MgeW91IHRvIHdyaXRlIHlvdXIgb3duICdwbHVnLWluJyBleHRlbnNpb25zIHRvCgkJVmltIHdpdGhvdXQgaGF2aW5nIHRvIHJlY29tcGlsZSB0aGUgcHJvZ3JhbS4gIEl0IGlzIE5PVCBhCgkJbWVhbnMgdG8gY2FsbCBzeXN0ZW0gZnVuY3Rpb25zISAgSWYgeW91IHRyeSB0byBkbyBzbyBWaW0gd2lsbAoJCXZlcnkgcHJvYmFibHkgY3Jhc2guCgoJCUZvciBXaW4zMiwgdGhlIGZ1bmN0aW9ucyB5b3Ugd3JpdGUgbXVzdCBiZSBwbGFjZWQgaW4gYSBETEwKCQlhbmQgdXNlIHRoZSBub3JtYWwgQyBjYWxsaW5nIGNvbnZlbnRpb24gKE5PVCBQYXNjYWwgd2hpY2ggaXMKCQl1c2VkIGluIFdpbmRvd3MgU3lzdGVtIERMTHMpLiAgVGhlIGZ1bmN0aW9uIG11c3QgdGFrZSBleGFjdGx5CgkJb25lIHBhcmFtZXRlciwgZWl0aGVyIGEgY2hhcmFjdGVyIHBvaW50ZXIgb3IgYSBsb25nIGludGVnZXIsCgkJYW5kIG11c3QgcmV0dXJuIGEgY2hhcmFjdGVyIHBvaW50ZXIgb3IgTlVMTC4gIFRoZSBjaGFyYWN0ZXIKCQlwb2ludGVyIHJldHVybmVkIG11c3QgcG9pbnQgdG8gbWVtb3J5IHRoYXQgd2lsbCByZW1haW4gdmFsaWQKCQlhZnRlciB0aGUgZnVuY3Rpb24gaGFzIHJldHVybmVkIChlLmcuIGluIHN0YXRpYyBkYXRhIGluIHRoZQoJCURMTCkuICBJZiBpdCBwb2ludHMgdG8gYWxsb2NhdGVkIG1lbW9yeSwgdGhhdCBtZW1vcnkgd2lsbAoJCWxlYWsgYXdheS4gIFVzaW5nIGEgc3RhdGljIGJ1ZmZlciBpbiB0aGUgZnVuY3Rpb24gc2hvdWxkIHdvcmssCgkJaXQncyB0aGVuIGZyZWVkIHdoZW4gdGhlIERMTCBpcyB1bmxvYWRlZC4KCgkJV0FSTklORzogSWYgdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBub24tdmFsaWQgcG9pbnRlciwgVmltIG1heQoJCWNyYXNoIQlUaGlzIGFsc28gaGFwcGVucyBpZiB0aGUgZnVuY3Rpb24gcmV0dXJucyBhIG51bWJlciwKCQliZWNhdXNlIFZpbSB0aGlua3MgaXQncyBhIHBvaW50ZXIuCgkJRm9yIFdpbjMyIHN5c3RlbXMsIHtsaWJuYW1lfSBzaG91bGQgYmUgdGhlIGZpbGVuYW1lIG9mIHRoZSBETEwKCQl3aXRob3V0IHRoZSAiLkRMTCIgc3VmZml4LiAgQSBmdWxsIHBhdGggaXMgb25seSByZXF1aXJlZCBpZgoJCXRoZSBETEwgaXMgbm90IGluIHRoZSB1c3VhbCBwbGFjZXMuCgkJRm9yIFVuaXg6IFdoZW4gY29tcGlsaW5nIHlvdXIgb3duIHBsdWdpbnMsIHJlbWVtYmVyIHRoYXQgdGhlCgkJb2JqZWN0IGNvZGUgbXVzdCBiZSBjb21waWxlZCBhcyBwb3NpdGlvbi1pbmRlcGVuZGVudCAoJ1BJQycpLgoJCXtvbmx5IGluIFdpbjMyIGFuZCBzb21lIFVuaXggdmVyc2lvbnMsIHdoZW4gdGhlIHwrbGliY2FsbHwKCQlmZWF0dXJlIGlzIHByZXNlbnR9CgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gbGliY2FsbCgibGliYy5zbyIsICJnZXRlbnYiLCAiSE9NRSIpCjwKCQkJCQkJCSpsaWJjYWxsbnIoKSoKbGliY2FsbG5yKHtsaWJuYW1lfSwge2Z1bmNuYW1lfSwge2FyZ3VtZW50fSkKCQlKdXN0IGxpa2UgfGxpYmNhbGwoKXwsIGJ1dCB1c2VkIGZvciBhIGZ1bmN0aW9uIHRoYXQgcmV0dXJucyBhbgoJCWludCBpbnN0ZWFkIG9mIGEgc3RyaW5nLgoJCXtvbmx5IGluIFdpbjMyIG9uIHNvbWUgVW5peCB2ZXJzaW9ucywgd2hlbiB0aGUgfCtsaWJjYWxsfAoJCWZlYXR1cmUgaXMgcHJlc2VudH0KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBsaWJjYWxsbnIoIi91c3IvbGliL2xpYmMuc28iLCAiZ2V0cGlkIiwgIiIpCgkJCTpjYWxsIGxpYmNhbGxucigibGliYy5zbyIsICJwcmludGYiLCAiSGVsbG8gV29ybGQhXG4iKQoJCQk6Y2FsbCBsaWJjYWxsbnIoImxpYmMuc28iLCAic2xlZXAiLCAxMCkKPAoJCQkJCQkJKmxpbmUoKSoKbGluZSh7ZXhwcn0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBsaW5lIG51bWJlciBvZiB0aGUgZmlsZQoJCXBvc2l0aW9uIGdpdmVuIHdpdGgge2V4cHJ9LiAgVGhlIGFjY2VwdGVkIHBvc2l0aW9ucyBhcmU6CgkJICAgIC4JICAgIHRoZSBjdXJzb3IgcG9zaXRpb24KCQkgICAgJAkgICAgdGhlIGxhc3QgbGluZSBpbiB0aGUgY3VycmVudCBidWZmZXIKCQkgICAgJ3gJICAgIHBvc2l0aW9uIG9mIG1hcmsgeCAoaWYgdGhlIG1hcmsgaXMgbm90IHNldCwgMCBpcwoJCQkgICAgcmV0dXJuZWQpCgkJICAgIHcwCSAgICBmaXJzdCBsaW5lIHZpc2libGUgaW4gY3VycmVudCB3aW5kb3cKCQkgICAgdyQJICAgIGxhc3QgbGluZSB2aXNpYmxlIGluIGN1cnJlbnQgd2luZG93CgkJICAgIHYJICAgIEluIFZpc3VhbCBtb2RlOiB0aGUgc3RhcnQgb2YgdGhlIFZpc3VhbCBhcmVhICh0aGUKCQkJICAgIGN1cnNvciBpcyB0aGUgZW5kKS4gIFdoZW4gbm90IGluIFZpc3VhbCBtb2RlCgkJCSAgICByZXR1cm5zIHRoZSBjdXJzb3IgcG9zaXRpb24uICBEaWZmZXJzIGZyb20gfCc8fCBpbgoJCQkgICAgdGhhdCBpdCdzIHVwZGF0ZWQgcmlnaHQgYXdheS4KCQlOb3RlIHRoYXQgYSBtYXJrIGluIGFub3RoZXIgZmlsZSBjYW4gYmUgdXNlZC4gIFRoZSBsaW5lIG51bWJlcgoJCXRoZW4gYXBwbGllcyB0byBhbm90aGVyIGJ1ZmZlci4KCQlUbyBnZXQgdGhlIGNvbHVtbiBudW1iZXIgdXNlIHxjb2woKXwuICBUbyBnZXQgYm90aCB1c2UKCQl8Z2V0cG9zKCl8LgoJCUV4YW1wbGVzOiA+CgkJCWxpbmUoIi4iKQkJbGluZSBudW1iZXIgb2YgdGhlIGN1cnNvcgoJCQlsaW5lKCIndCIpCQlsaW5lIG51bWJlciBvZiBtYXJrIHQKCQkJbGluZSgiJyIgLiBtYXJrZXIpCWxpbmUgbnVtYmVyIG9mIG1hcmsgbWFya2VyCjwJCQkJCQkJKmxhc3QtcG9zaXRpb24tanVtcCoKCQlUaGlzIGF1dG9jb21tYW5kIGp1bXBzIHRvIHRoZSBsYXN0IGtub3duIHBvc2l0aW9uIGluIGEgZmlsZQoJCWp1c3QgYWZ0ZXIgb3BlbmluZyBpdCwgaWYgdGhlICciIG1hcmsgaXMgc2V0OiA+Cgk6YXUgQnVmUmVhZFBvc3QgKiBpZiBsaW5lKCInXCIiKSA+IDEgJiYgbGluZSgiJ1wiIikgPD0gbGluZSgiJCIpIHwgZXhlICJub3JtYWwhIGdgXCIiIHwgZW5kaWYKCmxpbmUyYnl0ZSh7bG51bX0pCQkJCQkqbGluZTJieXRlKCkqCgkJUmV0dXJuIHRoZSBieXRlIGNvdW50IGZyb20gdGhlIHN0YXJ0IG9mIHRoZSBidWZmZXIgZm9yIGxpbmUKCQl7bG51bX0uICBUaGlzIGluY2x1ZGVzIHRoZSBlbmQtb2YtbGluZSBjaGFyYWN0ZXIsIGRlcGVuZGluZyBvbgoJCXRoZSAnZmlsZWZvcm1hdCcgb3B0aW9uIGZvciB0aGUgY3VycmVudCBidWZmZXIuICBUaGUgZmlyc3QKCQlsaW5lIHJldHVybnMgMS4gJ2VuY29kaW5nJyBtYXR0ZXJzLCAnZmlsZWVuY29kaW5nJyBpcyBpZ25vcmVkLgoJCVRoaXMgY2FuIGFsc28gYmUgdXNlZCB0byBnZXQgdGhlIGJ5dGUgY291bnQgZm9yIHRoZSBsaW5lIGp1c3QKCQliZWxvdyB0aGUgbGFzdCBsaW5lOiA+CgkJCWxpbmUyYnl0ZShsaW5lKCIkIikgKyAxKQo8CQlUaGlzIGlzIHRoZSBidWZmZXIgc2l6ZSBwbHVzIG9uZS4gIElmICdmaWxlZW5jb2RpbmcnIGlzIGVtcHR5CgkJaXQgaXMgdGhlIGZpbGUgc2l6ZSBwbHVzIG9uZS4KCQlXaGVuIHtsbnVtfSBpcyBpbnZhbGlkLCBvciB0aGUgfCtieXRlX29mZnNldHwgZmVhdHVyZSBoYXMgYmVlbgoJCWRpc2FibGVkIGF0IGNvbXBpbGUgdGltZSwgLTEgaXMgcmV0dXJuZWQuCgkJQWxzbyBzZWUgfGJ5dGUybGluZSgpfCwgfGdvfCBhbmQgfDpnb3RvfC4KCmxpc3BpbmRlbnQoe2xudW19KQkJCQkJKmxpc3BpbmRlbnQoKSoKCQlHZXQgdGhlIGFtb3VudCBvZiBpbmRlbnQgZm9yIGxpbmUge2xudW19IGFjY29yZGluZyB0aGUgbGlzcAoJCWluZGVudGluZyBydWxlcywgYXMgd2l0aCAnbGlzcCcuCgkJVGhlIGluZGVudCBpcyBjb3VudGVkIGluIHNwYWNlcywgdGhlIHZhbHVlIG9mICd0YWJzdG9wJyBpcwoJCXJlbGV2YW50LiAge2xudW19IGlzIHVzZWQganVzdCBsaWtlIGluIHxnZXRsaW5lKCl8LgoJCVdoZW4ge2xudW19IGlzIGludmFsaWQgb3IgVmltIHdhcyBub3QgY29tcGlsZWQgdGhlCgkJfCtsaXNwaW5kZW50fCBmZWF0dXJlLCAtMSBpcyByZXR1cm5lZC4KCmxvY2FsdGltZSgpCQkJCQkJKmxvY2FsdGltZSgpKgoJCVJldHVybiB0aGUgY3VycmVudCB0aW1lLCBtZWFzdXJlZCBhcyBzZWNvbmRzIHNpbmNlIDFzdCBKYW4KCQkxOTcwLiAgU2VlIGFsc28gfHN0cmZ0aW1lKCl8IGFuZCB8Z2V0ZnRpbWUoKXwuCgoKbG9nKHtleHByfSkJCQkJCQkqbG9nKCkqCgkJUmV0dXJuIHRoZSBuYXR1cmFsIGxvZ2FyaXRobSAoYmFzZSBlKSBvZiB7ZXhwcn0gYXMgYSB8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8IGluIHRoZSByYW5nZQoJCSgwLCBpbmZdLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGxvZygxMCkKPAkJCTIuMzAyNTg1ID4KCQkJOmVjaG8gbG9nKGV4cCg1KSkKPAkJCTUuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKbG9nMTAoe2V4cHJ9KQkJCQkJCSpsb2cxMCgpKgoJCVJldHVybiB0aGUgbG9nYXJpdGhtIG9mIEZsb2F0IHtleHByfSB0byBiYXNlIDEwIGFzIGEgfEZsb2F0fC4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBsb2cxMCgxMDAwKQo8CQkJMy4wID4KCQkJOmVjaG8gbG9nMTAoMC4wMSkKPAkJCS0yLjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoJCQptYXAoe2V4cHJ9LCB7c3RyaW5nfSkJCQkJCSptYXAoKSoKCQl7ZXhwcn0gbXVzdCBiZSBhIHxMaXN0fCBvciBhIHxEaWN0aW9uYXJ5fC4KCQlSZXBsYWNlIGVhY2ggaXRlbSBpbiB7ZXhwcn0gd2l0aCB0aGUgcmVzdWx0IG9mIGV2YWx1YXRpbmcKCQl7c3RyaW5nfS4KCQlJbnNpZGUge3N0cmluZ30gfHY6dmFsfCBoYXMgdGhlIHZhbHVlIG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRm9yIGEgfERpY3Rpb25hcnl8IHx2OmtleXwgaGFzIHRoZSBrZXkgb2YgdGhlIGN1cnJlbnQgaXRlbQoJCWFuZCBmb3IgYSB8TGlzdHwgfHY6a2V5fCBoYXMgdGhlIGluZGV4IG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRXhhbXBsZTogPgoJCQk6Y2FsbCBtYXAobXlsaXN0LCAnIj4gIiAuIHY6dmFsIC4gIiA8IicpCjwJCVRoaXMgcHV0cyAiPiAiIGJlZm9yZSBhbmQgIiA8IiBhZnRlciBlYWNoIGl0ZW0gaW4gIm15bGlzdCIuCgoJCU5vdGUgdGhhdCB7c3RyaW5nfSBpcyB0aGUgcmVzdWx0IG9mIGFuIGV4cHJlc3Npb24gYW5kIGlzIHRoZW4KCQl1c2VkIGFzIGFuIGV4cHJlc3Npb24gYWdhaW4uICBPZnRlbiBpdCBpcyBnb29kIHRvIHVzZSBhCgkJfGxpdGVyYWwtc3RyaW5nfCB0byBhdm9pZCBoYXZpbmcgdG8gZG91YmxlIGJhY2tzbGFzaGVzLiAgWW91CgkJc3RpbGwgaGF2ZSB0byBkb3VibGUgJyBxdW90ZXMKCgkJVGhlIG9wZXJhdGlvbiBpcyBkb25lIGluLXBsYWNlLiAgSWYgeW91IHdhbnQgYSB8TGlzdHwgb3IKCQl8RGljdGlvbmFyeXwgdG8gcmVtYWluIHVubW9kaWZpZWQgbWFrZSBhIGNvcHkgZmlyc3Q6ID4KCQkJOmxldCB0bGlzdCA9IG1hcChjb3B5KG15bGlzdCksICcgJiAuICJcdCInKQoKPAkJUmV0dXJucyB7ZXhwcn0sIHRoZSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IHRoYXQgd2FzIGZpbHRlcmVkLgoJCVdoZW4gYW4gZXJyb3IgaXMgZW5jb3VudGVyZWQgd2hpbGUgZXZhbHVhdGluZyB7c3RyaW5nfSBubwoJCWZ1cnRoZXIgaXRlbXMgaW4ge2V4cHJ9IGFyZSBwcm9jZXNzZWQuCgoKbWFwYXJnKHtuYW1lfVssIHttb2RlfSBbLCB7YWJicn0gWywge2RpY3R9XV1dKQkJCSptYXBhcmcoKSoKCQlXaGVuIHtkaWN0fSBpcyBvbWl0dGVkIG9yIHplcm86IFJldHVybiB0aGUgcmhzIG9mIG1hcHBpbmcKCQl7bmFtZX0gaW4gbW9kZSB7bW9kZX0uICBUaGUgcmV0dXJuZWQgU3RyaW5nIGhhcyBzcGVjaWFsCgkJY2hhcmFjdGVycyB0cmFuc2xhdGVkIGxpa2UgaW4gdGhlIG91dHB1dCBvZiB0aGUgIjptYXAiIGNvbW1hbmQKCQlsaXN0aW5nLgoJCQoJCVdoZW4gdGhlcmUgaXMgbm8gbWFwcGluZyBmb3Ige25hbWV9LCBhbiBlbXB0eSBTdHJpbmcgaXMKCQlyZXR1cm5lZC4KCgkJVGhlIHtuYW1lfSBjYW4gaGF2ZSBzcGVjaWFsIGtleSBuYW1lcywgbGlrZSBpbiB0aGUgIjptYXAiCgkJY29tbWFuZC4KCgkJe21vZGV9IGNhbiBiZSBvbmUgb2YgdGhlc2Ugc3RyaW5nczoKCQkJIm4iCU5vcm1hbAoJCQkidiIJVmlzdWFsIChpbmNsdWRpbmcgU2VsZWN0KQoJCQkibyIJT3BlcmF0b3ItcGVuZGluZwoJCQkiaSIJSW5zZXJ0CgkJCSJjIglDbWQtbGluZQoJCQkicyIJU2VsZWN0CgkJCSJ4IglWaXN1YWwKCQkJImwiCWxhbmdtYXAgfGxhbmd1YWdlLW1hcHBpbmd8CgkJCSIiCU5vcm1hbCwgVmlzdWFsIGFuZCBPcGVyYXRvci1wZW5kaW5nCgkJV2hlbiB7bW9kZX0gaXMgb21pdHRlZCwgdGhlIG1vZGVzIGZvciAiIiBhcmUgdXNlZC4KCgkJV2hlbiB7YWJicn0gaXMgdGhlcmUgYW5kIGl0IGlzIG5vbi16ZXJvIHVzZSBhYmJyZXZpYXRpb25zCgkJaW5zdGVhZCBvZiBtYXBwaW5ncy4KCgkJV2hlbiB7ZGljdH0gaXMgdGhlcmUgYW5kIGl0IGlzIG5vbi16ZXJvIHJldHVybiBhIGRpY3Rpb25hcnkKCQljb250YWluaW5nIGFsbCB0aGUgaW5mb3JtYXRpb24gb2YgdGhlIG1hcHBpbmcgd2l0aCB0aGUKCQlmb2xsb3dpbmcgaXRlbXM6CgkJICAibGhzIgkgICAgIFRoZSB7bGhzfSBvZiB0aGUgbWFwcGluZy4KCQkgICJyaHMiCSAgICAgVGhlIHtyaHN9IG9mIHRoZSBtYXBwaW5nIGFzIHR5cGVkLgoJCSAgInNpbGVudCIgICAxIGZvciBhIHw6bWFwLXNpbGVudHwgbWFwcGluZywgZWxzZSAwLgoJCSAgIm5vcmVtYXAiICAxIGlmIHRoZSB7cmhzfSBvZiB0aGUgbWFwcGluZyBpcyBub3QgcmVtYXBwYWJsZS4KCQkgICJleHByIiAgICAgMSBmb3IgYW4gZXhwcmVzc2lvbiBtYXBwaW5nICh8Om1hcC08ZXhwcj58KS4KCQkgICJidWZmZXIiICAgMSBmb3IgYSBidWZmZXIgbG9jYWwgbWFwcGluZyAofDptYXAtbG9jYWx8KS4KCQkgICJtb2RlIiAgICAgTW9kZXMgZm9yIHdoaWNoIHRoZSBtYXBwaW5nIGlzIGRlZmluZWQuIEluCgkJCSAgICAgYWRkaXRpb24gdG8gdGhlIG1vZGVzIG1lbnRpb25lZCBhYm92ZSwgdGhlc2UKCQkJICAgICBjaGFyYWN0ZXJzIHdpbGwgYmUgdXNlZDoKCQkJICAgICAiICIgICAgIE5vcm1hbCwgVmlzdWFsIGFuZCBPcGVyYXRvci1wZW5kaW5nCgkJCSAgICAgIiEiICAgICBJbnNlcnQgYW5kIENvbW1hbmRsaW5lIG1vZGUKCQkJCSAgICAgKHxtYXBtb2RlLWljfCkKCQkgICJzaWQiCSAgICAgVGhlIHNjcmlwdCBsb2NhbCBJRCwgdXNlZCBmb3IgPHNpZD4gbWFwcGluZ3MKCQkJICAgICAofDxTSUQ+fCkuCgoJCVRoZSBtYXBwaW5ncyBsb2NhbCB0byB0aGUgY3VycmVudCBidWZmZXIgYXJlIGNoZWNrZWQgZmlyc3QsCgkJdGhlbiB0aGUgZ2xvYmFsIG1hcHBpbmdzLgoJCVRoaXMgZnVuY3Rpb24gY2FuIGJlIHVzZWQgdG8gbWFwIGEga2V5IGV2ZW4gd2hlbiBpdCdzIGFscmVhZHkKCQltYXBwZWQsIGFuZCBoYXZlIGl0IGRvIHRoZSBvcmlnaW5hbCBtYXBwaW5nIHRvby4gIFNrZXRjaDogPgoJCQlleGUgJ25ub3JlbWFwIDxUYWI+ID09JyAuIG1hcGFyZygnPFRhYj4nLCAnbicpCgoKbWFwY2hlY2soe25hbWV9Wywge21vZGV9IFssIHthYmJyfV1dKQkJCSptYXBjaGVjaygpKgoJCUNoZWNrIGlmIHRoZXJlIGlzIGEgbWFwcGluZyB0aGF0IG1hdGNoZXMgd2l0aCB7bmFtZX0gaW4gbW9kZQoJCXttb2RlfS4gIFNlZSB8bWFwYXJnKCl8IGZvciB7bW9kZX0gYW5kIHNwZWNpYWwgbmFtZXMgaW4KCQl7bmFtZX0uCgkJV2hlbiB7YWJicn0gaXMgdGhlcmUgYW5kIGl0IGlzIG5vbi16ZXJvIHVzZSBhYmJyZXZpYXRpb25zCgkJaW5zdGVhZCBvZiBtYXBwaW5ncy4KCQlBIG1hdGNoIGhhcHBlbnMgd2l0aCBhIG1hcHBpbmcgdGhhdCBzdGFydHMgd2l0aCB7bmFtZX0gYW5kCgkJd2l0aCBhIG1hcHBpbmcgd2hpY2ggaXMgZXF1YWwgdG8gdGhlIHN0YXJ0IG9mIHtuYW1lfS4KCgkJCW1hdGNoZXMgbWFwcGluZyAiYSIJImFiIgkiYWJjIiB+CgkJICAgbWFwY2hlY2soImEiKQl5ZXMJeWVzCSB5ZXMKCQkgICBtYXBjaGVjaygiYWJjIikJeWVzCXllcwkgeWVzCgkJICAgbWFwY2hlY2soImF4IikJeWVzCW5vCSBubwoJCSAgIG1hcGNoZWNrKCJiIikJbm8Jbm8JIG5vCgoJCVRoZSBkaWZmZXJlbmNlIHdpdGggbWFwYXJnKCkgaXMgdGhhdCBtYXBjaGVjaygpIGZpbmRzIGEKCQltYXBwaW5nIHRoYXQgbWF0Y2hlcyB3aXRoIHtuYW1lfSwgd2hpbGUgbWFwYXJnKCkgb25seSBmaW5kcyBhCgkJbWFwcGluZyBmb3Ige25hbWV9IGV4YWN0bHkuCgkJV2hlbiB0aGVyZSBpcyBubyBtYXBwaW5nIHRoYXQgc3RhcnRzIHdpdGgge25hbWV9LCBhbiBlbXB0eQoJCVN0cmluZyBpcyByZXR1cm5lZC4gIElmIHRoZXJlIGlzIG9uZSwgdGhlIHJocyBvZiB0aGF0IG1hcHBpbmcKCQlpcyByZXR1cm5lZC4gIElmIHRoZXJlIGFyZSBzZXZlcmFsIG1hcHBpbmdzIHRoYXQgc3RhcnQgd2l0aAoJCXtuYW1lfSwgdGhlIHJocyBvZiBvbmUgb2YgdGhlbSBpcyByZXR1cm5lZC4KCQlUaGUgbWFwcGluZ3MgbG9jYWwgdG8gdGhlIGN1cnJlbnQgYnVmZmVyIGFyZSBjaGVja2VkIGZpcnN0LAoJCXRoZW4gdGhlIGdsb2JhbCBtYXBwaW5ncy4KCQlUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIHRvIGNoZWNrIGlmIGEgbWFwcGluZyBjYW4gYmUgYWRkZWQKCQl3aXRob3V0IGJlaW5nIGFtYmlndW91cy4gIEV4YW1wbGU6ID4KCTppZiBtYXBjaGVjaygiX3Z2IikgPT0gIiIKCTogICBtYXAgX3Z2IDpzZXQgZ3VpZm9udD03eDEzPENSPgoJOmVuZGlmCjwJCVRoaXMgYXZvaWRzIGFkZGluZyB0aGUgIl92diIgbWFwcGluZyB3aGVuIHRoZXJlIGFscmVhZHkgaXMgYQoJCW1hcHBpbmcgZm9yICJfdiIgb3IgZm9yICJfdnZ2Ii4KCm1hdGNoKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQkJCSptYXRjaCgpKgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IHRoZW4gdGhpcyByZXR1cm5zIHRoZSBpbmRleCBvZiB0aGUKCQlmaXJzdCBpdGVtIHdoZXJlIHtwYXR9IG1hdGNoZXMuICBFYWNoIGl0ZW0gaXMgdXNlZCBhcyBhCgkJU3RyaW5nLCB8TGlzdHN8IGFuZCB8RGljdGlvbmFyaWVzfCBhcmUgdXNlZCBhcyBlY2hvZWQuCgkJT3RoZXJ3aXNlLCB7ZXhwcn0gaXMgdXNlZCBhcyBhIFN0cmluZy4JVGhlIHJlc3VsdCBpcyBhCgkJTnVtYmVyLCB3aGljaCBnaXZlcyB0aGUgaW5kZXggKGJ5dGUgb2Zmc2V0KSBpbiB7ZXhwcn0gd2hlcmUKCQl7cGF0fSBtYXRjaGVzLgoJCUEgbWF0Y2ggYXQgdGhlIGZpcnN0IGNoYXJhY3RlciBvciB8TGlzdHwgaXRlbSByZXR1cm5zIHplcm8uCgkJSWYgdGhlcmUgaXMgbm8gbWF0Y2ggLTEgaXMgcmV0dXJuZWQuCgkJRm9yIGdldHRpbmcgc3VibWF0Y2hlcyBzZWUgfG1hdGNobGlzdCgpfC4KCQlFeGFtcGxlOiA+CgkJCTplY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgImluZyIpCSIgcmVzdWx0cyBpbiA0CgkJCTplY2hvIG1hdGNoKFsxLCAneCddLCAnXGEnKQkiIHJlc3VsdHMgaW4gMQo8CQlTZWUgfHN0cmluZy1tYXRjaHwgZm9yIGhvdyB7cGF0fSBpcyB1c2VkLgoJCQkJCQkJCSpzdHJwYnJrKCkqCgkJVmltIGRvZXNuJ3QgaGF2ZSBhIHN0cnBicmsoKSBmdW5jdGlvbi4JQnV0IHlvdSBjYW4gZG86ID4KCQkJOmxldCBzZXBpZHggPSBtYXRjaChsaW5lLCAnWy4sOzogXHRdJykKPAkJCQkJCQkJKnN0cmNhc2VzdHIoKSoKCQlWaW0gZG9lc24ndCBoYXZlIGEgc3RyY2FzZXN0cigpIGZ1bmN0aW9uLiAgQnV0IHlvdSBjYW4gYWRkCgkJIlxjIiB0byB0aGUgcGF0dGVybiB0byBpZ25vcmUgY2FzZTogPgoJCQk6bGV0IGlkeCA9IG1hdGNoKGhheXN0YWNrLCAnXGNuZWVkbGUnKQo8CgkJSWYge3N0YXJ0fSBpcyBnaXZlbiwgdGhlIHNlYXJjaCBzdGFydHMgZnJvbSBieXRlIGluZGV4CgkJe3N0YXJ0fSBpbiBhIFN0cmluZyBvciBpdGVtIHtzdGFydH0gaW4gYSB8TGlzdHwuCgkJVGhlIHJlc3VsdCwgaG93ZXZlciwgaXMgc3RpbGwgdGhlIGluZGV4IGNvdW50ZWQgZnJvbSB0aGUKCQlmaXJzdCBjaGFyYWN0ZXIvaXRlbS4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gbWF0Y2goInRlc3RpbmciLCAiaW5nIiwgMikKPAkJcmVzdWx0IGlzIGFnYWluICI0Ii4gPgoJCQk6ZWNobyBtYXRjaCgidGVzdGluZyIsICJpbmciLCA0KQo8CQlyZXN1bHQgaXMgYWdhaW4gIjQiLiA+CgkJCTplY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgInQiLCAyKQo8CQlyZXN1bHQgaXMgIjMiLgoJCUZvciBhIFN0cmluZywgaWYge3N0YXJ0fSA+IDAgdGhlbiBpdCBpcyBsaWtlIHRoZSBzdHJpbmcgc3RhcnRzCgkJe3N0YXJ0fSBieXRlcyBsYXRlciwgdGh1cyAiXiIgd2lsbCBtYXRjaCBhdCB7c3RhcnR9LiAgRXhjZXB0CgkJd2hlbiB7Y291bnR9IGlzIGdpdmVuLCB0aGVuIGl0J3MgbGlrZSBtYXRjaGVzIGJlZm9yZSB0aGUKCQl7c3RhcnR9IGJ5dGUgYXJlIGlnbm9yZWQgKHRoaXMgaXMgYSBiaXQgY29tcGxpY2F0ZWQgdG8ga2VlcCBpdAoJCWJhY2t3YXJkcyBjb21wYXRpYmxlKS4KCQlGb3IgYSBTdHJpbmcsIGlmIHtzdGFydH0gPCAwLCBpdCB3aWxsIGJlIHNldCB0byAwLiAgRm9yIGEgbGlzdAoJCXRoZSBpbmRleCBpcyBjb3VudGVkIGZyb20gdGhlIGVuZC4KCQlJZiB7c3RhcnR9IGlzIG91dCBvZiByYW5nZSAoe3N0YXJ0fSA+IHN0cmxlbih7ZXhwcn0pIGZvciBhCgkJU3RyaW5nIG9yIHtzdGFydH0gPiBsZW4oe2V4cHJ9KSBmb3IgYSB8TGlzdHwpIC0xIGlzIHJldHVybmVkLgoKCQlXaGVuIHtjb3VudH0gaXMgZ2l2ZW4gdXNlIHRoZSB7Y291bnR9J3RoIG1hdGNoLiAgV2hlbiBhIG1hdGNoCgkJaXMgZm91bmQgaW4gYSBTdHJpbmcgdGhlIHNlYXJjaCBmb3IgdGhlIG5leHQgb25lIHN0YXJ0cyBvbmUKCQljaGFyYWN0ZXIgZnVydGhlci4gIFRodXMgdGhpcyBleGFtcGxlIHJlc3VsdHMgaW4gMTogPgoJCQllY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgIi4uIiwgMCwgMikKPAkJSW4gYSB8TGlzdHwgdGhlIHNlYXJjaCBjb250aW51ZXMgaW4gdGhlIG5leHQgaXRlbS4KCQlOb3RlIHRoYXQgd2hlbiB7Y291bnR9IGlzIGFkZGVkIHRoZSB3YXkge3N0YXJ0fSB3b3JrcyBjaGFuZ2VzLAoJCXNlZSBhYm92ZS4KCgkJU2VlIHxwYXR0ZXJufCBmb3IgdGhlIHBhdHRlcm5zIHRoYXQgYXJlIGFjY2VwdGVkLgoJCVRoZSAnaWdub3JlY2FzZScgb3B0aW9uIGlzIHVzZWQgdG8gc2V0IHRoZSBpZ25vcmUtY2FzZW5lc3Mgb2YKCQl0aGUgcGF0dGVybi4gICdzbWFydGNhc2UnIGlzIE5PVCB1c2VkLglUaGUgbWF0Y2hpbmcgaXMgYWx3YXlzCgkJZG9uZSBsaWtlICdtYWdpYycgaXMgc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eS4KCgkJCQkJKm1hdGNoYWRkKCkqICpFNzk4KiAqRTc5OSogKkU4MDEqCm1hdGNoYWRkKHtncm91cH0sIHtwYXR0ZXJufVssIHtwcmlvcml0eX1bLCB7aWR9XV0pCgkJRGVmaW5lcyBhIHBhdHRlcm4gdG8gYmUgaGlnaGxpZ2h0ZWQgaW4gdGhlIGN1cnJlbnQgd2luZG93IChhCgkJIm1hdGNoIikuICBJdCB3aWxsIGJlIGhpZ2hsaWdodGVkIHdpdGgge2dyb3VwfS4gIFJldHVybnMgYW4KCQlpZGVudGlmaWNhdGlvbiBudW1iZXIgKElEKSwgd2hpY2ggY2FuIGJlIHVzZWQgdG8gZGVsZXRlIHRoZQoJCW1hdGNoIHVzaW5nIHxtYXRjaGRlbGV0ZSgpfC4KCgkJVGhlIG9wdGlvbmFsIHtwcmlvcml0eX0gYXJndW1lbnQgYXNzaWducyBhIHByaW9yaXR5IHRvIHRoZQoJCW1hdGNoLglBIG1hdGNoIHdpdGggYSBoaWdoIHByaW9yaXR5IHdpbGwgaGF2ZSBpdHMKCQloaWdobGlnaHRpbmcgb3ZlcnJ1bGUgdGhhdCBvZiBhIG1hdGNoIHdpdGggYSBsb3dlciBwcmlvcml0eS4KCQlBIHByaW9yaXR5IGlzIHNwZWNpZmllZCBhcyBhbiBpbnRlZ2VyIChuZWdhdGl2ZSBudW1iZXJzIGFyZSBubwoJCWV4Y2VwdGlvbikuICBJZiB0aGUge3ByaW9yaXR5fSBhcmd1bWVudCBpcyBub3Qgc3BlY2lmaWVkLCB0aGUKCQlkZWZhdWx0IHByaW9yaXR5IGlzIDEwLiAgVGhlIHByaW9yaXR5IG9mICdobHNlYXJjaCcgaXMgemVybywKCQloZW5jZSBhbGwgbWF0Y2hlcyB3aXRoIGEgcHJpb3JpdHkgZ3JlYXRlciB0aGFuIHplcm8gd2lsbAoJCW92ZXJydWxlIGl0LiAgU3ludGF4IGhpZ2hsaWdodGluZyAoc2VlICdzeW50YXgnKSBpcyBhIHNlcGFyYXRlCgkJbWVjaGFuaXNtLCBhbmQgcmVnYXJkbGVzcyBvZiB0aGUgY2hvc2VuIHByaW9yaXR5IGEgbWF0Y2ggd2lsbAoJCWFsd2F5cyBvdmVycnVsZSBzeW50YXggaGlnaGxpZ2h0aW5nLgoKCQlUaGUgb3B0aW9uYWwge2lkfSBhcmd1bWVudCBhbGxvd3MgdGhlIHJlcXVlc3QgZm9yIGEgc3BlY2lmaWMKCQltYXRjaCBJRC4gIElmIGEgc3BlY2lmaWVkIElEIGlzIGFscmVhZHkgdGFrZW4sIGFuIGVycm9yCgkJbWVzc2FnZSB3aWxsIGFwcGVhciBhbmQgdGhlIG1hdGNoIHdpbGwgbm90IGJlIGFkZGVkLiAgQW4gSUQKCQlpcyBzcGVjaWZpZWQgYXMgYSBwb3NpdGl2ZSBpbnRlZ2VyICh6ZXJvIGV4Y2x1ZGVkKS4gIElEcyAxLCAyCgkJYW5kIDMgYXJlIHJlc2VydmVkIGZvciB8Om1hdGNofCwgfDoybWF0Y2h8IGFuZCB8OjNtYXRjaHwsCgkJcmVzcGVjdGl2ZWx5LiAgSWYgdGhlIHtpZH0gYXJndW1lbnQgaXMgbm90IHNwZWNpZmllZCwKCQl8bWF0Y2hhZGQoKXwgYXV0b21hdGljYWxseSBjaG9vc2VzIGEgZnJlZSBJRC4KCgkJVGhlIG51bWJlciBvZiBtYXRjaGVzIGlzIG5vdCBsaW1pdGVkLCBhcyBpdCBpcyB0aGUgY2FzZSB3aXRoCgkJdGhlIHw6bWF0Y2h8IGNvbW1hbmRzLgoKCQlFeGFtcGxlOiA+CgkJCTpoaWdobGlnaHQgTXlHcm91cCBjdGVybWJnPWdyZWVuIGd1aWJnPWdyZWVuCgkJCTpsZXQgbSA9IG1hdGNoYWRkKCJNeUdyb3VwIiwgIlRPRE8iKQo8CQlEZWxldGlvbiBvZiB0aGUgcGF0dGVybjogPgoJCQk6Y2FsbCBtYXRjaGRlbGV0ZShtKQoKPAkJQSBsaXN0IG9mIG1hdGNoZXMgZGVmaW5lZCBieSB8bWF0Y2hhZGQoKXwgYW5kIHw6bWF0Y2h8IGFyZQoJCWF2YWlsYWJsZSBmcm9tIHxnZXRtYXRjaGVzKCl8LglBbGwgbWF0Y2hlcyBjYW4gYmUgZGVsZXRlZCBpbgoJCW9uZSBvcGVyYXRpb24gYnkgfGNsZWFybWF0Y2hlcygpfC4KCm1hdGNoYXJnKHtucn0pCQkJCQkJCSptYXRjaGFyZygpKgoJCVNlbGVjdHMgdGhlIHtucn0gbWF0Y2ggaXRlbSwgYXMgc2V0IHdpdGggYSB8Om1hdGNofCwKCQl8OjJtYXRjaHwgb3IgfDozbWF0Y2h8IGNvbW1hbmQuCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggdHdvIGVsZW1lbnRzOgoJCQlUaGUgbmFtZSBvZiB0aGUgaGlnaGxpZ2h0IGdyb3VwIHVzZWQKCQkJVGhlIHBhdHRlcm4gdXNlZC4KCQlXaGVuIHtucn0gaXMgbm90IDEsIDIgb3IgMyByZXR1cm5zIGFuIGVtcHR5IHxMaXN0fC4KCQlXaGVuIHRoZXJlIGlzIG5vIG1hdGNoIGl0ZW0gc2V0IHJldHVybnMgWycnLCAnJ10uCgkJVGhpcyBpcyB1c2VmdWwgdG8gc2F2ZSBhbmQgcmVzdG9yZSBhIHw6bWF0Y2h8LgoJCUhpZ2hsaWdodGluZyBtYXRjaGVzIHVzaW5nIHRoZSB8Om1hdGNofCBjb21tYW5kcyBhcmUgbGltaXRlZAoJCXRvIHRocmVlIG1hdGNoZXMuIHxtYXRjaGFkZCgpfCBkb2VzIG5vdCBoYXZlIHRoaXMgbGltaXRhdGlvbi4KCm1hdGNoZGVsZXRlKHtpZH0pCQkJICAgICAgICptYXRjaGRlbGV0ZSgpKiAqRTgwMiogKkU4MDMqCgkJRGVsZXRlcyBhIG1hdGNoIHdpdGggSUQge2lkfSBwcmV2aW91c2x5IGRlZmluZWQgYnkgfG1hdGNoYWRkKCl8CgkJb3Igb25lIG9mIHRoZSB8Om1hdGNofCBjb21tYW5kcy4gIFJldHVybnMgMCBpZiBzdWNjZXNzZnVsLAoJCW90aGVyd2lzZSAtMS4gIFNlZSBleGFtcGxlIGZvciB8bWF0Y2hhZGQoKXwuICBBbGwgbWF0Y2hlcyBjYW4KCQliZSBkZWxldGVkIGluIG9uZSBvcGVyYXRpb24gYnkgfGNsZWFybWF0Y2hlcygpfC4KCm1hdGNoZW5kKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQkJCSptYXRjaGVuZCgpKgoJCVNhbWUgYXMgfG1hdGNoKCl8LCBidXQgcmV0dXJuIHRoZSBpbmRleCBvZiBmaXJzdCBjaGFyYWN0ZXIKCQlhZnRlciB0aGUgbWF0Y2guICBFeGFtcGxlOiA+CgkJCTplY2hvIG1hdGNoZW5kKCJ0ZXN0aW5nIiwgImluZyIpCjwJCXJlc3VsdHMgaW4gIjciLgoJCQkJCQkJKnN0cnNwbigpKiAqc3RyY3NwbigpKgoJCVZpbSBkb2Vzbid0IGhhdmUgYSBzdHJzcG4oKSBvciBzdHJjc3BuKCkgZnVuY3Rpb24sIGJ1dCB5b3UgY2FuCgkJZG8gaXQgd2l0aCBtYXRjaGVuZCgpOiA+CgkJCTpsZXQgc3BhbiA9IG1hdGNoZW5kKGxpbmUsICdbYS16QS1aXScpCgkJCTpsZXQgc3BhbiA9IG1hdGNoZW5kKGxpbmUsICdbXmEtekEtWl0nKQo8CQlFeGNlcHQgdGhhdCAtMSBpcyByZXR1cm5lZCB3aGVuIHRoZXJlIGFyZSBubyBtYXRjaGVzLgoKCQlUaGUge3N0YXJ0fSwgaWYgZ2l2ZW4sIGhhcyB0aGUgc2FtZSBtZWFuaW5nIGFzIGZvciB8bWF0Y2goKXwuID4KCQkJOmVjaG8gbWF0Y2hlbmQoInRlc3RpbmciLCAiaW5nIiwgMikKPAkJcmVzdWx0cyBpbiAiNyIuID4KCQkJOmVjaG8gbWF0Y2hlbmQoInRlc3RpbmciLCAiaW5nIiwgNSkKPAkJcmVzdWx0IGlzICItMSIuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgdGhlIHJlc3VsdCBpcyBlcXVhbCB0byB8bWF0Y2goKXwuCgptYXRjaGxpc3Qoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCQkJKm1hdGNobGlzdCgpKgoJCVNhbWUgYXMgfG1hdGNoKCl8LCBidXQgcmV0dXJuIGEgfExpc3R8LiAgVGhlIGZpcnN0IGl0ZW0gaW4gdGhlCgkJbGlzdCBpcyB0aGUgbWF0Y2hlZCBzdHJpbmcsIHNhbWUgYXMgd2hhdCBtYXRjaHN0cigpIHdvdWxkCgkJcmV0dXJuLiAgRm9sbG93aW5nIGl0ZW1zIGFyZSBzdWJtYXRjaGVzLCBsaWtlICJcMSIsICJcMiIsIGV0Yy4KCQlpbiB8OnN1YnN0aXR1dGV8LiAgV2hlbiBhbiBvcHRpb25hbCBzdWJtYXRjaCBkaWRuJ3QgbWF0Y2ggYW4KCQllbXB0eSBzdHJpbmcgaXMgdXNlZC4gIEV4YW1wbGU6ID4KCQkJZWNobyBtYXRjaGxpc3QoJ2FjZCcsICdcKGFcKVw/XChiXClcP1woY1wpXD9cKC4qXCknKQo8CQlSZXN1bHRzIGluOiBbJ2FjZCcsICdhJywgJycsICdjJywgJ2QnLCAnJywgJycsICcnLCAnJywgJyddCgkJV2hlbiB0aGVyZSBpcyBubyBtYXRjaCBhbiBlbXB0eSBsaXN0IGlzIHJldHVybmVkLgoKbWF0Y2hzdHIoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCQkJKm1hdGNoc3RyKCkqCgkJU2FtZSBhcyB8bWF0Y2goKXwsIGJ1dCByZXR1cm4gdGhlIG1hdGNoZWQgc3RyaW5nLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBtYXRjaHN0cigidGVzdGluZyIsICJpbmciKQo8CQlyZXN1bHRzIGluICJpbmciLgoJCVdoZW4gdGhlcmUgaXMgbm8gbWF0Y2ggIiIgaXMgcmV0dXJuZWQuCgkJVGhlIHtzdGFydH0sIGlmIGdpdmVuLCBoYXMgdGhlIHNhbWUgbWVhbmluZyBhcyBmb3IgfG1hdGNoKCl8LiA+CgkJCTplY2hvIG1hdGNoc3RyKCJ0ZXN0aW5nIiwgImluZyIsIDIpCjwJCXJlc3VsdHMgaW4gImluZyIuID4KCQkJOmVjaG8gbWF0Y2hzdHIoInRlc3RpbmciLCAiaW5nIiwgNSkKPAkJcmVzdWx0IGlzICIiLgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IHRoZW4gdGhlIG1hdGNoaW5nIGl0ZW0gaXMgcmV0dXJuZWQuCgkJVGhlIHR5cGUgaXNuJ3QgY2hhbmdlZCwgaXQncyBub3QgbmVjZXNzYXJpbHkgYSBTdHJpbmcuCgoJCQkJCQkJKm1heCgpKgptYXgoe2xpc3R9KQlSZXR1cm4gdGhlIG1heGltdW0gdmFsdWUgb2YgYWxsIGl0ZW1zIGluIHtsaXN0fS4KCQlJZiB7bGlzdH0gaXMgbm90IGEgbGlzdCBvciBvbmUgb2YgdGhlIGl0ZW1zIGluIHtsaXN0fSBjYW5ub3QKCQliZSB1c2VkIGFzIGEgTnVtYmVyIHRoaXMgcmVzdWx0cyBpbiBhbiBlcnJvci4KCQlBbiBlbXB0eSB8TGlzdHwgcmVzdWx0cyBpbiB6ZXJvLgoKCQkJCQkJCSptaW4oKSoKbWluKHtsaXN0fSkJUmV0dXJuIHRoZSBtaW5pbXVtIHZhbHVlIG9mIGFsbCBpdGVtcyBpbiB7bGlzdH0uCgkJSWYge2xpc3R9IGlzIG5vdCBhIGxpc3Qgb3Igb25lIG9mIHRoZSBpdGVtcyBpbiB7bGlzdH0gY2Fubm90CgkJYmUgdXNlZCBhcyBhIE51bWJlciB0aGlzIHJlc3VsdHMgaW4gYW4gZXJyb3IuCgkJQW4gZW1wdHkgfExpc3R8IHJlc3VsdHMgaW4gemVyby4KCgkJCQkJCQkqbWtkaXIoKSogKkU3MzkqCm1rZGlyKHtuYW1lfSBbLCB7cGF0aH0gWywge3Byb3R9XV0pCgkJQ3JlYXRlIGRpcmVjdG9yeSB7bmFtZX0uCgkJSWYge3BhdGh9IGlzICJwIiB0aGVuIGludGVybWVkaWF0ZSBkaXJlY3RvcmllcyBhcmUgY3JlYXRlZCBhcwoJCW5lY2Vzc2FyeS4gIE90aGVyd2lzZSBpdCBtdXN0IGJlICIiLgoJCUlmIHtwcm90fSBpcyBnaXZlbiBpdCBpcyB1c2VkIHRvIHNldCB0aGUgcHJvdGVjdGlvbiBiaXRzIG9mCgkJdGhlIG5ldyBkaXJlY3RvcnkuICBUaGUgZGVmYXVsdCBpcyAwNzU1IChyd3hyLXhyLXg6IHIvdyBmb3IKCQl0aGUgdXNlciByZWFkYWJsZSBmb3Igb3RoZXJzKS4JVXNlIDA3MDAgdG8gbWFrZSBpdCB1bnJlYWRhYmxlCgkJZm9yIG90aGVycy4gIFRoaXMgaXMgb25seSB1c2VkIGZvciB0aGUgbGFzdCBwYXJ0IG9mIHtuYW1lfS4KCQlUaHVzIGlmIHlvdSBjcmVhdGUgL3RtcC9mb28vYmFyIHRoZW4gL3RtcC9mb28gd2lsbCBiZSBjcmVhdGVkCgkJd2l0aCAwNzU1LgoJCUV4YW1wbGU6ID4KCQkJOmNhbGwgbWtkaXIoJEhPTUUgLiAiL3RtcC9mb28vYmFyIiwgInAiLCAwNzAwKQo8CQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQlOb3QgYXZhaWxhYmxlIG9uIGFsbCBzeXN0ZW1zLiAgVG8gY2hlY2sgdXNlOiA+CgkJCTppZiBleGlzdHMoIipta2RpciIpCjwKCQkJCQkJCSptb2RlKCkqCm1vZGUoW2V4cHJdKQlSZXR1cm4gYSBzdHJpbmcgdGhhdCBpbmRpY2F0ZXMgdGhlIGN1cnJlbnQgbW9kZS4KCQlJZiBbZXhwcl0gaXMgc3VwcGxpZWQgYW5kIGl0IGV2YWx1YXRlcyB0byBhIG5vbi16ZXJvIE51bWJlciBvcgoJCWEgbm9uLWVtcHR5IFN0cmluZyAofG5vbi16ZXJvLWFyZ3wpLCB0aGVuIHRoZSBmdWxsIG1vZGUgaXMKCQlyZXR1cm5lZCwgb3RoZXJ3aXNlIG9ubHkgdGhlIGZpcnN0IGxldHRlciBpcyByZXR1cm5lZC4gIE5vdGUKCQl0aGF0ICIgIiBhbmQgIjAiIGFyZSBhbHNvIG5vbi1lbXB0eSBzdHJpbmdzLgoKCQkJbglOb3JtYWwKCQkJbm8JT3BlcmF0b3ItcGVuZGluZwoJCQl2CVZpc3VhbCBieSBjaGFyYWN0ZXIKCQkJVglWaXN1YWwgYnkgbGluZQoJCQlDVFJMLVYJVmlzdWFsIGJsb2Nrd2lzZQoJCQlzCVNlbGVjdCBieSBjaGFyYWN0ZXIKCQkJUwlTZWxlY3QgYnkgbGluZQoJCQlDVFJMLVMJU2VsZWN0IGJsb2Nrd2lzZQoJCQlpCUluc2VydAoJCQlSCVJlcGxhY2UgfFJ8CgkJCVJ2CVZpcnR1YWwgUmVwbGFjZSB8Z1J8CgkJCWMJQ29tbWFuZC1saW5lCgkJCWN2CVZpbSBFeCBtb2RlIHxnUXwKCQkJY2UJTm9ybWFsIEV4IG1vZGUgfFF8CgkJCXIJSGl0LWVudGVyIHByb21wdAoJCQlybQlUaGUgLS0gbW9yZSAtLSBwcm9tcHQKCQkJcj8JQSB8OmNvbmZpcm18IHF1ZXJ5IG9mIHNvbWUgc29ydAoJCQkhCVNoZWxsIG9yIGV4dGVybmFsIGNvbW1hbmQgaXMgZXhlY3V0aW5nCgkJVGhpcyBpcyB1c2VmdWwgaW4gdGhlICdzdGF0dXNsaW5lJyBvcHRpb24gb3Igd2hlbiB1c2VkCgkJd2l0aCB8cmVtb3RlX2V4cHIoKXwgSW4gbW9zdCBvdGhlciBwbGFjZXMgaXQgYWx3YXlzIHJldHVybnMKCQkiYyIgb3IgIm4iLgoJCUFsc28gc2VlIHx2aXN1YWxtb2RlKCl8LgoKbXpldmFsKHtleHByfSkJCQkJCQkJKm16ZXZhbCgpKgoJCUV2YWx1YXRlIE16U2NoZW1lIGV4cHJlc3Npb24ge2V4cHJ9IGFuZCByZXR1cm4gaXRzIHJlc3VsdAoJCWNvbnZlcnQgdG8gVmltIGRhdGEgc3RydWN0dXJlcy4KCQlOdW1iZXJzIGFuZCBzdHJpbmdzIGFyZSByZXR1cm5lZCBhcyB0aGV5IGFyZS4KCQlQYWlycyAoaW5jbHVkaW5nIGxpc3RzIGFuZCBpbXByb3BlciBsaXN0cykgYW5kIHZlY3RvcnMgYXJlCgkJcmV0dXJuZWQgYXMgVmltIHxMaXN0c3wuCgkJSGFzaCB0YWJsZXMgYXJlIHJlcHJlc2VudGVkIGFzIFZpbSB8RGljdGlvbmFyeXwgdHlwZSB3aXRoIGtleXMKCQljb252ZXJ0ZWQgdG8gc3RyaW5ncy4KCQlBbGwgb3RoZXIgdHlwZXMgYXJlIGNvbnZlcnRlZCB0byBzdHJpbmcgd2l0aCBkaXNwbGF5IGZ1bmN0aW9uLgoJCUV4YW1wbGVzOiA+CgkJICAgIDpteiAoZGVmaW5lIGwgKGxpc3QgMSAyIDMpKQoJCSAgICA6bXogKGRlZmluZSBoIChtYWtlLWhhc2gpKSAoaGFzaC1zZXQhIGggImxpc3QiIGwpCgkJICAgIDplY2hvIG16ZXZhbCgibCIpCgkJICAgIDplY2hvIG16ZXZhbCgiaCIpCjwKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K216c2NoZW1lfCBmZWF0dXJlfQoKbmV4dG5vbmJsYW5rKHtsbnVtfSkJCQkJCSpuZXh0bm9uYmxhbmsoKSoKCQlSZXR1cm4gdGhlIGxpbmUgbnVtYmVyIG9mIHRoZSBmaXJzdCBsaW5lIGF0IG9yIGJlbG93IHtsbnVtfQoJCXRoYXQgaXMgbm90IGJsYW5rLiAgRXhhbXBsZTogPgoJCQlpZiBnZXRsaW5lKG5leHRub25ibGFuaygxKSkgPX4gIkphdmEiCjwJCVdoZW4ge2xudW19IGlzIGludmFsaWQgb3IgdGhlcmUgaXMgbm8gbm9uLWJsYW5rIGxpbmUgYXQgb3IKCQliZWxvdyBpdCwgemVybyBpcyByZXR1cm5lZC4KCQlTZWUgYWxzbyB8cHJldm5vbmJsYW5rKCl8LgoKbnIyY2hhcih7ZXhwcn0pCQkJCQkJKm5yMmNoYXIoKSoKCQlSZXR1cm4gYSBzdHJpbmcgd2l0aCBhIHNpbmdsZSBjaGFyYWN0ZXIsIHdoaWNoIGhhcyB0aGUgbnVtYmVyCgkJdmFsdWUge2V4cHJ9LiAgRXhhbXBsZXM6ID4KCQkJbnIyY2hhcig2NCkJCXJldHVybnMgIkAiCgkJCW5yMmNoYXIoMzIpCQlyZXR1cm5zICIgIgo8CQlUaGUgY3VycmVudCAnZW5jb2RpbmcnIGlzIHVzZWQuICBFeGFtcGxlIGZvciAidXRmLTgiOiA+CgkJCW5yMmNoYXIoMzAwKQkJcmV0dXJucyBJIHdpdGggYm93IGNoYXJhY3Rlcgo8CQlOb3RlIHRoYXQgYSBOVUwgY2hhcmFjdGVyIGluIHRoZSBmaWxlIGlzIHNwZWNpZmllZCB3aXRoCgkJbnIyY2hhcigxMCksIGJlY2F1c2UgTlVMcyBhcmUgcmVwcmVzZW50ZWQgd2l0aCBuZXdsaW5lCgkJY2hhcmFjdGVycy4gIG5yMmNoYXIoMCkgaXMgYSByZWFsIE5VTCBhbmQgdGVybWluYXRlcyB0aGUKCQlzdHJpbmcsIHRodXMgcmVzdWx0cyBpbiBhbiBlbXB0eSBzdHJpbmcuCgoJCQkJCQkJKmdldHBpZCgpKgpnZXRwaWQoKQlSZXR1cm4gYSBOdW1iZXIgd2hpY2ggaXMgdGhlIHByb2Nlc3MgSUQgb2YgdGhlIFZpbSBwcm9jZXNzLgoJCU9uIFVuaXggYW5kIE1TLVdpbmRvd3MgdGhpcyBpcyBhIHVuaXF1ZSBudW1iZXIsIHVudGlsIFZpbQoJCWV4aXRzLglPbiBNUy1ET1MgaXQncyBhbHdheXMgemVyby4KCgkJCQkJCQkqZ2V0cG9zKCkqCmdldHBvcyh7ZXhwcn0pCUdldCB0aGUgcG9zaXRpb24gZm9yIHtleHByfS4gIEZvciBwb3NzaWJsZSB2YWx1ZXMgb2Yge2V4cHJ9CgkJc2VlIHxsaW5lKCl8LgoJCVRoZSByZXN1bHQgaXMgYSB8TGlzdHwgd2l0aCBmb3VyIG51bWJlcnM6CgkJICAgIFtidWZudW0sIGxudW0sIGNvbCwgb2ZmXQoJCSJidWZudW0iIGlzIHplcm8sIHVubGVzcyBhIG1hcmsgbGlrZSAnMCBvciAnQSBpcyB1c2VkLCB0aGVuIGl0CgkJaXMgdGhlIGJ1ZmZlciBudW1iZXIgb2YgdGhlIG1hcmsuCgkJImxudW0iIGFuZCAiY29sIiBhcmUgdGhlIHBvc2l0aW9uIGluIHRoZSBidWZmZXIuICBUaGUgZmlyc3QKCQljb2x1bW4gaXMgMS4KCQlUaGUgIm9mZiIgbnVtYmVyIGlzIHplcm8sIHVubGVzcyAndmlydHVhbGVkaXQnIGlzIHVzZWQuICBUaGVuCgkJaXQgaXMgdGhlIG9mZnNldCBpbiBzY3JlZW4gY29sdW1ucyBmcm9tIHRoZSBzdGFydCBvZiB0aGUKCQljaGFyYWN0ZXIuICBFLmcuLCBhIHBvc2l0aW9uIHdpdGhpbiBhIDxUYWI+IG9yIGFmdGVyIHRoZSBsYXN0CgkJY2hhcmFjdGVyLgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gc2F2ZSBhbmQgcmVzdG9yZSB0aGUgY3Vyc29yIHBvc2l0aW9uOiA+CgkJCWxldCBzYXZlX2N1cnNvciA9IGdldHBvcygiLiIpCgkJCU1vdmVUaGVDdXJzb3JBcm91bmQKCQkJY2FsbCBzZXRwb3MoJy4nLCBzYXZlX2N1cnNvcikKPAkJQWxzbyBzZWUgfHNldHBvcygpfC4KCm9yKHtleHByfSwge2V4cHJ9KQkJCQkJKm9yKCkqCgkJQml0d2lzZSBPUiBvbiB0aGUgdHdvIGFyZ3VtZW50cy4gIFRoZSBhcmd1bWVudHMgYXJlIGNvbnZlcnRlZAoJCXRvIGEgbnVtYmVyLiAgQSBMaXN0LCBEaWN0IG9yIEZsb2F0IGFyZ3VtZW50IGNhdXNlcyBhbiBlcnJvci4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgYml0cyA9IG9yKGJpdHMsIDB4ODApCgoKcGF0aHNob3J0ZW4oe2V4cHJ9KQkJCQkJKnBhdGhzaG9ydGVuKCkqCgkJU2hvcnRlbiBkaXJlY3RvcnkgbmFtZXMgaW4gdGhlIHBhdGgge2V4cHJ9IGFuZCByZXR1cm4gdGhlCgkJcmVzdWx0LiAgVGhlIHRhaWwsIHRoZSBmaWxlIG5hbWUsIGlzIGtlcHQgYXMtaXMuICBUaGUgb3RoZXIKCQljb21wb25lbnRzIGluIHRoZSBwYXRoIGFyZSByZWR1Y2VkIHRvIHNpbmdsZSBsZXR0ZXJzLiAgTGVhZGluZwoJCSd+JyBhbmQgJy4nIGNoYXJhY3RlcnMgYXJlIGtlcHQuICBFeGFtcGxlOiA+CgkJCTplY2hvIHBhdGhzaG9ydGVuKCd+Ly52aW0vYXV0b2xvYWQvbXlmaWxlLnZpbScpCjwJCQl+Ly52L2EvbXlmaWxlLnZpbSB+CgkJSXQgZG9lc24ndCBtYXR0ZXIgaWYgdGhlIHBhdGggZXhpc3RzIG9yIG5vdC4KCnBvdyh7eH0sIHt5fSkJCQkJCQkqcG93KCkqCgkJUmV0dXJuIHRoZSBwb3dlciBvZiB7eH0gdG8gdGhlIGV4cG9uZW50IHt5fSBhcyBhIHxGbG9hdHwuCgkJe3h9IGFuZCB7eX0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBwb3coMywgMykKPAkJCTI3LjAgPgoJCQk6ZWNobyBwb3coMiwgMTYpCjwJCQk2NTUzNi4wID4KCQkJOmVjaG8gcG93KDMyLCAwLjIwKQo8CQkJMi4wCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKcHJldm5vbmJsYW5rKHtsbnVtfSkJCQkJCSpwcmV2bm9uYmxhbmsoKSoKCQlSZXR1cm4gdGhlIGxpbmUgbnVtYmVyIG9mIHRoZSBmaXJzdCBsaW5lIGF0IG9yIGFib3ZlIHtsbnVtfQoJCXRoYXQgaXMgbm90IGJsYW5rLiAgRXhhbXBsZTogPgoJCQlsZXQgaW5kID0gaW5kZW50KHByZXZub25ibGFuayh2OmxudW0gLSAxKSkKPAkJV2hlbiB7bG51bX0gaXMgaW52YWxpZCBvciB0aGVyZSBpcyBubyBub24tYmxhbmsgbGluZSBhdCBvcgoJCWFib3ZlIGl0LCB6ZXJvIGlzIHJldHVybmVkLgoJCUFsc28gc2VlIHxuZXh0bm9uYmxhbmsoKXwuCgoKcHJpbnRmKHtmbXR9LCB7ZXhwcjF9IC4uLikJCQkJKnByaW50ZigpKgoJCVJldHVybiBhIFN0cmluZyB3aXRoIHtmbXR9LCB3aGVyZSAiJSIgaXRlbXMgYXJlIHJlcGxhY2VkIGJ5CgkJdGhlIGZvcm1hdHRlZCBmb3JtIG9mIHRoZWlyIHJlc3BlY3RpdmUgYXJndW1lbnRzLiAgRXhhbXBsZTogPgoJCQlwcmludGYoIiU0ZDogRSVkICUuMzBzIiwgbG51bSwgZXJybm8sIG1zZykKPAkJTWF5IHJlc3VsdCBpbjoKCQkJIiAgOTk6IEU0MiBhc2RmYXNkZmFzZGZhc2RmYXNkZmFzZGZhc2RmYXMiIH4KCgkJT2Z0ZW4gdXNlZCBpdGVtcyBhcmU6CgkJICAlcwlzdHJpbmcKCQkgICU2cwlzdHJpbmcgcmlnaHQtYWxpZ25lZCBpbiA2IGJ5dGVzCgkJICAlLjlzCXN0cmluZyB0cnVuY2F0ZWQgdG8gOSBieXRlcwoJCSAgJWMJc2luZ2xlIGJ5dGUKCQkgICVkCWRlY2ltYWwgbnVtYmVyCgkJICAlNWQJZGVjaW1hbCBudW1iZXIgcGFkZGVkIHdpdGggc3BhY2VzIHRvIDUgY2hhcmFjdGVycwoJCSAgJXgJaGV4IG51bWJlcgoJCSAgJTA0eAloZXggbnVtYmVyIHBhZGRlZCB3aXRoIHplcm9zIHRvIGF0IGxlYXN0IDQgY2hhcmFjdGVycwoJCSAgJVgJaGV4IG51bWJlciB1c2luZyB1cHBlciBjYXNlIGxldHRlcnMKCQkgICVvCW9jdGFsIG51bWJlcgoJCSAgJWYJZmxvYXRpbmcgcG9pbnQgbnVtYmVyIGluIHRoZSBmb3JtIDEyMy40NTYKCQkgICVlCWZsb2F0aW5nIHBvaW50IG51bWJlciBpbiB0aGUgZm9ybSAxLjIzNGUzCgkJICAlRQlmbG9hdGluZyBwb2ludCBudW1iZXIgaW4gdGhlIGZvcm0gMS4yMzRFMwoJCSAgJWcJZmxvYXRpbmcgcG9pbnQgbnVtYmVyLCBhcyAlZiBvciAlZSBkZXBlbmRpbmcgb24gdmFsdWUKCQkgICVHCWZsb2F0aW5nIHBvaW50IG51bWJlciwgYXMgJWYgb3IgJUUgZGVwZW5kaW5nIG9uIHZhbHVlCgkJICAlJQl0aGUgJSBjaGFyYWN0ZXIgaXRzZWxmCgoJCUNvbnZlcnNpb24gc3BlY2lmaWNhdGlvbnMgc3RhcnQgd2l0aCAnJScgYW5kIGVuZCB3aXRoIHRoZQoJCWNvbnZlcnNpb24gdHlwZS4gIEFsbCBvdGhlciBjaGFyYWN0ZXJzIGFyZSBjb3BpZWQgdW5jaGFuZ2VkIHRvCgkJdGhlIHJlc3VsdC4KCgkJVGhlICIlIiBzdGFydHMgYSBjb252ZXJzaW9uIHNwZWNpZmljYXRpb24uICBUaGUgZm9sbG93aW5nCgkJYXJndW1lbnRzIGFwcGVhciBpbiBzZXF1ZW5jZToKCgkJCSUgIFtmbGFnc10gIFtmaWVsZC13aWR0aF0gIFsucHJlY2lzaW9uXSAgdHlwZQoKCQlmbGFncwoJCQlaZXJvIG9yIG1vcmUgb2YgdGhlIGZvbGxvd2luZyBmbGFnczoKCgkJICAgICMJICAgICAgVGhlIHZhbHVlIHNob3VsZCBiZSBjb252ZXJ0ZWQgdG8gYW4gImFsdGVybmF0ZQoJCQkgICAgICBmb3JtIi4gIEZvciBjLCBkLCBhbmQgcyBjb252ZXJzaW9ucywgdGhpcyBvcHRpb24KCQkJICAgICAgaGFzIG5vIGVmZmVjdC4gIEZvciBvIGNvbnZlcnNpb25zLCB0aGUgcHJlY2lzaW9uCgkJCSAgICAgIG9mIHRoZSBudW1iZXIgaXMgaW5jcmVhc2VkIHRvIGZvcmNlIHRoZSBmaXJzdAoJCQkgICAgICBjaGFyYWN0ZXIgb2YgdGhlIG91dHB1dCBzdHJpbmcgdG8gYSB6ZXJvIChleGNlcHQKCQkJICAgICAgaWYgYSB6ZXJvIHZhbHVlIGlzIHByaW50ZWQgd2l0aCBhbiBleHBsaWNpdAoJCQkgICAgICBwcmVjaXNpb24gb2YgemVybykuCgkJCSAgICAgIEZvciB4IGFuZCBYIGNvbnZlcnNpb25zLCBhIG5vbi16ZXJvIHJlc3VsdCBoYXMKCQkJICAgICAgdGhlIHN0cmluZyAiMHgiIChvciAiMFgiIGZvciBYIGNvbnZlcnNpb25zKQoJCQkgICAgICBwcmVwZW5kZWQgdG8gaXQuCgoJCSAgICAwICh6ZXJvKSAgWmVybyBwYWRkaW5nLiAgRm9yIGFsbCBjb252ZXJzaW9ucyB0aGUgY29udmVydGVkCgkJCSAgICAgIHZhbHVlIGlzIHBhZGRlZCBvbiB0aGUgbGVmdCB3aXRoIHplcm9zIHJhdGhlcgoJCQkgICAgICB0aGFuIGJsYW5rcy4gIElmIGEgcHJlY2lzaW9uIGlzIGdpdmVuIHdpdGggYQoJCQkgICAgICBudW1lcmljIGNvbnZlcnNpb24gKGQsIG8sIHgsIGFuZCBYKSwgdGhlIDAgZmxhZwoJCQkgICAgICBpcyBpZ25vcmVkLgoKCQkgICAgLQkgICAgICBBIG5lZ2F0aXZlIGZpZWxkIHdpZHRoIGZsYWc7IHRoZSBjb252ZXJ0ZWQgdmFsdWUKCQkJICAgICAgaXMgdG8gYmUgbGVmdCBhZGp1c3RlZCBvbiB0aGUgZmllbGQgYm91bmRhcnkuCgkJCSAgICAgIFRoZSBjb252ZXJ0ZWQgdmFsdWUgaXMgcGFkZGVkIG9uIHRoZSByaWdodCB3aXRoCgkJCSAgICAgIGJsYW5rcywgcmF0aGVyIHRoYW4gb24gdGhlIGxlZnQgd2l0aCBibGFua3Mgb3IKCQkJICAgICAgemVyb3MuICBBIC0gb3ZlcnJpZGVzIGEgMCBpZiBib3RoIGFyZSBnaXZlbi4KCgkJICAgICcgJyAoc3BhY2UpICBBIGJsYW5rIHNob3VsZCBiZSBsZWZ0IGJlZm9yZSBhIHBvc2l0aXZlCgkJCSAgICAgIG51bWJlciBwcm9kdWNlZCBieSBhIHNpZ25lZCBjb252ZXJzaW9uIChkKS4KCgkJICAgICsJICAgICAgQSBzaWduIG11c3QgYWx3YXlzIGJlIHBsYWNlZCBiZWZvcmUgYSBudW1iZXIKCQkJICAgICAgcHJvZHVjZWQgYnkgYSBzaWduZWQgY29udmVyc2lvbi4JQSArIG92ZXJyaWRlcwoJCQkgICAgICBhIHNwYWNlIGlmIGJvdGggYXJlIHVzZWQuCgoJCWZpZWxkLXdpZHRoCgkJCUFuIG9wdGlvbmFsIGRlY2ltYWwgZGlnaXQgc3RyaW5nIHNwZWNpZnlpbmcgYSBtaW5pbXVtCgkJCWZpZWxkIHdpZHRoLiAgSWYgdGhlIGNvbnZlcnRlZCB2YWx1ZSBoYXMgZmV3ZXIgYnl0ZXMKCQkJdGhhbiB0aGUgZmllbGQgd2lkdGgsIGl0IHdpbGwgYmUgcGFkZGVkIHdpdGggc3BhY2VzIG9uCgkJCXRoZSBsZWZ0IChvciByaWdodCwgaWYgdGhlIGxlZnQtYWRqdXN0bWVudCBmbGFnIGhhcwoJCQliZWVuIGdpdmVuKSB0byBmaWxsIG91dCB0aGUgZmllbGQgd2lkdGguCgoJCS5wcmVjaXNpb24KCQkJQW4gb3B0aW9uYWwgcHJlY2lzaW9uLCBpbiB0aGUgZm9ybSBvZiBhIHBlcmlvZCAnLicKCQkJZm9sbG93ZWQgYnkgYW4gb3B0aW9uYWwgZGlnaXQgc3RyaW5nLiAgSWYgdGhlIGRpZ2l0CgkJCXN0cmluZyBpcyBvbWl0dGVkLCB0aGUgcHJlY2lzaW9uIGlzIHRha2VuIGFzIHplcm8uCgkJCVRoaXMgZ2l2ZXMgdGhlIG1pbmltdW0gbnVtYmVyIG9mIGRpZ2l0cyB0byBhcHBlYXIgZm9yCgkJCWQsIG8sIHgsIGFuZCBYIGNvbnZlcnNpb25zLCBvciB0aGUgbWF4aW11bSBudW1iZXIgb2YKCQkJYnl0ZXMgdG8gYmUgcHJpbnRlZCBmcm9tIGEgc3RyaW5nIGZvciBzIGNvbnZlcnNpb25zLgoJCQlGb3IgZmxvYXRpbmcgcG9pbnQgaXQgaXMgdGhlIG51bWJlciBvZiBkaWdpdHMgYWZ0ZXIKCQkJdGhlIGRlY2ltYWwgcG9pbnQuCgoJCXR5cGUKCQkJQSBjaGFyYWN0ZXIgdGhhdCBzcGVjaWZpZXMgdGhlIHR5cGUgb2YgY29udmVyc2lvbiB0bwoJCQliZSBhcHBsaWVkLCBzZWUgYmVsb3cuCgoJCUEgZmllbGQgd2lkdGggb3IgcHJlY2lzaW9uLCBvciBib3RoLCBtYXkgYmUgaW5kaWNhdGVkIGJ5IGFuCgkJYXN0ZXJpc2sgJyonIGluc3RlYWQgb2YgYSBkaWdpdCBzdHJpbmcuICBJbiB0aGlzIGNhc2UsIGEKCQlOdW1iZXIgYXJndW1lbnQgc3VwcGxpZXMgdGhlIGZpZWxkIHdpZHRoIG9yIHByZWNpc2lvbi4JQQoJCW5lZ2F0aXZlIGZpZWxkIHdpZHRoIGlzIHRyZWF0ZWQgYXMgYSBsZWZ0IGFkanVzdG1lbnQgZmxhZwoJCWZvbGxvd2VkIGJ5IGEgcG9zaXRpdmUgZmllbGQgd2lkdGg7IGEgbmVnYXRpdmUgcHJlY2lzaW9uIGlzCgkJdHJlYXRlZCBhcyB0aG91Z2ggaXQgd2VyZSBtaXNzaW5nLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBwcmludGYoIiVkOiAlLipzIiwgbnIsIHdpZHRoLCBsaW5lKQo8CQlUaGlzIGxpbWl0cyB0aGUgbGVuZ3RoIG9mIHRoZSB0ZXh0IHVzZWQgZnJvbSAibGluZSIgdG8KCQkid2lkdGgiIGJ5dGVzLgoKCQlUaGUgY29udmVyc2lvbiBzcGVjaWZpZXJzIGFuZCB0aGVpciBtZWFuaW5ncyBhcmU6CgoJCQkJKnByaW50Zi1kKiAqcHJpbnRmLW8qICpwcmludGYteCogKnByaW50Zi1YKgoJCWRveFgJVGhlIE51bWJlciBhcmd1bWVudCBpcyBjb252ZXJ0ZWQgdG8gc2lnbmVkIGRlY2ltYWwKCQkJKGQpLCB1bnNpZ25lZCBvY3RhbCAobyksIG9yIHVuc2lnbmVkIGhleGFkZWNpbWFsICh4CgkJCWFuZCBYKSBub3RhdGlvbi4gIFRoZSBsZXR0ZXJzICJhYmNkZWYiIGFyZSB1c2VkIGZvcgoJCQl4IGNvbnZlcnNpb25zOyB0aGUgbGV0dGVycyAiQUJDREVGIiBhcmUgdXNlZCBmb3IgWAoJCQljb252ZXJzaW9ucy4KCQkJVGhlIHByZWNpc2lvbiwgaWYgYW55LCBnaXZlcyB0aGUgbWluaW11bSBudW1iZXIgb2YKCQkJZGlnaXRzIHRoYXQgbXVzdCBhcHBlYXI7IGlmIHRoZSBjb252ZXJ0ZWQgdmFsdWUKCQkJcmVxdWlyZXMgZmV3ZXIgZGlnaXRzLCBpdCBpcyBwYWRkZWQgb24gdGhlIGxlZnQgd2l0aAoJCQl6ZXJvcy4KCQkJSW4gbm8gY2FzZSBkb2VzIGEgbm9uLWV4aXN0ZW50IG9yIHNtYWxsIGZpZWxkIHdpZHRoCgkJCWNhdXNlIHRydW5jYXRpb24gb2YgYSBudW1lcmljIGZpZWxkOyBpZiB0aGUgcmVzdWx0IG9mCgkJCWEgY29udmVyc2lvbiBpcyB3aWRlciB0aGFuIHRoZSBmaWVsZCB3aWR0aCwgdGhlIGZpZWxkCgkJCWlzIGV4cGFuZGVkIHRvIGNvbnRhaW4gdGhlIGNvbnZlcnNpb24gcmVzdWx0LgoKCQkJCQkJCSpwcmludGYtYyoKCQljCVRoZSBOdW1iZXIgYXJndW1lbnQgaXMgY29udmVydGVkIHRvIGEgYnl0ZSwgYW5kIHRoZQoJCQlyZXN1bHRpbmcgY2hhcmFjdGVyIGlzIHdyaXR0ZW4uCgoJCQkJCQkJKnByaW50Zi1zKgoJCXMJVGhlIHRleHQgb2YgdGhlIFN0cmluZyBhcmd1bWVudCBpcyB1c2VkLiAgSWYgYQoJCQlwcmVjaXNpb24gaXMgc3BlY2lmaWVkLCBubyBtb3JlIGJ5dGVzIHRoYW4gdGhlIG51bWJlcgoJCQlzcGVjaWZpZWQgYXJlIHVzZWQuCgoJCQkJCQkJKnByaW50Zi1mKiAqRTgwNyoKCQlmCVRoZSBGbG9hdCBhcmd1bWVudCBpcyBjb252ZXJ0ZWQgaW50byBhIHN0cmluZyBvZiB0aGUgCgkJCWZvcm0gMTIzLjQ1Ni4gIFRoZSBwcmVjaXNpb24gc3BlY2lmaWVzIHRoZSBudW1iZXIgb2YKCQkJZGlnaXRzIGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50LiAgV2hlbiB0aGUgcHJlY2lzaW9uIGlzCgkJCXplcm8gdGhlIGRlY2ltYWwgcG9pbnQgaXMgb21pdHRlZC4gIFdoZW4gdGhlIHByZWNpc2lvbgoJCQlpcyBub3Qgc3BlY2lmaWVkIDYgaXMgdXNlZC4gIEEgcmVhbGx5IGJpZyBudW1iZXIKCQkJKG91dCBvZiByYW5nZSBvciBkaXZpZGluZyBieSB6ZXJvKSByZXN1bHRzIGluICJpbmYiLgoJCQkiMC4wIC8gMC4wIiByZXN1bHRzIGluICJuYW4iLgoJCQlFeGFtcGxlOiA+CgkJCQllY2hvIHByaW50ZigiJS4yZiIsIDEyLjExNSkKPAkJCQkxMi4xMgoJCQlOb3RlIHRoYXQgcm91bmRvZmYgZGVwZW5kcyBvbiB0aGUgc3lzdGVtIGxpYnJhcmllcy4KCQkJVXNlIHxyb3VuZCgpfCB3aGVuIGluIGRvdWJ0LgoKCQkJCQkJCSpwcmludGYtZSogKnByaW50Zi1FKgoJCWUgRQlUaGUgRmxvYXQgYXJndW1lbnQgaXMgY29udmVydGVkIGludG8gYSBzdHJpbmcgb2YgdGhlCgkJCWZvcm0gMS4yMzRlKzAzIG9yIDEuMjM0RSswMyB3aGVuIHVzaW5nICdFJy4gIFRoZQoJCQlwcmVjaXNpb24gc3BlY2lmaWVzIHRoZSBudW1iZXIgb2YgZGlnaXRzIGFmdGVyIHRoZQoJCQlkZWNpbWFsIHBvaW50LCBsaWtlIHdpdGggJ2YnLgoKCQkJCQkJCSpwcmludGYtZyogKnByaW50Zi1HKgoJCWcgRwlUaGUgRmxvYXQgYXJndW1lbnQgaXMgY29udmVydGVkIGxpa2Ugd2l0aCAnZicgaWYgdGhlCgkJCXZhbHVlIGlzIGJldHdlZW4gMC4wMDEgKGluY2x1c2l2ZSkgYW5kIDEwMDAwMDAwLjAKCQkJKGV4Y2x1c2l2ZSkuICBPdGhlcndpc2UgJ2UnIGlzIHVzZWQgZm9yICdnJyBhbmQgJ0UnCgkJCWZvciAnRycuICBXaGVuIG5vIHByZWNpc2lvbiBpcyBzcGVjaWZpZWQgc3VwZXJmbHVvdXMKCQkJemVyb2VzIGFuZCAnKycgc2lnbnMgYXJlIHJlbW92ZWQsIGV4Y2VwdCBmb3IgdGhlIHplcm8KCQkJaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuICBUaHVzIDEwMDAwMDAwLjAKCQkJcmVzdWx0cyBpbiAxLjBlNy4KCgkJCQkJCQkqcHJpbnRmLSUqCgkJJQlBICclJyBpcyB3cml0dGVuLiAgTm8gYXJndW1lbnQgaXMgY29udmVydGVkLiAgVGhlCgkJCWNvbXBsZXRlIGNvbnZlcnNpb24gc3BlY2lmaWNhdGlvbiBpcyAiJSUiLgoKCQlXaGVuIGEgTnVtYmVyIGFyZ3VtZW50IGlzIGV4cGVjdGVkIGEgU3RyaW5nIGFyZ3VtZW50IGlzIGFsc28KCQlhY2NlcHRlZCBhbmQgYXV0b21hdGljYWxseSBjb252ZXJ0ZWQuCgkJV2hlbiBhIEZsb2F0IG9yIFN0cmluZyBhcmd1bWVudCBpcyBleHBlY3RlZCBhIE51bWJlciBhcmd1bWVudAoJCWlzIGFsc28gYWNjZXB0ZWQgYW5kIGF1dG9tYXRpY2FsbHkgY29udmVydGVkLgoJCUFueSBvdGhlciBhcmd1bWVudCB0eXBlIHJlc3VsdHMgaW4gYW4gZXJyb3IgbWVzc2FnZS4KCgkJCQkJCQkqRTc2NiogKkU3NjcqCgkJVGhlIG51bWJlciBvZiB7ZXhwck59IGFyZ3VtZW50cyBtdXN0IGV4YWN0bHkgbWF0Y2ggdGhlIG51bWJlcgoJCW9mICIlIiBpdGVtcy4gIElmIHRoZXJlIGFyZSBub3Qgc3VmZmljaWVudCBvciB0b28gbWFueQoJCWFyZ3VtZW50cyBhbiBlcnJvciBpcyBnaXZlbi4gIFVwIHRvIDE4IGFyZ3VtZW50cyBjYW4gYmUgdXNlZC4KCgpwdW12aXNpYmxlKCkJCQkJCQkqcHVtdmlzaWJsZSgpKgoJCVJldHVybnMgbm9uLXplcm8gd2hlbiB0aGUgcG9wdXAgbWVudSBpcyB2aXNpYmxlLCB6ZXJvCgkJb3RoZXJ3aXNlLiAgU2VlIHxpbnMtY29tcGxldGlvbi1tZW51fC4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIGF2b2lkIHNvbWUgdGhpbmdzIHRoYXQgd291bGQgcmVtb3ZlIHRoZQoJCXBvcHVwIG1lbnUuCgoJCQkJCQkJKkU3MjYqICpFNzI3KgpyYW5nZSh7ZXhwcn0gWywge21heH0gWywge3N0cmlkZX1dXSkJCQkJKnJhbmdlKCkqCgkJUmV0dXJucyBhIHxMaXN0fCB3aXRoIE51bWJlcnM6CgkJLSBJZiBvbmx5IHtleHByfSBpcyBzcGVjaWZpZWQ6IFswLCAxLCAuLi4sIHtleHByfSAtIDFdCgkJLSBJZiB7bWF4fSBpcyBzcGVjaWZpZWQ6IFt7ZXhwcn0sIHtleHByfSArIDEsIC4uLiwge21heH1dCgkJLSBJZiB7c3RyaWRlfSBpcyBzcGVjaWZpZWQ6IFt7ZXhwcn0sIHtleHByfSArIHtzdHJpZGV9LCAuLi4sCgkJICB7bWF4fV0gKGluY3JlYXNpbmcge2V4cHJ9IHdpdGgge3N0cmlkZX0gZWFjaCB0aW1lLCBub3QKCQkgIHByb2R1Y2luZyBhIHZhbHVlIHBhc3Qge21heH0pLgoJCVdoZW4gdGhlIG1heGltdW0gaXMgb25lIGJlZm9yZSB0aGUgc3RhcnQgdGhlIHJlc3VsdCBpcyBhbgoJCWVtcHR5IGxpc3QuICBXaGVuIHRoZSBtYXhpbXVtIGlzIG1vcmUgdGhhbiBvbmUgYmVmb3JlIHRoZQoJCXN0YXJ0IHRoaXMgaXMgYW4gZXJyb3IuCgkJRXhhbXBsZXM6ID4KCQkJcmFuZ2UoNCkJCSIgWzAsIDEsIDIsIDNdCgkJCXJhbmdlKDIsIDQpCQkiIFsyLCAzLCA0XQoJCQlyYW5nZSgyLCA5LCAzKQkJIiBbMiwgNSwgOF0KCQkJcmFuZ2UoMiwgLTIsIC0xKQkiIFsyLCAxLCAwLCAtMSwgLTJdCgkJCXJhbmdlKDApCQkiIFtdCgkJCXJhbmdlKDIsIDApCQkiIGVycm9yIQo8CgkJCQkJCQkqcmVhZGZpbGUoKSoKcmVhZGZpbGUoe2ZuYW1lfSBbLCB7YmluYXJ5fSBbLCB7bWF4fV1dKQoJCVJlYWQgZmlsZSB7Zm5hbWV9IGFuZCByZXR1cm4gYSB8TGlzdHwsIGVhY2ggbGluZSBvZiB0aGUgZmlsZQoJCWFzIGFuIGl0ZW0uICBMaW5lcyBicm9rZW4gYXQgTkwgY2hhcmFjdGVycy4gIE1hY2ludG9zaCBmaWxlcwoJCXNlcGFyYXRlZCB3aXRoIENSIHdpbGwgcmVzdWx0IGluIGEgc2luZ2xlIGxvbmcgbGluZSAodW5sZXNzIGEKCQlOTCBhcHBlYXJzIHNvbWV3aGVyZSkuCgkJQWxsIE5VTCBjaGFyYWN0ZXJzIGFyZSByZXBsYWNlZCB3aXRoIGEgTkwgY2hhcmFjdGVyLgoJCVdoZW4ge2JpbmFyeX0gaXMgZXF1YWwgdG8gImIiIGJpbmFyeSBtb2RlIGlzIHVzZWQ6CgkJLSBXaGVuIHRoZSBsYXN0IGxpbmUgZW5kcyBpbiBhIE5MIGFuIGV4dHJhIGVtcHR5IGxpc3QgaXRlbSBpcwoJCSAgYWRkZWQuCgkJLSBObyBDUiBjaGFyYWN0ZXJzIGFyZSByZW1vdmVkLgoJCU90aGVyd2lzZToKCQktIENSIGNoYXJhY3RlcnMgdGhhdCBhcHBlYXIgYmVmb3JlIGEgTkwgYXJlIHJlbW92ZWQuCgkJLSBXaGV0aGVyIHRoZSBsYXN0IGxpbmUgZW5kcyBpbiBhIE5MIG9yIG5vdCBkb2VzIG5vdCBtYXR0ZXIuCgkJLSBXaGVuICdlbmNvZGluZycgaXMgVW5pY29kZSBhbnkgVVRGLTggYnl0ZSBvcmRlciBtYXJrIGlzCgkJICByZW1vdmVkIGZyb20gdGhlIHRleHQuCgkJV2hlbiB7bWF4fSBpcyBnaXZlbiB0aGlzIHNwZWNpZmllcyB0aGUgbWF4aW11bSBudW1iZXIgb2YgbGluZXMKCQl0byBiZSByZWFkLiAgVXNlZnVsIGlmIHlvdSBvbmx5IHdhbnQgdG8gY2hlY2sgdGhlIGZpcnN0IHRlbgoJCWxpbmVzIG9mIGEgZmlsZTogPgoJCQk6Zm9yIGxpbmUgaW4gcmVhZGZpbGUoZm5hbWUsICcnLCAxMCkKCQkJOiAgaWYgbGluZSA9fiAnRGF0ZScgfCBlY2hvIGxpbmUgfCBlbmRpZgoJCQk6ZW5kZm9yCjwJCVdoZW4ge21heH0gaXMgbmVnYXRpdmUgLXttYXh9IGxpbmVzIGZyb20gdGhlIGVuZCBvZiB0aGUgZmlsZQoJCWFyZSByZXR1cm5lZCwgb3IgYXMgbWFueSBhcyB0aGVyZSBhcmUuCgkJV2hlbiB7bWF4fSBpcyB6ZXJvIHRoZSByZXN1bHQgaXMgYW4gZW1wdHkgbGlzdC4KCQlOb3RlIHRoYXQgd2l0aG91dCB7bWF4fSB0aGUgd2hvbGUgZmlsZSBpcyByZWFkIGludG8gbWVtb3J5LgoJCUFsc28gbm90ZSB0aGF0IHRoZXJlIGlzIG5vIHJlY29nbml0aW9uIG9mIGVuY29kaW5nLiAgUmVhZCBhCgkJZmlsZSBpbnRvIGEgYnVmZmVyIGlmIHlvdSBuZWVkIHRvLgoJCVdoZW4gdGhlIGZpbGUgY2FuJ3QgYmUgb3BlbmVkIGFuIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4gYW5kCgkJdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBsaXN0LgoJCUFsc28gc2VlIHx3cml0ZWZpbGUoKXwuCgpyZWx0aW1lKFt7c3RhcnR9IFssIHtlbmR9XV0pCQkJCSpyZWx0aW1lKCkqCgkJUmV0dXJuIGFuIGl0ZW0gdGhhdCByZXByZXNlbnRzIGEgdGltZSB2YWx1ZS4gIFRoZSBmb3JtYXQgb2YKCQl0aGUgaXRlbSBkZXBlbmRzIG9uIHRoZSBzeXN0ZW0uICBJdCBjYW4gYmUgcGFzc2VkIHRvCgkJfHJlbHRpbWVzdHIoKXwgdG8gY29udmVydCBpdCB0byBhIHN0cmluZy4KCQlXaXRob3V0IGFuIGFyZ3VtZW50IGl0IHJldHVybnMgdGhlIGN1cnJlbnQgdGltZS4KCQlXaXRoIG9uZSBhcmd1bWVudCBpcyByZXR1cm5zIHRoZSB0aW1lIHBhc3NlZCBzaW5jZSB0aGUgdGltZQoJCXNwZWNpZmllZCBpbiB0aGUgYXJndW1lbnQuCgkJV2l0aCB0d28gYXJndW1lbnRzIGl0IHJldHVybnMgdGhlIHRpbWUgcGFzc2VkIGJldHdlZW4ge3N0YXJ0fQoJCWFuZCB7ZW5kfS4KCQlUaGUge3N0YXJ0fSBhbmQge2VuZH0gYXJndW1lbnRzIG11c3QgYmUgdmFsdWVzIHJldHVybmVkIGJ5CgkJcmVsdGltZSgpLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCnJlbHRpbWVzdHIoe3RpbWV9KQkJCQkqcmVsdGltZXN0cigpKgoJCVJldHVybiBhIFN0cmluZyB0aGF0IHJlcHJlc2VudHMgdGhlIHRpbWUgdmFsdWUgb2Yge3RpbWV9LgoJCVRoaXMgaXMgdGhlIG51bWJlciBvZiBzZWNvbmRzLCBhIGRvdCBhbmQgdGhlIG51bWJlciBvZgoJCW1pY3Jvc2Vjb25kcy4gIEV4YW1wbGU6ID4KCQkJbGV0IHN0YXJ0ID0gcmVsdGltZSgpCgkJCWNhbGwgTXlGdW5jdGlvbigpCgkJCWVjaG8gcmVsdGltZXN0cihyZWx0aW1lKHN0YXJ0KSkKPAkJTm90ZSB0aGF0IG92ZXJoZWFkIGZvciB0aGUgY29tbWFuZHMgd2lsbCBiZSBhZGRlZCB0byB0aGUgdGltZS4KCQlUaGUgYWNjdXJhY3kgZGVwZW5kcyBvbiB0aGUgc3lzdGVtLgoJCUxlYWRpbmcgc3BhY2VzIGFyZSB1c2VkIHRvIG1ha2UgdGhlIHN0cmluZyBhbGlnbiBuaWNlbHkuICBZb3UKCQljYW4gdXNlIHNwbGl0KCkgdG8gcmVtb3ZlIGl0LiA+CgkJCWVjaG8gc3BsaXQocmVsdGltZXN0cihyZWx0aW1lKHN0YXJ0KSkpWzBdCjwJCUFsc28gc2VlIHxwcm9maWxpbmd8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCgkJCQkJCQkqcmVtb3RlX2V4cHIoKSogKkU0NDkqCnJlbW90ZV9leHByKHtzZXJ2ZXJ9LCB7c3RyaW5nfSBbLCB7aWR2YXJ9XSkKCQlTZW5kIHRoZSB7c3RyaW5nfSB0byB7c2VydmVyfS4JVGhlIHN0cmluZyBpcyBzZW50IGFzIGFuCgkJZXhwcmVzc2lvbiBhbmQgdGhlIHJlc3VsdCBpcyByZXR1cm5lZCBhZnRlciBldmFsdWF0aW9uLgoJCVRoZSByZXN1bHQgbXVzdCBiZSBhIFN0cmluZyBvciBhIHxMaXN0fC4gIEEgfExpc3R8IGlzIHR1cm5lZAoJCWludG8gYSBTdHJpbmcgYnkgam9pbmluZyB0aGUgaXRlbXMgd2l0aCBhIGxpbmUgYnJlYWsgaW4KCQliZXR3ZWVuIChub3QgYXQgdGhlIGVuZCksIGxpa2Ugd2l0aCBqb2luKGV4cHIsICJcbiIpLgoJCUlmIHtpZHZhcn0gaXMgcHJlc2VudCwgaXQgaXMgdGFrZW4gYXMgdGhlIG5hbWUgb2YgYQoJCXZhcmlhYmxlIGFuZCBhIHtzZXJ2ZXJpZH0gZm9yIGxhdGVyIHVzZSB3aXRoCgkJcmVtb3RlX3JlYWQoKSBpcyBzdG9yZWQgdGhlcmUuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwgfFJlbW90ZVJlcGx5fC4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NsaWVudHNlcnZlcnwgZmVhdHVyZX0KCQlOb3RlOiBBbnkgZXJyb3JzIHdpbGwgY2F1c2UgYSBsb2NhbCBlcnJvciBtZXNzYWdlIHRvIGJlIGlzc3VlZAoJCWFuZCB0aGUgcmVzdWx0IHdpbGwgYmUgdGhlIGVtcHR5IHN0cmluZy4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyByZW1vdGVfZXhwcigiZ3ZpbSIsICIyKzIiKQoJCQk6ZWNobyByZW1vdGVfZXhwcigiZ3ZpbTEiLCAiYjpjdXJyZW50X3N5bnRheCIpCjwKCnJlbW90ZV9mb3JlZ3JvdW5kKHtzZXJ2ZXJ9KQkJCQkqcmVtb3RlX2ZvcmVncm91bmQoKSoKCQlNb3ZlIHRoZSBWaW0gc2VydmVyIHdpdGggdGhlIG5hbWUge3NlcnZlcn0gdG8gdGhlIGZvcmVncm91bmQuCgkJVGhpcyB3b3JrcyBsaWtlOiA+CgkJCXJlbW90ZV9leHByKHtzZXJ2ZXJ9LCAiZm9yZWdyb3VuZCgpIikKPAkJRXhjZXB0IHRoYXQgb24gV2luMzIgc3lzdGVtcyB0aGUgY2xpZW50IGRvZXMgdGhlIHdvcmssIHRvIHdvcmsKCQlhcm91bmQgdGhlIHByb2JsZW0gdGhhdCB0aGUgT1MgZG9lc24ndCBhbHdheXMgYWxsb3cgdGhlIHNlcnZlcgoJCXRvIGJyaW5nIGl0c2VsZiB0byB0aGUgZm9yZWdyb3VuZC4KCQlOb3RlOiBUaGlzIGRvZXMgbm90IHJlc3RvcmUgdGhlIHdpbmRvdyBpZiBpdCB3YXMgbWluaW1pemVkLAoJCWxpa2UgZm9yZWdyb3VuZCgpIGRvZXMuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgaW4gdGhlIFdpbjMyLCBBdGhlbmEsIE1vdGlmIGFuZCBHVEsgR1VJIHZlcnNpb25zIGFuZCB0aGUKCQlXaW4zMiBjb25zb2xlIHZlcnNpb259CgoKcmVtb3RlX3BlZWsoe3NlcnZlcmlkfSBbLCB7cmV0dmFyfV0pCQkqcmVtb3RlX3BlZWsoKSoKCQlSZXR1cm5zIGEgcG9zaXRpdmUgbnVtYmVyIGlmIHRoZXJlIGFyZSBhdmFpbGFibGUgc3RyaW5ncwoJCWZyb20ge3NlcnZlcmlkfS4gIENvcGllcyBhbnkgcmVwbHkgc3RyaW5nIGludG8gdGhlIHZhcmlhYmxlCgkJe3JldHZhcn0gaWYgc3BlY2lmaWVkLgl7cmV0dmFyfSBtdXN0IGJlIGEgc3RyaW5nIHdpdGggdGhlCgkJbmFtZSBvZiBhIHZhcmlhYmxlLgoJCVJldHVybnMgemVybyBpZiBub25lIGFyZSBhdmFpbGFibGUuCgkJUmV0dXJucyAtMSBpZiBzb21ldGhpbmcgaXMgd3JvbmcuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJRXhhbXBsZXM6ID4KCQkJOmxldCByZXBsID0gIiIKCQkJOmVjaG8gIlBFRUs6ICIucmVtb3RlX3BlZWsoaWQsICJyZXBsIikuIjogIi5yZXBsCgpyZW1vdGVfcmVhZCh7c2VydmVyaWR9KQkJCQkqcmVtb3RlX3JlYWQoKSoKCQlSZXR1cm4gdGhlIG9sZGVzdCBhdmFpbGFibGUgcmVwbHkgZnJvbSB7c2VydmVyaWR9IGFuZCBjb25zdW1lCgkJaXQuICBJdCBibG9ja3MgdW50aWwgYSByZXBseSBpcyBhdmFpbGFibGUuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJRXhhbXBsZTogPgoJCQk6ZWNobyByZW1vdGVfcmVhZChpZCkKPAoJCQkJCQkJKnJlbW90ZV9zZW5kKCkqICpFMjQxKgpyZW1vdGVfc2VuZCh7c2VydmVyfSwge3N0cmluZ30gWywge2lkdmFyfV0pCgkJU2VuZCB0aGUge3N0cmluZ30gdG8ge3NlcnZlcn0uCVRoZSBzdHJpbmcgaXMgc2VudCBhcyBpbnB1dAoJCWtleXMgYW5kIHRoZSBmdW5jdGlvbiByZXR1cm5zIGltbWVkaWF0ZWx5LiAgQXQgdGhlIFZpbSBzZXJ2ZXIKCQl0aGUga2V5cyBhcmUgbm90IG1hcHBlZCB8Om1hcHwuCgkJSWYge2lkdmFyfSBpcyBwcmVzZW50LCBpdCBpcyB0YWtlbiBhcyB0aGUgbmFtZSBvZiBhIHZhcmlhYmxlCgkJYW5kIGEge3NlcnZlcmlkfSBmb3IgbGF0ZXIgdXNlIHdpdGggcmVtb3RlX3JlYWQoKSBpcyBzdG9yZWQKCQl0aGVyZS4KCQlTZWUgYWxzbyB8Y2xpZW50c2VydmVyfCB8UmVtb3RlUmVwbHl8LgoJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2xpZW50c2VydmVyfCBmZWF0dXJlfQoJCU5vdGU6IEFueSBlcnJvcnMgd2lsbCBiZSByZXBvcnRlZCBpbiB0aGUgc2VydmVyIGFuZCBtYXkgbWVzcwoJCXVwIHRoZSBkaXNwbGF5LgoJCUV4YW1wbGVzOiA+CgkJOmVjaG8gcmVtb3RlX3NlbmQoImd2aW0iLCAiOkRyb3BBbmRSZXBseSAiLmZpbGUsICJzZXJ2ZXJpZCIpLgoJCSBcIHJlbW90ZV9yZWFkKHNlcnZlcmlkKQoKCQk6YXV0b2NtZCBOT05FIFJlbW90ZVJlcGx5ICoKCQkgXCBlY2hvIHJlbW90ZV9yZWFkKGV4cGFuZCgiPGFtYXRjaD4iKSkKCQk6ZWNobyByZW1vdGVfc2VuZCgiZ3ZpbSIsICI6c2xlZXAgMTAgfCBlY2hvICIuCgkJIFwgJ3NlcnZlcjJjbGllbnQoZXhwYW5kKCI8Y2xpZW50PiIpLCAiSEVMTE8iKTxDUj4nKQo8CnJlbW92ZSh7bGlzdH0sIHtpZHh9IFssIHtlbmR9XSkJCQkJKnJlbW92ZSgpKgoJCVdpdGhvdXQge2VuZH06IFJlbW92ZSB0aGUgaXRlbSBhdCB7aWR4fSBmcm9tIHxMaXN0fCB7bGlzdH0gYW5kCgkJcmV0dXJuIHRoZSBpdGVtLgoJCVdpdGgge2VuZH06IFJlbW92ZSBpdGVtcyBmcm9tIHtpZHh9IHRvIHtlbmR9IChpbmNsdXNpdmUpIGFuZAoJCXJldHVybiBhIExpc3Qgd2l0aCB0aGVzZSBpdGVtcy4gIFdoZW4ge2lkeH0gcG9pbnRzIHRvIHRoZSBzYW1lCgkJaXRlbSBhcyB7ZW5kfSBhIGxpc3Qgd2l0aCBvbmUgaXRlbSBpcyByZXR1cm5lZC4gIFdoZW4ge2VuZH0KCQlwb2ludHMgdG8gYW4gaXRlbSBiZWZvcmUge2lkeH0gdGhpcyBpcyBhbiBlcnJvci4KCQlTZWUgfGxpc3QtaW5kZXh8IGZvciBwb3NzaWJsZSB2YWx1ZXMgb2Yge2lkeH0gYW5kIHtlbmR9LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gImxhc3QgaXRlbTogIiAuIHJlbW92ZShteWxpc3QsIC0xKQoJCQk6Y2FsbCByZW1vdmUobXlsaXN0LCAwLCA5KQpyZW1vdmUoe2RpY3R9LCB7a2V5fSkKCQlSZW1vdmUgdGhlIGVudHJ5IGZyb20ge2RpY3R9IHdpdGgga2V5IHtrZXl9LiAgRXhhbXBsZTogPgoJCQk6ZWNobyAicmVtb3ZlZCAiIC4gcmVtb3ZlKGRpY3QsICJvbmUiKQo8CQlJZiB0aGVyZSBpcyBubyB7a2V5fSBpbiB7ZGljdH0gdGhpcyBpcyBhbiBlcnJvci4KCgkJVXNlIHxkZWxldGUoKXwgdG8gcmVtb3ZlIGEgZmlsZS4KCnJlbmFtZSh7ZnJvbX0sIHt0b30pCQkJCQkqcmVuYW1lKCkqCgkJUmVuYW1lIHRoZSBmaWxlIGJ5IHRoZSBuYW1lIHtmcm9tfSB0byB0aGUgbmFtZSB7dG99LiAgVGhpcwoJCXNob3VsZCBhbHNvIHdvcmsgdG8gbW92ZSBmaWxlcyBhY3Jvc3MgZmlsZSBzeXN0ZW1zLiAgVGhlCgkJcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyAwIGlmIHRoZSBmaWxlIHdhcyByZW5hbWVkCgkJc3VjY2Vzc2Z1bGx5LCBhbmQgbm9uLXplcm8gd2hlbiB0aGUgcmVuYW1pbmcgZmFpbGVkLgoJCU5PVEU6IElmIHt0b30gZXhpc3RzIGl0IGlzIG92ZXJ3cml0dGVuIHdpdGhvdXQgd2FybmluZy4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCnJlcGVhdCh7ZXhwcn0sIHtjb3VudH0pCQkJCQkqcmVwZWF0KCkqCgkJUmVwZWF0IHtleHByfSB7Y291bnR9IHRpbWVzIGFuZCByZXR1cm4gdGhlIGNvbmNhdGVuYXRlZAoJCXJlc3VsdC4gIEV4YW1wbGU6ID4KCQkJOmxldCBzZXBhcmF0b3IgPSByZXBlYXQoJy0nLCA4MCkKPAkJV2hlbiB7Y291bnR9IGlzIHplcm8gb3IgbmVnYXRpdmUgdGhlIHJlc3VsdCBpcyBlbXB0eS4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCB0aGUgcmVzdWx0IGlzIHtleHByfSBjb25jYXRlbmF0ZWQKCQl7Y291bnR9IHRpbWVzLglFeGFtcGxlOiA+CgkJCTpsZXQgbG9uZ2xpc3QgPSByZXBlYXQoWydhJywgJ2InXSwgMykKPAkJUmVzdWx0cyBpbiBbJ2EnLCAnYicsICdhJywgJ2InLCAnYScsICdiJ10uCgoKcmVzb2x2ZSh7ZmlsZW5hbWV9KQkJCQkJKnJlc29sdmUoKSogKkU2NTUqCgkJT24gTVMtV2luZG93cywgd2hlbiB7ZmlsZW5hbWV9IGlzIGEgc2hvcnRjdXQgKGEgLmxuayBmaWxlKSwKCQlyZXR1cm5zIHRoZSBwYXRoIHRoZSBzaG9ydGN1dCBwb2ludHMgdG8gaW4gYSBzaW1wbGlmaWVkIGZvcm0uCgkJT24gVW5peCwgcmVwZWF0IHJlc29sdmluZyBzeW1ib2xpYyBsaW5rcyBpbiBhbGwgcGF0aAoJCWNvbXBvbmVudHMgb2Yge2ZpbGVuYW1lfSBhbmQgcmV0dXJuIHRoZSBzaW1wbGlmaWVkIHJlc3VsdC4KCQlUbyBjb3BlIHdpdGggbGluayBjeWNsZXMsIHJlc29sdmluZyBvZiBzeW1ib2xpYyBsaW5rcyBpcwoJCXN0b3BwZWQgYWZ0ZXIgMTAwIGl0ZXJhdGlvbnMuCgkJT24gb3RoZXIgc3lzdGVtcywgcmV0dXJuIHRoZSBzaW1wbGlmaWVkIHtmaWxlbmFtZX0uCgkJVGhlIHNpbXBsaWZpY2F0aW9uIHN0ZXAgaXMgZG9uZSBhcyBieSB8c2ltcGxpZnkoKXwuCgkJcmVzb2x2ZSgpIGtlZXBzIGEgbGVhZGluZyBwYXRoIGNvbXBvbmVudCBzcGVjaWZ5aW5nIHRoZQoJCWN1cnJlbnQgZGlyZWN0b3J5IChwcm92aWRlZCB0aGUgcmVzdWx0IGlzIHN0aWxsIGEgcmVsYXRpdmUKCQlwYXRoIG5hbWUpIGFuZCBhbHNvIGtlZXBzIGEgdHJhaWxpbmcgcGF0aCBzZXBhcmF0b3IuCgoJCQkJCQkJKnJldmVyc2UoKSoKcmV2ZXJzZSh7bGlzdH0pCVJldmVyc2UgdGhlIG9yZGVyIG9mIGl0ZW1zIGluIHtsaXN0fSBpbi1wbGFjZS4JUmV0dXJucwoJCXtsaXN0fS4KCQlJZiB5b3Ugd2FudCBhIGxpc3QgdG8gcmVtYWluIHVubW9kaWZpZWQgbWFrZSBhIGNvcHkgZmlyc3Q6ID4KCQkJOmxldCByZXZsaXN0ID0gcmV2ZXJzZShjb3B5KG15bGlzdCkpCgpyb3VuZCh7ZXhwcn0pCQkJCQkJCSpyb3VuZCgpKgoJCVJvdW5kIG9mZiB7ZXhwcn0gdG8gdGhlIG5lYXJlc3QgaW50ZWdyYWwgdmFsdWUgYW5kIHJldHVybiBpdAoJCWFzIGEgfEZsb2F0fC4gIElmIHtleHByfSBsaWVzIGhhbGZ3YXkgYmV0d2VlbiB0d28gaW50ZWdyYWwKCQl2YWx1ZXMsIHRoZW4gdXNlIHRoZSBsYXJnZXIgb25lIChhd2F5IGZyb20gemVybykuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJZWNobyByb3VuZCgwLjQ1NikKPAkJCTAuMCAgPgoJCQllY2hvIHJvdW5kKDQuNSkKPAkJCTUuMCA+CgkJCWVjaG8gcm91bmQoLTQuNSkKPAkJCS01LjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoJCQoJCQpzZWFyY2goe3BhdHRlcm59IFssIHtmbGFnc30gWywge3N0b3BsaW5lfSBbLCB7dGltZW91dH1dXV0pCSpzZWFyY2goKSoKCQlTZWFyY2ggZm9yIHJlZ2V4cCBwYXR0ZXJuIHtwYXR0ZXJufS4gIFRoZSBzZWFyY2ggc3RhcnRzIGF0IHRoZQoJCWN1cnNvciBwb3NpdGlvbiAoeW91IGNhbiB1c2UgfGN1cnNvcigpfCB0byBzZXQgaXQpLgoKCQlJZiB0aGVyZSBpcyBubyBtYXRjaCBhIDAgaXMgcmV0dXJuZWQgYW5kIHRoZSBjdXJzb3IgZG9lc24ndAoJCW1vdmUuICBObyBlcnJvciBtZXNzYWdlIGlzIGdpdmVuLgoJCVdoZW4gYSBtYXRjaCBoYXMgYmVlbiBmb3VuZCBpdHMgbGluZSBudW1iZXIgaXMgcmV0dXJuZWQuCgoJCXtmbGFnc30gaXMgYSBTdHJpbmcsIHdoaWNoIGNhbiBjb250YWluIHRoZXNlIGNoYXJhY3RlciBmbGFnczoKCQknYicJc2VhcmNoIGJhY2t3YXJkIGluc3RlYWQgb2YgZm9yd2FyZAoJCSdjJwlhY2NlcHQgYSBtYXRjaCBhdCB0aGUgY3Vyc29yIHBvc2l0aW9uCgkJJ2UnCW1vdmUgdG8gdGhlIEVuZCBvZiB0aGUgbWF0Y2gKCQknbicJZG8gTm90IG1vdmUgdGhlIGN1cnNvcgoJCSdwJwlyZXR1cm4gbnVtYmVyIG9mIG1hdGNoaW5nIHN1Yi1wYXR0ZXJuIChzZWUgYmVsb3cpCgkJJ3MnCXNldCB0aGUgJyBtYXJrIGF0IHRoZSBwcmV2aW91cyBsb2NhdGlvbiBvZiB0aGUgY3Vyc29yCgkJJ3cnCXdyYXAgYXJvdW5kIHRoZSBlbmQgb2YgdGhlIGZpbGUKCQknVycJZG9uJ3Qgd3JhcCBhcm91bmQgdGhlIGVuZCBvZiB0aGUgZmlsZQoJCUlmIG5laXRoZXIgJ3cnIG9yICdXJyBpcyBnaXZlbiwgdGhlICd3cmFwc2Nhbicgb3B0aW9uIGFwcGxpZXMuCgoJCUlmIHRoZSAncycgZmxhZyBpcyBzdXBwbGllZCwgdGhlICcgbWFyayBpcyBzZXQsIG9ubHkgaWYgdGhlCgkJY3Vyc29yIGlzIG1vdmVkLiBUaGUgJ3MnIGZsYWcgY2Fubm90IGJlIGNvbWJpbmVkIHdpdGggdGhlICduJwoJCWZsYWcuCgoJCSdpZ25vcmVjYXNlJywgJ3NtYXJ0Y2FzZScgYW5kICdtYWdpYycgYXJlIHVzZWQuCgoJCVdoZW4gdGhlIHtzdG9wbGluZX0gYXJndW1lbnQgaXMgZ2l2ZW4gdGhlbiB0aGUgc2VhcmNoIHN0b3BzCgkJYWZ0ZXIgc2VhcmNoaW5nIHRoaXMgbGluZS4gIFRoaXMgaXMgdXNlZnVsIHRvIHJlc3RyaWN0IHRoZQoJCXNlYXJjaCB0byBhIHJhbmdlIG9mIGxpbmVzLiAgRXhhbXBsZXM6ID4KCQkJbGV0IG1hdGNoID0gc2VhcmNoKCcoJywgJ2InLCBsaW5lKCJ3MCIpKQoJCQlsZXQgZW5kID0gc2VhcmNoKCdFTkQnLCAnJywgbGluZSgidyQiKSkKPAkJV2hlbiB7c3RvcGxpbmV9IGlzIHVzZWQgYW5kIGl0IGlzIG5vdCB6ZXJvIHRoaXMgYWxzbyBpbXBsaWVzCgkJdGhhdCB0aGUgc2VhcmNoIGRvZXMgbm90IHdyYXAgYXJvdW5kIHRoZSBlbmQgb2YgdGhlIGZpbGUuCgkJQSB6ZXJvIHZhbHVlIGlzIGVxdWFsIHRvIG5vdCBnaXZpbmcgdGhlIGFyZ3VtZW50LgoKCQlXaGVuIHRoZSB7dGltZW91dH0gYXJndW1lbnQgaXMgZ2l2ZW4gdGhlIHNlYXJjaCBzdG9wcyB3aGVuCgkJbW9yZSB0aGFuIHRoaXMgbWFueSBtaWxsaSBzZWNvbmRzIGhhdmUgcGFzc2VkLglUaHVzIHdoZW4KCQl7dGltZW91dH0gaXMgNTAwIHRoZSBzZWFyY2ggc3RvcHMgYWZ0ZXIgaGFsZiBhIHNlY29uZC4KCQlUaGUgdmFsdWUgbXVzdCBub3QgYmUgbmVnYXRpdmUuICBBIHplcm8gdmFsdWUgaXMgbGlrZSBub3QKCQlnaXZpbmcgdGhlIGFyZ3VtZW50LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCgkJCQkJCQkqc2VhcmNoKCktc3ViLW1hdGNoKgoJCVdpdGggdGhlICdwJyBmbGFnIHRoZSByZXR1cm5lZCB2YWx1ZSBpcyBvbmUgbW9yZSB0aGFuIHRoZQoJCWZpcnN0IHN1Yi1tYXRjaCBpbiBcKFwpLiAgT25lIGlmIG5vbmUgb2YgdGhlbSBtYXRjaGVkIGJ1dCB0aGUKCQl3aG9sZSBwYXR0ZXJuIGRpZCBtYXRjaC4KCQlUbyBnZXQgdGhlIGNvbHVtbiBudW1iZXIgdG9vIHVzZSB8c2VhcmNocG9zKCl8LgoKCQlUaGUgY3Vyc29yIHdpbGwgYmUgcG9zaXRpb25lZCBhdCB0aGUgbWF0Y2gsIHVubGVzcyB0aGUgJ24nCgkJZmxhZyBpcyB1c2VkLgoKCQlFeGFtcGxlIChnb2VzIG92ZXIgYWxsIGZpbGVzIGluIHRoZSBhcmd1bWVudCBsaXN0KTogPgoJCSAgICA6bGV0IG4gPSAxCgkJICAgIDp3aGlsZSBuIDw9IGFyZ2MoKQkgICAgIiBsb29wIG92ZXIgYWxsIGZpbGVzIGluIGFyZ2xpc3QKCQkgICAgOiAgZXhlICJhcmd1bWVudCAiIC4gbgoJCSAgICA6ICAiIHN0YXJ0IGF0IHRoZSBsYXN0IGNoYXIgaW4gdGhlIGZpbGUgYW5kIHdyYXAgZm9yIHRoZQoJCSAgICA6ICAiIGZpcnN0IHNlYXJjaCB0byBmaW5kIG1hdGNoIGF0IHN0YXJ0IG9mIGZpbGUKCQkgICAgOiAgbm9ybWFsIEckCgkJICAgIDogIGxldCBmbGFncyA9ICJ3IgoJCSAgICA6ICB3aGlsZSBzZWFyY2goImZvbyIsIGZsYWdzKSA+IDAKCQkgICAgOgkgcy9mb28vYmFyL2cKCQkgICAgOgkgbGV0IGZsYWdzID0gIlciCgkJICAgIDogIGVuZHdoaWxlCgkJICAgIDogIHVwZGF0ZQkJICAgICIgd3JpdGUgdGhlIGZpbGUgaWYgbW9kaWZpZWQKCQkgICAgOiAgbGV0IG4gPSBuICsgMQoJCSAgICA6ZW5kd2hpbGUKPAoJCUV4YW1wbGUgZm9yIHVzaW5nIHNvbWUgZmxhZ3M6ID4KCQkgICAgOmVjaG8gc2VhcmNoKCdcPGlmXHxcKGVsc2VcKVx8XChlbmRpZlwpJywgJ25jcGUnKQo8CQlUaGlzIHdpbGwgc2VhcmNoIGZvciB0aGUga2V5d29yZHMgImlmIiwgImVsc2UiLCBhbmQgImVuZGlmIgoJCXVuZGVyIG9yIGFmdGVyIHRoZSBjdXJzb3IuICBCZWNhdXNlIG9mIHRoZSAncCcgZmxhZywgaXQKCQlyZXR1cm5zIDEsIDIsIG9yIDMgZGVwZW5kaW5nIG9uIHdoaWNoIGtleXdvcmQgaXMgZm91bmQsIG9yIDAKCQlpZiB0aGUgc2VhcmNoIGZhaWxzLiAgV2l0aCB0aGUgY3Vyc29yIG9uIHRoZSBmaXJzdCB3b3JkIG9mIHRoZQoJCWxpbmU6CgkJICAgIGlmIChmb28gPT0gMCkgfCBsZXQgZm9vID0gZm9vICsgMSB8IGVuZGlmIH4KCQl0aGUgZnVuY3Rpb24gcmV0dXJucyAxLiAgV2l0aG91dCB0aGUgJ2MnIGZsYWcsIHRoZSBmdW5jdGlvbgoJCWZpbmRzIHRoZSAiZW5kaWYiIGFuZCByZXR1cm5zIDMuICBUaGUgc2FtZSB0aGluZyBoYXBwZW5zCgkJd2l0aG91dCB0aGUgJ2UnIGZsYWcgaWYgdGhlIGN1cnNvciBpcyBvbiB0aGUgImYiIG9mICJpZiIuCgkJVGhlICduJyBmbGFnIHRlbGxzIHRoZSBmdW5jdGlvbiBub3QgdG8gbW92ZSB0aGUgY3Vyc29yLgoKCnNlYXJjaGRlY2woe25hbWV9IFssIHtnbG9iYWx9IFssIHt0aGlzYmxvY2t9XV0pCQkJKnNlYXJjaGRlY2woKSoKCQlTZWFyY2ggZm9yIHRoZSBkZWNsYXJhdGlvbiBvZiB7bmFtZX0uCgoJCVdpdGggYSBub24temVybyB7Z2xvYmFsfSBhcmd1bWVudCBpdCB3b3JrcyBsaWtlIHxnRHwsIGZpbmQKCQlmaXJzdCBtYXRjaCBpbiB0aGUgZmlsZS4gIE90aGVyd2lzZSBpdCB3b3JrcyBsaWtlIHxnZHwsIGZpbmQKCQlmaXJzdCBtYXRjaCBpbiB0aGUgZnVuY3Rpb24uCgoJCVdpdGggYSBub24temVybyB7dGhpc2Jsb2NrfSBhcmd1bWVudCBtYXRjaGVzIGluIGEge30gYmxvY2sKCQl0aGF0IGVuZHMgYmVmb3JlIHRoZSBjdXJzb3IgcG9zaXRpb24gYXJlIGlnbm9yZWQuICBBdm9pZHMKCQlmaW5kaW5nIHZhcmlhYmxlIGRlY2xhcmF0aW9ucyBvbmx5IHZhbGlkIGluIGFub3RoZXIgc2NvcGUuCgoJCU1vdmVzIHRoZSBjdXJzb3IgdG8gdGhlIGZvdW5kIG1hdGNoLgoJCVJldHVybnMgemVybyBmb3Igc3VjY2Vzcywgbm9uLXplcm8gZm9yIGZhaWx1cmUuCgkJRXhhbXBsZTogPgoJCQlpZiBzZWFyY2hkZWNsKCdteXZhcicpID09IDAKCQkJICAgZWNobyBnZXRsaW5lKCcuJykKCQkJZW5kaWYKPAoJCQkJCQkJKnNlYXJjaHBhaXIoKSoKc2VhcmNocGFpcih7c3RhcnR9LCB7bWlkZGxlfSwge2VuZH0gWywge2ZsYWdzfSBbLCB7c2tpcH0KCQkJCVssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dXSkKCQlTZWFyY2ggZm9yIHRoZSBtYXRjaCBvZiBhIG5lc3RlZCBzdGFydC1lbmQgcGFpci4gIFRoaXMgY2FuIGJlCgkJdXNlZCB0byBmaW5kIHRoZSAiZW5kaWYiIHRoYXQgbWF0Y2hlcyBhbiAiaWYiLCB3aGlsZSBvdGhlcgoJCWlmL2VuZGlmIHBhaXJzIGluIGJldHdlZW4gYXJlIGlnbm9yZWQuCgkJVGhlIHNlYXJjaCBzdGFydHMgYXQgdGhlIGN1cnNvci4gIFRoZSBkZWZhdWx0IGlzIHRvIHNlYXJjaAoJCWZvcndhcmQsIGluY2x1ZGUgJ2InIGluIHtmbGFnc30gdG8gc2VhcmNoIGJhY2t3YXJkLgoJCUlmIGEgbWF0Y2ggaXMgZm91bmQsIHRoZSBjdXJzb3IgaXMgcG9zaXRpb25lZCBhdCBpdCBhbmQgdGhlCgkJbGluZSBudW1iZXIgaXMgcmV0dXJuZWQuICBJZiBubyBtYXRjaCBpcyBmb3VuZCAwIG9yIC0xIGlzCgkJcmV0dXJuZWQgYW5kIHRoZSBjdXJzb3IgZG9lc24ndCBtb3ZlLiAgTm8gZXJyb3IgbWVzc2FnZSBpcwoJCWdpdmVuLgoKCQl7c3RhcnR9LCB7bWlkZGxlfSBhbmQge2VuZH0gYXJlIHBhdHRlcm5zLCBzZWUgfHBhdHRlcm58LiAgVGhleQoJCW11c3Qgbm90IGNvbnRhaW4gXCggXCkgcGFpcnMuICBVc2Ugb2YgXCUoIFwpIGlzIGFsbG93ZWQuICBXaGVuCgkJe21pZGRsZX0gaXMgbm90IGVtcHR5LCBpdCBpcyBmb3VuZCB3aGVuIHNlYXJjaGluZyBmcm9tIGVpdGhlcgoJCWRpcmVjdGlvbiwgYnV0IG9ubHkgd2hlbiBub3QgaW4gYSBuZXN0ZWQgc3RhcnQtZW5kIHBhaXIuICBBCgkJdHlwaWNhbCB1c2UgaXM6ID4KCQkJc2VhcmNocGFpcignXDxpZlw+JywgJ1w8ZWxzZVw+JywgJ1w8ZW5kaWZcPicpCjwJCUJ5IGxlYXZpbmcge21pZGRsZX0gZW1wdHkgdGhlICJlbHNlIiBpcyBza2lwcGVkLgoKCQl7ZmxhZ3N9ICdiJywgJ2MnLCAnbicsICdzJywgJ3cnIGFuZCAnVycgYXJlIHVzZWQgbGlrZSB3aXRoCgkJfHNlYXJjaCgpfC4gIEFkZGl0aW9uYWxseToKCQkncicJUmVwZWF0IHVudGlsIG5vIG1vcmUgbWF0Y2hlcyBmb3VuZDsgd2lsbCBmaW5kIHRoZQoJCQlvdXRlciBwYWlyLiAgSW1wbGllcyB0aGUgJ1cnIGZsYWcuCgkJJ20nCVJldHVybiBudW1iZXIgb2YgbWF0Y2hlcyBpbnN0ZWFkIG9mIGxpbmUgbnVtYmVyIHdpdGgKCQkJdGhlIG1hdGNoOyB3aWxsIGJlID4gMSB3aGVuICdyJyBpcyB1c2VkLgoJCU5vdGU6IGl0J3MgbmVhcmx5IGFsd2F5cyBhIGdvb2QgaWRlYSB0byB1c2UgdGhlICdXJyBmbGFnLCB0bwoJCWF2b2lkIHdyYXBwaW5nIGFyb3VuZCB0aGUgZW5kIG9mIHRoZSBmaWxlLgoKCQlXaGVuIGEgbWF0Y2ggZm9yIHtzdGFydH0sIHttaWRkbGV9IG9yIHtlbmR9IGlzIGZvdW5kLCB0aGUKCQl7c2tpcH0gZXhwcmVzc2lvbiBpcyBldmFsdWF0ZWQgd2l0aCB0aGUgY3Vyc29yIHBvc2l0aW9uZWQgb24KCQl0aGUgc3RhcnQgb2YgdGhlIG1hdGNoLiAgSXQgc2hvdWxkIHJldHVybiBub24temVybyBpZiB0aGlzCgkJbWF0Y2ggaXMgdG8gYmUgc2tpcHBlZC4gIEUuZy4sIGJlY2F1c2UgaXQgaXMgaW5zaWRlIGEgY29tbWVudAoJCW9yIGEgc3RyaW5nLgoJCVdoZW4ge3NraXB9IGlzIG9taXR0ZWQgb3IgZW1wdHksIGV2ZXJ5IG1hdGNoIGlzIGFjY2VwdGVkLgoJCVdoZW4gZXZhbHVhdGluZyB7c2tpcH0gY2F1c2VzIGFuIGVycm9yIHRoZSBzZWFyY2ggaXMgYWJvcnRlZAoJCWFuZCAtMSByZXR1cm5lZC4KCgkJRm9yIHtzdG9wbGluZX0gYW5kIHt0aW1lb3V0fSBzZWUgfHNlYXJjaCgpfC4KCgkJVGhlIHZhbHVlIG9mICdpZ25vcmVjYXNlJyBpcyB1c2VkLiAgJ21hZ2ljJyBpcyBpZ25vcmVkLCB0aGUKCQlwYXR0ZXJucyBhcmUgdXNlZCBsaWtlIGl0J3Mgb24uCgoJCVRoZSBzZWFyY2ggc3RhcnRzIGV4YWN0bHkgYXQgdGhlIGN1cnNvci4gIEEgbWF0Y2ggd2l0aAoJCXtzdGFydH0sIHttaWRkbGV9IG9yIHtlbmR9IGF0IHRoZSBuZXh0IGNoYXJhY3RlciwgaW4gdGhlCgkJZGlyZWN0aW9uIG9mIHNlYXJjaGluZywgaXMgdGhlIGZpcnN0IG9uZSBmb3VuZC4gIEV4YW1wbGU6ID4KCQkJaWYgMQoJCQkgIGlmIDIKCQkJICBlbmRpZiAyCgkJCWVuZGlmIDEKPAkJV2hlbiBzdGFydGluZyBhdCB0aGUgImlmIDIiLCB3aXRoIHRoZSBjdXJzb3Igb24gdGhlICJpIiwgYW5kCgkJc2VhcmNoaW5nIGZvcndhcmRzLCB0aGUgImVuZGlmIDIiIGlzIGZvdW5kLiAgV2hlbiBzdGFydGluZyBvbgoJCXRoZSBjaGFyYWN0ZXIganVzdCBiZWZvcmUgdGhlICJpZiAyIiwgdGhlICJlbmRpZiAxIiB3aWxsIGJlCgkJZm91bmQuCVRoYXQncyBiZWNhdXNlIHRoZSAiaWYgMiIgd2lsbCBiZSBmb3VuZCBmaXJzdCwgYW5kCgkJdGhlbiB0aGlzIGlzIGNvbnNpZGVyZWQgdG8gYmUgYSBuZXN0ZWQgaWYvZW5kaWYgZnJvbSAiaWYgMiIgdG8KCQkiZW5kaWYgMiIuCgkJV2hlbiBzZWFyY2hpbmcgYmFja3dhcmRzIGFuZCB7ZW5kfSBpcyBtb3JlIHRoYW4gb25lIGNoYXJhY3RlciwKCQlpdCBtYXkgYmUgdXNlZnVsIHRvIHB1dCAiXHpzIiBhdCB0aGUgZW5kIG9mIHRoZSBwYXR0ZXJuLCBzbwoJCXRoYXQgd2hlbiB0aGUgY3Vyc29yIGlzIGluc2lkZSBhIG1hdGNoIHdpdGggdGhlIGVuZCBpdCBmaW5kcwoJCXRoZSBtYXRjaGluZyBzdGFydC4KCgkJRXhhbXBsZSwgdG8gZmluZCB0aGUgImVuZGlmIiBjb21tYW5kIGluIGEgVmltIHNjcmlwdDogPgoKCTplY2hvIHNlYXJjaHBhaXIoJ1w8aWZcPicsICdcPGVsXCVbc2VpZl1cPicsICdcPGVuXCVbZGlmXVw+JywgJ1cnLAoJCQlcICdnZXRsaW5lKCIuIikgPX4gIl5cXHMqXCIiJykKCjwJCVRoZSBjdXJzb3IgbXVzdCBiZSBhdCBvciBhZnRlciB0aGUgImlmIiBmb3Igd2hpY2ggYSBtYXRjaCBpcwoJCXRvIGJlIGZvdW5kLiAgTm90ZSB0aGF0IHNpbmdsZS1xdW90ZSBzdHJpbmdzIGFyZSB1c2VkIHRvIGF2b2lkCgkJaGF2aW5nIHRvIGRvdWJsZSB0aGUgYmFja3NsYXNoZXMuICBUaGUgc2tpcCBleHByZXNzaW9uIG9ubHkKCQljYXRjaGVzIGNvbW1lbnRzIGF0IHRoZSBzdGFydCBvZiBhIGxpbmUsIG5vdCBhZnRlciBhIGNvbW1hbmQuCgkJQWxzbywgYSB3b3JkICJlbiIgb3IgImlmIiBoYWxmd2F5IGEgbGluZSBpcyBjb25zaWRlcmVkIGEKCQltYXRjaC4KCQlBbm90aGVyIGV4YW1wbGUsIHRvIHNlYXJjaCBmb3IgdGhlIG1hdGNoaW5nICJ7IiBvZiBhICJ9IjogPgoKCTplY2hvIHNlYXJjaHBhaXIoJ3snLCAnJywgJ30nLCAnYlcnKQoKPAkJVGhpcyB3b3JrcyB3aGVuIHRoZSBjdXJzb3IgaXMgYXQgb3IgYmVmb3JlIHRoZSAifSIgZm9yIHdoaWNoIGEKCQltYXRjaCBpcyB0byBiZSBmb3VuZC4gIFRvIHJlamVjdCBtYXRjaGVzIHRoYXQgc3ludGF4CgkJaGlnaGxpZ2h0aW5nIHJlY29nbml6ZWQgYXMgc3RyaW5nczogPgoKCTplY2hvIHNlYXJjaHBhaXIoJ3snLCAnJywgJ30nLCAnYlcnLAoJICAgICBcICdzeW5JRGF0dHIoc3luSUQobGluZSgiLiIpLCBjb2woIi4iKSwgMCksICJuYW1lIikgPX4/ICJzdHJpbmciJykKPAoJCQkJCQkJKnNlYXJjaHBhaXJwb3MoKSoKc2VhcmNocGFpcnBvcyh7c3RhcnR9LCB7bWlkZGxlfSwge2VuZH0gWywge2ZsYWdzfSBbLCB7c2tpcH0KCQkJCVssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dXSkKCQlTYW1lIGFzIHxzZWFyY2hwYWlyKCl8LCBidXQgcmV0dXJucyBhIHxMaXN0fCB3aXRoIHRoZSBsaW5lIGFuZAoJCWNvbHVtbiBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guIFRoZSBmaXJzdCBlbGVtZW50IG9mIHRoZSB8TGlzdHwKCQlpcyB0aGUgbGluZSBudW1iZXIgYW5kIHRoZSBzZWNvbmQgZWxlbWVudCBpcyB0aGUgYnl0ZSBpbmRleCBvZgoJCXRoZSBjb2x1bW4gcG9zaXRpb24gb2YgdGhlIG1hdGNoLiAgSWYgbm8gbWF0Y2ggaXMgZm91bmQsCgkJcmV0dXJucyBbMCwgMF0uID4KCgkJCTpsZXQgW2xudW0sY29sXSA9IHNlYXJjaHBhaXJwb3MoJ3snLCAnJywgJ30nLCAnbicpCjwKCQlTZWUgfG1hdGNoLXBhcmVuc3wgZm9yIGEgYmlnZ2VyIGFuZCBtb3JlIHVzZWZ1bCBleGFtcGxlLgoKc2VhcmNocG9zKHtwYXR0ZXJufSBbLCB7ZmxhZ3N9IFssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dKQkqc2VhcmNocG9zKCkqCgkJU2FtZSBhcyB8c2VhcmNoKCl8LCBidXQgcmV0dXJucyBhIHxMaXN0fCB3aXRoIHRoZSBsaW5lIGFuZAoJCWNvbHVtbiBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guIFRoZSBmaXJzdCBlbGVtZW50IG9mIHRoZSB8TGlzdHwKCQlpcyB0aGUgbGluZSBudW1iZXIgYW5kIHRoZSBzZWNvbmQgZWxlbWVudCBpcyB0aGUgYnl0ZSBpbmRleCBvZgoJCXRoZSBjb2x1bW4gcG9zaXRpb24gb2YgdGhlIG1hdGNoLiBJZiBubyBtYXRjaCBpcyBmb3VuZCwKCQlyZXR1cm5zIFswLCAwXS4KCQlFeGFtcGxlOiA+Cgk6bGV0IFtsbnVtLCBjb2xdID0gc2VhcmNocG9zKCdteXBhdHRlcm4nLCAnbicpCgo8CQlXaGVuIHRoZSAncCcgZmxhZyBpcyBnaXZlbiB0aGVuIHRoZXJlIGlzIGFuIGV4dHJhIGl0ZW0gd2l0aAoJCXRoZSBzdWItcGF0dGVybiBtYXRjaCBudW1iZXIgfHNlYXJjaCgpLXN1Yi1tYXRjaHwuICBFeGFtcGxlOiA+Cgk6bGV0IFtsbnVtLCBjb2wsIHN1Ym1hdGNoXSA9IHNlYXJjaHBvcygnXChcbFwpXHxcKFx1XCknLCAnbnAnKQo8CQlJbiB0aGlzIGV4YW1wbGUgInN1Ym1hdGNoIiBpcyAyIHdoZW4gYSBsb3dlcmNhc2UgbGV0dGVyIGlzCgkJZm91bmQgfC9cbHwsIDMgd2hlbiBhbiB1cHBlcmNhc2UgbGV0dGVyIGlzIGZvdW5kIHwvXHV8LgoKc2VydmVyMmNsaWVudCgge2NsaWVudGlkfSwge3N0cmluZ30pCQkJKnNlcnZlcjJjbGllbnQoKSoKCQlTZW5kIGEgcmVwbHkgc3RyaW5nIHRvIHtjbGllbnRpZH0uICBUaGUgbW9zdCByZWNlbnQge2NsaWVudGlkfQoJCXRoYXQgc2VudCBhIHN0cmluZyBjYW4gYmUgcmV0cmlldmVkIHdpdGggZXhwYW5kKCI8Y2xpZW50PiIpLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2xpZW50c2VydmVyfCBmZWF0dXJlfQoJCU5vdGU6CgkJVGhpcyBpZCBoYXMgdG8gYmUgc3RvcmVkIGJlZm9yZSB0aGUgbmV4dCBjb21tYW5kIGNhbiBiZQoJCXJlY2VpdmVkLiAgSS5lLiBiZWZvcmUgcmV0dXJuaW5nIGZyb20gdGhlIHJlY2VpdmVkIGNvbW1hbmQgYW5kCgkJYmVmb3JlIGNhbGxpbmcgYW55IGNvbW1hbmRzIHRoYXQgd2FpdHMgZm9yIGlucHV0LgoJCVNlZSBhbHNvIHxjbGllbnRzZXJ2ZXJ8LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gc2VydmVyMmNsaWVudChleHBhbmQoIjxjbGllbnQ+IiksICJIRUxMTyIpCjwKc2VydmVybGlzdCgpCQkJCQkqc2VydmVybGlzdCgpKgoJCVJldHVybiBhIGxpc3Qgb2YgYXZhaWxhYmxlIHNlcnZlciBuYW1lcywgb25lIHBlciBsaW5lLgoJCVdoZW4gdGhlcmUgYXJlIG5vIHNlcnZlcnMgb3IgdGhlIGluZm9ybWF0aW9uIGlzIG5vdCBhdmFpbGFibGUKCQlhbiBlbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuICBTZWUgYWxzbyB8Y2xpZW50c2VydmVyfC4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NsaWVudHNlcnZlcnwgZmVhdHVyZX0KCQlFeGFtcGxlOiA+CgkJCTplY2hvIHNlcnZlcmxpc3QoKQo8CnNldGJ1ZnZhcih7ZXhwcn0sIHt2YXJuYW1lfSwge3ZhbH0pCQkJKnNldGJ1ZnZhcigpKgoJCVNldCBvcHRpb24gb3IgbG9jYWwgdmFyaWFibGUge3Zhcm5hbWV9IGluIGJ1ZmZlciB7ZXhwcn0gdG8KCQl7dmFsfS4KCQlUaGlzIGFsc28gd29ya3MgZm9yIGEgZ2xvYmFsIG9yIGxvY2FsIHdpbmRvdyBvcHRpb24sIGJ1dCBpdAoJCWRvZXNuJ3Qgd29yayBmb3IgYSBnbG9iYWwgb3IgbG9jYWwgd2luZG93IHZhcmlhYmxlLgoJCUZvciBhIGxvY2FsIHdpbmRvdyBvcHRpb24gdGhlIGdsb2JhbCB2YWx1ZSBpcyB1bmNoYW5nZWQuCgkJRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9LCBzZWUgfGJ1Zm5hbWUoKXwgYWJvdmUuCgkJTm90ZSB0aGF0IHRoZSB2YXJpYWJsZSBuYW1lIHdpdGhvdXQgImI6IiBtdXN0IGJlIHVzZWQuCgkJRXhhbXBsZXM6ID4KCQkJOmNhbGwgc2V0YnVmdmFyKDEsICImbW9kIiwgMSkKCQkJOmNhbGwgc2V0YnVmdmFyKCJ0b2RvIiwgIm15dmFyIiwgImZvb2JhciIpCjwJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoKc2V0Y21kcG9zKHtwb3N9KQkJCQkJKnNldGNtZHBvcygpKgoJCVNldCB0aGUgY3Vyc29yIHBvc2l0aW9uIGluIHRoZSBjb21tYW5kIGxpbmUgdG8gYnl0ZSBwb3NpdGlvbgoJCXtwb3N9LglUaGUgZmlyc3QgcG9zaXRpb24gaXMgMS4KCQlVc2UgfGdldGNtZHBvcygpfCB0byBvYnRhaW4gdGhlIGN1cnJlbnQgcG9zaXRpb24uCgkJT25seSB3b3JrcyB3aGlsZSBlZGl0aW5nIHRoZSBjb21tYW5kIGxpbmUsIHRodXMgeW91IG11c3QgdXNlCgkJfGNfQ1RSTC1cX2V8LCB8Y19DVFJMLVJfPXwgb3IgfGNfQ1RSTC1SX0NUUkwtUnwgd2l0aCAnPScuICBGb3IKCQl8Y19DVFJMLVxfZXwgYW5kIHxjX0NUUkwtUl9DVFJMLVJ8IHdpdGggJz0nIHRoZSBwb3NpdGlvbiBpcwoJCXNldCBhZnRlciB0aGUgY29tbWFuZCBsaW5lIGlzIHNldCB0byB0aGUgZXhwcmVzc2lvbi4gIEZvcgoJCXxjX0NUUkwtUl89fCBpdCBpcyBzZXQgYWZ0ZXIgZXZhbHVhdGluZyB0aGUgZXhwcmVzc2lvbiBidXQKCQliZWZvcmUgaW5zZXJ0aW5nIHRoZSByZXN1bHRpbmcgdGV4dC4KCQlXaGVuIHRoZSBudW1iZXIgaXMgdG9vIGJpZyB0aGUgY3Vyc29yIGlzIHB1dCBhdCB0aGUgZW5kIG9mIHRoZQoJCWxpbmUuICBBIG51bWJlciBzbWFsbGVyIHRoYW4gb25lIGhhcyB1bmRlZmluZWQgcmVzdWx0cy4KCQlSZXR1cm5zIDAgd2hlbiBzdWNjZXNzZnVsLCAxIHdoZW4gbm90IGVkaXRpbmcgdGhlIGNvbW1hbmQKCQlsaW5lLgoKc2V0bGluZSh7bG51bX0sIHt0ZXh0fSkJCQkJCSpzZXRsaW5lKCkqCgkJU2V0IGxpbmUge2xudW19IG9mIHRoZSBjdXJyZW50IGJ1ZmZlciB0byB7dGV4dH0uICBUbyBpbnNlcnQKCQlsaW5lcyB1c2UgfGFwcGVuZCgpfC4KCQl7bG51bX0gaXMgdXNlZCBsaWtlIHdpdGggfGdldGxpbmUoKXwuCgkJV2hlbiB7bG51bX0gaXMganVzdCBiZWxvdyB0aGUgbGFzdCBsaW5lIHRoZSB7dGV4dH0gd2lsbCBiZQoJCWFkZGVkIGFzIGEgbmV3IGxpbmUuCgkJSWYgdGhpcyBzdWNjZWVkcywgMCBpcyByZXR1cm5lZC4gIElmIHRoaXMgZmFpbHMgKG1vc3QgbGlrZWx5CgkJYmVjYXVzZSB7bG51bX0gaXMgaW52YWxpZCkgMSBpcyByZXR1cm5lZC4gIEV4YW1wbGU6ID4KCQkJOmNhbGwgc2V0bGluZSg1LCBzdHJmdGltZSgiJWMiKSkKPAkJV2hlbiB7dGV4dH0gaXMgYSB8TGlzdHwgdGhlbiBsaW5lIHtsbnVtfSBhbmQgZm9sbG93aW5nIGxpbmVzCgkJd2lsbCBiZSBzZXQgdG8gdGhlIGl0ZW1zIGluIHRoZSBsaXN0LiAgRXhhbXBsZTogPgoJCQk6Y2FsbCBzZXRsaW5lKDUsIFsnYWFhJywgJ2JiYicsICdjY2MnXSkKPAkJVGhpcyBpcyBlcXVpdmFsZW50IHRvOiA+CgkJCTpmb3IgW24sIGxdIGluIFtbNSwgNiwgN10sIFsnYWFhJywgJ2JiYicsICdjY2MnXV0KCQkJOiAgY2FsbCBzZXRsaW5lKG4sIGwpCgkJCTplbmRmb3IKPAkJTm90ZTogVGhlICdbIGFuZCAnXSBtYXJrcyBhcmUgbm90IHNldC4KCnNldGxvY2xpc3Qoe25yfSwge2xpc3R9IFssIHthY3Rpb259XSkJCQkqc2V0bG9jbGlzdCgpKgoJCUNyZWF0ZSBvciByZXBsYWNlIG9yIGFkZCB0byB0aGUgbG9jYXRpb24gbGlzdCBmb3Igd2luZG93IHtucn0uCgkJV2hlbiB7bnJ9IGlzIHplcm8gdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuIEZvciBhIGxvY2F0aW9uCgkJbGlzdCB3aW5kb3csIHRoZSBkaXNwbGF5ZWQgbG9jYXRpb24gbGlzdCBpcyBtb2RpZmllZC4gIEZvciBhbgoJCWludmFsaWQgd2luZG93IG51bWJlciB7bnJ9LCAtMSBpcyByZXR1cm5lZC4KCQlPdGhlcndpc2UsIHNhbWUgYXMgfHNldHFmbGlzdCgpfC4KCQlBbHNvIHNlZSB8bG9jYXRpb24tbGlzdHwuCgpzZXRtYXRjaGVzKHtsaXN0fSkJCQkJCSpzZXRtYXRjaGVzKCkqCgkJUmVzdG9yZXMgYSBsaXN0IG9mIG1hdGNoZXMgc2F2ZWQgYnkgfGdldG1hdGNoZXMoKXwuICBSZXR1cm5zIDAKCQlpZiBzdWNjZXNzZnVsLCBvdGhlcndpc2UgLTEuICBBbGwgY3VycmVudCBtYXRjaGVzIGFyZSBjbGVhcmVkCgkJYmVmb3JlIHRoZSBsaXN0IGlzIHJlc3RvcmVkLiAgU2VlIGV4YW1wbGUgZm9yIHxnZXRtYXRjaGVzKCl8LgoKCQkJCQkJCSpzZXRwb3MoKSoKc2V0cG9zKHtleHByfSwge2xpc3R9KQoJCVNldCB0aGUgcG9zaXRpb24gZm9yIHtleHByfS4gIFBvc3NpYmxlIHZhbHVlczoKCQkJLgl0aGUgY3Vyc29yCgkJCSd4CW1hcmsgeAoKCQl7bGlzdH0gbXVzdCBiZSBhIHxMaXN0fCB3aXRoIGZvdXIgbnVtYmVyczoKCQkgICAgW2J1Zm51bSwgbG51bSwgY29sLCBvZmZdCgoJCSJidWZudW0iIGlzIHRoZSBidWZmZXIgbnVtYmVyLglaZXJvIGNhbiBiZSB1c2VkIGZvciB0aGUKCQljdXJyZW50IGJ1ZmZlci4gIFNldHRpbmcgdGhlIGN1cnNvciBpcyBvbmx5IHBvc3NpYmxlIGZvcgoJCXRoZSBjdXJyZW50IGJ1ZmZlci4gIFRvIHNldCBhIG1hcmsgaW4gYW5vdGhlciBidWZmZXIgeW91IGNhbgoJCXVzZSB0aGUgfGJ1Zm5yKCl8IGZ1bmN0aW9uIHRvIHR1cm4gYSBmaWxlIG5hbWUgaW50byBhIGJ1ZmZlcgoJCW51bWJlci4KCQlEb2VzIG5vdCBjaGFuZ2UgdGhlIGp1bXBsaXN0LgoKCQkibG51bSIgYW5kICJjb2wiIGFyZSB0aGUgcG9zaXRpb24gaW4gdGhlIGJ1ZmZlci4gIFRoZSBmaXJzdAoJCWNvbHVtbiBpcyAxLiAgVXNlIGEgemVybyAibG51bSIgdG8gZGVsZXRlIGEgbWFyay4gIElmICJjb2wiIGlzCgkJc21hbGxlciB0aGFuIDEgdGhlbiAxIGlzIHVzZWQuCgoJCVRoZSAib2ZmIiBudW1iZXIgaXMgb25seSB1c2VkIHdoZW4gJ3ZpcnR1YWxlZGl0JyBpcyBzZXQuIFRoZW4KCQlpdCBpcyB0aGUgb2Zmc2V0IGluIHNjcmVlbiBjb2x1bW5zIGZyb20gdGhlIHN0YXJ0IG9mIHRoZQoJCWNoYXJhY3Rlci4gIEUuZy4sIGEgcG9zaXRpb24gd2l0aGluIGEgPFRhYj4gb3IgYWZ0ZXIgdGhlIGxhc3QKCQljaGFyYWN0ZXIuCgoJCVJldHVybnMgMCB3aGVuIHRoZSBwb3NpdGlvbiBjb3VsZCBiZSBzZXQsIC0xIG90aGVyd2lzZS4KCQlBbiBlcnJvciBtZXNzYWdlIGlzIGdpdmVuIGlmIHtleHByfSBpcyBpbnZhbGlkLgoKCQlBbHNvIHNlZSB8Z2V0cG9zKCl8CgoJCVRoaXMgZG9lcyBub3QgcmVzdG9yZSB0aGUgcHJlZmVycmVkIGNvbHVtbiBmb3IgbW92aW5nCgkJdmVydGljYWxseS4gIFNlZSB8d2lucmVzdHZpZXcoKXwgZm9yIHRoYXQuCgoKc2V0cWZsaXN0KHtsaXN0fSBbLCB7YWN0aW9ufV0pCQkJCSpzZXRxZmxpc3QoKSoKCQlDcmVhdGUgb3IgcmVwbGFjZSBvciBhZGQgdG8gdGhlIHF1aWNrZml4IGxpc3QgdXNpbmcgdGhlIGl0ZW1zCgkJaW4ge2xpc3R9LiAgRWFjaCBpdGVtIGluIHtsaXN0fSBpcyBhIGRpY3Rpb25hcnkuCgkJTm9uLWRpY3Rpb25hcnkgaXRlbXMgaW4ge2xpc3R9IGFyZSBpZ25vcmVkLiAgRWFjaCBkaWN0aW9uYXJ5CgkJaXRlbSBjYW4gY29udGFpbiB0aGUgZm9sbG93aW5nIGVudHJpZXM6CgoJCSAgICBidWZucglidWZmZXIgbnVtYmVyOyBtdXN0IGJlIHRoZSBudW1iZXIgb2YgYSB2YWxpZAoJCQkJYnVmZmVyCgkJICAgIGZpbGVuYW1lCW5hbWUgb2YgYSBmaWxlOyBvbmx5IHVzZWQgd2hlbiAiYnVmbnIiIGlzIG5vdAoJCQkJcHJlc2VudCBvciBpdCBpcyBpbnZhbGlkLgoJCSAgICBsbnVtCWxpbmUgbnVtYmVyIGluIHRoZSBmaWxlCgkJICAgIHBhdHRlcm4Jc2VhcmNoIHBhdHRlcm4gdXNlZCB0byBsb2NhdGUgdGhlIGVycm9yCgkJICAgIGNvbAkJY29sdW1uIG51bWJlcgoJCSAgICB2Y29sCXdoZW4gbm9uLXplcm86ICJjb2wiIGlzIHZpc3VhbCBjb2x1bW4KCQkJCXdoZW4gemVybzogImNvbCIgaXMgYnl0ZSBpbmRleAoJCSAgICBucgkJZXJyb3IgbnVtYmVyCgkJICAgIHRleHQJZGVzY3JpcHRpb24gb2YgdGhlIGVycm9yCgkJICAgIHR5cGUJc2luZ2xlLWNoYXJhY3RlciBlcnJvciB0eXBlLCAnRScsICdXJywgZXRjLgoKCQlUaGUgImNvbCIsICJ2Y29sIiwgIm5yIiwgInR5cGUiIGFuZCAidGV4dCIgZW50cmllcyBhcmUKCQlvcHRpb25hbC4gIEVpdGhlciAibG51bSIgb3IgInBhdHRlcm4iIGVudHJ5IGNhbiBiZSB1c2VkIHRvCgkJbG9jYXRlIGEgbWF0Y2hpbmcgZXJyb3IgbGluZS4KCQlJZiB0aGUgImZpbGVuYW1lIiBhbmQgImJ1Zm5yIiBlbnRyaWVzIGFyZSBub3QgcHJlc2VudCBvcgoJCW5laXRoZXIgdGhlICJsbnVtIiBvciAicGF0dGVybiIgZW50cmllcyBhcmUgcHJlc2VudCwgdGhlbiB0aGUKCQlpdGVtIHdpbGwgbm90IGJlIGhhbmRsZWQgYXMgYW4gZXJyb3IgbGluZS4KCQlJZiBib3RoICJwYXR0ZXJuIiBhbmQgImxudW0iIGFyZSBwcmVzZW50IHRoZW4gInBhdHRlcm4iIHdpbGwKCQliZSB1c2VkLgoJCUlmIHlvdSBzdXBwbHkgYW4gZW1wdHkge2xpc3R9LCB0aGUgcXVpY2tmaXggbGlzdCB3aWxsIGJlCgkJY2xlYXJlZC4KCQlOb3RlIHRoYXQgdGhlIGxpc3QgaXMgbm90IGV4YWN0bHkgdGhlIHNhbWUgYXMgd2hhdAoJCXxnZXRxZmxpc3QoKXwgcmV0dXJucy4KCgkJSWYge2FjdGlvbn0gaXMgc2V0IHRvICdhJywgdGhlbiB0aGUgaXRlbXMgZnJvbSB7bGlzdH0gYXJlCgkJYWRkZWQgdG8gdGhlIGV4aXN0aW5nIHF1aWNrZml4IGxpc3QuIElmIHRoZXJlIGlzIG5vIGV4aXN0aW5nCgkJbGlzdCwgdGhlbiBhIG5ldyBsaXN0IGlzIGNyZWF0ZWQuIElmIHthY3Rpb259IGlzIHNldCB0byAncicsCgkJdGhlbiB0aGUgaXRlbXMgZnJvbSB0aGUgY3VycmVudCBxdWlja2ZpeCBsaXN0IGFyZSByZXBsYWNlZAoJCXdpdGggdGhlIGl0ZW1zIGZyb20ge2xpc3R9LiBJZiB7YWN0aW9ufSBpcyBub3QgcHJlc2VudCBvciBpcwoJCXNldCB0byAnICcsIHRoZW4gYSBuZXcgbGlzdCBpcyBjcmVhdGVkLgoKCQlSZXR1cm5zIHplcm8gZm9yIHN1Y2Nlc3MsIC0xIGZvciBmYWlsdXJlLgoKCQlUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIHRvIGNyZWF0ZSBhIHF1aWNrZml4IGxpc3QKCQlpbmRlcGVuZGVudCBvZiB0aGUgJ2Vycm9yZm9ybWF0JyBzZXR0aW5nLiAgVXNlIGEgY29tbWFuZCBsaWtlCgkJIjpjYyAxIiB0byBqdW1wIHRvIHRoZSBmaXJzdCBwb3NpdGlvbi4KCgoJCQkJCQkJKnNldHJlZygpKgpzZXRyZWcoe3JlZ25hbWV9LCB7dmFsdWV9IFsse29wdGlvbnN9XSkKCQlTZXQgdGhlIHJlZ2lzdGVyIHtyZWduYW1lfSB0byB7dmFsdWV9LgoJCUlmIHtvcHRpb25zfSBjb250YWlucyAiYSIgb3Ige3JlZ25hbWV9IGlzIHVwcGVyIGNhc2UsCgkJdGhlbiB0aGUgdmFsdWUgaXMgYXBwZW5kZWQuCgkJe29wdGlvbnN9IGNhbiBhbHNvIGNvbnRhaW4gYSByZWdpc3RlciB0eXBlIHNwZWNpZmljYXRpb246CgkJICAgICJjIiBvciAidiIJICAgICAgfGNoYXJhY3Rlcndpc2V8IG1vZGUKCQkgICAgImwiIG9yICJWIgkgICAgICB8bGluZXdpc2V8IG1vZGUKCQkgICAgImIiIG9yICI8Q1RSTC1WPiIgfGJsb2Nrd2lzZS12aXN1YWx8IG1vZGUKCQlJZiBhIG51bWJlciBpbW1lZGlhdGVseSBmb2xsb3dzICJiIiBvciAiPENUUkwtVj4iIHRoZW4gdGhpcyBpcwoJCXVzZWQgYXMgdGhlIHdpZHRoIG9mIHRoZSBzZWxlY3Rpb24gLSBpZiBpdCBpcyBub3Qgc3BlY2lmaWVkCgkJdGhlbiB0aGUgd2lkdGggb2YgdGhlIGJsb2NrIGlzIHNldCB0byB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMKCQlpbiB0aGUgbG9uZ2VzdCBsaW5lIChjb3VudGluZyBhIDxUYWI+IGFzIDEgY2hhcmFjdGVyKS4KCgkJSWYge29wdGlvbnN9IGNvbnRhaW5zIG5vIHJlZ2lzdGVyIHNldHRpbmdzLCB0aGVuIHRoZSBkZWZhdWx0CgkJaXMgdG8gdXNlIGNoYXJhY3RlciBtb2RlIHVubGVzcyB7dmFsdWV9IGVuZHMgaW4gYSA8Tkw+LgoJCVNldHRpbmcgdGhlICc9JyByZWdpc3RlciBpcyBub3QgcG9zc2libGUuCgkJUmV0dXJucyB6ZXJvIGZvciBzdWNjZXNzLCBub24temVybyBmb3IgZmFpbHVyZS4KCgkJRXhhbXBsZXM6ID4KCQkJOmNhbGwgc2V0cmVnKHY6cmVnaXN0ZXIsIEAqKQoJCQk6Y2FsbCBzZXRyZWcoJyonLCBAJSwgJ2FjJykKCQkJOmNhbGwgc2V0cmVnKCdhJywgIjFcbjJcbjMiLCAnYjUnKQoKPAkJVGhpcyBleGFtcGxlIHNob3dzIHVzaW5nIHRoZSBmdW5jdGlvbnMgdG8gc2F2ZSBhbmQgcmVzdG9yZSBhCgkJcmVnaXN0ZXIuID4KCQkJOmxldCB2YXJfYSA9IGdldHJlZygnYScsIDEpCgkJCTpsZXQgdmFyX2Ftb2RlID0gZ2V0cmVndHlwZSgnYScpCgkJCSAgICAuLi4uCgkJCTpjYWxsIHNldHJlZygnYScsIHZhcl9hLCB2YXJfYW1vZGUpCgo8CQlZb3UgY2FuIGFsc28gY2hhbmdlIHRoZSB0eXBlIG9mIGEgcmVnaXN0ZXIgYnkgYXBwZW5kaW5nCgkJbm90aGluZzogPgoJCQk6Y2FsbCBzZXRyZWcoJ2EnLCAnJywgJ2FsJykKCnNldHRhYnZhcih7dGFibnJ9LCB7dmFybmFtZX0sIHt2YWx9KQkJCSpzZXR0YWJ2YXIoKSoKCQlTZXQgdGFiLWxvY2FsIHZhcmlhYmxlIHt2YXJuYW1lfSB0byB7dmFsfSBpbiB0YWIgcGFnZSB7dGFibnJ9LgoJCXx0OnZhcnwKCQlOb3RlIHRoYXQgdGhlIHZhcmlhYmxlIG5hbWUgd2l0aG91dCAidDoiIG11c3QgYmUgdXNlZC4KCQlUYWJzIGFyZSBudW1iZXJlZCBzdGFydGluZyB3aXRoIG9uZS4KCQlWaW0gYnJpZWZseSBnb2VzIHRvIHRoZSB0YWIgcGFnZSB7dGFibnJ9LCB0aGlzIG1heSB0cmlnZ2VyCgkJVGFiTGVhdmUgYW5kIFRhYkVudGVyIGF1dG9jb21tYW5kcy4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCnNldHRhYndpbnZhcih7dGFibnJ9LCB7d2lubnJ9LCB7dmFybmFtZX0sIHt2YWx9KQkqc2V0dGFid2ludmFyKCkqCgkJU2V0IG9wdGlvbiBvciBsb2NhbCB2YXJpYWJsZSB7dmFybmFtZX0gaW4gd2luZG93IHt3aW5ucn0gdG8KCQl7dmFsfS4KCQlUYWJzIGFyZSBudW1iZXJlZCBzdGFydGluZyB3aXRoIG9uZS4gIEZvciB0aGUgY3VycmVudCB0YWJwYWdlCgkJdXNlIHxzZXR3aW52YXIoKXwuCgkJV2hlbiB7d2lubnJ9IGlzIHplcm8gdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuCgkJVGhpcyBhbHNvIHdvcmtzIGZvciBhIGdsb2JhbCBvciBsb2NhbCBidWZmZXIgb3B0aW9uLCBidXQgaXQKCQlkb2Vzbid0IHdvcmsgZm9yIGEgZ2xvYmFsIG9yIGxvY2FsIGJ1ZmZlciB2YXJpYWJsZS4KCQlGb3IgYSBsb2NhbCBidWZmZXIgb3B0aW9uIHRoZSBnbG9iYWwgdmFsdWUgaXMgdW5jaGFuZ2VkLgoJCU5vdGUgdGhhdCB0aGUgdmFyaWFibGUgbmFtZSB3aXRob3V0ICJ3OiIgbXVzdCBiZSB1c2VkLgoJCVZpbSBicmllZmx5IGdvZXMgdG8gdGhlIHRhYiBwYWdlIHt0YWJucn0sIHRoaXMgbWF5IHRyaWdnZXIKCQlUYWJMZWF2ZSBhbmQgVGFiRW50ZXIgYXV0b2NvbW1hbmRzLgoJCUV4YW1wbGVzOiA+CgkJCTpjYWxsIHNldHRhYndpbnZhcigxLCAxLCAiJmxpc3QiLCAwKQoJCQk6Y2FsbCBzZXR0YWJ3aW52YXIoMywgMiwgIm15dmFyIiwgImZvb2JhciIpCjwJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoKc2V0d2ludmFyKHtucn0sIHt2YXJuYW1lfSwge3ZhbH0pCQkJKnNldHdpbnZhcigpKgoJCUxpa2UgfHNldHRhYndpbnZhcigpfCBmb3IgdGhlIGN1cnJlbnQgdGFiIHBhZ2UuCgkJRXhhbXBsZXM6ID4KCQkJOmNhbGwgc2V0d2ludmFyKDEsICImbGlzdCIsIDApCgkJCTpjYWxsIHNldHdpbnZhcigyLCAibXl2YXIiLCAiZm9vYmFyIikKCnNoZWxsZXNjYXBlKHtzdHJpbmd9IFssIHtzcGVjaWFsfV0pCQkJKnNoZWxsZXNjYXBlKCkqCgkJRXNjYXBlIHtzdHJpbmd9IGZvciB1c2UgYXMgYSBzaGVsbCBjb21tYW5kIGFyZ3VtZW50LgoJCU9uIE1TLVdpbmRvd3MgYW5kIE1TLURPUywgd2hlbiAnc2hlbGxzbGFzaCcgaXMgbm90IHNldCwgaXQKCQl3aWxsIGVuY2xvc2Uge3N0cmluZ30gaW4gZG91YmxlIHF1b3RlcyBhbmQgZG91YmxlIGFsbCBkb3VibGUKCQlxdW90ZXMgd2l0aGluIHtzdHJpbmd9LgoJCUZvciBvdGhlciBzeXN0ZW1zLCBpdCB3aWxsIGVuY2xvc2Uge3N0cmluZ30gaW4gc2luZ2xlIHF1b3RlcwoJCWFuZCByZXBsYWNlIGFsbCAiJyIgd2l0aCAiJ1wnJyIuCgkJV2hlbiB0aGUge3NwZWNpYWx9IGFyZ3VtZW50IGlzIHByZXNlbnQgYW5kIGl0J3MgYSBub24temVybwoJCU51bWJlciBvciBhIG5vbi1lbXB0eSBTdHJpbmcgKHxub24temVyby1hcmd8KSwgdGhlbiBzcGVjaWFsCgkJaXRlbXMgc3VjaCBhcyAiISIsICIlIiwgIiMiIGFuZCAiPGN3b3JkPiIgd2lsbCBiZSBwcmVjZWRlZCBieQoJCWEgYmFja3NsYXNoLiAgVGhpcyBiYWNrc2xhc2ggd2lsbCBiZSByZW1vdmVkIGFnYWluIGJ5IHRoZSB8OiF8CgkJY29tbWFuZC4KCQlUaGUgIiEiIGNoYXJhY3RlciB3aWxsIGJlIGVzY2FwZWQgKGFnYWluIHdpdGggYSB8bm9uLXplcm8tYXJnfAoJCXtzcGVjaWFsfSkgd2hlbiAnc2hlbGwnIGNvbnRhaW5zICJjc2giIGluIHRoZSB0YWlsLiAgVGhhdCBpcwoJCWJlY2F1c2UgZm9yIGNzaCBhbmQgdGNzaCAiISIgaXMgdXNlZCBmb3IgaGlzdG9yeSByZXBsYWNlbWVudAoJCWV2ZW4gd2hlbiBpbnNpZGUgc2luZ2xlIHF1b3Rlcy4KCQlUaGUgPE5MPiBjaGFyYWN0ZXIgaXMgYWxzbyBlc2NhcGVkLiAgV2l0aCBhIHxub24temVyby1hcmd8CgkJe3NwZWNpYWx9IGFuZCAnc2hlbGwnIGNvbnRhaW5pbmcgImNzaCIgaW4gdGhlIHRhaWwgaXQncwoJCWVzY2FwZWQgYSBzZWNvbmQgdGltZS4KCQlFeGFtcGxlIG9mIHVzZSB3aXRoIGEgfDohfCBjb21tYW5kOiA+CgkJICAgIDpleGUgJyFkaXIgJyAuIHNoZWxsZXNjYXBlKGV4cGFuZCgnPGNmaWxlPicpLCAxKQo8CQlUaGlzIHJlc3VsdHMgaW4gYSBkaXJlY3RvcnkgbGlzdGluZyBmb3IgdGhlIGZpbGUgdW5kZXIgdGhlCgkJY3Vyc29yLiAgRXhhbXBsZSBvZiB1c2Ugd2l0aCB8c3lzdGVtKCl8OiA+CgkJICAgIDpjYWxsIHN5c3RlbSgiY2htb2QgK3cgLS0gIiAuIHNoZWxsZXNjYXBlKGV4cGFuZCgiJSIpKSkKCgpzaW1wbGlmeSh7ZmlsZW5hbWV9KQkJCQkJKnNpbXBsaWZ5KCkqCgkJU2ltcGxpZnkgdGhlIGZpbGUgbmFtZSBhcyBtdWNoIGFzIHBvc3NpYmxlIHdpdGhvdXQgY2hhbmdpbmcKCQl0aGUgbWVhbmluZy4gIFNob3J0Y3V0cyAob24gTVMtV2luZG93cykgb3Igc3ltYm9saWMgbGlua3MgKG9uCgkJVW5peCkgYXJlIG5vdCByZXNvbHZlZC4gIElmIHRoZSBmaXJzdCBwYXRoIGNvbXBvbmVudCBpbgoJCXtmaWxlbmFtZX0gZGVzaWduYXRlcyB0aGUgY3VycmVudCBkaXJlY3RvcnksIHRoaXMgd2lsbCBiZQoJCXZhbGlkIGZvciB0aGUgcmVzdWx0IGFzIHdlbGwuICBBIHRyYWlsaW5nIHBhdGggc2VwYXJhdG9yIGlzCgkJbm90IHJlbW92ZWQgZWl0aGVyLgoJCUV4YW1wbGU6ID4KCQkJc2ltcGxpZnkoIi4vZGlyLy4uLy4vL2ZpbGUvIikgPT0gIi4vZmlsZS8iCjwJCU5vdGU6IFRoZSBjb21iaW5hdGlvbiAiZGlyLy4uIiBpcyBvbmx5IHJlbW92ZWQgaWYgImRpciIgaXMKCQlhIHNlYXJjaGFibGUgZGlyZWN0b3J5IG9yIGRvZXMgbm90IGV4aXN0LiAgT24gVW5peCwgaXQgaXMgYWxzbwoJCXJlbW92ZWQgd2hlbiAiZGlyIiBpcyBhIHN5bWJvbGljIGxpbmsgd2l0aGluIHRoZSBzYW1lCgkJZGlyZWN0b3J5LiAgSW4gb3JkZXIgdG8gcmVzb2x2ZSBhbGwgdGhlIGludm9sdmVkIHN5bWJvbGljCgkJbGlua3MgYmVmb3JlIHNpbXBsaWZ5aW5nIHRoZSBwYXRoIG5hbWUsIHVzZSB8cmVzb2x2ZSgpfC4KCgpzaW4oe2V4cHJ9KQkJCQkJCSpzaW4oKSoKCQlSZXR1cm4gdGhlIHNpbmUgb2Yge2V4cHJ9LCBtZWFzdXJlZCBpbiByYWRpYW5zLCBhcyBhIHxGbG9hdHwuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gc2luKDEwMCkKPAkJCS0wLjUwNjM2NiA+CgkJCTplY2hvIHNpbigtNC4wMSkKPAkJCTAuNzYzMzAxCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKCnNpbmgoe2V4cHJ9KQkJCQkJCSpzaW5oKCkqCgkJUmV0dXJuIHRoZSBoeXBlcmJvbGljIHNpbmUgb2Yge2V4cHJ9IGFzIGEgfEZsb2F0fCBpbiB0aGUgcmFuZ2UKCQlbLWluZiwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBzaW5oKDAuNSkKPAkJCTAuNTIxMDk1ID4KCQkJOmVjaG8gc2luaCgtMC45KQo8CQkJLTEuMDI2NTE3CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpzb3J0KHtsaXN0fSBbLCB7ZnVuY30gWywge2RpY3R9XV0pCQkJKnNvcnQoKSogKkU3MDIqCgkJU29ydCB0aGUgaXRlbXMgaW4ge2xpc3R9IGluLXBsYWNlLiAgUmV0dXJucyB7bGlzdH0uICBJZiB5b3UKCQl3YW50IGEgbGlzdCB0byByZW1haW4gdW5tb2RpZmllZCBtYWtlIGEgY29weSBmaXJzdDogPgoJCQk6bGV0IHNvcnRlZGxpc3QgPSBzb3J0KGNvcHkobXlsaXN0KSkKPAkJVXNlcyB0aGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIGVhY2ggaXRlbSB0byBzb3J0IG9uLgoJCU51bWJlcnMgc29ydCBhZnRlciBTdHJpbmdzLCB8TGlzdHN8IGFmdGVyIE51bWJlcnMuCgkJRm9yIHNvcnRpbmcgdGV4dCBpbiB0aGUgY3VycmVudCBidWZmZXIgdXNlIHw6c29ydHwuCgkJV2hlbiB7ZnVuY30gaXMgZ2l2ZW4gYW5kIGl0IGlzIG9uZSB0aGVuIGNhc2UgaXMgaWdub3JlZC4KCQl7ZGljdH0gaXMgZm9yIGZ1bmN0aW9ucyB3aXRoIHRoZSAiZGljdCIgYXR0cmlidXRlLiAgSXQgd2lsbCBiZQoJCXVzZWQgdG8gc2V0IHRoZSBsb2NhbCB2YXJpYWJsZSAic2VsZiIuIHxEaWN0aW9uYXJ5LWZ1bmN0aW9ufAoJCVdoZW4ge2Z1bmN9IGlzIGEgfEZ1bmNyZWZ8IG9yIGEgZnVuY3Rpb24gbmFtZSwgdGhpcyBmdW5jdGlvbgoJCWlzIGNhbGxlZCB0byBjb21wYXJlIGl0ZW1zLiAgVGhlIGZ1bmN0aW9uIGlzIGludm9rZWQgd2l0aCB0d28KCQlpdGVtcyBhcyBhcmd1bWVudCBhbmQgbXVzdCByZXR1cm4gemVybyBpZiB0aGV5IGFyZSBlcXVhbCwgMSBvcgoJCWJpZ2dlciBpZiB0aGUgZmlyc3Qgb25lIHNvcnRzIGFmdGVyIHRoZSBzZWNvbmQgb25lLCAtMSBvcgoJCXNtYWxsZXIgaWYgdGhlIGZpcnN0IG9uZSBzb3J0cyBiZWZvcmUgdGhlIHNlY29uZCBvbmUuCgkJRXhhbXBsZTogPgoJCQlmdW5jIE15Q29tcGFyZShpMSwgaTIpCgkJCSAgIHJldHVybiBhOmkxID09IGE6aTIgPyAwIDogYTppMSA+IGE6aTIgPyAxIDogLTEKCQkJZW5kZnVuYwoJCQlsZXQgc29ydGVkbGlzdCA9IHNvcnQobXlsaXN0LCAiTXlDb21wYXJlIikKPAkJQSBzaG9ydGVyIGNvbXBhcmUgdmVyc2lvbiBmb3IgdGhpcyBzcGVjaWZpYyBzaW1wbGUgY2FzZSwgd2hpY2gKCQlpZ25vcmVzIG92ZXJmbG93OiA+CgkJCWZ1bmMgTXlDb21wYXJlKGkxLCBpMikKCQkJICAgcmV0dXJuIGE6aTEgLSBhOmkyCgkJCWVuZGZ1bmMKPAoJCQkJCQkJKnNvdW5kZm9sZCgpKgpzb3VuZGZvbGQoe3dvcmR9KQoJCVJldHVybiB0aGUgc291bmQtZm9sZGVkIGVxdWl2YWxlbnQgb2Yge3dvcmR9LiAgVXNlcyB0aGUgZmlyc3QKCQlsYW5ndWFnZSBpbiAnc3BlbGxsYW5nJyBmb3IgdGhlIGN1cnJlbnQgd2luZG93IHRoYXQgc3VwcG9ydHMKCQlzb3VuZGZvbGRpbmcuICAnc3BlbGwnIG11c3QgYmUgc2V0LiAgV2hlbiBubyBzb3VuZCBmb2xkaW5nIGlzCgkJcG9zc2libGUgdGhlIHt3b3JkfSBpcyByZXR1cm5lZCB1bm1vZGlmaWVkLgoJCVRoaXMgY2FuIGJlIHVzZWQgZm9yIG1ha2luZyBzcGVsbGluZyBzdWdnZXN0aW9ucy4gIE5vdGUgdGhhdAoJCXRoZSBtZXRob2QgY2FuIGJlIHF1aXRlIHNsb3cuCgoJCQkJCQkJKnNwZWxsYmFkd29yZCgpKgpzcGVsbGJhZHdvcmQoW3tzZW50ZW5jZX1dKQoJCVdpdGhvdXQgYXJndW1lbnQ6IFRoZSByZXN1bHQgaXMgdGhlIGJhZGx5IHNwZWxsZWQgd29yZCB1bmRlcgoJCW9yIGFmdGVyIHRoZSBjdXJzb3IuICBUaGUgY3Vyc29yIGlzIG1vdmVkIHRvIHRoZSBzdGFydCBvZiB0aGUKCQliYWQgd29yZC4gIFdoZW4gbm8gYmFkIHdvcmQgaXMgZm91bmQgaW4gdGhlIGN1cnNvciBsaW5lIHRoZQoJCXJlc3VsdCBpcyBhbiBlbXB0eSBzdHJpbmcgYW5kIHRoZSBjdXJzb3IgZG9lc24ndCBtb3ZlLgoKCQlXaXRoIGFyZ3VtZW50OiBUaGUgcmVzdWx0IGlzIHRoZSBmaXJzdCB3b3JkIGluIHtzZW50ZW5jZX0gdGhhdAoJCWlzIGJhZGx5IHNwZWxsZWQuICBJZiB0aGVyZSBhcmUgbm8gc3BlbGxpbmcgbWlzdGFrZXMgdGhlCgkJcmVzdWx0IGlzIGFuIGVtcHR5IHN0cmluZy4KCgkJVGhlIHJldHVybiB2YWx1ZSBpcyBhIGxpc3Qgd2l0aCB0d28gaXRlbXM6CgkJLSBUaGUgYmFkbHkgc3BlbGxlZCB3b3JkIG9yIGFuIGVtcHR5IHN0cmluZy4KCQktIFRoZSB0eXBlIG9mIHRoZSBzcGVsbGluZyBlcnJvcjoKCQkJImJhZCIJCXNwZWxsaW5nIG1pc3Rha2UKCQkJInJhcmUiCQlyYXJlIHdvcmQKCQkJImxvY2FsIgkJd29yZCBvbmx5IHZhbGlkIGluIGFub3RoZXIgcmVnaW9uCgkJCSJjYXBzIgkJd29yZCBzaG91bGQgc3RhcnQgd2l0aCBDYXBpdGFsCgkJRXhhbXBsZTogPgoJCQllY2hvIHNwZWxsYmFkd29yZCgidGhlIHF1aWsgYnJvd24gZm94IikKPAkJCVsncXVpaycsICdiYWQnXSB+CgoJCVRoZSBzcGVsbGluZyBpbmZvcm1hdGlvbiBmb3IgdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuICBUaGUKCQknc3BlbGwnIG9wdGlvbiBtdXN0IGJlIHNldCBhbmQgdGhlIHZhbHVlIG9mICdzcGVsbGxhbmcnIGlzCgkJdXNlZC4KCgkJCQkJCQkqc3BlbGxzdWdnZXN0KCkqCnNwZWxsc3VnZ2VzdCh7d29yZH0gWywge21heH0gWywge2NhcGl0YWx9XV0pCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggc3BlbGxpbmcgc3VnZ2VzdGlvbnMgdG8gcmVwbGFjZSB7d29yZH0uCgkJV2hlbiB7bWF4fSBpcyBnaXZlbiB1cCB0byB0aGlzIG51bWJlciBvZiBzdWdnZXN0aW9ucyBhcmUKCQlyZXR1cm5lZC4gIE90aGVyd2lzZSB1cCB0byAyNSBzdWdnZXN0aW9ucyBhcmUgcmV0dXJuZWQuCgoJCVdoZW4gdGhlIHtjYXBpdGFsfSBhcmd1bWVudCBpcyBnaXZlbiBhbmQgaXQncyBub24temVybyBvbmx5CgkJc3VnZ2VzdGlvbnMgd2l0aCBhIGxlYWRpbmcgY2FwaXRhbCB3aWxsIGJlIGdpdmVuLiAgVXNlIHRoaXMKCQlhZnRlciBhIG1hdGNoIHdpdGggJ3NwZWxsY2FwY2hlY2snLgoKCQl7d29yZH0gY2FuIGJlIGEgYmFkbHkgc3BlbGxlZCB3b3JkIGZvbGxvd2VkIGJ5IG90aGVyIHRleHQuCgkJVGhpcyBhbGxvd3MgZm9yIGpvaW5pbmcgdHdvIHdvcmRzIHRoYXQgd2VyZSBzcGxpdC4gIFRoZQoJCXN1Z2dlc3Rpb25zIGFsc28gaW5jbHVkZSB0aGUgZm9sbG93aW5nIHRleHQsIHRodXMgeW91IGNhbgoJCXJlcGxhY2UgYSBsaW5lLgoKCQl7d29yZH0gbWF5IGFsc28gYmUgYSBnb29kIHdvcmQuICBTaW1pbGFyIHdvcmRzIHdpbGwgdGhlbiBiZQoJCXJldHVybmVkLiAge3dvcmR9IGl0c2VsZiBpcyBub3QgaW5jbHVkZWQgaW4gdGhlIHN1Z2dlc3Rpb25zLAoJCWFsdGhvdWdoIGl0IG1heSBhcHBlYXIgY2FwaXRhbGl6ZWQuCgoJCVRoZSBzcGVsbGluZyBpbmZvcm1hdGlvbiBmb3IgdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuICBUaGUKCQknc3BlbGwnIG9wdGlvbiBtdXN0IGJlIHNldCBhbmQgdGhlIHZhbHVlcyBvZiAnc3BlbGxsYW5nJyBhbmQKCQknc3BlbGxzdWdnZXN0JyBhcmUgdXNlZC4KCgpzcGxpdCh7ZXhwcn0gWywge3BhdHRlcm59IFssIHtrZWVwZW1wdHl9XV0pCQkJKnNwbGl0KCkqCgkJTWFrZSBhIHxMaXN0fCBvdXQgb2Yge2V4cHJ9LiAgV2hlbiB7cGF0dGVybn0gaXMgb21pdHRlZCBvcgoJCWVtcHR5IGVhY2ggd2hpdGUtc2VwYXJhdGVkIHNlcXVlbmNlIG9mIGNoYXJhY3RlcnMgYmVjb21lcyBhbgoJCWl0ZW0uCgkJT3RoZXJ3aXNlIHRoZSBzdHJpbmcgaXMgc3BsaXQgd2hlcmUge3BhdHRlcm59IG1hdGNoZXMsCgkJcmVtb3ZpbmcgdGhlIG1hdGNoZWQgY2hhcmFjdGVycy4KCQlXaGVuIHRoZSBmaXJzdCBvciBsYXN0IGl0ZW0gaXMgZW1wdHkgaXQgaXMgb21pdHRlZCwgdW5sZXNzIHRoZQoJCXtrZWVwZW1wdHl9IGFyZ3VtZW50IGlzIGdpdmVuIGFuZCBpdCdzIG5vbi16ZXJvLgoJCU90aGVyIGVtcHR5IGl0ZW1zIGFyZSBrZXB0IHdoZW4ge3BhdHRlcm59IG1hdGNoZXMgYXQgbGVhc3Qgb25lCgkJY2hhcmFjdGVyIG9yIHdoZW4ge2tlZXBlbXB0eX0gaXMgbm9uLXplcm8uCgkJRXhhbXBsZTogPgoJCQk6bGV0IHdvcmRzID0gc3BsaXQoZ2V0bGluZSgnLicpLCAnXFdcKycpCjwJCVRvIHNwbGl0IGEgc3RyaW5nIGluIGluZGl2aWR1YWwgY2hhcmFjdGVyczogPgoJCQk6Zm9yIGMgaW4gc3BsaXQobXlzdHJpbmcsICdcenMnKQo8CQlJZiB5b3Ugd2FudCB0byBrZWVwIHRoZSBzZXBhcmF0b3IgeW91IGNhbiBhbHNvIHVzZSAnXHpzJzogPgoJCQk6ZWNobyBzcGxpdCgnYWJjOmRlZjpnaGknLCAnOlx6cycpCjwJCQlbJ2FiYzonLCAnZGVmOicsICdnaGknXSB+CgkJU3BsaXR0aW5nIGEgdGFibGUgd2hlcmUgdGhlIGZpcnN0IGVsZW1lbnQgY2FuIGJlIGVtcHR5OiA+CgkJCTpsZXQgaXRlbXMgPSBzcGxpdChsaW5lLCAnOicsIDEpCjwJCVRoZSBvcHBvc2l0ZSBmdW5jdGlvbiBpcyB8am9pbigpfC4KCgpzcXJ0KHtleHByfSkJCQkJCQkqc3FydCgpKgoJCVJldHVybiB0aGUgbm9uLW5lZ2F0aXZlIHNxdWFyZSByb290IG9mIEZsb2F0IHtleHByfSBhcyBhCgkJfEZsb2F0fC4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4gIFdoZW4ge2V4cHJ9CgkJaXMgbmVnYXRpdmUgdGhlIHJlc3VsdCBpcyBOYU4gKE5vdCBhIE51bWJlcikuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gc3FydCgxMDApCjwJCQkxMC4wID4KCQkJOmVjaG8gc3FydCgtNC4wMSkKPAkJCW5hbgoJCSJuYW4iIG1heSBiZSBkaWZmZXJlbnQsIGl0IGRlcGVuZHMgb24gc3lzdGVtIGxpYnJhcmllcy4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoJCQoKc3RyMmZsb2F0KCB7ZXhwcn0pCQkJCQkqc3RyMmZsb2F0KCkqCgkJQ29udmVydCBTdHJpbmcge2V4cHJ9IHRvIGEgRmxvYXQuICBUaGlzIG1vc3RseSB3b3JrcyB0aGUgc2FtZQoJCWFzIHdoZW4gdXNpbmcgYSBmbG9hdGluZyBwb2ludCBudW1iZXIgaW4gYW4gZXhwcmVzc2lvbiwgc2VlCgkJfGZsb2F0aW5nLXBvaW50LWZvcm1hdHwuICBCdXQgaXQncyBhIGJpdCBtb3JlIHBlcm1pc3NpdmUuCgkJRS5nLiwgIjFlNDAiIGlzIGFjY2VwdGVkLCB3aGlsZSBpbiBhbiBleHByZXNzaW9uIHlvdSBuZWVkIHRvCgkJd3JpdGUgIjEuMGU0MCIuCgkJVGV4dCBhZnRlciB0aGUgbnVtYmVyIGlzIHNpbGVudGx5IGlnbm9yZWQuCgkJVGhlIGRlY2ltYWwgcG9pbnQgaXMgYWx3YXlzICcuJywgbm8gbWF0dGVyIHdoYXQgdGhlIGxvY2FsZSBpcwoJCXNldCB0by4gIEEgY29tbWEgZW5kcyB0aGUgbnVtYmVyOiAiMTIsMzQ1LjY3IiBpcyBjb252ZXJ0ZWQgdG8KCQkxMi4wLiAgWW91IGNhbiBzdHJpcCBvdXQgdGhvdXNhbmRzIHNlcGFyYXRvcnMgd2l0aAoJCXxzdWJzdGl0dXRlKCl8OiA+CgkJCWxldCBmID0gc3RyMmZsb2F0KHN1YnN0aXR1dGUodGV4dCwgJywnLCAnJywgJ2cnKSkKPAkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpzdHIybnIoIHtleHByfSBbLCB7YmFzZX1dKQkJCQkqc3RyMm5yKCkqCgkJQ29udmVydCBzdHJpbmcge2V4cHJ9IHRvIGEgbnVtYmVyLgoJCXtiYXNlfSBpcyB0aGUgY29udmVyc2lvbiBiYXNlLCBpdCBjYW4gYmUgOCwgMTAgb3IgMTYuCgkJV2hlbiB7YmFzZX0gaXMgb21pdHRlZCBiYXNlIDEwIGlzIHVzZWQuICBUaGlzIGFsc28gbWVhbnMgdGhhdAoJCWEgbGVhZGluZyB6ZXJvIGRvZXNuJ3QgY2F1c2Ugb2N0YWwgY29udmVyc2lvbiB0byBiZSB1c2VkLCBhcwoJCXdpdGggdGhlIGRlZmF1bHQgU3RyaW5nIHRvIE51bWJlciBjb252ZXJzaW9uLgoJCVdoZW4ge2Jhc2V9IGlzIDE2IGEgbGVhZGluZyAiMHgiIG9yICIwWCIgaXMgaWdub3JlZC4gIFdpdGggYQoJCWRpZmZlcmVudCBiYXNlIHRoZSByZXN1bHQgd2lsbCBiZSB6ZXJvLgoJCVRleHQgYWZ0ZXIgdGhlIG51bWJlciBpcyBzaWxlbnRseSBpZ25vcmVkLgoKCnN0cmNoYXJzKHtleHByfSkJCQkJCSpzdHJjaGFycygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycwoJCVN0cmluZyB7ZXhwcn0gb2NjdXBpZXMuICBDb21wb3NpbmcgY2hhcmFjdGVycyBhcmUgY291bnRlZAoJCXNlcGFyYXRlbHkuCgkJQWxzbyBzZWUgfHN0cmxlbigpfCwgfHN0cmRpc3BsYXl3aWR0aCgpfCBhbmQgfHN0cndpZHRoKCl8LgoKc3RyZGlzcGxheXdpZHRoKHtleHByfVssIHtjb2x9XSkJCQkqc3RyZGlzcGxheXdpZHRoKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIG51bWJlciBvZiBkaXNwbGF5IGNlbGxzCgkJU3RyaW5nIHtleHByfSBvY2N1cGllcyBvbiB0aGUgc2NyZWVuLgoJCVdoZW4ge2NvbH0gaXMgb21pdHRlZCB6ZXJvIGlzIHVzZWQuICBPdGhlcndpc2UgaXQgaXMgdGhlCgkJc2NyZWVuIGNvbHVtbiB3aGVyZSB0byBzdGFydC4gIFRoaXMgbWF0dGVycyBmb3IgVGFiCgkJY2hhcmFjdGVycy4KCQlUaGUgb3B0aW9uIHNldHRpbmdzIG9mIHRoZSBjdXJyZW50IHdpbmRvdyBhcmUgdXNlZC4gIFRoaXMKCQltYXR0ZXJzIGZvciBhbnl0aGluZyB0aGF0J3MgZGlzcGxheWVkIGRpZmZlcmVudGx5LCBzdWNoIGFzCgkJJ3RhYnN0b3AnIGFuZCAnZGlzcGxheScuCgkJV2hlbiB7ZXhwcn0gY29udGFpbnMgY2hhcmFjdGVycyB3aXRoIEVhc3QgQXNpYW4gV2lkdGggQ2xhc3MKCQlBbWJpZ3VvdXMsIHRoaXMgZnVuY3Rpb24ncyByZXR1cm4gdmFsdWUgZGVwZW5kcyBvbiAnYW1iaXdpZHRoJy4KCQlBbHNvIHNlZSB8c3RybGVuKCl8LCB8c3Ryd2lkdGgoKXwgYW5kIHxzdHJjaGFycygpfC4KCnN0cmZ0aW1lKHtmb3JtYXR9IFssIHt0aW1lfV0pCQkJCSpzdHJmdGltZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIGEgZm9ybWF0dGVkIGRhdGUgYW5kIHRpbWUsIGFzCgkJc3BlY2lmaWVkIGJ5IHRoZSB7Zm9ybWF0fSBzdHJpbmcuICBUaGUgZ2l2ZW4ge3RpbWV9IGlzIHVzZWQsCgkJb3IgdGhlIGN1cnJlbnQgdGltZSBpZiBubyB0aW1lIGlzIGdpdmVuLiAgVGhlIGFjY2VwdGVkCgkJe2Zvcm1hdH0gZGVwZW5kcyBvbiB5b3VyIHN5c3RlbSwgdGh1cyB0aGlzIGlzIG5vdCBwb3J0YWJsZSEKCQlTZWUgdGhlIG1hbnVhbCBwYWdlIG9mIHRoZSBDIGZ1bmN0aW9uIHN0cmZ0aW1lKCkgZm9yIHRoZQoJCWZvcm1hdC4gIFRoZSBtYXhpbXVtIGxlbmd0aCBvZiB0aGUgcmVzdWx0IGlzIDgwIGNoYXJhY3RlcnMuCgkJU2VlIGFsc28gfGxvY2FsdGltZSgpfCBhbmQgfGdldGZ0aW1lKCl8LgoJCVRoZSBsYW5ndWFnZSBjYW4gYmUgY2hhbmdlZCB3aXRoIHRoZSB8Omxhbmd1YWdlfCBjb21tYW5kLgoJCUV4YW1wbGVzOiA+CgkJICA6ZWNobyBzdHJmdGltZSgiJWMiKQkJICAgU3VuIEFwciAyNyAxMTo0OToyMyAxOTk3CgkJICA6ZWNobyBzdHJmdGltZSgiJVkgJWIgJWQgJVgiKQkgICAxOTk3IEFwciAyNyAxMTo1MzoyNQoJCSAgOmVjaG8gc3RyZnRpbWUoIiV5JW0lZCAlVCIpCSAgIDk3MDQyNyAxMTo1Mzo1NQoJCSAgOmVjaG8gc3RyZnRpbWUoIiVIOiVNIikJICAgMTE6NTUKCQkgIDplY2hvIHN0cmZ0aW1lKCIlYyIsIGdldGZ0aW1lKCJmaWxlLmMiKSkKCQkJCQkJICAgU2hvdyBtb2QgdGltZSBvZiBmaWxlLmMuCjwJCU5vdCBhdmFpbGFibGUgb24gYWxsIHN5c3RlbXMuICBUbyBjaGVjayB1c2U6ID4KCQkJOmlmIGV4aXN0cygiKnN0cmZ0aW1lIikKCnN0cmlkeCh7aGF5c3RhY2t9LCB7bmVlZGxlfSBbLCB7c3RhcnR9XSkJCSpzdHJpZHgoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBnaXZlcyB0aGUgYnl0ZSBpbmRleCBpbgoJCXtoYXlzdGFja30gb2YgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlIFN0cmluZyB7bmVlZGxlfS4KCQlJZiB7c3RhcnR9IGlzIHNwZWNpZmllZCwgdGhlIHNlYXJjaCBzdGFydHMgYXQgaW5kZXgge3N0YXJ0fS4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIGZpbmQgYSBzZWNvbmQgbWF0Y2g6ID4KCQkJOmxldCBjb2xvbjEgPSBzdHJpZHgobGluZSwgIjoiKQoJCQk6bGV0IGNvbG9uMiA9IHN0cmlkeChsaW5lLCAiOiIsIGNvbG9uMSArIDEpCjwJCVRoZSBzZWFyY2ggaXMgZG9uZSBjYXNlLXNlbnNpdGl2ZS4KCQlGb3IgcGF0dGVybiBzZWFyY2hlcyB1c2UgfG1hdGNoKCl8LgoJCS0xIGlzIHJldHVybmVkIGlmIHRoZSB7bmVlZGxlfSBkb2VzIG5vdCBvY2N1ciBpbiB7aGF5c3RhY2t9LgoJCVNlZSBhbHNvIHxzdHJyaWR4KCl8LgoJCUV4YW1wbGVzOiA+CgkJICA6ZWNobyBzdHJpZHgoIkFuIEV4YW1wbGUiLCAiRXhhbXBsZSIpCSAgICAgMwoJCSAgOmVjaG8gc3RyaWR4KCJTdGFydGluZyBwb2ludCIsICJTdGFydCIpICAgIDAKCQkgIDplY2hvIHN0cmlkeCgiU3RhcnRpbmcgcG9pbnQiLCAic3RhcnQiKSAgIC0xCjwJCQkJCQkqc3Ryc3RyKCkqICpzdHJjaHIoKSoKCQlzdHJpZHgoKSB3b3JrcyBzaW1pbGFyIHRvIHRoZSBDIGZ1bmN0aW9uIHN0cnN0cigpLiAgV2hlbiB1c2VkCgkJd2l0aCBhIHNpbmdsZSBjaGFyYWN0ZXIgaXQgd29ya3Mgc2ltaWxhciB0byBzdHJjaHIoKS4KCgkJCQkJCQkqc3RyaW5nKCkqCnN0cmluZyh7ZXhwcn0pCVJldHVybiB7ZXhwcn0gY29udmVydGVkIHRvIGEgU3RyaW5nLiAgSWYge2V4cHJ9IGlzIGEgTnVtYmVyLAoJCUZsb2F0LCBTdHJpbmcgb3IgYSBjb21wb3NpdGlvbiBvZiB0aGVtLCB0aGVuIHRoZSByZXN1bHQgY2FuIGJlCgkJcGFyc2VkIGJhY2sgd2l0aCB8ZXZhbCgpfC4KCQkJe2V4cHJ9IHR5cGUJcmVzdWx0IH4KCQkJU3RyaW5nCQknc3RyaW5nJwoJCQlOdW1iZXIJCTEyMwoJCQlGbG9hdAkJMTIzLjEyMzQ1NiBvciAxLjEyMzQ1NmU4CgkJCUZ1bmNyZWYJCWZ1bmN0aW9uKCduYW1lJykKCQkJTGlzdAkJW2l0ZW0sIGl0ZW1dCgkJCURpY3Rpb25hcnkJe2tleTogdmFsdWUsIGtleTogdmFsdWV9CgkJTm90ZSB0aGF0IGluIFN0cmluZyB2YWx1ZXMgdGhlICcgY2hhcmFjdGVyIGlzIGRvdWJsZWQuCgkJQWxzbyBzZWUgfHN0cnRyYW5zKCl8LgoKCQkJCQkJCSpzdHJsZW4oKSoKc3RybGVuKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGxlbmd0aCBvZiB0aGUgU3RyaW5nCgkJe2V4cHJ9IGluIGJ5dGVzLgoJCUlmIHlvdSB3YW50IHRvIGNvdW50IHRoZSBudW1iZXIgb2YgbXVsdGktYnl0ZSBjaGFyYWN0ZXJzIChub3QKCQljb3VudGluZyBjb21wb3NpbmcgY2hhcmFjdGVycykgdXNlIHNvbWV0aGluZyBsaWtlIHRoaXM6ID4KCgkJCTpsZXQgbGVuID0gc3RybGVuKHN1YnN0aXR1dGUoc3RyLCAiLiIsICJ4IiwgImciKSkKPAoJCUlmIHRoZSBhcmd1bWVudCBpcyBhIE51bWJlciBpdCBpcyBmaXJzdCBjb252ZXJ0ZWQgdG8gYSBTdHJpbmcuCgkJRm9yIG90aGVyIHR5cGVzIGFuIGVycm9yIGlzIGdpdmVuLgoJCUFsc28gc2VlIHxsZW4oKXwsIHxzdHJjaGFycygpfCwgfHN0cmRpc3BsYXl3aWR0aCgpfCBhbmQKCQl8c3Ryd2lkdGgoKXwuCgpzdHJwYXJ0KHtzcmN9LCB7c3RhcnR9Wywge2xlbn1dKQkJCSpzdHJwYXJ0KCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgcGFydCBvZiB7c3JjfSwgc3RhcnRpbmcgZnJvbQoJCWJ5dGUge3N0YXJ0fSwgd2l0aCB0aGUgYnl0ZSBsZW5ndGgge2xlbn0uCgkJV2hlbiBub24tZXhpc3RpbmcgYnl0ZXMgYXJlIGluY2x1ZGVkLCB0aGlzIGRvZXNuJ3QgcmVzdWx0IGluCgkJYW4gZXJyb3IsIHRoZSBieXRlcyBhcmUgc2ltcGx5IG9taXR0ZWQuCgkJSWYge2xlbn0gaXMgbWlzc2luZywgdGhlIGNvcHkgY29udGludWVzIGZyb20ge3N0YXJ0fSB0aWxsIHRoZQoJCWVuZCBvZiB0aGUge3NyY30uID4KCQkJc3RycGFydCgiYWJjZGVmZyIsIDMsIDIpICAgID09ICJkZSIKCQkJc3RycGFydCgiYWJjZGVmZyIsIC0yLCA0KSAgID09ICJhYiIKCQkJc3RycGFydCgiYWJjZGVmZyIsIDUsIDQpICAgID09ICJmZyIKCQkJc3RycGFydCgiYWJjZGVmZyIsIDMpCSAgICA9PSAiZGVmZyIKPAkJTm90ZTogVG8gZ2V0IHRoZSBmaXJzdCBjaGFyYWN0ZXIsIHtzdGFydH0gbXVzdCBiZSAwLiAgRm9yCgkJZXhhbXBsZSwgdG8gZ2V0IHRocmVlIGJ5dGVzIHVuZGVyIGFuZCBhZnRlciB0aGUgY3Vyc29yOiA+CgkJCXN0cnBhcnQoZ2V0bGluZSgiLiIpLCBjb2woIi4iKSAtIDEsIDMpCjwKc3RycmlkeCh7aGF5c3RhY2t9LCB7bmVlZGxlfSBbLCB7c3RhcnR9XSkJCQkqc3RycmlkeCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGdpdmVzIHRoZSBieXRlIGluZGV4IGluCgkJe2hheXN0YWNrfSBvZiB0aGUgbGFzdCBvY2N1cnJlbmNlIG9mIHRoZSBTdHJpbmcge25lZWRsZX0uCgkJV2hlbiB7c3RhcnR9IGlzIHNwZWNpZmllZCwgbWF0Y2hlcyBiZXlvbmQgdGhpcyBpbmRleCBhcmUKCQlpZ25vcmVkLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBmaW5kIGEgbWF0Y2ggYmVmb3JlIGEgcHJldmlvdXMKCQltYXRjaDogPgoJCQk6bGV0IGxhc3Rjb21tYSA9IHN0cnJpZHgobGluZSwgIiwiKQoJCQk6bGV0IGNvbW1hMiA9IHN0cnJpZHgobGluZSwgIiwiLCBsYXN0Y29tbWEgLSAxKQo8CQlUaGUgc2VhcmNoIGlzIGRvbmUgY2FzZS1zZW5zaXRpdmUuCgkJRm9yIHBhdHRlcm4gc2VhcmNoZXMgdXNlIHxtYXRjaCgpfC4KCQktMSBpcyByZXR1cm5lZCBpZiB0aGUge25lZWRsZX0gZG9lcyBub3Qgb2NjdXIgaW4ge2hheXN0YWNrfS4KCQlJZiB0aGUge25lZWRsZX0gaXMgZW1wdHkgdGhlIGxlbmd0aCBvZiB7aGF5c3RhY2t9IGlzIHJldHVybmVkLgoJCVNlZSBhbHNvIHxzdHJpZHgoKXwuICBFeGFtcGxlczogPgoJCSAgOmVjaG8gc3RycmlkeCgiYW4gYW5ncnkgYXJtYWRpbGxvIiwgImFuIikJICAgICAzCjwJCQkJCQkJKnN0cnJjaHIoKSoKCQlXaGVuIHVzZWQgd2l0aCBhIHNpbmdsZSBjaGFyYWN0ZXIgaXQgd29ya3Mgc2ltaWxhciB0byB0aGUgQwoJCWZ1bmN0aW9uIHN0cnJjaHIoKS4KCnN0cnRyYW5zKHtleHByfSkJCQkJCSpzdHJ0cmFucygpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHtleHByfSB3aXRoIGFsbCB1bnByaW50YWJsZQoJCWNoYXJhY3RlcnMgdHJhbnNsYXRlZCBpbnRvIHByaW50YWJsZSBjaGFyYWN0ZXJzIHwnaXNwcmludCd8LgoJCUxpa2UgdGhleSBhcmUgc2hvd24gaW4gYSB3aW5kb3cuICBFeGFtcGxlOiA+CgkJCWVjaG8gc3RydHJhbnMoQGEpCjwJCVRoaXMgZGlzcGxheXMgYSBuZXdsaW5lIGluIHJlZ2lzdGVyIGEgYXMgIl5AIiBpbnN0ZWFkIG9mCgkJc3RhcnRpbmcgYSBuZXcgbGluZS4KCnN0cndpZHRoKHtleHByfSkJCQkJCSpzdHJ3aWR0aCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgZGlzcGxheSBjZWxscwoJCVN0cmluZyB7ZXhwcn0gb2NjdXBpZXMuICBBIFRhYiBjaGFyYWN0ZXIgaXMgY291bnRlZCBhcyBvbmUKCQljZWxsLCBhbHRlcm5hdGl2ZWx5IHVzZSB8c3RyZGlzcGxheXdpZHRoKCl8LgoJCVdoZW4ge2V4cHJ9IGNvbnRhaW5zIGNoYXJhY3RlcnMgd2l0aCBFYXN0IEFzaWFuIFdpZHRoIENsYXNzCgkJQW1iaWd1b3VzLCB0aGlzIGZ1bmN0aW9uJ3MgcmV0dXJuIHZhbHVlIGRlcGVuZHMgb24gJ2FtYml3aWR0aCcuCgkJQWxzbyBzZWUgfHN0cmxlbigpfCwgfHN0cmRpc3BsYXl3aWR0aCgpfCBhbmQgfHN0cmNoYXJzKCl8LgoKc3VibWF0Y2goe25yfSkJCQkJCQkqc3VibWF0Y2goKSoKCQlPbmx5IGZvciBhbiBleHByZXNzaW9uIGluIGEgfDpzdWJzdGl0dXRlfCBjb21tYW5kIG9yCgkJc3Vic3RpdHV0ZSgpIGZ1bmN0aW9uLgoJCVJldHVybnMgdGhlIHtucn0ndGggc3VibWF0Y2ggb2YgdGhlIG1hdGNoZWQgdGV4dC4gIFdoZW4ge25yfQoJCWlzIDAgdGhlIHdob2xlIG1hdGNoZWQgdGV4dCBpcyByZXR1cm5lZC4KCQlBbHNvIHNlZSB8c3ViLXJlcGxhY2UtZXhwcmVzc2lvbnwuCgkJRXhhbXBsZTogPgoJCQk6cy9cZFwrL1w9c3VibWF0Y2goMCkgKyAxLwo8CQlUaGlzIGZpbmRzIHRoZSBmaXJzdCBudW1iZXIgaW4gdGhlIGxpbmUgYW5kIGFkZHMgb25lIHRvIGl0LgoJCUEgbGluZSBicmVhayBpcyBpbmNsdWRlZCBhcyBhIG5ld2xpbmUgY2hhcmFjdGVyLgoKc3Vic3RpdHV0ZSh7ZXhwcn0sIHtwYXR9LCB7c3VifSwge2ZsYWdzfSkJCSpzdWJzdGl0dXRlKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgYSBjb3B5IG9mIHtleHByfSwgaW4gd2hpY2gKCQl0aGUgZmlyc3QgbWF0Y2ggb2Yge3BhdH0gaXMgcmVwbGFjZWQgd2l0aCB7c3VifS4KCQlXaGVuIHtmbGFnc30gaXMgImciLCBhbGwgbWF0Y2hlcyBvZiB7cGF0fSBpbiB7ZXhwcn0gYXJlCgkJcmVwbGFjZWQuICBPdGhlcndpc2Uge2ZsYWdzfSBzaG91bGQgYmUgIiIuCgkJCgkJVGhpcyB3b3JrcyBsaWtlIHRoZSAiOnN1YnN0aXR1dGUiIGNvbW1hbmQgKHdpdGhvdXQgYW55IGZsYWdzKS4KCQlCdXQgdGhlIG1hdGNoaW5nIHdpdGgge3BhdH0gaXMgYWx3YXlzIGRvbmUgbGlrZSB0aGUgJ21hZ2ljJwoJCW9wdGlvbiBpcyBzZXQgYW5kICdjcG9wdGlvbnMnIGlzIGVtcHR5ICh0byBtYWtlIHNjcmlwdHMKCQlwb3J0YWJsZSkuICAnaWdub3JlY2FzZScgaXMgc3RpbGwgcmVsZXZhbnQuICAnc21hcnRjYXNlJyBpcwoJCW5vdCB1c2VkLiAgU2VlIHxzdHJpbmctbWF0Y2h8IGZvciBob3cge3BhdH0gaXMgdXNlZC4KCgkJQSAifiIgaW4ge3N1Yn0gaXMgbm90IHJlcGxhY2VkIHdpdGggdGhlIHByZXZpb3VzIHtzdWJ9LgoJCU5vdGUgdGhhdCBzb21lIGNvZGVzIGluIHtzdWJ9IGhhdmUgYSBzcGVjaWFsIG1lYW5pbmcKCQl8c3ViLXJlcGxhY2Utc3BlY2lhbHwuCUZvciBleGFtcGxlLCB0byByZXBsYWNlIHNvbWV0aGluZyB3aXRoCgkJIlxuIiAodHdvIGNoYXJhY3RlcnMpLCB1c2UgIlxcXFxuIiBvciAnXFxuJy4KCgkJV2hlbiB7cGF0fSBkb2VzIG5vdCBtYXRjaCBpbiB7ZXhwcn0sIHtleHByfSBpcyByZXR1cm5lZAoJCXVubW9kaWZpZWQuCgoJCUV4YW1wbGU6ID4KCQkJOmxldCAmcGF0aCA9IHN1YnN0aXR1dGUoJnBhdGgsICIsXFw9W14sXSokIiwgIiIsICIiKQo8CQlUaGlzIHJlbW92ZXMgdGhlIGxhc3QgY29tcG9uZW50IG9mIHRoZSAncGF0aCcgb3B0aW9uLiA+CgkJCTplY2hvIHN1YnN0aXR1dGUoInRlc3RpbmciLCAiLioiLCAiXFxVXFwwIiwgIiIpCjwJCXJlc3VsdHMgaW4gIlRFU1RJTkciLgoKCQlXaGVuIHtzdWJ9IHN0YXJ0cyB3aXRoICJcPSIsIHRoZSByZW1haW5kZXIgaXMgaW50ZXJwcmV0ZWQgYXMKCQlhbiBleHByZXNzaW9uLiBTZWUgfHN1Yi1yZXBsYWNlLWV4cHJlc3Npb258LiAgRXhhbXBsZTogPgoJCQk6ZWNobyBzdWJzdGl0dXRlKHMsICclXChceFx4XCknLAoJCQkgICBcICdcPW5yMmNoYXIoIjB4IiAuIHN1Ym1hdGNoKDEpKScsICdnJykKCnN5bklEKHtsbnVtfSwge2NvbH0sIHt0cmFuc30pCQkJCSpzeW5JRCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBzeW50YXggSUQgYXQgdGhlIHBvc2l0aW9uCgkJe2xudW19IGFuZCB7Y29sfSBpbiB0aGUgY3VycmVudCB3aW5kb3cuCgkJVGhlIHN5bnRheCBJRCBjYW4gYmUgdXNlZCB3aXRoIHxzeW5JRGF0dHIoKXwgYW5kCgkJfHN5bklEdHJhbnMoKXwgdG8gb2J0YWluIHN5bnRheCBpbmZvcm1hdGlvbiBhYm91dCB0ZXh0LgoKCQl7Y29sfSBpcyAxIGZvciB0aGUgbGVmdG1vc3QgY29sdW1uLCB7bG51bX0gaXMgMSBmb3IgdGhlIGZpcnN0CgkJbGluZS4gICdzeW5tYXhjb2wnIGFwcGxpZXMsIGluIGEgbG9uZ2VyIGxpbmUgemVybyBpcyByZXR1cm5lZC4KCgkJV2hlbiB7dHJhbnN9IGlzIG5vbi16ZXJvLCB0cmFuc3BhcmVudCBpdGVtcyBhcmUgcmVkdWNlZCB0byB0aGUKCQlpdGVtIHRoYXQgdGhleSByZXZlYWwuCVRoaXMgaXMgdXNlZnVsIHdoZW4gd2FudGluZyB0byBrbm93CgkJdGhlIGVmZmVjdGl2ZSBjb2xvci4gIFdoZW4ge3RyYW5zfSBpcyB6ZXJvLCB0aGUgdHJhbnNwYXJlbnQKCQlpdGVtIGlzIHJldHVybmVkLiAgVGhpcyBpcyB1c2VmdWwgd2hlbiB3YW50aW5nIHRvIGtub3cgd2hpY2gKCQlzeW50YXggaXRlbSBpcyBlZmZlY3RpdmUgKGUuZy4gaW5zaWRlIHBhcmVucykuCgkJV2FybmluZzogVGhpcyBmdW5jdGlvbiBjYW4gYmUgdmVyeSBzbG93LiAgQmVzdCBzcGVlZCBpcwoJCW9idGFpbmVkIGJ5IGdvaW5nIHRocm91Z2ggdGhlIGZpbGUgaW4gZm9yd2FyZCBkaXJlY3Rpb24uCgoJCUV4YW1wbGUgKGVjaG9lcyB0aGUgbmFtZSBvZiB0aGUgc3ludGF4IGl0ZW0gdW5kZXIgdGhlIGN1cnNvcik6ID4KCQkJOmVjaG8gc3luSURhdHRyKHN5bklEKGxpbmUoIi4iKSwgY29sKCIuIiksIDEpLCAibmFtZSIpCjwKCnN5bklEYXR0cih7c3luSUR9LCB7d2hhdH0gWywge21vZGV9XSkJCQkqc3luSURhdHRyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIHt3aGF0fSBhdHRyaWJ1dGUgb2YKCQlzeW50YXggSUQge3N5bklEfS4gIFRoaXMgY2FuIGJlIHVzZWQgdG8gb2J0YWluIGluZm9ybWF0aW9uCgkJYWJvdXQgYSBzeW50YXggaXRlbS4KCQl7bW9kZX0gY2FuIGJlICJndWkiLCAiY3Rlcm0iIG9yICJ0ZXJtIiwgdG8gZ2V0IHRoZSBhdHRyaWJ1dGVzCgkJZm9yIHRoYXQgbW9kZS4JV2hlbiB7bW9kZX0gaXMgb21pdHRlZCwgb3IgYW4gaW52YWxpZCB2YWx1ZSBpcwoJCXVzZWQsIHRoZSBhdHRyaWJ1dGVzIGZvciB0aGUgY3VycmVudGx5IGFjdGl2ZSBoaWdobGlnaHRpbmcgYXJlCgkJdXNlZCAoR1VJLCBjdGVybSBvciB0ZXJtKS4KCQlVc2Ugc3luSUR0cmFucygpIHRvIGZvbGxvdyBsaW5rZWQgaGlnaGxpZ2h0IGdyb3Vwcy4KCQl7d2hhdH0JCXJlc3VsdAoJCSJuYW1lIgkJdGhlIG5hbWUgb2YgdGhlIHN5bnRheCBpdGVtCgkJImZnIgkJZm9yZWdyb3VuZCBjb2xvciAoR1VJOiBjb2xvciBuYW1lIHVzZWQgdG8gc2V0CgkJCQl0aGUgY29sb3IsIGN0ZXJtOiBjb2xvciBudW1iZXIgYXMgYSBzdHJpbmcsCgkJCQl0ZXJtOiBlbXB0eSBzdHJpbmcpCgkJImJnIgkJYmFja2dyb3VuZCBjb2xvciAoYXMgd2l0aCAiZmciKQoJCSJmb250IgkJZm9udCBuYW1lIChvbmx5IGF2YWlsYWJsZSBpbiB0aGUgR1VJKQoJCQkJfGhpZ2hsaWdodC1mb250fAoJCSJzcCIJCXNwZWNpYWwgY29sb3IgKGFzIHdpdGggImZnIikgfGhpZ2hsaWdodC1ndWlzcHwKCQkiZmcjIgkJbGlrZSAiZmciLCBidXQgZm9yIHRoZSBHVUkgYW5kIHRoZSBHVUkgaXMKCQkJCXJ1bm5pbmcgdGhlIG5hbWUgaW4gIiNSUkdHQkIiIGZvcm0KCQkiYmcjIgkJbGlrZSAiZmcjIiBmb3IgImJnIgoJCSJzcCMiCQlsaWtlICJmZyMiIGZvciAic3AiCgkJImJvbGQiCQkiMSIgaWYgYm9sZAoJCSJpdGFsaWMiCSIxIiBpZiBpdGFsaWMKCQkicmV2ZXJzZSIJIjEiIGlmIHJldmVyc2UKCQkiaW52ZXJzZSIJIjEiIGlmIGludmVyc2UgKD0gcmV2ZXJzZSkKCQkic3RhbmRvdXQiCSIxIiBpZiBzdGFuZG91dAoJCSJ1bmRlcmxpbmUiCSIxIiBpZiB1bmRlcmxpbmVkCgkJInVuZGVyY3VybCIJIjEiIGlmIHVuZGVyY3VybGVkCgoJCUV4YW1wbGUgKGVjaG9lcyB0aGUgY29sb3Igb2YgdGhlIHN5bnRheCBpdGVtIHVuZGVyIHRoZQoJCWN1cnNvcik6ID4KCTplY2hvIHN5bklEYXR0cihzeW5JRHRyYW5zKHN5bklEKGxpbmUoIi4iKSwgY29sKCIuIiksIDEpKSwgImZnIikKPApzeW5JRHRyYW5zKHtzeW5JRH0pCQkJCQkqc3luSUR0cmFucygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSB0cmFuc2xhdGVkIHN5bnRheCBJRCBvZgoJCXtzeW5JRH0uICBUaGlzIGlzIHRoZSBzeW50YXggZ3JvdXAgSUQgb2Ygd2hhdCBpcyBiZWluZyB1c2VkIHRvCgkJaGlnaGxpZ2h0IHRoZSBjaGFyYWN0ZXIuICBIaWdobGlnaHQgbGlua3MgZ2l2ZW4gd2l0aAoJCSI6aGlnaGxpZ2h0IGxpbmsiIGFyZSBmb2xsb3dlZC4KCnN5bmNvbmNlYWxlZCh7bG51bX0sIHtjb2x9KQkJCQkqc3luY29uY2VhbGVkKCkqCgkJVGhlIHJlc3VsdCBpcyBhIExpc3QuIFRoZSBmaXJzdCBpdGVtIGluIHRoZSBsaXN0IGlzIDAgaWYgdGhlCgkJY2hhcmFjdGVyIGF0IHRoZSBwb3NpdGlvbiB7bG51bX0gYW5kIHtjb2x9IGlzIG5vdCBwYXJ0IG9mIGEKCQljb25jZWFsYWJsZSByZWdpb24sIDEgaWYgaXQgaXMuIFRoZSBzZWNvbmQgaXRlbSBpbiB0aGUgbGlzdCBpcwoJCWEgc3RyaW5nLiBJZiB0aGUgZmlyc3QgaXRlbSBpcyAxLCB0aGUgc2Vjb25kIGl0ZW0gY29udGFpbnMgdGhlCgkJdGV4dCB3aGljaCB3aWxsIGJlIGRpc3BsYXllZCBpbiBwbGFjZSBvZiB0aGUgY29uY2VhbGVkIHRleHQsCgkJZGVwZW5kaW5nIG9uIHRoZSBjdXJyZW50IHNldHRpbmcgb2YgJ2NvbmNlYWxsZXZlbCcuIFRoZSB0aGlyZAoJCWFuZCBmaW5hbCBpdGVtIGluIHRoZSBsaXN0IGlzIGEgdW5pcXVlIG51bWJlciByZXByZXNlbnRpbmcgdGhlCgkJc3BlY2lmaWMgc3ludGF4IHJlZ2lvbiBtYXRjaGVkLiBUaGlzIGFsbG93cyBkZXRlY3Rpb24gb2YgdGhlCgkJYmVnaW5uaW5nIG9mIGEgbmV3IGNvbmNlYWxhYmxlIHJlZ2lvbiBpZiB0aGVyZSBhcmUgdHdvCgkJY29uc2VjdXRpdmUgcmVnaW9ucyB3aXRoIHRoZSBzYW1lIHJlcGxhY2VtZW50IGNoYXJhY3Rlci4KCQlGb3IgYW4gZXhhbXBsZSB1c2Ugc2VlICRWSU1SVU5USU1FL3N5bnRheC8yaHRtbC52aW0gLgoKCnN5bnN0YWNrKHtsbnVtfSwge2NvbH0pCQkJCQkqc3luc3RhY2soKSoKCQlSZXR1cm4gYSB8TGlzdHwsIHdoaWNoIGlzIHRoZSBzdGFjayBvZiBzeW50YXggaXRlbXMgYXQgdGhlCgkJcG9zaXRpb24ge2xudW19IGFuZCB7Y29sfSBpbiB0aGUgY3VycmVudCB3aW5kb3cuICBFYWNoIGl0ZW0gaW4KCQl0aGUgTGlzdCBpcyBhbiBJRCBsaWtlIHdoYXQgfHN5bklEKCl8IHJldHVybnMuCgkJVGhlIGZpcnN0IGl0ZW0gaW4gdGhlIExpc3QgaXMgdGhlIG91dGVyIHJlZ2lvbiwgZm9sbG93aW5nIGFyZQoJCWl0ZW1zIGNvbnRhaW5lZCBpbiB0aGF0IG9uZS4gIFRoZSBsYXN0IG9uZSBpcyB3aGF0IHxzeW5JRCgpfAoJCXJldHVybnMsIHVubGVzcyBub3QgdGhlIHdob2xlIGl0ZW0gaXMgaGlnaGxpZ2h0ZWQgb3IgaXQgaXMgYQoJCXRyYW5zcGFyZW50IGl0ZW0uCgkJVGhpcyBmdW5jdGlvbiBpcyB1c2VmdWwgZm9yIGRlYnVnZ2luZyBhIHN5bnRheCBmaWxlLgoJCUV4YW1wbGUgdGhhdCBzaG93cyB0aGUgc3ludGF4IHN0YWNrIHVuZGVyIHRoZSBjdXJzb3I6ID4KCQkJZm9yIGlkIGluIHN5bnN0YWNrKGxpbmUoIi4iKSwgY29sKCIuIikpCgkJCSAgIGVjaG8gc3luSURhdHRyKGlkLCAibmFtZSIpCgkJCWVuZGZvcgo8CQlXaGVuIHRoZSBwb3NpdGlvbiBzcGVjaWZpZWQgd2l0aCB7bG51bX0gYW5kIHtjb2x9IGlzIGludmFsaWQKCQlub3RoaW5nIGlzIHJldHVybmVkLiAgVGhlIHBvc2l0aW9uIGp1c3QgYWZ0ZXIgdGhlIGxhc3QKCQljaGFyYWN0ZXIgaW4gYSBsaW5lIGFuZCB0aGUgZmlyc3QgY29sdW1uIGluIGFuIGVtcHR5IGxpbmUgYXJlCgkJdmFsaWQgcG9zaXRpb25zLgoKc3lzdGVtKHtleHByfSBbLCB7aW5wdXR9XSkJCQkJKnN5c3RlbSgpKiAqRTY3NyoKCQlHZXQgdGhlIG91dHB1dCBvZiB0aGUgc2hlbGwgY29tbWFuZCB7ZXhwcn0uCgkJV2hlbiB7aW5wdXR9IGlzIGdpdmVuLCB0aGlzIHN0cmluZyBpcyB3cml0dGVuIHRvIGEgZmlsZSBhbmQKCQlwYXNzZWQgYXMgc3RkaW4gdG8gdGhlIGNvbW1hbmQuICBUaGUgc3RyaW5nIGlzIHdyaXR0ZW4gYXMtaXMsCgkJeW91IG5lZWQgdG8gdGFrZSBjYXJlIG9mIHVzaW5nIHRoZSBjb3JyZWN0IGxpbmUgc2VwYXJhdG9ycwoJCXlvdXJzZWxmLiAgUGlwZXMgYXJlIG5vdCB1c2VkLgoJCU5vdGU6IFVzZSB8c2hlbGxlc2NhcGUoKXwgdG8gZXNjYXBlIHNwZWNpYWwgY2hhcmFjdGVycyBpbiBhCgkJY29tbWFuZCBhcmd1bWVudC4gIE5ld2xpbmVzIGluIHtleHByfSBtYXkgY2F1c2UgdGhlIGNvbW1hbmQgdG8KCQlmYWlsLiAgVGhlIGNoYXJhY3RlcnMgaW4gJ3NoZWxscXVvdGUnIGFuZCAnc2hlbGx4cXVvdGUnIG1heQoJCWFsc28gY2F1c2UgdHJvdWJsZS4KCQlUaGlzIGlzIG5vdCB0byBiZSB1c2VkIGZvciBpbnRlcmFjdGl2ZSBjb21tYW5kcy4KCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZy4gIEV4YW1wbGU6ID4KCQkgICAgOmxldCBmaWxlcyA9IHN5c3RlbSgibHMgIiAuICBzaGVsbGVzY2FwZShleHBhbmQoJyU6aCcpKSkKCjwJCVRvIG1ha2UgdGhlIHJlc3VsdCBtb3JlIHN5c3RlbS1pbmRlcGVuZGVudCwgdGhlIHNoZWxsIG91dHB1dAoJCWlzIGZpbHRlcmVkIHRvIHJlcGxhY2UgPENSPiB3aXRoIDxOTD4gZm9yIE1hY2ludG9zaCwgYW5kCgkJPENSPjxOTD4gd2l0aCA8Tkw+IGZvciBET1MtbGlrZSBzeXN0ZW1zLgoJCVRoZSBjb21tYW5kIGV4ZWN1dGVkIGlzIGNvbnN0cnVjdGVkIHVzaW5nIHNldmVyYWwgb3B0aW9uczoKCSdzaGVsbCcgJ3NoZWxsY21kZmxhZycgJ3NoZWxseHF1b3RlJyB7ZXhwcn0gJ3NoZWxscmVkaXInIHt0bXB9ICdzaGVsbHhxdW90ZScKCQkoe3RtcH0gaXMgYW4gYXV0b21hdGljYWxseSBnZW5lcmF0ZWQgZmlsZSBuYW1lKS4KCQlGb3IgVW5peCBhbmQgT1MvMiBicmFjZXMgYXJlIHB1dCBhcm91bmQge2V4cHJ9IHRvIGFsbG93IGZvcgoJCWNvbmNhdGVuYXRlZCBjb21tYW5kcy4KCgkJVGhlIGNvbW1hbmQgd2lsbCBiZSBleGVjdXRlZCBpbiAiY29va2VkIiBtb2RlLCBzbyB0aGF0IGEKCQlDVFJMLUMgd2lsbCBpbnRlcnJ1cHQgdGhlIGNvbW1hbmQgKG9uIFVuaXggYXQgbGVhc3QpLgoKCQlUaGUgcmVzdWx0aW5nIGVycm9yIGNvZGUgY2FuIGJlIGZvdW5kIGluIHx2OnNoZWxsX2Vycm9yfC4KCQlUaGlzIGZ1bmN0aW9uIHdpbGwgZmFpbCBpbiB8cmVzdHJpY3RlZC1tb2RlfC4KCgkJTm90ZSB0aGF0IGFueSB3cm9uZyB2YWx1ZSBpbiB0aGUgb3B0aW9ucyBtZW50aW9uZWQgYWJvdmUgbWF5CgkJbWFrZSB0aGUgZnVuY3Rpb24gZmFpbC4gIEl0IGhhcyBhbHNvIGJlZW4gcmVwb3J0ZWQgdG8gZmFpbAoJCXdoZW4gdXNpbmcgYSBzZWN1cml0eSBhZ2VudCBhcHBsaWNhdGlvbi4KCQlVbmxpa2UgIjohY21kIiB0aGVyZSBpcyBubyBhdXRvbWF0aWMgY2hlY2sgZm9yIGNoYW5nZWQgZmlsZXMuCgkJVXNlIHw6Y2hlY2t0aW1lfCB0byBmb3JjZSBhIGNoZWNrLgoKCnRhYnBhZ2VidWZsaXN0KFt7YXJnfV0pCQkJCQkqdGFicGFnZWJ1Zmxpc3QoKSoKCQlUaGUgcmVzdWx0IGlzIGEgfExpc3R8LCB3aGVyZSBlYWNoIGl0ZW0gaXMgdGhlIG51bWJlciBvZiB0aGUKCQlidWZmZXIgYXNzb2NpYXRlZCB3aXRoIGVhY2ggd2luZG93IGluIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoJCXthcmd9IHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIHRhYiBwYWdlIHRvIGJlIHVzZWQuICBXaGVuCgkJb21pdHRlZCB0aGUgY3VycmVudCB0YWIgcGFnZSBpcyB1c2VkLgoJCVdoZW4ge2FyZ30gaXMgaW52YWxpZCB0aGUgbnVtYmVyIHplcm8gaXMgcmV0dXJuZWQuCgkJVG8gZ2V0IGEgbGlzdCBvZiBhbGwgYnVmZmVycyBpbiBhbGwgdGFicyB1c2UgdGhpczogPgoJCQl0YWJsaXN0ID0gW10KCQkJZm9yIGkgaW4gcmFuZ2UodGFicGFnZW5yKCckJykpCgkJCSAgIGNhbGwgZXh0ZW5kKHRhYmxpc3QsIHRhYnBhZ2VidWZsaXN0KGkgKyAxKSkKCQkJZW5kZm9yCjwJCU5vdGUgdGhhdCBhIGJ1ZmZlciBtYXkgYXBwZWFyIGluIG1vcmUgdGhhbiBvbmUgd2luZG93LgoKCnRhYnBhZ2Vucihbe2FyZ31dKQkJCQkJKnRhYnBhZ2VucigpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgdGhlIGN1cnJlbnQKCQl0YWIgcGFnZS4gIFRoZSBmaXJzdCB0YWIgcGFnZSBoYXMgbnVtYmVyIDEuCgkJV2hlbiB0aGUgb3B0aW9uYWwgYXJndW1lbnQgaXMgIiQiLCB0aGUgbnVtYmVyIG9mIHRoZSBsYXN0IHRhYgoJCXBhZ2UgaXMgcmV0dXJuZWQgKHRoZSB0YWIgcGFnZSBjb3VudCkuCgkJVGhlIG51bWJlciBjYW4gYmUgdXNlZCB3aXRoIHRoZSB8OnRhYnwgY29tbWFuZC4KCgp0YWJwYWdld2lubnIoe3RhYmFyZ30sIFt7YXJnfV0pCQkJCSp0YWJwYWdld2lubnIoKSoKCQlMaWtlIHx3aW5ucigpfCBidXQgZm9yIHRhYiBwYWdlIHt0YWJhcmd9LgoJCXt0YWJhcmd9IHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIHRhYiBwYWdlIHRvIGJlIHVzZWQuCgkJe2FyZ30gaXMgdXNlZCBsaWtlIHdpdGggfHdpbm5yKCl8OgoJCS0gV2hlbiBvbWl0dGVkIHRoZSBjdXJyZW50IHdpbmRvdyBudW1iZXIgaXMgcmV0dXJuZWQuICBUaGlzIGlzCgkJICB0aGUgd2luZG93IHdoaWNoIHdpbGwgYmUgdXNlZCB3aGVuIGdvaW5nIHRvIHRoaXMgdGFiIHBhZ2UuCgkJLSBXaGVuICIkIiB0aGUgbnVtYmVyIG9mIHdpbmRvd3MgaXMgcmV0dXJuZWQuCgkJLSBXaGVuICIjIiB0aGUgcHJldmlvdXMgd2luZG93IG5yIGlzIHJldHVybmVkLgoJCVVzZWZ1bCBleGFtcGxlczogPgoJCSAgICB0YWJwYWdld2lubnIoMSkJICAgICIgY3VycmVudCB3aW5kb3cgb2YgdGFiIHBhZ2UgMQoJCSAgICB0YWJwYWdld2lubnIoNCwgJyQnKSAgICAiIG51bWJlciBvZiB3aW5kb3dzIGluIHRhYiBwYWdlIDQKPAkJV2hlbiB7dGFiYXJnfSBpcyBpbnZhbGlkIHplcm8gaXMgcmV0dXJuZWQuCgoJCQkJCQkJKnRhZ2ZpbGVzKCkqCnRhZ2ZpbGVzKCkJUmV0dXJucyBhIHxMaXN0fCB3aXRoIHRoZSBmaWxlIG5hbWVzIHVzZWQgdG8gc2VhcmNoIGZvciB0YWdzCgkJZm9yIHRoZSBjdXJyZW50IGJ1ZmZlci4gIFRoaXMgaXMgdGhlICd0YWdzJyBvcHRpb24gZXhwYW5kZWQuCgoKdGFnbGlzdCh7ZXhwcn0pCQkJCQkJCSp0YWdsaXN0KCkqCgkJUmV0dXJucyBhIGxpc3Qgb2YgdGFncyBtYXRjaGluZyB0aGUgcmVndWxhciBleHByZXNzaW9uIHtleHByfS4KCQlFYWNoIGxpc3QgaXRlbSBpcyBhIGRpY3Rpb25hcnkgd2l0aCBhdCBsZWFzdCB0aGUgZm9sbG93aW5nCgkJZW50cmllczoKCQkJbmFtZQkJTmFtZSBvZiB0aGUgdGFnLgoJCQlmaWxlbmFtZQlOYW1lIG9mIHRoZSBmaWxlIHdoZXJlIHRoZSB0YWcgaXMKCQkJCQlkZWZpbmVkLiAgSXQgaXMgZWl0aGVyIHJlbGF0aXZlIHRvIHRoZQoJCQkJCWN1cnJlbnQgZGlyZWN0b3J5IG9yIGEgZnVsbCBwYXRoLgoJCQljbWQJCUV4IGNvbW1hbmQgdXNlZCB0byBsb2NhdGUgdGhlIHRhZyBpbgoJCQkJCXRoZSBmaWxlLgoJCQlraW5kCQlUeXBlIG9mIHRoZSB0YWcuICBUaGUgdmFsdWUgZm9yIHRoaXMKCQkJCQllbnRyeSBkZXBlbmRzIG9uIHRoZSBsYW5ndWFnZSBzcGVjaWZpYwoJCQkJCWtpbmQgdmFsdWVzLiAgT25seSBhdmFpbGFibGUgd2hlbgoJCQkJCXVzaW5nIGEgdGFncyBmaWxlIGdlbmVyYXRlZCBieQoJCQkJCUV4dWJlcmFudCBjdGFncyBvciBoZHJ0YWcuCgkJCXN0YXRpYwkJQSBmaWxlIHNwZWNpZmljIHRhZy4gIFJlZmVyIHRvCgkJCQkJfHN0YXRpYy10YWd8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoJCU1vcmUgZW50cmllcyBtYXkgYmUgcHJlc2VudCwgZGVwZW5kaW5nIG9uIHRoZSBjb250ZW50IG9mIHRoZQoJCXRhZ3MgZmlsZTogYWNjZXNzLCBpbXBsZW1lbnRhdGlvbiwgaW5oZXJpdHMgYW5kIHNpZ25hdHVyZS4KCQlSZWZlciB0byB0aGUgY3RhZ3MgZG9jdW1lbnRhdGlvbiBmb3IgaW5mb3JtYXRpb24gYWJvdXQgdGhlc2UKCQlmaWVsZHMuICBGb3IgQyBjb2RlIHRoZSBmaWVsZHMgInN0cnVjdCIsICJjbGFzcyIgYW5kICJlbnVtIgoJCW1heSBhcHBlYXIsIHRoZXkgZ2l2ZSB0aGUgbmFtZSBvZiB0aGUgZW50aXR5IHRoZSB0YWcgaXMKCQljb250YWluZWQgaW4uCgoJCVRoZSBleC1jb21tYW5kICdjbWQnIGNhbiBiZSBlaXRoZXIgYW4gZXggc2VhcmNoIHBhdHRlcm4sIGEKCQlsaW5lIG51bWJlciBvciBhIGxpbmUgbnVtYmVyIGZvbGxvd2VkIGJ5IGEgYnl0ZSBudW1iZXIuCgoJCUlmIHRoZXJlIGFyZSBubyBtYXRjaGluZyB0YWdzLCB0aGVuIGFuIGVtcHR5IGxpc3QgaXMgcmV0dXJuZWQuCgoJCVRvIGdldCBhbiBleGFjdCB0YWcgbWF0Y2gsIHRoZSBhbmNob3JzICdeJyBhbmQgJyQnIHNob3VsZCBiZQoJCXVzZWQgaW4ge2V4cHJ9LiAgUmVmZXIgdG8gfHRhZy1yZWdleHB8IGZvciBtb3JlIGluZm9ybWF0aW9uCgkJYWJvdXQgdGhlIHRhZyBzZWFyY2ggcmVndWxhciBleHByZXNzaW9uIHBhdHRlcm4uCgoJCVJlZmVyIHRvIHwndGFncyd8IGZvciBpbmZvcm1hdGlvbiBhYm91dCBob3cgdGhlIHRhZ3MgZmlsZSBpcwoJCWxvY2F0ZWQgYnkgVmltLiBSZWZlciB0byB8dGFncy1maWxlLWZvcm1hdHwgZm9yIHRoZSBmb3JtYXQgb2YKCQl0aGUgdGFncyBmaWxlIGdlbmVyYXRlZCBieSB0aGUgZGlmZmVyZW50IGN0YWdzIHRvb2xzLgoKdGVtcG5hbWUoKQkJCQkJKnRlbXBuYW1lKCkqICp0ZW1wLWZpbGUtbmFtZSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUgbmFtZSBvZiBhIGZpbGUgdGhhdAoJCWRvZXNuJ3QgZXhpc3QuCUl0IGNhbiBiZSB1c2VkIGZvciBhIHRlbXBvcmFyeSBmaWxlLiAgVGhlIG5hbWUKCQlpcyBkaWZmZXJlbnQgZm9yIGF0IGxlYXN0IDI2IGNvbnNlY3V0aXZlIGNhbGxzLiAgRXhhbXBsZTogPgoJCQk6bGV0IHRtcGZpbGUgPSB0ZW1wbmFtZSgpCgkJCTpleGUgInJlZGlyID4gIiAuIHRtcGZpbGUKPAkJRm9yIFVuaXgsIHRoZSBmaWxlIHdpbGwgYmUgaW4gYSBwcml2YXRlIGRpcmVjdG9yeSB8dGVtcGZpbGV8LgoJCUZvciBNUy1XaW5kb3dzIGZvcndhcmQgc2xhc2hlcyBhcmUgdXNlZCB3aGVuIHRoZSAnc2hlbGxzbGFzaCcKCQlvcHRpb24gaXMgc2V0IG9yIHdoZW4gJ3NoZWxsY21kZmxhZycgc3RhcnRzIHdpdGggJy0nLgoKCnRhbih7ZXhwcn0pCQkJCQkJKnRhbigpKgoJCVJldHVybiB0aGUgdGFuZ2VudCBvZiB7ZXhwcn0sIG1lYXN1cmVkIGluIHJhZGlhbnMsIGFzIGEgfEZsb2F0fAoJCWluIHRoZSByYW5nZSBbLWluZiwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyB0YW4oMTApCjwJCQkwLjY0ODM2MSA+CgkJCTplY2hvIHRhbigtNC4wMSkKPAkJCS0xLjE4MTUwMgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKdGFuaCh7ZXhwcn0pCQkJCQkJKnRhbmgoKSoKCQlSZXR1cm4gdGhlIGh5cGVyYm9saWMgdGFuZ2VudCBvZiB7ZXhwcn0gYXMgYSB8RmxvYXR8IGluIHRoZQoJCXJhbmdlIFstMSwgMV0uCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gdGFuaCgwLjUpCjwJCQkwLjQ2MjExNyA+CgkJCTplY2hvIHRhbmgoLTEpCjwJCQktMC43NjE1OTQKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCnRvbG93ZXIoe2V4cHJ9KQkJCQkJCSp0b2xvd2VyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIGNvcHkgb2YgdGhlIFN0cmluZyBnaXZlbiwgd2l0aCBhbGwgdXBwZXJjYXNlCgkJY2hhcmFjdGVycyB0dXJuZWQgaW50byBsb3dlcmNhc2UgKGp1c3QgbGlrZSBhcHBseWluZyB8Z3V8IHRvCgkJdGhlIHN0cmluZykuCgp0b3VwcGVyKHtleHByfSkJCQkJCQkqdG91cHBlcigpKgoJCVRoZSByZXN1bHQgaXMgYSBjb3B5IG9mIHRoZSBTdHJpbmcgZ2l2ZW4sIHdpdGggYWxsIGxvd2VyY2FzZQoJCWNoYXJhY3RlcnMgdHVybmVkIGludG8gdXBwZXJjYXNlIChqdXN0IGxpa2UgYXBwbHlpbmcgfGdVfCB0bwoJCXRoZSBzdHJpbmcpLgoKdHIoe3NyY30sIHtmcm9tc3RyfSwge3Rvc3RyfSkJCQkJKnRyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIGNvcHkgb2YgdGhlIHtzcmN9IHN0cmluZyB3aXRoIGFsbCBjaGFyYWN0ZXJzCgkJd2hpY2ggYXBwZWFyIGluIHtmcm9tc3RyfSByZXBsYWNlZCBieSB0aGUgY2hhcmFjdGVyIGluIHRoYXQKCQlwb3NpdGlvbiBpbiB0aGUge3Rvc3RyfSBzdHJpbmcuICBUaHVzIHRoZSBmaXJzdCBjaGFyYWN0ZXIgaW4KCQl7ZnJvbXN0cn0gaXMgdHJhbnNsYXRlZCBpbnRvIHRoZSBmaXJzdCBjaGFyYWN0ZXIgaW4ge3Rvc3RyfQoJCWFuZCBzbyBvbi4gIEV4YWN0bHkgbGlrZSB0aGUgdW5peCAidHIiIGNvbW1hbmQuCgkJVGhpcyBjb2RlIGFsc28gZGVhbHMgd2l0aCBtdWx0aWJ5dGUgY2hhcmFjdGVycyBwcm9wZXJseS4KCgkJRXhhbXBsZXM6ID4KCQkJZWNobyB0cigiaGVsbG8gdGhlcmUiLCAiaHQiLCAiSFQiKQo8CQlyZXR1cm5zICJIZWxsbyBUSGVyZSIgPgoJCQllY2hvIHRyKCI8YmxvYj4iLCAiPD4iLCAie30iKQo8CQlyZXR1cm5zICJ7YmxvYn0iCgp0cnVuYyh7ZXhwcn0pCQkJCQkJCSp0cnVuYygpKgoJCVJldHVybiB0aGUgbGFyZ2VzdCBpbnRlZ3JhbCB2YWx1ZSB3aXRoIG1hZ25pdHVkZSBsZXNzIHRoYW4gb3IKCQllcXVhbCB0byB7ZXhwcn0gYXMgYSB8RmxvYXR8ICh0cnVuY2F0ZSB0b3dhcmRzIHplcm8pLgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCWVjaG8gdHJ1bmMoMS40NTYpCjwJCQkxLjAgID4KCQkJZWNobyB0cnVuYygtNS40NTYpCjwJCQktNS4wICA+CgkJCWVjaG8gdHJ1bmMoNC4wKQo8CQkJNC4wCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKCQkJCQkJCSp0eXBlKCkqCnR5cGUoe2V4cHJ9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCBkZXBlbmRpbmcgb24gdGhlIHR5cGUgb2Yge2V4cHJ9OgoJCQlOdW1iZXI6CSAgICAwCgkJCVN0cmluZzoJICAgIDEKCQkJRnVuY3JlZjogICAgMgoJCQlMaXN0OgkgICAgMwoJCQlEaWN0aW9uYXJ5OiA0CgkJCUZsb2F0OgkgICAgNQoJCVRvIGF2b2lkIHRoZSBtYWdpYyBudW1iZXJzIGl0IHNob3VsZCBiZSB1c2VkIHRoaXMgd2F5OiA+CgkJCTppZiB0eXBlKG15dmFyKSA9PSB0eXBlKDApCgkJCTppZiB0eXBlKG15dmFyKSA9PSB0eXBlKCIiKQoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZShmdW5jdGlvbigidHIiKSkKCQkJOmlmIHR5cGUobXl2YXIpID09IHR5cGUoW10pCgkJCTppZiB0eXBlKG15dmFyKSA9PSB0eXBlKHt9KQoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZSgwLjApCgp1bmRvZmlsZSh7bmFtZX0pCQkJCQkqdW5kb2ZpbGUoKSoKCQlSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIHVuZG8gZmlsZSB0aGF0IHdvdWxkIGJlIHVzZWQgZm9yIGEgZmlsZQoJCXdpdGggbmFtZSB7bmFtZX0gd2hlbiB3cml0aW5nLiAgVGhpcyB1c2VzIHRoZSAndW5kb2RpcicKCQlvcHRpb24sIGZpbmRpbmcgZGlyZWN0b3JpZXMgdGhhdCBleGlzdC4gIEl0IGRvZXMgbm90IGNoZWNrIGlmCgkJdGhlIHVuZG8gZmlsZSBleGlzdHMuCgkJe25hbWV9IGlzIGFsd2F5cyBleHBhbmRlZCB0byB0aGUgZnVsbCBwYXRoLCBzaW5jZSB0aGF0IGlzIHdoYXQKCQlpcyB1c2VkIGludGVybmFsbHkuCgkJVXNlZnVsIGluIGNvbWJpbmF0aW9uIHdpdGggfDp3dW5kb3wgYW5kIHw6cnVuZG98LgoJCVdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgK3BlcnNpc3RlbnRfdW5kbyBvcHRpb24gdGhpcyBhbHdheXMKCQlyZXR1cm5zIGFuIGVtcHR5IHN0cmluZy4KCnVuZG90cmVlKCkJCQkJCQkqdW5kb3RyZWUoKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgc3RhdGUgb2YgdGhlIHVuZG8gdHJlZSBpbiBhIGRpY3Rpb25hcnkgd2l0aAoJCXRoZSBmb2xsb3dpbmcgaXRlbXM6CgkJICAic2VxX2xhc3QiCVRoZSBoaWdoZXN0IHVuZG8gc2VxdWVuY2UgbnVtYmVyIHVzZWQuCgkJICAic2VxX2N1ciIJVGhlIHNlcXVlbmNlIG51bWJlciBvZiB0aGUgY3VycmVudCBwb3NpdGlvbiBpbgoJCQkJdGhlIHVuZG8gdHJlZS4gIFRoaXMgZGlmZmVycyBmcm9tICJzZXFfbGFzdCIKCQkJCXdoZW4gc29tZSBjaGFuZ2VzIHdlcmUgdW5kb25lLgoJCSAgInRpbWVfY3VyIglUaW1lIGxhc3QgdXNlZCBmb3IgfDplYXJsaWVyfCBhbmQgcmVsYXRlZAoJCQkJY29tbWFuZHMuICBVc2UgfHN0cmZ0aW1lKCl8IHRvIGNvbnZlcnQgdG8KCQkJCXNvbWV0aGluZyByZWFkYWJsZS4KCQkgICJzYXZlX2xhc3QiCU51bWJlciBvZiB0aGUgbGFzdCBmaWxlIHdyaXRlLiAgWmVybyB3aGVuIG5vCgkJCQl3cml0ZSB5ZXQuCgkJICAic2F2ZV9jdXIiCU51bWJlciBvZiB0aGUgY3VycmVudCBwb3NpdGlvbiBpbiB0aGUgdW5kbwoJCQkJdHJlZS4gIAoJCSAgInN5bmNlZCIJTm9uLXplcm8gd2hlbiB0aGUgbGFzdCB1bmRvIGJsb2NrIHdhcyBzeW5jZWQuCgkJCQlUaGlzIGhhcHBlbnMgd2hlbiB3YWl0aW5nIGZyb20gaW5wdXQgZnJvbSB0aGUKCQkJCXVzZXIuICBTZWUgfHVuZG8tYmxvY2tzfC4KCQkgICJlbnRyaWVzIglBIGxpc3Qgb2YgZGljdGlvbmFyaWVzIHdpdGggaW5mb3JtYXRpb24gYWJvdXQKCQkJCXVuZG8gYmxvY2tzLgoKCQlUaGUgZmlyc3QgaXRlbSBpbiB0aGUgImVudHJpZXMiIGxpc3QgaXMgdGhlIG9sZGVzdCB1bmRvIGl0ZW0uCgkJRWFjaCBMaXN0IGl0ZW0gaXMgYSBEaWN0aW9uYXJ5IHdpdGggdGhlc2UgaXRlbXM6CgkJICAic2VxIgkJVW5kbyBzZXF1ZW5jZSBudW1iZXIuICBTYW1lIGFzIHdoYXQgYXBwZWFycyBpbgoJCQkJfDp1bmRvbGlzdHwuCgkJICAidGltZSIJVGltZXN0YW1wIHdoZW4gdGhlIGNoYW5nZSBoYXBwZW5lZC4gIFVzZQoJCQkJfHN0cmZ0aW1lKCl8IHRvIGNvbnZlcnQgdG8gc29tZXRoaW5nIHJlYWRhYmxlLgoJCSAgIm5ld2hlYWQiCU9ubHkgYXBwZWFycyBpbiB0aGUgaXRlbSB0aGF0IGlzIHRoZSBsYXN0IG9uZQoJCQkJdGhhdCB3YXMgYWRkZWQuICBUaGlzIG1hcmtzIHRoZSBsYXN0IGNoYW5nZQoJCQkJYW5kIHdoZXJlIGZ1cnRoZXIgY2hhbmdlcyB3aWxsIGJlIGFkZGVkLgoJCSAgImN1cmhlYWQiCU9ubHkgYXBwZWFycyBpbiB0aGUgaXRlbSB0aGF0IGlzIHRoZSBsYXN0IG9uZQoJCQkJdGhhdCB3YXMgdW5kb25lLiAgVGhpcyBtYXJrcyB0aGUgY3VycmVudAoJCQkJcG9zaXRpb24gaW4gdGhlIHVuZG8gdHJlZSwgdGhlIGJsb2NrIHRoYXQgd2lsbAoJCQkJYmUgdXNlZCBieSBhIHJlZG8gY29tbWFuZC4gIFdoZW4gbm90aGluZyB3YXMKCQkJCXVuZG9uZSBhZnRlciB0aGUgbGFzdCBjaGFuZ2UgdGhpcyBpdGVtIHdpbGwKCQkJCW5vdCBhcHBlYXIgYW55d2hlcmUuCgkJICAic2F2ZSIJT25seSBhcHBlYXJzIG9uIHRoZSBsYXN0IGJsb2NrIGJlZm9yZSBhIGZpbGUKCQkJCXdyaXRlLiAgVGhlIG51bWJlciBpcyB0aGUgd3JpdGUgY291bnQuICBUaGUKCQkJCWZpcnN0IHdyaXRlIGhhcyBudW1iZXIgMSwgdGhlIGxhc3Qgb25lIHRoZQoJCQkJInNhdmVfbGFzdCIgbWVudGlvbmVkIGFib3ZlLgoJCSAgImFsdCIJCUFsdGVybmF0ZSBlbnRyeS4gIFRoaXMgaXMgYWdhaW4gYSBMaXN0IG9mIHVuZG8KCQkJCWJsb2Nrcy4gIEVhY2ggaXRlbSBtYXkgYWdhaW4gaGF2ZSBhbiAiYWx0IgoJCQkJaXRlbS4KCnZhbHVlcyh7ZGljdH0pCQkJCQkJKnZhbHVlcygpKgoJCVJldHVybiBhIHxMaXN0fCB3aXRoIGFsbCB0aGUgdmFsdWVzIG9mIHtkaWN0fS4JVGhlIHxMaXN0fCBpcwoJCWluIGFyYml0cmFyeSBvcmRlci4KCgp2aXJ0Y29sKHtleHByfSkJCQkJCQkqdmlydGNvbCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBzY3JlZW4gY29sdW1uIG9mIHRoZSBmaWxlCgkJcG9zaXRpb24gZ2l2ZW4gd2l0aCB7ZXhwcn0uICBUaGF0IGlzLCB0aGUgbGFzdCBzY3JlZW4gcG9zaXRpb24KCQlvY2N1cGllZCBieSB0aGUgY2hhcmFjdGVyIGF0IHRoYXQgcG9zaXRpb24sIHdoZW4gdGhlIHNjcmVlbgoJCXdvdWxkIGJlIG9mIHVubGltaXRlZCB3aWR0aC4gIFdoZW4gdGhlcmUgaXMgYSA8VGFiPiBhdCB0aGUKCQlwb3NpdGlvbiwgdGhlIHJldHVybmVkIE51bWJlciB3aWxsIGJlIHRoZSBjb2x1bW4gYXQgdGhlIGVuZCBvZgoJCXRoZSA8VGFiPi4gIEZvciBleGFtcGxlLCBmb3IgYSA8VGFiPiBpbiBjb2x1bW4gMSwgd2l0aCAndHMnCgkJc2V0IHRvIDgsIGl0IHJldHVybnMgOC4KCQlGb3IgdGhlIGJ5dGUgcG9zaXRpb24gdXNlIHxjb2woKXwuCgkJRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9IHNlZSB8Y29sKCl8LgoJCVdoZW4gJ3ZpcnR1YWxlZGl0JyBpcyB1c2VkIHtleHByfSBjYW4gYmUgW2xudW0sIGNvbCwgb2ZmXSwgd2hlcmUKCQkib2ZmIiBpcyB0aGUgb2Zmc2V0IGluIHNjcmVlbiBjb2x1bW5zIGZyb20gdGhlIHN0YXJ0IG9mIHRoZQoJCWNoYXJhY3Rlci4gIEUuZy4sIGEgcG9zaXRpb24gd2l0aGluIGEgPFRhYj4gb3IgYWZ0ZXIgdGhlIGxhc3QKCQljaGFyYWN0ZXIuICBXaGVuICJvZmYiIGlzIG9taXR0ZWQgemVybyBpcyB1c2VkLgoJCVdoZW4gVmlydHVhbCBlZGl0aW5nIGlzIGFjdGl2ZSBpbiB0aGUgY3VycmVudCBtb2RlLCBhIHBvc2l0aW9uCgkJYmV5b25kIHRoZSBlbmQgb2YgdGhlIGxpbmUgY2FuIGJlIHJldHVybmVkLiB8J3ZpcnR1YWxlZGl0J3wKCQlUaGUgYWNjZXB0ZWQgcG9zaXRpb25zIGFyZToKCQkgICAgLgkgICAgdGhlIGN1cnNvciBwb3NpdGlvbgoJCSAgICAkCSAgICB0aGUgZW5kIG9mIHRoZSBjdXJzb3IgbGluZSAodGhlIHJlc3VsdCBpcyB0aGUKCQkJICAgIG51bWJlciBvZiBkaXNwbGF5ZWQgY2hhcmFjdGVycyBpbiB0aGUgY3Vyc29yIGxpbmUKCQkJICAgIHBsdXMgb25lKQoJCSAgICAneAkgICAgcG9zaXRpb24gb2YgbWFyayB4IChpZiB0aGUgbWFyayBpcyBub3Qgc2V0LCAwIGlzCgkJCSAgICByZXR1cm5lZCkKCQlOb3RlIHRoYXQgb25seSBtYXJrcyBpbiB0aGUgY3VycmVudCBmaWxlIGNhbiBiZSB1c2VkLgoJCUV4YW1wbGVzOiA+CiAgdmlydGNvbCgiLiIpCSAgIHdpdGggdGV4dCAiZm9vXkxiYXIiLCB3aXRoIGN1cnNvciBvbiB0aGUgIl5MIiwgcmV0dXJucyA1CiAgdmlydGNvbCgiJCIpCSAgIHdpdGggdGV4dCAiZm9vXkxiYXIiLCByZXR1cm5zIDkKICB2aXJ0Y29sKCIndCIpICAgIHdpdGggdGV4dCAiCSAgdGhlcmUiLCB3aXRoICd0IGF0ICdoJywgcmV0dXJucyA2CjwJCVRoZSBmaXJzdCBjb2x1bW4gaXMgMS4JMCBpcyByZXR1cm5lZCBmb3IgYW4gZXJyb3IuCgkJQSBtb3JlIGFkdmFuY2VkIGV4YW1wbGUgdGhhdCBlY2hvZXMgdGhlIG1heGltdW0gbGVuZ3RoIG9mCgkJYWxsIGxpbmVzOiA+CgkJICAgIGVjaG8gbWF4KG1hcChyYW5nZSgxLCBsaW5lKCckJykpLCAidmlydGNvbChbdjp2YWwsICckJ10pIikpCgoKdmlzdWFsbW9kZShbZXhwcl0pCQkJCQkJKnZpc3VhbG1vZGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBkZXNjcmliZXMgdGhlIGxhc3QgVmlzdWFsIG1vZGUKCQl1c2VkIGluIHRoZSBjdXJyZW50IGJ1ZmZlci4gIEluaXRpYWxseSBpdCByZXR1cm5zIGFuIGVtcHR5CgkJc3RyaW5nLCBidXQgb25jZSBWaXN1YWwgbW9kZSBoYXMgYmVlbiB1c2VkLCBpdCByZXR1cm5zICJ2IiwKCQkiViIsIG9yICI8Q1RSTC1WPiIgKGEgc2luZ2xlIENUUkwtViBjaGFyYWN0ZXIpIGZvcgoJCWNoYXJhY3Rlci13aXNlLCBsaW5lLXdpc2UsIG9yIGJsb2NrLXdpc2UgVmlzdWFsIG1vZGUKCQlyZXNwZWN0aXZlbHkuCgkJRXhhbXBsZTogPgoJCQk6ZXhlICJub3JtYWwgIiAuIHZpc3VhbG1vZGUoKQo8CQlUaGlzIGVudGVycyB0aGUgc2FtZSBWaXN1YWwgbW9kZSBhcyBiZWZvcmUuICBJdCBpcyBhbHNvIHVzZWZ1bAoJCWluIHNjcmlwdHMgaWYgeW91IHdpc2ggdG8gYWN0IGRpZmZlcmVudGx5IGRlcGVuZGluZyBvbiB0aGUKCQlWaXN1YWwgbW9kZSB0aGF0IHdhcyB1c2VkLgoJCUlmIFZpc3VhbCBtb2RlIGlzIGFjdGl2ZSwgdXNlIHxtb2RlKCl8IHRvIGdldCB0aGUgVmlzdWFsIG1vZGUKCQkoZS5nLiwgaW4gYSB8OnZtYXB8KS4KCQkJCQkJCSpub24temVyby1hcmcqCgkJSWYgW2V4cHJdIGlzIHN1cHBsaWVkIGFuZCBpdCBldmFsdWF0ZXMgdG8gYSBub24temVybyBOdW1iZXIgb3IKCQlhIG5vbi1lbXB0eSBTdHJpbmcsIHRoZW4gdGhlIFZpc3VhbCBtb2RlIHdpbGwgYmUgY2xlYXJlZCBhbmQKCQl0aGUgb2xkIHZhbHVlIGlzIHJldHVybmVkLiAgTm90ZSB0aGF0ICIgIiBhbmQgIjAiIGFyZSBhbHNvCgkJbm9uLWVtcHR5IHN0cmluZ3MsIHRodXMgY2F1c2UgdGhlIG1vZGUgdG8gYmUgY2xlYXJlZC4gIEEgTGlzdCwKCQlEaWN0aW9uYXJ5IG9yIEZsb2F0IGlzIG5vdCBhIE51bWJlciBvciBTdHJpbmcsIHRodXMgZG9lcyBub3QKCQljYXVzZSB0aGUgbW9kZSB0byBiZSBjbGVhcmVkLgoKCQkJCQkJCSp3aW5idWZucigpKgp3aW5idWZucih7bnJ9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBidWZmZXIKCQlhc3NvY2lhdGVkIHdpdGggd2luZG93IHtucn0uICBXaGVuIHtucn0gaXMgemVybywgdGhlIG51bWJlciBvZgoJCXRoZSBidWZmZXIgaW4gdGhlIGN1cnJlbnQgd2luZG93IGlzIHJldHVybmVkLiAgV2hlbiB3aW5kb3cKCQl7bnJ9IGRvZXNuJ3QgZXhpc3QsIC0xIGlzIHJldHVybmVkLgoJCUV4YW1wbGU6ID4KICA6ZWNobyAiVGhlIGZpbGUgaW4gdGhlIGN1cnJlbnQgd2luZG93IGlzICIgLiBidWZuYW1lKHdpbmJ1Zm5yKDApKQo8CgkJCQkJCQkqd2luY29sKCkqCndpbmNvbCgpCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSB2aXJ0dWFsIGNvbHVtbiBvZiB0aGUKCQljdXJzb3IgaW4gdGhlIHdpbmRvdy4gIFRoaXMgaXMgY291bnRpbmcgc2NyZWVuIGNlbGxzIGZyb20gdGhlCgkJbGVmdCBzaWRlIG9mIHRoZSB3aW5kb3cuICBUaGUgbGVmdG1vc3QgY29sdW1uIGlzIG9uZS4KCndpbmhlaWdodCh7bnJ9KQkJCQkJCSp3aW5oZWlnaHQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgaGVpZ2h0IG9mIHdpbmRvdyB7bnJ9LgoJCVdoZW4ge25yfSBpcyB6ZXJvLCB0aGUgaGVpZ2h0IG9mIHRoZSBjdXJyZW50IHdpbmRvdyBpcwoJCXJldHVybmVkLiAgV2hlbiB3aW5kb3cge25yfSBkb2Vzbid0IGV4aXN0LCAtMSBpcyByZXR1cm5lZC4KCQlBbiBleGlzdGluZyB3aW5kb3cgYWx3YXlzIGhhcyBhIGhlaWdodCBvZiB6ZXJvIG9yIG1vcmUuCgkJRXhhbXBsZXM6ID4KICA6ZWNobyAiVGhlIGN1cnJlbnQgd2luZG93IGhhcyAiIC4gd2luaGVpZ2h0KDApIC4gIiBsaW5lcy4iCjwKCQkJCQkJCSp3aW5saW5lKCkqCndpbmxpbmUoKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgc2NyZWVuIGxpbmUgb2YgdGhlIGN1cnNvcgoJCWluIHRoZSB3aW5kb3cuCVRoaXMgaXMgY291bnRpbmcgc2NyZWVuIGxpbmVzIGZyb20gdGhlIHRvcCBvZgoJCXRoZSB3aW5kb3cuICBUaGUgZmlyc3QgbGluZSBpcyBvbmUuCgkJSWYgdGhlIGN1cnNvciB3YXMgbW92ZWQgdGhlIHZpZXcgb24gdGhlIGZpbGUgd2lsbCBiZSB1cGRhdGVkCgkJZmlyc3QsIHRoaXMgbWF5IGNhdXNlIGEgc2Nyb2xsLgoKCQkJCQkJCSp3aW5ucigpKgp3aW5ucihbe2FyZ31dKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBjdXJyZW50CgkJd2luZG93LiAgVGhlIHRvcCB3aW5kb3cgaGFzIG51bWJlciAxLgoJCVdoZW4gdGhlIG9wdGlvbmFsIGFyZ3VtZW50IGlzICIkIiwgdGhlIG51bWJlciBvZiB0aGUKCQlsYXN0IHdpbmRvdyBpcyByZXR1cm5lZCAodGhlIHdpbmRvdyBjb3VudCkuCgkJV2hlbiB0aGUgb3B0aW9uYWwgYXJndW1lbnQgaXMgIiMiLCB0aGUgbnVtYmVyIG9mIHRoZSBsYXN0CgkJYWNjZXNzZWQgd2luZG93IGlzIHJldHVybmVkICh3aGVyZSB8Q1RSTC1XX3B8IGdvZXMgdG8pLgoJCUlmIHRoZXJlIGlzIG5vIHByZXZpb3VzIHdpbmRvdyBvciBpdCBpcyBpbiBhbm90aGVyIHRhYiBwYWdlIDAKCQlpcyByZXR1cm5lZC4KCQlUaGUgbnVtYmVyIGNhbiBiZSB1c2VkIHdpdGggfENUUkwtV193fCBhbmQgIjp3aW5jbWQgdyIKCQl8OndpbmNtZHwuCgkJQWxzbyBzZWUgfHRhYnBhZ2V3aW5ucigpfC4KCgkJCQkJCQkqd2lucmVzdGNtZCgpKgp3aW5yZXN0Y21kKCkJUmV0dXJucyBhIHNlcXVlbmNlIG9mIHw6cmVzaXplfCBjb21tYW5kcyB0aGF0IHNob3VsZCByZXN0b3JlCgkJdGhlIGN1cnJlbnQgd2luZG93IHNpemVzLiAgT25seSB3b3JrcyBwcm9wZXJseSB3aGVuIG5vIHdpbmRvd3MKCQlhcmUgb3BlbmVkIG9yIGNsb3NlZCBhbmQgdGhlIGN1cnJlbnQgd2luZG93IGFuZCB0YWIgcGFnZSBpcwoJCXVuY2hhbmdlZC4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgY21kID0gd2lucmVzdGNtZCgpCgkJCTpjYWxsIE1lc3NXaXRoV2luZG93U2l6ZXMoKQoJCQk6ZXhlIGNtZAo8CgkJCQkJCQkqd2lucmVzdHZpZXcoKSoKd2lucmVzdHZpZXcoe2RpY3R9KQoJCVVzZXMgdGhlIHxEaWN0aW9uYXJ5fCByZXR1cm5lZCBieSB8d2luc2F2ZXZpZXcoKXwgdG8gcmVzdG9yZQoJCXRoZSB2aWV3IG9mIHRoZSBjdXJyZW50IHdpbmRvdy4KCQlJZiB5b3UgaGF2ZSBjaGFuZ2VkIHRoZSB2YWx1ZXMgdGhlIHJlc3VsdCBpcyB1bnByZWRpY3RhYmxlLgoJCUlmIHRoZSB3aW5kb3cgc2l6ZSBjaGFuZ2VkIHRoZSByZXN1bHQgd29uJ3QgYmUgdGhlIHNhbWUuCgoJCQkJCQkJKndpbnNhdmV2aWV3KCkqCndpbnNhdmV2aWV3KCkJUmV0dXJucyBhIHxEaWN0aW9uYXJ5fCB0aGF0IGNvbnRhaW5zIGluZm9ybWF0aW9uIHRvIHJlc3RvcmUKCQl0aGUgdmlldyBvZiB0aGUgY3VycmVudCB3aW5kb3cuICBVc2UgfHdpbnJlc3R2aWV3KCl8IHRvCgkJcmVzdG9yZSB0aGUgdmlldy4KCQlUaGlzIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBhIG1hcHBpbmcgdGhhdCBqdW1wcyBhcm91bmQgaW4gdGhlCgkJYnVmZmVyIGFuZCB5b3Ugd2FudCB0byBnbyBiYWNrIHRvIHRoZSBvcmlnaW5hbCB2aWV3LgoJCVRoaXMgZG9lcyBub3Qgc2F2ZSBmb2xkIGluZm9ybWF0aW9uLiAgVXNlIHRoZSAnZm9sZGVuYWJsZScKCQlvcHRpb24gdG8gdGVtcG9yYXJpbHkgc3dpdGNoIG9mZiBmb2xkaW5nLCBzbyB0aGF0IGZvbGRzIGFyZQoJCW5vdCBvcGVuZWQgd2hlbiBtb3ZpbmcgYXJvdW5kLgoJCVRoZSByZXR1cm4gdmFsdWUgaW5jbHVkZXM6CgkJCWxudW0JCWN1cnNvciBsaW5lIG51bWJlcgoJCQljb2wJCWN1cnNvciBjb2x1bW4KCQkJY29sYWRkCQljdXJzb3IgY29sdW1uIG9mZnNldCBmb3IgJ3ZpcnR1YWxlZGl0JwoJCQljdXJzd2FudAljb2x1bW4gZm9yIHZlcnRpY2FsIG1vdmVtZW50CgkJCXRvcGxpbmUJCWZpcnN0IGxpbmUgaW4gdGhlIHdpbmRvdwoJCQl0b3BmaWxsCQlmaWxsZXIgbGluZXMsIG9ubHkgaW4gZGlmZiBtb2RlCgkJCWxlZnRjb2wJCWZpcnN0IGNvbHVtbiBkaXNwbGF5ZWQKCQkJc2tpcGNvbAkJY29sdW1ucyBza2lwcGVkCgkJTm90ZSB0aGF0IG5vIG9wdGlvbiB2YWx1ZXMgYXJlIHNhdmVkLgoKCndpbndpZHRoKHtucn0pCQkJCQkJKndpbndpZHRoKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIHdpZHRoIG9mIHdpbmRvdyB7bnJ9LgoJCVdoZW4ge25yfSBpcyB6ZXJvLCB0aGUgd2lkdGggb2YgdGhlIGN1cnJlbnQgd2luZG93IGlzCgkJcmV0dXJuZWQuICBXaGVuIHdpbmRvdyB7bnJ9IGRvZXNuJ3QgZXhpc3QsIC0xIGlzIHJldHVybmVkLgoJCUFuIGV4aXN0aW5nIHdpbmRvdyBhbHdheXMgaGFzIGEgd2lkdGggb2YgemVybyBvciBtb3JlLgoJCUV4YW1wbGVzOiA+CiAgOmVjaG8gIlRoZSBjdXJyZW50IHdpbmRvdyBoYXMgIiAuIHdpbndpZHRoKDApIC4gIiBjb2x1bW5zLiIKICA6aWYgd2lud2lkdGgoMCkgPD0gNTAKICA6ICBleGUgIm5vcm1hbCA1MFw8Qy1XPnwiCiAgOmVuZGlmCjwKCQkJCQkJCSp3cml0ZWZpbGUoKSoKd3JpdGVmaWxlKHtsaXN0fSwge2ZuYW1lfSBbLCB7YmluYXJ5fV0pCgkJV3JpdGUgfExpc3R8IHtsaXN0fSB0byBmaWxlIHtmbmFtZX0uICBFYWNoIGxpc3QgaXRlbSBpcwoJCXNlcGFyYXRlZCB3aXRoIGEgTkwuICBFYWNoIGxpc3QgaXRlbSBtdXN0IGJlIGEgU3RyaW5nIG9yCgkJTnVtYmVyLgoJCVdoZW4ge2JpbmFyeX0gaXMgZXF1YWwgdG8gImIiIGJpbmFyeSBtb2RlIGlzIHVzZWQ6IFRoZXJlIHdpbGwKCQlub3QgYmUgYSBOTCBhZnRlciB0aGUgbGFzdCBsaXN0IGl0ZW0uICBBbiBlbXB0eSBpdGVtIGF0IHRoZQoJCWVuZCBkb2VzIGNhdXNlIHRoZSBsYXN0IGxpbmUgaW4gdGhlIGZpbGUgdG8gZW5kIGluIGEgTkwuCgkJQWxsIE5MIGNoYXJhY3RlcnMgYXJlIHJlcGxhY2VkIHdpdGggYSBOVUwgY2hhcmFjdGVyLgoJCUluc2VydGluZyBDUiBjaGFyYWN0ZXJzIG5lZWRzIHRvIGJlIGRvbmUgYmVmb3JlIHBhc3Npbmcge2xpc3R9CgkJdG8gd3JpdGVmaWxlKCkuCgkJQW4gZXhpc3RpbmcgZmlsZSBpcyBvdmVyd3JpdHRlbiwgaWYgcG9zc2libGUuCgkJV2hlbiB0aGUgd3JpdGUgZmFpbHMgLTEgaXMgcmV0dXJuZWQsIG90aGVyd2lzZSAwLiAgVGhlcmUgaXMgYW4KCQllcnJvciBtZXNzYWdlIGlmIHRoZSBmaWxlIGNhbid0IGJlIGNyZWF0ZWQgb3Igd2hlbiB3cml0aW5nCgkJZmFpbHMuCgkJQWxzbyBzZWUgfHJlYWRmaWxlKCl8LgoJCVRvIGNvcHkgYSBmaWxlIGJ5dGUgZm9yIGJ5dGU6ID4KCQkJOmxldCBmbCA9IHJlYWRmaWxlKCJmb28iLCAiYiIpCgkJCTpjYWxsIHdyaXRlZmlsZShmbCwgImZvb2NvcHkiLCAiYiIpCgoKeG9yKHtleHByfSwge2V4cHJ9KQkJCQkJKnhvcigpKgoJCUJpdHdpc2UgWE9SIG9uIHRoZSB0d28gYXJndW1lbnRzLiAgVGhlIGFyZ3VtZW50cyBhcmUgY29udmVydGVkCgkJdG8gYSBudW1iZXIuICBBIExpc3QsIERpY3Qgb3IgRmxvYXQgYXJndW1lbnQgY2F1c2VzIGFuIGVycm9yLgoJCUV4YW1wbGU6ID4KCQkJOmxldCBiaXRzID0geG9yKGJpdHMsIDB4ODApCjwKCgoJCQkJCQkJKmZlYXR1cmUtbGlzdCoKVGhlcmUgYXJlIHRocmVlIHR5cGVzIG9mIGZlYXR1cmVzOgoxLiAgRmVhdHVyZXMgdGhhdCBhcmUgb25seSBzdXBwb3J0ZWQgd2hlbiB0aGV5IGhhdmUgYmVlbiBlbmFibGVkIHdoZW4gVmltCiAgICB3YXMgY29tcGlsZWQgfCtmZWF0dXJlLWxpc3R8LiAgRXhhbXBsZTogPgoJOmlmIGhhcygiY2luZGVudCIpCjIuICBGZWF0dXJlcyB0aGF0IGFyZSBvbmx5IHN1cHBvcnRlZCB3aGVuIGNlcnRhaW4gY29uZGl0aW9ucyBoYXZlIGJlZW4gbWV0LgogICAgRXhhbXBsZTogPgoJOmlmIGhhcygiZ3VpX3J1bm5pbmciKQo8CQkJCQkJCSpoYXMtcGF0Y2gqCjMuICBJbmNsdWRlZCBwYXRjaGVzLiAgRmlyc3QgY2hlY2sgfHY6dmVyc2lvbnwgZm9yIHRoZSB2ZXJzaW9uIG9mIFZpbS4KICAgIFRoZW4gdGhlICJwYXRjaDEyMyIgZmVhdHVyZSBtZWFucyB0aGF0IHBhdGNoIDEyMyBoYXMgYmVlbiBpbmNsdWRlZCBmb3IKICAgIHRoaXMgdmVyc2lvbi4gIEV4YW1wbGUgKGNoZWNraW5nIHZlcnNpb24gNi4yLjE0OCBvciBsYXRlcik6ID4KCTppZiB2OnZlcnNpb24gPiA2MDIgfHwgdjp2ZXJzaW9uID09IDYwMiAmJiBoYXMoInBhdGNoMTQ4IikKPCAgIE5vdGUgdGhhdCBpdCdzIHBvc3NpYmxlIGZvciBwYXRjaCAxNDcgdG8gYmUgb21pdHRlZCBldmVuIHRob3VnaCAxNDggaXMKICAgIGluY2x1ZGVkLgoKYWxsX2J1aWx0aW5fdGVybXMJQ29tcGlsZWQgd2l0aCBhbGwgYnVpbHRpbiB0ZXJtaW5hbHMgZW5hYmxlZC4KYW1pZ2EJCQlBbWlnYSB2ZXJzaW9uIG9mIFZpbS4KYXJhYmljCQkJQ29tcGlsZWQgd2l0aCBBcmFiaWMgc3VwcG9ydCB8QXJhYmljfC4KYXJwCQkJQ29tcGlsZWQgd2l0aCBBUlAgc3VwcG9ydCAoQW1pZ2EpLgphdXRvY21kCQkJQ29tcGlsZWQgd2l0aCBhdXRvY29tbWFuZCBzdXBwb3J0LiB8YXV0b2NvbW1hbmR8CmJhbGxvb25fZXZhbAkJQ29tcGlsZWQgd2l0aCB8YmFsbG9vbi1ldmFsfCBzdXBwb3J0LgpiYWxsb29uX211bHRpbGluZQlHVUkgc3VwcG9ydHMgbXVsdGlsaW5lIGJhbGxvb25zLgpiZW9zCQkJQmVPUyB2ZXJzaW9uIG9mIFZpbS4KYnJvd3NlCQkJQ29tcGlsZWQgd2l0aCB8OmJyb3dzZXwgc3VwcG9ydCwgYW5kIGJyb3dzZSgpIHdpbGwKCQkJd29yay4KYnVpbHRpbl90ZXJtcwkJQ29tcGlsZWQgd2l0aCBzb21lIGJ1aWx0aW4gdGVybWluYWxzLgpieXRlX29mZnNldAkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciAnbycgaW4gJ3N0YXR1c2xpbmUnCmNpbmRlbnQJCQlDb21waWxlZCB3aXRoICdjaW5kZW50JyBzdXBwb3J0LgpjbGllbnRzZXJ2ZXIJCUNvbXBpbGVkIHdpdGggcmVtb3RlIGludm9jYXRpb24gc3VwcG9ydCB8Y2xpZW50c2VydmVyfC4KY2xpcGJvYXJkCQlDb21waWxlZCB3aXRoICdjbGlwYm9hcmQnIHN1cHBvcnQuCmNtZGxpbmVfY29tcGwJCUNvbXBpbGVkIHdpdGggfGNtZGxpbmUtY29tcGxldGlvbnwgc3VwcG9ydC4KY21kbGluZV9oaXN0CQlDb21waWxlZCB3aXRoIHxjbWRsaW5lLWhpc3Rvcnl8IHN1cHBvcnQuCmNtZGxpbmVfaW5mbwkJQ29tcGlsZWQgd2l0aCAnc2hvd2NtZCcgYW5kICdydWxlcicgc3VwcG9ydC4KY29tbWVudHMJCUNvbXBpbGVkIHdpdGggfCdjb21tZW50cyd8IHN1cHBvcnQuCmNvbXBhdGlibGUJCUNvbXBpbGVkIHRvIGJlIHZlcnkgVmkgY29tcGF0aWJsZS4KY3J5cHR2CQkJQ29tcGlsZWQgd2l0aCBlbmNyeXB0aW9uIHN1cHBvcnQgfGVuY3J5cHRpb258Lgpjc2NvcGUJCQlDb21waWxlZCB3aXRoIHxjc2NvcGV8IHN1cHBvcnQuCmRlYnVnCQkJQ29tcGlsZWQgd2l0aCAiREVCVUciIGRlZmluZWQuCmRpYWxvZ19jb24JCUNvbXBpbGVkIHdpdGggY29uc29sZSBkaWFsb2cgc3VwcG9ydC4KZGlhbG9nX2d1aQkJQ29tcGlsZWQgd2l0aCBHVUkgZGlhbG9nIHN1cHBvcnQuCmRpZmYJCQlDb21waWxlZCB3aXRoIHx2aW1kaWZmfCBhbmQgJ2RpZmYnIHN1cHBvcnQuCmRpZ3JhcGhzCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIGRpZ3JhcGhzLgpkbmQJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHRoZSAifiByZWdpc3RlciB8cXVvdGVffnwuCmRvczE2CQkJMTYgYml0cyBET1MgdmVyc2lvbiBvZiBWaW0uCmRvczMyCQkJMzIgYml0cyBET1MgKERKR1BQKSB2ZXJzaW9uIG9mIFZpbS4KZWJjZGljCQkJQ29tcGlsZWQgb24gYSBtYWNoaW5lIHdpdGggZWJjZGljIGNoYXJhY3RlciBzZXQuCmVtYWNzX3RhZ3MJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgRW1hY3MgdGFncy4KZXZhbAkJCUNvbXBpbGVkIHdpdGggZXhwcmVzc2lvbiBldmFsdWF0aW9uIHN1cHBvcnQuICBBbHdheXMKCQkJdHJ1ZSwgb2YgY291cnNlIQpleF9leHRyYQkJQ29tcGlsZWQgd2l0aCBleHRyYSBFeCBjb21tYW5kcyB8K2V4X2V4dHJhfC4KZXh0cmFfc2VhcmNoCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHwnaW5jc2VhcmNoJ3wgYW5kCgkJCXwnaGxzZWFyY2gnfApmYXJzaQkJCUNvbXBpbGVkIHdpdGggRmFyc2kgc3VwcG9ydCB8ZmFyc2l8LgpmaWxlX2luX3BhdGgJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgfGdmfCBhbmQgfDxjZmlsZT58CmZpbHRlcnBpcGUJCVdoZW4gJ3NoZWxsdGVtcCcgaXMgb2ZmIHBpcGVzIGFyZSB1c2VkIGZvciBzaGVsbAoJCQlyZWFkL3dyaXRlL2ZpbHRlciBjb21tYW5kcwpmaW5kX2luX3BhdGgJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgaW5jbHVkZSBmaWxlIHNlYXJjaGVzCgkJCXwrZmluZF9pbl9wYXRofC4KZmxvYXQJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHxGbG9hdHwuCmZuYW1lX2Nhc2UJCUNhc2UgaW4gZmlsZSBuYW1lcyBtYXR0ZXJzIChmb3IgQW1pZ2EsIE1TLURPUywgYW5kCgkJCVdpbmRvd3MgdGhpcyBpcyBub3QgcHJlc2VudCkuCmZvbGRpbmcJCQlDb21waWxlZCB3aXRoIHxmb2xkaW5nfCBzdXBwb3J0Lgpmb290ZXIJCQlDb21waWxlZCB3aXRoIEdVSSBmb290ZXIgc3VwcG9ydC4gfGd1aS1mb290ZXJ8CmZvcmsJCQlDb21waWxlZCB0byB1c2UgZm9yaygpL2V4ZWMoKSBpbnN0ZWFkIG9mIHN5c3RlbSgpLgpnZXR0ZXh0CQkJQ29tcGlsZWQgd2l0aCBtZXNzYWdlIHRyYW5zbGF0aW9uIHxtdWx0aS1sYW5nfApndWkJCQlDb21waWxlZCB3aXRoIEdVSSBlbmFibGVkLgpndWlfYXRoZW5hCQlDb21waWxlZCB3aXRoIEF0aGVuYSBHVUkuCmd1aV9nbm9tZQkJQ29tcGlsZWQgd2l0aCBHbm9tZSBzdXBwb3J0IChndWlfZ3RrIGlzIGFsc28gZGVmaW5lZCkuCmd1aV9ndGsJCQlDb21waWxlZCB3aXRoIEdUSysgR1VJIChhbnkgdmVyc2lvbikuCmd1aV9ndGsyCQlDb21waWxlZCB3aXRoIEdUSysgMiBHVUkgKGd1aV9ndGsgaXMgYWxzbyBkZWZpbmVkKS4KZ3VpX21hYwkJCUNvbXBpbGVkIHdpdGggTWFjaW50b3NoIEdVSS4KZ3VpX21vdGlmCQlDb21waWxlZCB3aXRoIE1vdGlmIEdVSS4KZ3VpX3Bob3RvbgkJQ29tcGlsZWQgd2l0aCBQaG90b24gR1VJLgpndWlfcnVubmluZwkJVmltIGlzIHJ1bm5pbmcgaW4gdGhlIEdVSSwgb3IgaXQgd2lsbCBzdGFydCBzb29uLgpndWlfd2luMzIJCUNvbXBpbGVkIHdpdGggTVMgV2luZG93cyBXaW4zMiBHVUkuCmd1aV93aW4zMnMJCWlkZW0sIGFuZCBXaW4zMnMgc3lzdGVtIGJlaW5nIHVzZWQgKFdpbmRvd3MgMy4xKQpoYW5ndWxfaW5wdXQJCUNvbXBpbGVkIHdpdGggSGFuZ3VsIGlucHV0IHN1cHBvcnQuIHxoYW5ndWx8Cmljb252CQkJQ2FuIHVzZSBpY29udigpIGZvciBjb252ZXJzaW9uLgppbnNlcnRfZXhwYW5kCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIENUUkwtWCBleHBhbnNpb24gY29tbWFuZHMgaW4KCQkJSW5zZXJ0IG1vZGUuCmp1bXBsaXN0CQlDb21waWxlZCB3aXRoIHxqdW1wbGlzdHwgc3VwcG9ydC4Ka2V5bWFwCQkJQ29tcGlsZWQgd2l0aCAna2V5bWFwJyBzdXBwb3J0LgpsYW5nbWFwCQkJQ29tcGlsZWQgd2l0aCAnbGFuZ21hcCcgc3VwcG9ydC4KbGliY2FsbAkJCUNvbXBpbGVkIHdpdGggfGxpYmNhbGwoKXwgc3VwcG9ydC4KbGluZWJyZWFrCQlDb21waWxlZCB3aXRoICdsaW5lYnJlYWsnLCAnYnJlYWthdCcgYW5kICdzaG93YnJlYWsnCgkJCXN1cHBvcnQuCmxpc3BpbmRlbnQJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgbGlzcCBpbmRlbnRpbmcuCmxpc3RjbWRzCQlDb21waWxlZCB3aXRoIGNvbW1hbmRzIGZvciB0aGUgYnVmZmVyIGxpc3QgfDpmaWxlc3wKCQkJYW5kIHRoZSBhcmd1bWVudCBsaXN0IHxhcmdsaXN0fC4KbG9jYWxtYXAJCUNvbXBpbGVkIHdpdGggbG9jYWwgbWFwcGluZ3MgYW5kIGFiYnIuIHw6bWFwLWxvY2FsfApsdWEJCQlDb21waWxlZCB3aXRoIEx1YSBpbnRlcmZhY2UgfEx1YXwuCm1hYwkJCU1hY2ludG9zaCB2ZXJzaW9uIG9mIFZpbS4KbWFjdW5peAkJCU1hY2ludG9zaCB2ZXJzaW9uIG9mIFZpbSwgdXNpbmcgVW5peCBmaWxlcyAoT1MtWCkuCm1lbnUJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHw6bWVudXwuCm1rc2Vzc2lvbgkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciB8Om1rc2Vzc2lvbnwuCm1vZGlmeV9mbmFtZQkJQ29tcGlsZWQgd2l0aCBmaWxlIG5hbWUgbW9kaWZpZXJzLiB8ZmlsZW5hbWUtbW9kaWZpZXJzfAptb3VzZQkJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBtb3VzZS4KbW91c2VfZGVjCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIERlYyB0ZXJtaW5hbCBtb3VzZS4KbW91c2VfZ3BtCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIGdwbSAoTGludXggY29uc29sZSBtb3VzZSkKbW91c2VfbmV0dGVybQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBuZXR0ZXJtIG1vdXNlLgptb3VzZV9wdGVybQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBxbnggcHRlcm0gbW91c2UuCm1vdXNlX3N5c21vdXNlCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHN5c21vdXNlICgqQlNEIGNvbnNvbGUgbW91c2UpCm1vdXNlX3VyeHZ0CQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHVyeHZ0IG1vdXNlLgptb3VzZV94dGVybQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciB4dGVybSBtb3VzZS4KbW91c2VzaGFwZQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciAnbW91c2VzaGFwZScuCm11bHRpX2J5dGUJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgJ2VuY29kaW5nJwptdWx0aV9ieXRlX2VuY29kaW5nCSdlbmNvZGluZycgaXMgc2V0IHRvIGEgbXVsdGktYnl0ZSBlbmNvZGluZy4KbXVsdGlfYnl0ZV9pbWUJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgSU1FIGlucHV0IG1ldGhvZC4KbXVsdGlfbGFuZwkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBtdWx0aXBsZSBsYW5ndWFnZXMuCm16c2NoZW1lCQlDb21waWxlZCB3aXRoIE16U2NoZW1lIGludGVyZmFjZSB8bXpzY2hlbWV8LgpuZXRiZWFuc19lbmFibGVkCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgfG5ldGJlYW5zfCBhbmQgY29ubmVjdGVkLgpuZXRiZWFuc19pbnRnCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHxuZXRiZWFuc3wuCm9sZQkJCUNvbXBpbGVkIHdpdGggT0xFIGF1dG9tYXRpb24gc3VwcG9ydCBmb3IgV2luMzIuCm9zMgkJCU9TLzIgdmVyc2lvbiBvZiBWaW0uCnBhdGhfZXh0cmEJCUNvbXBpbGVkIHdpdGggdXAvZG93bndhcmRzIHNlYXJjaCBpbiAncGF0aCcgYW5kICd0YWdzJwpwZXJsCQkJQ29tcGlsZWQgd2l0aCBQZXJsIGludGVyZmFjZS4KcGVyc2lzdGVudF91bmRvCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHBlcnNpc3RlbnQgdW5kbyBoaXN0b3J5Lgpwb3N0c2NyaXB0CQlDb21waWxlZCB3aXRoIFBvc3RTY3JpcHQgZmlsZSBwcmludGluZy4KcHJpbnRlcgkJCUNvbXBpbGVkIHdpdGggfDpoYXJkY29weXwgc3VwcG9ydC4KcHJvZmlsZQkJCUNvbXBpbGVkIHdpdGggfDpwcm9maWxlfCBzdXBwb3J0LgpweXRob24JCQlDb21waWxlZCB3aXRoIFB5dGhvbiAyLnggaW50ZXJmYWNlLiB8aGFzLXB5dGhvbnwKcHl0aG9uMwkJCUNvbXBpbGVkIHdpdGggUHl0aG9uIDMueCBpbnRlcmZhY2UuIHxoYXMtcHl0aG9ufApxbngJCQlRTlggdmVyc2lvbiBvZiBWaW0uCnF1aWNrZml4CQlDb21waWxlZCB3aXRoIHxxdWlja2ZpeHwgc3VwcG9ydC4KcmVsdGltZQkJCUNvbXBpbGVkIHdpdGggfHJlbHRpbWUoKXwgc3VwcG9ydC4KcmlnaHRsZWZ0CQlDb21waWxlZCB3aXRoICdyaWdodGxlZnQnIHN1cHBvcnQuCnJ1YnkJCQlDb21waWxlZCB3aXRoIFJ1YnkgaW50ZXJmYWNlIHxydWJ5fC4Kc2Nyb2xsYmluZAkJQ29tcGlsZWQgd2l0aCAnc2Nyb2xsYmluZCcgc3VwcG9ydC4Kc2hvd2NtZAkJCUNvbXBpbGVkIHdpdGggJ3Nob3djbWQnIHN1cHBvcnQuCnNpZ25zCQkJQ29tcGlsZWQgd2l0aCB8OnNpZ258IHN1cHBvcnQuCnNtYXJ0aW5kZW50CQlDb21waWxlZCB3aXRoICdzbWFydGluZGVudCcgc3VwcG9ydC4Kc25pZmYJCQlDb21waWxlZCB3aXRoIFNOaUZGIGludGVyZmFjZSBzdXBwb3J0LgpzcGVsbAkJCUNvbXBpbGVkIHdpdGggc3BlbGwgY2hlY2tpbmcgc3VwcG9ydCB8c3BlbGx8LgpzdGFydHVwdGltZQkJQ29tcGlsZWQgd2l0aCB8LS1zdGFydHVwdGltZXwgc3VwcG9ydC4Kc3RhdHVzbGluZQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciAnc3RhdHVzbGluZScsICdydWxlcmZvcm1hdCcKCQkJYW5kIHNwZWNpYWwgZm9ybWF0cyBvZiAndGl0bGVzdHJpbmcnIGFuZCAnaWNvbnN0cmluZycuCnN1bl93b3Jrc2hvcAkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBTdW4gfHdvcmtzaG9wfC4Kc3ludGF4CQkJQ29tcGlsZWQgd2l0aCBzeW50YXggaGlnaGxpZ2h0aW5nIHN1cHBvcnQgfHN5bnRheHwuCnN5bnRheF9pdGVtcwkJVGhlcmUgYXJlIGFjdGl2ZSBzeW50YXggaGlnaGxpZ2h0aW5nIGl0ZW1zIGZvciB0aGUKCQkJY3VycmVudCBidWZmZXIuCnN5c3RlbQkJCUNvbXBpbGVkIHRvIHVzZSBzeXN0ZW0oKSBpbnN0ZWFkIG9mIGZvcmsoKS9leGVjKCkuCnRhZ19iaW5hcnkJCUNvbXBpbGVkIHdpdGggYmluYXJ5IHNlYXJjaGluZyBpbiB0YWdzIGZpbGVzCgkJCXx0YWctYmluYXJ5LXNlYXJjaHwuCnRhZ19vbGRfc3RhdGljCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIG9sZCBzdGF0aWMgdGFncwoJCQl8dGFnLW9sZC1zdGF0aWN8Lgp0YWdfYW55X3doaXRlCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIGFueSB3aGl0ZSBjaGFyYWN0ZXJzIGluIHRhZ3MKCQkJZmlsZXMgfHRhZy1hbnktd2hpdGV8Lgp0Y2wJCQlDb21waWxlZCB3aXRoIFRjbCBpbnRlcmZhY2UuCnRlcm1pbmZvCQlDb21waWxlZCB3aXRoIHRlcm1pbmZvIGluc3RlYWQgb2YgdGVybWNhcC4KdGVybXJlc3BvbnNlCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHx0X1JWfCBhbmQgfHY6dGVybXJlc3BvbnNlfC4KdGV4dG9iamVjdHMJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgfHRleHQtb2JqZWN0c3wuCnRnZXRlbnQJCQlDb21waWxlZCB3aXRoIHRnZXRlbnQgc3VwcG9ydCwgYWJsZSB0byB1c2UgYSB0ZXJtY2FwCgkJCW9yIHRlcm1pbmZvIGZpbGUuCnRpdGxlCQkJQ29tcGlsZWQgd2l0aCB3aW5kb3cgdGl0bGUgc3VwcG9ydCB8J3RpdGxlJ3wuCnRvb2xiYXIJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHxndWktdG9vbGJhcnwuCnVuaXgJCQlVbml4IHZlcnNpb24gb2YgVmltLgp1c2VyX2NvbW1hbmRzCQlVc2VyLWRlZmluZWQgY29tbWFuZHMuCnZlcnRzcGxpdAkJQ29tcGlsZWQgd2l0aCB2ZXJ0aWNhbGx5IHNwbGl0IHdpbmRvd3MgfDp2c3BsaXR8Lgp2aW1fc3RhcnRpbmcJCVRydWUgd2hpbGUgaW5pdGlhbCBzb3VyY2UnaW5nIHRha2VzIHBsYWNlLiB8c3RhcnR1cHwKdmltaW5mbwkJCUNvbXBpbGVkIHdpdGggdmltaW5mbyBzdXBwb3J0Lgp2aXJ0dWFsZWRpdAkJQ29tcGlsZWQgd2l0aCAndmlydHVhbGVkaXQnIG9wdGlvbi4KdmlzdWFsCQkJQ29tcGlsZWQgd2l0aCBWaXN1YWwgbW9kZS4KdmlzdWFsZXh0cmEJCUNvbXBpbGVkIHdpdGggZXh0cmEgVmlzdWFsIG1vZGUgY29tbWFuZHMuCgkJCXxibG9ja3dpc2Utb3BlcmF0b3JzfC4Kdm1zCQkJVk1TIHZlcnNpb24gb2YgVmltLgp2cmVwbGFjZQkJQ29tcGlsZWQgd2l0aCB8Z1J8IGFuZCB8Z3J8IGNvbW1hbmRzLgp3aWxkaWdub3JlCQlDb21waWxlZCB3aXRoICd3aWxkaWdub3JlJyBvcHRpb24uCndpbGRtZW51CQlDb21waWxlZCB3aXRoICd3aWxkbWVudScgb3B0aW9uLgp3aW4xNgkJCVdpbjE2IHZlcnNpb24gb2YgVmltIChNUy1XaW5kb3dzIDMuMSkuCndpbjMyCQkJV2luMzIgdmVyc2lvbiBvZiBWaW0gKE1TLVdpbmRvd3MgOTUgYW5kIGxhdGVyLCAzMiBvcgoJCQk2NCBiaXRzKQp3aW4zMnVuaXgJCVdpbjMyIHZlcnNpb24gb2YgVmltLCB1c2luZyBVbml4IGZpbGVzIChDeWd3aW4pCndpbjY0CQkJV2luNjQgdmVyc2lvbiBvZiBWaW0gKE1TLVdpbmRvd3MgNjQgYml0KS4Kd2luOTUJCQlXaW4zMiB2ZXJzaW9uIGZvciBNUy1XaW5kb3dzIDk1Lzk4L01FLgp3aW5hbHRrZXlzCQlDb21waWxlZCB3aXRoICd3aW5hbHRrZXlzJyBvcHRpb24uCndpbmRvd3MJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIG1vcmUgdGhhbiBvbmUgd2luZG93Lgp3cml0ZWJhY2t1cAkJQ29tcGlsZWQgd2l0aCAnd3JpdGViYWNrdXAnIGRlZmF1bHQgb24uCnhmb250c2V0CQlDb21waWxlZCB3aXRoIFggZm9udHNldCBzdXBwb3J0IHx4Zm9udHNldHwuCnhpbQkJCUNvbXBpbGVkIHdpdGggWCBpbnB1dCBtZXRob2Qgc3VwcG9ydCB8eGltfC4KeHBtX3czMgkJCUNvbXBpbGVkIHdpdGggcGl4bWFwIHN1cHBvcnQgZm9yIFdpbjMyLgp4c21wCQkJQ29tcGlsZWQgd2l0aCBYIHNlc3Npb24gbWFuYWdlbWVudCBzdXBwb3J0Lgp4c21wX2ludGVyYWN0CQlDb21waWxlZCB3aXRoIGludGVyYWN0aXZlIFggc2Vzc2lvbiBtYW5hZ2VtZW50IHN1cHBvcnQuCnh0ZXJtX2NsaXBib2FyZAkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciB4dGVybSBjbGlwYm9hcmQuCnh0ZXJtX3NhdmUJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3Igc2F2aW5nIGFuZCByZXN0b3JpbmcgdGhlCgkJCXh0ZXJtIHNjcmVlbi4KeDExCQkJQ29tcGlsZWQgd2l0aCBYMTEgc3VwcG9ydC4KCgkJCQkJCQkqc3RyaW5nLW1hdGNoKgpNYXRjaGluZyBhIHBhdHRlcm4gaW4gYSBTdHJpbmcKCkEgcmVnZXhwIHBhdHRlcm4gYXMgZXhwbGFpbmVkIGF0IHxwYXR0ZXJufCBpcyBub3JtYWxseSB1c2VkIHRvIGZpbmQgYSBtYXRjaCBpbgp0aGUgYnVmZmVyIGxpbmVzLiAgV2hlbiBhIHBhdHRlcm4gaXMgdXNlZCB0byBmaW5kIGEgbWF0Y2ggaW4gYSBTdHJpbmcsIGFsbW9zdApldmVyeXRoaW5nIHdvcmtzIGluIHRoZSBzYW1lIHdheS4gIFRoZSBkaWZmZXJlbmNlIGlzIHRoYXQgYSBTdHJpbmcgaXMgaGFuZGxlZApsaWtlIGl0IGlzIG9uZSBsaW5lLiAgV2hlbiBpdCBjb250YWlucyBhICJcbiIgY2hhcmFjdGVyLCB0aGlzIGlzIG5vdCBzZWVuIGFzIGEKbGluZSBicmVhayBmb3IgdGhlIHBhdHRlcm4uICBJdCBjYW4gYmUgbWF0Y2hlZCB3aXRoIGEgIlxuIiBpbiB0aGUgcGF0dGVybiwgb3IKd2l0aCAiLiIuICBFeGFtcGxlOiA+Cgk6bGV0IGEgPSAiYWFhYVxueHh4eCIKCTplY2hvIG1hdGNoc3RyKGEsICIuLlxuLi4iKQoJYWEKCXh4Cgk6ZWNobyBtYXRjaHN0cihhLCAiYS54IikKCWEKCXgKCkRvbid0IGZvcmdldCB0aGF0ICJeIiB3aWxsIG9ubHkgbWF0Y2ggYXQgdGhlIGZpcnN0IGNoYXJhY3RlciBvZiB0aGUgU3RyaW5nIGFuZAoiJCIgYXQgdGhlIGxhc3QgY2hhcmFjdGVyIG9mIHRoZSBzdHJpbmcuICBUaGV5IGRvbid0IG1hdGNoIGFmdGVyIG9yIGJlZm9yZSBhCiJcbiIuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KNS4gRGVmaW5pbmcgZnVuY3Rpb25zCQkJCQkqdXNlci1mdW5jdGlvbnMqCgpOZXcgZnVuY3Rpb25zIGNhbiBiZSBkZWZpbmVkLiAgVGhlc2UgY2FuIGJlIGNhbGxlZCBqdXN0IGxpa2UgYnVpbHRpbgpmdW5jdGlvbnMuICBUaGUgZnVuY3Rpb24gZXhlY3V0ZXMgYSBzZXF1ZW5jZSBvZiBFeCBjb21tYW5kcy4gIE5vcm1hbCBtb2RlCmNvbW1hbmRzIGNhbiBiZSBleGVjdXRlZCB3aXRoIHRoZSB8Om5vcm1hbHwgY29tbWFuZC4KClRoZSBmdW5jdGlvbiBuYW1lIG11c3Qgc3RhcnQgd2l0aCBhbiB1cHBlcmNhc2UgbGV0dGVyLCB0byBhdm9pZCBjb25mdXNpb24gd2l0aApidWlsdGluIGZ1bmN0aW9ucy4gIFRvIHByZXZlbnQgZnJvbSB1c2luZyB0aGUgc2FtZSBuYW1lIGluIGRpZmZlcmVudCBzY3JpcHRzCmF2b2lkIG9idmlvdXMsIHNob3J0IG5hbWVzLiAgQSBnb29kIGhhYml0IGlzIHRvIHN0YXJ0IHRoZSBmdW5jdGlvbiBuYW1lIHdpdGgKdGhlIG5hbWUgb2YgdGhlIHNjcmlwdCwgZS5nLiwgIkhUTUxjb2xvcigpIi4KCkl0J3MgYWxzbyBwb3NzaWJsZSB0byB1c2UgY3VybHkgYnJhY2VzLCBzZWUgfGN1cmx5LWJyYWNlcy1uYW1lc3wuICBBbmQgdGhlCnxhdXRvbG9hZHwgZmFjaWxpdHkgaXMgdXNlZnVsIHRvIGRlZmluZSBhIGZ1bmN0aW9uIG9ubHkgd2hlbiBpdCdzIGNhbGxlZC4KCgkJCQkJCQkqbG9jYWwtZnVuY3Rpb24qCkEgZnVuY3Rpb24gbG9jYWwgdG8gYSBzY3JpcHQgbXVzdCBzdGFydCB3aXRoICJzOiIuICBBIGxvY2FsIHNjcmlwdCBmdW5jdGlvbgpjYW4gb25seSBiZSBjYWxsZWQgZnJvbSB3aXRoaW4gdGhlIHNjcmlwdCBhbmQgZnJvbSBmdW5jdGlvbnMsIHVzZXIgY29tbWFuZHMKYW5kIGF1dG9jb21tYW5kcyBkZWZpbmVkIGluIHRoZSBzY3JpcHQuICBJdCBpcyBhbHNvIHBvc3NpYmxlIHRvIGNhbGwgdGhlCmZ1bmN0aW9uIGZyb20gYSBtYXBwaW5nIGRlZmluZWQgaW4gdGhlIHNjcmlwdCwgYnV0IHRoZW4gfDxTSUQ+fCBtdXN0IGJlIHVzZWQKaW5zdGVhZCBvZiAiczoiIHdoZW4gdGhlIG1hcHBpbmcgaXMgZXhwYW5kZWQgb3V0c2lkZSBvZiB0aGUgc2NyaXB0LgoKCQkJCQkqOmZ1KiAqOmZ1bmN0aW9uKiAqRTEyOCogKkUxMjkqICpFMTIzKgo6ZnVbbmN0aW9uXQkJTGlzdCBhbGwgZnVuY3Rpb25zIGFuZCB0aGVpciBhcmd1bWVudHMuCgo6ZnVbbmN0aW9uXSB7bmFtZX0JTGlzdCBmdW5jdGlvbiB7bmFtZX0uCgkJCXtuYW1lfSBjYW4gYWxzbyBiZSBhIHxEaWN0aW9uYXJ5fCBlbnRyeSB0aGF0IGlzIGEKCQkJfEZ1bmNyZWZ8OiA+CgkJCQk6ZnVuY3Rpb24gZGljdC5pbml0Cgo6ZnVbbmN0aW9uXSAve3BhdHRlcm59CUxpc3QgZnVuY3Rpb25zIHdpdGggYSBuYW1lIG1hdGNoaW5nIHtwYXR0ZXJufS4KCQkJRXhhbXBsZSB0aGF0IGxpc3RzIGFsbCBmdW5jdGlvbnMgZW5kaW5nIHdpdGggIkZpbGUiOiA+CgkJCQk6ZnVuY3Rpb24gL0ZpbGUkCjwKCQkJCQkJCSo6ZnVuY3Rpb24tdmVyYm9zZSoKV2hlbiAndmVyYm9zZScgaXMgbm9uLXplcm8sIGxpc3RpbmcgYSBmdW5jdGlvbiB3aWxsIGFsc28gZGlzcGxheSB3aGVyZSBpdCB3YXMKbGFzdCBkZWZpbmVkLiBFeGFtcGxlOiA+CgogICAgOnZlcmJvc2UgZnVuY3Rpb24gU2V0RmlsZVR5cGVTSAoJZnVuY3Rpb24gU2V0RmlsZVR5cGVTSChuYW1lKQoJICAgIExhc3Qgc2V0IGZyb20gL3Vzci9zaGFyZS92aW0vdmltLTcuMC9maWxldHlwZS52aW0KPApTZWUgfDp2ZXJib3NlLWNtZHwgZm9yIG1vcmUgaW5mb3JtYXRpb24uCgoJCQkJCQkJKkUxMjQqICpFMTI1KiAqRTg1MyoKOmZ1W25jdGlvbl1bIV0ge25hbWV9KFthcmd1bWVudHNdKSBbcmFuZ2VdIFthYm9ydF0gW2RpY3RdCgkJCURlZmluZSBhIG5ldyBmdW5jdGlvbiBieSB0aGUgbmFtZSB7bmFtZX0uICBUaGUgbmFtZQoJCQltdXN0IGJlIG1hZGUgb2YgYWxwaGFudW1lcmljIGNoYXJhY3RlcnMgYW5kICdfJywgYW5kCgkJCW11c3Qgc3RhcnQgd2l0aCBhIGNhcGl0YWwgb3IgInM6IiAoc2VlIGFib3ZlKS4KCgkJCXtuYW1lfSBjYW4gYWxzbyBiZSBhIHxEaWN0aW9uYXJ5fCBlbnRyeSB0aGF0IGlzIGEKCQkJfEZ1bmNyZWZ8OiA+CgkJCQk6ZnVuY3Rpb24gZGljdC5pbml0KGFyZykKPAkJCSJkaWN0IiBtdXN0IGJlIGFuIGV4aXN0aW5nIGRpY3Rpb25hcnkuCVRoZSBlbnRyeQoJCQkiaW5pdCIgaXMgYWRkZWQgaWYgaXQgZGlkbid0IGV4aXN0IHlldC4gIE90aGVyd2lzZSBbIV0KCQkJaXMgcmVxdWlyZWQgdG8gb3ZlcndyaXRlIGFuIGV4aXN0aW5nIGZ1bmN0aW9uLglUaGUKCQkJcmVzdWx0IGlzIGEgfEZ1bmNyZWZ8IHRvIGEgbnVtYmVyZWQgZnVuY3Rpb24uICBUaGUKCQkJZnVuY3Rpb24gY2FuIG9ubHkgYmUgdXNlZCB3aXRoIGEgfEZ1bmNyZWZ8IGFuZCB3aWxsIGJlCgkJCWRlbGV0ZWQgaWYgdGhlcmUgYXJlIG5vIG1vcmUgcmVmZXJlbmNlcyB0byBpdC4KCQkJCQkJCQkqRTEyNyogKkUxMjIqCgkJCVdoZW4gYSBmdW5jdGlvbiBieSB0aGlzIG5hbWUgYWxyZWFkeSBleGlzdHMgYW5kIFshXSBpcwoJCQlub3QgdXNlZCBhbiBlcnJvciBtZXNzYWdlIGlzIGdpdmVuLiAgV2hlbiBbIV0gaXMgdXNlZCwKCQkJYW4gZXhpc3RpbmcgZnVuY3Rpb24gaXMgc2lsZW50bHkgcmVwbGFjZWQuICBVbmxlc3MgaXQKCQkJaXMgY3VycmVudGx5IGJlaW5nIGV4ZWN1dGVkLCB0aGF0IGlzIGFuIGVycm9yLgoKCQkJRm9yIHRoZSB7YXJndW1lbnRzfSBzZWUgfGZ1bmN0aW9uLWFyZ3VtZW50fC4KCgkJCQkJCSphOmZpcnN0bGluZSogKmE6bGFzdGxpbmUqCgkJCVdoZW4gdGhlIFtyYW5nZV0gYXJndW1lbnQgaXMgYWRkZWQsIHRoZSBmdW5jdGlvbiBpcwoJCQlleHBlY3RlZCB0byB0YWtlIGNhcmUgb2YgYSByYW5nZSBpdHNlbGYuICBUaGUgcmFuZ2UgaXMKCQkJcGFzc2VkIGFzICJhOmZpcnN0bGluZSIgYW5kICJhOmxhc3RsaW5lIi4gIElmIFtyYW5nZV0KCQkJaXMgZXhjbHVkZWQsICI6e3JhbmdlfWNhbGwiIHdpbGwgY2FsbCB0aGUgZnVuY3Rpb24gZm9yCgkJCWVhY2ggbGluZSBpbiB0aGUgcmFuZ2UsIHdpdGggdGhlIGN1cnNvciBvbiB0aGUgc3RhcnQKCQkJb2YgZWFjaCBsaW5lLiAgU2VlIHxmdW5jdGlvbi1yYW5nZS1leGFtcGxlfC4KCgkJCVdoZW4gdGhlIFthYm9ydF0gYXJndW1lbnQgaXMgYWRkZWQsIHRoZSBmdW5jdGlvbiB3aWxsCgkJCWFib3J0IGFzIHNvb24gYXMgYW4gZXJyb3IgaXMgZGV0ZWN0ZWQuCgoJCQlXaGVuIHRoZSBbZGljdF0gYXJndW1lbnQgaXMgYWRkZWQsIHRoZSBmdW5jdGlvbiBtdXN0CgkJCWJlIGludm9rZWQgdGhyb3VnaCBhbiBlbnRyeSBpbiBhIHxEaWN0aW9uYXJ5fC4JVGhlCgkJCWxvY2FsIHZhcmlhYmxlICJzZWxmIiB3aWxsIHRoZW4gYmUgc2V0IHRvIHRoZQoJCQlkaWN0aW9uYXJ5LiAgU2VlIHxEaWN0aW9uYXJ5LWZ1bmN0aW9ufC4KCgkJCQkJCSpmdW5jdGlvbi1zZWFyY2gtdW5kbyoKCQkJVGhlIGxhc3QgdXNlZCBzZWFyY2ggcGF0dGVybiBhbmQgdGhlIHJlZG8gY29tbWFuZCAiLiIKCQkJd2lsbCBub3QgYmUgY2hhbmdlZCBieSB0aGUgZnVuY3Rpb24uICBUaGlzIGFsc28KCQkJaW1wbGllcyB0aGF0IHRoZSBlZmZlY3Qgb2YgfDpub2hsc2VhcmNofCBpcyB1bmRvbmUKCQkJd2hlbiB0aGUgZnVuY3Rpb24gcmV0dXJucy4KCgkJCQkJKjplbmRmKiAqOmVuZGZ1bmN0aW9uKiAqRTEyNiogKkUxOTMqCjplbmRmW3VuY3Rpb25dCQlUaGUgZW5kIG9mIGEgZnVuY3Rpb24gZGVmaW5pdGlvbi4gIE11c3QgYmUgb24gYSBsaW5lCgkJCWJ5IGl0cyBvd24sIHdpdGhvdXQgb3RoZXIgY29tbWFuZHMuCgoJCQkJCSo6ZGVsZiogKjpkZWxmdW5jdGlvbiogKkUxMzAqICpFMTMxKgo6ZGVsZlt1bmN0aW9uXSB7bmFtZX0JRGVsZXRlIGZ1bmN0aW9uIHtuYW1lfS4KCQkJe25hbWV9IGNhbiBhbHNvIGJlIGEgfERpY3Rpb25hcnl8IGVudHJ5IHRoYXQgaXMgYQoJCQl8RnVuY3JlZnw6ID4KCQkJCTpkZWxmdW5jIGRpY3QuaW5pdAo8CQkJVGhpcyB3aWxsIHJlbW92ZSB0aGUgImluaXQiIGVudHJ5IGZyb20gImRpY3QiLglUaGUKCQkJZnVuY3Rpb24gaXMgZGVsZXRlZCBpZiB0aGVyZSBhcmUgbm8gbW9yZSByZWZlcmVuY2VzIHRvCgkJCWl0LgoJCQkJCQkJKjpyZXR1KiAqOnJldHVybiogKkUxMzMqCjpyZXR1W3JuXSBbZXhwcl0JUmV0dXJuIGZyb20gYSBmdW5jdGlvbi4gIFdoZW4gIltleHByXSIgaXMgZ2l2ZW4sIGl0IGlzCgkJCWV2YWx1YXRlZCBhbmQgcmV0dXJuZWQgYXMgdGhlIHJlc3VsdCBvZiB0aGUgZnVuY3Rpb24uCgkJCUlmICJbZXhwcl0iIGlzIG5vdCBnaXZlbiwgdGhlIG51bWJlciAwIGlzIHJldHVybmVkLgoJCQlXaGVuIGEgZnVuY3Rpb24gZW5kcyB3aXRob3V0IGFuIGV4cGxpY2l0ICI6cmV0dXJuIiwKCQkJdGhlIG51bWJlciAwIGlzIHJldHVybmVkLgoJCQlOb3RlIHRoYXQgdGhlcmUgaXMgbm8gY2hlY2sgZm9yIHVucmVhY2hhYmxlIGxpbmVzLAoJCQl0aHVzIHRoZXJlIGlzIG5vIHdhcm5pbmcgaWYgY29tbWFuZHMgZm9sbG93ICI6cmV0dXJuIi4KCgkJCUlmIHRoZSAiOnJldHVybiIgaXMgdXNlZCBhZnRlciBhIHw6dHJ5fCBidXQgYmVmb3JlIHRoZQoJCQltYXRjaGluZyB8OmZpbmFsbHl8IChpZiBwcmVzZW50KSwgdGhlIGNvbW1hbmRzCgkJCWZvbGxvd2luZyB0aGUgIjpmaW5hbGx5IiB1cCB0byB0aGUgbWF0Y2hpbmcgfDplbmR0cnl8CgkJCWFyZSBleGVjdXRlZCBmaXJzdC4gIFRoaXMgcHJvY2VzcyBhcHBsaWVzIHRvIGFsbAoJCQluZXN0ZWQgIjp0cnkicyBpbnNpZGUgdGhlIGZ1bmN0aW9uLiAgVGhlIGZ1bmN0aW9uCgkJCXJldHVybnMgYXQgdGhlIG91dGVybW9zdCAiOmVuZHRyeSIuCgoJCQkJCQkqZnVuY3Rpb24tYXJndW1lbnQqICphOnZhcioKQW4gYXJndW1lbnQgY2FuIGJlIGRlZmluZWQgYnkgZ2l2aW5nIGl0cyBuYW1lLglJbiB0aGUgZnVuY3Rpb24gdGhpcyBjYW4gdGhlbgpiZSB1c2VkIGFzICJhOm5hbWUiICgiYToiIGZvciBhcmd1bWVudCkuCgkJCQkJKmE6MCogKmE6MSogKmE6MDAwKiAqRTc0MCogKi4uLioKVXAgdG8gMjAgYXJndW1lbnRzIGNhbiBiZSBnaXZlbiwgc2VwYXJhdGVkIGJ5IGNvbW1hcy4gIEFmdGVyIHRoZSBuYW1lZAphcmd1bWVudHMgYW4gYXJndW1lbnQgIi4uLiIgY2FuIGJlIHNwZWNpZmllZCwgd2hpY2ggbWVhbnMgdGhhdCBtb3JlIGFyZ3VtZW50cwptYXkgb3B0aW9uYWxseSBiZSBmb2xsb3dpbmcuICBJbiB0aGUgZnVuY3Rpb24gdGhlIGV4dHJhIGFyZ3VtZW50cyBjYW4gYmUgdXNlZAphcyAiYToxIiwgImE6MiIsIGV0Yy4gICJhOjAiIGlzIHNldCB0byB0aGUgbnVtYmVyIG9mIGV4dHJhIGFyZ3VtZW50cyAod2hpY2gKY2FuIGJlIDApLiAgImE6MDAwIiBpcyBzZXQgdG8gYSB8TGlzdHwgdGhhdCBjb250YWlucyB0aGVzZSBhcmd1bWVudHMuICBOb3RlCnRoYXQgImE6MSIgaXMgdGhlIHNhbWUgYXMgImE6MDAwWzBdIi4KCQkJCQkJCQkqRTc0MioKVGhlIGE6IHNjb3BlIGFuZCB0aGUgdmFyaWFibGVzIGluIGl0IGNhbm5vdCBiZSBjaGFuZ2VkLCB0aGV5IGFyZSBmaXhlZC4KSG93ZXZlciwgaWYgYSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IGlzIHVzZWQsIHlvdSBjYW4gY2hhbmdlIHRoZWlyIGNvbnRlbnRzLgpUaHVzIHlvdSBjYW4gcGFzcyBhIHxMaXN0fCB0byBhIGZ1bmN0aW9uIGFuZCBoYXZlIHRoZSBmdW5jdGlvbiBhZGQgYW4gaXRlbSB0bwppdC4gIElmIHlvdSB3YW50IHRvIG1ha2Ugc3VyZSB0aGUgZnVuY3Rpb24gY2Fubm90IGNoYW5nZSBhIHxMaXN0fCBvcgp8RGljdGlvbmFyeXwgdXNlIHw6bG9ja3ZhcnwuCgpXaGVuIG5vdCB1c2luZyAiLi4uIiwgdGhlIG51bWJlciBvZiBhcmd1bWVudHMgaW4gYSBmdW5jdGlvbiBjYWxsIG11c3QgYmUgZXF1YWwKdG8gdGhlIG51bWJlciBvZiBuYW1lZCBhcmd1bWVudHMuICBXaGVuIHVzaW5nICIuLi4iLCB0aGUgbnVtYmVyIG9mIGFyZ3VtZW50cwptYXkgYmUgbGFyZ2VyLgoKSXQgaXMgYWxzbyBwb3NzaWJsZSB0byBkZWZpbmUgYSBmdW5jdGlvbiB3aXRob3V0IGFueSBhcmd1bWVudHMuICBZb3UgbXVzdApzdGlsbCBzdXBwbHkgdGhlICgpIHRoZW4uICBUaGUgYm9keSBvZiB0aGUgZnVuY3Rpb24gZm9sbG93cyBpbiB0aGUgbmV4dCBsaW5lcywKdW50aWwgdGhlIG1hdGNoaW5nIHw6ZW5kZnVuY3Rpb258LiAgSXQgaXMgYWxsb3dlZCB0byBkZWZpbmUgYW5vdGhlciBmdW5jdGlvbgppbnNpZGUgYSBmdW5jdGlvbiBib2R5LgoKCQkJCQkJCSpsb2NhbC12YXJpYWJsZXMqCkluc2lkZSBhIGZ1bmN0aW9uIHZhcmlhYmxlcyBjYW4gYmUgdXNlZC4gIFRoZXNlIGFyZSBsb2NhbCB2YXJpYWJsZXMsIHdoaWNoCndpbGwgZGlzYXBwZWFyIHdoZW4gdGhlIGZ1bmN0aW9uIHJldHVybnMuICBHbG9iYWwgdmFyaWFibGVzIG5lZWQgdG8gYmUKYWNjZXNzZWQgd2l0aCAiZzoiLgoKRXhhbXBsZTogPgogIDpmdW5jdGlvbiBUYWJsZSh0aXRsZSwgLi4uKQogIDogIGVjaG9obCBUaXRsZQogIDogIGVjaG8gYTp0aXRsZQogIDogIGVjaG9obCBOb25lCiAgOiAgZWNobyBhOjAgLiAiIGl0ZW1zOiIKICA6ICBmb3IgcyBpbiBhOjAwMAogIDogICAgZWNob24gJyAnIC4gcwogIDogIGVuZGZvcgogIDplbmRmdW5jdGlvbgoKVGhpcyBmdW5jdGlvbiBjYW4gdGhlbiBiZSBjYWxsZWQgd2l0aDogPgogIGNhbGwgVGFibGUoIlRhYmxlIiwgImxpbmUxIiwgImxpbmUyIikKICBjYWxsIFRhYmxlKCJFbXB0eSBUYWJsZSIpCgpUbyByZXR1cm4gbW9yZSB0aGFuIG9uZSB2YWx1ZSwgcmV0dXJuIGEgfExpc3R8OiA+CiAgOmZ1bmN0aW9uIENvbXB1dGUobjEsIG4yKQogIDogIGlmIGE6bjIgPT0gMAogIDogICAgcmV0dXJuIFsiZmFpbCIsIDBdCiAgOiAgZW5kaWYKICA6ICByZXR1cm4gWyJvayIsIGE6bjEgLyBhOm4yXQogIDplbmRmdW5jdGlvbgoKVGhpcyBmdW5jdGlvbiBjYW4gdGhlbiBiZSBjYWxsZWQgd2l0aDogPgogIDpsZXQgW3N1Y2Nlc3MsIGRpdl0gPSBDb21wdXRlKDEwMiwgNikKICA6aWYgc3VjY2VzcyA9PSAib2siCiAgOiAgZWNobyBkaXYKICA6ZW5kaWYKPAoJCQkJCQkqOmNhbCogKjpjYWxsKiAqRTEwNyogKkUxMTcqCjpbcmFuZ2VdY2FsW2xdIHtuYW1lfShbYXJndW1lbnRzXSkKCQlDYWxsIGEgZnVuY3Rpb24uICBUaGUgbmFtZSBvZiB0aGUgZnVuY3Rpb24gYW5kIGl0cyBhcmd1bWVudHMKCQlhcmUgYXMgc3BlY2lmaWVkIHdpdGggfDpmdW5jdGlvbnwuICBVcCB0byAyMCBhcmd1bWVudHMgY2FuIGJlCgkJdXNlZC4gIFRoZSByZXR1cm5lZCB2YWx1ZSBpcyBkaXNjYXJkZWQuCgkJV2l0aG91dCBhIHJhbmdlIGFuZCBmb3IgZnVuY3Rpb25zIHRoYXQgYWNjZXB0IGEgcmFuZ2UsIHRoZQoJCWZ1bmN0aW9uIGlzIGNhbGxlZCBvbmNlLiAgV2hlbiBhIHJhbmdlIGlzIGdpdmVuIHRoZSBjdXJzb3IgaXMKCQlwb3NpdGlvbmVkIGF0IHRoZSBzdGFydCBvZiB0aGUgZmlyc3QgbGluZSBiZWZvcmUgZXhlY3V0aW5nIHRoZQoJCWZ1bmN0aW9uLgoJCVdoZW4gYSByYW5nZSBpcyBnaXZlbiBhbmQgdGhlIGZ1bmN0aW9uIGRvZXNuJ3QgaGFuZGxlIGl0CgkJaXRzZWxmLCB0aGUgZnVuY3Rpb24gaXMgZXhlY3V0ZWQgZm9yIGVhY2ggbGluZSBpbiB0aGUgcmFuZ2UsCgkJd2l0aCB0aGUgY3Vyc29yIGluIHRoZSBmaXJzdCBjb2x1bW4gb2YgdGhhdCBsaW5lLiAgVGhlIGN1cnNvcgoJCWlzIGxlZnQgYXQgdGhlIGxhc3QgbGluZSAocG9zc2libHkgbW92ZWQgYnkgdGhlIGxhc3QgZnVuY3Rpb24KCQljYWxsKS4JVGhlIGFyZ3VtZW50cyBhcmUgcmUtZXZhbHVhdGVkIGZvciBlYWNoIGxpbmUuICBUaHVzCgkJdGhpcyB3b3JrczoKCQkJCQkJKmZ1bmN0aW9uLXJhbmdlLWV4YW1wbGUqICA+Cgk6ZnVuY3Rpb24gTXludW1iZXIoYXJnKQoJOiAgZWNobyBsaW5lKCIuIikgLiAiICIgLiBhOmFyZwoJOmVuZGZ1bmN0aW9uCgk6MSw1Y2FsbCBNeW51bWJlcihnZXRsaW5lKCIuIikpCjwKCQlUaGUgImE6Zmlyc3RsaW5lIiBhbmQgImE6bGFzdGxpbmUiIGFyZSBkZWZpbmVkIGFueXdheSwgdGhleQoJCWNhbiBiZSB1c2VkIHRvIGRvIHNvbWV0aGluZyBkaWZmZXJlbnQgYXQgdGhlIHN0YXJ0IG9yIGVuZCBvZgoJCXRoZSByYW5nZS4KCgkJRXhhbXBsZSBvZiBhIGZ1bmN0aW9uIHRoYXQgaGFuZGxlcyB0aGUgcmFuZ2UgaXRzZWxmOiA+CgoJOmZ1bmN0aW9uIENvbnQoKSByYW5nZQoJOiAgZXhlY3V0ZSAoYTpmaXJzdGxpbmUgKyAxKSAuICIsIiAuIGE6bGFzdGxpbmUgLiAncy9eL1x0XFwgJwoJOmVuZGZ1bmN0aW9uCgk6NCw4Y2FsbCBDb250KCkKPAoJCVRoaXMgZnVuY3Rpb24gaW5zZXJ0cyB0aGUgY29udGludWF0aW9uIGNoYXJhY3RlciAiXCIgaW4gZnJvbnQKCQlvZiBhbGwgdGhlIGxpbmVzIGluIHRoZSByYW5nZSwgZXhjZXB0IHRoZSBmaXJzdCBvbmUuCgoJCVdoZW4gdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBjb21wb3NpdGUgdmFsdWUgaXQgY2FuIGJlIGZ1cnRoZXIKCQlkZXJlZmVyZW5jZWQsIGJ1dCB0aGUgcmFuZ2Ugd2lsbCBub3QgYmUgdXNlZCB0aGVuLiAgRXhhbXBsZTogPgoJOjQsOGNhbGwgR2V0RGljdCgpLm1ldGhvZCgpCjwJCUhlcmUgR2V0RGljdCgpIGdldHMgdGhlIHJhbmdlIGJ1dCBtZXRob2QoKSBkb2VzIG5vdC4KCgkJCQkJCQkJKkUxMzIqClRoZSByZWN1cnNpdmVuZXNzIG9mIHVzZXIgZnVuY3Rpb25zIGlzIHJlc3RyaWN0ZWQgd2l0aCB0aGUgfCdtYXhmdW5jZGVwdGgnfApvcHRpb24uCgoKQVVUT01BVElDQUxMWSBMT0FESU5HIEZVTkNUSU9OUyB+CgkJCQkJCQkqYXV0b2xvYWQtZnVuY3Rpb25zKgpXaGVuIHVzaW5nIG1hbnkgb3IgbGFyZ2UgZnVuY3Rpb25zLCBpdCdzIHBvc3NpYmxlIHRvIGF1dG9tYXRpY2FsbHkgZGVmaW5lIHRoZW0Kb25seSB3aGVuIHRoZXkgYXJlIHVzZWQuICBUaGVyZSBhcmUgdHdvIG1ldGhvZHM6IHdpdGggYW4gYXV0b2NvbW1hbmQgYW5kIHdpdGgKdGhlICJhdXRvbG9hZCIgZGlyZWN0b3J5IGluICdydW50aW1lcGF0aCcuCgoKVXNpbmcgYW4gYXV0b2NvbW1hbmQgfgoKVGhpcyBpcyBpbnRyb2R1Y2VkIGluIHRoZSB1c2VyIG1hbnVhbCwgc2VjdGlvbiB8NDEuMTR8LgoKVGhlIGF1dG9jb21tYW5kIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBhIHBsdWdpbiB0aGF0IGlzIGEgbG9uZyBWaW0gc2NyaXB0IGZpbGUuCllvdSBjYW4gZGVmaW5lIHRoZSBhdXRvY29tbWFuZCBhbmQgcXVpY2tseSBxdWl0IHRoZSBzY3JpcHQgd2l0aCB8OmZpbmlzaHwuClRoYXQgbWFrZXMgVmltIHN0YXJ0dXAgZmFzdGVyLglUaGUgYXV0b2NvbW1hbmQgc2hvdWxkIHRoZW4gbG9hZCB0aGUgc2FtZSBmaWxlCmFnYWluLCBzZXR0aW5nIGEgdmFyaWFibGUgdG8gc2tpcCB0aGUgfDpmaW5pc2h8IGNvbW1hbmQuCgpVc2UgdGhlIEZ1bmNVbmRlZmluZWQgYXV0b2NvbW1hbmQgZXZlbnQgd2l0aCBhIHBhdHRlcm4gdGhhdCBtYXRjaGVzIHRoZQpmdW5jdGlvbihzKSB0byBiZSBkZWZpbmVkLiAgRXhhbXBsZTogPgoKCTphdSBGdW5jVW5kZWZpbmVkIEJ1Zk5ldCogc291cmNlIH4vdmltL2J1Zm5ldGZ1bmNzLnZpbQoKVGhlIGZpbGUgIn4vdmltL2J1Zm5ldGZ1bmNzLnZpbSIgc2hvdWxkIHRoZW4gZGVmaW5lIGZ1bmN0aW9ucyB0aGF0IHN0YXJ0IHdpdGgKIkJ1Zk5ldCIuICBBbHNvIHNlZSB8RnVuY1VuZGVmaW5lZHwuCgoKVXNpbmcgYW4gYXV0b2xvYWQgc2NyaXB0IH4KCQkJCQkJCSphdXRvbG9hZCogKkU3NDYqClRoaXMgaXMgaW50cm9kdWNlZCBpbiB0aGUgdXNlciBtYW51YWwsIHNlY3Rpb24gfDQxLjE1fC4KClVzaW5nIGEgc2NyaXB0IGluIHRoZSAiYXV0b2xvYWQiIGRpcmVjdG9yeSBpcyBzaW1wbGVyLCBidXQgcmVxdWlyZXMgdXNpbmcKZXhhY3RseSB0aGUgcmlnaHQgZmlsZSBuYW1lLiAgQSBmdW5jdGlvbiB0aGF0IGNhbiBiZSBhdXRvbG9hZGVkIGhhcyBhIG5hbWUKbGlrZSB0aGlzOiA+CgoJOmNhbGwgZmlsZW5hbWUjZnVuY25hbWUoKQoKV2hlbiBzdWNoIGEgZnVuY3Rpb24gaXMgY2FsbGVkLCBhbmQgaXQgaXMgbm90IGRlZmluZWQgeWV0LCBWaW0gd2lsbCBzZWFyY2ggdGhlCiJhdXRvbG9hZCIgZGlyZWN0b3JpZXMgaW4gJ3J1bnRpbWVwYXRoJyBmb3IgYSBzY3JpcHQgZmlsZSBjYWxsZWQKImZpbGVuYW1lLnZpbSIuICBGb3IgZXhhbXBsZSAifi8udmltL2F1dG9sb2FkL2ZpbGVuYW1lLnZpbSIuICBUaGF0IGZpbGUgc2hvdWxkCnRoZW4gZGVmaW5lIHRoZSBmdW5jdGlvbiBsaWtlIHRoaXM6ID4KCglmdW5jdGlvbiBmaWxlbmFtZSNmdW5jbmFtZSgpCgkgICBlY2hvICJEb25lISIKCWVuZGZ1bmN0aW9uCgpUaGUgZmlsZSBuYW1lIGFuZCB0aGUgbmFtZSB1c2VkIGJlZm9yZSB0aGUgIyBpbiB0aGUgZnVuY3Rpb24gbXVzdCBtYXRjaApleGFjdGx5LCBhbmQgdGhlIGRlZmluZWQgZnVuY3Rpb24gbXVzdCBoYXZlIHRoZSBuYW1lIGV4YWN0bHkgYXMgaXQgd2lsbCBiZQpjYWxsZWQuCgpJdCBpcyBwb3NzaWJsZSB0byB1c2Ugc3ViZGlyZWN0b3JpZXMuICBFdmVyeSAjIGluIHRoZSBmdW5jdGlvbiBuYW1lIHdvcmtzIGxpa2UKYSBwYXRoIHNlcGFyYXRvci4gIFRodXMgd2hlbiBjYWxsaW5nIGEgZnVuY3Rpb246ID4KCgk6Y2FsbCBmb28jYmFyI2Z1bmMoKQoKVmltIHdpbGwgbG9vayBmb3IgdGhlIGZpbGUgImF1dG9sb2FkL2Zvby9iYXIudmltIiBpbiAncnVudGltZXBhdGgnLgoKVGhpcyBhbHNvIHdvcmtzIHdoZW4gcmVhZGluZyBhIHZhcmlhYmxlIHRoYXQgaGFzIG5vdCBiZWVuIHNldCB5ZXQ6ID4KCgk6bGV0IGwgPSBmb28jYmFyI2x2YXIKCkhvd2V2ZXIsIHdoZW4gdGhlIGF1dG9sb2FkIHNjcmlwdCB3YXMgYWxyZWFkeSBsb2FkZWQgaXQgd29uJ3QgYmUgbG9hZGVkIGFnYWluCmZvciBhbiB1bmtub3duIHZhcmlhYmxlLgoKV2hlbiBhc3NpZ25pbmcgYSB2YWx1ZSB0byBzdWNoIGEgdmFyaWFibGUgbm90aGluZyBzcGVjaWFsIGhhcHBlbnMuICBUaGlzIGNhbgpiZSB1c2VkIHRvIHBhc3Mgc2V0dGluZ3MgdG8gdGhlIGF1dG9sb2FkIHNjcmlwdCBiZWZvcmUgaXQncyBsb2FkZWQ6ID4KCgk6bGV0IGZvbyNiYXIjdG9nZ2xlID0gMQoJOmNhbGwgZm9vI2JhciNmdW5jKCkKCk5vdGUgdGhhdCB3aGVuIHlvdSBtYWtlIGEgbWlzdGFrZSBhbmQgY2FsbCBhIGZ1bmN0aW9uIHRoYXQgaXMgc3VwcG9zZWQgdG8gYmUKZGVmaW5lZCBpbiBhbiBhdXRvbG9hZCBzY3JpcHQsIGJ1dCB0aGUgc2NyaXB0IGRvZXNuJ3QgYWN0dWFsbHkgZGVmaW5lIHRoZQpmdW5jdGlvbiwgdGhlIHNjcmlwdCB3aWxsIGJlIHNvdXJjZWQgZXZlcnkgdGltZSB5b3UgdHJ5IHRvIGNhbGwgdGhlIGZ1bmN0aW9uLgpBbmQgeW91IHdpbGwgZ2V0IGFuIGVycm9yIG1lc3NhZ2UgZXZlcnkgdGltZS4KCkFsc28gbm90ZSB0aGF0IGlmIHlvdSBoYXZlIHR3byBzY3JpcHQgZmlsZXMsIGFuZCBvbmUgY2FsbHMgYSBmdW5jdGlvbiBpbiB0aGUKb3RoZXIgYW5kIHZpY2UgdmVyc2EsIGJlZm9yZSB0aGUgdXNlZCBmdW5jdGlvbiBpcyBkZWZpbmVkLCBpdCB3b24ndCB3b3JrLgpBdm9pZCB1c2luZyB0aGUgYXV0b2xvYWQgZnVuY3Rpb25hbGl0eSBhdCB0aGUgdG9wbGV2ZWwuCgpIaW50OiBJZiB5b3UgZGlzdHJpYnV0ZSBhIGJ1bmNoIG9mIHNjcmlwdHMgeW91IGNhbiBwYWNrIHRoZW0gdG9nZXRoZXIgd2l0aCB0aGUKfHZpbWJhbGx8IHV0aWxpdHkuICBBbHNvIHJlYWQgdGhlIHVzZXIgbWFudWFsIHxkaXN0cmlidXRlLXNjcmlwdHwuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KNi4gQ3VybHkgYnJhY2VzIG5hbWVzCQkJCQkqY3VybHktYnJhY2VzLW5hbWVzKgoKV2hlcmV2ZXIgeW91IGNhbiB1c2UgYSB2YXJpYWJsZSwgeW91IGNhbiB1c2UgYSAiY3VybHkgYnJhY2VzIG5hbWUiIHZhcmlhYmxlLgpUaGlzIGlzIGEgcmVndWxhciB2YXJpYWJsZSBuYW1lIHdpdGggb25lIG9yIG1vcmUgZXhwcmVzc2lvbnMgd3JhcHBlZCBpbiBicmFjZXMKe30gbGlrZSB0aGlzOiA+CglteV97YWRqZWN0aXZlfV92YXJpYWJsZQoKV2hlbiBWaW0gZW5jb3VudGVycyB0aGlzLCBpdCBldmFsdWF0ZXMgdGhlIGV4cHJlc3Npb24gaW5zaWRlIHRoZSBicmFjZXMsIHB1dHMKdGhhdCBpbiBwbGFjZSBvZiB0aGUgZXhwcmVzc2lvbiwgYW5kIHJlLWludGVycHJldHMgdGhlIHdob2xlIGFzIGEgdmFyaWFibGUKbmFtZS4gIFNvIGluIHRoZSBhYm92ZSBleGFtcGxlLCBpZiB0aGUgdmFyaWFibGUgImFkamVjdGl2ZSIgd2FzIHNldCB0bwoibm9pc3kiLCB0aGVuIHRoZSByZWZlcmVuY2Ugd291bGQgYmUgdG8gIm15X25vaXN5X3ZhcmlhYmxlIiwgd2hlcmVhcyBpZgoiYWRqZWN0aXZlIiB3YXMgc2V0IHRvICJxdWlldCIsIHRoZW4gaXQgd291bGQgYmUgdG8gIm15X3F1aWV0X3ZhcmlhYmxlIi4KCk9uZSBhcHBsaWNhdGlvbiBmb3IgdGhpcyBpcyB0byBjcmVhdGUgYSBzZXQgb2YgdmFyaWFibGVzIGdvdmVybmVkIGJ5IGFuIG9wdGlvbgp2YWx1ZS4JRm9yIGV4YW1wbGUsIHRoZSBzdGF0ZW1lbnQgPgoJZWNobyBteV97JmJhY2tncm91bmR9X21lc3NhZ2UKCndvdWxkIG91dHB1dCB0aGUgY29udGVudHMgb2YgIm15X2RhcmtfbWVzc2FnZSIgb3IgIm15X2xpZ2h0X21lc3NhZ2UiIGRlcGVuZGluZwpvbiB0aGUgY3VycmVudCB2YWx1ZSBvZiAnYmFja2dyb3VuZCcuCgpZb3UgY2FuIHVzZSBtdWx0aXBsZSBicmFjZSBwYWlyczogPgoJZWNobyBteV97YWR2ZXJifV97YWRqZWN0aXZlfV9tZXNzYWdlCi4ub3IgZXZlbiBuZXN0IHRoZW06ID4KCWVjaG8gbXlfe2Fke2VuZF9vZl93b3JkfX1fbWVzc2FnZQp3aGVyZSAiZW5kX29mX3dvcmQiIGlzIGVpdGhlciAidmVyYiIgb3IgImplY3RpdmUiLgoKSG93ZXZlciwgdGhlIGV4cHJlc3Npb24gaW5zaWRlIHRoZSBicmFjZXMgbXVzdCBldmFsdWF0ZSB0byBhIHZhbGlkIHNpbmdsZQp2YXJpYWJsZSBuYW1lLCBlLmcuIHRoaXMgaXMgaW52YWxpZDogPgoJOmxldCBmb289J2EgKyBiJwoJOmVjaG8gY3tmb299ZAouLiBzaW5jZSB0aGUgcmVzdWx0IG9mIGV4cGFuc2lvbiBpcyAiY2EgKyBiZCIsIHdoaWNoIGlzIG5vdCBhIHZhcmlhYmxlIG5hbWUuCgoJCQkJCQkqY3VybHktYnJhY2VzLWZ1bmN0aW9uLW5hbWVzKgpZb3UgY2FuIGNhbGwgYW5kIGRlZmluZSBmdW5jdGlvbnMgYnkgYW4gZXZhbHVhdGVkIG5hbWUgaW4gYSBzaW1pbGFyIHdheS4KRXhhbXBsZTogPgoJOmxldCBmdW5jX2VuZD0nd2hpenonCgk6Y2FsbCBteV9mdW5jX3tmdW5jX2VuZH0ocGFyYW1ldGVyKQoKVGhpcyB3b3VsZCBjYWxsIHRoZSBmdW5jdGlvbiAibXlfZnVuY193aGl6eihwYXJhbWV0ZXIpIi4KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo3LiBDb21tYW5kcwkJCQkJCSpleHByZXNzaW9uLWNvbW1hbmRzKgoKOmxldCB7dmFyLW5hbWV9ID0ge2V4cHIxfQkJCQkqOmxldCogKkUxOCoKCQkJU2V0IGludGVybmFsIHZhcmlhYmxlIHt2YXItbmFtZX0gdG8gdGhlIHJlc3VsdCBvZiB0aGUKCQkJZXhwcmVzc2lvbiB7ZXhwcjF9LiAgVGhlIHZhcmlhYmxlIHdpbGwgZ2V0IHRoZSB0eXBlCgkJCWZyb20gdGhlIHtleHByfS4gIElmIHt2YXItbmFtZX0gZGlkbid0IGV4aXN0IHlldCwgaXQKCQkJaXMgY3JlYXRlZC4KCjpsZXQge3Zhci1uYW1lfVt7aWR4fV0gPSB7ZXhwcjF9CQkJKkU2ODkqCgkJCVNldCBhIGxpc3QgaXRlbSB0byB0aGUgcmVzdWx0IG9mIHRoZSBleHByZXNzaW9uCgkJCXtleHByMX0uICB7dmFyLW5hbWV9IG11c3QgcmVmZXIgdG8gYSBsaXN0IGFuZCB7aWR4fQoJCQltdXN0IGJlIGEgdmFsaWQgaW5kZXggaW4gdGhhdCBsaXN0LiAgRm9yIG5lc3RlZCBsaXN0CgkJCXRoZSBpbmRleCBjYW4gYmUgcmVwZWF0ZWQuCgkJCVRoaXMgY2Fubm90IGJlIHVzZWQgdG8gYWRkIGFuIGl0ZW0gdG8gYSB8TGlzdHwuCgkJCVRoaXMgY2Fubm90IGJlIHVzZWQgdG8gc2V0IGEgYnl0ZSBpbiBhIFN0cmluZy4JWW91CgkJCWNhbiBkbyB0aGF0IGxpa2UgdGhpczogPgoJCQkJOmxldCB2YXIgPSB2YXJbMDoyXSAuICdYJyAuIHZhcls0Ol0KPAoJCQkJCQkJKkU3MTEqICpFNzE5Kgo6bGV0IHt2YXItbmFtZX1be2lkeDF9OntpZHgyfV0gPSB7ZXhwcjF9CQkqRTcwOCogKkU3MDkqICpFNzEwKgoJCQlTZXQgYSBzZXF1ZW5jZSBvZiBpdGVtcyBpbiBhIHxMaXN0fCB0byB0aGUgcmVzdWx0IG9mCgkJCXRoZSBleHByZXNzaW9uIHtleHByMX0sIHdoaWNoIG11c3QgYmUgYSBsaXN0IHdpdGggdGhlCgkJCWNvcnJlY3QgbnVtYmVyIG9mIGl0ZW1zLgoJCQl7aWR4MX0gY2FuIGJlIG9taXR0ZWQsIHplcm8gaXMgdXNlZCBpbnN0ZWFkLgoJCQl7aWR4Mn0gY2FuIGJlIG9taXR0ZWQsIG1lYW5pbmcgdGhlIGVuZCBvZiB0aGUgbGlzdC4KCQkJV2hlbiB0aGUgc2VsZWN0ZWQgcmFuZ2Ugb2YgaXRlbXMgaXMgcGFydGx5IHBhc3QgdGhlCgkJCWVuZCBvZiB0aGUgbGlzdCwgaXRlbXMgd2lsbCBiZSBhZGRlZC4KCgkJCQkJKjpsZXQrPSogKjpsZXQtPSogKjpsZXQuPSogKkU3MzQqCjpsZXQge3Zhcn0gKz0ge2V4cHIxfQlMaWtlICI6bGV0IHt2YXJ9ID0ge3Zhcn0gKyB7ZXhwcjF9Ii4KOmxldCB7dmFyfSAtPSB7ZXhwcjF9CUxpa2UgIjpsZXQge3Zhcn0gPSB7dmFyfSAtIHtleHByMX0iLgo6bGV0IHt2YXJ9IC49IHtleHByMX0JTGlrZSAiOmxldCB7dmFyfSA9IHt2YXJ9IC4ge2V4cHIxfSIuCgkJCVRoZXNlIGZhaWwgaWYge3Zhcn0gd2FzIG5vdCBzZXQgeWV0IGFuZCB3aGVuIHRoZSB0eXBlCgkJCW9mIHt2YXJ9IGFuZCB7ZXhwcjF9IGRvbid0IGZpdCB0aGUgb3BlcmF0b3IuCgoKOmxldCAke2Vudi1uYW1lfSA9IHtleHByMX0JCQkqOmxldC1lbnZpcm9ubWVudCogKjpsZXQtJCoKCQkJU2V0IGVudmlyb25tZW50IHZhcmlhYmxlIHtlbnYtbmFtZX0gdG8gdGhlIHJlc3VsdCBvZgoJCQl0aGUgZXhwcmVzc2lvbiB7ZXhwcjF9LiAgVGhlIHR5cGUgaXMgYWx3YXlzIFN0cmluZy4KOmxldCAke2Vudi1uYW1lfSAuPSB7ZXhwcjF9CgkJCUFwcGVuZCB7ZXhwcjF9IHRvIHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZSB7ZW52LW5hbWV9LgoJCQlJZiB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGUgZGlkbid0IGV4aXN0IHlldCB0aGlzCgkJCXdvcmtzIGxpa2UgIj0iLgoKOmxldCBAe3JlZy1uYW1lfSA9IHtleHByMX0JCQkqOmxldC1yZWdpc3RlciogKjpsZXQtQCoKCQkJV3JpdGUgdGhlIHJlc3VsdCBvZiB0aGUgZXhwcmVzc2lvbiB7ZXhwcjF9IGluIHJlZ2lzdGVyCgkJCXtyZWctbmFtZX0uICB7cmVnLW5hbWV9IG11c3QgYmUgYSBzaW5nbGUgbGV0dGVyLCBhbmQKCQkJbXVzdCBiZSB0aGUgbmFtZSBvZiBhIHdyaXRhYmxlIHJlZ2lzdGVyIChzZWUKCQkJfHJlZ2lzdGVyc3wpLiAgIkBAIiBjYW4gYmUgdXNlZCBmb3IgdGhlIHVubmFtZWQKCQkJcmVnaXN0ZXIsICJALyIgZm9yIHRoZSBzZWFyY2ggcGF0dGVybi4KCQkJSWYgdGhlIHJlc3VsdCBvZiB7ZXhwcjF9IGVuZHMgaW4gYSA8Q1I+IG9yIDxOTD4sIHRoZQoJCQlyZWdpc3RlciB3aWxsIGJlIGxpbmV3aXNlLCBvdGhlcndpc2UgaXQgd2lsbCBiZSBzZXQgdG8KCQkJY2hhcmFjdGVyd2lzZS4KCQkJVGhpcyBjYW4gYmUgdXNlZCB0byBjbGVhciB0aGUgbGFzdCBzZWFyY2ggcGF0dGVybjogPgoJCQkJOmxldCBALyA9ICIiCjwJCQlUaGlzIGlzIGRpZmZlcmVudCBmcm9tIHNlYXJjaGluZyBmb3IgYW4gZW1wdHkgc3RyaW5nLAoJCQl0aGF0IHdvdWxkIG1hdGNoIGV2ZXJ5d2hlcmUuCgo6bGV0IEB7cmVnLW5hbWV9IC49IHtleHByMX0KCQkJQXBwZW5kIHtleHByMX0gdG8gcmVnaXN0ZXIge3JlZy1uYW1lfS4JSWYgdGhlCgkJCXJlZ2lzdGVyIHdhcyBlbXB0eSBpdCdzIGxpa2Ugc2V0dGluZyBpdCB0byB7ZXhwcjF9LgoKOmxldCAme29wdGlvbi1uYW1lfSA9IHtleHByMX0JCQkqOmxldC1vcHRpb24qICo6bGV0LSYqCgkJCVNldCBvcHRpb24ge29wdGlvbi1uYW1lfSB0byB0aGUgcmVzdWx0IG9mIHRoZQoJCQlleHByZXNzaW9uIHtleHByMX0uICBBIFN0cmluZyBvciBOdW1iZXIgdmFsdWUgaXMKCQkJYWx3YXlzIGNvbnZlcnRlZCB0byB0aGUgdHlwZSBvZiB0aGUgb3B0aW9uLgoJCQlGb3IgYW4gb3B0aW9uIGxvY2FsIHRvIGEgd2luZG93IG9yIGJ1ZmZlciB0aGUgZWZmZWN0CgkJCWlzIGp1c3QgbGlrZSB1c2luZyB0aGUgfDpzZXR8IGNvbW1hbmQ6IGJvdGggdGhlIGxvY2FsCgkJCXZhbHVlIGFuZCB0aGUgZ2xvYmFsIHZhbHVlIGFyZSBjaGFuZ2VkLgoJCQlFeGFtcGxlOiA+CgkJCQk6bGV0ICZwYXRoID0gJnBhdGggLiAnLC91c3IvbG9jYWwvaW5jbHVkZScKCjpsZXQgJntvcHRpb24tbmFtZX0gLj0ge2V4cHIxfQoJCQlGb3IgYSBzdHJpbmcgb3B0aW9uOiBBcHBlbmQge2V4cHIxfSB0byB0aGUgdmFsdWUuCgkJCURvZXMgbm90IGluc2VydCBhIGNvbW1hIGxpa2UgfDpzZXQrPXwuCgo6bGV0ICZ7b3B0aW9uLW5hbWV9ICs9IHtleHByMX0KOmxldCAme29wdGlvbi1uYW1lfSAtPSB7ZXhwcjF9CgkJCUZvciBhIG51bWJlciBvciBib29sZWFuIG9wdGlvbjogQWRkIG9yIHN1YnRyYWN0CgkJCXtleHByMX0uCgo6bGV0ICZsOntvcHRpb24tbmFtZX0gPSB7ZXhwcjF9CjpsZXQgJmw6e29wdGlvbi1uYW1lfSAuPSB7ZXhwcjF9CjpsZXQgJmw6e29wdGlvbi1uYW1lfSArPSB7ZXhwcjF9CjpsZXQgJmw6e29wdGlvbi1uYW1lfSAtPSB7ZXhwcjF9CgkJCUxpa2UgYWJvdmUsIGJ1dCBvbmx5IHNldCB0aGUgbG9jYWwgdmFsdWUgb2YgYW4gb3B0aW9uCgkJCShpZiB0aGVyZSBpcyBvbmUpLiAgV29ya3MgbGlrZSB8OnNldGxvY2FsfC4KCjpsZXQgJmc6e29wdGlvbi1uYW1lfSA9IHtleHByMX0KOmxldCAmZzp7b3B0aW9uLW5hbWV9IC49IHtleHByMX0KOmxldCAmZzp7b3B0aW9uLW5hbWV9ICs9IHtleHByMX0KOmxldCAmZzp7b3B0aW9uLW5hbWV9IC09IHtleHByMX0KCQkJTGlrZSBhYm92ZSwgYnV0IG9ubHkgc2V0IHRoZSBnbG9iYWwgdmFsdWUgb2YgYW4gb3B0aW9uCgkJCShpZiB0aGVyZSBpcyBvbmUpLiAgV29ya3MgbGlrZSB8OnNldGdsb2JhbHwuCgo6bGV0IFt7bmFtZTF9LCB7bmFtZTJ9LCAuLi5dID0ge2V4cHIxfQkJKjpsZXQtdW5wYWNrKiAqRTY4NyogKkU2ODgqCgkJCXtleHByMX0gbXVzdCBldmFsdWF0ZSB0byBhIHxMaXN0fC4gIFRoZSBmaXJzdCBpdGVtIGluCgkJCXRoZSBsaXN0IGlzIGFzc2lnbmVkIHRvIHtuYW1lMX0sIHRoZSBzZWNvbmQgaXRlbSB0bwoJCQl7bmFtZTJ9LCBldGMuCgkJCVRoZSBudW1iZXIgb2YgbmFtZXMgbXVzdCBtYXRjaCB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluCgkJCXRoZSB8TGlzdHwuCgkJCUVhY2ggbmFtZSBjYW4gYmUgb25lIG9mIHRoZSBpdGVtcyBvZiB0aGUgIjpsZXQiCgkJCWNvbW1hbmQgYXMgbWVudGlvbmVkIGFib3ZlLgoJCQlFeGFtcGxlOiA+CgkJCQk6bGV0IFtzLCBpdGVtXSA9IEdldEl0ZW0ocykKPAkJCURldGFpbDoge2V4cHIxfSBpcyBldmFsdWF0ZWQgZmlyc3QsIHRoZW4gdGhlCgkJCWFzc2lnbm1lbnRzIGFyZSBkb25lIGluIHNlcXVlbmNlLiAgVGhpcyBtYXR0ZXJzIGlmCgkJCXtuYW1lMn0gZGVwZW5kcyBvbiB7bmFtZTF9LiAgRXhhbXBsZTogPgoJCQkJOmxldCB4ID0gWzAsIDFdCgkJCQk6bGV0IGkgPSAwCgkJCQk6bGV0IFtpLCB4W2ldXSA9IFsxLCAyXQoJCQkJOmVjaG8geAo8CQkJVGhlIHJlc3VsdCBpcyBbMCwgMl0uCgo6bGV0IFt7bmFtZTF9LCB7bmFtZTJ9LCAuLi5dIC49IHtleHByMX0KOmxldCBbe25hbWUxfSwge25hbWUyfSwgLi4uXSArPSB7ZXhwcjF9CjpsZXQgW3tuYW1lMX0sIHtuYW1lMn0sIC4uLl0gLT0ge2V4cHIxfQoJCQlMaWtlIGFib3ZlLCBidXQgYXBwZW5kL2FkZC9zdWJ0cmFjdCB0aGUgdmFsdWUgZm9yIGVhY2gKCQkJfExpc3R8IGl0ZW0uCgo6bGV0IFt7bmFtZX0sIC4uLiwgOyB7bGFzdG5hbWV9XSA9IHtleHByMX0KCQkJTGlrZSB8OmxldC11bnBhY2t8IGFib3ZlLCBidXQgdGhlIHxMaXN0fCBtYXkgaGF2ZSBtb3JlCgkJCWl0ZW1zIHRoYW4gdGhlcmUgYXJlIG5hbWVzLiAgQSBsaXN0IG9mIHRoZSByZW1haW5pbmcKCQkJaXRlbXMgaXMgYXNzaWduZWQgdG8ge2xhc3RuYW1lfS4gIElmIHRoZXJlIGFyZSBubwoJCQlyZW1haW5pbmcgaXRlbXMge2xhc3RuYW1lfSBpcyBzZXQgdG8gYW4gZW1wdHkgbGlzdC4KCQkJRXhhbXBsZTogPgoJCQkJOmxldCBbYSwgYjsgcmVzdF0gPSBbImF2YWwiLCAiYnZhbCIsIDMsIDRdCjwKOmxldCBbe25hbWV9LCAuLi4sIDsge2xhc3RuYW1lfV0gLj0ge2V4cHIxfQo6bGV0IFt7bmFtZX0sIC4uLiwgOyB7bGFzdG5hbWV9XSArPSB7ZXhwcjF9CjpsZXQgW3tuYW1lfSwgLi4uLCA7IHtsYXN0bmFtZX1dIC09IHtleHByMX0KCQkJTGlrZSBhYm92ZSwgYnV0IGFwcGVuZC9hZGQvc3VidHJhY3QgdGhlIHZhbHVlIGZvciBlYWNoCgkJCXxMaXN0fCBpdGVtLgoKCQkJCQkJCQkqRTEyMSoKOmxldCB7dmFyLW5hbWV9CS4uCUxpc3QgdGhlIHZhbHVlIG9mIHZhcmlhYmxlIHt2YXItbmFtZX0uCU11bHRpcGxlCgkJCXZhcmlhYmxlIG5hbWVzIG1heSBiZSBnaXZlbi4gIFNwZWNpYWwgbmFtZXMgcmVjb2duaXplZAoJCQloZXJlOgkJCQkqRTczOCoKCQkJICBnOglnbG9iYWwgdmFyaWFibGVzCgkJCSAgYjoJbG9jYWwgYnVmZmVyIHZhcmlhYmxlcwoJCQkgIHc6CWxvY2FsIHdpbmRvdyB2YXJpYWJsZXMKCQkJICB0Oglsb2NhbCB0YWIgcGFnZSB2YXJpYWJsZXMKCQkJICBzOglzY3JpcHQtbG9jYWwgdmFyaWFibGVzCgkJCSAgbDoJbG9jYWwgZnVuY3Rpb24gdmFyaWFibGVzCgkJCSAgdjoJVmltIHZhcmlhYmxlcy4KCjpsZXQJCQlMaXN0IHRoZSB2YWx1ZXMgb2YgYWxsIHZhcmlhYmxlcy4gIFRoZSB0eXBlIG9mIHRoZQoJCQl2YXJpYWJsZSBpcyBpbmRpY2F0ZWQgYmVmb3JlIHRoZSB2YWx1ZToKCQkJICAgIDxub3RoaW5nPglTdHJpbmcKCQkJCSMJTnVtYmVyCgkJCQkqCUZ1bmNyZWYKCgo6dW5sW2V0XVshXSB7bmFtZX0gLi4uCQkJCSo6dW5sZXQqICo6dW5sKiAqRTEwOCogKkU3OTUqCgkJCVJlbW92ZSB0aGUgaW50ZXJuYWwgdmFyaWFibGUge25hbWV9LiAgU2V2ZXJhbCB2YXJpYWJsZQoJCQluYW1lcyBjYW4gYmUgZ2l2ZW4sIHRoZXkgYXJlIGFsbCByZW1vdmVkLiAgVGhlIG5hbWUKCQkJbWF5IGFsc28gYmUgYSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IGl0ZW0uCgkJCVdpdGggWyFdIG5vIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4gZm9yIG5vbi1leGlzdGluZwoJCQl2YXJpYWJsZXMuCgkJCU9uZSBvciBtb3JlIGl0ZW1zIGZyb20gYSB8TGlzdHwgY2FuIGJlIHJlbW92ZWQ6ID4KCQkJCTp1bmxldCBsaXN0WzNdCSAgIiByZW1vdmUgZm91cnRoIGl0ZW0KCQkJCTp1bmxldCBsaXN0WzM6XSAgICIgcmVtb3ZlIGZvdXJ0aCBpdGVtIHRvIGxhc3QKPAkJCU9uZSBpdGVtIGZyb20gYSB8RGljdGlvbmFyeXwgY2FuIGJlIHJlbW92ZWQgYXQgYSB0aW1lOiA+CgkJCQk6dW5sZXQgZGljdFsndHdvJ10KCQkJCTp1bmxldCBkaWN0LnR3bwo8CQkJVGhpcyBpcyBlc3BlY2lhbGx5IHVzZWZ1bCB0byBjbGVhbiB1cCB1c2VkIGdsb2JhbAoJCQl2YXJpYWJsZXMgYW5kIHNjcmlwdC1sb2NhbCB2YXJpYWJsZXMgKHRoZXNlIGFyZSBub3QKCQkJZGVsZXRlZCB3aGVuIHRoZSBzY3JpcHQgZW5kcykuICBGdW5jdGlvbi1sb2NhbAoJCQl2YXJpYWJsZXMgYXJlIGF1dG9tYXRpY2FsbHkgZGVsZXRlZCB3aGVuIHRoZSBmdW5jdGlvbgoJCQllbmRzLgoKOmxvY2t2W2FyXVshXSBbZGVwdGhdIHtuYW1lfSAuLi4JCQkqOmxvY2t2YXIqICo6bG9ja3YqCgkJCUxvY2sgdGhlIGludGVybmFsIHZhcmlhYmxlIHtuYW1lfS4gIExvY2tpbmcgbWVhbnMgdGhhdAoJCQlpdCBjYW4gbm8gbG9uZ2VyIGJlIGNoYW5nZWQgKHVudGlsIGl0IGlzIHVubG9ja2VkKS4KCQkJQSBsb2NrZWQgdmFyaWFibGUgY2FuIGJlIGRlbGV0ZWQ6ID4KCQkJCTpsb2NrdmFyIHYKCQkJCTpsZXQgdiA9ICdhc2RmJwkJIiBmYWlscyEKCQkJCTp1bmxldCB2CjwJCQkJCQkJKkU3NDEqCgkJCUlmIHlvdSB0cnkgdG8gY2hhbmdlIGEgbG9ja2VkIHZhcmlhYmxlIHlvdSBnZXQgYW4KCQkJZXJyb3IgbWVzc2FnZTogIkU3NDE6IFZhbHVlIG9mIHtuYW1lfSBpcyBsb2NrZWQiCgoJCQlbZGVwdGhdIGlzIHJlbGV2YW50IHdoZW4gbG9ja2luZyBhIHxMaXN0fCBvcgoJCQl8RGljdGlvbmFyeXwuICBJdCBzcGVjaWZpZXMgaG93IGRlZXAgdGhlIGxvY2tpbmcgZ29lczoKCQkJCTEJTG9jayB0aGUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCBpdHNlbGYsCgkJCQkJY2Fubm90IGFkZCBvciByZW1vdmUgaXRlbXMsIGJ1dCBjYW4KCQkJCQlzdGlsbCBjaGFuZ2UgdGhlaXIgdmFsdWVzLgoJCQkJMglBbHNvIGxvY2sgdGhlIHZhbHVlcywgY2Fubm90IGNoYW5nZQoJCQkJCXRoZSBpdGVtcy4gIElmIGFuIGl0ZW0gaXMgYSB8TGlzdHwgb3IKCQkJCQl8RGljdGlvbmFyeXwsIGNhbm5vdCBhZGQgb3IgcmVtb3ZlCgkJCQkJaXRlbXMsIGJ1dCBjYW4gc3RpbGwgY2hhbmdlIHRoZQoJCQkJCXZhbHVlcy4KCQkJCTMJTGlrZSAyIGJ1dCBmb3IgdGhlIHxMaXN0fCAvCgkJCQkJfERpY3Rpb25hcnl8IGluIHRoZSB8TGlzdHwgLwoJCQkJCXxEaWN0aW9uYXJ5fCwgb25lIGxldmVsIGRlZXBlci4KCQkJVGhlIGRlZmF1bHQgW2RlcHRoXSBpcyAyLCB0aHVzIHdoZW4ge25hbWV9IGlzIGEgfExpc3R8CgkJCW9yIHxEaWN0aW9uYXJ5fCB0aGUgdmFsdWVzIGNhbm5vdCBiZSBjaGFuZ2VkLgoJCQkJCQkJCSpFNzQzKgoJCQlGb3IgdW5saW1pdGVkIGRlcHRoIHVzZSBbIV0gYW5kIG9taXQgW2RlcHRoXS4KCQkJSG93ZXZlciwgdGhlcmUgaXMgYSBtYXhpbXVtIGRlcHRoIG9mIDEwMCB0byBjYXRjaAoJCQlsb29wcy4KCgkJCU5vdGUgdGhhdCB3aGVuIHR3byB2YXJpYWJsZXMgcmVmZXIgdG8gdGhlIHNhbWUgfExpc3R8CgkJCWFuZCB5b3UgbG9jayBvbmUgb2YgdGhlbSwgdGhlIHxMaXN0fCB3aWxsIGFsc28gYmUKCQkJbG9ja2VkIHdoZW4gdXNlZCB0aHJvdWdoIHRoZSBvdGhlciB2YXJpYWJsZS4KCQkJRXhhbXBsZTogPgoJCQkJOmxldCBsID0gWzAsIDEsIDIsIDNdCgkJCQk6bGV0IGNsID0gbAoJCQkJOmxvY2t2YXIgbAoJCQkJOmxldCBjbFsxXSA9IDk5CQkiIHdvbid0IHdvcmshCjwJCQlZb3UgbWF5IHdhbnQgdG8gbWFrZSBhIGNvcHkgb2YgYSBsaXN0IHRvIGF2b2lkIHRoaXMuCgkJCVNlZSB8ZGVlcGNvcHkoKXwuCgoKOnVubG9bY2t2YXJdWyFdIFtkZXB0aF0ge25hbWV9IC4uLgkJCSo6dW5sb2NrdmFyKiAqOnVubG8qCgkJCVVubG9jayB0aGUgaW50ZXJuYWwgdmFyaWFibGUge25hbWV9LiAgRG9lcyB0aGUKCQkJb3Bwb3NpdGUgb2YgfDpsb2NrdmFyfC4KCgo6aWYge2V4cHIxfQkJCSo6aWYqICo6ZW5kaWYqICo6ZW4qICpFMTcxKiAqRTU3OSogKkU1ODAqCjplbltkaWZdCQlFeGVjdXRlIHRoZSBjb21tYW5kcyB1bnRpbCB0aGUgbmV4dCBtYXRjaGluZyAiOmVsc2UiCgkJCW9yICI6ZW5kaWYiIGlmIHtleHByMX0gZXZhbHVhdGVzIHRvIG5vbi16ZXJvLgoKCQkJRnJvbSBWaW0gdmVyc2lvbiA0LjUgdW50aWwgNS4wLCBldmVyeSBFeCBjb21tYW5kIGluCgkJCWJldHdlZW4gdGhlICI6aWYiIGFuZCAiOmVuZGlmIiBpcyBpZ25vcmVkLiAgVGhlc2UgdHdvCgkJCWNvbW1hbmRzIHdlcmUganVzdCB0byBhbGxvdyBmb3IgZnV0dXJlIGV4cGFuc2lvbnMgaW4gYQoJCQliYWNrd2FyZHMgY29tcGF0aWJsZSB3YXkuICBOZXN0aW5nIHdhcyBhbGxvd2VkLiAgTm90ZQoJCQl0aGF0IGFueSAiOmVsc2UiIG9yICI6ZWxzZWlmIiB3YXMgaWdub3JlZCwgdGhlICJlbHNlIgoJCQlwYXJ0IHdhcyBub3QgZXhlY3V0ZWQgZWl0aGVyLgoKCQkJWW91IGNhbiB1c2UgdGhpcyB0byByZW1haW4gY29tcGF0aWJsZSB3aXRoIG9sZGVyCgkJCXZlcnNpb25zOiA+CgkJCQk6aWYgdmVyc2lvbiA+PSA1MDAKCQkJCTogIHZlcnNpb24tNS1zcGVjaWZpYy1jb21tYW5kcwoJCQkJOmVuZGlmCjwJCQlUaGUgY29tbWFuZHMgc3RpbGwgbmVlZCB0byBiZSBwYXJzZWQgdG8gZmluZCB0aGUKCQkJImVuZGlmIi4gIFNvbWV0aW1lcyBhbiBvbGRlciBWaW0gaGFzIGEgcHJvYmxlbSB3aXRoIGEKCQkJbmV3IGNvbW1hbmQuICBGb3IgZXhhbXBsZSwgIjpzaWxlbnQiIGlzIHJlY29nbml6ZWQgYXMKCQkJYSAiOnN1YnN0aXR1dGUiIGNvbW1hbmQuICBJbiB0aGF0IGNhc2UgIjpleGVjdXRlIiBjYW4KCQkJYXZvaWQgcHJvYmxlbXM6ID4KCQkJCTppZiB2ZXJzaW9uID49IDYwMAoJCQkJOiAgZXhlY3V0ZSAic2lsZW50IDEsJGRlbGV0ZSIKCQkJCTplbmRpZgo8CgkJCU5PVEU6IFRoZSAiOmFwcGVuZCIgYW5kICI6aW5zZXJ0IiBjb21tYW5kcyBkb24ndCB3b3JrCgkJCXByb3Blcmx5IGluIGJldHdlZW4gIjppZiIgYW5kICI6ZW5kaWYiLgoKCQkJCQkJKjplbHNlKiAqOmVsKiAqRTU4MSogKkU1ODMqCjplbFtzZV0JCQlFeGVjdXRlIHRoZSBjb21tYW5kcyB1bnRpbCB0aGUgbmV4dCBtYXRjaGluZyAiOmVsc2UiCgkJCW9yICI6ZW5kaWYiIGlmIHRoZXkgcHJldmlvdXNseSB3ZXJlIG5vdCBiZWluZwoJCQlleGVjdXRlZC4KCgkJCQkJKjplbHNlaWYqICo6ZWxzZWkqICpFNTgyKiAqRTU4NCoKOmVsc2VpW2ZdIHtleHByMX0JU2hvcnQgZm9yICI6ZWxzZSIgIjppZiIsIHdpdGggdGhlIGFkZGl0aW9uIHRoYXQgdGhlcmUKCQkJaXMgbm8gZXh0cmEgIjplbmRpZiIuCgo6d2hbaWxlXSB7ZXhwcjF9CQkJKjp3aGlsZSogKjplbmR3aGlsZSogKjp3aCogKjplbmR3KgoJCQkJCQkqRTE3MCogKkU1ODUqICpFNTg4KiAqRTczMyoKOmVuZHdbaGlsZV0JCVJlcGVhdCB0aGUgY29tbWFuZHMgYmV0d2VlbiAiOndoaWxlIiBhbmQgIjplbmR3aGlsZSIsCgkJCWFzIGxvbmcgYXMge2V4cHIxfSBldmFsdWF0ZXMgdG8gbm9uLXplcm8uCgkJCVdoZW4gYW4gZXJyb3IgaXMgZGV0ZWN0ZWQgZnJvbSBhIGNvbW1hbmQgaW5zaWRlIHRoZQoJCQlsb29wLCBleGVjdXRpb24gY29udGludWVzIGFmdGVyIHRoZSAiZW5kd2hpbGUiLgoJCQlFeGFtcGxlOiA+CgkJCQk6bGV0IGxudW0gPSAxCgkJCQk6d2hpbGUgbG51bSA8PSBsaW5lKCIkIikKCQkJCSAgIDpjYWxsIEZpeExpbmUobG51bSkKCQkJCSAgIDpsZXQgbG51bSA9IGxudW0gKyAxCgkJCQk6ZW5kd2hpbGUKPAoJCQlOT1RFOiBUaGUgIjphcHBlbmQiIGFuZCAiOmluc2VydCIgY29tbWFuZHMgZG9uJ3Qgd29yawoJCQlwcm9wZXJseSBpbnNpZGUgYSAiOndoaWxlIiBhbmQgIjpmb3IiIGxvb3AuCgo6Zm9yIHt2YXJ9IGluIHtsaXN0fQkJCQkJKjpmb3IqICpFNjkwKiAqRTczMioKOmVuZGZvW3JdCQkJCQkJKjplbmRmbyogKjplbmRmb3IqCgkJCVJlcGVhdCB0aGUgY29tbWFuZHMgYmV0d2VlbiAiOmZvciIgYW5kICI6ZW5kZm9yIiBmb3IKCQkJZWFjaCBpdGVtIGluIHtsaXN0fS4gIFZhcmlhYmxlIHt2YXJ9IGlzIHNldCB0byB0aGUKCQkJdmFsdWUgb2YgZWFjaCBpdGVtLgoJCQlXaGVuIGFuIGVycm9yIGlzIGRldGVjdGVkIGZvciBhIGNvbW1hbmQgaW5zaWRlIHRoZQoJCQlsb29wLCBleGVjdXRpb24gY29udGludWVzIGFmdGVyIHRoZSAiZW5kZm9yIi4KCQkJQ2hhbmdpbmcge2xpc3R9IGluc2lkZSB0aGUgbG9vcCBhZmZlY3RzIHdoYXQgaXRlbXMgYXJlCgkJCXVzZWQuICBNYWtlIGEgY29weSBpZiB0aGlzIGlzIHVud2FudGVkOiA+CgkJCQk6Zm9yIGl0ZW0gaW4gY29weShteWxpc3QpCjwJCQlXaGVuIG5vdCBtYWtpbmcgYSBjb3B5LCBWaW0gc3RvcmVzIGEgcmVmZXJlbmNlIHRvIHRoZQoJCQluZXh0IGl0ZW0gaW4gdGhlIGxpc3QsIGJlZm9yZSBleGVjdXRpbmcgdGhlIGNvbW1hbmRzCgkJCXdpdGggdGhlIGN1cnJlbnQgaXRlbS4JVGh1cyB0aGUgY3VycmVudCBpdGVtIGNhbiBiZQoJCQlyZW1vdmVkIHdpdGhvdXQgZWZmZWN0LiAgUmVtb3ZpbmcgYW55IGxhdGVyIGl0ZW0gbWVhbnMKCQkJaXQgd2lsbCBub3QgYmUgZm91bmQuICBUaHVzIHRoZSBmb2xsb3dpbmcgZXhhbXBsZQoJCQl3b3JrcyAoYW4gaW5lZmZpY2llbnQgd2F5IHRvIG1ha2UgYSBsaXN0IGVtcHR5KTogPgoJCQkJZm9yIGl0ZW0gaW4gbXlsaXN0CgkJCQkgICBjYWxsIHJlbW92ZShteWxpc3QsIDApCgkJCQllbmRmb3IKPAkJCU5vdGUgdGhhdCByZW9yZGVyaW5nIHRoZSBsaXN0IChlLmcuLCB3aXRoIHNvcnQoKSBvcgoJCQlyZXZlcnNlKCkpIG1heSBoYXZlIHVuZXhwZWN0ZWQgZWZmZWN0cy4KCQkJTm90ZSB0aGF0IHRoZSB0eXBlIG9mIGVhY2ggbGlzdCBpdGVtIHNob3VsZCBiZQoJCQlpZGVudGljYWwgdG8gYXZvaWQgZXJyb3JzIGZvciB0aGUgdHlwZSBvZiB7dmFyfQoJCQljaGFuZ2luZy4gIFVubGV0IHRoZSB2YXJpYWJsZSBhdCB0aGUgZW5kIG9mIHRoZSBsb29wCgkJCXRvIGFsbG93IG11bHRpcGxlIGl0ZW0gdHlwZXM6ID4KCQkJCWZvciBpdGVtIGluIFsiZm9vIiwgWyJiYXIiXV0KCQkJCSAgIGVjaG8gaXRlbQoJCQkJICAgdW5sZXQgaXRlbSAgIiBFNzA2IHdpdGhvdXQgdGhpcwoJCQkJZW5kZm9yCgo6Zm9yIFt7dmFyMX0sIHt2YXIyfSwgLi4uXSBpbiB7bGlzdGxpc3R9CjplbmRmb1tyXQoJCQlMaWtlICI6Zm9yIiBhYm92ZSwgYnV0IGVhY2ggaXRlbSBpbiB7bGlzdGxpc3R9IG11c3QgYmUKCQkJYSBsaXN0LCBvZiB3aGljaCBlYWNoIGl0ZW0gaXMgYXNzaWduZWQgdG8ge3ZhcjF9LAoJCQl7dmFyMn0sIGV0Yy4gIEV4YW1wbGU6ID4KCQkJCTpmb3IgW2xudW0sIGNvbF0gaW4gW1sxLCAzXSwgWzIsIDVdLCBbMywgOF1dCgkJCQkgICA6ZWNobyBnZXRsaW5lKGxudW0pW2NvbF0KCQkJCTplbmRmb3IKPAoJCQkJCQkqOmNvbnRpbnVlKiAqOmNvbiogKkU1ODYqCjpjb25bdGludWVdCQlXaGVuIHVzZWQgaW5zaWRlIGEgIjp3aGlsZSIgb3IgIjpmb3IiIGxvb3AsIGp1bXBzIGJhY2sKCQkJdG8gdGhlIHN0YXJ0IG9mIHRoZSBsb29wLgoJCQlJZiBpdCBpcyB1c2VkIGFmdGVyIGEgfDp0cnl8IGluc2lkZSB0aGUgbG9vcCBidXQKCQkJYmVmb3JlIHRoZSBtYXRjaGluZyB8OmZpbmFsbHl8IChpZiBwcmVzZW50KSwgdGhlCgkJCWNvbW1hbmRzIGZvbGxvd2luZyB0aGUgIjpmaW5hbGx5IiB1cCB0byB0aGUgbWF0Y2hpbmcKCQkJfDplbmR0cnl8IGFyZSBleGVjdXRlZCBmaXJzdC4gIFRoaXMgcHJvY2VzcyBhcHBsaWVzIHRvCgkJCWFsbCBuZXN0ZWQgIjp0cnkicyBpbnNpZGUgdGhlIGxvb3AuICBUaGUgb3V0ZXJtb3N0CgkJCSI6ZW5kdHJ5IiB0aGVuIGp1bXBzIGJhY2sgdG8gdGhlIHN0YXJ0IG9mIHRoZSBsb29wLgoKCQkJCQkJKjpicmVhayogKjpicmVhKiAqRTU4NyoKOmJyZWFba10JCVdoZW4gdXNlZCBpbnNpZGUgYSAiOndoaWxlIiBvciAiOmZvciIgbG9vcCwgc2tpcHMgdG8KCQkJdGhlIGNvbW1hbmQgYWZ0ZXIgdGhlIG1hdGNoaW5nICI6ZW5kd2hpbGUiIG9yCgkJCSI6ZW5kZm9yIi4KCQkJSWYgaXQgaXMgdXNlZCBhZnRlciBhIHw6dHJ5fCBpbnNpZGUgdGhlIGxvb3AgYnV0CgkJCWJlZm9yZSB0aGUgbWF0Y2hpbmcgfDpmaW5hbGx5fCAoaWYgcHJlc2VudCksIHRoZQoJCQljb21tYW5kcyBmb2xsb3dpbmcgdGhlICI6ZmluYWxseSIgdXAgdG8gdGhlIG1hdGNoaW5nCgkJCXw6ZW5kdHJ5fCBhcmUgZXhlY3V0ZWQgZmlyc3QuICBUaGlzIHByb2Nlc3MgYXBwbGllcyB0bwoJCQlhbGwgbmVzdGVkICI6dHJ5InMgaW5zaWRlIHRoZSBsb29wLiAgVGhlIG91dGVybW9zdAoJCQkiOmVuZHRyeSIgdGhlbiBqdW1wcyB0byB0aGUgY29tbWFuZCBhZnRlciB0aGUgbG9vcC4KCjp0cnkJCQkJKjp0cnkqICo6ZW5kdCogKjplbmR0cnkqICpFNjAwKiAqRTYwMSogKkU2MDIqCjplbmR0W3J5XQkJQ2hhbmdlIHRoZSBlcnJvciBoYW5kbGluZyBmb3IgdGhlIGNvbW1hbmRzIGJldHdlZW4KCQkJIjp0cnkiIGFuZCAiOmVuZHRyeSIgaW5jbHVkaW5nIGV2ZXJ5dGhpbmcgYmVpbmcKCQkJZXhlY3V0ZWQgYWNyb3NzICI6c291cmNlIiBjb21tYW5kcywgZnVuY3Rpb24gY2FsbHMsCgkJCW9yIGF1dG9jb21tYW5kIGludm9jYXRpb25zLgoKCQkJV2hlbiBhbiBlcnJvciBvciBpbnRlcnJ1cHQgaXMgZGV0ZWN0ZWQgYW5kIHRoZXJlIGlzCgkJCWEgfDpmaW5hbGx5fCBjb21tYW5kIGZvbGxvd2luZywgZXhlY3V0aW9uIGNvbnRpbnVlcwoJCQlhZnRlciB0aGUgIjpmaW5hbGx5Ii4gIE90aGVyd2lzZSwgb3Igd2hlbiB0aGUKCQkJIjplbmR0cnkiIGlzIHJlYWNoZWQgdGhlcmVhZnRlciwgdGhlIG5leHQKCQkJKGR5bmFtaWNhbGx5KSBzdXJyb3VuZGluZyAiOnRyeSIgaXMgY2hlY2tlZCBmb3IKCQkJYSBjb3JyZXNwb25kaW5nICI6ZmluYWxseSIgZXRjLiAgVGhlbiB0aGUgc2NyaXB0CgkJCXByb2Nlc3NpbmcgaXMgdGVybWluYXRlZC4gIChXaGV0aGVyIGEgZnVuY3Rpb24KCQkJZGVmaW5pdGlvbiBoYXMgYW4gImFib3J0IiBhcmd1bWVudCBkb2VzIG5vdCBtYXR0ZXIuKQoJCQlFeGFtcGxlOiA+CgkJOnRyeSB8IGVkaXQgdG9vIG11Y2ggfCBmaW5hbGx5IHwgZWNobyAiY2xlYW51cCIgfCBlbmR0cnkKCQk6ZWNobyAiaW1wb3NzaWJsZSIJIiBub3QgcmVhY2hlZCwgc2NyaXB0IHRlcm1pbmF0ZWQgYWJvdmUKPAoJCQlNb3Jlb3ZlciwgYW4gZXJyb3Igb3IgaW50ZXJydXB0IChkeW5hbWljYWxseSkgaW5zaWRlCgkJCSI6dHJ5IiBhbmQgIjplbmR0cnkiIGlzIGNvbnZlcnRlZCB0byBhbiBleGNlcHRpb24uICBJdAoJCQljYW4gYmUgY2F1Z2h0IGFzIGlmIGl0IHdlcmUgdGhyb3duIGJ5IGEgfDp0aHJvd3wKCQkJY29tbWFuZCAoc2VlIHw6Y2F0Y2h8KS4gIEluIHRoaXMgY2FzZSwgdGhlIHNjcmlwdAoJCQlwcm9jZXNzaW5nIGlzIG5vdCB0ZXJtaW5hdGVkLgoKCQkJVGhlIHZhbHVlICJWaW06SW50ZXJydXB0IiBpcyB1c2VkIGZvciBhbiBpbnRlcnJ1cHQKCQkJZXhjZXB0aW9uLiAgQW4gZXJyb3IgaW4gYSBWaW0gY29tbWFuZCBpcyBjb252ZXJ0ZWQKCQkJdG8gYSB2YWx1ZSBvZiB0aGUgZm9ybSAiVmltKHtjb21tYW5kfSk6e2Vycm1zZ30iLAoJCQlvdGhlciBlcnJvcnMgYXJlIGNvbnZlcnRlZCB0byBhIHZhbHVlIG9mIHRoZSBmb3JtCgkJCSJWaW06e2Vycm1zZ30iLiAge2NvbW1hbmR9IGlzIHRoZSBmdWxsIGNvbW1hbmQgbmFtZSwKCQkJYW5kIHtlcnJtc2d9IGlzIHRoZSBtZXNzYWdlIHRoYXQgaXMgZGlzcGxheWVkIGlmIHRoZQoJCQllcnJvciBleGNlcHRpb24gaXMgbm90IGNhdWdodCwgYWx3YXlzIGJlZ2lubmluZyB3aXRoCgkJCXRoZSBlcnJvciBudW1iZXIuCgkJCUV4YW1wbGVzOiA+CgkJOnRyeSB8IHNsZWVwIDEwMCB8IGNhdGNoIC9eVmltOkludGVycnVwdCQvIHwgZW5kdHJ5CgkJOnRyeSB8IGVkaXQgfCBjYXRjaCAvXlZpbShlZGl0KTpFXGRcKy8gfCBlY2hvICJlcnJvciIgfCBlbmR0cnkKPAoJCQkJCSo6Y2F0KiAqOmNhdGNoKiAqRTYwMyogKkU2MDQqICpFNjA1Kgo6Y2F0W2NoXSAve3BhdHRlcm59LwlUaGUgZm9sbG93aW5nIGNvbW1hbmRzIHVudGlsIHRoZSBuZXh0IHw6Y2F0Y2h8LAoJCQl8OmZpbmFsbHl8LCBvciB8OmVuZHRyeXwgdGhhdCBiZWxvbmdzIHRvIHRoZSBzYW1lCgkJCXw6dHJ5fCBhcyB0aGUgIjpjYXRjaCIgYXJlIGV4ZWN1dGVkIHdoZW4gYW4gZXhjZXB0aW9uCgkJCW1hdGNoaW5nIHtwYXR0ZXJufSBpcyBiZWluZyB0aHJvd24gYW5kIGhhcyBub3QgeWV0CgkJCWJlZW4gY2F1Z2h0IGJ5IGEgcHJldmlvdXMgIjpjYXRjaCIuICBPdGhlcndpc2UsIHRoZXNlCgkJCWNvbW1hbmRzIGFyZSBza2lwcGVkLgoJCQlXaGVuIHtwYXR0ZXJufSBpcyBvbWl0dGVkIGFsbCBlcnJvcnMgYXJlIGNhdWdodC4KCQkJRXhhbXBsZXM6ID4KCQk6Y2F0Y2ggL15WaW06SW50ZXJydXB0JC8JIiBjYXRjaCBpbnRlcnJ1cHRzIChDVFJMLUMpCgkJOmNhdGNoIC9eVmltXCUoKFxhXCspXClcPTpFLwkiIGNhdGNoIGFsbCBWaW0gZXJyb3JzCgkJOmNhdGNoIC9eVmltXCUoKFxhXCspXClcPTovCSIgY2F0Y2ggZXJyb3JzIGFuZCBpbnRlcnJ1cHRzCgkJOmNhdGNoIC9eVmltKHdyaXRlKTovCQkiIGNhdGNoIGFsbCBlcnJvcnMgaW4gOndyaXRlCgkJOmNhdGNoIC9eVmltXCUoKFxhXCspXClcPTpFMTIzLwkiIGNhdGNoIGVycm9yIEUxMjMKCQk6Y2F0Y2ggL215LWV4Y2VwdGlvbi8JCSIgY2F0Y2ggdXNlciBleGNlcHRpb24KCQk6Y2F0Y2ggLy4qLwkJCSIgY2F0Y2ggZXZlcnl0aGluZwoJCTpjYXRjaAkJCQkiIHNhbWUgYXMgLy4qLwo8CgkJCUFub3RoZXIgY2hhcmFjdGVyIGNhbiBiZSB1c2VkIGluc3RlYWQgb2YgLyBhcm91bmQgdGhlCgkJCXtwYXR0ZXJufSwgc28gbG9uZyBhcyBpdCBkb2VzIG5vdCBoYXZlIGEgc3BlY2lhbAoJCQltZWFuaW5nIChlLmcuLCAnfCcgb3IgJyInKSBhbmQgZG9lc24ndCBvY2N1ciBpbnNpZGUKCQkJe3BhdHRlcm59LgoJCQlOT1RFOiBJdCBpcyBub3QgcmVsaWFibGUgdG8gIjpjYXRjaCIgdGhlIFRFWFQgb2YKCQkJYW4gZXJyb3IgbWVzc2FnZSBiZWNhdXNlIGl0IG1heSB2YXJ5IGluIGRpZmZlcmVudAoJCQlsb2NhbGVzLgoKCQkJCQkqOmZpbmEqICo6ZmluYWxseSogKkU2MDYqICpFNjA3Kgo6ZmluYVtsbHldCQlUaGUgZm9sbG93aW5nIGNvbW1hbmRzIHVudGlsIHRoZSBtYXRjaGluZyB8OmVuZHRyeXwKCQkJYXJlIGV4ZWN1dGVkIHdoZW5ldmVyIHRoZSBwYXJ0IGJldHdlZW4gdGhlIG1hdGNoaW5nCgkJCXw6dHJ5fCBhbmQgdGhlICI6ZmluYWxseSIgaXMgbGVmdDogIGVpdGhlciBieSBmYWxsaW5nCgkJCXRocm91Z2ggdG8gdGhlICI6ZmluYWxseSIgb3IgYnkgYSB8OmNvbnRpbnVlfCwKCQkJfDpicmVha3wsIHw6ZmluaXNofCwgb3IgfDpyZXR1cm58LCBvciBieSBhbiBlcnJvciBvcgoJCQlpbnRlcnJ1cHQgb3IgZXhjZXB0aW9uIChzZWUgfDp0aHJvd3wpLgoKCQkJCQkJCSo6dGgqICo6dGhyb3cqICpFNjA4Kgo6dGhbcm93XSB7ZXhwcjF9CVRoZSB7ZXhwcjF9IGlzIGV2YWx1YXRlZCBhbmQgdGhyb3duIGFzIGFuIGV4Y2VwdGlvbi4KCQkJSWYgdGhlICI6dGhyb3ciIGlzIHVzZWQgYWZ0ZXIgYSB8OnRyeXwgYnV0IGJlZm9yZSB0aGUKCQkJZmlyc3QgY29ycmVzcG9uZGluZyB8OmNhdGNofCwgY29tbWFuZHMgYXJlIHNraXBwZWQKCQkJdW50aWwgdGhlIGZpcnN0ICI6Y2F0Y2giIG1hdGNoaW5nIHtleHByMX0gaXMgcmVhY2hlZC4KCQkJSWYgdGhlcmUgaXMgbm8gc3VjaCAiOmNhdGNoIiBvciBpZiB0aGUgIjp0aHJvdyIgaXMKCQkJdXNlZCBhZnRlciBhICI6Y2F0Y2giIGJ1dCBiZWZvcmUgdGhlIHw6ZmluYWxseXwsIHRoZQoJCQljb21tYW5kcyBmb2xsb3dpbmcgdGhlICI6ZmluYWxseSIgKGlmIHByZXNlbnQpIHVwIHRvCgkJCXRoZSBtYXRjaGluZyB8OmVuZHRyeXwgYXJlIGV4ZWN1dGVkLiAgSWYgdGhlICI6dGhyb3ciCgkJCWlzIGFmdGVyIHRoZSAiOmZpbmFsbHkiLCBjb21tYW5kcyB1cCB0byB0aGUgIjplbmR0cnkiCgkJCWFyZSBza2lwcGVkLiAgQXQgdGhlICI6ZW5kdHJ5IiwgdGhpcyBwcm9jZXNzIGFwcGxpZXMKCQkJYWdhaW4gZm9yIHRoZSBuZXh0IGR5bmFtaWNhbGx5IHN1cnJvdW5kaW5nICI6dHJ5IgoJCQkod2hpY2ggbWF5IGJlIGZvdW5kIGluIGEgY2FsbGluZyBmdW5jdGlvbiBvciBzb3VyY2luZwoJCQlzY3JpcHQpLCB1bnRpbCBhIG1hdGNoaW5nICI6Y2F0Y2giIGhhcyBiZWVuIGZvdW5kLgoJCQlJZiB0aGUgZXhjZXB0aW9uIGlzIG5vdCBjYXVnaHQsIHRoZSBjb21tYW5kIHByb2Nlc3NpbmcKCQkJaXMgdGVybWluYXRlZC4KCQkJRXhhbXBsZTogPgoJCTp0cnkgfCB0aHJvdyAib29wcyIgfCBjYXRjaCAvXm9vLyB8IGVjaG8gImNhdWdodCIgfCBlbmR0cnkKPAkJCU5vdGUgdGhhdCAiY2F0Y2giIG1heSBuZWVkIHRvIGJlIG9uIGEgc2VwYXJhdGUgbGluZQoJCQlmb3Igd2hlbiBhbiBlcnJvciBjYXVzZXMgdGhlIHBhcnNpbmcgdG8gc2tpcCB0aGUgd2hvbGUKCQkJbGluZSBhbmQgbm90IHNlZSB0aGUgInwiIHRoYXQgc2VwYXJhdGVzIHRoZSBjb21tYW5kcy4KCgkJCQkJCQkqOmVjKiAqOmVjaG8qCjplY1tob10ge2V4cHIxfSAuLglFY2hvZXMgZWFjaCB7ZXhwcjF9LCB3aXRoIGEgc3BhY2UgaW4gYmV0d2Vlbi4gIFRoZQoJCQlmaXJzdCB7ZXhwcjF9IHN0YXJ0cyBvbiBhIG5ldyBsaW5lLgoJCQlBbHNvIHNlZSB8OmNvbW1lbnR8LgoJCQlVc2UgIlxuIiB0byBzdGFydCBhIG5ldyBsaW5lLiAgVXNlICJcciIgdG8gbW92ZSB0aGUKCQkJY3Vyc29yIHRvIHRoZSBmaXJzdCBjb2x1bW4uCgkJCVVzZXMgdGhlIGhpZ2hsaWdodGluZyBzZXQgYnkgdGhlIHw6ZWNob2hsfCBjb21tYW5kLgoJCQlDYW5ub3QgYmUgZm9sbG93ZWQgYnkgYSBjb21tZW50LgoJCQlFeGFtcGxlOiA+CgkJOmVjaG8gInRoZSB2YWx1ZSBvZiAnc2hlbGwnIGlzIiAmc2hlbGwKPAkJCQkJCQkqOmVjaG8tcmVkcmF3KgoJCQlBIGxhdGVyIHJlZHJhdyBtYXkgbWFrZSB0aGUgbWVzc2FnZSBkaXNhcHBlYXIgYWdhaW4uCgkJCUFuZCBzaW5jZSBWaW0gbW9zdGx5IHBvc3Rwb25lcyByZWRyYXdpbmcgdW50aWwgaXQncwoJCQlmaW5pc2hlZCB3aXRoIGEgc2VxdWVuY2Ugb2YgY29tbWFuZHMgdGhpcyBoYXBwZW5zCgkJCXF1aXRlIG9mdGVuLiAgVG8gYXZvaWQgdGhhdCBhIGNvbW1hbmQgZnJvbSBiZWZvcmUgdGhlCgkJCSI6ZWNobyIgY2F1c2VzIGEgcmVkcmF3IGFmdGVyd2FyZHMgKHJlZHJhd3MgYXJlIG9mdGVuCgkJCXBvc3Rwb25lZCB1bnRpbCB5b3UgdHlwZSBzb21ldGhpbmcpLCBmb3JjZSBhIHJlZHJhdwoJCQl3aXRoIHRoZSB8OnJlZHJhd3wgY29tbWFuZC4gIEV4YW1wbGU6ID4KCQk6bmV3IHwgcmVkcmF3IHwgZWNobyAidGhlcmUgaXMgYSBuZXcgd2luZG93Igo8CgkJCQkJCQkqOmVjaG9uKgo6ZWNob24ge2V4cHIxfSAuLglFY2hvZXMgZWFjaCB7ZXhwcjF9LCB3aXRob3V0IGFueXRoaW5nIGFkZGVkLiAgQWxzbyBzZWUKCQkJfDpjb21tZW50fC4KCQkJVXNlcyB0aGUgaGlnaGxpZ2h0aW5nIHNldCBieSB0aGUgfDplY2hvaGx8IGNvbW1hbmQuCgkJCUNhbm5vdCBiZSBmb2xsb3dlZCBieSBhIGNvbW1lbnQuCgkJCUV4YW1wbGU6ID4KCQkJCTplY2hvbiAidGhlIHZhbHVlIG9mICdzaGVsbCcgaXMgIiAmc2hlbGwKPAoJCQlOb3RlIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gdXNpbmcgIjplY2hvIiwgd2hpY2ggaXMgYQoJCQlWaW0gY29tbWFuZCwgYW5kICI6IWVjaG8iLCB3aGljaCBpcyBhbiBleHRlcm5hbCBzaGVsbAoJCQljb21tYW5kOiA+CgkJOiFlY2hvICUJCS0tPiBmaWxlbmFtZQo8CQkJVGhlIGFyZ3VtZW50cyBvZiAiOiEiIGFyZSBleHBhbmRlZCwgc2VlIHw6XyV8LiA+CgkJOiFlY2hvICIlIgkJLS0+IGZpbGVuYW1lIG9yICJmaWxlbmFtZSIKPAkJCUxpa2UgdGhlIHByZXZpb3VzIGV4YW1wbGUuICBXaGV0aGVyIHlvdSBzZWUgdGhlIGRvdWJsZQoJCQlxdW90ZXMgb3Igbm90IGRlcGVuZHMgb24geW91ciAnc2hlbGwnLiA+CgkJOmVjaG8gJQkJCS0tPiBub3RoaW5nCjwJCQlUaGUgJyUnIGlzIGFuIGlsbGVnYWwgY2hhcmFjdGVyIGluIGFuIGV4cHJlc3Npb24uID4KCQk6ZWNobyAiJSIJCS0tPiAlCjwJCQlUaGlzIGp1c3QgZWNob2VzIHRoZSAnJScgY2hhcmFjdGVyLiA+CgkJOmVjaG8gZXhwYW5kKCIlIikJLS0+IGZpbGVuYW1lCjwJCQlUaGlzIGNhbGxzIHRoZSBleHBhbmQoKSBmdW5jdGlvbiB0byBleHBhbmQgdGhlICclJy4KCgkJCQkJCQkqOmVjaG9oKiAqOmVjaG9obCoKOmVjaG9oW2xdIHtuYW1lfQlVc2UgdGhlIGhpZ2hsaWdodCBncm91cCB7bmFtZX0gZm9yIHRoZSBmb2xsb3dpbmcKCQkJfDplY2hvfCwgfDplY2hvbnwgYW5kIHw6ZWNob21zZ3wgY29tbWFuZHMuICBBbHNvIHVzZWQKCQkJZm9yIHRoZSB8aW5wdXQoKXwgcHJvbXB0LiAgRXhhbXBsZTogPgoJCTplY2hvaGwgV2FybmluZ01zZyB8IGVjaG8gIkRvbid0IHBhbmljISIgfCBlY2hvaGwgTm9uZQo8CQkJRG9uJ3QgZm9yZ2V0IHRvIHNldCB0aGUgZ3JvdXAgYmFjayB0byAiTm9uZSIsCgkJCW90aGVyd2lzZSBhbGwgZm9sbG93aW5nIGVjaG8ncyB3aWxsIGJlIGhpZ2hsaWdodGVkLgoKCQkJCQkJCSo6ZWNob20qICo6ZWNob21zZyoKOmVjaG9tW3NnXSB7ZXhwcjF9IC4uCUVjaG8gdGhlIGV4cHJlc3Npb24ocykgYXMgYSB0cnVlIG1lc3NhZ2UsIHNhdmluZyB0aGUKCQkJbWVzc2FnZSBpbiB0aGUgfG1lc3NhZ2UtaGlzdG9yeXwuCgkJCVNwYWNlcyBhcmUgcGxhY2VkIGJldHdlZW4gdGhlIGFyZ3VtZW50cyBhcyB3aXRoIHRoZQoJCQl8OmVjaG98IGNvbW1hbmQuICBCdXQgdW5wcmludGFibGUgY2hhcmFjdGVycyBhcmUKCQkJZGlzcGxheWVkLCBub3QgaW50ZXJwcmV0ZWQuCgkJCVRoZSBwYXJzaW5nIHdvcmtzIHNsaWdodGx5IGRpZmZlcmVudCBmcm9tIHw6ZWNob3wsCgkJCW1vcmUgbGlrZSB8OmV4ZWN1dGV8LiAgQWxsIHRoZSBleHByZXNzaW9ucyBhcmUgZmlyc3QKCQkJZXZhbHVhdGVkIGFuZCBjb25jYXRlbmF0ZWQgYmVmb3JlIGVjaG9pbmcgYW55dGhpbmcuCgkJCVRoZSBleHByZXNzaW9ucyBtdXN0IGV2YWx1YXRlIHRvIGEgTnVtYmVyIG9yIFN0cmluZywgYQoJCQlEaWN0aW9uYXJ5IG9yIExpc3QgY2F1c2VzIGFuIGVycm9yLgoJCQlVc2VzIHRoZSBoaWdobGlnaHRpbmcgc2V0IGJ5IHRoZSB8OmVjaG9obHwgY29tbWFuZC4KCQkJRXhhbXBsZTogPgoJCTplY2hvbXNnICJJdCdzIGEgWml6emVyIFphenplciBadXp6LCBhcyB5b3UgY2FuIHBsYWlubHkgc2VlLiIKPAkJCVNlZSB8OmVjaG8tcmVkcmF3fCB0byBhdm9pZCB0aGUgbWVzc2FnZSBkaXNhcHBlYXJpbmcKCQkJd2hlbiB0aGUgc2NyZWVuIGlzIHJlZHJhd24uCgkJCQkJCQkqOmVjaG9lKiAqOmVjaG9lcnIqCjplY2hvZVtycl0ge2V4cHIxfSAuLglFY2hvIHRoZSBleHByZXNzaW9uKHMpIGFzIGFuIGVycm9yIG1lc3NhZ2UsIHNhdmluZyB0aGUKCQkJbWVzc2FnZSBpbiB0aGUgfG1lc3NhZ2UtaGlzdG9yeXwuICBXaGVuIHVzZWQgaW4gYQoJCQlzY3JpcHQgb3IgZnVuY3Rpb24gdGhlIGxpbmUgbnVtYmVyIHdpbGwgYmUgYWRkZWQuCgkJCVNwYWNlcyBhcmUgcGxhY2VkIGJldHdlZW4gdGhlIGFyZ3VtZW50cyBhcyB3aXRoIHRoZQoJCQk6ZWNobyBjb21tYW5kLglXaGVuIHVzZWQgaW5zaWRlIGEgdHJ5IGNvbmRpdGlvbmFsLAoJCQl0aGUgbWVzc2FnZSBpcyByYWlzZWQgYXMgYW4gZXJyb3IgZXhjZXB0aW9uIGluc3RlYWQKCQkJKHNlZSB8dHJ5LWVjaG9lcnJ8KS4KCQkJRXhhbXBsZTogPgoJCTplY2hvZXJyICJUaGlzIHNjcmlwdCBqdXN0IGZhaWxlZCEiCjwJCQlJZiB5b3UganVzdCB3YW50IGEgaGlnaGxpZ2h0ZWQgbWVzc2FnZSB1c2UgfDplY2hvaGx8LgoJCQlBbmQgdG8gZ2V0IGEgYmVlcDogPgoJCTpleGUgIm5vcm1hbCBcPEVzYz4iCjwKCQkJCQkJCSo6ZXhlKiAqOmV4ZWN1dGUqCjpleGVbY3V0ZV0ge2V4cHIxfSAuLglFeGVjdXRlcyB0aGUgc3RyaW5nIHRoYXQgcmVzdWx0cyBmcm9tIHRoZSBldmFsdWF0aW9uCgkJCW9mIHtleHByMX0gYXMgYW4gRXggY29tbWFuZC4KCQkJTXVsdGlwbGUgYXJndW1lbnRzIGFyZSBjb25jYXRlbmF0ZWQsIHdpdGggYSBzcGFjZSBpbgoJCQliZXR3ZWVuLiAgVG8gYXZvaWQgdGhlIGV4dHJhIHNwYWNlIHVzZSB0aGUgIi4iCgkJCW9wZXJhdG9yIHRvIGNvbmNhdGVuYXRlIHN0cmluZ3MgaW50byBvbmUgYXJndW1lbnQuCgkJCXtleHByMX0gaXMgdXNlZCBhcyB0aGUgcHJvY2Vzc2VkIGNvbW1hbmQsIGNvbW1hbmQgbGluZQoJCQllZGl0aW5nIGtleXMgYXJlIG5vdCByZWNvZ25pemVkLgoJCQlDYW5ub3QgYmUgZm9sbG93ZWQgYnkgYSBjb21tZW50LgoJCQlFeGFtcGxlczogPgoJCTpleGVjdXRlICJidWZmZXIiIG5leHRidWYKCQk6ZXhlY3V0ZSAibm9ybWFsIiBjb3VudCAuICJ3Igo8CgkJCSI6ZXhlY3V0ZSIgY2FuIGJlIHVzZWQgdG8gYXBwZW5kIGEgY29tbWFuZCB0byBjb21tYW5kcwoJCQl0aGF0IGRvbid0IGFjY2VwdCBhICd8Jy4gIEV4YW1wbGU6ID4KCQk6ZXhlY3V0ZSAnIWxzJyB8IGVjaG8gInRoZWVuZCIKCjwJCQkiOmV4ZWN1dGUiIGlzIGFsc28gYSBuaWNlIHdheSB0byBhdm9pZCBoYXZpbmcgdG8gdHlwZQoJCQljb250cm9sIGNoYXJhY3RlcnMgaW4gYSBWaW0gc2NyaXB0IGZvciBhICI6bm9ybWFsIgoJCQljb21tYW5kOiA+CgkJOmV4ZWN1dGUgIm5vcm1hbCBpeHh4XDxFc2M+Igo8CQkJVGhpcyBoYXMgYW4gPEVzYz4gY2hhcmFjdGVyLCBzZWUgfGV4cHItc3RyaW5nfC4KCgkJCUJlIGNhcmVmdWwgdG8gY29ycmVjdGx5IGVzY2FwZSBzcGVjaWFsIGNoYXJhY3RlcnMgaW4KCQkJZmlsZSBuYW1lcy4gIFRoZSB8Zm5hbWVlc2NhcGUoKXwgZnVuY3Rpb24gY2FuIGJlIHVzZWQKCQkJZm9yIFZpbSBjb21tYW5kcywgfHNoZWxsZXNjYXBlKCl8IGZvciB8OiF8IGNvbW1hbmRzLgoJCQlFeGFtcGxlczogPgoJCTpleGVjdXRlICJlICIgLiBmbmFtZWVzY2FwZShmaWxlbmFtZSkKCQk6ZXhlY3V0ZSAiIWxzICIgLiBzaGVsbGVzY2FwZShleHBhbmQoJyU6aCcpLCAxKQo8CgkJCU5vdGU6IFRoZSBleGVjdXRlZCBzdHJpbmcgbWF5IGJlIGFueSBjb21tYW5kLWxpbmUsIGJ1dAoJCQl5b3UgY2Fubm90IHN0YXJ0IG9yIGVuZCBhICJ3aGlsZSIsICJmb3IiIG9yICJpZiIKCQkJY29tbWFuZC4gIFRodXMgdGhpcyBpcyBpbGxlZ2FsOiA+CgkJOmV4ZWN1dGUgJ3doaWxlIGkgPiA1JwoJCTpleGVjdXRlICdlY2hvICJ0ZXN0IiB8IGJyZWFrJwo8CgkJCUl0IGlzIGFsbG93ZWQgdG8gaGF2ZSBhICJ3aGlsZSIgb3IgImlmIiBjb21tYW5kCgkJCWNvbXBsZXRlbHkgaW4gdGhlIGV4ZWN1dGVkIHN0cmluZzogPgoJCTpleGVjdXRlICd3aGlsZSBpIDwgNSB8IGVjaG8gaSB8IGxldCBpID0gaSArIDEgfCBlbmR3aGlsZScKPAoKCQkJCQkJCSo6ZXhlLWNvbW1lbnQqCgkJCSI6ZXhlY3V0ZSIsICI6ZWNobyIgYW5kICI6ZWNob24iIGNhbm5vdCBiZSBmb2xsb3dlZCBieQoJCQlhIGNvbW1lbnQgZGlyZWN0bHksIGJlY2F1c2UgdGhleSBzZWUgdGhlICciJyBhcyB0aGUKCQkJc3RhcnQgb2YgYSBzdHJpbmcuICBCdXQsIHlvdSBjYW4gdXNlICd8JyBmb2xsb3dlZCBieSBhCgkJCWNvbW1lbnQuICBFeGFtcGxlOiA+CgkJOmVjaG8gImZvbyIgfCAidGhpcyBpcyBhIGNvbW1lbnQKCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo4LiBFeGNlcHRpb24gaGFuZGxpbmcJCQkJCSpleGNlcHRpb24taGFuZGxpbmcqCgpUaGUgVmltIHNjcmlwdCBsYW5ndWFnZSBjb21wcmlzZXMgYW4gZXhjZXB0aW9uIGhhbmRsaW5nIGZlYXR1cmUuICBUaGlzIHNlY3Rpb24KZXhwbGFpbnMgaG93IGl0IGNhbiBiZSB1c2VkIGluIGEgVmltIHNjcmlwdC4KCkV4Y2VwdGlvbnMgbWF5IGJlIHJhaXNlZCBieSBWaW0gb24gYW4gZXJyb3Igb3Igb24gaW50ZXJydXB0LCBzZWUKfGNhdGNoLWVycm9yc3wgYW5kIHxjYXRjaC1pbnRlcnJ1cHR8LiAgWW91IGNhbiBhbHNvIGV4cGxpY2l0bHkgdGhyb3cgYW4KZXhjZXB0aW9uIGJ5IHVzaW5nIHRoZSAiOnRocm93IiBjb21tYW5kLCBzZWUgfHRocm93LWNhdGNofC4KCgpUUlkgQ09ORElUSU9OQUxTCQkJCQkqdHJ5LWNvbmRpdGlvbmFscyoKCkV4Y2VwdGlvbnMgY2FuIGJlIGNhdWdodCBvciBjYW4gY2F1c2UgY2xlYW51cCBjb2RlIHRvIGJlIGV4ZWN1dGVkLiAgWW91IGNhbgp1c2UgYSB0cnkgY29uZGl0aW9uYWwgdG8gc3BlY2lmeSBjYXRjaCBjbGF1c2VzICh0aGF0IGNhdGNoIGV4Y2VwdGlvbnMpIGFuZC9vcgphIGZpbmFsbHkgY2xhdXNlICh0byBiZSBleGVjdXRlZCBmb3IgY2xlYW51cCkuCiAgIEEgdHJ5IGNvbmRpdGlvbmFsIGJlZ2lucyB3aXRoIGEgfDp0cnl8IGNvbW1hbmQgYW5kIGVuZHMgYXQgdGhlIG1hdGNoaW5nCnw6ZW5kdHJ5fCBjb21tYW5kLiAgSW4gYmV0d2VlbiwgeW91IGNhbiB1c2UgYSB8OmNhdGNofCBjb21tYW5kIHRvIHN0YXJ0CmEgY2F0Y2ggY2xhdXNlLCBvciBhIHw6ZmluYWxseXwgY29tbWFuZCB0byBzdGFydCBhIGZpbmFsbHkgY2xhdXNlLiAgVGhlcmUgbWF5CmJlIG5vbmUgb3IgbXVsdGlwbGUgY2F0Y2ggY2xhdXNlcywgYnV0IHRoZXJlIGlzIGF0IG1vc3Qgb25lIGZpbmFsbHkgY2xhdXNlLAp3aGljaCBtdXN0IG5vdCBiZSBmb2xsb3dlZCBieSBhbnkgY2F0Y2ggY2xhdXNlcy4gIFRoZSBsaW5lcyBiZWZvcmUgdGhlIGNhdGNoCmNsYXVzZXMgYW5kIHRoZSBmaW5hbGx5IGNsYXVzZSBpcyBjYWxsZWQgYSB0cnkgYmxvY2suID4KCiAgICAgOnRyeQogICAgIDoJLi4uCiAgICAgOgkuLi4JCQkJVFJZIEJMT0NLCiAgICAgOgkuLi4KICAgICA6Y2F0Y2ggL3twYXR0ZXJufS8KICAgICA6CS4uLgogICAgIDoJLi4uCQkJCUNBVENIIENMQVVTRQogICAgIDoJLi4uCiAgICAgOmNhdGNoIC97cGF0dGVybn0vCiAgICAgOgkuLi4KICAgICA6CS4uLgkJCQlDQVRDSCBDTEFVU0UKICAgICA6CS4uLgogICAgIDpmaW5hbGx5CiAgICAgOgkuLi4KICAgICA6CS4uLgkJCQlGSU5BTExZIENMQVVTRQogICAgIDoJLi4uCiAgICAgOmVuZHRyeQoKVGhlIHRyeSBjb25kaXRpb25hbCBhbGxvd3MgdG8gd2F0Y2ggY29kZSBmb3IgZXhjZXB0aW9ucyBhbmQgdG8gdGFrZSB0aGUKYXBwcm9wcmlhdGUgYWN0aW9ucy4gIEV4Y2VwdGlvbnMgZnJvbSB0aGUgdHJ5IGJsb2NrIG1heSBiZSBjYXVnaHQuICBFeGNlcHRpb25zCmZyb20gdGhlIHRyeSBibG9jayBhbmQgYWxzbyB0aGUgY2F0Y2ggY2xhdXNlcyBtYXkgY2F1c2UgY2xlYW51cCBhY3Rpb25zLgogICBXaGVuIG5vIGV4Y2VwdGlvbiBpcyB0aHJvd24gZHVyaW5nIGV4ZWN1dGlvbiBvZiB0aGUgdHJ5IGJsb2NrLCB0aGUgY29udHJvbAppcyB0cmFuc2ZlcnJlZCB0byB0aGUgZmluYWxseSBjbGF1c2UsIGlmIHByZXNlbnQuICBBZnRlciBpdHMgZXhlY3V0aW9uLCB0aGUKc2NyaXB0IGNvbnRpbnVlcyB3aXRoIHRoZSBsaW5lIGZvbGxvd2luZyB0aGUgIjplbmR0cnkiLgogICBXaGVuIGFuIGV4Y2VwdGlvbiBvY2N1cnMgZHVyaW5nIGV4ZWN1dGlvbiBvZiB0aGUgdHJ5IGJsb2NrLCB0aGUgcmVtYWluaW5nCmxpbmVzIGluIHRoZSB0cnkgYmxvY2sgYXJlIHNraXBwZWQuICBUaGUgZXhjZXB0aW9uIGlzIG1hdGNoZWQgYWdhaW5zdCB0aGUKcGF0dGVybnMgc3BlY2lmaWVkIGFzIGFyZ3VtZW50cyB0byB0aGUgIjpjYXRjaCIgY29tbWFuZHMuICBUaGUgY2F0Y2ggY2xhdXNlCmFmdGVyIHRoZSBmaXJzdCBtYXRjaGluZyAiOmNhdGNoIiBpcyB0YWtlbiwgb3RoZXIgY2F0Y2ggY2xhdXNlcyBhcmUgbm90CmV4ZWN1dGVkLiAgVGhlIGNhdGNoIGNsYXVzZSBlbmRzIHdoZW4gdGhlIG5leHQgIjpjYXRjaCIsICI6ZmluYWxseSIsIG9yCiI6ZW5kdHJ5IiBjb21tYW5kIGlzIHJlYWNoZWQgLSB3aGF0ZXZlciBpcyBmaXJzdC4gIFRoZW4sIHRoZSBmaW5hbGx5IGNsYXVzZQooaWYgcHJlc2VudCkgaXMgZXhlY3V0ZWQuICBXaGVuIHRoZSAiOmVuZHRyeSIgaXMgcmVhY2hlZCwgdGhlIHNjcmlwdCBleGVjdXRpb24KY29udGludWVzIGluIHRoZSBmb2xsb3dpbmcgbGluZSBhcyB1c3VhbC4KICAgV2hlbiBhbiBleGNlcHRpb24gdGhhdCBkb2VzIG5vdCBtYXRjaCBhbnkgb2YgdGhlIHBhdHRlcm5zIHNwZWNpZmllZCBieSB0aGUKIjpjYXRjaCIgY29tbWFuZHMgaXMgdGhyb3duIGluIHRoZSB0cnkgYmxvY2ssIHRoZSBleGNlcHRpb24gaXMgbm90IGNhdWdodCBieQp0aGF0IHRyeSBjb25kaXRpb25hbCBhbmQgbm9uZSBvZiB0aGUgY2F0Y2ggY2xhdXNlcyBpcyBleGVjdXRlZC4gIE9ubHkgdGhlCmZpbmFsbHkgY2xhdXNlLCBpZiBwcmVzZW50LCBpcyB0YWtlbi4gIFRoZSBleGNlcHRpb24gcGVuZHMgZHVyaW5nIGV4ZWN1dGlvbiBvZgp0aGUgZmluYWxseSBjbGF1c2UuICBJdCBpcyByZXN1bWVkIGF0IHRoZSAiOmVuZHRyeSIsIHNvIHRoYXQgY29tbWFuZHMgYWZ0ZXIKdGhlICI6ZW5kdHJ5IiBhcmUgbm90IGV4ZWN1dGVkIGFuZCB0aGUgZXhjZXB0aW9uIG1pZ2h0IGJlIGNhdWdodCBlbHNld2hlcmUsCnNlZSB8dHJ5LW5lc3Rpbmd8LgogICBXaGVuIGR1cmluZyBleGVjdXRpb24gb2YgYSBjYXRjaCBjbGF1c2UgYW5vdGhlciBleGNlcHRpb24gaXMgdGhyb3duLCB0aGUKcmVtYWluaW5nIGxpbmVzIGluIHRoYXQgY2F0Y2ggY2xhdXNlIGFyZSBub3QgZXhlY3V0ZWQuCVRoZSBuZXcgZXhjZXB0aW9uIGlzCm5vdCBtYXRjaGVkIGFnYWluc3QgdGhlIHBhdHRlcm5zIGluIGFueSBvZiB0aGUgIjpjYXRjaCIgY29tbWFuZHMgb2YgdGhlIHNhbWUKdHJ5IGNvbmRpdGlvbmFsIGFuZCBub25lIG9mIGl0cyBjYXRjaCBjbGF1c2VzIGlzIHRha2VuLiAgSWYgdGhlcmUgaXMsIGhvd2V2ZXIsCmEgZmluYWxseSBjbGF1c2UsIGl0IGlzIGV4ZWN1dGVkLCBhbmQgdGhlIGV4Y2VwdGlvbiBwZW5kcyBkdXJpbmcgaXRzCmV4ZWN1dGlvbi4gIFRoZSBjb21tYW5kcyBmb2xsb3dpbmcgdGhlICI6ZW5kdHJ5IiBhcmUgbm90IGV4ZWN1dGVkLiAgVGhlIG5ldwpleGNlcHRpb24gbWlnaHQsIGhvd2V2ZXIsIGJlIGNhdWdodCBlbHNld2hlcmUsIHNlZSB8dHJ5LW5lc3Rpbmd8LgogICBXaGVuIGR1cmluZyBleGVjdXRpb24gb2YgdGhlIGZpbmFsbHkgY2xhdXNlIChpZiBwcmVzZW50KSBhbiBleGNlcHRpb24gaXMKdGhyb3duLCB0aGUgcmVtYWluaW5nIGxpbmVzIGluIHRoZSBmaW5hbGx5IGNsYXVzZSBhcmUgc2tpcHBlZC4JSWYgdGhlIGZpbmFsbHkKY2xhdXNlIGhhcyBiZWVuIHRha2VuIGJlY2F1c2Ugb2YgYW4gZXhjZXB0aW9uIGZyb20gdGhlIHRyeSBibG9jayBvciBvbmUgb2YgdGhlCmNhdGNoIGNsYXVzZXMsIHRoZSBvcmlnaW5hbCAocGVuZGluZykgZXhjZXB0aW9uIGlzIGRpc2NhcmRlZC4gIFRoZSBjb21tYW5kcwpmb2xsb3dpbmcgdGhlICI6ZW5kdHJ5IiBhcmUgbm90IGV4ZWN1dGVkLCBhbmQgdGhlIGV4Y2VwdGlvbiBmcm9tIHRoZSBmaW5hbGx5CmNsYXVzZSBpcyBwcm9wYWdhdGVkIGFuZCBjYW4gYmUgY2F1Z2h0IGVsc2V3aGVyZSwgc2VlIHx0cnktbmVzdGluZ3wuCgpUaGUgZmluYWxseSBjbGF1c2UgaXMgYWxzbyBleGVjdXRlZCwgd2hlbiBhICI6YnJlYWsiIG9yICI6Y29udGludWUiIGZvcgphICI6d2hpbGUiIGxvb3AgZW5jbG9zaW5nIHRoZSBjb21wbGV0ZSB0cnkgY29uZGl0aW9uYWwgaXMgZXhlY3V0ZWQgZnJvbSB0aGUKdHJ5IGJsb2NrIG9yIGEgY2F0Y2ggY2xhdXNlLiAgT3Igd2hlbiBhICI6cmV0dXJuIiBvciAiOmZpbmlzaCIgaXMgZXhlY3V0ZWQKZnJvbSB0aGUgdHJ5IGJsb2NrIG9yIGEgY2F0Y2ggY2xhdXNlIG9mIGEgdHJ5IGNvbmRpdGlvbmFsIGluIGEgZnVuY3Rpb24gb3IKc291cmNlZCBzY3JpcHQsIHJlc3BlY3RpdmVseS4gIFRoZSAiOmJyZWFrIiwgIjpjb250aW51ZSIsICI6cmV0dXJuIiwgb3IKIjpmaW5pc2giIHBlbmRzIGR1cmluZyBleGVjdXRpb24gb2YgdGhlIGZpbmFsbHkgY2xhdXNlIGFuZCBpcyByZXN1bWVkIHdoZW4gdGhlCiI6ZW5kdHJ5IiBpcyByZWFjaGVkLiAgSXQgaXMsIGhvd2V2ZXIsIGRpc2NhcmRlZCB3aGVuIGFuIGV4Y2VwdGlvbiBpcyB0aHJvd24KZnJvbSB0aGUgZmluYWxseSBjbGF1c2UuCiAgIFdoZW4gYSAiOmJyZWFrIiBvciAiOmNvbnRpbnVlIiBmb3IgYSAiOndoaWxlIiBsb29wIGVuY2xvc2luZyB0aGUgY29tcGxldGUKdHJ5IGNvbmRpdGlvbmFsIG9yIHdoZW4gYSAiOnJldHVybiIgb3IgIjpmaW5pc2giIGlzIGVuY291bnRlcmVkIGluIHRoZSBmaW5hbGx5CmNsYXVzZSwgdGhlIHJlc3Qgb2YgdGhlIGZpbmFsbHkgY2xhdXNlIGlzIHNraXBwZWQsIGFuZCB0aGUgIjpicmVhayIsCiI6Y29udGludWUiLCAiOnJldHVybiIgb3IgIjpmaW5pc2giIGlzIGV4ZWN1dGVkIGFzIHVzdWFsLiAgSWYgdGhlIGZpbmFsbHkKY2xhdXNlIGhhcyBiZWVuIHRha2VuIGJlY2F1c2Ugb2YgYW4gZXhjZXB0aW9uIG9yIGFuIGVhcmxpZXIgIjpicmVhayIsCiI6Y29udGludWUiLCAiOnJldHVybiIsIG9yICI6ZmluaXNoIiBmcm9tIHRoZSB0cnkgYmxvY2sgb3IgYSBjYXRjaCBjbGF1c2UsCnRoaXMgcGVuZGluZyBleGNlcHRpb24gb3IgY29tbWFuZCBpcyBkaXNjYXJkZWQuCgpGb3IgZXhhbXBsZXMgc2VlIHx0aHJvdy1jYXRjaHwgYW5kIHx0cnktZmluYWxseXwuCgoKTkVTVElORwlPRiBUUlkgQ09ORElUSU9OQUxTCQkJCSp0cnktbmVzdGluZyoKClRyeSBjb25kaXRpb25hbHMgY2FuIGJlIG5lc3RlZCBhcmJpdHJhcmlseS4gIFRoYXQgaXMsIGEgY29tcGxldGUgdHJ5CmNvbmRpdGlvbmFsIGNhbiBiZSBwdXQgaW50byB0aGUgdHJ5IGJsb2NrLCBhIGNhdGNoIGNsYXVzZSwgb3IgdGhlIGZpbmFsbHkKY2xhdXNlIG9mIGFub3RoZXIgdHJ5IGNvbmRpdGlvbmFsLiAgSWYgdGhlIGlubmVyIHRyeSBjb25kaXRpb25hbCBkb2VzIG5vdApjYXRjaCBhbiBleGNlcHRpb24gdGhyb3duIGluIGl0cyB0cnkgYmxvY2sgb3IgdGhyb3dzIGEgbmV3IGV4Y2VwdGlvbiBmcm9tIG9uZQpvZiBpdHMgY2F0Y2ggY2xhdXNlcyBvciBpdHMgZmluYWxseSBjbGF1c2UsIHRoZSBvdXRlciB0cnkgY29uZGl0aW9uYWwgaXMKY2hlY2tlZCBhY2NvcmRpbmcgdG8gdGhlIHJ1bGVzIGFib3ZlLiAgSWYgdGhlIGlubmVyIHRyeSBjb25kaXRpb25hbCBpcyBpbiB0aGUKdHJ5IGJsb2NrIG9mIHRoZSBvdXRlciB0cnkgY29uZGl0aW9uYWwsIGl0cyBjYXRjaCBjbGF1c2VzIGFyZSBjaGVja2VkLCBidXQKb3RoZXJ3aXNlIG9ubHkgdGhlIGZpbmFsbHkgY2xhdXNlIGlzIGV4ZWN1dGVkLglJdCBkb2VzIG5vdCBtYXR0ZXIgZm9yCm5lc3RpbmcsIHdoZXRoZXIgdGhlIGlubmVyIHRyeSBjb25kaXRpb25hbCBpcyBkaXJlY3RseSBjb250YWluZWQgaW4gdGhlIG91dGVyCm9uZSwgb3Igd2hldGhlciB0aGUgb3V0ZXIgb25lIHNvdXJjZXMgYSBzY3JpcHQgb3IgY2FsbHMgYSBmdW5jdGlvbiBjb250YWluaW5nCnRoZSBpbm5lciB0cnkgY29uZGl0aW9uYWwuCgpXaGVuIG5vbmUgb2YgdGhlIGFjdGl2ZSB0cnkgY29uZGl0aW9uYWxzIGNhdGNoZXMgYW4gZXhjZXB0aW9uLCBqdXN0IHRoZWlyCmZpbmFsbHkgY2xhdXNlcyBhcmUgZXhlY3V0ZWQuICBUaGVyZWFmdGVyLCB0aGUgc2NyaXB0IHByb2Nlc3NpbmcgdGVybWluYXRlcy4KQW4gZXJyb3IgbWVzc2FnZSBpcyBkaXNwbGF5ZWQgaW4gY2FzZSBvZiBhbiB1bmNhdWdodCBleGNlcHRpb24gZXhwbGljaXRseQp0aHJvd24gYnkgYSAiOnRocm93IiBjb21tYW5kLiAgRm9yIHVuY2F1Z2h0IGVycm9yIGFuZCBpbnRlcnJ1cHQgZXhjZXB0aW9ucwppbXBsaWNpdGx5IHJhaXNlZCBieSBWaW0sIHRoZSBlcnJvciBtZXNzYWdlKHMpIG9yIGludGVycnVwdCBtZXNzYWdlIGFyZSBzaG93bgphcyB1c3VhbC4KCkZvciBleGFtcGxlcyBzZWUgfHRocm93LWNhdGNofC4KCgpFWEFNSU5JTkcgRVhDRVBUSU9OIEhBTkRMSU5HIENPREUJCQkqZXhjZXB0LWV4YW1pbmUqCgpFeGNlcHRpb24gaGFuZGxpbmcgY29kZSBjYW4gZ2V0IHRyaWNreS4gIElmIHlvdSBhcmUgaW4gZG91YnQgd2hhdCBoYXBwZW5zLCBzZXQKJ3ZlcmJvc2UnIHRvIDEzIG9yIHVzZSB0aGUgIjoxM3ZlcmJvc2UiIGNvbW1hbmQgbW9kaWZpZXIgd2hlbiBzb3VyY2luZyB5b3VyCnNjcmlwdCBmaWxlLiAgVGhlbiB5b3Ugc2VlIHdoZW4gYW4gZXhjZXB0aW9uIGlzIHRocm93biwgZGlzY2FyZGVkLCBjYXVnaHQsIG9yCmZpbmlzaGVkLiAgV2hlbiB1c2luZyBhIHZlcmJvc2l0eSBsZXZlbCBvZiBhdCBsZWFzdCAxNCwgdGhpbmdzIHBlbmRpbmcgaW4KYSBmaW5hbGx5IGNsYXVzZSBhcmUgYWxzbyBzaG93bi4gIFRoaXMgaW5mb3JtYXRpb24gaXMgYWxzbyBnaXZlbiBpbiBkZWJ1ZyBtb2RlCihzZWUgfGRlYnVnLXNjcmlwdHN8KS4KCgpUSFJPV0lORyBBTkQgQ0FUQ0hJTkcgRVhDRVBUSU9OUwkJCSp0aHJvdy1jYXRjaCoKCllvdSBjYW4gdGhyb3cgYW55IG51bWJlciBvciBzdHJpbmcgYXMgYW4gZXhjZXB0aW9uLiAgVXNlIHRoZSB8OnRocm93fCBjb21tYW5kCmFuZCBwYXNzIHRoZSB2YWx1ZSB0byBiZSB0aHJvd24gYXMgYXJndW1lbnQ6ID4KCTp0aHJvdyA0NzExCgk6dGhyb3cgInN0cmluZyIKPAkJCQkJCQkqdGhyb3ctZXhwcmVzc2lvbioKWW91IGNhbiBhbHNvIHNwZWNpZnkgYW4gZXhwcmVzc2lvbiBhcmd1bWVudC4gIFRoZSBleHByZXNzaW9uIGlzIHRoZW4gZXZhbHVhdGVkCmZpcnN0LCBhbmQgdGhlIHJlc3VsdCBpcyB0aHJvd246ID4KCTp0aHJvdyA0NzA1ICsgc3RybGVuKCJzdHJpbmciKQoJOnRocm93IHN0cnBhcnQoInN0cmluZ3MiLCAwLCA2KQoKQW4gZXhjZXB0aW9uIG1pZ2h0IGJlIHRocm93biBkdXJpbmcgZXZhbHVhdGlvbiBvZiB0aGUgYXJndW1lbnQgb2YgdGhlICI6dGhyb3ciCmNvbW1hbmQuICBVbmxlc3MgaXQgaXMgY2F1Z2h0IHRoZXJlLCB0aGUgZXhwcmVzc2lvbiBldmFsdWF0aW9uIGlzIGFiYW5kb25lZC4KVGhlICI6dGhyb3ciIGNvbW1hbmQgdGhlbiBkb2VzIG5vdCB0aHJvdyBhIG5ldyBleGNlcHRpb24uCiAgIEV4YW1wbGU6ID4KCgk6ZnVuY3Rpb24hIEZvbyhhcmcpCgk6ICB0cnkKCTogICAgdGhyb3cgYTphcmcKCTogIGNhdGNoIC9mb28vCgk6ICBlbmR0cnkKCTogIHJldHVybiAxCgk6ZW5kZnVuY3Rpb24KCToKCTpmdW5jdGlvbiEgQmFyKCkKCTogIGVjaG8gImluIEJhciIKCTogIHJldHVybiA0NzEwCgk6ZW5kZnVuY3Rpb24KCToKCTp0aHJvdyBGb28oImFycmdoIikgKyBCYXIoKQoKVGhpcyB0aHJvd3MgImFycmdoIiwgYW5kICJpbiBCYXIiIGlzIG5vdCBkaXNwbGF5ZWQgc2luY2UgQmFyKCkgaXMgbm90CmV4ZWN1dGVkLiA+Cgk6dGhyb3cgRm9vKCJmb28iKSArIEJhcigpCmhvd2V2ZXIgZGlzcGxheXMgImluIEJhciIgYW5kIHRocm93cyA0NzExLgoKQW55IG90aGVyIGNvbW1hbmQgdGhhdCB0YWtlcyBhbiBleHByZXNzaW9uIGFzIGFyZ3VtZW50IG1pZ2h0IGFsc28gYmUKYWJhbmRvbmVkIGJ5IGFuICh1bmNhdWdodCkgZXhjZXB0aW9uIGR1cmluZyB0aGUgZXhwcmVzc2lvbiBldmFsdWF0aW9uLglUaGUKZXhjZXB0aW9uIGlzIHRoZW4gcHJvcGFnYXRlZCB0byB0aGUgY2FsbGVyIG9mIHRoZSBjb21tYW5kLgogICBFeGFtcGxlOiA+CgoJOmlmIEZvbygiYXJyZ2giKQoJOiAgZWNobyAidGhlbiIKCTplbHNlCgk6ICBlY2hvICJlbHNlIgoJOmVuZGlmCgpIZXJlIG5laXRoZXIgb2YgInRoZW4iIG9yICJlbHNlIiBpcyBkaXNwbGF5ZWQuCgoJCQkJCQkJKmNhdGNoLW9yZGVyKgpFeGNlcHRpb25zIGNhbiBiZSBjYXVnaHQgYnkgYSB0cnkgY29uZGl0aW9uYWwgd2l0aCBvbmUgb3IgbW9yZSB8OmNhdGNofApjb21tYW5kcywgc2VlIHx0cnktY29uZGl0aW9uYWxzfC4gICBUaGUgdmFsdWVzIHRvIGJlIGNhdWdodCBieSBlYWNoICI6Y2F0Y2giCmNvbW1hbmQgY2FuIGJlIHNwZWNpZmllZCBhcyBhIHBhdHRlcm4gYXJndW1lbnQuICBUaGUgc3Vic2VxdWVudCBjYXRjaCBjbGF1c2UKZ2V0cyBleGVjdXRlZCB3aGVuIGEgbWF0Y2hpbmcgZXhjZXB0aW9uIGlzIGNhdWdodC4KICAgRXhhbXBsZTogPgoKCTpmdW5jdGlvbiEgRm9vKHZhbHVlKQoJOiAgdHJ5Cgk6ICAgIHRocm93IGE6dmFsdWUKCTogIGNhdGNoIC9eXGRcKyQvCgk6ICAgIGVjaG8gIk51bWJlciB0aHJvd24iCgk6ICBjYXRjaCAvLiovCgk6ICAgIGVjaG8gIlN0cmluZyB0aHJvd24iCgk6ICBlbmR0cnkKCTplbmRmdW5jdGlvbgoJOgoJOmNhbGwgRm9vKDB4MTI2NykKCTpjYWxsIEZvbygnc3RyaW5nJykKClRoZSBmaXJzdCBjYWxsIHRvIEZvbygpIGRpc3BsYXlzICJOdW1iZXIgdGhyb3duIiwgdGhlIHNlY29uZCAiU3RyaW5nIHRocm93biIuCkFuIGV4Y2VwdGlvbiBpcyBtYXRjaGVkIGFnYWluc3QgdGhlICI6Y2F0Y2giIGNvbW1hbmRzIGluIHRoZSBvcmRlciB0aGV5IGFyZQpzcGVjaWZpZWQuICBPbmx5IHRoZSBmaXJzdCBtYXRjaCBjb3VudHMuICBTbyB5b3Ugc2hvdWxkIHBsYWNlIHRoZSBtb3JlCnNwZWNpZmljICI6Y2F0Y2giIGZpcnN0LiAgVGhlIGZvbGxvd2luZyBvcmRlciBkb2VzIG5vdCBtYWtlIHNlbnNlOiA+CgoJOiAgY2F0Y2ggLy4qLwoJOiAgICBlY2hvICJTdHJpbmcgdGhyb3duIgoJOiAgY2F0Y2ggL15cZFwrJC8KCTogICAgZWNobyAiTnVtYmVyIHRocm93biIKClRoZSBmaXJzdCAiOmNhdGNoIiBoZXJlIG1hdGNoZXMgYWx3YXlzLCBzbyB0aGF0IHRoZSBzZWNvbmQgY2F0Y2ggY2xhdXNlIGlzCm5ldmVyIHRha2VuLgoKCQkJCQkJCSp0aHJvdy12YXJpYWJsZXMqCklmIHlvdSBjYXRjaCBhbiBleGNlcHRpb24gYnkgYSBnZW5lcmFsIHBhdHRlcm4sIHlvdSBtYXkgYWNjZXNzIHRoZSBleGFjdCB2YWx1ZQppbiB0aGUgdmFyaWFibGUgfHY6ZXhjZXB0aW9ufDogPgoKCTogIGNhdGNoIC9eXGRcKyQvCgk6ICAgIGVjaG8gIk51bWJlciB0aHJvd24uICBWYWx1ZSBpcyIgdjpleGNlcHRpb24KCllvdSBtYXkgYWxzbyBiZSBpbnRlcmVzdGVkIHdoZXJlIGFuIGV4Y2VwdGlvbiB3YXMgdGhyb3duLiAgVGhpcyBpcyBzdG9yZWQgaW4KfHY6dGhyb3dwb2ludHwuICBOb3RlIHRoYXQgInY6ZXhjZXB0aW9uIiBhbmQgInY6dGhyb3dwb2ludCIgYXJlIHZhbGlkIGZvciB0aGUKZXhjZXB0aW9uIG1vc3QgcmVjZW50bHkgY2F1Z2h0IGFzIGxvbmcgaXQgaXMgbm90IGZpbmlzaGVkLgogICBFeGFtcGxlOiA+CgoJOmZ1bmN0aW9uISBDYXVnaHQoKQoJOiAgaWYgdjpleGNlcHRpb24gIT0gIiIKCTogICAgZWNobyAnQ2F1Z2h0ICInIC4gdjpleGNlcHRpb24gLiAnIiBpbiAnIC4gdjp0aHJvd3BvaW50Cgk6ICBlbHNlCgk6ICAgIGVjaG8gJ05vdGhpbmcgY2F1Z2h0JwoJOiAgZW5kaWYKCTplbmRmdW5jdGlvbgoJOgoJOmZ1bmN0aW9uISBGb28oKQoJOiAgdHJ5Cgk6ICAgIHRyeQoJOiAgICAgIHRyeQoJOgkgdGhyb3cgNDcxMQoJOiAgICAgIGZpbmFsbHkKCToJIGNhbGwgQ2F1Z2h0KCkKCTogICAgICBlbmR0cnkKCTogICAgY2F0Y2ggLy4qLwoJOiAgICAgIGNhbGwgQ2F1Z2h0KCkKCTogICAgICB0aHJvdyAib29wcyIKCTogICAgZW5kdHJ5Cgk6ICBjYXRjaCAvLiovCgk6ICAgIGNhbGwgQ2F1Z2h0KCkKCTogIGZpbmFsbHkKCTogICAgY2FsbCBDYXVnaHQoKQoJOiAgZW5kdHJ5Cgk6ZW5kZnVuY3Rpb24KCToKCTpjYWxsIEZvbygpCgpUaGlzIGRpc3BsYXlzID4KCglOb3RoaW5nIGNhdWdodAoJQ2F1Z2h0ICI0NzExIiBpbiBmdW5jdGlvbiBGb28sIGxpbmUgNAoJQ2F1Z2h0ICJvb3BzIiBpbiBmdW5jdGlvbiBGb28sIGxpbmUgMTAKCU5vdGhpbmcgY2F1Z2h0CgpBIHByYWN0aWNhbCBleGFtcGxlOiAgVGhlIGZvbGxvd2luZyBjb21tYW5kICI6TGluZU51bWJlciIgZGlzcGxheXMgdGhlIGxpbmUKbnVtYmVyIGluIHRoZSBzY3JpcHQgb3IgZnVuY3Rpb24gd2hlcmUgaXQgaGFzIGJlZW4gdXNlZDogPgoKCTpmdW5jdGlvbiEgTGluZU51bWJlcigpCgk6ICAgIHJldHVybiBzdWJzdGl0dXRlKHY6dGhyb3dwb2ludCwgJy4qXERcKFxkXCtcKS4qJywgJ1wxJywgIiIpCgk6ZW5kZnVuY3Rpb24KCTpjb21tYW5kISBMaW5lTnVtYmVyIHRyeSB8IHRocm93ICIiIHwgY2F0Y2ggfCBlY2hvIExpbmVOdW1iZXIoKSB8IGVuZHRyeQo8CgkJCQkJCQkqdHJ5LW5lc3RlZCoKQW4gZXhjZXB0aW9uIHRoYXQgaXMgbm90IGNhdWdodCBieSBhIHRyeSBjb25kaXRpb25hbCBjYW4gYmUgY2F1Z2h0IGJ5CmEgc3Vycm91bmRpbmcgdHJ5IGNvbmRpdGlvbmFsOiA+CgoJOnRyeQoJOiAgdHJ5Cgk6ICAgIHRocm93ICJmb28iCgk6ICBjYXRjaCAvZm9vYmFyLwoJOiAgICBlY2hvICJmb29iYXIiCgk6ICBmaW5hbGx5Cgk6ICAgIGVjaG8gImlubmVyIGZpbmFsbHkiCgk6ICBlbmR0cnkKCTpjYXRjaCAvZm9vLwoJOiAgZWNobyAiZm9vIgoJOmVuZHRyeQoKVGhlIGlubmVyIHRyeSBjb25kaXRpb25hbCBkb2VzIG5vdCBjYXRjaCB0aGUgZXhjZXB0aW9uLCBqdXN0IGl0cyBmaW5hbGx5CmNsYXVzZSBpcyBleGVjdXRlZC4gIFRoZSBleGNlcHRpb24gaXMgdGhlbiBjYXVnaHQgYnkgdGhlIG91dGVyIHRyeQpjb25kaXRpb25hbC4gIFRoZSBleGFtcGxlIGRpc3BsYXlzICJpbm5lciBmaW5hbGx5IiBhbmQgdGhlbiAiZm9vIi4KCgkJCQkJCQkqdGhyb3ctZnJvbS1jYXRjaCoKWW91IGNhbiBjYXRjaCBhbiBleGNlcHRpb24gYW5kIHRocm93IGEgbmV3IG9uZSB0byBiZSBjYXVnaHQgZWxzZXdoZXJlIGZyb20gdGhlCmNhdGNoIGNsYXVzZTogPgoKCTpmdW5jdGlvbiEgRm9vKCkKCTogIHRocm93ICJmb28iCgk6ZW5kZnVuY3Rpb24KCToKCTpmdW5jdGlvbiEgQmFyKCkKCTogIHRyeQoJOiAgICBjYWxsIEZvbygpCgk6ICBjYXRjaCAvZm9vLwoJOiAgICBlY2hvICJDYXVnaHQgZm9vLCB0aHJvdyBiYXIiCgk6ICAgIHRocm93ICJiYXIiCgk6ICBlbmR0cnkKCTplbmRmdW5jdGlvbgoJOgoJOnRyeQoJOiAgY2FsbCBCYXIoKQoJOmNhdGNoIC8uKi8KCTogIGVjaG8gIkNhdWdodCIgdjpleGNlcHRpb24KCTplbmR0cnkKClRoaXMgZGlzcGxheXMgIkNhdWdodCBmb28sIHRocm93IGJhciIgYW5kIHRoZW4gIkNhdWdodCBiYXIiLgoKCQkJCQkJCSpyZXRocm93KgpUaGVyZSBpcyBubyByZWFsIHJldGhyb3cgaW4gdGhlIFZpbSBzY3JpcHQgbGFuZ3VhZ2UsIGJ1dCB5b3UgbWF5IHRocm93CiJ2OmV4Y2VwdGlvbiIgaW5zdGVhZDogPgoKCTpmdW5jdGlvbiEgQmFyKCkKCTogIHRyeQoJOiAgICBjYWxsIEZvbygpCgk6ICBjYXRjaCAvLiovCgk6ICAgIGVjaG8gIlJldGhyb3ciIHY6ZXhjZXB0aW9uCgk6ICAgIHRocm93IHY6ZXhjZXB0aW9uCgk6ICBlbmR0cnkKCTplbmRmdW5jdGlvbgo8CQkJCQkJCSp0cnktZWNob2VycioKTm90ZSB0aGF0IHRoaXMgbWV0aG9kIGNhbm5vdCBiZSB1c2VkIHRvICJyZXRocm93IiBWaW0gZXJyb3Igb3IgaW50ZXJydXB0CmV4Y2VwdGlvbnMsIGJlY2F1c2UgaXQgaXMgbm90IHBvc3NpYmxlIHRvIGZha2UgVmltIGludGVybmFsIGV4Y2VwdGlvbnMuClRyeWluZyBzbyBjYXVzZXMgYW4gZXJyb3IgZXhjZXB0aW9uLiAgWW91IHNob3VsZCB0aHJvdyB5b3VyIG93biBleGNlcHRpb24KZGVub3RpbmcgdGhlIHNpdHVhdGlvbi4gIElmIHlvdSB3YW50IHRvIGNhdXNlIGEgVmltIGVycm9yIGV4Y2VwdGlvbiBjb250YWluaW5nCnRoZSBvcmlnaW5hbCBlcnJvciBleGNlcHRpb24gdmFsdWUsIHlvdSBjYW4gdXNlIHRoZSB8OmVjaG9lcnJ8IGNvbW1hbmQ6ID4KCgk6dHJ5Cgk6ICB0cnkKCTogICAgYXNkZgoJOiAgY2F0Y2ggLy4qLwoJOiAgICBlY2hvZXJyIHY6ZXhjZXB0aW9uCgk6ICBlbmR0cnkKCTpjYXRjaCAvLiovCgk6ICBlY2hvIHY6ZXhjZXB0aW9uCgk6ZW5kdHJ5CgpUaGlzIGNvZGUgZGlzcGxheXMKCglWaW0oZWNob2Vycik6VmltOkU0OTI6IE5vdCBhbiBlZGl0b3IgY29tbWFuZDoJYXNkZiB+CgoKQ0xFQU5VUCBDT0RFCQkJCQkJKnRyeS1maW5hbGx5KgoKU2NyaXB0cyBvZnRlbiBjaGFuZ2UgZ2xvYmFsIHNldHRpbmdzIGFuZCByZXN0b3JlIHRoZW0gYXQgdGhlaXIgZW5kLiAgSWYgdGhlCnVzZXIgaG93ZXZlciBpbnRlcnJ1cHRzIHRoZSBzY3JpcHQgYnkgcHJlc3NpbmcgQ1RSTC1DLCB0aGUgc2V0dGluZ3MgcmVtYWluIGluCmFuIGluY29uc2lzdGVudCBzdGF0ZS4JVGhlIHNhbWUgbWF5IGhhcHBlbiB0byB5b3UgaW4gdGhlIGRldmVsb3BtZW50IHBoYXNlIG9mCmEgc2NyaXB0IHdoZW4gYW4gZXJyb3Igb2NjdXJzIG9yIHlvdSBleHBsaWNpdGx5IHRocm93IGFuIGV4Y2VwdGlvbiB3aXRob3V0CmNhdGNoaW5nIGl0LiAgWW91IGNhbiBzb2x2ZSB0aGVzZSBwcm9ibGVtcyBieSB1c2luZyBhIHRyeSBjb25kaXRpb25hbCB3aXRoCmEgZmluYWxseSBjbGF1c2UgZm9yIHJlc3RvcmluZyB0aGUgc2V0dGluZ3MuICBJdHMgZXhlY3V0aW9uIGlzIGd1YXJhbnRlZWQgb24Kbm9ybWFsIGNvbnRyb2wgZmxvdywgb24gZXJyb3IsIG9uIGFuIGV4cGxpY2l0ICI6dGhyb3ciLCBhbmQgb24gaW50ZXJydXB0LgooTm90ZSB0aGF0IGVycm9ycyBhbmQgaW50ZXJydXB0cyBmcm9tIGluc2lkZSB0aGUgdHJ5IGNvbmRpdGlvbmFsIGFyZSBjb252ZXJ0ZWQKdG8gZXhjZXB0aW9ucy4JV2hlbiBub3QgY2F1Z2h0LCB0aGV5IHRlcm1pbmF0ZSB0aGUgc2NyaXB0IGFmdGVyIHRoZSBmaW5hbGx5CmNsYXVzZSBoYXMgYmVlbiBleGVjdXRlZC4pCkV4YW1wbGU6ID4KCgk6dHJ5Cgk6ICBsZXQgczpzYXZlZF90cyA9ICZ0cwoJOiAgc2V0IHRzPTE3Cgk6Cgk6ICAiIERvIHRoZSBoYXJkIHdvcmsgaGVyZS4KCToKCTpmaW5hbGx5Cgk6ICBsZXQgJnRzID0gczpzYXZlZF90cwoJOiAgdW5sZXQgczpzYXZlZF90cwoJOmVuZHRyeQoKVGhpcyBtZXRob2Qgc2hvdWxkIGJlIHVzZWQgbG9jYWxseSB3aGVuZXZlciBhIGZ1bmN0aW9uIG9yIHBhcnQgb2YgYSBzY3JpcHQKY2hhbmdlcyBnbG9iYWwgc2V0dGluZ3Mgd2hpY2ggbmVlZCB0byBiZSByZXN0b3JlZCBvbiBmYWlsdXJlIG9yIG5vcm1hbCBleGl0IG9mCnRoYXQgZnVuY3Rpb24gb3Igc2NyaXB0IHBhcnQuCgoJCQkJCQkJKmJyZWFrLWZpbmFsbHkqCkNsZWFudXAgY29kZSB3b3JrcyBhbHNvIHdoZW4gdGhlIHRyeSBibG9jayBvciBhIGNhdGNoIGNsYXVzZSBpcyBsZWZ0IGJ5CmEgIjpjb250aW51ZSIsICI6YnJlYWsiLCAiOnJldHVybiIsIG9yICI6ZmluaXNoIi4KICAgRXhhbXBsZTogPgoKCTpsZXQgZmlyc3QgPSAxCgk6d2hpbGUgMQoJOiAgdHJ5Cgk6ICAgIGlmIGZpcnN0Cgk6ICAgICAgZWNobyAiZmlyc3QiCgk6ICAgICAgbGV0IGZpcnN0ID0gMAoJOiAgICAgIGNvbnRpbnVlCgk6ICAgIGVsc2UKCTogICAgICB0aHJvdyAic2Vjb25kIgoJOiAgICBlbmRpZgoJOiAgY2F0Y2ggLy4qLwoJOiAgICBlY2hvIHY6ZXhjZXB0aW9uCgk6ICAgIGJyZWFrCgk6ICBmaW5hbGx5Cgk6ICAgIGVjaG8gImNsZWFudXAiCgk6ICBlbmR0cnkKCTogIGVjaG8gInN0aWxsIGluIHdoaWxlIgoJOmVuZHdoaWxlCgk6ZWNobyAiZW5kIgoKVGhpcyBkaXNwbGF5cyAiZmlyc3QiLCAiY2xlYW51cCIsICJzZWNvbmQiLCAiY2xlYW51cCIsIGFuZCAiZW5kIi4gPgoKCTpmdW5jdGlvbiEgRm9vKCkKCTogIHRyeQoJOiAgICByZXR1cm4gNDcxMQoJOiAgZmluYWxseQoJOiAgICBlY2hvICJjbGVhbnVwXG4iCgk6ICBlbmR0cnkKCTogIGVjaG8gIkZvbyBzdGlsbCBhY3RpdmUiCgk6ZW5kZnVuY3Rpb24KCToKCTplY2hvIEZvbygpICJyZXR1cm5lZCBieSBGb28iCgpUaGlzIGRpc3BsYXlzICJjbGVhbnVwIiBhbmQgIjQ3MTEgcmV0dXJuZWQgYnkgRm9vIi4gIFlvdSBkb24ndCBuZWVkIHRvIGFkZCBhbgpleHRyYSAiOnJldHVybiIgaW4gdGhlIGZpbmFsbHkgY2xhdXNlLgkoQWJvdmUgYWxsLCB0aGlzIHdvdWxkIG92ZXJyaWRlIHRoZQpyZXR1cm4gdmFsdWUuKQoKCQkJCQkJCSpleGNlcHQtZnJvbS1maW5hbGx5KgpVc2luZyBlaXRoZXIgb2YgIjpjb250aW51ZSIsICI6YnJlYWsiLCAiOnJldHVybiIsICI6ZmluaXNoIiwgb3IgIjp0aHJvdyIgaW4KYSBmaW5hbGx5IGNsYXVzZSBpcyBwb3NzaWJsZSwgYnV0IG5vdCByZWNvbW1lbmRlZCBzaW5jZSBpdCBhYmFuZG9ucyB0aGUKY2xlYW51cCBhY3Rpb25zIGZvciB0aGUgdHJ5IGNvbmRpdGlvbmFsLiAgQnV0LCBvZiBjb3Vyc2UsIGludGVycnVwdCBhbmQgZXJyb3IKZXhjZXB0aW9ucyBtaWdodCBnZXQgcmFpc2VkIGZyb20gYSBmaW5hbGx5IGNsYXVzZS4KICAgRXhhbXBsZSB3aGVyZSBhbiBlcnJvciBpbiB0aGUgZmluYWxseSBjbGF1c2Ugc3RvcHMgYW4gaW50ZXJydXB0IGZyb20Kd29ya2luZyBjb3JyZWN0bHk6ID4KCgk6dHJ5Cgk6ICB0cnkKCTogICAgZWNobyAiUHJlc3MgQ1RSTC1DIGZvciBpbnRlcnJ1cHQiCgk6ICAgIHdoaWxlIDEKCTogICAgZW5kd2hpbGUKCTogIGZpbmFsbHkKCTogICAgdW5sZXQgbm92YXIKCTogIGVuZHRyeQoJOmNhdGNoIC9ub3Zhci8KCTplbmR0cnkKCTplY2hvICJTY3JpcHQgc3RpbGwgcnVubmluZyIKCTpzbGVlcCAxCgpJZiB5b3UgbmVlZCB0byBwdXQgY29tbWFuZHMgdGhhdCBjb3VsZCBmYWlsIGludG8gYSBmaW5hbGx5IGNsYXVzZSwgeW91IHNob3VsZAp0aGluayBhYm91dCBjYXRjaGluZyBvciBpZ25vcmluZyB0aGUgZXJyb3JzIGluIHRoZXNlIGNvbW1hbmRzLCBzZWUKfGNhdGNoLWVycm9yc3wgYW5kIHxpZ25vcmUtZXJyb3JzfC4KCgpDQVRDSElORyBFUlJPUlMJCQkJCQkqY2F0Y2gtZXJyb3JzKgoKSWYgeW91IHdhbnQgdG8gY2F0Y2ggc3BlY2lmaWMgZXJyb3JzLCB5b3UganVzdCBoYXZlIHRvIHB1dCB0aGUgY29kZSB0byBiZQp3YXRjaGVkIGluIGEgdHJ5IGJsb2NrIGFuZCBhZGQgYSBjYXRjaCBjbGF1c2UgZm9yIHRoZSBlcnJvciBtZXNzYWdlLiAgVGhlCnByZXNlbmNlIG9mIHRoZSB0cnkgY29uZGl0aW9uYWwgY2F1c2VzIGFsbCBlcnJvcnMgdG8gYmUgY29udmVydGVkIHRvIGFuCmV4Y2VwdGlvbi4gIE5vIG1lc3NhZ2UgaXMgZGlzcGxheWVkIGFuZCB8djplcnJtc2d8IGlzIG5vdCBzZXQgdGhlbi4gIFRvIGZpbmQKdGhlIHJpZ2h0IHBhdHRlcm4gZm9yIHRoZSAiOmNhdGNoIiBjb21tYW5kLCB5b3UgaGF2ZSB0byBrbm93IGhvdyB0aGUgZm9ybWF0IG9mCnRoZSBlcnJvciBleGNlcHRpb24gaXMuCiAgIEVycm9yIGV4Y2VwdGlvbnMgaGF2ZSB0aGUgZm9sbG93aW5nIGZvcm1hdDogPgoKCVZpbSh7Y21kbmFtZX0pOntlcnJtc2d9Cm9yID4KCVZpbTp7ZXJybXNnfQoKe2NtZG5hbWV9IGlzIHRoZSBuYW1lIG9mIHRoZSBjb21tYW5kIHRoYXQgZmFpbGVkOyB0aGUgc2Vjb25kIGZvcm0gaXMgdXNlZCB3aGVuCnRoZSBjb21tYW5kIG5hbWUgaXMgbm90IGtub3duLgl7ZXJybXNnfSBpcyB0aGUgZXJyb3IgbWVzc2FnZSB1c3VhbGx5IHByb2R1Y2VkCndoZW4gdGhlIGVycm9yIG9jY3VycyBvdXRzaWRlIHRyeSBjb25kaXRpb25hbHMuICBJdCBhbHdheXMgYmVnaW5zIHdpdGgKYSBjYXBpdGFsICJFIiwgZm9sbG93ZWQgYnkgYSB0d28gb3IgdGhyZWUtZGlnaXQgZXJyb3IgbnVtYmVyLCBhIGNvbG9uLCBhbmQKYSBzcGFjZS4KCkV4YW1wbGVzOgoKVGhlIGNvbW1hbmQgPgoJOnVubGV0IG5vdmFyCm5vcm1hbGx5IHByb2R1Y2VzIHRoZSBlcnJvciBtZXNzYWdlID4KCUUxMDg6IE5vIHN1Y2ggdmFyaWFibGU6ICJub3ZhciIKd2hpY2ggaXMgY29udmVydGVkIGluc2lkZSB0cnkgY29uZGl0aW9uYWxzIHRvIGFuIGV4Y2VwdGlvbiA+CglWaW0odW5sZXQpOkUxMDg6IE5vIHN1Y2ggdmFyaWFibGU6ICJub3ZhciIKClRoZSBjb21tYW5kID4KCTpkd2ltCm5vcm1hbGx5IHByb2R1Y2VzIHRoZSBlcnJvciBtZXNzYWdlID4KCUU0OTI6IE5vdCBhbiBlZGl0b3IgY29tbWFuZDogZHdpbQp3aGljaCBpcyBjb252ZXJ0ZWQgaW5zaWRlIHRyeSBjb25kaXRpb25hbHMgdG8gYW4gZXhjZXB0aW9uID4KCVZpbTpFNDkyOiBOb3QgYW4gZWRpdG9yIGNvbW1hbmQ6IGR3aW0KCllvdSBjYW4gY2F0Y2ggYWxsICI6dW5sZXQiIGVycm9ycyBieSBhID4KCTpjYXRjaCAvXlZpbSh1bmxldCk6LwpvciBhbGwgZXJyb3JzIGZvciBtaXNzcGVsbGVkIGNvbW1hbmQgbmFtZXMgYnkgYSA+Cgk6Y2F0Y2ggL15WaW06RTQ5MjovCgpTb21lIGVycm9yIG1lc3NhZ2VzIG1heSBiZSBwcm9kdWNlZCBieSBkaWZmZXJlbnQgY29tbWFuZHM6ID4KCTpmdW5jdGlvbiBub2Z1bmMKYW5kID4KCTpkZWxmdW5jdGlvbiBub2Z1bmMKYm90aCBwcm9kdWNlIHRoZSBlcnJvciBtZXNzYWdlID4KCUUxMjg6IEZ1bmN0aW9uIG5hbWUgbXVzdCBzdGFydCB3aXRoIGEgY2FwaXRhbDogbm9mdW5jCndoaWNoIGlzIGNvbnZlcnRlZCBpbnNpZGUgdHJ5IGNvbmRpdGlvbmFscyB0byBhbiBleGNlcHRpb24gPgoJVmltKGZ1bmN0aW9uKTpFMTI4OiBGdW5jdGlvbiBuYW1lIG11c3Qgc3RhcnQgd2l0aCBhIGNhcGl0YWw6IG5vZnVuYwpvciA+CglWaW0oZGVsZnVuY3Rpb24pOkUxMjg6IEZ1bmN0aW9uIG5hbWUgbXVzdCBzdGFydCB3aXRoIGEgY2FwaXRhbDogbm9mdW5jCnJlc3BlY3RpdmVseS4gIFlvdSBjYW4gY2F0Y2ggdGhlIGVycm9yIGJ5IGl0cyBudW1iZXIgaW5kZXBlbmRlbnRseSBvbiB0aGUKY29tbWFuZCB0aGF0IGNhdXNlZCBpdCBpZiB5b3UgdXNlIHRoZSBmb2xsb3dpbmcgcGF0dGVybjogPgoJOmNhdGNoIC9eVmltKFxhXCspOkUxMjg6LwoKU29tZSBjb21tYW5kcyBsaWtlID4KCTpsZXQgeCA9IG5vdmFyCnByb2R1Y2UgbXVsdGlwbGUgZXJyb3IgbWVzc2FnZXMsIGhlcmU6ID4KCUUxMjE6IFVuZGVmaW5lZCB2YXJpYWJsZTogbm92YXIKCUUxNTogSW52YWxpZCBleHByZXNzaW9uOiAgbm92YXIKT25seSB0aGUgZmlyc3QgaXMgdXNlZCBmb3IgdGhlIGV4Y2VwdGlvbiB2YWx1ZSwgc2luY2UgaXQgaXMgdGhlIG1vc3Qgc3BlY2lmaWMKb25lIChzZWUgfGV4Y2VwdC1zZXZlcmFsLWVycm9yc3wpLiAgU28geW91IGNhbiBjYXRjaCBpdCBieSA+Cgk6Y2F0Y2ggL15WaW0oXGFcKyk6RTEyMTovCgpZb3UgY2FuIGNhdGNoIGFsbCBlcnJvcnMgcmVsYXRlZCB0byB0aGUgbmFtZSAibm9mdW5jIiBieSA+Cgk6Y2F0Y2ggL1w8bm9mdW5jXD4vCgpZb3UgY2FuIGNhdGNoIGFsbCBWaW0gZXJyb3JzIGluIHRoZSAiOndyaXRlIiBhbmQgIjpyZWFkIiBjb21tYW5kcyBieSA+Cgk6Y2F0Y2ggL15WaW0oXCh3cml0ZVx8cmVhZFwpKTpFXGRcKzovCgpZb3UgY2FuIGNhdGNoIGFsbCBWaW0gZXJyb3JzIGJ5IHRoZSBwYXR0ZXJuID4KCTpjYXRjaCAvXlZpbVwoKFxhXCspXClcPTpFXGRcKzovCjwKCQkJCQkJCSpjYXRjaC10ZXh0KgpOT1RFOiBZb3Ugc2hvdWxkIG5ldmVyIGNhdGNoIHRoZSBlcnJvciBtZXNzYWdlIHRleHQgaXRzZWxmOiA+Cgk6Y2F0Y2ggL05vIHN1Y2ggdmFyaWFibGUvCm9ubHkgd29ya3MgaW4gdGhlIGVuZ2xpc2ggbG9jYWxlLCBidXQgbm90IHdoZW4gdGhlIHVzZXIgaGFzIHNlbGVjdGVkCmEgZGlmZmVyZW50IGxhbmd1YWdlIGJ5IHRoZSB8Omxhbmd1YWdlfCBjb21tYW5kLiAgSXQgaXMgaG93ZXZlciBoZWxwZnVsIHRvCmNpdGUgdGhlIG1lc3NhZ2UgdGV4dCBpbiBhIGNvbW1lbnQ6ID4KCTpjYXRjaCAvXlZpbShcYVwrKTpFMTA4Oi8gICAiIE5vIHN1Y2ggdmFyaWFibGUKCgpJR05PUklORyBFUlJPUlMJCQkJCQkqaWdub3JlLWVycm9ycyoKCllvdSBjYW4gaWdub3JlIGVycm9ycyBpbiBhIHNwZWNpZmljIFZpbSBjb21tYW5kIGJ5IGNhdGNoaW5nIHRoZW0gbG9jYWxseTogPgoKCTp0cnkKCTogIHdyaXRlCgk6Y2F0Y2gKCTplbmR0cnkKCkJ1dCB5b3UgYXJlIHN0cm9uZ2x5IHJlY29tbWVuZGVkIE5PVCB0byB1c2UgdGhpcyBzaW1wbGUgZm9ybSwgc2luY2UgaXQgY291bGQKY2F0Y2ggbW9yZSB0aGFuIHlvdSB3YW50LiAgV2l0aCB0aGUgIjp3cml0ZSIgY29tbWFuZCwgc29tZSBhdXRvY29tbWFuZHMgY291bGQKYmUgZXhlY3V0ZWQgYW5kIGNhdXNlIGVycm9ycyBub3QgcmVsYXRlZCB0byB3cml0aW5nLCBmb3IgaW5zdGFuY2U6ID4KCgk6YXUgQnVmV3JpdGVQcmUgKiB1bmxldCBub3ZhcgoKVGhlcmUgY291bGQgZXZlbiBiZSBzdWNoIGVycm9ycyB5b3UgYXJlIG5vdCByZXNwb25zaWJsZSBmb3IgYXMgYSBzY3JpcHQKd3JpdGVyOiBhIHVzZXIgb2YgeW91ciBzY3JpcHQgbWlnaHQgaGF2ZSBkZWZpbmVkIHN1Y2ggYXV0b2NvbW1hbmRzLiAgWW91IHdvdWxkCnRoZW4gaGlkZSB0aGUgZXJyb3IgZnJvbSB0aGUgdXNlci4KICAgSXQgaXMgbXVjaCBiZXR0ZXIgdG8gdXNlID4KCgk6dHJ5Cgk6ICB3cml0ZQoJOmNhdGNoIC9eVmltKHdyaXRlKTovCgk6ZW5kdHJ5Cgp3aGljaCBvbmx5IGNhdGNoZXMgcmVhbCB3cml0ZSBlcnJvcnMuICBTbyBjYXRjaCBvbmx5IHdoYXQgeW91J2QgbGlrZSB0byBpZ25vcmUKaW50ZW50aW9uYWxseS4KCkZvciBhIHNpbmdsZSBjb21tYW5kIHRoYXQgZG9lcyBub3QgY2F1c2UgZXhlY3V0aW9uIG9mIGF1dG9jb21tYW5kcywgeW91IGNvdWxkCmV2ZW4gc3VwcHJlc3MgdGhlIGNvbnZlcnNpb24gb2YgZXJyb3JzIHRvIGV4Y2VwdGlvbnMgYnkgdGhlICI6c2lsZW50ISIKY29tbWFuZDogPgoJOnNpbGVudCEgbnVubWFwIGsKVGhpcyB3b3JrcyBhbHNvIHdoZW4gYSB0cnkgY29uZGl0aW9uYWwgaXMgYWN0aXZlLgoKCkNBVENISU5HIElOVEVSUlVQVFMJCQkJCSpjYXRjaC1pbnRlcnJ1cHQqCgpXaGVuIHRoZXJlIGFyZSBhY3RpdmUgdHJ5IGNvbmRpdGlvbmFscywgYW4gaW50ZXJydXB0IChDVFJMLUMpIGlzIGNvbnZlcnRlZCB0bwp0aGUgZXhjZXB0aW9uICJWaW06SW50ZXJydXB0Ii4JWW91IGNhbiBjYXRjaCBpdCBsaWtlIGV2ZXJ5IGV4Y2VwdGlvbi4JVGhlCnNjcmlwdCBpcyBub3QgdGVybWluYXRlZCwgdGhlbi4KICAgRXhhbXBsZTogPgoKCTpmdW5jdGlvbiEgVEFTSzEoKQoJOiAgc2xlZXAgMTAKCTplbmRmdW5jdGlvbgoKCTpmdW5jdGlvbiEgVEFTSzIoKQoJOiAgc2xlZXAgMjAKCTplbmRmdW5jdGlvbgoKCTp3aGlsZSAxCgk6ICBsZXQgY29tbWFuZCA9IGlucHV0KCJUeXBlIGEgY29tbWFuZDogIikKCTogIHRyeQoJOiAgICBpZiBjb21tYW5kID09ICIiCgk6ICAgICAgY29udGludWUKCTogICAgZWxzZWlmIGNvbW1hbmQgPT0gIkVORCIKCTogICAgICBicmVhawoJOiAgICBlbHNlaWYgY29tbWFuZCA9PSAiVEFTSzEiCgk6ICAgICAgY2FsbCBUQVNLMSgpCgk6ICAgIGVsc2VpZiBjb21tYW5kID09ICJUQVNLMiIKCTogICAgICBjYWxsIFRBU0syKCkKCTogICAgZWxzZQoJOiAgICAgIGVjaG8gIlxuSWxsZWdhbCBjb21tYW5kOiIgY29tbWFuZAoJOiAgICAgIGNvbnRpbnVlCgk6ICAgIGVuZGlmCgk6ICBjYXRjaCAvXlZpbTpJbnRlcnJ1cHQkLwoJOiAgICBlY2hvICJcbkNvbW1hbmQgaW50ZXJydXB0ZWQiCgk6ICAgICIgQ2F1Z2h0IHRoZSBpbnRlcnJ1cHQuICBDb250aW51ZSB3aXRoIG5leHQgcHJvbXB0LgoJOiAgZW5kdHJ5Cgk6ZW5kd2hpbGUKCllvdSBjYW4gaW50ZXJydXB0IGEgdGFzayBoZXJlIGJ5IHByZXNzaW5nIENUUkwtQzsgdGhlIHNjcmlwdCB0aGVuIGFza3MgZm9yCmEgbmV3IGNvbW1hbmQuCUlmIHlvdSBwcmVzcyBDVFJMLUMgYXQgdGhlIHByb21wdCwgdGhlIHNjcmlwdCBpcyB0ZXJtaW5hdGVkLgoKRm9yIHRlc3Rpbmcgd2hhdCBoYXBwZW5zIHdoZW4gQ1RSTC1DIHdvdWxkIGJlIHByZXNzZWQgb24gYSBzcGVjaWZpYyBsaW5lIGluCnlvdXIgc2NyaXB0LCB1c2UgdGhlIGRlYnVnIG1vZGUgYW5kIGV4ZWN1dGUgdGhlIHw+cXVpdHwgb3IgfD5pbnRlcnJ1cHR8CmNvbW1hbmQgb24gdGhhdCBsaW5lLiAgU2VlIHxkZWJ1Zy1zY3JpcHRzfC4KCgpDQVRDSElORyBBTEwJCQkJCQkqY2F0Y2gtYWxsKgoKVGhlIGNvbW1hbmRzID4KCgk6Y2F0Y2ggLy4qLwoJOmNhdGNoIC8vCgk6Y2F0Y2gKCmNhdGNoIGV2ZXJ5dGhpbmcsIGVycm9yIGV4Y2VwdGlvbnMsIGludGVycnVwdCBleGNlcHRpb25zIGFuZCBleGNlcHRpb25zCmV4cGxpY2l0bHkgdGhyb3duIGJ5IHRoZSB8OnRocm93fCBjb21tYW5kLiAgVGhpcyBpcyB1c2VmdWwgYXQgdGhlIHRvcCBsZXZlbCBvZgphIHNjcmlwdCBpbiBvcmRlciB0byBjYXRjaCB1bmV4cGVjdGVkIHRoaW5ncy4KICAgRXhhbXBsZTogPgoKCTp0cnkKCToKCTogICIgZG8gdGhlIGhhcmQgd29yayBoZXJlCgk6Cgk6Y2F0Y2ggL015RXhjZXB0aW9uLwoJOgoJOiAgIiBoYW5kbGUga25vd24gcHJvYmxlbQoJOgoJOmNhdGNoIC9eVmltOkludGVycnVwdCQvCgk6ICAgIGVjaG8gIlNjcmlwdCBpbnRlcnJ1cHRlZCIKCTpjYXRjaCAvLiovCgk6ICBlY2hvICJJbnRlcm5hbCBlcnJvciAoIiAuIHY6ZXhjZXB0aW9uIC4gIikiCgk6ICBlY2hvICIgLSBvY2N1cnJlZCBhdCAiIC4gdjp0aHJvd3BvaW50Cgk6ZW5kdHJ5Cgk6IiBlbmQgb2Ygc2NyaXB0CgpOb3RlOiBDYXRjaGluZyBhbGwgbWlnaHQgY2F0Y2ggbW9yZSB0aGluZ3MgdGhhbiB5b3Ugd2FudC4gIFRodXMsIHlvdSBhcmUKc3Ryb25nbHkgZW5jb3VyYWdlZCB0byBjYXRjaCBvbmx5IGZvciBwcm9ibGVtcyB0aGF0IHlvdSBjYW4gcmVhbGx5IGhhbmRsZSBieQpzcGVjaWZ5aW5nIGEgcGF0dGVybiBhcmd1bWVudCB0byB0aGUgIjpjYXRjaCIuCiAgIEV4YW1wbGU6IENhdGNoaW5nIGFsbCBjb3VsZCBtYWtlIGl0IG5lYXJseSBpbXBvc3NpYmxlIHRvIGludGVycnVwdCBhIHNjcmlwdApieSBwcmVzc2luZyBDVFJMLUM6ID4KCgk6d2hpbGUgMQoJOiAgdHJ5Cgk6ICAgIHNsZWVwIDEKCTogIGNhdGNoCgk6ICBlbmR0cnkKCTplbmR3aGlsZQoKCkVYQ0VQVElPTlMgQU5EIEFVVE9DT01NQU5EUwkJCQkqZXhjZXB0LWF1dG9jbWQqCgpFeGNlcHRpb25zIG1heSBiZSB1c2VkIGR1cmluZyBleGVjdXRpb24gb2YgYXV0b2NvbW1hbmRzLiAgRXhhbXBsZTogPgoKCTphdXRvY21kIFVzZXIgeCB0cnkKCTphdXRvY21kIFVzZXIgeCAgIHRocm93ICJPb3BzISIKCTphdXRvY21kIFVzZXIgeCBjYXRjaAoJOmF1dG9jbWQgVXNlciB4ICAgZWNobyB2OmV4Y2VwdGlvbgoJOmF1dG9jbWQgVXNlciB4IGVuZHRyeQoJOmF1dG9jbWQgVXNlciB4IHRocm93ICJBcnJnaCEiCgk6YXV0b2NtZCBVc2VyIHggZWNobyAiU2hvdWxkIG5vdCBiZSBkaXNwbGF5ZWQiCgk6Cgk6dHJ5Cgk6ICBkb2F1dG9jbWQgVXNlciB4Cgk6Y2F0Y2gKCTogIGVjaG8gdjpleGNlcHRpb24KCTplbmR0cnkKClRoaXMgZGlzcGxheXMgIk9vcHMhIiBhbmQgIkFycmdoISIuCgoJCQkJCQkJKmV4Y2VwdC1hdXRvY21kLVByZSoKRm9yIHNvbWUgY29tbWFuZHMsIGF1dG9jb21tYW5kcyBnZXQgZXhlY3V0ZWQgYmVmb3JlIHRoZSBtYWluIGFjdGlvbiBvZiB0aGUKY29tbWFuZCB0YWtlcyBwbGFjZS4gIElmIGFuIGV4Y2VwdGlvbiBpcyB0aHJvd24gYW5kIG5vdCBjYXVnaHQgaW4gdGhlIHNlcXVlbmNlCm9mIGF1dG9jb21tYW5kcywgdGhlIHNlcXVlbmNlIGFuZCB0aGUgY29tbWFuZCB0aGF0IGNhdXNlZCBpdHMgZXhlY3V0aW9uIGFyZQphYmFuZG9uZWQgYW5kIHRoZSBleGNlcHRpb24gaXMgcHJvcGFnYXRlZCB0byB0aGUgY2FsbGVyIG9mIHRoZSBjb21tYW5kLgogICBFeGFtcGxlOiA+CgoJOmF1dG9jbWQgQnVmV3JpdGVQcmUgKiB0aHJvdyAiRkFJTCIKCTphdXRvY21kIEJ1ZldyaXRlUHJlICogZWNobyAiU2hvdWxkIG5vdCBiZSBkaXNwbGF5ZWQiCgk6Cgk6dHJ5Cgk6ICB3cml0ZQoJOmNhdGNoCgk6ICBlY2hvICJDYXVnaHQ6IiB2OmV4Y2VwdGlvbiAiZnJvbSIgdjp0aHJvd3BvaW50Cgk6ZW5kdHJ5CgpIZXJlLCB0aGUgIjp3cml0ZSIgY29tbWFuZCBkb2VzIG5vdCB3cml0ZSB0aGUgZmlsZSBjdXJyZW50bHkgYmVpbmcgZWRpdGVkIChhcwp5b3UgY2FuIHNlZSBieSBjaGVja2luZyAnbW9kaWZpZWQnKSwgc2luY2UgdGhlIGV4Y2VwdGlvbiBmcm9tIHRoZSBCdWZXcml0ZVByZQphdXRvY29tbWFuZCBhYmFuZG9ucyB0aGUgIjp3cml0ZSIuICBUaGUgZXhjZXB0aW9uIGlzIHRoZW4gY2F1Z2h0IGFuZCB0aGUKc2NyaXB0IGRpc3BsYXlzOiA+CgoJQ2F1Z2h0OiBGQUlMIGZyb20gQnVmV3JpdGUgQXV0byBjb21tYW5kcyBmb3IgIioiCjwKCQkJCQkJCSpleGNlcHQtYXV0b2NtZC1Qb3N0KgpGb3Igc29tZSBjb21tYW5kcywgYXV0b2NvbW1hbmRzIGdldCBleGVjdXRlZCBhZnRlciB0aGUgbWFpbiBhY3Rpb24gb2YgdGhlCmNvbW1hbmQgaGFzIHRha2VuIHBsYWNlLiAgSWYgdGhpcyBtYWluIGFjdGlvbiBmYWlscyBhbmQgdGhlIGNvbW1hbmQgaXMgaW5zaWRlCmFuIGFjdGl2ZSB0cnkgY29uZGl0aW9uYWwsIHRoZSBhdXRvY29tbWFuZHMgYXJlIHNraXBwZWQgYW5kIGFuIGVycm9yIGV4Y2VwdGlvbgppcyB0aHJvd24gdGhhdCBjYW4gYmUgY2F1Z2h0IGJ5IHRoZSBjYWxsZXIgb2YgdGhlIGNvbW1hbmQuCiAgIEV4YW1wbGU6ID4KCgk6YXV0b2NtZCBCdWZXcml0ZVBvc3QgKiBlY2hvICJGaWxlIHN1Y2Nlc3NmdWxseSB3cml0dGVuISIKCToKCTp0cnkKCTogIHdyaXRlIC9pL20vcC9vL3Mvcy9pL2IvbC9lCgk6Y2F0Y2gKCTogIGVjaG8gdjpleGNlcHRpb24KCTplbmR0cnkKClRoaXMganVzdCBkaXNwbGF5czogPgoKCVZpbSh3cml0ZSk6RTIxMjogQ2FuJ3Qgb3BlbiBmaWxlIGZvciB3cml0aW5nICgvaS9tL3Avby9zL3MvaS9iL2wvZSkKCklmIHlvdSByZWFsbHkgbmVlZCB0byBleGVjdXRlIHRoZSBhdXRvY29tbWFuZHMgZXZlbiB3aGVuIHRoZSBtYWluIGFjdGlvbgpmYWlscywgdHJpZ2dlciB0aGUgZXZlbnQgZnJvbSB0aGUgY2F0Y2ggY2xhdXNlLgogICBFeGFtcGxlOiA+CgoJOmF1dG9jbWQgQnVmV3JpdGVQcmUgICogc2V0IG5vcmVhZG9ubHkKCTphdXRvY21kIEJ1ZldyaXRlUG9zdCAqIHNldCByZWFkb25seQoJOgoJOnRyeQoJOiAgd3JpdGUgL2kvbS9wL28vcy9zL2kvYi9sL2UKCTpjYXRjaAoJOiAgZG9hdXRvY21kIEJ1ZldyaXRlUG9zdCAvaS9tL3Avby9zL3MvaS9iL2wvZQoJOmVuZHRyeQo8CllvdSBjYW4gYWxzbyB1c2UgIjpzaWxlbnQhIjogPgoKCTpsZXQgeCA9ICJvayIKCTpsZXQgdjplcnJtc2cgPSAiIgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogaWYgdjplcnJtc2cgIT0gIiIKCTphdXRvY21kIEJ1ZldyaXRlUG9zdCAqICAgbGV0IHggPSAiYWZ0ZXIgZmFpbCIKCTphdXRvY21kIEJ1ZldyaXRlUG9zdCAqIGVuZGlmCgk6dHJ5Cgk6ICBzaWxlbnQhIHdyaXRlIC9pL20vcC9vL3Mvcy9pL2IvbC9lCgk6Y2F0Y2gKCTplbmR0cnkKCTplY2hvIHgKClRoaXMgZGlzcGxheXMgImFmdGVyIGZhaWwiLgoKSWYgdGhlIG1haW4gYWN0aW9uIG9mIHRoZSBjb21tYW5kIGRvZXMgbm90IGZhaWwsIGV4Y2VwdGlvbnMgZnJvbSB0aGUKYXV0b2NvbW1hbmRzIHdpbGwgYmUgY2F0Y2hhYmxlIGJ5IHRoZSBjYWxsZXIgb2YgdGhlIGNvbW1hbmQ6ICA+CgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogdGhyb3cgIjotKCIKCTphdXRvY21kIEJ1ZldyaXRlUG9zdCAqIGVjaG8gIlNob3VsZCBub3QgYmUgZGlzcGxheWVkIgoJOgoJOnRyeQoJOiAgd3JpdGUKCTpjYXRjaAoJOiAgZWNobyB2OmV4Y2VwdGlvbgoJOmVuZHRyeQo8CgkJCQkJCQkqZXhjZXB0LWF1dG9jbWQtQ21kKgpGb3Igc29tZSBjb21tYW5kcywgdGhlIG5vcm1hbCBhY3Rpb24gY2FuIGJlIHJlcGxhY2VkIGJ5IGEgc2VxdWVuY2Ugb2YKYXV0b2NvbW1hbmRzLiAgRXhjZXB0aW9ucyBmcm9tIHRoYXQgc2VxdWVuY2Ugd2lsbCBiZSBjYXRjaGFibGUgYnkgdGhlIGNhbGxlcgpvZiB0aGUgY29tbWFuZC4KICAgRXhhbXBsZTogIEZvciB0aGUgIjp3cml0ZSIgY29tbWFuZCwgdGhlIGNhbGxlciBjYW5ub3Qga25vdyB3aGV0aGVyIHRoZSBmaWxlCmhhZCBhY3R1YWxseSBiZWVuIHdyaXR0ZW4gd2hlbiB0aGUgZXhjZXB0aW9uIG9jY3VycmVkLglZb3UgbmVlZCB0byB0ZWxsIGl0IGluCnNvbWUgd2F5LiA+CgoJOmlmICFleGlzdHMoImNudCIpCgk6ICBsZXQgY250ID0gMAoJOgoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqIGlmICZtb2RpZmllZAoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqICAgbGV0IGNudCA9IGNudCArIDEKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiAgIGlmIGNudCAlIDMgPT0gMgoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqICAgICB0aHJvdyAiQnVmV3JpdGVDbWRFcnJvciIKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiAgIGVuZGlmCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogICB3cml0ZSB8IHNldCBub21vZGlmaWVkCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogICBpZiBjbnQgJSAzID09IDAKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiAgICAgdGhyb3cgIkJ1ZldyaXRlQ21kRXJyb3IiCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogICBlbmRpZgoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqICAgZWNobyAiRmlsZSBzdWNjZXNzZnVsbHkgd3JpdHRlbiEiCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogZW5kaWYKCTplbmRpZgoJOgoJOnRyeQoJOgl3cml0ZQoJOmNhdGNoIC9eQnVmV3JpdGVDbWRFcnJvciQvCgk6ICBpZiAmbW9kaWZpZWQKCTogICAgZWNobyAiRXJyb3Igb24gd3JpdGluZyAoZmlsZSBjb250ZW50cyBub3QgY2hhbmdlZCkiCgk6ICBlbHNlCgk6ICAgIGVjaG8gIkVycm9yIGFmdGVyIHdyaXRpbmciCgk6ICBlbmRpZgoJOmNhdGNoIC9eVmltKHdyaXRlKTovCgk6ICAgIGVjaG8gIkVycm9yIG9uIHdyaXRpbmciCgk6ZW5kdHJ5CgpXaGVuIHRoaXMgc2NyaXB0IGlzIHNvdXJjZWQgc2V2ZXJhbCB0aW1lcyBhZnRlciBtYWtpbmcgY2hhbmdlcywgaXQgZGlzcGxheXMKZmlyc3QgPgoJRmlsZSBzdWNjZXNzZnVsbHkgd3JpdHRlbiEKdGhlbiA+CglFcnJvciBvbiB3cml0aW5nIChmaWxlIGNvbnRlbnRzIG5vdCBjaGFuZ2VkKQp0aGVuID4KCUVycm9yIGFmdGVyIHdyaXRpbmcKZXRjLgoKCQkJCQkJCSpleGNlcHQtYXV0b2NtZC1pbGwqCllvdSBjYW5ub3Qgc3ByZWFkIGEgdHJ5IGNvbmRpdGlvbmFsIG92ZXIgYXV0b2NvbW1hbmRzIGZvciBkaWZmZXJlbnQgZXZlbnRzLgpUaGUgZm9sbG93aW5nIGNvZGUgaXMgaWxsLWZvcm1lZDogPgoKCTphdXRvY21kIEJ1ZldyaXRlUHJlICAqIHRyeQoJOgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogY2F0Y2gKCTphdXRvY21kIEJ1ZldyaXRlUG9zdCAqICAgZWNobyB2OmV4Y2VwdGlvbgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogZW5kdHJ5Cgk6Cgk6d3JpdGUKCgpFWENFUFRJT04gSElFUkFSQ0hJRVMgQU5EIFBBUkFNRVRFUklaRUQgRVhDRVBUSU9OUwkqZXhjZXB0LWhpZXItcGFyYW0qCgpTb21lIHByb2dyYW1taW5nIGxhbmd1YWdlcyBhbGxvdyB0byB1c2UgaGllcmFyY2hpZXMgb2YgZXhjZXB0aW9uIGNsYXNzZXMgb3IgdG8KcGFzcyBhZGRpdGlvbmFsIGluZm9ybWF0aW9uIHdpdGggdGhlIG9iamVjdCBvZiBhbiBleGNlcHRpb24gY2xhc3MuICBZb3UgY2FuIGRvCnNpbWlsYXIgdGhpbmdzIGluIFZpbS4KICAgSW4gb3JkZXIgdG8gdGhyb3cgYW4gZXhjZXB0aW9uIGZyb20gYSBoaWVyYXJjaHksIGp1c3QgdGhyb3cgdGhlIGNvbXBsZXRlCmNsYXNzIG5hbWUgd2l0aCB0aGUgY29tcG9uZW50cyBzZXBhcmF0ZWQgYnkgYSBjb2xvbiwgZm9yIGluc3RhbmNlIHRocm93IHRoZQpzdHJpbmcgIkVYQ0VQVDpNQVRIRVJSOk9WRVJGTE9XIiBmb3IgYW4gb3ZlcmZsb3cgaW4gYSBtYXRoZW1hdGljYWwgbGlicmFyeS4KICAgV2hlbiB5b3Ugd2FudCB0byBwYXNzIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gd2l0aCB5b3VyIGV4Y2VwdGlvbiBjbGFzcywgYWRkCml0IGluIHBhcmVudGhlc2VzLCBmb3IgaW5zdGFuY2UgdGhyb3cgdGhlIHN0cmluZyAiRVhDRVBUOklPOldSSVRFRVJSKG15ZmlsZSkiCmZvciBhbiBlcnJvciB3aGVuIHdyaXRpbmcgIm15ZmlsZSIuCiAgIFdpdGggdGhlIGFwcHJvcHJpYXRlIHBhdHRlcm5zIGluIHRoZSAiOmNhdGNoIiBjb21tYW5kLCB5b3UgY2FuIGNhdGNoIGZvcgpiYXNlIGNsYXNzZXMgb3IgZGVyaXZlZCBjbGFzc2VzIG9mIHlvdXIgaGllcmFyY2h5LiAgQWRkaXRpb25hbCBpbmZvcm1hdGlvbiBpbgpwYXJlbnRoZXNlcyBjYW4gYmUgY3V0IG91dCBmcm9tIHx2OmV4Y2VwdGlvbnwgd2l0aCB0aGUgIjpzdWJzdGl0dXRlIiBjb21tYW5kLgogICBFeGFtcGxlOiA+CgoJOmZ1bmN0aW9uISBDaGVja1JhbmdlKGEsIGZ1bmMpCgk6ICBpZiBhOmEgPCAwCgk6ICAgIHRocm93ICJFWENFUFQ6TUFUSEVSUjpSQU5HRSgiIC4gYTpmdW5jIC4gIikiCgk6ICBlbmRpZgoJOmVuZGZ1bmN0aW9uCgk6Cgk6ZnVuY3Rpb24hIEFkZChhLCBiKQoJOiAgY2FsbCBDaGVja1JhbmdlKGE6YSwgIkFkZCIpCgk6ICBjYWxsIENoZWNrUmFuZ2UoYTpiLCAiQWRkIikKCTogIGxldCBjID0gYTphICsgYTpiCgk6ICBpZiBjIDwgMAoJOiAgICB0aHJvdyAiRVhDRVBUOk1BVEhFUlI6T1ZFUkZMT1ciCgk6ICBlbmRpZgoJOiAgcmV0dXJuIGMKCTplbmRmdW5jdGlvbgoJOgoJOmZ1bmN0aW9uISBEaXYoYSwgYikKCTogIGNhbGwgQ2hlY2tSYW5nZShhOmEsICJEaXYiKQoJOiAgY2FsbCBDaGVja1JhbmdlKGE6YiwgIkRpdiIpCgk6ICBpZiAoYTpiID09IDApCgk6ICAgIHRocm93ICJFWENFUFQ6TUFUSEVSUjpaRVJPRElWIgoJOiAgZW5kaWYKCTogIHJldHVybiBhOmEgLyBhOmIKCTplbmRmdW5jdGlvbgoJOgoJOmZ1bmN0aW9uISBXcml0ZShmaWxlKQoJOiAgdHJ5Cgk6ICAgIGV4ZWN1dGUgIndyaXRlIiBmbmFtZWVzY2FwZShhOmZpbGUpCgk6ICBjYXRjaCAvXlZpbSh3cml0ZSk6LwoJOiAgICB0aHJvdyAiRVhDRVBUOklPKCIgLiBnZXRjd2QoKSAuICIsICIgLiBhOmZpbGUgLiAiKTpXUklURUVSUiIKCTogIGVuZHRyeQoJOmVuZGZ1bmN0aW9uCgk6Cgk6dHJ5Cgk6Cgk6ICAiIHNvbWV0aGluZyB3aXRoIGFyaXRobWV0aWNzIGFuZCBJL08KCToKCTpjYXRjaCAvXkVYQ0VQVDpNQVRIRVJSOlJBTkdFLwoJOiAgbGV0IGZ1bmN0aW9uID0gc3Vic3RpdHV0ZSh2OmV4Y2VwdGlvbiwgJy4qKFwoXGFcK1wpKS4qJywgJ1wxJywgIiIpCgk6ICBlY2hvICJSYW5nZSBlcnJvciBpbiIgZnVuY3Rpb24KCToKCTpjYXRjaCAvXkVYQ0VQVDpNQVRIRVJSLwkiIGNhdGNoZXMgT1ZFUkZMT1cgYW5kIFpFUk9ESVYKCTogIGVjaG8gIk1hdGggZXJyb3IiCgk6Cgk6Y2F0Y2ggL15FWENFUFQ6SU8vCgk6ICBsZXQgZGlyID0gc3Vic3RpdHV0ZSh2OmV4Y2VwdGlvbiwgJy4qKFwoLlwrXCksXHMqLlwrKS4qJywgJ1wxJywgIiIpCgk6ICBsZXQgZmlsZSA9IHN1YnN0aXR1dGUodjpleGNlcHRpb24sICcuKiguXCssXHMqXCguXCtcKSkuKicsICdcMScsICIiKQoJOiAgaWYgZmlsZSAhfiAnXi8nCgk6ICAgIGxldCBmaWxlID0gZGlyIC4gIi8iIC4gZmlsZQoJOiAgZW5kaWYKCTogIGVjaG8gJ0kvTyBlcnJvciBmb3IgIicgLiBmaWxlIC4gJyInCgk6Cgk6Y2F0Y2ggL15FWENFUFQvCgk6ICBlY2hvICJVbnNwZWNpZmllZCBlcnJvciIKCToKCTplbmR0cnkKClRoZSBleGNlcHRpb25zIHJhaXNlZCBieSBWaW0gaXRzZWxmIChvbiBlcnJvciBvciB3aGVuIHByZXNzaW5nIENUUkwtQykgdXNlCmEgZmxhdCBoaWVyYXJjaHk6ICB0aGV5IGFyZSBhbGwgaW4gdGhlICJWaW0iIGNsYXNzLiAgWW91IGNhbm5vdCB0aHJvdyB5b3Vyc2VsZgpleGNlcHRpb25zIHdpdGggdGhlICJWaW0iIHByZWZpeDsgdGhleSBhcmUgcmVzZXJ2ZWQgZm9yIFZpbS4KICAgVmltIGVycm9yIGV4Y2VwdGlvbnMgYXJlIHBhcmFtZXRlcml6ZWQgd2l0aCB0aGUgbmFtZSBvZiB0aGUgY29tbWFuZCB0aGF0CmZhaWxlZCwgaWYga25vd24uICBTZWUgfGNhdGNoLWVycm9yc3wuCgoKUEVDVUxJQVJJVElFUwoJCQkJCQkJKmV4Y2VwdC1jb21wYXQqClRoZSBleGNlcHRpb24gaGFuZGxpbmcgY29uY2VwdCByZXF1aXJlcyB0aGF0IHRoZSBjb21tYW5kIHNlcXVlbmNlIGNhdXNpbmcgdGhlCmV4Y2VwdGlvbiBpcyBhYm9ydGVkIGltbWVkaWF0ZWx5IGFuZCBjb250cm9sIGlzIHRyYW5zZmVycmVkIHRvIGZpbmFsbHkgY2xhdXNlcwphbmQvb3IgYSBjYXRjaCBjbGF1c2UuCgpJbiB0aGUgVmltIHNjcmlwdCBsYW5ndWFnZSB0aGVyZSBhcmUgY2FzZXMgd2hlcmUgc2NyaXB0cyBhbmQgZnVuY3Rpb25zCmNvbnRpbnVlIGFmdGVyIGFuIGVycm9yOiBpbiBmdW5jdGlvbnMgd2l0aG91dCB0aGUgImFib3J0IiBmbGFnIG9yIGluIGEgY29tbWFuZAphZnRlciAiOnNpbGVudCEiLCBjb250cm9sIGZsb3cgZ29lcyB0byB0aGUgZm9sbG93aW5nIGxpbmUsIGFuZCBvdXRzaWRlCmZ1bmN0aW9ucywgY29udHJvbCBmbG93IGdvZXMgdG8gdGhlIGxpbmUgZm9sbG93aW5nIHRoZSBvdXRlcm1vc3QgIjplbmR3aGlsZSIKb3IgIjplbmRpZiIuICBPbiB0aGUgb3RoZXIgaGFuZCwgZXJyb3JzIHNob3VsZCBiZSBjYXRjaGFibGUgYXMgZXhjZXB0aW9ucwoodGh1cywgcmVxdWlyaW5nIHRoZSBpbW1lZGlhdGUgYWJvcnRpb24pLgoKVGhpcyBwcm9ibGVtIGhhcyBiZWVuIHNvbHZlZCBieSBjb252ZXJ0aW5nIGVycm9ycyB0byBleGNlcHRpb25zIGFuZCB1c2luZwppbW1lZGlhdGUgYWJvcnRpb24gKGlmIG5vdCBzdXBwcmVzc2VkIGJ5ICI6c2lsZW50ISIpIG9ubHkgd2hlbiBhIHRyeQpjb25kaXRpb25hbCBpcyBhY3RpdmUuCVRoaXMgaXMgbm8gcmVzdHJpY3Rpb24gc2luY2UgYW4gKGVycm9yKSBleGNlcHRpb24gY2FuCmJlIGNhdWdodCBvbmx5IGZyb20gYW4gYWN0aXZlIHRyeSBjb25kaXRpb25hbC4JSWYgeW91IHdhbnQgYW4gaW1tZWRpYXRlCnRlcm1pbmF0aW9uIHdpdGhvdXQgY2F0Y2hpbmcgdGhlIGVycm9yLCBqdXN0IHVzZSBhIHRyeSBjb25kaXRpb25hbCB3aXRob3V0CmNhdGNoIGNsYXVzZS4gIChZb3UgY2FuIGNhdXNlIGNsZWFudXAgY29kZSBiZWluZyBleGVjdXRlZCBiZWZvcmUgdGVybWluYXRpb24KYnkgc3BlY2lmeWluZyBhIGZpbmFsbHkgY2xhdXNlLikKCldoZW4gbm8gdHJ5IGNvbmRpdGlvbmFsIGlzIGFjdGl2ZSwgdGhlIHVzdWFsIGFib3J0aW9uIGFuZCBjb250aW51YXRpb24KYmVoYXZpb3IgaXMgdXNlZCBpbnN0ZWFkIG9mIGltbWVkaWF0ZSBhYm9ydGlvbi4gIFRoaXMgZW5zdXJlcyBjb21wYXRpYmlsaXR5IG9mCnNjcmlwdHMgd3JpdHRlbiBmb3IgVmltIDYuMSBhbmQgZWFybGllci4KCkhvd2V2ZXIsIHdoZW4gc291cmNpbmcgYW4gZXhpc3Rpbmcgc2NyaXB0IHRoYXQgZG9lcyBub3QgdXNlIGV4Y2VwdGlvbiBoYW5kbGluZwpjb21tYW5kcyAob3Igd2hlbiBjYWxsaW5nIG9uZSBvZiBpdHMgZnVuY3Rpb25zKSBmcm9tIGluc2lkZSBhbiBhY3RpdmUgdHJ5CmNvbmRpdGlvbmFsIG9mIGEgbmV3IHNjcmlwdCwgeW91IG1pZ2h0IGNoYW5nZSB0aGUgY29udHJvbCBmbG93IG9mIHRoZSBleGlzdGluZwpzY3JpcHQgb24gZXJyb3IuICBZb3UgZ2V0IHRoZSBpbW1lZGlhdGUgYWJvcnRpb24gb24gZXJyb3IgYW5kIGNhbiBjYXRjaCB0aGUKZXJyb3IgaW4gdGhlIG5ldyBzY3JpcHQuICBJZiBob3dldmVyIHRoZSBzb3VyY2VkIHNjcmlwdCBzdXBwcmVzc2VzIGVycm9yCm1lc3NhZ2VzIGJ5IHVzaW5nIHRoZSAiOnNpbGVudCEiIGNvbW1hbmQgKGNoZWNraW5nIGZvciBlcnJvcnMgYnkgdGVzdGluZwp8djplcnJtc2d8IGlmIGFwcHJvcHJpYXRlKSwgaXRzIGV4ZWN1dGlvbiBwYXRoIGlzIG5vdCBjaGFuZ2VkLglUaGUgZXJyb3IgaXMKbm90IGNvbnZlcnRlZCB0byBhbiBleGNlcHRpb24uCShTZWUgfDpzaWxlbnR8LikgIFNvIHRoZSBvbmx5IHJlbWFpbmluZyBjYXVzZQp3aGVyZSB0aGlzIGhhcHBlbnMgaXMgZm9yIHNjcmlwdHMgdGhhdCBkb24ndCBjYXJlIGFib3V0IGVycm9ycyBhbmQgcHJvZHVjZQplcnJvciBtZXNzYWdlcy4gIFlvdSBwcm9iYWJseSB3b24ndCB3YW50IHRvIHVzZSBzdWNoIGNvZGUgZnJvbSB5b3VyIG5ldwpzY3JpcHRzLgoKCQkJCQkJCSpleGNlcHQtc3ludGF4LWVycioKU3ludGF4IGVycm9ycyBpbiB0aGUgZXhjZXB0aW9uIGhhbmRsaW5nIGNvbW1hbmRzIGFyZSBuZXZlciBjYXVnaHQgYnkgYW55IG9mCnRoZSAiOmNhdGNoIiBjb21tYW5kcyBvZiB0aGUgdHJ5IGNvbmRpdGlvbmFsIHRoZXkgYmVsb25nIHRvLiAgSXRzIGZpbmFsbHkKY2xhdXNlcywgaG93ZXZlciwgaXMgZXhlY3V0ZWQuCiAgIEV4YW1wbGU6ID4KCgk6dHJ5Cgk6ICB0cnkKCTogICAgdGhyb3cgNDcxMQoJOiAgY2F0Y2ggL1woLwoJOiAgICBlY2hvICJpbiBjYXRjaCB3aXRoIHN5bnRheCBlcnJvciIKCTogIGNhdGNoCgk6ICAgIGVjaG8gImlubmVyIGNhdGNoLWFsbCIKCTogIGZpbmFsbHkKCTogICAgZWNobyAiaW5uZXIgZmluYWxseSIKCTogIGVuZHRyeQoJOmNhdGNoCgk6ICBlY2hvICdvdXRlciBjYXRjaC1hbGwgY2F1Z2h0ICInIC4gdjpleGNlcHRpb24gLiAnIicKCTogIGZpbmFsbHkKCTogICAgZWNobyAib3V0ZXIgZmluYWxseSIKCTplbmR0cnkKClRoaXMgZGlzcGxheXM6ID4KICAgIGlubmVyIGZpbmFsbHkKICAgIG91dGVyIGNhdGNoLWFsbCBjYXVnaHQgIlZpbShjYXRjaCk6RTU0OiBVbm1hdGNoZWQgXCgiCiAgICBvdXRlciBmaW5hbGx5ClRoZSBvcmlnaW5hbCBleGNlcHRpb24gaXMgZGlzY2FyZGVkIGFuZCBhbiBlcnJvciBleGNlcHRpb24gaXMgcmFpc2VkLCBpbnN0ZWFkLgoKCQkJCQkJCSpleGNlcHQtc2luZ2xlLWxpbmUqClRoZSAiOnRyeSIsICI6Y2F0Y2giLCAiOmZpbmFsbHkiLCBhbmQgIjplbmR0cnkiIGNvbW1hbmRzIGNhbiBiZSBwdXQgb24KYSBzaW5nbGUgbGluZSwgYnV0IHRoZW4gc3ludGF4IGVycm9ycyBtYXkgbWFrZSBpdCBkaWZmaWN1bHQgdG8gcmVjb2duaXplIHRoZQoiY2F0Y2giIGxpbmUsIHRodXMgeW91IGJldHRlciBhdm9pZCB0aGlzLgogICBFeGFtcGxlOiA+Cgk6dHJ5IHwgdW5sZXQhIGZvbyAjIHwgY2F0Y2ggfCBlbmR0cnkKcmFpc2VzIGFuIGVycm9yIGV4Y2VwdGlvbiBmb3IgdGhlIHRyYWlsaW5nIGNoYXJhY3RlcnMgYWZ0ZXIgdGhlICI6dW5sZXQhIgphcmd1bWVudCwgYnV0IGRvZXMgbm90IHNlZSB0aGUgIjpjYXRjaCIgYW5kICI6ZW5kdHJ5IiBjb21tYW5kcywgc28gdGhhdCB0aGUKZXJyb3IgZXhjZXB0aW9uIGlzIGRpc2NhcmRlZCBhbmQgdGhlICJFNDg4OiBUcmFpbGluZyBjaGFyYWN0ZXJzIiBtZXNzYWdlIGdldHMKZGlzcGxheWVkLgoKCQkJCQkJCSpleGNlcHQtc2V2ZXJhbC1lcnJvcnMqCldoZW4gc2V2ZXJhbCBlcnJvcnMgYXBwZWFyIGluIGEgc2luZ2xlIGNvbW1hbmQsIHRoZSBmaXJzdCBlcnJvciBtZXNzYWdlIGlzCnVzdWFsbHkgdGhlIG1vc3Qgc3BlY2lmaWMgb25lIGFuZCB0aGVyZWZvciBjb252ZXJ0ZWQgdG8gdGhlIGVycm9yIGV4Y2VwdGlvbi4KICAgRXhhbXBsZTogPgoJZWNobyBub3ZhcgpjYXVzZXMgPgoJRTEyMTogVW5kZWZpbmVkIHZhcmlhYmxlOiBub3ZhcgoJRTE1OiBJbnZhbGlkIGV4cHJlc3Npb246IG5vdmFyClRoZSB2YWx1ZSBvZiB0aGUgZXJyb3IgZXhjZXB0aW9uIGluc2lkZSB0cnkgY29uZGl0aW9uYWxzIGlzOiA+CglWaW0oZWNobyk6RTEyMTogVW5kZWZpbmVkIHZhcmlhYmxlOiBub3Zhcgo8CQkJCQkJCSpleGNlcHQtc3ludGF4LWVycm9yKgpCdXQgd2hlbiBhIHN5bnRheCBlcnJvciBpcyBkZXRlY3RlZCBhZnRlciBhIG5vcm1hbCBlcnJvciBpbiB0aGUgc2FtZSBjb21tYW5kLAp0aGUgc3ludGF4IGVycm9yIGlzIHVzZWQgZm9yIHRoZSBleGNlcHRpb24gYmVpbmcgdGhyb3duLgogICBFeGFtcGxlOiA+Cgl1bmxldCBub3ZhciAjCmNhdXNlcyA+CglFMTA4OiBObyBzdWNoIHZhcmlhYmxlOiAibm92YXIiCglFNDg4OiBUcmFpbGluZyBjaGFyYWN0ZXJzClRoZSB2YWx1ZSBvZiB0aGUgZXJyb3IgZXhjZXB0aW9uIGluc2lkZSB0cnkgY29uZGl0aW9uYWxzIGlzOiA+CglWaW0odW5sZXQpOkU0ODg6IFRyYWlsaW5nIGNoYXJhY3RlcnMKVGhpcyBpcyBkb25lIGJlY2F1c2UgdGhlIHN5bnRheCBlcnJvciBtaWdodCBjaGFuZ2UgdGhlIGV4ZWN1dGlvbiBwYXRoIGluIGEgd2F5Cm5vdCBpbnRlbmRlZCBieSB0aGUgdXNlci4gIEV4YW1wbGU6ID4KCXRyeQoJICAgIHRyeSB8IHVubGV0IG5vdmFyICMgfCBjYXRjaCB8IGVjaG8gdjpleGNlcHRpb24gfCBlbmR0cnkKCWNhdGNoIC8uKi8KCSAgICBlY2hvICJvdXRlciBjYXRjaDoiIHY6ZXhjZXB0aW9uCgllbmR0cnkKVGhpcyBkaXNwbGF5cyAib3V0ZXIgY2F0Y2g6IFZpbSh1bmxldCk6RTQ4ODogVHJhaWxpbmcgY2hhcmFjdGVycyIsIGFuZCB0aGVuCmEgIkU2MDA6IE1pc3NpbmcgOmVuZHRyeSIgZXJyb3IgbWVzc2FnZSBpcyBnaXZlbiwgc2VlIHxleGNlcHQtc2luZ2xlLWxpbmV8LgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjkuIEV4YW1wbGVzCQkJCQkJKmV2YWwtZXhhbXBsZXMqCgpQcmludGluZyBpbiBCaW5hcnkgfgo+CiAgOiIgVGhlIGZ1bmN0aW9uIE5yMkJpbigpIHJldHVybnMgdGhlIGJpbmFyeSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgYSBudW1iZXIuCiAgOmZ1bmMgTnIyQmluKG5yKQogIDogIGxldCBuID0gYTpucgogIDogIGxldCByID0gIiIKICA6ICB3aGlsZSBuCiAgOiAgICBsZXQgciA9ICcwMSdbbiAlIDJdIC4gcgogIDogICAgbGV0IG4gPSBuIC8gMgogIDogIGVuZHdoaWxlCiAgOiAgcmV0dXJuIHIKICA6ZW5kZnVuYwoKICA6IiBUaGUgZnVuY3Rpb24gU3RyaW5nMkJpbigpIGNvbnZlcnRzIGVhY2ggY2hhcmFjdGVyIGluIGEgc3RyaW5nIHRvIGEKICA6IiBiaW5hcnkgc3RyaW5nLCBzZXBhcmF0ZWQgd2l0aCBkYXNoZXMuCiAgOmZ1bmMgU3RyaW5nMkJpbihzdHIpCiAgOiAgbGV0IG91dCA9ICcnCiAgOiAgZm9yIGl4IGluIHJhbmdlKHN0cmxlbihhOnN0cikpCiAgOiAgICBsZXQgb3V0ID0gb3V0IC4gJy0nIC4gTnIyQmluKGNoYXIybnIoYTpzdHJbaXhdKSkKICA6ICBlbmRmb3IKICA6ICByZXR1cm4gb3V0WzE6XQogIDplbmRmdW5jCgpFeGFtcGxlIG9mIGl0cyB1c2U6ID4KICA6ZWNobyBOcjJCaW4oMzIpCnJlc3VsdDogIjEwMDAwMCIgPgogIDplY2hvIFN0cmluZzJCaW4oIjMyIikKcmVzdWx0OiAiMTEwMDExLTExMDAxMCIKCgpTb3J0aW5nIGxpbmVzIH4KClRoaXMgZXhhbXBsZSBzb3J0cyBsaW5lcyB3aXRoIGEgc3BlY2lmaWMgY29tcGFyZSBmdW5jdGlvbi4gPgoKICA6ZnVuYyBTb3J0QnVmZmVyKCkKICA6ICBsZXQgbGluZXMgPSBnZXRsaW5lKDEsICckJykKICA6ICBjYWxsIHNvcnQobGluZXMsIGZ1bmN0aW9uKCJTdHJjbXAiKSkKICA6ICBjYWxsIHNldGxpbmUoMSwgbGluZXMpCiAgOmVuZGZ1bmN0aW9uCgpBcyBhIG9uZS1saW5lcjogPgogIDpjYWxsIHNldGxpbmUoMSwgc29ydChnZXRsaW5lKDEsICckJyksIGZ1bmN0aW9uKCJTdHJjbXAiKSkpCgoKc2NhbmYoKSByZXBsYWNlbWVudCB+CgkJCQkJCQkqc3NjYW5mKgpUaGVyZSBpcyBubyBzc2NhbmYoKSBmdW5jdGlvbiBpbiBWaW0uICBJZiB5b3UgbmVlZCB0byBleHRyYWN0IHBhcnRzIGZyb20gYQpsaW5lLCB5b3UgY2FuIHVzZSBtYXRjaHN0cigpIGFuZCBzdWJzdGl0dXRlKCkgdG8gZG8gaXQuICBUaGlzIGV4YW1wbGUgc2hvd3MKaG93IHRvIGdldCB0aGUgZmlsZSBuYW1lLCBsaW5lIG51bWJlciBhbmQgY29sdW1uIG51bWJlciBvdXQgb2YgYSBsaW5lIGxpa2UKImZvb2Jhci50eHQsIDEyMywgNDUiLiA+CiAgIDoiIFNldCB1cCB0aGUgbWF0Y2ggYml0CiAgIDpsZXQgbXg9J1woXGZcK1wpLFxzKlwoXGRcK1wpLFxzKlwoXGRcK1wpJwogICA6ImdldCB0aGUgcGFydCBtYXRjaGluZyB0aGUgd2hvbGUgZXhwcmVzc2lvbgogICA6bGV0IGwgPSBtYXRjaHN0cihsaW5lLCBteCkKICAgOiJnZXQgZWFjaCBpdGVtIG91dCBvZiB0aGUgbWF0Y2gKICAgOmxldCBmaWxlID0gc3Vic3RpdHV0ZShsLCBteCwgJ1wxJywgJycpCiAgIDpsZXQgbG51bSA9IHN1YnN0aXR1dGUobCwgbXgsICdcMicsICcnKQogICA6bGV0IGNvbCA9IHN1YnN0aXR1dGUobCwgbXgsICdcMycsICcnKQoKVGhlIGlucHV0IGlzIGluIHRoZSB2YXJpYWJsZSAibGluZSIsIHRoZSByZXN1bHRzIGluIHRoZSB2YXJpYWJsZXMgImZpbGUiLAoibG51bSIgYW5kICJjb2wiLiAoaWRlYSBmcm9tIE1pY2hhZWwgR2VkZGVzKQoKCmdldHRpbmcgdGhlIHNjcmlwdG5hbWVzIGluIGEgRGljdGlvbmFyeSB+CgkJCQkJCSpzY3JpcHRuYW1lcy1kaWN0aW9uYXJ5KgpUaGUgfDpzY3JpcHRuYW1lc3wgY29tbWFuZCBjYW4gYmUgdXNlZCB0byBnZXQgYSBsaXN0IG9mIGFsbCBzY3JpcHQgZmlsZXMgdGhhdApoYXZlIGJlZW4gc291cmNlZC4gIFRoZXJlIGlzIG5vIGVxdWl2YWxlbnQgZnVuY3Rpb24gb3IgdmFyaWFibGUgZm9yIHRoaXMKKGJlY2F1c2UgaXQncyByYXJlbHkgbmVlZGVkKS4gIEluIGNhc2UgeW91IG5lZWQgdG8gbWFuaXB1bGF0ZSB0aGUgbGlzdCB0aGlzCmNvZGUgY2FuIGJlIHVzZWQ6ID4KICAgICIgR2V0IHRoZSBvdXRwdXQgb2YgIjpzY3JpcHRuYW1lcyIgaW4gdGhlIHNjcmlwdG5hbWVzX291dHB1dCB2YXJpYWJsZS4KICAgIGxldCBzY3JpcHRuYW1lc19vdXRwdXQgPSAnJwogICAgcmVkaXIgPT4gc2NyaXB0bmFtZXNfb3V0cHV0CiAgICBzaWxlbnQgc2NyaXB0bmFtZXMKICAgIHJlZGlyIEVORAogICAgCiAgICAiIFNwbGl0IHRoZSBvdXRwdXQgaW50byBsaW5lcyBhbmQgcGFyc2UgZWFjaCBsaW5lLglBZGQgYW4gZW50cnkgdG8gdGhlCiAgICAiICJzY3JpcHRzIiBkaWN0aW9uYXJ5LgogICAgbGV0IHNjcmlwdHMgPSB7fQogICAgZm9yIGxpbmUgaW4gc3BsaXQoc2NyaXB0bmFtZXNfb3V0cHV0LCAiXG4iKQogICAgICAiIE9ubHkgZG8gbm9uLWJsYW5rIGxpbmVzLgogICAgICBpZiBsaW5lID1+ICdcUycKCSIgR2V0IHRoZSBmaXJzdCBudW1iZXIgaW4gdGhlIGxpbmUuCglsZXQgbnIgPSBtYXRjaHN0cihsaW5lLCAnXGRcKycpCgkiIEdldCB0aGUgZmlsZSBuYW1lLCByZW1vdmUgdGhlIHNjcmlwdCBudW1iZXIgIiAxMjM6ICIuCglsZXQgbmFtZSA9IHN1YnN0aXR1dGUobGluZSwgJy5cKzpccyonLCAnJywgJycpCgkiIEFkZCBhbiBpdGVtIHRvIHRoZSBEaWN0aW9uYXJ5CglsZXQgc2NyaXB0c1tucl0gPSBuYW1lCiAgICAgIGVuZGlmCiAgICBlbmRmb3IKICAgIHVubGV0IHNjcmlwdG5hbWVzX291dHB1dAoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjEwLiBObyArZXZhbCBmZWF0dXJlCQkJCSpuby1ldmFsLWZlYXR1cmUqCgpXaGVuIHRoZSB8K2V2YWx8IGZlYXR1cmUgd2FzIGRpc2FibGVkIGF0IGNvbXBpbGUgdGltZSwgbm9uZSBvZiB0aGUgZXhwcmVzc2lvbgpldmFsdWF0aW9uIGNvbW1hbmRzIGFyZSBhdmFpbGFibGUuICBUbyBwcmV2ZW50IHRoaXMgZnJvbSBjYXVzaW5nIFZpbSBzY3JpcHRzCnRvIGdlbmVyYXRlIGFsbCBraW5kcyBvZiBlcnJvcnMsIHRoZSAiOmlmIiBhbmQgIjplbmRpZiIgY29tbWFuZHMgYXJlIHN0aWxsCnJlY29nbml6ZWQsIHRob3VnaCB0aGUgYXJndW1lbnQgb2YgdGhlICI6aWYiIGFuZCBldmVyeXRoaW5nIGJldHdlZW4gdGhlICI6aWYiCmFuZCB0aGUgbWF0Y2hpbmcgIjplbmRpZiIgaXMgaWdub3JlZC4gIE5lc3Rpbmcgb2YgIjppZiIgYmxvY2tzIGlzIGFsbG93ZWQsIGJ1dApvbmx5IGlmIHRoZSBjb21tYW5kcyBhcmUgYXQgdGhlIHN0YXJ0IG9mIHRoZSBsaW5lLiAgVGhlICI6ZWxzZSIgY29tbWFuZCBpcyBub3QKcmVjb2duaXplZC4KCkV4YW1wbGUgb2YgaG93IHRvIGF2b2lkIGV4ZWN1dGluZyBjb21tYW5kcyB3aGVuIHRoZSB8K2V2YWx8IGZlYXR1cmUgaXMKbWlzc2luZzogPgoKCTppZiAxCgk6ICBlY2hvICJFeHByZXNzaW9uIGV2YWx1YXRpb24gaXMgY29tcGlsZWQgaW4iCgk6ZWxzZQoJOiAgZWNobyAiWW91IHdpbGwgX25ldmVyXyBzZWUgdGhpcyBtZXNzYWdlIgoJOmVuZGlmCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMTEuIFRoZSBzYW5kYm94CQkJCQkqZXZhbC1zYW5kYm94KiAqc2FuZGJveCogKkU0OCoKClRoZSAnZm9sZGV4cHInLCAnZm9ybWF0ZXhwcicsICdpbmNsdWRlZXhwcicsICdpbmRlbnRleHByJywgJ3N0YXR1c2xpbmUnIGFuZAonZm9sZHRleHQnIG9wdGlvbnMgbWF5IGJlIGV2YWx1YXRlZCBpbiBhIHNhbmRib3guICBUaGlzIG1lYW5zIHRoYXQgeW91IGFyZQpwcm90ZWN0ZWQgZnJvbSB0aGVzZSBleHByZXNzaW9ucyBoYXZpbmcgbmFzdHkgc2lkZSBlZmZlY3RzLiAgVGhpcyBnaXZlcyBzb21lCnNhZmV0eSBmb3Igd2hlbiB0aGVzZSBvcHRpb25zIGFyZSBzZXQgZnJvbSBhIG1vZGVsaW5lLiAgSXQgaXMgYWxzbyB1c2VkIHdoZW4KdGhlIGNvbW1hbmQgZnJvbSBhIHRhZ3MgZmlsZSBpcyBleGVjdXRlZCBhbmQgZm9yIENUUkwtUiA9IGluIHRoZSBjb21tYW5kIGxpbmUuClRoZSBzYW5kYm94IGlzIGFsc28gdXNlZCBmb3IgdGhlIHw6c2FuZGJveHwgY29tbWFuZC4KClRoZXNlIGl0ZW1zIGFyZSBub3QgYWxsb3dlZCBpbiB0aGUgc2FuZGJveDoKCS0gY2hhbmdpbmcgdGhlIGJ1ZmZlciB0ZXh0CgktIGRlZmluaW5nIG9yIGNoYW5naW5nIG1hcHBpbmcsIGF1dG9jb21tYW5kcywgZnVuY3Rpb25zLCB1c2VyIGNvbW1hbmRzCgktIHNldHRpbmcgY2VydGFpbiBvcHRpb25zIChzZWUgfG9wdGlvbi1zdW1tYXJ5fCkKCS0gc2V0dGluZyBjZXJ0YWluIHY6IHZhcmlhYmxlcyAoc2VlIHx2OnZhcnwpICAqRTc5NCoKCS0gZXhlY3V0aW5nIGEgc2hlbGwgY29tbWFuZAoJLSByZWFkaW5nIG9yIHdyaXRpbmcgYSBmaWxlCgktIGp1bXBpbmcgdG8gYW5vdGhlciBidWZmZXIgb3IgZWRpdGluZyBhIGZpbGUKCS0gZXhlY3V0aW5nIFB5dGhvbiwgUGVybCwgZXRjLiBjb21tYW5kcwpUaGlzIGlzIG5vdCBndWFyYW50ZWVkIDEwMCUgc2VjdXJlLCBidXQgaXQgc2hvdWxkIGJsb2NrIG1vc3QgYXR0YWNrcy4KCgkJCQkJCQkqOnNhbiogKjpzYW5kYm94Kgo6c2FuW2Rib3hdIHtjbWR9CUV4ZWN1dGUge2NtZH0gaW4gdGhlIHNhbmRib3guICBVc2VmdWwgdG8gZXZhbHVhdGUgYW4KCQkJb3B0aW9uIHRoYXQgbWF5IGhhdmUgYmVlbiBzZXQgZnJvbSBhIG1vZGVsaW5lLCBlLmcuCgkJCSdmb2xkZXhwcicuCgoJCQkJCQkJKnNhbmRib3gtb3B0aW9uKgpBIGZldyBvcHRpb25zIGNvbnRhaW4gYW4gZXhwcmVzc2lvbi4gIFdoZW4gdGhpcyBleHByZXNzaW9uIGlzIGV2YWx1YXRlZCBpdCBtYXkKaGF2ZSB0byBiZSBkb25lIGluIHRoZSBzYW5kYm94IHRvIGF2b2lkIGEgc2VjdXJpdHkgcmlzay4gIEJ1dCB0aGUgc2FuZGJveCBpcwpyZXN0cmljdGl2ZSwgdGh1cyB0aGlzIG9ubHkgaGFwcGVucyB3aGVuIHRoZSBvcHRpb24gd2FzIHNldCBmcm9tIGFuIGluc2VjdXJlCmxvY2F0aW9uLiAgSW5zZWN1cmUgaW4gdGhpcyBjb250ZXh0IGFyZToKLSBzb3VyY2luZyBhIC52aW1yYyBvciAuZXhyYyBpbiB0aGUgY3VycmVudCBkaXJlY3RvcnkKLSB3aGlsZSBleGVjdXRpbmcgaW4gdGhlIHNhbmRib3gKLSB2YWx1ZSBjb21pbmcgZnJvbSBhIG1vZGVsaW5lCgpOb3RlIHRoYXQgd2hlbiBpbiB0aGUgc2FuZGJveCBhbmQgc2F2aW5nIGFuIG9wdGlvbiB2YWx1ZSBhbmQgcmVzdG9yaW5nIGl0LCB0aGUKb3B0aW9uIHdpbGwgc3RpbGwgYmUgbWFya2VkIGFzIGl0IHdhcyBzZXQgaW4gdGhlIHNhbmRib3guCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMTIuIFRleHRsb2NrCQkJCQkJCSp0ZXh0bG9jayoKCkluIGEgZmV3IHNpdHVhdGlvbnMgaXQgaXMgbm90IGFsbG93ZWQgdG8gY2hhbmdlIHRoZSB0ZXh0IGluIHRoZSBidWZmZXIsIGp1bXAKdG8gYW5vdGhlciB3aW5kb3cgYW5kIHNvbWUgb3RoZXIgdGhpbmdzIHRoYXQgbWlnaHQgY29uZnVzZSBvciBicmVhayB3aGF0IFZpbQppcyBjdXJyZW50bHkgZG9pbmcuICBUaGlzIG1vc3RseSBhcHBsaWVzIHRvIHRoaW5ncyB0aGF0IGhhcHBlbiB3aGVuIFZpbSBpcwphY3R1YWxseSBkb2luZyBzb21ldGhpbmcgZWxzZS4JRm9yIGV4YW1wbGUsIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgbWF5CmhhcHBlbiBhbnkgbW9tZW50IHRoZSBtb3VzZSBjdXJzb3IgaXMgcmVzdGluZyBhdCBzb21lIHBvc2l0aW9uLgoKVGhpcyBpcyBub3QgYWxsb3dlZCB3aGVuIHRoZSB0ZXh0bG9jayBpcyBhY3RpdmU6CgktIGNoYW5naW5nIHRoZSBidWZmZXIgdGV4dAoJLSBqdW1waW5nIHRvIGFub3RoZXIgYnVmZmVyIG9yIHdpbmRvdwoJLSBlZGl0aW5nIGFub3RoZXIgZmlsZQoJLSBjbG9zaW5nIGEgd2luZG93IG9yIHF1aXR0aW5nIFZpbQoJLSBldGMuCgoKIHZpbTp0dz03ODp0cz04OmZ0PWhlbHA6bm9ybDoK