IyEvdXNyL2Jpbi9wZXJsIC13VAojIC0qLSBNb2RlOiBwZXJsOyBpbmRlbnQtdGFicy1tb2RlOiBuaWwgLSotCiMKIyBUaGUgY29udGVudHMgb2YgdGhpcyBmaWxlIGFyZSBzdWJqZWN0IHRvIHRoZSBNb3ppbGxhIFB1YmxpYwojIExpY2Vuc2UgVmVyc2lvbiAxLjEgKHRoZSAiTGljZW5zZSIpOyB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlCiMgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS4gWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mCiMgdGhlIExpY2Vuc2UgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvCiMKIyBTb2Z0d2FyZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAiQVMKIyBJUyIgYmFzaXMsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yCiMgaW1wbGllZC4gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nCiMgcmlnaHRzIGFuZCBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4KIwojIFRoZSBPcmlnaW5hbCBDb2RlIGlzIG1vemlsbGEub3JnIGNvZGUuCiMKIyBUaGUgSW5pdGlhbCBEZXZlbG9wZXIgb2YgdGhlIE9yaWdpbmFsIENvZGUgaXMgSG9sZ2VyCiMgU2NodXJpZy4gUG9ydGlvbnMgY3JlYXRlZCBieSBIb2xnZXIgU2NodXJpZyBhcmUKIyBDb3B5cmlnaHQgKEMpIDE5OTkgSG9sZ2VyIFNjaHVyaWcuIEFsbAojIFJpZ2h0cyBSZXNlcnZlZC4KIwojIENvbnRyaWJ1dG9yKHMpOiBIb2xnZXIgU2NodXJpZyA8aG9sZ2Vyc2NodXJpZ0BuaWtvY2l0eS5kZT4KIyAgICAgICAgICAgICAgIFRlcnJ5IFdlaXNzbWFuIDx0ZXJyeUBtb3ppbGxhLm9yZz4KIyAgICAgICAgICAgICAgIERhd24gRW5kaWNvIDxlbmRpY29AbW96aWxsYS5vcmc+CiMgICAgICAgICAgICAgICBKb2UgUm9iaW5zIDxqbXJvYmluc0B0Z2l4LmNvbT4KIyAgICAgICAgICAgICAgIEdhdmluIFNoZWxsZXkgPGJ1Z3ppbGxhQGNoaW1weWNob21weS5vcmc+CiMgICAgICAgICAgICAgICBGculk6XJpYyBCdWNsaW4gPExwU29saXRAZ21haWwuY29tPgojICAgICAgICAgICAgICAgR3JlZyBIZW5kcmlja3MgPGdoZW5kcmlja3NAbm92ZWxsLmNvbT4KIwojIERpcmVjdCBhbnkgcXVlc3Rpb25zIG9uIHRoaXMgc291cmNlIGNvZGUgdG8KIwojIEhvbGdlciBTY2h1cmlnIDxob2xnZXJzY2h1cmlnQG5pa29jaXR5LmRlPgoKdXNlIHN0cmljdDsKdXNlIGxpYiAiLiI7CnVzZSB2YXJzIHF3ICgkdGVtcGxhdGUgJHZhcnMpOwp1c2UgQnVnemlsbGE6OkNvbnN0YW50czsKcmVxdWlyZSAiQ0dJLnBsIjsKcmVxdWlyZSAiZ2xvYmFscy5wbCI7CnVzZSBCdWd6aWxsYTo6QnVnOwp1c2UgQnVnemlsbGE6OlNlcmllczsKdXNlIEJ1Z3ppbGxhOjpVc2VyOwp1c2UgQnVnemlsbGE6OkNvbmZpZyBxdyg6REVGQVVMVCAkZGF0YWRpcik7CgojIFNodXQgdXAgbWlzZ3VpZGVkIC13IHdhcm5pbmdzIGFib3V0ICJ1c2VkIG9ubHkgb25jZSIuICAidXNlIHZhcnMiIGp1c3QKIyBkb2Vzbid0IHdvcmsgZm9yIG1lLgp1c2UgdmFycyBxdyhAbGVnYWxfYnVnX3N0YXR1cyBAbGVnYWxfcmVzb2x1dGlvbik7CgpteSAlY3RsID0gKCAKICAgICY6OkNPTlRST0xNQVBOQSA9PiAnTkEnLAogICAgJjo6Q09OVFJPTE1BUFNIT1dOID0+ICdTaG93bicsCiAgICAmOjpDT05UUk9MTUFQREVGQVVMVCA9PiAnRGVmYXVsdCcsCiAgICAmOjpDT05UUk9MTUFQTUFOREFUT1JZID0+ICdNYW5kYXRvcnknCik7CgojIFRlc3RQcm9kdWN0OiAganVzdCByZXR1cm5zIGlmIHRoZSBzcGVjaWZpZWQgcHJvZHVjdCBkb2VzIGV4aXN0cwojIENoZWNrUHJvZHVjdDogc2FtZSBjaGVjaywgb3B0aW9uYWxseSAgZW1pdCBhbiBlcnJvciB0ZXh0CgpzdWIgVGVzdFByb2R1Y3QgKCQpCnsKICAgIG15ICRwcm9kID0gc2hpZnQ7CgogICAgIyBkb2VzIHRoZSBwcm9kdWN0IGV4aXN0PwogICAgU2VuZFNRTCgiU0VMRUNUIG5hbWUKICAgICAgICAgICAgIEZST00gcHJvZHVjdHMKICAgICAgICAgICAgIFdIRVJFIG5hbWU9IiAuIFNxbFF1b3RlKCRwcm9kKSk7CiAgICByZXR1cm4gRmV0Y2hPbmVDb2x1bW4oKTsKfQoKc3ViIENoZWNrUHJvZHVjdCAoJCkKewogICAgbXkgJHByb2QgPSBzaGlmdDsKCiAgICAjIGRvIHdlIGhhdmUgYSBwcm9kdWN0PwogICAgdW5sZXNzICgkcHJvZCkgewogICAgICAgIHByaW50ICJTb3JyeSwgeW91IGhhdmVuJ3Qgc3BlY2lmaWVkIGEgcHJvZHVjdC4iOwogICAgICAgIFB1dFRyYWlsZXIoKTsKICAgICAgICBleGl0OwogICAgfQoKICAgIHVubGVzcyAoVGVzdFByb2R1Y3QgJHByb2QpIHsKICAgICAgICBwcmludCAiU29ycnksIHByb2R1Y3QgJyRwcm9kJyBkb2VzIG5vdCBleGlzdC4iOwogICAgICAgIFB1dFRyYWlsZXIoKTsKICAgICAgICBleGl0OwogICAgfQp9CgojIFRlc3RDbGFzc2lmaWNhdGlvbjogIGp1c3QgcmV0dXJucyBpZiB0aGUgc3BlY2lmaWVkIGNsYXNzaWZpY2F0aW9uIGRvZXMgZXhpc3RzCiMgQ2hlY2tDbGFzc2lmaWNhdGlvbjogc2FtZSBjaGVjaywgb3B0aW9uYWxseSAgZW1pdCBhbiBlcnJvciB0ZXh0CgpzdWIgVGVzdENsYXNzaWZpY2F0aW9uICgkKQp7CiAgICBteSAkY2wgPSBzaGlmdDsKCiAgICAjIGRvZXMgdGhlIGNsYXNzaWZpY2F0aW9uIGV4aXN0PwogICAgU2VuZFNRTCgiU0VMRUNUIG5hbWUKICAgICAgICAgICAgIEZST00gY2xhc3NpZmljYXRpb25zCiAgICAgICAgICAgICBXSEVSRSBuYW1lPSIgLiBTcWxRdW90ZSgkY2wpKTsKICAgIHJldHVybiBGZXRjaE9uZUNvbHVtbigpOwp9CgpzdWIgQ2hlY2tDbGFzc2lmaWNhdGlvbiAoJCkKewogICAgbXkgJGNsID0gc2hpZnQ7CgogICAgIyBkbyB3ZSBoYXZlIGEgY2xhc3NpZmljYXRpb24/CiAgICB1bmxlc3MgKCRjbCkgewogICAgICAgIHByaW50ICJTb3JyeSwgeW91IGhhdmVuJ3Qgc3BlY2lmaWVkIGEgY2xhc3NpZmljYXRpb24uIjsKICAgICAgICBQdXRUcmFpbGVyKCk7CiAgICAgICAgZXhpdDsKICAgIH0KCiAgICB1bmxlc3MgKFRlc3RDbGFzc2lmaWNhdGlvbiAkY2wpIHsKICAgICAgICBwcmludCAiU29ycnksIGNsYXNzaWZpY2F0aW9uICckY2wnIGRvZXMgbm90IGV4aXN0LiI7CiAgICAgICAgUHV0VHJhaWxlcigpOwogICAgICAgIGV4aXQ7CiAgICB9Cn0KCiMgRm9yIHRoZSB0cmFuc2l0aW9uIHBlcmlvZCwgYXMgdGhpcyBmaWxlIGlzIHRlbXBsYXRpc2VkIGJpdCBieSBiaXQsCiMgd2UgbmVlZCB0aGlzIHJvdXRpbmUsIHdoaWNoIGRvZXMgdGhpbmdzIHByb3Blcmx5LCBhbmQgd2lsbAojIGV2ZW50dWFsbHkgYmUgdGhlIG9ubHkgdmVyc2lvbi4gKFRoZSBvbGRlciB2ZXJzaW9ucyBhc3N1bWUgYQojIFB1dEhlYWRlcigpIGNhbGwgaGFzIGJlZW4gbWFkZSkKc3ViIENoZWNrQ2xhc3NpZmljYXRpb25OZXcgKCQpCnsKICAgIG15ICRjbCA9IHNoaWZ0OwoKICAgICMgZG8gd2UgaGF2ZSBhIGNsYXNzaWZpY2F0aW9uPwogICAgdW5sZXNzICgkY2wpIHsKICAgICAgICBUaHJvd1VzZXJFcnJvcignY2xhc3NpZmljYXRpb25fbm90X3NwZWNpZmllZCcpOyAgICAKICAgIH0KCiAgICB1bmxlc3MgKFRlc3RDbGFzc2lmaWNhdGlvbiAkY2wpIHsKICAgICAgICBUaHJvd1VzZXJFcnJvcignY2xhc3NpZmljYXRpb25fZG9lc250X2V4aXN0JywKICAgICAgICAgICAgICAgICAgICAgICB7J25hbWUnID0+ICRjbH0pOwogICAgfQp9CgoKc3ViIENoZWNrQ2xhc3NpZmljYXRpb25Qcm9kdWN0ICgkJCkKewogICAgbXkgJGNsID0gc2hpZnQ7CiAgICBteSAkcHJvZCA9IHNoaWZ0OwogICAgbXkgJGRiaCA9IEJ1Z3ppbGxhLT5kYmg7CgogICAgQ2hlY2tDbGFzc2lmaWNhdGlvbigkY2wpOwogICAgQ2hlY2tQcm9kdWN0KCRwcm9kKTsKCiAgICB0cmlja190YWludCgkcHJvZCk7CiAgICB0cmlja190YWludCgkY2wpOwoKICAgIG15ICRxdWVyeSA9IHF7U0VMRUNUIHByb2R1Y3RzLm5hbWUKICAgICAgICAgICAgICAgICAgRlJPTSBwcm9kdWN0cwogICAgICAgICAgICAgICAgICBJTk5FUiBKT0lOIGNsYXNzaWZpY2F0aW9ucwogICAgICAgICAgICAgICAgICAgIE9OIHByb2R1Y3RzLmNsYXNzaWZpY2F0aW9uX2lkID0gY2xhc3NpZmljYXRpb25zLmlkCiAgICAgICAgICAgICAgICAgIFdIRVJFIHByb2R1Y3RzLm5hbWUgPSA/CiAgICAgICAgICAgICAgICAgICAgQU5EIGNsYXNzaWZpY2F0aW9ucy5uYW1lID0gP307CiAgICBteSAkcmVzID0gJGRiaC0+c2VsZWN0cm93X2FycmF5KCRxdWVyeSwgdW5kZWYsICgkcHJvZCwgJGNsKSk7CgogICAgdW5sZXNzICgkcmVzKSB7CiAgICAgICAgcHJpbnQgIlNvcnJ5LCBjbGFzc2lmaWNhdGlvbi0+cHJvZHVjdCAnJGNsJy0+JyRwcm9kJyBkb2VzIG5vdCBleGlzdC4iOwogICAgICAgIFB1dFRyYWlsZXIoKTsKICAgICAgICBleGl0OwogICAgfQp9CgpzdWIgQ2hlY2tDbGFzc2lmaWNhdGlvblByb2R1Y3ROZXcgKCQkKQp7CiAgICBteSAoJGNsLCAkcHJvZCkgPSBAXzsKICAgIG15ICRkYmggPSBCdWd6aWxsYS0+ZGJoOwogICAgCiAgICBDaGVja0NsYXNzaWZpY2F0aW9uTmV3KCRjbCk7CgogICAgdHJpY2tfdGFpbnQoJHByb2QpOwogICAgdHJpY2tfdGFpbnQoJGNsKTsKCiAgICBteSAoJHJlcykgPSAkZGJoLT5zZWxlY3Ryb3dfYXJyYXkocXsKICAgICAgICBTRUxFQ1QgcHJvZHVjdHMubmFtZQogICAgICAgIEZST00gcHJvZHVjdHMKICAgICAgICBJTk5FUiBKT0lOIGNsYXNzaWZpY2F0aW9ucwogICAgICAgICAgT04gcHJvZHVjdHMuY2xhc3NpZmljYXRpb25faWQgPSBjbGFzc2lmaWNhdGlvbnMuaWQKICAgICAgICBXSEVSRSBwcm9kdWN0cy5uYW1lID0gPyBBTkQgY2xhc3NpZmljYXRpb25zLm5hbWUgPSA/fSwKICAgICAgICB1bmRlZiwgKCRwcm9kLCAkY2wpKTsKCiAgICB1bmxlc3MgKCRyZXMpIHsKICAgICAgICBUaHJvd1VzZXJFcnJvcignY2xhc3NpZmljYXRpb25fZG9lc250X2V4aXN0X2Zvcl9wcm9kdWN0JywKICAgICAgICAgICAgICAgICAgICAgICB7IHByb2R1Y3QgPT4gJHByb2QsIGNsYXNzaWZpY2F0aW9uID0+ICRjbCB9KTsKICAgIH0KfQoKIwojIERpc3BsYXlzIHRoZSBmb3JtIHRvIGVkaXQgYSBwcm9kdWN0cyBwYXJhbWV0ZXJzCiMKCnN1YiBFbWl0Rm9ybUVsZW1lbnRzICgkJCQkJCQkJCQpCnsKICAgIG15ICgkY2xhc3NpZmljYXRpb24sICRwcm9kdWN0LCAkZGVzY3JpcHRpb24sICRtaWxlc3RvbmV1cmwsICRkaXNhbGxvd25ldywKICAgICAgICAkdm90ZXNwZXJ1c2VyLCAkbWF4dm90ZXNwZXJidWcsICR2b3Rlc3RvY29uZmlybSwgJGRlZmF1bHRtaWxlc3RvbmUpCiAgICAgICAgPSBAXzsKCiAgICAkcHJvZHVjdCA9IHZhbHVlX3F1b3RlKCRwcm9kdWN0KTsKICAgICRkZXNjcmlwdGlvbiA9IHZhbHVlX3F1b3RlKCRkZXNjcmlwdGlvbik7CgogICAgaWYgKFBhcmFtKCd1c2VjbGFzc2lmaWNhdGlvbicpKSB7CiAgICAgICAgcHJpbnQgIiAgPFRIIEFMSUdOPVwicmlnaHRcIj5DbGFzc2lmaWNhdGlvbjo8L1RIPlxuIjsKICAgICAgICBwcmludCAiICA8VEQ+PGI+IixodG1sX3F1b3RlKCRjbGFzc2lmaWNhdGlvbiksIjwvYj48L1REPlxuIjsKICAgICAgICBwcmludCAiPC9UUj48VFI+XG4iOwogICAgfQoKICAgIHByaW50ICIgIDxUSCBBTElHTj1cInJpZ2h0XCI+UHJvZHVjdDo8L1RIPlxuIjsKICAgIHByaW50ICIgIDxURD48SU5QVVQgU0laRT02NCBNQVhMRU5HVEg9NjQgTkFNRT1cInByb2R1Y3RcIiBWQUxVRT1cIiRwcm9kdWN0XCI+PC9URD5cbiI7CiAgICBwcmludCAiPC9UUj48VFI+XG4iOwoKICAgIHByaW50ICIgIDxUSCBBTElHTj1cInJpZ2h0XCI+RGVzY3JpcHRpb246PC9USD5cbiI7CiAgICBwcmludCAiICA8VEQ+PFRFWFRBUkVBIFJPV1M9NCBDT0xTPTY0IFdSQVA9VklSVFVBTCBOQU1FPVwiZGVzY3JpcHRpb25cIj4kZGVzY3JpcHRpb248L1RFWFRBUkVBPjwvVEQ+XG4iOwoKICAgICRkZWZhdWx0bWlsZXN0b25lID0gdmFsdWVfcXVvdGUoJGRlZmF1bHRtaWxlc3RvbmUpOwogICAgaWYgKFBhcmFtKCd1c2V0YXJnZXRtaWxlc3RvbmUnKSkgewogICAgICAgICRtaWxlc3RvbmV1cmwgPSB2YWx1ZV9xdW90ZSgkbWlsZXN0b25ldXJsKTsKICAgICAgICBwcmludCAiPC9UUj48VFI+XG4iOwogICAgICAgIHByaW50ICIgIDxUSCBBTElHTj1cInJpZ2h0XCI+VVJMIGRlc2NyaWJpbmcgbWlsZXN0b25lcyBmb3IgdGhpcyBwcm9kdWN0OjwvVEg+XG4iOwogICAgICAgIHByaW50ICIgIDxURD48SU5QVVQgVFlQRT1URVhUIFNJWkU9NjQgTUFYTEVOR1RIPTI1NSBOQU1FPVwibWlsZXN0b25ldXJsXCIgVkFMVUU9XCIkbWlsZXN0b25ldXJsXCI+PC9URD5cbiI7CgogICAgICAgIHByaW50ICI8L1RSPjxUUj5cbiI7CiAgICAgICAgcHJpbnQgIiAgPFRIIEFMSUdOPVwicmlnaHRcIj5EZWZhdWx0IG1pbGVzdG9uZTo8L1RIPlxuIjsKICAgICAgICAKICAgICAgICBwcmludCAiICA8VEQ+PElOUFVUIFRZUEU9VEVYVCBTSVpFPTIwIE1BWExFTkdUSD0yMCBOQU1FPVwiZGVmYXVsdG1pbGVzdG9uZVwiIFZBTFVFPVwiJGRlZmF1bHRtaWxlc3RvbmVcIj48L1REPlxuIjsKICAgIH0gZWxzZSB7CiAgICAgICAgcHJpbnQgcXF7PElOUFVUIFRZUEU9SElEREVOIE5BTUU9ImRlZmF1bHRtaWxlc3RvbmUiIFZBTFVFPSIkZGVmYXVsdG1pbGVzdG9uZSI+XG59OwogICAgfQoKCiAgICBwcmludCAiPC9UUj48VFI+XG4iOwogICAgcHJpbnQgIiAgPFRIIEFMSUdOPVwicmlnaHRcIj5DbG9zZWQgZm9yIGJ1ZyBlbnRyeTo8L1RIPlxuIjsKICAgIG15ICRjbG9zZWQgPSAkZGlzYWxsb3duZXcgPyAiQ0hFQ0tFRCIgOiAiIjsKICAgIHByaW50ICIgIDxURD48SU5QVVQgVFlQRT1DSEVDS0JPWCBOQU1FPVwiZGlzYWxsb3duZXdcIiAkY2xvc2VkIFZBTFVFPVwiMVwiPjwvVEQ+XG4iOwoKICAgIHByaW50ICI8L1RSPjxUUj5cbiI7CiAgICBwcmludCAiICA8VEggQUxJR049XCJyaWdodFwiPk1heGltdW0gdm90ZXMgcGVyIHBlcnNvbjo8L1RIPlxuIjsKICAgIHByaW50ICIgIDxURD48SU5QVVQgU0laRT01IE1BWExFTkdUSD01IE5BTUU9XCJ2b3Rlc3BlcnVzZXJcIiBWQUxVRT1cIiR2b3Rlc3BlcnVzZXJcIj48L1REPlxuIjsKCiAgICBwcmludCAiPC9UUj48VFI+XG4iOwogICAgcHJpbnQgIiAgPFRIIEFMSUdOPVwicmlnaHRcIj5NYXhpbXVtIHZvdGVzIGEgcGVyc29uIGNhbiBwdXQgb24gYSBzaW5nbGUgYnVnOjwvVEg+XG4iOwogICAgcHJpbnQgIiAgPFREPjxJTlBVVCBTSVpFPTUgTUFYTEVOR1RIPTUgTkFNRT1cIm1heHZvdGVzcGVyYnVnXCIgVkFMVUU9XCIkbWF4dm90ZXNwZXJidWdcIj48L1REPlxuIjsKCiAgICBwcmludCAiPC9UUj48VFI+XG4iOwogICAgcHJpbnQgIiAgPFRIIEFMSUdOPVwicmlnaHRcIj5OdW1iZXIgb2Ygdm90ZXMgYSBidWcgaW4gdGhpcyBwcm9kdWN0IG5lZWRzIHRvIGF1dG9tYXRpY2FsbHkgZ2V0IG91dCBvZiB0aGUgPEEgSFJFRj1cInBhZ2UuY2dpP2lkPWZpZWxkcy5odG1sI3N0YXR1c1wiPlVOQ09ORklSTUVEPC9BPiBzdGF0ZTo8L1RIPlxuIjsKICAgIHByaW50ICIgIDxURD48SU5QVVQgU0laRT01IE1BWExFTkdUSD01IE5BTUU9XCJ2b3Rlc3RvY29uZmlybVwiIFZBTFVFPVwiJHZvdGVzdG9jb25maXJtXCI+PC9URD5cbiI7Cn0KCgojCiMgRGlzcGxheXMgYSB0ZXh0IGxpa2UgImEuIiwgImEgb3IgYi4iLCAiYSwgYiBvciBjLiIsICJhLCBiLCBjIG9yIGQuIgojCgpzdWIgUHV0VHJhaWxlciAoQCkKewogICAgbXkgKEBsaW5rcykgPSAoIkJhY2sgdG8gdGhlIDxBIEhSRUY9XCJxdWVyeS5jZ2lcIj5xdWVyeSBwYWdlPC9BPiIsIEBfKTsKCiAgICBteSAkY291bnQgPSAkI2xpbmtzOwogICAgbXkgJG51bSA9IDA7CiAgICBwcmludCAiPFA+XG4iOwogICAgZm9yZWFjaCAoQGxpbmtzKSB7CiAgICAgICAgcHJpbnQgJF87CiAgICAgICAgaWYgKCRudW0gPT0gJGNvdW50KSB7CiAgICAgICAgICAgIHByaW50ICIuXG4iOwogICAgICAgIH0KICAgICAgICBlbHNpZiAoJG51bSA9PSAkY291bnQtMSkgewogICAgICAgICAgICBwcmludCAiIG9yICI7CiAgICAgICAgfQogICAgICAgIGVsc2UgewogICAgICAgICAgICBwcmludCAiLCAiOwogICAgICAgIH0KICAgICAgICAkbnVtKys7CiAgICB9CiAgICBQdXRGb290ZXIoKTsKfQoKCgoKCgoKIwojIFByZWxpbWluYXJ5IGNoZWNrczoKIwoKbXkgJHVzZXIgPSBCdWd6aWxsYS0+bG9naW4oTE9HSU5fUkVRVUlSRUQpOwpteSAkd2hvaWQgPSAkdXNlci0+aWQ7CgpteSAkY2dpID0gQnVnemlsbGEtPmNnaTsKcHJpbnQgJGNnaS0+aGVhZGVyKCk7CgpVc2VySW5Hcm91cCgiZWRpdGNvbXBvbmVudHMiKQogIHx8IFRocm93VXNlckVycm9yKCJhdXRoX2ZhaWx1cmUiLCB7Z3JvdXAgID0+ICJlZGl0Y29tcG9uZW50cyIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhY3Rpb24gPT4gImVkaXQiLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb2JqZWN0ID0+ICJwcm9kdWN0cyJ9KTsKCiMKIyBvZnRlbiB1c2VkIHZhcmlhYmxlcwojCm15ICRjbGFzc2lmaWNhdGlvbiA9IHRyaW0oJGNnaS0+cGFyYW0oJ2NsYXNzaWZpY2F0aW9uJykgfHwgJycpOwpteSAkcHJvZHVjdCA9IHRyaW0oJGNnaS0+cGFyYW0oJ3Byb2R1Y3QnKSB8fCAnJyk7Cm15ICRhY3Rpb24gID0gdHJpbSgkY2dpLT5wYXJhbSgnYWN0aW9uJykgIHx8ICcnKTsKbXkgJGhlYWRlcmRvbmUgPSAwOwpteSAkbG9jYWx0cmFpbGVyID0gIjxBIEhSRUY9XCJlZGl0cHJvZHVjdHMuY2dpXCI+ZWRpdDwvQT4gbW9yZSBwcm9kdWN0cyI7Cm15ICRjbGFzc2h0bWx2YXJzdGFydCA9ICIiOwpteSAkY2xhc3NodG1sdmFyID0gIiI7Cm15ICRkYmggPSBCdWd6aWxsYS0+ZGJoOwoKIwojIHByb2R1Y3QgPSAnJyAtPiBTaG93IG5pY2UgbGlzdCBvZiBjbGFzc2lmaWNhdGlvbnMgKGlmCiMgY2xhc3NpZmljYXRpb25zIGVuYWJsZWQpCiMKCmlmIChQYXJhbSgndXNlY2xhc3NpZmljYXRpb24nKSkgewogICAgaWYgKCRjbGFzc2lmaWNhdGlvbikgewogICAgICAgICRjbGFzc2h0bWx2YXIgPSAiJmNsYXNzaWZpY2F0aW9uPSIgLiB1cmxfcXVvdGUoJGNsYXNzaWZpY2F0aW9uKTsKICAgICAgICAkY2xhc3NodG1sdmFyc3RhcnQgPSAiP2NsYXNzaWZpY2F0aW9uPSIgLiB1cmxfcXVvdGUoJGNsYXNzaWZpY2F0aW9uKTsKICAgICAgICAkbG9jYWx0cmFpbGVyIC49ICIsIDxBIEhSRUY9XCJlZGl0cHJvZHVjdHMuY2dpIiAuICRjbGFzc2h0bWx2YXJzdGFydCAuICJcIj5lZGl0PC9BPiBpbiB0aGlzIGNsYXNzaWZpY2F0aW9uIjsgICAgCiAgICB9CiAgICBlbHNpZiAoISRwcm9kdWN0KSB7CiAgICAgICAgbXkgJHF1ZXJ5ID0gCiAgICAgICAgICAgICJTRUxFQ1QgY2xhc3NpZmljYXRpb25zLm5hbWUsIGNsYXNzaWZpY2F0aW9ucy5kZXNjcmlwdGlvbiwKICAgICAgICAgICAgICAgICAgICBDT1VOVChjbGFzc2lmaWNhdGlvbl9pZCkgQVMgcHJvZHVjdF9jb3VudAogICAgICAgICAgICAgRlJPTSBjbGFzc2lmaWNhdGlvbnMKICAgICAgICAgICAgIExFRlQgSk9JTiBwcm9kdWN0cwogICAgICAgICAgICAgICAgICBPTiBjbGFzc2lmaWNhdGlvbnMuaWQgPSBwcm9kdWN0cy5jbGFzc2lmaWNhdGlvbl9pZCAiIC4KICAgICAgICAgICAgICAgICAgJGRiaC0+c3FsX2dyb3VwX2J5KCdjbGFzc2lmaWNhdGlvbnMuaWQnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2NsYXNzaWZpY2F0aW9ucy5uYW1lLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNsYXNzaWZpY2F0aW9ucy5kZXNjcmlwdGlvbicpIC4gIgogICAgICAgICAgICAgT1JERVIgQlkgbmFtZSI7CgogICAgICAgICR2YXJzLT57J2NsYXNzaWZpY2F0aW9ucyd9ID0gJGRiaC0+c2VsZWN0YWxsX2FycmF5cmVmKCRxdWVyeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7J1NsaWNlJyA9PiB7fX0pOwoKICAgICAgICAkdGVtcGxhdGUtPnByb2Nlc3MoImFkbWluL3Byb2R1Y3RzL2xpc3QtY2xhc3NpZmljYXRpb25zLmh0bWwudG1wbCIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICR2YXJzKQogICAgICAgICAgICB8fCBUaHJvd1RlbXBsYXRlRXJyb3IoJHRlbXBsYXRlLT5lcnJvcigpKTsKCiAgICAgICAgZXhpdDsKICAgIH0KfQoKCiMKIyBhY3Rpb24gPSAnJyAtPiBTaG93IGEgbmljZSBsaXN0IG9mIHByb2R1Y3RzLCB1bmxlc3MgYSBwcm9kdWN0CiMgICAgICAgICAgICAgICAgaXMgYWxyZWFkeSBzcGVjaWZpZWQgKHRoZW4gZWRpdCBpdCkKIwoKaWYgKCEkYWN0aW9uICYmICEkcHJvZHVjdCkgewoKICAgIGlmIChQYXJhbSgndXNlY2xhc3NpZmljYXRpb24nKSkgewogICAgICAgIENoZWNrQ2xhc3NpZmljYXRpb25OZXcoJGNsYXNzaWZpY2F0aW9uKTsKICAgIH0KCiAgICBteSBAZXhlY3V0ZV9wYXJhbXMgPSAoKTsKICAgIG15IEBwcm9kdWN0cyA9ICgpOwoKICAgIG15ICRxdWVyeSA9ICJTRUxFQ1QgcHJvZHVjdHMubmFtZSwKICAgICAgICAgICAgICAgICAgICAgICAgQ09BTEVTQ0UocHJvZHVjdHMuZGVzY3JpcHRpb24sJycpIEFTIGRlc2NyaXB0aW9uLCAKICAgICAgICAgICAgICAgICAgICAgICAgZGlzYWxsb3duZXcgPSAwIEFTIHN0YXR1cywKICAgICAgICAgICAgICAgICAgICAgICAgdm90ZXNwZXJ1c2VyLCAgbWF4dm90ZXNwZXJidWcsIHZvdGVzdG9jb25maXJtLAogICAgICAgICAgICAgICAgICAgICAgICBDT1VOVChidWdfaWQpIEFTIGJ1Z19jb3VudAogICAgICAgICAgICAgICAgIEZST00gcHJvZHVjdHMiOwoKICAgIGlmIChQYXJhbSgndXNlY2xhc3NpZmljYXRpb24nKSkgewogICAgICAgICRxdWVyeSAuPSAiIElOTkVSIEpPSU4gY2xhc3NpZmljYXRpb25zICIgLgogICAgICAgICAgICAgICAgICAiT04gY2xhc3NpZmljYXRpb25zLmlkID0gcHJvZHVjdHMuY2xhc3NpZmljYXRpb25faWQiOwogICAgfQoKICAgICRxdWVyeSAuPSAiIExFRlQgSk9JTiBidWdzIE9OIHByb2R1Y3RzLmlkID0gYnVncy5wcm9kdWN0X2lkIjsKCiAgICBpZiAoUGFyYW0oJ3VzZWNsYXNzaWZpY2F0aW9uJykpIHsKICAgICAgICAkcXVlcnkgLj0gIiBXSEVSRSBjbGFzc2lmaWNhdGlvbnMubmFtZSA9ID8gIjsKCiAgICAgICAgIyB0cmlja190YWludCBpcyBPSyBiZWNhdXNlIHdlIHVzZSB0aGlzIGluIGEgcGxhY2Vob2xkZXIgaW4gYSBTRUxFQ1QKICAgICAgICB0cmlja190YWludCgkY2xhc3NpZmljYXRpb24pOwoKICAgICAgICBwdXNoKEBleGVjdXRlX3BhcmFtcywKICAgICAgICAgICAgICRjbGFzc2lmaWNhdGlvbik7CiAgICB9CgogICAgJHF1ZXJ5IC49ICIgIiAuICRkYmgtPnNxbF9ncm91cF9ieSgncHJvZHVjdHMubmFtZScsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdwcm9kdWN0cy5kZXNjcmlwdGlvbiwgZGlzYWxsb3duZXcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b3Rlc3BlcnVzZXIsIG1heHZvdGVzcGVyYnVnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdm90ZXN0b2NvbmZpcm0nKTsKICAgICRxdWVyeSAuPSAiIE9SREVSIEJZIHByb2R1Y3RzLm5hbWUiOwoKICAgICR2YXJzLT57J3Byb2R1Y3RzJ30gPSAkZGJoLT5zZWxlY3RhbGxfYXJyYXlyZWYoJHF1ZXJ5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7J1NsaWNlJyA9PiB7fX0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEBleGVjdXRlX3BhcmFtcyk7CgogICAgJHZhcnMtPnsnY2xhc3NpZmljYXRpb24nfSA9ICRjbGFzc2lmaWNhdGlvbjsKICAgICR0ZW1wbGF0ZS0+cHJvY2VzcygiYWRtaW4vcHJvZHVjdHMvbGlzdC5odG1sLnRtcGwiLAogICAgICAgICAgICAgICAgICAgICAgICR2YXJzKQogICAgICB8fCBUaHJvd1RlbXBsYXRlRXJyb3IoJHRlbXBsYXRlLT5lcnJvcigpKTsKCiAgICBleGl0Owp9CgoKCgojCiMgYWN0aW9uPSdhZGQnIC0+IHByZXNlbnQgZm9ybSBmb3IgcGFyYW1ldGVycyBmb3IgbmV3IHByb2R1Y3QKIwojIChuZXh0IGFjdGlvbiB3aWxsIGJlICduZXcnKQojCgppZiAoJGFjdGlvbiBlcSAnYWRkJykgewogICAgUHV0SGVhZGVyKCJBZGQgUHJvZHVjdCIpOwoKICAgIGlmIChQYXJhbSgndXNlY2xhc3NpZmljYXRpb24nKSkgewogICAgICAgIENoZWNrQ2xhc3NpZmljYXRpb24oJGNsYXNzaWZpY2F0aW9uKTsKICAgIH0KICAgICNwcmludCAiVGhpcyBwYWdlIGxldHMgeW91IGFkZCBhIG5ldyBwcm9kdWN0IHRvIGJ1Z3ppbGxhLlxuIjsKCiAgICBwcmludCAiPEZPUk0gTUVUSE9EPVBPU1QgQUNUSU9OPWVkaXRwcm9kdWN0cy5jZ2k+XG4iOwogICAgcHJpbnQgIjxUQUJMRSBCT1JERVI9MCBDRUxMUEFERElORz00IENFTExTUEFDSU5HPTA+PFRSPlxuIjsKCiAgICBFbWl0Rm9ybUVsZW1lbnRzKCRjbGFzc2lmaWNhdGlvbiwnJywgJycsICcnLCAwLCAwLCAxMDAwMCwgMCwgIi0tLSIpOwoKICAgIHByaW50ICI8L1RSPjxUUj5cbiI7CiAgICBwcmludCAiICA8VEggQUxJR049XCJyaWdodFwiPlZlcnNpb246PC9USD5cbiI7CiAgICBwcmludCAiICA8VEQ+PElOUFVUIFNJWkU9NjQgTUFYTEVOR1RIPTI1NSBOQU1FPVwidmVyc2lvblwiIFZBTFVFPVwidW5zcGVjaWZpZWRcIj48L1REPlxuIjsKICAgIHByaW50ICI8L1RSPjxUUj5cbiI7CiAgICBwcmludCAiICA8VEggQUxJR049XCJyaWdodFwiPkNyZWF0ZSBjaGFydCBkYXRhc2V0cyBmb3IgdGhpcyBwcm9kdWN0OjwvVEg+XG4iOwogICAgcHJpbnQgIiAgPFREPjxJTlBVVCBUWVBFPUNIRUNLQk9YIE5BTUU9XCJjcmVhdGVzZXJpZXNcIiBWQUxVRT0xPjwvVEQ+IjsKICAgIHByaW50ICI8L1RSPlxuIjsKCiAgICBwcmludCAiPC9UQUJMRT5cbjxIUj5cbiI7CiAgICBwcmludCAiPElOUFVUIFRZUEU9U1VCTUlUIFZBTFVFPVwiQWRkXCI+XG4iOwogICAgcHJpbnQgIjxJTlBVVCBUWVBFPUhJRERFTiBOQU1FPVwiYWN0aW9uXCIgVkFMVUU9XCJuZXdcIj5cbiI7CiAgICBwcmludCAiPElOUFVUIFRZUEU9SElEREVOIE5BTUU9J3N1YmNhdGVnb3J5JyBWQUxVRT0nLUFsbC0nPlxuIjsKICAgIHByaW50ICI8SU5QVVQgVFlQRT1ISURERU4gTkFNRT0nb3Blbl9uYW1lJyBWQUxVRT0nQWxsIE9wZW4nPlxuIjsKICAgIHByaW50ICI8SU5QVVQgVFlQRT1ISURERU4gTkFNRT0nY2xhc3NpZmljYXRpb24nIFZBTFVFPSciLGh0bWxfcXVvdGUoJGNsYXNzaWZpY2F0aW9uKSwiJz5cbiI7CiAgICBwcmludCAiPC9GT1JNPiI7CgogICAgbXkgJG90aGVyID0gJGxvY2FsdHJhaWxlcjsKICAgICRvdGhlciA9fiBzL21vcmUvb3RoZXIvOwogICAgUHV0VHJhaWxlcigkb3RoZXIpOwogICAgZXhpdDsKfQoKCgojCiMgYWN0aW9uPSduZXcnIC0+IGFkZCBwcm9kdWN0IGVudGVyZWQgaW4gdGhlICdhY3Rpb249YWRkJyBzY3JlZW4KIwoKaWYgKCRhY3Rpb24gZXEgJ25ldycpIHsKICAgIFB1dEhlYWRlcigiQWRkaW5nIG5ldyBwcm9kdWN0Iik7CgogICAgIyBDbGVhbnVwcyBhbmQgdmFsaWRpdHkgY2hlY2tzCgogICAgbXkgJGNsYXNzaWZpY2F0aW9uX2lkID0gMTsKICAgIGlmIChQYXJhbSgndXNlY2xhc3NpZmljYXRpb24nKSkgewogICAgICAgIENoZWNrQ2xhc3NpZmljYXRpb24oJGNsYXNzaWZpY2F0aW9uKTsKICAgICAgICAkY2xhc3NpZmljYXRpb25faWQgPSBnZXRfY2xhc3NpZmljYXRpb25faWQoJGNsYXNzaWZpY2F0aW9uKTsKICAgIH0KCiAgICB1bmxlc3MgKCRwcm9kdWN0KSB7CiAgICAgICAgcHJpbnQgIllvdSBtdXN0IGVudGVyIGEgbmFtZSBmb3IgdGhlIG5ldyBwcm9kdWN0LiBQbGVhc2UgcHJlc3NcbiI7CiAgICAgICAgcHJpbnQgIjxiPkJhY2s8L2I+IGFuZCB0cnkgYWdhaW4uXG4iOwogICAgICAgIFB1dFRyYWlsZXIoJGxvY2FsdHJhaWxlcik7CiAgICAgICAgZXhpdDsKICAgIH0KCiAgICBteSAkZXhpc3RpbmdfcHJvZHVjdCA9IFRlc3RQcm9kdWN0KCRwcm9kdWN0KTsKCiAgICBpZiAoJGV4aXN0aW5nX3Byb2R1Y3QpIHsKCiAgICAgICAgIyBDaGVjayBmb3IgZXhhY3QgY2FzZSBzZW5zaXRpdmUgbWF0Y2g6CiAgICAgICAgaWYgKCRleGlzdGluZ19wcm9kdWN0IGVxICRwcm9kdWN0KSB7CiAgICAgICAgICAgIHByaW50ICJUaGUgcHJvZHVjdCAnJHByb2R1Y3QnIGFscmVhZHkgZXhpc3RzLiBQbGVhc2UgcHJlc3NcbiI7CiAgICAgICAgICAgIHByaW50ICI8Yj5CYWNrPC9iPiBhbmQgdHJ5IGFnYWluLlxuIjsKICAgICAgICAgICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgICAgICAgICAgZXhpdDsKICAgICAgICB9CgogICAgICAgICMgTmV4dCBjaGVjayBmb3IgYSBjYXNlLWluc2Vuc2l0aXZlIG1hdGNoOgogICAgICAgIGlmIChsYygkZXhpc3RpbmdfcHJvZHVjdCkgZXEgbGMoJHByb2R1Y3QpKSB7CiAgICAgICAgICAgIHByaW50ICJUaGUgbmV3IHByb2R1Y3QgJyRwcm9kdWN0JyBkaWZmZXJzIGZyb20gZXhpc3RpbmcgcHJvZHVjdCAiOwogICAgICAgICAgICBwcmludCAiJyRleGlzdGluZ19wcm9kdWN0JyBvbmx5IGluIGNhc2UuIFBsZWFzZSBwcmVzc1xuIjsKICAgICAgICAgICAgcHJpbnQgIjxiPkJhY2s8L2I+IGFuZCB0cnkgYWdhaW4uXG4iOwogICAgICAgICAgICBQdXRUcmFpbGVyKCRsb2NhbHRyYWlsZXIpOwogICAgICAgICAgICBleGl0OwogICAgICAgIH0KICAgIH0KCiAgICBteSAkdmVyc2lvbiA9IHRyaW0oJGNnaS0+cGFyYW0oJ3ZlcnNpb24nKSB8fCAnJyk7CgogICAgaWYgKCR2ZXJzaW9uIGVxICcnKSB7CiAgICAgICAgcHJpbnQgIllvdSBtdXN0IGVudGVyIGEgdmVyc2lvbiBmb3IgcHJvZHVjdCAnJHByb2R1Y3QnLiBQbGVhc2UgcHJlc3NcbiI7CiAgICAgICAgcHJpbnQgIjxiPkJhY2s8L2I+IGFuZCB0cnkgYWdhaW4uXG4iOwogICAgICAgIFB1dFRyYWlsZXIoJGxvY2FsdHJhaWxlcik7CiAgICAgICAgZXhpdDsKICAgIH0KCiAgICBteSAkZGVzY3JpcHRpb24gID0gdHJpbSgkY2dpLT5wYXJhbSgnZGVzY3JpcHRpb24nKSAgfHwgJycpOwoKICAgIGlmICgkZGVzY3JpcHRpb24gZXEgJycpIHsKICAgICAgICBwcmludCAiWW91IG11c3QgZW50ZXIgYSBkZXNjcmlwdGlvbiBmb3IgcHJvZHVjdCAnJHByb2R1Y3QnLiBQbGVhc2UgcHJlc3NcbiI7CiAgICAgICAgcHJpbnQgIjxiPkJhY2s8L2I+IGFuZCB0cnkgYWdhaW4uXG4iOwogICAgICAgIFB1dFRyYWlsZXIoJGxvY2FsdHJhaWxlcik7CiAgICAgICAgZXhpdDsKICAgIH0KCiAgICBteSAkbWlsZXN0b25ldXJsID0gdHJpbSgkY2dpLT5wYXJhbSgnbWlsZXN0b25ldXJsJykgfHwgJycpOwogICAgbXkgJGRpc2FsbG93bmV3ID0gMDsKICAgICRkaXNhbGxvd25ldyA9IDEgaWYgJGNnaS0+cGFyYW0oJ2Rpc2FsbG93bmV3Jyk7CiAgICBteSAkdm90ZXNwZXJ1c2VyID0gJGNnaS0+cGFyYW0oJ3ZvdGVzcGVydXNlcicpOwogICAgJHZvdGVzcGVydXNlciB8fD0gMDsKICAgIG15ICRtYXh2b3Rlc3BlcmJ1ZyA9ICRjZ2ktPnBhcmFtKCdtYXh2b3Rlc3BlcmJ1ZycpOwogICAgJG1heHZvdGVzcGVyYnVnID0gMTAwMDAgaWYgIWRlZmluZWQgJG1heHZvdGVzcGVyYnVnOwogICAgbXkgJHZvdGVzdG9jb25maXJtID0gJGNnaS0+cGFyYW0oJ3ZvdGVzdG9jb25maXJtJyk7CiAgICAkdm90ZXN0b2NvbmZpcm0gfHw9IDA7CiAgICBteSAkZGVmYXVsdG1pbGVzdG9uZSA9ICRjZ2ktPnBhcmFtKCdkZWZhdWx0bWlsZXN0b25lJykgfHwgIi0tLSI7CgogICAgIyBBZGQgdGhlIG5ldyBwcm9kdWN0LgogICAgU2VuZFNRTCgiSU5TRVJUIElOVE8gcHJvZHVjdHMgKCAiIC4KICAgICAgICAgICAgIm5hbWUsIGRlc2NyaXB0aW9uLCBtaWxlc3RvbmV1cmwsIGRpc2FsbG93bmV3LCB2b3Rlc3BlcnVzZXIsICIgLgogICAgICAgICAgICAibWF4dm90ZXNwZXJidWcsIHZvdGVzdG9jb25maXJtLCBkZWZhdWx0bWlsZXN0b25lLCBjbGFzc2lmaWNhdGlvbl9pZCIgLgogICAgICAgICAgICAiICkgVkFMVUVTICggIiAuCiAgICAgICAgICAgIFNxbFF1b3RlKCRwcm9kdWN0KSAuICIsIiAuCiAgICAgICAgICAgIFNxbFF1b3RlKCRkZXNjcmlwdGlvbikgLiAiLCIgLgogICAgICAgICAgICBTcWxRdW90ZSgkbWlsZXN0b25ldXJsKSAuICIsIiAuCiAgICAgICAgICAgICMgaGFkIHRhaW50aW5nIGlzc3VlcyB1bmRlciBjeWd3aW4sIElJUyA1LjAsIHBlcmwgLVQgJXMgJXMKICAgICAgICAgICAgIyBzZWUgYnVnIDIwODY0Ny4gaHR0cDovL2J1Z3ppbGxhLm1vemlsbGEub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDg2NDcKICAgICAgICAgICAgIyBoYWQgdG8gZGUtdGFpbnQgJGRpc2FsbG93bmV3LCAkdm90ZXNwZXJ1c2VyLCAkbWF4dm90ZXNwZXJidWcsCiAgICAgICAgICAgICMgIGFuZCAkdm90ZXN0b2NvbmZpcm0gdy8gU3FsUXVvdGUoKQogICAgICAgICAgICAjIC0ganB5ZXJvbkBweWVyb3RlY2huaWNzLmNvbQogICAgICAgICAgICBTcWxRdW90ZSgkZGlzYWxsb3duZXcpIC4gIiwiIC4KICAgICAgICAgICAgU3FsUXVvdGUoJHZvdGVzcGVydXNlcikgLiAiLCIgLgogICAgICAgICAgICBTcWxRdW90ZSgkbWF4dm90ZXNwZXJidWcpIC4gIiwiIC4KICAgICAgICAgICAgU3FsUXVvdGUoJHZvdGVzdG9jb25maXJtKSAuICIsIiAuCiAgICAgICAgICAgIFNxbFF1b3RlKCRkZWZhdWx0bWlsZXN0b25lKSAuICIsIiAuCiAgICAgICAgICAgIFNxbFF1b3RlKCRjbGFzc2lmaWNhdGlvbl9pZCkgLiAiKSIpOwogICAgbXkgJHByb2R1Y3RfaWQgPSAkZGJoLT5iel9sYXN0X2tleSgncHJvZHVjdHMnLCAnaWQnKTsKCiAgICBTZW5kU1FMKCJJTlNFUlQgSU5UTyB2ZXJzaW9ucyAoICIgLgogICAgICAgICAgInZhbHVlLCBwcm9kdWN0X2lkIiAuCiAgICAgICAgICAiICkgVkFMVUVTICggIiAuCiAgICAgICAgICBTcWxRdW90ZSgkdmVyc2lvbikgLiAiLCIgLgogICAgICAgICAgJHByb2R1Y3RfaWQgLiAiKSIgKTsKCiAgICBTZW5kU1FMKCJJTlNFUlQgSU5UTyBtaWxlc3RvbmVzIChwcm9kdWN0X2lkLCB2YWx1ZSkgVkFMVUVTICgiIC4KICAgICAgICAgICAgJHByb2R1Y3RfaWQgLiAiLCAiIC4gU3FsUXVvdGUoJGRlZmF1bHRtaWxlc3RvbmUpIC4gIikiKTsKCiAgICAjIElmIHdlJ3JlIHVzaW5nIGJ1ZyBncm91cHMsIHRoZW4gd2UgbmVlZCB0byBjcmVhdGUgYSBncm91cCBmb3IgdGhpcwogICAgIyBwcm9kdWN0IGFzIHdlbGwuICAtSk1SLCAyLzE2LzAwCiAgICBpZiAoUGFyYW0oIm1ha2Vwcm9kdWN0Z3JvdXBzIikpIHsKICAgICAgICAjIE5leHQgd2UgaW5zZXJ0IGludG8gdGhlIGdyb3VwcyB0YWJsZQogICAgICAgIG15ICRwcm9kdWN0Z3JvdXAgPSAkcHJvZHVjdDsKICAgICAgICB3aGlsZSAoR3JvdXBFeGlzdHMoJHByb2R1Y3Rncm91cCkpIHsKICAgICAgICAgICAgJHByb2R1Y3Rncm91cCAuPSAnXyc7CiAgICAgICAgfQogICAgICAgIFNlbmRTUUwoIklOU0VSVCBJTlRPIGdyb3VwcyAiIC4KICAgICAgICAgICAgICAgICIobmFtZSwgZGVzY3JpcHRpb24sIGlzYnVnZ3JvdXAsIGxhc3RfY2hhbmdlZCkgIiAuCiAgICAgICAgICAgICAgICAiVkFMVUVTICgiIC4KICAgICAgICAgICAgICAgIFNxbFF1b3RlKCRwcm9kdWN0Z3JvdXApIC4gIiwgIiAuCiAgICAgICAgICAgICAgICBTcWxRdW90ZSgiQWNjZXNzIHRvIGJ1Z3MgaW4gdGhlICRwcm9kdWN0IHByb2R1Y3QiKSAuICIsIDEsIE5PVygpKSIpOwogICAgICAgIG15ICRnaWQgPSAkZGJoLT5iel9sYXN0X2tleSgnZ3JvdXBzJywgJ2lkJyk7CiAgICAgICAgbXkgJGFkbWluID0gR3JvdXBOYW1lVG9JZCgnYWRtaW4nKTsKICAgICAgICAjIElmIHdlIGNyZWF0ZWQgYSBuZXcgZ3JvdXAsIGdpdmUgdGhlICJhZG1pbiIgZ3JvdXAgcHJpdmlsZWRnZXMKICAgICAgICAjIGluaXRpYWxseS4KICAgICAgICBTZW5kU1FMKCJJTlNFUlQgSU5UTyBncm91cF9ncm91cF9tYXAgKG1lbWJlcl9pZCwgZ3JhbnRvcl9pZCwgZ3JhbnRfdHlwZSkKICAgICAgICAgICAgICAgICBWQUxVRVMgKCRhZG1pbiwgJGdpZCwiIC4gR1JPVVBfTUVNQkVSU0hJUCAuIikiKTsKICAgICAgICBTZW5kU1FMKCJJTlNFUlQgSU5UTyBncm91cF9ncm91cF9tYXAgKG1lbWJlcl9pZCwgZ3JhbnRvcl9pZCwgZ3JhbnRfdHlwZSkKICAgICAgICAgICAgICAgICBWQUxVRVMgKCRhZG1pbiwgJGdpZCwiIC4gR1JPVVBfQkxFU1MgLiIpIik7CiAgICAgICAgU2VuZFNRTCgiSU5TRVJUIElOVE8gZ3JvdXBfZ3JvdXBfbWFwIChtZW1iZXJfaWQsIGdyYW50b3JfaWQsIGdyYW50X3R5cGUpCiAgICAgICAgICAgICAgICAgVkFMVUVTICgkYWRtaW4sICRnaWQsIiAuIEdST1VQX1ZJU0lCTEUgLiIpIik7CgogICAgICAgICMgQXNzb2NpYXRlIHRoZSBuZXcgZ3JvdXAgYW5kIG5ldyBwcm9kdWN0LgogICAgICAgIFNlbmRTUUwoIklOU0VSVCBJTlRPIGdyb3VwX2NvbnRyb2xfbWFwICIgLgogICAgICAgICAgICAgICAgIihncm91cF9pZCwgcHJvZHVjdF9pZCwgZW50cnksICIgLgogICAgICAgICAgICAgICAgIm1lbWJlcmNvbnRyb2wsIG90aGVyY29udHJvbCwgY2FuZWRpdCkgVkFMVUVTICIgLgogICAgICAgICAgICAgICAgIigkZ2lkLCAkcHJvZHVjdF9pZCwgIiAuIFBhcmFtKCJ1c2VlbnRyeWdyb3VwZGVmYXVsdCIpIC4KICAgICAgICAgICAgICAgICIsICIgLiBDT05UUk9MTUFQREVGQVVMVCAuICIsICIgLgogICAgICAgICAgICAgICAgQ09OVFJPTE1BUE5BIC4gIiwgMCkiKTsKICAgIH0KCiAgICBpZiAoJGNnaS0+cGFyYW0oJ2NyZWF0ZXNlcmllcycpKSB7CiAgICAgICAgIyBJbnNlcnQgZGVmYXVsdCBjaGFydGluZyBxdWVyaWVzIGZvciB0aGlzIHByb2R1Y3QuCiAgICAgICAgIyBJZiB0aGV5IGFyZW4ndCB1c2luZyBjaGFydGluZywgdGhpcyB3b24ndCBkbyBhbnkgaGFybS4KICAgICAgICBHZXRWZXJzaW9uVGFibGUoKTsKCiAgICAgICAgIyAkb3Blbl9uYW1lIGFuZCAkcHJvZHVjdCBhcmUgc3FscXVvdGVkIGJ5IHRoZSBzZXJpZXMgY29kZSAKICAgICAgICAjIGFuZCBuZXZlciB1c2VkIGFnYWluIGhlcmUsIHNvIHdlIGNhbiB0cmlja190YWludCB0aGVtLgogICAgICAgIG15ICRvcGVuX25hbWUgPSAkY2dpLT5wYXJhbSgnb3Blbl9uYW1lJyk7CiAgICAgICAgdHJpY2tfdGFpbnQoJG9wZW5fbmFtZSk7CiAgICAgICAgdHJpY2tfdGFpbnQoJHByb2R1Y3QpOwogICAgCiAgICAgICAgbXkgQHNlcmllczsKICAgIAogICAgICAgICMgV2UgZG8gZXZlcnkgc3RhdHVzLCBldmVyeSByZXNvbHV0aW9uLCBhbmQgYW4gIm9wZW5lZCIgb25lIGFzIHdlbGwuCiAgICAgICAgZm9yZWFjaCBteSAkYnVnX3N0YXR1cyAoQDo6bGVnYWxfYnVnX3N0YXR1cykgewogICAgICAgICAgICBwdXNoKEBzZXJpZXMsIFskYnVnX3N0YXR1cywgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICJidWdfc3RhdHVzPSIgLiB1cmxfcXVvdGUoJGJ1Z19zdGF0dXMpXSk7CiAgICAgICAgfQoKICAgICAgICBmb3JlYWNoIG15ICRyZXNvbHV0aW9uIChAOjpsZWdhbF9yZXNvbHV0aW9uKSB7CiAgICAgICAgICAgIG5leHQgaWYgISRyZXNvbHV0aW9uOwogICAgICAgICAgICBwdXNoKEBzZXJpZXMsIFskcmVzb2x1dGlvbiwgInJlc29sdXRpb249IiAudXJsX3F1b3RlKCRyZXNvbHV0aW9uKV0pOwogICAgICAgIH0KCiAgICAgICAgIyBGb3IgbG9jYWxpc2F0aW9uIHJlYXNvbnMsIHdlIGdldCB0aGUgbmFtZSBvZiB0aGUgImdsb2JhbCIgc3ViY2F0ZWdvcnkKICAgICAgICAjIGFuZCB0aGUgdGl0bGUgb2YgdGhlICJvcGVuIiBxdWVyeSBmcm9tIHRoZSBzdWJtaXR0ZWQgZm9ybS4KICAgICAgICBteSBAb3BlbmVkc3RhdHVzZXMgPSBPcGVuU3RhdGVzKCk7CiAgICAgICAgbXkgJHF1ZXJ5ID0gCiAgICAgICAgICAgICAgIGpvaW4oIiYiLCBtYXAgeyAiYnVnX3N0YXR1cz0iIC4gdXJsX3F1b3RlKCRfKSB9IEBvcGVuZWRzdGF0dXNlcyk7CiAgICAgICAgcHVzaChAc2VyaWVzLCBbJG9wZW5fbmFtZSwgJHF1ZXJ5XSk7CiAgICAKICAgICAgICBmb3JlYWNoIG15ICRzZGF0YSAoQHNlcmllcykgewogICAgICAgICAgICBteSAkc2VyaWVzID0gbmV3IEJ1Z3ppbGxhOjpTZXJpZXModW5kZWYsICRwcm9kdWN0LCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNjYWxhciAkY2dpLT5wYXJhbSgnc3ViY2F0ZWdvcnknKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICRzZGF0YS0+WzBdLCAkOjp1c2VyaWQsIDEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAkc2RhdGEtPlsxXSAuICImcHJvZHVjdD0iIC4gdXJsX3F1b3RlKCRwcm9kdWN0KSwgMSk7CiAgICAgICAgICAgICRzZXJpZXMtPndyaXRlVG9EYXRhYmFzZSgpOwogICAgICAgIH0KICAgIH0KICAgICMgTWFrZSB2ZXJzaW9uY2FjaGUgZmx1c2gKICAgIHVubGluayAiJGRhdGFkaXIvdmVyc2lvbmNhY2hlIjsKCiAgICBwcmludCAiT0ssIGRvbmUuPHA+XG4iOwogICAgcHJpbnQgIjxkaXYgc3R5bGU9J2JvcmRlcjogMXB4IHJlZCBzb2xpZDsgcGFkZGluZzogMWV4Oyc+PGI+WW91IHdpbGwgbmVlZCB0byAgICAKICAgICAgICAgICA8YSBocmVmPVwiZWRpdGNvbXBvbmVudHMuY2dpP2FjdGlvbj1hZGQmcHJvZHVjdD0iIC4KICAgICAgICAgICB1cmxfcXVvdGUoJHByb2R1Y3QpIC4gIlwiPmFkZCBhdCBsZWFzdCBvbmUgCiAgICAgICAgICAgY29tcG9uZW50PC9hPiBiZWZvcmUgeW91IGNhbiBlbnRlciBidWdzIGFnYWluc3QgdGhpcyBwcm9kdWN0LjwvYj48L2Rpdj4iOwogICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyLAogICAgICAgICI8YSBocmVmPVwiZWRpdHByb2R1Y3RzLmNnaT9hY3Rpb249YWRkXCI+YWRkPC9hPiBhIG5ldyBwcm9kdWN0IiwKICAgICAgICAiPGEgaHJlZj1cImVkaXRjb21wb25lbnRzLmNnaT9hY3Rpb249YWRkJnByb2R1Y3Q9IiAuCiAgICAgICAgdXJsX3F1b3RlKCRwcm9kdWN0KSAuICRjbGFzc2h0bWx2YXIgLgogICAgICAgICJcIj5hZGQ8L2E+IGNvbXBvbmVudHMgdG8gdGhpcyBuZXcgcHJvZHVjdCIpOwogICAgZXhpdDsKfQoKCgojCiMgYWN0aW9uPSdkZWwnIC0+IGFzayBpZiB1c2VyIHJlYWxseSB3YW50cyB0byBkZWxldGUKIwojIChuZXh0IGFjdGlvbiB3b3VsZCBiZSAnZGVsZXRlJykKIwoKaWYgKCRhY3Rpb24gZXEgJ2RlbCcpIHsKICAgIAogICAgaWYgKCEkcHJvZHVjdCkgewogICAgICAgIFRocm93VXNlckVycm9yKCdwcm9kdWN0X25vdF9zcGVjaWZpZWQnKTsKICAgIH0KCiAgICBteSAkcHJvZHVjdF9pZCA9IGdldF9wcm9kdWN0X2lkKCRwcm9kdWN0KTsKICAgICRwcm9kdWN0X2lkIHx8IFRocm93VXNlckVycm9yKCdwcm9kdWN0X2RvZXNudF9leGlzdCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7cHJvZHVjdCA9PiAkcHJvZHVjdH0pOwoKICAgIG15ICRjbGFzc2lmaWNhdGlvbl9pZCA9IDE7CgogICAgaWYgKFBhcmFtKCd1c2VjbGFzc2lmaWNhdGlvbicpKSB7CiAgICAgICAgQ2hlY2tDbGFzc2lmaWNhdGlvblByb2R1Y3ROZXcoJGNsYXNzaWZpY2F0aW9uLCAkcHJvZHVjdCk7CiAgICAgICAgJGNsYXNzaWZpY2F0aW9uX2lkID0gZ2V0X2NsYXNzaWZpY2F0aW9uX2lkKCRjbGFzc2lmaWNhdGlvbik7CiAgICAgICAgJHZhcnMtPnsnY2xhc3NpZmljYXRpb24nfSA9ICRjbGFzc2lmaWNhdGlvbjsKICAgIH0KCiAgICAjIEV4dHJhY3Qgc29tZSBkYXRhIGFib3V0IHRoZSBwcm9kdWN0CiAgICBteSAkcXVlcnkgPSBxe1NFTEVDVCBjbGFzc2lmaWNhdGlvbnMuZGVzY3JpcHRpb24sCiAgICAgICAgICAgICAgICAgICAgICAgICBwcm9kdWN0cy5kZXNjcmlwdGlvbiwKICAgICAgICAgICAgICAgICAgICAgICAgIHByb2R1Y3RzLm1pbGVzdG9uZXVybCwKICAgICAgICAgICAgICAgICAgICAgICAgIHByb2R1Y3RzLmRpc2FsbG93bmV3CiAgICAgICAgICAgICAgICAgIEZST00gcHJvZHVjdHMKICAgICAgICAgICAgICAgICAgSU5ORVIgSk9JTiBjbGFzc2lmaWNhdGlvbnMKICAgICAgICAgICAgICAgICAgICBPTiBwcm9kdWN0cy5jbGFzc2lmaWNhdGlvbl9pZCA9IGNsYXNzaWZpY2F0aW9ucy5pZAogICAgICAgICAgICAgICAgICBXSEVSRSBwcm9kdWN0cy5pZCA9ID99OwoKICAgIG15ICgkY2xhc3NfZGVzY3JpcHRpb24sCiAgICAgICAgJHByb2RfZGVzY3JpcHRpb24sCiAgICAgICAgJG1pbGVzdG9uZXVybCwKICAgICAgICAkZGlzYWxsb3duZXcpID0gJGRiaC0+c2VsZWN0cm93X2FycmF5KCRxdWVyeSwgdW5kZWYsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAkcHJvZHVjdF9pZCk7CgogICAgJHZhcnMtPnsnY2xhc3NfZGVzY3JpcHRpb24nfSA9ICRjbGFzc19kZXNjcmlwdGlvbjsKICAgICR2YXJzLT57J3Byb2R1Y3RfaWQnfSAgICAgICAgPSAkcHJvZHVjdF9pZDsKICAgICR2YXJzLT57J3Byb2RfZGVzY3JpcHRpb24nfSAgPSAkcHJvZF9kZXNjcmlwdGlvbjsKICAgICR2YXJzLT57J21pbGVzdG9uZXVybCd9ICAgICAgPSAkbWlsZXN0b25ldXJsOwogICAgJHZhcnMtPnsnZGlzYWxsb3duZXcnfSAgICAgICA9ICRkaXNhbGxvd25ldzsKICAgICR2YXJzLT57J3Byb2R1Y3RfbmFtZSd9ICAgICAgPSAkcHJvZHVjdDsKCiAgICAkdmFycy0+eydjb21wb25lbnRzJ30gPSAkZGJoLT5zZWxlY3RhbGxfYXJyYXlyZWYocXsKICAgICAgICBTRUxFQ1QgbmFtZSwgZGVzY3JpcHRpb24gRlJPTSBjb21wb25lbnRzCiAgICAgICAgV0hFUkUgcHJvZHVjdF9pZCA9ID8gT1JERVIgQlkgbmFtZX0sIHsnU2xpY2UnID0+IHt9fSwKICAgICAgICAkcHJvZHVjdF9pZCk7CgogICAgJHZhcnMtPnsndmVyc2lvbnMnfSA9ICRkYmgtPnNlbGVjdGNvbF9hcnJheXJlZihxewogICAgICAgICAgICBTRUxFQ1QgdmFsdWUgRlJPTSB2ZXJzaW9ucwogICAgICAgICAgICBXSEVSRSBwcm9kdWN0X2lkID0gPyBPUkRFUiBCWSB2YWx1ZX0sIHVuZGVmLAogICAgICAgICAgICAkcHJvZHVjdF9pZCk7CgogICAgIyBBZGRpbmcgbGlzdGluZyBmb3IgYXNzb2NpYXRlZCB0YXJnZXQgbWlsZXN0b25lcyAtIAogICAgIyBtYXR0aGV3QHplcm9rbm93bGVkZ2UuY29tCiAgICBpZiAoUGFyYW0oJ3VzZXRhcmdldG1pbGVzdG9uZScpKSB7CiAgICAgICAgJHZhcnMtPnsnbWlsZXN0b25lcyd9ID0gJGRiaC0+c2VsZWN0Y29sX2FycmF5cmVmKHF7CiAgICAgICAgICAgIFNFTEVDVCB2YWx1ZSBGUk9NIG1pbGVzdG9uZXMKICAgICAgICAgICAgV0hFUkUgcHJvZHVjdF9pZCA9ID8KICAgICAgICAgICAgT1JERVIgQlkgc29ydGtleSwgdmFsdWV9LCB1bmRlZiwgJHByb2R1Y3RfaWQpOwogICAgfQoKICAgICgkdmFycy0+eydidWdfY291bnQnfSkgPSAkZGJoLT5zZWxlY3Ryb3dfYXJyYXkocXsKICAgICAgICBTRUxFQ1QgQ09VTlQoKikgRlJPTSBidWdzIFdIRVJFIHByb2R1Y3RfaWQgPSA/fSwKICAgICAgICB1bmRlZiwgJHByb2R1Y3RfaWQpIHx8IDA7CiAKICAgICR0ZW1wbGF0ZS0+cHJvY2VzcygiYWRtaW4vcHJvZHVjdHMvY29uZmlybS1kZWxldGUuaHRtbC50bXBsIiwgJHZhcnMpCiAgICAgICAgfHwgVGhyb3dUZW1wbGF0ZUVycm9yKCR0ZW1wbGF0ZS0+ZXJyb3IoKSk7CiAgICBleGl0Owp9CgojCiMgYWN0aW9uPSdkZWxldGUnIC0+IHJlYWxseSBkZWxldGUgdGhlIHByb2R1Y3QKIwoKaWYgKCRhY3Rpb24gZXEgJ2RlbGV0ZScpIHsKICAgIAogICAgaWYgKCEkcHJvZHVjdCkgewogICAgICAgIFRocm93VXNlckVycm9yKCdwcm9kdWN0X25vdF9zcGVjaWZpZWQnKTsKICAgIH0KCiAgICBteSAkcHJvZHVjdF9pZCA9IGdldF9wcm9kdWN0X2lkKCRwcm9kdWN0KTsKICAgICRwcm9kdWN0X2lkIHx8IFRocm93VXNlckVycm9yKCdwcm9kdWN0X2RvZXNudF9leGlzdCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7cHJvZHVjdCA9PiAkcHJvZHVjdH0pOwoKICAgICR2YXJzLT57J3Byb2R1Y3QnfSA9ICRwcm9kdWN0OwogICAgJHZhcnMtPnsnY2xhc3NpZmljYXRpb24nfSA9ICRjbGFzc2lmaWNhdGlvbjsKCiAgICBteSAkYnVnX2lkcyA9ICRkYmgtPnNlbGVjdGNvbF9hcnJheXJlZihxewogICAgICAgIFNFTEVDVCBidWdfaWQgRlJPTSBidWdzCiAgICAgICAgV0hFUkUgcHJvZHVjdF9pZCA9ID99LCB1bmRlZiwgJHByb2R1Y3RfaWQpOwoKICAgIG15ICRuYl9idWdzID0gc2NhbGFyKEAkYnVnX2lkcyk7CiAgICBpZiAoJG5iX2J1Z3MpIHsKICAgICAgICBpZiAoUGFyYW0oImFsbG93YnVnZGVsZXRpb24iKSkgewogICAgICAgICAgICBmb3JlYWNoIG15ICRidWdfaWQgKEAkYnVnX2lkcykgewogICAgICAgICAgICAgICAgbXkgJGJ1ZyA9IG5ldyBCdWd6aWxsYTo6QnVnKCRidWdfaWQsICR3aG9pZCk7CiAgICAgICAgICAgICAgICAkYnVnLT5yZW1vdmVfZnJvbV9kYigpOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgICAgIGVsc2UgewogICAgICAgICAgICBUaHJvd1VzZXJFcnJvcigicHJvZHVjdF9oYXNfYnVncyIsIHsgbmIgPT4gJG5iX2J1Z3MgfSk7CiAgICAgICAgfQogICAgICAgICR2YXJzLT57J25iX2J1Z3MnfSA9ICRuYl9idWdzOwogICAgfQoKICAgICRkYmgtPmJ6X2xvY2tfdGFibGVzKCdwcm9kdWN0cyBXUklURScsICdjb21wb25lbnRzIFdSSVRFJywKICAgICAgICAgICAgICAgICAgICAgICAgICd2ZXJzaW9ucyBXUklURScsICdtaWxlc3RvbmVzIFdSSVRFJywKICAgICAgICAgICAgICAgICAgICAgICAgICdncm91cF9jb250cm9sX21hcCBXUklURScsCiAgICAgICAgICAgICAgICAgICAgICAgICAnZmxhZ2luY2x1c2lvbnMgV1JJVEUnLCAnZmxhZ2V4Y2x1c2lvbnMgV1JJVEUnKTsKCiAgICAkZGJoLT5kbygiREVMRVRFIEZST00gY29tcG9uZW50cyBXSEVSRSBwcm9kdWN0X2lkID0gPyIsCiAgICAgICAgICAgICB1bmRlZiwgJHByb2R1Y3RfaWQpOwoKICAgICRkYmgtPmRvKCJERUxFVEUgRlJPTSB2ZXJzaW9ucyBXSEVSRSBwcm9kdWN0X2lkID0gPyIsCiAgICAgICAgICAgICB1bmRlZiwgJHByb2R1Y3RfaWQpOwoKICAgICRkYmgtPmRvKCJERUxFVEUgRlJPTSBtaWxlc3RvbmVzIFdIRVJFIHByb2R1Y3RfaWQgPSA/IiwKICAgICAgICAgICAgIHVuZGVmLCAkcHJvZHVjdF9pZCk7CgogICAgJGRiaC0+ZG8oIkRFTEVURSBGUk9NIGdyb3VwX2NvbnRyb2xfbWFwIFdIRVJFIHByb2R1Y3RfaWQgPSA/IiwKICAgICAgICAgICAgIHVuZGVmLCAkcHJvZHVjdF9pZCk7CgogICAgJGRiaC0+ZG8oIkRFTEVURSBGUk9NIGZsYWdpbmNsdXNpb25zIFdIRVJFIHByb2R1Y3RfaWQgPSA/IiwKICAgICAgICAgICAgIHVuZGVmLCAkcHJvZHVjdF9pZCk7CiAgICAgICAgICAgICAKICAgICRkYmgtPmRvKCJERUxFVEUgRlJPTSBmbGFnZXhjbHVzaW9ucyBXSEVSRSBwcm9kdWN0X2lkID0gPyIsCiAgICAgICAgICAgICB1bmRlZiwgJHByb2R1Y3RfaWQpOwogICAgICAgICAgICAgCiAgICAkZGJoLT5kbygiREVMRVRFIEZST00gcHJvZHVjdHMgV0hFUkUgaWQgPSA/IiwKICAgICAgICAgICAgIHVuZGVmLCAkcHJvZHVjdF9pZCk7CgogICAgJGRiaC0+YnpfdW5sb2NrX3RhYmxlcygpOwoKICAgIHVubGluayAiJGRhdGFkaXIvdmVyc2lvbmNhY2hlIjsKCiAgICAkdGVtcGxhdGUtPnByb2Nlc3MoImFkbWluL3Byb2R1Y3RzL2RlbGV0ZWQuaHRtbC50bXBsIiwgJHZhcnMpCiAgICAgICAgfHwgVGhyb3dUZW1wbGF0ZUVycm9yKCR0ZW1wbGF0ZS0+ZXJyb3IoKSk7CiAgICBleGl0Owp9CgojCiMgYWN0aW9uPSdlZGl0JyAtPiBwcmVzZW50IHRoZSAnZWRpdCBwcm9kdWN0JyBmb3JtCiMgSWYgYSBwcm9kdWN0IGlzIGdpdmVuIHdpdGggbm8gYWN0aW9uIGFzc29jaWF0ZWQgd2l0aCBpdCwgdGhlbiBlZGl0IGl0LgojCiMgKG5leHQgYWN0aW9uIHdvdWxkIGJlICd1cGRhdGUnKQojCgppZiAoJGFjdGlvbiBlcSAnZWRpdCcgfHwgKCEkYWN0aW9uICYmICRwcm9kdWN0KSkgewogICAgUHV0SGVhZGVyKCJFZGl0IFByb2R1Y3QiKTsKICAgIENoZWNrUHJvZHVjdCgkcHJvZHVjdCk7CiAgICBteSAkY2xhc3NpZmljYXRpb25faWQ9MTsKICAgIGlmIChQYXJhbSgndXNlY2xhc3NpZmljYXRpb24nKSkgewogICAgICAgICMgSWYgYSBwcm9kdWN0IGhhcyBiZWVuIGdpdmVuIHdpdGggbm8gY2xhc3NpZmljYXRpb24gYXNzb2NpYXRlZAogICAgICAgICMgd2l0aCBpdCwgdGFrZSB0aGlzIGluZm9ybWF0aW9uIGZyb20gdGhlIERCCiAgICAgICAgaWYgKCRjbGFzc2lmaWNhdGlvbikgewogICAgICAgICAgICBDaGVja0NsYXNzaWZpY2F0aW9uUHJvZHVjdCgkY2xhc3NpZmljYXRpb24sICRwcm9kdWN0KTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICB0cmlja190YWludCgkcHJvZHVjdCk7CiAgICAgICAgICAgICRjbGFzc2lmaWNhdGlvbiA9CiAgICAgICAgICAgICAgICAkZGJoLT5zZWxlY3Ryb3dfYXJyYXkoIlNFTEVDVCBjbGFzc2lmaWNhdGlvbnMubmFtZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGUk9NIHByb2R1Y3RzLCBjbGFzc2lmaWNhdGlvbnMKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0hFUkUgcHJvZHVjdHMubmFtZSA9ID8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQU5EIGNsYXNzaWZpY2F0aW9ucy5pZCA9IHByb2R1Y3RzLmNsYXNzaWZpY2F0aW9uX2lkIiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5kZWYsICRwcm9kdWN0KTsKICAgICAgICB9CiAgICAgICAgJGNsYXNzaWZpY2F0aW9uX2lkID0gZ2V0X2NsYXNzaWZpY2F0aW9uX2lkKCRjbGFzc2lmaWNhdGlvbik7CiAgICB9CgogICAgIyBnZXQgZGF0YSBvZiBwcm9kdWN0CiAgICBTZW5kU1FMKCJTRUxFQ1QgY2xhc3NpZmljYXRpb25zLmRlc2NyaXB0aW9uLAogICAgICAgICAgICAgICAgICAgIHByb2R1Y3RzLmlkLHByb2R1Y3RzLmRlc2NyaXB0aW9uLG1pbGVzdG9uZXVybCxkaXNhbGxvd25ldywKICAgICAgICAgICAgICAgICAgICB2b3Rlc3BlcnVzZXIsbWF4dm90ZXNwZXJidWcsdm90ZXN0b2NvbmZpcm0sZGVmYXVsdG1pbGVzdG9uZQogICAgICAgICAgICAgRlJPTSBwcm9kdWN0cyxjbGFzc2lmaWNhdGlvbnMKICAgICAgICAgICAgIFdIRVJFIHByb2R1Y3RzLm5hbWU9IiAuIFNxbFF1b3RlKCRwcm9kdWN0KSAuCiAgICAgICAgICAgICIgQU5EIGNsYXNzaWZpY2F0aW9ucy5pZD0iIC4gU3FsUXVvdGUoJGNsYXNzaWZpY2F0aW9uX2lkKSk7CiAgICBteSAoJGNsYXNzX2Rlc2NyaXB0aW9uLCAkcHJvZHVjdF9pZCwkcHJvZF9kZXNjcmlwdGlvbiwgJG1pbGVzdG9uZXVybCwgJGRpc2FsbG93bmV3LAogICAgICAgICR2b3Rlc3BlcnVzZXIsICRtYXh2b3Rlc3BlcmJ1ZywgJHZvdGVzdG9jb25maXJtLCAkZGVmYXVsdG1pbGVzdG9uZSkgPQogICAgICAgIEZldGNoU1FMRGF0YSgpOwoKICAgIHByaW50ICI8Rk9STSBNRVRIT0Q9UE9TVCBBQ1RJT049ZWRpdHByb2R1Y3RzLmNnaT5cbiI7CiAgICBwcmludCAiPFRBQkxFICBCT1JERVI9MCBDRUxMUEFERElORz00IENFTExTUEFDSU5HPTA+PFRSPlxuIjsKCiAgICBFbWl0Rm9ybUVsZW1lbnRzKCRjbGFzc2lmaWNhdGlvbiwgJHByb2R1Y3QsICRwcm9kX2Rlc2NyaXB0aW9uLCAkbWlsZXN0b25ldXJsLCAKICAgICAgICAgICAgICAgICAgICAgJGRpc2FsbG93bmV3LCAkdm90ZXNwZXJ1c2VyLCAkbWF4dm90ZXNwZXJidWcsCiAgICAgICAgICAgICAgICAgICAgICR2b3Rlc3RvY29uZmlybSwgJGRlZmF1bHRtaWxlc3RvbmUpOwogICAgCiAgICBwcmludCAiPC9UUj48VFIgVkFMSUdOPXRvcD5cbiI7CiAgICBwcmludCAiICA8VEggQUxJR049XCJyaWdodFwiPjxBIEhSRUY9XCJlZGl0Y29tcG9uZW50cy5jZ2k/cHJvZHVjdD0iLCB1cmxfcXVvdGUoJHByb2R1Y3QpLCAkY2xhc3NodG1sdmFyLCAiXCI+RWRpdCBjb21wb25lbnRzOjwvQT48L1RIPlxuIjsKICAgIHByaW50ICIgIDxURD4iOwogICAgU2VuZFNRTCgiU0VMRUNUIG5hbWUsZGVzY3JpcHRpb24KICAgICAgICAgICAgIEZST00gY29tcG9uZW50cwogICAgICAgICAgICAgV0hFUkUgcHJvZHVjdF9pZD0kcHJvZHVjdF9pZCIpOwogICAgaWYgKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICBwcmludCAiPHRhYmxlPiI7CiAgICAgICAgd2hpbGUgKCBNb3JlU1FMRGF0YSgpICkgewogICAgICAgICAgICBteSAoJGNvbXBvbmVudCwgJGRlc2NyaXB0aW9uKSA9IEZldGNoU1FMRGF0YSgpOwogICAgICAgICAgICAkZGVzY3JpcHRpb24gfHw9ICI8Rk9OVCBDT0xPUj1cInJlZFwiPmRlc2NyaXB0aW9uIG1pc3Npbmc8L0ZPTlQ+IjsKICAgICAgICAgICAgcHJpbnQgIjx0cj48dGggYWxpZ249cmlnaHQgdmFsaWduPXRvcD4kY29tcG9uZW50OjwvdGg+IjsKICAgICAgICAgICAgcHJpbnQgIjx0ZCB2YWxpZ249dG9wPiRkZXNjcmlwdGlvbjwvdGQ+PC90cj5cbiI7CiAgICAgICAgfQogICAgICAgIHByaW50ICI8L3RhYmxlPlxuIjsKICAgIH0gZWxzZSB7CiAgICAgICAgcHJpbnQgIjxGT05UIENPTE9SPVwicmVkXCI+bWlzc2luZzwvRk9OVD4iOwogICAgfQoKCiAgICBwcmludCAiPC9URD5cbjwvVFI+PFRSPlxuIjsKICAgIHByaW50ICIgIDxUSCBBTElHTj1cInJpZ2h0XCIgVkFMSUdOPVwidG9wXCI+PEEgSFJFRj1cImVkaXR2ZXJzaW9ucy5jZ2k/cHJvZHVjdD0iLCB1cmxfcXVvdGUoJHByb2R1Y3QpLCAkY2xhc3NodG1sdmFyLCAiXCI+RWRpdCB2ZXJzaW9uczo8L0E+PC9USD5cbiI7CiAgICBwcmludCAiICA8VEQ+IjsKICAgIFNlbmRTUUwoIlNFTEVDVCB2YWx1ZQogICAgICAgICAgICAgRlJPTSB2ZXJzaW9ucwogICAgICAgICAgICAgV0hFUkUgcHJvZHVjdF9pZD0kcHJvZHVjdF9pZAogICAgICAgICAgICAgT1JERVIgQlkgdmFsdWUiKTsKICAgIGlmIChNb3JlU1FMRGF0YSgpKSB7CiAgICAgICAgbXkgJGJyID0gMDsKICAgICAgICB3aGlsZSAoIE1vcmVTUUxEYXRhKCkgKSB7CiAgICAgICAgICAgIG15ICgkdmVyc2lvbikgPSBGZXRjaFNRTERhdGEoKTsKICAgICAgICAgICAgcHJpbnQgIjxCUj4iIGlmICRicjsKICAgICAgICAgICAgcHJpbnQgJHZlcnNpb247CiAgICAgICAgICAgICRiciA9IDE7CiAgICAgICAgfQogICAgfSBlbHNlIHsKICAgICAgICBwcmludCAiPEZPTlQgQ09MT1I9XCJyZWRcIj5taXNzaW5nPC9GT05UPiI7CiAgICB9CgogICAgIwogICAgIyBBZGRpbmcgbGlzdGluZyBmb3IgYXNzb2NpYXRlZCB0YXJnZXQgbWlsZXN0b25lcyAtIG1hdHRoZXdAemVyb2tub3dsZWRnZS5jb20KICAgICMKICAgIGlmIChQYXJhbSgndXNldGFyZ2V0bWlsZXN0b25lJykpIHsKICAgICAgICBwcmludCAiPC9URD5cbjwvVFI+PFRSPlxuIjsKICAgICAgICBwcmludCAiICA8VEggQUxJR049XCJyaWdodFwiIFZBTElHTj1cInRvcFwiPjxBIEhSRUY9XCJlZGl0bWlsZXN0b25lcy5jZ2k/cHJvZHVjdD0iLCB1cmxfcXVvdGUoJHByb2R1Y3QpLCAkY2xhc3NodG1sdmFyLCAiXCI+RWRpdCBtaWxlc3RvbmVzOjwvQT48L1RIPlxuIjsKICAgICAgICBwcmludCAiICA8VEQ+IjsKICAgICAgICBTZW5kU1FMKCJTRUxFQ1QgdmFsdWUKICAgICAgICAgICAgICAgICBGUk9NIG1pbGVzdG9uZXMKICAgICAgICAgICAgICAgICBXSEVSRSBwcm9kdWN0X2lkPSRwcm9kdWN0X2lkCiAgICAgICAgICAgICAgICAgT1JERVIgQlkgc29ydGtleSx2YWx1ZSIpOwogICAgICAgIGlmKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICAgICAgbXkgJGJyID0gMDsKICAgICAgICAgICAgd2hpbGUgKCBNb3JlU1FMRGF0YSgpICkgewogICAgICAgICAgICAgICAgbXkgKCRtaWxlc3RvbmUpID0gRmV0Y2hTUUxEYXRhKCk7CiAgICAgICAgICAgICAgICBwcmludCAiPEJSPiIgaWYgJGJyOwogICAgICAgICAgICAgICAgcHJpbnQgJG1pbGVzdG9uZTsKICAgICAgICAgICAgICAgICRiciA9IDE7CiAgICAgICAgICAgIH0KICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBwcmludCAiPEZPTlQgQ09MT1I9XCJyZWRcIj5taXNzaW5nPC9GT05UPiI7CiAgICAgICAgfQogICAgfQoKICAgIHByaW50ICI8L1REPlxuPC9UUj48VFI+XG4iOwogICAgcHJpbnQgIiAgPFRIIEFMSUdOPVwicmlnaHRcIiBWQUxJR049XCJ0b3BcIj48QSBIUkVGPVwiZWRpdHByb2R1Y3RzLmNnaT9hY3Rpb249ZWRpdGdyb3VwY29udHJvbHMmcHJvZHVjdD0iLCB1cmxfcXVvdGUoJHByb2R1Y3QpLCAkY2xhc3NodG1sdmFyLCJcIj5FZGl0IEdyb3VwIEFjY2VzcyBDb250cm9sczo8L0E+PC9USD5cbiI7CiAgICBwcmludCAiPFREPlxuIjsKICAgIFNlbmRTUUwoIlNFTEVDVCBpZCwgbmFtZSwgaXNhY3RpdmUsIGVudHJ5LCBtZW1iZXJjb250cm9sLCBvdGhlcmNvbnRyb2wsIGNhbmVkaXQgIiAuCiAgICAgICAgICAgICJGUk9NIGdyb3VwcywgIiAuCiAgICAgICAgICAgICJncm91cF9jb250cm9sX21hcCAiIC4KICAgICAgICAgICAgIldIRVJFIGdyb3VwX2NvbnRyb2xfbWFwLmdyb3VwX2lkID0gaWQgQU5EIHByb2R1Y3RfaWQgPSAkcHJvZHVjdF9pZCAiIC4KICAgICAgICAgICAgIkFORCBpc2J1Z2dyb3VwICE9IDAgT1JERVIgQlkgbmFtZSIpOwogICAgd2hpbGUgKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICBteSAoJGlkLCAkbmFtZSwgJGlzYWN0aXZlLCAkZW50cnksICRtZW1iZXJjb250cm9sLCAkb3RoZXJjb250cm9sLCAkY2FuZWRpdCkgCiAgICAgICAgICAgID0gRmV0Y2hTUUxEYXRhKCk7CiAgICAgICAgcHJpbnQgIjxCPiIgLiBodG1sX3F1b3RlKCRuYW1lKSAuICI6PC9CPiAiOwogICAgICAgIGlmICgkaXNhY3RpdmUpIHsKICAgICAgICAgICAgcHJpbnQgJGN0bHskbWVtYmVyY29udHJvbH0gLiAiLyIgLiAkY3RseyRvdGhlcmNvbnRyb2x9OyAKICAgICAgICAgICAgcHJpbnQgIiwgRU5UUlkiIGlmICRlbnRyeTsKICAgICAgICAgICAgcHJpbnQgIiwgQ0FORURJVCIgaWYgJGNhbmVkaXQ7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgcHJpbnQgIkRJU0FCTEVEIjsKICAgICAgICB9CiAgICAgICAgcHJpbnQgIjxCUj5cbiI7CiAgICB9CiAgICBwcmludCAiPC9URD5cbjwvVFI+PFRSPlxuIjsKICAgIHByaW50ICIgIDxUSCBBTElHTj1cInJpZ2h0XCI+QnVnczo8L1RIPlxuIjsKICAgIHByaW50ICIgIDxURD4iOwogICAgU2VuZFNRTCgiU0VMRUNUIGNvdW50KGJ1Z19pZCksIHByb2R1Y3RfaWQKICAgICAgICAgICAgIEZST00gYnVncyAiIC4KICAgICAgICAgICAgJGRiaC0+c3FsX2dyb3VwX2J5KCdwcm9kdWN0X2lkJykgLiAiCiAgICAgICAgICAgICBIQVZJTkcgcHJvZHVjdF9pZCA9ICRwcm9kdWN0X2lkIik7CiAgICBteSAkYnVncyA9ICcnOwogICAgJGJ1Z3MgPSBGZXRjaE9uZUNvbHVtbigpIGlmIE1vcmVTUUxEYXRhKCk7CiAgICBwcmludCAkYnVncyB8fCAnbm9uZSc7CgogICAgcHJpbnQgIjwvVEQ+XG48L1RSPjwvVEFCTEU+XG4iOwoKICAgIHByaW50ICI8SU5QVVQgVFlQRT1ISURERU4gTkFNRT1cImNsYXNzaWZpY2F0aW9uXCIgVkFMVUU9XCIiIC4KICAgICAgICBodG1sX3F1b3RlKCRjbGFzc2lmaWNhdGlvbikgLiAiXCI+XG4iOwogICAgcHJpbnQgIjxJTlBVVCBUWVBFPUhJRERFTiBOQU1FPVwicHJvZHVjdG9sZFwiIFZBTFVFPVwiIiAuCiAgICAgICAgaHRtbF9xdW90ZSgkcHJvZHVjdCkgLiAiXCI+XG4iOwogICAgcHJpbnQgIjxJTlBVVCBUWVBFPUhJRERFTiBOQU1FPVwiZGVzY3JpcHRpb25vbGRcIiBWQUxVRT1cIiIgLgogICAgICAgIGh0bWxfcXVvdGUoJHByb2RfZGVzY3JpcHRpb24pIC4gIlwiPlxuIjsKICAgIHByaW50ICI8SU5QVVQgVFlQRT1ISURERU4gTkFNRT1cIm1pbGVzdG9uZXVybG9sZFwiIFZBTFVFPVwiIiAuCiAgICAgICAgaHRtbF9xdW90ZSgkbWlsZXN0b25ldXJsKSAuICJcIj5cbiI7CiAgICBwcmludCAiPElOUFVUIFRZUEU9SElEREVOIE5BTUU9XCJkaXNhbGxvd25ld29sZFwiIFZBTFVFPVwiJGRpc2FsbG93bmV3XCI+XG4iOwogICAgcHJpbnQgIjxJTlBVVCBUWVBFPUhJRERFTiBOQU1FPVwidm90ZXNwZXJ1c2Vyb2xkXCIgVkFMVUU9XCIkdm90ZXNwZXJ1c2VyXCI+XG4iOwogICAgcHJpbnQgIjxJTlBVVCBUWVBFPUhJRERFTiBOQU1FPVwibWF4dm90ZXNwZXJidWdvbGRcIiBWQUxVRT1cIiRtYXh2b3Rlc3BlcmJ1Z1wiPlxuIjsKICAgIHByaW50ICI8SU5QVVQgVFlQRT1ISURERU4gTkFNRT1cInZvdGVzdG9jb25maXJtb2xkXCIgVkFMVUU9XCIkdm90ZXN0b2NvbmZpcm1cIj5cbiI7CiAgICAkZGVmYXVsdG1pbGVzdG9uZSA9IHZhbHVlX3F1b3RlKCRkZWZhdWx0bWlsZXN0b25lKTsKICAgIHByaW50ICI8SU5QVVQgVFlQRT1ISURERU4gTkFNRT1cImRlZmF1bHRtaWxlc3RvbmVvbGRcIiBWQUxVRT1cIiRkZWZhdWx0bWlsZXN0b25lXCI+XG4iOwogICAgcHJpbnQgIjxJTlBVVCBUWVBFPUhJRERFTiBOQU1FPVwiYWN0aW9uXCIgVkFMVUU9XCJ1cGRhdGVcIj5cbiI7CiAgICBwcmludCAiPElOUFVUIFRZUEU9U1VCTUlUIFZBTFVFPVwiVXBkYXRlXCI+XG4iOwoKICAgIHByaW50ICI8L0ZPUk0+IjsKCiAgICBteSAkeCA9ICRsb2NhbHRyYWlsZXI7CiAgICAkeCA9fiBzL21vcmUvb3RoZXIvOwogICAgUHV0VHJhaWxlcigkeCk7CiAgICBleGl0Owp9CgojCiMgYWN0aW9uPSd1cGRhdGVncm91cGNvbnRyb2xzJyAtPiB1cGRhdGUgdGhlIHByb2R1Y3QKIwoKaWYgKCRhY3Rpb24gZXEgJ3VwZGF0ZWdyb3VwY29udHJvbHMnKSB7CiAgICBteSAkcHJvZHVjdF9pZCA9IGdldF9wcm9kdWN0X2lkKCRwcm9kdWN0KTsKICAgIG15IEBub3dfbmEgPSAoKTsKICAgIG15IEBub3dfbWFuZGF0b3J5ID0gKCk7CiAgICBmb3JlYWNoIG15ICRmICgkY2dpLT5wYXJhbSgpKSB7CiAgICAgICAgaWYgKCRmID1+IC9ebWVtYmVyY29udHJvbF8oXGQrKSQvKSB7CiAgICAgICAgICAgIG15ICRpZCA9ICQxOwogICAgICAgICAgICBpZiAoJGNnaS0+cGFyYW0oJGYpID09IENPTlRST0xNQVBOQSkgewogICAgICAgICAgICAgICAgcHVzaCBAbm93X25hLCRpZDsKICAgICAgICAgICAgfSBlbHNpZiAoJGNnaS0+cGFyYW0oJGYpID09IENPTlRST0xNQVBNQU5EQVRPUlkpIHsKICAgICAgICAgICAgICAgIHB1c2ggQG5vd19tYW5kYXRvcnksJGlkOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgaWYgKCFkZWZpbmVkICRjZ2ktPnBhcmFtKCdjb25maXJtZWQnKSkgewogICAgICAgIG15IEBuYV9ncm91cHMgPSAoKTsKICAgICAgICBpZiAoQG5vd19uYSkgewogICAgICAgICAgICBTZW5kU1FMKCJTRUxFQ1QgZ3JvdXBzLm5hbWUsIENPVU5UKGJ1Z3MuYnVnX2lkKSAKICAgICAgICAgICAgICAgICAgICAgRlJPTSBidWdzLCBidWdfZ3JvdXBfbWFwLCBncm91cHMKICAgICAgICAgICAgICAgICAgICAgV0hFUkUgZ3JvdXBzLmlkIElOKCIgLiBqb2luKCcsICcsIEBub3dfbmEpIC4gIikKICAgICAgICAgICAgICAgICAgICAgQU5EIGJ1Z19ncm91cF9tYXAuZ3JvdXBfaWQgPSBncm91cHMuaWQKICAgICAgICAgICAgICAgICAgICAgQU5EIGJ1Z19ncm91cF9tYXAuYnVnX2lkID0gYnVncy5idWdfaWQKICAgICAgICAgICAgICAgICAgICAgQU5EIGJ1Z3MucHJvZHVjdF9pZCA9ICRwcm9kdWN0X2lkICIgLgogICAgICAgICAgICAgICAgICAgICRkYmgtPnNxbF9ncm91cF9ieSgnZ3JvdXBzLm5hbWUnKSk7CiAgICAgICAgICAgIHdoaWxlIChNb3JlU1FMRGF0YSgpKSB7CiAgICAgICAgICAgICAgICBteSAoJGdyb3VwbmFtZSwgJGJ1Z2NvdW50KSA9IEZldGNoU1FMRGF0YSgpOwogICAgICAgICAgICAgICAgbXkgJWcgPSAoKTsKICAgICAgICAgICAgICAgICRneyduYW1lJ30gPSAkZ3JvdXBuYW1lOwogICAgICAgICAgICAgICAgJGd7J2NvdW50J30gPSAkYnVnY291bnQ7CiAgICAgICAgICAgICAgICBwdXNoIEBuYV9ncm91cHMsXCVnOwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICBteSBAbWFuZGF0b3J5X2dyb3VwcyA9ICgpOwogICAgICAgIGlmIChAbm93X21hbmRhdG9yeSkgewogICAgICAgICAgICBTZW5kU1FMKCJTRUxFQ1QgZ3JvdXBzLm5hbWUsIENPVU5UKGJ1Z3MuYnVnX2lkKSAKICAgICAgICAgICAgICAgICAgICAgICBGUk9NIGJ1Z3MKICAgICAgICAgICAgICAgICAgTEVGVCBKT0lOIGJ1Z19ncm91cF9tYXAKICAgICAgICAgICAgICAgICAgICAgICAgIE9OIGJ1Z19ncm91cF9tYXAuYnVnX2lkID0gYnVncy5idWdfaWQKICAgICAgICAgICAgICAgICBJTk5FUiBKT0lOIGdyb3VwcwogICAgICAgICAgICAgICAgICAgICAgICAgT04gYnVnX2dyb3VwX21hcC5ncm91cF9pZCA9IGdyb3Vwcy5pZAogICAgICAgICAgICAgICAgICAgICAgV0hFUkUgZ3JvdXBzLmlkIElOKCIgLiBqb2luKCcsICcsIEBub3dfbWFuZGF0b3J5KSAuICIpCiAgICAgICAgICAgICAgICAgICAgICAgIEFORCBidWdzLnByb2R1Y3RfaWQgPSAkcHJvZHVjdF9pZAogICAgICAgICAgICAgICAgICAgICAgICBBTkQgYnVnX2dyb3VwX21hcC5idWdfaWQgSVMgTlVMTCAiIC4KICAgICAgICAgICAgICAgICAgICAgICAgJGRiaC0+c3FsX2dyb3VwX2J5KCdncm91cHMubmFtZScpKTsKICAgICAgICAgICAgd2hpbGUgKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICAgICAgICAgIG15ICgkZ3JvdXBuYW1lLCAkYnVnY291bnQpID0gRmV0Y2hTUUxEYXRhKCk7CiAgICAgICAgICAgICAgICBteSAlZyA9ICgpOwogICAgICAgICAgICAgICAgJGd7J25hbWUnfSA9ICRncm91cG5hbWU7CiAgICAgICAgICAgICAgICAkZ3snY291bnQnfSA9ICRidWdjb3VudDsKICAgICAgICAgICAgICAgIHB1c2ggQG1hbmRhdG9yeV9ncm91cHMsXCVnOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgICAgIGlmICgoQG5hX2dyb3VwcykgfHwgKEBtYW5kYXRvcnlfZ3JvdXBzKSkgewogICAgICAgICAgICAkdmFycy0+eydwcm9kdWN0J30gPSAkcHJvZHVjdDsKICAgICAgICAgICAgJHZhcnMtPnsnbmFfZ3JvdXBzJ30gPSBcQG5hX2dyb3VwczsKICAgICAgICAgICAgJHZhcnMtPnsnbWFuZGF0b3J5X2dyb3Vwcyd9ID0gXEBtYW5kYXRvcnlfZ3JvdXBzOwogICAgICAgICAgICAkdGVtcGxhdGUtPnByb2Nlc3MoImFkbWluL3Byb2R1Y3RzL2dyb3VwY29udHJvbC9jb25maXJtLWVkaXQuaHRtbC50bXBsIiwgJHZhcnMpCiAgICAgICAgICAgICAgICB8fCBUaHJvd1RlbXBsYXRlRXJyb3IoJHRlbXBsYXRlLT5lcnJvcigpKTsKICAgICAgICAgICAgZXhpdDsgICAgICAgICAgICAgICAgCiAgICAgICAgfQogICAgfQogICAgUHV0SGVhZGVyKCJVcGRhdGUgZ3JvdXAgYWNjZXNzIGNvbnRyb2xzIGZvciAkcHJvZHVjdCIpOwogICAgJGhlYWRlcmRvbmUgPSAxOwogICAgU2VuZFNRTCgiU0VMRUNUIGlkLCBuYW1lIEZST00gZ3JvdXBzICIgLgogICAgICAgICAgICAiV0hFUkUgaXNidWdncm91cCAhPSAwIEFORCBpc2FjdGl2ZSAhPSAwIik7CiAgICB3aGlsZSAoTW9yZVNRTERhdGEoKSl7CiAgICAgICAgbXkgKCRncm91cGlkLCAkZ3JvdXBuYW1lKSA9IEZldGNoU1FMRGF0YSgpOwogICAgICAgIG15ICRuZXdtZW1iZXJjb250cm9sID0gJGNnaS0+cGFyYW0oIm1lbWJlcmNvbnRyb2xfJGdyb3VwaWQiKSB8fCAwOwogICAgICAgIG15ICRuZXdvdGhlcmNvbnRyb2wgPSAkY2dpLT5wYXJhbSgib3RoZXJjb250cm9sXyRncm91cGlkIikgfHwgMDsKICAgICAgICAjICBMZWdhbGl0eSBvZiBjb250cm9sIGNvbWJpbmF0aW9uIGlzIGEgZnVuY3Rpb24gb2YKICAgICAgICAjICBtZW1iZXJjb250cm9sXG90aGVyY29udHJvbAogICAgICAgICMgICAgICAgICAgICAgICAgIE5BIFNIIERFIE1BCiAgICAgICAgIyAgICAgICAgICAgICAgTkEgICsgIC0gIC0gIC0KICAgICAgICAjICAgICAgICAgICAgICBTSCAgKyAgKyAgKyAgKwogICAgICAgICMgICAgICAgICAgICAgIERFICArICAtICArICArCiAgICAgICAgIyAgICAgICAgICAgICAgTUEgIC0gIC0gIC0gICsKICAgICAgICB1bmxlc3MgKCgkbmV3bWVtYmVyY29udHJvbCA9PSAkbmV3b3RoZXJjb250cm9sKQogICAgICAgICAgICAgIHx8ICgkbmV3bWVtYmVyY29udHJvbCA9PSBDT05UUk9MTUFQU0hPV04pCiAgICAgICAgICAgICAgfHwgKCgkbmV3bWVtYmVyY29udHJvbCA9PSBDT05UUk9MTUFQREVGQVVMVCkKICAgICAgICAgICAgICAgJiYgKCRuZXdvdGhlcmNvbnRyb2wgIT0gQ09OVFJPTE1BUFNIT1dOKSkpIHsKICAgICAgICAgICAgVGhyb3dVc2VyRXJyb3IoJ2lsbGVnYWxfZ3JvdXBfY29udHJvbF9jb21iaW5hdGlvbicsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICB7Z3JvdXBuYW1lID0+ICRncm91cG5hbWUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVhZGVyX2RvbmUgPT4gMX0pOwogICAgICAgIH0KICAgIH0KICAgICRkYmgtPmJ6X2xvY2tfdGFibGVzKCdncm91cHMgUkVBRCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAnZ3JvdXBfY29udHJvbF9tYXAgV1JJVEUnLAogICAgICAgICAgICAgICAgICAgICAgICAgJ2J1Z3MgV1JJVEUnLAogICAgICAgICAgICAgICAgICAgICAgICAgJ2J1Z3NfYWN0aXZpdHkgV1JJVEUnLAogICAgICAgICAgICAgICAgICAgICAgICAgJ2J1Z19ncm91cF9tYXAgV1JJVEUnLAogICAgICAgICAgICAgICAgICAgICAgICAgJ2ZpZWxkZGVmcyBSRUFEJyk7CiAgICBTZW5kU1FMKCJTRUxFQ1QgaWQsIG5hbWUsIGVudHJ5LCBtZW1iZXJjb250cm9sLCBvdGhlcmNvbnRyb2wsIGNhbmVkaXQgIiAuCiAgICAgICAgICAgICJGUk9NIGdyb3VwcyAiIC4KICAgICAgICAgICAgIkxFRlQgSk9JTiBncm91cF9jb250cm9sX21hcCAiIC4KICAgICAgICAgICAgIk9OIGdyb3VwX2NvbnRyb2xfbWFwLmdyb3VwX2lkID0gaWQgQU5EIHByb2R1Y3RfaWQgPSAkcHJvZHVjdF9pZCAiIC4KICAgICAgICAgICAgIldIRVJFIGlzYnVnZ3JvdXAgIT0gMCBBTkQgaXNhY3RpdmUgIT0gMCIpOwogICAgd2hpbGUgKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICBteSAoJGdyb3VwaWQsICRncm91cG5hbWUsICRlbnRyeSwgJG1lbWJlcmNvbnRyb2wsIAogICAgICAgICAgICAkb3RoZXJjb250cm9sLCAkY2FuZWRpdCkgPSBGZXRjaFNRTERhdGEoKTsKICAgICAgICBteSAkbmV3ZW50cnkgPSAkY2dpLT5wYXJhbSgiZW50cnlfJGdyb3VwaWQiKSB8fCAwOwogICAgICAgIG15ICRuZXdtZW1iZXJjb250cm9sID0gJGNnaS0+cGFyYW0oIm1lbWJlcmNvbnRyb2xfJGdyb3VwaWQiKSB8fCAwOwogICAgICAgIG15ICRuZXdvdGhlcmNvbnRyb2wgPSAkY2dpLT5wYXJhbSgib3RoZXJjb250cm9sXyRncm91cGlkIikgfHwgMDsKICAgICAgICBteSAkbmV3Y2FuZWRpdCA9ICRjZ2ktPnBhcmFtKCJjYW5lZGl0XyRncm91cGlkIikgfHwgMDsKICAgICAgICBteSAkb2xkZW50cnkgPSAkZW50cnk7CiAgICAgICAgJGVudHJ5ID0gJGVudHJ5IHx8IDA7CiAgICAgICAgJG1lbWJlcmNvbnRyb2wgPSAkbWVtYmVyY29udHJvbCB8fCAwOwogICAgICAgICRvdGhlcmNvbnRyb2wgPSAkb3RoZXJjb250cm9sIHx8IDA7CiAgICAgICAgJGNhbmVkaXQgPSAkY2FuZWRpdCB8fCAwOwogICAgICAgIGRldGFpbnRfbmF0dXJhbCgkbmV3ZW50cnkpOwogICAgICAgIGRldGFpbnRfbmF0dXJhbCgkbmV3b3RoZXJjb250cm9sKTsKICAgICAgICBkZXRhaW50X25hdHVyYWwoJG5ld21lbWJlcmNvbnRyb2wpOwogICAgICAgIGRldGFpbnRfbmF0dXJhbCgkbmV3Y2FuZWRpdCk7CiAgICAgICAgaWYgKCghZGVmaW5lZCgkb2xkZW50cnkpKSAmJiAKICAgICAgICAgICAgICgoJG5ld2VudHJ5KSB8fCAoJG5ld21lbWJlcmNvbnRyb2wpIHx8ICgkbmV3Y2FuZWRpdCkpKSB7CiAgICAgICAgICAgIFB1c2hHbG9iYWxTUUxTdGF0ZSgpOwogICAgICAgICAgICBTZW5kU1FMKCJJTlNFUlQgSU5UTyBncm91cF9jb250cm9sX21hcCAiIC4KICAgICAgICAgICAgICAgICAgICAiKGdyb3VwX2lkLCBwcm9kdWN0X2lkLCBlbnRyeSwgIiAuCiAgICAgICAgICAgICAgICAgICAgIm1lbWJlcmNvbnRyb2wsIG90aGVyY29udHJvbCwgY2FuZWRpdCkgIiAuCiAgICAgICAgICAgICAgICAgICAgIlZBTFVFUyAiIC4KICAgICAgICAgICAgICAgICAgICAiKCRncm91cGlkLCAkcHJvZHVjdF9pZCwgJG5ld2VudHJ5LCAiIC4KICAgICAgICAgICAgICAgICAgICAiJG5ld21lbWJlcmNvbnRyb2wsICRuZXdvdGhlcmNvbnRyb2wsICRuZXdjYW5lZGl0KSIpOwogICAgICAgICAgICBQb3BHbG9iYWxTUUxTdGF0ZSgpOwogICAgICAgIH0gZWxzaWYgKCgkbmV3ZW50cnkgIT0gJGVudHJ5KSAKICAgICAgICAgICAgICAgICAgfHwgKCRuZXdtZW1iZXJjb250cm9sICE9ICRtZW1iZXJjb250cm9sKSAKICAgICAgICAgICAgICAgICAgfHwgKCRuZXdvdGhlcmNvbnRyb2wgIT0gJG90aGVyY29udHJvbCkgCiAgICAgICAgICAgICAgICAgIHx8ICgkbmV3Y2FuZWRpdCAhPSAkY2FuZWRpdCkpIHsKICAgICAgICAgICAgUHVzaEdsb2JhbFNRTFN0YXRlKCk7CiAgICAgICAgICAgIFNlbmRTUUwoIlVQREFURSBncm91cF9jb250cm9sX21hcCAiIC4KICAgICAgICAgICAgICAgICAgICAiU0VUIGVudHJ5ID0gJG5ld2VudHJ5LCAiIC4KICAgICAgICAgICAgICAgICAgICAibWVtYmVyY29udHJvbCA9ICRuZXdtZW1iZXJjb250cm9sLCAiIC4KICAgICAgICAgICAgICAgICAgICAib3RoZXJjb250cm9sID0gJG5ld290aGVyY29udHJvbCwgIiAuCiAgICAgICAgICAgICAgICAgICAgImNhbmVkaXQgPSAkbmV3Y2FuZWRpdCAiIC4KICAgICAgICAgICAgICAgICAgICAiV0hFUkUgZ3JvdXBfaWQgPSAkZ3JvdXBpZCAiIC4KICAgICAgICAgICAgICAgICAgICAiQU5EIHByb2R1Y3RfaWQgPSAkcHJvZHVjdF9pZCIpOwogICAgICAgICAgICBQb3BHbG9iYWxTUUxTdGF0ZSgpOwogICAgICAgIH0KCiAgICAgICAgaWYgKCgkbmV3ZW50cnkgPT0gMCkgJiYgKCRuZXdtZW1iZXJjb250cm9sID09IDApCiAgICAgICAgICAmJiAoJG5ld290aGVyY29udHJvbCA9PSAwKSAmJiAoJG5ld2NhbmVkaXQgPT0gMCkpIHsKICAgICAgICAgICAgUHVzaEdsb2JhbFNRTFN0YXRlKCk7CiAgICAgICAgICAgIFNlbmRTUUwoIkRFTEVURSBGUk9NIGdyb3VwX2NvbnRyb2xfbWFwICIgLgogICAgICAgICAgICAgICAgICAgICJXSEVSRSBncm91cF9pZCA9ICRncm91cGlkICIgLgogICAgICAgICAgICAgICAgICAgICJBTkQgcHJvZHVjdF9pZCA9ICRwcm9kdWN0X2lkIik7CiAgICAgICAgICAgIFBvcEdsb2JhbFNRTFN0YXRlKCk7CiAgICAgICAgfQogICAgfQoKICAgIGZvcmVhY2ggbXkgJGdyb3VwaWQgKEBub3dfbmEpIHsKICAgICAgICBwcmludCAiUmVtb3ZpbmcgYnVncyBmcm9tIE5BIGdyb3VwICIgCiAgICAgICAgICAgICAuIGh0bWxfcXVvdGUoR3JvdXBJZFRvTmFtZSgkZ3JvdXBpZCkpIC4gIjxQPlxuIjsKICAgICAgICBteSAkY291bnQgPSAwOwogICAgICAgIFNlbmRTUUwoIlNFTEVDVCBidWdzLmJ1Z19pZCwgCiAgICAgICAgICAgICAgICAgKGxhc3RkaWZmZWQgPj0gZGVsdGFfdHMpCiAgICAgICAgICAgICAgICAgRlJPTSBidWdzLCBidWdfZ3JvdXBfbWFwCiAgICAgICAgICAgICAgICAgV0hFUkUgZ3JvdXBfaWQgPSAkZ3JvdXBpZAogICAgICAgICAgICAgICAgIEFORCBidWdfZ3JvdXBfbWFwLmJ1Z19pZCA9IGJ1Z3MuYnVnX2lkCiAgICAgICAgICAgICAgICAgQU5EIGJ1Z3MucHJvZHVjdF9pZCA9ICRwcm9kdWN0X2lkCiAgICAgICAgICAgICAgICAgT1JERVIgQlkgYnVncy5idWdfaWQiKTsKICAgICAgICB3aGlsZSAoTW9yZVNRTERhdGEoKSkgewogICAgICAgICAgICBteSAoJGJ1Z2lkLCAkbWFpbGlzY3VycmVudCkgPSBGZXRjaFNRTERhdGEoKTsKICAgICAgICAgICAgUHVzaEdsb2JhbFNRTFN0YXRlKCk7CiAgICAgICAgICAgIFNlbmRTUUwoIkRFTEVURSBGUk9NIGJ1Z19ncm91cF9tYXAgV0hFUkUKICAgICAgICAgICAgICAgICAgICAgYnVnX2lkID0gJGJ1Z2lkIEFORCBncm91cF9pZCA9ICRncm91cGlkIik7CiAgICAgICAgICAgIFNlbmRTUUwoIlNFTEVDVCBuYW1lLCBOT1coKSBGUk9NIGdyb3VwcyBXSEVSRSBpZCA9ICRncm91cGlkIik7CiAgICAgICAgICAgIG15ICgkcmVtb3ZlZCwgJHRpbWVzdGFtcCkgPSBGZXRjaFNRTERhdGEoKTsKICAgICAgICAgICAgTG9nQWN0aXZpdHlFbnRyeSgkYnVnaWQsICJidWdfZ3JvdXAiLCAkcmVtb3ZlZCwgIiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJDo6dXNlcmlkLCAkdGltZXN0YW1wKTsKICAgICAgICAgICAgbXkgJGRpZmZlZCA9ICIiOwogICAgICAgICAgICBpZiAoJG1haWxpc2N1cnJlbnQpIHsKICAgICAgICAgICAgICAgICRkaWZmZWQgPSAiLCBsYXN0ZGlmZmVkID0gIiAuIFNxbFF1b3RlKCR0aW1lc3RhbXApOwogICAgICAgICAgICB9CiAgICAgICAgICAgIFNlbmRTUUwoIlVQREFURSBidWdzIFNFVCBkZWx0YV90cyA9ICIgLiBTcWxRdW90ZSgkdGltZXN0YW1wKSAuCiAgICAgICAgICAgICAgICAgICAgJGRpZmZlZCAuICIgV0hFUkUgYnVnX2lkID0gJGJ1Z2lkIik7CiAgICAgICAgICAgIFBvcEdsb2JhbFNRTFN0YXRlKCk7CiAgICAgICAgICAgICRjb3VudCsrOwogICAgICAgIH0KICAgICAgICBwcmludCAiZHJvcHBlZCAkY291bnQgYnVnczxwPlxuIjsKICAgIH0KCiAgICBmb3JlYWNoIG15ICRncm91cGlkIChAbm93X21hbmRhdG9yeSkgewogICAgICAgIHByaW50ICJBZGRpbmcgYnVncyB0byBNYW5kYXRvcnkgZ3JvdXAgIiAKICAgICAgICAgICAgIC4gaHRtbF9xdW90ZShHcm91cElkVG9OYW1lKCRncm91cGlkKSkgLiAiPFA+XG4iOwogICAgICAgIG15ICRjb3VudCA9IDA7CiAgICAgICAgU2VuZFNRTCgiU0VMRUNUIGJ1Z3MuYnVnX2lkLAogICAgICAgICAgICAgICAgIChsYXN0ZGlmZmVkID49IGRlbHRhX3RzKQogICAgICAgICAgICAgICAgIEZST00gYnVncwogICAgICAgICAgICAgICAgIExFRlQgSk9JTiBidWdfZ3JvdXBfbWFwCiAgICAgICAgICAgICAgICAgT04gYnVnX2dyb3VwX21hcC5idWdfaWQgPSBidWdzLmJ1Z19pZAogICAgICAgICAgICAgICAgIEFORCBncm91cF9pZCA9ICRncm91cGlkCiAgICAgICAgICAgICAgICAgV0hFUkUgYnVncy5wcm9kdWN0X2lkID0gJHByb2R1Y3RfaWQKICAgICAgICAgICAgICAgICBBTkQgYnVnX2dyb3VwX21hcC5idWdfaWQgSVMgTlVMTAogICAgICAgICAgICAgICAgIE9SREVSIEJZIGJ1Z3MuYnVnX2lkIik7CiAgICAgICAgd2hpbGUgKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICAgICAgbXkgKCRidWdpZCwgJG1haWxpc2N1cnJlbnQpID0gRmV0Y2hTUUxEYXRhKCk7CiAgICAgICAgICAgIFB1c2hHbG9iYWxTUUxTdGF0ZSgpOwogICAgICAgICAgICBTZW5kU1FMKCJJTlNFUlQgSU5UTyBidWdfZ3JvdXBfbWFwIChidWdfaWQsIGdyb3VwX2lkKQogICAgICAgICAgICAgICAgICAgICBWQUxVRVMgKCRidWdpZCwgJGdyb3VwaWQpIik7CiAgICAgICAgICAgIFNlbmRTUUwoIlNFTEVDVCBuYW1lLCBOT1coKSBGUk9NIGdyb3VwcyBXSEVSRSBpZCA9ICRncm91cGlkIik7CiAgICAgICAgICAgIG15ICgkYWRkZWQsICR0aW1lc3RhbXApID0gRmV0Y2hTUUxEYXRhKCk7CiAgICAgICAgICAgIExvZ0FjdGl2aXR5RW50cnkoJGJ1Z2lkLCAiYnVnX2dyb3VwIiwgIiIsICRhZGRlZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAkOjp1c2VyaWQsICR0aW1lc3RhbXApOwogICAgICAgICAgICBteSAkZGlmZmVkID0gIiI7CiAgICAgICAgICAgIGlmICgkbWFpbGlzY3VycmVudCkgewogICAgICAgICAgICAgICAgJGRpZmZlZCA9ICIsIGxhc3RkaWZmZWQgPSAiIC4gU3FsUXVvdGUoJHRpbWVzdGFtcCk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgU2VuZFNRTCgiVVBEQVRFIGJ1Z3MgU0VUIGRlbHRhX3RzID0gIiAuIFNxbFF1b3RlKCR0aW1lc3RhbXApIC4KICAgICAgICAgICAgICAgICAgICAkZGlmZmVkIC4gIiBXSEVSRSBidWdfaWQgPSAkYnVnaWQiKTsKICAgICAgICAgICAgUG9wR2xvYmFsU1FMU3RhdGUoKTsKICAgICAgICAgICAgJGNvdW50Kys7CiAgICAgICAgfQogICAgICAgIHByaW50ICJhZGRlZCAkY291bnQgYnVnczxwPlxuIjsKICAgIH0KICAgICRkYmgtPmJ6X3VubG9ja190YWJsZXMoKTsKCiAgICBwcmludCAiR3JvdXAgY29udHJvbCB1cGRhdGVzIGRvbmU8UD5cbiI7CgogICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgIGV4aXQ7Cn0KCiMKIyBhY3Rpb249J3VwZGF0ZScgLT4gdXBkYXRlIHRoZSBwcm9kdWN0CiMKCmlmICgkYWN0aW9uIGVxICd1cGRhdGUnKSB7CiAgICBQdXRIZWFkZXIoIlVwZGF0ZSBwcm9kdWN0Iik7CgogICAgbXkgJHByb2R1Y3RvbGQgICAgICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdwcm9kdWN0b2xkJykgICAgICAgICAgfHwgJycpOwogICAgbXkgJGRlc2NyaXB0aW9uICAgICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdkZXNjcmlwdGlvbicpICAgICAgICAgfHwgJycpOwogICAgbXkgJGRlc2NyaXB0aW9ub2xkICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdkZXNjcmlwdGlvbm9sZCcpICAgICAgfHwgJycpOwogICAgbXkgJGRpc2FsbG93bmV3ICAgICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdkaXNhbGxvd25ldycpICAgICAgICAgfHwgJycpOwogICAgbXkgJGRpc2FsbG93bmV3b2xkICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdkaXNhbGxvd25ld29sZCcpICAgICAgfHwgJycpOwogICAgbXkgJG1pbGVzdG9uZXVybCAgICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdtaWxlc3RvbmV1cmwnKSAgICAgICAgfHwgJycpOwogICAgbXkgJG1pbGVzdG9uZXVybG9sZCAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdtaWxlc3RvbmV1cmxvbGQnKSAgICAgfHwgJycpOwogICAgbXkgJHZvdGVzcGVydXNlciAgICAgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCd2b3Rlc3BlcnVzZXInKSAgICAgICAgfHwgMCk7CiAgICBteSAkdm90ZXNwZXJ1c2Vyb2xkICAgICA9IHRyaW0oJGNnaS0+cGFyYW0oJ3ZvdGVzcGVydXNlcm9sZCcpICAgICB8fCAwKTsKICAgIG15ICRtYXh2b3Rlc3BlcmJ1ZyAgICAgID0gdHJpbSgkY2dpLT5wYXJhbSgnbWF4dm90ZXNwZXJidWcnKSAgICAgIHx8IDApOwogICAgbXkgJG1heHZvdGVzcGVyYnVnb2xkICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdtYXh2b3Rlc3BlcmJ1Z29sZCcpICAgfHwgMCk7CiAgICBteSAkdm90ZXN0b2NvbmZpcm0gICAgICA9IHRyaW0oJGNnaS0+cGFyYW0oJ3ZvdGVzdG9jb25maXJtJykgICAgICB8fCAwKTsKICAgIG15ICR2b3Rlc3RvY29uZmlybW9sZCAgID0gdHJpbSgkY2dpLT5wYXJhbSgndm90ZXN0b2NvbmZpcm1vbGQnKSAgIHx8IDApOwogICAgbXkgJGRlZmF1bHRtaWxlc3RvbmUgICAgPSB0cmltKCRjZ2ktPnBhcmFtKCdkZWZhdWx0bWlsZXN0b25lJykgICAgfHwgJy0tLScpOwogICAgbXkgJGRlZmF1bHRtaWxlc3RvbmVvbGQgPSB0cmltKCRjZ2ktPnBhcmFtKCdkZWZhdWx0bWlsZXN0b25lb2xkJykgfHwgJy0tLScpOwoKICAgIG15ICRjaGVja3ZvdGVzID0gMDsKCiAgICBDaGVja1Byb2R1Y3QoJHByb2R1Y3RvbGQpOwogICAgbXkgJHByb2R1Y3RfaWQgPSBnZXRfcHJvZHVjdF9pZCgkcHJvZHVjdG9sZCk7CgogICAgaWYgKCFkZXRhaW50X25hdHVyYWwoJG1heHZvdGVzcGVyYnVnKSkgewogICAgICAgIHByaW50ICJTb3JyeSwgdGhlIG1heCB2b3RlcyBwZXIgYnVnIG11c3QgYmUgYW4gaW50ZWdlciA+PSAwLiI7CiAgICAgICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgICAgICBleGl0OwogICAgfQoKICAgIGlmICghZGV0YWludF9uYXR1cmFsKCR2b3Rlc3BlcnVzZXIpKSB7CiAgICAgICAgcHJpbnQgIlNvcnJ5LCB0aGUgdm90ZXMgcGVyIHVzZXIgbXVzdCBiZSBhbiBpbnRlZ2VyID49IDAuIjsKICAgICAgICBQdXRUcmFpbGVyKCRsb2NhbHRyYWlsZXIpOwogICAgICAgIGV4aXQ7CiAgICB9CgogICAgaWYgKCFkZXRhaW50X25hdHVyYWwoJHZvdGVzdG9jb25maXJtKSkgewogICAgICAgIHByaW50ICJTb3JyeSwgdGhlIHZvdGVzIHRvIGNvbmZpcm0gbXVzdCBiZSBhbiBpbnRlZ2VyID49IDAuIjsKICAgICAgICBQdXRUcmFpbGVyKCRsb2NhbHRyYWlsZXIpOwogICAgICAgIGV4aXQ7CiAgICB9CgogICAgIyBOb3RlIHRoYXQgd2UgZ290IHRoZSAkcHJvZHVjdF9pZCB1c2luZyAkcHJvZHVjdG9sZCBhYm92ZSBzbyBpdCB3aWxsCiAgICAjIHJlbWFpbiBzdGF0aWMgZXZlbiBhZnRlciB3ZSByZW5hbWUgdGhlIHByb2R1Y3QgaW4gdGhlIGRhdGFiYXNlLgoKICAgICRkYmgtPmJ6X2xvY2tfdGFibGVzKCdwcm9kdWN0cyBXUklURScsCiAgICAgICAgICAgICAgICAgICAgICAgICAndmVyc2lvbnMgUkVBRCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAnZ3JvdXBzIFdSSVRFJywKICAgICAgICAgICAgICAgICAgICAgICAgICdncm91cF9jb250cm9sX21hcCBXUklURScsCiAgICAgICAgICAgICAgICAgICAgICAgICAncHJvZmlsZXMgV1JJVEUnLAogICAgICAgICAgICAgICAgICAgICAgICAgJ21pbGVzdG9uZXMgUkVBRCcpOwoKICAgIGlmICgkZGlzYWxsb3duZXcgbmUgJGRpc2FsbG93bmV3b2xkKSB7CiAgICAgICAgJGRpc2FsbG93bmV3ID0gJGRpc2FsbG93bmV3ID8gMSA6IDA7CiAgICAgICAgU2VuZFNRTCgiVVBEQVRFIHByb2R1Y3RzCiAgICAgICAgICAgICAgICAgU0VUIGRpc2FsbG93bmV3PSRkaXNhbGxvd25ldwogICAgICAgICAgICAgICAgIFdIRVJFIGlkPSRwcm9kdWN0X2lkIik7CiAgICAgICAgcHJpbnQgIlVwZGF0ZWQgYnVnIHN1Ym1pdCBzdGF0dXMuPEJSPlxuIjsKICAgIH0KCiAgICBpZiAoJGRlc2NyaXB0aW9uIG5lICRkZXNjcmlwdGlvbm9sZCkgewogICAgICAgIHVubGVzcyAoJGRlc2NyaXB0aW9uKSB7CiAgICAgICAgICAgIHByaW50ICJTb3JyeSwgSSBjYW4ndCBkZWxldGUgdGhlIGRlc2NyaXB0aW9uLiI7CiAgICAgICAgICAgICRkYmgtPmJ6X3VubG9ja190YWJsZXMoVU5MT0NLX0FCT1JUKTsKICAgICAgICAgICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgICAgICAgICAgZXhpdDsKICAgICAgICB9CiAgICAgICAgU2VuZFNRTCgiVVBEQVRFIHByb2R1Y3RzCiAgICAgICAgICAgICAgICAgU0VUIGRlc2NyaXB0aW9uPSIgLiBTcWxRdW90ZSgkZGVzY3JpcHRpb24pIC4gIgogICAgICAgICAgICAgICAgIFdIRVJFIGlkPSRwcm9kdWN0X2lkIik7CiAgICAgICAgcHJpbnQgIlVwZGF0ZWQgZGVzY3JpcHRpb24uPEJSPlxuIjsKICAgIH0KCiAgICBpZiAoUGFyYW0oJ3VzZXRhcmdldG1pbGVzdG9uZScpICYmICRtaWxlc3RvbmV1cmwgbmUgJG1pbGVzdG9uZXVybG9sZCkgewogICAgICAgIFNlbmRTUUwoIlVQREFURSBwcm9kdWN0cwogICAgICAgICAgICAgICAgIFNFVCBtaWxlc3RvbmV1cmw9IiAuIFNxbFF1b3RlKCRtaWxlc3RvbmV1cmwpIC4gIgogICAgICAgICAgICAgICAgIFdIRVJFIGlkPSRwcm9kdWN0X2lkIik7CiAgICAgICAgcHJpbnQgIlVwZGF0ZWQgbWlsZXN0b25lIFVSTC48QlI+XG4iOwogICAgfQoKCiAgICBpZiAoJHZvdGVzcGVydXNlciBuZSAkdm90ZXNwZXJ1c2Vyb2xkKSB7CiAgICAgICAgU2VuZFNRTCgiVVBEQVRFIHByb2R1Y3RzCiAgICAgICAgICAgICAgICAgU0VUIHZvdGVzcGVydXNlcj0kdm90ZXNwZXJ1c2VyCiAgICAgICAgICAgICAgICAgV0hFUkUgaWQ9JHByb2R1Y3RfaWQiKTsKICAgICAgICBwcmludCAiVXBkYXRlZCB2b3RlcyBwZXIgdXNlci48QlI+XG4iOwogICAgICAgICRjaGVja3ZvdGVzID0gMTsKICAgIH0KCgogICAgaWYgKCRtYXh2b3Rlc3BlcmJ1ZyBuZSAkbWF4dm90ZXNwZXJidWdvbGQpIHsKICAgICAgICBTZW5kU1FMKCJVUERBVEUgcHJvZHVjdHMKICAgICAgICAgICAgICAgICBTRVQgbWF4dm90ZXNwZXJidWc9JG1heHZvdGVzcGVyYnVnCiAgICAgICAgICAgICAgICAgV0hFUkUgaWQ9JHByb2R1Y3RfaWQiKTsKICAgICAgICBwcmludCAiVXBkYXRlZCBtYXggdm90ZXMgcGVyIGJ1Zy48QlI+XG4iOwogICAgICAgICRjaGVja3ZvdGVzID0gMTsKICAgIH0KCgogICAgaWYgKCR2b3Rlc3RvY29uZmlybSBuZSAkdm90ZXN0b2NvbmZpcm1vbGQpIHsKICAgICAgICBTZW5kU1FMKCJVUERBVEUgcHJvZHVjdHMKICAgICAgICAgICAgICAgICBTRVQgdm90ZXN0b2NvbmZpcm09JHZvdGVzdG9jb25maXJtCiAgICAgICAgICAgICAgICAgV0hFUkUgaWQ9JHByb2R1Y3RfaWQiKTsKICAgICAgICBwcmludCAiVXBkYXRlZCB2b3RlcyB0byBjb25maXJtLjxCUj5cbiI7CiAgICAgICAgJGNoZWNrdm90ZXMgPSAxOwogICAgfQoKCiAgICBpZiAoJGRlZmF1bHRtaWxlc3RvbmUgbmUgJGRlZmF1bHRtaWxlc3RvbmVvbGQpIHsKICAgICAgICBTZW5kU1FMKCJTRUxFQ1QgdmFsdWUgRlJPTSBtaWxlc3RvbmVzICIgLgogICAgICAgICAgICAgICAgIldIRVJFIHZhbHVlID0gIiAuIFNxbFF1b3RlKCRkZWZhdWx0bWlsZXN0b25lKSAuCiAgICAgICAgICAgICAgICAiICBBTkQgcHJvZHVjdF9pZCA9ICRwcm9kdWN0X2lkIik7CiAgICAgICAgaWYgKCFGZXRjaE9uZUNvbHVtbigpKSB7CiAgICAgICAgICAgIHByaW50ICJTb3JyeSwgdGhlIG1pbGVzdG9uZSAkZGVmYXVsdG1pbGVzdG9uZSBtdXN0IGJlIGRlZmluZWQgZmlyc3QuIjsKICAgICAgICAgICAgJGRiaC0+YnpfdW5sb2NrX3RhYmxlcyhVTkxPQ0tfQUJPUlQpOwogICAgICAgICAgICBQdXRUcmFpbGVyKCRsb2NhbHRyYWlsZXIpOwogICAgICAgICAgICBleGl0OwogICAgICAgIH0KICAgICAgICBTZW5kU1FMKCJVUERBVEUgcHJvZHVjdHMgIiAuCiAgICAgICAgICAgICAgICAiU0VUIGRlZmF1bHRtaWxlc3RvbmUgPSAiIC4gU3FsUXVvdGUoJGRlZmF1bHRtaWxlc3RvbmUpIC4KICAgICAgICAgICAgICAgICJXSEVSRSBpZD0kcHJvZHVjdF9pZCIpOwogICAgICAgIHByaW50ICJVcGRhdGVkIGRlZmF1bHQgbWlsZXN0b25lLjxCUj5cbiI7CiAgICB9CgogICAgbXkgJHFwID0gU3FsUXVvdGUoJHByb2R1Y3QpOwogICAgbXkgJHFwb2xkID0gU3FsUXVvdGUoJHByb2R1Y3RvbGQpOwoKICAgIGlmICgkcHJvZHVjdCBuZSAkcHJvZHVjdG9sZCkgewogICAgICAgIHVubGVzcyAoJHByb2R1Y3QpIHsKICAgICAgICAgICAgcHJpbnQgIlNvcnJ5LCBJIGNhbid0IGRlbGV0ZSB0aGUgcHJvZHVjdCBuYW1lLiI7CiAgICAgICAgICAgICRkYmgtPmJ6X3VubG9ja190YWJsZXMoVU5MT0NLX0FCT1JUKTsKICAgICAgICAgICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgICAgICAgICAgZXhpdDsKICAgICAgICB9CgogICAgICAgIGlmIChsYygkcHJvZHVjdCkgbmUgbGMoJHByb2R1Y3RvbGQpICYmCiAgICAgICAgICAgIFRlc3RQcm9kdWN0KCRwcm9kdWN0KSkgewogICAgICAgICAgICBwcmludCAiU29ycnksIHByb2R1Y3QgbmFtZSAnJHByb2R1Y3QnIGlzIGFscmVhZHkgaW4gdXNlLiI7CiAgICAgICAgICAgICRkYmgtPmJ6X3VubG9ja190YWJsZXMoVU5MT0NLX0FCT1JUKTsKICAgICAgICAgICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgICAgICAgICAgZXhpdDsKICAgICAgICB9CgogICAgICAgIFNlbmRTUUwoIlVQREFURSBwcm9kdWN0cyBTRVQgbmFtZT0kcXAgV0hFUkUgaWQ9JHByb2R1Y3RfaWQiKTsKICAgICAgICBwcmludCAiVXBkYXRlZCBwcm9kdWN0IG5hbWUuPEJSPlxuIjsKICAgIH0KICAgICRkYmgtPmJ6X3VubG9ja190YWJsZXMoKTsKICAgIHVubGluayAiJGRhdGFkaXIvdmVyc2lvbmNhY2hlIjsKCiAgICBpZiAoJGNoZWNrdm90ZXMpIHsKICAgICAgICAjIDEuIHRvbyBtYW55IHZvdGVzIGZvciBhIHNpbmdsZSB1c2VyIG9uIGEgc2luZ2xlIGJ1Zy4KICAgICAgICBpZiAoJG1heHZvdGVzcGVyYnVnIDwgJHZvdGVzcGVydXNlcikgewogICAgICAgICAgICBwcmludCAiPGJyPkNoZWNraW5nIGV4aXN0aW5nIHZvdGVzIGluIHRoaXMgcHJvZHVjdCBmb3IgYW55Ym9keSB3aG8gbm93IGhhcyB0b28gbWFueSB2b3RlcyBmb3IgYSBzaW5nbGUgYnVnLiI7CiAgICAgICAgICAgIFNlbmRTUUwoIlNFTEVDVCB2b3Rlcy53aG8sIHZvdGVzLmJ1Z19pZCAiIC4KICAgICAgICAgICAgICAgICAgICAiRlJPTSB2b3RlcywgYnVncyAiIC4KICAgICAgICAgICAgICAgICAgICAiV0hFUkUgYnVncy5idWdfaWQgPSB2b3Rlcy5idWdfaWQgIiAuCiAgICAgICAgICAgICAgICAgICAgIiBBTkQgYnVncy5wcm9kdWN0X2lkID0gJHByb2R1Y3RfaWQgIiAuCiAgICAgICAgICAgICAgICAgICAgIiBBTkQgdm90ZXMudm90ZV9jb3VudCA+ICRtYXh2b3Rlc3BlcmJ1ZyIpOwogICAgICAgICAgICBteSBAbGlzdDsKICAgICAgICAgICAgd2hpbGUgKE1vcmVTUUxEYXRhKCkpIHsKICAgICAgICAgICAgICAgIG15ICgkd2hvLCAkaWQpID0gKEZldGNoU1FMRGF0YSgpKTsKICAgICAgICAgICAgICAgIHB1c2goQGxpc3QsIFskd2hvLCAkaWRdKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBmb3JlYWNoIG15ICRyZWYgKEBsaXN0KSB7CiAgICAgICAgICAgICAgICBteSAoJHdobywgJGlkKSA9IChAJHJlZik7CiAgICAgICAgICAgICAgICBSZW1vdmVWb3RlcygkaWQsICR3aG8sICJUaGUgcnVsZXMgZm9yIHZvdGluZyBvbiB0aGlzIHByb2R1Y3QgaGFzIGNoYW5nZWQ7XG55b3UgaGFkIHRvbyBtYW55IHZvdGVzIGZvciBhIHNpbmdsZSBidWcuIik7CiAgICAgICAgICAgICAgICBteSAkbmFtZSA9IERCSURfdG9fbmFtZSgkd2hvKTsKICAgICAgICAgICAgICAgIHByaW50IHFxezxicj5SZW1vdmVkIHZvdGVzIGZvciBidWcgPEEgSFJFRj0ic2hvd19idWcuY2dpP2lkPSRpZCI+JGlkPC9BPiBmcm9tICRuYW1lXG59OwogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICAjIDIuIHRvbyBtYW55IHRvdGFsIHZvdGVzIGZvciBhIHNpbmdsZSB1c2VyLgogICAgICAgICMgVGhpcyBwYXJ0IGRvZXNuJ3Qgd29yayBpbiB0aGUgZ2VuZXJhbCBjYXNlIGJlY2F1c2UgUmVtb3ZlVm90ZXMKICAgICAgICAjIGRvZXNuJ3QgZW5mb3JjZSB2b3Rlc3BlcnVzZXIgKGV4Y2VwdCBwZXItYnVnIHdoZW4gaXQncyBsZXNzCiAgICAgICAgIyB0aGFuIG1heHZvdGVzcGVyYnVnKS4gIFNlZSBSZW1vdmVWb3RlcyBpbiBnbG9iYWxzLnBsLgogICAgICAgIHByaW50ICI8YnI+Q2hlY2tpbmcgZXhpc3Rpbmcgdm90ZXMgaW4gdGhpcyBwcm9kdWN0IGZvciBhbnlib2R5IHdobyBub3cgaGFzIHRvbyBtYW55IHRvdGFsIHZvdGVzLiI7CiAgICAgICAgU2VuZFNRTCgiU0VMRUNUIHZvdGVzLndobywgdm90ZXMudm90ZV9jb3VudCBGUk9NIHZvdGVzLCBidWdzICIgLgogICAgICAgICAgICAgICAgIldIRVJFIGJ1Z3MuYnVnX2lkID0gdm90ZXMuYnVnX2lkICIgLgogICAgICAgICAgICAgICAgIiBBTkQgYnVncy5wcm9kdWN0X2lkID0gJHByb2R1Y3RfaWQiKTsKICAgICAgICBteSAlY291bnRzOwogICAgICAgIHdoaWxlIChNb3JlU1FMRGF0YSgpKSB7CiAgICAgICAgICAgIG15ICgkd2hvLCAkY291bnQpID0gKEZldGNoU1FMRGF0YSgpKTsKICAgICAgICAgICAgaWYgKCFkZWZpbmVkICRjb3VudHN7JHdob30pIHsKICAgICAgICAgICAgICAgICRjb3VudHN7JHdob30gPSAkY291bnQ7CiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAkY291bnRzeyR3aG99ICs9ICRjb3VudDsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICBmb3JlYWNoIG15ICR3aG8gKGtleXMoJWNvdW50cykpIHsKICAgICAgICAgICAgaWYgKCRjb3VudHN7JHdob30gPiAkdm90ZXNwZXJ1c2VyKSB7CiAgICAgICAgICAgICAgICBTZW5kU1FMKCJTRUxFQ1Qgdm90ZXMuYnVnX2lkIEZST00gdm90ZXMsIGJ1Z3MgIiAuCiAgICAgICAgICAgICAgICAgICAgICAgICJXSEVSRSBidWdzLmJ1Z19pZCA9IHZvdGVzLmJ1Z19pZCAiIC4KICAgICAgICAgICAgICAgICAgICAgICAgIiBBTkQgYnVncy5wcm9kdWN0X2lkID0gJHByb2R1Y3RfaWQgIiAuCiAgICAgICAgICAgICAgICAgICAgICAgICIgQU5EIHZvdGVzLndobyA9ICR3aG8iKTsKICAgICAgICAgICAgICAgIHdoaWxlIChNb3JlU1FMRGF0YSgpKSB7CiAgICAgICAgICAgICAgICAgICAgbXkgKCRpZCkgPSBGZXRjaFNRTERhdGEoKTsKICAgICAgICAgICAgICAgICAgICBSZW1vdmVWb3RlcygkaWQsICR3aG8sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlRoZSBydWxlcyBmb3Igdm90aW5nIG9uIHRoaXMgcHJvZHVjdCBoYXMgY2hhbmdlZDsgeW91IGhhZCB0b28gbWFueVxudG90YWwgdm90ZXMsIHNvIGFsbCB2b3RlcyBoYXZlIGJlZW4gcmVtb3ZlZC4iKTsKICAgICAgICAgICAgICAgICAgICBteSAkbmFtZSA9IERCSURfdG9fbmFtZSgkd2hvKTsKICAgICAgICAgICAgICAgICAgICBwcmludCBxcXs8YnI+UmVtb3ZlZCB2b3RlcyBmb3IgYnVnIDxBIEhSRUY9InNob3dfYnVnLmNnaT9pZD0kaWQiPiRpZDwvQT4gZnJvbSAkbmFtZVxufTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICAjIDMuIGVub3VnaCB2b3RlcyB0byBjb25maXJtCiAgICAgICAgbXkgJGJ1Z19saXN0ID0gJGRiaC0+c2VsZWN0Y29sX2FycmF5cmVmKCJTRUxFQ1QgYnVnX2lkIEZST00gYnVncwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0hFUkUgcHJvZHVjdF9pZCA9ID8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFORCBidWdfc3RhdHVzID0gJ1VOQ09ORklSTUVEJwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQU5EIHZvdGVzID49ID8iLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5kZWYsICgkcHJvZHVjdF9pZCwgJHZvdGVzdG9jb25maXJtKSk7CiAgICAgICAgaWYgKHNjYWxhcihAJGJ1Z19saXN0KSkgewogICAgICAgICAgICBwcmludCAiPGJyPkNoZWNraW5nIHVuY29uZmlybWVkIGJ1Z3MgaW4gdGhpcyBwcm9kdWN0IGZvciBhbnkgd2hpY2ggbm93IGhhdmUgc3VmZmljaWVudCB2b3Rlcy4iOwogICAgICAgIH0KICAgICAgICBteSBAdXBkYXRlZF9idWdzID0gKCk7CiAgICAgICAgZm9yZWFjaCBteSAkYnVnX2lkIChAJGJ1Z19saXN0KSB7CiAgICAgICAgICAgIG15ICRjb25maXJtZWQgPSBDaGVja0lmVm90ZWRDb25maXJtZWQoJGJ1Z19pZCwgJHdob2lkKTsKICAgICAgICAgICAgcHVzaCAoQHVwZGF0ZWRfYnVncywgJGJ1Z19pZCkgaWYgJGNvbmZpcm1lZDsKICAgICAgICB9CgogICAgICAgICR2YXJzLT57J3R5cGUnfSA9ICJ2b3RlcyI7CiAgICAgICAgJHZhcnMtPnsnbWFpbHJlY2lwaWVudHMnfSA9IHsgJ2NoYW5nZXInID0+ICR3aG9pZCB9OwogICAgICAgICR2YXJzLT57J2hlYWRlcl9kb25lJ30gPSAxOwoKICAgICAgICBmb3JlYWNoIG15ICRidWdfaWQgKEB1cGRhdGVkX2J1Z3MpIHsKICAgICAgICAgICAgJHZhcnMtPnsnaWQnfSA9ICRidWdfaWQ7CiAgICAgICAgICAgICR0ZW1wbGF0ZS0+cHJvY2VzcygiYnVnL3Byb2Nlc3MvcmVzdWx0cy5odG1sLnRtcGwiLCAkdmFycykKICAgICAgICAgICAgICB8fCBUaHJvd1RlbXBsYXRlRXJyb3IoJHRlbXBsYXRlLT5lcnJvcigpKTsKICAgICAgICB9CiAgICB9CgogICAgUHV0VHJhaWxlcigkbG9jYWx0cmFpbGVyKTsKICAgIGV4aXQ7Cn0KCiMKIyBhY3Rpb249J2VkaXRncm91cGNvbnRyb2xzJyAtPiB1cGRhdGUgcHJvZHVjdCBncm91cCBjb250cm9scwojCgppZiAoJGFjdGlvbiBlcSAnZWRpdGdyb3VwY29udHJvbHMnKSB7CiAgICBteSAkcHJvZHVjdF9pZCA9IGdldF9wcm9kdWN0X2lkKCRwcm9kdWN0KTsKICAgICRwcm9kdWN0X2lkCiAgICAgIHx8IFRocm93VXNlckVycm9yKCJpbnZhbGlkX3Byb2R1Y3RfbmFtZSIsIHsgcHJvZHVjdCA9PiAkcHJvZHVjdCB9KTsKICAgICMgRGlzcGxheSBhIGdyb3VwIGlmIGl0IGlzIGVpdGhlciBlbmFibGVkIG9yIGhhcyBidWdzIGZvciB0aGlzIHByb2R1Y3QuCiAgICBTZW5kU1FMKCJTRUxFQ1QgaWQsIG5hbWUsIGVudHJ5LCBtZW1iZXJjb250cm9sLCBvdGhlcmNvbnRyb2wsIGNhbmVkaXQsICIgLgogICAgICAgICAgICAiaXNhY3RpdmUsIENPVU5UKGJ1Z3MuYnVnX2lkKSAiIC4KICAgICAgICAgICAgIkZST00gZ3JvdXBzICIgLgogICAgICAgICAgICAiTEVGVCBKT0lOIGdyb3VwX2NvbnRyb2xfbWFwICIgLgogICAgICAgICAgICAiT04gZ3JvdXBfY29udHJvbF9tYXAuZ3JvdXBfaWQgPSBpZCAiIC4KICAgICAgICAgICAgIkFORCBncm91cF9jb250cm9sX21hcC5wcm9kdWN0X2lkID0gJHByb2R1Y3RfaWQgIiAuCiAgICAgICAgICAgICJMRUZUIEpPSU4gYnVnX2dyb3VwX21hcCAiIC4KICAgICAgICAgICAgIk9OIGJ1Z19ncm91cF9tYXAuZ3JvdXBfaWQgPSBncm91cHMuaWQgIiAuCiAgICAgICAgICAgICJMRUZUIEpPSU4gYnVncyAiIC4KICAgICAgICAgICAgIk9OIGJ1Z3MuYnVnX2lkID0gYnVnX2dyb3VwX21hcC5idWdfaWQgIiAuCiAgICAgICAgICAgICJBTkQgYnVncy5wcm9kdWN0X2lkID0gJHByb2R1Y3RfaWQgIiAuCiAgICAgICAgICAgICJXSEVSRSBpc2J1Z2dyb3VwICE9IDAgIiAuCiAgICAgICAgICAgICJBTkQgKGlzYWN0aXZlICE9IDAgT1IgZW50cnkgSVMgTk9UIE5VTEwgIiAuCiAgICAgICAgICAgICJPUiBidWdzLmJ1Z19pZCBJUyBOT1QgTlVMTCkgIiAuCiAgICAgICAgICAgICRkYmgtPnNxbF9ncm91cF9ieSgnbmFtZScsICdpZCwgZW50cnksIG1lbWJlcmNvbnRyb2wsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb3RoZXJjb250cm9sLCBjYW5lZGl0LCBpc2FjdGl2ZScpKTsKICAgIG15IEBncm91cHMgPSAoKTsKICAgIHdoaWxlIChNb3JlU1FMRGF0YSgpKSB7CiAgICAgICAgbXkgJWdyb3VwID0gKCk7CiAgICAgICAgbXkgKCRncm91cGlkLCAkZ3JvdXBuYW1lLCAkZW50cnksICRtZW1iZXJjb250cm9sLCAkb3RoZXJjb250cm9sLCAKICAgICAgICAgICAgJGNhbmVkaXQsICRpc2FjdGl2ZSwgJGJ1Z2NvdW50KSA9IEZldGNoU1FMRGF0YSgpOwogICAgICAgICRncm91cHsnaWQnfSA9ICRncm91cGlkOwogICAgICAgICRncm91cHsnbmFtZSd9ID0gJGdyb3VwbmFtZTsKICAgICAgICAkZ3JvdXB7J2VudHJ5J30gPSAkZW50cnk7CiAgICAgICAgJGdyb3VweydtZW1iZXJjb250cm9sJ30gPSAkbWVtYmVyY29udHJvbDsKICAgICAgICAkZ3JvdXB7J290aGVyY29udHJvbCd9ID0gJG90aGVyY29udHJvbDsKICAgICAgICAkZ3JvdXB7J2NhbmVkaXQnfSA9ICRjYW5lZGl0OwogICAgICAgICRncm91cHsnaXNhY3RpdmUnfSA9ICRpc2FjdGl2ZTsKICAgICAgICAkZ3JvdXB7J2J1Z2NvdW50J30gPSAkYnVnY291bnQ7CiAgICAgICAgcHVzaCBAZ3JvdXBzLFwlZ3JvdXA7CiAgICB9CiAgICAkdmFycy0+eydoZWFkZXJfZG9uZSd9ID0gJGhlYWRlcmRvbmU7CiAgICAkdmFycy0+eydwcm9kdWN0J30gPSAkcHJvZHVjdDsKICAgICR2YXJzLT57J2NsYXNzaWZpY2F0aW9uJ30gPSAkY2xhc3NpZmljYXRpb247CiAgICAkdmFycy0+eydncm91cHMnfSA9IFxAZ3JvdXBzOwogICAgJHZhcnMtPnsnY29uc3QnfSA9IHsKICAgICAgICAnQ09OVFJPTE1BUE5BJyA9PiBDT05UUk9MTUFQTkEsCiAgICAgICAgJ0NPTlRST0xNQVBTSE9XTicgPT4gQ09OVFJPTE1BUFNIT1dOLAogICAgICAgICdDT05UUk9MTUFQREVGQVVMVCcgPT4gQ09OVFJPTE1BUERFRkFVTFQsCiAgICAgICAgJ0NPTlRST0xNQVBNQU5EQVRPUlknID0+IENPTlRST0xNQVBNQU5EQVRPUlksCiAgICB9OwoKICAgICR0ZW1wbGF0ZS0+cHJvY2VzcygiYWRtaW4vcHJvZHVjdHMvZ3JvdXBjb250cm9sL2VkaXQuaHRtbC50bXBsIiwgJHZhcnMpCiAgICAgICAgfHwgVGhyb3dUZW1wbGF0ZUVycm9yKCR0ZW1wbGF0ZS0+ZXJyb3IoKSk7CiAgICBleGl0OyAgICAgICAgICAgICAgICAKfQoKCiMKIyBObyB2YWxpZCBhY3Rpb24gZm91bmQKIwoKUHV0SGVhZGVyKCJFcnJvciIpOwpwcmludCAiSSBkb24ndCBoYXZlIGEgY2x1ZSB3aGF0IHlvdSB3YW50LjxCUj5cbiI7Cg==