LyogUG9ydGlvbnMgb2YgdGhpcyBmaWxlIGFyZSBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29weXJpZ2h0KHMpLiAgU2VlCiAqIHRoZSBOZXQtU05NUCdzIENPUFlJTkcgZmlsZSBmb3IgbW9yZSBkZXRhaWxzIGFuZCBvdGhlciBjb3B5cmlnaHRzCiAqIHRoYXQgbWF5IGFwcGx5OgogKi8KLyoKICogUG9ydGlvbnMgb2YgdGhpcyBmaWxlIGFyZSBjb3B5cmlnaHRlZCBieToKICogQ29weXJpZ2h0IKkgMjAwMyBTdW4gTWljcm9zeXN0ZW1zLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAqIFVzZSBpcyBzdWJqZWN0IHRvIGxpY2Vuc2UgdGVybXMgc3BlY2lmaWVkIGluIHRoZSBDT1BZSU5HIGZpbGUKICogZGlzdHJpYnV0ZWQgd2l0aCB0aGUgTmV0LVNOTVAgcGFja2FnZS4KICovCgovKgogKiBzY2FwaS5jCiAqCiAqLwoKI2luY2x1ZGUgPG5ldC1zbm1wL25ldC1zbm1wLWNvbmZpZy5oPgoKI2luY2x1ZGUgPHN5cy90eXBlcy5oPgojaWYgSEFWRV9XSU5TT0NLX0gKI2luY2x1ZGUgPHdpbnNvY2suaD4KI2VuZGlmCiNpZmRlZiBIQVZFX1NURExJQl9ICiNpbmNsdWRlIDxzdGRsaWIuaD4KI2VuZGlmCiNpZiBIQVZFX1NUUklOR19ICiNpbmNsdWRlIDxzdHJpbmcuaD4KI2Vsc2UKI2luY2x1ZGUgPHN0cmluZ3MuaD4KI2VuZGlmCiNpZiBUSU1FX1dJVEhfU1lTX1RJTUUKIyBpZmRlZiBXSU4zMgojICBpbmNsdWRlIDxzeXMvdGltZWIuaD4KIyBlbHNlCiMgIGluY2x1ZGUgPHN5cy90aW1lLmg+CiMgZW5kaWYKIyBpbmNsdWRlIDx0aW1lLmg+CiNlbHNlCiMgaWYgSEFWRV9TWVNfVElNRV9ICiMgIGluY2x1ZGUgPHN5cy90aW1lLmg+CiMgZWxzZQojICBpbmNsdWRlIDx0aW1lLmg+CiMgZW5kaWYKI2VuZGlmCiNpZmRlZiBIQVZFX05FVElORVRfSU5fSAojaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgojZW5kaWYKCiNpZiBIQVZFX1VOSVNURF9ICiNpbmNsdWRlIDx1bmlzdGQuaD4KI2VuZGlmCiNpZiBIQVZFX0RNQUxMT0NfSAojaW5jbHVkZSA8ZG1hbGxvYy5oPgojZW5kaWYKCiNpbmNsdWRlIDxuZXQtc25tcC90eXBlcy5oPgojaW5jbHVkZSA8bmV0LXNubXAvb3V0cHV0X2FwaS5oPgojaW5jbHVkZSA8bmV0LXNubXAvdXRpbGl0aWVzLmg+CgojaWZkZWYgTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1CiNpbmNsdWRlIDxuZXQtc25tcC9saWJyYXJ5L21kNS5oPgojZW5kaWYKI2luY2x1ZGUgPG5ldC1zbm1wL2xpYnJhcnkvc25tcF9hcGkuaD4KI2luY2x1ZGUgPG5ldC1zbm1wL2xpYnJhcnkvY2FsbGJhY2suaD4KI2luY2x1ZGUgPG5ldC1zbm1wL2xpYnJhcnkvc25tcF9zZWNtb2QuaD4KI2luY2x1ZGUgPG5ldC1zbm1wL2xpYnJhcnkvc25tcHVzbS5oPgojaW5jbHVkZSA8bmV0LXNubXAvbGlicmFyeS9rZXl0b29scy5oPgojaW5jbHVkZSA8bmV0LXNubXAvbGlicmFyeS9zY2FwaS5oPgojaW5jbHVkZSA8bmV0LXNubXAvbGlicmFyeS9taWIuaD4KI2luY2x1ZGUgPG5ldC1zbm1wL2xpYnJhcnkvdHJhbnNmb3JtX29pZHMuaD4KCiNpZmRlZiBORVRTTk1QX1VTRV9PUEVOU1NMCiNpbmNsdWRlIDxvcGVuc3NsL2htYWMuaD4KI2luY2x1ZGUgPG9wZW5zc2wvZXZwLmg+CiNpbmNsdWRlIDxvcGVuc3NsL3JhbmQuaD4KI2luY2x1ZGUgPG9wZW5zc2wvZGVzLmg+CiNpZmRlZiBIQVZFX0FFUwojaW5jbHVkZSA8b3BlbnNzbC9hZXMuaD4KI2VuZGlmCgojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9ERVMKI2lmZGVmIFNUUlVDVF9ERVNfS1NfU1RSVUNUX0hBU19XRUFLX0tFWQovKiB0aGVzZSBhcmUgb2xkZXIgbmFtZXMgZm9yIG5ld2VyIHN0cnVjdHVyZXMgdGhhdCBleGlzdCBpbiBvcGVuc3NsIC45LjcgKi8KI2RlZmluZSBERVNfa2V5X3NjaGVkdWxlICAgIGRlc19rZXlfc2NoZWR1bGUgCiNkZWZpbmUgREVTX2NibG9jayAgICAgICAgICBkZXNfY2Jsb2NrIAojZGVmaW5lIERFU19rZXlfc2NoZWQgICAgICAgZGVzX2tleV9zY2hlZCAKI2RlZmluZSBERVNfbmNiY19lbmNyeXB0ICAgIGRlc19uY2JjX2VuY3J5cHQKI2RlZmluZSBERVNfY2JjX2VuY3J5cHQgICAgZGVzX2NiY19lbmNyeXB0CiNkZWZpbmUgT0xEX0RFUwojZW5kaWYKI2VuZGlmCgojZW5kaWYgLyogSEFWRV9PUEVOU1NMICovCgojaWZkZWYgTkVUU05NUF9VU0VfUEtDUzExCiNpbmNsdWRlIDxzZWN1cml0eS9jcnlwdG9raS5oPgojZW5kaWYKCiNpZmRlZiBRVUlURlVOCiN1bmRlZiBRVUlURlVOCiNkZWZpbmUgUVVJVEZVTihlLCBsKQkJCQkJXAoJaWYgKGUgIT0gU05NUEVSUl9TVUNDRVNTKSB7CQkJXAoJCXJ2YWwgPSBTTk1QRVJSX1NDX0dFTkVSQUxfRkFJTFVSRTsJXAoJCWdvdG8gbCA7CQkJCVwKCX0KI2VuZGlmCgoKLyoKICogc2NfZ2V0X3Byb3Blcmxlbmd0aChvaWQgKmhhc2h0eXBlLCB1X2ludCBoYXNodHlwZV9sZW4pOgogKiAKICogR2l2ZW4gYSBoYXNoaW5nIHR5cGUgKCJoYXNodHlwZSIgYW5kIGl0cyBsZW5ndGggaGFzaHR5cGVfbGVuKSwgcmV0dXJuCiAqIHRoZSBsZW5ndGggb2YgdGhlIGhhc2ggcmVzdWx0LgogKiAKICogUmV0dXJucyBlaXRoZXIgdGhlIGxlbmd0aCBvciBTTk1QRVJSX0dFTkVSUiBmb3IgYW4gdW5rbm93biBoYXNoaW5nIHR5cGUuCiAqLwppbnQKc2NfZ2V0X3Byb3Blcmxlbmd0aChjb25zdCBvaWQgKiBoYXNodHlwZSwgdV9pbnQgaGFzaHR5cGVfbGVuKQp7CiAgICBERUJVR1RSQUNFOwogICAgLyoKICAgICAqIERldGVybWluZSB0cmFuc2Zvcm0gdHlwZSBoYXNoIGxlbmd0aC4KICAgICAqLwojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9NRDUKICAgIGlmIChJU1RSQU5TRk9STShoYXNodHlwZSwgSE1BQ01ENUF1dGgpKSB7CiAgICAgICAgcmV0dXJuIEJZVEVTSVpFKFNOTVBfVFJBTlNfQVVUSExFTl9ITUFDTUQ1KTsKICAgIH0gZWxzZQojZW5kaWYKICAgICAgICBpZiAoSVNUUkFOU0ZPUk0oaGFzaHR5cGUsIEhNQUNTSEExQXV0aCkpIHsKICAgICAgICByZXR1cm4gQllURVNJWkUoU05NUF9UUkFOU19BVVRITEVOX0hNQUNTSEExKTsKICAgIH0KICAgIHJldHVybiBTTk1QRVJSX0dFTkVSUjsKfQoKaW50CnNjX2dldF9wcm9wZXJfcHJpdl9sZW5ndGgoY29uc3Qgb2lkICogcHJpdnR5cGUsIHVfaW50IHByaXZ0eXBlX2xlbikKewogICAgaW50IHByb3Blcmxlbmd0aCA9IDA7CiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX0RFUwogICAgaWYgKElTVFJBTlNGT1JNKHByaXZ0eXBlLCBERVNQcml2KSkgewogICAgICAgIHByb3Blcmxlbmd0aCA9IEJZVEVTSVpFKFNOTVBfVFJBTlNfUFJJVkxFTl8xREVTKTsKICAgIH0KI2VuZGlmCiNpZmRlZiBIQVZFX0FFUwogICAgaWYgKElTVFJBTlNGT1JNKHByaXZ0eXBlLCBBRVNQcml2KSkgewogICAgICAgIHByb3Blcmxlbmd0aCA9IEJZVEVTSVpFKFNOTVBfVFJBTlNfUFJJVkxFTl9BRVMpOwogICAgfQojZW5kaWYKICAgIHJldHVybiBwcm9wZXJsZW5ndGg7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi1vLSoqKioqKgogKiBzY19pbml0CiAqCiAqIFJldHVybnM6CiAqCVNOTVBFUlJfU1VDQ0VTUwkJCVN1Y2Nlc3MuCiAqLwppbnQKc2NfaW5pdCh2b2lkKQp7CiAgICBpbnQgICAgICAgICAgICAgcnZhbCA9IFNOTVBFUlJfU1VDQ0VTUzsKCiNpZm5kZWYgTkVUU05NUF9VU0VfT1BFTlNTTAojaWZkZWYgTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1CiAgICBzdHJ1Y3QgdGltZXZhbCAgdHY7CgogICAgREVCVUdUUkFDRTsKCiAgICBnZXR0aW1lb2ZkYXkoJnR2LCAoc3RydWN0IHRpbWV6b25lICopIDApOwoKICAgIHNyYW5kb20odHYudHZfc2VjIF4gdHYudHZfdXNlYyk7CiNlbGlmIE5FVFNOTVBfVVNFX1BLQ1MxMQogICAgREVCVUdUUkFDRTsKICAgIHJ2YWwgPSBwa2NzX2luaXQoKTsKI2Vsc2UKICAgIHJ2YWwgPSBTTk1QRVJSX1NDX05PVF9DT05GSUdVUkVEOwojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBORVRTTk1QX1VTRV9JTlRFUk5BTF9NRDUgKi8KICAgIC8qCiAgICAgKiBYWFggb2d1ZDogVGhlIG9ubHkgcmVhc29uIHRvIGRvIGFueXRoaW5nIGhlcmUgd2l0aCBvcGVuc3NsIGlzIHRvIAogICAgICogKiBYWFggb2d1ZDogc2VlZCByYW5kb20gbnVtYmVyIGdlbmVyYXRvciAKICAgICAqLwojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIGlmbmRlZiBORVRTTk1QX1VTRV9PUEVOU1NMICovCiAgICByZXR1cm4gcnZhbDsKfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBlbmQgc2NfaW5pdCgpICovCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi1vLSoqKioqKgogKiBzY19yYW5kb20KICoKICogUGFyYW1ldGVyczoKICoJKmJ1ZgkJUHJlLWFsbG9jYXRlZCBidWZmZXIuCiAqCSpidWZsZW4gCVNpemUgb2YgYnVmZmVyLgogKiAgICAgIAogKiBSZXR1cm5zOgogKglTTk1QRVJSX1NVQ0NFU1MJCQlTdWNjZXNzLgogKi8KaW50CnNjX3JhbmRvbSh1X2NoYXIgKiBidWYsIHNpemVfdCAqIGJ1ZmxlbikKI2lmIGRlZmluZWQoTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1KSB8fCBkZWZpbmVkKE5FVFNOTVBfVVNFX09QRU5TU0wpIHx8IGRlZmluZWQoTkVUU05NUF9VU0VfUEtDUzExKQp7CiAgICBpbnQgICAgICAgICAgICAgcnZhbCA9IFNOTVBFUlJfU1VDQ0VTUzsKI2lmZGVmIE5FVFNOTVBfVVNFX0lOVEVSTkFMX01ENQogICAgaW50ICAgICAgICAgICAgIGk7CiAgICBpbnQgICAgICAgICAgICAgcm5kdmFsOwogICAgdV9jaGFyICAgICAgICAgKnVjcCA9IGJ1ZjsKI2VuZGlmCgogICAgREVCVUdUUkFDRTsKCiNpZmRlZiBORVRTTk1QX1VTRV9PUEVOU1NMCiAgICBSQU5EX2J5dGVzKGJ1ZiwgKmJ1Zmxlbik7ICAgLyogd2lsbCBuZXZlciBmYWlsICovCiNlbGlmIE5FVFNOTVBfVVNFX1BLQ1MxMQkJCS8qIE5FVFNOTVBfVVNFX1BLQ1MxMSAqLwogICAgcGtjc19yYW5kb20oYnVmLCAqYnVmbGVuKTsKI2Vsc2UgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBORVRTTk1QX1VTRV9JTlRFUk5BTF9NRDUgKi8KICAgIC8qCiAgICAgKiBmaWxsIHRoZSBidWZmZXIgd2l0aCByYW5kb20gaW50ZWdlcnMuICBOb3RlIHRoYXQgcmFuZG9tKCkKICAgICAqIGlzIGRlZmluZWQgaW4gY29uZmlnLmggYW5kIG1heSBub3QgYmUgdHJ1bHkgdGhlIHJhbmRvbSgpCiAgICAgKiBzeXN0ZW0gY2FsbCBpZiBzb21ldGhpbmcgYmV0dGVyIGV4aXN0ZWQgCiAgICAgKi8KICAgIHJ2YWwgPSAqYnVmbGVuIC0gKmJ1ZmxlbiAlIHNpemVvZihybmR2YWwpOwogICAgZm9yIChpID0gMDsgaSA8IHJ2YWw7IGkgKz0gc2l6ZW9mKHJuZHZhbCkpIHsKICAgICAgICBybmR2YWwgPSByYW5kb20oKTsKICAgICAgICBtZW1jcHkodWNwLCAmcm5kdmFsLCBzaXplb2Yocm5kdmFsKSk7CiAgICAgICAgdWNwICs9IHNpemVvZihybmR2YWwpOwogICAgfQoKICAgIHJuZHZhbCA9IHJhbmRvbSgpOwogICAgbWVtY3B5KHVjcCwgJnJuZHZhbCwgKmJ1ZmxlbiAlIHNpemVvZihybmR2YWwpKTsKCiAgICBydmFsID0gU05NUEVSUl9TVUNDRVNTOwojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIE5FVFNOTVBfVVNFX09QRU5TU0wgKi8KICAgIHJldHVybiBydmFsOwoKfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBlbmQgc2NfcmFuZG9tKCkgKi8KCiNlbHNlCl9TQ0FQSV9OT1RfQ09ORklHVVJFRAojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qICAqLwovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi1vLSoqKioqKgogKiBzY19nZW5lcmF0ZV9rZXllZF9oYXNoCiAqCiAqIFBhcmFtZXRlcnM6CiAqCSBhdXRodHlwZQlUeXBlIG9mIGF1dGhlbnRpY2F0aW9uIHRyYW5zZm9ybS4KICoJIGF1dGh0eXBlbGVuCiAqCSprZXkJCVBvaW50ZXIgdG8ga2V5IChLdWwpIHRvIHVzZSBpbiBrZXllZCBoYXNoLgogKgkga2V5bGVuCQlMZW5ndGggb2Yga2V5IGluIGJ5dGVzLgogKgkqbWVzc2FnZQlQb2ludGVyIHRvIHRoZSBtZXNzYWdlIHRvIGhhc2guCiAqCSBtc2dsZW4JCUxlbmd0aCBvZiB0aGUgbWVzc2FnZS4KICoJKk1BQwkJV2lsbCBiZSByZXR1cm5lZCB3aXRoIGFsbG9jYXRlZCBieXRlcyBjb250YWluZyBoYXNoLgogKgkqbWFjbGVuCQlMZW5ndGggb2YgdGhlIGhhc2ggYnVmZmVyIGluIGJ5dGVzOyBhbHNvIGluZGljYXRlcwogKgkJCQl3aGV0aGVyIHRoZSBNQUMgc2hvdWxkIGJlIHRydW5jYXRlZC4KICogICAgICAKICogUmV0dXJuczoKICoJU05NUEVSUl9TVUNDRVNTCQkJU3VjY2Vzcy4KICoJU05NUEVSUl9HRU5FUlIJCQlBbGwgZXJycwogKgogKgogKiBBIGhhc2ggb2YgdGhlIGZpcnN0IG1zZ2xlbiBieXRlcyBvZiBtZXNzYWdlIHVzaW5nIGEga2V5ZWQgaGFzaCBkZWZpbmVkCiAqIGJ5IGF1dGh0eXBlIGlzIGNyZWF0ZWQgYW5kIHN0b3JlZCBpbiBNQUMuICBNQUMgaXMgQVNTVU1FRCB0byBiZSBhIGJ1ZmZlcgogKiBvZiBhdCBsZWFzdCBtYWNsZW4gYnl0ZXMuICBJZiB0aGUgbGVuZ3RoIG9mIHRoZSBoYXNoIGlzIGdyZWF0ZXIgdGhhbgogKiBtYWNsZW4sIGl0IGlzIHRydW5jYXRlZCB0byBmaXQgdGhlIGJ1ZmZlci4gIElmIHRoZSBsZW5ndGggb2YgdGhlIGhhc2ggaXMKICogbGVzcyB0aGFuIG1hY2xlbiwgbWFjbGVuIHNldCB0byB0aGUgbnVtYmVyIG9mIGhhc2ggYnl0ZXMgZ2VuZXJhdGVkLgogKgogKiBBU1NVTUVEIHRoYXQgdGhlIG51bWJlciBvZiBoYXNoIGJpdHMgaXMgYSBtdWx0aXBsZSBvZiA4LgogKi8KaW50CnNjX2dlbmVyYXRlX2tleWVkX2hhc2goY29uc3Qgb2lkICogYXV0aHR5cGUsIHNpemVfdCBhdXRodHlwZWxlbiwKICAgICAgICAgICAgICAgICAgICAgICB1X2NoYXIgKiBrZXksIHVfaW50IGtleWxlbiwKICAgICAgICAgICAgICAgICAgICAgICB1X2NoYXIgKiBtZXNzYWdlLCB1X2ludCBtc2dsZW4sCiAgICAgICAgICAgICAgICAgICAgICAgdV9jaGFyICogTUFDLCBzaXplX3QgKiBtYWNsZW4pCiNpZiAgZGVmaW5lZChORVRTTk1QX1VTRV9JTlRFUk5BTF9NRDUpIHx8IGRlZmluZWQoTkVUU05NUF9VU0VfT1BFTlNTTCkgfHwgZGVmaW5lZChORVRTTk1QX1VTRV9QS0NTMTEpCnsKICAgIGludCAgICAgICAgICAgICBydmFsID0gU05NUEVSUl9TVUNDRVNTOwogICAgaW50ICAgICAgICAgICAgIHByb3Blcmxlbmd0aDsKCiAgICB1X2NoYXIgICAgICAgICAgYnVmW1NOTVBfTUFYQlVGX1NNQUxMXTsKI2lmICBkZWZpbmVkKE5FVFNOTVBfVVNFX09QRU5TU0wpIHx8IGRlZmluZWQoTkVUU05NUF9VU0VfUEtDUzExKQogICAgc2l6ZV90ICAgICAgICAgICAgIGJ1Zl9sZW4gPSBzaXplb2YoYnVmKTsKI2VuZGlmCgogICAgREVCVUdUUkFDRTsKCiNpZmRlZiBORVRTTk1QX0VOQUJMRV9URVNUSU5HX0NPREUKICAgIHsKICAgICAgICBpbnQgICAgICAgICAgICAgaTsKICAgICAgICBERUJVR01TRygoInNjX2dlbmVyYXRlX2tleWVkX2hhc2giLAogICAgICAgICAgICAgICAgICAic2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaCgpOiBrZXk9MHgiKSk7CiAgICAgICAgZm9yIChpID0gMDsgaSA8IGtleWxlbjsgaSsrKQogICAgICAgICAgICBERUJVR01TRygoInNjX2dlbmVyYXRlX2tleWVkX2hhc2giLCAiJTAyeCIsIGtleVtpXSAmIDB4ZmYpKTsKICAgICAgICBERUJVR01TRygoInNjX2dlbmVyYXRlX2tleWVkX2hhc2giLCAiICglZClcbiIsIGtleWxlbikpOwogICAgfQojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIE5FVFNOTVBfRU5BQkxFX1RFU1RJTkdfQ09ERSAqLwoKICAgIC8qCiAgICAgKiBTYW5pdHkgY2hlY2suCiAgICAgKi8KICAgIGlmICghYXV0aHR5cGUgfHwgIWtleSB8fCAhbWVzc2FnZSB8fCAhTUFDIHx8ICFtYWNsZW4KICAgICAgICB8fCAoa2V5bGVuIDw9IDApIHx8IChtc2dsZW4gPD0gMCkgfHwgKCptYWNsZW4gPD0gMCkKICAgICAgICB8fCAoYXV0aHR5cGVsZW4gIT0gVVNNX0xFTkdUSF9PSURfVFJBTlNGT1JNKSkgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2dlbmVyYXRlX2tleWVkX2hhc2hfcXVpdCk7CiAgICB9CgogICAgcHJvcGVybGVuZ3RoID0gc2NfZ2V0X3Byb3Blcmxlbmd0aChhdXRodHlwZSwgYXV0aHR5cGVsZW4pOwogICAgaWYgKHByb3Blcmxlbmd0aCA9PSBTTk1QRVJSX0dFTkVSUikKICAgICAgICByZXR1cm4gcHJvcGVybGVuZ3RoOwoKICAgIGlmICgoKGludCkga2V5bGVuIDwgcHJvcGVybGVuZ3RoKSkgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2dlbmVyYXRlX2tleWVkX2hhc2hfcXVpdCk7CiAgICB9CiNpZmRlZiBORVRTTk1QX1VTRV9PUEVOU1NMCiAgICAvKgogICAgICogRGV0ZXJtaW5lIHRyYW5zZm9ybSB0eXBlLgogICAgICovCiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX01ENQogICAgaWYgKElTVFJBTlNGT1JNKGF1dGh0eXBlLCBITUFDTUQ1QXV0aCkpCiAgICAgICAgSE1BQyhFVlBfbWQ1KCksIGtleSwga2V5bGVuLCBtZXNzYWdlLCBtc2dsZW4sIGJ1ZiwgJmJ1Zl9sZW4pOwogICAgZWxzZQojZW5kaWYKICAgICAgICBpZiAoSVNUUkFOU0ZPUk0oYXV0aHR5cGUsIEhNQUNTSEExQXV0aCkpCiAgICAgICAgSE1BQyhFVlBfc2hhMSgpLCBrZXksIGtleWxlbiwgbWVzc2FnZSwgbXNnbGVuLCBidWYsICZidWZfbGVuKTsKICAgIGVsc2UgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2dlbmVyYXRlX2tleWVkX2hhc2hfcXVpdCk7CiAgICB9CiAgICBpZiAoKGludClidWZfbGVuICE9IHByb3Blcmxlbmd0aCkgewogICAgICAgIFFVSVRGVU4ocnZhbCwgc2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaF9xdWl0KTsKICAgIH0KICAgIGlmICgoaW50KSptYWNsZW4gPiBidWZfbGVuKQogICAgICAgICptYWNsZW4gPSBidWZfbGVuOwogICAgbWVtY3B5KE1BQywgYnVmLCAqbWFjbGVuKTsKCiNlbGlmIE5FVFNOTVBfVVNFX1BLQ1MxMSAgICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9VU0VfUEtDUzExICovCgojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9NRDUKICAgIGlmIChJU1RSQU5TRk9STShhdXRodHlwZSwgSE1BQ01ENUF1dGgpKSB7CglpZiAocGtjc19zaWduKENLTV9NRDVfSE1BQyxrZXksIGtleWxlbiwgbWVzc2FnZSwKCQkJbXNnbGVuLCBidWYsICZidWZfbGVuKSAhPSBTTk1QRVJSX1NVQ0NFU1MpIHsKICAgICAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaF9xdWl0KTsKICAgICAgICB9CiAgICB9IGVsc2UKI2VuZGlmCiAgICAgICAgaWYgKElTVFJBTlNGT1JNKGF1dGh0eXBlLCBITUFDU0hBMUF1dGgpKSB7CglpZiAocGtjc19zaWduKENLTV9TSEFfMV9ITUFDLGtleSwga2V5bGVuLCBtZXNzYWdlLAoJCQltc2dsZW4sIGJ1ZiwgJmJ1Zl9sZW4pICE9IFNOTVBFUlJfU1VDQ0VTUykgewogICAgICAgICAgICBRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19nZW5lcmF0ZV9rZXllZF9oYXNoX3F1aXQpOwogICAgICAgIH0KICAgIH0gZWxzZSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaF9xdWl0KTsKICAgIH0KCiAgICBpZiAoYnVmX2xlbiAhPSBwcm9wZXJsZW5ndGgpIHsKICAgICAgICBRVUlURlVOKHJ2YWwsIHNjX2dlbmVyYXRlX2tleWVkX2hhc2hfcXVpdCk7CiAgICB9CiAgICBpZiAoKm1hY2xlbiA+IGJ1Zl9sZW4pCiAgICAgICAgKm1hY2xlbiA9IGJ1Zl9sZW47CiAgICBtZW1jcHkoTUFDLCBidWYsICptYWNsZW4pOwoKI2Vsc2UgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1ICovCiAgICBpZiAoKGludCkgKm1hY2xlbiA+IHByb3Blcmxlbmd0aCkKICAgICAgICAqbWFjbGVuID0gcHJvcGVybGVuZ3RoOwogICAgaWYgKE1Ec2lnbihtZXNzYWdlLCBtc2dsZW4sIE1BQywgKm1hY2xlbiwga2V5LCBrZXlsZW4pKSB7CiAgICAgICAgcnZhbCA9IFNOTVBFUlJfR0VORVJSOwogICAgICAgIGdvdG8gc2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaF9xdWl0OwogICAgfQojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIE5FVFNOTVBfVVNFX09QRU5TU0wgKi8KCiNpZmRlZiBORVRTTk1QX0VOQUJMRV9URVNUSU5HX0NPREUKICAgIHsKICAgICAgICBjaGFyICAgICAgICAgICAqczsKICAgICAgICBpbnQgICAgICAgICAgICAgbGVuID0gYmluYXJ5X3RvX2hleChNQUMsICptYWNsZW4sICZzKTsKCiAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwgIkZ1bGwgdjMgbWVzc2FnZSBoYXNoOiAlc1xuIiwgcykpOwogICAgICAgIFNOTVBfWkVSTyhzLCBsZW4pOwogICAgICAgIFNOTVBfRlJFRShzKTsKICAgIH0KI2VuZGlmICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBORVRTTk1QX0VOQUJMRV9URVNUSU5HX0NPREUgKi8KCiAgc2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaF9xdWl0OgogICAgbWVtc2V0KGJ1ZiwgMCwgU05NUF9NQVhCVUZfU01BTEwpOwogICAgcmV0dXJuIHJ2YWw7Cn0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogZW5kIHNjX2dlbmVyYXRlX2tleWVkX2hhc2goKSAqLwoKI2Vsc2UKICAgICAgICAgICAgICAgIF9TQ0FQSV9OT1RfQ09ORklHVVJFRAojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qICovCi8qCiAqIHNjX2hhc2goKTogYSBnZW5lcmljIHdyYXBwZXIgYXJvdW5kIHdoYXRldmVyIGhhc2hpbmcgcGFja2FnZSB3ZSBhcmUgdXNpbmcuCiAqIAogKiBJTjoKICogaGFzaHR5cGUgICAgLSBvaWQgcG9pbnRlciB0byBhIGhhc2ggdHlwZQogKiBoYXNodHlwZWxlbiAtIGxlbmd0aCBvZiBvaWQgcG9pbnRlcgogKiBidWYgICAgICAgICAtIHVfY2hhciBidWZmZXIgdG8gYmUgaGFzaGVkCiAqIGJ1Zl9sZW4gICAgIC0gaW50ZWdlciBsZW5ndGggb2YgYnVmIGRhdGEKICogTUFDX2xlbiAgICAgLSBsZW5ndGggb2YgdGhlIHBhc3NlZCBNQUMgYnVmZmVyIHNpemUuCiAqIAogKiBPVVQ6ICAgIAogKiBNQUMgICAgICAgICAtIHByZS1tYWxsb2NlZCBzcGFjZSB0byBzdG9yZSBoYXNoIG91dHB1dC4KICogTUFDX2xlbiAgICAgLSBsZW5ndGggb2YgTUFDIG91dHB1dCB0byB0aGUgTUFDIGJ1ZmZlci4KICogCiAqIFJldHVybnM6CiAqIFNOTVBFUlJfU1VDQ0VTUyAgICAgICAgICAgICAgU3VjY2Vzcy4KICogU05NUF9TQ19HRU5FUkFMX0ZBSUxVUkUgICAgICBBbnkgZXJyb3IuCiAqLwppbnQKc2NfaGFzaChjb25zdCBvaWQgKiBoYXNodHlwZSwgc2l6ZV90IGhhc2h0eXBlbGVuLCB1X2NoYXIgKiBidWYsCiAgICAgICAgc2l6ZV90IGJ1Zl9sZW4sIHVfY2hhciAqIE1BQywgc2l6ZV90ICogTUFDX2xlbikKI2lmIGRlZmluZWQoTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1KSB8fCBkZWZpbmVkKE5FVFNOTVBfVVNFX09QRU5TU0wpIHx8IGRlZmluZWQoTkVUU05NUF9VU0VfUEtDUzExKQp7CiNpZiBkZWZpbmVkKE5FVFNOTVBfVVNFX09QRU5TU0wpIHx8IGRlZmluZWQoTkVUU05NUF9VU0VfUEtDUzExKQogICAgaW50ICAgICAgICAgICAgcnZhbCA9IFNOTVBFUlJfU1VDQ0VTUzsKICAgIHVuc2lnbmVkIGludCAgIHRtcF9sZW47CiNlbmRpZgogICAgaW50ICAgICAgICAgICAgcmV0OwoKI2lmZGVmIE5FVFNOTVBfVVNFX09QRU5TU0wKICAgIGNvbnN0IEVWUF9NRCAgICpoYXNoZm47CiAgICBFVlBfTURfQ1RYICAgICAqY3B0cjsKI2VuZGlmCgogICAgREVCVUdUUkFDRTsKCiAgICBpZiAoaGFzaHR5cGUgPT0gTlVMTCB8fCBoYXNodHlwZWxlbiA8IDAgfHwgYnVmID09IE5VTEwgfHwKICAgICAgICBidWZfbGVuIDw9IDAgfHwgTUFDID09IE5VTEwgfHwgTUFDX2xlbiA9PSBOVUxMICkKICAgICAgICByZXR1cm4gKFNOTVBFUlJfR0VORVJSKTsKICAgIHJldCA9IHNjX2dldF9wcm9wZXJsZW5ndGgoaGFzaHR5cGUsIGhhc2h0eXBlbGVuKTsKICAgIGlmICgoIHJldCA8IDAgKSB8fCAoKk1BQ19sZW4gPCByZXQgKSkKICAgICAgICByZXR1cm4gKFNOTVBFUlJfR0VORVJSKTsKCiNpZmRlZiBORVRTTk1QX1VTRV9PUEVOU1NMCiAgICAvKgogICAgICogRGV0ZXJtaW5lIHRyYW5zZm9ybSB0eXBlLgogICAgICovCiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX01ENQogICAgaWYgKElTVFJBTlNGT1JNKGhhc2h0eXBlLCBITUFDTUQ1QXV0aCkpIHsKICAgICAgICBoYXNoZm4gPSAoY29uc3QgRVZQX01EICopIEVWUF9tZDUoKTsKICAgIH0gZWxzZQojZW5kaWYKICAgICAgICBpZiAoSVNUUkFOU0ZPUk0oaGFzaHR5cGUsIEhNQUNTSEExQXV0aCkpIHsKICAgICAgICBoYXNoZm4gPSAoY29uc3QgRVZQX01EICopIEVWUF9zaGExKCk7CiAgICB9IGVsc2UgewogICAgICAgIHJldHVybiAoU05NUEVSUl9HRU5FUlIpOwogICAgfQoKLyoqIGluaXRpYWxpemUgdGhlIHBvaW50ZXIgKi8KI2lmZGVmIEhBVkVfRVZQX01EX0NUWF9DUkVBVEUKICAgIGNwdHIgPSBFVlBfTURfQ1RYX2NyZWF0ZSgpOwojZWxzZQogICAgY3B0ciA9IG1hbGxvYyhzaXplb2YoKmNwdHIpKTsKI2lmIGRlZmluZWQoT0xEX0RFUykKICAgIG1lbXNldChjcHRyLCAwLCBzaXplb2YoKmNwdHIpKTsKI2Vsc2UKICAgIEVWUF9NRF9DVFhfaW5pdChjcHRyKTsKI2VuZGlmCiNlbmRpZgogICAgRVZQX0RpZ2VzdEluaXQoY3B0ciwgaGFzaGZuKTsKCi8qKiBwYXNzIHRoZSBkYXRhICovCiAgICBFVlBfRGlnZXN0VXBkYXRlKGNwdHIsIGJ1ZiwgYnVmX2xlbik7CgovKiogZG8gdGhlIGZpbmFsIHBhc3MgKi8KICAgIEVWUF9EaWdlc3RGaW5hbChjcHRyLCBNQUMsICZ0bXBfbGVuKTsKICAgICpNQUNfbGVuID0gdG1wX2xlbjsKI2lmZGVmIEhBVkVfRVZQX01EX0NUWF9ERVNUUk9ZCiAgICBFVlBfTURfQ1RYX2Rlc3Ryb3koY3B0cik7CiNlbHNlCiNpZiAhZGVmaW5lZChPTERfREVTKQogICAgRVZQX01EX0NUWF9jbGVhbnVwKGNwdHIpOwojZW5kaWYKICAgIGZyZWUoY3B0cik7CiNlbmRpZgogICAgcmV0dXJuIChydmFsKTsKI2VsaWYgTkVUU05NUF9VU0VfUEtDUzExICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9VU0VfUEtDUzExICovCgojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9NRDUKICAgIGlmIChJU1RSQU5TRk9STShoYXNodHlwZSwgSE1BQ01ENUF1dGgpKSB7CglydmFsID0gcGtjc19kaWdlc3QoQ0tNX01ENSwgYnVmLCBidWZfbGVuLCBNQUMsICZ0bXBfbGVuKTsKICAgICAgICAqTUFDX2xlbiA9IHRtcF9sZW47CiAgICB9IGVsc2UKI2VuZGlmCiAgICAgICAgaWYgKElTVFJBTlNGT1JNKGhhc2h0eXBlLCBITUFDU0hBMUF1dGgpKSB7CglydmFsID0gcGtjc19kaWdlc3QoQ0tNX1NIQV8xLCBidWYsIGJ1Zl9sZW4sIE1BQywgJnRtcF9sZW4pOwogICAgICAgICpNQUNfbGVuID0gdG1wX2xlbjsKICAgIH0gZWxzZSB7CiAgICAgICAgcmV0dXJuIChTTk1QRVJSX0dFTkVSUik7CiAgICB9CgogICAgIHJldHVybiAocnZhbCk7CgojZWxzZSAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIE5FVFNOTVBfVVNFX0lOVEVSTkFMX01ENSAqLwoKICAgIGlmIChNRGNoZWNrc3VtKGJ1ZiwgYnVmX2xlbiwgTUFDLCAqTUFDX2xlbikpIHsKICAgICAgICByZXR1cm4gU05NUEVSUl9HRU5FUlI7CiAgICB9CiAgICBpZiAoKk1BQ19sZW4gPiAxNikKICAgICAgICAqTUFDX2xlbiA9IDE2OwogICAgcmV0dXJuIFNOTVBFUlJfU1VDQ0VTUzsKCiNlbmRpZiAgICAgICAgICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9VU0VfT1BFTlNTTCAqLwp9CiNlbHNlICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogIWRlZmluZWQoTkVUU05NUF9VU0VfT1BFTlNTTCkgJiYgIWRlZmluZWQoTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1KSAqLwpfU0NBUElfTk9UX0NPTkZJR1VSRUQKI2VuZGlmICAgICAgICAgICAgICAgICAgICAgICAgICAvKiAhZGVmaW5lZChORVRTTk1QX1VTRV9PUEVOU1NMKSAmJiAhZGVmaW5lZChORVRTTk1QX1VTRV9JTlRFUk5BTF9NRDUpICovCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLW8tKioqKioqCiAqIHNjX2NoZWNrX2tleWVkX2hhc2gKICoKICogUGFyYW1ldGVyczoKICoJIGF1dGh0eXBlCVRyYW5zZm9ybSB0eXBlIG9mIGF1dGhlbnRpY2F0aW9uIGhhc2guCiAqCSprZXkJCUtleSBiaXRzIGluIGEgc3RyaW5nIG9mIGJ5dGVzLgogKgkga2V5bGVuCQlMZW5ndGggb2Yga2V5IGluIGJ5dGVzLgogKgkqbWVzc2FnZQlNZXNzYWdlIGZvciB3aGljaCB0byBjaGVjayB0aGUgaGFzaC4KICoJIG1zZ2xlbgkJTGVuZ3RoIG9mIG1lc3NhZ2UuCiAqCSpNQUMJCUdpdmVuIGhhc2guCiAqCSBtYWNsZW4JCUxlbmd0aCBvZiBnaXZlbiBoYXNoOyBpbmRpY2F0ZXMgdHJ1bmNhdGlvbiBpZiBpdCBpcwogKgkJCQlzaG9ydGVyIHRoYW4gdGhlIG5vcm1hbCBzaXplIG9mIG91dHB1dCBmb3IKICoJCQkJZ2l2ZW4gaGFzaCB0cmFuc2Zvcm0uCiAqIFJldHVybnM6CiAqCVNOTVBFUlJfU1VDQ0VTUwkJU3VjY2Vzcy4KICoJU05NUF9TQ19HRU5FUkFMX0ZBSUxVUkUJQW55IGVycm9yCiAqCiAqCiAqIENoZWNrIHRoZSBoYXNoIGdpdmVuIGluIE1BQyBhZ2FpbnN0IHRoZSBoYXNoIG9mIG1lc3NhZ2UuICBJZiB0aGUgbGVuZ3RoCiAqIG9mIE1BQyBpcyBsZXNzIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUgdHJhbnNmb3JtIGhhc2ggb3V0cHV0LCBvbmx5IG1hY2xlbgogKiBieXRlcyBhcmUgY29tcGFyZWQuICBUaGUgbGVuZ3RoIG9mIE1BQyBjYW5ub3QgYmUgZ3JlYXRlciB0aGFuIHRoZQogKiBsZW5ndGggb2YgdGhlIGhhc2ggdHJhbnNmb3JtIG91dHB1dC4KICovCmludApzY19jaGVja19rZXllZF9oYXNoKGNvbnN0IG9pZCAqIGF1dGh0eXBlLCBzaXplX3QgYXV0aHR5cGVsZW4sCiAgICAgICAgICAgICAgICAgICAgdV9jaGFyICoga2V5LCB1X2ludCBrZXlsZW4sCiAgICAgICAgICAgICAgICAgICAgdV9jaGFyICogbWVzc2FnZSwgdV9pbnQgbXNnbGVuLAogICAgICAgICAgICAgICAgICAgIHVfY2hhciAqIE1BQywgdV9pbnQgbWFjbGVuKQojaWYgZGVmaW5lZChORVRTTk1QX1VTRV9JTlRFUk5BTF9NRDUpIHx8IGRlZmluZWQoTkVUU05NUF9VU0VfT1BFTlNTTCkgfHwgZGVmaW5lZChORVRTTk1QX1VTRV9QS0NTMTEpCnsKICAgIGludCAgICAgICAgICAgICBydmFsID0gU05NUEVSUl9TVUNDRVNTOwogICAgc2l6ZV90ICAgICAgICAgIGJ1Zl9sZW4gPSBTTk1QX01BWEJVRl9TTUFMTDsKCiAgICB1X2NoYXIgICAgICAgICAgYnVmW1NOTVBfTUFYQlVGX1NNQUxMXTsKCiAgICBERUJVR1RSQUNFOwoKI2lmZGVmIE5FVFNOTVBfRU5BQkxFX1RFU1RJTkdfQ09ERQogICAgewogICAgICAgIGludCAgICAgICAgICAgICBpOwogICAgICAgIERFQlVHTVNHKCgic2NhcGkiLCAic2NfY2hlY2tfa2V5ZWRfaGFzaCgpOiAgICBrZXk9MHgiKSk7CiAgICAgICAgZm9yIChpID0gMDsgaSA8IGtleWxlbjsgaSsrKQogICAgICAgICAgICBERUJVR01TRygoInNjYXBpIiwgIiUwMngiLCBrZXlbaV0gJiAweGZmKSk7CiAgICAgICAgREVCVUdNU0coKCJzY2FwaSIsICIgKCVkKVxuIiwga2V5bGVuKSk7CiAgICB9CiNlbmRpZiAgICAgICAgICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9FTkFCTEVfVEVTVElOR19DT0RFICovCgogICAgLyoKICAgICAqIFNhbml0eSBjaGVjay4KICAgICAqLwogICAgaWYgKCFhdXRodHlwZSB8fCAha2V5IHx8ICFtZXNzYWdlIHx8ICFNQUMKICAgICAgICB8fCAoa2V5bGVuIDw9IDApIHx8IChtc2dsZW4gPD0gMCkgfHwgKG1hY2xlbiA8PSAwKQogICAgICAgIHx8IChhdXRodHlwZWxlbiAhPSBVU01fTEVOR1RIX09JRF9UUkFOU0ZPUk0pKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfY2hlY2tfa2V5ZWRfaGFzaF9xdWl0KTsKICAgIH0KCiAgICBpZiAobWFjbGVuICE9IFVTTV9NRDVfQU5EX1NIQV9BVVRIX0xFTikgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2NoZWNrX2tleWVkX2hhc2hfcXVpdCk7CiAgICB9CgogICAgLyoKICAgICAqIEdlbmVyYXRlIGEgZnVsbCBoYXNoIG9mIHRoZSBtZXNzYWdlLCB0aGVuIGNvbXBhcmUKICAgICAqIHRoZSByZXN1bHQgd2l0aCB0aGUgZ2l2ZW4gTUFDIHdoaWNoIG1heSBzaG9ydGVyIHRoYW4KICAgICAqIHRoZSBmdWxsIGhhc2ggbGVuZ3RoLgogICAgICovCiAgICBydmFsID0gc2NfZ2VuZXJhdGVfa2V5ZWRfaGFzaChhdXRodHlwZSwgYXV0aHR5cGVsZW4sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBrZXksIGtleWxlbiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1lc3NhZ2UsIG1zZ2xlbiwgYnVmLCAmYnVmX2xlbik7CiAgICBRVUlURlVOKHJ2YWwsIHNjX2NoZWNrX2tleWVkX2hhc2hfcXVpdCk7CgogICAgaWYgKG1hY2xlbiA+IG1zZ2xlbikgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2NoZWNrX2tleWVkX2hhc2hfcXVpdCk7CgogICAgfSBlbHNlIGlmIChtZW1jbXAoYnVmLCBNQUMsIG1hY2xlbikgIT0gMCkgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2NoZWNrX2tleWVkX2hhc2hfcXVpdCk7CiAgICB9CgoKICBzY19jaGVja19rZXllZF9oYXNoX3F1aXQ6CiAgICBtZW1zZXQoYnVmLCAwLCBTTk1QX01BWEJVRl9TTUFMTCk7CgogICAgcmV0dXJuIHJ2YWw7Cgp9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIGVuZCBzY19jaGVja19rZXllZF9oYXNoKCkgKi8KCiNlbHNlCl9TQ0FQSV9OT1RfQ09ORklHVVJFRAojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIE5FVFNOTVBfVVNFX0lOVEVSTkFMX01ENSAqLwovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi1vLSoqKioqKgogKiBzY19lbmNyeXB0CiAqCiAqIFBhcmFtZXRlcnM6CiAqCSBwcml2dHlwZQlUeXBlIG9mIHByaXZhY3kgY3J5cHRvZ3JhcGhpYyB0cmFuc2Zvcm0uCiAqCSprZXkJCUtleSBiaXRzIGZvciBjcnlwdGluZy4KICoJIGtleWxlbgkJTGVuZ3RoIG9mIGtleSAoYnVmZmVyKSBpbiBieXRlcy4KICoJKml2CQlJViBiaXRzIGZvciBjcnlwdGluZy4KICoJIGl2bGVuCQlMZW5ndGggb2YgaXYgKGJ1ZmZlcikgaW4gYnl0ZXMuCiAqCSpwbGFpbnRleHQJUGxhaW50ZXh0IHRvIGNyeXB0LgogKgkgcHRsZW4JCUxlbmd0aCBvZiBwbGFpbnRleHQuCiAqCSpjaXBoZXJ0ZXh0CUNpcGhlcnRleHQgdG8gY3J5cHQuCiAqCSpjdGxlbgkJTGVuZ3RoIG9mIGNpcGhlcnRleHQuCiAqICAgICAgCiAqIFJldHVybnM6CiAqCVNOTVBFUlJfU1VDQ0VTUwkJCVN1Y2Nlc3MuCiAqCVNOTVBFUlJfU0NfTk9UX0NPTkZJR1VSRUQJRW5jcnlwdGlvbiBpcyBub3Qgc3VwcG9ydGVkLgogKglTTk1QRVJSX1NDX0dFTkVSQUxfRkFJTFVSRQlBbnkgb3RoZXIgZXJyb3IKICoKICoKICogRW5jcnlwdCBwbGFpbnRleHQgaW50byBjaXBoZXJ0ZXh0IHVzaW5nIGtleSBhbmQgaXYuCiAqCiAqIGN0bGVuIGNvbnRhaW5zIGFjdHVhbCBudW1iZXIgb2YgY3J5cHRlZCBieXRlcyBpbiBjaXBoZXJ0ZXh0IHVwb24KICogc3VjY2Vzc2Z1bCByZXR1cm4uCiAqLwppbnQKc2NfZW5jcnlwdChjb25zdCBvaWQgKiBwcml2dHlwZSwgc2l6ZV90IHByaXZ0eXBlbGVuLAogICAgICAgICAgIHVfY2hhciAqIGtleSwgdV9pbnQga2V5bGVuLAogICAgICAgICAgIHVfY2hhciAqIGl2LCB1X2ludCBpdmxlbiwKICAgICAgICAgICB1X2NoYXIgKiBwbGFpbnRleHQsIHVfaW50IHB0bGVuLAogICAgICAgICAgIHVfY2hhciAqIGNpcGhlcnRleHQsIHNpemVfdCAqIGN0bGVuKQojaWYgZGVmaW5lZChORVRTTk1QX1VTRV9PUEVOU1NMKQp7CiAgICBpbnQgICAgICAgICAgICAgcnZhbCA9IFNOTVBFUlJfU1VDQ0VTUzsKICAgIHVfaW50ICAgICAgICAgICBwcm9wZXJsZW5ndGggPSAwLCBwcm9wZXJsZW5ndGhfaXYgPSAwOwogICAgdV9jaGFyICAgICAgICAgIHBhZF9ibG9ja1sxMjhdOyAgICAgIC8qIGJpZ2dlciB0aGFuIGFueXRoaW5nIEkgbmVlZCAqLwogICAgdV9jaGFyICAgICAgICAgIG15X2l2WzEyOF07ICAvKiBkaXR0byAqLwogICAgaW50ICAgICAgICAgICAgIHBhZCwgcGxhc3QsIHBhZF9zaXplID0gMDsKICAgIGludCAgICAgICAgICAgICBoYXZlX3RyYW5zOwojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9ERVMKI2lmZGVmIE9MRF9ERVMKICAgIERFU19rZXlfc2NoZWR1bGUga2V5X3NjaDsKI2Vsc2UKICAgIERFU19rZXlfc2NoZWR1bGUga2V5X3NjaGVkX3N0b3JlOwogICAgREVTX2tleV9zY2hlZHVsZSAqa2V5X3NjaCA9ICZrZXlfc2NoZWRfc3RvcmU7CiNlbmRpZgogICAgREVTX2NibG9jayAgICAgICBrZXlfc3RydWN0OwojZW5kaWYKI2lmZGVmIEhBVkVfQUVTCiAgICBBRVNfS0VZIGFlc19rZXk7CiAgICBpbnQgbmV3X2l2bGVuID0gMDsKI2VuZGlmCgogICAgREVCVUdUUkFDRTsKCiAgICAvKgogICAgICogU2FuaXR5IGNoZWNrLgogICAgICovCiNpZgkhZGVmaW5lZChORVRTTk1QX0VOQUJMRV9TQ0FQSV9BVVRIUFJJVikKICAgIHNubXBfbG9nKExPR19FUlIsICJFbmNyeXB0aW9uIHN1cHBvcnQgbm90IGVuYWJsZWQuXG4iKTsKICAgIHJldHVybiBTTk1QRVJSX1NDX05PVF9DT05GSUdVUkVEOwojZW5kaWYKCiAgICBpZiAoIXByaXZ0eXBlIHx8ICFrZXkgfHwgIWl2IHx8ICFwbGFpbnRleHQgfHwgIWNpcGhlcnRleHQgfHwgIWN0bGVuCiAgICAgICAgfHwgKGtleWxlbiA8PSAwKSB8fCAoaXZsZW4gPD0gMCkgfHwgKHB0bGVuIDw9IDApIHx8ICgqY3RsZW4gPD0gMCkKICAgICAgICB8fCAocHJpdnR5cGVsZW4gIT0gVVNNX0xFTkdUSF9PSURfVFJBTlNGT1JNKSkgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2VuY3J5cHRfcXVpdCk7CiAgICB9IGVsc2UgaWYgKHB0bGVuID4gKmN0bGVuKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZW5jcnlwdF9xdWl0KTsKICAgIH0KI2lmZGVmIE5FVFNOTVBfRU5BQkxFX1RFU1RJTkdfQ09ERQogICAgewogICAgICAgIHNpemVfdCAgICAgICAgICBidWZfbGVuID0gMTI4LCBvdXRfbGVuID0gMDsKICAgICAgICB1X2NoYXIgICAgICAgICAqYnVmID0gKHVfY2hhciAqKSBtYWxsb2MoYnVmX2xlbik7CgogICAgICAgIGlmIChidWYgIT0gTlVMTCkgewogICAgICAgICAgICBpZiAoc3ByaW50X3JlYWxsb2NfaGV4c3RyaW5nKCZidWYsICZidWZfbGVuLCAmb3V0X2xlbiwgMSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpdiwgaXZsZW4pKSB7CiAgICAgICAgICAgICAgICBERUJVR01TR1RMKCgic2NhcGkiLCAiZW5jcnlwdDogSVY6ICVzLyIsIGJ1ZikpOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwgImVuY3J5cHQ6IElWOiAlcyBbVFJVTkNBVEVEXS8iLCBidWYpKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBvdXRfbGVuID0gMDsKICAgICAgICAgICAgaWYgKHNwcmludF9yZWFsbG9jX2hleHN0cmluZygmYnVmLCAmYnVmX2xlbiwgJm91dF9sZW4sIDEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAga2V5LCBrZXlsZW4pKSB7CiAgICAgICAgICAgICAgICBERUJVR01TRygoInNjYXBpIiwgIiVzXG4iLCBidWYpKTsKICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIERFQlVHTVNHKCgic2NhcGkiLCAiJXMgW1RSVU5DQVRFRF1cbiIsIGJ1ZikpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIG91dF9sZW4gPSAwOwogICAgICAgICAgICBpZiAoc3ByaW50X3JlYWxsb2NfaGV4c3RyaW5nKCZidWYsICZidWZfbGVuLCAmb3V0X2xlbiwgMSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwbGFpbnRleHQsIDE2KSkgewogICAgICAgICAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwgImVuY3J5cHQ6IHN0cmluZzogJXNcbiIsIGJ1ZikpOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwgImVuY3J5cHQ6IHN0cmluZzogJXMgW1RSVU5DQVRFRF1cbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBidWYpKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBmcmVlKGJ1Zik7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwKICAgICAgICAgICAgICAgICAgICAgICAgImVuY3J5cHQ6IG1hbGxvYyBmYWlsIGZvciBkZWJ1ZyBvdXRwdXRcbiIpKTsKICAgICAgICB9CiAgICB9CiNlbmRpZiAgICAgICAgICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9FTkFCTEVfVEVTVElOR19DT0RFICovCgoKICAgIC8qCiAgICAgKiBEZXRlcm1pbmUgcHJpdmFjeSB0cmFuc2Zvcm0uCiAgICAgKi8KICAgIGhhdmVfdHJhbnMgPSAwOwojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9ERVMKICAgIGlmIChJU1RSQU5TRk9STShwcml2dHlwZSwgREVTUHJpdikpIHsKICAgICAgICBwcm9wZXJsZW5ndGggPSBCWVRFU0laRShTTk1QX1RSQU5TX1BSSVZMRU5fMURFUyk7CiAgICAgICAgcHJvcGVybGVuZ3RoX2l2ID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOXzFERVNfSVYpOwogICAgICAgIHBhZF9zaXplID0gcHJvcGVybGVuZ3RoOwogICAgICAgIGhhdmVfdHJhbnMgPSAxOwogICAgfQojZW5kaWYKI2lmZGVmIEhBVkVfQUVTCiAgICBpZiAoSVNUUkFOU0ZPUk0ocHJpdnR5cGUsIEFFU1ByaXYpKSB7CiAgICAgICAgcHJvcGVybGVuZ3RoID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOX0FFUyk7CiAgICAgICAgcHJvcGVybGVuZ3RoX2l2ID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOX0FFU19JVik7CiAgICAgICAgaGF2ZV90cmFucyA9IDE7CiAgICB9CiNlbmRpZgogICAgaWYgKCFoYXZlX3RyYW5zKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZW5jcnlwdF9xdWl0KTsKICAgIH0KCiAgICBpZiAoKGtleWxlbiA8IHByb3Blcmxlbmd0aCkgfHwgKGl2bGVuIDwgcHJvcGVybGVuZ3RoX2l2KSkgewogICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2VuY3J5cHRfcXVpdCk7CiAgICB9CgogICAgbWVtc2V0KG15X2l2LCAwLCBzaXplb2YobXlfaXYpKTsKCiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX0RFUwogICAgaWYgKElTVFJBTlNGT1JNKHByaXZ0eXBlLCBERVNQcml2KSkgewoKICAgICAgICAvKgogICAgICAgICAqIG5vdyBjYWxjdWxhdGUgdGhlIHBhZGRpbmcgbmVlZGVkIAogICAgICAgICAqLwogICAgICAgIHBhZCA9IHBhZF9zaXplIC0gKHB0bGVuICUgcGFkX3NpemUpOwogICAgICAgIHBsYXN0ID0gKGludCkgcHRsZW4gLSAocGFkX3NpemUgLSBwYWQpOwogICAgICAgIGlmIChwYWQgPT0gcGFkX3NpemUpCiAgICAgICAgICAgIHBhZCA9IDA7CiAgICAgICAgaWYgKHB0bGVuICsgcGFkID4gKmN0bGVuKSB7CiAgICAgICAgICAgIFFVSVRGVU4oU05NUEVSUl9HRU5FUlIsIHNjX2VuY3J5cHRfcXVpdCk7ICAgIC8qIG5vdCBlbm91Z2ggc3BhY2UgKi8KICAgICAgICB9CiAgICAgICAgaWYgKHBhZCA+IDApIHsgICAgICAgICAgICAgIC8qIGNvcHkgZGF0YSBpbnRvIHBhZCBibG9jayBpZiBuZWVkZWQgKi8KICAgICAgICAgICAgbWVtY3B5KHBhZF9ibG9jaywgcGxhaW50ZXh0ICsgcGxhc3QsIHBhZF9zaXplIC0gcGFkKTsKICAgICAgICAgICAgbWVtc2V0KCZwYWRfYmxvY2tbcGFkX3NpemUgLSBwYWRdLCBwYWQsIHBhZCk7ICAgLyogZmlsbGluZyBpbiBwYWRibG9jayAqLwogICAgICAgIH0KCiAgICAgICAgbWVtY3B5KGtleV9zdHJ1Y3QsIGtleSwgc2l6ZW9mKGtleV9zdHJ1Y3QpKTsKICAgICAgICAodm9pZCkgREVTX2tleV9zY2hlZCgma2V5X3N0cnVjdCwga2V5X3NjaCk7CgogICAgICAgIG1lbWNweShteV9pdiwgaXYsIGl2bGVuKTsKICAgICAgICAvKgogICAgICAgICAqIGVuY3J5cHQgdGhlIGRhdGEgCiAgICAgICAgICovCiAgICAgICAgREVTX25jYmNfZW5jcnlwdChwbGFpbnRleHQsIGNpcGhlcnRleHQsIHBsYXN0LCBrZXlfc2NoLAogICAgICAgICAgICAgICAgICAgICAgICAgKERFU19jYmxvY2sgKikgbXlfaXYsIERFU19FTkNSWVBUKTsKICAgICAgICBpZiAocGFkID4gMCkgewogICAgICAgICAgICAvKgogICAgICAgICAgICAgKiB0aGVuIGVuY3J5cHQgdGhlIHBhZCBibG9jayAKICAgICAgICAgICAgICovCiAgICAgICAgICAgIERFU19uY2JjX2VuY3J5cHQocGFkX2Jsb2NrLCBjaXBoZXJ0ZXh0ICsgcGxhc3QsIHBhZF9zaXplLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGtleV9zY2gsIChERVNfY2Jsb2NrICopIG15X2l2LCBERVNfRU5DUllQVCk7CiAgICAgICAgICAgICpjdGxlbiA9IHBsYXN0ICsgcGFkX3NpemU7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgKmN0bGVuID0gcGxhc3Q7CiAgICAgICAgfQogICAgfQojZW5kaWYKI2lmZGVmIEhBVkVfQUVTCiAgICBpZiAoSVNUUkFOU0ZPUk0ocHJpdnR5cGUsIEFFU1ByaXYpKSB7CiAgICAgICAgKHZvaWQpIEFFU19zZXRfZW5jcnlwdF9rZXkoa2V5LCBwcm9wZXJsZW5ndGgqOCwgJmFlc19rZXkpOwoKICAgICAgICBtZW1jcHkobXlfaXYsIGl2LCBpdmxlbik7CiAgICAgICAgLyoKICAgICAgICAgKiBlbmNyeXB0IHRoZSBkYXRhIAogICAgICAgICAqLwogICAgICAgIEFFU19jZmIxMjhfZW5jcnlwdChwbGFpbnRleHQsIGNpcGhlcnRleHQsIHB0bGVuLAogICAgICAgICAgICAgICAgICAgICAgICAgICAmYWVzX2tleSwgbXlfaXYsICZuZXdfaXZsZW4sIEFFU19FTkNSWVBUKTsKICAgICAgICAqY3RsZW4gPSBwdGxlbjsKICAgIH0KI2VuZGlmCiAgc2NfZW5jcnlwdF9xdWl0OgogICAgLyoKICAgICAqIGNsZWFyIG1lbW9yeSBqdXN0IGluIGNhc2UgCiAgICAgKi8KICAgIG1lbXNldChteV9pdiwgMCwgc2l6ZW9mKG15X2l2KSk7CiAgICBtZW1zZXQocGFkX2Jsb2NrLCAwLCBzaXplb2YocGFkX2Jsb2NrKSk7CiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX0RFUwogICAgbWVtc2V0KGtleV9zdHJ1Y3QsIDAsIHNpemVvZihrZXlfc3RydWN0KSk7CiNpZmRlZiBPTERfREVTCiAgICBtZW1zZXQoJmtleV9zY2gsIDAsIHNpemVvZihrZXlfc2NoKSk7CiNlbHNlCiAgICBtZW1zZXQoJmtleV9zY2hlZF9zdG9yZSwgMCwgc2l6ZW9mKGtleV9zY2hlZF9zdG9yZSkpOwojZW5kaWYKI2VuZGlmCiNpZmRlZiBIQVZFX0FFUwogICAgbWVtc2V0KCZhZXNfa2V5LDAsc2l6ZW9mKGFlc19rZXkpKTsKI2VuZGlmCiAgICByZXR1cm4gcnZhbDsKCn0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogZW5kIHNjX2VuY3J5cHQoKSAqLwojZWxpZiBkZWZpbmVkKE5FVFNOTVBfVVNFX1BLQ1MxMSkKewogICAgaW50ICAgICAgICAgICAgIHJ2YWwgPSBTTk1QRVJSX1NVQ0NFU1M7CiAgICB1X2ludCAgICAgICAgICAgcHJvcGVybGVuZ3RoLCBwcm9wZXJsZW5ndGhfaXY7CiAgICB1X2NoYXIJICAgIHBrY3NfZGVzX2tleVs4XTsKCiAgICBERUJVR1RSQUNFOwoKICAgIC8qCiAgICAgKiBTYW5pdHkgY2hlY2suCiAgICAgKi8KI2lmCSFkZWZpbmVkKE5FVFNOTVBfRU5BQkxFX1NDQVBJX0FVVEhQUklWKQogICAgc25tcF9sb2coTE9HX0VSUiwgIkVuY3J5cHRpb24gc3VwcG9ydCBub3QgZW5hYmxlZC5cbiIpOwogICAgcmV0dXJuIFNOTVBFUlJfU0NfTk9UX0NPTkZJR1VSRUQ7CiNlbmRpZgoKICAgIGlmICghcHJpdnR5cGUgfHwgIWtleSB8fCAhaXYgfHwgIXBsYWludGV4dCB8fCAhY2lwaGVydGV4dCB8fCAhY3RsZW4KICAgICAgICB8fCAoa2V5bGVuIDw9IDApIHx8IChpdmxlbiA8PSAwKSB8fCAocHRsZW4gPD0gMCkgfHwgKCpjdGxlbiA8PSAwKQogICAgICAgIHx8IChwcml2dHlwZWxlbiAhPSBVU01fTEVOR1RIX09JRF9UUkFOU0ZPUk0pKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZW5jcnlwdF9xdWl0KTsKICAgIH0gZWxzZSBpZiAocHRsZW4gPiAqY3RsZW4pIHsKICAgICAgICBRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19lbmNyeXB0X3F1aXQpOwogICAgfQoKICAgIC8qCiAgICAgKiBEZXRlcm1pbmUgcHJpdmFjeSB0cmFuc2Zvcm0uCiAgICAgKi8KICAgIGlmIChJU1RSQU5TRk9STShwcml2dHlwZSwgREVTUHJpdikpIHsKICAgICAgICBwcm9wZXJsZW5ndGggPSBCWVRFU0laRShTTk1QX1RSQU5TX1BSSVZMRU5fMURFUyk7CiAgICAgICAgcHJvcGVybGVuZ3RoX2l2ID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOXzFERVNfSVYpOwogICAgfSBlbHNlIHsKICAgICAgICBRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19lbmNyeXB0X3F1aXQpOwogICAgfQoKICAgIGlmICgoa2V5bGVuIDwgcHJvcGVybGVuZ3RoKSB8fCAoaXZsZW4gPCBwcm9wZXJsZW5ndGhfaXYpKSB7CglRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19lbmNyeXB0X3F1aXQpOwogICAgfQoKICAgIGlmIChJU1RSQU5TRk9STShwcml2dHlwZSwgREVTUHJpdikpIHsKCW1lbXNldChwa2NzX2Rlc19rZXksIDAsIHNpemVvZihwa2NzX2Rlc19rZXkpKTsKCW1lbWNweShwa2NzX2Rlc19rZXksIGtleSwgc2l6ZW9mKHBrY3NfZGVzX2tleSkpOwoJcnZhbCA9IHBrY3NfZW5jcnB5dChDS01fREVTX0NCQywgcGtjc19kZXNfa2V5LAoJCXNpemVvZihwa2NzX2Rlc19rZXkpLCBpdiwgaXZsZW4sIHBsYWludGV4dCwgcHRsZW4sCgkJY2lwaGVydGV4dCwgY3RsZW4pOwogICAgfQoKICBzY19lbmNyeXB0X3F1aXQ6CiAgICByZXR1cm4gcnZhbDsKfQojZWxzZQp7CiMJaWYgTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1CiAgICB7CiAgICAgICAgc25tcF9sb2coTE9HX0VSUiwgIkVuY3J5cHRpb24gc3VwcG9ydCBub3QgZW5hYmxlZC5cbiIpOwogICAgICAgIERFQlVHTVNHVEwoKCJzY2FwaSIsICJFbmNyeXB0IGZ1bmN0aW9uIG5vdCBkZWZpbmVkLlxuIikpOwogICAgICAgIHJldHVybiBTTk1QRVJSX1NDX0dFTkVSQUxfRkFJTFVSRTsKICAgIH0KCiMJZWxzZQogICAgX1NDQVBJX05PVF9DT05GSUdVUkVECiMJZW5kaWYgICAgICAgICAgICAgICAgICAgLyogTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1ICovCn0KI2VuZGlmICAgICAgICAgICAgICAgICAgICAgICAgICAvKiAqLwoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi1vLSoqKioqKgogKiBzY19kZWNyeXB0CiAqCiAqIFBhcmFtZXRlcnM6CiAqCSBwcml2dHlwZQogKgkqa2V5CiAqCSBrZXlsZW4KICoJKml2CiAqCSBpdmxlbgogKgkqY2lwaGVydGV4dAogKgkgY3RsZW4KICoJKnBsYWludGV4dAogKgkqcHRsZW4KICogICAgICAKICogUmV0dXJuczoKICoJU05NUEVSUl9TVUNDRVNTCQkJU3VjY2Vzcy4KICoJU05NUEVSUl9TQ19OT1RfQ09ORklHVVJFRAlFbmNyeXB0aW9uIGlzIG5vdCBzdXBwb3J0ZWQuCiAqICAgICAgU05NUEVSUl9TQ19HRU5FUkFMX0ZBSUxVUkUgICAgICBBbnkgb3RoZXIgZXJyb3IKICoKICoKICogRGVjcnlwdCBjaXBoZXJ0ZXh0IGludG8gcGxhaW50ZXh0IHVzaW5nIGtleSBhbmQgaXYuCiAqCiAqIHB0bGVuIGNvbnRhaW5zIGFjdHVhbCBudW1iZXIgb2YgcGxhaW50ZXh0IGJ5dGVzIGluIHBsYWludGV4dCB1cG9uCiAqIHN1Y2Nlc3NmdWwgcmV0dXJuLgogKi8KaW50CnNjX2RlY3J5cHQoY29uc3Qgb2lkICogcHJpdnR5cGUsIHNpemVfdCBwcml2dHlwZWxlbiwKICAgICAgICAgICB1X2NoYXIgKiBrZXksIHVfaW50IGtleWxlbiwKICAgICAgICAgICB1X2NoYXIgKiBpdiwgdV9pbnQgaXZsZW4sCiAgICAgICAgICAgdV9jaGFyICogY2lwaGVydGV4dCwgdV9pbnQgY3RsZW4sCiAgICAgICAgICAgdV9jaGFyICogcGxhaW50ZXh0LCBzaXplX3QgKiBwdGxlbikKI2lmZGVmIE5FVFNOTVBfVVNFX09QRU5TU0wKewoKICAgIGludCAgICAgICAgICAgICBydmFsID0gU05NUEVSUl9TVUNDRVNTOwogICAgdV9jaGFyICAgICAgICAgIG15X2l2WzEyOF07CiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX0RFUwojaWZkZWYgT0xEX0RFUwogICAgREVTX2tleV9zY2hlZHVsZSBrZXlfc2NoOwojZWxzZQogICAgREVTX2tleV9zY2hlZHVsZSBrZXlfc2NoZWRfc3RvcmU7CiAgICBERVNfa2V5X3NjaGVkdWxlICprZXlfc2NoID0gJmtleV9zY2hlZF9zdG9yZTsKI2VuZGlmCiAgICBERVNfY2Jsb2NrICAgICAga2V5X3N0cnVjdDsKI2VuZGlmCiAgICB1X2ludCAgICAgICAgICAgcHJvcGVybGVuZ3RoID0gMCwgcHJvcGVybGVuZ3RoX2l2ID0gMDsKICAgIGludCAgICAgICAgICAgICBoYXZlX3RyYW5zZm9ybTsKI2lmZGVmIEhBVkVfQUVTCiAgICBpbnQgbmV3X2l2bGVuID0gMDsKICAgIEFFU19LRVkgYWVzX2tleTsKI2VuZGlmCgogICAgREVCVUdUUkFDRTsKCiAgICBpZiAoIXByaXZ0eXBlIHx8ICFrZXkgfHwgIWl2IHx8ICFwbGFpbnRleHQgfHwgIWNpcGhlcnRleHQgfHwgIXB0bGVuCiAgICAgICAgfHwgKGN0bGVuIDw9IDApIHx8ICgqcHRsZW4gPD0gMCkgfHwgKCpwdGxlbiA8IGN0bGVuKQogICAgICAgIHx8IChwcml2dHlwZWxlbiAhPSBVU01fTEVOR1RIX09JRF9UUkFOU0ZPUk0pKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZGVjcnlwdF9xdWl0KTsKICAgIH0KI2lmZGVmIE5FVFNOTVBfRU5BQkxFX1RFU1RJTkdfQ09ERQogICAgewogICAgICAgIHNpemVfdCAgICAgICAgICBidWZfbGVuID0gMTI4LCBvdXRfbGVuID0gMDsKICAgICAgICB1X2NoYXIgICAgICAgICAqYnVmID0gKHVfY2hhciAqKSBtYWxsb2MoYnVmX2xlbik7CgogICAgICAgIGlmIChidWYgIT0gTlVMTCkgewogICAgICAgICAgICBpZiAoc3ByaW50X3JlYWxsb2NfaGV4c3RyaW5nKCZidWYsICZidWZfbGVuLCAmb3V0X2xlbiwgMSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpdiwgaXZsZW4pKSB7CiAgICAgICAgICAgICAgICBERUJVR01TR1RMKCgic2NhcGkiLCAiZGVjcnlwdDogSVY6ICVzLyIsIGJ1ZikpOwogICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwgImRlY3J5cHQ6IElWOiAlcyBbVFJVTkNBVEVEXS8iLCBidWYpKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBvdXRfbGVuID0gMDsKICAgICAgICAgICAgaWYgKHNwcmludF9yZWFsbG9jX2hleHN0cmluZygmYnVmLCAmYnVmX2xlbiwgJm91dF9sZW4sIDEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAga2V5LCBrZXlsZW4pKSB7CiAgICAgICAgICAgICAgICBERUJVR01TRygoInNjYXBpIiwgIiVzXG4iLCBidWYpKTsKICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgIERFQlVHTVNHKCgic2NhcGkiLCAiJXNcbiIsIGJ1ZikpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGZyZWUoYnVmKTsKICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBERUJVR01TR1RMKCgic2NhcGkiLAogICAgICAgICAgICAgICAgICAgICAgICAiZGVjcnlwdDogbWFsbG9jIGZhaWwgZm9yIGRlYnVnIG91dHB1dFxuIikpOwogICAgICAgIH0KICAgIH0KI2VuZGlmICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBORVRTTk1QX0VOQUJMRV9URVNUSU5HX0NPREUgKi8KCiAgICAvKgogICAgICogRGV0ZXJtaW5lIHByaXZhY3kgdHJhbnNmb3JtLgogICAgICovCiAgICBoYXZlX3RyYW5zZm9ybSA9IDA7CiNpZm5kZWYgTkVUU05NUF9ESVNBQkxFX0RFUwogICAgaWYgKElTVFJBTlNGT1JNKHByaXZ0eXBlLCBERVNQcml2KSkgewogICAgICAgIHByb3Blcmxlbmd0aCA9IEJZVEVTSVpFKFNOTVBfVFJBTlNfUFJJVkxFTl8xREVTKTsKICAgICAgICBwcm9wZXJsZW5ndGhfaXYgPSBCWVRFU0laRShTTk1QX1RSQU5TX1BSSVZMRU5fMURFU19JVik7CiAgICAgICAgaGF2ZV90cmFuc2Zvcm0gPSAxOwogICAgfQojZW5kaWYKI2lmZGVmIEhBVkVfQUVTCiAgICBpZiAoSVNUUkFOU0ZPUk0ocHJpdnR5cGUsIEFFU1ByaXYpKSB7CiAgICAgICAgcHJvcGVybGVuZ3RoID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOX0FFUyk7CiAgICAgICAgcHJvcGVybGVuZ3RoX2l2ID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOX0FFU19JVik7CiAgICAgICAgaGF2ZV90cmFuc2Zvcm0gPSAxOwogICAgfQojZW5kaWYKICAgIGlmICghaGF2ZV90cmFuc2Zvcm0pIHsKICAgICAgICBRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19kZWNyeXB0X3F1aXQpOwogICAgfQoKICAgIGlmICgoa2V5bGVuIDwgcHJvcGVybGVuZ3RoKSB8fCAoaXZsZW4gPCBwcm9wZXJsZW5ndGhfaXYpKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZGVjcnlwdF9xdWl0KTsKICAgIH0KCiAgICBtZW1zZXQobXlfaXYsIDAsIHNpemVvZihteV9pdikpOwojaWZuZGVmIE5FVFNOTVBfRElTQUJMRV9ERVMKICAgIGlmIChJU1RSQU5TRk9STShwcml2dHlwZSwgREVTUHJpdikpIHsKICAgICAgICBtZW1jcHkoa2V5X3N0cnVjdCwga2V5LCBzaXplb2Yoa2V5X3N0cnVjdCkpOwogICAgICAgICh2b2lkKSBERVNfa2V5X3NjaGVkKCZrZXlfc3RydWN0LCBrZXlfc2NoKTsKCiAgICAgICAgbWVtY3B5KG15X2l2LCBpdiwgaXZsZW4pOwogICAgICAgIERFU19jYmNfZW5jcnlwdChjaXBoZXJ0ZXh0LCBwbGFpbnRleHQsIGN0bGVuLCBrZXlfc2NoLAogICAgICAgICAgICAgICAgICAgICAgICAoREVTX2NibG9jayAqKSBteV9pdiwgREVTX0RFQ1JZUFQpOwogICAgICAgICpwdGxlbiA9IGN0bGVuOwogICAgfQojZW5kaWYKI2lmZGVmIEhBVkVfQUVTCiAgICBpZiAoSVNUUkFOU0ZPUk0ocHJpdnR5cGUsIEFFU1ByaXYpKSB7CiAgICAgICAgKHZvaWQpIEFFU19zZXRfZW5jcnlwdF9rZXkoa2V5LCBwcm9wZXJsZW5ndGgqOCwgJmFlc19rZXkpOwoKICAgICAgICBtZW1jcHkobXlfaXYsIGl2LCBpdmxlbik7CiAgICAgICAgLyoKICAgICAgICAgKiBlbmNyeXB0IHRoZSBkYXRhIAogICAgICAgICAqLwogICAgICAgIEFFU19jZmIxMjhfZW5jcnlwdChjaXBoZXJ0ZXh0LCBwbGFpbnRleHQsIGN0bGVuLAogICAgICAgICAgICAgICAgICAgICAgICAgICAmYWVzX2tleSwgbXlfaXYsICZuZXdfaXZsZW4sIEFFU19ERUNSWVBUKTsKICAgICAgICAqcHRsZW4gPSBjdGxlbjsKICAgIH0KI2VuZGlmCgogICAgLyoKICAgICAqIGV4aXQgY29uZCAKICAgICAqLwogIHNjX2RlY3J5cHRfcXVpdDoKI2lmbmRlZiBORVRTTk1QX0RJU0FCTEVfREVTCiNpZmRlZiBPTERfREVTCiAgICBtZW1zZXQoJmtleV9zY2gsIDAsIHNpemVvZihrZXlfc2NoKSk7CiNlbHNlCiAgICBtZW1zZXQoJmtleV9zY2hlZF9zdG9yZSwgMCwgc2l6ZW9mKGtleV9zY2hlZF9zdG9yZSkpOwojZW5kaWYKICAgIG1lbXNldChrZXlfc3RydWN0LCAwLCBzaXplb2Yoa2V5X3N0cnVjdCkpOwojZW5kaWYKICAgIG1lbXNldChteV9pdiwgMCwgc2l6ZW9mKG15X2l2KSk7CiAgICByZXR1cm4gcnZhbDsKfQkJCQkvKiBVU0UgT1BFTl9TU0wgKi8KI2VsaWYgTkVUU05NUF9VU0VfUEtDUzExICAgICAgICAgICAgICAgICAgLyogVVNFIFBLQ1MgKi8KewogICAgaW50ICAgICAgICAgICAgIHJ2YWwgPSBTTk1QRVJSX1NVQ0NFU1M7CiAgICB1X2ludCAgICAgICAgICAgcHJvcGVybGVuZ3RoLCBwcm9wZXJsZW5ndGhfaXY7CiAgICB1X2NoYXIJICAgIHBrY3NfZGVzX2tleVs4XTsKCiAgICBERUJVR1RSQUNFOwoKICAgIGlmICghcHJpdnR5cGUgfHwgIWtleSB8fCAhaXYgfHwgIXBsYWludGV4dCB8fCAhY2lwaGVydGV4dCB8fCAhcHRsZW4KICAgICAgICB8fCAoY3RsZW4gPD0gMCkgfHwgKCpwdGxlbiA8PSAwKSB8fCAoKnB0bGVuIDwgY3RsZW4pCiAgICAgICAgfHwgKHByaXZ0eXBlbGVuICE9IFVTTV9MRU5HVEhfT0lEX1RSQU5TRk9STSkpIHsKICAgICAgICBRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19kZWNyeXB0X3F1aXQpOwogICAgfQoKICAgIC8qCiAgICAgKiBEZXRlcm1pbmUgcHJpdmFjeSB0cmFuc2Zvcm0uCiAgICAgKi8KICAgIGlmIChJU1RSQU5TRk9STShwcml2dHlwZSwgREVTUHJpdikpIHsKICAgICAgICBwcm9wZXJsZW5ndGggPSBCWVRFU0laRShTTk1QX1RSQU5TX1BSSVZMRU5fMURFUyk7CiAgICAgICAgcHJvcGVybGVuZ3RoX2l2ID0gQllURVNJWkUoU05NUF9UUkFOU19QUklWTEVOXzFERVNfSVYpOwogICAgfSBlbHNlIHsKICAgICAgICBRVUlURlVOKFNOTVBFUlJfR0VORVJSLCBzY19kZWNyeXB0X3F1aXQpOwogICAgfQoKICAgIGlmICgoa2V5bGVuIDwgcHJvcGVybGVuZ3RoKSB8fCAoaXZsZW4gPCBwcm9wZXJsZW5ndGhfaXYpKSB7CiAgICAgICAgUVVJVEZVTihTTk1QRVJSX0dFTkVSUiwgc2NfZGVjcnlwdF9xdWl0KTsKICAgIH0KCiAgICBpZiAoSVNUUkFOU0ZPUk0ocHJpdnR5cGUsIERFU1ByaXYpKSB7CgltZW1zZXQocGtjc19kZXNfa2V5LCAwLCBzaXplb2YocGtjc19kZXNfa2V5KSk7CgltZW1jcHkocGtjc19kZXNfa2V5LCBrZXksIHNpemVvZihwa2NzX2Rlc19rZXkpKTsKCXJ2YWwgPSBwa2NzX2RlY3JweXQoQ0tNX0RFU19DQkMsIHBrY3NfZGVzX2tleSwgCgkJc2l6ZW9mKHBrY3NfZGVzX2tleSksIGl2LCBpdmxlbiwgY2lwaGVydGV4dCwKCQljdGxlbiwgcGxhaW50ZXh0LCBwdGxlbik7CiAgICAgICAgKnB0bGVuID0gY3RsZW47CiAgICB9CgogIHNjX2RlY3J5cHRfcXVpdDoKICAgIHJldHVybiBydmFsOwp9CQkJCS8qIFVTRSBQS0NTICovCiNlbHNlCnsKI2lmCSFkZWZpbmVkKE5FVFNOTVBfRU5BQkxFX1NDQVBJX0FVVEhQUklWKQogICAgc25tcF9sb2coTE9HX0VSUiwgIkVuY3J5cHRpb24gc3VwcG9ydCBub3QgZW5hYmxlZC5cbiIpOwogICAgcmV0dXJuIFNOTVBFUlJfU0NfTk9UX0NPTkZJR1VSRUQ7CiNlbHNlCiMJaWYgTkVUU05NUF9VU0VfSU5URVJOQUxfTUQ1CiAgICB7CiAgICAgICAgREVCVUdNU0dUTCgoInNjYXBpIiwgIkRlY3J5cHRpb24gZnVuY3Rpb24gbm90IGRlZmluZWQuXG4iKSk7CiAgICAgICAgcmV0dXJuIFNOTVBFUlJfU0NfR0VORVJBTF9GQUlMVVJFOwogICAgfQoKIwllbHNlCiAgICBfU0NBUElfTk9UX0NPTkZJR1VSRUQKIwllbmRpZiAgICAgICAgICAgICAgICAgICAvKiBORVRTTk1QX1VTRV9JTlRFUk5BTF9NRDUgKi8KI2VuZGlmICAgICAgICAgICAgICAgICAgICAgICAgICAvKiAgKi8KfQojZW5kaWYgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIE5FVFNOTVBfVVNFX09QRU5TU0wgKi8K