KmV2YWwudHh0KglGb3IgVmltIHZlcnNpb24gNy40LiAgTGFzdCBjaGFuZ2U6IDIwMTYgTWF5IDI0CgoKCQkgIFZJTSBSRUZFUkVOQ0UgTUFOVUFMCSAgYnkgQnJhbSBNb29sZW5hYXIKCgpFeHByZXNzaW9uIGV2YWx1YXRpb24JCQkqZXhwcmVzc2lvbiogKmV4cHIqICpFMTUqICpldmFsKgoKVXNpbmcgZXhwcmVzc2lvbnMgaXMgaW50cm9kdWNlZCBpbiBjaGFwdGVyIDQxIG9mIHRoZSB1c2VyIG1hbnVhbCB8dXNyXzQxLnR4dHwuCgpOb3RlOiBFeHByZXNzaW9uIGV2YWx1YXRpb24gY2FuIGJlIGRpc2FibGVkIGF0IGNvbXBpbGUgdGltZS4gIElmIHRoaXMgaGFzIGJlZW4KZG9uZSwgdGhlIGZlYXR1cmVzIGluIHRoaXMgZG9jdW1lbnQgYXJlIG5vdCBhdmFpbGFibGUuCVNlZSB8K2V2YWx8IGFuZAp8bm8tZXZhbC1mZWF0dXJlfC4KCjEuICBWYXJpYWJsZXMJCQl8dmFyaWFibGVzfAogICAgMS4xIFZhcmlhYmxlIHR5cGVzCiAgICAxLjIgRnVuY3Rpb24gcmVmZXJlbmNlcwkJfEZ1bmNyZWZ8CiAgICAxLjMgTGlzdHMJCQkJfExpc3RzfAogICAgMS40IERpY3Rpb25hcmllcwkJCXxEaWN0aW9uYXJpZXN8CiAgICAxLjUgTW9yZSBhYm91dCB2YXJpYWJsZXMJCXxtb3JlLXZhcmlhYmxlc3wKMi4gIEV4cHJlc3Npb24gc3ludGF4CQl8ZXhwcmVzc2lvbi1zeW50YXh8CjMuICBJbnRlcm5hbCB2YXJpYWJsZQkJfGludGVybmFsLXZhcmlhYmxlc3wKNC4gIEJ1aWx0aW4gRnVuY3Rpb25zCQl8ZnVuY3Rpb25zfAo1LiAgRGVmaW5pbmcgZnVuY3Rpb25zCQl8dXNlci1mdW5jdGlvbnN8CjYuICBDdXJseSBicmFjZXMgbmFtZXMJCXxjdXJseS1icmFjZXMtbmFtZXN8CjcuICBDb21tYW5kcwkJCXxleHByZXNzaW9uLWNvbW1hbmRzfAo4LiAgRXhjZXB0aW9uIGhhbmRsaW5nCQl8ZXhjZXB0aW9uLWhhbmRsaW5nfAo5LiAgRXhhbXBsZXMJCQl8ZXZhbC1leGFtcGxlc3wKMTAuIE5vICtldmFsIGZlYXR1cmUJCXxuby1ldmFsLWZlYXR1cmV8CjExLiBUaGUgc2FuZGJveAkJCXxldmFsLXNhbmRib3h8CjEyLiBUZXh0bG9jawkJCXx0ZXh0bG9ja3wKCntWaSBkb2VzIG5vdCBoYXZlIGFueSBvZiB0aGVzZSBjb21tYW5kc30KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoxLiBWYXJpYWJsZXMJCQkJCQkqdmFyaWFibGVzKgoKMS4xIFZhcmlhYmxlIHR5cGVzIH4KCQkJCQkJCSpFNzEyKgpUaGVyZSBhcmUgbmluZSB0eXBlcyBvZiB2YXJpYWJsZXM6CgpOdW1iZXIJCUEgMzIgb3IgNjQgYml0IHNpZ25lZCBudW1iZXIuICB8ZXhwci1udW1iZXJ8ICpOdW1iZXIqCgkJRXhhbXBsZXM6ICAtMTIzICAweDEwICAwMTc3CgpGbG9hdAkJQSBmbG9hdGluZyBwb2ludCBudW1iZXIuIHxmbG9hdGluZy1wb2ludC1mb3JtYXR8ICpGbG9hdCoKCQl7b25seSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJRXhhbXBsZXM6IDEyMy40NTYgIDEuMTVlLTYgIC0xLjFlMwoKCQkJCQkJCSpFOTI4KgpTdHJpbmcJCUEgTlVMIHRlcm1pbmF0ZWQgc3RyaW5nIG9mIDgtYml0IHVuc2lnbmVkIGNoYXJhY3RlcnMgKGJ5dGVzKS4KCQl8ZXhwci1zdHJpbmd8IEV4YW1wbGVzOiAiYWJcdHh4XCItLSIgICd4LXonJ2EsYycKCkxpc3QJCUFuIG9yZGVyZWQgc2VxdWVuY2Ugb2YgaXRlbXMgfExpc3R8LgoJCUV4YW1wbGU6IFsxLCAyLCBbJ2EnLCAnYiddXQoKRGljdGlvbmFyeQlBbiBhc3NvY2lhdGl2ZSwgdW5vcmRlcmVkIGFycmF5OiBFYWNoIGVudHJ5IGhhcyBhIGtleSBhbmQgYQoJCXZhbHVlLiB8RGljdGlvbmFyeXwKCQlFeGFtcGxlOiB7J2JsdWUnOiAiIzAwMDBmZiIsICdyZWQnOiAiI2ZmMDAwMCJ9CgpGdW5jcmVmCQlBIHJlZmVyZW5jZSB0byBhIGZ1bmN0aW9uIHxGdW5jcmVmfC4KCQlFeGFtcGxlOiBmdW5jdGlvbigic3RybGVuIikKCQlJdCBjYW4gYmUgYm91bmQgdG8gYSBkaWN0aW9uYXJ5IGFuZCBhcmd1bWVudHMsIGl0IHRoZW4gd29ya3MKCQlsaWtlIGEgUGFydGlhbC4KCQlFeGFtcGxlOiBmdW5jdGlvbigiQ2FsbGJhY2siLCBbYXJnXSwgbXlEaWN0KQoKU3BlY2lhbAkJfHY6ZmFsc2V8LCB8djp0cnVlfCwgfHY6bm9uZXwgYW5kIHx2Om51bGx8LiAgKlNwZWNpYWwqCgpKb2IJCVVzZWQgZm9yIGEgam9iLCBzZWUgfGpvYl9zdGFydCgpfC4gKkpvYiogKkpvYnMqCgpDaGFubmVsCQlVc2VkIGZvciBhIGNoYW5uZWwsIHNlZSB8Y2hfb3BlbigpfC4gKkNoYW5uZWwqICpDaGFubmVscyoKClRoZSBOdW1iZXIgYW5kIFN0cmluZyB0eXBlcyBhcmUgY29udmVydGVkIGF1dG9tYXRpY2FsbHksIGRlcGVuZGluZyBvbiBob3cgdGhleQphcmUgdXNlZC4KCkNvbnZlcnNpb24gZnJvbSBhIE51bWJlciB0byBhIFN0cmluZyBpcyBieSBtYWtpbmcgdGhlIEFTQ0lJIHJlcHJlc2VudGF0aW9uIG9mCnRoZSBOdW1iZXIuICBFeGFtcGxlczoKCU51bWJlciAxMjMJLS0+CVN0cmluZyAiMTIzIiB+CglOdW1iZXIgMAktLT4JU3RyaW5nICIwIiB+CglOdW1iZXIgLTEJLS0+CVN0cmluZyAiLTEiIH4KCQkJCQkJCSpvY3RhbCoKQ29udmVyc2lvbiBmcm9tIGEgU3RyaW5nIHRvIGEgTnVtYmVyIGlzIGRvbmUgYnkgY29udmVydGluZyB0aGUgZmlyc3QgZGlnaXRzIHRvCmEgbnVtYmVyLiAgSGV4YWRlY2ltYWwgIjB4ZjkiLCBPY3RhbCAiMDE3IiwgYW5kIEJpbmFyeSAiMGIxMCIgbnVtYmVycyBhcmUKcmVjb2duaXplZC4gIElmIHRoZSBTdHJpbmcgZG9lc24ndCBzdGFydCB3aXRoIGRpZ2l0cywgdGhlIHJlc3VsdCBpcyB6ZXJvLgpFeGFtcGxlczoKCVN0cmluZyAiNDU2IgktLT4JTnVtYmVyIDQ1NiB+CglTdHJpbmcgIjZiYXIiCS0tPglOdW1iZXIgNiB+CglTdHJpbmcgImZvbyIJLS0+CU51bWJlciAwIH4KCVN0cmluZyAiMHhmMSIJLS0+CU51bWJlciAyNDEgfgoJU3RyaW5nICIwMTAwIgktLT4JTnVtYmVyIDY0IH4KCVN0cmluZyAiMGIxMDEiCS0tPglOdW1iZXIgNSB+CglTdHJpbmcgIi04IgktLT4JTnVtYmVyIC04IH4KCVN0cmluZyAiKzgiCS0tPglOdW1iZXIgMCB+CgpUbyBmb3JjZSBjb252ZXJzaW9uIGZyb20gU3RyaW5nIHRvIE51bWJlciwgYWRkIHplcm8gdG8gaXQ6ID4KCTplY2hvICIwMTAwIiArIDAKPAk2NCB+CgpUbyBhdm9pZCBhIGxlYWRpbmcgemVybyB0byBjYXVzZSBvY3RhbCBjb252ZXJzaW9uLCBvciBmb3IgdXNpbmcgYSBkaWZmZXJlbnQKYmFzZSwgdXNlIHxzdHIybnIoKXwuCgpGb3IgYm9vbGVhbiBvcGVyYXRvcnMgTnVtYmVycyBhcmUgdXNlZC4gIFplcm8gaXMgRkFMU0UsIG5vbi16ZXJvIGlzIFRSVUUuCgpOb3RlIHRoYXQgaW4gdGhlIGNvbW1hbmQgPgoJOmlmICJmb28iCiJmb28iIGlzIGNvbnZlcnRlZCB0byAwLCB3aGljaCBtZWFucyBGQUxTRS4gIFRvIHRlc3QgZm9yIGEgbm9uLWVtcHR5IHN0cmluZywKdXNlIGVtcHR5KCk6ID4KCTppZiAhZW1wdHkoImZvbyIpCjwKCQkqRTc0NSogKkU3MjgqICpFNzAzKiAqRTcyOSogKkU3MzAqICpFNzMxKiAqRTkwOCogKkU5MTAqICpFOTEzKgpMaXN0LCBEaWN0aW9uYXJ5LCBGdW5jcmVmIGFuZCBKb2IgdHlwZXMgYXJlIG5vdCBhdXRvbWF0aWNhbGx5IGNvbnZlcnRlZC4KCgkJCQkJCQkqRTgwNSogKkU4MDYqICpFODA4KgpXaGVuIG1peGluZyBOdW1iZXIgYW5kIEZsb2F0IHRoZSBOdW1iZXIgaXMgY29udmVydGVkIHRvIEZsb2F0LglPdGhlcndpc2UKdGhlcmUgaXMgbm8gYXV0b21hdGljIGNvbnZlcnNpb24gb2YgRmxvYXQuICBZb3UgY2FuIHVzZSBzdHIyZmxvYXQoKSBmb3IgU3RyaW5nCnRvIEZsb2F0LCBwcmludGYoKSBmb3IgRmxvYXQgdG8gU3RyaW5nIGFuZCBmbG9hdDJucigpIGZvciBGbG9hdCB0byBOdW1iZXIuCgoJCQkqRTg5MSogKkU4OTIqICpFODkzKiAqRTg5NCogKkU5MDcqICpFOTExKiAqRTkxNCoKV2hlbiBleHBlY3RpbmcgYSBGbG9hdCBhIE51bWJlciBjYW4gYWxzbyBiZSB1c2VkLCBidXQgbm90aGluZyBlbHNlLgoKCQkJCQkJKm5vLXR5cGUtY2hlY2tpbmcqCllvdSB3aWxsIG5vdCBnZXQgYW4gZXJyb3IgaWYgeW91IHRyeSB0byBjaGFuZ2UgdGhlIHR5cGUgb2YgYSB2YXJpYWJsZS4KCgoxLjIgRnVuY3Rpb24gcmVmZXJlbmNlcyB+CgkJCQkJKkZ1bmNyZWYqICpFNjk1KiAqRTcxOCoKQSBGdW5jcmVmIHZhcmlhYmxlIGlzIG9idGFpbmVkIHdpdGggdGhlIHxmdW5jdGlvbigpfCBmdW5jdGlvbi4JSXQgY2FuIGJlIHVzZWQKaW4gYW4gZXhwcmVzc2lvbiBpbiB0aGUgcGxhY2Ugb2YgYSBmdW5jdGlvbiBuYW1lLCBiZWZvcmUgdGhlIHBhcmVudGhlc2lzCmFyb3VuZCB0aGUgYXJndW1lbnRzLCB0byBpbnZva2UgdGhlIGZ1bmN0aW9uIGl0IHJlZmVycyB0by4gIEV4YW1wbGU6ID4KCgk6bGV0IEZuID0gZnVuY3Rpb24oIk15RnVuYyIpCgk6ZWNobyBGbigpCjwJCQkJCQkJKkU3MDQqICpFNzA1KiAqRTcwNyoKQSBGdW5jcmVmIHZhcmlhYmxlIG11c3Qgc3RhcnQgd2l0aCBhIGNhcGl0YWwsICJzOiIsICJ3OiIsICJ0OiIgb3IgImI6Ii4gIFlvdQpjYW4gdXNlICJnOiIgYnV0IHRoZSBmb2xsb3dpbmcgbmFtZSBtdXN0IHN0aWxsIHN0YXJ0IHdpdGggYSBjYXBpdGFsLiAgWW91CmNhbm5vdCBoYXZlIGJvdGggYSBGdW5jcmVmIHZhcmlhYmxlIGFuZCBhIGZ1bmN0aW9uIHdpdGggdGhlIHNhbWUgbmFtZS4KCkEgc3BlY2lhbCBjYXNlIGlzIGRlZmluaW5nIGEgZnVuY3Rpb24gYW5kIGRpcmVjdGx5IGFzc2lnbmluZyBpdHMgRnVuY3JlZiB0byBhCkRpY3Rpb25hcnkgZW50cnkuICBFeGFtcGxlOiA+Cgk6ZnVuY3Rpb24gZGljdC5pbml0KCkgZGljdAoJOiAgIGxldCBzZWxmLnZhbCA9IDAKCTplbmRmdW5jdGlvbgoKVGhlIGtleSBvZiB0aGUgRGljdGlvbmFyeSBjYW4gc3RhcnQgd2l0aCBhIGxvd2VyIGNhc2UgbGV0dGVyLiAgVGhlIGFjdHVhbApmdW5jdGlvbiBuYW1lIGlzIG5vdCB1c2VkIGhlcmUuICBBbHNvIHNlZSB8bnVtYmVyZWQtZnVuY3Rpb258LgoKQSBGdW5jcmVmIGNhbiBhbHNvIGJlIHVzZWQgd2l0aCB0aGUgfDpjYWxsfCBjb21tYW5kOiA+Cgk6Y2FsbCBGbigpCgk6Y2FsbCBkaWN0LmluaXQoKQoKVGhlIG5hbWUgb2YgdGhlIHJlZmVyZW5jZWQgZnVuY3Rpb24gY2FuIGJlIG9idGFpbmVkIHdpdGggfHN0cmluZygpfC4gPgoJOmxldCBmdW5jID0gc3RyaW5nKEZuKQoKWW91IGNhbiB1c2UgfGNhbGwoKXwgdG8gaW52b2tlIGEgRnVuY3JlZiBhbmQgdXNlIGEgbGlzdCB2YXJpYWJsZSBmb3IgdGhlCmFyZ3VtZW50czogPgoJOmxldCByID0gY2FsbChGbiwgbXlsaXN0KQo8CgkJCQkJCQkJKlBhcnRpYWwqCkEgRnVuY3JlZiBvcHRpb25hbGx5IGJpbmRzIGEgRGljdGlvbmFyeSBhbmQvb3IgYXJndW1lbnRzLiAgVGhpcyBpcyBhbHNvIGNhbGxlZAphIFBhcnRpYWwuICBUaGlzIGlzIGNyZWF0ZWQgYnkgcGFzc2luZyB0aGUgRGljdGlvbmFyeSBhbmQvb3IgYXJndW1lbnRzIHRvCmZ1bmN0aW9uKCkuICBXaGVuIGNhbGxpbmcgdGhlIGZ1bmN0aW9uIHRoZSBEaWN0aW9uYXJ5IGFuZC9vciBhcmd1bWVudHMgd2lsbCBiZQpwYXNzZWQgdG8gdGhlIGZ1bmN0aW9uLiAgRXhhbXBsZTogPgoKCWxldCBDYiA9IGZ1bmN0aW9uKCdDYWxsYmFjaycsIFsnZm9vJ10sIG15RGljdCkKCWNhbGwgQ2IoKQoKVGhpcyB3aWxsIGludm9rZSB0aGUgZnVuY3Rpb24gYXMgaWYgdXNpbmc6ID4KCWNhbGwgbXlEaWN0LkNhbGxiYWNrKCdmb28nKQoKVGhpcyBpcyB2ZXJ5IHVzZWZ1bCB3aGVuIHBhc3NpbmcgYSBmdW5jdGlvbiBhcm91bmQsIGUuZy4gaW4gdGhlIGFyZ3VtZW50cyBvZgp8Y2hfb3BlbigpfC4KCk5vdGUgdGhhdCBiaW5kaW5nIGEgZnVuY3Rpb24gdG8gYSBEaWN0aW9uYXJ5IGFsc28gaGFwcGVucyB3aGVuIHRoZSBmdW5jdGlvbiBpcwphIG1lbWJlciBvZiB0aGUgRGljdGlvbmFyeTogPgoKCWxldCBteURpY3QubXlGdW5jdGlvbiA9IE15RnVuY3Rpb24KCWNhbGwgbXlEaWN0Lm15RnVuY3Rpb24oKQoKSGVyZSBNeUZ1bmN0aW9uKCkgd2lsbCBnZXQgbXlEaWN0IHBhc3NlZCBhcyAic2VsZiIuICBUaGlzIGhhcHBlbnMgd2hlbiB0aGUKIm15RnVuY3Rpb24iIG1lbWJlciBpcyBhY2Nlc3NlZC4gIFdoZW4gbWFraW5nIGFzc2lnbmluZyAibXlGdW5jdGlvbiIgdG8Kb3RoZXJEaWN0IGFuZCBjYWxsaW5nIGl0LCBpdCB3aWxsIGJlIGJvdW5kIHRvIG90aGVyRGljdDogPgoKCWxldCBvdGhlckRpY3QubXlGdW5jdGlvbiA9IG15RGljdC5teUZ1bmN0aW9uCgljYWxsIG90aGVyRGljdC5teUZ1bmN0aW9uKCkKCk5vdyAic2VsZiIgd2lsbCBiZSAib3RoZXJEaWN0Ii4gIEJ1dCB3aGVuIHRoZSBkaWN0aW9uYXJ5IHdhcyBib3VuZCBleHBsaWNpdGx5CnRoaXMgd29uJ3QgaGFwcGVuOiA+CgoJbGV0IG15RGljdC5teUZ1bmN0aW9uID0gZnVuY3Rpb24oTXlGdW5jdGlvbiwgbXlEaWN0KQoJbGV0IG90aGVyRGljdC5teUZ1bmN0aW9uID0gbXlEaWN0Lm15RnVuY3Rpb24KCWNhbGwgb3RoZXJEaWN0Lm15RnVuY3Rpb24oKQoKSGVyZSAic2VsZiIgd2lsbCBiZSAibXlEaWN0IiwgYmVjYXVzZSBpdCB3YXMgYm91bmQgZXhwbGl0bHkuCgoKMS4zIExpc3RzIH4KCQkJCQkJKmxpc3QqICpMaXN0KiAqTGlzdHMqICpFNjg2KgpBIExpc3QgaXMgYW4gb3JkZXJlZCBzZXF1ZW5jZSBvZiBpdGVtcy4gIEFuIGl0ZW0gY2FuIGJlIG9mIGFueSB0eXBlLiAgSXRlbXMKY2FuIGJlIGFjY2Vzc2VkIGJ5IHRoZWlyIGluZGV4IG51bWJlci4JSXRlbXMgY2FuIGJlIGFkZGVkIGFuZCByZW1vdmVkIGF0IGFueQpwb3NpdGlvbiBpbiB0aGUgc2VxdWVuY2UuCgoKTGlzdCBjcmVhdGlvbiB+CgkJCQkJCQkqRTY5NiogKkU2OTcqCkEgTGlzdCBpcyBjcmVhdGVkIHdpdGggYSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiBpdGVtcyBpbiBzcXVhcmUgYnJhY2tldHMuCkV4YW1wbGVzOiA+Cgk6bGV0IG15bGlzdCA9IFsxLCB0d28sIDMsICJmb3VyIl0KCTpsZXQgZW1wdHlsaXN0ID0gW10KCkFuIGl0ZW0gY2FuIGJlIGFueSBleHByZXNzaW9uLglVc2luZyBhIExpc3QgZm9yIGFuIGl0ZW0gY3JlYXRlcyBhCkxpc3Qgb2YgTGlzdHM6ID4KCTpsZXQgbmVzdGxpc3QgPSBbWzExLCAxMl0sIFsyMSwgMjJdLCBbMzEsIDMyXV0KCkFuIGV4dHJhIGNvbW1hIGFmdGVyIHRoZSBsYXN0IGl0ZW0gaXMgaWdub3JlZC4KCgpMaXN0IGluZGV4IH4KCQkJCQkJCSpsaXN0LWluZGV4KiAqRTY4NCoKQW4gaXRlbSBpbiB0aGUgTGlzdCBjYW4gYmUgYWNjZXNzZWQgYnkgcHV0dGluZyB0aGUgaW5kZXggaW4gc3F1YXJlIGJyYWNrZXRzCmFmdGVyIHRoZSBMaXN0LiAgSW5kZXhlcyBhcmUgemVyby1iYXNlZCwgdGh1cyB0aGUgZmlyc3QgaXRlbSBoYXMgaW5kZXggemVyby4gPgoJOmxldCBpdGVtID0gbXlsaXN0WzBdCQkiIGdldCB0aGUgZmlyc3QgaXRlbTogMQoJOmxldCBpdGVtID0gbXlsaXN0WzJdCQkiIGdldCB0aGUgdGhpcmQgaXRlbTogMwoKV2hlbiB0aGUgcmVzdWx0aW5nIGl0ZW0gaXMgYSBsaXN0IHRoaXMgY2FuIGJlIHJlcGVhdGVkOiA+Cgk6bGV0IGl0ZW0gPSBuZXN0bGlzdFswXVsxXQkiIGdldCB0aGUgZmlyc3QgbGlzdCwgc2Vjb25kIGl0ZW06IDEyCjwKQSBuZWdhdGl2ZSBpbmRleCBpcyBjb3VudGVkIGZyb20gdGhlIGVuZC4gIEluZGV4IC0xIHJlZmVycyB0byB0aGUgbGFzdCBpdGVtIGluCnRoZSBMaXN0LCAtMiB0byB0aGUgbGFzdCBidXQgb25lIGl0ZW0sIGV0Yy4gPgoJOmxldCBsYXN0ID0gbXlsaXN0Wy0xXQkJIiBnZXQgdGhlIGxhc3QgaXRlbTogImZvdXIiCgpUbyBhdm9pZCBhbiBlcnJvciBmb3IgYW4gaW52YWxpZCBpbmRleCB1c2UgdGhlIHxnZXQoKXwgZnVuY3Rpb24uICBXaGVuIGFuIGl0ZW0KaXMgbm90IGF2YWlsYWJsZSBpdCByZXR1cm5zIHplcm8gb3IgdGhlIGRlZmF1bHQgdmFsdWUgeW91IHNwZWNpZnk6ID4KCTplY2hvIGdldChteWxpc3QsIGlkeCkKCTplY2hvIGdldChteWxpc3QsIGlkeCwgIk5PTkUiKQoKCkxpc3QgY29uY2F0ZW5hdGlvbiB+CgpUd28gbGlzdHMgY2FuIGJlIGNvbmNhdGVuYXRlZCB3aXRoIHRoZSAiKyIgb3BlcmF0b3I6ID4KCTpsZXQgbG9uZ2xpc3QgPSBteWxpc3QgKyBbNSwgNl0KCTpsZXQgbXlsaXN0ICs9IFs3LCA4XQoKVG8gcHJlcGVuZCBvciBhcHBlbmQgYW4gaXRlbSB0dXJuIHRoZSBpdGVtIGludG8gYSBsaXN0IGJ5IHB1dHRpbmcgW10gYXJvdW5kCml0LiAgVG8gY2hhbmdlIGEgbGlzdCBpbi1wbGFjZSBzZWUgfGxpc3QtbW9kaWZpY2F0aW9ufCBiZWxvdy4KCgpTdWJsaXN0IH4KCkEgcGFydCBvZiB0aGUgTGlzdCBjYW4gYmUgb2J0YWluZWQgYnkgc3BlY2lmeWluZyB0aGUgZmlyc3QgYW5kIGxhc3QgaW5kZXgsCnNlcGFyYXRlZCBieSBhIGNvbG9uIGluIHNxdWFyZSBicmFja2V0czogPgoJOmxldCBzaG9ydGxpc3QgPSBteWxpc3RbMjotMV0JIiBnZXQgTGlzdCBbMywgImZvdXIiXQoKT21pdHRpbmcgdGhlIGZpcnN0IGluZGV4IGlzIHNpbWlsYXIgdG8gemVyby4gIE9taXR0aW5nIHRoZSBsYXN0IGluZGV4IGlzCnNpbWlsYXIgdG8gLTEuID4KCTpsZXQgZW5kbGlzdCA9IG15bGlzdFsyOl0JIiBmcm9tIGl0ZW0gMiB0byB0aGUgZW5kOiBbMywgImZvdXIiXQoJOmxldCBzaG9ydGxpc3QgPSBteWxpc3RbMjoyXQkiIExpc3Qgd2l0aCBvbmUgaXRlbTogWzNdCgk6bGV0IG90aGVybGlzdCA9IG15bGlzdFs6XQkiIG1ha2UgYSBjb3B5IG9mIHRoZSBMaXN0CgpJZiB0aGUgZmlyc3QgaW5kZXggaXMgYmV5b25kIHRoZSBsYXN0IGl0ZW0gb2YgdGhlIExpc3Qgb3IgdGhlIHNlY29uZCBpdGVtIGlzCmJlZm9yZSB0aGUgZmlyc3QgaXRlbSwgdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBsaXN0LiAgVGhlcmUgaXMgbm8gZXJyb3IKbWVzc2FnZS4KCklmIHRoZSBzZWNvbmQgaW5kZXggaXMgZXF1YWwgdG8gb3IgZ3JlYXRlciB0aGFuIHRoZSBsZW5ndGggb2YgdGhlIGxpc3QgdGhlCmxlbmd0aCBtaW51cyBvbmUgaXMgdXNlZDogPgoJOmxldCBteWxpc3QgPSBbMCwgMSwgMiwgM10KCTplY2hvIG15bGlzdFsyOjhdCQkiIHJlc3VsdDogWzIsIDNdCgpOT1RFOiBteWxpc3RbczplXSBtZWFucyB1c2luZyB0aGUgdmFyaWFibGUgInM6ZSIgYXMgaW5kZXguICBXYXRjaCBvdXQgZm9yCnVzaW5nIGEgc2luZ2xlIGxldHRlciB2YXJpYWJsZSBiZWZvcmUgdGhlICI6Ii4JSW5zZXJ0IGEgc3BhY2Ugd2hlbiBuZWVkZWQ6Cm15bGlzdFtzIDogZV0uCgoKTGlzdCBpZGVudGl0eSB+CgkJCQkJCQkqbGlzdC1pZGVudGl0eSoKV2hlbiB2YXJpYWJsZSAiYWEiIGlzIGEgbGlzdCBhbmQgeW91IGFzc2lnbiBpdCB0byBhbm90aGVyIHZhcmlhYmxlICJiYiIsIGJvdGgKdmFyaWFibGVzIHJlZmVyIHRvIHRoZSBzYW1lIGxpc3QuICBUaHVzIGNoYW5naW5nIHRoZSBsaXN0ICJhYSIgd2lsbCBhbHNvCmNoYW5nZSAiYmIiOiA+Cgk6bGV0IGFhID0gWzEsIDIsIDNdCgk6bGV0IGJiID0gYWEKCTpjYWxsIGFkZChhYSwgNCkKCTplY2hvIGJiCjwJWzEsIDIsIDMsIDRdCgpNYWtpbmcgYSBjb3B5IG9mIGEgbGlzdCBpcyBkb25lIHdpdGggdGhlIHxjb3B5KCl8IGZ1bmN0aW9uLiAgVXNpbmcgWzpdIGFsc28Kd29ya3MsIGFzIGV4cGxhaW5lZCBhYm92ZS4gIFRoaXMgY3JlYXRlcyBhIHNoYWxsb3cgY29weSBvZiB0aGUgbGlzdDogQ2hhbmdpbmcKYSBsaXN0IGl0ZW0gaW4gdGhlIGxpc3Qgd2lsbCBhbHNvIGNoYW5nZSB0aGUgaXRlbSBpbiB0aGUgY29waWVkIGxpc3Q6ID4KCTpsZXQgYWEgPSBbWzEsICdhJ10sIDIsIDNdCgk6bGV0IGJiID0gY29weShhYSkKCTpjYWxsIGFkZChhYSwgNCkKCTpsZXQgYWFbMF1bMV0gPSAnYWFhJwoJOmVjaG8gYWEKPAlbWzEsIGFhYV0sIDIsIDMsIDRdID4KCTplY2hvIGJiCjwJW1sxLCBhYWFdLCAyLCAzXQoKVG8gbWFrZSBhIGNvbXBsZXRlbHkgaW5kZXBlbmRlbnQgbGlzdCB1c2UgfGRlZXBjb3B5KCl8LiAgVGhpcyBhbHNvIG1ha2VzIGEKY29weSBvZiB0aGUgdmFsdWVzIGluIHRoZSBsaXN0LCByZWN1cnNpdmVseS4gIFVwIHRvIGEgaHVuZHJlZCBsZXZlbHMgZGVlcC4KClRoZSBvcGVyYXRvciAiaXMiIGNhbiBiZSB1c2VkIHRvIGNoZWNrIGlmIHR3byB2YXJpYWJsZXMgcmVmZXIgdG8gdGhlIHNhbWUKTGlzdC4gICJpc25vdCIgZG9lcyB0aGUgb3Bwb3NpdGUuICBJbiBjb250cmFzdCAiPT0iIGNvbXBhcmVzIGlmIHR3byBsaXN0cyBoYXZlCnRoZSBzYW1lIHZhbHVlLiA+Cgk6bGV0IGFsaXN0ID0gWzEsIDIsIDNdCgk6bGV0IGJsaXN0ID0gWzEsIDIsIDNdCgk6ZWNobyBhbGlzdCBpcyBibGlzdAo8CTAgPgoJOmVjaG8gYWxpc3QgPT0gYmxpc3QKPAkxCgpOb3RlIGFib3V0IGNvbXBhcmluZyBsaXN0czogVHdvIGxpc3RzIGFyZSBjb25zaWRlcmVkIGVxdWFsIGlmIHRoZXkgaGF2ZSB0aGUKc2FtZSBsZW5ndGggYW5kIGFsbCBpdGVtcyBjb21wYXJlIGVxdWFsLCBhcyB3aXRoIHVzaW5nICI9PSIuICBUaGVyZSBpcyBvbmUKZXhjZXB0aW9uOiBXaGVuIGNvbXBhcmluZyBhIG51bWJlciB3aXRoIGEgc3RyaW5nIHRoZXkgYXJlIGNvbnNpZGVyZWQKZGlmZmVyZW50LiAgVGhlcmUgaXMgbm8gYXV0b21hdGljIHR5cGUgY29udmVyc2lvbiwgYXMgd2l0aCB1c2luZyAiPT0iIG9uCnZhcmlhYmxlcy4gIEV4YW1wbGU6ID4KCWVjaG8gNCA9PSAiNCIKPAkxID4KCWVjaG8gWzRdID09IFsiNCJdCjwJMAoKVGh1cyBjb21wYXJpbmcgTGlzdHMgaXMgbW9yZSBzdHJpY3QgdGhhbiBjb21wYXJpbmcgbnVtYmVycyBhbmQgc3RyaW5ncy4gIFlvdQpjYW4gY29tcGFyZSBzaW1wbGUgdmFsdWVzIHRoaXMgd2F5IHRvbyBieSBwdXR0aW5nIHRoZW0gaW4gYSBsaXN0OiA+CgoJOmxldCBhID0gNQoJOmxldCBiID0gIjUiCgk6ZWNobyBhID09IGIKPAkxID4KCTplY2hvIFthXSA9PSBbYl0KPAkwCgoKTGlzdCB1bnBhY2sgfgoKVG8gdW5wYWNrIHRoZSBpdGVtcyBpbiBhIGxpc3QgdG8gaW5kaXZpZHVhbCB2YXJpYWJsZXMsIHB1dCB0aGUgdmFyaWFibGVzIGluCnNxdWFyZSBicmFja2V0cywgbGlrZSBsaXN0IGl0ZW1zOiA+Cgk6bGV0IFt2YXIxLCB2YXIyXSA9IG15bGlzdAoKV2hlbiB0aGUgbnVtYmVyIG9mIHZhcmlhYmxlcyBkb2VzIG5vdCBtYXRjaCB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSBsaXN0CnRoaXMgcHJvZHVjZXMgYW4gZXJyb3IuICBUbyBoYW5kbGUgYW55IGV4dHJhIGl0ZW1zIGZyb20gdGhlIGxpc3QgYXBwZW5kICI7IgphbmQgYSB2YXJpYWJsZSBuYW1lOiA+Cgk6bGV0IFt2YXIxLCB2YXIyOyByZXN0XSA9IG15bGlzdAoKVGhpcyB3b3JrcyBsaWtlOiA+Cgk6bGV0IHZhcjEgPSBteWxpc3RbMF0KCTpsZXQgdmFyMiA9IG15bGlzdFsxXQoJOmxldCByZXN0ID0gbXlsaXN0WzI6XQoKRXhjZXB0IHRoYXQgdGhlcmUgaXMgbm8gZXJyb3IgaWYgdGhlcmUgYXJlIG9ubHkgdHdvIGl0ZW1zLiAgInJlc3QiIHdpbGwgYmUgYW4KZW1wdHkgbGlzdCB0aGVuLgoKCkxpc3QgbW9kaWZpY2F0aW9uIH4KCQkJCQkJCSpsaXN0LW1vZGlmaWNhdGlvbioKVG8gY2hhbmdlIGEgc3BlY2lmaWMgaXRlbSBvZiBhIGxpc3QgdXNlIHw6bGV0fCB0aGlzIHdheTogPgoJOmxldCBsaXN0WzRdID0gImZvdXIiCgk6bGV0IGxpc3RsaXN0WzBdWzNdID0gaXRlbQoKVG8gY2hhbmdlIHBhcnQgb2YgYSBsaXN0IHlvdSBjYW4gc3BlY2lmeSB0aGUgZmlyc3QgYW5kIGxhc3QgaXRlbSB0byBiZQptb2RpZmllZC4gIFRoZSB2YWx1ZSBtdXN0IGF0IGxlYXN0IGhhdmUgdGhlIG51bWJlciBvZiBpdGVtcyBpbiB0aGUgcmFuZ2U6ID4KCTpsZXQgbGlzdFszOjVdID0gWzMsIDQsIDVdCgpBZGRpbmcgYW5kIHJlbW92aW5nIGl0ZW1zIGZyb20gYSBsaXN0IGlzIGRvbmUgd2l0aCBmdW5jdGlvbnMuICBIZXJlIGFyZSBhIGZldwpleGFtcGxlczogPgoJOmNhbGwgaW5zZXJ0KGxpc3QsICdhJykJCSIgcHJlcGVuZCBpdGVtICdhJwoJOmNhbGwgaW5zZXJ0KGxpc3QsICdhJywgMykJIiBpbnNlcnQgaXRlbSAnYScgYmVmb3JlIGxpc3RbM10KCTpjYWxsIGFkZChsaXN0LCAibmV3IikJCSIgYXBwZW5kIFN0cmluZyBpdGVtCgk6Y2FsbCBhZGQobGlzdCwgWzEsIDJdKQkJIiBhcHBlbmQgYSBMaXN0IGFzIG9uZSBuZXcgaXRlbQoJOmNhbGwgZXh0ZW5kKGxpc3QsIFsxLCAyXSkJIiBleHRlbmQgdGhlIGxpc3Qgd2l0aCB0d28gbW9yZSBpdGVtcwoJOmxldCBpID0gcmVtb3ZlKGxpc3QsIDMpCSIgcmVtb3ZlIGl0ZW0gMwoJOnVubGV0IGxpc3RbM10JCQkiIGlkZW0KCTpsZXQgbCA9IHJlbW92ZShsaXN0LCAzLCAtMSkJIiByZW1vdmUgaXRlbXMgMyB0byBsYXN0IGl0ZW0KCTp1bmxldCBsaXN0WzMgOiBdCQkiIGlkZW0KCTpjYWxsIGZpbHRlcihsaXN0LCAndjp2YWwgIX4gIngiJykgICIgcmVtb3ZlIGl0ZW1zIHdpdGggYW4gJ3gnCgpDaGFuZ2luZyB0aGUgb3JkZXIgb2YgaXRlbXMgaW4gYSBsaXN0OiA+Cgk6Y2FsbCBzb3J0KGxpc3QpCQkiIHNvcnQgYSBsaXN0IGFscGhhYmV0aWNhbGx5Cgk6Y2FsbCByZXZlcnNlKGxpc3QpCQkiIHJldmVyc2UgdGhlIG9yZGVyIG9mIGl0ZW1zCgk6Y2FsbCB1bmlxKHNvcnQobGlzdCkpCQkiIHNvcnQgYW5kIHJlbW92ZSBkdXBsaWNhdGVzCgoKRm9yIGxvb3AgfgoKVGhlIHw6Zm9yfCBsb29wIGV4ZWN1dGVzIGNvbW1hbmRzIGZvciBlYWNoIGl0ZW0gaW4gYSBsaXN0LiAgQSB2YXJpYWJsZSBpcyBzZXQKdG8gZWFjaCBpdGVtIGluIHRoZSBsaXN0IGluIHNlcXVlbmNlLiAgRXhhbXBsZTogPgoJOmZvciBpdGVtIGluIG15bGlzdAoJOiAgIGNhbGwgRG9pdChpdGVtKQoJOmVuZGZvcgoKVGhpcyB3b3JrcyBsaWtlOiA+Cgk6bGV0IGluZGV4ID0gMAoJOndoaWxlIGluZGV4IDwgbGVuKG15bGlzdCkKCTogICBsZXQgaXRlbSA9IG15bGlzdFtpbmRleF0KCTogICA6Y2FsbCBEb2l0KGl0ZW0pCgk6ICAgbGV0IGluZGV4ID0gaW5kZXggKyAxCgk6ZW5kd2hpbGUKCklmIGFsbCB5b3Ugd2FudCB0byBkbyBpcyBtb2RpZnkgZWFjaCBpdGVtIGluIHRoZSBsaXN0IHRoZW4gdGhlIHxtYXAoKXwKZnVuY3Rpb24gd2lsbCBiZSBhIHNpbXBsZXIgbWV0aG9kIHRoYW4gYSBmb3IgbG9vcC4KCkp1c3QgbGlrZSB0aGUgfDpsZXR8IGNvbW1hbmQsIHw6Zm9yfCBhbHNvIGFjY2VwdHMgYSBsaXN0IG9mIHZhcmlhYmxlcy4JVGhpcwpyZXF1aXJlcyB0aGUgYXJndW1lbnQgdG8gYmUgYSBsaXN0IG9mIGxpc3RzLiA+Cgk6Zm9yIFtsbnVtLCBjb2xdIGluIFtbMSwgM10sIFsyLCA4XSwgWzMsIDBdXQoJOiAgIGNhbGwgRG9pdChsbnVtLCBjb2wpCgk6ZW5kZm9yCgpUaGlzIHdvcmtzIGxpa2UgYSB8OmxldHwgY29tbWFuZCBpcyBkb25lIGZvciBlYWNoIGxpc3QgaXRlbS4gIEFnYWluLCB0aGUgdHlwZXMKbXVzdCByZW1haW4gdGhlIHNhbWUgdG8gYXZvaWQgYW4gZXJyb3IuCgpJdCBpcyBhbHNvIHBvc3NpYmxlIHRvIHB1dCByZW1haW5pbmcgaXRlbXMgaW4gYSBMaXN0IHZhcmlhYmxlOiA+Cgk6Zm9yIFtpLCBqOyByZXN0XSBpbiBsaXN0bGlzdAoJOiAgIGNhbGwgRG9pdChpLCBqKQoJOiAgIGlmICFlbXB0eShyZXN0KQoJOiAgICAgIGVjaG8gInJlbWFpbmRlcjogIiAuIHN0cmluZyhyZXN0KQoJOiAgIGVuZGlmCgk6ZW5kZm9yCgoKTGlzdCBmdW5jdGlvbnMgfgoJCQkJCQkqRTcxNCoKRnVuY3Rpb25zIHRoYXQgYXJlIHVzZWZ1bCB3aXRoIGEgTGlzdDogPgoJOmxldCByID0gY2FsbChmdW5jbmFtZSwgbGlzdCkJIiBjYWxsIGEgZnVuY3Rpb24gd2l0aCBhbiBhcmd1bWVudCBsaXN0Cgk6aWYgZW1wdHkobGlzdCkJCQkiIGNoZWNrIGlmIGxpc3QgaXMgZW1wdHkKCTpsZXQgbCA9IGxlbihsaXN0KQkJIiBudW1iZXIgb2YgaXRlbXMgaW4gbGlzdAoJOmxldCBiaWcgPSBtYXgobGlzdCkJCSIgbWF4aW11bSB2YWx1ZSBpbiBsaXN0Cgk6bGV0IHNtYWxsID0gbWluKGxpc3QpCQkiIG1pbmltdW0gdmFsdWUgaW4gbGlzdAoJOmxldCB4cyA9IGNvdW50KGxpc3QsICd4JykJIiBjb3VudCBuciBvZiB0aW1lcyAneCcgYXBwZWFycyBpbiBsaXN0Cgk6bGV0IGkgPSBpbmRleChsaXN0LCAneCcpCSIgaW5kZXggb2YgZmlyc3QgJ3gnIGluIGxpc3QKCTpsZXQgbGluZXMgPSBnZXRsaW5lKDEsIDEwKQkiIGdldCB0ZW4gdGV4dCBsaW5lcyBmcm9tIGJ1ZmZlcgoJOmNhbGwgYXBwZW5kKCckJywgbGluZXMpCSIgYXBwZW5kIHRleHQgbGluZXMgaW4gYnVmZmVyCgk6bGV0IGxpc3QgPSBzcGxpdCgiYSBiIGMiKQkiIGNyZWF0ZSBsaXN0IGZyb20gaXRlbXMgaW4gYSBzdHJpbmcKCTpsZXQgc3RyaW5nID0gam9pbihsaXN0LCAnLCAnKQkiIGNyZWF0ZSBzdHJpbmcgZnJvbSBsaXN0IGl0ZW1zCgk6bGV0IHMgPSBzdHJpbmcobGlzdCkJCSIgU3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIGxpc3QKCTpjYWxsIG1hcChsaXN0LCAnIj4+ICIgLiB2OnZhbCcpICAiIHByZXBlbmQgIj4+ICIgdG8gZWFjaCBpdGVtCgpEb24ndCBmb3JnZXQgdGhhdCBhIGNvbWJpbmF0aW9uIG9mIGZlYXR1cmVzIGNhbiBtYWtlIHRoaW5ncyBzaW1wbGUuICBGb3IKZXhhbXBsZSwgdG8gYWRkIHVwIGFsbCB0aGUgbnVtYmVycyBpbiBhIGxpc3Q6ID4KCTpleGUgJ2xldCBzdW0gPSAnIC4gam9pbihucmxpc3QsICcrJykKCgoxLjQgRGljdGlvbmFyaWVzIH4KCQkJCQkqZGljdCogKkRpY3Rpb25hcmllcyogKkRpY3Rpb25hcnkqCkEgRGljdGlvbmFyeSBpcyBhbiBhc3NvY2lhdGl2ZSBhcnJheTogRWFjaCBlbnRyeSBoYXMgYSBrZXkgYW5kIGEgdmFsdWUuICBUaGUKZW50cnkgY2FuIGJlIGxvY2F0ZWQgd2l0aCB0aGUga2V5LiAgVGhlIGVudHJpZXMgYXJlIHN0b3JlZCB3aXRob3V0IGEgc3BlY2lmaWMKb3JkZXJpbmcuCgoKRGljdGlvbmFyeSBjcmVhdGlvbiB+CgkJCQkJCSpFNzIwKiAqRTcyMSogKkU3MjIqICpFNzIzKgpBIERpY3Rpb25hcnkgaXMgY3JlYXRlZCB3aXRoIGEgY29tbWEgc2VwYXJhdGVkIGxpc3Qgb2YgZW50cmllcyBpbiBjdXJseQpicmFjZXMuICBFYWNoIGVudHJ5IGhhcyBhIGtleSBhbmQgYSB2YWx1ZSwgc2VwYXJhdGVkIGJ5IGEgY29sb24uICBFYWNoIGtleSBjYW4Kb25seSBhcHBlYXIgb25jZS4gIEV4YW1wbGVzOiA+Cgk6bGV0IG15ZGljdCA9IHsxOiAnb25lJywgMjogJ3R3bycsIDM6ICd0aHJlZSd9Cgk6bGV0IGVtcHR5ZGljdCA9IHt9CjwJCQkJCQkJKkU3MTMqICpFNzE2KiAqRTcxNyoKQSBrZXkgaXMgYWx3YXlzIGEgU3RyaW5nLiAgWW91IGNhbiB1c2UgYSBOdW1iZXIsIGl0IHdpbGwgYmUgY29udmVydGVkIHRvIGEKU3RyaW5nIGF1dG9tYXRpY2FsbHkuICBUaHVzIHRoZSBTdHJpbmcgJzQnIGFuZCB0aGUgbnVtYmVyIDQgd2lsbCBmaW5kIHRoZSBzYW1lCmVudHJ5LglOb3RlIHRoYXQgdGhlIFN0cmluZyAnMDQnIGFuZCB0aGUgTnVtYmVyIDA0IGFyZSBkaWZmZXJlbnQsIHNpbmNlIHRoZQpOdW1iZXIgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gdGhlIFN0cmluZyAnNCcuICBUaGUgZW1wdHkgc3RyaW5nIGNhbiBiZSB1c2VkIGFzIGEKa2V5LgoKQSB2YWx1ZSBjYW4gYmUgYW55IGV4cHJlc3Npb24uCVVzaW5nIGEgRGljdGlvbmFyeSBmb3IgYSB2YWx1ZSBjcmVhdGVzIGEKbmVzdGVkIERpY3Rpb25hcnk6ID4KCTpsZXQgbmVzdGRpY3QgPSB7MTogezExOiAnYScsIDEyOiAnYid9LCAyOiB7MjE6ICdjJ319CgpBbiBleHRyYSBjb21tYSBhZnRlciB0aGUgbGFzdCBlbnRyeSBpcyBpZ25vcmVkLgoKCkFjY2Vzc2luZyBlbnRyaWVzIH4KClRoZSBub3JtYWwgd2F5IHRvIGFjY2VzcyBhbiBlbnRyeSBpcyBieSBwdXR0aW5nIHRoZSBrZXkgaW4gc3F1YXJlIGJyYWNrZXRzOiA+Cgk6bGV0IHZhbCA9IG15ZGljdFsib25lIl0KCTpsZXQgbXlkaWN0WyJmb3VyIl0gPSA0CgpZb3UgY2FuIGFkZCBuZXcgZW50cmllcyB0byBhbiBleGlzdGluZyBEaWN0aW9uYXJ5IHRoaXMgd2F5LCB1bmxpa2UgTGlzdHMuCgpGb3Iga2V5cyB0aGF0IGNvbnNpc3QgZW50aXJlbHkgb2YgbGV0dGVycywgZGlnaXRzIGFuZCB1bmRlcnNjb3JlIHRoZSBmb2xsb3dpbmcKZm9ybSBjYW4gYmUgdXNlZCB8ZXhwci1lbnRyeXw6ID4KCTpsZXQgdmFsID0gbXlkaWN0Lm9uZQoJOmxldCBteWRpY3QuZm91ciA9IDQKClNpbmNlIGFuIGVudHJ5IGNhbiBiZSBhbnkgdHlwZSwgYWxzbyBhIExpc3QgYW5kIGEgRGljdGlvbmFyeSwgdGhlIGluZGV4aW5nIGFuZAprZXkgbG9va3VwIGNhbiBiZSByZXBlYXRlZDogPgoJOmVjaG8gZGljdC5rZXlbaWR4XS5rZXkKCgpEaWN0aW9uYXJ5IHRvIExpc3QgY29udmVyc2lvbiB+CgpZb3UgbWF5IHdhbnQgdG8gbG9vcCBvdmVyIHRoZSBlbnRyaWVzIGluIGEgZGljdGlvbmFyeS4JRm9yIHRoaXMgeW91IG5lZWQgdG8KdHVybiB0aGUgRGljdGlvbmFyeSBpbnRvIGEgTGlzdCBhbmQgcGFzcyBpdCB0byB8OmZvcnwuCgpNb3N0IG9mdGVuIHlvdSB3YW50IHRvIGxvb3Agb3ZlciB0aGUga2V5cywgdXNpbmcgdGhlIHxrZXlzKCl8IGZ1bmN0aW9uOiA+Cgk6Zm9yIGtleSBpbiBrZXlzKG15ZGljdCkKCTogICBlY2hvIGtleSAuICc6ICcgLiBteWRpY3Rba2V5XQoJOmVuZGZvcgoKVGhlIExpc3Qgb2Yga2V5cyBpcyB1bnNvcnRlZC4gIFlvdSBtYXkgd2FudCB0byBzb3J0IHRoZW0gZmlyc3Q6ID4KCTpmb3Iga2V5IGluIHNvcnQoa2V5cyhteWRpY3QpKQoKVG8gbG9vcCBvdmVyIHRoZSB2YWx1ZXMgdXNlIHRoZSB8dmFsdWVzKCl8IGZ1bmN0aW9uOiAgPgoJOmZvciB2IGluIHZhbHVlcyhteWRpY3QpCgk6ICAgZWNobyAidmFsdWU6ICIgLiB2Cgk6ZW5kZm9yCgpJZiB5b3Ugd2FudCBib3RoIHRoZSBrZXkgYW5kIHRoZSB2YWx1ZSB1c2UgdGhlIHxpdGVtcygpfCBmdW5jdGlvbi4gIEl0IHJldHVybnMKYSBMaXN0IGluIHdoaWNoIGVhY2ggaXRlbSBpcyBhCUxpc3Qgd2l0aCB0d28gaXRlbXMsIHRoZSBrZXkgYW5kIHRoZSB2YWx1ZTogPgoJOmZvciBba2V5LCB2YWx1ZV0gaW4gaXRlbXMobXlkaWN0KQoJOiAgIGVjaG8ga2V5IC4gJzogJyAuIHZhbHVlCgk6ZW5kZm9yCgoKRGljdGlvbmFyeSBpZGVudGl0eSB+CgkJCQkJCQkqZGljdC1pZGVudGl0eSoKSnVzdCBsaWtlIExpc3RzIHlvdSBuZWVkIHRvIHVzZSB8Y29weSgpfCBhbmQgfGRlZXBjb3B5KCl8IHRvIG1ha2UgYSBjb3B5IG9mIGEKRGljdGlvbmFyeS4gIE90aGVyd2lzZSwgYXNzaWdubWVudCByZXN1bHRzIGluIHJlZmVycmluZyB0byB0aGUgc2FtZQpEaWN0aW9uYXJ5OiA+Cgk6bGV0IG9uZWRpY3QgPSB7J2EnOiAxLCAnYic6IDJ9Cgk6bGV0IGFkaWN0ID0gb25lZGljdAoJOmxldCBhZGljdFsnYSddID0gMTEKCTplY2hvIG9uZWRpY3RbJ2EnXQoJMTEKClR3byBEaWN0aW9uYXJpZXMgY29tcGFyZSBlcXVhbCBpZiBhbGwgdGhlIGtleS12YWx1ZSBwYWlycyBjb21wYXJlIGVxdWFsLiAgRm9yCm1vcmUgaW5mbyBzZWUgfGxpc3QtaWRlbnRpdHl8LgoKCkRpY3Rpb25hcnkgbW9kaWZpY2F0aW9uIH4KCQkJCQkJCSpkaWN0LW1vZGlmaWNhdGlvbioKVG8gY2hhbmdlIGFuIGFscmVhZHkgZXhpc3RpbmcgZW50cnkgb2YgYSBEaWN0aW9uYXJ5LCBvciB0byBhZGQgYSBuZXcgZW50cnksCnVzZSB8OmxldHwgdGhpcyB3YXk6ID4KCTpsZXQgZGljdFs0XSA9ICJmb3VyIgoJOmxldCBkaWN0WydvbmUnXSA9IGl0ZW0KClJlbW92aW5nIGFuIGVudHJ5IGZyb20gYSBEaWN0aW9uYXJ5IGlzIGRvbmUgd2l0aCB8cmVtb3ZlKCl8IG9yIHw6dW5sZXR8LgpUaHJlZSB3YXlzIHRvIHJlbW92ZSB0aGUgZW50cnkgd2l0aCBrZXkgImFhYSIgZnJvbSBkaWN0OiA+Cgk6bGV0IGkgPSByZW1vdmUoZGljdCwgJ2FhYScpCgk6dW5sZXQgZGljdC5hYWEKCTp1bmxldCBkaWN0WydhYWEnXQoKTWVyZ2luZyBhIERpY3Rpb25hcnkgd2l0aCBhbm90aGVyIGlzIGRvbmUgd2l0aCB8ZXh0ZW5kKCl8OiA+Cgk6Y2FsbCBleHRlbmQoYWRpY3QsIGJkaWN0KQpUaGlzIGV4dGVuZHMgYWRpY3Qgd2l0aCBhbGwgZW50cmllcyBmcm9tIGJkaWN0LiAgRHVwbGljYXRlIGtleXMgY2F1c2UgZW50cmllcwppbiBhZGljdCB0byBiZSBvdmVyd3JpdHRlbi4gIEFuIG9wdGlvbmFsIHRoaXJkIGFyZ3VtZW50IGNhbiBjaGFuZ2UgdGhpcy4KTm90ZSB0aGF0IHRoZSBvcmRlciBvZiBlbnRyaWVzIGluIGEgRGljdGlvbmFyeSBpcyBpcnJlbGV2YW50LCB0aHVzIGRvbid0CmV4cGVjdCAiOmVjaG8gYWRpY3QiIHRvIHNob3cgdGhlIGl0ZW1zIGZyb20gYmRpY3QgYWZ0ZXIgdGhlIG9sZGVyIGVudHJpZXMgaW4KYWRpY3QuCgpXZWVkaW5nIG91dCBlbnRyaWVzIGZyb20gYSBEaWN0aW9uYXJ5IGNhbiBiZSBkb25lIHdpdGggfGZpbHRlcigpfDogPgoJOmNhbGwgZmlsdGVyKGRpY3QsICd2OnZhbCA9fiAieCInKQpUaGlzIHJlbW92ZXMgYWxsIGVudHJpZXMgZnJvbSAiZGljdCIgd2l0aCBhIHZhbHVlIG5vdCBtYXRjaGluZyAneCcuCgoKRGljdGlvbmFyeSBmdW5jdGlvbiB+CgkJCQkqRGljdGlvbmFyeS1mdW5jdGlvbiogKnNlbGYqICpFNzI1KiAqRTg2MioKV2hlbiBhIGZ1bmN0aW9uIGlzIGRlZmluZWQgd2l0aCB0aGUgImRpY3QiIGF0dHJpYnV0ZSBpdCBjYW4gYmUgdXNlZCBpbiBhCnNwZWNpYWwgd2F5IHdpdGggYSBkaWN0aW9uYXJ5LglFeGFtcGxlOiA+Cgk6ZnVuY3Rpb24gTXlsZW4oKSBkaWN0Cgk6ICAgcmV0dXJuIGxlbihzZWxmLmRhdGEpCgk6ZW5kZnVuY3Rpb24KCTpsZXQgbXlkaWN0ID0geydkYXRhJzogWzAsIDEsIDIsIDNdLCAnbGVuJzogZnVuY3Rpb24oIk15bGVuIil9Cgk6ZWNobyBteWRpY3QubGVuKCkKClRoaXMgaXMgbGlrZSBhIG1ldGhvZCBpbiBvYmplY3Qgb3JpZW50ZWQgcHJvZ3JhbW1pbmcuICBUaGUgZW50cnkgaW4gdGhlCkRpY3Rpb25hcnkgaXMgYSB8RnVuY3JlZnwuICBUaGUgbG9jYWwgdmFyaWFibGUgInNlbGYiIHJlZmVycyB0byB0aGUgZGljdGlvbmFyeQp0aGUgZnVuY3Rpb24gd2FzIGludm9rZWQgZnJvbS4KCkl0IGlzIGFsc28gcG9zc2libGUgdG8gYWRkIGEgZnVuY3Rpb24gd2l0aG91dCB0aGUgImRpY3QiIGF0dHJpYnV0ZSBhcyBhCkZ1bmNyZWYgdG8gYSBEaWN0aW9uYXJ5LCBidXQgdGhlICJzZWxmIiB2YXJpYWJsZSBpcyBub3QgYXZhaWxhYmxlIHRoZW4uCgoJCQkJKm51bWJlcmVkLWZ1bmN0aW9uKiAqYW5vbnltb3VzLWZ1bmN0aW9uKgpUbyBhdm9pZCB0aGUgZXh0cmEgbmFtZSBmb3IgdGhlIGZ1bmN0aW9uIGl0IGNhbiBiZSBkZWZpbmVkIGFuZCBkaXJlY3RseQphc3NpZ25lZCB0byBhIERpY3Rpb25hcnkgaW4gdGhpcyB3YXk6ID4KCTpsZXQgbXlkaWN0ID0geydkYXRhJzogWzAsIDEsIDIsIDNdfQoJOmZ1bmN0aW9uIG15ZGljdC5sZW4oKQoJOiAgIHJldHVybiBsZW4oc2VsZi5kYXRhKQoJOmVuZGZ1bmN0aW9uCgk6ZWNobyBteWRpY3QubGVuKCkKClRoZSBmdW5jdGlvbiB3aWxsIHRoZW4gZ2V0IGEgbnVtYmVyIGFuZCB0aGUgdmFsdWUgb2YgZGljdC5sZW4gaXMgYSB8RnVuY3JlZnwKdGhhdCByZWZlcmVuY2VzIHRoaXMgZnVuY3Rpb24uCVRoZSBmdW5jdGlvbiBjYW4gb25seSBiZSB1c2VkIHRocm91Z2ggYQp8RnVuY3JlZnwuICBJdCB3aWxsIGF1dG9tYXRpY2FsbHkgYmUgZGVsZXRlZCB3aGVuIHRoZXJlIGlzIG5vIHxGdW5jcmVmfApyZW1haW5pbmcgdGhhdCByZWZlcnMgdG8gaXQuCgpJdCBpcyBub3QgbmVjZXNzYXJ5IHRvIHVzZSB0aGUgImRpY3QiIGF0dHJpYnV0ZSBmb3IgYSBudW1iZXJlZCBmdW5jdGlvbi4KCklmIHlvdSBnZXQgYW4gZXJyb3IgZm9yIGEgbnVtYmVyZWQgZnVuY3Rpb24sIHlvdSBjYW4gZmluZCBvdXQgd2hhdCBpdCBpcyB3aXRoCmEgdHJpY2suICBBc3N1bWluZyB0aGUgZnVuY3Rpb24gaXMgNDIsIHRoZSBjb21tYW5kIGlzOiA+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+PwpzYW1lIGluc3RhbmNlCQlpcwkJaXMjCQlpcz8KZGlmZmVyZW50IGluc3RhbmNlCWlzbm90CQlpc25vdCMJCWlzbm90PwoKRXhhbXBsZXM6CiJhYmMiID09IyAiQWJjIgkgIGV2YWx1YXRlcyB0byAwCiJhYmMiID09PyAiQWJjIgkgIGV2YWx1YXRlcyB0byAxCiJhYmMiID09ICJBYmMiCSAgZXZhbHVhdGVzIHRvIDEgaWYgJ2lnbm9yZWNhc2UnIGlzIHNldCwgMCBvdGhlcndpc2UKCgkJCQkJCQkqRTY5MSogKkU2OTIqCkEgfExpc3R8IGNhbiBvbmx5IGJlIGNvbXBhcmVkIHdpdGggYSB8TGlzdHwgYW5kIG9ubHkgImVxdWFsIiwgIm5vdCBlcXVhbCIgYW5kCiJpcyIgY2FuIGJlIHVzZWQuICBUaGlzIGNvbXBhcmVzIHRoZSB2YWx1ZXMgb2YgdGhlIGxpc3QsIHJlY3Vyc2l2ZWx5LgpJZ25vcmluZyBjYXNlIG1lYW5zIGNhc2UgaXMgaWdub3JlZCB3aGVuIGNvbXBhcmluZyBpdGVtIHZhbHVlcy4KCgkJCQkJCQkqRTczNSogKkU3MzYqCkEgfERpY3Rpb25hcnl8IGNhbiBvbmx5IGJlIGNvbXBhcmVkIHdpdGggYSB8RGljdGlvbmFyeXwgYW5kIG9ubHkgImVxdWFsIiwgIm5vdAplcXVhbCIgYW5kICJpcyIgY2FuIGJlIHVzZWQuICBUaGlzIGNvbXBhcmVzIHRoZSBrZXkvdmFsdWVzIG9mIHRoZSB8RGljdGlvbmFyeXwKcmVjdXJzaXZlbHkuICBJZ25vcmluZyBjYXNlIG1lYW5zIGNhc2UgaXMgaWdub3JlZCB3aGVuIGNvbXBhcmluZyBpdGVtIHZhbHVlcy4KCgkJCQkJCQkqRTY5NCoKQSB8RnVuY3JlZnwgY2FuIG9ubHkgYmUgY29tcGFyZWQgd2l0aCBhIHxGdW5jcmVmfCBhbmQgb25seSAiZXF1YWwiIGFuZCAibm90CmVxdWFsIiBjYW4gYmUgdXNlZC4gIENhc2UgaXMgbmV2ZXIgaWdub3JlZC4gIFdoZXRoZXIgYXJndW1lbnRzIG9yIGEgRGljdGlvbmFyeQphcmUgYm91bmQgKHdpdGggYSBwYXJ0aWFsKSBpcyBpZ25vcmVkLiAgVGhpcyBpcyBzbyB0aGF0IHdoZW4gYSBmdW5jdGlvbiBpcwptYWRlIGEgbWVtYmVyIG9mIGEgRGljdGlvbmFyeSBpdCBpcyBzdGlsbCBjb25zaWRlcmVkIHRvIGJlIHRoZSBzYW1lIGZ1bmN0aW9uLgpUbyBjb21wYXJlIHBhcnRpYWxzIHRvIHNlZSBpZiB0aGV5IGJpbmQgdGhlIHNhbWUgYXJndW1lbnQgYW5kIERpY3Rpb25hcnkKdmFsdWVzIHVzZSBzdHJpbmcoKTogPgoJZWNobyBzdHJpbmcoUGFydGlhbDEpID09IHN0cmluZyhQYXJ0aWFsMikKCldoZW4gdXNpbmcgImlzIiBvciAiaXNub3QiIHdpdGggYSB8TGlzdHwgb3IgYSB8RGljdGlvbmFyeXwgdGhpcyBjaGVja3MgaWYgdGhlCmV4cHJlc3Npb25zIGFyZSByZWZlcnJpbmcgdG8gdGhlIHNhbWUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCBpbnN0YW5jZS4gIEEgY29weQpvZiBhIHxMaXN0fCBpcyBkaWZmZXJlbnQgZnJvbSB0aGUgb3JpZ2luYWwgfExpc3R8LiAgV2hlbiB1c2luZyAiaXMiIHdpdGhvdXQKYSB8TGlzdHwgb3IgYSB8RGljdGlvbmFyeXwgaXQgaXMgZXF1aXZhbGVudCB0byB1c2luZyAiZXF1YWwiLCB1c2luZyAiaXNub3QiCmVxdWl2YWxlbnQgdG8gdXNpbmcgIm5vdCBlcXVhbCIuICBFeGNlcHQgdGhhdCBhIGRpZmZlcmVudCB0eXBlIG1lYW5zIHRoZQp2YWx1ZXMgYXJlIGRpZmZlcmVudDogPgoJZWNobyA0ID09ICc0JwoJMQoJZWNobyA0IGlzICc0JwoJMAoJZWNobyAwIGlzIFtdCgkwCiJpcyMiLyJpc25vdCMiIGFuZCAiaXM/Ii8iaXNub3Q/IiBjYW4gYmUgdXNlZCB0byBtYXRjaCBhbmQgaWdub3JlIGNhc2UuCgpXaGVuIGNvbXBhcmluZyBhIFN0cmluZyB3aXRoIGEgTnVtYmVyLCB0aGUgU3RyaW5nIGlzIGNvbnZlcnRlZCB0byBhIE51bWJlciwKYW5kIHRoZSBjb21wYXJpc29uIGlzIGRvbmUgb24gTnVtYmVycy4JVGhpcyBtZWFucyB0aGF0OiA+CgllY2hvIDAgPT0gJ3gnCgkxCmJlY2F1c2UgJ3gnIGNvbnZlcnRlZCB0byBhIE51bWJlciBpcyB6ZXJvLiAgSG93ZXZlcjogPgoJZWNobyBbMF0gPT0gWyd4J10KCTAKSW5zaWRlIGEgTGlzdCBvciBEaWN0aW9uYXJ5IHRoaXMgY29udmVyc2lvbiBpcyBub3QgdXNlZC4KCldoZW4gY29tcGFyaW5nIHR3byBTdHJpbmdzLCB0aGlzIGlzIGRvbmUgd2l0aCBzdHJjbXAoKSBvciBzdHJpY21wKCkuICBUaGlzCnJlc3VsdHMgaW4gdGhlIG1hdGhlbWF0aWNhbCBkaWZmZXJlbmNlIChjb21wYXJpbmcgYnl0ZSB2YWx1ZXMpLCBub3QKbmVjZXNzYXJpbHkgdGhlIGFscGhhYmV0aWNhbCBkaWZmZXJlbmNlIGluIHRoZSBsb2NhbCBsYW5ndWFnZS4KCldoZW4gdXNpbmcgdGhlIG9wZXJhdG9ycyB3aXRoIGEgdHJhaWxpbmcgJyMnLCBvciB0aGUgc2hvcnQgdmVyc2lvbiBhbmQKJ2lnbm9yZWNhc2UnIGlzIG9mZiwgdGhlIGNvbXBhcmluZyBpcyBkb25lIHdpdGggc3RyY21wKCk6IGNhc2UgbWF0dGVycy4KCldoZW4gdXNpbmcgdGhlIG9wZXJhdG9ycyB3aXRoIGEgdHJhaWxpbmcgJz8nLCBvciB0aGUgc2hvcnQgdmVyc2lvbiBhbmQKJ2lnbm9yZWNhc2UnIGlzIHNldCwgdGhlIGNvbXBhcmluZyBpcyBkb25lIHdpdGggc3RyaWNtcCgpOiBjYXNlIGlzIGlnbm9yZWQuCgonc21hcnRjYXNlJyBpcyBub3QgdXNlZC4KClRoZSAiPX4iIGFuZCAiIX4iIG9wZXJhdG9ycyBtYXRjaCB0aGUgbGVmdGhhbmQgYXJndW1lbnQgd2l0aCB0aGUgcmlnaHRoYW5kCmFyZ3VtZW50LCB3aGljaCBpcyB1c2VkIGFzIGEgcGF0dGVybi4gIFNlZSB8cGF0dGVybnwgZm9yIHdoYXQgYSBwYXR0ZXJuIGlzLgpUaGlzIG1hdGNoaW5nIGlzIGFsd2F5cyBkb25lIGxpa2UgJ21hZ2ljJyB3YXMgc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eSwgbm8KbWF0dGVyIHdoYXQgdGhlIGFjdHVhbCB2YWx1ZSBvZiAnbWFnaWMnIG9yICdjcG9wdGlvbnMnIGlzLiAgVGhpcyBtYWtlcyBzY3JpcHRzCnBvcnRhYmxlLiAgVG8gYXZvaWQgYmFja3NsYXNoZXMgaW4gdGhlIHJlZ2V4cCBwYXR0ZXJuIHRvIGJlIGRvdWJsZWQsIHVzZSBhCnNpbmdsZS1xdW90ZSBzdHJpbmcsIHNlZSB8bGl0ZXJhbC1zdHJpbmd8LgpTaW5jZSBhIHN0cmluZyBpcyBjb25zaWRlcmVkIHRvIGJlIGEgc2luZ2xlIGxpbmUsIGEgbXVsdGktbGluZSBwYXR0ZXJuCihjb250YWluaW5nIFxuLCBiYWNrc2xhc2gtbikgd2lsbCBub3QgbWF0Y2guICBIb3dldmVyLCBhIGxpdGVyYWwgTkwgY2hhcmFjdGVyCmNhbiBiZSBtYXRjaGVkIGxpa2UgYW4gb3JkaW5hcnkgY2hhcmFjdGVyLiAgRXhhbXBsZXM6CgkiZm9vXG5iYXIiID1+ICJcbiIJZXZhbHVhdGVzIHRvIDEKCSJmb29cbmJhciIgPX4gIlxcbiIJZXZhbHVhdGVzIHRvIDAKCgpleHByNSBhbmQgZXhwcjYJCQkJCQkqZXhwcjUqICpleHByNioKLS0tLS0tLS0tLS0tLS0tCmV4cHI2ICsJIGV4cHI2IC4uCU51bWJlciBhZGRpdGlvbiBvciB8TGlzdHwgY29uY2F0ZW5hdGlvbgkqZXhwci0rKgpleHByNiAtCSBleHByNiAuLglOdW1iZXIgc3VidHJhY3Rpb24JCQkqZXhwci0tKgpleHByNiAuCSBleHByNiAuLglTdHJpbmcgY29uY2F0ZW5hdGlvbgkJCSpleHByLS4qCgpGb3IgfExpc3RzfCBvbmx5ICIrIiBpcyBwb3NzaWJsZSBhbmQgdGhlbiBib3RoIGV4cHI2IG11c3QgYmUgYSBsaXN0LiAgVGhlCnJlc3VsdCBpcyBhIG5ldyBsaXN0IHdpdGggdGhlIHR3byBsaXN0cyBDb25jYXRlbmF0ZWQuCgpleHByNyAqCSBleHByNyAuLglOdW1iZXIgbXVsdGlwbGljYXRpb24JCQkqZXhwci1zdGFyKgpleHByNyAvCSBleHByNyAuLglOdW1iZXIgZGl2aXNpb24JCQkJKmV4cHItLyoKZXhwcjcgJQkgZXhwcjcgLi4JTnVtYmVyIG1vZHVsbwkJCQkqZXhwci0lKgoKRm9yIGFsbCwgZXhjZXB0ICIuIiwgU3RyaW5ncyBhcmUgY29udmVydGVkIHRvIE51bWJlcnMuCkZvciBiaXR3aXNlIG9wZXJhdG9ycyBzZWUgfGFuZCgpfCwgfG9yKCl8IGFuZCB8eG9yKCl8LgoKTm90ZSB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuICIrIiBhbmQgIi4iOgoJIjEyMyIgKyAiNDU2IiA9IDU3OQoJIjEyMyIgLiAiNDU2IiA9ICIxMjM0NTYiCgpTaW5jZSAnLicgaGFzIHRoZSBzYW1lIHByZWNlZGVuY2UgYXMgJysnIGFuZCAnLScsIHlvdSBuZWVkIHRvIHJlYWQ6ID4KCTEgLiA5MCArIDkwLjAKQXM6ID4KCSgxIC4gOTApICsgOTAuMApUaGF0IHdvcmtzLCBzaW5jZSB0aGUgU3RyaW5nICIxOTAiIGlzIGF1dG9tYXRpY2FsbHkgY29udmVydGVkIHRvIHRoZSBOdW1iZXIKMTkwLCB3aGljaCBjYW4gYmUgYWRkZWQgdG8gdGhlIEZsb2F0IDkwLjAuICBIb3dldmVyOiA+CgkxIC4gOTAgKiA5MC4wClNob3VsZCBiZSByZWFkIGFzOiA+CgkxIC4gKDkwICogOTAuMCkKU2luY2UgJy4nIGhhcyBsb3dlciBwcmVjZWRlbmNlIHRoYW4gJyonLiAgVGhpcyBkb2VzIE5PVCB3b3JrLCBzaW5jZSB0aGlzCmF0dGVtcHRzIHRvIGNvbmNhdGVuYXRlIGEgRmxvYXQgYW5kIGEgU3RyaW5nLgoKV2hlbiBkaXZpZGluZyBhIE51bWJlciBieSB6ZXJvIHRoZSByZXN1bHQgZGVwZW5kcyBvbiB0aGUgdmFsdWU6CgkgIDAgLyAwICA9IC0weDgwMDAwMDAwCShsaWtlIE5hTiBmb3IgRmxvYXQpCgkgPjAgLyAwICA9ICAweDdmZmZmZmZmCShsaWtlIHBvc2l0aXZlIGluZmluaXR5KQoJIDwwIC8gMCAgPSAtMHg3ZmZmZmZmZgkobGlrZSBuZWdhdGl2ZSBpbmZpbml0eSkKCShiZWZvcmUgVmltIDcuMiBpdCB3YXMgYWx3YXlzIDB4N2ZmZmZmZmYpCgpXaGVuIHRoZSByaWdodGhhbmQgc2lkZSBvZiAnJScgaXMgemVybywgdGhlIHJlc3VsdCBpcyAwLgoKTm9uZSBvZiB0aGVzZSB3b3JrIGZvciB8RnVuY3JlZnxzLgoKLiBhbmQgJSBkbyBub3Qgd29yayBmb3IgRmxvYXQuICpFODA0KgoKCmV4cHI3CQkJCQkJCSpleHByNyoKLS0tLS0KISBleHByNwkJCWxvZ2ljYWwgTk9UCQkqZXhwci0hKgotIGV4cHI3CQkJdW5hcnkgbWludXMJCSpleHByLXVuYXJ5LS0qCisgZXhwcjcJCQl1bmFyeSBwbHVzCQkqZXhwci11bmFyeS0rKgoKRm9yICchJyBub24temVybyBiZWNvbWVzIHplcm8sIHplcm8gYmVjb21lcyBvbmUuCkZvciAnLScgdGhlIHNpZ24gb2YgdGhlIG51bWJlciBpcyBjaGFuZ2VkLgpGb3IgJysnIHRoZSBudW1iZXIgaXMgdW5jaGFuZ2VkLgoKQSBTdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYSBOdW1iZXIgZmlyc3QuCgpUaGVzZSB0aHJlZSBjYW4gYmUgcmVwZWF0ZWQgYW5kIG1peGVkLglFeGFtcGxlczoKCSEtMQkgICAgPT0gMAoJISE4CSAgICA9PSAxCgktLTkJICAgID09IDkKCgpleHByOAkJCQkJCQkqZXhwcjgqCi0tLS0tCmV4cHI4W2V4cHIxXQkJaXRlbSBvZiBTdHJpbmcgb3IgfExpc3R8CSpleHByLVtdKiAqRTExMSoKCQkJCQkJCSpFOTA5KiAqc3Vic2NyaXB0KgpJZiBleHByOCBpcyBhIE51bWJlciBvciBTdHJpbmcgdGhpcyByZXN1bHRzIGluIGEgU3RyaW5nIHRoYXQgY29udGFpbnMgdGhlCmV4cHIxJ3RoIHNpbmdsZSBieXRlIGZyb20gZXhwcjguICBleHByOCBpcyB1c2VkIGFzIGEgU3RyaW5nLCBleHByMSBhcyBhCk51bWJlci4gIFRoaXMgZG9lc24ndCByZWNvZ25pemUgbXVsdGktYnl0ZSBlbmNvZGluZ3MsIHNlZSB8Ynl0ZWlkeCgpfCBmb3IKYW4gYWx0ZXJuYXRpdmUsIG9yIHVzZSBgc3BsaXQoKWAgdG8gdHVybiB0aGUgc3RyaW5nIGludG8gYSBsaXN0IG9mIGNoYXJhY3RlcnMuCgpJbmRleCB6ZXJvIGdpdmVzIHRoZSBmaXJzdCBieXRlLiAgVGhpcyBpcyBsaWtlIGl0IHdvcmtzIGluIEMuICBDYXJlZnVsOgp0ZXh0IGNvbHVtbiBudW1iZXJzIHN0YXJ0IHdpdGggb25lISAgRXhhbXBsZSwgdG8gZ2V0IHRoZSBieXRlIHVuZGVyIHRoZQpjdXJzb3I6ID4KCTpsZXQgYyA9IGdldGxpbmUoIi4iKVtjb2woIi4iKSAtIDFdCgpJZiB0aGUgbGVuZ3RoIG9mIHRoZSBTdHJpbmcgaXMgbGVzcyB0aGFuIHRoZSBpbmRleCwgdGhlIHJlc3VsdCBpcyBhbiBlbXB0eQpTdHJpbmcuICBBIG5lZ2F0aXZlIGluZGV4IGFsd2F5cyByZXN1bHRzIGluIGFuIGVtcHR5IHN0cmluZyAocmVhc29uOiBiYWNrd2FyZApjb21wYXRpYmlsaXR5KS4gIFVzZSBbLTE6XSB0byBnZXQgdGhlIGxhc3QgYnl0ZS4KCklmIGV4cHI4IGlzIGEgfExpc3R8IHRoZW4gaXQgcmVzdWx0cyB0aGUgaXRlbSBhdCBpbmRleCBleHByMS4gIFNlZSB8bGlzdC1pbmRleHwKZm9yIHBvc3NpYmxlIGluZGV4IHZhbHVlcy4gIElmIHRoZSBpbmRleCBpcyBvdXQgb2YgcmFuZ2UgdGhpcyByZXN1bHRzIGluIGFuCmVycm9yLglFeGFtcGxlOiA+Cgk6bGV0IGl0ZW0gPSBteWxpc3RbLTFdCQkiIGdldCBsYXN0IGl0ZW0KCkdlbmVyYWxseSwgaWYgYSB8TGlzdHwgaW5kZXggaXMgZXF1YWwgdG8gb3IgaGlnaGVyIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUKfExpc3R8LCBvciBtb3JlIG5lZ2F0aXZlIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUgfExpc3R8LCB0aGlzIHJlc3VsdHMgaW4gYW4KZXJyb3IuCgoKZXhwcjhbZXhwcjFhIDogZXhwcjFiXQlzdWJzdHJpbmcgb3Igc3VibGlzdAkJKmV4cHItWzpdKgoKSWYgZXhwcjggaXMgYSBOdW1iZXIgb3IgU3RyaW5nIHRoaXMgcmVzdWx0cyBpbiB0aGUgc3Vic3RyaW5nIHdpdGggdGhlIGJ5dGVzCmZyb20gZXhwcjFhIHRvIGFuZCBpbmNsdWRpbmcgZXhwcjFiLiAgZXhwcjggaXMgdXNlZCBhcyBhIFN0cmluZywgZXhwcjFhIGFuZApleHByMWIgYXJlIHVzZWQgYXMgYSBOdW1iZXIuICBUaGlzIGRvZXNuJ3QgcmVjb2duaXplIG11bHRpLWJ5dGUgZW5jb2RpbmdzLCBzZWUKfGJ5dGVpZHgoKXwgZm9yIGNvbXB1dGluZyB0aGUgaW5kZXhlcy4KCklmIGV4cHIxYSBpcyBvbWl0dGVkIHplcm8gaXMgdXNlZC4gIElmIGV4cHIxYiBpcyBvbWl0dGVkIHRoZSBsZW5ndGggb2YgdGhlCnN0cmluZyBtaW51cyBvbmUgaXMgdXNlZC4KCkEgbmVnYXRpdmUgbnVtYmVyIGNhbiBiZSB1c2VkIHRvIG1lYXN1cmUgZnJvbSB0aGUgZW5kIG9mIHRoZSBzdHJpbmcuICAtMSBpcwp0aGUgbGFzdCBjaGFyYWN0ZXIsIC0yIHRoZSBsYXN0IGJ1dCBvbmUsIGV0Yy4KCklmIGFuIGluZGV4IGdvZXMgb3V0IG9mIHJhbmdlIGZvciB0aGUgc3RyaW5nIGNoYXJhY3RlcnMgYXJlIG9taXR0ZWQuICBJZgpleHByMWIgaXMgc21hbGxlciB0aGFuIGV4cHIxYSB0aGUgcmVzdWx0IGlzIGFuIGVtcHR5IHN0cmluZy4KCkV4YW1wbGVzOiA+Cgk6bGV0IGMgPSBuYW1lWy0xOl0JCSIgbGFzdCBieXRlIG9mIGEgc3RyaW5nCgk6bGV0IGMgPSBuYW1lWy0yOi0yXQkJIiBsYXN0IGJ1dCBvbmUgYnl0ZSBvZiBhIHN0cmluZwoJOmxldCBzID0gbGluZSgiLiIpWzQ6XQkJIiBmcm9tIHRoZSBmaWZ0aCBieXRlIHRvIHRoZSBlbmQKCTpsZXQgcyA9IHNbOi0zXQkJCSIgcmVtb3ZlIGxhc3QgdHdvIGJ5dGVzCjwKCQkJCQkJCSpzdWJsaXN0KiAqc2xpY2UqCklmIGV4cHI4IGlzIGEgfExpc3R8IHRoaXMgcmVzdWx0cyBpbiBhIG5ldyB8TGlzdHwgd2l0aCB0aGUgaXRlbXMgaW5kaWNhdGVkIGJ5CnRoZSBpbmRleGVzIGV4cHIxYSBhbmQgZXhwcjFiLglUaGlzIHdvcmtzIGxpa2Ugd2l0aCBhIFN0cmluZywgYXMgZXhwbGFpbmVkCmp1c3QgYWJvdmUsIGV4Y2VwdCB0aGF0IGluZGV4ZXMgb3V0IG9mIHJhbmdlIGNhdXNlIGFuIGVycm9yLiAgRXhhbXBsZXM6ID4KCTpsZXQgbCA9IG15bGlzdFs6M10JCSIgZmlyc3QgZm91ciBpdGVtcwoJOmxldCBsID0gbXlsaXN0WzQ6NF0JCSIgTGlzdCB3aXRoIG9uZSBpdGVtCgk6bGV0IGwgPSBteWxpc3RbOl0JCSIgc2hhbGxvdyBjb3B5IG9mIGEgTGlzdAoKVXNpbmcgZXhwcjhbZXhwcjFdIG9yIGV4cHI4W2V4cHIxYSA6IGV4cHIxYl0gb24gYSB8RnVuY3JlZnwgcmVzdWx0cyBpbiBhbgplcnJvci4KCldhdGNoIG91dCBmb3IgY29uZnVzaW9uIGJldHdlZW4gYSBuYW1lc3BhY2UgYW5kIGEgdmFyaWFibGUgZm9sbG93ZWQgYnkgYSBjb2xvbgpmb3IgYSBzdWJsaXN0OiA+CglteWxpc3RbbjpdICAgICAiIHVzZXMgdmFyaWFibGUgbgoJbXlsaXN0W3M6XSAgICAgIiB1c2VzIG5hbWVzcGFjZSBzOiwgZXJyb3IhCgoKZXhwcjgubmFtZQkJZW50cnkgaW4gYSB8RGljdGlvbmFyeXwJCSpleHByLWVudHJ5KgoKSWYgZXhwcjggaXMgYSB8RGljdGlvbmFyeXwgYW5kIGl0IGlzIGZvbGxvd2VkIGJ5IGEgZG90LCB0aGVuIHRoZSBmb2xsb3dpbmcKbmFtZSB3aWxsIGJlIHVzZWQgYXMgYSBrZXkgaW4gdGhlIHxEaWN0aW9uYXJ5fC4gIFRoaXMgaXMganVzdCBsaWtlOgpleHByOFtuYW1lXS4KClRoZSBuYW1lIG11c3QgY29uc2lzdCBvZiBhbHBoYW51bWVyaWMgY2hhcmFjdGVycywganVzdCBsaWtlIGEgdmFyaWFibGUgbmFtZSwKYnV0IGl0IG1heSBzdGFydCB3aXRoIGEgbnVtYmVyLiAgQ3VybHkgYnJhY2VzIGNhbm5vdCBiZSB1c2VkLgoKVGhlcmUgbXVzdCBub3QgYmUgd2hpdGUgc3BhY2UgYmVmb3JlIG9yIGFmdGVyIHRoZSBkb3QuCgpFeGFtcGxlczogPgoJOmxldCBkaWN0ID0geyJvbmUiOiAxLCAyOiAidHdvIn0KCTplY2hvIGRpY3Qub25lCgk6ZWNobyBkaWN0IC4yCgpOb3RlIHRoYXQgdGhlIGRvdCBpcyBhbHNvIHVzZWQgZm9yIFN0cmluZyBjb25jYXRlbmF0aW9uLiAgVG8gYXZvaWQgY29uZnVzaW9uCmFsd2F5cyBwdXQgc3BhY2VzIGFyb3VuZCB0aGUgZG90IGZvciBTdHJpbmcgY29uY2F0ZW5hdGlvbi4KCgpleHByOChleHByMSwgLi4uKQl8RnVuY3JlZnwgZnVuY3Rpb24gY2FsbAoKV2hlbiBleHByOCBpcyBhIHxGdW5jcmVmfCB0eXBlIHZhcmlhYmxlLCBpbnZva2UgdGhlIGZ1bmN0aW9uIGl0IHJlZmVycyB0by4KCgoKCQkJCQkJCSpleHByOSoKbnVtYmVyCi0tLS0tLQpudW1iZXIJCQludW1iZXIgY29uc3RhbnQJCQkqZXhwci1udW1iZXIqIAoJCQkJCQkqaGV4LW51bWJlciogKm9jdGFsLW51bWJlcioKCkRlY2ltYWwsIEhleGFkZWNpbWFsIChzdGFydGluZyB3aXRoIDB4IG9yIDBYKSwgb3IgT2N0YWwgKHN0YXJ0aW5nIHdpdGggMCkuCgoJCQkJCQkqZmxvYXRpbmctcG9pbnQtZm9ybWF0KgpGbG9hdGluZyBwb2ludCBudW1iZXJzIGNhbiBiZSB3cml0dGVuIGluIHR3byBmb3JtczoKCglbLStde059LntNfQoJWy0rXXtOfS57TX1bZUVdWy0rXXtleHB9Cgp7Tn0gYW5kIHtNfSBhcmUgbnVtYmVycy4gIEJvdGgge059IGFuZCB7TX0gbXVzdCBiZSBwcmVzZW50IGFuZCBjYW4gb25seQpjb250YWluIGRpZ2l0cy4KWy0rXSBtZWFucyB0aGVyZSBpcyBhbiBvcHRpb25hbCBwbHVzIG9yIG1pbnVzIHNpZ24uCntleHB9IGlzIHRoZSBleHBvbmVudCwgcG93ZXIgb2YgMTAuCk9ubHkgYSBkZWNpbWFsIHBvaW50IGlzIGFjY2VwdGVkLCBub3QgYSBjb21tYS4JTm8gbWF0dGVyIHdoYXQgdGhlIGN1cnJlbnQKbG9jYWxlIGlzLgp7b25seSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgpFeGFtcGxlczoKCTEyMy40NTYKCSswLjAwMDEKCTU1LjAKCS0wLjEyMwoJMS4yMzRlMDMKCTEuMEUtNgoJLTMuMTQxNmUrODgKClRoZXNlIGFyZSBJTlZBTElEOgoJMy4JCWVtcHR5IHtNfQoJMWU0MAkJbWlzc2luZyAue019CgoJCQkJCQkJKmZsb2F0LXBpKiAqZmxvYXQtZSoKQSBmZXcgdXNlZnVsIHZhbHVlcyB0byBjb3B5JnBhc3RlOiA+Cgk6bGV0IHBpID0gMy4xNDE1OTI2NTM1OQoJOmxldCBlICA9IDIuNzE4MjgxODI4NDYKClJhdGlvbmFsZToKQmVmb3JlIGZsb2F0aW5nIHBvaW50IHdhcyBpbnRyb2R1Y2VkLCB0aGUgdGV4dCAiMTIzLjQ1NiIgd2FzIGludGVycHJldGVkIGFzCnRoZSB0d28gbnVtYmVycyAiMTIzIiBhbmQgIjQ1NiIsIGJvdGggY29udmVydGVkIHRvIGEgc3RyaW5nIGFuZCBjb25jYXRlbmF0ZWQsCnJlc3VsdGluZyBpbiB0aGUgc3RyaW5nICIxMjM0NTYiLiAgU2luY2UgdGhpcyB3YXMgY29uc2lkZXJlZCBwb2ludGxlc3MsIGFuZCB3ZQpjb3VsZCBub3QgZmluZCBpdCBpbnRlbnRpb25hbGx5IGJlaW5nIHVzZWQgaW4gVmltIHNjcmlwdHMsIHRoaXMgYmFja3dhcmRzCmluY29tcGF0aWJpbGl0eSB3YXMgYWNjZXB0ZWQgaW4gZmF2b3Igb2YgYmVpbmcgYWJsZSB0byB1c2UgdGhlIG5vcm1hbCBub3RhdGlvbgpmb3IgZmxvYXRpbmcgcG9pbnQgbnVtYmVycy4KCgkJCQkJCSpmbG9hdGluZy1wb2ludC1wcmVjaXNpb24qClRoZSBwcmVjaXNpb24gYW5kIHJhbmdlIG9mIGZsb2F0aW5nIHBvaW50cyBudW1iZXJzIGRlcGVuZHMgb24gd2hhdCAiZG91YmxlIgptZWFucyBpbiB0aGUgbGlicmFyeSBWaW0gd2FzIGNvbXBpbGVkIHdpdGguICBUaGVyZSBpcyBubyB3YXkgdG8gY2hhbmdlIHRoaXMgYXQKcnVudGltZS4KClRoZSBkZWZhdWx0IGZvciBkaXNwbGF5aW5nIGEgfEZsb2F0fCBpcyB0byB1c2UgNiBkZWNpbWFsIHBsYWNlcywgbGlrZSB1c2luZwpwcmludGYoIiVnIiwgZikuICBZb3UgY2FuIHNlbGVjdCBzb21ldGhpbmcgZWxzZSB3aGVuIHVzaW5nIHRoZSB8cHJpbnRmKCl8CmZ1bmN0aW9uLiAgRXhhbXBsZTogPgoJOmVjaG8gcHJpbnRmKCclLjE1ZScsIGF0YW4oMSkpCjwJNy44NTM5ODE2MzM5NzQ0ODNlLTAxCgoKCnN0cmluZwkJCQkJKnN0cmluZyogKlN0cmluZyogKmV4cHItc3RyaW5nKiAqRTExNCoKLS0tLS0tCiJzdHJpbmciCQlzdHJpbmcgY29uc3RhbnQJCSpleHByLXF1b3RlKgoKTm90ZSB0aGF0IGRvdWJsZSBxdW90ZXMgYXJlIHVzZWQuCgpBIHN0cmluZyBjb25zdGFudCBhY2NlcHRzIHRoZXNlIHNwZWNpYWwgY2hhcmFjdGVyczoKXC4uLgl0aHJlZS1kaWdpdCBvY3RhbCBudW1iZXIgKGUuZy4sICJcMzE2IikKXC4uCXR3by1kaWdpdCBvY3RhbCBudW1iZXIgKG11c3QgYmUgZm9sbG93ZWQgYnkgbm9uLWRpZ2l0KQpcLglvbmUtZGlnaXQgb2N0YWwgbnVtYmVyIChtdXN0IGJlIGZvbGxvd2VkIGJ5IG5vbi1kaWdpdCkKXHguLglieXRlIHNwZWNpZmllZCB3aXRoIHR3byBoZXggbnVtYmVycyAoZS5nLiwgIlx4MWYiKQpceC4JYnl0ZSBzcGVjaWZpZWQgd2l0aCBvbmUgaGV4IG51bWJlciAobXVzdCBiZSBmb2xsb3dlZCBieSBub24taGV4IGNoYXIpClxYLi4Jc2FtZSBhcyBceC4uClxYLglzYW1lIGFzIFx4LgpcdS4uLi4JY2hhcmFjdGVyIHNwZWNpZmllZCB3aXRoIHVwIHRvIDQgaGV4IG51bWJlcnMsIHN0b3JlZCBhY2NvcmRpbmcgdG8gdGhlCgljdXJyZW50IHZhbHVlIG9mICdlbmNvZGluZycgKGUuZy4sICJcdTAyYTQiKQpcVS4uLi4Jc2FtZSBhcyBcdSBidXQgYWxsb3dzIHVwIHRvIDggaGV4IG51bWJlcnMuClxiCWJhY2tzcGFjZSA8QlM+ClxlCWVzY2FwZSA8RXNjPgpcZglmb3JtZmVlZCA8RkY+ClxuCW5ld2xpbmUgPE5MPgpccglyZXR1cm4gPENSPgpcdAl0YWIgPFRhYj4KXFwJYmFja3NsYXNoClwiCWRvdWJsZSBxdW90ZQpcPHh4eD4JU3BlY2lhbCBrZXkgbmFtZWQgInh4eCIuICBlLmcuICJcPEMtVz4iIGZvciBDVFJMLVcuICBUaGlzIGlzIGZvciB1c2UKCWluIG1hcHBpbmdzLCB0aGUgMHg4MCBieXRlIGlzIGVzY2FwZWQuICBEb24ndCB1c2UgPENoYXIteHh4eD4gdG8gZ2V0IGEKCXV0Zi04IGNoYXJhY3RlciwgdXNlIFx1eHh4eCBhcyBtZW50aW9uZWQgYWJvdmUuCgpOb3RlIHRoYXQgIlx4ZmYiIGlzIHN0b3JlZCBhcyB0aGUgYnl0ZSAyNTUsIHdoaWNoIG1heSBiZSBpbnZhbGlkIGluIHNvbWUKZW5jb2RpbmdzLiAgVXNlICJcdTAwZmYiIHRvIHN0b3JlIGNoYXJhY3RlciAyNTUgYWNjb3JkaW5nIHRvIHRoZSBjdXJyZW50IHZhbHVlCm9mICdlbmNvZGluZycuCgpOb3RlIHRoYXQgIlwwMDAiIGFuZCAiXHgwMCIgZm9yY2UgdGhlIGVuZCBvZiB0aGUgc3RyaW5nLgoKCmxpdGVyYWwtc3RyaW5nCQkJCQkJKmxpdGVyYWwtc3RyaW5nKiAqRTExNSoKLS0tLS0tLS0tLS0tLS0tCidzdHJpbmcnCQlzdHJpbmcgY29uc3RhbnQJCQkqZXhwci0nKgoKTm90ZSB0aGF0IHNpbmdsZSBxdW90ZXMgYXJlIHVzZWQuCgpUaGlzIHN0cmluZyBpcyB0YWtlbiBhcyBpdCBpcy4JTm8gYmFja3NsYXNoZXMgYXJlIHJlbW92ZWQgb3IgaGF2ZSBhIHNwZWNpYWwKbWVhbmluZy4gIFRoZSBvbmx5IGV4Y2VwdGlvbiBpcyB0aGF0IHR3byBxdW90ZXMgc3RhbmQgZm9yIG9uZSBxdW90ZS4KClNpbmdsZSBxdW90ZWQgc3RyaW5ncyBhcmUgdXNlZnVsIGZvciBwYXR0ZXJucywgc28gdGhhdCBiYWNrc2xhc2hlcyBkbyBub3QgbmVlZAp0byBiZSBkb3VibGVkLglUaGVzZSB0d28gY29tbWFuZHMgYXJlIGVxdWl2YWxlbnQ6ID4KCWlmIGEgPX4gIlxccyoiCglpZiBhID1+ICdccyonCgoKb3B0aW9uCQkJCQkJKmV4cHItb3B0aW9uKiAqRTExMiogKkUxMTMqCi0tLS0tLQomb3B0aW9uCQkJb3B0aW9uIHZhbHVlLCBsb2NhbCB2YWx1ZSBpZiBwb3NzaWJsZQomZzpvcHRpb24JCWdsb2JhbCBvcHRpb24gdmFsdWUKJmw6b3B0aW9uCQlsb2NhbCBvcHRpb24gdmFsdWUKCkV4YW1wbGVzOiA+CgllY2hvICJ0YWJzdG9wIGlzICIgLiAmdGFic3RvcAoJaWYgJmluc2VydG1vZGUKCkFueSBvcHRpb24gbmFtZSBjYW4gYmUgdXNlZCBoZXJlLiAgU2VlIHxvcHRpb25zfC4gIFdoZW4gdXNpbmcgdGhlIGxvY2FsIHZhbHVlCmFuZCB0aGVyZSBpcyBubyBidWZmZXItbG9jYWwgb3Igd2luZG93LWxvY2FsIHZhbHVlLCB0aGUgZ2xvYmFsIHZhbHVlIGlzIHVzZWQKYW55d2F5LgoKCnJlZ2lzdGVyCQkJCQkJKmV4cHItcmVnaXN0ZXIqICpAcioKLS0tLS0tLS0KQHIJCQljb250ZW50cyBvZiByZWdpc3RlciAncicKClRoZSByZXN1bHQgaXMgdGhlIGNvbnRlbnRzIG9mIHRoZSBuYW1lZCByZWdpc3RlciwgYXMgYSBzaW5nbGUgc3RyaW5nLgpOZXdsaW5lcyBhcmUgaW5zZXJ0ZWQgd2hlcmUgcmVxdWlyZWQuICBUbyBnZXQgdGhlIGNvbnRlbnRzIG9mIHRoZSB1bm5hbWVkCnJlZ2lzdGVyIHVzZSBAIiBvciBAQC4JU2VlIHxyZWdpc3RlcnN8IGZvciBhbiBleHBsYW5hdGlvbiBvZiB0aGUgYXZhaWxhYmxlCnJlZ2lzdGVycy4KCldoZW4gdXNpbmcgdGhlICc9JyByZWdpc3RlciB5b3UgZ2V0IHRoZSBleHByZXNzaW9uIGl0c2VsZiwgbm90IHdoYXQgaXQKZXZhbHVhdGVzIHRvLiAgVXNlIHxldmFsKCl8IHRvIGV2YWx1YXRlIGl0LgoKCm5lc3RpbmcJCQkJCQkJKmV4cHItbmVzdGluZyogKkUxMTAqCi0tLS0tLS0KKGV4cHIxKQkJCW5lc3RlZCBleHByZXNzaW9uCgoKZW52aXJvbm1lbnQgdmFyaWFibGUJCQkJCSpleHByLWVudioKLS0tLS0tLS0tLS0tLS0tLS0tLS0KJFZBUgkJCWVudmlyb25tZW50IHZhcmlhYmxlCgpUaGUgU3RyaW5nIHZhbHVlIG9mIGFueSBlbnZpcm9ubWVudCB2YXJpYWJsZS4gIFdoZW4gaXQgaXMgbm90IGRlZmluZWQsIHRoZQpyZXN1bHQgaXMgYW4gZW1wdHkgc3RyaW5nLgoJCQkJCQkqZXhwci1lbnYtZXhwYW5kKgpOb3RlIHRoYXQgdGhlcmUgaXMgYSBkaWZmZXJlbmNlIGJldHdlZW4gdXNpbmcgJFZBUiBkaXJlY3RseSBhbmQgdXNpbmcKZXhwYW5kKCIkVkFSIikuICBVc2luZyBpdCBkaXJlY3RseSB3aWxsIG9ubHkgZXhwYW5kIGVudmlyb25tZW50IHZhcmlhYmxlcyB0aGF0CmFyZSBrbm93biBpbnNpZGUgdGhlIGN1cnJlbnQgVmltIHNlc3Npb24uICBVc2luZyBleHBhbmQoKSB3aWxsIGZpcnN0IHRyeSB1c2luZwp0aGUgZW52aXJvbm1lbnQgdmFyaWFibGVzIGtub3duIGluc2lkZSB0aGUgY3VycmVudCBWaW0gc2Vzc2lvbi4gIElmIHRoYXQKZmFpbHMsIGEgc2hlbGwgd2lsbCBiZSB1c2VkIHRvIGV4cGFuZCB0aGUgdmFyaWFibGUuICBUaGlzIGNhbiBiZSBzbG93LCBidXQgaXQKZG9lcyBleHBhbmQgYWxsIHZhcmlhYmxlcyB0aGF0IHRoZSBzaGVsbCBrbm93cyBhYm91dC4gIEV4YW1wbGU6ID4KCTplY2hvICRzaGVsbAoJOmVjaG8gZXhwYW5kKCIkc2hlbGwiKQpUaGUgZmlyc3Qgb25lIHByb2JhYmx5IGRvZXNuJ3QgZWNobyBhbnl0aGluZywgdGhlIHNlY29uZCBlY2hvZXMgdGhlICRzaGVsbAp2YXJpYWJsZSAoaWYgeW91ciBzaGVsbCBzdXBwb3J0cyBpdCkuCgoKaW50ZXJuYWwgdmFyaWFibGUJCQkJCSpleHByLXZhcmlhYmxlKgotLS0tLS0tLS0tLS0tLS0tLQp2YXJpYWJsZQkJaW50ZXJuYWwgdmFyaWFibGUKU2VlIGJlbG93IHxpbnRlcm5hbC12YXJpYWJsZXN8LgoKCmZ1bmN0aW9uIGNhbGwJCSpleHByLWZ1bmN0aW9uKiAqRTExNiogKkUxMTgqICpFMTE5KiAqRTEyMCoKLS0tLS0tLS0tLS0tLQpmdW5jdGlvbihleHByMSwgLi4uKQlmdW5jdGlvbiBjYWxsClNlZSBiZWxvdyB8ZnVuY3Rpb25zfC4KCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMy4gSW50ZXJuYWwgdmFyaWFibGUJCQkJKmludGVybmFsLXZhcmlhYmxlcyogKkU0NjEqCgpBbiBpbnRlcm5hbCB2YXJpYWJsZSBuYW1lIGNhbiBiZSBtYWRlIHVwIG9mIGxldHRlcnMsIGRpZ2l0cyBhbmQgJ18nLiAgQnV0IGl0CmNhbm5vdCBzdGFydCB3aXRoIGEgZGlnaXQuICBJdCdzIGFsc28gcG9zc2libGUgdG8gdXNlIGN1cmx5IGJyYWNlcywgc2VlCnxjdXJseS1icmFjZXMtbmFtZXN8LgoKQW4gaW50ZXJuYWwgdmFyaWFibGUgaXMgY3JlYXRlZCB3aXRoIHRoZSAiOmxldCIgY29tbWFuZCB8OmxldHwuCkFuIGludGVybmFsIHZhcmlhYmxlIGlzIGV4cGxpY2l0bHkgZGVzdHJveWVkIHdpdGggdGhlICI6dW5sZXQiIGNvbW1hbmQKfDp1bmxldHwuClVzaW5nIGEgbmFtZSB0aGF0IGlzIG5vdCBhbiBpbnRlcm5hbCB2YXJpYWJsZSBvciByZWZlcnMgdG8gYSB2YXJpYWJsZSB0aGF0IGhhcwpiZWVuIGRlc3Ryb3llZCByZXN1bHRzIGluIGFuIGVycm9yLgoKVGhlcmUgYXJlIHNldmVyYWwgbmFtZSBzcGFjZXMgZm9yIHZhcmlhYmxlcy4gIFdoaWNoIG9uZSBpcyB0byBiZSB1c2VkIGlzCnNwZWNpZmllZCBieSB3aGF0IGlzIHByZXBlbmRlZDoKCgkJKG5vdGhpbmcpIEluIGEgZnVuY3Rpb246IGxvY2FsIHRvIGEgZnVuY3Rpb247IG90aGVyd2lzZTogZ2xvYmFsCnxidWZmZXItdmFyaWFibGV8ICAgIGI6CSAgTG9jYWwgdG8gdGhlIGN1cnJlbnQgYnVmZmVyLgp8d2luZG93LXZhcmlhYmxlfCAgICB3OgkgIExvY2FsIHRvIHRoZSBjdXJyZW50IHdpbmRvdy4KfHRhYnBhZ2UtdmFyaWFibGV8ICAgdDoJICBMb2NhbCB0byB0aGUgY3VycmVudCB0YWIgcGFnZS4KfGdsb2JhbC12YXJpYWJsZXwgICAgZzoJICBHbG9iYWwuCnxsb2NhbC12YXJpYWJsZXwgICAgIGw6CSAgTG9jYWwgdG8gYSBmdW5jdGlvbi4KfHNjcmlwdC12YXJpYWJsZXwgICAgczoJICBMb2NhbCB0byBhIHw6c291cmNlfCdlZCBWaW0gc2NyaXB0Lgp8ZnVuY3Rpb24tYXJndW1lbnR8ICBhOgkgIEZ1bmN0aW9uIGFyZ3VtZW50IChvbmx5IGluc2lkZSBhIGZ1bmN0aW9uKS4KfHZpbS12YXJpYWJsZXwgICAgICAgdjoJICBHbG9iYWwsIHByZWRlZmluZWQgYnkgVmltLgoKVGhlIHNjb3BlIG5hbWUgYnkgaXRzZWxmIGNhbiBiZSB1c2VkIGFzIGEgfERpY3Rpb25hcnl8LiAgRm9yIGV4YW1wbGUsIHRvCmRlbGV0ZSBhbGwgc2NyaXB0LWxvY2FsIHZhcmlhYmxlczogPgoJOmZvciBrIGluIGtleXMoczopCgk6ICAgIHVubGV0IHM6W2tdCgk6ZW5kZm9yCjwKCQkJCQkJKmJ1ZmZlci12YXJpYWJsZSogKmI6dmFyKiAqYjoqCkEgdmFyaWFibGUgbmFtZSB0aGF0IGlzIHByZWNlZGVkIHdpdGggImI6IiBpcyBsb2NhbCB0byB0aGUgY3VycmVudCBidWZmZXIuClRodXMgeW91IGNhbiBoYXZlIHNldmVyYWwgImI6Zm9vIiB2YXJpYWJsZXMsIG9uZSBmb3IgZWFjaCBidWZmZXIuClRoaXMga2luZCBvZiB2YXJpYWJsZSBpcyBkZWxldGVkIHdoZW4gdGhlIGJ1ZmZlciBpcyB3aXBlZCBvdXQgb3IgZGVsZXRlZCB3aXRoCnw6YmRlbGV0ZXwuCgpPbmUgbG9jYWwgYnVmZmVyIHZhcmlhYmxlIGlzIHByZWRlZmluZWQ6CgkJCQkJKmI6Y2hhbmdlZHRpY2sqICpjaGFuZ2V0aWNrKgpiOmNoYW5nZWR0aWNrCVRoZSB0b3RhbCBudW1iZXIgb2YgY2hhbmdlcyB0byB0aGUgY3VycmVudCBidWZmZXIuICBJdCBpcwoJCWluY3JlbWVudGVkIGZvciBlYWNoIGNoYW5nZS4gIEFuIHVuZG8gY29tbWFuZCBpcyBhbHNvIGEgY2hhbmdlCgkJaW4gdGhpcyBjYXNlLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBwZXJmb3JtIGFuIGFjdGlvbiBvbmx5IHdoZW4KCQl0aGUgYnVmZmVyIGhhcyBjaGFuZ2VkLiAgRXhhbXBsZTogPgoJCSAgICA6aWYgbXlfY2hhbmdlZHRpY2sgIT0gYjpjaGFuZ2VkdGljawoJCSAgICA6CWxldCBteV9jaGFuZ2VkdGljayA9IGI6Y2hhbmdlZHRpY2sKCQkgICAgOgljYWxsIE15X1VwZGF0ZSgpCgkJICAgIDplbmRpZgo8CgkJCQkJCSp3aW5kb3ctdmFyaWFibGUqICp3OnZhciogKnc6KgpBIHZhcmlhYmxlIG5hbWUgdGhhdCBpcyBwcmVjZWRlZCB3aXRoICJ3OiIgaXMgbG9jYWwgdG8gdGhlIGN1cnJlbnQgd2luZG93LiAgSXQKaXMgZGVsZXRlZCB3aGVuIHRoZSB3aW5kb3cgaXMgY2xvc2VkLgoKCQkJCQkJKnRhYnBhZ2UtdmFyaWFibGUqICp0OnZhciogKnQ6KgpBIHZhcmlhYmxlIG5hbWUgdGhhdCBpcyBwcmVjZWRlZCB3aXRoICJ0OiIgaXMgbG9jYWwgdG8gdGhlIGN1cnJlbnQgdGFiIHBhZ2UsCkl0IGlzIGRlbGV0ZWQgd2hlbiB0aGUgdGFiIHBhZ2UgaXMgY2xvc2VkLiB7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkCndpdGhvdXQgdGhlIHwrd2luZG93c3wgZmVhdHVyZX0KCgkJCQkJCSpnbG9iYWwtdmFyaWFibGUqICpnOnZhciogKmc6KgpJbnNpZGUgZnVuY3Rpb25zIGdsb2JhbCB2YXJpYWJsZXMgYXJlIGFjY2Vzc2VkIHdpdGggImc6Ii4gIE9taXR0aW5nIHRoaXMgd2lsbAphY2Nlc3MgYSB2YXJpYWJsZSBsb2NhbCB0byBhIGZ1bmN0aW9uLglCdXQgImc6IiBjYW4gYWxzbyBiZSB1c2VkIGluIGFueSBvdGhlcgpwbGFjZSBpZiB5b3UgbGlrZS4KCgkJCQkJCSpsb2NhbC12YXJpYWJsZSogKmw6dmFyKiAqbDoqCkluc2lkZSBmdW5jdGlvbnMgbG9jYWwgdmFyaWFibGVzIGFyZSBhY2Nlc3NlZCB3aXRob3V0IHByZXBlbmRpbmcgYW55dGhpbmcuCkJ1dCB5b3UgY2FuIGFsc28gcHJlcGVuZCAibDoiIGlmIHlvdSBsaWtlLiAgSG93ZXZlciwgd2l0aG91dCBwcmVwZW5kaW5nICJsOiIKeW91IG1heSBydW4gaW50byByZXNlcnZlZCB2YXJpYWJsZSBuYW1lcy4gIEZvciBleGFtcGxlICJjb3VudCIuICBCeSBpdHNlbGYgaXQKcmVmZXJzIHRvICJ2OmNvdW50Ii4gIFVzaW5nICJsOmNvdW50IiB5b3UgY2FuIGhhdmUgYSBsb2NhbCB2YXJpYWJsZSB3aXRoIHRoZQpzYW1lIG5hbWUuCgoJCQkJCQkqc2NyaXB0LXZhcmlhYmxlKiAqczp2YXIqCkluIGEgVmltIHNjcmlwdCB2YXJpYWJsZXMgc3RhcnRpbmcgd2l0aCAiczoiIGNhbiBiZSB1c2VkLiAgVGhleSBjYW5ub3QgYmUKYWNjZXNzZWQgZnJvbSBvdXRzaWRlIG9mIHRoZSBzY3JpcHRzLCB0aHVzIGFyZSBsb2NhbCB0byB0aGUgc2NyaXB0LgoKVGhleSBjYW4gYmUgdXNlZCBpbjoKLSBjb21tYW5kcyBleGVjdXRlZCB3aGlsZSB0aGUgc2NyaXB0IGlzIHNvdXJjZWQKLSBmdW5jdGlvbnMgZGVmaW5lZCBpbiB0aGUgc2NyaXB0Ci0gYXV0b2NvbW1hbmRzIGRlZmluZWQgaW4gdGhlIHNjcmlwdAotIGZ1bmN0aW9ucyBhbmQgYXV0b2NvbW1hbmRzIGRlZmluZWQgaW4gZnVuY3Rpb25zIGFuZCBhdXRvY29tbWFuZHMgd2hpY2ggd2VyZQogIGRlZmluZWQgaW4gdGhlIHNjcmlwdCAocmVjdXJzaXZlbHkpCi0gdXNlciBkZWZpbmVkIGNvbW1hbmRzIGRlZmluZWQgaW4gdGhlIHNjcmlwdApUaHVzIG5vdCBpbjoKLSBvdGhlciBzY3JpcHRzIHNvdXJjZWQgZnJvbSB0aGlzIG9uZQotIG1hcHBpbmdzCi0gbWVudXMKLSBldGMuCgpTY3JpcHQgdmFyaWFibGVzIGNhbiBiZSB1c2VkIHRvIGF2b2lkIGNvbmZsaWN0cyB3aXRoIGdsb2JhbCB2YXJpYWJsZSBuYW1lcy4KVGFrZSB0aGlzIGV4YW1wbGU6ID4KCglsZXQgczpjb3VudGVyID0gMAoJZnVuY3Rpb24gTXlDb3VudGVyKCkKCSAgbGV0IHM6Y291bnRlciA9IHM6Y291bnRlciArIDEKCSAgZWNobyBzOmNvdW50ZXIKCWVuZGZ1bmN0aW9uCgljb21tYW5kIFRpY2sgY2FsbCBNeUNvdW50ZXIoKQoKWW91IGNhbiBub3cgaW52b2tlICJUaWNrIiBmcm9tIGFueSBzY3JpcHQsIGFuZCB0aGUgInM6Y291bnRlciIgdmFyaWFibGUgaW4KdGhhdCBzY3JpcHQgd2lsbCBub3QgYmUgY2hhbmdlZCwgb25seSB0aGUgInM6Y291bnRlciIgaW4gdGhlIHNjcmlwdCB3aGVyZQoiVGljayIgd2FzIGRlZmluZWQgaXMgdXNlZC4KCkFub3RoZXIgZXhhbXBsZSB0aGF0IGRvZXMgdGhlIHNhbWU6ID4KCglsZXQgczpjb3VudGVyID0gMAoJY29tbWFuZCBUaWNrIGxldCBzOmNvdW50ZXIgPSBzOmNvdW50ZXIgKyAxIHwgZWNobyBzOmNvdW50ZXIKCldoZW4gY2FsbGluZyBhIGZ1bmN0aW9uIGFuZCBpbnZva2luZyBhIHVzZXItZGVmaW5lZCBjb21tYW5kLCB0aGUgY29udGV4dCBmb3IKc2NyaXB0IHZhcmlhYmxlcyBpcyBzZXQgdG8gdGhlIHNjcmlwdCB3aGVyZSB0aGUgZnVuY3Rpb24gb3IgY29tbWFuZCB3YXMKZGVmaW5lZC4KClRoZSBzY3JpcHQgdmFyaWFibGVzIGFyZSBhbHNvIGF2YWlsYWJsZSB3aGVuIGEgZnVuY3Rpb24gaXMgZGVmaW5lZCBpbnNpZGUgYQpmdW5jdGlvbiB0aGF0IGlzIGRlZmluZWQgaW4gYSBzY3JpcHQuICBFeGFtcGxlOiA+CgoJbGV0IHM6Y291bnRlciA9IDAKCWZ1bmN0aW9uIFN0YXJ0Q291bnRpbmcoaW5jcikKCSAgaWYgYTppbmNyCgkgICAgZnVuY3Rpb24gTXlDb3VudGVyKCkKCSAgICAgIGxldCBzOmNvdW50ZXIgPSBzOmNvdW50ZXIgKyAxCgkgICAgZW5kZnVuY3Rpb24KCSAgZWxzZQoJICAgIGZ1bmN0aW9uIE15Q291bnRlcigpCgkgICAgICBsZXQgczpjb3VudGVyID0gczpjb3VudGVyIC0gMQoJICAgIGVuZGZ1bmN0aW9uCgkgIGVuZGlmCgllbmRmdW5jdGlvbgoKVGhpcyBkZWZpbmVzIHRoZSBNeUNvdW50ZXIoKSBmdW5jdGlvbiBlaXRoZXIgZm9yIGNvdW50aW5nIHVwIG9yIGNvdW50aW5nIGRvd24Kd2hlbiBjYWxsaW5nIFN0YXJ0Q291bnRpbmcoKS4gIEl0IGRvZXNuJ3QgbWF0dGVyIGZyb20gd2hlcmUgU3RhcnRDb3VudGluZygpIGlzCmNhbGxlZCwgdGhlIHM6Y291bnRlciB2YXJpYWJsZSB3aWxsIGJlIGFjY2Vzc2libGUgaW4gTXlDb3VudGVyKCkuCgpXaGVuIHRoZSBzYW1lIHNjcmlwdCBpcyBzb3VyY2VkIGFnYWluIGl0IHdpbGwgdXNlIHRoZSBzYW1lIHNjcmlwdCB2YXJpYWJsZXMuClRoZXkgd2lsbCByZW1haW4gdmFsaWQgYXMgbG9uZyBhcyBWaW0gaXMgcnVubmluZy4gIFRoaXMgY2FuIGJlIHVzZWQgdG8KbWFpbnRhaW4gYSBjb3VudGVyOiA+CgoJaWYgIWV4aXN0cygiczpjb3VudGVyIikKCSAgbGV0IHM6Y291bnRlciA9IDEKCSAgZWNobyAic2NyaXB0IGV4ZWN1dGVkIGZvciB0aGUgZmlyc3QgdGltZSIKCWVsc2UKCSAgbGV0IHM6Y291bnRlciA9IHM6Y291bnRlciArIDEKCSAgZWNobyAic2NyaXB0IGV4ZWN1dGVkICIgLiBzOmNvdW50ZXIgLiAiIHRpbWVzIG5vdyIKCWVuZGlmCgpOb3RlIHRoYXQgdGhpcyBtZWFucyB0aGF0IGZpbGV0eXBlIHBsdWdpbnMgZG9uJ3QgZ2V0IGEgZGlmZmVyZW50IHNldCBvZiBzY3JpcHQKdmFyaWFibGVzIGZvciBlYWNoIGJ1ZmZlci4gIFVzZSBsb2NhbCBidWZmZXIgdmFyaWFibGVzIGluc3RlYWQgfGI6dmFyfC4KCgpQcmVkZWZpbmVkIFZpbSB2YXJpYWJsZXM6CQkJKnZpbS12YXJpYWJsZSogKnY6dmFyKiAqdjoqCgoJCQkJCSp2OmJldmFsX2NvbCogKmJldmFsX2NvbC12YXJpYWJsZSoKdjpiZXZhbF9jb2wJVGhlIG51bWJlciBvZiB0aGUgY29sdW1uLCBvdmVyIHdoaWNoIHRoZSBtb3VzZSBwb2ludGVyIGlzLgoJCVRoaXMgaXMgdGhlIGJ5dGUgaW5kZXggaW4gdGhlIHx2OmJldmFsX2xudW18IGxpbmUuCgkJT25seSB2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnYmFsbG9vbmV4cHInIG9wdGlvbi4KCgkJCQkJKnY6YmV2YWxfYnVmbnIqICpiZXZhbF9idWZuci12YXJpYWJsZSoKdjpiZXZhbF9idWZucglUaGUgbnVtYmVyIG9mIHRoZSBidWZmZXIsIG92ZXIgd2hpY2ggdGhlIG1vdXNlIHBvaW50ZXIgaXMuIE9ubHkKCQl2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnYmFsbG9vbmV4cHInIG9wdGlvbi4KCgkJCQkJKnY6YmV2YWxfbG51bSogKmJldmFsX2xudW0tdmFyaWFibGUqCnY6YmV2YWxfbG51bQlUaGUgbnVtYmVyIG9mIHRoZSBsaW5lLCBvdmVyIHdoaWNoIHRoZSBtb3VzZSBwb2ludGVyIGlzLiBPbmx5CgkJdmFsaWQgd2hpbGUgZXZhbHVhdGluZyB0aGUgJ2JhbGxvb25leHByJyBvcHRpb24uCgoJCQkJCSp2OmJldmFsX3RleHQqICpiZXZhbF90ZXh0LXZhcmlhYmxlKgp2OmJldmFsX3RleHQJVGhlIHRleHQgdW5kZXIgb3IgYWZ0ZXIgdGhlIG1vdXNlIHBvaW50ZXIuICBVc3VhbGx5IGEgd29yZCBhcwoJCWl0IGlzIHVzZWZ1bCBmb3IgZGVidWdnaW5nIGEgQyBwcm9ncmFtLiAgJ2lza2V5d29yZCcgYXBwbGllcywKCQlidXQgYSBkb3QgYW5kICItPiIgYmVmb3JlIHRoZSBwb3NpdGlvbiBpcyBpbmNsdWRlZC4gIFdoZW4gb24gYQoJCSddJyB0aGUgdGV4dCBiZWZvcmUgaXQgaXMgdXNlZCwgaW5jbHVkaW5nIHRoZSBtYXRjaGluZyAnWycgYW5kCgkJd29yZCBiZWZvcmUgaXQuICBXaGVuIG9uIGEgVmlzdWFsIGFyZWEgd2l0aGluIG9uZSBsaW5lIHRoZQoJCWhpZ2hsaWdodGVkIHRleHQgaXMgdXNlZC4KCQlPbmx5IHZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgb3B0aW9uLgoKCQkJCQkqdjpiZXZhbF93aW5uciogKmJldmFsX3dpbm5yLXZhcmlhYmxlKgp2OmJldmFsX3dpbm5yCVRoZSBudW1iZXIgb2YgdGhlIHdpbmRvdywgb3ZlciB3aGljaCB0aGUgbW91c2UgcG9pbnRlciBpcy4gT25seQoJCXZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgb3B0aW9uLiAgVGhlIGZpcnN0CgkJd2luZG93IGhhcyBudW1iZXIgemVybyAodW5saWtlIG1vc3Qgb3RoZXIgcGxhY2VzIHdoZXJlIGEKCQl3aW5kb3cgZ2V0cyBhIG51bWJlcikuCgoJCQkJCSp2OmNoYXIqICpjaGFyLXZhcmlhYmxlKgp2OmNoYXIJCUFyZ3VtZW50IGZvciBldmFsdWF0aW5nICdmb3JtYXRleHByJyBhbmQgdXNlZCBmb3IgdGhlIHR5cGVkCgkJY2hhcmFjdGVyIHdoZW4gdXNpbmcgPGV4cHI+IGluIGFuIGFiYnJldmlhdGlvbiB8Om1hcC08ZXhwcj58LgoJCUl0IGlzIGFsc28gdXNlZCBieSB0aGUgfEluc2VydENoYXJQcmV8IGFuZCB8SW5zZXJ0RW50ZXJ8IGV2ZW50cy4KCgkJCSp2OmNoYXJjb252ZXJ0X2Zyb20qICpjaGFyY29udmVydF9mcm9tLXZhcmlhYmxlKgp2OmNoYXJjb252ZXJ0X2Zyb20KCQlUaGUgbmFtZSBvZiB0aGUgY2hhcmFjdGVyIGVuY29kaW5nIG9mIGEgZmlsZSB0byBiZSBjb252ZXJ0ZWQuCgkJT25seSB2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnY2hhcmNvbnZlcnQnIG9wdGlvbi4KCgkJCSp2OmNoYXJjb252ZXJ0X3RvKiAqY2hhcmNvbnZlcnRfdG8tdmFyaWFibGUqCnY6Y2hhcmNvbnZlcnRfdG8KCQlUaGUgbmFtZSBvZiB0aGUgY2hhcmFjdGVyIGVuY29kaW5nIG9mIGEgZmlsZSBhZnRlciBjb252ZXJzaW9uLgoJCU9ubHkgdmFsaWQgd2hpbGUgZXZhbHVhdGluZyB0aGUgJ2NoYXJjb252ZXJ0JyBvcHRpb24uCgoJCQkJCSp2OmNtZGFyZyogKmNtZGFyZy12YXJpYWJsZSoKdjpjbWRhcmcJVGhpcyB2YXJpYWJsZSBpcyB1c2VkIGZvciB0d28gcHVycG9zZXM6CgkJMS4gVGhlIGV4dHJhIGFyZ3VtZW50cyBnaXZlbiB0byBhIGZpbGUgcmVhZC93cml0ZSBjb21tYW5kLgoJCSAgIEN1cnJlbnRseSB0aGVzZSBhcmUgIisrZW5jPSIgYW5kICIrK2ZmPSIuICBUaGlzIHZhcmlhYmxlIGlzCgkJICAgc2V0IGJlZm9yZSBhbiBhdXRvY29tbWFuZCBldmVudCBmb3IgYSBmaWxlIHJlYWQvd3JpdGUKCQkgICBjb21tYW5kIGlzIHRyaWdnZXJlZC4gIFRoZXJlIGlzIGEgbGVhZGluZyBzcGFjZSB0byBtYWtlIGl0CgkJICAgcG9zc2libGUgdG8gYXBwZW5kIHRoaXMgdmFyaWFibGUgZGlyZWN0bHkgYWZ0ZXIgdGhlCgkJICAgcmVhZC93cml0ZSBjb21tYW5kLglOb3RlOiBUaGUgIitjbWQiIGFyZ3VtZW50IGlzbid0CgkJICAgaW5jbHVkZWQgaGVyZSwgYmVjYXVzZSBpdCB3aWxsIGJlIGV4ZWN1dGVkIGFueXdheS4KCQkyLiBXaGVuIHByaW50aW5nIGEgUG9zdFNjcmlwdCBmaWxlIHdpdGggIjpoYXJkY29weSIgdGhpcyBpcwoJCSAgIHRoZSBhcmd1bWVudCBmb3IgdGhlICI6aGFyZGNvcHkiIGNvbW1hbmQuICBUaGlzIGNhbiBiZSB1c2VkCgkJICAgaW4gJ3ByaW50ZXhwcicuCgoJCQkJCSp2OmNtZGJhbmcqICpjbWRiYW5nLXZhcmlhYmxlKgp2OmNtZGJhbmcJU2V0IGxpa2UgdjpjbWRhcmcgZm9yIGEgZmlsZSByZWFkL3dyaXRlIGNvbW1hbmQuICBXaGVuIGEgIiEiCgkJd2FzIHVzZWQgdGhlIHZhbHVlIGlzIDEsIG90aGVyd2lzZSBpdCBpcyAwLiAgTm90ZSB0aGF0IHRoaXMKCQljYW4gb25seSBiZSB1c2VkIGluIGF1dG9jb21tYW5kcy4gIEZvciB1c2VyIGNvbW1hbmRzIHw8YmFuZz58CgkJY2FuIGJlIHVzZWQuCgoJCQkJKnY6Y29tcGxldGVkX2l0ZW0qICpjb21wbGV0ZWRfaXRlbS12YXJpYWJsZSoKdjpjb21wbGV0ZWRfaXRlbQoJCXxEaWN0aW9uYXJ5fCBjb250YWluaW5nIHRoZSB8Y29tcGxldGUtaXRlbXN8IGZvciB0aGUgbW9zdAoJCXJlY2VudGx5IGNvbXBsZXRlZCB3b3JkIGFmdGVyIHxDb21wbGV0ZURvbmV8LiAgVGhlCgkJfERpY3Rpb25hcnl8IGlzIGVtcHR5IGlmIHRoZSBjb21wbGV0aW9uIGZhaWxlZC4KCgkJCQkJKnY6Y291bnQqICpjb3VudC12YXJpYWJsZSoKdjpjb3VudAkJVGhlIGNvdW50IGdpdmVuIGZvciB0aGUgbGFzdCBOb3JtYWwgbW9kZSBjb21tYW5kLiAgQ2FuIGJlIHVzZWQKCQl0byBnZXQgdGhlIGNvdW50IGJlZm9yZSBhIG1hcHBpbmcuICBSZWFkLW9ubHkuCUV4YW1wbGU6ID4KCTptYXAgX3ggOjxDLVU+ZWNobyAidGhlIGNvdW50IGlzICIgLiB2OmNvdW50PENSPgo8CQlOb3RlOiBUaGUgPEMtVT4gaXMgcmVxdWlyZWQgdG8gcmVtb3ZlIHRoZSBsaW5lIHJhbmdlIHRoYXQgeW91CgkJZ2V0IHdoZW4gdHlwaW5nICc6JyBhZnRlciBhIGNvdW50LgoJCVdoZW4gdGhlcmUgYXJlIHR3byBjb3VudHMsIGFzIGluICIzZDJ3IiwgdGhleSBhcmUgbXVsdGlwbGllZCwKCQlqdXN0IGxpa2Ugd2hhdCBoYXBwZW5zIGluIHRoZSBjb21tYW5kLCAiZDZ3IiBmb3IgdGhlIGV4YW1wbGUuCgkJQWxzbyB1c2VkIGZvciBldmFsdWF0aW5nIHRoZSAnZm9ybWF0ZXhwcicgb3B0aW9uLgoJCSJjb3VudCIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjpjb3VudDEqICpjb3VudDEtdmFyaWFibGUqCnY6Y291bnQxCUp1c3QgbGlrZSAidjpjb3VudCIsIGJ1dCBkZWZhdWx0cyB0byBvbmUgd2hlbiBubyBjb3VudCBpcwoJCXVzZWQuCgoJCQkJCQkqdjpjdHlwZSogKmN0eXBlLXZhcmlhYmxlKgp2OmN0eXBlCQlUaGUgY3VycmVudCBsb2NhbGUgc2V0dGluZyBmb3IgY2hhcmFjdGVycyBvZiB0aGUgcnVudGltZQoJCWVudmlyb25tZW50LiAgVGhpcyBhbGxvd3MgVmltIHNjcmlwdHMgdG8gYmUgYXdhcmUgb2YgdGhlCgkJY3VycmVudCBsb2NhbGUgZW5jb2RpbmcuICBUZWNobmljYWw6IGl0J3MgdGhlIHZhbHVlIG9mCgkJTENfQ1RZUEUuICBXaGVuIG5vdCB1c2luZyBhIGxvY2FsZSB0aGUgdmFsdWUgaXMgIkMiLgoJCVRoaXMgdmFyaWFibGUgY2FuIG5vdCBiZSBzZXQgZGlyZWN0bHksIHVzZSB0aGUgfDpsYW5ndWFnZXwKCQljb21tYW5kLgoJCVNlZSB8bXVsdGktbGFuZ3wuCgoJCQkJCSp2OmR5aW5nKiAqZHlpbmctdmFyaWFibGUqCnY6ZHlpbmcJCU5vcm1hbGx5IHplcm8uCVdoZW4gYSBkZWFkbHkgc2lnbmFsIGlzIGNhdWdodCBpdCdzIHNldCB0bwoJCW9uZS4gIFdoZW4gbXVsdGlwbGUgc2lnbmFscyBhcmUgY2F1Z2h0IHRoZSBudW1iZXIgaW5jcmVhc2VzLgoJCUNhbiBiZSB1c2VkIGluIGFuIGF1dG9jb21tYW5kIHRvIGNoZWNrIGlmIFZpbSBkaWRuJ3QKCQl0ZXJtaW5hdGUgbm9ybWFsbHkuIHtvbmx5IHdvcmtzIG9uIFVuaXh9CgkJRXhhbXBsZTogPgoJOmF1IFZpbUxlYXZlICogaWYgdjpkeWluZyB8IGVjaG8gIlxuQUFBQWFhYWFycnJnZ2doaGhoISEhXG4iIHwgZW5kaWYKPAkJTm90ZTogaWYgYW5vdGhlciBkZWFkbHkgc2lnbmFsIGlzIGNhdWdodCB3aGVuIHY6ZHlpbmcgaXMgb25lLAoJCVZpbUxlYXZlIGF1dG9jb21tYW5kcyB3aWxsIG5vdCBiZSBleGVjdXRlZC4KCgkJCQkJKnY6ZXJybXNnKiAqZXJybXNnLXZhcmlhYmxlKgp2OmVycm1zZwlMYXN0IGdpdmVuIGVycm9yIG1lc3NhZ2UuICBJdCdzIGFsbG93ZWQgdG8gc2V0IHRoaXMgdmFyaWFibGUuCgkJRXhhbXBsZTogPgoJOmxldCB2OmVycm1zZyA9ICIiCgk6c2lsZW50ISBuZXh0Cgk6aWYgdjplcnJtc2cgIT0gIiIKCTogIC4uLiBoYW5kbGUgZXJyb3IKPAkJImVycm1zZyIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjplcnJvcnMqICplcnJvcnMtdmFyaWFibGUqCnY6ZXJyb3JzCUVycm9ycyBmb3VuZCBieSBhc3NlcnQgZnVuY3Rpb25zLCBzdWNoIGFzIHxhc3NlcnRfdHJ1ZSgpfC4KCQlUaGlzIGlzIGEgbGlzdCBvZiBzdHJpbmdzLgoJCVRoZSBhc3NlcnQgZnVuY3Rpb25zIGFwcGVuZCBhbiBpdGVtIHdoZW4gYW4gYXNzZXJ0IGZhaWxzLgoJCVRvIHJlbW92ZSBvbGQgcmVzdWx0cyBtYWtlIGl0IGVtcHR5OiA+Cgk6bGV0IHY6ZXJyb3JzID0gW10KPAkJSWYgdjplcnJvcnMgaXMgc2V0IHRvIGFueXRoaW5nIGJ1dCBhIGxpc3QgaXQgaXMgbWFkZSBhbiBlbXB0eQoJCWxpc3QgYnkgdGhlIGFzc2VydCBmdW5jdGlvbi4KCgkJCQkJKnY6ZXhjZXB0aW9uKiAqZXhjZXB0aW9uLXZhcmlhYmxlKgp2OmV4Y2VwdGlvbglUaGUgdmFsdWUgb2YgdGhlIGV4Y2VwdGlvbiBtb3N0IHJlY2VudGx5IGNhdWdodCBhbmQgbm90CgkJZmluaXNoZWQuICBTZWUgYWxzbyB8djp0aHJvd3BvaW50fCBhbmQgfHRocm93LXZhcmlhYmxlc3wuCgkJRXhhbXBsZTogPgoJOnRyeQoJOiAgdGhyb3cgIm9vcHMiCgk6Y2F0Y2ggLy4qLwoJOiAgZWNobyAiY2F1Z2h0IiB2OmV4Y2VwdGlvbgoJOmVuZHRyeQo8CQlPdXRwdXQ6ICJjYXVnaHQgb29wcyIuCgoJCQkJCSp2OmZhbHNlKiAqZmFsc2UtdmFyaWFibGUqCnY6ZmFsc2UJCUEgTnVtYmVyIHdpdGggdmFsdWUgemVyby4gVXNlZCB0byBwdXQgImZhbHNlIiBpbiBKU09OLiAgU2VlCgkJfGpzb25fZW5jb2RlKCl8LgoJCVdoZW4gdXNlZCBhcyBhIHN0cmluZyB0aGlzIGV2YWx1YXRlcyB0byAiZmFsc2UiLiA+CgkJCWVjaG8gdjpmYWxzZQo8CQkJZmFsc2UgfgoKCQkJCQkqdjpmY3NfcmVhc29uKiAqZmNzX3JlYXNvbi12YXJpYWJsZSoKdjpmY3NfcmVhc29uCVRoZSByZWFzb24gd2h5IHRoZSB8RmlsZUNoYW5nZWRTaGVsbHwgZXZlbnQgd2FzIHRyaWdnZXJlZC4KCQlDYW4gYmUgdXNlZCBpbiBhbiBhdXRvY29tbWFuZCB0byBkZWNpZGUgd2hhdCB0byBkbyBhbmQvb3Igd2hhdAoJCXRvIHNldCB2OmZjc19jaG9pY2UgdG8uICBQb3NzaWJsZSB2YWx1ZXM6CgkJCWRlbGV0ZWQJCWZpbGUgbm8gbG9uZ2VyIGV4aXN0cwoJCQljb25mbGljdAlmaWxlIGNvbnRlbnRzLCBtb2RlIG9yIHRpbWVzdGFtcCB3YXMKCQkJCQljaGFuZ2VkIGFuZCBidWZmZXIgaXMgbW9kaWZpZWQKCQkJY2hhbmdlZAkJZmlsZSBjb250ZW50cyBoYXMgY2hhbmdlZAoJCQltb2RlCQltb2RlIG9mIGZpbGUgY2hhbmdlZAoJCQl0aW1lCQlvbmx5IGZpbGUgdGltZXN0YW1wIGNoYW5nZWQKCgkJCQkJKnY6ZmNzX2Nob2ljZSogKmZjc19jaG9pY2UtdmFyaWFibGUqCnY6ZmNzX2Nob2ljZQlXaGF0IHNob3VsZCBoYXBwZW4gYWZ0ZXIgYSB8RmlsZUNoYW5nZWRTaGVsbHwgZXZlbnQgd2FzCgkJdHJpZ2dlcmVkLiAgQ2FuIGJlIHVzZWQgaW4gYW4gYXV0b2NvbW1hbmQgdG8gdGVsbCBWaW0gd2hhdCB0bwoJCWRvIHdpdGggdGhlIGFmZmVjdGVkIGJ1ZmZlcjoKCQkJcmVsb2FkCQlSZWxvYWQgdGhlIGJ1ZmZlciAoZG9lcyBub3Qgd29yayBpZgoJCQkJCXRoZSBmaWxlIHdhcyBkZWxldGVkKS4KCQkJYXNrCQlBc2sgdGhlIHVzZXIgd2hhdCB0byBkbywgYXMgaWYgdGhlcmUKCQkJCQl3YXMgbm8gYXV0b2NvbW1hbmQuICBFeGNlcHQgdGhhdCB3aGVuCgkJCQkJb25seSB0aGUgdGltZXN0YW1wIGNoYW5nZWQgbm90aGluZwoJCQkJCXdpbGwgaGFwcGVuLgoJCQk8ZW1wdHk+CQlOb3RoaW5nLCB0aGUgYXV0b2NvbW1hbmQgc2hvdWxkIGRvCgkJCQkJZXZlcnl0aGluZyB0aGF0IG5lZWRzIHRvIGJlIGRvbmUuCgkJVGhlIGRlZmF1bHQgaXMgZW1wdHkuICBJZiBhbm90aGVyIChpbnZhbGlkKSB2YWx1ZSBpcyB1c2VkIHRoZW4KCQlWaW0gYmVoYXZlcyBsaWtlIGl0IGlzIGVtcHR5LCB0aGVyZSBpcyBubyB3YXJuaW5nIG1lc3NhZ2UuCgoJCQkJCSp2OmZuYW1lX2luKiAqZm5hbWVfaW4tdmFyaWFibGUqCnY6Zm5hbWVfaW4JVGhlIG5hbWUgb2YgdGhlIGlucHV0IGZpbGUuICBWYWxpZCB3aGlsZSBldmFsdWF0aW5nOgoJCQlvcHRpb24JCXVzZWQgZm9yIH4KCQkJJ2NoYXJjb252ZXJ0JwlmaWxlIHRvIGJlIGNvbnZlcnRlZAoJCQknZGlmZmV4cHInCW9yaWdpbmFsIGZpbGUKCQkJJ3BhdGNoZXhwcicJb3JpZ2luYWwgZmlsZQoJCQkncHJpbnRleHByJwlmaWxlIHRvIGJlIHByaW50ZWQKCQlBbmQgc2V0IHRvIHRoZSBzd2FwIGZpbGUgbmFtZSBmb3IgfFN3YXBFeGlzdHN8LgoKCQkJCQkqdjpmbmFtZV9vdXQqICpmbmFtZV9vdXQtdmFyaWFibGUqCnY6Zm5hbWVfb3V0CVRoZSBuYW1lIG9mIHRoZSBvdXRwdXQgZmlsZS4gIE9ubHkgdmFsaWQgd2hpbGUKCQlldmFsdWF0aW5nOgoJCQlvcHRpb24JCXVzZWQgZm9yIH4KCQkJJ2NoYXJjb252ZXJ0JwlyZXN1bHRpbmcgY29udmVydGVkIGZpbGUgKCopCgkJCSdkaWZmZXhwcicJb3V0cHV0IG9mIGRpZmYKCQkJJ3BhdGNoZXhwcicJcmVzdWx0aW5nIHBhdGNoZWQgZmlsZQoJCSgqKSBXaGVuIGRvaW5nIGNvbnZlcnNpb24gZm9yIGEgd3JpdGUgY29tbWFuZCAoZS5nLiwgIjp3CgkJZmlsZSIpIGl0IHdpbGwgYmUgZXF1YWwgdG8gdjpmbmFtZV9pbi4JV2hlbiBkb2luZyBjb252ZXJzaW9uCgkJZm9yIGEgcmVhZCBjb21tYW5kIChlLmcuLCAiOmUgZmlsZSIpIGl0IHdpbGwgYmUgYSB0ZW1wb3JhcnkKCQlmaWxlIGFuZCBkaWZmZXJlbnQgZnJvbSB2OmZuYW1lX2luLgoKCQkJCQkqdjpmbmFtZV9uZXcqICpmbmFtZV9uZXctdmFyaWFibGUqCnY6Zm5hbWVfbmV3CVRoZSBuYW1lIG9mIHRoZSBuZXcgdmVyc2lvbiBvZiB0aGUgZmlsZS4gIE9ubHkgdmFsaWQgd2hpbGUKCQlldmFsdWF0aW5nICdkaWZmZXhwcicuCgoJCQkJCSp2OmZuYW1lX2RpZmYqICpmbmFtZV9kaWZmLXZhcmlhYmxlKgp2OmZuYW1lX2RpZmYJVGhlIG5hbWUgb2YgdGhlIGRpZmYgKHBhdGNoKSBmaWxlLiAgT25seSB2YWxpZCB3aGlsZQoJCWV2YWx1YXRpbmcgJ3BhdGNoZXhwcicuCgoJCQkJCSp2OmZvbGRkYXNoZXMqICpmb2xkZGFzaGVzLXZhcmlhYmxlKgp2OmZvbGRkYXNoZXMJVXNlZCBmb3IgJ2ZvbGR0ZXh0JzogZGFzaGVzIHJlcHJlc2VudGluZyBmb2xkbGV2ZWwgb2YgYSBjbG9zZWQKCQlmb2xkLgoJCVJlYWQtb25seSBpbiB0aGUgfHNhbmRib3h8LiB8Zm9sZC1mb2xkdGV4dHwKCgkJCQkJKnY6Zm9sZGxldmVsKiAqZm9sZGxldmVsLXZhcmlhYmxlKgp2OmZvbGRsZXZlbAlVc2VkIGZvciAnZm9sZHRleHQnOiBmb2xkbGV2ZWwgb2YgY2xvc2VkIGZvbGQuCgkJUmVhZC1vbmx5IGluIHRoZSB8c2FuZGJveHwuIHxmb2xkLWZvbGR0ZXh0fAoKCQkJCQkqdjpmb2xkZW5kKiAqZm9sZGVuZC12YXJpYWJsZSoKdjpmb2xkZW5kCVVzZWQgZm9yICdmb2xkdGV4dCc6IGxhc3QgbGluZSBvZiBjbG9zZWQgZm9sZC4KCQlSZWFkLW9ubHkgaW4gdGhlIHxzYW5kYm94fC4gfGZvbGQtZm9sZHRleHR8CgoJCQkJCSp2OmZvbGRzdGFydCogKmZvbGRzdGFydC12YXJpYWJsZSoKdjpmb2xkc3RhcnQJVXNlZCBmb3IgJ2ZvbGR0ZXh0JzogZmlyc3QgbGluZSBvZiBjbG9zZWQgZm9sZC4KCQlSZWFkLW9ubHkgaW4gdGhlIHxzYW5kYm94fC4gfGZvbGQtZm9sZHRleHR8CgoJCQkJCSp2Omhsc2VhcmNoKiAqaGxzZWFyY2gtdmFyaWFibGUqCnY6aGxzZWFyY2gJVmFyaWFibGUgdGhhdCBpbmRpY2F0ZXMgd2hldGhlciBzZWFyY2ggaGlnaGxpZ2h0aW5nIGlzIG9uLiAKCQlTZXR0aW5nIGl0IG1ha2VzIHNlbnNlIG9ubHkgaWYgJ2hsc2VhcmNoJyBpcyBlbmFibGVkIHdoaWNoCgkJcmVxdWlyZXMgfCtleHRyYV9zZWFyY2h8LiBTZXR0aW5nIHRoaXMgdmFyaWFibGUgdG8gemVybyBhY3RzCgkJbGlrZSB0aGUgfDpub2hsc2VhcmNofCBjb21tYW5kLCBzZXR0aW5nIGl0IHRvIG9uZSBhY3RzIGxpa2UgPgoJCQlsZXQgJmhsc2VhcmNoID0gJmhsc2VhcmNoCjwJCU5vdGUgdGhhdCB0aGUgdmFsdWUgaXMgcmVzdG9yZWQgd2hlbiByZXR1cm5pbmcgZnJvbSBhCgkJZnVuY3Rpb24uIHxmdW5jdGlvbi1zZWFyY2gtdW5kb3wuCgoJCQkJCSp2Omluc2VydG1vZGUqICppbnNlcnRtb2RlLXZhcmlhYmxlKgp2Omluc2VydG1vZGUJVXNlZCBmb3IgdGhlIHxJbnNlcnRFbnRlcnwgYW5kIHxJbnNlcnRDaGFuZ2V8IGF1dG9jb21tYW5kCgkJZXZlbnRzLiAgVmFsdWVzOgoJCQlpCUluc2VydCBtb2RlCgkJCXIJUmVwbGFjZSBtb2RlCgkJCXYJVmlydHVhbCBSZXBsYWNlIG1vZGUKCgkJCQkJCSp2OmtleSogKmtleS12YXJpYWJsZSoKdjprZXkJCUtleSBvZiB0aGUgY3VycmVudCBpdGVtIG9mIGEgfERpY3Rpb25hcnl8LiAgT25seSB2YWxpZCB3aGlsZQoJCWV2YWx1YXRpbmcgdGhlIGV4cHJlc3Npb24gdXNlZCB3aXRoIHxtYXAoKXwgYW5kIHxmaWx0ZXIoKXwuCgkJUmVhZC1vbmx5LgoKCQkJCQkJKnY6bGFuZyogKmxhbmctdmFyaWFibGUqCnY6bGFuZwkJVGhlIGN1cnJlbnQgbG9jYWxlIHNldHRpbmcgZm9yIG1lc3NhZ2VzIG9mIHRoZSBydW50aW1lCgkJZW52aXJvbm1lbnQuICBUaGlzIGFsbG93cyBWaW0gc2NyaXB0cyB0byBiZSBhd2FyZSBvZiB0aGUKCQljdXJyZW50IGxhbmd1YWdlLiAgVGVjaG5pY2FsOiBpdCdzIHRoZSB2YWx1ZSBvZiBMQ19NRVNTQUdFUy4KCQlUaGUgdmFsdWUgaXMgc3lzdGVtIGRlcGVuZGVudC4KCQlUaGlzIHZhcmlhYmxlIGNhbiBub3QgYmUgc2V0IGRpcmVjdGx5LCB1c2UgdGhlIHw6bGFuZ3VhZ2V8CgkJY29tbWFuZC4KCQlJdCBjYW4gYmUgZGlmZmVyZW50IGZyb20gfHY6Y3R5cGV8IHdoZW4gbWVzc2FnZXMgYXJlIGRlc2lyZWQKCQlpbiBhIGRpZmZlcmVudCBsYW5ndWFnZSB0aGFuIHdoYXQgaXMgdXNlZCBmb3IgY2hhcmFjdGVyCgkJZW5jb2RpbmcuICBTZWUgfG11bHRpLWxhbmd8LgoKCQkJCQkJKnY6bGNfdGltZSogKmxjX3RpbWUtdmFyaWFibGUqCnY6bGNfdGltZQlUaGUgY3VycmVudCBsb2NhbGUgc2V0dGluZyBmb3IgdGltZSBtZXNzYWdlcyBvZiB0aGUgcnVudGltZQoJCWVudmlyb25tZW50LiAgVGhpcyBhbGxvd3MgVmltIHNjcmlwdHMgdG8gYmUgYXdhcmUgb2YgdGhlCgkJY3VycmVudCBsYW5ndWFnZS4gIFRlY2huaWNhbDogaXQncyB0aGUgdmFsdWUgb2YgTENfVElNRS4KCQlUaGlzIHZhcmlhYmxlIGNhbiBub3QgYmUgc2V0IGRpcmVjdGx5LCB1c2UgdGhlIHw6bGFuZ3VhZ2V8CgkJY29tbWFuZC4gIFNlZSB8bXVsdGktbGFuZ3wuCgoJCQkJCQkqdjpsbnVtKiAqbG51bS12YXJpYWJsZSoKdjpsbnVtCQlMaW5lIG51bWJlciBmb3IgdGhlICdmb2xkZXhwcicgfGZvbGQtZXhwcnwsICdmb3JtYXRleHByJyBhbmQKCQknaW5kZW50ZXhwcicgZXhwcmVzc2lvbnMsIHRhYiBwYWdlIG51bWJlciBmb3IgJ2d1aXRhYmxhYmVsJwoJCWFuZCAnZ3VpdGFidG9vbHRpcCcuICBPbmx5IHZhbGlkIHdoaWxlIG9uZSBvZiB0aGVzZQoJCWV4cHJlc3Npb25zIGlzIGJlaW5nIGV2YWx1YXRlZC4gIFJlYWQtb25seSB3aGVuIGluIHRoZQoJCXxzYW5kYm94fC4KCgkJCQkJKnY6bW91c2Vfd2luKiAqbW91c2Vfd2luLXZhcmlhYmxlKgp2Om1vdXNlX3dpbglXaW5kb3cgbnVtYmVyIGZvciBhIG1vdXNlIGNsaWNrIG9idGFpbmVkIHdpdGggfGdldGNoYXIoKXwuCgkJRmlyc3Qgd2luZG93IGhhcyBudW1iZXIgMSwgbGlrZSB3aXRoIHx3aW5ucigpfC4gIFRoZSB2YWx1ZSBpcwoJCXplcm8gd2hlbiB0aGVyZSB3YXMgbm8gbW91c2UgYnV0dG9uIGNsaWNrLgoKCQkJCQkqdjptb3VzZV9sbnVtKiAqbW91c2VfbG51bS12YXJpYWJsZSoKdjptb3VzZV9sbnVtCUxpbmUgbnVtYmVyIGZvciBhIG1vdXNlIGNsaWNrIG9idGFpbmVkIHdpdGggfGdldGNoYXIoKXwuCgkJVGhpcyBpcyB0aGUgdGV4dCBsaW5lIG51bWJlciwgbm90IHRoZSBzY3JlZW4gbGluZSBudW1iZXIuICBUaGUKCQl2YWx1ZSBpcyB6ZXJvIHdoZW4gdGhlcmUgd2FzIG5vIG1vdXNlIGJ1dHRvbiBjbGljay4KCgkJCQkJKnY6bW91c2VfY29sKiAqbW91c2VfY29sLXZhcmlhYmxlKgp2Om1vdXNlX2NvbAlDb2x1bW4gbnVtYmVyIGZvciBhIG1vdXNlIGNsaWNrIG9idGFpbmVkIHdpdGggfGdldGNoYXIoKXwuCgkJVGhpcyBpcyB0aGUgc2NyZWVuIGNvbHVtbiBudW1iZXIsIGxpa2Ugd2l0aCB8dmlydGNvbCgpfC4gIFRoZQoJCXZhbHVlIGlzIHplcm8gd2hlbiB0aGVyZSB3YXMgbm8gbW91c2UgYnV0dG9uIGNsaWNrLgoKCQkJCQkqdjpub25lKiAqbm9uZS12YXJpYWJsZSoKdjpub25lCQlBbiBlbXB0eSBTdHJpbmcuIFVzZWQgdG8gcHV0IGFuIGVtcHR5IGl0ZW0gaW4gSlNPTi4gIFNlZQoJCXxqc29uX2VuY29kZSgpfC4KCQlXaGVuIHVzZWQgYXMgYSBudW1iZXIgdGhpcyBldmFsdWF0ZXMgdG8gemVyby4KCQlXaGVuIHVzZWQgYXMgYSBzdHJpbmcgdGhpcyBldmFsdWF0ZXMgdG8gIm5vbmUiLiA+CgkJCWVjaG8gdjpub25lCjwJCQlub25lIH4KCgkJCQkJKnY6bnVsbCogKm51bGwtdmFyaWFibGUqCnY6bnVsbAkJQW4gZW1wdHkgU3RyaW5nLiBVc2VkIHRvIHB1dCAibnVsbCIgaW4gSlNPTi4gIFNlZQoJCXxqc29uX2VuY29kZSgpfC4KCQlXaGVuIHVzZWQgYXMgYSBudW1iZXIgdGhpcyBldmFsdWF0ZXMgdG8gemVyby4KCQlXaGVuIHVzZWQgYXMgYSBzdHJpbmcgdGhpcyBldmFsdWF0ZXMgdG8gIm51bGwiLiA+CgkJCWVjaG8gdjpudWxsCjwJCQludWxsIH4KCgkJCQkJKnY6b2xkZmlsZXMqICpvbGRmaWxlcy12YXJpYWJsZSoKdjpvbGRmaWxlcwlMaXN0IG9mIGZpbGUgbmFtZXMgdGhhdCBpcyBsb2FkZWQgZnJvbSB0aGUgfHZpbWluZm98IGZpbGUgb24KCQlzdGFydHVwLiAgVGhlc2UgYXJlIHRoZSBmaWxlcyB0aGF0IFZpbSByZW1lbWJlcnMgbWFya3MgZm9yLgoJCVRoZSBsZW5ndGggb2YgdGhlIExpc3QgaXMgbGltaXRlZCBieSB0aGUgJyBhcmd1bWVudCBvZiB0aGUKCQkndmltaW5mbycgb3B0aW9uIChkZWZhdWx0IGlzIDEwMCkuCgkJV2hlbiB0aGUgfHZpbWluZm98IGZpbGUgaXMgbm90IHVzZWQgdGhlIExpc3QgaXMgZW1wdHkuCgkJQWxzbyBzZWUgfDpvbGRmaWxlc3wgYW5kIHxjXyM8fC4KCQlUaGUgTGlzdCBjYW4gYmUgbW9kaWZpZWQsIGJ1dCB0aGlzIGhhcyBubyBlZmZlY3Qgb24gd2hhdCBpcwoJCXN0b3JlZCBpbiB0aGUgfHZpbWluZm98IGZpbGUgbGF0ZXIuICBJZiB5b3UgdXNlIHZhbHVlcyBvdGhlcgoJCXRoYW4gU3RyaW5nIHRoaXMgd2lsbCBjYXVzZSB0cm91YmxlLgoJCXtvbmx5IHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCt2aW1pbmZvfCBmZWF0dXJlfQoKCQkJCQkJICAgICp2Om9wdGlvbl9uZXcqCnY6b3B0aW9uX25ldyAgICBOZXcgdmFsdWUgb2YgdGhlIG9wdGlvbi4gVmFsaWQgd2hpbGUgZXhlY3V0aW5nIGFuIHxPcHRpb25TZXR8CgkJYXV0b2NvbW1hbmQuCgkJCQkJCSAgICAqdjpvcHRpb25fb2xkKgp2Om9wdGlvbl9vbGQgICAgT2xkIHZhbHVlIG9mIHRoZSBvcHRpb24uIFZhbGlkIHdoaWxlIGV4ZWN1dGluZyBhbiB8T3B0aW9uU2V0fAoJCWF1dG9jb21tYW5kLgoJCQkJCQkgICAgKnY6b3B0aW9uX3R5cGUqCnY6b3B0aW9uX3R5cGUgICBTY29wZSBvZiB0aGUgc2V0IGNvbW1hbmQuIFZhbGlkIHdoaWxlIGV4ZWN1dGluZyBhbgoJCXxPcHRpb25TZXR8IGF1dG9jb21tYW5kLiBDYW4gYmUgZWl0aGVyICJnbG9iYWwiIG9yICJsb2NhbCIKCQkJCQkqdjpvcGVyYXRvciogKm9wZXJhdG9yLXZhcmlhYmxlKgp2Om9wZXJhdG9yCVRoZSBsYXN0IG9wZXJhdG9yIGdpdmVuIGluIE5vcm1hbCBtb2RlLiAgVGhpcyBpcyBhIHNpbmdsZQoJCWNoYXJhY3RlciBleGNlcHQgZm9yIGNvbW1hbmRzIHN0YXJ0aW5nIHdpdGggPGc+IG9yIDx6PiwKCQlpbiB3aGljaCBjYXNlIGl0IGlzIHR3byBjaGFyYWN0ZXJzLiAgQmVzdCB1c2VkIGFsb25nc2lkZQoJCXx2OnByZXZjb3VudHwgYW5kIHx2OnJlZ2lzdGVyfC4gIFVzZWZ1bCBpZiB5b3Ugd2FudCB0byBjYW5jZWwKCQlPcGVyYXRvci1wZW5kaW5nIG1vZGUgYW5kIHRoZW4gdXNlIHRoZSBvcGVyYXRvciwgZS5nLjogPgoJCQk6b21hcCBPIDxFc2M+OmNhbGwgTXlNb3Rpb24odjpvcGVyYXRvcik8Q1I+CjwJCVRoZSB2YWx1ZSByZW1haW5zIHNldCB1bnRpbCBhbm90aGVyIG9wZXJhdG9yIGlzIGVudGVyZWQsIHRodXMKCQlkb24ndCBleHBlY3QgaXQgdG8gYmUgZW1wdHkuCgkJdjpvcGVyYXRvciBpcyBub3Qgc2V0IGZvciB8OmRlbGV0ZXwsIHw6eWFua3wgb3Igb3RoZXIgRXgKCQljb21tYW5kcy4KCQlSZWFkLW9ubHkuCgoJCQkJCSp2OnByZXZjb3VudCogKnByZXZjb3VudC12YXJpYWJsZSoKdjpwcmV2Y291bnQJVGhlIGNvdW50IGdpdmVuIGZvciB0aGUgbGFzdCBidXQgb25lIE5vcm1hbCBtb2RlIGNvbW1hbmQuCgkJVGhpcyBpcyB0aGUgdjpjb3VudCB2YWx1ZSBvZiB0aGUgcHJldmlvdXMgY29tbWFuZC4gIFVzZWZ1bCBpZgoJCXlvdSB3YW50IHRvIGNhbmNlbCBWaXN1YWwgb3IgT3BlcmF0b3ItcGVuZGluZyBtb2RlIGFuZCB0aGVuCgkJdXNlIHRoZSBjb3VudCwgZS5nLjogPgoJCQk6dm1hcCAlIDxFc2M+OmNhbGwgTXlGaWx0ZXIodjpwcmV2Y291bnQpPENSPgo8CQlSZWFkLW9ubHkuCgoJCQkJCSp2OnByb2ZpbGluZyogKnByb2ZpbGluZy12YXJpYWJsZSoKdjpwcm9maWxpbmcJTm9ybWFsbHkgemVyby4JU2V0IHRvIG9uZSBhZnRlciB1c2luZyAiOnByb2ZpbGUgc3RhcnQiLgoJCVNlZSB8cHJvZmlsaW5nfC4KCgkJCQkJKnY6cHJvZ25hbWUqICpwcm9nbmFtZS12YXJpYWJsZSoKdjpwcm9nbmFtZQlDb250YWlucyB0aGUgbmFtZSAod2l0aCBwYXRoIHJlbW92ZWQpIHdpdGggd2hpY2ggVmltIHdhcwoJCWludm9rZWQuICBBbGxvd3MgeW91IHRvIGRvIHNwZWNpYWwgaW5pdGlhbGlzYXRpb25zIGZvciB8dmlld3wsCgkJfGV2aW18IGV0Yy4sIG9yIGFueSBvdGhlciBuYW1lIHlvdSBtaWdodCBzeW1saW5rIHRvIFZpbS4KCQlSZWFkLW9ubHkuCgoJCQkJCSp2OnByb2dwYXRoKiAqcHJvZ3BhdGgtdmFyaWFibGUqCnY6cHJvZ3BhdGgJQ29udGFpbnMgdGhlIGNvbW1hbmQgd2l0aCB3aGljaCBWaW0gd2FzIGludm9rZWQsIGluY2x1ZGluZyB0aGUKCQlwYXRoLiAgVXNlZnVsIGlmIHlvdSB3YW50IHRvIG1lc3NhZ2UgYSBWaW0gc2VydmVyIHVzaW5nIGEKCQl8LS1yZW1vdGUtZXhwcnwuCgkJVG8gZ2V0IHRoZSBmdWxsIHBhdGggdXNlOiA+CgkJCWVjaG8gZXhlcGF0aCh2OnByb2dwYXRoKQo8CQlOT1RFOiBUaGlzIGRvZXMgbm90IHdvcmsgd2hlbiB0aGUgY29tbWFuZCBpcyBhIHJlbGF0aXZlIHBhdGgKCQlhbmQgdGhlIGN1cnJlbnQgZGlyZWN0b3J5IGhhcyBjaGFuZ2VkLgoJCVJlYWQtb25seS4KCgkJCQkJKnY6cmVnaXN0ZXIqICpyZWdpc3Rlci12YXJpYWJsZSoKdjpyZWdpc3RlcglUaGUgbmFtZSBvZiB0aGUgcmVnaXN0ZXIgaW4gZWZmZWN0IGZvciB0aGUgY3VycmVudCBub3JtYWwgbW9kZQoJCWNvbW1hbmQgKHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciB0aGF0IGNvbW1hbmQgYWN0dWFsbHkgdXNlZCBhCgkJcmVnaXN0ZXIpLiAgT3IgZm9yIHRoZSBjdXJyZW50bHkgZXhlY3V0aW5nIG5vcm1hbCBtb2RlIG1hcHBpbmcKCQkodXNlIHRoaXMgaW4gY3VzdG9tIGNvbW1hbmRzIHRoYXQgdGFrZSBhIHJlZ2lzdGVyKS4KCQlJZiBub25lIGlzIHN1cHBsaWVkIGl0IGlzIHRoZSBkZWZhdWx0IHJlZ2lzdGVyICciJywgdW5sZXNzCgkJJ2NsaXBib2FyZCcgY29udGFpbnMgInVubmFtZWQiIG9yICJ1bm5hbWVkcGx1cyIsIHRoZW4gaXQgaXMKCQknKicgb3IgJysnLgoJCUFsc28gc2VlIHxnZXRyZWcoKXwgYW5kIHxzZXRyZWcoKXwKCgkJCQkJKnY6c2Nyb2xsc3RhcnQqICpzY3JvbGxzdGFydC12YXJpYWJsZSoKdjpzY3JvbGxzdGFydAlTdHJpbmcgZGVzY3JpYmluZyB0aGUgc2NyaXB0IG9yIGZ1bmN0aW9uIHRoYXQgY2F1c2VkIHRoZQoJCXNjcmVlbiB0byBzY3JvbGwgdXAuICBJdCdzIG9ubHkgc2V0IHdoZW4gaXQgaXMgZW1wdHksIHRodXMgdGhlCgkJZmlyc3QgcmVhc29uIGlzIHJlbWVtYmVyZWQuICBJdCBpcyBzZXQgdG8gIlVua25vd24iIGZvciBhCgkJdHlwZWQgY29tbWFuZC4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIGZpbmQgb3V0IHdoeSB5b3VyIHNjcmlwdCBjYXVzZXMgdGhlCgkJaGl0LWVudGVyIHByb21wdC4KCgkJCQkJKnY6c2VydmVybmFtZSogKnNlcnZlcm5hbWUtdmFyaWFibGUqCnY6c2VydmVybmFtZQlUaGUgcmVzdWx0aW5nIHJlZ2lzdGVyZWQgfHgxMS1jbGllbnRzZXJ2ZXJ8IG5hbWUgaWYgYW55LgoJCVJlYWQtb25seS4KCgkJCnY6c2VhcmNoZm9yd2FyZAkJCSp2OnNlYXJjaGZvcndhcmQqICpzZWFyY2hmb3J3YXJkLXZhcmlhYmxlKgoJCVNlYXJjaCBkaXJlY3Rpb246ICAxIGFmdGVyIGEgZm9yd2FyZCBzZWFyY2gsIDAgYWZ0ZXIgYQoJCWJhY2t3YXJkIHNlYXJjaC4gIEl0IGlzIHJlc2V0IHRvIGZvcndhcmQgd2hlbiBkaXJlY3RseSBzZXR0aW5nCgkJdGhlIGxhc3Qgc2VhcmNoIHBhdHRlcm4sIHNlZSB8cXVvdGUvfC4KCQlOb3RlIHRoYXQgdGhlIHZhbHVlIGlzIHJlc3RvcmVkIHdoZW4gcmV0dXJuaW5nIGZyb20gYQoJCWZ1bmN0aW9uLiB8ZnVuY3Rpb24tc2VhcmNoLXVuZG98LgoJCVJlYWQtd3JpdGUuCgoJCQkJCSp2OnNoZWxsX2Vycm9yKiAqc2hlbGxfZXJyb3ItdmFyaWFibGUqCnY6c2hlbGxfZXJyb3IJUmVzdWx0IG9mIHRoZSBsYXN0IHNoZWxsIGNvbW1hbmQuICBXaGVuIG5vbi16ZXJvLCB0aGUgbGFzdAoJCXNoZWxsIGNvbW1hbmQgaGFkIGFuIGVycm9yLiAgV2hlbiB6ZXJvLCB0aGVyZSB3YXMgbm8gcHJvYmxlbS4KCQlUaGlzIG9ubHkgd29ya3Mgd2hlbiB0aGUgc2hlbGwgcmV0dXJucyB0aGUgZXJyb3IgY29kZSB0byBWaW0uCgkJVGhlIHZhbHVlIC0xIGlzIG9mdGVuIHVzZWQgd2hlbiB0aGUgY29tbWFuZCBjb3VsZCBub3QgYmUKCQlleGVjdXRlZC4gIFJlYWQtb25seS4KCQlFeGFtcGxlOiA+Cgk6IW12IGZvbyBiYXIKCTppZiB2OnNoZWxsX2Vycm9yCgk6ICBlY2hvICdjb3VsZCBub3QgcmVuYW1lICJmb28iIHRvICJiYXIiIScKCTplbmRpZgo8CQkic2hlbGxfZXJyb3IiIGFsc28gd29ya3MsIGZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eS4KCgkJCQkJKnY6c3RhdHVzbXNnKiAqc3RhdHVzbXNnLXZhcmlhYmxlKgp2OnN0YXR1c21zZwlMYXN0IGdpdmVuIHN0YXR1cyBtZXNzYWdlLiAgSXQncyBhbGxvd2VkIHRvIHNldCB0aGlzIHZhcmlhYmxlLgoKCQkJCQkqdjpzd2FwbmFtZSogKnN3YXBuYW1lLXZhcmlhYmxlKgp2OnN3YXBuYW1lCU9ubHkgdmFsaWQgd2hlbiBleGVjdXRpbmcgfFN3YXBFeGlzdHN8IGF1dG9jb21tYW5kczogTmFtZSBvZgoJCXRoZSBzd2FwIGZpbGUgZm91bmQuICBSZWFkLW9ubHkuCgoJCQkJCSp2OnN3YXBjaG9pY2UqICpzd2FwY2hvaWNlLXZhcmlhYmxlKgp2OnN3YXBjaG9pY2UJfFN3YXBFeGlzdHN8IGF1dG9jb21tYW5kcyBjYW4gc2V0IHRoaXMgdG8gdGhlIHNlbGVjdGVkIGNob2ljZQoJCWZvciBoYW5kbGluZyBhbiBleGlzdGluZyBzd2FwIGZpbGU6CgkJCSdvJwlPcGVuIHJlYWQtb25seQoJCQknZScJRWRpdCBhbnl3YXkKCQkJJ3InCVJlY292ZXIKCQkJJ2QnCURlbGV0ZSBzd2FwZmlsZQoJCQkncScJUXVpdAoJCQknYScJQWJvcnQKCQlUaGUgdmFsdWUgc2hvdWxkIGJlIGEgc2luZ2xlLWNoYXJhY3RlciBzdHJpbmcuCUFuIGVtcHR5IHZhbHVlCgkJcmVzdWx0cyBpbiB0aGUgdXNlciBiZWluZyBhc2tlZCwgYXMgd291bGQgaGFwcGVuIHdoZW4gdGhlcmUgaXMKCQlubyBTd2FwRXhpc3RzIGF1dG9jb21tYW5kLiAgVGhlIGRlZmF1bHQgaXMgZW1wdHkuCgoJCQkJCSp2OnN3YXBjb21tYW5kKiAqc3dhcGNvbW1hbmQtdmFyaWFibGUqCnY6c3dhcGNvbW1hbmQJTm9ybWFsIG1vZGUgY29tbWFuZCB0byBiZSBleGVjdXRlZCBhZnRlciBhIGZpbGUgaGFzIGJlZW4KCQlvcGVuZWQuICBDYW4gYmUgdXNlZCBmb3IgYSB8U3dhcEV4aXN0c3wgYXV0b2NvbW1hbmQgdG8gaGF2ZQoJCWFub3RoZXIgVmltIG9wZW4gdGhlIGZpbGUgYW5kIGp1bXAgdG8gdGhlIHJpZ2h0IHBsYWNlLglGb3IKCQlleGFtcGxlLCB3aGVuIGp1bXBpbmcgdG8gYSB0YWcgdGhlIHZhbHVlIGlzICI6dGFnIHRhZ25hbWVcciIuCgkJRm9yICI6ZWRpdCArY21kIGZpbGUiIHRoZSB2YWx1ZSBpcyAiOmNtZFxyIi4KCgkJCQkqdjp0ZXJtcmVzcG9uc2UqICp0ZXJtcmVzcG9uc2UtdmFyaWFibGUqCnY6dGVybXJlc3BvbnNlCVRoZSBlc2NhcGUgc2VxdWVuY2UgcmV0dXJuZWQgYnkgdGhlIHRlcm1pbmFsIGZvciB0aGUgfHRfUlZ8CgkJdGVybWNhcCBlbnRyeS4JSXQgaXMgc2V0IHdoZW4gVmltIHJlY2VpdmVzIGFuIGVzY2FwZSBzZXF1ZW5jZQoJCXRoYXQgc3RhcnRzIHdpdGggRVNDIFsgb3IgQ1NJIGFuZCBlbmRzIGluIGEgJ2MnLCB3aXRoIG9ubHkKCQlkaWdpdHMsICc7JyBhbmQgJy4nIGluIGJldHdlZW4uCgkJV2hlbiB0aGlzIG9wdGlvbiBpcyBzZXQsIHRoZSBUZXJtUmVzcG9uc2UgYXV0b2NvbW1hbmQgZXZlbnQgaXMKCQlmaXJlZCwgc28gdGhhdCB5b3UgY2FuIHJlYWN0IHRvIHRoZSByZXNwb25zZSBmcm9tIHRoZQoJCXRlcm1pbmFsLgoJCVRoZSByZXNwb25zZSBmcm9tIGEgbmV3IHh0ZXJtIGlzOiAiPEVzYz5bIFBwIDsgUHYgOyBQYyBjIi4gIFBwCgkJaXMgdGhlIHRlcm1pbmFsIHR5cGU6IDAgZm9yIHZ0MTAwIGFuZCAxIGZvciB2dDIyMC4gIFB2IGlzIHRoZQoJCXBhdGNoIGxldmVsIChzaW5jZSB0aGlzIHdhcyBpbnRyb2R1Y2VkIGluIHBhdGNoIDk1LCBpdCdzCgkJYWx3YXlzIDk1IG9yIGJpZ2dlcikuICBQYyBpcyBhbHdheXMgemVyby4KCQl7b25seSB3aGVuIGNvbXBpbGVkIHdpdGggfCt0ZXJtcmVzcG9uc2V8IGZlYXR1cmV9CgoJCQkJCSp2OnRlc3RpbmcqICp0ZXN0aW5nLXZhcmlhYmxlKgp2OnRlc3RpbmcJTXVzdCBiZSBzZXQgYmVmb3JlIHVzaW5nIGBnYXJiYWdlY29sbGVjdF9mb3JfdGVzdGluZygpYC4KCgkJCQkqdjp0aGlzX3Nlc3Npb24qICp0aGlzX3Nlc3Npb24tdmFyaWFibGUqCnY6dGhpc19zZXNzaW9uCUZ1bGwgZmlsZW5hbWUgb2YgdGhlIGxhc3QgbG9hZGVkIG9yIHNhdmVkIHNlc3Npb24gZmlsZS4gIFNlZQoJCXw6bWtzZXNzaW9ufC4gIEl0IGlzIGFsbG93ZWQgdG8gc2V0IHRoaXMgdmFyaWFibGUuICBXaGVuIG5vCgkJc2Vzc2lvbiBmaWxlIGhhcyBiZWVuIHNhdmVkLCB0aGlzIHZhcmlhYmxlIGlzIGVtcHR5LgoJCSJ0aGlzX3Nlc3Npb24iIGFsc28gd29ya3MsIGZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eS4KCgkJCQkJKnY6dGhyb3dwb2ludCogKnRocm93cG9pbnQtdmFyaWFibGUqCnY6dGhyb3dwb2ludAlUaGUgcG9pbnQgd2hlcmUgdGhlIGV4Y2VwdGlvbiBtb3N0IHJlY2VudGx5IGNhdWdodCBhbmQgbm90CgkJZmluaXNoZWQgd2FzIHRocm93bi4gIE5vdCBzZXQgd2hlbiBjb21tYW5kcyBhcmUgdHlwZWQuCVNlZQoJCWFsc28gfHY6ZXhjZXB0aW9ufCBhbmQgfHRocm93LXZhcmlhYmxlc3wuCgkJRXhhbXBsZTogPgoJOnRyeQoJOiAgdGhyb3cgIm9vcHMiCgk6Y2F0Y2ggLy4qLwoJOiAgZWNobyAiRXhjZXB0aW9uIGZyb20iIHY6dGhyb3dwb2ludAoJOmVuZHRyeQo8CQlPdXRwdXQ6ICJFeGNlcHRpb24gZnJvbSB0ZXN0LnZpbSwgbGluZSAyIgoKCQkJCQkJKnY6dHJ1ZSogKnRydWUtdmFyaWFibGUqCnY6dHJ1ZQkJQSBOdW1iZXIgd2l0aCB2YWx1ZSBvbmUuIFVzZWQgdG8gcHV0ICJ0cnVlIiBpbiBKU09OLiAgU2VlCgkJfGpzb25fZW5jb2RlKCl8LgoJCVdoZW4gdXNlZCBhcyBhIHN0cmluZyB0aGlzIGV2YWx1YXRlcyB0byAidHJ1ZSIuID4KCQkJZWNobyB2OnRydWUKPAkJCXRydWUgfgoJCQkJCQkqdjp2YWwqICp2YWwtdmFyaWFibGUqCnY6dmFsCQlWYWx1ZSBvZiB0aGUgY3VycmVudCBpdGVtIG9mIGEgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fC4JT25seQoJCXZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlIGV4cHJlc3Npb24gdXNlZCB3aXRoIHxtYXAoKXwgYW5kCgkJfGZpbHRlcigpfC4gIFJlYWQtb25seS4KCgkJCQkJKnY6dmVyc2lvbiogKnZlcnNpb24tdmFyaWFibGUqCnY6dmVyc2lvbglWZXJzaW9uIG51bWJlciBvZiBWaW06IE1ham9yIHZlcnNpb24gbnVtYmVyIHRpbWVzIDEwMCBwbHVzCgkJbWlub3IgdmVyc2lvbiBudW1iZXIuICBWZXJzaW9uIDUuMCBpcyA1MDAuICBWZXJzaW9uIDUuMSAoNS4wMSkKCQlpcyA1MDEuICBSZWFkLW9ubHkuICAidmVyc2lvbiIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcwoJCWNvbXBhdGliaWxpdHkuCgkJVXNlIHxoYXMoKXwgdG8gY2hlY2sgaWYgYSBjZXJ0YWluIHBhdGNoIHdhcyBpbmNsdWRlZCwgZS5nLjogPgoJCQlpZiBoYXMoInBhdGNoLTcuNC4xMjMiKQo8CQlOb3RlIHRoYXQgcGF0Y2ggbnVtYmVycyBhcmUgc3BlY2lmaWMgdG8gdGhlIHZlcnNpb24sIHRodXMgYm90aAoJCXZlcnNpb24gNS4wIGFuZCA1LjEgbWF5IGhhdmUgYSBwYXRjaCAxMjMsIGJ1dCB0aGVzZSBhcmUKCQljb21wbGV0ZWx5IGRpZmZlcmVudC4KCgkJCQkqdjp2aW1fZGlkX2VudGVyKiAqdmltX2RpZF9lbnRlci12YXJpYWJsZSoKdjp2aW1fZGlkX2VudGVyCVplcm8gdW50aWwgbW9zdCBvZiBzdGFydHVwIGlzIGRvbmUuICBJdCBpcyBzZXQgdG8gb25lIGp1c3QKCQliZWZvcmUgfFZpbUVudGVyfCBhdXRvY29tbWFuZHMgYXJlIHRyaWdnZXJlZC4KCgkJCQkJKnY6d2FybmluZ21zZyogKndhcm5pbmdtc2ctdmFyaWFibGUqCnY6d2FybmluZ21zZwlMYXN0IGdpdmVuIHdhcm5pbmcgbWVzc2FnZS4gIEl0J3MgYWxsb3dlZCB0byBzZXQgdGhpcyB2YXJpYWJsZS4KCgkJCQkJKnY6d2luZG93aWQqICp3aW5kb3dpZC12YXJpYWJsZSoKdjp3aW5kb3dpZAlXaGVuIGFueSBYMTEgYmFzZWQgR1VJIGlzIHJ1bm5pbmcgb3Igd2hlbiBydW5uaW5nIGluIGEKCQl0ZXJtaW5hbCBhbmQgVmltIGNvbm5lY3RzIHRvIHRoZSBYIHNlcnZlciAofC1YfCkgdGhpcyB3aWxsIGJlCgkJc2V0IHRvIHRoZSB3aW5kb3cgSUQuCgkJV2hlbiBhbiBNUy1XaW5kb3dzIEdVSSBpcyBydW5uaW5nIHRoaXMgd2lsbCBiZSBzZXQgdG8gdGhlCgkJd2luZG93IGhhbmRsZS4KCQlPdGhlcndpc2UgdGhlIHZhbHVlIGlzIHplcm8uCgkJTm90ZTogZm9yIHdpbmRvd3MgaW5zaWRlIFZpbSB1c2UgfHdpbm5yKCl8LgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjQuIEJ1aWx0aW4gRnVuY3Rpb25zCQkJCQkqZnVuY3Rpb25zKgoKU2VlIHxmdW5jdGlvbi1saXN0fCBmb3IgYSBsaXN0IGdyb3VwZWQgYnkgd2hhdCB0aGUgZnVuY3Rpb24gaXMgdXNlZCBmb3IuCgooVXNlIENUUkwtXSBvbiB0aGUgZnVuY3Rpb24gbmFtZSB0byBqdW1wIHRvIHRoZSBmdWxsIGV4cGxhbmF0aW9uLikKClVTQUdFCQkJCVJFU1VMVAlERVNDUklQVElPTgl+CgphYnMoe2V4cHJ9KQkJCUZsb2F0IG9yIE51bWJlciAgYWJzb2x1dGUgdmFsdWUgb2Yge2V4cHJ9CmFjb3Moe2V4cHJ9KQkJCUZsb2F0CWFyYyBjb3NpbmUgb2Yge2V4cHJ9CmFkZCh7bGlzdH0sIHtpdGVtfSkJCUxpc3QJYXBwZW5kIHtpdGVtfSB0byB8TGlzdHwge2xpc3R9CmFsbG9jX2ZhaWwoe2lkfSwge2NvdW50ZG93bn0sIHtyZXBlYXR9KQoJCQkJbm9uZQltYWtlIG1lbW9yeSBhbGxvY2F0aW9uIGZhaWwKYW5kKHtleHByfSwge2V4cHJ9KQkJTnVtYmVyICBiaXR3aXNlIEFORAphcHBlbmQoe2xudW19LCB7c3RyaW5nfSkJTnVtYmVyCWFwcGVuZCB7c3RyaW5nfSBiZWxvdyBsaW5lIHtsbnVtfQphcHBlbmQoe2xudW19LCB7bGlzdH0pCQlOdW1iZXIJYXBwZW5kIGxpbmVzIHtsaXN0fSBiZWxvdyBsaW5lIHtsbnVtfQphcmdjKCkJCQkJTnVtYmVyCW51bWJlciBvZiBmaWxlcyBpbiB0aGUgYXJndW1lbnQgbGlzdAphcmdpZHgoKQkJCU51bWJlcgljdXJyZW50IGluZGV4IGluIHRoZSBhcmd1bWVudCBsaXN0CmFyZ2xpc3RpZChbe3dpbm5yfSBbLCB7dGFibnJ9XV0pIE51bWJlcglhcmd1bWVudCBsaXN0IGlkCmFyZ3Yoe25yfSkJCQlTdHJpbmcJe25yfSBlbnRyeSBvZiB0aGUgYXJndW1lbnQgbGlzdAphcmd2KCkJCQkJTGlzdAl0aGUgYXJndW1lbnQgbGlzdAphc3NlcnRfZXF1YWwoe2V4cH0sIHthY3R9IFssIHttc2d9XSkgICAgIG5vbmUgIGFzc2VydCB7ZXhwfSBpcyBlcXVhbCB0byB7YWN0fQphc3NlcnRfZXhjZXB0aW9uKHtlcnJvcn0gWywge21zZ31dKSAgICAgIG5vbmUgIGFzc2VydCB7ZXJyb3J9IGlzIGluIHY6ZXhjZXB0aW9uCmFzc2VydF9mYWlscyh7Y21kfSBbLCB7ZXJyb3J9XSkgICAgICAgICAgbm9uZSAgYXNzZXJ0IHtjbWR9IGZhaWxzCmFzc2VydF9mYWxzZSh7YWN0dWFsfSBbLCB7bXNnfV0pICAgICAgICAgbm9uZSAgYXNzZXJ0IHthY3R1YWx9IGlzIGZhbHNlCmFzc2VydF9tYXRjaCh7cGF0fSwge3RleHR9IFssIHttc2d9XSkgICAgbm9uZSAgYXNzZXJ0IHtwYXR9IG1hdGNoZXMge3RleHR9CmFzc2VydF9ub3RlcXVhbCh7ZXhwfSwge2FjdH0gWywge21zZ31dKSAgbm9uZSAgYXNzZXJ0IHtleHB9IGlzIG5vdCBlcXVhbCB7YWN0fQphc3NlcnRfbm90bWF0Y2goe3BhdH0sIHt0ZXh0fSBbLCB7bXNnfV0pIG5vbmUgIGFzc2VydCB7cGF0fSBub3QgbWF0Y2hlcyB7dGV4dH0KYXNzZXJ0X3RydWUoe2FjdHVhbH0gWywge21zZ31dKSAgICAgICAgICBub25lICBhc3NlcnQge2FjdHVhbH0gaXMgdHJ1ZQphc2luKHtleHByfSkJCQlGbG9hdAlhcmMgc2luZSBvZiB7ZXhwcn0KYXRhbih7ZXhwcn0pCQkJRmxvYXQJYXJjIHRhbmdlbnQgb2Yge2V4cHJ9CmF0YW4yKHtleHByfSwge2V4cHJ9KQkJRmxvYXQgICBhcmMgdGFuZ2VudCBvZiB7ZXhwcjF9IC8ge2V4cHIyfQpicm93c2Uoe3NhdmV9LCB7dGl0bGV9LCB7aW5pdGRpcn0sIHtkZWZhdWx0fSkKCQkJCVN0cmluZwlwdXQgdXAgYSBmaWxlIHJlcXVlc3Rlcgpicm93c2VkaXIoe3RpdGxlfSwge2luaXRkaXJ9KQlTdHJpbmcJcHV0IHVwIGEgZGlyZWN0b3J5IHJlcXVlc3RlcgpidWZleGlzdHMoe2V4cHJ9KQkJTnVtYmVyCVRSVUUgaWYgYnVmZmVyIHtleHByfSBleGlzdHMKYnVmbGlzdGVkKHtleHByfSkJCU51bWJlcglUUlVFIGlmIGJ1ZmZlciB7ZXhwcn0gaXMgbGlzdGVkCmJ1ZmxvYWRlZCh7ZXhwcn0pCQlOdW1iZXIJVFJVRSBpZiBidWZmZXIge2V4cHJ9IGlzIGxvYWRlZApidWZuYW1lKHtleHByfSkJCQlTdHJpbmcJTmFtZSBvZiB0aGUgYnVmZmVyIHtleHByfQpidWZucih7ZXhwcn0gWywge2NyZWF0ZX1dKQlOdW1iZXIJTnVtYmVyIG9mIHRoZSBidWZmZXIge2V4cHJ9CmJ1Zndpbm5yKHtleHByfSkJCU51bWJlcgl3aW5kb3cgbnVtYmVyIG9mIGJ1ZmZlciB7ZXhwcn0KYnl0ZTJsaW5lKHtieXRlfSkJCU51bWJlcglsaW5lIG51bWJlciBhdCBieXRlIGNvdW50IHtieXRlfQpieXRlaWR4KHtleHByfSwge25yfSkJCU51bWJlcglieXRlIGluZGV4IG9mIHtucn0ndGggY2hhciBpbiB7ZXhwcn0KYnl0ZWlkeGNvbXAoe2V4cHJ9LCB7bnJ9KQlOdW1iZXIJYnl0ZSBpbmRleCBvZiB7bnJ9J3RoIGNoYXIgaW4ge2V4cHJ9CmNhbGwoe2Z1bmN9LCB7YXJnbGlzdH0gWywge2RpY3R9XSkKCQkJCWFueQljYWxsIHtmdW5jfSB3aXRoIGFyZ3VtZW50cyB7YXJnbGlzdH0KY2VpbCh7ZXhwcn0pCQkJRmxvYXQJcm91bmQge2V4cHJ9IHVwCmNoX2Nsb3NlKHtoYW5kbGV9KQkJbm9uZQljbG9zZSB7aGFuZGxlfQpjaF9ldmFsZXhwcih7aGFuZGxlfSwge2V4cHJ9IFssIHtvcHRpb25zfV0pCgkJCQlhbnkJZXZhbHVhdGUge2V4cHJ9IG9uIEpTT04ge2hhbmRsZX0KY2hfZXZhbHJhdyh7aGFuZGxlfSwge3N0cmluZ30gWywge29wdGlvbnN9XSkKCQkJCWFueQlldmFsdWF0ZSB7c3RyaW5nfSBvbiByYXcge2hhbmRsZX0KY2hfZ2V0YnVmbnIoe2hhbmRsZX0sIHt3aGF0fSkJTnVtYmVyCWdldCBidWZmZXIgbnVtYmVyIGZvciB7aGFuZGxlfS97d2hhdH0KY2hfZ2V0am9iKHtjaGFubmVsfSkJCUpvYglnZXQgdGhlIEpvYiBvZiB7Y2hhbm5lbH0KY2hfaW5mbyh7aGFuZGxlfSkJCVN0cmluZwlpbmZvIGFib3V0IGNoYW5uZWwgIHtoYW5kbGV9CmNoX2xvZyh7bXNnfSBbLCB7aGFuZGxlfV0pCW5vbmUJd3JpdGUge21zZ30gaW4gdGhlIGNoYW5uZWwgbG9nIGZpbGUKY2hfbG9nZmlsZSh7Zm5hbWV9IFssIHttb2RlfV0pCW5vbmUJc3RhcnQgbG9nZ2luZyBjaGFubmVsIGFjdGl2aXR5CmNoX29wZW4oe2FkZHJlc3N9IFssIHtvcHRpb25zfV0pCgkJCQlDaGFubmVsIG9wZW4gYSBjaGFubmVsIHRvIHthZGRyZXNzfQpjaF9yZWFkKHtoYW5kbGV9IFssIHtvcHRpb25zfV0pIFN0cmluZyAgcmVhZCBmcm9tICB7aGFuZGxlfQpjaF9yZWFkcmF3KHtoYW5kbGV9IFssIHtvcHRpb25zfV0pCgkJCQlTdHJpbmcgIHJlYWQgcmF3IGZyb20gIHtoYW5kbGV9CmNoX3NlbmRleHByKHtoYW5kbGV9LCB7ZXhwcn0gWywge29wdGlvbnN9XSkKCQkJCWFueQlzZW5kIHtleHByfSBvdmVyIEpTT04ge2hhbmRsZX0KY2hfc2VuZHJhdyh7aGFuZGxlfSwge3N0cmluZ30gWywge29wdGlvbnN9XSkKCQkJCWFueQlzZW5kIHtzdHJpbmd9IG92ZXIgcmF3IHtoYW5kbGV9CmNoX3NldG9wdGlvbnMoe2hhbmRsZX0sIHtvcHRpb25zfSkKCQkJCW5vbmUJc2V0IG9wdGlvbnMgZm9yIHtoYW5kbGV9CmNoX3N0YXR1cyh7aGFuZGxlfSkJCVN0cmluZwlzdGF0dXMgb2YgY2hhbm5lbCAge2hhbmRsZX0KY2hhbmdlbnIoKQkJCU51bWJlcgljdXJyZW50IGNoYW5nZSBudW1iZXIKY2hhcjJucih7ZXhwcn1bLCB7dXRmOH1dKQlOdW1iZXIJQVNDSUkvVVRGOCB2YWx1ZSBvZiBmaXJzdCBjaGFyIGluIHtleHByfQpjaW5kZW50KHtsbnVtfSkJCQlOdW1iZXIJQyBpbmRlbnQgZm9yIGxpbmUge2xudW19CmNsZWFybWF0Y2hlcygpCQkJbm9uZQljbGVhciBhbGwgbWF0Y2hlcwpjb2woe2V4cHJ9KQkJCU51bWJlcgljb2x1bW4gbnIgb2YgY3Vyc29yIG9yIG1hcmsKY29tcGxldGUoe3N0YXJ0Y29sfSwge21hdGNoZXN9KSBub25lCXNldCBJbnNlcnQgbW9kZSBjb21wbGV0aW9uCmNvbXBsZXRlX2FkZCh7ZXhwcn0pCQlOdW1iZXIJYWRkIGNvbXBsZXRpb24gbWF0Y2gKY29tcGxldGVfY2hlY2soKQkJTnVtYmVyCWNoZWNrIGZvciBrZXkgdHlwZWQgZHVyaW5nIGNvbXBsZXRpb24KY29uZmlybSh7bXNnfSBbLCB7Y2hvaWNlc30gWywge2RlZmF1bHR9IFssIHt0eXBlfV1dXSkKCQkJCU51bWJlcgludW1iZXIgb2YgY2hvaWNlIHBpY2tlZCBieSB1c2VyCmNvcHkoe2V4cHJ9KQkJCWFueQltYWtlIGEgc2hhbGxvdyBjb3B5IG9mIHtleHByfQpjb3Moe2V4cHJ9KQkJCUZsb2F0CWNvc2luZSBvZiB7ZXhwcn0KY29zaCh7ZXhwcn0pCQkJRmxvYXQJaHlwZXJib2xpYyBjb3NpbmUgb2Yge2V4cHJ9CmNvdW50KHtsaXN0fSwge2V4cHJ9IFssIHtpY30gWywge3N0YXJ0fV1dKQoJCQkJTnVtYmVyCSBjb3VudCBob3cgbWFueSB7ZXhwcn0gYXJlIGluIHtsaXN0fQpjc2NvcGVfY29ubmVjdGlvbihbe251bX0gLCB7ZGJwYXRofSBbLCB7cHJlcGVuZH1dXSkKCQkJCU51bWJlcgljaGVja3MgZXhpc3RlbmNlIG9mIGNzY29wZSBjb25uZWN0aW9uCmN1cnNvcih7bG51bX0sIHtjb2x9IFssIHtvZmZ9XSkKCQkJCU51bWJlcgltb3ZlIGN1cnNvciB0byB7bG51bX0sIHtjb2x9LCB7b2ZmfQpjdXJzb3Ioe2xpc3R9KQkJCU51bWJlcgltb3ZlIGN1cnNvciB0byBwb3NpdGlvbiBpbiB7bGlzdH0KZGVlcGNvcHkoe2V4cHJ9IFssIHtub3JlZn1dKQlhbnkJbWFrZSBhIGZ1bGwgY29weSBvZiB7ZXhwcn0KZGVsZXRlKHtmbmFtZX0gWywge2ZsYWdzfV0pCU51bWJlcglkZWxldGUgdGhlIGZpbGUgb3IgZGlyZWN0b3J5IHtmbmFtZX0KZGlkX2ZpbGV0eXBlKCkJCQlOdW1iZXIJVFJVRSBpZiBGaWxlVHlwZSBhdXRvY29tbWFuZCBldmVudCB1c2VkCmRpZmZfZmlsbGVyKHtsbnVtfSkJCU51bWJlcglkaWZmIGZpbGxlciBsaW5lcyBhYm91dCB7bG51bX0KZGlmZl9obElEKHtsbnVtfSwge2NvbH0pCU51bWJlcglkaWZmIGhpZ2hsaWdodGluZyBhdCB7bG51bX0ve2NvbH0KZGlzYWJsZV9jaGFyX2F2YWlsX2Zvcl90ZXN0aW5nKHtleHByfSkKCQkJCW5vbmUJdGVzdCB3aXRob3V0IHR5cGVhaGVhZAplbXB0eSh7ZXhwcn0pCQkJTnVtYmVyCVRSVUUgaWYge2V4cHJ9IGlzIGVtcHR5CmVzY2FwZSh7c3RyaW5nfSwge2NoYXJzfSkJU3RyaW5nCWVzY2FwZSB7Y2hhcnN9IGluIHtzdHJpbmd9IHdpdGggJ1wnCmV2YWwoe3N0cmluZ30pCQkJYW55CWV2YWx1YXRlIHtzdHJpbmd9IGludG8gaXRzIHZhbHVlCmV2ZW50aGFuZGxlcigpCQkJTnVtYmVyCVRSVUUgaWYgaW5zaWRlIGFuIGV2ZW50IGhhbmRsZXIKZXhlY3V0YWJsZSh7ZXhwcn0pCQlOdW1iZXIJMSBpZiBleGVjdXRhYmxlIHtleHByfSBleGlzdHMKZXhlcGF0aCh7ZXhwcn0pCQkJU3RyaW5nICBmdWxsIHBhdGggb2YgdGhlIGNvbW1hbmQge2V4cHJ9CmV4aXN0cyh7ZXhwcn0pCQkJTnVtYmVyCVRSVUUgaWYge2V4cHJ9IGV4aXN0cwpleHRlbmQoe2V4cHIxfSwge2V4cHIyfSBbLCB7ZXhwcjN9XSkKCQkJCUxpc3QvRGljdCBpbnNlcnQgaXRlbXMgb2Yge2V4cHIyfSBpbnRvIHtleHByMX0KZXhwKHtleHByfSkJCQlGbG9hdAlleHBvbmVudGlhbCBvZiB7ZXhwcn0KZXhwYW5kKHtleHByfSBbLCB7bm9zdWZ9IFssIHtsaXN0fV1dKQoJCQkJYW55CWV4cGFuZCBzcGVjaWFsIGtleXdvcmRzIGluIHtleHByfQpmZWVka2V5cyh7c3RyaW5nfSBbLCB7bW9kZX1dKQlOdW1iZXIJYWRkIGtleSBzZXF1ZW5jZSB0byB0eXBlYWhlYWQgYnVmZmVyCmZpbGVyZWFkYWJsZSh7ZmlsZX0pCQlOdW1iZXIJVFJVRSBpZiB7ZmlsZX0gaXMgYSByZWFkYWJsZSBmaWxlCmZpbGV3cml0YWJsZSh7ZmlsZX0pCQlOdW1iZXIJVFJVRSBpZiB7ZmlsZX0gaXMgYSB3cml0YWJsZSBmaWxlCmZpbHRlcih7ZXhwcn0sIHtzdHJpbmd9KQlMaXN0L0RpY3QgIHJlbW92ZSBpdGVtcyBmcm9tIHtleHByfSB3aGVyZQoJCQkJCXtzdHJpbmd9IGlzIDAKZmluZGRpcih7bmFtZX1bLCB7cGF0aH1bLCB7Y291bnR9XV0pCgkJCQlTdHJpbmcJZmluZCBkaXJlY3Rvcnkge25hbWV9IGluIHtwYXRofQpmaW5kZmlsZSh7bmFtZX1bLCB7cGF0aH1bLCB7Y291bnR9XV0pCgkJCQlTdHJpbmcJZmluZCBmaWxlIHtuYW1lfSBpbiB7cGF0aH0KZmxvYXQybnIoe2V4cHJ9KQkJTnVtYmVyCWNvbnZlcnQgRmxvYXQge2V4cHJ9IHRvIGEgTnVtYmVyCmZsb29yKHtleHByfSkJCQlGbG9hdAlyb3VuZCB7ZXhwcn0gZG93bgpmbW9kKHtleHByMX0sIHtleHByMn0pCQlGbG9hdAlyZW1haW5kZXIgb2Yge2V4cHIxfSAvIHtleHByMn0KZm5hbWVlc2NhcGUoe2ZuYW1lfSkJCVN0cmluZwllc2NhcGUgc3BlY2lhbCBjaGFyYWN0ZXJzIGluIHtmbmFtZX0KZm5hbWVtb2RpZnkoe2ZuYW1lfSwge21vZHN9KQlTdHJpbmcJbW9kaWZ5IGZpbGUgbmFtZQpmb2xkY2xvc2VkKHtsbnVtfSkJCU51bWJlcglmaXJzdCBsaW5lIG9mIGZvbGQgYXQge2xudW19IGlmIGNsb3NlZApmb2xkY2xvc2VkZW5kKHtsbnVtfSkJCU51bWJlcglsYXN0IGxpbmUgb2YgZm9sZCBhdCB7bG51bX0gaWYgY2xvc2VkCmZvbGRsZXZlbCh7bG51bX0pCQlOdW1iZXIJZm9sZCBsZXZlbCBhdCB7bG51bX0KZm9sZHRleHQoKQkJCVN0cmluZwlsaW5lIGRpc3BsYXllZCBmb3IgY2xvc2VkIGZvbGQKZm9sZHRleHRyZXN1bHQoe2xudW19KQkJU3RyaW5nCXRleHQgZm9yIGNsb3NlZCBmb2xkIGF0IHtsbnVtfQpmb3JlZ3JvdW5kKCkJCQlOdW1iZXIJYnJpbmcgdGhlIFZpbSB3aW5kb3cgdG8gdGhlIGZvcmVncm91bmQKZnVuY3Rpb24oe25hbWV9IFssIHthcmdsaXN0fV0gWywge2RpY3R9XSkKCQkJCUZ1bmNyZWYgcmVmZXJlbmNlIHRvIGZ1bmN0aW9uIHtuYW1lfQpnYXJiYWdlY29sbGVjdChbe2F0ZXhpdH1dKQlub25lCWZyZWUgbWVtb3J5LCBicmVha2luZyBjeWNsaWMgcmVmZXJlbmNlcwpnZXQoe2xpc3R9LCB7aWR4fSBbLCB7ZGVmfV0pCWFueQlnZXQgaXRlbSB7aWR4fSBmcm9tIHtsaXN0fSBvciB7ZGVmfQpnZXQoe2RpY3R9LCB7a2V5fSBbLCB7ZGVmfV0pCWFueQlnZXQgaXRlbSB7a2V5fSBmcm9tIHtkaWN0fSBvciB7ZGVmfQpnZXRidWZsaW5lKHtleHByfSwge2xudW19IFssIHtlbmR9XSkKCQkJCUxpc3QJbGluZXMge2xudW19IHRvIHtlbmR9IG9mIGJ1ZmZlciB7ZXhwcn0KZ2V0YnVmdmFyKHtleHByfSwge3Zhcm5hbWV9IFssIHtkZWZ9XSkKCQkJCWFueQl2YXJpYWJsZSB7dmFybmFtZX0gaW4gYnVmZmVyIHtleHByfQpnZXRjaGFyKFtleHByXSkJCQlOdW1iZXIJZ2V0IG9uZSBjaGFyYWN0ZXIgZnJvbSB0aGUgdXNlcgpnZXRjaGFybW9kKCkJCQlOdW1iZXIJbW9kaWZpZXJzIGZvciB0aGUgbGFzdCB0eXBlZCBjaGFyYWN0ZXIKZ2V0Y2hhcnNlYXJjaCgpCQkJRGljdAlsYXN0IGNoYXJhY3RlciBzZWFyY2gKZ2V0Y21kbGluZSgpCQkJU3RyaW5nCXJldHVybiB0aGUgY3VycmVudCBjb21tYW5kLWxpbmUKZ2V0Y21kcG9zKCkJCQlOdW1iZXIJcmV0dXJuIGN1cnNvciBwb3NpdGlvbiBpbiBjb21tYW5kLWxpbmUKZ2V0Y21kdHlwZSgpCQkJU3RyaW5nCXJldHVybiBjdXJyZW50IGNvbW1hbmQtbGluZSB0eXBlCmdldGNtZHdpbnR5cGUoKQkJCVN0cmluZwlyZXR1cm4gY3VycmVudCBjb21tYW5kLWxpbmUgd2luZG93IHR5cGUKZ2V0Y3VycG9zKCkJCQlMaXN0CXBvc2l0aW9uIG9mIHRoZSBjdXJzb3IKZ2V0Y3dkKFt7d2lubnJ9IFssIHt0YWJucn1dXSkJU3RyaW5nCWdldCB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeQpnZXRmb250bmFtZShbe25hbWV9XSkJCVN0cmluZwluYW1lIG9mIGZvbnQgYmVpbmcgdXNlZApnZXRmcGVybSh7Zm5hbWV9KQkJU3RyaW5nCWZpbGUgcGVybWlzc2lvbnMgb2YgZmlsZSB7Zm5hbWV9CmdldGZzaXplKHtmbmFtZX0pCQlOdW1iZXIJc2l6ZSBpbiBieXRlcyBvZiBmaWxlIHtmbmFtZX0KZ2V0ZnRpbWUoe2ZuYW1lfSkJCU51bWJlcglsYXN0IG1vZGlmaWNhdGlvbiB0aW1lIG9mIGZpbGUKZ2V0ZnR5cGUoe2ZuYW1lfSkJCVN0cmluZwlkZXNjcmlwdGlvbiBvZiB0eXBlIG9mIGZpbGUge2ZuYW1lfQpnZXRsaW5lKHtsbnVtfSkJCQlTdHJpbmcJbGluZSB7bG51bX0gb2YgY3VycmVudCBidWZmZXIKZ2V0bGluZSh7bG51bX0sIHtlbmR9KQkJTGlzdAlsaW5lcyB7bG51bX0gdG8ge2VuZH0gb2YgY3VycmVudCBidWZmZXIKZ2V0bG9jbGlzdCh7bnJ9KQkJTGlzdAlsaXN0IG9mIGxvY2F0aW9uIGxpc3QgaXRlbXMKZ2V0bWF0Y2hlcygpCQkJTGlzdAlsaXN0IG9mIGN1cnJlbnQgbWF0Y2hlcwpnZXRwaWQoKQkJCU51bWJlcglwcm9jZXNzIElEIG9mIFZpbQpnZXRwb3Moe2V4cHJ9KQkJCUxpc3QJcG9zaXRpb24gb2YgY3Vyc29yLCBtYXJrLCBldGMuCmdldHFmbGlzdCgpCQkJTGlzdAlsaXN0IG9mIHF1aWNrZml4IGl0ZW1zCmdldHJlZyhbe3JlZ25hbWV9IFssIDEgWywge2xpc3R9XV1dKQoJCQkJU3RyaW5nIG9yIExpc3QgICBjb250ZW50cyBvZiByZWdpc3RlcgpnZXRyZWd0eXBlKFt7cmVnbmFtZX1dKQkJU3RyaW5nCXR5cGUgb2YgcmVnaXN0ZXIKZ2V0dGFidmFyKHtucn0sIHt2YXJuYW1lfSBbLCB7ZGVmfV0pCgkJCQlhbnkJdmFyaWFibGUge3Zhcm5hbWV9IGluIHRhYiB7bnJ9IG9yIHtkZWZ9CmdldHRhYndpbnZhcih7dGFibnJ9LCB7d2lubnJ9LCB7bmFtZX0gWywge2RlZn1dKQoJCQkJYW55CXtuYW1lfSBpbiB7d2lubnJ9IGluIHRhYiBwYWdlIHt0YWJucn0KZ2V0d2lucG9zeCgpCQkJTnVtYmVyCVggY29vcmQgaW4gcGl4ZWxzIG9mIEdVSSBWaW0gd2luZG93CmdldHdpbnBvc3koKQkJCU51bWJlcglZIGNvb3JkIGluIHBpeGVscyBvZiBHVUkgVmltIHdpbmRvdwpnZXR3aW52YXIoe25yfSwge3Zhcm5hbWV9IFssIHtkZWZ9XSkKCQkJCWFueQl2YXJpYWJsZSB7dmFybmFtZX0gaW4gd2luZG93IHtucn0KZ2xvYih7ZXhwcn0gWywge25vc3VmfSBbLCB7bGlzdH0gWywge2FsbGxpbmtzfV1dXSkKCQkJCWFueQlleHBhbmQgZmlsZSB3aWxkY2FyZHMgaW4ge2V4cHJ9Cmdsb2IycmVncGF0KHtleHByfSkJCVN0cmluZyAgY29udmVydCBhIGdsb2IgcGF0IGludG8gYSBzZWFyY2ggcGF0Cmdsb2JwYXRoKHtwYXRofSwge2V4cHJ9IFssIHtub3N1Zn0gWywge2xpc3R9IFssIHthbGxsaW5rc31dXV0pCgkJCQlTdHJpbmcJZG8gZ2xvYih7ZXhwcn0pIGZvciBhbGwgZGlycyBpbiB7cGF0aH0KaGFzKHtmZWF0dXJlfSkJCQlOdW1iZXIJVFJVRSBpZiBmZWF0dXJlIHtmZWF0dXJlfSBzdXBwb3J0ZWQKaGFzX2tleSh7ZGljdH0sIHtrZXl9KQkJTnVtYmVyCVRSVUUgaWYge2RpY3R9IGhhcyBlbnRyeSB7a2V5fQpoYXNsb2NhbGRpcihbe3dpbm5yfSBbLCB7dGFibnJ9XV0pCgkJCQlOdW1iZXIJVFJVRSBpZiB0aGUgd2luZG93IGV4ZWN1dGVkIHw6bGNkfApoYXNtYXB0byh7d2hhdH0gWywge21vZGV9IFssIHthYmJyfV1dKQoJCQkJTnVtYmVyCVRSVUUgaWYgbWFwcGluZyB0byB7d2hhdH0gZXhpc3RzCmhpc3RhZGQoe2hpc3Rvcnl9LCB7aXRlbX0pCVN0cmluZwlhZGQgYW4gaXRlbSB0byBhIGhpc3RvcnkKaGlzdGRlbCh7aGlzdG9yeX0gWywge2l0ZW19XSkJU3RyaW5nCXJlbW92ZSBhbiBpdGVtIGZyb20gYSBoaXN0b3J5Cmhpc3RnZXQoe2hpc3Rvcnl9IFssIHtpbmRleH1dKQlTdHJpbmcJZ2V0IHRoZSBpdGVtIHtpbmRleH0gZnJvbSBhIGhpc3RvcnkKaGlzdG5yKHtoaXN0b3J5fSkJCU51bWJlcgloaWdoZXN0IGluZGV4IG9mIGEgaGlzdG9yeQpobGV4aXN0cyh7bmFtZX0pCQlOdW1iZXIJVFJVRSBpZiBoaWdobGlnaHQgZ3JvdXAge25hbWV9IGV4aXN0cwpobElEKHtuYW1lfSkJCQlOdW1iZXIJc3ludGF4IElEIG9mIGhpZ2hsaWdodCBncm91cCB7bmFtZX0KaG9zdG5hbWUoKQkJCVN0cmluZwluYW1lIG9mIHRoZSBtYWNoaW5lIFZpbSBpcyBydW5uaW5nIG9uCmljb252KHtleHByfSwge2Zyb219LCB7dG99KQlTdHJpbmcJY29udmVydCBlbmNvZGluZyBvZiB7ZXhwcn0KaW5kZW50KHtsbnVtfSkJCQlOdW1iZXIJaW5kZW50IG9mIGxpbmUge2xudW19CmluZGV4KHtsaXN0fSwge2V4cHJ9IFssIHtzdGFydH0gWywge2ljfV1dKQoJCQkJTnVtYmVyCWluZGV4IGluIHtsaXN0fSB3aGVyZSB7ZXhwcn0gYXBwZWFycwppbnB1dCh7cHJvbXB0fSBbLCB7dGV4dH0gWywge2NvbXBsZXRpb259XV0pCgkJCQlTdHJpbmcJZ2V0IGlucHV0IGZyb20gdGhlIHVzZXIKaW5wdXRkaWFsb2coe3Byb21wdH0gWywge3RleHR9IFssIHtjb21wbGV0aW9ufV1dXSkKCQkJCVN0cmluZyAgbGlrZSBpbnB1dCgpIGJ1dCBpbiBhIEdVSSBkaWFsb2cKaW5wdXRsaXN0KHt0ZXh0bGlzdH0pCQlOdW1iZXIJbGV0IHRoZSB1c2VyIHBpY2sgZnJvbSBhIGNob2ljZSBsaXN0CmlucHV0cmVzdG9yZSgpCQkJTnVtYmVyCXJlc3RvcmUgdHlwZWFoZWFkCmlucHV0c2F2ZSgpCQkJTnVtYmVyCXNhdmUgYW5kIGNsZWFyIHR5cGVhaGVhZAppbnB1dHNlY3JldCh7cHJvbXB0fSBbLCB7dGV4dH1dKSBTdHJpbmcgIGxpa2UgaW5wdXQoKSBidXQgaGlkaW5nIHRoZSB0ZXh0Cmluc2VydCh7bGlzdH0sIHtpdGVtfSBbLCB7aWR4fV0pIExpc3QJaW5zZXJ0IHtpdGVtfSBpbiB7bGlzdH0gW2JlZm9yZSB7aWR4fV0KaW52ZXJ0KHtleHByfSkJCQlOdW1iZXIgIGJpdHdpc2UgaW52ZXJ0CmlzZGlyZWN0b3J5KHtkaXJlY3Rvcnl9KQlOdW1iZXIJVFJVRSBpZiB7ZGlyZWN0b3J5fSBpcyBhIGRpcmVjdG9yeQppc2xvY2tlZCh7ZXhwcn0pCQlOdW1iZXIJVFJVRSBpZiB7ZXhwcn0gaXMgbG9ja2VkCmlzbmFuKHtleHByfSkJCQlOdW1iZXIgIFRSVUUgaWYge2V4cHJ9IGlzIE5hTgppdGVtcyh7ZGljdH0pCQkJTGlzdAlrZXktdmFsdWUgcGFpcnMgaW4ge2RpY3R9CmpvYl9nZXRjaGFubmVsKHtqb2J9KQkJQ2hhbm5lbAlnZXQgdGhlIGNoYW5uZWwgaGFuZGxlIGZvciB7am9ifQpqb2JfaW5mbyh7am9ifSkJCQlEaWN0CWdldCBpbmZvcm1hdGlvbiBhYm91dCB7am9ifQpqb2Jfc2V0b3B0aW9ucyh7am9ifSwge29wdGlvbnN9KSBub25lCXNldCBvcHRpb25zIGZvciB7am9ifQpqb2Jfc3RhcnQoe2NvbW1hbmR9IFssIHtvcHRpb25zfV0pCgkJCQlKb2IJIHN0YXJ0IGEgam9iCmpvYl9zdGF0dXMoe2pvYn0pCQlTdHJpbmcJZ2V0IHRoZSBzdGF0dXMgb2Yge2pvYn0Kam9iX3N0b3Aoe2pvYn0gWywge2hvd31dKQlOdW1iZXIJc3RvcCB7am9ifQpqb2luKHtsaXN0fSBbLCB7c2VwfV0pCQlTdHJpbmcJam9pbiB7bGlzdH0gaXRlbXMgaW50byBvbmUgU3RyaW5nCmpzX2RlY29kZSh7c3RyaW5nfSkJCWFueQlkZWNvZGUgSlMgc3R5bGUgSlNPTgpqc19lbmNvZGUoe2V4cHJ9KQkJU3RyaW5nCWVuY29kZSBKUyBzdHlsZSBKU09OCmpzb25fZGVjb2RlKHtzdHJpbmd9KQkJYW55CWRlY29kZSBKU09OCmpzb25fZW5jb2RlKHtleHByfSkJCVN0cmluZwllbmNvZGUgSlNPTgprZXlzKHtkaWN0fSkJCQlMaXN0CWtleXMgaW4ge2RpY3R9Cmxlbih7ZXhwcn0pCQkJTnVtYmVyCXRoZSBsZW5ndGggb2Yge2V4cHJ9CmxpYmNhbGwoe2xpYn0sIHtmdW5jfSwge2FyZ30pCVN0cmluZwljYWxsIHtmdW5jfSBpbiBsaWJyYXJ5IHtsaWJ9IHdpdGgge2FyZ30KbGliY2FsbG5yKHtsaWJ9LCB7ZnVuY30sIHthcmd9KSAgTnVtYmVyICBpZGVtLCBidXQgcmV0dXJuIGEgTnVtYmVyCmxpbmUoe2V4cHJ9KQkJCU51bWJlcglsaW5lIG5yIG9mIGN1cnNvciwgbGFzdCBsaW5lIG9yIG1hcmsKbGluZTJieXRlKHtsbnVtfSkJCU51bWJlcglieXRlIGNvdW50IG9mIGxpbmUge2xudW19Cmxpc3BpbmRlbnQoe2xudW19KQkJTnVtYmVyCUxpc3AgaW5kZW50IGZvciBsaW5lIHtsbnVtfQpsb2NhbHRpbWUoKQkJCU51bWJlcgljdXJyZW50IHRpbWUKbG9nKHtleHByfSkJCQlGbG9hdAluYXR1cmFsIGxvZ2FyaXRobSAoYmFzZSBlKSBvZiB7ZXhwcn0KbG9nMTAoe2V4cHJ9KQkJCUZsb2F0CWxvZ2FyaXRobSBvZiBGbG9hdCB7ZXhwcn0gdG8gYmFzZSAxMApsdWFldmFsKHtleHByfVssIHtleHByfV0pCWFueQlldmFsdWF0ZSB8THVhfCBleHByZXNzaW9uCm1hcCh7ZXhwcn0sIHtzdHJpbmd9KQkJTGlzdC9EaWN0ICBjaGFuZ2UgZWFjaCBpdGVtIGluIHtleHByfSB0byB7ZXhwcn0KbWFwYXJnKHtuYW1lfVssIHttb2RlfSBbLCB7YWJicn0gWywge2RpY3R9XV1dKQoJCQkJU3RyaW5nIG9yIERpY3QKCQkJCQlyaHMgb2YgbWFwcGluZyB7bmFtZX0gaW4gbW9kZSB7bW9kZX0KbWFwY2hlY2soe25hbWV9Wywge21vZGV9IFssIHthYmJyfV1dKQoJCQkJU3RyaW5nCWNoZWNrIGZvciBtYXBwaW5ncyBtYXRjaGluZyB7bmFtZX0KbWF0Y2goe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCgkJCQlOdW1iZXIJcG9zaXRpb24gd2hlcmUge3BhdH0gbWF0Y2hlcyBpbiB7ZXhwcn0KbWF0Y2hhZGQoe2dyb3VwfSwge3BhdHRlcm59Wywge3ByaW9yaXR5fVssIHtpZH0gWywge2RpY3R9XV1dKQoJCQkJTnVtYmVyCWhpZ2hsaWdodCB7cGF0dGVybn0gd2l0aCB7Z3JvdXB9Cm1hdGNoYWRkcG9zKHtncm91cH0sIHtwb3N9Wywge3ByaW9yaXR5fVssIHtpZH1bLCB7ZGljdH1dXV0pCgkJCQlOdW1iZXIJaGlnaGxpZ2h0IHBvc2l0aW9ucyB3aXRoIHtncm91cH0KbWF0Y2hhcmcoe25yfSkJCQlMaXN0CWFyZ3VtZW50cyBvZiB8Om1hdGNofAptYXRjaGRlbGV0ZSh7aWR9KQkJTnVtYmVyCWRlbGV0ZSBtYXRjaCBpZGVudGlmaWVkIGJ5IHtpZH0KbWF0Y2hlbmQoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCgkJCQlOdW1iZXIJcG9zaXRpb24gd2hlcmUge3BhdH0gZW5kcyBpbiB7ZXhwcn0KbWF0Y2hsaXN0KHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQoJCQkJTGlzdAltYXRjaCBhbmQgc3VibWF0Y2hlcyBvZiB7cGF0fSBpbiB7ZXhwcn0KbWF0Y2hzdHIoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCgkJCQlTdHJpbmcJe2NvdW50fSd0aCBtYXRjaCBvZiB7cGF0fSBpbiB7ZXhwcn0KbWF0Y2hzdHJwb3Moe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCgkJCQlMaXN0CXtjb3VudH0ndGggbWF0Y2ggb2Yge3BhdH0gaW4ge2V4cHJ9Cm1heCh7bGlzdH0pCQkJTnVtYmVyCW1heGltdW0gdmFsdWUgb2YgaXRlbXMgaW4ge2xpc3R9Cm1pbih7bGlzdH0pCQkJTnVtYmVyCW1pbmltdW0gdmFsdWUgb2YgaXRlbXMgaW4ge2xpc3R9Cm1rZGlyKHtuYW1lfSBbLCB7cGF0aH0gWywge3Byb3R9XV0pCgkJCQlOdW1iZXIJY3JlYXRlIGRpcmVjdG9yeSB7bmFtZX0KbW9kZShbZXhwcl0pCQkJU3RyaW5nCWN1cnJlbnQgZWRpdGluZyBtb2RlCm16ZXZhbCh7ZXhwcn0pCQkJYW55CWV2YWx1YXRlIHxNelNjaGVtZXwgZXhwcmVzc2lvbgpuZXh0bm9uYmxhbmsoe2xudW19KQkJTnVtYmVyCWxpbmUgbnIgb2Ygbm9uLWJsYW5rIGxpbmUgPj0ge2xudW19Cm5yMmNoYXIoe2V4cHJ9Wywge3V0Zjh9XSkJU3RyaW5nCXNpbmdsZSBjaGFyIHdpdGggQVNDSUkvVVRGOCB2YWx1ZSB7ZXhwcn0Kb3Ioe2V4cHJ9LCB7ZXhwcn0pCQlOdW1iZXIgIGJpdHdpc2UgT1IKcGF0aHNob3J0ZW4oe2V4cHJ9KQkJU3RyaW5nCXNob3J0ZW4gZGlyZWN0b3J5IG5hbWVzIGluIGEgcGF0aApwZXJsZXZhbCh7ZXhwcn0pCQlhbnkJZXZhbHVhdGUgfFBlcmx8IGV4cHJlc3Npb24KcG93KHt4fSwge3l9KQkJCUZsb2F0CXt4fSB0byB0aGUgcG93ZXIgb2Yge3l9CnByZXZub25ibGFuayh7bG51bX0pCQlOdW1iZXIJbGluZSBuciBvZiBub24tYmxhbmsgbGluZSA8PSB7bG51bX0KcHJpbnRmKHtmbXR9LCB7ZXhwcjF9Li4uKQlTdHJpbmcJZm9ybWF0IHRleHQKcHVtdmlzaWJsZSgpCQkJTnVtYmVyCXdoZXRoZXIgcG9wdXAgbWVudSBpcyB2aXNpYmxlCnB5ZXZhbCh7ZXhwcn0pCQkJYW55CWV2YWx1YXRlIHxQeXRob258IGV4cHJlc3Npb24KcHkzZXZhbCh7ZXhwcn0pCQkJYW55CWV2YWx1YXRlIHxweXRob24zfCBleHByZXNzaW9uCnJhbmdlKHtleHByfSBbLCB7bWF4fSBbLCB7c3RyaWRlfV1dKQoJCQkJTGlzdAlpdGVtcyBmcm9tIHtleHByfSB0byB7bWF4fQpyZWFkZmlsZSh7Zm5hbWV9IFssIHtiaW5hcnl9IFssIHttYXh9XV0pCgkJCQlMaXN0CWdldCBsaXN0IG9mIGxpbmVzIGZyb20gZmlsZSB7Zm5hbWV9CnJlbHRpbWUoW3tzdGFydH0gWywge2VuZH1dXSkJTGlzdAlnZXQgdGltZSB2YWx1ZQpyZWx0aW1lZmxvYXQoe3RpbWV9KQkJRmxvYXQJdHVybiB0aGUgdGltZSB2YWx1ZSBpbnRvIGEgRmxvYXQKcmVsdGltZXN0cih7dGltZX0pCQlTdHJpbmcJdHVybiB0aW1lIHZhbHVlIGludG8gYSBTdHJpbmcKcmVtb3RlX2V4cHIoe3NlcnZlcn0sIHtzdHJpbmd9IFssIHtpZHZhcn1dKQoJCQkJU3RyaW5nCXNlbmQgZXhwcmVzc2lvbgpyZW1vdGVfZm9yZWdyb3VuZCh7c2VydmVyfSkJTnVtYmVyCWJyaW5nIFZpbSBzZXJ2ZXIgdG8gdGhlIGZvcmVncm91bmQKcmVtb3RlX3BlZWsoe3NlcnZlcmlkfSBbLCB7cmV0dmFyfV0pCgkJCQlOdW1iZXIJY2hlY2sgZm9yIHJlcGx5IHN0cmluZwpyZW1vdGVfcmVhZCh7c2VydmVyaWR9KQkJU3RyaW5nCXJlYWQgcmVwbHkgc3RyaW5nCnJlbW90ZV9zZW5kKHtzZXJ2ZXJ9LCB7c3RyaW5nfSBbLCB7aWR2YXJ9XSkKCQkJCVN0cmluZwlzZW5kIGtleSBzZXF1ZW5jZQpyZW1vdmUoe2xpc3R9LCB7aWR4fSBbLCB7ZW5kfV0pICBhbnkJcmVtb3ZlIGl0ZW1zIHtpZHh9LXtlbmR9IGZyb20ge2xpc3R9CnJlbW92ZSh7ZGljdH0sIHtrZXl9KQkJYW55CXJlbW92ZSBlbnRyeSB7a2V5fSBmcm9tIHtkaWN0fQpyZW5hbWUoe2Zyb219LCB7dG99KQkJTnVtYmVyCXJlbmFtZSAobW92ZSkgZmlsZSBmcm9tIHtmcm9tfSB0byB7dG99CnJlcGVhdCh7ZXhwcn0sIHtjb3VudH0pCQlTdHJpbmcJcmVwZWF0IHtleHByfSB7Y291bnR9IHRpbWVzCnJlc29sdmUoe2ZpbGVuYW1lfSkJCVN0cmluZwlnZXQgZmlsZW5hbWUgYSBzaG9ydGN1dCBwb2ludHMgdG8KcmV2ZXJzZSh7bGlzdH0pCQkJTGlzdAlyZXZlcnNlIHtsaXN0fSBpbi1wbGFjZQpyb3VuZCh7ZXhwcn0pCQkJRmxvYXQJcm91bmQgb2ZmIHtleHByfQpzY3JlZW5hdHRyKHtyb3d9LCB7Y29sfSkJTnVtYmVyCWF0dHJpYnV0ZSBhdCBzY3JlZW4gcG9zaXRpb24Kc2NyZWVuY2hhcih7cm93fSwge2NvbH0pCU51bWJlcgljaGFyYWN0ZXIgYXQgc2NyZWVuIHBvc2l0aW9uCnNjcmVlbmNvbCgpCQkJTnVtYmVyCWN1cnJlbnQgY3Vyc29yIGNvbHVtbgpzY3JlZW5yb3coKQkJCU51bWJlcgljdXJyZW50IGN1cnNvciByb3cKc2VhcmNoKHtwYXR0ZXJufSBbLCB7ZmxhZ3N9IFssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dKQoJCQkJTnVtYmVyCXNlYXJjaCBmb3Ige3BhdHRlcm59CnNlYXJjaGRlY2woe25hbWV9IFssIHtnbG9iYWx9IFssIHt0aGlzYmxvY2t9XV0pCgkJCQlOdW1iZXIJc2VhcmNoIGZvciB2YXJpYWJsZSBkZWNsYXJhdGlvbgpzZWFyY2hwYWlyKHtzdGFydH0sIHttaWRkbGV9LCB7ZW5kfSBbLCB7ZmxhZ3N9IFssIHtza2lwfSBbLi4uXV1dKQoJCQkJTnVtYmVyCXNlYXJjaCBmb3Igb3RoZXIgZW5kIG9mIHN0YXJ0L2VuZCBwYWlyCnNlYXJjaHBhaXJwb3Moe3N0YXJ0fSwge21pZGRsZX0sIHtlbmR9IFssIHtmbGFnc30gWywge3NraXB9IFsuLi5dXV0pCgkJCQlMaXN0CXNlYXJjaCBmb3Igb3RoZXIgZW5kIG9mIHN0YXJ0L2VuZCBwYWlyCnNlYXJjaHBvcyh7cGF0dGVybn0gWywge2ZsYWdzfSBbLCB7c3RvcGxpbmV9IFssIHt0aW1lb3V0fV1dXSkKCQkJCUxpc3QJc2VhcmNoIGZvciB7cGF0dGVybn0Kc2VydmVyMmNsaWVudCh7Y2xpZW50aWR9LCB7c3RyaW5nfSkKCQkJCU51bWJlcglzZW5kIHJlcGx5IHN0cmluZwpzZXJ2ZXJsaXN0KCkJCQlTdHJpbmcJZ2V0IGEgbGlzdCBvZiBhdmFpbGFibGUgc2VydmVycwpzZXRidWZ2YXIoe2V4cHJ9LCB7dmFybmFtZX0sIHt2YWx9KQoJCQkJbm9uZQlzZXQge3Zhcm5hbWV9IGluIGJ1ZmZlciB7ZXhwcn0gdG8ge3ZhbH0Kc2V0Y2hhcnNlYXJjaCh7ZGljdH0pCQlEaWN0CXNldCBjaGFyYWN0ZXIgc2VhcmNoIGZyb20ge2RpY3R9CnNldGNtZHBvcyh7cG9zfSkJCU51bWJlcglzZXQgY3Vyc29yIHBvc2l0aW9uIGluIGNvbW1hbmQtbGluZQpzZXRmcGVybSh7Zm5hbWV9LCB7bW9kZX0pCU51bWJlcglzZXQge2ZuYW1lfSBmaWxlIHBlcm1pc3Npb25zIHRvIHttb2RlfQpzZXRsaW5lKHtsbnVtfSwge2xpbmV9KQkJTnVtYmVyCXNldCBsaW5lIHtsbnVtfSB0byB7bGluZX0Kc2V0bG9jbGlzdCh7bnJ9LCB7bGlzdH1bLCB7YWN0aW9ufV0pCgkJCQlOdW1iZXIJbW9kaWZ5IGxvY2F0aW9uIGxpc3QgdXNpbmcge2xpc3R9CnNldG1hdGNoZXMoe2xpc3R9KQkJTnVtYmVyCXJlc3RvcmUgYSBsaXN0IG9mIG1hdGNoZXMKc2V0cG9zKHtleHByfSwge2xpc3R9KQkJTnVtYmVyCXNldCB0aGUge2V4cHJ9IHBvc2l0aW9uIHRvIHtsaXN0fQpzZXRxZmxpc3Qoe2xpc3R9Wywge2FjdGlvbn1dKQlOdW1iZXIJbW9kaWZ5IHF1aWNrZml4IGxpc3QgdXNpbmcge2xpc3R9CnNldHJlZyh7bn0sIHt2fVssIHtvcHR9XSkJTnVtYmVyCXNldCByZWdpc3RlciB0byB2YWx1ZSBhbmQgdHlwZQpzZXR0YWJ2YXIoe25yfSwge3Zhcm5hbWV9LCB7dmFsfSkgbm9uZQlzZXQge3Zhcm5hbWV9IGluIHRhYiBwYWdlIHtucn0gdG8ge3ZhbH0Kc2V0dGFid2ludmFyKHt0YWJucn0sIHt3aW5ucn0sIHt2YXJuYW1lfSwge3ZhbH0pCgkJCQlub25lCXNldCB7dmFybmFtZX0gaW4gd2luZG93IHt3aW5ucn0gaW4gdGFiCgkJCQkJcGFnZSB7dGFibnJ9IHRvIHt2YWx9CnNldHdpbnZhcih7bnJ9LCB7dmFybmFtZX0sIHt2YWx9KSBub25lCXNldCB7dmFybmFtZX0gaW4gd2luZG93IHtucn0gdG8ge3ZhbH0Kc2hhMjU2KHtzdHJpbmd9KQkJU3RyaW5nCVNIQTI1NiBjaGVja3N1bSBvZiB7c3RyaW5nfQpzaGVsbGVzY2FwZSh7c3RyaW5nfSBbLCB7c3BlY2lhbH1dKQoJCQkJU3RyaW5nCWVzY2FwZSB7c3RyaW5nfSBmb3IgdXNlIGFzIHNoZWxsCgkJCQkJY29tbWFuZCBhcmd1bWVudApzaGlmdHdpZHRoKCkJCQlOdW1iZXIJZWZmZWN0aXZlIHZhbHVlIG9mICdzaGlmdHdpZHRoJwpzaW1wbGlmeSh7ZmlsZW5hbWV9KQkJU3RyaW5nCXNpbXBsaWZ5IGZpbGVuYW1lIGFzIG11Y2ggYXMgcG9zc2libGUKc2luKHtleHByfSkJCQlGbG9hdAlzaW5lIG9mIHtleHByfQpzaW5oKHtleHByfSkJCQlGbG9hdAloeXBlcmJvbGljIHNpbmUgb2Yge2V4cHJ9CnNvcnQoe2xpc3R9IFssIHtmdW5jfSBbLCB7ZGljdH1dXSkKCQkJCUxpc3QJc29ydCB7bGlzdH0sIHVzaW5nIHtmdW5jfSB0byBjb21wYXJlCnNvdW5kZm9sZCh7d29yZH0pCQlTdHJpbmcJc291bmQtZm9sZCB7d29yZH0Kc3BlbGxiYWR3b3JkKCkJCQlTdHJpbmcJYmFkbHkgc3BlbGxlZCB3b3JkIGF0IGN1cnNvcgpzcGVsbHN1Z2dlc3Qoe3dvcmR9IFssIHttYXh9IFssIHtjYXBpdGFsfV1dKQoJCQkJTGlzdAlzcGVsbGluZyBzdWdnZXN0aW9ucwpzcGxpdCh7ZXhwcn0gWywge3BhdH0gWywge2tlZXBlbXB0eX1dXSkKCQkJCUxpc3QJbWFrZSB8TGlzdHwgZnJvbSB7cGF0fSBzZXBhcmF0ZWQge2V4cHJ9CnNxcnQoe2V4cHJ9KQkJCUZsb2F0CXNxdWFyZSByb290IG9mIHtleHByfQpzdHIyZmxvYXQoe2V4cHJ9KQkJRmxvYXQJY29udmVydCBTdHJpbmcgdG8gRmxvYXQKc3RyMm5yKHtleHByfSBbLCB7YmFzZX1dKQlOdW1iZXIJY29udmVydCBTdHJpbmcgdG8gTnVtYmVyCnN0cmNoYXJzKHtleHByfSBbLCB7c2tpcGNjfV0pCU51bWJlcgljaGFyYWN0ZXIgbGVuZ3RoIG9mIHRoZSBTdHJpbmcge2V4cHJ9CnN0cmNoYXJwYXJ0KHtzdHJ9LCB7c3RhcnR9Wywge2xlbn1dKQoJCQkJU3RyaW5nCXtsZW59IGNoYXJhY3RlcnMgb2Yge3N0cn0gYXQge3N0YXJ0fQpzdHJkaXNwbGF5d2lkdGgoe2V4cHJ9IFssIHtjb2x9XSkgTnVtYmVyIGRpc3BsYXkgbGVuZ3RoIG9mIHRoZSBTdHJpbmcge2V4cHJ9CnN0cmZ0aW1lKHtmb3JtYXR9Wywge3RpbWV9XSkJU3RyaW5nCXRpbWUgaW4gc3BlY2lmaWVkIGZvcm1hdApzdHJnZXRjaGFyKHtzdHJ9LCB7aW5kZXh9KQlOdW1iZXIJZ2V0IGNoYXIge2luZGV4fSBmcm9tIHtzdHJ9CnN0cmlkeCh7aGF5c3RhY2t9LCB7bmVlZGxlfVssIHtzdGFydH1dKQoJCQkJTnVtYmVyCWluZGV4IG9mIHtuZWVkbGV9IGluIHtoYXlzdGFja30Kc3RyaW5nKHtleHByfSkJCQlTdHJpbmcJU3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHtleHByfSB2YWx1ZQpzdHJsZW4oe2V4cHJ9KQkJCU51bWJlcglsZW5ndGggb2YgdGhlIFN0cmluZyB7ZXhwcn0Kc3RycGFydCh7c3RyfSwge3N0YXJ0fVssIHtsZW59XSkKCQkJCVN0cmluZwl7bGVufSBjaGFyYWN0ZXJzIG9mIHtzdHJ9IGF0IHtzdGFydH0Kc3RycmlkeCh7aGF5c3RhY2t9LCB7bmVlZGxlfSBbLCB7c3RhcnR9XSkKCQkJCU51bWJlcglsYXN0IGluZGV4IG9mIHtuZWVkbGV9IGluIHtoYXlzdGFja30Kc3RydHJhbnMoe2V4cHJ9KQkJU3RyaW5nCXRyYW5zbGF0ZSBzdHJpbmcgdG8gbWFrZSBpdCBwcmludGFibGUKc3Ryd2lkdGgoe2V4cHJ9KQkJTnVtYmVyCWRpc3BsYXkgY2VsbCBsZW5ndGggb2YgdGhlIFN0cmluZyB7ZXhwcn0Kc3VibWF0Y2goe25yfVssIHtsaXN0fV0pCVN0cmluZyBvciBMaXN0CgkJCQkJc3BlY2lmaWMgbWF0Y2ggaW4gIjpzIiBvciBzdWJzdGl0dXRlKCkKc3Vic3RpdHV0ZSh7ZXhwcn0sIHtwYXR9LCB7c3VifSwge2ZsYWdzfSkKCQkJCVN0cmluZwlhbGwge3BhdH0gaW4ge2V4cHJ9IHJlcGxhY2VkIHdpdGgge3N1Yn0Kc3luSUQoe2xudW19LCB7Y29sfSwge3RyYW5zfSkJTnVtYmVyCXN5bnRheCBJRCBhdCB7bG51bX0gYW5kIHtjb2x9CnN5bklEYXR0cih7c3luSUR9LCB7d2hhdH0gWywge21vZGV9XSkKCQkJCVN0cmluZwlhdHRyaWJ1dGUge3doYXR9IG9mIHN5bnRheCBJRCB7c3luSUR9CnN5bklEdHJhbnMoe3N5bklEfSkJCU51bWJlcgl0cmFuc2xhdGVkIHN5bnRheCBJRCBvZiB7c3luSUR9CnN5bmNvbmNlYWxlZCh7bG51bX0sIHtjb2x9KQlMaXN0ICAgIGluZm8gYWJvdXQgY29uY2VhbGluZwpzeW5zdGFjayh7bG51bX0sIHtjb2x9KQkJTGlzdAlzdGFjayBvZiBzeW50YXggSURzIGF0IHtsbnVtfSBhbmQge2NvbH0Kc3lzdGVtKHtleHByfSBbLCB7aW5wdXR9XSkJU3RyaW5nCW91dHB1dCBvZiBzaGVsbCBjb21tYW5kL2ZpbHRlciB7ZXhwcn0Kc3lzdGVtbGlzdCh7ZXhwcn0gWywge2lucHV0fV0pCUxpc3QJb3V0cHV0IG9mIHNoZWxsIGNvbW1hbmQvZmlsdGVyIHtleHByfQp0YWJwYWdlYnVmbGlzdChbe2FyZ31dKQlMaXN0CWxpc3Qgb2YgYnVmZmVyIG51bWJlcnMgaW4gdGFiIHBhZ2UKdGFicGFnZW5yKFt7YXJnfV0pCQlOdW1iZXIJbnVtYmVyIG9mIGN1cnJlbnQgb3IgbGFzdCB0YWIgcGFnZQp0YWJwYWdld2lubnIoe3RhYmFyZ31bLCB7YXJnfV0pIE51bWJlcgludW1iZXIgb2YgY3VycmVudCB3aW5kb3cgaW4gdGFiIHBhZ2UKdGFnbGlzdCh7ZXhwcn0pCQkJTGlzdAlsaXN0IG9mIHRhZ3MgbWF0Y2hpbmcge2V4cHJ9CnRhZ2ZpbGVzKCkJCQlMaXN0CXRhZ3MgZmlsZXMgdXNlZAp0YW4oe2V4cHJ9KQkJCUZsb2F0CXRhbmdlbnQgb2Yge2V4cHJ9CnRhbmgoe2V4cHJ9KQkJCUZsb2F0CWh5cGVyYm9saWMgdGFuZ2VudCBvZiB7ZXhwcn0KdGVtcG5hbWUoKQkJCVN0cmluZwluYW1lIGZvciBhIHRlbXBvcmFyeSBmaWxlCnRlc3RfZ2FyYmFnZWNvbGxlY3Rfbm93KCkJbm9uZQlmcmVlIG1lbW9yeSByaWdodCBub3cgZm9yIHRlc3RpbmcKdGVzdF9udWxsX2NoYW5uZWwoKQkJQ2hhbm5lbAludWxsIHZhbHVlIGZvciB0ZXN0aW5nCnRlc3RfbnVsbF9kaWN0KCkJCURpY3QJbnVsbCB2YWx1ZSBmb3IgdGVzdGluZwp0ZXN0X251bGxfam9iKCkJCQlKb2IJbnVsbCB2YWx1ZSBmb3IgdGVzdGluZwp0ZXN0X251bGxfbGlzdCgpCQlMaXN0CW51bGwgdmFsdWUgZm9yIHRlc3RpbmcKdGVzdF9udWxsX3BhcnRpYWwoKQkJRnVuY3JlZgludWxsIHZhbHVlIGZvciB0ZXN0aW5nCnRlc3RfbnVsbF9zdHJpbmcoKQkJU3RyaW5nCW51bGwgdmFsdWUgZm9yIHRlc3RpbmcKdGltZXJfc3RhcnQoe3RpbWV9LCB7Y2FsbGJhY2t9IFssIHtvcHRpb25zfV0pCgkJCQlOdW1iZXIJY3JlYXRlIGEgdGltZXIKdGltZXJfc3RvcCh7dGltZXJ9KQkJbm9uZQlzdG9wIGEgdGltZXIKdG9sb3dlcih7ZXhwcn0pCQkJU3RyaW5nCXRoZSBTdHJpbmcge2V4cHJ9IHN3aXRjaGVkIHRvIGxvd2VyY2FzZQp0b3VwcGVyKHtleHByfSkJCQlTdHJpbmcJdGhlIFN0cmluZyB7ZXhwcn0gc3dpdGNoZWQgdG8gdXBwZXJjYXNlCnRyKHtzcmN9LCB7ZnJvbXN0cn0sIHt0b3N0cn0pCVN0cmluZwl0cmFuc2xhdGUgY2hhcnMgb2Yge3NyY30gaW4ge2Zyb21zdHJ9CgkJCQkJdG8gY2hhcnMgaW4ge3Rvc3RyfQp0cnVuYyh7ZXhwcn0pCQkJRmxvYXQJdHJ1bmNhdGUgRmxvYXQge2V4cHJ9CnR5cGUoe25hbWV9KQkJCU51bWJlcgl0eXBlIG9mIHZhcmlhYmxlIHtuYW1lfQp1bmRvZmlsZSh7bmFtZX0pCQlTdHJpbmcJdW5kbyBmaWxlIG5hbWUgZm9yIHtuYW1lfQp1bmRvdHJlZSgpCQkJTGlzdAl1bmRvIGZpbGUgdHJlZQp1bmlxKHtsaXN0fSBbLCB7ZnVuY30gWywge2RpY3R9XV0pCgkJCQlMaXN0CXJlbW92ZSBhZGphY2VudCBkdXBsaWNhdGVzIGZyb20gYSBsaXN0CnZhbHVlcyh7ZGljdH0pCQkJTGlzdAl2YWx1ZXMgaW4ge2RpY3R9CnZpcnRjb2woe2V4cHJ9KQkJCU51bWJlcglzY3JlZW4gY29sdW1uIG9mIGN1cnNvciBvciBtYXJrCnZpc3VhbG1vZGUoW2V4cHJdKQkJU3RyaW5nCWxhc3QgdmlzdWFsIG1vZGUgdXNlZAp3aWxkbWVudW1vZGUoKQkJCU51bWJlcgl3aGV0aGVyICd3aWxkbWVudScgbW9kZSBpcyBhY3RpdmUKd2luX2ZpbmRidWYoe2J1Zm5yfSkJCUxpc3QJZmluZCB3aW5kb3dzIGNvbnRhaW5pbmcge2J1Zm5yfQp3aW5fZ2V0aWQoW3t3aW59IFssIHt0YWJ9XV0pCU51bWJlcglnZXQgd2luZG93IElEIGZvciB7d2lufSBpbiB7dGFifQp3aW5fZ290b2lkKHtleHByfSkJCU51bWJlcglnbyB0byB3aW5kb3cgd2l0aCBJRCB7ZXhwcn0Kd2luX2lkMnRhYndpbih7ZXhwcn0pCQlMaXN0CWdldCB0YWIgYW5kIHdpbmRvdyBuciBmcm9tIHdpbmRvdyBJRAp3aW5faWQyd2luKHtleHByfSkJCU51bWJlcglnZXQgd2luZG93IG5yIGZyb20gd2luZG93IElECndpbmJ1Zm5yKHtucn0pCQkJTnVtYmVyCWJ1ZmZlciBudW1iZXIgb2Ygd2luZG93IHtucn0Kd2luY29sKCkJCQlOdW1iZXIJd2luZG93IGNvbHVtbiBvZiB0aGUgY3Vyc29yCndpbmhlaWdodCh7bnJ9KQkJCU51bWJlcgloZWlnaHQgb2Ygd2luZG93IHtucn0Kd2lubGluZSgpCQkJTnVtYmVyCXdpbmRvdyBsaW5lIG9mIHRoZSBjdXJzb3IKd2lubnIoW3tleHByfV0pCQkJTnVtYmVyCW51bWJlciBvZiBjdXJyZW50IHdpbmRvdwp3aW5yZXN0Y21kKCkJCQlTdHJpbmcJcmV0dXJucyBjb21tYW5kIHRvIHJlc3RvcmUgd2luZG93IHNpemVzCndpbnJlc3R2aWV3KHtkaWN0fSkJCW5vbmUJcmVzdG9yZSB2aWV3IG9mIGN1cnJlbnQgd2luZG93CndpbnNhdmV2aWV3KCkJCQlEaWN0CXNhdmUgdmlldyBvZiBjdXJyZW50IHdpbmRvdwp3aW53aWR0aCh7bnJ9KQkJCU51bWJlcgl3aWR0aCBvZiB3aW5kb3cge25yfQp3b3JkY291bnQoKQkJCURpY3QJZ2V0IGJ5dGUvY2hhci93b3JkIHN0YXRpc3RpY3MKd3JpdGVmaWxlKHtsaXN0fSwge2ZuYW1lfSBbLCB7ZmxhZ3N9XSkKCQkJCU51bWJlcgl3cml0ZSBsaXN0IG9mIGxpbmVzIHRvIGZpbGUge2ZuYW1lfQp4b3Ioe2V4cHJ9LCB7ZXhwcn0pCQlOdW1iZXIgIGJpdHdpc2UgWE9SCgoKYWJzKHtleHByfSkJCQkJCQkJKmFicygpKgoJCVJldHVybiB0aGUgYWJzb2x1dGUgdmFsdWUgb2Yge2V4cHJ9LiAgV2hlbiB7ZXhwcn0gZXZhbHVhdGVzIHRvCgkJYSB8RmxvYXR8IGFicygpIHJldHVybnMgYSB8RmxvYXR8LiAgV2hlbiB7ZXhwcn0gY2FuIGJlCgkJY29udmVydGVkIHRvIGEgfE51bWJlcnwgYWJzKCkgcmV0dXJucyBhIHxOdW1iZXJ8LiAgT3RoZXJ3aXNlCgkJYWJzKCkgZ2l2ZXMgYW4gZXJyb3IgbWVzc2FnZSBhbmQgcmV0dXJucyAtMS4KCQlFeGFtcGxlczogPgoJCQllY2hvIGFicygxLjQ1NikKPAkJCTEuNDU2ICA+CgkJCWVjaG8gYWJzKC01LjQ1NikKPAkJCTUuNDU2ICA+CgkJCWVjaG8gYWJzKC00KQo8CQkJNAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKYWNvcyh7ZXhwcn0pCQkJCQkJCSphY29zKCkqCgkJUmV0dXJuIHRoZSBhcmMgY29zaW5lIG9mIHtleHByfSBtZWFzdXJlZCBpbiByYWRpYW5zLCBhcyBhCgkJfEZsb2F0fCBpbiB0aGUgcmFuZ2Ugb2YgWzAsIHBpXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfCBpbiB0aGUgcmFuZ2UKCQlbLTEsIDFdLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGFjb3MoMCkKPAkJCTEuNTcwNzk2ID4KCQkJOmVjaG8gYWNvcygtMC41KQo8CQkJMi4wOTQzOTUKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmFkZCh7bGlzdH0sIHtleHByfSkJCQkJCSphZGQoKSoKCQlBcHBlbmQgdGhlIGl0ZW0ge2V4cHJ9IHRvIHxMaXN0fCB7bGlzdH0uICBSZXR1cm5zIHRoZQoJCXJlc3VsdGluZyB8TGlzdHwuICBFeGFtcGxlczogPgoJCQk6bGV0IGFsaXN0ID0gYWRkKFsxLCAyLCAzXSwgaXRlbSkKCQkJOmNhbGwgYWRkKG15bGlzdCwgIndvb2RzdG9jayIpCjwJCU5vdGUgdGhhdCB3aGVuIHtleHByfSBpcyBhIHxMaXN0fCBpdCBpcyBhcHBlbmRlZCBhcyBhIHNpbmdsZQoJCWl0ZW0uICBVc2UgfGV4dGVuZCgpfCB0byBjb25jYXRlbmF0ZSB8TGlzdHN8LgoJCVVzZSB8aW5zZXJ0KCl8IHRvIGFkZCBhbiBpdGVtIGF0IGFub3RoZXIgcG9zaXRpb24uCgoKYWxsb2NfZmFpbCh7aWR9LCB7Y291bnRkb3dufSwge3JlcGVhdH0pCQkJKmFsbG9jX2ZhaWwoKSoKCQlUaGlzIGlzIGZvciB0ZXN0aW5nOiBJZiB0aGUgbWVtb3J5IGFsbG9jYXRpb24gd2l0aCB7aWR9IGlzCgkJY2FsbGVkLCB0aGVuIGRlY3JlbWVudCB7Y291bnRkb3dufSwgYW5kIHdoZW4gaXQgcmVhY2hlcyB6ZXJvCgkJbGV0IG1lbW9yeSBhbGxvY2F0aW9uIGZhaWwge3JlcGVhdH0gdGltZXMuICBXaGVuIHtyZXBlYXR9IGlzCgkJc21hbGxlciB0aGFuIG9uZSBpdCBmYWlscyBvbmUgdGltZS4KCgphbmQoe2V4cHJ9LCB7ZXhwcn0pCQkJCQkqYW5kKCkqCgkJQml0d2lzZSBBTkQgb24gdGhlIHR3byBhcmd1bWVudHMuICBUaGUgYXJndW1lbnRzIGFyZSBjb252ZXJ0ZWQKCQl0byBhIG51bWJlci4gIEEgTGlzdCwgRGljdCBvciBGbG9hdCBhcmd1bWVudCBjYXVzZXMgYW4gZXJyb3IuCgkJRXhhbXBsZTogPgoJCQk6bGV0IGZsYWcgPSBhbmQoYml0cywgMHg4MCkKCgphcHBlbmQoe2xudW19LCB7ZXhwcn0pCQkJCQkqYXBwZW5kKCkqCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHw6IEFwcGVuZCBlYWNoIGl0ZW0gb2YgdGhlIHxMaXN0fCBhcyBhCgkJdGV4dCBsaW5lIGJlbG93IGxpbmUge2xudW19IGluIHRoZSBjdXJyZW50IGJ1ZmZlci4KCQlPdGhlcndpc2UgYXBwZW5kIHtleHByfSBhcyBvbmUgdGV4dCBsaW5lIGJlbG93IGxpbmUge2xudW19IGluCgkJdGhlIGN1cnJlbnQgYnVmZmVyLgoJCXtsbnVtfSBjYW4gYmUgemVybyB0byBpbnNlcnQgYSBsaW5lIGJlZm9yZSB0aGUgZmlyc3Qgb25lLgoJCVJldHVybnMgMSBmb3IgZmFpbHVyZSAoe2xudW19IG91dCBvZiByYW5nZSBvciBvdXQgb2YgbWVtb3J5KSwKCQkwIGZvciBzdWNjZXNzLglFeGFtcGxlOiA+CgkJCTpsZXQgZmFpbGVkID0gYXBwZW5kKGxpbmUoJyQnKSwgIiMgVEhFIEVORCIpCgkJCTpsZXQgZmFpbGVkID0gYXBwZW5kKDAsIFsiQ2hhcHRlciAxIiwgInRoZSBiZWdpbm5pbmciXSkKPAoJCQkJCQkJKmFyZ2MoKSoKYXJnYygpCQlUaGUgcmVzdWx0IGlzIHRoZSBudW1iZXIgb2YgZmlsZXMgaW4gdGhlIGFyZ3VtZW50IGxpc3Qgb2YgdGhlCgkJY3VycmVudCB3aW5kb3cuICBTZWUgfGFyZ2xpc3R8LgoKCQkJCQkJCSphcmdpZHgoKSoKYXJnaWR4KCkJVGhlIHJlc3VsdCBpcyB0aGUgY3VycmVudCBpbmRleCBpbiB0aGUgYXJndW1lbnQgbGlzdC4gIDAgaXMKCQl0aGUgZmlyc3QgZmlsZS4gIGFyZ2MoKSAtIDEgaXMgdGhlIGxhc3Qgb25lLiAgU2VlIHxhcmdsaXN0fC4KCgkJCQkJCQkqYXJnbGlzdGlkKCkqCmFyZ2xpc3RpZChbe3dpbm5yfSBbLCB7dGFibnJ9XV0pCgkJUmV0dXJuIHRoZSBhcmd1bWVudCBsaXN0IElELiAgVGhpcyBpcyBhIG51bWJlciB3aGljaAoJCWlkZW50aWZpZXMgdGhlIGFyZ3VtZW50IGxpc3QgYmVpbmcgdXNlZC4gIFplcm8gaXMgdXNlZCBmb3IgdGhlCgkJZ2xvYmFsIGFyZ3VtZW50IGxpc3QuICBTZWUgfGFyZ2xpc3R8LgoJCVJldHVybiAtMSBpZiB0aGUgYXJndW1lbnRzIGFyZSBpbnZhbGlkLgoKCQlXaXRob3V0IGFyZ3VtZW50cyB1c2UgdGhlIGN1cnJlbnQgd2luZG93LgoJCVdpdGgge3dpbm5yfSBvbmx5IHVzZSB0aGlzIHdpbmRvdyBpbiB0aGUgY3VycmVudCB0YWIgcGFnZS4KCQlXaXRoIHt3aW5ucn0gYW5kIHt0YWJucn0gdXNlIHRoZSB3aW5kb3cgaW4gdGhlIHNwZWNpZmllZCB0YWIKCQlwYWdlLgoKCQkJCQkJCSphcmd2KCkqCmFyZ3YoW3tucn1dKQlUaGUgcmVzdWx0IGlzIHRoZSB7bnJ9dGggZmlsZSBpbiB0aGUgYXJndW1lbnQgbGlzdCBvZiB0aGUKCQljdXJyZW50IHdpbmRvdy4gIFNlZSB8YXJnbGlzdHwuICAiYXJndigwKSIgaXMgdGhlIGZpcnN0IG9uZS4KCQlFeGFtcGxlOiA+Cgk6bGV0IGkgPSAwCgk6d2hpbGUgaSA8IGFyZ2MoKQoJOiAgbGV0IGYgPSBlc2NhcGUoZm5hbWVlc2NhcGUoYXJndihpKSksICcuJykKCTogIGV4ZSAnYW1lbnUgQXJnLicgLiBmIC4gJyA6ZSAnIC4gZiAuICc8Q1I+JwoJOiAgbGV0IGkgPSBpICsgMQoJOmVuZHdoaWxlCjwJCVdpdGhvdXQgdGhlIHtucn0gYXJndW1lbnQgYSB8TGlzdHwgd2l0aCB0aGUgd2hvbGUgfGFyZ2xpc3R8IGlzCgkJcmV0dXJuZWQuCgoJCQkJCQkJKmFzc2VydF9lcXVhbCgpKgphc3NlcnRfZXF1YWwoe2V4cGVjdGVkfSwge2FjdHVhbH0gWywge21zZ31dKQoJCVdoZW4ge2V4cGVjdGVkfSBhbmQge2FjdHVhbH0gYXJlIG5vdCBlcXVhbCBhbiBlcnJvciBtZXNzYWdlIGlzCgkJYWRkZWQgdG8gfHY6ZXJyb3JzfC4KCQlUaGVyZSBpcyBubyBhdXRvbWF0aWMgY29udmVyc2lvbiwgdGhlIFN0cmluZyAiNCIgaXMgZGlmZmVyZW50CgkJZnJvbSB0aGUgTnVtYmVyIDQuICBBbmQgdGhlIG51bWJlciA0IGlzIGRpZmZlcmVudCBmcm9tIHRoZQoJCUZsb2F0IDQuMC4gIFRoZSB2YWx1ZSBvZiAnaWdub3JlY2FzZScgaXMgbm90IHVzZWQgaGVyZSwgY2FzZQoJCWFsd2F5cyBtYXR0ZXJzLgoJCVdoZW4ge21zZ30gaXMgb21pdHRlZCBhbiBlcnJvciBpbiB0aGUgZm9ybSAiRXhwZWN0ZWQKCQl7ZXhwZWN0ZWR9IGJ1dCBnb3Qge2FjdHVhbH0iIGlzIHByb2R1Y2VkLgoJCUV4YW1wbGU6ID4KCWFzc2VydF9lcXVhbCgnZm9vJywgJ2JhcicpCjwJCVdpbGwgcmVzdWx0IGluIGEgc3RyaW5nIHRvIGJlIGFkZGVkIHRvIHx2OmVycm9yc3w6Cgl0ZXN0LnZpbSBsaW5lIDEyOiBFeHBlY3RlZCAnZm9vJyBidXQgZ290ICdiYXInIH4KCmFzc2VydF9leGNlcHRpb24oe2Vycm9yfSBbLCB7bXNnfV0pCQkJKmFzc2VydF9leGNlcHRpb24oKSoKCQlXaGVuIHY6ZXhjZXB0aW9uIGRvZXMgbm90IGNvbnRhaW4gdGhlIHN0cmluZyB7ZXJyb3J9IGFuIGVycm9yCgkJbWVzc2FnZSBpcyBhZGRlZCB0byB8djplcnJvcnN8LgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gYXNzZXJ0IHRoYXQgYSBjb21tYW5kIHRocm93cyBhbiBleGNlcHRpb24uCgkJVXNpbmcgdGhlIGVycm9yIG51bWJlciwgZm9sbG93ZWQgYnkgYSBjb2xvbiwgYXZvaWRzIHByb2JsZW1zCgkJd2l0aCB0cmFuc2xhdGlvbnM6ID4KCQkJdHJ5CgkJCSAgY29tbWFuZHRoYXRmYWlscwoJCQkgIGNhbGwgYXNzZXJ0X2ZhbHNlKDEsICdjb21tYW5kIHNob3VsZCBoYXZlIGZhaWxlZCcpCgkJCWNhdGNoCgkJCSAgY2FsbCBhc3NlcnRfZXhjZXB0aW9uKCdFNDkyOicpCgkJCWVuZHRyeQoKYXNzZXJ0X2ZhaWxzKHtjbWR9IFssIHtlcnJvcn1dKQkJCQkJKmFzc2VydF9mYWlscygpKgoJCVJ1biB7Y21kfSBhbmQgYWRkIGFuIGVycm9yIG1lc3NhZ2UgdG8gfHY6ZXJyb3JzfCBpZiBpdCBkb2VzCgkJTk9UIHByb2R1Y2UgYW4gZXJyb3IuCgkJV2hlbiB7ZXJyb3J9IGlzIGdpdmVuIGl0IG11c3QgbWF0Y2ggfHY6ZXJybXNnfC4KCmFzc2VydF9mYWxzZSh7YWN0dWFsfSBbLCB7bXNnfV0pCQkJCSphc3NlcnRfZmFsc2UoKSoKCQlXaGVuIHthY3R1YWx9IGlzIG5vdCBmYWxzZSBhbiBlcnJvciBtZXNzYWdlIGlzIGFkZGVkIHRvCgkJfHY6ZXJyb3JzfCwgbGlrZSB3aXRoIHxhc3NlcnRfZXF1YWwoKXwuCgkJQSB2YWx1ZSBpcyBmYWxzZSB3aGVuIGl0IGlzIHplcm8uIFdoZW4ge2FjdHVhbH0gaXMgbm90IGEKCQludW1iZXIgdGhlIGFzc2VydCBmYWlscy4KCQlXaGVuIHttc2d9IGlzIG9taXR0ZWQgYW4gZXJyb3IgaW4gdGhlIGZvcm0gIkV4cGVjdGVkIEZhbHNlIGJ1dAoJCWdvdCB7YWN0dWFsfSIgaXMgcHJvZHVjZWQuCgoJCQkJCQkJCSphc3NlcnRfbWF0Y2goKSoKYXNzZXJ0X21hdGNoKHtwYXR0ZXJufSwge2FjdHVhbH0gWywge21zZ31dKQoJCVdoZW4ge3BhdHRlcm59IGRvZXMgbm90IG1hdGNoIHthY3R1YWx9IGFuIGVycm9yIG1lc3NhZ2UgaXMKCQlhZGRlZCB0byB8djplcnJvcnN8LgoKCQl7cGF0dGVybn0gaXMgdXNlZCBhcyB3aXRoIHw9fnw6IFRoZSBtYXRjaGluZyBpcyBhbHdheXMgZG9uZQoJCWxpa2UgJ21hZ2ljJyB3YXMgc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eSwgbm8gbWF0dGVyIHdoYXQKCQl0aGUgYWN0dWFsIHZhbHVlIG9mICdtYWdpYycgb3IgJ2Nwb3B0aW9ucycgaXMuCgoJCXthY3R1YWx9IGlzIHVzZWQgYXMgYSBzdHJpbmcsIGF1dG9tYXRpYyBjb252ZXJzaW9uIGFwcGxpZXMuCgkJVXNlICJeIiBhbmQgIiQiIHRvIG1hdGNoIHdpdGggdGhlIHN0YXJ0IGFuZCBlbmQgb2YgdGhlIHRleHQuCgkJVXNlIGJvdGggdG8gbWF0Y2ggdGhlIHdob2xlIHRleHQuCgoJCVdoZW4ge21zZ30gaXMgb21pdHRlZCBhbiBlcnJvciBpbiB0aGUgZm9ybSAiUGF0dGVybiB7cGF0dGVybn0KCQlkb2VzIG5vdCBtYXRjaCB7YWN0dWFsfSIgaXMgcHJvZHVjZWQuCgkJRXhhbXBsZTogPgoJYXNzZXJ0X21hdGNoKCdeZi4qbyQnLCAnZm9vYmFyJykKPAkJV2lsbCByZXN1bHQgaW4gYSBzdHJpbmcgdG8gYmUgYWRkZWQgdG8gfHY6ZXJyb3JzfDoKCXRlc3QudmltIGxpbmUgMTI6IFBhdHRlcm4gJ15mLipvJCcgZG9lcyBub3QgbWF0Y2ggJ2Zvb2JhcicgfgoKCQkJCQkJCSphc3NlcnRfbm90ZXF1YWwoKSoKYXNzZXJ0X25vdGVxdWFsKHtleHBlY3RlZH0sIHthY3R1YWx9IFssIHttc2d9XSkKCQlUaGUgb3Bwb3NpdGUgb2YgYGFzc2VydF9lcXVhbCgpYDogYWRkIGFuIGVycm9yIG1lc3NhZ2UgdG8KCQl8djplcnJvcnN8IHdoZW4ge2V4cGVjdGVkfSBhbmQge2FjdHVhbH0gYXJlIGVxdWFsLgoKCQkJCQkJCSphc3NlcnRfbm90bWF0Y2goKSoKYXNzZXJ0X25vdG1hdGNoKHtwYXR0ZXJufSwge2FjdHVhbH0gWywge21zZ31dKQoJCVRoZSBvcHBvc2l0ZSBvZiBgYXNzZXJ0X21hdGNoKClgOiBhZGQgYW4gZXJyb3IgbWVzc2FnZSB0bwoJCXx2OmVycm9yc3wgd2hlbiB7cGF0dGVybn0gbWF0Y2hlcyB7YWN0dWFsfS4KCmFzc2VydF90cnVlKHthY3R1YWx9IFssIHttc2d9XSkJCQkJCSphc3NlcnRfdHJ1ZSgpKgoJCVdoZW4ge2FjdHVhbH0gaXMgbm90IHRydWUgYW4gZXJyb3IgbWVzc2FnZSBpcyBhZGRlZCB0bwoJCXx2OmVycm9yc3wsIGxpa2Ugd2l0aCB8YXNzZXJ0X2VxdWFsKCl8LgoJCUEgdmFsdWUgaXMgdHJ1ZSB3aGVuIGl0IGlzIGEgbm9uLXplcm8gbnVtYmVyLiAgV2hlbiB7YWN0dWFsfQoJCWlzIG5vdCBhIG51bWJlciB0aGUgYXNzZXJ0IGZhaWxzLgoJCVdoZW4ge21zZ30gaXMgb21pdHRlZCBhbiBlcnJvciBpbiB0aGUgZm9ybSAiRXhwZWN0ZWQgVHJ1ZSBidXQKCQlnb3Qge2FjdHVhbH0iIGlzIHByb2R1Y2VkLgoKYXNpbih7ZXhwcn0pCQkJCQkJKmFzaW4oKSoKCQlSZXR1cm4gdGhlIGFyYyBzaW5lIG9mIHtleHByfSBtZWFzdXJlZCBpbiByYWRpYW5zLCBhcyBhIHxGbG9hdHwKCQlpbiB0aGUgcmFuZ2Ugb2YgWy1waS8yLCBwaS8yXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfCBpbiB0aGUgcmFuZ2UKCQlbLTEsIDFdLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGFzaW4oMC44KQo8CQkJMC45MjcyOTUgPgoJCQk6ZWNobyBhc2luKC0wLjUpCjwJCQktMC41MjM1OTkKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmF0YW4oe2V4cHJ9KQkJCQkJCSphdGFuKCkqCgkJUmV0dXJuIHRoZSBwcmluY2lwYWwgdmFsdWUgb2YgdGhlIGFyYyB0YW5nZW50IG9mIHtleHByfSwgaW4KCQl0aGUgcmFuZ2UgWy1waS8yLCArcGkvMl0gcmFkaWFucywgYXMgYSB8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGF0YW4oMTAwKQo8CQkJMS41NjA3OTcgPgoJCQk6ZWNobyBhdGFuKC00LjAxKQo8CQkJLTEuMzI2NDA1CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgphdGFuMih7ZXhwcjF9LCB7ZXhwcjJ9KQkJCQkJKmF0YW4yKCkqCgkJUmV0dXJuIHRoZSBhcmMgdGFuZ2VudCBvZiB7ZXhwcjF9IC8ge2V4cHIyfSwgbWVhc3VyZWQgaW4KCQlyYWRpYW5zLCBhcyBhIHxGbG9hdHwgaW4gdGhlIHJhbmdlIFstcGksIHBpXS4KCQl7ZXhwcjF9IGFuZCB7ZXhwcjJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gYXRhbjIoLTEsIDEpCjwJCQktMC43ODUzOTggPgoJCQk6ZWNobyBhdGFuMigxLCAtMSkKPAkJCTIuMzU2MTk0CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgoJCQkJCQkJKmJyb3dzZSgpKgpicm93c2Uoe3NhdmV9LCB7dGl0bGV9LCB7aW5pdGRpcn0sIHtkZWZhdWx0fSkKCQlQdXQgdXAgYSBmaWxlIHJlcXVlc3Rlci4gIFRoaXMgb25seSB3b3JrcyB3aGVuICJoYXMoImJyb3dzZSIpIgoJCXJldHVybnMgbm9uLXplcm8gKG9ubHkgaW4gc29tZSBHVUkgdmVyc2lvbnMpLgoJCVRoZSBpbnB1dCBmaWVsZHMgYXJlOgoJCSAgICB7c2F2ZX0Jd2hlbiBub24temVybywgc2VsZWN0IGZpbGUgdG8gd3JpdGUKCQkgICAge3RpdGxlfQl0aXRsZSBmb3IgdGhlIHJlcXVlc3RlcgoJCSAgICB7aW5pdGRpcn0JZGlyZWN0b3J5IHRvIHN0YXJ0IGJyb3dzaW5nIGluCgkJICAgIHtkZWZhdWx0fQlkZWZhdWx0IGZpbGUgbmFtZQoJCVdoZW4gdGhlICJDYW5jZWwiIGJ1dHRvbiBpcyBoaXQsIHNvbWV0aGluZyB3ZW50IHdyb25nLCBvcgoJCWJyb3dzaW5nIGlzIG5vdCBwb3NzaWJsZSwgYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoKCQkJCQkJCSpicm93c2VkaXIoKSoKYnJvd3NlZGlyKHt0aXRsZX0sIHtpbml0ZGlyfSkKCQlQdXQgdXAgYSBkaXJlY3RvcnkgcmVxdWVzdGVyLiAgVGhpcyBvbmx5IHdvcmtzIHdoZW4KCQkiaGFzKCJicm93c2UiKSIgcmV0dXJucyBub24temVybyAob25seSBpbiBzb21lIEdVSSB2ZXJzaW9ucykuCgkJT24gc3lzdGVtcyB3aGVyZSBhIGRpcmVjdG9yeSBicm93c2VyIGlzIG5vdCBzdXBwb3J0ZWQgYSBmaWxlCgkJYnJvd3NlciBpcyB1c2VkLiAgSW4gdGhhdCBjYXNlOiBzZWxlY3QgYSBmaWxlIGluIHRoZSBkaXJlY3RvcnkKCQl0byBiZSB1c2VkLgoJCVRoZSBpbnB1dCBmaWVsZHMgYXJlOgoJCSAgICB7dGl0bGV9CXRpdGxlIGZvciB0aGUgcmVxdWVzdGVyCgkJICAgIHtpbml0ZGlyfQlkaXJlY3RvcnkgdG8gc3RhcnQgYnJvd3NpbmcgaW4KCQlXaGVuIHRoZSAiQ2FuY2VsIiBidXR0b24gaXMgaGl0LCBzb21ldGhpbmcgd2VudCB3cm9uZywgb3IKCQlicm93c2luZyBpcyBub3QgcG9zc2libGUsIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCmJ1ZmV4aXN0cyh7ZXhwcn0pCQkJCQkqYnVmZXhpc3RzKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gaWYgYSBidWZmZXIgY2FsbGVkCgkJe2V4cHJ9IGV4aXN0cy4KCQlJZiB0aGUge2V4cHJ9IGFyZ3VtZW50IGlzIGEgbnVtYmVyLCBidWZmZXIgbnVtYmVycyBhcmUgdXNlZC4KCQlJZiB0aGUge2V4cHJ9IGFyZ3VtZW50IGlzIGEgc3RyaW5nIGl0IG11c3QgbWF0Y2ggYSBidWZmZXIgbmFtZQoJCWV4YWN0bHkuICBUaGUgbmFtZSBjYW4gYmU6CgkJLSBSZWxhdGl2ZSB0byB0aGUgY3VycmVudCBkaXJlY3RvcnkuCgkJLSBBIGZ1bGwgcGF0aC4KCQktIFRoZSBuYW1lIG9mIGEgYnVmZmVyIHdpdGggJ2J1ZnR5cGUnIHNldCB0byAibm9maWxlIi4KCQktIEEgVVJMIG5hbWUuCgkJVW5saXN0ZWQgYnVmZmVycyB3aWxsIGJlIGZvdW5kLgoJCU5vdGUgdGhhdCBoZWxwIGZpbGVzIGFyZSBsaXN0ZWQgYnkgdGhlaXIgc2hvcnQgbmFtZSBpbiB0aGUKCQlvdXRwdXQgb2YgfDpidWZmZXJzfCwgYnV0IGJ1ZmV4aXN0cygpIHJlcXVpcmVzIHVzaW5nIHRoZWlyCgkJbG9uZyBuYW1lIHRvIGJlIGFibGUgdG8gZmluZCB0aGVtLgoJCWJ1ZmV4aXN0cygpIG1heSByZXBvcnQgYSBidWZmZXIgZXhpc3RzLCBidXQgdG8gdXNlIHRoZSBuYW1lCgkJd2l0aCBhIHw6YnVmZmVyfCBjb21tYW5kIHlvdSBtYXkgbmVlZCB0byB1c2UgfGV4cGFuZCgpfC4gIEVzcAoJCWZvciBNUy1XaW5kb3dzIDguMyBuYW1lcyBpbiB0aGUgZm9ybSAiYzpcRE9DVU1FfjEiCgkJVXNlICJidWZleGlzdHMoMCkiIHRvIHRlc3QgZm9yIHRoZSBleGlzdGVuY2Ugb2YgYW4gYWx0ZXJuYXRlCgkJZmlsZSBuYW1lLgoJCQkJCQkJKmJ1ZmZlcl9leGlzdHMoKSoKCQlPYnNvbGV0ZSBuYW1lOiBidWZmZXJfZXhpc3RzKCkuCgpidWZsaXN0ZWQoe2V4cHJ9KQkJCQkJKmJ1Zmxpc3RlZCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIGlmIGEgYnVmZmVyIGNhbGxlZAoJCXtleHByfSBleGlzdHMgYW5kIGlzIGxpc3RlZCAoaGFzIHRoZSAnYnVmbGlzdGVkJyBvcHRpb24gc2V0KS4KCQlUaGUge2V4cHJ9IGFyZ3VtZW50IGlzIHVzZWQgbGlrZSB3aXRoIHxidWZleGlzdHMoKXwuCgpidWZsb2FkZWQoe2V4cHJ9KQkJCQkJKmJ1ZmxvYWRlZCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIGlmIGEgYnVmZmVyIGNhbGxlZAoJCXtleHByfSBleGlzdHMgYW5kIGlzIGxvYWRlZCAoc2hvd24gaW4gYSB3aW5kb3cgb3IgaGlkZGVuKS4KCQlUaGUge2V4cHJ9IGFyZ3VtZW50IGlzIHVzZWQgbGlrZSB3aXRoIHxidWZleGlzdHMoKXwuCgpidWZuYW1lKHtleHByfSkJCQkJCQkqYnVmbmFtZSgpKgoJCVRoZSByZXN1bHQgaXMgdGhlIG5hbWUgb2YgYSBidWZmZXIsIGFzIGl0IGlzIGRpc3BsYXllZCBieSB0aGUKCQkiOmxzIiBjb21tYW5kLgoJCUlmIHtleHByfSBpcyBhIE51bWJlciwgdGhhdCBidWZmZXIgbnVtYmVyJ3MgbmFtZSBpcyBnaXZlbi4KCQlOdW1iZXIgemVybyBpcyB0aGUgYWx0ZXJuYXRlIGJ1ZmZlciBmb3IgdGhlIGN1cnJlbnQgd2luZG93LgoJCUlmIHtleHByfSBpcyBhIFN0cmluZywgaXQgaXMgdXNlZCBhcyBhIHxmaWxlLXBhdHRlcm58IHRvIG1hdGNoCgkJd2l0aCB0aGUgYnVmZmVyIG5hbWVzLglUaGlzIGlzIGFsd2F5cyBkb25lIGxpa2UgJ21hZ2ljJyBpcwoJCXNldCBhbmQgJ2Nwb3B0aW9ucycgaXMgZW1wdHkuICBXaGVuIHRoZXJlIGlzIG1vcmUgdGhhbiBvbmUKCQltYXRjaCBhbiBlbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuCgkJIiIgb3IgIiUiIGNhbiBiZSB1c2VkIGZvciB0aGUgY3VycmVudCBidWZmZXIsICIjIiBmb3IgdGhlCgkJYWx0ZXJuYXRlIGJ1ZmZlci4KCQlBIGZ1bGwgbWF0Y2ggaXMgcHJlZmVycmVkLCBvdGhlcndpc2UgYSBtYXRjaCBhdCB0aGUgc3RhcnQsIGVuZAoJCW9yIG1pZGRsZSBvZiB0aGUgYnVmZmVyIG5hbWUgaXMgYWNjZXB0ZWQuICBJZiB5b3Ugb25seSB3YW50IGEKCQlmdWxsIG1hdGNoIHRoZW4gcHV0ICJeIiBhdCB0aGUgc3RhcnQgYW5kICIkIiBhdCB0aGUgZW5kIG9mIHRoZQoJCXBhdHRlcm4uCgkJTGlzdGVkIGJ1ZmZlcnMgYXJlIGZvdW5kIGZpcnN0LiAgSWYgdGhlcmUgaXMgYSBzaW5nbGUgbWF0Y2gKCQl3aXRoIGEgbGlzdGVkIGJ1ZmZlciwgdGhhdCBvbmUgaXMgcmV0dXJuZWQuICBOZXh0IHVubGlzdGVkCgkJYnVmZmVycyBhcmUgc2VhcmNoZWQgZm9yLgoJCUlmIHRoZSB7ZXhwcn0gaXMgYSBTdHJpbmcsIGJ1dCB5b3Ugd2FudCB0byB1c2UgaXQgYXMgYSBidWZmZXIKCQludW1iZXIsIGZvcmNlIGl0IHRvIGJlIGEgTnVtYmVyIGJ5IGFkZGluZyB6ZXJvIHRvIGl0OiA+CgkJCTplY2hvIGJ1Zm5hbWUoIjMiICsgMCkKPAkJSWYgdGhlIGJ1ZmZlciBkb2Vzbid0IGV4aXN0LCBvciBkb2Vzbid0IGhhdmUgYSBuYW1lLCBhbiBlbXB0eQoJCXN0cmluZyBpcyByZXR1cm5lZC4gPgoJYnVmbmFtZSgiIyIpCQlhbHRlcm5hdGUgYnVmZmVyIG5hbWUKCWJ1Zm5hbWUoMykJCW5hbWUgb2YgYnVmZmVyIDMKCWJ1Zm5hbWUoIiUiKQkJbmFtZSBvZiBjdXJyZW50IGJ1ZmZlcgoJYnVmbmFtZSgiZmlsZTIiKQluYW1lIG9mIGJ1ZmZlciB3aGVyZSAiZmlsZTIiIG1hdGNoZXMuCjwJCQkJCQkJKmJ1ZmZlcl9uYW1lKCkqCgkJT2Jzb2xldGUgbmFtZTogYnVmZmVyX25hbWUoKS4KCgkJCQkJCQkqYnVmbnIoKSoKYnVmbnIoe2V4cHJ9IFssIHtjcmVhdGV9XSkKCQlUaGUgcmVzdWx0IGlzIHRoZSBudW1iZXIgb2YgYSBidWZmZXIsIGFzIGl0IGlzIGRpc3BsYXllZCBieQoJCXRoZSAiOmxzIiBjb21tYW5kLiAgRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9LCBzZWUgfGJ1Zm5hbWUoKXwKCQlhYm92ZS4KCQlJZiB0aGUgYnVmZmVyIGRvZXNuJ3QgZXhpc3QsIC0xIGlzIHJldHVybmVkLiAgT3IsIGlmIHRoZQoJCXtjcmVhdGV9IGFyZ3VtZW50IGlzIHByZXNlbnQgYW5kIG5vdCB6ZXJvLCBhIG5ldywgdW5saXN0ZWQsCgkJYnVmZmVyIGlzIGNyZWF0ZWQgYW5kIGl0cyBudW1iZXIgaXMgcmV0dXJuZWQuCgkJYnVmbnIoIiQiKSBpcyB0aGUgbGFzdCBidWZmZXI6ID4KCTpsZXQgbGFzdF9idWZmZXIgPSBidWZucigiJCIpCjwJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBoaWdoZXN0IGJ1ZmZlciBudW1iZXIKCQlvZiBleGlzdGluZyBidWZmZXJzLiAgTm90ZSB0aGF0IG5vdCBhbGwgYnVmZmVycyB3aXRoIGEgc21hbGxlcgoJCW51bWJlciBuZWNlc3NhcmlseSBleGlzdCwgYmVjYXVzZSAiOmJ3aXBlb3V0IiBtYXkgaGF2ZSByZW1vdmVkCgkJdGhlbS4gIFVzZSBidWZleGlzdHMoKSB0byB0ZXN0IGZvciB0aGUgZXhpc3RlbmNlIG9mIGEgYnVmZmVyLgoJCQkJCQkJKmJ1ZmZlcl9udW1iZXIoKSoKCQlPYnNvbGV0ZSBuYW1lOiBidWZmZXJfbnVtYmVyKCkuCgkJCQkJCQkqbGFzdF9idWZmZXJfbnIoKSoKCQlPYnNvbGV0ZSBuYW1lIGZvciBidWZucigiJCIpOiBsYXN0X2J1ZmZlcl9ucigpLgoKYnVmd2lubnIoe2V4cHJ9KQkJCQkJKmJ1Zndpbm5yKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIG51bWJlciBvZiB0aGUgZmlyc3QKCQl3aW5kb3cgYXNzb2NpYXRlZCB3aXRoIGJ1ZmZlciB7ZXhwcn0uICBGb3IgdGhlIHVzZSBvZiB7ZXhwcn0sCgkJc2VlIHxidWZuYW1lKCl8IGFib3ZlLglJZiBidWZmZXIge2V4cHJ9IGRvZXNuJ3QgZXhpc3Qgb3IKCQl0aGVyZSBpcyBubyBzdWNoIHdpbmRvdywgLTEgaXMgcmV0dXJuZWQuICBFeGFtcGxlOiA+CgoJZWNobyAiQSB3aW5kb3cgY29udGFpbmluZyBidWZmZXIgMSBpcyAiIC4gKGJ1Zndpbm5yKDEpKQoKPAkJVGhlIG51bWJlciBjYW4gYmUgdXNlZCB3aXRoIHxDVFJMLVdfd3wgYW5kICI6d2luY21kIHciCgkJfDp3aW5jbWR8LgoJCU9ubHkgZGVhbHMgd2l0aCB0aGUgY3VycmVudCB0YWIgcGFnZS4KCmJ5dGUybGluZSh7Ynl0ZX0pCQkJCQkqYnl0ZTJsaW5lKCkqCgkJUmV0dXJuIHRoZSBsaW5lIG51bWJlciB0aGF0IGNvbnRhaW5zIHRoZSBjaGFyYWN0ZXIgYXQgYnl0ZQoJCWNvdW50IHtieXRlfSBpbiB0aGUgY3VycmVudCBidWZmZXIuICBUaGlzIGluY2x1ZGVzIHRoZQoJCWVuZC1vZi1saW5lIGNoYXJhY3RlciwgZGVwZW5kaW5nIG9uIHRoZSAnZmlsZWZvcm1hdCcgb3B0aW9uCgkJZm9yIHRoZSBjdXJyZW50IGJ1ZmZlci4gIFRoZSBmaXJzdCBjaGFyYWN0ZXIgaGFzIGJ5dGUgY291bnQKCQlvbmUuCgkJQWxzbyBzZWUgfGxpbmUyYnl0ZSgpfCwgfGdvfCBhbmQgfDpnb3RvfC4KCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrYnl0ZV9vZmZzZXR8CgkJZmVhdHVyZX0KCmJ5dGVpZHgoe2V4cHJ9LCB7bnJ9KQkJCQkJKmJ5dGVpZHgoKSoKCQlSZXR1cm4gYnl0ZSBpbmRleCBvZiB0aGUge25yfSd0aCBjaGFyYWN0ZXIgaW4gdGhlIHN0cmluZwoJCXtleHByfS4gIFVzZSB6ZXJvIGZvciB0aGUgZmlyc3QgY2hhcmFjdGVyLCBpdCByZXR1cm5zIHplcm8uCgkJVGhpcyBmdW5jdGlvbiBpcyBvbmx5IHVzZWZ1bCB3aGVuIHRoZXJlIGFyZSBtdWx0aWJ5dGUKCQljaGFyYWN0ZXJzLCBvdGhlcndpc2UgdGhlIHJldHVybmVkIHZhbHVlIGlzIGVxdWFsIHRvIHtucn0uCgkJQ29tcG9zaW5nIGNoYXJhY3RlcnMgYXJlIG5vdCBjb3VudGVkIHNlcGFyYXRlbHksIHRoZWlyIGJ5dGUKCQlsZW5ndGggaXMgYWRkZWQgdG8gdGhlIHByZWNlZGluZyBiYXNlIGNoYXJhY3Rlci4gIFNlZQoJCXxieXRlaWR4Y29tcCgpfCBiZWxvdyBmb3IgY291bnRpbmcgY29tcG9zaW5nIGNoYXJhY3RlcnMKCQlzZXBhcmF0ZWx5LgoJCUV4YW1wbGUgOiA+CgkJCWVjaG8gbWF0Y2hzdHIoc3RyLCAiLiIsIGJ5dGVpZHgoc3RyLCAzKSkKPAkJd2lsbCBkaXNwbGF5IHRoZSBmb3VydGggY2hhcmFjdGVyLiAgQW5vdGhlciB3YXkgdG8gZG8gdGhlCgkJc2FtZTogPgoJCQlsZXQgcyA9IHN0cnBhcnQoc3RyLCBieXRlaWR4KHN0ciwgMykpCgkJCWVjaG8gc3RycGFydChzLCAwLCBieXRlaWR4KHMsIDEpKQo8CQlBbHNvIHNlZSB8c3RyZ2V0Y2hhcigpfCBhbmQgfHN0cmNoYXJwYXJ0KCl8LgoKCQlJZiB0aGVyZSBhcmUgbGVzcyB0aGFuIHtucn0gY2hhcmFjdGVycyAtMSBpcyByZXR1cm5lZC4KCQlJZiB0aGVyZSBhcmUgZXhhY3RseSB7bnJ9IGNoYXJhY3RlcnMgdGhlIGxlbmd0aCBvZiB0aGUgc3RyaW5nCgkJaW4gYnl0ZXMgaXMgcmV0dXJuZWQuCgpieXRlaWR4Y29tcCh7ZXhwcn0sIHtucn0pCQkJCQkqYnl0ZWlkeGNvbXAoKSoKCQlMaWtlIGJ5dGVpZHgoKSwgZXhjZXB0IHRoYXQgYSBjb21wb3NpbmcgY2hhcmFjdGVyIGlzIGNvdW50ZWQKCQlhcyBhIHNlcGFyYXRlIGNoYXJhY3Rlci4gIEV4YW1wbGU6ID4KCQkJbGV0IHMgPSAnZScgLiBucjJjaGFyKDB4MzAxKQoJCQllY2hvIGJ5dGVpZHgocywgMSkKCQkJZWNobyBieXRlaWR4Y29tcChzLCAxKQoJCQllY2hvIGJ5dGVpZHhjb21wKHMsIDIpCjwJCVRoZSBmaXJzdCBhbmQgdGhpcmQgZWNobyByZXN1bHQgaW4gMyAoJ2UnIHBsdXMgY29tcG9zaW5nCgkJY2hhcmFjdGVyIGlzIDMgYnl0ZXMpLCB0aGUgc2Vjb25kIGVjaG8gcmVzdWx0cyBpbiAxICgnZScgaXMKCQlvbmUgYnl0ZSkuCgkJT25seSB3b3JrcyBkaWZmZXJlbnQgZnJvbSBieXRlaWR4KCkgd2hlbiAnZW5jb2RpbmcnIGlzIHNldCB0bwoJCWEgVW5pY29kZSBlbmNvZGluZy4KCmNhbGwoe2Z1bmN9LCB7YXJnbGlzdH0gWywge2RpY3R9XSkJCQkqY2FsbCgpKiAqRTY5OSoKCQlDYWxsIGZ1bmN0aW9uIHtmdW5jfSB3aXRoIHRoZSBpdGVtcyBpbiB8TGlzdHwge2FyZ2xpc3R9IGFzCgkJYXJndW1lbnRzLgoJCXtmdW5jfSBjYW4gZWl0aGVyIGJlIGEgfEZ1bmNyZWZ8IG9yIHRoZSBuYW1lIG9mIGEgZnVuY3Rpb24uCgkJYTpmaXJzdGxpbmUgYW5kIGE6bGFzdGxpbmUgYXJlIHNldCB0byB0aGUgY3Vyc29yIGxpbmUuCgkJUmV0dXJucyB0aGUgcmV0dXJuIHZhbHVlIG9mIHRoZSBjYWxsZWQgZnVuY3Rpb24uCgkJe2RpY3R9IGlzIGZvciBmdW5jdGlvbnMgd2l0aCB0aGUgImRpY3QiIGF0dHJpYnV0ZS4gIEl0IHdpbGwgYmUKCQl1c2VkIHRvIHNldCB0aGUgbG9jYWwgdmFyaWFibGUgInNlbGYiLiB8RGljdGlvbmFyeS1mdW5jdGlvbnwKCmNlaWwoe2V4cHJ9KQkJCQkJCQkqY2VpbCgpKgoJCVJldHVybiB0aGUgc21hbGxlc3QgaW50ZWdyYWwgdmFsdWUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvCgkJe2V4cHJ9IGFzIGEgfEZsb2F0fCAocm91bmQgdXApLgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCWVjaG8gY2VpbCgxLjQ1NikKPAkJCTIuMCAgPgoJCQllY2hvIGNlaWwoLTUuNDU2KQo8CQkJLTUuMCAgPgoJCQllY2hvIGNlaWwoNC4wKQo8CQkJNC4wCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCmNoYW5nZW5yKCkJCQkJCQkqY2hhbmdlbnIoKSoKCQlSZXR1cm4gdGhlIG51bWJlciBvZiB0aGUgbW9zdCByZWNlbnQgY2hhbmdlLiAgVGhpcyBpcyB0aGUgc2FtZQoJCW51bWJlciBhcyB3aGF0IGlzIGRpc3BsYXllZCB3aXRoIHw6dW5kb2xpc3R8IGFuZCBjYW4gYmUgdXNlZAoJCXdpdGggdGhlIHw6dW5kb3wgY29tbWFuZC4KCQlXaGVuIGEgY2hhbmdlIHdhcyBtYWRlIGl0IGlzIHRoZSBudW1iZXIgb2YgdGhhdCBjaGFuZ2UuICBBZnRlcgoJCXJlZG8gaXQgaXMgdGhlIG51bWJlciBvZiB0aGUgcmVkb25lIGNoYW5nZS4gIEFmdGVyIHVuZG8gaXQgaXMKCQlvbmUgbGVzcyB0aGFuIHRoZSBudW1iZXIgb2YgdGhlIHVuZG9uZSBjaGFuZ2UuCgpjaGFyMm5yKHtleHByfVssIHt1dGY4fV0pCQkJCQkqY2hhcjJucigpKgoJCVJldHVybiBudW1iZXIgdmFsdWUgb2YgdGhlIGZpcnN0IGNoYXIgaW4ge2V4cHJ9LiAgRXhhbXBsZXM6ID4KCQkJY2hhcjJucigiICIpCQlyZXR1cm5zIDMyCgkJCWNoYXIybnIoIkFCQyIpCQlyZXR1cm5zIDY1CjwJCVdoZW4ge3V0Zjh9IGlzIG9taXR0ZWQgb3IgemVybywgdGhlIGN1cnJlbnQgJ2VuY29kaW5nJyBpcyB1c2VkLgoJCUV4YW1wbGUgZm9yICJ1dGYtOCI6ID4KCQkJY2hhcjJucigi4SIpCQlyZXR1cm5zIDIyNQoJCQljaGFyMm5yKCLhIlswXSkJCXJldHVybnMgMTk1CjwJCVdpdGgge3V0Zjh9IHNldCB0byAxLCBhbHdheXMgdHJlYXQgYXMgdXRmLTggY2hhcmFjdGVycy4KCQlBIGNvbWJpbmluZyBjaGFyYWN0ZXIgaXMgYSBzZXBhcmF0ZSBjaGFyYWN0ZXIuCgkJfG5yMmNoYXIoKXwgZG9lcyB0aGUgb3Bwb3NpdGUuCgpjaW5kZW50KHtsbnVtfSkJCQkJCQkqY2luZGVudCgpKgoJCUdldCB0aGUgYW1vdW50IG9mIGluZGVudCBmb3IgbGluZSB7bG51bX0gYWNjb3JkaW5nIHRoZSBDCgkJaW5kZW50aW5nIHJ1bGVzLCBhcyB3aXRoICdjaW5kZW50Jy4KCQlUaGUgaW5kZW50IGlzIGNvdW50ZWQgaW4gc3BhY2VzLCB0aGUgdmFsdWUgb2YgJ3RhYnN0b3AnIGlzCgkJcmVsZXZhbnQuICB7bG51bX0gaXMgdXNlZCBqdXN0IGxpa2UgaW4gfGdldGxpbmUoKXwuCgkJV2hlbiB7bG51bX0gaXMgaW52YWxpZCBvciBWaW0gd2FzIG5vdCBjb21waWxlZCB0aGUgfCtjaW5kZW50fAoJCWZlYXR1cmUsIC0xIGlzIHJldHVybmVkLgoJCVNlZSB8Qy1pbmRlbnRpbmd8LgoKY2xlYXJtYXRjaGVzKCkJCQkJCQkqY2xlYXJtYXRjaGVzKCkqCgkJQ2xlYXJzIGFsbCBtYXRjaGVzIHByZXZpb3VzbHkgZGVmaW5lZCBieSB8bWF0Y2hhZGQoKXwgYW5kIHRoZQoJCXw6bWF0Y2h8IGNvbW1hbmRzLgoKCQkJCQkJCSpjb2woKSoKY29sKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGJ5dGUgaW5kZXggb2YgdGhlIGNvbHVtbgoJCXBvc2l0aW9uIGdpdmVuIHdpdGgge2V4cHJ9LiAgVGhlIGFjY2VwdGVkIHBvc2l0aW9ucyBhcmU6CgkJICAgIC4JICAgIHRoZSBjdXJzb3IgcG9zaXRpb24KCQkgICAgJAkgICAgdGhlIGVuZCBvZiB0aGUgY3Vyc29yIGxpbmUgKHRoZSByZXN1bHQgaXMgdGhlCgkJCSAgICBudW1iZXIgb2YgYnl0ZXMgaW4gdGhlIGN1cnNvciBsaW5lIHBsdXMgb25lKQoJCSAgICAneAkgICAgcG9zaXRpb24gb2YgbWFyayB4IChpZiB0aGUgbWFyayBpcyBub3Qgc2V0LCAwIGlzCgkJCSAgICByZXR1cm5lZCkKCQkgICAgdiAgICAgICBJbiBWaXN1YWwgbW9kZTogdGhlIHN0YXJ0IG9mIHRoZSBWaXN1YWwgYXJlYSAodGhlCgkJCSAgICBjdXJzb3IgaXMgdGhlIGVuZCkuICBXaGVuIG5vdCBpbiBWaXN1YWwgbW9kZQoJCQkgICAgcmV0dXJucyB0aGUgY3Vyc29yIHBvc2l0aW9uLiAgRGlmZmVycyBmcm9tIHwnPHwgaW4KCQkJICAgIHRoYXQgaXQncyB1cGRhdGVkIHJpZ2h0IGF3YXkuCgkJQWRkaXRpb25hbGx5IHtleHByfSBjYW4gYmUgW2xudW0sIGNvbF06IGEgfExpc3R8IHdpdGggdGhlIGxpbmUKCQlhbmQgY29sdW1uIG51bWJlci4gTW9zdCB1c2VmdWwgd2hlbiB0aGUgY29sdW1uIGlzICIkIiwgdG8gZ2V0CgkJdGhlIGxhc3QgY29sdW1uIG9mIGEgc3BlY2lmaWMgbGluZS4gIFdoZW4gImxudW0iIG9yICJjb2wiIGlzCgkJb3V0IG9mIHJhbmdlIHRoZW4gY29sKCkgcmV0dXJucyB6ZXJvLgoJCVRvIGdldCB0aGUgbGluZSBudW1iZXIgdXNlIHxsaW5lKCl8LiAgVG8gZ2V0IGJvdGggdXNlCgkJfGdldHBvcygpfC4KCQlGb3IgdGhlIHNjcmVlbiBjb2x1bW4gcG9zaXRpb24gdXNlIHx2aXJ0Y29sKCl8LgoJCU5vdGUgdGhhdCBvbmx5IG1hcmtzIGluIHRoZSBjdXJyZW50IGZpbGUgY2FuIGJlIHVzZWQuCgkJRXhhbXBsZXM6ID4KCQkJY29sKCIuIikJCWNvbHVtbiBvZiBjdXJzb3IKCQkJY29sKCIkIikJCWxlbmd0aCBvZiBjdXJzb3IgbGluZSBwbHVzIG9uZQoJCQljb2woIid0IikJCWNvbHVtbiBvZiBtYXJrIHQKCQkJY29sKCInIiAuIG1hcmtuYW1lKQljb2x1bW4gb2YgbWFyayBtYXJrbmFtZQo8CQlUaGUgZmlyc3QgY29sdW1uIGlzIDEuCTAgaXMgcmV0dXJuZWQgZm9yIGFuIGVycm9yLgoJCUZvciBhbiB1cHBlcmNhc2UgbWFyayB0aGUgY29sdW1uIG1heSBhY3R1YWxseSBiZSBpbiBhbm90aGVyCgkJYnVmZmVyLgoJCUZvciB0aGUgY3Vyc29yIHBvc2l0aW9uLCB3aGVuICd2aXJ0dWFsZWRpdCcgaXMgYWN0aXZlLCB0aGUKCQljb2x1bW4gaXMgb25lIGhpZ2hlciBpZiB0aGUgY3Vyc29yIGlzIGFmdGVyIHRoZSBlbmQgb2YgdGhlCgkJbGluZS4gIFRoaXMgY2FuIGJlIHVzZWQgdG8gb2J0YWluIHRoZSBjb2x1bW4gaW4gSW5zZXJ0IG1vZGU6ID4KCQkJOmltYXAgPEYyPiA8Qy1PPjpsZXQgc2F2ZV92ZSA9ICZ2ZTxDUj4KCQkJCVw8Qy1PPjpzZXQgdmU9YWxsPENSPgoJCQkJXDxDLU8+OmVjaG8gY29sKCIuIikgLiAiXG4iIDxCYXI+CgkJCQlcbGV0ICZ2ZSA9IHNhdmVfdmU8Q1I+CjwKCmNvbXBsZXRlKHtzdGFydGNvbH0sIHttYXRjaGVzfSkJCQkqY29tcGxldGUoKSogKkU3ODUqCgkJU2V0IHRoZSBtYXRjaGVzIGZvciBJbnNlcnQgbW9kZSBjb21wbGV0aW9uLgoJCUNhbiBvbmx5IGJlIHVzZWQgaW4gSW5zZXJ0IG1vZGUuICBZb3UgbmVlZCB0byB1c2UgYSBtYXBwaW5nCgkJd2l0aCBDVFJMLVIgPSB8aV9DVFJMLVJ8LiAgSXQgZG9lcyBub3Qgd29yayBhZnRlciBDVFJMLU8gb3IKCQl3aXRoIGFuIGV4cHJlc3Npb24gbWFwcGluZy4KCQl7c3RhcnRjb2x9IGlzIHRoZSBieXRlIG9mZnNldCBpbiB0aGUgbGluZSB3aGVyZSB0aGUgY29tcGxldGVkCgkJdGV4dCBzdGFydC4gIFRoZSB0ZXh0IHVwIHRvIHRoZSBjdXJzb3IgaXMgdGhlIG9yaWdpbmFsIHRleHQKCQl0aGF0IHdpbGwgYmUgcmVwbGFjZWQgYnkgdGhlIG1hdGNoZXMuICBVc2UgY29sKCcuJykgZm9yIGFuCgkJZW1wdHkgc3RyaW5nLiAgImNvbCgnLicpIC0gMSIgd2lsbCByZXBsYWNlIG9uZSBjaGFyYWN0ZXIgYnkgYQoJCW1hdGNoLgoJCXttYXRjaGVzfSBtdXN0IGJlIGEgfExpc3R8LiAgRWFjaCB8TGlzdHwgaXRlbSBpcyBvbmUgbWF0Y2guCgkJU2VlIHxjb21wbGV0ZS1pdGVtc3wgZm9yIHRoZSBraW5kIG9mIGl0ZW1zIHRoYXQgYXJlIHBvc3NpYmxlLgoJCU5vdGUgdGhhdCB0aGUgYWZ0ZXIgY2FsbGluZyB0aGlzIGZ1bmN0aW9uIHlvdSBuZWVkIHRvIGF2b2lkCgkJaW5zZXJ0aW5nIGFueXRoaW5nIHRoYXQgd291bGQgY2F1c2UgY29tcGxldGlvbiB0byBzdG9wLgoJCVRoZSBtYXRjaCBjYW4gYmUgc2VsZWN0ZWQgd2l0aCBDVFJMLU4gYW5kIENUUkwtUCBhcyB1c3VhbCB3aXRoCgkJSW5zZXJ0IG1vZGUgY29tcGxldGlvbi4gIFRoZSBwb3B1cCBtZW51IHdpbGwgYXBwZWFyIGlmCgkJc3BlY2lmaWVkLCBzZWUgfGlucy1jb21wbGV0aW9uLW1lbnV8LgoJCUV4YW1wbGU6ID4KCWlub3JlbWFwIDxGNT4gPEMtUj49TGlzdE1vbnRocygpPENSPgoKCWZ1bmMhIExpc3RNb250aHMoKQoJICBjYWxsIGNvbXBsZXRlKGNvbCgnLicpLCBbJ0phbnVhcnknLCAnRmVicnVhcnknLCAnTWFyY2gnLAoJCVwgJ0FwcmlsJywgJ01heScsICdKdW5lJywgJ0p1bHknLCAnQXVndXN0JywgJ1NlcHRlbWJlcicsCgkJXCAnT2N0b2JlcicsICdOb3ZlbWJlcicsICdEZWNlbWJlciddKQoJICByZXR1cm4gJycKCWVuZGZ1bmMKPAkJVGhpcyBpc24ndCB2ZXJ5IHVzZWZ1bCwgYnV0IGl0IHNob3dzIGhvdyBpdCB3b3Jrcy4gIE5vdGUgdGhhdAoJCWFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZCB0byBhdm9pZCBhIHplcm8gYmVpbmcgaW5zZXJ0ZWQuCgpjb21wbGV0ZV9hZGQoe2V4cHJ9KQkJCQkqY29tcGxldGVfYWRkKCkqCgkJQWRkIHtleHByfSB0byB0aGUgbGlzdCBvZiBtYXRjaGVzLiAgT25seSB0byBiZSB1c2VkIGJ5IHRoZQoJCWZ1bmN0aW9uIHNwZWNpZmllZCB3aXRoIHRoZSAnY29tcGxldGVmdW5jJyBvcHRpb24uCgkJUmV0dXJucyAwIGZvciBmYWlsdXJlIChlbXB0eSBzdHJpbmcgb3Igb3V0IG9mIG1lbW9yeSksCgkJMSB3aGVuIHRoZSBtYXRjaCB3YXMgYWRkZWQsIDIgd2hlbiB0aGUgbWF0Y2ggd2FzIGFscmVhZHkgaW4KCQl0aGUgbGlzdC4KCQlTZWUgfGNvbXBsZXRlLWZ1bmN0aW9uc3wgZm9yIGFuIGV4cGxhbmF0aW9uIG9mIHtleHByfS4JSXQgaXMKCQl0aGUgc2FtZSBhcyBvbmUgaXRlbSBpbiB0aGUgbGlzdCB0aGF0ICdvbW5pZnVuYycgd291bGQgcmV0dXJuLgoKY29tcGxldGVfY2hlY2soKQkJCQkqY29tcGxldGVfY2hlY2soKSoKCQlDaGVjayBmb3IgYSBrZXkgdHlwZWQgd2hpbGUgbG9va2luZyBmb3IgY29tcGxldGlvbiBtYXRjaGVzLgoJCVRoaXMgaXMgdG8gYmUgdXNlZCB3aGVuIGxvb2tpbmcgZm9yIG1hdGNoZXMgdGFrZXMgc29tZSB0aW1lLgoJCVJldHVybnMgbm9uLXplcm8gd2hlbiBzZWFyY2hpbmcgZm9yIG1hdGNoZXMgaXMgdG8gYmUgYWJvcnRlZCwKCQl6ZXJvIG90aGVyd2lzZS4KCQlPbmx5IHRvIGJlIHVzZWQgYnkgdGhlIGZ1bmN0aW9uIHNwZWNpZmllZCB3aXRoIHRoZQoJCSdjb21wbGV0ZWZ1bmMnIG9wdGlvbi4KCgkJCQkJCSpjb25maXJtKCkqCmNvbmZpcm0oe21zZ30gWywge2Nob2ljZXN9IFssIHtkZWZhdWx0fSBbLCB7dHlwZX1dXV0pCgkJQ29uZmlybSgpIG9mZmVycyB0aGUgdXNlciBhIGRpYWxvZywgZnJvbSB3aGljaCBhIGNob2ljZSBjYW4gYmUKCQltYWRlLiAgSXQgcmV0dXJucyB0aGUgbnVtYmVyIG9mIHRoZSBjaG9pY2UuICBGb3IgdGhlIGZpcnN0CgkJY2hvaWNlIHRoaXMgaXMgMS4KCQlOb3RlOiBjb25maXJtKCkgaXMgb25seSBzdXBwb3J0ZWQgd2hlbiBjb21waWxlZCB3aXRoIGRpYWxvZwoJCXN1cHBvcnQsIHNlZSB8K2RpYWxvZ19jb258IGFuZCB8K2RpYWxvZ19ndWl8LgoKCQl7bXNnfSBpcyBkaXNwbGF5ZWQgaW4gYSB8ZGlhbG9nfCB3aXRoIHtjaG9pY2VzfSBhcyB0aGUKCQlhbHRlcm5hdGl2ZXMuICBXaGVuIHtjaG9pY2VzfSBpcyBtaXNzaW5nIG9yIGVtcHR5LCAiJk9LIiBpcwoJCXVzZWQgKGFuZCB0cmFuc2xhdGVkKS4KCQl7bXNnfSBpcyBhIFN0cmluZywgdXNlICdcbicgdG8gaW5jbHVkZSBhIG5ld2xpbmUuICBPbmx5IG9uCgkJc29tZSBzeXN0ZW1zIHRoZSBzdHJpbmcgaXMgd3JhcHBlZCB3aGVuIGl0IGRvZXNuJ3QgZml0LgoKCQl7Y2hvaWNlc30gaXMgYSBTdHJpbmcsIHdpdGggdGhlIGluZGl2aWR1YWwgY2hvaWNlcyBzZXBhcmF0ZWQKCQlieSAnXG4nLCBlLmcuID4KCQkJY29uZmlybSgiU2F2ZSBjaGFuZ2VzPyIsICImWWVzXG4mTm9cbiZDYW5jZWwiKQo8CQlUaGUgbGV0dGVyIGFmdGVyIHRoZSAnJicgaXMgdGhlIHNob3J0Y3V0IGtleSBmb3IgdGhhdCBjaG9pY2UuCgkJVGh1cyB5b3UgY2FuIHR5cGUgJ2MnIHRvIHNlbGVjdCAiQ2FuY2VsIi4gIFRoZSBzaG9ydGN1dCBkb2VzCgkJbm90IG5lZWQgdG8gYmUgdGhlIGZpcnN0IGxldHRlcjogPgoJCQljb25maXJtKCJmaWxlIGhhcyBiZWVuIG1vZGlmaWVkIiwgIiZTYXZlXG5TYXZlICZBbGwiKQo8CQlGb3IgdGhlIGNvbnNvbGUsIHRoZSBmaXJzdCBsZXR0ZXIgb2YgZWFjaCBjaG9pY2UgaXMgdXNlZCBhcwoJCXRoZSBkZWZhdWx0IHNob3J0Y3V0IGtleS4KCgkJVGhlIG9wdGlvbmFsIHtkZWZhdWx0fSBhcmd1bWVudCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBjaG9pY2UKCQl0aGF0IGlzIG1hZGUgaWYgdGhlIHVzZXIgaGl0cyA8Q1I+LiAgVXNlIDEgdG8gbWFrZSB0aGUgZmlyc3QKCQljaG9pY2UgdGhlIGRlZmF1bHQgb25lLiAgVXNlIDAgdG8gbm90IHNldCBhIGRlZmF1bHQuICBJZgoJCXtkZWZhdWx0fSBpcyBvbWl0dGVkLCAxIGlzIHVzZWQuCgoJCVRoZSBvcHRpb25hbCB7dHlwZX0gYXJndW1lbnQgZ2l2ZXMgdGhlIHR5cGUgb2YgZGlhbG9nLiAgVGhpcwoJCWlzIG9ubHkgdXNlZCBmb3IgdGhlIGljb24gb2YgdGhlIEdUSywgTWFjLCBNb3RpZiBhbmQgV2luMzIKCQlHVUkuICBJdCBjYW4gYmUgb25lIG9mIHRoZXNlIHZhbHVlczogIkVycm9yIiwgIlF1ZXN0aW9uIiwKCQkiSW5mbyIsICJXYXJuaW5nIiBvciAiR2VuZXJpYyIuICBPbmx5IHRoZSBmaXJzdCBjaGFyYWN0ZXIgaXMKCQlyZWxldmFudC4gIFdoZW4ge3R5cGV9IGlzIG9taXR0ZWQsICJHZW5lcmljIiBpcyB1c2VkLgoKCQlJZiB0aGUgdXNlciBhYm9ydHMgdGhlIGRpYWxvZyBieSBwcmVzc2luZyA8RXNjPiwgQ1RSTC1DLAoJCW9yIGFub3RoZXIgdmFsaWQgaW50ZXJydXB0IGtleSwgY29uZmlybSgpIHJldHVybnMgMC4KCgkJQW4gZXhhbXBsZTogPgogICA6bGV0IGNob2ljZSA9IGNvbmZpcm0oIldoYXQgZG8geW91IHdhbnQ/IiwgIiZBcHBsZXNcbiZPcmFuZ2VzXG4mQmFuYW5hcyIsIDIpCiAgIDppZiBjaG9pY2UgPT0gMAogICA6CWVjaG8gIm1ha2UgdXAgeW91ciBtaW5kISIKICAgOmVsc2VpZiBjaG9pY2UgPT0gMwogICA6CWVjaG8gInRhc3RlZnVsIgogICA6ZWxzZQogICA6CWVjaG8gIkkgcHJlZmVyIGJhbmFuYXMgbXlzZWxmLiIKICAgOmVuZGlmCjwJCUluIGEgR1VJIGRpYWxvZywgYnV0dG9ucyBhcmUgdXNlZC4gIFRoZSBsYXlvdXQgb2YgdGhlIGJ1dHRvbnMKCQlkZXBlbmRzIG9uIHRoZSAndicgZmxhZyBpbiAnZ3Vpb3B0aW9ucycuICBJZiBpdCBpcyBpbmNsdWRlZCwKCQl0aGUgYnV0dG9ucyBhcmUgYWx3YXlzIHB1dCB2ZXJ0aWNhbGx5LglPdGhlcndpc2UsICBjb25maXJtKCkKCQl0cmllcyB0byBwdXQgdGhlIGJ1dHRvbnMgaW4gb25lIGhvcml6b250YWwgbGluZS4gIElmIHRoZXkKCQlkb24ndCBmaXQsIGEgdmVydGljYWwgbGF5b3V0IGlzIHVzZWQgYW55d2F5LiAgRm9yIHNvbWUgc3lzdGVtcwoJCXRoZSBob3Jpem9udGFsIGxheW91dCBpcyBhbHdheXMgdXNlZC4KCmNoX2Nsb3NlKHtoYW5kbGV9KQkJCQkJCSpjaF9jbG9zZSgpKgoJCUNsb3NlIHtoYW5kbGV9LiAgU2VlIHxjaGFubmVsLWNsb3NlfC4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX2V2YWxleHByKHtoYW5kbGV9LCB7ZXhwcn0gWywge29wdGlvbnN9XSkJCQkqY2hfZXZhbGV4cHIoKSoKCQlTZW5kIHtleHByfSBvdmVyIHtoYW5kbGV9LiAgVGhlIHtleHByfSBpcyBlbmNvZGVkCgkJYWNjb3JkaW5nIHRvIHRoZSB0eXBlIG9mIGNoYW5uZWwuICBUaGUgZnVuY3Rpb24gY2Fubm90IGJlIHVzZWQKCQl3aXRoIGEgcmF3IGNoYW5uZWwuICBTZWUgfGNoYW5uZWwtdXNlfC4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgkJCQkJCQkJKkU5MTcqCgkJe29wdGlvbnN9IG11c3QgYmUgYSBEaWN0aW9uYXJ5LiAgSXQgbXVzdCBub3QgaGF2ZSBhICJjYWxsYmFjayIKCQllbnRyeS4gIEl0IGNhbiBoYXZlIGEgInRpbWVvdXQiIGVudHJ5IHRvIHNwZWNpZnkgdGhlIHRpbWVvdXQKCQlmb3IgdGhpcyBzcGVjaWZpYyByZXF1ZXN0LgoKCQljaF9ldmFsZXhwcigpIHdhaXRzIGZvciBhIHJlc3BvbnNlIGFuZCByZXR1cm5zIHRoZSBkZWNvZGVkCgkJZXhwcmVzc2lvbi4gIFdoZW4gdGhlcmUgaXMgYW4gZXJyb3Igb3IgdGltZW91dCBpdCByZXR1cm5zIGFuCgkJZW1wdHkgc3RyaW5nLgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NoYW5uZWx8IGZlYXR1cmV9CgpjaF9ldmFscmF3KHtoYW5kbGV9LCB7c3RyaW5nfSBbLCB7b3B0aW9uc31dKQkJKmNoX2V2YWxyYXcoKSoKCQlTZW5kIHtzdHJpbmd9IG92ZXIge2hhbmRsZX0uCgkJe2hhbmRsZX0gY2FuIGJlIENoYW5uZWwgb3IgYSBKb2IgdGhhdCBoYXMgYSBDaGFubmVsLgoKCQlXb3JrcyBsaWtlIHxjaF9ldmFsZXhwcigpfCwgYnV0IGRvZXMgbm90IGVuY29kZSB0aGUgcmVxdWVzdCBvcgoJCWRlY29kZSB0aGUgcmVzcG9uc2UuICBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmxlIGZvciB0aGUKCQljb3JyZWN0IGNvbnRlbnRzLiAgQWxzbyBkb2VzIG5vdCBhZGQgYSBuZXdsaW5lIGZvciBhIGNoYW5uZWwKCQlpbiBOTCBtb2RlLCB0aGUgY2FsbGVyIG11c3QgZG8gdGhhdC4gIFRoZSBOTCBpbiB0aGUgcmVzcG9uc2UKCQlpcyByZW1vdmVkLgoJCVNlZSB8Y2hhbm5lbC11c2V8LgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NoYW5uZWx8IGZlYXR1cmV9CgpjaF9nZXRidWZucih7aGFuZGxlfSwge3doYXR9KQkJCQkgKmNoX2dldGJ1Zm5yKCkqCgkJR2V0IHRoZSBidWZmZXIgbnVtYmVyIHRoYXQge2hhbmRsZX0gaXMgdXNpbmcgZm9yIHt3aGF0fS4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgkJe3doYXR9IGNhbiBiZSAiZXJyIiBmb3Igc3RkZXJyLCAib3V0IiBmb3Igc3Rkb3V0IG9yIGVtcHR5IGZvcgoJCXNvY2tldCBvdXRwdXQuCgkJUmV0dXJucyAtMSB3aGVuIHRoZXJlIGlzIG5vIGJ1ZmZlci4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NoYW5uZWx8IGZlYXR1cmV9CgpjaF9nZXRqb2Ioe2NoYW5uZWx9KQkJCQkJCSpjaF9nZXRqb2IoKSoKCQlHZXQgdGhlIEpvYiBhc3NvY2lhdGVkIHdpdGgge2NoYW5uZWx9LgoJCUlmIHRoZXJlIGlzIG5vIGpvYiBjYWxsaW5nIHxqb2Jfc3RhdHVzKCl8IG9uIHRoZSByZXR1cm5lZCBKb2IKCQl3aWxsIHJlc3VsdCBpbiAiZmFpbCIuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgYW5kCgkJfCtqb2J8IGZlYXR1cmVzfQoKY2hfaW5mbyh7aGFuZGxlfSkJCQkJCQkqY2hfaW5mbygpKgoJCVJldHVybnMgYSBEaWN0aW9uYXJ5IHdpdGggaW5mb3JtYXRpb24gYWJvdXQge2hhbmRsZX0uICBUaGUKCQlpdGVtcyBhcmU6CgkJICAgImlkIgkJICBudW1iZXIgb2YgdGhlIGNoYW5uZWwKCQkgICAic3RhdHVzIgkgICJvcGVuIiAoYW55IHBhcnQgaXMgb3Blbikgb3IgImNsb3NlZCIKCQlXaGVuIG9wZW5lZCB3aXRoIGNoX29wZW4oKToKCQkgICAiaG9zdG5hbWUiCSAgdGhlIGhvc3RuYW1lIG9mIHRoZSBhZGRyZXNzCgkJICAgInBvcnQiCSAgdGhlIHBvcnQgb2YgdGhlIGFkZHJlc3MKCQkgICAic29ja19zdGF0dXMiICAib3BlbiIgb3IgImNsb3NlZCIKCQkgICAic29ja19tb2RlIgkgICJOTCIsICJSQVciLCAiSlNPTiIgb3IgIkpTIgoJCSAgICJzb2NrX2lvIgkgICJzb2NrZXQiCgkJICAgInNvY2tfdGltZW91dCIgdGltZW91dCBpbiBtc2VjCgkJV2hlbiBvcGVuZWQgd2l0aCBqb2Jfc3RhcnQoKToKCQkgICAib3V0X3N0YXR1cyIJICAib3BlbiIgb3IgImNsb3NlZCIKCQkgICAib3V0X21vZGUiCSAgIk5MIiwgIlJBVyIsICJKU09OIiBvciAiSlMiCgkJICAgIm91dF9pbyIJICAibnVsbCIsICJwaXBlIiwgImZpbGUiIG9yICJidWZmZXIiCgkJICAgIm91dF90aW1lb3V0IiAgdGltZW91dCBpbiBtc2VjCgkJICAgImVycl9zdGF0dXMiCSAgIm9wZW4iIG9yICJjbG9zZWQiCgkJICAgImVycl9tb2RlIgkgICJOTCIsICJSQVciLCAiSlNPTiIgb3IgIkpTIgoJCSAgICJlcnJfaW8iCSAgIm91dCIsICJudWxsIiwgInBpcGUiLCAiZmlsZSIgb3IgImJ1ZmZlciIKCQkgICAiZXJyX3RpbWVvdXQiICB0aW1lb3V0IGluIG1zZWMKCQkgICAiaW5fc3RhdHVzIgkgICJvcGVuIiBvciAiY2xvc2VkIgoJCSAgICJpbl9tb2RlIgkgICJOTCIsICJSQVciLCAiSlNPTiIgb3IgIkpTIgoJCSAgICJpbl9pbyIJICAibnVsbCIsICJwaXBlIiwgImZpbGUiIG9yICJidWZmZXIiCgkJICAgImluX3RpbWVvdXQiCSAgdGltZW91dCBpbiBtc2VjCgpjaF9sb2coe21zZ30gWywge2hhbmRsZX1dKQkJCQkJKmNoX2xvZygpKgoJCVdyaXRlIHttc2d9IGluIHRoZSBjaGFubmVsIGxvZyBmaWxlLCBpZiBpdCB3YXMgb3BlbmVkIHdpdGgKCQl8Y2hfbG9nZmlsZSgpfC4KCQlXaGVuIHtoYW5kbGV9IGlzIHBhc3NlZCB0aGUgY2hhbm5lbCBudW1iZXIgaXMgdXNlZCBmb3IgdGhlCgkJbWVzc2FnZS4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuICBUaGUKCQlDaGFubmVsIG11c3Qgb3Blbi4KCmNoX2xvZ2ZpbGUoe2ZuYW1lfSBbLCB7bW9kZX1dKQkJCQkJKmNoX2xvZ2ZpbGUoKSoKCQlTdGFydCBsb2dnaW5nIGNoYW5uZWwgYWN0aXZpdHkgdG8ge2ZuYW1lfS4KCQlXaGVuIHtmbmFtZX0gaXMgYW4gZW1wdHkgc3RyaW5nOiBzdG9wIGxvZ2dpbmcuCgoJCVdoZW4ge21vZGV9IGlzIG9taXR0ZWQgb3IgImEiIGFwcGVuZCB0byB0aGUgZmlsZS4KCQlXaGVuIHttb2RlfSBpcyAidyIgc3RhcnQgd2l0aCBhbiBlbXB0eSBmaWxlLgoKCQlUaGUgZmlsZSBpcyBmbHVzaGVkIGFmdGVyIGV2ZXJ5IG1lc3NhZ2UsIG9uIFVuaXggeW91IGNhbiB1c2UKCQkidGFpbCAtZiIgdG8gc2VlIHdoYXQgaXMgZ29pbmcgb24gaW4gcmVhbCB0aW1lLgoKCmNoX29wZW4oe2FkZHJlc3N9IFssIHtvcHRpb25zfV0pCQkJCSpjaF9vcGVuKCkqCgkJT3BlbiBhIGNoYW5uZWwgdG8ge2FkZHJlc3N9LiAgU2VlIHxjaGFubmVsfC4KCQlSZXR1cm5zIGEgQ2hhbm5lbC4gIFVzZSB8Y2hfc3RhdHVzKCl8IHRvIGNoZWNrIGZvciBmYWlsdXJlLgoKCQl7YWRkcmVzc30gaGFzIHRoZSBmb3JtICJob3N0bmFtZTpwb3J0IiwgZS5nLiwKCQkibG9jYWxob3N0Ojg3NjUiLgoKCQlJZiB7b3B0aW9uc30gaXMgZ2l2ZW4gaXQgbXVzdCBiZSBhIHxEaWN0aW9uYXJ5fC4KCQlTZWUgfGNoYW5uZWwtb3Blbi1vcHRpb25zfC4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBmZWF0dXJlfQoKY2hfcmVhZCh7aGFuZGxlfSBbLCB7b3B0aW9uc31dKQkJCQkJKmNoX3JlYWQoKSoKCQlSZWFkIGZyb20ge2hhbmRsZX0gYW5kIHJldHVybiB0aGUgcmVjZWl2ZWQgbWVzc2FnZS4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgkJU2VlIHxjaGFubmVsLW1vcmV8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX3JlYWRyYXcoe2hhbmRsZX0gWywge29wdGlvbnN9XSkJCQkqY2hfcmVhZHJhdygpKgoJCUxpa2UgY2hfcmVhZCgpIGJ1dCBmb3IgYSBKUyBhbmQgSlNPTiBjaGFubmVsIGRvZXMgbm90IGRlY29kZQoJCXRoZSBtZXNzYWdlLiAgU2VlIHxjaGFubmVsLW1vcmV8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX3NlbmRleHByKHtoYW5kbGV9LCB7ZXhwcn0gWywge29wdGlvbnN9XSkJCQkqY2hfc2VuZGV4cHIoKSoKCQlTZW5kIHtleHByfSBvdmVyIHtoYW5kbGV9LiAgVGhlIHtleHByfSBpcyBlbmNvZGVkCgkJYWNjb3JkaW5nIHRvIHRoZSB0eXBlIG9mIGNoYW5uZWwuICBUaGUgZnVuY3Rpb24gY2Fubm90IGJlIHVzZWQKCQl3aXRoIGEgcmF3IGNoYW5uZWwuCgkJU2VlIHxjaGFubmVsLXVzZXwuCQkJCSpFOTEyKgoJCXtoYW5kbGV9IGNhbiBiZSBDaGFubmVsIG9yIGEgSm9iIHRoYXQgaGFzIGEgQ2hhbm5lbC4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBmZWF0dXJlfQoKY2hfc2VuZHJhdyh7aGFuZGxlfSwge3N0cmluZ30gWywge29wdGlvbnN9XSkJCSpjaF9zZW5kcmF3KCkqCgkJU2VuZCB7c3RyaW5nfSBvdmVyIHtoYW5kbGV9LgoJCVdvcmtzIGxpa2UgfGNoX3NlbmRleHByKCl8LCBidXQgZG9lcyBub3QgZW5jb2RlIHRoZSByZXF1ZXN0IG9yCgkJZGVjb2RlIHRoZSByZXNwb25zZS4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yIHRoZQoJCWNvcnJlY3QgY29udGVudHMuICBBbHNvIGRvZXMgbm90IGFkZCBhIG5ld2xpbmUgZm9yIGEgY2hhbm5lbAoJCWluIE5MIG1vZGUsIHRoZSBjYWxsZXIgbXVzdCBkbyB0aGF0LiAgVGhlIE5MIGluIHRoZSByZXNwb25zZQoJCWlzIHJlbW92ZWQuCgkJU2VlIHxjaGFubmVsLXVzZXwuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX3NldG9wdGlvbnMoe2hhbmRsZX0sIHtvcHRpb25zfSkJCQkqY2hfc2V0b3B0aW9ucygpKgoJCVNldCBvcHRpb25zIG9uIHtoYW5kbGV9OgoJCQkiY2FsbGJhY2siCXRoZSBjaGFubmVsIGNhbGxiYWNrCgkJCSJ0aW1lb3V0IglkZWZhdWx0IHJlYWQgdGltZW91dCBpbiBtc2VjCgkJCSJtb2RlIgkJbW9kZSBmb3IgdGhlIHdob2xlIGNoYW5uZWwKCQlTZWUgfGNoX29wZW4oKXwgZm9yIG1vcmUgZXhwbGFuYXRpb24uCgkJe2hhbmRsZX0gY2FuIGJlIENoYW5uZWwgb3IgYSBKb2IgdGhhdCBoYXMgYSBDaGFubmVsLgoKCQlOb3RlIHRoYXQgY2hhbmdpbmcgdGhlIG1vZGUgbWF5IGNhdXNlIHF1ZXVlZCBtZXNzYWdlcyB0byBiZQoJCWxvc3QuCgoJCVRoZXNlIG9wdGlvbnMgY2Fubm90IGJlIGNoYW5nZWQ6CgkJCSJ3YWl0dGltZSIJb25seSBhcHBsaWVzIHRvICJjaF9vcGVuKCl8CgpjaF9zdGF0dXMoe2hhbmRsZX0pCQkJCQkJKmNoX3N0YXR1cygpKgoJCVJldHVybiB0aGUgc3RhdHVzIG9mIHtoYW5kbGV9OgoJCQkiZmFpbCIJCWZhaWxlZCB0byBvcGVuIHRoZSBjaGFubmVsCgkJCSJvcGVuIgkJY2hhbm5lbCBjYW4gYmUgdXNlZAoJCQkiYnVmZmVyZWQiCWNoYW5uZWwgY2FuIGJlIHJlYWQsIG5vdCB3cml0dGVuIHRvCgkJCSJjbG9zZWQiCWNoYW5uZWwgY2FuIG5vdCBiZSB1c2VkCgkJe2hhbmRsZX0gY2FuIGJlIENoYW5uZWwgb3IgYSBKb2IgdGhhdCBoYXMgYSBDaGFubmVsLgoJCSJidWZmZXJlZCIgaXMgdXNlZCB3aGVuIHRoZSBjaGFubmVsIHdhcyBjbG9zZWQgYnV0IHRoZXJlIGlzCgkJc3RpbGwgZGF0YSB0aGF0IGNhbiBiZSBvYnRhaW5lZCB3aXRoIHxjaF9yZWFkKCl8LgoKCQkJCQkJCSpjb3B5KCkqCmNvcHkoe2V4cHJ9KQlNYWtlIGEgY29weSBvZiB7ZXhwcn0uCUZvciBOdW1iZXJzIGFuZCBTdHJpbmdzIHRoaXMgaXNuJ3QKCQlkaWZmZXJlbnQgZnJvbSB1c2luZyB7ZXhwcn0gZGlyZWN0bHkuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgYSBzaGFsbG93IGNvcHkgaXMgY3JlYXRlZC4gIFRoaXMgbWVhbnMKCQl0aGF0IHRoZSBvcmlnaW5hbCB8TGlzdHwgY2FuIGJlIGNoYW5nZWQgd2l0aG91dCBjaGFuZ2luZyB0aGUKCQljb3B5LCBhbmQgdmljZSB2ZXJzYS4gIEJ1dCB0aGUgaXRlbXMgYXJlIGlkZW50aWNhbCwgdGh1cwoJCWNoYW5naW5nIGFuIGl0ZW0gY2hhbmdlcyB0aGUgY29udGVudHMgb2YgYm90aCB8TGlzdHN8LgoJCUEgfERpY3Rpb25hcnl8IGlzIGNvcGllZCBpbiBhIHNpbWlsYXIgd2F5IGFzIGEgfExpc3R8LgoJCUFsc28gc2VlIHxkZWVwY29weSgpfC4KCmNvcyh7ZXhwcn0pCQkJCQkJKmNvcygpKgoJCVJldHVybiB0aGUgY29zaW5lIG9mIHtleHByfSwgbWVhc3VyZWQgaW4gcmFkaWFucywgYXMgYSB8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGNvcygxMDApCjwJCQkwLjg2MjMxOSA+CgkJCTplY2hvIGNvcygtNC4wMSkKPAkJCS0wLjY0NjA0MwoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKY29zaCh7ZXhwcn0pCQkJCQkJKmNvc2goKSoKCQlSZXR1cm4gdGhlIGh5cGVyYm9saWMgY29zaW5lIG9mIHtleHByfSBhcyBhIHxGbG9hdHwgaW4gdGhlIHJhbmdlCgkJWzEsIGluZl0uCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gY29zaCgwLjUpCjwJCQkxLjEyNzYyNiA+CgkJCTplY2hvIGNvc2goLTAuNSkKPAkJCS0xLjEyNzYyNgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoJCQpjb3VudCh7Y29tcH0sIHtleHByfSBbLCB7aWN9IFssIHtzdGFydH1dXSkJCQkqY291bnQoKSoKCQlSZXR1cm4gdGhlIG51bWJlciBvZiB0aW1lcyBhbiBpdGVtIHdpdGggdmFsdWUge2V4cHJ9IGFwcGVhcnMKCQlpbiB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IHtjb21wfS4KCQlJZiB7c3RhcnR9IGlzIGdpdmVuIHRoZW4gc3RhcnQgd2l0aCB0aGUgaXRlbSB3aXRoIHRoaXMgaW5kZXguCgkJe3N0YXJ0fSBjYW4gb25seSBiZSB1c2VkIHdpdGggYSB8TGlzdHwuCgkJV2hlbiB7aWN9IGlzIGdpdmVuIGFuZCBpdCdzIG5vbi16ZXJvIHRoZW4gY2FzZSBpcyBpZ25vcmVkLgoKCgkJCQkJCQkqY3Njb3BlX2Nvbm5lY3Rpb24oKSoKY3Njb3BlX2Nvbm5lY3Rpb24oW3tudW19ICwge2RicGF0aH0gWywge3ByZXBlbmR9XV0pCgkJQ2hlY2tzIGZvciB0aGUgZXhpc3RlbmNlIG9mIGEgfGNzY29wZXwgY29ubmVjdGlvbi4gIElmIG5vCgkJcGFyYW1ldGVycyBhcmUgc3BlY2lmaWVkLCB0aGVuIHRoZSBmdW5jdGlvbiByZXR1cm5zOgoJCQkwLCBpZiBjc2NvcGUgd2FzIG5vdCBhdmFpbGFibGUgKG5vdCBjb21waWxlZCBpbiksIG9yCgkJCSAgIGlmIHRoZXJlIGFyZSBubyBjc2NvcGUgY29ubmVjdGlvbnM7CgkJCTEsIGlmIHRoZXJlIGlzIGF0IGxlYXN0IG9uZSBjc2NvcGUgY29ubmVjdGlvbi4KCgkJSWYgcGFyYW1ldGVycyBhcmUgc3BlY2lmaWVkLCB0aGVuIHRoZSB2YWx1ZSBvZiB7bnVtfQoJCWRldGVybWluZXMgaG93IGV4aXN0ZW5jZSBvZiBhIGNzY29wZSBjb25uZWN0aW9uIGlzIGNoZWNrZWQ6CgoJCXtudW19CURlc2NyaXB0aW9uIG9mIGV4aXN0ZW5jZSBjaGVjawoJCS0tLS0tCS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoJCTAJU2FtZSBhcyBubyBwYXJhbWV0ZXJzIChlLmcuLCAiY3Njb3BlX2Nvbm5lY3Rpb24oKSIpLgoJCTEJSWdub3JlIHtwcmVwZW5kfSwgYW5kIHVzZSBwYXJ0aWFsIHN0cmluZyBtYXRjaGVzIGZvcgoJCQl7ZGJwYXRofS4KCQkyCUlnbm9yZSB7cHJlcGVuZH0sIGFuZCB1c2UgZXhhY3Qgc3RyaW5nIG1hdGNoZXMgZm9yCgkJCXtkYnBhdGh9LgoJCTMJVXNlIHtwcmVwZW5kfSwgdXNlIHBhcnRpYWwgc3RyaW5nIG1hdGNoZXMgZm9yIGJvdGgKCQkJe2RicGF0aH0gYW5kIHtwcmVwZW5kfS4KCQk0CVVzZSB7cHJlcGVuZH0sIHVzZSBleGFjdCBzdHJpbmcgbWF0Y2hlcyBmb3IgYm90aAoJCQl7ZGJwYXRofSBhbmQge3ByZXBlbmR9LgoKCQlOb3RlOiBBbGwgc3RyaW5nIGNvbXBhcmlzb25zIGFyZSBjYXNlIHNlbnNpdGl2ZSEKCgkJRXhhbXBsZXMuICBTdXBwb3NlIHdlIGhhZCB0aGUgZm9sbG93aW5nIChmcm9tICI6Y3Mgc2hvdyIpOiA+CgogICMgcGlkICAgIGRhdGFiYXNlIG5hbWUJCQlwcmVwZW5kIHBhdGgKICAwIDI3NjY0ICBjc2NvcGUub3V0CQkJCS91c3IvbG9jYWwKPAoJCUludm9jYXRpb24JCQkJCVJldHVybiBWYWwgfgoJCS0tLS0tLS0tLS0JCQkJCS0tLS0tLS0tLS0gPgoJCWNzY29wZV9jb25uZWN0aW9uKCkJCQkJCTEKCQljc2NvcGVfY29ubmVjdGlvbigxLCAib3V0IikJCQkJMQoJCWNzY29wZV9jb25uZWN0aW9uKDIsICJvdXQiKQkJCQkwCgkJY3Njb3BlX2Nvbm5lY3Rpb24oMywgIm91dCIpCQkJCTAKCQljc2NvcGVfY29ubmVjdGlvbigzLCAib3V0IiwgImxvY2FsIikJCQkxCgkJY3Njb3BlX2Nvbm5lY3Rpb24oNCwgIm91dCIpCQkJCTAKCQljc2NvcGVfY29ubmVjdGlvbig0LCAib3V0IiwgImxvY2FsIikJCQkwCgkJY3Njb3BlX2Nvbm5lY3Rpb24oNCwgImNzY29wZS5vdXQiLCAiL3Vzci9sb2NhbCIpCTEKPApjdXJzb3Ioe2xudW19LCB7Y29sfSBbLCB7b2ZmfV0pCQkJCSpjdXJzb3IoKSoKY3Vyc29yKHtsaXN0fSkKCQlQb3NpdGlvbnMgdGhlIGN1cnNvciBhdCB0aGUgY29sdW1uIChieXRlIGNvdW50KSB7Y29sfSBpbiB0aGUKCQlsaW5lIHtsbnVtfS4gIFRoZSBmaXJzdCBjb2x1bW4gaXMgb25lLgoKCQlXaGVuIHRoZXJlIGlzIG9uZSBhcmd1bWVudCB7bGlzdH0gdGhpcyBpcyB1c2VkIGFzIGEgfExpc3R8CgkJd2l0aCB0d28sIHRocmVlIG9yIGZvdXIgaXRlbToKCQkJW3tsbnVtfSwge2NvbH1dCgkJCVt7bG51bX0sIHtjb2x9LCB7b2ZmfV0KCQkJW3tsbnVtfSwge2NvbH0sIHtvZmZ9LCB7Y3Vyc3dhbnR9XQoJCVRoaXMgaXMgbGlrZSB0aGUgcmV0dXJuIHZhbHVlIG9mIHxnZXRwb3MoKXwgb3IgfGdldGN1cnBvcygpfCwKCQlidXQgd2l0aG91dCB0aGUgZmlyc3QgaXRlbS4KCgkJRG9lcyBub3QgY2hhbmdlIHRoZSBqdW1wbGlzdC4KCQlJZiB7bG51bX0gaXMgZ3JlYXRlciB0aGFuIHRoZSBudW1iZXIgb2YgbGluZXMgaW4gdGhlIGJ1ZmZlciwKCQl0aGUgY3Vyc29yIHdpbGwgYmUgcG9zaXRpb25lZCBhdCB0aGUgbGFzdCBsaW5lIGluIHRoZSBidWZmZXIuCgkJSWYge2xudW19IGlzIHplcm8sIHRoZSBjdXJzb3Igd2lsbCBzdGF5IGluIHRoZSBjdXJyZW50IGxpbmUuCgkJSWYge2NvbH0gaXMgZ3JlYXRlciB0aGFuIHRoZSBudW1iZXIgb2YgYnl0ZXMgaW4gdGhlIGxpbmUsCgkJdGhlIGN1cnNvciB3aWxsIGJlIHBvc2l0aW9uZWQgYXQgdGhlIGxhc3QgY2hhcmFjdGVyIGluIHRoZQoJCWxpbmUuCgkJSWYge2NvbH0gaXMgemVybywgdGhlIGN1cnNvciB3aWxsIHN0YXkgaW4gdGhlIGN1cnJlbnQgY29sdW1uLgoJCUlmIHtjdXJzd2FudH0gaXMgZ2l2ZW4gaXQgaXMgdXNlZCB0byBzZXQgdGhlIHByZWZlcnJlZCBjb2x1bW4KCQlmb3IgdmVydGljYWwgbW92ZW1lbnQuICBPdGhlcndpc2Uge2NvbH0gaXMgdXNlZC4KCgkJV2hlbiAndmlydHVhbGVkaXQnIGlzIHVzZWQge29mZn0gc3BlY2lmaWVzIHRoZSBvZmZzZXQgaW4KCQlzY3JlZW4gY29sdW1ucyBmcm9tIHRoZSBzdGFydCBvZiB0aGUgY2hhcmFjdGVyLiAgRS5nLiwgYQoJCXBvc2l0aW9uIHdpdGhpbiBhIDxUYWI+IG9yIGFmdGVyIHRoZSBsYXN0IGNoYXJhY3Rlci4KCQlSZXR1cm5zIDAgd2hlbiB0aGUgcG9zaXRpb24gY291bGQgYmUgc2V0LCAtMSBvdGhlcndpc2UuCgoKZGVlcGNvcHkoe2V4cHJ9Wywge25vcmVmfV0pCQkJCSpkZWVwY29weSgpKiAqRTY5OCoKCQlNYWtlIGEgY29weSBvZiB7ZXhwcn0uCUZvciBOdW1iZXJzIGFuZCBTdHJpbmdzIHRoaXMgaXNuJ3QKCQlkaWZmZXJlbnQgZnJvbSB1c2luZyB7ZXhwcn0gZGlyZWN0bHkuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgYSBmdWxsIGNvcHkgaXMgY3JlYXRlZC4gIFRoaXMgbWVhbnMKCQl0aGF0IHRoZSBvcmlnaW5hbCB8TGlzdHwgY2FuIGJlIGNoYW5nZWQgd2l0aG91dCBjaGFuZ2luZyB0aGUKCQljb3B5LCBhbmQgdmljZSB2ZXJzYS4gIFdoZW4gYW4gaXRlbSBpcyBhIHxMaXN0fCBvcgoJCXxEaWN0aW9uYXJ5fCwgYSBjb3B5IGZvciBpdCBpcyBtYWRlLCByZWN1cnNpdmVseS4gIFRodXMKCQljaGFuZ2luZyBhbiBpdGVtIGluIHRoZSBjb3B5IGRvZXMgbm90IGNoYW5nZSB0aGUgY29udGVudHMgb2YKCQl0aGUgb3JpZ2luYWwgfExpc3R8LgoJCUEgfERpY3Rpb25hcnl8IGlzIGNvcGllZCBpbiBhIHNpbWlsYXIgd2F5IGFzIGEgfExpc3R8LgoJCVdoZW4ge25vcmVmfSBpcyBvbWl0dGVkIG9yIHplcm8gYSBjb250YWluZWQgfExpc3R8IG9yCgkJfERpY3Rpb25hcnl8IGlzIG9ubHkgY29waWVkIG9uY2UuICBBbGwgcmVmZXJlbmNlcyBwb2ludCB0bwoJCXRoaXMgc2luZ2xlIGNvcHkuICBXaXRoIHtub3JlZn0gc2V0IHRvIDEgZXZlcnkgb2NjdXJyZW5jZSBvZiBhCgkJfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCByZXN1bHRzIGluIGEgbmV3IGNvcHkuICBUaGlzIGFsc28gbWVhbnMKCQl0aGF0IGEgY3ljbGljIHJlZmVyZW5jZSBjYXVzZXMgZGVlcGNvcHkoKSB0byBmYWlsLgoJCQkJCQkJCSpFNzI0KgoJCU5lc3RpbmcgaXMgcG9zc2libGUgdXAgdG8gMTAwIGxldmVscy4gIFdoZW4gdGhlcmUgaXMgYW4gaXRlbQoJCXRoYXQgcmVmZXJzIGJhY2sgdG8gYSBoaWdoZXIgbGV2ZWwgbWFraW5nIGEgZGVlcCBjb3B5IHdpdGgKCQl7bm9yZWZ9IHNldCB0byAxIHdpbGwgZmFpbC4KCQlBbHNvIHNlZSB8Y29weSgpfC4KCmRlbGV0ZSh7Zm5hbWV9IFssIHtmbGFnc31dKQkJCQkJKmRlbGV0ZSgpKgoJCVdpdGhvdXQge2ZsYWdzfSBvciB3aXRoIHtmbGFnc30gZW1wdHk6IERlbGV0ZXMgdGhlIGZpbGUgYnkgdGhlCgkJbmFtZSB7Zm5hbWV9LiAgVGhpcyBhbHNvIHdvcmtzIHdoZW4ge2ZuYW1lfSBpcyBhIHN5bWJvbGljIGxpbmsuCgoJCVdoZW4ge2ZsYWdzfSBpcyAiZCI6IERlbGV0ZXMgdGhlIGRpcmVjdG9yeSBieSB0aGUgbmFtZQoJCXtmbmFtZX0uICBUaGlzIGZhaWxzIHdoZW4gZGlyZWN0b3J5IHtmbmFtZX0gaXMgbm90IGVtcHR5LgoJCQoJCVdoZW4ge2ZsYWdzfSBpcyAicmYiOiBEZWxldGVzIHRoZSBkaXJlY3RvcnkgYnkgdGhlIG5hbWUKCQl7Zm5hbWV9IGFuZCBldmVyeXRoaW5nIGluIGl0LCByZWN1cnNpdmVseS4gIEJFIENBUkVGVUwhCgkJQSBzeW1ib2xpYyBsaW5rIGl0c2VsZiBpcyBkZWxldGVkLCBub3Qgd2hhdCBpdCBwb2ludHMgdG8uCgkJCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMCBpZiB0aGUgZGVsZXRlIG9wZXJhdGlvbiB3YXMKCQlzdWNjZXNzZnVsIGFuZCAtMSB3aGVuIHRoZSBkZWxldGlvbiBmYWlsZWQgb3IgcGFydGx5IGZhaWxlZC4KCgkJVXNlIHxyZW1vdmUoKXwgdG8gZGVsZXRlIGFuIGl0ZW0gZnJvbSBhIHxMaXN0fC4KCQlUbyBkZWxldGUgYSBsaW5lIGZyb20gdGhlIGJ1ZmZlciB1c2UgfDpkZWxldGV8LiAgVXNlIHw6ZXhlfAoJCXdoZW4gdGhlIGxpbmUgbnVtYmVyIGlzIGluIGEgdmFyaWFibGUuCgoJCQkJCQkJKmRpZF9maWxldHlwZSgpKgpkaWRfZmlsZXR5cGUoKQlSZXR1cm5zIG5vbi16ZXJvIHdoZW4gYXV0b2NvbW1hbmRzIGFyZSBiZWluZyBleGVjdXRlZCBhbmQgdGhlCgkJRmlsZVR5cGUgZXZlbnQgaGFzIGJlZW4gdHJpZ2dlcmVkIGF0IGxlYXN0IG9uY2UuICBDYW4gYmUgdXNlZAoJCXRvIGF2b2lkIHRyaWdnZXJpbmcgdGhlIEZpbGVUeXBlIGV2ZW50IGFnYWluIGluIHRoZSBzY3JpcHRzCgkJdGhhdCBkZXRlY3QgdGhlIGZpbGUgdHlwZS4gfEZpbGVUeXBlfAoJCVdoZW4gZWRpdGluZyBhbm90aGVyIGZpbGUsIHRoZSBjb3VudGVyIGlzIHJlc2V0LCB0aHVzIHRoaXMKCQlyZWFsbHkgY2hlY2tzIGlmIHRoZSBGaWxlVHlwZSBldmVudCBoYXMgYmVlbiB0cmlnZ2VyZWQgZm9yIHRoZQoJCWN1cnJlbnQgYnVmZmVyLiAgVGhpcyBhbGxvd3MgYW4gYXV0b2NvbW1hbmQgdGhhdCBzdGFydHMKCQllZGl0aW5nIGFub3RoZXIgYnVmZmVyIHRvIHNldCAnZmlsZXR5cGUnIGFuZCBsb2FkIGEgc3ludGF4CgkJZmlsZS4KCmRpZmZfZmlsbGVyKHtsbnVtfSkJCQkJCSpkaWZmX2ZpbGxlcigpKgoJCVJldHVybnMgdGhlIG51bWJlciBvZiBmaWxsZXIgbGluZXMgYWJvdmUgbGluZSB7bG51bX0uCgkJVGhlc2UgYXJlIHRoZSBsaW5lcyB0aGF0IHdlcmUgaW5zZXJ0ZWQgYXQgdGhpcyBwb2ludCBpbgoJCWFub3RoZXIgZGlmZidlZCB3aW5kb3cuICBUaGVzZSBmaWxsZXIgbGluZXMgYXJlIHNob3duIGluIHRoZQoJCWRpc3BsYXkgYnV0IGRvbid0IGV4aXN0IGluIHRoZSBidWZmZXIuCgkJe2xudW19IGlzIHVzZWQgbGlrZSB3aXRoIHxnZXRsaW5lKCl8LiAgVGh1cyAiLiIgaXMgdGhlIGN1cnJlbnQKCQlsaW5lLCAiJ20iIG1hcmsgbSwgZXRjLgoJCVJldHVybnMgMCBpZiB0aGUgY3VycmVudCB3aW5kb3cgaXMgbm90IGluIGRpZmYgbW9kZS4KCmRpZmZfaGxJRCh7bG51bX0sIHtjb2x9KQkJCQkqZGlmZl9obElEKCkqCgkJUmV0dXJucyB0aGUgaGlnaGxpZ2h0IElEIGZvciBkaWZmIG1vZGUgYXQgbGluZSB7bG51bX0gY29sdW1uCgkJe2NvbH0gKGJ5dGUgaW5kZXgpLiAgV2hlbiB0aGUgY3VycmVudCBsaW5lIGRvZXMgbm90IGhhdmUgYQoJCWRpZmYgY2hhbmdlIHplcm8gaXMgcmV0dXJuZWQuCgkJe2xudW19IGlzIHVzZWQgbGlrZSB3aXRoIHxnZXRsaW5lKCl8LiAgVGh1cyAiLiIgaXMgdGhlIGN1cnJlbnQKCQlsaW5lLCAiJ20iIG1hcmsgbSwgZXRjLgoJCXtjb2x9IGlzIDEgZm9yIHRoZSBsZWZ0bW9zdCBjb2x1bW4sIHtsbnVtfSBpcyAxIGZvciB0aGUgZmlyc3QKCQlsaW5lLgoJCVRoZSBoaWdobGlnaHQgSUQgY2FuIGJlIHVzZWQgd2l0aCB8c3luSURhdHRyKCl8IHRvIG9idGFpbgoJCXN5bnRheCBpbmZvcm1hdGlvbiBhYm91dCB0aGUgaGlnaGxpZ2h0aW5nLgoKCQkJCQkqZGlzYWJsZV9jaGFyX2F2YWlsX2Zvcl90ZXN0aW5nKCkqCmRpc2FibGVfY2hhcl9hdmFpbF9mb3JfdGVzdGluZyh7ZXhwcn0pCgkJV2hlbiB7ZXhwcn0gaXMgMSB0aGUgaW50ZXJuYWwgY2hhcl9hdmFpbCgpIGZ1bmN0aW9uIHdpbGwKCQlyZXR1cm4gRkFMU0UuICBXaGVuIHtleHByfSBpcyAwIHRoZSBjaGFyX2F2YWlsKCkgZnVuY3Rpb24gd2lsbAoJCWZ1bmN0aW9uIG5vcm1hbGx5LgoJCU9ubHkgdXNlIHRoaXMgZm9yIGEgdGVzdCB3aGVyZSB0eXBlYWhlYWQgY2F1c2VzIHRoZSB0ZXN0IG5vdAoJCXRvIHdvcmsuICBFLmcuLCB0byB0cmlnZ2VyIHRoZSBDdXJzb3JNb3ZlZEkgYXV0b2NvbW1hbmQgZXZlbnQuCgplbXB0eSh7ZXhwcn0pCQkJCQkJKmVtcHR5KCkqCgkJUmV0dXJuIHRoZSBOdW1iZXIgMSBpZiB7ZXhwcn0gaXMgZW1wdHksIHplcm8gb3RoZXJ3aXNlLgoJCS0gQSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IGlzIGVtcHR5IHdoZW4gaXQgZG9lcyBub3QgaGF2ZSBhbnkKCQkgIGl0ZW1zLgoJCS0gQSBOdW1iZXIgYW5kIEZsb2F0IGlzIGVtcHR5IHdoZW4gaXRzIHZhbHVlIGlzIHplcm8uCgkJLSB8djpmYWxzZXwsIHx2Om5vbmV8IGFuZCB8djpudWxsfCBhcmUgZW1wdHksIHx2OnRydWV8IGlzIG5vdC4KCQktIEEgSm9iIGlzIGVtcHR5IHdoZW4gaXQgZmFpbGVkIHRvIHN0YXJ0LgoJCS0gQSBDaGFubmVsIGlzIGVtcHR5IHdoZW4gaXQgaXMgY2xvc2VkLgoKCQlGb3IgYSBsb25nIHxMaXN0fCB0aGlzIGlzIG11Y2ggZmFzdGVyIHRoYW4gY29tcGFyaW5nIHRoZQoJCWxlbmd0aCB3aXRoIHplcm8uCgplc2NhcGUoe3N0cmluZ30sIHtjaGFyc30pCQkJCSplc2NhcGUoKSoKCQlFc2NhcGUgdGhlIGNoYXJhY3RlcnMgaW4ge2NoYXJzfSB0aGF0IG9jY3VyIGluIHtzdHJpbmd9IHdpdGggYQoJCWJhY2tzbGFzaC4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gZXNjYXBlKCdjOlxwcm9ncmFtIGZpbGVzXHZpbScsICcgXCcpCjwJCXJlc3VsdHMgaW46ID4KCQkJYzpcXHByb2dyYW1cIGZpbGVzXFx2aW0KPAkJQWxzbyBzZWUgfHNoZWxsZXNjYXBlKCl8LgoKCQkJCQkJCSpldmFsKCkqCmV2YWwoe3N0cmluZ30pCUV2YWx1YXRlIHtzdHJpbmd9IGFuZCByZXR1cm4gdGhlIHJlc3VsdC4gIEVzcGVjaWFsbHkgdXNlZnVsIHRvCgkJdHVybiB0aGUgcmVzdWx0IG9mIHxzdHJpbmcoKXwgYmFjayBpbnRvIHRoZSBvcmlnaW5hbCB2YWx1ZS4KCQlUaGlzIHdvcmtzIGZvciBOdW1iZXJzLCBGbG9hdHMsIFN0cmluZ3MgYW5kIGNvbXBvc2l0ZXMgb2YKCQl0aGVtLiAgQWxzbyB3b3JrcyBmb3IgfEZ1bmNyZWZ8cyB0aGF0IHJlZmVyIHRvIGV4aXN0aW5nCgkJZnVuY3Rpb25zLgoKZXZlbnRoYW5kbGVyKCkJCQkJCQkqZXZlbnRoYW5kbGVyKCkqCgkJUmV0dXJucyAxIHdoZW4gaW5zaWRlIGFuIGV2ZW50IGhhbmRsZXIuICBUaGF0IGlzIHRoYXQgVmltIGdvdAoJCWludGVycnVwdGVkIHdoaWxlIHdhaXRpbmcgZm9yIHRoZSB1c2VyIHRvIHR5cGUgYSBjaGFyYWN0ZXIsCgkJZS5nLiwgd2hlbiBkcm9wcGluZyBhIGZpbGUgb24gVmltLiAgVGhpcyBtZWFucyBpbnRlcmFjdGl2ZQoJCWNvbW1hbmRzIGNhbm5vdCBiZSB1c2VkLiAgT3RoZXJ3aXNlIHplcm8gaXMgcmV0dXJuZWQuCgpleGVjdXRhYmxlKHtleHByfSkJCQkJCSpleGVjdXRhYmxlKCkqCgkJVGhpcyBmdW5jdGlvbiBjaGVja3MgaWYgYW4gZXhlY3V0YWJsZSB3aXRoIHRoZSBuYW1lIHtleHByfQoJCWV4aXN0cy4gIHtleHByfSBtdXN0IGJlIHRoZSBuYW1lIG9mIHRoZSBwcm9ncmFtIHdpdGhvdXQgYW55CgkJYXJndW1lbnRzLgoJCWV4ZWN1dGFibGUoKSB1c2VzIHRoZSB2YWx1ZSBvZiAkUEFUSCBhbmQvb3IgdGhlIG5vcm1hbAoJCXNlYXJjaHBhdGggZm9yIHByb2dyYW1zLgkJKlBBVEhFWFQqCgkJT24gTVMtRE9TIGFuZCBNUy1XaW5kb3dzIHRoZSAiLmV4ZSIsICIuYmF0IiwgZXRjLiBjYW4KCQlvcHRpb25hbGx5IGJlIGluY2x1ZGVkLiAgVGhlbiB0aGUgZXh0ZW5zaW9ucyBpbiAkUEFUSEVYVCBhcmUKCQl0cmllZC4JVGh1cyBpZiAiZm9vLmV4ZSIgZG9lcyBub3QgZXhpc3QsICJmb28uZXhlLmJhdCIgY2FuIGJlCgkJZm91bmQuCUlmICRQQVRIRVhUIGlzIG5vdCBzZXQgdGhlbiAiLmV4ZTsuY29tOy5iYXQ7LmNtZCIgaXMKCQl1c2VkLiAgQSBkb3QgYnkgaXRzZWxmIGNhbiBiZSB1c2VkIGluICRQQVRIRVhUIHRvIHRyeSB1c2luZwoJCXRoZSBuYW1lIHdpdGhvdXQgYW4gZXh0ZW5zaW9uLglXaGVuICdzaGVsbCcgbG9va3MgbGlrZSBhCgkJVW5peCBzaGVsbCwgdGhlbiB0aGUgbmFtZSBpcyBhbHNvIHRyaWVkIHdpdGhvdXQgYWRkaW5nIGFuCgkJZXh0ZW5zaW9uLgoJCU9uIE1TLURPUyBhbmQgTVMtV2luZG93cyBpdCBvbmx5IGNoZWNrcyBpZiB0aGUgZmlsZSBleGlzdHMgYW5kCgkJaXMgbm90IGEgZGlyZWN0b3J5LCBub3QgaWYgaXQncyByZWFsbHkgZXhlY3V0YWJsZS4KCQlPbiBNUy1XaW5kb3dzIGFuIGV4ZWN1dGFibGUgaW4gdGhlIHNhbWUgZGlyZWN0b3J5IGFzIFZpbSBpcwoJCWFsd2F5cyBmb3VuZC4gIFNpbmNlIHRoaXMgZGlyZWN0b3J5IGlzIGFkZGVkIHRvICRQQVRIIGl0CgkJc2hvdWxkIGFsc28gd29yayB0byBleGVjdXRlIGl0IHx3aW4zMi1QQVRIfC4KCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyOgoJCQkxCWV4aXN0cwoJCQkwCWRvZXMgbm90IGV4aXN0CgkJCS0xCW5vdCBpbXBsZW1lbnRlZCBvbiB0aGlzIHN5c3RlbQoKZXhlcGF0aCh7ZXhwcn0pCQkJCQkJKmV4ZXBhdGgoKSoKCQlJZiB7ZXhwcn0gaXMgYW4gZXhlY3V0YWJsZSBhbmQgaXMgZWl0aGVyIGFuIGFic29sdXRlIHBhdGgsIGEKCQlyZWxhdGl2ZSBwYXRoIG9yIGZvdW5kIGluICRQQVRILCByZXR1cm4gdGhlIGZ1bGwgcGF0aC4KCQlOb3RlIHRoYXQgdGhlIGN1cnJlbnQgZGlyZWN0b3J5IGlzIHVzZWQgd2hlbiB7ZXhwcn0gc3RhcnRzCgkJd2l0aCAiLi8iLCB3aGljaCBtYXkgYmUgYSBwcm9ibGVtIGZvciBWaW06ID4KCQkJZWNobyBleGVwYXRoKHY6cHJvZ3BhdGgpCjwJCUlmIHtleHByfSBjYW5ub3QgYmUgZm91bmQgaW4gJFBBVEggb3IgaXMgbm90IGV4ZWN1dGFibGUgdGhlbgoJCWFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCgkJCQkJCQkqZXhpc3RzKCkqCmV4aXN0cyh7ZXhwcn0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIGlmIHtleHByfSBpcwoJCWRlZmluZWQsIHplcm8gb3RoZXJ3aXNlLiAgVGhlIHtleHByfSBhcmd1bWVudCBpcyBhIHN0cmluZywKCQl3aGljaCBjb250YWlucyBvbmUgb2YgdGhlc2U6CgkJCSZvcHRpb24tbmFtZQlWaW0gb3B0aW9uIChvbmx5IGNoZWNrcyBpZiBpdCBleGlzdHMsCgkJCQkJbm90IGlmIGl0IHJlYWxseSB3b3JrcykKCQkJK29wdGlvbi1uYW1lCVZpbSBvcHRpb24gdGhhdCB3b3Jrcy4KCQkJJEVOVk5BTUUJZW52aXJvbm1lbnQgdmFyaWFibGUgKGNvdWxkIGFsc28gYmUKCQkJCQlkb25lIGJ5IGNvbXBhcmluZyB3aXRoIGFuIGVtcHR5CgkJCQkJc3RyaW5nKQoJCQkqZnVuY25hbWUJYnVpbHQtaW4gZnVuY3Rpb24gKHNlZSB8ZnVuY3Rpb25zfCkKCQkJCQlvciB1c2VyIGRlZmluZWQgZnVuY3Rpb24gKHNlZQoJCQkJCXx1c2VyLWZ1bmN0aW9uc3wpLiBBbHNvIHdvcmtzIGZvciBhCgkJCQkJdmFyaWFibGUgdGhhdCBpcyBhIEZ1bmNyZWYuCgkJCXZhcm5hbWUJCWludGVybmFsIHZhcmlhYmxlIChzZWUKCQkJCQl8aW50ZXJuYWwtdmFyaWFibGVzfCkuCUFsc28gd29ya3MKCQkJCQlmb3IgfGN1cmx5LWJyYWNlcy1uYW1lc3wsIHxEaWN0aW9uYXJ5fAoJCQkJCWVudHJpZXMsIHxMaXN0fCBpdGVtcywgZXRjLiAgQmV3YXJlCgkJCQkJdGhhdCBldmFsdWF0aW5nIGFuIGluZGV4IG1heSBjYXVzZSBhbgoJCQkJCWVycm9yIG1lc3NhZ2UgZm9yIGFuIGludmFsaWQKCQkJCQlleHByZXNzaW9uLiAgRS5nLjogPgoJCQkJCSAgIDpsZXQgbCA9IFsxLCAyLCAzXQoJCQkJCSAgIDplY2hvIGV4aXN0cygibFs1XSIpCjwJCQkJCSAgIDAgPgoJCQkJCSAgIDplY2hvIGV4aXN0cygibFt4eF0iKQo8CQkJCQkgICBFMTIxOiBVbmRlZmluZWQgdmFyaWFibGU6IHh4CgkJCQkJICAgMAoJCQk6Y21kbmFtZQlFeCBjb21tYW5kOiBidWlsdC1pbiBjb21tYW5kLCB1c2VyCgkJCQkJY29tbWFuZCBvciBjb21tYW5kIG1vZGlmaWVyIHw6Y29tbWFuZHwuCgkJCQkJUmV0dXJuczoKCQkJCQkxICBmb3IgbWF0Y2ggd2l0aCBzdGFydCBvZiBhIGNvbW1hbmQKCQkJCQkyICBmdWxsIG1hdGNoIHdpdGggYSBjb21tYW5kCgkJCQkJMyAgbWF0Y2hlcyBzZXZlcmFsIHVzZXIgY29tbWFuZHMKCQkJCQlUbyBjaGVjayBmb3IgYSBzdXBwb3J0ZWQgY29tbWFuZAoJCQkJCWFsd2F5cyBjaGVjayB0aGUgcmV0dXJuIHZhbHVlIHRvIGJlIDIuCgkJCToybWF0Y2gJCVRoZSB8OjJtYXRjaHwgY29tbWFuZC4KCQkJOjNtYXRjaAkJVGhlIHw6M21hdGNofCBjb21tYW5kLgoJCQkjZXZlbnQJCWF1dG9jb21tYW5kIGRlZmluZWQgZm9yIHRoaXMgZXZlbnQKCQkJI2V2ZW50I3BhdHRlcm4JYXV0b2NvbW1hbmQgZGVmaW5lZCBmb3IgdGhpcyBldmVudCBhbmQKCQkJCQlwYXR0ZXJuICh0aGUgcGF0dGVybiBpcyB0YWtlbgoJCQkJCWxpdGVyYWxseSBhbmQgY29tcGFyZWQgdG8gdGhlCgkJCQkJYXV0b2NvbW1hbmQgcGF0dGVybnMgY2hhcmFjdGVyIGJ5CgkJCQkJY2hhcmFjdGVyKQoJCQkjZ3JvdXAJCWF1dG9jb21tYW5kIGdyb3VwIGV4aXN0cwoJCQkjZ3JvdXAjZXZlbnQJYXV0b2NvbW1hbmQgZGVmaW5lZCBmb3IgdGhpcyBncm91cCBhbmQKCQkJCQlldmVudC4KCQkJI2dyb3VwI2V2ZW50I3BhdHRlcm4KCQkJCQlhdXRvY29tbWFuZCBkZWZpbmVkIGZvciB0aGlzIGdyb3VwLAoJCQkJCWV2ZW50IGFuZCBwYXR0ZXJuLgoJCQkjI2V2ZW50CQlhdXRvY29tbWFuZCBmb3IgdGhpcyBldmVudCBpcwoJCQkJCXN1cHBvcnRlZC4KCQlGb3IgY2hlY2tpbmcgZm9yIGEgc3VwcG9ydGVkIGZlYXR1cmUgdXNlIHxoYXMoKXwuCgoJCUV4YW1wbGVzOiA+CgkJCWV4aXN0cygiJnNob3J0bmFtZSIpCgkJCWV4aXN0cygiJEhPU1ROQU1FIikKCQkJZXhpc3RzKCIqc3RyZnRpbWUiKQoJCQlleGlzdHMoIipzOk15RnVuYyIpCgkJCWV4aXN0cygiYnVmY291bnQiKQoJCQlleGlzdHMoIjpNYWtlIikKCQkJZXhpc3RzKCIjQ3Vyc29ySG9sZCIpCgkJCWV4aXN0cygiI0J1ZlJlYWRQcmUjKi5neiIpCgkJCWV4aXN0cygiI2ZpbGV0eXBlaW5kZW50IikKCQkJZXhpc3RzKCIjZmlsZXR5cGVpbmRlbnQjRmlsZVR5cGUiKQoJCQlleGlzdHMoIiNmaWxldHlwZWluZGVudCNGaWxlVHlwZSMqIikKCQkJZXhpc3RzKCIjI0NvbG9yU2NoZW1lIikKPAkJVGhlcmUgbXVzdCBiZSBubyBzcGFjZSBiZXR3ZWVuIHRoZSBzeW1ib2wgKCYvJC8qLyMpIGFuZCB0aGUKCQluYW1lLgoJCVRoZXJlIG11c3QgYmUgbm8gZXh0cmEgY2hhcmFjdGVycyBhZnRlciB0aGUgbmFtZSwgYWx0aG91Z2ggaW4KCQlhIGZldyBjYXNlcyB0aGlzIGlzIGlnbm9yZWQuICBUaGF0IG1heSBiZWNvbWUgbW9yZSBzdHJpY3QgaW4KCQl0aGUgZnV0dXJlLCB0aHVzIGRvbid0IGNvdW50IG9uIGl0IQoJCVdvcmtpbmcgZXhhbXBsZTogPgoJCQlleGlzdHMoIjptYWtlIikKPAkJTk9UIHdvcmtpbmcgZXhhbXBsZTogPgoJCQlleGlzdHMoIjptYWtlIGluc3RhbGwiKQoKPAkJTm90ZSB0aGF0IHRoZSBhcmd1bWVudCBtdXN0IGJlIGEgc3RyaW5nLCBub3QgdGhlIG5hbWUgb2YgdGhlCgkJdmFyaWFibGUgaXRzZWxmLiAgRm9yIGV4YW1wbGU6ID4KCQkJZXhpc3RzKGJ1ZmNvdW50KQo8CQlUaGlzIGRvZXNuJ3QgY2hlY2sgZm9yIGV4aXN0ZW5jZSBvZiB0aGUgImJ1ZmNvdW50IiB2YXJpYWJsZSwKCQlidXQgZ2V0cyB0aGUgdmFsdWUgb2YgImJ1ZmNvdW50IiwgYW5kIGNoZWNrcyBpZiB0aGF0IGV4aXN0cy4KCmV4cCh7ZXhwcn0pCQkJCQkJKmV4cCgpKgoJCVJldHVybiB0aGUgZXhwb25lbnRpYWwgb2Yge2V4cHJ9IGFzIGEgfEZsb2F0fCBpbiB0aGUgcmFuZ2UKCQlbMCwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBleHAoMikKPAkJCTcuMzg5MDU2ID4KCQkJOmVjaG8gZXhwKC0xKQo8CQkJMC4zNjc4NzkKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmV4cGFuZCh7ZXhwcn0gWywge25vc3VmfSBbLCB7bGlzdH1dXSkJCQkJKmV4cGFuZCgpKgoJCUV4cGFuZCB3aWxkY2FyZHMgYW5kIHRoZSBmb2xsb3dpbmcgc3BlY2lhbCBrZXl3b3JkcyBpbiB7ZXhwcn0uCgkJJ3dpbGRpZ25vcmVjYXNlJyBhcHBsaWVzLgoKCQlJZiB7bGlzdH0gaXMgZ2l2ZW4gYW5kIGl0IGlzIG5vbi16ZXJvLCBhIExpc3Qgd2lsbCBiZSByZXR1cm5lZC4KCQlPdGhlcndpc2UgdGhlIHJlc3VsdCBpcyBhIFN0cmluZyBhbmQgd2hlbiB0aGVyZSBhcmUgc2V2ZXJhbAoJCW1hdGNoZXMsIHRoZXkgYXJlIHNlcGFyYXRlZCBieSA8Tkw+IGNoYXJhY3RlcnMuICBbTm90ZTogaW4KCQl2ZXJzaW9uIDUuMCBhIHNwYWNlIHdhcyB1c2VkLCB3aGljaCBjYXVzZWQgcHJvYmxlbXMgd2hlbiBhCgkJZmlsZSBuYW1lIGNvbnRhaW5zIGEgc3BhY2VdCgoJCUlmIHRoZSBleHBhbnNpb24gZmFpbHMsIHRoZSByZXN1bHQgaXMgYW4gZW1wdHkgc3RyaW5nLglBIG5hbWUKCQlmb3IgYSBub24tZXhpc3RpbmcgZmlsZSBpcyBub3QgaW5jbHVkZWQsIHVubGVzcyB7ZXhwcn0gZG9lcwoJCW5vdCBzdGFydCB3aXRoICclJywgJyMnIG9yICc8Jywgc2VlIGJlbG93LgoKCQlXaGVuIHtleHByfSBzdGFydHMgd2l0aCAnJScsICcjJyBvciAnPCcsIHRoZSBleHBhbnNpb24gaXMgZG9uZQoJCWxpa2UgZm9yIHRoZSB8Y21kbGluZS1zcGVjaWFsfCB2YXJpYWJsZXMgd2l0aCB0aGVpciBhc3NvY2lhdGVkCgkJbW9kaWZpZXJzLiAgSGVyZSBpcyBhIHNob3J0IG92ZXJ2aWV3OgoKCQkJJQkJY3VycmVudCBmaWxlIG5hbWUKCQkJIwkJYWx0ZXJuYXRlIGZpbGUgbmFtZQoJCQkjbgkJYWx0ZXJuYXRlIGZpbGUgbmFtZSBuCgkJCTxjZmlsZT4JCWZpbGUgbmFtZSB1bmRlciB0aGUgY3Vyc29yCgkJCTxhZmlsZT4JCWF1dG9jbWQgZmlsZSBuYW1lCgkJCTxhYnVmPgkJYXV0b2NtZCBidWZmZXIgbnVtYmVyIChhcyBhIFN0cmluZyEpCgkJCTxhbWF0Y2g+CWF1dG9jbWQgbWF0Y2hlZCBuYW1lCgkJCTxzZmlsZT4JCXNvdXJjZWQgc2NyaXB0IGZpbGUgb3IgZnVuY3Rpb24gbmFtZQoJCQk8c2xudW0+CQlzb3VyY2VkIHNjcmlwdCBmaWxlIGxpbmUgbnVtYmVyCgkJCTxjd29yZD4JCXdvcmQgdW5kZXIgdGhlIGN1cnNvcgoJCQk8Y1dPUkQ+CQlXT1JEIHVuZGVyIHRoZSBjdXJzb3IKCQkJPGNsaWVudD4JdGhlIHtjbGllbnRpZH0gb2YgdGhlIGxhc3QgcmVjZWl2ZWQKCQkJCQltZXNzYWdlIHxzZXJ2ZXIyY2xpZW50KCl8CgkJTW9kaWZpZXJzOgoJCQk6cAkJZXhwYW5kIHRvIGZ1bGwgcGF0aAoJCQk6aAkJaGVhZCAobGFzdCBwYXRoIGNvbXBvbmVudCByZW1vdmVkKQoJCQk6dAkJdGFpbCAobGFzdCBwYXRoIGNvbXBvbmVudCBvbmx5KQoJCQk6cgkJcm9vdCAob25lIGV4dGVuc2lvbiByZW1vdmVkKQoJCQk6ZQkJZXh0ZW5zaW9uIG9ubHkKCgkJRXhhbXBsZTogPgoJCQk6bGV0ICZ0YWdzID0gZXhwYW5kKCIlOnA6aCIpIC4gIi90YWdzIgo8CQlOb3RlIHRoYXQgd2hlbiBleHBhbmRpbmcgYSBzdHJpbmcgdGhhdCBzdGFydHMgd2l0aCAnJScsICcjJyBvcgoJCSc8JywgYW55IGZvbGxvd2luZyB0ZXh0IGlzIGlnbm9yZWQuICBUaGlzIGRvZXMgTk9UIHdvcms6ID4KCQkJOmxldCBkb2VzbnR3b3JrID0gZXhwYW5kKCIlOmguYmFrIikKPAkJVXNlIHRoaXM6ID4KCQkJOmxldCBkb2Vzd29yayA9IGV4cGFuZCgiJTpoIikgLiAiLmJhayIKPAkJQWxzbyBub3RlIHRoYXQgZXhwYW5kaW5nICI8Y2ZpbGU+IiBhbmQgb3RoZXJzIG9ubHkgcmV0dXJucyB0aGUKCQlyZWZlcmVuY2VkIGZpbGUgbmFtZSB3aXRob3V0IGZ1cnRoZXIgZXhwYW5zaW9uLiAgSWYgIjxjZmlsZT4iCgkJaXMgIn4vLmNzaHJjIiwgeW91IG5lZWQgdG8gZG8gYW5vdGhlciBleHBhbmQoKSB0byBoYXZlIHRoZQoJCSJ+LyIgZXhwYW5kZWQgaW50byB0aGUgcGF0aCBvZiB0aGUgaG9tZSBkaXJlY3Rvcnk6ID4KCQkJOmVjaG8gZXhwYW5kKGV4cGFuZCgiPGNmaWxlPiIpKQo8CgkJVGhlcmUgY2Fubm90IGJlIHdoaXRlIHNwYWNlIGJldHdlZW4gdGhlIHZhcmlhYmxlcyBhbmQgdGhlCgkJZm9sbG93aW5nIG1vZGlmaWVyLiAgVGhlIHxmbmFtZW1vZGlmeSgpfCBmdW5jdGlvbiBjYW4gYmUgdXNlZAoJCXRvIG1vZGlmeSBub3JtYWwgZmlsZSBuYW1lcy4KCgkJV2hlbiB1c2luZyAnJScgb3IgJyMnLCBhbmQgdGhlIGN1cnJlbnQgb3IgYWx0ZXJuYXRlIGZpbGUgbmFtZQoJCWlzIG5vdCBkZWZpbmVkLCBhbiBlbXB0eSBzdHJpbmcgaXMgdXNlZC4gIFVzaW5nICIlOnAiIGluIGEKCQlidWZmZXIgd2l0aCBubyBuYW1lLCByZXN1bHRzIGluIHRoZSBjdXJyZW50IGRpcmVjdG9yeSwgd2l0aCBhCgkJJy8nIGFkZGVkLgoKCQlXaGVuIHtleHByfSBkb2VzIG5vdCBzdGFydCB3aXRoICclJywgJyMnIG9yICc8JywgaXQgaXMKCQlleHBhbmRlZCBsaWtlIGEgZmlsZSBuYW1lIGlzIGV4cGFuZGVkIG9uIHRoZSBjb21tYW5kIGxpbmUuCgkJJ3N1ZmZpeGVzJyBhbmQgJ3dpbGRpZ25vcmUnIGFyZSB1c2VkLCB1bmxlc3MgdGhlIG9wdGlvbmFsCgkJe25vc3VmfSBhcmd1bWVudCBpcyBnaXZlbiBhbmQgaXQgaXMgbm9uLXplcm8uCgkJTmFtZXMgZm9yIG5vbi1leGlzdGluZyBmaWxlcyBhcmUgaW5jbHVkZWQuICBUaGUgIioqIiBpdGVtIGNhbgoJCWJlIHVzZWQgdG8gc2VhcmNoIGluIGEgZGlyZWN0b3J5IHRyZWUuICBGb3IgZXhhbXBsZSwgdG8gZmluZAoJCWFsbCAiUkVBRE1FIiBmaWxlcyBpbiB0aGUgY3VycmVudCBkaXJlY3RvcnkgYW5kIGJlbG93OiA+CgkJCTplY2hvIGV4cGFuZCgiKiovUkVBRE1FIikKPAoJCUV4cGFuZCgpIGNhbiBhbHNvIGJlIHVzZWQgdG8gZXhwYW5kIHZhcmlhYmxlcyBhbmQgZW52aXJvbm1lbnQKCQl2YXJpYWJsZXMgdGhhdCBhcmUgb25seSBrbm93biBpbiBhIHNoZWxsLiAgQnV0IHRoaXMgY2FuIGJlCgkJc2xvdywgYmVjYXVzZSBhIHNoZWxsIG1heSBiZSB1c2VkIHRvIGRvIHRoZSBleHBhbnNpb24uICBTZWUKCQl8ZXhwci1lbnYtZXhwYW5kfC4KCQlUaGUgZXhwYW5kZWQgdmFyaWFibGUgaXMgc3RpbGwgaGFuZGxlZCBsaWtlIGEgbGlzdCBvZiBmaWxlCgkJbmFtZXMuCVdoZW4gYW4gZW52aXJvbm1lbnQgdmFyaWFibGUgY2Fubm90IGJlIGV4cGFuZGVkLCBpdCBpcwoJCWxlZnQgdW5jaGFuZ2VkLiAgVGh1cyAiOmVjaG8gZXhwYW5kKCckRk9PQkFSJykiIHJlc3VsdHMgaW4KCQkiJEZPT0JBUiIuCgoJCVNlZSB8Z2xvYigpfCBmb3IgZmluZGluZyBleGlzdGluZyBmaWxlcy4gIFNlZSB8c3lzdGVtKCl8IGZvcgoJCWdldHRpbmcgdGhlIHJhdyBvdXRwdXQgb2YgYW4gZXh0ZXJuYWwgY29tbWFuZC4KCmV4dGVuZCh7ZXhwcjF9LCB7ZXhwcjJ9IFssIHtleHByM31dKQkJCSpleHRlbmQoKSoKCQl7ZXhwcjF9IGFuZCB7ZXhwcjJ9IG11c3QgYmUgYm90aCB8TGlzdHN8IG9yIGJvdGgKCQl8RGljdGlvbmFyaWVzfC4KCgkJSWYgdGhleSBhcmUgfExpc3RzfDogQXBwZW5kIHtleHByMn0gdG8ge2V4cHIxfS4KCQlJZiB7ZXhwcjN9IGlzIGdpdmVuIGluc2VydCB0aGUgaXRlbXMgb2Yge2V4cHIyfSBiZWZvcmUgaXRlbQoJCXtleHByM30gaW4ge2V4cHIxfS4gIFdoZW4ge2V4cHIzfSBpcyB6ZXJvIGluc2VydCBiZWZvcmUgdGhlCgkJZmlyc3QgaXRlbS4gIFdoZW4ge2V4cHIzfSBpcyBlcXVhbCB0byBsZW4oe2V4cHIxfSkgdGhlbgoJCXtleHByMn0gaXMgYXBwZW5kZWQuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gc29ydChleHRlbmQobXlsaXN0LCBbNywgNV0pKQoJCQk6Y2FsbCBleHRlbmQobXlsaXN0LCBbMiwgM10sIDEpCjwJCVdoZW4ge2V4cHIxfSBpcyB0aGUgc2FtZSBMaXN0IGFzIHtleHByMn0gdGhlbiB0aGUgbnVtYmVyIG9mCgkJaXRlbXMgY29waWVkIGlzIGVxdWFsIHRvIHRoZSBvcmlnaW5hbCBsZW5ndGggb2YgdGhlIExpc3QuCgkJRS5nLiwgd2hlbiB7ZXhwcjN9IGlzIDEgeW91IGdldCBOIG5ldyBjb3BpZXMgb2YgdGhlIGZpcnN0IGl0ZW0KCQkod2hlcmUgTiBpcyB0aGUgb3JpZ2luYWwgbGVuZ3RoIG9mIHRoZSBMaXN0KS4KCQlVc2UgfGFkZCgpfCB0byBjb25jYXRlbmF0ZSBvbmUgaXRlbSB0byBhIGxpc3QuCVRvIGNvbmNhdGVuYXRlCgkJdHdvIGxpc3RzIGludG8gYSBuZXcgbGlzdCB1c2UgdGhlICsgb3BlcmF0b3I6ID4KCQkJOmxldCBuZXdsaXN0ID0gWzEsIDIsIDNdICsgWzQsIDVdCjwKCQlJZiB0aGV5IGFyZSB8RGljdGlvbmFyaWVzfDoKCQlBZGQgYWxsIGVudHJpZXMgZnJvbSB7ZXhwcjJ9IHRvIHtleHByMX0uCgkJSWYgYSBrZXkgZXhpc3RzIGluIGJvdGgge2V4cHIxfSBhbmQge2V4cHIyfSB0aGVuIHtleHByM30gaXMKCQl1c2VkIHRvIGRlY2lkZSB3aGF0IHRvIGRvOgoJCXtleHByM30gPSAia2VlcCI6IGtlZXAgdGhlIHZhbHVlIG9mIHtleHByMX0KCQl7ZXhwcjN9ID0gImZvcmNlIjogdXNlIHRoZSB2YWx1ZSBvZiB7ZXhwcjJ9CgkJe2V4cHIzfSA9ICJlcnJvciI6IGdpdmUgYW4gZXJyb3IgbWVzc2FnZQkJKkU3MzcqCgkJV2hlbiB7ZXhwcjN9IGlzIG9taXR0ZWQgdGhlbiAiZm9yY2UiIGlzIGFzc3VtZWQuCgoJCXtleHByMX0gaXMgY2hhbmdlZCB3aGVuIHtleHByMn0gaXMgbm90IGVtcHR5LiAgSWYgbmVjZXNzYXJ5CgkJbWFrZSBhIGNvcHkgb2Yge2V4cHIxfSBmaXJzdC4KCQl7ZXhwcjJ9IHJlbWFpbnMgdW5jaGFuZ2VkLgoJCVdoZW4ge2V4cHIxfSBpcyBsb2NrZWQgYW5kIHtleHByMn0gaXMgbm90IGVtcHR5IHRoZSBvcGVyYXRpb24KCQlmYWlscy4KCQlSZXR1cm5zIHtleHByMX0uCgoKZmVlZGtleXMoe3N0cmluZ30gWywge21vZGV9XSkJCQkJKmZlZWRrZXlzKCkqCgkJQ2hhcmFjdGVycyBpbiB7c3RyaW5nfSBhcmUgcXVldWVkIGZvciBwcm9jZXNzaW5nIGFzIGlmIHRoZXkKCQljb21lIGZyb20gYSBtYXBwaW5nIG9yIHdlcmUgdHlwZWQgYnkgdGhlIHVzZXIuCgkJQnkgZGVmYXVsdCB0aGUgc3RyaW5nIGlzIGFkZGVkIHRvIHRoZSBlbmQgb2YgdGhlIHR5cGVhaGVhZAoJCWJ1ZmZlciwgdGh1cyBpZiBhIG1hcHBpbmcgaXMgc3RpbGwgYmVpbmcgZXhlY3V0ZWQgdGhlCgkJY2hhcmFjdGVycyBjb21lIGFmdGVyIHRoZW0uICBVc2UgdGhlICdpJyBmbGFnIHRvIGluc2VydCBiZWZvcmUKCQlvdGhlciBjaGFyYWN0ZXJzLCB0aGV5IHdpbGwgYmUgZXhlY3V0ZWQgbmV4dCwgYmVmb3JlIGFueQoJCWNoYXJhY3RlcnMgZnJvbSBhIG1hcHBpbmcuCgkJVGhlIGZ1bmN0aW9uIGRvZXMgbm90IHdhaXQgZm9yIHByb2Nlc3Npbmcgb2Yga2V5cyBjb250YWluZWQgaW4KCQl7c3RyaW5nfS4KCQlUbyBpbmNsdWRlIHNwZWNpYWwga2V5cyBpbnRvIHtzdHJpbmd9LCB1c2UgZG91YmxlLXF1b3RlcwoJCWFuZCAiXC4uLiIgbm90YXRpb24gfGV4cHItcXVvdGV8LiBGb3IgZXhhbXBsZSwKCQlmZWVka2V5cygiXDxDUj4iKSBzaW11bGF0ZXMgcHJlc3Npbmcgb2YgdGhlIDxFbnRlcj4ga2V5LiBCdXQKCQlmZWVka2V5cygnXDxDUj4nKSBwdXNoZXMgNSBjaGFyYWN0ZXJzLgoJCUlmIHttb2RlfSBpcyBhYnNlbnQsIGtleXMgYXJlIHJlbWFwcGVkLgoJCXttb2RlfSBpcyBhIFN0cmluZywgd2hpY2ggY2FuIGNvbnRhaW4gdGhlc2UgY2hhcmFjdGVyIGZsYWdzOgoJCSdtJwlSZW1hcCBrZXlzLiBUaGlzIGlzIGRlZmF1bHQuCgkJJ24nCURvIG5vdCByZW1hcCBrZXlzLgoJCSd0JwlIYW5kbGUga2V5cyBhcyBpZiB0eXBlZDsgb3RoZXJ3aXNlIHRoZXkgYXJlIGhhbmRsZWQgYXMKCQkJaWYgY29taW5nIGZyb20gYSBtYXBwaW5nLiAgVGhpcyBtYXR0ZXJzIGZvciB1bmRvLAoJCQlvcGVuaW5nIGZvbGRzLCBldGMuCgkJJ2knCUluc2VydCB0aGUgc3RyaW5nIGluc3RlYWQgb2YgYXBwZW5kaW5nIChzZWUgYWJvdmUpLgoJCSd4JwlFeGVjdXRlIGNvbW1hbmRzIHVudGlsIHR5cGVhaGVhZCBpcyBlbXB0eS4gIFRoaXMgaXMKCQkJc2ltaWxhciB0byB1c2luZyAiOm5vcm1hbCEiLiAgWW91IGNhbiBjYWxsIGZlZWRrZXlzKCkKCQkJc2V2ZXJhbCB0aW1lcyB3aXRob3V0ICd4JyBhbmQgdGhlbiBvbmUgdGltZSB3aXRoICd4JwoJCQkocG9zc2libHkgd2l0aCBhbiBlbXB0eSB7c3RyaW5nfSkgdG8gZXhlY3V0ZSBhbGwgdGhlCgkJCXR5cGVhaGVhZC4gIE5vdGUgdGhhdCB3aGVuIFZpbSBlbmRzIGluIEluc2VydCBtb2RlIGl0CgkJCXdpbGwgYmVoYXZlIGFzIGlmIDxFc2M+IGlzIHR5cGVkLCB0byBhdm9pZCBnZXR0aW5nCgkJCXN0dWNrLCB3YWl0aW5nIGZvciBhIGNoYXJhY3RlciB0byBiZSB0eXBlZCBiZWZvcmUgdGhlCgkJCXNjcmlwdCBjb250aW51ZXMuCgkJJyEnCVdoZW4gdXNlZCB3aXRoICd4JyB3aWxsIG5vdCBlbmQgSW5zZXJ0IG1vZGUuIENhbiBiZQoJCQl1c2VkIGluIGEgdGVzdCB3aGVuIGEgdGltZXIgaXMgc2V0IHRvIGV4aXQgSW5zZXJ0IG1vZGUKCQkJYSBsaXR0bGUgbGF0ZXIuICBVc2VmdWwgZm9yIHRlc3RpbmcgQ3Vyc29ySG9sZEkuCgoJCVJldHVybiB2YWx1ZSBpcyBhbHdheXMgMC4KCmZpbGVyZWFkYWJsZSh7ZmlsZX0pCQkJCQkqZmlsZXJlYWRhYmxlKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgVFJVRSB3aGVuIGEgZmlsZSB3aXRoIHRoZQoJCW5hbWUge2ZpbGV9IGV4aXN0cywgYW5kIGNhbiBiZSByZWFkLiAgSWYge2ZpbGV9IGRvZXNuJ3QgZXhpc3QsCgkJb3IgaXMgYSBkaXJlY3RvcnksIHRoZSByZXN1bHQgaXMgRkFMU0UuICB7ZmlsZX0gaXMgYW55CgkJZXhwcmVzc2lvbiwgd2hpY2ggaXMgdXNlZCBhcyBhIFN0cmluZy4KCQlJZiB5b3UgZG9uJ3QgY2FyZSBhYm91dCB0aGUgZmlsZSBiZWluZyByZWFkYWJsZSB5b3UgY2FuIHVzZQoJCXxnbG9iKCl8LgoJCQkJCQkJKmZpbGVfcmVhZGFibGUoKSoKCQlPYnNvbGV0ZSBuYW1lOiBmaWxlX3JlYWRhYmxlKCkuCgoKZmlsZXdyaXRhYmxlKHtmaWxlfSkJCQkJCSpmaWxld3JpdGFibGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyAxIHdoZW4gYSBmaWxlIHdpdGggdGhlCgkJbmFtZSB7ZmlsZX0gZXhpc3RzLCBhbmQgY2FuIGJlIHdyaXR0ZW4uICBJZiB7ZmlsZX0gZG9lc24ndAoJCWV4aXN0LCBvciBpcyBub3Qgd3JpdGFibGUsIHRoZSByZXN1bHQgaXMgMC4gIElmIHtmaWxlfSBpcyBhCgkJZGlyZWN0b3J5LCBhbmQgd2UgY2FuIHdyaXRlIHRvIGl0LCB0aGUgcmVzdWx0IGlzIDIuCgoKZmlsdGVyKHtleHByfSwge3N0cmluZ30pCQkJCQkqZmlsdGVyKCkqCgkJe2V4cHJ9IG11c3QgYmUgYSB8TGlzdHwgb3IgYSB8RGljdGlvbmFyeXwuCgkJRm9yIGVhY2ggaXRlbSBpbiB7ZXhwcn0gZXZhbHVhdGUge3N0cmluZ30gYW5kIHdoZW4gdGhlIHJlc3VsdAoJCWlzIHplcm8gcmVtb3ZlIHRoZSBpdGVtIGZyb20gdGhlIHxMaXN0fCBvciB8RGljdGlvbmFyeXwuCgkJSW5zaWRlIHtzdHJpbmd9IHx2OnZhbHwgaGFzIHRoZSB2YWx1ZSBvZiB0aGUgY3VycmVudCBpdGVtLgoJCUZvciBhIHxEaWN0aW9uYXJ5fCB8djprZXl8IGhhcyB0aGUga2V5IG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRXhhbXBsZXM6ID4KCQkJOmNhbGwgZmlsdGVyKG15bGlzdCwgJ3Y6dmFsICF+ICJPTEQiJykKPAkJUmVtb3ZlcyB0aGUgaXRlbXMgd2hlcmUgIk9MRCIgYXBwZWFycy4gPgoJCQk6Y2FsbCBmaWx0ZXIobXlkaWN0LCAndjprZXkgPj0gOCcpCjwJCVJlbW92ZXMgdGhlIGl0ZW1zIHdpdGggYSBrZXkgYmVsb3cgOC4gPgoJCQk6Y2FsbCBmaWx0ZXIodmFyLCAwKQo8CQlSZW1vdmVzIGFsbCB0aGUgaXRlbXMsIHRodXMgY2xlYXJzIHRoZSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8LgoKCQlOb3RlIHRoYXQge3N0cmluZ30gaXMgdGhlIHJlc3VsdCBvZiBleHByZXNzaW9uIGFuZCBpcyB0aGVuCgkJdXNlZCBhcyBhbiBleHByZXNzaW9uIGFnYWluLiAgT2Z0ZW4gaXQgaXMgZ29vZCB0byB1c2UgYQoJCXxsaXRlcmFsLXN0cmluZ3wgdG8gYXZvaWQgaGF2aW5nIHRvIGRvdWJsZSBiYWNrc2xhc2hlcy4KCgkJVGhlIG9wZXJhdGlvbiBpcyBkb25lIGluLXBsYWNlLiAgSWYgeW91IHdhbnQgYSB8TGlzdHwgb3IKCQl8RGljdGlvbmFyeXwgdG8gcmVtYWluIHVubW9kaWZpZWQgbWFrZSBhIGNvcHkgZmlyc3Q6ID4KCQkJOmxldCBsID0gZmlsdGVyKGNvcHkobXlsaXN0KSwgJ3Y6dmFsID1+ICJLRUVQIicpCgo8CQlSZXR1cm5zIHtleHByfSwgdGhlIHxMaXN0fCBvciB8RGljdGlvbmFyeXwgdGhhdCB3YXMgZmlsdGVyZWQuCgkJV2hlbiBhbiBlcnJvciBpcyBlbmNvdW50ZXJlZCB3aGlsZSBldmFsdWF0aW5nIHtzdHJpbmd9IG5vCgkJZnVydGhlciBpdGVtcyBpbiB7ZXhwcn0gYXJlIHByb2Nlc3NlZC4KCgpmaW5kZGlyKHtuYW1lfVssIHtwYXRofVssIHtjb3VudH1dXSkJCQkJKmZpbmRkaXIoKSoKCQlGaW5kIGRpcmVjdG9yeSB7bmFtZX0gaW4ge3BhdGh9LiAgU3VwcG9ydHMgYm90aCBkb3dud2FyZHMgYW5kCgkJdXB3YXJkcyByZWN1cnNpdmUgZGlyZWN0b3J5IHNlYXJjaGVzLiAgU2VlIHxmaWxlLXNlYXJjaGluZ3wKCQlmb3IgdGhlIHN5bnRheCBvZiB7cGF0aH0uCgkJUmV0dXJucyB0aGUgcGF0aCBvZiB0aGUgZmlyc3QgZm91bmQgbWF0Y2guICBXaGVuIHRoZSBmb3VuZAoJCWRpcmVjdG9yeSBpcyBiZWxvdyB0aGUgY3VycmVudCBkaXJlY3RvcnkgYSByZWxhdGl2ZSBwYXRoIGlzCgkJcmV0dXJuZWQuICBPdGhlcndpc2UgYSBmdWxsIHBhdGggaXMgcmV0dXJuZWQuCgkJSWYge3BhdGh9IGlzIG9taXR0ZWQgb3IgZW1wdHkgdGhlbiAncGF0aCcgaXMgdXNlZC4KCQlJZiB0aGUgb3B0aW9uYWwge2NvdW50fSBpcyBnaXZlbiwgZmluZCB7Y291bnR9J3Mgb2NjdXJyZW5jZSBvZgoJCXtuYW1lfSBpbiB7cGF0aH0gaW5zdGVhZCBvZiB0aGUgZmlyc3Qgb25lLgoJCVdoZW4ge2NvdW50fSBpcyBuZWdhdGl2ZSByZXR1cm4gYWxsIHRoZSBtYXRjaGVzIGluIGEgfExpc3R8LgoJCVRoaXMgaXMgcXVpdGUgc2ltaWxhciB0byB0aGUgZXgtY29tbWFuZCB8OmZpbmR8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmlsZV9pbl9wYXRofAoJCWZlYXR1cmV9CgpmaW5kZmlsZSh7bmFtZX1bLCB7cGF0aH1bLCB7Y291bnR9XV0pCQkJCSpmaW5kZmlsZSgpKgoJCUp1c3QgbGlrZSB8ZmluZGRpcigpfCwgYnV0IGZpbmQgYSBmaWxlIGluc3RlYWQgb2YgYSBkaXJlY3RvcnkuCgkJVXNlcyAnc3VmZml4ZXNhZGQnLgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gZmluZGZpbGUoInRhZ3MudmltIiwgIi47IikKPAkJU2VhcmNoZXMgZnJvbSB0aGUgZGlyZWN0b3J5IG9mIHRoZSBjdXJyZW50IGZpbGUgdXB3YXJkcyB1bnRpbAoJCWl0IGZpbmRzIHRoZSBmaWxlICJ0YWdzLnZpbSIuCgpmbG9hdDJucih7ZXhwcn0pCQkJCQkqZmxvYXQybnIoKSoKCQlDb252ZXJ0IHtleHByfSB0byBhIE51bWJlciBieSBvbWl0dGluZyB0aGUgcGFydCBhZnRlciB0aGUKCQlkZWNpbWFsIHBvaW50LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIE51bWJlci4KCQlXaGVuIHRoZSB2YWx1ZSBvZiB7ZXhwcn0gaXMgb3V0IG9mIHJhbmdlIGZvciBhIHxOdW1iZXJ8IHRoZQoJCXJlc3VsdCBpcyB0cnVuY2F0ZWQgdG8gMHg3ZmZmZmZmZiBvciAtMHg3ZmZmZmZmZi4gIE5hTiByZXN1bHRzCgkJaW4gLTB4ODAwMDAwMDAuCgkJRXhhbXBsZXM6ID4KCQkJZWNobyBmbG9hdDJucigzLjk1KQo8CQkJMyAgPgoJCQllY2hvIGZsb2F0Mm5yKC0yMy40NSkKPAkJCS0yMyAgPgoJCQllY2hvIGZsb2F0Mm5yKDEuMGUxMDApCjwJCQkyMTQ3NDgzNjQ3ICA+CgkJCWVjaG8gZmxvYXQybnIoLTEuMGUxNTApCjwJCQktMjE0NzQ4MzY0NyAgPgoJCQllY2hvIGZsb2F0Mm5yKDEuMGUtMTAwKQo8CQkJMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKZmxvb3Ioe2V4cHJ9KQkJCQkJCQkqZmxvb3IoKSoKCQlSZXR1cm4gdGhlIGxhcmdlc3QgaW50ZWdyYWwgdmFsdWUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvCgkJe2V4cHJ9IGFzIGEgfEZsb2F0fCAocm91bmQgZG93bikuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJZWNobyBmbG9vcigxLjg1NikKPAkJCTEuMCAgPgoJCQllY2hvIGZsb29yKC01LjQ1NikKPAkJCS02LjAgID4KCQkJZWNobyBmbG9vcig0LjApCjwJCQk0LjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoJCQoKZm1vZCh7ZXhwcjF9LCB7ZXhwcjJ9KQkJCQkJKmZtb2QoKSoKCQlSZXR1cm4gdGhlIHJlbWFpbmRlciBvZiB7ZXhwcjF9IC8ge2V4cHIyfSwgZXZlbiBpZiB0aGUKCQlkaXZpc2lvbiBpcyBub3QgcmVwcmVzZW50YWJsZS4gIFJldHVybnMge2V4cHIxfSAtIGkgKiB7ZXhwcjJ9CgkJZm9yIHNvbWUgaW50ZWdlciBpIHN1Y2ggdGhhdCBpZiB7ZXhwcjJ9IGlzIG5vbi16ZXJvLCB0aGUKCQlyZXN1bHQgaGFzIHRoZSBzYW1lIHNpZ24gYXMge2V4cHIxfSBhbmQgbWFnbml0dWRlIGxlc3MgdGhhbgoJCXRoZSBtYWduaXR1ZGUgb2Yge2V4cHIyfS4gIElmIHtleHByMn0gaXMgemVybywgdGhlIHZhbHVlCgkJcmV0dXJuZWQgaXMgemVyby4gIFRoZSB2YWx1ZSByZXR1cm5lZCBpcyBhIHxGbG9hdHwuCgkJe2V4cHIxfSBhbmQge2V4cHIyfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGZtb2QoMTIuMzMsIDEuMjIpCjwJCQkwLjEzID4KCQkJOmVjaG8gZm1vZCgtMTIuMzMsIDEuMjIpCjwJCQktMC4xMwoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggfCtmbG9hdHwgZmVhdHVyZX0KCgpmbmFtZWVzY2FwZSh7c3RyaW5nfSkJCQkJCSpmbmFtZWVzY2FwZSgpKgoJCUVzY2FwZSB7c3RyaW5nfSBmb3IgdXNlIGFzIGZpbGUgbmFtZSBjb21tYW5kIGFyZ3VtZW50LglBbGwKCQljaGFyYWN0ZXJzIHRoYXQgaGF2ZSBhIHNwZWNpYWwgbWVhbmluZywgc3VjaCBhcyAnJScgYW5kICd8JwoJCWFyZSBlc2NhcGVkIHdpdGggYSBiYWNrc2xhc2guCgkJRm9yIG1vc3Qgc3lzdGVtcyB0aGUgY2hhcmFjdGVycyBlc2NhcGVkIGFyZQoJCSIgXHRcbio/W3tgJFxcJSMnXCJ8ITwiLiAgRm9yIHN5c3RlbXMgd2hlcmUgYSBiYWNrc2xhc2gKCQlhcHBlYXJzIGluIGEgZmlsZW5hbWUsIGl0IGRlcGVuZHMgb24gdGhlIHZhbHVlIG9mICdpc2ZuYW1lJy4KCQlBIGxlYWRpbmcgJysnIGFuZCAnPicgaXMgYWxzbyBlc2NhcGVkIChzcGVjaWFsIGFmdGVyIHw6ZWRpdHwKCQlhbmQgfDp3cml0ZXwpLiAgQW5kIGEgIi0iIGJ5IGl0c2VsZiAoc3BlY2lhbCBhZnRlciB8OmNkfCkuCgkJRXhhbXBsZTogPgoJCQk6bGV0IGZuYW1lID0gJytzb21lIHN0ciVuZ2V8bmFtZScKCQkJOmV4ZSAiZWRpdCAiIC4gZm5hbWVlc2NhcGUoZm5hbWUpCjwJCXJlc3VsdHMgaW4gZXhlY3V0aW5nOiA+CgkJCWVkaXQgXCtzb21lXCBzdHJcJW5nZVx8bmFtZQoKZm5hbWVtb2RpZnkoe2ZuYW1lfSwge21vZHN9KQkJCQkqZm5hbWVtb2RpZnkoKSoKCQlNb2RpZnkgZmlsZSBuYW1lIHtmbmFtZX0gYWNjb3JkaW5nIHRvIHttb2RzfS4gIHttb2RzfSBpcyBhCgkJc3RyaW5nIG9mIGNoYXJhY3RlcnMgbGlrZSBpdCBpcyB1c2VkIGZvciBmaWxlIG5hbWVzIG9uIHRoZQoJCWNvbW1hbmQgbGluZS4gIFNlZSB8ZmlsZW5hbWUtbW9kaWZpZXJzfC4KCQlFeGFtcGxlOiA+CgkJCTplY2hvIGZuYW1lbW9kaWZ5KCJtYWluLmMiLCAiOnA6aCIpCjwJCXJlc3VsdHMgaW46ID4KCQkJL2hvbWUvbW9vbC92aW0vdmltL3NyYwo8CQlOb3RlOiBFbnZpcm9ubWVudCB2YXJpYWJsZXMgZG9uJ3Qgd29yayBpbiB7Zm5hbWV9LCB1c2UKCQl8ZXhwYW5kKCl8IGZpcnN0IHRoZW4uCgpmb2xkY2xvc2VkKHtsbnVtfSkJCQkJCSpmb2xkY2xvc2VkKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlci4gIElmIHRoZSBsaW5lIHtsbnVtfSBpcyBpbiBhIGNsb3NlZAoJCWZvbGQsIHRoZSByZXN1bHQgaXMgdGhlIG51bWJlciBvZiB0aGUgZmlyc3QgbGluZSBpbiB0aGF0IGZvbGQuCgkJSWYgdGhlIGxpbmUge2xudW19IGlzIG5vdCBpbiBhIGNsb3NlZCBmb2xkLCAtMSBpcyByZXR1cm5lZC4KCmZvbGRjbG9zZWRlbmQoe2xudW19KQkJCQkJKmZvbGRjbG9zZWRlbmQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLiAgSWYgdGhlIGxpbmUge2xudW19IGlzIGluIGEgY2xvc2VkCgkJZm9sZCwgdGhlIHJlc3VsdCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBsYXN0IGxpbmUgaW4gdGhhdCBmb2xkLgoJCUlmIHRoZSBsaW5lIHtsbnVtfSBpcyBub3QgaW4gYSBjbG9zZWQgZm9sZCwgLTEgaXMgcmV0dXJuZWQuCgpmb2xkbGV2ZWwoe2xudW19KQkJCQkJKmZvbGRsZXZlbCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBmb2xkbGV2ZWwgb2YgbGluZSB7bG51bX0KCQlpbiB0aGUgY3VycmVudCBidWZmZXIuCUZvciBuZXN0ZWQgZm9sZHMgdGhlIGRlZXBlc3QgbGV2ZWwgaXMKCQlyZXR1cm5lZC4gIElmIHRoZXJlIGlzIG5vIGZvbGQgYXQgbGluZSB7bG51bX0sIHplcm8gaXMKCQlyZXR1cm5lZC4gIEl0IGRvZXNuJ3QgbWF0dGVyIGlmIHRoZSBmb2xkcyBhcmUgb3BlbiBvciBjbG9zZWQuCgkJV2hlbiB1c2VkIHdoaWxlIHVwZGF0aW5nIGZvbGRzIChmcm9tICdmb2xkZXhwcicpIC0xIGlzCgkJcmV0dXJuZWQgZm9yIGxpbmVzIHdoZXJlIGZvbGRzIGFyZSBzdGlsbCB0byBiZSB1cGRhdGVkIGFuZCB0aGUKCQlmb2xkbGV2ZWwgaXMgdW5rbm93bi4gIEFzIGEgc3BlY2lhbCBjYXNlIHRoZSBsZXZlbCBvZiB0aGUKCQlwcmV2aW91cyBsaW5lIGlzIHVzdWFsbHkgYXZhaWxhYmxlLgoKCQkJCQkJCSpmb2xkdGV4dCgpKgpmb2xkdGV4dCgpCVJldHVybnMgYSBTdHJpbmcsIHRvIGJlIGRpc3BsYXllZCBmb3IgYSBjbG9zZWQgZm9sZC4gIFRoaXMgaXMKCQl0aGUgZGVmYXVsdCBmdW5jdGlvbiB1c2VkIGZvciB0aGUgJ2ZvbGR0ZXh0JyBvcHRpb24gYW5kIHNob3VsZAoJCW9ubHkgYmUgY2FsbGVkIGZyb20gZXZhbHVhdGluZyAnZm9sZHRleHQnLiAgSXQgdXNlcyB0aGUKCQl8djpmb2xkc3RhcnR8LCB8djpmb2xkZW5kfCBhbmQgfHY6Zm9sZGRhc2hlc3wgdmFyaWFibGVzLgoJCVRoZSByZXR1cm5lZCBzdHJpbmcgbG9va3MgbGlrZSB0aGlzOiA+CgkJCSstLSA0NSBsaW5lczogYWJjZGVmCjwJCVRoZSBudW1iZXIgb2YgZGFzaGVzIGRlcGVuZHMgb24gdGhlIGZvbGRsZXZlbC4JVGhlICI0NSIgaXMKCQl0aGUgbnVtYmVyIG9mIGxpbmVzIGluIHRoZSBmb2xkLiAgImFiY2RlZiIgaXMgdGhlIHRleHQgaW4gdGhlCgkJZmlyc3Qgbm9uLWJsYW5rIGxpbmUgb2YgdGhlIGZvbGQuICBMZWFkaW5nIHdoaXRlIHNwYWNlLCAiLy8iCgkJb3IgIi8qIiBhbmQgdGhlIHRleHQgZnJvbSB0aGUgJ2ZvbGRtYXJrZXInIGFuZCAnY29tbWVudHN0cmluZycKCQlvcHRpb25zIGlzIHJlbW92ZWQuCgkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8IGZlYXR1cmV9Cgpmb2xkdGV4dHJlc3VsdCh7bG51bX0pCQkJCQkqZm9sZHRleHRyZXN1bHQoKSoKCQlSZXR1cm5zIHRoZSB0ZXh0IHRoYXQgaXMgZGlzcGxheWVkIGZvciB0aGUgY2xvc2VkIGZvbGQgYXQgbGluZQoJCXtsbnVtfS4gIEV2YWx1YXRlcyAnZm9sZHRleHQnIGluIHRoZSBhcHByb3ByaWF0ZSBjb250ZXh0LgoJCVdoZW4gdGhlcmUgaXMgbm8gY2xvc2VkIGZvbGQgYXQge2xudW19IGFuIGVtcHR5IHN0cmluZyBpcwoJCXJldHVybmVkLgoJCXtsbnVtfSBpcyB1c2VkIGxpa2Ugd2l0aCB8Z2V0bGluZSgpfC4gIFRodXMgIi4iIGlzIHRoZSBjdXJyZW50CgkJbGluZSwgIidtIiBtYXJrIG0sIGV0Yy4KCQlVc2VmdWwgd2hlbiBleHBvcnRpbmcgZm9sZGVkIHRleHQsIGUuZy4sIHRvIEhUTUwuCgkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8IGZlYXR1cmV9CgoJCQkJCQkJKmZvcmVncm91bmQoKSoKZm9yZWdyb3VuZCgpCU1vdmUgdGhlIFZpbSB3aW5kb3cgdG8gdGhlIGZvcmVncm91bmQuCVVzZWZ1bCB3aGVuIHNlbnQgZnJvbQoJCWEgY2xpZW50IHRvIGEgVmltIHNlcnZlci4gfHJlbW90ZV9zZW5kKCl8CgkJT24gV2luMzIgc3lzdGVtcyB0aGlzIG1pZ2h0IG5vdCB3b3JrLCB0aGUgT1MgZG9lcyBub3QgYWx3YXlzCgkJYWxsb3cgYSB3aW5kb3cgdG8gYnJpbmcgaXRzZWxmIHRvIHRoZSBmb3JlZ3JvdW5kLiAgVXNlCgkJfHJlbW90ZV9mb3JlZ3JvdW5kKCl8IGluc3RlYWQuCgkJe29ubHkgaW4gdGhlIFdpbjMyLCBBdGhlbmEsIE1vdGlmIGFuZCBHVEsgR1VJIHZlcnNpb25zIGFuZCB0aGUKCQlXaW4zMiBjb25zb2xlIHZlcnNpb259CgoKCQkJCQkqZnVuY3Rpb24oKSogKkU3MDAqICpFOTIyKiAqRTkyMyoKZnVuY3Rpb24oe25hbWV9IFssIHthcmdsaXN0fV0gWywge2RpY3R9XSkKCQlSZXR1cm4gYSB8RnVuY3JlZnwgdmFyaWFibGUgdGhhdCByZWZlcnMgdG8gZnVuY3Rpb24ge25hbWV9LgoJCXtuYW1lfSBjYW4gYmUgdGhlIG5hbWUgb2YgYSB1c2VyIGRlZmluZWQgZnVuY3Rpb24gb3IgYW4KCQlpbnRlcm5hbCBmdW5jdGlvbi4KCgkJe25hbWV9IGNhbiBhbHNvIGJlIGEgRnVuY3JlZiwgYWxzbyBhIHBhcnRpYWwuICBXaGVuIGl0IGlzIGEKCQlwYXJ0aWFsIHRoZSBkaWN0IHN0b3JlZCBpbiBpdCB3aWxsIGJlIHVzZWQgYW5kIHRoZSB7ZGljdH0KCQlhcmd1bWVudCBpcyBub3QgYWxsb3dlZC4gRS5nLjogPgoJCQlsZXQgRnVuY1dpdGhBcmcgPSBmdW5jdGlvbihkaWN0LkZ1bmMsIFthcmddKQoJCQlsZXQgQnJva2VuID0gZnVuY3Rpb24oZGljdC5GdW5jLCBbYXJnXSwgZGljdCkKPAoJCVdoZW4ge2FyZ2xpc3R9IG9yIHtkaWN0fSBpcyBwcmVzZW50IHRoaXMgY3JlYXRlcyBhIHBhcnRpYWwuCgkJVGhhdCBtZWFucyB0aGUgYXJndW1lbnQgbGlzdCBhbmQvb3IgdGhlIGRpY3Rpb25hcnkgaXMgc3RvcmVkIGluCgkJdGhlIEZ1bmNyZWYgYW5kIHdpbGwgYmUgdXNlZCB3aGVuIHRoZSBGdW5jcmVmIGlzIGNhbGxlZC4KCQkKCQlUaGUgYXJndW1lbnRzIGFyZSBwYXNzZWQgdG8gdGhlIGZ1bmN0aW9uIGluIGZyb250IG9mIG90aGVyCgkJYXJndW1lbnRzLiAgRXhhbXBsZTogPgoJCQlmdW5jIENhbGxiYWNrKGFyZzEsIGFyZzIsIG5hbWUpCgkJCS4uLgoJCQlsZXQgRnVuYyA9IGZ1bmN0aW9uKCdDYWxsYmFjaycsIFsnb25lJywgJ3R3byddKQoJCQkuLi4KCQkJY2FsbCBGdW5jKCduYW1lJykKPAkJSW52b2tlcyB0aGUgZnVuY3Rpb24gYXMgd2l0aDogPgoJCQljYWxsIENhbGxiYWNrKCdvbmUnLCAndHdvJywgJ25hbWUnKQoKPAkJVGhlIGZ1bmN0aW9uKCkgY2FsbCBjYW4gYmUgbmVzdGVkIHRvIGFkZCBtb3JlIGFyZ3VtZW50cyB0byB0aGUKCQlGdW5jcmVmLiAgVGhlIGV4dHJhIGFyZ3VtZW50cyBhcmUgYXBwZW5kZWQgdG8gdGhlIGxpc3Qgb2YKCQlhcmd1bWVudHMuICBFeGFtcGxlOiA+CgkJCWZ1bmMgQ2FsbGJhY2soYXJnMSwgYXJnMiwgbmFtZSkKCQkJLi4uCgkJCWxldCBGdW5jID0gZnVuY3Rpb24oJ0NhbGxiYWNrJywgWydvbmUnXSkKCQkJbGV0IEZ1bmMyID0gZnVuY3Rpb24oRnVuYywgWyd0d28nXSkKCQkJLi4uCgkJCWNhbGwgRnVuYzIoJ25hbWUnKQo8CQlJbnZva2VzIHRoZSBmdW5jdGlvbiBhcyB3aXRoOiA+CgkJCWNhbGwgQ2FsbGJhY2soJ29uZScsICd0d28nLCAnbmFtZScpCgo8CQlUaGUgRGljdGlvbmFyeSBpcyBvbmx5IHVzZWZ1bCB3aGVuIGNhbGxpbmcgYSAiZGljdCIgZnVuY3Rpb24uCgkJSW4gdGhhdCBjYXNlIHRoZSB7ZGljdH0gaXMgcGFzc2VkIGluIGFzICJzZWxmIi4gRXhhbXBsZTogPgoJCQlmdW5jdGlvbiBDYWxsYmFjaygpIGRpY3QKCQkJICAgZWNobyAiY2FsbGVkIGZvciAiIC4gc2VsZi5uYW1lCgkJCWVuZGZ1bmN0aW9uCgkJCS4uLgoJCQlsZXQgY29udGV4dCA9IHsibmFtZSI6ICJleGFtcGxlIn0KCQkJbGV0IEZ1bmMgPSBmdW5jdGlvbignQ2FsbGJhY2snLCBjb250ZXh0KQoJCQkuLi4KCQkJY2FsbCBGdW5jKCkJIiB3aWxsIGVjaG86IGNhbGxlZCBmb3IgZXhhbXBsZQo8CQlUaGUgdXNlIG9mIGZ1bmN0aW9uKCkgaXMgbm90IG5lZWRlZCB3aGVuIHRoZXJlIGFyZSBubyBleHRyYQoJCWFyZ3VtZW50cywgdGhlc2UgdHdvIGFyZSBlcXVpdmFsZW50OiA+CgkJCWxldCBGdW5jID0gZnVuY3Rpb24oJ0NhbGxiYWNrJywgY29udGV4dCkKCQkJbGV0IEZ1bmMgPSBjb250ZXh0LkNhbGxiYWNrCgo8CQlUaGUgYXJndW1lbnQgbGlzdCBhbmQgdGhlIERpY3Rpb25hcnkgY2FuIGJlIGNvbWJpbmVkOiA+CgkJCWZ1bmN0aW9uIENhbGxiYWNrKGFyZzEsIGNvdW50KSBkaWN0CgkJCS4uLgoJCQlsZXQgY29udGV4dCA9IHsibmFtZSI6ICJleGFtcGxlIn0KCQkJbGV0IEZ1bmMgPSBmdW5jdGlvbignQ2FsbGJhY2snLCBbJ29uZSddLCBjb250ZXh0KQoJCQkuLi4KCQkJY2FsbCBGdW5jKDUwMCkKPAkJSW52b2tlcyB0aGUgZnVuY3Rpb24gYXMgd2l0aDogPgoJCQljYWxsIGNvbnRleHQuQ2FsbGJhY2soJ29uZScsIDUwMCkKCgpnYXJiYWdlY29sbGVjdChbe2F0ZXhpdH1dKQkJCQkqZ2FyYmFnZWNvbGxlY3QoKSoKCQlDbGVhbnVwIHVudXNlZCB8TGlzdHN8LCB8RGljdGlvbmFyaWVzfCwgfENoYW5uZWxzfCBhbmQgfEpvYnN8CgkJdGhhdCBoYXZlIGNpcmN1bGFyIHJlZmVyZW5jZXMuCgkJCgkJVGhlcmUgaXMgaGFyZGx5IGV2ZXIgYSBuZWVkIHRvIGludm9rZSB0aGlzIGZ1bmN0aW9uLCBhcyBpdCBpcwoJCWF1dG9tYXRpY2FsbHkgZG9uZSB3aGVuIFZpbSBydW5zIG91dCBvZiBtZW1vcnkgb3IgaXMgd2FpdGluZwoJCWZvciB0aGUgdXNlciB0byBwcmVzcyBhIGtleSBhZnRlciAndXBkYXRldGltZScuICBJdGVtcyB3aXRob3V0CgkJY2lyY3VsYXIgcmVmZXJlbmNlcyBhcmUgYWx3YXlzIGZyZWVkIHdoZW4gdGhleSBiZWNvbWUgdW51c2VkLgoJCVRoaXMgaXMgdXNlZnVsIGlmIHlvdSBoYXZlIGRlbGV0ZWQgYSB2ZXJ5IGJpZyB8TGlzdHwgYW5kL29yCgkJfERpY3Rpb25hcnl8IHdpdGggY2lyY3VsYXIgcmVmZXJlbmNlcyBpbiBhIHNjcmlwdCB0aGF0IHJ1bnMKCQlmb3IgYSBsb25nIHRpbWUuCgoJCVdoZW4gdGhlIG9wdGlvbmFsIHthdGV4aXR9IGFyZ3VtZW50IGlzIG9uZSwgZ2FyYmFnZQoJCWNvbGxlY3Rpb24gd2lsbCBhbHNvIGJlIGRvbmUgd2hlbiBleGl0aW5nIFZpbSwgaWYgaXQgd2Fzbid0CgkJZG9uZSBiZWZvcmUuICBUaGlzIGlzIHVzZWZ1bCB3aGVuIGNoZWNraW5nIGZvciBtZW1vcnkgbGVha3MuCgoJCVRoZSBnYXJiYWdlIGNvbGxlY3Rpb24gaXMgbm90IGRvbmUgaW1tZWRpYXRlbHkgYnV0IG9ubHkgd2hlbgoJCWl0J3Mgc2FmZSB0byBwZXJmb3JtLiAgVGhpcyBpcyB3aGVuIHdhaXRpbmcgZm9yIHRoZSB1c2VyIHRvCgkJdHlwZSBhIGNoYXJhY3Rlci4gIFRvIGZvcmNlIGdhcmJhZ2UgY29sbGVjdGlvbiBpbW1lZGlhdGVseSB1c2UKCQl8dGVzdF9nYXJiYWdlY29sbGVjdF9ub3coKXwuCgpnZXQoe2xpc3R9LCB7aWR4fSBbLCB7ZGVmYXVsdH1dKQkJCSpnZXQoKSoKCQlHZXQgaXRlbSB7aWR4fSBmcm9tIHxMaXN0fCB7bGlzdH0uICBXaGVuIHRoaXMgaXRlbSBpcyBub3QKCQlhdmFpbGFibGUgcmV0dXJuIHtkZWZhdWx0fS4gIFJldHVybiB6ZXJvIHdoZW4ge2RlZmF1bHR9IGlzCgkJb21pdHRlZC4KZ2V0KHtkaWN0fSwge2tleX0gWywge2RlZmF1bHR9XSkKCQlHZXQgaXRlbSB3aXRoIGtleSB7a2V5fSBmcm9tIHxEaWN0aW9uYXJ5fCB7ZGljdH0uICBXaGVuIHRoaXMKCQlpdGVtIGlzIG5vdCBhdmFpbGFibGUgcmV0dXJuIHtkZWZhdWx0fS4gIFJldHVybiB6ZXJvIHdoZW4KCQl7ZGVmYXVsdH0gaXMgb21pdHRlZC4KZ2V0KHtwYXJ0aWFsfSwge3doYXR9KQoJCUdldCBhbiBpdGVtIHdpdGggZnJvbSBGdW5jcmVmIHtwYXJ0aWFsfS4gIFBvc3NpYmxlIHZhbHVlcyBmb3IKCQl7d2hhdH0gYXJlOgoJCQknZnVuYycJVGhlIGZ1bmN0aW9uCgkJCSdkaWN0JwlUaGUgZGljdGlvbmFyeQoJCQknYXJncycJVGhlIGxpc3Qgd2l0aCBhcmd1bWVudHMKCgkJCQkJCQkqZ2V0YnVmbGluZSgpKgpnZXRidWZsaW5lKHtleHByfSwge2xudW19IFssIHtlbmR9XSkKCQlSZXR1cm4gYSB8TGlzdHwgd2l0aCB0aGUgbGluZXMgc3RhcnRpbmcgZnJvbSB7bG51bX0gdG8ge2VuZH0KCQkoaW5jbHVzaXZlKSBpbiB0aGUgYnVmZmVyIHtleHByfS4gIElmIHtlbmR9IGlzIG9taXR0ZWQsIGEKCQl8TGlzdHwgd2l0aCBvbmx5IHRoZSBsaW5lIHtsbnVtfSBpcyByZXR1cm5lZC4KCgkJRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9LCBzZWUgfGJ1Zm5hbWUoKXwgYWJvdmUuCgoJCUZvciB7bG51bX0gYW5kIHtlbmR9ICIkIiBjYW4gYmUgdXNlZCBmb3IgdGhlIGxhc3QgbGluZSBvZiB0aGUKCQlidWZmZXIuICBPdGhlcndpc2UgYSBudW1iZXIgbXVzdCBiZSB1c2VkLgoKCQlXaGVuIHtsbnVtfSBpcyBzbWFsbGVyIHRoYW4gMSBvciBiaWdnZXIgdGhhbiB0aGUgbnVtYmVyIG9mCgkJbGluZXMgaW4gdGhlIGJ1ZmZlciwgYW4gZW1wdHkgfExpc3R8IGlzIHJldHVybmVkLgoKCQlXaGVuIHtlbmR9IGlzIGdyZWF0ZXIgdGhhbiB0aGUgbnVtYmVyIG9mIGxpbmVzIGluIHRoZSBidWZmZXIsCgkJaXQgaXMgdHJlYXRlZCBhcyB7ZW5kfSBpcyBzZXQgdG8gdGhlIG51bWJlciBvZiBsaW5lcyBpbiB0aGUKCQlidWZmZXIuICBXaGVuIHtlbmR9IGlzIGJlZm9yZSB7bG51bX0gYW4gZW1wdHkgfExpc3R8IGlzCgkJcmV0dXJuZWQuCgoJCVRoaXMgZnVuY3Rpb24gd29ya3Mgb25seSBmb3IgbG9hZGVkIGJ1ZmZlcnMuICBGb3IgdW5sb2FkZWQgYW5kCgkJbm9uLWV4aXN0aW5nIGJ1ZmZlcnMsIGFuIGVtcHR5IHxMaXN0fCBpcyByZXR1cm5lZC4KCgkJRXhhbXBsZTogPgoJCQk6bGV0IGxpbmVzID0gZ2V0YnVmbGluZShidWZucigibXlmaWxlIiksIDEsICIkIikKCmdldGJ1ZnZhcih7ZXhwcn0sIHt2YXJuYW1lfSBbLCB7ZGVmfV0pCQkJCSpnZXRidWZ2YXIoKSoKCQlUaGUgcmVzdWx0IGlzIHRoZSB2YWx1ZSBvZiBvcHRpb24gb3IgbG9jYWwgYnVmZmVyIHZhcmlhYmxlCgkJe3Zhcm5hbWV9IGluIGJ1ZmZlciB7ZXhwcn0uICBOb3RlIHRoYXQgdGhlIG5hbWUgd2l0aG91dCAiYjoiCgkJbXVzdCBiZSB1c2VkLgoJCVdoZW4ge3Zhcm5hbWV9IGlzIGVtcHR5IHJldHVybnMgYSBkaWN0aW9uYXJ5IHdpdGggYWxsIHRoZQoJCWJ1ZmZlci1sb2NhbCB2YXJpYWJsZXMuCgkJVGhpcyBhbHNvIHdvcmtzIGZvciBhIGdsb2JhbCBvciBidWZmZXItbG9jYWwgb3B0aW9uLCBidXQgaXQKCQlkb2Vzbid0IHdvcmsgZm9yIGEgZ2xvYmFsIHZhcmlhYmxlLCB3aW5kb3ctbG9jYWwgdmFyaWFibGUgb3IKCQl3aW5kb3ctbG9jYWwgb3B0aW9uLgoJCUZvciB0aGUgdXNlIG9mIHtleHByfSwgc2VlIHxidWZuYW1lKCl8IGFib3ZlLgoJCVdoZW4gdGhlIGJ1ZmZlciBvciB2YXJpYWJsZSBkb2Vzbid0IGV4aXN0IHtkZWZ9IG9yIGFuIGVtcHR5CgkJc3RyaW5nIGlzIHJldHVybmVkLCB0aGVyZSBpcyBubyBlcnJvciBtZXNzYWdlLgoJCUV4YW1wbGVzOiA+CgkJCTpsZXQgYnVmbW9kaWZpZWQgPSBnZXRidWZ2YXIoMSwgIiZtb2QiKQoJCQk6ZWNobyAidG9kbyBteXZhciA9ICIgLiBnZXRidWZ2YXIoInRvZG8iLCAibXl2YXIiKQo8CmdldGNoYXIoW2V4cHJdKQkJCQkJCSpnZXRjaGFyKCkqCgkJR2V0IGEgc2luZ2xlIGNoYXJhY3RlciBmcm9tIHRoZSB1c2VyIG9yIGlucHV0IHN0cmVhbS4KCQlJZiBbZXhwcl0gaXMgb21pdHRlZCwgd2FpdCB1bnRpbCBhIGNoYXJhY3RlciBpcyBhdmFpbGFibGUuCgkJSWYgW2V4cHJdIGlzIDAsIG9ubHkgZ2V0IGEgY2hhcmFjdGVyIHdoZW4gb25lIGlzIGF2YWlsYWJsZS4KCQkJUmV0dXJuIHplcm8gb3RoZXJ3aXNlLgoJCUlmIFtleHByXSBpcyAxLCBvbmx5IGNoZWNrIGlmIGEgY2hhcmFjdGVyIGlzIGF2YWlsYWJsZSwgaXQgaXMKCQkJbm90IGNvbnN1bWVkLiAgUmV0dXJuIHplcm8gaWYgbm8gY2hhcmFjdGVyIGF2YWlsYWJsZS4KCgkJV2l0aG91dCBbZXhwcl0gYW5kIHdoZW4gW2V4cHJdIGlzIDAgYSB3aG9sZSBjaGFyYWN0ZXIgb3IKCQlzcGVjaWFsIGtleSBpcyByZXR1cm5lZC4gIElmIGl0IGlzIGFuIDgtYml0IGNoYXJhY3RlciwgdGhlCgkJcmVzdWx0IGlzIGEgbnVtYmVyLiAgVXNlIG5yMmNoYXIoKSB0byBjb252ZXJ0IGl0IHRvIGEgU3RyaW5nLgoJCU90aGVyd2lzZSBhIFN0cmluZyBpcyByZXR1cm5lZCB3aXRoIHRoZSBlbmNvZGVkIGNoYXJhY3Rlci4KCQlGb3IgYSBzcGVjaWFsIGtleSBpdCdzIGEgc2VxdWVuY2Ugb2YgYnl0ZXMgc3RhcnRpbmcgd2l0aCAweDgwCgkJKGRlY2ltYWw6IDEyOCkuICBUaGlzIGlzIHRoZSBzYW1lIHZhbHVlIGFzIHRoZSBzdHJpbmcKCQkiXDxLZXk+IiwgZS5nLiwgIlw8TGVmdD4iLiAgVGhlIHJldHVybmVkIHZhbHVlIGlzIGFsc28gYQoJCVN0cmluZyB3aGVuIGEgbW9kaWZpZXIgKHNoaWZ0LCBjb250cm9sLCBhbHQpIHdhcyB1c2VkIHRoYXQgaXMKCQlub3QgaW5jbHVkZWQgaW4gdGhlIGNoYXJhY3Rlci4KCgkJV2hlbiBbZXhwcl0gaXMgMCBhbmQgRXNjIGlzIHR5cGVkLCB0aGVyZSB3aWxsIGJlIGEgc2hvcnQgZGVsYXkKCQl3aGlsZSBWaW0gd2FpdHMgdG8gc2VlIGlmIHRoaXMgaXMgdGhlIHN0YXJ0IG9mIGFuIGVzY2FwZQoJCXNlcXVlbmNlLgoKCQlXaGVuIFtleHByXSBpcyAxIG9ubHkgdGhlIGZpcnN0IGJ5dGUgaXMgcmV0dXJuZWQuICBGb3IgYQoJCW9uZS1ieXRlIGNoYXJhY3RlciBpdCBpcyB0aGUgY2hhcmFjdGVyIGl0c2VsZiBhcyBhIG51bWJlci4KCQlVc2UgbnIyY2hhcigpIHRvIGNvbnZlcnQgaXQgdG8gYSBTdHJpbmcuCgoJCVVzZSBnZXRjaGFybW9kKCkgdG8gb2J0YWluIGFueSBhZGRpdGlvbmFsIG1vZGlmaWVycy4KCgkJV2hlbiB0aGUgdXNlciBjbGlja3MgYSBtb3VzZSBidXR0b24sIHRoZSBtb3VzZSBldmVudCB3aWxsIGJlCgkJcmV0dXJuZWQuICBUaGUgcG9zaXRpb24gY2FuIHRoZW4gYmUgZm91bmQgaW4gfHY6bW91c2VfY29sfCwKCQl8djptb3VzZV9sbnVtfCBhbmQgfHY6bW91c2Vfd2lufC4gIFRoaXMgZXhhbXBsZSBwb3NpdGlvbnMgdGhlCgkJbW91c2UgYXMgaXQgd291bGQgbm9ybWFsbHkgaGFwcGVuOiA+CgkJCWxldCBjID0gZ2V0Y2hhcigpCgkJCWlmIGMgPT0gIlw8TGVmdE1vdXNlPiIgJiYgdjptb3VzZV93aW4gPiAwCgkJCSAgZXhlIHY6bW91c2Vfd2luIC4gIndpbmNtZCB3IgoJCQkgIGV4ZSB2Om1vdXNlX2xudW0KCQkJICBleGUgIm5vcm1hbCAiIC4gdjptb3VzZV9jb2wgLiAifCIKCQkJZW5kaWYKPAoJCVRoZXJlIGlzIG5vIHByb21wdCwgeW91IHdpbGwgc29tZWhvdyBoYXZlIHRvIG1ha2UgY2xlYXIgdG8gdGhlCgkJdXNlciB0aGF0IGEgY2hhcmFjdGVyIGhhcyB0byBiZSB0eXBlZC4KCQlUaGVyZSBpcyBubyBtYXBwaW5nIGZvciB0aGUgY2hhcmFjdGVyLgoJCUtleSBjb2RlcyBhcmUgcmVwbGFjZWQsIHRodXMgd2hlbiB0aGUgdXNlciBwcmVzc2VzIHRoZSA8RGVsPgoJCWtleSB5b3UgZ2V0IHRoZSBjb2RlIGZvciB0aGUgPERlbD4ga2V5LCBub3QgdGhlIHJhdyBjaGFyYWN0ZXIKCQlzZXF1ZW5jZS4gIEV4YW1wbGVzOiA+CgkJCWdldGNoYXIoKSA9PSAiXDxEZWw+IgoJCQlnZXRjaGFyKCkgPT0gIlw8Uy1MZWZ0PiIKPAkJVGhpcyBleGFtcGxlIHJlZGVmaW5lcyAiZiIgdG8gaWdub3JlIGNhc2U6ID4KCQkJOm5tYXAgZiA6Y2FsbCBGaW5kQ2hhcigpPENSPgoJCQk6ZnVuY3Rpb24gRmluZENoYXIoKQoJCQk6ICBsZXQgYyA9IG5yMmNoYXIoZ2V0Y2hhcigpKQoJCQk6ICB3aGlsZSBjb2woJy4nKSA8IGNvbCgnJCcpIC0gMQoJCQk6ICAgIG5vcm1hbCBsCgkJCTogICAgaWYgZ2V0bGluZSgnLicpW2NvbCgnLicpIC0gMV0gPT0/IGMKCQkJOiAgICAgIGJyZWFrCgkJCTogICAgZW5kaWYKCQkJOiAgZW5kd2hpbGUKCQkJOmVuZGZ1bmN0aW9uCjwKCQlZb3UgbWF5IGFsc28gcmVjZWl2ZSBzeW50aGV0aWMgY2hhcmFjdGVycywgc3VjaCBhcwoJCXw8Q3Vyc29ySG9sZD58LiBPZnRlbiB5b3Ugd2lsbCB3YW50IHRvIGlnbm9yZSB0aGlzIGFuZCBnZXQKCQlhbm90aGVyIGNoYXJhY3RlcjogPgoJCQk6ZnVuY3Rpb24gR2V0S2V5KCkKCQkJOiAgbGV0IGMgPSBnZXRjaGFyKCkKCQkJOiAgd2hpbGUgYyA9PSAiXDxDdXJzb3JIb2xkPiIKCQkJOiAgICBsZXQgYyA9IGdldGNoYXIoKQoJCQk6ICBlbmR3aGlsZQoJCQk6ICByZXR1cm4gYwoJCQk6ZW5kZnVuY3Rpb24KCmdldGNoYXJtb2QoKQkJCQkJCSpnZXRjaGFybW9kKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciB3aGljaCBpcyB0aGUgc3RhdGUgb2YgdGhlIG1vZGlmaWVycyBmb3IKCQl0aGUgbGFzdCBvYnRhaW5lZCBjaGFyYWN0ZXIgd2l0aCBnZXRjaGFyKCkgb3IgaW4gYW5vdGhlciB3YXkuCgkJVGhlc2UgdmFsdWVzIGFyZSBhZGRlZCB0b2dldGhlcjoKCQkJMglzaGlmdAoJCQk0CWNvbnRyb2wKCQkJOAlhbHQgKG1ldGEpCgkJCTE2CW1ldGEgKHdoZW4gaXQncyBkaWZmZXJlbnQgZnJvbSBBTFQpCgkJCTMyCW1vdXNlIGRvdWJsZSBjbGljawoJCQk2NAltb3VzZSB0cmlwbGUgY2xpY2sKCQkJOTYJbW91c2UgcXVhZHJ1cGxlIGNsaWNrICg9PSAzMiArIDY0KQoJCQkxMjgJY29tbWFuZCAoTWFjaW50b3NoIG9ubHkpCgkJT25seSB0aGUgbW9kaWZpZXJzIHRoYXQgaGF2ZSBub3QgYmVlbiBpbmNsdWRlZCBpbiB0aGUKCQljaGFyYWN0ZXIgaXRzZWxmIGFyZSBvYnRhaW5lZC4JVGh1cyBTaGlmdC1hIHJlc3VsdHMgaW4gIkEiCgkJd2l0aG91dCBhIG1vZGlmaWVyLgoKZ2V0Y2hhcnNlYXJjaCgpCQkJCQkJKmdldGNoYXJzZWFyY2goKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgY2hhcmFjdGVyIHNlYXJjaCBpbmZvcm1hdGlvbiBhcyBhIHtkaWN0fQoJCXdpdGggdGhlIGZvbGxvd2luZyBlbnRyaWVzOgoKCQkgICAgY2hhcgljaGFyYWN0ZXIgcHJldmlvdXNseSB1c2VkIGZvciBhIGNoYXJhY3RlcgoJCQkJc2VhcmNoICh8dHwsIHxmfCwgfFR8LCBvciB8RnwpOyBlbXB0eSBzdHJpbmcKCQkJCWlmIG5vIGNoYXJhY3RlciBzZWFyY2ggaGFzIGJlZW4gcGVyZm9ybWVkCgkJICAgIGZvcndhcmQJZGlyZWN0aW9uIG9mIGNoYXJhY3RlciBzZWFyY2g7IDEgZm9yIGZvcndhcmQsCgkJCQkwIGZvciBiYWNrd2FyZAoJCSAgICB1bnRpbAl0eXBlIG9mIGNoYXJhY3RlciBzZWFyY2g7IDEgZm9yIGEgfHR8IG9yIHxUfAoJCQkJY2hhcmFjdGVyIHNlYXJjaCwgMCBmb3IgYW4gfGZ8IG9yIHxGfAoJCQkJY2hhcmFjdGVyIHNlYXJjaAoKCQlUaGlzIGNhbiBiZSB1c2VmdWwgdG8gYWx3YXlzIGhhdmUgfDt8IGFuZCB8LHwgc2VhcmNoCgkJZm9yd2FyZC9iYWNrd2FyZCByZWdhcmRsZXNzIG9mIHRoZSBkaXJlY3Rpb24gb2YgdGhlIHByZXZpb3VzCgkJY2hhcmFjdGVyIHNlYXJjaDogPgoJCQk6bm5vcmVtYXAgPGV4cHI+IDsgZ2V0Y2hhcnNlYXJjaCgpLmZvcndhcmQgPyAnOycgOiAnLCcKCQkJOm5ub3JlbWFwIDxleHByPiAsIGdldGNoYXJzZWFyY2goKS5mb3J3YXJkID8gJywnIDogJzsnCjwJCUFsc28gc2VlIHxzZXRjaGFyc2VhcmNoKCl8LgoKZ2V0Y21kbGluZSgpCQkJCQkJKmdldGNtZGxpbmUoKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgY29tbWFuZC1saW5lLiAgT25seSB3b3JrcyB3aGVuIHRoZSBjb21tYW5kCgkJbGluZSBpcyBiZWluZyBlZGl0ZWQsIHRodXMgcmVxdWlyZXMgdXNlIG9mIHxjX0NUUkwtXF9lfCBvcgoJCXxjX0NUUkwtUl89fC4KCQlFeGFtcGxlOiA+CgkJCTpjbWFwIDxGNz4gPEMtXD5lZXNjYXBlKGdldGNtZGxpbmUoKSwgJyBcJyk8Q1I+CjwJCUFsc28gc2VlIHxnZXRjbWR0eXBlKCl8LCB8Z2V0Y21kcG9zKCl8IGFuZCB8c2V0Y21kcG9zKCl8LgoKZ2V0Y21kcG9zKCkJCQkJCQkqZ2V0Y21kcG9zKCkqCgkJUmV0dXJuIHRoZSBwb3NpdGlvbiBvZiB0aGUgY3Vyc29yIGluIHRoZSBjb21tYW5kIGxpbmUgYXMgYQoJCWJ5dGUgY291bnQuICBUaGUgZmlyc3QgY29sdW1uIGlzIDEuCgkJT25seSB3b3JrcyB3aGVuIGVkaXRpbmcgdGhlIGNvbW1hbmQgbGluZSwgdGh1cyByZXF1aXJlcyB1c2Ugb2YKCQl8Y19DVFJMLVxfZXwgb3IgfGNfQ1RSTC1SXz18IG9yIGFuIGV4cHJlc3Npb24gbWFwcGluZy4KCQlSZXR1cm5zIDAgb3RoZXJ3aXNlLgoJCUFsc28gc2VlIHxnZXRjbWR0eXBlKCl8LCB8c2V0Y21kcG9zKCl8IGFuZCB8Z2V0Y21kbGluZSgpfC4KCmdldGNtZHR5cGUoKQkJCQkJCSpnZXRjbWR0eXBlKCkqCgkJUmV0dXJuIHRoZSBjdXJyZW50IGNvbW1hbmQtbGluZSB0eXBlLiBQb3NzaWJsZSByZXR1cm4gdmFsdWVzCgkJYXJlOgoJCSAgICA6CW5vcm1hbCBFeCBjb21tYW5kCgkJICAgID4JZGVidWcgbW9kZSBjb21tYW5kIHxkZWJ1Zy1tb2RlfAoJCSAgICAvCWZvcndhcmQgc2VhcmNoIGNvbW1hbmQKCQkgICAgPwliYWNrd2FyZCBzZWFyY2ggY29tbWFuZAoJCSAgICBACXxpbnB1dCgpfCBjb21tYW5kCgkJICAgIC0JfDppbnNlcnR8IG9yIHw6YXBwZW5kfCBjb21tYW5kCgkJICAgID0JfGlfQ1RSTC1SXz18CgkJT25seSB3b3JrcyB3aGVuIGVkaXRpbmcgdGhlIGNvbW1hbmQgbGluZSwgdGh1cyByZXF1aXJlcyB1c2Ugb2YKCQl8Y19DVFJMLVxfZXwgb3IgfGNfQ1RSTC1SXz18IG9yIGFuIGV4cHJlc3Npb24gbWFwcGluZy4KCQlSZXR1cm5zIGFuIGVtcHR5IHN0cmluZyBvdGhlcndpc2UuCgkJQWxzbyBzZWUgfGdldGNtZHBvcygpfCwgfHNldGNtZHBvcygpfCBhbmQgfGdldGNtZGxpbmUoKXwuCgpnZXRjbWR3aW50eXBlKCkJCQkJCQkqZ2V0Y21kd2ludHlwZSgpKgoJCVJldHVybiB0aGUgY3VycmVudCB8Y29tbWFuZC1saW5lLXdpbmRvd3wgdHlwZS4gUG9zc2libGUgcmV0dXJuCgkJdmFsdWVzIGFyZSB0aGUgc2FtZSBhcyB8Z2V0Y21kdHlwZSgpfC4gUmV0dXJucyBhbiBlbXB0eSBzdHJpbmcKCQl3aGVuIG5vdCBpbiB0aGUgY29tbWFuZC1saW5lIHdpbmRvdy4KCgkJCQkJCQkqZ2V0Y3VycG9zKCkqCmdldGN1cnBvcygpCUdldCB0aGUgcG9zaXRpb24gb2YgdGhlIGN1cnNvci4gIFRoaXMgaXMgbGlrZSBnZXRwb3MoJy4nKSwgYnV0CgkJaW5jbHVkZXMgYW4gZXh0cmEgaXRlbSBpbiB0aGUgbGlzdDoKCQkgICAgW2J1Zm51bSwgbG51bSwgY29sLCBvZmYsIGN1cnN3YW50XSB+CgkJVGhlICJjdXJzd2FudCIgbnVtYmVyIGlzIHRoZSBwcmVmZXJyZWQgY29sdW1uIHdoZW4gbW92aW5nIHRoZQoJCWN1cnNvciB2ZXJ0aWNhbGx5LgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gc2F2ZSBhbmQgcmVzdG9yZSB0aGUgY3Vyc29yIHBvc2l0aW9uOiA+CgkJCWxldCBzYXZlX2N1cnNvciA9IGdldGN1cnBvcygpCgkJCU1vdmVUaGVDdXJzb3JBcm91bmQKCQkJY2FsbCBzZXRwb3MoJy4nLCBzYXZlX2N1cnNvcikKPAoJCQkJCQkJKmdldGN3ZCgpKgpnZXRjd2QoW3t3aW5ucn0gWywge3RhYm5yfV1dKQoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSBuYW1lIG9mIHRoZSBjdXJyZW50CgkJd29ya2luZyBkaXJlY3RvcnkuCgkJV2l0aG91dCBhcmd1bWVudHMsIGZvciB0aGUgY3VycmVudCB3aW5kb3cuCgoJCVdpdGgge3dpbm5yfSByZXR1cm4gdGhlIGxvY2FsIGN1cnJlbnQgZGlyZWN0b3J5IG9mIHRoaXMgd2luZG93CgkJaW4gdGhlIGN1cnJlbnQgdGFiIHBhZ2UuCgkJV2l0aCB7d2lubnJ9IGFuZCB7dGFibnJ9IHJldHVybiB0aGUgbG9jYWwgY3VycmVudCBkaXJlY3Rvcnkgb2YKCQl0aGUgd2luZG93IGluIHRoZSBzcGVjaWZpZWQgdGFiIHBhZ2UuCgkJUmV0dXJuIGFuIGVtcHR5IHN0cmluZyBpZiB0aGUgYXJndW1lbnRzIGFyZSBpbnZhbGlkLgoKZ2V0ZnNpemUoe2ZuYW1lfSkJCQkJCSpnZXRmc2l6ZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBzaXplIGluIGJ5dGVzIG9mIHRoZQoJCWdpdmVuIGZpbGUge2ZuYW1lfS4KCQlJZiB7Zm5hbWV9IGlzIGEgZGlyZWN0b3J5LCAwIGlzIHJldHVybmVkLgoJCUlmIHRoZSBmaWxlIHtmbmFtZX0gY2FuJ3QgYmUgZm91bmQsIC0xIGlzIHJldHVybmVkLgoJCUlmIHRoZSBzaXplIG9mIHtmbmFtZX0gaXMgdG9vIGJpZyB0byBmaXQgaW4gYSBOdW1iZXIgdGhlbiAtMgoJCWlzIHJldHVybmVkLgoKZ2V0Zm9udG5hbWUoW3tuYW1lfV0pCQkJCQkqZ2V0Zm9udG5hbWUoKSoKCQlXaXRob3V0IGFuIGFyZ3VtZW50IHJldHVybnMgdGhlIG5hbWUgb2YgdGhlIG5vcm1hbCBmb250IGJlaW5nCgkJdXNlZC4gIExpa2Ugd2hhdCBpcyB1c2VkIGZvciB0aGUgTm9ybWFsIGhpZ2hsaWdodCBncm91cAoJCXxobC1Ob3JtYWx8LgoJCVdpdGggYW4gYXJndW1lbnQgYSBjaGVjayBpcyBkb25lIHdoZXRoZXIge25hbWV9IGlzIGEgdmFsaWQKCQlmb250IG5hbWUuICBJZiBub3QgdGhlbiBhbiBlbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuCgkJT3RoZXJ3aXNlIHRoZSBhY3R1YWwgZm9udCBuYW1lIGlzIHJldHVybmVkLCBvciB7bmFtZX0gaWYgdGhlCgkJR1VJIGRvZXMgbm90IHN1cHBvcnQgb2J0YWluaW5nIHRoZSByZWFsIG5hbWUuCgkJT25seSB3b3JrcyB3aGVuIHRoZSBHVUkgaXMgcnVubmluZywgdGh1cyBub3QgaW4geW91ciB2aW1yYyBvcgoJCWd2aW1yYyBmaWxlLiAgVXNlIHRoZSB8R1VJRW50ZXJ8IGF1dG9jb21tYW5kIHRvIHVzZSB0aGlzCgkJZnVuY3Rpb24ganVzdCBhZnRlciB0aGUgR1VJIGhhcyBzdGFydGVkLgoJCU5vdGUgdGhhdCB0aGUgR1RLIDIgR1VJIGFjY2VwdHMgYW55IGZvbnQgbmFtZSwgdGh1cyBjaGVja2luZwoJCWZvciBhIHZhbGlkIG5hbWUgZG9lcyBub3Qgd29yay4KCmdldGZwZXJtKHtmbmFtZX0pCQkJCQkqZ2V0ZnBlcm0oKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUgcmVhZCwgd3JpdGUsIGFuZCBleGVjdXRlCgkJcGVybWlzc2lvbnMgb2YgdGhlIGdpdmVuIGZpbGUge2ZuYW1lfS4KCQlJZiB7Zm5hbWV9IGRvZXMgbm90IGV4aXN0IG9yIGl0cyBkaXJlY3RvcnkgY2Fubm90IGJlIHJlYWQsIGFuCgkJZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoJCVRoZSByZXN1bHQgaXMgb2YgdGhlIGZvcm0gInJ3eHJ3eHJ3eCIsIHdoZXJlIGVhY2ggZ3JvdXAgb2YKCQkicnd4IiBmbGFncyByZXByZXNlbnQsIGluIHR1cm4sIHRoZSBwZXJtaXNzaW9ucyBvZiB0aGUgb3duZXIKCQlvZiB0aGUgZmlsZSwgdGhlIGdyb3VwIHRoZSBmaWxlIGJlbG9uZ3MgdG8sIGFuZCBvdGhlciB1c2Vycy4KCQlJZiBhIHVzZXIgZG9lcyBub3QgaGF2ZSBhIGdpdmVuIHBlcm1pc3Npb24gdGhlIGZsYWcgZm9yIHRoaXMKCQlpcyByZXBsYWNlZCB3aXRoIHRoZSBzdHJpbmcgIi0iLiAgRXhhbXBsZXM6ID4KCQkJOmVjaG8gZ2V0ZnBlcm0oIi9ldGMvcGFzc3dkIikKCQkJOmVjaG8gZ2V0ZnBlcm0oZXhwYW5kKCJ+Ly52aW1yYyIpKQo8CQlUaGlzIHdpbGwgaG9wZWZ1bGx5IChmcm9tIGEgc2VjdXJpdHkgcG9pbnQgb2YgdmlldykgZGlzcGxheQoJCXRoZSBzdHJpbmcgInJ3LXItLXItLSIgb3IgZXZlbiAicnctLS0tLS0tIi4KCgkJRm9yIHNldHRpbmcgcGVybWlzc2lucyB1c2UgfHNldGZwZXJtKCl8LgoKZ2V0ZnRpbWUoe2ZuYW1lfSkJCQkJCSpnZXRmdGltZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBsYXN0IG1vZGlmaWNhdGlvbiB0aW1lIG9mCgkJdGhlIGdpdmVuIGZpbGUge2ZuYW1lfS4gIFRoZSB2YWx1ZSBpcyBtZWFzdXJlZCBhcyBzZWNvbmRzCgkJc2luY2UgMXN0IEphbiAxOTcwLCBhbmQgbWF5IGJlIHBhc3NlZCB0byBzdHJmdGltZSgpLiAgU2VlIGFsc28KCQl8bG9jYWx0aW1lKCl8IGFuZCB8c3RyZnRpbWUoKXwuCgkJSWYgdGhlIGZpbGUge2ZuYW1lfSBjYW4ndCBiZSBmb3VuZCAtMSBpcyByZXR1cm5lZC4KCmdldGZ0eXBlKHtmbmFtZX0pCQkJCQkqZ2V0ZnR5cGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyBhIGRlc2NyaXB0aW9uIG9mIHRoZSBraW5kIG9mCgkJZmlsZSBvZiB0aGUgZ2l2ZW4gZmlsZSB7Zm5hbWV9LgoJCUlmIHtmbmFtZX0gZG9lcyBub3QgZXhpc3QgYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoJCUhlcmUgaXMgYSB0YWJsZSBvdmVyIGRpZmZlcmVudCBraW5kcyBvZiBmaWxlcyBhbmQgdGhlaXIKCQlyZXN1bHRzOgoJCQlOb3JtYWwgZmlsZQkJImZpbGUiCgkJCURpcmVjdG9yeQkJImRpciIKCQkJU3ltYm9saWMgbGluawkJImxpbmsiCgkJCUJsb2NrIGRldmljZQkJImJkZXYiCgkJCUNoYXJhY3RlciBkZXZpY2UJImNkZXYiCgkJCVNvY2tldAkJCSJzb2NrZXQiCgkJCUZJRk8JCQkiZmlmbyIKCQkJQWxsIG90aGVyCQkib3RoZXIiCgkJRXhhbXBsZTogPgoJCQlnZXRmdHlwZSgiL2hvbWUiKQo8CQlOb3RlIHRoYXQgYSB0eXBlIHN1Y2ggYXMgImxpbmsiIHdpbGwgb25seSBiZSByZXR1cm5lZCBvbgoJCXN5c3RlbXMgdGhhdCBzdXBwb3J0IGl0LiAgT24gc29tZSBzeXN0ZW1zIG9ubHkgImRpciIgYW5kCgkJImZpbGUiIGFyZSByZXR1cm5lZC4gIE9uIE1TLVdpbmRvd3MgYSBzeW1ib2xpYyBsaW5rIHRvIGEKCQlkaXJlY3RvcnkgcmV0dXJucyAiZGlyIiBpbnN0ZWFkIG9mICJsaW5rIi4KCgkJCQkJCQkqZ2V0bGluZSgpKgpnZXRsaW5lKHtsbnVtfSBbLCB7ZW5kfV0pCgkJV2l0aG91dCB7ZW5kfSB0aGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyBsaW5lIHtsbnVtfQoJCWZyb20gdGhlIGN1cnJlbnQgYnVmZmVyLiAgRXhhbXBsZTogPgoJCQlnZXRsaW5lKDEpCjwJCVdoZW4ge2xudW19IGlzIGEgU3RyaW5nIHRoYXQgZG9lc24ndCBzdGFydCB3aXRoIGEKCQlkaWdpdCwgbGluZSgpIGlzIGNhbGxlZCB0byB0cmFuc2xhdGUgdGhlIFN0cmluZyBpbnRvIGEgTnVtYmVyLgoJCVRvIGdldCB0aGUgbGluZSB1bmRlciB0aGUgY3Vyc29yOiA+CgkJCWdldGxpbmUoIi4iKQo8CQlXaGVuIHtsbnVtfSBpcyBzbWFsbGVyIHRoYW4gMSBvciBiaWdnZXIgdGhhbiB0aGUgbnVtYmVyIG9mCgkJbGluZXMgaW4gdGhlIGJ1ZmZlciwgYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoKCQlXaGVuIHtlbmR9IGlzIGdpdmVuIHRoZSByZXN1bHQgaXMgYSB8TGlzdHwgd2hlcmUgZWFjaCBpdGVtIGlzCgkJYSBsaW5lIGZyb20gdGhlIGN1cnJlbnQgYnVmZmVyIGluIHRoZSByYW5nZSB7bG51bX0gdG8ge2VuZH0sCgkJaW5jbHVkaW5nIGxpbmUge2VuZH0uCgkJe2VuZH0gaXMgdXNlZCBpbiB0aGUgc2FtZSB3YXkgYXMge2xudW19LgoJCU5vbi1leGlzdGluZyBsaW5lcyBhcmUgc2lsZW50bHkgb21pdHRlZC4KCQlXaGVuIHtlbmR9IGlzIGJlZm9yZSB7bG51bX0gYW4gZW1wdHkgfExpc3R8IGlzIHJldHVybmVkLgoJCUV4YW1wbGU6ID4KCQkJOmxldCBzdGFydCA9IGxpbmUoJy4nKQoJCQk6bGV0IGVuZCA9IHNlYXJjaCgiXiQiKSAtIDEKCQkJOmxldCBsaW5lcyA9IGdldGxpbmUoc3RhcnQsIGVuZCkKCjwJCVRvIGdldCBsaW5lcyBmcm9tIGFub3RoZXIgYnVmZmVyIHNlZSB8Z2V0YnVmbGluZSgpfAoKZ2V0bG9jbGlzdCh7bnJ9KQkJCQkJKmdldGxvY2xpc3QoKSoKCQlSZXR1cm5zIGEgbGlzdCB3aXRoIGFsbCB0aGUgZW50cmllcyBpbiB0aGUgbG9jYXRpb24gbGlzdCBmb3IKCQl3aW5kb3cge25yfS4gV2hlbiB7bnJ9IGlzIHplcm8gdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuCgkJRm9yIGEgbG9jYXRpb24gbGlzdCB3aW5kb3csIHRoZSBkaXNwbGF5ZWQgbG9jYXRpb24gbGlzdCBpcwoJCXJldHVybmVkLiAgRm9yIGFuIGludmFsaWQgd2luZG93IG51bWJlciB7bnJ9LCBhbiBlbXB0eSBsaXN0IGlzCgkJcmV0dXJuZWQuIE90aGVyd2lzZSwgc2FtZSBhcyB8Z2V0cWZsaXN0KCl8LgoKZ2V0bWF0Y2hlcygpCQkJCQkJKmdldG1hdGNoZXMoKSoKCQlSZXR1cm5zIGEgfExpc3R8IHdpdGggYWxsIG1hdGNoZXMgcHJldmlvdXNseSBkZWZpbmVkIGJ5CgkJfG1hdGNoYWRkKCl8IGFuZCB0aGUgfDptYXRjaHwgY29tbWFuZHMuICB8Z2V0bWF0Y2hlcygpfCBpcwoJCXVzZWZ1bCBpbiBjb21iaW5hdGlvbiB3aXRoIHxzZXRtYXRjaGVzKCl8LCBhcyB8c2V0bWF0Y2hlcygpfAoJCWNhbiByZXN0b3JlIGEgbGlzdCBvZiBtYXRjaGVzIHNhdmVkIGJ5IHxnZXRtYXRjaGVzKCl8LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gZ2V0bWF0Y2hlcygpCjwJCQlbeydncm91cCc6ICdNeUdyb3VwMScsICdwYXR0ZXJuJzogJ1RPRE8nLAoJCQkncHJpb3JpdHknOiAxMCwgJ2lkJzogMX0sIHsnZ3JvdXAnOiAnTXlHcm91cDInLAoJCQkncGF0dGVybic6ICdGSVhNRScsICdwcmlvcml0eSc6IDEwLCAnaWQnOiAyfV0gPgoJCQk6bGV0IG0gPSBnZXRtYXRjaGVzKCkKCQkJOmNhbGwgY2xlYXJtYXRjaGVzKCkKCQkJOmVjaG8gZ2V0bWF0Y2hlcygpCjwJCQlbXSA+CgkJCTpjYWxsIHNldG1hdGNoZXMobSkKCQkJOmVjaG8gZ2V0bWF0Y2hlcygpCjwJCQlbeydncm91cCc6ICdNeUdyb3VwMScsICdwYXR0ZXJuJzogJ1RPRE8nLAoJCQkncHJpb3JpdHknOiAxMCwgJ2lkJzogMX0sIHsnZ3JvdXAnOiAnTXlHcm91cDInLAoJCQkncGF0dGVybic6ICdGSVhNRScsICdwcmlvcml0eSc6IDEwLCAnaWQnOiAyfV0gPgoJCQk6dW5sZXQgbQo8CgkJCQkJCQkqZ2V0cGlkKCkqCmdldHBpZCgpCVJldHVybiBhIE51bWJlciB3aGljaCBpcyB0aGUgcHJvY2VzcyBJRCBvZiB0aGUgVmltIHByb2Nlc3MuCgkJT24gVW5peCBhbmQgTVMtV2luZG93cyB0aGlzIGlzIGEgdW5pcXVlIG51bWJlciwgdW50aWwgVmltCgkJZXhpdHMuCU9uIE1TLURPUyBpdCdzIGFsd2F5cyB6ZXJvLgoKCQkJCQkJCSpnZXRwb3MoKSoKZ2V0cG9zKHtleHByfSkJR2V0IHRoZSBwb3NpdGlvbiBmb3Ige2V4cHJ9LiAgRm9yIHBvc3NpYmxlIHZhbHVlcyBvZiB7ZXhwcn0KCQlzZWUgfGxpbmUoKXwuICBGb3IgZ2V0dGluZyB0aGUgY3Vyc29yIHBvc2l0aW9uIHNlZQoJCXxnZXRjdXJwb3MoKXwuCgkJVGhlIHJlc3VsdCBpcyBhIHxMaXN0fCB3aXRoIGZvdXIgbnVtYmVyczoKCQkgICAgW2J1Zm51bSwgbG51bSwgY29sLCBvZmZdCgkJImJ1Zm51bSIgaXMgemVybywgdW5sZXNzIGEgbWFyayBsaWtlICcwIG9yICdBIGlzIHVzZWQsIHRoZW4gaXQKCQlpcyB0aGUgYnVmZmVyIG51bWJlciBvZiB0aGUgbWFyay4KCQkibG51bSIgYW5kICJjb2wiIGFyZSB0aGUgcG9zaXRpb24gaW4gdGhlIGJ1ZmZlci4gIFRoZSBmaXJzdAoJCWNvbHVtbiBpcyAxLgoJCVRoZSAib2ZmIiBudW1iZXIgaXMgemVybywgdW5sZXNzICd2aXJ0dWFsZWRpdCcgaXMgdXNlZC4gIFRoZW4KCQlpdCBpcyB0aGUgb2Zmc2V0IGluIHNjcmVlbiBjb2x1bW5zIGZyb20gdGhlIHN0YXJ0IG9mIHRoZQoJCWNoYXJhY3Rlci4gIEUuZy4sIGEgcG9zaXRpb24gd2l0aGluIGEgPFRhYj4gb3IgYWZ0ZXIgdGhlIGxhc3QKCQljaGFyYWN0ZXIuCgkJTm90ZSB0aGF0IGZvciAnPCBhbmQgJz4gVmlzdWFsIG1vZGUgbWF0dGVyczogd2hlbiBpdCBpcyAiViIKCQkodmlzdWFsIGxpbmUgbW9kZSkgdGhlIGNvbHVtbiBvZiAnPCBpcyB6ZXJvIGFuZCB0aGUgY29sdW1uIG9mCgkJJz4gaXMgYSBsYXJnZSBudW1iZXIuCgkJVGhpcyBjYW4gYmUgdXNlZCB0byBzYXZlIGFuZCByZXN0b3JlIHRoZSBwb3NpdGlvbiBvZiBhIG1hcms6ID4KCQkJbGV0IHNhdmVfYV9tYXJrID0gZ2V0cG9zKCInYSIpCgkJCS4uLgoJCQljYWxsIHNldHBvcygiJ2EiLCBzYXZlX2FfbWFyaykKPAkJQWxzbyBzZWUgfGdldGN1cnBvcygpfCBhbmQgfHNldHBvcygpfC4KCgpnZXRxZmxpc3QoKQkJCQkJCSpnZXRxZmxpc3QoKSoKCQlSZXR1cm5zIGEgbGlzdCB3aXRoIGFsbCB0aGUgY3VycmVudCBxdWlja2ZpeCBlcnJvcnMuICBFYWNoCgkJbGlzdCBpdGVtIGlzIGEgZGljdGlvbmFyeSB3aXRoIHRoZXNlIGVudHJpZXM6CgkJCWJ1Zm5yCW51bWJlciBvZiBidWZmZXIgdGhhdCBoYXMgdGhlIGZpbGUgbmFtZSwgdXNlCgkJCQlidWZuYW1lKCkgdG8gZ2V0IHRoZSBuYW1lCgkJCWxudW0JbGluZSBudW1iZXIgaW4gdGhlIGJ1ZmZlciAoZmlyc3QgbGluZSBpcyAxKQoJCQljb2wJY29sdW1uIG51bWJlciAoZmlyc3QgY29sdW1uIGlzIDEpCgkJCXZjb2wJbm9uLXplcm86ICJjb2wiIGlzIHZpc3VhbCBjb2x1bW4KCQkJCXplcm86ICJjb2wiIGlzIGJ5dGUgaW5kZXgKCQkJbnIJZXJyb3IgbnVtYmVyCgkJCXBhdHRlcm4Jc2VhcmNoIHBhdHRlcm4gdXNlZCB0byBsb2NhdGUgdGhlIGVycm9yCgkJCXRleHQJZGVzY3JpcHRpb24gb2YgdGhlIGVycm9yCgkJCXR5cGUJdHlwZSBvZiB0aGUgZXJyb3IsICdFJywgJzEnLCBldGMuCgkJCXZhbGlkCW5vbi16ZXJvOiByZWNvZ25pemVkIGVycm9yIG1lc3NhZ2UKCgkJV2hlbiB0aGVyZSBpcyBubyBlcnJvciBsaXN0IG9yIGl0J3MgZW1wdHkgYW4gZW1wdHkgbGlzdCBpcwoJCXJldHVybmVkLiBRdWlja2ZpeCBsaXN0IGVudHJpZXMgd2l0aCBub24tZXhpc3RpbmcgYnVmZmVyCgkJbnVtYmVyIGFyZSByZXR1cm5lZCB3aXRoICJidWZuciIgc2V0IHRvIHplcm8uCgoJCVVzZWZ1bCBhcHBsaWNhdGlvbjogRmluZCBwYXR0ZXJuIG1hdGNoZXMgaW4gbXVsdGlwbGUgZmlsZXMgYW5kCgkJZG8gc29tZXRoaW5nIHdpdGggdGhlbTogPgoJCQk6dmltZ3JlcCAvdGhld29yZC9qZyAqLmMKCQkJOmZvciBkIGluIGdldHFmbGlzdCgpCgkJCTogICBlY2hvIGJ1Zm5hbWUoZC5idWZucikgJzonIGQubG51bSAnPScgZC50ZXh0CgkJCTplbmRmb3IKCgpnZXRyZWcoW3tyZWduYW1lfSBbLCAxIFssIHtsaXN0fV1dXSkJCQkqZ2V0cmVnKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIGNvbnRlbnRzIG9mIHJlZ2lzdGVyCgkJe3JlZ25hbWV9LiAgRXhhbXBsZTogPgoJCQk6bGV0IGNsaXB0ZXh0ID0gZ2V0cmVnKCcqJykKPAkJV2hlbiB7cmVnbmFtZX0gd2FzIG5vdCBzZXQgdGhlIHJlc3VsdCBpcyBhIGVtcHR5IHN0cmluZy4KCgkJZ2V0cmVnKCc9JykgcmV0dXJucyB0aGUgbGFzdCBldmFsdWF0ZWQgdmFsdWUgb2YgdGhlIGV4cHJlc3Npb24KCQlyZWdpc3Rlci4gIChGb3IgdXNlIGluIG1hcHMuKQoJCWdldHJlZygnPScsIDEpIHJldHVybnMgdGhlIGV4cHJlc3Npb24gaXRzZWxmLCBzbyB0aGF0IGl0IGNhbgoJCWJlIHJlc3RvcmVkIHdpdGggfHNldHJlZygpfC4gIEZvciBvdGhlciByZWdpc3RlcnMgdGhlIGV4dHJhCgkJYXJndW1lbnQgaXMgaWdub3JlZCwgdGh1cyB5b3UgY2FuIGFsd2F5cyBnaXZlIGl0LgoKCQlJZiB7bGlzdH0gaXMgcHJlc2VudCBhbmQgbm9uLXplcm8sIHRoZSByZXN1bHQgdHlwZSBpcyBjaGFuZ2VkCgkJdG8gfExpc3R8LiBFYWNoIGxpc3QgaXRlbSBpcyBvbmUgdGV4dCBsaW5lLiBVc2UgaXQgaWYgeW91IGNhcmUKCQlhYm91dCB6ZXJvIGJ5dGVzIHBvc3NpYmx5IHByZXNlbnQgaW5zaWRlIHJlZ2lzdGVyOiB3aXRob3V0CgkJdGhpcmQgYXJndW1lbnQgYm90aCBOTHMgYW5kIHplcm8gYnl0ZXMgYXJlIHJlcHJlc2VudGVkIGFzIE5McwoJCShzZWUgfE5MLXVzZWQtZm9yLU51bHwpLgoJCVdoZW4gdGhlIHJlZ2lzdGVyIHdhcyBub3Qgc2V0IGFuIGVtcHR5IGxpc3QgaXMgcmV0dXJuZWQuCgoJCUlmIHtyZWduYW1lfSBpcyBub3Qgc3BlY2lmaWVkLCB8djpyZWdpc3RlcnwgaXMgdXNlZC4KCgpnZXRyZWd0eXBlKFt7cmVnbmFtZX1dKQkJCQkJKmdldHJlZ3R5cGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0eXBlIG9mIHJlZ2lzdGVyIHtyZWduYW1lfS4KCQlUaGUgdmFsdWUgd2lsbCBiZSBvbmUgb2Y6CgkJICAgICJ2IgkJCWZvciB8Y2hhcmFjdGVyd2lzZXwgdGV4dAoJCSAgICAiViIJCQlmb3IgfGxpbmV3aXNlfCB0ZXh0CgkJICAgICI8Q1RSTC1WPnt3aWR0aH0iCWZvciB8YmxvY2t3aXNlLXZpc3VhbHwgdGV4dAoJCSAgICAiIgkJCWZvciBhbiBlbXB0eSBvciB1bmtub3duIHJlZ2lzdGVyCgkJPENUUkwtVj4gaXMgb25lIGNoYXJhY3RlciB3aXRoIHZhbHVlIDB4MTYuCgkJSWYge3JlZ25hbWV9IGlzIG5vdCBzcGVjaWZpZWQsIHx2OnJlZ2lzdGVyfCBpcyB1c2VkLgoKZ2V0dGFidmFyKHt0YWJucn0sIHt2YXJuYW1lfSBbLCB7ZGVmfV0pCQkJCSpnZXR0YWJ2YXIoKSoKCQlHZXQgdGhlIHZhbHVlIG9mIGEgdGFiLWxvY2FsIHZhcmlhYmxlIHt2YXJuYW1lfSBpbiB0YWIgcGFnZQoJCXt0YWJucn0uIHx0OnZhcnwKCQlUYWJzIGFyZSBudW1iZXJlZCBzdGFydGluZyB3aXRoIG9uZS4KCQlXaGVuIHt2YXJuYW1lfSBpcyBlbXB0eSBhIGRpY3Rpb25hcnkgd2l0aCBhbGwgdGFiLWxvY2FsCgkJdmFyaWFibGVzIGlzIHJldHVybmVkLgoJCU5vdGUgdGhhdCB0aGUgbmFtZSB3aXRob3V0ICJ0OiIgbXVzdCBiZSB1c2VkLgoJCVdoZW4gdGhlIHRhYiBvciB2YXJpYWJsZSBkb2Vzbid0IGV4aXN0IHtkZWZ9IG9yIGFuIGVtcHR5CgkJc3RyaW5nIGlzIHJldHVybmVkLCB0aGVyZSBpcyBubyBlcnJvciBtZXNzYWdlLgoKZ2V0dGFid2ludmFyKHt0YWJucn0sIHt3aW5ucn0sIHt2YXJuYW1lfSBbLCB7ZGVmfV0pCQkqZ2V0dGFid2ludmFyKCkqCgkJR2V0IHRoZSB2YWx1ZSBvZiB3aW5kb3ctbG9jYWwgdmFyaWFibGUge3Zhcm5hbWV9IGluIHdpbmRvdwoJCXt3aW5ucn0gaW4gdGFiIHBhZ2Uge3RhYm5yfS4KCQlXaGVuIHt2YXJuYW1lfSBzdGFydHMgd2l0aCAiJiIgZ2V0IHRoZSB2YWx1ZSBvZiBhIHdpbmRvdy1sb2NhbAoJCW9wdGlvbi4KCQlXaGVuIHt2YXJuYW1lfSBpcyBlbXB0eSBhIGRpY3Rpb25hcnkgd2l0aCBhbGwgd2luZG93LWxvY2FsCgkJdmFyaWFibGVzIGlzIHJldHVybmVkLgoJCU5vdGUgdGhhdCB7dmFybmFtZX0gbXVzdCBiZSB0aGUgbmFtZSB3aXRob3V0ICJ3OiIuCgkJVGFicyBhcmUgbnVtYmVyZWQgc3RhcnRpbmcgd2l0aCBvbmUuICBGb3IgdGhlIGN1cnJlbnQgdGFicGFnZQoJCXVzZSB8Z2V0d2ludmFyKCl8LgoJCVdoZW4ge3dpbm5yfSBpcyB6ZXJvIHRoZSBjdXJyZW50IHdpbmRvdyBpcyB1c2VkLgoJCVRoaXMgYWxzbyB3b3JrcyBmb3IgYSBnbG9iYWwgb3B0aW9uLCBidWZmZXItbG9jYWwgb3B0aW9uIGFuZAoJCXdpbmRvdy1sb2NhbCBvcHRpb24sIGJ1dCBpdCBkb2Vzbid0IHdvcmsgZm9yIGEgZ2xvYmFsIHZhcmlhYmxlCgkJb3IgYnVmZmVyLWxvY2FsIHZhcmlhYmxlLgoJCVdoZW4gdGhlIHRhYiwgd2luZG93IG9yIHZhcmlhYmxlIGRvZXNuJ3QgZXhpc3Qge2RlZn0gb3IgYW4KCQllbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQsIHRoZXJlIGlzIG5vIGVycm9yIG1lc3NhZ2UuCgkJRXhhbXBsZXM6ID4KCQkJOmxldCBsaXN0X2lzX29uID0gZ2V0dGFid2ludmFyKDEsIDIsICcmbGlzdCcpCgkJCTplY2hvICJteXZhciA9ICIgLiBnZXR0YWJ3aW52YXIoMywgMSwgJ215dmFyJykKPAoJCQkJCQkJKmdldHdpbnBvc3goKSoKZ2V0d2lucG9zeCgpCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBYIGNvb3JkaW5hdGUgaW4gcGl4ZWxzIG9mCgkJdGhlIGxlZnQgaGFuZCBzaWRlIG9mIHRoZSBHVUkgVmltIHdpbmRvdy4gIFRoZSByZXN1bHQgd2lsbCBiZQoJCS0xIGlmIHRoZSBpbmZvcm1hdGlvbiBpcyBub3QgYXZhaWxhYmxlLgoKCQkJCQkJCSpnZXR3aW5wb3N5KCkqCmdldHdpbnBvc3koKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgWSBjb29yZGluYXRlIGluIHBpeGVscyBvZgoJCXRoZSB0b3Agb2YgdGhlIEdVSSBWaW0gd2luZG93LglUaGUgcmVzdWx0IHdpbGwgYmUgLTEgaWYgdGhlCgkJaW5mb3JtYXRpb24gaXMgbm90IGF2YWlsYWJsZS4KCmdldHdpbnZhcih7d2lubnJ9LCB7dmFybmFtZX0gWywge2RlZn1dKQkJCQkqZ2V0d2ludmFyKCkqCgkJTGlrZSB8Z2V0dGFid2ludmFyKCl8IGZvciB0aGUgY3VycmVudCB0YWJwYWdlLgoJCUV4YW1wbGVzOiA+CgkJCTpsZXQgbGlzdF9pc19vbiA9IGdldHdpbnZhcigyLCAnJmxpc3QnKQoJCQk6ZWNobyAibXl2YXIgPSAiIC4gZ2V0d2ludmFyKDEsICdteXZhcicpCjwKZ2xvYih7ZXhwcn0gWywge25vc3VmfSBbLCB7bGlzdH0gWywge2FsbGxpbmtzfV1dXSkJCSpnbG9iKCkqCgkJRXhwYW5kIHRoZSBmaWxlIHdpbGRjYXJkcyBpbiB7ZXhwcn0uICBTZWUgfHdpbGRjYXJkc3wgZm9yIHRoZQoJCXVzZSBvZiBzcGVjaWFsIGNoYXJhY3RlcnMuCgoJCVVubGVzcyB0aGUgb3B0aW9uYWwge25vc3VmfSBhcmd1bWVudCBpcyBnaXZlbiBhbmQgaXMgbm9uLXplcm8sCgkJdGhlICdzdWZmaXhlcycgYW5kICd3aWxkaWdub3JlJyBvcHRpb25zIGFwcGx5OiBOYW1lcyBtYXRjaGluZwoJCW9uZSBvZiB0aGUgcGF0dGVybnMgaW4gJ3dpbGRpZ25vcmUnIHdpbGwgYmUgc2tpcHBlZCBhbmQKCQknc3VmZml4ZXMnIGFmZmVjdCB0aGUgb3JkZXJpbmcgb2YgbWF0Y2hlcy4KCQknd2lsZGlnbm9yZWNhc2UnIGFsd2F5cyBhcHBsaWVzLgoKCQlXaGVuIHtsaXN0fSBpcyBwcmVzZW50IGFuZCBpdCBpcyBub24temVybyB0aGUgcmVzdWx0IGlzIGEgTGlzdAoJCXdpdGggYWxsIG1hdGNoaW5nIGZpbGVzLiBUaGUgYWR2YW50YWdlIG9mIHVzaW5nIGEgTGlzdCBpcywKCQl5b3UgYWxzbyBnZXQgZmlsZW5hbWVzIGNvbnRhaW5pbmcgbmV3bGluZXMgY29ycmVjdGx5LgoJCU90aGVyd2lzZSB0aGUgcmVzdWx0IGlzIGEgU3RyaW5nIGFuZCB3aGVuIHRoZXJlIGFyZSBzZXZlcmFsCgkJbWF0Y2hlcywgdGhleSBhcmUgc2VwYXJhdGVkIGJ5IDxOTD4gY2hhcmFjdGVycy4KCgkJSWYgdGhlIGV4cGFuc2lvbiBmYWlscywgdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBTdHJpbmcgb3IgTGlzdC4KCgkJQSBuYW1lIGZvciBhIG5vbi1leGlzdGluZyBmaWxlIGlzIG5vdCBpbmNsdWRlZC4gIEEgc3ltYm9saWMKCQlsaW5rIGlzIG9ubHkgaW5jbHVkZWQgaWYgaXQgcG9pbnRzIHRvIGFuIGV4aXN0aW5nIGZpbGUuCgkJSG93ZXZlciwgd2hlbiB0aGUge2FsbGxpbmtzfSBhcmd1bWVudCBpcyBwcmVzZW50IGFuZCBpdCBpcwoJCW5vbi16ZXJvIHRoZW4gYWxsIHN5bWJvbGljIGxpbmtzIGFyZSBpbmNsdWRlZC4KCgkJRm9yIG1vc3Qgc3lzdGVtcyBiYWNrdGlja3MgY2FuIGJlIHVzZWQgdG8gZ2V0IGZpbGVzIG5hbWVzIGZyb20KCQlhbnkgZXh0ZXJuYWwgY29tbWFuZC4gIEV4YW1wbGU6ID4KCQkJOmxldCB0YWdmaWxlcyA9IGdsb2IoImBmaW5kIC4gLW5hbWUgdGFncyAtcHJpbnRgIikKCQkJOmxldCAmdGFncyA9IHN1YnN0aXR1dGUodGFnZmlsZXMsICJcbiIsICIsIiwgImciKQo8CQlUaGUgcmVzdWx0IG9mIHRoZSBwcm9ncmFtIGluc2lkZSB0aGUgYmFja3RpY2tzIHNob3VsZCBiZSBvbmUKCQlpdGVtIHBlciBsaW5lLglTcGFjZXMgaW5zaWRlIGFuIGl0ZW0gYXJlIGFsbG93ZWQuCgoJCVNlZSB8ZXhwYW5kKCl8IGZvciBleHBhbmRpbmcgc3BlY2lhbCBWaW0gdmFyaWFibGVzLiAgU2VlCgkJfHN5c3RlbSgpfCBmb3IgZ2V0dGluZyB0aGUgcmF3IG91dHB1dCBvZiBhbiBleHRlcm5hbCBjb21tYW5kLgoKZ2xvYjJyZWdwYXQoe2V4cHJ9KQkJCQkJICpnbG9iMnJlZ3BhdCgpKgoJCUNvbnZlcnQgYSBmaWxlIHBhdHRlcm4sIGFzIHVzZWQgYnkgZ2xvYigpLCBpbnRvIGEgc2VhcmNoCgkJcGF0dGVybi4gIFRoZSByZXN1bHQgY2FuIGJlIHVzZWQgdG8gbWF0Y2ggd2l0aCBhIHN0cmluZyB0aGF0CgkJaXMgYSBmaWxlIG5hbWUuICBFLmcuID4KCQkJaWYgZmlsZW5hbWUgPX4gZ2xvYjJyZWdwYXQoJ01ha2UqLm1haycpCjwJCVRoaXMgaXMgZXF1aXZhbGVudCB0bzogPgoJCQlpZiBmaWxlbmFtZSA9fiAnXk1ha2UuKlwubWFrJCcKPAkJV2hlbiB7ZXhwcn0gaXMgYW4gZW1wdHkgc3RyaW5nIHRoZSByZXN1bHQgaXMgIl4kIiwgbWF0Y2ggYW4KCQllbXB0eSBzdHJpbmcuCgoJCQkJCQkJCSpnbG9icGF0aCgpKgpnbG9icGF0aCh7cGF0aH0sIHtleHByfSBbLCB7bm9zdWZ9IFssIHtsaXN0fSBbLCB7YWxsbGlua3N9XV1dKQoJCVBlcmZvcm0gZ2xvYigpIG9uIGFsbCBkaXJlY3RvcmllcyBpbiB7cGF0aH0gYW5kIGNvbmNhdGVuYXRlCgkJdGhlIHJlc3VsdHMuICBFeGFtcGxlOiA+CgkJCTplY2hvIGdsb2JwYXRoKCZydHAsICJzeW50YXgvYy52aW0iKQo8CgkJe3BhdGh9IGlzIGEgY29tbWEtc2VwYXJhdGVkIGxpc3Qgb2YgZGlyZWN0b3J5IG5hbWVzLiAgRWFjaAoJCWRpcmVjdG9yeSBuYW1lIGlzIHByZXBlbmRlZCB0byB7ZXhwcn0gYW5kIGV4cGFuZGVkIGxpa2Ugd2l0aAoJCXxnbG9iKCl8LiAgQSBwYXRoIHNlcGFyYXRvciBpcyBpbnNlcnRlZCB3aGVuIG5lZWRlZC4KCQlUbyBhZGQgYSBjb21tYSBpbnNpZGUgYSBkaXJlY3RvcnkgbmFtZSBlc2NhcGUgaXQgd2l0aCBhCgkJYmFja3NsYXNoLiAgTm90ZSB0aGF0IG9uIE1TLVdpbmRvd3MgYSBkaXJlY3RvcnkgbWF5IGhhdmUgYQoJCXRyYWlsaW5nIGJhY2tzbGFzaCwgcmVtb3ZlIGl0IGlmIHlvdSBwdXQgYSBjb21tYSBhZnRlciBpdC4KCQlJZiB0aGUgZXhwYW5zaW9uIGZhaWxzIGZvciBvbmUgb2YgdGhlIGRpcmVjdG9yaWVzLCB0aGVyZSBpcyBubwoJCWVycm9yIG1lc3NhZ2UuCgoJCVVubGVzcyB0aGUgb3B0aW9uYWwge25vc3VmfSBhcmd1bWVudCBpcyBnaXZlbiBhbmQgaXMgbm9uLXplcm8sCgkJdGhlICdzdWZmaXhlcycgYW5kICd3aWxkaWdub3JlJyBvcHRpb25zIGFwcGx5OiBOYW1lcyBtYXRjaGluZwoJCW9uZSBvZiB0aGUgcGF0dGVybnMgaW4gJ3dpbGRpZ25vcmUnIHdpbGwgYmUgc2tpcHBlZCBhbmQKCQknc3VmZml4ZXMnIGFmZmVjdCB0aGUgb3JkZXJpbmcgb2YgbWF0Y2hlcy4KCgkJV2hlbiB7bGlzdH0gaXMgcHJlc2VudCBhbmQgaXQgaXMgbm9uLXplcm8gdGhlIHJlc3VsdCBpcyBhIExpc3QKCQl3aXRoIGFsbCBtYXRjaGluZyBmaWxlcy4gVGhlIGFkdmFudGFnZSBvZiB1c2luZyBhIExpc3QgaXMsIHlvdQoJCWFsc28gZ2V0IGZpbGVuYW1lcyBjb250YWluaW5nIG5ld2xpbmVzIGNvcnJlY3RseS4gT3RoZXJ3aXNlCgkJdGhlIHJlc3VsdCBpcyBhIFN0cmluZyBhbmQgd2hlbiB0aGVyZSBhcmUgc2V2ZXJhbCBtYXRjaGVzLAoJCXRoZXkgYXJlIHNlcGFyYXRlZCBieSA8Tkw+IGNoYXJhY3RlcnMuICBFeGFtcGxlOiA+CgkJCTplY2hvIGdsb2JwYXRoKCZydHAsICJzeW50YXgvYy52aW0iLCAwLCAxKQo8CgkJe2FsbGxpbmtzfSBpcyB1c2VkIGFzIHdpdGggfGdsb2IoKXwuCgoJCVRoZSAiKioiIGl0ZW0gY2FuIGJlIHVzZWQgdG8gc2VhcmNoIGluIGEgZGlyZWN0b3J5IHRyZWUuCgkJRm9yIGV4YW1wbGUsIHRvIGZpbmQgYWxsICJSRUFETUUudHh0IiBmaWxlcyBpbiB0aGUgZGlyZWN0b3JpZXMKCQlpbiAncnVudGltZXBhdGgnIGFuZCBiZWxvdzogPgoJCQk6ZWNobyBnbG9icGF0aCgmcnRwLCAiKiovUkVBRE1FLnR4dCIpCjwJCVVwd2FyZHMgc2VhcmNoIGFuZCBsaW1pdGluZyB0aGUgZGVwdGggb2YgIioqIiBpcyBub3QKCQlzdXBwb3J0ZWQsIHRodXMgdXNpbmcgJ3BhdGgnIHdpbGwgbm90IGFsd2F5cyB3b3JrIHByb3Blcmx5LgoKCQkJCQkJCSpoYXMoKSoKaGFzKHtmZWF0dXJlfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSBpZiB0aGUgZmVhdHVyZSB7ZmVhdHVyZX0gaXMKCQlzdXBwb3J0ZWQsIHplcm8gb3RoZXJ3aXNlLiAgVGhlIHtmZWF0dXJlfSBhcmd1bWVudCBpcyBhCgkJc3RyaW5nLiAgU2VlIHxmZWF0dXJlLWxpc3R8IGJlbG93LgoJCUFsc28gc2VlIHxleGlzdHMoKXwuCgoKaGFzX2tleSh7ZGljdH0sIHtrZXl9KQkJCQkJKmhhc19rZXkoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyAxIGlmIHxEaWN0aW9uYXJ5fCB7ZGljdH0gaGFzCgkJYW4gZW50cnkgd2l0aCBrZXkge2tleX0uICBaZXJvIG90aGVyd2lzZS4KCmhhc2xvY2FsZGlyKFt7d2lubnJ9IFssIHt0YWJucn1dXSkJCQkqaGFzbG9jYWxkaXIoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyAxIHdoZW4gdGhlIHdpbmRvdyBoYXMgc2V0IGEKCQlsb2NhbCBwYXRoIHZpYSB8OmxjZHwsIGFuZCAwIG90aGVyd2lzZS4KCgkJV2l0aG91dCBhcmd1bWVudHMgdXNlIHRoZSBjdXJyZW50IHdpbmRvdy4KCQlXaXRoIHt3aW5ucn0gdXNlIHRoaXMgd2luZG93IGluIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoJCVdpdGgge3dpbm5yfSBhbmQge3RhYm5yfSB1c2UgdGhlIHdpbmRvdyBpbiB0aGUgc3BlY2lmaWVkIHRhYgoJCXBhZ2UuCgkJUmV0dXJuIDAgaWYgdGhlIGFyZ3VtZW50cyBhcmUgaW52YWxpZC4KCmhhc21hcHRvKHt3aGF0fSBbLCB7bW9kZX0gWywge2FiYnJ9XV0pCQkJKmhhc21hcHRvKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSBpZiB0aGVyZSBpcyBhIG1hcHBpbmcgdGhhdAoJCWNvbnRhaW5zIHt3aGF0fSBpbiBzb21ld2hlcmUgaW4gdGhlIHJocyAod2hhdCBpdCBpcyBtYXBwZWQgdG8pCgkJYW5kIHRoaXMgbWFwcGluZyBleGlzdHMgaW4gb25lIG9mIHRoZSBtb2RlcyBpbmRpY2F0ZWQgYnkKCQl7bW9kZX0uCgkJV2hlbiB7YWJicn0gaXMgdGhlcmUgYW5kIGl0IGlzIG5vbi16ZXJvIHVzZSBhYmJyZXZpYXRpb25zCgkJaW5zdGVhZCBvZiBtYXBwaW5ncy4gIERvbid0IGZvcmdldCB0byBzcGVjaWZ5IEluc2VydCBhbmQvb3IKCQlDb21tYW5kLWxpbmUgbW9kZS4KCQlCb3RoIHRoZSBnbG9iYWwgbWFwcGluZ3MgYW5kIHRoZSBtYXBwaW5ncyBsb2NhbCB0byB0aGUgY3VycmVudAoJCWJ1ZmZlciBhcmUgY2hlY2tlZCBmb3IgYSBtYXRjaC4KCQlJZiBubyBtYXRjaGluZyBtYXBwaW5nIGlzIGZvdW5kIDAgaXMgcmV0dXJuZWQuCgkJVGhlIGZvbGxvd2luZyBjaGFyYWN0ZXJzIGFyZSByZWNvZ25pemVkIGluIHttb2RlfToKCQkJbglOb3JtYWwgbW9kZQoJCQl2CVZpc3VhbCBtb2RlCgkJCW8JT3BlcmF0b3ItcGVuZGluZyBtb2RlCgkJCWkJSW5zZXJ0IG1vZGUKCQkJbAlMYW5ndWFnZS1Bcmd1bWVudCAoInIiLCAiZiIsICJ0IiwgZXRjLikKCQkJYwlDb21tYW5kLWxpbmUgbW9kZQoJCVdoZW4ge21vZGV9IGlzIG9taXR0ZWQsICJudm8iIGlzIHVzZWQuCgoJCVRoaXMgZnVuY3Rpb24gaXMgdXNlZnVsIHRvIGNoZWNrIGlmIGEgbWFwcGluZyBhbHJlYWR5IGV4aXN0cwoJCXRvIGEgZnVuY3Rpb24gaW4gYSBWaW0gc2NyaXB0LglFeGFtcGxlOiA+CgkJCTppZiAhaGFzbWFwdG8oJ1xBQkNkb2l0JykKCQkJOiAgIG1hcCA8TGVhZGVyPmQgXEFCQ2RvaXQKCQkJOmVuZGlmCjwJCVRoaXMgaW5zdGFsbHMgdGhlIG1hcHBpbmcgdG8gIlxBQkNkb2l0IiBvbmx5IGlmIHRoZXJlIGlzbid0CgkJYWxyZWFkeSBhIG1hcHBpbmcgdG8gIlxBQkNkb2l0Ii4KCmhpc3RhZGQoe2hpc3Rvcnl9LCB7aXRlbX0pCQkJCSpoaXN0YWRkKCkqCgkJQWRkIHRoZSBTdHJpbmcge2l0ZW19IHRvIHRoZSBoaXN0b3J5IHtoaXN0b3J5fSB3aGljaCBjYW4gYmUKCQlvbmUgb2Y6CQkJCQkqaGlzdC1uYW1lcyoKCQkJImNtZCIJIG9yICI6IgkgIGNvbW1hbmQgbGluZSBoaXN0b3J5CgkJCSJzZWFyY2giIG9yICIvIiAgIHNlYXJjaCBwYXR0ZXJuIGhpc3RvcnkKCQkJImV4cHIiCSBvciAiPSIgICB0eXBlZCBleHByZXNzaW9uIGhpc3RvcnkKCQkJImlucHV0IiAgb3IgIkAiCSAgaW5wdXQgbGluZSBoaXN0b3J5CgkJCSJkZWJ1ZyIgIG9yICI+IiAgIGRlYnVnIGNvbW1hbmQgaGlzdG9yeQoJCVRoZSB7aGlzdG9yeX0gc3RyaW5nIGRvZXMgbm90IG5lZWQgdG8gYmUgdGhlIHdob2xlIG5hbWUsIG9uZQoJCWNoYXJhY3RlciBpcyBzdWZmaWNpZW50LgoJCUlmIHtpdGVtfSBkb2VzIGFscmVhZHkgZXhpc3QgaW4gdGhlIGhpc3RvcnksIGl0IHdpbGwgYmUKCQlzaGlmdGVkIHRvIGJlY29tZSB0aGUgbmV3ZXN0IGVudHJ5LgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXI6IDEgaWYgdGhlIG9wZXJhdGlvbiB3YXMgc3VjY2Vzc2Z1bCwKCQlvdGhlcndpc2UgMCBpcyByZXR1cm5lZC4KCgkJRXhhbXBsZTogPgoJCQk6Y2FsbCBoaXN0YWRkKCJpbnB1dCIsIHN0cmZ0aW1lKCIlWSAlYiAlZCIpKQoJCQk6bGV0IGRhdGU9aW5wdXQoIkVudGVyIGRhdGU6ICIpCjwJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoKaGlzdGRlbCh7aGlzdG9yeX0gWywge2l0ZW19XSkJCQkJKmhpc3RkZWwoKSoKCQlDbGVhciB7aGlzdG9yeX0sIGkuZS4gZGVsZXRlIGFsbCBpdHMgZW50cmllcy4gIFNlZSB8aGlzdC1uYW1lc3wKCQlmb3IgdGhlIHBvc3NpYmxlIHZhbHVlcyBvZiB7aGlzdG9yeX0uCgoJCUlmIHRoZSBwYXJhbWV0ZXIge2l0ZW19IGV2YWx1YXRlcyB0byBhIFN0cmluZywgaXQgaXMgdXNlZCBhcyBhCgkJcmVndWxhciBleHByZXNzaW9uLiAgQWxsIGVudHJpZXMgbWF0Y2hpbmcgdGhhdCBleHByZXNzaW9uIHdpbGwKCQliZSByZW1vdmVkIGZyb20gdGhlIGhpc3RvcnkgKGlmIHRoZXJlIGFyZSBhbnkpLgoJCVVwcGVyL2xvd2VyY2FzZSBtdXN0IG1hdGNoLCB1bmxlc3MgIlxjIiBpcyB1c2VkIHwvXGN8LgoJCUlmIHtpdGVtfSBldmFsdWF0ZXMgdG8gYSBOdW1iZXIsIGl0IHdpbGwgYmUgaW50ZXJwcmV0ZWQgYXMKCQlhbiBpbmRleCwgc2VlIHw6aGlzdG9yeS1pbmRleGluZ3wuICBUaGUgcmVzcGVjdGl2ZSBlbnRyeSB3aWxsCgkJYmUgcmVtb3ZlZCBpZiBpdCBleGlzdHMuCgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXI6IDEgZm9yIGEgc3VjY2Vzc2Z1bCBvcGVyYXRpb24sCgkJb3RoZXJ3aXNlIDAgaXMgcmV0dXJuZWQuCgoJCUV4YW1wbGVzOgoJCUNsZWFyIGV4cHJlc3Npb24gcmVnaXN0ZXIgaGlzdG9yeTogPgoJCQk6Y2FsbCBoaXN0ZGVsKCJleHByIikKPAoJCVJlbW92ZSBhbGwgZW50cmllcyBzdGFydGluZyB3aXRoICIqIiBmcm9tIHRoZSBzZWFyY2ggaGlzdG9yeTogPgoJCQk6Y2FsbCBoaXN0ZGVsKCIvIiwgJ15cKicpCjwKCQlUaGUgZm9sbG93aW5nIHRocmVlIGFyZSBlcXVpdmFsZW50OiA+CgkJCTpjYWxsIGhpc3RkZWwoInNlYXJjaCIsIGhpc3Rucigic2VhcmNoIikpCgkJCTpjYWxsIGhpc3RkZWwoInNlYXJjaCIsIC0xKQoJCQk6Y2FsbCBoaXN0ZGVsKCJzZWFyY2giLCAnXicuaGlzdGdldCgic2VhcmNoIiwgLTEpLickJykKPAoJCVRvIGRlbGV0ZSB0aGUgbGFzdCBzZWFyY2ggcGF0dGVybiBhbmQgdXNlIHRoZSBsYXN0LWJ1dC1vbmUgZm9yCgkJdGhlICJuIiBjb21tYW5kIGFuZCAnaGxzZWFyY2gnOiA+CgkJCTpjYWxsIGhpc3RkZWwoInNlYXJjaCIsIC0xKQoJCQk6bGV0IEAvID0gaGlzdGdldCgic2VhcmNoIiwgLTEpCgpoaXN0Z2V0KHtoaXN0b3J5fSBbLCB7aW5kZXh9XSkJCQkJKmhpc3RnZXQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB0aGUgZW50cnkgd2l0aCBOdW1iZXIge2luZGV4fSBmcm9tCgkJe2hpc3Rvcnl9LiAgU2VlIHxoaXN0LW5hbWVzfCBmb3IgdGhlIHBvc3NpYmxlIHZhbHVlcyBvZgoJCXtoaXN0b3J5fSwgYW5kIHw6aGlzdG9yeS1pbmRleGluZ3wgZm9yIHtpbmRleH0uICBJZiB0aGVyZSBpcwoJCW5vIHN1Y2ggZW50cnksIGFuIGVtcHR5IFN0cmluZyBpcyByZXR1cm5lZC4gIFdoZW4ge2luZGV4fSBpcwoJCW9taXR0ZWQsIHRoZSBtb3N0IHJlY2VudCBpdGVtIGZyb20gdGhlIGhpc3RvcnkgaXMgdXNlZC4KCgkJRXhhbXBsZXM6CgkJUmVkbyB0aGUgc2Vjb25kIGxhc3Qgc2VhcmNoIGZyb20gaGlzdG9yeS4gPgoJCQk6ZXhlY3V0ZSAnLycgLiBoaXN0Z2V0KCJzZWFyY2giLCAtMikKCjwJCURlZmluZSBhbiBFeCBjb21tYW5kICI6SCB7bnVtfSIgdGhhdCBzdXBwb3J0cyByZS1leGVjdXRpb24gb2YKCQl0aGUge251bX10aCBlbnRyeSBmcm9tIHRoZSBvdXRwdXQgb2YgfDpoaXN0b3J5fC4gPgoJCQk6Y29tbWFuZCAtbmFyZ3M9MSBIIGV4ZWN1dGUgaGlzdGdldCgiY21kIiwgMCs8YXJncz4pCjwKaGlzdG5yKHtoaXN0b3J5fSkJCQkJCSpoaXN0bnIoKSoKCQlUaGUgcmVzdWx0IGlzIHRoZSBOdW1iZXIgb2YgdGhlIGN1cnJlbnQgZW50cnkgaW4ge2hpc3Rvcnl9LgoJCVNlZSB8aGlzdC1uYW1lc3wgZm9yIHRoZSBwb3NzaWJsZSB2YWx1ZXMgb2Yge2hpc3Rvcnl9LgoJCUlmIGFuIGVycm9yIG9jY3VycmVkLCAtMSBpcyByZXR1cm5lZC4KCgkJRXhhbXBsZTogPgoJCQk6bGV0IGlucF9pbmRleCA9IGhpc3RucigiZXhwciIpCjwKaGxleGlzdHMoe25hbWV9KQkJCQkJKmhsZXhpc3RzKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gaWYgYSBoaWdobGlnaHQgZ3JvdXAKCQljYWxsZWQge25hbWV9IGV4aXN0cy4gIFRoaXMgaXMgd2hlbiB0aGUgZ3JvdXAgaGFzIGJlZW4KCQlkZWZpbmVkIGluIHNvbWUgd2F5LiAgTm90IG5lY2Vzc2FyaWx5IHdoZW4gaGlnaGxpZ2h0aW5nIGhhcwoJCWJlZW4gZGVmaW5lZCBmb3IgaXQsIGl0IG1heSBhbHNvIGhhdmUgYmVlbiB1c2VkIGZvciBhIHN5bnRheAoJCWl0ZW0uCgkJCQkJCQkqaGlnaGxpZ2h0X2V4aXN0cygpKgoJCU9ic29sZXRlIG5hbWU6IGhpZ2hsaWdodF9leGlzdHMoKS4KCgkJCQkJCQkqaGxJRCgpKgpobElEKHtuYW1lfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIElEIG9mIHRoZSBoaWdobGlnaHQgZ3JvdXAKCQl3aXRoIG5hbWUge25hbWV9LiAgV2hlbiB0aGUgaGlnaGxpZ2h0IGdyb3VwIGRvZXNuJ3QgZXhpc3QsCgkJemVybyBpcyByZXR1cm5lZC4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIHJldHJpZXZlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBoaWdobGlnaHQKCQlncm91cC4JRm9yIGV4YW1wbGUsIHRvIGdldCB0aGUgYmFja2dyb3VuZCBjb2xvciBvZiB0aGUKCQkiQ29tbWVudCIgZ3JvdXA6ID4KCTplY2hvIHN5bklEYXR0cihzeW5JRHRyYW5zKGhsSUQoIkNvbW1lbnQiKSksICJiZyIpCjwJCQkJCQkJKmhpZ2hsaWdodElEKCkqCgkJT2Jzb2xldGUgbmFtZTogaGlnaGxpZ2h0SUQoKS4KCmhvc3RuYW1lKCkJCQkJCQkqaG9zdG5hbWUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUgbmFtZSBvZiB0aGUgbWFjaGluZSBvbgoJCXdoaWNoIFZpbSBpcyBjdXJyZW50bHkgcnVubmluZy4gIE1hY2hpbmUgbmFtZXMgZ3JlYXRlciB0aGFuCgkJMjU2IGNoYXJhY3RlcnMgbG9uZyBhcmUgdHJ1bmNhdGVkLgoKaWNvbnYoe2V4cHJ9LCB7ZnJvbX0sIHt0b30pCQkJCSppY29udigpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSB0ZXh0IHtleHByfSBjb252ZXJ0ZWQKCQlmcm9tIGVuY29kaW5nIHtmcm9tfSB0byBlbmNvZGluZyB7dG99LgoJCVdoZW4gdGhlIGNvbnZlcnNpb24gY29tcGxldGVseSBmYWlscyBhbiBlbXB0eSBzdHJpbmcgaXMKCQlyZXR1cm5lZC4gIFdoZW4gc29tZSBjaGFyYWN0ZXJzIGNvdWxkIG5vdCBiZSBjb252ZXJ0ZWQgdGhleQoJCWFyZSByZXBsYWNlZCB3aXRoICI/Ii4KCQlUaGUgZW5jb2RpbmcgbmFtZXMgYXJlIHdoYXRldmVyIHRoZSBpY29udigpIGxpYnJhcnkgZnVuY3Rpb24KCQljYW4gYWNjZXB0LCBzZWUgIjohbWFuIDMgaWNvbnYiLgoJCU1vc3QgY29udmVyc2lvbnMgcmVxdWlyZSBWaW0gdG8gYmUgY29tcGlsZWQgd2l0aCB0aGUgfCtpY29udnwKCQlmZWF0dXJlLiAgT3RoZXJ3aXNlIG9ubHkgVVRGLTggdG8gbGF0aW4xIGNvbnZlcnNpb24gYW5kIGJhY2sKCQljYW4gYmUgZG9uZS4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIGRpc3BsYXkgbWVzc2FnZXMgd2l0aCBzcGVjaWFsIGNoYXJhY3RlcnMsCgkJbm8gbWF0dGVyIHdoYXQgJ2VuY29kaW5nJyBpcyBzZXQgdG8uICBXcml0ZSB0aGUgbWVzc2FnZSBpbgoJCVVURi04IGFuZCB1c2U6ID4KCQkJZWNobyBpY29udih1dGY4X3N0ciwgInV0Zi04IiwgJmVuYykKPAkJTm90ZSB0aGF0IFZpbSB1c2VzIFVURi04IGZvciBhbGwgVW5pY29kZSBlbmNvZGluZ3MsIGNvbnZlcnNpb24KCQlmcm9tL3RvIFVDUy0yIGlzIGF1dG9tYXRpY2FsbHkgY2hhbmdlZCB0byB1c2UgVVRGLTguICBZb3UKCQljYW5ub3QgdXNlIFVDUy0yIGluIGEgc3RyaW5nIGFueXdheSwgYmVjYXVzZSBvZiB0aGUgTlVMIGJ5dGVzLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZXwgZmVhdHVyZX0KCgkJCQkJCQkqaW5kZW50KCkqCmluZGVudCh7bG51bX0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIGluZGVudCBvZiBsaW5lIHtsbnVtfSBpbiB0aGUKCQljdXJyZW50IGJ1ZmZlci4gIFRoZSBpbmRlbnQgaXMgY291bnRlZCBpbiBzcGFjZXMsIHRoZSB2YWx1ZQoJCW9mICd0YWJzdG9wJyBpcyByZWxldmFudC4gIHtsbnVtfSBpcyB1c2VkIGp1c3QgbGlrZSBpbgoJCXxnZXRsaW5lKCl8LgoJCVdoZW4ge2xudW19IGlzIGludmFsaWQgLTEgaXMgcmV0dXJuZWQuCgoKaW5kZXgoe2xpc3R9LCB7ZXhwcn0gWywge3N0YXJ0fSBbLCB7aWN9XV0pCQkJKmluZGV4KCkqCgkJUmV0dXJuIHRoZSBsb3dlc3QgaW5kZXggaW4gfExpc3R8IHtsaXN0fSB3aGVyZSB0aGUgaXRlbSBoYXMgYQoJCXZhbHVlIGVxdWFsIHRvIHtleHByfS4gIFRoZXJlIGlzIG5vIGF1dG9tYXRpYyBjb252ZXJzaW9uLCBzbwoJCXRoZSBTdHJpbmcgIjQiIGlzIGRpZmZlcmVudCBmcm9tIHRoZSBOdW1iZXIgNC4gIEFuZCB0aGUgbnVtYmVyCgkJNCBpcyBkaWZmZXJlbnQgZnJvbSB0aGUgRmxvYXQgNC4wLiAgVGhlIHZhbHVlIG9mICdpZ25vcmVjYXNlJwoJCWlzIG5vdCB1c2VkIGhlcmUsIGNhc2UgYWx3YXlzIG1hdHRlcnMuCgkJSWYge3N0YXJ0fSBpcyBnaXZlbiB0aGVuIHN0YXJ0IGxvb2tpbmcgYXQgdGhlIGl0ZW0gd2l0aCBpbmRleAoJCXtzdGFydH0gKG1heSBiZSBuZWdhdGl2ZSBmb3IgYW4gaXRlbSByZWxhdGl2ZSB0byB0aGUgZW5kKS4KCQlXaGVuIHtpY30gaXMgZ2l2ZW4gYW5kIGl0IGlzIG5vbi16ZXJvLCBpZ25vcmUgY2FzZS4gIE90aGVyd2lzZQoJCWNhc2UgbXVzdCBtYXRjaC4KCQktMSBpcyByZXR1cm5lZCB3aGVuIHtleHByfSBpcyBub3QgZm91bmQgaW4ge2xpc3R9LgoJCUV4YW1wbGU6ID4KCQkJOmxldCBpZHggPSBpbmRleCh3b3JkcywgInRoZSIpCgkJCTppZiBpbmRleChudW1iZXJzLCAxMjMpID49IDAKCgppbnB1dCh7cHJvbXB0fSBbLCB7dGV4dH0gWywge2NvbXBsZXRpb259XV0pCQkqaW5wdXQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB3aGF0ZXZlciB0aGUgdXNlciB0eXBlZCBvbgoJCXRoZSBjb21tYW5kLWxpbmUuICBUaGUge3Byb21wdH0gYXJndW1lbnQgaXMgZWl0aGVyIGEgcHJvbXB0CgkJc3RyaW5nLCBvciBhIGJsYW5rIHN0cmluZyAoZm9yIG5vIHByb21wdCkuICBBICdcbicgY2FuIGJlIHVzZWQKCQlpbiB0aGUgcHJvbXB0IHRvIHN0YXJ0IGEgbmV3IGxpbmUuCgkJVGhlIGhpZ2hsaWdodGluZyBzZXQgd2l0aCB8OmVjaG9obHwgaXMgdXNlZCBmb3IgdGhlIHByb21wdC4KCQlUaGUgaW5wdXQgaXMgZW50ZXJlZCBqdXN0IGxpa2UgYSBjb21tYW5kLWxpbmUsIHdpdGggdGhlIHNhbWUKCQllZGl0aW5nIGNvbW1hbmRzIGFuZCBtYXBwaW5ncy4JVGhlcmUgaXMgYSBzZXBhcmF0ZSBoaXN0b3J5CgkJZm9yIGxpbmVzIHR5cGVkIGZvciBpbnB1dCgpLgoJCUV4YW1wbGU6ID4KCQkJOmlmIGlucHV0KCJDb2ZmZWUgb3IgYmVlcj8gIikgPT0gImJlZXIiCgkJCTogIGVjaG8gIkNoZWVycyEiCgkJCTplbmRpZgo8CgkJSWYgdGhlIG9wdGlvbmFsIHt0ZXh0fSBhcmd1bWVudCBpcyBwcmVzZW50IGFuZCBub3QgZW1wdHksIHRoaXMKCQlpcyB1c2VkIGZvciB0aGUgZGVmYXVsdCByZXBseSwgYXMgaWYgdGhlIHVzZXIgdHlwZWQgdGhpcy4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgY29sb3IgPSBpbnB1dCgiQ29sb3I/ICIsICJ3aGl0ZSIpCgo8CQlUaGUgb3B0aW9uYWwge2NvbXBsZXRpb259IGFyZ3VtZW50IHNwZWNpZmllcyB0aGUgdHlwZSBvZgoJCWNvbXBsZXRpb24gc3VwcG9ydGVkIGZvciB0aGUgaW5wdXQuICBXaXRob3V0IGl0IGNvbXBsZXRpb24gaXMKCQlub3QgcGVyZm9ybWVkLglUaGUgc3VwcG9ydGVkIGNvbXBsZXRpb24gdHlwZXMgYXJlIHRoZSBzYW1lIGFzCgkJdGhhdCBjYW4gYmUgc3VwcGxpZWQgdG8gYSB1c2VyLWRlZmluZWQgY29tbWFuZCB1c2luZyB0aGUKCQkiLWNvbXBsZXRlPSIgYXJndW1lbnQuCVJlZmVyIHRvIHw6Y29tbWFuZC1jb21wbGV0aW9ufCBmb3IKCQltb3JlIGluZm9ybWF0aW9uLiAgRXhhbXBsZTogPgoJCQlsZXQgZm5hbWUgPSBpbnB1dCgiRmlsZTogIiwgIiIsICJmaWxlIikKPAoJCU5PVEU6IFRoaXMgZnVuY3Rpb24gbXVzdCBub3QgYmUgdXNlZCBpbiBhIHN0YXJ0dXAgZmlsZSwgZm9yCgkJdGhlIHZlcnNpb25zIHRoYXQgb25seSBydW4gaW4gR1VJIG1vZGUgKGUuZy4sIHRoZSBXaW4zMiBHVUkpLgoJCU5vdGU6IFdoZW4gaW5wdXQoKSBpcyBjYWxsZWQgZnJvbSB3aXRoaW4gYSBtYXBwaW5nIGl0IHdpbGwKCQljb25zdW1lIHJlbWFpbmluZyBjaGFyYWN0ZXJzIGZyb20gdGhhdCBtYXBwaW5nLCBiZWNhdXNlIGEKCQltYXBwaW5nIGlzIGhhbmRsZWQgbGlrZSB0aGUgY2hhcmFjdGVycyB3ZXJlIHR5cGVkLgoJCVVzZSB8aW5wdXRzYXZlKCl8IGJlZm9yZSBpbnB1dCgpIGFuZCB8aW5wdXRyZXN0b3JlKCl8CgkJYWZ0ZXIgaW5wdXQoKSB0byBhdm9pZCB0aGF0LiAgQW5vdGhlciBzb2x1dGlvbiBpcyB0byBhdm9pZAoJCXRoYXQgZnVydGhlciBjaGFyYWN0ZXJzIGZvbGxvdyBpbiB0aGUgbWFwcGluZywgZS5nLiwgYnkgdXNpbmcKCQl8OmV4ZWN1dGV8IG9yIHw6bm9ybWFsfC4KCgkJRXhhbXBsZSB3aXRoIGEgbWFwcGluZzogPgoJCQk6bm1hcCBceCA6Y2FsbCBHZXRGb28oKTxDUj46ZXhlICIvIiAuIEZvbzxDUj4KCQkJOmZ1bmN0aW9uIEdldEZvbygpCgkJCTogIGNhbGwgaW5wdXRzYXZlKCkKCQkJOiAgbGV0IGc6Rm9vID0gaW5wdXQoImVudGVyIHNlYXJjaCBwYXR0ZXJuOiAiKQoJCQk6ICBjYWxsIGlucHV0cmVzdG9yZSgpCgkJCTplbmRmdW5jdGlvbgoKaW5wdXRkaWFsb2coe3Byb21wdH0gWywge3RleHR9IFssIHtjYW5jZWxyZXR1cm59XV0pCQkqaW5wdXRkaWFsb2coKSoKCQlMaWtlIHxpbnB1dCgpfCwgYnV0IHdoZW4gdGhlIEdVSSBpcyBydW5uaW5nIGFuZCB0ZXh0IGRpYWxvZ3MKCQlhcmUgc3VwcG9ydGVkLCBhIGRpYWxvZyB3aW5kb3cgcG9wcyB1cCB0byBpbnB1dCB0aGUgdGV4dC4KCQlFeGFtcGxlOiA+CgkJICAgOmxldCBuID0gaW5wdXRkaWFsb2coInZhbHVlIGZvciBzaGlmdHdpZHRoIiwgc2hpZnR3aWR0aCgpKQoJCSAgIDppZiBuICE9ICIiCgkJICAgOiAgbGV0ICZzdyA9IG4KCQkgICA6ZW5kaWYKPAkJV2hlbiB0aGUgZGlhbG9nIGlzIGNhbmNlbGxlZCB7Y2FuY2VscmV0dXJufSBpcyByZXR1cm5lZC4gIFdoZW4KCQlvbWl0dGVkIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCQlIaXR0aW5nIDxFbnRlcj4gd29ya3MgbGlrZSBwcmVzc2luZyB0aGUgT0sgYnV0dG9uLiAgSGl0dGluZwoJCTxFc2M+IHdvcmtzIGxpa2UgcHJlc3NpbmcgdGhlIENhbmNlbCBidXR0b24uCgkJTk9URTogQ29tbWFuZC1saW5lIGNvbXBsZXRpb24gaXMgbm90IHN1cHBvcnRlZC4KCmlucHV0bGlzdCh7dGV4dGxpc3R9KQkJCQkJKmlucHV0bGlzdCgpKgoJCXt0ZXh0bGlzdH0gbXVzdCBiZSBhIHxMaXN0fCBvZiBzdHJpbmdzLiAgVGhpcyB8TGlzdHwgaXMKCQlkaXNwbGF5ZWQsIG9uZSBzdHJpbmcgcGVyIGxpbmUuICBUaGUgdXNlciB3aWxsIGJlIHByb21wdGVkIHRvCgkJZW50ZXIgYSBudW1iZXIsIHdoaWNoIGlzIHJldHVybmVkLgoJCVRoZSB1c2VyIGNhbiBhbHNvIHNlbGVjdCBhbiBpdGVtIGJ5IGNsaWNraW5nIG9uIGl0IHdpdGggdGhlCgkJbW91c2UuCUZvciB0aGUgZmlyc3Qgc3RyaW5nIDAgaXMgcmV0dXJuZWQuICBXaGVuIGNsaWNraW5nCgkJYWJvdmUgdGhlIGZpcnN0IGl0ZW0gYSBuZWdhdGl2ZSBudW1iZXIgaXMgcmV0dXJuZWQuICBXaGVuCgkJY2xpY2tpbmcgb24gdGhlIHByb21wdCBvbmUgbW9yZSB0aGFuIHRoZSBsZW5ndGggb2Yge3RleHRsaXN0fQoJCWlzIHJldHVybmVkLgoJCU1ha2Ugc3VyZSB7dGV4dGxpc3R9IGhhcyBsZXNzIHRoYW4gJ2xpbmVzJyBlbnRyaWVzLCBvdGhlcndpc2UKCQlpdCB3b24ndCB3b3JrLglJdCdzIGEgZ29vZCBpZGVhIHRvIHB1dCB0aGUgZW50cnkgbnVtYmVyIGF0CgkJdGhlIHN0YXJ0IG9mIHRoZSBzdHJpbmcuICBBbmQgcHV0IGEgcHJvbXB0IGluIHRoZSBmaXJzdCBpdGVtLgoJCUV4YW1wbGU6ID4KCQkJbGV0IGNvbG9yID0gaW5wdXRsaXN0KFsnU2VsZWN0IGNvbG9yOicsICcxLiByZWQnLAoJCQkJXCAnMi4gZ3JlZW4nLCAnMy4gYmx1ZSddKQoKaW5wdXRyZXN0b3JlKCkJCQkJCQkqaW5wdXRyZXN0b3JlKCkqCgkJUmVzdG9yZSB0eXBlYWhlYWQgdGhhdCB3YXMgc2F2ZWQgd2l0aCBhIHByZXZpb3VzIHxpbnB1dHNhdmUoKXwuCgkJU2hvdWxkIGJlIGNhbGxlZCB0aGUgc2FtZSBudW1iZXIgb2YgdGltZXMgaW5wdXRzYXZlKCkgaXMKCQljYWxsZWQuICBDYWxsaW5nIGl0IG1vcmUgb2Z0ZW4gaXMgaGFybWxlc3MgdGhvdWdoLgoJCVJldHVybnMgMSB3aGVuIHRoZXJlIGlzIG5vdGhpbmcgdG8gcmVzdG9yZSwgMCBvdGhlcndpc2UuCgppbnB1dHNhdmUoKQkJCQkJCSppbnB1dHNhdmUoKSoKCQlQcmVzZXJ2ZSB0eXBlYWhlYWQgKGFsc28gZnJvbSBtYXBwaW5ncykgYW5kIGNsZWFyIGl0LCBzbyB0aGF0CgkJYSBmb2xsb3dpbmcgcHJvbXB0IGdldHMgaW5wdXQgZnJvbSB0aGUgdXNlci4gIFNob3VsZCBiZQoJCWZvbGxvd2VkIGJ5IGEgbWF0Y2hpbmcgaW5wdXRyZXN0b3JlKCkgYWZ0ZXIgdGhlIHByb21wdC4gIENhbgoJCWJlIHVzZWQgc2V2ZXJhbCB0aW1lcywgaW4gd2hpY2ggY2FzZSB0aGVyZSBtdXN0IGJlIGp1c3QgYXMKCQltYW55IGlucHV0cmVzdG9yZSgpIGNhbGxzLgoJCVJldHVybnMgMSB3aGVuIG91dCBvZiBtZW1vcnksIDAgb3RoZXJ3aXNlLgoKaW5wdXRzZWNyZXQoe3Byb21wdH0gWywge3RleHR9XSkJCQkqaW5wdXRzZWNyZXQoKSoKCQlUaGlzIGZ1bmN0aW9uIGFjdHMgbXVjaCBsaWtlIHRoZSB8aW5wdXQoKXwgZnVuY3Rpb24gd2l0aCBidXQKCQl0d28gZXhjZXB0aW9uczoKCQlhKSB0aGUgdXNlcidzIHJlc3BvbnNlIHdpbGwgYmUgZGlzcGxheWVkIGFzIGEgc2VxdWVuY2Ugb2YKCQlhc3Rlcmlza3MgKCIqIikgdGhlcmVieSBrZWVwaW5nIHRoZSBlbnRyeSBzZWNyZXQsIGFuZAoJCWIpIHRoZSB1c2VyJ3MgcmVzcG9uc2Ugd2lsbCBub3QgYmUgcmVjb3JkZWQgb24gdGhlIGlucHV0CgkJfGhpc3Rvcnl8IHN0YWNrLgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHdoYXRldmVyIHRoZSB1c2VyIGFjdHVhbGx5CgkJdHlwZWQgb24gdGhlIGNvbW1hbmQtbGluZSBpbiByZXNwb25zZSB0byB0aGUgaXNzdWVkIHByb21wdC4KCQlOT1RFOiBDb21tYW5kLWxpbmUgY29tcGxldGlvbiBpcyBub3Qgc3VwcG9ydGVkLgoKaW5zZXJ0KHtsaXN0fSwge2l0ZW19IFssIHtpZHh9XSkJCQkqaW5zZXJ0KCkqCgkJSW5zZXJ0IHtpdGVtfSBhdCB0aGUgc3RhcnQgb2YgfExpc3R8IHtsaXN0fS4KCQlJZiB7aWR4fSBpcyBzcGVjaWZpZWQgaW5zZXJ0IHtpdGVtfSBiZWZvcmUgdGhlIGl0ZW0gd2l0aCBpbmRleAoJCXtpZHh9LglJZiB7aWR4fSBpcyB6ZXJvIGl0IGdvZXMgYmVmb3JlIHRoZSBmaXJzdCBpdGVtLCBqdXN0CgkJbGlrZSBvbWl0dGluZyB7aWR4fS4gIEEgbmVnYXRpdmUge2lkeH0gaXMgYWxzbyBwb3NzaWJsZSwgc2VlCgkJfGxpc3QtaW5kZXh8LiAgLTEgaW5zZXJ0cyBqdXN0IGJlZm9yZSB0aGUgbGFzdCBpdGVtLgoJCVJldHVybnMgdGhlIHJlc3VsdGluZyB8TGlzdHwuICBFeGFtcGxlczogPgoJCQk6bGV0IG15bGlzdCA9IGluc2VydChbMiwgMywgNV0sIDEpCgkJCTpjYWxsIGluc2VydChteWxpc3QsIDQsIC0xKQoJCQk6Y2FsbCBpbnNlcnQobXlsaXN0LCA2LCBsZW4obXlsaXN0KSkKPAkJVGhlIGxhc3QgZXhhbXBsZSBjYW4gYmUgZG9uZSBzaW1wbGVyIHdpdGggfGFkZCgpfC4KCQlOb3RlIHRoYXQgd2hlbiB7aXRlbX0gaXMgYSB8TGlzdHwgaXQgaXMgaW5zZXJ0ZWQgYXMgYSBzaW5nbGUKCQlpdGVtLiAgVXNlIHxleHRlbmQoKXwgdG8gY29uY2F0ZW5hdGUgfExpc3RzfC4KCmludmVydCh7ZXhwcn0pCQkJCQkJKmludmVydCgpKgoJCUJpdHdpc2UgaW52ZXJ0LiAgVGhlIGFyZ3VtZW50IGlzIGNvbnZlcnRlZCB0byBhIG51bWJlci4gIEEKCQlMaXN0LCBEaWN0IG9yIEZsb2F0IGFyZ3VtZW50IGNhdXNlcyBhbiBlcnJvci4gIEV4YW1wbGU6ID4KCQkJOmxldCBiaXRzID0gaW52ZXJ0KGJpdHMpCgppc2RpcmVjdG9yeSh7ZGlyZWN0b3J5fSkJCQkJKmlzZGlyZWN0b3J5KCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gd2hlbiBhIGRpcmVjdG9yeQoJCXdpdGggdGhlIG5hbWUge2RpcmVjdG9yeX0gZXhpc3RzLiAgSWYge2RpcmVjdG9yeX0gZG9lc24ndAoJCWV4aXN0LCBvciBpc24ndCBhIGRpcmVjdG9yeSwgdGhlIHJlc3VsdCBpcyBGQUxTRS4gIHtkaXJlY3Rvcnl9CgkJaXMgYW55IGV4cHJlc3Npb24sIHdoaWNoIGlzIHVzZWQgYXMgYSBTdHJpbmcuCgppc2xvY2tlZCh7ZXhwcn0pCQkJCQkqaXNsb2NrZWQoKSogKkU3ODYqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gd2hlbiB7ZXhwcn0gaXMgdGhlCgkJbmFtZSBvZiBhIGxvY2tlZCB2YXJpYWJsZS4KCQl7ZXhwcn0gbXVzdCBiZSB0aGUgbmFtZSBvZiBhIHZhcmlhYmxlLCB8TGlzdHwgaXRlbSBvcgoJCXxEaWN0aW9uYXJ5fCBlbnRyeSwgbm90IHRoZSB2YXJpYWJsZSBpdHNlbGYhICBFeGFtcGxlOiA+CgkJCTpsZXQgYWxpc3QgPSBbMCwgWydhJywgJ2InXSwgMiwgM10KCQkJOmxvY2t2YXIgMSBhbGlzdAoJCQk6ZWNobyBpc2xvY2tlZCgnYWxpc3QnKQkJIiAxCgkJCTplY2hvIGlzbG9ja2VkKCdhbGlzdFsxXScpCSIgMAoKPAkJV2hlbiB7ZXhwcn0gaXMgYSB2YXJpYWJsZSB0aGF0IGRvZXMgbm90IGV4aXN0IHlvdSBnZXQgYW4gZXJyb3IKCQltZXNzYWdlLiAgVXNlIHxleGlzdHMoKXwgdG8gY2hlY2sgZm9yIGV4aXN0ZW5jZS4KCmlzbmFuKHtleHByfSkJCQkJCQkqaXNuYW4oKSoKCQlSZXR1cm4gbm9uLXplcm8gaWYge2V4cHJ9IGlzIGEgZmxvYXQgd2l0aCB2YWx1ZSBOYU4uID4KCQkJZWNobyBpc25hbigwLjAgLyAwLjApCjwJCQkxIH4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCml0ZW1zKHtkaWN0fSkJCQkJCQkqaXRlbXMoKSoKCQlSZXR1cm4gYSB8TGlzdHwgd2l0aCBhbGwgdGhlIGtleS12YWx1ZSBwYWlycyBvZiB7ZGljdH0uICBFYWNoCgkJfExpc3R8IGl0ZW0gaXMgYSBsaXN0IHdpdGggdHdvIGl0ZW1zOiB0aGUga2V5IG9mIGEge2RpY3R9CgkJZW50cnkgYW5kIHRoZSB2YWx1ZSBvZiB0aGlzIGVudHJ5LiAgVGhlIHxMaXN0fCBpcyBpbiBhcmJpdHJhcnkKCQlvcmRlci4KCmpvYl9nZXRjaGFubmVsKHtqb2J9KQkJCQkJICpqb2JfZ2V0Y2hhbm5lbCgpKgoJCUdldCB0aGUgY2hhbm5lbCBoYW5kbGUgdGhhdCB7am9ifSBpcyB1c2luZy4KCQlUbyBjaGVjayBpZiB0aGUgam9iIGhhcyBubyBjaGFubmVsOiA+CgkJCWlmIHN0cmluZyhqb2JfZ2V0Y2hhbm5lbCgpKSA9PSAnY2hhbm5lbCBmYWlsJwo8CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtqb2J8IGZlYXR1cmV9Cgpqb2JfaW5mbyh7am9ifSkJCQkJCQkqam9iX2luZm8oKSoKCQlSZXR1cm5zIGEgRGljdGlvbmFyeSB3aXRoIGluZm9ybWF0aW9uIGFib3V0IHtqb2J9OgoJCSAgICJzdGF0dXMiCXdoYXQgfGpvYl9zdGF0dXMoKXwgcmV0dXJucwoJCSAgICJjaGFubmVsIgl3aGF0IHxqb2JfZ2V0Y2hhbm5lbCgpfCByZXR1cm5zCgkJICAgImV4aXR2YWwiCW9ubHkgdmFsaWQgd2hlbiAic3RhdHVzIiBpcyAiZGVhZCIKCQkgICAiZXhpdF9jYiIJZnVuY3Rpb24gdG8gYmUgY2FsbGVkIG9uIGV4aXQKCQkgICAic3RvcG9uZXhpdCIJfGpvYi1zdG9wb25leGl0fAoKam9iX3NldG9wdGlvbnMoe2pvYn0sIHtvcHRpb25zfSkJCQkqam9iX3NldG9wdGlvbnMoKSoKCQlDaGFuZ2Ugb3B0aW9ucyBmb3Ige2pvYn0uICBTdXBwb3J0ZWQgYXJlOgoJCSAgICJzdG9wb25leGl0Igl8am9iLXN0b3BvbmV4aXR8CgkJICAgImV4aXRfY2IiCXxqb2ItZXhpdF9jYnwKCmpvYl9zdGFydCh7Y29tbWFuZH0gWywge29wdGlvbnN9XSkJCQkqam9iX3N0YXJ0KCkqCgkJU3RhcnQgYSBqb2IgYW5kIHJldHVybiBhIEpvYiBvYmplY3QuICBVbmxpa2UgfHN5c3RlbSgpfCBhbmQKCQl8OiFjbWR8IHRoaXMgZG9lcyBub3Qgd2FpdCBmb3IgdGhlIGpvYiB0byBmaW5pc2guCgoJCXtjb21tYW5kfSBjYW4gYmUgYSBTdHJpbmcuICBUaGlzIHdvcmtzIGJlc3Qgb24gTVMtV2luZG93cy4gIE9uCgkJVW5peCBpdCBpcyBzcGxpdCB1cCBpbiB3aGl0ZS1zZXBhcmF0ZWQgcGFydHMgdG8gYmUgcGFzc2VkIHRvCgkJZXhlY3ZwKCkuICBBcmd1bWVudHMgaW4gZG91YmxlIHF1b3RlcyBjYW4gY29udGFpbiB3aGl0ZSBzcGFjZS4KCgkJe2NvbW1hbmR9IGNhbiBiZSBhIExpc3QsIHdoZXJlIHRoZSBmaXJzdCBpdGVtIGlzIHRoZSBleGVjdXRhYmxlCgkJYW5kIGZ1cnRoZXIgaXRlbXMgYXJlIHRoZSBhcmd1bWVudHMuICBBbGwgaXRlbXMgYXJlIGNvbnZlcnRlZAoJCXRvIFN0cmluZy4gIFRoaXMgd29ya3MgYmVzdCBvbiBVbml4LgoKCQlPbiBNUy1XaW5kb3dzLCBqb2Jfc3RhcnQoKSBtYWtlcyBhIEdVSSBhcHBsaWNhdGlvbiBoaWRkZW4uIElmCgkJd2FudCB0byBzaG93IGl0LCBVc2UgfDohc3RhcnR8IGluc3RlYWQuCgoJCVRoZSBjb21tYW5kIGlzIGV4ZWN1dGVkIGRpcmVjdGx5LCBub3QgdGhyb3VnaCBhIHNoZWxsLCB0aGUKCQknc2hlbGwnIG9wdGlvbiBpcyBub3QgdXNlZC4gIFRvIHVzZSB0aGUgc2hlbGw6ID4KCWxldCBqb2IgPSBqb2Jfc3RhcnQoWyIvYmluL3NoIiwgIi1jIiwgImVjaG8gaGVsbG8iXSkKPAkJT3I6ID4KCWxldCBqb2IgPSBqb2Jfc3RhcnQoJy9iaW4vc2ggLWMgImVjaG8gaGVsbG8iJykKPAkJTm90ZSB0aGF0IHRoaXMgd2lsbCBzdGFydCB0d28gcHJvY2Vzc2VzLCB0aGUgc2hlbGwgYW5kIHRoZQoJCWNvbW1hbmQgaXQgZXhlY3V0ZXMuICBJZiB5b3UgZG9uJ3Qgd2FudCB0aGlzIHVzZSB0aGUgImV4ZWMiCgkJc2hlbGwgY29tbWFuZC4KCgkJT24gVW5peCAkUEFUSCBpcyB1c2VkIHRvIHNlYXJjaCBmb3IgdGhlIGV4ZWN1dGFibGUgb25seSB3aGVuCgkJdGhlIGNvbW1hbmQgZG9lcyBub3QgY29udGFpbiBhIHNsYXNoLgoKCQlUaGUgam9iIHdpbGwgdXNlIHRoZSBzYW1lIHRlcm1pbmFsIGFzIFZpbS4gIElmIGl0IHJlYWRzIGZyb20KCQlzdGRpbiB0aGUgam9iIGFuZCBWaW0gd2lsbCBiZSBmaWdodGluZyBvdmVyIGlucHV0LCB0aGF0CgkJZG9lc24ndCB3b3JrLiAgUmVkaXJlY3Qgc3RkaW4gYW5kIHN0ZG91dCB0byBhdm9pZCBwcm9ibGVtczogPgoJbGV0IGpvYiA9IGpvYl9zdGFydChbJ3NoJywgJy1jJywgIm15c2VydmVyIDwvZGV2L251bGwgPi9kZXYvbnVsbCJdKQo8CgkJVGhlIHJldHVybmVkIEpvYiBvYmplY3QgY2FuIGJlIHVzZWQgdG8gZ2V0IHRoZSBzdGF0dXMgd2l0aAoJCXxqb2Jfc3RhdHVzKCl8IGFuZCBzdG9wIHRoZSBqb2Igd2l0aCB8am9iX3N0b3AoKXwuCgoJCXtvcHRpb25zfSBtdXN0IGJlIGEgRGljdGlvbmFyeS4gIEl0IGNhbiBjb250YWluIG1hbnkgb3B0aW9uYWwKCQlpdGVtcywgc2VlIHxqb2Itb3B0aW9uc3wuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwram9ifCBmZWF0dXJlfQoKam9iX3N0YXR1cyh7am9ifSkJCQkJCSpqb2Jfc3RhdHVzKCkqICpFOTE2KgoJCVJldHVybnMgYSBTdHJpbmcgd2l0aCB0aGUgc3RhdHVzIG9mIHtqb2J9OgoJCQkicnVuIglqb2IgaXMgcnVubmluZwoJCQkiZmFpbCIJam9iIGZhaWxlZCB0byBzdGFydAoJCQkiZGVhZCIJam9iIGRpZWQgb3Igd2FzIHN0b3BwZWQgYWZ0ZXIgcnVubmluZwoJCQoJCUlmIGFuIGV4aXQgY2FsbGJhY2sgd2FzIHNldCB3aXRoIHRoZSAiZXhpdF9jYiIgb3B0aW9uIGFuZCB0aGUKCQlqb2IgaXMgbm93IGRldGVjdGVkIHRvIGJlICJkZWFkIiB0aGUgY2FsbGJhY2sgd2lsbCBiZSBpbnZva2VkLgoKCQlGb3IgbW9yZSBpbmZvcm1hdGlvbiBzZWUgfGpvYl9pbmZvKCl8LgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2pvYnwgZmVhdHVyZX0KCmpvYl9zdG9wKHtqb2J9IFssIHtob3d9XSkJCQkJCSpqb2Jfc3RvcCgpKgoJCVN0b3AgdGhlIHtqb2J9LiAgVGhpcyBjYW4gYWxzbyBiZSB1c2VkIHRvIHNpZ25hbCB0aGUgam9iLgoKCQlXaGVuIHtob3d9IGlzIG9taXR0ZWQgb3IgaXMgInRlcm0iIHRoZSBqb2Igd2lsbCBiZSB0ZXJtaW5hdGVkLgoJCUZvciBVbml4IFNJR1RFUk0gaXMgc2VudC4gIE9uIE1TLVdpbmRvd3MgdGhlIGpvYiB3aWxsIGJlCgkJdGVybWluYXRlZCBmb3JjZWRseSAodGhlcmUgaXMgbm8gImdlbnRsZSIgd2F5KS4KCQlUaGlzIGdvZXMgdG8gdGhlIHByb2Nlc3MgZ3JvdXAsIHRodXMgY2hpbGRyZW4gbWF5IGFsc28gYmUKCQlhZmZlY3RlZC4KCgkJRWZmZWN0IGZvciBVbml4OgoJCQkidGVybSIJIFNJR1RFUk0gKGRlZmF1bHQpCgkJCSJodXAiCSBTSUdIVVAKCQkJInF1aXQiCSBTSUdRVUlUCgkJCSJpbnQiCSBTSUdJTlQKCQkJImtpbGwiCSBTSUdLSUxMIChzdHJvbmdlc3Qgd2F5IHRvIHN0b3ApCgkJCW51bWJlcgkgc2lnbmFsIHdpdGggdGhhdCBudW1iZXIKCgkJRWZmZWN0IGZvciBNUy1XaW5kb3dzOgoJCQkidGVybSIJIHRlcm1pbmF0ZSBwcm9jZXNzIGZvcmNlZGx5IChkZWZhdWx0KQoJCQkiaHVwIgkgQ1RSTF9CUkVBSwoJCQkicXVpdCIJIENUUkxfQlJFQUsKCQkJImludCIJIENUUkxfQwoJCQkia2lsbCIJIHRlcm1pbmF0ZSBwcm9jZXNzIGZvcmNlZGx5CgkJCU90aGVycwkgQ1RSTF9CUkVBSwoKCQlPbiBVbml4IHRoZSBzaWduYWwgaXMgc2VudCB0byB0aGUgcHJvY2VzcyBncm91cC4gIFRoaXMgbWVhbnMKCQl0aGF0IHdoZW4gdGhlIGpvYiBpcyAic2ggLWMgY29tbWFuZCIgaXQgYWZmZWN0cyBib3RoIHRoZSBzaGVsbAoJCWFuZCB0aGUgY29tbWFuZC4KCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlcjogMSBpZiB0aGUgb3BlcmF0aW9uIGNvdWxkIGJlIGV4ZWN1dGVkLAoJCTAgaWYgImhvdyIgaXMgbm90IHN1cHBvcnRlZCBvbiB0aGUgc3lzdGVtLgoJCU5vdGUgdGhhdCBldmVuIHdoZW4gdGhlIG9wZXJhdGlvbiB3YXMgZXhlY3V0ZWQsIHdoZXRoZXIgdGhlCgkJam9iIHdhcyBhY3R1YWxseSBzdG9wcGVkIG5lZWRzIHRvIGJlIGNoZWNrZWQgd2l0aAoJCWpvYl9zdGF0dXMoKS4KCQlUaGUgc3RhdHVzIG9mIHRoZSBqb2IgaXNuJ3QgY2hlY2tlZCwgdGhlIG9wZXJhdGlvbiB3aWxsIGV2ZW4KCQliZSBkb25lIHdoZW4gVmltIHRoaW5rcyB0aGUgam9iIGlzbid0IHJ1bm5pbmcuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwram9ifCBmZWF0dXJlfQoKam9pbih7bGlzdH0gWywge3NlcH1dKQkJCQkJKmpvaW4oKSoKCQlKb2luIHRoZSBpdGVtcyBpbiB7bGlzdH0gdG9nZXRoZXIgaW50byBvbmUgU3RyaW5nLgoJCVdoZW4ge3NlcH0gaXMgc3BlY2lmaWVkIGl0IGlzIHB1dCBpbiBiZXR3ZWVuIHRoZSBpdGVtcy4gIElmCgkJe3NlcH0gaXMgb21pdHRlZCBhIHNpbmdsZSBzcGFjZSBpcyB1c2VkLgoJCU5vdGUgdGhhdCB7c2VwfSBpcyBub3QgYWRkZWQgYXQgdGhlIGVuZC4gIFlvdSBtaWdodCB3YW50IHRvCgkJYWRkIGl0IHRoZXJlIHRvbzogPgoJCQlsZXQgbGluZXMgPSBqb2luKG15bGlzdCwgIlxuIikgLiAiXG4iCjwJCVN0cmluZyBpdGVtcyBhcmUgdXNlZCBhcy1pcy4gIHxMaXN0c3wgYW5kIHxEaWN0aW9uYXJpZXN8IGFyZQoJCWNvbnZlcnRlZCBpbnRvIGEgc3RyaW5nIGxpa2Ugd2l0aCB8c3RyaW5nKCl8LgoJCVRoZSBvcHBvc2l0ZSBmdW5jdGlvbiBpcyB8c3BsaXQoKXwuCgpqc19kZWNvZGUoe3N0cmluZ30pCQkJCQkqanNfZGVjb2RlKCkqCgkJVGhpcyBpcyBzaW1pbGFyIHRvIHxqc29uX2RlY29kZSgpfCB3aXRoIHRoZXNlIGRpZmZlcmVuY2VzOgoJCS0gT2JqZWN0IGtleSBuYW1lcyBkbyBub3QgaGF2ZSB0byBiZSBpbiBxdW90ZXMuCgkJLSBFbXB0eSBpdGVtcyBpbiBhbiBhcnJheSAoYmV0d2VlbiB0d28gY29tbWFzKSBhcmUgYWxsb3dlZCBhbmQKCQkgIHJlc3VsdCBpbiB2Om5vbmUgaXRlbXMuCgpqc19lbmNvZGUoe2V4cHJ9KQkJCQkJKmpzX2VuY29kZSgpKgoJCVRoaXMgaXMgc2ltaWxhciB0byB8anNvbl9lbmNvZGUoKXwgd2l0aCB0aGVzZSBkaWZmZXJlbmNlczoKCQktIE9iamVjdCBrZXkgbmFtZXMgYXJlIG5vdCBpbiBxdW90ZXMuCgkJLSB2Om5vbmUgaXRlbXMgaW4gYW4gYXJyYXkgcmVzdWx0IGluIGFuIGVtcHR5IGl0ZW0gYmV0d2VlbgoJCSAgY29tbWFzLgoJCUZvciBleGFtcGxlLCB0aGUgVmltIG9iamVjdDoKCQkJWzEsdjpub25lLHsib25lIjoxfSx2Om5vbmVdIH4KCQlXaWxsIGJlIGVuY29kZWQgYXM6CgkJCVsxLCx7b25lOjF9LCxdIH4KCQlXaGlsZSBqc29uX2VuY29kZSgpIHdvdWxkIHByb2R1Y2U6CgkJCVsxLG51bGwseyJvbmUiOjF9LG51bGxdIH4KCQlUaGlzIGVuY29kaW5nIGlzIHZhbGlkIGZvciBKYXZhU2NyaXB0LiBJdCBpcyBtb3JlIGVmZmljaWVudAoJCXRoYW4gSlNPTiwgZXNwZWNpYWxseSB3aGVuIHVzaW5nIGFuIGFycmF5IHdpdGggb3B0aW9uYWwgaXRlbXMuCgoKanNvbl9kZWNvZGUoe3N0cmluZ30pCQkJCQkqanNvbl9kZWNvZGUoKSoKCQlUaGlzIHBhcnNlcyBhIEpTT04gZm9ybWF0dGVkIHN0cmluZyBhbmQgcmV0dXJucyB0aGUgZXF1aXZhbGVudAoJCWluIFZpbSB2YWx1ZXMuICBTZWUgfGpzb25fZW5jb2RlKCl8IGZvciB0aGUgcmVsYXRpb24gYmV0d2VlbgoJCUpTT04gYW5kIFZpbSB2YWx1ZXMuCgkJVGhlIGRlY29kaW5nIGlzIHBlcm1pc3NpdmU6CgkJLSBBIHRyYWlsaW5nIGNvbW1hIGluIGFuIGFycmF5IGFuZCBvYmplY3QgaXMgaWdub3JlZC4KCQktIE1vcmUgZmxvYXRpbmcgcG9pbnQgbnVtYmVycyBhcmUgcmVjb2duaXplZCwgZS5nLiAiMS4iIGZvcgoJCSAgIjEuMCIuCgkJVGhlIHJlc3VsdCBtdXN0IGJlIGEgdmFsaWQgVmltIHR5cGU6CgkJLSBBbiBlbXB0eSBvYmplY3QgbWVtYmVyIG5hbWUgaXMgbm90IGFsbG93ZWQuCgkJLSBEdXBsaWNhdGUgb2JqZWN0IG1lbWJlciBuYW1lcyBhcmUgbm90IGFsbG93ZWQuCgpqc29uX2VuY29kZSh7ZXhwcn0pCQkJCQkqanNvbl9lbmNvZGUoKSoKCQlFbmNvZGUge2V4cHJ9IGFzIEpTT04gYW5kIHJldHVybiB0aGlzIGFzIGEgc3RyaW5nLgoJCVRoZSBlbmNvZGluZyBpcyBzcGVjaWZpZWQgaW46CgkJaHR0cHM6Ly90b29scy5pZXRmLm9yZy9odG1sL3JmYzcxNTkuaHRtbAoJCVZpbSB2YWx1ZXMgYXJlIGNvbnZlcnRlZCBhcyBmb2xsb3dzOgoJCSAgIE51bWJlcgkJZGVjaW1hbCBudW1iZXIKCQkgICBGbG9hdAkJZmxvYXRpbmcgcG9pbnQgbnVtYmVyCgkJICAgRmxvYXQgbmFuCQkiTmFOIgoJCSAgIEZsb2F0IGluZgkJIkluZmluaXR5IgoJCSAgIFN0cmluZwkJaW4gZG91YmxlIHF1b3RlcyAocG9zc2libHkgbnVsbCkKCQkgICBGdW5jcmVmCQlub3QgcG9zc2libGUsIGVycm9yCgkJICAgTGlzdAkJCWFzIGFuIGFycmF5IChwb3NzaWJseSBudWxsKTsgd2hlbgoJCQkJCXVzZWQgcmVjdXJzaXZlbHk6IFtdCgkJICAgRGljdAkJCWFzIGFuIG9iamVjdCAocG9zc2libHkgbnVsbCk7IHdoZW4KCQkJCQl1c2VkIHJlY3Vyc2l2ZWx5OiB7fQoJCSAgIHY6ZmFsc2UJCSJmYWxzZSIKCQkgICB2OnRydWUJCSJ0cnVlIgoJCSAgIHY6bm9uZQkJIm51bGwiCgkJICAgdjpudWxsCQkibnVsbCIKCQlOb3RlIHRoYXQgTmFOIGFuZCBJbmZpbml0eSBhcmUgcGFzc2VkIG9uIGFzIHZhbHVlcy4gIFRoaXMgaXMKCQltaXNzaW5nIGluIHRoZSBKU09OIHN0YW5kYXJkLCBidXQgc2V2ZXJhbCBpbXBsZW1lbnRhdGlvbnMgZG8KCQlhbGxvdyBpdC4gIElmIG5vdCB0aGVuIHlvdSB3aWxsIGdldCBhbiBlcnJvci4KCmtleXMoe2RpY3R9KQkJCQkJCSprZXlzKCkqCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggYWxsIHRoZSBrZXlzIG9mIHtkaWN0fS4gIFRoZSB8TGlzdHwgaXMgaW4KCQlhcmJpdHJhcnkgb3JkZXIuCgoJCQkJCQkJKmxlbigpKiAqRTcwMSoKbGVuKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGxlbmd0aCBvZiB0aGUgYXJndW1lbnQuCgkJV2hlbiB7ZXhwcn0gaXMgYSBTdHJpbmcgb3IgYSBOdW1iZXIgdGhlIGxlbmd0aCBpbiBieXRlcyBpcwoJCXVzZWQsIGFzIHdpdGggfHN0cmxlbigpfC4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSB8TGlzdHwgaXMKCQlyZXR1cm5lZC4KCQlXaGVuIHtleHByfSBpcyBhIHxEaWN0aW9uYXJ5fCB0aGUgbnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlCgkJfERpY3Rpb25hcnl8IGlzIHJldHVybmVkLgoJCU90aGVyd2lzZSBhbiBlcnJvciBpcyBnaXZlbi4KCgkJCQkJCSpsaWJjYWxsKCkqICpFMzY0KiAqRTM2OCoKbGliY2FsbCh7bGlibmFtZX0sIHtmdW5jbmFtZX0sIHthcmd1bWVudH0pCgkJQ2FsbCBmdW5jdGlvbiB7ZnVuY25hbWV9IGluIHRoZSBydW4tdGltZSBsaWJyYXJ5IHtsaWJuYW1lfQoJCXdpdGggc2luZ2xlIGFyZ3VtZW50IHthcmd1bWVudH0uCgkJVGhpcyBpcyB1c2VmdWwgdG8gY2FsbCBmdW5jdGlvbnMgaW4gYSBsaWJyYXJ5IHRoYXQgeW91CgkJZXNwZWNpYWxseSBtYWRlIHRvIGJlIHVzZWQgd2l0aCBWaW0uICBTaW5jZSBvbmx5IG9uZSBhcmd1bWVudAoJCWlzIHBvc3NpYmxlLCBjYWxsaW5nIHN0YW5kYXJkIGxpYnJhcnkgZnVuY3Rpb25zIGlzIHJhdGhlcgoJCWxpbWl0ZWQuCgkJVGhlIHJlc3VsdCBpcyB0aGUgU3RyaW5nIHJldHVybmVkIGJ5IHRoZSBmdW5jdGlvbi4gIElmIHRoZQoJCWZ1bmN0aW9uIHJldHVybnMgTlVMTCwgdGhpcyB3aWxsIGFwcGVhciBhcyBhbiBlbXB0eSBzdHJpbmcgIiIKCQl0byBWaW0uCgkJSWYgdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBudW1iZXIsIHVzZSBsaWJjYWxsbnIoKSEKCQlJZiB7YXJndW1lbnR9IGlzIGEgbnVtYmVyLCBpdCBpcyBwYXNzZWQgdG8gdGhlIGZ1bmN0aW9uIGFzIGFuCgkJaW50OyBpZiB7YXJndW1lbnR9IGlzIGEgc3RyaW5nLCBpdCBpcyBwYXNzZWQgYXMgYQoJCW51bGwtdGVybWluYXRlZCBzdHJpbmcuCgkJVGhpcyBmdW5jdGlvbiB3aWxsIGZhaWwgaW4gfHJlc3RyaWN0ZWQtbW9kZXwuCgoJCWxpYmNhbGwoKSBhbGxvd3MgeW91IHRvIHdyaXRlIHlvdXIgb3duICdwbHVnLWluJyBleHRlbnNpb25zIHRvCgkJVmltIHdpdGhvdXQgaGF2aW5nIHRvIHJlY29tcGlsZSB0aGUgcHJvZ3JhbS4gIEl0IGlzIE5PVCBhCgkJbWVhbnMgdG8gY2FsbCBzeXN0ZW0gZnVuY3Rpb25zISAgSWYgeW91IHRyeSB0byBkbyBzbyBWaW0gd2lsbAoJCXZlcnkgcHJvYmFibHkgY3Jhc2guCgoJCUZvciBXaW4zMiwgdGhlIGZ1bmN0aW9ucyB5b3Ugd3JpdGUgbXVzdCBiZSBwbGFjZWQgaW4gYSBETEwKCQlhbmQgdXNlIHRoZSBub3JtYWwgQyBjYWxsaW5nIGNvbnZlbnRpb24gKE5PVCBQYXNjYWwgd2hpY2ggaXMKCQl1c2VkIGluIFdpbmRvd3MgU3lzdGVtIERMTHMpLiAgVGhlIGZ1bmN0aW9uIG11c3QgdGFrZSBleGFjdGx5CgkJb25lIHBhcmFtZXRlciwgZWl0aGVyIGEgY2hhcmFjdGVyIHBvaW50ZXIgb3IgYSBsb25nIGludGVnZXIsCgkJYW5kIG11c3QgcmV0dXJuIGEgY2hhcmFjdGVyIHBvaW50ZXIgb3IgTlVMTC4gIFRoZSBjaGFyYWN0ZXIKCQlwb2ludGVyIHJldHVybmVkIG11c3QgcG9pbnQgdG8gbWVtb3J5IHRoYXQgd2lsbCByZW1haW4gdmFsaWQKCQlhZnRlciB0aGUgZnVuY3Rpb24gaGFzIHJldHVybmVkIChlLmcuIGluIHN0YXRpYyBkYXRhIGluIHRoZQoJCURMTCkuICBJZiBpdCBwb2ludHMgdG8gYWxsb2NhdGVkIG1lbW9yeSwgdGhhdCBtZW1vcnkgd2lsbAoJCWxlYWsgYXdheS4gIFVzaW5nIGEgc3RhdGljIGJ1ZmZlciBpbiB0aGUgZnVuY3Rpb24gc2hvdWxkIHdvcmssCgkJaXQncyB0aGVuIGZyZWVkIHdoZW4gdGhlIERMTCBpcyB1bmxvYWRlZC4KCgkJV0FSTklORzogSWYgdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBub24tdmFsaWQgcG9pbnRlciwgVmltIG1heQoJCWNyYXNoIQlUaGlzIGFsc28gaGFwcGVucyBpZiB0aGUgZnVuY3Rpb24gcmV0dXJucyBhIG51bWJlciwKCQliZWNhdXNlIFZpbSB0aGlua3MgaXQncyBhIHBvaW50ZXIuCgkJRm9yIFdpbjMyIHN5c3RlbXMsIHtsaWJuYW1lfSBzaG91bGQgYmUgdGhlIGZpbGVuYW1lIG9mIHRoZSBETEwKCQl3aXRob3V0IHRoZSAiLkRMTCIgc3VmZml4LiAgQSBmdWxsIHBhdGggaXMgb25seSByZXF1aXJlZCBpZgoJCXRoZSBETEwgaXMgbm90IGluIHRoZSB1c3VhbCBwbGFjZXMuCgkJRm9yIFVuaXg6IFdoZW4gY29tcGlsaW5nIHlvdXIgb3duIHBsdWdpbnMsIHJlbWVtYmVyIHRoYXQgdGhlCgkJb2JqZWN0IGNvZGUgbXVzdCBiZSBjb21waWxlZCBhcyBwb3NpdGlvbi1pbmRlcGVuZGVudCAoJ1BJQycpLgoJCXtvbmx5IGluIFdpbjMyIGFuZCBzb21lIFVuaXggdmVyc2lvbnMsIHdoZW4gdGhlIHwrbGliY2FsbHwKCQlmZWF0dXJlIGlzIHByZXNlbnR9CgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gbGliY2FsbCgibGliYy5zbyIsICJnZXRlbnYiLCAiSE9NRSIpCjwKCQkJCQkJCSpsaWJjYWxsbnIoKSoKbGliY2FsbG5yKHtsaWJuYW1lfSwge2Z1bmNuYW1lfSwge2FyZ3VtZW50fSkKCQlKdXN0IGxpa2UgfGxpYmNhbGwoKXwsIGJ1dCB1c2VkIGZvciBhIGZ1bmN0aW9uIHRoYXQgcmV0dXJucyBhbgoJCWludCBpbnN0ZWFkIG9mIGEgc3RyaW5nLgoJCXtvbmx5IGluIFdpbjMyIG9uIHNvbWUgVW5peCB2ZXJzaW9ucywgd2hlbiB0aGUgfCtsaWJjYWxsfAoJCWZlYXR1cmUgaXMgcHJlc2VudH0KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBsaWJjYWxsbnIoIi91c3IvbGliL2xpYmMuc28iLCAiZ2V0cGlkIiwgIiIpCgkJCTpjYWxsIGxpYmNhbGxucigibGliYy5zbyIsICJwcmludGYiLCAiSGVsbG8gV29ybGQhXG4iKQoJCQk6Y2FsbCBsaWJjYWxsbnIoImxpYmMuc28iLCAic2xlZXAiLCAxMCkKPAoJCQkJCQkJKmxpbmUoKSoKbGluZSh7ZXhwcn0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBsaW5lIG51bWJlciBvZiB0aGUgZmlsZQoJCXBvc2l0aW9uIGdpdmVuIHdpdGgge2V4cHJ9LiAgVGhlIGFjY2VwdGVkIHBvc2l0aW9ucyBhcmU6CgkJICAgIC4JICAgIHRoZSBjdXJzb3IgcG9zaXRpb24KCQkgICAgJAkgICAgdGhlIGxhc3QgbGluZSBpbiB0aGUgY3VycmVudCBidWZmZXIKCQkgICAgJ3gJICAgIHBvc2l0aW9uIG9mIG1hcmsgeCAoaWYgdGhlIG1hcmsgaXMgbm90IHNldCwgMCBpcwoJCQkgICAgcmV0dXJuZWQpCgkJICAgIHcwCSAgICBmaXJzdCBsaW5lIHZpc2libGUgaW4gY3VycmVudCB3aW5kb3cKCQkgICAgdyQJICAgIGxhc3QgbGluZSB2aXNpYmxlIGluIGN1cnJlbnQgd2luZG93CgkJICAgIHYJICAgIEluIFZpc3VhbCBtb2RlOiB0aGUgc3RhcnQgb2YgdGhlIFZpc3VhbCBhcmVhICh0aGUKCQkJICAgIGN1cnNvciBpcyB0aGUgZW5kKS4gIFdoZW4gbm90IGluIFZpc3VhbCBtb2RlCgkJCSAgICByZXR1cm5zIHRoZSBjdXJzb3IgcG9zaXRpb24uICBEaWZmZXJzIGZyb20gfCc8fCBpbgoJCQkgICAgdGhhdCBpdCdzIHVwZGF0ZWQgcmlnaHQgYXdheS4KCQlOb3RlIHRoYXQgYSBtYXJrIGluIGFub3RoZXIgZmlsZSBjYW4gYmUgdXNlZC4gIFRoZSBsaW5lIG51bWJlcgoJCXRoZW4gYXBwbGllcyB0byBhbm90aGVyIGJ1ZmZlci4KCQlUbyBnZXQgdGhlIGNvbHVtbiBudW1iZXIgdXNlIHxjb2woKXwuICBUbyBnZXQgYm90aCB1c2UKCQl8Z2V0cG9zKCl8LgoJCUV4YW1wbGVzOiA+CgkJCWxpbmUoIi4iKQkJbGluZSBudW1iZXIgb2YgdGhlIGN1cnNvcgoJCQlsaW5lKCIndCIpCQlsaW5lIG51bWJlciBvZiBtYXJrIHQKCQkJbGluZSgiJyIgLiBtYXJrZXIpCWxpbmUgbnVtYmVyIG9mIG1hcmsgbWFya2VyCjwJCQkJCQkJKmxhc3QtcG9zaXRpb24tanVtcCoKCQlUaGlzIGF1dG9jb21tYW5kIGp1bXBzIHRvIHRoZSBsYXN0IGtub3duIHBvc2l0aW9uIGluIGEgZmlsZQoJCWp1c3QgYWZ0ZXIgb3BlbmluZyBpdCwgaWYgdGhlICciIG1hcmsgaXMgc2V0OiA+Cgk6YXUgQnVmUmVhZFBvc3QgKiBpZiBsaW5lKCInXCIiKSA+IDEgJiYgbGluZSgiJ1wiIikgPD0gbGluZSgiJCIpIHwgZXhlICJub3JtYWwhIGdgXCIiIHwgZW5kaWYKCmxpbmUyYnl0ZSh7bG51bX0pCQkJCQkqbGluZTJieXRlKCkqCgkJUmV0dXJuIHRoZSBieXRlIGNvdW50IGZyb20gdGhlIHN0YXJ0IG9mIHRoZSBidWZmZXIgZm9yIGxpbmUKCQl7bG51bX0uICBUaGlzIGluY2x1ZGVzIHRoZSBlbmQtb2YtbGluZSBjaGFyYWN0ZXIsIGRlcGVuZGluZyBvbgoJCXRoZSAnZmlsZWZvcm1hdCcgb3B0aW9uIGZvciB0aGUgY3VycmVudCBidWZmZXIuICBUaGUgZmlyc3QKCQlsaW5lIHJldHVybnMgMS4gJ2VuY29kaW5nJyBtYXR0ZXJzLCAnZmlsZWVuY29kaW5nJyBpcyBpZ25vcmVkLgoJCVRoaXMgY2FuIGFsc28gYmUgdXNlZCB0byBnZXQgdGhlIGJ5dGUgY291bnQgZm9yIHRoZSBsaW5lIGp1c3QKCQliZWxvdyB0aGUgbGFzdCBsaW5lOiA+CgkJCWxpbmUyYnl0ZShsaW5lKCIkIikgKyAxKQo8CQlUaGlzIGlzIHRoZSBidWZmZXIgc2l6ZSBwbHVzIG9uZS4gIElmICdmaWxlZW5jb2RpbmcnIGlzIGVtcHR5CgkJaXQgaXMgdGhlIGZpbGUgc2l6ZSBwbHVzIG9uZS4KCQlXaGVuIHtsbnVtfSBpcyBpbnZhbGlkLCBvciB0aGUgfCtieXRlX29mZnNldHwgZmVhdHVyZSBoYXMgYmVlbgoJCWRpc2FibGVkIGF0IGNvbXBpbGUgdGltZSwgLTEgaXMgcmV0dXJuZWQuCgkJQWxzbyBzZWUgfGJ5dGUybGluZSgpfCwgfGdvfCBhbmQgfDpnb3RvfC4KCmxpc3BpbmRlbnQoe2xudW19KQkJCQkJKmxpc3BpbmRlbnQoKSoKCQlHZXQgdGhlIGFtb3VudCBvZiBpbmRlbnQgZm9yIGxpbmUge2xudW19IGFjY29yZGluZyB0aGUgbGlzcAoJCWluZGVudGluZyBydWxlcywgYXMgd2l0aCAnbGlzcCcuCgkJVGhlIGluZGVudCBpcyBjb3VudGVkIGluIHNwYWNlcywgdGhlIHZhbHVlIG9mICd0YWJzdG9wJyBpcwoJCXJlbGV2YW50LiAge2xudW19IGlzIHVzZWQganVzdCBsaWtlIGluIHxnZXRsaW5lKCl8LgoJCVdoZW4ge2xudW19IGlzIGludmFsaWQgb3IgVmltIHdhcyBub3QgY29tcGlsZWQgdGhlCgkJfCtsaXNwaW5kZW50fCBmZWF0dXJlLCAtMSBpcyByZXR1cm5lZC4KCmxvY2FsdGltZSgpCQkJCQkJKmxvY2FsdGltZSgpKgoJCVJldHVybiB0aGUgY3VycmVudCB0aW1lLCBtZWFzdXJlZCBhcyBzZWNvbmRzIHNpbmNlIDFzdCBKYW4KCQkxOTcwLiAgU2VlIGFsc28gfHN0cmZ0aW1lKCl8IGFuZCB8Z2V0ZnRpbWUoKXwuCgoKbG9nKHtleHByfSkJCQkJCQkqbG9nKCkqCgkJUmV0dXJuIHRoZSBuYXR1cmFsIGxvZ2FyaXRobSAoYmFzZSBlKSBvZiB7ZXhwcn0gYXMgYSB8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8IGluIHRoZSByYW5nZQoJCSgwLCBpbmZdLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGxvZygxMCkKPAkJCTIuMzAyNTg1ID4KCQkJOmVjaG8gbG9nKGV4cCg1KSkKPAkJCTUuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKbG9nMTAoe2V4cHJ9KQkJCQkJCSpsb2cxMCgpKgoJCVJldHVybiB0aGUgbG9nYXJpdGhtIG9mIEZsb2F0IHtleHByfSB0byBiYXNlIDEwIGFzIGEgfEZsb2F0fC4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBsb2cxMCgxMDAwKQo8CQkJMy4wID4KCQkJOmVjaG8gbG9nMTAoMC4wMSkKPAkJCS0yLjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoJCQpsdWFldmFsKHtleHByfVssIHtleHByfV0pCQkJCQkqbHVhZXZhbCgpKgoJCUV2YWx1YXRlIEx1YSBleHByZXNzaW9uIHtleHByfSBhbmQgcmV0dXJuIGl0cyByZXN1bHQgY29udmVydGVkIAoJCXRvIFZpbSBkYXRhIHN0cnVjdHVyZXMuIFNlY29uZCB7ZXhwcn0gbWF5IGhvbGQgYWRkaXRpb25hbCAKCQlhcmd1bWVudCBhY2Nlc3NpYmxlIGFzIF9BIGluc2lkZSBmaXJzdCB7ZXhwcn0uCgkJU3RyaW5ncyBhcmUgcmV0dXJuZWQgYXMgdGhleSBhcmUuCgkJQm9vbGVhbiBvYmplY3RzIGFyZSBjb252ZXJ0ZWQgdG8gbnVtYmVycy4KCQlOdW1iZXJzIGFyZSBjb252ZXJ0ZWQgdG8gfEZsb2F0fCB2YWx1ZXMgaWYgdmltIHdhcyBjb21waWxlZCAKCQl3aXRoIHwrZmxvYXR8IGFuZCB0byBudW1iZXJzIG90aGVyd2lzZS4KCQlEaWN0aW9uYXJpZXMgYW5kIGxpc3RzIG9idGFpbmVkIGJ5IHZpbS5ldmFsKCkgYXJlIHJldHVybmVkIAoJCWFzLWlzLgoJCU90aGVyIG9iamVjdHMgYXJlIHJldHVybmVkIGFzIHplcm8gd2l0aG91dCBhbnkgZXJyb3JzLgoJCVNlZSB8bHVhLWx1YWV2YWx8IGZvciBtb3JlIGRldGFpbHMuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtsdWF8IGZlYXR1cmV9CgptYXAoe2V4cHJ9LCB7c3RyaW5nfSkJCQkJCSptYXAoKSoKCQl7ZXhwcn0gbXVzdCBiZSBhIHxMaXN0fCBvciBhIHxEaWN0aW9uYXJ5fC4KCQlSZXBsYWNlIGVhY2ggaXRlbSBpbiB7ZXhwcn0gd2l0aCB0aGUgcmVzdWx0IG9mIGV2YWx1YXRpbmcKCQl7c3RyaW5nfS4KCQlJbnNpZGUge3N0cmluZ30gfHY6dmFsfCBoYXMgdGhlIHZhbHVlIG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRm9yIGEgfERpY3Rpb25hcnl8IHx2OmtleXwgaGFzIHRoZSBrZXkgb2YgdGhlIGN1cnJlbnQgaXRlbQoJCWFuZCBmb3IgYSB8TGlzdHwgfHY6a2V5fCBoYXMgdGhlIGluZGV4IG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRXhhbXBsZTogPgoJCQk6Y2FsbCBtYXAobXlsaXN0LCAnIj4gIiAuIHY6dmFsIC4gIiA8IicpCjwJCVRoaXMgcHV0cyAiPiAiIGJlZm9yZSBhbmQgIiA8IiBhZnRlciBlYWNoIGl0ZW0gaW4gIm15bGlzdCIuCgoJCU5vdGUgdGhhdCB7c3RyaW5nfSBpcyB0aGUgcmVzdWx0IG9mIGFuIGV4cHJlc3Npb24gYW5kIGlzIHRoZW4KCQl1c2VkIGFzIGFuIGV4cHJlc3Npb24gYWdhaW4uICBPZnRlbiBpdCBpcyBnb29kIHRvIHVzZSBhCgkJfGxpdGVyYWwtc3RyaW5nfCB0byBhdm9pZCBoYXZpbmcgdG8gZG91YmxlIGJhY2tzbGFzaGVzLiAgWW91CgkJc3RpbGwgaGF2ZSB0byBkb3VibGUgJyBxdW90ZXMKCgkJVGhlIG9wZXJhdGlvbiBpcyBkb25lIGluLXBsYWNlLiAgSWYgeW91IHdhbnQgYSB8TGlzdHwgb3IKCQl8RGljdGlvbmFyeXwgdG8gcmVtYWluIHVubW9kaWZpZWQgbWFrZSBhIGNvcHkgZmlyc3Q6ID4KCQkJOmxldCB0bGlzdCA9IG1hcChjb3B5KG15bGlzdCksICcgdjp2YWwgLiAiXHQiJykKCjwJCVJldHVybnMge2V4cHJ9LCB0aGUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCB0aGF0IHdhcyBmaWx0ZXJlZC4KCQlXaGVuIGFuIGVycm9yIGlzIGVuY291bnRlcmVkIHdoaWxlIGV2YWx1YXRpbmcge3N0cmluZ30gbm8KCQlmdXJ0aGVyIGl0ZW1zIGluIHtleHByfSBhcmUgcHJvY2Vzc2VkLgoKCm1hcGFyZyh7bmFtZX1bLCB7bW9kZX0gWywge2FiYnJ9IFssIHtkaWN0fV1dXSkJCQkqbWFwYXJnKCkqCgkJV2hlbiB7ZGljdH0gaXMgb21pdHRlZCBvciB6ZXJvOiBSZXR1cm4gdGhlIHJocyBvZiBtYXBwaW5nCgkJe25hbWV9IGluIG1vZGUge21vZGV9LiAgVGhlIHJldHVybmVkIFN0cmluZyBoYXMgc3BlY2lhbAoJCWNoYXJhY3RlcnMgdHJhbnNsYXRlZCBsaWtlIGluIHRoZSBvdXRwdXQgb2YgdGhlICI6bWFwIiBjb21tYW5kCgkJbGlzdGluZy4KCQkKCQlXaGVuIHRoZXJlIGlzIG5vIG1hcHBpbmcgZm9yIHtuYW1lfSwgYW4gZW1wdHkgU3RyaW5nIGlzCgkJcmV0dXJuZWQuCgoJCVRoZSB7bmFtZX0gY2FuIGhhdmUgc3BlY2lhbCBrZXkgbmFtZXMsIGxpa2UgaW4gdGhlICI6bWFwIgoJCWNvbW1hbmQuCgoJCXttb2RlfSBjYW4gYmUgb25lIG9mIHRoZXNlIHN0cmluZ3M6CgkJCSJuIglOb3JtYWwKCQkJInYiCVZpc3VhbCAoaW5jbHVkaW5nIFNlbGVjdCkKCQkJIm8iCU9wZXJhdG9yLXBlbmRpbmcKCQkJImkiCUluc2VydAoJCQkiYyIJQ21kLWxpbmUKCQkJInMiCVNlbGVjdAoJCQkieCIJVmlzdWFsCgkJCSJsIglsYW5nbWFwIHxsYW5ndWFnZS1tYXBwaW5nfAoJCQkiIglOb3JtYWwsIFZpc3VhbCBhbmQgT3BlcmF0b3ItcGVuZGluZwoJCVdoZW4ge21vZGV9IGlzIG9taXR0ZWQsIHRoZSBtb2RlcyBmb3IgIiIgYXJlIHVzZWQuCgoJCVdoZW4ge2FiYnJ9IGlzIHRoZXJlIGFuZCBpdCBpcyBub24temVybyB1c2UgYWJicmV2aWF0aW9ucwoJCWluc3RlYWQgb2YgbWFwcGluZ3MuCgoJCVdoZW4ge2RpY3R9IGlzIHRoZXJlIGFuZCBpdCBpcyBub24temVybyByZXR1cm4gYSBkaWN0aW9uYXJ5CgkJY29udGFpbmluZyBhbGwgdGhlIGluZm9ybWF0aW9uIG9mIHRoZSBtYXBwaW5nIHdpdGggdGhlCgkJZm9sbG93aW5nIGl0ZW1zOgoJCSAgImxocyIJICAgICBUaGUge2xoc30gb2YgdGhlIG1hcHBpbmcuCgkJICAicmhzIgkgICAgIFRoZSB7cmhzfSBvZiB0aGUgbWFwcGluZyBhcyB0eXBlZC4KCQkgICJzaWxlbnQiICAgMSBmb3IgYSB8Om1hcC1zaWxlbnR8IG1hcHBpbmcsIGVsc2UgMC4KCQkgICJub3JlbWFwIiAgMSBpZiB0aGUge3Joc30gb2YgdGhlIG1hcHBpbmcgaXMgbm90IHJlbWFwcGFibGUuCgkJICAiZXhwciIgICAgIDEgZm9yIGFuIGV4cHJlc3Npb24gbWFwcGluZyAofDptYXAtPGV4cHI+fCkuCgkJICAiYnVmZmVyIiAgIDEgZm9yIGEgYnVmZmVyIGxvY2FsIG1hcHBpbmcgKHw6bWFwLWxvY2FsfCkuCgkJICAibW9kZSIgICAgIE1vZGVzIGZvciB3aGljaCB0aGUgbWFwcGluZyBpcyBkZWZpbmVkLiBJbgoJCQkgICAgIGFkZGl0aW9uIHRvIHRoZSBtb2RlcyBtZW50aW9uZWQgYWJvdmUsIHRoZXNlCgkJCSAgICAgY2hhcmFjdGVycyB3aWxsIGJlIHVzZWQ6CgkJCSAgICAgIiAiICAgICBOb3JtYWwsIFZpc3VhbCBhbmQgT3BlcmF0b3ItcGVuZGluZwoJCQkgICAgICIhIiAgICAgSW5zZXJ0IGFuZCBDb21tYW5kbGluZSBtb2RlCgkJCQkgICAgICh8bWFwbW9kZS1pY3wpCgkJICAic2lkIgkgICAgIFRoZSBzY3JpcHQgbG9jYWwgSUQsIHVzZWQgZm9yIDxzaWQ+IG1hcHBpbmdzCgkJCSAgICAgKHw8U0lEPnwpLgoJCSAgIm5vd2FpdCIgICBEbyBub3Qgd2FpdCBmb3Igb3RoZXIsIGxvbmdlciBtYXBwaW5ncy4KCQkJICAgICAofDptYXAtPG5vd2FpdD58KS4KCgkJVGhlIG1hcHBpbmdzIGxvY2FsIHRvIHRoZSBjdXJyZW50IGJ1ZmZlciBhcmUgY2hlY2tlZCBmaXJzdCwKCQl0aGVuIHRoZSBnbG9iYWwgbWFwcGluZ3MuCgkJVGhpcyBmdW5jdGlvbiBjYW4gYmUgdXNlZCB0byBtYXAgYSBrZXkgZXZlbiB3aGVuIGl0J3MgYWxyZWFkeQoJCW1hcHBlZCwgYW5kIGhhdmUgaXQgZG8gdGhlIG9yaWdpbmFsIG1hcHBpbmcgdG9vLiAgU2tldGNoOiA+CgkJCWV4ZSAnbm5vcmVtYXAgPFRhYj4gPT0nIC4gbWFwYXJnKCc8VGFiPicsICduJykKCgptYXBjaGVjayh7bmFtZX1bLCB7bW9kZX0gWywge2FiYnJ9XV0pCQkJKm1hcGNoZWNrKCkqCgkJQ2hlY2sgaWYgdGhlcmUgaXMgYSBtYXBwaW5nIHRoYXQgbWF0Y2hlcyB3aXRoIHtuYW1lfSBpbiBtb2RlCgkJe21vZGV9LiAgU2VlIHxtYXBhcmcoKXwgZm9yIHttb2RlfSBhbmQgc3BlY2lhbCBuYW1lcyBpbgoJCXtuYW1lfS4KCQlXaGVuIHthYmJyfSBpcyB0aGVyZSBhbmQgaXQgaXMgbm9uLXplcm8gdXNlIGFiYnJldmlhdGlvbnMKCQlpbnN0ZWFkIG9mIG1hcHBpbmdzLgoJCUEgbWF0Y2ggaGFwcGVucyB3aXRoIGEgbWFwcGluZyB0aGF0IHN0YXJ0cyB3aXRoIHtuYW1lfSBhbmQKCQl3aXRoIGEgbWFwcGluZyB3aGljaCBpcyBlcXVhbCB0byB0aGUgc3RhcnQgb2Yge25hbWV9LgoKCQkJbWF0Y2hlcyBtYXBwaW5nICJhIgkiYWIiCSJhYmMiIH4KCQkgICBtYXBjaGVjaygiYSIpCXllcwl5ZXMJIHllcwoJCSAgIG1hcGNoZWNrKCJhYmMiKQl5ZXMJeWVzCSB5ZXMKCQkgICBtYXBjaGVjaygiYXgiKQl5ZXMJbm8JIG5vCgkJICAgbWFwY2hlY2soImIiKQlubwlubwkgbm8KCgkJVGhlIGRpZmZlcmVuY2Ugd2l0aCBtYXBhcmcoKSBpcyB0aGF0IG1hcGNoZWNrKCkgZmluZHMgYQoJCW1hcHBpbmcgdGhhdCBtYXRjaGVzIHdpdGgge25hbWV9LCB3aGlsZSBtYXBhcmcoKSBvbmx5IGZpbmRzIGEKCQltYXBwaW5nIGZvciB7bmFtZX0gZXhhY3RseS4KCQlXaGVuIHRoZXJlIGlzIG5vIG1hcHBpbmcgdGhhdCBzdGFydHMgd2l0aCB7bmFtZX0sIGFuIGVtcHR5CgkJU3RyaW5nIGlzIHJldHVybmVkLiAgSWYgdGhlcmUgaXMgb25lLCB0aGUgcmhzIG9mIHRoYXQgbWFwcGluZwoJCWlzIHJldHVybmVkLiAgSWYgdGhlcmUgYXJlIHNldmVyYWwgbWFwcGluZ3MgdGhhdCBzdGFydCB3aXRoCgkJe25hbWV9LCB0aGUgcmhzIG9mIG9uZSBvZiB0aGVtIGlzIHJldHVybmVkLgoJCVRoZSBtYXBwaW5ncyBsb2NhbCB0byB0aGUgY3VycmVudCBidWZmZXIgYXJlIGNoZWNrZWQgZmlyc3QsCgkJdGhlbiB0aGUgZ2xvYmFsIG1hcHBpbmdzLgoJCVRoaXMgZnVuY3Rpb24gY2FuIGJlIHVzZWQgdG8gY2hlY2sgaWYgYSBtYXBwaW5nIGNhbiBiZSBhZGRlZAoJCXdpdGhvdXQgYmVpbmcgYW1iaWd1b3VzLiAgRXhhbXBsZTogPgoJOmlmIG1hcGNoZWNrKCJfdnYiKSA9PSAiIgoJOiAgIG1hcCBfdnYgOnNldCBndWlmb250PTd4MTM8Q1I+Cgk6ZW5kaWYKPAkJVGhpcyBhdm9pZHMgYWRkaW5nIHRoZSAiX3Z2IiBtYXBwaW5nIHdoZW4gdGhlcmUgYWxyZWFkeSBpcyBhCgkJbWFwcGluZyBmb3IgIl92IiBvciBmb3IgIl92dnYiLgoKbWF0Y2goe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCQkJKm1hdGNoKCkqCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgdGhlbiB0aGlzIHJldHVybnMgdGhlIGluZGV4IG9mIHRoZQoJCWZpcnN0IGl0ZW0gd2hlcmUge3BhdH0gbWF0Y2hlcy4gIEVhY2ggaXRlbSBpcyB1c2VkIGFzIGEKCQlTdHJpbmcsIHxMaXN0c3wgYW5kIHxEaWN0aW9uYXJpZXN8IGFyZSB1c2VkIGFzIGVjaG9lZC4KCQlPdGhlcndpc2UsIHtleHByfSBpcyB1c2VkIGFzIGEgU3RyaW5nLglUaGUgcmVzdWx0IGlzIGEKCQlOdW1iZXIsIHdoaWNoIGdpdmVzIHRoZSBpbmRleCAoYnl0ZSBvZmZzZXQpIGluIHtleHByfSB3aGVyZQoJCXtwYXR9IG1hdGNoZXMuCgkJQSBtYXRjaCBhdCB0aGUgZmlyc3QgY2hhcmFjdGVyIG9yIHxMaXN0fCBpdGVtIHJldHVybnMgemVyby4KCQlJZiB0aGVyZSBpcyBubyBtYXRjaCAtMSBpcyByZXR1cm5lZC4KCQlGb3IgZ2V0dGluZyBzdWJtYXRjaGVzIHNlZSB8bWF0Y2hsaXN0KCl8LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gbWF0Y2goInRlc3RpbmciLCAiaW5nIikJIiByZXN1bHRzIGluIDQKCQkJOmVjaG8gbWF0Y2goWzEsICd4J10sICdcYScpCSIgcmVzdWx0cyBpbiAxCjwJCVNlZSB8c3RyaW5nLW1hdGNofCBmb3IgaG93IHtwYXR9IGlzIHVzZWQuCgkJCQkJCQkJKnN0cnBicmsoKSoKCQlWaW0gZG9lc24ndCBoYXZlIGEgc3RycGJyaygpIGZ1bmN0aW9uLglCdXQgeW91IGNhbiBkbzogPgoJCQk6bGV0IHNlcGlkeCA9IG1hdGNoKGxpbmUsICdbLiw7OiBcdF0nKQo8CQkJCQkJCQkqc3RyY2FzZXN0cigpKgoJCVZpbSBkb2Vzbid0IGhhdmUgYSBzdHJjYXNlc3RyKCkgZnVuY3Rpb24uICBCdXQgeW91IGNhbiBhZGQKCQkiXGMiIHRvIHRoZSBwYXR0ZXJuIHRvIGlnbm9yZSBjYXNlOiA+CgkJCTpsZXQgaWR4ID0gbWF0Y2goaGF5c3RhY2ssICdcY25lZWRsZScpCjwKCQlJZiB7c3RhcnR9IGlzIGdpdmVuLCB0aGUgc2VhcmNoIHN0YXJ0cyBmcm9tIGJ5dGUgaW5kZXgKCQl7c3RhcnR9IGluIGEgU3RyaW5nIG9yIGl0ZW0ge3N0YXJ0fSBpbiBhIHxMaXN0fC4KCQlUaGUgcmVzdWx0LCBob3dldmVyLCBpcyBzdGlsbCB0aGUgaW5kZXggY291bnRlZCBmcm9tIHRoZQoJCWZpcnN0IGNoYXJhY3Rlci9pdGVtLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBtYXRjaCgidGVzdGluZyIsICJpbmciLCAyKQo8CQlyZXN1bHQgaXMgYWdhaW4gIjQiLiA+CgkJCTplY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgImluZyIsIDQpCjwJCXJlc3VsdCBpcyBhZ2FpbiAiNCIuID4KCQkJOmVjaG8gbWF0Y2goInRlc3RpbmciLCAidCIsIDIpCjwJCXJlc3VsdCBpcyAiMyIuCgkJRm9yIGEgU3RyaW5nLCBpZiB7c3RhcnR9ID4gMCB0aGVuIGl0IGlzIGxpa2UgdGhlIHN0cmluZyBzdGFydHMKCQl7c3RhcnR9IGJ5dGVzIGxhdGVyLCB0aHVzICJeIiB3aWxsIG1hdGNoIGF0IHtzdGFydH0uICBFeGNlcHQKCQl3aGVuIHtjb3VudH0gaXMgZ2l2ZW4sIHRoZW4gaXQncyBsaWtlIG1hdGNoZXMgYmVmb3JlIHRoZQoJCXtzdGFydH0gYnl0ZSBhcmUgaWdub3JlZCAodGhpcyBpcyBhIGJpdCBjb21wbGljYXRlZCB0byBrZWVwIGl0CgkJYmFja3dhcmRzIGNvbXBhdGlibGUpLgoJCUZvciBhIFN0cmluZywgaWYge3N0YXJ0fSA8IDAsIGl0IHdpbGwgYmUgc2V0IHRvIDAuICBGb3IgYSBsaXN0CgkJdGhlIGluZGV4IGlzIGNvdW50ZWQgZnJvbSB0aGUgZW5kLgoJCUlmIHtzdGFydH0gaXMgb3V0IG9mIHJhbmdlICh7c3RhcnR9ID4gc3RybGVuKHtleHByfSkgZm9yIGEKCQlTdHJpbmcgb3Ige3N0YXJ0fSA+IGxlbih7ZXhwcn0pIGZvciBhIHxMaXN0fCkgLTEgaXMgcmV0dXJuZWQuCgoJCVdoZW4ge2NvdW50fSBpcyBnaXZlbiB1c2UgdGhlIHtjb3VudH0ndGggbWF0Y2guICBXaGVuIGEgbWF0Y2gKCQlpcyBmb3VuZCBpbiBhIFN0cmluZyB0aGUgc2VhcmNoIGZvciB0aGUgbmV4dCBvbmUgc3RhcnRzIG9uZQoJCWNoYXJhY3RlciBmdXJ0aGVyLiAgVGh1cyB0aGlzIGV4YW1wbGUgcmVzdWx0cyBpbiAxOiA+CgkJCWVjaG8gbWF0Y2goInRlc3RpbmciLCAiLi4iLCAwLCAyKQo8CQlJbiBhIHxMaXN0fCB0aGUgc2VhcmNoIGNvbnRpbnVlcyBpbiB0aGUgbmV4dCBpdGVtLgoJCU5vdGUgdGhhdCB3aGVuIHtjb3VudH0gaXMgYWRkZWQgdGhlIHdheSB7c3RhcnR9IHdvcmtzIGNoYW5nZXMsCgkJc2VlIGFib3ZlLgoKCQlTZWUgfHBhdHRlcm58IGZvciB0aGUgcGF0dGVybnMgdGhhdCBhcmUgYWNjZXB0ZWQuCgkJVGhlICdpZ25vcmVjYXNlJyBvcHRpb24gaXMgdXNlZCB0byBzZXQgdGhlIGlnbm9yZS1jYXNlbmVzcyBvZgoJCXRoZSBwYXR0ZXJuLiAgJ3NtYXJ0Y2FzZScgaXMgTk9UIHVzZWQuCVRoZSBtYXRjaGluZyBpcyBhbHdheXMKCQlkb25lIGxpa2UgJ21hZ2ljJyBpcyBzZXQgYW5kICdjcG9wdGlvbnMnIGlzIGVtcHR5LgoKCQkJCQkqbWF0Y2hhZGQoKSogKkU3OTgqICpFNzk5KiAqRTgwMSoKbWF0Y2hhZGQoe2dyb3VwfSwge3BhdHRlcm59Wywge3ByaW9yaXR5fVssIHtpZH1bLCB7ZGljdH1dXV0pCgkJRGVmaW5lcyBhIHBhdHRlcm4gdG8gYmUgaGlnaGxpZ2h0ZWQgaW4gdGhlIGN1cnJlbnQgd2luZG93IChhCgkJIm1hdGNoIikuICBJdCB3aWxsIGJlIGhpZ2hsaWdodGVkIHdpdGgge2dyb3VwfS4gIFJldHVybnMgYW4KCQlpZGVudGlmaWNhdGlvbiBudW1iZXIgKElEKSwgd2hpY2ggY2FuIGJlIHVzZWQgdG8gZGVsZXRlIHRoZQoJCW1hdGNoIHVzaW5nIHxtYXRjaGRlbGV0ZSgpfC4KCQlNYXRjaGluZyBpcyBjYXNlIHNlbnNpdGl2ZSBhbmQgbWFnaWMsIHVubGVzcyBjYXNlIHNlbnNpdGl2aXR5CgkJb3IgbWFnaWNuZXNzIGFyZSBleHBsaWNpdGx5IG92ZXJyaWRkZW4gaW4ge3BhdHRlcm59LiAgVGhlCgkJJ21hZ2ljJywgJ3NtYXJ0Y2FzZScgYW5kICdpZ25vcmVjYXNlJyBvcHRpb25zIGFyZSBub3QgdXNlZC4KCQlUaGUgIkNvbmNlYWwiIHZhbHVlIGlzIHNwZWNpYWwsIGl0IGNhdXNlcyB0aGUgbWF0Y2ggdG8gYmUKCQljb25jZWFsZWQuCgoJCVRoZSBvcHRpb25hbCB7cHJpb3JpdHl9IGFyZ3VtZW50IGFzc2lnbnMgYSBwcmlvcml0eSB0byB0aGUKCQltYXRjaC4JQSBtYXRjaCB3aXRoIGEgaGlnaCBwcmlvcml0eSB3aWxsIGhhdmUgaXRzCgkJaGlnaGxpZ2h0aW5nIG92ZXJydWxlIHRoYXQgb2YgYSBtYXRjaCB3aXRoIGEgbG93ZXIgcHJpb3JpdHkuCgkJQSBwcmlvcml0eSBpcyBzcGVjaWZpZWQgYXMgYW4gaW50ZWdlciAobmVnYXRpdmUgbnVtYmVycyBhcmUgbm8KCQlleGNlcHRpb24pLiAgSWYgdGhlIHtwcmlvcml0eX0gYXJndW1lbnQgaXMgbm90IHNwZWNpZmllZCwgdGhlCgkJZGVmYXVsdCBwcmlvcml0eSBpcyAxMC4gIFRoZSBwcmlvcml0eSBvZiAnaGxzZWFyY2gnIGlzIHplcm8sCgkJaGVuY2UgYWxsIG1hdGNoZXMgd2l0aCBhIHByaW9yaXR5IGdyZWF0ZXIgdGhhbiB6ZXJvIHdpbGwKCQlvdmVycnVsZSBpdC4gIFN5bnRheCBoaWdobGlnaHRpbmcgKHNlZSAnc3ludGF4JykgaXMgYSBzZXBhcmF0ZQoJCW1lY2hhbmlzbSwgYW5kIHJlZ2FyZGxlc3Mgb2YgdGhlIGNob3NlbiBwcmlvcml0eSBhIG1hdGNoIHdpbGwKCQlhbHdheXMgb3ZlcnJ1bGUgc3ludGF4IGhpZ2hsaWdodGluZy4KCgkJVGhlIG9wdGlvbmFsIHtpZH0gYXJndW1lbnQgYWxsb3dzIHRoZSByZXF1ZXN0IGZvciBhIHNwZWNpZmljCgkJbWF0Y2ggSUQuICBJZiBhIHNwZWNpZmllZCBJRCBpcyBhbHJlYWR5IHRha2VuLCBhbiBlcnJvcgoJCW1lc3NhZ2Ugd2lsbCBhcHBlYXIgYW5kIHRoZSBtYXRjaCB3aWxsIG5vdCBiZSBhZGRlZC4gIEFuIElECgkJaXMgc3BlY2lmaWVkIGFzIGEgcG9zaXRpdmUgaW50ZWdlciAoemVybyBleGNsdWRlZCkuICBJRHMgMSwgMgoJCWFuZCAzIGFyZSByZXNlcnZlZCBmb3IgfDptYXRjaHwsIHw6Mm1hdGNofCBhbmQgfDozbWF0Y2h8LAoJCXJlc3BlY3RpdmVseS4gIElmIHRoZSB7aWR9IGFyZ3VtZW50IGlzIG5vdCBzcGVjaWZpZWQgb3IgLTEsCgkJfG1hdGNoYWRkKCl8IGF1dG9tYXRpY2FsbHkgY2hvb3NlcyBhIGZyZWUgSUQuCgoJCVRoZSBvcHRpb25hbCB7ZGljdH0gYXJndW1lbnQgYWxsb3dzIGZvciBmdXJ0aGVyIGN1c3RvbQoJCXZhbHVlcy4gQ3VycmVudGx5IHRoaXMgaXMgdXNlZCB0byBzcGVjaWZ5IGEgbWF0Y2ggc3BlY2lmaWMKCQljb25jZWFsIGNoYXJhY3RlciB0aGF0IHdpbGwgYmUgc2hvd24gZm9yIHxobC1Db25jZWFsfAoJCWhpZ2hsaWdodGVkIG1hdGNoZXMuIFRoZSBkaWN0IGNhbiBoYXZlIHRoZSBmb2xsb3dpbmcgbWVtYmVyczoKCgkJCWNvbmNlYWwJICAgIFNwZWNpYWwgY2hhcmFjdGVyIHRvIHNob3cgaW5zdGVhZCBvZiB0aGUKCQkJCSAgICBtYXRjaCAob25seSBmb3IgfGhsLUNvbmNlYWx8IGhpZ2hsaWdodGVkCgkJCQkgICAgbWF0Y2hlcywgc2VlIHw6c3luLWNjaGFyfCkKCgkJVGhlIG51bWJlciBvZiBtYXRjaGVzIGlzIG5vdCBsaW1pdGVkLCBhcyBpdCBpcyB0aGUgY2FzZSB3aXRoCgkJdGhlIHw6bWF0Y2h8IGNvbW1hbmRzLgoKCQlFeGFtcGxlOiA+CgkJCTpoaWdobGlnaHQgTXlHcm91cCBjdGVybWJnPWdyZWVuIGd1aWJnPWdyZWVuCgkJCTpsZXQgbSA9IG1hdGNoYWRkKCJNeUdyb3VwIiwgIlRPRE8iKQo8CQlEZWxldGlvbiBvZiB0aGUgcGF0dGVybjogPgoJCQk6Y2FsbCBtYXRjaGRlbGV0ZShtKQoKPAkJQSBsaXN0IG9mIG1hdGNoZXMgZGVmaW5lZCBieSB8bWF0Y2hhZGQoKXwgYW5kIHw6bWF0Y2h8IGFyZQoJCWF2YWlsYWJsZSBmcm9tIHxnZXRtYXRjaGVzKCl8LglBbGwgbWF0Y2hlcyBjYW4gYmUgZGVsZXRlZCBpbgoJCW9uZSBvcGVyYXRpb24gYnkgfGNsZWFybWF0Y2hlcygpfC4KCm1hdGNoYWRkcG9zKHtncm91cH0sIHtwb3N9Wywge3ByaW9yaXR5fVssIHtpZH1bLCB7ZGljdH1dXV0pCQkqbWF0Y2hhZGRwb3MoKSoKCQlTYW1lIGFzIHxtYXRjaGFkZCgpfCwgYnV0IHJlcXVpcmVzIGEgbGlzdCBvZiBwb3NpdGlvbnMge3Bvc30KCQlpbnN0ZWFkIG9mIGEgcGF0dGVybi4gVGhpcyBjb21tYW5kIGlzIGZhc3RlciB0aGFuIHxtYXRjaGFkZCgpfAoJCWJlY2F1c2UgaXQgZG9lcyBub3QgcmVxdWlyZSB0byBoYW5kbGUgcmVndWxhciBleHByZXNzaW9ucyBhbmQKCQlzZXRzIGJ1ZmZlciBsaW5lIGJvdW5kYXJpZXMgdG8gcmVkcmF3IHNjcmVlbi4gSXQgaXMgc3VwcG9zZWQKCQl0byBiZSB1c2VkIHdoZW4gZmFzdCBtYXRjaCBhZGRpdGlvbnMgYW5kIGRlbGV0aW9ucyBhcmUKCQlyZXF1aXJlZCwgZm9yIGV4YW1wbGUgdG8gaGlnaGxpZ2h0IG1hdGNoaW5nIHBhcmVudGhlc2VzLgoKCQlUaGUgbGlzdCB7cG9zfSBjYW4gY29udGFpbiBvbmUgb2YgdGhlc2UgaXRlbXM6CgkJLSBBIG51bWJlci4gIFRoaXMgd2hvbGUgbGluZSB3aWxsIGJlIGhpZ2hsaWdodGVkLiAgVGhlIGZpcnN0CgkJICBsaW5lIGhhcyBudW1iZXIgMS4KCQktIEEgbGlzdCB3aXRoIG9uZSBudW1iZXIsIGUuZy4sIFsyM10uIFRoZSB3aG9sZSBsaW5lIHdpdGggdGhpcwoJCSAgbnVtYmVyIHdpbGwgYmUgaGlnaGxpZ2h0ZWQuCgkJLSBBIGxpc3Qgd2l0aCB0d28gbnVtYmVycywgZS5nLiwgWzIzLCAxMV0uIFRoZSBmaXJzdCBudW1iZXIgaXMKCQkgIHRoZSBsaW5lIG51bWJlciwgdGhlIHNlY29uZCBvbmUgaXMgdGhlIGNvbHVtbiBudW1iZXIgKGZpcnN0CgkJICBjb2x1bW4gaXMgMSwgdGhlIHZhbHVlIG11c3QgY29ycmVzcG9uZCB0byB0aGUgYnl0ZSBpbmRleCBhcwoJCSAgfGNvbCgpfCB3b3VsZCByZXR1cm4pLiAgVGhlIGNoYXJhY3RlciBhdCB0aGlzIHBvc2l0aW9uIHdpbGwKCQkgIGJlIGhpZ2hsaWdodGVkLgoJCS0gQSBsaXN0IHdpdGggdGhyZWUgbnVtYmVycywgZS5nLiwgWzIzLCAxMSwgM10uIEFzIGFib3ZlLCBidXQKCQkgIHRoZSB0aGlyZCBudW1iZXIgZ2l2ZXMgdGhlIGxlbmd0aCBvZiB0aGUgaGlnaGxpZ2h0IGluIGJ5dGVzLgoJCQoJCVRoZSBtYXhpbXVtIG51bWJlciBvZiBwb3NpdGlvbnMgaXMgOC4KCgkJRXhhbXBsZTogPgoJCQk6aGlnaGxpZ2h0IE15R3JvdXAgY3Rlcm1iZz1ncmVlbiBndWliZz1ncmVlbgoJCQk6bGV0IG0gPSBtYXRjaGFkZHBvcygiTXlHcm91cCIsIFtbMjMsIDI0XSwgMzRdKQo8CQlEZWxldGlvbiBvZiB0aGUgcGF0dGVybjogPgoJCQk6Y2FsbCBtYXRjaGRlbGV0ZShtKQoKPAkJTWF0Y2hlcyBhZGRlZCBieSB8bWF0Y2hhZGRwb3MoKXwgYXJlIHJldHVybmVkIGJ5CgkJfGdldG1hdGNoZXMoKXwgd2l0aCBhbiBlbnRyeSAicG9zMSIsICJwb3MyIiwgZXRjLiwgd2l0aCB0aGUKCQl2YWx1ZSBhIGxpc3QgbGlrZSB0aGUge3Bvc30gaXRlbS4KCQlUaGVzZSBtYXRjaGVzIGNhbm5vdCBiZSBzZXQgdmlhIHxzZXRtYXRjaGVzKCl8LCBob3dldmVyIHRoZXkKCQljYW4gc3RpbGwgYmUgZGVsZXRlZCBieSB8Y2xlYXJtYXRjaGVzKCl8LgoKbWF0Y2hhcmcoe25yfSkJCQkJCQkJKm1hdGNoYXJnKCkqCgkJU2VsZWN0cyB0aGUge25yfSBtYXRjaCBpdGVtLCBhcyBzZXQgd2l0aCBhIHw6bWF0Y2h8LAoJCXw6Mm1hdGNofCBvciB8OjNtYXRjaHwgY29tbWFuZC4KCQlSZXR1cm4gYSB8TGlzdHwgd2l0aCB0d28gZWxlbWVudHM6CgkJCVRoZSBuYW1lIG9mIHRoZSBoaWdobGlnaHQgZ3JvdXAgdXNlZAoJCQlUaGUgcGF0dGVybiB1c2VkLgoJCVdoZW4ge25yfSBpcyBub3QgMSwgMiBvciAzIHJldHVybnMgYW4gZW1wdHkgfExpc3R8LgoJCVdoZW4gdGhlcmUgaXMgbm8gbWF0Y2ggaXRlbSBzZXQgcmV0dXJucyBbJycsICcnXS4KCQlUaGlzIGlzIHVzZWZ1bCB0byBzYXZlIGFuZCByZXN0b3JlIGEgfDptYXRjaHwuCgkJSGlnaGxpZ2h0aW5nIG1hdGNoZXMgdXNpbmcgdGhlIHw6bWF0Y2h8IGNvbW1hbmRzIGFyZSBsaW1pdGVkCgkJdG8gdGhyZWUgbWF0Y2hlcy4gfG1hdGNoYWRkKCl8IGRvZXMgbm90IGhhdmUgdGhpcyBsaW1pdGF0aW9uLgoKbWF0Y2hkZWxldGUoe2lkfSkJCQkgICAgICAgKm1hdGNoZGVsZXRlKCkqICpFODAyKiAqRTgwMyoKCQlEZWxldGVzIGEgbWF0Y2ggd2l0aCBJRCB7aWR9IHByZXZpb3VzbHkgZGVmaW5lZCBieSB8bWF0Y2hhZGQoKXwKCQlvciBvbmUgb2YgdGhlIHw6bWF0Y2h8IGNvbW1hbmRzLiAgUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWwsCgkJb3RoZXJ3aXNlIC0xLiAgU2VlIGV4YW1wbGUgZm9yIHxtYXRjaGFkZCgpfC4gIEFsbCBtYXRjaGVzIGNhbgoJCWJlIGRlbGV0ZWQgaW4gb25lIG9wZXJhdGlvbiBieSB8Y2xlYXJtYXRjaGVzKCl8LgoKbWF0Y2hlbmQoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCQkJKm1hdGNoZW5kKCkqCgkJU2FtZSBhcyB8bWF0Y2goKXwsIGJ1dCByZXR1cm4gdGhlIGluZGV4IG9mIGZpcnN0IGNoYXJhY3RlcgoJCWFmdGVyIHRoZSBtYXRjaC4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gbWF0Y2hlbmQoInRlc3RpbmciLCAiaW5nIikKPAkJcmVzdWx0cyBpbiAiNyIuCgkJCQkJCQkqc3Ryc3BuKCkqICpzdHJjc3BuKCkqCgkJVmltIGRvZXNuJ3QgaGF2ZSBhIHN0cnNwbigpIG9yIHN0cmNzcG4oKSBmdW5jdGlvbiwgYnV0IHlvdSBjYW4KCQlkbyBpdCB3aXRoIG1hdGNoZW5kKCk6ID4KCQkJOmxldCBzcGFuID0gbWF0Y2hlbmQobGluZSwgJ1thLXpBLVpdJykKCQkJOmxldCBzcGFuID0gbWF0Y2hlbmQobGluZSwgJ1teYS16QS1aXScpCjwJCUV4Y2VwdCB0aGF0IC0xIGlzIHJldHVybmVkIHdoZW4gdGhlcmUgYXJlIG5vIG1hdGNoZXMuCgoJCVRoZSB7c3RhcnR9LCBpZiBnaXZlbiwgaGFzIHRoZSBzYW1lIG1lYW5pbmcgYXMgZm9yIHxtYXRjaCgpfC4gPgoJCQk6ZWNobyBtYXRjaGVuZCgidGVzdGluZyIsICJpbmciLCAyKQo8CQlyZXN1bHRzIGluICI3Ii4gPgoJCQk6ZWNobyBtYXRjaGVuZCgidGVzdGluZyIsICJpbmciLCA1KQo8CQlyZXN1bHQgaXMgIi0xIi4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCB0aGUgcmVzdWx0IGlzIGVxdWFsIHRvIHxtYXRjaCgpfC4KCm1hdGNobGlzdCh7ZXhwcn0sIHtwYXR9Wywge3N0YXJ0fVssIHtjb3VudH1dXSkJCQkqbWF0Y2hsaXN0KCkqCgkJU2FtZSBhcyB8bWF0Y2goKXwsIGJ1dCByZXR1cm4gYSB8TGlzdHwuICBUaGUgZmlyc3QgaXRlbSBpbiB0aGUKCQlsaXN0IGlzIHRoZSBtYXRjaGVkIHN0cmluZywgc2FtZSBhcyB3aGF0IG1hdGNoc3RyKCkgd291bGQKCQlyZXR1cm4uICBGb2xsb3dpbmcgaXRlbXMgYXJlIHN1Ym1hdGNoZXMsIGxpa2UgIlwxIiwgIlwyIiwgZXRjLgoJCWluIHw6c3Vic3RpdHV0ZXwuICBXaGVuIGFuIG9wdGlvbmFsIHN1Ym1hdGNoIGRpZG4ndCBtYXRjaCBhbgoJCWVtcHR5IHN0cmluZyBpcyB1c2VkLiAgRXhhbXBsZTogPgoJCQllY2hvIG1hdGNobGlzdCgnYWNkJywgJ1woYVwpXD9cKGJcKVw/XChjXClcP1woLipcKScpCjwJCVJlc3VsdHMgaW46IFsnYWNkJywgJ2EnLCAnJywgJ2MnLCAnZCcsICcnLCAnJywgJycsICcnLCAnJ10KCQlXaGVuIHRoZXJlIGlzIG5vIG1hdGNoIGFuIGVtcHR5IGxpc3QgaXMgcmV0dXJuZWQuCgptYXRjaHN0cih7ZXhwcn0sIHtwYXR9Wywge3N0YXJ0fVssIHtjb3VudH1dXSkJCQkqbWF0Y2hzdHIoKSoKCQlTYW1lIGFzIHxtYXRjaCgpfCwgYnV0IHJldHVybiB0aGUgbWF0Y2hlZCBzdHJpbmcuICBFeGFtcGxlOiA+CgkJCTplY2hvIG1hdGNoc3RyKCJ0ZXN0aW5nIiwgImluZyIpCjwJCXJlc3VsdHMgaW4gImluZyIuCgkJV2hlbiB0aGVyZSBpcyBubyBtYXRjaCAiIiBpcyByZXR1cm5lZC4KCQlUaGUge3N0YXJ0fSwgaWYgZ2l2ZW4sIGhhcyB0aGUgc2FtZSBtZWFuaW5nIGFzIGZvciB8bWF0Y2goKXwuID4KCQkJOmVjaG8gbWF0Y2hzdHIoInRlc3RpbmciLCAiaW5nIiwgMikKPAkJcmVzdWx0cyBpbiAiaW5nIi4gPgoJCQk6ZWNobyBtYXRjaHN0cigidGVzdGluZyIsICJpbmciLCA1KQo8CQlyZXN1bHQgaXMgIiIuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgdGhlbiB0aGUgbWF0Y2hpbmcgaXRlbSBpcyByZXR1cm5lZC4KCQlUaGUgdHlwZSBpc24ndCBjaGFuZ2VkLCBpdCdzIG5vdCBuZWNlc3NhcmlseSBhIFN0cmluZy4KCm1hdGNoc3RycG9zKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQkJKm1hdGNoc3RycG9zKCkqCgkJU2FtZSBhcyB8bWF0Y2hzdHIoKXwsIGJ1dCByZXR1cm4gdGhlIG1hdGNoZWQgc3RyaW5nLCB0aGUgc3RhcnQKCQlwb3NpdGlvbiBhbmQgdGhlIGVuZCBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guICBFeGFtcGxlOiA+CgkJCTplY2hvIG1hdGNoc3RycG9zKCJ0ZXN0aW5nIiwgImluZyIpCjwJCXJlc3VsdHMgaW4gWyJpbmciLCA0LCA3XS4KCQlXaGVuIHRoZXJlIGlzIG5vIG1hdGNoIFsiIiwgLTEsIC0xXSBpcyByZXR1cm5lZC4KCQlUaGUge3N0YXJ0fSwgaWYgZ2l2ZW4sIGhhcyB0aGUgc2FtZSBtZWFuaW5nIGFzIGZvciB8bWF0Y2goKXwuID4KCQkJOmVjaG8gbWF0Y2hzdHJwb3MoInRlc3RpbmciLCAiaW5nIiwgMikKPAkJcmVzdWx0cyBpbiBbImluZyIsIDQsIDddLiA+CgkJCTplY2hvIG1hdGNoc3RycG9zKCJ0ZXN0aW5nIiwgImluZyIsIDUpCjwJCXJlc3VsdCBpcyBbIiIsIC0xLCAtMV0uCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgdGhlbiB0aGUgbWF0Y2hpbmcgaXRlbSwgdGhlIGluZGV4CgkJb2YgZmlyc3QgaXRlbSB3aGVyZSB7cGF0fSBtYXRjaGVzLCB0aGUgc3RhcnQgcG9zaXRpb24gYW5kIHRoZQoJCWVuZCBwb3NpdGlvbiBvZiB0aGUgbWF0Y2ggYXJlIHJldHVybmVkLiA+CgkJCTplY2hvIG1hdGNoc3RycG9zKFsxLCAnX194J10sICdcYScpCjwJCXJlc3VsdCBpcyBbIngiLCAxLCAyLCAzXS4KCQlUaGUgdHlwZSBpc24ndCBjaGFuZ2VkLCBpdCdzIG5vdCBuZWNlc3NhcmlseSBhIFN0cmluZy4KCgkJCQkJCQkqbWF4KCkqCm1heCh7bGlzdH0pCVJldHVybiB0aGUgbWF4aW11bSB2YWx1ZSBvZiBhbGwgaXRlbXMgaW4ge2xpc3R9LgoJCUlmIHtsaXN0fSBpcyBub3QgYSBsaXN0IG9yIG9uZSBvZiB0aGUgaXRlbXMgaW4ge2xpc3R9IGNhbm5vdAoJCWJlIHVzZWQgYXMgYSBOdW1iZXIgdGhpcyByZXN1bHRzIGluIGFuIGVycm9yLgoJCUFuIGVtcHR5IHxMaXN0fCByZXN1bHRzIGluIHplcm8uCgoJCQkJCQkJKm1pbigpKgptaW4oe2xpc3R9KQlSZXR1cm4gdGhlIG1pbmltdW0gdmFsdWUgb2YgYWxsIGl0ZW1zIGluIHtsaXN0fS4KCQlJZiB7bGlzdH0gaXMgbm90IGEgbGlzdCBvciBvbmUgb2YgdGhlIGl0ZW1zIGluIHtsaXN0fSBjYW5ub3QKCQliZSB1c2VkIGFzIGEgTnVtYmVyIHRoaXMgcmVzdWx0cyBpbiBhbiBlcnJvci4KCQlBbiBlbXB0eSB8TGlzdHwgcmVzdWx0cyBpbiB6ZXJvLgoKCQkJCQkJCSpta2RpcigpKiAqRTczOSoKbWtkaXIoe25hbWV9IFssIHtwYXRofSBbLCB7cHJvdH1dXSkKCQlDcmVhdGUgZGlyZWN0b3J5IHtuYW1lfS4KCQlJZiB7cGF0aH0gaXMgInAiIHRoZW4gaW50ZXJtZWRpYXRlIGRpcmVjdG9yaWVzIGFyZSBjcmVhdGVkIGFzCgkJbmVjZXNzYXJ5LiAgT3RoZXJ3aXNlIGl0IG11c3QgYmUgIiIuCgkJSWYge3Byb3R9IGlzIGdpdmVuIGl0IGlzIHVzZWQgdG8gc2V0IHRoZSBwcm90ZWN0aW9uIGJpdHMgb2YKCQl0aGUgbmV3IGRpcmVjdG9yeS4gIFRoZSBkZWZhdWx0IGlzIDA3NTUgKHJ3eHIteHIteDogci93IGZvcgoJCXRoZSB1c2VyIHJlYWRhYmxlIGZvciBvdGhlcnMpLglVc2UgMDcwMCB0byBtYWtlIGl0IHVucmVhZGFibGUKCQlmb3Igb3RoZXJzLiAgVGhpcyBpcyBvbmx5IHVzZWQgZm9yIHRoZSBsYXN0IHBhcnQgb2Yge25hbWV9LgoJCVRodXMgaWYgeW91IGNyZWF0ZSAvdG1wL2Zvby9iYXIgdGhlbiAvdG1wL2ZvbyB3aWxsIGJlIGNyZWF0ZWQKCQl3aXRoIDA3NTUuCgkJRXhhbXBsZTogPgoJCQk6Y2FsbCBta2RpcigkSE9NRSAuICIvdG1wL2Zvby9iYXIiLCAicCIsIDA3MDApCjwJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoJCU5vdCBhdmFpbGFibGUgb24gYWxsIHN5c3RlbXMuICBUbyBjaGVjayB1c2U6ID4KCQkJOmlmIGV4aXN0cygiKm1rZGlyIikKPAoJCQkJCQkJKm1vZGUoKSoKbW9kZShbZXhwcl0pCVJldHVybiBhIHN0cmluZyB0aGF0IGluZGljYXRlcyB0aGUgY3VycmVudCBtb2RlLgoJCUlmIFtleHByXSBpcyBzdXBwbGllZCBhbmQgaXQgZXZhbHVhdGVzIHRvIGEgbm9uLXplcm8gTnVtYmVyIG9yCgkJYSBub24tZW1wdHkgU3RyaW5nICh8bm9uLXplcm8tYXJnfCksIHRoZW4gdGhlIGZ1bGwgbW9kZSBpcwoJCXJldHVybmVkLCBvdGhlcndpc2Ugb25seSB0aGUgZmlyc3QgbGV0dGVyIGlzIHJldHVybmVkLiAgTm90ZQoJCXRoYXQgIiAiIGFuZCAiMCIgYXJlIGFsc28gbm9uLWVtcHR5IHN0cmluZ3MuCgoJCQluCU5vcm1hbAoJCQlubwlPcGVyYXRvci1wZW5kaW5nCgkJCXYJVmlzdWFsIGJ5IGNoYXJhY3RlcgoJCQlWCVZpc3VhbCBieSBsaW5lCgkJCUNUUkwtVglWaXN1YWwgYmxvY2t3aXNlCgkJCXMJU2VsZWN0IGJ5IGNoYXJhY3RlcgoJCQlTCVNlbGVjdCBieSBsaW5lCgkJCUNUUkwtUwlTZWxlY3QgYmxvY2t3aXNlCgkJCWkJSW5zZXJ0CgkJCVIJUmVwbGFjZSB8UnwKCQkJUnYJVmlydHVhbCBSZXBsYWNlIHxnUnwKCQkJYwlDb21tYW5kLWxpbmUKCQkJY3YJVmltIEV4IG1vZGUgfGdRfAoJCQljZQlOb3JtYWwgRXggbW9kZSB8UXwKCQkJcglIaXQtZW50ZXIgcHJvbXB0CgkJCXJtCVRoZSAtLSBtb3JlIC0tIHByb21wdAoJCQlyPwlBIHw6Y29uZmlybXwgcXVlcnkgb2Ygc29tZSBzb3J0CgkJCSEJU2hlbGwgb3IgZXh0ZXJuYWwgY29tbWFuZCBpcyBleGVjdXRpbmcKCQlUaGlzIGlzIHVzZWZ1bCBpbiB0aGUgJ3N0YXR1c2xpbmUnIG9wdGlvbiBvciB3aGVuIHVzZWQKCQl3aXRoIHxyZW1vdGVfZXhwcigpfCBJbiBtb3N0IG90aGVyIHBsYWNlcyBpdCBhbHdheXMgcmV0dXJucwoJCSJjIiBvciAibiIuCgkJQWxzbyBzZWUgfHZpc3VhbG1vZGUoKXwuCgptemV2YWwoe2V4cHJ9KQkJCQkJCQkqbXpldmFsKCkqCgkJRXZhbHVhdGUgTXpTY2hlbWUgZXhwcmVzc2lvbiB7ZXhwcn0gYW5kIHJldHVybiBpdHMgcmVzdWx0CgkJY29udmVydGVkIHRvIFZpbSBkYXRhIHN0cnVjdHVyZXMuCgkJTnVtYmVycyBhbmQgc3RyaW5ncyBhcmUgcmV0dXJuZWQgYXMgdGhleSBhcmUuCgkJUGFpcnMgKGluY2x1ZGluZyBsaXN0cyBhbmQgaW1wcm9wZXIgbGlzdHMpIGFuZCB2ZWN0b3JzIGFyZQoJCXJldHVybmVkIGFzIFZpbSB8TGlzdHN8LgoJCUhhc2ggdGFibGVzIGFyZSByZXByZXNlbnRlZCBhcyBWaW0gfERpY3Rpb25hcnl8IHR5cGUgd2l0aCBrZXlzCgkJY29udmVydGVkIHRvIHN0cmluZ3MuCgkJQWxsIG90aGVyIHR5cGVzIGFyZSBjb252ZXJ0ZWQgdG8gc3RyaW5nIHdpdGggZGlzcGxheSBmdW5jdGlvbi4KCQlFeGFtcGxlczogPgoJCSAgICA6bXogKGRlZmluZSBsIChsaXN0IDEgMiAzKSkKCQkgICAgOm16IChkZWZpbmUgaCAobWFrZS1oYXNoKSkgKGhhc2gtc2V0ISBoICJsaXN0IiBsKQoJCSAgICA6ZWNobyBtemV2YWwoImwiKQoJCSAgICA6ZWNobyBtemV2YWwoImgiKQo8CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCttenNjaGVtZXwgZmVhdHVyZX0KCm5leHRub25ibGFuayh7bG51bX0pCQkJCQkqbmV4dG5vbmJsYW5rKCkqCgkJUmV0dXJuIHRoZSBsaW5lIG51bWJlciBvZiB0aGUgZmlyc3QgbGluZSBhdCBvciBiZWxvdyB7bG51bX0KCQl0aGF0IGlzIG5vdCBibGFuay4gIEV4YW1wbGU6ID4KCQkJaWYgZ2V0bGluZShuZXh0bm9uYmxhbmsoMSkpID1+ICJKYXZhIgo8CQlXaGVuIHtsbnVtfSBpcyBpbnZhbGlkIG9yIHRoZXJlIGlzIG5vIG5vbi1ibGFuayBsaW5lIGF0IG9yCgkJYmVsb3cgaXQsIHplcm8gaXMgcmV0dXJuZWQuCgkJU2VlIGFsc28gfHByZXZub25ibGFuaygpfC4KCm5yMmNoYXIoe2V4cHJ9Wywge3V0Zjh9XSkJCQkJKm5yMmNoYXIoKSoKCQlSZXR1cm4gYSBzdHJpbmcgd2l0aCBhIHNpbmdsZSBjaGFyYWN0ZXIsIHdoaWNoIGhhcyB0aGUgbnVtYmVyCgkJdmFsdWUge2V4cHJ9LiAgRXhhbXBsZXM6ID4KCQkJbnIyY2hhcig2NCkJCXJldHVybnMgIkAiCgkJCW5yMmNoYXIoMzIpCQlyZXR1cm5zICIgIgo8CQlXaGVuIHt1dGY4fSBpcyBvbWl0dGVkIG9yIHplcm8sIHRoZSBjdXJyZW50ICdlbmNvZGluZycgaXMgdXNlZC4KCQlFeGFtcGxlIGZvciAidXRmLTgiOiA+CgkJCW5yMmNoYXIoMzAwKQkJcmV0dXJucyBJIHdpdGggYm93IGNoYXJhY3Rlcgo8CQlXaXRoIHt1dGY4fSBzZXQgdG8gMSwgYWx3YXlzIHJldHVybiB1dGYtOCBjaGFyYWN0ZXJzLgoJCU5vdGUgdGhhdCBhIE5VTCBjaGFyYWN0ZXIgaW4gdGhlIGZpbGUgaXMgc3BlY2lmaWVkIHdpdGgKCQlucjJjaGFyKDEwKSwgYmVjYXVzZSBOVUxzIGFyZSByZXByZXNlbnRlZCB3aXRoIG5ld2xpbmUKCQljaGFyYWN0ZXJzLiAgbnIyY2hhcigwKSBpcyBhIHJlYWwgTlVMIGFuZCB0ZXJtaW5hdGVzIHRoZQoJCXN0cmluZywgdGh1cyByZXN1bHRzIGluIGFuIGVtcHR5IHN0cmluZy4KCm9yKHtleHByfSwge2V4cHJ9KQkJCQkJKm9yKCkqCgkJQml0d2lzZSBPUiBvbiB0aGUgdHdvIGFyZ3VtZW50cy4gIFRoZSBhcmd1bWVudHMgYXJlIGNvbnZlcnRlZAoJCXRvIGEgbnVtYmVyLiAgQSBMaXN0LCBEaWN0IG9yIEZsb2F0IGFyZ3VtZW50IGNhdXNlcyBhbiBlcnJvci4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgYml0cyA9IG9yKGJpdHMsIDB4ODApCgoKcGF0aHNob3J0ZW4oe2V4cHJ9KQkJCQkJKnBhdGhzaG9ydGVuKCkqCgkJU2hvcnRlbiBkaXJlY3RvcnkgbmFtZXMgaW4gdGhlIHBhdGgge2V4cHJ9IGFuZCByZXR1cm4gdGhlCgkJcmVzdWx0LiAgVGhlIHRhaWwsIHRoZSBmaWxlIG5hbWUsIGlzIGtlcHQgYXMtaXMuICBUaGUgb3RoZXIKCQljb21wb25lbnRzIGluIHRoZSBwYXRoIGFyZSByZWR1Y2VkIHRvIHNpbmdsZSBsZXR0ZXJzLiAgTGVhZGluZwoJCSd+JyBhbmQgJy4nIGNoYXJhY3RlcnMgYXJlIGtlcHQuICBFeGFtcGxlOiA+CgkJCTplY2hvIHBhdGhzaG9ydGVuKCd+Ly52aW0vYXV0b2xvYWQvbXlmaWxlLnZpbScpCjwJCQl+Ly52L2EvbXlmaWxlLnZpbSB+CgkJSXQgZG9lc24ndCBtYXR0ZXIgaWYgdGhlIHBhdGggZXhpc3RzIG9yIG5vdC4KCnBlcmxldmFsKHtleHByfSkJCQkJCSpwZXJsZXZhbCgpKgoJCUV2YWx1YXRlIFBlcmwgZXhwcmVzc2lvbiB7ZXhwcn0gaW4gc2NhbGFyIGNvbnRleHQgYW5kIHJldHVybgoJCWl0cyByZXN1bHQgY29udmVydGVkIHRvIFZpbSBkYXRhIHN0cnVjdHVyZXMuIElmIHZhbHVlIGNhbid0IGJlCgkJY29udmVydGVkLCBpdCBpcyByZXR1cm5lZCBhcyBhIHN0cmluZyBQZXJsIHJlcHJlc2VudGF0aW9uLgoJCU5vdGU6IElmIHlvdSB3YW50IGFuIGFycmF5IG9yIGhhc2gsIHtleHByfSBtdXN0IHJldHVybiBhCgkJcmVmZXJlbmNlIHRvIGl0LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gcGVybGV2YWwoJ1sxIC4uIDRdJykKPAkJCVsxLCAyLCAzLCA0XQoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcGVybHwgZmVhdHVyZX0KCnBvdyh7eH0sIHt5fSkJCQkJCQkqcG93KCkqCgkJUmV0dXJuIHRoZSBwb3dlciBvZiB7eH0gdG8gdGhlIGV4cG9uZW50IHt5fSBhcyBhIHxGbG9hdHwuCgkJe3h9IGFuZCB7eX0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBwb3coMywgMykKPAkJCTI3LjAgPgoJCQk6ZWNobyBwb3coMiwgMTYpCjwJCQk2NTUzNi4wID4KCQkJOmVjaG8gcG93KDMyLCAwLjIwKQo8CQkJMi4wCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKcHJldm5vbmJsYW5rKHtsbnVtfSkJCQkJCSpwcmV2bm9uYmxhbmsoKSoKCQlSZXR1cm4gdGhlIGxpbmUgbnVtYmVyIG9mIHRoZSBmaXJzdCBsaW5lIGF0IG9yIGFib3ZlIHtsbnVtfQoJCXRoYXQgaXMgbm90IGJsYW5rLiAgRXhhbXBsZTogPgoJCQlsZXQgaW5kID0gaW5kZW50KHByZXZub25ibGFuayh2OmxudW0gLSAxKSkKPAkJV2hlbiB7bG51bX0gaXMgaW52YWxpZCBvciB0aGVyZSBpcyBubyBub24tYmxhbmsgbGluZSBhdCBvcgoJCWFib3ZlIGl0LCB6ZXJvIGlzIHJldHVybmVkLgoJCUFsc28gc2VlIHxuZXh0bm9uYmxhbmsoKXwuCgoKcHJpbnRmKHtmbXR9LCB7ZXhwcjF9IC4uLikJCQkJKnByaW50ZigpKgoJCVJldHVybiBhIFN0cmluZyB3aXRoIHtmbXR9LCB3aGVyZSAiJSIgaXRlbXMgYXJlIHJlcGxhY2VkIGJ5CgkJdGhlIGZvcm1hdHRlZCBmb3JtIG9mIHRoZWlyIHJlc3BlY3RpdmUgYXJndW1lbnRzLiAgRXhhbXBsZTogPgoJCQlwcmludGYoIiU0ZDogRSVkICUuMzBzIiwgbG51bSwgZXJybm8sIG1zZykKPAkJTWF5IHJlc3VsdCBpbjoKCQkJIiAgOTk6IEU0MiBhc2RmYXNkZmFzZGZhc2RmYXNkZmFzZGZhc2RmYXMiIH4KCgkJT2Z0ZW4gdXNlZCBpdGVtcyBhcmU6CgkJICAlcwlzdHJpbmcKCQkgICU2UwlzdHJpbmcgcmlnaHQtYWxpZ25lZCBpbiA2IGRpc3BsYXkgY2VsbHMKCQkgICU2cwlzdHJpbmcgcmlnaHQtYWxpZ25lZCBpbiA2IGJ5dGVzCgkJICAlLjlzCXN0cmluZyB0cnVuY2F0ZWQgdG8gOSBieXRlcwoJCSAgJWMJc2luZ2xlIGJ5dGUKCQkgICVkCWRlY2ltYWwgbnVtYmVyCgkJICAlNWQJZGVjaW1hbCBudW1iZXIgcGFkZGVkIHdpdGggc3BhY2VzIHRvIDUgY2hhcmFjdGVycwoJCSAgJXgJaGV4IG51bWJlcgoJCSAgJTA0eAloZXggbnVtYmVyIHBhZGRlZCB3aXRoIHplcm9zIHRvIGF0IGxlYXN0IDQgY2hhcmFjdGVycwoJCSAgJVgJaGV4IG51bWJlciB1c2luZyB1cHBlciBjYXNlIGxldHRlcnMKCQkgICVvCW9jdGFsIG51bWJlcgoJCSAgJWYJZmxvYXRpbmcgcG9pbnQgbnVtYmVyIGluIHRoZSBmb3JtIDEyMy40NTYKCQkgICVlCWZsb2F0aW5nIHBvaW50IG51bWJlciBpbiB0aGUgZm9ybSAxLjIzNGUzCgkJICAlRQlmbG9hdGluZyBwb2ludCBudW1iZXIgaW4gdGhlIGZvcm0gMS4yMzRFMwoJCSAgJWcJZmxvYXRpbmcgcG9pbnQgbnVtYmVyLCBhcyAlZiBvciAlZSBkZXBlbmRpbmcgb24gdmFsdWUKCQkgICVHCWZsb2F0aW5nIHBvaW50IG51bWJlciwgYXMgJWYgb3IgJUUgZGVwZW5kaW5nIG9uIHZhbHVlCgkJICAlJQl0aGUgJSBjaGFyYWN0ZXIgaXRzZWxmCgoJCUNvbnZlcnNpb24gc3BlY2lmaWNhdGlvbnMgc3RhcnQgd2l0aCAnJScgYW5kIGVuZCB3aXRoIHRoZQoJCWNvbnZlcnNpb24gdHlwZS4gIEFsbCBvdGhlciBjaGFyYWN0ZXJzIGFyZSBjb3BpZWQgdW5jaGFuZ2VkIHRvCgkJdGhlIHJlc3VsdC4KCgkJVGhlICIlIiBzdGFydHMgYSBjb252ZXJzaW9uIHNwZWNpZmljYXRpb24uICBUaGUgZm9sbG93aW5nCgkJYXJndW1lbnRzIGFwcGVhciBpbiBzZXF1ZW5jZToKCgkJCSUgIFtmbGFnc10gIFtmaWVsZC13aWR0aF0gIFsucHJlY2lzaW9uXSAgdHlwZQoKCQlmbGFncwoJCQlaZXJvIG9yIG1vcmUgb2YgdGhlIGZvbGxvd2luZyBmbGFnczoKCgkJICAgICMJICAgICAgVGhlIHZhbHVlIHNob3VsZCBiZSBjb252ZXJ0ZWQgdG8gYW4gImFsdGVybmF0ZQoJCQkgICAgICBmb3JtIi4gIEZvciBjLCBkLCBhbmQgcyBjb252ZXJzaW9ucywgdGhpcyBvcHRpb24KCQkJICAgICAgaGFzIG5vIGVmZmVjdC4gIEZvciBvIGNvbnZlcnNpb25zLCB0aGUgcHJlY2lzaW9uCgkJCSAgICAgIG9mIHRoZSBudW1iZXIgaXMgaW5jcmVhc2VkIHRvIGZvcmNlIHRoZSBmaXJzdAoJCQkgICAgICBjaGFyYWN0ZXIgb2YgdGhlIG91dHB1dCBzdHJpbmcgdG8gYSB6ZXJvIChleGNlcHQKCQkJICAgICAgaWYgYSB6ZXJvIHZhbHVlIGlzIHByaW50ZWQgd2l0aCBhbiBleHBsaWNpdAoJCQkgICAgICBwcmVjaXNpb24gb2YgemVybykuCgkJCSAgICAgIEZvciB4IGFuZCBYIGNvbnZlcnNpb25zLCBhIG5vbi16ZXJvIHJlc3VsdCBoYXMKCQkJICAgICAgdGhlIHN0cmluZyAiMHgiIChvciAiMFgiIGZvciBYIGNvbnZlcnNpb25zKQoJCQkgICAgICBwcmVwZW5kZWQgdG8gaXQuCgoJCSAgICAwICh6ZXJvKSAgWmVybyBwYWRkaW5nLiAgRm9yIGFsbCBjb252ZXJzaW9ucyB0aGUgY29udmVydGVkCgkJCSAgICAgIHZhbHVlIGlzIHBhZGRlZCBvbiB0aGUgbGVmdCB3aXRoIHplcm9zIHJhdGhlcgoJCQkgICAgICB0aGFuIGJsYW5rcy4gIElmIGEgcHJlY2lzaW9uIGlzIGdpdmVuIHdpdGggYQoJCQkgICAgICBudW1lcmljIGNvbnZlcnNpb24gKGQsIG8sIHgsIGFuZCBYKSwgdGhlIDAgZmxhZwoJCQkgICAgICBpcyBpZ25vcmVkLgoKCQkgICAgLQkgICAgICBBIG5lZ2F0aXZlIGZpZWxkIHdpZHRoIGZsYWc7IHRoZSBjb252ZXJ0ZWQgdmFsdWUKCQkJICAgICAgaXMgdG8gYmUgbGVmdCBhZGp1c3RlZCBvbiB0aGUgZmllbGQgYm91bmRhcnkuCgkJCSAgICAgIFRoZSBjb252ZXJ0ZWQgdmFsdWUgaXMgcGFkZGVkIG9uIHRoZSByaWdodCB3aXRoCgkJCSAgICAgIGJsYW5rcywgcmF0aGVyIHRoYW4gb24gdGhlIGxlZnQgd2l0aCBibGFua3Mgb3IKCQkJICAgICAgemVyb3MuICBBIC0gb3ZlcnJpZGVzIGEgMCBpZiBib3RoIGFyZSBnaXZlbi4KCgkJICAgICcgJyAoc3BhY2UpICBBIGJsYW5rIHNob3VsZCBiZSBsZWZ0IGJlZm9yZSBhIHBvc2l0aXZlCgkJCSAgICAgIG51bWJlciBwcm9kdWNlZCBieSBhIHNpZ25lZCBjb252ZXJzaW9uIChkKS4KCgkJICAgICsJICAgICAgQSBzaWduIG11c3QgYWx3YXlzIGJlIHBsYWNlZCBiZWZvcmUgYSBudW1iZXIKCQkJICAgICAgcHJvZHVjZWQgYnkgYSBzaWduZWQgY29udmVyc2lvbi4JQSArIG92ZXJyaWRlcwoJCQkgICAgICBhIHNwYWNlIGlmIGJvdGggYXJlIHVzZWQuCgoJCWZpZWxkLXdpZHRoCgkJCUFuIG9wdGlvbmFsIGRlY2ltYWwgZGlnaXQgc3RyaW5nIHNwZWNpZnlpbmcgYSBtaW5pbXVtCgkJCWZpZWxkIHdpZHRoLiAgSWYgdGhlIGNvbnZlcnRlZCB2YWx1ZSBoYXMgZmV3ZXIgYnl0ZXMKCQkJdGhhbiB0aGUgZmllbGQgd2lkdGgsIGl0IHdpbGwgYmUgcGFkZGVkIHdpdGggc3BhY2VzIG9uCgkJCXRoZSBsZWZ0IChvciByaWdodCwgaWYgdGhlIGxlZnQtYWRqdXN0bWVudCBmbGFnIGhhcwoJCQliZWVuIGdpdmVuKSB0byBmaWxsIG91dCB0aGUgZmllbGQgd2lkdGguCgoJCS5wcmVjaXNpb24KCQkJQW4gb3B0aW9uYWwgcHJlY2lzaW9uLCBpbiB0aGUgZm9ybSBvZiBhIHBlcmlvZCAnLicKCQkJZm9sbG93ZWQgYnkgYW4gb3B0aW9uYWwgZGlnaXQgc3RyaW5nLiAgSWYgdGhlIGRpZ2l0CgkJCXN0cmluZyBpcyBvbWl0dGVkLCB0aGUgcHJlY2lzaW9uIGlzIHRha2VuIGFzIHplcm8uCgkJCVRoaXMgZ2l2ZXMgdGhlIG1pbmltdW0gbnVtYmVyIG9mIGRpZ2l0cyB0byBhcHBlYXIgZm9yCgkJCWQsIG8sIHgsIGFuZCBYIGNvbnZlcnNpb25zLCBvciB0aGUgbWF4aW11bSBudW1iZXIgb2YKCQkJYnl0ZXMgdG8gYmUgcHJpbnRlZCBmcm9tIGEgc3RyaW5nIGZvciBzIGNvbnZlcnNpb25zLgoJCQlGb3IgZmxvYXRpbmcgcG9pbnQgaXQgaXMgdGhlIG51bWJlciBvZiBkaWdpdHMgYWZ0ZXIKCQkJdGhlIGRlY2ltYWwgcG9pbnQuCgoJCXR5cGUKCQkJQSBjaGFyYWN0ZXIgdGhhdCBzcGVjaWZpZXMgdGhlIHR5cGUgb2YgY29udmVyc2lvbiB0bwoJCQliZSBhcHBsaWVkLCBzZWUgYmVsb3cuCgoJCUEgZmllbGQgd2lkdGggb3IgcHJlY2lzaW9uLCBvciBib3RoLCBtYXkgYmUgaW5kaWNhdGVkIGJ5IGFuCgkJYXN0ZXJpc2sgJyonIGluc3RlYWQgb2YgYSBkaWdpdCBzdHJpbmcuICBJbiB0aGlzIGNhc2UsIGEKCQlOdW1iZXIgYXJndW1lbnQgc3VwcGxpZXMgdGhlIGZpZWxkIHdpZHRoIG9yIHByZWNpc2lvbi4JQQoJCW5lZ2F0aXZlIGZpZWxkIHdpZHRoIGlzIHRyZWF0ZWQgYXMgYSBsZWZ0IGFkanVzdG1lbnQgZmxhZwoJCWZvbGxvd2VkIGJ5IGEgcG9zaXRpdmUgZmllbGQgd2lkdGg7IGEgbmVnYXRpdmUgcHJlY2lzaW9uIGlzCgkJdHJlYXRlZCBhcyB0aG91Z2ggaXQgd2VyZSBtaXNzaW5nLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBwcmludGYoIiVkOiAlLipzIiwgbnIsIHdpZHRoLCBsaW5lKQo8CQlUaGlzIGxpbWl0cyB0aGUgbGVuZ3RoIG9mIHRoZSB0ZXh0IHVzZWQgZnJvbSAibGluZSIgdG8KCQkid2lkdGgiIGJ5dGVzLgoKCQlUaGUgY29udmVyc2lvbiBzcGVjaWZpZXJzIGFuZCB0aGVpciBtZWFuaW5ncyBhcmU6CgoJCQkJKnByaW50Zi1kKiAqcHJpbnRmLW8qICpwcmludGYteCogKnByaW50Zi1YKgoJCWRveFgJVGhlIE51bWJlciBhcmd1bWVudCBpcyBjb252ZXJ0ZWQgdG8gc2lnbmVkIGRlY2ltYWwKCQkJKGQpLCB1bnNpZ25lZCBvY3RhbCAobyksIG9yIHVuc2lnbmVkIGhleGFkZWNpbWFsICh4CgkJCWFuZCBYKSBub3RhdGlvbi4gIFRoZSBsZXR0ZXJzICJhYmNkZWYiIGFyZSB1c2VkIGZvcgoJCQl4IGNvbnZlcnNpb25zOyB0aGUgbGV0dGVycyAiQUJDREVGIiBhcmUgdXNlZCBmb3IgWAoJCQljb252ZXJzaW9ucy4KCQkJVGhlIHByZWNpc2lvbiwgaWYgYW55LCBnaXZlcyB0aGUgbWluaW11bSBudW1iZXIgb2YKCQkJZGlnaXRzIHRoYXQgbXVzdCBhcHBlYXI7IGlmIHRoZSBjb252ZXJ0ZWQgdmFsdWUKCQkJcmVxdWlyZXMgZmV3ZXIgZGlnaXRzLCBpdCBpcyBwYWRkZWQgb24gdGhlIGxlZnQgd2l0aAoJCQl6ZXJvcy4KCQkJSW4gbm8gY2FzZSBkb2VzIGEgbm9uLWV4aXN0ZW50IG9yIHNtYWxsIGZpZWxkIHdpZHRoCgkJCWNhdXNlIHRydW5jYXRpb24gb2YgYSBudW1lcmljIGZpZWxkOyBpZiB0aGUgcmVzdWx0IG9mCgkJCWEgY29udmVyc2lvbiBpcyB3aWRlciB0aGFuIHRoZSBmaWVsZCB3aWR0aCwgdGhlIGZpZWxkCgkJCWlzIGV4cGFuZGVkIHRvIGNvbnRhaW4gdGhlIGNvbnZlcnNpb24gcmVzdWx0LgoKCQkJCQkJCSpwcmludGYtYyoKCQljCVRoZSBOdW1iZXIgYXJndW1lbnQgaXMgY29udmVydGVkIHRvIGEgYnl0ZSwgYW5kIHRoZQoJCQlyZXN1bHRpbmcgY2hhcmFjdGVyIGlzIHdyaXR0ZW4uCgoJCQkJCQkJKnByaW50Zi1zKgoJCXMJVGhlIHRleHQgb2YgdGhlIFN0cmluZyBhcmd1bWVudCBpcyB1c2VkLiAgSWYgYQoJCQlwcmVjaXNpb24gaXMgc3BlY2lmaWVkLCBubyBtb3JlIGJ5dGVzIHRoYW4gdGhlIG51bWJlcgoJCQlzcGVjaWZpZWQgYXJlIHVzZWQuCgkJCQkJCQkqcHJpbnRmLVMqCgkJUwlUaGUgdGV4dCBvZiB0aGUgU3RyaW5nIGFyZ3VtZW50IGlzIHVzZWQuICBJZiBhCgkJCXByZWNpc2lvbiBpcyBzcGVjaWZpZWQsIG5vIG1vcmUgZGlzcGxheSBjZWxscyB0aGFuIHRoZQoJCQludW1iZXIgc3BlY2lmaWVkIGFyZSB1c2VkLiAgV2l0aG91dCB0aGUgfCttdWx0aV9ieXRlfAoJCQlmZWF0dXJlIHdvcmtzIGp1c3QgbGlrZSAncycuCgoJCQkJCQkJKnByaW50Zi1mKiAqRTgwNyoKCQlmCVRoZSBGbG9hdCBhcmd1bWVudCBpcyBjb252ZXJ0ZWQgaW50byBhIHN0cmluZyBvZiB0aGUgCgkJCWZvcm0gMTIzLjQ1Ni4gIFRoZSBwcmVjaXNpb24gc3BlY2lmaWVzIHRoZSBudW1iZXIgb2YKCQkJZGlnaXRzIGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50LiAgV2hlbiB0aGUgcHJlY2lzaW9uIGlzCgkJCXplcm8gdGhlIGRlY2ltYWwgcG9pbnQgaXMgb21pdHRlZC4gIFdoZW4gdGhlIHByZWNpc2lvbgoJCQlpcyBub3Qgc3BlY2lmaWVkIDYgaXMgdXNlZC4gIEEgcmVhbGx5IGJpZyBudW1iZXIKCQkJKG91dCBvZiByYW5nZSBvciBkaXZpZGluZyBieSB6ZXJvKSByZXN1bHRzIGluICJpbmYiLgoJCQkiMC4wIC8gMC4wIiByZXN1bHRzIGluICJuYW4iLgoJCQlFeGFtcGxlOiA+CgkJCQllY2hvIHByaW50ZigiJS4yZiIsIDEyLjExNSkKPAkJCQkxMi4xMgoJCQlOb3RlIHRoYXQgcm91bmRvZmYgZGVwZW5kcyBvbiB0aGUgc3lzdGVtIGxpYnJhcmllcy4KCQkJVXNlIHxyb3VuZCgpfCB3aGVuIGluIGRvdWJ0LgoKCQkJCQkJCSpwcmludGYtZSogKnByaW50Zi1FKgoJCWUgRQlUaGUgRmxvYXQgYXJndW1lbnQgaXMgY29udmVydGVkIGludG8gYSBzdHJpbmcgb2YgdGhlCgkJCWZvcm0gMS4yMzRlKzAzIG9yIDEuMjM0RSswMyB3aGVuIHVzaW5nICdFJy4gIFRoZQoJCQlwcmVjaXNpb24gc3BlY2lmaWVzIHRoZSBudW1iZXIgb2YgZGlnaXRzIGFmdGVyIHRoZQoJCQlkZWNpbWFsIHBvaW50LCBsaWtlIHdpdGggJ2YnLgoKCQkJCQkJCSpwcmludGYtZyogKnByaW50Zi1HKgoJCWcgRwlUaGUgRmxvYXQgYXJndW1lbnQgaXMgY29udmVydGVkIGxpa2Ugd2l0aCAnZicgaWYgdGhlCgkJCXZhbHVlIGlzIGJldHdlZW4gMC4wMDEgKGluY2x1c2l2ZSkgYW5kIDEwMDAwMDAwLjAKCQkJKGV4Y2x1c2l2ZSkuICBPdGhlcndpc2UgJ2UnIGlzIHVzZWQgZm9yICdnJyBhbmQgJ0UnCgkJCWZvciAnRycuICBXaGVuIG5vIHByZWNpc2lvbiBpcyBzcGVjaWZpZWQgc3VwZXJmbHVvdXMKCQkJemVyb2VzIGFuZCAnKycgc2lnbnMgYXJlIHJlbW92ZWQsIGV4Y2VwdCBmb3IgdGhlIHplcm8KCQkJaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIGRlY2ltYWwgcG9pbnQuICBUaHVzIDEwMDAwMDAwLjAKCQkJcmVzdWx0cyBpbiAxLjBlNy4KCgkJCQkJCQkqcHJpbnRmLSUqCgkJJQlBICclJyBpcyB3cml0dGVuLiAgTm8gYXJndW1lbnQgaXMgY29udmVydGVkLiAgVGhlCgkJCWNvbXBsZXRlIGNvbnZlcnNpb24gc3BlY2lmaWNhdGlvbiBpcyAiJSUiLgoKCQlXaGVuIGEgTnVtYmVyIGFyZ3VtZW50IGlzIGV4cGVjdGVkIGEgU3RyaW5nIGFyZ3VtZW50IGlzIGFsc28KCQlhY2NlcHRlZCBhbmQgYXV0b21hdGljYWxseSBjb252ZXJ0ZWQuCgkJV2hlbiBhIEZsb2F0IG9yIFN0cmluZyBhcmd1bWVudCBpcyBleHBlY3RlZCBhIE51bWJlciBhcmd1bWVudAoJCWlzIGFsc28gYWNjZXB0ZWQgYW5kIGF1dG9tYXRpY2FsbHkgY29udmVydGVkLgoJCUFueSBvdGhlciBhcmd1bWVudCB0eXBlIHJlc3VsdHMgaW4gYW4gZXJyb3IgbWVzc2FnZS4KCgkJCQkJCQkqRTc2NiogKkU3NjcqCgkJVGhlIG51bWJlciBvZiB7ZXhwck59IGFyZ3VtZW50cyBtdXN0IGV4YWN0bHkgbWF0Y2ggdGhlIG51bWJlcgoJCW9mICIlIiBpdGVtcy4gIElmIHRoZXJlIGFyZSBub3Qgc3VmZmljaWVudCBvciB0b28gbWFueQoJCWFyZ3VtZW50cyBhbiBlcnJvciBpcyBnaXZlbi4gIFVwIHRvIDE4IGFyZ3VtZW50cyBjYW4gYmUgdXNlZC4KCgpwdW12aXNpYmxlKCkJCQkJCQkqcHVtdmlzaWJsZSgpKgoJCVJldHVybnMgbm9uLXplcm8gd2hlbiB0aGUgcG9wdXAgbWVudSBpcyB2aXNpYmxlLCB6ZXJvCgkJb3RoZXJ3aXNlLiAgU2VlIHxpbnMtY29tcGxldGlvbi1tZW51fC4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIGF2b2lkIHNvbWUgdGhpbmdzIHRoYXQgd291bGQgcmVtb3ZlIHRoZQoJCXBvcHVwIG1lbnUuCgpweTNldmFsKHtleHByfSkJCQkJCQkqcHkzZXZhbCgpKgoJCUV2YWx1YXRlIFB5dGhvbiBleHByZXNzaW9uIHtleHByfSBhbmQgcmV0dXJuIGl0cyByZXN1bHQKCQljb252ZXJ0ZWQgdG8gVmltIGRhdGEgc3RydWN0dXJlcy4KCQlOdW1iZXJzIGFuZCBzdHJpbmdzIGFyZSByZXR1cm5lZCBhcyB0aGV5IGFyZSAoc3RyaW5ncyBhcmUgCgkJY29waWVkIHRob3VnaCwgVW5pY29kZSBzdHJpbmdzIGFyZSBhZGRpdGlvbmFsbHkgY29udmVydGVkIHRvIAoJCSdlbmNvZGluZycpLgoJCUxpc3RzIGFyZSByZXByZXNlbnRlZCBhcyBWaW0gfExpc3R8IHR5cGUuCgkJRGljdGlvbmFyaWVzIGFyZSByZXByZXNlbnRlZCBhcyBWaW0gfERpY3Rpb25hcnl8IHR5cGUgd2l0aCAKCQlrZXlzIGNvbnZlcnRlZCB0byBzdHJpbmdzLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcHl0aG9uM3wgZmVhdHVyZX0KCgkJCQkJCQkqRTg1OCogKkU4NTkqCnB5ZXZhbCh7ZXhwcn0pCQkJCQkJKnB5ZXZhbCgpKgoJCUV2YWx1YXRlIFB5dGhvbiBleHByZXNzaW9uIHtleHByfSBhbmQgcmV0dXJuIGl0cyByZXN1bHQKCQljb252ZXJ0ZWQgdG8gVmltIGRhdGEgc3RydWN0dXJlcy4KCQlOdW1iZXJzIGFuZCBzdHJpbmdzIGFyZSByZXR1cm5lZCBhcyB0aGV5IGFyZSAoc3RyaW5ncyBhcmUgCgkJY29waWVkIHRob3VnaCkuCgkJTGlzdHMgYXJlIHJlcHJlc2VudGVkIGFzIFZpbSB8TGlzdHwgdHlwZS4KCQlEaWN0aW9uYXJpZXMgYXJlIHJlcHJlc2VudGVkIGFzIFZpbSB8RGljdGlvbmFyeXwgdHlwZSwgCgkJbm9uLXN0cmluZyBrZXlzIHJlc3VsdCBpbiBlcnJvci4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3B5dGhvbnwgZmVhdHVyZX0KCgkJCQkJCQkqRTcyNiogKkU3MjcqCnJhbmdlKHtleHByfSBbLCB7bWF4fSBbLCB7c3RyaWRlfV1dKQkJCQkqcmFuZ2UoKSoKCQlSZXR1cm5zIGEgfExpc3R8IHdpdGggTnVtYmVyczoKCQktIElmIG9ubHkge2V4cHJ9IGlzIHNwZWNpZmllZDogWzAsIDEsIC4uLiwge2V4cHJ9IC0gMV0KCQktIElmIHttYXh9IGlzIHNwZWNpZmllZDogW3tleHByfSwge2V4cHJ9ICsgMSwgLi4uLCB7bWF4fV0KCQktIElmIHtzdHJpZGV9IGlzIHNwZWNpZmllZDogW3tleHByfSwge2V4cHJ9ICsge3N0cmlkZX0sIC4uLiwKCQkgIHttYXh9XSAoaW5jcmVhc2luZyB7ZXhwcn0gd2l0aCB7c3RyaWRlfSBlYWNoIHRpbWUsIG5vdAoJCSAgcHJvZHVjaW5nIGEgdmFsdWUgcGFzdCB7bWF4fSkuCgkJV2hlbiB0aGUgbWF4aW11bSBpcyBvbmUgYmVmb3JlIHRoZSBzdGFydCB0aGUgcmVzdWx0IGlzIGFuCgkJZW1wdHkgbGlzdC4gIFdoZW4gdGhlIG1heGltdW0gaXMgbW9yZSB0aGFuIG9uZSBiZWZvcmUgdGhlCgkJc3RhcnQgdGhpcyBpcyBhbiBlcnJvci4KCQlFeGFtcGxlczogPgoJCQlyYW5nZSg0KQkJIiBbMCwgMSwgMiwgM10KCQkJcmFuZ2UoMiwgNCkJCSIgWzIsIDMsIDRdCgkJCXJhbmdlKDIsIDksIDMpCQkiIFsyLCA1LCA4XQoJCQlyYW5nZSgyLCAtMiwgLTEpCSIgWzIsIDEsIDAsIC0xLCAtMl0KCQkJcmFuZ2UoMCkJCSIgW10KCQkJcmFuZ2UoMiwgMCkJCSIgZXJyb3IhCjwKCQkJCQkJCSpyZWFkZmlsZSgpKgpyZWFkZmlsZSh7Zm5hbWV9IFssIHtiaW5hcnl9IFssIHttYXh9XV0pCgkJUmVhZCBmaWxlIHtmbmFtZX0gYW5kIHJldHVybiBhIHxMaXN0fCwgZWFjaCBsaW5lIG9mIHRoZSBmaWxlCgkJYXMgYW4gaXRlbS4gIExpbmVzIGJyb2tlbiBhdCBOTCBjaGFyYWN0ZXJzLiAgTWFjaW50b3NoIGZpbGVzCgkJc2VwYXJhdGVkIHdpdGggQ1Igd2lsbCByZXN1bHQgaW4gYSBzaW5nbGUgbG9uZyBsaW5lICh1bmxlc3MgYQoJCU5MIGFwcGVhcnMgc29tZXdoZXJlKS4KCQlBbGwgTlVMIGNoYXJhY3RlcnMgYXJlIHJlcGxhY2VkIHdpdGggYSBOTCBjaGFyYWN0ZXIuCgkJV2hlbiB7YmluYXJ5fSBjb250YWlucyAiYiIgYmluYXJ5IG1vZGUgaXMgdXNlZDoKCQktIFdoZW4gdGhlIGxhc3QgbGluZSBlbmRzIGluIGEgTkwgYW4gZXh0cmEgZW1wdHkgbGlzdCBpdGVtIGlzCgkJICBhZGRlZC4KCQktIE5vIENSIGNoYXJhY3RlcnMgYXJlIHJlbW92ZWQuCgkJT3RoZXJ3aXNlOgoJCS0gQ1IgY2hhcmFjdGVycyB0aGF0IGFwcGVhciBiZWZvcmUgYSBOTCBhcmUgcmVtb3ZlZC4KCQktIFdoZXRoZXIgdGhlIGxhc3QgbGluZSBlbmRzIGluIGEgTkwgb3Igbm90IGRvZXMgbm90IG1hdHRlci4KCQktIFdoZW4gJ2VuY29kaW5nJyBpcyBVbmljb2RlIGFueSBVVEYtOCBieXRlIG9yZGVyIG1hcmsgaXMKCQkgIHJlbW92ZWQgZnJvbSB0aGUgdGV4dC4KCQlXaGVuIHttYXh9IGlzIGdpdmVuIHRoaXMgc3BlY2lmaWVzIHRoZSBtYXhpbXVtIG51bWJlciBvZiBsaW5lcwoJCXRvIGJlIHJlYWQuICBVc2VmdWwgaWYgeW91IG9ubHkgd2FudCB0byBjaGVjayB0aGUgZmlyc3QgdGVuCgkJbGluZXMgb2YgYSBmaWxlOiA+CgkJCTpmb3IgbGluZSBpbiByZWFkZmlsZShmbmFtZSwgJycsIDEwKQoJCQk6ICBpZiBsaW5lID1+ICdEYXRlJyB8IGVjaG8gbGluZSB8IGVuZGlmCgkJCTplbmRmb3IKPAkJV2hlbiB7bWF4fSBpcyBuZWdhdGl2ZSAte21heH0gbGluZXMgZnJvbSB0aGUgZW5kIG9mIHRoZSBmaWxlCgkJYXJlIHJldHVybmVkLCBvciBhcyBtYW55IGFzIHRoZXJlIGFyZS4KCQlXaGVuIHttYXh9IGlzIHplcm8gdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBsaXN0LgoJCU5vdGUgdGhhdCB3aXRob3V0IHttYXh9IHRoZSB3aG9sZSBmaWxlIGlzIHJlYWQgaW50byBtZW1vcnkuCgkJQWxzbyBub3RlIHRoYXQgdGhlcmUgaXMgbm8gcmVjb2duaXRpb24gb2YgZW5jb2RpbmcuICBSZWFkIGEKCQlmaWxlIGludG8gYSBidWZmZXIgaWYgeW91IG5lZWQgdG8uCgkJV2hlbiB0aGUgZmlsZSBjYW4ndCBiZSBvcGVuZWQgYW4gZXJyb3IgbWVzc2FnZSBpcyBnaXZlbiBhbmQKCQl0aGUgcmVzdWx0IGlzIGFuIGVtcHR5IGxpc3QuCgkJQWxzbyBzZWUgfHdyaXRlZmlsZSgpfC4KCnJlbHRpbWUoW3tzdGFydH0gWywge2VuZH1dXSkJCQkJKnJlbHRpbWUoKSoKCQlSZXR1cm4gYW4gaXRlbSB0aGF0IHJlcHJlc2VudHMgYSB0aW1lIHZhbHVlLiAgVGhlIGZvcm1hdCBvZgoJCXRoZSBpdGVtIGRlcGVuZHMgb24gdGhlIHN5c3RlbS4gIEl0IGNhbiBiZSBwYXNzZWQgdG8KCQl8cmVsdGltZXN0cigpfCB0byBjb252ZXJ0IGl0IHRvIGEgc3RyaW5nICBvciB8cmVsdGltZWZsb2F0KCl8CgkJdG8gY29udmVydCB0byBhIEZsb2F0LgoJCVdpdGhvdXQgYW4gYXJndW1lbnQgaXQgcmV0dXJucyB0aGUgY3VycmVudCB0aW1lLgoJCVdpdGggb25lIGFyZ3VtZW50IGlzIHJldHVybnMgdGhlIHRpbWUgcGFzc2VkIHNpbmNlIHRoZSB0aW1lCgkJc3BlY2lmaWVkIGluIHRoZSBhcmd1bWVudC4KCQlXaXRoIHR3byBhcmd1bWVudHMgaXQgcmV0dXJucyB0aGUgdGltZSBwYXNzZWQgYmV0d2VlbiB7c3RhcnR9CgkJYW5kIHtlbmR9LgoJCVRoZSB7c3RhcnR9IGFuZCB7ZW5kfSBhcmd1bWVudHMgbXVzdCBiZSB2YWx1ZXMgcmV0dXJuZWQgYnkKCQlyZWx0aW1lKCkuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtyZWx0aW1lfCBmZWF0dXJlfQoKcmVsdGltZWZsb2F0KHt0aW1lfSkJCQkJKnJlbHRpbWVmbG9hdCgpKgoJCVJldHVybiBhIEZsb2F0IHRoYXQgcmVwcmVzZW50cyB0aGUgdGltZSB2YWx1ZSBvZiB7dGltZX0uCgkJRXhhbXBsZTogPgoJCQlsZXQgc3RhcnQgPSByZWx0aW1lKCkKCQkJY2FsbCBNeUZ1bmN0aW9uKCkKCQkJbGV0IHNlY29uZHMgPSByZWx0aW1lZmxvYXQocmVsdGltZShzdGFydCkpCjwJCVNlZSB0aGUgbm90ZSBvZiByZWx0aW1lc3RyKCkgYWJvdXQgb3ZlcmhlYWQuCgkJQWxzbyBzZWUgfHByb2ZpbGluZ3wuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtyZWx0aW1lfCBmZWF0dXJlfQoKcmVsdGltZXN0cih7dGltZX0pCQkJCSpyZWx0aW1lc3RyKCkqCgkJUmV0dXJuIGEgU3RyaW5nIHRoYXQgcmVwcmVzZW50cyB0aGUgdGltZSB2YWx1ZSBvZiB7dGltZX0uCgkJVGhpcyBpcyB0aGUgbnVtYmVyIG9mIHNlY29uZHMsIGEgZG90IGFuZCB0aGUgbnVtYmVyIG9mCgkJbWljcm9zZWNvbmRzLiAgRXhhbXBsZTogPgoJCQlsZXQgc3RhcnQgPSByZWx0aW1lKCkKCQkJY2FsbCBNeUZ1bmN0aW9uKCkKCQkJZWNobyByZWx0aW1lc3RyKHJlbHRpbWUoc3RhcnQpKQo8CQlOb3RlIHRoYXQgb3ZlcmhlYWQgZm9yIHRoZSBjb21tYW5kcyB3aWxsIGJlIGFkZGVkIHRvIHRoZSB0aW1lLgoJCVRoZSBhY2N1cmFjeSBkZXBlbmRzIG9uIHRoZSBzeXN0ZW0uCgkJTGVhZGluZyBzcGFjZXMgYXJlIHVzZWQgdG8gbWFrZSB0aGUgc3RyaW5nIGFsaWduIG5pY2VseS4gIFlvdQoJCWNhbiB1c2Ugc3BsaXQoKSB0byByZW1vdmUgaXQuID4KCQkJZWNobyBzcGxpdChyZWx0aW1lc3RyKHJlbHRpbWUoc3RhcnQpKSlbMF0KPAkJQWxzbyBzZWUgfHByb2ZpbGluZ3wuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtyZWx0aW1lfCBmZWF0dXJlfQoKCQkJCQkJCSpyZW1vdGVfZXhwcigpKiAqRTQ0OSoKcmVtb3RlX2V4cHIoe3NlcnZlcn0sIHtzdHJpbmd9IFssIHtpZHZhcn1dKQoJCVNlbmQgdGhlIHtzdHJpbmd9IHRvIHtzZXJ2ZXJ9LglUaGUgc3RyaW5nIGlzIHNlbnQgYXMgYW4KCQlleHByZXNzaW9uIGFuZCB0aGUgcmVzdWx0IGlzIHJldHVybmVkIGFmdGVyIGV2YWx1YXRpb24uCgkJVGhlIHJlc3VsdCBtdXN0IGJlIGEgU3RyaW5nIG9yIGEgfExpc3R8LiAgQSB8TGlzdHwgaXMgdHVybmVkCgkJaW50byBhIFN0cmluZyBieSBqb2luaW5nIHRoZSBpdGVtcyB3aXRoIGEgbGluZSBicmVhayBpbgoJCWJldHdlZW4gKG5vdCBhdCB0aGUgZW5kKSwgbGlrZSB3aXRoIGpvaW4oZXhwciwgIlxuIikuCgkJSWYge2lkdmFyfSBpcyBwcmVzZW50LCBpdCBpcyB0YWtlbiBhcyB0aGUgbmFtZSBvZiBhCgkJdmFyaWFibGUgYW5kIGEge3NlcnZlcmlkfSBmb3IgbGF0ZXIgdXNlIHdpdGgKCQlyZW1vdGVfcmVhZCgpIGlzIHN0b3JlZCB0aGVyZS4KCQlTZWUgYWxzbyB8Y2xpZW50c2VydmVyfCB8UmVtb3RlUmVwbHl8LgoJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2xpZW50c2VydmVyfCBmZWF0dXJlfQoJCU5vdGU6IEFueSBlcnJvcnMgd2lsbCBjYXVzZSBhIGxvY2FsIGVycm9yIG1lc3NhZ2UgdG8gYmUgaXNzdWVkCgkJYW5kIHRoZSByZXN1bHQgd2lsbCBiZSB0aGUgZW1wdHkgc3RyaW5nLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIHJlbW90ZV9leHByKCJndmltIiwgIjIrMiIpCgkJCTplY2hvIHJlbW90ZV9leHByKCJndmltMSIsICJiOmN1cnJlbnRfc3ludGF4IikKPAoKcmVtb3RlX2ZvcmVncm91bmQoe3NlcnZlcn0pCQkJCSpyZW1vdGVfZm9yZWdyb3VuZCgpKgoJCU1vdmUgdGhlIFZpbSBzZXJ2ZXIgd2l0aCB0aGUgbmFtZSB7c2VydmVyfSB0byB0aGUgZm9yZWdyb3VuZC4KCQlUaGlzIHdvcmtzIGxpa2U6ID4KCQkJcmVtb3RlX2V4cHIoe3NlcnZlcn0sICJmb3JlZ3JvdW5kKCkiKQo8CQlFeGNlcHQgdGhhdCBvbiBXaW4zMiBzeXN0ZW1zIHRoZSBjbGllbnQgZG9lcyB0aGUgd29yaywgdG8gd29yawoJCWFyb3VuZCB0aGUgcHJvYmxlbSB0aGF0IHRoZSBPUyBkb2Vzbid0IGFsd2F5cyBhbGxvdyB0aGUgc2VydmVyCgkJdG8gYnJpbmcgaXRzZWxmIHRvIHRoZSBmb3JlZ3JvdW5kLgoJCU5vdGU6IFRoaXMgZG9lcyBub3QgcmVzdG9yZSB0aGUgd2luZG93IGlmIGl0IHdhcyBtaW5pbWl6ZWQsCgkJbGlrZSBmb3JlZ3JvdW5kKCkgZG9lcy4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQl7b25seSBpbiB0aGUgV2luMzIsIEF0aGVuYSwgTW90aWYgYW5kIEdUSyBHVUkgdmVyc2lvbnMgYW5kIHRoZQoJCVdpbjMyIGNvbnNvbGUgdmVyc2lvbn0KCgpyZW1vdGVfcGVlayh7c2VydmVyaWR9IFssIHtyZXR2YXJ9XSkJCSpyZW1vdGVfcGVlaygpKgoJCVJldHVybnMgYSBwb3NpdGl2ZSBudW1iZXIgaWYgdGhlcmUgYXJlIGF2YWlsYWJsZSBzdHJpbmdzCgkJZnJvbSB7c2VydmVyaWR9LiAgQ29waWVzIGFueSByZXBseSBzdHJpbmcgaW50byB0aGUgdmFyaWFibGUKCQl7cmV0dmFyfSBpZiBzcGVjaWZpZWQuCXtyZXR2YXJ9IG11c3QgYmUgYSBzdHJpbmcgd2l0aCB0aGUKCQluYW1lIG9mIGEgdmFyaWFibGUuCgkJUmV0dXJucyB6ZXJvIGlmIG5vbmUgYXJlIGF2YWlsYWJsZS4KCQlSZXR1cm5zIC0xIGlmIHNvbWV0aGluZyBpcyB3cm9uZy4KCQlTZWUgYWxzbyB8Y2xpZW50c2VydmVyfC4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NsaWVudHNlcnZlcnwgZmVhdHVyZX0KCQlFeGFtcGxlczogPgoJCQk6bGV0IHJlcGwgPSAiIgoJCQk6ZWNobyAiUEVFSzogIi5yZW1vdGVfcGVlayhpZCwgInJlcGwiKS4iOiAiLnJlcGwKCnJlbW90ZV9yZWFkKHtzZXJ2ZXJpZH0pCQkJCSpyZW1vdGVfcmVhZCgpKgoJCVJldHVybiB0aGUgb2xkZXN0IGF2YWlsYWJsZSByZXBseSBmcm9tIHtzZXJ2ZXJpZH0gYW5kIGNvbnN1bWUKCQlpdC4gIEl0IGJsb2NrcyB1bnRpbCBhIHJlcGx5IGlzIGF2YWlsYWJsZS4KCQlTZWUgYWxzbyB8Y2xpZW50c2VydmVyfC4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NsaWVudHNlcnZlcnwgZmVhdHVyZX0KCQlFeGFtcGxlOiA+CgkJCTplY2hvIHJlbW90ZV9yZWFkKGlkKQo8CgkJCQkJCQkqcmVtb3RlX3NlbmQoKSogKkUyNDEqCnJlbW90ZV9zZW5kKHtzZXJ2ZXJ9LCB7c3RyaW5nfSBbLCB7aWR2YXJ9XSkKCQlTZW5kIHRoZSB7c3RyaW5nfSB0byB7c2VydmVyfS4JVGhlIHN0cmluZyBpcyBzZW50IGFzIGlucHV0CgkJa2V5cyBhbmQgdGhlIGZ1bmN0aW9uIHJldHVybnMgaW1tZWRpYXRlbHkuICBBdCB0aGUgVmltIHNlcnZlcgoJCXRoZSBrZXlzIGFyZSBub3QgbWFwcGVkIHw6bWFwfC4KCQlJZiB7aWR2YXJ9IGlzIHByZXNlbnQsIGl0IGlzIHRha2VuIGFzIHRoZSBuYW1lIG9mIGEgdmFyaWFibGUKCQlhbmQgYSB7c2VydmVyaWR9IGZvciBsYXRlciB1c2Ugd2l0aCByZW1vdGVfcmVhZCgpIGlzIHN0b3JlZAoJCXRoZXJlLgoJCVNlZSBhbHNvIHxjbGllbnRzZXJ2ZXJ8IHxSZW1vdGVSZXBseXwuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJTm90ZTogQW55IGVycm9ycyB3aWxsIGJlIHJlcG9ydGVkIGluIHRoZSBzZXJ2ZXIgYW5kIG1heSBtZXNzCgkJdXAgdGhlIGRpc3BsYXkuCgkJRXhhbXBsZXM6ID4KCQk6ZWNobyByZW1vdGVfc2VuZCgiZ3ZpbSIsICI6RHJvcEFuZFJlcGx5ICIuZmlsZSwgInNlcnZlcmlkIikuCgkJIFwgcmVtb3RlX3JlYWQoc2VydmVyaWQpCgoJCTphdXRvY21kIE5PTkUgUmVtb3RlUmVwbHkgKgoJCSBcIGVjaG8gcmVtb3RlX3JlYWQoZXhwYW5kKCI8YW1hdGNoPiIpKQoJCTplY2hvIHJlbW90ZV9zZW5kKCJndmltIiwgIjpzbGVlcCAxMCB8IGVjaG8gIi4KCQkgXCAnc2VydmVyMmNsaWVudChleHBhbmQoIjxjbGllbnQ+IiksICJIRUxMTyIpPENSPicpCjwKcmVtb3ZlKHtsaXN0fSwge2lkeH0gWywge2VuZH1dKQkJCQkqcmVtb3ZlKCkqCgkJV2l0aG91dCB7ZW5kfTogUmVtb3ZlIHRoZSBpdGVtIGF0IHtpZHh9IGZyb20gfExpc3R8IHtsaXN0fSBhbmQKCQlyZXR1cm4gdGhlIGl0ZW0uCgkJV2l0aCB7ZW5kfTogUmVtb3ZlIGl0ZW1zIGZyb20ge2lkeH0gdG8ge2VuZH0gKGluY2x1c2l2ZSkgYW5kCgkJcmV0dXJuIGEgTGlzdCB3aXRoIHRoZXNlIGl0ZW1zLiAgV2hlbiB7aWR4fSBwb2ludHMgdG8gdGhlIHNhbWUKCQlpdGVtIGFzIHtlbmR9IGEgbGlzdCB3aXRoIG9uZSBpdGVtIGlzIHJldHVybmVkLiAgV2hlbiB7ZW5kfQoJCXBvaW50cyB0byBhbiBpdGVtIGJlZm9yZSB7aWR4fSB0aGlzIGlzIGFuIGVycm9yLgoJCVNlZSB8bGlzdC1pbmRleHwgZm9yIHBvc3NpYmxlIHZhbHVlcyBvZiB7aWR4fSBhbmQge2VuZH0uCgkJRXhhbXBsZTogPgoJCQk6ZWNobyAibGFzdCBpdGVtOiAiIC4gcmVtb3ZlKG15bGlzdCwgLTEpCgkJCTpjYWxsIHJlbW92ZShteWxpc3QsIDAsIDkpCnJlbW92ZSh7ZGljdH0sIHtrZXl9KQoJCVJlbW92ZSB0aGUgZW50cnkgZnJvbSB7ZGljdH0gd2l0aCBrZXkge2tleX0uICBFeGFtcGxlOiA+CgkJCTplY2hvICJyZW1vdmVkICIgLiByZW1vdmUoZGljdCwgIm9uZSIpCjwJCUlmIHRoZXJlIGlzIG5vIHtrZXl9IGluIHtkaWN0fSB0aGlzIGlzIGFuIGVycm9yLgoKCQlVc2UgfGRlbGV0ZSgpfCB0byByZW1vdmUgYSBmaWxlLgoKcmVuYW1lKHtmcm9tfSwge3RvfSkJCQkJCSpyZW5hbWUoKSoKCQlSZW5hbWUgdGhlIGZpbGUgYnkgdGhlIG5hbWUge2Zyb219IHRvIHRoZSBuYW1lIHt0b30uICBUaGlzCgkJc2hvdWxkIGFsc28gd29yayB0byBtb3ZlIGZpbGVzIGFjcm9zcyBmaWxlIHN5c3RlbXMuICBUaGUKCQlyZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIDAgaWYgdGhlIGZpbGUgd2FzIHJlbmFtZWQKCQlzdWNjZXNzZnVsbHksIGFuZCBub24temVybyB3aGVuIHRoZSByZW5hbWluZyBmYWlsZWQuCgkJTk9URTogSWYge3RvfSBleGlzdHMgaXQgaXMgb3ZlcndyaXR0ZW4gd2l0aG91dCB3YXJuaW5nLgoJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoKcmVwZWF0KHtleHByfSwge2NvdW50fSkJCQkJCSpyZXBlYXQoKSoKCQlSZXBlYXQge2V4cHJ9IHtjb3VudH0gdGltZXMgYW5kIHJldHVybiB0aGUgY29uY2F0ZW5hdGVkCgkJcmVzdWx0LiAgRXhhbXBsZTogPgoJCQk6bGV0IHNlcGFyYXRvciA9IHJlcGVhdCgnLScsIDgwKQo8CQlXaGVuIHtjb3VudH0gaXMgemVybyBvciBuZWdhdGl2ZSB0aGUgcmVzdWx0IGlzIGVtcHR5LgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IHRoZSByZXN1bHQgaXMge2V4cHJ9IGNvbmNhdGVuYXRlZAoJCXtjb3VudH0gdGltZXMuCUV4YW1wbGU6ID4KCQkJOmxldCBsb25nbGlzdCA9IHJlcGVhdChbJ2EnLCAnYiddLCAzKQo8CQlSZXN1bHRzIGluIFsnYScsICdiJywgJ2EnLCAnYicsICdhJywgJ2InXS4KCgpyZXNvbHZlKHtmaWxlbmFtZX0pCQkJCQkqcmVzb2x2ZSgpKiAqRTY1NSoKCQlPbiBNUy1XaW5kb3dzLCB3aGVuIHtmaWxlbmFtZX0gaXMgYSBzaG9ydGN1dCAoYSAubG5rIGZpbGUpLAoJCXJldHVybnMgdGhlIHBhdGggdGhlIHNob3J0Y3V0IHBvaW50cyB0byBpbiBhIHNpbXBsaWZpZWQgZm9ybS4KCQlPbiBVbml4LCByZXBlYXQgcmVzb2x2aW5nIHN5bWJvbGljIGxpbmtzIGluIGFsbCBwYXRoCgkJY29tcG9uZW50cyBvZiB7ZmlsZW5hbWV9IGFuZCByZXR1cm4gdGhlIHNpbXBsaWZpZWQgcmVzdWx0LgoJCVRvIGNvcGUgd2l0aCBsaW5rIGN5Y2xlcywgcmVzb2x2aW5nIG9mIHN5bWJvbGljIGxpbmtzIGlzCgkJc3RvcHBlZCBhZnRlciAxMDAgaXRlcmF0aW9ucy4KCQlPbiBvdGhlciBzeXN0ZW1zLCByZXR1cm4gdGhlIHNpbXBsaWZpZWQge2ZpbGVuYW1lfS4KCQlUaGUgc2ltcGxpZmljYXRpb24gc3RlcCBpcyBkb25lIGFzIGJ5IHxzaW1wbGlmeSgpfC4KCQlyZXNvbHZlKCkga2VlcHMgYSBsZWFkaW5nIHBhdGggY29tcG9uZW50IHNwZWNpZnlpbmcgdGhlCgkJY3VycmVudCBkaXJlY3RvcnkgKHByb3ZpZGVkIHRoZSByZXN1bHQgaXMgc3RpbGwgYSByZWxhdGl2ZQoJCXBhdGggbmFtZSkgYW5kIGFsc28ga2VlcHMgYSB0cmFpbGluZyBwYXRoIHNlcGFyYXRvci4KCgkJCQkJCQkqcmV2ZXJzZSgpKgpyZXZlcnNlKHtsaXN0fSkJUmV2ZXJzZSB0aGUgb3JkZXIgb2YgaXRlbXMgaW4ge2xpc3R9IGluLXBsYWNlLglSZXR1cm5zCgkJe2xpc3R9LgoJCUlmIHlvdSB3YW50IGEgbGlzdCB0byByZW1haW4gdW5tb2RpZmllZCBtYWtlIGEgY29weSBmaXJzdDogPgoJCQk6bGV0IHJldmxpc3QgPSByZXZlcnNlKGNvcHkobXlsaXN0KSkKCnJvdW5kKHtleHByfSkJCQkJCQkJKnJvdW5kKCkqCgkJUm91bmQgb2ZmIHtleHByfSB0byB0aGUgbmVhcmVzdCBpbnRlZ3JhbCB2YWx1ZSBhbmQgcmV0dXJuIGl0CgkJYXMgYSB8RmxvYXR8LiAgSWYge2V4cHJ9IGxpZXMgaGFsZndheSBiZXR3ZWVuIHR3byBpbnRlZ3JhbAoJCXZhbHVlcywgdGhlbiB1c2UgdGhlIGxhcmdlciBvbmUgKGF3YXkgZnJvbSB6ZXJvKS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQllY2hvIHJvdW5kKDAuNDU2KQo8CQkJMC4wICA+CgkJCWVjaG8gcm91bmQoNC41KQo8CQkJNS4wID4KCQkJZWNobyByb3VuZCgtNC41KQo8CQkJLTUuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgpzY3JlZW5hdHRyKHJvdywgY29sKQkJCQkJCSpzY3JlZW5hdHRyKCkqCgkJTGlrZSBzY3JlZW5jaGFyKCksIGJ1dCByZXR1cm4gdGhlIGF0dHJpYnV0ZS4gIFRoaXMgaXMgYSByYXRoZXIKCQlhcmJpdHJhcnkgbnVtYmVyIHRoYXQgY2FuIG9ubHkgYmUgdXNlZCB0byBjb21wYXJlIHRvIHRoZQoJCWF0dHJpYnV0ZSBhdCBvdGhlciBwb3NpdGlvbnMuCgpzY3JlZW5jaGFyKHJvdywgY29sKQkJCQkJCSpzY3JlZW5jaGFyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGNoYXJhY3RlciBhdCBwb3NpdGlvbgoJCVtyb3csIGNvbF0gb24gdGhlIHNjcmVlbi4gIFRoaXMgd29ya3MgZm9yIGV2ZXJ5IHBvc3NpYmxlCgkJc2NyZWVuIHBvc2l0aW9uLCBhbHNvIHN0YXR1cyBsaW5lcywgd2luZG93IHNlcGFyYXRvcnMgYW5kIHRoZQoJCWNvbW1hbmQgbGluZS4gIFRoZSB0b3AgbGVmdCBwb3NpdGlvbiBpcyByb3cgb25lLCBjb2x1bW4gb25lCgkJVGhlIGNoYXJhY3RlciBleGNsdWRlcyBjb21wb3NpbmcgY2hhcmFjdGVycy4gIEZvciBkb3VibGUtYnl0ZQoJCWVuY29kaW5ncyBpdCBtYXkgb25seSBiZSB0aGUgZmlyc3QgYnl0ZS4KCQlUaGlzIGlzIG1haW5seSB0byBiZSB1c2VkIGZvciB0ZXN0aW5nLgoJCVJldHVybnMgLTEgd2hlbiByb3cgb3IgY29sIGlzIG91dCBvZiByYW5nZS4KCnNjcmVlbmNvbCgpCQkJCQkJCSpzY3JlZW5jb2woKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgY3VycmVudCBzY3JlZW4gY29sdW1uIG9mCgkJdGhlIGN1cnNvci4gVGhlIGxlZnRtb3N0IGNvbHVtbiBoYXMgbnVtYmVyIDEuCgkJVGhpcyBmdW5jdGlvbiBpcyBtYWlubHkgdXNlZCBmb3IgdGVzdGluZy4KCgkJTm90ZTogQWx3YXlzIHJldHVybnMgdGhlIGN1cnJlbnQgc2NyZWVuIGNvbHVtbiwgdGh1cyBpZiB1c2VkCgkJaW4gYSBjb21tYW5kIChlLmcuICI6ZWNobyBzY3JlZW5jb2woKSIpIGl0IHdpbGwgcmV0dXJuIHRoZQoJCWNvbHVtbiBpbnNpZGUgdGhlIGNvbW1hbmQgbGluZSwgd2hpY2ggaXMgMSB3aGVuIHRoZSBjb21tYW5kIGlzCgkJZXhlY3V0ZWQuIFRvIGdldCB0aGUgY3Vyc29yIHBvc2l0aW9uIGluIHRoZSBmaWxlIHVzZSBvbmUgb2YKCQl0aGUgZm9sbG93aW5nIG1hcHBpbmdzOiA+CgkJCW5ub3JlbWFwIDxleHByPiBHRyAiOmVjaG9tICIuc2NyZWVuY29sKCkuIlxuIgoJCQlubm9yZW1hcCA8c2lsZW50PiBHRyA6ZWNob20gc2NyZWVuY29sKCk8Q1I+CjwKc2NyZWVucm93KCkJCQkJCQkJKnNjcmVlbnJvdygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBjdXJyZW50IHNjcmVlbiByb3cgb2YgdGhlCgkJY3Vyc29yLiAgVGhlIHRvcCBsaW5lIGhhcyBudW1iZXIgb25lLgoJCVRoaXMgZnVuY3Rpb24gaXMgbWFpbmx5IHVzZWQgZm9yIHRlc3RpbmcuCgoJCU5vdGU6IFNhbWUgcmVzdHJpY3Rpb25zIGFzIHdpdGggfHNjcmVlbmNvbCgpfC4KCnNlYXJjaCh7cGF0dGVybn0gWywge2ZsYWdzfSBbLCB7c3RvcGxpbmV9IFssIHt0aW1lb3V0fV1dXSkJKnNlYXJjaCgpKgoJCVNlYXJjaCBmb3IgcmVnZXhwIHBhdHRlcm4ge3BhdHRlcm59LiAgVGhlIHNlYXJjaCBzdGFydHMgYXQgdGhlCgkJY3Vyc29yIHBvc2l0aW9uICh5b3UgY2FuIHVzZSB8Y3Vyc29yKCl8IHRvIHNldCBpdCkuCgoJCVdoZW4gYSBtYXRjaCBoYXMgYmVlbiBmb3VuZCBpdHMgbGluZSBudW1iZXIgaXMgcmV0dXJuZWQuCgkJSWYgdGhlcmUgaXMgbm8gbWF0Y2ggYSAwIGlzIHJldHVybmVkIGFuZCB0aGUgY3Vyc29yIGRvZXNuJ3QKCQltb3ZlLiAgTm8gZXJyb3IgbWVzc2FnZSBpcyBnaXZlbi4KCgkJe2ZsYWdzfSBpcyBhIFN0cmluZywgd2hpY2ggY2FuIGNvbnRhaW4gdGhlc2UgY2hhcmFjdGVyIGZsYWdzOgoJCSdiJwlzZWFyY2ggQmFja3dhcmQgaW5zdGVhZCBvZiBmb3J3YXJkCgkJJ2MnCWFjY2VwdCBhIG1hdGNoIGF0IHRoZSBDdXJzb3IgcG9zaXRpb24KCQknZScJbW92ZSB0byB0aGUgRW5kIG9mIHRoZSBtYXRjaAoJCSduJwlkbyBOb3QgbW92ZSB0aGUgY3Vyc29yCgkJJ3AnCXJldHVybiBudW1iZXIgb2YgbWF0Y2hpbmcgc3ViLVBhdHRlcm4gKHNlZSBiZWxvdykKCQkncycJU2V0IHRoZSAnIG1hcmsgYXQgdGhlIHByZXZpb3VzIGxvY2F0aW9uIG9mIHRoZSBjdXJzb3IKCQkndycJV3JhcCBhcm91bmQgdGhlIGVuZCBvZiB0aGUgZmlsZQoJCSdXJwlkb24ndCBXcmFwIGFyb3VuZCB0aGUgZW5kIG9mIHRoZSBmaWxlCgkJJ3onCXN0YXJ0IHNlYXJjaGluZyBhdCB0aGUgY3Vyc29yIGNvbHVtbiBpbnN0ZWFkIG9mIHplcm8KCQlJZiBuZWl0aGVyICd3JyBvciAnVycgaXMgZ2l2ZW4sIHRoZSAnd3JhcHNjYW4nIG9wdGlvbiBhcHBsaWVzLgoKCQlJZiB0aGUgJ3MnIGZsYWcgaXMgc3VwcGxpZWQsIHRoZSAnIG1hcmsgaXMgc2V0LCBvbmx5IGlmIHRoZQoJCWN1cnNvciBpcyBtb3ZlZC4gVGhlICdzJyBmbGFnIGNhbm5vdCBiZSBjb21iaW5lZCB3aXRoIHRoZSAnbicKCQlmbGFnLgoKCQknaWdub3JlY2FzZScsICdzbWFydGNhc2UnIGFuZCAnbWFnaWMnIGFyZSB1c2VkLgoJCQoJCVdoZW4gdGhlICd6JyBmbGFnIGlzIG5vdCBnaXZlbiwgc2VhcmNoaW5nIGFsd2F5cyBzdGFydHMgaW4KCQljb2x1bW4gemVybyBhbmQgdGhlbiBtYXRjaGVzIGJlZm9yZSB0aGUgY3Vyc29yIGFyZSBza2lwcGVkLgoJCVdoZW4gdGhlICdjJyBmbGFnIGlzIHByZXNlbnQgaW4gJ2NwbycgdGhlIG5leHQgc2VhcmNoIHN0YXJ0cwoJCWFmdGVyIHRoZSBtYXRjaC4gIFdpdGhvdXQgdGhlICdjJyBmbGFnIHRoZSBuZXh0IHNlYXJjaCBzdGFydHMKCQlvbmUgY29sdW1uIGZ1cnRoZXIuCgoJCVdoZW4gdGhlIHtzdG9wbGluZX0gYXJndW1lbnQgaXMgZ2l2ZW4gdGhlbiB0aGUgc2VhcmNoIHN0b3BzCgkJYWZ0ZXIgc2VhcmNoaW5nIHRoaXMgbGluZS4gIFRoaXMgaXMgdXNlZnVsIHRvIHJlc3RyaWN0IHRoZQoJCXNlYXJjaCB0byBhIHJhbmdlIG9mIGxpbmVzLiAgRXhhbXBsZXM6ID4KCQkJbGV0IG1hdGNoID0gc2VhcmNoKCcoJywgJ2InLCBsaW5lKCJ3MCIpKQoJCQlsZXQgZW5kID0gc2VhcmNoKCdFTkQnLCAnJywgbGluZSgidyQiKSkKPAkJV2hlbiB7c3RvcGxpbmV9IGlzIHVzZWQgYW5kIGl0IGlzIG5vdCB6ZXJvIHRoaXMgYWxzbyBpbXBsaWVzCgkJdGhhdCB0aGUgc2VhcmNoIGRvZXMgbm90IHdyYXAgYXJvdW5kIHRoZSBlbmQgb2YgdGhlIGZpbGUuCgkJQSB6ZXJvIHZhbHVlIGlzIGVxdWFsIHRvIG5vdCBnaXZpbmcgdGhlIGFyZ3VtZW50LgoKCQlXaGVuIHRoZSB7dGltZW91dH0gYXJndW1lbnQgaXMgZ2l2ZW4gdGhlIHNlYXJjaCBzdG9wcyB3aGVuCgkJbW9yZSB0aGFuIHRoaXMgbWFueSBtaWxsaXNlY29uZHMgaGF2ZSBwYXNzZWQuCVRodXMgd2hlbgoJCXt0aW1lb3V0fSBpcyA1MDAgdGhlIHNlYXJjaCBzdG9wcyBhZnRlciBoYWxmIGEgc2Vjb25kLgoJCVRoZSB2YWx1ZSBtdXN0IG5vdCBiZSBuZWdhdGl2ZS4gIEEgemVybyB2YWx1ZSBpcyBsaWtlIG5vdAoJCWdpdmluZyB0aGUgYXJndW1lbnQuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtyZWx0aW1lfCBmZWF0dXJlfQoKCQkJCQkJCSpzZWFyY2goKS1zdWItbWF0Y2gqCgkJV2l0aCB0aGUgJ3AnIGZsYWcgdGhlIHJldHVybmVkIHZhbHVlIGlzIG9uZSBtb3JlIHRoYW4gdGhlCgkJZmlyc3Qgc3ViLW1hdGNoIGluIFwoXCkuICBPbmUgaWYgbm9uZSBvZiB0aGVtIG1hdGNoZWQgYnV0IHRoZQoJCXdob2xlIHBhdHRlcm4gZGlkIG1hdGNoLgoJCVRvIGdldCB0aGUgY29sdW1uIG51bWJlciB0b28gdXNlIHxzZWFyY2hwb3MoKXwuCgoJCVRoZSBjdXJzb3Igd2lsbCBiZSBwb3NpdGlvbmVkIGF0IHRoZSBtYXRjaCwgdW5sZXNzIHRoZSAnbicKCQlmbGFnIGlzIHVzZWQuCgoJCUV4YW1wbGUgKGdvZXMgb3ZlciBhbGwgZmlsZXMgaW4gdGhlIGFyZ3VtZW50IGxpc3QpOiA+CgkJICAgIDpsZXQgbiA9IDEKCQkgICAgOndoaWxlIG4gPD0gYXJnYygpCSAgICAiIGxvb3Agb3ZlciBhbGwgZmlsZXMgaW4gYXJnbGlzdAoJCSAgICA6ICBleGUgImFyZ3VtZW50ICIgLiBuCgkJICAgIDogICIgc3RhcnQgYXQgdGhlIGxhc3QgY2hhciBpbiB0aGUgZmlsZSBhbmQgd3JhcCBmb3IgdGhlCgkJICAgIDogICIgZmlyc3Qgc2VhcmNoIHRvIGZpbmQgbWF0Y2ggYXQgc3RhcnQgb2YgZmlsZQoJCSAgICA6ICBub3JtYWwgRyQKCQkgICAgOiAgbGV0IGZsYWdzID0gInciCgkJICAgIDogIHdoaWxlIHNlYXJjaCgiZm9vIiwgZmxhZ3MpID4gMAoJCSAgICA6CSBzL2Zvby9iYXIvZwoJCSAgICA6CSBsZXQgZmxhZ3MgPSAiVyIKCQkgICAgOiAgZW5kd2hpbGUKCQkgICAgOiAgdXBkYXRlCQkgICAgIiB3cml0ZSB0aGUgZmlsZSBpZiBtb2RpZmllZAoJCSAgICA6ICBsZXQgbiA9IG4gKyAxCgkJICAgIDplbmR3aGlsZQo8CgkJRXhhbXBsZSBmb3IgdXNpbmcgc29tZSBmbGFnczogPgoJCSAgICA6ZWNobyBzZWFyY2goJ1w8aWZcfFwoZWxzZVwpXHxcKGVuZGlmXCknLCAnbmNwZScpCjwJCVRoaXMgd2lsbCBzZWFyY2ggZm9yIHRoZSBrZXl3b3JkcyAiaWYiLCAiZWxzZSIsIGFuZCAiZW5kaWYiCgkJdW5kZXIgb3IgYWZ0ZXIgdGhlIGN1cnNvci4gIEJlY2F1c2Ugb2YgdGhlICdwJyBmbGFnLCBpdAoJCXJldHVybnMgMSwgMiwgb3IgMyBkZXBlbmRpbmcgb24gd2hpY2gga2V5d29yZCBpcyBmb3VuZCwgb3IgMAoJCWlmIHRoZSBzZWFyY2ggZmFpbHMuICBXaXRoIHRoZSBjdXJzb3Igb24gdGhlIGZpcnN0IHdvcmQgb2YgdGhlCgkJbGluZToKCQkgICAgaWYgKGZvbyA9PSAwKSB8IGxldCBmb28gPSBmb28gKyAxIHwgZW5kaWYgfgoJCXRoZSBmdW5jdGlvbiByZXR1cm5zIDEuICBXaXRob3V0IHRoZSAnYycgZmxhZywgdGhlIGZ1bmN0aW9uCgkJZmluZHMgdGhlICJlbmRpZiIgYW5kIHJldHVybnMgMy4gIFRoZSBzYW1lIHRoaW5nIGhhcHBlbnMKCQl3aXRob3V0IHRoZSAnZScgZmxhZyBpZiB0aGUgY3Vyc29yIGlzIG9uIHRoZSAiZiIgb2YgImlmIi4KCQlUaGUgJ24nIGZsYWcgdGVsbHMgdGhlIGZ1bmN0aW9uIG5vdCB0byBtb3ZlIHRoZSBjdXJzb3IuCgoKc2VhcmNoZGVjbCh7bmFtZX0gWywge2dsb2JhbH0gWywge3RoaXNibG9ja31dXSkJCQkqc2VhcmNoZGVjbCgpKgoJCVNlYXJjaCBmb3IgdGhlIGRlY2xhcmF0aW9uIG9mIHtuYW1lfS4KCgkJV2l0aCBhIG5vbi16ZXJvIHtnbG9iYWx9IGFyZ3VtZW50IGl0IHdvcmtzIGxpa2UgfGdEfCwgZmluZAoJCWZpcnN0IG1hdGNoIGluIHRoZSBmaWxlLiAgT3RoZXJ3aXNlIGl0IHdvcmtzIGxpa2UgfGdkfCwgZmluZAoJCWZpcnN0IG1hdGNoIGluIHRoZSBmdW5jdGlvbi4KCgkJV2l0aCBhIG5vbi16ZXJvIHt0aGlzYmxvY2t9IGFyZ3VtZW50IG1hdGNoZXMgaW4gYSB7fSBibG9jawoJCXRoYXQgZW5kcyBiZWZvcmUgdGhlIGN1cnNvciBwb3NpdGlvbiBhcmUgaWdub3JlZC4gIEF2b2lkcwoJCWZpbmRpbmcgdmFyaWFibGUgZGVjbGFyYXRpb25zIG9ubHkgdmFsaWQgaW4gYW5vdGhlciBzY29wZS4KCgkJTW92ZXMgdGhlIGN1cnNvciB0byB0aGUgZm91bmQgbWF0Y2guCgkJUmV0dXJucyB6ZXJvIGZvciBzdWNjZXNzLCBub24temVybyBmb3IgZmFpbHVyZS4KCQlFeGFtcGxlOiA+CgkJCWlmIHNlYXJjaGRlY2woJ215dmFyJykgPT0gMAoJCQkgICBlY2hvIGdldGxpbmUoJy4nKQoJCQllbmRpZgo8CgkJCQkJCQkqc2VhcmNocGFpcigpKgpzZWFyY2hwYWlyKHtzdGFydH0sIHttaWRkbGV9LCB7ZW5kfSBbLCB7ZmxhZ3N9IFssIHtza2lwfQoJCQkJWywge3N0b3BsaW5lfSBbLCB7dGltZW91dH1dXV1dKQoJCVNlYXJjaCBmb3IgdGhlIG1hdGNoIG9mIGEgbmVzdGVkIHN0YXJ0LWVuZCBwYWlyLiAgVGhpcyBjYW4gYmUKCQl1c2VkIHRvIGZpbmQgdGhlICJlbmRpZiIgdGhhdCBtYXRjaGVzIGFuICJpZiIsIHdoaWxlIG90aGVyCgkJaWYvZW5kaWYgcGFpcnMgaW4gYmV0d2VlbiBhcmUgaWdub3JlZC4KCQlUaGUgc2VhcmNoIHN0YXJ0cyBhdCB0aGUgY3Vyc29yLiAgVGhlIGRlZmF1bHQgaXMgdG8gc2VhcmNoCgkJZm9yd2FyZCwgaW5jbHVkZSAnYicgaW4ge2ZsYWdzfSB0byBzZWFyY2ggYmFja3dhcmQuCgkJSWYgYSBtYXRjaCBpcyBmb3VuZCwgdGhlIGN1cnNvciBpcyBwb3NpdGlvbmVkIGF0IGl0IGFuZCB0aGUKCQlsaW5lIG51bWJlciBpcyByZXR1cm5lZC4gIElmIG5vIG1hdGNoIGlzIGZvdW5kIDAgb3IgLTEgaXMKCQlyZXR1cm5lZCBhbmQgdGhlIGN1cnNvciBkb2Vzbid0IG1vdmUuICBObyBlcnJvciBtZXNzYWdlIGlzCgkJZ2l2ZW4uCgoJCXtzdGFydH0sIHttaWRkbGV9IGFuZCB7ZW5kfSBhcmUgcGF0dGVybnMsIHNlZSB8cGF0dGVybnwuICBUaGV5CgkJbXVzdCBub3QgY29udGFpbiBcKCBcKSBwYWlycy4gIFVzZSBvZiBcJSggXCkgaXMgYWxsb3dlZC4gIFdoZW4KCQl7bWlkZGxlfSBpcyBub3QgZW1wdHksIGl0IGlzIGZvdW5kIHdoZW4gc2VhcmNoaW5nIGZyb20gZWl0aGVyCgkJZGlyZWN0aW9uLCBidXQgb25seSB3aGVuIG5vdCBpbiBhIG5lc3RlZCBzdGFydC1lbmQgcGFpci4gIEEKCQl0eXBpY2FsIHVzZSBpczogPgoJCQlzZWFyY2hwYWlyKCdcPGlmXD4nLCAnXDxlbHNlXD4nLCAnXDxlbmRpZlw+JykKPAkJQnkgbGVhdmluZyB7bWlkZGxlfSBlbXB0eSB0aGUgImVsc2UiIGlzIHNraXBwZWQuCgoJCXtmbGFnc30gJ2InLCAnYycsICduJywgJ3MnLCAndycgYW5kICdXJyBhcmUgdXNlZCBsaWtlIHdpdGgKCQl8c2VhcmNoKCl8LiAgQWRkaXRpb25hbGx5OgoJCSdyJwlSZXBlYXQgdW50aWwgbm8gbW9yZSBtYXRjaGVzIGZvdW5kOyB3aWxsIGZpbmQgdGhlCgkJCW91dGVyIHBhaXIuICBJbXBsaWVzIHRoZSAnVycgZmxhZy4KCQknbScJUmV0dXJuIG51bWJlciBvZiBtYXRjaGVzIGluc3RlYWQgb2YgbGluZSBudW1iZXIgd2l0aAoJCQl0aGUgbWF0Y2g7IHdpbGwgYmUgPiAxIHdoZW4gJ3InIGlzIHVzZWQuCgkJTm90ZTogaXQncyBuZWFybHkgYWx3YXlzIGEgZ29vZCBpZGVhIHRvIHVzZSB0aGUgJ1cnIGZsYWcsIHRvCgkJYXZvaWQgd3JhcHBpbmcgYXJvdW5kIHRoZSBlbmQgb2YgdGhlIGZpbGUuCgoJCVdoZW4gYSBtYXRjaCBmb3Ige3N0YXJ0fSwge21pZGRsZX0gb3Ige2VuZH0gaXMgZm91bmQsIHRoZQoJCXtza2lwfSBleHByZXNzaW9uIGlzIGV2YWx1YXRlZCB3aXRoIHRoZSBjdXJzb3IgcG9zaXRpb25lZCBvbgoJCXRoZSBzdGFydCBvZiB0aGUgbWF0Y2guICBJdCBzaG91bGQgcmV0dXJuIG5vbi16ZXJvIGlmIHRoaXMKCQltYXRjaCBpcyB0byBiZSBza2lwcGVkLiAgRS5nLiwgYmVjYXVzZSBpdCBpcyBpbnNpZGUgYSBjb21tZW50CgkJb3IgYSBzdHJpbmcuCgkJV2hlbiB7c2tpcH0gaXMgb21pdHRlZCBvciBlbXB0eSwgZXZlcnkgbWF0Y2ggaXMgYWNjZXB0ZWQuCgkJV2hlbiBldmFsdWF0aW5nIHtza2lwfSBjYXVzZXMgYW4gZXJyb3IgdGhlIHNlYXJjaCBpcyBhYm9ydGVkCgkJYW5kIC0xIHJldHVybmVkLgoKCQlGb3Ige3N0b3BsaW5lfSBhbmQge3RpbWVvdXR9IHNlZSB8c2VhcmNoKCl8LgoKCQlUaGUgdmFsdWUgb2YgJ2lnbm9yZWNhc2UnIGlzIHVzZWQuICAnbWFnaWMnIGlzIGlnbm9yZWQsIHRoZQoJCXBhdHRlcm5zIGFyZSB1c2VkIGxpa2UgaXQncyBvbi4KCgkJVGhlIHNlYXJjaCBzdGFydHMgZXhhY3RseSBhdCB0aGUgY3Vyc29yLiAgQSBtYXRjaCB3aXRoCgkJe3N0YXJ0fSwge21pZGRsZX0gb3Ige2VuZH0gYXQgdGhlIG5leHQgY2hhcmFjdGVyLCBpbiB0aGUKCQlkaXJlY3Rpb24gb2Ygc2VhcmNoaW5nLCBpcyB0aGUgZmlyc3Qgb25lIGZvdW5kLiAgRXhhbXBsZTogPgoJCQlpZiAxCgkJCSAgaWYgMgoJCQkgIGVuZGlmIDIKCQkJZW5kaWYgMQo8CQlXaGVuIHN0YXJ0aW5nIGF0IHRoZSAiaWYgMiIsIHdpdGggdGhlIGN1cnNvciBvbiB0aGUgImkiLCBhbmQKCQlzZWFyY2hpbmcgZm9yd2FyZHMsIHRoZSAiZW5kaWYgMiIgaXMgZm91bmQuICBXaGVuIHN0YXJ0aW5nIG9uCgkJdGhlIGNoYXJhY3RlciBqdXN0IGJlZm9yZSB0aGUgImlmIDIiLCB0aGUgImVuZGlmIDEiIHdpbGwgYmUKCQlmb3VuZC4JVGhhdCdzIGJlY2F1c2UgdGhlICJpZiAyIiB3aWxsIGJlIGZvdW5kIGZpcnN0LCBhbmQKCQl0aGVuIHRoaXMgaXMgY29uc2lkZXJlZCB0byBiZSBhIG5lc3RlZCBpZi9lbmRpZiBmcm9tICJpZiAyIiB0bwoJCSJlbmRpZiAyIi4KCQlXaGVuIHNlYXJjaGluZyBiYWNrd2FyZHMgYW5kIHtlbmR9IGlzIG1vcmUgdGhhbiBvbmUgY2hhcmFjdGVyLAoJCWl0IG1heSBiZSB1c2VmdWwgdG8gcHV0ICJcenMiIGF0IHRoZSBlbmQgb2YgdGhlIHBhdHRlcm4sIHNvCgkJdGhhdCB3aGVuIHRoZSBjdXJzb3IgaXMgaW5zaWRlIGEgbWF0Y2ggd2l0aCB0aGUgZW5kIGl0IGZpbmRzCgkJdGhlIG1hdGNoaW5nIHN0YXJ0LgoKCQlFeGFtcGxlLCB0byBmaW5kIHRoZSAiZW5kaWYiIGNvbW1hbmQgaW4gYSBWaW0gc2NyaXB0OiA+CgoJOmVjaG8gc2VhcmNocGFpcignXDxpZlw+JywgJ1w8ZWxcJVtzZWlmXVw+JywgJ1w8ZW5cJVtkaWZdXD4nLCAnVycsCgkJCVwgJ2dldGxpbmUoIi4iKSA9fiAiXlxccypcIiInKQoKPAkJVGhlIGN1cnNvciBtdXN0IGJlIGF0IG9yIGFmdGVyIHRoZSAiaWYiIGZvciB3aGljaCBhIG1hdGNoIGlzCgkJdG8gYmUgZm91bmQuICBOb3RlIHRoYXQgc2luZ2xlLXF1b3RlIHN0cmluZ3MgYXJlIHVzZWQgdG8gYXZvaWQKCQloYXZpbmcgdG8gZG91YmxlIHRoZSBiYWNrc2xhc2hlcy4gIFRoZSBza2lwIGV4cHJlc3Npb24gb25seQoJCWNhdGNoZXMgY29tbWVudHMgYXQgdGhlIHN0YXJ0IG9mIGEgbGluZSwgbm90IGFmdGVyIGEgY29tbWFuZC4KCQlBbHNvLCBhIHdvcmQgImVuIiBvciAiaWYiIGhhbGZ3YXkgYSBsaW5lIGlzIGNvbnNpZGVyZWQgYQoJCW1hdGNoLgoJCUFub3RoZXIgZXhhbXBsZSwgdG8gc2VhcmNoIGZvciB0aGUgbWF0Y2hpbmcgInsiIG9mIGEgIn0iOiA+CgoJOmVjaG8gc2VhcmNocGFpcigneycsICcnLCAnfScsICdiVycpCgo8CQlUaGlzIHdvcmtzIHdoZW4gdGhlIGN1cnNvciBpcyBhdCBvciBiZWZvcmUgdGhlICJ9IiBmb3Igd2hpY2ggYQoJCW1hdGNoIGlzIHRvIGJlIGZvdW5kLiAgVG8gcmVqZWN0IG1hdGNoZXMgdGhhdCBzeW50YXgKCQloaWdobGlnaHRpbmcgcmVjb2duaXplZCBhcyBzdHJpbmdzOiA+CgoJOmVjaG8gc2VhcmNocGFpcigneycsICcnLCAnfScsICdiVycsCgkgICAgIFwgJ3N5bklEYXR0cihzeW5JRChsaW5lKCIuIiksIGNvbCgiLiIpLCAwKSwgIm5hbWUiKSA9fj8gInN0cmluZyInKQo8CgkJCQkJCQkqc2VhcmNocGFpcnBvcygpKgpzZWFyY2hwYWlycG9zKHtzdGFydH0sIHttaWRkbGV9LCB7ZW5kfSBbLCB7ZmxhZ3N9IFssIHtza2lwfQoJCQkJWywge3N0b3BsaW5lfSBbLCB7dGltZW91dH1dXV1dKQoJCVNhbWUgYXMgfHNlYXJjaHBhaXIoKXwsIGJ1dCByZXR1cm5zIGEgfExpc3R8IHdpdGggdGhlIGxpbmUgYW5kCgkJY29sdW1uIHBvc2l0aW9uIG9mIHRoZSBtYXRjaC4gVGhlIGZpcnN0IGVsZW1lbnQgb2YgdGhlIHxMaXN0fAoJCWlzIHRoZSBsaW5lIG51bWJlciBhbmQgdGhlIHNlY29uZCBlbGVtZW50IGlzIHRoZSBieXRlIGluZGV4IG9mCgkJdGhlIGNvbHVtbiBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guICBJZiBubyBtYXRjaCBpcyBmb3VuZCwKCQlyZXR1cm5zIFswLCAwXS4gPgoKCQkJOmxldCBbbG51bSxjb2xdID0gc2VhcmNocGFpcnBvcygneycsICcnLCAnfScsICduJykKPAoJCVNlZSB8bWF0Y2gtcGFyZW5zfCBmb3IgYSBiaWdnZXIgYW5kIG1vcmUgdXNlZnVsIGV4YW1wbGUuCgpzZWFyY2hwb3Moe3BhdHRlcm59IFssIHtmbGFnc30gWywge3N0b3BsaW5lfSBbLCB7dGltZW91dH1dXV0pCSpzZWFyY2hwb3MoKSoKCQlTYW1lIGFzIHxzZWFyY2goKXwsIGJ1dCByZXR1cm5zIGEgfExpc3R8IHdpdGggdGhlIGxpbmUgYW5kCgkJY29sdW1uIHBvc2l0aW9uIG9mIHRoZSBtYXRjaC4gVGhlIGZpcnN0IGVsZW1lbnQgb2YgdGhlIHxMaXN0fAoJCWlzIHRoZSBsaW5lIG51bWJlciBhbmQgdGhlIHNlY29uZCBlbGVtZW50IGlzIHRoZSBieXRlIGluZGV4IG9mCgkJdGhlIGNvbHVtbiBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guIElmIG5vIG1hdGNoIGlzIGZvdW5kLAoJCXJldHVybnMgWzAsIDBdLgoJCUV4YW1wbGU6ID4KCTpsZXQgW2xudW0sIGNvbF0gPSBzZWFyY2hwb3MoJ215cGF0dGVybicsICduJykKCjwJCVdoZW4gdGhlICdwJyBmbGFnIGlzIGdpdmVuIHRoZW4gdGhlcmUgaXMgYW4gZXh0cmEgaXRlbSB3aXRoCgkJdGhlIHN1Yi1wYXR0ZXJuIG1hdGNoIG51bWJlciB8c2VhcmNoKCktc3ViLW1hdGNofC4gIEV4YW1wbGU6ID4KCTpsZXQgW2xudW0sIGNvbCwgc3VibWF0Y2hdID0gc2VhcmNocG9zKCdcKFxsXClcfFwoXHVcKScsICducCcpCjwJCUluIHRoaXMgZXhhbXBsZSAic3VibWF0Y2giIGlzIDIgd2hlbiBhIGxvd2VyY2FzZSBsZXR0ZXIgaXMKCQlmb3VuZCB8L1xsfCwgMyB3aGVuIGFuIHVwcGVyY2FzZSBsZXR0ZXIgaXMgZm91bmQgfC9cdXwuCgpzZXJ2ZXIyY2xpZW50KHtjbGllbnRpZH0sIHtzdHJpbmd9KQkJCSpzZXJ2ZXIyY2xpZW50KCkqCgkJU2VuZCBhIHJlcGx5IHN0cmluZyB0byB7Y2xpZW50aWR9LiAgVGhlIG1vc3QgcmVjZW50IHtjbGllbnRpZH0KCQl0aGF0IHNlbnQgYSBzdHJpbmcgY2FuIGJlIHJldHJpZXZlZCB3aXRoIGV4cGFuZCgiPGNsaWVudD4iKS4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NsaWVudHNlcnZlcnwgZmVhdHVyZX0KCQlOb3RlOgoJCVRoaXMgaWQgaGFzIHRvIGJlIHN0b3JlZCBiZWZvcmUgdGhlIG5leHQgY29tbWFuZCBjYW4gYmUKCQlyZWNlaXZlZC4gIEkuZS4gYmVmb3JlIHJldHVybmluZyBmcm9tIHRoZSByZWNlaXZlZCBjb21tYW5kIGFuZAoJCWJlZm9yZSBjYWxsaW5nIGFueSBjb21tYW5kcyB0aGF0IHdhaXRzIGZvciBpbnB1dC4KCQlTZWUgYWxzbyB8Y2xpZW50c2VydmVyfC4KCQlFeGFtcGxlOiA+CgkJCTplY2hvIHNlcnZlcjJjbGllbnQoZXhwYW5kKCI8Y2xpZW50PiIpLCAiSEVMTE8iKQo8CnNlcnZlcmxpc3QoKQkJCQkJKnNlcnZlcmxpc3QoKSoKCQlSZXR1cm4gYSBsaXN0IG9mIGF2YWlsYWJsZSBzZXJ2ZXIgbmFtZXMsIG9uZSBwZXIgbGluZS4KCQlXaGVuIHRoZXJlIGFyZSBubyBzZXJ2ZXJzIG9yIHRoZSBpbmZvcm1hdGlvbiBpcyBub3QgYXZhaWxhYmxlCgkJYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLiAgU2VlIGFsc28gfGNsaWVudHNlcnZlcnwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJRXhhbXBsZTogPgoJCQk6ZWNobyBzZXJ2ZXJsaXN0KCkKPApzZXRidWZ2YXIoe2V4cHJ9LCB7dmFybmFtZX0sIHt2YWx9KQkJCSpzZXRidWZ2YXIoKSoKCQlTZXQgb3B0aW9uIG9yIGxvY2FsIHZhcmlhYmxlIHt2YXJuYW1lfSBpbiBidWZmZXIge2V4cHJ9IHRvCgkJe3ZhbH0uCgkJVGhpcyBhbHNvIHdvcmtzIGZvciBhIGdsb2JhbCBvciBsb2NhbCB3aW5kb3cgb3B0aW9uLCBidXQgaXQKCQlkb2Vzbid0IHdvcmsgZm9yIGEgZ2xvYmFsIG9yIGxvY2FsIHdpbmRvdyB2YXJpYWJsZS4KCQlGb3IgYSBsb2NhbCB3aW5kb3cgb3B0aW9uIHRoZSBnbG9iYWwgdmFsdWUgaXMgdW5jaGFuZ2VkLgoJCUZvciB0aGUgdXNlIG9mIHtleHByfSwgc2VlIHxidWZuYW1lKCl8IGFib3ZlLgoJCU5vdGUgdGhhdCB0aGUgdmFyaWFibGUgbmFtZSB3aXRob3V0ICJiOiIgbXVzdCBiZSB1c2VkLgoJCUV4YW1wbGVzOiA+CgkJCTpjYWxsIHNldGJ1ZnZhcigxLCAiJm1vZCIsIDEpCgkJCTpjYWxsIHNldGJ1ZnZhcigidG9kbyIsICJteXZhciIsICJmb29iYXIiKQo8CQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCnNldGNoYXJzZWFyY2goe2RpY3R9KQkJCQkJKnNldGNoYXJzZWFyY2goKSoKCQlTZXQgdGhlIGN1cnJlbnQgY2hhcmFjdGVyIHNlYXJjaCBpbmZvcm1hdGlvbiB0byB7ZGljdH0sCgkJd2hpY2ggY29udGFpbnMgb25lIG9yIG1vcmUgb2YgdGhlIGZvbGxvd2luZyBlbnRyaWVzOgoKCQkgICAgY2hhcgljaGFyYWN0ZXIgd2hpY2ggd2lsbCBiZSB1c2VkIGZvciBhIHN1YnNlcXVlbnQKCQkJCXwsfCBvciB8O3wgY29tbWFuZDsgYW4gZW1wdHkgc3RyaW5nIGNsZWFycyB0aGUKCQkJCWNoYXJhY3RlciBzZWFyY2gKCQkgICAgZm9yd2FyZAlkaXJlY3Rpb24gb2YgY2hhcmFjdGVyIHNlYXJjaDsgMSBmb3IgZm9yd2FyZCwKCQkJCTAgZm9yIGJhY2t3YXJkCgkJICAgIHVudGlsCXR5cGUgb2YgY2hhcmFjdGVyIHNlYXJjaDsgMSBmb3IgYSB8dHwgb3IgfFR8CgkJCQljaGFyYWN0ZXIgc2VhcmNoLCAwIGZvciBhbiB8Znwgb3IgfEZ8CgkJCQljaGFyYWN0ZXIgc2VhcmNoCgoJCVRoaXMgY2FuIGJlIHVzZWZ1bCB0byBzYXZlL3Jlc3RvcmUgYSB1c2VyJ3MgY2hhcmFjdGVyIHNlYXJjaAoJCWZyb20gYSBzY3JpcHQ6ID4KCQkJOmxldCBwcmV2c2VhcmNoID0gZ2V0Y2hhcnNlYXJjaCgpCgkJCToiIFBlcmZvcm0gYSBjb21tYW5kIHdoaWNoIGNsb2JiZXJzIHVzZXIncyBzZWFyY2gKCQkJOmNhbGwgc2V0Y2hhcnNlYXJjaChwcmV2c2VhcmNoKQo8CQlBbHNvIHNlZSB8Z2V0Y2hhcnNlYXJjaCgpfC4KCnNldGNtZHBvcyh7cG9zfSkJCQkJCSpzZXRjbWRwb3MoKSoKCQlTZXQgdGhlIGN1cnNvciBwb3NpdGlvbiBpbiB0aGUgY29tbWFuZCBsaW5lIHRvIGJ5dGUgcG9zaXRpb24KCQl7cG9zfS4JVGhlIGZpcnN0IHBvc2l0aW9uIGlzIDEuCgkJVXNlIHxnZXRjbWRwb3MoKXwgdG8gb2J0YWluIHRoZSBjdXJyZW50IHBvc2l0aW9uLgoJCU9ubHkgd29ya3Mgd2hpbGUgZWRpdGluZyB0aGUgY29tbWFuZCBsaW5lLCB0aHVzIHlvdSBtdXN0IHVzZQoJCXxjX0NUUkwtXF9lfCwgfGNfQ1RSTC1SXz18IG9yIHxjX0NUUkwtUl9DVFJMLVJ8IHdpdGggJz0nLiAgRm9yCgkJfGNfQ1RSTC1cX2V8IGFuZCB8Y19DVFJMLVJfQ1RSTC1SfCB3aXRoICc9JyB0aGUgcG9zaXRpb24gaXMKCQlzZXQgYWZ0ZXIgdGhlIGNvbW1hbmQgbGluZSBpcyBzZXQgdG8gdGhlIGV4cHJlc3Npb24uICBGb3IKCQl8Y19DVFJMLVJfPXwgaXQgaXMgc2V0IGFmdGVyIGV2YWx1YXRpbmcgdGhlIGV4cHJlc3Npb24gYnV0CgkJYmVmb3JlIGluc2VydGluZyB0aGUgcmVzdWx0aW5nIHRleHQuCgkJV2hlbiB0aGUgbnVtYmVyIGlzIHRvbyBiaWcgdGhlIGN1cnNvciBpcyBwdXQgYXQgdGhlIGVuZCBvZiB0aGUKCQlsaW5lLiAgQSBudW1iZXIgc21hbGxlciB0aGFuIG9uZSBoYXMgdW5kZWZpbmVkIHJlc3VsdHMuCgkJUmV0dXJucyAwIHdoZW4gc3VjY2Vzc2Z1bCwgMSB3aGVuIG5vdCBlZGl0aW5nIHRoZSBjb21tYW5kCgkJbGluZS4KCnNldGZwZXJtKHtmbmFtZX0sIHttb2RlfSkJCQkJKnNldGZwZXJtKCkqICpjaG1vZCoKCQlTZXQgdGhlIGZpbGUgcGVybWlzc2lvbnMgZm9yIHtmbmFtZX0gdG8ge21vZGV9LgoJCXttb2RlfSBtdXN0IGJlIGEgc3RyaW5nIHdpdGggOSBjaGFyYWN0ZXJzLiAgSXQgaXMgb2YgdGhlIGZvcm0KCQkicnd4cnd4cnd4Iiwgd2hlcmUgZWFjaCBncm91cCBvZiAicnd4IiBmbGFncyByZXByZXNlbnQsIGluCgkJdHVybiwgdGhlIHBlcm1pc3Npb25zIG9mIHRoZSBvd25lciBvZiB0aGUgZmlsZSwgdGhlIGdyb3VwIHRoZQoJCWZpbGUgYmVsb25ncyB0bywgYW5kIG90aGVyIHVzZXJzLiAgQSAnLScgY2hhcmFjdGVyIG1lYW5zIHRoZQoJCXBlcm1pc3Npb24gaXMgb2ZmLCBhbnkgb3RoZXIgY2hhcmFjdGVyIG1lYW5zIG9uLiAgTXVsdGktYnl0ZQoJCWNoYXJhY3RlcnMgYXJlIG5vdCBzdXBwb3J0ZWQuCgoJCUZvciBleGFtcGxlICJydy1yLS0tLS0iIG1lYW5zIHJlYWQtd3JpdGUgZm9yIHRoZSB1c2VyLAoJCXJlYWRhYmxlIGJ5IHRoZSBncm91cCwgbm90IGFjY2Vzc2libGUgYnkgb3RoZXJzLiAgInh4LXgtLS0tLSIKCQl3b3VsZCBkbyB0aGUgc2FtZSB0aGluZy4KCgkJUmV0dXJucyBub24temVybyBmb3Igc3VjY2VzcywgemVybyBmb3IgZmFpbHVyZS4KCgkJVG8gcmVhZCBwZXJtaXNzaW9ucyBzZWUgfGdldGZwZXJtKCl8LgoKCnNldGxpbmUoe2xudW19LCB7dGV4dH0pCQkJCQkqc2V0bGluZSgpKgoJCVNldCBsaW5lIHtsbnVtfSBvZiB0aGUgY3VycmVudCBidWZmZXIgdG8ge3RleHR9LiAgVG8gaW5zZXJ0CgkJbGluZXMgdXNlIHxhcHBlbmQoKXwuCgkJe2xudW19IGlzIHVzZWQgbGlrZSB3aXRoIHxnZXRsaW5lKCl8LgoJCVdoZW4ge2xudW19IGlzIGp1c3QgYmVsb3cgdGhlIGxhc3QgbGluZSB0aGUge3RleHR9IHdpbGwgYmUKCQlhZGRlZCBhcyBhIG5ldyBsaW5lLgoJCUlmIHRoaXMgc3VjY2VlZHMsIDAgaXMgcmV0dXJuZWQuICBJZiB0aGlzIGZhaWxzIChtb3N0IGxpa2VseQoJCWJlY2F1c2Uge2xudW19IGlzIGludmFsaWQpIDEgaXMgcmV0dXJuZWQuICBFeGFtcGxlOiA+CgkJCTpjYWxsIHNldGxpbmUoNSwgc3RyZnRpbWUoIiVjIikpCjwJCVdoZW4ge3RleHR9IGlzIGEgfExpc3R8IHRoZW4gbGluZSB7bG51bX0gYW5kIGZvbGxvd2luZyBsaW5lcwoJCXdpbGwgYmUgc2V0IHRvIHRoZSBpdGVtcyBpbiB0aGUgbGlzdC4gIEV4YW1wbGU6ID4KCQkJOmNhbGwgc2V0bGluZSg1LCBbJ2FhYScsICdiYmInLCAnY2NjJ10pCjwJCVRoaXMgaXMgZXF1aXZhbGVudCB0bzogPgoJCQk6Zm9yIFtuLCBsXSBpbiBbWzUsICdhYWEnXSwgWzYsICdiYmInXSwgWzcsICdjY2MnXV0KCQkJOiAgY2FsbCBzZXRsaW5lKG4sIGwpCgkJCTplbmRmb3IKPAkJTm90ZTogVGhlICdbIGFuZCAnXSBtYXJrcyBhcmUgbm90IHNldC4KCnNldGxvY2xpc3Qoe25yfSwge2xpc3R9IFssIHthY3Rpb259XSkJCQkqc2V0bG9jbGlzdCgpKgoJCUNyZWF0ZSBvciByZXBsYWNlIG9yIGFkZCB0byB0aGUgbG9jYXRpb24gbGlzdCBmb3Igd2luZG93IHtucn0uCgkJV2hlbiB7bnJ9IGlzIHplcm8gdGhlIGN1cnJlbnQgd2luZG93IGlzIHVzZWQuIEZvciBhIGxvY2F0aW9uCgkJbGlzdCB3aW5kb3csIHRoZSBkaXNwbGF5ZWQgbG9jYXRpb24gbGlzdCBpcyBtb2RpZmllZC4gIEZvciBhbgoJCWludmFsaWQgd2luZG93IG51bWJlciB7bnJ9LCAtMSBpcyByZXR1cm5lZC4KCQlPdGhlcndpc2UsIHNhbWUgYXMgfHNldHFmbGlzdCgpfC4KCQlBbHNvIHNlZSB8bG9jYXRpb24tbGlzdHwuCgpzZXRtYXRjaGVzKHtsaXN0fSkJCQkJCSpzZXRtYXRjaGVzKCkqCgkJUmVzdG9yZXMgYSBsaXN0IG9mIG1hdGNoZXMgc2F2ZWQgYnkgfGdldG1hdGNoZXMoKXwuICBSZXR1cm5zIDAKCQlpZiBzdWNjZXNzZnVsLCBvdGhlcndpc2UgLTEuICBBbGwgY3VycmVudCBtYXRjaGVzIGFyZSBjbGVhcmVkCgkJYmVmb3JlIHRoZSBsaXN0IGlzIHJlc3RvcmVkLiAgU2VlIGV4YW1wbGUgZm9yIHxnZXRtYXRjaGVzKCl8LgoKCQkJCQkJCSpzZXRwb3MoKSoKc2V0cG9zKHtleHByfSwge2xpc3R9KQoJCVNldCB0aGUgcG9zaXRpb24gZm9yIHtleHByfS4gIFBvc3NpYmxlIHZhbHVlczoKCQkJLgl0aGUgY3Vyc29yCgkJCSd4CW1hcmsgeAoKCQl7bGlzdH0gbXVzdCBiZSBhIHxMaXN0fCB3aXRoIGZvdXIgb3IgZml2ZSBudW1iZXJzOgoJCSAgICBbYnVmbnVtLCBsbnVtLCBjb2wsIG9mZl0KCQkgICAgW2J1Zm51bSwgbG51bSwgY29sLCBvZmYsIGN1cnN3YW50XQoKCQkiYnVmbnVtIiBpcyB0aGUgYnVmZmVyIG51bWJlci4JWmVybyBjYW4gYmUgdXNlZCBmb3IgdGhlCgkJY3VycmVudCBidWZmZXIuICBTZXR0aW5nIHRoZSBjdXJzb3IgaXMgb25seSBwb3NzaWJsZSBmb3IKCQl0aGUgY3VycmVudCBidWZmZXIuICBUbyBzZXQgYSBtYXJrIGluIGFub3RoZXIgYnVmZmVyIHlvdSBjYW4KCQl1c2UgdGhlIHxidWZucigpfCBmdW5jdGlvbiB0byB0dXJuIGEgZmlsZSBuYW1lIGludG8gYSBidWZmZXIKCQludW1iZXIuCgkJRG9lcyBub3QgY2hhbmdlIHRoZSBqdW1wbGlzdC4KCgkJImxudW0iIGFuZCAiY29sIiBhcmUgdGhlIHBvc2l0aW9uIGluIHRoZSBidWZmZXIuICBUaGUgZmlyc3QKCQljb2x1bW4gaXMgMS4gIFVzZSBhIHplcm8gImxudW0iIHRvIGRlbGV0ZSBhIG1hcmsuICBJZiAiY29sIiBpcwoJCXNtYWxsZXIgdGhhbiAxIHRoZW4gMSBpcyB1c2VkLgoKCQlUaGUgIm9mZiIgbnVtYmVyIGlzIG9ubHkgdXNlZCB3aGVuICd2aXJ0dWFsZWRpdCcgaXMgc2V0LiBUaGVuCgkJaXQgaXMgdGhlIG9mZnNldCBpbiBzY3JlZW4gY29sdW1ucyBmcm9tIHRoZSBzdGFydCBvZiB0aGUKCQljaGFyYWN0ZXIuICBFLmcuLCBhIHBvc2l0aW9uIHdpdGhpbiBhIDxUYWI+IG9yIGFmdGVyIHRoZSBsYXN0CgkJY2hhcmFjdGVyLgoKCQlUaGUgImN1cnN3YW50IiBudW1iZXIgaXMgb25seSB1c2VkIHdoZW4gc2V0dGluZyB0aGUgY3Vyc29yCgkJcG9zaXRpb24uICBJdCBzZXRzIHRoZSBwcmVmZXJyZWQgY29sdW1uIGZvciB3aGVuIG1vdmluZyB0aGUKCQljdXJzb3IgdmVydGljYWxseS4gIFdoZW4gdGhlICJjdXJzd2FudCIgbnVtYmVyIGlzIG1pc3NpbmcgdGhlCgkJcHJlZmVycmVkIGNvbHVtbiBpcyBub3Qgc2V0LiAgV2hlbiBpdCBpcyBwcmVzZW50IGFuZCBzZXR0aW5nIGEKCQltYXJrIHBvc2l0aW9uIGl0IGlzIG5vdCB1c2VkLgoKCQlOb3RlIHRoYXQgZm9yICc8IGFuZCAnPiBjaGFuZ2luZyB0aGUgbGluZSBudW1iZXIgbWF5IHJlc3VsdCBpbgoJCXRoZSBtYXJrcyB0byBiZSBlZmZlY3RpdmVseSBiZSBzd2FwcGVkLCBzbyB0aGF0ICc8IGlzIGFsd2F5cwoJCWJlZm9yZSAnPi4KCgkJUmV0dXJucyAwIHdoZW4gdGhlIHBvc2l0aW9uIGNvdWxkIGJlIHNldCwgLTEgb3RoZXJ3aXNlLgoJCUFuIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4gaWYge2V4cHJ9IGlzIGludmFsaWQuCgoJCUFsc28gc2VlIHxnZXRwb3MoKXwgYW5kIHxnZXRjdXJwb3MoKXwuCgoJCVRoaXMgZG9lcyBub3QgcmVzdG9yZSB0aGUgcHJlZmVycmVkIGNvbHVtbiBmb3IgbW92aW5nCgkJdmVydGljYWxseTsgaWYgeW91IHNldCB0aGUgY3Vyc29yIHBvc2l0aW9uIHdpdGggdGhpcywgfGp8IGFuZAoJCXxrfCBtb3Rpb25zIHdpbGwganVtcCB0byBwcmV2aW91cyBjb2x1bW5zISAgVXNlIHxjdXJzb3IoKXwgdG8KCQlhbHNvIHNldCB0aGUgcHJlZmVycmVkIGNvbHVtbi4gIEFsc28gc2VlIHRoZSAiY3Vyc3dhbnQiIGtleSBpbgoJCXx3aW5yZXN0dmlldygpfC4KCgpzZXRxZmxpc3Qoe2xpc3R9IFssIHthY3Rpb259XSkJCQkJKnNldHFmbGlzdCgpKgoJCUNyZWF0ZSBvciByZXBsYWNlIG9yIGFkZCB0byB0aGUgcXVpY2tmaXggbGlzdCB1c2luZyB0aGUgaXRlbXMKCQlpbiB7bGlzdH0uICBFYWNoIGl0ZW0gaW4ge2xpc3R9IGlzIGEgZGljdGlvbmFyeS4KCQlOb24tZGljdGlvbmFyeSBpdGVtcyBpbiB7bGlzdH0gYXJlIGlnbm9yZWQuICBFYWNoIGRpY3Rpb25hcnkKCQlpdGVtIGNhbiBjb250YWluIHRoZSBmb2xsb3dpbmcgZW50cmllczoKCgkJICAgIGJ1Zm5yCWJ1ZmZlciBudW1iZXI7IG11c3QgYmUgdGhlIG51bWJlciBvZiBhIHZhbGlkCgkJCQlidWZmZXIKCQkgICAgZmlsZW5hbWUJbmFtZSBvZiBhIGZpbGU7IG9ubHkgdXNlZCB3aGVuICJidWZuciIgaXMgbm90CgkJCQlwcmVzZW50IG9yIGl0IGlzIGludmFsaWQuCgkJICAgIGxudW0JbGluZSBudW1iZXIgaW4gdGhlIGZpbGUKCQkgICAgcGF0dGVybglzZWFyY2ggcGF0dGVybiB1c2VkIHRvIGxvY2F0ZSB0aGUgZXJyb3IKCQkgICAgY29sCQljb2x1bW4gbnVtYmVyCgkJICAgIHZjb2wJd2hlbiBub24temVybzogImNvbCIgaXMgdmlzdWFsIGNvbHVtbgoJCQkJd2hlbiB6ZXJvOiAiY29sIiBpcyBieXRlIGluZGV4CgkJICAgIG5yCQllcnJvciBudW1iZXIKCQkgICAgdGV4dAlkZXNjcmlwdGlvbiBvZiB0aGUgZXJyb3IKCQkgICAgdHlwZQlzaW5nbGUtY2hhcmFjdGVyIGVycm9yIHR5cGUsICdFJywgJ1cnLCBldGMuCgoJCVRoZSAiY29sIiwgInZjb2wiLCAibnIiLCAidHlwZSIgYW5kICJ0ZXh0IiBlbnRyaWVzIGFyZQoJCW9wdGlvbmFsLiAgRWl0aGVyICJsbnVtIiBvciAicGF0dGVybiIgZW50cnkgY2FuIGJlIHVzZWQgdG8KCQlsb2NhdGUgYSBtYXRjaGluZyBlcnJvciBsaW5lLgoJCUlmIHRoZSAiZmlsZW5hbWUiIGFuZCAiYnVmbnIiIGVudHJpZXMgYXJlIG5vdCBwcmVzZW50IG9yCgkJbmVpdGhlciB0aGUgImxudW0iIG9yICJwYXR0ZXJuIiBlbnRyaWVzIGFyZSBwcmVzZW50LCB0aGVuIHRoZQoJCWl0ZW0gd2lsbCBub3QgYmUgaGFuZGxlZCBhcyBhbiBlcnJvciBsaW5lLgoJCUlmIGJvdGggInBhdHRlcm4iIGFuZCAibG51bSIgYXJlIHByZXNlbnQgdGhlbiAicGF0dGVybiIgd2lsbAoJCWJlIHVzZWQuCgkJSWYgeW91IHN1cHBseSBhbiBlbXB0eSB7bGlzdH0sIHRoZSBxdWlja2ZpeCBsaXN0IHdpbGwgYmUKCQljbGVhcmVkLgoJCU5vdGUgdGhhdCB0aGUgbGlzdCBpcyBub3QgZXhhY3RseSB0aGUgc2FtZSBhcyB3aGF0CgkJfGdldHFmbGlzdCgpfCByZXR1cm5zLgoKCQkJCQkJCSpFOTI3KgoJCUlmIHthY3Rpb259IGlzIHNldCB0byAnYScsIHRoZW4gdGhlIGl0ZW1zIGZyb20ge2xpc3R9IGFyZQoJCWFkZGVkIHRvIHRoZSBleGlzdGluZyBxdWlja2ZpeCBsaXN0LiBJZiB0aGVyZSBpcyBubyBleGlzdGluZwoJCWxpc3QsIHRoZW4gYSBuZXcgbGlzdCBpcyBjcmVhdGVkLiBJZiB7YWN0aW9ufSBpcyBzZXQgdG8gJ3InLAoJCXRoZW4gdGhlIGl0ZW1zIGZyb20gdGhlIGN1cnJlbnQgcXVpY2tmaXggbGlzdCBhcmUgcmVwbGFjZWQKCQl3aXRoIHRoZSBpdGVtcyBmcm9tIHtsaXN0fS4gSWYge2FjdGlvbn0gaXMgbm90IHByZXNlbnQgb3IgaXMKCQlzZXQgdG8gJyAnLCB0aGVuIGEgbmV3IGxpc3QgaXMgY3JlYXRlZC4KCgkJUmV0dXJucyB6ZXJvIGZvciBzdWNjZXNzLCAtMSBmb3IgZmFpbHVyZS4KCgkJVGhpcyBmdW5jdGlvbiBjYW4gYmUgdXNlZCB0byBjcmVhdGUgYSBxdWlja2ZpeCBsaXN0CgkJaW5kZXBlbmRlbnQgb2YgdGhlICdlcnJvcmZvcm1hdCcgc2V0dGluZy4gIFVzZSBhIGNvbW1hbmQgbGlrZQoJCSI6Y2MgMSIgdG8ganVtcCB0byB0aGUgZmlyc3QgcG9zaXRpb24uCgoKCQkJCQkJCSpzZXRyZWcoKSoKc2V0cmVnKHtyZWduYW1lfSwge3ZhbHVlfSBbLCB7b3B0aW9uc31dKQoJCVNldCB0aGUgcmVnaXN0ZXIge3JlZ25hbWV9IHRvIHt2YWx1ZX0uCgkJe3ZhbHVlfSBtYXkgYmUgYW55IHZhbHVlIHJldHVybmVkIGJ5IHxnZXRyZWcoKXwsIGluY2x1ZGluZyAKCQlhIHxMaXN0fC4KCQlJZiB7b3B0aW9uc30gY29udGFpbnMgImEiIG9yIHtyZWduYW1lfSBpcyB1cHBlciBjYXNlLAoJCXRoZW4gdGhlIHZhbHVlIGlzIGFwcGVuZGVkLgoJCXtvcHRpb25zfSBjYW4gYWxzbyBjb250YWluIGEgcmVnaXN0ZXIgdHlwZSBzcGVjaWZpY2F0aW9uOgoJCSAgICAiYyIgb3IgInYiCSAgICAgIHxjaGFyYWN0ZXJ3aXNlfCBtb2RlCgkJICAgICJsIiBvciAiViIJICAgICAgfGxpbmV3aXNlfCBtb2RlCgkJICAgICJiIiBvciAiPENUUkwtVj4iIHxibG9ja3dpc2UtdmlzdWFsfCBtb2RlCgkJSWYgYSBudW1iZXIgaW1tZWRpYXRlbHkgZm9sbG93cyAiYiIgb3IgIjxDVFJMLVY+IiB0aGVuIHRoaXMgaXMKCQl1c2VkIGFzIHRoZSB3aWR0aCBvZiB0aGUgc2VsZWN0aW9uIC0gaWYgaXQgaXMgbm90IHNwZWNpZmllZAoJCXRoZW4gdGhlIHdpZHRoIG9mIHRoZSBibG9jayBpcyBzZXQgdG8gdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzCgkJaW4gdGhlIGxvbmdlc3QgbGluZSAoY291bnRpbmcgYSA8VGFiPiBhcyAxIGNoYXJhY3RlcikuCgoJCUlmIHtvcHRpb25zfSBjb250YWlucyBubyByZWdpc3RlciBzZXR0aW5ncywgdGhlbiB0aGUgZGVmYXVsdAoJCWlzIHRvIHVzZSBjaGFyYWN0ZXIgbW9kZSB1bmxlc3Mge3ZhbHVlfSBlbmRzIGluIGEgPE5MPiBmb3IgCgkJc3RyaW5nIHt2YWx1ZX0gYW5kIGxpbmV3aXNlIG1vZGUgZm9yIGxpc3Qge3ZhbHVlfS4gQmxvY2t3aXNlIAoJCW1vZGUgaXMgbmV2ZXIgc2VsZWN0ZWQgYXV0b21hdGljYWxseS4KCQlSZXR1cm5zIHplcm8gZm9yIHN1Y2Nlc3MsIG5vbi16ZXJvIGZvciBmYWlsdXJlLgoKCQkJCQkJCSpFODgzKgoJCU5vdGU6IHlvdSBtYXkgbm90IHVzZSB8TGlzdHwgY29udGFpbmluZyBtb3JlIHRoYW4gb25lIGl0ZW0gdG8gCgkJICAgICAgc2V0IHNlYXJjaCBhbmQgZXhwcmVzc2lvbiByZWdpc3RlcnMuIExpc3RzIGNvbnRhaW5pbmcgbm8gCgkJICAgICAgaXRlbXMgYWN0IGxpa2UgZW1wdHkgc3RyaW5ncy4KCgkJRXhhbXBsZXM6ID4KCQkJOmNhbGwgc2V0cmVnKHY6cmVnaXN0ZXIsIEAqKQoJCQk6Y2FsbCBzZXRyZWcoJyonLCBAJSwgJ2FjJykKCQkJOmNhbGwgc2V0cmVnKCdhJywgIjFcbjJcbjMiLCAnYjUnKQoKPAkJVGhpcyBleGFtcGxlIHNob3dzIHVzaW5nIHRoZSBmdW5jdGlvbnMgdG8gc2F2ZSBhbmQgcmVzdG9yZSBhCgkJcmVnaXN0ZXIgKG5vdGU6IHlvdSBtYXkgbm90IHJlbGlhYmx5IHJlc3RvcmUgcmVnaXN0ZXIgdmFsdWUgCgkJd2l0aG91dCB1c2luZyB0aGUgdGhpcmQgYXJndW1lbnQgdG8gfGdldHJlZygpfCBhcyB3aXRob3V0IGl0IAoJCW5ld2xpbmVzIGFyZSByZXByZXNlbnRlZCBhcyBuZXdsaW5lcyBBTkQgTnVsIGJ5dGVzIGFyZSAKCQlyZXByZXNlbnRlZCBhcyBuZXdsaW5lcyBhcyB3ZWxsLCBzZWUgfE5MLXVzZWQtZm9yLU51bHwpLiA+CgkJCTpsZXQgdmFyX2EgPSBnZXRyZWcoJ2EnLCAxLCAxKQoJCQk6bGV0IHZhcl9hbW9kZSA9IGdldHJlZ3R5cGUoJ2EnKQoJCQkgICAgLi4uLgoJCQk6Y2FsbCBzZXRyZWcoJ2EnLCB2YXJfYSwgdmFyX2Ftb2RlKQoKPAkJWW91IGNhbiBhbHNvIGNoYW5nZSB0aGUgdHlwZSBvZiBhIHJlZ2lzdGVyIGJ5IGFwcGVuZGluZwoJCW5vdGhpbmc6ID4KCQkJOmNhbGwgc2V0cmVnKCdhJywgJycsICdhbCcpCgpzZXR0YWJ2YXIoe3RhYm5yfSwge3Zhcm5hbWV9LCB7dmFsfSkJCQkqc2V0dGFidmFyKCkqCgkJU2V0IHRhYi1sb2NhbCB2YXJpYWJsZSB7dmFybmFtZX0gdG8ge3ZhbH0gaW4gdGFiIHBhZ2Uge3RhYm5yfS4KCQl8dDp2YXJ8CgkJTm90ZSB0aGF0IHRoZSB2YXJpYWJsZSBuYW1lIHdpdGhvdXQgInQ6IiBtdXN0IGJlIHVzZWQuCgkJVGFicyBhcmUgbnVtYmVyZWQgc3RhcnRpbmcgd2l0aCBvbmUuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgpzZXR0YWJ3aW52YXIoe3RhYm5yfSwge3dpbm5yfSwge3Zhcm5hbWV9LCB7dmFsfSkJKnNldHRhYndpbnZhcigpKgoJCVNldCBvcHRpb24gb3IgbG9jYWwgdmFyaWFibGUge3Zhcm5hbWV9IGluIHdpbmRvdyB7d2lubnJ9IHRvCgkJe3ZhbH0uCgkJVGFicyBhcmUgbnVtYmVyZWQgc3RhcnRpbmcgd2l0aCBvbmUuICBGb3IgdGhlIGN1cnJlbnQgdGFicGFnZQoJCXVzZSB8c2V0d2ludmFyKCl8LgoJCVdoZW4ge3dpbm5yfSBpcyB6ZXJvIHRoZSBjdXJyZW50IHdpbmRvdyBpcyB1c2VkLgoJCVRoaXMgYWxzbyB3b3JrcyBmb3IgYSBnbG9iYWwgb3IgbG9jYWwgYnVmZmVyIG9wdGlvbiwgYnV0IGl0CgkJZG9lc24ndCB3b3JrIGZvciBhIGdsb2JhbCBvciBsb2NhbCBidWZmZXIgdmFyaWFibGUuCgkJRm9yIGEgbG9jYWwgYnVmZmVyIG9wdGlvbiB0aGUgZ2xvYmFsIHZhbHVlIGlzIHVuY2hhbmdlZC4KCQlOb3RlIHRoYXQgdGhlIHZhcmlhYmxlIG5hbWUgd2l0aG91dCAidzoiIG11c3QgYmUgdXNlZC4KCQlFeGFtcGxlczogPgoJCQk6Y2FsbCBzZXR0YWJ3aW52YXIoMSwgMSwgIiZsaXN0IiwgMCkKCQkJOmNhbGwgc2V0dGFid2ludmFyKDMsIDIsICJteXZhciIsICJmb29iYXIiKQo8CQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCnNldHdpbnZhcih7bnJ9LCB7dmFybmFtZX0sIHt2YWx9KQkJCSpzZXR3aW52YXIoKSoKCQlMaWtlIHxzZXR0YWJ3aW52YXIoKXwgZm9yIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoJCUV4YW1wbGVzOiA+CgkJCTpjYWxsIHNldHdpbnZhcigxLCAiJmxpc3QiLCAwKQoJCQk6Y2FsbCBzZXR3aW52YXIoMiwgIm15dmFyIiwgImZvb2JhciIpCgpzaGEyNTYoe3N0cmluZ30pCQkJCQkJKnNoYTI1NigpKgoJCVJldHVybnMgYSBTdHJpbmcgd2l0aCA2NCBoZXggY2hhcmFjdGVycywgd2hpY2ggaXMgdGhlIFNIQTI1NgoJCWNoZWNrc3VtIG9mIHtzdHJpbmd9LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY3J5cHR2fCBmZWF0dXJlfQoKc2hlbGxlc2NhcGUoe3N0cmluZ30gWywge3NwZWNpYWx9XSkJCQkqc2hlbGxlc2NhcGUoKSoKCQlFc2NhcGUge3N0cmluZ30gZm9yIHVzZSBhcyBhIHNoZWxsIGNvbW1hbmQgYXJndW1lbnQuCgkJT24gTVMtV2luZG93cyBhbmQgTVMtRE9TLCB3aGVuICdzaGVsbHNsYXNoJyBpcyBub3Qgc2V0LCBpdAoJCXdpbGwgZW5jbG9zZSB7c3RyaW5nfSBpbiBkb3VibGUgcXVvdGVzIGFuZCBkb3VibGUgYWxsIGRvdWJsZQoJCXF1b3RlcyB3aXRoaW4ge3N0cmluZ30uCgkJRm9yIG90aGVyIHN5c3RlbXMsIGl0IHdpbGwgZW5jbG9zZSB7c3RyaW5nfSBpbiBzaW5nbGUgcXVvdGVzCgkJYW5kIHJlcGxhY2UgYWxsICInIiB3aXRoICInXCcnIi4KCQlXaGVuIHRoZSB7c3BlY2lhbH0gYXJndW1lbnQgaXMgcHJlc2VudCBhbmQgaXQncyBhIG5vbi16ZXJvCgkJTnVtYmVyIG9yIGEgbm9uLWVtcHR5IFN0cmluZyAofG5vbi16ZXJvLWFyZ3wpLCB0aGVuIHNwZWNpYWwKCQlpdGVtcyBzdWNoIGFzICIhIiwgIiUiLCAiIyIgYW5kICI8Y3dvcmQ+IiB3aWxsIGJlIHByZWNlZGVkIGJ5CgkJYSBiYWNrc2xhc2guICBUaGlzIGJhY2tzbGFzaCB3aWxsIGJlIHJlbW92ZWQgYWdhaW4gYnkgdGhlIHw6IXwKCQljb21tYW5kLgoJCVRoZSAiISIgY2hhcmFjdGVyIHdpbGwgYmUgZXNjYXBlZCAoYWdhaW4gd2l0aCBhIHxub24temVyby1hcmd8CgkJe3NwZWNpYWx9KSB3aGVuICdzaGVsbCcgY29udGFpbnMgImNzaCIgaW4gdGhlIHRhaWwuICBUaGF0IGlzCgkJYmVjYXVzZSBmb3IgY3NoIGFuZCB0Y3NoICIhIiBpcyB1c2VkIGZvciBoaXN0b3J5IHJlcGxhY2VtZW50CgkJZXZlbiB3aGVuIGluc2lkZSBzaW5nbGUgcXVvdGVzLgoJCVRoZSA8Tkw+IGNoYXJhY3RlciBpcyBhbHNvIGVzY2FwZWQuICBXaXRoIGEgfG5vbi16ZXJvLWFyZ3wKCQl7c3BlY2lhbH0gYW5kICdzaGVsbCcgY29udGFpbmluZyAiY3NoIiBpbiB0aGUgdGFpbCBpdCdzCgkJZXNjYXBlZCBhIHNlY29uZCB0aW1lLgoJCUV4YW1wbGUgb2YgdXNlIHdpdGggYSB8OiF8IGNvbW1hbmQ6ID4KCQkgICAgOmV4ZSAnIWRpciAnIC4gc2hlbGxlc2NhcGUoZXhwYW5kKCc8Y2ZpbGU+JyksIDEpCjwJCVRoaXMgcmVzdWx0cyBpbiBhIGRpcmVjdG9yeSBsaXN0aW5nIGZvciB0aGUgZmlsZSB1bmRlciB0aGUKCQljdXJzb3IuICBFeGFtcGxlIG9mIHVzZSB3aXRoIHxzeXN0ZW0oKXw6ID4KCQkgICAgOmNhbGwgc3lzdGVtKCJjaG1vZCArdyAtLSAiIC4gc2hlbGxlc2NhcGUoZXhwYW5kKCIlIikpKQo8CQlTZWUgYWxzbyB8OjpTfC4KCgpzaGlmdHdpZHRoKCkJCQkJCQkqc2hpZnR3aWR0aCgpKgoJCVJldHVybnMgdGhlIGVmZmVjdGl2ZSB2YWx1ZSBvZiAnc2hpZnR3aWR0aCcuIFRoaXMgaXMgdGhlCgkJJ3NoaWZ0d2lkdGgnIHZhbHVlIHVubGVzcyBpdCBpcyB6ZXJvLCBpbiB3aGljaCBjYXNlIGl0IGlzIHRoZQoJCSd0YWJzdG9wJyB2YWx1ZS4gIFRoaXMgZnVuY3Rpb24gd2FzIGludHJvZHVjZWQgd2l0aCBwYXRjaAoJCTcuMy42OTQgaW4gMjAxMiwgZXZlcnlib2R5IHNob3VsZCBoYXZlIGl0IGJ5IG5vdy4KCgpzaW1wbGlmeSh7ZmlsZW5hbWV9KQkJCQkJKnNpbXBsaWZ5KCkqCgkJU2ltcGxpZnkgdGhlIGZpbGUgbmFtZSBhcyBtdWNoIGFzIHBvc3NpYmxlIHdpdGhvdXQgY2hhbmdpbmcKCQl0aGUgbWVhbmluZy4gIFNob3J0Y3V0cyAob24gTVMtV2luZG93cykgb3Igc3ltYm9saWMgbGlua3MgKG9uCgkJVW5peCkgYXJlIG5vdCByZXNvbHZlZC4gIElmIHRoZSBmaXJzdCBwYXRoIGNvbXBvbmVudCBpbgoJCXtmaWxlbmFtZX0gZGVzaWduYXRlcyB0aGUgY3VycmVudCBkaXJlY3RvcnksIHRoaXMgd2lsbCBiZQoJCXZhbGlkIGZvciB0aGUgcmVzdWx0IGFzIHdlbGwuICBBIHRyYWlsaW5nIHBhdGggc2VwYXJhdG9yIGlzCgkJbm90IHJlbW92ZWQgZWl0aGVyLgoJCUV4YW1wbGU6ID4KCQkJc2ltcGxpZnkoIi4vZGlyLy4uLy4vL2ZpbGUvIikgPT0gIi4vZmlsZS8iCjwJCU5vdGU6IFRoZSBjb21iaW5hdGlvbiAiZGlyLy4uIiBpcyBvbmx5IHJlbW92ZWQgaWYgImRpciIgaXMKCQlhIHNlYXJjaGFibGUgZGlyZWN0b3J5IG9yIGRvZXMgbm90IGV4aXN0LiAgT24gVW5peCwgaXQgaXMgYWxzbwoJCXJlbW92ZWQgd2hlbiAiZGlyIiBpcyBhIHN5bWJvbGljIGxpbmsgd2l0aGluIHRoZSBzYW1lCgkJZGlyZWN0b3J5LiAgSW4gb3JkZXIgdG8gcmVzb2x2ZSBhbGwgdGhlIGludm9sdmVkIHN5bWJvbGljCgkJbGlua3MgYmVmb3JlIHNpbXBsaWZ5aW5nIHRoZSBwYXRoIG5hbWUsIHVzZSB8cmVzb2x2ZSgpfC4KCgpzaW4oe2V4cHJ9KQkJCQkJCSpzaW4oKSoKCQlSZXR1cm4gdGhlIHNpbmUgb2Yge2V4cHJ9LCBtZWFzdXJlZCBpbiByYWRpYW5zLCBhcyBhIHxGbG9hdHwuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gc2luKDEwMCkKPAkJCS0wLjUwNjM2NiA+CgkJCTplY2hvIHNpbigtNC4wMSkKPAkJCTAuNzYzMzAxCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKCnNpbmgoe2V4cHJ9KQkJCQkJCSpzaW5oKCkqCgkJUmV0dXJuIHRoZSBoeXBlcmJvbGljIHNpbmUgb2Yge2V4cHJ9IGFzIGEgfEZsb2F0fCBpbiB0aGUgcmFuZ2UKCQlbLWluZiwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBzaW5oKDAuNSkKPAkJCTAuNTIxMDk1ID4KCQkJOmVjaG8gc2luaCgtMC45KQo8CQkJLTEuMDI2NTE3CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpzb3J0KHtsaXN0fSBbLCB7ZnVuY30gWywge2RpY3R9XV0pCQkJKnNvcnQoKSogKkU3MDIqCgkJU29ydCB0aGUgaXRlbXMgaW4ge2xpc3R9IGluLXBsYWNlLiAgUmV0dXJucyB7bGlzdH0uCgkJCgkJSWYgeW91IHdhbnQgYSBsaXN0IHRvIHJlbWFpbiB1bm1vZGlmaWVkIG1ha2UgYSBjb3B5IGZpcnN0OiA+CgkJCTpsZXQgc29ydGVkbGlzdCA9IHNvcnQoY29weShteWxpc3QpKQoKPAkJV2hlbiB7ZnVuY30gaXMgb21pdHRlZCwgaXMgZW1wdHkgb3IgemVybywgdGhlbiBzb3J0KCkgdXNlcyB0aGUKCQlzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgZWFjaCBpdGVtIHRvIHNvcnQgb24uICBOdW1iZXJzIHNvcnQKCQlhZnRlciBTdHJpbmdzLCB8TGlzdHN8IGFmdGVyIE51bWJlcnMuICBGb3Igc29ydGluZyB0ZXh0IGluIHRoZQoJCWN1cnJlbnQgYnVmZmVyIHVzZSB8OnNvcnR8LgoKCQlXaGVuIHtmdW5jfSBpcyBnaXZlbiBhbmQgaXQgaXMgJzEnIG9yICdpJyB0aGVuIGNhc2UgaXMKCQlpZ25vcmVkLgoJCQoJCVdoZW4ge2Z1bmN9IGlzIGdpdmVuIGFuZCBpdCBpcyAnbicgdGhlbiBhbGwgaXRlbXMgd2lsbCBiZQoJCXNvcnRlZCBudW1lcmljYWwgKEltcGxlbWVudGF0aW9uIGRldGFpbDogVGhpcyB1c2VzIHRoZQoJCXN0cnRvZCgpIGZ1bmN0aW9uIHRvIHBhcnNlIG51bWJlcnMsIFN0cmluZ3MsIExpc3RzLCBEaWN0cyBhbmQKCQlGdW5jcmVmcyB3aWxsIGJlIGNvbnNpZGVyZWQgYXMgYmVpbmcgMCkuCgoJCVdoZW4ge2Z1bmN9IGlzIGdpdmVuIGFuZCBpdCBpcyAnTicgdGhlbiBhbGwgaXRlbXMgd2lsbCBiZQoJCXNvcnRlZCBudW1lcmljYWwuIFRoaXMgaXMgbGlrZSAnbicgYnV0IGEgc3RyaW5nIGNvbnRhaW5pbmcKCQlkaWdpdHMgd2lsbCBiZSB1c2VkIGFzIHRoZSBudW1iZXIgdGhleSByZXByZXNlbnQuCgoJCVdoZW4ge2Z1bmN9IGlzIGdpdmVuIGFuZCBpdCBpcyAnZicgdGhlbiBhbGwgaXRlbXMgd2lsbCBiZQoJCXNvcnRlZCBudW1lcmljYWwuIEFsbCB2YWx1ZXMgbXVzdCBiZSBhIE51bWJlciBvciBhIEZsb2F0LgoKCQlXaGVuIHtmdW5jfSBpcyBhIHxGdW5jcmVmfCBvciBhIGZ1bmN0aW9uIG5hbWUsIHRoaXMgZnVuY3Rpb24KCQlpcyBjYWxsZWQgdG8gY29tcGFyZSBpdGVtcy4gIFRoZSBmdW5jdGlvbiBpcyBpbnZva2VkIHdpdGggdHdvCgkJaXRlbXMgYXMgYXJndW1lbnQgYW5kIG11c3QgcmV0dXJuIHplcm8gaWYgdGhleSBhcmUgZXF1YWwsIDEgb3IKCQliaWdnZXIgaWYgdGhlIGZpcnN0IG9uZSBzb3J0cyBhZnRlciB0aGUgc2Vjb25kIG9uZSwgLTEgb3IKCQlzbWFsbGVyIGlmIHRoZSBmaXJzdCBvbmUgc29ydHMgYmVmb3JlIHRoZSBzZWNvbmQgb25lLgoKCQl7ZGljdH0gaXMgZm9yIGZ1bmN0aW9ucyB3aXRoIHRoZSAiZGljdCIgYXR0cmlidXRlLiAgSXQgd2lsbCBiZQoJCXVzZWQgdG8gc2V0IHRoZSBsb2NhbCB2YXJpYWJsZSAic2VsZiIuIHxEaWN0aW9uYXJ5LWZ1bmN0aW9ufAoKCQlUaGUgc29ydCBpcyBzdGFibGUsIGl0ZW1zIHdoaWNoIGNvbXBhcmUgZXF1YWwgKGFzIG51bWJlciBvciBhcwoJCXN0cmluZykgd2lsbCBrZWVwIHRoZWlyIHJlbGF0aXZlIHBvc2l0aW9uLiBFLmcuLCB3aGVuIHNvcnRpbmcKCQlvbiBudW1iZXJzLCB0ZXh0IHN0cmluZ3Mgd2lsbCBzb3J0IG5leHQgdG8gZWFjaCBvdGhlciwgaW4gdGhlCgkJc2FtZSBvcmRlciBhcyB0aGV5IHdlcmUgb3JpZ2luYWxseS4KCgkJQWxzbyBzZWUgfHVuaXEoKXwuCgoJCUV4YW1wbGU6ID4KCQkJZnVuYyBNeUNvbXBhcmUoaTEsIGkyKQoJCQkgICByZXR1cm4gYTppMSA9PSBhOmkyID8gMCA6IGE6aTEgPiBhOmkyID8gMSA6IC0xCgkJCWVuZGZ1bmMKCQkJbGV0IHNvcnRlZGxpc3QgPSBzb3J0KG15bGlzdCwgIk15Q29tcGFyZSIpCjwJCUEgc2hvcnRlciBjb21wYXJlIHZlcnNpb24gZm9yIHRoaXMgc3BlY2lmaWMgc2ltcGxlIGNhc2UsIHdoaWNoCgkJaWdub3JlcyBvdmVyZmxvdzogPgoJCQlmdW5jIE15Q29tcGFyZShpMSwgaTIpCgkJCSAgIHJldHVybiBhOmkxIC0gYTppMgoJCQllbmRmdW5jCjwKCQkJCQkJCSpzb3VuZGZvbGQoKSoKc291bmRmb2xkKHt3b3JkfSkKCQlSZXR1cm4gdGhlIHNvdW5kLWZvbGRlZCBlcXVpdmFsZW50IG9mIHt3b3JkfS4gIFVzZXMgdGhlIGZpcnN0CgkJbGFuZ3VhZ2UgaW4gJ3NwZWxsbGFuZycgZm9yIHRoZSBjdXJyZW50IHdpbmRvdyB0aGF0IHN1cHBvcnRzCgkJc291bmRmb2xkaW5nLiAgJ3NwZWxsJyBtdXN0IGJlIHNldC4gIFdoZW4gbm8gc291bmQgZm9sZGluZyBpcwoJCXBvc3NpYmxlIHRoZSB7d29yZH0gaXMgcmV0dXJuZWQgdW5tb2RpZmllZC4KCQlUaGlzIGNhbiBiZSB1c2VkIGZvciBtYWtpbmcgc3BlbGxpbmcgc3VnZ2VzdGlvbnMuICBOb3RlIHRoYXQKCQl0aGUgbWV0aG9kIGNhbiBiZSBxdWl0ZSBzbG93LgoKCQkJCQkJCSpzcGVsbGJhZHdvcmQoKSoKc3BlbGxiYWR3b3JkKFt7c2VudGVuY2V9XSkKCQlXaXRob3V0IGFyZ3VtZW50OiBUaGUgcmVzdWx0IGlzIHRoZSBiYWRseSBzcGVsbGVkIHdvcmQgdW5kZXIKCQlvciBhZnRlciB0aGUgY3Vyc29yLiAgVGhlIGN1cnNvciBpcyBtb3ZlZCB0byB0aGUgc3RhcnQgb2YgdGhlCgkJYmFkIHdvcmQuICBXaGVuIG5vIGJhZCB3b3JkIGlzIGZvdW5kIGluIHRoZSBjdXJzb3IgbGluZSB0aGUKCQlyZXN1bHQgaXMgYW4gZW1wdHkgc3RyaW5nIGFuZCB0aGUgY3Vyc29yIGRvZXNuJ3QgbW92ZS4KCgkJV2l0aCBhcmd1bWVudDogVGhlIHJlc3VsdCBpcyB0aGUgZmlyc3Qgd29yZCBpbiB7c2VudGVuY2V9IHRoYXQKCQlpcyBiYWRseSBzcGVsbGVkLiAgSWYgdGhlcmUgYXJlIG5vIHNwZWxsaW5nIG1pc3Rha2VzIHRoZQoJCXJlc3VsdCBpcyBhbiBlbXB0eSBzdHJpbmcuCgoJCVRoZSByZXR1cm4gdmFsdWUgaXMgYSBsaXN0IHdpdGggdHdvIGl0ZW1zOgoJCS0gVGhlIGJhZGx5IHNwZWxsZWQgd29yZCBvciBhbiBlbXB0eSBzdHJpbmcuCgkJLSBUaGUgdHlwZSBvZiB0aGUgc3BlbGxpbmcgZXJyb3I6CgkJCSJiYWQiCQlzcGVsbGluZyBtaXN0YWtlCgkJCSJyYXJlIgkJcmFyZSB3b3JkCgkJCSJsb2NhbCIJCXdvcmQgb25seSB2YWxpZCBpbiBhbm90aGVyIHJlZ2lvbgoJCQkiY2FwcyIJCXdvcmQgc2hvdWxkIHN0YXJ0IHdpdGggQ2FwaXRhbAoJCUV4YW1wbGU6ID4KCQkJZWNobyBzcGVsbGJhZHdvcmQoInRoZSBxdWlrIGJyb3duIGZveCIpCjwJCQlbJ3F1aWsnLCAnYmFkJ10gfgoKCQlUaGUgc3BlbGxpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50IHdpbmRvdyBpcyB1c2VkLiAgVGhlCgkJJ3NwZWxsJyBvcHRpb24gbXVzdCBiZSBzZXQgYW5kIHRoZSB2YWx1ZSBvZiAnc3BlbGxsYW5nJyBpcwoJCXVzZWQuCgoJCQkJCQkJKnNwZWxsc3VnZ2VzdCgpKgpzcGVsbHN1Z2dlc3Qoe3dvcmR9IFssIHttYXh9IFssIHtjYXBpdGFsfV1dKQoJCVJldHVybiBhIHxMaXN0fCB3aXRoIHNwZWxsaW5nIHN1Z2dlc3Rpb25zIHRvIHJlcGxhY2Uge3dvcmR9LgoJCVdoZW4ge21heH0gaXMgZ2l2ZW4gdXAgdG8gdGhpcyBudW1iZXIgb2Ygc3VnZ2VzdGlvbnMgYXJlCgkJcmV0dXJuZWQuICBPdGhlcndpc2UgdXAgdG8gMjUgc3VnZ2VzdGlvbnMgYXJlIHJldHVybmVkLgoKCQlXaGVuIHRoZSB7Y2FwaXRhbH0gYXJndW1lbnQgaXMgZ2l2ZW4gYW5kIGl0J3Mgbm9uLXplcm8gb25seQoJCXN1Z2dlc3Rpb25zIHdpdGggYSBsZWFkaW5nIGNhcGl0YWwgd2lsbCBiZSBnaXZlbi4gIFVzZSB0aGlzCgkJYWZ0ZXIgYSBtYXRjaCB3aXRoICdzcGVsbGNhcGNoZWNrJy4KCgkJe3dvcmR9IGNhbiBiZSBhIGJhZGx5IHNwZWxsZWQgd29yZCBmb2xsb3dlZCBieSBvdGhlciB0ZXh0LgoJCVRoaXMgYWxsb3dzIGZvciBqb2luaW5nIHR3byB3b3JkcyB0aGF0IHdlcmUgc3BsaXQuICBUaGUKCQlzdWdnZXN0aW9ucyBhbHNvIGluY2x1ZGUgdGhlIGZvbGxvd2luZyB0ZXh0LCB0aHVzIHlvdSBjYW4KCQlyZXBsYWNlIGEgbGluZS4KCgkJe3dvcmR9IG1heSBhbHNvIGJlIGEgZ29vZCB3b3JkLiAgU2ltaWxhciB3b3JkcyB3aWxsIHRoZW4gYmUKCQlyZXR1cm5lZC4gIHt3b3JkfSBpdHNlbGYgaXMgbm90IGluY2x1ZGVkIGluIHRoZSBzdWdnZXN0aW9ucywKCQlhbHRob3VnaCBpdCBtYXkgYXBwZWFyIGNhcGl0YWxpemVkLgoKCQlUaGUgc3BlbGxpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50IHdpbmRvdyBpcyB1c2VkLiAgVGhlCgkJJ3NwZWxsJyBvcHRpb24gbXVzdCBiZSBzZXQgYW5kIHRoZSB2YWx1ZXMgb2YgJ3NwZWxsbGFuZycgYW5kCgkJJ3NwZWxsc3VnZ2VzdCcgYXJlIHVzZWQuCgoKc3BsaXQoe2V4cHJ9IFssIHtwYXR0ZXJufSBbLCB7a2VlcGVtcHR5fV1dKQkJCSpzcGxpdCgpKgoJCU1ha2UgYSB8TGlzdHwgb3V0IG9mIHtleHByfS4gIFdoZW4ge3BhdHRlcm59IGlzIG9taXR0ZWQgb3IKCQllbXB0eSBlYWNoIHdoaXRlLXNlcGFyYXRlZCBzZXF1ZW5jZSBvZiBjaGFyYWN0ZXJzIGJlY29tZXMgYW4KCQlpdGVtLgoJCU90aGVyd2lzZSB0aGUgc3RyaW5nIGlzIHNwbGl0IHdoZXJlIHtwYXR0ZXJufSBtYXRjaGVzLAoJCXJlbW92aW5nIHRoZSBtYXRjaGVkIGNoYXJhY3RlcnMuICdpZ25vcmVjYXNlJyBpcyBub3QgdXNlZAoJCWhlcmUsIGFkZCBcYyB0byBpZ25vcmUgY2FzZS4gfC9cY3wKCQlXaGVuIHRoZSBmaXJzdCBvciBsYXN0IGl0ZW0gaXMgZW1wdHkgaXQgaXMgb21pdHRlZCwgdW5sZXNzIHRoZQoJCXtrZWVwZW1wdHl9IGFyZ3VtZW50IGlzIGdpdmVuIGFuZCBpdCdzIG5vbi16ZXJvLgoJCU90aGVyIGVtcHR5IGl0ZW1zIGFyZSBrZXB0IHdoZW4ge3BhdHRlcm59IG1hdGNoZXMgYXQgbGVhc3Qgb25lCgkJY2hhcmFjdGVyIG9yIHdoZW4ge2tlZXBlbXB0eX0gaXMgbm9uLXplcm8uCgkJRXhhbXBsZTogPgoJCQk6bGV0IHdvcmRzID0gc3BsaXQoZ2V0bGluZSgnLicpLCAnXFdcKycpCjwJCVRvIHNwbGl0IGEgc3RyaW5nIGluIGluZGl2aWR1YWwgY2hhcmFjdGVyczogPgoJCQk6Zm9yIGMgaW4gc3BsaXQobXlzdHJpbmcsICdcenMnKQo8CQlJZiB5b3Ugd2FudCB0byBrZWVwIHRoZSBzZXBhcmF0b3IgeW91IGNhbiBhbHNvIHVzZSAnXHpzJyBhdAoJCXRoZSBlbmQgb2YgdGhlIHBhdHRlcm46ID4KCQkJOmVjaG8gc3BsaXQoJ2FiYzpkZWY6Z2hpJywgJzpcenMnKQo8CQkJWydhYmM6JywgJ2RlZjonLCAnZ2hpJ10gfgoJCVNwbGl0dGluZyBhIHRhYmxlIHdoZXJlIHRoZSBmaXJzdCBlbGVtZW50IGNhbiBiZSBlbXB0eTogPgoJCQk6bGV0IGl0ZW1zID0gc3BsaXQobGluZSwgJzonLCAxKQo8CQlUaGUgb3Bwb3NpdGUgZnVuY3Rpb24gaXMgfGpvaW4oKXwuCgoKc3FydCh7ZXhwcn0pCQkJCQkJKnNxcnQoKSoKCQlSZXR1cm4gdGhlIG5vbi1uZWdhdGl2ZSBzcXVhcmUgcm9vdCBvZiBGbG9hdCB7ZXhwcn0gYXMgYQoJCXxGbG9hdHwuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuICBXaGVuIHtleHByfQoJCWlzIG5lZ2F0aXZlIHRoZSByZXN1bHQgaXMgTmFOIChOb3QgYSBOdW1iZXIpLgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIHNxcnQoMTAwKQo8CQkJMTAuMCA+CgkJCTplY2hvIHNxcnQoLTQuMDEpCjwJCQluYW4KCQkibmFuIiBtYXkgYmUgZGlmZmVyZW50LCBpdCBkZXBlbmRzIG9uIHN5c3RlbSBsaWJyYXJpZXMuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKCnN0cjJmbG9hdCh7ZXhwcn0pCQkJCQkqc3RyMmZsb2F0KCkqCgkJQ29udmVydCBTdHJpbmcge2V4cHJ9IHRvIGEgRmxvYXQuICBUaGlzIG1vc3RseSB3b3JrcyB0aGUgc2FtZQoJCWFzIHdoZW4gdXNpbmcgYSBmbG9hdGluZyBwb2ludCBudW1iZXIgaW4gYW4gZXhwcmVzc2lvbiwgc2VlCgkJfGZsb2F0aW5nLXBvaW50LWZvcm1hdHwuICBCdXQgaXQncyBhIGJpdCBtb3JlIHBlcm1pc3NpdmUuCgkJRS5nLiwgIjFlNDAiIGlzIGFjY2VwdGVkLCB3aGlsZSBpbiBhbiBleHByZXNzaW9uIHlvdSBuZWVkIHRvCgkJd3JpdGUgIjEuMGU0MCIuCgkJVGV4dCBhZnRlciB0aGUgbnVtYmVyIGlzIHNpbGVudGx5IGlnbm9yZWQuCgkJVGhlIGRlY2ltYWwgcG9pbnQgaXMgYWx3YXlzICcuJywgbm8gbWF0dGVyIHdoYXQgdGhlIGxvY2FsZSBpcwoJCXNldCB0by4gIEEgY29tbWEgZW5kcyB0aGUgbnVtYmVyOiAiMTIsMzQ1LjY3IiBpcyBjb252ZXJ0ZWQgdG8KCQkxMi4wLiAgWW91IGNhbiBzdHJpcCBvdXQgdGhvdXNhbmRzIHNlcGFyYXRvcnMgd2l0aAoJCXxzdWJzdGl0dXRlKCl8OiA+CgkJCWxldCBmID0gc3RyMmZsb2F0KHN1YnN0aXR1dGUodGV4dCwgJywnLCAnJywgJ2cnKSkKPAkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpzdHIybnIoe2V4cHJ9IFssIHtiYXNlfV0pCQkJCSpzdHIybnIoKSoKCQlDb252ZXJ0IHN0cmluZyB7ZXhwcn0gdG8gYSBudW1iZXIuCgkJe2Jhc2V9IGlzIHRoZSBjb252ZXJzaW9uIGJhc2UsIGl0IGNhbiBiZSAyLCA4LCAxMCBvciAxNi4KCQlXaGVuIHtiYXNlfSBpcyBvbWl0dGVkIGJhc2UgMTAgaXMgdXNlZC4gIFRoaXMgYWxzbyBtZWFucyB0aGF0CgkJYSBsZWFkaW5nIHplcm8gZG9lc24ndCBjYXVzZSBvY3RhbCBjb252ZXJzaW9uIHRvIGJlIHVzZWQsIGFzCgkJd2l0aCB0aGUgZGVmYXVsdCBTdHJpbmcgdG8gTnVtYmVyIGNvbnZlcnNpb24uCgkJV2hlbiB7YmFzZX0gaXMgMTYgYSBsZWFkaW5nICIweCIgb3IgIjBYIiBpcyBpZ25vcmVkLiAgV2l0aCBhCgkJZGlmZmVyZW50IGJhc2UgdGhlIHJlc3VsdCB3aWxsIGJlIHplcm8uICBTaW1pbGFybHksIHdoZW4KCQl7YmFzZX0gaXMgOCBhIGxlYWRpbmcgIjAiIGlzIGlnbm9yZWQsIGFuZCB3aGVuIHtiYXNlfSBpcyAyIGEKCQlsZWFkaW5nICIwYiIgb3IgIjBCIiBpcyBpZ25vcmVkLgoJCVRleHQgYWZ0ZXIgdGhlIG51bWJlciBpcyBzaWxlbnRseSBpZ25vcmVkLgoKCnN0cmNoYXJzKHtleHByfSBbLCB7c2tpcGNjfV0pCQkJCQkqc3RyY2hhcnMoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMKCQlpbiBTdHJpbmcge2V4cHJ9LgoJCVdoZW4ge3NraXBjY30gaXMgb21pdHRlZCBvciB6ZXJvLCBjb21wb3NpbmcgY2hhcmFjdGVycyBhcmUKCQljb3VudGVkIHNlcGFyYXRlbHkuCgkJV2hlbiB7c2tpcGNjfSBzZXQgdG8gMSwgQ29tcG9zaW5nIGNoYXJhY3RlcnMgYXJlIGlnbm9yZWQuCgkJQWxzbyBzZWUgfHN0cmxlbigpfCwgfHN0cmRpc3BsYXl3aWR0aCgpfCBhbmQgfHN0cndpZHRoKCl8LgoJCQoJCXtza2lwY2N9IGlzIG9ubHkgYXZhaWxhYmxlIGFmdGVyIDcuNC43NTUuICBGb3IgYmFja3dhcmQKCQljb21wYXRpYmlsaXR5LCB5b3UgY2FuIGRlZmluZSBhIHdyYXBwZXIgZnVuY3Rpb246ID4KCQkgICAgaWYgaGFzKCJwYXRjaC03LjQuNzU1IikKCQkgICAgICBmdW5jdGlvbiBzOnN0cmNoYXJzKHN0ciwgc2tpcGNjKQoJCQlyZXR1cm4gc3RyY2hhcnMoYTpzdHIsIGE6c2tpcGNjKQoJCSAgICAgIGVuZGZ1bmN0aW9uCgkJICAgIGVsc2UKCQkgICAgICBmdW5jdGlvbiBzOnN0cmNoYXJzKHN0ciwgc2tpcGNjKQoJCQlpZiBhOnNraXBjYwoJCQkgIHJldHVybiBzdHJsZW4oc3Vic3RpdHV0ZShhOnN0ciwgIi4iLCAieCIsICJnIikpCgkJCWVsc2UKCQkJICByZXR1cm4gc3RyY2hhcnMoYTpzdHIpCgkJCWVuZGlmCgkJICAgICAgZW5kZnVuY3Rpb24KCQkgICAgZW5kaWYKPApzdHJjaGFycGFydCh7c3JjfSwge3N0YXJ0fVssIHtsZW59XSkJCQkqc3RyY2hhcnBhcnQoKSoKCQlMaWtlIHxzdHJwYXJ0KCl8IGJ1dCB1c2luZyBjaGFyYWN0ZXIgaW5kZXggYW5kIGxlbmd0aCBpbnN0ZWFkCgkJb2YgYnl0ZSBpbmRleCBhbmQgbGVuZ3RoLgoJCVdoZW4gYSBjaGFyYWN0ZXIgaW5kZXggaXMgdXNlZCB3aGVyZSBhIGNoYXJhY3RlciBkb2VzIG5vdAoJCWV4aXN0IGl0IGlzIGFzc3VtZWQgdG8gYmUgb25lIGJ5dGUuICBGb3IgZXhhbXBsZTogPgoJCQlzdHJjaGFycGFydCgnYWJjJywgLTEsIDIpCjwJCXJlc3VsdHMgaW4gJ2EnLgoKc3RyZGlzcGxheXdpZHRoKHtleHByfVssIHtjb2x9XSkJCQkqc3RyZGlzcGxheXdpZHRoKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIG51bWJlciBvZiBkaXNwbGF5IGNlbGxzCgkJU3RyaW5nIHtleHByfSBvY2N1cGllcyBvbiB0aGUgc2NyZWVuIHdoZW4gaXQgc3RhcnRzIGF0IHtjb2x9LgoJCVdoZW4ge2NvbH0gaXMgb21pdHRlZCB6ZXJvIGlzIHVzZWQuICBPdGhlcndpc2UgaXQgaXMgdGhlCgkJc2NyZWVuIGNvbHVtbiB3aGVyZSB0byBzdGFydC4gIFRoaXMgbWF0dGVycyBmb3IgVGFiCgkJY2hhcmFjdGVycy4KCQlUaGUgb3B0aW9uIHNldHRpbmdzIG9mIHRoZSBjdXJyZW50IHdpbmRvdyBhcmUgdXNlZC4gIFRoaXMKCQltYXR0ZXJzIGZvciBhbnl0aGluZyB0aGF0J3MgZGlzcGxheWVkIGRpZmZlcmVudGx5LCBzdWNoIGFzCgkJJ3RhYnN0b3AnIGFuZCAnZGlzcGxheScuCgkJV2hlbiB7ZXhwcn0gY29udGFpbnMgY2hhcmFjdGVycyB3aXRoIEVhc3QgQXNpYW4gV2lkdGggQ2xhc3MKCQlBbWJpZ3VvdXMsIHRoaXMgZnVuY3Rpb24ncyByZXR1cm4gdmFsdWUgZGVwZW5kcyBvbiAnYW1iaXdpZHRoJy4KCQlBbHNvIHNlZSB8c3RybGVuKCl8LCB8c3Ryd2lkdGgoKXwgYW5kIHxzdHJjaGFycygpfC4KCnN0cmZ0aW1lKHtmb3JtYXR9IFssIHt0aW1lfV0pCQkJCSpzdHJmdGltZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIGEgZm9ybWF0dGVkIGRhdGUgYW5kIHRpbWUsIGFzCgkJc3BlY2lmaWVkIGJ5IHRoZSB7Zm9ybWF0fSBzdHJpbmcuICBUaGUgZ2l2ZW4ge3RpbWV9IGlzIHVzZWQsCgkJb3IgdGhlIGN1cnJlbnQgdGltZSBpZiBubyB0aW1lIGlzIGdpdmVuLiAgVGhlIGFjY2VwdGVkCgkJe2Zvcm1hdH0gZGVwZW5kcyBvbiB5b3VyIHN5c3RlbSwgdGh1cyB0aGlzIGlzIG5vdCBwb3J0YWJsZSEKCQlTZWUgdGhlIG1hbnVhbCBwYWdlIG9mIHRoZSBDIGZ1bmN0aW9uIHN0cmZ0aW1lKCkgZm9yIHRoZQoJCWZvcm1hdC4gIFRoZSBtYXhpbXVtIGxlbmd0aCBvZiB0aGUgcmVzdWx0IGlzIDgwIGNoYXJhY3RlcnMuCgkJU2VlIGFsc28gfGxvY2FsdGltZSgpfCBhbmQgfGdldGZ0aW1lKCl8LgoJCVRoZSBsYW5ndWFnZSBjYW4gYmUgY2hhbmdlZCB3aXRoIHRoZSB8Omxhbmd1YWdlfCBjb21tYW5kLgoJCUV4YW1wbGVzOiA+CgkJICA6ZWNobyBzdHJmdGltZSgiJWMiKQkJICAgU3VuIEFwciAyNyAxMTo0OToyMyAxOTk3CgkJICA6ZWNobyBzdHJmdGltZSgiJVkgJWIgJWQgJVgiKQkgICAxOTk3IEFwciAyNyAxMTo1MzoyNQoJCSAgOmVjaG8gc3RyZnRpbWUoIiV5JW0lZCAlVCIpCSAgIDk3MDQyNyAxMTo1Mzo1NQoJCSAgOmVjaG8gc3RyZnRpbWUoIiVIOiVNIikJICAgMTE6NTUKCQkgIDplY2hvIHN0cmZ0aW1lKCIlYyIsIGdldGZ0aW1lKCJmaWxlLmMiKSkKCQkJCQkJICAgU2hvdyBtb2QgdGltZSBvZiBmaWxlLmMuCjwJCU5vdCBhdmFpbGFibGUgb24gYWxsIHN5c3RlbXMuICBUbyBjaGVjayB1c2U6ID4KCQkJOmlmIGV4aXN0cygiKnN0cmZ0aW1lIikKCnN0cmdldGNoYXIoe3N0cn0sIHtpbmRleH0pCQkJCSpzdHJnZXRjaGFyKCkqCgkJR2V0IGNoYXJhY3RlciB7aW5kZXh9IGZyb20ge3N0cn0uICBUaGlzIHVzZXMgYSBjaGFyYWN0ZXIKCQlpbmRleCwgbm90IGEgYnl0ZSBpbmRleC4gIENvbXBvc2luZyBjaGFyYWN0ZXJzIGFyZSBjb25zaWRlcmVkCgkJc2VwYXJhdGUgY2hhcmFjdGVycyBoZXJlLgoJCUFsc28gc2VlIHxzdHJjaGFycGFydCgpfCBhbmQgfHN0cmNoYXJzKCl8LgoKc3RyaWR4KHtoYXlzdGFja30sIHtuZWVkbGV9IFssIHtzdGFydH1dKQkJKnN0cmlkeCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGdpdmVzIHRoZSBieXRlIGluZGV4IGluCgkJe2hheXN0YWNrfSBvZiB0aGUgZmlyc3Qgb2NjdXJyZW5jZSBvZiB0aGUgU3RyaW5nIHtuZWVkbGV9LgoJCUlmIHtzdGFydH0gaXMgc3BlY2lmaWVkLCB0aGUgc2VhcmNoIHN0YXJ0cyBhdCBpbmRleCB7c3RhcnR9LgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gZmluZCBhIHNlY29uZCBtYXRjaDogPgoJCQk6bGV0IGNvbG9uMSA9IHN0cmlkeChsaW5lLCAiOiIpCgkJCTpsZXQgY29sb24yID0gc3RyaWR4KGxpbmUsICI6IiwgY29sb24xICsgMSkKPAkJVGhlIHNlYXJjaCBpcyBkb25lIGNhc2Utc2Vuc2l0aXZlLgoJCUZvciBwYXR0ZXJuIHNlYXJjaGVzIHVzZSB8bWF0Y2goKXwuCgkJLTEgaXMgcmV0dXJuZWQgaWYgdGhlIHtuZWVkbGV9IGRvZXMgbm90IG9jY3VyIGluIHtoYXlzdGFja30uCgkJU2VlIGFsc28gfHN0cnJpZHgoKXwuCgkJRXhhbXBsZXM6ID4KCQkgIDplY2hvIHN0cmlkeCgiQW4gRXhhbXBsZSIsICJFeGFtcGxlIikJICAgICAzCgkJICA6ZWNobyBzdHJpZHgoIlN0YXJ0aW5nIHBvaW50IiwgIlN0YXJ0IikgICAgMAoJCSAgOmVjaG8gc3RyaWR4KCJTdGFydGluZyBwb2ludCIsICJzdGFydCIpICAgLTEKPAkJCQkJCSpzdHJzdHIoKSogKnN0cmNocigpKgoJCXN0cmlkeCgpIHdvcmtzIHNpbWlsYXIgdG8gdGhlIEMgZnVuY3Rpb24gc3Ryc3RyKCkuICBXaGVuIHVzZWQKCQl3aXRoIGEgc2luZ2xlIGNoYXJhY3RlciBpdCB3b3JrcyBzaW1pbGFyIHRvIHN0cmNocigpLgoKCQkJCQkJCSpzdHJpbmcoKSoKc3RyaW5nKHtleHByfSkJUmV0dXJuIHtleHByfSBjb252ZXJ0ZWQgdG8gYSBTdHJpbmcuICBJZiB7ZXhwcn0gaXMgYSBOdW1iZXIsCgkJRmxvYXQsIFN0cmluZyBvciBhIGNvbXBvc2l0aW9uIG9mIHRoZW0sIHRoZW4gdGhlIHJlc3VsdCBjYW4gYmUKCQlwYXJzZWQgYmFjayB3aXRoIHxldmFsKCl8LgoJCQl7ZXhwcn0gdHlwZQlyZXN1bHQgfgoJCQlTdHJpbmcJCSdzdHJpbmcnIChzaW5nbGUgcXVvdGVzIGFyZSBkb3VibGVkKQoJCQlOdW1iZXIJCTEyMwoJCQlGbG9hdAkJMTIzLjEyMzQ1NiBvciAxLjEyMzQ1NmU4CgkJCUZ1bmNyZWYJCWZ1bmN0aW9uKCduYW1lJykKCQkJTGlzdAkJW2l0ZW0sIGl0ZW1dCgkJCURpY3Rpb25hcnkJe2tleTogdmFsdWUsIGtleTogdmFsdWV9CgoJCVdoZW4gYSBMaXN0IG9yIERpY3Rpb25hcnkgaGFzIGEgcmVjdXJzaXZlIHJlZmVyZW5jZSBpdCBpcwoJCXJlcGxhY2VkIGJ5ICJbLi4uXSIgb3IgInsuLi59Ii4gIFVzaW5nIGV2YWwoKSBvbiB0aGUgcmVzdWx0CgkJd2lsbCB0aGVuIGZhaWwuCgoJCUFsc28gc2VlIHxzdHJ0cmFucygpfC4KCgkJCQkJCQkqc3RybGVuKCkqCnN0cmxlbih7ZXhwcn0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBsZW5ndGggb2YgdGhlIFN0cmluZwoJCXtleHByfSBpbiBieXRlcy4KCQlJZiB0aGUgYXJndW1lbnQgaXMgYSBOdW1iZXIgaXQgaXMgZmlyc3QgY29udmVydGVkIHRvIGEgU3RyaW5nLgoJCUZvciBvdGhlciB0eXBlcyBhbiBlcnJvciBpcyBnaXZlbi4KCQlJZiB5b3Ugd2FudCB0byBjb3VudCB0aGUgbnVtYmVyIG9mIG11bHRpLWJ5dGUgY2hhcmFjdGVycyB1c2UKCQl8c3RyY2hhcnMoKXwuCgkJQWxzbyBzZWUgfGxlbigpfCwgfHN0cmRpc3BsYXl3aWR0aCgpfCBhbmQgfHN0cndpZHRoKCl8LgoKc3RycGFydCh7c3JjfSwge3N0YXJ0fVssIHtsZW59XSkJCQkqc3RycGFydCgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHBhcnQgb2Yge3NyY30sIHN0YXJ0aW5nIGZyb20KCQlieXRlIHtzdGFydH0sIHdpdGggdGhlIGJ5dGUgbGVuZ3RoIHtsZW59LgoJCVRvIGNvdW50IGNoYXJhY3RlcnMgaW5zdGVhZCBvZiBieXRlcyB1c2UgfHN0cmNoYXJwYXJ0KCl8LgoKCQlXaGVuIGJ5dGVzIGFyZSBzZWxlY3RlZCB3aGljaCBkbyBub3QgZXhpc3QsIHRoaXMgZG9lc24ndAoJCXJlc3VsdCBpbiBhbiBlcnJvciwgdGhlIGJ5dGVzIGFyZSBzaW1wbHkgb21pdHRlZC4KCQlJZiB7bGVufSBpcyBtaXNzaW5nLCB0aGUgY29weSBjb250aW51ZXMgZnJvbSB7c3RhcnR9IHRpbGwgdGhlCgkJZW5kIG9mIHRoZSB7c3JjfS4gPgoJCQlzdHJwYXJ0KCJhYmNkZWZnIiwgMywgMikgICAgPT0gImRlIgoJCQlzdHJwYXJ0KCJhYmNkZWZnIiwgLTIsIDQpICAgPT0gImFiIgoJCQlzdHJwYXJ0KCJhYmNkZWZnIiwgNSwgNCkgICAgPT0gImZnIgoJCQlzdHJwYXJ0KCJhYmNkZWZnIiwgMykJICAgID09ICJkZWZnIgoKPAkJTm90ZTogVG8gZ2V0IHRoZSBmaXJzdCBjaGFyYWN0ZXIsIHtzdGFydH0gbXVzdCBiZSAwLiAgRm9yCgkJZXhhbXBsZSwgdG8gZ2V0IHRocmVlIGJ5dGVzIHVuZGVyIGFuZCBhZnRlciB0aGUgY3Vyc29yOiA+CgkJCXN0cnBhcnQoZ2V0bGluZSgiLiIpLCBjb2woIi4iKSAtIDEsIDMpCjwKc3RycmlkeCh7aGF5c3RhY2t9LCB7bmVlZGxlfSBbLCB7c3RhcnR9XSkJCQkqc3RycmlkeCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGdpdmVzIHRoZSBieXRlIGluZGV4IGluCgkJe2hheXN0YWNrfSBvZiB0aGUgbGFzdCBvY2N1cnJlbmNlIG9mIHRoZSBTdHJpbmcge25lZWRsZX0uCgkJV2hlbiB7c3RhcnR9IGlzIHNwZWNpZmllZCwgbWF0Y2hlcyBiZXlvbmQgdGhpcyBpbmRleCBhcmUKCQlpZ25vcmVkLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBmaW5kIGEgbWF0Y2ggYmVmb3JlIGEgcHJldmlvdXMKCQltYXRjaDogPgoJCQk6bGV0IGxhc3Rjb21tYSA9IHN0cnJpZHgobGluZSwgIiwiKQoJCQk6bGV0IGNvbW1hMiA9IHN0cnJpZHgobGluZSwgIiwiLCBsYXN0Y29tbWEgLSAxKQo8CQlUaGUgc2VhcmNoIGlzIGRvbmUgY2FzZS1zZW5zaXRpdmUuCgkJRm9yIHBhdHRlcm4gc2VhcmNoZXMgdXNlIHxtYXRjaCgpfC4KCQktMSBpcyByZXR1cm5lZCBpZiB0aGUge25lZWRsZX0gZG9lcyBub3Qgb2NjdXIgaW4ge2hheXN0YWNrfS4KCQlJZiB0aGUge25lZWRsZX0gaXMgZW1wdHkgdGhlIGxlbmd0aCBvZiB7aGF5c3RhY2t9IGlzIHJldHVybmVkLgoJCVNlZSBhbHNvIHxzdHJpZHgoKXwuICBFeGFtcGxlczogPgoJCSAgOmVjaG8gc3RycmlkeCgiYW4gYW5ncnkgYXJtYWRpbGxvIiwgImFuIikJICAgICAzCjwJCQkJCQkJKnN0cnJjaHIoKSoKCQlXaGVuIHVzZWQgd2l0aCBhIHNpbmdsZSBjaGFyYWN0ZXIgaXQgd29ya3Mgc2ltaWxhciB0byB0aGUgQwoJCWZ1bmN0aW9uIHN0cnJjaHIoKS4KCnN0cnRyYW5zKHtleHByfSkJCQkJCSpzdHJ0cmFucygpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHtleHByfSB3aXRoIGFsbCB1bnByaW50YWJsZQoJCWNoYXJhY3RlcnMgdHJhbnNsYXRlZCBpbnRvIHByaW50YWJsZSBjaGFyYWN0ZXJzIHwnaXNwcmludCd8LgoJCUxpa2UgdGhleSBhcmUgc2hvd24gaW4gYSB3aW5kb3cuICBFeGFtcGxlOiA+CgkJCWVjaG8gc3RydHJhbnMoQGEpCjwJCVRoaXMgZGlzcGxheXMgYSBuZXdsaW5lIGluIHJlZ2lzdGVyIGEgYXMgIl5AIiBpbnN0ZWFkIG9mCgkJc3RhcnRpbmcgYSBuZXcgbGluZS4KCnN0cndpZHRoKHtleHByfSkJCQkJCSpzdHJ3aWR0aCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgZGlzcGxheSBjZWxscwoJCVN0cmluZyB7ZXhwcn0gb2NjdXBpZXMuICBBIFRhYiBjaGFyYWN0ZXIgaXMgY291bnRlZCBhcyBvbmUKCQljZWxsLCBhbHRlcm5hdGl2ZWx5IHVzZSB8c3RyZGlzcGxheXdpZHRoKCl8LgoJCVdoZW4ge2V4cHJ9IGNvbnRhaW5zIGNoYXJhY3RlcnMgd2l0aCBFYXN0IEFzaWFuIFdpZHRoIENsYXNzCgkJQW1iaWd1b3VzLCB0aGlzIGZ1bmN0aW9uJ3MgcmV0dXJuIHZhbHVlIGRlcGVuZHMgb24gJ2FtYml3aWR0aCcuCgkJQWxzbyBzZWUgfHN0cmxlbigpfCwgfHN0cmRpc3BsYXl3aWR0aCgpfCBhbmQgfHN0cmNoYXJzKCl8LgoKc3VibWF0Y2goe25yfVssIHtsaXN0fV0pCQkJCSpzdWJtYXRjaCgpKgoJCU9ubHkgZm9yIGFuIGV4cHJlc3Npb24gaW4gYSB8OnN1YnN0aXR1dGV8IGNvbW1hbmQgb3IKCQlzdWJzdGl0dXRlKCkgZnVuY3Rpb24uCgkJUmV0dXJucyB0aGUge25yfSd0aCBzdWJtYXRjaCBvZiB0aGUgbWF0Y2hlZCB0ZXh0LiAgV2hlbiB7bnJ9CgkJaXMgMCB0aGUgd2hvbGUgbWF0Y2hlZCB0ZXh0IGlzIHJldHVybmVkLgoJCU5vdGUgdGhhdCBhIE5MIGluIHRoZSBzdHJpbmcgY2FuIHN0YW5kIGZvciBhIGxpbmUgYnJlYWsgb2YgYQoJCW11bHRpLWxpbmUgbWF0Y2ggb3IgYSBOVUwgY2hhcmFjdGVyIGluIHRoZSB0ZXh0LgoJCUFsc28gc2VlIHxzdWItcmVwbGFjZS1leHByZXNzaW9ufC4KCgkJSWYge2xpc3R9IGlzIHByZXNlbnQgYW5kIG5vbi16ZXJvIHRoZW4gc3VibWF0Y2goKSByZXR1cm5zIAoJCWEgbGlzdCBvZiBzdHJpbmdzLCBzaW1pbGFyIHRvIHxnZXRsaW5lKCl8IHdpdGggdHdvIGFyZ3VtZW50cy4gCgkJTkwgY2hhcmFjdGVycyBpbiB0aGUgdGV4dCByZXByZXNlbnQgTlVMIGNoYXJhY3RlcnMgaW4gdGhlCgkJdGV4dC4KCQlPbmx5IHJldHVybnMgbW9yZSB0aGFuIG9uZSBpdGVtIGZvciB8OnN1YnN0aXR1dGV8LCBpbnNpZGUKCQl8c3Vic3RpdHV0ZSgpfCB0aGlzIGxpc3Qgd2lsbCBhbHdheXMgY29udGFpbiBvbmUgb3IgemVybwoJCWl0ZW1zLCBzaW5jZSB0aGVyZSBhcmUgbm8gcmVhbCBsaW5lIGJyZWFrcy4KCgkJRXhhbXBsZTogPgoJCQk6cy9cZFwrL1w9c3VibWF0Y2goMCkgKyAxLwo8CQlUaGlzIGZpbmRzIHRoZSBmaXJzdCBudW1iZXIgaW4gdGhlIGxpbmUgYW5kIGFkZHMgb25lIHRvIGl0LgoJCUEgbGluZSBicmVhayBpcyBpbmNsdWRlZCBhcyBhIG5ld2xpbmUgY2hhcmFjdGVyLgoKc3Vic3RpdHV0ZSh7ZXhwcn0sIHtwYXR9LCB7c3VifSwge2ZsYWdzfSkJCSpzdWJzdGl0dXRlKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgYSBjb3B5IG9mIHtleHByfSwgaW4gd2hpY2gKCQl0aGUgZmlyc3QgbWF0Y2ggb2Yge3BhdH0gaXMgcmVwbGFjZWQgd2l0aCB7c3VifS4KCQlXaGVuIHtmbGFnc30gaXMgImciLCBhbGwgbWF0Y2hlcyBvZiB7cGF0fSBpbiB7ZXhwcn0gYXJlCgkJcmVwbGFjZWQuICBPdGhlcndpc2Uge2ZsYWdzfSBzaG91bGQgYmUgIiIuCgkJCgkJVGhpcyB3b3JrcyBsaWtlIHRoZSAiOnN1YnN0aXR1dGUiIGNvbW1hbmQgKHdpdGhvdXQgYW55IGZsYWdzKS4KCQlCdXQgdGhlIG1hdGNoaW5nIHdpdGgge3BhdH0gaXMgYWx3YXlzIGRvbmUgbGlrZSB0aGUgJ21hZ2ljJwoJCW9wdGlvbiBpcyBzZXQgYW5kICdjcG9wdGlvbnMnIGlzIGVtcHR5ICh0byBtYWtlIHNjcmlwdHMKCQlwb3J0YWJsZSkuICAnaWdub3JlY2FzZScgaXMgc3RpbGwgcmVsZXZhbnQsIHVzZSB8L1xjfCBvciB8L1xDfAoJCWlmIHlvdSB3YW50IHRvIGlnbm9yZSBvciBtYXRjaCBjYXNlIGFuZCBpZ25vcmUgJ2lnbm9yZWNhc2UnLgoJCSdzbWFydGNhc2UnIGlzIG5vdCB1c2VkLiAgU2VlIHxzdHJpbmctbWF0Y2h8IGZvciBob3cge3BhdH0gaXMKCQl1c2VkLgoKCQlBICJ+IiBpbiB7c3VifSBpcyBub3QgcmVwbGFjZWQgd2l0aCB0aGUgcHJldmlvdXMge3N1Yn0uCgkJTm90ZSB0aGF0IHNvbWUgY29kZXMgaW4ge3N1Yn0gaGF2ZSBhIHNwZWNpYWwgbWVhbmluZwoJCXxzdWItcmVwbGFjZS1zcGVjaWFsfC4JRm9yIGV4YW1wbGUsIHRvIHJlcGxhY2Ugc29tZXRoaW5nIHdpdGgKCQkiXG4iICh0d28gY2hhcmFjdGVycyksIHVzZSAiXFxcXG4iIG9yICdcXG4nLgoKCQlXaGVuIHtwYXR9IGRvZXMgbm90IG1hdGNoIGluIHtleHByfSwge2V4cHJ9IGlzIHJldHVybmVkCgkJdW5tb2RpZmllZC4KCgkJRXhhbXBsZTogPgoJCQk6bGV0ICZwYXRoID0gc3Vic3RpdHV0ZSgmcGF0aCwgIixcXD1bXixdKiQiLCAiIiwgIiIpCjwJCVRoaXMgcmVtb3ZlcyB0aGUgbGFzdCBjb21wb25lbnQgb2YgdGhlICdwYXRoJyBvcHRpb24uID4KCQkJOmVjaG8gc3Vic3RpdHV0ZSgidGVzdGluZyIsICIuKiIsICJcXFVcXDAiLCAiIikKPAkJcmVzdWx0cyBpbiAiVEVTVElORyIuCgoJCVdoZW4ge3N1Yn0gc3RhcnRzIHdpdGggIlw9IiwgdGhlIHJlbWFpbmRlciBpcyBpbnRlcnByZXRlZCBhcwoJCWFuIGV4cHJlc3Npb24uIFNlZSB8c3ViLXJlcGxhY2UtZXhwcmVzc2lvbnwuICBFeGFtcGxlOiA+CgkJCTplY2hvIHN1YnN0aXR1dGUocywgJyVcKFx4XHhcKScsCgkJCSAgIFwgJ1w9bnIyY2hhcigiMHgiIC4gc3VibWF0Y2goMSkpJywgJ2cnKQoKc3luSUQoe2xudW19LCB7Y29sfSwge3RyYW5zfSkJCQkJKnN5bklEKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIHN5bnRheCBJRCBhdCB0aGUgcG9zaXRpb24KCQl7bG51bX0gYW5kIHtjb2x9IGluIHRoZSBjdXJyZW50IHdpbmRvdy4KCQlUaGUgc3ludGF4IElEIGNhbiBiZSB1c2VkIHdpdGggfHN5bklEYXR0cigpfCBhbmQKCQl8c3luSUR0cmFucygpfCB0byBvYnRhaW4gc3ludGF4IGluZm9ybWF0aW9uIGFib3V0IHRleHQuCgoJCXtjb2x9IGlzIDEgZm9yIHRoZSBsZWZ0bW9zdCBjb2x1bW4sIHtsbnVtfSBpcyAxIGZvciB0aGUgZmlyc3QKCQlsaW5lLiAgJ3N5bm1heGNvbCcgYXBwbGllcywgaW4gYSBsb25nZXIgbGluZSB6ZXJvIGlzIHJldHVybmVkLgoJCU5vdGUgdGhhdCB3aGVuIHRoZSBwb3NpdGlvbiBpcyBhZnRlciB0aGUgbGFzdCBjaGFyYWN0ZXIsCgkJdGhhdCdzIHdoZXJlIHRoZSBjdXJzb3IgY2FuIGJlIGluIEluc2VydCBtb2RlLCBzeW5JRCgpIHJldHVybnMKCQl6ZXJvLgoKCQlXaGVuIHt0cmFuc30gaXMgbm9uLXplcm8sIHRyYW5zcGFyZW50IGl0ZW1zIGFyZSByZWR1Y2VkIHRvIHRoZQoJCWl0ZW0gdGhhdCB0aGV5IHJldmVhbC4JVGhpcyBpcyB1c2VmdWwgd2hlbiB3YW50aW5nIHRvIGtub3cKCQl0aGUgZWZmZWN0aXZlIGNvbG9yLiAgV2hlbiB7dHJhbnN9IGlzIHplcm8sIHRoZSB0cmFuc3BhcmVudAoJCWl0ZW0gaXMgcmV0dXJuZWQuICBUaGlzIGlzIHVzZWZ1bCB3aGVuIHdhbnRpbmcgdG8ga25vdyB3aGljaAoJCXN5bnRheCBpdGVtIGlzIGVmZmVjdGl2ZSAoZS5nLiBpbnNpZGUgcGFyZW5zKS4KCQlXYXJuaW5nOiBUaGlzIGZ1bmN0aW9uIGNhbiBiZSB2ZXJ5IHNsb3cuICBCZXN0IHNwZWVkIGlzCgkJb2J0YWluZWQgYnkgZ29pbmcgdGhyb3VnaCB0aGUgZmlsZSBpbiBmb3J3YXJkIGRpcmVjdGlvbi4KCgkJRXhhbXBsZSAoZWNob2VzIHRoZSBuYW1lIG9mIHRoZSBzeW50YXggaXRlbSB1bmRlciB0aGUgY3Vyc29yKTogPgoJCQk6ZWNobyBzeW5JRGF0dHIoc3luSUQobGluZSgiLiIpLCBjb2woIi4iKSwgMSksICJuYW1lIikKPAoKc3luSURhdHRyKHtzeW5JRH0sIHt3aGF0fSBbLCB7bW9kZX1dKQkJCSpzeW5JRGF0dHIoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUge3doYXR9IGF0dHJpYnV0ZSBvZgoJCXN5bnRheCBJRCB7c3luSUR9LiAgVGhpcyBjYW4gYmUgdXNlZCB0byBvYnRhaW4gaW5mb3JtYXRpb24KCQlhYm91dCBhIHN5bnRheCBpdGVtLgoJCXttb2RlfSBjYW4gYmUgImd1aSIsICJjdGVybSIgb3IgInRlcm0iLCB0byBnZXQgdGhlIGF0dHJpYnV0ZXMKCQlmb3IgdGhhdCBtb2RlLglXaGVuIHttb2RlfSBpcyBvbWl0dGVkLCBvciBhbiBpbnZhbGlkIHZhbHVlIGlzCgkJdXNlZCwgdGhlIGF0dHJpYnV0ZXMgZm9yIHRoZSBjdXJyZW50bHkgYWN0aXZlIGhpZ2hsaWdodGluZyBhcmUKCQl1c2VkIChHVUksIGN0ZXJtIG9yIHRlcm0pLgoJCVVzZSBzeW5JRHRyYW5zKCkgdG8gZm9sbG93IGxpbmtlZCBoaWdobGlnaHQgZ3JvdXBzLgoJCXt3aGF0fQkJcmVzdWx0CgkJIm5hbWUiCQl0aGUgbmFtZSBvZiB0aGUgc3ludGF4IGl0ZW0KCQkiZmciCQlmb3JlZ3JvdW5kIGNvbG9yIChHVUk6IGNvbG9yIG5hbWUgdXNlZCB0byBzZXQKCQkJCXRoZSBjb2xvciwgY3Rlcm06IGNvbG9yIG51bWJlciBhcyBhIHN0cmluZywKCQkJCXRlcm06IGVtcHR5IHN0cmluZykKCQkiYmciCQliYWNrZ3JvdW5kIGNvbG9yIChhcyB3aXRoICJmZyIpCgkJImZvbnQiCQlmb250IG5hbWUgKG9ubHkgYXZhaWxhYmxlIGluIHRoZSBHVUkpCgkJCQl8aGlnaGxpZ2h0LWZvbnR8CgkJInNwIgkJc3BlY2lhbCBjb2xvciAoYXMgd2l0aCAiZmciKSB8aGlnaGxpZ2h0LWd1aXNwfAoJCSJmZyMiCQlsaWtlICJmZyIsIGJ1dCBmb3IgdGhlIEdVSSBhbmQgdGhlIEdVSSBpcwoJCQkJcnVubmluZyB0aGUgbmFtZSBpbiAiI1JSR0dCQiIgZm9ybQoJCSJiZyMiCQlsaWtlICJmZyMiIGZvciAiYmciCgkJInNwIyIJCWxpa2UgImZnIyIgZm9yICJzcCIKCQkiYm9sZCIJCSIxIiBpZiBib2xkCgkJIml0YWxpYyIJIjEiIGlmIGl0YWxpYwoJCSJyZXZlcnNlIgkiMSIgaWYgcmV2ZXJzZQoJCSJpbnZlcnNlIgkiMSIgaWYgaW52ZXJzZSAoPSByZXZlcnNlKQoJCSJzdGFuZG91dCIJIjEiIGlmIHN0YW5kb3V0CgkJInVuZGVybGluZSIJIjEiIGlmIHVuZGVybGluZWQKCQkidW5kZXJjdXJsIgkiMSIgaWYgdW5kZXJjdXJsZWQKCgkJRXhhbXBsZSAoZWNob2VzIHRoZSBjb2xvciBvZiB0aGUgc3ludGF4IGl0ZW0gdW5kZXIgdGhlCgkJY3Vyc29yKTogPgoJOmVjaG8gc3luSURhdHRyKHN5bklEdHJhbnMoc3luSUQobGluZSgiLiIpLCBjb2woIi4iKSwgMSkpLCAiZmciKQo8CnN5bklEdHJhbnMoe3N5bklEfSkJCQkJCSpzeW5JRHRyYW5zKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIHRyYW5zbGF0ZWQgc3ludGF4IElEIG9mCgkJe3N5bklEfS4gIFRoaXMgaXMgdGhlIHN5bnRheCBncm91cCBJRCBvZiB3aGF0IGlzIGJlaW5nIHVzZWQgdG8KCQloaWdobGlnaHQgdGhlIGNoYXJhY3Rlci4gIEhpZ2hsaWdodCBsaW5rcyBnaXZlbiB3aXRoCgkJIjpoaWdobGlnaHQgbGluayIgYXJlIGZvbGxvd2VkLgoKc3luY29uY2VhbGVkKHtsbnVtfSwge2NvbH0pCQkJCSpzeW5jb25jZWFsZWQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTGlzdC4gVGhlIGZpcnN0IGl0ZW0gaW4gdGhlIGxpc3QgaXMgMCBpZiB0aGUKCQljaGFyYWN0ZXIgYXQgdGhlIHBvc2l0aW9uIHtsbnVtfSBhbmQge2NvbH0gaXMgbm90IHBhcnQgb2YgYQoJCWNvbmNlYWxhYmxlIHJlZ2lvbiwgMSBpZiBpdCBpcy4gVGhlIHNlY29uZCBpdGVtIGluIHRoZSBsaXN0IGlzCgkJYSBzdHJpbmcuIElmIHRoZSBmaXJzdCBpdGVtIGlzIDEsIHRoZSBzZWNvbmQgaXRlbSBjb250YWlucyB0aGUKCQl0ZXh0IHdoaWNoIHdpbGwgYmUgZGlzcGxheWVkIGluIHBsYWNlIG9mIHRoZSBjb25jZWFsZWQgdGV4dCwKCQlkZXBlbmRpbmcgb24gdGhlIGN1cnJlbnQgc2V0dGluZyBvZiAnY29uY2VhbGxldmVsJy4gVGhlIHRoaXJkCgkJYW5kIGZpbmFsIGl0ZW0gaW4gdGhlIGxpc3QgaXMgYSB1bmlxdWUgbnVtYmVyIHJlcHJlc2VudGluZyB0aGUKCQlzcGVjaWZpYyBzeW50YXggcmVnaW9uIG1hdGNoZWQuIFRoaXMgYWxsb3dzIGRldGVjdGlvbiBvZiB0aGUKCQliZWdpbm5pbmcgb2YgYSBuZXcgY29uY2VhbGFibGUgcmVnaW9uIGlmIHRoZXJlIGFyZSB0d28KCQljb25zZWN1dGl2ZSByZWdpb25zIHdpdGggdGhlIHNhbWUgcmVwbGFjZW1lbnQgY2hhcmFjdGVyLgoJCUZvciBhbiBleGFtcGxlIHVzZSBzZWUgJFZJTVJVTlRJTUUvc3ludGF4LzJodG1sLnZpbSAuCgoKc3luc3RhY2soe2xudW19LCB7Y29sfSkJCQkJCSpzeW5zdGFjaygpKgoJCVJldHVybiBhIHxMaXN0fCwgd2hpY2ggaXMgdGhlIHN0YWNrIG9mIHN5bnRheCBpdGVtcyBhdCB0aGUKCQlwb3NpdGlvbiB7bG51bX0gYW5kIHtjb2x9IGluIHRoZSBjdXJyZW50IHdpbmRvdy4gIEVhY2ggaXRlbSBpbgoJCXRoZSBMaXN0IGlzIGFuIElEIGxpa2Ugd2hhdCB8c3luSUQoKXwgcmV0dXJucy4KCQlUaGUgZmlyc3QgaXRlbSBpbiB0aGUgTGlzdCBpcyB0aGUgb3V0ZXIgcmVnaW9uLCBmb2xsb3dpbmcgYXJlCgkJaXRlbXMgY29udGFpbmVkIGluIHRoYXQgb25lLiAgVGhlIGxhc3Qgb25lIGlzIHdoYXQgfHN5bklEKCl8CgkJcmV0dXJucywgdW5sZXNzIG5vdCB0aGUgd2hvbGUgaXRlbSBpcyBoaWdobGlnaHRlZCBvciBpdCBpcyBhCgkJdHJhbnNwYXJlbnQgaXRlbS4KCQlUaGlzIGZ1bmN0aW9uIGlzIHVzZWZ1bCBmb3IgZGVidWdnaW5nIGEgc3ludGF4IGZpbGUuCgkJRXhhbXBsZSB0aGF0IHNob3dzIHRoZSBzeW50YXggc3RhY2sgdW5kZXIgdGhlIGN1cnNvcjogPgoJCQlmb3IgaWQgaW4gc3luc3RhY2sobGluZSgiLiIpLCBjb2woIi4iKSkKCQkJICAgZWNobyBzeW5JRGF0dHIoaWQsICJuYW1lIikKCQkJZW5kZm9yCjwJCVdoZW4gdGhlIHBvc2l0aW9uIHNwZWNpZmllZCB3aXRoIHtsbnVtfSBhbmQge2NvbH0gaXMgaW52YWxpZAoJCW5vdGhpbmcgaXMgcmV0dXJuZWQuICBUaGUgcG9zaXRpb24ganVzdCBhZnRlciB0aGUgbGFzdAoJCWNoYXJhY3RlciBpbiBhIGxpbmUgYW5kIHRoZSBmaXJzdCBjb2x1bW4gaW4gYW4gZW1wdHkgbGluZSBhcmUKCQl2YWxpZCBwb3NpdGlvbnMuCgpzeXN0ZW0oe2V4cHJ9IFssIHtpbnB1dH1dKQkJCQkqc3lzdGVtKCkqICpFNjc3KgoJCUdldCB0aGUgb3V0cHV0IG9mIHRoZSBzaGVsbCBjb21tYW5kIHtleHByfSBhcyBhIHN0cmluZy4gIFNlZQoJCXxzeXN0ZW1saXN0KCl8IHRvIGdldCB0aGUgb3V0cHV0IGFzIGEgTGlzdC4KCgkJV2hlbiB7aW5wdXR9IGlzIGdpdmVuIGFuZCBpcyBhIHN0cmluZyB0aGlzIHN0cmluZyBpcyB3cml0dGVuIAoJCXRvIGEgZmlsZSBhbmQgcGFzc2VkIGFzIHN0ZGluIHRvIHRoZSBjb21tYW5kLiAgVGhlIHN0cmluZyBpcyAKCQl3cml0dGVuIGFzLWlzLCB5b3UgbmVlZCB0byB0YWtlIGNhcmUgb2YgdXNpbmcgdGhlIGNvcnJlY3QgbGluZSAKCQlzZXBhcmF0b3JzIHlvdXJzZWxmLgoJCUlmIHtpbnB1dH0gaXMgZ2l2ZW4gYW5kIGlzIGEgfExpc3R8IGl0IGlzIHdyaXR0ZW4gdG8gdGhlIGZpbGUKCQlpbiBhIHdheSB8d3JpdGVmaWxlKCl8IGRvZXMgd2l0aCB7YmluYXJ5fSBzZXQgdG8gImIiIChpLmUuCgkJd2l0aCBhIG5ld2xpbmUgYmV0d2VlbiBlYWNoIGxpc3QgaXRlbSB3aXRoIG5ld2xpbmVzIGluc2lkZQoJCWxpc3QgaXRlbXMgY29udmVydGVkIHRvIE5VTHMpLiAgCgkJUGlwZXMgYXJlIG5vdCB1c2VkLgoKCQlXaGVuIHByZXBlbmRlZCBieSB8OnNpbGVudHwgdGhlIHNoZWxsIHdpbGwgbm90IGJlIHNldCB0bwoJCWNvb2tlZCBtb2RlLiAgVGhpcyBpcyBtZWFudCB0byBiZSB1c2VkIGZvciBjb21tYW5kcyB0aGF0IGRvCgkJbm90IG5lZWQgdGhlIHVzZXIgdG8gdHlwZS4gIEl0IGF2b2lkcyBzdHJheSBjaGFyYWN0ZXJzIHNob3dpbmcKCQl1cCBvbiB0aGUgc2NyZWVuIHdoaWNoIHJlcXVpcmUgfENUUkwtTHwgdG8gcmVtb3ZlLiA+CgkJCTpzaWxlbnQgbGV0IGYgPSBzeXN0ZW0oJ2xzICoudmltJykKPAoJCU5vdGU6IFVzZSB8c2hlbGxlc2NhcGUoKXwgb3IgfDo6U3wgd2l0aCB8ZXhwYW5kKCl8IG9yIAoJCXxmbmFtZW1vZGlmeSgpfCB0byBlc2NhcGUgc3BlY2lhbCBjaGFyYWN0ZXJzIGluIGEgY29tbWFuZCAKCQlhcmd1bWVudC4gIE5ld2xpbmVzIGluIHtleHByfSBtYXkgY2F1c2UgdGhlIGNvbW1hbmQgdG8gZmFpbC4gIAoJCVRoZSBjaGFyYWN0ZXJzIGluICdzaGVsbHF1b3RlJyBhbmQgJ3NoZWxseHF1b3RlJyBtYXkgYWxzbyAKCQljYXVzZSB0cm91YmxlLgoJCVRoaXMgaXMgbm90IHRvIGJlIHVzZWQgZm9yIGludGVyYWN0aXZlIGNvbW1hbmRzLgoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLiAgRXhhbXBsZTogPgoJCSAgICA6bGV0IGZpbGVzID0gc3lzdGVtKCJscyAiIC4gIHNoZWxsZXNjYXBlKGV4cGFuZCgnJTpoJykpKQoJCSAgICA6bGV0IGZpbGVzID0gc3lzdGVtKCdscyAnIC4gZXhwYW5kKCclOmg6UycpKQoKPAkJVG8gbWFrZSB0aGUgcmVzdWx0IG1vcmUgc3lzdGVtLWluZGVwZW5kZW50LCB0aGUgc2hlbGwgb3V0cHV0CgkJaXMgZmlsdGVyZWQgdG8gcmVwbGFjZSA8Q1I+IHdpdGggPE5MPiBmb3IgTWFjaW50b3NoLCBhbmQKCQk8Q1I+PE5MPiB3aXRoIDxOTD4gZm9yIERPUy1saWtlIHN5c3RlbXMuCgkJVG8gYXZvaWQgdGhlIHN0cmluZyBiZWluZyB0cnVuY2F0ZWQgYXQgYSBOVUwsIGFsbCBOVUwKCQljaGFyYWN0ZXJzIGFyZSByZXBsYWNlZCB3aXRoIFNPSCAoMHgwMSkuCgoJCVRoZSBjb21tYW5kIGV4ZWN1dGVkIGlzIGNvbnN0cnVjdGVkIHVzaW5nIHNldmVyYWwgb3B0aW9uczoKCSdzaGVsbCcgJ3NoZWxsY21kZmxhZycgJ3NoZWxseHF1b3RlJyB7ZXhwcn0gJ3NoZWxscmVkaXInIHt0bXB9ICdzaGVsbHhxdW90ZScKCQkoe3RtcH0gaXMgYW4gYXV0b21hdGljYWxseSBnZW5lcmF0ZWQgZmlsZSBuYW1lKS4KCQlGb3IgVW5peCBhbmQgT1MvMiBicmFjZXMgYXJlIHB1dCBhcm91bmQge2V4cHJ9IHRvIGFsbG93IGZvcgoJCWNvbmNhdGVuYXRlZCBjb21tYW5kcy4KCgkJVGhlIGNvbW1hbmQgd2lsbCBiZSBleGVjdXRlZCBpbiAiY29va2VkIiBtb2RlLCBzbyB0aGF0IGEKCQlDVFJMLUMgd2lsbCBpbnRlcnJ1cHQgdGhlIGNvbW1hbmQgKG9uIFVuaXggYXQgbGVhc3QpLgoKCQlUaGUgcmVzdWx0aW5nIGVycm9yIGNvZGUgY2FuIGJlIGZvdW5kIGluIHx2OnNoZWxsX2Vycm9yfC4KCQlUaGlzIGZ1bmN0aW9uIHdpbGwgZmFpbCBpbiB8cmVzdHJpY3RlZC1tb2RlfC4KCgkJTm90ZSB0aGF0IGFueSB3cm9uZyB2YWx1ZSBpbiB0aGUgb3B0aW9ucyBtZW50aW9uZWQgYWJvdmUgbWF5CgkJbWFrZSB0aGUgZnVuY3Rpb24gZmFpbC4gIEl0IGhhcyBhbHNvIGJlZW4gcmVwb3J0ZWQgdG8gZmFpbAoJCXdoZW4gdXNpbmcgYSBzZWN1cml0eSBhZ2VudCBhcHBsaWNhdGlvbi4KCQlVbmxpa2UgIjohY21kIiB0aGVyZSBpcyBubyBhdXRvbWF0aWMgY2hlY2sgZm9yIGNoYW5nZWQgZmlsZXMuCgkJVXNlIHw6Y2hlY2t0aW1lfCB0byBmb3JjZSBhIGNoZWNrLgoKCnN5c3RlbWxpc3Qoe2V4cHJ9IFssIHtpbnB1dH1dKQkJCQkqc3lzdGVtbGlzdCgpKgoJCVNhbWUgYXMgfHN5c3RlbSgpfCwgYnV0IHJldHVybnMgYSB8TGlzdHwgd2l0aCBsaW5lcyAocGFydHMgb2YgCgkJb3V0cHV0IHNlcGFyYXRlZCBieSBOTCkgd2l0aCBOVUxzIHRyYW5zZm9ybWVkIGludG8gTkxzLiBPdXRwdXQgCgkJaXMgdGhlIHNhbWUgYXMgfHJlYWRmaWxlKCl8IHdpbGwgb3V0cHV0IHdpdGgge2JpbmFyeX0gYXJndW1lbnQgCgkJc2V0IHRvICJiIi4KCgkJUmV0dXJucyBhbiBlbXB0eSBzdHJpbmcgb24gZXJyb3IuCgoKdGFicGFnZWJ1Zmxpc3QoW3thcmd9XSkJCQkJCSp0YWJwYWdlYnVmbGlzdCgpKgoJCVRoZSByZXN1bHQgaXMgYSB8TGlzdHwsIHdoZXJlIGVhY2ggaXRlbSBpcyB0aGUgbnVtYmVyIG9mIHRoZQoJCWJ1ZmZlciBhc3NvY2lhdGVkIHdpdGggZWFjaCB3aW5kb3cgaW4gdGhlIGN1cnJlbnQgdGFiIHBhZ2UuCgkJe2FyZ30gc3BlY2lmaWVzIHRoZSBudW1iZXIgb2YgdGFiIHBhZ2UgdG8gYmUgdXNlZC4gIFdoZW4KCQlvbWl0dGVkIHRoZSBjdXJyZW50IHRhYiBwYWdlIGlzIHVzZWQuCgkJV2hlbiB7YXJnfSBpcyBpbnZhbGlkIHRoZSBudW1iZXIgemVybyBpcyByZXR1cm5lZC4KCQlUbyBnZXQgYSBsaXN0IG9mIGFsbCBidWZmZXJzIGluIGFsbCB0YWJzIHVzZSB0aGlzOiA+CgkJCWxldCBidWZsaXN0ID0gW10KCQkJZm9yIGkgaW4gcmFuZ2UodGFicGFnZW5yKCckJykpCgkJCSAgIGNhbGwgZXh0ZW5kKGJ1Zmxpc3QsIHRhYnBhZ2VidWZsaXN0KGkgKyAxKSkKCQkJZW5kZm9yCjwJCU5vdGUgdGhhdCBhIGJ1ZmZlciBtYXkgYXBwZWFyIGluIG1vcmUgdGhhbiBvbmUgd2luZG93LgoKCnRhYnBhZ2Vucihbe2FyZ31dKQkJCQkJKnRhYnBhZ2VucigpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgdGhlIGN1cnJlbnQKCQl0YWIgcGFnZS4gIFRoZSBmaXJzdCB0YWIgcGFnZSBoYXMgbnVtYmVyIDEuCgkJV2hlbiB0aGUgb3B0aW9uYWwgYXJndW1lbnQgaXMgIiQiLCB0aGUgbnVtYmVyIG9mIHRoZSBsYXN0IHRhYgoJCXBhZ2UgaXMgcmV0dXJuZWQgKHRoZSB0YWIgcGFnZSBjb3VudCkuCgkJVGhlIG51bWJlciBjYW4gYmUgdXNlZCB3aXRoIHRoZSB8OnRhYnwgY29tbWFuZC4KCgp0YWJwYWdld2lubnIoe3RhYmFyZ30gWywge2FyZ31dKQkJCSp0YWJwYWdld2lubnIoKSoKCQlMaWtlIHx3aW5ucigpfCBidXQgZm9yIHRhYiBwYWdlIHt0YWJhcmd9LgoJCXt0YWJhcmd9IHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIHRhYiBwYWdlIHRvIGJlIHVzZWQuCgkJe2FyZ30gaXMgdXNlZCBsaWtlIHdpdGggfHdpbm5yKCl8OgoJCS0gV2hlbiBvbWl0dGVkIHRoZSBjdXJyZW50IHdpbmRvdyBudW1iZXIgaXMgcmV0dXJuZWQuICBUaGlzIGlzCgkJICB0aGUgd2luZG93IHdoaWNoIHdpbGwgYmUgdXNlZCB3aGVuIGdvaW5nIHRvIHRoaXMgdGFiIHBhZ2UuCgkJLSBXaGVuICIkIiB0aGUgbnVtYmVyIG9mIHdpbmRvd3MgaXMgcmV0dXJuZWQuCgkJLSBXaGVuICIjIiB0aGUgcHJldmlvdXMgd2luZG93IG5yIGlzIHJldHVybmVkLgoJCVVzZWZ1bCBleGFtcGxlczogPgoJCSAgICB0YWJwYWdld2lubnIoMSkJICAgICIgY3VycmVudCB3aW5kb3cgb2YgdGFiIHBhZ2UgMQoJCSAgICB0YWJwYWdld2lubnIoNCwgJyQnKSAgICAiIG51bWJlciBvZiB3aW5kb3dzIGluIHRhYiBwYWdlIDQKPAkJV2hlbiB7dGFiYXJnfSBpcyBpbnZhbGlkIHplcm8gaXMgcmV0dXJuZWQuCgoJCQkJCQkJKnRhZ2ZpbGVzKCkqCnRhZ2ZpbGVzKCkJUmV0dXJucyBhIHxMaXN0fCB3aXRoIHRoZSBmaWxlIG5hbWVzIHVzZWQgdG8gc2VhcmNoIGZvciB0YWdzCgkJZm9yIHRoZSBjdXJyZW50IGJ1ZmZlci4gIFRoaXMgaXMgdGhlICd0YWdzJyBvcHRpb24gZXhwYW5kZWQuCgoKdGFnbGlzdCh7ZXhwcn0pCQkJCQkJCSp0YWdsaXN0KCkqCgkJUmV0dXJucyBhIGxpc3Qgb2YgdGFncyBtYXRjaGluZyB0aGUgcmVndWxhciBleHByZXNzaW9uIHtleHByfS4KCQlFYWNoIGxpc3QgaXRlbSBpcyBhIGRpY3Rpb25hcnkgd2l0aCBhdCBsZWFzdCB0aGUgZm9sbG93aW5nCgkJZW50cmllczoKCQkJbmFtZQkJTmFtZSBvZiB0aGUgdGFnLgoJCQlmaWxlbmFtZQlOYW1lIG9mIHRoZSBmaWxlIHdoZXJlIHRoZSB0YWcgaXMKCQkJCQlkZWZpbmVkLiAgSXQgaXMgZWl0aGVyIHJlbGF0aXZlIHRvIHRoZQoJCQkJCWN1cnJlbnQgZGlyZWN0b3J5IG9yIGEgZnVsbCBwYXRoLgoJCQljbWQJCUV4IGNvbW1hbmQgdXNlZCB0byBsb2NhdGUgdGhlIHRhZyBpbgoJCQkJCXRoZSBmaWxlLgoJCQlraW5kCQlUeXBlIG9mIHRoZSB0YWcuICBUaGUgdmFsdWUgZm9yIHRoaXMKCQkJCQllbnRyeSBkZXBlbmRzIG9uIHRoZSBsYW5ndWFnZSBzcGVjaWZpYwoJCQkJCWtpbmQgdmFsdWVzLiAgT25seSBhdmFpbGFibGUgd2hlbgoJCQkJCXVzaW5nIGEgdGFncyBmaWxlIGdlbmVyYXRlZCBieQoJCQkJCUV4dWJlcmFudCBjdGFncyBvciBoZHJ0YWcuCgkJCXN0YXRpYwkJQSBmaWxlIHNwZWNpZmljIHRhZy4gIFJlZmVyIHRvCgkJCQkJfHN0YXRpYy10YWd8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoJCU1vcmUgZW50cmllcyBtYXkgYmUgcHJlc2VudCwgZGVwZW5kaW5nIG9uIHRoZSBjb250ZW50IG9mIHRoZQoJCXRhZ3MgZmlsZTogYWNjZXNzLCBpbXBsZW1lbnRhdGlvbiwgaW5oZXJpdHMgYW5kIHNpZ25hdHVyZS4KCQlSZWZlciB0byB0aGUgY3RhZ3MgZG9jdW1lbnRhdGlvbiBmb3IgaW5mb3JtYXRpb24gYWJvdXQgdGhlc2UKCQlmaWVsZHMuICBGb3IgQyBjb2RlIHRoZSBmaWVsZHMgInN0cnVjdCIsICJjbGFzcyIgYW5kICJlbnVtIgoJCW1heSBhcHBlYXIsIHRoZXkgZ2l2ZSB0aGUgbmFtZSBvZiB0aGUgZW50aXR5IHRoZSB0YWcgaXMKCQljb250YWluZWQgaW4uCgoJCVRoZSBleC1jb21tYW5kICdjbWQnIGNhbiBiZSBlaXRoZXIgYW4gZXggc2VhcmNoIHBhdHRlcm4sIGEKCQlsaW5lIG51bWJlciBvciBhIGxpbmUgbnVtYmVyIGZvbGxvd2VkIGJ5IGEgYnl0ZSBudW1iZXIuCgoJCUlmIHRoZXJlIGFyZSBubyBtYXRjaGluZyB0YWdzLCB0aGVuIGFuIGVtcHR5IGxpc3QgaXMgcmV0dXJuZWQuCgoJCVRvIGdldCBhbiBleGFjdCB0YWcgbWF0Y2gsIHRoZSBhbmNob3JzICdeJyBhbmQgJyQnIHNob3VsZCBiZQoJCXVzZWQgaW4ge2V4cHJ9LiAgVGhpcyBhbHNvIG1ha2UgdGhlIGZ1bmN0aW9uIHdvcmsgZmFzdGVyLgoJCVJlZmVyIHRvIHx0YWctcmVnZXhwfCBmb3IgbW9yZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgdGFnCgkJc2VhcmNoIHJlZ3VsYXIgZXhwcmVzc2lvbiBwYXR0ZXJuLgoKCQlSZWZlciB0byB8J3RhZ3MnfCBmb3IgaW5mb3JtYXRpb24gYWJvdXQgaG93IHRoZSB0YWdzIGZpbGUgaXMKCQlsb2NhdGVkIGJ5IFZpbS4gUmVmZXIgdG8gfHRhZ3MtZmlsZS1mb3JtYXR8IGZvciB0aGUgZm9ybWF0IG9mCgkJdGhlIHRhZ3MgZmlsZSBnZW5lcmF0ZWQgYnkgdGhlIGRpZmZlcmVudCBjdGFncyB0b29scy4KCnRhbih7ZXhwcn0pCQkJCQkJKnRhbigpKgoJCVJldHVybiB0aGUgdGFuZ2VudCBvZiB7ZXhwcn0sIG1lYXN1cmVkIGluIHJhZGlhbnMsIGFzIGEgfEZsb2F0fAoJCWluIHRoZSByYW5nZSBbLWluZiwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyB0YW4oMTApCjwJCQkwLjY0ODM2MSA+CgkJCTplY2hvIHRhbigtNC4wMSkKPAkJCS0xLjE4MTUwMgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKdGFuaCh7ZXhwcn0pCQkJCQkJKnRhbmgoKSoKCQlSZXR1cm4gdGhlIGh5cGVyYm9saWMgdGFuZ2VudCBvZiB7ZXhwcn0gYXMgYSB8RmxvYXR8IGluIHRoZQoJCXJhbmdlIFstMSwgMV0uCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gdGFuaCgwLjUpCjwJCQkwLjQ2MjExNyA+CgkJCTplY2hvIHRhbmgoLTEpCjwJCQktMC43NjE1OTQKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCnRlbXBuYW1lKCkJCQkJCSp0ZW1wbmFtZSgpKiAqdGVtcC1maWxlLW5hbWUqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIG5hbWUgb2YgYSBmaWxlIHRoYXQKCQlkb2Vzbid0IGV4aXN0LglJdCBjYW4gYmUgdXNlZCBmb3IgYSB0ZW1wb3JhcnkgZmlsZS4gIFRoZSBuYW1lCgkJaXMgZGlmZmVyZW50IGZvciBhdCBsZWFzdCAyNiBjb25zZWN1dGl2ZSBjYWxscy4gIEV4YW1wbGU6ID4KCQkJOmxldCB0bXBmaWxlID0gdGVtcG5hbWUoKQoJCQk6ZXhlICJyZWRpciA+ICIgLiB0bXBmaWxlCjwJCUZvciBVbml4LCB0aGUgZmlsZSB3aWxsIGJlIGluIGEgcHJpdmF0ZSBkaXJlY3RvcnkgfHRlbXBmaWxlfC4KCQlGb3IgTVMtV2luZG93cyBmb3J3YXJkIHNsYXNoZXMgYXJlIHVzZWQgd2hlbiB0aGUgJ3NoZWxsc2xhc2gnCgkJb3B0aW9uIGlzIHNldCBvciB3aGVuICdzaGVsbGNtZGZsYWcnIHN0YXJ0cyB3aXRoICctJy4KCgp0ZXN0X2dhcmJhZ2Vjb2xsZWN0X25vdygpCQkJICp0ZXN0X2dhcmJhZ2Vjb2xsZWN0X25vdygpKgoJCUxpa2UgZ2FyYmFnZWNvbGxlY3QoKSwgYnV0IGV4ZWN1dGVkIHJpZ2h0IGF3YXkuICBUaGlzIG11c3QKCQlvbmx5IGJlIGNhbGxlZCBkaXJlY3RseSB0byBhdm9pZCBhbnkgc3RydWN0dXJlIHRvIGV4aXN0CgkJaW50ZXJuYWxseSwgYW5kIHx2OnRlc3Rpbmd8IG11c3QgaGF2ZSBiZWVuIHNldCBiZWZvcmUgY2FsbGluZwoJCWFueSBmdW5jdGlvbi4KCnRlc3RfbnVsbF9jaGFubmVsKCkJCQkJCSp0ZXN0X251bGxfY2hhbm5lbCgpKgoJCVJldHVybiBhIENoYW5uZWwgdGhhdCBpcyBudWxsLiBPbmx5IHVzZWZ1bCBmb3IgdGVzdGluZy4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSArY2hhbm5lbCBmZWF0dXJlfQoKdGVzdF9udWxsX2RpY3QoKQkJCQkJKnRlc3RfbnVsbF9kaWN0KCkqCgkJUmV0dXJuIGEgRGljdCB0aGF0IGlzIG51bGwuIE9ubHkgdXNlZnVsIGZvciB0ZXN0aW5nLgoKdGVzdF9udWxsX2pvYigpCQkJCQkJKnRlc3RfbnVsbF9qb2IoKSoKCQlSZXR1cm4gYSBKb2IgdGhhdCBpcyBudWxsLiBPbmx5IHVzZWZ1bCBmb3IgdGVzdGluZy4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSAram9iIGZlYXR1cmV9Cgp0ZXN0X251bGxfbGlzdCgpCQkJCQkqdGVzdF9udWxsX2xpc3QoKSoKCQlSZXR1cm4gYSBMaXN0IHRoYXQgaXMgbnVsbC4gT25seSB1c2VmdWwgZm9yIHRlc3RpbmcuCgp0ZXN0X251bGxfcGFydGlhbCgpCQkJCQkqdGVzdF9udWxsX3BhcnRpYWwoKSoKCQlSZXR1cm4gYSBQYXJ0aWFsIHRoYXQgaXMgbnVsbC4gT25seSB1c2VmdWwgZm9yIHRlc3RpbmcuCgp0ZXN0X251bGxfc3RyaW5nKCkJCQkJCSp0ZXN0X251bGxfc3RyaW5nKCkqCgkJUmV0dXJuIGEgU3RyaW5nIHRoYXQgaXMgbnVsbC4gT25seSB1c2VmdWwgZm9yIHRlc3RpbmcuCgoKCQkJCQkJCSp0aW1lcl9zdGFydCgpKgp0aW1lcl9zdGFydCh7dGltZX0sIHtjYWxsYmFja30gWywge29wdGlvbnN9XSkKCQlDcmVhdGUgYSB0aW1lciBhbmQgcmV0dXJuIHRoZSB0aW1lciBJRC4KCgkJe3RpbWV9IGlzIHRoZSB3YWl0aW5nIHRpbWUgaW4gbWlsbGlzZWNvbmRzLiBUaGlzIGlzIHRoZQoJCW1pbmltdW0gdGltZSBiZWZvcmUgaW52b2tpbmcgdGhlIGNhbGxiYWNrLiAgV2hlbiB0aGUgc3lzdGVtIGlzCgkJYnVzeSBvciBWaW0gaXMgbm90IHdhaXRpbmcgZm9yIGlucHV0IHRoZSB0aW1lIHdpbGwgYmUgbG9uZ2VyLgoKCQl7Y2FsbGJhY2t9IGlzIHRoZSBmdW5jdGlvbiB0byBjYWxsLiAgSXQgY2FuIGJlIHRoZSBuYW1lIG9mIGEKCQlmdW5jdGlvbiBvciBhIEZ1bmNyZWYuICBJdCBpcyBjYWxsZWQgd2l0aCBvbmUgYXJndW1lbnQsIHdoaWNoCgkJaXMgdGhlIHRpbWVyIElELiAgVGhlIGNhbGxiYWNrIGlzIG9ubHkgaW52b2tlZCB3aGVuIFZpbSBpcwoJCXdhaXRpbmcgZm9yIGlucHV0LgoKCQl7b3B0aW9uc30gaXMgYSBkaWN0aW9uYXJ5LiAgU3VwcG9ydGVkIGVudHJpZXM6CgkJICAgInJlcGVhdCIJTnVtYmVyIG9mIHRpbWVzIHRvIHJlcGVhdCBjYWxsaW5nIHRoZQoJCQkJY2FsbGJhY2suICAtMSBtZWFucyBmb3JldmVyLgoKCQlFeGFtcGxlOiA+CgkJCWZ1bmMgTXlIYW5kbGVyKHRpbWVyKQoJCQkgIGVjaG8gJ0hhbmRsZXIgY2FsbGVkJwoJCQllbmRmdW5jCgkJCWxldCB0aW1lciA9IHRpbWVyX3N0YXJ0KDUwMCwgJ015SGFuZGxlcicsCgkJCQlcIHsncmVwZWF0JzogM30pCjwJCVRoaXMgd2lsbCBpbnZva2UgTXlIYW5kbGVyKCkgdGhyZWUgdGltZXMgYXQgNTAwIG1zZWMKCQlpbnRlcnZhbHMuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCt0aW1lcnN8IGZlYXR1cmV9Cgp0aW1lcl9zdG9wKHt0aW1lcn0pCQkJCQkqdGltZXJfc3RvcCgpKgoJCVN0b3AgYSB0aW1lci4gIFRoZSB0aW1lciBjYWxsYmFjayB3aWxsIG5vIGxvbmdlciBiZSBpbnZva2VkLgoJCXt0aW1lcn0gaXMgYW4gSUQgcmV0dXJuZWQgYnkgdGltZXJfc3RhcnQoKSwgdGh1cyBpdCBtdXN0IGJlIGEKCQlOdW1iZXIuCgp0b2xvd2VyKHtleHByfSkJCQkJCQkqdG9sb3dlcigpKgoJCVRoZSByZXN1bHQgaXMgYSBjb3B5IG9mIHRoZSBTdHJpbmcgZ2l2ZW4sIHdpdGggYWxsIHVwcGVyY2FzZQoJCWNoYXJhY3RlcnMgdHVybmVkIGludG8gbG93ZXJjYXNlIChqdXN0IGxpa2UgYXBwbHlpbmcgfGd1fCB0bwoJCXRoZSBzdHJpbmcpLgoKdG91cHBlcih7ZXhwcn0pCQkJCQkJKnRvdXBwZXIoKSoKCQlUaGUgcmVzdWx0IGlzIGEgY29weSBvZiB0aGUgU3RyaW5nIGdpdmVuLCB3aXRoIGFsbCBsb3dlcmNhc2UKCQljaGFyYWN0ZXJzIHR1cm5lZCBpbnRvIHVwcGVyY2FzZSAoanVzdCBsaWtlIGFwcGx5aW5nIHxnVXwgdG8KCQl0aGUgc3RyaW5nKS4KCnRyKHtzcmN9LCB7ZnJvbXN0cn0sIHt0b3N0cn0pCQkJCSp0cigpKgoJCVRoZSByZXN1bHQgaXMgYSBjb3B5IG9mIHRoZSB7c3JjfSBzdHJpbmcgd2l0aCBhbGwgY2hhcmFjdGVycwoJCXdoaWNoIGFwcGVhciBpbiB7ZnJvbXN0cn0gcmVwbGFjZWQgYnkgdGhlIGNoYXJhY3RlciBpbiB0aGF0CgkJcG9zaXRpb24gaW4gdGhlIHt0b3N0cn0gc3RyaW5nLiAgVGh1cyB0aGUgZmlyc3QgY2hhcmFjdGVyIGluCgkJe2Zyb21zdHJ9IGlzIHRyYW5zbGF0ZWQgaW50byB0aGUgZmlyc3QgY2hhcmFjdGVyIGluIHt0b3N0cn0KCQlhbmQgc28gb24uICBFeGFjdGx5IGxpa2UgdGhlIHVuaXggInRyIiBjb21tYW5kLgoJCVRoaXMgY29kZSBhbHNvIGRlYWxzIHdpdGggbXVsdGlieXRlIGNoYXJhY3RlcnMgcHJvcGVybHkuCgoJCUV4YW1wbGVzOiA+CgkJCWVjaG8gdHIoImhlbGxvIHRoZXJlIiwgImh0IiwgIkhUIikKPAkJcmV0dXJucyAiSGVsbG8gVEhlcmUiID4KCQkJZWNobyB0cigiPGJsb2I+IiwgIjw+IiwgInt9IikKPAkJcmV0dXJucyAie2Jsb2J9IgoKdHJ1bmMoe2V4cHJ9KQkJCQkJCQkqdHJ1bmMoKSoKCQlSZXR1cm4gdGhlIGxhcmdlc3QgaW50ZWdyYWwgdmFsdWUgd2l0aCBtYWduaXR1ZGUgbGVzcyB0aGFuIG9yCgkJZXF1YWwgdG8ge2V4cHJ9IGFzIGEgfEZsb2F0fCAodHJ1bmNhdGUgdG93YXJkcyB6ZXJvKS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQllY2hvIHRydW5jKDEuNDU2KQo8CQkJMS4wICA+CgkJCWVjaG8gdHJ1bmMoLTUuNDU2KQo8CQkJLTUuMCAgPgoJCQllY2hvIHRydW5jKDQuMCkKPAkJCTQuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJCgkJCQkJCQkqdHlwZSgpKgp0eXBlKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgZGVwZW5kaW5nIG9uIHRoZSB0eXBlIG9mIHtleHByfToKCQkJTnVtYmVyOgkgICAgMAoJCQlTdHJpbmc6CSAgICAxCgkJCUZ1bmNyZWY6ICAgIDIKCQkJTGlzdDoJICAgIDMKCQkJRGljdGlvbmFyeTogNAoJCQlGbG9hdDoJICAgIDUKCQkJQm9vbGVhbjogICAgNiAodjpmYWxzZSBhbmQgdjp0cnVlKQoJCQlOb25lCSAgICA3ICh2Om51bGwgYW5kIHY6bm9uZSkKCQkJSm9iCSAgICA4CgkJCUNoYW5uZWwJICAgIDkKCQlUbyBhdm9pZCB0aGUgbWFnaWMgbnVtYmVycyBpdCBzaG91bGQgYmUgdXNlZCB0aGlzIHdheTogPgoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZSgwKQoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZSgiIikKCQkJOmlmIHR5cGUobXl2YXIpID09IHR5cGUoZnVuY3Rpb24oInRyIikpCgkJCTppZiB0eXBlKG15dmFyKSA9PSB0eXBlKFtdKQoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZSh7fSkKCQkJOmlmIHR5cGUobXl2YXIpID09IHR5cGUoMC4wKQoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZSh2OmZhbHNlKQoJCQk6aWYgdHlwZShteXZhcikgPT0gdHlwZSh2Om5vbmUpCgp1bmRvZmlsZSh7bmFtZX0pCQkJCQkqdW5kb2ZpbGUoKSoKCQlSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIHVuZG8gZmlsZSB0aGF0IHdvdWxkIGJlIHVzZWQgZm9yIGEgZmlsZQoJCXdpdGggbmFtZSB7bmFtZX0gd2hlbiB3cml0aW5nLiAgVGhpcyB1c2VzIHRoZSAndW5kb2RpcicKCQlvcHRpb24sIGZpbmRpbmcgZGlyZWN0b3JpZXMgdGhhdCBleGlzdC4gIEl0IGRvZXMgbm90IGNoZWNrIGlmCgkJdGhlIHVuZG8gZmlsZSBleGlzdHMuCgkJe25hbWV9IGlzIGFsd2F5cyBleHBhbmRlZCB0byB0aGUgZnVsbCBwYXRoLCBzaW5jZSB0aGF0IGlzIHdoYXQKCQlpcyB1c2VkIGludGVybmFsbHkuCgkJSWYge25hbWV9IGlzIGVtcHR5IHVuZG9maWxlKCkgcmV0dXJucyBhbiBlbXB0eSBzdHJpbmcsIHNpbmNlIGEKCQlidWZmZXIgd2l0aG91dCBhIGZpbGUgbmFtZSB3aWxsIG5vdCB3cml0ZSBhbiB1bmRvIGZpbGUuCgkJVXNlZnVsIGluIGNvbWJpbmF0aW9uIHdpdGggfDp3dW5kb3wgYW5kIHw6cnVuZG98LgoJCVdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgK3BlcnNpc3RlbnRfdW5kbyBvcHRpb24gdGhpcyBhbHdheXMKCQlyZXR1cm5zIGFuIGVtcHR5IHN0cmluZy4KCnVuZG90cmVlKCkJCQkJCQkqdW5kb3RyZWUoKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgc3RhdGUgb2YgdGhlIHVuZG8gdHJlZSBpbiBhIGRpY3Rpb25hcnkgd2l0aAoJCXRoZSBmb2xsb3dpbmcgaXRlbXM6CgkJICAic2VxX2xhc3QiCVRoZSBoaWdoZXN0IHVuZG8gc2VxdWVuY2UgbnVtYmVyIHVzZWQuCgkJICAic2VxX2N1ciIJVGhlIHNlcXVlbmNlIG51bWJlciBvZiB0aGUgY3VycmVudCBwb3NpdGlvbiBpbgoJCQkJdGhlIHVuZG8gdHJlZS4gIFRoaXMgZGlmZmVycyBmcm9tICJzZXFfbGFzdCIKCQkJCXdoZW4gc29tZSBjaGFuZ2VzIHdlcmUgdW5kb25lLgoJCSAgInRpbWVfY3VyIglUaW1lIGxhc3QgdXNlZCBmb3IgfDplYXJsaWVyfCBhbmQgcmVsYXRlZAoJCQkJY29tbWFuZHMuICBVc2UgfHN0cmZ0aW1lKCl8IHRvIGNvbnZlcnQgdG8KCQkJCXNvbWV0aGluZyByZWFkYWJsZS4KCQkgICJzYXZlX2xhc3QiCU51bWJlciBvZiB0aGUgbGFzdCBmaWxlIHdyaXRlLiAgWmVybyB3aGVuIG5vCgkJCQl3cml0ZSB5ZXQuCgkJICAic2F2ZV9jdXIiCU51bWJlciBvZiB0aGUgY3VycmVudCBwb3NpdGlvbiBpbiB0aGUgdW5kbwoJCQkJdHJlZS4gIAoJCSAgInN5bmNlZCIJTm9uLXplcm8gd2hlbiB0aGUgbGFzdCB1bmRvIGJsb2NrIHdhcyBzeW5jZWQuCgkJCQlUaGlzIGhhcHBlbnMgd2hlbiB3YWl0aW5nIGZyb20gaW5wdXQgZnJvbSB0aGUKCQkJCXVzZXIuICBTZWUgfHVuZG8tYmxvY2tzfC4KCQkgICJlbnRyaWVzIglBIGxpc3Qgb2YgZGljdGlvbmFyaWVzIHdpdGggaW5mb3JtYXRpb24gYWJvdXQKCQkJCXVuZG8gYmxvY2tzLgoKCQlUaGUgZmlyc3QgaXRlbSBpbiB0aGUgImVudHJpZXMiIGxpc3QgaXMgdGhlIG9sZGVzdCB1bmRvIGl0ZW0uCgkJRWFjaCBMaXN0IGl0ZW0gaXMgYSBEaWN0aW9uYXJ5IHdpdGggdGhlc2UgaXRlbXM6CgkJICAic2VxIgkJVW5kbyBzZXF1ZW5jZSBudW1iZXIuICBTYW1lIGFzIHdoYXQgYXBwZWFycyBpbgoJCQkJfDp1bmRvbGlzdHwuCgkJICAidGltZSIJVGltZXN0YW1wIHdoZW4gdGhlIGNoYW5nZSBoYXBwZW5lZC4gIFVzZQoJCQkJfHN0cmZ0aW1lKCl8IHRvIGNvbnZlcnQgdG8gc29tZXRoaW5nIHJlYWRhYmxlLgoJCSAgIm5ld2hlYWQiCU9ubHkgYXBwZWFycyBpbiB0aGUgaXRlbSB0aGF0IGlzIHRoZSBsYXN0IG9uZQoJCQkJdGhhdCB3YXMgYWRkZWQuICBUaGlzIG1hcmtzIHRoZSBsYXN0IGNoYW5nZQoJCQkJYW5kIHdoZXJlIGZ1cnRoZXIgY2hhbmdlcyB3aWxsIGJlIGFkZGVkLgoJCSAgImN1cmhlYWQiCU9ubHkgYXBwZWFycyBpbiB0aGUgaXRlbSB0aGF0IGlzIHRoZSBsYXN0IG9uZQoJCQkJdGhhdCB3YXMgdW5kb25lLiAgVGhpcyBtYXJrcyB0aGUgY3VycmVudAoJCQkJcG9zaXRpb24gaW4gdGhlIHVuZG8gdHJlZSwgdGhlIGJsb2NrIHRoYXQgd2lsbAoJCQkJYmUgdXNlZCBieSBhIHJlZG8gY29tbWFuZC4gIFdoZW4gbm90aGluZyB3YXMKCQkJCXVuZG9uZSBhZnRlciB0aGUgbGFzdCBjaGFuZ2UgdGhpcyBpdGVtIHdpbGwKCQkJCW5vdCBhcHBlYXIgYW55d2hlcmUuCgkJICAic2F2ZSIJT25seSBhcHBlYXJzIG9uIHRoZSBsYXN0IGJsb2NrIGJlZm9yZSBhIGZpbGUKCQkJCXdyaXRlLiAgVGhlIG51bWJlciBpcyB0aGUgd3JpdGUgY291bnQuICBUaGUKCQkJCWZpcnN0IHdyaXRlIGhhcyBudW1iZXIgMSwgdGhlIGxhc3Qgb25lIHRoZQoJCQkJInNhdmVfbGFzdCIgbWVudGlvbmVkIGFib3ZlLgoJCSAgImFsdCIJCUFsdGVybmF0ZSBlbnRyeS4gIFRoaXMgaXMgYWdhaW4gYSBMaXN0IG9mIHVuZG8KCQkJCWJsb2Nrcy4gIEVhY2ggaXRlbSBtYXkgYWdhaW4gaGF2ZSBhbiAiYWx0IgoJCQkJaXRlbS4KCnVuaXEoe2xpc3R9IFssIHtmdW5jfSBbLCB7ZGljdH1dXSkJCQkqdW5pcSgpKiAqRTg4MioKCQlSZW1vdmUgc2Vjb25kIGFuZCBzdWNjZWVkaW5nIGNvcGllcyBvZiByZXBlYXRlZCBhZGphY2VudAoJCXtsaXN0fSBpdGVtcyBpbi1wbGFjZS4gIFJldHVybnMge2xpc3R9LiAgSWYgeW91IHdhbnQgYSBsaXN0CgkJdG8gcmVtYWluIHVubW9kaWZpZWQgbWFrZSBhIGNvcHkgZmlyc3Q6ID4KCQkJOmxldCBuZXdsaXN0ID0gdW5pcShjb3B5KG15bGlzdCkpCjwJCVRoZSBkZWZhdWx0IGNvbXBhcmUgZnVuY3Rpb24gdXNlcyB0aGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mCgkJZWFjaCBpdGVtLiAgRm9yIHRoZSB1c2Ugb2Yge2Z1bmN9IGFuZCB7ZGljdH0gc2VlIHxzb3J0KCl8LgoKdmFsdWVzKHtkaWN0fSkJCQkJCQkqdmFsdWVzKCkqCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggYWxsIHRoZSB2YWx1ZXMgb2Yge2RpY3R9LglUaGUgfExpc3R8IGlzCgkJaW4gYXJiaXRyYXJ5IG9yZGVyLgoKCnZpcnRjb2woe2V4cHJ9KQkJCQkJCSp2aXJ0Y29sKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIHNjcmVlbiBjb2x1bW4gb2YgdGhlIGZpbGUKCQlwb3NpdGlvbiBnaXZlbiB3aXRoIHtleHByfS4gIFRoYXQgaXMsIHRoZSBsYXN0IHNjcmVlbiBwb3NpdGlvbgoJCW9jY3VwaWVkIGJ5IHRoZSBjaGFyYWN0ZXIgYXQgdGhhdCBwb3NpdGlvbiwgd2hlbiB0aGUgc2NyZWVuCgkJd291bGQgYmUgb2YgdW5saW1pdGVkIHdpZHRoLiAgV2hlbiB0aGVyZSBpcyBhIDxUYWI+IGF0IHRoZQoJCXBvc2l0aW9uLCB0aGUgcmV0dXJuZWQgTnVtYmVyIHdpbGwgYmUgdGhlIGNvbHVtbiBhdCB0aGUgZW5kIG9mCgkJdGhlIDxUYWI+LiAgRm9yIGV4YW1wbGUsIGZvciBhIDxUYWI+IGluIGNvbHVtbiAxLCB3aXRoICd0cycKCQlzZXQgdG8gOCwgaXQgcmV0dXJucyA4LiB8Y29uY2VhbHwgaXMgaWdub3JlZC4KCQlGb3IgdGhlIGJ5dGUgcG9zaXRpb24gdXNlIHxjb2woKXwuCgkJRm9yIHRoZSB1c2Ugb2Yge2V4cHJ9IHNlZSB8Y29sKCl8LgoJCVdoZW4gJ3ZpcnR1YWxlZGl0JyBpcyB1c2VkIHtleHByfSBjYW4gYmUgW2xudW0sIGNvbCwgb2ZmXSwgd2hlcmUKCQkib2ZmIiBpcyB0aGUgb2Zmc2V0IGluIHNjcmVlbiBjb2x1bW5zIGZyb20gdGhlIHN0YXJ0IG9mIHRoZQoJCWNoYXJhY3Rlci4gIEUuZy4sIGEgcG9zaXRpb24gd2l0aGluIGEgPFRhYj4gb3IgYWZ0ZXIgdGhlIGxhc3QKCQljaGFyYWN0ZXIuICBXaGVuICJvZmYiIGlzIG9taXR0ZWQgemVybyBpcyB1c2VkLgoJCVdoZW4gVmlydHVhbCBlZGl0aW5nIGlzIGFjdGl2ZSBpbiB0aGUgY3VycmVudCBtb2RlLCBhIHBvc2l0aW9uCgkJYmV5b25kIHRoZSBlbmQgb2YgdGhlIGxpbmUgY2FuIGJlIHJldHVybmVkLiB8J3ZpcnR1YWxlZGl0J3wKCQlUaGUgYWNjZXB0ZWQgcG9zaXRpb25zIGFyZToKCQkgICAgLgkgICAgdGhlIGN1cnNvciBwb3NpdGlvbgoJCSAgICAkCSAgICB0aGUgZW5kIG9mIHRoZSBjdXJzb3IgbGluZSAodGhlIHJlc3VsdCBpcyB0aGUKCQkJICAgIG51bWJlciBvZiBkaXNwbGF5ZWQgY2hhcmFjdGVycyBpbiB0aGUgY3Vyc29yIGxpbmUKCQkJICAgIHBsdXMgb25lKQoJCSAgICAneAkgICAgcG9zaXRpb24gb2YgbWFyayB4IChpZiB0aGUgbWFyayBpcyBub3Qgc2V0LCAwIGlzCgkJCSAgICByZXR1cm5lZCkKCQkgICAgdiAgICAgICBJbiBWaXN1YWwgbW9kZTogdGhlIHN0YXJ0IG9mIHRoZSBWaXN1YWwgYXJlYSAodGhlCgkJCSAgICBjdXJzb3IgaXMgdGhlIGVuZCkuICBXaGVuIG5vdCBpbiBWaXN1YWwgbW9kZQoJCQkgICAgcmV0dXJucyB0aGUgY3Vyc29yIHBvc2l0aW9uLiAgRGlmZmVycyBmcm9tIHwnPHwgaW4KCQkJICAgIHRoYXQgaXQncyB1cGRhdGVkIHJpZ2h0IGF3YXkuCgkJTm90ZSB0aGF0IG9ubHkgbWFya3MgaW4gdGhlIGN1cnJlbnQgZmlsZSBjYW4gYmUgdXNlZC4KCQlFeGFtcGxlczogPgogIHZpcnRjb2woIi4iKQkgICB3aXRoIHRleHQgImZvb15MYmFyIiwgd2l0aCBjdXJzb3Igb24gdGhlICJeTCIsIHJldHVybnMgNQogIHZpcnRjb2woIiQiKQkgICB3aXRoIHRleHQgImZvb15MYmFyIiwgcmV0dXJucyA5CiAgdmlydGNvbCgiJ3QiKSAgICB3aXRoIHRleHQgIgkgIHRoZXJlIiwgd2l0aCAndCBhdCAnaCcsIHJldHVybnMgNgo8CQlUaGUgZmlyc3QgY29sdW1uIGlzIDEuCTAgaXMgcmV0dXJuZWQgZm9yIGFuIGVycm9yLgoJCUEgbW9yZSBhZHZhbmNlZCBleGFtcGxlIHRoYXQgZWNob2VzIHRoZSBtYXhpbXVtIGxlbmd0aCBvZgoJCWFsbCBsaW5lczogPgoJCSAgICBlY2hvIG1heChtYXAocmFuZ2UoMSwgbGluZSgnJCcpKSwgInZpcnRjb2woW3Y6dmFsLCAnJCddKSIpKQoKCnZpc3VhbG1vZGUoW2V4cHJdKQkJCQkJCSp2aXN1YWxtb2RlKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggZGVzY3JpYmVzIHRoZSBsYXN0IFZpc3VhbCBtb2RlCgkJdXNlZCBpbiB0aGUgY3VycmVudCBidWZmZXIuICBJbml0aWFsbHkgaXQgcmV0dXJucyBhbiBlbXB0eQoJCXN0cmluZywgYnV0IG9uY2UgVmlzdWFsIG1vZGUgaGFzIGJlZW4gdXNlZCwgaXQgcmV0dXJucyAidiIsCgkJIlYiLCBvciAiPENUUkwtVj4iIChhIHNpbmdsZSBDVFJMLVYgY2hhcmFjdGVyKSBmb3IKCQljaGFyYWN0ZXItd2lzZSwgbGluZS13aXNlLCBvciBibG9jay13aXNlIFZpc3VhbCBtb2RlCgkJcmVzcGVjdGl2ZWx5LgoJCUV4YW1wbGU6ID4KCQkJOmV4ZSAibm9ybWFsICIgLiB2aXN1YWxtb2RlKCkKPAkJVGhpcyBlbnRlcnMgdGhlIHNhbWUgVmlzdWFsIG1vZGUgYXMgYmVmb3JlLiAgSXQgaXMgYWxzbyB1c2VmdWwKCQlpbiBzY3JpcHRzIGlmIHlvdSB3aXNoIHRvIGFjdCBkaWZmZXJlbnRseSBkZXBlbmRpbmcgb24gdGhlCgkJVmlzdWFsIG1vZGUgdGhhdCB3YXMgdXNlZC4KCQlJZiBWaXN1YWwgbW9kZSBpcyBhY3RpdmUsIHVzZSB8bW9kZSgpfCB0byBnZXQgdGhlIFZpc3VhbCBtb2RlCgkJKGUuZy4sIGluIGEgfDp2bWFwfCkuCgkJCQkJCQkqbm9uLXplcm8tYXJnKgoJCUlmIFtleHByXSBpcyBzdXBwbGllZCBhbmQgaXQgZXZhbHVhdGVzIHRvIGEgbm9uLXplcm8gTnVtYmVyIG9yCgkJYSBub24tZW1wdHkgU3RyaW5nLCB0aGVuIHRoZSBWaXN1YWwgbW9kZSB3aWxsIGJlIGNsZWFyZWQgYW5kCgkJdGhlIG9sZCB2YWx1ZSBpcyByZXR1cm5lZC4gIE5vdGUgdGhhdCAiICIgYW5kICIwIiBhcmUgYWxzbwoJCW5vbi1lbXB0eSBzdHJpbmdzLCB0aHVzIGNhdXNlIHRoZSBtb2RlIHRvIGJlIGNsZWFyZWQuICBBIExpc3QsCgkJRGljdGlvbmFyeSBvciBGbG9hdCBpcyBub3QgYSBOdW1iZXIgb3IgU3RyaW5nLCB0aHVzIGRvZXMgbm90CgkJY2F1c2UgdGhlIG1vZGUgdG8gYmUgY2xlYXJlZC4KCndpbGRtZW51bW9kZSgpCQkJCQkqd2lsZG1lbnVtb2RlKCkqCgkJUmV0dXJucyBub24temVybyB3aGVuIHRoZSB3aWxkbWVudSBpcyBhY3RpdmUgYW5kIHplcm8KCQlvdGhlcndpc2UuICBTZWUgJ3dpbGRtZW51JyBhbmQgJ3dpbGRtb2RlJy4KCQlUaGlzIGNhbiBiZSB1c2VkIGluIG1hcHBpbmdzIHRvIGhhbmRsZSB0aGUgJ3dpbGRjaGFybScgb3B0aW9uCgkJZ3JhY2VmdWxseS4gKE1ha2VzIG9ubHkgc2Vuc2Ugd2l0aCB8bWFwbW9kZS1jfCBtYXBwaW5ncykuCgoJCUZvciBleGFtcGxlIHRvIG1ha2UgPGMtaj4gd29yayBsaWtlIDxkb3duPiBpbiB3aWxkbW9kZSwgdXNlOiA+CiAgICA6Y25vcmVtYXAgPGV4cHI+IDxDLWo+IHdpbGRtZW51bW9kZSgpID8gIlw8RG93bj5cPFRhYj4iIDogIlw8Yy1qPiIKPAoJCShOb3RlLCB0aGlzIG5lZWRzIHRoZSAnd2lsZGNoYXJtJyBvcHRpb24gc2V0IGFwcHJvcHJpYXRlbHkpLgoKCndpbl9maW5kYnVmKHtidWZucn0pCQkJCQkqd2luX2ZpbmRidWYoKSoKCQlSZXR1cm5zIGEgbGlzdCB3aXRoIHdpbmRvdyBJRHMgZm9yIHdpbmRvd3MgdGhhdCBjb250YWluIGJ1ZmZlcgoJCXtidWZucn0uICBXaGVuIHRoZXJlIGlzIG5vbmUgdGhlIGxpc3QgaXMgZW1wdHkuCgp3aW5fZ2V0aWQoW3t3aW59IFssIHt0YWJ9XV0pCQkJCSp3aW5fZ2V0aWQoKSoKCQlHZXQgdGhlIHdpbmRvdyBJRCBmb3IgdGhlIHNwZWNpZmllZCB3aW5kb3cuCgkJV2hlbiB7d2lufSBpcyBtaXNzaW5nIHVzZSB0aGUgY3VycmVudCB3aW5kb3cuCgkJV2l0aCB7d2lufSB0aGlzIGlzIHRoZSB3aW5kb3cgbnVtYmVyLiAgVGhlIHRvcCB3aW5kb3cgaGFzCgkJbnVtYmVyIDEuCgkJV2l0aG91dCB7dGFifSB1c2UgdGhlIGN1cnJlbnQgdGFiLCBvdGhlcndpc2UgdGhlIHRhYiB3aXRoCgkJbnVtYmVyIHt0YWJ9LiAgVGhlIGZpcnN0IHRhYiBoYXMgbnVtYmVyIG9uZS4KCQlSZXR1cm4gemVybyBpZiB0aGUgd2luZG93IGNhbm5vdCBiZSBmb3VuZC4KCndpbl9nb3RvaWQoe2V4cHJ9KQkJCQkJKndpbl9nb3RvaWQoKSoKCQlHbyB0byB3aW5kb3cgd2l0aCBJRCB7ZXhwcn0uICBUaGlzIG1heSBhbHNvIGNoYW5nZSB0aGUgY3VycmVudAoJCXRhYnBhZ2UuCgkJUmV0dXJuIDEgaWYgc3VjY2Vzc2Z1bCwgMCBpZiB0aGUgd2luZG93IGNhbm5vdCBiZSBmb3VuZC4KCndpbl9pZDJ0YWJ3aW4oe2V4cHJ9KQkJCQkJKndpbl9pZDJ0YWJ3aW4oKSoKCQlSZXR1cm4gYSBsaXN0IHdpdGggdGhlIHRhYiBudW1iZXIgYW5kIHdpbmRvdyBudW1iZXIgb2Ygd2luZG93CgkJd2l0aCBJRCB7ZXhwcn06IFt0YWJuciwgd2lubnJdLgoJCVJldHVybiBbMCwgMF0gaWYgdGhlIHdpbmRvdyBjYW5ub3QgYmUgZm91bmQuCgp3aW5faWQyd2luKHtleHByfSkJCQkJCSp3aW5faWQyd2luKCkqCgkJUmV0dXJuIHRoZSB3aW5kb3cgbnVtYmVyIG9mIHdpbmRvdyB3aXRoIElEIHtleHByfS4KCQlSZXR1cm4gMCBpZiB0aGUgd2luZG93IGNhbm5vdCBiZSBmb3VuZCBpbiB0aGUgY3VycmVudCB0YWJwYWdlLgoKCQkJCQkJCSp3aW5idWZucigpKgp3aW5idWZucih7bnJ9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBidWZmZXIKCQlhc3NvY2lhdGVkIHdpdGggd2luZG93IHtucn0uICBXaGVuIHtucn0gaXMgemVybywgdGhlIG51bWJlciBvZgoJCXRoZSBidWZmZXIgaW4gdGhlIGN1cnJlbnQgd2luZG93IGlzIHJldHVybmVkLiAgV2hlbiB3aW5kb3cKCQl7bnJ9IGRvZXNuJ3QgZXhpc3QsIC0xIGlzIHJldHVybmVkLgoJCUV4YW1wbGU6ID4KICA6ZWNobyAiVGhlIGZpbGUgaW4gdGhlIGN1cnJlbnQgd2luZG93IGlzICIgLiBidWZuYW1lKHdpbmJ1Zm5yKDApKQo8CgkJCQkJCQkqd2luY29sKCkqCndpbmNvbCgpCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSB2aXJ0dWFsIGNvbHVtbiBvZiB0aGUKCQljdXJzb3IgaW4gdGhlIHdpbmRvdy4gIFRoaXMgaXMgY291bnRpbmcgc2NyZWVuIGNlbGxzIGZyb20gdGhlCgkJbGVmdCBzaWRlIG9mIHRoZSB3aW5kb3cuICBUaGUgbGVmdG1vc3QgY29sdW1uIGlzIG9uZS4KCndpbmhlaWdodCh7bnJ9KQkJCQkJCSp3aW5oZWlnaHQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgaGVpZ2h0IG9mIHdpbmRvdyB7bnJ9LgoJCVdoZW4ge25yfSBpcyB6ZXJvLCB0aGUgaGVpZ2h0IG9mIHRoZSBjdXJyZW50IHdpbmRvdyBpcwoJCXJldHVybmVkLiAgV2hlbiB3aW5kb3cge25yfSBkb2Vzbid0IGV4aXN0LCAtMSBpcyByZXR1cm5lZC4KCQlBbiBleGlzdGluZyB3aW5kb3cgYWx3YXlzIGhhcyBhIGhlaWdodCBvZiB6ZXJvIG9yIG1vcmUuCgkJRXhhbXBsZXM6ID4KICA6ZWNobyAiVGhlIGN1cnJlbnQgd2luZG93IGhhcyAiIC4gd2luaGVpZ2h0KDApIC4gIiBsaW5lcy4iCjwKCQkJCQkJCSp3aW5saW5lKCkqCndpbmxpbmUoKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgc2NyZWVuIGxpbmUgb2YgdGhlIGN1cnNvcgoJCWluIHRoZSB3aW5kb3cuCVRoaXMgaXMgY291bnRpbmcgc2NyZWVuIGxpbmVzIGZyb20gdGhlIHRvcCBvZgoJCXRoZSB3aW5kb3cuICBUaGUgZmlyc3QgbGluZSBpcyBvbmUuCgkJSWYgdGhlIGN1cnNvciB3YXMgbW92ZWQgdGhlIHZpZXcgb24gdGhlIGZpbGUgd2lsbCBiZSB1cGRhdGVkCgkJZmlyc3QsIHRoaXMgbWF5IGNhdXNlIGEgc2Nyb2xsLgoKCQkJCQkJCSp3aW5ucigpKgp3aW5ucihbe2FyZ31dKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBjdXJyZW50CgkJd2luZG93LiAgVGhlIHRvcCB3aW5kb3cgaGFzIG51bWJlciAxLgoJCVdoZW4gdGhlIG9wdGlvbmFsIGFyZ3VtZW50IGlzICIkIiwgdGhlIG51bWJlciBvZiB0aGUKCQlsYXN0IHdpbmRvdyBpcyByZXR1cm5lZCAodGhlIHdpbmRvdyBjb3VudCkuID4KCQkJbGV0IHdpbmRvd19jb3VudCA9IHdpbm5yKCckJykKPAkJV2hlbiB0aGUgb3B0aW9uYWwgYXJndW1lbnQgaXMgIiMiLCB0aGUgbnVtYmVyIG9mIHRoZSBsYXN0CgkJYWNjZXNzZWQgd2luZG93IGlzIHJldHVybmVkICh3aGVyZSB8Q1RSTC1XX3B8IGdvZXMgdG8pLgoJCUlmIHRoZXJlIGlzIG5vIHByZXZpb3VzIHdpbmRvdyBvciBpdCBpcyBpbiBhbm90aGVyIHRhYiBwYWdlIDAKCQlpcyByZXR1cm5lZC4KCQlUaGUgbnVtYmVyIGNhbiBiZSB1c2VkIHdpdGggfENUUkwtV193fCBhbmQgIjp3aW5jbWQgdyIKCQl8OndpbmNtZHwuCgkJQWxzbyBzZWUgfHRhYnBhZ2V3aW5ucigpfC4KCgkJCQkJCQkqd2lucmVzdGNtZCgpKgp3aW5yZXN0Y21kKCkJUmV0dXJucyBhIHNlcXVlbmNlIG9mIHw6cmVzaXplfCBjb21tYW5kcyB0aGF0IHNob3VsZCByZXN0b3JlCgkJdGhlIGN1cnJlbnQgd2luZG93IHNpemVzLiAgT25seSB3b3JrcyBwcm9wZXJseSB3aGVuIG5vIHdpbmRvd3MKCQlhcmUgb3BlbmVkIG9yIGNsb3NlZCBhbmQgdGhlIGN1cnJlbnQgd2luZG93IGFuZCB0YWIgcGFnZSBpcwoJCXVuY2hhbmdlZC4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgY21kID0gd2lucmVzdGNtZCgpCgkJCTpjYWxsIE1lc3NXaXRoV2luZG93U2l6ZXMoKQoJCQk6ZXhlIGNtZAo8CgkJCQkJCQkqd2lucmVzdHZpZXcoKSoKd2lucmVzdHZpZXcoe2RpY3R9KQoJCVVzZXMgdGhlIHxEaWN0aW9uYXJ5fCByZXR1cm5lZCBieSB8d2luc2F2ZXZpZXcoKXwgdG8gcmVzdG9yZQoJCXRoZSB2aWV3IG9mIHRoZSBjdXJyZW50IHdpbmRvdy4KCQlOb3RlOiBUaGUge2RpY3R9IGRvZXMgbm90IGhhdmUgdG8gY29udGFpbiBhbGwgdmFsdWVzLCB0aGF0IGFyZQoJCXJldHVybmVkIGJ5IHx3aW5zYXZldmlldygpfC4gSWYgdmFsdWVzIGFyZSBtaXNzaW5nLCB0aG9zZQoJCXNldHRpbmdzIHdvbid0IGJlIHJlc3RvcmVkLiBTbyB5b3UgY2FuIHVzZTogPgoJCSAgICA6Y2FsbCB3aW5yZXN0dmlldyh7J2N1cnN3YW50JzogNH0pCjwKCQlUaGlzIHdpbGwgb25seSBzZXQgdGhlIGN1cnN3YW50IHZhbHVlICh0aGUgY29sdW1uIHRoZSBjdXJzb3IKCQl3YW50cyB0byBtb3ZlIG9uIHZlcnRpY2FsIG1vdmVtZW50cykgb2YgdGhlIGN1cnNvciB0byBjb2x1bW4gNQoJCSh5ZXMsIHRoYXQgaXMgNSksIHdoaWxlIGFsbCBvdGhlciBzZXR0aW5ncyB3aWxsIHJlbWFpbiB0aGUKCQlzYW1lLiBUaGlzIGlzIHVzZWZ1bCwgaWYgeW91IHNldCB0aGUgY3Vyc29yIHBvc2l0aW9uIG1hbnVhbGx5LgoKCQlJZiB5b3UgaGF2ZSBjaGFuZ2VkIHRoZSB2YWx1ZXMgdGhlIHJlc3VsdCBpcyB1bnByZWRpY3RhYmxlLgoJCUlmIHRoZSB3aW5kb3cgc2l6ZSBjaGFuZ2VkIHRoZSByZXN1bHQgd29uJ3QgYmUgdGhlIHNhbWUuCgoJCQkJCQkJKndpbnNhdmV2aWV3KCkqCndpbnNhdmV2aWV3KCkJUmV0dXJucyBhIHxEaWN0aW9uYXJ5fCB0aGF0IGNvbnRhaW5zIGluZm9ybWF0aW9uIHRvIHJlc3RvcmUKCQl0aGUgdmlldyBvZiB0aGUgY3VycmVudCB3aW5kb3cuICBVc2UgfHdpbnJlc3R2aWV3KCl8IHRvCgkJcmVzdG9yZSB0aGUgdmlldy4KCQlUaGlzIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBhIG1hcHBpbmcgdGhhdCBqdW1wcyBhcm91bmQgaW4gdGhlCgkJYnVmZmVyIGFuZCB5b3Ugd2FudCB0byBnbyBiYWNrIHRvIHRoZSBvcmlnaW5hbCB2aWV3LgoJCVRoaXMgZG9lcyBub3Qgc2F2ZSBmb2xkIGluZm9ybWF0aW9uLiAgVXNlIHRoZSAnZm9sZGVuYWJsZScKCQlvcHRpb24gdG8gdGVtcG9yYXJpbHkgc3dpdGNoIG9mZiBmb2xkaW5nLCBzbyB0aGF0IGZvbGRzIGFyZQoJCW5vdCBvcGVuZWQgd2hlbiBtb3ZpbmcgYXJvdW5kLiBUaGlzIG1heSBoYXZlIHNpZGUgZWZmZWN0cy4KCQlUaGUgcmV0dXJuIHZhbHVlIGluY2x1ZGVzOgoJCQlsbnVtCQljdXJzb3IgbGluZSBudW1iZXIKCQkJY29sCQljdXJzb3IgY29sdW1uIChOb3RlOiB0aGUgZmlyc3QgY29sdW1uCgkJCQkJemVybywgYXMgb3Bwb3NlZCB0byB3aGF0IGdldHBvcygpCgkJCQkJcmV0dXJucykKCQkJY29sYWRkCQljdXJzb3IgY29sdW1uIG9mZnNldCBmb3IgJ3ZpcnR1YWxlZGl0JwoJCQljdXJzd2FudAljb2x1bW4gZm9yIHZlcnRpY2FsIG1vdmVtZW50CgkJCXRvcGxpbmUJCWZpcnN0IGxpbmUgaW4gdGhlIHdpbmRvdwoJCQl0b3BmaWxsCQlmaWxsZXIgbGluZXMsIG9ubHkgaW4gZGlmZiBtb2RlCgkJCWxlZnRjb2wJCWZpcnN0IGNvbHVtbiBkaXNwbGF5ZWQKCQkJc2tpcGNvbAkJY29sdW1ucyBza2lwcGVkCgkJTm90ZSB0aGF0IG5vIG9wdGlvbiB2YWx1ZXMgYXJlIHNhdmVkLgoKCndpbndpZHRoKHtucn0pCQkJCQkJKndpbndpZHRoKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIHdpZHRoIG9mIHdpbmRvdyB7bnJ9LgoJCVdoZW4ge25yfSBpcyB6ZXJvLCB0aGUgd2lkdGggb2YgdGhlIGN1cnJlbnQgd2luZG93IGlzCgkJcmV0dXJuZWQuICBXaGVuIHdpbmRvdyB7bnJ9IGRvZXNuJ3QgZXhpc3QsIC0xIGlzIHJldHVybmVkLgoJCUFuIGV4aXN0aW5nIHdpbmRvdyBhbHdheXMgaGFzIGEgd2lkdGggb2YgemVybyBvciBtb3JlLgoJCUV4YW1wbGVzOiA+CiAgOmVjaG8gIlRoZSBjdXJyZW50IHdpbmRvdyBoYXMgIiAuIHdpbndpZHRoKDApIC4gIiBjb2x1bW5zLiIKICA6aWYgd2lud2lkdGgoMCkgPD0gNTAKICA6ICBleGUgIm5vcm1hbCA1MFw8Qy1XPnwiCiAgOmVuZGlmCjwKd29yZGNvdW50KCkJCQkJCQkqd29yZGNvdW50KCkqCgkJVGhlIHJlc3VsdCBpcyBhIGRpY3Rpb25hcnkgb2YgYnl0ZS9jaGFycy93b3JkIHN0YXRpc3RpY3MgZm9yCgkJdGhlIGN1cnJlbnQgYnVmZmVyLiAgVGhpcyBpcyB0aGUgc2FtZSBpbmZvIGFzIHByb3ZpZGVkIGJ5CgkJfGdfQ1RSTC1HfAoJCVRoZSByZXR1cm4gdmFsdWUgaW5jbHVkZXM6CgkJCWJ5dGVzCQlOdW1iZXIgb2YgYnl0ZXMgaW4gdGhlIGJ1ZmZlcgoJCQljaGFycwkJTnVtYmVyIG9mIGNoYXJzIGluIHRoZSBidWZmZXIKCQkJd29yZHMJCU51bWJlciBvZiB3b3JkcyBpbiB0aGUgYnVmZmVyCgkJCWN1cnNvcl9ieXRlcyAgICBOdW1iZXIgb2YgYnl0ZXMgYmVmb3JlIGN1cnNvciBwb3NpdGlvbgoJCQkJCShub3QgaW4gVmlzdWFsIG1vZGUpCgkJCWN1cnNvcl9jaGFycyAgICBOdW1iZXIgb2YgY2hhcnMgYmVmb3JlIGN1cnNvciBwb3NpdGlvbgoJCQkJCShub3QgaW4gVmlzdWFsIG1vZGUpCgkJCWN1cnNvcl93b3JkcyAgICBOdW1iZXIgb2Ygd29yZHMgYmVmb3JlIGN1cnNvciBwb3NpdGlvbgoJCQkJCShub3QgaW4gVmlzdWFsIG1vZGUpCgkJCXZpc3VhbF9ieXRlcyAgICBOdW1iZXIgb2YgYnl0ZXMgdmlzdWFsbHkgc2VsZWN0ZWQKCQkJICAgICAgICAgICAgICAgIChvbmx5IGluIFZpc3VhbCBtb2RlKQoJCQl2aXN1YWxfY2hhcnMgICAgTnVtYmVyIG9mIGNoYXJzIHZpc3VhbGx5IHNlbGVjdGVkCgkJCSAgICAgICAgICAgICAgICAob25seSBpbiBWaXN1YWwgbW9kZSkKCQkJdmlzdWFsX3dvcmRzICAgIE51bWJlciBvZiBjaGFycyB2aXN1YWxseSBzZWxlY3RlZAoJCQkgICAgICAgICAgICAgICAgKG9ubHkgaW4gVmlzdWFsIG1vZGUpCgoKCQkJCQkJCSp3cml0ZWZpbGUoKSoKd3JpdGVmaWxlKHtsaXN0fSwge2ZuYW1lfSBbLCB7ZmxhZ3N9XSkKCQlXcml0ZSB8TGlzdHwge2xpc3R9IHRvIGZpbGUge2ZuYW1lfS4gIEVhY2ggbGlzdCBpdGVtIGlzCgkJc2VwYXJhdGVkIHdpdGggYSBOTC4gIEVhY2ggbGlzdCBpdGVtIG11c3QgYmUgYSBTdHJpbmcgb3IKCQlOdW1iZXIuCgkJV2hlbiB7ZmxhZ3N9IGNvbnRhaW5zICJiIiB0aGVuIGJpbmFyeSBtb2RlIGlzIHVzZWQ6IFRoZXJlIHdpbGwKCQlub3QgYmUgYSBOTCBhZnRlciB0aGUgbGFzdCBsaXN0IGl0ZW0uICBBbiBlbXB0eSBpdGVtIGF0IHRoZQoJCWVuZCBkb2VzIGNhdXNlIHRoZSBsYXN0IGxpbmUgaW4gdGhlIGZpbGUgdG8gZW5kIGluIGEgTkwuCgoJCVdoZW4ge2ZsYWdzfSBjb250YWlucyAiYSIgdGhlbiBhcHBlbmQgbW9kZSBpcyB1c2VkLCBsaW5lcyBhcmUKCQlhcHBlbmQgdG8gdGhlIGZpbGU6ID4KCQkJOmNhbGwgd3JpdGVmaWxlKFsiZm9vIl0sICJldmVudC5sb2ciLCAiYSIpCgkJCTpjYWxsIHdyaXRlZmlsZShbImJhciJdLCAiZXZlbnQubG9nIiwgImEiKQo+CjwJCUFsbCBOTCBjaGFyYWN0ZXJzIGFyZSByZXBsYWNlZCB3aXRoIGEgTlVMIGNoYXJhY3Rlci4KCQlJbnNlcnRpbmcgQ1IgY2hhcmFjdGVycyBuZWVkcyB0byBiZSBkb25lIGJlZm9yZSBwYXNzaW5nIHtsaXN0fQoJCXRvIHdyaXRlZmlsZSgpLgoJCUFuIGV4aXN0aW5nIGZpbGUgaXMgb3ZlcndyaXR0ZW4sIGlmIHBvc3NpYmxlLgoJCVdoZW4gdGhlIHdyaXRlIGZhaWxzIC0xIGlzIHJldHVybmVkLCBvdGhlcndpc2UgMC4gIFRoZXJlIGlzIGFuCgkJZXJyb3IgbWVzc2FnZSBpZiB0aGUgZmlsZSBjYW4ndCBiZSBjcmVhdGVkIG9yIHdoZW4gd3JpdGluZwoJCWZhaWxzLgoJCUFsc28gc2VlIHxyZWFkZmlsZSgpfC4KCQlUbyBjb3B5IGEgZmlsZSBieXRlIGZvciBieXRlOiA+CgkJCTpsZXQgZmwgPSByZWFkZmlsZSgiZm9vIiwgImIiKQoJCQk6Y2FsbCB3cml0ZWZpbGUoZmwsICJmb29jb3B5IiwgImIiKQoKCnhvcih7ZXhwcn0sIHtleHByfSkJCQkJCSp4b3IoKSoKCQlCaXR3aXNlIFhPUiBvbiB0aGUgdHdvIGFyZ3VtZW50cy4gIFRoZSBhcmd1bWVudHMgYXJlIGNvbnZlcnRlZAoJCXRvIGEgbnVtYmVyLiAgQSBMaXN0LCBEaWN0IG9yIEZsb2F0IGFyZ3VtZW50IGNhdXNlcyBhbiBlcnJvci4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgYml0cyA9IHhvcihiaXRzLCAweDgwKQo8CgoKCQkJCQkJCSpmZWF0dXJlLWxpc3QqClRoZXJlIGFyZSBmb3VyIHR5cGVzIG9mIGZlYXR1cmVzOgoxLiAgRmVhdHVyZXMgdGhhdCBhcmUgb25seSBzdXBwb3J0ZWQgd2hlbiB0aGV5IGhhdmUgYmVlbiBlbmFibGVkIHdoZW4gVmltCiAgICB3YXMgY29tcGlsZWQgfCtmZWF0dXJlLWxpc3R8LiAgRXhhbXBsZTogPgoJOmlmIGhhcygiY2luZGVudCIpCjIuICBGZWF0dXJlcyB0aGF0IGFyZSBvbmx5IHN1cHBvcnRlZCB3aGVuIGNlcnRhaW4gY29uZGl0aW9ucyBoYXZlIGJlZW4gbWV0LgogICAgRXhhbXBsZTogPgoJOmlmIGhhcygiZ3VpX3J1bm5pbmciKQo8CQkJCQkJCSpoYXMtcGF0Y2gqCjMuICBJbmNsdWRlZCBwYXRjaGVzLiAgVGhlICJwYXRjaDEyMyIgZmVhdHVyZSBtZWFucyB0aGF0IHBhdGNoIDEyMyBoYXMgYmVlbgogICAgaW5jbHVkZWQuICBOb3RlIHRoYXQgdGhpcyBmb3JtIGRvZXMgbm90IGNoZWNrIHRoZSB2ZXJzaW9uIG9mIFZpbSwgeW91IG5lZWQKICAgIHRvIGluc3BlY3QgfHY6dmVyc2lvbnwgZm9yIHRoYXQuCiAgICBFeGFtcGxlIChjaGVja2luZyB2ZXJzaW9uIDYuMi4xNDggb3IgbGF0ZXIpOiA+Cgk6aWYgdjp2ZXJzaW9uID4gNjAyIHx8IHY6dmVyc2lvbiA9PSA2MDIgJiYgaGFzKCJwYXRjaDE0OCIpCjwgICAgTm90ZSB0aGF0IGl0J3MgcG9zc2libGUgZm9yIHBhdGNoIDE0NyB0byBiZSBvbWl0dGVkIGV2ZW4gdGhvdWdoIDE0OCBpcwogICAgaW5jbHVkZWQuCgo0LiAgQmV5b25kIGEgY2VydGFpbiB2ZXJzaW9uIG9yIGF0IGEgY2VydGFpbiB2ZXJzaW9uIGFuZCBpbmNsdWRpbmcgYSBzcGVjaWZpYwogICAgcGF0Y2guICBUaGUgInBhdGNoLTcuNC4yMzciIGZlYXR1cmUgbWVhbnMgdGhhdCB0aGUgVmltIHZlcnNpb24gaXMgNy41IG9yCiAgICBsYXRlciwgb3IgaXQgaXMgdmVyc2lvbiA3LjQgYW5kIHBhdGNoIDIzNyB3YXMgaW5jbHVkZWQuCiAgICBOb3RlIHRoYXQgdGhpcyBvbmx5IHdvcmtzIGZvciBwYXRjaCA3LjQuMjM3IGFuZCBsYXRlciwgYmVmb3JlIHRoYXQgeW91CiAgICBuZWVkIHRvIHVzZSB0aGUgZXhhbXBsZSBhYm92ZSB0aGF0IGNoZWNrcyB2OnZlcnNpb24uICBFeGFtcGxlOiA+Cgk6aWYgaGFzKCJwYXRjaC03LjQuMjQ4IikKPCAgICBOb3RlIHRoYXQgaXQncyBwb3NzaWJsZSBmb3IgcGF0Y2ggMTQ3IHRvIGJlIG9taXR0ZWQgZXZlbiB0aG91Z2ggMTQ4IGlzCiAgICBpbmNsdWRlZC4KCmFjbAkJCUNvbXBpbGVkIHdpdGggfEFDTHwgc3VwcG9ydC4KYWxsX2J1aWx0aW5fdGVybXMJQ29tcGlsZWQgd2l0aCBhbGwgYnVpbHRpbiB0ZXJtaW5hbHMgZW5hYmxlZC4KYW1pZ2EJCQlBbWlnYSB2ZXJzaW9uIG9mIFZpbS4KYXJhYmljCQkJQ29tcGlsZWQgd2l0aCBBcmFiaWMgc3VwcG9ydCB8QXJhYmljfC4KYXJwCQkJQ29tcGlsZWQgd2l0aCBBUlAgc3VwcG9ydCAoQW1pZ2EpLgphdXRvY21kCQkJQ29tcGlsZWQgd2l0aCBhdXRvY29tbWFuZCBzdXBwb3J0LiB8YXV0b2NvbW1hbmR8CmJhbGxvb25fZXZhbAkJQ29tcGlsZWQgd2l0aCB8YmFsbG9vbi1ldmFsfCBzdXBwb3J0LgpiYWxsb29uX211bHRpbGluZQlHVUkgc3VwcG9ydHMgbXVsdGlsaW5lIGJhbGxvb25zLgpiZW9zCQkJQmVPUyB2ZXJzaW9uIG9mIFZpbS4KYnJvd3NlCQkJQ29tcGlsZWQgd2l0aCB8OmJyb3dzZXwgc3VwcG9ydCwgYW5kIGJyb3dzZSgpIHdpbGwKCQkJd29yay4KYnJvd3NlZmlsdGVyCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHxicm93c2VmaWx0ZXJ8LgpidWlsdGluX3Rlcm1zCQlDb21waWxlZCB3aXRoIHNvbWUgYnVpbHRpbiB0ZXJtaW5hbHMuCmJ5dGVfb2Zmc2V0CQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yICdvJyBpbiAnc3RhdHVzbGluZScKY2luZGVudAkJCUNvbXBpbGVkIHdpdGggJ2NpbmRlbnQnIHN1cHBvcnQuCmNsaWVudHNlcnZlcgkJQ29tcGlsZWQgd2l0aCByZW1vdGUgaW52b2NhdGlvbiBzdXBwb3J0IHxjbGllbnRzZXJ2ZXJ8LgpjbGlwYm9hcmQJCUNvbXBpbGVkIHdpdGggJ2NsaXBib2FyZCcgc3VwcG9ydC4KY21kbGluZV9jb21wbAkJQ29tcGlsZWQgd2l0aCB8Y21kbGluZS1jb21wbGV0aW9ufCBzdXBwb3J0LgpjbWRsaW5lX2hpc3QJCUNvbXBpbGVkIHdpdGggfGNtZGxpbmUtaGlzdG9yeXwgc3VwcG9ydC4KY21kbGluZV9pbmZvCQlDb21waWxlZCB3aXRoICdzaG93Y21kJyBhbmQgJ3J1bGVyJyBzdXBwb3J0Lgpjb21tZW50cwkJQ29tcGlsZWQgd2l0aCB8J2NvbW1lbnRzJ3wgc3VwcG9ydC4KY29tcGF0aWJsZQkJQ29tcGlsZWQgdG8gYmUgdmVyeSBWaSBjb21wYXRpYmxlLgpjcnlwdHYJCQlDb21waWxlZCB3aXRoIGVuY3J5cHRpb24gc3VwcG9ydCB8ZW5jcnlwdGlvbnwuCmNzY29wZQkJCUNvbXBpbGVkIHdpdGggfGNzY29wZXwgc3VwcG9ydC4KZGVidWcJCQlDb21waWxlZCB3aXRoICJERUJVRyIgZGVmaW5lZC4KZGlhbG9nX2NvbgkJQ29tcGlsZWQgd2l0aCBjb25zb2xlIGRpYWxvZyBzdXBwb3J0LgpkaWFsb2dfZ3VpCQlDb21waWxlZCB3aXRoIEdVSSBkaWFsb2cgc3VwcG9ydC4KZGlmZgkJCUNvbXBpbGVkIHdpdGggfHZpbWRpZmZ8IGFuZCAnZGlmZicgc3VwcG9ydC4KZGlncmFwaHMJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgZGlncmFwaHMuCmRpcmVjdHgJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIERpcmVjdC1YIGFuZCAncmVuZGVyb3B0aW9ucycuCmRuZAkJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgdGhlICJ+IHJlZ2lzdGVyIHxxdW90ZV9+fC4KZG9zMTYJCQkxNiBiaXRzIERPUyB2ZXJzaW9uIG9mIFZpbS4KZG9zMzIJCQkzMiBiaXRzIERPUyAoREpHUFApIHZlcnNpb24gb2YgVmltLgplYmNkaWMJCQlDb21waWxlZCBvbiBhIG1hY2hpbmUgd2l0aCBlYmNkaWMgY2hhcmFjdGVyIHNldC4KZW1hY3NfdGFncwkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBFbWFjcyB0YWdzLgpldmFsCQkJQ29tcGlsZWQgd2l0aCBleHByZXNzaW9uIGV2YWx1YXRpb24gc3VwcG9ydC4gIEFsd2F5cwoJCQl0cnVlLCBvZiBjb3Vyc2UhCmV4X2V4dHJhCQl8K2V4X2V4dHJhfCwgYWx3YXlzIHRydWUgbm93CmV4dHJhX3NlYXJjaAkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciB8J2luY3NlYXJjaCd8IGFuZAoJCQl8J2hsc2VhcmNoJ3wKZmFyc2kJCQlDb21waWxlZCB3aXRoIEZhcnNpIHN1cHBvcnQgfGZhcnNpfC4KZmlsZV9pbl9wYXRoCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHxnZnwgYW5kIHw8Y2ZpbGU+fApmaWx0ZXJwaXBlCQlXaGVuICdzaGVsbHRlbXAnIGlzIG9mZiBwaXBlcyBhcmUgdXNlZCBmb3Igc2hlbGwKCQkJcmVhZC93cml0ZS9maWx0ZXIgY29tbWFuZHMKZmluZF9pbl9wYXRoCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIGluY2x1ZGUgZmlsZSBzZWFyY2hlcwoJCQl8K2ZpbmRfaW5fcGF0aHwuCmZsb2F0CQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciB8RmxvYXR8LgpmbmFtZV9jYXNlCQlDYXNlIGluIGZpbGUgbmFtZXMgbWF0dGVycyAoZm9yIEFtaWdhLCBNUy1ET1MsIGFuZAoJCQlXaW5kb3dzIHRoaXMgaXMgbm90IHByZXNlbnQpLgpmb2xkaW5nCQkJQ29tcGlsZWQgd2l0aCB8Zm9sZGluZ3wgc3VwcG9ydC4KZm9vdGVyCQkJQ29tcGlsZWQgd2l0aCBHVUkgZm9vdGVyIHN1cHBvcnQuIHxndWktZm9vdGVyfApmb3JrCQkJQ29tcGlsZWQgdG8gdXNlIGZvcmsoKS9leGVjKCkgaW5zdGVhZCBvZiBzeXN0ZW0oKS4KZ2V0dGV4dAkJCUNvbXBpbGVkIHdpdGggbWVzc2FnZSB0cmFuc2xhdGlvbiB8bXVsdGktbGFuZ3wKZ3VpCQkJQ29tcGlsZWQgd2l0aCBHVUkgZW5hYmxlZC4KZ3VpX2F0aGVuYQkJQ29tcGlsZWQgd2l0aCBBdGhlbmEgR1VJLgpndWlfZ25vbWUJCUNvbXBpbGVkIHdpdGggR25vbWUgc3VwcG9ydCAoZ3VpX2d0ayBpcyBhbHNvIGRlZmluZWQpLgpndWlfZ3RrCQkJQ29tcGlsZWQgd2l0aCBHVEsrIEdVSSAoYW55IHZlcnNpb24pLgpndWlfZ3RrMgkJQ29tcGlsZWQgd2l0aCBHVEsrIDIgR1VJIChndWlfZ3RrIGlzIGFsc28gZGVmaW5lZCkuCmd1aV9ndGszCQlDb21waWxlZCB3aXRoIEdUSysgMyBHVUkgKGd1aV9ndGsgaXMgYWxzbyBkZWZpbmVkKS4KZ3VpX21hYwkJCUNvbXBpbGVkIHdpdGggTWFjaW50b3NoIEdVSS4KZ3VpX21vdGlmCQlDb21waWxlZCB3aXRoIE1vdGlmIEdVSS4KZ3VpX3Bob3RvbgkJQ29tcGlsZWQgd2l0aCBQaG90b24gR1VJLgpndWlfcnVubmluZwkJVmltIGlzIHJ1bm5pbmcgaW4gdGhlIEdVSSwgb3IgaXQgd2lsbCBzdGFydCBzb29uLgpndWlfd2luMzIJCUNvbXBpbGVkIHdpdGggTVMgV2luZG93cyBXaW4zMiBHVUkuCmd1aV93aW4zMnMJCWlkZW0sIGFuZCBXaW4zMnMgc3lzdGVtIGJlaW5nIHVzZWQgKFdpbmRvd3MgMy4xKQpoYW5ndWxfaW5wdXQJCUNvbXBpbGVkIHdpdGggSGFuZ3VsIGlucHV0IHN1cHBvcnQuIHxoYW5ndWx8Cmljb252CQkJQ2FuIHVzZSBpY29udigpIGZvciBjb252ZXJzaW9uLgppbnNlcnRfZXhwYW5kCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIENUUkwtWCBleHBhbnNpb24gY29tbWFuZHMgaW4KCQkJSW5zZXJ0IG1vZGUuCmp1bXBsaXN0CQlDb21waWxlZCB3aXRoIHxqdW1wbGlzdHwgc3VwcG9ydC4Ka2V5bWFwCQkJQ29tcGlsZWQgd2l0aCAna2V5bWFwJyBzdXBwb3J0LgpsYW5nbWFwCQkJQ29tcGlsZWQgd2l0aCAnbGFuZ21hcCcgc3VwcG9ydC4KbGliY2FsbAkJCUNvbXBpbGVkIHdpdGggfGxpYmNhbGwoKXwgc3VwcG9ydC4KbGluZWJyZWFrCQlDb21waWxlZCB3aXRoICdsaW5lYnJlYWsnLCAnYnJlYWthdCcsICdzaG93YnJlYWsnIGFuZAoJCQknYnJlYWtpbmRlbnQnIHN1cHBvcnQuCmxpc3BpbmRlbnQJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgbGlzcCBpbmRlbnRpbmcuCmxpc3RjbWRzCQlDb21waWxlZCB3aXRoIGNvbW1hbmRzIGZvciB0aGUgYnVmZmVyIGxpc3QgfDpmaWxlc3wKCQkJYW5kIHRoZSBhcmd1bWVudCBsaXN0IHxhcmdsaXN0fC4KbG9jYWxtYXAJCUNvbXBpbGVkIHdpdGggbG9jYWwgbWFwcGluZ3MgYW5kIGFiYnIuIHw6bWFwLWxvY2FsfApsdWEJCQlDb21waWxlZCB3aXRoIEx1YSBpbnRlcmZhY2UgfEx1YXwuCm1hYwkJCUFueSBNYWNpbnRvc2ggdmVyc2lvbiBvZiBWaW0uCm1hY3VuaXgJCQlDb21waWxlZCBmb3IgT1MgWCwgd2l0aCBkYXJ3aW4Kb3N4CQkJQ29tcGlsZWQgZm9yIE9TIFgsIHdpdGggb3Igd2l0aG91dCBkYXJ3aW4KbWVudQkJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgfDptZW51fC4KbWtzZXNzaW9uCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHw6bWtzZXNzaW9ufC4KbW9kaWZ5X2ZuYW1lCQlDb21waWxlZCB3aXRoIGZpbGUgbmFtZSBtb2RpZmllcnMuIHxmaWxlbmFtZS1tb2RpZmllcnN8Cm1vdXNlCQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IG1vdXNlLgptb3VzZV9kZWMJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgRGVjIHRlcm1pbmFsIG1vdXNlLgptb3VzZV9ncG0JCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgZ3BtIChMaW51eCBjb25zb2xlIG1vdXNlKQptb3VzZV9uZXR0ZXJtCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIG5ldHRlcm0gbW91c2UuCm1vdXNlX3B0ZXJtCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHFueCBwdGVybSBtb3VzZS4KbW91c2Vfc3lzbW91c2UJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3Igc3lzbW91c2UgKCpCU0QgY29uc29sZSBtb3VzZSkKbW91c2Vfc2dyCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHNnciBtb3VzZS4KbW91c2VfdXJ4dnQJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgdXJ4dnQgbW91c2UuCm1vdXNlX3h0ZXJtCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHh0ZXJtIG1vdXNlLgptb3VzZXNoYXBlCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yICdtb3VzZXNoYXBlJy4KbXVsdGlfYnl0ZQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciAnZW5jb2RpbmcnCm11bHRpX2J5dGVfZW5jb2RpbmcJJ2VuY29kaW5nJyBpcyBzZXQgdG8gYSBtdWx0aS1ieXRlIGVuY29kaW5nLgptdWx0aV9ieXRlX2ltZQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBJTUUgaW5wdXQgbWV0aG9kLgptdWx0aV9sYW5nCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIG11bHRpcGxlIGxhbmd1YWdlcy4KbXpzY2hlbWUJCUNvbXBpbGVkIHdpdGggTXpTY2hlbWUgaW50ZXJmYWNlIHxtenNjaGVtZXwuCm5ldGJlYW5zX2VuYWJsZWQJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciB8bmV0YmVhbnN8IGFuZCBjb25uZWN0ZWQuCm5ldGJlYW5zX2ludGcJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgfG5ldGJlYW5zfC4Kb2xlCQkJQ29tcGlsZWQgd2l0aCBPTEUgYXV0b21hdGlvbiBzdXBwb3J0IGZvciBXaW4zMi4Kb3MyCQkJT1MvMiB2ZXJzaW9uIG9mIFZpbS4KcGFja2FnZXMJCUNvbXBpbGVkIHdpdGggfHBhY2thZ2VzfCBzdXBwb3J0LgpwYXRoX2V4dHJhCQlDb21waWxlZCB3aXRoIHVwL2Rvd253YXJkcyBzZWFyY2ggaW4gJ3BhdGgnIGFuZCAndGFncycKcGVybAkJCUNvbXBpbGVkIHdpdGggUGVybCBpbnRlcmZhY2UuCnBlcnNpc3RlbnRfdW5kbwkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBwZXJzaXN0ZW50IHVuZG8gaGlzdG9yeS4KcG9zdHNjcmlwdAkJQ29tcGlsZWQgd2l0aCBQb3N0U2NyaXB0IGZpbGUgcHJpbnRpbmcuCnByaW50ZXIJCQlDb21waWxlZCB3aXRoIHw6aGFyZGNvcHl8IHN1cHBvcnQuCnByb2ZpbGUJCQlDb21waWxlZCB3aXRoIHw6cHJvZmlsZXwgc3VwcG9ydC4KcHl0aG9uCQkJQ29tcGlsZWQgd2l0aCBQeXRob24gMi54IGludGVyZmFjZS4gfGhhcy1weXRob258CnB5dGhvbjMJCQlDb21waWxlZCB3aXRoIFB5dGhvbiAzLnggaW50ZXJmYWNlLiB8aGFzLXB5dGhvbnwKcW54CQkJUU5YIHZlcnNpb24gb2YgVmltLgpxdWlja2ZpeAkJQ29tcGlsZWQgd2l0aCB8cXVpY2tmaXh8IHN1cHBvcnQuCnJlbHRpbWUJCQlDb21waWxlZCB3aXRoIHxyZWx0aW1lKCl8IHN1cHBvcnQuCnJpZ2h0bGVmdAkJQ29tcGlsZWQgd2l0aCAncmlnaHRsZWZ0JyBzdXBwb3J0LgpydWJ5CQkJQ29tcGlsZWQgd2l0aCBSdWJ5IGludGVyZmFjZSB8cnVieXwuCnNjcm9sbGJpbmQJCUNvbXBpbGVkIHdpdGggJ3Njcm9sbGJpbmQnIHN1cHBvcnQuCnNob3djbWQJCQlDb21waWxlZCB3aXRoICdzaG93Y21kJyBzdXBwb3J0LgpzaWducwkJCUNvbXBpbGVkIHdpdGggfDpzaWdufCBzdXBwb3J0LgpzbWFydGluZGVudAkJQ29tcGlsZWQgd2l0aCAnc21hcnRpbmRlbnQnIHN1cHBvcnQuCnNwZWxsCQkJQ29tcGlsZWQgd2l0aCBzcGVsbCBjaGVja2luZyBzdXBwb3J0IHxzcGVsbHwuCnN0YXJ0dXB0aW1lCQlDb21waWxlZCB3aXRoIHwtLXN0YXJ0dXB0aW1lfCBzdXBwb3J0LgpzdGF0dXNsaW5lCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yICdzdGF0dXNsaW5lJywgJ3J1bGVyZm9ybWF0JwoJCQlhbmQgc3BlY2lhbCBmb3JtYXRzIG9mICd0aXRsZXN0cmluZycgYW5kICdpY29uc3RyaW5nJy4Kc3VuX3dvcmtzaG9wCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIFN1biB8d29ya3Nob3B8LgpzeW50YXgJCQlDb21waWxlZCB3aXRoIHN5bnRheCBoaWdobGlnaHRpbmcgc3VwcG9ydCB8c3ludGF4fC4Kc3ludGF4X2l0ZW1zCQlUaGVyZSBhcmUgYWN0aXZlIHN5bnRheCBoaWdobGlnaHRpbmcgaXRlbXMgZm9yIHRoZQoJCQljdXJyZW50IGJ1ZmZlci4Kc3lzdGVtCQkJQ29tcGlsZWQgdG8gdXNlIHN5c3RlbSgpIGluc3RlYWQgb2YgZm9yaygpL2V4ZWMoKS4KdGFnX2JpbmFyeQkJQ29tcGlsZWQgd2l0aCBiaW5hcnkgc2VhcmNoaW5nIGluIHRhZ3MgZmlsZXMKCQkJfHRhZy1iaW5hcnktc2VhcmNofC4KdGFnX29sZF9zdGF0aWMJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3Igb2xkIHN0YXRpYyB0YWdzCgkJCXx0YWctb2xkLXN0YXRpY3wuCnRhZ19hbnlfd2hpdGUJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgYW55IHdoaXRlIGNoYXJhY3RlcnMgaW4gdGFncwoJCQlmaWxlcyB8dGFnLWFueS13aGl0ZXwuCnRjbAkJCUNvbXBpbGVkIHdpdGggVGNsIGludGVyZmFjZS4KdGVybWd1aWNvbG9ycwkJQ29tcGlsZWQgd2l0aCB0cnVlIGNvbG9yIGluIHRlcm1pbmFsIHN1cHBvcnQuCnRlcm1pbmZvCQlDb21waWxlZCB3aXRoIHRlcm1pbmZvIGluc3RlYWQgb2YgdGVybWNhcC4KdGVybXJlc3BvbnNlCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHx0X1JWfCBhbmQgfHY6dGVybXJlc3BvbnNlfC4KdGV4dG9iamVjdHMJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgfHRleHQtb2JqZWN0c3wuCnRnZXRlbnQJCQlDb21waWxlZCB3aXRoIHRnZXRlbnQgc3VwcG9ydCwgYWJsZSB0byB1c2UgYSB0ZXJtY2FwCgkJCW9yIHRlcm1pbmZvIGZpbGUuCnRpbWVycwkJCUNvbXBpbGVkIHdpdGggfHRpbWVyX3N0YXJ0KCl8IHN1cHBvcnQuCnRpdGxlCQkJQ29tcGlsZWQgd2l0aCB3aW5kb3cgdGl0bGUgc3VwcG9ydCB8J3RpdGxlJ3wuCnRvb2xiYXIJCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHxndWktdG9vbGJhcnwuCnVuaXgJCQlVbml4IHZlcnNpb24gb2YgVmltLgp1c2VyX2NvbW1hbmRzCQlVc2VyLWRlZmluZWQgY29tbWFuZHMuCnZlcnRzcGxpdAkJQ29tcGlsZWQgd2l0aCB2ZXJ0aWNhbGx5IHNwbGl0IHdpbmRvd3MgfDp2c3BsaXR8Lgp2aW1fc3RhcnRpbmcJCVRydWUgd2hpbGUgaW5pdGlhbCBzb3VyY2UnaW5nIHRha2VzIHBsYWNlLiB8c3RhcnR1cHwKCQkJKnZpbV9zdGFydGluZyoKdmltaW5mbwkJCUNvbXBpbGVkIHdpdGggdmltaW5mbyBzdXBwb3J0Lgp2aXJ0dWFsZWRpdAkJQ29tcGlsZWQgd2l0aCAndmlydHVhbGVkaXQnIG9wdGlvbi4KdmlzdWFsCQkJQ29tcGlsZWQgd2l0aCBWaXN1YWwgbW9kZS4KdmlzdWFsZXh0cmEJCUNvbXBpbGVkIHdpdGggZXh0cmEgVmlzdWFsIG1vZGUgY29tbWFuZHMuCgkJCXxibG9ja3dpc2Utb3BlcmF0b3JzfC4Kdm1zCQkJVk1TIHZlcnNpb24gb2YgVmltLgp2cmVwbGFjZQkJQ29tcGlsZWQgd2l0aCB8Z1J8IGFuZCB8Z3J8IGNvbW1hbmRzLgp3aWxkaWdub3JlCQlDb21waWxlZCB3aXRoICd3aWxkaWdub3JlJyBvcHRpb24uCndpbGRtZW51CQlDb21waWxlZCB3aXRoICd3aWxkbWVudScgb3B0aW9uLgp3aW4zMgkJCVdpbjMyIHZlcnNpb24gb2YgVmltIChNUy1XaW5kb3dzIDk1IGFuZCBsYXRlciwgMzIgb3IKCQkJNjQgYml0cykKd2luMzJ1bml4CQlXaW4zMiB2ZXJzaW9uIG9mIFZpbSwgdXNpbmcgVW5peCBmaWxlcyAoQ3lnd2luKQp3aW42NAkJCVdpbjY0IHZlcnNpb24gb2YgVmltIChNUy1XaW5kb3dzIDY0IGJpdCkuCndpbjk1CQkJV2luMzIgdmVyc2lvbiBmb3IgTVMtV2luZG93cyA5NS85OC9NRS4Kd2luYWx0a2V5cwkJQ29tcGlsZWQgd2l0aCAnd2luYWx0a2V5cycgb3B0aW9uLgp3aW5kb3dzCQkJQ29tcGlsZWQgd2l0aCBzdXBwb3J0IGZvciBtb3JlIHRoYW4gb25lIHdpbmRvdy4Kd3JpdGViYWNrdXAJCUNvbXBpbGVkIHdpdGggJ3dyaXRlYmFja3VwJyBkZWZhdWx0IG9uLgp4Zm9udHNldAkJQ29tcGlsZWQgd2l0aCBYIGZvbnRzZXQgc3VwcG9ydCB8eGZvbnRzZXR8Lgp4aW0JCQlDb21waWxlZCB3aXRoIFggaW5wdXQgbWV0aG9kIHN1cHBvcnQgfHhpbXwuCnhwbQkJCUNvbXBpbGVkIHdpdGggcGl4bWFwIHN1cHBvcnQuCnhwbV93MzIJCQlDb21waWxlZCB3aXRoIHBpeG1hcCBzdXBwb3J0IGZvciBXaW4zMi4gKE9ubHkgZm9yCgkJCWJhY2t3YXJkIGNvbXBhdGliaWxpdHkuIFVzZSAieHBtIiBpbnN0ZWFkLikKeHNtcAkJCUNvbXBpbGVkIHdpdGggWCBzZXNzaW9uIG1hbmFnZW1lbnQgc3VwcG9ydC4KeHNtcF9pbnRlcmFjdAkJQ29tcGlsZWQgd2l0aCBpbnRlcmFjdGl2ZSBYIHNlc3Npb24gbWFuYWdlbWVudCBzdXBwb3J0Lgp4dGVybV9jbGlwYm9hcmQJCUNvbXBpbGVkIHdpdGggc3VwcG9ydCBmb3IgeHRlcm0gY2xpcGJvYXJkLgp4dGVybV9zYXZlCQlDb21waWxlZCB3aXRoIHN1cHBvcnQgZm9yIHNhdmluZyBhbmQgcmVzdG9yaW5nIHRoZQoJCQl4dGVybSBzY3JlZW4uCngxMQkJCUNvbXBpbGVkIHdpdGggWDExIHN1cHBvcnQuCgoJCQkJCQkJKnN0cmluZy1tYXRjaCoKTWF0Y2hpbmcgYSBwYXR0ZXJuIGluIGEgU3RyaW5nCgpBIHJlZ2V4cCBwYXR0ZXJuIGFzIGV4cGxhaW5lZCBhdCB8cGF0dGVybnwgaXMgbm9ybWFsbHkgdXNlZCB0byBmaW5kIGEgbWF0Y2ggaW4KdGhlIGJ1ZmZlciBsaW5lcy4gIFdoZW4gYSBwYXR0ZXJuIGlzIHVzZWQgdG8gZmluZCBhIG1hdGNoIGluIGEgU3RyaW5nLCBhbG1vc3QKZXZlcnl0aGluZyB3b3JrcyBpbiB0aGUgc2FtZSB3YXkuICBUaGUgZGlmZmVyZW5jZSBpcyB0aGF0IGEgU3RyaW5nIGlzIGhhbmRsZWQKbGlrZSBpdCBpcyBvbmUgbGluZS4gIFdoZW4gaXQgY29udGFpbnMgYSAiXG4iIGNoYXJhY3RlciwgdGhpcyBpcyBub3Qgc2VlbiBhcyBhCmxpbmUgYnJlYWsgZm9yIHRoZSBwYXR0ZXJuLiAgSXQgY2FuIGJlIG1hdGNoZWQgd2l0aCBhICJcbiIgaW4gdGhlIHBhdHRlcm4sIG9yCndpdGggIi4iLiAgRXhhbXBsZTogPgoJOmxldCBhID0gImFhYWFcbnh4eHgiCgk6ZWNobyBtYXRjaHN0cihhLCAiLi5cbi4uIikKCWFhCgl4eAoJOmVjaG8gbWF0Y2hzdHIoYSwgImEueCIpCglhCgl4CgpEb24ndCBmb3JnZXQgdGhhdCAiXiIgd2lsbCBvbmx5IG1hdGNoIGF0IHRoZSBmaXJzdCBjaGFyYWN0ZXIgb2YgdGhlIFN0cmluZyBhbmQKIiQiIGF0IHRoZSBsYXN0IGNoYXJhY3RlciBvZiB0aGUgc3RyaW5nLiAgVGhleSBkb24ndCBtYXRjaCBhZnRlciBvciBiZWZvcmUgYQoiXG4iLgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjUuIERlZmluaW5nIGZ1bmN0aW9ucwkJCQkJKnVzZXItZnVuY3Rpb25zKgoKTmV3IGZ1bmN0aW9ucyBjYW4gYmUgZGVmaW5lZC4gIFRoZXNlIGNhbiBiZSBjYWxsZWQganVzdCBsaWtlIGJ1aWx0aW4KZnVuY3Rpb25zLiAgVGhlIGZ1bmN0aW9uIGV4ZWN1dGVzIGEgc2VxdWVuY2Ugb2YgRXggY29tbWFuZHMuICBOb3JtYWwgbW9kZQpjb21tYW5kcyBjYW4gYmUgZXhlY3V0ZWQgd2l0aCB0aGUgfDpub3JtYWx8IGNvbW1hbmQuCgpUaGUgZnVuY3Rpb24gbmFtZSBtdXN0IHN0YXJ0IHdpdGggYW4gdXBwZXJjYXNlIGxldHRlciwgdG8gYXZvaWQgY29uZnVzaW9uIHdpdGgKYnVpbHRpbiBmdW5jdGlvbnMuICBUbyBwcmV2ZW50IGZyb20gdXNpbmcgdGhlIHNhbWUgbmFtZSBpbiBkaWZmZXJlbnQgc2NyaXB0cwphdm9pZCBvYnZpb3VzLCBzaG9ydCBuYW1lcy4gIEEgZ29vZCBoYWJpdCBpcyB0byBzdGFydCB0aGUgZnVuY3Rpb24gbmFtZSB3aXRoCnRoZSBuYW1lIG9mIHRoZSBzY3JpcHQsIGUuZy4sICJIVE1MY29sb3IoKSIuCgpJdCdzIGFsc28gcG9zc2libGUgdG8gdXNlIGN1cmx5IGJyYWNlcywgc2VlIHxjdXJseS1icmFjZXMtbmFtZXN8LiAgQW5kIHRoZQp8YXV0b2xvYWR8IGZhY2lsaXR5IGlzIHVzZWZ1bCB0byBkZWZpbmUgYSBmdW5jdGlvbiBvbmx5IHdoZW4gaXQncyBjYWxsZWQuCgoJCQkJCQkJKmxvY2FsLWZ1bmN0aW9uKgpBIGZ1bmN0aW9uIGxvY2FsIHRvIGEgc2NyaXB0IG11c3Qgc3RhcnQgd2l0aCAiczoiLiAgQSBsb2NhbCBzY3JpcHQgZnVuY3Rpb24KY2FuIG9ubHkgYmUgY2FsbGVkIGZyb20gd2l0aGluIHRoZSBzY3JpcHQgYW5kIGZyb20gZnVuY3Rpb25zLCB1c2VyIGNvbW1hbmRzCmFuZCBhdXRvY29tbWFuZHMgZGVmaW5lZCBpbiB0aGUgc2NyaXB0LiAgSXQgaXMgYWxzbyBwb3NzaWJsZSB0byBjYWxsIHRoZQpmdW5jdGlvbiBmcm9tIGEgbWFwcGluZyBkZWZpbmVkIGluIHRoZSBzY3JpcHQsIGJ1dCB0aGVuIHw8U0lEPnwgbXVzdCBiZSB1c2VkCmluc3RlYWQgb2YgInM6IiB3aGVuIHRoZSBtYXBwaW5nIGlzIGV4cGFuZGVkIG91dHNpZGUgb2YgdGhlIHNjcmlwdC4KVGhlcmUgYXJlIG9ubHkgc2NyaXB0LWxvY2FsIGZ1bmN0aW9ucywgbm8gYnVmZmVyLWxvY2FsIG9yIHdpbmRvdy1sb2NhbApmdW5jdGlvbnMuCgoJCQkJCSo6ZnUqICo6ZnVuY3Rpb24qICpFMTI4KiAqRTEyOSogKkUxMjMqCjpmdVtuY3Rpb25dCQlMaXN0IGFsbCBmdW5jdGlvbnMgYW5kIHRoZWlyIGFyZ3VtZW50cy4KCjpmdVtuY3Rpb25dIHtuYW1lfQlMaXN0IGZ1bmN0aW9uIHtuYW1lfS4KCQkJe25hbWV9IGNhbiBhbHNvIGJlIGEgfERpY3Rpb25hcnl8IGVudHJ5IHRoYXQgaXMgYQoJCQl8RnVuY3JlZnw6ID4KCQkJCTpmdW5jdGlvbiBkaWN0LmluaXQKCjpmdVtuY3Rpb25dIC97cGF0dGVybn0JTGlzdCBmdW5jdGlvbnMgd2l0aCBhIG5hbWUgbWF0Y2hpbmcge3BhdHRlcm59LgoJCQlFeGFtcGxlIHRoYXQgbGlzdHMgYWxsIGZ1bmN0aW9ucyBlbmRpbmcgd2l0aCAiRmlsZSI6ID4KCQkJCTpmdW5jdGlvbiAvRmlsZSQKPAoJCQkJCQkJKjpmdW5jdGlvbi12ZXJib3NlKgpXaGVuICd2ZXJib3NlJyBpcyBub24temVybywgbGlzdGluZyBhIGZ1bmN0aW9uIHdpbGwgYWxzbyBkaXNwbGF5IHdoZXJlIGl0IHdhcwpsYXN0IGRlZmluZWQuIEV4YW1wbGU6ID4KCiAgICA6dmVyYm9zZSBmdW5jdGlvbiBTZXRGaWxlVHlwZVNICglmdW5jdGlvbiBTZXRGaWxlVHlwZVNIKG5hbWUpCgkgICAgTGFzdCBzZXQgZnJvbSAvdXNyL3NoYXJlL3ZpbS92aW0tNy4wL2ZpbGV0eXBlLnZpbQo8ClNlZSB8OnZlcmJvc2UtY21kfCBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KCgkJCQkJCSpFMTI0KiAqRTEyNSogKkU4NTMqICpFODg0Kgo6ZnVbbmN0aW9uXVshXSB7bmFtZX0oW2FyZ3VtZW50c10pIFtyYW5nZV0gW2Fib3J0XSBbZGljdF0KCQkJRGVmaW5lIGEgbmV3IGZ1bmN0aW9uIGJ5IHRoZSBuYW1lIHtuYW1lfS4gIFRoZSBuYW1lCgkJCW11c3QgYmUgbWFkZSBvZiBhbHBoYW51bWVyaWMgY2hhcmFjdGVycyBhbmQgJ18nLCBhbmQKCQkJbXVzdCBzdGFydCB3aXRoIGEgY2FwaXRhbCBvciAiczoiIChzZWUgYWJvdmUpLiAgTm90ZQoJCQl0aGF0IHVzaW5nICJiOiIgb3IgImc6IiBpcyBub3QgYWxsb3dlZC4gKHNpbmNlIHBhdGNoCgkJCTcuNC4yNjAgRTg4NCBpcyBnaXZlbiBpZiB0aGUgZnVuY3Rpb24gbmFtZSBoYXMgYSBjb2xvbgoJCQlpbiB0aGUgbmFtZSwgZS5nLiBmb3IgImZvbzpiYXIoKSIuICBCZWZvcmUgdGhhdCBwYXRjaAoJCQlubyBlcnJvciB3YXMgZ2l2ZW4pLgoKCQkJe25hbWV9IGNhbiBhbHNvIGJlIGEgfERpY3Rpb25hcnl8IGVudHJ5IHRoYXQgaXMgYQoJCQl8RnVuY3JlZnw6ID4KCQkJCTpmdW5jdGlvbiBkaWN0LmluaXQoYXJnKQo8CQkJImRpY3QiIG11c3QgYmUgYW4gZXhpc3RpbmcgZGljdGlvbmFyeS4JVGhlIGVudHJ5CgkJCSJpbml0IiBpcyBhZGRlZCBpZiBpdCBkaWRuJ3QgZXhpc3QgeWV0LiAgT3RoZXJ3aXNlIFshXQoJCQlpcyByZXF1aXJlZCB0byBvdmVyd3JpdGUgYW4gZXhpc3RpbmcgZnVuY3Rpb24uCVRoZQoJCQlyZXN1bHQgaXMgYSB8RnVuY3JlZnwgdG8gYSBudW1iZXJlZCBmdW5jdGlvbi4gIFRoZQoJCQlmdW5jdGlvbiBjYW4gb25seSBiZSB1c2VkIHdpdGggYSB8RnVuY3JlZnwgYW5kIHdpbGwgYmUKCQkJZGVsZXRlZCBpZiB0aGVyZSBhcmUgbm8gbW9yZSByZWZlcmVuY2VzIHRvIGl0LgoJCQkJCQkJCSpFMTI3KiAqRTEyMioKCQkJV2hlbiBhIGZ1bmN0aW9uIGJ5IHRoaXMgbmFtZSBhbHJlYWR5IGV4aXN0cyBhbmQgWyFdIGlzCgkJCW5vdCB1c2VkIGFuIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4uICBXaGVuIFshXSBpcyB1c2VkLAoJCQlhbiBleGlzdGluZyBmdW5jdGlvbiBpcyBzaWxlbnRseSByZXBsYWNlZC4gIFVubGVzcyBpdAoJCQlpcyBjdXJyZW50bHkgYmVpbmcgZXhlY3V0ZWQsIHRoYXQgaXMgYW4gZXJyb3IuCgoJCQlGb3IgdGhlIHthcmd1bWVudHN9IHNlZSB8ZnVuY3Rpb24tYXJndW1lbnR8LgoKCQkJCQkqOmZ1bmMtcmFuZ2UqICphOmZpcnN0bGluZSogKmE6bGFzdGxpbmUqCgkJCVdoZW4gdGhlIFtyYW5nZV0gYXJndW1lbnQgaXMgYWRkZWQsIHRoZSBmdW5jdGlvbiBpcwoJCQlleHBlY3RlZCB0byB0YWtlIGNhcmUgb2YgYSByYW5nZSBpdHNlbGYuICBUaGUgcmFuZ2UgaXMKCQkJcGFzc2VkIGFzICJhOmZpcnN0bGluZSIgYW5kICJhOmxhc3RsaW5lIi4gIElmIFtyYW5nZV0KCQkJaXMgZXhjbHVkZWQsICI6e3JhbmdlfWNhbGwiIHdpbGwgY2FsbCB0aGUgZnVuY3Rpb24gZm9yCgkJCWVhY2ggbGluZSBpbiB0aGUgcmFuZ2UsIHdpdGggdGhlIGN1cnNvciBvbiB0aGUgc3RhcnQKCQkJb2YgZWFjaCBsaW5lLiAgU2VlIHxmdW5jdGlvbi1yYW5nZS1leGFtcGxlfC4KCQkJVGhlIGN1cnNvciBpcyBzdGlsbCBtb3ZlZCB0byB0aGUgZmlyc3QgbGluZSBvZiB0aGUKCQkJcmFuZ2UsIGFzIGlzIHRoZSBjYXNlIHdpdGggYWxsIEV4IGNvbW1hbmRzLgoJCQkJCQkJCSo6ZnVuYy1hYm9ydCoKCQkJV2hlbiB0aGUgW2Fib3J0XSBhcmd1bWVudCBpcyBhZGRlZCwgdGhlIGZ1bmN0aW9uIHdpbGwKCQkJYWJvcnQgYXMgc29vbiBhcyBhbiBlcnJvciBpcyBkZXRlY3RlZC4KCQkJCQkJCQkqOmZ1bmMtZGljdCoKCQkJV2hlbiB0aGUgW2RpY3RdIGFyZ3VtZW50IGlzIGFkZGVkLCB0aGUgZnVuY3Rpb24gbXVzdAoJCQliZSBpbnZva2VkIHRocm91Z2ggYW4gZW50cnkgaW4gYSB8RGljdGlvbmFyeXwuCVRoZQoJCQlsb2NhbCB2YXJpYWJsZSAic2VsZiIgd2lsbCB0aGVuIGJlIHNldCB0byB0aGUKCQkJZGljdGlvbmFyeS4gIFNlZSB8RGljdGlvbmFyeS1mdW5jdGlvbnwuCgoJCQkJCQkqZnVuY3Rpb24tc2VhcmNoLXVuZG8qCgkJCVRoZSBsYXN0IHVzZWQgc2VhcmNoIHBhdHRlcm4gYW5kIHRoZSByZWRvIGNvbW1hbmQgIi4iCgkJCXdpbGwgbm90IGJlIGNoYW5nZWQgYnkgdGhlIGZ1bmN0aW9uLiAgVGhpcyBhbHNvCgkJCWltcGxpZXMgdGhhdCB0aGUgZWZmZWN0IG9mIHw6bm9obHNlYXJjaHwgaXMgdW5kb25lCgkJCXdoZW4gdGhlIGZ1bmN0aW9uIHJldHVybnMuCgoJCQkJCSo6ZW5kZiogKjplbmRmdW5jdGlvbiogKkUxMjYqICpFMTkzKgo6ZW5kZlt1bmN0aW9uXQkJVGhlIGVuZCBvZiBhIGZ1bmN0aW9uIGRlZmluaXRpb24uICBNdXN0IGJlIG9uIGEgbGluZQoJCQlieSBpdHMgb3duLCB3aXRob3V0IG90aGVyIGNvbW1hbmRzLgoKCQkJCQkqOmRlbGYqICo6ZGVsZnVuY3Rpb24qICpFMTMwKiAqRTEzMSoKOmRlbGZbdW5jdGlvbl0ge25hbWV9CURlbGV0ZSBmdW5jdGlvbiB7bmFtZX0uCgkJCXtuYW1lfSBjYW4gYWxzbyBiZSBhIHxEaWN0aW9uYXJ5fCBlbnRyeSB0aGF0IGlzIGEKCQkJfEZ1bmNyZWZ8OiA+CgkJCQk6ZGVsZnVuYyBkaWN0LmluaXQKPAkJCVRoaXMgd2lsbCByZW1vdmUgdGhlICJpbml0IiBlbnRyeSBmcm9tICJkaWN0Ii4JVGhlCgkJCWZ1bmN0aW9uIGlzIGRlbGV0ZWQgaWYgdGhlcmUgYXJlIG5vIG1vcmUgcmVmZXJlbmNlcyB0bwoJCQlpdC4KCQkJCQkJCSo6cmV0dSogKjpyZXR1cm4qICpFMTMzKgo6cmV0dVtybl0gW2V4cHJdCVJldHVybiBmcm9tIGEgZnVuY3Rpb24uICBXaGVuICJbZXhwcl0iIGlzIGdpdmVuLCBpdCBpcwoJCQlldmFsdWF0ZWQgYW5kIHJldHVybmVkIGFzIHRoZSByZXN1bHQgb2YgdGhlIGZ1bmN0aW9uLgoJCQlJZiAiW2V4cHJdIiBpcyBub3QgZ2l2ZW4sIHRoZSBudW1iZXIgMCBpcyByZXR1cm5lZC4KCQkJV2hlbiBhIGZ1bmN0aW9uIGVuZHMgd2l0aG91dCBhbiBleHBsaWNpdCAiOnJldHVybiIsCgkJCXRoZSBudW1iZXIgMCBpcyByZXR1cm5lZC4KCQkJTm90ZSB0aGF0IHRoZXJlIGlzIG5vIGNoZWNrIGZvciB1bnJlYWNoYWJsZSBsaW5lcywKCQkJdGh1cyB0aGVyZSBpcyBubyB3YXJuaW5nIGlmIGNvbW1hbmRzIGZvbGxvdyAiOnJldHVybiIuCgoJCQlJZiB0aGUgIjpyZXR1cm4iIGlzIHVzZWQgYWZ0ZXIgYSB8OnRyeXwgYnV0IGJlZm9yZSB0aGUKCQkJbWF0Y2hpbmcgfDpmaW5hbGx5fCAoaWYgcHJlc2VudCksIHRoZSBjb21tYW5kcwoJCQlmb2xsb3dpbmcgdGhlICI6ZmluYWxseSIgdXAgdG8gdGhlIG1hdGNoaW5nIHw6ZW5kdHJ5fAoJCQlhcmUgZXhlY3V0ZWQgZmlyc3QuICBUaGlzIHByb2Nlc3MgYXBwbGllcyB0byBhbGwKCQkJbmVzdGVkICI6dHJ5InMgaW5zaWRlIHRoZSBmdW5jdGlvbi4gIFRoZSBmdW5jdGlvbgoJCQlyZXR1cm5zIGF0IHRoZSBvdXRlcm1vc3QgIjplbmR0cnkiLgoKCQkJCQkJKmZ1bmN0aW9uLWFyZ3VtZW50KiAqYTp2YXIqCkFuIGFyZ3VtZW50IGNhbiBiZSBkZWZpbmVkIGJ5IGdpdmluZyBpdHMgbmFtZS4JSW4gdGhlIGZ1bmN0aW9uIHRoaXMgY2FuIHRoZW4KYmUgdXNlZCBhcyAiYTpuYW1lIiAoImE6IiBmb3IgYXJndW1lbnQpLgoJCQkJCSphOjAqICphOjEqICphOjAwMCogKkU3NDAqICouLi4qClVwIHRvIDIwIGFyZ3VtZW50cyBjYW4gYmUgZ2l2ZW4sIHNlcGFyYXRlZCBieSBjb21tYXMuICBBZnRlciB0aGUgbmFtZWQKYXJndW1lbnRzIGFuIGFyZ3VtZW50ICIuLi4iIGNhbiBiZSBzcGVjaWZpZWQsIHdoaWNoIG1lYW5zIHRoYXQgbW9yZSBhcmd1bWVudHMKbWF5IG9wdGlvbmFsbHkgYmUgZm9sbG93aW5nLiAgSW4gdGhlIGZ1bmN0aW9uIHRoZSBleHRyYSBhcmd1bWVudHMgY2FuIGJlIHVzZWQKYXMgImE6MSIsICJhOjIiLCBldGMuICAiYTowIiBpcyBzZXQgdG8gdGhlIG51bWJlciBvZiBleHRyYSBhcmd1bWVudHMgKHdoaWNoCmNhbiBiZSAwKS4gICJhOjAwMCIgaXMgc2V0IHRvIGEgfExpc3R8IHRoYXQgY29udGFpbnMgdGhlc2UgYXJndW1lbnRzLiAgTm90ZQp0aGF0ICJhOjEiIGlzIHRoZSBzYW1lIGFzICJhOjAwMFswXSIuCgkJCQkJCQkJKkU3NDIqClRoZSBhOiBzY29wZSBhbmQgdGhlIHZhcmlhYmxlcyBpbiBpdCBjYW5ub3QgYmUgY2hhbmdlZCwgdGhleSBhcmUgZml4ZWQuCkhvd2V2ZXIsIGlmIGEgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCBpcyB1c2VkLCB5b3UgY2FuIGNoYW5nZSB0aGVpciBjb250ZW50cy4KVGh1cyB5b3UgY2FuIHBhc3MgYSB8TGlzdHwgdG8gYSBmdW5jdGlvbiBhbmQgaGF2ZSB0aGUgZnVuY3Rpb24gYWRkIGFuIGl0ZW0gdG8KaXQuICBJZiB5b3Ugd2FudCB0byBtYWtlIHN1cmUgdGhlIGZ1bmN0aW9uIGNhbm5vdCBjaGFuZ2UgYSB8TGlzdHwgb3IKfERpY3Rpb25hcnl8IHVzZSB8OmxvY2t2YXJ8LgoKV2hlbiBub3QgdXNpbmcgIi4uLiIsIHRoZSBudW1iZXIgb2YgYXJndW1lbnRzIGluIGEgZnVuY3Rpb24gY2FsbCBtdXN0IGJlIGVxdWFsCnRvIHRoZSBudW1iZXIgb2YgbmFtZWQgYXJndW1lbnRzLiAgV2hlbiB1c2luZyAiLi4uIiwgdGhlIG51bWJlciBvZiBhcmd1bWVudHMKbWF5IGJlIGxhcmdlci4KCkl0IGlzIGFsc28gcG9zc2libGUgdG8gZGVmaW5lIGEgZnVuY3Rpb24gd2l0aG91dCBhbnkgYXJndW1lbnRzLiAgWW91IG11c3QKc3RpbGwgc3VwcGx5IHRoZSAoKSB0aGVuLiAgVGhlIGJvZHkgb2YgdGhlIGZ1bmN0aW9uIGZvbGxvd3MgaW4gdGhlIG5leHQgbGluZXMsCnVudGlsIHRoZSBtYXRjaGluZyB8OmVuZGZ1bmN0aW9ufC4gIEl0IGlzIGFsbG93ZWQgdG8gZGVmaW5lIGFub3RoZXIgZnVuY3Rpb24KaW5zaWRlIGEgZnVuY3Rpb24gYm9keS4KCgkJCQkJCQkqbG9jYWwtdmFyaWFibGVzKgpJbnNpZGUgYSBmdW5jdGlvbiB2YXJpYWJsZXMgY2FuIGJlIHVzZWQuICBUaGVzZSBhcmUgbG9jYWwgdmFyaWFibGVzLCB3aGljaAp3aWxsIGRpc2FwcGVhciB3aGVuIHRoZSBmdW5jdGlvbiByZXR1cm5zLiAgR2xvYmFsIHZhcmlhYmxlcyBuZWVkIHRvIGJlCmFjY2Vzc2VkIHdpdGggImc6Ii4KCkV4YW1wbGU6ID4KICA6ZnVuY3Rpb24gVGFibGUodGl0bGUsIC4uLikKICA6ICBlY2hvaGwgVGl0bGUKICA6ICBlY2hvIGE6dGl0bGUKICA6ICBlY2hvaGwgTm9uZQogIDogIGVjaG8gYTowIC4gIiBpdGVtczoiCiAgOiAgZm9yIHMgaW4gYTowMDAKICA6ICAgIGVjaG9uICcgJyAuIHMKICA6ICBlbmRmb3IKICA6ZW5kZnVuY3Rpb24KClRoaXMgZnVuY3Rpb24gY2FuIHRoZW4gYmUgY2FsbGVkIHdpdGg6ID4KICBjYWxsIFRhYmxlKCJUYWJsZSIsICJsaW5lMSIsICJsaW5lMiIpCiAgY2FsbCBUYWJsZSgiRW1wdHkgVGFibGUiKQoKVG8gcmV0dXJuIG1vcmUgdGhhbiBvbmUgdmFsdWUsIHJldHVybiBhIHxMaXN0fDogPgogIDpmdW5jdGlvbiBDb21wdXRlKG4xLCBuMikKICA6ICBpZiBhOm4yID09IDAKICA6ICAgIHJldHVybiBbImZhaWwiLCAwXQogIDogIGVuZGlmCiAgOiAgcmV0dXJuIFsib2siLCBhOm4xIC8gYTpuMl0KICA6ZW5kZnVuY3Rpb24KClRoaXMgZnVuY3Rpb24gY2FuIHRoZW4gYmUgY2FsbGVkIHdpdGg6ID4KICA6bGV0IFtzdWNjZXNzLCBkaXZdID0gQ29tcHV0ZSgxMDIsIDYpCiAgOmlmIHN1Y2Nlc3MgPT0gIm9rIgogIDogIGVjaG8gZGl2CiAgOmVuZGlmCjwKCQkJCQkJKjpjYWwqICo6Y2FsbCogKkUxMDcqICpFMTE3Kgo6W3JhbmdlXWNhbFtsXSB7bmFtZX0oW2FyZ3VtZW50c10pCgkJQ2FsbCBhIGZ1bmN0aW9uLiAgVGhlIG5hbWUgb2YgdGhlIGZ1bmN0aW9uIGFuZCBpdHMgYXJndW1lbnRzCgkJYXJlIGFzIHNwZWNpZmllZCB3aXRoIHw6ZnVuY3Rpb258LiAgVXAgdG8gMjAgYXJndW1lbnRzIGNhbiBiZQoJCXVzZWQuICBUaGUgcmV0dXJuZWQgdmFsdWUgaXMgZGlzY2FyZGVkLgoJCVdpdGhvdXQgYSByYW5nZSBhbmQgZm9yIGZ1bmN0aW9ucyB0aGF0IGFjY2VwdCBhIHJhbmdlLCB0aGUKCQlmdW5jdGlvbiBpcyBjYWxsZWQgb25jZS4gIFdoZW4gYSByYW5nZSBpcyBnaXZlbiB0aGUgY3Vyc29yIGlzCgkJcG9zaXRpb25lZCBhdCB0aGUgc3RhcnQgb2YgdGhlIGZpcnN0IGxpbmUgYmVmb3JlIGV4ZWN1dGluZyB0aGUKCQlmdW5jdGlvbi4KCQlXaGVuIGEgcmFuZ2UgaXMgZ2l2ZW4gYW5kIHRoZSBmdW5jdGlvbiBkb2Vzbid0IGhhbmRsZSBpdAoJCWl0c2VsZiwgdGhlIGZ1bmN0aW9uIGlzIGV4ZWN1dGVkIGZvciBlYWNoIGxpbmUgaW4gdGhlIHJhbmdlLAoJCXdpdGggdGhlIGN1cnNvciBpbiB0aGUgZmlyc3QgY29sdW1uIG9mIHRoYXQgbGluZS4gIFRoZSBjdXJzb3IKCQlpcyBsZWZ0IGF0IHRoZSBsYXN0IGxpbmUgKHBvc3NpYmx5IG1vdmVkIGJ5IHRoZSBsYXN0IGZ1bmN0aW9uCgkJY2FsbCkuCVRoZSBhcmd1bWVudHMgYXJlIHJlLWV2YWx1YXRlZCBmb3IgZWFjaCBsaW5lLiAgVGh1cwoJCXRoaXMgd29ya3M6CgkJCQkJCSpmdW5jdGlvbi1yYW5nZS1leGFtcGxlKiAgPgoJOmZ1bmN0aW9uIE15bnVtYmVyKGFyZykKCTogIGVjaG8gbGluZSgiLiIpIC4gIiAiIC4gYTphcmcKCTplbmRmdW5jdGlvbgoJOjEsNWNhbGwgTXludW1iZXIoZ2V0bGluZSgiLiIpKQo8CgkJVGhlICJhOmZpcnN0bGluZSIgYW5kICJhOmxhc3RsaW5lIiBhcmUgZGVmaW5lZCBhbnl3YXksIHRoZXkKCQljYW4gYmUgdXNlZCB0byBkbyBzb21ldGhpbmcgZGlmZmVyZW50IGF0IHRoZSBzdGFydCBvciBlbmQgb2YKCQl0aGUgcmFuZ2UuCgoJCUV4YW1wbGUgb2YgYSBmdW5jdGlvbiB0aGF0IGhhbmRsZXMgdGhlIHJhbmdlIGl0c2VsZjogPgoKCTpmdW5jdGlvbiBDb250KCkgcmFuZ2UKCTogIGV4ZWN1dGUgKGE6Zmlyc3RsaW5lICsgMSkgLiAiLCIgLiBhOmxhc3RsaW5lIC4gJ3MvXi9cdFxcICcKCTplbmRmdW5jdGlvbgoJOjQsOGNhbGwgQ29udCgpCjwKCQlUaGlzIGZ1bmN0aW9uIGluc2VydHMgdGhlIGNvbnRpbnVhdGlvbiBjaGFyYWN0ZXIgIlwiIGluIGZyb250CgkJb2YgYWxsIHRoZSBsaW5lcyBpbiB0aGUgcmFuZ2UsIGV4Y2VwdCB0aGUgZmlyc3Qgb25lLgoKCQlXaGVuIHRoZSBmdW5jdGlvbiByZXR1cm5zIGEgY29tcG9zaXRlIHZhbHVlIGl0IGNhbiBiZSBmdXJ0aGVyCgkJZGVyZWZlcmVuY2VkLCBidXQgdGhlIHJhbmdlIHdpbGwgbm90IGJlIHVzZWQgdGhlbi4gIEV4YW1wbGU6ID4KCTo0LDhjYWxsIEdldERpY3QoKS5tZXRob2QoKQo8CQlIZXJlIEdldERpY3QoKSBnZXRzIHRoZSByYW5nZSBidXQgbWV0aG9kKCkgZG9lcyBub3QuCgoJCQkJCQkJCSpFMTMyKgpUaGUgcmVjdXJzaXZlbmVzcyBvZiB1c2VyIGZ1bmN0aW9ucyBpcyByZXN0cmljdGVkIHdpdGggdGhlIHwnbWF4ZnVuY2RlcHRoJ3wKb3B0aW9uLgoKCkFVVE9NQVRJQ0FMTFkgTE9BRElORyBGVU5DVElPTlMgfgoJCQkJCQkJKmF1dG9sb2FkLWZ1bmN0aW9ucyoKV2hlbiB1c2luZyBtYW55IG9yIGxhcmdlIGZ1bmN0aW9ucywgaXQncyBwb3NzaWJsZSB0byBhdXRvbWF0aWNhbGx5IGRlZmluZSB0aGVtCm9ubHkgd2hlbiB0aGV5IGFyZSB1c2VkLiAgVGhlcmUgYXJlIHR3byBtZXRob2RzOiB3aXRoIGFuIGF1dG9jb21tYW5kIGFuZCB3aXRoCnRoZSAiYXV0b2xvYWQiIGRpcmVjdG9yeSBpbiAncnVudGltZXBhdGgnLgoKClVzaW5nIGFuIGF1dG9jb21tYW5kIH4KClRoaXMgaXMgaW50cm9kdWNlZCBpbiB0aGUgdXNlciBtYW51YWwsIHNlY3Rpb24gfDQxLjE0fC4KClRoZSBhdXRvY29tbWFuZCBpcyB1c2VmdWwgaWYgeW91IGhhdmUgYSBwbHVnaW4gdGhhdCBpcyBhIGxvbmcgVmltIHNjcmlwdCBmaWxlLgpZb3UgY2FuIGRlZmluZSB0aGUgYXV0b2NvbW1hbmQgYW5kIHF1aWNrbHkgcXVpdCB0aGUgc2NyaXB0IHdpdGggfDpmaW5pc2h8LgpUaGF0IG1ha2VzIFZpbSBzdGFydHVwIGZhc3Rlci4JVGhlIGF1dG9jb21tYW5kIHNob3VsZCB0aGVuIGxvYWQgdGhlIHNhbWUgZmlsZQphZ2Fpbiwgc2V0dGluZyBhIHZhcmlhYmxlIHRvIHNraXAgdGhlIHw6ZmluaXNofCBjb21tYW5kLgoKVXNlIHRoZSBGdW5jVW5kZWZpbmVkIGF1dG9jb21tYW5kIGV2ZW50IHdpdGggYSBwYXR0ZXJuIHRoYXQgbWF0Y2hlcyB0aGUKZnVuY3Rpb24ocykgdG8gYmUgZGVmaW5lZC4gIEV4YW1wbGU6ID4KCgk6YXUgRnVuY1VuZGVmaW5lZCBCdWZOZXQqIHNvdXJjZSB+L3ZpbS9idWZuZXRmdW5jcy52aW0KClRoZSBmaWxlICJ+L3ZpbS9idWZuZXRmdW5jcy52aW0iIHNob3VsZCB0aGVuIGRlZmluZSBmdW5jdGlvbnMgdGhhdCBzdGFydCB3aXRoCiJCdWZOZXQiLiAgQWxzbyBzZWUgfEZ1bmNVbmRlZmluZWR8LgoKClVzaW5nIGFuIGF1dG9sb2FkIHNjcmlwdCB+CgkJCQkJCQkqYXV0b2xvYWQqICpFNzQ2KgpUaGlzIGlzIGludHJvZHVjZWQgaW4gdGhlIHVzZXIgbWFudWFsLCBzZWN0aW9uIHw0MS4xNXwuCgpVc2luZyBhIHNjcmlwdCBpbiB0aGUgImF1dG9sb2FkIiBkaXJlY3RvcnkgaXMgc2ltcGxlciwgYnV0IHJlcXVpcmVzIHVzaW5nCmV4YWN0bHkgdGhlIHJpZ2h0IGZpbGUgbmFtZS4gIEEgZnVuY3Rpb24gdGhhdCBjYW4gYmUgYXV0b2xvYWRlZCBoYXMgYSBuYW1lCmxpa2UgdGhpczogPgoKCTpjYWxsIGZpbGVuYW1lI2Z1bmNuYW1lKCkKCldoZW4gc3VjaCBhIGZ1bmN0aW9uIGlzIGNhbGxlZCwgYW5kIGl0IGlzIG5vdCBkZWZpbmVkIHlldCwgVmltIHdpbGwgc2VhcmNoIHRoZQoiYXV0b2xvYWQiIGRpcmVjdG9yaWVzIGluICdydW50aW1lcGF0aCcgZm9yIGEgc2NyaXB0IGZpbGUgY2FsbGVkCiJmaWxlbmFtZS52aW0iLiAgRm9yIGV4YW1wbGUgIn4vLnZpbS9hdXRvbG9hZC9maWxlbmFtZS52aW0iLiAgVGhhdCBmaWxlIHNob3VsZAp0aGVuIGRlZmluZSB0aGUgZnVuY3Rpb24gbGlrZSB0aGlzOiA+CgoJZnVuY3Rpb24gZmlsZW5hbWUjZnVuY25hbWUoKQoJICAgZWNobyAiRG9uZSEiCgllbmRmdW5jdGlvbgoKVGhlIGZpbGUgbmFtZSBhbmQgdGhlIG5hbWUgdXNlZCBiZWZvcmUgdGhlICMgaW4gdGhlIGZ1bmN0aW9uIG11c3QgbWF0Y2gKZXhhY3RseSwgYW5kIHRoZSBkZWZpbmVkIGZ1bmN0aW9uIG11c3QgaGF2ZSB0aGUgbmFtZSBleGFjdGx5IGFzIGl0IHdpbGwgYmUKY2FsbGVkLgoKSXQgaXMgcG9zc2libGUgdG8gdXNlIHN1YmRpcmVjdG9yaWVzLiAgRXZlcnkgIyBpbiB0aGUgZnVuY3Rpb24gbmFtZSB3b3JrcyBsaWtlCmEgcGF0aCBzZXBhcmF0b3IuICBUaHVzIHdoZW4gY2FsbGluZyBhIGZ1bmN0aW9uOiA+CgoJOmNhbGwgZm9vI2JhciNmdW5jKCkKClZpbSB3aWxsIGxvb2sgZm9yIHRoZSBmaWxlICJhdXRvbG9hZC9mb28vYmFyLnZpbSIgaW4gJ3J1bnRpbWVwYXRoJy4KClRoaXMgYWxzbyB3b3JrcyB3aGVuIHJlYWRpbmcgYSB2YXJpYWJsZSB0aGF0IGhhcyBub3QgYmVlbiBzZXQgeWV0OiA+CgoJOmxldCBsID0gZm9vI2JhciNsdmFyCgpIb3dldmVyLCB3aGVuIHRoZSBhdXRvbG9hZCBzY3JpcHQgd2FzIGFscmVhZHkgbG9hZGVkIGl0IHdvbid0IGJlIGxvYWRlZCBhZ2Fpbgpmb3IgYW4gdW5rbm93biB2YXJpYWJsZS4KCldoZW4gYXNzaWduaW5nIGEgdmFsdWUgdG8gc3VjaCBhIHZhcmlhYmxlIG5vdGhpbmcgc3BlY2lhbCBoYXBwZW5zLiAgVGhpcyBjYW4KYmUgdXNlZCB0byBwYXNzIHNldHRpbmdzIHRvIHRoZSBhdXRvbG9hZCBzY3JpcHQgYmVmb3JlIGl0J3MgbG9hZGVkOiA+CgoJOmxldCBmb28jYmFyI3RvZ2dsZSA9IDEKCTpjYWxsIGZvbyNiYXIjZnVuYygpCgpOb3RlIHRoYXQgd2hlbiB5b3UgbWFrZSBhIG1pc3Rha2UgYW5kIGNhbGwgYSBmdW5jdGlvbiB0aGF0IGlzIHN1cHBvc2VkIHRvIGJlCmRlZmluZWQgaW4gYW4gYXV0b2xvYWQgc2NyaXB0LCBidXQgdGhlIHNjcmlwdCBkb2Vzbid0IGFjdHVhbGx5IGRlZmluZSB0aGUKZnVuY3Rpb24sIHRoZSBzY3JpcHQgd2lsbCBiZSBzb3VyY2VkIGV2ZXJ5IHRpbWUgeW91IHRyeSB0byBjYWxsIHRoZSBmdW5jdGlvbi4KQW5kIHlvdSB3aWxsIGdldCBhbiBlcnJvciBtZXNzYWdlIGV2ZXJ5IHRpbWUuCgpBbHNvIG5vdGUgdGhhdCBpZiB5b3UgaGF2ZSB0d28gc2NyaXB0IGZpbGVzLCBhbmQgb25lIGNhbGxzIGEgZnVuY3Rpb24gaW4gdGhlCm90aGVyIGFuZCB2aWNlIHZlcnNhLCBiZWZvcmUgdGhlIHVzZWQgZnVuY3Rpb24gaXMgZGVmaW5lZCwgaXQgd29uJ3Qgd29yay4KQXZvaWQgdXNpbmcgdGhlIGF1dG9sb2FkIGZ1bmN0aW9uYWxpdHkgYXQgdGhlIHRvcGxldmVsLgoKSGludDogSWYgeW91IGRpc3RyaWJ1dGUgYSBidW5jaCBvZiBzY3JpcHRzIHlvdSBjYW4gcGFjayB0aGVtIHRvZ2V0aGVyIHdpdGggdGhlCnx2aW1iYWxsfCB1dGlsaXR5LiAgQWxzbyByZWFkIHRoZSB1c2VyIG1hbnVhbCB8ZGlzdHJpYnV0ZS1zY3JpcHR8LgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjYuIEN1cmx5IGJyYWNlcyBuYW1lcwkJCQkJKmN1cmx5LWJyYWNlcy1uYW1lcyoKCkluIG1vc3QgcGxhY2VzIHdoZXJlIHlvdSBjYW4gdXNlIGEgdmFyaWFibGUsIHlvdSBjYW4gdXNlIGEgImN1cmx5IGJyYWNlcyBuYW1lIgp2YXJpYWJsZS4gIFRoaXMgaXMgYSByZWd1bGFyIHZhcmlhYmxlIG5hbWUgd2l0aCBvbmUgb3IgbW9yZSBleHByZXNzaW9ucwp3cmFwcGVkIGluIGJyYWNlcyB7fSBsaWtlIHRoaXM6ID4KCW15X3thZGplY3RpdmV9X3ZhcmlhYmxlCgpXaGVuIFZpbSBlbmNvdW50ZXJzIHRoaXMsIGl0IGV2YWx1YXRlcyB0aGUgZXhwcmVzc2lvbiBpbnNpZGUgdGhlIGJyYWNlcywgcHV0cwp0aGF0IGluIHBsYWNlIG9mIHRoZSBleHByZXNzaW9uLCBhbmQgcmUtaW50ZXJwcmV0cyB0aGUgd2hvbGUgYXMgYSB2YXJpYWJsZQpuYW1lLiAgU28gaW4gdGhlIGFib3ZlIGV4YW1wbGUsIGlmIHRoZSB2YXJpYWJsZSAiYWRqZWN0aXZlIiB3YXMgc2V0IHRvCiJub2lzeSIsIHRoZW4gdGhlIHJlZmVyZW5jZSB3b3VsZCBiZSB0byAibXlfbm9pc3lfdmFyaWFibGUiLCB3aGVyZWFzIGlmCiJhZGplY3RpdmUiIHdhcyBzZXQgdG8gInF1aWV0IiwgdGhlbiBpdCB3b3VsZCBiZSB0byAibXlfcXVpZXRfdmFyaWFibGUiLgoKT25lIGFwcGxpY2F0aW9uIGZvciB0aGlzIGlzIHRvIGNyZWF0ZSBhIHNldCBvZiB2YXJpYWJsZXMgZ292ZXJuZWQgYnkgYW4gb3B0aW9uCnZhbHVlLglGb3IgZXhhbXBsZSwgdGhlIHN0YXRlbWVudCA+CgllY2hvIG15X3smYmFja2dyb3VuZH1fbWVzc2FnZQoKd291bGQgb3V0cHV0IHRoZSBjb250ZW50cyBvZiAibXlfZGFya19tZXNzYWdlIiBvciAibXlfbGlnaHRfbWVzc2FnZSIgZGVwZW5kaW5nCm9uIHRoZSBjdXJyZW50IHZhbHVlIG9mICdiYWNrZ3JvdW5kJy4KCllvdSBjYW4gdXNlIG11bHRpcGxlIGJyYWNlIHBhaXJzOiA+CgllY2hvIG15X3thZHZlcmJ9X3thZGplY3RpdmV9X21lc3NhZ2UKLi5vciBldmVuIG5lc3QgdGhlbTogPgoJZWNobyBteV97YWR7ZW5kX29mX3dvcmR9fV9tZXNzYWdlCndoZXJlICJlbmRfb2Zfd29yZCIgaXMgZWl0aGVyICJ2ZXJiIiBvciAiamVjdGl2ZSIuCgpIb3dldmVyLCB0aGUgZXhwcmVzc2lvbiBpbnNpZGUgdGhlIGJyYWNlcyBtdXN0IGV2YWx1YXRlIHRvIGEgdmFsaWQgc2luZ2xlCnZhcmlhYmxlIG5hbWUsIGUuZy4gdGhpcyBpcyBpbnZhbGlkOiA+Cgk6bGV0IGZvbz0nYSArIGInCgk6ZWNobyBje2Zvb31kCi4uIHNpbmNlIHRoZSByZXN1bHQgb2YgZXhwYW5zaW9uIGlzICJjYSArIGJkIiwgd2hpY2ggaXMgbm90IGEgdmFyaWFibGUgbmFtZS4KCgkJCQkJCSpjdXJseS1icmFjZXMtZnVuY3Rpb24tbmFtZXMqCllvdSBjYW4gY2FsbCBhbmQgZGVmaW5lIGZ1bmN0aW9ucyBieSBhbiBldmFsdWF0ZWQgbmFtZSBpbiBhIHNpbWlsYXIgd2F5LgpFeGFtcGxlOiA+Cgk6bGV0IGZ1bmNfZW5kPSd3aGl6eicKCTpjYWxsIG15X2Z1bmNfe2Z1bmNfZW5kfShwYXJhbWV0ZXIpCgpUaGlzIHdvdWxkIGNhbGwgdGhlIGZ1bmN0aW9uICJteV9mdW5jX3doaXp6KHBhcmFtZXRlcikiLgoKVGhpcyBkb2VzIE5PVCB3b3JrOiA+CiAgOmxldCBpID0gMwogIDpsZXQgQHtpfSA9ICcnICAiIGVycm9yCiAgOmVjaG8gQHtpfSAgICAgICIgZXJyb3IKCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo3LiBDb21tYW5kcwkJCQkJCSpleHByZXNzaW9uLWNvbW1hbmRzKgoKOmxldCB7dmFyLW5hbWV9ID0ge2V4cHIxfQkJCQkqOmxldCogKkUxOCoKCQkJU2V0IGludGVybmFsIHZhcmlhYmxlIHt2YXItbmFtZX0gdG8gdGhlIHJlc3VsdCBvZiB0aGUKCQkJZXhwcmVzc2lvbiB7ZXhwcjF9LiAgVGhlIHZhcmlhYmxlIHdpbGwgZ2V0IHRoZSB0eXBlCgkJCWZyb20gdGhlIHtleHByfS4gIElmIHt2YXItbmFtZX0gZGlkbid0IGV4aXN0IHlldCwgaXQKCQkJaXMgY3JlYXRlZC4KCjpsZXQge3Zhci1uYW1lfVt7aWR4fV0gPSB7ZXhwcjF9CQkJKkU2ODkqCgkJCVNldCBhIGxpc3QgaXRlbSB0byB0aGUgcmVzdWx0IG9mIHRoZSBleHByZXNzaW9uCgkJCXtleHByMX0uICB7dmFyLW5hbWV9IG11c3QgcmVmZXIgdG8gYSBsaXN0IGFuZCB7aWR4fQoJCQltdXN0IGJlIGEgdmFsaWQgaW5kZXggaW4gdGhhdCBsaXN0LiAgRm9yIG5lc3RlZCBsaXN0CgkJCXRoZSBpbmRleCBjYW4gYmUgcmVwZWF0ZWQuCgkJCVRoaXMgY2Fubm90IGJlIHVzZWQgdG8gYWRkIGFuIGl0ZW0gdG8gYSB8TGlzdHwuCgkJCVRoaXMgY2Fubm90IGJlIHVzZWQgdG8gc2V0IGEgYnl0ZSBpbiBhIFN0cmluZy4JWW91CgkJCWNhbiBkbyB0aGF0IGxpa2UgdGhpczogPgoJCQkJOmxldCB2YXIgPSB2YXJbMDoyXSAuICdYJyAuIHZhcls0Ol0KPAoJCQkJCQkJKkU3MTEqICpFNzE5Kgo6bGV0IHt2YXItbmFtZX1be2lkeDF9OntpZHgyfV0gPSB7ZXhwcjF9CQkqRTcwOCogKkU3MDkqICpFNzEwKgoJCQlTZXQgYSBzZXF1ZW5jZSBvZiBpdGVtcyBpbiBhIHxMaXN0fCB0byB0aGUgcmVzdWx0IG9mCgkJCXRoZSBleHByZXNzaW9uIHtleHByMX0sIHdoaWNoIG11c3QgYmUgYSBsaXN0IHdpdGggdGhlCgkJCWNvcnJlY3QgbnVtYmVyIG9mIGl0ZW1zLgoJCQl7aWR4MX0gY2FuIGJlIG9taXR0ZWQsIHplcm8gaXMgdXNlZCBpbnN0ZWFkLgoJCQl7aWR4Mn0gY2FuIGJlIG9taXR0ZWQsIG1lYW5pbmcgdGhlIGVuZCBvZiB0aGUgbGlzdC4KCQkJV2hlbiB0aGUgc2VsZWN0ZWQgcmFuZ2Ugb2YgaXRlbXMgaXMgcGFydGx5IHBhc3QgdGhlCgkJCWVuZCBvZiB0aGUgbGlzdCwgaXRlbXMgd2lsbCBiZSBhZGRlZC4KCgkJCQkJKjpsZXQrPSogKjpsZXQtPSogKjpsZXQuPSogKkU3MzQqCjpsZXQge3Zhcn0gKz0ge2V4cHIxfQlMaWtlICI6bGV0IHt2YXJ9ID0ge3Zhcn0gKyB7ZXhwcjF9Ii4KOmxldCB7dmFyfSAtPSB7ZXhwcjF9CUxpa2UgIjpsZXQge3Zhcn0gPSB7dmFyfSAtIHtleHByMX0iLgo6bGV0IHt2YXJ9IC49IHtleHByMX0JTGlrZSAiOmxldCB7dmFyfSA9IHt2YXJ9IC4ge2V4cHIxfSIuCgkJCVRoZXNlIGZhaWwgaWYge3Zhcn0gd2FzIG5vdCBzZXQgeWV0IGFuZCB3aGVuIHRoZSB0eXBlCgkJCW9mIHt2YXJ9IGFuZCB7ZXhwcjF9IGRvbid0IGZpdCB0aGUgb3BlcmF0b3IuCgoKOmxldCAke2Vudi1uYW1lfSA9IHtleHByMX0JCQkqOmxldC1lbnZpcm9ubWVudCogKjpsZXQtJCoKCQkJU2V0IGVudmlyb25tZW50IHZhcmlhYmxlIHtlbnYtbmFtZX0gdG8gdGhlIHJlc3VsdCBvZgoJCQl0aGUgZXhwcmVzc2lvbiB7ZXhwcjF9LiAgVGhlIHR5cGUgaXMgYWx3YXlzIFN0cmluZy4KOmxldCAke2Vudi1uYW1lfSAuPSB7ZXhwcjF9CgkJCUFwcGVuZCB7ZXhwcjF9IHRvIHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZSB7ZW52LW5hbWV9LgoJCQlJZiB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGUgZGlkbid0IGV4aXN0IHlldCB0aGlzCgkJCXdvcmtzIGxpa2UgIj0iLgoKOmxldCBAe3JlZy1uYW1lfSA9IHtleHByMX0JCQkqOmxldC1yZWdpc3RlciogKjpsZXQtQCoKCQkJV3JpdGUgdGhlIHJlc3VsdCBvZiB0aGUgZXhwcmVzc2lvbiB7ZXhwcjF9IGluIHJlZ2lzdGVyCgkJCXtyZWctbmFtZX0uICB7cmVnLW5hbWV9IG11c3QgYmUgYSBzaW5nbGUgbGV0dGVyLCBhbmQKCQkJbXVzdCBiZSB0aGUgbmFtZSBvZiBhIHdyaXRhYmxlIHJlZ2lzdGVyIChzZWUKCQkJfHJlZ2lzdGVyc3wpLiAgIkBAIiBjYW4gYmUgdXNlZCBmb3IgdGhlIHVubmFtZWQKCQkJcmVnaXN0ZXIsICJALyIgZm9yIHRoZSBzZWFyY2ggcGF0dGVybi4KCQkJSWYgdGhlIHJlc3VsdCBvZiB7ZXhwcjF9IGVuZHMgaW4gYSA8Q1I+IG9yIDxOTD4sIHRoZQoJCQlyZWdpc3RlciB3aWxsIGJlIGxpbmV3aXNlLCBvdGhlcndpc2UgaXQgd2lsbCBiZSBzZXQgdG8KCQkJY2hhcmFjdGVyd2lzZS4KCQkJVGhpcyBjYW4gYmUgdXNlZCB0byBjbGVhciB0aGUgbGFzdCBzZWFyY2ggcGF0dGVybjogPgoJCQkJOmxldCBALyA9ICIiCjwJCQlUaGlzIGlzIGRpZmZlcmVudCBmcm9tIHNlYXJjaGluZyBmb3IgYW4gZW1wdHkgc3RyaW5nLAoJCQl0aGF0IHdvdWxkIG1hdGNoIGV2ZXJ5d2hlcmUuCgo6bGV0IEB7cmVnLW5hbWV9IC49IHtleHByMX0KCQkJQXBwZW5kIHtleHByMX0gdG8gcmVnaXN0ZXIge3JlZy1uYW1lfS4JSWYgdGhlCgkJCXJlZ2lzdGVyIHdhcyBlbXB0eSBpdCdzIGxpa2Ugc2V0dGluZyBpdCB0byB7ZXhwcjF9LgoKOmxldCAme29wdGlvbi1uYW1lfSA9IHtleHByMX0JCQkqOmxldC1vcHRpb24qICo6bGV0LSYqCgkJCVNldCBvcHRpb24ge29wdGlvbi1uYW1lfSB0byB0aGUgcmVzdWx0IG9mIHRoZQoJCQlleHByZXNzaW9uIHtleHByMX0uICBBIFN0cmluZyBvciBOdW1iZXIgdmFsdWUgaXMKCQkJYWx3YXlzIGNvbnZlcnRlZCB0byB0aGUgdHlwZSBvZiB0aGUgb3B0aW9uLgoJCQlGb3IgYW4gb3B0aW9uIGxvY2FsIHRvIGEgd2luZG93IG9yIGJ1ZmZlciB0aGUgZWZmZWN0CgkJCWlzIGp1c3QgbGlrZSB1c2luZyB0aGUgfDpzZXR8IGNvbW1hbmQ6IGJvdGggdGhlIGxvY2FsCgkJCXZhbHVlIGFuZCB0aGUgZ2xvYmFsIHZhbHVlIGFyZSBjaGFuZ2VkLgoJCQlFeGFtcGxlOiA+CgkJCQk6bGV0ICZwYXRoID0gJnBhdGggLiAnLC91c3IvbG9jYWwvaW5jbHVkZScKCjpsZXQgJntvcHRpb24tbmFtZX0gLj0ge2V4cHIxfQoJCQlGb3IgYSBzdHJpbmcgb3B0aW9uOiBBcHBlbmQge2V4cHIxfSB0byB0aGUgdmFsdWUuCgkJCURvZXMgbm90IGluc2VydCBhIGNvbW1hIGxpa2UgfDpzZXQrPXwuCgo6bGV0ICZ7b3B0aW9uLW5hbWV9ICs9IHtleHByMX0KOmxldCAme29wdGlvbi1uYW1lfSAtPSB7ZXhwcjF9CgkJCUZvciBhIG51bWJlciBvciBib29sZWFuIG9wdGlvbjogQWRkIG9yIHN1YnRyYWN0CgkJCXtleHByMX0uCgo6bGV0ICZsOntvcHRpb24tbmFtZX0gPSB7ZXhwcjF9CjpsZXQgJmw6e29wdGlvbi1uYW1lfSAuPSB7ZXhwcjF9CjpsZXQgJmw6e29wdGlvbi1uYW1lfSArPSB7ZXhwcjF9CjpsZXQgJmw6e29wdGlvbi1uYW1lfSAtPSB7ZXhwcjF9CgkJCUxpa2UgYWJvdmUsIGJ1dCBvbmx5IHNldCB0aGUgbG9jYWwgdmFsdWUgb2YgYW4gb3B0aW9uCgkJCShpZiB0aGVyZSBpcyBvbmUpLiAgV29ya3MgbGlrZSB8OnNldGxvY2FsfC4KCjpsZXQgJmc6e29wdGlvbi1uYW1lfSA9IHtleHByMX0KOmxldCAmZzp7b3B0aW9uLW5hbWV9IC49IHtleHByMX0KOmxldCAmZzp7b3B0aW9uLW5hbWV9ICs9IHtleHByMX0KOmxldCAmZzp7b3B0aW9uLW5hbWV9IC09IHtleHByMX0KCQkJTGlrZSBhYm92ZSwgYnV0IG9ubHkgc2V0IHRoZSBnbG9iYWwgdmFsdWUgb2YgYW4gb3B0aW9uCgkJCShpZiB0aGVyZSBpcyBvbmUpLiAgV29ya3MgbGlrZSB8OnNldGdsb2JhbHwuCgo6bGV0IFt7bmFtZTF9LCB7bmFtZTJ9LCAuLi5dID0ge2V4cHIxfQkJKjpsZXQtdW5wYWNrKiAqRTY4NyogKkU2ODgqCgkJCXtleHByMX0gbXVzdCBldmFsdWF0ZSB0byBhIHxMaXN0fC4gIFRoZSBmaXJzdCBpdGVtIGluCgkJCXRoZSBsaXN0IGlzIGFzc2lnbmVkIHRvIHtuYW1lMX0sIHRoZSBzZWNvbmQgaXRlbSB0bwoJCQl7bmFtZTJ9LCBldGMuCgkJCVRoZSBudW1iZXIgb2YgbmFtZXMgbXVzdCBtYXRjaCB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluCgkJCXRoZSB8TGlzdHwuCgkJCUVhY2ggbmFtZSBjYW4gYmUgb25lIG9mIHRoZSBpdGVtcyBvZiB0aGUgIjpsZXQiCgkJCWNvbW1hbmQgYXMgbWVudGlvbmVkIGFib3ZlLgoJCQlFeGFtcGxlOiA+CgkJCQk6bGV0IFtzLCBpdGVtXSA9IEdldEl0ZW0ocykKPAkJCURldGFpbDoge2V4cHIxfSBpcyBldmFsdWF0ZWQgZmlyc3QsIHRoZW4gdGhlCgkJCWFzc2lnbm1lbnRzIGFyZSBkb25lIGluIHNlcXVlbmNlLiAgVGhpcyBtYXR0ZXJzIGlmCgkJCXtuYW1lMn0gZGVwZW5kcyBvbiB7bmFtZTF9LiAgRXhhbXBsZTogPgoJCQkJOmxldCB4ID0gWzAsIDFdCgkJCQk6bGV0IGkgPSAwCgkJCQk6bGV0IFtpLCB4W2ldXSA9IFsxLCAyXQoJCQkJOmVjaG8geAo8CQkJVGhlIHJlc3VsdCBpcyBbMCwgMl0uCgo6bGV0IFt7bmFtZTF9LCB7bmFtZTJ9LCAuLi5dIC49IHtleHByMX0KOmxldCBbe25hbWUxfSwge25hbWUyfSwgLi4uXSArPSB7ZXhwcjF9CjpsZXQgW3tuYW1lMX0sIHtuYW1lMn0sIC4uLl0gLT0ge2V4cHIxfQoJCQlMaWtlIGFib3ZlLCBidXQgYXBwZW5kL2FkZC9zdWJ0cmFjdCB0aGUgdmFsdWUgZm9yIGVhY2gKCQkJfExpc3R8IGl0ZW0uCgo6bGV0IFt7bmFtZX0sIC4uLiwgOyB7bGFzdG5hbWV9XSA9IHtleHByMX0KCQkJTGlrZSB8OmxldC11bnBhY2t8IGFib3ZlLCBidXQgdGhlIHxMaXN0fCBtYXkgaGF2ZSBtb3JlCgkJCWl0ZW1zIHRoYW4gdGhlcmUgYXJlIG5hbWVzLiAgQSBsaXN0IG9mIHRoZSByZW1haW5pbmcKCQkJaXRlbXMgaXMgYXNzaWduZWQgdG8ge2xhc3RuYW1lfS4gIElmIHRoZXJlIGFyZSBubwoJCQlyZW1haW5pbmcgaXRlbXMge2xhc3RuYW1lfSBpcyBzZXQgdG8gYW4gZW1wdHkgbGlzdC4KCQkJRXhhbXBsZTogPgoJCQkJOmxldCBbYSwgYjsgcmVzdF0gPSBbImF2YWwiLCAiYnZhbCIsIDMsIDRdCjwKOmxldCBbe25hbWV9LCAuLi4sIDsge2xhc3RuYW1lfV0gLj0ge2V4cHIxfQo6bGV0IFt7bmFtZX0sIC4uLiwgOyB7bGFzdG5hbWV9XSArPSB7ZXhwcjF9CjpsZXQgW3tuYW1lfSwgLi4uLCA7IHtsYXN0bmFtZX1dIC09IHtleHByMX0KCQkJTGlrZSBhYm92ZSwgYnV0IGFwcGVuZC9hZGQvc3VidHJhY3QgdGhlIHZhbHVlIGZvciBlYWNoCgkJCXxMaXN0fCBpdGVtLgoKCQkJCQkJCQkqRTEyMSoKOmxldCB7dmFyLW5hbWV9CS4uCUxpc3QgdGhlIHZhbHVlIG9mIHZhcmlhYmxlIHt2YXItbmFtZX0uCU11bHRpcGxlCgkJCXZhcmlhYmxlIG5hbWVzIG1heSBiZSBnaXZlbi4gIFNwZWNpYWwgbmFtZXMgcmVjb2duaXplZAoJCQloZXJlOgkJCQkqRTczOCoKCQkJICBnOglnbG9iYWwgdmFyaWFibGVzCgkJCSAgYjoJbG9jYWwgYnVmZmVyIHZhcmlhYmxlcwoJCQkgIHc6CWxvY2FsIHdpbmRvdyB2YXJpYWJsZXMKCQkJICB0Oglsb2NhbCB0YWIgcGFnZSB2YXJpYWJsZXMKCQkJICBzOglzY3JpcHQtbG9jYWwgdmFyaWFibGVzCgkJCSAgbDoJbG9jYWwgZnVuY3Rpb24gdmFyaWFibGVzCgkJCSAgdjoJVmltIHZhcmlhYmxlcy4KCjpsZXQJCQlMaXN0IHRoZSB2YWx1ZXMgb2YgYWxsIHZhcmlhYmxlcy4gIFRoZSB0eXBlIG9mIHRoZQoJCQl2YXJpYWJsZSBpcyBpbmRpY2F0ZWQgYmVmb3JlIHRoZSB2YWx1ZToKCQkJICAgIDxub3RoaW5nPglTdHJpbmcKCQkJCSMJTnVtYmVyCgkJCQkqCUZ1bmNyZWYKCgo6dW5sW2V0XVshXSB7bmFtZX0gLi4uCQkJCSo6dW5sZXQqICo6dW5sKiAqRTEwOCogKkU3OTUqCgkJCVJlbW92ZSB0aGUgaW50ZXJuYWwgdmFyaWFibGUge25hbWV9LiAgU2V2ZXJhbCB2YXJpYWJsZQoJCQluYW1lcyBjYW4gYmUgZ2l2ZW4sIHRoZXkgYXJlIGFsbCByZW1vdmVkLiAgVGhlIG5hbWUKCQkJbWF5IGFsc28gYmUgYSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IGl0ZW0uCgkJCVdpdGggWyFdIG5vIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4gZm9yIG5vbi1leGlzdGluZwoJCQl2YXJpYWJsZXMuCgkJCU9uZSBvciBtb3JlIGl0ZW1zIGZyb20gYSB8TGlzdHwgY2FuIGJlIHJlbW92ZWQ6ID4KCQkJCTp1bmxldCBsaXN0WzNdCSAgIiByZW1vdmUgZm91cnRoIGl0ZW0KCQkJCTp1bmxldCBsaXN0WzM6XSAgICIgcmVtb3ZlIGZvdXJ0aCBpdGVtIHRvIGxhc3QKPAkJCU9uZSBpdGVtIGZyb20gYSB8RGljdGlvbmFyeXwgY2FuIGJlIHJlbW92ZWQgYXQgYSB0aW1lOiA+CgkJCQk6dW5sZXQgZGljdFsndHdvJ10KCQkJCTp1bmxldCBkaWN0LnR3bwo8CQkJVGhpcyBpcyBlc3BlY2lhbGx5IHVzZWZ1bCB0byBjbGVhbiB1cCB1c2VkIGdsb2JhbAoJCQl2YXJpYWJsZXMgYW5kIHNjcmlwdC1sb2NhbCB2YXJpYWJsZXMgKHRoZXNlIGFyZSBub3QKCQkJZGVsZXRlZCB3aGVuIHRoZSBzY3JpcHQgZW5kcykuICBGdW5jdGlvbi1sb2NhbAoJCQl2YXJpYWJsZXMgYXJlIGF1dG9tYXRpY2FsbHkgZGVsZXRlZCB3aGVuIHRoZSBmdW5jdGlvbgoJCQllbmRzLgoKOmxvY2t2W2FyXVshXSBbZGVwdGhdIHtuYW1lfSAuLi4JCQkqOmxvY2t2YXIqICo6bG9ja3YqCgkJCUxvY2sgdGhlIGludGVybmFsIHZhcmlhYmxlIHtuYW1lfS4gIExvY2tpbmcgbWVhbnMgdGhhdAoJCQlpdCBjYW4gbm8gbG9uZ2VyIGJlIGNoYW5nZWQgKHVudGlsIGl0IGlzIHVubG9ja2VkKS4KCQkJQSBsb2NrZWQgdmFyaWFibGUgY2FuIGJlIGRlbGV0ZWQ6ID4KCQkJCTpsb2NrdmFyIHYKCQkJCTpsZXQgdiA9ICdhc2RmJwkJIiBmYWlscyEKCQkJCTp1bmxldCB2CjwJCQkJCQkJKkU3NDEqCgkJCUlmIHlvdSB0cnkgdG8gY2hhbmdlIGEgbG9ja2VkIHZhcmlhYmxlIHlvdSBnZXQgYW4KCQkJZXJyb3IgbWVzc2FnZTogIkU3NDE6IFZhbHVlIGlzIGxvY2tlZDoge25hbWV9IgoKCQkJW2RlcHRoXSBpcyByZWxldmFudCB3aGVuIGxvY2tpbmcgYSB8TGlzdHwgb3IKCQkJfERpY3Rpb25hcnl8LiAgSXQgc3BlY2lmaWVzIGhvdyBkZWVwIHRoZSBsb2NraW5nIGdvZXM6CgkJCQkxCUxvY2sgdGhlIHxMaXN0fCBvciB8RGljdGlvbmFyeXwgaXRzZWxmLAoJCQkJCWNhbm5vdCBhZGQgb3IgcmVtb3ZlIGl0ZW1zLCBidXQgY2FuCgkJCQkJc3RpbGwgY2hhbmdlIHRoZWlyIHZhbHVlcy4KCQkJCTIJQWxzbyBsb2NrIHRoZSB2YWx1ZXMsIGNhbm5vdCBjaGFuZ2UKCQkJCQl0aGUgaXRlbXMuICBJZiBhbiBpdGVtIGlzIGEgfExpc3R8IG9yCgkJCQkJfERpY3Rpb25hcnl8LCBjYW5ub3QgYWRkIG9yIHJlbW92ZQoJCQkJCWl0ZW1zLCBidXQgY2FuIHN0aWxsIGNoYW5nZSB0aGUKCQkJCQl2YWx1ZXMuCgkJCQkzCUxpa2UgMiBidXQgZm9yIHRoZSB8TGlzdHwgLwoJCQkJCXxEaWN0aW9uYXJ5fCBpbiB0aGUgfExpc3R8IC8KCQkJCQl8RGljdGlvbmFyeXwsIG9uZSBsZXZlbCBkZWVwZXIuCgkJCVRoZSBkZWZhdWx0IFtkZXB0aF0gaXMgMiwgdGh1cyB3aGVuIHtuYW1lfSBpcyBhIHxMaXN0fAoJCQlvciB8RGljdGlvbmFyeXwgdGhlIHZhbHVlcyBjYW5ub3QgYmUgY2hhbmdlZC4KCQkJCQkJCQkqRTc0MyoKCQkJRm9yIHVubGltaXRlZCBkZXB0aCB1c2UgWyFdIGFuZCBvbWl0IFtkZXB0aF0uCgkJCUhvd2V2ZXIsIHRoZXJlIGlzIGEgbWF4aW11bSBkZXB0aCBvZiAxMDAgdG8gY2F0Y2gKCQkJbG9vcHMuCgoJCQlOb3RlIHRoYXQgd2hlbiB0d28gdmFyaWFibGVzIHJlZmVyIHRvIHRoZSBzYW1lIHxMaXN0fAoJCQlhbmQgeW91IGxvY2sgb25lIG9mIHRoZW0sIHRoZSB8TGlzdHwgd2lsbCBhbHNvIGJlCgkJCWxvY2tlZCB3aGVuIHVzZWQgdGhyb3VnaCB0aGUgb3RoZXIgdmFyaWFibGUuCgkJCUV4YW1wbGU6ID4KCQkJCTpsZXQgbCA9IFswLCAxLCAyLCAzXQoJCQkJOmxldCBjbCA9IGwKCQkJCTpsb2NrdmFyIGwKCQkJCTpsZXQgY2xbMV0gPSA5OQkJIiB3b24ndCB3b3JrIQo8CQkJWW91IG1heSB3YW50IHRvIG1ha2UgYSBjb3B5IG9mIGEgbGlzdCB0byBhdm9pZCB0aGlzLgoJCQlTZWUgfGRlZXBjb3B5KCl8LgoKCjp1bmxvW2NrdmFyXVshXSBbZGVwdGhdIHtuYW1lfSAuLi4JCQkqOnVubG9ja3ZhciogKjp1bmxvKgoJCQlVbmxvY2sgdGhlIGludGVybmFsIHZhcmlhYmxlIHtuYW1lfS4gIERvZXMgdGhlCgkJCW9wcG9zaXRlIG9mIHw6bG9ja3ZhcnwuCgoKOmlmIHtleHByMX0JCQkqOmlmKiAqOmVuZGlmKiAqOmVuKiAqRTE3MSogKkU1NzkqICpFNTgwKgo6ZW5bZGlmXQkJRXhlY3V0ZSB0aGUgY29tbWFuZHMgdW50aWwgdGhlIG5leHQgbWF0Y2hpbmcgIjplbHNlIgoJCQlvciAiOmVuZGlmIiBpZiB7ZXhwcjF9IGV2YWx1YXRlcyB0byBub24temVyby4KCgkJCUZyb20gVmltIHZlcnNpb24gNC41IHVudGlsIDUuMCwgZXZlcnkgRXggY29tbWFuZCBpbgoJCQliZXR3ZWVuIHRoZSAiOmlmIiBhbmQgIjplbmRpZiIgaXMgaWdub3JlZC4gIFRoZXNlIHR3bwoJCQljb21tYW5kcyB3ZXJlIGp1c3QgdG8gYWxsb3cgZm9yIGZ1dHVyZSBleHBhbnNpb25zIGluIGEKCQkJYmFja3dhcmQgY29tcGF0aWJsZSB3YXkuICBOZXN0aW5nIHdhcyBhbGxvd2VkLiAgTm90ZQoJCQl0aGF0IGFueSAiOmVsc2UiIG9yICI6ZWxzZWlmIiB3YXMgaWdub3JlZCwgdGhlICJlbHNlIgoJCQlwYXJ0IHdhcyBub3QgZXhlY3V0ZWQgZWl0aGVyLgoKCQkJWW91IGNhbiB1c2UgdGhpcyB0byByZW1haW4gY29tcGF0aWJsZSB3aXRoIG9sZGVyCgkJCXZlcnNpb25zOiA+CgkJCQk6aWYgdmVyc2lvbiA+PSA1MDAKCQkJCTogIHZlcnNpb24tNS1zcGVjaWZpYy1jb21tYW5kcwoJCQkJOmVuZGlmCjwJCQlUaGUgY29tbWFuZHMgc3RpbGwgbmVlZCB0byBiZSBwYXJzZWQgdG8gZmluZCB0aGUKCQkJImVuZGlmIi4gIFNvbWV0aW1lcyBhbiBvbGRlciBWaW0gaGFzIGEgcHJvYmxlbSB3aXRoIGEKCQkJbmV3IGNvbW1hbmQuICBGb3IgZXhhbXBsZSwgIjpzaWxlbnQiIGlzIHJlY29nbml6ZWQgYXMKCQkJYSAiOnN1YnN0aXR1dGUiIGNvbW1hbmQuICBJbiB0aGF0IGNhc2UgIjpleGVjdXRlIiBjYW4KCQkJYXZvaWQgcHJvYmxlbXM6ID4KCQkJCTppZiB2ZXJzaW9uID49IDYwMAoJCQkJOiAgZXhlY3V0ZSAic2lsZW50IDEsJGRlbGV0ZSIKCQkJCTplbmRpZgo8CgkJCU5PVEU6IFRoZSAiOmFwcGVuZCIgYW5kICI6aW5zZXJ0IiBjb21tYW5kcyBkb24ndCB3b3JrCgkJCXByb3Blcmx5IGluIGJldHdlZW4gIjppZiIgYW5kICI6ZW5kaWYiLgoKCQkJCQkJKjplbHNlKiAqOmVsKiAqRTU4MSogKkU1ODMqCjplbFtzZV0JCQlFeGVjdXRlIHRoZSBjb21tYW5kcyB1bnRpbCB0aGUgbmV4dCBtYXRjaGluZyAiOmVsc2UiCgkJCW9yICI6ZW5kaWYiIGlmIHRoZXkgcHJldmlvdXNseSB3ZXJlIG5vdCBiZWluZwoJCQlleGVjdXRlZC4KCgkJCQkJKjplbHNlaWYqICo6ZWxzZWkqICpFNTgyKiAqRTU4NCoKOmVsc2VpW2ZdIHtleHByMX0JU2hvcnQgZm9yICI6ZWxzZSIgIjppZiIsIHdpdGggdGhlIGFkZGl0aW9uIHRoYXQgdGhlcmUKCQkJaXMgbm8gZXh0cmEgIjplbmRpZiIuCgo6d2hbaWxlXSB7ZXhwcjF9CQkJKjp3aGlsZSogKjplbmR3aGlsZSogKjp3aCogKjplbmR3KgoJCQkJCQkqRTE3MCogKkU1ODUqICpFNTg4KiAqRTczMyoKOmVuZHdbaGlsZV0JCVJlcGVhdCB0aGUgY29tbWFuZHMgYmV0d2VlbiAiOndoaWxlIiBhbmQgIjplbmR3aGlsZSIsCgkJCWFzIGxvbmcgYXMge2V4cHIxfSBldmFsdWF0ZXMgdG8gbm9uLXplcm8uCgkJCVdoZW4gYW4gZXJyb3IgaXMgZGV0ZWN0ZWQgZnJvbSBhIGNvbW1hbmQgaW5zaWRlIHRoZQoJCQlsb29wLCBleGVjdXRpb24gY29udGludWVzIGFmdGVyIHRoZSAiZW5kd2hpbGUiLgoJCQlFeGFtcGxlOiA+CgkJCQk6bGV0IGxudW0gPSAxCgkJCQk6d2hpbGUgbG51bSA8PSBsaW5lKCIkIikKCQkJCSAgIDpjYWxsIEZpeExpbmUobG51bSkKCQkJCSAgIDpsZXQgbG51bSA9IGxudW0gKyAxCgkJCQk6ZW5kd2hpbGUKPAoJCQlOT1RFOiBUaGUgIjphcHBlbmQiIGFuZCAiOmluc2VydCIgY29tbWFuZHMgZG9uJ3Qgd29yawoJCQlwcm9wZXJseSBpbnNpZGUgYSAiOndoaWxlIiBhbmQgIjpmb3IiIGxvb3AuCgo6Zm9yIHt2YXJ9IGluIHtsaXN0fQkJCQkJKjpmb3IqICpFNjkwKiAqRTczMioKOmVuZGZvW3JdCQkJCQkJKjplbmRmbyogKjplbmRmb3IqCgkJCVJlcGVhdCB0aGUgY29tbWFuZHMgYmV0d2VlbiAiOmZvciIgYW5kICI6ZW5kZm9yIiBmb3IKCQkJZWFjaCBpdGVtIGluIHtsaXN0fS4gIFZhcmlhYmxlIHt2YXJ9IGlzIHNldCB0byB0aGUKCQkJdmFsdWUgb2YgZWFjaCBpdGVtLgoJCQlXaGVuIGFuIGVycm9yIGlzIGRldGVjdGVkIGZvciBhIGNvbW1hbmQgaW5zaWRlIHRoZQoJCQlsb29wLCBleGVjdXRpb24gY29udGludWVzIGFmdGVyIHRoZSAiZW5kZm9yIi4KCQkJQ2hhbmdpbmcge2xpc3R9IGluc2lkZSB0aGUgbG9vcCBhZmZlY3RzIHdoYXQgaXRlbXMgYXJlCgkJCXVzZWQuICBNYWtlIGEgY29weSBpZiB0aGlzIGlzIHVud2FudGVkOiA+CgkJCQk6Zm9yIGl0ZW0gaW4gY29weShteWxpc3QpCjwJCQlXaGVuIG5vdCBtYWtpbmcgYSBjb3B5LCBWaW0gc3RvcmVzIGEgcmVmZXJlbmNlIHRvIHRoZQoJCQluZXh0IGl0ZW0gaW4gdGhlIGxpc3QsIGJlZm9yZSBleGVjdXRpbmcgdGhlIGNvbW1hbmRzCgkJCXdpdGggdGhlIGN1cnJlbnQgaXRlbS4JVGh1cyB0aGUgY3VycmVudCBpdGVtIGNhbiBiZQoJCQlyZW1vdmVkIHdpdGhvdXQgZWZmZWN0LiAgUmVtb3ZpbmcgYW55IGxhdGVyIGl0ZW0gbWVhbnMKCQkJaXQgd2lsbCBub3QgYmUgZm91bmQuICBUaHVzIHRoZSBmb2xsb3dpbmcgZXhhbXBsZQoJCQl3b3JrcyAoYW4gaW5lZmZpY2llbnQgd2F5IHRvIG1ha2UgYSBsaXN0IGVtcHR5KTogPgoJCQkJZm9yIGl0ZW0gaW4gbXlsaXN0CgkJCQkgICBjYWxsIHJlbW92ZShteWxpc3QsIDApCgkJCQllbmRmb3IKPAkJCU5vdGUgdGhhdCByZW9yZGVyaW5nIHRoZSBsaXN0IChlLmcuLCB3aXRoIHNvcnQoKSBvcgoJCQlyZXZlcnNlKCkpIG1heSBoYXZlIHVuZXhwZWN0ZWQgZWZmZWN0cy4KCjpmb3IgW3t2YXIxfSwge3ZhcjJ9LCAuLi5dIGluIHtsaXN0bGlzdH0KOmVuZGZvW3JdCgkJCUxpa2UgIjpmb3IiIGFib3ZlLCBidXQgZWFjaCBpdGVtIGluIHtsaXN0bGlzdH0gbXVzdCBiZQoJCQlhIGxpc3QsIG9mIHdoaWNoIGVhY2ggaXRlbSBpcyBhc3NpZ25lZCB0byB7dmFyMX0sCgkJCXt2YXIyfSwgZXRjLiAgRXhhbXBsZTogPgoJCQkJOmZvciBbbG51bSwgY29sXSBpbiBbWzEsIDNdLCBbMiwgNV0sIFszLCA4XV0KCQkJCSAgIDplY2hvIGdldGxpbmUobG51bSlbY29sXQoJCQkJOmVuZGZvcgo8CgkJCQkJCSo6Y29udGludWUqICo6Y29uKiAqRTU4NioKOmNvblt0aW51ZV0JCVdoZW4gdXNlZCBpbnNpZGUgYSAiOndoaWxlIiBvciAiOmZvciIgbG9vcCwganVtcHMgYmFjawoJCQl0byB0aGUgc3RhcnQgb2YgdGhlIGxvb3AuCgkJCUlmIGl0IGlzIHVzZWQgYWZ0ZXIgYSB8OnRyeXwgaW5zaWRlIHRoZSBsb29wIGJ1dAoJCQliZWZvcmUgdGhlIG1hdGNoaW5nIHw6ZmluYWxseXwgKGlmIHByZXNlbnQpLCB0aGUKCQkJY29tbWFuZHMgZm9sbG93aW5nIHRoZSAiOmZpbmFsbHkiIHVwIHRvIHRoZSBtYXRjaGluZwoJCQl8OmVuZHRyeXwgYXJlIGV4ZWN1dGVkIGZpcnN0LiAgVGhpcyBwcm9jZXNzIGFwcGxpZXMgdG8KCQkJYWxsIG5lc3RlZCAiOnRyeSJzIGluc2lkZSB0aGUgbG9vcC4gIFRoZSBvdXRlcm1vc3QKCQkJIjplbmR0cnkiIHRoZW4ganVtcHMgYmFjayB0byB0aGUgc3RhcnQgb2YgdGhlIGxvb3AuCgoJCQkJCQkqOmJyZWFrKiAqOmJyZWEqICpFNTg3Kgo6YnJlYVtrXQkJV2hlbiB1c2VkIGluc2lkZSBhICI6d2hpbGUiIG9yICI6Zm9yIiBsb29wLCBza2lwcyB0bwoJCQl0aGUgY29tbWFuZCBhZnRlciB0aGUgbWF0Y2hpbmcgIjplbmR3aGlsZSIgb3IKCQkJIjplbmRmb3IiLgoJCQlJZiBpdCBpcyB1c2VkIGFmdGVyIGEgfDp0cnl8IGluc2lkZSB0aGUgbG9vcCBidXQKCQkJYmVmb3JlIHRoZSBtYXRjaGluZyB8OmZpbmFsbHl8IChpZiBwcmVzZW50KSwgdGhlCgkJCWNvbW1hbmRzIGZvbGxvd2luZyB0aGUgIjpmaW5hbGx5IiB1cCB0byB0aGUgbWF0Y2hpbmcKCQkJfDplbmR0cnl8IGFyZSBleGVjdXRlZCBmaXJzdC4gIFRoaXMgcHJvY2VzcyBhcHBsaWVzIHRvCgkJCWFsbCBuZXN0ZWQgIjp0cnkicyBpbnNpZGUgdGhlIGxvb3AuICBUaGUgb3V0ZXJtb3N0CgkJCSI6ZW5kdHJ5IiB0aGVuIGp1bXBzIHRvIHRoZSBjb21tYW5kIGFmdGVyIHRoZSBsb29wLgoKOnRyeQkJCQkqOnRyeSogKjplbmR0KiAqOmVuZHRyeSogKkU2MDAqICpFNjAxKiAqRTYwMioKOmVuZHRbcnldCQlDaGFuZ2UgdGhlIGVycm9yIGhhbmRsaW5nIGZvciB0aGUgY29tbWFuZHMgYmV0d2VlbgoJCQkiOnRyeSIgYW5kICI6ZW5kdHJ5IiBpbmNsdWRpbmcgZXZlcnl0aGluZyBiZWluZwoJCQlleGVjdXRlZCBhY3Jvc3MgIjpzb3VyY2UiIGNvbW1hbmRzLCBmdW5jdGlvbiBjYWxscywKCQkJb3IgYXV0b2NvbW1hbmQgaW52b2NhdGlvbnMuCgoJCQlXaGVuIGFuIGVycm9yIG9yIGludGVycnVwdCBpcyBkZXRlY3RlZCBhbmQgdGhlcmUgaXMKCQkJYSB8OmZpbmFsbHl8IGNvbW1hbmQgZm9sbG93aW5nLCBleGVjdXRpb24gY29udGludWVzCgkJCWFmdGVyIHRoZSAiOmZpbmFsbHkiLiAgT3RoZXJ3aXNlLCBvciB3aGVuIHRoZQoJCQkiOmVuZHRyeSIgaXMgcmVhY2hlZCB0aGVyZWFmdGVyLCB0aGUgbmV4dAoJCQkoZHluYW1pY2FsbHkpIHN1cnJvdW5kaW5nICI6dHJ5IiBpcyBjaGVja2VkIGZvcgoJCQlhIGNvcnJlc3BvbmRpbmcgIjpmaW5hbGx5IiBldGMuICBUaGVuIHRoZSBzY3JpcHQKCQkJcHJvY2Vzc2luZyBpcyB0ZXJtaW5hdGVkLiAgKFdoZXRoZXIgYSBmdW5jdGlvbgoJCQlkZWZpbml0aW9uIGhhcyBhbiAiYWJvcnQiIGFyZ3VtZW50IGRvZXMgbm90IG1hdHRlci4pCgkJCUV4YW1wbGU6ID4KCQk6dHJ5IHwgZWRpdCB0b28gbXVjaCB8IGZpbmFsbHkgfCBlY2hvICJjbGVhbnVwIiB8IGVuZHRyeQoJCTplY2hvICJpbXBvc3NpYmxlIgkiIG5vdCByZWFjaGVkLCBzY3JpcHQgdGVybWluYXRlZCBhYm92ZQo8CgkJCU1vcmVvdmVyLCBhbiBlcnJvciBvciBpbnRlcnJ1cHQgKGR5bmFtaWNhbGx5KSBpbnNpZGUKCQkJIjp0cnkiIGFuZCAiOmVuZHRyeSIgaXMgY29udmVydGVkIHRvIGFuIGV4Y2VwdGlvbi4gIEl0CgkJCWNhbiBiZSBjYXVnaHQgYXMgaWYgaXQgd2VyZSB0aHJvd24gYnkgYSB8OnRocm93fAoJCQljb21tYW5kIChzZWUgfDpjYXRjaHwpLiAgSW4gdGhpcyBjYXNlLCB0aGUgc2NyaXB0CgkJCXByb2Nlc3NpbmcgaXMgbm90IHRlcm1pbmF0ZWQuCgoJCQlUaGUgdmFsdWUgIlZpbTpJbnRlcnJ1cHQiIGlzIHVzZWQgZm9yIGFuIGludGVycnVwdAoJCQlleGNlcHRpb24uICBBbiBlcnJvciBpbiBhIFZpbSBjb21tYW5kIGlzIGNvbnZlcnRlZAoJCQl0byBhIHZhbHVlIG9mIHRoZSBmb3JtICJWaW0oe2NvbW1hbmR9KTp7ZXJybXNnfSIsCgkJCW90aGVyIGVycm9ycyBhcmUgY29udmVydGVkIHRvIGEgdmFsdWUgb2YgdGhlIGZvcm0KCQkJIlZpbTp7ZXJybXNnfSIuICB7Y29tbWFuZH0gaXMgdGhlIGZ1bGwgY29tbWFuZCBuYW1lLAoJCQlhbmQge2Vycm1zZ30gaXMgdGhlIG1lc3NhZ2UgdGhhdCBpcyBkaXNwbGF5ZWQgaWYgdGhlCgkJCWVycm9yIGV4Y2VwdGlvbiBpcyBub3QgY2F1Z2h0LCBhbHdheXMgYmVnaW5uaW5nIHdpdGgKCQkJdGhlIGVycm9yIG51bWJlci4KCQkJRXhhbXBsZXM6ID4KCQk6dHJ5IHwgc2xlZXAgMTAwIHwgY2F0Y2ggL15WaW06SW50ZXJydXB0JC8gfCBlbmR0cnkKCQk6dHJ5IHwgZWRpdCB8IGNhdGNoIC9eVmltKGVkaXQpOkVcZFwrLyB8IGVjaG8gImVycm9yIiB8IGVuZHRyeQo8CgkJCQkJKjpjYXQqICo6Y2F0Y2gqICpFNjAzKiAqRTYwNCogKkU2MDUqCjpjYXRbY2hdIC97cGF0dGVybn0vCVRoZSBmb2xsb3dpbmcgY29tbWFuZHMgdW50aWwgdGhlIG5leHQgfDpjYXRjaHwsCgkJCXw6ZmluYWxseXwsIG9yIHw6ZW5kdHJ5fCB0aGF0IGJlbG9uZ3MgdG8gdGhlIHNhbWUKCQkJfDp0cnl8IGFzIHRoZSAiOmNhdGNoIiBhcmUgZXhlY3V0ZWQgd2hlbiBhbiBleGNlcHRpb24KCQkJbWF0Y2hpbmcge3BhdHRlcm59IGlzIGJlaW5nIHRocm93biBhbmQgaGFzIG5vdCB5ZXQKCQkJYmVlbiBjYXVnaHQgYnkgYSBwcmV2aW91cyAiOmNhdGNoIi4gIE90aGVyd2lzZSwgdGhlc2UKCQkJY29tbWFuZHMgYXJlIHNraXBwZWQuCgkJCVdoZW4ge3BhdHRlcm59IGlzIG9taXR0ZWQgYWxsIGVycm9ycyBhcmUgY2F1Z2h0LgoJCQlFeGFtcGxlczogPgoJCTpjYXRjaCAvXlZpbTpJbnRlcnJ1cHQkLwkiIGNhdGNoIGludGVycnVwdHMgKENUUkwtQykKCQk6Y2F0Y2ggL15WaW1cJSgoXGFcKylcKVw9OkUvCSIgY2F0Y2ggYWxsIFZpbSBlcnJvcnMKCQk6Y2F0Y2ggL15WaW1cJSgoXGFcKylcKVw9Oi8JIiBjYXRjaCBlcnJvcnMgYW5kIGludGVycnVwdHMKCQk6Y2F0Y2ggL15WaW0od3JpdGUpOi8JCSIgY2F0Y2ggYWxsIGVycm9ycyBpbiA6d3JpdGUKCQk6Y2F0Y2ggL15WaW1cJSgoXGFcKylcKVw9OkUxMjMvCSIgY2F0Y2ggZXJyb3IgRTEyMwoJCTpjYXRjaCAvbXktZXhjZXB0aW9uLwkJIiBjYXRjaCB1c2VyIGV4Y2VwdGlvbgoJCTpjYXRjaCAvLiovCQkJIiBjYXRjaCBldmVyeXRoaW5nCgkJOmNhdGNoCQkJCSIgc2FtZSBhcyAvLiovCjwKCQkJQW5vdGhlciBjaGFyYWN0ZXIgY2FuIGJlIHVzZWQgaW5zdGVhZCBvZiAvIGFyb3VuZCB0aGUKCQkJe3BhdHRlcm59LCBzbyBsb25nIGFzIGl0IGRvZXMgbm90IGhhdmUgYSBzcGVjaWFsCgkJCW1lYW5pbmcgKGUuZy4sICd8JyBvciAnIicpIGFuZCBkb2Vzbid0IG9jY3VyIGluc2lkZQoJCQl7cGF0dGVybn0uCgkJCUluZm9ybWF0aW9uIGFib3V0IHRoZSBleGNlcHRpb24gaXMgYXZhaWxhYmxlIGluCgkJCXx2OmV4Y2VwdGlvbnwuICBBbHNvIHNlZSB8dGhyb3ctdmFyaWFibGVzfC4KCQkJTk9URTogSXQgaXMgbm90IHJlbGlhYmxlIHRvICI6Y2F0Y2giIHRoZSBURVhUIG9mCgkJCWFuIGVycm9yIG1lc3NhZ2UgYmVjYXVzZSBpdCBtYXkgdmFyeSBpbiBkaWZmZXJlbnQKCQkJbG9jYWxlcy4KCgkJCQkJKjpmaW5hKiAqOmZpbmFsbHkqICpFNjA2KiAqRTYwNyoKOmZpbmFbbGx5XQkJVGhlIGZvbGxvd2luZyBjb21tYW5kcyB1bnRpbCB0aGUgbWF0Y2hpbmcgfDplbmR0cnl8CgkJCWFyZSBleGVjdXRlZCB3aGVuZXZlciB0aGUgcGFydCBiZXR3ZWVuIHRoZSBtYXRjaGluZwoJCQl8OnRyeXwgYW5kIHRoZSAiOmZpbmFsbHkiIGlzIGxlZnQ6ICBlaXRoZXIgYnkgZmFsbGluZwoJCQl0aHJvdWdoIHRvIHRoZSAiOmZpbmFsbHkiIG9yIGJ5IGEgfDpjb250aW51ZXwsCgkJCXw6YnJlYWt8LCB8OmZpbmlzaHwsIG9yIHw6cmV0dXJufCwgb3IgYnkgYW4gZXJyb3Igb3IKCQkJaW50ZXJydXB0IG9yIGV4Y2VwdGlvbiAoc2VlIHw6dGhyb3d8KS4KCgkJCQkJCQkqOnRoKiAqOnRocm93KiAqRTYwOCoKOnRoW3Jvd10ge2V4cHIxfQlUaGUge2V4cHIxfSBpcyBldmFsdWF0ZWQgYW5kIHRocm93biBhcyBhbiBleGNlcHRpb24uCgkJCUlmIHRoZSAiOnRocm93IiBpcyB1c2VkIGFmdGVyIGEgfDp0cnl8IGJ1dCBiZWZvcmUgdGhlCgkJCWZpcnN0IGNvcnJlc3BvbmRpbmcgfDpjYXRjaHwsIGNvbW1hbmRzIGFyZSBza2lwcGVkCgkJCXVudGlsIHRoZSBmaXJzdCAiOmNhdGNoIiBtYXRjaGluZyB7ZXhwcjF9IGlzIHJlYWNoZWQuCgkJCUlmIHRoZXJlIGlzIG5vIHN1Y2ggIjpjYXRjaCIgb3IgaWYgdGhlICI6dGhyb3ciIGlzCgkJCXVzZWQgYWZ0ZXIgYSAiOmNhdGNoIiBidXQgYmVmb3JlIHRoZSB8OmZpbmFsbHl8LCB0aGUKCQkJY29tbWFuZHMgZm9sbG93aW5nIHRoZSAiOmZpbmFsbHkiIChpZiBwcmVzZW50KSB1cCB0bwoJCQl0aGUgbWF0Y2hpbmcgfDplbmR0cnl8IGFyZSBleGVjdXRlZC4gIElmIHRoZSAiOnRocm93IgoJCQlpcyBhZnRlciB0aGUgIjpmaW5hbGx5IiwgY29tbWFuZHMgdXAgdG8gdGhlICI6ZW5kdHJ5IgoJCQlhcmUgc2tpcHBlZC4gIEF0IHRoZSAiOmVuZHRyeSIsIHRoaXMgcHJvY2VzcyBhcHBsaWVzCgkJCWFnYWluIGZvciB0aGUgbmV4dCBkeW5hbWljYWxseSBzdXJyb3VuZGluZyAiOnRyeSIKCQkJKHdoaWNoIG1heSBiZSBmb3VuZCBpbiBhIGNhbGxpbmcgZnVuY3Rpb24gb3Igc291cmNpbmcKCQkJc2NyaXB0KSwgdW50aWwgYSBtYXRjaGluZyAiOmNhdGNoIiBoYXMgYmVlbiBmb3VuZC4KCQkJSWYgdGhlIGV4Y2VwdGlvbiBpcyBub3QgY2F1Z2h0LCB0aGUgY29tbWFuZCBwcm9jZXNzaW5nCgkJCWlzIHRlcm1pbmF0ZWQuCgkJCUV4YW1wbGU6ID4KCQk6dHJ5IHwgdGhyb3cgIm9vcHMiIHwgY2F0Y2ggL15vby8gfCBlY2hvICJjYXVnaHQiIHwgZW5kdHJ5CjwJCQlOb3RlIHRoYXQgImNhdGNoIiBtYXkgbmVlZCB0byBiZSBvbiBhIHNlcGFyYXRlIGxpbmUKCQkJZm9yIHdoZW4gYW4gZXJyb3IgY2F1c2VzIHRoZSBwYXJzaW5nIHRvIHNraXAgdGhlIHdob2xlCgkJCWxpbmUgYW5kIG5vdCBzZWUgdGhlICJ8IiB0aGF0IHNlcGFyYXRlcyB0aGUgY29tbWFuZHMuCgoJCQkJCQkJKjplYyogKjplY2hvKgo6ZWNbaG9dIHtleHByMX0gLi4JRWNob2VzIGVhY2gge2V4cHIxfSwgd2l0aCBhIHNwYWNlIGluIGJldHdlZW4uICBUaGUKCQkJZmlyc3Qge2V4cHIxfSBzdGFydHMgb24gYSBuZXcgbGluZS4KCQkJQWxzbyBzZWUgfDpjb21tZW50fC4KCQkJVXNlICJcbiIgdG8gc3RhcnQgYSBuZXcgbGluZS4gIFVzZSAiXHIiIHRvIG1vdmUgdGhlCgkJCWN1cnNvciB0byB0aGUgZmlyc3QgY29sdW1uLgoJCQlVc2VzIHRoZSBoaWdobGlnaHRpbmcgc2V0IGJ5IHRoZSB8OmVjaG9obHwgY29tbWFuZC4KCQkJQ2Fubm90IGJlIGZvbGxvd2VkIGJ5IGEgY29tbWVudC4KCQkJRXhhbXBsZTogPgoJCTplY2hvICJ0aGUgdmFsdWUgb2YgJ3NoZWxsJyBpcyIgJnNoZWxsCjwJCQkJCQkJKjplY2hvLXJlZHJhdyoKCQkJQSBsYXRlciByZWRyYXcgbWF5IG1ha2UgdGhlIG1lc3NhZ2UgZGlzYXBwZWFyIGFnYWluLgoJCQlBbmQgc2luY2UgVmltIG1vc3RseSBwb3N0cG9uZXMgcmVkcmF3aW5nIHVudGlsIGl0J3MKCQkJZmluaXNoZWQgd2l0aCBhIHNlcXVlbmNlIG9mIGNvbW1hbmRzIHRoaXMgaGFwcGVucwoJCQlxdWl0ZSBvZnRlbi4gIFRvIGF2b2lkIHRoYXQgYSBjb21tYW5kIGZyb20gYmVmb3JlIHRoZQoJCQkiOmVjaG8iIGNhdXNlcyBhIHJlZHJhdyBhZnRlcndhcmRzIChyZWRyYXdzIGFyZSBvZnRlbgoJCQlwb3N0cG9uZWQgdW50aWwgeW91IHR5cGUgc29tZXRoaW5nKSwgZm9yY2UgYSByZWRyYXcKCQkJd2l0aCB0aGUgfDpyZWRyYXd8IGNvbW1hbmQuICBFeGFtcGxlOiA+CgkJOm5ldyB8IHJlZHJhdyB8IGVjaG8gInRoZXJlIGlzIGEgbmV3IHdpbmRvdyIKPAoJCQkJCQkJKjplY2hvbioKOmVjaG9uIHtleHByMX0gLi4JRWNob2VzIGVhY2gge2V4cHIxfSwgd2l0aG91dCBhbnl0aGluZyBhZGRlZC4gIEFsc28gc2VlCgkJCXw6Y29tbWVudHwuCgkJCVVzZXMgdGhlIGhpZ2hsaWdodGluZyBzZXQgYnkgdGhlIHw6ZWNob2hsfCBjb21tYW5kLgoJCQlDYW5ub3QgYmUgZm9sbG93ZWQgYnkgYSBjb21tZW50LgoJCQlFeGFtcGxlOiA+CgkJCQk6ZWNob24gInRoZSB2YWx1ZSBvZiAnc2hlbGwnIGlzICIgJnNoZWxsCjwKCQkJTm90ZSB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHVzaW5nICI6ZWNobyIsIHdoaWNoIGlzIGEKCQkJVmltIGNvbW1hbmQsIGFuZCAiOiFlY2hvIiwgd2hpY2ggaXMgYW4gZXh0ZXJuYWwgc2hlbGwKCQkJY29tbWFuZDogPgoJCTohZWNobyAlCQktLT4gZmlsZW5hbWUKPAkJCVRoZSBhcmd1bWVudHMgb2YgIjohIiBhcmUgZXhwYW5kZWQsIHNlZSB8Ol8lfC4gPgoJCTohZWNobyAiJSIJCS0tPiBmaWxlbmFtZSBvciAiZmlsZW5hbWUiCjwJCQlMaWtlIHRoZSBwcmV2aW91cyBleGFtcGxlLiAgV2hldGhlciB5b3Ugc2VlIHRoZSBkb3VibGUKCQkJcXVvdGVzIG9yIG5vdCBkZXBlbmRzIG9uIHlvdXIgJ3NoZWxsJy4gPgoJCTplY2hvICUJCQktLT4gbm90aGluZwo8CQkJVGhlICclJyBpcyBhbiBpbGxlZ2FsIGNoYXJhY3RlciBpbiBhbiBleHByZXNzaW9uLiA+CgkJOmVjaG8gIiUiCQktLT4gJQo8CQkJVGhpcyBqdXN0IGVjaG9lcyB0aGUgJyUnIGNoYXJhY3Rlci4gPgoJCTplY2hvIGV4cGFuZCgiJSIpCS0tPiBmaWxlbmFtZQo8CQkJVGhpcyBjYWxscyB0aGUgZXhwYW5kKCkgZnVuY3Rpb24gdG8gZXhwYW5kIHRoZSAnJScuCgoJCQkJCQkJKjplY2hvaCogKjplY2hvaGwqCjplY2hvaFtsXSB7bmFtZX0JVXNlIHRoZSBoaWdobGlnaHQgZ3JvdXAge25hbWV9IGZvciB0aGUgZm9sbG93aW5nCgkJCXw6ZWNob3wsIHw6ZWNob258IGFuZCB8OmVjaG9tc2d8IGNvbW1hbmRzLiAgQWxzbyB1c2VkCgkJCWZvciB0aGUgfGlucHV0KCl8IHByb21wdC4gIEV4YW1wbGU6ID4KCQk6ZWNob2hsIFdhcm5pbmdNc2cgfCBlY2hvICJEb24ndCBwYW5pYyEiIHwgZWNob2hsIE5vbmUKPAkJCURvbid0IGZvcmdldCB0byBzZXQgdGhlIGdyb3VwIGJhY2sgdG8gIk5vbmUiLAoJCQlvdGhlcndpc2UgYWxsIGZvbGxvd2luZyBlY2hvJ3Mgd2lsbCBiZSBoaWdobGlnaHRlZC4KCgkJCQkJCQkqOmVjaG9tKiAqOmVjaG9tc2cqCjplY2hvbVtzZ10ge2V4cHIxfSAuLglFY2hvIHRoZSBleHByZXNzaW9uKHMpIGFzIGEgdHJ1ZSBtZXNzYWdlLCBzYXZpbmcgdGhlCgkJCW1lc3NhZ2UgaW4gdGhlIHxtZXNzYWdlLWhpc3Rvcnl8LgoJCQlTcGFjZXMgYXJlIHBsYWNlZCBiZXR3ZWVuIHRoZSBhcmd1bWVudHMgYXMgd2l0aCB0aGUKCQkJfDplY2hvfCBjb21tYW5kLiAgQnV0IHVucHJpbnRhYmxlIGNoYXJhY3RlcnMgYXJlCgkJCWRpc3BsYXllZCwgbm90IGludGVycHJldGVkLgoJCQlUaGUgcGFyc2luZyB3b3JrcyBzbGlnaHRseSBkaWZmZXJlbnQgZnJvbSB8OmVjaG98LAoJCQltb3JlIGxpa2UgfDpleGVjdXRlfC4gIEFsbCB0aGUgZXhwcmVzc2lvbnMgYXJlIGZpcnN0CgkJCWV2YWx1YXRlZCBhbmQgY29uY2F0ZW5hdGVkIGJlZm9yZSBlY2hvaW5nIGFueXRoaW5nLgoJCQlUaGUgZXhwcmVzc2lvbnMgbXVzdCBldmFsdWF0ZSB0byBhIE51bWJlciBvciBTdHJpbmcsIGEKCQkJRGljdGlvbmFyeSBvciBMaXN0IGNhdXNlcyBhbiBlcnJvci4KCQkJVXNlcyB0aGUgaGlnaGxpZ2h0aW5nIHNldCBieSB0aGUgfDplY2hvaGx8IGNvbW1hbmQuCgkJCUV4YW1wbGU6ID4KCQk6ZWNob21zZyAiSXQncyBhIFppenplciBaYXp6ZXIgWnV6eiwgYXMgeW91IGNhbiBwbGFpbmx5IHNlZS4iCjwJCQlTZWUgfDplY2hvLXJlZHJhd3wgdG8gYXZvaWQgdGhlIG1lc3NhZ2UgZGlzYXBwZWFyaW5nCgkJCXdoZW4gdGhlIHNjcmVlbiBpcyByZWRyYXduLgoJCQkJCQkJKjplY2hvZSogKjplY2hvZXJyKgo6ZWNob2VbcnJdIHtleHByMX0gLi4JRWNobyB0aGUgZXhwcmVzc2lvbihzKSBhcyBhbiBlcnJvciBtZXNzYWdlLCBzYXZpbmcgdGhlCgkJCW1lc3NhZ2UgaW4gdGhlIHxtZXNzYWdlLWhpc3Rvcnl8LiAgV2hlbiB1c2VkIGluIGEKCQkJc2NyaXB0IG9yIGZ1bmN0aW9uIHRoZSBsaW5lIG51bWJlciB3aWxsIGJlIGFkZGVkLgoJCQlTcGFjZXMgYXJlIHBsYWNlZCBiZXR3ZWVuIHRoZSBhcmd1bWVudHMgYXMgd2l0aCB0aGUKCQkJOmVjaG8gY29tbWFuZC4JV2hlbiB1c2VkIGluc2lkZSBhIHRyeSBjb25kaXRpb25hbCwKCQkJdGhlIG1lc3NhZ2UgaXMgcmFpc2VkIGFzIGFuIGVycm9yIGV4Y2VwdGlvbiBpbnN0ZWFkCgkJCShzZWUgfHRyeS1lY2hvZXJyfCkuCgkJCUV4YW1wbGU6ID4KCQk6ZWNob2VyciAiVGhpcyBzY3JpcHQganVzdCBmYWlsZWQhIgo8CQkJSWYgeW91IGp1c3Qgd2FudCBhIGhpZ2hsaWdodGVkIG1lc3NhZ2UgdXNlIHw6ZWNob2hsfC4KCQkJQW5kIHRvIGdldCBhIGJlZXA6ID4KCQk6ZXhlICJub3JtYWwgXDxFc2M+Igo8CgkJCQkJCQkqOmV4ZSogKjpleGVjdXRlKgo6ZXhlW2N1dGVdIHtleHByMX0gLi4JRXhlY3V0ZXMgdGhlIHN0cmluZyB0aGF0IHJlc3VsdHMgZnJvbSB0aGUgZXZhbHVhdGlvbgoJCQlvZiB7ZXhwcjF9IGFzIGFuIEV4IGNvbW1hbmQuCgkJCU11bHRpcGxlIGFyZ3VtZW50cyBhcmUgY29uY2F0ZW5hdGVkLCB3aXRoIGEgc3BhY2UgaW4KCQkJYmV0d2Vlbi4gIFRvIGF2b2lkIHRoZSBleHRyYSBzcGFjZSB1c2UgdGhlICIuIgoJCQlvcGVyYXRvciB0byBjb25jYXRlbmF0ZSBzdHJpbmdzIGludG8gb25lIGFyZ3VtZW50LgoJCQl7ZXhwcjF9IGlzIHVzZWQgYXMgdGhlIHByb2Nlc3NlZCBjb21tYW5kLCBjb21tYW5kIGxpbmUKCQkJZWRpdGluZyBrZXlzIGFyZSBub3QgcmVjb2duaXplZC4KCQkJQ2Fubm90IGJlIGZvbGxvd2VkIGJ5IGEgY29tbWVudC4KCQkJRXhhbXBsZXM6ID4KCQk6ZXhlY3V0ZSAiYnVmZmVyIiBuZXh0YnVmCgkJOmV4ZWN1dGUgIm5vcm1hbCIgY291bnQgLiAidyIKPAoJCQkiOmV4ZWN1dGUiIGNhbiBiZSB1c2VkIHRvIGFwcGVuZCBhIGNvbW1hbmQgdG8gY29tbWFuZHMKCQkJdGhhdCBkb24ndCBhY2NlcHQgYSAnfCcuICBFeGFtcGxlOiA+CgkJOmV4ZWN1dGUgJyFscycgfCBlY2hvICJ0aGVlbmQiCgo8CQkJIjpleGVjdXRlIiBpcyBhbHNvIGEgbmljZSB3YXkgdG8gYXZvaWQgaGF2aW5nIHRvIHR5cGUKCQkJY29udHJvbCBjaGFyYWN0ZXJzIGluIGEgVmltIHNjcmlwdCBmb3IgYSAiOm5vcm1hbCIKCQkJY29tbWFuZDogPgoJCTpleGVjdXRlICJub3JtYWwgaXh4eFw8RXNjPiIKPAkJCVRoaXMgaGFzIGFuIDxFc2M+IGNoYXJhY3Rlciwgc2VlIHxleHByLXN0cmluZ3wuCgoJCQlCZSBjYXJlZnVsIHRvIGNvcnJlY3RseSBlc2NhcGUgc3BlY2lhbCBjaGFyYWN0ZXJzIGluCgkJCWZpbGUgbmFtZXMuICBUaGUgfGZuYW1lZXNjYXBlKCl8IGZ1bmN0aW9uIGNhbiBiZSB1c2VkCgkJCWZvciBWaW0gY29tbWFuZHMsIHxzaGVsbGVzY2FwZSgpfCBmb3IgfDohfCBjb21tYW5kcy4KCQkJRXhhbXBsZXM6ID4KCQk6ZXhlY3V0ZSAiZSAiIC4gZm5hbWVlc2NhcGUoZmlsZW5hbWUpCgkJOmV4ZWN1dGUgIiFscyAiIC4gc2hlbGxlc2NhcGUoZmlsZW5hbWUsIDEpCjwKCQkJTm90ZTogVGhlIGV4ZWN1dGVkIHN0cmluZyBtYXkgYmUgYW55IGNvbW1hbmQtbGluZSwgYnV0CgkJCXN0YXJ0aW5nIG9yIGVuZGluZyAiaWYiLCAid2hpbGUiIGFuZCAiZm9yIiBkb2VzIG5vdAoJCQlhbHdheXMgd29yaywgYmVjYXVzZSB3aGVuIGNvbW1hbmRzIGFyZSBza2lwcGVkIHRoZQoJCQkiOmV4ZWN1dGUiIGlzIG5vdCBldmFsdWF0ZWQgYW5kIFZpbSBsb3NlcyB0cmFjayBvZgoJCQl3aGVyZSBibG9ja3Mgc3RhcnQgYW5kIGVuZC4gIEFsc28gImJyZWFrIiBhbmQKCQkJImNvbnRpbnVlIiBzaG91bGQgbm90IGJlIGluc2lkZSAiOmV4ZWN1dGUiLgoJCQlUaGlzIGV4YW1wbGUgZG9lcyBub3Qgd29yaywgYmVjYXVzZSB0aGUgIjpleGVjdXRlIiBpcwoJCQlub3QgZXZhbHVhdGVkIGFuZCBWaW0gZG9lcyBub3Qgc2VlIHRoZSAid2hpbGUiLCBhbmQKCQkJZ2l2ZXMgYW4gZXJyb3IgZm9yIGZpbmRpbmcgYW4gIjplbmR3aGlsZSI6ID4KCQk6aWYgMAoJCTogZXhlY3V0ZSAnd2hpbGUgaSA+IDUnCgkJOiAgZWNobyAidGVzdCIKCQk6IGVuZHdoaWxlCgkJOmVuZGlmCjwKCQkJSXQgaXMgYWxsb3dlZCB0byBoYXZlIGEgIndoaWxlIiBvciAiaWYiIGNvbW1hbmQKCQkJY29tcGxldGVseSBpbiB0aGUgZXhlY3V0ZWQgc3RyaW5nOiA+CgkJOmV4ZWN1dGUgJ3doaWxlIGkgPCA1IHwgZWNobyBpIHwgbGV0IGkgPSBpICsgMSB8IGVuZHdoaWxlJwo8CgoJCQkJCQkJKjpleGUtY29tbWVudCoKCQkJIjpleGVjdXRlIiwgIjplY2hvIiBhbmQgIjplY2hvbiIgY2Fubm90IGJlIGZvbGxvd2VkIGJ5CgkJCWEgY29tbWVudCBkaXJlY3RseSwgYmVjYXVzZSB0aGV5IHNlZSB0aGUgJyInIGFzIHRoZQoJCQlzdGFydCBvZiBhIHN0cmluZy4gIEJ1dCwgeW91IGNhbiB1c2UgJ3wnIGZvbGxvd2VkIGJ5IGEKCQkJY29tbWVudC4gIEV4YW1wbGU6ID4KCQk6ZWNobyAiZm9vIiB8ICJ0aGlzIGlzIGEgY29tbWVudAoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjguIEV4Y2VwdGlvbiBoYW5kbGluZwkJCQkJKmV4Y2VwdGlvbi1oYW5kbGluZyoKClRoZSBWaW0gc2NyaXB0IGxhbmd1YWdlIGNvbXByaXNlcyBhbiBleGNlcHRpb24gaGFuZGxpbmcgZmVhdHVyZS4gIFRoaXMgc2VjdGlvbgpleHBsYWlucyBob3cgaXQgY2FuIGJlIHVzZWQgaW4gYSBWaW0gc2NyaXB0LgoKRXhjZXB0aW9ucyBtYXkgYmUgcmFpc2VkIGJ5IFZpbSBvbiBhbiBlcnJvciBvciBvbiBpbnRlcnJ1cHQsIHNlZQp8Y2F0Y2gtZXJyb3JzfCBhbmQgfGNhdGNoLWludGVycnVwdHwuICBZb3UgY2FuIGFsc28gZXhwbGljaXRseSB0aHJvdyBhbgpleGNlcHRpb24gYnkgdXNpbmcgdGhlICI6dGhyb3ciIGNvbW1hbmQsIHNlZSB8dGhyb3ctY2F0Y2h8LgoKClRSWSBDT05ESVRJT05BTFMJCQkJCSp0cnktY29uZGl0aW9uYWxzKgoKRXhjZXB0aW9ucyBjYW4gYmUgY2F1Z2h0IG9yIGNhbiBjYXVzZSBjbGVhbnVwIGNvZGUgdG8gYmUgZXhlY3V0ZWQuICBZb3UgY2FuCnVzZSBhIHRyeSBjb25kaXRpb25hbCB0byBzcGVjaWZ5IGNhdGNoIGNsYXVzZXMgKHRoYXQgY2F0Y2ggZXhjZXB0aW9ucykgYW5kL29yCmEgZmluYWxseSBjbGF1c2UgKHRvIGJlIGV4ZWN1dGVkIGZvciBjbGVhbnVwKS4KICAgQSB0cnkgY29uZGl0aW9uYWwgYmVnaW5zIHdpdGggYSB8OnRyeXwgY29tbWFuZCBhbmQgZW5kcyBhdCB0aGUgbWF0Y2hpbmcKfDplbmR0cnl8IGNvbW1hbmQuICBJbiBiZXR3ZWVuLCB5b3UgY2FuIHVzZSBhIHw6Y2F0Y2h8IGNvbW1hbmQgdG8gc3RhcnQKYSBjYXRjaCBjbGF1c2UsIG9yIGEgfDpmaW5hbGx5fCBjb21tYW5kIHRvIHN0YXJ0IGEgZmluYWxseSBjbGF1c2UuICBUaGVyZSBtYXkKYmUgbm9uZSBvciBtdWx0aXBsZSBjYXRjaCBjbGF1c2VzLCBidXQgdGhlcmUgaXMgYXQgbW9zdCBvbmUgZmluYWxseSBjbGF1c2UsCndoaWNoIG11c3Qgbm90IGJlIGZvbGxvd2VkIGJ5IGFueSBjYXRjaCBjbGF1c2VzLiAgVGhlIGxpbmVzIGJlZm9yZSB0aGUgY2F0Y2gKY2xhdXNlcyBhbmQgdGhlIGZpbmFsbHkgY2xhdXNlIGlzIGNhbGxlZCBhIHRyeSBibG9jay4gPgoKICAgICA6dHJ5CiAgICAgOgkuLi4KICAgICA6CS4uLgkJCQlUUlkgQkxPQ0sKICAgICA6CS4uLgogICAgIDpjYXRjaCAve3BhdHRlcm59LwogICAgIDoJLi4uCiAgICAgOgkuLi4JCQkJQ0FUQ0ggQ0xBVVNFCiAgICAgOgkuLi4KICAgICA6Y2F0Y2ggL3twYXR0ZXJufS8KICAgICA6CS4uLgogICAgIDoJLi4uCQkJCUNBVENIIENMQVVTRQogICAgIDoJLi4uCiAgICAgOmZpbmFsbHkKICAgICA6CS4uLgogICAgIDoJLi4uCQkJCUZJTkFMTFkgQ0xBVVNFCiAgICAgOgkuLi4KICAgICA6ZW5kdHJ5CgpUaGUgdHJ5IGNvbmRpdGlvbmFsIGFsbG93cyB0byB3YXRjaCBjb2RlIGZvciBleGNlcHRpb25zIGFuZCB0byB0YWtlIHRoZQphcHByb3ByaWF0ZSBhY3Rpb25zLiAgRXhjZXB0aW9ucyBmcm9tIHRoZSB0cnkgYmxvY2sgbWF5IGJlIGNhdWdodC4gIEV4Y2VwdGlvbnMKZnJvbSB0aGUgdHJ5IGJsb2NrIGFuZCBhbHNvIHRoZSBjYXRjaCBjbGF1c2VzIG1heSBjYXVzZSBjbGVhbnVwIGFjdGlvbnMuCiAgIFdoZW4gbm8gZXhjZXB0aW9uIGlzIHRocm93biBkdXJpbmcgZXhlY3V0aW9uIG9mIHRoZSB0cnkgYmxvY2ssIHRoZSBjb250cm9sCmlzIHRyYW5zZmVycmVkIHRvIHRoZSBmaW5hbGx5IGNsYXVzZSwgaWYgcHJlc2VudC4gIEFmdGVyIGl0cyBleGVjdXRpb24sIHRoZQpzY3JpcHQgY29udGludWVzIHdpdGggdGhlIGxpbmUgZm9sbG93aW5nIHRoZSAiOmVuZHRyeSIuCiAgIFdoZW4gYW4gZXhjZXB0aW9uIG9jY3VycyBkdXJpbmcgZXhlY3V0aW9uIG9mIHRoZSB0cnkgYmxvY2ssIHRoZSByZW1haW5pbmcKbGluZXMgaW4gdGhlIHRyeSBibG9jayBhcmUgc2tpcHBlZC4gIFRoZSBleGNlcHRpb24gaXMgbWF0Y2hlZCBhZ2FpbnN0IHRoZQpwYXR0ZXJucyBzcGVjaWZpZWQgYXMgYXJndW1lbnRzIHRvIHRoZSAiOmNhdGNoIiBjb21tYW5kcy4gIFRoZSBjYXRjaCBjbGF1c2UKYWZ0ZXIgdGhlIGZpcnN0IG1hdGNoaW5nICI6Y2F0Y2giIGlzIHRha2VuLCBvdGhlciBjYXRjaCBjbGF1c2VzIGFyZSBub3QKZXhlY3V0ZWQuICBUaGUgY2F0Y2ggY2xhdXNlIGVuZHMgd2hlbiB0aGUgbmV4dCAiOmNhdGNoIiwgIjpmaW5hbGx5Iiwgb3IKIjplbmR0cnkiIGNvbW1hbmQgaXMgcmVhY2hlZCAtIHdoYXRldmVyIGlzIGZpcnN0LiAgVGhlbiwgdGhlIGZpbmFsbHkgY2xhdXNlCihpZiBwcmVzZW50KSBpcyBleGVjdXRlZC4gIFdoZW4gdGhlICI6ZW5kdHJ5IiBpcyByZWFjaGVkLCB0aGUgc2NyaXB0IGV4ZWN1dGlvbgpjb250aW51ZXMgaW4gdGhlIGZvbGxvd2luZyBsaW5lIGFzIHVzdWFsLgogICBXaGVuIGFuIGV4Y2VwdGlvbiB0aGF0IGRvZXMgbm90IG1hdGNoIGFueSBvZiB0aGUgcGF0dGVybnMgc3BlY2lmaWVkIGJ5IHRoZQoiOmNhdGNoIiBjb21tYW5kcyBpcyB0aHJvd24gaW4gdGhlIHRyeSBibG9jaywgdGhlIGV4Y2VwdGlvbiBpcyBub3QgY2F1Z2h0IGJ5CnRoYXQgdHJ5IGNvbmRpdGlvbmFsIGFuZCBub25lIG9mIHRoZSBjYXRjaCBjbGF1c2VzIGlzIGV4ZWN1dGVkLiAgT25seSB0aGUKZmluYWxseSBjbGF1c2UsIGlmIHByZXNlbnQsIGlzIHRha2VuLiAgVGhlIGV4Y2VwdGlvbiBwZW5kcyBkdXJpbmcgZXhlY3V0aW9uIG9mCnRoZSBmaW5hbGx5IGNsYXVzZS4gIEl0IGlzIHJlc3VtZWQgYXQgdGhlICI6ZW5kdHJ5Iiwgc28gdGhhdCBjb21tYW5kcyBhZnRlcgp0aGUgIjplbmR0cnkiIGFyZSBub3QgZXhlY3V0ZWQgYW5kIHRoZSBleGNlcHRpb24gbWlnaHQgYmUgY2F1Z2h0IGVsc2V3aGVyZSwKc2VlIHx0cnktbmVzdGluZ3wuCiAgIFdoZW4gZHVyaW5nIGV4ZWN1dGlvbiBvZiBhIGNhdGNoIGNsYXVzZSBhbm90aGVyIGV4Y2VwdGlvbiBpcyB0aHJvd24sIHRoZQpyZW1haW5pbmcgbGluZXMgaW4gdGhhdCBjYXRjaCBjbGF1c2UgYXJlIG5vdCBleGVjdXRlZC4JVGhlIG5ldyBleGNlcHRpb24gaXMKbm90IG1hdGNoZWQgYWdhaW5zdCB0aGUgcGF0dGVybnMgaW4gYW55IG9mIHRoZSAiOmNhdGNoIiBjb21tYW5kcyBvZiB0aGUgc2FtZQp0cnkgY29uZGl0aW9uYWwgYW5kIG5vbmUgb2YgaXRzIGNhdGNoIGNsYXVzZXMgaXMgdGFrZW4uICBJZiB0aGVyZSBpcywgaG93ZXZlciwKYSBmaW5hbGx5IGNsYXVzZSwgaXQgaXMgZXhlY3V0ZWQsIGFuZCB0aGUgZXhjZXB0aW9uIHBlbmRzIGR1cmluZyBpdHMKZXhlY3V0aW9uLiAgVGhlIGNvbW1hbmRzIGZvbGxvd2luZyB0aGUgIjplbmR0cnkiIGFyZSBub3QgZXhlY3V0ZWQuICBUaGUgbmV3CmV4Y2VwdGlvbiBtaWdodCwgaG93ZXZlciwgYmUgY2F1Z2h0IGVsc2V3aGVyZSwgc2VlIHx0cnktbmVzdGluZ3wuCiAgIFdoZW4gZHVyaW5nIGV4ZWN1dGlvbiBvZiB0aGUgZmluYWxseSBjbGF1c2UgKGlmIHByZXNlbnQpIGFuIGV4Y2VwdGlvbiBpcwp0aHJvd24sIHRoZSByZW1haW5pbmcgbGluZXMgaW4gdGhlIGZpbmFsbHkgY2xhdXNlIGFyZSBza2lwcGVkLglJZiB0aGUgZmluYWxseQpjbGF1c2UgaGFzIGJlZW4gdGFrZW4gYmVjYXVzZSBvZiBhbiBleGNlcHRpb24gZnJvbSB0aGUgdHJ5IGJsb2NrIG9yIG9uZSBvZiB0aGUKY2F0Y2ggY2xhdXNlcywgdGhlIG9yaWdpbmFsIChwZW5kaW5nKSBleGNlcHRpb24gaXMgZGlzY2FyZGVkLiAgVGhlIGNvbW1hbmRzCmZvbGxvd2luZyB0aGUgIjplbmR0cnkiIGFyZSBub3QgZXhlY3V0ZWQsIGFuZCB0aGUgZXhjZXB0aW9uIGZyb20gdGhlIGZpbmFsbHkKY2xhdXNlIGlzIHByb3BhZ2F0ZWQgYW5kIGNhbiBiZSBjYXVnaHQgZWxzZXdoZXJlLCBzZWUgfHRyeS1uZXN0aW5nfC4KClRoZSBmaW5hbGx5IGNsYXVzZSBpcyBhbHNvIGV4ZWN1dGVkLCB3aGVuIGEgIjpicmVhayIgb3IgIjpjb250aW51ZSIgZm9yCmEgIjp3aGlsZSIgbG9vcCBlbmNsb3NpbmcgdGhlIGNvbXBsZXRlIHRyeSBjb25kaXRpb25hbCBpcyBleGVjdXRlZCBmcm9tIHRoZQp0cnkgYmxvY2sgb3IgYSBjYXRjaCBjbGF1c2UuICBPciB3aGVuIGEgIjpyZXR1cm4iIG9yICI6ZmluaXNoIiBpcyBleGVjdXRlZApmcm9tIHRoZSB0cnkgYmxvY2sgb3IgYSBjYXRjaCBjbGF1c2Ugb2YgYSB0cnkgY29uZGl0aW9uYWwgaW4gYSBmdW5jdGlvbiBvcgpzb3VyY2VkIHNjcmlwdCwgcmVzcGVjdGl2ZWx5LiAgVGhlICI6YnJlYWsiLCAiOmNvbnRpbnVlIiwgIjpyZXR1cm4iLCBvcgoiOmZpbmlzaCIgcGVuZHMgZHVyaW5nIGV4ZWN1dGlvbiBvZiB0aGUgZmluYWxseSBjbGF1c2UgYW5kIGlzIHJlc3VtZWQgd2hlbiB0aGUKIjplbmR0cnkiIGlzIHJlYWNoZWQuICBJdCBpcywgaG93ZXZlciwgZGlzY2FyZGVkIHdoZW4gYW4gZXhjZXB0aW9uIGlzIHRocm93bgpmcm9tIHRoZSBmaW5hbGx5IGNsYXVzZS4KICAgV2hlbiBhICI6YnJlYWsiIG9yICI6Y29udGludWUiIGZvciBhICI6d2hpbGUiIGxvb3AgZW5jbG9zaW5nIHRoZSBjb21wbGV0ZQp0cnkgY29uZGl0aW9uYWwgb3Igd2hlbiBhICI6cmV0dXJuIiBvciAiOmZpbmlzaCIgaXMgZW5jb3VudGVyZWQgaW4gdGhlIGZpbmFsbHkKY2xhdXNlLCB0aGUgcmVzdCBvZiB0aGUgZmluYWxseSBjbGF1c2UgaXMgc2tpcHBlZCwgYW5kIHRoZSAiOmJyZWFrIiwKIjpjb250aW51ZSIsICI6cmV0dXJuIiBvciAiOmZpbmlzaCIgaXMgZXhlY3V0ZWQgYXMgdXN1YWwuICBJZiB0aGUgZmluYWxseQpjbGF1c2UgaGFzIGJlZW4gdGFrZW4gYmVjYXVzZSBvZiBhbiBleGNlcHRpb24gb3IgYW4gZWFybGllciAiOmJyZWFrIiwKIjpjb250aW51ZSIsICI6cmV0dXJuIiwgb3IgIjpmaW5pc2giIGZyb20gdGhlIHRyeSBibG9jayBvciBhIGNhdGNoIGNsYXVzZSwKdGhpcyBwZW5kaW5nIGV4Y2VwdGlvbiBvciBjb21tYW5kIGlzIGRpc2NhcmRlZC4KCkZvciBleGFtcGxlcyBzZWUgfHRocm93LWNhdGNofCBhbmQgfHRyeS1maW5hbGx5fC4KCgpORVNUSU5HCU9GIFRSWSBDT05ESVRJT05BTFMJCQkJKnRyeS1uZXN0aW5nKgoKVHJ5IGNvbmRpdGlvbmFscyBjYW4gYmUgbmVzdGVkIGFyYml0cmFyaWx5LiAgVGhhdCBpcywgYSBjb21wbGV0ZSB0cnkKY29uZGl0aW9uYWwgY2FuIGJlIHB1dCBpbnRvIHRoZSB0cnkgYmxvY2ssIGEgY2F0Y2ggY2xhdXNlLCBvciB0aGUgZmluYWxseQpjbGF1c2Ugb2YgYW5vdGhlciB0cnkgY29uZGl0aW9uYWwuICBJZiB0aGUgaW5uZXIgdHJ5IGNvbmRpdGlvbmFsIGRvZXMgbm90CmNhdGNoIGFuIGV4Y2VwdGlvbiB0aHJvd24gaW4gaXRzIHRyeSBibG9jayBvciB0aHJvd3MgYSBuZXcgZXhjZXB0aW9uIGZyb20gb25lCm9mIGl0cyBjYXRjaCBjbGF1c2VzIG9yIGl0cyBmaW5hbGx5IGNsYXVzZSwgdGhlIG91dGVyIHRyeSBjb25kaXRpb25hbCBpcwpjaGVja2VkIGFjY29yZGluZyB0byB0aGUgcnVsZXMgYWJvdmUuICBJZiB0aGUgaW5uZXIgdHJ5IGNvbmRpdGlvbmFsIGlzIGluIHRoZQp0cnkgYmxvY2sgb2YgdGhlIG91dGVyIHRyeSBjb25kaXRpb25hbCwgaXRzIGNhdGNoIGNsYXVzZXMgYXJlIGNoZWNrZWQsIGJ1dApvdGhlcndpc2Ugb25seSB0aGUgZmluYWxseSBjbGF1c2UgaXMgZXhlY3V0ZWQuCUl0IGRvZXMgbm90IG1hdHRlciBmb3IKbmVzdGluZywgd2hldGhlciB0aGUgaW5uZXIgdHJ5IGNvbmRpdGlvbmFsIGlzIGRpcmVjdGx5IGNvbnRhaW5lZCBpbiB0aGUgb3V0ZXIKb25lLCBvciB3aGV0aGVyIHRoZSBvdXRlciBvbmUgc291cmNlcyBhIHNjcmlwdCBvciBjYWxscyBhIGZ1bmN0aW9uIGNvbnRhaW5pbmcKdGhlIGlubmVyIHRyeSBjb25kaXRpb25hbC4KCldoZW4gbm9uZSBvZiB0aGUgYWN0aXZlIHRyeSBjb25kaXRpb25hbHMgY2F0Y2hlcyBhbiBleGNlcHRpb24sIGp1c3QgdGhlaXIKZmluYWxseSBjbGF1c2VzIGFyZSBleGVjdXRlZC4gIFRoZXJlYWZ0ZXIsIHRoZSBzY3JpcHQgcHJvY2Vzc2luZyB0ZXJtaW5hdGVzLgpBbiBlcnJvciBtZXNzYWdlIGlzIGRpc3BsYXllZCBpbiBjYXNlIG9mIGFuIHVuY2F1Z2h0IGV4Y2VwdGlvbiBleHBsaWNpdGx5CnRocm93biBieSBhICI6dGhyb3ciIGNvbW1hbmQuICBGb3IgdW5jYXVnaHQgZXJyb3IgYW5kIGludGVycnVwdCBleGNlcHRpb25zCmltcGxpY2l0bHkgcmFpc2VkIGJ5IFZpbSwgdGhlIGVycm9yIG1lc3NhZ2Uocykgb3IgaW50ZXJydXB0IG1lc3NhZ2UgYXJlIHNob3duCmFzIHVzdWFsLgoKRm9yIGV4YW1wbGVzIHNlZSB8dGhyb3ctY2F0Y2h8LgoKCkVYQU1JTklORyBFWENFUFRJT04gSEFORExJTkcgQ09ERQkJCSpleGNlcHQtZXhhbWluZSoKCkV4Y2VwdGlvbiBoYW5kbGluZyBjb2RlIGNhbiBnZXQgdHJpY2t5LiAgSWYgeW91IGFyZSBpbiBkb3VidCB3aGF0IGhhcHBlbnMsIHNldAondmVyYm9zZScgdG8gMTMgb3IgdXNlIHRoZSAiOjEzdmVyYm9zZSIgY29tbWFuZCBtb2RpZmllciB3aGVuIHNvdXJjaW5nIHlvdXIKc2NyaXB0IGZpbGUuICBUaGVuIHlvdSBzZWUgd2hlbiBhbiBleGNlcHRpb24gaXMgdGhyb3duLCBkaXNjYXJkZWQsIGNhdWdodCwgb3IKZmluaXNoZWQuICBXaGVuIHVzaW5nIGEgdmVyYm9zaXR5IGxldmVsIG9mIGF0IGxlYXN0IDE0LCB0aGluZ3MgcGVuZGluZyBpbgphIGZpbmFsbHkgY2xhdXNlIGFyZSBhbHNvIHNob3duLiAgVGhpcyBpbmZvcm1hdGlvbiBpcyBhbHNvIGdpdmVuIGluIGRlYnVnIG1vZGUKKHNlZSB8ZGVidWctc2NyaXB0c3wpLgoKClRIUk9XSU5HIEFORCBDQVRDSElORyBFWENFUFRJT05TCQkJKnRocm93LWNhdGNoKgoKWW91IGNhbiB0aHJvdyBhbnkgbnVtYmVyIG9yIHN0cmluZyBhcyBhbiBleGNlcHRpb24uICBVc2UgdGhlIHw6dGhyb3d8IGNvbW1hbmQKYW5kIHBhc3MgdGhlIHZhbHVlIHRvIGJlIHRocm93biBhcyBhcmd1bWVudDogPgoJOnRocm93IDQ3MTEKCTp0aHJvdyAic3RyaW5nIgo8CQkJCQkJCSp0aHJvdy1leHByZXNzaW9uKgpZb3UgY2FuIGFsc28gc3BlY2lmeSBhbiBleHByZXNzaW9uIGFyZ3VtZW50LiAgVGhlIGV4cHJlc3Npb24gaXMgdGhlbiBldmFsdWF0ZWQKZmlyc3QsIGFuZCB0aGUgcmVzdWx0IGlzIHRocm93bjogPgoJOnRocm93IDQ3MDUgKyBzdHJsZW4oInN0cmluZyIpCgk6dGhyb3cgc3RycGFydCgic3RyaW5ncyIsIDAsIDYpCgpBbiBleGNlcHRpb24gbWlnaHQgYmUgdGhyb3duIGR1cmluZyBldmFsdWF0aW9uIG9mIHRoZSBhcmd1bWVudCBvZiB0aGUgIjp0aHJvdyIKY29tbWFuZC4gIFVubGVzcyBpdCBpcyBjYXVnaHQgdGhlcmUsIHRoZSBleHByZXNzaW9uIGV2YWx1YXRpb24gaXMgYWJhbmRvbmVkLgpUaGUgIjp0aHJvdyIgY29tbWFuZCB0aGVuIGRvZXMgbm90IHRocm93IGEgbmV3IGV4Y2VwdGlvbi4KICAgRXhhbXBsZTogPgoKCTpmdW5jdGlvbiEgRm9vKGFyZykKCTogIHRyeQoJOiAgICB0aHJvdyBhOmFyZwoJOiAgY2F0Y2ggL2Zvby8KCTogIGVuZHRyeQoJOiAgcmV0dXJuIDEKCTplbmRmdW5jdGlvbgoJOgoJOmZ1bmN0aW9uISBCYXIoKQoJOiAgZWNobyAiaW4gQmFyIgoJOiAgcmV0dXJuIDQ3MTAKCTplbmRmdW5jdGlvbgoJOgoJOnRocm93IEZvbygiYXJyZ2giKSArIEJhcigpCgpUaGlzIHRocm93cyAiYXJyZ2giLCBhbmQgImluIEJhciIgaXMgbm90IGRpc3BsYXllZCBzaW5jZSBCYXIoKSBpcyBub3QKZXhlY3V0ZWQuID4KCTp0aHJvdyBGb28oImZvbyIpICsgQmFyKCkKaG93ZXZlciBkaXNwbGF5cyAiaW4gQmFyIiBhbmQgdGhyb3dzIDQ3MTEuCgpBbnkgb3RoZXIgY29tbWFuZCB0aGF0IHRha2VzIGFuIGV4cHJlc3Npb24gYXMgYXJndW1lbnQgbWlnaHQgYWxzbyBiZQphYmFuZG9uZWQgYnkgYW4gKHVuY2F1Z2h0KSBleGNlcHRpb24gZHVyaW5nIHRoZSBleHByZXNzaW9uIGV2YWx1YXRpb24uCVRoZQpleGNlcHRpb24gaXMgdGhlbiBwcm9wYWdhdGVkIHRvIHRoZSBjYWxsZXIgb2YgdGhlIGNvbW1hbmQuCiAgIEV4YW1wbGU6ID4KCgk6aWYgRm9vKCJhcnJnaCIpCgk6ICBlY2hvICJ0aGVuIgoJOmVsc2UKCTogIGVjaG8gImVsc2UiCgk6ZW5kaWYKCkhlcmUgbmVpdGhlciBvZiAidGhlbiIgb3IgImVsc2UiIGlzIGRpc3BsYXllZC4KCgkJCQkJCQkqY2F0Y2gtb3JkZXIqCkV4Y2VwdGlvbnMgY2FuIGJlIGNhdWdodCBieSBhIHRyeSBjb25kaXRpb25hbCB3aXRoIG9uZSBvciBtb3JlIHw6Y2F0Y2h8CmNvbW1hbmRzLCBzZWUgfHRyeS1jb25kaXRpb25hbHN8LiAgIFRoZSB2YWx1ZXMgdG8gYmUgY2F1Z2h0IGJ5IGVhY2ggIjpjYXRjaCIKY29tbWFuZCBjYW4gYmUgc3BlY2lmaWVkIGFzIGEgcGF0dGVybiBhcmd1bWVudC4gIFRoZSBzdWJzZXF1ZW50IGNhdGNoIGNsYXVzZQpnZXRzIGV4ZWN1dGVkIHdoZW4gYSBtYXRjaGluZyBleGNlcHRpb24gaXMgY2F1Z2h0LgogICBFeGFtcGxlOiA+CgoJOmZ1bmN0aW9uISBGb28odmFsdWUpCgk6ICB0cnkKCTogICAgdGhyb3cgYTp2YWx1ZQoJOiAgY2F0Y2ggL15cZFwrJC8KCTogICAgZWNobyAiTnVtYmVyIHRocm93biIKCTogIGNhdGNoIC8uKi8KCTogICAgZWNobyAiU3RyaW5nIHRocm93biIKCTogIGVuZHRyeQoJOmVuZGZ1bmN0aW9uCgk6Cgk6Y2FsbCBGb28oMHgxMjY3KQoJOmNhbGwgRm9vKCdzdHJpbmcnKQoKVGhlIGZpcnN0IGNhbGwgdG8gRm9vKCkgZGlzcGxheXMgIk51bWJlciB0aHJvd24iLCB0aGUgc2Vjb25kICJTdHJpbmcgdGhyb3duIi4KQW4gZXhjZXB0aW9uIGlzIG1hdGNoZWQgYWdhaW5zdCB0aGUgIjpjYXRjaCIgY29tbWFuZHMgaW4gdGhlIG9yZGVyIHRoZXkgYXJlCnNwZWNpZmllZC4gIE9ubHkgdGhlIGZpcnN0IG1hdGNoIGNvdW50cy4gIFNvIHlvdSBzaG91bGQgcGxhY2UgdGhlIG1vcmUKc3BlY2lmaWMgIjpjYXRjaCIgZmlyc3QuICBUaGUgZm9sbG93aW5nIG9yZGVyIGRvZXMgbm90IG1ha2Ugc2Vuc2U6ID4KCgk6ICBjYXRjaCAvLiovCgk6ICAgIGVjaG8gIlN0cmluZyB0aHJvd24iCgk6ICBjYXRjaCAvXlxkXCskLwoJOiAgICBlY2hvICJOdW1iZXIgdGhyb3duIgoKVGhlIGZpcnN0ICI6Y2F0Y2giIGhlcmUgbWF0Y2hlcyBhbHdheXMsIHNvIHRoYXQgdGhlIHNlY29uZCBjYXRjaCBjbGF1c2UgaXMKbmV2ZXIgdGFrZW4uCgoJCQkJCQkJKnRocm93LXZhcmlhYmxlcyoKSWYgeW91IGNhdGNoIGFuIGV4Y2VwdGlvbiBieSBhIGdlbmVyYWwgcGF0dGVybiwgeW91IG1heSBhY2Nlc3MgdGhlIGV4YWN0IHZhbHVlCmluIHRoZSB2YXJpYWJsZSB8djpleGNlcHRpb258OiA+CgoJOiAgY2F0Y2ggL15cZFwrJC8KCTogICAgZWNobyAiTnVtYmVyIHRocm93bi4gIFZhbHVlIGlzIiB2OmV4Y2VwdGlvbgoKWW91IG1heSBhbHNvIGJlIGludGVyZXN0ZWQgd2hlcmUgYW4gZXhjZXB0aW9uIHdhcyB0aHJvd24uICBUaGlzIGlzIHN0b3JlZCBpbgp8djp0aHJvd3BvaW50fC4gIE5vdGUgdGhhdCAidjpleGNlcHRpb24iIGFuZCAidjp0aHJvd3BvaW50IiBhcmUgdmFsaWQgZm9yIHRoZQpleGNlcHRpb24gbW9zdCByZWNlbnRseSBjYXVnaHQgYXMgbG9uZyBpdCBpcyBub3QgZmluaXNoZWQuCiAgIEV4YW1wbGU6ID4KCgk6ZnVuY3Rpb24hIENhdWdodCgpCgk6ICBpZiB2OmV4Y2VwdGlvbiAhPSAiIgoJOiAgICBlY2hvICdDYXVnaHQgIicgLiB2OmV4Y2VwdGlvbiAuICciIGluICcgLiB2OnRocm93cG9pbnQKCTogIGVsc2UKCTogICAgZWNobyAnTm90aGluZyBjYXVnaHQnCgk6ICBlbmRpZgoJOmVuZGZ1bmN0aW9uCgk6Cgk6ZnVuY3Rpb24hIEZvbygpCgk6ICB0cnkKCTogICAgdHJ5Cgk6ICAgICAgdHJ5Cgk6CSB0aHJvdyA0NzExCgk6ICAgICAgZmluYWxseQoJOgkgY2FsbCBDYXVnaHQoKQoJOiAgICAgIGVuZHRyeQoJOiAgICBjYXRjaCAvLiovCgk6ICAgICAgY2FsbCBDYXVnaHQoKQoJOiAgICAgIHRocm93ICJvb3BzIgoJOiAgICBlbmR0cnkKCTogIGNhdGNoIC8uKi8KCTogICAgY2FsbCBDYXVnaHQoKQoJOiAgZmluYWxseQoJOiAgICBjYWxsIENhdWdodCgpCgk6ICBlbmR0cnkKCTplbmRmdW5jdGlvbgoJOgoJOmNhbGwgRm9vKCkKClRoaXMgZGlzcGxheXMgPgoKCU5vdGhpbmcgY2F1Z2h0CglDYXVnaHQgIjQ3MTEiIGluIGZ1bmN0aW9uIEZvbywgbGluZSA0CglDYXVnaHQgIm9vcHMiIGluIGZ1bmN0aW9uIEZvbywgbGluZSAxMAoJTm90aGluZyBjYXVnaHQKCkEgcHJhY3RpY2FsIGV4YW1wbGU6ICBUaGUgZm9sbG93aW5nIGNvbW1hbmQgIjpMaW5lTnVtYmVyIiBkaXNwbGF5cyB0aGUgbGluZQpudW1iZXIgaW4gdGhlIHNjcmlwdCBvciBmdW5jdGlvbiB3aGVyZSBpdCBoYXMgYmVlbiB1c2VkOiA+CgoJOmZ1bmN0aW9uISBMaW5lTnVtYmVyKCkKCTogICAgcmV0dXJuIHN1YnN0aXR1dGUodjp0aHJvd3BvaW50LCAnLipcRFwoXGRcK1wpLionLCAnXDEnLCAiIikKCTplbmRmdW5jdGlvbgoJOmNvbW1hbmQhIExpbmVOdW1iZXIgdHJ5IHwgdGhyb3cgIiIgfCBjYXRjaCB8IGVjaG8gTGluZU51bWJlcigpIHwgZW5kdHJ5CjwKCQkJCQkJCSp0cnktbmVzdGVkKgpBbiBleGNlcHRpb24gdGhhdCBpcyBub3QgY2F1Z2h0IGJ5IGEgdHJ5IGNvbmRpdGlvbmFsIGNhbiBiZSBjYXVnaHQgYnkKYSBzdXJyb3VuZGluZyB0cnkgY29uZGl0aW9uYWw6ID4KCgk6dHJ5Cgk6ICB0cnkKCTogICAgdGhyb3cgImZvbyIKCTogIGNhdGNoIC9mb29iYXIvCgk6ICAgIGVjaG8gImZvb2JhciIKCTogIGZpbmFsbHkKCTogICAgZWNobyAiaW5uZXIgZmluYWxseSIKCTogIGVuZHRyeQoJOmNhdGNoIC9mb28vCgk6ICBlY2hvICJmb28iCgk6ZW5kdHJ5CgpUaGUgaW5uZXIgdHJ5IGNvbmRpdGlvbmFsIGRvZXMgbm90IGNhdGNoIHRoZSBleGNlcHRpb24sIGp1c3QgaXRzIGZpbmFsbHkKY2xhdXNlIGlzIGV4ZWN1dGVkLiAgVGhlIGV4Y2VwdGlvbiBpcyB0aGVuIGNhdWdodCBieSB0aGUgb3V0ZXIgdHJ5CmNvbmRpdGlvbmFsLiAgVGhlIGV4YW1wbGUgZGlzcGxheXMgImlubmVyIGZpbmFsbHkiIGFuZCB0aGVuICJmb28iLgoKCQkJCQkJCSp0aHJvdy1mcm9tLWNhdGNoKgpZb3UgY2FuIGNhdGNoIGFuIGV4Y2VwdGlvbiBhbmQgdGhyb3cgYSBuZXcgb25lIHRvIGJlIGNhdWdodCBlbHNld2hlcmUgZnJvbSB0aGUKY2F0Y2ggY2xhdXNlOiA+CgoJOmZ1bmN0aW9uISBGb28oKQoJOiAgdGhyb3cgImZvbyIKCTplbmRmdW5jdGlvbgoJOgoJOmZ1bmN0aW9uISBCYXIoKQoJOiAgdHJ5Cgk6ICAgIGNhbGwgRm9vKCkKCTogIGNhdGNoIC9mb28vCgk6ICAgIGVjaG8gIkNhdWdodCBmb28sIHRocm93IGJhciIKCTogICAgdGhyb3cgImJhciIKCTogIGVuZHRyeQoJOmVuZGZ1bmN0aW9uCgk6Cgk6dHJ5Cgk6ICBjYWxsIEJhcigpCgk6Y2F0Y2ggLy4qLwoJOiAgZWNobyAiQ2F1Z2h0IiB2OmV4Y2VwdGlvbgoJOmVuZHRyeQoKVGhpcyBkaXNwbGF5cyAiQ2F1Z2h0IGZvbywgdGhyb3cgYmFyIiBhbmQgdGhlbiAiQ2F1Z2h0IGJhciIuCgoJCQkJCQkJKnJldGhyb3cqClRoZXJlIGlzIG5vIHJlYWwgcmV0aHJvdyBpbiB0aGUgVmltIHNjcmlwdCBsYW5ndWFnZSwgYnV0IHlvdSBtYXkgdGhyb3cKInY6ZXhjZXB0aW9uIiBpbnN0ZWFkOiA+CgoJOmZ1bmN0aW9uISBCYXIoKQoJOiAgdHJ5Cgk6ICAgIGNhbGwgRm9vKCkKCTogIGNhdGNoIC8uKi8KCTogICAgZWNobyAiUmV0aHJvdyIgdjpleGNlcHRpb24KCTogICAgdGhyb3cgdjpleGNlcHRpb24KCTogIGVuZHRyeQoJOmVuZGZ1bmN0aW9uCjwJCQkJCQkJKnRyeS1lY2hvZXJyKgpOb3RlIHRoYXQgdGhpcyBtZXRob2QgY2Fubm90IGJlIHVzZWQgdG8gInJldGhyb3ciIFZpbSBlcnJvciBvciBpbnRlcnJ1cHQKZXhjZXB0aW9ucywgYmVjYXVzZSBpdCBpcyBub3QgcG9zc2libGUgdG8gZmFrZSBWaW0gaW50ZXJuYWwgZXhjZXB0aW9ucy4KVHJ5aW5nIHNvIGNhdXNlcyBhbiBlcnJvciBleGNlcHRpb24uICBZb3Ugc2hvdWxkIHRocm93IHlvdXIgb3duIGV4Y2VwdGlvbgpkZW5vdGluZyB0aGUgc2l0dWF0aW9uLiAgSWYgeW91IHdhbnQgdG8gY2F1c2UgYSBWaW0gZXJyb3IgZXhjZXB0aW9uIGNvbnRhaW5pbmcKdGhlIG9yaWdpbmFsIGVycm9yIGV4Y2VwdGlvbiB2YWx1ZSwgeW91IGNhbiB1c2UgdGhlIHw6ZWNob2VycnwgY29tbWFuZDogPgoKCTp0cnkKCTogIHRyeQoJOiAgICBhc2RmCgk6ICBjYXRjaCAvLiovCgk6ICAgIGVjaG9lcnIgdjpleGNlcHRpb24KCTogIGVuZHRyeQoJOmNhdGNoIC8uKi8KCTogIGVjaG8gdjpleGNlcHRpb24KCTplbmR0cnkKClRoaXMgY29kZSBkaXNwbGF5cwoKCVZpbShlY2hvZXJyKTpWaW06RTQ5MjogTm90IGFuIGVkaXRvciBjb21tYW5kOglhc2RmIH4KCgpDTEVBTlVQIENPREUJCQkJCQkqdHJ5LWZpbmFsbHkqCgpTY3JpcHRzIG9mdGVuIGNoYW5nZSBnbG9iYWwgc2V0dGluZ3MgYW5kIHJlc3RvcmUgdGhlbSBhdCB0aGVpciBlbmQuICBJZiB0aGUKdXNlciBob3dldmVyIGludGVycnVwdHMgdGhlIHNjcmlwdCBieSBwcmVzc2luZyBDVFJMLUMsIHRoZSBzZXR0aW5ncyByZW1haW4gaW4KYW4gaW5jb25zaXN0ZW50IHN0YXRlLglUaGUgc2FtZSBtYXkgaGFwcGVuIHRvIHlvdSBpbiB0aGUgZGV2ZWxvcG1lbnQgcGhhc2Ugb2YKYSBzY3JpcHQgd2hlbiBhbiBlcnJvciBvY2N1cnMgb3IgeW91IGV4cGxpY2l0bHkgdGhyb3cgYW4gZXhjZXB0aW9uIHdpdGhvdXQKY2F0Y2hpbmcgaXQuICBZb3UgY2FuIHNvbHZlIHRoZXNlIHByb2JsZW1zIGJ5IHVzaW5nIGEgdHJ5IGNvbmRpdGlvbmFsIHdpdGgKYSBmaW5hbGx5IGNsYXVzZSBmb3IgcmVzdG9yaW5nIHRoZSBzZXR0aW5ncy4gIEl0cyBleGVjdXRpb24gaXMgZ3VhcmFudGVlZCBvbgpub3JtYWwgY29udHJvbCBmbG93LCBvbiBlcnJvciwgb24gYW4gZXhwbGljaXQgIjp0aHJvdyIsIGFuZCBvbiBpbnRlcnJ1cHQuCihOb3RlIHRoYXQgZXJyb3JzIGFuZCBpbnRlcnJ1cHRzIGZyb20gaW5zaWRlIHRoZSB0cnkgY29uZGl0aW9uYWwgYXJlIGNvbnZlcnRlZAp0byBleGNlcHRpb25zLglXaGVuIG5vdCBjYXVnaHQsIHRoZXkgdGVybWluYXRlIHRoZSBzY3JpcHQgYWZ0ZXIgdGhlIGZpbmFsbHkKY2xhdXNlIGhhcyBiZWVuIGV4ZWN1dGVkLikKRXhhbXBsZTogPgoKCTp0cnkKCTogIGxldCBzOnNhdmVkX3RzID0gJnRzCgk6ICBzZXQgdHM9MTcKCToKCTogICIgRG8gdGhlIGhhcmQgd29yayBoZXJlLgoJOgoJOmZpbmFsbHkKCTogIGxldCAmdHMgPSBzOnNhdmVkX3RzCgk6ICB1bmxldCBzOnNhdmVkX3RzCgk6ZW5kdHJ5CgpUaGlzIG1ldGhvZCBzaG91bGQgYmUgdXNlZCBsb2NhbGx5IHdoZW5ldmVyIGEgZnVuY3Rpb24gb3IgcGFydCBvZiBhIHNjcmlwdApjaGFuZ2VzIGdsb2JhbCBzZXR0aW5ncyB3aGljaCBuZWVkIHRvIGJlIHJlc3RvcmVkIG9uIGZhaWx1cmUgb3Igbm9ybWFsIGV4aXQgb2YKdGhhdCBmdW5jdGlvbiBvciBzY3JpcHQgcGFydC4KCgkJCQkJCQkqYnJlYWstZmluYWxseSoKQ2xlYW51cCBjb2RlIHdvcmtzIGFsc28gd2hlbiB0aGUgdHJ5IGJsb2NrIG9yIGEgY2F0Y2ggY2xhdXNlIGlzIGxlZnQgYnkKYSAiOmNvbnRpbnVlIiwgIjpicmVhayIsICI6cmV0dXJuIiwgb3IgIjpmaW5pc2giLgogICBFeGFtcGxlOiA+CgoJOmxldCBmaXJzdCA9IDEKCTp3aGlsZSAxCgk6ICB0cnkKCTogICAgaWYgZmlyc3QKCTogICAgICBlY2hvICJmaXJzdCIKCTogICAgICBsZXQgZmlyc3QgPSAwCgk6ICAgICAgY29udGludWUKCTogICAgZWxzZQoJOiAgICAgIHRocm93ICJzZWNvbmQiCgk6ICAgIGVuZGlmCgk6ICBjYXRjaCAvLiovCgk6ICAgIGVjaG8gdjpleGNlcHRpb24KCTogICAgYnJlYWsKCTogIGZpbmFsbHkKCTogICAgZWNobyAiY2xlYW51cCIKCTogIGVuZHRyeQoJOiAgZWNobyAic3RpbGwgaW4gd2hpbGUiCgk6ZW5kd2hpbGUKCTplY2hvICJlbmQiCgpUaGlzIGRpc3BsYXlzICJmaXJzdCIsICJjbGVhbnVwIiwgInNlY29uZCIsICJjbGVhbnVwIiwgYW5kICJlbmQiLiA+CgoJOmZ1bmN0aW9uISBGb28oKQoJOiAgdHJ5Cgk6ICAgIHJldHVybiA0NzExCgk6ICBmaW5hbGx5Cgk6ICAgIGVjaG8gImNsZWFudXBcbiIKCTogIGVuZHRyeQoJOiAgZWNobyAiRm9vIHN0aWxsIGFjdGl2ZSIKCTplbmRmdW5jdGlvbgoJOgoJOmVjaG8gRm9vKCkgInJldHVybmVkIGJ5IEZvbyIKClRoaXMgZGlzcGxheXMgImNsZWFudXAiIGFuZCAiNDcxMSByZXR1cm5lZCBieSBGb28iLiAgWW91IGRvbid0IG5lZWQgdG8gYWRkIGFuCmV4dHJhICI6cmV0dXJuIiBpbiB0aGUgZmluYWxseSBjbGF1c2UuCShBYm92ZSBhbGwsIHRoaXMgd291bGQgb3ZlcnJpZGUgdGhlCnJldHVybiB2YWx1ZS4pCgoJCQkJCQkJKmV4Y2VwdC1mcm9tLWZpbmFsbHkqClVzaW5nIGVpdGhlciBvZiAiOmNvbnRpbnVlIiwgIjpicmVhayIsICI6cmV0dXJuIiwgIjpmaW5pc2giLCBvciAiOnRocm93IiBpbgphIGZpbmFsbHkgY2xhdXNlIGlzIHBvc3NpYmxlLCBidXQgbm90IHJlY29tbWVuZGVkIHNpbmNlIGl0IGFiYW5kb25zIHRoZQpjbGVhbnVwIGFjdGlvbnMgZm9yIHRoZSB0cnkgY29uZGl0aW9uYWwuICBCdXQsIG9mIGNvdXJzZSwgaW50ZXJydXB0IGFuZCBlcnJvcgpleGNlcHRpb25zIG1pZ2h0IGdldCByYWlzZWQgZnJvbSBhIGZpbmFsbHkgY2xhdXNlLgogICBFeGFtcGxlIHdoZXJlIGFuIGVycm9yIGluIHRoZSBmaW5hbGx5IGNsYXVzZSBzdG9wcyBhbiBpbnRlcnJ1cHQgZnJvbQp3b3JraW5nIGNvcnJlY3RseTogPgoKCTp0cnkKCTogIHRyeQoJOiAgICBlY2hvICJQcmVzcyBDVFJMLUMgZm9yIGludGVycnVwdCIKCTogICAgd2hpbGUgMQoJOiAgICBlbmR3aGlsZQoJOiAgZmluYWxseQoJOiAgICB1bmxldCBub3ZhcgoJOiAgZW5kdHJ5Cgk6Y2F0Y2ggL25vdmFyLwoJOmVuZHRyeQoJOmVjaG8gIlNjcmlwdCBzdGlsbCBydW5uaW5nIgoJOnNsZWVwIDEKCklmIHlvdSBuZWVkIHRvIHB1dCBjb21tYW5kcyB0aGF0IGNvdWxkIGZhaWwgaW50byBhIGZpbmFsbHkgY2xhdXNlLCB5b3Ugc2hvdWxkCnRoaW5rIGFib3V0IGNhdGNoaW5nIG9yIGlnbm9yaW5nIHRoZSBlcnJvcnMgaW4gdGhlc2UgY29tbWFuZHMsIHNlZQp8Y2F0Y2gtZXJyb3JzfCBhbmQgfGlnbm9yZS1lcnJvcnN8LgoKCkNBVENISU5HIEVSUk9SUwkJCQkJCSpjYXRjaC1lcnJvcnMqCgpJZiB5b3Ugd2FudCB0byBjYXRjaCBzcGVjaWZpYyBlcnJvcnMsIHlvdSBqdXN0IGhhdmUgdG8gcHV0IHRoZSBjb2RlIHRvIGJlCndhdGNoZWQgaW4gYSB0cnkgYmxvY2sgYW5kIGFkZCBhIGNhdGNoIGNsYXVzZSBmb3IgdGhlIGVycm9yIG1lc3NhZ2UuICBUaGUKcHJlc2VuY2Ugb2YgdGhlIHRyeSBjb25kaXRpb25hbCBjYXVzZXMgYWxsIGVycm9ycyB0byBiZSBjb252ZXJ0ZWQgdG8gYW4KZXhjZXB0aW9uLiAgTm8gbWVzc2FnZSBpcyBkaXNwbGF5ZWQgYW5kIHx2OmVycm1zZ3wgaXMgbm90IHNldCB0aGVuLiAgVG8gZmluZAp0aGUgcmlnaHQgcGF0dGVybiBmb3IgdGhlICI6Y2F0Y2giIGNvbW1hbmQsIHlvdSBoYXZlIHRvIGtub3cgaG93IHRoZSBmb3JtYXQgb2YKdGhlIGVycm9yIGV4Y2VwdGlvbiBpcy4KICAgRXJyb3IgZXhjZXB0aW9ucyBoYXZlIHRoZSBmb2xsb3dpbmcgZm9ybWF0OiA+CgoJVmltKHtjbWRuYW1lfSk6e2Vycm1zZ30Kb3IgPgoJVmltOntlcnJtc2d9Cgp7Y21kbmFtZX0gaXMgdGhlIG5hbWUgb2YgdGhlIGNvbW1hbmQgdGhhdCBmYWlsZWQ7IHRoZSBzZWNvbmQgZm9ybSBpcyB1c2VkIHdoZW4KdGhlIGNvbW1hbmQgbmFtZSBpcyBub3Qga25vd24uCXtlcnJtc2d9IGlzIHRoZSBlcnJvciBtZXNzYWdlIHVzdWFsbHkgcHJvZHVjZWQKd2hlbiB0aGUgZXJyb3Igb2NjdXJzIG91dHNpZGUgdHJ5IGNvbmRpdGlvbmFscy4gIEl0IGFsd2F5cyBiZWdpbnMgd2l0aAphIGNhcGl0YWwgIkUiLCBmb2xsb3dlZCBieSBhIHR3byBvciB0aHJlZS1kaWdpdCBlcnJvciBudW1iZXIsIGEgY29sb24sIGFuZAphIHNwYWNlLgoKRXhhbXBsZXM6CgpUaGUgY29tbWFuZCA+Cgk6dW5sZXQgbm92YXIKbm9ybWFsbHkgcHJvZHVjZXMgdGhlIGVycm9yIG1lc3NhZ2UgPgoJRTEwODogTm8gc3VjaCB2YXJpYWJsZTogIm5vdmFyIgp3aGljaCBpcyBjb252ZXJ0ZWQgaW5zaWRlIHRyeSBjb25kaXRpb25hbHMgdG8gYW4gZXhjZXB0aW9uID4KCVZpbSh1bmxldCk6RTEwODogTm8gc3VjaCB2YXJpYWJsZTogIm5vdmFyIgoKVGhlIGNvbW1hbmQgPgoJOmR3aW0Kbm9ybWFsbHkgcHJvZHVjZXMgdGhlIGVycm9yIG1lc3NhZ2UgPgoJRTQ5MjogTm90IGFuIGVkaXRvciBjb21tYW5kOiBkd2ltCndoaWNoIGlzIGNvbnZlcnRlZCBpbnNpZGUgdHJ5IGNvbmRpdGlvbmFscyB0byBhbiBleGNlcHRpb24gPgoJVmltOkU0OTI6IE5vdCBhbiBlZGl0b3IgY29tbWFuZDogZHdpbQoKWW91IGNhbiBjYXRjaCBhbGwgIjp1bmxldCIgZXJyb3JzIGJ5IGEgPgoJOmNhdGNoIC9eVmltKHVubGV0KTovCm9yIGFsbCBlcnJvcnMgZm9yIG1pc3NwZWxsZWQgY29tbWFuZCBuYW1lcyBieSBhID4KCTpjYXRjaCAvXlZpbTpFNDkyOi8KClNvbWUgZXJyb3IgbWVzc2FnZXMgbWF5IGJlIHByb2R1Y2VkIGJ5IGRpZmZlcmVudCBjb21tYW5kczogPgoJOmZ1bmN0aW9uIG5vZnVuYwphbmQgPgoJOmRlbGZ1bmN0aW9uIG5vZnVuYwpib3RoIHByb2R1Y2UgdGhlIGVycm9yIG1lc3NhZ2UgPgoJRTEyODogRnVuY3Rpb24gbmFtZSBtdXN0IHN0YXJ0IHdpdGggYSBjYXBpdGFsOiBub2Z1bmMKd2hpY2ggaXMgY29udmVydGVkIGluc2lkZSB0cnkgY29uZGl0aW9uYWxzIHRvIGFuIGV4Y2VwdGlvbiA+CglWaW0oZnVuY3Rpb24pOkUxMjg6IEZ1bmN0aW9uIG5hbWUgbXVzdCBzdGFydCB3aXRoIGEgY2FwaXRhbDogbm9mdW5jCm9yID4KCVZpbShkZWxmdW5jdGlvbik6RTEyODogRnVuY3Rpb24gbmFtZSBtdXN0IHN0YXJ0IHdpdGggYSBjYXBpdGFsOiBub2Z1bmMKcmVzcGVjdGl2ZWx5LiAgWW91IGNhbiBjYXRjaCB0aGUgZXJyb3IgYnkgaXRzIG51bWJlciBpbmRlcGVuZGVudGx5IG9uIHRoZQpjb21tYW5kIHRoYXQgY2F1c2VkIGl0IGlmIHlvdSB1c2UgdGhlIGZvbGxvd2luZyBwYXR0ZXJuOiA+Cgk6Y2F0Y2ggL15WaW0oXGFcKyk6RTEyODovCgpTb21lIGNvbW1hbmRzIGxpa2UgPgoJOmxldCB4ID0gbm92YXIKcHJvZHVjZSBtdWx0aXBsZSBlcnJvciBtZXNzYWdlcywgaGVyZTogPgoJRTEyMTogVW5kZWZpbmVkIHZhcmlhYmxlOiBub3ZhcgoJRTE1OiBJbnZhbGlkIGV4cHJlc3Npb246ICBub3ZhcgpPbmx5IHRoZSBmaXJzdCBpcyB1c2VkIGZvciB0aGUgZXhjZXB0aW9uIHZhbHVlLCBzaW5jZSBpdCBpcyB0aGUgbW9zdCBzcGVjaWZpYwpvbmUgKHNlZSB8ZXhjZXB0LXNldmVyYWwtZXJyb3JzfCkuICBTbyB5b3UgY2FuIGNhdGNoIGl0IGJ5ID4KCTpjYXRjaCAvXlZpbShcYVwrKTpFMTIxOi8KCllvdSBjYW4gY2F0Y2ggYWxsIGVycm9ycyByZWxhdGVkIHRvIHRoZSBuYW1lICJub2Z1bmMiIGJ5ID4KCTpjYXRjaCAvXDxub2Z1bmNcPi8KCllvdSBjYW4gY2F0Y2ggYWxsIFZpbSBlcnJvcnMgaW4gdGhlICI6d3JpdGUiIGFuZCAiOnJlYWQiIGNvbW1hbmRzIGJ5ID4KCTpjYXRjaCAvXlZpbShcKHdyaXRlXHxyZWFkXCkpOkVcZFwrOi8KCllvdSBjYW4gY2F0Y2ggYWxsIFZpbSBlcnJvcnMgYnkgdGhlIHBhdHRlcm4gPgoJOmNhdGNoIC9eVmltXCgoXGFcKylcKVw9OkVcZFwrOi8KPAoJCQkJCQkJKmNhdGNoLXRleHQqCk5PVEU6IFlvdSBzaG91bGQgbmV2ZXIgY2F0Y2ggdGhlIGVycm9yIG1lc3NhZ2UgdGV4dCBpdHNlbGY6ID4KCTpjYXRjaCAvTm8gc3VjaCB2YXJpYWJsZS8Kb25seSB3b3JrcyBpbiB0aGUgRW5nbGlzaCBsb2NhbGUsIGJ1dCBub3Qgd2hlbiB0aGUgdXNlciBoYXMgc2VsZWN0ZWQKYSBkaWZmZXJlbnQgbGFuZ3VhZ2UgYnkgdGhlIHw6bGFuZ3VhZ2V8IGNvbW1hbmQuICBJdCBpcyBob3dldmVyIGhlbHBmdWwgdG8KY2l0ZSB0aGUgbWVzc2FnZSB0ZXh0IGluIGEgY29tbWVudDogPgoJOmNhdGNoIC9eVmltKFxhXCspOkUxMDg6LyAgICIgTm8gc3VjaCB2YXJpYWJsZQoKCklHTk9SSU5HIEVSUk9SUwkJCQkJCSppZ25vcmUtZXJyb3JzKgoKWW91IGNhbiBpZ25vcmUgZXJyb3JzIGluIGEgc3BlY2lmaWMgVmltIGNvbW1hbmQgYnkgY2F0Y2hpbmcgdGhlbSBsb2NhbGx5OiA+CgoJOnRyeQoJOiAgd3JpdGUKCTpjYXRjaAoJOmVuZHRyeQoKQnV0IHlvdSBhcmUgc3Ryb25nbHkgcmVjb21tZW5kZWQgTk9UIHRvIHVzZSB0aGlzIHNpbXBsZSBmb3JtLCBzaW5jZSBpdCBjb3VsZApjYXRjaCBtb3JlIHRoYW4geW91IHdhbnQuICBXaXRoIHRoZSAiOndyaXRlIiBjb21tYW5kLCBzb21lIGF1dG9jb21tYW5kcyBjb3VsZApiZSBleGVjdXRlZCBhbmQgY2F1c2UgZXJyb3JzIG5vdCByZWxhdGVkIHRvIHdyaXRpbmcsIGZvciBpbnN0YW5jZTogPgoKCTphdSBCdWZXcml0ZVByZSAqIHVubGV0IG5vdmFyCgpUaGVyZSBjb3VsZCBldmVuIGJlIHN1Y2ggZXJyb3JzIHlvdSBhcmUgbm90IHJlc3BvbnNpYmxlIGZvciBhcyBhIHNjcmlwdAp3cml0ZXI6IGEgdXNlciBvZiB5b3VyIHNjcmlwdCBtaWdodCBoYXZlIGRlZmluZWQgc3VjaCBhdXRvY29tbWFuZHMuICBZb3Ugd291bGQKdGhlbiBoaWRlIHRoZSBlcnJvciBmcm9tIHRoZSB1c2VyLgogICBJdCBpcyBtdWNoIGJldHRlciB0byB1c2UgPgoKCTp0cnkKCTogIHdyaXRlCgk6Y2F0Y2ggL15WaW0od3JpdGUpOi8KCTplbmR0cnkKCndoaWNoIG9ubHkgY2F0Y2hlcyByZWFsIHdyaXRlIGVycm9ycy4gIFNvIGNhdGNoIG9ubHkgd2hhdCB5b3UnZCBsaWtlIHRvIGlnbm9yZQppbnRlbnRpb25hbGx5LgoKRm9yIGEgc2luZ2xlIGNvbW1hbmQgdGhhdCBkb2VzIG5vdCBjYXVzZSBleGVjdXRpb24gb2YgYXV0b2NvbW1hbmRzLCB5b3UgY291bGQKZXZlbiBzdXBwcmVzcyB0aGUgY29udmVyc2lvbiBvZiBlcnJvcnMgdG8gZXhjZXB0aW9ucyBieSB0aGUgIjpzaWxlbnQhIgpjb21tYW5kOiA+Cgk6c2lsZW50ISBudW5tYXAgawpUaGlzIHdvcmtzIGFsc28gd2hlbiBhIHRyeSBjb25kaXRpb25hbCBpcyBhY3RpdmUuCgoKQ0FUQ0hJTkcgSU5URVJSVVBUUwkJCQkJKmNhdGNoLWludGVycnVwdCoKCldoZW4gdGhlcmUgYXJlIGFjdGl2ZSB0cnkgY29uZGl0aW9uYWxzLCBhbiBpbnRlcnJ1cHQgKENUUkwtQykgaXMgY29udmVydGVkIHRvCnRoZSBleGNlcHRpb24gIlZpbTpJbnRlcnJ1cHQiLglZb3UgY2FuIGNhdGNoIGl0IGxpa2UgZXZlcnkgZXhjZXB0aW9uLglUaGUKc2NyaXB0IGlzIG5vdCB0ZXJtaW5hdGVkLCB0aGVuLgogICBFeGFtcGxlOiA+CgoJOmZ1bmN0aW9uISBUQVNLMSgpCgk6ICBzbGVlcCAxMAoJOmVuZGZ1bmN0aW9uCgoJOmZ1bmN0aW9uISBUQVNLMigpCgk6ICBzbGVlcCAyMAoJOmVuZGZ1bmN0aW9uCgoJOndoaWxlIDEKCTogIGxldCBjb21tYW5kID0gaW5wdXQoIlR5cGUgYSBjb21tYW5kOiAiKQoJOiAgdHJ5Cgk6ICAgIGlmIGNvbW1hbmQgPT0gIiIKCTogICAgICBjb250aW51ZQoJOiAgICBlbHNlaWYgY29tbWFuZCA9PSAiRU5EIgoJOiAgICAgIGJyZWFrCgk6ICAgIGVsc2VpZiBjb21tYW5kID09ICJUQVNLMSIKCTogICAgICBjYWxsIFRBU0sxKCkKCTogICAgZWxzZWlmIGNvbW1hbmQgPT0gIlRBU0syIgoJOiAgICAgIGNhbGwgVEFTSzIoKQoJOiAgICBlbHNlCgk6ICAgICAgZWNobyAiXG5JbGxlZ2FsIGNvbW1hbmQ6IiBjb21tYW5kCgk6ICAgICAgY29udGludWUKCTogICAgZW5kaWYKCTogIGNhdGNoIC9eVmltOkludGVycnVwdCQvCgk6ICAgIGVjaG8gIlxuQ29tbWFuZCBpbnRlcnJ1cHRlZCIKCTogICAgIiBDYXVnaHQgdGhlIGludGVycnVwdC4gIENvbnRpbnVlIHdpdGggbmV4dCBwcm9tcHQuCgk6ICBlbmR0cnkKCTplbmR3aGlsZQoKWW91IGNhbiBpbnRlcnJ1cHQgYSB0YXNrIGhlcmUgYnkgcHJlc3NpbmcgQ1RSTC1DOyB0aGUgc2NyaXB0IHRoZW4gYXNrcyBmb3IKYSBuZXcgY29tbWFuZC4JSWYgeW91IHByZXNzIENUUkwtQyBhdCB0aGUgcHJvbXB0LCB0aGUgc2NyaXB0IGlzIHRlcm1pbmF0ZWQuCgpGb3IgdGVzdGluZyB3aGF0IGhhcHBlbnMgd2hlbiBDVFJMLUMgd291bGQgYmUgcHJlc3NlZCBvbiBhIHNwZWNpZmljIGxpbmUgaW4KeW91ciBzY3JpcHQsIHVzZSB0aGUgZGVidWcgbW9kZSBhbmQgZXhlY3V0ZSB0aGUgfD5xdWl0fCBvciB8PmludGVycnVwdHwKY29tbWFuZCBvbiB0aGF0IGxpbmUuICBTZWUgfGRlYnVnLXNjcmlwdHN8LgoKCkNBVENISU5HIEFMTAkJCQkJCSpjYXRjaC1hbGwqCgpUaGUgY29tbWFuZHMgPgoKCTpjYXRjaCAvLiovCgk6Y2F0Y2ggLy8KCTpjYXRjaAoKY2F0Y2ggZXZlcnl0aGluZywgZXJyb3IgZXhjZXB0aW9ucywgaW50ZXJydXB0IGV4Y2VwdGlvbnMgYW5kIGV4Y2VwdGlvbnMKZXhwbGljaXRseSB0aHJvd24gYnkgdGhlIHw6dGhyb3d8IGNvbW1hbmQuICBUaGlzIGlzIHVzZWZ1bCBhdCB0aGUgdG9wIGxldmVsIG9mCmEgc2NyaXB0IGluIG9yZGVyIHRvIGNhdGNoIHVuZXhwZWN0ZWQgdGhpbmdzLgogICBFeGFtcGxlOiA+CgoJOnRyeQoJOgoJOiAgIiBkbyB0aGUgaGFyZCB3b3JrIGhlcmUKCToKCTpjYXRjaCAvTXlFeGNlcHRpb24vCgk6Cgk6ICAiIGhhbmRsZSBrbm93biBwcm9ibGVtCgk6Cgk6Y2F0Y2ggL15WaW06SW50ZXJydXB0JC8KCTogICAgZWNobyAiU2NyaXB0IGludGVycnVwdGVkIgoJOmNhdGNoIC8uKi8KCTogIGVjaG8gIkludGVybmFsIGVycm9yICgiIC4gdjpleGNlcHRpb24gLiAiKSIKCTogIGVjaG8gIiAtIG9jY3VycmVkIGF0ICIgLiB2OnRocm93cG9pbnQKCTplbmR0cnkKCToiIGVuZCBvZiBzY3JpcHQKCk5vdGU6IENhdGNoaW5nIGFsbCBtaWdodCBjYXRjaCBtb3JlIHRoaW5ncyB0aGFuIHlvdSB3YW50LiAgVGh1cywgeW91IGFyZQpzdHJvbmdseSBlbmNvdXJhZ2VkIHRvIGNhdGNoIG9ubHkgZm9yIHByb2JsZW1zIHRoYXQgeW91IGNhbiByZWFsbHkgaGFuZGxlIGJ5CnNwZWNpZnlpbmcgYSBwYXR0ZXJuIGFyZ3VtZW50IHRvIHRoZSAiOmNhdGNoIi4KICAgRXhhbXBsZTogQ2F0Y2hpbmcgYWxsIGNvdWxkIG1ha2UgaXQgbmVhcmx5IGltcG9zc2libGUgdG8gaW50ZXJydXB0IGEgc2NyaXB0CmJ5IHByZXNzaW5nIENUUkwtQzogPgoKCTp3aGlsZSAxCgk6ICB0cnkKCTogICAgc2xlZXAgMQoJOiAgY2F0Y2gKCTogIGVuZHRyeQoJOmVuZHdoaWxlCgoKRVhDRVBUSU9OUyBBTkQgQVVUT0NPTU1BTkRTCQkJCSpleGNlcHQtYXV0b2NtZCoKCkV4Y2VwdGlvbnMgbWF5IGJlIHVzZWQgZHVyaW5nIGV4ZWN1dGlvbiBvZiBhdXRvY29tbWFuZHMuICBFeGFtcGxlOiA+CgoJOmF1dG9jbWQgVXNlciB4IHRyeQoJOmF1dG9jbWQgVXNlciB4ICAgdGhyb3cgIk9vcHMhIgoJOmF1dG9jbWQgVXNlciB4IGNhdGNoCgk6YXV0b2NtZCBVc2VyIHggICBlY2hvIHY6ZXhjZXB0aW9uCgk6YXV0b2NtZCBVc2VyIHggZW5kdHJ5Cgk6YXV0b2NtZCBVc2VyIHggdGhyb3cgIkFycmdoISIKCTphdXRvY21kIFVzZXIgeCBlY2hvICJTaG91bGQgbm90IGJlIGRpc3BsYXllZCIKCToKCTp0cnkKCTogIGRvYXV0b2NtZCBVc2VyIHgKCTpjYXRjaAoJOiAgZWNobyB2OmV4Y2VwdGlvbgoJOmVuZHRyeQoKVGhpcyBkaXNwbGF5cyAiT29wcyEiIGFuZCAiQXJyZ2ghIi4KCgkJCQkJCQkqZXhjZXB0LWF1dG9jbWQtUHJlKgpGb3Igc29tZSBjb21tYW5kcywgYXV0b2NvbW1hbmRzIGdldCBleGVjdXRlZCBiZWZvcmUgdGhlIG1haW4gYWN0aW9uIG9mIHRoZQpjb21tYW5kIHRha2VzIHBsYWNlLiAgSWYgYW4gZXhjZXB0aW9uIGlzIHRocm93biBhbmQgbm90IGNhdWdodCBpbiB0aGUgc2VxdWVuY2UKb2YgYXV0b2NvbW1hbmRzLCB0aGUgc2VxdWVuY2UgYW5kIHRoZSBjb21tYW5kIHRoYXQgY2F1c2VkIGl0cyBleGVjdXRpb24gYXJlCmFiYW5kb25lZCBhbmQgdGhlIGV4Y2VwdGlvbiBpcyBwcm9wYWdhdGVkIHRvIHRoZSBjYWxsZXIgb2YgdGhlIGNvbW1hbmQuCiAgIEV4YW1wbGU6ID4KCgk6YXV0b2NtZCBCdWZXcml0ZVByZSAqIHRocm93ICJGQUlMIgoJOmF1dG9jbWQgQnVmV3JpdGVQcmUgKiBlY2hvICJTaG91bGQgbm90IGJlIGRpc3BsYXllZCIKCToKCTp0cnkKCTogIHdyaXRlCgk6Y2F0Y2gKCTogIGVjaG8gIkNhdWdodDoiIHY6ZXhjZXB0aW9uICJmcm9tIiB2OnRocm93cG9pbnQKCTplbmR0cnkKCkhlcmUsIHRoZSAiOndyaXRlIiBjb21tYW5kIGRvZXMgbm90IHdyaXRlIHRoZSBmaWxlIGN1cnJlbnRseSBiZWluZyBlZGl0ZWQgKGFzCnlvdSBjYW4gc2VlIGJ5IGNoZWNraW5nICdtb2RpZmllZCcpLCBzaW5jZSB0aGUgZXhjZXB0aW9uIGZyb20gdGhlIEJ1ZldyaXRlUHJlCmF1dG9jb21tYW5kIGFiYW5kb25zIHRoZSAiOndyaXRlIi4gIFRoZSBleGNlcHRpb24gaXMgdGhlbiBjYXVnaHQgYW5kIHRoZQpzY3JpcHQgZGlzcGxheXM6ID4KCglDYXVnaHQ6IEZBSUwgZnJvbSBCdWZXcml0ZSBBdXRvIGNvbW1hbmRzIGZvciAiKiIKPAoJCQkJCQkJKmV4Y2VwdC1hdXRvY21kLVBvc3QqCkZvciBzb21lIGNvbW1hbmRzLCBhdXRvY29tbWFuZHMgZ2V0IGV4ZWN1dGVkIGFmdGVyIHRoZSBtYWluIGFjdGlvbiBvZiB0aGUKY29tbWFuZCBoYXMgdGFrZW4gcGxhY2UuICBJZiB0aGlzIG1haW4gYWN0aW9uIGZhaWxzIGFuZCB0aGUgY29tbWFuZCBpcyBpbnNpZGUKYW4gYWN0aXZlIHRyeSBjb25kaXRpb25hbCwgdGhlIGF1dG9jb21tYW5kcyBhcmUgc2tpcHBlZCBhbmQgYW4gZXJyb3IgZXhjZXB0aW9uCmlzIHRocm93biB0aGF0IGNhbiBiZSBjYXVnaHQgYnkgdGhlIGNhbGxlciBvZiB0aGUgY29tbWFuZC4KICAgRXhhbXBsZTogPgoKCTphdXRvY21kIEJ1ZldyaXRlUG9zdCAqIGVjaG8gIkZpbGUgc3VjY2Vzc2Z1bGx5IHdyaXR0ZW4hIgoJOgoJOnRyeQoJOiAgd3JpdGUgL2kvbS9wL28vcy9zL2kvYi9sL2UKCTpjYXRjaAoJOiAgZWNobyB2OmV4Y2VwdGlvbgoJOmVuZHRyeQoKVGhpcyBqdXN0IGRpc3BsYXlzOiA+CgoJVmltKHdyaXRlKTpFMjEyOiBDYW4ndCBvcGVuIGZpbGUgZm9yIHdyaXRpbmcgKC9pL20vcC9vL3Mvcy9pL2IvbC9lKQoKSWYgeW91IHJlYWxseSBuZWVkIHRvIGV4ZWN1dGUgdGhlIGF1dG9jb21tYW5kcyBldmVuIHdoZW4gdGhlIG1haW4gYWN0aW9uCmZhaWxzLCB0cmlnZ2VyIHRoZSBldmVudCBmcm9tIHRoZSBjYXRjaCBjbGF1c2UuCiAgIEV4YW1wbGU6ID4KCgk6YXV0b2NtZCBCdWZXcml0ZVByZSAgKiBzZXQgbm9yZWFkb25seQoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogc2V0IHJlYWRvbmx5Cgk6Cgk6dHJ5Cgk6ICB3cml0ZSAvaS9tL3Avby9zL3MvaS9iL2wvZQoJOmNhdGNoCgk6ICBkb2F1dG9jbWQgQnVmV3JpdGVQb3N0IC9pL20vcC9vL3Mvcy9pL2IvbC9lCgk6ZW5kdHJ5CjwKWW91IGNhbiBhbHNvIHVzZSAiOnNpbGVudCEiOiA+CgoJOmxldCB4ID0gIm9rIgoJOmxldCB2OmVycm1zZyA9ICIiCgk6YXV0b2NtZCBCdWZXcml0ZVBvc3QgKiBpZiB2OmVycm1zZyAhPSAiIgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogICBsZXQgeCA9ICJhZnRlciBmYWlsIgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogZW5kaWYKCTp0cnkKCTogIHNpbGVudCEgd3JpdGUgL2kvbS9wL28vcy9zL2kvYi9sL2UKCTpjYXRjaAoJOmVuZHRyeQoJOmVjaG8geAoKVGhpcyBkaXNwbGF5cyAiYWZ0ZXIgZmFpbCIuCgpJZiB0aGUgbWFpbiBhY3Rpb24gb2YgdGhlIGNvbW1hbmQgZG9lcyBub3QgZmFpbCwgZXhjZXB0aW9ucyBmcm9tIHRoZQphdXRvY29tbWFuZHMgd2lsbCBiZSBjYXRjaGFibGUgYnkgdGhlIGNhbGxlciBvZiB0aGUgY29tbWFuZDogID4KCgk6YXV0b2NtZCBCdWZXcml0ZVBvc3QgKiB0aHJvdyAiOi0oIgoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogZWNobyAiU2hvdWxkIG5vdCBiZSBkaXNwbGF5ZWQiCgk6Cgk6dHJ5Cgk6ICB3cml0ZQoJOmNhdGNoCgk6ICBlY2hvIHY6ZXhjZXB0aW9uCgk6ZW5kdHJ5CjwKCQkJCQkJCSpleGNlcHQtYXV0b2NtZC1DbWQqCkZvciBzb21lIGNvbW1hbmRzLCB0aGUgbm9ybWFsIGFjdGlvbiBjYW4gYmUgcmVwbGFjZWQgYnkgYSBzZXF1ZW5jZSBvZgphdXRvY29tbWFuZHMuICBFeGNlcHRpb25zIGZyb20gdGhhdCBzZXF1ZW5jZSB3aWxsIGJlIGNhdGNoYWJsZSBieSB0aGUgY2FsbGVyCm9mIHRoZSBjb21tYW5kLgogICBFeGFtcGxlOiAgRm9yIHRoZSAiOndyaXRlIiBjb21tYW5kLCB0aGUgY2FsbGVyIGNhbm5vdCBrbm93IHdoZXRoZXIgdGhlIGZpbGUKaGFkIGFjdHVhbGx5IGJlZW4gd3JpdHRlbiB3aGVuIHRoZSBleGNlcHRpb24gb2NjdXJyZWQuCVlvdSBuZWVkIHRvIHRlbGwgaXQgaW4Kc29tZSB3YXkuID4KCgk6aWYgIWV4aXN0cygiY250IikKCTogIGxldCBjbnQgPSAwCgk6Cgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogaWYgJm1vZGlmaWVkCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogICBsZXQgY250ID0gY250ICsgMQoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqICAgaWYgY250ICUgMyA9PSAyCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogICAgIHRocm93ICJCdWZXcml0ZUNtZEVycm9yIgoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqICAgZW5kaWYKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiAgIHdyaXRlIHwgc2V0IG5vbW9kaWZpZWQKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiAgIGlmIGNudCAlIDMgPT0gMAoJOiAgYXV0b2NtZCBCdWZXcml0ZUNtZCAqICAgICB0aHJvdyAiQnVmV3JpdGVDbWRFcnJvciIKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiAgIGVuZGlmCgk6ICBhdXRvY21kIEJ1ZldyaXRlQ21kICogICBlY2hvICJGaWxlIHN1Y2Nlc3NmdWxseSB3cml0dGVuISIKCTogIGF1dG9jbWQgQnVmV3JpdGVDbWQgKiBlbmRpZgoJOmVuZGlmCgk6Cgk6dHJ5Cgk6CXdyaXRlCgk6Y2F0Y2ggL15CdWZXcml0ZUNtZEVycm9yJC8KCTogIGlmICZtb2RpZmllZAoJOiAgICBlY2hvICJFcnJvciBvbiB3cml0aW5nIChmaWxlIGNvbnRlbnRzIG5vdCBjaGFuZ2VkKSIKCTogIGVsc2UKCTogICAgZWNobyAiRXJyb3IgYWZ0ZXIgd3JpdGluZyIKCTogIGVuZGlmCgk6Y2F0Y2ggL15WaW0od3JpdGUpOi8KCTogICAgZWNobyAiRXJyb3Igb24gd3JpdGluZyIKCTplbmR0cnkKCldoZW4gdGhpcyBzY3JpcHQgaXMgc291cmNlZCBzZXZlcmFsIHRpbWVzIGFmdGVyIG1ha2luZyBjaGFuZ2VzLCBpdCBkaXNwbGF5cwpmaXJzdCA+CglGaWxlIHN1Y2Nlc3NmdWxseSB3cml0dGVuIQp0aGVuID4KCUVycm9yIG9uIHdyaXRpbmcgKGZpbGUgY29udGVudHMgbm90IGNoYW5nZWQpCnRoZW4gPgoJRXJyb3IgYWZ0ZXIgd3JpdGluZwpldGMuCgoJCQkJCQkJKmV4Y2VwdC1hdXRvY21kLWlsbCoKWW91IGNhbm5vdCBzcHJlYWQgYSB0cnkgY29uZGl0aW9uYWwgb3ZlciBhdXRvY29tbWFuZHMgZm9yIGRpZmZlcmVudCBldmVudHMuClRoZSBmb2xsb3dpbmcgY29kZSBpcyBpbGwtZm9ybWVkOiA+CgoJOmF1dG9jbWQgQnVmV3JpdGVQcmUgICogdHJ5Cgk6Cgk6YXV0b2NtZCBCdWZXcml0ZVBvc3QgKiBjYXRjaAoJOmF1dG9jbWQgQnVmV3JpdGVQb3N0ICogICBlY2hvIHY6ZXhjZXB0aW9uCgk6YXV0b2NtZCBCdWZXcml0ZVBvc3QgKiBlbmR0cnkKCToKCTp3cml0ZQoKCkVYQ0VQVElPTiBISUVSQVJDSElFUyBBTkQgUEFSQU1FVEVSSVpFRCBFWENFUFRJT05TCSpleGNlcHQtaGllci1wYXJhbSoKClNvbWUgcHJvZ3JhbW1pbmcgbGFuZ3VhZ2VzIGFsbG93IHRvIHVzZSBoaWVyYXJjaGllcyBvZiBleGNlcHRpb24gY2xhc3NlcyBvciB0bwpwYXNzIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24gd2l0aCB0aGUgb2JqZWN0IG9mIGFuIGV4Y2VwdGlvbiBjbGFzcy4gIFlvdSBjYW4gZG8Kc2ltaWxhciB0aGluZ3MgaW4gVmltLgogICBJbiBvcmRlciB0byB0aHJvdyBhbiBleGNlcHRpb24gZnJvbSBhIGhpZXJhcmNoeSwganVzdCB0aHJvdyB0aGUgY29tcGxldGUKY2xhc3MgbmFtZSB3aXRoIHRoZSBjb21wb25lbnRzIHNlcGFyYXRlZCBieSBhIGNvbG9uLCBmb3IgaW5zdGFuY2UgdGhyb3cgdGhlCnN0cmluZyAiRVhDRVBUOk1BVEhFUlI6T1ZFUkZMT1ciIGZvciBhbiBvdmVyZmxvdyBpbiBhIG1hdGhlbWF0aWNhbCBsaWJyYXJ5LgogICBXaGVuIHlvdSB3YW50IHRvIHBhc3MgYWRkaXRpb25hbCBpbmZvcm1hdGlvbiB3aXRoIHlvdXIgZXhjZXB0aW9uIGNsYXNzLCBhZGQKaXQgaW4gcGFyZW50aGVzZXMsIGZvciBpbnN0YW5jZSB0aHJvdyB0aGUgc3RyaW5nICJFWENFUFQ6SU86V1JJVEVFUlIobXlmaWxlKSIKZm9yIGFuIGVycm9yIHdoZW4gd3JpdGluZyAibXlmaWxlIi4KICAgV2l0aCB0aGUgYXBwcm9wcmlhdGUgcGF0dGVybnMgaW4gdGhlICI6Y2F0Y2giIGNvbW1hbmQsIHlvdSBjYW4gY2F0Y2ggZm9yCmJhc2UgY2xhc3NlcyBvciBkZXJpdmVkIGNsYXNzZXMgb2YgeW91ciBoaWVyYXJjaHkuICBBZGRpdGlvbmFsIGluZm9ybWF0aW9uIGluCnBhcmVudGhlc2VzIGNhbiBiZSBjdXQgb3V0IGZyb20gfHY6ZXhjZXB0aW9ufCB3aXRoIHRoZSAiOnN1YnN0aXR1dGUiIGNvbW1hbmQuCiAgIEV4YW1wbGU6ID4KCgk6ZnVuY3Rpb24hIENoZWNrUmFuZ2UoYSwgZnVuYykKCTogIGlmIGE6YSA8IDAKCTogICAgdGhyb3cgIkVYQ0VQVDpNQVRIRVJSOlJBTkdFKCIgLiBhOmZ1bmMgLiAiKSIKCTogIGVuZGlmCgk6ZW5kZnVuY3Rpb24KCToKCTpmdW5jdGlvbiEgQWRkKGEsIGIpCgk6ICBjYWxsIENoZWNrUmFuZ2UoYTphLCAiQWRkIikKCTogIGNhbGwgQ2hlY2tSYW5nZShhOmIsICJBZGQiKQoJOiAgbGV0IGMgPSBhOmEgKyBhOmIKCTogIGlmIGMgPCAwCgk6ICAgIHRocm93ICJFWENFUFQ6TUFUSEVSUjpPVkVSRkxPVyIKCTogIGVuZGlmCgk6ICByZXR1cm4gYwoJOmVuZGZ1bmN0aW9uCgk6Cgk6ZnVuY3Rpb24hIERpdihhLCBiKQoJOiAgY2FsbCBDaGVja1JhbmdlKGE6YSwgIkRpdiIpCgk6ICBjYWxsIENoZWNrUmFuZ2UoYTpiLCAiRGl2IikKCTogIGlmIChhOmIgPT0gMCkKCTogICAgdGhyb3cgIkVYQ0VQVDpNQVRIRVJSOlpFUk9ESVYiCgk6ICBlbmRpZgoJOiAgcmV0dXJuIGE6YSAvIGE6YgoJOmVuZGZ1bmN0aW9uCgk6Cgk6ZnVuY3Rpb24hIFdyaXRlKGZpbGUpCgk6ICB0cnkKCTogICAgZXhlY3V0ZSAid3JpdGUiIGZuYW1lZXNjYXBlKGE6ZmlsZSkKCTogIGNhdGNoIC9eVmltKHdyaXRlKTovCgk6ICAgIHRocm93ICJFWENFUFQ6SU8oIiAuIGdldGN3ZCgpIC4gIiwgIiAuIGE6ZmlsZSAuICIpOldSSVRFRVJSIgoJOiAgZW5kdHJ5Cgk6ZW5kZnVuY3Rpb24KCToKCTp0cnkKCToKCTogICIgc29tZXRoaW5nIHdpdGggYXJpdGhtZXRpY3MgYW5kIEkvTwoJOgoJOmNhdGNoIC9eRVhDRVBUOk1BVEhFUlI6UkFOR0UvCgk6ICBsZXQgZnVuY3Rpb24gPSBzdWJzdGl0dXRlKHY6ZXhjZXB0aW9uLCAnLiooXChcYVwrXCkpLionLCAnXDEnLCAiIikKCTogIGVjaG8gIlJhbmdlIGVycm9yIGluIiBmdW5jdGlvbgoJOgoJOmNhdGNoIC9eRVhDRVBUOk1BVEhFUlIvCSIgY2F0Y2hlcyBPVkVSRkxPVyBhbmQgWkVST0RJVgoJOiAgZWNobyAiTWF0aCBlcnJvciIKCToKCTpjYXRjaCAvXkVYQ0VQVDpJTy8KCTogIGxldCBkaXIgPSBzdWJzdGl0dXRlKHY6ZXhjZXB0aW9uLCAnLiooXCguXCtcKSxccyouXCspLionLCAnXDEnLCAiIikKCTogIGxldCBmaWxlID0gc3Vic3RpdHV0ZSh2OmV4Y2VwdGlvbiwgJy4qKC5cKyxccypcKC5cK1wpKS4qJywgJ1wxJywgIiIpCgk6ICBpZiBmaWxlICF+ICdeLycKCTogICAgbGV0IGZpbGUgPSBkaXIgLiAiLyIgLiBmaWxlCgk6ICBlbmRpZgoJOiAgZWNobyAnSS9PIGVycm9yIGZvciAiJyAuIGZpbGUgLiAnIicKCToKCTpjYXRjaCAvXkVYQ0VQVC8KCTogIGVjaG8gIlVuc3BlY2lmaWVkIGVycm9yIgoJOgoJOmVuZHRyeQoKVGhlIGV4Y2VwdGlvbnMgcmFpc2VkIGJ5IFZpbSBpdHNlbGYgKG9uIGVycm9yIG9yIHdoZW4gcHJlc3NpbmcgQ1RSTC1DKSB1c2UKYSBmbGF0IGhpZXJhcmNoeTogIHRoZXkgYXJlIGFsbCBpbiB0aGUgIlZpbSIgY2xhc3MuICBZb3UgY2Fubm90IHRocm93IHlvdXJzZWxmCmV4Y2VwdGlvbnMgd2l0aCB0aGUgIlZpbSIgcHJlZml4OyB0aGV5IGFyZSByZXNlcnZlZCBmb3IgVmltLgogICBWaW0gZXJyb3IgZXhjZXB0aW9ucyBhcmUgcGFyYW1ldGVyaXplZCB3aXRoIHRoZSBuYW1lIG9mIHRoZSBjb21tYW5kIHRoYXQKZmFpbGVkLCBpZiBrbm93bi4gIFNlZSB8Y2F0Y2gtZXJyb3JzfC4KCgpQRUNVTElBUklUSUVTCgkJCQkJCQkqZXhjZXB0LWNvbXBhdCoKVGhlIGV4Y2VwdGlvbiBoYW5kbGluZyBjb25jZXB0IHJlcXVpcmVzIHRoYXQgdGhlIGNvbW1hbmQgc2VxdWVuY2UgY2F1c2luZyB0aGUKZXhjZXB0aW9uIGlzIGFib3J0ZWQgaW1tZWRpYXRlbHkgYW5kIGNvbnRyb2wgaXMgdHJhbnNmZXJyZWQgdG8gZmluYWxseSBjbGF1c2VzCmFuZC9vciBhIGNhdGNoIGNsYXVzZS4KCkluIHRoZSBWaW0gc2NyaXB0IGxhbmd1YWdlIHRoZXJlIGFyZSBjYXNlcyB3aGVyZSBzY3JpcHRzIGFuZCBmdW5jdGlvbnMKY29udGludWUgYWZ0ZXIgYW4gZXJyb3I6IGluIGZ1bmN0aW9ucyB3aXRob3V0IHRoZSAiYWJvcnQiIGZsYWcgb3IgaW4gYSBjb21tYW5kCmFmdGVyICI6c2lsZW50ISIsIGNvbnRyb2wgZmxvdyBnb2VzIHRvIHRoZSBmb2xsb3dpbmcgbGluZSwgYW5kIG91dHNpZGUKZnVuY3Rpb25zLCBjb250cm9sIGZsb3cgZ29lcyB0byB0aGUgbGluZSBmb2xsb3dpbmcgdGhlIG91dGVybW9zdCAiOmVuZHdoaWxlIgpvciAiOmVuZGlmIi4gIE9uIHRoZSBvdGhlciBoYW5kLCBlcnJvcnMgc2hvdWxkIGJlIGNhdGNoYWJsZSBhcyBleGNlcHRpb25zCih0aHVzLCByZXF1aXJpbmcgdGhlIGltbWVkaWF0ZSBhYm9ydGlvbikuCgpUaGlzIHByb2JsZW0gaGFzIGJlZW4gc29sdmVkIGJ5IGNvbnZlcnRpbmcgZXJyb3JzIHRvIGV4Y2VwdGlvbnMgYW5kIHVzaW5nCmltbWVkaWF0ZSBhYm9ydGlvbiAoaWYgbm90IHN1cHByZXNzZWQgYnkgIjpzaWxlbnQhIikgb25seSB3aGVuIGEgdHJ5CmNvbmRpdGlvbmFsIGlzIGFjdGl2ZS4JVGhpcyBpcyBubyByZXN0cmljdGlvbiBzaW5jZSBhbiAoZXJyb3IpIGV4Y2VwdGlvbiBjYW4KYmUgY2F1Z2h0IG9ubHkgZnJvbSBhbiBhY3RpdmUgdHJ5IGNvbmRpdGlvbmFsLglJZiB5b3Ugd2FudCBhbiBpbW1lZGlhdGUKdGVybWluYXRpb24gd2l0aG91dCBjYXRjaGluZyB0aGUgZXJyb3IsIGp1c3QgdXNlIGEgdHJ5IGNvbmRpdGlvbmFsIHdpdGhvdXQKY2F0Y2ggY2xhdXNlLiAgKFlvdSBjYW4gY2F1c2UgY2xlYW51cCBjb2RlIGJlaW5nIGV4ZWN1dGVkIGJlZm9yZSB0ZXJtaW5hdGlvbgpieSBzcGVjaWZ5aW5nIGEgZmluYWxseSBjbGF1c2UuKQoKV2hlbiBubyB0cnkgY29uZGl0aW9uYWwgaXMgYWN0aXZlLCB0aGUgdXN1YWwgYWJvcnRpb24gYW5kIGNvbnRpbnVhdGlvbgpiZWhhdmlvciBpcyB1c2VkIGluc3RlYWQgb2YgaW1tZWRpYXRlIGFib3J0aW9uLiAgVGhpcyBlbnN1cmVzIGNvbXBhdGliaWxpdHkgb2YKc2NyaXB0cyB3cml0dGVuIGZvciBWaW0gNi4xIGFuZCBlYXJsaWVyLgoKSG93ZXZlciwgd2hlbiBzb3VyY2luZyBhbiBleGlzdGluZyBzY3JpcHQgdGhhdCBkb2VzIG5vdCB1c2UgZXhjZXB0aW9uIGhhbmRsaW5nCmNvbW1hbmRzIChvciB3aGVuIGNhbGxpbmcgb25lIG9mIGl0cyBmdW5jdGlvbnMpIGZyb20gaW5zaWRlIGFuIGFjdGl2ZSB0cnkKY29uZGl0aW9uYWwgb2YgYSBuZXcgc2NyaXB0LCB5b3UgbWlnaHQgY2hhbmdlIHRoZSBjb250cm9sIGZsb3cgb2YgdGhlIGV4aXN0aW5nCnNjcmlwdCBvbiBlcnJvci4gIFlvdSBnZXQgdGhlIGltbWVkaWF0ZSBhYm9ydGlvbiBvbiBlcnJvciBhbmQgY2FuIGNhdGNoIHRoZQplcnJvciBpbiB0aGUgbmV3IHNjcmlwdC4gIElmIGhvd2V2ZXIgdGhlIHNvdXJjZWQgc2NyaXB0IHN1cHByZXNzZXMgZXJyb3IKbWVzc2FnZXMgYnkgdXNpbmcgdGhlICI6c2lsZW50ISIgY29tbWFuZCAoY2hlY2tpbmcgZm9yIGVycm9ycyBieSB0ZXN0aW5nCnx2OmVycm1zZ3wgaWYgYXBwcm9wcmlhdGUpLCBpdHMgZXhlY3V0aW9uIHBhdGggaXMgbm90IGNoYW5nZWQuCVRoZSBlcnJvciBpcwpub3QgY29udmVydGVkIHRvIGFuIGV4Y2VwdGlvbi4JKFNlZSB8OnNpbGVudHwuKSAgU28gdGhlIG9ubHkgcmVtYWluaW5nIGNhdXNlCndoZXJlIHRoaXMgaGFwcGVucyBpcyBmb3Igc2NyaXB0cyB0aGF0IGRvbid0IGNhcmUgYWJvdXQgZXJyb3JzIGFuZCBwcm9kdWNlCmVycm9yIG1lc3NhZ2VzLiAgWW91IHByb2JhYmx5IHdvbid0IHdhbnQgdG8gdXNlIHN1Y2ggY29kZSBmcm9tIHlvdXIgbmV3CnNjcmlwdHMuCgoJCQkJCQkJKmV4Y2VwdC1zeW50YXgtZXJyKgpTeW50YXggZXJyb3JzIGluIHRoZSBleGNlcHRpb24gaGFuZGxpbmcgY29tbWFuZHMgYXJlIG5ldmVyIGNhdWdodCBieSBhbnkgb2YKdGhlICI6Y2F0Y2giIGNvbW1hbmRzIG9mIHRoZSB0cnkgY29uZGl0aW9uYWwgdGhleSBiZWxvbmcgdG8uICBJdHMgZmluYWxseQpjbGF1c2VzLCBob3dldmVyLCBpcyBleGVjdXRlZC4KICAgRXhhbXBsZTogPgoKCTp0cnkKCTogIHRyeQoJOiAgICB0aHJvdyA0NzExCgk6ICBjYXRjaCAvXCgvCgk6ICAgIGVjaG8gImluIGNhdGNoIHdpdGggc3ludGF4IGVycm9yIgoJOiAgY2F0Y2gKCTogICAgZWNobyAiaW5uZXIgY2F0Y2gtYWxsIgoJOiAgZmluYWxseQoJOiAgICBlY2hvICJpbm5lciBmaW5hbGx5IgoJOiAgZW5kdHJ5Cgk6Y2F0Y2gKCTogIGVjaG8gJ291dGVyIGNhdGNoLWFsbCBjYXVnaHQgIicgLiB2OmV4Y2VwdGlvbiAuICciJwoJOiAgZmluYWxseQoJOiAgICBlY2hvICJvdXRlciBmaW5hbGx5IgoJOmVuZHRyeQoKVGhpcyBkaXNwbGF5czogPgogICAgaW5uZXIgZmluYWxseQogICAgb3V0ZXIgY2F0Y2gtYWxsIGNhdWdodCAiVmltKGNhdGNoKTpFNTQ6IFVubWF0Y2hlZCBcKCIKICAgIG91dGVyIGZpbmFsbHkKVGhlIG9yaWdpbmFsIGV4Y2VwdGlvbiBpcyBkaXNjYXJkZWQgYW5kIGFuIGVycm9yIGV4Y2VwdGlvbiBpcyByYWlzZWQsIGluc3RlYWQuCgoJCQkJCQkJKmV4Y2VwdC1zaW5nbGUtbGluZSoKVGhlICI6dHJ5IiwgIjpjYXRjaCIsICI6ZmluYWxseSIsIGFuZCAiOmVuZHRyeSIgY29tbWFuZHMgY2FuIGJlIHB1dCBvbgphIHNpbmdsZSBsaW5lLCBidXQgdGhlbiBzeW50YXggZXJyb3JzIG1heSBtYWtlIGl0IGRpZmZpY3VsdCB0byByZWNvZ25pemUgdGhlCiJjYXRjaCIgbGluZSwgdGh1cyB5b3UgYmV0dGVyIGF2b2lkIHRoaXMuCiAgIEV4YW1wbGU6ID4KCTp0cnkgfCB1bmxldCEgZm9vICMgfCBjYXRjaCB8IGVuZHRyeQpyYWlzZXMgYW4gZXJyb3IgZXhjZXB0aW9uIGZvciB0aGUgdHJhaWxpbmcgY2hhcmFjdGVycyBhZnRlciB0aGUgIjp1bmxldCEiCmFyZ3VtZW50LCBidXQgZG9lcyBub3Qgc2VlIHRoZSAiOmNhdGNoIiBhbmQgIjplbmR0cnkiIGNvbW1hbmRzLCBzbyB0aGF0IHRoZQplcnJvciBleGNlcHRpb24gaXMgZGlzY2FyZGVkIGFuZCB0aGUgIkU0ODg6IFRyYWlsaW5nIGNoYXJhY3RlcnMiIG1lc3NhZ2UgZ2V0cwpkaXNwbGF5ZWQuCgoJCQkJCQkJKmV4Y2VwdC1zZXZlcmFsLWVycm9ycyoKV2hlbiBzZXZlcmFsIGVycm9ycyBhcHBlYXIgaW4gYSBzaW5nbGUgY29tbWFuZCwgdGhlIGZpcnN0IGVycm9yIG1lc3NhZ2UgaXMKdXN1YWxseSB0aGUgbW9zdCBzcGVjaWZpYyBvbmUgYW5kIHRoZXJlZm9yIGNvbnZlcnRlZCB0byB0aGUgZXJyb3IgZXhjZXB0aW9uLgogICBFeGFtcGxlOiA+CgllY2hvIG5vdmFyCmNhdXNlcyA+CglFMTIxOiBVbmRlZmluZWQgdmFyaWFibGU6IG5vdmFyCglFMTU6IEludmFsaWQgZXhwcmVzc2lvbjogbm92YXIKVGhlIHZhbHVlIG9mIHRoZSBlcnJvciBleGNlcHRpb24gaW5zaWRlIHRyeSBjb25kaXRpb25hbHMgaXM6ID4KCVZpbShlY2hvKTpFMTIxOiBVbmRlZmluZWQgdmFyaWFibGU6IG5vdmFyCjwJCQkJCQkJKmV4Y2VwdC1zeW50YXgtZXJyb3IqCkJ1dCB3aGVuIGEgc3ludGF4IGVycm9yIGlzIGRldGVjdGVkIGFmdGVyIGEgbm9ybWFsIGVycm9yIGluIHRoZSBzYW1lIGNvbW1hbmQsCnRoZSBzeW50YXggZXJyb3IgaXMgdXNlZCBmb3IgdGhlIGV4Y2VwdGlvbiBiZWluZyB0aHJvd24uCiAgIEV4YW1wbGU6ID4KCXVubGV0IG5vdmFyICMKY2F1c2VzID4KCUUxMDg6IE5vIHN1Y2ggdmFyaWFibGU6ICJub3ZhciIKCUU0ODg6IFRyYWlsaW5nIGNoYXJhY3RlcnMKVGhlIHZhbHVlIG9mIHRoZSBlcnJvciBleGNlcHRpb24gaW5zaWRlIHRyeSBjb25kaXRpb25hbHMgaXM6ID4KCVZpbSh1bmxldCk6RTQ4ODogVHJhaWxpbmcgY2hhcmFjdGVycwpUaGlzIGlzIGRvbmUgYmVjYXVzZSB0aGUgc3ludGF4IGVycm9yIG1pZ2h0IGNoYW5nZSB0aGUgZXhlY3V0aW9uIHBhdGggaW4gYSB3YXkKbm90IGludGVuZGVkIGJ5IHRoZSB1c2VyLiAgRXhhbXBsZTogPgoJdHJ5CgkgICAgdHJ5IHwgdW5sZXQgbm92YXIgIyB8IGNhdGNoIHwgZWNobyB2OmV4Y2VwdGlvbiB8IGVuZHRyeQoJY2F0Y2ggLy4qLwoJICAgIGVjaG8gIm91dGVyIGNhdGNoOiIgdjpleGNlcHRpb24KCWVuZHRyeQpUaGlzIGRpc3BsYXlzICJvdXRlciBjYXRjaDogVmltKHVubGV0KTpFNDg4OiBUcmFpbGluZyBjaGFyYWN0ZXJzIiwgYW5kIHRoZW4KYSAiRTYwMDogTWlzc2luZyA6ZW5kdHJ5IiBlcnJvciBtZXNzYWdlIGlzIGdpdmVuLCBzZWUgfGV4Y2VwdC1zaW5nbGUtbGluZXwuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KOS4gRXhhbXBsZXMJCQkJCQkqZXZhbC1leGFtcGxlcyoKClByaW50aW5nIGluIEJpbmFyeSB+Cj4KICA6IiBUaGUgZnVuY3Rpb24gTnIyQmluKCkgcmV0dXJucyB0aGUgYmluYXJ5IHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiBhIG51bWJlci4KICA6ZnVuYyBOcjJCaW4obnIpCiAgOiAgbGV0IG4gPSBhOm5yCiAgOiAgbGV0IHIgPSAiIgogIDogIHdoaWxlIG4KICA6ICAgIGxldCByID0gJzAxJ1tuICUgMl0gLiByCiAgOiAgICBsZXQgbiA9IG4gLyAyCiAgOiAgZW5kd2hpbGUKICA6ICByZXR1cm4gcgogIDplbmRmdW5jCgogIDoiIFRoZSBmdW5jdGlvbiBTdHJpbmcyQmluKCkgY29udmVydHMgZWFjaCBjaGFyYWN0ZXIgaW4gYSBzdHJpbmcgdG8gYQogIDoiIGJpbmFyeSBzdHJpbmcsIHNlcGFyYXRlZCB3aXRoIGRhc2hlcy4KICA6ZnVuYyBTdHJpbmcyQmluKHN0cikKICA6ICBsZXQgb3V0ID0gJycKICA6ICBmb3IgaXggaW4gcmFuZ2Uoc3RybGVuKGE6c3RyKSkKICA6ICAgIGxldCBvdXQgPSBvdXQgLiAnLScgLiBOcjJCaW4oY2hhcjJucihhOnN0cltpeF0pKQogIDogIGVuZGZvcgogIDogIHJldHVybiBvdXRbMTpdCiAgOmVuZGZ1bmMKCkV4YW1wbGUgb2YgaXRzIHVzZTogPgogIDplY2hvIE5yMkJpbigzMikKcmVzdWx0OiAiMTAwMDAwIiA+CiAgOmVjaG8gU3RyaW5nMkJpbigiMzIiKQpyZXN1bHQ6ICIxMTAwMTEtMTEwMDEwIgoKClNvcnRpbmcgbGluZXMgfgoKVGhpcyBleGFtcGxlIHNvcnRzIGxpbmVzIHdpdGggYSBzcGVjaWZpYyBjb21wYXJlIGZ1bmN0aW9uLiA+CgogIDpmdW5jIFNvcnRCdWZmZXIoKQogIDogIGxldCBsaW5lcyA9IGdldGxpbmUoMSwgJyQnKQogIDogIGNhbGwgc29ydChsaW5lcywgZnVuY3Rpb24oIlN0cmNtcCIpKQogIDogIGNhbGwgc2V0bGluZSgxLCBsaW5lcykKICA6ZW5kZnVuY3Rpb24KCkFzIGEgb25lLWxpbmVyOiA+CiAgOmNhbGwgc2V0bGluZSgxLCBzb3J0KGdldGxpbmUoMSwgJyQnKSwgZnVuY3Rpb24oIlN0cmNtcCIpKSkKCgpzY2FuZigpIHJlcGxhY2VtZW50IH4KCQkJCQkJCSpzc2NhbmYqClRoZXJlIGlzIG5vIHNzY2FuZigpIGZ1bmN0aW9uIGluIFZpbS4gIElmIHlvdSBuZWVkIHRvIGV4dHJhY3QgcGFydHMgZnJvbSBhCmxpbmUsIHlvdSBjYW4gdXNlIG1hdGNoc3RyKCkgYW5kIHN1YnN0aXR1dGUoKSB0byBkbyBpdC4gIFRoaXMgZXhhbXBsZSBzaG93cwpob3cgdG8gZ2V0IHRoZSBmaWxlIG5hbWUsIGxpbmUgbnVtYmVyIGFuZCBjb2x1bW4gbnVtYmVyIG91dCBvZiBhIGxpbmUgbGlrZQoiZm9vYmFyLnR4dCwgMTIzLCA0NSIuID4KICAgOiIgU2V0IHVwIHRoZSBtYXRjaCBiaXQKICAgOmxldCBteD0nXChcZlwrXCksXHMqXChcZFwrXCksXHMqXChcZFwrXCknCiAgIDoiZ2V0IHRoZSBwYXJ0IG1hdGNoaW5nIHRoZSB3aG9sZSBleHByZXNzaW9uCiAgIDpsZXQgbCA9IG1hdGNoc3RyKGxpbmUsIG14KQogICA6ImdldCBlYWNoIGl0ZW0gb3V0IG9mIHRoZSBtYXRjaAogICA6bGV0IGZpbGUgPSBzdWJzdGl0dXRlKGwsIG14LCAnXDEnLCAnJykKICAgOmxldCBsbnVtID0gc3Vic3RpdHV0ZShsLCBteCwgJ1wyJywgJycpCiAgIDpsZXQgY29sID0gc3Vic3RpdHV0ZShsLCBteCwgJ1wzJywgJycpCgpUaGUgaW5wdXQgaXMgaW4gdGhlIHZhcmlhYmxlICJsaW5lIiwgdGhlIHJlc3VsdHMgaW4gdGhlIHZhcmlhYmxlcyAiZmlsZSIsCiJsbnVtIiBhbmQgImNvbCIuIChpZGVhIGZyb20gTWljaGFlbCBHZWRkZXMpCgoKZ2V0dGluZyB0aGUgc2NyaXB0bmFtZXMgaW4gYSBEaWN0aW9uYXJ5IH4KCQkJCQkJKnNjcmlwdG5hbWVzLWRpY3Rpb25hcnkqClRoZSB8OnNjcmlwdG5hbWVzfCBjb21tYW5kIGNhbiBiZSB1c2VkIHRvIGdldCBhIGxpc3Qgb2YgYWxsIHNjcmlwdCBmaWxlcyB0aGF0CmhhdmUgYmVlbiBzb3VyY2VkLiAgVGhlcmUgaXMgbm8gZXF1aXZhbGVudCBmdW5jdGlvbiBvciB2YXJpYWJsZSBmb3IgdGhpcwooYmVjYXVzZSBpdCdzIHJhcmVseSBuZWVkZWQpLiAgSW4gY2FzZSB5b3UgbmVlZCB0byBtYW5pcHVsYXRlIHRoZSBsaXN0IHRoaXMKY29kZSBjYW4gYmUgdXNlZDogPgogICAgIiBHZXQgdGhlIG91dHB1dCBvZiAiOnNjcmlwdG5hbWVzIiBpbiB0aGUgc2NyaXB0bmFtZXNfb3V0cHV0IHZhcmlhYmxlLgogICAgbGV0IHNjcmlwdG5hbWVzX291dHB1dCA9ICcnCiAgICByZWRpciA9PiBzY3JpcHRuYW1lc19vdXRwdXQKICAgIHNpbGVudCBzY3JpcHRuYW1lcwogICAgcmVkaXIgRU5ECiAgICAKICAgICIgU3BsaXQgdGhlIG91dHB1dCBpbnRvIGxpbmVzIGFuZCBwYXJzZSBlYWNoIGxpbmUuCUFkZCBhbiBlbnRyeSB0byB0aGUKICAgICIgInNjcmlwdHMiIGRpY3Rpb25hcnkuCiAgICBsZXQgc2NyaXB0cyA9IHt9CiAgICBmb3IgbGluZSBpbiBzcGxpdChzY3JpcHRuYW1lc19vdXRwdXQsICJcbiIpCiAgICAgICIgT25seSBkbyBub24tYmxhbmsgbGluZXMuCiAgICAgIGlmIGxpbmUgPX4gJ1xTJwoJIiBHZXQgdGhlIGZpcnN0IG51bWJlciBpbiB0aGUgbGluZS4KCWxldCBuciA9IG1hdGNoc3RyKGxpbmUsICdcZFwrJykKCSIgR2V0IHRoZSBmaWxlIG5hbWUsIHJlbW92ZSB0aGUgc2NyaXB0IG51bWJlciAiIDEyMzogIi4KCWxldCBuYW1lID0gc3Vic3RpdHV0ZShsaW5lLCAnLlwrOlxzKicsICcnLCAnJykKCSIgQWRkIGFuIGl0ZW0gdG8gdGhlIERpY3Rpb25hcnkKCWxldCBzY3JpcHRzW25yXSA9IG5hbWUKICAgICAgZW5kaWYKICAgIGVuZGZvcgogICAgdW5sZXQgc2NyaXB0bmFtZXNfb3V0cHV0Cgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMTAuIE5vICtldmFsIGZlYXR1cmUJCQkJKm5vLWV2YWwtZmVhdHVyZSoKCldoZW4gdGhlIHwrZXZhbHwgZmVhdHVyZSB3YXMgZGlzYWJsZWQgYXQgY29tcGlsZSB0aW1lLCBub25lIG9mIHRoZSBleHByZXNzaW9uCmV2YWx1YXRpb24gY29tbWFuZHMgYXJlIGF2YWlsYWJsZS4gIFRvIHByZXZlbnQgdGhpcyBmcm9tIGNhdXNpbmcgVmltIHNjcmlwdHMKdG8gZ2VuZXJhdGUgYWxsIGtpbmRzIG9mIGVycm9ycywgdGhlICI6aWYiIGFuZCAiOmVuZGlmIiBjb21tYW5kcyBhcmUgc3RpbGwKcmVjb2duaXplZCwgdGhvdWdoIHRoZSBhcmd1bWVudCBvZiB0aGUgIjppZiIgYW5kIGV2ZXJ5dGhpbmcgYmV0d2VlbiB0aGUgIjppZiIKYW5kIHRoZSBtYXRjaGluZyAiOmVuZGlmIiBpcyBpZ25vcmVkLiAgTmVzdGluZyBvZiAiOmlmIiBibG9ja3MgaXMgYWxsb3dlZCwgYnV0Cm9ubHkgaWYgdGhlIGNvbW1hbmRzIGFyZSBhdCB0aGUgc3RhcnQgb2YgdGhlIGxpbmUuICBUaGUgIjplbHNlIiBjb21tYW5kIGlzIG5vdApyZWNvZ25pemVkLgoKRXhhbXBsZSBvZiBob3cgdG8gYXZvaWQgZXhlY3V0aW5nIGNvbW1hbmRzIHdoZW4gdGhlIHwrZXZhbHwgZmVhdHVyZSBpcwptaXNzaW5nOiA+CgoJOmlmIDEKCTogIGVjaG8gIkV4cHJlc3Npb24gZXZhbHVhdGlvbiBpcyBjb21waWxlZCBpbiIKCTplbHNlCgk6ICBlY2hvICJZb3Ugd2lsbCBfbmV2ZXJfIHNlZSB0aGlzIG1lc3NhZ2UiCgk6ZW5kaWYKCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoxMS4gVGhlIHNhbmRib3gJCQkJCSpldmFsLXNhbmRib3gqICpzYW5kYm94KiAqRTQ4KgoKVGhlICdmb2xkZXhwcicsICdmb3JtYXRleHByJywgJ2luY2x1ZGVleHByJywgJ2luZGVudGV4cHInLCAnc3RhdHVzbGluZScgYW5kCidmb2xkdGV4dCcgb3B0aW9ucyBtYXkgYmUgZXZhbHVhdGVkIGluIGEgc2FuZGJveC4gIFRoaXMgbWVhbnMgdGhhdCB5b3UgYXJlCnByb3RlY3RlZCBmcm9tIHRoZXNlIGV4cHJlc3Npb25zIGhhdmluZyBuYXN0eSBzaWRlIGVmZmVjdHMuICBUaGlzIGdpdmVzIHNvbWUKc2FmZXR5IGZvciB3aGVuIHRoZXNlIG9wdGlvbnMgYXJlIHNldCBmcm9tIGEgbW9kZWxpbmUuICBJdCBpcyBhbHNvIHVzZWQgd2hlbgp0aGUgY29tbWFuZCBmcm9tIGEgdGFncyBmaWxlIGlzIGV4ZWN1dGVkIGFuZCBmb3IgQ1RSTC1SID0gaW4gdGhlIGNvbW1hbmQgbGluZS4KVGhlIHNhbmRib3ggaXMgYWxzbyB1c2VkIGZvciB0aGUgfDpzYW5kYm94fCBjb21tYW5kLgoKVGhlc2UgaXRlbXMgYXJlIG5vdCBhbGxvd2VkIGluIHRoZSBzYW5kYm94OgoJLSBjaGFuZ2luZyB0aGUgYnVmZmVyIHRleHQKCS0gZGVmaW5pbmcgb3IgY2hhbmdpbmcgbWFwcGluZywgYXV0b2NvbW1hbmRzLCBmdW5jdGlvbnMsIHVzZXIgY29tbWFuZHMKCS0gc2V0dGluZyBjZXJ0YWluIG9wdGlvbnMgKHNlZSB8b3B0aW9uLXN1bW1hcnl8KQoJLSBzZXR0aW5nIGNlcnRhaW4gdjogdmFyaWFibGVzIChzZWUgfHY6dmFyfCkgICpFNzk0KgoJLSBleGVjdXRpbmcgYSBzaGVsbCBjb21tYW5kCgktIHJlYWRpbmcgb3Igd3JpdGluZyBhIGZpbGUKCS0ganVtcGluZyB0byBhbm90aGVyIGJ1ZmZlciBvciBlZGl0aW5nIGEgZmlsZQoJLSBleGVjdXRpbmcgUHl0aG9uLCBQZXJsLCBldGMuIGNvbW1hbmRzClRoaXMgaXMgbm90IGd1YXJhbnRlZWQgMTAwJSBzZWN1cmUsIGJ1dCBpdCBzaG91bGQgYmxvY2sgbW9zdCBhdHRhY2tzLgoKCQkJCQkJCSo6c2FuKiAqOnNhbmRib3gqCjpzYW5bZGJveF0ge2NtZH0JRXhlY3V0ZSB7Y21kfSBpbiB0aGUgc2FuZGJveC4gIFVzZWZ1bCB0byBldmFsdWF0ZSBhbgoJCQlvcHRpb24gdGhhdCBtYXkgaGF2ZSBiZWVuIHNldCBmcm9tIGEgbW9kZWxpbmUsIGUuZy4KCQkJJ2ZvbGRleHByJy4KCgkJCQkJCQkqc2FuZGJveC1vcHRpb24qCkEgZmV3IG9wdGlvbnMgY29udGFpbiBhbiBleHByZXNzaW9uLiAgV2hlbiB0aGlzIGV4cHJlc3Npb24gaXMgZXZhbHVhdGVkIGl0IG1heQpoYXZlIHRvIGJlIGRvbmUgaW4gdGhlIHNhbmRib3ggdG8gYXZvaWQgYSBzZWN1cml0eSByaXNrLiAgQnV0IHRoZSBzYW5kYm94IGlzCnJlc3RyaWN0aXZlLCB0aHVzIHRoaXMgb25seSBoYXBwZW5zIHdoZW4gdGhlIG9wdGlvbiB3YXMgc2V0IGZyb20gYW4gaW5zZWN1cmUKbG9jYXRpb24uICBJbnNlY3VyZSBpbiB0aGlzIGNvbnRleHQgYXJlOgotIHNvdXJjaW5nIGEgLnZpbXJjIG9yIC5leHJjIGluIHRoZSBjdXJyZW50IGRpcmVjdG9yeQotIHdoaWxlIGV4ZWN1dGluZyBpbiB0aGUgc2FuZGJveAotIHZhbHVlIGNvbWluZyBmcm9tIGEgbW9kZWxpbmUKCk5vdGUgdGhhdCB3aGVuIGluIHRoZSBzYW5kYm94IGFuZCBzYXZpbmcgYW4gb3B0aW9uIHZhbHVlIGFuZCByZXN0b3JpbmcgaXQsIHRoZQpvcHRpb24gd2lsbCBzdGlsbCBiZSBtYXJrZWQgYXMgaXQgd2FzIHNldCBpbiB0aGUgc2FuZGJveC4KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoxMi4gVGV4dGxvY2sJCQkJCQkJKnRleHRsb2NrKgoKSW4gYSBmZXcgc2l0dWF0aW9ucyBpdCBpcyBub3QgYWxsb3dlZCB0byBjaGFuZ2UgdGhlIHRleHQgaW4gdGhlIGJ1ZmZlciwganVtcAp0byBhbm90aGVyIHdpbmRvdyBhbmQgc29tZSBvdGhlciB0aGluZ3MgdGhhdCBtaWdodCBjb25mdXNlIG9yIGJyZWFrIHdoYXQgVmltCmlzIGN1cnJlbnRseSBkb2luZy4gIFRoaXMgbW9zdGx5IGFwcGxpZXMgdG8gdGhpbmdzIHRoYXQgaGFwcGVuIHdoZW4gVmltIGlzCmFjdHVhbGx5IGRvaW5nIHNvbWV0aGluZyBlbHNlLglGb3IgZXhhbXBsZSwgZXZhbHVhdGluZyB0aGUgJ2JhbGxvb25leHByJyBtYXkKaGFwcGVuIGFueSBtb21lbnQgdGhlIG1vdXNlIGN1cnNvciBpcyByZXN0aW5nIGF0IHNvbWUgcG9zaXRpb24uCgpUaGlzIGlzIG5vdCBhbGxvd2VkIHdoZW4gdGhlIHRleHRsb2NrIGlzIGFjdGl2ZToKCS0gY2hhbmdpbmcgdGhlIGJ1ZmZlciB0ZXh0CgktIGp1bXBpbmcgdG8gYW5vdGhlciBidWZmZXIgb3Igd2luZG93CgktIGVkaXRpbmcgYW5vdGhlciBmaWxlCgktIGNsb3NpbmcgYSB3aW5kb3cgb3IgcXVpdHRpbmcgVmltCgktIGV0Yy4KCgogdmltOnR3PTc4OnRzPTg6ZnQ9aGVscDpub3JsOgo=