KmV2YWwudHh0KglGb3IgVmltIHZlcnNpb24gNy40LiAgTGFzdCBjaGFuZ2U6IDIwMTYgTWF5IDIwCgoKCQkgIFZJTSBSRUZFUkVOQ0UgTUFOVUFMCSAgYnkgQnJhbSBNb29sZW5hYXIKCgpFeHByZXNzaW9uIGV2YWx1YXRpb24JCQkqZXhwcmVzc2lvbiogKmV4cHIqICpFMTUqICpldmFsKgoKVXNpbmcgZXhwcmVzc2lvbnMgaXMgaW50cm9kdWNlZCBpbiBjaGFwdGVyIDQxIG9mIHRoZSB1c2VyIG1hbnVhbCB8dXNyXzQxLnR4dHwuCgpOb3RlOiBFeHByZXNzaW9uIGV2YWx1YXRpb24gY2FuIGJlIGRpc2FibGVkIGF0IGNvbXBpbGUgdGltZS4gIElmIHRoaXMgaGFzIGJlZW4KZG9uZSwgdGhlIGZlYXR1cmVzIGluIHRoaXMgZG9jdW1lbnQgYXJlIG5vdCBhdmFpbGFibGUuCVNlZSB8K2V2YWx8IGFuZAp8bm8tZXZhbC1mZWF0dXJlfC4KCjEuICBWYXJpYWJsZXMJCQl8dmFyaWFibGVzfAogICAgMS4xIFZhcmlhYmxlIHR5cGVzCiAgICAxLjIgRnVuY3Rpb24gcmVmZXJlbmNlcwkJfEZ1bmNyZWZ8CiAgICAxLjMgTGlzdHMJCQkJfExpc3RzfAogICAgMS40IERpY3Rpb25hcmllcwkJCXxEaWN0aW9uYXJpZXN8CiAgICAxLjUgTW9yZSBhYm91dCB2YXJpYWJsZXMJCXxtb3JlLXZhcmlhYmxlc3wKMi4gIEV4cHJlc3Npb24gc3ludGF4CQl8ZXhwcmVzc2lvbi1zeW50YXh8CjMuICBJbnRlcm5hbCB2YXJpYWJsZQkJfGludGVybmFsLXZhcmlhYmxlc3wKNC4gIEJ1aWx0aW4gRnVuY3Rpb25zCQl8ZnVuY3Rpb25zfAo1LiAgRGVmaW5pbmcgZnVuY3Rpb25zCQl8dXNlci1mdW5jdGlvbnN8CjYuICBDdXJseSBicmFjZXMgbmFtZXMJCXxjdXJseS1icmFjZXMtbmFtZXN8CjcuICBDb21tYW5kcwkJCXxleHByZXNzaW9uLWNvbW1hbmRzfAo4LiAgRXhjZXB0aW9uIGhhbmRsaW5nCQl8ZXhjZXB0aW9uLWhhbmRsaW5nfAo5LiAgRXhhbXBsZXMJCQl8ZXZhbC1leGFtcGxlc3wKMTAuIE5vICtldmFsIGZlYXR1cmUJCXxuby1ldmFsLWZlYXR1cmV8CjExLiBUaGUgc2FuZGJveAkJCXxldmFsLXNhbmRib3h8CjEyLiBUZXh0bG9jawkJCXx0ZXh0bG9ja3wKCntWaSBkb2VzIG5vdCBoYXZlIGFueSBvZiB0aGVzZSBjb21tYW5kc30KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoxLiBWYXJpYWJsZXMJCQkJCQkqdmFyaWFibGVzKgoKMS4xIFZhcmlhYmxlIHR5cGVzIH4KCQkJCQkJCSpFNzEyKgpUaGVyZSBhcmUgbmluZSB0eXBlcyBvZiB2YXJpYWJsZXM6CgpOdW1iZXIJCUEgMzIgb3IgNjQgYml0IHNpZ25lZCBudW1iZXIuICB8ZXhwci1udW1iZXJ8ICpOdW1iZXIqCgkJRXhhbXBsZXM6ICAtMTIzICAweDEwICAwMTc3CgpGbG9hdAkJQSBmbG9hdGluZyBwb2ludCBudW1iZXIuIHxmbG9hdGluZy1wb2ludC1mb3JtYXR8ICpGbG9hdCoKCQl7b25seSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJRXhhbXBsZXM6IDEyMy40NTYgIDEuMTVlLTYgIC0xLjFlMwoKCQkJCQkJCSpFOTI4KgpTdHJpbmcJCUEgTlVMIHRlcm1pbmF0ZWQgc3RyaW5nIG9mIDgtYml0IHVuc2lnbmVkIGNoYXJhY3RlcnMgKGJ5dGVzKS4KCQl8ZXhwci1zdHJpbmd8IEV4YW1wbGVzOiAiYWJcdHh4XCItLSIgICd4LXonJ2EsYycKCkxpc3QJCUFuIG9yZGVyZWQgc2VxdWVuY2Ugb2YgaXRlbXMgfExpc3R8LgoJCUV4YW1wbGU6IFsxLCAyLCBbJ2EnLCAnYiddXQoKRGljdGlvbmFyeQlBbiBhc3NvY2lhdGl2ZSwgdW5vcmRlcmVkIGFycmF5OiBFYWNoIGVudHJ5IGhhcyBhIGtleSBhbmQgYQoJCXZhbHVlLiB8RGljdGlvbmFyeXwKCQlFeGFtcGxlOiB7J2JsdWUnOiAiIzAwMDBmZiIsICdyZWQnOiAiI2ZmMDAwMCJ9CgpGdW5jcmVmCQlBIHJlZmVyZW5jZSB0byBhIGZ1bmN0aW9uIHxGdW5jcmVmfC4KCQlFeGFtcGxlOiBmdW5jdGlvbigic3RybGVuIikKClNwZWNpYWwJCXx2OmZhbHNlfCwgfHY6dHJ1ZXwsIHx2Om5vbmV8IGFuZCB8djpudWxsfC4gICpTcGVjaWFsKgoKSm9iCQlVc2VkIGZvciBhIGpvYiwgc2VlIHxqb2Jfc3RhcnQoKXwuICpKb2IqICpKb2JzKgoKQ2hhbm5lbAkJVXNlZCBmb3IgYSBjaGFubmVsLCBzZWUgfGNoX29wZW4oKXwuICpDaGFubmVsKiAqQ2hhbm5lbHMqCgpUaGUgTnVtYmVyIGFuZCBTdHJpbmcgdHlwZXMgYXJlIGNvbnZlcnRlZCBhdXRvbWF0aWNhbGx5LCBkZXBlbmRpbmcgb24gaG93IHRoZXkKYXJlIHVzZWQuCgpDb252ZXJzaW9uIGZyb20gYSBOdW1iZXIgdG8gYSBTdHJpbmcgaXMgYnkgbWFraW5nIHRoZSBBU0NJSSByZXByZXNlbnRhdGlvbiBvZgp0aGUgTnVtYmVyLiAgRXhhbXBsZXM6CglOdW1iZXIgMTIzCS0tPglTdHJpbmcgIjEyMyIgfgoJTnVtYmVyIDAJLS0+CVN0cmluZyAiMCIgfgoJTnVtYmVyIC0xCS0tPglTdHJpbmcgIi0xIiB+CgkJCQkJCQkqb2N0YWwqCkNvbnZlcnNpb24gZnJvbSBhIFN0cmluZyB0byBhIE51bWJlciBpcyBkb25lIGJ5IGNvbnZlcnRpbmcgdGhlIGZpcnN0IGRpZ2l0cyB0bwphIG51bWJlci4gIEhleGFkZWNpbWFsICIweGY5IiwgT2N0YWwgIjAxNyIsIGFuZCBCaW5hcnkgIjBiMTAiIG51bWJlcnMgYXJlCnJlY29nbml6ZWQuICBJZiB0aGUgU3RyaW5nIGRvZXNuJ3Qgc3RhcnQgd2l0aCBkaWdpdHMsIHRoZSByZXN1bHQgaXMgemVyby4KRXhhbXBsZXM6CglTdHJpbmcgIjQ1NiIJLS0+CU51bWJlciA0NTYgfgoJU3RyaW5nICI2YmFyIgktLT4JTnVtYmVyIDYgfgoJU3RyaW5nICJmb28iCS0tPglOdW1iZXIgMCB+CglTdHJpbmcgIjB4ZjEiCS0tPglOdW1iZXIgMjQxIH4KCVN0cmluZyAiMDEwMCIJLS0+CU51bWJlciA2NCB+CglTdHJpbmcgIjBiMTAxIgktLT4JTnVtYmVyIDUgfgoJU3RyaW5nICItOCIJLS0+CU51bWJlciAtOCB+CglTdHJpbmcgIis4IgktLT4JTnVtYmVyIDAgfgoKVG8gZm9yY2UgY29udmVyc2lvbiBmcm9tIFN0cmluZyB0byBOdW1iZXIsIGFkZCB6ZXJvIHRvIGl0OiA+Cgk6ZWNobyAiMDEwMCIgKyAwCjwJNjQgfgoKVG8gYXZvaWQgYSBsZWFkaW5nIHplcm8gdG8gY2F1c2Ugb2N0YWwgY29udmVyc2lvbiwgb3IgZm9yIHVzaW5nIGEgZGlmZmVyZW50CmJhc2UsIHVzZSB8c3RyMm5yKCl8LgoKRm9yIGJvb2xlYW4gb3BlcmF0b3JzIE51bWJlcnMgYXJlIHVzZWQuICBaZXJvIGlzIEZBTFNFLCBub24temVybyBpcyBUUlVFLgoKTm90ZSB0aGF0IGluIHRoZSBjb21tYW5kID4KCTppZiAiZm9vIgoiZm9vIiBpcyBjb252ZXJ0ZWQgdG8gMCwgd2hpY2ggbWVhbnMgRkFMU0UuICBUbyB0ZXN0IGZvciBhIG5vbi1lbXB0eSBzdHJpbmcsCnVzZSBlbXB0eSgpOiA+Cgk6aWYgIWVtcHR5KCJmb28iKQo8CgkJKkU3NDUqICpFNzI4KiAqRTcwMyogKkU3MjkqICpFNzMwKiAqRTczMSogKkU5MDgqICpFOTEwKiAqRTkxMyoKTGlzdCwgRGljdGlvbmFyeSwgRnVuY3JlZiBhbmQgSm9iIHR5cGVzIGFyZSBub3QgYXV0b21hdGljYWxseSBjb252ZXJ0ZWQuCgoJCQkJCQkJKkU4MDUqICpFODA2KiAqRTgwOCoKV2hlbiBtaXhpbmcgTnVtYmVyIGFuZCBGbG9hdCB0aGUgTnVtYmVyIGlzIGNvbnZlcnRlZCB0byBGbG9hdC4JT3RoZXJ3aXNlCnRoZXJlIGlzIG5vIGF1dG9tYXRpYyBjb252ZXJzaW9uIG9mIEZsb2F0LiAgWW91IGNhbiB1c2Ugc3RyMmZsb2F0KCkgZm9yIFN0cmluZwp0byBGbG9hdCwgcHJpbnRmKCkgZm9yIEZsb2F0IHRvIFN0cmluZyBhbmQgZmxvYXQybnIoKSBmb3IgRmxvYXQgdG8gTnVtYmVyLgoKCQkJKkU4OTEqICpFODkyKiAqRTg5MyogKkU4OTQqICpFOTA3KiAqRTkxMSogKkU5MTQqCldoZW4gZXhwZWN0aW5nIGEgRmxvYXQgYSBOdW1iZXIgY2FuIGFsc28gYmUgdXNlZCwgYnV0IG5vdGhpbmcgZWxzZS4KCgkJCQkJCSpuby10eXBlLWNoZWNraW5nKgpZb3Ugd2lsbCBub3QgZ2V0IGFuIGVycm9yIGlmIHlvdSB0cnkgdG8gY2hhbmdlIHRoZSB0eXBlIG9mIGEgdmFyaWFibGUuCgoKMS4yIEZ1bmN0aW9uIHJlZmVyZW5jZXMgfgoJCQkJCSpGdW5jcmVmKiAqRTY5NSogKkU3MTgqCkEgRnVuY3JlZiB2YXJpYWJsZSBpcyBvYnRhaW5lZCB3aXRoIHRoZSB8ZnVuY3Rpb24oKXwgZnVuY3Rpb24uCUl0IGNhbiBiZSB1c2VkCmluIGFuIGV4cHJlc3Npb24gaW4gdGhlIHBsYWNlIG9mIGEgZnVuY3Rpb24gbmFtZSwgYmVmb3JlIHRoZSBwYXJlbnRoZXNpcwphcm91bmQgdGhlIGFyZ3VtZW50cywgdG8gaW52b2tlIHRoZSBmdW5jdGlvbiBpdCByZWZlcnMgdG8uICBFeGFtcGxlOiA+CgoJOmxldCBGbiA9IGZ1bmN0aW9uKCJNeUZ1bmMiKQoJOmVjaG8gRm4oKQo8CQkJCQkJCSpFNzA0KiAqRTcwNSogKkU3MDcqCkEgRnVuY3JlZiB2YXJpYWJsZSBtdXN0IHN0YXJ0IHdpdGggYSBjYXBpdGFsLCAiczoiLCAidzoiLCAidDoiIG9yICJiOiIuICBZb3UKY2FuIHVzZSAiZzoiIGJ1dCB0aGUgZm9sbG93aW5nIG5hbWUgbXVzdCBzdGlsbCBzdGFydCB3aXRoIGEgY2FwaXRhbC4gIFlvdQpjYW5ub3QgaGF2ZSBib3RoIGEgRnVuY3JlZiB2YXJpYWJsZSBhbmQgYSBmdW5jdGlvbiB3aXRoIHRoZSBzYW1lIG5hbWUuCgpBIHNwZWNpYWwgY2FzZSBpcyBkZWZpbmluZyBhIGZ1bmN0aW9uIGFuZCBkaXJlY3RseSBhc3NpZ25pbmcgaXRzIEZ1bmNyZWYgdG8gYQpEaWN0aW9uYXJ5IGVudHJ5LiAgRXhhbXBsZTogPgoJOmZ1bmN0aW9uIGRpY3QuaW5pdCgpIGRpY3QKCTogICBsZXQgc2VsZi52YWwgPSAwCgk6ZW5kZnVuY3Rpb24KClRoZSBrZXkgb2YgdGhlIERpY3Rpb25hcnkgY2FuIHN0YXJ0IHdpdGggYSBsb3dlciBjYXNlIGxldHRlci4gIFRoZSBhY3R1YWwKZnVuY3Rpb24gbmFtZSBpcyBub3QgdXNlZCBoZXJlLiAgQWxzbyBzZWUgfG51bWJlcmVkLWZ1bmN0aW9ufC4KCkEgRnVuY3JlZiBjYW4gYWxzbyBiZSB1c2VkIHdpdGggdGhlIHw6Y2FsbHwgY29tbWFuZDogPgoJOmNhbGwgRm4oKQoJOmNhbGwgZGljdC5pbml0KCkKClRoZSBuYW1lIG9mIHRoZSByZWZlcmVuY2VkIGZ1bmN0aW9uIGNhbiBiZSBvYnRhaW5lZCB3aXRoIHxzdHJpbmcoKXwuID4KCTpsZXQgZnVuYyA9IHN0cmluZyhGbikKCllvdSBjYW4gdXNlIHxjYWxsKCl8IHRvIGludm9rZSBhIEZ1bmNyZWYgYW5kIHVzZSBhIGxpc3QgdmFyaWFibGUgZm9yIHRoZQphcmd1bWVudHM6ID4KCTpsZXQgciA9IGNhbGwoRm4sIG15bGlzdCkKCgoxLjMgTGlzdHMgfgoJCQkJCQkqbGlzdCogKkxpc3QqICpMaXN0cyogKkU2ODYqCkEgTGlzdCBpcyBhbiBvcmRlcmVkIHNlcXVlbmNlIG9mIGl0ZW1zLiAgQW4gaXRlbSBjYW4gYmUgb2YgYW55IHR5cGUuICBJdGVtcwpjYW4gYmUgYWNjZXNzZWQgYnkgdGhlaXIgaW5kZXggbnVtYmVyLglJdGVtcyBjYW4gYmUgYWRkZWQgYW5kIHJlbW92ZWQgYXQgYW55CnBvc2l0aW9uIGluIHRoZSBzZXF1ZW5jZS4KCgpMaXN0IGNyZWF0aW9uIH4KCQkJCQkJCSpFNjk2KiAqRTY5NyoKQSBMaXN0IGlzIGNyZWF0ZWQgd2l0aCBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIGl0ZW1zIGluIHNxdWFyZSBicmFja2V0cy4KRXhhbXBsZXM6ID4KCTpsZXQgbXlsaXN0ID0gWzEsIHR3bywgMywgImZvdXIiXQoJOmxldCBlbXB0eWxpc3QgPSBbXQoKQW4gaXRlbSBjYW4gYmUgYW55IGV4cHJlc3Npb24uCVVzaW5nIGEgTGlzdCBmb3IgYW4gaXRlbSBjcmVhdGVzIGEKTGlzdCBvZiBMaXN0czogPgoJOmxldCBuZXN0bGlzdCA9IFtbMTEsIDEyXSwgWzIxLCAyMl0sIFszMSwgMzJdXQoKQW4gZXh0cmEgY29tbWEgYWZ0ZXIgdGhlIGxhc3QgaXRlbSBpcyBpZ25vcmVkLgoKCkxpc3QgaW5kZXggfgoJCQkJCQkJKmxpc3QtaW5kZXgqICpFNjg0KgpBbiBpdGVtIGluIHRoZSBMaXN0IGNhbiBiZSBhY2Nlc3NlZCBieSBwdXR0aW5nIHRoZSBpbmRleCBpbiBzcXVhcmUgYnJhY2tldHMKYWZ0ZXIgdGhlIExpc3QuICBJbmRleGVzIGFyZSB6ZXJvLWJhc2VkLCB0aHVzIHRoZSBmaXJzdCBpdGVtIGhhcyBpbmRleCB6ZXJvLiA+Cgk6bGV0IGl0ZW0gPSBteWxpc3RbMF0JCSIgZ2V0IHRoZSBmaXJzdCBpdGVtOiAxCgk6bGV0IGl0ZW0gPSBteWxpc3RbMl0JCSIgZ2V0IHRoZSB0aGlyZCBpdGVtOiAzCgpXaGVuIHRoZSByZXN1bHRpbmcgaXRlbSBpcyBhIGxpc3QgdGhpcyBjYW4gYmUgcmVwZWF0ZWQ6ID4KCTpsZXQgaXRlbSA9IG5lc3RsaXN0WzBdWzFdCSIgZ2V0IHRoZSBmaXJzdCBsaXN0LCBzZWNvbmQgaXRlbTogMTIKPApBIG5lZ2F0aXZlIGluZGV4IGlzIGNvdW50ZWQgZnJvbSB0aGUgZW5kLiAgSW5kZXggLTEgcmVmZXJzIHRvIHRoZSBsYXN0IGl0ZW0gaW4KdGhlIExpc3QsIC0yIHRvIHRoZSBsYXN0IGJ1dCBvbmUgaXRlbSwgZXRjLiA+Cgk6bGV0IGxhc3QgPSBteWxpc3RbLTFdCQkiIGdldCB0aGUgbGFzdCBpdGVtOiAiZm91ciIKClRvIGF2b2lkIGFuIGVycm9yIGZvciBhbiBpbnZhbGlkIGluZGV4IHVzZSB0aGUgfGdldCgpfCBmdW5jdGlvbi4gIFdoZW4gYW4gaXRlbQppcyBub3QgYXZhaWxhYmxlIGl0IHJldHVybnMgemVybyBvciB0aGUgZGVmYXVsdCB2YWx1ZSB5b3Ugc3BlY2lmeTogPgoJOmVjaG8gZ2V0KG15bGlzdCwgaWR4KQoJOmVjaG8gZ2V0KG15bGlzdCwgaWR4LCAiTk9ORSIpCgoKTGlzdCBjb25jYXRlbmF0aW9uIH4KClR3byBsaXN0cyBjYW4gYmUgY29uY2F0ZW5hdGVkIHdpdGggdGhlICIrIiBvcGVyYXRvcjogPgoJOmxldCBsb25nbGlzdCA9IG15bGlzdCArIFs1LCA2XQoJOmxldCBteWxpc3QgKz0gWzcsIDhdCgpUbyBwcmVwZW5kIG9yIGFwcGVuZCBhbiBpdGVtIHR1cm4gdGhlIGl0ZW0gaW50byBhIGxpc3QgYnkgcHV0dGluZyBbXSBhcm91bmQKaXQuICBUbyBjaGFuZ2UgYSBsaXN0IGluLXBsYWNlIHNlZSB8bGlzdC1tb2RpZmljYXRpb258IGJlbG93LgoKClN1Ymxpc3QgfgoKQSBwYXJ0IG9mIHRoZSBMaXN0IGNhbiBiZSBvYnRhaW5lZCBieSBzcGVjaWZ5aW5nIHRoZSBmaXJzdCBhbmQgbGFzdCBpbmRleCwKc2VwYXJhdGVkIGJ5IGEgY29sb24gaW4gc3F1YXJlIGJyYWNrZXRzOiA+Cgk6bGV0IHNob3J0bGlzdCA9IG15bGlzdFsyOi0xXQkiIGdldCBMaXN0IFszLCAiZm91ciJdCgpPbWl0dGluZyB0aGUgZmlyc3QgaW5kZXggaXMgc2ltaWxhciB0byB6ZXJvLiAgT21pdHRpbmcgdGhlIGxhc3QgaW5kZXggaXMKc2ltaWxhciB0byAtMS4gPgoJOmxldCBlbmRsaXN0ID0gbXlsaXN0WzI6XQkiIGZyb20gaXRlbSAyIHRvIHRoZSBlbmQ6IFszLCAiZm91ciJdCgk6bGV0IHNob3J0bGlzdCA9IG15bGlzdFsyOjJdCSIgTGlzdCB3aXRoIG9uZSBpdGVtOiBbM10KCTpsZXQgb3RoZXJsaXN0ID0gbXlsaXN0WzpdCSIgbWFrZSBhIGNvcHkgb2YgdGhlIExpc3QKCklmIHRoZSBmaXJzdCBpbmRleCBpcyBiZXlvbmQgdGhlIGxhc3QgaXRlbSBvZiB0aGUgTGlzdCBvciB0aGUgc2Vjb25kIGl0ZW0gaXMKYmVmb3JlIHRoZSBmaXJzdCBpdGVtLCB0aGUgcmVzdWx0IGlzIGFuIGVtcHR5IGxpc3QuICBUaGVyZSBpcyBubyBlcnJvcgptZXNzYWdlLgoKSWYgdGhlIHNlY29uZCBpbmRleCBpcyBlcXVhbCB0byBvciBncmVhdGVyIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUgbGlzdCB0aGUKbGVuZ3RoIG1pbnVzIG9uZSBpcyB1c2VkOiA+Cgk6bGV0IG15bGlzdCA9IFswLCAxLCAyLCAzXQoJOmVjaG8gbXlsaXN0WzI6OF0JCSIgcmVzdWx0OiBbMiwgM10KCk5PVEU6IG15bGlzdFtzOmVdIG1lYW5zIHVzaW5nIHRoZSB2YXJpYWJsZSAiczplIiBhcyBpbmRleC4gIFdhdGNoIG91dCBmb3IKdXNpbmcgYSBzaW5nbGUgbGV0dGVyIHZhcmlhYmxlIGJlZm9yZSB0aGUgIjoiLglJbnNlcnQgYSBzcGFjZSB3aGVuIG5lZWRlZDoKbXlsaXN0W3MgOiBlXS4KCgpMaXN0IGlkZW50aXR5IH4KCQkJCQkJCSpsaXN0LWlkZW50aXR5KgpXaGVuIHZhcmlhYmxlICJhYSIgaXMgYSBsaXN0IGFuZCB5b3UgYXNzaWduIGl0IHRvIGFub3RoZXIgdmFyaWFibGUgImJiIiwgYm90aAp2YXJpYWJsZXMgcmVmZXIgdG8gdGhlIHNhbWUgbGlzdC4gIFRodXMgY2hhbmdpbmcgdGhlIGxpc3QgImFhIiB3aWxsIGFsc28KY2hhbmdlICJiYiI6ID4KCTpsZXQgYWEgPSBbMSwgMiwgM10KCTpsZXQgYmIgPSBhYQoJOmNhbGwgYWRkKGFhLCA0KQoJOmVjaG8gYmIKPAlbMSwgMiwgMywgNF0KCk1ha2luZyBhIGNvcHkgb2YgYSBsaXN0IGlzIGRvbmUgd2l0aCB0aGUgfGNvcHkoKXwgZnVuY3Rpb24uICBVc2luZyBbOl0gYWxzbwp3b3JrcywgYXMgZXhwbGFpbmVkIGFib3ZlLiAgVGhpcyBjcmVhdGVzIGEgc2hhbGxvdyBjb3B5IG9mIHRoZSBsaXN0OiBDaGFuZ2luZwphIGxpc3QgaXRlbSBpbiB0aGUgbGlzdCB3aWxsIGFsc28gY2hhbmdlIHRoZSBpdGVtIGluIHRoZSBjb3BpZWQgbGlzdDogPgoJOmxldCBhYSA9IFtbMSwgJ2EnXSwgMiwgM10KCTpsZXQgYmIgPSBjb3B5KGFhKQoJOmNhbGwgYWRkKGFhLCA0KQoJOmxldCBhYVswXVsxXSA9ICdhYWEnCgk6ZWNobyBhYQo8CVtbMSwgYWFhXSwgMiwgMywgNF0gPgoJOmVjaG8gYmIKPAlbWzEsIGFhYV0sIDIsIDNdCgpUbyBtYWtlIGEgY29tcGxldGVseSBpbmRlcGVuZGVudCBsaXN0IHVzZSB8ZGVlcGNvcHkoKXwuICBUaGlzIGFsc28gbWFrZXMgYQpjb3B5IG9mIHRoZSB2YWx1ZXMgaW4gdGhlIGxpc3QsIHJlY3Vyc2l2ZWx5LiAgVXAgdG8gYSBodW5kcmVkIGxldmVscyBkZWVwLgoKVGhlIG9wZXJhdG9yICJpcyIgY2FuIGJlIHVzZWQgdG8gY2hlY2sgaWYgdHdvIHZhcmlhYmxlcyByZWZlciB0byB0aGUgc2FtZQpMaXN0LiAgImlzbm90IiBkb2VzIHRoZSBvcHBvc2l0ZS4gIEluIGNvbnRyYXN0ICI9PSIgY29tcGFyZXMgaWYgdHdvIGxpc3RzIGhhdmUKdGhlIHNhbWUgdmFsdWUuID4KCTpsZXQgYWxpc3QgPSBbMSwgMiwgM10KCTpsZXQgYmxpc3QgPSBbMSwgMiwgM10KCTplY2hvIGFsaXN0IGlzIGJsaXN0CjwJMCA+Cgk6ZWNobyBhbGlzdCA9PSBibGlzdAo8CTEKCk5vdGUgYWJvdXQgY29tcGFyaW5nIGxpc3RzOiBUd28gbGlzdHMgYXJlIGNvbnNpZGVyZWQgZXF1YWwgaWYgdGhleSBoYXZlIHRoZQpzYW1lIGxlbmd0aCBhbmQgYWxsIGl0ZW1zIGNvbXBhcmUgZXF1YWwsIGFzIHdpdGggdXNpbmcgIj09Ii4gIFRoZXJlIGlzIG9uZQpleGNlcHRpb246IFdoZW4gY29tcGFyaW5nIGEgbnVtYmVyIHdpdGggYSBzdHJpbmcgdGhleSBhcmUgY29uc2lkZXJlZApkaWZmZXJlbnQuICBUaGVyZSBpcyBubyBhdXRvbWF0aWMgdHlwZSBjb252ZXJzaW9uLCBhcyB3aXRoIHVzaW5nICI9PSIgb24KdmFyaWFibGVzLiAgRXhhbXBsZTogPgoJZWNobyA0ID09ICI0Igo8CTEgPgoJZWNobyBbNF0gPT0gWyI0Il0KPAkwCgpUaHVzIGNvbXBhcmluZyBMaXN0cyBpcyBtb3JlIHN0cmljdCB0aGFuIGNvbXBhcmluZyBudW1iZXJzIGFuZCBzdHJpbmdzLiAgWW91CmNhbiBjb21wYXJlIHNpbXBsZSB2YWx1ZXMgdGhpcyB3YXkgdG9vIGJ5IHB1dHRpbmcgdGhlbSBpbiBhIGxpc3Q6ID4KCgk6bGV0IGEgPSA1Cgk6bGV0IGIgPSAiNSIKCTplY2hvIGEgPT0gYgo8CTEgPgoJOmVjaG8gW2FdID09IFtiXQo8CTAKCgpMaXN0IHVucGFjayB+CgpUbyB1bnBhY2sgdGhlIGl0ZW1zIGluIGEgbGlzdCB0byBpbmRpdmlkdWFsIHZhcmlhYmxlcywgcHV0IHRoZSB2YXJpYWJsZXMgaW4Kc3F1YXJlIGJyYWNrZXRzLCBsaWtlIGxpc3QgaXRlbXM6ID4KCTpsZXQgW3ZhcjEsIHZhcjJdID0gbXlsaXN0CgpXaGVuIHRoZSBudW1iZXIgb2YgdmFyaWFibGVzIGRvZXMgbm90IG1hdGNoIHRoZSBudW1iZXIgb2YgaXRlbXMgaW4gdGhlIGxpc3QKdGhpcyBwcm9kdWNlcyBhbiBlcnJvci4gIFRvIGhhbmRsZSBhbnkgZXh0cmEgaXRlbXMgZnJvbSB0aGUgbGlzdCBhcHBlbmQgIjsiCmFuZCBhIHZhcmlhYmxlIG5hbWU6ID4KCTpsZXQgW3ZhcjEsIHZhcjI7IHJlc3RdID0gbXlsaXN0CgpUaGlzIHdvcmtzIGxpa2U6ID4KCTpsZXQgdmFyMSA9IG15bGlzdFswXQoJOmxldCB2YXIyID0gbXlsaXN0WzFdCgk6bGV0IHJlc3QgPSBteWxpc3RbMjpdCgpFeGNlcHQgdGhhdCB0aGVyZSBpcyBubyBlcnJvciBpZiB0aGVyZSBhcmUgb25seSB0d28gaXRlbXMuICAicmVzdCIgd2lsbCBiZSBhbgplbXB0eSBsaXN0IHRoZW4uCgoKTGlzdCBtb2RpZmljYXRpb24gfgoJCQkJCQkJKmxpc3QtbW9kaWZpY2F0aW9uKgpUbyBjaGFuZ2UgYSBzcGVjaWZpYyBpdGVtIG9mIGEgbGlzdCB1c2UgfDpsZXR8IHRoaXMgd2F5OiA+Cgk6bGV0IGxpc3RbNF0gPSAiZm91ciIKCTpsZXQgbGlzdGxpc3RbMF1bM10gPSBpdGVtCgpUbyBjaGFuZ2UgcGFydCBvZiBhIGxpc3QgeW91IGNhbiBzcGVjaWZ5IHRoZSBmaXJzdCBhbmQgbGFzdCBpdGVtIHRvIGJlCm1vZGlmaWVkLiAgVGhlIHZhbHVlIG11c3QgYXQgbGVhc3QgaGF2ZSB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSByYW5nZTogPgoJOmxldCBsaXN0WzM6NV0gPSBbMywgNCwgNV0KCkFkZGluZyBhbmQgcmVtb3ZpbmcgaXRlbXMgZnJvbSBhIGxpc3QgaXMgZG9uZSB3aXRoIGZ1bmN0aW9ucy4gIEhlcmUgYXJlIGEgZmV3CmV4YW1wbGVzOiA+Cgk6Y2FsbCBpbnNlcnQobGlzdCwgJ2EnKQkJIiBwcmVwZW5kIGl0ZW0gJ2EnCgk6Y2FsbCBpbnNlcnQobGlzdCwgJ2EnLCAzKQkiIGluc2VydCBpdGVtICdhJyBiZWZvcmUgbGlzdFszXQoJOmNhbGwgYWRkKGxpc3QsICJuZXciKQkJIiBhcHBlbmQgU3RyaW5nIGl0ZW0KCTpjYWxsIGFkZChsaXN0LCBbMSwgMl0pCQkiIGFwcGVuZCBhIExpc3QgYXMgb25lIG5ldyBpdGVtCgk6Y2FsbCBleHRlbmQobGlzdCwgWzEsIDJdKQkiIGV4dGVuZCB0aGUgbGlzdCB3aXRoIHR3byBtb3JlIGl0ZW1zCgk6bGV0IGkgPSByZW1vdmUobGlzdCwgMykJIiByZW1vdmUgaXRlbSAzCgk6dW5sZXQgbGlzdFszXQkJCSIgaWRlbQoJOmxldCBsID0gcmVtb3ZlKGxpc3QsIDMsIC0xKQkiIHJlbW92ZSBpdGVtcyAzIHRvIGxhc3QgaXRlbQoJOnVubGV0IGxpc3RbMyA6IF0JCSIgaWRlbQoJOmNhbGwgZmlsdGVyKGxpc3QsICd2OnZhbCAhfiAieCInKSAgIiByZW1vdmUgaXRlbXMgd2l0aCBhbiAneCcKCkNoYW5naW5nIHRoZSBvcmRlciBvZiBpdGVtcyBpbiBhIGxpc3Q6ID4KCTpjYWxsIHNvcnQobGlzdCkJCSIgc29ydCBhIGxpc3QgYWxwaGFiZXRpY2FsbHkKCTpjYWxsIHJldmVyc2UobGlzdCkJCSIgcmV2ZXJzZSB0aGUgb3JkZXIgb2YgaXRlbXMKCTpjYWxsIHVuaXEoc29ydChsaXN0KSkJCSIgc29ydCBhbmQgcmVtb3ZlIGR1cGxpY2F0ZXMKCgpGb3IgbG9vcCB+CgpUaGUgfDpmb3J8IGxvb3AgZXhlY3V0ZXMgY29tbWFuZHMgZm9yIGVhY2ggaXRlbSBpbiBhIGxpc3QuICBBIHZhcmlhYmxlIGlzIHNldAp0byBlYWNoIGl0ZW0gaW4gdGhlIGxpc3QgaW4gc2VxdWVuY2UuICBFeGFtcGxlOiA+Cgk6Zm9yIGl0ZW0gaW4gbXlsaXN0Cgk6ICAgY2FsbCBEb2l0KGl0ZW0pCgk6ZW5kZm9yCgpUaGlzIHdvcmtzIGxpa2U6ID4KCTpsZXQgaW5kZXggPSAwCgk6d2hpbGUgaW5kZXggPCBsZW4obXlsaXN0KQoJOiAgIGxldCBpdGVtID0gbXlsaXN0W2luZGV4XQoJOiAgIDpjYWxsIERvaXQoaXRlbSkKCTogICBsZXQgaW5kZXggPSBpbmRleCArIDEKCTplbmR3aGlsZQoKSWYgYWxsIHlvdSB3YW50IHRvIGRvIGlzIG1vZGlmeSBlYWNoIGl0ZW0gaW4gdGhlIGxpc3QgdGhlbiB0aGUgfG1hcCgpfApmdW5jdGlvbiB3aWxsIGJlIGEgc2ltcGxlciBtZXRob2QgdGhhbiBhIGZvciBsb29wLgoKSnVzdCBsaWtlIHRoZSB8OmxldHwgY29tbWFuZCwgfDpmb3J8IGFsc28gYWNjZXB0cyBhIGxpc3Qgb2YgdmFyaWFibGVzLglUaGlzCnJlcXVpcmVzIHRoZSBhcmd1bWVudCB0byBiZSBhIGxpc3Qgb2YgbGlzdHMuID4KCTpmb3IgW2xudW0sIGNvbF0gaW4gW1sxLCAzXSwgWzIsIDhdLCBbMywgMF1dCgk6ICAgY2FsbCBEb2l0KGxudW0sIGNvbCkKCTplbmRmb3IKClRoaXMgd29ya3MgbGlrZSBhIHw6bGV0fCBjb21tYW5kIGlzIGRvbmUgZm9yIGVhY2ggbGlzdCBpdGVtLiAgQWdhaW4sIHRoZSB0eXBlcwptdXN0IHJlbWFpbiB0aGUgc2FtZSB0byBhdm9pZCBhbiBlcnJvci4KCkl0IGlzIGFsc28gcG9zc2libGUgdG8gcHV0IHJlbWFpbmluZyBpdGVtcyBpbiBhIExpc3QgdmFyaWFibGU6ID4KCTpmb3IgW2ksIGo7IHJlc3RdIGluIGxpc3RsaXN0Cgk6ICAgY2FsbCBEb2l0KGksIGopCgk6ICAgaWYgIWVtcHR5KHJlc3QpCgk6ICAgICAgZWNobyAicmVtYWluZGVyOiAiIC4gc3RyaW5nKHJlc3QpCgk6ICAgZW5kaWYKCTplbmRmb3IKCgpMaXN0IGZ1bmN0aW9ucyB+CgkJCQkJCSpFNzE0KgpGdW5jdGlvbnMgdGhhdCBhcmUgdXNlZnVsIHdpdGggYSBMaXN0OiA+Cgk6bGV0IHIgPSBjYWxsKGZ1bmNuYW1lLCBsaXN0KQkiIGNhbGwgYSBmdW5jdGlvbiB3aXRoIGFuIGFyZ3VtZW50IGxpc3QKCTppZiBlbXB0eShsaXN0KQkJCSIgY2hlY2sgaWYgbGlzdCBpcyBlbXB0eQoJOmxldCBsID0gbGVuKGxpc3QpCQkiIG51bWJlciBvZiBpdGVtcyBpbiBsaXN0Cgk6bGV0IGJpZyA9IG1heChsaXN0KQkJIiBtYXhpbXVtIHZhbHVlIGluIGxpc3QKCTpsZXQgc21hbGwgPSBtaW4obGlzdCkJCSIgbWluaW11bSB2YWx1ZSBpbiBsaXN0Cgk6bGV0IHhzID0gY291bnQobGlzdCwgJ3gnKQkiIGNvdW50IG5yIG9mIHRpbWVzICd4JyBhcHBlYXJzIGluIGxpc3QKCTpsZXQgaSA9IGluZGV4KGxpc3QsICd4JykJIiBpbmRleCBvZiBmaXJzdCAneCcgaW4gbGlzdAoJOmxldCBsaW5lcyA9IGdldGxpbmUoMSwgMTApCSIgZ2V0IHRlbiB0ZXh0IGxpbmVzIGZyb20gYnVmZmVyCgk6Y2FsbCBhcHBlbmQoJyQnLCBsaW5lcykJIiBhcHBlbmQgdGV4dCBsaW5lcyBpbiBidWZmZXIKCTpsZXQgbGlzdCA9IHNwbGl0KCJhIGIgYyIpCSIgY3JlYXRlIGxpc3QgZnJvbSBpdGVtcyBpbiBhIHN0cmluZwoJOmxldCBzdHJpbmcgPSBqb2luKGxpc3QsICcsICcpCSIgY3JlYXRlIHN0cmluZyBmcm9tIGxpc3QgaXRlbXMKCTpsZXQgcyA9IHN0cmluZyhsaXN0KQkJIiBTdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgbGlzdAoJOmNhbGwgbWFwKGxpc3QsICciPj4gIiAuIHY6dmFsJykgICIgcHJlcGVuZCAiPj4gIiB0byBlYWNoIGl0ZW0KCkRvbid0IGZvcmdldCB0aGF0IGEgY29tYmluYXRpb24gb2YgZmVhdHVyZXMgY2FuIG1ha2UgdGhpbmdzIHNpbXBsZS4gIEZvcgpleGFtcGxlLCB0byBhZGQgdXAgYWxsIHRoZSBudW1iZXJzIGluIGEgbGlzdDogPgoJOmV4ZSAnbGV0IHN1bSA9ICcgLiBqb2luKG5ybGlzdCwgJysnKQoKCjEuNCBEaWN0aW9uYXJpZXMgfgoJCQkJCSpkaWN0KiAqRGljdGlvbmFyaWVzKiAqRGljdGlvbmFyeSoKQSBEaWN0aW9uYXJ5IGlzIGFuIGFzc29jaWF0aXZlIGFycmF5OiBFYWNoIGVudHJ5IGhhcyBhIGtleSBhbmQgYSB2YWx1ZS4gIFRoZQplbnRyeSBjYW4gYmUgbG9jYXRlZCB3aXRoIHRoZSBrZXkuICBUaGUgZW50cmllcyBhcmUgc3RvcmVkIHdpdGhvdXQgYSBzcGVjaWZpYwpvcmRlcmluZy4KCgpEaWN0aW9uYXJ5IGNyZWF0aW9uIH4KCQkJCQkJKkU3MjAqICpFNzIxKiAqRTcyMiogKkU3MjMqCkEgRGljdGlvbmFyeSBpcyBjcmVhdGVkIHdpdGggYSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiBlbnRyaWVzIGluIGN1cmx5CmJyYWNlcy4gIEVhY2ggZW50cnkgaGFzIGEga2V5IGFuZCBhIHZhbHVlLCBzZXBhcmF0ZWQgYnkgYSBjb2xvbi4gIEVhY2gga2V5IGNhbgpvbmx5IGFwcGVhciBvbmNlLiAgRXhhbXBsZXM6ID4KCTpsZXQgbXlkaWN0ID0gezE6ICdvbmUnLCAyOiAndHdvJywgMzogJ3RocmVlJ30KCTpsZXQgZW1wdHlkaWN0ID0ge30KPAkJCQkJCQkqRTcxMyogKkU3MTYqICpFNzE3KgpBIGtleSBpcyBhbHdheXMgYSBTdHJpbmcuICBZb3UgY2FuIHVzZSBhIE51bWJlciwgaXQgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYQpTdHJpbmcgYXV0b21hdGljYWxseS4gIFRodXMgdGhlIFN0cmluZyAnNCcgYW5kIHRoZSBudW1iZXIgNCB3aWxsIGZpbmQgdGhlIHNhbWUKZW50cnkuCU5vdGUgdGhhdCB0aGUgU3RyaW5nICcwNCcgYW5kIHRoZSBOdW1iZXIgMDQgYXJlIGRpZmZlcmVudCwgc2luY2UgdGhlCk51bWJlciB3aWxsIGJlIGNvbnZlcnRlZCB0byB0aGUgU3RyaW5nICc0Jy4gIFRoZSBlbXB0eSBzdHJpbmcgY2FuIGJlIHVzZWQgYXMgYQprZXkuCgpBIHZhbHVlIGNhbiBiZSBhbnkgZXhwcmVzc2lvbi4JVXNpbmcgYSBEaWN0aW9uYXJ5IGZvciBhIHZhbHVlIGNyZWF0ZXMgYQpuZXN0ZWQgRGljdGlvbmFyeTogPgoJOmxldCBuZXN0ZGljdCA9IHsxOiB7MTE6ICdhJywgMTI6ICdiJ30sIDI6IHsyMTogJ2MnfX0KCkFuIGV4dHJhIGNvbW1hIGFmdGVyIHRoZSBsYXN0IGVudHJ5IGlzIGlnbm9yZWQuCgoKQWNjZXNzaW5nIGVudHJpZXMgfgoKVGhlIG5vcm1hbCB3YXkgdG8gYWNjZXNzIGFuIGVudHJ5IGlzIGJ5IHB1dHRpbmcgdGhlIGtleSBpbiBzcXVhcmUgYnJhY2tldHM6ID4KCTpsZXQgdmFsID0gbXlkaWN0WyJvbmUiXQoJOmxldCBteWRpY3RbImZvdXIiXSA9IDQKCllvdSBjYW4gYWRkIG5ldyBlbnRyaWVzIHRvIGFuIGV4aXN0aW5nIERpY3Rpb25hcnkgdGhpcyB3YXksIHVubGlrZSBMaXN0cy4KCkZvciBrZXlzIHRoYXQgY29uc2lzdCBlbnRpcmVseSBvZiBsZXR0ZXJzLCBkaWdpdHMgYW5kIHVuZGVyc2NvcmUgdGhlIGZvbGxvd2luZwpmb3JtIGNhbiBiZSB1c2VkIHxleHByLWVudHJ5fDogPgoJOmxldCB2YWwgPSBteWRpY3Qub25lCgk6bGV0IG15ZGljdC5mb3VyID0gNAoKU2luY2UgYW4gZW50cnkgY2FuIGJlIGFueSB0eXBlLCBhbHNvIGEgTGlzdCBhbmQgYSBEaWN0aW9uYXJ5LCB0aGUgaW5kZXhpbmcgYW5kCmtleSBsb29rdXAgY2FuIGJlIHJlcGVhdGVkOiA+Cgk6ZWNobyBkaWN0LmtleVtpZHhdLmtleQoKCkRpY3Rpb25hcnkgdG8gTGlzdCBjb252ZXJzaW9uIH4KCllvdSBtYXkgd2FudCB0byBsb29wIG92ZXIgdGhlIGVudHJpZXMgaW4gYSBkaWN0aW9uYXJ5LglGb3IgdGhpcyB5b3UgbmVlZCB0bwp0dXJuIHRoZSBEaWN0aW9uYXJ5IGludG8gYSBMaXN0IGFuZCBwYXNzIGl0IHRvIHw6Zm9yfC4KCk1vc3Qgb2Z0ZW4geW91IHdhbnQgdG8gbG9vcCBvdmVyIHRoZSBrZXlzLCB1c2luZyB0aGUgfGtleXMoKXwgZnVuY3Rpb246ID4KCTpmb3Iga2V5IGluIGtleXMobXlkaWN0KQoJOiAgIGVjaG8ga2V5IC4gJzogJyAuIG15ZGljdFtrZXldCgk6ZW5kZm9yCgpUaGUgTGlzdCBvZiBrZXlzIGlzIHVuc29ydGVkLiAgWW91IG1heSB3YW50IHRvIHNvcnQgdGhlbSBmaXJzdDogPgoJOmZvciBrZXkgaW4gc29ydChrZXlzKG15ZGljdCkpCgpUbyBsb29wIG92ZXIgdGhlIHZhbHVlcyB1c2UgdGhlIHx2YWx1ZXMoKXwgZnVuY3Rpb246ICA+Cgk6Zm9yIHYgaW4gdmFsdWVzKG15ZGljdCkKCTogICBlY2hvICJ2YWx1ZTogIiAuIHYKCTplbmRmb3IKCklmIHlvdSB3YW50IGJvdGggdGhlIGtleSBhbmQgdGhlIHZhbHVlIHVzZSB0aGUgfGl0ZW1zKCl8IGZ1bmN0aW9uLiAgSXQgcmV0dXJucwphIExpc3QgaW4gd2hpY2ggZWFjaCBpdGVtIGlzIGEJTGlzdCB3aXRoIHR3byBpdGVtcywgdGhlIGtleSBhbmQgdGhlIHZhbHVlOiA+Cgk6Zm9yIFtrZXksIHZhbHVlXSBpbiBpdGVtcyhteWRpY3QpCgk6ICAgZWNobyBrZXkgLiAnOiAnIC4gdmFsdWUKCTplbmRmb3IKCgpEaWN0aW9uYXJ5IGlkZW50aXR5IH4KCQkJCQkJCSpkaWN0LWlkZW50aXR5KgpKdXN0IGxpa2UgTGlzdHMgeW91IG5lZWQgdG8gdXNlIHxjb3B5KCl8IGFuZCB8ZGVlcGNvcHkoKXwgdG8gbWFrZSBhIGNvcHkgb2YgYQpEaWN0aW9uYXJ5LiAgT3RoZXJ3aXNlLCBhc3NpZ25tZW50IHJlc3VsdHMgaW4gcmVmZXJyaW5nIHRvIHRoZSBzYW1lCkRpY3Rpb25hcnk6ID4KCTpsZXQgb25lZGljdCA9IHsnYSc6IDEsICdiJzogMn0KCTpsZXQgYWRpY3QgPSBvbmVkaWN0Cgk6bGV0IGFkaWN0WydhJ10gPSAxMQoJOmVjaG8gb25lZGljdFsnYSddCgkxMQoKVHdvIERpY3Rpb25hcmllcyBjb21wYXJlIGVxdWFsIGlmIGFsbCB0aGUga2V5LXZhbHVlIHBhaXJzIGNvbXBhcmUgZXF1YWwuICBGb3IKbW9yZSBpbmZvIHNlZSB8bGlzdC1pZGVudGl0eXwuCgoKRGljdGlvbmFyeSBtb2RpZmljYXRpb24gfgoJCQkJCQkJKmRpY3QtbW9kaWZpY2F0aW9uKgpUbyBjaGFuZ2UgYW4gYWxyZWFkeSBleGlzdGluZyBlbnRyeSBvZiBhIERpY3Rpb25hcnksIG9yIHRvIGFkZCBhIG5ldyBlbnRyeSwKdXNlIHw6bGV0fCB0aGlzIHdheTogPgoJOmxldCBkaWN0WzRdID0gImZvdXIiCgk6bGV0IGRpY3RbJ29uZSddID0gaXRlbQoKUmVtb3ZpbmcgYW4gZW50cnkgZnJvbSBhIERpY3Rpb25hcnkgaXMgZG9uZSB3aXRoIHxyZW1vdmUoKXwgb3IgfDp1bmxldHwuClRocmVlIHdheXMgdG8gcmVtb3ZlIHRoZSBlbnRyeSB3aXRoIGtleSAiYWFhIiBmcm9tIGRpY3Q6ID4KCTpsZXQgaSA9IHJlbW92ZShkaWN0LCAnYWFhJykKCTp1bmxldCBkaWN0LmFhYQoJOnVubGV0IGRpY3RbJ2FhYSddCgpNZXJnaW5nIGEgRGljdGlvbmFyeSB3aXRoIGFub3RoZXIgaXMgZG9uZSB3aXRoIHxleHRlbmQoKXw6ID4KCTpjYWxsIGV4dGVuZChhZGljdCwgYmRpY3QpClRoaXMgZXh0ZW5kcyBhZGljdCB3aXRoIGFsbCBlbnRyaWVzIGZyb20gYmRpY3QuICBEdXBsaWNhdGUga2V5cyBjYXVzZSBlbnRyaWVzCmluIGFkaWN0IHRvIGJlIG92ZXJ3cml0dGVuLiAgQW4gb3B0aW9uYWwgdGhpcmQgYXJndW1lbnQgY2FuIGNoYW5nZSB0aGlzLgpOb3RlIHRoYXQgdGhlIG9yZGVyIG9mIGVudHJpZXMgaW4gYSBEaWN0aW9uYXJ5IGlzIGlycmVsZXZhbnQsIHRodXMgZG9uJ3QKZXhwZWN0ICI6ZWNobyBhZGljdCIgdG8gc2hvdyB0aGUgaXRlbXMgZnJvbSBiZGljdCBhZnRlciB0aGUgb2xkZXIgZW50cmllcyBpbgphZGljdC4KCldlZWRpbmcgb3V0IGVudHJpZXMgZnJvbSBhIERpY3Rpb25hcnkgY2FuIGJlIGRvbmUgd2l0aCB8ZmlsdGVyKCl8OiA+Cgk6Y2FsbCBmaWx0ZXIoZGljdCwgJ3Y6dmFsID1+ICJ4IicpClRoaXMgcmVtb3ZlcyBhbGwgZW50cmllcyBmcm9tICJkaWN0IiB3aXRoIGEgdmFsdWUgbm90IG1hdGNoaW5nICd4Jy4KCgpEaWN0aW9uYXJ5IGZ1bmN0aW9uIH4KCQkJCSpEaWN0aW9uYXJ5LWZ1bmN0aW9uKiAqc2VsZiogKkU3MjUqICpFODYyKgpXaGVuIGEgZnVuY3Rpb24gaXMgZGVmaW5lZCB3aXRoIHRoZSAiZGljdCIgYXR0cmlidXRlIGl0IGNhbiBiZSB1c2VkIGluIGEKc3BlY2lhbCB3YXkgd2l0aCBhIGRpY3Rpb25hcnkuCUV4YW1wbGU6ID4KCTpmdW5jdGlvbiBNeWxlbigpIGRpY3QKCTogICByZXR1cm4gbGVuKHNlbGYuZGF0YSkKCTplbmRmdW5jdGlvbgoJOmxldCBteWRpY3QgPSB7J2RhdGEnOiBbMCwgMSwgMiwgM10sICdsZW4nOiBmdW5jdGlvbigiTXlsZW4iKX0KCTplY2hvIG15ZGljdC5sZW4oKQoKVGhpcyBpcyBsaWtlIGEgbWV0aG9kIGluIG9iamVjdCBvcmllbnRlZCBwcm9ncmFtbWluZy4gIFRoZSBlbnRyeSBpbiB0aGUKRGljdGlvbmFyeSBpcyBhIHxGdW5jcmVmfC4gIFRoZSBsb2NhbCB2YXJpYWJsZSAic2VsZiIgcmVmZXJzIHRvIHRoZSBkaWN0aW9uYXJ5CnRoZSBmdW5jdGlvbiB3YXMgaW52b2tlZCBmcm9tLgoKSXQgaXMgYWxzbyBwb3NzaWJsZSB0byBhZGQgYSBmdW5jdGlvbiB3aXRob3V0IHRoZSAiZGljdCIgYXR0cmlidXRlIGFzIGEKRnVuY3JlZiB0byBhIERpY3Rpb25hcnksIGJ1dCB0aGUgInNlbGYiIHZhcmlhYmxlIGlzIG5vdCBhdmFpbGFibGUgdGhlbi4KCgkJCQkqbnVtYmVyZWQtZnVuY3Rpb24qICphbm9ueW1vdXMtZnVuY3Rpb24qClRvIGF2b2lkIHRoZSBleHRyYSBuYW1lIGZvciB0aGUgZnVuY3Rpb24gaXQgY2FuIGJlIGRlZmluZWQgYW5kIGRpcmVjdGx5CmFzc2lnbmVkIHRvIGEgRGljdGlvbmFyeSBpbiB0aGlzIHdheTogPgoJOmxldCBteWRpY3QgPSB7J2RhdGEnOiBbMCwgMSwgMiwgM119Cgk6ZnVuY3Rpb24gbXlkaWN0LmxlbigpCgk6ICAgcmV0dXJuIGxlbihzZWxmLmRhdGEpCgk6ZW5kZnVuY3Rpb24KCTplY2hvIG15ZGljdC5sZW4oKQoKVGhlIGZ1bmN0aW9uIHdpbGwgdGhlbiBnZXQgYSBudW1iZXIgYW5kIHRoZSB2YWx1ZSBvZiBkaWN0LmxlbiBpcyBhIHxGdW5jcmVmfAp0aGF0IHJlZmVyZW5jZXMgdGhpcyBmdW5jdGlvbi4JVGhlIGZ1bmN0aW9uIGNhbiBvbmx5IGJlIHVzZWQgdGhyb3VnaCBhCnxGdW5jcmVmfC4gIEl0IHdpbGwgYXV0b21hdGljYWxseSBiZSBkZWxldGVkIHdoZW4gdGhlcmUgaXMgbm8gfEZ1bmNyZWZ8CnJlbWFpbmluZyB0aGF0IHJlZmVycyB0byBpdC4KCkl0IGlzIG5vdCBuZWNlc3NhcnkgdG8gdXNlIHRoZSAiZGljdCIgYXR0cmlidXRlIGZvciBhIG51bWJlcmVkIGZ1bmN0aW9uLgoKSWYgeW91IGdldCBhbiBlcnJvciBmb3IgYSBudW1iZXJlZCBmdW5jdGlvbiwgeW91IGNhbiBmaW5kIG91dCB3aGF0IGl0IGlzIHdpdGgKYSB0cmljay4gIEFzc3VtaW5nIHRoZSBmdW5jdGlvbiBpcyA0MiwgdGhlIGNvbW1hbmQgaXM6ID4KCTpmdW5jdGlvbiB7NDJ9CgoKRnVuY3Rpb25zIGZvciBEaWN0aW9uYXJpZXMgfgoJCQkJCQkJKkU3MTUqCkZ1bmN0aW9ucyB0aGF0IGNhbiBiZSB1c2VkIHdpdGggYSBEaWN0aW9uYXJ5OiA+Cgk6aWYgaGFzX2tleShkaWN0LCAnZm9vJykJIiBUUlVFIGlmIGRpY3QgaGFzIGVudHJ5IHdpdGgga2V5ICJmb28iCgk6aWYgZW1wdHkoZGljdCkJCQkiIFRSVUUgaWYgZGljdCBpcyBlbXB0eQoJOmxldCBsID0gbGVuKGRpY3QpCQkiIG51bWJlciBvZiBpdGVtcyBpbiBkaWN0Cgk6bGV0IGJpZyA9IG1heChkaWN0KQkJIiBtYXhpbXVtIHZhbHVlIGluIGRpY3QKCTpsZXQgc21hbGwgPSBtaW4oZGljdCkJCSIgbWluaW11bSB2YWx1ZSBpbiBkaWN0Cgk6bGV0IHhzID0gY291bnQoZGljdCwgJ3gnKQkiIGNvdW50IG5yIG9mIHRpbWVzICd4JyBhcHBlYXJzIGluIGRpY3QKCTpsZXQgcyA9IHN0cmluZyhkaWN0KQkJIiBTdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgZGljdAoJOmNhbGwgbWFwKGRpY3QsICciPj4gIiAuIHY6dmFsJykgICIgcHJlcGVuZCAiPj4gIiB0byBlYWNoIGl0ZW0KCgoxLjUgTW9yZSBhYm91dCB2YXJpYWJsZXMgfgoJCQkJCQkJKm1vcmUtdmFyaWFibGVzKgpJZiB5b3UgbmVlZCB0byBrbm93IHRoZSB0eXBlIG9mIGEgdmFyaWFibGUgb3IgZXhwcmVzc2lvbiwgdXNlIHRoZSB8dHlwZSgpfApmdW5jdGlvbi4KCldoZW4gdGhlICchJyBmbGFnIGlzIGluY2x1ZGVkIGluIHRoZSAndmltaW5mbycgb3B0aW9uLCBnbG9iYWwgdmFyaWFibGVzIHRoYXQKc3RhcnQgd2l0aCBhbiB1cHBlcmNhc2UgbGV0dGVyLCBhbmQgZG9uJ3QgY29udGFpbiBhIGxvd2VyY2FzZSBsZXR0ZXIsIGFyZQpzdG9yZWQgaW4gdGhlIHZpbWluZm8gZmlsZSB8dmltaW5mby1maWxlfC4KCldoZW4gdGhlICdzZXNzaW9ub3B0aW9ucycgb3B0aW9uIGNvbnRhaW5zICJnbG9iYWwiLCBnbG9iYWwgdmFyaWFibGVzIHRoYXQKc3RhcnQgd2l0aCBhbiB1cHBlcmNhc2UgbGV0dGVyIGFuZCBjb250YWluIGF0IGxlYXN0IG9uZSBsb3dlcmNhc2UgbGV0dGVyIGFyZQpzdG9yZWQgaW4gdGhlIHNlc3Npb24gZmlsZSB8c2Vzc2lvbi1maWxlfC4KCnZhcmlhYmxlIG5hbWUJCWNhbiBiZSBzdG9yZWQgd2hlcmUgfgpteV92YXJfNgkJbm90Ck15X1Zhcl82CQlzZXNzaW9uIGZpbGUKTVlfVkFSXzYJCXZpbWluZm8gZmlsZQoKCkl0J3MgcG9zc2libGUgdG8gZm9ybSBhIHZhcmlhYmxlIG5hbWUgd2l0aCBjdXJseSBicmFjZXMsIHNlZQp8Y3VybHktYnJhY2VzLW5hbWVzfC4KCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoyLiBFeHByZXNzaW9uIHN5bnRheAkJCQkJKmV4cHJlc3Npb24tc3ludGF4KgoKRXhwcmVzc2lvbiBzeW50YXggc3VtbWFyeSwgZnJvbSBsZWFzdCB0byBtb3N0IHNpZ25pZmljYW50OgoKfGV4cHIxfCBleHByMiA/IGV4cHIxIDogZXhwcjEJaWYtdGhlbi1lbHNlCgp8ZXhwcjJ8CWV4cHIzIHx8IGV4cHIzIC4uCWxvZ2ljYWwgT1IKCnxleHByM3wJZXhwcjQgJiYgZXhwcjQgLi4JbG9naWNhbCBBTkQKCnxleHByNHwJZXhwcjUgPT0gZXhwcjUJCWVxdWFsCglleHByNSAhPSBleHByNQkJbm90IGVxdWFsCglleHByNSA+CSBleHByNQkJZ3JlYXRlciB0aGFuCglleHByNSA+PSBleHByNQkJZ3JlYXRlciB0aGFuIG9yIGVxdWFsCglleHByNSA8CSBleHByNQkJc21hbGxlciB0aGFuCglleHByNSA8PSBleHByNQkJc21hbGxlciB0aGFuIG9yIGVxdWFsCglleHByNSA9fiBleHByNQkJcmVnZXhwIG1hdGNoZXMKCWV4cHI1ICF+IGV4cHI1CQlyZWdleHAgZG9lc24ndCBtYXRjaAoKCWV4cHI1ID09PyBleHByNQkJZXF1YWwsIGlnbm9yaW5nIGNhc2UKCWV4cHI1ID09IyBleHByNQkJZXF1YWwsIG1hdGNoIGNhc2UKCWV0Yy4JCQlBcyBhYm92ZSwgYXBwZW5kID8gZm9yIGlnbm9yaW5nIGNhc2UsICMgZm9yCgkJCQltYXRjaGluZyBjYXNlCgoJZXhwcjUgaXMgZXhwcjUJCXNhbWUgfExpc3R8IGluc3RhbmNlCglleHByNSBpc25vdCBleHByNQlkaWZmZXJlbnQgfExpc3R8IGluc3RhbmNlCgp8ZXhwcjV8CWV4cHI2ICsJIGV4cHI2IC4uCW51bWJlciBhZGRpdGlvbiBvciBsaXN0IGNvbmNhdGVuYXRpb24KCWV4cHI2IC0JIGV4cHI2IC4uCW51bWJlciBzdWJ0cmFjdGlvbgoJZXhwcjYgLgkgZXhwcjYgLi4Jc3RyaW5nIGNvbmNhdGVuYXRpb24KCnxleHByNnwJZXhwcjcgKgkgZXhwcjcgLi4JbnVtYmVyIG11bHRpcGxpY2F0aW9uCglleHByNyAvCSBleHByNyAuLgludW1iZXIgZGl2aXNpb24KCWV4cHI3ICUJIGV4cHI3IC4uCW51bWJlciBtb2R1bG8KCnxleHByN3wJISBleHByNwkJCWxvZ2ljYWwgTk9UCgktIGV4cHI3CQkJdW5hcnkgbWludXMKCSsgZXhwcjcJCQl1bmFyeSBwbHVzCgp8ZXhwcjh8CWV4cHI4W2V4cHIxXQkJYnl0ZSBvZiBhIFN0cmluZyBvciBpdGVtIG9mIGEgfExpc3R8CglleHByOFtleHByMSA6IGV4cHIxXQlzdWJzdHJpbmcgb2YgYSBTdHJpbmcgb3Igc3VibGlzdCBvZiBhIHxMaXN0fAoJZXhwcjgubmFtZQkJZW50cnkgaW4gYSB8RGljdGlvbmFyeXwKCWV4cHI4KGV4cHIxLCAuLi4pCWZ1bmN0aW9uIGNhbGwgd2l0aCB8RnVuY3JlZnwgdmFyaWFibGUKCnxleHByOXwgbnVtYmVyCQkJbnVtYmVyIGNvbnN0YW50Cgkic3RyaW5nIgkJc3RyaW5nIGNvbnN0YW50LCBiYWNrc2xhc2ggaXMgc3BlY2lhbAoJJ3N0cmluZycJCXN0cmluZyBjb25zdGFudCwgJyBpcyBkb3VibGVkCglbZXhwcjEsIC4uLl0JCXxMaXN0fAoJe2V4cHIxOiBleHByMSwgLi4ufQl8RGljdGlvbmFyeXwKCSZvcHRpb24JCQlvcHRpb24gdmFsdWUKCShleHByMSkJCQluZXN0ZWQgZXhwcmVzc2lvbgoJdmFyaWFibGUJCWludGVybmFsIHZhcmlhYmxlCgl2YXtyaWF9YmxlCQlpbnRlcm5hbCB2YXJpYWJsZSB3aXRoIGN1cmx5IGJyYWNlcwoJJFZBUgkJCWVudmlyb25tZW50IHZhcmlhYmxlCglAcgkJCWNvbnRlbnRzIG9mIHJlZ2lzdGVyICdyJwoJZnVuY3Rpb24oZXhwcjEsIC4uLikJZnVuY3Rpb24gY2FsbAoJZnVuY3t0aX1vbihleHByMSwgLi4uKQlmdW5jdGlvbiBjYWxsIHdpdGggY3VybHkgYnJhY2VzCgoKIi4uIiBpbmRpY2F0ZXMgdGhhdCB0aGUgb3BlcmF0aW9ucyBpbiB0aGlzIGxldmVsIGNhbiBiZSBjb25jYXRlbmF0ZWQuCkV4YW1wbGU6ID4KCSZudSB8fCAmbGlzdCAmJiAmc2hlbGwgPT0gImNzaCIKCkFsbCBleHByZXNzaW9ucyB3aXRoaW4gb25lIGxldmVsIGFyZSBwYXJzZWQgZnJvbSBsZWZ0IHRvIHJpZ2h0LgoKCmV4cHIxCQkJCQkJCSpleHByMSogKkUxMDkqCi0tLS0tCgpleHByMiA/IGV4cHIxIDogZXhwcjEKClRoZSBleHByZXNzaW9uIGJlZm9yZSB0aGUgJz8nIGlzIGV2YWx1YXRlZCB0byBhIG51bWJlci4gIElmIGl0IGV2YWx1YXRlcyB0bwpub24temVybywgdGhlIHJlc3VsdCBpcyB0aGUgdmFsdWUgb2YgdGhlIGV4cHJlc3Npb24gYmV0d2VlbiB0aGUgJz8nIGFuZCAnOicsCm90aGVyd2lzZSB0aGUgcmVzdWx0IGlzIHRoZSB2YWx1ZSBvZiB0aGUgZXhwcmVzc2lvbiBhZnRlciB0aGUgJzonLgpFeGFtcGxlOiA+Cgk6ZWNobyBsbnVtID09IDEgPyAidG9wIiA6IGxudW0KClNpbmNlIHRoZSBmaXJzdCBleHByZXNzaW9uIGlzIGFuICJleHByMiIsIGl0IGNhbm5vdCBjb250YWluIGFub3RoZXIgPzouICBUaGUKb3RoZXIgdHdvIGV4cHJlc3Npb25zIGNhbiwgdGh1cyBhbGxvdyBmb3IgcmVjdXJzaXZlIHVzZSBvZiA/Oi4KRXhhbXBsZTogPgoJOmVjaG8gbG51bSA9PSAxID8gInRvcCIgOiBsbnVtID09IDEwMDAgPyAibGFzdCIgOiBsbnVtCgpUbyBrZWVwIHRoaXMgcmVhZGFibGUsIHVzaW5nIHxsaW5lLWNvbnRpbnVhdGlvbnwgaXMgc3VnZ2VzdGVkOiA+Cgk6ZWNobyBsbnVtID09IDEKCTpcCT8gInRvcCIKCTpcCTogbG51bSA9PSAxMDAwCgk6XAkJPyAibGFzdCIKCTpcCQk6IGxudW0KCllvdSBzaG91bGQgYWx3YXlzIHB1dCBhIHNwYWNlIGJlZm9yZSB0aGUgJzonLCBvdGhlcndpc2UgaXQgY2FuIGJlIG1pc3Rha2VuIGZvcgp1c2UgaW4gYSB2YXJpYWJsZSBzdWNoIGFzICJhOjEiLgoKCmV4cHIyIGFuZCBleHByMwkJCQkJCSpleHByMiogKmV4cHIzKgotLS0tLS0tLS0tLS0tLS0KCgkJCQkJKmV4cHItYmFyYmFyKiAqZXhwci0mJioKVGhlICJ8fCIgYW5kICImJiIgb3BlcmF0b3JzIHRha2Ugb25lIGFyZ3VtZW50IG9uIGVhY2ggc2lkZS4gIFRoZSBhcmd1bWVudHMKYXJlIChjb252ZXJ0ZWQgdG8pIE51bWJlcnMuICBUaGUgcmVzdWx0IGlzOgoKCSBpbnB1dAkJCQkgb3V0cHV0IH4KbjEJCW4yCQluMSB8fCBuMgluMSAmJiBuMiB+Cnplcm8JCXplcm8JCXplcm8JCXplcm8KemVybwkJbm9uLXplcm8Jbm9uLXplcm8JemVybwpub24temVybwl6ZXJvCQlub24temVybwl6ZXJvCm5vbi16ZXJvCW5vbi16ZXJvCW5vbi16ZXJvCW5vbi16ZXJvCgpUaGUgb3BlcmF0b3JzIGNhbiBiZSBjb25jYXRlbmF0ZWQsIGZvciBleGFtcGxlOiA+CgoJJm51IHx8ICZsaXN0ICYmICZzaGVsbCA9PSAiY3NoIgoKTm90ZSB0aGF0ICImJiIgdGFrZXMgcHJlY2VkZW5jZSBvdmVyICJ8fCIsIHNvIHRoaXMgaGFzIHRoZSBtZWFuaW5nIG9mOiA+CgoJJm51IHx8ICgmbGlzdCAmJiAmc2hlbGwgPT0gImNzaCIpCgpPbmNlIHRoZSByZXN1bHQgaXMga25vd24sIHRoZSBleHByZXNzaW9uICJzaG9ydC1jaXJjdWl0cyIsIHRoYXQgaXMsIGZ1cnRoZXIKYXJndW1lbnRzIGFyZSBub3QgZXZhbHVhdGVkLiAgVGhpcyBpcyBsaWtlIHdoYXQgaGFwcGVucyBpbiBDLiAgRm9yIGV4YW1wbGU6ID4KCglsZXQgYSA9IDEKCWVjaG8gYSB8fCBiCgpUaGlzIGlzIHZhbGlkIGV2ZW4gaWYgdGhlcmUgaXMgbm8gdmFyaWFibGUgY2FsbGVkICJiIiBiZWNhdXNlICJhIiBpcyBub24temVybywKc28gdGhlIHJlc3VsdCBtdXN0IGJlIG5vbi16ZXJvLiAgU2ltaWxhcmx5IGJlbG93OiA+CgoJZWNobyBleGlzdHMoImIiKSAmJiBiID09ICJ5ZXMiCgpUaGlzIGlzIHZhbGlkIHdoZXRoZXIgImIiIGhhcyBiZWVuIGRlZmluZWQgb3Igbm90LiAgVGhlIHNlY29uZCBjbGF1c2Ugd2lsbApvbmx5IGJlIGV2YWx1YXRlZCBpZiAiYiIgaGFzIGJlZW4gZGVmaW5lZC4KCgpleHByNAkJCQkJCQkqZXhwcjQqCi0tLS0tCgpleHByNSB7Y21wfSBleHByNQoKQ29tcGFyZSB0d28gZXhwcjUgZXhwcmVzc2lvbnMsIHJlc3VsdGluZyBpbiBhIDAgaWYgaXQgZXZhbHVhdGVzIHRvIGZhbHNlLCBvciAxCmlmIGl0IGV2YWx1YXRlcyB0byB0cnVlLgoKCQkJKmV4cHItPT0qICAqZXhwci0hPSogICpleHByLT4qCSAqZXhwci0+PSoKCQkJKmV4cHItPCogICAqZXhwci08PSogICpleHByLT1+KiAgKmV4cHItIX4qCgkJCSpleHByLT09IyogKmV4cHItIT0jKiAqZXhwci0+IyogICpleHByLT49IyoKCQkJKmV4cHItPCMqICAqZXhwci08PSMqICpleHByLT1+IyogKmV4cHItIX4jKgoJCQkqZXhwci09PT8qICpleHByLSE9PyogKmV4cHItPj8qICAqZXhwci0+PT8qCgkJCSpleHByLTw/KiAgKmV4cHItPD0/KiAqZXhwci09fj8qICpleHByLSF+PyoKCQkJKmV4cHItaXMqICpleHByLWlzbm90KiAqZXhwci1pcyMqICpleHByLWlzbm90IyoKCQkJKmV4cHItaXM/KiAqZXhwci1pc25vdD8qCgkJdXNlICdpZ25vcmVjYXNlJyAgICBtYXRjaCBjYXNlCSAgIGlnbm9yZSBjYXNlIH4KZXF1YWwJCQk9PQkJPT0jCQk9PT8Kbm90IGVxdWFsCQkhPQkJIT0jCQkhPT8KZ3JlYXRlciB0aGFuCQk+CQk+IwkJPj8KZ3JlYXRlciB0aGFuIG9yIGVxdWFsCT49CQk+PSMJCT49PwpzbWFsbGVyIHRoYW4JCTwJCTwjCQk8PwpzbWFsbGVyIHRoYW4gb3IgZXF1YWwJPD0JCTw9IwkJPD0/CnJlZ2V4cCBtYXRjaGVzCQk9fgkJPX4jCQk9fj8KcmVnZXhwIGRvZXNuJ3QgbWF0Y2gJIX4JCSF+IwkJIX4/CnNhbWUgaW5zdGFuY2UJCWlzCQlpcyMJCWlzPwpkaWZmZXJlbnQgaW5zdGFuY2UJaXNub3QJCWlzbm90IwkJaXNub3Q/CgpFeGFtcGxlczoKImFiYyIgPT0jICJBYmMiCSAgZXZhbHVhdGVzIHRvIDAKImFiYyIgPT0/ICJBYmMiCSAgZXZhbHVhdGVzIHRvIDEKImFiYyIgPT0gIkFiYyIJICBldmFsdWF0ZXMgdG8gMSBpZiAnaWdub3JlY2FzZScgaXMgc2V0LCAwIG90aGVyd2lzZQoKCQkJCQkJCSpFNjkxKiAqRTY5MioKQSB8TGlzdHwgY2FuIG9ubHkgYmUgY29tcGFyZWQgd2l0aCBhIHxMaXN0fCBhbmQgb25seSAiZXF1YWwiLCAibm90IGVxdWFsIiBhbmQKImlzIiBjYW4gYmUgdXNlZC4gIFRoaXMgY29tcGFyZXMgdGhlIHZhbHVlcyBvZiB0aGUgbGlzdCwgcmVjdXJzaXZlbHkuCklnbm9yaW5nIGNhc2UgbWVhbnMgY2FzZSBpcyBpZ25vcmVkIHdoZW4gY29tcGFyaW5nIGl0ZW0gdmFsdWVzLgoKCQkJCQkJCSpFNzM1KiAqRTczNioKQSB8RGljdGlvbmFyeXwgY2FuIG9ubHkgYmUgY29tcGFyZWQgd2l0aCBhIHxEaWN0aW9uYXJ5fCBhbmQgb25seSAiZXF1YWwiLCAibm90CmVxdWFsIiBhbmQgImlzIiBjYW4gYmUgdXNlZC4gIFRoaXMgY29tcGFyZXMgdGhlIGtleS92YWx1ZXMgb2YgdGhlIHxEaWN0aW9uYXJ5fApyZWN1cnNpdmVseS4gIElnbm9yaW5nIGNhc2UgbWVhbnMgY2FzZSBpcyBpZ25vcmVkIHdoZW4gY29tcGFyaW5nIGl0ZW0gdmFsdWVzLgoKCQkJCQkJCSpFNjk0KgpBIHxGdW5jcmVmfCBjYW4gb25seSBiZSBjb21wYXJlZCB3aXRoIGEgfEZ1bmNyZWZ8IGFuZCBvbmx5ICJlcXVhbCIgYW5kICJub3QKZXF1YWwiIGNhbiBiZSB1c2VkLiAgQ2FzZSBpcyBuZXZlciBpZ25vcmVkLiAgV2hldGhlciBhcmd1bWVudHMgb3IgYSBEaWN0aW9uYXJ5CmFyZSBib3VuZCAod2l0aCBhIHBhcnRpYWwpIGlzIGlnbm9yZWQuICBUaGlzIGlzIHNvIHRoYXQgd2hlbiBhIGZ1bmN0aW9uIGlzCm1hZGUgYSBtZW1iZXIgb2YgYSBEaWN0aW9uYXJ5IGl0IGlzIHN0aWxsIGNvbnNpZGVyZWQgdG8gYmUgdGhlIHNhbWUgZnVuY3Rpb24uClRvIGNvbXBhcmUgcGFydGlhbHMgdG8gc2VlIGlmIHRoZXkgYmluZCB0aGUgc2FtZSBhcmd1bWVudCBhbmQgRGljdGlvbmFyeQp2YWx1ZXMgdXNlIHN0cmluZygpOiA+CgllY2hvIHN0cmluZyhQYXJ0aWFsMSkgPT0gc3RyaW5nKFBhcnRpYWwyKQoKV2hlbiB1c2luZyAiaXMiIG9yICJpc25vdCIgd2l0aCBhIHxMaXN0fCBvciBhIHxEaWN0aW9uYXJ5fCB0aGlzIGNoZWNrcyBpZiB0aGUKZXhwcmVzc2lvbnMgYXJlIHJlZmVycmluZyB0byB0aGUgc2FtZSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8IGluc3RhbmNlLiAgQSBjb3B5Cm9mIGEgfExpc3R8IGlzIGRpZmZlcmVudCBmcm9tIHRoZSBvcmlnaW5hbCB8TGlzdHwuICBXaGVuIHVzaW5nICJpcyIgd2l0aG91dAphIHxMaXN0fCBvciBhIHxEaWN0aW9uYXJ5fCBpdCBpcyBlcXVpdmFsZW50IHRvIHVzaW5nICJlcXVhbCIsIHVzaW5nICJpc25vdCIKZXF1aXZhbGVudCB0byB1c2luZyAibm90IGVxdWFsIi4gIEV4Y2VwdCB0aGF0IGEgZGlmZmVyZW50IHR5cGUgbWVhbnMgdGhlCnZhbHVlcyBhcmUgZGlmZmVyZW50OiA+CgllY2hvIDQgPT0gJzQnCgkxCgllY2hvIDQgaXMgJzQnCgkwCgllY2hvIDAgaXMgW10KCTAKImlzIyIvImlzbm90IyIgYW5kICJpcz8iLyJpc25vdD8iIGNhbiBiZSB1c2VkIHRvIG1hdGNoIGFuZCBpZ25vcmUgY2FzZS4KCldoZW4gY29tcGFyaW5nIGEgU3RyaW5nIHdpdGggYSBOdW1iZXIsIHRoZSBTdHJpbmcgaXMgY29udmVydGVkIHRvIGEgTnVtYmVyLAphbmQgdGhlIGNvbXBhcmlzb24gaXMgZG9uZSBvbiBOdW1iZXJzLglUaGlzIG1lYW5zIHRoYXQ6ID4KCWVjaG8gMCA9PSAneCcKCTEKYmVjYXVzZSAneCcgY29udmVydGVkIHRvIGEgTnVtYmVyIGlzIHplcm8uICBIb3dldmVyOiA+CgllY2hvIFswXSA9PSBbJ3gnXQoJMApJbnNpZGUgYSBMaXN0IG9yIERpY3Rpb25hcnkgdGhpcyBjb252ZXJzaW9uIGlzIG5vdCB1c2VkLgoKV2hlbiBjb21wYXJpbmcgdHdvIFN0cmluZ3MsIHRoaXMgaXMgZG9uZSB3aXRoIHN0cmNtcCgpIG9yIHN0cmljbXAoKS4gIFRoaXMKcmVzdWx0cyBpbiB0aGUgbWF0aGVtYXRpY2FsIGRpZmZlcmVuY2UgKGNvbXBhcmluZyBieXRlIHZhbHVlcyksIG5vdApuZWNlc3NhcmlseSB0aGUgYWxwaGFiZXRpY2FsIGRpZmZlcmVuY2UgaW4gdGhlIGxvY2FsIGxhbmd1YWdlLgoKV2hlbiB1c2luZyB0aGUgb3BlcmF0b3JzIHdpdGggYSB0cmFpbGluZyAnIycsIG9yIHRoZSBzaG9ydCB2ZXJzaW9uIGFuZAonaWdub3JlY2FzZScgaXMgb2ZmLCB0aGUgY29tcGFyaW5nIGlzIGRvbmUgd2l0aCBzdHJjbXAoKTogY2FzZSBtYXR0ZXJzLgoKV2hlbiB1c2luZyB0aGUgb3BlcmF0b3JzIHdpdGggYSB0cmFpbGluZyAnPycsIG9yIHRoZSBzaG9ydCB2ZXJzaW9uIGFuZAonaWdub3JlY2FzZScgaXMgc2V0LCB0aGUgY29tcGFyaW5nIGlzIGRvbmUgd2l0aCBzdHJpY21wKCk6IGNhc2UgaXMgaWdub3JlZC4KCidzbWFydGNhc2UnIGlzIG5vdCB1c2VkLgoKVGhlICI9fiIgYW5kICIhfiIgb3BlcmF0b3JzIG1hdGNoIHRoZSBsZWZ0aGFuZCBhcmd1bWVudCB3aXRoIHRoZSByaWdodGhhbmQKYXJndW1lbnQsIHdoaWNoIGlzIHVzZWQgYXMgYSBwYXR0ZXJuLiAgU2VlIHxwYXR0ZXJufCBmb3Igd2hhdCBhIHBhdHRlcm4gaXMuClRoaXMgbWF0Y2hpbmcgaXMgYWx3YXlzIGRvbmUgbGlrZSAnbWFnaWMnIHdhcyBzZXQgYW5kICdjcG9wdGlvbnMnIGlzIGVtcHR5LCBubwptYXR0ZXIgd2hhdCB0aGUgYWN0dWFsIHZhbHVlIG9mICdtYWdpYycgb3IgJ2Nwb3B0aW9ucycgaXMuICBUaGlzIG1ha2VzIHNjcmlwdHMKcG9ydGFibGUuICBUbyBhdm9pZCBiYWNrc2xhc2hlcyBpbiB0aGUgcmVnZXhwIHBhdHRlcm4gdG8gYmUgZG91YmxlZCwgdXNlIGEKc2luZ2xlLXF1b3RlIHN0cmluZywgc2VlIHxsaXRlcmFsLXN0cmluZ3wuClNpbmNlIGEgc3RyaW5nIGlzIGNvbnNpZGVyZWQgdG8gYmUgYSBzaW5nbGUgbGluZSwgYSBtdWx0aS1saW5lIHBhdHRlcm4KKGNvbnRhaW5pbmcgXG4sIGJhY2tzbGFzaC1uKSB3aWxsIG5vdCBtYXRjaC4gIEhvd2V2ZXIsIGEgbGl0ZXJhbCBOTCBjaGFyYWN0ZXIKY2FuIGJlIG1hdGNoZWQgbGlrZSBhbiBvcmRpbmFyeSBjaGFyYWN0ZXIuICBFeGFtcGxlczoKCSJmb29cbmJhciIgPX4gIlxuIglldmFsdWF0ZXMgdG8gMQoJImZvb1xuYmFyIiA9fiAiXFxuIglldmFsdWF0ZXMgdG8gMAoKCmV4cHI1IGFuZCBleHByNgkJCQkJCSpleHByNSogKmV4cHI2KgotLS0tLS0tLS0tLS0tLS0KZXhwcjYgKwkgZXhwcjYgLi4JTnVtYmVyIGFkZGl0aW9uIG9yIHxMaXN0fCBjb25jYXRlbmF0aW9uCSpleHByLSsqCmV4cHI2IC0JIGV4cHI2IC4uCU51bWJlciBzdWJ0cmFjdGlvbgkJCSpleHByLS0qCmV4cHI2IC4JIGV4cHI2IC4uCVN0cmluZyBjb25jYXRlbmF0aW9uCQkJKmV4cHItLioKCkZvciB8TGlzdHN8IG9ubHkgIisiIGlzIHBvc3NpYmxlIGFuZCB0aGVuIGJvdGggZXhwcjYgbXVzdCBiZSBhIGxpc3QuICBUaGUKcmVzdWx0IGlzIGEgbmV3IGxpc3Qgd2l0aCB0aGUgdHdvIGxpc3RzIENvbmNhdGVuYXRlZC4KCmV4cHI3ICoJIGV4cHI3IC4uCU51bWJlciBtdWx0aXBsaWNhdGlvbgkJCSpleHByLXN0YXIqCmV4cHI3IC8JIGV4cHI3IC4uCU51bWJlciBkaXZpc2lvbgkJCQkqZXhwci0vKgpleHByNyAlCSBleHByNyAuLglOdW1iZXIgbW9kdWxvCQkJCSpleHByLSUqCgpGb3IgYWxsLCBleGNlcHQgIi4iLCBTdHJpbmdzIGFyZSBjb252ZXJ0ZWQgdG8gTnVtYmVycy4KRm9yIGJpdHdpc2Ugb3BlcmF0b3JzIHNlZSB8YW5kKCl8LCB8b3IoKXwgYW5kIHx4b3IoKXwuCgpOb3RlIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gIisiIGFuZCAiLiI6CgkiMTIzIiArICI0NTYiID0gNTc5CgkiMTIzIiAuICI0NTYiID0gIjEyMzQ1NiIKClNpbmNlICcuJyBoYXMgdGhlIHNhbWUgcHJlY2VkZW5jZSBhcyAnKycgYW5kICctJywgeW91IG5lZWQgdG8gcmVhZDogPgoJMSAuIDkwICsgOTAuMApBczogPgoJKDEgLiA5MCkgKyA5MC4wClRoYXQgd29ya3MsIHNpbmNlIHRoZSBTdHJpbmcgIjE5MCIgaXMgYXV0b21hdGljYWxseSBjb252ZXJ0ZWQgdG8gdGhlIE51bWJlcgoxOTAsIHdoaWNoIGNhbiBiZSBhZGRlZCB0byB0aGUgRmxvYXQgOTAuMC4gIEhvd2V2ZXI6ID4KCTEgLiA5MCAqIDkwLjAKU2hvdWxkIGJlIHJlYWQgYXM6ID4KCTEgLiAoOTAgKiA5MC4wKQpTaW5jZSAnLicgaGFzIGxvd2VyIHByZWNlZGVuY2UgdGhhbiAnKicuICBUaGlzIGRvZXMgTk9UIHdvcmssIHNpbmNlIHRoaXMKYXR0ZW1wdHMgdG8gY29uY2F0ZW5hdGUgYSBGbG9hdCBhbmQgYSBTdHJpbmcuCgpXaGVuIGRpdmlkaW5nIGEgTnVtYmVyIGJ5IHplcm8gdGhlIHJlc3VsdCBkZXBlbmRzIG9uIHRoZSB2YWx1ZToKCSAgMCAvIDAgID0gLTB4ODAwMDAwMDAJKGxpa2UgTmFOIGZvciBGbG9hdCkKCSA+MCAvIDAgID0gIDB4N2ZmZmZmZmYJKGxpa2UgcG9zaXRpdmUgaW5maW5pdHkpCgkgPDAgLyAwICA9IC0weDdmZmZmZmZmCShsaWtlIG5lZ2F0aXZlIGluZmluaXR5KQoJKGJlZm9yZSBWaW0gNy4yIGl0IHdhcyBhbHdheXMgMHg3ZmZmZmZmZikKCldoZW4gdGhlIHJpZ2h0aGFuZCBzaWRlIG9mICclJyBpcyB6ZXJvLCB0aGUgcmVzdWx0IGlzIDAuCgpOb25lIG9mIHRoZXNlIHdvcmsgZm9yIHxGdW5jcmVmfHMuCgouIGFuZCAlIGRvIG5vdCB3b3JrIGZvciBGbG9hdC4gKkU4MDQqCgoKZXhwcjcJCQkJCQkJKmV4cHI3KgotLS0tLQohIGV4cHI3CQkJbG9naWNhbCBOT1QJCSpleHByLSEqCi0gZXhwcjcJCQl1bmFyeSBtaW51cwkJKmV4cHItdW5hcnktLSoKKyBleHByNwkJCXVuYXJ5IHBsdXMJCSpleHByLXVuYXJ5LSsqCgpGb3IgJyEnIG5vbi16ZXJvIGJlY29tZXMgemVybywgemVybyBiZWNvbWVzIG9uZS4KRm9yICctJyB0aGUgc2lnbiBvZiB0aGUgbnVtYmVyIGlzIGNoYW5nZWQuCkZvciAnKycgdGhlIG51bWJlciBpcyB1bmNoYW5nZWQuCgpBIFN0cmluZyB3aWxsIGJlIGNvbnZlcnRlZCB0byBhIE51bWJlciBmaXJzdC4KClRoZXNlIHRocmVlIGNhbiBiZSByZXBlYXRlZCBhbmQgbWl4ZWQuCUV4YW1wbGVzOgoJIS0xCSAgICA9PSAwCgkhITgJICAgID09IDEKCS0tOQkgICAgPT0gOQoKCmV4cHI4CQkJCQkJCSpleHByOCoKLS0tLS0KZXhwcjhbZXhwcjFdCQlpdGVtIG9mIFN0cmluZyBvciB8TGlzdHwJKmV4cHItW10qICpFMTExKgoJCQkJCQkJKkU5MDkqICpzdWJzY3JpcHQqCklmIGV4cHI4IGlzIGEgTnVtYmVyIG9yIFN0cmluZyB0aGlzIHJlc3VsdHMgaW4gYSBTdHJpbmcgdGhhdCBjb250YWlucyB0aGUKZXhwcjEndGggc2luZ2xlIGJ5dGUgZnJvbSBleHByOC4gIGV4cHI4IGlzIHVzZWQgYXMgYSBTdHJpbmcsIGV4cHIxIGFzIGEKTnVtYmVyLiAgVGhpcyBkb2Vzbid0IHJlY29nbml6ZSBtdWx0aS1ieXRlIGVuY29kaW5ncywgc2VlIHxieXRlaWR4KCl8IGZvcgphbiBhbHRlcm5hdGl2ZSwgb3IgdXNlIGBzcGxpdCgpYCB0byB0dXJuIHRoZSBzdHJpbmcgaW50byBhIGxpc3Qgb2YgY2hhcmFjdGVycy4KCkluZGV4IHplcm8gZ2l2ZXMgdGhlIGZpcnN0IGJ5dGUuICBUaGlzIGlzIGxpa2UgaXQgd29ya3MgaW4gQy4gIENhcmVmdWw6CnRleHQgY29sdW1uIG51bWJlcnMgc3RhcnQgd2l0aCBvbmUhICBFeGFtcGxlLCB0byBnZXQgdGhlIGJ5dGUgdW5kZXIgdGhlCmN1cnNvcjogPgoJOmxldCBjID0gZ2V0bGluZSgiLiIpW2NvbCgiLiIpIC0gMV0KCklmIHRoZSBsZW5ndGggb2YgdGhlIFN0cmluZyBpcyBsZXNzIHRoYW4gdGhlIGluZGV4LCB0aGUgcmVzdWx0IGlzIGFuIGVtcHR5ClN0cmluZy4gIEEgbmVnYXRpdmUgaW5kZXggYWx3YXlzIHJlc3VsdHMgaW4gYW4gZW1wdHkgc3RyaW5nIChyZWFzb246IGJhY2t3YXJkCmNvbXBhdGliaWxpdHkpLiAgVXNlIFstMTpdIHRvIGdldCB0aGUgbGFzdCBieXRlLgoKSWYgZXhwcjggaXMgYSB8TGlzdHwgdGhlbiBpdCByZXN1bHRzIHRoZSBpdGVtIGF0IGluZGV4IGV4cHIxLiAgU2VlIHxsaXN0LWluZGV4fApmb3IgcG9zc2libGUgaW5kZXggdmFsdWVzLiAgSWYgdGhlIGluZGV4IGlzIG91dCBvZiByYW5nZSB0aGlzIHJlc3VsdHMgaW4gYW4KZXJyb3IuCUV4YW1wbGU6ID4KCTpsZXQgaXRlbSA9IG15bGlzdFstMV0JCSIgZ2V0IGxhc3QgaXRlbQoKR2VuZXJhbGx5LCBpZiBhIHxMaXN0fCBpbmRleCBpcyBlcXVhbCB0byBvciBoaWdoZXIgdGhhbiB0aGUgbGVuZ3RoIG9mIHRoZQp8TGlzdHwsIG9yIG1vcmUgbmVnYXRpdmUgdGhhbiB0aGUgbGVuZ3RoIG9mIHRoZSB8TGlzdHwsIHRoaXMgcmVzdWx0cyBpbiBhbgplcnJvci4KCgpleHByOFtleHByMWEgOiBleHByMWJdCXN1YnN0cmluZyBvciBzdWJsaXN0CQkqZXhwci1bOl0qCgpJZiBleHByOCBpcyBhIE51bWJlciBvciBTdHJpbmcgdGhpcyByZXN1bHRzIGluIHRoZSBzdWJzdHJpbmcgd2l0aCB0aGUgYnl0ZXMKZnJvbSBleHByMWEgdG8gYW5kIGluY2x1ZGluZyBleHByMWIuICBleHByOCBpcyB1c2VkIGFzIGEgU3RyaW5nLCBleHByMWEgYW5kCmV4cHIxYiBhcmUgdXNlZCBhcyBhIE51bWJlci4gIFRoaXMgZG9lc24ndCByZWNvZ25pemUgbXVsdGktYnl0ZSBlbmNvZGluZ3MsIHNlZQp8Ynl0ZWlkeCgpfCBmb3IgY29tcHV0aW5nIHRoZSBpbmRleGVzLgoKSWYgZXhwcjFhIGlzIG9taXR0ZWQgemVybyBpcyB1c2VkLiAgSWYgZXhwcjFiIGlzIG9taXR0ZWQgdGhlIGxlbmd0aCBvZiB0aGUKc3RyaW5nIG1pbnVzIG9uZSBpcyB1c2VkLgoKQSBuZWdhdGl2ZSBudW1iZXIgY2FuIGJlIHVzZWQgdG8gbWVhc3VyZSBmcm9tIHRoZSBlbmQgb2YgdGhlIHN0cmluZy4gIC0xIGlzCnRoZSBsYXN0IGNoYXJhY3RlciwgLTIgdGhlIGxhc3QgYnV0IG9uZSwgZXRjLgoKSWYgYW4gaW5kZXggZ29lcyBvdXQgb2YgcmFuZ2UgZm9yIHRoZSBzdHJpbmcgY2hhcmFjdGVycyBhcmUgb21pdHRlZC4gIElmCmV4cHIxYiBpcyBzbWFsbGVyIHRoYW4gZXhwcjFhIHRoZSByZXN1bHQgaXMgYW4gZW1wdHkgc3RyaW5nLgoKRXhhbXBsZXM6ID4KCTpsZXQgYyA9IG5hbWVbLTE6XQkJIiBsYXN0IGJ5dGUgb2YgYSBzdHJpbmcKCTpsZXQgYyA9IG5hbWVbLTI6LTJdCQkiIGxhc3QgYnV0IG9uZSBieXRlIG9mIGEgc3RyaW5nCgk6bGV0IHMgPSBsaW5lKCIuIilbNDpdCQkiIGZyb20gdGhlIGZpZnRoIGJ5dGUgdG8gdGhlIGVuZAoJOmxldCBzID0gc1s6LTNdCQkJIiByZW1vdmUgbGFzdCB0d28gYnl0ZXMKPAoJCQkJCQkJKnN1Ymxpc3QqICpzbGljZSoKSWYgZXhwcjggaXMgYSB8TGlzdHwgdGhpcyByZXN1bHRzIGluIGEgbmV3IHxMaXN0fCB3aXRoIHRoZSBpdGVtcyBpbmRpY2F0ZWQgYnkKdGhlIGluZGV4ZXMgZXhwcjFhIGFuZCBleHByMWIuCVRoaXMgd29ya3MgbGlrZSB3aXRoIGEgU3RyaW5nLCBhcyBleHBsYWluZWQKanVzdCBhYm92ZSwgZXhjZXB0IHRoYXQgaW5kZXhlcyBvdXQgb2YgcmFuZ2UgY2F1c2UgYW4gZXJyb3IuICBFeGFtcGxlczogPgoJOmxldCBsID0gbXlsaXN0WzozXQkJIiBmaXJzdCBmb3VyIGl0ZW1zCgk6bGV0IGwgPSBteWxpc3RbNDo0XQkJIiBMaXN0IHdpdGggb25lIGl0ZW0KCTpsZXQgbCA9IG15bGlzdFs6XQkJIiBzaGFsbG93IGNvcHkgb2YgYSBMaXN0CgpVc2luZyBleHByOFtleHByMV0gb3IgZXhwcjhbZXhwcjFhIDogZXhwcjFiXSBvbiBhIHxGdW5jcmVmfCByZXN1bHRzIGluIGFuCmVycm9yLgoKV2F0Y2ggb3V0IGZvciBjb25mdXNpb24gYmV0d2VlbiBhIG5hbWVzcGFjZSBhbmQgYSB2YXJpYWJsZSBmb2xsb3dlZCBieSBhIGNvbG9uCmZvciBhIHN1Ymxpc3Q6ID4KCW15bGlzdFtuOl0gICAgICIgdXNlcyB2YXJpYWJsZSBuCglteWxpc3RbczpdICAgICAiIHVzZXMgbmFtZXNwYWNlIHM6LCBlcnJvciEKCgpleHByOC5uYW1lCQllbnRyeSBpbiBhIHxEaWN0aW9uYXJ5fAkJKmV4cHItZW50cnkqCgpJZiBleHByOCBpcyBhIHxEaWN0aW9uYXJ5fCBhbmQgaXQgaXMgZm9sbG93ZWQgYnkgYSBkb3QsIHRoZW4gdGhlIGZvbGxvd2luZwpuYW1lIHdpbGwgYmUgdXNlZCBhcyBhIGtleSBpbiB0aGUgfERpY3Rpb25hcnl8LiAgVGhpcyBpcyBqdXN0IGxpa2U6CmV4cHI4W25hbWVdLgoKVGhlIG5hbWUgbXVzdCBjb25zaXN0IG9mIGFscGhhbnVtZXJpYyBjaGFyYWN0ZXJzLCBqdXN0IGxpa2UgYSB2YXJpYWJsZSBuYW1lLApidXQgaXQgbWF5IHN0YXJ0IHdpdGggYSBudW1iZXIuICBDdXJseSBicmFjZXMgY2Fubm90IGJlIHVzZWQuCgpUaGVyZSBtdXN0IG5vdCBiZSB3aGl0ZSBzcGFjZSBiZWZvcmUgb3IgYWZ0ZXIgdGhlIGRvdC4KCkV4YW1wbGVzOiA+Cgk6bGV0IGRpY3QgPSB7Im9uZSI6IDEsIDI6ICJ0d28ifQoJOmVjaG8gZGljdC5vbmUKCTplY2hvIGRpY3QgLjIKCk5vdGUgdGhhdCB0aGUgZG90IGlzIGFsc28gdXNlZCBmb3IgU3RyaW5nIGNvbmNhdGVuYXRpb24uICBUbyBhdm9pZCBjb25mdXNpb24KYWx3YXlzIHB1dCBzcGFjZXMgYXJvdW5kIHRoZSBkb3QgZm9yIFN0cmluZyBjb25jYXRlbmF0aW9uLgoKCmV4cHI4KGV4cHIxLCAuLi4pCXxGdW5jcmVmfCBmdW5jdGlvbiBjYWxsCgpXaGVuIGV4cHI4IGlzIGEgfEZ1bmNyZWZ8IHR5cGUgdmFyaWFibGUsIGludm9rZSB0aGUgZnVuY3Rpb24gaXQgcmVmZXJzIHRvLgoKCgoJCQkJCQkJKmV4cHI5KgpudW1iZXIKLS0tLS0tCm51bWJlcgkJCW51bWJlciBjb25zdGFudAkJCSpleHByLW51bWJlciogCgkJCQkJCSpoZXgtbnVtYmVyKiAqb2N0YWwtbnVtYmVyKgoKRGVjaW1hbCwgSGV4YWRlY2ltYWwgKHN0YXJ0aW5nIHdpdGggMHggb3IgMFgpLCBvciBPY3RhbCAoc3RhcnRpbmcgd2l0aCAwKS4KCgkJCQkJCSpmbG9hdGluZy1wb2ludC1mb3JtYXQqCkZsb2F0aW5nIHBvaW50IG51bWJlcnMgY2FuIGJlIHdyaXR0ZW4gaW4gdHdvIGZvcm1zOgoKCVstK117Tn0ue019CglbLStde059LntNfVtlRV1bLStde2V4cH0KCntOfSBhbmQge019IGFyZSBudW1iZXJzLiAgQm90aCB7Tn0gYW5kIHtNfSBtdXN0IGJlIHByZXNlbnQgYW5kIGNhbiBvbmx5CmNvbnRhaW4gZGlnaXRzLgpbLStdIG1lYW5zIHRoZXJlIGlzIGFuIG9wdGlvbmFsIHBsdXMgb3IgbWludXMgc2lnbi4Ke2V4cH0gaXMgdGhlIGV4cG9uZW50LCBwb3dlciBvZiAxMC4KT25seSBhIGRlY2ltYWwgcG9pbnQgaXMgYWNjZXB0ZWQsIG5vdCBhIGNvbW1hLglObyBtYXR0ZXIgd2hhdCB0aGUgY3VycmVudApsb2NhbGUgaXMuCntvbmx5IHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCkV4YW1wbGVzOgoJMTIzLjQ1NgoJKzAuMDAwMQoJNTUuMAoJLTAuMTIzCgkxLjIzNGUwMwoJMS4wRS02CgktMy4xNDE2ZSs4OAoKVGhlc2UgYXJlIElOVkFMSUQ6CgkzLgkJZW1wdHkge019CgkxZTQwCQltaXNzaW5nIC57TX0KCgkJCQkJCQkqZmxvYXQtcGkqICpmbG9hdC1lKgpBIGZldyB1c2VmdWwgdmFsdWVzIHRvIGNvcHkmcGFzdGU6ID4KCTpsZXQgcGkgPSAzLjE0MTU5MjY1MzU5Cgk6bGV0IGUgID0gMi43MTgyODE4Mjg0NgoKUmF0aW9uYWxlOgpCZWZvcmUgZmxvYXRpbmcgcG9pbnQgd2FzIGludHJvZHVjZWQsIHRoZSB0ZXh0ICIxMjMuNDU2IiB3YXMgaW50ZXJwcmV0ZWQgYXMKdGhlIHR3byBudW1iZXJzICIxMjMiIGFuZCAiNDU2IiwgYm90aCBjb252ZXJ0ZWQgdG8gYSBzdHJpbmcgYW5kIGNvbmNhdGVuYXRlZCwKcmVzdWx0aW5nIGluIHRoZSBzdHJpbmcgIjEyMzQ1NiIuICBTaW5jZSB0aGlzIHdhcyBjb25zaWRlcmVkIHBvaW50bGVzcywgYW5kIHdlCmNvdWxkIG5vdCBmaW5kIGl0IGludGVudGlvbmFsbHkgYmVpbmcgdXNlZCBpbiBWaW0gc2NyaXB0cywgdGhpcyBiYWNrd2FyZHMKaW5jb21wYXRpYmlsaXR5IHdhcyBhY2NlcHRlZCBpbiBmYXZvciBvZiBiZWluZyBhYmxlIHRvIHVzZSB0aGUgbm9ybWFsIG5vdGF0aW9uCmZvciBmbG9hdGluZyBwb2ludCBudW1iZXJzLgoKCQkJCQkJKmZsb2F0aW5nLXBvaW50LXByZWNpc2lvbioKVGhlIHByZWNpc2lvbiBhbmQgcmFuZ2Ugb2YgZmxvYXRpbmcgcG9pbnRzIG51bWJlcnMgZGVwZW5kcyBvbiB3aGF0ICJkb3VibGUiCm1lYW5zIGluIHRoZSBsaWJyYXJ5IFZpbSB3YXMgY29tcGlsZWQgd2l0aC4gIFRoZXJlIGlzIG5vIHdheSB0byBjaGFuZ2UgdGhpcyBhdApydW50aW1lLgoKVGhlIGRlZmF1bHQgZm9yIGRpc3BsYXlpbmcgYSB8RmxvYXR8IGlzIHRvIHVzZSA2IGRlY2ltYWwgcGxhY2VzLCBsaWtlIHVzaW5nCnByaW50ZigiJWciLCBmKS4gIFlvdSBjYW4gc2VsZWN0IHNvbWV0aGluZyBlbHNlIHdoZW4gdXNpbmcgdGhlIHxwcmludGYoKXwKZnVuY3Rpb24uICBFeGFtcGxlOiA+Cgk6ZWNobyBwcmludGYoJyUuMTVlJywgYXRhbigxKSkKPAk3Ljg1Mzk4MTYzMzk3NDQ4M2UtMDEKCgoKc3RyaW5nCQkJCQkqc3RyaW5nKiAqU3RyaW5nKiAqZXhwci1zdHJpbmcqICpFMTE0KgotLS0tLS0KInN0cmluZyIJCXN0cmluZyBjb25zdGFudAkJKmV4cHItcXVvdGUqCgpOb3RlIHRoYXQgZG91YmxlIHF1b3RlcyBhcmUgdXNlZC4KCkEgc3RyaW5nIGNvbnN0YW50IGFjY2VwdHMgdGhlc2Ugc3BlY2lhbCBjaGFyYWN0ZXJzOgpcLi4uCXRocmVlLWRpZ2l0IG9jdGFsIG51bWJlciAoZS5nLiwgIlwzMTYiKQpcLi4JdHdvLWRpZ2l0IG9jdGFsIG51bWJlciAobXVzdCBiZSBmb2xsb3dlZCBieSBub24tZGlnaXQpClwuCW9uZS1kaWdpdCBvY3RhbCBudW1iZXIgKG11c3QgYmUgZm9sbG93ZWQgYnkgbm9uLWRpZ2l0KQpceC4uCWJ5dGUgc3BlY2lmaWVkIHdpdGggdHdvIGhleCBudW1iZXJzIChlLmcuLCAiXHgxZiIpClx4LglieXRlIHNwZWNpZmllZCB3aXRoIG9uZSBoZXggbnVtYmVyIChtdXN0IGJlIGZvbGxvd2VkIGJ5IG5vbi1oZXggY2hhcikKXFguLglzYW1lIGFzIFx4Li4KXFguCXNhbWUgYXMgXHguClx1Li4uLgljaGFyYWN0ZXIgc3BlY2lmaWVkIHdpdGggdXAgdG8gNCBoZXggbnVtYmVycywgc3RvcmVkIGFjY29yZGluZyB0byB0aGUKCWN1cnJlbnQgdmFsdWUgb2YgJ2VuY29kaW5nJyAoZS5nLiwgIlx1MDJhNCIpClxVLi4uLglzYW1lIGFzIFx1IGJ1dCBhbGxvd3MgdXAgdG8gOCBoZXggbnVtYmVycy4KXGIJYmFja3NwYWNlIDxCUz4KXGUJZXNjYXBlIDxFc2M+ClxmCWZvcm1mZWVkIDxGRj4KXG4JbmV3bGluZSA8Tkw+ClxyCXJldHVybiA8Q1I+Clx0CXRhYiA8VGFiPgpcXAliYWNrc2xhc2gKXCIJZG91YmxlIHF1b3RlClw8eHh4PglTcGVjaWFsIGtleSBuYW1lZCAieHh4Ii4gIGUuZy4gIlw8Qy1XPiIgZm9yIENUUkwtVy4gIFRoaXMgaXMgZm9yIHVzZQoJaW4gbWFwcGluZ3MsIHRoZSAweDgwIGJ5dGUgaXMgZXNjYXBlZC4gIERvbid0IHVzZSA8Q2hhci14eHh4PiB0byBnZXQgYQoJdXRmLTggY2hhcmFjdGVyLCB1c2UgXHV4eHh4IGFzIG1lbnRpb25lZCBhYm92ZS4KCk5vdGUgdGhhdCAiXHhmZiIgaXMgc3RvcmVkIGFzIHRoZSBieXRlIDI1NSwgd2hpY2ggbWF5IGJlIGludmFsaWQgaW4gc29tZQplbmNvZGluZ3MuICBVc2UgIlx1MDBmZiIgdG8gc3RvcmUgY2hhcmFjdGVyIDI1NSBhY2NvcmRpbmcgdG8gdGhlIGN1cnJlbnQgdmFsdWUKb2YgJ2VuY29kaW5nJy4KCk5vdGUgdGhhdCAiXDAwMCIgYW5kICJceDAwIiBmb3JjZSB0aGUgZW5kIG9mIHRoZSBzdHJpbmcuCgoKbGl0ZXJhbC1zdHJpbmcJCQkJCQkqbGl0ZXJhbC1zdHJpbmcqICpFMTE1KgotLS0tLS0tLS0tLS0tLS0KJ3N0cmluZycJCXN0cmluZyBjb25zdGFudAkJCSpleHByLScqCgpOb3RlIHRoYXQgc2luZ2xlIHF1b3RlcyBhcmUgdXNlZC4KClRoaXMgc3RyaW5nIGlzIHRha2VuIGFzIGl0IGlzLglObyBiYWNrc2xhc2hlcyBhcmUgcmVtb3ZlZCBvciBoYXZlIGEgc3BlY2lhbAptZWFuaW5nLiAgVGhlIG9ubHkgZXhjZXB0aW9uIGlzIHRoYXQgdHdvIHF1b3RlcyBzdGFuZCBmb3Igb25lIHF1b3RlLgoKU2luZ2xlIHF1b3RlZCBzdHJpbmdzIGFyZSB1c2VmdWwgZm9yIHBhdHRlcm5zLCBzbyB0aGF0IGJhY2tzbGFzaGVzIGRvIG5vdCBuZWVkCnRvIGJlIGRvdWJsZWQuCVRoZXNlIHR3byBjb21tYW5kcyBhcmUgZXF1aXZhbGVudDogPgoJaWYgYSA9fiAiXFxzKiIKCWlmIGEgPX4gJ1xzKicKCgpvcHRpb24JCQkJCQkqZXhwci1vcHRpb24qICpFMTEyKiAqRTExMyoKLS0tLS0tCiZvcHRpb24JCQlvcHRpb24gdmFsdWUsIGxvY2FsIHZhbHVlIGlmIHBvc3NpYmxlCiZnOm9wdGlvbgkJZ2xvYmFsIG9wdGlvbiB2YWx1ZQombDpvcHRpb24JCWxvY2FsIG9wdGlvbiB2YWx1ZQoKRXhhbXBsZXM6ID4KCWVjaG8gInRhYnN0b3AgaXMgIiAuICZ0YWJzdG9wCglpZiAmaW5zZXJ0bW9kZQoKQW55IG9wdGlvbiBuYW1lIGNhbiBiZSB1c2VkIGhlcmUuICBTZWUgfG9wdGlvbnN8LiAgV2hlbiB1c2luZyB0aGUgbG9jYWwgdmFsdWUKYW5kIHRoZXJlIGlzIG5vIGJ1ZmZlci1sb2NhbCBvciB3aW5kb3ctbG9jYWwgdmFsdWUsIHRoZSBnbG9iYWwgdmFsdWUgaXMgdXNlZAphbnl3YXkuCgoKcmVnaXN0ZXIJCQkJCQkqZXhwci1yZWdpc3RlciogKkByKgotLS0tLS0tLQpAcgkJCWNvbnRlbnRzIG9mIHJlZ2lzdGVyICdyJwoKVGhlIHJlc3VsdCBpcyB0aGUgY29udGVudHMgb2YgdGhlIG5hbWVkIHJlZ2lzdGVyLCBhcyBhIHNpbmdsZSBzdHJpbmcuCk5ld2xpbmVzIGFyZSBpbnNlcnRlZCB3aGVyZSByZXF1aXJlZC4gIFRvIGdldCB0aGUgY29udGVudHMgb2YgdGhlIHVubmFtZWQKcmVnaXN0ZXIgdXNlIEAiIG9yIEBALglTZWUgfHJlZ2lzdGVyc3wgZm9yIGFuIGV4cGxhbmF0aW9uIG9mIHRoZSBhdmFpbGFibGUKcmVnaXN0ZXJzLgoKV2hlbiB1c2luZyB0aGUgJz0nIHJlZ2lzdGVyIHlvdSBnZXQgdGhlIGV4cHJlc3Npb24gaXRzZWxmLCBub3Qgd2hhdCBpdApldmFsdWF0ZXMgdG8uICBVc2UgfGV2YWwoKXwgdG8gZXZhbHVhdGUgaXQuCgoKbmVzdGluZwkJCQkJCQkqZXhwci1uZXN0aW5nKiAqRTExMCoKLS0tLS0tLQooZXhwcjEpCQkJbmVzdGVkIGV4cHJlc3Npb24KCgplbnZpcm9ubWVudCB2YXJpYWJsZQkJCQkJKmV4cHItZW52KgotLS0tLS0tLS0tLS0tLS0tLS0tLQokVkFSCQkJZW52aXJvbm1lbnQgdmFyaWFibGUKClRoZSBTdHJpbmcgdmFsdWUgb2YgYW55IGVudmlyb25tZW50IHZhcmlhYmxlLiAgV2hlbiBpdCBpcyBub3QgZGVmaW5lZCwgdGhlCnJlc3VsdCBpcyBhbiBlbXB0eSBzdHJpbmcuCgkJCQkJCSpleHByLWVudi1leHBhbmQqCk5vdGUgdGhhdCB0aGVyZSBpcyBhIGRpZmZlcmVuY2UgYmV0d2VlbiB1c2luZyAkVkFSIGRpcmVjdGx5IGFuZCB1c2luZwpleHBhbmQoIiRWQVIiKS4gIFVzaW5nIGl0IGRpcmVjdGx5IHdpbGwgb25seSBleHBhbmQgZW52aXJvbm1lbnQgdmFyaWFibGVzIHRoYXQKYXJlIGtub3duIGluc2lkZSB0aGUgY3VycmVudCBWaW0gc2Vzc2lvbi4gIFVzaW5nIGV4cGFuZCgpIHdpbGwgZmlyc3QgdHJ5IHVzaW5nCnRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZXMga25vd24gaW5zaWRlIHRoZSBjdXJyZW50IFZpbSBzZXNzaW9uLiAgSWYgdGhhdApmYWlscywgYSBzaGVsbCB3aWxsIGJlIHVzZWQgdG8gZXhwYW5kIHRoZSB2YXJpYWJsZS4gIFRoaXMgY2FuIGJlIHNsb3csIGJ1dCBpdApkb2VzIGV4cGFuZCBhbGwgdmFyaWFibGVzIHRoYXQgdGhlIHNoZWxsIGtub3dzIGFib3V0LiAgRXhhbXBsZTogPgoJOmVjaG8gJHNoZWxsCgk6ZWNobyBleHBhbmQoIiRzaGVsbCIpClRoZSBmaXJzdCBvbmUgcHJvYmFibHkgZG9lc24ndCBlY2hvIGFueXRoaW5nLCB0aGUgc2Vjb25kIGVjaG9lcyB0aGUgJHNoZWxsCnZhcmlhYmxlIChpZiB5b3VyIHNoZWxsIHN1cHBvcnRzIGl0KS4KCgppbnRlcm5hbCB2YXJpYWJsZQkJCQkJKmV4cHItdmFyaWFibGUqCi0tLS0tLS0tLS0tLS0tLS0tCnZhcmlhYmxlCQlpbnRlcm5hbCB2YXJpYWJsZQpTZWUgYmVsb3cgfGludGVybmFsLXZhcmlhYmxlc3wuCgoKZnVuY3Rpb24gY2FsbAkJKmV4cHItZnVuY3Rpb24qICpFMTE2KiAqRTExOCogKkUxMTkqICpFMTIwKgotLS0tLS0tLS0tLS0tCmZ1bmN0aW9uKGV4cHIxLCAuLi4pCWZ1bmN0aW9uIGNhbGwKU2VlIGJlbG93IHxmdW5jdGlvbnN8LgoKCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQozLiBJbnRlcm5hbCB2YXJpYWJsZQkJCQkqaW50ZXJuYWwtdmFyaWFibGVzKiAqRTQ2MSoKCkFuIGludGVybmFsIHZhcmlhYmxlIG5hbWUgY2FuIGJlIG1hZGUgdXAgb2YgbGV0dGVycywgZGlnaXRzIGFuZCAnXycuICBCdXQgaXQKY2Fubm90IHN0YXJ0IHdpdGggYSBkaWdpdC4gIEl0J3MgYWxzbyBwb3NzaWJsZSB0byB1c2UgY3VybHkgYnJhY2VzLCBzZWUKfGN1cmx5LWJyYWNlcy1uYW1lc3wuCgpBbiBpbnRlcm5hbCB2YXJpYWJsZSBpcyBjcmVhdGVkIHdpdGggdGhlICI6bGV0IiBjb21tYW5kIHw6bGV0fC4KQW4gaW50ZXJuYWwgdmFyaWFibGUgaXMgZXhwbGljaXRseSBkZXN0cm95ZWQgd2l0aCB0aGUgIjp1bmxldCIgY29tbWFuZAp8OnVubGV0fC4KVXNpbmcgYSBuYW1lIHRoYXQgaXMgbm90IGFuIGludGVybmFsIHZhcmlhYmxlIG9yIHJlZmVycyB0byBhIHZhcmlhYmxlIHRoYXQgaGFzCmJlZW4gZGVzdHJveWVkIHJlc3VsdHMgaW4gYW4gZXJyb3IuCgpUaGVyZSBhcmUgc2V2ZXJhbCBuYW1lIHNwYWNlcyBmb3IgdmFyaWFibGVzLiAgV2hpY2ggb25lIGlzIHRvIGJlIHVzZWQgaXMKc3BlY2lmaWVkIGJ5IHdoYXQgaXMgcHJlcGVuZGVkOgoKCQkobm90aGluZykgSW4gYSBmdW5jdGlvbjogbG9jYWwgdG8gYSBmdW5jdGlvbjsgb3RoZXJ3aXNlOiBnbG9iYWwKfGJ1ZmZlci12YXJpYWJsZXwgICAgYjoJICBMb2NhbCB0byB0aGUgY3VycmVudCBidWZmZXIuCnx3aW5kb3ctdmFyaWFibGV8ICAgIHc6CSAgTG9jYWwgdG8gdGhlIGN1cnJlbnQgd2luZG93Lgp8dGFicGFnZS12YXJpYWJsZXwgICB0OgkgIExvY2FsIHRvIHRoZSBjdXJyZW50IHRhYiBwYWdlLgp8Z2xvYmFsLXZhcmlhYmxlfCAgICBnOgkgIEdsb2JhbC4KfGxvY2FsLXZhcmlhYmxlfCAgICAgbDoJICBMb2NhbCB0byBhIGZ1bmN0aW9uLgp8c2NyaXB0LXZhcmlhYmxlfCAgICBzOgkgIExvY2FsIHRvIGEgfDpzb3VyY2V8J2VkIFZpbSBzY3JpcHQuCnxmdW5jdGlvbi1hcmd1bWVudHwgIGE6CSAgRnVuY3Rpb24gYXJndW1lbnQgKG9ubHkgaW5zaWRlIGEgZnVuY3Rpb24pLgp8dmltLXZhcmlhYmxlfCAgICAgICB2OgkgIEdsb2JhbCwgcHJlZGVmaW5lZCBieSBWaW0uCgpUaGUgc2NvcGUgbmFtZSBieSBpdHNlbGYgY2FuIGJlIHVzZWQgYXMgYSB8RGljdGlvbmFyeXwuICBGb3IgZXhhbXBsZSwgdG8KZGVsZXRlIGFsbCBzY3JpcHQtbG9jYWwgdmFyaWFibGVzOiA+Cgk6Zm9yIGsgaW4ga2V5cyhzOikKCTogICAgdW5sZXQgczpba10KCTplbmRmb3IKPAoJCQkJCQkqYnVmZmVyLXZhcmlhYmxlKiAqYjp2YXIqICpiOioKQSB2YXJpYWJsZSBuYW1lIHRoYXQgaXMgcHJlY2VkZWQgd2l0aCAiYjoiIGlzIGxvY2FsIHRvIHRoZSBjdXJyZW50IGJ1ZmZlci4KVGh1cyB5b3UgY2FuIGhhdmUgc2V2ZXJhbCAiYjpmb28iIHZhcmlhYmxlcywgb25lIGZvciBlYWNoIGJ1ZmZlci4KVGhpcyBraW5kIG9mIHZhcmlhYmxlIGlzIGRlbGV0ZWQgd2hlbiB0aGUgYnVmZmVyIGlzIHdpcGVkIG91dCBvciBkZWxldGVkIHdpdGgKfDpiZGVsZXRlfC4KCk9uZSBsb2NhbCBidWZmZXIgdmFyaWFibGUgaXMgcHJlZGVmaW5lZDoKCQkJCQkqYjpjaGFuZ2VkdGljayogKmNoYW5nZXRpY2sqCmI6Y2hhbmdlZHRpY2sJVGhlIHRvdGFsIG51bWJlciBvZiBjaGFuZ2VzIHRvIHRoZSBjdXJyZW50IGJ1ZmZlci4gIEl0IGlzCgkJaW5jcmVtZW50ZWQgZm9yIGVhY2ggY2hhbmdlLiAgQW4gdW5kbyBjb21tYW5kIGlzIGFsc28gYSBjaGFuZ2UKCQlpbiB0aGlzIGNhc2UuICBUaGlzIGNhbiBiZSB1c2VkIHRvIHBlcmZvcm0gYW4gYWN0aW9uIG9ubHkgd2hlbgoJCXRoZSBidWZmZXIgaGFzIGNoYW5nZWQuICBFeGFtcGxlOiA+CgkJICAgIDppZiBteV9jaGFuZ2VkdGljayAhPSBiOmNoYW5nZWR0aWNrCgkJICAgIDoJbGV0IG15X2NoYW5nZWR0aWNrID0gYjpjaGFuZ2VkdGljawoJCSAgICA6CWNhbGwgTXlfVXBkYXRlKCkKCQkgICAgOmVuZGlmCjwKCQkJCQkJKndpbmRvdy12YXJpYWJsZSogKnc6dmFyKiAqdzoqCkEgdmFyaWFibGUgbmFtZSB0aGF0IGlzIHByZWNlZGVkIHdpdGggInc6IiBpcyBsb2NhbCB0byB0aGUgY3VycmVudCB3aW5kb3cuICBJdAppcyBkZWxldGVkIHdoZW4gdGhlIHdpbmRvdyBpcyBjbG9zZWQuCgoJCQkJCQkqdGFicGFnZS12YXJpYWJsZSogKnQ6dmFyKiAqdDoqCkEgdmFyaWFibGUgbmFtZSB0aGF0IGlzIHByZWNlZGVkIHdpdGggInQ6IiBpcyBsb2NhbCB0byB0aGUgY3VycmVudCB0YWIgcGFnZSwKSXQgaXMgZGVsZXRlZCB3aGVuIHRoZSB0YWIgcGFnZSBpcyBjbG9zZWQuIHtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQKd2l0aG91dCB0aGUgfCt3aW5kb3dzfCBmZWF0dXJlfQoKCQkJCQkJKmdsb2JhbC12YXJpYWJsZSogKmc6dmFyKiAqZzoqCkluc2lkZSBmdW5jdGlvbnMgZ2xvYmFsIHZhcmlhYmxlcyBhcmUgYWNjZXNzZWQgd2l0aCAiZzoiLiAgT21pdHRpbmcgdGhpcyB3aWxsCmFjY2VzcyBhIHZhcmlhYmxlIGxvY2FsIHRvIGEgZnVuY3Rpb24uCUJ1dCAiZzoiIGNhbiBhbHNvIGJlIHVzZWQgaW4gYW55IG90aGVyCnBsYWNlIGlmIHlvdSBsaWtlLgoKCQkJCQkJKmxvY2FsLXZhcmlhYmxlKiAqbDp2YXIqICpsOioKSW5zaWRlIGZ1bmN0aW9ucyBsb2NhbCB2YXJpYWJsZXMgYXJlIGFjY2Vzc2VkIHdpdGhvdXQgcHJlcGVuZGluZyBhbnl0aGluZy4KQnV0IHlvdSBjYW4gYWxzbyBwcmVwZW5kICJsOiIgaWYgeW91IGxpa2UuICBIb3dldmVyLCB3aXRob3V0IHByZXBlbmRpbmcgImw6Igp5b3UgbWF5IHJ1biBpbnRvIHJlc2VydmVkIHZhcmlhYmxlIG5hbWVzLiAgRm9yIGV4YW1wbGUgImNvdW50Ii4gIEJ5IGl0c2VsZiBpdApyZWZlcnMgdG8gInY6Y291bnQiLiAgVXNpbmcgImw6Y291bnQiIHlvdSBjYW4gaGF2ZSBhIGxvY2FsIHZhcmlhYmxlIHdpdGggdGhlCnNhbWUgbmFtZS4KCgkJCQkJCSpzY3JpcHQtdmFyaWFibGUqICpzOnZhcioKSW4gYSBWaW0gc2NyaXB0IHZhcmlhYmxlcyBzdGFydGluZyB3aXRoICJzOiIgY2FuIGJlIHVzZWQuICBUaGV5IGNhbm5vdCBiZQphY2Nlc3NlZCBmcm9tIG91dHNpZGUgb2YgdGhlIHNjcmlwdHMsIHRodXMgYXJlIGxvY2FsIHRvIHRoZSBzY3JpcHQuCgpUaGV5IGNhbiBiZSB1c2VkIGluOgotIGNvbW1hbmRzIGV4ZWN1dGVkIHdoaWxlIHRoZSBzY3JpcHQgaXMgc291cmNlZAotIGZ1bmN0aW9ucyBkZWZpbmVkIGluIHRoZSBzY3JpcHQKLSBhdXRvY29tbWFuZHMgZGVmaW5lZCBpbiB0aGUgc2NyaXB0Ci0gZnVuY3Rpb25zIGFuZCBhdXRvY29tbWFuZHMgZGVmaW5lZCBpbiBmdW5jdGlvbnMgYW5kIGF1dG9jb21tYW5kcyB3aGljaCB3ZXJlCiAgZGVmaW5lZCBpbiB0aGUgc2NyaXB0IChyZWN1cnNpdmVseSkKLSB1c2VyIGRlZmluZWQgY29tbWFuZHMgZGVmaW5lZCBpbiB0aGUgc2NyaXB0ClRodXMgbm90IGluOgotIG90aGVyIHNjcmlwdHMgc291cmNlZCBmcm9tIHRoaXMgb25lCi0gbWFwcGluZ3MKLSBtZW51cwotIGV0Yy4KClNjcmlwdCB2YXJpYWJsZXMgY2FuIGJlIHVzZWQgdG8gYXZvaWQgY29uZmxpY3RzIHdpdGggZ2xvYmFsIHZhcmlhYmxlIG5hbWVzLgpUYWtlIHRoaXMgZXhhbXBsZTogPgoKCWxldCBzOmNvdW50ZXIgPSAwCglmdW5jdGlvbiBNeUNvdW50ZXIoKQoJICBsZXQgczpjb3VudGVyID0gczpjb3VudGVyICsgMQoJICBlY2hvIHM6Y291bnRlcgoJZW5kZnVuY3Rpb24KCWNvbW1hbmQgVGljayBjYWxsIE15Q291bnRlcigpCgpZb3UgY2FuIG5vdyBpbnZva2UgIlRpY2siIGZyb20gYW55IHNjcmlwdCwgYW5kIHRoZSAiczpjb3VudGVyIiB2YXJpYWJsZSBpbgp0aGF0IHNjcmlwdCB3aWxsIG5vdCBiZSBjaGFuZ2VkLCBvbmx5IHRoZSAiczpjb3VudGVyIiBpbiB0aGUgc2NyaXB0IHdoZXJlCiJUaWNrIiB3YXMgZGVmaW5lZCBpcyB1c2VkLgoKQW5vdGhlciBleGFtcGxlIHRoYXQgZG9lcyB0aGUgc2FtZTogPgoKCWxldCBzOmNvdW50ZXIgPSAwCgljb21tYW5kIFRpY2sgbGV0IHM6Y291bnRlciA9IHM6Y291bnRlciArIDEgfCBlY2hvIHM6Y291bnRlcgoKV2hlbiBjYWxsaW5nIGEgZnVuY3Rpb24gYW5kIGludm9raW5nIGEgdXNlci1kZWZpbmVkIGNvbW1hbmQsIHRoZSBjb250ZXh0IGZvcgpzY3JpcHQgdmFyaWFibGVzIGlzIHNldCB0byB0aGUgc2NyaXB0IHdoZXJlIHRoZSBmdW5jdGlvbiBvciBjb21tYW5kIHdhcwpkZWZpbmVkLgoKVGhlIHNjcmlwdCB2YXJpYWJsZXMgYXJlIGFsc28gYXZhaWxhYmxlIHdoZW4gYSBmdW5jdGlvbiBpcyBkZWZpbmVkIGluc2lkZSBhCmZ1bmN0aW9uIHRoYXQgaXMgZGVmaW5lZCBpbiBhIHNjcmlwdC4gIEV4YW1wbGU6ID4KCglsZXQgczpjb3VudGVyID0gMAoJZnVuY3Rpb24gU3RhcnRDb3VudGluZyhpbmNyKQoJICBpZiBhOmluY3IKCSAgICBmdW5jdGlvbiBNeUNvdW50ZXIoKQoJICAgICAgbGV0IHM6Y291bnRlciA9IHM6Y291bnRlciArIDEKCSAgICBlbmRmdW5jdGlvbgoJICBlbHNlCgkgICAgZnVuY3Rpb24gTXlDb3VudGVyKCkKCSAgICAgIGxldCBzOmNvdW50ZXIgPSBzOmNvdW50ZXIgLSAxCgkgICAgZW5kZnVuY3Rpb24KCSAgZW5kaWYKCWVuZGZ1bmN0aW9uCgpUaGlzIGRlZmluZXMgdGhlIE15Q291bnRlcigpIGZ1bmN0aW9uIGVpdGhlciBmb3IgY291bnRpbmcgdXAgb3IgY291bnRpbmcgZG93bgp3aGVuIGNhbGxpbmcgU3RhcnRDb3VudGluZygpLiAgSXQgZG9lc24ndCBtYXR0ZXIgZnJvbSB3aGVyZSBTdGFydENvdW50aW5nKCkgaXMKY2FsbGVkLCB0aGUgczpjb3VudGVyIHZhcmlhYmxlIHdpbGwgYmUgYWNjZXNzaWJsZSBpbiBNeUNvdW50ZXIoKS4KCldoZW4gdGhlIHNhbWUgc2NyaXB0IGlzIHNvdXJjZWQgYWdhaW4gaXQgd2lsbCB1c2UgdGhlIHNhbWUgc2NyaXB0IHZhcmlhYmxlcy4KVGhleSB3aWxsIHJlbWFpbiB2YWxpZCBhcyBsb25nIGFzIFZpbSBpcyBydW5uaW5nLiAgVGhpcyBjYW4gYmUgdXNlZCB0bwptYWludGFpbiBhIGNvdW50ZXI6ID4KCglpZiAhZXhpc3RzKCJzOmNvdW50ZXIiKQoJICBsZXQgczpjb3VudGVyID0gMQoJICBlY2hvICJzY3JpcHQgZXhlY3V0ZWQgZm9yIHRoZSBmaXJzdCB0aW1lIgoJZWxzZQoJICBsZXQgczpjb3VudGVyID0gczpjb3VudGVyICsgMQoJICBlY2hvICJzY3JpcHQgZXhlY3V0ZWQgIiAuIHM6Y291bnRlciAuICIgdGltZXMgbm93IgoJZW5kaWYKCk5vdGUgdGhhdCB0aGlzIG1lYW5zIHRoYXQgZmlsZXR5cGUgcGx1Z2lucyBkb24ndCBnZXQgYSBkaWZmZXJlbnQgc2V0IG9mIHNjcmlwdAp2YXJpYWJsZXMgZm9yIGVhY2ggYnVmZmVyLiAgVXNlIGxvY2FsIGJ1ZmZlciB2YXJpYWJsZXMgaW5zdGVhZCB8Yjp2YXJ8LgoKClByZWRlZmluZWQgVmltIHZhcmlhYmxlczoJCQkqdmltLXZhcmlhYmxlKiAqdjp2YXIqICp2OioKCgkJCQkJKnY6YmV2YWxfY29sKiAqYmV2YWxfY29sLXZhcmlhYmxlKgp2OmJldmFsX2NvbAlUaGUgbnVtYmVyIG9mIHRoZSBjb2x1bW4sIG92ZXIgd2hpY2ggdGhlIG1vdXNlIHBvaW50ZXIgaXMuCgkJVGhpcyBpcyB0aGUgYnl0ZSBpbmRleCBpbiB0aGUgfHY6YmV2YWxfbG51bXwgbGluZS4KCQlPbmx5IHZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgb3B0aW9uLgoKCQkJCQkqdjpiZXZhbF9idWZuciogKmJldmFsX2J1Zm5yLXZhcmlhYmxlKgp2OmJldmFsX2J1Zm5yCVRoZSBudW1iZXIgb2YgdGhlIGJ1ZmZlciwgb3ZlciB3aGljaCB0aGUgbW91c2UgcG9pbnRlciBpcy4gT25seQoJCXZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdiYWxsb29uZXhwcicgb3B0aW9uLgoKCQkJCQkqdjpiZXZhbF9sbnVtKiAqYmV2YWxfbG51bS12YXJpYWJsZSoKdjpiZXZhbF9sbnVtCVRoZSBudW1iZXIgb2YgdGhlIGxpbmUsIG92ZXIgd2hpY2ggdGhlIG1vdXNlIHBvaW50ZXIgaXMuIE9ubHkKCQl2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnYmFsbG9vbmV4cHInIG9wdGlvbi4KCgkJCQkJKnY6YmV2YWxfdGV4dCogKmJldmFsX3RleHQtdmFyaWFibGUqCnY6YmV2YWxfdGV4dAlUaGUgdGV4dCB1bmRlciBvciBhZnRlciB0aGUgbW91c2UgcG9pbnRlci4gIFVzdWFsbHkgYSB3b3JkIGFzCgkJaXQgaXMgdXNlZnVsIGZvciBkZWJ1Z2dpbmcgYSBDIHByb2dyYW0uICAnaXNrZXl3b3JkJyBhcHBsaWVzLAoJCWJ1dCBhIGRvdCBhbmQgIi0+IiBiZWZvcmUgdGhlIHBvc2l0aW9uIGlzIGluY2x1ZGVkLiAgV2hlbiBvbiBhCgkJJ10nIHRoZSB0ZXh0IGJlZm9yZSBpdCBpcyB1c2VkLCBpbmNsdWRpbmcgdGhlIG1hdGNoaW5nICdbJyBhbmQKCQl3b3JkIGJlZm9yZSBpdC4gIFdoZW4gb24gYSBWaXN1YWwgYXJlYSB3aXRoaW4gb25lIGxpbmUgdGhlCgkJaGlnaGxpZ2h0ZWQgdGV4dCBpcyB1c2VkLgoJCU9ubHkgdmFsaWQgd2hpbGUgZXZhbHVhdGluZyB0aGUgJ2JhbGxvb25leHByJyBvcHRpb24uCgoJCQkJCSp2OmJldmFsX3dpbm5yKiAqYmV2YWxfd2lubnItdmFyaWFibGUqCnY6YmV2YWxfd2lubnIJVGhlIG51bWJlciBvZiB0aGUgd2luZG93LCBvdmVyIHdoaWNoIHRoZSBtb3VzZSBwb2ludGVyIGlzLiBPbmx5CgkJdmFsaWQgd2hpbGUgZXZhbHVhdGluZyB0aGUgJ2JhbGxvb25leHByJyBvcHRpb24uICBUaGUgZmlyc3QKCQl3aW5kb3cgaGFzIG51bWJlciB6ZXJvICh1bmxpa2UgbW9zdCBvdGhlciBwbGFjZXMgd2hlcmUgYQoJCXdpbmRvdyBnZXRzIGEgbnVtYmVyKS4KCgkJCQkJKnY6Y2hhciogKmNoYXItdmFyaWFibGUqCnY6Y2hhcgkJQXJndW1lbnQgZm9yIGV2YWx1YXRpbmcgJ2Zvcm1hdGV4cHInIGFuZCB1c2VkIGZvciB0aGUgdHlwZWQKCQljaGFyYWN0ZXIgd2hlbiB1c2luZyA8ZXhwcj4gaW4gYW4gYWJicmV2aWF0aW9uIHw6bWFwLTxleHByPnwuCgkJSXQgaXMgYWxzbyB1c2VkIGJ5IHRoZSB8SW5zZXJ0Q2hhclByZXwgYW5kIHxJbnNlcnRFbnRlcnwgZXZlbnRzLgoKCQkJKnY6Y2hhcmNvbnZlcnRfZnJvbSogKmNoYXJjb252ZXJ0X2Zyb20tdmFyaWFibGUqCnY6Y2hhcmNvbnZlcnRfZnJvbQoJCVRoZSBuYW1lIG9mIHRoZSBjaGFyYWN0ZXIgZW5jb2Rpbmcgb2YgYSBmaWxlIHRvIGJlIGNvbnZlcnRlZC4KCQlPbmx5IHZhbGlkIHdoaWxlIGV2YWx1YXRpbmcgdGhlICdjaGFyY29udmVydCcgb3B0aW9uLgoKCQkJKnY6Y2hhcmNvbnZlcnRfdG8qICpjaGFyY29udmVydF90by12YXJpYWJsZSoKdjpjaGFyY29udmVydF90bwoJCVRoZSBuYW1lIG9mIHRoZSBjaGFyYWN0ZXIgZW5jb2Rpbmcgb2YgYSBmaWxlIGFmdGVyIGNvbnZlcnNpb24uCgkJT25seSB2YWxpZCB3aGlsZSBldmFsdWF0aW5nIHRoZSAnY2hhcmNvbnZlcnQnIG9wdGlvbi4KCgkJCQkJKnY6Y21kYXJnKiAqY21kYXJnLXZhcmlhYmxlKgp2OmNtZGFyZwlUaGlzIHZhcmlhYmxlIGlzIHVzZWQgZm9yIHR3byBwdXJwb3NlczoKCQkxLiBUaGUgZXh0cmEgYXJndW1lbnRzIGdpdmVuIHRvIGEgZmlsZSByZWFkL3dyaXRlIGNvbW1hbmQuCgkJICAgQ3VycmVudGx5IHRoZXNlIGFyZSAiKytlbmM9IiBhbmQgIisrZmY9Ii4gIFRoaXMgdmFyaWFibGUgaXMKCQkgICBzZXQgYmVmb3JlIGFuIGF1dG9jb21tYW5kIGV2ZW50IGZvciBhIGZpbGUgcmVhZC93cml0ZQoJCSAgIGNvbW1hbmQgaXMgdHJpZ2dlcmVkLiAgVGhlcmUgaXMgYSBsZWFkaW5nIHNwYWNlIHRvIG1ha2UgaXQKCQkgICBwb3NzaWJsZSB0byBhcHBlbmQgdGhpcyB2YXJpYWJsZSBkaXJlY3RseSBhZnRlciB0aGUKCQkgICByZWFkL3dyaXRlIGNvbW1hbmQuCU5vdGU6IFRoZSAiK2NtZCIgYXJndW1lbnQgaXNuJ3QKCQkgICBpbmNsdWRlZCBoZXJlLCBiZWNhdXNlIGl0IHdpbGwgYmUgZXhlY3V0ZWQgYW55d2F5LgoJCTIuIFdoZW4gcHJpbnRpbmcgYSBQb3N0U2NyaXB0IGZpbGUgd2l0aCAiOmhhcmRjb3B5IiB0aGlzIGlzCgkJICAgdGhlIGFyZ3VtZW50IGZvciB0aGUgIjpoYXJkY29weSIgY29tbWFuZC4gIFRoaXMgY2FuIGJlIHVzZWQKCQkgICBpbiAncHJpbnRleHByJy4KCgkJCQkJKnY6Y21kYmFuZyogKmNtZGJhbmctdmFyaWFibGUqCnY6Y21kYmFuZwlTZXQgbGlrZSB2OmNtZGFyZyBmb3IgYSBmaWxlIHJlYWQvd3JpdGUgY29tbWFuZC4gIFdoZW4gYSAiISIKCQl3YXMgdXNlZCB0aGUgdmFsdWUgaXMgMSwgb3RoZXJ3aXNlIGl0IGlzIDAuICBOb3RlIHRoYXQgdGhpcwoJCWNhbiBvbmx5IGJlIHVzZWQgaW4gYXV0b2NvbW1hbmRzLiAgRm9yIHVzZXIgY29tbWFuZHMgfDxiYW5nPnwKCQljYW4gYmUgdXNlZC4KCgkJCQkqdjpjb21wbGV0ZWRfaXRlbSogKmNvbXBsZXRlZF9pdGVtLXZhcmlhYmxlKgp2OmNvbXBsZXRlZF9pdGVtCgkJfERpY3Rpb25hcnl8IGNvbnRhaW5pbmcgdGhlIHxjb21wbGV0ZS1pdGVtc3wgZm9yIHRoZSBtb3N0CgkJcmVjZW50bHkgY29tcGxldGVkIHdvcmQgYWZ0ZXIgfENvbXBsZXRlRG9uZXwuICBUaGUKCQl8RGljdGlvbmFyeXwgaXMgZW1wdHkgaWYgdGhlIGNvbXBsZXRpb24gZmFpbGVkLgoKCQkJCQkqdjpjb3VudCogKmNvdW50LXZhcmlhYmxlKgp2OmNvdW50CQlUaGUgY291bnQgZ2l2ZW4gZm9yIHRoZSBsYXN0IE5vcm1hbCBtb2RlIGNvbW1hbmQuICBDYW4gYmUgdXNlZAoJCXRvIGdldCB0aGUgY291bnQgYmVmb3JlIGEgbWFwcGluZy4gIFJlYWQtb25seS4JRXhhbXBsZTogPgoJOm1hcCBfeCA6PEMtVT5lY2hvICJ0aGUgY291bnQgaXMgIiAuIHY6Y291bnQ8Q1I+CjwJCU5vdGU6IFRoZSA8Qy1VPiBpcyByZXF1aXJlZCB0byByZW1vdmUgdGhlIGxpbmUgcmFuZ2UgdGhhdCB5b3UKCQlnZXQgd2hlbiB0eXBpbmcgJzonIGFmdGVyIGEgY291bnQuCgkJV2hlbiB0aGVyZSBhcmUgdHdvIGNvdW50cywgYXMgaW4gIjNkMnciLCB0aGV5IGFyZSBtdWx0aXBsaWVkLAoJCWp1c3QgbGlrZSB3aGF0IGhhcHBlbnMgaW4gdGhlIGNvbW1hbmQsICJkNnciIGZvciB0aGUgZXhhbXBsZS4KCQlBbHNvIHVzZWQgZm9yIGV2YWx1YXRpbmcgdGhlICdmb3JtYXRleHByJyBvcHRpb24uCgkJImNvdW50IiBhbHNvIHdvcmtzLCBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkuCgoJCQkJCSp2OmNvdW50MSogKmNvdW50MS12YXJpYWJsZSoKdjpjb3VudDEJSnVzdCBsaWtlICJ2OmNvdW50IiwgYnV0IGRlZmF1bHRzIHRvIG9uZSB3aGVuIG5vIGNvdW50IGlzCgkJdXNlZC4KCgkJCQkJCSp2OmN0eXBlKiAqY3R5cGUtdmFyaWFibGUqCnY6Y3R5cGUJCVRoZSBjdXJyZW50IGxvY2FsZSBzZXR0aW5nIGZvciBjaGFyYWN0ZXJzIG9mIHRoZSBydW50aW1lCgkJZW52aXJvbm1lbnQuICBUaGlzIGFsbG93cyBWaW0gc2NyaXB0cyB0byBiZSBhd2FyZSBvZiB0aGUKCQljdXJyZW50IGxvY2FsZSBlbmNvZGluZy4gIFRlY2huaWNhbDogaXQncyB0aGUgdmFsdWUgb2YKCQlMQ19DVFlQRS4gIFdoZW4gbm90IHVzaW5nIGEgbG9jYWxlIHRoZSB2YWx1ZSBpcyAiQyIuCgkJVGhpcyB2YXJpYWJsZSBjYW4gbm90IGJlIHNldCBkaXJlY3RseSwgdXNlIHRoZSB8Omxhbmd1YWdlfAoJCWNvbW1hbmQuCgkJU2VlIHxtdWx0aS1sYW5nfC4KCgkJCQkJKnY6ZHlpbmcqICpkeWluZy12YXJpYWJsZSoKdjpkeWluZwkJTm9ybWFsbHkgemVyby4JV2hlbiBhIGRlYWRseSBzaWduYWwgaXMgY2F1Z2h0IGl0J3Mgc2V0IHRvCgkJb25lLiAgV2hlbiBtdWx0aXBsZSBzaWduYWxzIGFyZSBjYXVnaHQgdGhlIG51bWJlciBpbmNyZWFzZXMuCgkJQ2FuIGJlIHVzZWQgaW4gYW4gYXV0b2NvbW1hbmQgdG8gY2hlY2sgaWYgVmltIGRpZG4ndAoJCXRlcm1pbmF0ZSBub3JtYWxseS4ge29ubHkgd29ya3Mgb24gVW5peH0KCQlFeGFtcGxlOiA+Cgk6YXUgVmltTGVhdmUgKiBpZiB2OmR5aW5nIHwgZWNobyAiXG5BQUFBYWFhYXJycmdnZ2hoaGghISFcbiIgfCBlbmRpZgo8CQlOb3RlOiBpZiBhbm90aGVyIGRlYWRseSBzaWduYWwgaXMgY2F1Z2h0IHdoZW4gdjpkeWluZyBpcyBvbmUsCgkJVmltTGVhdmUgYXV0b2NvbW1hbmRzIHdpbGwgbm90IGJlIGV4ZWN1dGVkLgoKCQkJCQkqdjplcnJtc2cqICplcnJtc2ctdmFyaWFibGUqCnY6ZXJybXNnCUxhc3QgZ2l2ZW4gZXJyb3IgbWVzc2FnZS4gIEl0J3MgYWxsb3dlZCB0byBzZXQgdGhpcyB2YXJpYWJsZS4KCQlFeGFtcGxlOiA+Cgk6bGV0IHY6ZXJybXNnID0gIiIKCTpzaWxlbnQhIG5leHQKCTppZiB2OmVycm1zZyAhPSAiIgoJOiAgLi4uIGhhbmRsZSBlcnJvcgo8CQkiZXJybXNnIiBhbHNvIHdvcmtzLCBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkuCgoJCQkJCSp2OmVycm9ycyogKmVycm9ycy12YXJpYWJsZSoKdjplcnJvcnMJRXJyb3JzIGZvdW5kIGJ5IGFzc2VydCBmdW5jdGlvbnMsIHN1Y2ggYXMgfGFzc2VydF90cnVlKCl8LgoJCVRoaXMgaXMgYSBsaXN0IG9mIHN0cmluZ3MuCgkJVGhlIGFzc2VydCBmdW5jdGlvbnMgYXBwZW5kIGFuIGl0ZW0gd2hlbiBhbiBhc3NlcnQgZmFpbHMuCgkJVG8gcmVtb3ZlIG9sZCByZXN1bHRzIG1ha2UgaXQgZW1wdHk6ID4KCTpsZXQgdjplcnJvcnMgPSBbXQo8CQlJZiB2OmVycm9ycyBpcyBzZXQgdG8gYW55dGhpbmcgYnV0IGEgbGlzdCBpdCBpcyBtYWRlIGFuIGVtcHR5CgkJbGlzdCBieSB0aGUgYXNzZXJ0IGZ1bmN0aW9uLgoKCQkJCQkqdjpleGNlcHRpb24qICpleGNlcHRpb24tdmFyaWFibGUqCnY6ZXhjZXB0aW9uCVRoZSB2YWx1ZSBvZiB0aGUgZXhjZXB0aW9uIG1vc3QgcmVjZW50bHkgY2F1Z2h0IGFuZCBub3QKCQlmaW5pc2hlZC4gIFNlZSBhbHNvIHx2OnRocm93cG9pbnR8IGFuZCB8dGhyb3ctdmFyaWFibGVzfC4KCQlFeGFtcGxlOiA+Cgk6dHJ5Cgk6ICB0aHJvdyAib29wcyIKCTpjYXRjaCAvLiovCgk6ICBlY2hvICJjYXVnaHQiIHY6ZXhjZXB0aW9uCgk6ZW5kdHJ5CjwJCU91dHB1dDogImNhdWdodCBvb3BzIi4KCgkJCQkJKnY6ZmFsc2UqICpmYWxzZS12YXJpYWJsZSoKdjpmYWxzZQkJQSBOdW1iZXIgd2l0aCB2YWx1ZSB6ZXJvLiBVc2VkIHRvIHB1dCAiZmFsc2UiIGluIEpTT04uICBTZWUKCQl8anNvbl9lbmNvZGUoKXwuCgkJV2hlbiB1c2VkIGFzIGEgc3RyaW5nIHRoaXMgZXZhbHVhdGVzIHRvICJmYWxzZSIuID4KCQkJZWNobyB2OmZhbHNlCjwJCQlmYWxzZSB+CgoJCQkJCSp2OmZjc19yZWFzb24qICpmY3NfcmVhc29uLXZhcmlhYmxlKgp2OmZjc19yZWFzb24JVGhlIHJlYXNvbiB3aHkgdGhlIHxGaWxlQ2hhbmdlZFNoZWxsfCBldmVudCB3YXMgdHJpZ2dlcmVkLgoJCUNhbiBiZSB1c2VkIGluIGFuIGF1dG9jb21tYW5kIHRvIGRlY2lkZSB3aGF0IHRvIGRvIGFuZC9vciB3aGF0CgkJdG8gc2V0IHY6ZmNzX2Nob2ljZSB0by4gIFBvc3NpYmxlIHZhbHVlczoKCQkJZGVsZXRlZAkJZmlsZSBubyBsb25nZXIgZXhpc3RzCgkJCWNvbmZsaWN0CWZpbGUgY29udGVudHMsIG1vZGUgb3IgdGltZXN0YW1wIHdhcwoJCQkJCWNoYW5nZWQgYW5kIGJ1ZmZlciBpcyBtb2RpZmllZAoJCQljaGFuZ2VkCQlmaWxlIGNvbnRlbnRzIGhhcyBjaGFuZ2VkCgkJCW1vZGUJCW1vZGUgb2YgZmlsZSBjaGFuZ2VkCgkJCXRpbWUJCW9ubHkgZmlsZSB0aW1lc3RhbXAgY2hhbmdlZAoKCQkJCQkqdjpmY3NfY2hvaWNlKiAqZmNzX2Nob2ljZS12YXJpYWJsZSoKdjpmY3NfY2hvaWNlCVdoYXQgc2hvdWxkIGhhcHBlbiBhZnRlciBhIHxGaWxlQ2hhbmdlZFNoZWxsfCBldmVudCB3YXMKCQl0cmlnZ2VyZWQuICBDYW4gYmUgdXNlZCBpbiBhbiBhdXRvY29tbWFuZCB0byB0ZWxsIFZpbSB3aGF0IHRvCgkJZG8gd2l0aCB0aGUgYWZmZWN0ZWQgYnVmZmVyOgoJCQlyZWxvYWQJCVJlbG9hZCB0aGUgYnVmZmVyIChkb2VzIG5vdCB3b3JrIGlmCgkJCQkJdGhlIGZpbGUgd2FzIGRlbGV0ZWQpLgoJCQlhc2sJCUFzayB0aGUgdXNlciB3aGF0IHRvIGRvLCBhcyBpZiB0aGVyZQoJCQkJCXdhcyBubyBhdXRvY29tbWFuZC4gIEV4Y2VwdCB0aGF0IHdoZW4KCQkJCQlvbmx5IHRoZSB0aW1lc3RhbXAgY2hhbmdlZCBub3RoaW5nCgkJCQkJd2lsbCBoYXBwZW4uCgkJCTxlbXB0eT4JCU5vdGhpbmcsIHRoZSBhdXRvY29tbWFuZCBzaG91bGQgZG8KCQkJCQlldmVyeXRoaW5nIHRoYXQgbmVlZHMgdG8gYmUgZG9uZS4KCQlUaGUgZGVmYXVsdCBpcyBlbXB0eS4gIElmIGFub3RoZXIgKGludmFsaWQpIHZhbHVlIGlzIHVzZWQgdGhlbgoJCVZpbSBiZWhhdmVzIGxpa2UgaXQgaXMgZW1wdHksIHRoZXJlIGlzIG5vIHdhcm5pbmcgbWVzc2FnZS4KCgkJCQkJKnY6Zm5hbWVfaW4qICpmbmFtZV9pbi12YXJpYWJsZSoKdjpmbmFtZV9pbglUaGUgbmFtZSBvZiB0aGUgaW5wdXQgZmlsZS4gIFZhbGlkIHdoaWxlIGV2YWx1YXRpbmc6CgkJCW9wdGlvbgkJdXNlZCBmb3IgfgoJCQknY2hhcmNvbnZlcnQnCWZpbGUgdG8gYmUgY29udmVydGVkCgkJCSdkaWZmZXhwcicJb3JpZ2luYWwgZmlsZQoJCQkncGF0Y2hleHByJwlvcmlnaW5hbCBmaWxlCgkJCSdwcmludGV4cHInCWZpbGUgdG8gYmUgcHJpbnRlZAoJCUFuZCBzZXQgdG8gdGhlIHN3YXAgZmlsZSBuYW1lIGZvciB8U3dhcEV4aXN0c3wuCgoJCQkJCSp2OmZuYW1lX291dCogKmZuYW1lX291dC12YXJpYWJsZSoKdjpmbmFtZV9vdXQJVGhlIG5hbWUgb2YgdGhlIG91dHB1dCBmaWxlLiAgT25seSB2YWxpZCB3aGlsZQoJCWV2YWx1YXRpbmc6CgkJCW9wdGlvbgkJdXNlZCBmb3IgfgoJCQknY2hhcmNvbnZlcnQnCXJlc3VsdGluZyBjb252ZXJ0ZWQgZmlsZSAoKikKCQkJJ2RpZmZleHByJwlvdXRwdXQgb2YgZGlmZgoJCQkncGF0Y2hleHByJwlyZXN1bHRpbmcgcGF0Y2hlZCBmaWxlCgkJKCopIFdoZW4gZG9pbmcgY29udmVyc2lvbiBmb3IgYSB3cml0ZSBjb21tYW5kIChlLmcuLCAiOncKCQlmaWxlIikgaXQgd2lsbCBiZSBlcXVhbCB0byB2OmZuYW1lX2luLglXaGVuIGRvaW5nIGNvbnZlcnNpb24KCQlmb3IgYSByZWFkIGNvbW1hbmQgKGUuZy4sICI6ZSBmaWxlIikgaXQgd2lsbCBiZSBhIHRlbXBvcmFyeQoJCWZpbGUgYW5kIGRpZmZlcmVudCBmcm9tIHY6Zm5hbWVfaW4uCgoJCQkJCSp2OmZuYW1lX25ldyogKmZuYW1lX25ldy12YXJpYWJsZSoKdjpmbmFtZV9uZXcJVGhlIG5hbWUgb2YgdGhlIG5ldyB2ZXJzaW9uIG9mIHRoZSBmaWxlLiAgT25seSB2YWxpZCB3aGlsZQoJCWV2YWx1YXRpbmcgJ2RpZmZleHByJy4KCgkJCQkJKnY6Zm5hbWVfZGlmZiogKmZuYW1lX2RpZmYtdmFyaWFibGUqCnY6Zm5hbWVfZGlmZglUaGUgbmFtZSBvZiB0aGUgZGlmZiAocGF0Y2gpIGZpbGUuICBPbmx5IHZhbGlkIHdoaWxlCgkJZXZhbHVhdGluZyAncGF0Y2hleHByJy4KCgkJCQkJKnY6Zm9sZGRhc2hlcyogKmZvbGRkYXNoZXMtdmFyaWFibGUqCnY6Zm9sZGRhc2hlcwlVc2VkIGZvciAnZm9sZHRleHQnOiBkYXNoZXMgcmVwcmVzZW50aW5nIGZvbGRsZXZlbCBvZiBhIGNsb3NlZAoJCWZvbGQuCgkJUmVhZC1vbmx5IGluIHRoZSB8c2FuZGJveHwuIHxmb2xkLWZvbGR0ZXh0fAoKCQkJCQkqdjpmb2xkbGV2ZWwqICpmb2xkbGV2ZWwtdmFyaWFibGUqCnY6Zm9sZGxldmVsCVVzZWQgZm9yICdmb2xkdGV4dCc6IGZvbGRsZXZlbCBvZiBjbG9zZWQgZm9sZC4KCQlSZWFkLW9ubHkgaW4gdGhlIHxzYW5kYm94fC4gfGZvbGQtZm9sZHRleHR8CgoJCQkJCSp2OmZvbGRlbmQqICpmb2xkZW5kLXZhcmlhYmxlKgp2OmZvbGRlbmQJVXNlZCBmb3IgJ2ZvbGR0ZXh0JzogbGFzdCBsaW5lIG9mIGNsb3NlZCBmb2xkLgoJCVJlYWQtb25seSBpbiB0aGUgfHNhbmRib3h8LiB8Zm9sZC1mb2xkdGV4dHwKCgkJCQkJKnY6Zm9sZHN0YXJ0KiAqZm9sZHN0YXJ0LXZhcmlhYmxlKgp2OmZvbGRzdGFydAlVc2VkIGZvciAnZm9sZHRleHQnOiBmaXJzdCBsaW5lIG9mIGNsb3NlZCBmb2xkLgoJCVJlYWQtb25seSBpbiB0aGUgfHNhbmRib3h8LiB8Zm9sZC1mb2xkdGV4dHwKCgkJCQkJKnY6aGxzZWFyY2gqICpobHNlYXJjaC12YXJpYWJsZSoKdjpobHNlYXJjaAlWYXJpYWJsZSB0aGF0IGluZGljYXRlcyB3aGV0aGVyIHNlYXJjaCBoaWdobGlnaHRpbmcgaXMgb24uIAoJCVNldHRpbmcgaXQgbWFrZXMgc2Vuc2Ugb25seSBpZiAnaGxzZWFyY2gnIGlzIGVuYWJsZWQgd2hpY2gKCQlyZXF1aXJlcyB8K2V4dHJhX3NlYXJjaHwuIFNldHRpbmcgdGhpcyB2YXJpYWJsZSB0byB6ZXJvIGFjdHMKCQlsaWtlIHRoZSB8Om5vaGxzZWFyY2h8IGNvbW1hbmQsIHNldHRpbmcgaXQgdG8gb25lIGFjdHMgbGlrZSA+CgkJCWxldCAmaGxzZWFyY2ggPSAmaGxzZWFyY2gKPAkJTm90ZSB0aGF0IHRoZSB2YWx1ZSBpcyByZXN0b3JlZCB3aGVuIHJldHVybmluZyBmcm9tIGEKCQlmdW5jdGlvbi4gfGZ1bmN0aW9uLXNlYXJjaC11bmRvfC4KCgkJCQkJKnY6aW5zZXJ0bW9kZSogKmluc2VydG1vZGUtdmFyaWFibGUqCnY6aW5zZXJ0bW9kZQlVc2VkIGZvciB0aGUgfEluc2VydEVudGVyfCBhbmQgfEluc2VydENoYW5nZXwgYXV0b2NvbW1hbmQKCQlldmVudHMuICBWYWx1ZXM6CgkJCWkJSW5zZXJ0IG1vZGUKCQkJcglSZXBsYWNlIG1vZGUKCQkJdglWaXJ0dWFsIFJlcGxhY2UgbW9kZQoKCQkJCQkJKnY6a2V5KiAqa2V5LXZhcmlhYmxlKgp2OmtleQkJS2V5IG9mIHRoZSBjdXJyZW50IGl0ZW0gb2YgYSB8RGljdGlvbmFyeXwuICBPbmx5IHZhbGlkIHdoaWxlCgkJZXZhbHVhdGluZyB0aGUgZXhwcmVzc2lvbiB1c2VkIHdpdGggfG1hcCgpfCBhbmQgfGZpbHRlcigpfC4KCQlSZWFkLW9ubHkuCgoJCQkJCQkqdjpsYW5nKiAqbGFuZy12YXJpYWJsZSoKdjpsYW5nCQlUaGUgY3VycmVudCBsb2NhbGUgc2V0dGluZyBmb3IgbWVzc2FnZXMgb2YgdGhlIHJ1bnRpbWUKCQllbnZpcm9ubWVudC4gIFRoaXMgYWxsb3dzIFZpbSBzY3JpcHRzIHRvIGJlIGF3YXJlIG9mIHRoZQoJCWN1cnJlbnQgbGFuZ3VhZ2UuICBUZWNobmljYWw6IGl0J3MgdGhlIHZhbHVlIG9mIExDX01FU1NBR0VTLgoJCVRoZSB2YWx1ZSBpcyBzeXN0ZW0gZGVwZW5kZW50LgoJCVRoaXMgdmFyaWFibGUgY2FuIG5vdCBiZSBzZXQgZGlyZWN0bHksIHVzZSB0aGUgfDpsYW5ndWFnZXwKCQljb21tYW5kLgoJCUl0IGNhbiBiZSBkaWZmZXJlbnQgZnJvbSB8djpjdHlwZXwgd2hlbiBtZXNzYWdlcyBhcmUgZGVzaXJlZAoJCWluIGEgZGlmZmVyZW50IGxhbmd1YWdlIHRoYW4gd2hhdCBpcyB1c2VkIGZvciBjaGFyYWN0ZXIKCQllbmNvZGluZy4gIFNlZSB8bXVsdGktbGFuZ3wuCgoJCQkJCQkqdjpsY190aW1lKiAqbGNfdGltZS12YXJpYWJsZSoKdjpsY190aW1lCVRoZSBjdXJyZW50IGxvY2FsZSBzZXR0aW5nIGZvciB0aW1lIG1lc3NhZ2VzIG9mIHRoZSBydW50aW1lCgkJZW52aXJvbm1lbnQuICBUaGlzIGFsbG93cyBWaW0gc2NyaXB0cyB0byBiZSBhd2FyZSBvZiB0aGUKCQljdXJyZW50IGxhbmd1YWdlLiAgVGVjaG5pY2FsOiBpdCdzIHRoZSB2YWx1ZSBvZiBMQ19USU1FLgoJCVRoaXMgdmFyaWFibGUgY2FuIG5vdCBiZSBzZXQgZGlyZWN0bHksIHVzZSB0aGUgfDpsYW5ndWFnZXwKCQljb21tYW5kLiAgU2VlIHxtdWx0aS1sYW5nfC4KCgkJCQkJCSp2OmxudW0qICpsbnVtLXZhcmlhYmxlKgp2OmxudW0JCUxpbmUgbnVtYmVyIGZvciB0aGUgJ2ZvbGRleHByJyB8Zm9sZC1leHByfCwgJ2Zvcm1hdGV4cHInIGFuZAoJCSdpbmRlbnRleHByJyBleHByZXNzaW9ucywgdGFiIHBhZ2UgbnVtYmVyIGZvciAnZ3VpdGFibGFiZWwnCgkJYW5kICdndWl0YWJ0b29sdGlwJy4gIE9ubHkgdmFsaWQgd2hpbGUgb25lIG9mIHRoZXNlCgkJZXhwcmVzc2lvbnMgaXMgYmVpbmcgZXZhbHVhdGVkLiAgUmVhZC1vbmx5IHdoZW4gaW4gdGhlCgkJfHNhbmRib3h8LgoKCQkJCQkqdjptb3VzZV93aW4qICptb3VzZV93aW4tdmFyaWFibGUqCnY6bW91c2Vfd2luCVdpbmRvdyBudW1iZXIgZm9yIGEgbW91c2UgY2xpY2sgb2J0YWluZWQgd2l0aCB8Z2V0Y2hhcigpfC4KCQlGaXJzdCB3aW5kb3cgaGFzIG51bWJlciAxLCBsaWtlIHdpdGggfHdpbm5yKCl8LiAgVGhlIHZhbHVlIGlzCgkJemVybyB3aGVuIHRoZXJlIHdhcyBubyBtb3VzZSBidXR0b24gY2xpY2suCgoJCQkJCSp2Om1vdXNlX2xudW0qICptb3VzZV9sbnVtLXZhcmlhYmxlKgp2Om1vdXNlX2xudW0JTGluZSBudW1iZXIgZm9yIGEgbW91c2UgY2xpY2sgb2J0YWluZWQgd2l0aCB8Z2V0Y2hhcigpfC4KCQlUaGlzIGlzIHRoZSB0ZXh0IGxpbmUgbnVtYmVyLCBub3QgdGhlIHNjcmVlbiBsaW5lIG51bWJlci4gIFRoZQoJCXZhbHVlIGlzIHplcm8gd2hlbiB0aGVyZSB3YXMgbm8gbW91c2UgYnV0dG9uIGNsaWNrLgoKCQkJCQkqdjptb3VzZV9jb2wqICptb3VzZV9jb2wtdmFyaWFibGUqCnY6bW91c2VfY29sCUNvbHVtbiBudW1iZXIgZm9yIGEgbW91c2UgY2xpY2sgb2J0YWluZWQgd2l0aCB8Z2V0Y2hhcigpfC4KCQlUaGlzIGlzIHRoZSBzY3JlZW4gY29sdW1uIG51bWJlciwgbGlrZSB3aXRoIHx2aXJ0Y29sKCl8LiAgVGhlCgkJdmFsdWUgaXMgemVybyB3aGVuIHRoZXJlIHdhcyBubyBtb3VzZSBidXR0b24gY2xpY2suCgoJCQkJCSp2Om5vbmUqICpub25lLXZhcmlhYmxlKgp2Om5vbmUJCUFuIGVtcHR5IFN0cmluZy4gVXNlZCB0byBwdXQgYW4gZW1wdHkgaXRlbSBpbiBKU09OLiAgU2VlCgkJfGpzb25fZW5jb2RlKCl8LgoJCVdoZW4gdXNlZCBhcyBhIG51bWJlciB0aGlzIGV2YWx1YXRlcyB0byB6ZXJvLgoJCVdoZW4gdXNlZCBhcyBhIHN0cmluZyB0aGlzIGV2YWx1YXRlcyB0byAibm9uZSIuID4KCQkJZWNobyB2Om5vbmUKPAkJCW5vbmUgfgoKCQkJCQkqdjpudWxsKiAqbnVsbC12YXJpYWJsZSoKdjpudWxsCQlBbiBlbXB0eSBTdHJpbmcuIFVzZWQgdG8gcHV0ICJudWxsIiBpbiBKU09OLiAgU2VlCgkJfGpzb25fZW5jb2RlKCl8LgoJCVdoZW4gdXNlZCBhcyBhIG51bWJlciB0aGlzIGV2YWx1YXRlcyB0byB6ZXJvLgoJCVdoZW4gdXNlZCBhcyBhIHN0cmluZyB0aGlzIGV2YWx1YXRlcyB0byAibnVsbCIuID4KCQkJZWNobyB2Om51bGwKPAkJCW51bGwgfgoKCQkJCQkqdjpvbGRmaWxlcyogKm9sZGZpbGVzLXZhcmlhYmxlKgp2Om9sZGZpbGVzCUxpc3Qgb2YgZmlsZSBuYW1lcyB0aGF0IGlzIGxvYWRlZCBmcm9tIHRoZSB8dmltaW5mb3wgZmlsZSBvbgoJCXN0YXJ0dXAuICBUaGVzZSBhcmUgdGhlIGZpbGVzIHRoYXQgVmltIHJlbWVtYmVycyBtYXJrcyBmb3IuCgkJVGhlIGxlbmd0aCBvZiB0aGUgTGlzdCBpcyBsaW1pdGVkIGJ5IHRoZSAnIGFyZ3VtZW50IG9mIHRoZQoJCSd2aW1pbmZvJyBvcHRpb24gKGRlZmF1bHQgaXMgMTAwKS4KCQlXaGVuIHRoZSB8dmltaW5mb3wgZmlsZSBpcyBub3QgdXNlZCB0aGUgTGlzdCBpcyBlbXB0eS4KCQlBbHNvIHNlZSB8Om9sZGZpbGVzfCBhbmQgfGNfIzx8LgoJCVRoZSBMaXN0IGNhbiBiZSBtb2RpZmllZCwgYnV0IHRoaXMgaGFzIG5vIGVmZmVjdCBvbiB3aGF0IGlzCgkJc3RvcmVkIGluIHRoZSB8dmltaW5mb3wgZmlsZSBsYXRlci4gIElmIHlvdSB1c2UgdmFsdWVzIG90aGVyCgkJdGhhbiBTdHJpbmcgdGhpcyB3aWxsIGNhdXNlIHRyb3VibGUuCgkJe29ubHkgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3ZpbWluZm98IGZlYXR1cmV9CgoJCQkJCQkgICAgKnY6b3B0aW9uX25ldyoKdjpvcHRpb25fbmV3ICAgIE5ldyB2YWx1ZSBvZiB0aGUgb3B0aW9uLiBWYWxpZCB3aGlsZSBleGVjdXRpbmcgYW4gfE9wdGlvblNldHwKCQlhdXRvY29tbWFuZC4KCQkJCQkJICAgICp2Om9wdGlvbl9vbGQqCnY6b3B0aW9uX29sZCAgICBPbGQgdmFsdWUgb2YgdGhlIG9wdGlvbi4gVmFsaWQgd2hpbGUgZXhlY3V0aW5nIGFuIHxPcHRpb25TZXR8CgkJYXV0b2NvbW1hbmQuCgkJCQkJCSAgICAqdjpvcHRpb25fdHlwZSoKdjpvcHRpb25fdHlwZSAgIFNjb3BlIG9mIHRoZSBzZXQgY29tbWFuZC4gVmFsaWQgd2hpbGUgZXhlY3V0aW5nIGFuCgkJfE9wdGlvblNldHwgYXV0b2NvbW1hbmQuIENhbiBiZSBlaXRoZXIgImdsb2JhbCIgb3IgImxvY2FsIgoJCQkJCSp2Om9wZXJhdG9yKiAqb3BlcmF0b3ItdmFyaWFibGUqCnY6b3BlcmF0b3IJVGhlIGxhc3Qgb3BlcmF0b3IgZ2l2ZW4gaW4gTm9ybWFsIG1vZGUuICBUaGlzIGlzIGEgc2luZ2xlCgkJY2hhcmFjdGVyIGV4Y2VwdCBmb3IgY29tbWFuZHMgc3RhcnRpbmcgd2l0aCA8Zz4gb3IgPHo+LAoJCWluIHdoaWNoIGNhc2UgaXQgaXMgdHdvIGNoYXJhY3RlcnMuICBCZXN0IHVzZWQgYWxvbmdzaWRlCgkJfHY6cHJldmNvdW50fCBhbmQgfHY6cmVnaXN0ZXJ8LiAgVXNlZnVsIGlmIHlvdSB3YW50IHRvIGNhbmNlbAoJCU9wZXJhdG9yLXBlbmRpbmcgbW9kZSBhbmQgdGhlbiB1c2UgdGhlIG9wZXJhdG9yLCBlLmcuOiA+CgkJCTpvbWFwIE8gPEVzYz46Y2FsbCBNeU1vdGlvbih2Om9wZXJhdG9yKTxDUj4KPAkJVGhlIHZhbHVlIHJlbWFpbnMgc2V0IHVudGlsIGFub3RoZXIgb3BlcmF0b3IgaXMgZW50ZXJlZCwgdGh1cwoJCWRvbid0IGV4cGVjdCBpdCB0byBiZSBlbXB0eS4KCQl2Om9wZXJhdG9yIGlzIG5vdCBzZXQgZm9yIHw6ZGVsZXRlfCwgfDp5YW5rfCBvciBvdGhlciBFeAoJCWNvbW1hbmRzLgoJCVJlYWQtb25seS4KCgkJCQkJKnY6cHJldmNvdW50KiAqcHJldmNvdW50LXZhcmlhYmxlKgp2OnByZXZjb3VudAlUaGUgY291bnQgZ2l2ZW4gZm9yIHRoZSBsYXN0IGJ1dCBvbmUgTm9ybWFsIG1vZGUgY29tbWFuZC4KCQlUaGlzIGlzIHRoZSB2OmNvdW50IHZhbHVlIG9mIHRoZSBwcmV2aW91cyBjb21tYW5kLiAgVXNlZnVsIGlmCgkJeW91IHdhbnQgdG8gY2FuY2VsIFZpc3VhbCBvciBPcGVyYXRvci1wZW5kaW5nIG1vZGUgYW5kIHRoZW4KCQl1c2UgdGhlIGNvdW50LCBlLmcuOiA+CgkJCTp2bWFwICUgPEVzYz46Y2FsbCBNeUZpbHRlcih2OnByZXZjb3VudCk8Q1I+CjwJCVJlYWQtb25seS4KCgkJCQkJKnY6cHJvZmlsaW5nKiAqcHJvZmlsaW5nLXZhcmlhYmxlKgp2OnByb2ZpbGluZwlOb3JtYWxseSB6ZXJvLglTZXQgdG8gb25lIGFmdGVyIHVzaW5nICI6cHJvZmlsZSBzdGFydCIuCgkJU2VlIHxwcm9maWxpbmd8LgoKCQkJCQkqdjpwcm9nbmFtZSogKnByb2duYW1lLXZhcmlhYmxlKgp2OnByb2duYW1lCUNvbnRhaW5zIHRoZSBuYW1lICh3aXRoIHBhdGggcmVtb3ZlZCkgd2l0aCB3aGljaCBWaW0gd2FzCgkJaW52b2tlZC4gIEFsbG93cyB5b3UgdG8gZG8gc3BlY2lhbCBpbml0aWFsaXNhdGlvbnMgZm9yIHx2aWV3fCwKCQl8ZXZpbXwgZXRjLiwgb3IgYW55IG90aGVyIG5hbWUgeW91IG1pZ2h0IHN5bWxpbmsgdG8gVmltLgoJCVJlYWQtb25seS4KCgkJCQkJKnY6cHJvZ3BhdGgqICpwcm9ncGF0aC12YXJpYWJsZSoKdjpwcm9ncGF0aAlDb250YWlucyB0aGUgY29tbWFuZCB3aXRoIHdoaWNoIFZpbSB3YXMgaW52b2tlZCwgaW5jbHVkaW5nIHRoZQoJCXBhdGguICBVc2VmdWwgaWYgeW91IHdhbnQgdG8gbWVzc2FnZSBhIFZpbSBzZXJ2ZXIgdXNpbmcgYQoJCXwtLXJlbW90ZS1leHByfC4KCQlUbyBnZXQgdGhlIGZ1bGwgcGF0aCB1c2U6ID4KCQkJZWNobyBleGVwYXRoKHY6cHJvZ3BhdGgpCjwJCU5PVEU6IFRoaXMgZG9lcyBub3Qgd29yayB3aGVuIHRoZSBjb21tYW5kIGlzIGEgcmVsYXRpdmUgcGF0aAoJCWFuZCB0aGUgY3VycmVudCBkaXJlY3RvcnkgaGFzIGNoYW5nZWQuCgkJUmVhZC1vbmx5LgoKCQkJCQkqdjpyZWdpc3RlciogKnJlZ2lzdGVyLXZhcmlhYmxlKgp2OnJlZ2lzdGVyCVRoZSBuYW1lIG9mIHRoZSByZWdpc3RlciBpbiBlZmZlY3QgZm9yIHRoZSBjdXJyZW50IG5vcm1hbCBtb2RlCgkJY29tbWFuZCAocmVnYXJkbGVzcyBvZiB3aGV0aGVyIHRoYXQgY29tbWFuZCBhY3R1YWxseSB1c2VkIGEKCQlyZWdpc3RlcikuICBPciBmb3IgdGhlIGN1cnJlbnRseSBleGVjdXRpbmcgbm9ybWFsIG1vZGUgbWFwcGluZwoJCSh1c2UgdGhpcyBpbiBjdXN0b20gY29tbWFuZHMgdGhhdCB0YWtlIGEgcmVnaXN0ZXIpLgoJCUlmIG5vbmUgaXMgc3VwcGxpZWQgaXQgaXMgdGhlIGRlZmF1bHQgcmVnaXN0ZXIgJyInLCB1bmxlc3MKCQknY2xpcGJvYXJkJyBjb250YWlucyAidW5uYW1lZCIgb3IgInVubmFtZWRwbHVzIiwgdGhlbiBpdCBpcwoJCScqJyBvciAnKycuCgkJQWxzbyBzZWUgfGdldHJlZygpfCBhbmQgfHNldHJlZygpfAoKCQkJCQkqdjpzY3JvbGxzdGFydCogKnNjcm9sbHN0YXJ0LXZhcmlhYmxlKgp2OnNjcm9sbHN0YXJ0CVN0cmluZyBkZXNjcmliaW5nIHRoZSBzY3JpcHQgb3IgZnVuY3Rpb24gdGhhdCBjYXVzZWQgdGhlCgkJc2NyZWVuIHRvIHNjcm9sbCB1cC4gIEl0J3Mgb25seSBzZXQgd2hlbiBpdCBpcyBlbXB0eSwgdGh1cyB0aGUKCQlmaXJzdCByZWFzb24gaXMgcmVtZW1iZXJlZC4gIEl0IGlzIHNldCB0byAiVW5rbm93biIgZm9yIGEKCQl0eXBlZCBjb21tYW5kLgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gZmluZCBvdXQgd2h5IHlvdXIgc2NyaXB0IGNhdXNlcyB0aGUKCQloaXQtZW50ZXIgcHJvbXB0LgoKCQkJCQkqdjpzZXJ2ZXJuYW1lKiAqc2VydmVybmFtZS12YXJpYWJsZSoKdjpzZXJ2ZXJuYW1lCVRoZSByZXN1bHRpbmcgcmVnaXN0ZXJlZCB8eDExLWNsaWVudHNlcnZlcnwgbmFtZSBpZiBhbnkuCgkJUmVhZC1vbmx5LgoKCQkKdjpzZWFyY2hmb3J3YXJkCQkJKnY6c2VhcmNoZm9yd2FyZCogKnNlYXJjaGZvcndhcmQtdmFyaWFibGUqCgkJU2VhcmNoIGRpcmVjdGlvbjogIDEgYWZ0ZXIgYSBmb3J3YXJkIHNlYXJjaCwgMCBhZnRlciBhCgkJYmFja3dhcmQgc2VhcmNoLiAgSXQgaXMgcmVzZXQgdG8gZm9yd2FyZCB3aGVuIGRpcmVjdGx5IHNldHRpbmcKCQl0aGUgbGFzdCBzZWFyY2ggcGF0dGVybiwgc2VlIHxxdW90ZS98LgoJCU5vdGUgdGhhdCB0aGUgdmFsdWUgaXMgcmVzdG9yZWQgd2hlbiByZXR1cm5pbmcgZnJvbSBhCgkJZnVuY3Rpb24uIHxmdW5jdGlvbi1zZWFyY2gtdW5kb3wuCgkJUmVhZC13cml0ZS4KCgkJCQkJKnY6c2hlbGxfZXJyb3IqICpzaGVsbF9lcnJvci12YXJpYWJsZSoKdjpzaGVsbF9lcnJvcglSZXN1bHQgb2YgdGhlIGxhc3Qgc2hlbGwgY29tbWFuZC4gIFdoZW4gbm9uLXplcm8sIHRoZSBsYXN0CgkJc2hlbGwgY29tbWFuZCBoYWQgYW4gZXJyb3IuICBXaGVuIHplcm8sIHRoZXJlIHdhcyBubyBwcm9ibGVtLgoJCVRoaXMgb25seSB3b3JrcyB3aGVuIHRoZSBzaGVsbCByZXR1cm5zIHRoZSBlcnJvciBjb2RlIHRvIFZpbS4KCQlUaGUgdmFsdWUgLTEgaXMgb2Z0ZW4gdXNlZCB3aGVuIHRoZSBjb21tYW5kIGNvdWxkIG5vdCBiZQoJCWV4ZWN1dGVkLiAgUmVhZC1vbmx5LgoJCUV4YW1wbGU6ID4KCTohbXYgZm9vIGJhcgoJOmlmIHY6c2hlbGxfZXJyb3IKCTogIGVjaG8gJ2NvdWxkIG5vdCByZW5hbWUgImZvbyIgdG8gImJhciIhJwoJOmVuZGlmCjwJCSJzaGVsbF9lcnJvciIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjpzdGF0dXNtc2cqICpzdGF0dXNtc2ctdmFyaWFibGUqCnY6c3RhdHVzbXNnCUxhc3QgZ2l2ZW4gc3RhdHVzIG1lc3NhZ2UuICBJdCdzIGFsbG93ZWQgdG8gc2V0IHRoaXMgdmFyaWFibGUuCgoJCQkJCSp2OnN3YXBuYW1lKiAqc3dhcG5hbWUtdmFyaWFibGUqCnY6c3dhcG5hbWUJT25seSB2YWxpZCB3aGVuIGV4ZWN1dGluZyB8U3dhcEV4aXN0c3wgYXV0b2NvbW1hbmRzOiBOYW1lIG9mCgkJdGhlIHN3YXAgZmlsZSBmb3VuZC4gIFJlYWQtb25seS4KCgkJCQkJKnY6c3dhcGNob2ljZSogKnN3YXBjaG9pY2UtdmFyaWFibGUqCnY6c3dhcGNob2ljZQl8U3dhcEV4aXN0c3wgYXV0b2NvbW1hbmRzIGNhbiBzZXQgdGhpcyB0byB0aGUgc2VsZWN0ZWQgY2hvaWNlCgkJZm9yIGhhbmRsaW5nIGFuIGV4aXN0aW5nIHN3YXAgZmlsZToKCQkJJ28nCU9wZW4gcmVhZC1vbmx5CgkJCSdlJwlFZGl0IGFueXdheQoJCQkncicJUmVjb3ZlcgoJCQknZCcJRGVsZXRlIHN3YXBmaWxlCgkJCSdxJwlRdWl0CgkJCSdhJwlBYm9ydAoJCVRoZSB2YWx1ZSBzaG91bGQgYmUgYSBzaW5nbGUtY2hhcmFjdGVyIHN0cmluZy4JQW4gZW1wdHkgdmFsdWUKCQlyZXN1bHRzIGluIHRoZSB1c2VyIGJlaW5nIGFza2VkLCBhcyB3b3VsZCBoYXBwZW4gd2hlbiB0aGVyZSBpcwoJCW5vIFN3YXBFeGlzdHMgYXV0b2NvbW1hbmQuICBUaGUgZGVmYXVsdCBpcyBlbXB0eS4KCgkJCQkJKnY6c3dhcGNvbW1hbmQqICpzd2FwY29tbWFuZC12YXJpYWJsZSoKdjpzd2FwY29tbWFuZAlOb3JtYWwgbW9kZSBjb21tYW5kIHRvIGJlIGV4ZWN1dGVkIGFmdGVyIGEgZmlsZSBoYXMgYmVlbgoJCW9wZW5lZC4gIENhbiBiZSB1c2VkIGZvciBhIHxTd2FwRXhpc3RzfCBhdXRvY29tbWFuZCB0byBoYXZlCgkJYW5vdGhlciBWaW0gb3BlbiB0aGUgZmlsZSBhbmQganVtcCB0byB0aGUgcmlnaHQgcGxhY2UuCUZvcgoJCWV4YW1wbGUsIHdoZW4ganVtcGluZyB0byBhIHRhZyB0aGUgdmFsdWUgaXMgIjp0YWcgdGFnbmFtZVxyIi4KCQlGb3IgIjplZGl0ICtjbWQgZmlsZSIgdGhlIHZhbHVlIGlzICI6Y21kXHIiLgoKCQkJCSp2OnRlcm1yZXNwb25zZSogKnRlcm1yZXNwb25zZS12YXJpYWJsZSoKdjp0ZXJtcmVzcG9uc2UJVGhlIGVzY2FwZSBzZXF1ZW5jZSByZXR1cm5lZCBieSB0aGUgdGVybWluYWwgZm9yIHRoZSB8dF9SVnwKCQl0ZXJtY2FwIGVudHJ5LglJdCBpcyBzZXQgd2hlbiBWaW0gcmVjZWl2ZXMgYW4gZXNjYXBlIHNlcXVlbmNlCgkJdGhhdCBzdGFydHMgd2l0aCBFU0MgWyBvciBDU0kgYW5kIGVuZHMgaW4gYSAnYycsIHdpdGggb25seQoJCWRpZ2l0cywgJzsnIGFuZCAnLicgaW4gYmV0d2Vlbi4KCQlXaGVuIHRoaXMgb3B0aW9uIGlzIHNldCwgdGhlIFRlcm1SZXNwb25zZSBhdXRvY29tbWFuZCBldmVudCBpcwoJCWZpcmVkLCBzbyB0aGF0IHlvdSBjYW4gcmVhY3QgdG8gdGhlIHJlc3BvbnNlIGZyb20gdGhlCgkJdGVybWluYWwuCgkJVGhlIHJlc3BvbnNlIGZyb20gYSBuZXcgeHRlcm0gaXM6ICI8RXNjPlsgUHAgOyBQdiA7IFBjIGMiLiAgUHAKCQlpcyB0aGUgdGVybWluYWwgdHlwZTogMCBmb3IgdnQxMDAgYW5kIDEgZm9yIHZ0MjIwLiAgUHYgaXMgdGhlCgkJcGF0Y2ggbGV2ZWwgKHNpbmNlIHRoaXMgd2FzIGludHJvZHVjZWQgaW4gcGF0Y2ggOTUsIGl0J3MKCQlhbHdheXMgOTUgb3IgYmlnZ2VyKS4gIFBjIGlzIGFsd2F5cyB6ZXJvLgoJCXtvbmx5IHdoZW4gY29tcGlsZWQgd2l0aCB8K3Rlcm1yZXNwb25zZXwgZmVhdHVyZX0KCgkJCQkJKnY6dGVzdGluZyogKnRlc3RpbmctdmFyaWFibGUqCnY6dGVzdGluZwlNdXN0IGJlIHNldCBiZWZvcmUgdXNpbmcgYGdhcmJhZ2Vjb2xsZWN0X2Zvcl90ZXN0aW5nKClgLgoKCQkJCSp2OnRoaXNfc2Vzc2lvbiogKnRoaXNfc2Vzc2lvbi12YXJpYWJsZSoKdjp0aGlzX3Nlc3Npb24JRnVsbCBmaWxlbmFtZSBvZiB0aGUgbGFzdCBsb2FkZWQgb3Igc2F2ZWQgc2Vzc2lvbiBmaWxlLiAgU2VlCgkJfDpta3Nlc3Npb258LiAgSXQgaXMgYWxsb3dlZCB0byBzZXQgdGhpcyB2YXJpYWJsZS4gIFdoZW4gbm8KCQlzZXNzaW9uIGZpbGUgaGFzIGJlZW4gc2F2ZWQsIHRoaXMgdmFyaWFibGUgaXMgZW1wdHkuCgkJInRoaXNfc2Vzc2lvbiIgYWxzbyB3b3JrcywgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LgoKCQkJCQkqdjp0aHJvd3BvaW50KiAqdGhyb3dwb2ludC12YXJpYWJsZSoKdjp0aHJvd3BvaW50CVRoZSBwb2ludCB3aGVyZSB0aGUgZXhjZXB0aW9uIG1vc3QgcmVjZW50bHkgY2F1Z2h0IGFuZCBub3QKCQlmaW5pc2hlZCB3YXMgdGhyb3duLiAgTm90IHNldCB3aGVuIGNvbW1hbmRzIGFyZSB0eXBlZC4JU2VlCgkJYWxzbyB8djpleGNlcHRpb258IGFuZCB8dGhyb3ctdmFyaWFibGVzfC4KCQlFeGFtcGxlOiA+Cgk6dHJ5Cgk6ICB0aHJvdyAib29wcyIKCTpjYXRjaCAvLiovCgk6ICBlY2hvICJFeGNlcHRpb24gZnJvbSIgdjp0aHJvd3BvaW50Cgk6ZW5kdHJ5CjwJCU91dHB1dDogIkV4Y2VwdGlvbiBmcm9tIHRlc3QudmltLCBsaW5lIDIiCgoJCQkJCQkqdjp0cnVlKiAqdHJ1ZS12YXJpYWJsZSoKdjp0cnVlCQlBIE51bWJlciB3aXRoIHZhbHVlIG9uZS4gVXNlZCB0byBwdXQgInRydWUiIGluIEpTT04uICBTZWUKCQl8anNvbl9lbmNvZGUoKXwuCgkJV2hlbiB1c2VkIGFzIGEgc3RyaW5nIHRoaXMgZXZhbHVhdGVzIHRvICJ0cnVlIi4gPgoJCQllY2hvIHY6dHJ1ZQo8CQkJdHJ1ZSB+CgkJCQkJCSp2OnZhbCogKnZhbC12YXJpYWJsZSoKdjp2YWwJCVZhbHVlIG9mIHRoZSBjdXJyZW50IGl0ZW0gb2YgYSB8TGlzdHwgb3IgfERpY3Rpb25hcnl8LglPbmx5CgkJdmFsaWQgd2hpbGUgZXZhbHVhdGluZyB0aGUgZXhwcmVzc2lvbiB1c2VkIHdpdGggfG1hcCgpfCBhbmQKCQl8ZmlsdGVyKCl8LiAgUmVhZC1vbmx5LgoKCQkJCQkqdjp2ZXJzaW9uKiAqdmVyc2lvbi12YXJpYWJsZSoKdjp2ZXJzaW9uCVZlcnNpb24gbnVtYmVyIG9mIFZpbTogTWFqb3IgdmVyc2lvbiBudW1iZXIgdGltZXMgMTAwIHBsdXMKCQltaW5vciB2ZXJzaW9uIG51bWJlci4gIFZlcnNpb24gNS4wIGlzIDUwMC4gIFZlcnNpb24gNS4xICg1LjAxKQoJCWlzIDUwMS4gIFJlYWQtb25seS4gICJ2ZXJzaW9uIiBhbHNvIHdvcmtzLCBmb3IgYmFja3dhcmRzCgkJY29tcGF0aWJpbGl0eS4KCQlVc2UgfGhhcygpfCB0byBjaGVjayBpZiBhIGNlcnRhaW4gcGF0Y2ggd2FzIGluY2x1ZGVkLCBlLmcuOiA+CgkJCWlmIGhhcygicGF0Y2gtNy40LjEyMyIpCjwJCU5vdGUgdGhhdCBwYXRjaCBudW1iZXJzIGFyZSBzcGVjaWZpYyB0byB0aGUgdmVyc2lvbiwgdGh1cyBib3RoCgkJdmVyc2lvbiA1LjAgYW5kIDUuMSBtYXkgaGF2ZSBhIHBhdGNoIDEyMywgYnV0IHRoZXNlIGFyZQoJCWNvbXBsZXRlbHkgZGlmZmVyZW50LgoKCQkJCSp2OnZpbV9kaWRfZW50ZXIqICp2aW1fZGlkX2VudGVyLXZhcmlhYmxlKgp2OnZpbV9kaWRfZW50ZXIJWmVybyB1bnRpbCBtb3N0IG9mIHN0YXJ0dXAgaXMgZG9uZS4gIEl0IGlzIHNldCB0byBvbmUganVzdAoJCWJlZm9yZSB8VmltRW50ZXJ8IGF1dG9jb21tYW5kcyBhcmUgdHJpZ2dlcmVkLgoKCQkJCQkqdjp3YXJuaW5nbXNnKiAqd2FybmluZ21zZy12YXJpYWJsZSoKdjp3YXJuaW5nbXNnCUxhc3QgZ2l2ZW4gd2FybmluZyBtZXNzYWdlLiAgSXQncyBhbGxvd2VkIHRvIHNldCB0aGlzIHZhcmlhYmxlLgoKCQkJCQkqdjp3aW5kb3dpZCogKndpbmRvd2lkLXZhcmlhYmxlKgp2OndpbmRvd2lkCVdoZW4gYW55IFgxMSBiYXNlZCBHVUkgaXMgcnVubmluZyBvciB3aGVuIHJ1bm5pbmcgaW4gYQoJCXRlcm1pbmFsIGFuZCBWaW0gY29ubmVjdHMgdG8gdGhlIFggc2VydmVyICh8LVh8KSB0aGlzIHdpbGwgYmUKCQlzZXQgdG8gdGhlIHdpbmRvdyBJRC4KCQlXaGVuIGFuIE1TLVdpbmRvd3MgR1VJIGlzIHJ1bm5pbmcgdGhpcyB3aWxsIGJlIHNldCB0byB0aGUKCQl3aW5kb3cgaGFuZGxlLgoJCU90aGVyd2lzZSB0aGUgdmFsdWUgaXMgemVyby4KCQlOb3RlOiBmb3Igd2luZG93cyBpbnNpZGUgVmltIHVzZSB8d2lubnIoKXwuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KNC4gQnVpbHRpbiBGdW5jdGlvbnMJCQkJCSpmdW5jdGlvbnMqCgpTZWUgfGZ1bmN0aW9uLWxpc3R8IGZvciBhIGxpc3QgZ3JvdXBlZCBieSB3aGF0IHRoZSBmdW5jdGlvbiBpcyB1c2VkIGZvci4KCihVc2UgQ1RSTC1dIG9uIHRoZSBmdW5jdGlvbiBuYW1lIHRvIGp1bXAgdG8gdGhlIGZ1bGwgZXhwbGFuYXRpb24uKQoKVVNBR0UJCQkJUkVTVUxUCURFU0NSSVBUSU9OCX4KCmFicyh7ZXhwcn0pCQkJRmxvYXQgb3IgTnVtYmVyICBhYnNvbHV0ZSB2YWx1ZSBvZiB7ZXhwcn0KYWNvcyh7ZXhwcn0pCQkJRmxvYXQJYXJjIGNvc2luZSBvZiB7ZXhwcn0KYWRkKHtsaXN0fSwge2l0ZW19KQkJTGlzdAlhcHBlbmQge2l0ZW19IHRvIHxMaXN0fCB7bGlzdH0KYWxsb2NfZmFpbCh7aWR9LCB7Y291bnRkb3dufSwge3JlcGVhdH0pCgkJCQlub25lCW1ha2UgbWVtb3J5IGFsbG9jYXRpb24gZmFpbAphbmQoe2V4cHJ9LCB7ZXhwcn0pCQlOdW1iZXIgIGJpdHdpc2UgQU5ECmFwcGVuZCh7bG51bX0sIHtzdHJpbmd9KQlOdW1iZXIJYXBwZW5kIHtzdHJpbmd9IGJlbG93IGxpbmUge2xudW19CmFwcGVuZCh7bG51bX0sIHtsaXN0fSkJCU51bWJlcglhcHBlbmQgbGluZXMge2xpc3R9IGJlbG93IGxpbmUge2xudW19CmFyZ2MoKQkJCQlOdW1iZXIJbnVtYmVyIG9mIGZpbGVzIGluIHRoZSBhcmd1bWVudCBsaXN0CmFyZ2lkeCgpCQkJTnVtYmVyCWN1cnJlbnQgaW5kZXggaW4gdGhlIGFyZ3VtZW50IGxpc3QKYXJnbGlzdGlkKFt7d2lubnJ9IFssIHt0YWJucn1dXSkgTnVtYmVyCWFyZ3VtZW50IGxpc3QgaWQKYXJndih7bnJ9KQkJCVN0cmluZwl7bnJ9IGVudHJ5IG9mIHRoZSBhcmd1bWVudCBsaXN0CmFyZ3YoKQkJCQlMaXN0CXRoZSBhcmd1bWVudCBsaXN0CmFzc2VydF9lcXVhbCh7ZXhwfSwge2FjdH0gWywge21zZ31dKSAgICAgbm9uZSAgYXNzZXJ0IHtleHB9IGlzIGVxdWFsIHRvIHthY3R9CmFzc2VydF9leGNlcHRpb24oe2Vycm9yfSBbLCB7bXNnfV0pICAgICAgbm9uZSAgYXNzZXJ0IHtlcnJvcn0gaXMgaW4gdjpleGNlcHRpb24KYXNzZXJ0X2ZhaWxzKHtjbWR9IFssIHtlcnJvcn1dKSAgICAgICAgICBub25lICBhc3NlcnQge2NtZH0gZmFpbHMKYXNzZXJ0X2ZhbHNlKHthY3R1YWx9IFssIHttc2d9XSkgICAgICAgICBub25lICBhc3NlcnQge2FjdHVhbH0gaXMgZmFsc2UKYXNzZXJ0X21hdGNoKHtwYXR9LCB7dGV4dH0gWywge21zZ31dKSAgICBub25lICBhc3NlcnQge3BhdH0gbWF0Y2hlcyB7dGV4dH0KYXNzZXJ0X25vdGVxdWFsKHtleHB9LCB7YWN0fSBbLCB7bXNnfV0pICBub25lICBhc3NlcnQge2V4cH0gaXMgbm90IGVxdWFsIHthY3R9CmFzc2VydF9ub3RtYXRjaCh7cGF0fSwge3RleHR9IFssIHttc2d9XSkgbm9uZSAgYXNzZXJ0IHtwYXR9IG5vdCBtYXRjaGVzIHt0ZXh0fQphc3NlcnRfdHJ1ZSh7YWN0dWFsfSBbLCB7bXNnfV0pICAgICAgICAgIG5vbmUgIGFzc2VydCB7YWN0dWFsfSBpcyB0cnVlCmFzaW4oe2V4cHJ9KQkJCUZsb2F0CWFyYyBzaW5lIG9mIHtleHByfQphdGFuKHtleHByfSkJCQlGbG9hdAlhcmMgdGFuZ2VudCBvZiB7ZXhwcn0KYXRhbjIoe2V4cHJ9LCB7ZXhwcn0pCQlGbG9hdCAgIGFyYyB0YW5nZW50IG9mIHtleHByMX0gLyB7ZXhwcjJ9CmJyb3dzZSh7c2F2ZX0sIHt0aXRsZX0sIHtpbml0ZGlyfSwge2RlZmF1bHR9KQoJCQkJU3RyaW5nCXB1dCB1cCBhIGZpbGUgcmVxdWVzdGVyCmJyb3dzZWRpcih7dGl0bGV9LCB7aW5pdGRpcn0pCVN0cmluZwlwdXQgdXAgYSBkaXJlY3RvcnkgcmVxdWVzdGVyCmJ1ZmV4aXN0cyh7ZXhwcn0pCQlOdW1iZXIJVFJVRSBpZiBidWZmZXIge2V4cHJ9IGV4aXN0cwpidWZsaXN0ZWQoe2V4cHJ9KQkJTnVtYmVyCVRSVUUgaWYgYnVmZmVyIHtleHByfSBpcyBsaXN0ZWQKYnVmbG9hZGVkKHtleHByfSkJCU51bWJlcglUUlVFIGlmIGJ1ZmZlciB7ZXhwcn0gaXMgbG9hZGVkCmJ1Zm5hbWUoe2V4cHJ9KQkJCVN0cmluZwlOYW1lIG9mIHRoZSBidWZmZXIge2V4cHJ9CmJ1Zm5yKHtleHByfSBbLCB7Y3JlYXRlfV0pCU51bWJlcglOdW1iZXIgb2YgdGhlIGJ1ZmZlciB7ZXhwcn0KYnVmd2lubnIoe2V4cHJ9KQkJTnVtYmVyCXdpbmRvdyBudW1iZXIgb2YgYnVmZmVyIHtleHByfQpieXRlMmxpbmUoe2J5dGV9KQkJTnVtYmVyCWxpbmUgbnVtYmVyIGF0IGJ5dGUgY291bnQge2J5dGV9CmJ5dGVpZHgoe2V4cHJ9LCB7bnJ9KQkJTnVtYmVyCWJ5dGUgaW5kZXggb2Yge25yfSd0aCBjaGFyIGluIHtleHByfQpieXRlaWR4Y29tcCh7ZXhwcn0sIHtucn0pCU51bWJlcglieXRlIGluZGV4IG9mIHtucn0ndGggY2hhciBpbiB7ZXhwcn0KY2FsbCh7ZnVuY30sIHthcmdsaXN0fSBbLCB7ZGljdH1dKQoJCQkJYW55CWNhbGwge2Z1bmN9IHdpdGggYXJndW1lbnRzIHthcmdsaXN0fQpjZWlsKHtleHByfSkJCQlGbG9hdAlyb3VuZCB7ZXhwcn0gdXAKY2hfY2xvc2Uoe2hhbmRsZX0pCQlub25lCWNsb3NlIHtoYW5kbGV9CmNoX2V2YWxleHByKHtoYW5kbGV9LCB7ZXhwcn0gWywge29wdGlvbnN9XSkKCQkJCWFueQlldmFsdWF0ZSB7ZXhwcn0gb24gSlNPTiB7aGFuZGxlfQpjaF9ldmFscmF3KHtoYW5kbGV9LCB7c3RyaW5nfSBbLCB7b3B0aW9uc31dKQoJCQkJYW55CWV2YWx1YXRlIHtzdHJpbmd9IG9uIHJhdyB7aGFuZGxlfQpjaF9nZXRidWZucih7aGFuZGxlfSwge3doYXR9KQlOdW1iZXIJZ2V0IGJ1ZmZlciBudW1iZXIgZm9yIHtoYW5kbGV9L3t3aGF0fQpjaF9nZXRqb2Ioe2NoYW5uZWx9KQkJSm9iCWdldCB0aGUgSm9iIG9mIHtjaGFubmVsfQpjaF9pbmZvKHtoYW5kbGV9KQkJU3RyaW5nCWluZm8gYWJvdXQgY2hhbm5lbCAge2hhbmRsZX0KY2hfbG9nKHttc2d9IFssIHtoYW5kbGV9XSkJbm9uZQl3cml0ZSB7bXNnfSBpbiB0aGUgY2hhbm5lbCBsb2cgZmlsZQpjaF9sb2dmaWxlKHtmbmFtZX0gWywge21vZGV9XSkJbm9uZQlzdGFydCBsb2dnaW5nIGNoYW5uZWwgYWN0aXZpdHkKY2hfb3Blbih7YWRkcmVzc30gWywge29wdGlvbnN9XSkKCQkJCUNoYW5uZWwgb3BlbiBhIGNoYW5uZWwgdG8ge2FkZHJlc3N9CmNoX3JlYWQoe2hhbmRsZX0gWywge29wdGlvbnN9XSkgU3RyaW5nICByZWFkIGZyb20gIHtoYW5kbGV9CmNoX3JlYWRyYXcoe2hhbmRsZX0gWywge29wdGlvbnN9XSkKCQkJCVN0cmluZyAgcmVhZCByYXcgZnJvbSAge2hhbmRsZX0KY2hfc2VuZGV4cHIoe2hhbmRsZX0sIHtleHByfSBbLCB7b3B0aW9uc31dKQoJCQkJYW55CXNlbmQge2V4cHJ9IG92ZXIgSlNPTiB7aGFuZGxlfQpjaF9zZW5kcmF3KHtoYW5kbGV9LCB7c3RyaW5nfSBbLCB7b3B0aW9uc31dKQoJCQkJYW55CXNlbmQge3N0cmluZ30gb3ZlciByYXcge2hhbmRsZX0KY2hfc2V0b3B0aW9ucyh7aGFuZGxlfSwge29wdGlvbnN9KQoJCQkJbm9uZQlzZXQgb3B0aW9ucyBmb3Ige2hhbmRsZX0KY2hfc3RhdHVzKHtoYW5kbGV9KQkJU3RyaW5nCXN0YXR1cyBvZiBjaGFubmVsICB7aGFuZGxlfQpjaGFuZ2VucigpCQkJTnVtYmVyCWN1cnJlbnQgY2hhbmdlIG51bWJlcgpjaGFyMm5yKHtleHByfVssIHt1dGY4fV0pCU51bWJlcglBU0NJSS9VVEY4IHZhbHVlIG9mIGZpcnN0IGNoYXIgaW4ge2V4cHJ9CmNpbmRlbnQoe2xudW19KQkJCU51bWJlcglDIGluZGVudCBmb3IgbGluZSB7bG51bX0KY2xlYXJtYXRjaGVzKCkJCQlub25lCWNsZWFyIGFsbCBtYXRjaGVzCmNvbCh7ZXhwcn0pCQkJTnVtYmVyCWNvbHVtbiBuciBvZiBjdXJzb3Igb3IgbWFyawpjb21wbGV0ZSh7c3RhcnRjb2x9LCB7bWF0Y2hlc30pIG5vbmUJc2V0IEluc2VydCBtb2RlIGNvbXBsZXRpb24KY29tcGxldGVfYWRkKHtleHByfSkJCU51bWJlcglhZGQgY29tcGxldGlvbiBtYXRjaApjb21wbGV0ZV9jaGVjaygpCQlOdW1iZXIJY2hlY2sgZm9yIGtleSB0eXBlZCBkdXJpbmcgY29tcGxldGlvbgpjb25maXJtKHttc2d9IFssIHtjaG9pY2VzfSBbLCB7ZGVmYXVsdH0gWywge3R5cGV9XV1dKQoJCQkJTnVtYmVyCW51bWJlciBvZiBjaG9pY2UgcGlja2VkIGJ5IHVzZXIKY29weSh7ZXhwcn0pCQkJYW55CW1ha2UgYSBzaGFsbG93IGNvcHkgb2Yge2V4cHJ9CmNvcyh7ZXhwcn0pCQkJRmxvYXQJY29zaW5lIG9mIHtleHByfQpjb3NoKHtleHByfSkJCQlGbG9hdAloeXBlcmJvbGljIGNvc2luZSBvZiB7ZXhwcn0KY291bnQoe2xpc3R9LCB7ZXhwcn0gWywge2ljfSBbLCB7c3RhcnR9XV0pCgkJCQlOdW1iZXIJIGNvdW50IGhvdyBtYW55IHtleHByfSBhcmUgaW4ge2xpc3R9CmNzY29wZV9jb25uZWN0aW9uKFt7bnVtfSAsIHtkYnBhdGh9IFssIHtwcmVwZW5kfV1dKQoJCQkJTnVtYmVyCWNoZWNrcyBleGlzdGVuY2Ugb2YgY3Njb3BlIGNvbm5lY3Rpb24KY3Vyc29yKHtsbnVtfSwge2NvbH0gWywge29mZn1dKQoJCQkJTnVtYmVyCW1vdmUgY3Vyc29yIHRvIHtsbnVtfSwge2NvbH0sIHtvZmZ9CmN1cnNvcih7bGlzdH0pCQkJTnVtYmVyCW1vdmUgY3Vyc29yIHRvIHBvc2l0aW9uIGluIHtsaXN0fQpkZWVwY29weSh7ZXhwcn0gWywge25vcmVmfV0pCWFueQltYWtlIGEgZnVsbCBjb3B5IG9mIHtleHByfQpkZWxldGUoe2ZuYW1lfSBbLCB7ZmxhZ3N9XSkJTnVtYmVyCWRlbGV0ZSB0aGUgZmlsZSBvciBkaXJlY3Rvcnkge2ZuYW1lfQpkaWRfZmlsZXR5cGUoKQkJCU51bWJlcglUUlVFIGlmIEZpbGVUeXBlIGF1dG9jb21tYW5kIGV2ZW50IHVzZWQKZGlmZl9maWxsZXIoe2xudW19KQkJTnVtYmVyCWRpZmYgZmlsbGVyIGxpbmVzIGFib3V0IHtsbnVtfQpkaWZmX2hsSUQoe2xudW19LCB7Y29sfSkJTnVtYmVyCWRpZmYgaGlnaGxpZ2h0aW5nIGF0IHtsbnVtfS97Y29sfQpkaXNhYmxlX2NoYXJfYXZhaWxfZm9yX3Rlc3Rpbmcoe2V4cHJ9KQoJCQkJbm9uZQl0ZXN0IHdpdGhvdXQgdHlwZWFoZWFkCmVtcHR5KHtleHByfSkJCQlOdW1iZXIJVFJVRSBpZiB7ZXhwcn0gaXMgZW1wdHkKZXNjYXBlKHtzdHJpbmd9LCB7Y2hhcnN9KQlTdHJpbmcJZXNjYXBlIHtjaGFyc30gaW4ge3N0cmluZ30gd2l0aCAnXCcKZXZhbCh7c3RyaW5nfSkJCQlhbnkJZXZhbHVhdGUge3N0cmluZ30gaW50byBpdHMgdmFsdWUKZXZlbnRoYW5kbGVyKCkJCQlOdW1iZXIJVFJVRSBpZiBpbnNpZGUgYW4gZXZlbnQgaGFuZGxlcgpleGVjdXRhYmxlKHtleHByfSkJCU51bWJlcgkxIGlmIGV4ZWN1dGFibGUge2V4cHJ9IGV4aXN0cwpleGVwYXRoKHtleHByfSkJCQlTdHJpbmcgIGZ1bGwgcGF0aCBvZiB0aGUgY29tbWFuZCB7ZXhwcn0KZXhpc3RzKHtleHByfSkJCQlOdW1iZXIJVFJVRSBpZiB7ZXhwcn0gZXhpc3RzCmV4dGVuZCh7ZXhwcjF9LCB7ZXhwcjJ9IFssIHtleHByM31dKQoJCQkJTGlzdC9EaWN0IGluc2VydCBpdGVtcyBvZiB7ZXhwcjJ9IGludG8ge2V4cHIxfQpleHAoe2V4cHJ9KQkJCUZsb2F0CWV4cG9uZW50aWFsIG9mIHtleHByfQpleHBhbmQoe2V4cHJ9IFssIHtub3N1Zn0gWywge2xpc3R9XV0pCgkJCQlhbnkJZXhwYW5kIHNwZWNpYWwga2V5d29yZHMgaW4ge2V4cHJ9CmZlZWRrZXlzKHtzdHJpbmd9IFssIHttb2RlfV0pCU51bWJlcglhZGQga2V5IHNlcXVlbmNlIHRvIHR5cGVhaGVhZCBidWZmZXIKZmlsZXJlYWRhYmxlKHtmaWxlfSkJCU51bWJlcglUUlVFIGlmIHtmaWxlfSBpcyBhIHJlYWRhYmxlIGZpbGUKZmlsZXdyaXRhYmxlKHtmaWxlfSkJCU51bWJlcglUUlVFIGlmIHtmaWxlfSBpcyBhIHdyaXRhYmxlIGZpbGUKZmlsdGVyKHtleHByfSwge3N0cmluZ30pCUxpc3QvRGljdCAgcmVtb3ZlIGl0ZW1zIGZyb20ge2V4cHJ9IHdoZXJlCgkJCQkJe3N0cmluZ30gaXMgMApmaW5kZGlyKHtuYW1lfVssIHtwYXRofVssIHtjb3VudH1dXSkKCQkJCVN0cmluZwlmaW5kIGRpcmVjdG9yeSB7bmFtZX0gaW4ge3BhdGh9CmZpbmRmaWxlKHtuYW1lfVssIHtwYXRofVssIHtjb3VudH1dXSkKCQkJCVN0cmluZwlmaW5kIGZpbGUge25hbWV9IGluIHtwYXRofQpmbG9hdDJucih7ZXhwcn0pCQlOdW1iZXIJY29udmVydCBGbG9hdCB7ZXhwcn0gdG8gYSBOdW1iZXIKZmxvb3Ioe2V4cHJ9KQkJCUZsb2F0CXJvdW5kIHtleHByfSBkb3duCmZtb2Qoe2V4cHIxfSwge2V4cHIyfSkJCUZsb2F0CXJlbWFpbmRlciBvZiB7ZXhwcjF9IC8ge2V4cHIyfQpmbmFtZWVzY2FwZSh7Zm5hbWV9KQkJU3RyaW5nCWVzY2FwZSBzcGVjaWFsIGNoYXJhY3RlcnMgaW4ge2ZuYW1lfQpmbmFtZW1vZGlmeSh7Zm5hbWV9LCB7bW9kc30pCVN0cmluZwltb2RpZnkgZmlsZSBuYW1lCmZvbGRjbG9zZWQoe2xudW19KQkJTnVtYmVyCWZpcnN0IGxpbmUgb2YgZm9sZCBhdCB7bG51bX0gaWYgY2xvc2VkCmZvbGRjbG9zZWRlbmQoe2xudW19KQkJTnVtYmVyCWxhc3QgbGluZSBvZiBmb2xkIGF0IHtsbnVtfSBpZiBjbG9zZWQKZm9sZGxldmVsKHtsbnVtfSkJCU51bWJlcglmb2xkIGxldmVsIGF0IHtsbnVtfQpmb2xkdGV4dCgpCQkJU3RyaW5nCWxpbmUgZGlzcGxheWVkIGZvciBjbG9zZWQgZm9sZApmb2xkdGV4dHJlc3VsdCh7bG51bX0pCQlTdHJpbmcJdGV4dCBmb3IgY2xvc2VkIGZvbGQgYXQge2xudW19CmZvcmVncm91bmQoKQkJCU51bWJlcglicmluZyB0aGUgVmltIHdpbmRvdyB0byB0aGUgZm9yZWdyb3VuZApmdW5jdGlvbih7bmFtZX0gWywge2FyZ2xpc3R9XSBbLCB7ZGljdH1dKQoJCQkJRnVuY3JlZiByZWZlcmVuY2UgdG8gZnVuY3Rpb24ge25hbWV9CmdhcmJhZ2Vjb2xsZWN0KFt7YXRleGl0fV0pCW5vbmUJZnJlZSBtZW1vcnksIGJyZWFraW5nIGN5Y2xpYyByZWZlcmVuY2VzCmdhcmJhZ2Vjb2xsZWN0X2Zvcl90ZXN0aW5nKCkJbm9uZQlmcmVlIG1lbW9yeSByaWdodCBub3cKZ2V0KHtsaXN0fSwge2lkeH0gWywge2RlZn1dKQlhbnkJZ2V0IGl0ZW0ge2lkeH0gZnJvbSB7bGlzdH0gb3Ige2RlZn0KZ2V0KHtkaWN0fSwge2tleX0gWywge2RlZn1dKQlhbnkJZ2V0IGl0ZW0ge2tleX0gZnJvbSB7ZGljdH0gb3Ige2RlZn0KZ2V0YnVmbGluZSh7ZXhwcn0sIHtsbnVtfSBbLCB7ZW5kfV0pCgkJCQlMaXN0CWxpbmVzIHtsbnVtfSB0byB7ZW5kfSBvZiBidWZmZXIge2V4cHJ9CmdldGJ1ZnZhcih7ZXhwcn0sIHt2YXJuYW1lfSBbLCB7ZGVmfV0pCgkJCQlhbnkJdmFyaWFibGUge3Zhcm5hbWV9IGluIGJ1ZmZlciB7ZXhwcn0KZ2V0Y2hhcihbZXhwcl0pCQkJTnVtYmVyCWdldCBvbmUgY2hhcmFjdGVyIGZyb20gdGhlIHVzZXIKZ2V0Y2hhcm1vZCgpCQkJTnVtYmVyCW1vZGlmaWVycyBmb3IgdGhlIGxhc3QgdHlwZWQgY2hhcmFjdGVyCmdldGNoYXJzZWFyY2goKQkJCURpY3QJbGFzdCBjaGFyYWN0ZXIgc2VhcmNoCmdldGNtZGxpbmUoKQkJCVN0cmluZwlyZXR1cm4gdGhlIGN1cnJlbnQgY29tbWFuZC1saW5lCmdldGNtZHBvcygpCQkJTnVtYmVyCXJldHVybiBjdXJzb3IgcG9zaXRpb24gaW4gY29tbWFuZC1saW5lCmdldGNtZHR5cGUoKQkJCVN0cmluZwlyZXR1cm4gY3VycmVudCBjb21tYW5kLWxpbmUgdHlwZQpnZXRjbWR3aW50eXBlKCkJCQlTdHJpbmcJcmV0dXJuIGN1cnJlbnQgY29tbWFuZC1saW5lIHdpbmRvdyB0eXBlCmdldGN1cnBvcygpCQkJTGlzdAlwb3NpdGlvbiBvZiB0aGUgY3Vyc29yCmdldGN3ZChbe3dpbm5yfSBbLCB7dGFibnJ9XV0pCVN0cmluZwlnZXQgdGhlIGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkKZ2V0Zm9udG5hbWUoW3tuYW1lfV0pCQlTdHJpbmcJbmFtZSBvZiBmb250IGJlaW5nIHVzZWQKZ2V0ZnBlcm0oe2ZuYW1lfSkJCVN0cmluZwlmaWxlIHBlcm1pc3Npb25zIG9mIGZpbGUge2ZuYW1lfQpnZXRmc2l6ZSh7Zm5hbWV9KQkJTnVtYmVyCXNpemUgaW4gYnl0ZXMgb2YgZmlsZSB7Zm5hbWV9CmdldGZ0aW1lKHtmbmFtZX0pCQlOdW1iZXIJbGFzdCBtb2RpZmljYXRpb24gdGltZSBvZiBmaWxlCmdldGZ0eXBlKHtmbmFtZX0pCQlTdHJpbmcJZGVzY3JpcHRpb24gb2YgdHlwZSBvZiBmaWxlIHtmbmFtZX0KZ2V0bGluZSh7bG51bX0pCQkJU3RyaW5nCWxpbmUge2xudW19IG9mIGN1cnJlbnQgYnVmZmVyCmdldGxpbmUoe2xudW19LCB7ZW5kfSkJCUxpc3QJbGluZXMge2xudW19IHRvIHtlbmR9IG9mIGN1cnJlbnQgYnVmZmVyCmdldGxvY2xpc3Qoe25yfSkJCUxpc3QJbGlzdCBvZiBsb2NhdGlvbiBsaXN0IGl0ZW1zCmdldG1hdGNoZXMoKQkJCUxpc3QJbGlzdCBvZiBjdXJyZW50IG1hdGNoZXMKZ2V0cGlkKCkJCQlOdW1iZXIJcHJvY2VzcyBJRCBvZiBWaW0KZ2V0cG9zKHtleHByfSkJCQlMaXN0CXBvc2l0aW9uIG9mIGN1cnNvciwgbWFyaywgZXRjLgpnZXRxZmxpc3QoKQkJCUxpc3QJbGlzdCBvZiBxdWlja2ZpeCBpdGVtcwpnZXRyZWcoW3tyZWduYW1lfSBbLCAxIFssIHtsaXN0fV1dXSkKCQkJCVN0cmluZyBvciBMaXN0ICAgY29udGVudHMgb2YgcmVnaXN0ZXIKZ2V0cmVndHlwZShbe3JlZ25hbWV9XSkJCVN0cmluZwl0eXBlIG9mIHJlZ2lzdGVyCmdldHRhYnZhcih7bnJ9LCB7dmFybmFtZX0gWywge2RlZn1dKQoJCQkJYW55CXZhcmlhYmxlIHt2YXJuYW1lfSBpbiB0YWIge25yfSBvciB7ZGVmfQpnZXR0YWJ3aW52YXIoe3RhYm5yfSwge3dpbm5yfSwge25hbWV9IFssIHtkZWZ9XSkKCQkJCWFueQl7bmFtZX0gaW4ge3dpbm5yfSBpbiB0YWIgcGFnZSB7dGFibnJ9CmdldHdpbnBvc3goKQkJCU51bWJlcglYIGNvb3JkIGluIHBpeGVscyBvZiBHVUkgVmltIHdpbmRvdwpnZXR3aW5wb3N5KCkJCQlOdW1iZXIJWSBjb29yZCBpbiBwaXhlbHMgb2YgR1VJIFZpbSB3aW5kb3cKZ2V0d2ludmFyKHtucn0sIHt2YXJuYW1lfSBbLCB7ZGVmfV0pCgkJCQlhbnkJdmFyaWFibGUge3Zhcm5hbWV9IGluIHdpbmRvdyB7bnJ9Cmdsb2Ioe2V4cHJ9IFssIHtub3N1Zn0gWywge2xpc3R9IFssIHthbGxsaW5rc31dXV0pCgkJCQlhbnkJZXhwYW5kIGZpbGUgd2lsZGNhcmRzIGluIHtleHByfQpnbG9iMnJlZ3BhdCh7ZXhwcn0pCQlTdHJpbmcgIGNvbnZlcnQgYSBnbG9iIHBhdCBpbnRvIGEgc2VhcmNoIHBhdApnbG9icGF0aCh7cGF0aH0sIHtleHByfSBbLCB7bm9zdWZ9IFssIHtsaXN0fSBbLCB7YWxsbGlua3N9XV1dKQoJCQkJU3RyaW5nCWRvIGdsb2Ioe2V4cHJ9KSBmb3IgYWxsIGRpcnMgaW4ge3BhdGh9Cmhhcyh7ZmVhdHVyZX0pCQkJTnVtYmVyCVRSVUUgaWYgZmVhdHVyZSB7ZmVhdHVyZX0gc3VwcG9ydGVkCmhhc19rZXkoe2RpY3R9LCB7a2V5fSkJCU51bWJlcglUUlVFIGlmIHtkaWN0fSBoYXMgZW50cnkge2tleX0KaGFzbG9jYWxkaXIoW3t3aW5ucn0gWywge3RhYm5yfV1dKQoJCQkJTnVtYmVyCVRSVUUgaWYgdGhlIHdpbmRvdyBleGVjdXRlZCB8OmxjZHwKaGFzbWFwdG8oe3doYXR9IFssIHttb2RlfSBbLCB7YWJicn1dXSkKCQkJCU51bWJlcglUUlVFIGlmIG1hcHBpbmcgdG8ge3doYXR9IGV4aXN0cwpoaXN0YWRkKHtoaXN0b3J5fSwge2l0ZW19KQlTdHJpbmcJYWRkIGFuIGl0ZW0gdG8gYSBoaXN0b3J5Cmhpc3RkZWwoe2hpc3Rvcnl9IFssIHtpdGVtfV0pCVN0cmluZwlyZW1vdmUgYW4gaXRlbSBmcm9tIGEgaGlzdG9yeQpoaXN0Z2V0KHtoaXN0b3J5fSBbLCB7aW5kZXh9XSkJU3RyaW5nCWdldCB0aGUgaXRlbSB7aW5kZXh9IGZyb20gYSBoaXN0b3J5Cmhpc3Rucih7aGlzdG9yeX0pCQlOdW1iZXIJaGlnaGVzdCBpbmRleCBvZiBhIGhpc3RvcnkKaGxleGlzdHMoe25hbWV9KQkJTnVtYmVyCVRSVUUgaWYgaGlnaGxpZ2h0IGdyb3VwIHtuYW1lfSBleGlzdHMKaGxJRCh7bmFtZX0pCQkJTnVtYmVyCXN5bnRheCBJRCBvZiBoaWdobGlnaHQgZ3JvdXAge25hbWV9Cmhvc3RuYW1lKCkJCQlTdHJpbmcJbmFtZSBvZiB0aGUgbWFjaGluZSBWaW0gaXMgcnVubmluZyBvbgppY29udih7ZXhwcn0sIHtmcm9tfSwge3RvfSkJU3RyaW5nCWNvbnZlcnQgZW5jb2Rpbmcgb2Yge2V4cHJ9CmluZGVudCh7bG51bX0pCQkJTnVtYmVyCWluZGVudCBvZiBsaW5lIHtsbnVtfQppbmRleCh7bGlzdH0sIHtleHByfSBbLCB7c3RhcnR9IFssIHtpY31dXSkKCQkJCU51bWJlcglpbmRleCBpbiB7bGlzdH0gd2hlcmUge2V4cHJ9IGFwcGVhcnMKaW5wdXQoe3Byb21wdH0gWywge3RleHR9IFssIHtjb21wbGV0aW9ufV1dKQoJCQkJU3RyaW5nCWdldCBpbnB1dCBmcm9tIHRoZSB1c2VyCmlucHV0ZGlhbG9nKHtwcm9tcHR9IFssIHt0ZXh0fSBbLCB7Y29tcGxldGlvbn1dXV0pCgkJCQlTdHJpbmcgIGxpa2UgaW5wdXQoKSBidXQgaW4gYSBHVUkgZGlhbG9nCmlucHV0bGlzdCh7dGV4dGxpc3R9KQkJTnVtYmVyCWxldCB0aGUgdXNlciBwaWNrIGZyb20gYSBjaG9pY2UgbGlzdAppbnB1dHJlc3RvcmUoKQkJCU51bWJlcglyZXN0b3JlIHR5cGVhaGVhZAppbnB1dHNhdmUoKQkJCU51bWJlcglzYXZlIGFuZCBjbGVhciB0eXBlYWhlYWQKaW5wdXRzZWNyZXQoe3Byb21wdH0gWywge3RleHR9XSkgU3RyaW5nICBsaWtlIGlucHV0KCkgYnV0IGhpZGluZyB0aGUgdGV4dAppbnNlcnQoe2xpc3R9LCB7aXRlbX0gWywge2lkeH1dKSBMaXN0CWluc2VydCB7aXRlbX0gaW4ge2xpc3R9IFtiZWZvcmUge2lkeH1dCmludmVydCh7ZXhwcn0pCQkJTnVtYmVyICBiaXR3aXNlIGludmVydAppc2RpcmVjdG9yeSh7ZGlyZWN0b3J5fSkJTnVtYmVyCVRSVUUgaWYge2RpcmVjdG9yeX0gaXMgYSBkaXJlY3RvcnkKaXNsb2NrZWQoe2V4cHJ9KQkJTnVtYmVyCVRSVUUgaWYge2V4cHJ9IGlzIGxvY2tlZAppc25hbih7ZXhwcn0pCQkJTnVtYmVyICBUUlVFIGlmIHtleHByfSBpcyBOYU4KaXRlbXMoe2RpY3R9KQkJCUxpc3QJa2V5LXZhbHVlIHBhaXJzIGluIHtkaWN0fQpqb2JfZ2V0Y2hhbm5lbCh7am9ifSkJCUNoYW5uZWwJZ2V0IHRoZSBjaGFubmVsIGhhbmRsZSBmb3Ige2pvYn0Kam9iX2luZm8oe2pvYn0pCQkJRGljdAlnZXQgaW5mb3JtYXRpb24gYWJvdXQge2pvYn0Kam9iX3NldG9wdGlvbnMoe2pvYn0sIHtvcHRpb25zfSkgbm9uZQlzZXQgb3B0aW9ucyBmb3Ige2pvYn0Kam9iX3N0YXJ0KHtjb21tYW5kfSBbLCB7b3B0aW9uc31dKQoJCQkJSm9iCSBzdGFydCBhIGpvYgpqb2Jfc3RhdHVzKHtqb2J9KQkJU3RyaW5nCWdldCB0aGUgc3RhdHVzIG9mIHtqb2J9CmpvYl9zdG9wKHtqb2J9IFssIHtob3d9XSkJTnVtYmVyCXN0b3Age2pvYn0Kam9pbih7bGlzdH0gWywge3NlcH1dKQkJU3RyaW5nCWpvaW4ge2xpc3R9IGl0ZW1zIGludG8gb25lIFN0cmluZwpqc19kZWNvZGUoe3N0cmluZ30pCQlhbnkJZGVjb2RlIEpTIHN0eWxlIEpTT04KanNfZW5jb2RlKHtleHByfSkJCVN0cmluZwllbmNvZGUgSlMgc3R5bGUgSlNPTgpqc29uX2RlY29kZSh7c3RyaW5nfSkJCWFueQlkZWNvZGUgSlNPTgpqc29uX2VuY29kZSh7ZXhwcn0pCQlTdHJpbmcJZW5jb2RlIEpTT04Ka2V5cyh7ZGljdH0pCQkJTGlzdAlrZXlzIGluIHtkaWN0fQpsZW4oe2V4cHJ9KQkJCU51bWJlcgl0aGUgbGVuZ3RoIG9mIHtleHByfQpsaWJjYWxsKHtsaWJ9LCB7ZnVuY30sIHthcmd9KQlTdHJpbmcJY2FsbCB7ZnVuY30gaW4gbGlicmFyeSB7bGlifSB3aXRoIHthcmd9CmxpYmNhbGxucih7bGlifSwge2Z1bmN9LCB7YXJnfSkgIE51bWJlciAgaWRlbSwgYnV0IHJldHVybiBhIE51bWJlcgpsaW5lKHtleHByfSkJCQlOdW1iZXIJbGluZSBuciBvZiBjdXJzb3IsIGxhc3QgbGluZSBvciBtYXJrCmxpbmUyYnl0ZSh7bG51bX0pCQlOdW1iZXIJYnl0ZSBjb3VudCBvZiBsaW5lIHtsbnVtfQpsaXNwaW5kZW50KHtsbnVtfSkJCU51bWJlcglMaXNwIGluZGVudCBmb3IgbGluZSB7bG51bX0KbG9jYWx0aW1lKCkJCQlOdW1iZXIJY3VycmVudCB0aW1lCmxvZyh7ZXhwcn0pCQkJRmxvYXQJbmF0dXJhbCBsb2dhcml0aG0gKGJhc2UgZSkgb2Yge2V4cHJ9CmxvZzEwKHtleHByfSkJCQlGbG9hdAlsb2dhcml0aG0gb2YgRmxvYXQge2V4cHJ9IHRvIGJhc2UgMTAKbHVhZXZhbCh7ZXhwcn1bLCB7ZXhwcn1dKQlhbnkJZXZhbHVhdGUgfEx1YXwgZXhwcmVzc2lvbgptYXAoe2V4cHJ9LCB7c3RyaW5nfSkJCUxpc3QvRGljdCAgY2hhbmdlIGVhY2ggaXRlbSBpbiB7ZXhwcn0gdG8ge2V4cHJ9Cm1hcGFyZyh7bmFtZX1bLCB7bW9kZX0gWywge2FiYnJ9IFssIHtkaWN0fV1dXSkKCQkJCVN0cmluZyBvciBEaWN0CgkJCQkJcmhzIG9mIG1hcHBpbmcge25hbWV9IGluIG1vZGUge21vZGV9Cm1hcGNoZWNrKHtuYW1lfVssIHttb2RlfSBbLCB7YWJicn1dXSkKCQkJCVN0cmluZwljaGVjayBmb3IgbWFwcGluZ3MgbWF0Y2hpbmcge25hbWV9Cm1hdGNoKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQoJCQkJTnVtYmVyCXBvc2l0aW9uIHdoZXJlIHtwYXR9IG1hdGNoZXMgaW4ge2V4cHJ9Cm1hdGNoYWRkKHtncm91cH0sIHtwYXR0ZXJufVssIHtwcmlvcml0eX1bLCB7aWR9IFssIHtkaWN0fV1dXSkKCQkJCU51bWJlcgloaWdobGlnaHQge3BhdHRlcm59IHdpdGgge2dyb3VwfQptYXRjaGFkZHBvcyh7Z3JvdXB9LCB7cG9zfVssIHtwcmlvcml0eX1bLCB7aWR9Wywge2RpY3R9XV1dKQoJCQkJTnVtYmVyCWhpZ2hsaWdodCBwb3NpdGlvbnMgd2l0aCB7Z3JvdXB9Cm1hdGNoYXJnKHtucn0pCQkJTGlzdAlhcmd1bWVudHMgb2YgfDptYXRjaHwKbWF0Y2hkZWxldGUoe2lkfSkJCU51bWJlcglkZWxldGUgbWF0Y2ggaWRlbnRpZmllZCBieSB7aWR9Cm1hdGNoZW5kKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQoJCQkJTnVtYmVyCXBvc2l0aW9uIHdoZXJlIHtwYXR9IGVuZHMgaW4ge2V4cHJ9Cm1hdGNobGlzdCh7ZXhwcn0sIHtwYXR9Wywge3N0YXJ0fVssIHtjb3VudH1dXSkKCQkJCUxpc3QJbWF0Y2ggYW5kIHN1Ym1hdGNoZXMgb2Yge3BhdH0gaW4ge2V4cHJ9Cm1hdGNoc3RyKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQoJCQkJU3RyaW5nCXtjb3VudH0ndGggbWF0Y2ggb2Yge3BhdH0gaW4ge2V4cHJ9Cm1hdGNoc3RycG9zKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQoJCQkJTGlzdAl7Y291bnR9J3RoIG1hdGNoIG9mIHtwYXR9IGluIHtleHByfQptYXgoe2xpc3R9KQkJCU51bWJlcgltYXhpbXVtIHZhbHVlIG9mIGl0ZW1zIGluIHtsaXN0fQptaW4oe2xpc3R9KQkJCU51bWJlcgltaW5pbXVtIHZhbHVlIG9mIGl0ZW1zIGluIHtsaXN0fQpta2Rpcih7bmFtZX0gWywge3BhdGh9IFssIHtwcm90fV1dKQoJCQkJTnVtYmVyCWNyZWF0ZSBkaXJlY3Rvcnkge25hbWV9Cm1vZGUoW2V4cHJdKQkJCVN0cmluZwljdXJyZW50IGVkaXRpbmcgbW9kZQptemV2YWwoe2V4cHJ9KQkJCWFueQlldmFsdWF0ZSB8TXpTY2hlbWV8IGV4cHJlc3Npb24KbmV4dG5vbmJsYW5rKHtsbnVtfSkJCU51bWJlcglsaW5lIG5yIG9mIG5vbi1ibGFuayBsaW5lID49IHtsbnVtfQpucjJjaGFyKHtleHByfVssIHt1dGY4fV0pCVN0cmluZwlzaW5nbGUgY2hhciB3aXRoIEFTQ0lJL1VURjggdmFsdWUge2V4cHJ9Cm9yKHtleHByfSwge2V4cHJ9KQkJTnVtYmVyICBiaXR3aXNlIE9SCnBhdGhzaG9ydGVuKHtleHByfSkJCVN0cmluZwlzaG9ydGVuIGRpcmVjdG9yeSBuYW1lcyBpbiBhIHBhdGgKcGVybGV2YWwoe2V4cHJ9KQkJYW55CWV2YWx1YXRlIHxQZXJsfCBleHByZXNzaW9uCnBvdyh7eH0sIHt5fSkJCQlGbG9hdAl7eH0gdG8gdGhlIHBvd2VyIG9mIHt5fQpwcmV2bm9uYmxhbmsoe2xudW19KQkJTnVtYmVyCWxpbmUgbnIgb2Ygbm9uLWJsYW5rIGxpbmUgPD0ge2xudW19CnByaW50Zih7Zm10fSwge2V4cHIxfS4uLikJU3RyaW5nCWZvcm1hdCB0ZXh0CnB1bXZpc2libGUoKQkJCU51bWJlcgl3aGV0aGVyIHBvcHVwIG1lbnUgaXMgdmlzaWJsZQpweWV2YWwoe2V4cHJ9KQkJCWFueQlldmFsdWF0ZSB8UHl0aG9ufCBleHByZXNzaW9uCnB5M2V2YWwoe2V4cHJ9KQkJCWFueQlldmFsdWF0ZSB8cHl0aG9uM3wgZXhwcmVzc2lvbgpyYW5nZSh7ZXhwcn0gWywge21heH0gWywge3N0cmlkZX1dXSkKCQkJCUxpc3QJaXRlbXMgZnJvbSB7ZXhwcn0gdG8ge21heH0KcmVhZGZpbGUoe2ZuYW1lfSBbLCB7YmluYXJ5fSBbLCB7bWF4fV1dKQoJCQkJTGlzdAlnZXQgbGlzdCBvZiBsaW5lcyBmcm9tIGZpbGUge2ZuYW1lfQpyZWx0aW1lKFt7c3RhcnR9IFssIHtlbmR9XV0pCUxpc3QJZ2V0IHRpbWUgdmFsdWUKcmVsdGltZWZsb2F0KHt0aW1lfSkJCUZsb2F0CXR1cm4gdGhlIHRpbWUgdmFsdWUgaW50byBhIEZsb2F0CnJlbHRpbWVzdHIoe3RpbWV9KQkJU3RyaW5nCXR1cm4gdGltZSB2YWx1ZSBpbnRvIGEgU3RyaW5nCnJlbW90ZV9leHByKHtzZXJ2ZXJ9LCB7c3RyaW5nfSBbLCB7aWR2YXJ9XSkKCQkJCVN0cmluZwlzZW5kIGV4cHJlc3Npb24KcmVtb3RlX2ZvcmVncm91bmQoe3NlcnZlcn0pCU51bWJlcglicmluZyBWaW0gc2VydmVyIHRvIHRoZSBmb3JlZ3JvdW5kCnJlbW90ZV9wZWVrKHtzZXJ2ZXJpZH0gWywge3JldHZhcn1dKQoJCQkJTnVtYmVyCWNoZWNrIGZvciByZXBseSBzdHJpbmcKcmVtb3RlX3JlYWQoe3NlcnZlcmlkfSkJCVN0cmluZwlyZWFkIHJlcGx5IHN0cmluZwpyZW1vdGVfc2VuZCh7c2VydmVyfSwge3N0cmluZ30gWywge2lkdmFyfV0pCgkJCQlTdHJpbmcJc2VuZCBrZXkgc2VxdWVuY2UKcmVtb3ZlKHtsaXN0fSwge2lkeH0gWywge2VuZH1dKSAgYW55CXJlbW92ZSBpdGVtcyB7aWR4fS17ZW5kfSBmcm9tIHtsaXN0fQpyZW1vdmUoe2RpY3R9LCB7a2V5fSkJCWFueQlyZW1vdmUgZW50cnkge2tleX0gZnJvbSB7ZGljdH0KcmVuYW1lKHtmcm9tfSwge3RvfSkJCU51bWJlcglyZW5hbWUgKG1vdmUpIGZpbGUgZnJvbSB7ZnJvbX0gdG8ge3RvfQpyZXBlYXQoe2V4cHJ9LCB7Y291bnR9KQkJU3RyaW5nCXJlcGVhdCB7ZXhwcn0ge2NvdW50fSB0aW1lcwpyZXNvbHZlKHtmaWxlbmFtZX0pCQlTdHJpbmcJZ2V0IGZpbGVuYW1lIGEgc2hvcnRjdXQgcG9pbnRzIHRvCnJldmVyc2Uoe2xpc3R9KQkJCUxpc3QJcmV2ZXJzZSB7bGlzdH0gaW4tcGxhY2UKcm91bmQoe2V4cHJ9KQkJCUZsb2F0CXJvdW5kIG9mZiB7ZXhwcn0Kc2NyZWVuYXR0cih7cm93fSwge2NvbH0pCU51bWJlcglhdHRyaWJ1dGUgYXQgc2NyZWVuIHBvc2l0aW9uCnNjcmVlbmNoYXIoe3Jvd30sIHtjb2x9KQlOdW1iZXIJY2hhcmFjdGVyIGF0IHNjcmVlbiBwb3NpdGlvbgpzY3JlZW5jb2woKQkJCU51bWJlcgljdXJyZW50IGN1cnNvciBjb2x1bW4Kc2NyZWVucm93KCkJCQlOdW1iZXIJY3VycmVudCBjdXJzb3Igcm93CnNlYXJjaCh7cGF0dGVybn0gWywge2ZsYWdzfSBbLCB7c3RvcGxpbmV9IFssIHt0aW1lb3V0fV1dXSkKCQkJCU51bWJlcglzZWFyY2ggZm9yIHtwYXR0ZXJufQpzZWFyY2hkZWNsKHtuYW1lfSBbLCB7Z2xvYmFsfSBbLCB7dGhpc2Jsb2NrfV1dKQoJCQkJTnVtYmVyCXNlYXJjaCBmb3IgdmFyaWFibGUgZGVjbGFyYXRpb24Kc2VhcmNocGFpcih7c3RhcnR9LCB7bWlkZGxlfSwge2VuZH0gWywge2ZsYWdzfSBbLCB7c2tpcH0gWy4uLl1dXSkKCQkJCU51bWJlcglzZWFyY2ggZm9yIG90aGVyIGVuZCBvZiBzdGFydC9lbmQgcGFpcgpzZWFyY2hwYWlycG9zKHtzdGFydH0sIHttaWRkbGV9LCB7ZW5kfSBbLCB7ZmxhZ3N9IFssIHtza2lwfSBbLi4uXV1dKQoJCQkJTGlzdAlzZWFyY2ggZm9yIG90aGVyIGVuZCBvZiBzdGFydC9lbmQgcGFpcgpzZWFyY2hwb3Moe3BhdHRlcm59IFssIHtmbGFnc30gWywge3N0b3BsaW5lfSBbLCB7dGltZW91dH1dXV0pCgkJCQlMaXN0CXNlYXJjaCBmb3Ige3BhdHRlcm59CnNlcnZlcjJjbGllbnQoe2NsaWVudGlkfSwge3N0cmluZ30pCgkJCQlOdW1iZXIJc2VuZCByZXBseSBzdHJpbmcKc2VydmVybGlzdCgpCQkJU3RyaW5nCWdldCBhIGxpc3Qgb2YgYXZhaWxhYmxlIHNlcnZlcnMKc2V0YnVmdmFyKHtleHByfSwge3Zhcm5hbWV9LCB7dmFsfSkKCQkJCW5vbmUJc2V0IHt2YXJuYW1lfSBpbiBidWZmZXIge2V4cHJ9IHRvIHt2YWx9CnNldGNoYXJzZWFyY2goe2RpY3R9KQkJRGljdAlzZXQgY2hhcmFjdGVyIHNlYXJjaCBmcm9tIHtkaWN0fQpzZXRjbWRwb3Moe3Bvc30pCQlOdW1iZXIJc2V0IGN1cnNvciBwb3NpdGlvbiBpbiBjb21tYW5kLWxpbmUKc2V0ZnBlcm0oe2ZuYW1lfSwge21vZGV9KQlOdW1iZXIJc2V0IHtmbmFtZX0gZmlsZSBwZXJtaXNzaW9ucyB0byB7bW9kZX0Kc2V0bGluZSh7bG51bX0sIHtsaW5lfSkJCU51bWJlcglzZXQgbGluZSB7bG51bX0gdG8ge2xpbmV9CnNldGxvY2xpc3Qoe25yfSwge2xpc3R9Wywge2FjdGlvbn1dKQoJCQkJTnVtYmVyCW1vZGlmeSBsb2NhdGlvbiBsaXN0IHVzaW5nIHtsaXN0fQpzZXRtYXRjaGVzKHtsaXN0fSkJCU51bWJlcglyZXN0b3JlIGEgbGlzdCBvZiBtYXRjaGVzCnNldHBvcyh7ZXhwcn0sIHtsaXN0fSkJCU51bWJlcglzZXQgdGhlIHtleHByfSBwb3NpdGlvbiB0byB7bGlzdH0Kc2V0cWZsaXN0KHtsaXN0fVssIHthY3Rpb259XSkJTnVtYmVyCW1vZGlmeSBxdWlja2ZpeCBsaXN0IHVzaW5nIHtsaXN0fQpzZXRyZWcoe259LCB7dn1bLCB7b3B0fV0pCU51bWJlcglzZXQgcmVnaXN0ZXIgdG8gdmFsdWUgYW5kIHR5cGUKc2V0dGFidmFyKHtucn0sIHt2YXJuYW1lfSwge3ZhbH0pIG5vbmUJc2V0IHt2YXJuYW1lfSBpbiB0YWIgcGFnZSB7bnJ9IHRvIHt2YWx9CnNldHRhYndpbnZhcih7dGFibnJ9LCB7d2lubnJ9LCB7dmFybmFtZX0sIHt2YWx9KQoJCQkJbm9uZQlzZXQge3Zhcm5hbWV9IGluIHdpbmRvdyB7d2lubnJ9IGluIHRhYgoJCQkJCXBhZ2Uge3RhYm5yfSB0byB7dmFsfQpzZXR3aW52YXIoe25yfSwge3Zhcm5hbWV9LCB7dmFsfSkgbm9uZQlzZXQge3Zhcm5hbWV9IGluIHdpbmRvdyB7bnJ9IHRvIHt2YWx9CnNoYTI1Nih7c3RyaW5nfSkJCVN0cmluZwlTSEEyNTYgY2hlY2tzdW0gb2Yge3N0cmluZ30Kc2hlbGxlc2NhcGUoe3N0cmluZ30gWywge3NwZWNpYWx9XSkKCQkJCVN0cmluZwllc2NhcGUge3N0cmluZ30gZm9yIHVzZSBhcyBzaGVsbAoJCQkJCWNvbW1hbmQgYXJndW1lbnQKc2hpZnR3aWR0aCgpCQkJTnVtYmVyCWVmZmVjdGl2ZSB2YWx1ZSBvZiAnc2hpZnR3aWR0aCcKc2ltcGxpZnkoe2ZpbGVuYW1lfSkJCVN0cmluZwlzaW1wbGlmeSBmaWxlbmFtZSBhcyBtdWNoIGFzIHBvc3NpYmxlCnNpbih7ZXhwcn0pCQkJRmxvYXQJc2luZSBvZiB7ZXhwcn0Kc2luaCh7ZXhwcn0pCQkJRmxvYXQJaHlwZXJib2xpYyBzaW5lIG9mIHtleHByfQpzb3J0KHtsaXN0fSBbLCB7ZnVuY30gWywge2RpY3R9XV0pCgkJCQlMaXN0CXNvcnQge2xpc3R9LCB1c2luZyB7ZnVuY30gdG8gY29tcGFyZQpzb3VuZGZvbGQoe3dvcmR9KQkJU3RyaW5nCXNvdW5kLWZvbGQge3dvcmR9CnNwZWxsYmFkd29yZCgpCQkJU3RyaW5nCWJhZGx5IHNwZWxsZWQgd29yZCBhdCBjdXJzb3IKc3BlbGxzdWdnZXN0KHt3b3JkfSBbLCB7bWF4fSBbLCB7Y2FwaXRhbH1dXSkKCQkJCUxpc3QJc3BlbGxpbmcgc3VnZ2VzdGlvbnMKc3BsaXQoe2V4cHJ9IFssIHtwYXR9IFssIHtrZWVwZW1wdHl9XV0pCgkJCQlMaXN0CW1ha2UgfExpc3R8IGZyb20ge3BhdH0gc2VwYXJhdGVkIHtleHByfQpzcXJ0KHtleHByfSkJCQlGbG9hdAlzcXVhcmUgcm9vdCBvZiB7ZXhwcn0Kc3RyMmZsb2F0KHtleHByfSkJCUZsb2F0CWNvbnZlcnQgU3RyaW5nIHRvIEZsb2F0CnN0cjJucih7ZXhwcn0gWywge2Jhc2V9XSkJTnVtYmVyCWNvbnZlcnQgU3RyaW5nIHRvIE51bWJlcgpzdHJjaGFycyh7ZXhwcn0gWywge3NraXBjY31dKQlOdW1iZXIJY2hhcmFjdGVyIGxlbmd0aCBvZiB0aGUgU3RyaW5nIHtleHByfQpzdHJjaGFycGFydCh7c3RyfSwge3N0YXJ0fVssIHtsZW59XSkKCQkJCVN0cmluZwl7bGVufSBjaGFyYWN0ZXJzIG9mIHtzdHJ9IGF0IHtzdGFydH0Kc3RyZGlzcGxheXdpZHRoKHtleHByfSBbLCB7Y29sfV0pIE51bWJlciBkaXNwbGF5IGxlbmd0aCBvZiB0aGUgU3RyaW5nIHtleHByfQpzdHJmdGltZSh7Zm9ybWF0fVssIHt0aW1lfV0pCVN0cmluZwl0aW1lIGluIHNwZWNpZmllZCBmb3JtYXQKc3RyZ2V0Y2hhcih7c3RyfSwge2luZGV4fSkJTnVtYmVyCWdldCBjaGFyIHtpbmRleH0gZnJvbSB7c3RyfQpzdHJpZHgoe2hheXN0YWNrfSwge25lZWRsZX1bLCB7c3RhcnR9XSkKCQkJCU51bWJlcglpbmRleCBvZiB7bmVlZGxlfSBpbiB7aGF5c3RhY2t9CnN0cmluZyh7ZXhwcn0pCQkJU3RyaW5nCVN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB7ZXhwcn0gdmFsdWUKc3RybGVuKHtleHByfSkJCQlOdW1iZXIJbGVuZ3RoIG9mIHRoZSBTdHJpbmcge2V4cHJ9CnN0cnBhcnQoe3N0cn0sIHtzdGFydH1bLCB7bGVufV0pCgkJCQlTdHJpbmcJe2xlbn0gY2hhcmFjdGVycyBvZiB7c3RyfSBhdCB7c3RhcnR9CnN0cnJpZHgoe2hheXN0YWNrfSwge25lZWRsZX0gWywge3N0YXJ0fV0pCgkJCQlOdW1iZXIJbGFzdCBpbmRleCBvZiB7bmVlZGxlfSBpbiB7aGF5c3RhY2t9CnN0cnRyYW5zKHtleHByfSkJCVN0cmluZwl0cmFuc2xhdGUgc3RyaW5nIHRvIG1ha2UgaXQgcHJpbnRhYmxlCnN0cndpZHRoKHtleHByfSkJCU51bWJlcglkaXNwbGF5IGNlbGwgbGVuZ3RoIG9mIHRoZSBTdHJpbmcge2V4cHJ9CnN1Ym1hdGNoKHtucn1bLCB7bGlzdH1dKQlTdHJpbmcgb3IgTGlzdAoJCQkJCXNwZWNpZmljIG1hdGNoIGluICI6cyIgb3Igc3Vic3RpdHV0ZSgpCnN1YnN0aXR1dGUoe2V4cHJ9LCB7cGF0fSwge3N1Yn0sIHtmbGFnc30pCgkJCQlTdHJpbmcJYWxsIHtwYXR9IGluIHtleHByfSByZXBsYWNlZCB3aXRoIHtzdWJ9CnN5bklEKHtsbnVtfSwge2NvbH0sIHt0cmFuc30pCU51bWJlcglzeW50YXggSUQgYXQge2xudW19IGFuZCB7Y29sfQpzeW5JRGF0dHIoe3N5bklEfSwge3doYXR9IFssIHttb2RlfV0pCgkJCQlTdHJpbmcJYXR0cmlidXRlIHt3aGF0fSBvZiBzeW50YXggSUQge3N5bklEfQpzeW5JRHRyYW5zKHtzeW5JRH0pCQlOdW1iZXIJdHJhbnNsYXRlZCBzeW50YXggSUQgb2Yge3N5bklEfQpzeW5jb25jZWFsZWQoe2xudW19LCB7Y29sfSkJTGlzdCAgICBpbmZvIGFib3V0IGNvbmNlYWxpbmcKc3luc3RhY2soe2xudW19LCB7Y29sfSkJCUxpc3QJc3RhY2sgb2Ygc3ludGF4IElEcyBhdCB7bG51bX0gYW5kIHtjb2x9CnN5c3RlbSh7ZXhwcn0gWywge2lucHV0fV0pCVN0cmluZwlvdXRwdXQgb2Ygc2hlbGwgY29tbWFuZC9maWx0ZXIge2V4cHJ9CnN5c3RlbWxpc3Qoe2V4cHJ9IFssIHtpbnB1dH1dKQlMaXN0CW91dHB1dCBvZiBzaGVsbCBjb21tYW5kL2ZpbHRlciB7ZXhwcn0KdGFicGFnZWJ1Zmxpc3QoW3thcmd9XSkJTGlzdAlsaXN0IG9mIGJ1ZmZlciBudW1iZXJzIGluIHRhYiBwYWdlCnRhYnBhZ2Vucihbe2FyZ31dKQkJTnVtYmVyCW51bWJlciBvZiBjdXJyZW50IG9yIGxhc3QgdGFiIHBhZ2UKdGFicGFnZXdpbm5yKHt0YWJhcmd9Wywge2FyZ31dKSBOdW1iZXIJbnVtYmVyIG9mIGN1cnJlbnQgd2luZG93IGluIHRhYiBwYWdlCnRhZ2xpc3Qoe2V4cHJ9KQkJCUxpc3QJbGlzdCBvZiB0YWdzIG1hdGNoaW5nIHtleHByfQp0YWdmaWxlcygpCQkJTGlzdAl0YWdzIGZpbGVzIHVzZWQKdGFuKHtleHByfSkJCQlGbG9hdAl0YW5nZW50IG9mIHtleHByfQp0YW5oKHtleHByfSkJCQlGbG9hdAloeXBlcmJvbGljIHRhbmdlbnQgb2Yge2V4cHJ9CnRlbXBuYW1lKCkJCQlTdHJpbmcJbmFtZSBmb3IgYSB0ZW1wb3JhcnkgZmlsZQp0aW1lcl9zdGFydCh7dGltZX0sIHtjYWxsYmFja30gWywge29wdGlvbnN9XSkKCQkJCU51bWJlcgljcmVhdGUgYSB0aW1lcgp0aW1lcl9zdG9wKHt0aW1lcn0pCQlub25lCXN0b3AgYSB0aW1lcgp0b2xvd2VyKHtleHByfSkJCQlTdHJpbmcJdGhlIFN0cmluZyB7ZXhwcn0gc3dpdGNoZWQgdG8gbG93ZXJjYXNlCnRvdXBwZXIoe2V4cHJ9KQkJCVN0cmluZwl0aGUgU3RyaW5nIHtleHByfSBzd2l0Y2hlZCB0byB1cHBlcmNhc2UKdHIoe3NyY30sIHtmcm9tc3RyfSwge3Rvc3RyfSkJU3RyaW5nCXRyYW5zbGF0ZSBjaGFycyBvZiB7c3JjfSBpbiB7ZnJvbXN0cn0KCQkJCQl0byBjaGFycyBpbiB7dG9zdHJ9CnRydW5jKHtleHByfSkJCQlGbG9hdAl0cnVuY2F0ZSBGbG9hdCB7ZXhwcn0KdHlwZSh7bmFtZX0pCQkJTnVtYmVyCXR5cGUgb2YgdmFyaWFibGUge25hbWV9CnVuZG9maWxlKHtuYW1lfSkJCVN0cmluZwl1bmRvIGZpbGUgbmFtZSBmb3Ige25hbWV9CnVuZG90cmVlKCkJCQlMaXN0CXVuZG8gZmlsZSB0cmVlCnVuaXEoe2xpc3R9IFssIHtmdW5jfSBbLCB7ZGljdH1dXSkKCQkJCUxpc3QJcmVtb3ZlIGFkamFjZW50IGR1cGxpY2F0ZXMgZnJvbSBhIGxpc3QKdmFsdWVzKHtkaWN0fSkJCQlMaXN0CXZhbHVlcyBpbiB7ZGljdH0KdmlydGNvbCh7ZXhwcn0pCQkJTnVtYmVyCXNjcmVlbiBjb2x1bW4gb2YgY3Vyc29yIG9yIG1hcmsKdmlzdWFsbW9kZShbZXhwcl0pCQlTdHJpbmcJbGFzdCB2aXN1YWwgbW9kZSB1c2VkCndpbGRtZW51bW9kZSgpCQkJTnVtYmVyCXdoZXRoZXIgJ3dpbGRtZW51JyBtb2RlIGlzIGFjdGl2ZQp3aW5fZmluZGJ1Zih7YnVmbnJ9KQkJTGlzdAlmaW5kIHdpbmRvd3MgY29udGFpbmluZyB7YnVmbnJ9Cndpbl9nZXRpZChbe3dpbn0gWywge3RhYn1dXSkJTnVtYmVyCWdldCB3aW5kb3cgSUQgZm9yIHt3aW59IGluIHt0YWJ9Cndpbl9nb3RvaWQoe2V4cHJ9KQkJTnVtYmVyCWdvIHRvIHdpbmRvdyB3aXRoIElEIHtleHByfQp3aW5faWQydGFid2luKHtleHByfSkJCUxpc3QJZ2V0IHRhYiBhbmQgd2luZG93IG5yIGZyb20gd2luZG93IElECndpbl9pZDJ3aW4oe2V4cHJ9KQkJTnVtYmVyCWdldCB3aW5kb3cgbnIgZnJvbSB3aW5kb3cgSUQKd2luYnVmbnIoe25yfSkJCQlOdW1iZXIJYnVmZmVyIG51bWJlciBvZiB3aW5kb3cge25yfQp3aW5jb2woKQkJCU51bWJlcgl3aW5kb3cgY29sdW1uIG9mIHRoZSBjdXJzb3IKd2luaGVpZ2h0KHtucn0pCQkJTnVtYmVyCWhlaWdodCBvZiB3aW5kb3cge25yfQp3aW5saW5lKCkJCQlOdW1iZXIJd2luZG93IGxpbmUgb2YgdGhlIGN1cnNvcgp3aW5ucihbe2V4cHJ9XSkJCQlOdW1iZXIJbnVtYmVyIG9mIGN1cnJlbnQgd2luZG93CndpbnJlc3RjbWQoKQkJCVN0cmluZwlyZXR1cm5zIGNvbW1hbmQgdG8gcmVzdG9yZSB3aW5kb3cgc2l6ZXMKd2lucmVzdHZpZXcoe2RpY3R9KQkJbm9uZQlyZXN0b3JlIHZpZXcgb2YgY3VycmVudCB3aW5kb3cKd2luc2F2ZXZpZXcoKQkJCURpY3QJc2F2ZSB2aWV3IG9mIGN1cnJlbnQgd2luZG93CndpbndpZHRoKHtucn0pCQkJTnVtYmVyCXdpZHRoIG9mIHdpbmRvdyB7bnJ9CndvcmRjb3VudCgpCQkJRGljdAlnZXQgYnl0ZS9jaGFyL3dvcmQgc3RhdGlzdGljcwp3cml0ZWZpbGUoe2xpc3R9LCB7Zm5hbWV9IFssIHtmbGFnc31dKQoJCQkJTnVtYmVyCXdyaXRlIGxpc3Qgb2YgbGluZXMgdG8gZmlsZSB7Zm5hbWV9Cnhvcih7ZXhwcn0sIHtleHByfSkJCU51bWJlciAgYml0d2lzZSBYT1IKCgphYnMoe2V4cHJ9KQkJCQkJCQkqYWJzKCkqCgkJUmV0dXJuIHRoZSBhYnNvbHV0ZSB2YWx1ZSBvZiB7ZXhwcn0uICBXaGVuIHtleHByfSBldmFsdWF0ZXMgdG8KCQlhIHxGbG9hdHwgYWJzKCkgcmV0dXJucyBhIHxGbG9hdHwuICBXaGVuIHtleHByfSBjYW4gYmUKCQljb252ZXJ0ZWQgdG8gYSB8TnVtYmVyfCBhYnMoKSByZXR1cm5zIGEgfE51bWJlcnwuICBPdGhlcndpc2UKCQlhYnMoKSBnaXZlcyBhbiBlcnJvciBtZXNzYWdlIGFuZCByZXR1cm5zIC0xLgoJCUV4YW1wbGVzOiA+CgkJCWVjaG8gYWJzKDEuNDU2KQo8CQkJMS40NTYgID4KCQkJZWNobyBhYnMoLTUuNDU2KQo8CQkJNS40NTYgID4KCQkJZWNobyBhYnMoLTQpCjwJCQk0CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgphY29zKHtleHByfSkJCQkJCQkJKmFjb3MoKSoKCQlSZXR1cm4gdGhlIGFyYyBjb3NpbmUgb2Yge2V4cHJ9IG1lYXN1cmVkIGluIHJhZGlhbnMsIGFzIGEKCQl8RmxvYXR8IGluIHRoZSByYW5nZSBvZiBbMCwgcGldLgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8IGluIHRoZSByYW5nZQoJCVstMSwgMV0uCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gYWNvcygwKQo8CQkJMS41NzA3OTYgPgoJCQk6ZWNobyBhY29zKC0wLjUpCjwJCQkyLjA5NDM5NQoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKYWRkKHtsaXN0fSwge2V4cHJ9KQkJCQkJKmFkZCgpKgoJCUFwcGVuZCB0aGUgaXRlbSB7ZXhwcn0gdG8gfExpc3R8IHtsaXN0fS4gIFJldHVybnMgdGhlCgkJcmVzdWx0aW5nIHxMaXN0fC4gIEV4YW1wbGVzOiA+CgkJCTpsZXQgYWxpc3QgPSBhZGQoWzEsIDIsIDNdLCBpdGVtKQoJCQk6Y2FsbCBhZGQobXlsaXN0LCAid29vZHN0b2NrIikKPAkJTm90ZSB0aGF0IHdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IGl0IGlzIGFwcGVuZGVkIGFzIGEgc2luZ2xlCgkJaXRlbS4gIFVzZSB8ZXh0ZW5kKCl8IHRvIGNvbmNhdGVuYXRlIHxMaXN0c3wuCgkJVXNlIHxpbnNlcnQoKXwgdG8gYWRkIGFuIGl0ZW0gYXQgYW5vdGhlciBwb3NpdGlvbi4KCgphbGxvY19mYWlsKHtpZH0sIHtjb3VudGRvd259LCB7cmVwZWF0fSkJCQkqYWxsb2NfZmFpbCgpKgoJCVRoaXMgaXMgZm9yIHRlc3Rpbmc6IElmIHRoZSBtZW1vcnkgYWxsb2NhdGlvbiB3aXRoIHtpZH0gaXMKCQljYWxsZWQsIHRoZW4gZGVjcmVtZW50IHtjb3VudGRvd259LCBhbmQgd2hlbiBpdCByZWFjaGVzIHplcm8KCQlsZXQgbWVtb3J5IGFsbG9jYXRpb24gZmFpbCB7cmVwZWF0fSB0aW1lcy4gIFdoZW4ge3JlcGVhdH0gaXMKCQlzbWFsbGVyIHRoYW4gb25lIGl0IGZhaWxzIG9uZSB0aW1lLgoKCmFuZCh7ZXhwcn0sIHtleHByfSkJCQkJCSphbmQoKSoKCQlCaXR3aXNlIEFORCBvbiB0aGUgdHdvIGFyZ3VtZW50cy4gIFRoZSBhcmd1bWVudHMgYXJlIGNvbnZlcnRlZAoJCXRvIGEgbnVtYmVyLiAgQSBMaXN0LCBEaWN0IG9yIEZsb2F0IGFyZ3VtZW50IGNhdXNlcyBhbiBlcnJvci4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgZmxhZyA9IGFuZChiaXRzLCAweDgwKQoKCmFwcGVuZCh7bG51bX0sIHtleHByfSkJCQkJCSphcHBlbmQoKSoKCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fDogQXBwZW5kIGVhY2ggaXRlbSBvZiB0aGUgfExpc3R8IGFzIGEKCQl0ZXh0IGxpbmUgYmVsb3cgbGluZSB7bG51bX0gaW4gdGhlIGN1cnJlbnQgYnVmZmVyLgoJCU90aGVyd2lzZSBhcHBlbmQge2V4cHJ9IGFzIG9uZSB0ZXh0IGxpbmUgYmVsb3cgbGluZSB7bG51bX0gaW4KCQl0aGUgY3VycmVudCBidWZmZXIuCgkJe2xudW19IGNhbiBiZSB6ZXJvIHRvIGluc2VydCBhIGxpbmUgYmVmb3JlIHRoZSBmaXJzdCBvbmUuCgkJUmV0dXJucyAxIGZvciBmYWlsdXJlICh7bG51bX0gb3V0IG9mIHJhbmdlIG9yIG91dCBvZiBtZW1vcnkpLAoJCTAgZm9yIHN1Y2Nlc3MuCUV4YW1wbGU6ID4KCQkJOmxldCBmYWlsZWQgPSBhcHBlbmQobGluZSgnJCcpLCAiIyBUSEUgRU5EIikKCQkJOmxldCBmYWlsZWQgPSBhcHBlbmQoMCwgWyJDaGFwdGVyIDEiLCAidGhlIGJlZ2lubmluZyJdKQo8CgkJCQkJCQkqYXJnYygpKgphcmdjKCkJCVRoZSByZXN1bHQgaXMgdGhlIG51bWJlciBvZiBmaWxlcyBpbiB0aGUgYXJndW1lbnQgbGlzdCBvZiB0aGUKCQljdXJyZW50IHdpbmRvdy4gIFNlZSB8YXJnbGlzdHwuCgoJCQkJCQkJKmFyZ2lkeCgpKgphcmdpZHgoKQlUaGUgcmVzdWx0IGlzIHRoZSBjdXJyZW50IGluZGV4IGluIHRoZSBhcmd1bWVudCBsaXN0LiAgMCBpcwoJCXRoZSBmaXJzdCBmaWxlLiAgYXJnYygpIC0gMSBpcyB0aGUgbGFzdCBvbmUuICBTZWUgfGFyZ2xpc3R8LgoKCQkJCQkJCSphcmdsaXN0aWQoKSoKYXJnbGlzdGlkKFt7d2lubnJ9IFssIHt0YWJucn1dXSkKCQlSZXR1cm4gdGhlIGFyZ3VtZW50IGxpc3QgSUQuICBUaGlzIGlzIGEgbnVtYmVyIHdoaWNoCgkJaWRlbnRpZmllcyB0aGUgYXJndW1lbnQgbGlzdCBiZWluZyB1c2VkLiAgWmVybyBpcyB1c2VkIGZvciB0aGUKCQlnbG9iYWwgYXJndW1lbnQgbGlzdC4gIFNlZSB8YXJnbGlzdHwuCgkJUmV0dXJuIC0xIGlmIHRoZSBhcmd1bWVudHMgYXJlIGludmFsaWQuCgoJCVdpdGhvdXQgYXJndW1lbnRzIHVzZSB0aGUgY3VycmVudCB3aW5kb3cuCgkJV2l0aCB7d2lubnJ9IG9ubHkgdXNlIHRoaXMgd2luZG93IGluIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoJCVdpdGgge3dpbm5yfSBhbmQge3RhYm5yfSB1c2UgdGhlIHdpbmRvdyBpbiB0aGUgc3BlY2lmaWVkIHRhYgoJCXBhZ2UuCgoJCQkJCQkJKmFyZ3YoKSoKYXJndihbe25yfV0pCVRoZSByZXN1bHQgaXMgdGhlIHtucn10aCBmaWxlIGluIHRoZSBhcmd1bWVudCBsaXN0IG9mIHRoZQoJCWN1cnJlbnQgd2luZG93LiAgU2VlIHxhcmdsaXN0fC4gICJhcmd2KDApIiBpcyB0aGUgZmlyc3Qgb25lLgoJCUV4YW1wbGU6ID4KCTpsZXQgaSA9IDAKCTp3aGlsZSBpIDwgYXJnYygpCgk6ICBsZXQgZiA9IGVzY2FwZShmbmFtZWVzY2FwZShhcmd2KGkpKSwgJy4nKQoJOiAgZXhlICdhbWVudSBBcmcuJyAuIGYgLiAnIDplICcgLiBmIC4gJzxDUj4nCgk6ICBsZXQgaSA9IGkgKyAxCgk6ZW5kd2hpbGUKPAkJV2l0aG91dCB0aGUge25yfSBhcmd1bWVudCBhIHxMaXN0fCB3aXRoIHRoZSB3aG9sZSB8YXJnbGlzdHwgaXMKCQlyZXR1cm5lZC4KCgkJCQkJCQkqYXNzZXJ0X2VxdWFsKCkqCmFzc2VydF9lcXVhbCh7ZXhwZWN0ZWR9LCB7YWN0dWFsfSBbLCB7bXNnfV0pCgkJV2hlbiB7ZXhwZWN0ZWR9IGFuZCB7YWN0dWFsfSBhcmUgbm90IGVxdWFsIGFuIGVycm9yIG1lc3NhZ2UgaXMKCQlhZGRlZCB0byB8djplcnJvcnN8LgoJCVRoZXJlIGlzIG5vIGF1dG9tYXRpYyBjb252ZXJzaW9uLCB0aGUgU3RyaW5nICI0IiBpcyBkaWZmZXJlbnQKCQlmcm9tIHRoZSBOdW1iZXIgNC4gIEFuZCB0aGUgbnVtYmVyIDQgaXMgZGlmZmVyZW50IGZyb20gdGhlCgkJRmxvYXQgNC4wLiAgVGhlIHZhbHVlIG9mICdpZ25vcmVjYXNlJyBpcyBub3QgdXNlZCBoZXJlLCBjYXNlCgkJYWx3YXlzIG1hdHRlcnMuCgkJV2hlbiB7bXNnfSBpcyBvbWl0dGVkIGFuIGVycm9yIGluIHRoZSBmb3JtICJFeHBlY3RlZAoJCXtleHBlY3RlZH0gYnV0IGdvdCB7YWN0dWFsfSIgaXMgcHJvZHVjZWQuCgkJRXhhbXBsZTogPgoJYXNzZXJ0X2VxdWFsKCdmb28nLCAnYmFyJykKPAkJV2lsbCByZXN1bHQgaW4gYSBzdHJpbmcgdG8gYmUgYWRkZWQgdG8gfHY6ZXJyb3JzfDoKCXRlc3QudmltIGxpbmUgMTI6IEV4cGVjdGVkICdmb28nIGJ1dCBnb3QgJ2JhcicgfgoKYXNzZXJ0X2V4Y2VwdGlvbih7ZXJyb3J9IFssIHttc2d9XSkJCQkqYXNzZXJ0X2V4Y2VwdGlvbigpKgoJCVdoZW4gdjpleGNlcHRpb24gZG9lcyBub3QgY29udGFpbiB0aGUgc3RyaW5nIHtlcnJvcn0gYW4gZXJyb3IKCQltZXNzYWdlIGlzIGFkZGVkIHRvIHx2OmVycm9yc3wuCgkJVGhpcyBjYW4gYmUgdXNlZCB0byBhc3NlcnQgdGhhdCBhIGNvbW1hbmQgdGhyb3dzIGFuIGV4Y2VwdGlvbi4KCQlVc2luZyB0aGUgZXJyb3IgbnVtYmVyLCBmb2xsb3dlZCBieSBhIGNvbG9uLCBhdm9pZHMgcHJvYmxlbXMKCQl3aXRoIHRyYW5zbGF0aW9uczogPgoJCQl0cnkKCQkJICBjb21tYW5kdGhhdGZhaWxzCgkJCSAgY2FsbCBhc3NlcnRfZmFsc2UoMSwgJ2NvbW1hbmQgc2hvdWxkIGhhdmUgZmFpbGVkJykKCQkJY2F0Y2gKCQkJICBjYWxsIGFzc2VydF9leGNlcHRpb24oJ0U0OTI6JykKCQkJZW5kdHJ5Cgphc3NlcnRfZmFpbHMoe2NtZH0gWywge2Vycm9yfV0pCQkJCQkqYXNzZXJ0X2ZhaWxzKCkqCgkJUnVuIHtjbWR9IGFuZCBhZGQgYW4gZXJyb3IgbWVzc2FnZSB0byB8djplcnJvcnN8IGlmIGl0IGRvZXMKCQlOT1QgcHJvZHVjZSBhbiBlcnJvci4KCQlXaGVuIHtlcnJvcn0gaXMgZ2l2ZW4gaXQgbXVzdCBtYXRjaCB8djplcnJtc2d8LgoKYXNzZXJ0X2ZhbHNlKHthY3R1YWx9IFssIHttc2d9XSkJCQkJKmFzc2VydF9mYWxzZSgpKgoJCVdoZW4ge2FjdHVhbH0gaXMgbm90IGZhbHNlIGFuIGVycm9yIG1lc3NhZ2UgaXMgYWRkZWQgdG8KCQl8djplcnJvcnN8LCBsaWtlIHdpdGggfGFzc2VydF9lcXVhbCgpfC4KCQlBIHZhbHVlIGlzIGZhbHNlIHdoZW4gaXQgaXMgemVyby4gV2hlbiB7YWN0dWFsfSBpcyBub3QgYQoJCW51bWJlciB0aGUgYXNzZXJ0IGZhaWxzLgoJCVdoZW4ge21zZ30gaXMgb21pdHRlZCBhbiBlcnJvciBpbiB0aGUgZm9ybSAiRXhwZWN0ZWQgRmFsc2UgYnV0CgkJZ290IHthY3R1YWx9IiBpcyBwcm9kdWNlZC4KCgkJCQkJCQkJKmFzc2VydF9tYXRjaCgpKgphc3NlcnRfbWF0Y2goe3BhdHRlcm59LCB7YWN0dWFsfSBbLCB7bXNnfV0pCgkJV2hlbiB7cGF0dGVybn0gZG9lcyBub3QgbWF0Y2gge2FjdHVhbH0gYW4gZXJyb3IgbWVzc2FnZSBpcwoJCWFkZGVkIHRvIHx2OmVycm9yc3wuCgoJCXtwYXR0ZXJufSBpcyB1c2VkIGFzIHdpdGggfD1+fDogVGhlIG1hdGNoaW5nIGlzIGFsd2F5cyBkb25lCgkJbGlrZSAnbWFnaWMnIHdhcyBzZXQgYW5kICdjcG9wdGlvbnMnIGlzIGVtcHR5LCBubyBtYXR0ZXIgd2hhdAoJCXRoZSBhY3R1YWwgdmFsdWUgb2YgJ21hZ2ljJyBvciAnY3BvcHRpb25zJyBpcy4KCgkJe2FjdHVhbH0gaXMgdXNlZCBhcyBhIHN0cmluZywgYXV0b21hdGljIGNvbnZlcnNpb24gYXBwbGllcy4KCQlVc2UgIl4iIGFuZCAiJCIgdG8gbWF0Y2ggd2l0aCB0aGUgc3RhcnQgYW5kIGVuZCBvZiB0aGUgdGV4dC4KCQlVc2UgYm90aCB0byBtYXRjaCB0aGUgd2hvbGUgdGV4dC4KCgkJV2hlbiB7bXNnfSBpcyBvbWl0dGVkIGFuIGVycm9yIGluIHRoZSBmb3JtICJQYXR0ZXJuIHtwYXR0ZXJufQoJCWRvZXMgbm90IG1hdGNoIHthY3R1YWx9IiBpcyBwcm9kdWNlZC4KCQlFeGFtcGxlOiA+Cglhc3NlcnRfbWF0Y2goJ15mLipvJCcsICdmb29iYXInKQo8CQlXaWxsIHJlc3VsdCBpbiBhIHN0cmluZyB0byBiZSBhZGRlZCB0byB8djplcnJvcnN8OgoJdGVzdC52aW0gbGluZSAxMjogUGF0dGVybiAnXmYuKm8kJyBkb2VzIG5vdCBtYXRjaCAnZm9vYmFyJyB+CgoJCQkJCQkJKmFzc2VydF9ub3RlcXVhbCgpKgphc3NlcnRfbm90ZXF1YWwoe2V4cGVjdGVkfSwge2FjdHVhbH0gWywge21zZ31dKQoJCVRoZSBvcHBvc2l0ZSBvZiBgYXNzZXJ0X2VxdWFsKClgOiBhZGQgYW4gZXJyb3IgbWVzc2FnZSB0bwoJCXx2OmVycm9yc3wgd2hlbiB7ZXhwZWN0ZWR9IGFuZCB7YWN0dWFsfSBhcmUgZXF1YWwuCgoJCQkJCQkJKmFzc2VydF9ub3RtYXRjaCgpKgphc3NlcnRfbm90bWF0Y2goe3BhdHRlcm59LCB7YWN0dWFsfSBbLCB7bXNnfV0pCgkJVGhlIG9wcG9zaXRlIG9mIGBhc3NlcnRfbWF0Y2goKWA6IGFkZCBhbiBlcnJvciBtZXNzYWdlIHRvCgkJfHY6ZXJyb3JzfCB3aGVuIHtwYXR0ZXJufSBtYXRjaGVzIHthY3R1YWx9LgoKYXNzZXJ0X3RydWUoe2FjdHVhbH0gWywge21zZ31dKQkJCQkJKmFzc2VydF90cnVlKCkqCgkJV2hlbiB7YWN0dWFsfSBpcyBub3QgdHJ1ZSBhbiBlcnJvciBtZXNzYWdlIGlzIGFkZGVkIHRvCgkJfHY6ZXJyb3JzfCwgbGlrZSB3aXRoIHxhc3NlcnRfZXF1YWwoKXwuCgkJQSB2YWx1ZSBpcyB0cnVlIHdoZW4gaXQgaXMgYSBub24temVybyBudW1iZXIuICBXaGVuIHthY3R1YWx9CgkJaXMgbm90IGEgbnVtYmVyIHRoZSBhc3NlcnQgZmFpbHMuCgkJV2hlbiB7bXNnfSBpcyBvbWl0dGVkIGFuIGVycm9yIGluIHRoZSBmb3JtICJFeHBlY3RlZCBUcnVlIGJ1dAoJCWdvdCB7YWN0dWFsfSIgaXMgcHJvZHVjZWQuCgphc2luKHtleHByfSkJCQkJCQkqYXNpbigpKgoJCVJldHVybiB0aGUgYXJjIHNpbmUgb2Yge2V4cHJ9IG1lYXN1cmVkIGluIHJhZGlhbnMsIGFzIGEgfEZsb2F0fAoJCWluIHRoZSByYW5nZSBvZiBbLXBpLzIsIHBpLzJdLgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8IGluIHRoZSByYW5nZQoJCVstMSwgMV0uCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gYXNpbigwLjgpCjwJCQkwLjkyNzI5NSA+CgkJCTplY2hvIGFzaW4oLTAuNSkKPAkJCS0wLjUyMzU5OQoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKYXRhbih7ZXhwcn0pCQkJCQkJKmF0YW4oKSoKCQlSZXR1cm4gdGhlIHByaW5jaXBhbCB2YWx1ZSBvZiB0aGUgYXJjIHRhbmdlbnQgb2Yge2V4cHJ9LCBpbgoJCXRoZSByYW5nZSBbLXBpLzIsICtwaS8yXSByYWRpYW5zLCBhcyBhIHxGbG9hdHwuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gYXRhbigxMDApCjwJCQkxLjU2MDc5NyA+CgkJCTplY2hvIGF0YW4oLTQuMDEpCjwJCQktMS4zMjY0MDUKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmF0YW4yKHtleHByMX0sIHtleHByMn0pCQkJCQkqYXRhbjIoKSoKCQlSZXR1cm4gdGhlIGFyYyB0YW5nZW50IG9mIHtleHByMX0gLyB7ZXhwcjJ9LCBtZWFzdXJlZCBpbgoJCXJhZGlhbnMsIGFzIGEgfEZsb2F0fCBpbiB0aGUgcmFuZ2UgWy1waSwgcGldLgoJCXtleHByMX0gYW5kIHtleHByMn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBhdGFuMigtMSwgMSkKPAkJCS0wLjc4NTM5OCA+CgkJCTplY2hvIGF0YW4yKDEsIC0xKQo8CQkJMi4zNTYxOTQKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCgkJCQkJCQkqYnJvd3NlKCkqCmJyb3dzZSh7c2F2ZX0sIHt0aXRsZX0sIHtpbml0ZGlyfSwge2RlZmF1bHR9KQoJCVB1dCB1cCBhIGZpbGUgcmVxdWVzdGVyLiAgVGhpcyBvbmx5IHdvcmtzIHdoZW4gImhhcygiYnJvd3NlIikiCgkJcmV0dXJucyBub24temVybyAob25seSBpbiBzb21lIEdVSSB2ZXJzaW9ucykuCgkJVGhlIGlucHV0IGZpZWxkcyBhcmU6CgkJICAgIHtzYXZlfQl3aGVuIG5vbi16ZXJvLCBzZWxlY3QgZmlsZSB0byB3cml0ZQoJCSAgICB7dGl0bGV9CXRpdGxlIGZvciB0aGUgcmVxdWVzdGVyCgkJICAgIHtpbml0ZGlyfQlkaXJlY3RvcnkgdG8gc3RhcnQgYnJvd3NpbmcgaW4KCQkgICAge2RlZmF1bHR9CWRlZmF1bHQgZmlsZSBuYW1lCgkJV2hlbiB0aGUgIkNhbmNlbCIgYnV0dG9uIGlzIGhpdCwgc29tZXRoaW5nIHdlbnQgd3JvbmcsIG9yCgkJYnJvd3NpbmcgaXMgbm90IHBvc3NpYmxlLCBhbiBlbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuCgoJCQkJCQkJKmJyb3dzZWRpcigpKgpicm93c2VkaXIoe3RpdGxlfSwge2luaXRkaXJ9KQoJCVB1dCB1cCBhIGRpcmVjdG9yeSByZXF1ZXN0ZXIuICBUaGlzIG9ubHkgd29ya3Mgd2hlbgoJCSJoYXMoImJyb3dzZSIpIiByZXR1cm5zIG5vbi16ZXJvIChvbmx5IGluIHNvbWUgR1VJIHZlcnNpb25zKS4KCQlPbiBzeXN0ZW1zIHdoZXJlIGEgZGlyZWN0b3J5IGJyb3dzZXIgaXMgbm90IHN1cHBvcnRlZCBhIGZpbGUKCQlicm93c2VyIGlzIHVzZWQuICBJbiB0aGF0IGNhc2U6IHNlbGVjdCBhIGZpbGUgaW4gdGhlIGRpcmVjdG9yeQoJCXRvIGJlIHVzZWQuCgkJVGhlIGlucHV0IGZpZWxkcyBhcmU6CgkJICAgIHt0aXRsZX0JdGl0bGUgZm9yIHRoZSByZXF1ZXN0ZXIKCQkgICAge2luaXRkaXJ9CWRpcmVjdG9yeSB0byBzdGFydCBicm93c2luZyBpbgoJCVdoZW4gdGhlICJDYW5jZWwiIGJ1dHRvbiBpcyBoaXQsIHNvbWV0aGluZyB3ZW50IHdyb25nLCBvcgoJCWJyb3dzaW5nIGlzIG5vdCBwb3NzaWJsZSwgYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoKYnVmZXhpc3RzKHtleHByfSkJCQkJCSpidWZleGlzdHMoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBub24temVybyBpZiBhIGJ1ZmZlciBjYWxsZWQKCQl7ZXhwcn0gZXhpc3RzLgoJCUlmIHRoZSB7ZXhwcn0gYXJndW1lbnQgaXMgYSBudW1iZXIsIGJ1ZmZlciBudW1iZXJzIGFyZSB1c2VkLgoJCUlmIHRoZSB7ZXhwcn0gYXJndW1lbnQgaXMgYSBzdHJpbmcgaXQgbXVzdCBtYXRjaCBhIGJ1ZmZlciBuYW1lCgkJZXhhY3RseS4gIFRoZSBuYW1lIGNhbiBiZToKCQktIFJlbGF0aXZlIHRvIHRoZSBjdXJyZW50IGRpcmVjdG9yeS4KCQktIEEgZnVsbCBwYXRoLgoJCS0gVGhlIG5hbWUgb2YgYSBidWZmZXIgd2l0aCAnYnVmdHlwZScgc2V0IHRvICJub2ZpbGUiLgoJCS0gQSBVUkwgbmFtZS4KCQlVbmxpc3RlZCBidWZmZXJzIHdpbGwgYmUgZm91bmQuCgkJTm90ZSB0aGF0IGhlbHAgZmlsZXMgYXJlIGxpc3RlZCBieSB0aGVpciBzaG9ydCBuYW1lIGluIHRoZQoJCW91dHB1dCBvZiB8OmJ1ZmZlcnN8LCBidXQgYnVmZXhpc3RzKCkgcmVxdWlyZXMgdXNpbmcgdGhlaXIKCQlsb25nIG5hbWUgdG8gYmUgYWJsZSB0byBmaW5kIHRoZW0uCgkJYnVmZXhpc3RzKCkgbWF5IHJlcG9ydCBhIGJ1ZmZlciBleGlzdHMsIGJ1dCB0byB1c2UgdGhlIG5hbWUKCQl3aXRoIGEgfDpidWZmZXJ8IGNvbW1hbmQgeW91IG1heSBuZWVkIHRvIHVzZSB8ZXhwYW5kKCl8LiAgRXNwCgkJZm9yIE1TLVdpbmRvd3MgOC4zIG5hbWVzIGluIHRoZSBmb3JtICJjOlxET0NVTUV+MSIKCQlVc2UgImJ1ZmV4aXN0cygwKSIgdG8gdGVzdCBmb3IgdGhlIGV4aXN0ZW5jZSBvZiBhbiBhbHRlcm5hdGUKCQlmaWxlIG5hbWUuCgkJCQkJCQkqYnVmZmVyX2V4aXN0cygpKgoJCU9ic29sZXRlIG5hbWU6IGJ1ZmZlcl9leGlzdHMoKS4KCmJ1Zmxpc3RlZCh7ZXhwcn0pCQkJCQkqYnVmbGlzdGVkKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gaWYgYSBidWZmZXIgY2FsbGVkCgkJe2V4cHJ9IGV4aXN0cyBhbmQgaXMgbGlzdGVkIChoYXMgdGhlICdidWZsaXN0ZWQnIG9wdGlvbiBzZXQpLgoJCVRoZSB7ZXhwcn0gYXJndW1lbnQgaXMgdXNlZCBsaWtlIHdpdGggfGJ1ZmV4aXN0cygpfC4KCmJ1ZmxvYWRlZCh7ZXhwcn0pCQkJCQkqYnVmbG9hZGVkKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gaWYgYSBidWZmZXIgY2FsbGVkCgkJe2V4cHJ9IGV4aXN0cyBhbmQgaXMgbG9hZGVkIChzaG93biBpbiBhIHdpbmRvdyBvciBoaWRkZW4pLgoJCVRoZSB7ZXhwcn0gYXJndW1lbnQgaXMgdXNlZCBsaWtlIHdpdGggfGJ1ZmV4aXN0cygpfC4KCmJ1Zm5hbWUoe2V4cHJ9KQkJCQkJCSpidWZuYW1lKCkqCgkJVGhlIHJlc3VsdCBpcyB0aGUgbmFtZSBvZiBhIGJ1ZmZlciwgYXMgaXQgaXMgZGlzcGxheWVkIGJ5IHRoZQoJCSI6bHMiIGNvbW1hbmQuCgkJSWYge2V4cHJ9IGlzIGEgTnVtYmVyLCB0aGF0IGJ1ZmZlciBudW1iZXIncyBuYW1lIGlzIGdpdmVuLgoJCU51bWJlciB6ZXJvIGlzIHRoZSBhbHRlcm5hdGUgYnVmZmVyIGZvciB0aGUgY3VycmVudCB3aW5kb3cuCgkJSWYge2V4cHJ9IGlzIGEgU3RyaW5nLCBpdCBpcyB1c2VkIGFzIGEgfGZpbGUtcGF0dGVybnwgdG8gbWF0Y2gKCQl3aXRoIHRoZSBidWZmZXIgbmFtZXMuCVRoaXMgaXMgYWx3YXlzIGRvbmUgbGlrZSAnbWFnaWMnIGlzCgkJc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eS4gIFdoZW4gdGhlcmUgaXMgbW9yZSB0aGFuIG9uZQoJCW1hdGNoIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCQkiIiBvciAiJSIgY2FuIGJlIHVzZWQgZm9yIHRoZSBjdXJyZW50IGJ1ZmZlciwgIiMiIGZvciB0aGUKCQlhbHRlcm5hdGUgYnVmZmVyLgoJCUEgZnVsbCBtYXRjaCBpcyBwcmVmZXJyZWQsIG90aGVyd2lzZSBhIG1hdGNoIGF0IHRoZSBzdGFydCwgZW5kCgkJb3IgbWlkZGxlIG9mIHRoZSBidWZmZXIgbmFtZSBpcyBhY2NlcHRlZC4gIElmIHlvdSBvbmx5IHdhbnQgYQoJCWZ1bGwgbWF0Y2ggdGhlbiBwdXQgIl4iIGF0IHRoZSBzdGFydCBhbmQgIiQiIGF0IHRoZSBlbmQgb2YgdGhlCgkJcGF0dGVybi4KCQlMaXN0ZWQgYnVmZmVycyBhcmUgZm91bmQgZmlyc3QuICBJZiB0aGVyZSBpcyBhIHNpbmdsZSBtYXRjaAoJCXdpdGggYSBsaXN0ZWQgYnVmZmVyLCB0aGF0IG9uZSBpcyByZXR1cm5lZC4gIE5leHQgdW5saXN0ZWQKCQlidWZmZXJzIGFyZSBzZWFyY2hlZCBmb3IuCgkJSWYgdGhlIHtleHByfSBpcyBhIFN0cmluZywgYnV0IHlvdSB3YW50IHRvIHVzZSBpdCBhcyBhIGJ1ZmZlcgoJCW51bWJlciwgZm9yY2UgaXQgdG8gYmUgYSBOdW1iZXIgYnkgYWRkaW5nIHplcm8gdG8gaXQ6ID4KCQkJOmVjaG8gYnVmbmFtZSgiMyIgKyAwKQo8CQlJZiB0aGUgYnVmZmVyIGRvZXNuJ3QgZXhpc3QsIG9yIGRvZXNuJ3QgaGF2ZSBhIG5hbWUsIGFuIGVtcHR5CgkJc3RyaW5nIGlzIHJldHVybmVkLiA+CglidWZuYW1lKCIjIikJCWFsdGVybmF0ZSBidWZmZXIgbmFtZQoJYnVmbmFtZSgzKQkJbmFtZSBvZiBidWZmZXIgMwoJYnVmbmFtZSgiJSIpCQluYW1lIG9mIGN1cnJlbnQgYnVmZmVyCglidWZuYW1lKCJmaWxlMiIpCW5hbWUgb2YgYnVmZmVyIHdoZXJlICJmaWxlMiIgbWF0Y2hlcy4KPAkJCQkJCQkqYnVmZmVyX25hbWUoKSoKCQlPYnNvbGV0ZSBuYW1lOiBidWZmZXJfbmFtZSgpLgoKCQkJCQkJCSpidWZucigpKgpidWZucih7ZXhwcn0gWywge2NyZWF0ZX1dKQoJCVRoZSByZXN1bHQgaXMgdGhlIG51bWJlciBvZiBhIGJ1ZmZlciwgYXMgaXQgaXMgZGlzcGxheWVkIGJ5CgkJdGhlICI6bHMiIGNvbW1hbmQuICBGb3IgdGhlIHVzZSBvZiB7ZXhwcn0sIHNlZSB8YnVmbmFtZSgpfAoJCWFib3ZlLgoJCUlmIHRoZSBidWZmZXIgZG9lc24ndCBleGlzdCwgLTEgaXMgcmV0dXJuZWQuICBPciwgaWYgdGhlCgkJe2NyZWF0ZX0gYXJndW1lbnQgaXMgcHJlc2VudCBhbmQgbm90IHplcm8sIGEgbmV3LCB1bmxpc3RlZCwKCQlidWZmZXIgaXMgY3JlYXRlZCBhbmQgaXRzIG51bWJlciBpcyByZXR1cm5lZC4KCQlidWZucigiJCIpIGlzIHRoZSBsYXN0IGJ1ZmZlcjogPgoJOmxldCBsYXN0X2J1ZmZlciA9IGJ1Zm5yKCIkIikKPAkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGhpZ2hlc3QgYnVmZmVyIG51bWJlcgoJCW9mIGV4aXN0aW5nIGJ1ZmZlcnMuICBOb3RlIHRoYXQgbm90IGFsbCBidWZmZXJzIHdpdGggYSBzbWFsbGVyCgkJbnVtYmVyIG5lY2Vzc2FyaWx5IGV4aXN0LCBiZWNhdXNlICI6YndpcGVvdXQiIG1heSBoYXZlIHJlbW92ZWQKCQl0aGVtLiAgVXNlIGJ1ZmV4aXN0cygpIHRvIHRlc3QgZm9yIHRoZSBleGlzdGVuY2Ugb2YgYSBidWZmZXIuCgkJCQkJCQkqYnVmZmVyX251bWJlcigpKgoJCU9ic29sZXRlIG5hbWU6IGJ1ZmZlcl9udW1iZXIoKS4KCQkJCQkJCSpsYXN0X2J1ZmZlcl9ucigpKgoJCU9ic29sZXRlIG5hbWUgZm9yIGJ1Zm5yKCIkIik6IGxhc3RfYnVmZmVyX25yKCkuCgpidWZ3aW5ucih7ZXhwcn0pCQkJCQkqYnVmd2lubnIoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBmaXJzdAoJCXdpbmRvdyBhc3NvY2lhdGVkIHdpdGggYnVmZmVyIHtleHByfS4gIEZvciB0aGUgdXNlIG9mIHtleHByfSwKCQlzZWUgfGJ1Zm5hbWUoKXwgYWJvdmUuCUlmIGJ1ZmZlciB7ZXhwcn0gZG9lc24ndCBleGlzdCBvcgoJCXRoZXJlIGlzIG5vIHN1Y2ggd2luZG93LCAtMSBpcyByZXR1cm5lZC4gIEV4YW1wbGU6ID4KCgllY2hvICJBIHdpbmRvdyBjb250YWluaW5nIGJ1ZmZlciAxIGlzICIgLiAoYnVmd2lubnIoMSkpCgo8CQlUaGUgbnVtYmVyIGNhbiBiZSB1c2VkIHdpdGggfENUUkwtV193fCBhbmQgIjp3aW5jbWQgdyIKCQl8OndpbmNtZHwuCgkJT25seSBkZWFscyB3aXRoIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoKYnl0ZTJsaW5lKHtieXRlfSkJCQkJCSpieXRlMmxpbmUoKSoKCQlSZXR1cm4gdGhlIGxpbmUgbnVtYmVyIHRoYXQgY29udGFpbnMgdGhlIGNoYXJhY3RlciBhdCBieXRlCgkJY291bnQge2J5dGV9IGluIHRoZSBjdXJyZW50IGJ1ZmZlci4gIFRoaXMgaW5jbHVkZXMgdGhlCgkJZW5kLW9mLWxpbmUgY2hhcmFjdGVyLCBkZXBlbmRpbmcgb24gdGhlICdmaWxlZm9ybWF0JyBvcHRpb24KCQlmb3IgdGhlIGN1cnJlbnQgYnVmZmVyLiAgVGhlIGZpcnN0IGNoYXJhY3RlciBoYXMgYnl0ZSBjb3VudAoJCW9uZS4KCQlBbHNvIHNlZSB8bGluZTJieXRlKCl8LCB8Z298IGFuZCB8OmdvdG98LgoJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtieXRlX29mZnNldHwKCQlmZWF0dXJlfQoKYnl0ZWlkeCh7ZXhwcn0sIHtucn0pCQkJCQkqYnl0ZWlkeCgpKgoJCVJldHVybiBieXRlIGluZGV4IG9mIHRoZSB7bnJ9J3RoIGNoYXJhY3RlciBpbiB0aGUgc3RyaW5nCgkJe2V4cHJ9LiAgVXNlIHplcm8gZm9yIHRoZSBmaXJzdCBjaGFyYWN0ZXIsIGl0IHJldHVybnMgemVyby4KCQlUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgdXNlZnVsIHdoZW4gdGhlcmUgYXJlIG11bHRpYnl0ZQoJCWNoYXJhY3RlcnMsIG90aGVyd2lzZSB0aGUgcmV0dXJuZWQgdmFsdWUgaXMgZXF1YWwgdG8ge25yfS4KCQlDb21wb3NpbmcgY2hhcmFjdGVycyBhcmUgbm90IGNvdW50ZWQgc2VwYXJhdGVseSwgdGhlaXIgYnl0ZQoJCWxlbmd0aCBpcyBhZGRlZCB0byB0aGUgcHJlY2VkaW5nIGJhc2UgY2hhcmFjdGVyLiAgU2VlCgkJfGJ5dGVpZHhjb21wKCl8IGJlbG93IGZvciBjb3VudGluZyBjb21wb3NpbmcgY2hhcmFjdGVycwoJCXNlcGFyYXRlbHkuCgkJRXhhbXBsZSA6ID4KCQkJZWNobyBtYXRjaHN0cihzdHIsICIuIiwgYnl0ZWlkeChzdHIsIDMpKQo8CQl3aWxsIGRpc3BsYXkgdGhlIGZvdXJ0aCBjaGFyYWN0ZXIuICBBbm90aGVyIHdheSB0byBkbyB0aGUKCQlzYW1lOiA+CgkJCWxldCBzID0gc3RycGFydChzdHIsIGJ5dGVpZHgoc3RyLCAzKSkKCQkJZWNobyBzdHJwYXJ0KHMsIDAsIGJ5dGVpZHgocywgMSkpCjwJCUFsc28gc2VlIHxzdHJnZXRjaGFyKCl8IGFuZCB8c3RyY2hhcnBhcnQoKXwuCgoJCUlmIHRoZXJlIGFyZSBsZXNzIHRoYW4ge25yfSBjaGFyYWN0ZXJzIC0xIGlzIHJldHVybmVkLgoJCUlmIHRoZXJlIGFyZSBleGFjdGx5IHtucn0gY2hhcmFjdGVycyB0aGUgbGVuZ3RoIG9mIHRoZSBzdHJpbmcKCQlpbiBieXRlcyBpcyByZXR1cm5lZC4KCmJ5dGVpZHhjb21wKHtleHByfSwge25yfSkJCQkJCSpieXRlaWR4Y29tcCgpKgoJCUxpa2UgYnl0ZWlkeCgpLCBleGNlcHQgdGhhdCBhIGNvbXBvc2luZyBjaGFyYWN0ZXIgaXMgY291bnRlZAoJCWFzIGEgc2VwYXJhdGUgY2hhcmFjdGVyLiAgRXhhbXBsZTogPgoJCQlsZXQgcyA9ICdlJyAuIG5yMmNoYXIoMHgzMDEpCgkJCWVjaG8gYnl0ZWlkeChzLCAxKQoJCQllY2hvIGJ5dGVpZHhjb21wKHMsIDEpCgkJCWVjaG8gYnl0ZWlkeGNvbXAocywgMikKPAkJVGhlIGZpcnN0IGFuZCB0aGlyZCBlY2hvIHJlc3VsdCBpbiAzICgnZScgcGx1cyBjb21wb3NpbmcKCQljaGFyYWN0ZXIgaXMgMyBieXRlcyksIHRoZSBzZWNvbmQgZWNobyByZXN1bHRzIGluIDEgKCdlJyBpcwoJCW9uZSBieXRlKS4KCQlPbmx5IHdvcmtzIGRpZmZlcmVudCBmcm9tIGJ5dGVpZHgoKSB3aGVuICdlbmNvZGluZycgaXMgc2V0IHRvCgkJYSBVbmljb2RlIGVuY29kaW5nLgoKY2FsbCh7ZnVuY30sIHthcmdsaXN0fSBbLCB7ZGljdH1dKQkJCSpjYWxsKCkqICpFNjk5KgoJCUNhbGwgZnVuY3Rpb24ge2Z1bmN9IHdpdGggdGhlIGl0ZW1zIGluIHxMaXN0fCB7YXJnbGlzdH0gYXMKCQlhcmd1bWVudHMuCgkJe2Z1bmN9IGNhbiBlaXRoZXIgYmUgYSB8RnVuY3JlZnwgb3IgdGhlIG5hbWUgb2YgYSBmdW5jdGlvbi4KCQlhOmZpcnN0bGluZSBhbmQgYTpsYXN0bGluZSBhcmUgc2V0IHRvIHRoZSBjdXJzb3IgbGluZS4KCQlSZXR1cm5zIHRoZSByZXR1cm4gdmFsdWUgb2YgdGhlIGNhbGxlZCBmdW5jdGlvbi4KCQl7ZGljdH0gaXMgZm9yIGZ1bmN0aW9ucyB3aXRoIHRoZSAiZGljdCIgYXR0cmlidXRlLiAgSXQgd2lsbCBiZQoJCXVzZWQgdG8gc2V0IHRoZSBsb2NhbCB2YXJpYWJsZSAic2VsZiIuIHxEaWN0aW9uYXJ5LWZ1bmN0aW9ufAoKY2VpbCh7ZXhwcn0pCQkJCQkJCSpjZWlsKCkqCgkJUmV0dXJuIHRoZSBzbWFsbGVzdCBpbnRlZ3JhbCB2YWx1ZSBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8KCQl7ZXhwcn0gYXMgYSB8RmxvYXR8IChyb3VuZCB1cCkuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJZWNobyBjZWlsKDEuNDU2KQo8CQkJMi4wICA+CgkJCWVjaG8gY2VpbCgtNS40NTYpCjwJCQktNS4wICA+CgkJCWVjaG8gY2VpbCg0LjApCjwJCQk0LjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKY2hhbmdlbnIoKQkJCQkJCSpjaGFuZ2VucigpKgoJCVJldHVybiB0aGUgbnVtYmVyIG9mIHRoZSBtb3N0IHJlY2VudCBjaGFuZ2UuICBUaGlzIGlzIHRoZSBzYW1lCgkJbnVtYmVyIGFzIHdoYXQgaXMgZGlzcGxheWVkIHdpdGggfDp1bmRvbGlzdHwgYW5kIGNhbiBiZSB1c2VkCgkJd2l0aCB0aGUgfDp1bmRvfCBjb21tYW5kLgoJCVdoZW4gYSBjaGFuZ2Ugd2FzIG1hZGUgaXQgaXMgdGhlIG51bWJlciBvZiB0aGF0IGNoYW5nZS4gIEFmdGVyCgkJcmVkbyBpdCBpcyB0aGUgbnVtYmVyIG9mIHRoZSByZWRvbmUgY2hhbmdlLiAgQWZ0ZXIgdW5kbyBpdCBpcwoJCW9uZSBsZXNzIHRoYW4gdGhlIG51bWJlciBvZiB0aGUgdW5kb25lIGNoYW5nZS4KCmNoYXIybnIoe2V4cHJ9Wywge3V0Zjh9XSkJCQkJCSpjaGFyMm5yKCkqCgkJUmV0dXJuIG51bWJlciB2YWx1ZSBvZiB0aGUgZmlyc3QgY2hhciBpbiB7ZXhwcn0uICBFeGFtcGxlczogPgoJCQljaGFyMm5yKCIgIikJCXJldHVybnMgMzIKCQkJY2hhcjJucigiQUJDIikJCXJldHVybnMgNjUKPAkJV2hlbiB7dXRmOH0gaXMgb21pdHRlZCBvciB6ZXJvLCB0aGUgY3VycmVudCAnZW5jb2RpbmcnIGlzIHVzZWQuCgkJRXhhbXBsZSBmb3IgInV0Zi04IjogPgoJCQljaGFyMm5yKCLhIikJCXJldHVybnMgMjI1CgkJCWNoYXIybnIoIuEiWzBdKQkJcmV0dXJucyAxOTUKPAkJV2l0aCB7dXRmOH0gc2V0IHRvIDEsIGFsd2F5cyB0cmVhdCBhcyB1dGYtOCBjaGFyYWN0ZXJzLgoJCUEgY29tYmluaW5nIGNoYXJhY3RlciBpcyBhIHNlcGFyYXRlIGNoYXJhY3Rlci4KCQl8bnIyY2hhcigpfCBkb2VzIHRoZSBvcHBvc2l0ZS4KCmNpbmRlbnQoe2xudW19KQkJCQkJCSpjaW5kZW50KCkqCgkJR2V0IHRoZSBhbW91bnQgb2YgaW5kZW50IGZvciBsaW5lIHtsbnVtfSBhY2NvcmRpbmcgdGhlIEMKCQlpbmRlbnRpbmcgcnVsZXMsIGFzIHdpdGggJ2NpbmRlbnQnLgoJCVRoZSBpbmRlbnQgaXMgY291bnRlZCBpbiBzcGFjZXMsIHRoZSB2YWx1ZSBvZiAndGFic3RvcCcgaXMKCQlyZWxldmFudC4gIHtsbnVtfSBpcyB1c2VkIGp1c3QgbGlrZSBpbiB8Z2V0bGluZSgpfC4KCQlXaGVuIHtsbnVtfSBpcyBpbnZhbGlkIG9yIFZpbSB3YXMgbm90IGNvbXBpbGVkIHRoZSB8K2NpbmRlbnR8CgkJZmVhdHVyZSwgLTEgaXMgcmV0dXJuZWQuCgkJU2VlIHxDLWluZGVudGluZ3wuCgpjbGVhcm1hdGNoZXMoKQkJCQkJCSpjbGVhcm1hdGNoZXMoKSoKCQlDbGVhcnMgYWxsIG1hdGNoZXMgcHJldmlvdXNseSBkZWZpbmVkIGJ5IHxtYXRjaGFkZCgpfCBhbmQgdGhlCgkJfDptYXRjaHwgY29tbWFuZHMuCgoJCQkJCQkJKmNvbCgpKgpjb2woe2V4cHJ9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgYnl0ZSBpbmRleCBvZiB0aGUgY29sdW1uCgkJcG9zaXRpb24gZ2l2ZW4gd2l0aCB7ZXhwcn0uICBUaGUgYWNjZXB0ZWQgcG9zaXRpb25zIGFyZToKCQkgICAgLgkgICAgdGhlIGN1cnNvciBwb3NpdGlvbgoJCSAgICAkCSAgICB0aGUgZW5kIG9mIHRoZSBjdXJzb3IgbGluZSAodGhlIHJlc3VsdCBpcyB0aGUKCQkJICAgIG51bWJlciBvZiBieXRlcyBpbiB0aGUgY3Vyc29yIGxpbmUgcGx1cyBvbmUpCgkJICAgICd4CSAgICBwb3NpdGlvbiBvZiBtYXJrIHggKGlmIHRoZSBtYXJrIGlzIG5vdCBzZXQsIDAgaXMKCQkJICAgIHJldHVybmVkKQoJCSAgICB2ICAgICAgIEluIFZpc3VhbCBtb2RlOiB0aGUgc3RhcnQgb2YgdGhlIFZpc3VhbCBhcmVhICh0aGUKCQkJICAgIGN1cnNvciBpcyB0aGUgZW5kKS4gIFdoZW4gbm90IGluIFZpc3VhbCBtb2RlCgkJCSAgICByZXR1cm5zIHRoZSBjdXJzb3IgcG9zaXRpb24uICBEaWZmZXJzIGZyb20gfCc8fCBpbgoJCQkgICAgdGhhdCBpdCdzIHVwZGF0ZWQgcmlnaHQgYXdheS4KCQlBZGRpdGlvbmFsbHkge2V4cHJ9IGNhbiBiZSBbbG51bSwgY29sXTogYSB8TGlzdHwgd2l0aCB0aGUgbGluZQoJCWFuZCBjb2x1bW4gbnVtYmVyLiBNb3N0IHVzZWZ1bCB3aGVuIHRoZSBjb2x1bW4gaXMgIiQiLCB0byBnZXQKCQl0aGUgbGFzdCBjb2x1bW4gb2YgYSBzcGVjaWZpYyBsaW5lLiAgV2hlbiAibG51bSIgb3IgImNvbCIgaXMKCQlvdXQgb2YgcmFuZ2UgdGhlbiBjb2woKSByZXR1cm5zIHplcm8uCgkJVG8gZ2V0IHRoZSBsaW5lIG51bWJlciB1c2UgfGxpbmUoKXwuICBUbyBnZXQgYm90aCB1c2UKCQl8Z2V0cG9zKCl8LgoJCUZvciB0aGUgc2NyZWVuIGNvbHVtbiBwb3NpdGlvbiB1c2UgfHZpcnRjb2woKXwuCgkJTm90ZSB0aGF0IG9ubHkgbWFya3MgaW4gdGhlIGN1cnJlbnQgZmlsZSBjYW4gYmUgdXNlZC4KCQlFeGFtcGxlczogPgoJCQljb2woIi4iKQkJY29sdW1uIG9mIGN1cnNvcgoJCQljb2woIiQiKQkJbGVuZ3RoIG9mIGN1cnNvciBsaW5lIHBsdXMgb25lCgkJCWNvbCgiJ3QiKQkJY29sdW1uIG9mIG1hcmsgdAoJCQljb2woIiciIC4gbWFya25hbWUpCWNvbHVtbiBvZiBtYXJrIG1hcmtuYW1lCjwJCVRoZSBmaXJzdCBjb2x1bW4gaXMgMS4JMCBpcyByZXR1cm5lZCBmb3IgYW4gZXJyb3IuCgkJRm9yIGFuIHVwcGVyY2FzZSBtYXJrIHRoZSBjb2x1bW4gbWF5IGFjdHVhbGx5IGJlIGluIGFub3RoZXIKCQlidWZmZXIuCgkJRm9yIHRoZSBjdXJzb3IgcG9zaXRpb24sIHdoZW4gJ3ZpcnR1YWxlZGl0JyBpcyBhY3RpdmUsIHRoZQoJCWNvbHVtbiBpcyBvbmUgaGlnaGVyIGlmIHRoZSBjdXJzb3IgaXMgYWZ0ZXIgdGhlIGVuZCBvZiB0aGUKCQlsaW5lLiAgVGhpcyBjYW4gYmUgdXNlZCB0byBvYnRhaW4gdGhlIGNvbHVtbiBpbiBJbnNlcnQgbW9kZTogPgoJCQk6aW1hcCA8RjI+IDxDLU8+OmxldCBzYXZlX3ZlID0gJnZlPENSPgoJCQkJXDxDLU8+OnNldCB2ZT1hbGw8Q1I+CgkJCQlcPEMtTz46ZWNobyBjb2woIi4iKSAuICJcbiIgPEJhcj4KCQkJCVxsZXQgJnZlID0gc2F2ZV92ZTxDUj4KPAoKY29tcGxldGUoe3N0YXJ0Y29sfSwge21hdGNoZXN9KQkJCSpjb21wbGV0ZSgpKiAqRTc4NSoKCQlTZXQgdGhlIG1hdGNoZXMgZm9yIEluc2VydCBtb2RlIGNvbXBsZXRpb24uCgkJQ2FuIG9ubHkgYmUgdXNlZCBpbiBJbnNlcnQgbW9kZS4gIFlvdSBuZWVkIHRvIHVzZSBhIG1hcHBpbmcKCQl3aXRoIENUUkwtUiA9IHxpX0NUUkwtUnwuICBJdCBkb2VzIG5vdCB3b3JrIGFmdGVyIENUUkwtTyBvcgoJCXdpdGggYW4gZXhwcmVzc2lvbiBtYXBwaW5nLgoJCXtzdGFydGNvbH0gaXMgdGhlIGJ5dGUgb2Zmc2V0IGluIHRoZSBsaW5lIHdoZXJlIHRoZSBjb21wbGV0ZWQKCQl0ZXh0IHN0YXJ0LiAgVGhlIHRleHQgdXAgdG8gdGhlIGN1cnNvciBpcyB0aGUgb3JpZ2luYWwgdGV4dAoJCXRoYXQgd2lsbCBiZSByZXBsYWNlZCBieSB0aGUgbWF0Y2hlcy4gIFVzZSBjb2woJy4nKSBmb3IgYW4KCQllbXB0eSBzdHJpbmcuICAiY29sKCcuJykgLSAxIiB3aWxsIHJlcGxhY2Ugb25lIGNoYXJhY3RlciBieSBhCgkJbWF0Y2guCgkJe21hdGNoZXN9IG11c3QgYmUgYSB8TGlzdHwuICBFYWNoIHxMaXN0fCBpdGVtIGlzIG9uZSBtYXRjaC4KCQlTZWUgfGNvbXBsZXRlLWl0ZW1zfCBmb3IgdGhlIGtpbmQgb2YgaXRlbXMgdGhhdCBhcmUgcG9zc2libGUuCgkJTm90ZSB0aGF0IHRoZSBhZnRlciBjYWxsaW5nIHRoaXMgZnVuY3Rpb24geW91IG5lZWQgdG8gYXZvaWQKCQlpbnNlcnRpbmcgYW55dGhpbmcgdGhhdCB3b3VsZCBjYXVzZSBjb21wbGV0aW9uIHRvIHN0b3AuCgkJVGhlIG1hdGNoIGNhbiBiZSBzZWxlY3RlZCB3aXRoIENUUkwtTiBhbmQgQ1RSTC1QIGFzIHVzdWFsIHdpdGgKCQlJbnNlcnQgbW9kZSBjb21wbGV0aW9uLiAgVGhlIHBvcHVwIG1lbnUgd2lsbCBhcHBlYXIgaWYKCQlzcGVjaWZpZWQsIHNlZSB8aW5zLWNvbXBsZXRpb24tbWVudXwuCgkJRXhhbXBsZTogPgoJaW5vcmVtYXAgPEY1PiA8Qy1SPj1MaXN0TW9udGhzKCk8Q1I+CgoJZnVuYyEgTGlzdE1vbnRocygpCgkgIGNhbGwgY29tcGxldGUoY29sKCcuJyksIFsnSmFudWFyeScsICdGZWJydWFyeScsICdNYXJjaCcsCgkJXCAnQXByaWwnLCAnTWF5JywgJ0p1bmUnLCAnSnVseScsICdBdWd1c3QnLCAnU2VwdGVtYmVyJywKCQlcICdPY3RvYmVyJywgJ05vdmVtYmVyJywgJ0RlY2VtYmVyJ10pCgkgIHJldHVybiAnJwoJZW5kZnVuYwo8CQlUaGlzIGlzbid0IHZlcnkgdXNlZnVsLCBidXQgaXQgc2hvd3MgaG93IGl0IHdvcmtzLiAgTm90ZSB0aGF0CgkJYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkIHRvIGF2b2lkIGEgemVybyBiZWluZyBpbnNlcnRlZC4KCmNvbXBsZXRlX2FkZCh7ZXhwcn0pCQkJCSpjb21wbGV0ZV9hZGQoKSoKCQlBZGQge2V4cHJ9IHRvIHRoZSBsaXN0IG9mIG1hdGNoZXMuICBPbmx5IHRvIGJlIHVzZWQgYnkgdGhlCgkJZnVuY3Rpb24gc3BlY2lmaWVkIHdpdGggdGhlICdjb21wbGV0ZWZ1bmMnIG9wdGlvbi4KCQlSZXR1cm5zIDAgZm9yIGZhaWx1cmUgKGVtcHR5IHN0cmluZyBvciBvdXQgb2YgbWVtb3J5KSwKCQkxIHdoZW4gdGhlIG1hdGNoIHdhcyBhZGRlZCwgMiB3aGVuIHRoZSBtYXRjaCB3YXMgYWxyZWFkeSBpbgoJCXRoZSBsaXN0LgoJCVNlZSB8Y29tcGxldGUtZnVuY3Rpb25zfCBmb3IgYW4gZXhwbGFuYXRpb24gb2Yge2V4cHJ9LglJdCBpcwoJCXRoZSBzYW1lIGFzIG9uZSBpdGVtIGluIHRoZSBsaXN0IHRoYXQgJ29tbmlmdW5jJyB3b3VsZCByZXR1cm4uCgpjb21wbGV0ZV9jaGVjaygpCQkJCSpjb21wbGV0ZV9jaGVjaygpKgoJCUNoZWNrIGZvciBhIGtleSB0eXBlZCB3aGlsZSBsb29raW5nIGZvciBjb21wbGV0aW9uIG1hdGNoZXMuCgkJVGhpcyBpcyB0byBiZSB1c2VkIHdoZW4gbG9va2luZyBmb3IgbWF0Y2hlcyB0YWtlcyBzb21lIHRpbWUuCgkJUmV0dXJucyBub24temVybyB3aGVuIHNlYXJjaGluZyBmb3IgbWF0Y2hlcyBpcyB0byBiZSBhYm9ydGVkLAoJCXplcm8gb3RoZXJ3aXNlLgoJCU9ubHkgdG8gYmUgdXNlZCBieSB0aGUgZnVuY3Rpb24gc3BlY2lmaWVkIHdpdGggdGhlCgkJJ2NvbXBsZXRlZnVuYycgb3B0aW9uLgoKCQkJCQkJKmNvbmZpcm0oKSoKY29uZmlybSh7bXNnfSBbLCB7Y2hvaWNlc30gWywge2RlZmF1bHR9IFssIHt0eXBlfV1dXSkKCQlDb25maXJtKCkgb2ZmZXJzIHRoZSB1c2VyIGEgZGlhbG9nLCBmcm9tIHdoaWNoIGEgY2hvaWNlIGNhbiBiZQoJCW1hZGUuICBJdCByZXR1cm5zIHRoZSBudW1iZXIgb2YgdGhlIGNob2ljZS4gIEZvciB0aGUgZmlyc3QKCQljaG9pY2UgdGhpcyBpcyAxLgoJCU5vdGU6IGNvbmZpcm0oKSBpcyBvbmx5IHN1cHBvcnRlZCB3aGVuIGNvbXBpbGVkIHdpdGggZGlhbG9nCgkJc3VwcG9ydCwgc2VlIHwrZGlhbG9nX2NvbnwgYW5kIHwrZGlhbG9nX2d1aXwuCgoJCXttc2d9IGlzIGRpc3BsYXllZCBpbiBhIHxkaWFsb2d8IHdpdGgge2Nob2ljZXN9IGFzIHRoZQoJCWFsdGVybmF0aXZlcy4gIFdoZW4ge2Nob2ljZXN9IGlzIG1pc3Npbmcgb3IgZW1wdHksICImT0siIGlzCgkJdXNlZCAoYW5kIHRyYW5zbGF0ZWQpLgoJCXttc2d9IGlzIGEgU3RyaW5nLCB1c2UgJ1xuJyB0byBpbmNsdWRlIGEgbmV3bGluZS4gIE9ubHkgb24KCQlzb21lIHN5c3RlbXMgdGhlIHN0cmluZyBpcyB3cmFwcGVkIHdoZW4gaXQgZG9lc24ndCBmaXQuCgoJCXtjaG9pY2VzfSBpcyBhIFN0cmluZywgd2l0aCB0aGUgaW5kaXZpZHVhbCBjaG9pY2VzIHNlcGFyYXRlZAoJCWJ5ICdcbicsIGUuZy4gPgoJCQljb25maXJtKCJTYXZlIGNoYW5nZXM/IiwgIiZZZXNcbiZOb1xuJkNhbmNlbCIpCjwJCVRoZSBsZXR0ZXIgYWZ0ZXIgdGhlICcmJyBpcyB0aGUgc2hvcnRjdXQga2V5IGZvciB0aGF0IGNob2ljZS4KCQlUaHVzIHlvdSBjYW4gdHlwZSAnYycgdG8gc2VsZWN0ICJDYW5jZWwiLiAgVGhlIHNob3J0Y3V0IGRvZXMKCQlub3QgbmVlZCB0byBiZSB0aGUgZmlyc3QgbGV0dGVyOiA+CgkJCWNvbmZpcm0oImZpbGUgaGFzIGJlZW4gbW9kaWZpZWQiLCAiJlNhdmVcblNhdmUgJkFsbCIpCjwJCUZvciB0aGUgY29uc29sZSwgdGhlIGZpcnN0IGxldHRlciBvZiBlYWNoIGNob2ljZSBpcyB1c2VkIGFzCgkJdGhlIGRlZmF1bHQgc2hvcnRjdXQga2V5LgoKCQlUaGUgb3B0aW9uYWwge2RlZmF1bHR9IGFyZ3VtZW50IGlzIHRoZSBudW1iZXIgb2YgdGhlIGNob2ljZQoJCXRoYXQgaXMgbWFkZSBpZiB0aGUgdXNlciBoaXRzIDxDUj4uICBVc2UgMSB0byBtYWtlIHRoZSBmaXJzdAoJCWNob2ljZSB0aGUgZGVmYXVsdCBvbmUuICBVc2UgMCB0byBub3Qgc2V0IGEgZGVmYXVsdC4gIElmCgkJe2RlZmF1bHR9IGlzIG9taXR0ZWQsIDEgaXMgdXNlZC4KCgkJVGhlIG9wdGlvbmFsIHt0eXBlfSBhcmd1bWVudCBnaXZlcyB0aGUgdHlwZSBvZiBkaWFsb2cuICBUaGlzCgkJaXMgb25seSB1c2VkIGZvciB0aGUgaWNvbiBvZiB0aGUgR1RLLCBNYWMsIE1vdGlmIGFuZCBXaW4zMgoJCUdVSS4gIEl0IGNhbiBiZSBvbmUgb2YgdGhlc2UgdmFsdWVzOiAiRXJyb3IiLCAiUXVlc3Rpb24iLAoJCSJJbmZvIiwgIldhcm5pbmciIG9yICJHZW5lcmljIi4gIE9ubHkgdGhlIGZpcnN0IGNoYXJhY3RlciBpcwoJCXJlbGV2YW50LiAgV2hlbiB7dHlwZX0gaXMgb21pdHRlZCwgIkdlbmVyaWMiIGlzIHVzZWQuCgoJCUlmIHRoZSB1c2VyIGFib3J0cyB0aGUgZGlhbG9nIGJ5IHByZXNzaW5nIDxFc2M+LCBDVFJMLUMsCgkJb3IgYW5vdGhlciB2YWxpZCBpbnRlcnJ1cHQga2V5LCBjb25maXJtKCkgcmV0dXJucyAwLgoKCQlBbiBleGFtcGxlOiA+CiAgIDpsZXQgY2hvaWNlID0gY29uZmlybSgiV2hhdCBkbyB5b3Ugd2FudD8iLCAiJkFwcGxlc1xuJk9yYW5nZXNcbiZCYW5hbmFzIiwgMikKICAgOmlmIGNob2ljZSA9PSAwCiAgIDoJZWNobyAibWFrZSB1cCB5b3VyIG1pbmQhIgogICA6ZWxzZWlmIGNob2ljZSA9PSAzCiAgIDoJZWNobyAidGFzdGVmdWwiCiAgIDplbHNlCiAgIDoJZWNobyAiSSBwcmVmZXIgYmFuYW5hcyBteXNlbGYuIgogICA6ZW5kaWYKPAkJSW4gYSBHVUkgZGlhbG9nLCBidXR0b25zIGFyZSB1c2VkLiAgVGhlIGxheW91dCBvZiB0aGUgYnV0dG9ucwoJCWRlcGVuZHMgb24gdGhlICd2JyBmbGFnIGluICdndWlvcHRpb25zJy4gIElmIGl0IGlzIGluY2x1ZGVkLAoJCXRoZSBidXR0b25zIGFyZSBhbHdheXMgcHV0IHZlcnRpY2FsbHkuCU90aGVyd2lzZSwgIGNvbmZpcm0oKQoJCXRyaWVzIHRvIHB1dCB0aGUgYnV0dG9ucyBpbiBvbmUgaG9yaXpvbnRhbCBsaW5lLiAgSWYgdGhleQoJCWRvbid0IGZpdCwgYSB2ZXJ0aWNhbCBsYXlvdXQgaXMgdXNlZCBhbnl3YXkuICBGb3Igc29tZSBzeXN0ZW1zCgkJdGhlIGhvcml6b250YWwgbGF5b3V0IGlzIGFsd2F5cyB1c2VkLgoKY2hfY2xvc2Uoe2hhbmRsZX0pCQkJCQkJKmNoX2Nsb3NlKCkqCgkJQ2xvc2Uge2hhbmRsZX0uICBTZWUgfGNoYW5uZWwtY2xvc2V8LgoJCXtoYW5kbGV9IGNhbiBiZSBDaGFubmVsIG9yIGEgSm9iIHRoYXQgaGFzIGEgQ2hhbm5lbC4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBmZWF0dXJlfQoKY2hfZXZhbGV4cHIoe2hhbmRsZX0sIHtleHByfSBbLCB7b3B0aW9uc31dKQkJCSpjaF9ldmFsZXhwcigpKgoJCVNlbmQge2V4cHJ9IG92ZXIge2hhbmRsZX0uICBUaGUge2V4cHJ9IGlzIGVuY29kZWQKCQlhY2NvcmRpbmcgdG8gdGhlIHR5cGUgb2YgY2hhbm5lbC4gIFRoZSBmdW5jdGlvbiBjYW5ub3QgYmUgdXNlZAoJCXdpdGggYSByYXcgY2hhbm5lbC4gIFNlZSB8Y2hhbm5lbC11c2V8LgoJCXtoYW5kbGV9IGNhbiBiZSBDaGFubmVsIG9yIGEgSm9iIHRoYXQgaGFzIGEgQ2hhbm5lbC4KCQkJCQkJCQkqRTkxNyoKCQl7b3B0aW9uc30gbXVzdCBiZSBhIERpY3Rpb25hcnkuICBJdCBtdXN0IG5vdCBoYXZlIGEgImNhbGxiYWNrIgoJCWVudHJ5LiAgSXQgY2FuIGhhdmUgYSAidGltZW91dCIgZW50cnkgdG8gc3BlY2lmeSB0aGUgdGltZW91dAoJCWZvciB0aGlzIHNwZWNpZmljIHJlcXVlc3QuCgoJCWNoX2V2YWxleHByKCkgd2FpdHMgZm9yIGEgcmVzcG9uc2UgYW5kIHJldHVybnMgdGhlIGRlY29kZWQKCQlleHByZXNzaW9uLiAgV2hlbiB0aGVyZSBpcyBhbiBlcnJvciBvciB0aW1lb3V0IGl0IHJldHVybnMgYW4KCQllbXB0eSBzdHJpbmcuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX2V2YWxyYXcoe2hhbmRsZX0sIHtzdHJpbmd9IFssIHtvcHRpb25zfV0pCQkqY2hfZXZhbHJhdygpKgoJCVNlbmQge3N0cmluZ30gb3ZlciB7aGFuZGxlfS4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgoJCVdvcmtzIGxpa2UgfGNoX2V2YWxleHByKCl8LCBidXQgZG9lcyBub3QgZW5jb2RlIHRoZSByZXF1ZXN0IG9yCgkJZGVjb2RlIHRoZSByZXNwb25zZS4gIFRoZSBjYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yIHRoZQoJCWNvcnJlY3QgY29udGVudHMuICBBbHNvIGRvZXMgbm90IGFkZCBhIG5ld2xpbmUgZm9yIGEgY2hhbm5lbAoJCWluIE5MIG1vZGUsIHRoZSBjYWxsZXIgbXVzdCBkbyB0aGF0LiAgVGhlIE5MIGluIHRoZSByZXNwb25zZQoJCWlzIHJlbW92ZWQuCgkJU2VlIHxjaGFubmVsLXVzZXwuCgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX2dldGJ1Zm5yKHtoYW5kbGV9LCB7d2hhdH0pCQkJCSAqY2hfZ2V0YnVmbnIoKSoKCQlHZXQgdGhlIGJ1ZmZlciBudW1iZXIgdGhhdCB7aGFuZGxlfSBpcyB1c2luZyBmb3Ige3doYXR9LgoJCXtoYW5kbGV9IGNhbiBiZSBDaGFubmVsIG9yIGEgSm9iIHRoYXQgaGFzIGEgQ2hhbm5lbC4KCQl7d2hhdH0gY2FuIGJlICJlcnIiIGZvciBzdGRlcnIsICJvdXQiIGZvciBzdGRvdXQgb3IgZW1wdHkgZm9yCgkJc29ja2V0IG91dHB1dC4KCQlSZXR1cm5zIC0xIHdoZW4gdGhlcmUgaXMgbm8gYnVmZmVyLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2hhbm5lbHwgZmVhdHVyZX0KCmNoX2dldGpvYih7Y2hhbm5lbH0pCQkJCQkJKmNoX2dldGpvYigpKgoJCUdldCB0aGUgSm9iIGFzc29jaWF0ZWQgd2l0aCB7Y2hhbm5lbH0uCgkJSWYgdGhlcmUgaXMgbm8gam9iIGNhbGxpbmcgfGpvYl9zdGF0dXMoKXwgb24gdGhlIHJldHVybmVkIEpvYgoJCXdpbGwgcmVzdWx0IGluICJmYWlsIi4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBhbmQKCQl8K2pvYnwgZmVhdHVyZXN9CgpjaF9pbmZvKHtoYW5kbGV9KQkJCQkJCSpjaF9pbmZvKCkqCgkJUmV0dXJucyBhIERpY3Rpb25hcnkgd2l0aCBpbmZvcm1hdGlvbiBhYm91dCB7aGFuZGxlfS4gIFRoZQoJCWl0ZW1zIGFyZToKCQkgICAiaWQiCQkgIG51bWJlciBvZiB0aGUgY2hhbm5lbAoJCSAgICJzdGF0dXMiCSAgIm9wZW4iIChhbnkgcGFydCBpcyBvcGVuKSBvciAiY2xvc2VkIgoJCVdoZW4gb3BlbmVkIHdpdGggY2hfb3BlbigpOgoJCSAgICJob3N0bmFtZSIJICB0aGUgaG9zdG5hbWUgb2YgdGhlIGFkZHJlc3MKCQkgICAicG9ydCIJICB0aGUgcG9ydCBvZiB0aGUgYWRkcmVzcwoJCSAgICJzb2NrX3N0YXR1cyIgICJvcGVuIiBvciAiY2xvc2VkIgoJCSAgICJzb2NrX21vZGUiCSAgIk5MIiwgIlJBVyIsICJKU09OIiBvciAiSlMiCgkJICAgInNvY2tfaW8iCSAgInNvY2tldCIKCQkgICAic29ja190aW1lb3V0IiB0aW1lb3V0IGluIG1zZWMKCQlXaGVuIG9wZW5lZCB3aXRoIGpvYl9zdGFydCgpOgoJCSAgICJvdXRfc3RhdHVzIgkgICJvcGVuIiBvciAiY2xvc2VkIgoJCSAgICJvdXRfbW9kZSIJICAiTkwiLCAiUkFXIiwgIkpTT04iIG9yICJKUyIKCQkgICAib3V0X2lvIgkgICJudWxsIiwgInBpcGUiLCAiZmlsZSIgb3IgImJ1ZmZlciIKCQkgICAib3V0X3RpbWVvdXQiICB0aW1lb3V0IGluIG1zZWMKCQkgICAiZXJyX3N0YXR1cyIJICAib3BlbiIgb3IgImNsb3NlZCIKCQkgICAiZXJyX21vZGUiCSAgIk5MIiwgIlJBVyIsICJKU09OIiBvciAiSlMiCgkJICAgImVycl9pbyIJICAib3V0IiwgIm51bGwiLCAicGlwZSIsICJmaWxlIiBvciAiYnVmZmVyIgoJCSAgICJlcnJfdGltZW91dCIgIHRpbWVvdXQgaW4gbXNlYwoJCSAgICJpbl9zdGF0dXMiCSAgIm9wZW4iIG9yICJjbG9zZWQiCgkJICAgImluX21vZGUiCSAgIk5MIiwgIlJBVyIsICJKU09OIiBvciAiSlMiCgkJICAgImluX2lvIgkgICJudWxsIiwgInBpcGUiLCAiZmlsZSIgb3IgImJ1ZmZlciIKCQkgICAiaW5fdGltZW91dCIJICB0aW1lb3V0IGluIG1zZWMKCmNoX2xvZyh7bXNnfSBbLCB7aGFuZGxlfV0pCQkJCQkqY2hfbG9nKCkqCgkJV3JpdGUge21zZ30gaW4gdGhlIGNoYW5uZWwgbG9nIGZpbGUsIGlmIGl0IHdhcyBvcGVuZWQgd2l0aAoJCXxjaF9sb2dmaWxlKCl8LgoJCVdoZW4ge2hhbmRsZX0gaXMgcGFzc2VkIHRoZSBjaGFubmVsIG51bWJlciBpcyB1c2VkIGZvciB0aGUKCQltZXNzYWdlLgoJCXtoYW5kbGV9IGNhbiBiZSBDaGFubmVsIG9yIGEgSm9iIHRoYXQgaGFzIGEgQ2hhbm5lbC4gIFRoZQoJCUNoYW5uZWwgbXVzdCBvcGVuLgoKY2hfbG9nZmlsZSh7Zm5hbWV9IFssIHttb2RlfV0pCQkJCQkqY2hfbG9nZmlsZSgpKgoJCVN0YXJ0IGxvZ2dpbmcgY2hhbm5lbCBhY3Rpdml0eSB0byB7Zm5hbWV9LgoJCVdoZW4ge2ZuYW1lfSBpcyBhbiBlbXB0eSBzdHJpbmc6IHN0b3AgbG9nZ2luZy4KCgkJV2hlbiB7bW9kZX0gaXMgb21pdHRlZCBvciAiYSIgYXBwZW5kIHRvIHRoZSBmaWxlLgoJCVdoZW4ge21vZGV9IGlzICJ3IiBzdGFydCB3aXRoIGFuIGVtcHR5IGZpbGUuCgoJCVRoZSBmaWxlIGlzIGZsdXNoZWQgYWZ0ZXIgZXZlcnkgbWVzc2FnZSwgb24gVW5peCB5b3UgY2FuIHVzZQoJCSJ0YWlsIC1mIiB0byBzZWUgd2hhdCBpcyBnb2luZyBvbiBpbiByZWFsIHRpbWUuCgoKY2hfb3Blbih7YWRkcmVzc30gWywge29wdGlvbnN9XSkJCQkJKmNoX29wZW4oKSoKCQlPcGVuIGEgY2hhbm5lbCB0byB7YWRkcmVzc30uICBTZWUgfGNoYW5uZWx8LgoJCVJldHVybnMgYSBDaGFubmVsLiAgVXNlIHxjaF9zdGF0dXMoKXwgdG8gY2hlY2sgZm9yIGZhaWx1cmUuCgoJCXthZGRyZXNzfSBoYXMgdGhlIGZvcm0gImhvc3RuYW1lOnBvcnQiLCBlLmcuLAoJCSJsb2NhbGhvc3Q6ODc2NSIuCgoJCUlmIHtvcHRpb25zfSBpcyBnaXZlbiBpdCBtdXN0IGJlIGEgfERpY3Rpb25hcnl8LgoJCVNlZSB8Y2hhbm5lbC1vcGVuLW9wdGlvbnN8LgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NoYW5uZWx8IGZlYXR1cmV9CgpjaF9yZWFkKHtoYW5kbGV9IFssIHtvcHRpb25zfV0pCQkJCQkqY2hfcmVhZCgpKgoJCVJlYWQgZnJvbSB7aGFuZGxlfSBhbmQgcmV0dXJuIHRoZSByZWNlaXZlZCBtZXNzYWdlLgoJCXtoYW5kbGV9IGNhbiBiZSBDaGFubmVsIG9yIGEgSm9iIHRoYXQgaGFzIGEgQ2hhbm5lbC4KCQlTZWUgfGNoYW5uZWwtbW9yZXwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBmZWF0dXJlfQoKY2hfcmVhZHJhdyh7aGFuZGxlfSBbLCB7b3B0aW9uc31dKQkJCSpjaF9yZWFkcmF3KCkqCgkJTGlrZSBjaF9yZWFkKCkgYnV0IGZvciBhIEpTIGFuZCBKU09OIGNoYW5uZWwgZG9lcyBub3QgZGVjb2RlCgkJdGhlIG1lc3NhZ2UuICBTZWUgfGNoYW5uZWwtbW9yZXwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBmZWF0dXJlfQoKY2hfc2VuZGV4cHIoe2hhbmRsZX0sIHtleHByfSBbLCB7b3B0aW9uc31dKQkJCSpjaF9zZW5kZXhwcigpKgoJCVNlbmQge2V4cHJ9IG92ZXIge2hhbmRsZX0uICBUaGUge2V4cHJ9IGlzIGVuY29kZWQKCQlhY2NvcmRpbmcgdG8gdGhlIHR5cGUgb2YgY2hhbm5lbC4gIFRoZSBmdW5jdGlvbiBjYW5ub3QgYmUgdXNlZAoJCXdpdGggYSByYXcgY2hhbm5lbC4KCQlTZWUgfGNoYW5uZWwtdXNlfC4JCQkJKkU5MTIqCgkJe2hhbmRsZX0gY2FuIGJlIENoYW5uZWwgb3IgYSBKb2IgdGhhdCBoYXMgYSBDaGFubmVsLgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NoYW5uZWx8IGZlYXR1cmV9CgpjaF9zZW5kcmF3KHtoYW5kbGV9LCB7c3RyaW5nfSBbLCB7b3B0aW9uc31dKQkJKmNoX3NlbmRyYXcoKSoKCQlTZW5kIHtzdHJpbmd9IG92ZXIge2hhbmRsZX0uCgkJV29ya3MgbGlrZSB8Y2hfc2VuZGV4cHIoKXwsIGJ1dCBkb2VzIG5vdCBlbmNvZGUgdGhlIHJlcXVlc3Qgb3IKCQlkZWNvZGUgdGhlIHJlc3BvbnNlLiAgVGhlIGNhbGxlciBpcyByZXNwb25zaWJsZSBmb3IgdGhlCgkJY29ycmVjdCBjb250ZW50cy4gIEFsc28gZG9lcyBub3QgYWRkIGEgbmV3bGluZSBmb3IgYSBjaGFubmVsCgkJaW4gTkwgbW9kZSwgdGhlIGNhbGxlciBtdXN0IGRvIHRoYXQuICBUaGUgTkwgaW4gdGhlIHJlc3BvbnNlCgkJaXMgcmVtb3ZlZC4KCQlTZWUgfGNoYW5uZWwtdXNlfC4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjaGFubmVsfCBmZWF0dXJlfQoKY2hfc2V0b3B0aW9ucyh7aGFuZGxlfSwge29wdGlvbnN9KQkJCSpjaF9zZXRvcHRpb25zKCkqCgkJU2V0IG9wdGlvbnMgb24ge2hhbmRsZX06CgkJCSJjYWxsYmFjayIJdGhlIGNoYW5uZWwgY2FsbGJhY2sKCQkJInRpbWVvdXQiCWRlZmF1bHQgcmVhZCB0aW1lb3V0IGluIG1zZWMKCQkJIm1vZGUiCQltb2RlIGZvciB0aGUgd2hvbGUgY2hhbm5lbAoJCVNlZSB8Y2hfb3BlbigpfCBmb3IgbW9yZSBleHBsYW5hdGlvbi4KCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgoJCU5vdGUgdGhhdCBjaGFuZ2luZyB0aGUgbW9kZSBtYXkgY2F1c2UgcXVldWVkIG1lc3NhZ2VzIHRvIGJlCgkJbG9zdC4KCgkJVGhlc2Ugb3B0aW9ucyBjYW5ub3QgYmUgY2hhbmdlZDoKCQkJIndhaXR0aW1lIglvbmx5IGFwcGxpZXMgdG8gImNoX29wZW4oKXwKCmNoX3N0YXR1cyh7aGFuZGxlfSkJCQkJCQkqY2hfc3RhdHVzKCkqCgkJUmV0dXJuIHRoZSBzdGF0dXMgb2Yge2hhbmRsZX06CgkJCSJmYWlsIgkJZmFpbGVkIHRvIG9wZW4gdGhlIGNoYW5uZWwKCQkJIm9wZW4iCQljaGFubmVsIGNhbiBiZSB1c2VkCgkJCSJidWZmZXJlZCIJY2hhbm5lbCBjYW4gYmUgcmVhZCwgbm90IHdyaXR0ZW4gdG8KCQkJImNsb3NlZCIJY2hhbm5lbCBjYW4gbm90IGJlIHVzZWQKCQl7aGFuZGxlfSBjYW4gYmUgQ2hhbm5lbCBvciBhIEpvYiB0aGF0IGhhcyBhIENoYW5uZWwuCgkJImJ1ZmZlcmVkIiBpcyB1c2VkIHdoZW4gdGhlIGNoYW5uZWwgd2FzIGNsb3NlZCBidXQgdGhlcmUgaXMKCQlzdGlsbCBkYXRhIHRoYXQgY2FuIGJlIG9idGFpbmVkIHdpdGggfGNoX3JlYWQoKXwuCgoJCQkJCQkJKmNvcHkoKSoKY29weSh7ZXhwcn0pCU1ha2UgYSBjb3B5IG9mIHtleHByfS4JRm9yIE51bWJlcnMgYW5kIFN0cmluZ3MgdGhpcyBpc24ndAoJCWRpZmZlcmVudCBmcm9tIHVzaW5nIHtleHByfSBkaXJlY3RseS4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCBhIHNoYWxsb3cgY29weSBpcyBjcmVhdGVkLiAgVGhpcyBtZWFucwoJCXRoYXQgdGhlIG9yaWdpbmFsIHxMaXN0fCBjYW4gYmUgY2hhbmdlZCB3aXRob3V0IGNoYW5naW5nIHRoZQoJCWNvcHksIGFuZCB2aWNlIHZlcnNhLiAgQnV0IHRoZSBpdGVtcyBhcmUgaWRlbnRpY2FsLCB0aHVzCgkJY2hhbmdpbmcgYW4gaXRlbSBjaGFuZ2VzIHRoZSBjb250ZW50cyBvZiBib3RoIHxMaXN0c3wuCgkJQSB8RGljdGlvbmFyeXwgaXMgY29waWVkIGluIGEgc2ltaWxhciB3YXkgYXMgYSB8TGlzdHwuCgkJQWxzbyBzZWUgfGRlZXBjb3B5KCl8LgoKY29zKHtleHByfSkJCQkJCQkqY29zKCkqCgkJUmV0dXJuIHRoZSBjb3NpbmUgb2Yge2V4cHJ9LCBtZWFzdXJlZCBpbiByYWRpYW5zLCBhcyBhIHxGbG9hdHwuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gY29zKDEwMCkKPAkJCTAuODYyMzE5ID4KCQkJOmVjaG8gY29zKC00LjAxKQo8CQkJLTAuNjQ2MDQzCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpjb3NoKHtleHByfSkJCQkJCQkqY29zaCgpKgoJCVJldHVybiB0aGUgaHlwZXJib2xpYyBjb3NpbmUgb2Yge2V4cHJ9IGFzIGEgfEZsb2F0fCBpbiB0aGUgcmFuZ2UKCQlbMSwgaW5mXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBjb3NoKDAuNSkKPAkJCTEuMTI3NjI2ID4KCQkJOmVjaG8gY29zaCgtMC41KQo8CQkJLTEuMTI3NjI2CgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgkJCmNvdW50KHtjb21wfSwge2V4cHJ9IFssIHtpY30gWywge3N0YXJ0fV1dKQkJCSpjb3VudCgpKgoJCVJldHVybiB0aGUgbnVtYmVyIG9mIHRpbWVzIGFuIGl0ZW0gd2l0aCB2YWx1ZSB7ZXhwcn0gYXBwZWFycwoJCWluIHxMaXN0fCBvciB8RGljdGlvbmFyeXwge2NvbXB9LgoJCUlmIHtzdGFydH0gaXMgZ2l2ZW4gdGhlbiBzdGFydCB3aXRoIHRoZSBpdGVtIHdpdGggdGhpcyBpbmRleC4KCQl7c3RhcnR9IGNhbiBvbmx5IGJlIHVzZWQgd2l0aCBhIHxMaXN0fC4KCQlXaGVuIHtpY30gaXMgZ2l2ZW4gYW5kIGl0J3Mgbm9uLXplcm8gdGhlbiBjYXNlIGlzIGlnbm9yZWQuCgoKCQkJCQkJCSpjc2NvcGVfY29ubmVjdGlvbigpKgpjc2NvcGVfY29ubmVjdGlvbihbe251bX0gLCB7ZGJwYXRofSBbLCB7cHJlcGVuZH1dXSkKCQlDaGVja3MgZm9yIHRoZSBleGlzdGVuY2Ugb2YgYSB8Y3Njb3BlfCBjb25uZWN0aW9uLiAgSWYgbm8KCQlwYXJhbWV0ZXJzIGFyZSBzcGVjaWZpZWQsIHRoZW4gdGhlIGZ1bmN0aW9uIHJldHVybnM6CgkJCTAsIGlmIGNzY29wZSB3YXMgbm90IGF2YWlsYWJsZSAobm90IGNvbXBpbGVkIGluKSwgb3IKCQkJICAgaWYgdGhlcmUgYXJlIG5vIGNzY29wZSBjb25uZWN0aW9uczsKCQkJMSwgaWYgdGhlcmUgaXMgYXQgbGVhc3Qgb25lIGNzY29wZSBjb25uZWN0aW9uLgoKCQlJZiBwYXJhbWV0ZXJzIGFyZSBzcGVjaWZpZWQsIHRoZW4gdGhlIHZhbHVlIG9mIHtudW19CgkJZGV0ZXJtaW5lcyBob3cgZXhpc3RlbmNlIG9mIGEgY3Njb3BlIGNvbm5lY3Rpb24gaXMgY2hlY2tlZDoKCgkJe251bX0JRGVzY3JpcHRpb24gb2YgZXhpc3RlbmNlIGNoZWNrCgkJLS0tLS0JLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgkJMAlTYW1lIGFzIG5vIHBhcmFtZXRlcnMgKGUuZy4sICJjc2NvcGVfY29ubmVjdGlvbigpIikuCgkJMQlJZ25vcmUge3ByZXBlbmR9LCBhbmQgdXNlIHBhcnRpYWwgc3RyaW5nIG1hdGNoZXMgZm9yCgkJCXtkYnBhdGh9LgoJCTIJSWdub3JlIHtwcmVwZW5kfSwgYW5kIHVzZSBleGFjdCBzdHJpbmcgbWF0Y2hlcyBmb3IKCQkJe2RicGF0aH0uCgkJMwlVc2Uge3ByZXBlbmR9LCB1c2UgcGFydGlhbCBzdHJpbmcgbWF0Y2hlcyBmb3IgYm90aAoJCQl7ZGJwYXRofSBhbmQge3ByZXBlbmR9LgoJCTQJVXNlIHtwcmVwZW5kfSwgdXNlIGV4YWN0IHN0cmluZyBtYXRjaGVzIGZvciBib3RoCgkJCXtkYnBhdGh9IGFuZCB7cHJlcGVuZH0uCgoJCU5vdGU6IEFsbCBzdHJpbmcgY29tcGFyaXNvbnMgYXJlIGNhc2Ugc2Vuc2l0aXZlIQoKCQlFeGFtcGxlcy4gIFN1cHBvc2Ugd2UgaGFkIHRoZSBmb2xsb3dpbmcgKGZyb20gIjpjcyBzaG93Iik6ID4KCiAgIyBwaWQgICAgZGF0YWJhc2UgbmFtZQkJCXByZXBlbmQgcGF0aAogIDAgMjc2NjQgIGNzY29wZS5vdXQJCQkJL3Vzci9sb2NhbAo8CgkJSW52b2NhdGlvbgkJCQkJUmV0dXJuIFZhbCB+CgkJLS0tLS0tLS0tLQkJCQkJLS0tLS0tLS0tLSA+CgkJY3Njb3BlX2Nvbm5lY3Rpb24oKQkJCQkJMQoJCWNzY29wZV9jb25uZWN0aW9uKDEsICJvdXQiKQkJCQkxCgkJY3Njb3BlX2Nvbm5lY3Rpb24oMiwgIm91dCIpCQkJCTAKCQljc2NvcGVfY29ubmVjdGlvbigzLCAib3V0IikJCQkJMAoJCWNzY29wZV9jb25uZWN0aW9uKDMsICJvdXQiLCAibG9jYWwiKQkJCTEKCQljc2NvcGVfY29ubmVjdGlvbig0LCAib3V0IikJCQkJMAoJCWNzY29wZV9jb25uZWN0aW9uKDQsICJvdXQiLCAibG9jYWwiKQkJCTAKCQljc2NvcGVfY29ubmVjdGlvbig0LCAiY3Njb3BlLm91dCIsICIvdXNyL2xvY2FsIikJMQo8CmN1cnNvcih7bG51bX0sIHtjb2x9IFssIHtvZmZ9XSkJCQkJKmN1cnNvcigpKgpjdXJzb3Ioe2xpc3R9KQoJCVBvc2l0aW9ucyB0aGUgY3Vyc29yIGF0IHRoZSBjb2x1bW4gKGJ5dGUgY291bnQpIHtjb2x9IGluIHRoZQoJCWxpbmUge2xudW19LiAgVGhlIGZpcnN0IGNvbHVtbiBpcyBvbmUuCgoJCVdoZW4gdGhlcmUgaXMgb25lIGFyZ3VtZW50IHtsaXN0fSB0aGlzIGlzIHVzZWQgYXMgYSB8TGlzdHwKCQl3aXRoIHR3bywgdGhyZWUgb3IgZm91ciBpdGVtOgoJCQlbe2xudW19LCB7Y29sfV0KCQkJW3tsbnVtfSwge2NvbH0sIHtvZmZ9XQoJCQlbe2xudW19LCB7Y29sfSwge29mZn0sIHtjdXJzd2FudH1dCgkJVGhpcyBpcyBsaWtlIHRoZSByZXR1cm4gdmFsdWUgb2YgfGdldHBvcygpfCBvciB8Z2V0Y3VycG9zKCl8LAoJCWJ1dCB3aXRob3V0IHRoZSBmaXJzdCBpdGVtLgoKCQlEb2VzIG5vdCBjaGFuZ2UgdGhlIGp1bXBsaXN0LgoJCUlmIHtsbnVtfSBpcyBncmVhdGVyIHRoYW4gdGhlIG51bWJlciBvZiBsaW5lcyBpbiB0aGUgYnVmZmVyLAoJCXRoZSBjdXJzb3Igd2lsbCBiZSBwb3NpdGlvbmVkIGF0IHRoZSBsYXN0IGxpbmUgaW4gdGhlIGJ1ZmZlci4KCQlJZiB7bG51bX0gaXMgemVybywgdGhlIGN1cnNvciB3aWxsIHN0YXkgaW4gdGhlIGN1cnJlbnQgbGluZS4KCQlJZiB7Y29sfSBpcyBncmVhdGVyIHRoYW4gdGhlIG51bWJlciBvZiBieXRlcyBpbiB0aGUgbGluZSwKCQl0aGUgY3Vyc29yIHdpbGwgYmUgcG9zaXRpb25lZCBhdCB0aGUgbGFzdCBjaGFyYWN0ZXIgaW4gdGhlCgkJbGluZS4KCQlJZiB7Y29sfSBpcyB6ZXJvLCB0aGUgY3Vyc29yIHdpbGwgc3RheSBpbiB0aGUgY3VycmVudCBjb2x1bW4uCgkJSWYge2N1cnN3YW50fSBpcyBnaXZlbiBpdCBpcyB1c2VkIHRvIHNldCB0aGUgcHJlZmVycmVkIGNvbHVtbgoJCWZvciB2ZXJ0aWNhbCBtb3ZlbWVudC4gIE90aGVyd2lzZSB7Y29sfSBpcyB1c2VkLgoKCQlXaGVuICd2aXJ0dWFsZWRpdCcgaXMgdXNlZCB7b2ZmfSBzcGVjaWZpZXMgdGhlIG9mZnNldCBpbgoJCXNjcmVlbiBjb2x1bW5zIGZyb20gdGhlIHN0YXJ0IG9mIHRoZSBjaGFyYWN0ZXIuICBFLmcuLCBhCgkJcG9zaXRpb24gd2l0aGluIGEgPFRhYj4gb3IgYWZ0ZXIgdGhlIGxhc3QgY2hhcmFjdGVyLgoJCVJldHVybnMgMCB3aGVuIHRoZSBwb3NpdGlvbiBjb3VsZCBiZSBzZXQsIC0xIG90aGVyd2lzZS4KCgpkZWVwY29weSh7ZXhwcn1bLCB7bm9yZWZ9XSkJCQkJKmRlZXBjb3B5KCkqICpFNjk4KgoJCU1ha2UgYSBjb3B5IG9mIHtleHByfS4JRm9yIE51bWJlcnMgYW5kIFN0cmluZ3MgdGhpcyBpc24ndAoJCWRpZmZlcmVudCBmcm9tIHVzaW5nIHtleHByfSBkaXJlY3RseS4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCBhIGZ1bGwgY29weSBpcyBjcmVhdGVkLiAgVGhpcyBtZWFucwoJCXRoYXQgdGhlIG9yaWdpbmFsIHxMaXN0fCBjYW4gYmUgY2hhbmdlZCB3aXRob3V0IGNoYW5naW5nIHRoZQoJCWNvcHksIGFuZCB2aWNlIHZlcnNhLiAgV2hlbiBhbiBpdGVtIGlzIGEgfExpc3R8IG9yCgkJfERpY3Rpb25hcnl8LCBhIGNvcHkgZm9yIGl0IGlzIG1hZGUsIHJlY3Vyc2l2ZWx5LiAgVGh1cwoJCWNoYW5naW5nIGFuIGl0ZW0gaW4gdGhlIGNvcHkgZG9lcyBub3QgY2hhbmdlIHRoZSBjb250ZW50cyBvZgoJCXRoZSBvcmlnaW5hbCB8TGlzdHwuCgkJQSB8RGljdGlvbmFyeXwgaXMgY29waWVkIGluIGEgc2ltaWxhciB3YXkgYXMgYSB8TGlzdHwuCgkJV2hlbiB7bm9yZWZ9IGlzIG9taXR0ZWQgb3IgemVybyBhIGNvbnRhaW5lZCB8TGlzdHwgb3IKCQl8RGljdGlvbmFyeXwgaXMgb25seSBjb3BpZWQgb25jZS4gIEFsbCByZWZlcmVuY2VzIHBvaW50IHRvCgkJdGhpcyBzaW5nbGUgY29weS4gIFdpdGgge25vcmVmfSBzZXQgdG8gMSBldmVyeSBvY2N1cnJlbmNlIG9mIGEKCQl8TGlzdHwgb3IgfERpY3Rpb25hcnl8IHJlc3VsdHMgaW4gYSBuZXcgY29weS4gIFRoaXMgYWxzbyBtZWFucwoJCXRoYXQgYSBjeWNsaWMgcmVmZXJlbmNlIGNhdXNlcyBkZWVwY29weSgpIHRvIGZhaWwuCgkJCQkJCQkJKkU3MjQqCgkJTmVzdGluZyBpcyBwb3NzaWJsZSB1cCB0byAxMDAgbGV2ZWxzLiAgV2hlbiB0aGVyZSBpcyBhbiBpdGVtCgkJdGhhdCByZWZlcnMgYmFjayB0byBhIGhpZ2hlciBsZXZlbCBtYWtpbmcgYSBkZWVwIGNvcHkgd2l0aAoJCXtub3JlZn0gc2V0IHRvIDEgd2lsbCBmYWlsLgoJCUFsc28gc2VlIHxjb3B5KCl8LgoKZGVsZXRlKHtmbmFtZX0gWywge2ZsYWdzfV0pCQkJCQkqZGVsZXRlKCkqCgkJV2l0aG91dCB7ZmxhZ3N9IG9yIHdpdGgge2ZsYWdzfSBlbXB0eTogRGVsZXRlcyB0aGUgZmlsZSBieSB0aGUKCQluYW1lIHtmbmFtZX0uICBUaGlzIGFsc28gd29ya3Mgd2hlbiB7Zm5hbWV9IGlzIGEgc3ltYm9saWMgbGluay4KCgkJV2hlbiB7ZmxhZ3N9IGlzICJkIjogRGVsZXRlcyB0aGUgZGlyZWN0b3J5IGJ5IHRoZSBuYW1lCgkJe2ZuYW1lfS4gIFRoaXMgZmFpbHMgd2hlbiBkaXJlY3Rvcnkge2ZuYW1lfSBpcyBub3QgZW1wdHkuCgkJCgkJV2hlbiB7ZmxhZ3N9IGlzICJyZiI6IERlbGV0ZXMgdGhlIGRpcmVjdG9yeSBieSB0aGUgbmFtZQoJCXtmbmFtZX0gYW5kIGV2ZXJ5dGhpbmcgaW4gaXQsIHJlY3Vyc2l2ZWx5LiAgQkUgQ0FSRUZVTCEKCQlBIHN5bWJvbGljIGxpbmsgaXRzZWxmIGlzIGRlbGV0ZWQsIG5vdCB3aGF0IGl0IHBvaW50cyB0by4KCQkKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyAwIGlmIHRoZSBkZWxldGUgb3BlcmF0aW9uIHdhcwoJCXN1Y2Nlc3NmdWwgYW5kIC0xIHdoZW4gdGhlIGRlbGV0aW9uIGZhaWxlZCBvciBwYXJ0bHkgZmFpbGVkLgoKCQlVc2UgfHJlbW92ZSgpfCB0byBkZWxldGUgYW4gaXRlbSBmcm9tIGEgfExpc3R8LgoJCVRvIGRlbGV0ZSBhIGxpbmUgZnJvbSB0aGUgYnVmZmVyIHVzZSB8OmRlbGV0ZXwuICBVc2UgfDpleGV8CgkJd2hlbiB0aGUgbGluZSBudW1iZXIgaXMgaW4gYSB2YXJpYWJsZS4KCgkJCQkJCQkqZGlkX2ZpbGV0eXBlKCkqCmRpZF9maWxldHlwZSgpCVJldHVybnMgbm9uLXplcm8gd2hlbiBhdXRvY29tbWFuZHMgYXJlIGJlaW5nIGV4ZWN1dGVkIGFuZCB0aGUKCQlGaWxlVHlwZSBldmVudCBoYXMgYmVlbiB0cmlnZ2VyZWQgYXQgbGVhc3Qgb25jZS4gIENhbiBiZSB1c2VkCgkJdG8gYXZvaWQgdHJpZ2dlcmluZyB0aGUgRmlsZVR5cGUgZXZlbnQgYWdhaW4gaW4gdGhlIHNjcmlwdHMKCQl0aGF0IGRldGVjdCB0aGUgZmlsZSB0eXBlLiB8RmlsZVR5cGV8CgkJV2hlbiBlZGl0aW5nIGFub3RoZXIgZmlsZSwgdGhlIGNvdW50ZXIgaXMgcmVzZXQsIHRodXMgdGhpcwoJCXJlYWxseSBjaGVja3MgaWYgdGhlIEZpbGVUeXBlIGV2ZW50IGhhcyBiZWVuIHRyaWdnZXJlZCBmb3IgdGhlCgkJY3VycmVudCBidWZmZXIuICBUaGlzIGFsbG93cyBhbiBhdXRvY29tbWFuZCB0aGF0IHN0YXJ0cwoJCWVkaXRpbmcgYW5vdGhlciBidWZmZXIgdG8gc2V0ICdmaWxldHlwZScgYW5kIGxvYWQgYSBzeW50YXgKCQlmaWxlLgoKZGlmZl9maWxsZXIoe2xudW19KQkJCQkJKmRpZmZfZmlsbGVyKCkqCgkJUmV0dXJucyB0aGUgbnVtYmVyIG9mIGZpbGxlciBsaW5lcyBhYm92ZSBsaW5lIHtsbnVtfS4KCQlUaGVzZSBhcmUgdGhlIGxpbmVzIHRoYXQgd2VyZSBpbnNlcnRlZCBhdCB0aGlzIHBvaW50IGluCgkJYW5vdGhlciBkaWZmJ2VkIHdpbmRvdy4gIFRoZXNlIGZpbGxlciBsaW5lcyBhcmUgc2hvd24gaW4gdGhlCgkJZGlzcGxheSBidXQgZG9uJ3QgZXhpc3QgaW4gdGhlIGJ1ZmZlci4KCQl7bG51bX0gaXMgdXNlZCBsaWtlIHdpdGggfGdldGxpbmUoKXwuICBUaHVzICIuIiBpcyB0aGUgY3VycmVudAoJCWxpbmUsICInbSIgbWFyayBtLCBldGMuCgkJUmV0dXJucyAwIGlmIHRoZSBjdXJyZW50IHdpbmRvdyBpcyBub3QgaW4gZGlmZiBtb2RlLgoKZGlmZl9obElEKHtsbnVtfSwge2NvbH0pCQkJCSpkaWZmX2hsSUQoKSoKCQlSZXR1cm5zIHRoZSBoaWdobGlnaHQgSUQgZm9yIGRpZmYgbW9kZSBhdCBsaW5lIHtsbnVtfSBjb2x1bW4KCQl7Y29sfSAoYnl0ZSBpbmRleCkuICBXaGVuIHRoZSBjdXJyZW50IGxpbmUgZG9lcyBub3QgaGF2ZSBhCgkJZGlmZiBjaGFuZ2UgemVybyBpcyByZXR1cm5lZC4KCQl7bG51bX0gaXMgdXNlZCBsaWtlIHdpdGggfGdldGxpbmUoKXwuICBUaHVzICIuIiBpcyB0aGUgY3VycmVudAoJCWxpbmUsICInbSIgbWFyayBtLCBldGMuCgkJe2NvbH0gaXMgMSBmb3IgdGhlIGxlZnRtb3N0IGNvbHVtbiwge2xudW19IGlzIDEgZm9yIHRoZSBmaXJzdAoJCWxpbmUuCgkJVGhlIGhpZ2hsaWdodCBJRCBjYW4gYmUgdXNlZCB3aXRoIHxzeW5JRGF0dHIoKXwgdG8gb2J0YWluCgkJc3ludGF4IGluZm9ybWF0aW9uIGFib3V0IHRoZSBoaWdobGlnaHRpbmcuCgoJCQkJCSpkaXNhYmxlX2NoYXJfYXZhaWxfZm9yX3Rlc3RpbmcoKSoKZGlzYWJsZV9jaGFyX2F2YWlsX2Zvcl90ZXN0aW5nKHtleHByfSkKCQlXaGVuIHtleHByfSBpcyAxIHRoZSBpbnRlcm5hbCBjaGFyX2F2YWlsKCkgZnVuY3Rpb24gd2lsbAoJCXJldHVybiBGQUxTRS4gIFdoZW4ge2V4cHJ9IGlzIDAgdGhlIGNoYXJfYXZhaWwoKSBmdW5jdGlvbiB3aWxsCgkJZnVuY3Rpb24gbm9ybWFsbHkuCgkJT25seSB1c2UgdGhpcyBmb3IgYSB0ZXN0IHdoZXJlIHR5cGVhaGVhZCBjYXVzZXMgdGhlIHRlc3Qgbm90CgkJdG8gd29yay4gIEUuZy4sIHRvIHRyaWdnZXIgdGhlIEN1cnNvck1vdmVkSSBhdXRvY29tbWFuZCBldmVudC4KCmVtcHR5KHtleHByfSkJCQkJCQkqZW1wdHkoKSoKCQlSZXR1cm4gdGhlIE51bWJlciAxIGlmIHtleHByfSBpcyBlbXB0eSwgemVybyBvdGhlcndpc2UuCgkJLSBBIHxMaXN0fCBvciB8RGljdGlvbmFyeXwgaXMgZW1wdHkgd2hlbiBpdCBkb2VzIG5vdCBoYXZlIGFueQoJCSAgaXRlbXMuCgkJLSBBIE51bWJlciBhbmQgRmxvYXQgaXMgZW1wdHkgd2hlbiBpdHMgdmFsdWUgaXMgemVyby4KCQktIHx2OmZhbHNlfCwgfHY6bm9uZXwgYW5kIHx2Om51bGx8IGFyZSBlbXB0eSwgfHY6dHJ1ZXwgaXMgbm90LgoJCS0gQSBKb2IgaXMgZW1wdHkgd2hlbiBpdCBmYWlsZWQgdG8gc3RhcnQuCgkJLSBBIENoYW5uZWwgaXMgZW1wdHkgd2hlbiBpdCBpcyBjbG9zZWQuCgoJCUZvciBhIGxvbmcgfExpc3R8IHRoaXMgaXMgbXVjaCBmYXN0ZXIgdGhhbiBjb21wYXJpbmcgdGhlCgkJbGVuZ3RoIHdpdGggemVyby4KCmVzY2FwZSh7c3RyaW5nfSwge2NoYXJzfSkJCQkJKmVzY2FwZSgpKgoJCUVzY2FwZSB0aGUgY2hhcmFjdGVycyBpbiB7Y2hhcnN9IHRoYXQgb2NjdXIgaW4ge3N0cmluZ30gd2l0aCBhCgkJYmFja3NsYXNoLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBlc2NhcGUoJ2M6XHByb2dyYW0gZmlsZXNcdmltJywgJyBcJykKPAkJcmVzdWx0cyBpbjogPgoJCQljOlxccHJvZ3JhbVwgZmlsZXNcXHZpbQo8CQlBbHNvIHNlZSB8c2hlbGxlc2NhcGUoKXwuCgoJCQkJCQkJKmV2YWwoKSoKZXZhbCh7c3RyaW5nfSkJRXZhbHVhdGUge3N0cmluZ30gYW5kIHJldHVybiB0aGUgcmVzdWx0LiAgRXNwZWNpYWxseSB1c2VmdWwgdG8KCQl0dXJuIHRoZSByZXN1bHQgb2YgfHN0cmluZygpfCBiYWNrIGludG8gdGhlIG9yaWdpbmFsIHZhbHVlLgoJCVRoaXMgd29ya3MgZm9yIE51bWJlcnMsIEZsb2F0cywgU3RyaW5ncyBhbmQgY29tcG9zaXRlcyBvZgoJCXRoZW0uICBBbHNvIHdvcmtzIGZvciB8RnVuY3JlZnxzIHRoYXQgcmVmZXIgdG8gZXhpc3RpbmcKCQlmdW5jdGlvbnMuCgpldmVudGhhbmRsZXIoKQkJCQkJCSpldmVudGhhbmRsZXIoKSoKCQlSZXR1cm5zIDEgd2hlbiBpbnNpZGUgYW4gZXZlbnQgaGFuZGxlci4gIFRoYXQgaXMgdGhhdCBWaW0gZ290CgkJaW50ZXJydXB0ZWQgd2hpbGUgd2FpdGluZyBmb3IgdGhlIHVzZXIgdG8gdHlwZSBhIGNoYXJhY3RlciwKCQllLmcuLCB3aGVuIGRyb3BwaW5nIGEgZmlsZSBvbiBWaW0uICBUaGlzIG1lYW5zIGludGVyYWN0aXZlCgkJY29tbWFuZHMgY2Fubm90IGJlIHVzZWQuICBPdGhlcndpc2UgemVybyBpcyByZXR1cm5lZC4KCmV4ZWN1dGFibGUoe2V4cHJ9KQkJCQkJKmV4ZWN1dGFibGUoKSoKCQlUaGlzIGZ1bmN0aW9uIGNoZWNrcyBpZiBhbiBleGVjdXRhYmxlIHdpdGggdGhlIG5hbWUge2V4cHJ9CgkJZXhpc3RzLiAge2V4cHJ9IG11c3QgYmUgdGhlIG5hbWUgb2YgdGhlIHByb2dyYW0gd2l0aG91dCBhbnkKCQlhcmd1bWVudHMuCgkJZXhlY3V0YWJsZSgpIHVzZXMgdGhlIHZhbHVlIG9mICRQQVRIIGFuZC9vciB0aGUgbm9ybWFsCgkJc2VhcmNocGF0aCBmb3IgcHJvZ3JhbXMuCQkqUEFUSEVYVCoKCQlPbiBNUy1ET1MgYW5kIE1TLVdpbmRvd3MgdGhlICIuZXhlIiwgIi5iYXQiLCBldGMuIGNhbgoJCW9wdGlvbmFsbHkgYmUgaW5jbHVkZWQuICBUaGVuIHRoZSBleHRlbnNpb25zIGluICRQQVRIRVhUIGFyZQoJCXRyaWVkLglUaHVzIGlmICJmb28uZXhlIiBkb2VzIG5vdCBleGlzdCwgImZvby5leGUuYmF0IiBjYW4gYmUKCQlmb3VuZC4JSWYgJFBBVEhFWFQgaXMgbm90IHNldCB0aGVuICIuZXhlOy5jb207LmJhdDsuY21kIiBpcwoJCXVzZWQuICBBIGRvdCBieSBpdHNlbGYgY2FuIGJlIHVzZWQgaW4gJFBBVEhFWFQgdG8gdHJ5IHVzaW5nCgkJdGhlIG5hbWUgd2l0aG91dCBhbiBleHRlbnNpb24uCVdoZW4gJ3NoZWxsJyBsb29rcyBsaWtlIGEKCQlVbml4IHNoZWxsLCB0aGVuIHRoZSBuYW1lIGlzIGFsc28gdHJpZWQgd2l0aG91dCBhZGRpbmcgYW4KCQlleHRlbnNpb24uCgkJT24gTVMtRE9TIGFuZCBNUy1XaW5kb3dzIGl0IG9ubHkgY2hlY2tzIGlmIHRoZSBmaWxlIGV4aXN0cyBhbmQKCQlpcyBub3QgYSBkaXJlY3RvcnksIG5vdCBpZiBpdCdzIHJlYWxseSBleGVjdXRhYmxlLgoJCU9uIE1TLVdpbmRvd3MgYW4gZXhlY3V0YWJsZSBpbiB0aGUgc2FtZSBkaXJlY3RvcnkgYXMgVmltIGlzCgkJYWx3YXlzIGZvdW5kLiAgU2luY2UgdGhpcyBkaXJlY3RvcnkgaXMgYWRkZWQgdG8gJFBBVEggaXQKCQlzaG91bGQgYWxzbyB3b3JrIHRvIGV4ZWN1dGUgaXQgfHdpbjMyLVBBVEh8LgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXI6CgkJCTEJZXhpc3RzCgkJCTAJZG9lcyBub3QgZXhpc3QKCQkJLTEJbm90IGltcGxlbWVudGVkIG9uIHRoaXMgc3lzdGVtCgpleGVwYXRoKHtleHByfSkJCQkJCQkqZXhlcGF0aCgpKgoJCUlmIHtleHByfSBpcyBhbiBleGVjdXRhYmxlIGFuZCBpcyBlaXRoZXIgYW4gYWJzb2x1dGUgcGF0aCwgYQoJCXJlbGF0aXZlIHBhdGggb3IgZm91bmQgaW4gJFBBVEgsIHJldHVybiB0aGUgZnVsbCBwYXRoLgoJCU5vdGUgdGhhdCB0aGUgY3VycmVudCBkaXJlY3RvcnkgaXMgdXNlZCB3aGVuIHtleHByfSBzdGFydHMKCQl3aXRoICIuLyIsIHdoaWNoIG1heSBiZSBhIHByb2JsZW0gZm9yIFZpbTogPgoJCQllY2hvIGV4ZXBhdGgodjpwcm9ncGF0aCkKPAkJSWYge2V4cHJ9IGNhbm5vdCBiZSBmb3VuZCBpbiAkUEFUSCBvciBpcyBub3QgZXhlY3V0YWJsZSB0aGVuCgkJYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoKCQkJCQkJCSpleGlzdHMoKSoKZXhpc3RzKHtleHByfSkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgbm9uLXplcm8gaWYge2V4cHJ9IGlzCgkJZGVmaW5lZCwgemVybyBvdGhlcndpc2UuICBUaGUge2V4cHJ9IGFyZ3VtZW50IGlzIGEgc3RyaW5nLAoJCXdoaWNoIGNvbnRhaW5zIG9uZSBvZiB0aGVzZToKCQkJJm9wdGlvbi1uYW1lCVZpbSBvcHRpb24gKG9ubHkgY2hlY2tzIGlmIGl0IGV4aXN0cywKCQkJCQlub3QgaWYgaXQgcmVhbGx5IHdvcmtzKQoJCQkrb3B0aW9uLW5hbWUJVmltIG9wdGlvbiB0aGF0IHdvcmtzLgoJCQkkRU5WTkFNRQllbnZpcm9ubWVudCB2YXJpYWJsZSAoY291bGQgYWxzbyBiZQoJCQkJCWRvbmUgYnkgY29tcGFyaW5nIHdpdGggYW4gZW1wdHkKCQkJCQlzdHJpbmcpCgkJCSpmdW5jbmFtZQlidWlsdC1pbiBmdW5jdGlvbiAoc2VlIHxmdW5jdGlvbnN8KQoJCQkJCW9yIHVzZXIgZGVmaW5lZCBmdW5jdGlvbiAoc2VlCgkJCQkJfHVzZXItZnVuY3Rpb25zfCkuIEFsc28gd29ya3MgZm9yIGEKCQkJCQl2YXJpYWJsZSB0aGF0IGlzIGEgRnVuY3JlZi4KCQkJdmFybmFtZQkJaW50ZXJuYWwgdmFyaWFibGUgKHNlZQoJCQkJCXxpbnRlcm5hbC12YXJpYWJsZXN8KS4JQWxzbyB3b3JrcwoJCQkJCWZvciB8Y3VybHktYnJhY2VzLW5hbWVzfCwgfERpY3Rpb25hcnl8CgkJCQkJZW50cmllcywgfExpc3R8IGl0ZW1zLCBldGMuICBCZXdhcmUKCQkJCQl0aGF0IGV2YWx1YXRpbmcgYW4gaW5kZXggbWF5IGNhdXNlIGFuCgkJCQkJZXJyb3IgbWVzc2FnZSBmb3IgYW4gaW52YWxpZAoJCQkJCWV4cHJlc3Npb24uICBFLmcuOiA+CgkJCQkJICAgOmxldCBsID0gWzEsIDIsIDNdCgkJCQkJICAgOmVjaG8gZXhpc3RzKCJsWzVdIikKPAkJCQkJICAgMCA+CgkJCQkJICAgOmVjaG8gZXhpc3RzKCJsW3h4XSIpCjwJCQkJCSAgIEUxMjE6IFVuZGVmaW5lZCB2YXJpYWJsZTogeHgKCQkJCQkgICAwCgkJCTpjbWRuYW1lCUV4IGNvbW1hbmQ6IGJ1aWx0LWluIGNvbW1hbmQsIHVzZXIKCQkJCQljb21tYW5kIG9yIGNvbW1hbmQgbW9kaWZpZXIgfDpjb21tYW5kfC4KCQkJCQlSZXR1cm5zOgoJCQkJCTEgIGZvciBtYXRjaCB3aXRoIHN0YXJ0IG9mIGEgY29tbWFuZAoJCQkJCTIgIGZ1bGwgbWF0Y2ggd2l0aCBhIGNvbW1hbmQKCQkJCQkzICBtYXRjaGVzIHNldmVyYWwgdXNlciBjb21tYW5kcwoJCQkJCVRvIGNoZWNrIGZvciBhIHN1cHBvcnRlZCBjb21tYW5kCgkJCQkJYWx3YXlzIGNoZWNrIHRoZSByZXR1cm4gdmFsdWUgdG8gYmUgMi4KCQkJOjJtYXRjaAkJVGhlIHw6Mm1hdGNofCBjb21tYW5kLgoJCQk6M21hdGNoCQlUaGUgfDozbWF0Y2h8IGNvbW1hbmQuCgkJCSNldmVudAkJYXV0b2NvbW1hbmQgZGVmaW5lZCBmb3IgdGhpcyBldmVudAoJCQkjZXZlbnQjcGF0dGVybglhdXRvY29tbWFuZCBkZWZpbmVkIGZvciB0aGlzIGV2ZW50IGFuZAoJCQkJCXBhdHRlcm4gKHRoZSBwYXR0ZXJuIGlzIHRha2VuCgkJCQkJbGl0ZXJhbGx5IGFuZCBjb21wYXJlZCB0byB0aGUKCQkJCQlhdXRvY29tbWFuZCBwYXR0ZXJucyBjaGFyYWN0ZXIgYnkKCQkJCQljaGFyYWN0ZXIpCgkJCSNncm91cAkJYXV0b2NvbW1hbmQgZ3JvdXAgZXhpc3RzCgkJCSNncm91cCNldmVudAlhdXRvY29tbWFuZCBkZWZpbmVkIGZvciB0aGlzIGdyb3VwIGFuZAoJCQkJCWV2ZW50LgoJCQkjZ3JvdXAjZXZlbnQjcGF0dGVybgoJCQkJCWF1dG9jb21tYW5kIGRlZmluZWQgZm9yIHRoaXMgZ3JvdXAsCgkJCQkJZXZlbnQgYW5kIHBhdHRlcm4uCgkJCSMjZXZlbnQJCWF1dG9jb21tYW5kIGZvciB0aGlzIGV2ZW50IGlzCgkJCQkJc3VwcG9ydGVkLgoJCUZvciBjaGVja2luZyBmb3IgYSBzdXBwb3J0ZWQgZmVhdHVyZSB1c2UgfGhhcygpfC4KCgkJRXhhbXBsZXM6ID4KCQkJZXhpc3RzKCImc2hvcnRuYW1lIikKCQkJZXhpc3RzKCIkSE9TVE5BTUUiKQoJCQlleGlzdHMoIipzdHJmdGltZSIpCgkJCWV4aXN0cygiKnM6TXlGdW5jIikKCQkJZXhpc3RzKCJidWZjb3VudCIpCgkJCWV4aXN0cygiOk1ha2UiKQoJCQlleGlzdHMoIiNDdXJzb3JIb2xkIikKCQkJZXhpc3RzKCIjQnVmUmVhZFByZSMqLmd6IikKCQkJZXhpc3RzKCIjZmlsZXR5cGVpbmRlbnQiKQoJCQlleGlzdHMoIiNmaWxldHlwZWluZGVudCNGaWxlVHlwZSIpCgkJCWV4aXN0cygiI2ZpbGV0eXBlaW5kZW50I0ZpbGVUeXBlIyoiKQoJCQlleGlzdHMoIiMjQ29sb3JTY2hlbWUiKQo8CQlUaGVyZSBtdXN0IGJlIG5vIHNwYWNlIGJldHdlZW4gdGhlIHN5bWJvbCAoJi8kLyovIykgYW5kIHRoZQoJCW5hbWUuCgkJVGhlcmUgbXVzdCBiZSBubyBleHRyYSBjaGFyYWN0ZXJzIGFmdGVyIHRoZSBuYW1lLCBhbHRob3VnaCBpbgoJCWEgZmV3IGNhc2VzIHRoaXMgaXMgaWdub3JlZC4gIFRoYXQgbWF5IGJlY29tZSBtb3JlIHN0cmljdCBpbgoJCXRoZSBmdXR1cmUsIHRodXMgZG9uJ3QgY291bnQgb24gaXQhCgkJV29ya2luZyBleGFtcGxlOiA+CgkJCWV4aXN0cygiOm1ha2UiKQo8CQlOT1Qgd29ya2luZyBleGFtcGxlOiA+CgkJCWV4aXN0cygiOm1ha2UgaW5zdGFsbCIpCgo8CQlOb3RlIHRoYXQgdGhlIGFyZ3VtZW50IG11c3QgYmUgYSBzdHJpbmcsIG5vdCB0aGUgbmFtZSBvZiB0aGUKCQl2YXJpYWJsZSBpdHNlbGYuICBGb3IgZXhhbXBsZTogPgoJCQlleGlzdHMoYnVmY291bnQpCjwJCVRoaXMgZG9lc24ndCBjaGVjayBmb3IgZXhpc3RlbmNlIG9mIHRoZSAiYnVmY291bnQiIHZhcmlhYmxlLAoJCWJ1dCBnZXRzIHRoZSB2YWx1ZSBvZiAiYnVmY291bnQiLCBhbmQgY2hlY2tzIGlmIHRoYXQgZXhpc3RzLgoKZXhwKHtleHByfSkJCQkJCQkqZXhwKCkqCgkJUmV0dXJuIHRoZSBleHBvbmVudGlhbCBvZiB7ZXhwcn0gYXMgYSB8RmxvYXR8IGluIHRoZSByYW5nZQoJCVswLCBpbmZdLgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGV4cCgyKQo8CQkJNy4zODkwNTYgPgoJCQk6ZWNobyBleHAoLTEpCjwJCQkwLjM2Nzg3OQoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKZXhwYW5kKHtleHByfSBbLCB7bm9zdWZ9IFssIHtsaXN0fV1dKQkJCQkqZXhwYW5kKCkqCgkJRXhwYW5kIHdpbGRjYXJkcyBhbmQgdGhlIGZvbGxvd2luZyBzcGVjaWFsIGtleXdvcmRzIGluIHtleHByfS4KCQknd2lsZGlnbm9yZWNhc2UnIGFwcGxpZXMuCgoJCUlmIHtsaXN0fSBpcyBnaXZlbiBhbmQgaXQgaXMgbm9uLXplcm8sIGEgTGlzdCB3aWxsIGJlIHJldHVybmVkLgoJCU90aGVyd2lzZSB0aGUgcmVzdWx0IGlzIGEgU3RyaW5nIGFuZCB3aGVuIHRoZXJlIGFyZSBzZXZlcmFsCgkJbWF0Y2hlcywgdGhleSBhcmUgc2VwYXJhdGVkIGJ5IDxOTD4gY2hhcmFjdGVycy4gIFtOb3RlOiBpbgoJCXZlcnNpb24gNS4wIGEgc3BhY2Ugd2FzIHVzZWQsIHdoaWNoIGNhdXNlZCBwcm9ibGVtcyB3aGVuIGEKCQlmaWxlIG5hbWUgY29udGFpbnMgYSBzcGFjZV0KCgkJSWYgdGhlIGV4cGFuc2lvbiBmYWlscywgdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBzdHJpbmcuCUEgbmFtZQoJCWZvciBhIG5vbi1leGlzdGluZyBmaWxlIGlzIG5vdCBpbmNsdWRlZCwgdW5sZXNzIHtleHByfSBkb2VzCgkJbm90IHN0YXJ0IHdpdGggJyUnLCAnIycgb3IgJzwnLCBzZWUgYmVsb3cuCgoJCVdoZW4ge2V4cHJ9IHN0YXJ0cyB3aXRoICclJywgJyMnIG9yICc8JywgdGhlIGV4cGFuc2lvbiBpcyBkb25lCgkJbGlrZSBmb3IgdGhlIHxjbWRsaW5lLXNwZWNpYWx8IHZhcmlhYmxlcyB3aXRoIHRoZWlyIGFzc29jaWF0ZWQKCQltb2RpZmllcnMuICBIZXJlIGlzIGEgc2hvcnQgb3ZlcnZpZXc6CgoJCQklCQljdXJyZW50IGZpbGUgbmFtZQoJCQkjCQlhbHRlcm5hdGUgZmlsZSBuYW1lCgkJCSNuCQlhbHRlcm5hdGUgZmlsZSBuYW1lIG4KCQkJPGNmaWxlPgkJZmlsZSBuYW1lIHVuZGVyIHRoZSBjdXJzb3IKCQkJPGFmaWxlPgkJYXV0b2NtZCBmaWxlIG5hbWUKCQkJPGFidWY+CQlhdXRvY21kIGJ1ZmZlciBudW1iZXIgKGFzIGEgU3RyaW5nISkKCQkJPGFtYXRjaD4JYXV0b2NtZCBtYXRjaGVkIG5hbWUKCQkJPHNmaWxlPgkJc291cmNlZCBzY3JpcHQgZmlsZSBvciBmdW5jdGlvbiBuYW1lCgkJCTxzbG51bT4JCXNvdXJjZWQgc2NyaXB0IGZpbGUgbGluZSBudW1iZXIKCQkJPGN3b3JkPgkJd29yZCB1bmRlciB0aGUgY3Vyc29yCgkJCTxjV09SRD4JCVdPUkQgdW5kZXIgdGhlIGN1cnNvcgoJCQk8Y2xpZW50Pgl0aGUge2NsaWVudGlkfSBvZiB0aGUgbGFzdCByZWNlaXZlZAoJCQkJCW1lc3NhZ2UgfHNlcnZlcjJjbGllbnQoKXwKCQlNb2RpZmllcnM6CgkJCTpwCQlleHBhbmQgdG8gZnVsbCBwYXRoCgkJCTpoCQloZWFkIChsYXN0IHBhdGggY29tcG9uZW50IHJlbW92ZWQpCgkJCTp0CQl0YWlsIChsYXN0IHBhdGggY29tcG9uZW50IG9ubHkpCgkJCTpyCQlyb290IChvbmUgZXh0ZW5zaW9uIHJlbW92ZWQpCgkJCTplCQlleHRlbnNpb24gb25seQoKCQlFeGFtcGxlOiA+CgkJCTpsZXQgJnRhZ3MgPSBleHBhbmQoIiU6cDpoIikgLiAiL3RhZ3MiCjwJCU5vdGUgdGhhdCB3aGVuIGV4cGFuZGluZyBhIHN0cmluZyB0aGF0IHN0YXJ0cyB3aXRoICclJywgJyMnIG9yCgkJJzwnLCBhbnkgZm9sbG93aW5nIHRleHQgaXMgaWdub3JlZC4gIFRoaXMgZG9lcyBOT1Qgd29yazogPgoJCQk6bGV0IGRvZXNudHdvcmsgPSBleHBhbmQoIiU6aC5iYWsiKQo8CQlVc2UgdGhpczogPgoJCQk6bGV0IGRvZXN3b3JrID0gZXhwYW5kKCIlOmgiKSAuICIuYmFrIgo8CQlBbHNvIG5vdGUgdGhhdCBleHBhbmRpbmcgIjxjZmlsZT4iIGFuZCBvdGhlcnMgb25seSByZXR1cm5zIHRoZQoJCXJlZmVyZW5jZWQgZmlsZSBuYW1lIHdpdGhvdXQgZnVydGhlciBleHBhbnNpb24uICBJZiAiPGNmaWxlPiIKCQlpcyAifi8uY3NocmMiLCB5b3UgbmVlZCB0byBkbyBhbm90aGVyIGV4cGFuZCgpIHRvIGhhdmUgdGhlCgkJIn4vIiBleHBhbmRlZCBpbnRvIHRoZSBwYXRoIG9mIHRoZSBob21lIGRpcmVjdG9yeTogPgoJCQk6ZWNobyBleHBhbmQoZXhwYW5kKCI8Y2ZpbGU+IikpCjwKCQlUaGVyZSBjYW5ub3QgYmUgd2hpdGUgc3BhY2UgYmV0d2VlbiB0aGUgdmFyaWFibGVzIGFuZCB0aGUKCQlmb2xsb3dpbmcgbW9kaWZpZXIuICBUaGUgfGZuYW1lbW9kaWZ5KCl8IGZ1bmN0aW9uIGNhbiBiZSB1c2VkCgkJdG8gbW9kaWZ5IG5vcm1hbCBmaWxlIG5hbWVzLgoKCQlXaGVuIHVzaW5nICclJyBvciAnIycsIGFuZCB0aGUgY3VycmVudCBvciBhbHRlcm5hdGUgZmlsZSBuYW1lCgkJaXMgbm90IGRlZmluZWQsIGFuIGVtcHR5IHN0cmluZyBpcyB1c2VkLiAgVXNpbmcgIiU6cCIgaW4gYQoJCWJ1ZmZlciB3aXRoIG5vIG5hbWUsIHJlc3VsdHMgaW4gdGhlIGN1cnJlbnQgZGlyZWN0b3J5LCB3aXRoIGEKCQknLycgYWRkZWQuCgoJCVdoZW4ge2V4cHJ9IGRvZXMgbm90IHN0YXJ0IHdpdGggJyUnLCAnIycgb3IgJzwnLCBpdCBpcwoJCWV4cGFuZGVkIGxpa2UgYSBmaWxlIG5hbWUgaXMgZXhwYW5kZWQgb24gdGhlIGNvbW1hbmQgbGluZS4KCQknc3VmZml4ZXMnIGFuZCAnd2lsZGlnbm9yZScgYXJlIHVzZWQsIHVubGVzcyB0aGUgb3B0aW9uYWwKCQl7bm9zdWZ9IGFyZ3VtZW50IGlzIGdpdmVuIGFuZCBpdCBpcyBub24temVyby4KCQlOYW1lcyBmb3Igbm9uLWV4aXN0aW5nIGZpbGVzIGFyZSBpbmNsdWRlZC4gIFRoZSAiKioiIGl0ZW0gY2FuCgkJYmUgdXNlZCB0byBzZWFyY2ggaW4gYSBkaXJlY3RvcnkgdHJlZS4gIEZvciBleGFtcGxlLCB0byBmaW5kCgkJYWxsICJSRUFETUUiIGZpbGVzIGluIHRoZSBjdXJyZW50IGRpcmVjdG9yeSBhbmQgYmVsb3c6ID4KCQkJOmVjaG8gZXhwYW5kKCIqKi9SRUFETUUiKQo8CgkJRXhwYW5kKCkgY2FuIGFsc28gYmUgdXNlZCB0byBleHBhbmQgdmFyaWFibGVzIGFuZCBlbnZpcm9ubWVudAoJCXZhcmlhYmxlcyB0aGF0IGFyZSBvbmx5IGtub3duIGluIGEgc2hlbGwuICBCdXQgdGhpcyBjYW4gYmUKCQlzbG93LCBiZWNhdXNlIGEgc2hlbGwgbWF5IGJlIHVzZWQgdG8gZG8gdGhlIGV4cGFuc2lvbi4gIFNlZQoJCXxleHByLWVudi1leHBhbmR8LgoJCVRoZSBleHBhbmRlZCB2YXJpYWJsZSBpcyBzdGlsbCBoYW5kbGVkIGxpa2UgYSBsaXN0IG9mIGZpbGUKCQluYW1lcy4JV2hlbiBhbiBlbnZpcm9ubWVudCB2YXJpYWJsZSBjYW5ub3QgYmUgZXhwYW5kZWQsIGl0IGlzCgkJbGVmdCB1bmNoYW5nZWQuICBUaHVzICI6ZWNobyBleHBhbmQoJyRGT09CQVInKSIgcmVzdWx0cyBpbgoJCSIkRk9PQkFSIi4KCgkJU2VlIHxnbG9iKCl8IGZvciBmaW5kaW5nIGV4aXN0aW5nIGZpbGVzLiAgU2VlIHxzeXN0ZW0oKXwgZm9yCgkJZ2V0dGluZyB0aGUgcmF3IG91dHB1dCBvZiBhbiBleHRlcm5hbCBjb21tYW5kLgoKZXh0ZW5kKHtleHByMX0sIHtleHByMn0gWywge2V4cHIzfV0pCQkJKmV4dGVuZCgpKgoJCXtleHByMX0gYW5kIHtleHByMn0gbXVzdCBiZSBib3RoIHxMaXN0c3wgb3IgYm90aAoJCXxEaWN0aW9uYXJpZXN8LgoKCQlJZiB0aGV5IGFyZSB8TGlzdHN8OiBBcHBlbmQge2V4cHIyfSB0byB7ZXhwcjF9LgoJCUlmIHtleHByM30gaXMgZ2l2ZW4gaW5zZXJ0IHRoZSBpdGVtcyBvZiB7ZXhwcjJ9IGJlZm9yZSBpdGVtCgkJe2V4cHIzfSBpbiB7ZXhwcjF9LiAgV2hlbiB7ZXhwcjN9IGlzIHplcm8gaW5zZXJ0IGJlZm9yZSB0aGUKCQlmaXJzdCBpdGVtLiAgV2hlbiB7ZXhwcjN9IGlzIGVxdWFsIHRvIGxlbih7ZXhwcjF9KSB0aGVuCgkJe2V4cHIyfSBpcyBhcHBlbmRlZC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBzb3J0KGV4dGVuZChteWxpc3QsIFs3LCA1XSkpCgkJCTpjYWxsIGV4dGVuZChteWxpc3QsIFsyLCAzXSwgMSkKPAkJV2hlbiB7ZXhwcjF9IGlzIHRoZSBzYW1lIExpc3QgYXMge2V4cHIyfSB0aGVuIHRoZSBudW1iZXIgb2YKCQlpdGVtcyBjb3BpZWQgaXMgZXF1YWwgdG8gdGhlIG9yaWdpbmFsIGxlbmd0aCBvZiB0aGUgTGlzdC4KCQlFLmcuLCB3aGVuIHtleHByM30gaXMgMSB5b3UgZ2V0IE4gbmV3IGNvcGllcyBvZiB0aGUgZmlyc3QgaXRlbQoJCSh3aGVyZSBOIGlzIHRoZSBvcmlnaW5hbCBsZW5ndGggb2YgdGhlIExpc3QpLgoJCVVzZSB8YWRkKCl8IHRvIGNvbmNhdGVuYXRlIG9uZSBpdGVtIHRvIGEgbGlzdC4JVG8gY29uY2F0ZW5hdGUKCQl0d28gbGlzdHMgaW50byBhIG5ldyBsaXN0IHVzZSB0aGUgKyBvcGVyYXRvcjogPgoJCQk6bGV0IG5ld2xpc3QgPSBbMSwgMiwgM10gKyBbNCwgNV0KPAoJCUlmIHRoZXkgYXJlIHxEaWN0aW9uYXJpZXN8OgoJCUFkZCBhbGwgZW50cmllcyBmcm9tIHtleHByMn0gdG8ge2V4cHIxfS4KCQlJZiBhIGtleSBleGlzdHMgaW4gYm90aCB7ZXhwcjF9IGFuZCB7ZXhwcjJ9IHRoZW4ge2V4cHIzfSBpcwoJCXVzZWQgdG8gZGVjaWRlIHdoYXQgdG8gZG86CgkJe2V4cHIzfSA9ICJrZWVwIjoga2VlcCB0aGUgdmFsdWUgb2Yge2V4cHIxfQoJCXtleHByM30gPSAiZm9yY2UiOiB1c2UgdGhlIHZhbHVlIG9mIHtleHByMn0KCQl7ZXhwcjN9ID0gImVycm9yIjogZ2l2ZSBhbiBlcnJvciBtZXNzYWdlCQkqRTczNyoKCQlXaGVuIHtleHByM30gaXMgb21pdHRlZCB0aGVuICJmb3JjZSIgaXMgYXNzdW1lZC4KCgkJe2V4cHIxfSBpcyBjaGFuZ2VkIHdoZW4ge2V4cHIyfSBpcyBub3QgZW1wdHkuICBJZiBuZWNlc3NhcnkKCQltYWtlIGEgY29weSBvZiB7ZXhwcjF9IGZpcnN0LgoJCXtleHByMn0gcmVtYWlucyB1bmNoYW5nZWQuCgkJV2hlbiB7ZXhwcjF9IGlzIGxvY2tlZCBhbmQge2V4cHIyfSBpcyBub3QgZW1wdHkgdGhlIG9wZXJhdGlvbgoJCWZhaWxzLgoJCVJldHVybnMge2V4cHIxfS4KCgpmZWVka2V5cyh7c3RyaW5nfSBbLCB7bW9kZX1dKQkJCQkqZmVlZGtleXMoKSoKCQlDaGFyYWN0ZXJzIGluIHtzdHJpbmd9IGFyZSBxdWV1ZWQgZm9yIHByb2Nlc3NpbmcgYXMgaWYgdGhleQoJCWNvbWUgZnJvbSBhIG1hcHBpbmcgb3Igd2VyZSB0eXBlZCBieSB0aGUgdXNlci4KCQlCeSBkZWZhdWx0IHRoZSBzdHJpbmcgaXMgYWRkZWQgdG8gdGhlIGVuZCBvZiB0aGUgdHlwZWFoZWFkCgkJYnVmZmVyLCB0aHVzIGlmIGEgbWFwcGluZyBpcyBzdGlsbCBiZWluZyBleGVjdXRlZCB0aGUKCQljaGFyYWN0ZXJzIGNvbWUgYWZ0ZXIgdGhlbS4gIFVzZSB0aGUgJ2knIGZsYWcgdG8gaW5zZXJ0IGJlZm9yZQoJCW90aGVyIGNoYXJhY3RlcnMsIHRoZXkgd2lsbCBiZSBleGVjdXRlZCBuZXh0LCBiZWZvcmUgYW55CgkJY2hhcmFjdGVycyBmcm9tIGEgbWFwcGluZy4KCQlUaGUgZnVuY3Rpb24gZG9lcyBub3Qgd2FpdCBmb3IgcHJvY2Vzc2luZyBvZiBrZXlzIGNvbnRhaW5lZCBpbgoJCXtzdHJpbmd9LgoJCVRvIGluY2x1ZGUgc3BlY2lhbCBrZXlzIGludG8ge3N0cmluZ30sIHVzZSBkb3VibGUtcXVvdGVzCgkJYW5kICJcLi4uIiBub3RhdGlvbiB8ZXhwci1xdW90ZXwuIEZvciBleGFtcGxlLAoJCWZlZWRrZXlzKCJcPENSPiIpIHNpbXVsYXRlcyBwcmVzc2luZyBvZiB0aGUgPEVudGVyPiBrZXkuIEJ1dAoJCWZlZWRrZXlzKCdcPENSPicpIHB1c2hlcyA1IGNoYXJhY3RlcnMuCgkJSWYge21vZGV9IGlzIGFic2VudCwga2V5cyBhcmUgcmVtYXBwZWQuCgkJe21vZGV9IGlzIGEgU3RyaW5nLCB3aGljaCBjYW4gY29udGFpbiB0aGVzZSBjaGFyYWN0ZXIgZmxhZ3M6CgkJJ20nCVJlbWFwIGtleXMuIFRoaXMgaXMgZGVmYXVsdC4KCQknbicJRG8gbm90IHJlbWFwIGtleXMuCgkJJ3QnCUhhbmRsZSBrZXlzIGFzIGlmIHR5cGVkOyBvdGhlcndpc2UgdGhleSBhcmUgaGFuZGxlZCBhcwoJCQlpZiBjb21pbmcgZnJvbSBhIG1hcHBpbmcuICBUaGlzIG1hdHRlcnMgZm9yIHVuZG8sCgkJCW9wZW5pbmcgZm9sZHMsIGV0Yy4KCQknaScJSW5zZXJ0IHRoZSBzdHJpbmcgaW5zdGVhZCBvZiBhcHBlbmRpbmcgKHNlZSBhYm92ZSkuCgkJJ3gnCUV4ZWN1dGUgY29tbWFuZHMgdW50aWwgdHlwZWFoZWFkIGlzIGVtcHR5LiAgVGhpcyBpcwoJCQlzaW1pbGFyIHRvIHVzaW5nICI6bm9ybWFsISIuICBZb3UgY2FuIGNhbGwgZmVlZGtleXMoKQoJCQlzZXZlcmFsIHRpbWVzIHdpdGhvdXQgJ3gnIGFuZCB0aGVuIG9uZSB0aW1lIHdpdGggJ3gnCgkJCShwb3NzaWJseSB3aXRoIGFuIGVtcHR5IHtzdHJpbmd9KSB0byBleGVjdXRlIGFsbCB0aGUKCQkJdHlwZWFoZWFkLiAgTm90ZSB0aGF0IHdoZW4gVmltIGVuZHMgaW4gSW5zZXJ0IG1vZGUgaXQKCQkJd2lsbCBiZWhhdmUgYXMgaWYgPEVzYz4gaXMgdHlwZWQsIHRvIGF2b2lkIGdldHRpbmcKCQkJc3R1Y2ssIHdhaXRpbmcgZm9yIGEgY2hhcmFjdGVyIHRvIGJlIHR5cGVkIGJlZm9yZSB0aGUKCQkJc2NyaXB0IGNvbnRpbnVlcy4KCQknIScJV2hlbiB1c2VkIHdpdGggJ3gnIHdpbGwgbm90IGVuZCBJbnNlcnQgbW9kZS4gQ2FuIGJlCgkJCXVzZWQgaW4gYSB0ZXN0IHdoZW4gYSB0aW1lciBpcyBzZXQgdG8gZXhpdCBJbnNlcnQgbW9kZQoJCQlhIGxpdHRsZSBsYXRlci4gIFVzZWZ1bCBmb3IgdGVzdGluZyBDdXJzb3JIb2xkSS4KCgkJUmV0dXJuIHZhbHVlIGlzIGFsd2F5cyAwLgoKZmlsZXJlYWRhYmxlKHtmaWxlfSkJCQkJCSpmaWxlcmVhZGFibGUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBUUlVFIHdoZW4gYSBmaWxlIHdpdGggdGhlCgkJbmFtZSB7ZmlsZX0gZXhpc3RzLCBhbmQgY2FuIGJlIHJlYWQuICBJZiB7ZmlsZX0gZG9lc24ndCBleGlzdCwKCQlvciBpcyBhIGRpcmVjdG9yeSwgdGhlIHJlc3VsdCBpcyBGQUxTRS4gIHtmaWxlfSBpcyBhbnkKCQlleHByZXNzaW9uLCB3aGljaCBpcyB1c2VkIGFzIGEgU3RyaW5nLgoJCUlmIHlvdSBkb24ndCBjYXJlIGFib3V0IHRoZSBmaWxlIGJlaW5nIHJlYWRhYmxlIHlvdSBjYW4gdXNlCgkJfGdsb2IoKXwuCgkJCQkJCQkqZmlsZV9yZWFkYWJsZSgpKgoJCU9ic29sZXRlIG5hbWU6IGZpbGVfcmVhZGFibGUoKS4KCgpmaWxld3JpdGFibGUoe2ZpbGV9KQkJCQkJKmZpbGV3cml0YWJsZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIDEgd2hlbiBhIGZpbGUgd2l0aCB0aGUKCQluYW1lIHtmaWxlfSBleGlzdHMsIGFuZCBjYW4gYmUgd3JpdHRlbi4gIElmIHtmaWxlfSBkb2Vzbid0CgkJZXhpc3QsIG9yIGlzIG5vdCB3cml0YWJsZSwgdGhlIHJlc3VsdCBpcyAwLiAgSWYge2ZpbGV9IGlzIGEKCQlkaXJlY3RvcnksIGFuZCB3ZSBjYW4gd3JpdGUgdG8gaXQsIHRoZSByZXN1bHQgaXMgMi4KCgpmaWx0ZXIoe2V4cHJ9LCB7c3RyaW5nfSkJCQkJCSpmaWx0ZXIoKSoKCQl7ZXhwcn0gbXVzdCBiZSBhIHxMaXN0fCBvciBhIHxEaWN0aW9uYXJ5fC4KCQlGb3IgZWFjaCBpdGVtIGluIHtleHByfSBldmFsdWF0ZSB7c3RyaW5nfSBhbmQgd2hlbiB0aGUgcmVzdWx0CgkJaXMgemVybyByZW1vdmUgdGhlIGl0ZW0gZnJvbSB0aGUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fC4KCQlJbnNpZGUge3N0cmluZ30gfHY6dmFsfCBoYXMgdGhlIHZhbHVlIG9mIHRoZSBjdXJyZW50IGl0ZW0uCgkJRm9yIGEgfERpY3Rpb25hcnl8IHx2OmtleXwgaGFzIHRoZSBrZXkgb2YgdGhlIGN1cnJlbnQgaXRlbS4KCQlFeGFtcGxlczogPgoJCQk6Y2FsbCBmaWx0ZXIobXlsaXN0LCAndjp2YWwgIX4gIk9MRCInKQo8CQlSZW1vdmVzIHRoZSBpdGVtcyB3aGVyZSAiT0xEIiBhcHBlYXJzLiA+CgkJCTpjYWxsIGZpbHRlcihteWRpY3QsICd2OmtleSA+PSA4JykKPAkJUmVtb3ZlcyB0aGUgaXRlbXMgd2l0aCBhIGtleSBiZWxvdyA4LiA+CgkJCTpjYWxsIGZpbHRlcih2YXIsIDApCjwJCVJlbW92ZXMgYWxsIHRoZSBpdGVtcywgdGh1cyBjbGVhcnMgdGhlIHxMaXN0fCBvciB8RGljdGlvbmFyeXwuCgoJCU5vdGUgdGhhdCB7c3RyaW5nfSBpcyB0aGUgcmVzdWx0IG9mIGV4cHJlc3Npb24gYW5kIGlzIHRoZW4KCQl1c2VkIGFzIGFuIGV4cHJlc3Npb24gYWdhaW4uICBPZnRlbiBpdCBpcyBnb29kIHRvIHVzZSBhCgkJfGxpdGVyYWwtc3RyaW5nfCB0byBhdm9pZCBoYXZpbmcgdG8gZG91YmxlIGJhY2tzbGFzaGVzLgoKCQlUaGUgb3BlcmF0aW9uIGlzIGRvbmUgaW4tcGxhY2UuICBJZiB5b3Ugd2FudCBhIHxMaXN0fCBvcgoJCXxEaWN0aW9uYXJ5fCB0byByZW1haW4gdW5tb2RpZmllZCBtYWtlIGEgY29weSBmaXJzdDogPgoJCQk6bGV0IGwgPSBmaWx0ZXIoY29weShteWxpc3QpLCAndjp2YWwgPX4gIktFRVAiJykKCjwJCVJldHVybnMge2V4cHJ9LCB0aGUgfExpc3R8IG9yIHxEaWN0aW9uYXJ5fCB0aGF0IHdhcyBmaWx0ZXJlZC4KCQlXaGVuIGFuIGVycm9yIGlzIGVuY291bnRlcmVkIHdoaWxlIGV2YWx1YXRpbmcge3N0cmluZ30gbm8KCQlmdXJ0aGVyIGl0ZW1zIGluIHtleHByfSBhcmUgcHJvY2Vzc2VkLgoKCmZpbmRkaXIoe25hbWV9Wywge3BhdGh9Wywge2NvdW50fV1dKQkJCQkqZmluZGRpcigpKgoJCUZpbmQgZGlyZWN0b3J5IHtuYW1lfSBpbiB7cGF0aH0uICBTdXBwb3J0cyBib3RoIGRvd253YXJkcyBhbmQKCQl1cHdhcmRzIHJlY3Vyc2l2ZSBkaXJlY3Rvcnkgc2VhcmNoZXMuICBTZWUgfGZpbGUtc2VhcmNoaW5nfAoJCWZvciB0aGUgc3ludGF4IG9mIHtwYXRofS4KCQlSZXR1cm5zIHRoZSBwYXRoIG9mIHRoZSBmaXJzdCBmb3VuZCBtYXRjaC4gIFdoZW4gdGhlIGZvdW5kCgkJZGlyZWN0b3J5IGlzIGJlbG93IHRoZSBjdXJyZW50IGRpcmVjdG9yeSBhIHJlbGF0aXZlIHBhdGggaXMKCQlyZXR1cm5lZC4gIE90aGVyd2lzZSBhIGZ1bGwgcGF0aCBpcyByZXR1cm5lZC4KCQlJZiB7cGF0aH0gaXMgb21pdHRlZCBvciBlbXB0eSB0aGVuICdwYXRoJyBpcyB1c2VkLgoJCUlmIHRoZSBvcHRpb25hbCB7Y291bnR9IGlzIGdpdmVuLCBmaW5kIHtjb3VudH0ncyBvY2N1cnJlbmNlIG9mCgkJe25hbWV9IGluIHtwYXRofSBpbnN0ZWFkIG9mIHRoZSBmaXJzdCBvbmUuCgkJV2hlbiB7Y291bnR9IGlzIG5lZ2F0aXZlIHJldHVybiBhbGwgdGhlIG1hdGNoZXMgaW4gYSB8TGlzdHwuCgkJVGhpcyBpcyBxdWl0ZSBzaW1pbGFyIHRvIHRoZSBleC1jb21tYW5kIHw6ZmluZHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmaWxlX2luX3BhdGh8CgkJZmVhdHVyZX0KCmZpbmRmaWxlKHtuYW1lfVssIHtwYXRofVssIHtjb3VudH1dXSkJCQkJKmZpbmRmaWxlKCkqCgkJSnVzdCBsaWtlIHxmaW5kZGlyKCl8LCBidXQgZmluZCBhIGZpbGUgaW5zdGVhZCBvZiBhIGRpcmVjdG9yeS4KCQlVc2VzICdzdWZmaXhlc2FkZCcuCgkJRXhhbXBsZTogPgoJCQk6ZWNobyBmaW5kZmlsZSgidGFncy52aW0iLCAiLjsiKQo8CQlTZWFyY2hlcyBmcm9tIHRoZSBkaXJlY3Rvcnkgb2YgdGhlIGN1cnJlbnQgZmlsZSB1cHdhcmRzIHVudGlsCgkJaXQgZmluZHMgdGhlIGZpbGUgInRhZ3MudmltIi4KCmZsb2F0Mm5yKHtleHByfSkJCQkJCSpmbG9hdDJucigpKgoJCUNvbnZlcnQge2V4cHJ9IHRvIGEgTnVtYmVyIGJ5IG9taXR0aW5nIHRoZSBwYXJ0IGFmdGVyIHRoZQoJCWRlY2ltYWwgcG9pbnQuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgTnVtYmVyLgoJCVdoZW4gdGhlIHZhbHVlIG9mIHtleHByfSBpcyBvdXQgb2YgcmFuZ2UgZm9yIGEgfE51bWJlcnwgdGhlCgkJcmVzdWx0IGlzIHRydW5jYXRlZCB0byAweDdmZmZmZmZmIG9yIC0weDdmZmZmZmZmLiAgTmFOIHJlc3VsdHMKCQlpbiAtMHg4MDAwMDAwMC4KCQlFeGFtcGxlczogPgoJCQllY2hvIGZsb2F0Mm5yKDMuOTUpCjwJCQkzICA+CgkJCWVjaG8gZmxvYXQybnIoLTIzLjQ1KQo8CQkJLTIzICA+CgkJCWVjaG8gZmxvYXQybnIoMS4wZTEwMCkKPAkJCTIxNDc0ODM2NDcgID4KCQkJZWNobyBmbG9hdDJucigtMS4wZTE1MCkKPAkJCS0yMTQ3NDgzNjQ3ICA+CgkJCWVjaG8gZmxvYXQybnIoMS4wZS0xMDApCjwJCQkwCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgpmbG9vcih7ZXhwcn0pCQkJCQkJCSpmbG9vcigpKgoJCVJldHVybiB0aGUgbGFyZ2VzdCBpbnRlZ3JhbCB2YWx1ZSBsZXNzIHRoYW4gb3IgZXF1YWwgdG8KCQl7ZXhwcn0gYXMgYSB8RmxvYXR8IChyb3VuZCBkb3duKS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQllY2hvIGZsb29yKDEuODU2KQo8CQkJMS4wICA+CgkJCWVjaG8gZmxvb3IoLTUuNDU2KQo8CQkJLTYuMCAgPgoJCQllY2hvIGZsb29yKDQuMCkKPAkJCTQuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJCgpmbW9kKHtleHByMX0sIHtleHByMn0pCQkJCQkqZm1vZCgpKgoJCVJldHVybiB0aGUgcmVtYWluZGVyIG9mIHtleHByMX0gLyB7ZXhwcjJ9LCBldmVuIGlmIHRoZQoJCWRpdmlzaW9uIGlzIG5vdCByZXByZXNlbnRhYmxlLiAgUmV0dXJucyB7ZXhwcjF9IC0gaSAqIHtleHByMn0KCQlmb3Igc29tZSBpbnRlZ2VyIGkgc3VjaCB0aGF0IGlmIHtleHByMn0gaXMgbm9uLXplcm8sIHRoZQoJCXJlc3VsdCBoYXMgdGhlIHNhbWUgc2lnbiBhcyB7ZXhwcjF9IGFuZCBtYWduaXR1ZGUgbGVzcyB0aGFuCgkJdGhlIG1hZ25pdHVkZSBvZiB7ZXhwcjJ9LiAgSWYge2V4cHIyfSBpcyB6ZXJvLCB0aGUgdmFsdWUKCQlyZXR1cm5lZCBpcyB6ZXJvLiAgVGhlIHZhbHVlIHJldHVybmVkIGlzIGEgfEZsb2F0fC4KCQl7ZXhwcjF9IGFuZCB7ZXhwcjJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gZm1vZCgxMi4zMywgMS4yMikKPAkJCTAuMTMgPgoJCQk6ZWNobyBmbW9kKC0xMi4zMywgMS4yMikKPAkJCS0wLjEzCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB8K2Zsb2F0fCBmZWF0dXJlfQoKCmZuYW1lZXNjYXBlKHtzdHJpbmd9KQkJCQkJKmZuYW1lZXNjYXBlKCkqCgkJRXNjYXBlIHtzdHJpbmd9IGZvciB1c2UgYXMgZmlsZSBuYW1lIGNvbW1hbmQgYXJndW1lbnQuCUFsbAoJCWNoYXJhY3RlcnMgdGhhdCBoYXZlIGEgc3BlY2lhbCBtZWFuaW5nLCBzdWNoIGFzICclJyBhbmQgJ3wnCgkJYXJlIGVzY2FwZWQgd2l0aCBhIGJhY2tzbGFzaC4KCQlGb3IgbW9zdCBzeXN0ZW1zIHRoZSBjaGFyYWN0ZXJzIGVzY2FwZWQgYXJlCgkJIiBcdFxuKj9be2AkXFwlIydcInwhPCIuICBGb3Igc3lzdGVtcyB3aGVyZSBhIGJhY2tzbGFzaAoJCWFwcGVhcnMgaW4gYSBmaWxlbmFtZSwgaXQgZGVwZW5kcyBvbiB0aGUgdmFsdWUgb2YgJ2lzZm5hbWUnLgoJCUEgbGVhZGluZyAnKycgYW5kICc+JyBpcyBhbHNvIGVzY2FwZWQgKHNwZWNpYWwgYWZ0ZXIgfDplZGl0fAoJCWFuZCB8OndyaXRlfCkuICBBbmQgYSAiLSIgYnkgaXRzZWxmIChzcGVjaWFsIGFmdGVyIHw6Y2R8KS4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgZm5hbWUgPSAnK3NvbWUgc3RyJW5nZXxuYW1lJwoJCQk6ZXhlICJlZGl0ICIgLiBmbmFtZWVzY2FwZShmbmFtZSkKPAkJcmVzdWx0cyBpbiBleGVjdXRpbmc6ID4KCQkJZWRpdCBcK3NvbWVcIHN0clwlbmdlXHxuYW1lCgpmbmFtZW1vZGlmeSh7Zm5hbWV9LCB7bW9kc30pCQkJCSpmbmFtZW1vZGlmeSgpKgoJCU1vZGlmeSBmaWxlIG5hbWUge2ZuYW1lfSBhY2NvcmRpbmcgdG8ge21vZHN9LiAge21vZHN9IGlzIGEKCQlzdHJpbmcgb2YgY2hhcmFjdGVycyBsaWtlIGl0IGlzIHVzZWQgZm9yIGZpbGUgbmFtZXMgb24gdGhlCgkJY29tbWFuZCBsaW5lLiAgU2VlIHxmaWxlbmFtZS1tb2RpZmllcnN8LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gZm5hbWVtb2RpZnkoIm1haW4uYyIsICI6cDpoIikKPAkJcmVzdWx0cyBpbjogPgoJCQkvaG9tZS9tb29sL3ZpbS92aW0vc3JjCjwJCU5vdGU6IEVudmlyb25tZW50IHZhcmlhYmxlcyBkb24ndCB3b3JrIGluIHtmbmFtZX0sIHVzZQoJCXxleHBhbmQoKXwgZmlyc3QgdGhlbi4KCmZvbGRjbG9zZWQoe2xudW19KQkJCQkJKmZvbGRjbG9zZWQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLiAgSWYgdGhlIGxpbmUge2xudW19IGlzIGluIGEgY2xvc2VkCgkJZm9sZCwgdGhlIHJlc3VsdCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBmaXJzdCBsaW5lIGluIHRoYXQgZm9sZC4KCQlJZiB0aGUgbGluZSB7bG51bX0gaXMgbm90IGluIGEgY2xvc2VkIGZvbGQsIC0xIGlzIHJldHVybmVkLgoKZm9sZGNsb3NlZGVuZCh7bG51bX0pCQkJCQkqZm9sZGNsb3NlZGVuZCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIuICBJZiB0aGUgbGluZSB7bG51bX0gaXMgaW4gYSBjbG9zZWQKCQlmb2xkLCB0aGUgcmVzdWx0IGlzIHRoZSBudW1iZXIgb2YgdGhlIGxhc3QgbGluZSBpbiB0aGF0IGZvbGQuCgkJSWYgdGhlIGxpbmUge2xudW19IGlzIG5vdCBpbiBhIGNsb3NlZCBmb2xkLCAtMSBpcyByZXR1cm5lZC4KCmZvbGRsZXZlbCh7bG51bX0pCQkJCQkqZm9sZGxldmVsKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGZvbGRsZXZlbCBvZiBsaW5lIHtsbnVtfQoJCWluIHRoZSBjdXJyZW50IGJ1ZmZlci4JRm9yIG5lc3RlZCBmb2xkcyB0aGUgZGVlcGVzdCBsZXZlbCBpcwoJCXJldHVybmVkLiAgSWYgdGhlcmUgaXMgbm8gZm9sZCBhdCBsaW5lIHtsbnVtfSwgemVybyBpcwoJCXJldHVybmVkLiAgSXQgZG9lc24ndCBtYXR0ZXIgaWYgdGhlIGZvbGRzIGFyZSBvcGVuIG9yIGNsb3NlZC4KCQlXaGVuIHVzZWQgd2hpbGUgdXBkYXRpbmcgZm9sZHMgKGZyb20gJ2ZvbGRleHByJykgLTEgaXMKCQlyZXR1cm5lZCBmb3IgbGluZXMgd2hlcmUgZm9sZHMgYXJlIHN0aWxsIHRvIGJlIHVwZGF0ZWQgYW5kIHRoZQoJCWZvbGRsZXZlbCBpcyB1bmtub3duLiAgQXMgYSBzcGVjaWFsIGNhc2UgdGhlIGxldmVsIG9mIHRoZQoJCXByZXZpb3VzIGxpbmUgaXMgdXN1YWxseSBhdmFpbGFibGUuCgoJCQkJCQkJKmZvbGR0ZXh0KCkqCmZvbGR0ZXh0KCkJUmV0dXJucyBhIFN0cmluZywgdG8gYmUgZGlzcGxheWVkIGZvciBhIGNsb3NlZCBmb2xkLiAgVGhpcyBpcwoJCXRoZSBkZWZhdWx0IGZ1bmN0aW9uIHVzZWQgZm9yIHRoZSAnZm9sZHRleHQnIG9wdGlvbiBhbmQgc2hvdWxkCgkJb25seSBiZSBjYWxsZWQgZnJvbSBldmFsdWF0aW5nICdmb2xkdGV4dCcuICBJdCB1c2VzIHRoZQoJCXx2OmZvbGRzdGFydHwsIHx2OmZvbGRlbmR8IGFuZCB8djpmb2xkZGFzaGVzfCB2YXJpYWJsZXMuCgkJVGhlIHJldHVybmVkIHN0cmluZyBsb29rcyBsaWtlIHRoaXM6ID4KCQkJKy0tIDQ1IGxpbmVzOiBhYmNkZWYKPAkJVGhlIG51bWJlciBvZiBkYXNoZXMgZGVwZW5kcyBvbiB0aGUgZm9sZGxldmVsLglUaGUgIjQ1IiBpcwoJCXRoZSBudW1iZXIgb2YgbGluZXMgaW4gdGhlIGZvbGQuICAiYWJjZGVmIiBpcyB0aGUgdGV4dCBpbiB0aGUKCQlmaXJzdCBub24tYmxhbmsgbGluZSBvZiB0aGUgZm9sZC4gIExlYWRpbmcgd2hpdGUgc3BhY2UsICIvLyIKCQlvciAiLyoiIGFuZCB0aGUgdGV4dCBmcm9tIHRoZSAnZm9sZG1hcmtlcicgYW5kICdjb21tZW50c3RyaW5nJwoJCW9wdGlvbnMgaXMgcmVtb3ZlZC4KCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wgZmVhdHVyZX0KCmZvbGR0ZXh0cmVzdWx0KHtsbnVtfSkJCQkJCSpmb2xkdGV4dHJlc3VsdCgpKgoJCVJldHVybnMgdGhlIHRleHQgdGhhdCBpcyBkaXNwbGF5ZWQgZm9yIHRoZSBjbG9zZWQgZm9sZCBhdCBsaW5lCgkJe2xudW19LiAgRXZhbHVhdGVzICdmb2xkdGV4dCcgaW4gdGhlIGFwcHJvcHJpYXRlIGNvbnRleHQuCgkJV2hlbiB0aGVyZSBpcyBubyBjbG9zZWQgZm9sZCBhdCB7bG51bX0gYW4gZW1wdHkgc3RyaW5nIGlzCgkJcmV0dXJuZWQuCgkJe2xudW19IGlzIHVzZWQgbGlrZSB3aXRoIHxnZXRsaW5lKCl8LiAgVGh1cyAiLiIgaXMgdGhlIGN1cnJlbnQKCQlsaW5lLCAiJ20iIG1hcmsgbSwgZXRjLgoJCVVzZWZ1bCB3aGVuIGV4cG9ydGluZyBmb2xkZWQgdGV4dCwgZS5nLiwgdG8gSFRNTC4KCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wgZmVhdHVyZX0KCgkJCQkJCQkqZm9yZWdyb3VuZCgpKgpmb3JlZ3JvdW5kKCkJTW92ZSB0aGUgVmltIHdpbmRvdyB0byB0aGUgZm9yZWdyb3VuZC4JVXNlZnVsIHdoZW4gc2VudCBmcm9tCgkJYSBjbGllbnQgdG8gYSBWaW0gc2VydmVyLiB8cmVtb3RlX3NlbmQoKXwKCQlPbiBXaW4zMiBzeXN0ZW1zIHRoaXMgbWlnaHQgbm90IHdvcmssIHRoZSBPUyBkb2VzIG5vdCBhbHdheXMKCQlhbGxvdyBhIHdpbmRvdyB0byBicmluZyBpdHNlbGYgdG8gdGhlIGZvcmVncm91bmQuICBVc2UKCQl8cmVtb3RlX2ZvcmVncm91bmQoKXwgaW5zdGVhZC4KCQl7b25seSBpbiB0aGUgV2luMzIsIEF0aGVuYSwgTW90aWYgYW5kIEdUSyBHVUkgdmVyc2lvbnMgYW5kIHRoZQoJCVdpbjMyIGNvbnNvbGUgdmVyc2lvbn0KCgoJCQkJCSpmdW5jdGlvbigpKiAqRTcwMCogKkU5MjIqICpFOTIzKgpmdW5jdGlvbih7bmFtZX0gWywge2FyZ2xpc3R9XSBbLCB7ZGljdH1dKQoJCVJldHVybiBhIHxGdW5jcmVmfCB2YXJpYWJsZSB0aGF0IHJlZmVycyB0byBmdW5jdGlvbiB7bmFtZX0uCgkJe25hbWV9IGNhbiBiZSB0aGUgbmFtZSBvZiBhIHVzZXIgZGVmaW5lZCBmdW5jdGlvbiBvciBhbgoJCWludGVybmFsIGZ1bmN0aW9uLgoKCQl7bmFtZX0gY2FuIGFsc28gYmUgYSBGdW5jcmVmLCBhbHNvIGEgcGFydGlhbC4gIFdoZW4gaXQgaXMgYQoJCXBhcnRpYWwgdGhlIGRpY3Qgc3RvcmVkIGluIGl0IHdpbGwgYmUgdXNlZCBhbmQgdGhlIHtkaWN0fQoJCWFyZ3VtZW50IGlzIG5vdCBhbGxvd2VkLiBFLmcuOiA+CgkJCWxldCBGdW5jV2l0aEFyZyA9IGZ1bmN0aW9uKGRpY3QuRnVuYywgW2FyZ10pCgkJCWxldCBCcm9rZW4gPSBmdW5jdGlvbihkaWN0LkZ1bmMsIFthcmddLCBkaWN0KQo8CgkJV2hlbiB7YXJnbGlzdH0gb3Ige2RpY3R9IGlzIHByZXNlbnQgdGhpcyBjcmVhdGVzIGEgcGFydGlhbC4KCQlUaGF0IG1lYW5zIHRoZSBhcmd1bWVudCBsaXN0IGFuZC9vciB0aGUgZGljdGlvbmFyeSBpcyBzdG9yZWQgaW4KCQl0aGUgRnVuY3JlZiBhbmQgd2lsbCBiZSB1c2VkIHdoZW4gdGhlIEZ1bmNyZWYgaXMgY2FsbGVkLgoJCQoJCVRoZSBhcmd1bWVudHMgYXJlIHBhc3NlZCB0byB0aGUgZnVuY3Rpb24gaW4gZnJvbnQgb2Ygb3RoZXIKCQlhcmd1bWVudHMuICBFeGFtcGxlOiA+CgkJCWZ1bmMgQ2FsbGJhY2soYXJnMSwgYXJnMiwgbmFtZSkKCQkJLi4uCgkJCWxldCBGdW5jID0gZnVuY3Rpb24oJ0NhbGxiYWNrJywgWydvbmUnLCAndHdvJ10pCgkJCS4uLgoJCQljYWxsIEZ1bmMoJ25hbWUnKQo8CQlJbnZva2VzIHRoZSBmdW5jdGlvbiBhcyB3aXRoOiA+CgkJCWNhbGwgQ2FsbGJhY2soJ29uZScsICd0d28nLCAnbmFtZScpCgo8CQlUaGUgZnVuY3Rpb24oKSBjYWxsIGNhbiBiZSBuZXN0ZWQgdG8gYWRkIG1vcmUgYXJndW1lbnRzIHRvIHRoZQoJCUZ1bmNyZWYuICBUaGUgZXh0cmEgYXJndW1lbnRzIGFyZSBhcHBlbmRlZCB0byB0aGUgbGlzdCBvZgoJCWFyZ3VtZW50cy4gIEV4YW1wbGU6ID4KCQkJZnVuYyBDYWxsYmFjayhhcmcxLCBhcmcyLCBuYW1lKQoJCQkuLi4KCQkJbGV0IEZ1bmMgPSBmdW5jdGlvbignQ2FsbGJhY2snLCBbJ29uZSddKQoJCQlsZXQgRnVuYzIgPSBmdW5jdGlvbihGdW5jLCBbJ3R3byddKQoJCQkuLi4KCQkJY2FsbCBGdW5jMignbmFtZScpCjwJCUludm9rZXMgdGhlIGZ1bmN0aW9uIGFzIHdpdGg6ID4KCQkJY2FsbCBDYWxsYmFjaygnb25lJywgJ3R3bycsICduYW1lJykKCjwJCVRoZSBEaWN0aW9uYXJ5IGlzIG9ubHkgdXNlZnVsIHdoZW4gY2FsbGluZyBhICJkaWN0IiBmdW5jdGlvbi4KCQlJbiB0aGF0IGNhc2UgdGhlIHtkaWN0fSBpcyBwYXNzZWQgaW4gYXMgInNlbGYiLiBFeGFtcGxlOiA+CgkJCWZ1bmN0aW9uIENhbGxiYWNrKCkgZGljdAoJCQkgICBlY2hvICJjYWxsZWQgZm9yICIgLiBzZWxmLm5hbWUKCQkJZW5kZnVuY3Rpb24KCQkJLi4uCgkJCWxldCBjb250ZXh0ID0geyJuYW1lIjogImV4YW1wbGUifQoJCQlsZXQgRnVuYyA9IGZ1bmN0aW9uKCdDYWxsYmFjaycsIGNvbnRleHQpCgkJCS4uLgoJCQljYWxsIEZ1bmMoKQkiIHdpbGwgZWNobzogY2FsbGVkIGZvciBleGFtcGxlCjwJCVRoZSB1c2Ugb2YgZnVuY3Rpb24oKSBpcyBub3QgbmVlZGVkIHdoZW4gdGhlcmUgYXJlIG5vIGV4dHJhCgkJYXJndW1lbnRzLCB0aGVzZSB0d28gYXJlIGVxdWl2YWxlbnQ6ID4KCQkJbGV0IEZ1bmMgPSBmdW5jdGlvbignQ2FsbGJhY2snLCBjb250ZXh0KQoJCQlsZXQgRnVuYyA9IGNvbnRleHQuQ2FsbGJhY2sKCjwJCVRoZSBhcmd1bWVudCBsaXN0IGFuZCB0aGUgRGljdGlvbmFyeSBjYW4gYmUgY29tYmluZWQ6ID4KCQkJZnVuY3Rpb24gQ2FsbGJhY2soYXJnMSwgY291bnQpIGRpY3QKCQkJLi4uCgkJCWxldCBjb250ZXh0ID0geyJuYW1lIjogImV4YW1wbGUifQoJCQlsZXQgRnVuYyA9IGZ1bmN0aW9uKCdDYWxsYmFjaycsIFsnb25lJ10sIGNvbnRleHQpCgkJCS4uLgoJCQljYWxsIEZ1bmMoNTAwKQo8CQlJbnZva2VzIHRoZSBmdW5jdGlvbiBhcyB3aXRoOiA+CgkJCWNhbGwgY29udGV4dC5DYWxsYmFjaygnb25lJywgNTAwKQoKCmdhcmJhZ2Vjb2xsZWN0KFt7YXRleGl0fV0pCQkJCSpnYXJiYWdlY29sbGVjdCgpKgoJCUNsZWFudXAgdW51c2VkIHxMaXN0c3wsIHxEaWN0aW9uYXJpZXN8LCB8Q2hhbm5lbHN8IGFuZCB8Sm9ic3wKCQl0aGF0IGhhdmUgY2lyY3VsYXIgcmVmZXJlbmNlcy4KCQkKCQlUaGVyZSBpcyBoYXJkbHkgZXZlciBhIG5lZWQgdG8gaW52b2tlIHRoaXMgZnVuY3Rpb24sIGFzIGl0IGlzCgkJYXV0b21hdGljYWxseSBkb25lIHdoZW4gVmltIHJ1bnMgb3V0IG9mIG1lbW9yeSBvciBpcyB3YWl0aW5nCgkJZm9yIHRoZSB1c2VyIHRvIHByZXNzIGEga2V5IGFmdGVyICd1cGRhdGV0aW1lJy4gIEl0ZW1zIHdpdGhvdXQKCQljaXJjdWxhciByZWZlcmVuY2VzIGFyZSBhbHdheXMgZnJlZWQgd2hlbiB0aGV5IGJlY29tZSB1bnVzZWQuCgkJVGhpcyBpcyB1c2VmdWwgaWYgeW91IGhhdmUgZGVsZXRlZCBhIHZlcnkgYmlnIHxMaXN0fCBhbmQvb3IKCQl8RGljdGlvbmFyeXwgd2l0aCBjaXJjdWxhciByZWZlcmVuY2VzIGluIGEgc2NyaXB0IHRoYXQgcnVucwoJCWZvciBhIGxvbmcgdGltZS4KCgkJV2hlbiB0aGUgb3B0aW9uYWwge2F0ZXhpdH0gYXJndW1lbnQgaXMgb25lLCBnYXJiYWdlCgkJY29sbGVjdGlvbiB3aWxsIGFsc28gYmUgZG9uZSB3aGVuIGV4aXRpbmcgVmltLCBpZiBpdCB3YXNuJ3QKCQlkb25lIGJlZm9yZS4gIFRoaXMgaXMgdXNlZnVsIHdoZW4gY2hlY2tpbmcgZm9yIG1lbW9yeSBsZWFrcy4KCmdhcmJhZ2Vjb2xsZWN0X2Zvcl90ZXN0aW5nKCkJCQkgKmdhcmJhZ2Vjb2xsZWN0X2Zvcl90ZXN0aW5nKCkqCgkJTGlrZSBnYXJiYWdlY29sbGVjdCgpLCBidXQgZXhlY3V0ZWQgcmlnaHQgYXdheS4gIFRoaXMgbXVzdAoJCW9ubHkgYmUgY2FsbGVkIGRpcmVjdGx5IHRvIGF2b2lkIGFueSBzdHJ1Y3R1cmUgdG8gZXhpc3QKCQlpbnRlcm5hbGx5LCBhbmQgfHY6dGVzdGluZ3wgbXVzdCBoYXZlIGJlZW4gc2V0IGJlZm9yZSBjYWxsaW5nCgkJYW55IGZ1bmN0aW9uLgoKZ2V0KHtsaXN0fSwge2lkeH0gWywge2RlZmF1bHR9XSkJCQkqZ2V0KCkqCgkJR2V0IGl0ZW0ge2lkeH0gZnJvbSB8TGlzdHwge2xpc3R9LiAgV2hlbiB0aGlzIGl0ZW0gaXMgbm90CgkJYXZhaWxhYmxlIHJldHVybiB7ZGVmYXVsdH0uICBSZXR1cm4gemVybyB3aGVuIHtkZWZhdWx0fSBpcwoJCW9taXR0ZWQuCmdldCh7ZGljdH0sIHtrZXl9IFssIHtkZWZhdWx0fV0pCgkJR2V0IGl0ZW0gd2l0aCBrZXkge2tleX0gZnJvbSB8RGljdGlvbmFyeXwge2RpY3R9LiAgV2hlbiB0aGlzCgkJaXRlbSBpcyBub3QgYXZhaWxhYmxlIHJldHVybiB7ZGVmYXVsdH0uICBSZXR1cm4gemVybyB3aGVuCgkJe2RlZmF1bHR9IGlzIG9taXR0ZWQuCgoJCQkJCQkJKmdldGJ1ZmxpbmUoKSoKZ2V0YnVmbGluZSh7ZXhwcn0sIHtsbnVtfSBbLCB7ZW5kfV0pCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggdGhlIGxpbmVzIHN0YXJ0aW5nIGZyb20ge2xudW19IHRvIHtlbmR9CgkJKGluY2x1c2l2ZSkgaW4gdGhlIGJ1ZmZlciB7ZXhwcn0uICBJZiB7ZW5kfSBpcyBvbWl0dGVkLCBhCgkJfExpc3R8IHdpdGggb25seSB0aGUgbGluZSB7bG51bX0gaXMgcmV0dXJuZWQuCgoJCUZvciB0aGUgdXNlIG9mIHtleHByfSwgc2VlIHxidWZuYW1lKCl8IGFib3ZlLgoKCQlGb3Ige2xudW19IGFuZCB7ZW5kfSAiJCIgY2FuIGJlIHVzZWQgZm9yIHRoZSBsYXN0IGxpbmUgb2YgdGhlCgkJYnVmZmVyLiAgT3RoZXJ3aXNlIGEgbnVtYmVyIG11c3QgYmUgdXNlZC4KCgkJV2hlbiB7bG51bX0gaXMgc21hbGxlciB0aGFuIDEgb3IgYmlnZ2VyIHRoYW4gdGhlIG51bWJlciBvZgoJCWxpbmVzIGluIHRoZSBidWZmZXIsIGFuIGVtcHR5IHxMaXN0fCBpcyByZXR1cm5lZC4KCgkJV2hlbiB7ZW5kfSBpcyBncmVhdGVyIHRoYW4gdGhlIG51bWJlciBvZiBsaW5lcyBpbiB0aGUgYnVmZmVyLAoJCWl0IGlzIHRyZWF0ZWQgYXMge2VuZH0gaXMgc2V0IHRvIHRoZSBudW1iZXIgb2YgbGluZXMgaW4gdGhlCgkJYnVmZmVyLiAgV2hlbiB7ZW5kfSBpcyBiZWZvcmUge2xudW19IGFuIGVtcHR5IHxMaXN0fCBpcwoJCXJldHVybmVkLgoKCQlUaGlzIGZ1bmN0aW9uIHdvcmtzIG9ubHkgZm9yIGxvYWRlZCBidWZmZXJzLiAgRm9yIHVubG9hZGVkIGFuZAoJCW5vbi1leGlzdGluZyBidWZmZXJzLCBhbiBlbXB0eSB8TGlzdHwgaXMgcmV0dXJuZWQuCgoJCUV4YW1wbGU6ID4KCQkJOmxldCBsaW5lcyA9IGdldGJ1ZmxpbmUoYnVmbnIoIm15ZmlsZSIpLCAxLCAiJCIpCgpnZXRidWZ2YXIoe2V4cHJ9LCB7dmFybmFtZX0gWywge2RlZn1dKQkJCQkqZ2V0YnVmdmFyKCkqCgkJVGhlIHJlc3VsdCBpcyB0aGUgdmFsdWUgb2Ygb3B0aW9uIG9yIGxvY2FsIGJ1ZmZlciB2YXJpYWJsZQoJCXt2YXJuYW1lfSBpbiBidWZmZXIge2V4cHJ9LiAgTm90ZSB0aGF0IHRoZSBuYW1lIHdpdGhvdXQgImI6IgoJCW11c3QgYmUgdXNlZC4KCQlXaGVuIHt2YXJuYW1lfSBpcyBlbXB0eSByZXR1cm5zIGEgZGljdGlvbmFyeSB3aXRoIGFsbCB0aGUKCQlidWZmZXItbG9jYWwgdmFyaWFibGVzLgoJCVRoaXMgYWxzbyB3b3JrcyBmb3IgYSBnbG9iYWwgb3IgYnVmZmVyLWxvY2FsIG9wdGlvbiwgYnV0IGl0CgkJZG9lc24ndCB3b3JrIGZvciBhIGdsb2JhbCB2YXJpYWJsZSwgd2luZG93LWxvY2FsIHZhcmlhYmxlIG9yCgkJd2luZG93LWxvY2FsIG9wdGlvbi4KCQlGb3IgdGhlIHVzZSBvZiB7ZXhwcn0sIHNlZSB8YnVmbmFtZSgpfCBhYm92ZS4KCQlXaGVuIHRoZSBidWZmZXIgb3IgdmFyaWFibGUgZG9lc24ndCBleGlzdCB7ZGVmfSBvciBhbiBlbXB0eQoJCXN0cmluZyBpcyByZXR1cm5lZCwgdGhlcmUgaXMgbm8gZXJyb3IgbWVzc2FnZS4KCQlFeGFtcGxlczogPgoJCQk6bGV0IGJ1Zm1vZGlmaWVkID0gZ2V0YnVmdmFyKDEsICImbW9kIikKCQkJOmVjaG8gInRvZG8gbXl2YXIgPSAiIC4gZ2V0YnVmdmFyKCJ0b2RvIiwgIm15dmFyIikKPApnZXRjaGFyKFtleHByXSkJCQkJCQkqZ2V0Y2hhcigpKgoJCUdldCBhIHNpbmdsZSBjaGFyYWN0ZXIgZnJvbSB0aGUgdXNlciBvciBpbnB1dCBzdHJlYW0uCgkJSWYgW2V4cHJdIGlzIG9taXR0ZWQsIHdhaXQgdW50aWwgYSBjaGFyYWN0ZXIgaXMgYXZhaWxhYmxlLgoJCUlmIFtleHByXSBpcyAwLCBvbmx5IGdldCBhIGNoYXJhY3RlciB3aGVuIG9uZSBpcyBhdmFpbGFibGUuCgkJCVJldHVybiB6ZXJvIG90aGVyd2lzZS4KCQlJZiBbZXhwcl0gaXMgMSwgb25seSBjaGVjayBpZiBhIGNoYXJhY3RlciBpcyBhdmFpbGFibGUsIGl0IGlzCgkJCW5vdCBjb25zdW1lZC4gIFJldHVybiB6ZXJvIGlmIG5vIGNoYXJhY3RlciBhdmFpbGFibGUuCgoJCVdpdGhvdXQgW2V4cHJdIGFuZCB3aGVuIFtleHByXSBpcyAwIGEgd2hvbGUgY2hhcmFjdGVyIG9yCgkJc3BlY2lhbCBrZXkgaXMgcmV0dXJuZWQuICBJZiBpdCBpcyBhbiA4LWJpdCBjaGFyYWN0ZXIsIHRoZQoJCXJlc3VsdCBpcyBhIG51bWJlci4gIFVzZSBucjJjaGFyKCkgdG8gY29udmVydCBpdCB0byBhIFN0cmluZy4KCQlPdGhlcndpc2UgYSBTdHJpbmcgaXMgcmV0dXJuZWQgd2l0aCB0aGUgZW5jb2RlZCBjaGFyYWN0ZXIuCgkJRm9yIGEgc3BlY2lhbCBrZXkgaXQncyBhIHNlcXVlbmNlIG9mIGJ5dGVzIHN0YXJ0aW5nIHdpdGggMHg4MAoJCShkZWNpbWFsOiAxMjgpLiAgVGhpcyBpcyB0aGUgc2FtZSB2YWx1ZSBhcyB0aGUgc3RyaW5nCgkJIlw8S2V5PiIsIGUuZy4sICJcPExlZnQ+Ii4gIFRoZSByZXR1cm5lZCB2YWx1ZSBpcyBhbHNvIGEKCQlTdHJpbmcgd2hlbiBhIG1vZGlmaWVyIChzaGlmdCwgY29udHJvbCwgYWx0KSB3YXMgdXNlZCB0aGF0IGlzCgkJbm90IGluY2x1ZGVkIGluIHRoZSBjaGFyYWN0ZXIuCgoJCVdoZW4gW2V4cHJdIGlzIDAgYW5kIEVzYyBpcyB0eXBlZCwgdGhlcmUgd2lsbCBiZSBhIHNob3J0IGRlbGF5CgkJd2hpbGUgVmltIHdhaXRzIHRvIHNlZSBpZiB0aGlzIGlzIHRoZSBzdGFydCBvZiBhbiBlc2NhcGUKCQlzZXF1ZW5jZS4KCgkJV2hlbiBbZXhwcl0gaXMgMSBvbmx5IHRoZSBmaXJzdCBieXRlIGlzIHJldHVybmVkLiAgRm9yIGEKCQlvbmUtYnl0ZSBjaGFyYWN0ZXIgaXQgaXMgdGhlIGNoYXJhY3RlciBpdHNlbGYgYXMgYSBudW1iZXIuCgkJVXNlIG5yMmNoYXIoKSB0byBjb252ZXJ0IGl0IHRvIGEgU3RyaW5nLgoKCQlVc2UgZ2V0Y2hhcm1vZCgpIHRvIG9idGFpbiBhbnkgYWRkaXRpb25hbCBtb2RpZmllcnMuCgoJCVdoZW4gdGhlIHVzZXIgY2xpY2tzIGEgbW91c2UgYnV0dG9uLCB0aGUgbW91c2UgZXZlbnQgd2lsbCBiZQoJCXJldHVybmVkLiAgVGhlIHBvc2l0aW9uIGNhbiB0aGVuIGJlIGZvdW5kIGluIHx2Om1vdXNlX2NvbHwsCgkJfHY6bW91c2VfbG51bXwgYW5kIHx2Om1vdXNlX3dpbnwuICBUaGlzIGV4YW1wbGUgcG9zaXRpb25zIHRoZQoJCW1vdXNlIGFzIGl0IHdvdWxkIG5vcm1hbGx5IGhhcHBlbjogPgoJCQlsZXQgYyA9IGdldGNoYXIoKQoJCQlpZiBjID09ICJcPExlZnRNb3VzZT4iICYmIHY6bW91c2Vfd2luID4gMAoJCQkgIGV4ZSB2Om1vdXNlX3dpbiAuICJ3aW5jbWQgdyIKCQkJICBleGUgdjptb3VzZV9sbnVtCgkJCSAgZXhlICJub3JtYWwgIiAuIHY6bW91c2VfY29sIC4gInwiCgkJCWVuZGlmCjwKCQlUaGVyZSBpcyBubyBwcm9tcHQsIHlvdSB3aWxsIHNvbWVob3cgaGF2ZSB0byBtYWtlIGNsZWFyIHRvIHRoZQoJCXVzZXIgdGhhdCBhIGNoYXJhY3RlciBoYXMgdG8gYmUgdHlwZWQuCgkJVGhlcmUgaXMgbm8gbWFwcGluZyBmb3IgdGhlIGNoYXJhY3Rlci4KCQlLZXkgY29kZXMgYXJlIHJlcGxhY2VkLCB0aHVzIHdoZW4gdGhlIHVzZXIgcHJlc3NlcyB0aGUgPERlbD4KCQlrZXkgeW91IGdldCB0aGUgY29kZSBmb3IgdGhlIDxEZWw+IGtleSwgbm90IHRoZSByYXcgY2hhcmFjdGVyCgkJc2VxdWVuY2UuICBFeGFtcGxlczogPgoJCQlnZXRjaGFyKCkgPT0gIlw8RGVsPiIKCQkJZ2V0Y2hhcigpID09ICJcPFMtTGVmdD4iCjwJCVRoaXMgZXhhbXBsZSByZWRlZmluZXMgImYiIHRvIGlnbm9yZSBjYXNlOiA+CgkJCTpubWFwIGYgOmNhbGwgRmluZENoYXIoKTxDUj4KCQkJOmZ1bmN0aW9uIEZpbmRDaGFyKCkKCQkJOiAgbGV0IGMgPSBucjJjaGFyKGdldGNoYXIoKSkKCQkJOiAgd2hpbGUgY29sKCcuJykgPCBjb2woJyQnKSAtIDEKCQkJOiAgICBub3JtYWwgbAoJCQk6ICAgIGlmIGdldGxpbmUoJy4nKVtjb2woJy4nKSAtIDFdID09PyBjCgkJCTogICAgICBicmVhawoJCQk6ICAgIGVuZGlmCgkJCTogIGVuZHdoaWxlCgkJCTplbmRmdW5jdGlvbgo8CgkJWW91IG1heSBhbHNvIHJlY2VpdmUgc3ludGhldGljIGNoYXJhY3RlcnMsIHN1Y2ggYXMKCQl8PEN1cnNvckhvbGQ+fC4gT2Z0ZW4geW91IHdpbGwgd2FudCB0byBpZ25vcmUgdGhpcyBhbmQgZ2V0CgkJYW5vdGhlciBjaGFyYWN0ZXI6ID4KCQkJOmZ1bmN0aW9uIEdldEtleSgpCgkJCTogIGxldCBjID0gZ2V0Y2hhcigpCgkJCTogIHdoaWxlIGMgPT0gIlw8Q3Vyc29ySG9sZD4iCgkJCTogICAgbGV0IGMgPSBnZXRjaGFyKCkKCQkJOiAgZW5kd2hpbGUKCQkJOiAgcmV0dXJuIGMKCQkJOmVuZGZ1bmN0aW9uCgpnZXRjaGFybW9kKCkJCQkJCQkqZ2V0Y2hhcm1vZCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIgd2hpY2ggaXMgdGhlIHN0YXRlIG9mIHRoZSBtb2RpZmllcnMgZm9yCgkJdGhlIGxhc3Qgb2J0YWluZWQgY2hhcmFjdGVyIHdpdGggZ2V0Y2hhcigpIG9yIGluIGFub3RoZXIgd2F5LgoJCVRoZXNlIHZhbHVlcyBhcmUgYWRkZWQgdG9nZXRoZXI6CgkJCTIJc2hpZnQKCQkJNAljb250cm9sCgkJCTgJYWx0IChtZXRhKQoJCQkxNgltZXRhICh3aGVuIGl0J3MgZGlmZmVyZW50IGZyb20gQUxUKQoJCQkzMgltb3VzZSBkb3VibGUgY2xpY2sKCQkJNjQJbW91c2UgdHJpcGxlIGNsaWNrCgkJCTk2CW1vdXNlIHF1YWRydXBsZSBjbGljayAoPT0gMzIgKyA2NCkKCQkJMTI4CWNvbW1hbmQgKE1hY2ludG9zaCBvbmx5KQoJCU9ubHkgdGhlIG1vZGlmaWVycyB0aGF0IGhhdmUgbm90IGJlZW4gaW5jbHVkZWQgaW4gdGhlCgkJY2hhcmFjdGVyIGl0c2VsZiBhcmUgb2J0YWluZWQuCVRodXMgU2hpZnQtYSByZXN1bHRzIGluICJBIgoJCXdpdGhvdXQgYSBtb2RpZmllci4KCmdldGNoYXJzZWFyY2goKQkJCQkJCSpnZXRjaGFyc2VhcmNoKCkqCgkJUmV0dXJuIHRoZSBjdXJyZW50IGNoYXJhY3RlciBzZWFyY2ggaW5mb3JtYXRpb24gYXMgYSB7ZGljdH0KCQl3aXRoIHRoZSBmb2xsb3dpbmcgZW50cmllczoKCgkJICAgIGNoYXIJY2hhcmFjdGVyIHByZXZpb3VzbHkgdXNlZCBmb3IgYSBjaGFyYWN0ZXIKCQkJCXNlYXJjaCAofHR8LCB8ZnwsIHxUfCwgb3IgfEZ8KTsgZW1wdHkgc3RyaW5nCgkJCQlpZiBubyBjaGFyYWN0ZXIgc2VhcmNoIGhhcyBiZWVuIHBlcmZvcm1lZAoJCSAgICBmb3J3YXJkCWRpcmVjdGlvbiBvZiBjaGFyYWN0ZXIgc2VhcmNoOyAxIGZvciBmb3J3YXJkLAoJCQkJMCBmb3IgYmFja3dhcmQKCQkgICAgdW50aWwJdHlwZSBvZiBjaGFyYWN0ZXIgc2VhcmNoOyAxIGZvciBhIHx0fCBvciB8VHwKCQkJCWNoYXJhY3RlciBzZWFyY2gsIDAgZm9yIGFuIHxmfCBvciB8RnwKCQkJCWNoYXJhY3RlciBzZWFyY2gKCgkJVGhpcyBjYW4gYmUgdXNlZnVsIHRvIGFsd2F5cyBoYXZlIHw7fCBhbmQgfCx8IHNlYXJjaAoJCWZvcndhcmQvYmFja3dhcmQgcmVnYXJkbGVzcyBvZiB0aGUgZGlyZWN0aW9uIG9mIHRoZSBwcmV2aW91cwoJCWNoYXJhY3RlciBzZWFyY2g6ID4KCQkJOm5ub3JlbWFwIDxleHByPiA7IGdldGNoYXJzZWFyY2goKS5mb3J3YXJkID8gJzsnIDogJywnCgkJCTpubm9yZW1hcCA8ZXhwcj4gLCBnZXRjaGFyc2VhcmNoKCkuZm9yd2FyZCA/ICcsJyA6ICc7Jwo8CQlBbHNvIHNlZSB8c2V0Y2hhcnNlYXJjaCgpfC4KCmdldGNtZGxpbmUoKQkJCQkJCSpnZXRjbWRsaW5lKCkqCgkJUmV0dXJuIHRoZSBjdXJyZW50IGNvbW1hbmQtbGluZS4gIE9ubHkgd29ya3Mgd2hlbiB0aGUgY29tbWFuZAoJCWxpbmUgaXMgYmVpbmcgZWRpdGVkLCB0aHVzIHJlcXVpcmVzIHVzZSBvZiB8Y19DVFJMLVxfZXwgb3IKCQl8Y19DVFJMLVJfPXwuCgkJRXhhbXBsZTogPgoJCQk6Y21hcCA8Rjc+IDxDLVw+ZWVzY2FwZShnZXRjbWRsaW5lKCksICcgXCcpPENSPgo8CQlBbHNvIHNlZSB8Z2V0Y21kdHlwZSgpfCwgfGdldGNtZHBvcygpfCBhbmQgfHNldGNtZHBvcygpfC4KCmdldGNtZHBvcygpCQkJCQkJKmdldGNtZHBvcygpKgoJCVJldHVybiB0aGUgcG9zaXRpb24gb2YgdGhlIGN1cnNvciBpbiB0aGUgY29tbWFuZCBsaW5lIGFzIGEKCQlieXRlIGNvdW50LiAgVGhlIGZpcnN0IGNvbHVtbiBpcyAxLgoJCU9ubHkgd29ya3Mgd2hlbiBlZGl0aW5nIHRoZSBjb21tYW5kIGxpbmUsIHRodXMgcmVxdWlyZXMgdXNlIG9mCgkJfGNfQ1RSTC1cX2V8IG9yIHxjX0NUUkwtUl89fCBvciBhbiBleHByZXNzaW9uIG1hcHBpbmcuCgkJUmV0dXJucyAwIG90aGVyd2lzZS4KCQlBbHNvIHNlZSB8Z2V0Y21kdHlwZSgpfCwgfHNldGNtZHBvcygpfCBhbmQgfGdldGNtZGxpbmUoKXwuCgpnZXRjbWR0eXBlKCkJCQkJCQkqZ2V0Y21kdHlwZSgpKgoJCVJldHVybiB0aGUgY3VycmVudCBjb21tYW5kLWxpbmUgdHlwZS4gUG9zc2libGUgcmV0dXJuIHZhbHVlcwoJCWFyZToKCQkgICAgOglub3JtYWwgRXggY29tbWFuZAoJCSAgICA+CWRlYnVnIG1vZGUgY29tbWFuZCB8ZGVidWctbW9kZXwKCQkgICAgLwlmb3J3YXJkIHNlYXJjaCBjb21tYW5kCgkJICAgID8JYmFja3dhcmQgc2VhcmNoIGNvbW1hbmQKCQkgICAgQAl8aW5wdXQoKXwgY29tbWFuZAoJCSAgICAtCXw6aW5zZXJ0fCBvciB8OmFwcGVuZHwgY29tbWFuZAoJCSAgICA9CXxpX0NUUkwtUl89fAoJCU9ubHkgd29ya3Mgd2hlbiBlZGl0aW5nIHRoZSBjb21tYW5kIGxpbmUsIHRodXMgcmVxdWlyZXMgdXNlIG9mCgkJfGNfQ1RSTC1cX2V8IG9yIHxjX0NUUkwtUl89fCBvciBhbiBleHByZXNzaW9uIG1hcHBpbmcuCgkJUmV0dXJucyBhbiBlbXB0eSBzdHJpbmcgb3RoZXJ3aXNlLgoJCUFsc28gc2VlIHxnZXRjbWRwb3MoKXwsIHxzZXRjbWRwb3MoKXwgYW5kIHxnZXRjbWRsaW5lKCl8LgoKZ2V0Y21kd2ludHlwZSgpCQkJCQkJKmdldGNtZHdpbnR5cGUoKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgfGNvbW1hbmQtbGluZS13aW5kb3d8IHR5cGUuIFBvc3NpYmxlIHJldHVybgoJCXZhbHVlcyBhcmUgdGhlIHNhbWUgYXMgfGdldGNtZHR5cGUoKXwuIFJldHVybnMgYW4gZW1wdHkgc3RyaW5nCgkJd2hlbiBub3QgaW4gdGhlIGNvbW1hbmQtbGluZSB3aW5kb3cuCgoJCQkJCQkJKmdldGN1cnBvcygpKgpnZXRjdXJwb3MoKQlHZXQgdGhlIHBvc2l0aW9uIG9mIHRoZSBjdXJzb3IuICBUaGlzIGlzIGxpa2UgZ2V0cG9zKCcuJyksIGJ1dAoJCWluY2x1ZGVzIGFuIGV4dHJhIGl0ZW0gaW4gdGhlIGxpc3Q6CgkJICAgIFtidWZudW0sIGxudW0sIGNvbCwgb2ZmLCBjdXJzd2FudF0gfgoJCVRoZSAiY3Vyc3dhbnQiIG51bWJlciBpcyB0aGUgcHJlZmVycmVkIGNvbHVtbiB3aGVuIG1vdmluZyB0aGUKCQljdXJzb3IgdmVydGljYWxseS4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIHNhdmUgYW5kIHJlc3RvcmUgdGhlIGN1cnNvciBwb3NpdGlvbjogPgoJCQlsZXQgc2F2ZV9jdXJzb3IgPSBnZXRjdXJwb3MoKQoJCQlNb3ZlVGhlQ3Vyc29yQXJvdW5kCgkJCWNhbGwgc2V0cG9zKCcuJywgc2F2ZV9jdXJzb3IpCjwKCQkJCQkJCSpnZXRjd2QoKSoKZ2V0Y3dkKFt7d2lubnJ9IFssIHt0YWJucn1dXSkKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUgbmFtZSBvZiB0aGUgY3VycmVudAoJCXdvcmtpbmcgZGlyZWN0b3J5LgoJCVdpdGhvdXQgYXJndW1lbnRzLCBmb3IgdGhlIGN1cnJlbnQgd2luZG93LgoKCQlXaXRoIHt3aW5ucn0gcmV0dXJuIHRoZSBsb2NhbCBjdXJyZW50IGRpcmVjdG9yeSBvZiB0aGlzIHdpbmRvdwoJCWluIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoJCVdpdGgge3dpbm5yfSBhbmQge3RhYm5yfSByZXR1cm4gdGhlIGxvY2FsIGN1cnJlbnQgZGlyZWN0b3J5IG9mCgkJdGhlIHdpbmRvdyBpbiB0aGUgc3BlY2lmaWVkIHRhYiBwYWdlLgoJCVJldHVybiBhbiBlbXB0eSBzdHJpbmcgaWYgdGhlIGFyZ3VtZW50cyBhcmUgaW52YWxpZC4KCmdldGZzaXplKHtmbmFtZX0pCQkJCQkqZ2V0ZnNpemUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgc2l6ZSBpbiBieXRlcyBvZiB0aGUKCQlnaXZlbiBmaWxlIHtmbmFtZX0uCgkJSWYge2ZuYW1lfSBpcyBhIGRpcmVjdG9yeSwgMCBpcyByZXR1cm5lZC4KCQlJZiB0aGUgZmlsZSB7Zm5hbWV9IGNhbid0IGJlIGZvdW5kLCAtMSBpcyByZXR1cm5lZC4KCQlJZiB0aGUgc2l6ZSBvZiB7Zm5hbWV9IGlzIHRvbyBiaWcgdG8gZml0IGluIGEgTnVtYmVyIHRoZW4gLTIKCQlpcyByZXR1cm5lZC4KCmdldGZvbnRuYW1lKFt7bmFtZX1dKQkJCQkJKmdldGZvbnRuYW1lKCkqCgkJV2l0aG91dCBhbiBhcmd1bWVudCByZXR1cm5zIHRoZSBuYW1lIG9mIHRoZSBub3JtYWwgZm9udCBiZWluZwoJCXVzZWQuICBMaWtlIHdoYXQgaXMgdXNlZCBmb3IgdGhlIE5vcm1hbCBoaWdobGlnaHQgZ3JvdXAKCQl8aGwtTm9ybWFsfC4KCQlXaXRoIGFuIGFyZ3VtZW50IGEgY2hlY2sgaXMgZG9uZSB3aGV0aGVyIHtuYW1lfSBpcyBhIHZhbGlkCgkJZm9udCBuYW1lLiAgSWYgbm90IHRoZW4gYW4gZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLgoJCU90aGVyd2lzZSB0aGUgYWN0dWFsIGZvbnQgbmFtZSBpcyByZXR1cm5lZCwgb3Ige25hbWV9IGlmIHRoZQoJCUdVSSBkb2VzIG5vdCBzdXBwb3J0IG9idGFpbmluZyB0aGUgcmVhbCBuYW1lLgoJCU9ubHkgd29ya3Mgd2hlbiB0aGUgR1VJIGlzIHJ1bm5pbmcsIHRodXMgbm90IGluIHlvdXIgdmltcmMgb3IKCQlndmltcmMgZmlsZS4gIFVzZSB0aGUgfEdVSUVudGVyfCBhdXRvY29tbWFuZCB0byB1c2UgdGhpcwoJCWZ1bmN0aW9uIGp1c3QgYWZ0ZXIgdGhlIEdVSSBoYXMgc3RhcnRlZC4KCQlOb3RlIHRoYXQgdGhlIEdUSyAyIEdVSSBhY2NlcHRzIGFueSBmb250IG5hbWUsIHRodXMgY2hlY2tpbmcKCQlmb3IgYSB2YWxpZCBuYW1lIGRvZXMgbm90IHdvcmsuCgpnZXRmcGVybSh7Zm5hbWV9KQkJCQkJKmdldGZwZXJtKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIHJlYWQsIHdyaXRlLCBhbmQgZXhlY3V0ZQoJCXBlcm1pc3Npb25zIG9mIHRoZSBnaXZlbiBmaWxlIHtmbmFtZX0uCgkJSWYge2ZuYW1lfSBkb2VzIG5vdCBleGlzdCBvciBpdHMgZGlyZWN0b3J5IGNhbm5vdCBiZSByZWFkLCBhbgoJCWVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCQlUaGUgcmVzdWx0IGlzIG9mIHRoZSBmb3JtICJyd3hyd3hyd3giLCB3aGVyZSBlYWNoIGdyb3VwIG9mCgkJInJ3eCIgZmxhZ3MgcmVwcmVzZW50LCBpbiB0dXJuLCB0aGUgcGVybWlzc2lvbnMgb2YgdGhlIG93bmVyCgkJb2YgdGhlIGZpbGUsIHRoZSBncm91cCB0aGUgZmlsZSBiZWxvbmdzIHRvLCBhbmQgb3RoZXIgdXNlcnMuCgkJSWYgYSB1c2VyIGRvZXMgbm90IGhhdmUgYSBnaXZlbiBwZXJtaXNzaW9uIHRoZSBmbGFnIGZvciB0aGlzCgkJaXMgcmVwbGFjZWQgd2l0aCB0aGUgc3RyaW5nICItIi4gIEV4YW1wbGVzOiA+CgkJCTplY2hvIGdldGZwZXJtKCIvZXRjL3Bhc3N3ZCIpCgkJCTplY2hvIGdldGZwZXJtKGV4cGFuZCgifi8udmltcmMiKSkKPAkJVGhpcyB3aWxsIGhvcGVmdWxseSAoZnJvbSBhIHNlY3VyaXR5IHBvaW50IG9mIHZpZXcpIGRpc3BsYXkKCQl0aGUgc3RyaW5nICJydy1yLS1yLS0iIG9yIGV2ZW4gInJ3LS0tLS0tLSIuCgoJCUZvciBzZXR0aW5nIHBlcm1pc3NpbnMgdXNlIHxzZXRmcGVybSgpfC4KCmdldGZ0aW1lKHtmbmFtZX0pCQkJCQkqZ2V0ZnRpbWUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbGFzdCBtb2RpZmljYXRpb24gdGltZSBvZgoJCXRoZSBnaXZlbiBmaWxlIHtmbmFtZX0uICBUaGUgdmFsdWUgaXMgbWVhc3VyZWQgYXMgc2Vjb25kcwoJCXNpbmNlIDFzdCBKYW4gMTk3MCwgYW5kIG1heSBiZSBwYXNzZWQgdG8gc3RyZnRpbWUoKS4gIFNlZSBhbHNvCgkJfGxvY2FsdGltZSgpfCBhbmQgfHN0cmZ0aW1lKCl8LgoJCUlmIHRoZSBmaWxlIHtmbmFtZX0gY2FuJ3QgYmUgZm91bmQgLTEgaXMgcmV0dXJuZWQuCgpnZXRmdHlwZSh7Zm5hbWV9KQkJCQkJKmdldGZ0eXBlKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgYSBkZXNjcmlwdGlvbiBvZiB0aGUga2luZCBvZgoJCWZpbGUgb2YgdGhlIGdpdmVuIGZpbGUge2ZuYW1lfS4KCQlJZiB7Zm5hbWV9IGRvZXMgbm90IGV4aXN0IGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCQlIZXJlIGlzIGEgdGFibGUgb3ZlciBkaWZmZXJlbnQga2luZHMgb2YgZmlsZXMgYW5kIHRoZWlyCgkJcmVzdWx0czoKCQkJTm9ybWFsIGZpbGUJCSJmaWxlIgoJCQlEaXJlY3RvcnkJCSJkaXIiCgkJCVN5bWJvbGljIGxpbmsJCSJsaW5rIgoJCQlCbG9jayBkZXZpY2UJCSJiZGV2IgoJCQlDaGFyYWN0ZXIgZGV2aWNlCSJjZGV2IgoJCQlTb2NrZXQJCQkic29ja2V0IgoJCQlGSUZPCQkJImZpZm8iCgkJCUFsbCBvdGhlcgkJIm90aGVyIgoJCUV4YW1wbGU6ID4KCQkJZ2V0ZnR5cGUoIi9ob21lIikKPAkJTm90ZSB0aGF0IGEgdHlwZSBzdWNoIGFzICJsaW5rIiB3aWxsIG9ubHkgYmUgcmV0dXJuZWQgb24KCQlzeXN0ZW1zIHRoYXQgc3VwcG9ydCBpdC4gIE9uIHNvbWUgc3lzdGVtcyBvbmx5ICJkaXIiIGFuZAoJCSJmaWxlIiBhcmUgcmV0dXJuZWQuICBPbiBNUy1XaW5kb3dzIGEgc3ltYm9saWMgbGluayB0byBhCgkJZGlyZWN0b3J5IHJldHVybnMgImRpciIgaW5zdGVhZCBvZiAibGluayIuCgoJCQkJCQkJKmdldGxpbmUoKSoKZ2V0bGluZSh7bG51bX0gWywge2VuZH1dKQoJCVdpdGhvdXQge2VuZH0gdGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgbGluZSB7bG51bX0KCQlmcm9tIHRoZSBjdXJyZW50IGJ1ZmZlci4gIEV4YW1wbGU6ID4KCQkJZ2V0bGluZSgxKQo8CQlXaGVuIHtsbnVtfSBpcyBhIFN0cmluZyB0aGF0IGRvZXNuJ3Qgc3RhcnQgd2l0aCBhCgkJZGlnaXQsIGxpbmUoKSBpcyBjYWxsZWQgdG8gdHJhbnNsYXRlIHRoZSBTdHJpbmcgaW50byBhIE51bWJlci4KCQlUbyBnZXQgdGhlIGxpbmUgdW5kZXIgdGhlIGN1cnNvcjogPgoJCQlnZXRsaW5lKCIuIikKPAkJV2hlbiB7bG51bX0gaXMgc21hbGxlciB0aGFuIDEgb3IgYmlnZ2VyIHRoYW4gdGhlIG51bWJlciBvZgoJCWxpbmVzIGluIHRoZSBidWZmZXIsIGFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4KCgkJV2hlbiB7ZW5kfSBpcyBnaXZlbiB0aGUgcmVzdWx0IGlzIGEgfExpc3R8IHdoZXJlIGVhY2ggaXRlbSBpcwoJCWEgbGluZSBmcm9tIHRoZSBjdXJyZW50IGJ1ZmZlciBpbiB0aGUgcmFuZ2Uge2xudW19IHRvIHtlbmR9LAoJCWluY2x1ZGluZyBsaW5lIHtlbmR9LgoJCXtlbmR9IGlzIHVzZWQgaW4gdGhlIHNhbWUgd2F5IGFzIHtsbnVtfS4KCQlOb24tZXhpc3RpbmcgbGluZXMgYXJlIHNpbGVudGx5IG9taXR0ZWQuCgkJV2hlbiB7ZW5kfSBpcyBiZWZvcmUge2xudW19IGFuIGVtcHR5IHxMaXN0fCBpcyByZXR1cm5lZC4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgc3RhcnQgPSBsaW5lKCcuJykKCQkJOmxldCBlbmQgPSBzZWFyY2goIl4kIikgLSAxCgkJCTpsZXQgbGluZXMgPSBnZXRsaW5lKHN0YXJ0LCBlbmQpCgo8CQlUbyBnZXQgbGluZXMgZnJvbSBhbm90aGVyIGJ1ZmZlciBzZWUgfGdldGJ1ZmxpbmUoKXwKCmdldGxvY2xpc3Qoe25yfSkJCQkJCSpnZXRsb2NsaXN0KCkqCgkJUmV0dXJucyBhIGxpc3Qgd2l0aCBhbGwgdGhlIGVudHJpZXMgaW4gdGhlIGxvY2F0aW9uIGxpc3QgZm9yCgkJd2luZG93IHtucn0uIFdoZW4ge25yfSBpcyB6ZXJvIHRoZSBjdXJyZW50IHdpbmRvdyBpcyB1c2VkLgoJCUZvciBhIGxvY2F0aW9uIGxpc3Qgd2luZG93LCB0aGUgZGlzcGxheWVkIGxvY2F0aW9uIGxpc3QgaXMKCQlyZXR1cm5lZC4gIEZvciBhbiBpbnZhbGlkIHdpbmRvdyBudW1iZXIge25yfSwgYW4gZW1wdHkgbGlzdCBpcwoJCXJldHVybmVkLiBPdGhlcndpc2UsIHNhbWUgYXMgfGdldHFmbGlzdCgpfC4KCmdldG1hdGNoZXMoKQkJCQkJCSpnZXRtYXRjaGVzKCkqCgkJUmV0dXJucyBhIHxMaXN0fCB3aXRoIGFsbCBtYXRjaGVzIHByZXZpb3VzbHkgZGVmaW5lZCBieQoJCXxtYXRjaGFkZCgpfCBhbmQgdGhlIHw6bWF0Y2h8IGNvbW1hbmRzLiAgfGdldG1hdGNoZXMoKXwgaXMKCQl1c2VmdWwgaW4gY29tYmluYXRpb24gd2l0aCB8c2V0bWF0Y2hlcygpfCwgYXMgfHNldG1hdGNoZXMoKXwKCQljYW4gcmVzdG9yZSBhIGxpc3Qgb2YgbWF0Y2hlcyBzYXZlZCBieSB8Z2V0bWF0Y2hlcygpfC4KCQlFeGFtcGxlOiA+CgkJCTplY2hvIGdldG1hdGNoZXMoKQo8CQkJW3snZ3JvdXAnOiAnTXlHcm91cDEnLCAncGF0dGVybic6ICdUT0RPJywKCQkJJ3ByaW9yaXR5JzogMTAsICdpZCc6IDF9LCB7J2dyb3VwJzogJ015R3JvdXAyJywKCQkJJ3BhdHRlcm4nOiAnRklYTUUnLCAncHJpb3JpdHknOiAxMCwgJ2lkJzogMn1dID4KCQkJOmxldCBtID0gZ2V0bWF0Y2hlcygpCgkJCTpjYWxsIGNsZWFybWF0Y2hlcygpCgkJCTplY2hvIGdldG1hdGNoZXMoKQo8CQkJW10gPgoJCQk6Y2FsbCBzZXRtYXRjaGVzKG0pCgkJCTplY2hvIGdldG1hdGNoZXMoKQo8CQkJW3snZ3JvdXAnOiAnTXlHcm91cDEnLCAncGF0dGVybic6ICdUT0RPJywKCQkJJ3ByaW9yaXR5JzogMTAsICdpZCc6IDF9LCB7J2dyb3VwJzogJ015R3JvdXAyJywKCQkJJ3BhdHRlcm4nOiAnRklYTUUnLCAncHJpb3JpdHknOiAxMCwgJ2lkJzogMn1dID4KCQkJOnVubGV0IG0KPAoJCQkJCQkJKmdldHBpZCgpKgpnZXRwaWQoKQlSZXR1cm4gYSBOdW1iZXIgd2hpY2ggaXMgdGhlIHByb2Nlc3MgSUQgb2YgdGhlIFZpbSBwcm9jZXNzLgoJCU9uIFVuaXggYW5kIE1TLVdpbmRvd3MgdGhpcyBpcyBhIHVuaXF1ZSBudW1iZXIsIHVudGlsIFZpbQoJCWV4aXRzLglPbiBNUy1ET1MgaXQncyBhbHdheXMgemVyby4KCgkJCQkJCQkqZ2V0cG9zKCkqCmdldHBvcyh7ZXhwcn0pCUdldCB0aGUgcG9zaXRpb24gZm9yIHtleHByfS4gIEZvciBwb3NzaWJsZSB2YWx1ZXMgb2Yge2V4cHJ9CgkJc2VlIHxsaW5lKCl8LiAgRm9yIGdldHRpbmcgdGhlIGN1cnNvciBwb3NpdGlvbiBzZWUKCQl8Z2V0Y3VycG9zKCl8LgoJCVRoZSByZXN1bHQgaXMgYSB8TGlzdHwgd2l0aCBmb3VyIG51bWJlcnM6CgkJICAgIFtidWZudW0sIGxudW0sIGNvbCwgb2ZmXQoJCSJidWZudW0iIGlzIHplcm8sIHVubGVzcyBhIG1hcmsgbGlrZSAnMCBvciAnQSBpcyB1c2VkLCB0aGVuIGl0CgkJaXMgdGhlIGJ1ZmZlciBudW1iZXIgb2YgdGhlIG1hcmsuCgkJImxudW0iIGFuZCAiY29sIiBhcmUgdGhlIHBvc2l0aW9uIGluIHRoZSBidWZmZXIuICBUaGUgZmlyc3QKCQljb2x1bW4gaXMgMS4KCQlUaGUgIm9mZiIgbnVtYmVyIGlzIHplcm8sIHVubGVzcyAndmlydHVhbGVkaXQnIGlzIHVzZWQuICBUaGVuCgkJaXQgaXMgdGhlIG9mZnNldCBpbiBzY3JlZW4gY29sdW1ucyBmcm9tIHRoZSBzdGFydCBvZiB0aGUKCQljaGFyYWN0ZXIuICBFLmcuLCBhIHBvc2l0aW9uIHdpdGhpbiBhIDxUYWI+IG9yIGFmdGVyIHRoZSBsYXN0CgkJY2hhcmFjdGVyLgoJCU5vdGUgdGhhdCBmb3IgJzwgYW5kICc+IFZpc3VhbCBtb2RlIG1hdHRlcnM6IHdoZW4gaXQgaXMgIlYiCgkJKHZpc3VhbCBsaW5lIG1vZGUpIHRoZSBjb2x1bW4gb2YgJzwgaXMgemVybyBhbmQgdGhlIGNvbHVtbiBvZgoJCSc+IGlzIGEgbGFyZ2UgbnVtYmVyLgoJCVRoaXMgY2FuIGJlIHVzZWQgdG8gc2F2ZSBhbmQgcmVzdG9yZSB0aGUgcG9zaXRpb24gb2YgYSBtYXJrOiA+CgkJCWxldCBzYXZlX2FfbWFyayA9IGdldHBvcygiJ2EiKQoJCQkuLi4KCQkJY2FsbCBzZXRwb3MoIidhIiwgc2F2ZV9hX21hcmspCjwJCUFsc28gc2VlIHxnZXRjdXJwb3MoKXwgYW5kIHxzZXRwb3MoKXwuCgoKZ2V0cWZsaXN0KCkJCQkJCQkqZ2V0cWZsaXN0KCkqCgkJUmV0dXJucyBhIGxpc3Qgd2l0aCBhbGwgdGhlIGN1cnJlbnQgcXVpY2tmaXggZXJyb3JzLiAgRWFjaAoJCWxpc3QgaXRlbSBpcyBhIGRpY3Rpb25hcnkgd2l0aCB0aGVzZSBlbnRyaWVzOgoJCQlidWZucgludW1iZXIgb2YgYnVmZmVyIHRoYXQgaGFzIHRoZSBmaWxlIG5hbWUsIHVzZQoJCQkJYnVmbmFtZSgpIHRvIGdldCB0aGUgbmFtZQoJCQlsbnVtCWxpbmUgbnVtYmVyIGluIHRoZSBidWZmZXIgKGZpcnN0IGxpbmUgaXMgMSkKCQkJY29sCWNvbHVtbiBudW1iZXIgKGZpcnN0IGNvbHVtbiBpcyAxKQoJCQl2Y29sCW5vbi16ZXJvOiAiY29sIiBpcyB2aXN1YWwgY29sdW1uCgkJCQl6ZXJvOiAiY29sIiBpcyBieXRlIGluZGV4CgkJCW5yCWVycm9yIG51bWJlcgoJCQlwYXR0ZXJuCXNlYXJjaCBwYXR0ZXJuIHVzZWQgdG8gbG9jYXRlIHRoZSBlcnJvcgoJCQl0ZXh0CWRlc2NyaXB0aW9uIG9mIHRoZSBlcnJvcgoJCQl0eXBlCXR5cGUgb2YgdGhlIGVycm9yLCAnRScsICcxJywgZXRjLgoJCQl2YWxpZAlub24temVybzogcmVjb2duaXplZCBlcnJvciBtZXNzYWdlCgoJCVdoZW4gdGhlcmUgaXMgbm8gZXJyb3IgbGlzdCBvciBpdCdzIGVtcHR5IGFuIGVtcHR5IGxpc3QgaXMKCQlyZXR1cm5lZC4gUXVpY2tmaXggbGlzdCBlbnRyaWVzIHdpdGggbm9uLWV4aXN0aW5nIGJ1ZmZlcgoJCW51bWJlciBhcmUgcmV0dXJuZWQgd2l0aCAiYnVmbnIiIHNldCB0byB6ZXJvLgoKCQlVc2VmdWwgYXBwbGljYXRpb246IEZpbmQgcGF0dGVybiBtYXRjaGVzIGluIG11bHRpcGxlIGZpbGVzIGFuZAoJCWRvIHNvbWV0aGluZyB3aXRoIHRoZW06ID4KCQkJOnZpbWdyZXAgL3RoZXdvcmQvamcgKi5jCgkJCTpmb3IgZCBpbiBnZXRxZmxpc3QoKQoJCQk6ICAgZWNobyBidWZuYW1lKGQuYnVmbnIpICc6JyBkLmxudW0gJz0nIGQudGV4dAoJCQk6ZW5kZm9yCgoKZ2V0cmVnKFt7cmVnbmFtZX0gWywgMSBbLCB7bGlzdH1dXV0pCQkJKmdldHJlZygpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSBjb250ZW50cyBvZiByZWdpc3RlcgoJCXtyZWduYW1lfS4gIEV4YW1wbGU6ID4KCQkJOmxldCBjbGlwdGV4dCA9IGdldHJlZygnKicpCjwJCVdoZW4ge3JlZ25hbWV9IHdhcyBub3Qgc2V0IHRoZSByZXN1bHQgaXMgYSBlbXB0eSBzdHJpbmcuCgoJCWdldHJlZygnPScpIHJldHVybnMgdGhlIGxhc3QgZXZhbHVhdGVkIHZhbHVlIG9mIHRoZSBleHByZXNzaW9uCgkJcmVnaXN0ZXIuICAoRm9yIHVzZSBpbiBtYXBzLikKCQlnZXRyZWcoJz0nLCAxKSByZXR1cm5zIHRoZSBleHByZXNzaW9uIGl0c2VsZiwgc28gdGhhdCBpdCBjYW4KCQliZSByZXN0b3JlZCB3aXRoIHxzZXRyZWcoKXwuICBGb3Igb3RoZXIgcmVnaXN0ZXJzIHRoZSBleHRyYQoJCWFyZ3VtZW50IGlzIGlnbm9yZWQsIHRodXMgeW91IGNhbiBhbHdheXMgZ2l2ZSBpdC4KCgkJSWYge2xpc3R9IGlzIHByZXNlbnQgYW5kIG5vbi16ZXJvLCB0aGUgcmVzdWx0IHR5cGUgaXMgY2hhbmdlZAoJCXRvIHxMaXN0fC4gRWFjaCBsaXN0IGl0ZW0gaXMgb25lIHRleHQgbGluZS4gVXNlIGl0IGlmIHlvdSBjYXJlCgkJYWJvdXQgemVybyBieXRlcyBwb3NzaWJseSBwcmVzZW50IGluc2lkZSByZWdpc3Rlcjogd2l0aG91dAoJCXRoaXJkIGFyZ3VtZW50IGJvdGggTkxzIGFuZCB6ZXJvIGJ5dGVzIGFyZSByZXByZXNlbnRlZCBhcyBOTHMKCQkoc2VlIHxOTC11c2VkLWZvci1OdWx8KS4KCQlXaGVuIHRoZSByZWdpc3RlciB3YXMgbm90IHNldCBhbiBlbXB0eSBsaXN0IGlzIHJldHVybmVkLgoKCQlJZiB7cmVnbmFtZX0gaXMgbm90IHNwZWNpZmllZCwgfHY6cmVnaXN0ZXJ8IGlzIHVzZWQuCgoKZ2V0cmVndHlwZShbe3JlZ25hbWV9XSkJCQkJCSpnZXRyZWd0eXBlKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdHlwZSBvZiByZWdpc3RlciB7cmVnbmFtZX0uCgkJVGhlIHZhbHVlIHdpbGwgYmUgb25lIG9mOgoJCSAgICAidiIJCQlmb3IgfGNoYXJhY3Rlcndpc2V8IHRleHQKCQkgICAgIlYiCQkJZm9yIHxsaW5ld2lzZXwgdGV4dAoJCSAgICAiPENUUkwtVj57d2lkdGh9Iglmb3IgfGJsb2Nrd2lzZS12aXN1YWx8IHRleHQKCQkgICAgIiIJCQlmb3IgYW4gZW1wdHkgb3IgdW5rbm93biByZWdpc3RlcgoJCTxDVFJMLVY+IGlzIG9uZSBjaGFyYWN0ZXIgd2l0aCB2YWx1ZSAweDE2LgoJCUlmIHtyZWduYW1lfSBpcyBub3Qgc3BlY2lmaWVkLCB8djpyZWdpc3RlcnwgaXMgdXNlZC4KCmdldHRhYnZhcih7dGFibnJ9LCB7dmFybmFtZX0gWywge2RlZn1dKQkJCQkqZ2V0dGFidmFyKCkqCgkJR2V0IHRoZSB2YWx1ZSBvZiBhIHRhYi1sb2NhbCB2YXJpYWJsZSB7dmFybmFtZX0gaW4gdGFiIHBhZ2UKCQl7dGFibnJ9LiB8dDp2YXJ8CgkJVGFicyBhcmUgbnVtYmVyZWQgc3RhcnRpbmcgd2l0aCBvbmUuCgkJV2hlbiB7dmFybmFtZX0gaXMgZW1wdHkgYSBkaWN0aW9uYXJ5IHdpdGggYWxsIHRhYi1sb2NhbAoJCXZhcmlhYmxlcyBpcyByZXR1cm5lZC4KCQlOb3RlIHRoYXQgdGhlIG5hbWUgd2l0aG91dCAidDoiIG11c3QgYmUgdXNlZC4KCQlXaGVuIHRoZSB0YWIgb3IgdmFyaWFibGUgZG9lc24ndCBleGlzdCB7ZGVmfSBvciBhbiBlbXB0eQoJCXN0cmluZyBpcyByZXR1cm5lZCwgdGhlcmUgaXMgbm8gZXJyb3IgbWVzc2FnZS4KCmdldHRhYndpbnZhcih7dGFibnJ9LCB7d2lubnJ9LCB7dmFybmFtZX0gWywge2RlZn1dKQkJKmdldHRhYndpbnZhcigpKgoJCUdldCB0aGUgdmFsdWUgb2Ygd2luZG93LWxvY2FsIHZhcmlhYmxlIHt2YXJuYW1lfSBpbiB3aW5kb3cKCQl7d2lubnJ9IGluIHRhYiBwYWdlIHt0YWJucn0uCgkJV2hlbiB7dmFybmFtZX0gc3RhcnRzIHdpdGggIiYiIGdldCB0aGUgdmFsdWUgb2YgYSB3aW5kb3ctbG9jYWwKCQlvcHRpb24uCgkJV2hlbiB7dmFybmFtZX0gaXMgZW1wdHkgYSBkaWN0aW9uYXJ5IHdpdGggYWxsIHdpbmRvdy1sb2NhbAoJCXZhcmlhYmxlcyBpcyByZXR1cm5lZC4KCQlOb3RlIHRoYXQge3Zhcm5hbWV9IG11c3QgYmUgdGhlIG5hbWUgd2l0aG91dCAidzoiLgoJCVRhYnMgYXJlIG51bWJlcmVkIHN0YXJ0aW5nIHdpdGggb25lLiAgRm9yIHRoZSBjdXJyZW50IHRhYnBhZ2UKCQl1c2UgfGdldHdpbnZhcigpfC4KCQlXaGVuIHt3aW5ucn0gaXMgemVybyB0aGUgY3VycmVudCB3aW5kb3cgaXMgdXNlZC4KCQlUaGlzIGFsc28gd29ya3MgZm9yIGEgZ2xvYmFsIG9wdGlvbiwgYnVmZmVyLWxvY2FsIG9wdGlvbiBhbmQKCQl3aW5kb3ctbG9jYWwgb3B0aW9uLCBidXQgaXQgZG9lc24ndCB3b3JrIGZvciBhIGdsb2JhbCB2YXJpYWJsZQoJCW9yIGJ1ZmZlci1sb2NhbCB2YXJpYWJsZS4KCQlXaGVuIHRoZSB0YWIsIHdpbmRvdyBvciB2YXJpYWJsZSBkb2Vzbid0IGV4aXN0IHtkZWZ9IG9yIGFuCgkJZW1wdHkgc3RyaW5nIGlzIHJldHVybmVkLCB0aGVyZSBpcyBubyBlcnJvciBtZXNzYWdlLgoJCUV4YW1wbGVzOiA+CgkJCTpsZXQgbGlzdF9pc19vbiA9IGdldHRhYndpbnZhcigxLCAyLCAnJmxpc3QnKQoJCQk6ZWNobyAibXl2YXIgPSAiIC4gZ2V0dGFid2ludmFyKDMsIDEsICdteXZhcicpCjwKCQkJCQkJCSpnZXR3aW5wb3N4KCkqCmdldHdpbnBvc3goKQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgWCBjb29yZGluYXRlIGluIHBpeGVscyBvZgoJCXRoZSBsZWZ0IGhhbmQgc2lkZSBvZiB0aGUgR1VJIFZpbSB3aW5kb3cuICBUaGUgcmVzdWx0IHdpbGwgYmUKCQktMSBpZiB0aGUgaW5mb3JtYXRpb24gaXMgbm90IGF2YWlsYWJsZS4KCgkJCQkJCQkqZ2V0d2lucG9zeSgpKgpnZXR3aW5wb3N5KCkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIFkgY29vcmRpbmF0ZSBpbiBwaXhlbHMgb2YKCQl0aGUgdG9wIG9mIHRoZSBHVUkgVmltIHdpbmRvdy4JVGhlIHJlc3VsdCB3aWxsIGJlIC0xIGlmIHRoZQoJCWluZm9ybWF0aW9uIGlzIG5vdCBhdmFpbGFibGUuCgpnZXR3aW52YXIoe3dpbm5yfSwge3Zhcm5hbWV9IFssIHtkZWZ9XSkJCQkJKmdldHdpbnZhcigpKgoJCUxpa2UgfGdldHRhYndpbnZhcigpfCBmb3IgdGhlIGN1cnJlbnQgdGFicGFnZS4KCQlFeGFtcGxlczogPgoJCQk6bGV0IGxpc3RfaXNfb24gPSBnZXR3aW52YXIoMiwgJyZsaXN0JykKCQkJOmVjaG8gIm15dmFyID0gIiAuIGdldHdpbnZhcigxLCAnbXl2YXInKQo8Cmdsb2Ioe2V4cHJ9IFssIHtub3N1Zn0gWywge2xpc3R9IFssIHthbGxsaW5rc31dXV0pCQkqZ2xvYigpKgoJCUV4cGFuZCB0aGUgZmlsZSB3aWxkY2FyZHMgaW4ge2V4cHJ9LiAgU2VlIHx3aWxkY2FyZHN8IGZvciB0aGUKCQl1c2Ugb2Ygc3BlY2lhbCBjaGFyYWN0ZXJzLgoKCQlVbmxlc3MgdGhlIG9wdGlvbmFsIHtub3N1Zn0gYXJndW1lbnQgaXMgZ2l2ZW4gYW5kIGlzIG5vbi16ZXJvLAoJCXRoZSAnc3VmZml4ZXMnIGFuZCAnd2lsZGlnbm9yZScgb3B0aW9ucyBhcHBseTogTmFtZXMgbWF0Y2hpbmcKCQlvbmUgb2YgdGhlIHBhdHRlcm5zIGluICd3aWxkaWdub3JlJyB3aWxsIGJlIHNraXBwZWQgYW5kCgkJJ3N1ZmZpeGVzJyBhZmZlY3QgdGhlIG9yZGVyaW5nIG9mIG1hdGNoZXMuCgkJJ3dpbGRpZ25vcmVjYXNlJyBhbHdheXMgYXBwbGllcy4KCgkJV2hlbiB7bGlzdH0gaXMgcHJlc2VudCBhbmQgaXQgaXMgbm9uLXplcm8gdGhlIHJlc3VsdCBpcyBhIExpc3QKCQl3aXRoIGFsbCBtYXRjaGluZyBmaWxlcy4gVGhlIGFkdmFudGFnZSBvZiB1c2luZyBhIExpc3QgaXMsCgkJeW91IGFsc28gZ2V0IGZpbGVuYW1lcyBjb250YWluaW5nIG5ld2xpbmVzIGNvcnJlY3RseS4KCQlPdGhlcndpc2UgdGhlIHJlc3VsdCBpcyBhIFN0cmluZyBhbmQgd2hlbiB0aGVyZSBhcmUgc2V2ZXJhbAoJCW1hdGNoZXMsIHRoZXkgYXJlIHNlcGFyYXRlZCBieSA8Tkw+IGNoYXJhY3RlcnMuCgoJCUlmIHRoZSBleHBhbnNpb24gZmFpbHMsIHRoZSByZXN1bHQgaXMgYW4gZW1wdHkgU3RyaW5nIG9yIExpc3QuCgoJCUEgbmFtZSBmb3IgYSBub24tZXhpc3RpbmcgZmlsZSBpcyBub3QgaW5jbHVkZWQuICBBIHN5bWJvbGljCgkJbGluayBpcyBvbmx5IGluY2x1ZGVkIGlmIGl0IHBvaW50cyB0byBhbiBleGlzdGluZyBmaWxlLgoJCUhvd2V2ZXIsIHdoZW4gdGhlIHthbGxsaW5rc30gYXJndW1lbnQgaXMgcHJlc2VudCBhbmQgaXQgaXMKCQlub24temVybyB0aGVuIGFsbCBzeW1ib2xpYyBsaW5rcyBhcmUgaW5jbHVkZWQuCgoJCUZvciBtb3N0IHN5c3RlbXMgYmFja3RpY2tzIGNhbiBiZSB1c2VkIHRvIGdldCBmaWxlcyBuYW1lcyBmcm9tCgkJYW55IGV4dGVybmFsIGNvbW1hbmQuICBFeGFtcGxlOiA+CgkJCTpsZXQgdGFnZmlsZXMgPSBnbG9iKCJgZmluZCAuIC1uYW1lIHRhZ3MgLXByaW50YCIpCgkJCTpsZXQgJnRhZ3MgPSBzdWJzdGl0dXRlKHRhZ2ZpbGVzLCAiXG4iLCAiLCIsICJnIikKPAkJVGhlIHJlc3VsdCBvZiB0aGUgcHJvZ3JhbSBpbnNpZGUgdGhlIGJhY2t0aWNrcyBzaG91bGQgYmUgb25lCgkJaXRlbSBwZXIgbGluZS4JU3BhY2VzIGluc2lkZSBhbiBpdGVtIGFyZSBhbGxvd2VkLgoKCQlTZWUgfGV4cGFuZCgpfCBmb3IgZXhwYW5kaW5nIHNwZWNpYWwgVmltIHZhcmlhYmxlcy4gIFNlZQoJCXxzeXN0ZW0oKXwgZm9yIGdldHRpbmcgdGhlIHJhdyBvdXRwdXQgb2YgYW4gZXh0ZXJuYWwgY29tbWFuZC4KCmdsb2IycmVncGF0KHtleHByfSkJCQkJCSAqZ2xvYjJyZWdwYXQoKSoKCQlDb252ZXJ0IGEgZmlsZSBwYXR0ZXJuLCBhcyB1c2VkIGJ5IGdsb2IoKSwgaW50byBhIHNlYXJjaAoJCXBhdHRlcm4uICBUaGUgcmVzdWx0IGNhbiBiZSB1c2VkIHRvIG1hdGNoIHdpdGggYSBzdHJpbmcgdGhhdAoJCWlzIGEgZmlsZSBuYW1lLiAgRS5nLiA+CgkJCWlmIGZpbGVuYW1lID1+IGdsb2IycmVncGF0KCdNYWtlKi5tYWsnKQo8CQlUaGlzIGlzIGVxdWl2YWxlbnQgdG86ID4KCQkJaWYgZmlsZW5hbWUgPX4gJ15NYWtlLipcLm1hayQnCjwJCVdoZW4ge2V4cHJ9IGlzIGFuIGVtcHR5IHN0cmluZyB0aGUgcmVzdWx0IGlzICJeJCIsIG1hdGNoIGFuCgkJZW1wdHkgc3RyaW5nLgoKCQkJCQkJCQkqZ2xvYnBhdGgoKSoKZ2xvYnBhdGgoe3BhdGh9LCB7ZXhwcn0gWywge25vc3VmfSBbLCB7bGlzdH0gWywge2FsbGxpbmtzfV1dXSkKCQlQZXJmb3JtIGdsb2IoKSBvbiBhbGwgZGlyZWN0b3JpZXMgaW4ge3BhdGh9IGFuZCBjb25jYXRlbmF0ZQoJCXRoZSByZXN1bHRzLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBnbG9icGF0aCgmcnRwLCAic3ludGF4L2MudmltIikKPAoJCXtwYXRofSBpcyBhIGNvbW1hLXNlcGFyYXRlZCBsaXN0IG9mIGRpcmVjdG9yeSBuYW1lcy4gIEVhY2gKCQlkaXJlY3RvcnkgbmFtZSBpcyBwcmVwZW5kZWQgdG8ge2V4cHJ9IGFuZCBleHBhbmRlZCBsaWtlIHdpdGgKCQl8Z2xvYigpfC4gIEEgcGF0aCBzZXBhcmF0b3IgaXMgaW5zZXJ0ZWQgd2hlbiBuZWVkZWQuCgkJVG8gYWRkIGEgY29tbWEgaW5zaWRlIGEgZGlyZWN0b3J5IG5hbWUgZXNjYXBlIGl0IHdpdGggYQoJCWJhY2tzbGFzaC4gIE5vdGUgdGhhdCBvbiBNUy1XaW5kb3dzIGEgZGlyZWN0b3J5IG1heSBoYXZlIGEKCQl0cmFpbGluZyBiYWNrc2xhc2gsIHJlbW92ZSBpdCBpZiB5b3UgcHV0IGEgY29tbWEgYWZ0ZXIgaXQuCgkJSWYgdGhlIGV4cGFuc2lvbiBmYWlscyBmb3Igb25lIG9mIHRoZSBkaXJlY3RvcmllcywgdGhlcmUgaXMgbm8KCQllcnJvciBtZXNzYWdlLgoKCQlVbmxlc3MgdGhlIG9wdGlvbmFsIHtub3N1Zn0gYXJndW1lbnQgaXMgZ2l2ZW4gYW5kIGlzIG5vbi16ZXJvLAoJCXRoZSAnc3VmZml4ZXMnIGFuZCAnd2lsZGlnbm9yZScgb3B0aW9ucyBhcHBseTogTmFtZXMgbWF0Y2hpbmcKCQlvbmUgb2YgdGhlIHBhdHRlcm5zIGluICd3aWxkaWdub3JlJyB3aWxsIGJlIHNraXBwZWQgYW5kCgkJJ3N1ZmZpeGVzJyBhZmZlY3QgdGhlIG9yZGVyaW5nIG9mIG1hdGNoZXMuCgoJCVdoZW4ge2xpc3R9IGlzIHByZXNlbnQgYW5kIGl0IGlzIG5vbi16ZXJvIHRoZSByZXN1bHQgaXMgYSBMaXN0CgkJd2l0aCBhbGwgbWF0Y2hpbmcgZmlsZXMuIFRoZSBhZHZhbnRhZ2Ugb2YgdXNpbmcgYSBMaXN0IGlzLCB5b3UKCQlhbHNvIGdldCBmaWxlbmFtZXMgY29udGFpbmluZyBuZXdsaW5lcyBjb3JyZWN0bHkuIE90aGVyd2lzZQoJCXRoZSByZXN1bHQgaXMgYSBTdHJpbmcgYW5kIHdoZW4gdGhlcmUgYXJlIHNldmVyYWwgbWF0Y2hlcywKCQl0aGV5IGFyZSBzZXBhcmF0ZWQgYnkgPE5MPiBjaGFyYWN0ZXJzLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBnbG9icGF0aCgmcnRwLCAic3ludGF4L2MudmltIiwgMCwgMSkKPAoJCXthbGxsaW5rc30gaXMgdXNlZCBhcyB3aXRoIHxnbG9iKCl8LgoKCQlUaGUgIioqIiBpdGVtIGNhbiBiZSB1c2VkIHRvIHNlYXJjaCBpbiBhIGRpcmVjdG9yeSB0cmVlLgoJCUZvciBleGFtcGxlLCB0byBmaW5kIGFsbCAiUkVBRE1FLnR4dCIgZmlsZXMgaW4gdGhlIGRpcmVjdG9yaWVzCgkJaW4gJ3J1bnRpbWVwYXRoJyBhbmQgYmVsb3c6ID4KCQkJOmVjaG8gZ2xvYnBhdGgoJnJ0cCwgIioqL1JFQURNRS50eHQiKQo8CQlVcHdhcmRzIHNlYXJjaCBhbmQgbGltaXRpbmcgdGhlIGRlcHRoIG9mICIqKiIgaXMgbm90CgkJc3VwcG9ydGVkLCB0aHVzIHVzaW5nICdwYXRoJyB3aWxsIG5vdCBhbHdheXMgd29yayBwcm9wZXJseS4KCgkJCQkJCQkqaGFzKCkqCmhhcyh7ZmVhdHVyZX0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIDEgaWYgdGhlIGZlYXR1cmUge2ZlYXR1cmV9IGlzCgkJc3VwcG9ydGVkLCB6ZXJvIG90aGVyd2lzZS4gIFRoZSB7ZmVhdHVyZX0gYXJndW1lbnQgaXMgYQoJCXN0cmluZy4gIFNlZSB8ZmVhdHVyZS1saXN0fCBiZWxvdy4KCQlBbHNvIHNlZSB8ZXhpc3RzKCl8LgoKCmhhc19rZXkoe2RpY3R9LCB7a2V5fSkJCQkJCSpoYXNfa2V5KCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSBpZiB8RGljdGlvbmFyeXwge2RpY3R9IGhhcwoJCWFuIGVudHJ5IHdpdGgga2V5IHtrZXl9LiAgWmVybyBvdGhlcndpc2UuCgpoYXNsb2NhbGRpcihbe3dpbm5yfSBbLCB7dGFibnJ9XV0pCQkJKmhhc2xvY2FsZGlyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgMSB3aGVuIHRoZSB3aW5kb3cgaGFzIHNldCBhCgkJbG9jYWwgcGF0aCB2aWEgfDpsY2R8LCBhbmQgMCBvdGhlcndpc2UuCgoJCVdpdGhvdXQgYXJndW1lbnRzIHVzZSB0aGUgY3VycmVudCB3aW5kb3cuCgkJV2l0aCB7d2lubnJ9IHVzZSB0aGlzIHdpbmRvdyBpbiB0aGUgY3VycmVudCB0YWIgcGFnZS4KCQlXaXRoIHt3aW5ucn0gYW5kIHt0YWJucn0gdXNlIHRoZSB3aW5kb3cgaW4gdGhlIHNwZWNpZmllZCB0YWIKCQlwYWdlLgoJCVJldHVybiAwIGlmIHRoZSBhcmd1bWVudHMgYXJlIGludmFsaWQuCgpoYXNtYXB0byh7d2hhdH0gWywge21vZGV9IFssIHthYmJyfV1dKQkJCSpoYXNtYXB0bygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIDEgaWYgdGhlcmUgaXMgYSBtYXBwaW5nIHRoYXQKCQljb250YWlucyB7d2hhdH0gaW4gc29tZXdoZXJlIGluIHRoZSByaHMgKHdoYXQgaXQgaXMgbWFwcGVkIHRvKQoJCWFuZCB0aGlzIG1hcHBpbmcgZXhpc3RzIGluIG9uZSBvZiB0aGUgbW9kZXMgaW5kaWNhdGVkIGJ5CgkJe21vZGV9LgoJCVdoZW4ge2FiYnJ9IGlzIHRoZXJlIGFuZCBpdCBpcyBub24temVybyB1c2UgYWJicmV2aWF0aW9ucwoJCWluc3RlYWQgb2YgbWFwcGluZ3MuICBEb24ndCBmb3JnZXQgdG8gc3BlY2lmeSBJbnNlcnQgYW5kL29yCgkJQ29tbWFuZC1saW5lIG1vZGUuCgkJQm90aCB0aGUgZ2xvYmFsIG1hcHBpbmdzIGFuZCB0aGUgbWFwcGluZ3MgbG9jYWwgdG8gdGhlIGN1cnJlbnQKCQlidWZmZXIgYXJlIGNoZWNrZWQgZm9yIGEgbWF0Y2guCgkJSWYgbm8gbWF0Y2hpbmcgbWFwcGluZyBpcyBmb3VuZCAwIGlzIHJldHVybmVkLgoJCVRoZSBmb2xsb3dpbmcgY2hhcmFjdGVycyBhcmUgcmVjb2duaXplZCBpbiB7bW9kZX06CgkJCW4JTm9ybWFsIG1vZGUKCQkJdglWaXN1YWwgbW9kZQoJCQlvCU9wZXJhdG9yLXBlbmRpbmcgbW9kZQoJCQlpCUluc2VydCBtb2RlCgkJCWwJTGFuZ3VhZ2UtQXJndW1lbnQgKCJyIiwgImYiLCAidCIsIGV0Yy4pCgkJCWMJQ29tbWFuZC1saW5lIG1vZGUKCQlXaGVuIHttb2RlfSBpcyBvbWl0dGVkLCAibnZvIiBpcyB1c2VkLgoKCQlUaGlzIGZ1bmN0aW9uIGlzIHVzZWZ1bCB0byBjaGVjayBpZiBhIG1hcHBpbmcgYWxyZWFkeSBleGlzdHMKCQl0byBhIGZ1bmN0aW9uIGluIGEgVmltIHNjcmlwdC4JRXhhbXBsZTogPgoJCQk6aWYgIWhhc21hcHRvKCdcQUJDZG9pdCcpCgkJCTogICBtYXAgPExlYWRlcj5kIFxBQkNkb2l0CgkJCTplbmRpZgo8CQlUaGlzIGluc3RhbGxzIHRoZSBtYXBwaW5nIHRvICJcQUJDZG9pdCIgb25seSBpZiB0aGVyZSBpc24ndAoJCWFscmVhZHkgYSBtYXBwaW5nIHRvICJcQUJDZG9pdCIuCgpoaXN0YWRkKHtoaXN0b3J5fSwge2l0ZW19KQkJCQkqaGlzdGFkZCgpKgoJCUFkZCB0aGUgU3RyaW5nIHtpdGVtfSB0byB0aGUgaGlzdG9yeSB7aGlzdG9yeX0gd2hpY2ggY2FuIGJlCgkJb25lIG9mOgkJCQkJKmhpc3QtbmFtZXMqCgkJCSJjbWQiCSBvciAiOiIJICBjb21tYW5kIGxpbmUgaGlzdG9yeQoJCQkic2VhcmNoIiBvciAiLyIgICBzZWFyY2ggcGF0dGVybiBoaXN0b3J5CgkJCSJleHByIgkgb3IgIj0iICAgdHlwZWQgZXhwcmVzc2lvbiBoaXN0b3J5CgkJCSJpbnB1dCIgIG9yICJAIgkgIGlucHV0IGxpbmUgaGlzdG9yeQoJCQkiZGVidWciICBvciAiPiIgICBkZWJ1ZyBjb21tYW5kIGhpc3RvcnkKCQlUaGUge2hpc3Rvcnl9IHN0cmluZyBkb2VzIG5vdCBuZWVkIHRvIGJlIHRoZSB3aG9sZSBuYW1lLCBvbmUKCQljaGFyYWN0ZXIgaXMgc3VmZmljaWVudC4KCQlJZiB7aXRlbX0gZG9lcyBhbHJlYWR5IGV4aXN0IGluIHRoZSBoaXN0b3J5LCBpdCB3aWxsIGJlCgkJc2hpZnRlZCB0byBiZWNvbWUgdGhlIG5ld2VzdCBlbnRyeS4KCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyOiAxIGlmIHRoZSBvcGVyYXRpb24gd2FzIHN1Y2Nlc3NmdWwsCgkJb3RoZXJ3aXNlIDAgaXMgcmV0dXJuZWQuCgoJCUV4YW1wbGU6ID4KCQkJOmNhbGwgaGlzdGFkZCgiaW5wdXQiLCBzdHJmdGltZSgiJVkgJWIgJWQiKSkKCQkJOmxldCBkYXRlPWlucHV0KCJFbnRlciBkYXRlOiAiKQo8CQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCmhpc3RkZWwoe2hpc3Rvcnl9IFssIHtpdGVtfV0pCQkJCSpoaXN0ZGVsKCkqCgkJQ2xlYXIge2hpc3Rvcnl9LCBpLmUuIGRlbGV0ZSBhbGwgaXRzIGVudHJpZXMuICBTZWUgfGhpc3QtbmFtZXN8CgkJZm9yIHRoZSBwb3NzaWJsZSB2YWx1ZXMgb2Yge2hpc3Rvcnl9LgoKCQlJZiB0aGUgcGFyYW1ldGVyIHtpdGVtfSBldmFsdWF0ZXMgdG8gYSBTdHJpbmcsIGl0IGlzIHVzZWQgYXMgYQoJCXJlZ3VsYXIgZXhwcmVzc2lvbi4gIEFsbCBlbnRyaWVzIG1hdGNoaW5nIHRoYXQgZXhwcmVzc2lvbiB3aWxsCgkJYmUgcmVtb3ZlZCBmcm9tIHRoZSBoaXN0b3J5IChpZiB0aGVyZSBhcmUgYW55KS4KCQlVcHBlci9sb3dlcmNhc2UgbXVzdCBtYXRjaCwgdW5sZXNzICJcYyIgaXMgdXNlZCB8L1xjfC4KCQlJZiB7aXRlbX0gZXZhbHVhdGVzIHRvIGEgTnVtYmVyLCBpdCB3aWxsIGJlIGludGVycHJldGVkIGFzCgkJYW4gaW5kZXgsIHNlZSB8Omhpc3RvcnktaW5kZXhpbmd8LiAgVGhlIHJlc3BlY3RpdmUgZW50cnkgd2lsbAoJCWJlIHJlbW92ZWQgaWYgaXQgZXhpc3RzLgoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyOiAxIGZvciBhIHN1Y2Nlc3NmdWwgb3BlcmF0aW9uLAoJCW90aGVyd2lzZSAwIGlzIHJldHVybmVkLgoKCQlFeGFtcGxlczoKCQlDbGVhciBleHByZXNzaW9uIHJlZ2lzdGVyIGhpc3Rvcnk6ID4KCQkJOmNhbGwgaGlzdGRlbCgiZXhwciIpCjwKCQlSZW1vdmUgYWxsIGVudHJpZXMgc3RhcnRpbmcgd2l0aCAiKiIgZnJvbSB0aGUgc2VhcmNoIGhpc3Rvcnk6ID4KCQkJOmNhbGwgaGlzdGRlbCgiLyIsICdeXConKQo8CgkJVGhlIGZvbGxvd2luZyB0aHJlZSBhcmUgZXF1aXZhbGVudDogPgoJCQk6Y2FsbCBoaXN0ZGVsKCJzZWFyY2giLCBoaXN0bnIoInNlYXJjaCIpKQoJCQk6Y2FsbCBoaXN0ZGVsKCJzZWFyY2giLCAtMSkKCQkJOmNhbGwgaGlzdGRlbCgic2VhcmNoIiwgJ14nLmhpc3RnZXQoInNlYXJjaCIsIC0xKS4nJCcpCjwKCQlUbyBkZWxldGUgdGhlIGxhc3Qgc2VhcmNoIHBhdHRlcm4gYW5kIHVzZSB0aGUgbGFzdC1idXQtb25lIGZvcgoJCXRoZSAibiIgY29tbWFuZCBhbmQgJ2hsc2VhcmNoJzogPgoJCQk6Y2FsbCBoaXN0ZGVsKCJzZWFyY2giLCAtMSkKCQkJOmxldCBALyA9IGhpc3RnZXQoInNlYXJjaCIsIC0xKQoKaGlzdGdldCh7aGlzdG9yeX0gWywge2luZGV4fV0pCQkJCSpoaXN0Z2V0KCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgdGhlIGVudHJ5IHdpdGggTnVtYmVyIHtpbmRleH0gZnJvbQoJCXtoaXN0b3J5fS4gIFNlZSB8aGlzdC1uYW1lc3wgZm9yIHRoZSBwb3NzaWJsZSB2YWx1ZXMgb2YKCQl7aGlzdG9yeX0sIGFuZCB8Omhpc3RvcnktaW5kZXhpbmd8IGZvciB7aW5kZXh9LiAgSWYgdGhlcmUgaXMKCQlubyBzdWNoIGVudHJ5LCBhbiBlbXB0eSBTdHJpbmcgaXMgcmV0dXJuZWQuICBXaGVuIHtpbmRleH0gaXMKCQlvbWl0dGVkLCB0aGUgbW9zdCByZWNlbnQgaXRlbSBmcm9tIHRoZSBoaXN0b3J5IGlzIHVzZWQuCgoJCUV4YW1wbGVzOgoJCVJlZG8gdGhlIHNlY29uZCBsYXN0IHNlYXJjaCBmcm9tIGhpc3RvcnkuID4KCQkJOmV4ZWN1dGUgJy8nIC4gaGlzdGdldCgic2VhcmNoIiwgLTIpCgo8CQlEZWZpbmUgYW4gRXggY29tbWFuZCAiOkgge251bX0iIHRoYXQgc3VwcG9ydHMgcmUtZXhlY3V0aW9uIG9mCgkJdGhlIHtudW19dGggZW50cnkgZnJvbSB0aGUgb3V0cHV0IG9mIHw6aGlzdG9yeXwuID4KCQkJOmNvbW1hbmQgLW5hcmdzPTEgSCBleGVjdXRlIGhpc3RnZXQoImNtZCIsIDArPGFyZ3M+KQo8Cmhpc3Rucih7aGlzdG9yeX0pCQkJCQkqaGlzdG5yKCkqCgkJVGhlIHJlc3VsdCBpcyB0aGUgTnVtYmVyIG9mIHRoZSBjdXJyZW50IGVudHJ5IGluIHtoaXN0b3J5fS4KCQlTZWUgfGhpc3QtbmFtZXN8IGZvciB0aGUgcG9zc2libGUgdmFsdWVzIG9mIHtoaXN0b3J5fS4KCQlJZiBhbiBlcnJvciBvY2N1cnJlZCwgLTEgaXMgcmV0dXJuZWQuCgoJCUV4YW1wbGU6ID4KCQkJOmxldCBpbnBfaW5kZXggPSBoaXN0bnIoImV4cHIiKQo8CmhsZXhpc3RzKHtuYW1lfSkJCQkJCSpobGV4aXN0cygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIGlmIGEgaGlnaGxpZ2h0IGdyb3VwCgkJY2FsbGVkIHtuYW1lfSBleGlzdHMuICBUaGlzIGlzIHdoZW4gdGhlIGdyb3VwIGhhcyBiZWVuCgkJZGVmaW5lZCBpbiBzb21lIHdheS4gIE5vdCBuZWNlc3NhcmlseSB3aGVuIGhpZ2hsaWdodGluZyBoYXMKCQliZWVuIGRlZmluZWQgZm9yIGl0LCBpdCBtYXkgYWxzbyBoYXZlIGJlZW4gdXNlZCBmb3IgYSBzeW50YXgKCQlpdGVtLgoJCQkJCQkJKmhpZ2hsaWdodF9leGlzdHMoKSoKCQlPYnNvbGV0ZSBuYW1lOiBoaWdobGlnaHRfZXhpc3RzKCkuCgoJCQkJCQkJKmhsSUQoKSoKaGxJRCh7bmFtZX0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBJRCBvZiB0aGUgaGlnaGxpZ2h0IGdyb3VwCgkJd2l0aCBuYW1lIHtuYW1lfS4gIFdoZW4gdGhlIGhpZ2hsaWdodCBncm91cCBkb2Vzbid0IGV4aXN0LAoJCXplcm8gaXMgcmV0dXJuZWQuCgkJVGhpcyBjYW4gYmUgdXNlZCB0byByZXRyaWV2ZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgaGlnaGxpZ2h0CgkJZ3JvdXAuCUZvciBleGFtcGxlLCB0byBnZXQgdGhlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlCgkJIkNvbW1lbnQiIGdyb3VwOiA+Cgk6ZWNobyBzeW5JRGF0dHIoc3luSUR0cmFucyhobElEKCJDb21tZW50IikpLCAiYmciKQo8CQkJCQkJCSpoaWdobGlnaHRJRCgpKgoJCU9ic29sZXRlIG5hbWU6IGhpZ2hsaWdodElEKCkuCgpob3N0bmFtZSgpCQkJCQkJKmhvc3RuYW1lKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIG5hbWUgb2YgdGhlIG1hY2hpbmUgb24KCQl3aGljaCBWaW0gaXMgY3VycmVudGx5IHJ1bm5pbmcuICBNYWNoaW5lIG5hbWVzIGdyZWF0ZXIgdGhhbgoJCTI1NiBjaGFyYWN0ZXJzIGxvbmcgYXJlIHRydW5jYXRlZC4KCmljb252KHtleHByfSwge2Zyb219LCB7dG99KQkJCQkqaWNvbnYoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB0aGUgdGV4dCB7ZXhwcn0gY29udmVydGVkCgkJZnJvbSBlbmNvZGluZyB7ZnJvbX0gdG8gZW5jb2Rpbmcge3RvfS4KCQlXaGVuIHRoZSBjb252ZXJzaW9uIGNvbXBsZXRlbHkgZmFpbHMgYW4gZW1wdHkgc3RyaW5nIGlzCgkJcmV0dXJuZWQuICBXaGVuIHNvbWUgY2hhcmFjdGVycyBjb3VsZCBub3QgYmUgY29udmVydGVkIHRoZXkKCQlhcmUgcmVwbGFjZWQgd2l0aCAiPyIuCgkJVGhlIGVuY29kaW5nIG5hbWVzIGFyZSB3aGF0ZXZlciB0aGUgaWNvbnYoKSBsaWJyYXJ5IGZ1bmN0aW9uCgkJY2FuIGFjY2VwdCwgc2VlICI6IW1hbiAzIGljb252Ii4KCQlNb3N0IGNvbnZlcnNpb25zIHJlcXVpcmUgVmltIHRvIGJlIGNvbXBpbGVkIHdpdGggdGhlIHwraWNvbnZ8CgkJZmVhdHVyZS4gIE90aGVyd2lzZSBvbmx5IFVURi04IHRvIGxhdGluMSBjb252ZXJzaW9uIGFuZCBiYWNrCgkJY2FuIGJlIGRvbmUuCgkJVGhpcyBjYW4gYmUgdXNlZCB0byBkaXNwbGF5IG1lc3NhZ2VzIHdpdGggc3BlY2lhbCBjaGFyYWN0ZXJzLAoJCW5vIG1hdHRlciB3aGF0ICdlbmNvZGluZycgaXMgc2V0IHRvLiAgV3JpdGUgdGhlIG1lc3NhZ2UgaW4KCQlVVEYtOCBhbmQgdXNlOiA+CgkJCWVjaG8gaWNvbnYodXRmOF9zdHIsICJ1dGYtOCIsICZlbmMpCjwJCU5vdGUgdGhhdCBWaW0gdXNlcyBVVEYtOCBmb3IgYWxsIFVuaWNvZGUgZW5jb2RpbmdzLCBjb252ZXJzaW9uCgkJZnJvbS90byBVQ1MtMiBpcyBhdXRvbWF0aWNhbGx5IGNoYW5nZWQgdG8gdXNlIFVURi04LiAgWW91CgkJY2Fubm90IHVzZSBVQ1MtMiBpbiBhIHN0cmluZyBhbnl3YXksIGJlY2F1c2Ugb2YgdGhlIE5VTCBieXRlcy4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K211bHRpX2J5dGV8IGZlYXR1cmV9CgoJCQkJCQkJKmluZGVudCgpKgppbmRlbnQoe2xudW19KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyBpbmRlbnQgb2YgbGluZSB7bG51bX0gaW4gdGhlCgkJY3VycmVudCBidWZmZXIuICBUaGUgaW5kZW50IGlzIGNvdW50ZWQgaW4gc3BhY2VzLCB0aGUgdmFsdWUKCQlvZiAndGFic3RvcCcgaXMgcmVsZXZhbnQuICB7bG51bX0gaXMgdXNlZCBqdXN0IGxpa2UgaW4KCQl8Z2V0bGluZSgpfC4KCQlXaGVuIHtsbnVtfSBpcyBpbnZhbGlkIC0xIGlzIHJldHVybmVkLgoKCmluZGV4KHtsaXN0fSwge2V4cHJ9IFssIHtzdGFydH0gWywge2ljfV1dKQkJCSppbmRleCgpKgoJCVJldHVybiB0aGUgbG93ZXN0IGluZGV4IGluIHxMaXN0fCB7bGlzdH0gd2hlcmUgdGhlIGl0ZW0gaGFzIGEKCQl2YWx1ZSBlcXVhbCB0byB7ZXhwcn0uICBUaGVyZSBpcyBubyBhdXRvbWF0aWMgY29udmVyc2lvbiwgc28KCQl0aGUgU3RyaW5nICI0IiBpcyBkaWZmZXJlbnQgZnJvbSB0aGUgTnVtYmVyIDQuICBBbmQgdGhlIG51bWJlcgoJCTQgaXMgZGlmZmVyZW50IGZyb20gdGhlIEZsb2F0IDQuMC4gIFRoZSB2YWx1ZSBvZiAnaWdub3JlY2FzZScKCQlpcyBub3QgdXNlZCBoZXJlLCBjYXNlIGFsd2F5cyBtYXR0ZXJzLgoJCUlmIHtzdGFydH0gaXMgZ2l2ZW4gdGhlbiBzdGFydCBsb29raW5nIGF0IHRoZSBpdGVtIHdpdGggaW5kZXgKCQl7c3RhcnR9IChtYXkgYmUgbmVnYXRpdmUgZm9yIGFuIGl0ZW0gcmVsYXRpdmUgdG8gdGhlIGVuZCkuCgkJV2hlbiB7aWN9IGlzIGdpdmVuIGFuZCBpdCBpcyBub24temVybywgaWdub3JlIGNhc2UuICBPdGhlcndpc2UKCQljYXNlIG11c3QgbWF0Y2guCgkJLTEgaXMgcmV0dXJuZWQgd2hlbiB7ZXhwcn0gaXMgbm90IGZvdW5kIGluIHtsaXN0fS4KCQlFeGFtcGxlOiA+CgkJCTpsZXQgaWR4ID0gaW5kZXgod29yZHMsICJ0aGUiKQoJCQk6aWYgaW5kZXgobnVtYmVycywgMTIzKSA+PSAwCgoKaW5wdXQoe3Byb21wdH0gWywge3RleHR9IFssIHtjb21wbGV0aW9ufV1dKQkJKmlucHV0KCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgd2hhdGV2ZXIgdGhlIHVzZXIgdHlwZWQgb24KCQl0aGUgY29tbWFuZC1saW5lLiAgVGhlIHtwcm9tcHR9IGFyZ3VtZW50IGlzIGVpdGhlciBhIHByb21wdAoJCXN0cmluZywgb3IgYSBibGFuayBzdHJpbmcgKGZvciBubyBwcm9tcHQpLiAgQSAnXG4nIGNhbiBiZSB1c2VkCgkJaW4gdGhlIHByb21wdCB0byBzdGFydCBhIG5ldyBsaW5lLgoJCVRoZSBoaWdobGlnaHRpbmcgc2V0IHdpdGggfDplY2hvaGx8IGlzIHVzZWQgZm9yIHRoZSBwcm9tcHQuCgkJVGhlIGlucHV0IGlzIGVudGVyZWQganVzdCBsaWtlIGEgY29tbWFuZC1saW5lLCB3aXRoIHRoZSBzYW1lCgkJZWRpdGluZyBjb21tYW5kcyBhbmQgbWFwcGluZ3MuCVRoZXJlIGlzIGEgc2VwYXJhdGUgaGlzdG9yeQoJCWZvciBsaW5lcyB0eXBlZCBmb3IgaW5wdXQoKS4KCQlFeGFtcGxlOiA+CgkJCTppZiBpbnB1dCgiQ29mZmVlIG9yIGJlZXI/ICIpID09ICJiZWVyIgoJCQk6ICBlY2hvICJDaGVlcnMhIgoJCQk6ZW5kaWYKPAoJCUlmIHRoZSBvcHRpb25hbCB7dGV4dH0gYXJndW1lbnQgaXMgcHJlc2VudCBhbmQgbm90IGVtcHR5LCB0aGlzCgkJaXMgdXNlZCBmb3IgdGhlIGRlZmF1bHQgcmVwbHksIGFzIGlmIHRoZSB1c2VyIHR5cGVkIHRoaXMuCgkJRXhhbXBsZTogPgoJCQk6bGV0IGNvbG9yID0gaW5wdXQoIkNvbG9yPyAiLCAid2hpdGUiKQoKPAkJVGhlIG9wdGlvbmFsIHtjb21wbGV0aW9ufSBhcmd1bWVudCBzcGVjaWZpZXMgdGhlIHR5cGUgb2YKCQljb21wbGV0aW9uIHN1cHBvcnRlZCBmb3IgdGhlIGlucHV0LiAgV2l0aG91dCBpdCBjb21wbGV0aW9uIGlzCgkJbm90IHBlcmZvcm1lZC4JVGhlIHN1cHBvcnRlZCBjb21wbGV0aW9uIHR5cGVzIGFyZSB0aGUgc2FtZSBhcwoJCXRoYXQgY2FuIGJlIHN1cHBsaWVkIHRvIGEgdXNlci1kZWZpbmVkIGNvbW1hbmQgdXNpbmcgdGhlCgkJIi1jb21wbGV0ZT0iIGFyZ3VtZW50LglSZWZlciB0byB8OmNvbW1hbmQtY29tcGxldGlvbnwgZm9yCgkJbW9yZSBpbmZvcm1hdGlvbi4gIEV4YW1wbGU6ID4KCQkJbGV0IGZuYW1lID0gaW5wdXQoIkZpbGU6ICIsICIiLCAiZmlsZSIpCjwKCQlOT1RFOiBUaGlzIGZ1bmN0aW9uIG11c3Qgbm90IGJlIHVzZWQgaW4gYSBzdGFydHVwIGZpbGUsIGZvcgoJCXRoZSB2ZXJzaW9ucyB0aGF0IG9ubHkgcnVuIGluIEdVSSBtb2RlIChlLmcuLCB0aGUgV2luMzIgR1VJKS4KCQlOb3RlOiBXaGVuIGlucHV0KCkgaXMgY2FsbGVkIGZyb20gd2l0aGluIGEgbWFwcGluZyBpdCB3aWxsCgkJY29uc3VtZSByZW1haW5pbmcgY2hhcmFjdGVycyBmcm9tIHRoYXQgbWFwcGluZywgYmVjYXVzZSBhCgkJbWFwcGluZyBpcyBoYW5kbGVkIGxpa2UgdGhlIGNoYXJhY3RlcnMgd2VyZSB0eXBlZC4KCQlVc2UgfGlucHV0c2F2ZSgpfCBiZWZvcmUgaW5wdXQoKSBhbmQgfGlucHV0cmVzdG9yZSgpfAoJCWFmdGVyIGlucHV0KCkgdG8gYXZvaWQgdGhhdC4gIEFub3RoZXIgc29sdXRpb24gaXMgdG8gYXZvaWQKCQl0aGF0IGZ1cnRoZXIgY2hhcmFjdGVycyBmb2xsb3cgaW4gdGhlIG1hcHBpbmcsIGUuZy4sIGJ5IHVzaW5nCgkJfDpleGVjdXRlfCBvciB8Om5vcm1hbHwuCgoJCUV4YW1wbGUgd2l0aCBhIG1hcHBpbmc6ID4KCQkJOm5tYXAgXHggOmNhbGwgR2V0Rm9vKCk8Q1I+OmV4ZSAiLyIgLiBGb288Q1I+CgkJCTpmdW5jdGlvbiBHZXRGb28oKQoJCQk6ICBjYWxsIGlucHV0c2F2ZSgpCgkJCTogIGxldCBnOkZvbyA9IGlucHV0KCJlbnRlciBzZWFyY2ggcGF0dGVybjogIikKCQkJOiAgY2FsbCBpbnB1dHJlc3RvcmUoKQoJCQk6ZW5kZnVuY3Rpb24KCmlucHV0ZGlhbG9nKHtwcm9tcHR9IFssIHt0ZXh0fSBbLCB7Y2FuY2VscmV0dXJufV1dKQkJKmlucHV0ZGlhbG9nKCkqCgkJTGlrZSB8aW5wdXQoKXwsIGJ1dCB3aGVuIHRoZSBHVUkgaXMgcnVubmluZyBhbmQgdGV4dCBkaWFsb2dzCgkJYXJlIHN1cHBvcnRlZCwgYSBkaWFsb2cgd2luZG93IHBvcHMgdXAgdG8gaW5wdXQgdGhlIHRleHQuCgkJRXhhbXBsZTogPgoJCSAgIDpsZXQgbiA9IGlucHV0ZGlhbG9nKCJ2YWx1ZSBmb3Igc2hpZnR3aWR0aCIsIHNoaWZ0d2lkdGgoKSkKCQkgICA6aWYgbiAhPSAiIgoJCSAgIDogIGxldCAmc3cgPSBuCgkJICAgOmVuZGlmCjwJCVdoZW4gdGhlIGRpYWxvZyBpcyBjYW5jZWxsZWQge2NhbmNlbHJldHVybn0gaXMgcmV0dXJuZWQuICBXaGVuCgkJb21pdHRlZCBhbiBlbXB0eSBzdHJpbmcgaXMgcmV0dXJuZWQuCgkJSGl0dGluZyA8RW50ZXI+IHdvcmtzIGxpa2UgcHJlc3NpbmcgdGhlIE9LIGJ1dHRvbi4gIEhpdHRpbmcKCQk8RXNjPiB3b3JrcyBsaWtlIHByZXNzaW5nIHRoZSBDYW5jZWwgYnV0dG9uLgoJCU5PVEU6IENvbW1hbmQtbGluZSBjb21wbGV0aW9uIGlzIG5vdCBzdXBwb3J0ZWQuCgppbnB1dGxpc3Qoe3RleHRsaXN0fSkJCQkJCSppbnB1dGxpc3QoKSoKCQl7dGV4dGxpc3R9IG11c3QgYmUgYSB8TGlzdHwgb2Ygc3RyaW5ncy4gIFRoaXMgfExpc3R8IGlzCgkJZGlzcGxheWVkLCBvbmUgc3RyaW5nIHBlciBsaW5lLiAgVGhlIHVzZXIgd2lsbCBiZSBwcm9tcHRlZCB0bwoJCWVudGVyIGEgbnVtYmVyLCB3aGljaCBpcyByZXR1cm5lZC4KCQlUaGUgdXNlciBjYW4gYWxzbyBzZWxlY3QgYW4gaXRlbSBieSBjbGlja2luZyBvbiBpdCB3aXRoIHRoZQoJCW1vdXNlLglGb3IgdGhlIGZpcnN0IHN0cmluZyAwIGlzIHJldHVybmVkLiAgV2hlbiBjbGlja2luZwoJCWFib3ZlIHRoZSBmaXJzdCBpdGVtIGEgbmVnYXRpdmUgbnVtYmVyIGlzIHJldHVybmVkLiAgV2hlbgoJCWNsaWNraW5nIG9uIHRoZSBwcm9tcHQgb25lIG1vcmUgdGhhbiB0aGUgbGVuZ3RoIG9mIHt0ZXh0bGlzdH0KCQlpcyByZXR1cm5lZC4KCQlNYWtlIHN1cmUge3RleHRsaXN0fSBoYXMgbGVzcyB0aGFuICdsaW5lcycgZW50cmllcywgb3RoZXJ3aXNlCgkJaXQgd29uJ3Qgd29yay4JSXQncyBhIGdvb2QgaWRlYSB0byBwdXQgdGhlIGVudHJ5IG51bWJlciBhdAoJCXRoZSBzdGFydCBvZiB0aGUgc3RyaW5nLiAgQW5kIHB1dCBhIHByb21wdCBpbiB0aGUgZmlyc3QgaXRlbS4KCQlFeGFtcGxlOiA+CgkJCWxldCBjb2xvciA9IGlucHV0bGlzdChbJ1NlbGVjdCBjb2xvcjonLCAnMS4gcmVkJywKCQkJCVwgJzIuIGdyZWVuJywgJzMuIGJsdWUnXSkKCmlucHV0cmVzdG9yZSgpCQkJCQkJKmlucHV0cmVzdG9yZSgpKgoJCVJlc3RvcmUgdHlwZWFoZWFkIHRoYXQgd2FzIHNhdmVkIHdpdGggYSBwcmV2aW91cyB8aW5wdXRzYXZlKCl8LgoJCVNob3VsZCBiZSBjYWxsZWQgdGhlIHNhbWUgbnVtYmVyIG9mIHRpbWVzIGlucHV0c2F2ZSgpIGlzCgkJY2FsbGVkLiAgQ2FsbGluZyBpdCBtb3JlIG9mdGVuIGlzIGhhcm1sZXNzIHRob3VnaC4KCQlSZXR1cm5zIDEgd2hlbiB0aGVyZSBpcyBub3RoaW5nIHRvIHJlc3RvcmUsIDAgb3RoZXJ3aXNlLgoKaW5wdXRzYXZlKCkJCQkJCQkqaW5wdXRzYXZlKCkqCgkJUHJlc2VydmUgdHlwZWFoZWFkIChhbHNvIGZyb20gbWFwcGluZ3MpIGFuZCBjbGVhciBpdCwgc28gdGhhdAoJCWEgZm9sbG93aW5nIHByb21wdCBnZXRzIGlucHV0IGZyb20gdGhlIHVzZXIuICBTaG91bGQgYmUKCQlmb2xsb3dlZCBieSBhIG1hdGNoaW5nIGlucHV0cmVzdG9yZSgpIGFmdGVyIHRoZSBwcm9tcHQuICBDYW4KCQliZSB1c2VkIHNldmVyYWwgdGltZXMsIGluIHdoaWNoIGNhc2UgdGhlcmUgbXVzdCBiZSBqdXN0IGFzCgkJbWFueSBpbnB1dHJlc3RvcmUoKSBjYWxscy4KCQlSZXR1cm5zIDEgd2hlbiBvdXQgb2YgbWVtb3J5LCAwIG90aGVyd2lzZS4KCmlucHV0c2VjcmV0KHtwcm9tcHR9IFssIHt0ZXh0fV0pCQkJKmlucHV0c2VjcmV0KCkqCgkJVGhpcyBmdW5jdGlvbiBhY3RzIG11Y2ggbGlrZSB0aGUgfGlucHV0KCl8IGZ1bmN0aW9uIHdpdGggYnV0CgkJdHdvIGV4Y2VwdGlvbnM6CgkJYSkgdGhlIHVzZXIncyByZXNwb25zZSB3aWxsIGJlIGRpc3BsYXllZCBhcyBhIHNlcXVlbmNlIG9mCgkJYXN0ZXJpc2tzICgiKiIpIHRoZXJlYnkga2VlcGluZyB0aGUgZW50cnkgc2VjcmV0LCBhbmQKCQliKSB0aGUgdXNlcidzIHJlc3BvbnNlIHdpbGwgbm90IGJlIHJlY29yZGVkIG9uIHRoZSBpbnB1dAoJCXxoaXN0b3J5fCBzdGFjay4KCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB3aGF0ZXZlciB0aGUgdXNlciBhY3R1YWxseQoJCXR5cGVkIG9uIHRoZSBjb21tYW5kLWxpbmUgaW4gcmVzcG9uc2UgdG8gdGhlIGlzc3VlZCBwcm9tcHQuCgkJTk9URTogQ29tbWFuZC1saW5lIGNvbXBsZXRpb24gaXMgbm90IHN1cHBvcnRlZC4KCmluc2VydCh7bGlzdH0sIHtpdGVtfSBbLCB7aWR4fV0pCQkJKmluc2VydCgpKgoJCUluc2VydCB7aXRlbX0gYXQgdGhlIHN0YXJ0IG9mIHxMaXN0fCB7bGlzdH0uCgkJSWYge2lkeH0gaXMgc3BlY2lmaWVkIGluc2VydCB7aXRlbX0gYmVmb3JlIHRoZSBpdGVtIHdpdGggaW5kZXgKCQl7aWR4fS4JSWYge2lkeH0gaXMgemVybyBpdCBnb2VzIGJlZm9yZSB0aGUgZmlyc3QgaXRlbSwganVzdAoJCWxpa2Ugb21pdHRpbmcge2lkeH0uICBBIG5lZ2F0aXZlIHtpZHh9IGlzIGFsc28gcG9zc2libGUsIHNlZQoJCXxsaXN0LWluZGV4fC4gIC0xIGluc2VydHMganVzdCBiZWZvcmUgdGhlIGxhc3QgaXRlbS4KCQlSZXR1cm5zIHRoZSByZXN1bHRpbmcgfExpc3R8LiAgRXhhbXBsZXM6ID4KCQkJOmxldCBteWxpc3QgPSBpbnNlcnQoWzIsIDMsIDVdLCAxKQoJCQk6Y2FsbCBpbnNlcnQobXlsaXN0LCA0LCAtMSkKCQkJOmNhbGwgaW5zZXJ0KG15bGlzdCwgNiwgbGVuKG15bGlzdCkpCjwJCVRoZSBsYXN0IGV4YW1wbGUgY2FuIGJlIGRvbmUgc2ltcGxlciB3aXRoIHxhZGQoKXwuCgkJTm90ZSB0aGF0IHdoZW4ge2l0ZW19IGlzIGEgfExpc3R8IGl0IGlzIGluc2VydGVkIGFzIGEgc2luZ2xlCgkJaXRlbS4gIFVzZSB8ZXh0ZW5kKCl8IHRvIGNvbmNhdGVuYXRlIHxMaXN0c3wuCgppbnZlcnQoe2V4cHJ9KQkJCQkJCSppbnZlcnQoKSoKCQlCaXR3aXNlIGludmVydC4gIFRoZSBhcmd1bWVudCBpcyBjb252ZXJ0ZWQgdG8gYSBudW1iZXIuICBBCgkJTGlzdCwgRGljdCBvciBGbG9hdCBhcmd1bWVudCBjYXVzZXMgYW4gZXJyb3IuICBFeGFtcGxlOiA+CgkJCTpsZXQgYml0cyA9IGludmVydChiaXRzKQoKaXNkaXJlY3Rvcnkoe2RpcmVjdG9yeX0pCQkJCSppc2RpcmVjdG9yeSgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIHdoZW4gYSBkaXJlY3RvcnkKCQl3aXRoIHRoZSBuYW1lIHtkaXJlY3Rvcnl9IGV4aXN0cy4gIElmIHtkaXJlY3Rvcnl9IGRvZXNuJ3QKCQlleGlzdCwgb3IgaXNuJ3QgYSBkaXJlY3RvcnksIHRoZSByZXN1bHQgaXMgRkFMU0UuICB7ZGlyZWN0b3J5fQoJCWlzIGFueSBleHByZXNzaW9uLCB3aGljaCBpcyB1c2VkIGFzIGEgU3RyaW5nLgoKaXNsb2NrZWQoe2V4cHJ9KQkJCQkJKmlzbG9ja2VkKCkqICpFNzg2KgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIG5vbi16ZXJvIHdoZW4ge2V4cHJ9IGlzIHRoZQoJCW5hbWUgb2YgYSBsb2NrZWQgdmFyaWFibGUuCgkJe2V4cHJ9IG11c3QgYmUgdGhlIG5hbWUgb2YgYSB2YXJpYWJsZSwgfExpc3R8IGl0ZW0gb3IKCQl8RGljdGlvbmFyeXwgZW50cnksIG5vdCB0aGUgdmFyaWFibGUgaXRzZWxmISAgRXhhbXBsZTogPgoJCQk6bGV0IGFsaXN0ID0gWzAsIFsnYScsICdiJ10sIDIsIDNdCgkJCTpsb2NrdmFyIDEgYWxpc3QKCQkJOmVjaG8gaXNsb2NrZWQoJ2FsaXN0JykJCSIgMQoJCQk6ZWNobyBpc2xvY2tlZCgnYWxpc3RbMV0nKQkiIDAKCjwJCVdoZW4ge2V4cHJ9IGlzIGEgdmFyaWFibGUgdGhhdCBkb2VzIG5vdCBleGlzdCB5b3UgZ2V0IGFuIGVycm9yCgkJbWVzc2FnZS4gIFVzZSB8ZXhpc3RzKCl8IHRvIGNoZWNrIGZvciBleGlzdGVuY2UuCgppc25hbih7ZXhwcn0pCQkJCQkJKmlzbmFuKCkqCgkJUmV0dXJuIG5vbi16ZXJvIGlmIHtleHByfSBpcyBhIGZsb2F0IHdpdGggdmFsdWUgTmFOLiA+CgkJCWVjaG8gaXNuYW4oMC4wIC8gMC4wKQo8CQkJMSB+CgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgppdGVtcyh7ZGljdH0pCQkJCQkJKml0ZW1zKCkqCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggYWxsIHRoZSBrZXktdmFsdWUgcGFpcnMgb2Yge2RpY3R9LiAgRWFjaAoJCXxMaXN0fCBpdGVtIGlzIGEgbGlzdCB3aXRoIHR3byBpdGVtczogdGhlIGtleSBvZiBhIHtkaWN0fQoJCWVudHJ5IGFuZCB0aGUgdmFsdWUgb2YgdGhpcyBlbnRyeS4gIFRoZSB8TGlzdHwgaXMgaW4gYXJiaXRyYXJ5CgkJb3JkZXIuCgpqb2JfZ2V0Y2hhbm5lbCh7am9ifSkJCQkJCSAqam9iX2dldGNoYW5uZWwoKSoKCQlHZXQgdGhlIGNoYW5uZWwgaGFuZGxlIHRoYXQge2pvYn0gaXMgdXNpbmcuCgkJVG8gY2hlY2sgaWYgdGhlIGpvYiBoYXMgbm8gY2hhbm5lbDogPgoJCQlpZiBzdHJpbmcoam9iX2dldGNoYW5uZWwoKSkgPT0gJ2NoYW5uZWwgZmFpbCcKPAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwram9ifCBmZWF0dXJlfQoKam9iX2luZm8oe2pvYn0pCQkJCQkJKmpvYl9pbmZvKCkqCgkJUmV0dXJucyBhIERpY3Rpb25hcnkgd2l0aCBpbmZvcm1hdGlvbiBhYm91dCB7am9ifToKCQkgICAic3RhdHVzIgl3aGF0IHxqb2Jfc3RhdHVzKCl8IHJldHVybnMKCQkgICAiY2hhbm5lbCIJd2hhdCB8am9iX2dldGNoYW5uZWwoKXwgcmV0dXJucwoJCSAgICJleGl0dmFsIglvbmx5IHZhbGlkIHdoZW4gInN0YXR1cyIgaXMgImRlYWQiCgkJICAgImV4aXRfY2IiCWZ1bmN0aW9uIHRvIGJlIGNhbGxlZCBvbiBleGl0CgkJICAgInN0b3BvbmV4aXQiCXxqb2Itc3RvcG9uZXhpdHwKCmpvYl9zZXRvcHRpb25zKHtqb2J9LCB7b3B0aW9uc30pCQkJKmpvYl9zZXRvcHRpb25zKCkqCgkJQ2hhbmdlIG9wdGlvbnMgZm9yIHtqb2J9LiAgU3VwcG9ydGVkIGFyZToKCQkgICAic3RvcG9uZXhpdCIJfGpvYi1zdG9wb25leGl0fAoJCSAgICJleGl0X2NiIgl8am9iLWV4aXRfY2J8Cgpqb2Jfc3RhcnQoe2NvbW1hbmR9IFssIHtvcHRpb25zfV0pCQkJKmpvYl9zdGFydCgpKgoJCVN0YXJ0IGEgam9iIGFuZCByZXR1cm4gYSBKb2Igb2JqZWN0LiAgVW5saWtlIHxzeXN0ZW0oKXwgYW5kCgkJfDohY21kfCB0aGlzIGRvZXMgbm90IHdhaXQgZm9yIHRoZSBqb2IgdG8gZmluaXNoLgoKCQl7Y29tbWFuZH0gY2FuIGJlIGEgU3RyaW5nLiAgVGhpcyB3b3JrcyBiZXN0IG9uIE1TLVdpbmRvd3MuICBPbgoJCVVuaXggaXQgaXMgc3BsaXQgdXAgaW4gd2hpdGUtc2VwYXJhdGVkIHBhcnRzIHRvIGJlIHBhc3NlZCB0bwoJCWV4ZWN2cCgpLiAgQXJndW1lbnRzIGluIGRvdWJsZSBxdW90ZXMgY2FuIGNvbnRhaW4gd2hpdGUgc3BhY2UuCgoJCXtjb21tYW5kfSBjYW4gYmUgYSBMaXN0LCB3aGVyZSB0aGUgZmlyc3QgaXRlbSBpcyB0aGUgZXhlY3V0YWJsZQoJCWFuZCBmdXJ0aGVyIGl0ZW1zIGFyZSB0aGUgYXJndW1lbnRzLiAgQWxsIGl0ZW1zIGFyZSBjb252ZXJ0ZWQKCQl0byBTdHJpbmcuICBUaGlzIHdvcmtzIGJlc3Qgb24gVW5peC4KCgkJT24gTVMtV2luZG93cywgam9iX3N0YXJ0KCkgbWFrZXMgYSBHVUkgYXBwbGljYXRpb24gaGlkZGVuLiBJZgoJCXdhbnQgdG8gc2hvdyBpdCwgVXNlIHw6IXN0YXJ0fCBpbnN0ZWFkLgoKCQlUaGUgY29tbWFuZCBpcyBleGVjdXRlZCBkaXJlY3RseSwgbm90IHRocm91Z2ggYSBzaGVsbCwgdGhlCgkJJ3NoZWxsJyBvcHRpb24gaXMgbm90IHVzZWQuICBUbyB1c2UgdGhlIHNoZWxsOiA+CglsZXQgam9iID0gam9iX3N0YXJ0KFsiL2Jpbi9zaCIsICItYyIsICJlY2hvIGhlbGxvIl0pCjwJCU9yOiA+CglsZXQgam9iID0gam9iX3N0YXJ0KCcvYmluL3NoIC1jICJlY2hvIGhlbGxvIicpCjwJCU5vdGUgdGhhdCB0aGlzIHdpbGwgc3RhcnQgdHdvIHByb2Nlc3NlcywgdGhlIHNoZWxsIGFuZCB0aGUKCQljb21tYW5kIGl0IGV4ZWN1dGVzLiAgSWYgeW91IGRvbid0IHdhbnQgdGhpcyB1c2UgdGhlICJleGVjIgoJCXNoZWxsIGNvbW1hbmQuCgoJCU9uIFVuaXggJFBBVEggaXMgdXNlZCB0byBzZWFyY2ggZm9yIHRoZSBleGVjdXRhYmxlIG9ubHkgd2hlbgoJCXRoZSBjb21tYW5kIGRvZXMgbm90IGNvbnRhaW4gYSBzbGFzaC4KCgkJVGhlIGpvYiB3aWxsIHVzZSB0aGUgc2FtZSB0ZXJtaW5hbCBhcyBWaW0uICBJZiBpdCByZWFkcyBmcm9tCgkJc3RkaW4gdGhlIGpvYiBhbmQgVmltIHdpbGwgYmUgZmlnaHRpbmcgb3ZlciBpbnB1dCwgdGhhdAoJCWRvZXNuJ3Qgd29yay4gIFJlZGlyZWN0IHN0ZGluIGFuZCBzdGRvdXQgdG8gYXZvaWQgcHJvYmxlbXM6ID4KCWxldCBqb2IgPSBqb2Jfc3RhcnQoWydzaCcsICctYycsICJteXNlcnZlciA8L2Rldi9udWxsID4vZGV2L251bGwiXSkKPAoJCVRoZSByZXR1cm5lZCBKb2Igb2JqZWN0IGNhbiBiZSB1c2VkIHRvIGdldCB0aGUgc3RhdHVzIHdpdGgKCQl8am9iX3N0YXR1cygpfCBhbmQgc3RvcCB0aGUgam9iIHdpdGggfGpvYl9zdG9wKCl8LgoKCQl7b3B0aW9uc30gbXVzdCBiZSBhIERpY3Rpb25hcnkuICBJdCBjYW4gY29udGFpbiBtYW55IG9wdGlvbmFsCgkJaXRlbXMsIHNlZSB8am9iLW9wdGlvbnN8LgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2pvYnwgZmVhdHVyZX0KCmpvYl9zdGF0dXMoe2pvYn0pCQkJCQkqam9iX3N0YXR1cygpKiAqRTkxNioKCQlSZXR1cm5zIGEgU3RyaW5nIHdpdGggdGhlIHN0YXR1cyBvZiB7am9ifToKCQkJInJ1biIJam9iIGlzIHJ1bm5pbmcKCQkJImZhaWwiCWpvYiBmYWlsZWQgdG8gc3RhcnQKCQkJImRlYWQiCWpvYiBkaWVkIG9yIHdhcyBzdG9wcGVkIGFmdGVyIHJ1bm5pbmcKCQkKCQlJZiBhbiBleGl0IGNhbGxiYWNrIHdhcyBzZXQgd2l0aCB0aGUgImV4aXRfY2IiIG9wdGlvbiBhbmQgdGhlCgkJam9iIGlzIG5vdyBkZXRlY3RlZCB0byBiZSAiZGVhZCIgdGhlIGNhbGxiYWNrIHdpbGwgYmUgaW52b2tlZC4KCgkJRm9yIG1vcmUgaW5mb3JtYXRpb24gc2VlIHxqb2JfaW5mbygpfC4KCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtqb2J8IGZlYXR1cmV9Cgpqb2Jfc3RvcCh7am9ifSBbLCB7aG93fV0pCQkJCQkqam9iX3N0b3AoKSoKCQlTdG9wIHRoZSB7am9ifS4gIFRoaXMgY2FuIGFsc28gYmUgdXNlZCB0byBzaWduYWwgdGhlIGpvYi4KCgkJV2hlbiB7aG93fSBpcyBvbWl0dGVkIG9yIGlzICJ0ZXJtIiB0aGUgam9iIHdpbGwgYmUgdGVybWluYXRlZC4KCQlGb3IgVW5peCBTSUdURVJNIGlzIHNlbnQuICBPbiBNUy1XaW5kb3dzIHRoZSBqb2Igd2lsbCBiZQoJCXRlcm1pbmF0ZWQgZm9yY2VkbHkgKHRoZXJlIGlzIG5vICJnZW50bGUiIHdheSkuCgkJVGhpcyBnb2VzIHRvIHRoZSBwcm9jZXNzIGdyb3VwLCB0aHVzIGNoaWxkcmVuIG1heSBhbHNvIGJlCgkJYWZmZWN0ZWQuCgoJCUVmZmVjdCBmb3IgVW5peDoKCQkJInRlcm0iCSBTSUdURVJNIChkZWZhdWx0KQoJCQkiaHVwIgkgU0lHSFVQCgkJCSJxdWl0IgkgU0lHUVVJVAoJCQkiaW50IgkgU0lHSU5UCgkJCSJraWxsIgkgU0lHS0lMTCAoc3Ryb25nZXN0IHdheSB0byBzdG9wKQoJCQludW1iZXIJIHNpZ25hbCB3aXRoIHRoYXQgbnVtYmVyCgoJCUVmZmVjdCBmb3IgTVMtV2luZG93czoKCQkJInRlcm0iCSB0ZXJtaW5hdGUgcHJvY2VzcyBmb3JjZWRseSAoZGVmYXVsdCkKCQkJImh1cCIJIENUUkxfQlJFQUsKCQkJInF1aXQiCSBDVFJMX0JSRUFLCgkJCSJpbnQiCSBDVFJMX0MKCQkJImtpbGwiCSB0ZXJtaW5hdGUgcHJvY2VzcyBmb3JjZWRseQoJCQlPdGhlcnMJIENUUkxfQlJFQUsKCgkJT24gVW5peCB0aGUgc2lnbmFsIGlzIHNlbnQgdG8gdGhlIHByb2Nlc3MgZ3JvdXAuICBUaGlzIG1lYW5zCgkJdGhhdCB3aGVuIHRoZSBqb2IgaXMgInNoIC1jIGNvbW1hbmQiIGl0IGFmZmVjdHMgYm90aCB0aGUgc2hlbGwKCQlhbmQgdGhlIGNvbW1hbmQuCgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXI6IDEgaWYgdGhlIG9wZXJhdGlvbiBjb3VsZCBiZSBleGVjdXRlZCwKCQkwIGlmICJob3ciIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhlIHN5c3RlbS4KCQlOb3RlIHRoYXQgZXZlbiB3aGVuIHRoZSBvcGVyYXRpb24gd2FzIGV4ZWN1dGVkLCB3aGV0aGVyIHRoZQoJCWpvYiB3YXMgYWN0dWFsbHkgc3RvcHBlZCBuZWVkcyB0byBiZSBjaGVja2VkIHdpdGgKCQlqb2Jfc3RhdHVzKCkuCgkJVGhlIHN0YXR1cyBvZiB0aGUgam9iIGlzbid0IGNoZWNrZWQsIHRoZSBvcGVyYXRpb24gd2lsbCBldmVuCgkJYmUgZG9uZSB3aGVuIFZpbSB0aGlua3MgdGhlIGpvYiBpc24ndCBydW5uaW5nLgoKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2pvYnwgZmVhdHVyZX0KCmpvaW4oe2xpc3R9IFssIHtzZXB9XSkJCQkJCSpqb2luKCkqCgkJSm9pbiB0aGUgaXRlbXMgaW4ge2xpc3R9IHRvZ2V0aGVyIGludG8gb25lIFN0cmluZy4KCQlXaGVuIHtzZXB9IGlzIHNwZWNpZmllZCBpdCBpcyBwdXQgaW4gYmV0d2VlbiB0aGUgaXRlbXMuICBJZgoJCXtzZXB9IGlzIG9taXR0ZWQgYSBzaW5nbGUgc3BhY2UgaXMgdXNlZC4KCQlOb3RlIHRoYXQge3NlcH0gaXMgbm90IGFkZGVkIGF0IHRoZSBlbmQuICBZb3UgbWlnaHQgd2FudCB0bwoJCWFkZCBpdCB0aGVyZSB0b286ID4KCQkJbGV0IGxpbmVzID0gam9pbihteWxpc3QsICJcbiIpIC4gIlxuIgo8CQlTdHJpbmcgaXRlbXMgYXJlIHVzZWQgYXMtaXMuICB8TGlzdHN8IGFuZCB8RGljdGlvbmFyaWVzfCBhcmUKCQljb252ZXJ0ZWQgaW50byBhIHN0cmluZyBsaWtlIHdpdGggfHN0cmluZygpfC4KCQlUaGUgb3Bwb3NpdGUgZnVuY3Rpb24gaXMgfHNwbGl0KCl8LgoKanNfZGVjb2RlKHtzdHJpbmd9KQkJCQkJKmpzX2RlY29kZSgpKgoJCVRoaXMgaXMgc2ltaWxhciB0byB8anNvbl9kZWNvZGUoKXwgd2l0aCB0aGVzZSBkaWZmZXJlbmNlczoKCQktIE9iamVjdCBrZXkgbmFtZXMgZG8gbm90IGhhdmUgdG8gYmUgaW4gcXVvdGVzLgoJCS0gRW1wdHkgaXRlbXMgaW4gYW4gYXJyYXkgKGJldHdlZW4gdHdvIGNvbW1hcykgYXJlIGFsbG93ZWQgYW5kCgkJICByZXN1bHQgaW4gdjpub25lIGl0ZW1zLgoKanNfZW5jb2RlKHtleHByfSkJCQkJCSpqc19lbmNvZGUoKSoKCQlUaGlzIGlzIHNpbWlsYXIgdG8gfGpzb25fZW5jb2RlKCl8IHdpdGggdGhlc2UgZGlmZmVyZW5jZXM6CgkJLSBPYmplY3Qga2V5IG5hbWVzIGFyZSBub3QgaW4gcXVvdGVzLgoJCS0gdjpub25lIGl0ZW1zIGluIGFuIGFycmF5IHJlc3VsdCBpbiBhbiBlbXB0eSBpdGVtIGJldHdlZW4KCQkgIGNvbW1hcy4KCQlGb3IgZXhhbXBsZSwgdGhlIFZpbSBvYmplY3Q6CgkJCVsxLHY6bm9uZSx7Im9uZSI6MX0sdjpub25lXSB+CgkJV2lsbCBiZSBlbmNvZGVkIGFzOgoJCQlbMSwse29uZToxfSwsXSB+CgkJV2hpbGUganNvbl9lbmNvZGUoKSB3b3VsZCBwcm9kdWNlOgoJCQlbMSxudWxsLHsib25lIjoxfSxudWxsXSB+CgkJVGhpcyBlbmNvZGluZyBpcyB2YWxpZCBmb3IgSmF2YVNjcmlwdC4gSXQgaXMgbW9yZSBlZmZpY2llbnQKCQl0aGFuIEpTT04sIGVzcGVjaWFsbHkgd2hlbiB1c2luZyBhbiBhcnJheSB3aXRoIG9wdGlvbmFsIGl0ZW1zLgoKCmpzb25fZGVjb2RlKHtzdHJpbmd9KQkJCQkJKmpzb25fZGVjb2RlKCkqCgkJVGhpcyBwYXJzZXMgYSBKU09OIGZvcm1hdHRlZCBzdHJpbmcgYW5kIHJldHVybnMgdGhlIGVxdWl2YWxlbnQKCQlpbiBWaW0gdmFsdWVzLiAgU2VlIHxqc29uX2VuY29kZSgpfCBmb3IgdGhlIHJlbGF0aW9uIGJldHdlZW4KCQlKU09OIGFuZCBWaW0gdmFsdWVzLgoJCVRoZSBkZWNvZGluZyBpcyBwZXJtaXNzaXZlOgoJCS0gQSB0cmFpbGluZyBjb21tYSBpbiBhbiBhcnJheSBhbmQgb2JqZWN0IGlzIGlnbm9yZWQuCgkJLSBNb3JlIGZsb2F0aW5nIHBvaW50IG51bWJlcnMgYXJlIHJlY29nbml6ZWQsIGUuZy4gIjEuIiBmb3IKCQkgICIxLjAiLgoJCVRoZSByZXN1bHQgbXVzdCBiZSBhIHZhbGlkIFZpbSB0eXBlOgoJCS0gQW4gZW1wdHkgb2JqZWN0IG1lbWJlciBuYW1lIGlzIG5vdCBhbGxvd2VkLgoJCS0gRHVwbGljYXRlIG9iamVjdCBtZW1iZXIgbmFtZXMgYXJlIG5vdCBhbGxvd2VkLgoKanNvbl9lbmNvZGUoe2V4cHJ9KQkJCQkJKmpzb25fZW5jb2RlKCkqCgkJRW5jb2RlIHtleHByfSBhcyBKU09OIGFuZCByZXR1cm4gdGhpcyBhcyBhIHN0cmluZy4KCQlUaGUgZW5jb2RpbmcgaXMgc3BlY2lmaWVkIGluOgoJCWh0dHBzOi8vdG9vbHMuaWV0Zi5vcmcvaHRtbC9yZmM3MTU5Lmh0bWwKCQlWaW0gdmFsdWVzIGFyZSBjb252ZXJ0ZWQgYXMgZm9sbG93czoKCQkgICBOdW1iZXIJCWRlY2ltYWwgbnVtYmVyCgkJICAgRmxvYXQJCWZsb2F0aW5nIHBvaW50IG51bWJlcgoJCSAgIEZsb2F0IG5hbgkJIk5hTiIKCQkgICBGbG9hdCBpbmYJCSJJbmZpbml0eSIKCQkgICBTdHJpbmcJCWluIGRvdWJsZSBxdW90ZXMgKHBvc3NpYmx5IG51bGwpCgkJICAgRnVuY3JlZgkJbm90IHBvc3NpYmxlLCBlcnJvcgoJCSAgIExpc3QJCQlhcyBhbiBhcnJheSAocG9zc2libHkgbnVsbCk7IHdoZW4KCQkJCQl1c2VkIHJlY3Vyc2l2ZWx5OiBbXQoJCSAgIERpY3QJCQlhcyBhbiBvYmplY3QgKHBvc3NpYmx5IG51bGwpOyB3aGVuCgkJCQkJdXNlZCByZWN1cnNpdmVseToge30KCQkgICB2OmZhbHNlCQkiZmFsc2UiCgkJICAgdjp0cnVlCQkidHJ1ZSIKCQkgICB2Om5vbmUJCSJudWxsIgoJCSAgIHY6bnVsbAkJIm51bGwiCgkJTm90ZSB0aGF0IE5hTiBhbmQgSW5maW5pdHkgYXJlIHBhc3NlZCBvbiBhcyB2YWx1ZXMuICBUaGlzIGlzCgkJbWlzc2luZyBpbiB0aGUgSlNPTiBzdGFuZGFyZCwgYnV0IHNldmVyYWwgaW1wbGVtZW50YXRpb25zIGRvCgkJYWxsb3cgaXQuICBJZiBub3QgdGhlbiB5b3Ugd2lsbCBnZXQgYW4gZXJyb3IuCgprZXlzKHtkaWN0fSkJCQkJCQkqa2V5cygpKgoJCVJldHVybiBhIHxMaXN0fCB3aXRoIGFsbCB0aGUga2V5cyBvZiB7ZGljdH0uICBUaGUgfExpc3R8IGlzIGluCgkJYXJiaXRyYXJ5IG9yZGVyLgoKCQkJCQkJCSpsZW4oKSogKkU3MDEqCmxlbih7ZXhwcn0pCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBsZW5ndGggb2YgdGhlIGFyZ3VtZW50LgoJCVdoZW4ge2V4cHJ9IGlzIGEgU3RyaW5nIG9yIGEgTnVtYmVyIHRoZSBsZW5ndGggaW4gYnl0ZXMgaXMKCQl1c2VkLCBhcyB3aXRoIHxzdHJsZW4oKXwuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgdGhlIG51bWJlciBvZiBpdGVtcyBpbiB0aGUgfExpc3R8IGlzCgkJcmV0dXJuZWQuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8RGljdGlvbmFyeXwgdGhlIG51bWJlciBvZiBlbnRyaWVzIGluIHRoZQoJCXxEaWN0aW9uYXJ5fCBpcyByZXR1cm5lZC4KCQlPdGhlcndpc2UgYW4gZXJyb3IgaXMgZ2l2ZW4uCgoJCQkJCQkqbGliY2FsbCgpKiAqRTM2NCogKkUzNjgqCmxpYmNhbGwoe2xpYm5hbWV9LCB7ZnVuY25hbWV9LCB7YXJndW1lbnR9KQoJCUNhbGwgZnVuY3Rpb24ge2Z1bmNuYW1lfSBpbiB0aGUgcnVuLXRpbWUgbGlicmFyeSB7bGlibmFtZX0KCQl3aXRoIHNpbmdsZSBhcmd1bWVudCB7YXJndW1lbnR9LgoJCVRoaXMgaXMgdXNlZnVsIHRvIGNhbGwgZnVuY3Rpb25zIGluIGEgbGlicmFyeSB0aGF0IHlvdQoJCWVzcGVjaWFsbHkgbWFkZSB0byBiZSB1c2VkIHdpdGggVmltLiAgU2luY2Ugb25seSBvbmUgYXJndW1lbnQKCQlpcyBwb3NzaWJsZSwgY2FsbGluZyBzdGFuZGFyZCBsaWJyYXJ5IGZ1bmN0aW9ucyBpcyByYXRoZXIKCQlsaW1pdGVkLgoJCVRoZSByZXN1bHQgaXMgdGhlIFN0cmluZyByZXR1cm5lZCBieSB0aGUgZnVuY3Rpb24uICBJZiB0aGUKCQlmdW5jdGlvbiByZXR1cm5zIE5VTEwsIHRoaXMgd2lsbCBhcHBlYXIgYXMgYW4gZW1wdHkgc3RyaW5nICIiCgkJdG8gVmltLgoJCUlmIHRoZSBmdW5jdGlvbiByZXR1cm5zIGEgbnVtYmVyLCB1c2UgbGliY2FsbG5yKCkhCgkJSWYge2FyZ3VtZW50fSBpcyBhIG51bWJlciwgaXQgaXMgcGFzc2VkIHRvIHRoZSBmdW5jdGlvbiBhcyBhbgoJCWludDsgaWYge2FyZ3VtZW50fSBpcyBhIHN0cmluZywgaXQgaXMgcGFzc2VkIGFzIGEKCQludWxsLXRlcm1pbmF0ZWQgc3RyaW5nLgoJCVRoaXMgZnVuY3Rpb24gd2lsbCBmYWlsIGluIHxyZXN0cmljdGVkLW1vZGV8LgoKCQlsaWJjYWxsKCkgYWxsb3dzIHlvdSB0byB3cml0ZSB5b3VyIG93biAncGx1Zy1pbicgZXh0ZW5zaW9ucyB0bwoJCVZpbSB3aXRob3V0IGhhdmluZyB0byByZWNvbXBpbGUgdGhlIHByb2dyYW0uICBJdCBpcyBOT1QgYQoJCW1lYW5zIHRvIGNhbGwgc3lzdGVtIGZ1bmN0aW9ucyEgIElmIHlvdSB0cnkgdG8gZG8gc28gVmltIHdpbGwKCQl2ZXJ5IHByb2JhYmx5IGNyYXNoLgoKCQlGb3IgV2luMzIsIHRoZSBmdW5jdGlvbnMgeW91IHdyaXRlIG11c3QgYmUgcGxhY2VkIGluIGEgRExMCgkJYW5kIHVzZSB0aGUgbm9ybWFsIEMgY2FsbGluZyBjb252ZW50aW9uIChOT1QgUGFzY2FsIHdoaWNoIGlzCgkJdXNlZCBpbiBXaW5kb3dzIFN5c3RlbSBETExzKS4gIFRoZSBmdW5jdGlvbiBtdXN0IHRha2UgZXhhY3RseQoJCW9uZSBwYXJhbWV0ZXIsIGVpdGhlciBhIGNoYXJhY3RlciBwb2ludGVyIG9yIGEgbG9uZyBpbnRlZ2VyLAoJCWFuZCBtdXN0IHJldHVybiBhIGNoYXJhY3RlciBwb2ludGVyIG9yIE5VTEwuICBUaGUgY2hhcmFjdGVyCgkJcG9pbnRlciByZXR1cm5lZCBtdXN0IHBvaW50IHRvIG1lbW9yeSB0aGF0IHdpbGwgcmVtYWluIHZhbGlkCgkJYWZ0ZXIgdGhlIGZ1bmN0aW9uIGhhcyByZXR1cm5lZCAoZS5nLiBpbiBzdGF0aWMgZGF0YSBpbiB0aGUKCQlETEwpLiAgSWYgaXQgcG9pbnRzIHRvIGFsbG9jYXRlZCBtZW1vcnksIHRoYXQgbWVtb3J5IHdpbGwKCQlsZWFrIGF3YXkuICBVc2luZyBhIHN0YXRpYyBidWZmZXIgaW4gdGhlIGZ1bmN0aW9uIHNob3VsZCB3b3JrLAoJCWl0J3MgdGhlbiBmcmVlZCB3aGVuIHRoZSBETEwgaXMgdW5sb2FkZWQuCgoJCVdBUk5JTkc6IElmIHRoZSBmdW5jdGlvbiByZXR1cm5zIGEgbm9uLXZhbGlkIHBvaW50ZXIsIFZpbSBtYXkKCQljcmFzaCEJVGhpcyBhbHNvIGhhcHBlbnMgaWYgdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBudW1iZXIsCgkJYmVjYXVzZSBWaW0gdGhpbmtzIGl0J3MgYSBwb2ludGVyLgoJCUZvciBXaW4zMiBzeXN0ZW1zLCB7bGlibmFtZX0gc2hvdWxkIGJlIHRoZSBmaWxlbmFtZSBvZiB0aGUgRExMCgkJd2l0aG91dCB0aGUgIi5ETEwiIHN1ZmZpeC4gIEEgZnVsbCBwYXRoIGlzIG9ubHkgcmVxdWlyZWQgaWYKCQl0aGUgRExMIGlzIG5vdCBpbiB0aGUgdXN1YWwgcGxhY2VzLgoJCUZvciBVbml4OiBXaGVuIGNvbXBpbGluZyB5b3VyIG93biBwbHVnaW5zLCByZW1lbWJlciB0aGF0IHRoZQoJCW9iamVjdCBjb2RlIG11c3QgYmUgY29tcGlsZWQgYXMgcG9zaXRpb24taW5kZXBlbmRlbnQgKCdQSUMnKS4KCQl7b25seSBpbiBXaW4zMiBhbmQgc29tZSBVbml4IHZlcnNpb25zLCB3aGVuIHRoZSB8K2xpYmNhbGx8CgkJZmVhdHVyZSBpcyBwcmVzZW50fQoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIGxpYmNhbGwoImxpYmMuc28iLCAiZ2V0ZW52IiwgIkhPTUUiKQo8CgkJCQkJCQkqbGliY2FsbG5yKCkqCmxpYmNhbGxucih7bGlibmFtZX0sIHtmdW5jbmFtZX0sIHthcmd1bWVudH0pCgkJSnVzdCBsaWtlIHxsaWJjYWxsKCl8LCBidXQgdXNlZCBmb3IgYSBmdW5jdGlvbiB0aGF0IHJldHVybnMgYW4KCQlpbnQgaW5zdGVhZCBvZiBhIHN0cmluZy4KCQl7b25seSBpbiBXaW4zMiBvbiBzb21lIFVuaXggdmVyc2lvbnMsIHdoZW4gdGhlIHwrbGliY2FsbHwKCQlmZWF0dXJlIGlzIHByZXNlbnR9CgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gbGliY2FsbG5yKCIvdXNyL2xpYi9saWJjLnNvIiwgImdldHBpZCIsICIiKQoJCQk6Y2FsbCBsaWJjYWxsbnIoImxpYmMuc28iLCAicHJpbnRmIiwgIkhlbGxvIFdvcmxkIVxuIikKCQkJOmNhbGwgbGliY2FsbG5yKCJsaWJjLnNvIiwgInNsZWVwIiwgMTApCjwKCQkJCQkJCSpsaW5lKCkqCmxpbmUoe2V4cHJ9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbGluZSBudW1iZXIgb2YgdGhlIGZpbGUKCQlwb3NpdGlvbiBnaXZlbiB3aXRoIHtleHByfS4gIFRoZSBhY2NlcHRlZCBwb3NpdGlvbnMgYXJlOgoJCSAgICAuCSAgICB0aGUgY3Vyc29yIHBvc2l0aW9uCgkJICAgICQJICAgIHRoZSBsYXN0IGxpbmUgaW4gdGhlIGN1cnJlbnQgYnVmZmVyCgkJICAgICd4CSAgICBwb3NpdGlvbiBvZiBtYXJrIHggKGlmIHRoZSBtYXJrIGlzIG5vdCBzZXQsIDAgaXMKCQkJICAgIHJldHVybmVkKQoJCSAgICB3MAkgICAgZmlyc3QgbGluZSB2aXNpYmxlIGluIGN1cnJlbnQgd2luZG93CgkJICAgIHckCSAgICBsYXN0IGxpbmUgdmlzaWJsZSBpbiBjdXJyZW50IHdpbmRvdwoJCSAgICB2CSAgICBJbiBWaXN1YWwgbW9kZTogdGhlIHN0YXJ0IG9mIHRoZSBWaXN1YWwgYXJlYSAodGhlCgkJCSAgICBjdXJzb3IgaXMgdGhlIGVuZCkuICBXaGVuIG5vdCBpbiBWaXN1YWwgbW9kZQoJCQkgICAgcmV0dXJucyB0aGUgY3Vyc29yIHBvc2l0aW9uLiAgRGlmZmVycyBmcm9tIHwnPHwgaW4KCQkJICAgIHRoYXQgaXQncyB1cGRhdGVkIHJpZ2h0IGF3YXkuCgkJTm90ZSB0aGF0IGEgbWFyayBpbiBhbm90aGVyIGZpbGUgY2FuIGJlIHVzZWQuICBUaGUgbGluZSBudW1iZXIKCQl0aGVuIGFwcGxpZXMgdG8gYW5vdGhlciBidWZmZXIuCgkJVG8gZ2V0IHRoZSBjb2x1bW4gbnVtYmVyIHVzZSB8Y29sKCl8LiAgVG8gZ2V0IGJvdGggdXNlCgkJfGdldHBvcygpfC4KCQlFeGFtcGxlczogPgoJCQlsaW5lKCIuIikJCWxpbmUgbnVtYmVyIG9mIHRoZSBjdXJzb3IKCQkJbGluZSgiJ3QiKQkJbGluZSBudW1iZXIgb2YgbWFyayB0CgkJCWxpbmUoIiciIC4gbWFya2VyKQlsaW5lIG51bWJlciBvZiBtYXJrIG1hcmtlcgo8CQkJCQkJCSpsYXN0LXBvc2l0aW9uLWp1bXAqCgkJVGhpcyBhdXRvY29tbWFuZCBqdW1wcyB0byB0aGUgbGFzdCBrbm93biBwb3NpdGlvbiBpbiBhIGZpbGUKCQlqdXN0IGFmdGVyIG9wZW5pbmcgaXQsIGlmIHRoZSAnIiBtYXJrIGlzIHNldDogPgoJOmF1IEJ1ZlJlYWRQb3N0ICogaWYgbGluZSgiJ1wiIikgPiAxICYmIGxpbmUoIidcIiIpIDw9IGxpbmUoIiQiKSB8IGV4ZSAibm9ybWFsISBnYFwiIiB8IGVuZGlmCgpsaW5lMmJ5dGUoe2xudW19KQkJCQkJKmxpbmUyYnl0ZSgpKgoJCVJldHVybiB0aGUgYnl0ZSBjb3VudCBmcm9tIHRoZSBzdGFydCBvZiB0aGUgYnVmZmVyIGZvciBsaW5lCgkJe2xudW19LiAgVGhpcyBpbmNsdWRlcyB0aGUgZW5kLW9mLWxpbmUgY2hhcmFjdGVyLCBkZXBlbmRpbmcgb24KCQl0aGUgJ2ZpbGVmb3JtYXQnIG9wdGlvbiBmb3IgdGhlIGN1cnJlbnQgYnVmZmVyLiAgVGhlIGZpcnN0CgkJbGluZSByZXR1cm5zIDEuICdlbmNvZGluZycgbWF0dGVycywgJ2ZpbGVlbmNvZGluZycgaXMgaWdub3JlZC4KCQlUaGlzIGNhbiBhbHNvIGJlIHVzZWQgdG8gZ2V0IHRoZSBieXRlIGNvdW50IGZvciB0aGUgbGluZSBqdXN0CgkJYmVsb3cgdGhlIGxhc3QgbGluZTogPgoJCQlsaW5lMmJ5dGUobGluZSgiJCIpICsgMSkKPAkJVGhpcyBpcyB0aGUgYnVmZmVyIHNpemUgcGx1cyBvbmUuICBJZiAnZmlsZWVuY29kaW5nJyBpcyBlbXB0eQoJCWl0IGlzIHRoZSBmaWxlIHNpemUgcGx1cyBvbmUuCgkJV2hlbiB7bG51bX0gaXMgaW52YWxpZCwgb3IgdGhlIHwrYnl0ZV9vZmZzZXR8IGZlYXR1cmUgaGFzIGJlZW4KCQlkaXNhYmxlZCBhdCBjb21waWxlIHRpbWUsIC0xIGlzIHJldHVybmVkLgoJCUFsc28gc2VlIHxieXRlMmxpbmUoKXwsIHxnb3wgYW5kIHw6Z290b3wuCgpsaXNwaW5kZW50KHtsbnVtfSkJCQkJCSpsaXNwaW5kZW50KCkqCgkJR2V0IHRoZSBhbW91bnQgb2YgaW5kZW50IGZvciBsaW5lIHtsbnVtfSBhY2NvcmRpbmcgdGhlIGxpc3AKCQlpbmRlbnRpbmcgcnVsZXMsIGFzIHdpdGggJ2xpc3AnLgoJCVRoZSBpbmRlbnQgaXMgY291bnRlZCBpbiBzcGFjZXMsIHRoZSB2YWx1ZSBvZiAndGFic3RvcCcgaXMKCQlyZWxldmFudC4gIHtsbnVtfSBpcyB1c2VkIGp1c3QgbGlrZSBpbiB8Z2V0bGluZSgpfC4KCQlXaGVuIHtsbnVtfSBpcyBpbnZhbGlkIG9yIFZpbSB3YXMgbm90IGNvbXBpbGVkIHRoZQoJCXwrbGlzcGluZGVudHwgZmVhdHVyZSwgLTEgaXMgcmV0dXJuZWQuCgpsb2NhbHRpbWUoKQkJCQkJCSpsb2NhbHRpbWUoKSoKCQlSZXR1cm4gdGhlIGN1cnJlbnQgdGltZSwgbWVhc3VyZWQgYXMgc2Vjb25kcyBzaW5jZSAxc3QgSmFuCgkJMTk3MC4gIFNlZSBhbHNvIHxzdHJmdGltZSgpfCBhbmQgfGdldGZ0aW1lKCl8LgoKCmxvZyh7ZXhwcn0pCQkJCQkJKmxvZygpKgoJCVJldHVybiB0aGUgbmF0dXJhbCBsb2dhcml0aG0gKGJhc2UgZSkgb2Yge2V4cHJ9IGFzIGEgfEZsb2F0fC4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfCBpbiB0aGUgcmFuZ2UKCQkoMCwgaW5mXS4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBsb2coMTApCjwJCQkyLjMwMjU4NSA+CgkJCTplY2hvIGxvZyhleHAoNSkpCjwJCQk1LjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKCmxvZzEwKHtleHByfSkJCQkJCQkqbG9nMTAoKSoKCQlSZXR1cm4gdGhlIGxvZ2FyaXRobSBvZiBGbG9hdCB7ZXhwcn0gdG8gYmFzZSAxMCBhcyBhIHxGbG9hdHwuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gbG9nMTAoMTAwMCkKPAkJCTMuMCA+CgkJCTplY2hvIGxvZzEwKDAuMDEpCjwJCQktMi4wCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCQkKbHVhZXZhbCh7ZXhwcn1bLCB7ZXhwcn1dKQkJCQkJKmx1YWV2YWwoKSoKCQlFdmFsdWF0ZSBMdWEgZXhwcmVzc2lvbiB7ZXhwcn0gYW5kIHJldHVybiBpdHMgcmVzdWx0IGNvbnZlcnRlZCAKCQl0byBWaW0gZGF0YSBzdHJ1Y3R1cmVzLiBTZWNvbmQge2V4cHJ9IG1heSBob2xkIGFkZGl0aW9uYWwgCgkJYXJndW1lbnQgYWNjZXNzaWJsZSBhcyBfQSBpbnNpZGUgZmlyc3Qge2V4cHJ9LgoJCVN0cmluZ3MgYXJlIHJldHVybmVkIGFzIHRoZXkgYXJlLgoJCUJvb2xlYW4gb2JqZWN0cyBhcmUgY29udmVydGVkIHRvIG51bWJlcnMuCgkJTnVtYmVycyBhcmUgY29udmVydGVkIHRvIHxGbG9hdHwgdmFsdWVzIGlmIHZpbSB3YXMgY29tcGlsZWQgCgkJd2l0aCB8K2Zsb2F0fCBhbmQgdG8gbnVtYmVycyBvdGhlcndpc2UuCgkJRGljdGlvbmFyaWVzIGFuZCBsaXN0cyBvYnRhaW5lZCBieSB2aW0uZXZhbCgpIGFyZSByZXR1cm5lZCAKCQlhcy1pcy4KCQlPdGhlciBvYmplY3RzIGFyZSByZXR1cm5lZCBhcyB6ZXJvIHdpdGhvdXQgYW55IGVycm9ycy4KCQlTZWUgfGx1YS1sdWFldmFsfCBmb3IgbW9yZSBkZXRhaWxzLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbHVhfCBmZWF0dXJlfQoKbWFwKHtleHByfSwge3N0cmluZ30pCQkJCQkqbWFwKCkqCgkJe2V4cHJ9IG11c3QgYmUgYSB8TGlzdHwgb3IgYSB8RGljdGlvbmFyeXwuCgkJUmVwbGFjZSBlYWNoIGl0ZW0gaW4ge2V4cHJ9IHdpdGggdGhlIHJlc3VsdCBvZiBldmFsdWF0aW5nCgkJe3N0cmluZ30uCgkJSW5zaWRlIHtzdHJpbmd9IHx2OnZhbHwgaGFzIHRoZSB2YWx1ZSBvZiB0aGUgY3VycmVudCBpdGVtLgoJCUZvciBhIHxEaWN0aW9uYXJ5fCB8djprZXl8IGhhcyB0aGUga2V5IG9mIHRoZSBjdXJyZW50IGl0ZW0KCQlhbmQgZm9yIGEgfExpc3R8IHx2OmtleXwgaGFzIHRoZSBpbmRleCBvZiB0aGUgY3VycmVudCBpdGVtLgoJCUV4YW1wbGU6ID4KCQkJOmNhbGwgbWFwKG15bGlzdCwgJyI+ICIgLiB2OnZhbCAuICIgPCInKQo8CQlUaGlzIHB1dHMgIj4gIiBiZWZvcmUgYW5kICIgPCIgYWZ0ZXIgZWFjaCBpdGVtIGluICJteWxpc3QiLgoKCQlOb3RlIHRoYXQge3N0cmluZ30gaXMgdGhlIHJlc3VsdCBvZiBhbiBleHByZXNzaW9uIGFuZCBpcyB0aGVuCgkJdXNlZCBhcyBhbiBleHByZXNzaW9uIGFnYWluLiAgT2Z0ZW4gaXQgaXMgZ29vZCB0byB1c2UgYQoJCXxsaXRlcmFsLXN0cmluZ3wgdG8gYXZvaWQgaGF2aW5nIHRvIGRvdWJsZSBiYWNrc2xhc2hlcy4gIFlvdQoJCXN0aWxsIGhhdmUgdG8gZG91YmxlICcgcXVvdGVzCgoJCVRoZSBvcGVyYXRpb24gaXMgZG9uZSBpbi1wbGFjZS4gIElmIHlvdSB3YW50IGEgfExpc3R8IG9yCgkJfERpY3Rpb25hcnl8IHRvIHJlbWFpbiB1bm1vZGlmaWVkIG1ha2UgYSBjb3B5IGZpcnN0OiA+CgkJCTpsZXQgdGxpc3QgPSBtYXAoY29weShteWxpc3QpLCAnIHY6dmFsIC4gIlx0IicpCgo8CQlSZXR1cm5zIHtleHByfSwgdGhlIHxMaXN0fCBvciB8RGljdGlvbmFyeXwgdGhhdCB3YXMgZmlsdGVyZWQuCgkJV2hlbiBhbiBlcnJvciBpcyBlbmNvdW50ZXJlZCB3aGlsZSBldmFsdWF0aW5nIHtzdHJpbmd9IG5vCgkJZnVydGhlciBpdGVtcyBpbiB7ZXhwcn0gYXJlIHByb2Nlc3NlZC4KCgptYXBhcmcoe25hbWV9Wywge21vZGV9IFssIHthYmJyfSBbLCB7ZGljdH1dXV0pCQkJKm1hcGFyZygpKgoJCVdoZW4ge2RpY3R9IGlzIG9taXR0ZWQgb3IgemVybzogUmV0dXJuIHRoZSByaHMgb2YgbWFwcGluZwoJCXtuYW1lfSBpbiBtb2RlIHttb2RlfS4gIFRoZSByZXR1cm5lZCBTdHJpbmcgaGFzIHNwZWNpYWwKCQljaGFyYWN0ZXJzIHRyYW5zbGF0ZWQgbGlrZSBpbiB0aGUgb3V0cHV0IG9mIHRoZSAiOm1hcCIgY29tbWFuZAoJCWxpc3RpbmcuCgkJCgkJV2hlbiB0aGVyZSBpcyBubyBtYXBwaW5nIGZvciB7bmFtZX0sIGFuIGVtcHR5IFN0cmluZyBpcwoJCXJldHVybmVkLgoKCQlUaGUge25hbWV9IGNhbiBoYXZlIHNwZWNpYWwga2V5IG5hbWVzLCBsaWtlIGluIHRoZSAiOm1hcCIKCQljb21tYW5kLgoKCQl7bW9kZX0gY2FuIGJlIG9uZSBvZiB0aGVzZSBzdHJpbmdzOgoJCQkibiIJTm9ybWFsCgkJCSJ2IglWaXN1YWwgKGluY2x1ZGluZyBTZWxlY3QpCgkJCSJvIglPcGVyYXRvci1wZW5kaW5nCgkJCSJpIglJbnNlcnQKCQkJImMiCUNtZC1saW5lCgkJCSJzIglTZWxlY3QKCQkJIngiCVZpc3VhbAoJCQkibCIJbGFuZ21hcCB8bGFuZ3VhZ2UtbWFwcGluZ3wKCQkJIiIJTm9ybWFsLCBWaXN1YWwgYW5kIE9wZXJhdG9yLXBlbmRpbmcKCQlXaGVuIHttb2RlfSBpcyBvbWl0dGVkLCB0aGUgbW9kZXMgZm9yICIiIGFyZSB1c2VkLgoKCQlXaGVuIHthYmJyfSBpcyB0aGVyZSBhbmQgaXQgaXMgbm9uLXplcm8gdXNlIGFiYnJldmlhdGlvbnMKCQlpbnN0ZWFkIG9mIG1hcHBpbmdzLgoKCQlXaGVuIHtkaWN0fSBpcyB0aGVyZSBhbmQgaXQgaXMgbm9uLXplcm8gcmV0dXJuIGEgZGljdGlvbmFyeQoJCWNvbnRhaW5pbmcgYWxsIHRoZSBpbmZvcm1hdGlvbiBvZiB0aGUgbWFwcGluZyB3aXRoIHRoZQoJCWZvbGxvd2luZyBpdGVtczoKCQkgICJsaHMiCSAgICAgVGhlIHtsaHN9IG9mIHRoZSBtYXBwaW5nLgoJCSAgInJocyIJICAgICBUaGUge3Joc30gb2YgdGhlIG1hcHBpbmcgYXMgdHlwZWQuCgkJICAic2lsZW50IiAgIDEgZm9yIGEgfDptYXAtc2lsZW50fCBtYXBwaW5nLCBlbHNlIDAuCgkJICAibm9yZW1hcCIgIDEgaWYgdGhlIHtyaHN9IG9mIHRoZSBtYXBwaW5nIGlzIG5vdCByZW1hcHBhYmxlLgoJCSAgImV4cHIiICAgICAxIGZvciBhbiBleHByZXNzaW9uIG1hcHBpbmcgKHw6bWFwLTxleHByPnwpLgoJCSAgImJ1ZmZlciIgICAxIGZvciBhIGJ1ZmZlciBsb2NhbCBtYXBwaW5nICh8Om1hcC1sb2NhbHwpLgoJCSAgIm1vZGUiICAgICBNb2RlcyBmb3Igd2hpY2ggdGhlIG1hcHBpbmcgaXMgZGVmaW5lZC4gSW4KCQkJICAgICBhZGRpdGlvbiB0byB0aGUgbW9kZXMgbWVudGlvbmVkIGFib3ZlLCB0aGVzZQoJCQkgICAgIGNoYXJhY3RlcnMgd2lsbCBiZSB1c2VkOgoJCQkgICAgICIgIiAgICAgTm9ybWFsLCBWaXN1YWwgYW5kIE9wZXJhdG9yLXBlbmRpbmcKCQkJICAgICAiISIgICAgIEluc2VydCBhbmQgQ29tbWFuZGxpbmUgbW9kZQoJCQkJICAgICAofG1hcG1vZGUtaWN8KQoJCSAgInNpZCIJICAgICBUaGUgc2NyaXB0IGxvY2FsIElELCB1c2VkIGZvciA8c2lkPiBtYXBwaW5ncwoJCQkgICAgICh8PFNJRD58KS4KCQkgICJub3dhaXQiICAgRG8gbm90IHdhaXQgZm9yIG90aGVyLCBsb25nZXIgbWFwcGluZ3MuCgkJCSAgICAgKHw6bWFwLTxub3dhaXQ+fCkuCgoJCVRoZSBtYXBwaW5ncyBsb2NhbCB0byB0aGUgY3VycmVudCBidWZmZXIgYXJlIGNoZWNrZWQgZmlyc3QsCgkJdGhlbiB0aGUgZ2xvYmFsIG1hcHBpbmdzLgoJCVRoaXMgZnVuY3Rpb24gY2FuIGJlIHVzZWQgdG8gbWFwIGEga2V5IGV2ZW4gd2hlbiBpdCdzIGFscmVhZHkKCQltYXBwZWQsIGFuZCBoYXZlIGl0IGRvIHRoZSBvcmlnaW5hbCBtYXBwaW5nIHRvby4gIFNrZXRjaDogPgoJCQlleGUgJ25ub3JlbWFwIDxUYWI+ID09JyAuIG1hcGFyZygnPFRhYj4nLCAnbicpCgoKbWFwY2hlY2soe25hbWV9Wywge21vZGV9IFssIHthYmJyfV1dKQkJCSptYXBjaGVjaygpKgoJCUNoZWNrIGlmIHRoZXJlIGlzIGEgbWFwcGluZyB0aGF0IG1hdGNoZXMgd2l0aCB7bmFtZX0gaW4gbW9kZQoJCXttb2RlfS4gIFNlZSB8bWFwYXJnKCl8IGZvciB7bW9kZX0gYW5kIHNwZWNpYWwgbmFtZXMgaW4KCQl7bmFtZX0uCgkJV2hlbiB7YWJicn0gaXMgdGhlcmUgYW5kIGl0IGlzIG5vbi16ZXJvIHVzZSBhYmJyZXZpYXRpb25zCgkJaW5zdGVhZCBvZiBtYXBwaW5ncy4KCQlBIG1hdGNoIGhhcHBlbnMgd2l0aCBhIG1hcHBpbmcgdGhhdCBzdGFydHMgd2l0aCB7bmFtZX0gYW5kCgkJd2l0aCBhIG1hcHBpbmcgd2hpY2ggaXMgZXF1YWwgdG8gdGhlIHN0YXJ0IG9mIHtuYW1lfS4KCgkJCW1hdGNoZXMgbWFwcGluZyAiYSIJImFiIgkiYWJjIiB+CgkJICAgbWFwY2hlY2soImEiKQl5ZXMJeWVzCSB5ZXMKCQkgICBtYXBjaGVjaygiYWJjIikJeWVzCXllcwkgeWVzCgkJICAgbWFwY2hlY2soImF4IikJeWVzCW5vCSBubwoJCSAgIG1hcGNoZWNrKCJiIikJbm8Jbm8JIG5vCgoJCVRoZSBkaWZmZXJlbmNlIHdpdGggbWFwYXJnKCkgaXMgdGhhdCBtYXBjaGVjaygpIGZpbmRzIGEKCQltYXBwaW5nIHRoYXQgbWF0Y2hlcyB3aXRoIHtuYW1lfSwgd2hpbGUgbWFwYXJnKCkgb25seSBmaW5kcyBhCgkJbWFwcGluZyBmb3Ige25hbWV9IGV4YWN0bHkuCgkJV2hlbiB0aGVyZSBpcyBubyBtYXBwaW5nIHRoYXQgc3RhcnRzIHdpdGgge25hbWV9LCBhbiBlbXB0eQoJCVN0cmluZyBpcyByZXR1cm5lZC4gIElmIHRoZXJlIGlzIG9uZSwgdGhlIHJocyBvZiB0aGF0IG1hcHBpbmcKCQlpcyByZXR1cm5lZC4gIElmIHRoZXJlIGFyZSBzZXZlcmFsIG1hcHBpbmdzIHRoYXQgc3RhcnQgd2l0aAoJCXtuYW1lfSwgdGhlIHJocyBvZiBvbmUgb2YgdGhlbSBpcyByZXR1cm5lZC4KCQlUaGUgbWFwcGluZ3MgbG9jYWwgdG8gdGhlIGN1cnJlbnQgYnVmZmVyIGFyZSBjaGVja2VkIGZpcnN0LAoJCXRoZW4gdGhlIGdsb2JhbCBtYXBwaW5ncy4KCQlUaGlzIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIHRvIGNoZWNrIGlmIGEgbWFwcGluZyBjYW4gYmUgYWRkZWQKCQl3aXRob3V0IGJlaW5nIGFtYmlndW91cy4gIEV4YW1wbGU6ID4KCTppZiBtYXBjaGVjaygiX3Z2IikgPT0gIiIKCTogICBtYXAgX3Z2IDpzZXQgZ3VpZm9udD03eDEzPENSPgoJOmVuZGlmCjwJCVRoaXMgYXZvaWRzIGFkZGluZyB0aGUgIl92diIgbWFwcGluZyB3aGVuIHRoZXJlIGFscmVhZHkgaXMgYQoJCW1hcHBpbmcgZm9yICJfdiIgb3IgZm9yICJfdnZ2Ii4KCm1hdGNoKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQkJCSptYXRjaCgpKgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IHRoZW4gdGhpcyByZXR1cm5zIHRoZSBpbmRleCBvZiB0aGUKCQlmaXJzdCBpdGVtIHdoZXJlIHtwYXR9IG1hdGNoZXMuICBFYWNoIGl0ZW0gaXMgdXNlZCBhcyBhCgkJU3RyaW5nLCB8TGlzdHN8IGFuZCB8RGljdGlvbmFyaWVzfCBhcmUgdXNlZCBhcyBlY2hvZWQuCgkJT3RoZXJ3aXNlLCB7ZXhwcn0gaXMgdXNlZCBhcyBhIFN0cmluZy4JVGhlIHJlc3VsdCBpcyBhCgkJTnVtYmVyLCB3aGljaCBnaXZlcyB0aGUgaW5kZXggKGJ5dGUgb2Zmc2V0KSBpbiB7ZXhwcn0gd2hlcmUKCQl7cGF0fSBtYXRjaGVzLgoJCUEgbWF0Y2ggYXQgdGhlIGZpcnN0IGNoYXJhY3RlciBvciB8TGlzdHwgaXRlbSByZXR1cm5zIHplcm8uCgkJSWYgdGhlcmUgaXMgbm8gbWF0Y2ggLTEgaXMgcmV0dXJuZWQuCgkJRm9yIGdldHRpbmcgc3VibWF0Y2hlcyBzZWUgfG1hdGNobGlzdCgpfC4KCQlFeGFtcGxlOiA+CgkJCTplY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgImluZyIpCSIgcmVzdWx0cyBpbiA0CgkJCTplY2hvIG1hdGNoKFsxLCAneCddLCAnXGEnKQkiIHJlc3VsdHMgaW4gMQo8CQlTZWUgfHN0cmluZy1tYXRjaHwgZm9yIGhvdyB7cGF0fSBpcyB1c2VkLgoJCQkJCQkJCSpzdHJwYnJrKCkqCgkJVmltIGRvZXNuJ3QgaGF2ZSBhIHN0cnBicmsoKSBmdW5jdGlvbi4JQnV0IHlvdSBjYW4gZG86ID4KCQkJOmxldCBzZXBpZHggPSBtYXRjaChsaW5lLCAnWy4sOzogXHRdJykKPAkJCQkJCQkJKnN0cmNhc2VzdHIoKSoKCQlWaW0gZG9lc24ndCBoYXZlIGEgc3RyY2FzZXN0cigpIGZ1bmN0aW9uLiAgQnV0IHlvdSBjYW4gYWRkCgkJIlxjIiB0byB0aGUgcGF0dGVybiB0byBpZ25vcmUgY2FzZTogPgoJCQk6bGV0IGlkeCA9IG1hdGNoKGhheXN0YWNrLCAnXGNuZWVkbGUnKQo8CgkJSWYge3N0YXJ0fSBpcyBnaXZlbiwgdGhlIHNlYXJjaCBzdGFydHMgZnJvbSBieXRlIGluZGV4CgkJe3N0YXJ0fSBpbiBhIFN0cmluZyBvciBpdGVtIHtzdGFydH0gaW4gYSB8TGlzdHwuCgkJVGhlIHJlc3VsdCwgaG93ZXZlciwgaXMgc3RpbGwgdGhlIGluZGV4IGNvdW50ZWQgZnJvbSB0aGUKCQlmaXJzdCBjaGFyYWN0ZXIvaXRlbS4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gbWF0Y2goInRlc3RpbmciLCAiaW5nIiwgMikKPAkJcmVzdWx0IGlzIGFnYWluICI0Ii4gPgoJCQk6ZWNobyBtYXRjaCgidGVzdGluZyIsICJpbmciLCA0KQo8CQlyZXN1bHQgaXMgYWdhaW4gIjQiLiA+CgkJCTplY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgInQiLCAyKQo8CQlyZXN1bHQgaXMgIjMiLgoJCUZvciBhIFN0cmluZywgaWYge3N0YXJ0fSA+IDAgdGhlbiBpdCBpcyBsaWtlIHRoZSBzdHJpbmcgc3RhcnRzCgkJe3N0YXJ0fSBieXRlcyBsYXRlciwgdGh1cyAiXiIgd2lsbCBtYXRjaCBhdCB7c3RhcnR9LiAgRXhjZXB0CgkJd2hlbiB7Y291bnR9IGlzIGdpdmVuLCB0aGVuIGl0J3MgbGlrZSBtYXRjaGVzIGJlZm9yZSB0aGUKCQl7c3RhcnR9IGJ5dGUgYXJlIGlnbm9yZWQgKHRoaXMgaXMgYSBiaXQgY29tcGxpY2F0ZWQgdG8ga2VlcCBpdAoJCWJhY2t3YXJkcyBjb21wYXRpYmxlKS4KCQlGb3IgYSBTdHJpbmcsIGlmIHtzdGFydH0gPCAwLCBpdCB3aWxsIGJlIHNldCB0byAwLiAgRm9yIGEgbGlzdAoJCXRoZSBpbmRleCBpcyBjb3VudGVkIGZyb20gdGhlIGVuZC4KCQlJZiB7c3RhcnR9IGlzIG91dCBvZiByYW5nZSAoe3N0YXJ0fSA+IHN0cmxlbih7ZXhwcn0pIGZvciBhCgkJU3RyaW5nIG9yIHtzdGFydH0gPiBsZW4oe2V4cHJ9KSBmb3IgYSB8TGlzdHwpIC0xIGlzIHJldHVybmVkLgoKCQlXaGVuIHtjb3VudH0gaXMgZ2l2ZW4gdXNlIHRoZSB7Y291bnR9J3RoIG1hdGNoLiAgV2hlbiBhIG1hdGNoCgkJaXMgZm91bmQgaW4gYSBTdHJpbmcgdGhlIHNlYXJjaCBmb3IgdGhlIG5leHQgb25lIHN0YXJ0cyBvbmUKCQljaGFyYWN0ZXIgZnVydGhlci4gIFRodXMgdGhpcyBleGFtcGxlIHJlc3VsdHMgaW4gMTogPgoJCQllY2hvIG1hdGNoKCJ0ZXN0aW5nIiwgIi4uIiwgMCwgMikKPAkJSW4gYSB8TGlzdHwgdGhlIHNlYXJjaCBjb250aW51ZXMgaW4gdGhlIG5leHQgaXRlbS4KCQlOb3RlIHRoYXQgd2hlbiB7Y291bnR9IGlzIGFkZGVkIHRoZSB3YXkge3N0YXJ0fSB3b3JrcyBjaGFuZ2VzLAoJCXNlZSBhYm92ZS4KCgkJU2VlIHxwYXR0ZXJufCBmb3IgdGhlIHBhdHRlcm5zIHRoYXQgYXJlIGFjY2VwdGVkLgoJCVRoZSAnaWdub3JlY2FzZScgb3B0aW9uIGlzIHVzZWQgdG8gc2V0IHRoZSBpZ25vcmUtY2FzZW5lc3Mgb2YKCQl0aGUgcGF0dGVybi4gICdzbWFydGNhc2UnIGlzIE5PVCB1c2VkLglUaGUgbWF0Y2hpbmcgaXMgYWx3YXlzCgkJZG9uZSBsaWtlICdtYWdpYycgaXMgc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eS4KCgkJCQkJKm1hdGNoYWRkKCkqICpFNzk4KiAqRTc5OSogKkU4MDEqCm1hdGNoYWRkKHtncm91cH0sIHtwYXR0ZXJufVssIHtwcmlvcml0eX1bLCB7aWR9Wywge2RpY3R9XV1dKQoJCURlZmluZXMgYSBwYXR0ZXJuIHRvIGJlIGhpZ2hsaWdodGVkIGluIHRoZSBjdXJyZW50IHdpbmRvdyAoYQoJCSJtYXRjaCIpLiAgSXQgd2lsbCBiZSBoaWdobGlnaHRlZCB3aXRoIHtncm91cH0uICBSZXR1cm5zIGFuCgkJaWRlbnRpZmljYXRpb24gbnVtYmVyIChJRCksIHdoaWNoIGNhbiBiZSB1c2VkIHRvIGRlbGV0ZSB0aGUKCQltYXRjaCB1c2luZyB8bWF0Y2hkZWxldGUoKXwuCgkJTWF0Y2hpbmcgaXMgY2FzZSBzZW5zaXRpdmUgYW5kIG1hZ2ljLCB1bmxlc3MgY2FzZSBzZW5zaXRpdml0eQoJCW9yIG1hZ2ljbmVzcyBhcmUgZXhwbGljaXRseSBvdmVycmlkZGVuIGluIHtwYXR0ZXJufS4gIFRoZQoJCSdtYWdpYycsICdzbWFydGNhc2UnIGFuZCAnaWdub3JlY2FzZScgb3B0aW9ucyBhcmUgbm90IHVzZWQuCgkJVGhlICJDb25jZWFsIiB2YWx1ZSBpcyBzcGVjaWFsLCBpdCBjYXVzZXMgdGhlIG1hdGNoIHRvIGJlCgkJY29uY2VhbGVkLgoKCQlUaGUgb3B0aW9uYWwge3ByaW9yaXR5fSBhcmd1bWVudCBhc3NpZ25zIGEgcHJpb3JpdHkgdG8gdGhlCgkJbWF0Y2guCUEgbWF0Y2ggd2l0aCBhIGhpZ2ggcHJpb3JpdHkgd2lsbCBoYXZlIGl0cwoJCWhpZ2hsaWdodGluZyBvdmVycnVsZSB0aGF0IG9mIGEgbWF0Y2ggd2l0aCBhIGxvd2VyIHByaW9yaXR5LgoJCUEgcHJpb3JpdHkgaXMgc3BlY2lmaWVkIGFzIGFuIGludGVnZXIgKG5lZ2F0aXZlIG51bWJlcnMgYXJlIG5vCgkJZXhjZXB0aW9uKS4gIElmIHRoZSB7cHJpb3JpdHl9IGFyZ3VtZW50IGlzIG5vdCBzcGVjaWZpZWQsIHRoZQoJCWRlZmF1bHQgcHJpb3JpdHkgaXMgMTAuICBUaGUgcHJpb3JpdHkgb2YgJ2hsc2VhcmNoJyBpcyB6ZXJvLAoJCWhlbmNlIGFsbCBtYXRjaGVzIHdpdGggYSBwcmlvcml0eSBncmVhdGVyIHRoYW4gemVybyB3aWxsCgkJb3ZlcnJ1bGUgaXQuICBTeW50YXggaGlnaGxpZ2h0aW5nIChzZWUgJ3N5bnRheCcpIGlzIGEgc2VwYXJhdGUKCQltZWNoYW5pc20sIGFuZCByZWdhcmRsZXNzIG9mIHRoZSBjaG9zZW4gcHJpb3JpdHkgYSBtYXRjaCB3aWxsCgkJYWx3YXlzIG92ZXJydWxlIHN5bnRheCBoaWdobGlnaHRpbmcuCgoJCVRoZSBvcHRpb25hbCB7aWR9IGFyZ3VtZW50IGFsbG93cyB0aGUgcmVxdWVzdCBmb3IgYSBzcGVjaWZpYwoJCW1hdGNoIElELiAgSWYgYSBzcGVjaWZpZWQgSUQgaXMgYWxyZWFkeSB0YWtlbiwgYW4gZXJyb3IKCQltZXNzYWdlIHdpbGwgYXBwZWFyIGFuZCB0aGUgbWF0Y2ggd2lsbCBub3QgYmUgYWRkZWQuICBBbiBJRAoJCWlzIHNwZWNpZmllZCBhcyBhIHBvc2l0aXZlIGludGVnZXIgKHplcm8gZXhjbHVkZWQpLiAgSURzIDEsIDIKCQlhbmQgMyBhcmUgcmVzZXJ2ZWQgZm9yIHw6bWF0Y2h8LCB8OjJtYXRjaHwgYW5kIHw6M21hdGNofCwKCQlyZXNwZWN0aXZlbHkuICBJZiB0aGUge2lkfSBhcmd1bWVudCBpcyBub3Qgc3BlY2lmaWVkIG9yIC0xLAoJCXxtYXRjaGFkZCgpfCBhdXRvbWF0aWNhbGx5IGNob29zZXMgYSBmcmVlIElELgoKCQlUaGUgb3B0aW9uYWwge2RpY3R9IGFyZ3VtZW50IGFsbG93cyBmb3IgZnVydGhlciBjdXN0b20KCQl2YWx1ZXMuIEN1cnJlbnRseSB0aGlzIGlzIHVzZWQgdG8gc3BlY2lmeSBhIG1hdGNoIHNwZWNpZmljCgkJY29uY2VhbCBjaGFyYWN0ZXIgdGhhdCB3aWxsIGJlIHNob3duIGZvciB8aGwtQ29uY2VhbHwKCQloaWdobGlnaHRlZCBtYXRjaGVzLiBUaGUgZGljdCBjYW4gaGF2ZSB0aGUgZm9sbG93aW5nIG1lbWJlcnM6CgoJCQljb25jZWFsCSAgICBTcGVjaWFsIGNoYXJhY3RlciB0byBzaG93IGluc3RlYWQgb2YgdGhlCgkJCQkgICAgbWF0Y2ggKG9ubHkgZm9yIHxobC1Db25jZWFsfCBoaWdobGlnaHRlZAoJCQkJICAgIG1hdGNoZXMsIHNlZSB8OnN5bi1jY2hhcnwpCgoJCVRoZSBudW1iZXIgb2YgbWF0Y2hlcyBpcyBub3QgbGltaXRlZCwgYXMgaXQgaXMgdGhlIGNhc2Ugd2l0aAoJCXRoZSB8Om1hdGNofCBjb21tYW5kcy4KCgkJRXhhbXBsZTogPgoJCQk6aGlnaGxpZ2h0IE15R3JvdXAgY3Rlcm1iZz1ncmVlbiBndWliZz1ncmVlbgoJCQk6bGV0IG0gPSBtYXRjaGFkZCgiTXlHcm91cCIsICJUT0RPIikKPAkJRGVsZXRpb24gb2YgdGhlIHBhdHRlcm46ID4KCQkJOmNhbGwgbWF0Y2hkZWxldGUobSkKCjwJCUEgbGlzdCBvZiBtYXRjaGVzIGRlZmluZWQgYnkgfG1hdGNoYWRkKCl8IGFuZCB8Om1hdGNofCBhcmUKCQlhdmFpbGFibGUgZnJvbSB8Z2V0bWF0Y2hlcygpfC4JQWxsIG1hdGNoZXMgY2FuIGJlIGRlbGV0ZWQgaW4KCQlvbmUgb3BlcmF0aW9uIGJ5IHxjbGVhcm1hdGNoZXMoKXwuCgptYXRjaGFkZHBvcyh7Z3JvdXB9LCB7cG9zfVssIHtwcmlvcml0eX1bLCB7aWR9Wywge2RpY3R9XV1dKQkJKm1hdGNoYWRkcG9zKCkqCgkJU2FtZSBhcyB8bWF0Y2hhZGQoKXwsIGJ1dCByZXF1aXJlcyBhIGxpc3Qgb2YgcG9zaXRpb25zIHtwb3N9CgkJaW5zdGVhZCBvZiBhIHBhdHRlcm4uIFRoaXMgY29tbWFuZCBpcyBmYXN0ZXIgdGhhbiB8bWF0Y2hhZGQoKXwKCQliZWNhdXNlIGl0IGRvZXMgbm90IHJlcXVpcmUgdG8gaGFuZGxlIHJlZ3VsYXIgZXhwcmVzc2lvbnMgYW5kCgkJc2V0cyBidWZmZXIgbGluZSBib3VuZGFyaWVzIHRvIHJlZHJhdyBzY3JlZW4uIEl0IGlzIHN1cHBvc2VkCgkJdG8gYmUgdXNlZCB3aGVuIGZhc3QgbWF0Y2ggYWRkaXRpb25zIGFuZCBkZWxldGlvbnMgYXJlCgkJcmVxdWlyZWQsIGZvciBleGFtcGxlIHRvIGhpZ2hsaWdodCBtYXRjaGluZyBwYXJlbnRoZXNlcy4KCgkJVGhlIGxpc3Qge3Bvc30gY2FuIGNvbnRhaW4gb25lIG9mIHRoZXNlIGl0ZW1zOgoJCS0gQSBudW1iZXIuICBUaGlzIHdob2xlIGxpbmUgd2lsbCBiZSBoaWdobGlnaHRlZC4gIFRoZSBmaXJzdAoJCSAgbGluZSBoYXMgbnVtYmVyIDEuCgkJLSBBIGxpc3Qgd2l0aCBvbmUgbnVtYmVyLCBlLmcuLCBbMjNdLiBUaGUgd2hvbGUgbGluZSB3aXRoIHRoaXMKCQkgIG51bWJlciB3aWxsIGJlIGhpZ2hsaWdodGVkLgoJCS0gQSBsaXN0IHdpdGggdHdvIG51bWJlcnMsIGUuZy4sIFsyMywgMTFdLiBUaGUgZmlyc3QgbnVtYmVyIGlzCgkJICB0aGUgbGluZSBudW1iZXIsIHRoZSBzZWNvbmQgb25lIGlzIHRoZSBjb2x1bW4gbnVtYmVyIChmaXJzdAoJCSAgY29sdW1uIGlzIDEsIHRoZSB2YWx1ZSBtdXN0IGNvcnJlc3BvbmQgdG8gdGhlIGJ5dGUgaW5kZXggYXMKCQkgIHxjb2woKXwgd291bGQgcmV0dXJuKS4gIFRoZSBjaGFyYWN0ZXIgYXQgdGhpcyBwb3NpdGlvbiB3aWxsCgkJICBiZSBoaWdobGlnaHRlZC4KCQktIEEgbGlzdCB3aXRoIHRocmVlIG51bWJlcnMsIGUuZy4sIFsyMywgMTEsIDNdLiBBcyBhYm92ZSwgYnV0CgkJICB0aGUgdGhpcmQgbnVtYmVyIGdpdmVzIHRoZSBsZW5ndGggb2YgdGhlIGhpZ2hsaWdodCBpbiBieXRlcy4KCQkKCQlUaGUgbWF4aW11bSBudW1iZXIgb2YgcG9zaXRpb25zIGlzIDguCgoJCUV4YW1wbGU6ID4KCQkJOmhpZ2hsaWdodCBNeUdyb3VwIGN0ZXJtYmc9Z3JlZW4gZ3VpYmc9Z3JlZW4KCQkJOmxldCBtID0gbWF0Y2hhZGRwb3MoIk15R3JvdXAiLCBbWzIzLCAyNF0sIDM0XSkKPAkJRGVsZXRpb24gb2YgdGhlIHBhdHRlcm46ID4KCQkJOmNhbGwgbWF0Y2hkZWxldGUobSkKCjwJCU1hdGNoZXMgYWRkZWQgYnkgfG1hdGNoYWRkcG9zKCl8IGFyZSByZXR1cm5lZCBieQoJCXxnZXRtYXRjaGVzKCl8IHdpdGggYW4gZW50cnkgInBvczEiLCAicG9zMiIsIGV0Yy4sIHdpdGggdGhlCgkJdmFsdWUgYSBsaXN0IGxpa2UgdGhlIHtwb3N9IGl0ZW0uCgkJVGhlc2UgbWF0Y2hlcyBjYW5ub3QgYmUgc2V0IHZpYSB8c2V0bWF0Y2hlcygpfCwgaG93ZXZlciB0aGV5CgkJY2FuIHN0aWxsIGJlIGRlbGV0ZWQgYnkgfGNsZWFybWF0Y2hlcygpfC4KCm1hdGNoYXJnKHtucn0pCQkJCQkJCSptYXRjaGFyZygpKgoJCVNlbGVjdHMgdGhlIHtucn0gbWF0Y2ggaXRlbSwgYXMgc2V0IHdpdGggYSB8Om1hdGNofCwKCQl8OjJtYXRjaHwgb3IgfDozbWF0Y2h8IGNvbW1hbmQuCgkJUmV0dXJuIGEgfExpc3R8IHdpdGggdHdvIGVsZW1lbnRzOgoJCQlUaGUgbmFtZSBvZiB0aGUgaGlnaGxpZ2h0IGdyb3VwIHVzZWQKCQkJVGhlIHBhdHRlcm4gdXNlZC4KCQlXaGVuIHtucn0gaXMgbm90IDEsIDIgb3IgMyByZXR1cm5zIGFuIGVtcHR5IHxMaXN0fC4KCQlXaGVuIHRoZXJlIGlzIG5vIG1hdGNoIGl0ZW0gc2V0IHJldHVybnMgWycnLCAnJ10uCgkJVGhpcyBpcyB1c2VmdWwgdG8gc2F2ZSBhbmQgcmVzdG9yZSBhIHw6bWF0Y2h8LgoJCUhpZ2hsaWdodGluZyBtYXRjaGVzIHVzaW5nIHRoZSB8Om1hdGNofCBjb21tYW5kcyBhcmUgbGltaXRlZAoJCXRvIHRocmVlIG1hdGNoZXMuIHxtYXRjaGFkZCgpfCBkb2VzIG5vdCBoYXZlIHRoaXMgbGltaXRhdGlvbi4KCm1hdGNoZGVsZXRlKHtpZH0pCQkJICAgICAgICptYXRjaGRlbGV0ZSgpKiAqRTgwMiogKkU4MDMqCgkJRGVsZXRlcyBhIG1hdGNoIHdpdGggSUQge2lkfSBwcmV2aW91c2x5IGRlZmluZWQgYnkgfG1hdGNoYWRkKCl8CgkJb3Igb25lIG9mIHRoZSB8Om1hdGNofCBjb21tYW5kcy4gIFJldHVybnMgMCBpZiBzdWNjZXNzZnVsLAoJCW90aGVyd2lzZSAtMS4gIFNlZSBleGFtcGxlIGZvciB8bWF0Y2hhZGQoKXwuICBBbGwgbWF0Y2hlcyBjYW4KCQliZSBkZWxldGVkIGluIG9uZSBvcGVyYXRpb24gYnkgfGNsZWFybWF0Y2hlcygpfC4KCm1hdGNoZW5kKHtleHByfSwge3BhdH1bLCB7c3RhcnR9Wywge2NvdW50fV1dKQkJCSptYXRjaGVuZCgpKgoJCVNhbWUgYXMgfG1hdGNoKCl8LCBidXQgcmV0dXJuIHRoZSBpbmRleCBvZiBmaXJzdCBjaGFyYWN0ZXIKCQlhZnRlciB0aGUgbWF0Y2guICBFeGFtcGxlOiA+CgkJCTplY2hvIG1hdGNoZW5kKCJ0ZXN0aW5nIiwgImluZyIpCjwJCXJlc3VsdHMgaW4gIjciLgoJCQkJCQkJKnN0cnNwbigpKiAqc3RyY3NwbigpKgoJCVZpbSBkb2Vzbid0IGhhdmUgYSBzdHJzcG4oKSBvciBzdHJjc3BuKCkgZnVuY3Rpb24sIGJ1dCB5b3UgY2FuCgkJZG8gaXQgd2l0aCBtYXRjaGVuZCgpOiA+CgkJCTpsZXQgc3BhbiA9IG1hdGNoZW5kKGxpbmUsICdbYS16QS1aXScpCgkJCTpsZXQgc3BhbiA9IG1hdGNoZW5kKGxpbmUsICdbXmEtekEtWl0nKQo8CQlFeGNlcHQgdGhhdCAtMSBpcyByZXR1cm5lZCB3aGVuIHRoZXJlIGFyZSBubyBtYXRjaGVzLgoKCQlUaGUge3N0YXJ0fSwgaWYgZ2l2ZW4sIGhhcyB0aGUgc2FtZSBtZWFuaW5nIGFzIGZvciB8bWF0Y2goKXwuID4KCQkJOmVjaG8gbWF0Y2hlbmQoInRlc3RpbmciLCAiaW5nIiwgMikKPAkJcmVzdWx0cyBpbiAiNyIuID4KCQkJOmVjaG8gbWF0Y2hlbmQoInRlc3RpbmciLCAiaW5nIiwgNSkKPAkJcmVzdWx0IGlzICItMSIuCgkJV2hlbiB7ZXhwcn0gaXMgYSB8TGlzdHwgdGhlIHJlc3VsdCBpcyBlcXVhbCB0byB8bWF0Y2goKXwuCgptYXRjaGxpc3Qoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCQkJKm1hdGNobGlzdCgpKgoJCVNhbWUgYXMgfG1hdGNoKCl8LCBidXQgcmV0dXJuIGEgfExpc3R8LiAgVGhlIGZpcnN0IGl0ZW0gaW4gdGhlCgkJbGlzdCBpcyB0aGUgbWF0Y2hlZCBzdHJpbmcsIHNhbWUgYXMgd2hhdCBtYXRjaHN0cigpIHdvdWxkCgkJcmV0dXJuLiAgRm9sbG93aW5nIGl0ZW1zIGFyZSBzdWJtYXRjaGVzLCBsaWtlICJcMSIsICJcMiIsIGV0Yy4KCQlpbiB8OnN1YnN0aXR1dGV8LiAgV2hlbiBhbiBvcHRpb25hbCBzdWJtYXRjaCBkaWRuJ3QgbWF0Y2ggYW4KCQllbXB0eSBzdHJpbmcgaXMgdXNlZC4gIEV4YW1wbGU6ID4KCQkJZWNobyBtYXRjaGxpc3QoJ2FjZCcsICdcKGFcKVw/XChiXClcP1woY1wpXD9cKC4qXCknKQo8CQlSZXN1bHRzIGluOiBbJ2FjZCcsICdhJywgJycsICdjJywgJ2QnLCAnJywgJycsICcnLCAnJywgJyddCgkJV2hlbiB0aGVyZSBpcyBubyBtYXRjaCBhbiBlbXB0eSBsaXN0IGlzIHJldHVybmVkLgoKbWF0Y2hzdHIoe2V4cHJ9LCB7cGF0fVssIHtzdGFydH1bLCB7Y291bnR9XV0pCQkJKm1hdGNoc3RyKCkqCgkJU2FtZSBhcyB8bWF0Y2goKXwsIGJ1dCByZXR1cm4gdGhlIG1hdGNoZWQgc3RyaW5nLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBtYXRjaHN0cigidGVzdGluZyIsICJpbmciKQo8CQlyZXN1bHRzIGluICJpbmciLgoJCVdoZW4gdGhlcmUgaXMgbm8gbWF0Y2ggIiIgaXMgcmV0dXJuZWQuCgkJVGhlIHtzdGFydH0sIGlmIGdpdmVuLCBoYXMgdGhlIHNhbWUgbWVhbmluZyBhcyBmb3IgfG1hdGNoKCl8LiA+CgkJCTplY2hvIG1hdGNoc3RyKCJ0ZXN0aW5nIiwgImluZyIsIDIpCjwJCXJlc3VsdHMgaW4gImluZyIuID4KCQkJOmVjaG8gbWF0Y2hzdHIoInRlc3RpbmciLCAiaW5nIiwgNSkKPAkJcmVzdWx0IGlzICIiLgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IHRoZW4gdGhlIG1hdGNoaW5nIGl0ZW0gaXMgcmV0dXJuZWQuCgkJVGhlIHR5cGUgaXNuJ3QgY2hhbmdlZCwgaXQncyBub3QgbmVjZXNzYXJpbHkgYSBTdHJpbmcuCgptYXRjaHN0cnBvcyh7ZXhwcn0sIHtwYXR9Wywge3N0YXJ0fVssIHtjb3VudH1dXSkJCSptYXRjaHN0cnBvcygpKgoJCVNhbWUgYXMgfG1hdGNoc3RyKCl8LCBidXQgcmV0dXJuIHRoZSBtYXRjaGVkIHN0cmluZywgdGhlIHN0YXJ0CgkJcG9zaXRpb24gYW5kIHRoZSBlbmQgcG9zaXRpb24gb2YgdGhlIG1hdGNoLiAgRXhhbXBsZTogPgoJCQk6ZWNobyBtYXRjaHN0cnBvcygidGVzdGluZyIsICJpbmciKQo8CQlyZXN1bHRzIGluIFsiaW5nIiwgNCwgN10uCgkJV2hlbiB0aGVyZSBpcyBubyBtYXRjaCBbIiIsIC0xLCAtMV0gaXMgcmV0dXJuZWQuCgkJVGhlIHtzdGFydH0sIGlmIGdpdmVuLCBoYXMgdGhlIHNhbWUgbWVhbmluZyBhcyBmb3IgfG1hdGNoKCl8LiA+CgkJCTplY2hvIG1hdGNoc3RycG9zKCJ0ZXN0aW5nIiwgImluZyIsIDIpCjwJCXJlc3VsdHMgaW4gWyJpbmciLCA0LCA3XS4gPgoJCQk6ZWNobyBtYXRjaHN0cnBvcygidGVzdGluZyIsICJpbmciLCA1KQo8CQlyZXN1bHQgaXMgWyIiLCAtMSwgLTFdLgoJCVdoZW4ge2V4cHJ9IGlzIGEgfExpc3R8IHRoZW4gdGhlIG1hdGNoaW5nIGl0ZW0sIHRoZSBpbmRleAoJCW9mIGZpcnN0IGl0ZW0gd2hlcmUge3BhdH0gbWF0Y2hlcywgdGhlIHN0YXJ0IHBvc2l0aW9uIGFuZCB0aGUKCQllbmQgcG9zaXRpb24gb2YgdGhlIG1hdGNoIGFyZSByZXR1cm5lZC4gPgoJCQk6ZWNobyBtYXRjaHN0cnBvcyhbMSwgJ19feCddLCAnXGEnKQo8CQlyZXN1bHQgaXMgWyJ4IiwgMSwgMiwgM10uCgkJVGhlIHR5cGUgaXNuJ3QgY2hhbmdlZCwgaXQncyBub3QgbmVjZXNzYXJpbHkgYSBTdHJpbmcuCgoJCQkJCQkJKm1heCgpKgptYXgoe2xpc3R9KQlSZXR1cm4gdGhlIG1heGltdW0gdmFsdWUgb2YgYWxsIGl0ZW1zIGluIHtsaXN0fS4KCQlJZiB7bGlzdH0gaXMgbm90IGEgbGlzdCBvciBvbmUgb2YgdGhlIGl0ZW1zIGluIHtsaXN0fSBjYW5ub3QKCQliZSB1c2VkIGFzIGEgTnVtYmVyIHRoaXMgcmVzdWx0cyBpbiBhbiBlcnJvci4KCQlBbiBlbXB0eSB8TGlzdHwgcmVzdWx0cyBpbiB6ZXJvLgoKCQkJCQkJCSptaW4oKSoKbWluKHtsaXN0fSkJUmV0dXJuIHRoZSBtaW5pbXVtIHZhbHVlIG9mIGFsbCBpdGVtcyBpbiB7bGlzdH0uCgkJSWYge2xpc3R9IGlzIG5vdCBhIGxpc3Qgb3Igb25lIG9mIHRoZSBpdGVtcyBpbiB7bGlzdH0gY2Fubm90CgkJYmUgdXNlZCBhcyBhIE51bWJlciB0aGlzIHJlc3VsdHMgaW4gYW4gZXJyb3IuCgkJQW4gZW1wdHkgfExpc3R8IHJlc3VsdHMgaW4gemVyby4KCgkJCQkJCQkqbWtkaXIoKSogKkU3MzkqCm1rZGlyKHtuYW1lfSBbLCB7cGF0aH0gWywge3Byb3R9XV0pCgkJQ3JlYXRlIGRpcmVjdG9yeSB7bmFtZX0uCgkJSWYge3BhdGh9IGlzICJwIiB0aGVuIGludGVybWVkaWF0ZSBkaXJlY3RvcmllcyBhcmUgY3JlYXRlZCBhcwoJCW5lY2Vzc2FyeS4gIE90aGVyd2lzZSBpdCBtdXN0IGJlICIiLgoJCUlmIHtwcm90fSBpcyBnaXZlbiBpdCBpcyB1c2VkIHRvIHNldCB0aGUgcHJvdGVjdGlvbiBiaXRzIG9mCgkJdGhlIG5ldyBkaXJlY3RvcnkuICBUaGUgZGVmYXVsdCBpcyAwNzU1IChyd3hyLXhyLXg6IHIvdyBmb3IKCQl0aGUgdXNlciByZWFkYWJsZSBmb3Igb3RoZXJzKS4JVXNlIDA3MDAgdG8gbWFrZSBpdCB1bnJlYWRhYmxlCgkJZm9yIG90aGVycy4gIFRoaXMgaXMgb25seSB1c2VkIGZvciB0aGUgbGFzdCBwYXJ0IG9mIHtuYW1lfS4KCQlUaHVzIGlmIHlvdSBjcmVhdGUgL3RtcC9mb28vYmFyIHRoZW4gL3RtcC9mb28gd2lsbCBiZSBjcmVhdGVkCgkJd2l0aCAwNzU1LgoJCUV4YW1wbGU6ID4KCQkJOmNhbGwgbWtkaXIoJEhPTUUgLiAiL3RtcC9mb28vYmFyIiwgInAiLCAwNzAwKQo8CQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQlOb3QgYXZhaWxhYmxlIG9uIGFsbCBzeXN0ZW1zLiAgVG8gY2hlY2sgdXNlOiA+CgkJCTppZiBleGlzdHMoIipta2RpciIpCjwKCQkJCQkJCSptb2RlKCkqCm1vZGUoW2V4cHJdKQlSZXR1cm4gYSBzdHJpbmcgdGhhdCBpbmRpY2F0ZXMgdGhlIGN1cnJlbnQgbW9kZS4KCQlJZiBbZXhwcl0gaXMgc3VwcGxpZWQgYW5kIGl0IGV2YWx1YXRlcyB0byBhIG5vbi16ZXJvIE51bWJlciBvcgoJCWEgbm9uLWVtcHR5IFN0cmluZyAofG5vbi16ZXJvLWFyZ3wpLCB0aGVuIHRoZSBmdWxsIG1vZGUgaXMKCQlyZXR1cm5lZCwgb3RoZXJ3aXNlIG9ubHkgdGhlIGZpcnN0IGxldHRlciBpcyByZXR1cm5lZC4gIE5vdGUKCQl0aGF0ICIgIiBhbmQgIjAiIGFyZSBhbHNvIG5vbi1lbXB0eSBzdHJpbmdzLgoKCQkJbglOb3JtYWwKCQkJbm8JT3BlcmF0b3ItcGVuZGluZwoJCQl2CVZpc3VhbCBieSBjaGFyYWN0ZXIKCQkJVglWaXN1YWwgYnkgbGluZQoJCQlDVFJMLVYJVmlzdWFsIGJsb2Nrd2lzZQoJCQlzCVNlbGVjdCBieSBjaGFyYWN0ZXIKCQkJUwlTZWxlY3QgYnkgbGluZQoJCQlDVFJMLVMJU2VsZWN0IGJsb2Nrd2lzZQoJCQlpCUluc2VydAoJCQlSCVJlcGxhY2UgfFJ8CgkJCVJ2CVZpcnR1YWwgUmVwbGFjZSB8Z1J8CgkJCWMJQ29tbWFuZC1saW5lCgkJCWN2CVZpbSBFeCBtb2RlIHxnUXwKCQkJY2UJTm9ybWFsIEV4IG1vZGUgfFF8CgkJCXIJSGl0LWVudGVyIHByb21wdAoJCQlybQlUaGUgLS0gbW9yZSAtLSBwcm9tcHQKCQkJcj8JQSB8OmNvbmZpcm18IHF1ZXJ5IG9mIHNvbWUgc29ydAoJCQkhCVNoZWxsIG9yIGV4dGVybmFsIGNvbW1hbmQgaXMgZXhlY3V0aW5nCgkJVGhpcyBpcyB1c2VmdWwgaW4gdGhlICdzdGF0dXNsaW5lJyBvcHRpb24gb3Igd2hlbiB1c2VkCgkJd2l0aCB8cmVtb3RlX2V4cHIoKXwgSW4gbW9zdCBvdGhlciBwbGFjZXMgaXQgYWx3YXlzIHJldHVybnMKCQkiYyIgb3IgIm4iLgoJCUFsc28gc2VlIHx2aXN1YWxtb2RlKCl8LgoKbXpldmFsKHtleHByfSkJCQkJCQkJKm16ZXZhbCgpKgoJCUV2YWx1YXRlIE16U2NoZW1lIGV4cHJlc3Npb24ge2V4cHJ9IGFuZCByZXR1cm4gaXRzIHJlc3VsdAoJCWNvbnZlcnRlZCB0byBWaW0gZGF0YSBzdHJ1Y3R1cmVzLgoJCU51bWJlcnMgYW5kIHN0cmluZ3MgYXJlIHJldHVybmVkIGFzIHRoZXkgYXJlLgoJCVBhaXJzIChpbmNsdWRpbmcgbGlzdHMgYW5kIGltcHJvcGVyIGxpc3RzKSBhbmQgdmVjdG9ycyBhcmUKCQlyZXR1cm5lZCBhcyBWaW0gfExpc3RzfC4KCQlIYXNoIHRhYmxlcyBhcmUgcmVwcmVzZW50ZWQgYXMgVmltIHxEaWN0aW9uYXJ5fCB0eXBlIHdpdGgga2V5cwoJCWNvbnZlcnRlZCB0byBzdHJpbmdzLgoJCUFsbCBvdGhlciB0eXBlcyBhcmUgY29udmVydGVkIHRvIHN0cmluZyB3aXRoIGRpc3BsYXkgZnVuY3Rpb24uCgkJRXhhbXBsZXM6ID4KCQkgICAgOm16IChkZWZpbmUgbCAobGlzdCAxIDIgMykpCgkJICAgIDpteiAoZGVmaW5lIGggKG1ha2UtaGFzaCkpIChoYXNoLXNldCEgaCAibGlzdCIgbCkKCQkgICAgOmVjaG8gbXpldmFsKCJsIikKCQkgICAgOmVjaG8gbXpldmFsKCJoIikKPAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXpzY2hlbWV8IGZlYXR1cmV9CgpuZXh0bm9uYmxhbmsoe2xudW19KQkJCQkJKm5leHRub25ibGFuaygpKgoJCVJldHVybiB0aGUgbGluZSBudW1iZXIgb2YgdGhlIGZpcnN0IGxpbmUgYXQgb3IgYmVsb3cge2xudW19CgkJdGhhdCBpcyBub3QgYmxhbmsuICBFeGFtcGxlOiA+CgkJCWlmIGdldGxpbmUobmV4dG5vbmJsYW5rKDEpKSA9fiAiSmF2YSIKPAkJV2hlbiB7bG51bX0gaXMgaW52YWxpZCBvciB0aGVyZSBpcyBubyBub24tYmxhbmsgbGluZSBhdCBvcgoJCWJlbG93IGl0LCB6ZXJvIGlzIHJldHVybmVkLgoJCVNlZSBhbHNvIHxwcmV2bm9uYmxhbmsoKXwuCgpucjJjaGFyKHtleHByfVssIHt1dGY4fV0pCQkJCSpucjJjaGFyKCkqCgkJUmV0dXJuIGEgc3RyaW5nIHdpdGggYSBzaW5nbGUgY2hhcmFjdGVyLCB3aGljaCBoYXMgdGhlIG51bWJlcgoJCXZhbHVlIHtleHByfS4gIEV4YW1wbGVzOiA+CgkJCW5yMmNoYXIoNjQpCQlyZXR1cm5zICJAIgoJCQlucjJjaGFyKDMyKQkJcmV0dXJucyAiICIKPAkJV2hlbiB7dXRmOH0gaXMgb21pdHRlZCBvciB6ZXJvLCB0aGUgY3VycmVudCAnZW5jb2RpbmcnIGlzIHVzZWQuCgkJRXhhbXBsZSBmb3IgInV0Zi04IjogPgoJCQlucjJjaGFyKDMwMCkJCXJldHVybnMgSSB3aXRoIGJvdyBjaGFyYWN0ZXIKPAkJV2l0aCB7dXRmOH0gc2V0IHRvIDEsIGFsd2F5cyByZXR1cm4gdXRmLTggY2hhcmFjdGVycy4KCQlOb3RlIHRoYXQgYSBOVUwgY2hhcmFjdGVyIGluIHRoZSBmaWxlIGlzIHNwZWNpZmllZCB3aXRoCgkJbnIyY2hhcigxMCksIGJlY2F1c2UgTlVMcyBhcmUgcmVwcmVzZW50ZWQgd2l0aCBuZXdsaW5lCgkJY2hhcmFjdGVycy4gIG5yMmNoYXIoMCkgaXMgYSByZWFsIE5VTCBhbmQgdGVybWluYXRlcyB0aGUKCQlzdHJpbmcsIHRodXMgcmVzdWx0cyBpbiBhbiBlbXB0eSBzdHJpbmcuCgpvcih7ZXhwcn0sIHtleHByfSkJCQkJCSpvcigpKgoJCUJpdHdpc2UgT1Igb24gdGhlIHR3byBhcmd1bWVudHMuICBUaGUgYXJndW1lbnRzIGFyZSBjb252ZXJ0ZWQKCQl0byBhIG51bWJlci4gIEEgTGlzdCwgRGljdCBvciBGbG9hdCBhcmd1bWVudCBjYXVzZXMgYW4gZXJyb3IuCgkJRXhhbXBsZTogPgoJCQk6bGV0IGJpdHMgPSBvcihiaXRzLCAweDgwKQoKCnBhdGhzaG9ydGVuKHtleHByfSkJCQkJCSpwYXRoc2hvcnRlbigpKgoJCVNob3J0ZW4gZGlyZWN0b3J5IG5hbWVzIGluIHRoZSBwYXRoIHtleHByfSBhbmQgcmV0dXJuIHRoZQoJCXJlc3VsdC4gIFRoZSB0YWlsLCB0aGUgZmlsZSBuYW1lLCBpcyBrZXB0IGFzLWlzLiAgVGhlIG90aGVyCgkJY29tcG9uZW50cyBpbiB0aGUgcGF0aCBhcmUgcmVkdWNlZCB0byBzaW5nbGUgbGV0dGVycy4gIExlYWRpbmcKCQknficgYW5kICcuJyBjaGFyYWN0ZXJzIGFyZSBrZXB0LiAgRXhhbXBsZTogPgoJCQk6ZWNobyBwYXRoc2hvcnRlbignfi8udmltL2F1dG9sb2FkL215ZmlsZS52aW0nKQo8CQkJfi8udi9hL215ZmlsZS52aW0gfgoJCUl0IGRvZXNuJ3QgbWF0dGVyIGlmIHRoZSBwYXRoIGV4aXN0cyBvciBub3QuCgpwZXJsZXZhbCh7ZXhwcn0pCQkJCQkqcGVybGV2YWwoKSoKCQlFdmFsdWF0ZSBQZXJsIGV4cHJlc3Npb24ge2V4cHJ9IGluIHNjYWxhciBjb250ZXh0IGFuZCByZXR1cm4KCQlpdHMgcmVzdWx0IGNvbnZlcnRlZCB0byBWaW0gZGF0YSBzdHJ1Y3R1cmVzLiBJZiB2YWx1ZSBjYW4ndCBiZQoJCWNvbnZlcnRlZCwgaXQgaXMgcmV0dXJuZWQgYXMgYSBzdHJpbmcgUGVybCByZXByZXNlbnRhdGlvbi4KCQlOb3RlOiBJZiB5b3Ugd2FudCBhbiBhcnJheSBvciBoYXNoLCB7ZXhwcn0gbXVzdCByZXR1cm4gYQoJCXJlZmVyZW5jZSB0byBpdC4KCQlFeGFtcGxlOiA+CgkJCTplY2hvIHBlcmxldmFsKCdbMSAuLiA0XScpCjwJCQlbMSwgMiwgMywgNF0KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3Blcmx8IGZlYXR1cmV9Cgpwb3coe3h9LCB7eX0pCQkJCQkJKnBvdygpKgoJCVJldHVybiB0aGUgcG93ZXIgb2Yge3h9IHRvIHRoZSBleHBvbmVudCB7eX0gYXMgYSB8RmxvYXR8LgoJCXt4fSBhbmQge3l9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gcG93KDMsIDMpCjwJCQkyNy4wID4KCQkJOmVjaG8gcG93KDIsIDE2KQo8CQkJNjU1MzYuMCA+CgkJCTplY2hvIHBvdygzMiwgMC4yMCkKPAkJCTIuMAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJCnByZXZub25ibGFuayh7bG51bX0pCQkJCQkqcHJldm5vbmJsYW5rKCkqCgkJUmV0dXJuIHRoZSBsaW5lIG51bWJlciBvZiB0aGUgZmlyc3QgbGluZSBhdCBvciBhYm92ZSB7bG51bX0KCQl0aGF0IGlzIG5vdCBibGFuay4gIEV4YW1wbGU6ID4KCQkJbGV0IGluZCA9IGluZGVudChwcmV2bm9uYmxhbmsodjpsbnVtIC0gMSkpCjwJCVdoZW4ge2xudW19IGlzIGludmFsaWQgb3IgdGhlcmUgaXMgbm8gbm9uLWJsYW5rIGxpbmUgYXQgb3IKCQlhYm92ZSBpdCwgemVybyBpcyByZXR1cm5lZC4KCQlBbHNvIHNlZSB8bmV4dG5vbmJsYW5rKCl8LgoKCnByaW50Zih7Zm10fSwge2V4cHIxfSAuLi4pCQkJCSpwcmludGYoKSoKCQlSZXR1cm4gYSBTdHJpbmcgd2l0aCB7Zm10fSwgd2hlcmUgIiUiIGl0ZW1zIGFyZSByZXBsYWNlZCBieQoJCXRoZSBmb3JtYXR0ZWQgZm9ybSBvZiB0aGVpciByZXNwZWN0aXZlIGFyZ3VtZW50cy4gIEV4YW1wbGU6ID4KCQkJcHJpbnRmKCIlNGQ6IEUlZCAlLjMwcyIsIGxudW0sIGVycm5vLCBtc2cpCjwJCU1heSByZXN1bHQgaW46CgkJCSIgIDk5OiBFNDIgYXNkZmFzZGZhc2RmYXNkZmFzZGZhc2RmYXNkZmFzIiB+CgoJCU9mdGVuIHVzZWQgaXRlbXMgYXJlOgoJCSAgJXMJc3RyaW5nCgkJICAlNlMJc3RyaW5nIHJpZ2h0LWFsaWduZWQgaW4gNiBkaXNwbGF5IGNlbGxzCgkJICAlNnMJc3RyaW5nIHJpZ2h0LWFsaWduZWQgaW4gNiBieXRlcwoJCSAgJS45cwlzdHJpbmcgdHJ1bmNhdGVkIHRvIDkgYnl0ZXMKCQkgICVjCXNpbmdsZSBieXRlCgkJICAlZAlkZWNpbWFsIG51bWJlcgoJCSAgJTVkCWRlY2ltYWwgbnVtYmVyIHBhZGRlZCB3aXRoIHNwYWNlcyB0byA1IGNoYXJhY3RlcnMKCQkgICV4CWhleCBudW1iZXIKCQkgICUwNHgJaGV4IG51bWJlciBwYWRkZWQgd2l0aCB6ZXJvcyB0byBhdCBsZWFzdCA0IGNoYXJhY3RlcnMKCQkgICVYCWhleCBudW1iZXIgdXNpbmcgdXBwZXIgY2FzZSBsZXR0ZXJzCgkJICAlbwlvY3RhbCBudW1iZXIKCQkgICVmCWZsb2F0aW5nIHBvaW50IG51bWJlciBpbiB0aGUgZm9ybSAxMjMuNDU2CgkJICAlZQlmbG9hdGluZyBwb2ludCBudW1iZXIgaW4gdGhlIGZvcm0gMS4yMzRlMwoJCSAgJUUJZmxvYXRpbmcgcG9pbnQgbnVtYmVyIGluIHRoZSBmb3JtIDEuMjM0RTMKCQkgICVnCWZsb2F0aW5nIHBvaW50IG51bWJlciwgYXMgJWYgb3IgJWUgZGVwZW5kaW5nIG9uIHZhbHVlCgkJICAlRwlmbG9hdGluZyBwb2ludCBudW1iZXIsIGFzICVmIG9yICVFIGRlcGVuZGluZyBvbiB2YWx1ZQoJCSAgJSUJdGhlICUgY2hhcmFjdGVyIGl0c2VsZgoKCQlDb252ZXJzaW9uIHNwZWNpZmljYXRpb25zIHN0YXJ0IHdpdGggJyUnIGFuZCBlbmQgd2l0aCB0aGUKCQljb252ZXJzaW9uIHR5cGUuICBBbGwgb3RoZXIgY2hhcmFjdGVycyBhcmUgY29waWVkIHVuY2hhbmdlZCB0bwoJCXRoZSByZXN1bHQuCgoJCVRoZSAiJSIgc3RhcnRzIGEgY29udmVyc2lvbiBzcGVjaWZpY2F0aW9uLiAgVGhlIGZvbGxvd2luZwoJCWFyZ3VtZW50cyBhcHBlYXIgaW4gc2VxdWVuY2U6CgoJCQklICBbZmxhZ3NdICBbZmllbGQtd2lkdGhdICBbLnByZWNpc2lvbl0gIHR5cGUKCgkJZmxhZ3MKCQkJWmVybyBvciBtb3JlIG9mIHRoZSBmb2xsb3dpbmcgZmxhZ3M6CgoJCSAgICAjCSAgICAgIFRoZSB2YWx1ZSBzaG91bGQgYmUgY29udmVydGVkIHRvIGFuICJhbHRlcm5hdGUKCQkJICAgICAgZm9ybSIuICBGb3IgYywgZCwgYW5kIHMgY29udmVyc2lvbnMsIHRoaXMgb3B0aW9uCgkJCSAgICAgIGhhcyBubyBlZmZlY3QuICBGb3IgbyBjb252ZXJzaW9ucywgdGhlIHByZWNpc2lvbgoJCQkgICAgICBvZiB0aGUgbnVtYmVyIGlzIGluY3JlYXNlZCB0byBmb3JjZSB0aGUgZmlyc3QKCQkJICAgICAgY2hhcmFjdGVyIG9mIHRoZSBvdXRwdXQgc3RyaW5nIHRvIGEgemVybyAoZXhjZXB0CgkJCSAgICAgIGlmIGEgemVybyB2YWx1ZSBpcyBwcmludGVkIHdpdGggYW4gZXhwbGljaXQKCQkJICAgICAgcHJlY2lzaW9uIG9mIHplcm8pLgoJCQkgICAgICBGb3IgeCBhbmQgWCBjb252ZXJzaW9ucywgYSBub24temVybyByZXN1bHQgaGFzCgkJCSAgICAgIHRoZSBzdHJpbmcgIjB4IiAob3IgIjBYIiBmb3IgWCBjb252ZXJzaW9ucykKCQkJICAgICAgcHJlcGVuZGVkIHRvIGl0LgoKCQkgICAgMCAoemVybykgIFplcm8gcGFkZGluZy4gIEZvciBhbGwgY29udmVyc2lvbnMgdGhlIGNvbnZlcnRlZAoJCQkgICAgICB2YWx1ZSBpcyBwYWRkZWQgb24gdGhlIGxlZnQgd2l0aCB6ZXJvcyByYXRoZXIKCQkJICAgICAgdGhhbiBibGFua3MuICBJZiBhIHByZWNpc2lvbiBpcyBnaXZlbiB3aXRoIGEKCQkJICAgICAgbnVtZXJpYyBjb252ZXJzaW9uIChkLCBvLCB4LCBhbmQgWCksIHRoZSAwIGZsYWcKCQkJICAgICAgaXMgaWdub3JlZC4KCgkJICAgIC0JICAgICAgQSBuZWdhdGl2ZSBmaWVsZCB3aWR0aCBmbGFnOyB0aGUgY29udmVydGVkIHZhbHVlCgkJCSAgICAgIGlzIHRvIGJlIGxlZnQgYWRqdXN0ZWQgb24gdGhlIGZpZWxkIGJvdW5kYXJ5LgoJCQkgICAgICBUaGUgY29udmVydGVkIHZhbHVlIGlzIHBhZGRlZCBvbiB0aGUgcmlnaHQgd2l0aAoJCQkgICAgICBibGFua3MsIHJhdGhlciB0aGFuIG9uIHRoZSBsZWZ0IHdpdGggYmxhbmtzIG9yCgkJCSAgICAgIHplcm9zLiAgQSAtIG92ZXJyaWRlcyBhIDAgaWYgYm90aCBhcmUgZ2l2ZW4uCgoJCSAgICAnICcgKHNwYWNlKSAgQSBibGFuayBzaG91bGQgYmUgbGVmdCBiZWZvcmUgYSBwb3NpdGl2ZQoJCQkgICAgICBudW1iZXIgcHJvZHVjZWQgYnkgYSBzaWduZWQgY29udmVyc2lvbiAoZCkuCgoJCSAgICArCSAgICAgIEEgc2lnbiBtdXN0IGFsd2F5cyBiZSBwbGFjZWQgYmVmb3JlIGEgbnVtYmVyCgkJCSAgICAgIHByb2R1Y2VkIGJ5IGEgc2lnbmVkIGNvbnZlcnNpb24uCUEgKyBvdmVycmlkZXMKCQkJICAgICAgYSBzcGFjZSBpZiBib3RoIGFyZSB1c2VkLgoKCQlmaWVsZC13aWR0aAoJCQlBbiBvcHRpb25hbCBkZWNpbWFsIGRpZ2l0IHN0cmluZyBzcGVjaWZ5aW5nIGEgbWluaW11bQoJCQlmaWVsZCB3aWR0aC4gIElmIHRoZSBjb252ZXJ0ZWQgdmFsdWUgaGFzIGZld2VyIGJ5dGVzCgkJCXRoYW4gdGhlIGZpZWxkIHdpZHRoLCBpdCB3aWxsIGJlIHBhZGRlZCB3aXRoIHNwYWNlcyBvbgoJCQl0aGUgbGVmdCAob3IgcmlnaHQsIGlmIHRoZSBsZWZ0LWFkanVzdG1lbnQgZmxhZyBoYXMKCQkJYmVlbiBnaXZlbikgdG8gZmlsbCBvdXQgdGhlIGZpZWxkIHdpZHRoLgoKCQkucHJlY2lzaW9uCgkJCUFuIG9wdGlvbmFsIHByZWNpc2lvbiwgaW4gdGhlIGZvcm0gb2YgYSBwZXJpb2QgJy4nCgkJCWZvbGxvd2VkIGJ5IGFuIG9wdGlvbmFsIGRpZ2l0IHN0cmluZy4gIElmIHRoZSBkaWdpdAoJCQlzdHJpbmcgaXMgb21pdHRlZCwgdGhlIHByZWNpc2lvbiBpcyB0YWtlbiBhcyB6ZXJvLgoJCQlUaGlzIGdpdmVzIHRoZSBtaW5pbXVtIG51bWJlciBvZiBkaWdpdHMgdG8gYXBwZWFyIGZvcgoJCQlkLCBvLCB4LCBhbmQgWCBjb252ZXJzaW9ucywgb3IgdGhlIG1heGltdW0gbnVtYmVyIG9mCgkJCWJ5dGVzIHRvIGJlIHByaW50ZWQgZnJvbSBhIHN0cmluZyBmb3IgcyBjb252ZXJzaW9ucy4KCQkJRm9yIGZsb2F0aW5nIHBvaW50IGl0IGlzIHRoZSBudW1iZXIgb2YgZGlnaXRzIGFmdGVyCgkJCXRoZSBkZWNpbWFsIHBvaW50LgoKCQl0eXBlCgkJCUEgY2hhcmFjdGVyIHRoYXQgc3BlY2lmaWVzIHRoZSB0eXBlIG9mIGNvbnZlcnNpb24gdG8KCQkJYmUgYXBwbGllZCwgc2VlIGJlbG93LgoKCQlBIGZpZWxkIHdpZHRoIG9yIHByZWNpc2lvbiwgb3IgYm90aCwgbWF5IGJlIGluZGljYXRlZCBieSBhbgoJCWFzdGVyaXNrICcqJyBpbnN0ZWFkIG9mIGEgZGlnaXQgc3RyaW5nLiAgSW4gdGhpcyBjYXNlLCBhCgkJTnVtYmVyIGFyZ3VtZW50IHN1cHBsaWVzIHRoZSBmaWVsZCB3aWR0aCBvciBwcmVjaXNpb24uCUEKCQluZWdhdGl2ZSBmaWVsZCB3aWR0aCBpcyB0cmVhdGVkIGFzIGEgbGVmdCBhZGp1c3RtZW50IGZsYWcKCQlmb2xsb3dlZCBieSBhIHBvc2l0aXZlIGZpZWxkIHdpZHRoOyBhIG5lZ2F0aXZlIHByZWNpc2lvbiBpcwoJCXRyZWF0ZWQgYXMgdGhvdWdoIGl0IHdlcmUgbWlzc2luZy4gIEV4YW1wbGU6ID4KCQkJOmVjaG8gcHJpbnRmKCIlZDogJS4qcyIsIG5yLCB3aWR0aCwgbGluZSkKPAkJVGhpcyBsaW1pdHMgdGhlIGxlbmd0aCBvZiB0aGUgdGV4dCB1c2VkIGZyb20gImxpbmUiIHRvCgkJIndpZHRoIiBieXRlcy4KCgkJVGhlIGNvbnZlcnNpb24gc3BlY2lmaWVycyBhbmQgdGhlaXIgbWVhbmluZ3MgYXJlOgoKCQkJCSpwcmludGYtZCogKnByaW50Zi1vKiAqcHJpbnRmLXgqICpwcmludGYtWCoKCQlkb3hYCVRoZSBOdW1iZXIgYXJndW1lbnQgaXMgY29udmVydGVkIHRvIHNpZ25lZCBkZWNpbWFsCgkJCShkKSwgdW5zaWduZWQgb2N0YWwgKG8pLCBvciB1bnNpZ25lZCBoZXhhZGVjaW1hbCAoeAoJCQlhbmQgWCkgbm90YXRpb24uICBUaGUgbGV0dGVycyAiYWJjZGVmIiBhcmUgdXNlZCBmb3IKCQkJeCBjb252ZXJzaW9uczsgdGhlIGxldHRlcnMgIkFCQ0RFRiIgYXJlIHVzZWQgZm9yIFgKCQkJY29udmVyc2lvbnMuCgkJCVRoZSBwcmVjaXNpb24sIGlmIGFueSwgZ2l2ZXMgdGhlIG1pbmltdW0gbnVtYmVyIG9mCgkJCWRpZ2l0cyB0aGF0IG11c3QgYXBwZWFyOyBpZiB0aGUgY29udmVydGVkIHZhbHVlCgkJCXJlcXVpcmVzIGZld2VyIGRpZ2l0cywgaXQgaXMgcGFkZGVkIG9uIHRoZSBsZWZ0IHdpdGgKCQkJemVyb3MuCgkJCUluIG5vIGNhc2UgZG9lcyBhIG5vbi1leGlzdGVudCBvciBzbWFsbCBmaWVsZCB3aWR0aAoJCQljYXVzZSB0cnVuY2F0aW9uIG9mIGEgbnVtZXJpYyBmaWVsZDsgaWYgdGhlIHJlc3VsdCBvZgoJCQlhIGNvbnZlcnNpb24gaXMgd2lkZXIgdGhhbiB0aGUgZmllbGQgd2lkdGgsIHRoZSBmaWVsZAoJCQlpcyBleHBhbmRlZCB0byBjb250YWluIHRoZSBjb252ZXJzaW9uIHJlc3VsdC4KCgkJCQkJCQkqcHJpbnRmLWMqCgkJYwlUaGUgTnVtYmVyIGFyZ3VtZW50IGlzIGNvbnZlcnRlZCB0byBhIGJ5dGUsIGFuZCB0aGUKCQkJcmVzdWx0aW5nIGNoYXJhY3RlciBpcyB3cml0dGVuLgoKCQkJCQkJCSpwcmludGYtcyoKCQlzCVRoZSB0ZXh0IG9mIHRoZSBTdHJpbmcgYXJndW1lbnQgaXMgdXNlZC4gIElmIGEKCQkJcHJlY2lzaW9uIGlzIHNwZWNpZmllZCwgbm8gbW9yZSBieXRlcyB0aGFuIHRoZSBudW1iZXIKCQkJc3BlY2lmaWVkIGFyZSB1c2VkLgoJCQkJCQkJKnByaW50Zi1TKgoJCVMJVGhlIHRleHQgb2YgdGhlIFN0cmluZyBhcmd1bWVudCBpcyB1c2VkLiAgSWYgYQoJCQlwcmVjaXNpb24gaXMgc3BlY2lmaWVkLCBubyBtb3JlIGRpc3BsYXkgY2VsbHMgdGhhbiB0aGUKCQkJbnVtYmVyIHNwZWNpZmllZCBhcmUgdXNlZC4gIFdpdGhvdXQgdGhlIHwrbXVsdGlfYnl0ZXwKCQkJZmVhdHVyZSB3b3JrcyBqdXN0IGxpa2UgJ3MnLgoKCQkJCQkJCSpwcmludGYtZiogKkU4MDcqCgkJZglUaGUgRmxvYXQgYXJndW1lbnQgaXMgY29udmVydGVkIGludG8gYSBzdHJpbmcgb2YgdGhlIAoJCQlmb3JtIDEyMy40NTYuICBUaGUgcHJlY2lzaW9uIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mCgkJCWRpZ2l0cyBhZnRlciB0aGUgZGVjaW1hbCBwb2ludC4gIFdoZW4gdGhlIHByZWNpc2lvbiBpcwoJCQl6ZXJvIHRoZSBkZWNpbWFsIHBvaW50IGlzIG9taXR0ZWQuICBXaGVuIHRoZSBwcmVjaXNpb24KCQkJaXMgbm90IHNwZWNpZmllZCA2IGlzIHVzZWQuICBBIHJlYWxseSBiaWcgbnVtYmVyCgkJCShvdXQgb2YgcmFuZ2Ugb3IgZGl2aWRpbmcgYnkgemVybykgcmVzdWx0cyBpbiAiaW5mIi4KCQkJIjAuMCAvIDAuMCIgcmVzdWx0cyBpbiAibmFuIi4KCQkJRXhhbXBsZTogPgoJCQkJZWNobyBwcmludGYoIiUuMmYiLCAxMi4xMTUpCjwJCQkJMTIuMTIKCQkJTm90ZSB0aGF0IHJvdW5kb2ZmIGRlcGVuZHMgb24gdGhlIHN5c3RlbSBsaWJyYXJpZXMuCgkJCVVzZSB8cm91bmQoKXwgd2hlbiBpbiBkb3VidC4KCgkJCQkJCQkqcHJpbnRmLWUqICpwcmludGYtRSoKCQllIEUJVGhlIEZsb2F0IGFyZ3VtZW50IGlzIGNvbnZlcnRlZCBpbnRvIGEgc3RyaW5nIG9mIHRoZQoJCQlmb3JtIDEuMjM0ZSswMyBvciAxLjIzNEUrMDMgd2hlbiB1c2luZyAnRScuICBUaGUKCQkJcHJlY2lzaW9uIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIGRpZ2l0cyBhZnRlciB0aGUKCQkJZGVjaW1hbCBwb2ludCwgbGlrZSB3aXRoICdmJy4KCgkJCQkJCQkqcHJpbnRmLWcqICpwcmludGYtRyoKCQlnIEcJVGhlIEZsb2F0IGFyZ3VtZW50IGlzIGNvbnZlcnRlZCBsaWtlIHdpdGggJ2YnIGlmIHRoZQoJCQl2YWx1ZSBpcyBiZXR3ZWVuIDAuMDAxIChpbmNsdXNpdmUpIGFuZCAxMDAwMDAwMC4wCgkJCShleGNsdXNpdmUpLiAgT3RoZXJ3aXNlICdlJyBpcyB1c2VkIGZvciAnZycgYW5kICdFJwoJCQlmb3IgJ0cnLiAgV2hlbiBubyBwcmVjaXNpb24gaXMgc3BlY2lmaWVkIHN1cGVyZmx1b3VzCgkJCXplcm9lcyBhbmQgJysnIHNpZ25zIGFyZSByZW1vdmVkLCBleGNlcHQgZm9yIHRoZSB6ZXJvCgkJCWltbWVkaWF0ZWx5IGFmdGVyIHRoZSBkZWNpbWFsIHBvaW50LiAgVGh1cyAxMDAwMDAwMC4wCgkJCXJlc3VsdHMgaW4gMS4wZTcuCgoJCQkJCQkJKnByaW50Zi0lKgoJCSUJQSAnJScgaXMgd3JpdHRlbi4gIE5vIGFyZ3VtZW50IGlzIGNvbnZlcnRlZC4gIFRoZQoJCQljb21wbGV0ZSBjb252ZXJzaW9uIHNwZWNpZmljYXRpb24gaXMgIiUlIi4KCgkJV2hlbiBhIE51bWJlciBhcmd1bWVudCBpcyBleHBlY3RlZCBhIFN0cmluZyBhcmd1bWVudCBpcyBhbHNvCgkJYWNjZXB0ZWQgYW5kIGF1dG9tYXRpY2FsbHkgY29udmVydGVkLgoJCVdoZW4gYSBGbG9hdCBvciBTdHJpbmcgYXJndW1lbnQgaXMgZXhwZWN0ZWQgYSBOdW1iZXIgYXJndW1lbnQKCQlpcyBhbHNvIGFjY2VwdGVkIGFuZCBhdXRvbWF0aWNhbGx5IGNvbnZlcnRlZC4KCQlBbnkgb3RoZXIgYXJndW1lbnQgdHlwZSByZXN1bHRzIGluIGFuIGVycm9yIG1lc3NhZ2UuCgoJCQkJCQkJKkU3NjYqICpFNzY3KgoJCVRoZSBudW1iZXIgb2Yge2V4cHJOfSBhcmd1bWVudHMgbXVzdCBleGFjdGx5IG1hdGNoIHRoZSBudW1iZXIKCQlvZiAiJSIgaXRlbXMuICBJZiB0aGVyZSBhcmUgbm90IHN1ZmZpY2llbnQgb3IgdG9vIG1hbnkKCQlhcmd1bWVudHMgYW4gZXJyb3IgaXMgZ2l2ZW4uICBVcCB0byAxOCBhcmd1bWVudHMgY2FuIGJlIHVzZWQuCgoKcHVtdmlzaWJsZSgpCQkJCQkJKnB1bXZpc2libGUoKSoKCQlSZXR1cm5zIG5vbi16ZXJvIHdoZW4gdGhlIHBvcHVwIG1lbnUgaXMgdmlzaWJsZSwgemVybwoJCW90aGVyd2lzZS4gIFNlZSB8aW5zLWNvbXBsZXRpb24tbWVudXwuCgkJVGhpcyBjYW4gYmUgdXNlZCB0byBhdm9pZCBzb21lIHRoaW5ncyB0aGF0IHdvdWxkIHJlbW92ZSB0aGUKCQlwb3B1cCBtZW51LgoKcHkzZXZhbCh7ZXhwcn0pCQkJCQkJKnB5M2V2YWwoKSoKCQlFdmFsdWF0ZSBQeXRob24gZXhwcmVzc2lvbiB7ZXhwcn0gYW5kIHJldHVybiBpdHMgcmVzdWx0CgkJY29udmVydGVkIHRvIFZpbSBkYXRhIHN0cnVjdHVyZXMuCgkJTnVtYmVycyBhbmQgc3RyaW5ncyBhcmUgcmV0dXJuZWQgYXMgdGhleSBhcmUgKHN0cmluZ3MgYXJlIAoJCWNvcGllZCB0aG91Z2gsIFVuaWNvZGUgc3RyaW5ncyBhcmUgYWRkaXRpb25hbGx5IGNvbnZlcnRlZCB0byAKCQknZW5jb2RpbmcnKS4KCQlMaXN0cyBhcmUgcmVwcmVzZW50ZWQgYXMgVmltIHxMaXN0fCB0eXBlLgoJCURpY3Rpb25hcmllcyBhcmUgcmVwcmVzZW50ZWQgYXMgVmltIHxEaWN0aW9uYXJ5fCB0eXBlIHdpdGggCgkJa2V5cyBjb252ZXJ0ZWQgdG8gc3RyaW5ncy4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3B5dGhvbjN8IGZlYXR1cmV9CgoJCQkJCQkJKkU4NTgqICpFODU5KgpweWV2YWwoe2V4cHJ9KQkJCQkJCSpweWV2YWwoKSoKCQlFdmFsdWF0ZSBQeXRob24gZXhwcmVzc2lvbiB7ZXhwcn0gYW5kIHJldHVybiBpdHMgcmVzdWx0CgkJY29udmVydGVkIHRvIFZpbSBkYXRhIHN0cnVjdHVyZXMuCgkJTnVtYmVycyBhbmQgc3RyaW5ncyBhcmUgcmV0dXJuZWQgYXMgdGhleSBhcmUgKHN0cmluZ3MgYXJlIAoJCWNvcGllZCB0aG91Z2gpLgoJCUxpc3RzIGFyZSByZXByZXNlbnRlZCBhcyBWaW0gfExpc3R8IHR5cGUuCgkJRGljdGlvbmFyaWVzIGFyZSByZXByZXNlbnRlZCBhcyBWaW0gfERpY3Rpb25hcnl8IHR5cGUsIAoJCW5vbi1zdHJpbmcga2V5cyByZXN1bHQgaW4gZXJyb3IuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtweXRob258IGZlYXR1cmV9CgoJCQkJCQkJKkU3MjYqICpFNzI3KgpyYW5nZSh7ZXhwcn0gWywge21heH0gWywge3N0cmlkZX1dXSkJCQkJKnJhbmdlKCkqCgkJUmV0dXJucyBhIHxMaXN0fCB3aXRoIE51bWJlcnM6CgkJLSBJZiBvbmx5IHtleHByfSBpcyBzcGVjaWZpZWQ6IFswLCAxLCAuLi4sIHtleHByfSAtIDFdCgkJLSBJZiB7bWF4fSBpcyBzcGVjaWZpZWQ6IFt7ZXhwcn0sIHtleHByfSArIDEsIC4uLiwge21heH1dCgkJLSBJZiB7c3RyaWRlfSBpcyBzcGVjaWZpZWQ6IFt7ZXhwcn0sIHtleHByfSArIHtzdHJpZGV9LCAuLi4sCgkJICB7bWF4fV0gKGluY3JlYXNpbmcge2V4cHJ9IHdpdGgge3N0cmlkZX0gZWFjaCB0aW1lLCBub3QKCQkgIHByb2R1Y2luZyBhIHZhbHVlIHBhc3Qge21heH0pLgoJCVdoZW4gdGhlIG1heGltdW0gaXMgb25lIGJlZm9yZSB0aGUgc3RhcnQgdGhlIHJlc3VsdCBpcyBhbgoJCWVtcHR5IGxpc3QuICBXaGVuIHRoZSBtYXhpbXVtIGlzIG1vcmUgdGhhbiBvbmUgYmVmb3JlIHRoZQoJCXN0YXJ0IHRoaXMgaXMgYW4gZXJyb3IuCgkJRXhhbXBsZXM6ID4KCQkJcmFuZ2UoNCkJCSIgWzAsIDEsIDIsIDNdCgkJCXJhbmdlKDIsIDQpCQkiIFsyLCAzLCA0XQoJCQlyYW5nZSgyLCA5LCAzKQkJIiBbMiwgNSwgOF0KCQkJcmFuZ2UoMiwgLTIsIC0xKQkiIFsyLCAxLCAwLCAtMSwgLTJdCgkJCXJhbmdlKDApCQkiIFtdCgkJCXJhbmdlKDIsIDApCQkiIGVycm9yIQo8CgkJCQkJCQkqcmVhZGZpbGUoKSoKcmVhZGZpbGUoe2ZuYW1lfSBbLCB7YmluYXJ5fSBbLCB7bWF4fV1dKQoJCVJlYWQgZmlsZSB7Zm5hbWV9IGFuZCByZXR1cm4gYSB8TGlzdHwsIGVhY2ggbGluZSBvZiB0aGUgZmlsZQoJCWFzIGFuIGl0ZW0uICBMaW5lcyBicm9rZW4gYXQgTkwgY2hhcmFjdGVycy4gIE1hY2ludG9zaCBmaWxlcwoJCXNlcGFyYXRlZCB3aXRoIENSIHdpbGwgcmVzdWx0IGluIGEgc2luZ2xlIGxvbmcgbGluZSAodW5sZXNzIGEKCQlOTCBhcHBlYXJzIHNvbWV3aGVyZSkuCgkJQWxsIE5VTCBjaGFyYWN0ZXJzIGFyZSByZXBsYWNlZCB3aXRoIGEgTkwgY2hhcmFjdGVyLgoJCVdoZW4ge2JpbmFyeX0gY29udGFpbnMgImIiIGJpbmFyeSBtb2RlIGlzIHVzZWQ6CgkJLSBXaGVuIHRoZSBsYXN0IGxpbmUgZW5kcyBpbiBhIE5MIGFuIGV4dHJhIGVtcHR5IGxpc3QgaXRlbSBpcwoJCSAgYWRkZWQuCgkJLSBObyBDUiBjaGFyYWN0ZXJzIGFyZSByZW1vdmVkLgoJCU90aGVyd2lzZToKCQktIENSIGNoYXJhY3RlcnMgdGhhdCBhcHBlYXIgYmVmb3JlIGEgTkwgYXJlIHJlbW92ZWQuCgkJLSBXaGV0aGVyIHRoZSBsYXN0IGxpbmUgZW5kcyBpbiBhIE5MIG9yIG5vdCBkb2VzIG5vdCBtYXR0ZXIuCgkJLSBXaGVuICdlbmNvZGluZycgaXMgVW5pY29kZSBhbnkgVVRGLTggYnl0ZSBvcmRlciBtYXJrIGlzCgkJICByZW1vdmVkIGZyb20gdGhlIHRleHQuCgkJV2hlbiB7bWF4fSBpcyBnaXZlbiB0aGlzIHNwZWNpZmllcyB0aGUgbWF4aW11bSBudW1iZXIgb2YgbGluZXMKCQl0byBiZSByZWFkLiAgVXNlZnVsIGlmIHlvdSBvbmx5IHdhbnQgdG8gY2hlY2sgdGhlIGZpcnN0IHRlbgoJCWxpbmVzIG9mIGEgZmlsZTogPgoJCQk6Zm9yIGxpbmUgaW4gcmVhZGZpbGUoZm5hbWUsICcnLCAxMCkKCQkJOiAgaWYgbGluZSA9fiAnRGF0ZScgfCBlY2hvIGxpbmUgfCBlbmRpZgoJCQk6ZW5kZm9yCjwJCVdoZW4ge21heH0gaXMgbmVnYXRpdmUgLXttYXh9IGxpbmVzIGZyb20gdGhlIGVuZCBvZiB0aGUgZmlsZQoJCWFyZSByZXR1cm5lZCwgb3IgYXMgbWFueSBhcyB0aGVyZSBhcmUuCgkJV2hlbiB7bWF4fSBpcyB6ZXJvIHRoZSByZXN1bHQgaXMgYW4gZW1wdHkgbGlzdC4KCQlOb3RlIHRoYXQgd2l0aG91dCB7bWF4fSB0aGUgd2hvbGUgZmlsZSBpcyByZWFkIGludG8gbWVtb3J5LgoJCUFsc28gbm90ZSB0aGF0IHRoZXJlIGlzIG5vIHJlY29nbml0aW9uIG9mIGVuY29kaW5nLiAgUmVhZCBhCgkJZmlsZSBpbnRvIGEgYnVmZmVyIGlmIHlvdSBuZWVkIHRvLgoJCVdoZW4gdGhlIGZpbGUgY2FuJ3QgYmUgb3BlbmVkIGFuIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4gYW5kCgkJdGhlIHJlc3VsdCBpcyBhbiBlbXB0eSBsaXN0LgoJCUFsc28gc2VlIHx3cml0ZWZpbGUoKXwuCgpyZWx0aW1lKFt7c3RhcnR9IFssIHtlbmR9XV0pCQkJCSpyZWx0aW1lKCkqCgkJUmV0dXJuIGFuIGl0ZW0gdGhhdCByZXByZXNlbnRzIGEgdGltZSB2YWx1ZS4gIFRoZSBmb3JtYXQgb2YKCQl0aGUgaXRlbSBkZXBlbmRzIG9uIHRoZSBzeXN0ZW0uICBJdCBjYW4gYmUgcGFzc2VkIHRvCgkJfHJlbHRpbWVzdHIoKXwgdG8gY29udmVydCBpdCB0byBhIHN0cmluZyAgb3IgfHJlbHRpbWVmbG9hdCgpfAoJCXRvIGNvbnZlcnQgdG8gYSBGbG9hdC4KCQlXaXRob3V0IGFuIGFyZ3VtZW50IGl0IHJldHVybnMgdGhlIGN1cnJlbnQgdGltZS4KCQlXaXRoIG9uZSBhcmd1bWVudCBpcyByZXR1cm5zIHRoZSB0aW1lIHBhc3NlZCBzaW5jZSB0aGUgdGltZQoJCXNwZWNpZmllZCBpbiB0aGUgYXJndW1lbnQuCgkJV2l0aCB0d28gYXJndW1lbnRzIGl0IHJldHVybnMgdGhlIHRpbWUgcGFzc2VkIGJldHdlZW4ge3N0YXJ0fQoJCWFuZCB7ZW5kfS4KCQlUaGUge3N0YXJ0fSBhbmQge2VuZH0gYXJndW1lbnRzIG11c3QgYmUgdmFsdWVzIHJldHVybmVkIGJ5CgkJcmVsdGltZSgpLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCnJlbHRpbWVmbG9hdCh7dGltZX0pCQkJCSpyZWx0aW1lZmxvYXQoKSoKCQlSZXR1cm4gYSBGbG9hdCB0aGF0IHJlcHJlc2VudHMgdGhlIHRpbWUgdmFsdWUgb2Yge3RpbWV9LgoJCUV4YW1wbGU6ID4KCQkJbGV0IHN0YXJ0ID0gcmVsdGltZSgpCgkJCWNhbGwgTXlGdW5jdGlvbigpCgkJCWxldCBzZWNvbmRzID0gcmVsdGltZWZsb2F0KHJlbHRpbWUoc3RhcnQpKQo8CQlTZWUgdGhlIG5vdGUgb2YgcmVsdGltZXN0cigpIGFib3V0IG92ZXJoZWFkLgoJCUFsc28gc2VlIHxwcm9maWxpbmd8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCnJlbHRpbWVzdHIoe3RpbWV9KQkJCQkqcmVsdGltZXN0cigpKgoJCVJldHVybiBhIFN0cmluZyB0aGF0IHJlcHJlc2VudHMgdGhlIHRpbWUgdmFsdWUgb2Yge3RpbWV9LgoJCVRoaXMgaXMgdGhlIG51bWJlciBvZiBzZWNvbmRzLCBhIGRvdCBhbmQgdGhlIG51bWJlciBvZgoJCW1pY3Jvc2Vjb25kcy4gIEV4YW1wbGU6ID4KCQkJbGV0IHN0YXJ0ID0gcmVsdGltZSgpCgkJCWNhbGwgTXlGdW5jdGlvbigpCgkJCWVjaG8gcmVsdGltZXN0cihyZWx0aW1lKHN0YXJ0KSkKPAkJTm90ZSB0aGF0IG92ZXJoZWFkIGZvciB0aGUgY29tbWFuZHMgd2lsbCBiZSBhZGRlZCB0byB0aGUgdGltZS4KCQlUaGUgYWNjdXJhY3kgZGVwZW5kcyBvbiB0aGUgc3lzdGVtLgoJCUxlYWRpbmcgc3BhY2VzIGFyZSB1c2VkIHRvIG1ha2UgdGhlIHN0cmluZyBhbGlnbiBuaWNlbHkuICBZb3UKCQljYW4gdXNlIHNwbGl0KCkgdG8gcmVtb3ZlIGl0LiA+CgkJCWVjaG8gc3BsaXQocmVsdGltZXN0cihyZWx0aW1lKHN0YXJ0KSkpWzBdCjwJCUFsc28gc2VlIHxwcm9maWxpbmd8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCgkJCQkJCQkqcmVtb3RlX2V4cHIoKSogKkU0NDkqCnJlbW90ZV9leHByKHtzZXJ2ZXJ9LCB7c3RyaW5nfSBbLCB7aWR2YXJ9XSkKCQlTZW5kIHRoZSB7c3RyaW5nfSB0byB7c2VydmVyfS4JVGhlIHN0cmluZyBpcyBzZW50IGFzIGFuCgkJZXhwcmVzc2lvbiBhbmQgdGhlIHJlc3VsdCBpcyByZXR1cm5lZCBhZnRlciBldmFsdWF0aW9uLgoJCVRoZSByZXN1bHQgbXVzdCBiZSBhIFN0cmluZyBvciBhIHxMaXN0fC4gIEEgfExpc3R8IGlzIHR1cm5lZAoJCWludG8gYSBTdHJpbmcgYnkgam9pbmluZyB0aGUgaXRlbXMgd2l0aCBhIGxpbmUgYnJlYWsgaW4KCQliZXR3ZWVuIChub3QgYXQgdGhlIGVuZCksIGxpa2Ugd2l0aCBqb2luKGV4cHIsICJcbiIpLgoJCUlmIHtpZHZhcn0gaXMgcHJlc2VudCwgaXQgaXMgdGFrZW4gYXMgdGhlIG5hbWUgb2YgYQoJCXZhcmlhYmxlIGFuZCBhIHtzZXJ2ZXJpZH0gZm9yIGxhdGVyIHVzZSB3aXRoCgkJcmVtb3RlX3JlYWQoKSBpcyBzdG9yZWQgdGhlcmUuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwgfFJlbW90ZVJlcGx5fC4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NsaWVudHNlcnZlcnwgZmVhdHVyZX0KCQlOb3RlOiBBbnkgZXJyb3JzIHdpbGwgY2F1c2UgYSBsb2NhbCBlcnJvciBtZXNzYWdlIHRvIGJlIGlzc3VlZAoJCWFuZCB0aGUgcmVzdWx0IHdpbGwgYmUgdGhlIGVtcHR5IHN0cmluZy4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyByZW1vdGVfZXhwcigiZ3ZpbSIsICIyKzIiKQoJCQk6ZWNobyByZW1vdGVfZXhwcigiZ3ZpbTEiLCAiYjpjdXJyZW50X3N5bnRheCIpCjwKCnJlbW90ZV9mb3JlZ3JvdW5kKHtzZXJ2ZXJ9KQkJCQkqcmVtb3RlX2ZvcmVncm91bmQoKSoKCQlNb3ZlIHRoZSBWaW0gc2VydmVyIHdpdGggdGhlIG5hbWUge3NlcnZlcn0gdG8gdGhlIGZvcmVncm91bmQuCgkJVGhpcyB3b3JrcyBsaWtlOiA+CgkJCXJlbW90ZV9leHByKHtzZXJ2ZXJ9LCAiZm9yZWdyb3VuZCgpIikKPAkJRXhjZXB0IHRoYXQgb24gV2luMzIgc3lzdGVtcyB0aGUgY2xpZW50IGRvZXMgdGhlIHdvcmssIHRvIHdvcmsKCQlhcm91bmQgdGhlIHByb2JsZW0gdGhhdCB0aGUgT1MgZG9lc24ndCBhbHdheXMgYWxsb3cgdGhlIHNlcnZlcgoJCXRvIGJyaW5nIGl0c2VsZiB0byB0aGUgZm9yZWdyb3VuZC4KCQlOb3RlOiBUaGlzIGRvZXMgbm90IHJlc3RvcmUgdGhlIHdpbmRvdyBpZiBpdCB3YXMgbWluaW1pemVkLAoJCWxpa2UgZm9yZWdyb3VuZCgpIGRvZXMuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgaW4gdGhlIFdpbjMyLCBBdGhlbmEsIE1vdGlmIGFuZCBHVEsgR1VJIHZlcnNpb25zIGFuZCB0aGUKCQlXaW4zMiBjb25zb2xlIHZlcnNpb259CgoKcmVtb3RlX3BlZWsoe3NlcnZlcmlkfSBbLCB7cmV0dmFyfV0pCQkqcmVtb3RlX3BlZWsoKSoKCQlSZXR1cm5zIGEgcG9zaXRpdmUgbnVtYmVyIGlmIHRoZXJlIGFyZSBhdmFpbGFibGUgc3RyaW5ncwoJCWZyb20ge3NlcnZlcmlkfS4gIENvcGllcyBhbnkgcmVwbHkgc3RyaW5nIGludG8gdGhlIHZhcmlhYmxlCgkJe3JldHZhcn0gaWYgc3BlY2lmaWVkLgl7cmV0dmFyfSBtdXN0IGJlIGEgc3RyaW5nIHdpdGggdGhlCgkJbmFtZSBvZiBhIHZhcmlhYmxlLgoJCVJldHVybnMgemVybyBpZiBub25lIGFyZSBhdmFpbGFibGUuCgkJUmV0dXJucyAtMSBpZiBzb21ldGhpbmcgaXMgd3JvbmcuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJRXhhbXBsZXM6ID4KCQkJOmxldCByZXBsID0gIiIKCQkJOmVjaG8gIlBFRUs6ICIucmVtb3RlX3BlZWsoaWQsICJyZXBsIikuIjogIi5yZXBsCgpyZW1vdGVfcmVhZCh7c2VydmVyaWR9KQkJCQkqcmVtb3RlX3JlYWQoKSoKCQlSZXR1cm4gdGhlIG9sZGVzdCBhdmFpbGFibGUgcmVwbHkgZnJvbSB7c2VydmVyaWR9IGFuZCBjb25zdW1lCgkJaXQuICBJdCBibG9ja3MgdW50aWwgYSByZXBseSBpcyBhdmFpbGFibGUuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwuCgkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJRXhhbXBsZTogPgoJCQk6ZWNobyByZW1vdGVfcmVhZChpZCkKPAoJCQkJCQkJKnJlbW90ZV9zZW5kKCkqICpFMjQxKgpyZW1vdGVfc2VuZCh7c2VydmVyfSwge3N0cmluZ30gWywge2lkdmFyfV0pCgkJU2VuZCB0aGUge3N0cmluZ30gdG8ge3NlcnZlcn0uCVRoZSBzdHJpbmcgaXMgc2VudCBhcyBpbnB1dAoJCWtleXMgYW5kIHRoZSBmdW5jdGlvbiByZXR1cm5zIGltbWVkaWF0ZWx5LiAgQXQgdGhlIFZpbSBzZXJ2ZXIKCQl0aGUga2V5cyBhcmUgbm90IG1hcHBlZCB8Om1hcHwuCgkJSWYge2lkdmFyfSBpcyBwcmVzZW50LCBpdCBpcyB0YWtlbiBhcyB0aGUgbmFtZSBvZiBhIHZhcmlhYmxlCgkJYW5kIGEge3NlcnZlcmlkfSBmb3IgbGF0ZXIgdXNlIHdpdGggcmVtb3RlX3JlYWQoKSBpcyBzdG9yZWQKCQl0aGVyZS4KCQlTZWUgYWxzbyB8Y2xpZW50c2VydmVyfCB8UmVtb3RlUmVwbHl8LgoJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2xpZW50c2VydmVyfCBmZWF0dXJlfQoJCU5vdGU6IEFueSBlcnJvcnMgd2lsbCBiZSByZXBvcnRlZCBpbiB0aGUgc2VydmVyIGFuZCBtYXkgbWVzcwoJCXVwIHRoZSBkaXNwbGF5LgoJCUV4YW1wbGVzOiA+CgkJOmVjaG8gcmVtb3RlX3NlbmQoImd2aW0iLCAiOkRyb3BBbmRSZXBseSAiLmZpbGUsICJzZXJ2ZXJpZCIpLgoJCSBcIHJlbW90ZV9yZWFkKHNlcnZlcmlkKQoKCQk6YXV0b2NtZCBOT05FIFJlbW90ZVJlcGx5ICoKCQkgXCBlY2hvIHJlbW90ZV9yZWFkKGV4cGFuZCgiPGFtYXRjaD4iKSkKCQk6ZWNobyByZW1vdGVfc2VuZCgiZ3ZpbSIsICI6c2xlZXAgMTAgfCBlY2hvICIuCgkJIFwgJ3NlcnZlcjJjbGllbnQoZXhwYW5kKCI8Y2xpZW50PiIpLCAiSEVMTE8iKTxDUj4nKQo8CnJlbW92ZSh7bGlzdH0sIHtpZHh9IFssIHtlbmR9XSkJCQkJKnJlbW92ZSgpKgoJCVdpdGhvdXQge2VuZH06IFJlbW92ZSB0aGUgaXRlbSBhdCB7aWR4fSBmcm9tIHxMaXN0fCB7bGlzdH0gYW5kCgkJcmV0dXJuIHRoZSBpdGVtLgoJCVdpdGgge2VuZH06IFJlbW92ZSBpdGVtcyBmcm9tIHtpZHh9IHRvIHtlbmR9IChpbmNsdXNpdmUpIGFuZAoJCXJldHVybiBhIExpc3Qgd2l0aCB0aGVzZSBpdGVtcy4gIFdoZW4ge2lkeH0gcG9pbnRzIHRvIHRoZSBzYW1lCgkJaXRlbSBhcyB7ZW5kfSBhIGxpc3Qgd2l0aCBvbmUgaXRlbSBpcyByZXR1cm5lZC4gIFdoZW4ge2VuZH0KCQlwb2ludHMgdG8gYW4gaXRlbSBiZWZvcmUge2lkeH0gdGhpcyBpcyBhbiBlcnJvci4KCQlTZWUgfGxpc3QtaW5kZXh8IGZvciBwb3NzaWJsZSB2YWx1ZXMgb2Yge2lkeH0gYW5kIHtlbmR9LgoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gImxhc3QgaXRlbTogIiAuIHJlbW92ZShteWxpc3QsIC0xKQoJCQk6Y2FsbCByZW1vdmUobXlsaXN0LCAwLCA5KQpyZW1vdmUoe2RpY3R9LCB7a2V5fSkKCQlSZW1vdmUgdGhlIGVudHJ5IGZyb20ge2RpY3R9IHdpdGgga2V5IHtrZXl9LiAgRXhhbXBsZTogPgoJCQk6ZWNobyAicmVtb3ZlZCAiIC4gcmVtb3ZlKGRpY3QsICJvbmUiKQo8CQlJZiB0aGVyZSBpcyBubyB7a2V5fSBpbiB7ZGljdH0gdGhpcyBpcyBhbiBlcnJvci4KCgkJVXNlIHxkZWxldGUoKXwgdG8gcmVtb3ZlIGEgZmlsZS4KCnJlbmFtZSh7ZnJvbX0sIHt0b30pCQkJCQkqcmVuYW1lKCkqCgkJUmVuYW1lIHRoZSBmaWxlIGJ5IHRoZSBuYW1lIHtmcm9tfSB0byB0aGUgbmFtZSB7dG99LiAgVGhpcwoJCXNob3VsZCBhbHNvIHdvcmsgdG8gbW92ZSBmaWxlcyBhY3Jvc3MgZmlsZSBzeXN0ZW1zLiAgVGhlCgkJcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyAwIGlmIHRoZSBmaWxlIHdhcyByZW5hbWVkCgkJc3VjY2Vzc2Z1bGx5LCBhbmQgbm9uLXplcm8gd2hlbiB0aGUgcmVuYW1pbmcgZmFpbGVkLgoJCU5PVEU6IElmIHt0b30gZXhpc3RzIGl0IGlzIG92ZXJ3cml0dGVuIHdpdGhvdXQgd2FybmluZy4KCQlUaGlzIGZ1bmN0aW9uIGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIHxzYW5kYm94fC4KCnJlcGVhdCh7ZXhwcn0sIHtjb3VudH0pCQkJCQkqcmVwZWF0KCkqCgkJUmVwZWF0IHtleHByfSB7Y291bnR9IHRpbWVzIGFuZCByZXR1cm4gdGhlIGNvbmNhdGVuYXRlZAoJCXJlc3VsdC4gIEV4YW1wbGU6ID4KCQkJOmxldCBzZXBhcmF0b3IgPSByZXBlYXQoJy0nLCA4MCkKPAkJV2hlbiB7Y291bnR9IGlzIHplcm8gb3IgbmVnYXRpdmUgdGhlIHJlc3VsdCBpcyBlbXB0eS4KCQlXaGVuIHtleHByfSBpcyBhIHxMaXN0fCB0aGUgcmVzdWx0IGlzIHtleHByfSBjb25jYXRlbmF0ZWQKCQl7Y291bnR9IHRpbWVzLglFeGFtcGxlOiA+CgkJCTpsZXQgbG9uZ2xpc3QgPSByZXBlYXQoWydhJywgJ2InXSwgMykKPAkJUmVzdWx0cyBpbiBbJ2EnLCAnYicsICdhJywgJ2InLCAnYScsICdiJ10uCgoKcmVzb2x2ZSh7ZmlsZW5hbWV9KQkJCQkJKnJlc29sdmUoKSogKkU2NTUqCgkJT24gTVMtV2luZG93cywgd2hlbiB7ZmlsZW5hbWV9IGlzIGEgc2hvcnRjdXQgKGEgLmxuayBmaWxlKSwKCQlyZXR1cm5zIHRoZSBwYXRoIHRoZSBzaG9ydGN1dCBwb2ludHMgdG8gaW4gYSBzaW1wbGlmaWVkIGZvcm0uCgkJT24gVW5peCwgcmVwZWF0IHJlc29sdmluZyBzeW1ib2xpYyBsaW5rcyBpbiBhbGwgcGF0aAoJCWNvbXBvbmVudHMgb2Yge2ZpbGVuYW1lfSBhbmQgcmV0dXJuIHRoZSBzaW1wbGlmaWVkIHJlc3VsdC4KCQlUbyBjb3BlIHdpdGggbGluayBjeWNsZXMsIHJlc29sdmluZyBvZiBzeW1ib2xpYyBsaW5rcyBpcwoJCXN0b3BwZWQgYWZ0ZXIgMTAwIGl0ZXJhdGlvbnMuCgkJT24gb3RoZXIgc3lzdGVtcywgcmV0dXJuIHRoZSBzaW1wbGlmaWVkIHtmaWxlbmFtZX0uCgkJVGhlIHNpbXBsaWZpY2F0aW9uIHN0ZXAgaXMgZG9uZSBhcyBieSB8c2ltcGxpZnkoKXwuCgkJcmVzb2x2ZSgpIGtlZXBzIGEgbGVhZGluZyBwYXRoIGNvbXBvbmVudCBzcGVjaWZ5aW5nIHRoZQoJCWN1cnJlbnQgZGlyZWN0b3J5IChwcm92aWRlZCB0aGUgcmVzdWx0IGlzIHN0aWxsIGEgcmVsYXRpdmUKCQlwYXRoIG5hbWUpIGFuZCBhbHNvIGtlZXBzIGEgdHJhaWxpbmcgcGF0aCBzZXBhcmF0b3IuCgoJCQkJCQkJKnJldmVyc2UoKSoKcmV2ZXJzZSh7bGlzdH0pCVJldmVyc2UgdGhlIG9yZGVyIG9mIGl0ZW1zIGluIHtsaXN0fSBpbi1wbGFjZS4JUmV0dXJucwoJCXtsaXN0fS4KCQlJZiB5b3Ugd2FudCBhIGxpc3QgdG8gcmVtYWluIHVubW9kaWZpZWQgbWFrZSBhIGNvcHkgZmlyc3Q6ID4KCQkJOmxldCByZXZsaXN0ID0gcmV2ZXJzZShjb3B5KG15bGlzdCkpCgpyb3VuZCh7ZXhwcn0pCQkJCQkJCSpyb3VuZCgpKgoJCVJvdW5kIG9mZiB7ZXhwcn0gdG8gdGhlIG5lYXJlc3QgaW50ZWdyYWwgdmFsdWUgYW5kIHJldHVybiBpdAoJCWFzIGEgfEZsb2F0fC4gIElmIHtleHByfSBsaWVzIGhhbGZ3YXkgYmV0d2VlbiB0d28gaW50ZWdyYWwKCQl2YWx1ZXMsIHRoZW4gdXNlIHRoZSBsYXJnZXIgb25lIChhd2F5IGZyb20gemVybykuCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJZWNobyByb3VuZCgwLjQ1NikKPAkJCTAuMCAgPgoJCQllY2hvIHJvdW5kKDQuNSkKPAkJCTUuMCA+CgkJCWVjaG8gcm91bmQoLTQuNSkKPAkJCS01LjAKCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2Zsb2F0fCBmZWF0dXJlfQoKc2NyZWVuYXR0cihyb3csIGNvbCkJCQkJCQkqc2NyZWVuYXR0cigpKgoJCUxpa2Ugc2NyZWVuY2hhcigpLCBidXQgcmV0dXJuIHRoZSBhdHRyaWJ1dGUuICBUaGlzIGlzIGEgcmF0aGVyCgkJYXJiaXRyYXJ5IG51bWJlciB0aGF0IGNhbiBvbmx5IGJlIHVzZWQgdG8gY29tcGFyZSB0byB0aGUKCQlhdHRyaWJ1dGUgYXQgb3RoZXIgcG9zaXRpb25zLgoKc2NyZWVuY2hhcihyb3csIGNvbCkJCQkJCQkqc2NyZWVuY2hhcigpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBjaGFyYWN0ZXIgYXQgcG9zaXRpb24KCQlbcm93LCBjb2xdIG9uIHRoZSBzY3JlZW4uICBUaGlzIHdvcmtzIGZvciBldmVyeSBwb3NzaWJsZQoJCXNjcmVlbiBwb3NpdGlvbiwgYWxzbyBzdGF0dXMgbGluZXMsIHdpbmRvdyBzZXBhcmF0b3JzIGFuZCB0aGUKCQljb21tYW5kIGxpbmUuICBUaGUgdG9wIGxlZnQgcG9zaXRpb24gaXMgcm93IG9uZSwgY29sdW1uIG9uZQoJCVRoZSBjaGFyYWN0ZXIgZXhjbHVkZXMgY29tcG9zaW5nIGNoYXJhY3RlcnMuICBGb3IgZG91YmxlLWJ5dGUKCQllbmNvZGluZ3MgaXQgbWF5IG9ubHkgYmUgdGhlIGZpcnN0IGJ5dGUuCgkJVGhpcyBpcyBtYWlubHkgdG8gYmUgdXNlZCBmb3IgdGVzdGluZy4KCQlSZXR1cm5zIC0xIHdoZW4gcm93IG9yIGNvbCBpcyBvdXQgb2YgcmFuZ2UuCgpzY3JlZW5jb2woKQkJCQkJCQkqc2NyZWVuY29sKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIGN1cnJlbnQgc2NyZWVuIGNvbHVtbiBvZgoJCXRoZSBjdXJzb3IuIFRoZSBsZWZ0bW9zdCBjb2x1bW4gaGFzIG51bWJlciAxLgoJCVRoaXMgZnVuY3Rpb24gaXMgbWFpbmx5IHVzZWQgZm9yIHRlc3RpbmcuCgoJCU5vdGU6IEFsd2F5cyByZXR1cm5zIHRoZSBjdXJyZW50IHNjcmVlbiBjb2x1bW4sIHRodXMgaWYgdXNlZAoJCWluIGEgY29tbWFuZCAoZS5nLiAiOmVjaG8gc2NyZWVuY29sKCkiKSBpdCB3aWxsIHJldHVybiB0aGUKCQljb2x1bW4gaW5zaWRlIHRoZSBjb21tYW5kIGxpbmUsIHdoaWNoIGlzIDEgd2hlbiB0aGUgY29tbWFuZCBpcwoJCWV4ZWN1dGVkLiBUbyBnZXQgdGhlIGN1cnNvciBwb3NpdGlvbiBpbiB0aGUgZmlsZSB1c2Ugb25lIG9mCgkJdGhlIGZvbGxvd2luZyBtYXBwaW5nczogPgoJCQlubm9yZW1hcCA8ZXhwcj4gR0cgIjplY2hvbSAiLnNjcmVlbmNvbCgpLiJcbiIKCQkJbm5vcmVtYXAgPHNpbGVudD4gR0cgOmVjaG9tIHNjcmVlbmNvbCgpPENSPgo8CnNjcmVlbnJvdygpCQkJCQkJCSpzY3JlZW5yb3coKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgY3VycmVudCBzY3JlZW4gcm93IG9mIHRoZQoJCWN1cnNvci4gIFRoZSB0b3AgbGluZSBoYXMgbnVtYmVyIG9uZS4KCQlUaGlzIGZ1bmN0aW9uIGlzIG1haW5seSB1c2VkIGZvciB0ZXN0aW5nLgoKCQlOb3RlOiBTYW1lIHJlc3RyaWN0aW9ucyBhcyB3aXRoIHxzY3JlZW5jb2woKXwuCgpzZWFyY2goe3BhdHRlcm59IFssIHtmbGFnc30gWywge3N0b3BsaW5lfSBbLCB7dGltZW91dH1dXV0pCSpzZWFyY2goKSoKCQlTZWFyY2ggZm9yIHJlZ2V4cCBwYXR0ZXJuIHtwYXR0ZXJufS4gIFRoZSBzZWFyY2ggc3RhcnRzIGF0IHRoZQoJCWN1cnNvciBwb3NpdGlvbiAoeW91IGNhbiB1c2UgfGN1cnNvcigpfCB0byBzZXQgaXQpLgoKCQlXaGVuIGEgbWF0Y2ggaGFzIGJlZW4gZm91bmQgaXRzIGxpbmUgbnVtYmVyIGlzIHJldHVybmVkLgoJCUlmIHRoZXJlIGlzIG5vIG1hdGNoIGEgMCBpcyByZXR1cm5lZCBhbmQgdGhlIGN1cnNvciBkb2Vzbid0CgkJbW92ZS4gIE5vIGVycm9yIG1lc3NhZ2UgaXMgZ2l2ZW4uCgoJCXtmbGFnc30gaXMgYSBTdHJpbmcsIHdoaWNoIGNhbiBjb250YWluIHRoZXNlIGNoYXJhY3RlciBmbGFnczoKCQknYicJc2VhcmNoIEJhY2t3YXJkIGluc3RlYWQgb2YgZm9yd2FyZAoJCSdjJwlhY2NlcHQgYSBtYXRjaCBhdCB0aGUgQ3Vyc29yIHBvc2l0aW9uCgkJJ2UnCW1vdmUgdG8gdGhlIEVuZCBvZiB0aGUgbWF0Y2gKCQknbicJZG8gTm90IG1vdmUgdGhlIGN1cnNvcgoJCSdwJwlyZXR1cm4gbnVtYmVyIG9mIG1hdGNoaW5nIHN1Yi1QYXR0ZXJuIChzZWUgYmVsb3cpCgkJJ3MnCVNldCB0aGUgJyBtYXJrIGF0IHRoZSBwcmV2aW91cyBsb2NhdGlvbiBvZiB0aGUgY3Vyc29yCgkJJ3cnCVdyYXAgYXJvdW5kIHRoZSBlbmQgb2YgdGhlIGZpbGUKCQknVycJZG9uJ3QgV3JhcCBhcm91bmQgdGhlIGVuZCBvZiB0aGUgZmlsZQoJCSd6JwlzdGFydCBzZWFyY2hpbmcgYXQgdGhlIGN1cnNvciBjb2x1bW4gaW5zdGVhZCBvZiB6ZXJvCgkJSWYgbmVpdGhlciAndycgb3IgJ1cnIGlzIGdpdmVuLCB0aGUgJ3dyYXBzY2FuJyBvcHRpb24gYXBwbGllcy4KCgkJSWYgdGhlICdzJyBmbGFnIGlzIHN1cHBsaWVkLCB0aGUgJyBtYXJrIGlzIHNldCwgb25seSBpZiB0aGUKCQljdXJzb3IgaXMgbW92ZWQuIFRoZSAncycgZmxhZyBjYW5ub3QgYmUgY29tYmluZWQgd2l0aCB0aGUgJ24nCgkJZmxhZy4KCgkJJ2lnbm9yZWNhc2UnLCAnc21hcnRjYXNlJyBhbmQgJ21hZ2ljJyBhcmUgdXNlZC4KCQkKCQlXaGVuIHRoZSAneicgZmxhZyBpcyBub3QgZ2l2ZW4sIHNlYXJjaGluZyBhbHdheXMgc3RhcnRzIGluCgkJY29sdW1uIHplcm8gYW5kIHRoZW4gbWF0Y2hlcyBiZWZvcmUgdGhlIGN1cnNvciBhcmUgc2tpcHBlZC4KCQlXaGVuIHRoZSAnYycgZmxhZyBpcyBwcmVzZW50IGluICdjcG8nIHRoZSBuZXh0IHNlYXJjaCBzdGFydHMKCQlhZnRlciB0aGUgbWF0Y2guICBXaXRob3V0IHRoZSAnYycgZmxhZyB0aGUgbmV4dCBzZWFyY2ggc3RhcnRzCgkJb25lIGNvbHVtbiBmdXJ0aGVyLgoKCQlXaGVuIHRoZSB7c3RvcGxpbmV9IGFyZ3VtZW50IGlzIGdpdmVuIHRoZW4gdGhlIHNlYXJjaCBzdG9wcwoJCWFmdGVyIHNlYXJjaGluZyB0aGlzIGxpbmUuICBUaGlzIGlzIHVzZWZ1bCB0byByZXN0cmljdCB0aGUKCQlzZWFyY2ggdG8gYSByYW5nZSBvZiBsaW5lcy4gIEV4YW1wbGVzOiA+CgkJCWxldCBtYXRjaCA9IHNlYXJjaCgnKCcsICdiJywgbGluZSgidzAiKSkKCQkJbGV0IGVuZCA9IHNlYXJjaCgnRU5EJywgJycsIGxpbmUoInckIikpCjwJCVdoZW4ge3N0b3BsaW5lfSBpcyB1c2VkIGFuZCBpdCBpcyBub3QgemVybyB0aGlzIGFsc28gaW1wbGllcwoJCXRoYXQgdGhlIHNlYXJjaCBkb2VzIG5vdCB3cmFwIGFyb3VuZCB0aGUgZW5kIG9mIHRoZSBmaWxlLgoJCUEgemVybyB2YWx1ZSBpcyBlcXVhbCB0byBub3QgZ2l2aW5nIHRoZSBhcmd1bWVudC4KCgkJV2hlbiB0aGUge3RpbWVvdXR9IGFyZ3VtZW50IGlzIGdpdmVuIHRoZSBzZWFyY2ggc3RvcHMgd2hlbgoJCW1vcmUgdGhhbiB0aGlzIG1hbnkgbWlsbGlzZWNvbmRzIGhhdmUgcGFzc2VkLglUaHVzIHdoZW4KCQl7dGltZW91dH0gaXMgNTAwIHRoZSBzZWFyY2ggc3RvcHMgYWZ0ZXIgaGFsZiBhIHNlY29uZC4KCQlUaGUgdmFsdWUgbXVzdCBub3QgYmUgbmVnYXRpdmUuICBBIHplcm8gdmFsdWUgaXMgbGlrZSBub3QKCQlnaXZpbmcgdGhlIGFyZ3VtZW50LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmVsdGltZXwgZmVhdHVyZX0KCgkJCQkJCQkqc2VhcmNoKCktc3ViLW1hdGNoKgoJCVdpdGggdGhlICdwJyBmbGFnIHRoZSByZXR1cm5lZCB2YWx1ZSBpcyBvbmUgbW9yZSB0aGFuIHRoZQoJCWZpcnN0IHN1Yi1tYXRjaCBpbiBcKFwpLiAgT25lIGlmIG5vbmUgb2YgdGhlbSBtYXRjaGVkIGJ1dCB0aGUKCQl3aG9sZSBwYXR0ZXJuIGRpZCBtYXRjaC4KCQlUbyBnZXQgdGhlIGNvbHVtbiBudW1iZXIgdG9vIHVzZSB8c2VhcmNocG9zKCl8LgoKCQlUaGUgY3Vyc29yIHdpbGwgYmUgcG9zaXRpb25lZCBhdCB0aGUgbWF0Y2gsIHVubGVzcyB0aGUgJ24nCgkJZmxhZyBpcyB1c2VkLgoKCQlFeGFtcGxlIChnb2VzIG92ZXIgYWxsIGZpbGVzIGluIHRoZSBhcmd1bWVudCBsaXN0KTogPgoJCSAgICA6bGV0IG4gPSAxCgkJICAgIDp3aGlsZSBuIDw9IGFyZ2MoKQkgICAgIiBsb29wIG92ZXIgYWxsIGZpbGVzIGluIGFyZ2xpc3QKCQkgICAgOiAgZXhlICJhcmd1bWVudCAiIC4gbgoJCSAgICA6ICAiIHN0YXJ0IGF0IHRoZSBsYXN0IGNoYXIgaW4gdGhlIGZpbGUgYW5kIHdyYXAgZm9yIHRoZQoJCSAgICA6ICAiIGZpcnN0IHNlYXJjaCB0byBmaW5kIG1hdGNoIGF0IHN0YXJ0IG9mIGZpbGUKCQkgICAgOiAgbm9ybWFsIEckCgkJICAgIDogIGxldCBmbGFncyA9ICJ3IgoJCSAgICA6ICB3aGlsZSBzZWFyY2goImZvbyIsIGZsYWdzKSA+IDAKCQkgICAgOgkgcy9mb28vYmFyL2cKCQkgICAgOgkgbGV0IGZsYWdzID0gIlciCgkJICAgIDogIGVuZHdoaWxlCgkJICAgIDogIHVwZGF0ZQkJICAgICIgd3JpdGUgdGhlIGZpbGUgaWYgbW9kaWZpZWQKCQkgICAgOiAgbGV0IG4gPSBuICsgMQoJCSAgICA6ZW5kd2hpbGUKPAoJCUV4YW1wbGUgZm9yIHVzaW5nIHNvbWUgZmxhZ3M6ID4KCQkgICAgOmVjaG8gc2VhcmNoKCdcPGlmXHxcKGVsc2VcKVx8XChlbmRpZlwpJywgJ25jcGUnKQo8CQlUaGlzIHdpbGwgc2VhcmNoIGZvciB0aGUga2V5d29yZHMgImlmIiwgImVsc2UiLCBhbmQgImVuZGlmIgoJCXVuZGVyIG9yIGFmdGVyIHRoZSBjdXJzb3IuICBCZWNhdXNlIG9mIHRoZSAncCcgZmxhZywgaXQKCQlyZXR1cm5zIDEsIDIsIG9yIDMgZGVwZW5kaW5nIG9uIHdoaWNoIGtleXdvcmQgaXMgZm91bmQsIG9yIDAKCQlpZiB0aGUgc2VhcmNoIGZhaWxzLiAgV2l0aCB0aGUgY3Vyc29yIG9uIHRoZSBmaXJzdCB3b3JkIG9mIHRoZQoJCWxpbmU6CgkJICAgIGlmIChmb28gPT0gMCkgfCBsZXQgZm9vID0gZm9vICsgMSB8IGVuZGlmIH4KCQl0aGUgZnVuY3Rpb24gcmV0dXJucyAxLiAgV2l0aG91dCB0aGUgJ2MnIGZsYWcsIHRoZSBmdW5jdGlvbgoJCWZpbmRzIHRoZSAiZW5kaWYiIGFuZCByZXR1cm5zIDMuICBUaGUgc2FtZSB0aGluZyBoYXBwZW5zCgkJd2l0aG91dCB0aGUgJ2UnIGZsYWcgaWYgdGhlIGN1cnNvciBpcyBvbiB0aGUgImYiIG9mICJpZiIuCgkJVGhlICduJyBmbGFnIHRlbGxzIHRoZSBmdW5jdGlvbiBub3QgdG8gbW92ZSB0aGUgY3Vyc29yLgoKCnNlYXJjaGRlY2woe25hbWV9IFssIHtnbG9iYWx9IFssIHt0aGlzYmxvY2t9XV0pCQkJKnNlYXJjaGRlY2woKSoKCQlTZWFyY2ggZm9yIHRoZSBkZWNsYXJhdGlvbiBvZiB7bmFtZX0uCgoJCVdpdGggYSBub24temVybyB7Z2xvYmFsfSBhcmd1bWVudCBpdCB3b3JrcyBsaWtlIHxnRHwsIGZpbmQKCQlmaXJzdCBtYXRjaCBpbiB0aGUgZmlsZS4gIE90aGVyd2lzZSBpdCB3b3JrcyBsaWtlIHxnZHwsIGZpbmQKCQlmaXJzdCBtYXRjaCBpbiB0aGUgZnVuY3Rpb24uCgoJCVdpdGggYSBub24temVybyB7dGhpc2Jsb2NrfSBhcmd1bWVudCBtYXRjaGVzIGluIGEge30gYmxvY2sKCQl0aGF0IGVuZHMgYmVmb3JlIHRoZSBjdXJzb3IgcG9zaXRpb24gYXJlIGlnbm9yZWQuICBBdm9pZHMKCQlmaW5kaW5nIHZhcmlhYmxlIGRlY2xhcmF0aW9ucyBvbmx5IHZhbGlkIGluIGFub3RoZXIgc2NvcGUuCgoJCU1vdmVzIHRoZSBjdXJzb3IgdG8gdGhlIGZvdW5kIG1hdGNoLgoJCVJldHVybnMgemVybyBmb3Igc3VjY2Vzcywgbm9uLXplcm8gZm9yIGZhaWx1cmUuCgkJRXhhbXBsZTogPgoJCQlpZiBzZWFyY2hkZWNsKCdteXZhcicpID09IDAKCQkJICAgZWNobyBnZXRsaW5lKCcuJykKCQkJZW5kaWYKPAoJCQkJCQkJKnNlYXJjaHBhaXIoKSoKc2VhcmNocGFpcih7c3RhcnR9LCB7bWlkZGxlfSwge2VuZH0gWywge2ZsYWdzfSBbLCB7c2tpcH0KCQkJCVssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dXSkKCQlTZWFyY2ggZm9yIHRoZSBtYXRjaCBvZiBhIG5lc3RlZCBzdGFydC1lbmQgcGFpci4gIFRoaXMgY2FuIGJlCgkJdXNlZCB0byBmaW5kIHRoZSAiZW5kaWYiIHRoYXQgbWF0Y2hlcyBhbiAiaWYiLCB3aGlsZSBvdGhlcgoJCWlmL2VuZGlmIHBhaXJzIGluIGJldHdlZW4gYXJlIGlnbm9yZWQuCgkJVGhlIHNlYXJjaCBzdGFydHMgYXQgdGhlIGN1cnNvci4gIFRoZSBkZWZhdWx0IGlzIHRvIHNlYXJjaAoJCWZvcndhcmQsIGluY2x1ZGUgJ2InIGluIHtmbGFnc30gdG8gc2VhcmNoIGJhY2t3YXJkLgoJCUlmIGEgbWF0Y2ggaXMgZm91bmQsIHRoZSBjdXJzb3IgaXMgcG9zaXRpb25lZCBhdCBpdCBhbmQgdGhlCgkJbGluZSBudW1iZXIgaXMgcmV0dXJuZWQuICBJZiBubyBtYXRjaCBpcyBmb3VuZCAwIG9yIC0xIGlzCgkJcmV0dXJuZWQgYW5kIHRoZSBjdXJzb3IgZG9lc24ndCBtb3ZlLiAgTm8gZXJyb3IgbWVzc2FnZSBpcwoJCWdpdmVuLgoKCQl7c3RhcnR9LCB7bWlkZGxlfSBhbmQge2VuZH0gYXJlIHBhdHRlcm5zLCBzZWUgfHBhdHRlcm58LiAgVGhleQoJCW11c3Qgbm90IGNvbnRhaW4gXCggXCkgcGFpcnMuICBVc2Ugb2YgXCUoIFwpIGlzIGFsbG93ZWQuICBXaGVuCgkJe21pZGRsZX0gaXMgbm90IGVtcHR5LCBpdCBpcyBmb3VuZCB3aGVuIHNlYXJjaGluZyBmcm9tIGVpdGhlcgoJCWRpcmVjdGlvbiwgYnV0IG9ubHkgd2hlbiBub3QgaW4gYSBuZXN0ZWQgc3RhcnQtZW5kIHBhaXIuICBBCgkJdHlwaWNhbCB1c2UgaXM6ID4KCQkJc2VhcmNocGFpcignXDxpZlw+JywgJ1w8ZWxzZVw+JywgJ1w8ZW5kaWZcPicpCjwJCUJ5IGxlYXZpbmcge21pZGRsZX0gZW1wdHkgdGhlICJlbHNlIiBpcyBza2lwcGVkLgoKCQl7ZmxhZ3N9ICdiJywgJ2MnLCAnbicsICdzJywgJ3cnIGFuZCAnVycgYXJlIHVzZWQgbGlrZSB3aXRoCgkJfHNlYXJjaCgpfC4gIEFkZGl0aW9uYWxseToKCQkncicJUmVwZWF0IHVudGlsIG5vIG1vcmUgbWF0Y2hlcyBmb3VuZDsgd2lsbCBmaW5kIHRoZQoJCQlvdXRlciBwYWlyLiAgSW1wbGllcyB0aGUgJ1cnIGZsYWcuCgkJJ20nCVJldHVybiBudW1iZXIgb2YgbWF0Y2hlcyBpbnN0ZWFkIG9mIGxpbmUgbnVtYmVyIHdpdGgKCQkJdGhlIG1hdGNoOyB3aWxsIGJlID4gMSB3aGVuICdyJyBpcyB1c2VkLgoJCU5vdGU6IGl0J3MgbmVhcmx5IGFsd2F5cyBhIGdvb2QgaWRlYSB0byB1c2UgdGhlICdXJyBmbGFnLCB0bwoJCWF2b2lkIHdyYXBwaW5nIGFyb3VuZCB0aGUgZW5kIG9mIHRoZSBmaWxlLgoKCQlXaGVuIGEgbWF0Y2ggZm9yIHtzdGFydH0sIHttaWRkbGV9IG9yIHtlbmR9IGlzIGZvdW5kLCB0aGUKCQl7c2tpcH0gZXhwcmVzc2lvbiBpcyBldmFsdWF0ZWQgd2l0aCB0aGUgY3Vyc29yIHBvc2l0aW9uZWQgb24KCQl0aGUgc3RhcnQgb2YgdGhlIG1hdGNoLiAgSXQgc2hvdWxkIHJldHVybiBub24temVybyBpZiB0aGlzCgkJbWF0Y2ggaXMgdG8gYmUgc2tpcHBlZC4gIEUuZy4sIGJlY2F1c2UgaXQgaXMgaW5zaWRlIGEgY29tbWVudAoJCW9yIGEgc3RyaW5nLgoJCVdoZW4ge3NraXB9IGlzIG9taXR0ZWQgb3IgZW1wdHksIGV2ZXJ5IG1hdGNoIGlzIGFjY2VwdGVkLgoJCVdoZW4gZXZhbHVhdGluZyB7c2tpcH0gY2F1c2VzIGFuIGVycm9yIHRoZSBzZWFyY2ggaXMgYWJvcnRlZAoJCWFuZCAtMSByZXR1cm5lZC4KCgkJRm9yIHtzdG9wbGluZX0gYW5kIHt0aW1lb3V0fSBzZWUgfHNlYXJjaCgpfC4KCgkJVGhlIHZhbHVlIG9mICdpZ25vcmVjYXNlJyBpcyB1c2VkLiAgJ21hZ2ljJyBpcyBpZ25vcmVkLCB0aGUKCQlwYXR0ZXJucyBhcmUgdXNlZCBsaWtlIGl0J3Mgb24uCgoJCVRoZSBzZWFyY2ggc3RhcnRzIGV4YWN0bHkgYXQgdGhlIGN1cnNvci4gIEEgbWF0Y2ggd2l0aAoJCXtzdGFydH0sIHttaWRkbGV9IG9yIHtlbmR9IGF0IHRoZSBuZXh0IGNoYXJhY3RlciwgaW4gdGhlCgkJZGlyZWN0aW9uIG9mIHNlYXJjaGluZywgaXMgdGhlIGZpcnN0IG9uZSBmb3VuZC4gIEV4YW1wbGU6ID4KCQkJaWYgMQoJCQkgIGlmIDIKCQkJICBlbmRpZiAyCgkJCWVuZGlmIDEKPAkJV2hlbiBzdGFydGluZyBhdCB0aGUgImlmIDIiLCB3aXRoIHRoZSBjdXJzb3Igb24gdGhlICJpIiwgYW5kCgkJc2VhcmNoaW5nIGZvcndhcmRzLCB0aGUgImVuZGlmIDIiIGlzIGZvdW5kLiAgV2hlbiBzdGFydGluZyBvbgoJCXRoZSBjaGFyYWN0ZXIganVzdCBiZWZvcmUgdGhlICJpZiAyIiwgdGhlICJlbmRpZiAxIiB3aWxsIGJlCgkJZm91bmQuCVRoYXQncyBiZWNhdXNlIHRoZSAiaWYgMiIgd2lsbCBiZSBmb3VuZCBmaXJzdCwgYW5kCgkJdGhlbiB0aGlzIGlzIGNvbnNpZGVyZWQgdG8gYmUgYSBuZXN0ZWQgaWYvZW5kaWYgZnJvbSAiaWYgMiIgdG8KCQkiZW5kaWYgMiIuCgkJV2hlbiBzZWFyY2hpbmcgYmFja3dhcmRzIGFuZCB7ZW5kfSBpcyBtb3JlIHRoYW4gb25lIGNoYXJhY3RlciwKCQlpdCBtYXkgYmUgdXNlZnVsIHRvIHB1dCAiXHpzIiBhdCB0aGUgZW5kIG9mIHRoZSBwYXR0ZXJuLCBzbwoJCXRoYXQgd2hlbiB0aGUgY3Vyc29yIGlzIGluc2lkZSBhIG1hdGNoIHdpdGggdGhlIGVuZCBpdCBmaW5kcwoJCXRoZSBtYXRjaGluZyBzdGFydC4KCgkJRXhhbXBsZSwgdG8gZmluZCB0aGUgImVuZGlmIiBjb21tYW5kIGluIGEgVmltIHNjcmlwdDogPgoKCTplY2hvIHNlYXJjaHBhaXIoJ1w8aWZcPicsICdcPGVsXCVbc2VpZl1cPicsICdcPGVuXCVbZGlmXVw+JywgJ1cnLAoJCQlcICdnZXRsaW5lKCIuIikgPX4gIl5cXHMqXCIiJykKCjwJCVRoZSBjdXJzb3IgbXVzdCBiZSBhdCBvciBhZnRlciB0aGUgImlmIiBmb3Igd2hpY2ggYSBtYXRjaCBpcwoJCXRvIGJlIGZvdW5kLiAgTm90ZSB0aGF0IHNpbmdsZS1xdW90ZSBzdHJpbmdzIGFyZSB1c2VkIHRvIGF2b2lkCgkJaGF2aW5nIHRvIGRvdWJsZSB0aGUgYmFja3NsYXNoZXMuICBUaGUgc2tpcCBleHByZXNzaW9uIG9ubHkKCQljYXRjaGVzIGNvbW1lbnRzIGF0IHRoZSBzdGFydCBvZiBhIGxpbmUsIG5vdCBhZnRlciBhIGNvbW1hbmQuCgkJQWxzbywgYSB3b3JkICJlbiIgb3IgImlmIiBoYWxmd2F5IGEgbGluZSBpcyBjb25zaWRlcmVkIGEKCQltYXRjaC4KCQlBbm90aGVyIGV4YW1wbGUsIHRvIHNlYXJjaCBmb3IgdGhlIG1hdGNoaW5nICJ7IiBvZiBhICJ9IjogPgoKCTplY2hvIHNlYXJjaHBhaXIoJ3snLCAnJywgJ30nLCAnYlcnKQoKPAkJVGhpcyB3b3JrcyB3aGVuIHRoZSBjdXJzb3IgaXMgYXQgb3IgYmVmb3JlIHRoZSAifSIgZm9yIHdoaWNoIGEKCQltYXRjaCBpcyB0byBiZSBmb3VuZC4gIFRvIHJlamVjdCBtYXRjaGVzIHRoYXQgc3ludGF4CgkJaGlnaGxpZ2h0aW5nIHJlY29nbml6ZWQgYXMgc3RyaW5nczogPgoKCTplY2hvIHNlYXJjaHBhaXIoJ3snLCAnJywgJ30nLCAnYlcnLAoJICAgICBcICdzeW5JRGF0dHIoc3luSUQobGluZSgiLiIpLCBjb2woIi4iKSwgMCksICJuYW1lIikgPX4/ICJzdHJpbmciJykKPAoJCQkJCQkJKnNlYXJjaHBhaXJwb3MoKSoKc2VhcmNocGFpcnBvcyh7c3RhcnR9LCB7bWlkZGxlfSwge2VuZH0gWywge2ZsYWdzfSBbLCB7c2tpcH0KCQkJCVssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dXSkKCQlTYW1lIGFzIHxzZWFyY2hwYWlyKCl8LCBidXQgcmV0dXJucyBhIHxMaXN0fCB3aXRoIHRoZSBsaW5lIGFuZAoJCWNvbHVtbiBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guIFRoZSBmaXJzdCBlbGVtZW50IG9mIHRoZSB8TGlzdHwKCQlpcyB0aGUgbGluZSBudW1iZXIgYW5kIHRoZSBzZWNvbmQgZWxlbWVudCBpcyB0aGUgYnl0ZSBpbmRleCBvZgoJCXRoZSBjb2x1bW4gcG9zaXRpb24gb2YgdGhlIG1hdGNoLiAgSWYgbm8gbWF0Y2ggaXMgZm91bmQsCgkJcmV0dXJucyBbMCwgMF0uID4KCgkJCTpsZXQgW2xudW0sY29sXSA9IHNlYXJjaHBhaXJwb3MoJ3snLCAnJywgJ30nLCAnbicpCjwKCQlTZWUgfG1hdGNoLXBhcmVuc3wgZm9yIGEgYmlnZ2VyIGFuZCBtb3JlIHVzZWZ1bCBleGFtcGxlLgoKc2VhcmNocG9zKHtwYXR0ZXJufSBbLCB7ZmxhZ3N9IFssIHtzdG9wbGluZX0gWywge3RpbWVvdXR9XV1dKQkqc2VhcmNocG9zKCkqCgkJU2FtZSBhcyB8c2VhcmNoKCl8LCBidXQgcmV0dXJucyBhIHxMaXN0fCB3aXRoIHRoZSBsaW5lIGFuZAoJCWNvbHVtbiBwb3NpdGlvbiBvZiB0aGUgbWF0Y2guIFRoZSBmaXJzdCBlbGVtZW50IG9mIHRoZSB8TGlzdHwKCQlpcyB0aGUgbGluZSBudW1iZXIgYW5kIHRoZSBzZWNvbmQgZWxlbWVudCBpcyB0aGUgYnl0ZSBpbmRleCBvZgoJCXRoZSBjb2x1bW4gcG9zaXRpb24gb2YgdGhlIG1hdGNoLiBJZiBubyBtYXRjaCBpcyBmb3VuZCwKCQlyZXR1cm5zIFswLCAwXS4KCQlFeGFtcGxlOiA+Cgk6bGV0IFtsbnVtLCBjb2xdID0gc2VhcmNocG9zKCdteXBhdHRlcm4nLCAnbicpCgo8CQlXaGVuIHRoZSAncCcgZmxhZyBpcyBnaXZlbiB0aGVuIHRoZXJlIGlzIGFuIGV4dHJhIGl0ZW0gd2l0aAoJCXRoZSBzdWItcGF0dGVybiBtYXRjaCBudW1iZXIgfHNlYXJjaCgpLXN1Yi1tYXRjaHwuICBFeGFtcGxlOiA+Cgk6bGV0IFtsbnVtLCBjb2wsIHN1Ym1hdGNoXSA9IHNlYXJjaHBvcygnXChcbFwpXHxcKFx1XCknLCAnbnAnKQo8CQlJbiB0aGlzIGV4YW1wbGUgInN1Ym1hdGNoIiBpcyAyIHdoZW4gYSBsb3dlcmNhc2UgbGV0dGVyIGlzCgkJZm91bmQgfC9cbHwsIDMgd2hlbiBhbiB1cHBlcmNhc2UgbGV0dGVyIGlzIGZvdW5kIHwvXHV8LgoKc2VydmVyMmNsaWVudCh7Y2xpZW50aWR9LCB7c3RyaW5nfSkJCQkqc2VydmVyMmNsaWVudCgpKgoJCVNlbmQgYSByZXBseSBzdHJpbmcgdG8ge2NsaWVudGlkfS4gIFRoZSBtb3N0IHJlY2VudCB7Y2xpZW50aWR9CgkJdGhhdCBzZW50IGEgc3RyaW5nIGNhbiBiZSByZXRyaWV2ZWQgd2l0aCBleHBhbmQoIjxjbGllbnQ+IikuCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtjbGllbnRzZXJ2ZXJ8IGZlYXR1cmV9CgkJTm90ZToKCQlUaGlzIGlkIGhhcyB0byBiZSBzdG9yZWQgYmVmb3JlIHRoZSBuZXh0IGNvbW1hbmQgY2FuIGJlCgkJcmVjZWl2ZWQuICBJLmUuIGJlZm9yZSByZXR1cm5pbmcgZnJvbSB0aGUgcmVjZWl2ZWQgY29tbWFuZCBhbmQKCQliZWZvcmUgY2FsbGluZyBhbnkgY29tbWFuZHMgdGhhdCB3YWl0cyBmb3IgaW5wdXQuCgkJU2VlIGFsc28gfGNsaWVudHNlcnZlcnwuCgkJRXhhbXBsZTogPgoJCQk6ZWNobyBzZXJ2ZXIyY2xpZW50KGV4cGFuZCgiPGNsaWVudD4iKSwgIkhFTExPIikKPApzZXJ2ZXJsaXN0KCkJCQkJCSpzZXJ2ZXJsaXN0KCkqCgkJUmV0dXJuIGEgbGlzdCBvZiBhdmFpbGFibGUgc2VydmVyIG5hbWVzLCBvbmUgcGVyIGxpbmUuCgkJV2hlbiB0aGVyZSBhcmUgbm8gc2VydmVycyBvciB0aGUgaW5mb3JtYXRpb24gaXMgbm90IGF2YWlsYWJsZQoJCWFuIGVtcHR5IHN0cmluZyBpcyByZXR1cm5lZC4gIFNlZSBhbHNvIHxjbGllbnRzZXJ2ZXJ8LgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrY2xpZW50c2VydmVyfCBmZWF0dXJlfQoJCUV4YW1wbGU6ID4KCQkJOmVjaG8gc2VydmVybGlzdCgpCjwKc2V0YnVmdmFyKHtleHByfSwge3Zhcm5hbWV9LCB7dmFsfSkJCQkqc2V0YnVmdmFyKCkqCgkJU2V0IG9wdGlvbiBvciBsb2NhbCB2YXJpYWJsZSB7dmFybmFtZX0gaW4gYnVmZmVyIHtleHByfSB0bwoJCXt2YWx9LgoJCVRoaXMgYWxzbyB3b3JrcyBmb3IgYSBnbG9iYWwgb3IgbG9jYWwgd2luZG93IG9wdGlvbiwgYnV0IGl0CgkJZG9lc24ndCB3b3JrIGZvciBhIGdsb2JhbCBvciBsb2NhbCB3aW5kb3cgdmFyaWFibGUuCgkJRm9yIGEgbG9jYWwgd2luZG93IG9wdGlvbiB0aGUgZ2xvYmFsIHZhbHVlIGlzIHVuY2hhbmdlZC4KCQlGb3IgdGhlIHVzZSBvZiB7ZXhwcn0sIHNlZSB8YnVmbmFtZSgpfCBhYm92ZS4KCQlOb3RlIHRoYXQgdGhlIHZhcmlhYmxlIG5hbWUgd2l0aG91dCAiYjoiIG11c3QgYmUgdXNlZC4KCQlFeGFtcGxlczogPgoJCQk6Y2FsbCBzZXRidWZ2YXIoMSwgIiZtb2QiLCAxKQoJCQk6Y2FsbCBzZXRidWZ2YXIoInRvZG8iLCAibXl2YXIiLCAiZm9vYmFyIikKPAkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgpzZXRjaGFyc2VhcmNoKHtkaWN0fSkJCQkJCSpzZXRjaGFyc2VhcmNoKCkqCgkJU2V0IHRoZSBjdXJyZW50IGNoYXJhY3RlciBzZWFyY2ggaW5mb3JtYXRpb24gdG8ge2RpY3R9LAoJCXdoaWNoIGNvbnRhaW5zIG9uZSBvciBtb3JlIG9mIHRoZSBmb2xsb3dpbmcgZW50cmllczoKCgkJICAgIGNoYXIJY2hhcmFjdGVyIHdoaWNoIHdpbGwgYmUgdXNlZCBmb3IgYSBzdWJzZXF1ZW50CgkJCQl8LHwgb3IgfDt8IGNvbW1hbmQ7IGFuIGVtcHR5IHN0cmluZyBjbGVhcnMgdGhlCgkJCQljaGFyYWN0ZXIgc2VhcmNoCgkJICAgIGZvcndhcmQJZGlyZWN0aW9uIG9mIGNoYXJhY3RlciBzZWFyY2g7IDEgZm9yIGZvcndhcmQsCgkJCQkwIGZvciBiYWNrd2FyZAoJCSAgICB1bnRpbAl0eXBlIG9mIGNoYXJhY3RlciBzZWFyY2g7IDEgZm9yIGEgfHR8IG9yIHxUfAoJCQkJY2hhcmFjdGVyIHNlYXJjaCwgMCBmb3IgYW4gfGZ8IG9yIHxGfAoJCQkJY2hhcmFjdGVyIHNlYXJjaAoKCQlUaGlzIGNhbiBiZSB1c2VmdWwgdG8gc2F2ZS9yZXN0b3JlIGEgdXNlcidzIGNoYXJhY3RlciBzZWFyY2gKCQlmcm9tIGEgc2NyaXB0OiA+CgkJCTpsZXQgcHJldnNlYXJjaCA9IGdldGNoYXJzZWFyY2goKQoJCQk6IiBQZXJmb3JtIGEgY29tbWFuZCB3aGljaCBjbG9iYmVycyB1c2VyJ3Mgc2VhcmNoCgkJCTpjYWxsIHNldGNoYXJzZWFyY2gocHJldnNlYXJjaCkKPAkJQWxzbyBzZWUgfGdldGNoYXJzZWFyY2goKXwuCgpzZXRjbWRwb3Moe3Bvc30pCQkJCQkqc2V0Y21kcG9zKCkqCgkJU2V0IHRoZSBjdXJzb3IgcG9zaXRpb24gaW4gdGhlIGNvbW1hbmQgbGluZSB0byBieXRlIHBvc2l0aW9uCgkJe3Bvc30uCVRoZSBmaXJzdCBwb3NpdGlvbiBpcyAxLgoJCVVzZSB8Z2V0Y21kcG9zKCl8IHRvIG9idGFpbiB0aGUgY3VycmVudCBwb3NpdGlvbi4KCQlPbmx5IHdvcmtzIHdoaWxlIGVkaXRpbmcgdGhlIGNvbW1hbmQgbGluZSwgdGh1cyB5b3UgbXVzdCB1c2UKCQl8Y19DVFJMLVxfZXwsIHxjX0NUUkwtUl89fCBvciB8Y19DVFJMLVJfQ1RSTC1SfCB3aXRoICc9Jy4gIEZvcgoJCXxjX0NUUkwtXF9lfCBhbmQgfGNfQ1RSTC1SX0NUUkwtUnwgd2l0aCAnPScgdGhlIHBvc2l0aW9uIGlzCgkJc2V0IGFmdGVyIHRoZSBjb21tYW5kIGxpbmUgaXMgc2V0IHRvIHRoZSBleHByZXNzaW9uLiAgRm9yCgkJfGNfQ1RSTC1SXz18IGl0IGlzIHNldCBhZnRlciBldmFsdWF0aW5nIHRoZSBleHByZXNzaW9uIGJ1dAoJCWJlZm9yZSBpbnNlcnRpbmcgdGhlIHJlc3VsdGluZyB0ZXh0LgoJCVdoZW4gdGhlIG51bWJlciBpcyB0b28gYmlnIHRoZSBjdXJzb3IgaXMgcHV0IGF0IHRoZSBlbmQgb2YgdGhlCgkJbGluZS4gIEEgbnVtYmVyIHNtYWxsZXIgdGhhbiBvbmUgaGFzIHVuZGVmaW5lZCByZXN1bHRzLgoJCVJldHVybnMgMCB3aGVuIHN1Y2Nlc3NmdWwsIDEgd2hlbiBub3QgZWRpdGluZyB0aGUgY29tbWFuZAoJCWxpbmUuCgpzZXRmcGVybSh7Zm5hbWV9LCB7bW9kZX0pCQkJCSpzZXRmcGVybSgpKiAqY2htb2QqCgkJU2V0IHRoZSBmaWxlIHBlcm1pc3Npb25zIGZvciB7Zm5hbWV9IHRvIHttb2RlfS4KCQl7bW9kZX0gbXVzdCBiZSBhIHN0cmluZyB3aXRoIDkgY2hhcmFjdGVycy4gIEl0IGlzIG9mIHRoZSBmb3JtCgkJInJ3eHJ3eHJ3eCIsIHdoZXJlIGVhY2ggZ3JvdXAgb2YgInJ3eCIgZmxhZ3MgcmVwcmVzZW50LCBpbgoJCXR1cm4sIHRoZSBwZXJtaXNzaW9ucyBvZiB0aGUgb3duZXIgb2YgdGhlIGZpbGUsIHRoZSBncm91cCB0aGUKCQlmaWxlIGJlbG9uZ3MgdG8sIGFuZCBvdGhlciB1c2Vycy4gIEEgJy0nIGNoYXJhY3RlciBtZWFucyB0aGUKCQlwZXJtaXNzaW9uIGlzIG9mZiwgYW55IG90aGVyIGNoYXJhY3RlciBtZWFucyBvbi4gIE11bHRpLWJ5dGUKCQljaGFyYWN0ZXJzIGFyZSBub3Qgc3VwcG9ydGVkLgoKCQlGb3IgZXhhbXBsZSAicnctci0tLS0tIiBtZWFucyByZWFkLXdyaXRlIGZvciB0aGUgdXNlciwKCQlyZWFkYWJsZSBieSB0aGUgZ3JvdXAsIG5vdCBhY2Nlc3NpYmxlIGJ5IG90aGVycy4gICJ4eC14LS0tLS0iCgkJd291bGQgZG8gdGhlIHNhbWUgdGhpbmcuCgoJCVJldHVybnMgbm9uLXplcm8gZm9yIHN1Y2Nlc3MsIHplcm8gZm9yIGZhaWx1cmUuCgoJCVRvIHJlYWQgcGVybWlzc2lvbnMgc2VlIHxnZXRmcGVybSgpfC4KCgpzZXRsaW5lKHtsbnVtfSwge3RleHR9KQkJCQkJKnNldGxpbmUoKSoKCQlTZXQgbGluZSB7bG51bX0gb2YgdGhlIGN1cnJlbnQgYnVmZmVyIHRvIHt0ZXh0fS4gIFRvIGluc2VydAoJCWxpbmVzIHVzZSB8YXBwZW5kKCl8LgoJCXtsbnVtfSBpcyB1c2VkIGxpa2Ugd2l0aCB8Z2V0bGluZSgpfC4KCQlXaGVuIHtsbnVtfSBpcyBqdXN0IGJlbG93IHRoZSBsYXN0IGxpbmUgdGhlIHt0ZXh0fSB3aWxsIGJlCgkJYWRkZWQgYXMgYSBuZXcgbGluZS4KCQlJZiB0aGlzIHN1Y2NlZWRzLCAwIGlzIHJldHVybmVkLiAgSWYgdGhpcyBmYWlscyAobW9zdCBsaWtlbHkKCQliZWNhdXNlIHtsbnVtfSBpcyBpbnZhbGlkKSAxIGlzIHJldHVybmVkLiAgRXhhbXBsZTogPgoJCQk6Y2FsbCBzZXRsaW5lKDUsIHN0cmZ0aW1lKCIlYyIpKQo8CQlXaGVuIHt0ZXh0fSBpcyBhIHxMaXN0fCB0aGVuIGxpbmUge2xudW19IGFuZCBmb2xsb3dpbmcgbGluZXMKCQl3aWxsIGJlIHNldCB0byB0aGUgaXRlbXMgaW4gdGhlIGxpc3QuICBFeGFtcGxlOiA+CgkJCTpjYWxsIHNldGxpbmUoNSwgWydhYWEnLCAnYmJiJywgJ2NjYyddKQo8CQlUaGlzIGlzIGVxdWl2YWxlbnQgdG86ID4KCQkJOmZvciBbbiwgbF0gaW4gW1s1LCAnYWFhJ10sIFs2LCAnYmJiJ10sIFs3LCAnY2NjJ11dCgkJCTogIGNhbGwgc2V0bGluZShuLCBsKQoJCQk6ZW5kZm9yCjwJCU5vdGU6IFRoZSAnWyBhbmQgJ10gbWFya3MgYXJlIG5vdCBzZXQuCgpzZXRsb2NsaXN0KHtucn0sIHtsaXN0fSBbLCB7YWN0aW9ufV0pCQkJKnNldGxvY2xpc3QoKSoKCQlDcmVhdGUgb3IgcmVwbGFjZSBvciBhZGQgdG8gdGhlIGxvY2F0aW9uIGxpc3QgZm9yIHdpbmRvdyB7bnJ9LgoJCVdoZW4ge25yfSBpcyB6ZXJvIHRoZSBjdXJyZW50IHdpbmRvdyBpcyB1c2VkLiBGb3IgYSBsb2NhdGlvbgoJCWxpc3Qgd2luZG93LCB0aGUgZGlzcGxheWVkIGxvY2F0aW9uIGxpc3QgaXMgbW9kaWZpZWQuICBGb3IgYW4KCQlpbnZhbGlkIHdpbmRvdyBudW1iZXIge25yfSwgLTEgaXMgcmV0dXJuZWQuCgkJT3RoZXJ3aXNlLCBzYW1lIGFzIHxzZXRxZmxpc3QoKXwuCgkJQWxzbyBzZWUgfGxvY2F0aW9uLWxpc3R8LgoKc2V0bWF0Y2hlcyh7bGlzdH0pCQkJCQkqc2V0bWF0Y2hlcygpKgoJCVJlc3RvcmVzIGEgbGlzdCBvZiBtYXRjaGVzIHNhdmVkIGJ5IHxnZXRtYXRjaGVzKCl8LiAgUmV0dXJucyAwCgkJaWYgc3VjY2Vzc2Z1bCwgb3RoZXJ3aXNlIC0xLiAgQWxsIGN1cnJlbnQgbWF0Y2hlcyBhcmUgY2xlYXJlZAoJCWJlZm9yZSB0aGUgbGlzdCBpcyByZXN0b3JlZC4gIFNlZSBleGFtcGxlIGZvciB8Z2V0bWF0Y2hlcygpfC4KCgkJCQkJCQkqc2V0cG9zKCkqCnNldHBvcyh7ZXhwcn0sIHtsaXN0fSkKCQlTZXQgdGhlIHBvc2l0aW9uIGZvciB7ZXhwcn0uICBQb3NzaWJsZSB2YWx1ZXM6CgkJCS4JdGhlIGN1cnNvcgoJCQkneAltYXJrIHgKCgkJe2xpc3R9IG11c3QgYmUgYSB8TGlzdHwgd2l0aCBmb3VyIG9yIGZpdmUgbnVtYmVyczoKCQkgICAgW2J1Zm51bSwgbG51bSwgY29sLCBvZmZdCgkJICAgIFtidWZudW0sIGxudW0sIGNvbCwgb2ZmLCBjdXJzd2FudF0KCgkJImJ1Zm51bSIgaXMgdGhlIGJ1ZmZlciBudW1iZXIuCVplcm8gY2FuIGJlIHVzZWQgZm9yIHRoZQoJCWN1cnJlbnQgYnVmZmVyLiAgU2V0dGluZyB0aGUgY3Vyc29yIGlzIG9ubHkgcG9zc2libGUgZm9yCgkJdGhlIGN1cnJlbnQgYnVmZmVyLiAgVG8gc2V0IGEgbWFyayBpbiBhbm90aGVyIGJ1ZmZlciB5b3UgY2FuCgkJdXNlIHRoZSB8YnVmbnIoKXwgZnVuY3Rpb24gdG8gdHVybiBhIGZpbGUgbmFtZSBpbnRvIGEgYnVmZmVyCgkJbnVtYmVyLgoJCURvZXMgbm90IGNoYW5nZSB0aGUganVtcGxpc3QuCgoJCSJsbnVtIiBhbmQgImNvbCIgYXJlIHRoZSBwb3NpdGlvbiBpbiB0aGUgYnVmZmVyLiAgVGhlIGZpcnN0CgkJY29sdW1uIGlzIDEuICBVc2UgYSB6ZXJvICJsbnVtIiB0byBkZWxldGUgYSBtYXJrLiAgSWYgImNvbCIgaXMKCQlzbWFsbGVyIHRoYW4gMSB0aGVuIDEgaXMgdXNlZC4KCgkJVGhlICJvZmYiIG51bWJlciBpcyBvbmx5IHVzZWQgd2hlbiAndmlydHVhbGVkaXQnIGlzIHNldC4gVGhlbgoJCWl0IGlzIHRoZSBvZmZzZXQgaW4gc2NyZWVuIGNvbHVtbnMgZnJvbSB0aGUgc3RhcnQgb2YgdGhlCgkJY2hhcmFjdGVyLiAgRS5nLiwgYSBwb3NpdGlvbiB3aXRoaW4gYSA8VGFiPiBvciBhZnRlciB0aGUgbGFzdAoJCWNoYXJhY3Rlci4KCgkJVGhlICJjdXJzd2FudCIgbnVtYmVyIGlzIG9ubHkgdXNlZCB3aGVuIHNldHRpbmcgdGhlIGN1cnNvcgoJCXBvc2l0aW9uLiAgSXQgc2V0cyB0aGUgcHJlZmVycmVkIGNvbHVtbiBmb3Igd2hlbiBtb3ZpbmcgdGhlCgkJY3Vyc29yIHZlcnRpY2FsbHkuICBXaGVuIHRoZSAiY3Vyc3dhbnQiIG51bWJlciBpcyBtaXNzaW5nIHRoZQoJCXByZWZlcnJlZCBjb2x1bW4gaXMgbm90IHNldC4gIFdoZW4gaXQgaXMgcHJlc2VudCBhbmQgc2V0dGluZyBhCgkJbWFyayBwb3NpdGlvbiBpdCBpcyBub3QgdXNlZC4KCgkJTm90ZSB0aGF0IGZvciAnPCBhbmQgJz4gY2hhbmdpbmcgdGhlIGxpbmUgbnVtYmVyIG1heSByZXN1bHQgaW4KCQl0aGUgbWFya3MgdG8gYmUgZWZmZWN0aXZlbHkgYmUgc3dhcHBlZCwgc28gdGhhdCAnPCBpcyBhbHdheXMKCQliZWZvcmUgJz4uCgoJCVJldHVybnMgMCB3aGVuIHRoZSBwb3NpdGlvbiBjb3VsZCBiZSBzZXQsIC0xIG90aGVyd2lzZS4KCQlBbiBlcnJvciBtZXNzYWdlIGlzIGdpdmVuIGlmIHtleHByfSBpcyBpbnZhbGlkLgoKCQlBbHNvIHNlZSB8Z2V0cG9zKCl8IGFuZCB8Z2V0Y3VycG9zKCl8LgoKCQlUaGlzIGRvZXMgbm90IHJlc3RvcmUgdGhlIHByZWZlcnJlZCBjb2x1bW4gZm9yIG1vdmluZwoJCXZlcnRpY2FsbHk7IGlmIHlvdSBzZXQgdGhlIGN1cnNvciBwb3NpdGlvbiB3aXRoIHRoaXMsIHxqfCBhbmQKCQl8a3wgbW90aW9ucyB3aWxsIGp1bXAgdG8gcHJldmlvdXMgY29sdW1ucyEgIFVzZSB8Y3Vyc29yKCl8IHRvCgkJYWxzbyBzZXQgdGhlIHByZWZlcnJlZCBjb2x1bW4uICBBbHNvIHNlZSB0aGUgImN1cnN3YW50IiBrZXkgaW4KCQl8d2lucmVzdHZpZXcoKXwuCgoKc2V0cWZsaXN0KHtsaXN0fSBbLCB7YWN0aW9ufV0pCQkJCSpzZXRxZmxpc3QoKSoKCQlDcmVhdGUgb3IgcmVwbGFjZSBvciBhZGQgdG8gdGhlIHF1aWNrZml4IGxpc3QgdXNpbmcgdGhlIGl0ZW1zCgkJaW4ge2xpc3R9LiAgRWFjaCBpdGVtIGluIHtsaXN0fSBpcyBhIGRpY3Rpb25hcnkuCgkJTm9uLWRpY3Rpb25hcnkgaXRlbXMgaW4ge2xpc3R9IGFyZSBpZ25vcmVkLiAgRWFjaCBkaWN0aW9uYXJ5CgkJaXRlbSBjYW4gY29udGFpbiB0aGUgZm9sbG93aW5nIGVudHJpZXM6CgoJCSAgICBidWZucglidWZmZXIgbnVtYmVyOyBtdXN0IGJlIHRoZSBudW1iZXIgb2YgYSB2YWxpZAoJCQkJYnVmZmVyCgkJICAgIGZpbGVuYW1lCW5hbWUgb2YgYSBmaWxlOyBvbmx5IHVzZWQgd2hlbiAiYnVmbnIiIGlzIG5vdAoJCQkJcHJlc2VudCBvciBpdCBpcyBpbnZhbGlkLgoJCSAgICBsbnVtCWxpbmUgbnVtYmVyIGluIHRoZSBmaWxlCgkJICAgIHBhdHRlcm4Jc2VhcmNoIHBhdHRlcm4gdXNlZCB0byBsb2NhdGUgdGhlIGVycm9yCgkJICAgIGNvbAkJY29sdW1uIG51bWJlcgoJCSAgICB2Y29sCXdoZW4gbm9uLXplcm86ICJjb2wiIGlzIHZpc3VhbCBjb2x1bW4KCQkJCXdoZW4gemVybzogImNvbCIgaXMgYnl0ZSBpbmRleAoJCSAgICBucgkJZXJyb3IgbnVtYmVyCgkJICAgIHRleHQJZGVzY3JpcHRpb24gb2YgdGhlIGVycm9yCgkJICAgIHR5cGUJc2luZ2xlLWNoYXJhY3RlciBlcnJvciB0eXBlLCAnRScsICdXJywgZXRjLgoKCQlUaGUgImNvbCIsICJ2Y29sIiwgIm5yIiwgInR5cGUiIGFuZCAidGV4dCIgZW50cmllcyBhcmUKCQlvcHRpb25hbC4gIEVpdGhlciAibG51bSIgb3IgInBhdHRlcm4iIGVudHJ5IGNhbiBiZSB1c2VkIHRvCgkJbG9jYXRlIGEgbWF0Y2hpbmcgZXJyb3IgbGluZS4KCQlJZiB0aGUgImZpbGVuYW1lIiBhbmQgImJ1Zm5yIiBlbnRyaWVzIGFyZSBub3QgcHJlc2VudCBvcgoJCW5laXRoZXIgdGhlICJsbnVtIiBvciAicGF0dGVybiIgZW50cmllcyBhcmUgcHJlc2VudCwgdGhlbiB0aGUKCQlpdGVtIHdpbGwgbm90IGJlIGhhbmRsZWQgYXMgYW4gZXJyb3IgbGluZS4KCQlJZiBib3RoICJwYXR0ZXJuIiBhbmQgImxudW0iIGFyZSBwcmVzZW50IHRoZW4gInBhdHRlcm4iIHdpbGwKCQliZSB1c2VkLgoJCUlmIHlvdSBzdXBwbHkgYW4gZW1wdHkge2xpc3R9LCB0aGUgcXVpY2tmaXggbGlzdCB3aWxsIGJlCgkJY2xlYXJlZC4KCQlOb3RlIHRoYXQgdGhlIGxpc3QgaXMgbm90IGV4YWN0bHkgdGhlIHNhbWUgYXMgd2hhdAoJCXxnZXRxZmxpc3QoKXwgcmV0dXJucy4KCgkJCQkJCQkqRTkyNyoKCQlJZiB7YWN0aW9ufSBpcyBzZXQgdG8gJ2EnLCB0aGVuIHRoZSBpdGVtcyBmcm9tIHtsaXN0fSBhcmUKCQlhZGRlZCB0byB0aGUgZXhpc3RpbmcgcXVpY2tmaXggbGlzdC4gSWYgdGhlcmUgaXMgbm8gZXhpc3RpbmcKCQlsaXN0LCB0aGVuIGEgbmV3IGxpc3QgaXMgY3JlYXRlZC4gSWYge2FjdGlvbn0gaXMgc2V0IHRvICdyJywKCQl0aGVuIHRoZSBpdGVtcyBmcm9tIHRoZSBjdXJyZW50IHF1aWNrZml4IGxpc3QgYXJlIHJlcGxhY2VkCgkJd2l0aCB0aGUgaXRlbXMgZnJvbSB7bGlzdH0uIElmIHthY3Rpb259IGlzIG5vdCBwcmVzZW50IG9yIGlzCgkJc2V0IHRvICcgJywgdGhlbiBhIG5ldyBsaXN0IGlzIGNyZWF0ZWQuCgoJCVJldHVybnMgemVybyBmb3Igc3VjY2VzcywgLTEgZm9yIGZhaWx1cmUuCgoJCVRoaXMgZnVuY3Rpb24gY2FuIGJlIHVzZWQgdG8gY3JlYXRlIGEgcXVpY2tmaXggbGlzdAoJCWluZGVwZW5kZW50IG9mIHRoZSAnZXJyb3Jmb3JtYXQnIHNldHRpbmcuICBVc2UgYSBjb21tYW5kIGxpa2UKCQkiOmNjIDEiIHRvIGp1bXAgdG8gdGhlIGZpcnN0IHBvc2l0aW9uLgoKCgkJCQkJCQkqc2V0cmVnKCkqCnNldHJlZyh7cmVnbmFtZX0sIHt2YWx1ZX0gWywge29wdGlvbnN9XSkKCQlTZXQgdGhlIHJlZ2lzdGVyIHtyZWduYW1lfSB0byB7dmFsdWV9LgoJCXt2YWx1ZX0gbWF5IGJlIGFueSB2YWx1ZSByZXR1cm5lZCBieSB8Z2V0cmVnKCl8LCBpbmNsdWRpbmcgCgkJYSB8TGlzdHwuCgkJSWYge29wdGlvbnN9IGNvbnRhaW5zICJhIiBvciB7cmVnbmFtZX0gaXMgdXBwZXIgY2FzZSwKCQl0aGVuIHRoZSB2YWx1ZSBpcyBhcHBlbmRlZC4KCQl7b3B0aW9uc30gY2FuIGFsc28gY29udGFpbiBhIHJlZ2lzdGVyIHR5cGUgc3BlY2lmaWNhdGlvbjoKCQkgICAgImMiIG9yICJ2IgkgICAgICB8Y2hhcmFjdGVyd2lzZXwgbW9kZQoJCSAgICAibCIgb3IgIlYiCSAgICAgIHxsaW5ld2lzZXwgbW9kZQoJCSAgICAiYiIgb3IgIjxDVFJMLVY+IiB8YmxvY2t3aXNlLXZpc3VhbHwgbW9kZQoJCUlmIGEgbnVtYmVyIGltbWVkaWF0ZWx5IGZvbGxvd3MgImIiIG9yICI8Q1RSTC1WPiIgdGhlbiB0aGlzIGlzCgkJdXNlZCBhcyB0aGUgd2lkdGggb2YgdGhlIHNlbGVjdGlvbiAtIGlmIGl0IGlzIG5vdCBzcGVjaWZpZWQKCQl0aGVuIHRoZSB3aWR0aCBvZiB0aGUgYmxvY2sgaXMgc2V0IHRvIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycwoJCWluIHRoZSBsb25nZXN0IGxpbmUgKGNvdW50aW5nIGEgPFRhYj4gYXMgMSBjaGFyYWN0ZXIpLgoKCQlJZiB7b3B0aW9uc30gY29udGFpbnMgbm8gcmVnaXN0ZXIgc2V0dGluZ3MsIHRoZW4gdGhlIGRlZmF1bHQKCQlpcyB0byB1c2UgY2hhcmFjdGVyIG1vZGUgdW5sZXNzIHt2YWx1ZX0gZW5kcyBpbiBhIDxOTD4gZm9yIAoJCXN0cmluZyB7dmFsdWV9IGFuZCBsaW5ld2lzZSBtb2RlIGZvciBsaXN0IHt2YWx1ZX0uIEJsb2Nrd2lzZSAKCQltb2RlIGlzIG5ldmVyIHNlbGVjdGVkIGF1dG9tYXRpY2FsbHkuCgkJUmV0dXJucyB6ZXJvIGZvciBzdWNjZXNzLCBub24temVybyBmb3IgZmFpbHVyZS4KCgkJCQkJCQkqRTg4MyoKCQlOb3RlOiB5b3UgbWF5IG5vdCB1c2UgfExpc3R8IGNvbnRhaW5pbmcgbW9yZSB0aGFuIG9uZSBpdGVtIHRvIAoJCSAgICAgIHNldCBzZWFyY2ggYW5kIGV4cHJlc3Npb24gcmVnaXN0ZXJzLiBMaXN0cyBjb250YWluaW5nIG5vIAoJCSAgICAgIGl0ZW1zIGFjdCBsaWtlIGVtcHR5IHN0cmluZ3MuCgoJCUV4YW1wbGVzOiA+CgkJCTpjYWxsIHNldHJlZyh2OnJlZ2lzdGVyLCBAKikKCQkJOmNhbGwgc2V0cmVnKCcqJywgQCUsICdhYycpCgkJCTpjYWxsIHNldHJlZygnYScsICIxXG4yXG4zIiwgJ2I1JykKCjwJCVRoaXMgZXhhbXBsZSBzaG93cyB1c2luZyB0aGUgZnVuY3Rpb25zIHRvIHNhdmUgYW5kIHJlc3RvcmUgYQoJCXJlZ2lzdGVyIChub3RlOiB5b3UgbWF5IG5vdCByZWxpYWJseSByZXN0b3JlIHJlZ2lzdGVyIHZhbHVlIAoJCXdpdGhvdXQgdXNpbmcgdGhlIHRoaXJkIGFyZ3VtZW50IHRvIHxnZXRyZWcoKXwgYXMgd2l0aG91dCBpdCAKCQluZXdsaW5lcyBhcmUgcmVwcmVzZW50ZWQgYXMgbmV3bGluZXMgQU5EIE51bCBieXRlcyBhcmUgCgkJcmVwcmVzZW50ZWQgYXMgbmV3bGluZXMgYXMgd2VsbCwgc2VlIHxOTC11c2VkLWZvci1OdWx8KS4gPgoJCQk6bGV0IHZhcl9hID0gZ2V0cmVnKCdhJywgMSwgMSkKCQkJOmxldCB2YXJfYW1vZGUgPSBnZXRyZWd0eXBlKCdhJykKCQkJICAgIC4uLi4KCQkJOmNhbGwgc2V0cmVnKCdhJywgdmFyX2EsIHZhcl9hbW9kZSkKCjwJCVlvdSBjYW4gYWxzbyBjaGFuZ2UgdGhlIHR5cGUgb2YgYSByZWdpc3RlciBieSBhcHBlbmRpbmcKCQlub3RoaW5nOiA+CgkJCTpjYWxsIHNldHJlZygnYScsICcnLCAnYWwnKQoKc2V0dGFidmFyKHt0YWJucn0sIHt2YXJuYW1lfSwge3ZhbH0pCQkJKnNldHRhYnZhcigpKgoJCVNldCB0YWItbG9jYWwgdmFyaWFibGUge3Zhcm5hbWV9IHRvIHt2YWx9IGluIHRhYiBwYWdlIHt0YWJucn0uCgkJfHQ6dmFyfAoJCU5vdGUgdGhhdCB0aGUgdmFyaWFibGUgbmFtZSB3aXRob3V0ICJ0OiIgbXVzdCBiZSB1c2VkLgoJCVRhYnMgYXJlIG51bWJlcmVkIHN0YXJ0aW5nIHdpdGggb25lLgoJCVRoaXMgZnVuY3Rpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgfHNhbmRib3h8LgoKc2V0dGFid2ludmFyKHt0YWJucn0sIHt3aW5ucn0sIHt2YXJuYW1lfSwge3ZhbH0pCSpzZXR0YWJ3aW52YXIoKSoKCQlTZXQgb3B0aW9uIG9yIGxvY2FsIHZhcmlhYmxlIHt2YXJuYW1lfSBpbiB3aW5kb3cge3dpbm5yfSB0bwoJCXt2YWx9LgoJCVRhYnMgYXJlIG51bWJlcmVkIHN0YXJ0aW5nIHdpdGggb25lLiAgRm9yIHRoZSBjdXJyZW50IHRhYnBhZ2UKCQl1c2UgfHNldHdpbnZhcigpfC4KCQlXaGVuIHt3aW5ucn0gaXMgemVybyB0aGUgY3VycmVudCB3aW5kb3cgaXMgdXNlZC4KCQlUaGlzIGFsc28gd29ya3MgZm9yIGEgZ2xvYmFsIG9yIGxvY2FsIGJ1ZmZlciBvcHRpb24sIGJ1dCBpdAoJCWRvZXNuJ3Qgd29yayBmb3IgYSBnbG9iYWwgb3IgbG9jYWwgYnVmZmVyIHZhcmlhYmxlLgoJCUZvciBhIGxvY2FsIGJ1ZmZlciBvcHRpb24gdGhlIGdsb2JhbCB2YWx1ZSBpcyB1bmNoYW5nZWQuCgkJTm90ZSB0aGF0IHRoZSB2YXJpYWJsZSBuYW1lIHdpdGhvdXQgInc6IiBtdXN0IGJlIHVzZWQuCgkJRXhhbXBsZXM6ID4KCQkJOmNhbGwgc2V0dGFid2ludmFyKDEsIDEsICImbGlzdCIsIDApCgkJCTpjYWxsIHNldHRhYndpbnZhcigzLCAyLCAibXl2YXIiLCAiZm9vYmFyIikKPAkJVGhpcyBmdW5jdGlvbiBpcyBub3QgYXZhaWxhYmxlIGluIHRoZSB8c2FuZGJveHwuCgpzZXR3aW52YXIoe25yfSwge3Zhcm5hbWV9LCB7dmFsfSkJCQkqc2V0d2ludmFyKCkqCgkJTGlrZSB8c2V0dGFid2ludmFyKCl8IGZvciB0aGUgY3VycmVudCB0YWIgcGFnZS4KCQlFeGFtcGxlczogPgoJCQk6Y2FsbCBzZXR3aW52YXIoMSwgIiZsaXN0IiwgMCkKCQkJOmNhbGwgc2V0d2ludmFyKDIsICJteXZhciIsICJmb29iYXIiKQoKc2hhMjU2KHtzdHJpbmd9KQkJCQkJCSpzaGEyNTYoKSoKCQlSZXR1cm5zIGEgU3RyaW5nIHdpdGggNjQgaGV4IGNoYXJhY3RlcnMsIHdoaWNoIGlzIHRoZSBTSEEyNTYKCQljaGVja3N1bSBvZiB7c3RyaW5nfS4KCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2NyeXB0dnwgZmVhdHVyZX0KCnNoZWxsZXNjYXBlKHtzdHJpbmd9IFssIHtzcGVjaWFsfV0pCQkJKnNoZWxsZXNjYXBlKCkqCgkJRXNjYXBlIHtzdHJpbmd9IGZvciB1c2UgYXMgYSBzaGVsbCBjb21tYW5kIGFyZ3VtZW50LgoJCU9uIE1TLVdpbmRvd3MgYW5kIE1TLURPUywgd2hlbiAnc2hlbGxzbGFzaCcgaXMgbm90IHNldCwgaXQKCQl3aWxsIGVuY2xvc2Uge3N0cmluZ30gaW4gZG91YmxlIHF1b3RlcyBhbmQgZG91YmxlIGFsbCBkb3VibGUKCQlxdW90ZXMgd2l0aGluIHtzdHJpbmd9LgoJCUZvciBvdGhlciBzeXN0ZW1zLCBpdCB3aWxsIGVuY2xvc2Uge3N0cmluZ30gaW4gc2luZ2xlIHF1b3RlcwoJCWFuZCByZXBsYWNlIGFsbCAiJyIgd2l0aCAiJ1wnJyIuCgkJV2hlbiB0aGUge3NwZWNpYWx9IGFyZ3VtZW50IGlzIHByZXNlbnQgYW5kIGl0J3MgYSBub24temVybwoJCU51bWJlciBvciBhIG5vbi1lbXB0eSBTdHJpbmcgKHxub24temVyby1hcmd8KSwgdGhlbiBzcGVjaWFsCgkJaXRlbXMgc3VjaCBhcyAiISIsICIlIiwgIiMiIGFuZCAiPGN3b3JkPiIgd2lsbCBiZSBwcmVjZWRlZCBieQoJCWEgYmFja3NsYXNoLiAgVGhpcyBiYWNrc2xhc2ggd2lsbCBiZSByZW1vdmVkIGFnYWluIGJ5IHRoZSB8OiF8CgkJY29tbWFuZC4KCQlUaGUgIiEiIGNoYXJhY3RlciB3aWxsIGJlIGVzY2FwZWQgKGFnYWluIHdpdGggYSB8bm9uLXplcm8tYXJnfAoJCXtzcGVjaWFsfSkgd2hlbiAnc2hlbGwnIGNvbnRhaW5zICJjc2giIGluIHRoZSB0YWlsLiAgVGhhdCBpcwoJCWJlY2F1c2UgZm9yIGNzaCBhbmQgdGNzaCAiISIgaXMgdXNlZCBmb3IgaGlzdG9yeSByZXBsYWNlbWVudAoJCWV2ZW4gd2hlbiBpbnNpZGUgc2luZ2xlIHF1b3Rlcy4KCQlUaGUgPE5MPiBjaGFyYWN0ZXIgaXMgYWxzbyBlc2NhcGVkLiAgV2l0aCBhIHxub24temVyby1hcmd8CgkJe3NwZWNpYWx9IGFuZCAnc2hlbGwnIGNvbnRhaW5pbmcgImNzaCIgaW4gdGhlIHRhaWwgaXQncwoJCWVzY2FwZWQgYSBzZWNvbmQgdGltZS4KCQlFeGFtcGxlIG9mIHVzZSB3aXRoIGEgfDohfCBjb21tYW5kOiA+CgkJICAgIDpleGUgJyFkaXIgJyAuIHNoZWxsZXNjYXBlKGV4cGFuZCgnPGNmaWxlPicpLCAxKQo8CQlUaGlzIHJlc3VsdHMgaW4gYSBkaXJlY3RvcnkgbGlzdGluZyBmb3IgdGhlIGZpbGUgdW5kZXIgdGhlCgkJY3Vyc29yLiAgRXhhbXBsZSBvZiB1c2Ugd2l0aCB8c3lzdGVtKCl8OiA+CgkJICAgIDpjYWxsIHN5c3RlbSgiY2htb2QgK3cgLS0gIiAuIHNoZWxsZXNjYXBlKGV4cGFuZCgiJSIpKSkKPAkJU2VlIGFsc28gfDo6U3wuCgoKc2hpZnR3aWR0aCgpCQkJCQkJKnNoaWZ0d2lkdGgoKSoKCQlSZXR1cm5zIHRoZSBlZmZlY3RpdmUgdmFsdWUgb2YgJ3NoaWZ0d2lkdGgnLiBUaGlzIGlzIHRoZQoJCSdzaGlmdHdpZHRoJyB2YWx1ZSB1bmxlc3MgaXQgaXMgemVybywgaW4gd2hpY2ggY2FzZSBpdCBpcyB0aGUKCQkndGFic3RvcCcgdmFsdWUuICBUaGlzIGZ1bmN0aW9uIHdhcyBpbnRyb2R1Y2VkIHdpdGggcGF0Y2gKCQk3LjMuNjk0IGluIDIwMTIsIGV2ZXJ5Ym9keSBzaG91bGQgaGF2ZSBpdCBieSBub3cuCgoKc2ltcGxpZnkoe2ZpbGVuYW1lfSkJCQkJCSpzaW1wbGlmeSgpKgoJCVNpbXBsaWZ5IHRoZSBmaWxlIG5hbWUgYXMgbXVjaCBhcyBwb3NzaWJsZSB3aXRob3V0IGNoYW5naW5nCgkJdGhlIG1lYW5pbmcuICBTaG9ydGN1dHMgKG9uIE1TLVdpbmRvd3MpIG9yIHN5bWJvbGljIGxpbmtzIChvbgoJCVVuaXgpIGFyZSBub3QgcmVzb2x2ZWQuICBJZiB0aGUgZmlyc3QgcGF0aCBjb21wb25lbnQgaW4KCQl7ZmlsZW5hbWV9IGRlc2lnbmF0ZXMgdGhlIGN1cnJlbnQgZGlyZWN0b3J5LCB0aGlzIHdpbGwgYmUKCQl2YWxpZCBmb3IgdGhlIHJlc3VsdCBhcyB3ZWxsLiAgQSB0cmFpbGluZyBwYXRoIHNlcGFyYXRvciBpcwoJCW5vdCByZW1vdmVkIGVpdGhlci4KCQlFeGFtcGxlOiA+CgkJCXNpbXBsaWZ5KCIuL2Rpci8uLi8uLy9maWxlLyIpID09ICIuL2ZpbGUvIgo8CQlOb3RlOiBUaGUgY29tYmluYXRpb24gImRpci8uLiIgaXMgb25seSByZW1vdmVkIGlmICJkaXIiIGlzCgkJYSBzZWFyY2hhYmxlIGRpcmVjdG9yeSBvciBkb2VzIG5vdCBleGlzdC4gIE9uIFVuaXgsIGl0IGlzIGFsc28KCQlyZW1vdmVkIHdoZW4gImRpciIgaXMgYSBzeW1ib2xpYyBsaW5rIHdpdGhpbiB0aGUgc2FtZQoJCWRpcmVjdG9yeS4gIEluIG9yZGVyIHRvIHJlc29sdmUgYWxsIHRoZSBpbnZvbHZlZCBzeW1ib2xpYwoJCWxpbmtzIGJlZm9yZSBzaW1wbGlmeWluZyB0aGUgcGF0aCBuYW1lLCB1c2UgfHJlc29sdmUoKXwuCgoKc2luKHtleHByfSkJCQkJCQkqc2luKCkqCgkJUmV0dXJuIHRoZSBzaW5lIG9mIHtleHByfSwgbWVhc3VyZWQgaW4gcmFkaWFucywgYXMgYSB8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIHNpbigxMDApCjwJCQktMC41MDYzNjYgPgoJCQk6ZWNobyBzaW4oLTQuMDEpCjwJCQkwLjc2MzMwMQoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJCgpzaW5oKHtleHByfSkJCQkJCQkqc2luaCgpKgoJCVJldHVybiB0aGUgaHlwZXJib2xpYyBzaW5lIG9mIHtleHByfSBhcyBhIHxGbG9hdHwgaW4gdGhlIHJhbmdlCgkJWy1pbmYsIGluZl0uCgkJe2V4cHJ9IG11c3QgZXZhbHVhdGUgdG8gYSB8RmxvYXR8IG9yIGEgfE51bWJlcnwuCgkJRXhhbXBsZXM6ID4KCQkJOmVjaG8gc2luaCgwLjUpCjwJCQkwLjUyMTA5NSA+CgkJCTplY2hvIHNpbmgoLTAuOSkKPAkJCS0xLjAyNjUxNwoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKc29ydCh7bGlzdH0gWywge2Z1bmN9IFssIHtkaWN0fV1dKQkJCSpzb3J0KCkqICpFNzAyKgoJCVNvcnQgdGhlIGl0ZW1zIGluIHtsaXN0fSBpbi1wbGFjZS4gIFJldHVybnMge2xpc3R9LgoJCQoJCUlmIHlvdSB3YW50IGEgbGlzdCB0byByZW1haW4gdW5tb2RpZmllZCBtYWtlIGEgY29weSBmaXJzdDogPgoJCQk6bGV0IHNvcnRlZGxpc3QgPSBzb3J0KGNvcHkobXlsaXN0KSkKCjwJCVdoZW4ge2Z1bmN9IGlzIG9taXR0ZWQsIGlzIGVtcHR5IG9yIHplcm8sIHRoZW4gc29ydCgpIHVzZXMgdGhlCgkJc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIGVhY2ggaXRlbSB0byBzb3J0IG9uLiAgTnVtYmVycyBzb3J0CgkJYWZ0ZXIgU3RyaW5ncywgfExpc3RzfCBhZnRlciBOdW1iZXJzLiAgRm9yIHNvcnRpbmcgdGV4dCBpbiB0aGUKCQljdXJyZW50IGJ1ZmZlciB1c2UgfDpzb3J0fC4KCgkJV2hlbiB7ZnVuY30gaXMgZ2l2ZW4gYW5kIGl0IGlzICcxJyBvciAnaScgdGhlbiBjYXNlIGlzCgkJaWdub3JlZC4KCQkKCQlXaGVuIHtmdW5jfSBpcyBnaXZlbiBhbmQgaXQgaXMgJ24nIHRoZW4gYWxsIGl0ZW1zIHdpbGwgYmUKCQlzb3J0ZWQgbnVtZXJpY2FsIChJbXBsZW1lbnRhdGlvbiBkZXRhaWw6IFRoaXMgdXNlcyB0aGUKCQlzdHJ0b2QoKSBmdW5jdGlvbiB0byBwYXJzZSBudW1iZXJzLCBTdHJpbmdzLCBMaXN0cywgRGljdHMgYW5kCgkJRnVuY3JlZnMgd2lsbCBiZSBjb25zaWRlcmVkIGFzIGJlaW5nIDApLgoKCQlXaGVuIHtmdW5jfSBpcyBnaXZlbiBhbmQgaXQgaXMgJ04nIHRoZW4gYWxsIGl0ZW1zIHdpbGwgYmUKCQlzb3J0ZWQgbnVtZXJpY2FsLiBUaGlzIGlzIGxpa2UgJ24nIGJ1dCBhIHN0cmluZyBjb250YWluaW5nCgkJZGlnaXRzIHdpbGwgYmUgdXNlZCBhcyB0aGUgbnVtYmVyIHRoZXkgcmVwcmVzZW50LgoKCQlXaGVuIHtmdW5jfSBpcyBnaXZlbiBhbmQgaXQgaXMgJ2YnIHRoZW4gYWxsIGl0ZW1zIHdpbGwgYmUKCQlzb3J0ZWQgbnVtZXJpY2FsLiBBbGwgdmFsdWVzIG11c3QgYmUgYSBOdW1iZXIgb3IgYSBGbG9hdC4KCgkJV2hlbiB7ZnVuY30gaXMgYSB8RnVuY3JlZnwgb3IgYSBmdW5jdGlvbiBuYW1lLCB0aGlzIGZ1bmN0aW9uCgkJaXMgY2FsbGVkIHRvIGNvbXBhcmUgaXRlbXMuICBUaGUgZnVuY3Rpb24gaXMgaW52b2tlZCB3aXRoIHR3bwoJCWl0ZW1zIGFzIGFyZ3VtZW50IGFuZCBtdXN0IHJldHVybiB6ZXJvIGlmIHRoZXkgYXJlIGVxdWFsLCAxIG9yCgkJYmlnZ2VyIGlmIHRoZSBmaXJzdCBvbmUgc29ydHMgYWZ0ZXIgdGhlIHNlY29uZCBvbmUsIC0xIG9yCgkJc21hbGxlciBpZiB0aGUgZmlyc3Qgb25lIHNvcnRzIGJlZm9yZSB0aGUgc2Vjb25kIG9uZS4KCgkJe2RpY3R9IGlzIGZvciBmdW5jdGlvbnMgd2l0aCB0aGUgImRpY3QiIGF0dHJpYnV0ZS4gIEl0IHdpbGwgYmUKCQl1c2VkIHRvIHNldCB0aGUgbG9jYWwgdmFyaWFibGUgInNlbGYiLiB8RGljdGlvbmFyeS1mdW5jdGlvbnwKCgkJVGhlIHNvcnQgaXMgc3RhYmxlLCBpdGVtcyB3aGljaCBjb21wYXJlIGVxdWFsIChhcyBudW1iZXIgb3IgYXMKCQlzdHJpbmcpIHdpbGwga2VlcCB0aGVpciByZWxhdGl2ZSBwb3NpdGlvbi4gRS5nLiwgd2hlbiBzb3J0aW5nCgkJb24gbnVtYmVycywgdGV4dCBzdHJpbmdzIHdpbGwgc29ydCBuZXh0IHRvIGVhY2ggb3RoZXIsIGluIHRoZQoJCXNhbWUgb3JkZXIgYXMgdGhleSB3ZXJlIG9yaWdpbmFsbHkuCgoJCUFsc28gc2VlIHx1bmlxKCl8LgoKCQlFeGFtcGxlOiA+CgkJCWZ1bmMgTXlDb21wYXJlKGkxLCBpMikKCQkJICAgcmV0dXJuIGE6aTEgPT0gYTppMiA/IDAgOiBhOmkxID4gYTppMiA/IDEgOiAtMQoJCQllbmRmdW5jCgkJCWxldCBzb3J0ZWRsaXN0ID0gc29ydChteWxpc3QsICJNeUNvbXBhcmUiKQo8CQlBIHNob3J0ZXIgY29tcGFyZSB2ZXJzaW9uIGZvciB0aGlzIHNwZWNpZmljIHNpbXBsZSBjYXNlLCB3aGljaAoJCWlnbm9yZXMgb3ZlcmZsb3c6ID4KCQkJZnVuYyBNeUNvbXBhcmUoaTEsIGkyKQoJCQkgICByZXR1cm4gYTppMSAtIGE6aTIKCQkJZW5kZnVuYwo8CgkJCQkJCQkqc291bmRmb2xkKCkqCnNvdW5kZm9sZCh7d29yZH0pCgkJUmV0dXJuIHRoZSBzb3VuZC1mb2xkZWQgZXF1aXZhbGVudCBvZiB7d29yZH0uICBVc2VzIHRoZSBmaXJzdAoJCWxhbmd1YWdlIGluICdzcGVsbGxhbmcnIGZvciB0aGUgY3VycmVudCB3aW5kb3cgdGhhdCBzdXBwb3J0cwoJCXNvdW5kZm9sZGluZy4gICdzcGVsbCcgbXVzdCBiZSBzZXQuICBXaGVuIG5vIHNvdW5kIGZvbGRpbmcgaXMKCQlwb3NzaWJsZSB0aGUge3dvcmR9IGlzIHJldHVybmVkIHVubW9kaWZpZWQuCgkJVGhpcyBjYW4gYmUgdXNlZCBmb3IgbWFraW5nIHNwZWxsaW5nIHN1Z2dlc3Rpb25zLiAgTm90ZSB0aGF0CgkJdGhlIG1ldGhvZCBjYW4gYmUgcXVpdGUgc2xvdy4KCgkJCQkJCQkqc3BlbGxiYWR3b3JkKCkqCnNwZWxsYmFkd29yZChbe3NlbnRlbmNlfV0pCgkJV2l0aG91dCBhcmd1bWVudDogVGhlIHJlc3VsdCBpcyB0aGUgYmFkbHkgc3BlbGxlZCB3b3JkIHVuZGVyCgkJb3IgYWZ0ZXIgdGhlIGN1cnNvci4gIFRoZSBjdXJzb3IgaXMgbW92ZWQgdG8gdGhlIHN0YXJ0IG9mIHRoZQoJCWJhZCB3b3JkLiAgV2hlbiBubyBiYWQgd29yZCBpcyBmb3VuZCBpbiB0aGUgY3Vyc29yIGxpbmUgdGhlCgkJcmVzdWx0IGlzIGFuIGVtcHR5IHN0cmluZyBhbmQgdGhlIGN1cnNvciBkb2Vzbid0IG1vdmUuCgoJCVdpdGggYXJndW1lbnQ6IFRoZSByZXN1bHQgaXMgdGhlIGZpcnN0IHdvcmQgaW4ge3NlbnRlbmNlfSB0aGF0CgkJaXMgYmFkbHkgc3BlbGxlZC4gIElmIHRoZXJlIGFyZSBubyBzcGVsbGluZyBtaXN0YWtlcyB0aGUKCQlyZXN1bHQgaXMgYW4gZW1wdHkgc3RyaW5nLgoKCQlUaGUgcmV0dXJuIHZhbHVlIGlzIGEgbGlzdCB3aXRoIHR3byBpdGVtczoKCQktIFRoZSBiYWRseSBzcGVsbGVkIHdvcmQgb3IgYW4gZW1wdHkgc3RyaW5nLgoJCS0gVGhlIHR5cGUgb2YgdGhlIHNwZWxsaW5nIGVycm9yOgoJCQkiYmFkIgkJc3BlbGxpbmcgbWlzdGFrZQoJCQkicmFyZSIJCXJhcmUgd29yZAoJCQkibG9jYWwiCQl3b3JkIG9ubHkgdmFsaWQgaW4gYW5vdGhlciByZWdpb24KCQkJImNhcHMiCQl3b3JkIHNob3VsZCBzdGFydCB3aXRoIENhcGl0YWwKCQlFeGFtcGxlOiA+CgkJCWVjaG8gc3BlbGxiYWR3b3JkKCJ0aGUgcXVpayBicm93biBmb3giKQo8CQkJWydxdWlrJywgJ2JhZCddIH4KCgkJVGhlIHNwZWxsaW5nIGluZm9ybWF0aW9uIGZvciB0aGUgY3VycmVudCB3aW5kb3cgaXMgdXNlZC4gIFRoZQoJCSdzcGVsbCcgb3B0aW9uIG11c3QgYmUgc2V0IGFuZCB0aGUgdmFsdWUgb2YgJ3NwZWxsbGFuZycgaXMKCQl1c2VkLgoKCQkJCQkJCSpzcGVsbHN1Z2dlc3QoKSoKc3BlbGxzdWdnZXN0KHt3b3JkfSBbLCB7bWF4fSBbLCB7Y2FwaXRhbH1dXSkKCQlSZXR1cm4gYSB8TGlzdHwgd2l0aCBzcGVsbGluZyBzdWdnZXN0aW9ucyB0byByZXBsYWNlIHt3b3JkfS4KCQlXaGVuIHttYXh9IGlzIGdpdmVuIHVwIHRvIHRoaXMgbnVtYmVyIG9mIHN1Z2dlc3Rpb25zIGFyZQoJCXJldHVybmVkLiAgT3RoZXJ3aXNlIHVwIHRvIDI1IHN1Z2dlc3Rpb25zIGFyZSByZXR1cm5lZC4KCgkJV2hlbiB0aGUge2NhcGl0YWx9IGFyZ3VtZW50IGlzIGdpdmVuIGFuZCBpdCdzIG5vbi16ZXJvIG9ubHkKCQlzdWdnZXN0aW9ucyB3aXRoIGEgbGVhZGluZyBjYXBpdGFsIHdpbGwgYmUgZ2l2ZW4uICBVc2UgdGhpcwoJCWFmdGVyIGEgbWF0Y2ggd2l0aCAnc3BlbGxjYXBjaGVjaycuCgoJCXt3b3JkfSBjYW4gYmUgYSBiYWRseSBzcGVsbGVkIHdvcmQgZm9sbG93ZWQgYnkgb3RoZXIgdGV4dC4KCQlUaGlzIGFsbG93cyBmb3Igam9pbmluZyB0d28gd29yZHMgdGhhdCB3ZXJlIHNwbGl0LiAgVGhlCgkJc3VnZ2VzdGlvbnMgYWxzbyBpbmNsdWRlIHRoZSBmb2xsb3dpbmcgdGV4dCwgdGh1cyB5b3UgY2FuCgkJcmVwbGFjZSBhIGxpbmUuCgoJCXt3b3JkfSBtYXkgYWxzbyBiZSBhIGdvb2Qgd29yZC4gIFNpbWlsYXIgd29yZHMgd2lsbCB0aGVuIGJlCgkJcmV0dXJuZWQuICB7d29yZH0gaXRzZWxmIGlzIG5vdCBpbmNsdWRlZCBpbiB0aGUgc3VnZ2VzdGlvbnMsCgkJYWx0aG91Z2ggaXQgbWF5IGFwcGVhciBjYXBpdGFsaXplZC4KCgkJVGhlIHNwZWxsaW5nIGluZm9ybWF0aW9uIGZvciB0aGUgY3VycmVudCB3aW5kb3cgaXMgdXNlZC4gIFRoZQoJCSdzcGVsbCcgb3B0aW9uIG11c3QgYmUgc2V0IGFuZCB0aGUgdmFsdWVzIG9mICdzcGVsbGxhbmcnIGFuZAoJCSdzcGVsbHN1Z2dlc3QnIGFyZSB1c2VkLgoKCnNwbGl0KHtleHByfSBbLCB7cGF0dGVybn0gWywge2tlZXBlbXB0eX1dXSkJCQkqc3BsaXQoKSoKCQlNYWtlIGEgfExpc3R8IG91dCBvZiB7ZXhwcn0uICBXaGVuIHtwYXR0ZXJufSBpcyBvbWl0dGVkIG9yCgkJZW1wdHkgZWFjaCB3aGl0ZS1zZXBhcmF0ZWQgc2VxdWVuY2Ugb2YgY2hhcmFjdGVycyBiZWNvbWVzIGFuCgkJaXRlbS4KCQlPdGhlcndpc2UgdGhlIHN0cmluZyBpcyBzcGxpdCB3aGVyZSB7cGF0dGVybn0gbWF0Y2hlcywKCQlyZW1vdmluZyB0aGUgbWF0Y2hlZCBjaGFyYWN0ZXJzLiAnaWdub3JlY2FzZScgaXMgbm90IHVzZWQKCQloZXJlLCBhZGQgXGMgdG8gaWdub3JlIGNhc2UuIHwvXGN8CgkJV2hlbiB0aGUgZmlyc3Qgb3IgbGFzdCBpdGVtIGlzIGVtcHR5IGl0IGlzIG9taXR0ZWQsIHVubGVzcyB0aGUKCQl7a2VlcGVtcHR5fSBhcmd1bWVudCBpcyBnaXZlbiBhbmQgaXQncyBub24temVyby4KCQlPdGhlciBlbXB0eSBpdGVtcyBhcmUga2VwdCB3aGVuIHtwYXR0ZXJufSBtYXRjaGVzIGF0IGxlYXN0IG9uZQoJCWNoYXJhY3RlciBvciB3aGVuIHtrZWVwZW1wdHl9IGlzIG5vbi16ZXJvLgoJCUV4YW1wbGU6ID4KCQkJOmxldCB3b3JkcyA9IHNwbGl0KGdldGxpbmUoJy4nKSwgJ1xXXCsnKQo8CQlUbyBzcGxpdCBhIHN0cmluZyBpbiBpbmRpdmlkdWFsIGNoYXJhY3RlcnM6ID4KCQkJOmZvciBjIGluIHNwbGl0KG15c3RyaW5nLCAnXHpzJykKPAkJSWYgeW91IHdhbnQgdG8ga2VlcCB0aGUgc2VwYXJhdG9yIHlvdSBjYW4gYWxzbyB1c2UgJ1x6cycgYXQKCQl0aGUgZW5kIG9mIHRoZSBwYXR0ZXJuOiA+CgkJCTplY2hvIHNwbGl0KCdhYmM6ZGVmOmdoaScsICc6XHpzJykKPAkJCVsnYWJjOicsICdkZWY6JywgJ2doaSddIH4KCQlTcGxpdHRpbmcgYSB0YWJsZSB3aGVyZSB0aGUgZmlyc3QgZWxlbWVudCBjYW4gYmUgZW1wdHk6ID4KCQkJOmxldCBpdGVtcyA9IHNwbGl0KGxpbmUsICc6JywgMSkKPAkJVGhlIG9wcG9zaXRlIGZ1bmN0aW9uIGlzIHxqb2luKCl8LgoKCnNxcnQoe2V4cHJ9KQkJCQkJCSpzcXJ0KCkqCgkJUmV0dXJuIHRoZSBub24tbmVnYXRpdmUgc3F1YXJlIHJvb3Qgb2YgRmxvYXQge2V4cHJ9IGFzIGEKCQl8RmxvYXR8LgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LiAgV2hlbiB7ZXhwcn0KCQlpcyBuZWdhdGl2ZSB0aGUgcmVzdWx0IGlzIE5hTiAoTm90IGEgTnVtYmVyKS4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyBzcXJ0KDEwMCkKPAkJCTEwLjAgPgoJCQk6ZWNobyBzcXJ0KC00LjAxKQo8CQkJbmFuCgkJIm5hbiIgbWF5IGJlIGRpZmZlcmVudCwgaXQgZGVwZW5kcyBvbiBzeXN0ZW0gbGlicmFyaWVzLgoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgkJCgpzdHIyZmxvYXQoe2V4cHJ9KQkJCQkJKnN0cjJmbG9hdCgpKgoJCUNvbnZlcnQgU3RyaW5nIHtleHByfSB0byBhIEZsb2F0LiAgVGhpcyBtb3N0bHkgd29ya3MgdGhlIHNhbWUKCQlhcyB3aGVuIHVzaW5nIGEgZmxvYXRpbmcgcG9pbnQgbnVtYmVyIGluIGFuIGV4cHJlc3Npb24sIHNlZQoJCXxmbG9hdGluZy1wb2ludC1mb3JtYXR8LiAgQnV0IGl0J3MgYSBiaXQgbW9yZSBwZXJtaXNzaXZlLgoJCUUuZy4sICIxZTQwIiBpcyBhY2NlcHRlZCwgd2hpbGUgaW4gYW4gZXhwcmVzc2lvbiB5b3UgbmVlZCB0bwoJCXdyaXRlICIxLjBlNDAiLgoJCVRleHQgYWZ0ZXIgdGhlIG51bWJlciBpcyBzaWxlbnRseSBpZ25vcmVkLgoJCVRoZSBkZWNpbWFsIHBvaW50IGlzIGFsd2F5cyAnLicsIG5vIG1hdHRlciB3aGF0IHRoZSBsb2NhbGUgaXMKCQlzZXQgdG8uICBBIGNvbW1hIGVuZHMgdGhlIG51bWJlcjogIjEyLDM0NS42NyIgaXMgY29udmVydGVkIHRvCgkJMTIuMC4gIFlvdSBjYW4gc3RyaXAgb3V0IHRob3VzYW5kcyBzZXBhcmF0b3JzIHdpdGgKCQl8c3Vic3RpdHV0ZSgpfDogPgoJCQlsZXQgZiA9IHN0cjJmbG9hdChzdWJzdGl0dXRlKHRleHQsICcsJywgJycsICdnJykpCjwJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKc3RyMm5yKHtleHByfSBbLCB7YmFzZX1dKQkJCQkqc3RyMm5yKCkqCgkJQ29udmVydCBzdHJpbmcge2V4cHJ9IHRvIGEgbnVtYmVyLgoJCXtiYXNlfSBpcyB0aGUgY29udmVyc2lvbiBiYXNlLCBpdCBjYW4gYmUgMiwgOCwgMTAgb3IgMTYuCgkJV2hlbiB7YmFzZX0gaXMgb21pdHRlZCBiYXNlIDEwIGlzIHVzZWQuICBUaGlzIGFsc28gbWVhbnMgdGhhdAoJCWEgbGVhZGluZyB6ZXJvIGRvZXNuJ3QgY2F1c2Ugb2N0YWwgY29udmVyc2lvbiB0byBiZSB1c2VkLCBhcwoJCXdpdGggdGhlIGRlZmF1bHQgU3RyaW5nIHRvIE51bWJlciBjb252ZXJzaW9uLgoJCVdoZW4ge2Jhc2V9IGlzIDE2IGEgbGVhZGluZyAiMHgiIG9yICIwWCIgaXMgaWdub3JlZC4gIFdpdGggYQoJCWRpZmZlcmVudCBiYXNlIHRoZSByZXN1bHQgd2lsbCBiZSB6ZXJvLiAgU2ltaWxhcmx5LCB3aGVuCgkJe2Jhc2V9IGlzIDggYSBsZWFkaW5nICIwIiBpcyBpZ25vcmVkLCBhbmQgd2hlbiB7YmFzZX0gaXMgMiBhCgkJbGVhZGluZyAiMGIiIG9yICIwQiIgaXMgaWdub3JlZC4KCQlUZXh0IGFmdGVyIHRoZSBudW1iZXIgaXMgc2lsZW50bHkgaWdub3JlZC4KCgpzdHJjaGFycyh7ZXhwcn0gWywge3NraXBjY31dKQkJCQkJKnN0cmNoYXJzKCkqCgkJVGhlIHJlc3VsdCBpcyBhIE51bWJlciwgd2hpY2ggaXMgdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzCgkJaW4gU3RyaW5nIHtleHByfS4KCQlXaGVuIHtza2lwY2N9IGlzIG9taXR0ZWQgb3IgemVybywgY29tcG9zaW5nIGNoYXJhY3RlcnMgYXJlCgkJY291bnRlZCBzZXBhcmF0ZWx5LgoJCVdoZW4ge3NraXBjY30gc2V0IHRvIDEsIENvbXBvc2luZyBjaGFyYWN0ZXJzIGFyZSBpZ25vcmVkLgoJCUFsc28gc2VlIHxzdHJsZW4oKXwsIHxzdHJkaXNwbGF5d2lkdGgoKXwgYW5kIHxzdHJ3aWR0aCgpfC4KCQkKCQl7c2tpcGNjfSBpcyBvbmx5IGF2YWlsYWJsZSBhZnRlciA3LjQuNzU1LiAgRm9yIGJhY2t3YXJkCgkJY29tcGF0aWJpbGl0eSwgeW91IGNhbiBkZWZpbmUgYSB3cmFwcGVyIGZ1bmN0aW9uOiA+CgkJICAgIGlmIGhhcygicGF0Y2gtNy40Ljc1NSIpCgkJICAgICAgZnVuY3Rpb24gczpzdHJjaGFycyhzdHIsIHNraXBjYykKCQkJcmV0dXJuIHN0cmNoYXJzKGE6c3RyLCBhOnNraXBjYykKCQkgICAgICBlbmRmdW5jdGlvbgoJCSAgICBlbHNlCgkJICAgICAgZnVuY3Rpb24gczpzdHJjaGFycyhzdHIsIHNraXBjYykKCQkJaWYgYTpza2lwY2MKCQkJICByZXR1cm4gc3RybGVuKHN1YnN0aXR1dGUoYTpzdHIsICIuIiwgIngiLCAiZyIpKQoJCQllbHNlCgkJCSAgcmV0dXJuIHN0cmNoYXJzKGE6c3RyKQoJCQllbmRpZgoJCSAgICAgIGVuZGZ1bmN0aW9uCgkJICAgIGVuZGlmCjwKc3RyY2hhcnBhcnQoe3NyY30sIHtzdGFydH1bLCB7bGVufV0pCQkJKnN0cmNoYXJwYXJ0KCkqCgkJTGlrZSB8c3RycGFydCgpfCBidXQgdXNpbmcgY2hhcmFjdGVyIGluZGV4IGFuZCBsZW5ndGggaW5zdGVhZAoJCW9mIGJ5dGUgaW5kZXggYW5kIGxlbmd0aC4KCQlXaGVuIGEgY2hhcmFjdGVyIGluZGV4IGlzIHVzZWQgd2hlcmUgYSBjaGFyYWN0ZXIgZG9lcyBub3QKCQlleGlzdCBpdCBpcyBhc3N1bWVkIHRvIGJlIG9uZSBieXRlLiAgRm9yIGV4YW1wbGU6ID4KCQkJc3RyY2hhcnBhcnQoJ2FiYycsIC0xLCAyKQo8CQlyZXN1bHRzIGluICdhJy4KCnN0cmRpc3BsYXl3aWR0aCh7ZXhwcn1bLCB7Y29sfV0pCQkJKnN0cmRpc3BsYXl3aWR0aCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgZGlzcGxheSBjZWxscwoJCVN0cmluZyB7ZXhwcn0gb2NjdXBpZXMgb24gdGhlIHNjcmVlbiB3aGVuIGl0IHN0YXJ0cyBhdCB7Y29sfS4KCQlXaGVuIHtjb2x9IGlzIG9taXR0ZWQgemVybyBpcyB1c2VkLiAgT3RoZXJ3aXNlIGl0IGlzIHRoZQoJCXNjcmVlbiBjb2x1bW4gd2hlcmUgdG8gc3RhcnQuICBUaGlzIG1hdHRlcnMgZm9yIFRhYgoJCWNoYXJhY3RlcnMuCgkJVGhlIG9wdGlvbiBzZXR0aW5ncyBvZiB0aGUgY3VycmVudCB3aW5kb3cgYXJlIHVzZWQuICBUaGlzCgkJbWF0dGVycyBmb3IgYW55dGhpbmcgdGhhdCdzIGRpc3BsYXllZCBkaWZmZXJlbnRseSwgc3VjaCBhcwoJCSd0YWJzdG9wJyBhbmQgJ2Rpc3BsYXknLgoJCVdoZW4ge2V4cHJ9IGNvbnRhaW5zIGNoYXJhY3RlcnMgd2l0aCBFYXN0IEFzaWFuIFdpZHRoIENsYXNzCgkJQW1iaWd1b3VzLCB0aGlzIGZ1bmN0aW9uJ3MgcmV0dXJuIHZhbHVlIGRlcGVuZHMgb24gJ2FtYml3aWR0aCcuCgkJQWxzbyBzZWUgfHN0cmxlbigpfCwgfHN0cndpZHRoKCl8IGFuZCB8c3RyY2hhcnMoKXwuCgpzdHJmdGltZSh7Zm9ybWF0fSBbLCB7dGltZX1dKQkJCQkqc3RyZnRpbWUoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyBhIGZvcm1hdHRlZCBkYXRlIGFuZCB0aW1lLCBhcwoJCXNwZWNpZmllZCBieSB0aGUge2Zvcm1hdH0gc3RyaW5nLiAgVGhlIGdpdmVuIHt0aW1lfSBpcyB1c2VkLAoJCW9yIHRoZSBjdXJyZW50IHRpbWUgaWYgbm8gdGltZSBpcyBnaXZlbi4gIFRoZSBhY2NlcHRlZAoJCXtmb3JtYXR9IGRlcGVuZHMgb24geW91ciBzeXN0ZW0sIHRodXMgdGhpcyBpcyBub3QgcG9ydGFibGUhCgkJU2VlIHRoZSBtYW51YWwgcGFnZSBvZiB0aGUgQyBmdW5jdGlvbiBzdHJmdGltZSgpIGZvciB0aGUKCQlmb3JtYXQuICBUaGUgbWF4aW11bSBsZW5ndGggb2YgdGhlIHJlc3VsdCBpcyA4MCBjaGFyYWN0ZXJzLgoJCVNlZSBhbHNvIHxsb2NhbHRpbWUoKXwgYW5kIHxnZXRmdGltZSgpfC4KCQlUaGUgbGFuZ3VhZ2UgY2FuIGJlIGNoYW5nZWQgd2l0aCB0aGUgfDpsYW5ndWFnZXwgY29tbWFuZC4KCQlFeGFtcGxlczogPgoJCSAgOmVjaG8gc3RyZnRpbWUoIiVjIikJCSAgIFN1biBBcHIgMjcgMTE6NDk6MjMgMTk5NwoJCSAgOmVjaG8gc3RyZnRpbWUoIiVZICViICVkICVYIikJICAgMTk5NyBBcHIgMjcgMTE6NTM6MjUKCQkgIDplY2hvIHN0cmZ0aW1lKCIleSVtJWQgJVQiKQkgICA5NzA0MjcgMTE6NTM6NTUKCQkgIDplY2hvIHN0cmZ0aW1lKCIlSDolTSIpCSAgIDExOjU1CgkJICA6ZWNobyBzdHJmdGltZSgiJWMiLCBnZXRmdGltZSgiZmlsZS5jIikpCgkJCQkJCSAgIFNob3cgbW9kIHRpbWUgb2YgZmlsZS5jLgo8CQlOb3QgYXZhaWxhYmxlIG9uIGFsbCBzeXN0ZW1zLiAgVG8gY2hlY2sgdXNlOiA+CgkJCTppZiBleGlzdHMoIipzdHJmdGltZSIpCgpzdHJnZXRjaGFyKHtzdHJ9LCB7aW5kZXh9KQkJCQkqc3RyZ2V0Y2hhcigpKgoJCUdldCBjaGFyYWN0ZXIge2luZGV4fSBmcm9tIHtzdHJ9LiAgVGhpcyB1c2VzIGEgY2hhcmFjdGVyCgkJaW5kZXgsIG5vdCBhIGJ5dGUgaW5kZXguICBDb21wb3NpbmcgY2hhcmFjdGVycyBhcmUgY29uc2lkZXJlZAoJCXNlcGFyYXRlIGNoYXJhY3RlcnMgaGVyZS4KCQlBbHNvIHNlZSB8c3RyY2hhcnBhcnQoKXwgYW5kIHxzdHJjaGFycygpfC4KCnN0cmlkeCh7aGF5c3RhY2t9LCB7bmVlZGxlfSBbLCB7c3RhcnR9XSkJCSpzdHJpZHgoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBnaXZlcyB0aGUgYnl0ZSBpbmRleCBpbgoJCXtoYXlzdGFja30gb2YgdGhlIGZpcnN0IG9jY3VycmVuY2Ugb2YgdGhlIFN0cmluZyB7bmVlZGxlfS4KCQlJZiB7c3RhcnR9IGlzIHNwZWNpZmllZCwgdGhlIHNlYXJjaCBzdGFydHMgYXQgaW5kZXgge3N0YXJ0fS4KCQlUaGlzIGNhbiBiZSB1c2VkIHRvIGZpbmQgYSBzZWNvbmQgbWF0Y2g6ID4KCQkJOmxldCBjb2xvbjEgPSBzdHJpZHgobGluZSwgIjoiKQoJCQk6bGV0IGNvbG9uMiA9IHN0cmlkeChsaW5lLCAiOiIsIGNvbG9uMSArIDEpCjwJCVRoZSBzZWFyY2ggaXMgZG9uZSBjYXNlLXNlbnNpdGl2ZS4KCQlGb3IgcGF0dGVybiBzZWFyY2hlcyB1c2UgfG1hdGNoKCl8LgoJCS0xIGlzIHJldHVybmVkIGlmIHRoZSB7bmVlZGxlfSBkb2VzIG5vdCBvY2N1ciBpbiB7aGF5c3RhY2t9LgoJCVNlZSBhbHNvIHxzdHJyaWR4KCl8LgoJCUV4YW1wbGVzOiA+CgkJICA6ZWNobyBzdHJpZHgoIkFuIEV4YW1wbGUiLCAiRXhhbXBsZSIpCSAgICAgMwoJCSAgOmVjaG8gc3RyaWR4KCJTdGFydGluZyBwb2ludCIsICJTdGFydCIpICAgIDAKCQkgIDplY2hvIHN0cmlkeCgiU3RhcnRpbmcgcG9pbnQiLCAic3RhcnQiKSAgIC0xCjwJCQkJCQkqc3Ryc3RyKCkqICpzdHJjaHIoKSoKCQlzdHJpZHgoKSB3b3JrcyBzaW1pbGFyIHRvIHRoZSBDIGZ1bmN0aW9uIHN0cnN0cigpLiAgV2hlbiB1c2VkCgkJd2l0aCBhIHNpbmdsZSBjaGFyYWN0ZXIgaXQgd29ya3Mgc2ltaWxhciB0byBzdHJjaHIoKS4KCgkJCQkJCQkqc3RyaW5nKCkqCnN0cmluZyh7ZXhwcn0pCVJldHVybiB7ZXhwcn0gY29udmVydGVkIHRvIGEgU3RyaW5nLiAgSWYge2V4cHJ9IGlzIGEgTnVtYmVyLAoJCUZsb2F0LCBTdHJpbmcgb3IgYSBjb21wb3NpdGlvbiBvZiB0aGVtLCB0aGVuIHRoZSByZXN1bHQgY2FuIGJlCgkJcGFyc2VkIGJhY2sgd2l0aCB8ZXZhbCgpfC4KCQkJe2V4cHJ9IHR5cGUJcmVzdWx0IH4KCQkJU3RyaW5nCQknc3RyaW5nJyAoc2luZ2xlIHF1b3RlcyBhcmUgZG91YmxlZCkKCQkJTnVtYmVyCQkxMjMKCQkJRmxvYXQJCTEyMy4xMjM0NTYgb3IgMS4xMjM0NTZlOAoJCQlGdW5jcmVmCQlmdW5jdGlvbignbmFtZScpCgkJCUxpc3QJCVtpdGVtLCBpdGVtXQoJCQlEaWN0aW9uYXJ5CXtrZXk6IHZhbHVlLCBrZXk6IHZhbHVlfQoKCQlXaGVuIGEgTGlzdCBvciBEaWN0aW9uYXJ5IGhhcyBhIHJlY3Vyc2l2ZSByZWZlcmVuY2UgaXQgaXMKCQlyZXBsYWNlZCBieSAiWy4uLl0iIG9yICJ7Li4ufSIuICBVc2luZyBldmFsKCkgb24gdGhlIHJlc3VsdAoJCXdpbGwgdGhlbiBmYWlsLgoKCQlBbHNvIHNlZSB8c3RydHJhbnMoKXwuCgoJCQkJCQkJKnN0cmxlbigpKgpzdHJsZW4oe2V4cHJ9KQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbGVuZ3RoIG9mIHRoZSBTdHJpbmcKCQl7ZXhwcn0gaW4gYnl0ZXMuCgkJSWYgdGhlIGFyZ3VtZW50IGlzIGEgTnVtYmVyIGl0IGlzIGZpcnN0IGNvbnZlcnRlZCB0byBhIFN0cmluZy4KCQlGb3Igb3RoZXIgdHlwZXMgYW4gZXJyb3IgaXMgZ2l2ZW4uCgkJSWYgeW91IHdhbnQgdG8gY291bnQgdGhlIG51bWJlciBvZiBtdWx0aS1ieXRlIGNoYXJhY3RlcnMgdXNlCgkJfHN0cmNoYXJzKCl8LgoJCUFsc28gc2VlIHxsZW4oKXwsIHxzdHJkaXNwbGF5d2lkdGgoKXwgYW5kIHxzdHJ3aWR0aCgpfC4KCnN0cnBhcnQoe3NyY30sIHtzdGFydH1bLCB7bGVufV0pCQkJKnN0cnBhcnQoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyBwYXJ0IG9mIHtzcmN9LCBzdGFydGluZyBmcm9tCgkJYnl0ZSB7c3RhcnR9LCB3aXRoIHRoZSBieXRlIGxlbmd0aCB7bGVufS4KCQlUbyBjb3VudCBjaGFyYWN0ZXJzIGluc3RlYWQgb2YgYnl0ZXMgdXNlIHxzdHJjaGFycGFydCgpfC4KCgkJV2hlbiBieXRlcyBhcmUgc2VsZWN0ZWQgd2hpY2ggZG8gbm90IGV4aXN0LCB0aGlzIGRvZXNuJ3QKCQlyZXN1bHQgaW4gYW4gZXJyb3IsIHRoZSBieXRlcyBhcmUgc2ltcGx5IG9taXR0ZWQuCgkJSWYge2xlbn0gaXMgbWlzc2luZywgdGhlIGNvcHkgY29udGludWVzIGZyb20ge3N0YXJ0fSB0aWxsIHRoZQoJCWVuZCBvZiB0aGUge3NyY30uID4KCQkJc3RycGFydCgiYWJjZGVmZyIsIDMsIDIpICAgID09ICJkZSIKCQkJc3RycGFydCgiYWJjZGVmZyIsIC0yLCA0KSAgID09ICJhYiIKCQkJc3RycGFydCgiYWJjZGVmZyIsIDUsIDQpICAgID09ICJmZyIKCQkJc3RycGFydCgiYWJjZGVmZyIsIDMpCSAgICA9PSAiZGVmZyIKCjwJCU5vdGU6IFRvIGdldCB0aGUgZmlyc3QgY2hhcmFjdGVyLCB7c3RhcnR9IG11c3QgYmUgMC4gIEZvcgoJCWV4YW1wbGUsIHRvIGdldCB0aHJlZSBieXRlcyB1bmRlciBhbmQgYWZ0ZXIgdGhlIGN1cnNvcjogPgoJCQlzdHJwYXJ0KGdldGxpbmUoIi4iKSwgY29sKCIuIikgLSAxLCAzKQo8CnN0cnJpZHgoe2hheXN0YWNrfSwge25lZWRsZX0gWywge3N0YXJ0fV0pCQkJKnN0cnJpZHgoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBnaXZlcyB0aGUgYnl0ZSBpbmRleCBpbgoJCXtoYXlzdGFja30gb2YgdGhlIGxhc3Qgb2NjdXJyZW5jZSBvZiB0aGUgU3RyaW5nIHtuZWVkbGV9LgoJCVdoZW4ge3N0YXJ0fSBpcyBzcGVjaWZpZWQsIG1hdGNoZXMgYmV5b25kIHRoaXMgaW5kZXggYXJlCgkJaWdub3JlZC4gIFRoaXMgY2FuIGJlIHVzZWQgdG8gZmluZCBhIG1hdGNoIGJlZm9yZSBhIHByZXZpb3VzCgkJbWF0Y2g6ID4KCQkJOmxldCBsYXN0Y29tbWEgPSBzdHJyaWR4KGxpbmUsICIsIikKCQkJOmxldCBjb21tYTIgPSBzdHJyaWR4KGxpbmUsICIsIiwgbGFzdGNvbW1hIC0gMSkKPAkJVGhlIHNlYXJjaCBpcyBkb25lIGNhc2Utc2Vuc2l0aXZlLgoJCUZvciBwYXR0ZXJuIHNlYXJjaGVzIHVzZSB8bWF0Y2goKXwuCgkJLTEgaXMgcmV0dXJuZWQgaWYgdGhlIHtuZWVkbGV9IGRvZXMgbm90IG9jY3VyIGluIHtoYXlzdGFja30uCgkJSWYgdGhlIHtuZWVkbGV9IGlzIGVtcHR5IHRoZSBsZW5ndGggb2Yge2hheXN0YWNrfSBpcyByZXR1cm5lZC4KCQlTZWUgYWxzbyB8c3RyaWR4KCl8LiAgRXhhbXBsZXM6ID4KCQkgIDplY2hvIHN0cnJpZHgoImFuIGFuZ3J5IGFybWFkaWxsbyIsICJhbiIpCSAgICAgMwo8CQkJCQkJCSpzdHJyY2hyKCkqCgkJV2hlbiB1c2VkIHdpdGggYSBzaW5nbGUgY2hhcmFjdGVyIGl0IHdvcmtzIHNpbWlsYXIgdG8gdGhlIEMKCQlmdW5jdGlvbiBzdHJyY2hyKCkuCgpzdHJ0cmFucyh7ZXhwcn0pCQkJCQkqc3RydHJhbnMoKSoKCQlUaGUgcmVzdWx0IGlzIGEgU3RyaW5nLCB3aGljaCBpcyB7ZXhwcn0gd2l0aCBhbGwgdW5wcmludGFibGUKCQljaGFyYWN0ZXJzIHRyYW5zbGF0ZWQgaW50byBwcmludGFibGUgY2hhcmFjdGVycyB8J2lzcHJpbnQnfC4KCQlMaWtlIHRoZXkgYXJlIHNob3duIGluIGEgd2luZG93LiAgRXhhbXBsZTogPgoJCQllY2hvIHN0cnRyYW5zKEBhKQo8CQlUaGlzIGRpc3BsYXlzIGEgbmV3bGluZSBpbiByZWdpc3RlciBhIGFzICJeQCIgaW5zdGVhZCBvZgoJCXN0YXJ0aW5nIGEgbmV3IGxpbmUuCgpzdHJ3aWR0aCh7ZXhwcn0pCQkJCQkqc3Ryd2lkdGgoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIGRpc3BsYXkgY2VsbHMKCQlTdHJpbmcge2V4cHJ9IG9jY3VwaWVzLiAgQSBUYWIgY2hhcmFjdGVyIGlzIGNvdW50ZWQgYXMgb25lCgkJY2VsbCwgYWx0ZXJuYXRpdmVseSB1c2UgfHN0cmRpc3BsYXl3aWR0aCgpfC4KCQlXaGVuIHtleHByfSBjb250YWlucyBjaGFyYWN0ZXJzIHdpdGggRWFzdCBBc2lhbiBXaWR0aCBDbGFzcwoJCUFtYmlndW91cywgdGhpcyBmdW5jdGlvbidzIHJldHVybiB2YWx1ZSBkZXBlbmRzIG9uICdhbWJpd2lkdGgnLgoJCUFsc28gc2VlIHxzdHJsZW4oKXwsIHxzdHJkaXNwbGF5d2lkdGgoKXwgYW5kIHxzdHJjaGFycygpfC4KCnN1Ym1hdGNoKHtucn1bLCB7bGlzdH1dKQkJCQkqc3VibWF0Y2goKSoKCQlPbmx5IGZvciBhbiBleHByZXNzaW9uIGluIGEgfDpzdWJzdGl0dXRlfCBjb21tYW5kIG9yCgkJc3Vic3RpdHV0ZSgpIGZ1bmN0aW9uLgoJCVJldHVybnMgdGhlIHtucn0ndGggc3VibWF0Y2ggb2YgdGhlIG1hdGNoZWQgdGV4dC4gIFdoZW4ge25yfQoJCWlzIDAgdGhlIHdob2xlIG1hdGNoZWQgdGV4dCBpcyByZXR1cm5lZC4KCQlOb3RlIHRoYXQgYSBOTCBpbiB0aGUgc3RyaW5nIGNhbiBzdGFuZCBmb3IgYSBsaW5lIGJyZWFrIG9mIGEKCQltdWx0aS1saW5lIG1hdGNoIG9yIGEgTlVMIGNoYXJhY3RlciBpbiB0aGUgdGV4dC4KCQlBbHNvIHNlZSB8c3ViLXJlcGxhY2UtZXhwcmVzc2lvbnwuCgoJCUlmIHtsaXN0fSBpcyBwcmVzZW50IGFuZCBub24temVybyB0aGVuIHN1Ym1hdGNoKCkgcmV0dXJucyAKCQlhIGxpc3Qgb2Ygc3RyaW5ncywgc2ltaWxhciB0byB8Z2V0bGluZSgpfCB3aXRoIHR3byBhcmd1bWVudHMuIAoJCU5MIGNoYXJhY3RlcnMgaW4gdGhlIHRleHQgcmVwcmVzZW50IE5VTCBjaGFyYWN0ZXJzIGluIHRoZQoJCXRleHQuCgkJT25seSByZXR1cm5zIG1vcmUgdGhhbiBvbmUgaXRlbSBmb3IgfDpzdWJzdGl0dXRlfCwgaW5zaWRlCgkJfHN1YnN0aXR1dGUoKXwgdGhpcyBsaXN0IHdpbGwgYWx3YXlzIGNvbnRhaW4gb25lIG9yIHplcm8KCQlpdGVtcywgc2luY2UgdGhlcmUgYXJlIG5vIHJlYWwgbGluZSBicmVha3MuCgoJCUV4YW1wbGU6ID4KCQkJOnMvXGRcKy9cPXN1Ym1hdGNoKDApICsgMS8KPAkJVGhpcyBmaW5kcyB0aGUgZmlyc3QgbnVtYmVyIGluIHRoZSBsaW5lIGFuZCBhZGRzIG9uZSB0byBpdC4KCQlBIGxpbmUgYnJlYWsgaXMgaW5jbHVkZWQgYXMgYSBuZXdsaW5lIGNoYXJhY3Rlci4KCnN1YnN0aXR1dGUoe2V4cHJ9LCB7cGF0fSwge3N1Yn0sIHtmbGFnc30pCQkqc3Vic3RpdHV0ZSgpKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIGEgY29weSBvZiB7ZXhwcn0sIGluIHdoaWNoCgkJdGhlIGZpcnN0IG1hdGNoIG9mIHtwYXR9IGlzIHJlcGxhY2VkIHdpdGgge3N1Yn0uCgkJV2hlbiB7ZmxhZ3N9IGlzICJnIiwgYWxsIG1hdGNoZXMgb2Yge3BhdH0gaW4ge2V4cHJ9IGFyZQoJCXJlcGxhY2VkLiAgT3RoZXJ3aXNlIHtmbGFnc30gc2hvdWxkIGJlICIiLgoJCQoJCVRoaXMgd29ya3MgbGlrZSB0aGUgIjpzdWJzdGl0dXRlIiBjb21tYW5kICh3aXRob3V0IGFueSBmbGFncykuCgkJQnV0IHRoZSBtYXRjaGluZyB3aXRoIHtwYXR9IGlzIGFsd2F5cyBkb25lIGxpa2UgdGhlICdtYWdpYycKCQlvcHRpb24gaXMgc2V0IGFuZCAnY3BvcHRpb25zJyBpcyBlbXB0eSAodG8gbWFrZSBzY3JpcHRzCgkJcG9ydGFibGUpLiAgJ2lnbm9yZWNhc2UnIGlzIHN0aWxsIHJlbGV2YW50LCB1c2UgfC9cY3wgb3IgfC9cQ3wKCQlpZiB5b3Ugd2FudCB0byBpZ25vcmUgb3IgbWF0Y2ggY2FzZSBhbmQgaWdub3JlICdpZ25vcmVjYXNlJy4KCQknc21hcnRjYXNlJyBpcyBub3QgdXNlZC4gIFNlZSB8c3RyaW5nLW1hdGNofCBmb3IgaG93IHtwYXR9IGlzCgkJdXNlZC4KCgkJQSAifiIgaW4ge3N1Yn0gaXMgbm90IHJlcGxhY2VkIHdpdGggdGhlIHByZXZpb3VzIHtzdWJ9LgoJCU5vdGUgdGhhdCBzb21lIGNvZGVzIGluIHtzdWJ9IGhhdmUgYSBzcGVjaWFsIG1lYW5pbmcKCQl8c3ViLXJlcGxhY2Utc3BlY2lhbHwuCUZvciBleGFtcGxlLCB0byByZXBsYWNlIHNvbWV0aGluZyB3aXRoCgkJIlxuIiAodHdvIGNoYXJhY3RlcnMpLCB1c2UgIlxcXFxuIiBvciAnXFxuJy4KCgkJV2hlbiB7cGF0fSBkb2VzIG5vdCBtYXRjaCBpbiB7ZXhwcn0sIHtleHByfSBpcyByZXR1cm5lZAoJCXVubW9kaWZpZWQuCgoJCUV4YW1wbGU6ID4KCQkJOmxldCAmcGF0aCA9IHN1YnN0aXR1dGUoJnBhdGgsICIsXFw9W14sXSokIiwgIiIsICIiKQo8CQlUaGlzIHJlbW92ZXMgdGhlIGxhc3QgY29tcG9uZW50IG9mIHRoZSAncGF0aCcgb3B0aW9uLiA+CgkJCTplY2hvIHN1YnN0aXR1dGUoInRlc3RpbmciLCAiLioiLCAiXFxVXFwwIiwgIiIpCjwJCXJlc3VsdHMgaW4gIlRFU1RJTkciLgoKCQlXaGVuIHtzdWJ9IHN0YXJ0cyB3aXRoICJcPSIsIHRoZSByZW1haW5kZXIgaXMgaW50ZXJwcmV0ZWQgYXMKCQlhbiBleHByZXNzaW9uLiBTZWUgfHN1Yi1yZXBsYWNlLWV4cHJlc3Npb258LiAgRXhhbXBsZTogPgoJCQk6ZWNobyBzdWJzdGl0dXRlKHMsICclXChceFx4XCknLAoJCQkgICBcICdcPW5yMmNoYXIoIjB4IiAuIHN1Ym1hdGNoKDEpKScsICdnJykKCnN5bklEKHtsbnVtfSwge2NvbH0sIHt0cmFuc30pCQkJCSpzeW5JRCgpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSBzeW50YXggSUQgYXQgdGhlIHBvc2l0aW9uCgkJe2xudW19IGFuZCB7Y29sfSBpbiB0aGUgY3VycmVudCB3aW5kb3cuCgkJVGhlIHN5bnRheCBJRCBjYW4gYmUgdXNlZCB3aXRoIHxzeW5JRGF0dHIoKXwgYW5kCgkJfHN5bklEdHJhbnMoKXwgdG8gb2J0YWluIHN5bnRheCBpbmZvcm1hdGlvbiBhYm91dCB0ZXh0LgoKCQl7Y29sfSBpcyAxIGZvciB0aGUgbGVmdG1vc3QgY29sdW1uLCB7bG51bX0gaXMgMSBmb3IgdGhlIGZpcnN0CgkJbGluZS4gICdzeW5tYXhjb2wnIGFwcGxpZXMsIGluIGEgbG9uZ2VyIGxpbmUgemVybyBpcyByZXR1cm5lZC4KCQlOb3RlIHRoYXQgd2hlbiB0aGUgcG9zaXRpb24gaXMgYWZ0ZXIgdGhlIGxhc3QgY2hhcmFjdGVyLAoJCXRoYXQncyB3aGVyZSB0aGUgY3Vyc29yIGNhbiBiZSBpbiBJbnNlcnQgbW9kZSwgc3luSUQoKSByZXR1cm5zCgkJemVyby4KCgkJV2hlbiB7dHJhbnN9IGlzIG5vbi16ZXJvLCB0cmFuc3BhcmVudCBpdGVtcyBhcmUgcmVkdWNlZCB0byB0aGUKCQlpdGVtIHRoYXQgdGhleSByZXZlYWwuCVRoaXMgaXMgdXNlZnVsIHdoZW4gd2FudGluZyB0byBrbm93CgkJdGhlIGVmZmVjdGl2ZSBjb2xvci4gIFdoZW4ge3RyYW5zfSBpcyB6ZXJvLCB0aGUgdHJhbnNwYXJlbnQKCQlpdGVtIGlzIHJldHVybmVkLiAgVGhpcyBpcyB1c2VmdWwgd2hlbiB3YW50aW5nIHRvIGtub3cgd2hpY2gKCQlzeW50YXggaXRlbSBpcyBlZmZlY3RpdmUgKGUuZy4gaW5zaWRlIHBhcmVucykuCgkJV2FybmluZzogVGhpcyBmdW5jdGlvbiBjYW4gYmUgdmVyeSBzbG93LiAgQmVzdCBzcGVlZCBpcwoJCW9idGFpbmVkIGJ5IGdvaW5nIHRocm91Z2ggdGhlIGZpbGUgaW4gZm9yd2FyZCBkaXJlY3Rpb24uCgoJCUV4YW1wbGUgKGVjaG9lcyB0aGUgbmFtZSBvZiB0aGUgc3ludGF4IGl0ZW0gdW5kZXIgdGhlIGN1cnNvcik6ID4KCQkJOmVjaG8gc3luSURhdHRyKHN5bklEKGxpbmUoIi4iKSwgY29sKCIuIiksIDEpLCAibmFtZSIpCjwKCnN5bklEYXR0cih7c3luSUR9LCB7d2hhdH0gWywge21vZGV9XSkJCQkqc3luSURhdHRyKCkqCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZywgd2hpY2ggaXMgdGhlIHt3aGF0fSBhdHRyaWJ1dGUgb2YKCQlzeW50YXggSUQge3N5bklEfS4gIFRoaXMgY2FuIGJlIHVzZWQgdG8gb2J0YWluIGluZm9ybWF0aW9uCgkJYWJvdXQgYSBzeW50YXggaXRlbS4KCQl7bW9kZX0gY2FuIGJlICJndWkiLCAiY3Rlcm0iIG9yICJ0ZXJtIiwgdG8gZ2V0IHRoZSBhdHRyaWJ1dGVzCgkJZm9yIHRoYXQgbW9kZS4JV2hlbiB7bW9kZX0gaXMgb21pdHRlZCwgb3IgYW4gaW52YWxpZCB2YWx1ZSBpcwoJCXVzZWQsIHRoZSBhdHRyaWJ1dGVzIGZvciB0aGUgY3VycmVudGx5IGFjdGl2ZSBoaWdobGlnaHRpbmcgYXJlCgkJdXNlZCAoR1VJLCBjdGVybSBvciB0ZXJtKS4KCQlVc2Ugc3luSUR0cmFucygpIHRvIGZvbGxvdyBsaW5rZWQgaGlnaGxpZ2h0IGdyb3Vwcy4KCQl7d2hhdH0JCXJlc3VsdAoJCSJuYW1lIgkJdGhlIG5hbWUgb2YgdGhlIHN5bnRheCBpdGVtCgkJImZnIgkJZm9yZWdyb3VuZCBjb2xvciAoR1VJOiBjb2xvciBuYW1lIHVzZWQgdG8gc2V0CgkJCQl0aGUgY29sb3IsIGN0ZXJtOiBjb2xvciBudW1iZXIgYXMgYSBzdHJpbmcsCgkJCQl0ZXJtOiBlbXB0eSBzdHJpbmcpCgkJImJnIgkJYmFja2dyb3VuZCBjb2xvciAoYXMgd2l0aCAiZmciKQoJCSJmb250IgkJZm9udCBuYW1lIChvbmx5IGF2YWlsYWJsZSBpbiB0aGUgR1VJKQoJCQkJfGhpZ2hsaWdodC1mb250fAoJCSJzcCIJCXNwZWNpYWwgY29sb3IgKGFzIHdpdGggImZnIikgfGhpZ2hsaWdodC1ndWlzcHwKCQkiZmcjIgkJbGlrZSAiZmciLCBidXQgZm9yIHRoZSBHVUkgYW5kIHRoZSBHVUkgaXMKCQkJCXJ1bm5pbmcgdGhlIG5hbWUgaW4gIiNSUkdHQkIiIGZvcm0KCQkiYmcjIgkJbGlrZSAiZmcjIiBmb3IgImJnIgoJCSJzcCMiCQlsaWtlICJmZyMiIGZvciAic3AiCgkJImJvbGQiCQkiMSIgaWYgYm9sZAoJCSJpdGFsaWMiCSIxIiBpZiBpdGFsaWMKCQkicmV2ZXJzZSIJIjEiIGlmIHJldmVyc2UKCQkiaW52ZXJzZSIJIjEiIGlmIGludmVyc2UgKD0gcmV2ZXJzZSkKCQkic3RhbmRvdXQiCSIxIiBpZiBzdGFuZG91dAoJCSJ1bmRlcmxpbmUiCSIxIiBpZiB1bmRlcmxpbmVkCgkJInVuZGVyY3VybCIJIjEiIGlmIHVuZGVyY3VybGVkCgoJCUV4YW1wbGUgKGVjaG9lcyB0aGUgY29sb3Igb2YgdGhlIHN5bnRheCBpdGVtIHVuZGVyIHRoZQoJCWN1cnNvcik6ID4KCTplY2hvIHN5bklEYXR0cihzeW5JRHRyYW5zKHN5bklEKGxpbmUoIi4iKSwgY29sKCIuIiksIDEpKSwgImZnIikKPApzeW5JRHRyYW5zKHtzeW5JRH0pCQkJCQkqc3luSUR0cmFucygpKgoJCVRoZSByZXN1bHQgaXMgYSBOdW1iZXIsIHdoaWNoIGlzIHRoZSB0cmFuc2xhdGVkIHN5bnRheCBJRCBvZgoJCXtzeW5JRH0uICBUaGlzIGlzIHRoZSBzeW50YXggZ3JvdXAgSUQgb2Ygd2hhdCBpcyBiZWluZyB1c2VkIHRvCgkJaGlnaGxpZ2h0IHRoZSBjaGFyYWN0ZXIuICBIaWdobGlnaHQgbGlua3MgZ2l2ZW4gd2l0aAoJCSI6aGlnaGxpZ2h0IGxpbmsiIGFyZSBmb2xsb3dlZC4KCnN5bmNvbmNlYWxlZCh7bG51bX0sIHtjb2x9KQkJCQkqc3luY29uY2VhbGVkKCkqCgkJVGhlIHJlc3VsdCBpcyBhIExpc3QuIFRoZSBmaXJzdCBpdGVtIGluIHRoZSBsaXN0IGlzIDAgaWYgdGhlCgkJY2hhcmFjdGVyIGF0IHRoZSBwb3NpdGlvbiB7bG51bX0gYW5kIHtjb2x9IGlzIG5vdCBwYXJ0IG9mIGEKCQljb25jZWFsYWJsZSByZWdpb24sIDEgaWYgaXQgaXMuIFRoZSBzZWNvbmQgaXRlbSBpbiB0aGUgbGlzdCBpcwoJCWEgc3RyaW5nLiBJZiB0aGUgZmlyc3QgaXRlbSBpcyAxLCB0aGUgc2Vjb25kIGl0ZW0gY29udGFpbnMgdGhlCgkJdGV4dCB3aGljaCB3aWxsIGJlIGRpc3BsYXllZCBpbiBwbGFjZSBvZiB0aGUgY29uY2VhbGVkIHRleHQsCgkJZGVwZW5kaW5nIG9uIHRoZSBjdXJyZW50IHNldHRpbmcgb2YgJ2NvbmNlYWxsZXZlbCcuIFRoZSB0aGlyZAoJCWFuZCBmaW5hbCBpdGVtIGluIHRoZSBsaXN0IGlzIGEgdW5pcXVlIG51bWJlciByZXByZXNlbnRpbmcgdGhlCgkJc3BlY2lmaWMgc3ludGF4IHJlZ2lvbiBtYXRjaGVkLiBUaGlzIGFsbG93cyBkZXRlY3Rpb24gb2YgdGhlCgkJYmVnaW5uaW5nIG9mIGEgbmV3IGNvbmNlYWxhYmxlIHJlZ2lvbiBpZiB0aGVyZSBhcmUgdHdvCgkJY29uc2VjdXRpdmUgcmVnaW9ucyB3aXRoIHRoZSBzYW1lIHJlcGxhY2VtZW50IGNoYXJhY3Rlci4KCQlGb3IgYW4gZXhhbXBsZSB1c2Ugc2VlICRWSU1SVU5USU1FL3N5bnRheC8yaHRtbC52aW0gLgoKCnN5bnN0YWNrKHtsbnVtfSwge2NvbH0pCQkJCQkqc3luc3RhY2soKSoKCQlSZXR1cm4gYSB8TGlzdHwsIHdoaWNoIGlzIHRoZSBzdGFjayBvZiBzeW50YXggaXRlbXMgYXQgdGhlCgkJcG9zaXRpb24ge2xudW19IGFuZCB7Y29sfSBpbiB0aGUgY3VycmVudCB3aW5kb3cuICBFYWNoIGl0ZW0gaW4KCQl0aGUgTGlzdCBpcyBhbiBJRCBsaWtlIHdoYXQgfHN5bklEKCl8IHJldHVybnMuCgkJVGhlIGZpcnN0IGl0ZW0gaW4gdGhlIExpc3QgaXMgdGhlIG91dGVyIHJlZ2lvbiwgZm9sbG93aW5nIGFyZQoJCWl0ZW1zIGNvbnRhaW5lZCBpbiB0aGF0IG9uZS4gIFRoZSBsYXN0IG9uZSBpcyB3aGF0IHxzeW5JRCgpfAoJCXJldHVybnMsIHVubGVzcyBub3QgdGhlIHdob2xlIGl0ZW0gaXMgaGlnaGxpZ2h0ZWQgb3IgaXQgaXMgYQoJCXRyYW5zcGFyZW50IGl0ZW0uCgkJVGhpcyBmdW5jdGlvbiBpcyB1c2VmdWwgZm9yIGRlYnVnZ2luZyBhIHN5bnRheCBmaWxlLgoJCUV4YW1wbGUgdGhhdCBzaG93cyB0aGUgc3ludGF4IHN0YWNrIHVuZGVyIHRoZSBjdXJzb3I6ID4KCQkJZm9yIGlkIGluIHN5bnN0YWNrKGxpbmUoIi4iKSwgY29sKCIuIikpCgkJCSAgIGVjaG8gc3luSURhdHRyKGlkLCAibmFtZSIpCgkJCWVuZGZvcgo8CQlXaGVuIHRoZSBwb3NpdGlvbiBzcGVjaWZpZWQgd2l0aCB7bG51bX0gYW5kIHtjb2x9IGlzIGludmFsaWQKCQlub3RoaW5nIGlzIHJldHVybmVkLiAgVGhlIHBvc2l0aW9uIGp1c3QgYWZ0ZXIgdGhlIGxhc3QKCQljaGFyYWN0ZXIgaW4gYSBsaW5lIGFuZCB0aGUgZmlyc3QgY29sdW1uIGluIGFuIGVtcHR5IGxpbmUgYXJlCgkJdmFsaWQgcG9zaXRpb25zLgoKc3lzdGVtKHtleHByfSBbLCB7aW5wdXR9XSkJCQkJKnN5c3RlbSgpKiAqRTY3NyoKCQlHZXQgdGhlIG91dHB1dCBvZiB0aGUgc2hlbGwgY29tbWFuZCB7ZXhwcn0gYXMgYSBzdHJpbmcuICBTZWUKCQl8c3lzdGVtbGlzdCgpfCB0byBnZXQgdGhlIG91dHB1dCBhcyBhIExpc3QuCgoJCVdoZW4ge2lucHV0fSBpcyBnaXZlbiBhbmQgaXMgYSBzdHJpbmcgdGhpcyBzdHJpbmcgaXMgd3JpdHRlbiAKCQl0byBhIGZpbGUgYW5kIHBhc3NlZCBhcyBzdGRpbiB0byB0aGUgY29tbWFuZC4gIFRoZSBzdHJpbmcgaXMgCgkJd3JpdHRlbiBhcy1pcywgeW91IG5lZWQgdG8gdGFrZSBjYXJlIG9mIHVzaW5nIHRoZSBjb3JyZWN0IGxpbmUgCgkJc2VwYXJhdG9ycyB5b3Vyc2VsZi4KCQlJZiB7aW5wdXR9IGlzIGdpdmVuIGFuZCBpcyBhIHxMaXN0fCBpdCBpcyB3cml0dGVuIHRvIHRoZSBmaWxlCgkJaW4gYSB3YXkgfHdyaXRlZmlsZSgpfCBkb2VzIHdpdGgge2JpbmFyeX0gc2V0IHRvICJiIiAoaS5lLgoJCXdpdGggYSBuZXdsaW5lIGJldHdlZW4gZWFjaCBsaXN0IGl0ZW0gd2l0aCBuZXdsaW5lcyBpbnNpZGUKCQlsaXN0IGl0ZW1zIGNvbnZlcnRlZCB0byBOVUxzKS4gIAoJCVBpcGVzIGFyZSBub3QgdXNlZC4KCgkJV2hlbiBwcmVwZW5kZWQgYnkgfDpzaWxlbnR8IHRoZSBzaGVsbCB3aWxsIG5vdCBiZSBzZXQgdG8KCQljb29rZWQgbW9kZS4gIFRoaXMgaXMgbWVhbnQgdG8gYmUgdXNlZCBmb3IgY29tbWFuZHMgdGhhdCBkbwoJCW5vdCBuZWVkIHRoZSB1c2VyIHRvIHR5cGUuICBJdCBhdm9pZHMgc3RyYXkgY2hhcmFjdGVycyBzaG93aW5nCgkJdXAgb24gdGhlIHNjcmVlbiB3aGljaCByZXF1aXJlIHxDVFJMLUx8IHRvIHJlbW92ZS4gPgoJCQk6c2lsZW50IGxldCBmID0gc3lzdGVtKCdscyAqLnZpbScpCjwKCQlOb3RlOiBVc2UgfHNoZWxsZXNjYXBlKCl8IG9yIHw6OlN8IHdpdGggfGV4cGFuZCgpfCBvciAKCQl8Zm5hbWVtb2RpZnkoKXwgdG8gZXNjYXBlIHNwZWNpYWwgY2hhcmFjdGVycyBpbiBhIGNvbW1hbmQgCgkJYXJndW1lbnQuICBOZXdsaW5lcyBpbiB7ZXhwcn0gbWF5IGNhdXNlIHRoZSBjb21tYW5kIHRvIGZhaWwuICAKCQlUaGUgY2hhcmFjdGVycyBpbiAnc2hlbGxxdW90ZScgYW5kICdzaGVsbHhxdW90ZScgbWF5IGFsc28gCgkJY2F1c2UgdHJvdWJsZS4KCQlUaGlzIGlzIG5vdCB0byBiZSB1c2VkIGZvciBpbnRlcmFjdGl2ZSBjb21tYW5kcy4KCgkJVGhlIHJlc3VsdCBpcyBhIFN0cmluZy4gIEV4YW1wbGU6ID4KCQkgICAgOmxldCBmaWxlcyA9IHN5c3RlbSgibHMgIiAuICBzaGVsbGVzY2FwZShleHBhbmQoJyU6aCcpKSkKCQkgICAgOmxldCBmaWxlcyA9IHN5c3RlbSgnbHMgJyAuIGV4cGFuZCgnJTpoOlMnKSkKCjwJCVRvIG1ha2UgdGhlIHJlc3VsdCBtb3JlIHN5c3RlbS1pbmRlcGVuZGVudCwgdGhlIHNoZWxsIG91dHB1dAoJCWlzIGZpbHRlcmVkIHRvIHJlcGxhY2UgPENSPiB3aXRoIDxOTD4gZm9yIE1hY2ludG9zaCwgYW5kCgkJPENSPjxOTD4gd2l0aCA8Tkw+IGZvciBET1MtbGlrZSBzeXN0ZW1zLgoJCVRvIGF2b2lkIHRoZSBzdHJpbmcgYmVpbmcgdHJ1bmNhdGVkIGF0IGEgTlVMLCBhbGwgTlVMCgkJY2hhcmFjdGVycyBhcmUgcmVwbGFjZWQgd2l0aCBTT0ggKDB4MDEpLgoKCQlUaGUgY29tbWFuZCBleGVjdXRlZCBpcyBjb25zdHJ1Y3RlZCB1c2luZyBzZXZlcmFsIG9wdGlvbnM6Cgknc2hlbGwnICdzaGVsbGNtZGZsYWcnICdzaGVsbHhxdW90ZScge2V4cHJ9ICdzaGVsbHJlZGlyJyB7dG1wfSAnc2hlbGx4cXVvdGUnCgkJKHt0bXB9IGlzIGFuIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZpbGUgbmFtZSkuCgkJRm9yIFVuaXggYW5kIE9TLzIgYnJhY2VzIGFyZSBwdXQgYXJvdW5kIHtleHByfSB0byBhbGxvdyBmb3IKCQljb25jYXRlbmF0ZWQgY29tbWFuZHMuCgoJCVRoZSBjb21tYW5kIHdpbGwgYmUgZXhlY3V0ZWQgaW4gImNvb2tlZCIgbW9kZSwgc28gdGhhdCBhCgkJQ1RSTC1DIHdpbGwgaW50ZXJydXB0IHRoZSBjb21tYW5kIChvbiBVbml4IGF0IGxlYXN0KS4KCgkJVGhlIHJlc3VsdGluZyBlcnJvciBjb2RlIGNhbiBiZSBmb3VuZCBpbiB8djpzaGVsbF9lcnJvcnwuCgkJVGhpcyBmdW5jdGlvbiB3aWxsIGZhaWwgaW4gfHJlc3RyaWN0ZWQtbW9kZXwuCgoJCU5vdGUgdGhhdCBhbnkgd3JvbmcgdmFsdWUgaW4gdGhlIG9wdGlvbnMgbWVudGlvbmVkIGFib3ZlIG1heQoJCW1ha2UgdGhlIGZ1bmN0aW9uIGZhaWwuICBJdCBoYXMgYWxzbyBiZWVuIHJlcG9ydGVkIHRvIGZhaWwKCQl3aGVuIHVzaW5nIGEgc2VjdXJpdHkgYWdlbnQgYXBwbGljYXRpb24uCgkJVW5saWtlICI6IWNtZCIgdGhlcmUgaXMgbm8gYXV0b21hdGljIGNoZWNrIGZvciBjaGFuZ2VkIGZpbGVzLgoJCVVzZSB8OmNoZWNrdGltZXwgdG8gZm9yY2UgYSBjaGVjay4KCgpzeXN0ZW1saXN0KHtleHByfSBbLCB7aW5wdXR9XSkJCQkJKnN5c3RlbWxpc3QoKSoKCQlTYW1lIGFzIHxzeXN0ZW0oKXwsIGJ1dCByZXR1cm5zIGEgfExpc3R8IHdpdGggbGluZXMgKHBhcnRzIG9mIAoJCW91dHB1dCBzZXBhcmF0ZWQgYnkgTkwpIHdpdGggTlVMcyB0cmFuc2Zvcm1lZCBpbnRvIE5Mcy4gT3V0cHV0IAoJCWlzIHRoZSBzYW1lIGFzIHxyZWFkZmlsZSgpfCB3aWxsIG91dHB1dCB3aXRoIHtiaW5hcnl9IGFyZ3VtZW50IAoJCXNldCB0byAiYiIuCgoJCVJldHVybnMgYW4gZW1wdHkgc3RyaW5nIG9uIGVycm9yLgoKCnRhYnBhZ2VidWZsaXN0KFt7YXJnfV0pCQkJCQkqdGFicGFnZWJ1Zmxpc3QoKSoKCQlUaGUgcmVzdWx0IGlzIGEgfExpc3R8LCB3aGVyZSBlYWNoIGl0ZW0gaXMgdGhlIG51bWJlciBvZiB0aGUKCQlidWZmZXIgYXNzb2NpYXRlZCB3aXRoIGVhY2ggd2luZG93IGluIHRoZSBjdXJyZW50IHRhYiBwYWdlLgoJCXthcmd9IHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIHRhYiBwYWdlIHRvIGJlIHVzZWQuICBXaGVuCgkJb21pdHRlZCB0aGUgY3VycmVudCB0YWIgcGFnZSBpcyB1c2VkLgoJCVdoZW4ge2FyZ30gaXMgaW52YWxpZCB0aGUgbnVtYmVyIHplcm8gaXMgcmV0dXJuZWQuCgkJVG8gZ2V0IGEgbGlzdCBvZiBhbGwgYnVmZmVycyBpbiBhbGwgdGFicyB1c2UgdGhpczogPgoJCQlsZXQgYnVmbGlzdCA9IFtdCgkJCWZvciBpIGluIHJhbmdlKHRhYnBhZ2VucignJCcpKQoJCQkgICBjYWxsIGV4dGVuZChidWZsaXN0LCB0YWJwYWdlYnVmbGlzdChpICsgMSkpCgkJCWVuZGZvcgo8CQlOb3RlIHRoYXQgYSBidWZmZXIgbWF5IGFwcGVhciBpbiBtb3JlIHRoYW4gb25lIHdpbmRvdy4KCgp0YWJwYWdlbnIoW3thcmd9XSkJCQkJCSp0YWJwYWdlbnIoKSoKCQlUaGUgcmVzdWx0IGlzIGEgTnVtYmVyLCB3aGljaCBpcyB0aGUgbnVtYmVyIG9mIHRoZSBjdXJyZW50CgkJdGFiIHBhZ2UuICBUaGUgZmlyc3QgdGFiIHBhZ2UgaGFzIG51bWJlciAxLgoJCVdoZW4gdGhlIG9wdGlvbmFsIGFyZ3VtZW50IGlzICIkIiwgdGhlIG51bWJlciBvZiB0aGUgbGFzdCB0YWIKCQlwYWdlIGlzIHJldHVybmVkICh0aGUgdGFiIHBhZ2UgY291bnQpLgoJCVRoZSBudW1iZXIgY2FuIGJlIHVzZWQgd2l0aCB0aGUgfDp0YWJ8IGNvbW1hbmQuCgoKdGFicGFnZXdpbm5yKHt0YWJhcmd9IFssIHthcmd9XSkJCQkqdGFicGFnZXdpbm5yKCkqCgkJTGlrZSB8d2lubnIoKXwgYnV0IGZvciB0YWIgcGFnZSB7dGFiYXJnfS4KCQl7dGFiYXJnfSBzcGVjaWZpZXMgdGhlIG51bWJlciBvZiB0YWIgcGFnZSB0byBiZSB1c2VkLgoJCXthcmd9IGlzIHVzZWQgbGlrZSB3aXRoIHx3aW5ucigpfDoKCQktIFdoZW4gb21pdHRlZCB0aGUgY3VycmVudCB3aW5kb3cgbnVtYmVyIGlzIHJldHVybmVkLiAgVGhpcyBpcwoJCSAgdGhlIHdpbmRvdyB3aGljaCB3aWxsIGJlIHVzZWQgd2hlbiBnb2luZyB0byB0aGlzIHRhYiBwYWdlLgoJCS0gV2hlbiAiJCIgdGhlIG51bWJlciBvZiB3aW5kb3dzIGlzIHJldHVybmVkLgoJCS0gV2hlbiAiIyIgdGhlIHByZXZpb3VzIHdpbmRvdyBuciBpcyByZXR1cm5lZC4KCQlVc2VmdWwgZXhhbXBsZXM6ID4KCQkgICAgdGFicGFnZXdpbm5yKDEpCSAgICAiIGN1cnJlbnQgd2luZG93IG9mIHRhYiBwYWdlIDEKCQkgICAgdGFicGFnZXdpbm5yKDQsICckJykgICAgIiBudW1iZXIgb2Ygd2luZG93cyBpbiB0YWIgcGFnZSA0CjwJCVdoZW4ge3RhYmFyZ30gaXMgaW52YWxpZCB6ZXJvIGlzIHJldHVybmVkLgoKCQkJCQkJCSp0YWdmaWxlcygpKgp0YWdmaWxlcygpCVJldHVybnMgYSB8TGlzdHwgd2l0aCB0aGUgZmlsZSBuYW1lcyB1c2VkIHRvIHNlYXJjaCBmb3IgdGFncwoJCWZvciB0aGUgY3VycmVudCBidWZmZXIuICBUaGlzIGlzIHRoZSAndGFncycgb3B0aW9uIGV4cGFuZGVkLgoKCnRhZ2xpc3Qoe2V4cHJ9KQkJCQkJCQkqdGFnbGlzdCgpKgoJCVJldHVybnMgYSBsaXN0IG9mIHRhZ3MgbWF0Y2hpbmcgdGhlIHJlZ3VsYXIgZXhwcmVzc2lvbiB7ZXhwcn0uCgkJRWFjaCBsaXN0IGl0ZW0gaXMgYSBkaWN0aW9uYXJ5IHdpdGggYXQgbGVhc3QgdGhlIGZvbGxvd2luZwoJCWVudHJpZXM6CgkJCW5hbWUJCU5hbWUgb2YgdGhlIHRhZy4KCQkJZmlsZW5hbWUJTmFtZSBvZiB0aGUgZmlsZSB3aGVyZSB0aGUgdGFnIGlzCgkJCQkJZGVmaW5lZC4gIEl0IGlzIGVpdGhlciByZWxhdGl2ZSB0byB0aGUKCQkJCQljdXJyZW50IGRpcmVjdG9yeSBvciBhIGZ1bGwgcGF0aC4KCQkJY21kCQlFeCBjb21tYW5kIHVzZWQgdG8gbG9jYXRlIHRoZSB0YWcgaW4KCQkJCQl0aGUgZmlsZS4KCQkJa2luZAkJVHlwZSBvZiB0aGUgdGFnLiAgVGhlIHZhbHVlIGZvciB0aGlzCgkJCQkJZW50cnkgZGVwZW5kcyBvbiB0aGUgbGFuZ3VhZ2Ugc3BlY2lmaWMKCQkJCQlraW5kIHZhbHVlcy4gIE9ubHkgYXZhaWxhYmxlIHdoZW4KCQkJCQl1c2luZyBhIHRhZ3MgZmlsZSBnZW5lcmF0ZWQgYnkKCQkJCQlFeHViZXJhbnQgY3RhZ3Mgb3IgaGRydGFnLgoJCQlzdGF0aWMJCUEgZmlsZSBzcGVjaWZpYyB0YWcuICBSZWZlciB0bwoJCQkJCXxzdGF0aWMtdGFnfCBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KCQlNb3JlIGVudHJpZXMgbWF5IGJlIHByZXNlbnQsIGRlcGVuZGluZyBvbiB0aGUgY29udGVudCBvZiB0aGUKCQl0YWdzIGZpbGU6IGFjY2VzcywgaW1wbGVtZW50YXRpb24sIGluaGVyaXRzIGFuZCBzaWduYXR1cmUuCgkJUmVmZXIgdG8gdGhlIGN0YWdzIGRvY3VtZW50YXRpb24gZm9yIGluZm9ybWF0aW9uIGFib3V0IHRoZXNlCgkJZmllbGRzLiAgRm9yIEMgY29kZSB0aGUgZmllbGRzICJzdHJ1Y3QiLCAiY2xhc3MiIGFuZCAiZW51bSIKCQltYXkgYXBwZWFyLCB0aGV5IGdpdmUgdGhlIG5hbWUgb2YgdGhlIGVudGl0eSB0aGUgdGFnIGlzCgkJY29udGFpbmVkIGluLgoKCQlUaGUgZXgtY29tbWFuZCAnY21kJyBjYW4gYmUgZWl0aGVyIGFuIGV4IHNlYXJjaCBwYXR0ZXJuLCBhCgkJbGluZSBudW1iZXIgb3IgYSBsaW5lIG51bWJlciBmb2xsb3dlZCBieSBhIGJ5dGUgbnVtYmVyLgoKCQlJZiB0aGVyZSBhcmUgbm8gbWF0Y2hpbmcgdGFncywgdGhlbiBhbiBlbXB0eSBsaXN0IGlzIHJldHVybmVkLgoKCQlUbyBnZXQgYW4gZXhhY3QgdGFnIG1hdGNoLCB0aGUgYW5jaG9ycyAnXicgYW5kICckJyBzaG91bGQgYmUKCQl1c2VkIGluIHtleHByfS4gIFRoaXMgYWxzbyBtYWtlIHRoZSBmdW5jdGlvbiB3b3JrIGZhc3Rlci4KCQlSZWZlciB0byB8dGFnLXJlZ2V4cHwgZm9yIG1vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHRhZwoJCXNlYXJjaCByZWd1bGFyIGV4cHJlc3Npb24gcGF0dGVybi4KCgkJUmVmZXIgdG8gfCd0YWdzJ3wgZm9yIGluZm9ybWF0aW9uIGFib3V0IGhvdyB0aGUgdGFncyBmaWxlIGlzCgkJbG9jYXRlZCBieSBWaW0uIFJlZmVyIHRvIHx0YWdzLWZpbGUtZm9ybWF0fCBmb3IgdGhlIGZvcm1hdCBvZgoJCXRoZSB0YWdzIGZpbGUgZ2VuZXJhdGVkIGJ5IHRoZSBkaWZmZXJlbnQgY3RhZ3MgdG9vbHMuCgp0ZW1wbmFtZSgpCQkJCQkqdGVtcG5hbWUoKSogKnRlbXAtZmlsZS1uYW1lKgoJCVRoZSByZXN1bHQgaXMgYSBTdHJpbmcsIHdoaWNoIGlzIHRoZSBuYW1lIG9mIGEgZmlsZSB0aGF0CgkJZG9lc24ndCBleGlzdC4JSXQgY2FuIGJlIHVzZWQgZm9yIGEgdGVtcG9yYXJ5IGZpbGUuICBUaGUgbmFtZQoJCWlzIGRpZmZlcmVudCBmb3IgYXQgbGVhc3QgMjYgY29uc2VjdXRpdmUgY2FsbHMuICBFeGFtcGxlOiA+CgkJCTpsZXQgdG1wZmlsZSA9IHRlbXBuYW1lKCkKCQkJOmV4ZSAicmVkaXIgPiAiIC4gdG1wZmlsZQo8CQlGb3IgVW5peCwgdGhlIGZpbGUgd2lsbCBiZSBpbiBhIHByaXZhdGUgZGlyZWN0b3J5IHx0ZW1wZmlsZXwuCgkJRm9yIE1TLVdpbmRvd3MgZm9yd2FyZCBzbGFzaGVzIGFyZSB1c2VkIHdoZW4gdGhlICdzaGVsbHNsYXNoJwoJCW9wdGlvbiBpcyBzZXQgb3Igd2hlbiAnc2hlbGxjbWRmbGFnJyBzdGFydHMgd2l0aCAnLScuCgoKdGFuKHtleHByfSkJCQkJCQkqdGFuKCkqCgkJUmV0dXJuIHRoZSB0YW5nZW50IG9mIHtleHByfSwgbWVhc3VyZWQgaW4gcmFkaWFucywgYXMgYSB8RmxvYXR8CgkJaW4gdGhlIHJhbmdlIFstaW5mLCBpbmZdLgoJCXtleHByfSBtdXN0IGV2YWx1YXRlIHRvIGEgfEZsb2F0fCBvciBhIHxOdW1iZXJ8LgoJCUV4YW1wbGVzOiA+CgkJCTplY2hvIHRhbigxMCkKPAkJCTAuNjQ4MzYxID4KCQkJOmVjaG8gdGFuKC00LjAxKQo8CQkJLTEuMTgxNTAyCgkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtmbG9hdHwgZmVhdHVyZX0KCgp0YW5oKHtleHByfSkJCQkJCQkqdGFuaCgpKgoJCVJldHVybiB0aGUgaHlwZXJib2xpYyB0YW5nZW50IG9mIHtleHByfSBhcyBhIHxGbG9hdHwgaW4gdGhlCgkJcmFuZ2UgWy0xLCAxXS4KCQl7ZXhwcn0gbXVzdCBldmFsdWF0ZSB0byBhIHxGbG9hdHwgb3IgYSB8TnVtYmVyfC4KCQlFeGFtcGxlczogPgoJCQk6ZWNobyB0YW5oKDAuNSkKPAkJCTAuNDYyMTE3ID4KCQkJOmVjaG8gdGFuaCgtMSkKPAkJCS0wLjc2MTU5NAoJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmxvYXR8IGZlYXR1cmV9CgoKCQkJCQkJCSp0aW1lcl9zdGFydCgpKgp0aW1lcl9zdGFydCh7dGltZX0sIHtjYWxsYmFja30gWywge29wdGlvbnN9XSkKCQlDcmVhdGUgYSB0aW1lciBhbmQgcmV0dXJuIHRoZSB0aW1lciBJRC4KCgkJe3RpbWV9IGlzIHRoZSB3YWl0aW5nIHRpbWUgaW4gbWlsbGlzZWNvbmRzLiBUaGlzIGlzIHRoZQoJCW1pbmltdW0gdGltZSBiZWZvcmUgaW52b2tpbmcgdGhlIGNhbGxiYWNrLiAgV2hlbiB0aGUgc3lzdGVtIGlzCgkJYnVzeSBvciBWaW0gaXMgbm90IHdhaXRpbmcgZm9yIGlucHV0IHRoZSB0aW1lIHdpbGwgYmUgbG9uZ2VyLgoKCQl7Y2FsbGJhY2t9IGlzIHRoZSBmdW5jdGlvbiB0byBjYWxsLiAgSXQgY2FuIGJlIHRoZSBuYW1lIG9mIGEKCQlmdW5jdGlvbiBvciBhIEZ1bmNyZWYuICBJdCBpcyBjYWxsZWQgd2l0aCBvbmUgYXJndW1lbnQsIHdoaWNoCgkJaXMgdGhlIHRpbWVyIElELiAgVGhlIGNhbGxiYWNrIGlzIG9ubHkgaW52b2tlZCB3aGVuIFZpbSBpcwoJCXdhaXRpbmcgZm9yIGlucHV0LgoKCQl7b3B0aW9uc30gaXMgYSBkaWN0aW9uYXJ5LiAgU3VwcG9ydGVkIGVudHJpZXM6CgkJICAgInJlcGVhdCIJTnVtYmVyIG9mIHRpbWVzIHRvIHJlcGVhdCBjYWxsaW5nIHRoZQoJCQkJY2FsbGJhY2suICAtMSBtZWFucyBmb3JldmVyLgoKCQlFeGFtcGxlOiA+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=