LyoKICogbXNpZXhlYy5leGUgaW1wbGVtZW50YXRpb24KICoKICogQ29weXJpZ2h0IDIwMDQgVmluY2VudCBC6XJvbgogKiBDb3B5cmlnaHQgMjAwNSBNaWtlIE1jQ29ybWFjawogKgogKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCiAqIHZlcnNpb24gMi4xIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EKICovCgojZGVmaW5lIFdJTjMyX0xFQU5fQU5EX01FQU4KCiNpbmNsdWRlIDx3aW5kb3dzLmg+CiNpbmNsdWRlIDxtc2kuaD4KI2luY2x1ZGUgPG9iamJhc2UuaD4KI2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzaGVsbGFwaS5oPgoKI2luY2x1ZGUgIndpbmUvZGVidWcuaCIKI2luY2x1ZGUgIndpbmUvdW5pY29kZS5oIgoKV0lORV9ERUZBVUxUX0RFQlVHX0NIQU5ORUwobXNpZXhlYyk7Cgp0eXBlZGVmIEhSRVNVTFQgKFdJTkFQSSAqRExMUkVHSVNURVJTRVJWRVIpKHZvaWQpOwp0eXBlZGVmIEhSRVNVTFQgKFdJTkFQSSAqRExMVU5SRUdJU1RFUlNFUlZFUikodm9pZCk7CgpzdHJ1Y3Qgc3RyaW5nX2xpc3QKewoJc3RydWN0IHN0cmluZ19saXN0ICpuZXh0OwoJV0NIQVIgc3RyWzFdOwp9OwoKc3RhdGljIGNvbnN0IGNoYXIgVXNhZ2VTdHJbXSA9CiJVc2FnZTpcbiIKIiAgSW5zdGFsbCBhIHByb2R1Y3Q6XG4iCiIgICAgbXNpZXhlYyB7cGFja2FnZXxwcm9kdWN0Y29kZX0gW3Byb3BlcnR5XVxuIgoiICAgIG1zaWV4ZWMgL2kge3BhY2thZ2V8cHJvZHVjdGNvZGV9IFtwcm9wZXJ0eV1cbiIKIiAgICBtc2lleGVjIC9hIHBhY2thZ2UgW3Byb3BlcnR5XVxuIgoiICBSZXBhaXIgYW4gaW5zdGFsbGF0aW9uOlxuIgoiICAgIG1zaWV4ZWMgL2ZbcHxvfGV8ZHxjfGF8dXxtfHN8dl0ge3BhY2thZ2V8cHJvZHVjdGNvZGV9XG4iCiIgIFVuaW5zdGFsbCBhIHByb2R1Y3Q6XG4iCiIgICAgbXNpZXhlYyAveCB7cGFja2FnZXxwcm9kdWN0Y29kZX0gW3Byb3BlcnR5XVxuIgoiICBBZHZlcnRpc2UgYSBwcm9kdWN0OlxuIgoiICAgIG1zaWV4ZWMgL2pbdXxtXSBwYWNrYWdlIFsvdCB0cmFuc2Zvcm1dIFsvZyBsYW5ndWFnZWlkXVxuIgoiICAgIG1zaWV4ZWMge3V8bX0gcGFja2FnZSBbL3QgdHJhbnNmb3JtXSBbL2cgbGFuZ3VhZ2VpZF1cbiIKIiAgQXBwbHkgYSBwYXRjaDpcbiIKIiAgICBtc2lleGVjIC9wIHBhdGNocGFja2FnZSBbcHJvcGVydHldXG4iCiIgICAgbXNpZXhlYyAvcCBwYXRjaHBhY2thZ2UgL2EgcGFja2FnZSBbcHJvcGVydHldXG4iCiIgIE1vZGlmaWVycyBmb3IgYWJvdmUgb3BlcmF0aW9uczpcbiIKIiAgICBtc2lleGVjIC9sWypdW2l8d3xlfGF8cnx1fGN8bXxvfHB8dnxdWyt8IV0gbG9nZmlsZVxuIgoiICAgIG1zaWV4ZWMgL3F7fG58YnxyfGZ8bit8Yit8Yi19XG4iCiIgIFJlZ2lzdGVyIGEgbW9kdWxlOlxuIgoiICAgIG1zaWV4ZWMgL3kgbW9kdWxlXG4iCiIgIFVucmVnaXN0ZXIgYSBtb2R1bGU6XG4iCiIgICAgbXNpZXhlYyAveiBtb2R1bGVcbiIKIiAgRGlzcGxheSB1c2FnZSBhbmQgY29weXJpZ2h0OlxuIgoiICAgIG1zaWV4ZWMgey9ofC8/fVxuIgoiTk9URTogUHJvZHVjdCBjb2RlIG9uIGNvbW1hbmRsaW5lIHVuaW1wbGVtZW50ZWQgYXMgb2YgeWV0XG4iCiJcbiIKIkNvcHlyaWdodCAyMDA0IFZpbmNlbnQgQulyb25cbiI7CgpzdGF0aWMgY29uc3QgV0NIQVIgQWN0aW9uQWRtaW5bXSA9IHsKICAgJ0EnLCdDJywnVCcsJ0knLCdPJywnTicsJz0nLCdBJywnRCcsJ00nLCdJJywnTicsMCB9OwpzdGF0aWMgY29uc3QgV0NIQVIgUmVtb3ZlQWxsW10gPSB7CiAgICdSJywnRScsJ00nLCdPJywnVicsJ0UnLCc9JywnQScsJ0wnLCdMJywwIH07CgpzdGF0aWMgY29uc3QgV0NIQVIgSW5zdGFsbFJ1bk9uY2VbXSA9IHsKICAgJ1MnLCdvJywnZicsJ3QnLCd3JywnYScsJ3InLCdlJywnXFwnLAogICAnTScsJ2knLCdjJywncicsJ28nLCdzJywnbycsJ2YnLCd0JywnXFwnLAogICAnVycsJ2knLCduJywnZCcsJ28nLCd3JywncycsJ1xcJywKICAgJ0MnLCd1JywncicsJ3InLCdlJywnbicsJ3QnLCdWJywnZScsJ3InLCdzJywnaScsJ28nLCduJywnXFwnLAogICAnSScsJ24nLCdzJywndCcsJ2EnLCdsJywnbCcsJ2UnLCdyJywnXFwnLAogICAnUicsJ3UnLCduJywnTycsJ24nLCdjJywnZScsJ0UnLCduJywndCcsJ3InLCdpJywnZScsJ3MnLDB9OwoKc3RhdGljIHZvaWQgU2hvd1VzYWdlKGludCBFeGl0Q29kZSkKewoJcHJpbnRmKFVzYWdlU3RyKTsKCUV4aXRQcm9jZXNzKEV4aXRDb2RlKTsKfQoKc3RhdGljIEJPT0wgSXNQcm9kdWN0Q29kZShMUFdTVFIgc3RyKQp7CglHVUlEIFByb2R1Y3RDb2RlOwoKCWlmKGxzdHJsZW5XKHN0cikgIT0gMzgpCgkJcmV0dXJuIEZBTFNFOwoJcmV0dXJuICggKENMU0lERnJvbVN0cmluZyhzdHIsICZQcm9kdWN0Q29kZSkgPT0gTk9FUlJPUikgKTsKCn0KCnN0YXRpYyBWT0lEIFN0cmluZ0xpc3RBcHBlbmQoc3RydWN0IHN0cmluZ19saXN0ICoqbGlzdCwgTFBDV1NUUiBzdHIpCnsKCXN0cnVjdCBzdHJpbmdfbGlzdCAqZW50cnk7CglEV09SRCBzaXplOwoKCXNpemUgPSBzaXplb2YgKmVudHJ5ICsgbHN0cmxlblcoc3RyKSAqIHNpemVvZiAoV0NIQVIpOwoJZW50cnkgPSBIZWFwQWxsb2MoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgc2l6ZSk7CglpZighZW50cnkpCgl7CgkJV0lORV9FUlIoIk91dCBvZiBtZW1vcnkhXG4iKTsKCQlFeGl0UHJvY2VzcygxKTsKCX0KCWxzdHJjcHlXKGVudHJ5LT5zdHIsIHN0cik7CgllbnRyeS0+bmV4dCA9IE5VTEw7CgoJLyoKCSAqIElnbm9yaW5nIG8obl4yKSB0aW1lIGNvbXBsZXhpdHkgdG8gYWRkIG4gc3RyaW5ncyBmb3Igc2ltcGxpY2l0eSwKCSAqICBhZGQgdGhlIHN0cmluZyB0byB0aGUgZW5kIG9mIHRoZSBsaXN0IHRvIHByZXNlcnZlIHRoZSBvcmRlci4KCSAqLwoJd2hpbGUoICpsaXN0ICkKCQlsaXN0ID0gJigqbGlzdCktPm5leHQ7CgkqbGlzdCA9IGVudHJ5Owp9CgpzdGF0aWMgTFBXU1RSIGJ1aWxkX3Byb3BlcnRpZXMoc3RydWN0IHN0cmluZ19saXN0ICpwcm9wZXJ0eV9saXN0KQp7CglzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmxpc3Q7CglMUFdTVFIgcmV0LCBwLCB2YWx1ZTsKCURXT1JEIGxlbjsKCUJPT0wgbmVlZHNfcXVvdGU7CgoJaWYoIXByb3BlcnR5X2xpc3QpCgkJcmV0dXJuIE5VTEw7CgoJLyogY291bnQgdGhlIHNwYWNlIHdlIG5lZWQgKi8KCWxlbiA9IDE7Cglmb3IobGlzdCA9IHByb3BlcnR5X2xpc3Q7IGxpc3Q7IGxpc3QgPSBsaXN0LT5uZXh0KQoJCWxlbiArPSBsc3RybGVuVyhsaXN0LT5zdHIpICsgMzsKCglyZXQgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIGxlbipzaXplb2YoV0NIQVIpICk7CgoJLyogYWRkIGEgc3BhY2UgYmVmb3JlIGVhY2ggc3RyaW5nLCBhbmQgcXVvdGUgdGhlIHZhbHVlICovCglwID0gcmV0OwoJZm9yKGxpc3QgPSBwcm9wZXJ0eV9saXN0OyBsaXN0OyBsaXN0ID0gbGlzdC0+bmV4dCkKCXsKCQl2YWx1ZSA9IHN0cmNoclcobGlzdC0+c3RyLCc9Jyk7CgkJaWYoIXZhbHVlKQoJCQljb250aW51ZTsKCQlsZW4gPSB2YWx1ZSAtIGxpc3QtPnN0cjsKCQkqcCsrID0gJyAnOwoJCW1lbWNweShwLCBsaXN0LT5zdHIsIGxlbiAqIHNpemVvZihXQ0hBUikpOwoJCXAgKz0gbGVuOwoJCSpwKysgPSAnPSc7CgoJCS8qIGNoZWNrIGlmIHRoZSB2YWx1ZSBjb250YWlucyBzcGFjZXMgYW5kIG1heWJlIHF1b3RlIGl0ICovCgkJdmFsdWUrKzsKCQluZWVkc19xdW90ZSA9IHN0cmNoclcodmFsdWUsJyAnKSA/IDEgOiAwOwoJCWlmKG5lZWRzX3F1b3RlKQoJCQkqcCsrID0gJyInOwoJCWxlbiA9IGxzdHJsZW5XKHZhbHVlKTsKCQltZW1jcHkocCwgdmFsdWUsIGxlbiAqIHNpemVvZihXQ0hBUikpOwoJCXAgKz0gbGVuOwoJCWlmKG5lZWRzX3F1b3RlKQoJCQkqcCsrID0gJyInOwoJfQoJKnAgPSAwOwoKCVdJTkVfVFJBQ0UoInByb3BlcnRpZXMgLT4gJXNcbiIsIHdpbmVfZGJnc3RyX3cocmV0KSApOwoKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBMUFdTVFIgYnVpbGRfdHJhbnNmb3JtcyhzdHJ1Y3Qgc3RyaW5nX2xpc3QgKnRyYW5zZm9ybV9saXN0KQp7CglzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmxpc3Q7CglMUFdTVFIgcmV0LCBwOwoJRFdPUkQgbGVuOwoKCS8qIGNvdW50IHRoZSBzcGFjZSB3ZSBuZWVkICovCglsZW4gPSAxOwoJZm9yKGxpc3QgPSB0cmFuc2Zvcm1fbGlzdDsgbGlzdDsgbGlzdCA9IGxpc3QtPm5leHQpCgkJbGVuICs9IGxzdHJsZW5XKGxpc3QtPnN0cikgKyAxOwoKCXJldCA9IEhlYXBBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbGVuKnNpemVvZihXQ0hBUikgKTsKCgkvKiBhZGQgYWxsIHRoZSB0cmFuc2Zvcm1zIHdpdGggYSBzZW1pY29sb24gYmV0d2VlbiBlYWNoIG9uZSAqLwoJcCA9IHJldDsKCWZvcihsaXN0ID0gdHJhbnNmb3JtX2xpc3Q7IGxpc3Q7IGxpc3QgPSBsaXN0LT5uZXh0KQoJewoJCWxlbiA9IGxzdHJsZW5XKGxpc3QtPnN0cik7CgkJbHN0cmNweW5XKHAsIGxpc3QtPnN0ciwgbGVuICk7CgkJcCArPSBsZW47CgkJaWYobGlzdC0+bmV4dCkKCQkJKnArKyA9ICc7JzsKCX0KCSpwID0gMDsKCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgRFdPUkQgbXNpX2F0b3UoTFBDV1NUUiBzdHIpCnsKCURXT1JEIHJldCA9IDA7Cgl3aGlsZSgqc3RyID49ICcwJyAmJiAqc3RyIDw9ICc5JykKCXsKCQlyZXQgKj0gMTA7CgkJcmV0ICs9ICgqc3RyIC0gJzAnKTsKCQlzdHIrKzsKCX0KCXJldHVybiAwOwp9CgovKiBzdHIxIGlzIHRoZSBzYW1lIGFzIHN0cjIsIGlnbm9yaW5nIGNhc2UgKi8Kc3RhdGljIEJPT0wgbXNpX3N0cmVxdWFsKExQQ1dTVFIgc3RyMSwgTFBDU1RSIHN0cjIpCnsKCURXT1JEIGxlbiwgcmV0OwoJTFBXU1RSIHN0clc7CgoJbGVuID0gTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIyLCAtMSwgTlVMTCwgMCk7CglpZiggIWxlbiApCgkJcmV0dXJuIEZBTFNFOwoJaWYoIGxzdHJsZW5XKHN0cjEpICE9IChsZW4tMSkgKQoJCXJldHVybiBGQUxTRTsKCXN0clcgPSBIZWFwQWxsb2MoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgc2l6ZW9mKFdDSEFSKSpsZW4pOwoJTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIyLCAtMSwgc3RyVywgbGVuKTsKCXJldCA9IENvbXBhcmVTdHJpbmdXKEdldFRocmVhZExvY2FsZSgpLCBOT1JNX0lHTk9SRUNBU0UsIHN0cjEsIGxlbiwgc3RyVywgbGVuKTsKCUhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIHN0clcpOwoJcmV0dXJuIChyZXQgPT0gQ1NUUl9FUVVBTCk7Cn0KCi8qIHByZWZpeCBpcyBoeXBoZW4gb3IgZGFzaCwgYW5kIHN0cjEgaXMgdGhlIHNhbWUgYXMgc3RyMiwgaWdub3JpbmcgY2FzZSAqLwpzdGF0aWMgQk9PTCBtc2lfb3B0aW9uX2VxdWFsKExQQ1dTVFIgc3RyMSwgTFBDU1RSIHN0cjIpCnsKICAgIGlmIChzdHIxWzBdICE9ICcvJyAmJiBzdHIxWzBdICE9ICctJykKICAgICAgICByZXR1cm4gRkFMU0U7CgogICAgLyogc2tpcCBvdmVyIHRoZSBoeXBoZW4gb3Igc2xhc2ggKi8KICAgIHJldHVybiBtc2lfc3RyZXF1YWwoc3RyMSArIDEsIHN0cjIpOwp9CgovKiBzdHIyIGlzIGF0IHRoZSBiZWdpbm5pbmcgb2Ygc3RyMSwgaWdub3JpbmcgY2FzZSAqLwpzdGF0aWMgQk9PTCBtc2lfc3RycHJlZml4KExQQ1dTVFIgc3RyMSwgTFBDU1RSIHN0cjIpCnsKCURXT1JEIGxlbiwgcmV0OwoJTFBXU1RSIHN0clc7CgoJbGVuID0gTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIyLCAtMSwgTlVMTCwgMCk7CglpZiggIWxlbiApCgkJcmV0dXJuIEZBTFNFOwoJaWYoIGxzdHJsZW5XKHN0cjEpIDwgKGxlbi0xKSApCgkJcmV0dXJuIEZBTFNFOwoJc3RyVyA9IEhlYXBBbGxvYyhHZXRQcm9jZXNzSGVhcCgpLCAwLCBzaXplb2YoV0NIQVIpKmxlbik7CglNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0cjIsIC0xLCBzdHJXLCBsZW4pOwoJcmV0ID0gQ29tcGFyZVN0cmluZ1coR2V0VGhyZWFkTG9jYWxlKCksIE5PUk1fSUdOT1JFQ0FTRSwgc3RyMSwgbGVuLTEsIHN0clcsIGxlbi0xKTsKCUhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIHN0clcpOwoJcmV0dXJuIChyZXQgPT0gQ1NUUl9FUVVBTCk7Cn0KCi8qIHByZWZpeCBpcyBoeXBoZW4gb3IgZGFzaCwgYW5kIHN0cjIgaXMgYXQgdGhlIGJlZ2lubmluZyBvZiBzdHIxLCBpZ25vcmluZyBjYXNlICovCnN0YXRpYyBCT09MIG1zaV9vcHRpb25fcHJlZml4KExQQ1dTVFIgc3RyMSwgTFBDU1RSIHN0cjIpCnsKICAgIGlmIChzdHIxWzBdICE9ICcvJyAmJiBzdHIxWzBdICE9ICctJykKICAgICAgICByZXR1cm4gRkFMU0U7CgogICAgLyogc2tpcCBvdmVyIHRoZSBoeXBoZW4gb3Igc2xhc2ggKi8KICAgIHJldHVybiBtc2lfc3RycHJlZml4KHN0cjEgKyAxLCBzdHIyKTsKfQoKc3RhdGljIFZPSUQgKkxvYWRQcm9jKExQQ1dTVFIgRGxsTmFtZSwgTFBDU1RSIFByb2NOYW1lLCBITU9EVUxFKiBEbGxIYW5kbGUpCnsKCVZPSUQqICgqcHJvYykodm9pZCk7CgoJKkRsbEhhbmRsZSA9IExvYWRMaWJyYXJ5RXhXKERsbE5hbWUsIE5VTEwsIExPQURfV0lUSF9BTFRFUkVEX1NFQVJDSF9QQVRIKTsKCWlmKCEqRGxsSGFuZGxlKQoJewoJCWZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvYWQgZGxsICVzXG4iLCB3aW5lX2RiZ3N0cl93KERsbE5hbWUpKTsKCQlFeGl0UHJvY2VzcygxKTsKCX0KCXByb2MgPSAoVk9JRCAqKSBHZXRQcm9jQWRkcmVzcygqRGxsSGFuZGxlLCBQcm9jTmFtZSk7CglpZighcHJvYykKCXsKCQlmcHJpbnRmKHN0ZGVyciwgIkRsbCAlcyBkb2VzIG5vdCBpbXBsZW1lbnQgZnVuY3Rpb24gJXNcbiIsCgkJCXdpbmVfZGJnc3RyX3coRGxsTmFtZSksIFByb2NOYW1lKTsKCQlGcmVlTGlicmFyeSgqRGxsSGFuZGxlKTsKCQlFeGl0UHJvY2VzcygxKTsKCX0KCglyZXR1cm4gcHJvYzsKfQoKc3RhdGljIERXT1JEIERvRGxsUmVnaXN0ZXJTZXJ2ZXIoTFBDV1NUUiBEbGxOYW1lKQp7CglIUkVTVUxUIGhyOwoJRExMUkVHSVNURVJTRVJWRVIgcGZEbGxSZWdpc3RlclNlcnZlciA9IE5VTEw7CglITU9EVUxFIERsbEhhbmRsZSA9IE5VTEw7CgoJcGZEbGxSZWdpc3RlclNlcnZlciA9IExvYWRQcm9jKERsbE5hbWUsICJEbGxSZWdpc3RlclNlcnZlciIsICZEbGxIYW5kbGUpOwoKCWhyID0gcGZEbGxSZWdpc3RlclNlcnZlcigpOwoJaWYoRkFJTEVEKGhyKSkKCXsKCQlmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byByZWdpc3RlciBkbGwgJXNcbiIsIHdpbmVfZGJnc3RyX3coRGxsTmFtZSkpOwoJCXJldHVybiAxOwoJfQoJcHJpbnRmKCJTdWNjZXNzZnVsbHkgcmVnaXN0ZXJlZCBkbGwgJXNcbiIsIHdpbmVfZGJnc3RyX3coRGxsTmFtZSkpOwoJaWYoRGxsSGFuZGxlKQoJCUZyZWVMaWJyYXJ5KERsbEhhbmRsZSk7CglyZXR1cm4gMDsKfQoKc3RhdGljIERXT1JEIERvRGxsVW5yZWdpc3RlclNlcnZlcihMUENXU1RSIERsbE5hbWUpCnsKCUhSRVNVTFQgaHI7CglETExVTlJFR0lTVEVSU0VSVkVSIHBmRGxsVW5yZWdpc3RlclNlcnZlciA9IE5VTEw7CglITU9EVUxFIERsbEhhbmRsZSA9IE5VTEw7CgoJcGZEbGxVbnJlZ2lzdGVyU2VydmVyID0gTG9hZFByb2MoRGxsTmFtZSwgIkRsbFVucmVnaXN0ZXJTZXJ2ZXIiLCAmRGxsSGFuZGxlKTsKCglociA9IHBmRGxsVW5yZWdpc3RlclNlcnZlcigpOwoJaWYoRkFJTEVEKGhyKSkKCXsKCQlmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byB1bnJlZ2lzdGVyIGRsbCAlc1xuIiwgd2luZV9kYmdzdHJfdyhEbGxOYW1lKSk7CgkJcmV0dXJuIDE7Cgl9CglwcmludGYoIlN1Y2Nlc3NmdWxseSB1bnJlZ2lzdGVyZWQgZGxsICVzXG4iLCB3aW5lX2RiZ3N0cl93KERsbE5hbWUpKTsKCWlmKERsbEhhbmRsZSkKCQlGcmVlTGlicmFyeShEbGxIYW5kbGUpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBCT09MIHByb2Nlc3NfYXJnc19mcm9tX3JlZyggTFBXU1RSIGlkZW50LCBpbnQgKnBhcmdjLCBXQ0hBUiAqKipwYXJndiApCnsKCUxPTkcgcjsKCUhLRVkgaGtleSA9IDAsIGhrZXlBcmdzID0gMDsKCURXT1JEIHN6ID0gMCwgdHlwZSA9IDA7CglMUFdTVFIgYnVmID0gTlVMTDsKCUJPT0wgcmV0ID0gRkFMU0U7CgoJciA9IFJlZ09wZW5LZXlXKEhLRVlfTE9DQUxfTUFDSElORSwgSW5zdGFsbFJ1bk9uY2UsICZoa2V5KTsKCWlmKHIgIT0gRVJST1JfU1VDQ0VTUykKCQlyZXR1cm4gRkFMU0U7CglyID0gUmVnUXVlcnlWYWx1ZUV4Vyhoa2V5LCBpZGVudCwgMCwgJnR5cGUsIDAsICZzeik7CglpZihyID09IEVSUk9SX1NVQ0NFU1MgJiYgdHlwZSA9PSBSRUdfU1opCgl7CgkJYnVmID0gSGVhcEFsbG9jKEdldFByb2Nlc3NIZWFwKCksIDAsIHN6KTsKCQlyID0gUmVnUXVlcnlWYWx1ZUV4Vyhoa2V5LCBpZGVudCwgMCwgJnR5cGUsIChMUEJZVEUpYnVmLCAmc3opOwoJCWlmKCByID09IEVSUk9SX1NVQ0NFU1MgKQoJCXsKCQkJKnBhcmd2ID0gQ29tbWFuZExpbmVUb0FyZ3ZXKGJ1ZiwgcGFyZ2MpOwoJCQlyZXQgPSBUUlVFOwoJCX0KCX0KCVJlZ0Nsb3NlS2V5KGhrZXlBcmdzKTsKCXJldHVybiByZXQ7Cn0KCmludCBtYWluKGludCBhcmdjLCBjaGFyICoqYXJndikKewoJaW50IGk7CglCT09MIEZ1bmN0aW9uSW5zdGFsbCA9IEZBTFNFOwoJQk9PTCBGdW5jdGlvbkluc3RhbGxBZG1pbiA9IEZBTFNFOwoJQk9PTCBGdW5jdGlvblJlcGFpciA9IEZBTFNFOwoJQk9PTCBGdW5jdGlvbkFkdmVydGlzZSA9IEZBTFNFOwoJQk9PTCBGdW5jdGlvblBhdGNoID0gRkFMU0U7CglCT09MIEZ1bmN0aW9uRGxsUmVnaXN0ZXJTZXJ2ZXIgPSBGQUxTRTsKCUJPT0wgRnVuY3Rpb25EbGxVbnJlZ2lzdGVyU2VydmVyID0gRkFMU0U7CglCT09MIEZ1bmN0aW9uUmVnU2VydmVyID0gRkFMU0U7CglCT09MIEZ1bmN0aW9uVW5yZWdTZXJ2ZXIgPSBGQUxTRTsKCUJPT0wgRnVuY3Rpb25Vbmtub3duID0gRkFMU0U7CgoJTFBXU1RSIFBhY2thZ2VOYW1lID0gTlVMTDsKCUxQV1NUUiBQcm9wZXJ0aWVzID0gTlVMTDsKCXN0cnVjdCBzdHJpbmdfbGlzdCAqcHJvcGVydHlfbGlzdCA9IE5VTEw7CgoJRFdPUkQgUmVwYWlyTW9kZSA9IDA7CgoJRFdPUkRfUFRSIEFkdmVydGlzZU1vZGUgPSAwOwoJc3RydWN0IHN0cmluZ19saXN0ICp0cmFuc2Zvcm1fbGlzdCA9IE5VTEw7CglMQU5HSUQgTGFuZ3VhZ2UgPSAwOwoKCURXT1JEIExvZ01vZGUgPSAwOwoJTFBXU1RSIExvZ0ZpbGVOYW1lID0gTlVMTDsKCURXT1JEIExvZ0F0dHJpYnV0ZXMgPSAwOwoKCUxQV1NUUiBQYXRjaEZpbGVOYW1lID0gTlVMTDsKCUlOU1RBTExUWVBFIEluc3RhbGxUeXBlID0gSU5TVEFMTFRZUEVfREVGQVVMVDsKCglJTlNUQUxMVUlMRVZFTCBJbnN0YWxsVUlMZXZlbCA9IElOU1RBTExVSUxFVkVMX0ZVTEw7CgoJTFBXU1RSIERsbE5hbWUgPSBOVUxMOwoJRFdPUkQgUmV0dXJuQ29kZTsKCUxQV1NUUiAqYXJndlcgPSBOVUxMOwoKCS8qIG92ZXJ3cml0ZSB0aGUgY29tbWFuZCBsaW5lICovCglhcmd2VyA9IENvbW1hbmRMaW5lVG9Bcmd2VyggR2V0Q29tbWFuZExpbmVXKCksICZhcmdjICk7CgoJLyoKCSAqIElmIHRoZSBhcmdzIGJlZ2luIHdpdGggL0AgSURFTlQgdGhlbiB3ZSBuZWVkIHRvIGxvYWQgdGhlIHJlYWwKCSAqIGNvbW1hbmQgbGluZSBvdXQgb2YgdGhlIFJ1bk9uY2VFbnRyaWVzIGtleSBpbiB0aGUgcmVnaXN0cnkuCgkgKiAgV2UgZG8gdGhhdCBiZWZvcmUgc3RhcnRpbmcgdG8gcHJvY2VzcyB0aGUgcmVhbCBjb21tYW5kbGluZSwKCSAqIHRoZW4gb3ZlcndyaXRlIHRoZSBjb21tYW5kbGluZSBhZ2Fpbi4KCSAqLwoJaWYoYXJnYz4xICYmIG1zaV9vcHRpb25fZXF1YWwoYXJndldbMV0sICJAIikpCgl7CgkJaWYoIXByb2Nlc3NfYXJnc19mcm9tX3JlZyggYXJndldbMl0sICZhcmdjLCAmYXJndlcgKSkKCQkJcmV0dXJuIDE7Cgl9CgoJZm9yKGkgPSAxOyBpIDwgYXJnYzsgaSsrKQoJewoJCVdJTkVfVFJBQ0UoImFyZ3ZXWyVkXSA9ICVzXG4iLCBpLCB3aW5lX2RiZ3N0cl93KGFyZ3ZXW2ldKSk7CgoJCWlmIChtc2lfb3B0aW9uX2VxdWFsKGFyZ3ZXW2ldLCAicmVnc2VydmVyIikpCgkJewoJCQlGdW5jdGlvblJlZ1NlcnZlciA9IFRSVUU7CgkJfQoJCWVsc2UgaWYgKG1zaV9vcHRpb25fZXF1YWwoYXJndldbaV0sICJ1bnJlZ3NlcnZlciIpIHx8IG1zaV9vcHRpb25fZXF1YWwoYXJndldbaV0sICJ1bnJlZ2lzdGVyIikpCgkJewoJCQlGdW5jdGlvblVucmVnU2VydmVyID0gVFJVRTsKCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX3ByZWZpeChhcmd2V1tpXSwgImkiKSkKCQl7CgkJCUxQV1NUUiBhcmd2V2kgPSBhcmd2V1tpXTsKCQkJRnVuY3Rpb25JbnN0YWxsID0gVFJVRTsKCQkJaWYobHN0cmxlblcoYXJndldpKSA+IDIpCgkJCQlhcmd2V2kgKz0gMjsKCQkJZWxzZQoJCQl7CgkJCQlpKys7CgkJCQlpZihpID49IGFyZ2MpCgkJCQkJU2hvd1VzYWdlKDEpOwoJCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJCWFyZ3ZXaSA9IGFyZ3ZXW2ldOwoJCQl9CgkJCVBhY2thZ2VOYW1lID0gYXJndldpOwoJCX0KCQllbHNlIGlmKG1zaV9vcHRpb25fZXF1YWwoYXJndldbaV0sICJhIikpCgkJewoJCQlGdW5jdGlvbkluc3RhbGwgPSBUUlVFOwoJCQlGdW5jdGlvbkluc3RhbGxBZG1pbiA9IFRSVUU7CgkJCUluc3RhbGxUeXBlID0gSU5TVEFMTFRZUEVfTkVUV09SS19JTUFHRTsKCQkJaSsrOwoJCQlpZihpID49IGFyZ2MpCgkJCQlTaG93VXNhZ2UoMSk7CgkJCVdJTkVfVFJBQ0UoImFyZ3ZXWyVkXSA9ICVzXG4iLCBpLCB3aW5lX2RiZ3N0cl93KGFyZ3ZXW2ldKSk7CgkJCVBhY2thZ2VOYW1lID0gYXJndldbaV07CgkJCVN0cmluZ0xpc3RBcHBlbmQoJnByb3BlcnR5X2xpc3QsIEFjdGlvbkFkbWluKTsKCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX3ByZWZpeChhcmd2V1tpXSwgImYiKSkKCQl7CgkJCWludCBqOwoJCQlpbnQgbGVuID0gbHN0cmxlblcoYXJndldbaV0pOwoJCQlGdW5jdGlvblJlcGFpciA9IFRSVUU7CgkJCWZvcihqID0gMjsgaiA8IGxlbjsgaisrKQoJCQl7CgkJCQlzd2l0Y2goYXJndldbaV1bal0pCgkJCQl7CgkJCQkJY2FzZSAnUCc6CgkJCQkJY2FzZSAncCc6CgkJCQkJCVJlcGFpck1vZGUgfD0gUkVJTlNUQUxMTU9ERV9GSUxFTUlTU0lORzsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnTyc6CgkJCQkJY2FzZSAnbyc6CgkJCQkJCVJlcGFpck1vZGUgfD0gUkVJTlNUQUxMTU9ERV9GSUxFT0xERVJWRVJTSU9OOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdFJzoKCQkJCQljYXNlICdlJzoKCQkJCQkJUmVwYWlyTW9kZSB8PSBSRUlOU1RBTExNT0RFX0ZJTEVFUVVBTFZFUlNJT047CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ0QnOgoJCQkJCWNhc2UgJ2QnOgoJCQkJCQlSZXBhaXJNb2RlIHw9IFJFSU5TVEFMTE1PREVfRklMRUVYQUNUOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdDJzoKCQkJCQljYXNlICdjJzoKCQkJCQkJUmVwYWlyTW9kZSB8PSBSRUlOU1RBTExNT0RFX0ZJTEVWRVJJRlk7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ0EnOgoJCQkJCWNhc2UgJ2EnOgoJCQkJCQlSZXBhaXJNb2RlIHw9IFJFSU5TVEFMTE1PREVfRklMRVJFUExBQ0U7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ1UnOgoJCQkJCWNhc2UgJ3UnOgoJCQkJCQlSZXBhaXJNb2RlIHw9IFJFSU5TVEFMTE1PREVfVVNFUkRBVEE7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ00nOgoJCQkJCWNhc2UgJ20nOgoJCQkJCQlSZXBhaXJNb2RlIHw9IFJFSU5TVEFMTE1PREVfTUFDSElORURBVEE7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ1MnOgoJCQkJCWNhc2UgJ3MnOgoJCQkJCQlSZXBhaXJNb2RlIHw9IFJFSU5TVEFMTE1PREVfU0hPUlRDVVQ7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ1YnOgoJCQkJCWNhc2UgJ3YnOgoJCQkJCQlSZXBhaXJNb2RlIHw9IFJFSU5TVEFMTE1PREVfUEFDS0FHRTsKCQkJCQkJYnJlYWs7CgkJCQkJZGVmYXVsdDoKCQkJCQkJZnByaW50ZihzdGRlcnIsICJVbmtub3duIG9wdGlvbiBcIiVjXCIgaW4gUmVwYWlyIG1vZGVcbiIsIGFyZ3ZXW2ldW2pdKTsKCQkJCQkJYnJlYWs7CgkJCQl9CgkJCX0KCQkJaWYobGVuID09IDIpCgkJCXsKCQkJCVJlcGFpck1vZGUgPSBSRUlOU1RBTExNT0RFX0ZJTEVNSVNTSU5HIHwKCQkJCQlSRUlOU1RBTExNT0RFX0ZJTEVFUVVBTFZFUlNJT04gfAoJCQkJCVJFSU5TVEFMTE1PREVfRklMRVZFUklGWSB8CgkJCQkJUkVJTlNUQUxMTU9ERV9NQUNISU5FREFUQSB8CgkJCQkJUkVJTlNUQUxMTU9ERV9TSE9SVENVVDsKCQkJfQoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJUGFja2FnZU5hbWUgPSBhcmd2V1tpXTsKCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX2VxdWFsKGFyZ3ZXW2ldLCAieCIpKQoJCXsKCQkJRnVuY3Rpb25JbnN0YWxsID0gVFJVRTsKCQkJaSsrOwoJCQlpZihpID49IGFyZ2MpCgkJCQlTaG93VXNhZ2UoMSk7CgkJCVdJTkVfVFJBQ0UoImFyZ3ZXWyVkXSA9ICVzXG4iLCBpLCB3aW5lX2RiZ3N0cl93KGFyZ3ZXW2ldKSk7CgkJCVBhY2thZ2VOYW1lID0gYXJndldbaV07CgkJCVN0cmluZ0xpc3RBcHBlbmQoJnByb3BlcnR5X2xpc3QsIFJlbW92ZUFsbCk7CgkJfQoJCWVsc2UgaWYobXNpX29wdGlvbl9wcmVmaXgoYXJndldbaV0sICJqIikpCgkJewoJCQlpbnQgajsKCQkJaW50IGxlbiA9IGxzdHJsZW5XKGFyZ3ZXW2ldKTsKCQkJRnVuY3Rpb25BZHZlcnRpc2UgPSBUUlVFOwoJCQlmb3IoaiA9IDI7IGogPCBsZW47IGorKykKCQkJewoJCQkJc3dpdGNoKGFyZ3ZXW2ldW2pdKQoJCQkJewoJCQkJCWNhc2UgJ1UnOgoJCQkJCWNhc2UgJ3UnOgoJCQkJCQlBZHZlcnRpc2VNb2RlID0gQURWRVJUSVNFRkxBR1NfVVNFUkFTU0lHTjsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnTSc6CgkJCQkJY2FzZSAnbSc6CgkJCQkJCUFkdmVydGlzZU1vZGUgPSBBRFZFUlRJU0VGTEFHU19NQUNISU5FQVNTSUdOOwoJCQkJCQlicmVhazsKCQkJCQlkZWZhdWx0OgoJCQkJCQlmcHJpbnRmKHN0ZGVyciwgIlVua25vd24gb3B0aW9uIFwiJWNcIiBpbiBBZHZlcnRpc2UgbW9kZVxuIiwgYXJndldbaV1bal0pOwoJCQkJCQlicmVhazsKCQkJCX0KCQkJfQoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJUGFja2FnZU5hbWUgPSBhcmd2V1tpXTsKCQl9CgkJZWxzZSBpZihtc2lfc3RyZXF1YWwoYXJndldbaV0sICJ1IikpCgkJewoJCQlGdW5jdGlvbkFkdmVydGlzZSA9IFRSVUU7CgkJCUFkdmVydGlzZU1vZGUgPSBBRFZFUlRJU0VGTEFHU19VU0VSQVNTSUdOOwoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJUGFja2FnZU5hbWUgPSBhcmd2V1tpXTsKCQl9CgkJZWxzZSBpZihtc2lfc3RyZXF1YWwoYXJndldbaV0sICJtIikpCgkJewoJCQlGdW5jdGlvbkFkdmVydGlzZSA9IFRSVUU7CgkJCUFkdmVydGlzZU1vZGUgPSBBRFZFUlRJU0VGTEFHU19NQUNISU5FQVNTSUdOOwoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJUGFja2FnZU5hbWUgPSBhcmd2V1tpXTsKCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX2VxdWFsKGFyZ3ZXW2ldLCAidCIpKQoJCXsKCQkJaSsrOwoJCQlpZihpID49IGFyZ2MpCgkJCQlTaG93VXNhZ2UoMSk7CgkJCVdJTkVfVFJBQ0UoImFyZ3ZXWyVkXSA9ICVzXG4iLCBpLCB3aW5lX2RiZ3N0cl93KGFyZ3ZXW2ldKSk7CgkJCVN0cmluZ0xpc3RBcHBlbmQoJnRyYW5zZm9ybV9saXN0LCBhcmd2V1tpXSk7CgkJfQoJCWVsc2UgaWYobXNpX29wdGlvbl9lcXVhbChhcmd2V1tpXSwgImciKSkKCQl7CgkJCWkrKzsKCQkJaWYoaSA+PSBhcmdjKQoJCQkJU2hvd1VzYWdlKDEpOwoJCQlXSU5FX1RSQUNFKCJhcmd2V1slZF0gPSAlc1xuIiwgaSwgd2luZV9kYmdzdHJfdyhhcmd2V1tpXSkpOwoJCQlMYW5ndWFnZSA9IG1zaV9hdG91KGFyZ3ZXW2ldKTsKCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX3ByZWZpeChhcmd2V1tpXSwgImwiKSkKCQl7CgkJCWludCBqOwoJCQlpbnQgbGVuID0gbHN0cmxlblcoYXJndldbaV0pOwoJCQlmb3IoaiA9IDI7IGogPCBsZW47IGorKykKCQkJewoJCQkJc3dpdGNoKGFyZ3ZXW2ldW2pdKQoJCQkJewoJCQkJCWNhc2UgJ0knOgoJCQkJCWNhc2UgJ2knOgoJCQkJCQlMb2dNb2RlIHw9IElOU1RBTExMT0dNT0RFX0lORk87CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ1cnOgoJCQkJCWNhc2UgJ3cnOgoJCQkJCQlMb2dNb2RlIHw9IElOU1RBTExMT0dNT0RFX1dBUk5JTkc7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ0UnOgoJCQkJCWNhc2UgJ2UnOgoJCQkJCQlMb2dNb2RlIHw9IElOU1RBTExMT0dNT0RFX0VSUk9SOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdBJzoKCQkJCQljYXNlICdhJzoKCQkJCQkJTG9nTW9kZSB8PSBJTlNUQUxMTE9HTU9ERV9BQ1RJT05TVEFSVDsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnUic6CgkJCQkJY2FzZSAncic6CgkJCQkJCUxvZ01vZGUgfD0gSU5TVEFMTExPR01PREVfQUNUSU9OREFUQTsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnVSc6CgkJCQkJY2FzZSAndSc6CgkJCQkJCUxvZ01vZGUgfD0gSU5TVEFMTExPR01PREVfVVNFUjsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnQyc6CgkJCQkJY2FzZSAnYyc6CgkJCQkJCUxvZ01vZGUgfD0gSU5TVEFMTExPR01PREVfQ09NTU9OREFUQTsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnTSc6CgkJCQkJY2FzZSAnbSc6CgkJCQkJCUxvZ01vZGUgfD0gSU5TVEFMTExPR01PREVfRkFUQUxFWElUOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdPJzoKCQkJCQljYXNlICdvJzoKCQkJCQkJTG9nTW9kZSB8PSBJTlNUQUxMTE9HTU9ERV9PVVRPRkRJU0tTUEFDRTsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnUCc6CgkJCQkJY2FzZSAncCc6CgkJCQkJCUxvZ01vZGUgfD0gSU5TVEFMTExPR01PREVfUFJPUEVSVFlEVU1QOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdWJzoKCQkJCQljYXNlICd2JzoKCQkJCQkJTG9nTW9kZSB8PSBJTlNUQUxMTE9HTU9ERV9WRVJCT1NFOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICcqJzoKCQkJCQkJTG9nTW9kZSA9IElOU1RBTExMT0dNT0RFX0ZBVEFMRVhJVCB8CgkJCQkJCQlJTlNUQUxMTE9HTU9ERV9FUlJPUiB8CgkJCQkJCQlJTlNUQUxMTE9HTU9ERV9XQVJOSU5HIHwKCQkJCQkJCUlOU1RBTExMT0dNT0RFX1VTRVIgfAoJCQkJCQkJSU5TVEFMTExPR01PREVfSU5GTyB8CgkJCQkJCQlJTlNUQUxMTE9HTU9ERV9SRVNPTFZFU09VUkNFIHwKCQkJCQkJCUlOU1RBTExMT0dNT0RFX09VVE9GRElTS1NQQUNFIHwKCQkJCQkJCUlOU1RBTExMT0dNT0RFX0FDVElPTlNUQVJUIHwKCQkJCQkJCUlOU1RBTExMT0dNT0RFX0FDVElPTkRBVEEgfAoJCQkJCQkJSU5TVEFMTExPR01PREVfQ09NTU9OREFUQSB8CgkJCQkJCQlJTlNUQUxMTE9HTU9ERV9QUk9QRVJUWURVTVAgfAoJCQkJCQkJSU5TVEFMTExPR01PREVfUFJPR1JFU1MgfAoJCQkJCQkJSU5TVEFMTExPR01PREVfSU5JVElBTElaRSB8CgkJCQkJCQlJTlNUQUxMTE9HTU9ERV9URVJNSU5BVEUgfAoJCQkJCQkJSU5TVEFMTExPR01PREVfU0hPV0RJQUxPRzsKCQkJCQkJYnJlYWs7CgkJCQkJY2FzZSAnKyc6CgkJCQkJCUxvZ0F0dHJpYnV0ZXMgfD0gSU5TVEFMTExPR0FUVFJJQlVURVNfQVBQRU5EOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICchJzoKCQkJCQkJTG9nQXR0cmlidXRlcyB8PSBJTlNUQUxMTE9HQVRUUklCVVRFU19GTFVTSEVBQ0hMSU5FOwoJCQkJCQlicmVhazsKCQkJCQlkZWZhdWx0OgoJCQkJCQlicmVhazsKCQkJCX0KCQkJfQoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJTG9nRmlsZU5hbWUgPSBhcmd2V1tpXTsKCQkJaWYoTXNpRW5hYmxlTG9nVyhMb2dNb2RlLCBMb2dGaWxlTmFtZSwgTG9nQXR0cmlidXRlcykgIT0gRVJST1JfU1VDQ0VTUykKCQkJewoJCQkJZnByaW50ZihzdGRlcnIsICJMb2dnaW5nIGluICVzICgweCUwOGx4LCAlbHUpIGZhaWxlZFxuIiwKCQkJCQkgd2luZV9kYmdzdHJfdyhMb2dGaWxlTmFtZSksIExvZ01vZGUsIExvZ0F0dHJpYnV0ZXMpOwoJCQkJRXhpdFByb2Nlc3MoMSk7CgkJCX0KCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX2VxdWFsKGFyZ3ZXW2ldLCAicCIpKQoJCXsKCQkJRnVuY3Rpb25QYXRjaCA9IFRSVUU7CgkJCWkrKzsKCQkJaWYoaSA+PSBhcmdjKQoJCQkJU2hvd1VzYWdlKDEpOwoJCQlXSU5FX1RSQUNFKCJhcmd2V1slZF0gPSAlc1xuIiwgaSwgd2luZV9kYmdzdHJfdyhhcmd2V1tpXSkpOwoJCQlQYXRjaEZpbGVOYW1lID0gYXJndldbaV07CgkJfQoJCWVsc2UgaWYobXNpX29wdGlvbl9wcmVmaXgoYXJndldbaV0sICJxIikpCgkJewoJCQlpZihsc3RybGVuVyhhcmd2V1tpXSkgPT0gMiB8fCBtc2lfc3RyZXF1YWwoYXJndldbaV0rMiwgIm4iKSkKCQkJewoJCQkJSW5zdGFsbFVJTGV2ZWwgPSBJTlNUQUxMVUlMRVZFTF9OT05FOwoJCQl9CgkJCWVsc2UgaWYobXNpX3N0cmVxdWFsKGFyZ3ZXW2ldKzIsICJiIikpCgkJCXsKCQkJCUluc3RhbGxVSUxldmVsID0gSU5TVEFMTFVJTEVWRUxfQkFTSUM7CgkJCX0KCQkJZWxzZSBpZihtc2lfc3RyZXF1YWwoYXJndldbaV0rMiwgInIiKSkKCQkJewoJCQkJSW5zdGFsbFVJTGV2ZWwgPSBJTlNUQUxMVUlMRVZFTF9SRURVQ0VEOwoJCQl9CgkJCWVsc2UgaWYobXNpX3N0cmVxdWFsKGFyZ3ZXW2ldKzIsICJmIikpCgkJCXsKCQkJCUluc3RhbGxVSUxldmVsID0gSU5TVEFMTFVJTEVWRUxfRlVMTHxJTlNUQUxMVUlMRVZFTF9FTkRESUFMT0c7CgkJCX0KCQkJZWxzZSBpZihtc2lfc3RyZXF1YWwoYXJndldbaV0rMiwgIm4rIikpCgkJCXsKCQkJCUluc3RhbGxVSUxldmVsID0gSU5TVEFMTFVJTEVWRUxfTk9ORXxJTlNUQUxMVUlMRVZFTF9FTkRESUFMT0c7CgkJCX0KCQkJZWxzZSBpZihtc2lfc3RyZXF1YWwoYXJndldbaV0rMiwgImIrIikpCgkJCXsKCQkJCUluc3RhbGxVSUxldmVsID0gSU5TVEFMTFVJTEVWRUxfQkFTSUN8SU5TVEFMTFVJTEVWRUxfRU5ERElBTE9HOwoJCQl9CgkJCWVsc2UgaWYobXNpX3N0cmVxdWFsKGFyZ3ZXW2ldKzIsICJiLSIpKQoJCQl7CgkJCQlJbnN0YWxsVUlMZXZlbCA9IElOU1RBTExVSUxFVkVMX0JBU0lDfElOU1RBTExVSUxFVkVMX1BST0dSRVNTT05MWTsKCQkJfQoJCQllbHNlIGlmKG1zaV9zdHJlcXVhbChhcmd2V1tpXSsyLCAiYishIikpCgkJCXsKCQkJCUluc3RhbGxVSUxldmVsID0gSU5TVEFMTFVJTEVWRUxfQkFTSUN8SU5TVEFMTFVJTEVWRUxfRU5ERElBTE9HOwoJCQkJV0lORV9GSVhNRSgiVW5rbm93biBtb2RpZmllcjogIVxuIik7CgkJCX0KCQkJZWxzZQoJCQl7CgkJCQlmcHJpbnRmKHN0ZGVyciwgIlVua25vd24gb3B0aW9uIFwiJXNcIiBmb3IgVUkgbGV2ZWxcbiIsCgkJCQkJIHdpbmVfZGJnc3RyX3coYXJndldbaV0rMikpOwoJCQl9CgkJfQoJCWVsc2UgaWYobXNpX29wdGlvbl9lcXVhbChhcmd2V1tpXSwgInkiKSkKCQl7CgkJCUZ1bmN0aW9uRGxsUmVnaXN0ZXJTZXJ2ZXIgPSBUUlVFOwoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJRGxsTmFtZSA9IGFyZ3ZXW2ldOwoJCX0KCQllbHNlIGlmKG1zaV9vcHRpb25fZXF1YWwoYXJndldbaV0sICJ6IikpCgkJewoJCQlGdW5jdGlvbkRsbFVucmVnaXN0ZXJTZXJ2ZXIgPSBUUlVFOwoJCQlpKys7CgkJCWlmKGkgPj0gYXJnYykKCQkJCVNob3dVc2FnZSgxKTsKCQkJV0lORV9UUkFDRSgiYXJndldbJWRdID0gJXNcbiIsIGksIHdpbmVfZGJnc3RyX3coYXJndldbaV0pKTsKCQkJRGxsTmFtZSA9IGFyZ3ZXW2ldOwoJCX0KCQllbHNlIGlmKG1zaV9vcHRpb25fZXF1YWwoYXJndldbaV0sICJoIikgfHwgbXNpX29wdGlvbl9lcXVhbChhcmd2V1tpXSwgIj8iKSkKCQl7CgkJCVNob3dVc2FnZSgwKTsKCQl9CgkJZWxzZSBpZihtc2lfb3B0aW9uX2VxdWFsKGFyZ3ZXW2ldLCAibSIpKQoJCXsKCQkJRnVuY3Rpb25Vbmtub3duID0gVFJVRTsKCQkJV0lORV9GSVhNRSgiVW5rbm93biBwYXJhbWV0ZXIgL21cbiIpOwoJCX0KCQllbHNlIGlmKG1zaV9vcHRpb25fZXF1YWwoYXJndldbaV0sICJEIikpCgkJewoJCQlGdW5jdGlvblVua25vd24gPSBUUlVFOwoJCQlXSU5FX0ZJWE1FKCJVbmtub3duIHBhcmFtZXRlciAvRFxuIik7CgkJfQoJCWVsc2UKCQkJU3RyaW5nTGlzdEFwcGVuZCgmcHJvcGVydHlfbGlzdCwgYXJndldbaV0pOwoJfQoKCS8qIHN0YXJ0IHRoZSBHVUkgKi8KCU1zaVNldEludGVybmFsVUkoSW5zdGFsbFVJTGV2ZWwsIE5VTEwpOwoKCVByb3BlcnRpZXMgPSBidWlsZF9wcm9wZXJ0aWVzKCBwcm9wZXJ0eV9saXN0ICk7CgoJaWYoRnVuY3Rpb25JbnN0YWxsQWRtaW4gJiYgRnVuY3Rpb25QYXRjaCkKCQlGdW5jdGlvbkluc3RhbGwgPSBGQUxTRTsKCglSZXR1cm5Db2RlID0gMTsKCWlmKEZ1bmN0aW9uSW5zdGFsbCkKCXsKCQlpZihJc1Byb2R1Y3RDb2RlKFBhY2thZ2VOYW1lKSkKCQkJUmV0dXJuQ29kZSA9IE1zaUNvbmZpZ3VyZVByb2R1Y3RFeFcoUGFja2FnZU5hbWUsIDAsIElOU1RBTExTVEFURV9ERUZBVUxULCBQcm9wZXJ0aWVzKTsKCQllbHNlCgkJCVJldHVybkNvZGUgPSBNc2lJbnN0YWxsUHJvZHVjdFcoUGFja2FnZU5hbWUsIFByb3BlcnRpZXMpOwoJfQoJZWxzZSBpZihGdW5jdGlvblJlcGFpcikKCXsKCQlpZihJc1Byb2R1Y3RDb2RlKFBhY2thZ2VOYW1lKSkKCQkJV0lORV9GSVhNRSgiUHJvZHVjdCBjb2RlIHRyZWF0bWVudCBub3QgaW1wbGVtZW50ZWQgeWV0XG4iKTsKCQllbHNlCgkJCVJldHVybkNvZGUgPSBNc2lSZWluc3RhbGxQcm9kdWN0VyhQYWNrYWdlTmFtZSwgUmVwYWlyTW9kZSk7Cgl9CgllbHNlIGlmKEZ1bmN0aW9uQWR2ZXJ0aXNlKQoJewoJCUxQV1NUUiBUcmFuc2Zvcm1zID0gYnVpbGRfdHJhbnNmb3JtcyggcHJvcGVydHlfbGlzdCApOwoJCVJldHVybkNvZGUgPSBNc2lBZHZlcnRpc2VQcm9kdWN0VyhQYWNrYWdlTmFtZSwgKExQV1NUUikgQWR2ZXJ0aXNlTW9kZSwgVHJhbnNmb3JtcywgTGFuZ3VhZ2UpOwoJfQoJZWxzZSBpZihGdW5jdGlvblBhdGNoKQoJewoJCVJldHVybkNvZGUgPSBNc2lBcHBseVBhdGNoVyhQYXRjaEZpbGVOYW1lLCBQYWNrYWdlTmFtZSwgSW5zdGFsbFR5cGUsIFByb3BlcnRpZXMpOwoJfQoJZWxzZSBpZihGdW5jdGlvbkRsbFJlZ2lzdGVyU2VydmVyKQoJewoJCVJldHVybkNvZGUgPSBEb0RsbFJlZ2lzdGVyU2VydmVyKERsbE5hbWUpOwoJfQoJZWxzZSBpZihGdW5jdGlvbkRsbFVucmVnaXN0ZXJTZXJ2ZXIpCgl7CgkJUmV0dXJuQ29kZSA9IERvRGxsVW5yZWdpc3RlclNlcnZlcihEbGxOYW1lKTsKCX0KCWVsc2UgaWYgKEZ1bmN0aW9uUmVnU2VydmVyKQoJewoJCVdJTkVfRklYTUUoICIvcmVnc2VydmVyIG5vdCBpbXBsZW1lbnRlZCB5ZXQsIGlnbm9yaW5nXG4iICk7Cgl9CgllbHNlIGlmIChGdW5jdGlvblVucmVnU2VydmVyKQoJewoJCVdJTkVfRklYTUUoICIvdW5yZWdzZXJ2ZXIgbm90IGltcGxlbWVudGVkIHlldCwgaWdub3JpbmdcbiIgKTsKCX0KCWVsc2UgaWYgKEZ1bmN0aW9uVW5rbm93bikKCXsKCQlXSU5FX0ZJWE1FKCAiVW5rbm93biBmdW5jdGlvbiwgaWdub3JpbmdcbiIgKTsKCX0KCWVsc2UKCQlTaG93VXNhZ2UoMSk7CgoJcmV0dXJuIFJldHVybkNvZGU7Cn0K