LyoKICAgVGVzdCBwcm9ncmFtIGZvciBUaW55WE1MLgoqLwoKCiNpbmNsdWRlICJ0aW55eG1sLmgiCgojaWZkZWYgVElYTUxfVVNFX1NUTAoJI2luY2x1ZGUgPGlvc3RyZWFtPgoJI2luY2x1ZGUgPHNzdHJlYW0+Cgl1c2luZyBuYW1lc3BhY2Ugc3RkOwojZWxzZQoJI2luY2x1ZGUgPHN0ZGlvLmg+CiNlbmRpZgoKI2lmIGRlZmluZWQoIFdJTjMyICkgJiYgZGVmaW5lZCggVFVORSApCgkjaW5jbHVkZSA8d2luZG93cy5oPgoJLy8gQXBvbG9naWVzIHRvIG5vbi13aW5kb3dzIHVzZXJzISBCdXQgSSBuZWVkIHNvbWUgZ29vZCB0aW1lcnMgZm9yCgkvLyBwcm9maWxpbmcsIGFuZCB0aGVzZSBhcmUgdmVyeSBwbGF0Zm9ybSBzcGVjaWZpYy4KCV9faW50NjQgc3RhcnQ7CglfX2ludDY0IGVuZDsKCV9faW50NjQgZnJlcTsKI2VuZGlmCgpzdGF0aWMgaW50IGdQYXNzID0gMDsKc3RhdGljIGludCBnRmFpbCA9IDA7CgoKYm9vbCBYbWxUZXN0IChjb25zdCBjaGFyKiB0ZXN0U3RyaW5nLCBjb25zdCBjaGFyKiBleHBlY3RlZCwgY29uc3QgY2hhciogZm91bmQsIGJvb2wgbm9FY2hvID0gZmFsc2UpCnsKCWJvb2wgcGFzcyA9ICFzdHJjbXAoIGV4cGVjdGVkLCBmb3VuZCApOwoJaWYgKCBwYXNzICkKCQlwcmludGYgKCJbcGFzc10iKTsKCWVsc2UKCQlwcmludGYgKCJbZmFpbF0iKTsKCglpZiAoIG5vRWNobyApCgkJcHJpbnRmICgiICVzXG4iLCB0ZXN0U3RyaW5nKTsKCWVsc2UKCQlwcmludGYgKCIgJXMgWyVzXVslc11cbiIsIHRlc3RTdHJpbmcsIGV4cGVjdGVkLCBmb3VuZCk7CgoJaWYgKCBwYXNzICkKCQkrK2dQYXNzOwoJZWxzZQoJCSsrZ0ZhaWw7CglyZXR1cm4gcGFzczsKfQoKCmJvb2wgWG1sVGVzdCggY29uc3QgY2hhciogdGVzdFN0cmluZywgaW50IGV4cGVjdGVkLCBpbnQgZm91bmQsIGJvb2wgbm9FY2hvID0gZmFsc2UgKQp7Cglib29sIHBhc3MgPSAoIGV4cGVjdGVkID09IGZvdW5kICk7CglpZiAoIHBhc3MgKQoJCXByaW50ZiAoIltwYXNzXSIpOwoJZWxzZQoJCXByaW50ZiAoIltmYWlsXSIpOwoKCWlmICggbm9FY2hvICkKCQlwcmludGYgKCIgJXNcbiIsIHRlc3RTdHJpbmcpOwoJZWxzZQoJCXByaW50ZiAoIiAlcyBbJWRdWyVkXVxuIiwgdGVzdFN0cmluZywgZXhwZWN0ZWQsIGZvdW5kKTsKCglpZiAoIHBhc3MgKQoJCSsrZ1Bhc3M7CgllbHNlCgkJKytnRmFpbDsKCXJldHVybiBwYXNzOwp9CgoKLy8KLy8gVGhpcyBmaWxlIGRlbW9uc3RyYXRlcyBzb21lIGJhc2ljIGZ1bmN0aW9uYWxpdHkgb2YgVGlueVhtbC4KLy8gTm90ZSB0aGF0IHRoZSBleGFtcGxlIGlzIHZlcnkgY29udHJpdmVkLiBJdCBwcmVzdW1lcyB5b3Uga25vdwovLyB3aGF0IGlzIGluIHRoZSBYTUwgZmlsZS4gQnV0IGl0IGRvZXMgdGVzdCB0aGUgYmFzaWMgb3BlcmF0aW9ucywKLy8gYW5kIHNob3cgaG93IHRvIGFkZCBhbmQgcmVtb3ZlIG5vZGVzLgovLwoKaW50IG1haW4oKQp7CgkvLwoJLy8gV2Ugc3RhcnQgd2l0aCB0aGUgJ2RlbW9TdGFydCcgdG9kbyBsaXN0LiBQcm9jZXNzIGl0LiBBbmQKCS8vIHNob3VsZCBob3BlZnVsbHkgZW5kIHVwIHdpdGggdGhlIHRvZG8gbGlzdCBhcyBpbGx1c3RyYXRlZC4KCS8vCgljb25zdCBjaGFyKiBkZW1vU3RhcnQgPQoJCSI8P3htbCB2ZXJzaW9uPVwiMS4wXCIgIHN0YW5kYWxvbmU9J25vJyA+XG4iCgkJIjwhLS0gT3VyIHRvIGRvIGxpc3QgZGF0YSAtLT4iCgkJIjxUb0RvPlxuIgoJCSI8IS0tIERvIEkgbmVlZCBhIHNlY3VyZSBQREE/IC0tPlxuIgoJCSI8SXRlbSBwcmlvcml0eT1cIjFcIiBkaXN0YW5jZT0nY2xvc2UnPiBHbyB0byB0aGUgPGJvbGQ+VG95IHN0b3JlITwvYm9sZD48L0l0ZW0+IgoJCSI8SXRlbSBwcmlvcml0eT1cIjJcIiBkaXN0YW5jZT0nbm9uZSc+IERvIGJpbGxzICAgPC9JdGVtPiIKCQkiPEl0ZW0gcHJpb3JpdHk9XCIyXCIgZGlzdGFuY2U9J2ZhciAmYW1wOyBiYWNrJz4gTG9vayBmb3IgRXZpbCBEaW5vc2F1cnMhIDwvSXRlbT4iCgkJIjwvVG9Ebz4iOwoKI2lmZGVmIFRJWE1MX1VTRV9TVEwKCS8qCVdoYXQgdGhlIHRvZG8gbGlzdCBzaG91bGQgbG9vayBsaWtlIGFmdGVyIHByb2Nlc3NpbmcuCgkJSW4gc3RyZWFtIChubyBmb3JtYXR0aW5nKSByZXByZXNlbnRhdGlvbi4gKi8KCWNvbnN0IGNoYXIqIGRlbW9FbmQgPQoJCSI8P3htbCB2ZXJzaW9uPVwiMS4wXCIgc3RhbmRhbG9uZT1cIm5vXCIgPz4iCgkJIjwhLS0gT3VyIHRvIGRvIGxpc3QgZGF0YSAtLT4iCgkJIjxUb0RvPiIKCQkiPCEtLSBEbyBJIG5lZWQgYSBzZWN1cmUgUERBPyAtLT4iCgkJIjxJdGVtIHByaW9yaXR5PVwiMlwiIGRpc3RhbmNlPVwiY2xvc2VcIj5HbyB0byB0aGUiCgkJIjxib2xkPlRveSBzdG9yZSEiCgkJIjwvYm9sZD4iCgkJIjwvSXRlbT4iCgkJIjxJdGVtIHByaW9yaXR5PVwiMVwiIGRpc3RhbmNlPVwiZmFyXCI+VGFsayB0bzoiCgkJIjxNZWV0aW5nIHdoZXJlPVwiU2Nob29sXCI+IgoJCSI8QXR0ZW5kZWUgbmFtZT1cIk1hcnBsZVwiIHBvc2l0aW9uPVwidGVhY2hlclwiIC8+IgoJCSI8QXR0ZW5kZWUgbmFtZT1cIlZvZWxcIiBwb3NpdGlvbj1cImNvdW5zZWxvclwiIC8+IgoJCSI8L01lZXRpbmc+IgoJCSI8TWVldGluZyB3aGVyZT1cIkx1bmNoXCIgLz4iCgkJIjwvSXRlbT4iCgkJIjxJdGVtIHByaW9yaXR5PVwiMlwiIGRpc3RhbmNlPVwiaGVyZVwiPkRvIGJpbGxzIgoJCSI8L0l0ZW0+IgoJCSI8L1RvRG8+IjsKI2VuZGlmCgoJLy8gVGhlIGV4YW1wbGUgcGFyc2VzIGZyb20gdGhlIGNoYXJhY3RlciBzdHJpbmcgKGFib3ZlKToKCSNpZiBkZWZpbmVkKCBXSU4zMiApICYmIGRlZmluZWQoIFRVTkUgKQoJUXVlcnlQZXJmb3JtYW5jZUNvdW50ZXIoIChMQVJHRV9JTlRFR0VSKikgKCZzdGFydCkgKTsKCSNlbmRpZgkKCgl7CgkJLy8gV3JpdGUgdG8gYSBmaWxlIGFuZCByZWFkIGl0IGJhY2ssIHRvIGNoZWNrIGZpbGUgSS9PLgoKCQlUaVhtbERvY3VtZW50IGRvYyggImRlbW90ZXN0LnhtbCIgKTsKCQlkb2MuUGFyc2UoIGRlbW9TdGFydCApOwoKCQlpZiAoIGRvYy5FcnJvcigpICkKCQl7CgkJCXByaW50ZiggIkVycm9yIGluICVzOiAlc1xuIiwgZG9jLlZhbHVlKCksIGRvYy5FcnJvckRlc2MoKSApOwoJCQlleGl0KCAxICk7CgkJfQoJCWRvYy5TYXZlRmlsZSgpOwoJfQoKCVRpWG1sRG9jdW1lbnQgZG9jKCAiZGVtb3Rlc3QueG1sIiApOwoJYm9vbCBsb2FkT2theSA9IGRvYy5Mb2FkRmlsZSgpOwoKCWlmICggIWxvYWRPa2F5ICkKCXsKCQlwcmludGYoICJDb3VsZCBub3QgbG9hZCB0ZXN0IGZpbGUgJ2RlbW90ZXN0LnhtbCcuIEVycm9yPSclcycuIEV4aXRpbmcuXG4iLCBkb2MuRXJyb3JEZXNjKCkgKTsKCQlleGl0KCAxICk7Cgl9CgoJcHJpbnRmKCAiKiogRGVtbyBkb2MgcmVhZCBmcm9tIGRpc2s6ICoqIFxuXG4iICk7Cglkb2MuUHJpbnQoIHN0ZG91dCApOwoKCVRpWG1sTm9kZSogbm9kZSA9IDA7CglUaVhtbEVsZW1lbnQqIHRvZG9FbGVtZW50ID0gMDsKCVRpWG1sRWxlbWVudCogaXRlbUVsZW1lbnQgPSAwOwoKCgkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoJLy8gQW4gZXhhbXBsZSBvZiBjaGFuZ2luZyBleGlzdGluZyBhdHRyaWJ1dGVzLCBhbmQgcmVtb3ZpbmcKCS8vIGFuIGVsZW1lbnQgZnJvbSB0aGUgZG9jdW1lbnQuCgkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKCS8vIEdldCB0aGUgIlRvRG8iIGVsZW1lbnQuCgkvLyBJdCBpcyBhIGNoaWxkIG9mIHRoZSBkb2N1bWVudCwgYW5kIGNhbiBiZSBzZWxlY3RlZCBieSBuYW1lLgoJbm9kZSA9IGRvYy5GaXJzdENoaWxkKCAiVG9EbyIgKTsKCWFzc2VydCggbm9kZSApOwoJdG9kb0VsZW1lbnQgPSBub2RlLT5Ub0VsZW1lbnQoKTsKCWFzc2VydCggdG9kb0VsZW1lbnQgICk7CgoJLy8gR29pbmcgdG8gdGhlIHRveSBzdG9yZSBpcyBub3cgb3VyIHNlY29uZCBwcmlvcml0eS4uLgoJLy8gU28gc2V0IHRoZSAicHJpb3JpdHkiIGF0dHJpYnV0ZSBvZiB0aGUgZmlyc3QgaXRlbSBpbiB0aGUgbGlzdC4KCW5vZGUgPSB0b2RvRWxlbWVudC0+Rmlyc3RDaGlsZEVsZW1lbnQoKTsJLy8gVGhpcyBza2lwcyB0aGUgIlBEQSIgY29tbWVudC4KCWFzc2VydCggbm9kZSApOwoJaXRlbUVsZW1lbnQgPSBub2RlLT5Ub0VsZW1lbnQoKTsKCWFzc2VydCggaXRlbUVsZW1lbnQgICk7CglpdGVtRWxlbWVudC0+U2V0QXR0cmlidXRlKCAicHJpb3JpdHkiLCAyICk7CgoJLy8gQ2hhbmdlIHRoZSBkaXN0YW5jZSB0byAiZG9pbmcgYmlsbHMiIGZyb20KCS8vICJub25lIiB0byAiaGVyZSIuIEl0J3MgdGhlIG5leHQgc2libGluZyBlbGVtZW50LgoJaXRlbUVsZW1lbnQgPSBpdGVtRWxlbWVudC0+TmV4dFNpYmxpbmdFbGVtZW50KCk7Cglhc3NlcnQoIGl0ZW1FbGVtZW50ICk7CglpdGVtRWxlbWVudC0+U2V0QXR0cmlidXRlKCAiZGlzdGFuY2UiLCAiaGVyZSIgKTsKCgkvLyBSZW1vdmUgdGhlICJMb29rIGZvciBFdmlsIERpbm9zYXVycyEiIGl0ZW0uCgkvLyBJdCBpcyAxIG1vcmUgc2libGluZyBhd2F5LiBXZSBhc2sgdGhlIHBhcmVudCB0byByZW1vdmUKCS8vIGEgcGFydGljdWxhciBjaGlsZC4KCWl0ZW1FbGVtZW50ID0gaXRlbUVsZW1lbnQtPk5leHRTaWJsaW5nRWxlbWVudCgpOwoJdG9kb0VsZW1lbnQtPlJlbW92ZUNoaWxkKCBpdGVtRWxlbWVudCApOwoKCWl0ZW1FbGVtZW50ID0gMDsKCgkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoJLy8gV2hhdCBmb2xsb3dzIGlzIGFuIGV4YW1wbGUgb2YgY3JlYXRlZCBlbGVtZW50cyBhbmQgdGV4dAoJLy8gbm9kZXMgYW5kIGFkZGluZyB0aGVtIHRvIHRoZSBkb2N1bWVudC4KCS8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgoJLy8gQWRkIHNvbWUgbWVldGluZ3MuCglUaVhtbEVsZW1lbnQgaXRlbSggIkl0ZW0iICk7CglpdGVtLlNldEF0dHJpYnV0ZSggInByaW9yaXR5IiwgIjEiICk7CglpdGVtLlNldEF0dHJpYnV0ZSggImRpc3RhbmNlIiwgImZhciIgKTsKCglUaVhtbFRleHQgdGV4dCggIlRhbGsgdG86IiApOwoKCVRpWG1sRWxlbWVudCBtZWV0aW5nMSggIk1lZXRpbmciICk7CgltZWV0aW5nMS5TZXRBdHRyaWJ1dGUoICJ3aGVyZSIsICJTY2hvb2wiICk7CgoJVGlYbWxFbGVtZW50IG1lZXRpbmcyKCAiTWVldGluZyIgKTsKCW1lZXRpbmcyLlNldEF0dHJpYnV0ZSggIndoZXJlIiwgIkx1bmNoIiApOwoKCVRpWG1sRWxlbWVudCBhdHRlbmRlZTEoICJBdHRlbmRlZSIgKTsKCWF0dGVuZGVlMS5TZXRBdHRyaWJ1dGUoICJuYW1lIiwgIk1hcnBsZSIgKTsKCWF0dGVuZGVlMS5TZXRBdHRyaWJ1dGUoICJwb3NpdGlvbiIsICJ0ZWFjaGVyIiApOwoKCVRpWG1sRWxlbWVudCBhdHRlbmRlZTIoICJBdHRlbmRlZSIgKTsKCWF0dGVuZGVlMi5TZXRBdHRyaWJ1dGUoICJuYW1lIiwgIlZvZWwiICk7CglhdHRlbmRlZTIuU2V0QXR0cmlidXRlKCAicG9zaXRpb24iLCAiY291bnNlbG9yIiApOwoKCS8vIEFzc2VtYmxlIHRoZSBub2RlcyB3ZSd2ZSBjcmVhdGVkOgoJbWVldGluZzEuSW5zZXJ0RW5kQ2hpbGQoIGF0dGVuZGVlMSApOwoJbWVldGluZzEuSW5zZXJ0RW5kQ2hpbGQoIGF0dGVuZGVlMiApOwoKCWl0ZW0uSW5zZXJ0RW5kQ2hpbGQoIHRleHQgKTsKCWl0ZW0uSW5zZXJ0RW5kQ2hpbGQoIG1lZXRpbmcxICk7CglpdGVtLkluc2VydEVuZENoaWxkKCBtZWV0aW5nMiApOwoKCS8vIEFuZCBhZGQgdGhlIG5vZGUgdG8gdGhlIGV4aXN0aW5nIGxpc3QgYWZ0ZXIgdGhlIGZpcnN0IGNoaWxkLgoJbm9kZSA9IHRvZG9FbGVtZW50LT5GaXJzdENoaWxkKCAiSXRlbSIgKTsKCWFzc2VydCggbm9kZSApOwoJaXRlbUVsZW1lbnQgPSBub2RlLT5Ub0VsZW1lbnQoKTsKCWFzc2VydCggaXRlbUVsZW1lbnQgKTsKCgl0b2RvRWxlbWVudC0+SW5zZXJ0QWZ0ZXJDaGlsZCggaXRlbUVsZW1lbnQsIGl0ZW0gKTsKCglwcmludGYoICJcbioqIERlbW8gZG9jIHByb2Nlc3NlZDogKiogXG5cbiIgKTsKCWRvYy5QcmludCggc3Rkb3V0ICk7CgoKI2lmZGVmIFRJWE1MX1VTRV9TVEwKCXByaW50ZiggIioqIERlbW8gZG9jIHByb2Nlc3NlZCB0byBzdHJlYW06ICoqIFxuXG4iICk7Cgljb3V0IDw8IGRvYyA8PCBlbmRsIDw8IGVuZGw7CiNlbmRpZgoKCS8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgkvLyBEaWZmZXJlbnQgdGVzdHMuLi5kbyB3ZSBoYXZlIHdoYXQgd2UgZXhwZWN0PwoJLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCglpbnQgY291bnQgPSAwOwoJVGlYbWxFbGVtZW50KgllbGVtZW50OwoKCS8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwoKI2lmZGVmIFRJWE1MX1VTRV9TVEwKCWNvdXQgPDwgIioqIEJhc2ljIHN0cnVjdHVyZS4gKipcbiI7Cglvc3RyaW5nc3RyZWFtIG91dHB1dFN0cmVhbSggb3N0cmluZ3N0cmVhbTo6b3V0ICk7CglvdXRwdXRTdHJlYW0gPDwgZG9jOwoJWG1sVGVzdCggIk91dHB1dCBzdHJlYW0gY29ycmVjdC4iLAlzdHJpbmcoIGRlbW9FbmQgKS5jX3N0cigpLAoJCQkJCQkJCQkJb3V0cHV0U3RyZWFtLnN0cigpLmNfc3RyKCksIHRydWUgKTsKI2VuZGlmCgoJbm9kZSA9IGRvYy5Sb290RWxlbWVudCgpOwoJWG1sVGVzdCggIlJvb3QgZWxlbWVudCBleGlzdHMuIiwgdHJ1ZSwgKCBub2RlICE9IDAgJiYgbm9kZS0+VG9FbGVtZW50KCkgKSApOwoJWG1sVGVzdCAoICJSb290IGVsZW1lbnQgdmFsdWUgaXMgJ1RvRG8nLiIsICJUb0RvIiwgIG5vZGUtPlZhbHVlKCkpOwoKCW5vZGUgPSBub2RlLT5GaXJzdENoaWxkKCk7CglYbWxUZXN0KCAiRmlyc3QgY2hpbGQgZXhpc3RzICYgaXMgYSBjb21tZW50LiIsIHRydWUsICggbm9kZSAhPSAwICYmIG5vZGUtPlRvQ29tbWVudCgpICkgKTsKCW5vZGUgPSBub2RlLT5OZXh0U2libGluZygpOwoJWG1sVGVzdCggIlNpYmxpbmcgZWxlbWVudCBleGlzdHMgJiBpcyBhbiBlbGVtZW50LiIsIHRydWUsICggbm9kZSAhPSAwICYmIG5vZGUtPlRvRWxlbWVudCgpICkgKTsKCVhtbFRlc3QgKCAiVmFsdWUgaXMgJ0l0ZW0nLiIsICJJdGVtIiwgbm9kZS0+VmFsdWUoKSApOwoKCW5vZGUgPSBub2RlLT5GaXJzdENoaWxkKCk7CglYbWxUZXN0ICggIkZpcnN0IGNoaWxkIGV4aXN0cy4iLCB0cnVlLCAoIG5vZGUgIT0gMCAmJiBub2RlLT5Ub1RleHQoKSApICk7CglYbWxUZXN0ICggIlZhbHVlIGlzICdHbyB0byB0aGUnLiIsICJHbyB0byB0aGUiLCBub2RlLT5WYWx1ZSgpICk7CgoKCS8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwoJcHJpbnRmICgiXG4qKiBJdGVyYXRvcnMuICoqXG4iKTsKCgkvLyBXYWxrIGFsbCB0aGUgdG9wIGxldmVsIG5vZGVzIG9mIHRoZSBkb2N1bWVudC4KCWNvdW50ID0gMDsKCWZvciggbm9kZSA9IGRvYy5GaXJzdENoaWxkKCk7CgkJIG5vZGU7CgkJIG5vZGUgPSBub2RlLT5OZXh0U2libGluZygpICkKCXsKCQljb3VudCsrOwoJfQoJWG1sVGVzdCggIlRvcCBsZXZlbCBub2RlcywgdXNpbmcgRmlyc3QgLyBOZXh0LiIsIDMsIGNvdW50ICk7CgoJY291bnQgPSAwOwoJZm9yKCBub2RlID0gZG9jLkxhc3RDaGlsZCgpOwoJCSBub2RlOwoJCSBub2RlID0gbm9kZS0+UHJldmlvdXNTaWJsaW5nKCkgKQoJewoJCWNvdW50Kys7Cgl9CglYbWxUZXN0KCAiVG9wIGxldmVsIG5vZGVzLCB1c2luZyBMYXN0IC8gUHJldmlvdXMuIiwgMywgY291bnQgKTsKCgkvLyBXYWxrIGFsbCB0aGUgdG9wIGxldmVsIG5vZGVzIG9mIHRoZSBkb2N1bWVudCwKCS8vIHVzaW5nIGEgZGlmZmVyZW50IHN5bnRheC4KCWNvdW50ID0gMDsKCWZvciggbm9kZSA9IGRvYy5JdGVyYXRlQ2hpbGRyZW4oIDAgKTsKCQkgbm9kZTsKCQkgbm9kZSA9IGRvYy5JdGVyYXRlQ2hpbGRyZW4oIG5vZGUgKSApCgl7CgkJY291bnQrKzsKCX0KCVhtbFRlc3QoICJUb3AgbGV2ZWwgbm9kZXMsIHVzaW5nIEl0ZXJhdGVDaGlsZHJlbi4iLCAzLCBjb3VudCApOwoKCS8vIFdhbGsgYWxsIHRoZSBlbGVtZW50cyBpbiBhIG5vZGUuCgljb3VudCA9IDA7Cglmb3IoIGVsZW1lbnQgPSB0b2RvRWxlbWVudC0+Rmlyc3RDaGlsZEVsZW1lbnQoKTsKCQkgZWxlbWVudDsKCQkgZWxlbWVudCA9IGVsZW1lbnQtPk5leHRTaWJsaW5nRWxlbWVudCgpICkKCXsKCQljb3VudCsrOwoJfQoJWG1sVGVzdCggIkNoaWxkcmVuIG9mIHRoZSAnVG9EbycgZWxlbWVudCwgdXNpbmcgRmlyc3QgLyBOZXh0LiIsCgkJMywgY291bnQgKTsKCgkvLyBXYWxrIGFsbCB0aGUgZWxlbWVudHMgaW4gYSBub2RlIGJ5IHZhbHVlLgoJY291bnQgPSAwOwoJZm9yKCBub2RlID0gdG9kb0VsZW1lbnQtPkZpcnN0Q2hpbGQoICJJdGVtIiApOwoJCSBub2RlOwoJCSBub2RlID0gbm9kZS0+TmV4dFNpYmxpbmcoICJJdGVtIiApICkKCXsKCQljb3VudCsrOwoJfQoJWG1sVGVzdCggIidJdGVtJyBjaGlsZHJlbiBvZiB0aGUgJ1RvRG8nIGVsZW1lbnQsIHVzaW5nIEZpcnN0L05leHQuIiwgMywgY291bnQgKTsKCgljb3VudCA9IDA7Cglmb3IoIG5vZGUgPSB0b2RvRWxlbWVudC0+TGFzdENoaWxkKCAiSXRlbSIgKTsKCQkgbm9kZTsKCQkgbm9kZSA9IG5vZGUtPlByZXZpb3VzU2libGluZyggIkl0ZW0iICkgKQoJewoJCWNvdW50Kys7Cgl9CglYbWxUZXN0KCAiJ0l0ZW0nIGNoaWxkcmVuIG9mIHRoZSAnVG9EbycgZWxlbWVudCwgdXNpbmcgTGFzdC9QcmV2aW91cy4iLCAzLCBjb3VudCApOwoKI2lmZGVmIFRJWE1MX1VTRV9TVEwKCXsKCQljb3V0IDw8ICJcbioqIFBhcnNpbmcuICoqXG4iOwoJCWlzdHJpbmdzdHJlYW0gcGFyc2UwKCAiPEVsZW1lbnQwIGF0dHJpYnV0ZTA9J2ZvbzAnIGF0dHJpYnV0ZTE9IG5vcXVvdGVzIGF0dHJpYnV0ZTIgPSAnJmd0OycgLz4iICk7CgkJVGlYbWxFbGVtZW50IGVsZW1lbnQwKCAiZGVmYXVsdCIgKTsKCQlwYXJzZTAgPj4gZWxlbWVudDA7CgoJCVhtbFRlc3QgKCAiRWxlbWVudCBwYXJzZWQsIHZhbHVlIGlzICdFbGVtZW50MCcuIiwgIkVsZW1lbnQwIiwgZWxlbWVudDAuVmFsdWUoKSApOwoJCVhtbFRlc3QgKCAiUmVhZHMgYXR0cmlidXRlICdhdHRyaWJ1dGUwPVwiZm9vMFwiJy4iLCAiZm9vMCIsIGVsZW1lbnQwLkF0dHJpYnV0ZSggImF0dHJpYnV0ZTAiICkpOwoJCVhtbFRlc3QgKCAiUmVhZHMgaW5jb3JyZWN0bHkgZm9ybWF0dGVkICdhdHRyaWJ1dGUxPW5vcXVvdGVzJy4iLCAibm9xdW90ZXMiLCBlbGVtZW50MC5BdHRyaWJ1dGUoICJhdHRyaWJ1dGUxIiApICk7CgkJWG1sVGVzdCAoICJSZWFkIGF0dHJpYnV0ZSB3aXRoIGVudGl0eSB2YWx1ZSAnPicuIiwgIj4iLCBlbGVtZW50MC5BdHRyaWJ1dGUoICJhdHRyaWJ1dGUyIiApICk7Cgl9CiNlbmRpZgoKCXsKCQljb25zdCBjaGFyKiBlcnJvciA9CSI8P3htbCB2ZXJzaW9uPVwiMS4wXCIgc3RhbmRhbG9uZT1cIm5vXCIgPz5cbiIKCQkJCQkJCSI8cGFzc2FnZXMgY291bnQ9XCIwMDZcIiBmb3JtYXR2ZXJzaW9uPVwiMjAwMjA2MjBcIj5cbiIKCQkJCQkJCSIgICAgPHdyb25nIGVycm9yPlxuIgoJCQkJCQkJIjwvcGFzc2FnZXM+IjsKCiAgICAgICAgVGlYbWxEb2N1bWVudCBkb2M7CgkJZG9jLlBhcnNlKCBlcnJvciApOwoJCVhtbFRlc3QoICJFcnJvciByb3ciLCBkb2MuRXJyb3JSb3coKSwgMyApOwoJCVhtbFRlc3QoICJFcnJvciBjb2x1bW4iLCBkb2MuRXJyb3JDb2woKSwgMTcgKTsKCQkvL3ByaW50ZiggImVycm9yPSVkIGlkPSclcycgcm93ICVkIGNvbCVkXG4iLCAoaW50KSBkb2MuRXJyb3IoKSwgZG9jLkVycm9yRGVzYygpLCBkb2MuRXJyb3JSb3coKSsxLCBkb2MuRXJyb3JDb2woKSArIDEgKTsKCgl9Cgl7CgkJY29uc3QgY2hhciogc3RyID0JIlx0PD94bWwgdmVyc2lvbj1cIjEuMFwiIHN0YW5kYWxvbmU9XCJub1wiID8+XHQ8cm9vbSBkb29ycz0nMic+XG4iCgkJCQkJCQkiICA8IS0tIFNpbGx5IGV4YW1wbGUgLS0+XG4iCgkJCQkJCQkiICAgIDxkb29yIHdhbGw9J25vcnRoJz5BIGdyZWF0IGRvb3IhPC9kb29yPlxuIgoJCQkJCQkJIlx0PGRvb3Igd2FsbD0nZWFzdCcvPiIKCQkJCQkJCSI8L3Jvb20+IjsKCiAgICAgICAgVGlYbWxEb2N1bWVudCBkb2M7CgkJZG9jLlBhcnNlKCBzdHIgKTsKCgkJVGlYbWxIYW5kbGUgZG9jSGFuZGxlKCAmZG9jICk7CgkJVGlYbWxIYW5kbGUgcm9vbUhhbmRsZSA9IGRvY0hhbmRsZS5GaXJzdENoaWxkRWxlbWVudCggInJvb20iICk7CgkJVGlYbWxIYW5kbGUgY29tbWVudEhhbmRsZSA9IGRvY0hhbmRsZS5GaXJzdENoaWxkRWxlbWVudCggInJvb20iICkuRmlyc3RDaGlsZCgpOwoJCVRpWG1sSGFuZGxlIHRleHRIYW5kbGUgPSBkb2NIYW5kbGUuRmlyc3RDaGlsZEVsZW1lbnQoICJyb29tIiApLkNoaWxkRWxlbWVudCggImRvb3IiLCAwICkuRmlyc3RDaGlsZCgpOwoJCVRpWG1sSGFuZGxlIGRvb3IwSGFuZGxlID0gZG9jSGFuZGxlLkZpcnN0Q2hpbGRFbGVtZW50KCAicm9vbSIgKS5DaGlsZEVsZW1lbnQoIDAgKTsKCQlUaVhtbEhhbmRsZSBkb29yMUhhbmRsZSA9IGRvY0hhbmRsZS5GaXJzdENoaWxkRWxlbWVudCggInJvb20iICkuQ2hpbGRFbGVtZW50KCAxICk7CgoJCWFzc2VydCggZG9jSGFuZGxlLk5vZGUoKSApOwoJCWFzc2VydCggcm9vbUhhbmRsZS5FbGVtZW50KCkgKTsKCQlhc3NlcnQoIGNvbW1lbnRIYW5kbGUuTm9kZSgpICk7CgkJYXNzZXJ0KCB0ZXh0SGFuZGxlLlRleHQoKSApOwoJCWFzc2VydCggZG9vcjBIYW5kbGUuRWxlbWVudCgpICk7CgkJYXNzZXJ0KCBkb29yMUhhbmRsZS5FbGVtZW50KCkgKTsKCgkJVGlYbWxEZWNsYXJhdGlvbiogZGVjbGFyYXRpb24gPSBkb2MuRmlyc3RDaGlsZCgpLT5Ub0RlY2xhcmF0aW9uKCk7CgkJYXNzZXJ0KCBkZWNsYXJhdGlvbiApOwoJCVRpWG1sRWxlbWVudCogcm9vbSA9IHJvb21IYW5kbGUuRWxlbWVudCgpOwoJCWFzc2VydCggcm9vbSApOwoJCVRpWG1sQXR0cmlidXRlKiBkb29ycyA9IHJvb20tPkZpcnN0QXR0cmlidXRlKCk7CgkJYXNzZXJ0KCBkb29ycyApOwoJCVRpWG1sVGV4dCogdGV4dCA9IHRleHRIYW5kbGUuVGV4dCgpOwoJCVRpWG1sQ29tbWVudCogY29tbWVudCA9IGNvbW1lbnRIYW5kbGUuTm9kZSgpLT5Ub0NvbW1lbnQoKTsKCQlhc3NlcnQoIGNvbW1lbnQgKTsKCQlUaVhtbEVsZW1lbnQqIGRvb3IwID0gZG9vcjBIYW5kbGUuRWxlbWVudCgpOwoJCVRpWG1sRWxlbWVudCogZG9vcjEgPSBkb29yMUhhbmRsZS5FbGVtZW50KCk7CgoJCVhtbFRlc3QoICJMb2NhdGlvbiB0cmFja2luZzogRGVjbGFyYXRpb24gcm93IiwgZGVjbGFyYXRpb24tPlJvdygpLCAxICk7CgkJWG1sVGVzdCggIkxvY2F0aW9uIHRyYWNraW5nOiBEZWNsYXJhdGlvbiBjb2wiLCBkZWNsYXJhdGlvbi0+Q29sdW1uKCksIDUgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IHJvb20gcm93Iiwgcm9vbS0+Um93KCksIDEgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IHJvb20gY29sIiwgcm9vbS0+Q29sdW1uKCksIDQ1ICk7CgkJWG1sVGVzdCggIkxvY2F0aW9uIHRyYWNraW5nOiBkb29ycyByb3ciLCBkb29ycy0+Um93KCksIDEgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IGRvb3JzIGNvbCIsIGRvb3JzLT5Db2x1bW4oKSwgNTEgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IENvbW1lbnQgcm93IiwgY29tbWVudC0+Um93KCksIDIgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IENvbW1lbnQgY29sIiwgY29tbWVudC0+Q29sdW1uKCksIDMgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IHRleHQgcm93IiwgdGV4dC0+Um93KCksIDMgKTsgCgkJWG1sVGVzdCggIkxvY2F0aW9uIHRyYWNraW5nOiB0ZXh0IGNvbCIsIHRleHQtPkNvbHVtbigpLCAyNCApOwoJCVhtbFRlc3QoICJMb2NhdGlvbiB0cmFja2luZzogZG9vcjAgcm93IiwgZG9vcjAtPlJvdygpLCAzICk7CgkJWG1sVGVzdCggIkxvY2F0aW9uIHRyYWNraW5nOiBkb29yMCBjb2wiLCBkb29yMC0+Q29sdW1uKCksIDUgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IGRvb3IxIHJvdyIsIGRvb3IxLT5Sb3coKSwgNCApOwoJCVhtbFRlc3QoICJMb2NhdGlvbiB0cmFja2luZzogZG9vcjEgY29sIiwgZG9vcjEtPkNvbHVtbigpLCA1ICk7Cgl9Cgl7CgkJY29uc3QgY2hhciogc3RyID0JIlx0PD94bWwgdmVyc2lvbj1cIjEuMFwiIHN0YW5kYWxvbmU9XCJub1wiID8+XHQ8cm9vbSBkb29ycz0nMic+XG4iCgkJCQkJCQkiPC9yb29tPiI7CgogICAgICAgIFRpWG1sRG9jdW1lbnQgZG9jOwoJCWRvYy5TZXRUYWJTaXplKCA4ICk7CgkJZG9jLlBhcnNlKCBzdHIgKTsKCgkJVGlYbWxIYW5kbGUgZG9jSGFuZGxlKCAmZG9jICk7CgkJVGlYbWxIYW5kbGUgcm9vbUhhbmRsZSA9IGRvY0hhbmRsZS5GaXJzdENoaWxkRWxlbWVudCggInJvb20iICk7CgoJCWFzc2VydCggZG9jSGFuZGxlLk5vZGUoKSApOwoJCWFzc2VydCggcm9vbUhhbmRsZS5FbGVtZW50KCkgKTsKCgkJVGlYbWxFbGVtZW50KiByb29tID0gcm9vbUhhbmRsZS5FbGVtZW50KCk7CgkJYXNzZXJ0KCByb29tICk7CgkJVGlYbWxBdHRyaWJ1dGUqIGRvb3JzID0gcm9vbS0+Rmlyc3RBdHRyaWJ1dGUoKTsKCQlhc3NlcnQoIGRvb3JzICk7CgoJCVhtbFRlc3QoICJMb2NhdGlvbiB0cmFja2luZzogVGFiIDg6IHJvb20gcm93Iiwgcm9vbS0+Um93KCksIDEgKTsKCQlYbWxUZXN0KCAiTG9jYXRpb24gdHJhY2tpbmc6IFRhYiA4OiByb29tIGNvbCIsIHJvb20tPkNvbHVtbigpLCA0OSApOwoJCVhtbFRlc3QoICJMb2NhdGlvbiB0cmFja2luZzogVGFiIDg6IGRvb3JzIHJvdyIsIGRvb3JzLT5Sb3coKSwgMSApOwoJCVhtbFRlc3QoICJMb2NhdGlvbiB0cmFja2luZzogVGFiIDg6IGRvb3JzIGNvbCIsIGRvb3JzLT5Db2x1bW4oKSwgNTUgKTsKCX0KCgl7CgkJY29uc3QgY2hhciogc3RyID0gIjxkb2MgYXR0cjA9JzEnIGF0dHIxPScyLjAnIGF0dHIyPSdmb28nIC8+IjsKCgkJVGlYbWxEb2N1bWVudCBkb2M7CgkJZG9jLlBhcnNlKCBzdHIgKTsKCgkJVGlYbWxFbGVtZW50KiBlbGUgPSBkb2MuRmlyc3RDaGlsZEVsZW1lbnQoKTsKCgkJaW50IGlWYWwsIHJlc3VsdDsKCQlkb3VibGUgZFZhbDsKCgkJcmVzdWx0ID0gZWxlLT5RdWVyeURvdWJsZUF0dHJpYnV0ZSggImF0dHIwIiwgJmRWYWwgKTsKCQlYbWxUZXN0KCAiUXVlcnkgYXR0cmlidXRlOiBpbnQgYXMgZG91YmxlIiwgcmVzdWx0LCBUSVhNTF9TVUNDRVNTICk7CgkJWG1sVGVzdCggIlF1ZXJ5IGF0dHJpYnV0ZTogaW50IGFzIGRvdWJsZSIsIChpbnQpZFZhbCwgMSApOwoJCXJlc3VsdCA9IGVsZS0+UXVlcnlEb3VibGVBdHRyaWJ1dGUoICJhdHRyMSIsICZkVmFsICk7CgkJWG1sVGVzdCggIlF1ZXJ5IGF0dHJpYnV0ZTogZG91YmxlIGFzIGRvdWJsZSIsIChpbnQpZFZhbCwgMiApOwoJCXJlc3VsdCA9IGVsZS0+UXVlcnlJbnRBdHRyaWJ1dGUoICJhdHRyMSIsICZpVmFsICk7CgkJWG1sVGVzdCggIlF1ZXJ5IGF0dHJpYnV0ZTogZG91YmxlIGFzIGludCIsIHJlc3VsdCwgVElYTUxfU1VDQ0VTUyApOwoJCVhtbFRlc3QoICJRdWVyeSBhdHRyaWJ1dGU6IGRvdWJsZSBhcyBpbnQiLCBpVmFsLCAyICk7CgkJcmVzdWx0ID0gZWxlLT5RdWVyeUludEF0dHJpYnV0ZSggImF0dHIyIiwgJmlWYWwgKTsKCQlYbWxUZXN0KCAiUXVlcnkgYXR0cmlidXRlOiBub3QgYSBudW1iZXIiLCByZXN1bHQsIFRJWE1MX1dST05HX1RZUEUgKTsKCQlyZXN1bHQgPSBlbGUtPlF1ZXJ5SW50QXR0cmlidXRlKCAiYmFyIiwgJmlWYWwgKTsKCQlYbWxUZXN0KCAiUXVlcnkgYXR0cmlidXRlOiBkb2VzIG5vdCBleGlzdCIsIHJlc3VsdCwgVElYTUxfTk9fQVRUUklCVVRFICk7Cgl9CgojaWZkZWYgVElYTUxfVVNFX1NUTAoJewoJCS8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwoJCWNvdXQgPDwgIlxuKiogU3RyZWFtaW5nLiAqKlxuIjsKCgkJLy8gUm91bmQgdHJpcCBjaGVjazogc3RyZWFtIGluLCB0aGVuIHN0cmVhbSBiYWNrIG91dCB0byB2ZXJpZnkuIFRoZSBzdHJlYW0KCQkvLyBvdXQgaGFzIGFscmVhZHkgYmVlbiBjaGVja2VkLCBhYm92ZS4gV2UgdXNlIHRoZSBvdXRwdXQKCgkJaXN0cmluZ3N0cmVhbSBpbnB1dFN0cmluZ1N0cmVhbSggb3V0cHV0U3RyZWFtLnN0cigpICk7CgkJVGlYbWxEb2N1bWVudCBkb2N1bWVudDA7CgoJCWlucHV0U3RyaW5nU3RyZWFtID4+IGRvY3VtZW50MDsKCgkJb3N0cmluZ3N0cmVhbSBvdXRwdXRTdHJlYW0wKCBvc3RyaW5nc3RyZWFtOjpvdXQgKTsKCQlvdXRwdXRTdHJlYW0wIDw8IGRvY3VtZW50MDsKCgkJWG1sVGVzdCggIlN0cmVhbSByb3VuZCB0cmlwIGNvcnJlY3QuIiwJc3RyaW5nKCBkZW1vRW5kICkuY19zdHIoKSwgCgkJCQkJCQkJCQkJCW91dHB1dFN0cmVhbTAuc3RyKCkuY19zdHIoKSwgdHJ1ZSApOwoKCQlzdGQ6OnN0cmluZyBzdHI7CgkJc3RyIDw8IGRvY3VtZW50MDsKCgkJWG1sVGVzdCggIlN0cmluZyBwcmludGluZyBjb3JyZWN0LiIsIHN0cmluZyggZGVtb0VuZCApLmNfc3RyKCksIAoJCQkJCQkJCQkJCSBzdHIuY19zdHIoKSwgdHJ1ZSApOwoJfQojZW5kaWYKCgkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoJLy8gVVRGLTggdGVzdGluZy4gSXQgaXMgaW1wb3J0YW50IHRvIHRlc3Q6CgkvLwkxLiBNYWtpbmcgc3VyZSBuYW1lLCB2YWx1ZSwgYW5kIHRleHQgcmVhZCBjb3JyZWN0bHkKCS8vCTIuIFJvdywgQ29sIGZ1bmN0aW9uYWxpdHkKCS8vCTMuIENvcnJlY3Qgb3V0cHV0CgkvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoJcHJpbnRmICgiXG4qKiBVVEYtOCAqKlxuIik7Cgl7CgkJVGlYbWxEb2N1bWVudCBkb2MoICJ1dGY4dGVzdC54bWwiICk7CgkJZG9jLkxvYWRGaWxlKCk7CgkJaWYgKCBkb2MuRXJyb3IoKSAmJiBkb2MuRXJyb3JJZCgpID09IFRpWG1sQmFzZTo6VElYTUxfRVJST1JfT1BFTklOR19GSUxFICkgewoJCQlwcmludGYoICJXQVJOSU5HOiBGaWxlICd1dGY4dGVzdC54bWwnIG5vdCBmb3VuZC5cbiIKCQkJCQkiKEFyZSB5b3UgcnVubmluZyB0aGUgdGVzdCBmcm9tIHRoZSB3cm9uZyBkaXJlY3Rvcnk/KVxuIgoJCQkJICAgICJDb3VsZCBub3QgdGVzdCBVVEYtOCBmdW5jdGlvbmFsaXR5LlxuIiApOwoJCX0KCQllbHNlCgkJewoJCQlUaVhtbEhhbmRsZSBkb2NIKCAmZG9jICk7CgkJCS8vIEdldCB0aGUgYXR0cmlidXRlICJ2YWx1ZSIgZnJvbSB0aGUgIlJ1c3NpYW4iIGVsZW1lbnQgYW5kIGNoZWNrIGl0LgoJCQlUaVhtbEVsZW1lbnQqIGVsZW1lbnQgPSBkb2NILkZpcnN0Q2hpbGRFbGVtZW50KCAiZG9jdW1lbnQiICkuRmlyc3RDaGlsZEVsZW1lbnQoICJSdXNzaWFuIiApLkVsZW1lbnQoKTsKCQkJY29uc3QgdW5zaWduZWQgY2hhciBjb3JyZWN0VmFsdWVbXSA9IHsJMHhkMVUsIDB4ODZVLCAweGQwVSwgMHhiNVUsIDB4ZDBVLCAweGJkVSwgMHhkMFUsIDB4YmRVLCAKCQkJCQkJCQkJCQkJCTB4ZDBVLCAweGJlVSwgMHhkMVUsIDB4ODFVLCAweGQxVSwgMHg4MlUsIDB4ZDFVLCAweDhjVSwgMCB9OwoKCQkJWG1sVGVzdCggIlVURi04OiBSdXNzaWFuIHZhbHVlLiIsIChjb25zdCBjaGFyKiljb3JyZWN0VmFsdWUsIGVsZW1lbnQtPkF0dHJpYnV0ZSggInZhbHVlIiApLCB0cnVlICk7CgkJCVhtbFRlc3QoICJVVEYtODogUnVzc2lhbiB2YWx1ZSByb3cuIiwgNCwgZWxlbWVudC0+Um93KCkgKTsKCQkJWG1sVGVzdCggIlVURi04OiBSdXNzaWFuIHZhbHVlIGNvbHVtbi4iLCA1LCBlbGVtZW50LT5Db2x1bW4oKSApOwoKCQkJY29uc3QgdW5zaWduZWQgY2hhciBydXNzaWFuRWxlbWVudE5hbWVbXSA9IHsJMHhkMFUsIDB4YTBVLCAweGQxVSwgMHg4M1UsCgkJCQkJCQkJCQkJCQkJCTB4ZDFVLCAweDgxVSwgMHhkMVUsIDB4ODFVLAoJCQkJCQkJCQkJCQkJCQkweGQwVSwgMHhiYVUsIDB4ZDBVLCAweGI4VSwKCQkJCQkJCQkJCQkJCQkJMHhkMFUsIDB4YjlVLCAwIH07CgkJCWNvbnN0IGNoYXIgcnVzc2lhblRleHRbXSA9ICI8XHhEMFx4QjhceEQwXHhCQ1x4RDBceEI1XHhEMFx4QjVceEQxXHg4Mj4iOwoKCQkJVGlYbWxUZXh0KiB0ZXh0ID0gZG9jSC5GaXJzdENoaWxkRWxlbWVudCggImRvY3VtZW50IiApLkZpcnN0Q2hpbGRFbGVtZW50KCAoY29uc3QgY2hhciopIHJ1c3NpYW5FbGVtZW50TmFtZSApLkNoaWxkKCAwICkuVGV4dCgpOwoJCQlYbWxUZXN0KCAiVVRGLTg6IEJyb3dzaW5nIHJ1c3NpYW4gZWxlbWVudCBuYW1lLiIsCgkJCQkJIHJ1c3NpYW5UZXh0LAoJCQkJCSB0ZXh0LT5WYWx1ZSgpLAoJCQkJCSB0cnVlICk7CgkJCVhtbFRlc3QoICJVVEYtODogUnVzc2lhbiBlbGVtZW50IG5hbWUgcm93LiIsIDcsIHRleHQtPlJvdygpICk7CgkJCVhtbFRlc3QoICJVVEYtODogUnVzc2lhbiBlbGVtZW50IG5hbWUgY29sdW1uLiIsIDQ3LCB0ZXh0LT5Db2x1bW4oKSApOwoKCQkJVGlYbWxEZWNsYXJhdGlvbiogZGVjID0gZG9jSC5DaGlsZCggMCApLk5vZGUoKS0+VG9EZWNsYXJhdGlvbigpOwoJCQlYbWxUZXN0KCAiVVRGLTg6IERlY2xhcmF0aW9uIGNvbHVtbi4iLCAxLCBkZWMtPkNvbHVtbigpICk7CgkJCVhtbFRlc3QoICJVVEYtODogRG9jdW1lbnQgY29sdW1uLiIsIDEsIGRvYy5Db2x1bW4oKSApOwoKCQkJLy8gTm93IHRyeSBmb3IgYSByb3VuZCB0cmlwLgoJCQlkb2MuU2F2ZUZpbGUoICJ1dGY4dGVzdG91dC54bWwiICk7CgoJCQkvLyBDaGVjayB0aGUgcm91bmQgdHJpcC4KCQkJY2hhciBzYXZlZEJ1ZlsyNTZdOwoJCQljaGFyIHZlcmlmeUJ1ZlsyNTZdOwoJCQlpbnQgb2theSA9IDE7CgoJCQlGSUxFKiBzYXZlZCAgPSBmb3BlbiggInV0Zjh0ZXN0b3V0LnhtbCIsICJyIiApOwoJCQlGSUxFKiB2ZXJpZnkgPSBmb3BlbiggInV0Zjh0ZXN0dmVyaWZ5LnhtbCIsICJyIiApOwoJCQlpZiAoIHNhdmVkICYmIHZlcmlmeSApCgkJCXsKCQkJCXdoaWxlICggZmdldHMoIHZlcmlmeUJ1ZiwgMjU2LCB2ZXJpZnkgKSApCgkJCQl7CgkJCQkJZmdldHMoIHNhdmVkQnVmLCAyNTYsIHNhdmVkICk7CgkJCQkJaWYgKCBzdHJjbXAoIHZlcmlmeUJ1Ziwgc2F2ZWRCdWYgKSApCgkJCQkJewoJCQkJCQlva2F5ID0gMDsKCQkJCQkJYnJlYWs7CgkJCQkJfQoJCQkJfQoJCQkJZmNsb3NlKCBzYXZlZCApOwoJCQkJZmNsb3NlKCB2ZXJpZnkgKTsKCQkJfQoJCQlYbWxUZXN0KCAiVVRGLTg6IFZlcmlmaWVkIG11bHRpLWxhbmd1YWdlIHJvdW5kIHRyaXAuIiwgMSwgb2theSApOwoKCQkJLy8gT24gbW9zdCBXZXN0ZXJuIG1hY2hpbmVzLCB0aGlzIGlzIGFuIGVsZW1lbnQgdGhhdCBjb250YWlucwoJCQkvLyB0aGUgd29yZCAicmVzdW1lIiB3aXRoIHRoZSBjb3JyZWN0IGFjY2VudHMsIGluIGEgbGF0aW4gZW5jb2RpbmcuCgkJCS8vIEl0IHdpbGwgYmUgc29tZXRoaW5nIGVsc2UgY29tcGxldGVseSBvbiBub24td2VzdGVyIG1hY2hpbmVzLAoJCQkvLyB3aGljaCBpcyB3aHkgVGlueVhtbCBpcyBzd2l0Y2hpbmcgdG8gVVRGLTguCgkJCWNvbnN0IGNoYXIgbGF0aW5bXSA9ICI8ZWxlbWVudD5yXHg4MnN1bVx4ODI8L2VsZW1lbnQ+IjsKCgkJCVRpWG1sRG9jdW1lbnQgbGF0aW5Eb2M7CgkJCWxhdGluRG9jLlBhcnNlKCBsYXRpbiwgMCwgVElYTUxfRU5DT0RJTkdfTEVHQUNZICk7CgoJCQl0ZXh0ID0gbGF0aW5Eb2MuRmlyc3RDaGlsZEVsZW1lbnQoKS0+Rmlyc3RDaGlsZCgpLT5Ub1RleHQoKTsKCQkJWG1sVGVzdCggIkxlZ2FjeSBlbmNvZGluZzogVmVyaWZ5IHRleHQgZWxlbWVudC4iLCAiclx4ODJzdW1ceDgyIiwgdGV4dC0+VmFsdWUoKSApOwoJCX0KCX0JCQoKCS8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCS8vIENvcHkgYW5kIGFzc2lnbm1lbnQKCS8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCXByaW50ZiAoIlxuKiogQ29weSBhbmQgQXNzaWdubWVudCAqKlxuIik7Cgl7CgkJVGlYbWxFbGVtZW50IGVsZW1lbnQoICJmb28iICk7CgkJZWxlbWVudC5QYXJzZSggIjxlbGVtZW50IG5hbWU9J3ZhbHVlJyAvPiIsIDAsIFRJWE1MX0VOQ09ESU5HX1VOS05PV04gKTsKCgkJVGlYbWxFbGVtZW50IGVsZW1lbnRDb3B5KCBlbGVtZW50ICk7CgkJVGlYbWxFbGVtZW50IGVsZW1lbnRBc3NpZ24oICJmb28iICk7CgkJZWxlbWVudEFzc2lnbi5QYXJzZSggIjxpbmNvcnJlY3QgZm9vPSdiYXInLz4iLCAwLCBUSVhNTF9FTkNPRElOR19VTktOT1dOICk7CgkJZWxlbWVudEFzc2lnbiA9IGVsZW1lbnQ7CgoJCVhtbFRlc3QoICJDb3B5L0Fzc2lnbjogZWxlbWVudCBjb3B5ICMxLiIsICJlbGVtZW50IiwgZWxlbWVudENvcHkuVmFsdWUoKSApOwoJCVhtbFRlc3QoICJDb3B5L0Fzc2lnbjogZWxlbWVudCBjb3B5ICMyLiIsICJ2YWx1ZSIsIGVsZW1lbnRDb3B5LkF0dHJpYnV0ZSggIm5hbWUiICkgKTsKCQlYbWxUZXN0KCAiQ29weS9Bc3NpZ246IGVsZW1lbnQgYXNzaWduICMxLiIsICJlbGVtZW50IiwgZWxlbWVudEFzc2lnbi5WYWx1ZSgpICk7CgkJWG1sVGVzdCggIkNvcHkvQXNzaWduOiBlbGVtZW50IGFzc2lnbiAjMi4iLCAidmFsdWUiLCBlbGVtZW50QXNzaWduLkF0dHJpYnV0ZSggIm5hbWUiICkgKTsKCQlYbWxUZXN0KCAiQ29weS9Bc3NpZ246IGVsZW1lbnQgYXNzaWduICMzLiIsIDAsIChpbnQpIGVsZW1lbnRBc3NpZ24uQXR0cmlidXRlKCAiZm9vIiApICk7CgoJCVRpWG1sQ29tbWVudCBjb21tZW50OwoJCWNvbW1lbnQuUGFyc2UoICI8IS0tY29tbWVudC0tPiIsIDAsIFRJWE1MX0VOQ09ESU5HX1VOS05PV04gKTsKCQlUaVhtbENvbW1lbnQgY29tbWVudENvcHkoIGNvbW1lbnQgKTsKCQlUaVhtbENvbW1lbnQgY29tbWVudEFzc2lnbjsKCQljb21tZW50QXNzaWduID0gY29tbWVudENvcHk7CgkJWG1sVGVzdCggIkNvcHkvQXNzaWduOiBjb21tZW50IGNvcHkuIiwgImNvbW1lbnQiLCBjb21tZW50Q29weS5WYWx1ZSgpICk7CgkJWG1sVGVzdCggIkNvcHkvQXNzaWduOiBjb21tZW50IGFzc2lnbi4iLCAiY29tbWVudCIsIGNvbW1lbnRBc3NpZ24uVmFsdWUoKSApOwoKCQlUaVhtbFVua25vd24gdW5rbm93bjsKCQl1bmtub3duLlBhcnNlKCAiPFt1bmtub3duXT4iLCAwLCBUSVhNTF9FTkNPRElOR19VTktOT1dOICk7CgkJVGlYbWxVbmtub3duIHVua25vd25Db3B5KCB1bmtub3duICk7CgkJVGlYbWxVbmtub3duIHVua25vd25Bc3NpZ247CgkJdW5rbm93bkFzc2lnbi5QYXJzZSggImluY29ycmVjdCIsIDAsIFRJWE1MX0VOQ09ESU5HX1VOS05PV04gKTsKCQl1bmtub3duQXNzaWduID0gdW5rbm93bkNvcHk7CgkJWG1sVGVzdCggIkNvcHkvQXNzaWduOiB1bmtub3duIGNvcHkuIiwgIlt1bmtub3duXSIsIHVua25vd25Db3B5LlZhbHVlKCkgKTsKCQlYbWxUZXN0KCAiQ29weS9Bc3NpZ246IHVua25vd24gYXNzaWduLiIsICJbdW5rbm93bl0iLCB1bmtub3duQXNzaWduLlZhbHVlKCkgKTsKCQkKCQlUaVhtbFRleHQgdGV4dCggIlRleHROb2RlIiApOwoJCVRpWG1sVGV4dCB0ZXh0Q29weSggdGV4dCApOwoJCVRpWG1sVGV4dCB0ZXh0QXNzaWduKCAiaW5jb3JyZWN0IiApOwoJCXRleHRBc3NpZ24gPSB0ZXh0OwoJCVhtbFRlc3QoICJDb3B5L0Fzc2lnbjogdGV4dCBjb3B5LiIsICJUZXh0Tm9kZSIsIHRleHRDb3B5LlZhbHVlKCkgKTsKCQlYbWxUZXN0KCAiQ29weS9Bc3NpZ246IHRleHQgYXNzaWduLiIsICJUZXh0Tm9kZSIsIHRleHRBc3NpZ24uVmFsdWUoKSApOwoKCQlUaVhtbERlY2xhcmF0aW9uIGRlYzsKCQlkZWMuUGFyc2UoICI8P3htbCB2ZXJzaW9uPScxLjAnIGVuY29kaW5nPSdVVEYtOCc/PiIsIDAsIFRJWE1MX0VOQ09ESU5HX1VOS05PV04gKTsKCQlUaVhtbERlY2xhcmF0aW9uIGRlY0NvcHkoIGRlYyApOwoJCVRpWG1sRGVjbGFyYXRpb24gZGVjQXNzaWduOwoJCWRlY0Fzc2lnbiA9IGRlYzsKCgkJWG1sVGVzdCggIkNvcHkvQXNzaWduOiBkZWNsYXJhdGlvbiBjb3B5LiIsICJVVEYtOCIsIGRlY0NvcHkuRW5jb2RpbmcoKSApOwoJCVhtbFRlc3QoICJDb3B5L0Fzc2lnbjogdGV4dCBhc3NpZ24uIiwgIlVURi04IiwgZGVjQXNzaWduLkVuY29kaW5nKCkgKTsKCgkJVGlYbWxEb2N1bWVudCBkb2M7CgkJZWxlbWVudENvcHkuSW5zZXJ0RW5kQ2hpbGQoIHRleHRDb3B5ICk7CgkJZG9jLkluc2VydEVuZENoaWxkKCBkZWNBc3NpZ24gKTsKCQlkb2MuSW5zZXJ0RW5kQ2hpbGQoIGVsZW1lbnRDb3B5ICk7CgkJZG9jLkluc2VydEVuZENoaWxkKCB1bmtub3duQXNzaWduICk7CgoJCVRpWG1sRG9jdW1lbnQgZG9jQ29weSggZG9jICk7CgkJVGlYbWxEb2N1bWVudCBkb2NBc3NpZ247CgkJZG9jQXNzaWduID0gZG9jQ29weTsKCgkJI2lmZGVmIFRJWE1MX1VTRV9TVEwKCQlzdGQ6OnN0cmluZyBvcmlnaW5hbCwgY29weSwgYXNzaWduOwoJCW9yaWdpbmFsIDw8IGRvYzsKCQljb3B5IDw8IGRvY0NvcHk7CgkJYXNzaWduIDw8IGRvY0Fzc2lnbjsKCQlYbWxUZXN0KCAiQ29weS9Bc3NpZ246IGRvY3VtZW50IGNvcHkuIiwgb3JpZ2luYWwuY19zdHIoKSwgY29weS5jX3N0cigpLCB0cnVlICk7CgkJWG1sVGVzdCggIkNvcHkvQXNzaWduOiBkb2N1bWVudCBhc3NpZ24uIiwgb3JpZ2luYWwuY19zdHIoKSwgYXNzaWduLmNfc3RyKCksIHRydWUgKTsKCgkJI2VuZGlmCgl9CQoKCS8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLwojaWZkZWYgVElYTUxfVVNFX1NUTAoJcHJpbnRmICgiXG4qKiBQYXJzaW5nLCBubyBDb25kZW5zZSBXaGl0ZXNwYWNlICoqXG4iKTsKCVRpWG1sQmFzZTo6U2V0Q29uZGVuc2VXaGl0ZVNwYWNlKCBmYWxzZSApOwoKCWlzdHJpbmdzdHJlYW0gcGFyc2UxKCAiPHN0YXJ0PlRoaXMgIGlzICAgIFxudGV4dDwvc3RhcnQ+IiApOwoJVGlYbWxFbGVtZW50IHRleHQxKCAidGV4dCIgKTsKCXBhcnNlMSA+PiB0ZXh0MTsKCglYbWxUZXN0ICggIkNvbmRlbnNlIHdoaXRlIHNwYWNlIE9GRi4iLCAiVGhpcyAgaXMgICAgXG50ZXh0IiwKCQkJCXRleHQxLkZpcnN0Q2hpbGQoKS0+VmFsdWUoKSwKCQkJCXRydWUgKTsKCglUaVhtbEJhc2U6OlNldENvbmRlbnNlV2hpdGVTcGFjZSggdHJ1ZSApOwojZW5kaWYKCgkvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KCS8vIEdldFRleHQoKTsKCXsKCQljb25zdCBjaGFyKiBzdHIgPSAiPGZvbz5UaGlzIGlzIHRleHQ8L2Zvbz4iOwoJCVRpWG1sRG9jdW1lbnQgZG9jOwoJCWRvYy5QYXJzZSggc3RyICk7CgkJY29uc3QgVGlYbWxFbGVtZW50KiBlbGVtZW50ID0gZG9jLlJvb3RFbGVtZW50KCk7CgoJCVhtbFRlc3QoICJHZXRUZXh0KCkgbm9ybWFsIHVzZS4iLCAiVGhpcyBpcyB0ZXh0IiwgZWxlbWVudC0+R2V0VGV4dCgpICk7CgoJCXN0ciA9ICI8Zm9vPjxiPlRoaXMgaXMgdGV4dDwvYj48L2Zvbz4iOwoJCWRvYy5DbGVhcigpOwoJCWRvYy5QYXJzZSggc3RyICk7CgkJZWxlbWVudCA9IGRvYy5Sb290RWxlbWVudCgpOwoKCQlYbWxUZXN0KCAiR2V0VGV4dCgpIGNvbnRhaW5lZCBlbGVtZW50LiIsIGVsZW1lbnQtPkdldFRleHQoKSA9PSAwLCB0cnVlICk7CgoJCXN0ciA9ICI8Zm9vPlRoaXMgaXMgPGI+dGV4dDwvYj48L2Zvbz4iOwoJCWRvYy5DbGVhcigpOwoJCVRpWG1sQmFzZTo6U2V0Q29uZGVuc2VXaGl0ZVNwYWNlKCBmYWxzZSApOwoJCWRvYy5QYXJzZSggc3RyICk7CgkJVGlYbWxCYXNlOjpTZXRDb25kZW5zZVdoaXRlU3BhY2UoIHRydWUgKTsKCQllbGVtZW50ID0gZG9jLlJvb3RFbGVtZW50KCk7CgoJCVhtbFRlc3QoICJHZXRUZXh0KCkgcGFydGlhbC4iLCAiVGhpcyBpcyAiLCBlbGVtZW50LT5HZXRUZXh0KCkgKTsKCX0KCgoJLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vCgkvLyBDREFUQQoJewoJCWNvbnN0IGNoYXIqIHN0ciA9CSI8eG1sRWxlbWVudD4iCgkJCQkJCQkJIjwhW0NEQVRBWyIKCQkJCQkJCQkJIkkgYW0gPiB0aGUgcnVsZXMhXG4iCgkJCQkJCQkJCSIuLi5zaW5jZSBJIG1ha2Ugc3ltYm9saWMgcHVucyIKCQkJCQkJCQkiXV0+IgoJCQkJCQkJIjwveG1sRWxlbWVudD4iOwoJCVRpWG1sRG9jdW1lbnQgZG9jOwoJCWRvYy5QYXJzZSggc3RyICk7CgkJLy9kb2MuUHJpbnQoKTsKCgkJWG1sVGVzdCggIkNEQVRBIHBhcnNlLiIsIGRvYy5GaXJzdENoaWxkRWxlbWVudCgpLT5GaXJzdENoaWxkKCktPlZhbHVlKCksIAoJCQkJCQkJCSAiSSBhbSA+IHRoZSBydWxlcyFcbi4uLnNpbmNlIEkgbWFrZSBzeW1ib2xpYyBwdW5zIiwKCQkJCQkJCQkgdHJ1ZSApOwoKCQkjaWZkZWYgVElYTUxfVVNFX1NUTAoJCS8vY291dCA8PCBkb2MgPDwgJ1xuJzsKCgkJZG9jLkNsZWFyKCk7CgoJCWlzdHJpbmdzdHJlYW0gcGFyc2UwKCBzdHIgKTsKCQlwYXJzZTAgPj4gZG9jOwoJCS8vY291dCA8PCBkb2MgPDwgJ1xuJzsKCgkJWG1sVGVzdCggIkNEQVRBIHN0cmVhbS4iLCBkb2MuRmlyc3RDaGlsZEVsZW1lbnQoKS0+Rmlyc3RDaGlsZCgpLT5WYWx1ZSgpLCAKCQkJCQkJCQkgIkkgYW0gPiB0aGUgcnVsZXMhXG4uLi5zaW5jZSBJIG1ha2Ugc3ltYm9saWMgcHVucyIsCgkJCQkJCQkJIHRydWUgKTsKCQkjZW5kaWYKCgkJVGlYbWxEb2N1bWVudCBkb2MxID0gZG9jOwoJCS8vZG9jLlByaW50KCk7CgoJCVhtbFRlc3QoICJDREFUQSBjb3B5LiIsIGRvYzEuRmlyc3RDaGlsZEVsZW1lbnQoKS0+Rmlyc3RDaGlsZCgpLT5WYWx1ZSgpLCAKCQkJCQkJCQkgIkkgYW0gPiB0aGUgcnVsZXMhXG4uLi5zaW5jZSBJIG1ha2Ugc3ltYm9saWMgcHVucyIsCgkJCQkJCQkJIHRydWUgKTsKCX0KCgoJLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vCglwcmludGYgKCJcbioqIEJ1ZyByZWdyZXNzaW9uIHRlc3RzICoqXG4iKTsKCgkvLyBJbnNlcnRCZWZvcmVDaGlsZCBhbmQgSW5zZXJ0QWZ0ZXJDaGlsZCBjYXVzZXMgY3Jhc2guCgl7CgkJVGlYbWxFbGVtZW50IHBhcmVudCggIlBhcmVudCIgKTsKCQlUaVhtbEVsZW1lbnQgY2hpbGRUZXh0MCggImNoaWxkVGV4dDAiICk7CgkJVGlYbWxFbGVtZW50IGNoaWxkVGV4dDEoICJjaGlsZFRleHQxIiApOwoJCVRpWG1sTm9kZSogY2hpbGROb2RlMCA9IHBhcmVudC5JbnNlcnRFbmRDaGlsZCggY2hpbGRUZXh0MCApOwoJCVRpWG1sTm9kZSogY2hpbGROb2RlMSA9IHBhcmVudC5JbnNlcnRCZWZvcmVDaGlsZCggY2hpbGROb2RlMCwgY2hpbGRUZXh0MSApOwoKCQlYbWxUZXN0KCAiVGVzdCBJbnNlcnRCZWZvcmVDaGlsZCBvbiBlbXB0eSBub2RlLiIsICggY2hpbGROb2RlMSA9PSBwYXJlbnQuRmlyc3RDaGlsZCgpICksIHRydWUgKTsKCX0KCgl7CgkJLy8gSW5zZXJ0QmVmb3JlQ2hpbGQgYW5kIEluc2VydEFmdGVyQ2hpbGQgY2F1c2VzIGNyYXNoLgoJCVRpWG1sRWxlbWVudCBwYXJlbnQoICJQYXJlbnQiICk7CgkJVGlYbWxFbGVtZW50IGNoaWxkVGV4dDAoICJjaGlsZFRleHQwIiApOwoJCVRpWG1sRWxlbWVudCBjaGlsZFRleHQxKCAiY2hpbGRUZXh0MSIgKTsKCQlUaVhtbE5vZGUqIGNoaWxkTm9kZTAgPSBwYXJlbnQuSW5zZXJ0RW5kQ2hpbGQoIGNoaWxkVGV4dDAgKTsKCQlUaVhtbE5vZGUqIGNoaWxkTm9kZTEgPSBwYXJlbnQuSW5zZXJ0QWZ0ZXJDaGlsZCggY2hpbGROb2RlMCwgY2hpbGRUZXh0MSApOwoKCQlYbWxUZXN0KCAiVGVzdCBJbnNlcnRBZnRlckNoaWxkIG9uIGVtcHR5IG5vZGUuICIsICggY2hpbGROb2RlMSA9PSBwYXJlbnQuTGFzdENoaWxkKCkgKSwgdHJ1ZSApOwoJfQoKCS8vIFJlcG9ydHMgb2YgbWlzc2luZyBjb25zdHJ1Y3RvcnMsIGlycmVndWxhciBzdHJpbmcgcHJvYmxlbXMuCgl7CgkJLy8gTWlzc2luZyBjb25zdHJ1Y3RvciBpbXBsZW1lbnRhdGlvbi4gTm8gdGVzdCAtLSBqdXN0IGNvbXBpbGVzLgoJCVRpWG1sVGV4dCB0ZXh0KCAiTWlzc2luZyIgKTsKCgkJI2lmZGVmIFRJWE1MX1VTRV9TVEwKCQkJLy8gTWlzc2luZyBpbXBsZW1lbnRhdGlvbjoKCQkJVGlYbWxEb2N1bWVudCBkb2M7CgkJCXN0cmluZyBuYW1lID0gIm1pc3NpbmciOwoJCQlkb2MuTG9hZEZpbGUoIG5hbWUgKTsKCgkJCVRpWG1sVGV4dCB0ZXh0U1RMKCBuYW1lICk7CgkJI2Vsc2UKCQkJLy8gdmVyaWZ5aW5nIHNvbWUgYmFzaWMgc3RyaW5nIGZ1bmN0aW9uczoKCQkJVGlYbWxTdHJpbmcgYTsKCQkJVGlYbWxTdHJpbmcgYiggIkhlbGxvIiApOwoJCQlUaVhtbFN0cmluZyBjKCAib29nYSIgKTsKCgkJCWMgPSAiIFdvcmxkISI7CgkJCWEgPSBiOwoJCQlhICs9IGM7CgkJCWEgPSBhOwoKCQkJWG1sVGVzdCggIkJhc2ljIFRpWG1sU3RyaW5nIHRlc3QuICIsICJIZWxsbyBXb3JsZCEiLCBhLmNfc3RyKCkgKTsKCQkjZW5kaWYKIAl9CgoJLy8gTG9uZyBmaWxlbmFtZXMgY3Jhc2hpbmcgU1RMIHZlcnNpb24KCXsKCQlUaVhtbERvY3VtZW50IGRvYyggIm1pZHN1bW1lck5pZ2h0c0RyZWFtV2l0aEFWZXJ5TG9uZ0ZpbGVuYW1lVG9Db25mdXNlVGhlU3RyaW5nSGFuZGxpbmdSb3V0aW5lcy54bWwiICk7CgkJYm9vbCBsb2FkT2theSA9IGRvYy5Mb2FkRmlsZSgpOwoJCWxvYWRPa2F5ID0gdHJ1ZTsJLy8gZ2V0IHJpZCBvZiBjb21waWxlciB3YXJuaW5nLgoJCS8vIFdvbid0IHBhc3Mgb24gbm9uLWRldiBzeXN0ZW1zLiBKdXN0IGEgIm5vIGNyYXNoIiBjaGVjay4KCQkvL1htbFRlc3QoICJMb25nIGZpbGVuYW1lLiAiLCB0cnVlLCBsb2FkT2theSApOwoJfQoKCXsKCQkvLyBFbnRpdGllcyBub3QgYmVpbmcgd3JpdHRlbiBjb3JyZWN0bHkuCgkJLy8gRnJvbSBMeW5uIEFsbGVuCgoJCWNvbnN0IGNoYXIqIHBhc3NhZ2VzID0KCQkJIjw/eG1sIHZlcnNpb249XCIxLjBcIiBzdGFuZGFsb25lPVwibm9cIiA/PiIKCQkJIjxwYXNzYWdlcyBjb3VudD1cIjAwNlwiIGZvcm1hdHZlcnNpb249XCIyMDAyMDYyMFwiPiIKCQkJCSI8cHNnIGNvbnRleHQ9XCJMaW5lIDUgaGFzICZxdW90O3F1b3RhdGlvbiBtYXJrcyZxdW90OyBhbmQgJmFwb3M7YXBvc3Ryb3BoZSBtYXJrcyZhcG9zOy4iCgkJCQkiIEl0IGFsc28gaGFzICZsdDssICZndDssIGFuZCAmYW1wOywgYXMgd2VsbCBhcyBhIGZha2UgY29weXJpZ2h0ICYjeEE5Oy5cIj4gPC9wc2c+IgoJCQkiPC9wYXNzYWdlcz4iOwoKCQlUaVhtbERvY3VtZW50IGRvYyggInBhc3NhZ2VzLnhtbCIgKTsKCQlkb2MuUGFyc2UoIHBhc3NhZ2VzICk7CgkJVGlYbWxFbGVtZW50KiBwc2cgPSBkb2MuUm9vdEVsZW1lbnQoKS0+Rmlyc3RDaGlsZEVsZW1lbnQoKTsKCQljb25zdCBjaGFyKiBjb250ZXh0ID0gcHNnLT5BdHRyaWJ1dGUoICJjb250ZXh0IiApOwoJCWNvbnN0IGNoYXIqIGV4cGVjdGVkID0gIkxpbmUgNSBoYXMgXCJxdW90YXRpb24gbWFya3NcIiBhbmQgJ2Fwb3N0cm9waGUgbWFya3MnLiBJdCBhbHNvIGhhcyA8LCA+LCBhbmQgJiwgYXMgd2VsbCBhcyBhIGZha2UgY29weXJpZ2h0IFx4QzJceEE5LiI7CgoJCVhtbFRlc3QoICJFbnRpdHkgdHJhbnNmb3JtYXRpb246IHJlYWQuICIsIGV4cGVjdGVkLCBjb250ZXh0LCB0cnVlICk7CgoJCUZJTEUqIHRleHRmaWxlID0gZm9wZW4oICJ0ZXh0ZmlsZS50eHQiLCAidyIgKTsKCQlpZiAoIHRleHRmaWxlICkKCQl7CgkJCXBzZy0+UHJpbnQoIHRleHRmaWxlLCAwICk7CgkJCWZjbG9zZSggdGV4dGZpbGUgKTsKCQl9CgkJdGV4dGZpbGUgPSBmb3BlbiggInRleHRmaWxlLnR4dCIsICJyIiApOwoJCWFzc2VydCggdGV4dGZpbGUgKTsKCQlpZiAoIHRleHRmaWxlICkKCQl7CgkJCWNoYXIgYnVmWyAxMDI0IF07CgkJCWZnZXRzKCBidWYsIDEwMjQsIHRleHRmaWxlICk7CgkJCVhtbFRlc3QoICJFbnRpdHkgdHJhbnNmb3JtYXRpb246IHdyaXRlLiAiLAoJCQkJCSAiPHBzZyBjb250ZXh0PVwnTGluZSA1IGhhcyAmcXVvdDtxdW90YXRpb24gbWFya3MmcXVvdDsgYW5kICZhcG9zO2Fwb3N0cm9waGUgbWFya3MmYXBvczsuIgoJCQkJCSAiIEl0IGFsc28gaGFzICZsdDssICZndDssIGFuZCAmYW1wOywgYXMgd2VsbCBhcyBhIGZha2UgY29weXJpZ2h0IFx4QzJceEE5LicgLz4iLAoJCQkJCSBidWYsCgkJCQkJIHRydWUgKTsKCQl9CgkJZmNsb3NlKCB0ZXh0ZmlsZSApOwoJfQoKICAgIHsKCQlGSUxFKiB0ZXh0ZmlsZSA9IGZvcGVuKCAidGVzdDUueG1sIiwgInciICk7CgkJaWYgKCB0ZXh0ZmlsZSApCgkJewogICAgICAgICAgICBmcHV0cygiPD94bWwgdmVyc2lvbj0nMS4wJz8+PGEuZWxlbSB4bWkudmVyc2lvbj0nMi4wJy8+IiwgdGV4dGZpbGUpOwogICAgICAgICAgICBmY2xvc2UodGV4dGZpbGUpOwoKCQkJVGlYbWxEb2N1bWVudCBkb2M7CiAgICAgICAgICAgIGRvYy5Mb2FkRmlsZSggInRlc3Q1LnhtbCIgKTsKICAgICAgICAgICAgWG1sVGVzdCggImRvdCBpbiBlbGVtZW50IGF0dHJpYnV0ZXMgYW5kIG5hbWVzIiwgZG9jLkVycm9yKCksIDApOwoJCX0KICAgIH0KCgl7CgkJRklMRSogdGV4dGZpbGUgPSBmb3BlbiggInRlc3Q2LnhtbCIsICJ3IiApOwoJCWlmICggdGV4dGZpbGUgKQoJCXsKICAgICAgICAgICAgZnB1dHMoIjxlbGVtZW50PjxOYW1lPjEuMSBTdGFydCBlYXN5IGlnbm9yZSBmaW4gdGhpY2tuZXNzJiN4QTs8L05hbWU+PC9lbGVtZW50PiIsIHRleHRmaWxlICk7CiAgICAgICAgICAgIGZjbG9zZSh0ZXh0ZmlsZSk7CgogICAgICAgICAgICBUaVhtbERvY3VtZW50IGRvYzsKICAgICAgICAgICAgYm9vbCByZXN1bHQgPSBkb2MuTG9hZEZpbGUoICJ0ZXN0Ni54bWwiICk7CiAgICAgICAgICAgIFhtbFRlc3QoICJFbnRpdHkgd2l0aCBvbmUgZGlnaXQuIiwgcmVzdWx0LCB0cnVlICk7CgoJCQlUaVhtbFRleHQqIHRleHQgPSBkb2MuRmlyc3RDaGlsZEVsZW1lbnQoKS0+Rmlyc3RDaGlsZEVsZW1lbnQoKS0+Rmlyc3RDaGlsZCgpLT5Ub1RleHQoKTsKCQkJWG1sVGVzdCggIkVudGl0eSB3aXRoIG9uZSBkaWdpdC4iLAoJCQkJCQl0ZXh0LT5WYWx1ZSgpLCAiMS4xIFN0YXJ0IGVhc3kgaWdub3JlIGZpbiB0aGlja25lc3NcbiIgKTsKCQl9CiAgICB9CgoJewoJCS8vIERPQ1RZUEUgbm90IHByZXNlcnZlZCAoOTUwMTcxKQoJCS8vIAoJCWNvbnN0IGNoYXIqIGRvY3R5cGUgPQoJCQkiPD94bWwgdmVyc2lvbj1cIjEuMFwiID8+IgoJCQkiPCFET0NUWVBFIFBMQVkgU1lTVEVNICdwbGF5LmR0ZCc+IgoJCQkiPCFFTEVNRU5UIHRpdGxlICgjUENEQVRBKT4iCgkJCSI8IUVMRU1FTlQgYm9va3MgKHRpdGxlLGF1dGhvcnMpPiIKCQkJIjxlbGVtZW50IC8+IjsKCgkJVGlYbWxEb2N1bWVudCBkb2M7CgkJZG9jLlBhcnNlKCBkb2N0eXBlICk7CgkJZG9jLlNhdmVGaWxlKCAidGVzdDcueG1sIiApOwoJCWRvYy5DbGVhcigpOwoJCWRvYy5Mb2FkRmlsZSggInRlc3Q3LnhtbCIgKTsKCQkKCQlUaVhtbEhhbmRsZSBkb2NIKCAmZG9jICk7CgkJVGlYbWxVbmtub3duKiB1bmtub3duID0gZG9jSC5DaGlsZCggMSApLlVua25vd24oKTsKCQlYbWxUZXN0KCAiQ29ycmVjdCB2YWx1ZSBvZiB1bmtub3duLiIsICIhRE9DVFlQRSBQTEFZIFNZU1RFTSAncGxheS5kdGQnIiwgdW5rbm93bi0+VmFsdWUoKSApOwoJCSNpZmRlZiBUSVhNTF9VU0VfU1RMCgkJVGlYbWxOb2RlKiBub2RlID0gZG9jSC5DaGlsZCggMiApLk5vZGUoKTsKCQlzdGQ6OnN0cmluZyBzdHI7CgkJc3RyIDw8ICgqbm9kZSk7CgkJWG1sVGVzdCggIkNvcnJlY3Qgc3RyZWFtaW5nIG9mIHVua25vd24uIiwgIjwhRUxFTUVOVCB0aXRsZSAoI1BDREFUQSk+Iiwgc3RyLmNfc3RyKCkgKTsKCQkjZW5kaWYKCX0KCgl7CgkJLy8gWyA3OTE0MTEgXSBGb3JtYXR0aW5nIGJ1ZwoJCS8vIENvbW1lbnRzIGRvIG5vdCBzdHJlYW0gb3V0IGNvcnJlY3RseS4KCQljb25zdCBjaGFyKiBkb2N0eXBlID0gCgkJCSI8IS0tIFNvbWV3aGF0PGV2aWw+IC0tPiI7CgkJVGlYbWxEb2N1bWVudCBkb2M7CgkJZG9jLlBhcnNlKCBkb2N0eXBlICk7CgoJCVRpWG1sSGFuZGxlIGRvY0goICZkb2MgKTsKCQlUaVhtbENvbW1lbnQqIGNvbW1lbnQgPSBkb2NILkNoaWxkKCAwICkuTm9kZSgpLT5Ub0NvbW1lbnQoKTsKCgkJWG1sVGVzdCggIkNvbW1lbnQgZm9ybWF0dGluZy4iLCAiIFNvbWV3aGF0PGV2aWw+ICIsIGNvbW1lbnQtPlZhbHVlKCkgKTsKCQkjaWZkZWYgVElYTUxfVVNFX1NUTAoJCXN0ZDo6c3RyaW5nIHN0cjsKCQlzdHIgPDwgKCpjb21tZW50KTsKCQlYbWxUZXN0KCAiQ29tbWVudCBzdHJlYW1pbmcuIiwgIjwhLS0gU29tZXdoYXQ8ZXZpbD4gLS0+Iiwgc3RyLmNfc3RyKCkgKTsKCQkjZW5kaWYKCX0KCgl7CgkJLy8gWyA4NzA1MDIgXSBXaGl0ZSBzcGFjZSBpc3N1ZXMKCQlUaVhtbERvY3VtZW50IGRvYzsKCQlUaVhtbFRleHQqIHRleHQ7CgkJVGlYbWxIYW5kbGUgZG9jSCggJmRvYyApOwoJCgkJY29uc3QgY2hhciogZG9jdHlwZTAgPSAiPGVsZW1lbnQ+IFRoaXMgaGFzIGxlYWRpbmcgYW5kIHRyYWlsaW5nIHNwYWNlIDwvZWxlbWVudD4iOwoJCWNvbnN0IGNoYXIqIGRvY3R5cGUxID0gIjxlbGVtZW50PlRoaXMgaGFzICBpbnRlcm5hbCBzcGFjZTwvZWxlbWVudD4iOwoJCWNvbnN0IGNoYXIqIGRvY3R5cGUyID0gIjxlbGVtZW50PiBUaGlzIGhhcyBsZWFkaW5nLCB0cmFpbGluZywgYW5kICBpbnRlcm5hbCBzcGFjZSA8L2VsZW1lbnQ+IjsKCgkJVGlYbWxCYXNlOjpTZXRDb25kZW5zZVdoaXRlU3BhY2UoIGZhbHNlICk7CgkJZG9jLkNsZWFyKCk7CgkJZG9jLlBhcnNlKCBkb2N0eXBlMCApOwoJCXRleHQgPSBkb2NILkZpcnN0Q2hpbGRFbGVtZW50KCAiZWxlbWVudCIgKS5DaGlsZCggMCApLlRleHQoKTsKCQlYbWxUZXN0KCAiV2hpdGUgc3BhY2Uga2VwdC4iLCAiIFRoaXMgaGFzIGxlYWRpbmcgYW5kIHRyYWlsaW5nIHNwYWNlICIsIHRleHQtPlZhbHVlKCkgKTsKCgkJZG9jLkNsZWFyKCk7CgkJZG9jLlBhcnNlKCBkb2N0eXBlMSApOwoJCXRleHQgPSBkb2NILkZpcnN0Q2hpbGRFbGVtZW50KCAiZWxlbWVudCIgKS5DaGlsZCggMCApLlRleHQoKTsKCQlYbWxUZXN0KCAiV2hpdGUgc3BhY2Uga2VwdC4iLCAiVGhpcyBoYXMgIGludGVybmFsIHNwYWNlIiwgdGV4dC0+VmFsdWUoKSApOwoKCQlkb2MuQ2xlYXIoKTsKCQlkb2MuUGFyc2UoIGRvY3R5cGUyICk7CgkJdGV4dCA9IGRvY0guRmlyc3RDaGlsZEVsZW1lbnQoICJlbGVtZW50IiApLkNoaWxkKCAwICkuVGV4dCgpOwoJCVhtbFRlc3QoICJXaGl0ZSBzcGFjZSBrZXB0LiIsICIgVGhpcyBoYXMgbGVhZGluZywgdHJhaWxpbmcsIGFuZCAgaW50ZXJuYWwgc3BhY2UgIiwgdGV4dC0+VmFsdWUoKSApOwoKCQlUaVhtbEJhc2U6OlNldENvbmRlbnNlV2hpdGVTcGFjZSggdHJ1ZSApOwoJCWRvYy5DbGVhcigpOwoJCWRvYy5QYXJzZSggZG9jdHlwZTAgKTsKCQl0ZXh0ID0gZG9jSC5GaXJzdENoaWxkRWxlbWVudCggImVsZW1lbnQiICkuQ2hpbGQoIDAgKS5UZXh0KCk7CgkJWG1sVGVzdCggIldoaXRlIHNwYWNlIGNvbmRlbnNlZC4iLCAiVGhpcyBoYXMgbGVhZGluZyBhbmQgdHJhaWxpbmcgc3BhY2UiLCB0ZXh0LT5WYWx1ZSgpICk7CgoJCWRvYy5DbGVhcigpOwoJCWRvYy5QYXJzZSggZG9jdHlwZTEgKTsKCQl0ZXh0ID0gZG9jSC5GaXJzdENoaWxkRWxlbWVudCggImVsZW1lbnQiICkuQ2hpbGQoIDAgKS5UZXh0KCk7CgkJWG1sVGVzdCggIldoaXRlIHNwYWNlIGNvbmRlbnNlZC4iLCAiVGhpcyBoYXMgaW50ZXJuYWwgc3BhY2UiLCB0ZXh0LT5WYWx1ZSgpICk7CgoJCWRvYy5DbGVhcigpOwoJCWRvYy5QYXJzZSggZG9jdHlwZTIgKTsKCQl0ZXh0ID0gZG9jSC5GaXJzdENoaWxkRWxlbWVudCggImVsZW1lbnQiICkuQ2hpbGQoIDAgKS5UZXh0KCk7CgkJWG1sVGVzdCggIldoaXRlIHNwYWNlIGNvbmRlbnNlZC4iLCAiVGhpcyBoYXMgbGVhZGluZywgdHJhaWxpbmcsIGFuZCBpbnRlcm5hbCBzcGFjZSIsIHRleHQtPlZhbHVlKCkgKTsKCX0KCgl7CgkJLy8gRG91YmxlIGF0dHJpYnV0ZXMKCQljb25zdCBjaGFyKiBkb2N0eXBlID0gIjxlbGVtZW50IGF0dHI9J3JlZCcgYXR0cj0nYmx1ZScgLz4iOwoKCQlUaVhtbERvY3VtZW50IGRvYzsKCQlkb2MuUGFyc2UoIGRvY3R5cGUgKTsKCQkKCQlYbWxUZXN0KCAiUGFyc2luZyByZXBlYXRlZCBhdHRyaWJ1dGVzLiIsIDAsIChpbnQpZG9jLkVycm9yKCkgKTsJLy8gbm90IGFuICBlcnJvciB0byB0aW55eG1sCgkJWG1sVGVzdCggIlBhcnNpbmcgcmVwZWF0ZWQgYXR0cmlidXRlcy4iLCAiYmx1ZSIsIGRvYy5GaXJzdENoaWxkRWxlbWVudCggImVsZW1lbnQiICktPkF0dHJpYnV0ZSggImF0dHIiICkgKTsKCX0KCgl7CgkJLy8gRW1iZWRkZWQgbnVsbCBpbiBzdHJlYW0uCgkJY29uc3QgY2hhciogZG9jdHlwZSA9ICI8ZWxlbWVudCBhdHRcMHI9J3JlZCcgYXR0cj0nYmx1ZScgLz4iOwoKCQlUaVhtbERvY3VtZW50IGRvYzsKCQlkb2MuUGFyc2UoIGRvY3R5cGUgKTsKCQlYbWxUZXN0KCAiRW1iZWRkZWQgbnVsbCB0aHJvd3MgZXJyb3IuIiwgdHJ1ZSwgZG9jLkVycm9yKCkgKTsKCgkJI2lmZGVmIFRJWE1MX1VTRV9TVEwKCQlpc3RyaW5nc3RyZWFtIHN0cm0oIGRvY3R5cGUgKTsKCQlkb2MuQ2xlYXIoKTsKCQlkb2MuQ2xlYXJFcnJvcigpOwoJCXN0cm0gPj4gZG9jOwoJCVhtbFRlc3QoICJFbWJlZGRlZCBudWxsIHRocm93cyBlcnJvci4iLCB0cnVlLCBkb2MuRXJyb3IoKSApOwoJCSNlbmRpZgoJfQoKICAgIHsKICAgICAgICAgICAgLy8gTGVnYWN5IG1vZGUgdGVzdC4gKFRoaXMgdGVzdCBtYXkgb25seSBwYXNzIG9uIGEgd2VzdGVybiBzeXN0ZW0pCiAgICAgICAgICAgIGNvbnN0IGNoYXIqIHN0ciA9CiAgICAgICAgICAgICAgICAgICAgICAgICI8P3htbCB2ZXJzaW9uPVwiMS4wXCIgZW5jb2Rpbmc9XCJJU08tODg1OS0xXCI/PiIKICAgICAgICAgICAgICAgICAgICAgICAgIjzkPiIKICAgICAgICAgICAgICAgICAgICAgICAgIkP2bnTkbnTf5Pb8xNbcIgogICAgICAgICAgICAgICAgICAgICAgICAiPC/kPiI7CgogICAgICAgICAgICBUaVhtbERvY3VtZW50IGRvYzsKICAgICAgICAgICAgZG9jLlBhcnNlKCBzdHIgKTsKCgkJCS8vZG9jLlByaW50KCBzdGRvdXQsIDAgKTsKCiAgICAgICAgICAgIFRpWG1sSGFuZGxlIGRvY0hhbmRsZSggJmRvYyApOwogICAgICAgICAgICBUaVhtbEhhbmRsZSBhSGFuZGxlID0gZG9jSGFuZGxlLkZpcnN0Q2hpbGRFbGVtZW50KCAi5CIgKTsKICAgICAgICAgICAgVGlYbWxIYW5kbGUgdEhhbmRsZSA9IGFIYW5kbGUuQ2hpbGQoIDAgKTsKICAgICAgICAgICAgYXNzZXJ0KCBhSGFuZGxlLkVsZW1lbnQoKSApOwogICAgICAgICAgICBhc3NlcnQoIHRIYW5kbGUuVGV4dCgpICk7CiAgICAgICAgICAgIFhtbFRlc3QoICJJU08tODg1OS0xIFBhcnNpbmcuIiwgIkP2bnTkbnTf5Pb8xNbcIiwgdEhhbmRsZS5UZXh0KCktPlZhbHVlKCkgKTsKICAgIH0KCgl7CgkJLy8gRW1wdHkgZG9jdW1lbnRzIHNob3VsZCByZXR1cm4gVElYTUxfRVJST1JfUEFSU0lOR19FTVBUWSwgYnVnIDEwNzA3MTcKCQljb25zdCBjaGFyKiBzdHIgPSAiICAgICI7CgkJVGlYbWxEb2N1bWVudCBkb2M7CgkJZG9jLlBhcnNlKCBzdHIgKTsKCQlYbWxUZXN0KCAiRW1wdHkgZG9jdW1lbnQgZXJyb3IgVElYTUxfRVJST1JfRE9DVU1FTlRfRU1QVFkiLCBUaVhtbEJhc2U6OlRJWE1MX0VSUk9SX0RPQ1VNRU5UX0VNUFRZLCBkb2MuRXJyb3JJZCgpICk7Cgl9CgkjaWZuZGVmIFRJWE1MX1VTRV9TVEwKCXsKCQkvLyBTdHJpbmcgZXF1YWxpdHkuIFsgMTAwNjQwOSBdIHN0cmluZyBvcGVyYXRvcj09LyE9IG5vIHdvcmt5IGluIGFsbCBjYXNlcwoJCVRpWG1sU3RyaW5nIHRlbXA7CgkJWG1sVGVzdCggIkVtcHR5IHRpbnl4bWwgc3RyaW5nIGNvbXBhcmUgZXF1YWwiLCAoIHRlbXAgPT0gIiIgKSwgdHJ1ZSApOwoKCQlUaVhtbFN0cmluZyAgICBmb287CgkJVGlYbWxTdHJpbmcgICAgYmFyKCAiIiApOwoJCVhtbFRlc3QoICJFbXB0eSB0aW55eG1sIHN0cmluZyBjb21wYXJlIGVxdWFsIiwgKCBmb28gPT0gYmFyICksIHRydWUgKTsKCX0KCgkjZW5kaWYKCXsKCQkvLyBCdWcgWyAxMTk1Njk2IF0gZnJvbSBtYXJsb25pc20KCQlUaVhtbEJhc2U6OlNldENvbmRlbnNlV2hpdGVTcGFjZShmYWxzZSk7IAoJCVRpWG1sRG9jdW1lbnQgeG1sOyAKCQl4bWwuUGFyc2UoIjx0ZXh0PjxicmVhay8+VGhpcyBoYW5nczwvdGV4dD4iKTsgCgkJWG1sVGVzdCggIlRlc3Qgc2FmZSBlcnJvciByZXR1cm4uIiwgeG1sLkVycm9yKCksIGZhbHNlICk7Cgl9CgoJewoJCS8vIEJ1ZyBbIDEyNDM5OTIgXSAtIGFub3RoZXIgaW5maW5pdGUgbG9vcAoJCVRpWG1sRG9jdW1lbnQgZG9jOwoJCWRvYy5TZXRDb25kZW5zZVdoaXRlU3BhY2UoZmFsc2UpOwoJCWRvYy5QYXJzZSgiPHA+PHBiPjwvcGI+dGVzdDwvcD4iKTsKCX0gCgl7CgkJLy8gTG93IGVudGl0aWVzCgkJVGlYbWxEb2N1bWVudCB4bWw7CgkJeG1sLlBhcnNlKCAiPHRlc3Q+JiN4MGU7PC90ZXN0PiIgKTsKCQljb25zdCBjaGFyIHJlc3VsdFtdID0geyAweDBlLCAwIH07CgkJWG1sVGVzdCggIkxvdyBlbnRpdGllcy4iLCB4bWwuRmlyc3RDaGlsZEVsZW1lbnQoKS0+R2V0VGV4dCgpLCByZXN1bHQgKTsKCQl4bWwuUHJpbnQoKTsKCX0KCgkjaWYgZGVmaW5lZCggV0lOMzIgKSAmJiBkZWZpbmVkKCBUVU5FICkKCVF1ZXJ5UGVyZm9ybWFuY2VDb3VudGVyKCAoTEFSR0VfSU5URUdFUiopICgmZW5kKSApOwoJUXVlcnlQZXJmb3JtYW5jZUZyZXF1ZW5jeSggKExBUkdFX0lOVEVHRVIqKSAoJmZyZXEpICk7CglwcmludGYoICJUaW1lIGZvciBydW46ICVmXG4iLCAoIGRvdWJsZSApKCBlbmQtc3RhcnQgKSAvIChkb3VibGUpIGZyZXEgKTsKCSNlbmRpZgoKCXByaW50ZiAoIlxuUGFzcyAlZCwgRmFpbCAlZFxuIiwgZ1Bhc3MsIGdGYWlsKTsKCXJldHVybiBnRmFpbDsKfQoKCg==