ZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2FyY2gvYXJtL21hY2gtengyOTc1MjB2My9yZXNldC5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvYXJjaC9hcm0vbWFjaC16eDI5NzUyMHYzL3Jlc2V0LmMKb2xkIG1vZGUgMTAwNjQ0Cm5ldyBtb2RlIDEwMDc1NQppbmRleCAwYTUwYTIxLi43NzdkZmJmCi0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2FyY2gvYXJtL21hY2gtengyOTc1MjB2My9yZXNldC5jCisrKyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2FyY2gvYXJtL21hY2gtengyOTc1MjB2My9yZXNldC5jCkBAIC0yMyw3ICsyMyw4IEBACiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvc3lzY29yZV9vcHMuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+Ci0KKyNpbmNsdWRlIDxsaW51eC9taXNjZGV2aWNlLmg+CS8qIEZvciBoYW5kbGluZyBtaXNjIGRldmljZXMgKi8KKyNpbmNsdWRlIDxsaW51eC9mcy5oPgkJLyogRm9yIGZpbGUgb3BlcmF0aW9ucyAqLwogI2luY2x1ZGUgPG1hY2gvYm9hcmQuaD4KICNpbmNsdWRlIDxtYWNoL2lvbWFwLmg+CiAjaW5jbHVkZSA8bWFjaC9zcGlubG9jay5oPgpAQCAtMzEsNiArMzIsMTMgQEAKICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogCiAKKyNkZWZpbmUgWlhfUkVTRVRfREVWICAgICIvZGV2L3p4X3Jlc2V0IgorCisjZGVmaW5lIFpYX1JFU0VUX0lPQ19NQUdJQyAgICAgJ1cnCisvKmlvY3RsIGNtZCB1c2QgYnkgZGV2aWNlKi8KKyNkZWZpbmUgWlhfUkVTRVRfRkFTVF9SRUJPT1QgICAgICAgICAJX0lPVyhaWF9SRVNFVF9JT0NfTUFHSUMsIDEsIGNoYXIgKikKKworCiAjZGVmaW5lCUdMT0JBTF9SRVNFVF9SRUcJCShaWF9UT1BfQ1JNX0JBU0UpCiAKICNkZWZpbmUJVVNFUl9SU1RfVU5ERUZJTkUJIAkwCkBAIC0xNzIsMyArMTgwLDYzIEBACiBFWFBPUlRfU1lNQk9MKHp4MjlfcmVzdGFydCk7CiAKIAorIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRnVuY3Rpb246CisgKiBEZXNjcmlwdGlvbjogCisgKiBQYXJhbWV0ZXJzOiAKKyAqIFJldHVybnM6IAorICogT3RoZXJzOgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisgc3RhdGljIGludCB6eF9yZXNldF9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiAwOyAKK30KKworc3RhdGljIGludCB6eF9yZXNldF9jbG9zZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gMDsKK30KK3N0YXRpYyBsb25nIHp4X3Jlc2V0X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sJCisJc3dpdGNoKGNtZCkKKwl7CisJCWNhc2UgWlhfUkVTRVRfRkFTVF9SRUJPT1Q6CisJCQl6eDI5X3Jlc3RhcnQJKE5VTEwsICJhdCBzZXQgZmFzdCByZWJvb3QhXG5cbiIpOworCQkJYnJlYWs7CisJCQkKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOwkJCisJfQorCisJcmV0dXJuIDA7Cit9CisKKworIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHp4X3Jlc2V0X2ZvcHMgPSB7CisJLm93bmVyCQk9IFRISVNfTU9EVUxFLAorCS51bmxvY2tlZF9pb2N0bAk9IHp4X3Jlc2V0X2lvY3RsLAorCS5vcGVuCQk9IHp4X3Jlc2V0X29wZW4sCisJLnJlbGVhc2UJPSB6eF9yZXNldF9jbG9zZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgbWlzY2RldmljZSB6eF9yZXNldF9taXNjZGV2ID0geworCS5taW5vcgkJPSBNSVNDX0RZTkFNSUNfTUlOT1IsCisJLm5hbWUJCT0gInp4X3Jlc2V0IiwKKwkuZm9wcwkJPSAmenhfcmVzZXRfZm9wcywKK307CisKKyBzdGF0aWMgaW50IF9faW5pdCB6eF9yZXNldF9pbml0KHZvaWQpCisgeworIAlpbnQgcmV0PTA7CisgCXJldCA9IG1pc2NfcmVnaXN0ZXIoJnp4X3Jlc2V0X21pc2NkZXYpOworCWlmIChyZXQgIT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIicmVzZXQgY2Fubm90IHJlZ2lzdGVyIG1pc2NkZXYgb24oZXJyPSVkKVxuIiwgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisJcmV0dXJuIDA7CisgfQorCitsYXRlX2luaXRjYWxsX3N5bmMoenhfcmVzZXRfaW5pdCk7CisKKyAKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2FyY2gvYXJtL21tL2ZhdWx0LmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9hcmNoL2FybS9tbS9mYXVsdC5jCmluZGV4IGNjZWQ5NjYuLjkyYjkxNjMgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2FyY2gvYXJtL21tL2ZhdWx0LmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvYXJjaC9hcm0vbW0vZmF1bHQuYwpAQCAtMjEsMTIgKzIxLDEyIEBACiAjaWZkZWYgQ09ORklHX01NVQogI2lmZGVmIENPTkZJR19LUFJPQkVTCiBzdGF0aWMgaW5saW5lIGludCBub3RpZnlfcGFnZV9mYXVsdChzdHJ1Y3QgcHRfcmVncypyZWdzLHVuc2lnbmVkIGludCBmc3Ipe2ludCAKLXJldD0oMHg5M2YrNDk3OC0weDFjYjEpO2lmKCF1c2VyX21vZGUocmVncykpe3ByZWVtcHRfZGlzYWJsZSgpO2lmKGtwcm9iZV9ydW5uaW5nCi0oKSYma3Byb2JlX2ZhdWx0X2hhbmRsZXIocmVncyxmc3IpKXJldD0oMHg3ZDErNjg0My0weDIyOGIpO3ByZWVtcHRfZW5hYmxlKCk7fQorcmV0PSgweDE4MCs0MzkxLTB4MTJhNyk7aWYoIXVzZXJfbW9kZShyZWdzKSl7cHJlZW1wdF9kaXNhYmxlKCk7aWYoa3Byb2JlX3J1bm5pbmcKKygpJiZrcHJvYmVfZmF1bHRfaGFuZGxlcihyZWdzLGZzcikpcmV0PSgweDFkYTcrMTcyMS0weDI0NWYpO3ByZWVtcHRfZW5hYmxlKCk7fQogcmV0dXJuIHJldDt9CiAjZWxzZQogc3RhdGljIGlubGluZSBpbnQgbm90aWZ5X3BhZ2VfZmF1bHQoc3RydWN0IHB0X3JlZ3MqcmVncyx1bnNpZ25lZCBpbnQgZnNyKXtyZXR1cm4KLSgweDE5ZmQrMTc2MS0weDIwZGUpO30KKygweGYrMzA1My0weGJmYyk7fQogI2VuZGlmCiB2b2lkIHNob3dfcHRlKHN0cnVjdCBtbV9zdHJ1Y3QqbW0sdW5zaWduZWQgbG9uZyBhZGRyKXtwZ2RfdCpwZ2Q7aWYoIW1tKW1tPSYKIGluaXRfbW07cHJpbnRrKEtFUk5fQUxFUlQiXHg3MFx4NjdceDY0XHgyMFx4M2RceDIwXHgyNVx4NzAiICJcbiIsbW0tPnBnZCk7cGdkPQpAQCAtMzQsMTAgKzM0LDEwIEBACiAiXHg1Ylx4MjVceDMwXHgzOFx4NmNceDc4XHg1ZFx4MjBceDJhXHg3MFx4NjdceDY0XHgzZFx4MjVceDMwXHgzOFx4NmNceDZjXHg3OCIsCiBhZGRyLChsb25nIGxvbmcpcGdkX3ZhbCgqcGdkKSk7ZG97cHVkX3QqcHVkO3BtZF90KnBtZDtwdGVfdCpwdGU7aWYocGdkX25vbmUoKnBnZAogKSlicmVhaztpZihwZ2RfYmFkKCpwZ2QpKXtwcmludGsoIlx4MjhceDYyXHg2MVx4NjRceDI5Iik7YnJlYWs7fXB1ZD1wdWRfb2Zmc2V0KAotcGdkLGFkZHIpO2lmKFBUUlNfUEVSX1BVRCE9KDB4ODJhKzY5NDgtMHgyMzRkKSlwcmludGsoCitwZ2QsYWRkcik7aWYoUFRSU19QRVJfUFVEIT0oMHhiYmErNTIzNC0weDIwMmIpKXByaW50aygKICJceDJjXHgyMFx4MmFceDcwXHg3NVx4NjRceDNkXHgyNVx4MzBceDM4XHg2Y1x4NmNceDc4IiwobG9uZyBsb25nKXB1ZF92YWwoKnB1ZCkpCiA7aWYocHVkX25vbmUoKnB1ZCkpYnJlYWs7aWYocHVkX2JhZCgqcHVkKSl7cHJpbnRrKCJceDI4XHg2Mlx4NjFceDY0XHgyOSIpO2JyZWFrOwotfXBtZD1wbWRfb2Zmc2V0KHB1ZCxhZGRyKTtpZihQVFJTX1BFUl9QTUQhPSgweGU1YysyNDY3LTB4MTdmZSkpcHJpbnRrKAorfXBtZD1wbWRfb2Zmc2V0KHB1ZCxhZGRyKTtpZihQVFJTX1BFUl9QTUQhPSgweGI2NysxNTQyLTB4MTE2YykpcHJpbnRrKAogIlx4MmNceDIwXHgyYVx4NzBceDZkXHg2NFx4M2RceDI1XHgzMFx4MzhceDZjXHg2Y1x4NzgiLChsb25nIGxvbmcpcG1kX3ZhbCgqcG1kKSkKIDtpZihwbWRfbm9uZSgqcG1kKSlicmVhaztpZihwbWRfYmFkKCpwbWQpKXtwcmludGsoIlx4MjhceDYyXHg2MVx4NjRceDI5Iik7YnJlYWs7CiB9aWYoUGFnZUhpZ2hNZW0ocGZuX3RvX3BhZ2UocG1kX3ZhbCgqcG1kKT4+UEFHRV9TSElGVCkpKWJyZWFrO3B0ZT1wdGVfb2Zmc2V0X21hcApAQCAtNDcsMTggKzQ3LDE4IEBACiBwcmludGsoIlx4MmNceDIwXHgyYVx4NzBceDcwXHg3NFx4NjVceDNkXHgyNVx4MzBceDM4XHg2Y1x4NmNceDc4IiwobG9uZyBsb25nKQogcHRlX3ZhbChwdGVbUFRFX0hXVEFCTEVfUFRSU10pKTsKICNlbmRpZgotcHRlX3VubWFwKHB0ZSk7fXdoaWxlKCgweDE1YTUrNjMxLTB4MTgxYykpO3ByaW50aygiXG4iKTt9CitwdGVfdW5tYXAocHRlKTt9d2hpbGUoKDB4MTBmOCs3NTktMHgxM2VmKSk7cHJpbnRrKCJcbiIpO30KICNlbHNlCQkJCQkKIHZvaWQgc2hvd19wdGUoc3RydWN0IG1tX3N0cnVjdCptbSx1bnNpZ25lZCBsb25nIGFkZHIpe30KICNlbmRpZgkJCQkJCiBzdGF0aWMgdm9pZCBfX2RvX2tlcm5lbF9mYXVsdChzdHJ1Y3QgbW1fc3RydWN0Km1tLHVuc2lnbmVkIGxvbmcgYWRkcix1bnNpZ25lZCAKIGludCBmc3Isc3RydWN0IHB0X3JlZ3MqcmVncyl7aWYoZml4dXBfZXhjZXB0aW9uKHJlZ3MpKXJldHVybjtidXN0X3NwaW5sb2NrcygKLSgweDRjMys4NTQ5LTB4MjYyNykpO3ByaW50ayhLRVJOX0FMRVJUCisoMHgxNDhmKzMwNDItMHgyMDcwKSk7cHJpbnRrKEtFUk5fQUxFUlQKICJceDU1XHg2ZVx4NjFceDYyXHg2Y1x4NjVceDIwXHg3NFx4NmZceDIwXHg2OFx4NjFceDZlXHg2NFx4NmNceDY1XHgyMFx4NmJceDY1XHg3Mlx4NmVceDY1XHg2Y1x4MjBceDI1XHg3M1x4MjBceDYxXHg3NFx4MjBceDc2XHg2OVx4NzJceDc0XHg3NVx4NjFceDZjXHgyMFx4NjFceDY0XHg2NFx4NzJceDY1XHg3M1x4NzNceDIwXHgyNVx4MzBceDM4XHg2Y1x4NzgiICJcbiIKICwoYWRkcjxQQUdFX1NJWkUpPwogIlx4NGVceDU1XHg0Y1x4NGNceDIwXHg3MFx4NmZceDY5XHg2ZVx4NzRceDY1XHg3Mlx4MjBceDY0XHg2NVx4NzJceDY1XHg2Nlx4NjVceDcyXHg2NVx4NmVceDYzXHg2NSIKIDoiXHg3MFx4NjFceDY3XHg2OVx4NmVceDY3XHgyMFx4NzJceDY1XHg3MVx4NzVceDY1XHg3M1x4NzQiLGFkZHIpO3Nob3dfcHRlKG1tLAotYWRkcik7ZGllKCJceDRmXHg2Zlx4NzBceDczIixyZWdzLGZzcik7YnVzdF9zcGlubG9ja3MoKDB4NDk3KzMxNDItMHgxMGRkKSk7CithZGRyKTtkaWUoIlx4NGZceDZmXHg3MFx4NzMiLHJlZ3MsZnNyKTtidXN0X3NwaW5sb2NrcygoMHgzNmYrMTQ3NS0weDkzMikpOwogZG9fZXhpdChTSUdLSUxMKTt9c3RhdGljIHZvaWQgX19kb191c2VyX2ZhdWx0KHN0cnVjdCB0YXNrX3N0cnVjdCp0c2ssdW5zaWduZWQgCiBsb25nIGFkZHIsdW5zaWduZWQgaW50IGZzcix1bnNpZ25lZCBpbnQgc2lnLGludCBjb2RlLHN0cnVjdCBwdF9yZWdzKnJlZ3Mpe3N0cnVjdAogIHNpZ2luZm8gc2k7CkBAIC02OSw3ICs2OSw3IEBACiAsdHNrLT5jb21tLHNpZyxhZGRyLGZzcik7c2hvd19wdGUodHNrLT5tbSxhZGRyKTtzaG93X3JlZ3MocmVncyk7fQogI2VuZGlmCiB0c2stPnRocmVhZC5hZGRyZXNzPWFkZHI7dHNrLT50aHJlYWQuZXJyb3JfY29kZT1mc3I7dHNrLT50aHJlYWQudHJhcF9ubz0KLSgweDM4ZCszNjk0LTB4MTFlZCk7c2kuc2lfc2lnbm89c2lnO3NpLnNpX2Vycm5vPSgweDE4MzIrMzIyNC0weDI0Y2EpO3NpLnNpX2NvZGU9CisoMHgxZTI3KzMwNS0weDFmNGEpO3NpLnNpX3NpZ25vPXNpZztzaS5zaV9lcnJubz0oMHgzOGYrNTU0MS0weDE5MzQpO3NpLnNpX2NvZGU9CiBjb2RlO3NpLnNpX2FkZHI9KHZvaWQgX191c2VyKilhZGRyO2ZvcmNlX3NpZ19pbmZvKHNpZywmc2ksdHNrKTt9dm9pZCBkb19iYWRfYXJlYQogKHVuc2lnbmVkIGxvbmcgYWRkcix1bnNpZ25lZCBpbnQgZnNyLHN0cnVjdCBwdF9yZWdzKnJlZ3Mpe3N0cnVjdCB0YXNrX3N0cnVjdCp0c2sKID1jdXJyZW50O3N0cnVjdCBtbV9zdHJ1Y3QqbW09dHNrLT5hY3RpdmVfbW07aWYodXNlcl9tb2RlKHJlZ3MpKV9fZG9fdXNlcl9mYXVsdCgKQEAgLTkxLDggKzkxLDggQEAKIHN0YXRpYyBpbnQgX19rcHJvYmVzIGRvX3BhZ2VfZmF1bHQodW5zaWduZWQgbG9uZyBhZGRyLHVuc2lnbmVkIGludCBmc3Isc3RydWN0IAogcHRfcmVncypyZWdzKXtzdHJ1Y3QgdGFza19zdHJ1Y3QqdHNrO3N0cnVjdCBtbV9zdHJ1Y3QqbW07aW50IGZhdWx0LHNpZyxjb2RlO2ludCAKIHdyaXRlPWZzciZGU1JfV1JJVEU7dW5zaWduZWQgaW50IGZsYWdzPUZBVUxUX0ZMQUdfQUxMT1dfUkVUUll8Ci1GQVVMVF9GTEFHX0tJTExBQkxFfCh3cml0ZT9GQVVMVF9GTEFHX1dSSVRFOigweGNmYys0OTI5LTB4MjAzZCkpO2lmKAotbm90aWZ5X3BhZ2VfZmF1bHQocmVncyxmc3IpKXJldHVybigweGU2Nys2MDczLTB4MjYyMCk7dHNrPWN1cnJlbnQ7bW09dHNrLT5tbTtpZigKK0ZBVUxUX0ZMQUdfS0lMTEFCTEV8KHdyaXRlP0ZBVUxUX0ZMQUdfV1JJVEU6KDB4YjE5KzE4MzAtMHgxMjNmKSk7aWYoCitub3RpZnlfcGFnZV9mYXVsdChyZWdzLGZzcikpcmV0dXJuKDB4NDY4KzcxNDEtMHgyMDRkKTt0c2s9Y3VycmVudDttbT10c2stPm1tO2lmKAogaW50ZXJydXB0c19lbmFibGVkKHJlZ3MpKWxvY2FsX2lycV9lbmFibGUoKTtpZighbW18fHBhZ2VmYXVsdF9kaXNhYmxlZCgpKWdvdG8gCiBub19jb250ZXh0O2lmKCFkb3duX3JlYWRfdHJ5bG9jaygmbW0tPm1tYXBfc2VtKSl7aWYoIXVzZXJfbW9kZShyZWdzKSYmIQogc2VhcmNoX2V4Y2VwdGlvbl90YWJsZXMocmVncy0+QVJNX3BjKSlnb3RvIG5vX2NvbnRleHQ7cmV0cnk6ZG93bl9yZWFkKCZtbS0+CkBAIC0xMDEsMjIgKzEwMSwyMiBAQAogaWYoIXVzZXJfbW9kZShyZWdzKSYmIXNlYXJjaF9leGNlcHRpb25fdGFibGVzKHJlZ3MtPkFSTV9wYykpZ290byBub19jb250ZXh0OwogI2VuZGlmCiB9ZmF1bHQ9X19kb19wYWdlX2ZhdWx0KG1tLGFkZHIsZnNyLGZsYWdzLHRzayk7aWYoKGZhdWx0JlZNX0ZBVUxUX1JFVFJZKSYmCi1mYXRhbF9zaWduYWxfcGVuZGluZyhjdXJyZW50KSlyZXR1cm4oMHgxMTA4KzE2NDEtMHgxNzcxKTtwZXJmX3N3X2V2ZW50KAotUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUUywoMHgxNTlkKzMzNDQtMHgyMmFjKSxyZWdzLGFkZHIpO2lmKCEoZmF1bHQmCitmYXRhbF9zaWduYWxfcGVuZGluZyhjdXJyZW50KSlyZXR1cm4oMHgxZGNjKzcxNi0weDIwOTgpO3BlcmZfc3dfZXZlbnQoCitQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTLCgweGQ1YisyMzU4LTB4MTY5MCkscmVncyxhZGRyKTtpZighKGZhdWx0JgogVk1fRkFVTFRfRVJST1IpJiZmbGFncyZGQVVMVF9GTEFHX0FMTE9XX1JFVFJZKXtpZihmYXVsdCZWTV9GQVVMVF9NQUpPUil7dHNrLT4KLW1hal9mbHQrKztwZXJmX3N3X2V2ZW50KFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUFKLCgweGMwYSs2MTEyLTB4MjNlOSkscmVncywKLWFkZHIpO31lbHNle3Rzay0+bWluX2ZsdCsrO3BlcmZfc3dfZXZlbnQoUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUU19NSU4sCi0oMHgxZWEwKzE5OTctMHgyNjZjKSxyZWdzLGFkZHIpO31pZihmYXVsdCZWTV9GQVVMVF9SRVRSWSl7ZmxhZ3MmPX4KK21hal9mbHQrKztwZXJmX3N3X2V2ZW50KFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUFKLCgweDYzMis2OS0weDY3NikscmVncyxhZGRyCispO31lbHNle3Rzay0+bWluX2ZsdCsrO3BlcmZfc3dfZXZlbnQoUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUU19NSU4sCisoMHgxMDcyKzE0MTQtMHgxNWY3KSxyZWdzLGFkZHIpO31pZihmYXVsdCZWTV9GQVVMVF9SRVRSWSl7ZmxhZ3MmPX4KIEZBVUxUX0ZMQUdfQUxMT1dfUkVUUlk7Z290byByZXRyeTt9fXVwX3JlYWQoJm1tLT5tbWFwX3NlbSk7aWYobGlrZWx5KCEoZmF1bHQmKAotVk1fRkFVTFRfRVJST1J8Vk1fRkFVTFRfQkFETUFQfFZNX0ZBVUxUX0JBREFDQ0VTUykpKSlyZXR1cm4oMHgzMjIrODc3LTB4NjhmKTtpZigKLWZhdWx0JlZNX0ZBVUxUX09PTSl7cGFnZWZhdWx0X291dF9vZl9tZW1vcnkoKTtyZXR1cm4oMHhjMGIrMzMzMi0weDE5MGYpO31pZighCitWTV9GQVVMVF9FUlJPUnxWTV9GQVVMVF9CQURNQVB8Vk1fRkFVTFRfQkFEQUNDRVNTKSkpKXJldHVybigweGVkNys5ODEtMHgxMmFjKTtpZgorKGZhdWx0JlZNX0ZBVUxUX09PTSl7cGFnZWZhdWx0X291dF9vZl9tZW1vcnkoKTtyZXR1cm4oMHg4ZjMrNjc4Mi0weDIzNzEpO31pZighCiB1c2VyX21vZGUocmVncykpZ290byBub19jb250ZXh0O2lmKGZhdWx0JlZNX0ZBVUxUX1NJR0JVUyl7c2lnPVNJR0JVUztjb2RlPQogQlVTX0FEUkVSUjt9ZWxzZXtzaWc9U0lHU0VHVjtjb2RlPWZhdWx0PT1WTV9GQVVMVF9CQURBQ0NFU1M/U0VHVl9BQ0NFUlI6Ci1TRUdWX01BUEVSUjt9X19kb191c2VyX2ZhdWx0KHRzayxhZGRyLGZzcixzaWcsY29kZSxyZWdzKTtyZXR1cm4oMHg4MjYrODgzLTB4Yjk5KQotO25vX2NvbnRleHQ6X19kb19rZXJuZWxfZmF1bHQobW0sYWRkcixmc3IscmVncyk7cmV0dXJuKDB4YjI1KzQ3OTYtMHgxZGUxKTt9CitTRUdWX01BUEVSUjt9X19kb191c2VyX2ZhdWx0KHRzayxhZGRyLGZzcixzaWcsY29kZSxyZWdzKTtyZXR1cm4oMHg4ZjkrNTAwLTB4YWVkKQorO25vX2NvbnRleHQ6X19kb19rZXJuZWxfZmF1bHQobW0sYWRkcixmc3IscmVncyk7cmV0dXJuKDB4MWFkNys4MjItMHgxZTBkKTt9CiAjZWxzZQkJCQkJCiBzdGF0aWMgaW50IGRvX3BhZ2VfZmF1bHQodW5zaWduZWQgbG9uZyBhZGRyLHVuc2lnbmVkIGludCBmc3Isc3RydWN0IHB0X3JlZ3MqcmVncwotKXtyZXR1cm4oMHgyZjArMjIyMC0weGI5Yyk7fQorKXtyZXR1cm4oMHgyNDVkKzQ2OS0weDI2MzIpO30KICNlbmRpZgkJCQkJCiAjaWZkZWYgQ09ORklHX01NVQogc3RhdGljIGludCBfX2twcm9iZXMgZG9fdHJhbnNsYXRpb25fZmF1bHQodW5zaWduZWQgbG9uZyBhZGRyLHVuc2lnbmVkIGludCBmc3IsCkBAIC0xMjksMjEgKzEyOSwyMSBAQAogYmFkX2FyZWE7aWYoIXB1ZF9wcmVzZW50KCpwdWQpKXNldF9wdWQocHVkLCpwdWRfayk7cG1kPXBtZF9vZmZzZXQocHVkLGFkZHIpOwogcG1kX2s9cG1kX29mZnNldChwdWRfayxhZGRyKTsKICNpZmRlZiBDT05GSUdfQVJNX0xQQUUKLWluZGV4PSgweGVmOSszNjYyLTB4MWQ0Nyk7CitpbmRleD0oMHhkYyszNDE2LTB4ZTM0KTsKICNlbHNlCi1pbmRleD0oYWRkcj4+U0VDVElPTl9TSElGVCkmKDB4MjE0ZisxMDMwLTB4MjU1NCk7CitpbmRleD0oYWRkcj4+U0VDVElPTl9TSElGVCkmKDB4OTIrMjQxMC0weDlmYik7CiAjZW5kaWYKIGlmKHBtZF9ub25lKHBtZF9rW2luZGV4XSkpZ290byBiYWRfYXJlYTtjb3B5X3BtZChwbWQscG1kX2spO3JldHVybgotKDB4MWJhNysyNzMxLTB4MjY1Mik7YmFkX2FyZWE6ZG9fYmFkX2FyZWEoYWRkcixmc3IscmVncyk7cmV0dXJuCi0oMHg4MDIrMzUwMi0weDE1YjApO30KKygweDEyNmErMTUyMy0weDE4NWQpO2JhZF9hcmVhOmRvX2JhZF9hcmVhKGFkZHIsZnNyLHJlZ3MpO3JldHVybgorKDB4MTA0Zis0MjQ1LTB4MjBlNCk7fQogI2Vsc2UJCQkJCQogc3RhdGljIGludCBkb190cmFuc2xhdGlvbl9mYXVsdCh1bnNpZ25lZCBsb25nIGFkZHIsdW5zaWduZWQgaW50IGZzcixzdHJ1Y3QgCi1wdF9yZWdzKnJlZ3Mpe3JldHVybigweGFkMis2NDQtMHhkNTYpO30KK3B0X3JlZ3MqcmVncyl7cmV0dXJuKDB4MTNiMSsxOTk3LTB4MWI3ZSk7fQogI2VuZGlmCQkJCQkKIHN0YXRpYyBpbnQgZG9fc2VjdF9mYXVsdCh1bnNpZ25lZCBsb25nIGFkZHIsdW5zaWduZWQgaW50IGZzcixzdHJ1Y3QgcHRfcmVncypyZWdzCiApe2lmKGludGVycnVwdHNfZW5hYmxlZChyZWdzKSlsb2NhbF9pcnFfZW5hYmxlKCk7ZG9fYmFkX2FyZWEoYWRkcixmc3IscmVncyk7Ci1yZXR1cm4oMHgxMmM3KzM0MjItMHgyMDI1KTt9c3RhdGljIGludCBkb19iYWQodW5zaWduZWQgbG9uZyBhZGRyLHVuc2lnbmVkIGludCAKLWZzcixzdHJ1Y3QgcHRfcmVncypyZWdzKXtyZXR1cm4oMHgxNTdkKzE5NDctMHgxZDE3KTt9c3RydWN0IGZzcl9pbmZve2ludCgqZm4pKAorcmV0dXJuKDB4NWUxKzMzOTUtMHgxMzI0KTt9c3RhdGljIGludCBkb19iYWQodW5zaWduZWQgbG9uZyBhZGRyLHVuc2lnbmVkIGludCBmc3IKKyxzdHJ1Y3QgcHRfcmVncypyZWdzKXtyZXR1cm4oMHhjNGYrMjM4MS0weDE1OWIpO31zdHJ1Y3QgZnNyX2luZm97aW50KCpmbikoCiB1bnNpZ25lZCBsb25nIGFkZHIsdW5zaWduZWQgaW50IGZzcixzdHJ1Y3QgcHRfcmVncypyZWdzKTtpbnQgc2lnO2ludCBjb2RlO2NvbnN0IAogY2hhcipuYW1lO307CiAjaWZkZWYgQ09ORklHX0FSTV9MUEFFCkBAIC0xNTIsMjEgKzE1MiwyMSBAQAogI2luY2x1ZGUgImZzci0ybGV2ZWwuYyIKICNlbmRpZgogdm9pZCBfX2luaXQgaG9va19mYXVsdF9jb2RlKGludCBucixpbnQoKmZuKSh1bnNpZ25lZCBsb25nLHVuc2lnbmVkIGludCxzdHJ1Y3QgCi1wdF9yZWdzKiksaW50IHNpZyxpbnQgY29kZSxjb25zdCBjaGFyKm5hbWUpe2lmKG5yPCgweGU5MCs0ODk1LTB4MjFhZil8fG5yPj0KK3B0X3JlZ3MqKSxpbnQgc2lnLGludCBjb2RlLGNvbnN0IGNoYXIqbmFtZSl7aWYobnI8KDB4MWEyMSs2OTYtMHgxY2Q5KXx8bnI+PQogQVJSQVlfU0laRShmc3JfaW5mbykpQlVHKCk7ZnNyX2luZm9bbnJdLmZuPWZuO2Zzcl9pbmZvW25yXS5zaWc9c2lnO2Zzcl9pbmZvW25yXS4KIGNvZGU9Y29kZTtmc3JfaW5mb1tucl0ubmFtZT1uYW1lO30KICNpZmRlZiBDT05GSUdfTU9ERU1fQ09ERV9JU19NQVBQSU5HCiBzdGF0aWMgREVDTEFSRV9SV1NFTShzaHJpbmtlcl9yd3NlbSk7YXRvbWljX3QgX2NvZGVfcGFnZV9jb3VudD1BVE9NSUNfSU5JVCgKLSgweDlhZCsxNjAzLTB4ZmYwKSk7c3RydWN0IGFkZHJfaW5mb3tzdHJ1Y3QgbGlzdF9oZWFkIG5vZGU7dW5zaWduZWQgbG9uZyB2YWRkcjsKKygweGZkMSsxNjcwLTB4MTY1NykpO3N0cnVjdCBhZGRyX2luZm97c3RydWN0IGxpc3RfaGVhZCBub2RlO3Vuc2lnbmVkIGxvbmcgdmFkZHI7CiB1bnNpZ25lZCBsb25nIGthZGRyO3Vuc2lnbmVkIGxvbmcgcGFnZV9pbmRleDt9O2VudW0gbW9kZW1fYWNjZXNzX3RlY2hub2xvZ3l7R1NNPQotKDB4MTQwKzkzMjAtMHgyNWE4KSxVVFJBTj0oMHgxNzNiKzMyMzYtMHgyM2RlKSxMVEU9KDB4MTc1ZiszNjEzLTB4MjU3YSksQ09NPQotKDB4MTE1NSszODY4LTB4MjA2ZSksTlJfTU9ERU1fQUNDRVNTPSgweDM3NSs1MjY1LTB4MTgwMil9O3N0cnVjdCBsaXN0X2hlYWQgCisoMHgxMTI4KzM3NDEtMHgxZmM1KSxVVFJBTj0oMHg1N2YrMTk1MS0weGQxZCksTFRFPSgweGM4NSsxNzgzLTB4MTM3YSksQ09NPQorKDB4NWIxKzY0NTktMHgxZWU5KSxOUl9NT0RFTV9BQ0NFU1M9KDB4MThhOCs4MTctMHgxYmQ1KX07c3RydWN0IGxpc3RfaGVhZCAKIG1vZGVtX3BhZ2VfbGlzdFtOUl9NT0RFTV9BQ0NFU1NdPXtMSVNUX0hFQURfSU5JVChtb2RlbV9wYWdlX2xpc3RbCi0oMHhmYzArMTc5LTB4MTA3MyldKSxMSVNUX0hFQURfSU5JVChtb2RlbV9wYWdlX2xpc3RbKDB4MjEzYys3MTQtMHgyNDA1KV0pLAotTElTVF9IRUFEX0lOSVQobW9kZW1fcGFnZV9saXN0WygweDFmMmErNjgxLTB4MjFkMSldKSxMSVNUX0hFQURfSU5JVCgKLW1vZGVtX3BhZ2VfbGlzdFsoMHgxY2EwKzE2NS0weDFkNDIpXSksfTt1bnNpZ25lZCBpbnQgcGFnZV91c2VkWwotKDB4MTA5MSszNzU2LTB4MWYxNSldO3N0cnVjdCBjb21wbGV0aW9uIHBhZ2VfY29tcGxldGlvblsoMHgxZTYyKzcyNi0weDIxMTApKgotKDB4MjJiZCs3OTktMHgyNWJjKV07c3RhdGljIHZvaWQgdW5tYXBfcHRlX3JhbmdlKHBtZF90KnBtZCx1bnNpZ25lZCBsb25nIGFkZHIsCisoMHg5OTIrNDU5Mi0weDFiODIpXSksTElTVF9IRUFEX0lOSVQobW9kZW1fcGFnZV9saXN0WygweGIyNSsxNTAzLTB4MTEwMyldKSwKK0xJU1RfSEVBRF9JTklUKG1vZGVtX3BhZ2VfbGlzdFsoMHg4YjkrNDQxMS0weDE5ZjIpXSksTElTVF9IRUFEX0lOSVQoCittb2RlbV9wYWdlX2xpc3RbKDB4NmEzKzIzNjktMHhmZTEpXSksfTt1bnNpZ25lZCBpbnQgcGFnZV91c2VkWworKDB4MjA4KzkyMDQtMHgyNWQ0KV07c3RydWN0IGNvbXBsZXRpb24gcGFnZV9jb21wbGV0aW9uWygweGIwOCsxOTU4LTB4MTI4NikqCisoMHgxNmM3KzQwNzAtMHgyNjhkKV07c3RhdGljIHZvaWQgdW5tYXBfcHRlX3JhbmdlKHBtZF90KnBtZCx1bnNpZ25lZCBsb25nIGFkZHIsCiB1bnNpZ25lZCBsb25nIGVuZCl7cHRlX3QqcHRlO3B0ZT1wdGVfb2Zmc2V0X2tlcm5lbChwbWQsYWRkcik7ZG97cHRlX3QgcHRlbnQ9CiBwdGVwX2dldF9hbmRfY2xlYXIoJmluaXRfbW0sYWRkcixwdGUpO1dBUk5fT04oIXB0ZV9ub25lKHB0ZW50KSYmIXB0ZV9wcmVzZW50KAogcHRlbnQpKTt9d2hpbGUocHRlKyssYWRkcis9UEFHRV9TSVpFLGFkZHIhPWVuZCk7fXN0YXRpYyB2b2lkIHVubWFwX3BtZF9yYW5nZSgKQEAgLTE4MCwxNCArMTgwLDE0IEBACiBhZGRyLHVuc2lnbmVkIGxvbmcgZW5kKXtwZ2RfdCpwZ2Q7dW5zaWduZWQgbG9uZyBuZXh0O0JVR19PTihhZGRyPj1lbmQpO3BnZD0KIHBnZF9vZmZzZXRfayhhZGRyKTtkb3tuZXh0PXBnZF9hZGRyX2VuZChhZGRyLGVuZCk7aWYocGdkX25vbmVfb3JfY2xlYXJfYmFkKHBnZCkpCiBjb250aW51ZTt1bm1hcF9wdWRfcmFuZ2UocGdkLGFkZHIsbmV4dCk7fXdoaWxlKHBnZCsrLGFkZHI9bmV4dCxhZGRyIT1lbmQpO312b2lkIAotc2hyaW5rX21vZGVtX21lbSh1bnNpZ25lZCBpbnQgYWNjZXNzX3R5cGUpe2ludCBpPSgweDY1MCs3OTI0LTB4MjU0NCk7dW5zaWduZWQgCitzaHJpbmtfbW9kZW1fbWVtKHVuc2lnbmVkIGludCBhY2Nlc3NfdHlwZSl7aW50IGk9KDB4NDQ5KzcyOTQtMHgyMGM3KTt1bnNpZ25lZCAKIGxvbmcgdmFkZHI7c3RydWN0IGFkZHJfaW5mbyphZGRyLCp0bXBfYWRkcjtzdHJ1Y3QgbGlzdF9oZWFkIHRtcF9wYWdlX2xpc3Q7Zm9yKGk9Ci0oMHg3NzYrNjAxMy0weDFlZjMpO2k8TlJfTU9ERU1fQUNDRVNTO2krKyl7aWYoaT09YWNjZXNzX3R5cGUpY29udGludWU7ZG93bl93cml0ZQorKDB4NTczKzQ0NzMtMHgxNmVjKTtpPE5SX01PREVNX0FDQ0VTUztpKyspe2lmKGk9PWFjY2Vzc190eXBlKWNvbnRpbnVlO2Rvd25fd3JpdGUKICgmc2hyaW5rZXJfcndzZW0pO2xpc3RfcmVwbGFjZV9pbml0KCZtb2RlbV9wYWdlX2xpc3RbaV0sJnRtcF9wYWdlX2xpc3QpO3VwX3dyaXRlCiAoJnNocmlua2VyX3J3c2VtKTtsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoYWRkcix0bXBfYWRkciwmdG1wX3BhZ2VfbGlzdCxub2RlKXsKIGxpc3RfZGVsX2luaXQoJmFkZHItPm5vZGUpO3BhZ2VfY29tcGxldGlvblthZGRyLT5wYWdlX2luZGV4XS5kb25lPQotKDB4MTI2Yis0ODE4LTB4MjUzZCk7cGFnZV91c2VkW2FkZHItPnBhZ2VfaW5kZXgvQklUU19QRVJfTE9OR10mPX4oCi0oMHgxNzQrMTE3Ny0weDYwYyk8PChhZGRyLT5wYWdlX2luZGV4JUJJVFNfUEVSX0xPTkcpKTt2YWRkcj1hZGRyLT52YWRkciYKKygweGE3Nys2NjA4LTB4MjQ0Nyk7cGFnZV91c2VkW2FkZHItPnBhZ2VfaW5kZXgvQklUU19QRVJfTE9OR10mPX4oCisoMHhjMjQrMjk3OC0weDE3YzUpPDwoYWRkci0+cGFnZV9pbmRleCVCSVRTX1BFUl9MT05HKSk7dmFkZHI9YWRkci0+dmFkZHImCiBQQUdFX01BU0s7aWYodmFkZHI8Y3Bwc19nbG9iYWxfdmFyLmNwa29fdGV4dF9zdGFydHx8dmFkZHI+Y3Bwc19nbG9iYWxfdmFyLgogbW9kZW1fdGV4dF9lbmQpe3BhbmljKAogIlx4NjFceDY0XHg2NFx4NzJceDVmXHg2OVx4NmVceDY2XHg2Zlx4M2FceDIwXHgyNVx4MzBceDM4XHg3OFx4MjBceDY5XHg3M1x4MjBceDIwXHg2NFx4NjVceDczXHg3NFx4NzJceDZmXHg3OSIKQEAgLTE5NSwxNCArMTk1LDE0IEBACiBQQUdFX1NJWkUpO2ZsdXNoX3RsYl9rZXJuZWxfcmFuZ2UodmFkZHIsdmFkZHIrUEFHRV9TSVpFKTsKICNpZmRlZiBDT05GSUdfREVCVUdfUk9EQVRBCiB1bnNpZ25lZCBpbnQgZmxhZ3M7bG9jYWxfaXJxX3NhdmUoZmxhZ3MpO3NldF9tZW1vcnlfcncoYWRkci0+a2FkZHIsCi0oMHgxMjU0KzI4NjUtMHgxZDg0KSk7bG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOworKDB4ZjQ1KzU1MzctMHgyNGU1KSk7bG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogI2VuZGlmCiBmcmVlX3BhZ2UoYWRkci0+a2FkZHIpO2tmcmVlKGFkZHIpO2F0b21pY19kZWMoJl9jb2RlX3BhZ2VfY291bnQpO307fX0KIEVYUE9SVF9TWU1CT0woc2hyaW5rX21vZGVtX21lbSk7cGh5c19hZGRyX3QgdmlydF9pc19tYXBwaW5nKHVuc2lnbmVkIGxvbmcgYWRkcil7CiBwZ2RfdCpwZ2Q7cG1kX3QqcG1kO3B0ZV90KnB0ZXAscHRlO3Vuc2lnbmVkIGxvbmcgcGZuO3BnZD1wZ2Rfb2Zmc2V0X2soYWRkcik7aWYoIQogcGdkX25vbmUoKnBnZCkpe3BtZD1wbWRfb2Zmc2V0KHBnZCxhZGRyKTtpZighcG1kX25vbmUoKnBtZCkpe3B0ZXA9cHRlX29mZnNldF9tYXAKIChwbWQsYWRkcik7cHRlPSpwdGVwO2lmKHB0ZV9wcmVzZW50KHB0ZSkpe3Bmbj1wdGVfcGZuKHB0ZSk7cmV0dXJuIF9fcGZuX3RvX3BoeXMoCi1wZm4pO319fXJldHVybigweDE1OGIrMjUxMy0weDFmNWMpO31zdGF0aWMgaW50IHN5bmNfcGdkKHVuc2lnbmVkIGxvbmcgYWRkciwKK3Bmbik7fX19cmV0dXJuKDB4MTdkKzU5ODItMHgxOGRiKTt9c3RhdGljIGludCBzeW5jX3BnZCh1bnNpZ25lZCBsb25nIGFkZHIsCiB1bnNpZ25lZCBpbnQgZnNyLHN0cnVjdCBwdF9yZWdzKnJlZ3Mpe3Vuc2lnbmVkIGludCBpbmRleDtwZ2RfdCpwZ2QsKnBnZF9rO3B1ZF90KgogcHVkLCpwdWRfaztwbWRfdCpwbWQsKnBtZF9rO2luZGV4PXBnZF9pbmRleChhZGRyKTtwZ2Q9Y3B1X2dldF9wZ2QoKStpbmRleDtwZ2Rfaz0KIGluaXRfbW0ucGdkK2luZGV4O2lmKHBnZF9ub25lKCpwZ2RfaykpZ290byBiYWRfYXJlYTtpZighcGdkX3ByZXNlbnQoKnBnZCkpCkBAIC0yMTAsMTMgKzIxMCwxMyBAQAogcHVkX25vbmUoKnB1ZF9rKSlnb3RvIGJhZF9hcmVhO2lmKCFwdWRfcHJlc2VudCgqcHVkKSlzZXRfcHVkKHB1ZCwqcHVkX2spO3BtZD0KIHBtZF9vZmZzZXQocHVkLGFkZHIpO3BtZF9rPXBtZF9vZmZzZXQocHVkX2ssYWRkcik7CiAjaWZkZWYgQ09ORklHX0FSTV9MUEFFCi1pbmRleD0oMHgxYzY2KzYzNy0weDFlZTMpOworaW5kZXg9KDB4ODhiKzI5MDQtMHgxM2UzKTsKICNlbHNlCi1pbmRleD0oYWRkcj4+U0VDVElPTl9TSElGVCkmKDB4M2NiKzkzMi0weDc2ZSk7CitpbmRleD0oYWRkcj4+U0VDVElPTl9TSElGVCkmKDB4MWJjNysyNjA4LTB4MjVmNik7CiAjZW5kaWYKIGlmKHBtZF9ub25lKHBtZF9rW2luZGV4XSkpZ290byBiYWRfYXJlYTtjb3B5X3BtZChwbWQscG1kX2spO3JldHVybgotKDB4MWMwKzEzNTctMHg3MGQpO2JhZF9hcmVhOmRvX2JhZF9hcmVhKGFkZHIsZnNyLHJlZ3MpO3JldHVybigweDczMisyMzY1LTB4MTA2ZikKLTt9dW5zaWduZWQgbG9uZypyZWFkX2NvZGVfZmlsZSh1bnNpZ25lZCBsb25nIHBhZ2VfaW5kZXgpe3Vuc2lnbmVkIGxvbmcqY29kZV9idWY7CisoMHhlNCsxMDk4LTB4NTJlKTtiYWRfYXJlYTpkb19iYWRfYXJlYShhZGRyLGZzcixyZWdzKTtyZXR1cm4oMHgxOTIrODc3Ny0weDIzZGIpOworfXVuc2lnbmVkIGxvbmcqcmVhZF9jb2RlX2ZpbGUodW5zaWduZWQgbG9uZyBwYWdlX2luZGV4KXt1bnNpZ25lZCBsb25nKmNvZGVfYnVmOwogc3NpemVfdCByZXN1bHQ7Y29kZV9idWY9Z2V0X3plcm9lZF9wYWdlKEdGUF9BVE9NSUMpO2lmKCFjb2RlX2J1ZilwYW5pYygKICJceDZkXHg2NVx4NmRceDY1XHg2Zlx4NzJceDc5XHgyMFx4NmVceDZmXHg3NFx4MjBceDY1XHg2ZVx4NmZceDc1XHg2N1x4NjhceDIxXHgyMSIKICk7YXRvbWljX2luYygmX2NvZGVfcGFnZV9jb3VudCk7aWYoSVNfRVJSKGNwcHNfZ2xvYmFsX3Zhci5mcF9jb2RlKXx8CkBAIC0yMjQsMjMgKzIyNCwyMyBAQAogIlx4NmZceDcwXHg2NVx4NmVceDIwXHg2Nlx4NjlceDZjXHg2NVx4MjBceDY1XHg3Mlx4NzJceDZmXHg3MiIgIlxuIik7fQogbW1fc2VnbWVudF90IG9sZF9mcztvbGRfZnM9Z2V0X2ZzKCk7c2V0X2ZzKEtFUk5FTF9EUyk7bG9mZl90IHBvcztwb3M9cGFnZV9pbmRleCoKIFBBR0VfU0laRStjcHBzX2dsb2JhbF92YXIubW9kZW1fb2Zmc2V0O3Jlc3VsdD12ZnNfcmVhZChjcHBzX2dsb2JhbF92YXIuZnBfY29kZSwoCi1jaGFyKiljb2RlX2J1ZixQQUdFX1NJWkUsJnBvcyk7aWYocmVzdWx0PCgweDQ3MysyODk0LTB4ZmMxKSl7cGFuaWMoCitjaGFyKiljb2RlX2J1ZixQQUdFX1NJWkUsJnBvcyk7aWYocmVzdWx0PCgweDEwMDgrMTI0MC0weDE0ZTApKXtwYW5pYygKICJceDcyXHg2NVx4NjFceDY0XHgyMFx4NjNceDZmXHg2NFx4NjVceDIwXHg2Nlx4NjlceDZjXHg2NVx4MjBceDY1XHg3Mlx4NzJceDZmXHg3MiIgIlxuIgogKTt9CiAjaWZkZWYgQ09ORklHX0RFQlVHX1JPREFUQQogdW5zaWduZWQgaW50IGZsYWdzO2xvY2FsX2lycV9zYXZlKGZsYWdzKTtzZXRfbWVtb3J5X3JvKCh1bnNpZ25lZCBsb25nKWNvZGVfYnVmLAotKDB4MTY1MysyOTktMHgxNzdkKSk7bG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOworKDB4YmEyKzEzMDEtMHgxMGI2KSk7bG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogI2VuZGlmCiBzZXRfZnMob2xkX2ZzKTtyZXR1cm4gY29kZV9idWY7fXZvaWQgcmVhZF9jb2RlX21hcHBpbmcodW5zaWduZWQgbG9uZyBhZGRyLAogdW5zaWduZWQgaW50IGZzcixzdHJ1Y3QgcHRfcmVncypyZWdzKXt1bnNpZ25lZCBsb25nIG9mZnNldDt1bnNpZ25lZCBsb25nIHZhZGRyOwogY29uc3Qgc3RydWN0IG1lbV90eXBlKm10eXBlO3Vuc2lnbmVkIGxvbmcqdmlyX2NvZGVidWY7dW5zaWduZWQgbG9uZyBwYWdlX2luZGV4OwotdW5zaWduZWQgbG9uZyBwYWdlX3NoaWZ0O2lmKHZpcnRfaXNfbWFwcGluZyhhZGRyJlBBR0VfTUFTSykhPSgweDI3MSs0Njg2LTB4MTRiZikKK3Vuc2lnbmVkIGxvbmcgcGFnZV9zaGlmdDtpZih2aXJ0X2lzX21hcHBpbmcoYWRkciZQQUdFX01BU0spIT0oMHgyOTYrODE0OC0weDIyNmEpCiApe3N5bmNfcGdkKGFkZHImUEFHRV9NQVNLLGZzcixyZWdzKTtyZXR1cm47fXZhZGRyPWFkZHImUEFHRV9NQVNLO29mZnNldD12YWRkciYofgogY3Bwc19nbG9iYWxfdmFyLmNwa29fdGV4dF9zdGFydCk7cGFnZV9pbmRleD1vZmZzZXQ+PlBBR0VfU0hJRlQ7cGFnZV9zaGlmdD0KIHBhZ2VfaW5kZXglQklUU19QRVJfTE9ORztpZigocGFnZV91c2VkW3BhZ2VfaW5kZXgvQklUU19QRVJfTE9OR10+PnBhZ2Vfc2hpZnQpJgotKDB4MTZkOSs5NjQtMHgxYTljKSl7d2FpdF9mb3JfY29tcGxldGlvbigmcGFnZV9jb21wbGV0aW9uW3BhZ2VfaW5kZXhdKTtzeW5jX3BnZCgKLXZhZGRyLGZzcixyZWdzKTtyZXR1cm47fWVsc2UgcGFnZV91c2VkW3BhZ2VfaW5kZXgvQklUU19QRVJfTE9OR118PSgKLSgweDhlYisyMzgwLTB4MTIzNik8PHBhZ2Vfc2hpZnQpO2xvY2FsX2lycV9lbmFibGUoKTt2aXJfY29kZWJ1Zj1yZWFkX2NvZGVfZmlsZSgKKygweDE0ZDcrMTEzMC0weDE5NDApKXt3YWl0X2Zvcl9jb21wbGV0aW9uKCZwYWdlX2NvbXBsZXRpb25bcGFnZV9pbmRleF0pO3N5bmNfcGdkCisodmFkZHIsZnNyLHJlZ3MpO3JldHVybjt9ZWxzZSBwYWdlX3VzZWRbcGFnZV9pbmRleC9CSVRTX1BFUl9MT05HXXw9KAorKDB4Zjg2KzEyOTAtMHgxNDhmKTw8cGFnZV9zaGlmdCk7bG9jYWxfaXJxX2VuYWJsZSgpO3Zpcl9jb2RlYnVmPXJlYWRfY29kZV9maWxlKAogcGFnZV9pbmRleCk7c3RydWN0IGFkZHJfaW5mbyphZGRyX2luZm87YWRkcl9pbmZvPWt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBhZGRyX2luZm8KICksR0ZQX0tFUk5FTCk7YWRkcl9pbmZvLT5rYWRkcj12aXJfY29kZWJ1ZjthZGRyX2luZm8tPnZhZGRyPWFkZHI7YWRkcl9pbmZvLT4KIHBhZ2VfaW5kZXg9cGFnZV9pbmRleDtkb3duX3dyaXRlKCZzaHJpbmtlcl9yd3NlbSk7aWYodmFkZHI8Y3Bwc19nbG9iYWxfdmFyLgpAQCAtMjU4LDQ2ICsyNTgsNDYgQEAKIHN0cnVjdCBwdF9yZWdzKnJlZ3Mpe2NvbnN0IHN0cnVjdCBmc3JfaW5mbyppbmY9ZnNyX2luZm8rZnNyX2ZzKGZzcik7c3RydWN0IAogc2lnaW5mbyBpbmZvOwogI2lmZGVmIENPTkZJR19NT0RFTV9DT0RFX0lTX01BUFBJTkcKLWlmKGFkZHIhPSgweDE2Y2QrMjQwOC0weDIwMzUpJiZhZGRyPj1jcHBzX2dsb2JhbF92YXIuY3Brb190ZXh0X3N0YXJ0JiZhZGRyPD0KK2lmKGFkZHIhPSgweDE3ZmMrMjU4OC0weDIyMTgpJiZhZGRyPj1jcHBzX2dsb2JhbF92YXIuY3Brb190ZXh0X3N0YXJ0JiZhZGRyPD0KIGNwcHNfZ2xvYmFsX3Zhci5tb2RlbV90ZXh0X2VuZCl7cmVhZF9jb2RlX21hcHBpbmcoYWRkcixmc3ImfkZTUl9MTlhfUEYscmVncyk7CiByZXR1cm47fQogI2VuZGlmCiBpZighaW5mLT5mbihhZGRyLGZzciZ+RlNSX0xOWF9QRixyZWdzKSlyZXR1cm47cHJpbnRrKEtFUk5fQUxFUlQKICJceDU1XHg2ZVx4NjhceDYxXHg2ZVx4NjRceDZjXHg2NVx4NjRceDIwXHg2Nlx4NjFceDc1XHg2Y1x4NzRceDNhXHgyMFx4MjVceDczXHgyMFx4MjhceDMwXHg3OFx4MjVceDMwXHgzM1x4NzhceDI5XHgyMFx4NjFceDc0XHgyMFx4MzBceDc4XHgyNVx4MzBceDM4XHg2Y1x4NzgiICJcbiIKLSxpbmYtPm5hbWUsZnNyLGFkZHIpO2luZm8uc2lfc2lnbm89aW5mLT5zaWc7aW5mby5zaV9lcnJubz0oMHgxOTQyKzE4NjQtMHgyMDhhKTsKKyxpbmYtPm5hbWUsZnNyLGFkZHIpO2luZm8uc2lfc2lnbm89aW5mLT5zaWc7aW5mby5zaV9lcnJubz0oMHg2YTQrNTA2Ny0weDFhNmYpOwogaW5mby5zaV9jb2RlPWluZi0+Y29kZTtpbmZvLnNpX2FkZHI9KHZvaWQgX191c2VyKilhZGRyO2FybV9ub3RpZnlfZGllKCIiLHJlZ3MsJgotaW5mbyxmc3IsKDB4MTA2OSs0NDg1LTB4MjFlZSkpO312b2lkIF9faW5pdCBob29rX2lmYXVsdF9jb2RlKGludCBucixpbnQoKmZuKSgKK2luZm8sZnNyLCgweDg4OCs0MzM4LTB4MTk3YSkpO312b2lkIF9faW5pdCBob29rX2lmYXVsdF9jb2RlKGludCBucixpbnQoKmZuKSgKIHVuc2lnbmVkIGxvbmcsdW5zaWduZWQgaW50LHN0cnVjdCBwdF9yZWdzKiksaW50IHNpZyxpbnQgY29kZSxjb25zdCBjaGFyKm5hbWUpe2lmCi0obnI8KDB4YjUxKzU3NDgtMHgyMWM1KXx8bnI+PUFSUkFZX1NJWkUoaWZzcl9pbmZvKSlCVUcoKTtpZnNyX2luZm9bbnJdLmZuPWZuOworKG5yPCgweGY2NCs1NjM5LTB4MjU2Yil8fG5yPj1BUlJBWV9TSVpFKGlmc3JfaW5mbykpQlVHKCk7aWZzcl9pbmZvW25yXS5mbj1mbjsKIGlmc3JfaW5mb1tucl0uc2lnPXNpZztpZnNyX2luZm9bbnJdLmNvZGU9Y29kZTtpZnNyX2luZm9bbnJdLm5hbWU9bmFtZTt9CiBhc21saW5rYWdlIHZvaWQgX19leGNlcHRpb24gZG9fUHJlZmV0Y2hBYm9ydCh1bnNpZ25lZCBsb25nIGFkZHIsdW5zaWduZWQgaW50IAogaWZzcixzdHJ1Y3QgcHRfcmVncypyZWdzKXtjb25zdCBzdHJ1Y3QgZnNyX2luZm8qaW5mPWlmc3JfaW5mbytmc3JfZnMoaWZzcik7CiBzdHJ1Y3Qgc2lnaW5mbyBpbmZvOwogI2lmZGVmIENPTkZJR19NT0RFTV9DT0RFX0lTX01BUFBJTkcKLWlmKGFkZHIhPSgweDE2YjYrMzMzLTB4MTgwMykmJmFkZHI+PWNwcHNfZ2xvYmFsX3Zhci5jcGtvX3RleHRfc3RhcnQmJmFkZHI8PQoraWYoYWRkciE9KDB4OTliKzE5MzQtMHgxMTI5KSYmYWRkcj49Y3Bwc19nbG9iYWxfdmFyLmNwa29fdGV4dF9zdGFydCYmYWRkcjw9CiBjcHBzX2dsb2JhbF92YXIubW9kZW1fdGV4dF9lbmQpe3JlYWRfY29kZV9tYXBwaW5nKGFkZHIsaWZzcnxGU1JfTE5YX1BGLHJlZ3MpOwogcmV0dXJuO30KICNlbmRpZgogaWYoIWluZi0+Zm4oYWRkcixpZnNyfEZTUl9MTlhfUEYscmVncykpcmV0dXJuO3ByaW50ayhLRVJOX0FMRVJUCiAiXHg1NVx4NmVceDY4XHg2MVx4NmVceDY0XHg2Y1x4NjVceDY0XHgyMFx4NzBceDcyXHg2NVx4NjZceDY1XHg3NFx4NjNceDY4XHgyMFx4NjFceDYyXHg2Zlx4NzJceDc0XHgzYVx4MjBceDI1XHg3M1x4MjBceDI4XHgzMFx4NzhceDI1XHgzMFx4MzNceDc4XHgyOVx4MjBceDYxXHg3NFx4MjBceDMwXHg3OFx4MjVceDMwXHgzOFx4NmNceDc4IiAiXG4iCi0saW5mLT5uYW1lLGlmc3IsYWRkcik7aW5mby5zaV9zaWdubz1pbmYtPnNpZztpbmZvLnNpX2Vycm5vPSgweDQ2Nis0NTg0LTB4MTY0ZSk7CissaW5mLT5uYW1lLGlmc3IsYWRkcik7aW5mby5zaV9zaWdubz1pbmYtPnNpZztpbmZvLnNpX2Vycm5vPSgweDFhZTcrNjM4LTB4MWQ2NSk7CiBpbmZvLnNpX2NvZGU9aW5mLT5jb2RlO2luZm8uc2lfYWRkcj0odm9pZCBfX3VzZXIqKWFkZHI7YXJtX25vdGlmeV9kaWUoIiIscmVncywmCi1pbmZvLGlmc3IsKDB4YmFjKzU4NDYtMHgyMjgyKSk7fQoraW5mbyxpZnNyLCgweGQzOSs2NTMtMHhmYzYpKTt9CiAjaWZuZGVmIENPTkZJR19BUk1fTFBBRQogc3RhdGljIGludCBfX2luaXQgZXhjZXB0aW9uc19pbml0KHZvaWQpe2lmKGNwdV9hcmNoaXRlY3R1cmUoKT49Q1BVX0FSQ0hfQVJNdjYpewotaG9va19mYXVsdF9jb2RlKCgweDljOSs0MzM4LTB4MWFiNyksZG9fdHJhbnNsYXRpb25fZmF1bHQsU0lHU0VHVixTRUdWX01BUEVSUiwKK2hvb2tfZmF1bHRfY29kZSgoMHgxMTdhKzY0NC0weDEzZmEpLGRvX3RyYW5zbGF0aW9uX2ZhdWx0LFNJR1NFR1YsU0VHVl9NQVBFUlIsCiAiXHg0OVx4MmRceDYzXHg2MVx4NjNceDY4XHg2NVx4MjBceDZkXHg2MVx4NjlceDZlXHg3NFx4NjVceDZlXHg2MVx4NmVceDYzXHg2NVx4MjBceDY2XHg2MVx4NzVceDZjXHg3NCIKLSk7fWlmKGNwdV9hcmNoaXRlY3R1cmUoKT49Q1BVX0FSQ0hfQVJNdjcpe2hvb2tfZmF1bHRfY29kZSgoMHgxNjljKzI0ODAtMHgyMDQ5KSwKKyk7fWlmKGNwdV9hcmNoaXRlY3R1cmUoKT49Q1BVX0FSQ0hfQVJNdjcpe2hvb2tfZmF1bHRfY29kZSgoMHgxYWRjKzEzNC0weDFiNWYpLAogZG9fYmFkLFNJR1NFR1YsU0VHVl9NQVBFUlIsCiAiXHg3M1x4NjVceDYzXHg3NFx4NjlceDZmXHg2ZVx4MjBceDYxXHg2M1x4NjNceDY1XHg3M1x4NzNceDIwXHg2Nlx4NmNceDYxXHg2N1x4MjBceDY2XHg2MVx4NzVceDZjXHg3NCIKLSk7aG9va19mYXVsdF9jb2RlKCgweDkwOCs0MTctMHhhYTMpLGRvX2JhZCxTSUdTRUdWLFNFR1ZfTUFQRVJSLAorKTtob29rX2ZhdWx0X2NvZGUoKDB4MTdiYysxODg3LTB4MWYxNSksZG9fYmFkLFNJR1NFR1YsU0VHVl9NQVBFUlIsCiAiXHg3M1x4NjVceDYzXHg3NFx4NjlceDZmXHg2ZVx4MjBceDYxXHg2M1x4NjNceDY1XHg3M1x4NzNceDIwXHg2Nlx4NmNceDYxXHg2N1x4MjBceDY2XHg2MVx4NzVceDZjXHg3NCIKICk7fQogI2lmZGVmIENPTkZJR19NT0RFTV9DT0RFX0lTX01BUFBJTkcKLWludCBpbmRleD0oMHhjNmIrNDA0OC0weDFjM2IpO2ZvcihpbmRleD0oMHg3MTMrMjg5Mi0weDEyNWYpO2luZGV4PAotKDB4MzZmKzU5MDAtMHgxYTUzKSooMHgxMGQ5KzQ0NDgtMHgyMjE5KTtpbmRleCsrKWluaXRfY29tcGxldGlvbigmCitpbnQgaW5kZXg9KDB4MTM5NSs0MTQ2LTB4MjNjNyk7Zm9yKGluZGV4PSgweDE1ZmIrMzc3NC0weDI0YjkpO2luZGV4PAorKDB4MTY0MiszOTUyLTB4MjU4YSkqKDB4NzBkKzYyMzEtMHgxZjQ0KTtpbmRleCsrKWluaXRfY29tcGxldGlvbigmCiBwYWdlX2NvbXBsZXRpb25baW5kZXhdKTsKICNlbmRpZgotcmV0dXJuKDB4MThhYisxNjI0LTB4MWYwMyk7fWFyY2hfaW5pdGNhbGwoZXhjZXB0aW9uc19pbml0KTsKK3JldHVybigweDkxKzE5NjYtMHg4M2YpO31hcmNoX2luaXRjYWxsKGV4Y2VwdGlvbnNfaW5pdCk7CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9jcGtvL2Nwa29fbWFpbi5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9jcGtvL2Nwa29fbWFpbi5jCmluZGV4IDdhOWMyMmMuLjM0MWQ2NjggMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvY3Brby9jcGtvX21haW4uYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL2Nwa28vY3Brb19tYWluLmMKQEAgLTc3LDM2ICs3NywzNyBAQAogZXh0ZXJuIFNJTlQzMiB6RHJ2VnBfQXVkaW9EYXRhV3JpdGUoY29uc3QgVk9JRCpwQnVmLFVJTlQzMiB1aUxlbik7ZXh0ZXJuIFNJTlQzMiAKIHpEcnZWcF9BdWRpb0RhdGFPcGVuKFVJTlQzMiBhdWRpb1R5cGUsVUlOVDMyIHNhbXBsZVJhdGUpO2V4dGVybiBTSU5UMzIgCiB6RHJ2VnBfQXVkaW9EYXRhQ2xvc2Uodm9pZCk7ZXh0ZXJuIFNJTlQzMiB6RHJ2VnBfR2V0VnBMb29wX1dyYXAoVk9JRCk7ZXh0ZXJuIAotVk9JRCB6RHJ2VnBfU3RhdHVzKFVJTlQzMipzYW1wbGVfcmF0ZSxVSU5UMzIqdm9pY2Vfc3RhdHVzKTt0eXBlZGVmIHN0cnVjdCAKLWNwa29fc2VjdGlvbnt1bnNpZ25lZCBpbnQgY3Brb190ZXh0X3N0YXJ0O3Vuc2lnbmVkIGludCBjcGtvX3JvZGF0YV9zdGFydDsKLXVuc2lnbmVkIGludCBfX3V0cmFuX21vZGVtX3RleHRfc3RhcnQ7dW5zaWduZWQgaW50IF9fbHRlX21vZGVtX3RleHRfc3RhcnQ7Ci11bnNpZ25lZCBpbnQgX19jb21tX21vZGVtX3RleHRfc3RhcnQ7dW5zaWduZWQgaW50IG1vZGVtX3RleHRfZW5kO3Vuc2lnbmVkIGludCAKLWNwa29fZGF0YV9zdGFydDt1bnNpZ25lZCBpbnQgY3Brb19ic3Nfc3RhcnQ7dW5zaWduZWQgaW50IGNwa29fdGV4dF9vZmZzZXQ7fQotY3Brb19zZWN0aW9uX2xheW91dDtjcGtvX3NlY3Rpb25fbGF5b3V0IGNwa29fcHNfc2VjdGlvbjtpbnQgcmFpc2UoaW50IHNpZ25vKXsKLXJldHVybigweDQwNCs4OTcwLTB4MjcwZSk7fWV4dGVybiB1bnNpZ25lZCBpbnQgU3lzRW50cnkodm9pZCk7c3RhdGljIGludCAKLWtvX01haW5fVGhyZWFkKHZvaWQqZGF0YSl7c3RydWN0IHNjaGVkX3BhcmFtIHBhcmFtPXsuc2NoZWRfcHJpb3JpdHk9Ci1NQVhfVVNFUl9SVF9QUklPLygweGFmYis0NTExLTB4MWM5OCktKDB4MTYzMyszODE1LTB4MjUxNyl9O2ludCByZXQ9Ci0oMHgxZjQzKzQwMi0weDIwZDUpO3NjaGVkX3NldHNjaGVkdWxlcihjdXJyZW50LFNDSEVEX0ZJRk8sJnBhcmFtKTtyZXQ9U3lzRW50cnkoKQotO2lmKHJldCE9KDB4MTBiOCszOTY2LTB4MjAzNikpcGFuaWMoIk1haW5fVGhyZWFkXG4iKTtwYXJhbS5zY2hlZF9wcmlvcml0eT0KLU1BWF9VU0VSX1JUX1BSSU8tKDB4ZmIzKzI4NTItMHgxYWE5KTtzY2hlZF9zZXRzY2hlZHVsZXIoa3RocmVhZGRfdGFzayxTQ0hFRF9GSUZPCi0sJnBhcmFtKTtyZXR1cm4oMHhhYTYrNjQwMS0weDIzYTcpO31pbnQgenRlX21vZGVtX2tvX3N0YXJ0KHZvaWQpe2t0aHJlYWRfcnVuKAota29fTWFpbl9UaHJlYWQsTlVMTCwiXHg1YVx4NTRceDQ1XHg0ZFx4NjFceDY5XHg2ZVx4NTRceDY4XHg3Mlx4NjVceDYxXHg2NCIpOwotcmV0dXJuKDB4OGI5KzE5NTUtMHgxMDVjKTt9c3RhdGljIHZvaWQgY3Brb19zZWN0aW9uaW5mb19zZXQodm9pZCl7aW50IHJldDtzdHJ1Y3QKLSBmaWxlKmZwO21tX3NlZ21lbnRfdCBvbGRfZnM7bG9mZl90IGNwa29fcG9zPSgweDZlZCs1NTAzLTB4MWM2Yyk7c3RydWN0IAorVk9JRCB6RHJ2VnBfU3RhdHVzKFVJTlQzMipzYW1wbGVfcmF0ZSxVSU5UMzIqdm9pY2Vfc3RhdHVzKTtleHRlcm4gVk9JRCAKK3pEcnZWcF9VcGRhdGVWb2ljZU52KFVJTlQ4KnZvaWNlX252X3VwZGF0ZSk7dHlwZWRlZiBzdHJ1Y3QgY3Brb19zZWN0aW9ue3Vuc2lnbmVkCisgaW50IGNwa29fdGV4dF9zdGFydDt1bnNpZ25lZCBpbnQgY3Brb19yb2RhdGFfc3RhcnQ7dW5zaWduZWQgaW50IAorX191dHJhbl9tb2RlbV90ZXh0X3N0YXJ0O3Vuc2lnbmVkIGludCBfX2x0ZV9tb2RlbV90ZXh0X3N0YXJ0O3Vuc2lnbmVkIGludCAKK19fY29tbV9tb2RlbV90ZXh0X3N0YXJ0O3Vuc2lnbmVkIGludCBtb2RlbV90ZXh0X2VuZDt1bnNpZ25lZCBpbnQgY3Brb19kYXRhX3N0YXJ0Cis7dW5zaWduZWQgaW50IGNwa29fYnNzX3N0YXJ0O3Vuc2lnbmVkIGludCBjcGtvX3RleHRfb2Zmc2V0O31jcGtvX3NlY3Rpb25fbGF5b3V0OworY3Brb19zZWN0aW9uX2xheW91dCBjcGtvX3BzX3NlY3Rpb247aW50IHJhaXNlKGludCBzaWdubyl7cmV0dXJuKDB4NmVkKzQ0OC0weDhhZCkKKzt9ZXh0ZXJuIHVuc2lnbmVkIGludCBTeXNFbnRyeSh2b2lkKTtzdGF0aWMgaW50IGtvX01haW5fVGhyZWFkKHZvaWQqZGF0YSl7c3RydWN0Cisgc2NoZWRfcGFyYW0gcGFyYW09ey5zY2hlZF9wcmlvcml0eT1NQVhfVVNFUl9SVF9QUklPLygweDgxYSszMzM1LTB4MTUxZiktCisoMHg5MzErNDgyMy0weDFjMDUpfTtpbnQgcmV0PSgweDEzOCs5MTM4LTB4MjRlYSk7c2NoZWRfc2V0c2NoZWR1bGVyKGN1cnJlbnQsCitTQ0hFRF9GSUZPLCZwYXJhbSk7cmV0PVN5c0VudHJ5KCk7aWYocmV0IT0oMHg0YzkrMTMxMy0weDllYSkpcGFuaWMoCisiTWFpbl9UaHJlYWRcbiIpO3BhcmFtLnNjaGVkX3ByaW9yaXR5PU1BWF9VU0VSX1JUX1BSSU8tKDB4N2ExKzc2MzEtMHgyNTQyKTsKK3NjaGVkX3NldHNjaGVkdWxlcihrdGhyZWFkZF90YXNrLFNDSEVEX0ZJRk8sJnBhcmFtKTtyZXR1cm4oMHgxMjM5KzE4NTctMHgxOTdhKTt9CitpbnQgenRlX21vZGVtX2tvX3N0YXJ0KHZvaWQpe2t0aHJlYWRfcnVuKGtvX01haW5fVGhyZWFkLE5VTEwsCisiXHg1YVx4NTRceDQ1XHg0ZFx4NjFceDY5XHg2ZVx4NTRceDY4XHg3Mlx4NjVceDYxXHg2NCIpO3JldHVybgorKDB4MTA1MCszMTE0LTB4MWM3YSk7fXN0YXRpYyB2b2lkIGNwa29fc2VjdGlvbmluZm9fc2V0KHZvaWQpe2ludCByZXQ7c3RydWN0IGZpbGUKKypmcDttbV9zZWdtZW50X3Qgb2xkX2ZzO2xvZmZfdCBjcGtvX3Bvcz0oMHgxNjBiKzE3MzMtMHgxY2QwKTtzdHJ1Y3QgCiBjcHBzX2dsb2JhbE1vZGVtIGdsb2JhbFZhcjtmcD1maWxwX29wZW4oCiAiXHgyZlx4NmNceDY5XHg2Mlx4MmZceDYzXHg3MFx4NmJceDZmXHgyZlx4NjNceDcwXHg2Ylx4NmZceDVmXHg3M1x4NjVceDYzXHg2OVx4NmVceDY2XHg2Zlx4MmVceDYyXHg2OVx4NmUiCi0sKDB4ZjI4KzI1NzEtMHgxOTMzKSwoMHhhNTkrMTE3MS0weGVlYykpO2lmKElTX0VSUihmcCl8fGZwPT1OVUxMKXBhbmljKAorLCgweGQ2YyszMTk4LTB4MTllYSksKDB4NjU1KzU3MDEtMHgxYzlhKSk7aWYoSVNfRVJSKGZwKXx8ZnA9PU5VTEwpcGFuaWMoCiAiXHg2Zlx4NzBceDY1XHg2ZVx4MjBceDY2XHg2OVx4NmNceDY1XHgyMFx4NjVceDcyXHg3Mlx4NmZceDcyIiAiXG4iKTtvbGRfZnM9CiBnZXRfZnMoKTtzZXRfZnMoS0VSTkVMX0RTKTtyZXQ9dmZzX3JlYWQoZnAsKGNoYXIqKSZjcGtvX3BzX3NlY3Rpb24sc2l6ZW9mKAotY3Brb19zZWN0aW9uX2xheW91dCksJmNwa29fcG9zKTtpZihyZXQ8PSgweDMwNCszNzU2LTB4MTFiMCkpcGFuaWMoCitjcGtvX3NlY3Rpb25fbGF5b3V0KSwmY3Brb19wb3MpO2lmKHJldDw9KDB4MjM1ZisyMy0weDIzNzYpKXBhbmljKAogIlx4NzJceDY1XHg2MVx4NjRceDIwXHg2Nlx4NjlceDZjXHg2NVx4MjBceDY1XHg3Mlx4NzJceDZmXHg3MiIgIlxuIik7ZmlscF9jbG9zZSgKIGZwLE5VTEwpOwogI2lmZGVmIENPTkZJR19NT0RFTV9DT0RFX0lTX01BUFBJTkcKIGZwPWZpbHBfb3BlbigKICJceDJmXHg2Y1x4NjlceDYyXHgyZlx4NjNceDcwXHg2Ylx4NmZceDJmXHg2M1x4NzBceDZiXHg2Zlx4MmVceDZiXHg2ZiIsCi0oMHgxMDE5KzQ1NjMtMHgyMWVjKSwoMHgxY2YyKzE4MzctMHgyNDFmKSk7aWYoSVNfRVJSKGZwKXx8ZnA9PU5VTEwpcGFuaWMoCisoMHg5NDArMzcyNC0weDE3Y2MpLCgweGIyYSszMjE1LTB4MTdiOSkpO2lmKElTX0VSUihmcCl8fGZwPT1OVUxMKXBhbmljKAogIlx4NmZceDcwXHg2NVx4NmVceDIwXHg2Nlx4NjlceDZjXHg2NVx4MjBceDY1XHg3Mlx4NzJceDZmXHg3MiIgIlxuIik7ZnAtPmZfcmEuCi1yYV9wYWdlcz0oMHg1M2YrNDQ4NS0weDE2YzQpOworcmFfcGFnZXM9KDB4MTVhOCs3NjktMHgxOGE5KTsKICNlbmRpZgogaWYoY3Brb19wc19zZWN0aW9uLmNwa29fdGV4dF9zdGFydCl7Z2xvYmFsVmFyLmNwa29fdGV4dF9zdGFydD0odW5zaWduZWQgbG9uZykKIGNwa29fcHNfc2VjdGlvbi5jcGtvX3RleHRfc3RhcnQ7Z2xvYmFsVmFyLmNwa29fcm9kYXRhX3N0YXJ0PSh1bnNpZ25lZCBsb25nKQpAQCAtMTI2LDcgKzEyNyw3IEBACiB2ZnJlZV9tb2RlbV9zZWN0aW9uKGdsb2JhbFZhci5jcGtvX3RleHRfc3RhcnQsZ2xvYmFsVmFyLm1vZGVtX3RleHRfZW5kKTsKICNlbmRpZgogfWVsc2UgcGFuaWMoIlx4NjZceDY5XHg2Y1x4NjVceDIwXHg2NVx4NzJceDcyXHg2Zlx4NzIiICJcbiIpO31zdGF0aWMgaW50IAotY3Brb19zdGFydCh2b2lkKXtzdHJ1Y3QgY3Bwc19jYWxsYmFja3MgY2FsbGJhY2s9eygweDkxMys0NTg4LTB4MWFmZil9O2NhbGxiYWNrLgorY3Brb19zdGFydCh2b2lkKXtzdHJ1Y3QgY3Bwc19jYWxsYmFja3MgY2FsbGJhY2s9eygweDY2Zis0NTI2LTB4MTgxZCl9O2NhbGxiYWNrLgogek9zc19SZXNldE5WRmFjdG9yeT16T3NzX1Jlc2V0TlZGYWN0b3J5O2NhbGxiYWNrLnpPc3NfTnZyYW1GbHVzaD16T3NzX052cmFtRmx1c2gKIDtjYWxsYmFjay56T3NzX052SXRlbVdyaXRlPXpPc3NfTnZJdGVtV3JpdGU7Y2FsbGJhY2suek9zc19Odkl0ZW1Xcml0ZUZhY3Rvcnk9CiB6T3NzX052SXRlbVdyaXRlRmFjdG9yeTtjYWxsYmFjay56T3NzX052SXRlbVJlYWQ9ek9zc19Odkl0ZW1SZWFkO2NhbGxiYWNrLgpAQCAtMTkwLDcgKzE5MSw4IEBACiBtbXBfQW1yRGVjQ2xvc2U7Y2FsbGJhY2subW1wX0FtckVuY0Nsb3NlPW1tcF9BbXJFbmNDbG9zZTtjYWxsYmFjay4KIHpEcnZWcF9BdWRpb0RhdGFPcGVuPXpEcnZWcF9BdWRpb0RhdGFPcGVuO2NhbGxiYWNrLnpEcnZWcF9BdWRpb0RhdGFXcml0ZT0KIHpEcnZWcF9BdWRpb0RhdGFXcml0ZTtjYWxsYmFjay56RHJ2VnBfQXVkaW9EYXRhQ2xvc2U9ekRydlZwX0F1ZGlvRGF0YUNsb3NlOwotY2FsbGJhY2suekRydlZwX1N0YXR1cz16RHJ2VnBfU3RhdHVzOworY2FsbGJhY2suekRydlZwX1N0YXR1cz16RHJ2VnBfU3RhdHVzO2NhbGxiYWNrLnpEcnZWcF9VcGRhdGVWb2ljZU52PQorekRydlZwX1VwZGF0ZVZvaWNlTnY7CiAjZW5kaWYJCiBjYWxsYmFjay5wc21fTW9kZW1EZXZTbGVlcD1wc21fTW9kZW1EZXZTbGVlcDtjYWxsYmFjay5wc21fTW9kZW1TbGVlcENoZWNrPQogcHNtX01vZGVtU2xlZXBDaGVjaztjYWxsYmFjay5wc21fTW9kZW1TbGVlcFRpbWVHZXQ9cHNtX01vZGVtU2xlZXBUaW1lR2V0OwpAQCAtMTk4LDUgKzIwMCw1IEBACiBwc21fR2V0TW9kZW1TbGVlcEZsYWdTdGF0dXM9cHNtX0dldE1vZGVtU2xlZXBGbGFnU3RhdHVzOwogI2VuZGlmCiBjcHBzX2NhbGxiYWNrc19yZWdpc3RlcigmY2FsbGJhY2spO2Nwa29fc2VjdGlvbmluZm9fc2V0KCk7enRlX21vZGVtX2tvX3N0YXJ0KCk7Ci1yZXR1cm4oMHhiNDMrNDUyMC0weDFjZWIpO31zdGF0aWMgaW50IGNwa29fc3RvcCh2b2lkKXtyZXR1cm4oMHgyMGNkKzQ2MC0weDIyOTkpOwotfW1vZHVsZV9pbml0KGNwa29fc3RhcnQpO21vZHVsZV9leGl0KGNwa29fc3RvcCk7CityZXR1cm4oMHgxYTZkKzI2MzktMHgyNGJjKTt9c3RhdGljIGludCBjcGtvX3N0b3Aodm9pZCl7cmV0dXJuKDB4NjIrNTYxLTB4MjkzKTt9Cittb2R1bGVfaW5pdChjcGtvX3N0YXJ0KTttb2R1bGVfZXhpdChjcGtvX3N0b3ApOwpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9tZmQvengyMzQyOTAtcmVndWxhdG9yLXdyYXBwZXIuYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbWZkL3p4MjM0MjkwLXJlZ3VsYXRvci13cmFwcGVyLmMKaW5kZXggYzVkOTlkYi4uZjZiZjNjNCAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9tZmQvengyMzQyOTAtcmVndWxhdG9yLXdyYXBwZXIuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL21mZC96eDIzNDI5MC1yZWd1bGF0b3Itd3JhcHBlci5jCkBAIC0xNTcsMTMgKzE1NywxMyBAQAogICAgIC8vengyMzQyOTBfc2V0X2J1Y2s0X3NsZWVwX21vZGUoQlVDSzIzNF9TTFBfU0hVVERPV04pOyAgIC8qUEEgM1Y2Ki8NCiAgICAgLy96eDIzNDI5MF9zZXRfbGRvMV9zbGVlcF9tb2RlKExET0FfU0xQX1NIVVRET1dOKTsgICAgICAgLypVU0IgMFY5Ki8NCiAgICAgLy96eDIzNDI5MF9zZXRfbGRvNV9zbGVlcF9tb2RlKExET0FfU0xQX1NIVVRET1dOKTsgICAgICAgLypVU0IgM1YzKi8NCi0JengyMzQyOTBfc2V0X2xkbzJfc2xlZXBfbW9kZShMRE9BX1NMUF9FQ09fVk9MVF9TTFApOyAgICAvKmlvMS44di9tY3AxLjh2L3NkMDEuOHYqLw0KLQl6eDIzNDI5MF9zZXRfbGRvM19zbGVlcF9tb2RlKExET0FfU0xQX0VDT19WT0xUX1NMUCk7CS8qdnAxMTEuOHYvdmRkcl9wbGwxLjh2LyovDQorCXp4MjM0MjkwX3NldF9sZG8yX3NsZWVwX21vZGUoTERPQV9TTFBfRUNPX1ZPTFQpOyAgICAvKmlvMS44di9tY3AxLjh2L3NkMDEuOHYqLw0KKwl6eDIzNDI5MF9zZXRfbGRvM19zbGVlcF9tb2RlKExET0FfU0xQX0VDT19WT0xUKTsJLyp2cDExMS44di92ZGRyX3BsbDEuOHYvKi8NCiAJengyMzQyOTBfc2V0X2xkbzRfc2xlZXBfbW9kZShMRE9BX1NMUF9TSFVURE9XTik7CQkvKnZjeG8qLw0KICAgICAvL3p4MjM0MjkwX3NldF9sZG82X3NsZWVwX21vZGUoTERPQV9TTFBfU0hVVERPV04pOyAgICAgICAvKlNJTTEgMVY4Ki8NCi0gICAgengyMzQyOTBfc2V0X2xkbzdfc2xlZXBfbW9kZShMRE9BX1NMUF9FQ09fVk9MVF9TTFApOyAgLypSRiAyVjg1IC0tIDI2TSAqLw0KLSAgICB6eDIzNDI5MF9zZXRfbGRvOF9zbGVlcF9tb2RlKExET0FfU0xQX0VDT19WT0xUX1NMUCk7ICAgICAgIC8qWlNQIEpUQUcvU0QgMlY4NS9MQ0QqLw0KLSAgICB6eDIzNDI5MF9zZXRfbGRvOV9zbGVlcF9tb2RlKExET0FfU0xQX0VDT19WT0xUX1NMUCk7ICAgICAgIC8qUExMIDBWOSovDQorICAgIHp4MjM0MjkwX3NldF9sZG83X3NsZWVwX21vZGUoTERPQV9TTFBfRUNPX1ZPTFQpOyAgLypSRiAtLSAyNk0gKi8NCisgICAgengyMzQyOTBfc2V0X2xkbzhfc2xlZXBfbW9kZShMRE9BX1NMUF9FQ09fVk9MVCk7ICAgICAgIC8qWlNQIEpUQUcvU0QgMlY4NS9MQ0QqLw0KKyAgICB6eDIzNDI5MF9zZXRfbGRvOV9zbGVlcF9tb2RlKExET0FfU0xQX0VDT19WT0xUKTsgICAgICAgLypQTEwgMFY5Ki8NCiAgICAgLy96eDIzNDI5MF9zZXRfbGRvMTBfc2xlZXBfbW9kZShMRE9BX1NMUF9TSFVURE9XTik7ICAgICAgLypBQkIgRElHKi8NCiANCiAJcmV0dXJuIDA7DQpAQCAtMTkxLDkgKzE5MSwxNiBAQAogCXJldCArPSB6RHJ2WngyMzQyOTBfRGlzY2hhcmdlckNvbmZpZygpOw0KIA0KIAkvL3pEcnZaeDIzNDI5MF9TbGVlcENvbmZpZygpOw0KKyNpZmRlZiBfVVNFX1ZFSElDTEVfREMJDQorCXJldCArPSB6eDIzNDI5MF9TZXRUbGxwVG9EbyhMTFBfUkVTVEFSVCk7DQorCXJldCArPSB6eDIzNDI5MF9TZXRMbHBUaW1lKExMUF9USU1FXzZTKTsNCiANCi0gICAgcmV0ICs9IHp4MjM0MjkwX1NldExscEVuYWJsZShMTFBfRU5BQkxFKTsNCisjZWxzZQ0KICAgICByZXQgKz0gengyMzQyOTBfU2V0VGxscFRvRG8oTExQX1NIVVRET1dOKTsNCisJcmV0ICs9IHp4MjM0MjkwX1NldExscFRpbWUoTExQX1RJTUVfMTBTKTsNCisjZW5kaWYNCisJcmV0ICs9IHp4MjM0MjkwX1NldExscEVuYWJsZShMTFBfRU5BQkxFKTsNCisNCiAgICAvLyByZXQgKz0gengyMzQyOTBfU2V0UmVzdGFydERseShMTFBfRExZXzUwME1TKTsgIC8vTExQX0RMWV8yNTBNUyANCiAgICAgaWYocmV0ICE9IDApDQogCXsNCmRpZmYgLS1naXQgYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL21tYy9ob3N0L3p4MjlfbW1jLmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL21tYy9ob3N0L3p4MjlfbW1jLmMKaW5kZXggNDI1ZDZhNy4uNDcyNGI4OCAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9tbWMvaG9zdC96eDI5X21tYy5jCisrKyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbW1jL2hvc3QvengyOV9tbWMuYwpAQCAtNDAsNyArNDAsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9rdGhyZWFkLmg+Ci0KKyNpbmNsdWRlIDxsaW51eC9yYW1kdW1wL3JhbWR1bXAuaD4KIAogI2luY2x1ZGUgPG1hY2gvengyOV9tbWMuaD4KICNpbmNsdWRlICJtbWNfeGxvZy5oIgpAQCAtNDAyMCw5ICs0MDIwLDkgQEAKIAogI2lmIChkZWZpbmVkIENPTkZJR19BUkNIX1pYMjk3NTIwVjIpfHwoZGVmaW5lZCBDT05GSUdfQVJDSF9aWDI5NzUyMFYzKQogCWlmIChob3N0LT5ob3N0X2lkID09IDApewotCQlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgic2QwX3JlZ18weDAxMjEwMDAwLmJpbiIsIDB4MDEyMTAwMDAsIDB4MTEwLCAodW5zaWduZWQgbG9uZylob3N0LT5yZWdzLCAwLCAwKTsKKwkJcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoInNkMF9yZWdfMHgwMTIxMDAwMC5iaW4iLCAweDAxMjEwMDAwLCAweDExMCwgKHVuc2lnbmVkIGxvbmcpaG9zdC0+cmVncywgUkFNRFVNUF9GTEFHX0xFVkVMX01FRElVTSwgMCk7CiAJfWVsc2V7Ci0JCXJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKCJzZDFfcmVnXzB4MDEyMTEwMDAuYmluIiwgMHgwMTIxMTAwMCwgMHgxMTAsICh1bnNpZ25lZCBsb25nKWhvc3QtPnJlZ3MsIDAsIDApOworCQlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgic2QxX3JlZ18weDAxMjExMDAwLmJpbiIsIDB4MDEyMTEwMDAsIDB4MTEwLCAodW5zaWduZWQgbG9uZylob3N0LT5yZWdzLCBSQU1EVU1QX0ZMQUdfTEVWRUxfTUVESVVNLCAwKTsKIAl9CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvcHNuZXQvcHNuZXRfZGV2LmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL25ldC9wc25ldC9wc25ldF9kZXYuYwppbmRleCAwOWExYjJiLi5mNDc2OTRiIDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL25ldC9wc25ldC9wc25ldF9kZXYuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL25ldC9wc25ldC9wc25ldF9kZXYuYwpAQCAtMjcxLDYgKzI3MSw3IEBACiAJYnVmZiA9IGJ1ZmYgKyBzaXplb2Yoc3RydWN0IGluNl9hZGRyKTsKIAltZW1jcHkoJmdfaXB2NF9sb2NhbF9zdWJuZXQsIGJ1ZmYsIHNpemVvZihzdHJ1Y3QgaW5fYWRkcikpOwogCWdfeGxhdF9kZXYgPSBkZXZfZ2V0X2J5X25hbWUoJmluaXRfbmV0LCBkZXZfbmFtZSk7CisJcmV0dXJuIDA7CiB9CiAKIGludCBmaWxsX2lwX2hlYWRlcihzdHJ1Y3QgaXBoZHIgKmlwLCBjb25zdCBzdHJ1Y3QgaXB2NmhkciAqb2xkX2hlYWRlcikgewpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvcHNuZXQvcHNuZXRfaW8uYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3BzbmV0L3BzbmV0X2lvLmMKaW5kZXggNzAzMzY4NS4uYjVmZmFkYSAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvcHNuZXQvcHNuZXRfaW8uYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL25ldC9wc25ldC9wc25ldF9pby5jCkBAIC0xMiw4ICsxMiw3IEBACiAjaW5jbHVkZSA8bmV0L2lwdjYuaD4KICNpbmNsdWRlIDxuZXQvcHJvdG9jb2wuaD4KICNpbmNsdWRlIDxuZXQvbmRpc2MuaD4KLQotZXh0ZXJuIHN0cnVjdCBwc25ldCAqZ2xvYmFsX3BzbmV0W0REUl9ERVZfTUFYXTsKKyNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KIAogI2RlZmluZSBaQVRJMl9EQVRBX0NIQU5ORUxfSURfTlVNX1NUQVJUCQkoQ0hBTk5FTF9BUDJQU19NQVhJRCkvLysxCiAjZGVmaW5lIFpBVEkyX0RBVEFfQ0hBTk5FTF9CQVNFIDkwCkBAIC03MCw2ICs2OSwxNCBAQAogCXN0cnVjdCBpbjZfYWRkciBuZF9vcHRfcGlfcHJlZml4OwogfTsKIAorc3RydWN0IG5kX29wdF9tdHVfaW5mbyAgICAgLyogbXR1IGluZm9ybWF0aW9uICovCit7CisJdWludDhfdCAgIG5kX29wdF9taV90eXBlOworCXVpbnQ4X3QgICBuZF9vcHRfbWlfbGVuOworCXVpbnQxNl90ICBuZF9vcHRfbWlfcmVzZXJ2ZWQyOworCXVpbnQzMl90ICBuZF9vcHRfbWlfbXR1OworfTsKKwogc3RydWN0IHBzbmV0X1JBX2luZm8KIHsKIAl1bnNpZ25lZCBpbnQgZmxhZzsKQEAgLTg1LDYgKzkyLDEwIEBACiBleHRlcm4gaW50IHpBdGkyX0lzRXhDaWQodW5zaWduZWQgY2hhciBjaWQsIHVuc2lnbmVkIGNoYXIgKnBjaWQpOwogc3RydWN0IHBzbmV0X1JBX2luZm8gZ19wc25ldF9pcHY2X3ByZWZpeFtERFJfREVWX01BWF0gPSB7MH07CiAKK2ludCByYV9tdHVfZW5hYmxlOworbW9kdWxlX3BhcmFtKHJhX210dV9lbmFibGUsIGludCwgMDY0NCk7CitleHRlcm4gc3RydWN0IHBzbmV0ICpnbG9iYWxfcHNuZXRbRERSX0RFVl9NQVhdOworCiB2b2lkIHBzbmV0X3BhcnNlX1JBX3BrdCh1bnNpZ25lZCBjaGFyIGNpZCwgdW5zaWduZWQgY2hhciogcGt0LCBpbnQgbGVuKQogewogCS8vd2FybigiY2lkPSVkIGZsYWc9JWRcbiIsIGNpZCwgZ19wc25ldF9pcHY2X3ByZWZpeFtjaWQtMV0uZmxhZyk7CkBAIC0xMzAsNyArMTQxLDE3IEBACiAJCQkJCWdfcHNuZXRfaXB2Nl9wcmVmaXhbZXh0X2NpZC0xXS5mbGFnID0gMTsKIAkJCQkJdXAoJmdfcHNuZXRfaXB2Nl9wcmVmaXhbZXh0X2NpZC0xXS5zZW0pOwogCQkJCQl3YXJuKCJjaWQ9JWQgcHJlZml4X2xlbj0lZFxuIiwgZXh0X2NpZCwgcGluZm8tPm5kX29wdF9waV9wcmVmaXhfbGVuKTsKLQkJCQkJcmV0dXJuOworCQkJCQkvL3JldHVybjsKKwkJCQl9CisJCQkJaWYoKG5kX29wdC0+bmRfb3B0X3R5cGUpID09IE5EX09QVF9NVFUpeworCQkJCQlpZihyYV9tdHVfZW5hYmxlKSB7CisJCQkJCQlpbnQgZXJyOworCQkJCQkJc3RydWN0IG5kX29wdF9tdHVfaW5mbyAqbWluZm8gPSAoc3RydWN0IG5kX29wdF9tdHVfaW5mbyAqKW5kX29wdDsKKwkJCQkJCXdhcm4oIm10dTogJXUsIGRldjogJXNcbiIsIG50b2hsKG1pbmZvLT5uZF9vcHRfbWlfbXR1KSwgZ2xvYmFsX3BzbmV0W2NpZC0xXS0+bmV0LT5uYW1lKTsKKwkJCQkJCWVyciA9IGRldl9zZXRfbXR1KGdsb2JhbF9wc25ldFtjaWQtMV0tPm5ldCwgbnRvaGwobWluZm8tPm5kX29wdF9taV9tdHUpKTsKKwkJCQkJCXdhcm4oImVycjogJWQiLCBlcnIpOworCQkJCQl9CQkJCQkKKwkJCQkJLy9yZXR1cm47CiAJCQkJfQogCQkJCW9wdF9sZW4gLT0gbDsKIAkJCQluZF9vcHQgPSAoKHZvaWQgKiluZF9vcHQpICsgbDsKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3dpcmVsZXNzL2FpYzg4MDAvTWFrZWZpbGUgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL25ldC93aXJlbGVzcy9haWM4ODAwL01ha2VmaWxlCmluZGV4IDdjYWY1MDcuLjFhNWM4MTQgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3dpcmVsZXNzL2FpYzg4MDAvTWFrZWZpbGUKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9NYWtlZmlsZQpAQCAtMTUyLDYgKzE1Miw3IEBACiBDT05GSUdfVFhSWF9USFJFQURfUFJJTyA9IHkKIENPTkZJR19EUEQgPSB5CiBDT05GSUdfRk9SQ0VfRFBEX0NBTElCID0geQorQ09ORklHX1RFTVBfUFcgPSB5CiAKICMgU3VwcG9ydCBvZiBNVS1NSU1PIHRyYW5zbWlzc2lvbiAobmVlZCBGVyBzdXBwb3J0KQogaWZlcSAoJChDT05GSUdfUldOWF9CRk1FUiksIHkpCkBAIC0yNjcsNiArMjY4LDcgQEAKIGNjZmxhZ3MtJChDT05GSUdfVFhSWF9USFJFQURfUFJJTykgKz0gLURDT05GSUdfVFhSWF9USFJFQURfUFJJTwogY2NmbGFncy0kKENPTkZJR19EUEQpICArPSAtRENPTkZJR19EUEQKIGNjZmxhZ3MtJChDT05GSUdfRk9SQ0VfRFBEX0NBTElCKSArPSAtRENPTkZJR19GT1JDRV9EUERfQ0FMSUIgLURDT05GSUdfRFBECitjY2ZsYWdzLSQoQ09ORklHX1RFTVBfUFcpICs9IC1EQ09ORklHX1RFTVBfUFcKIAogaWZlcSAoJChDT05GSUdfTEVTU19TS0IpLCB5KQogY2NmbGFncy15ICs9IC1ETEVTU19TS0IKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3dpcmVsZXNzL2FpYzg4MDAvYWljd2Zfc2Rpby5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9haWN3Zl9zZGlvLmMKaW5kZXggYTljN2ZiNS4uZDMwMDA5NiAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9haWN3Zl9zZGlvLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9haWN3Zl9zZGlvLmMKQEAgLTMzNCwxMSArMzM0LDEzIEBACiAgICAgc3RydWN0IGFpY19zZGlvX2RldiAqc2Rpb2RldiA9IE5VTEw7CiAKICAgICBzZGlvX2RiZygiJXNcbiIsIF9fZnVuY19fKTsKKyNpZmRlZiBDT05GSUdfVEVNUF9QVwogCWlmICh0aW1lcl9wZW5kaW5nKCZnX3J3bnhfcGxhdC0+c2Rpb2Rldi0+dHBfdGltZXIpKSB7CiAJCXByaW50aygiJXMgZGVsX3RpbWVyXG4iLCBfX2Z1bmNfXyk7CiAJCWRlbF90aW1lcl9zeW5jKCZnX3J3bnhfcGxhdC0+c2Rpb2Rldi0+dHBfdGltZXIpOwogCX0KIAljYW5jZWxfd29ya19zeW5jKCZnX3J3bnhfcGxhdC0+c2Rpb2Rldi0+dHBfd29yayk7CisjZW5kaWYKICAgICBob3N0ID0gZnVuYy0+Y2FyZC0+aG9zdDsKICAgICBob3N0LT5jYXBzICY9IH5NTUNfQ0FQX05PTlJFTU9WQUJMRTsKICAgICBidXNfaWYgPSBkZXZfZ2V0X2RydmRhdGEoJmZ1bmMtPmRldik7CkBAIC0xODM1LDUwICsxODM3LDkgQEAKICAgICBzZGlvX3JlbGVhc2VfaG9zdChzZGlvZGV2LT5mdW5jKTsKIH0KIAorI2lmZGVmIENPTkZJR19URU1QX1BXCiBleHRlcm4gdm9pZCBzZXRfdHhwd3JfY3RybChzdHJ1Y3QgYWljX3NkaW9fZGV2ICpzZGlvZGV2LCBzOF9sIHZhbHVlKTsKLSNpZiAwCi1zdGF0aWMgdm9pZCBzZXRfdHhwd3JfY3RybChzdHJ1Y3QgYWljX3NkaW9fZGV2ICpzZGlvZGV2LCBzOF9sIHZhbHVlKQotewotCW52cmFtX2luZm8udHhwd3JfbG9zcy5sb3NzX2VuYWJsZSA9IDE7Ci0JaWYgKHZhbHVlID4gVEVNUF9USERfMSAmJiB2YWx1ZSA8PSBURU1QX1RIRF8yKSB7Ci0JCWlmIChzZGlvZGV2LT5yYW5nZSA9PSAwKSB7Ci0JCQludnJhbV9pbmZvLnR4cHdyX2xvc3MubG9zc192YWx1ZSArPSAtVEVNUF9TVEVQXzE7Ci0JCQlzZGlvZGV2LnJhbmdlID0gMTsKLQkJCXJ3bnhfc2VuZF90eHB3cl9sdmxfcmVxKHNkaW9kZXYtPnJ3bnhfaHcpOwotCQl9IGVsc2UgaWYgKHNkaW9kZXYtPnJhbmdlID09IDEpIHsKLQkJCWNvbnRpbnVlOwotCQl9IGVsc2UgaWYgKHNkaW9kZXYtPnJhbmdlID09IDIpIHsKLQkJCW52cmFtX2luZm8udHhwd3JfbG9zcy5sb3NzX3ZhbHVlICs9IFRFTVBfU1RFUF8xOwotCQkJc2Rpb2Rldi5yYW5nZSA9IDE7Ci0JCQlyd254X3NlbmRfdHhwd3JfbHZsX3JlcShzZGlvZGV2LT5yd254X2h3KTsKLQkJfQotCX0gZWxzZSBpZiAodmFsdWUgPiBURU1QX1RIRF8yKSB7Ci0JCWlmIChzZGlvZGV2LT5yYW5nZSA9PSAwKSB7Ci0JCQludnJhbV9pbmZvLnR4cHdyX2xvc3MubG9zc192YWx1ZSArPSAtVEVNUF9TVEVQXzI7Ci0JCQlzZGlvZGV2LnJhbmdlID0gMjsKLQkJCXJ3bnhfc2VuZF90eHB3cl9sdmxfcmVxKHNkaW9kZXYtPnJ3bnhfaHcpOwotCQl9IGVsc2UgaWYgKHNkaW9kZXYtPnJhbmdlID09IDEpIHsKLQkJCW52cmFtX2luZm8udHhwd3JfbG9zcy5sb3NzX3ZhbHVlICs9IC1URU1QX1NURVBfMTsKLQkJCXNkaW9kZXYucmFuZ2UgPSAyOwotCQkJcndueF9zZW5kX3R4cHdyX2x2bF9yZXEoc2Rpb2Rldi0+cndueF9odyk7Ci0JCX0gZWxzZSB7Ci0JCQljb250aW51ZTsKLQkJfQotCX0gZWxzZSB7Ci0JCWlmIChzZGlvZGV2LT5yYW5nZSA9PSAwKSB7Ci0JCQljb250aW51ZTsKLQkJfSBlbHNlIGlmIChzZGlvZGV2LT5yYW5nZSA9PSAxKSB7Ci0JCQludnJhbV9pbmZvLnR4cHdyX2xvc3MubG9zc192YWx1ZSArPSBURU1QX1NURVBfMTsKLQkJCXNkaW9kZXYucmFuZ2UgPSAwOwotCQkJcndueF9zZW5kX3R4cHdyX2x2bF9yZXEoc2Rpb2Rldi0+cndueF9odyk7Ci0JCX0gZWxzZSBpZiAoc2Rpb2Rldi0+cmFuZ2UgPT0gMikgewotCQkJbnZyYW1faW5mby50eHB3cl9sb3NzLmxvc3NfdmFsdWUgKz0gVEVNUF9TVEVQXzI7Ci0JCQlzZGlvZGV2LnJhbmdlID0gMDsKLQkJCXJ3bnhfc2VuZF90eHB3cl9sdmxfcmVxKHNkaW9kZXYtPnJ3bnhfaHcpOwotCQl9Ci0JfQotfQotI2VuZGlmCisKIHZvaWQgYWljd2ZfdGVtcF93b3JrZXIoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCByd254X2h3ICpyd254X2h3OwpAQCAtMTkwNCw2ICsxODY1LDcgQEAKIAkJc2NoZWR1bGVfd29yaygmc2Rpb2Rldi0+dHBfd29yayk7CiAJcmV0dXJuOwogfQorI2VuZGlmCiB2b2lkICphaWN3Zl9zZGlvX2J1c19pbml0KHN0cnVjdCBhaWNfc2Rpb19kZXYgKnNkaW9kZXYpCiB7CiAgICAgaW50IHJldDsKQEAgLTE5NDcsNiArMTkwOSw3IEBACiAgICAgaW5pdF93YWl0cXVldWVfaGVhZCgmdHhfcHJpdi0+Y21kX3R4ZG9uZV93YWl0KTsKICAgICBhdG9taWNfc2V0KCZ0eF9wcml2LT50eF9wa3RjbnQsIDApOwogCisjaWZkZWYgQ09ORklHX1RFTVBfUFcKICNpZiBMSU5VWF9WRVJTSU9OX0NPREUgPCBLRVJORUxfVkVSU0lPTig0LCAxNCwgMCkKIAkJaW5pdF90aW1lcigmc2Rpb2Rldi0+dHBfdGltZXIpOwogCQlzZGlvZGV2LT50cF90aW1lci5kYXRhID0gKHVsb25nKSBzZGlvZGV2OwpAQCAtMTk1OCw2ICsxOTIxLDcgQEAKIAkJSU5JVF9XT1JLKCZzZGlvZGV2LT50cF93b3JrLCBhaWN3Zl90ZW1wX3dvcmtlcik7CiAJCW1vZF90aW1lcigmc2Rpb2Rldi0+dHBfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDEwICogMTAwMCkpOwogCQlzZGlvZGV2LT5yYW5nZSA9IDA7CisjZW5kaWYKICNpZiBkZWZpbmVkKENPTkZJR19TRElPX1BXUkNUUkwpCiAjaWYgTElOVVhfVkVSU0lPTl9DT0RFIDwgS0VSTkVMX1ZFUlNJT04oNCwxNCwwKQogICAgIGluaXRfdGltZXIoJnNkaW9kZXYtPnRpbWVyKTsKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3dpcmVsZXNzL2FpYzg4MDAvYWljd2Zfc2Rpby5oIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9haWN3Zl9zZGlvLmgKaW5kZXggOWExMGNkNC4uZmQ5OGRjYyAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9haWN3Zl9zZGlvLmgKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9haWN3Zl9zZGlvLmgKQEAgLTg0LDkgKzg0LDExIEBACiAgICAgdTggZmxvd2N0cmw7CiAgICAgc3BpbmxvY2tfdCB0eF9mbG93X2xvY2s7CiAjZW5kaWYKKyNpZmRlZiBDT05GSUdfVEVNUF9QVwogCXN0cnVjdCB0aW1lcl9saXN0IHRwX3RpbWVyOwogCXN0cnVjdCB3b3JrX3N0cnVjdCB0cF93b3JrOwogCXU4IHJhbmdlOworI2VuZGlmCiAgICAgI2lmIGRlZmluZWQoQ09ORklHX1NESU9fUFdSQ1RSTCkKICAgICAvL2ZvciBzZGlvIHB3ciBjdHJsCiAgICAgc3RydWN0IHRpbWVyX2xpc3QgdGltZXI7CkBAIC0xMDAsNyArMTAyLDkgQEAKIGludCBhaWN3Zl9zZGlvX3dyaXRlYihzdHJ1Y3QgYWljX3NkaW9fZGV2ICpzZGlvZGV2LCB1aW50IHJlZ2FkZHIsIHU4IHZhbCk7CiB2b2lkIGFpY3dmX3NkaW9faGFsX2lycWhhbmRsZXIoc3RydWN0IHNkaW9fZnVuYyAqZnVuYyk7CiB2b2lkIGFpY3dmX3NkaW9faGFsX2lycWhhbmRsZXJfZnVuYzIoc3RydWN0IHNkaW9fZnVuYyAqZnVuYyk7CisjaWZkZWYgQ09ORklHX1RFTVBfUFcKIHZvaWQgYWljd2ZfdGVtcF93b3JrZXIoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKTsKKyNlbmRpZgogCiAjaWYgZGVmaW5lZChDT05GSUdfU0RJT19QV1JDVFJMKQogdm9pZCBhaWN3Zl9zZGlvX3B3cmN0bF90aW1lcihzdHJ1Y3QgYWljX3NkaW9fZGV2ICpzZGlvZGV2LCB1aW50IGR1cmF0aW9uKTsKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3dpcmVsZXNzL2FpYzg4MDAvcndueF9wbGF0Zm9ybS5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9yd254X3BsYXRmb3JtLmMKaW5kZXggZTE3MDNhNC4uZWE5YWJiNyAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9yd254X3BsYXRmb3JtLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWljODgwMC9yd254X3BsYXRmb3JtLmMKQEAgLTExMCwxMyArMTEwLDkgQEAKICAgICB9LAogfTsKIAotZXh0ZXJuIHU4IGNoaXBfaWQ7CisjaWZkZWYgQ09ORklHX1RFTVBfUFcKIHZvaWQgc2V0X3R4cHdyX2N0cmwoc3RydWN0IGFpY19zZGlvX2RldiAqc2Rpb2RldiwgczhfbCB2YWx1ZSkKIHsKLQlpZiAoIUlTX0NISVBfSURfSCgpKSB7Ci0JCXByaW50aygiJXMgICFoXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybjsKLQl9CiAJbnZyYW1faW5mby50eHB3cl9sb3NzLmxvc3NfZW5hYmxlID0gMTsKIAlpZiAodmFsdWUgPiBURU1QX1RIRF8xICYmIHZhbHVlIDw9IFRFTVBfVEhEXzIpIHsKIAkJaWYgKHNkaW9kZXYtPnJhbmdlID09IDApIHsKQEAgLTE1Nyw2ICsxNTMsNyBAQAogCX0KIAlyZXR1cm47CiB9CisjZW5kaWYKIAogI2lmZGVmIFZFTkRPUl9TUEVDSUZJRURfRldfUEFUSAogaW50IHJ3bnhfbG9hZF9maXJtd2FyZSh1MzIgKipmd19idWYsIGNvbnN0IGNoYXIgKm5hbWUsIHN0cnVjdCBkZXZpY2UgKmRldmljZSkKQEAgLTgwMiw3ICs3OTksNyBAQAogdm9pZCBzZXRfdHhwd3JfbG9zc19vZnN0KHM4X2wgdmFsdWUpCiB7CiAgICAgbnZyYW1faW5mby50eHB3cl9sb3NzLmxvc3NfZW5hYmxlID0gMTsKLSAgICBudnJhbV9pbmZvLnR4cHdyX2xvc3MubG9zc192YWx1ZSArPSB2YWx1ZTsKKyAgICBudnJhbV9pbmZvLnR4cHdyX2xvc3MubG9zc192YWx1ZSA9IHZhbHVlOwogICAgIHByaW50aygiJXM6dmFsdWU6JWRcclxuIiwgICAgICBfX2Z1bmNfXywgdmFsdWUpOwogfQogdm9pZCBnZXRfdXNlcmNvbmZpZ190eHB3cl9vZnN0KHR4cHdyX29mc3RfY29uZl90ICp0eHB3cl9vZnN0KQpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3Mvc3N2Nng1eC9zbWFjL2Rldi5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9uZXQvd2lyZWxlc3Mvc3N2Nng1eC9zbWFjL2Rldi5jCmluZGV4IDY0MzM1ZWQuLjM4YzFiYzkgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvbmV0L3dpcmVsZXNzL3NzdjZ4NXgvc21hYy9kZXYuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL25ldC93aXJlbGVzcy9zc3Y2eDV4L3NtYWMvZGV2LmMKQEAgLTEwODksNiArMTA4OSw4IEBACiAJICAgIGlmIChzdGEpIHsKIAkgICAgICAgIGlmIChzc3Y2eHh4X2NvbXBhcmVfZXRoZXJfYWRkcihoZHItPmFkZHIxLCBzdGEtPmFkZHIpKSB7CiAJICAgICAgICAgICAgc3N2X3NrYl9mcmVlKHNjLCBza2IpOworCQkgICAgaWYgKHdzaWQgPD0gU1NWX1NXX1RYUV9JRF9TVEFNQVgpCisJICAgICAgICAJSENJX1RYUV9VTkxPQ0tfQllfU1RBKHNjLT5zaCwgd3NpZCk7CiAJICAgICAgICAgICAgY29udGludWU7CiAJICAgICAgICB9IGVsc2UgewogCSAgICAgICAgICAgIHNzdjZ4eHhfc2V0dXBfYW1wZHVfc2Vzc2lvbigodm9pZCAqKXNjLCBzdGEsIHNrYik7CmRpZmYgLS1naXQgYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3J0Yy96eDIzNDI5MC1ydGMuYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvcnRjL3p4MjM0MjkwLXJ0Yy5jCmluZGV4IDU0NDI4ZGIuLjFlYTE5NGMgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvcnRjL3p4MjM0MjkwLXJ0Yy5jCisrKyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvcnRjL3p4MjM0MjkwLXJ0Yy5jCkBAIC0yNzksNyArMjc5LDcgQEAKIAl6dGVfc2VuZF9ob3VyX2lycV9ldmVudCgpOw0KIAlyZXR1cm4gSVJRX0hBTkRMRUQ7DQogfQ0KLS8qYWxhcm0gZW5hYmxlL2Rpc2FibGUsIDA6ZGlzYWJsZSAxOmVuYWJsZSovDQorLyphbGFybSBlbmFibGUvZGlzYWJsZSwgMTpkaXNhYmxlIDA6ZW5hYmxlKi8NCiBpbnQgengyMzQyOTBfcnRjX2FsYXJtX2VuYWJsZSh6eDIzNDI5MF9hbGFybV90eXBlIHR5cGUsIHVuc2lnbmVkIGludCBlbmFibGVkKQ0KIHsNCiAgICAgaW50IHJldCA9IDA7DQpAQCAtMzUxLDcgKzM1MSwxNSBAQAogCWludCByZWdfdmFsPTAsIG1hc2s9MDsNCiANCiAJcHJfZGVidWcoIiVzOiBhaWU9JWRcbiIsIF9fZnVuY19fLCBlbmFibGVkKTsNCi0NCisJDQorCWlmKDA9PWVuYWJsZWQpLy9kaXNhYmxlIGFsYXJtDQorCXsNCisJCXp4MjM0MjkwX3J0Y19hbGFybV9lbmFibGUoQUxBUk1fU0VDT05ELCAxKTsJCQ0KKwkJengyMzQyOTBfcnRjX2FsYXJtX2VuYWJsZShBTEFSTV9NSU5VVEUsIDEpOwkJDQorCQl6eDIzNDI5MF9ydGNfYWxhcm1fZW5hYmxlKEFMQVJNX0hPVVIsIDEpOwkJDQorCQl6eDIzNDI5MF9ydGNfYWxhcm1fZW5hYmxlKEFMQVJNX0RBWSwgMSk7CQ0KKwkJengyMzQyOTBfcnRjX2FsYXJtX2VuYWJsZShBTEFSTV9XRUVLREFZLCAxKTsNCisJfTsNCiAgICAgLyplbmFibGUvZGlzYWJsZSBBSUUgYml0Ki8NCiAJbWFzayA9IFpYMjM0MjkwX0JJVEZNQVNLKFpYMjM0MjkwX1JUQ19BSUVfV0lELCBaWDIzNDI5MF9SVENfQUlFX0xTSCk7DQogCXJlZ192YWw9IFpYMjM0MjkwX0JJVEZWQUwoZW5hYmxlZCwgWlgyMzQyOTBfUlRDX0FJRV9MU0gpOw0KZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvc29jL3p0ZS9vdHAvb3RwX3p4LmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3NvYy96dGUvb3RwL290cF96eC5jCmluZGV4IDg3ZWYzOTguLmZiYTNmNTAgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvc29jL3p0ZS9vdHAvb3RwX3p4LmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zb2MvenRlL290cC9vdHBfenguYwpAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2RtYWVuZ2luZS5oPg0KICNpbmNsdWRlIDxtYWNoL2lvbWFwLmg+DQogI2luY2x1ZGUgPG1hY2gvZ3Bpby5oPg0KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPg0KIA0KIGV4dGVybiBzdHJ1Y3QgbXV0ZXggb3RwTXV0ZXg7DQogZXh0ZXJuIGNoYXIgKm5vcl9jbWRsaW5lOw0KQEAgLTU0Miw0MyArNTQzLDcgQEAKIAkgIHJldHVybiAwOw0KICAgIH0NCiAgICANCi0gICBpbnQgbm9yX3dyaXRlKHUzMiB0bywgdTMyIGxlbiwgdTMyIGJ1ZikNCi0gIHsNCi0JICBpbnQgcmV0Ow0KLQkgIHUzMiBwYWdlX29mZnNldCwgcGFnZV9zaXplLCBpOw0KLQkgIHN0cnVjdCBub3JfaW5mbyAqaW5mbyA9IHNwaV9ub3JfZmxhc2g7DQotDQotCSAgc29mdF9zcGluX2xvY2soTkFORF9TRkxPQ0spOw0KLQkgIG11dGV4X2xvY2soJm90cE11dGV4KTsNCi0gDQotCSAgbm9yX3dyaXRlX3JlZyhDTURfV1JFTiwgTlVMTCwgMCk7DQotCSAgDQotCSAgcGFnZV9vZmZzZXQgPSB0byAmIChpbmZvLT5wYWdlX3NpemUgLSAxKTsNCiAgIA0KLQkgIC8qIGRvIGFsbCB0aGUgYnl0ZXMgZml0IG9udG8gb25lIHBhZ2U/ICovDQotCSAgaWYgKHBhZ2Vfb2Zmc2V0ICsgbGVuIDw9IGluZm8tPnBhZ2Vfc2l6ZSkgew0KLQkJICByZXQgPSBzcGlfbm9yX3dyaXRlKHRvLCBsZW4sICh1aW50OF90ICopYnVmKTsNCi0JICB9IGVsc2Ugew0KLQkJICAvKiB0aGUgc2l6ZSBvZiBkYXRhIHJlbWFpbmluZyBvbiB0aGUgZmlyc3QgcGFnZSAqLw0KLQkJICBwYWdlX3NpemUgPSBpbmZvLT5wYWdlX3NpemUgLSBwYWdlX29mZnNldDsNCi0JCSAgcmV0ID0gc3BpX25vcl93cml0ZSh0bywgcGFnZV9zaXplLCAodWludDhfdCAqKWJ1Zik7DQotICANCi0JCSAgLyogcmVhZCBldmVyeXRoaW5nIGluIG5vci0+cGFnZV9zaXplIGNodW5rcyAqLw0KLQkJICBmb3IgKGkgPSBwYWdlX3NpemU7IGkgPCBsZW47IGkgKz0gcGFnZV9zaXplKSB7DQotCQkJICBwYWdlX3NpemUgPSBsZW4gLSBpOw0KLQkJCSAgaWYgKHBhZ2Vfc2l6ZSA+IGluZm8tPnBhZ2Vfc2l6ZSkNCi0JCQkJICBwYWdlX3NpemUgPSBpbmZvLT5wYWdlX3NpemU7DQotIA0KLQkJCSAgbm9yX3dyaXRlX3JlZyhDTURfV1JFTiwgTlVMTCwgMCk7DQotCQkJICByZXQgPSBzcGlfbm9yX3dyaXRlKHRvICsgaSwgcGFnZV9zaXplLCAoKHVpbnQ4X3QgKilidWYgKyBpKSk7DQotCQkgIH0NCi0JICB9DQotDQotCSAgbXV0ZXhfdW5sb2NrKCZvdHBNdXRleCk7DQotCSAgc29mdF9zcGluX3VubG9jayhOQU5EX1NGTE9DSyk7DQotICANCi0JICByZXR1cm4gcmV0Ow0KLSAgfQ0KICAgaW50IHNwaV9ub3JfcmVhZCh1aW50MzJfdCBmcm9tLCBzaXplX3QgbGVuLCB1X2NoYXIgKmJ1ZikNCiAgIHsNCiAJICBpbnQgcmV0Ow0KQEAgLTYxMyw3ICs1NzgsNjEgQEAKIAkgIGNzX2Nsb3NlKCk7Ly9zcHANCiAJICByZXR1cm4gMDsNCiAgIH0NCisNCisgICBpbnQgbm9yX3dyaXRlKHUzMiB0bywgdTMyIGxlbiwgdTMyIGJ1ZikNCisgIHsNCisJICBpbnQgcmV0Ow0KKwkgIHUzMiBwYWdlX29mZnNldCwgcGFnZV9zaXplLCBpOw0KKwkgIHN0cnVjdCBub3JfaW5mbyAqaW5mbyA9IHNwaV9ub3JfZmxhc2g7DQorCSAgY2hhciB0ZW1wX2FkZHJbNDA5Nl0gPSB7MH07DQorCSAgdW5zaWduZWQgbG9uZyBsb25nIHN0YXJ0X3RpbWUsZW5kX3RpbWUsZGVsdGFfdGltZSA9IDA7DQorDQorCSAgc29mdF9zcGluX2xvY2soTkFORF9TRkxPQ0spOw0KKwkgIG11dGV4X2xvY2soJm90cE11dGV4KTsNCisgDQorCSAgbm9yX3dyaXRlX3JlZyhDTURfV1JFTiwgTlVMTCwgMCk7DQorCSAgDQorCSAgcGFnZV9vZmZzZXQgPSB0byAmIChpbmZvLT5wYWdlX3NpemUgLSAxKTsNCiAgIA0KKwkgIC8qIGRvIGFsbCB0aGUgYnl0ZXMgZml0IG9udG8gb25lIHBhZ2U/ICovDQorCSAgaWYgKHBhZ2Vfb2Zmc2V0ICsgbGVuIDw9IGluZm8tPnBhZ2Vfc2l6ZSkgew0KKwkJICByZXQgPSBzcGlfbm9yX3dyaXRlKHRvLCBsZW4sICh1aW50OF90ICopYnVmKTsNCisJICB9IGVsc2Ugew0KKwkJICAvKiB0aGUgc2l6ZSBvZiBkYXRhIHJlbWFpbmluZyBvbiB0aGUgZmlyc3QgcGFnZSAqLw0KKwkJICBwYWdlX3NpemUgPSBpbmZvLT5wYWdlX3NpemUgLSBwYWdlX29mZnNldDsNCisJCSAgcmV0ID0gc3BpX25vcl93cml0ZSh0bywgcGFnZV9zaXplLCAodWludDhfdCAqKWJ1Zik7DQorICANCisJCSAgLyogcmVhZCBldmVyeXRoaW5nIGluIG5vci0+cGFnZV9zaXplIGNodW5rcyAqLw0KKwkJICBmb3IgKGkgPSBwYWdlX3NpemU7IGkgPCBsZW47IGkgKz0gcGFnZV9zaXplKSB7DQorCQkJICBwYWdlX3NpemUgPSBsZW4gLSBpOw0KKwkJCSAgaWYgKHBhZ2Vfc2l6ZSA+IGluZm8tPnBhZ2Vfc2l6ZSkNCisJCQkJICBwYWdlX3NpemUgPSBpbmZvLT5wYWdlX3NpemU7DQorIA0KKwkJCSAgbm9yX3dyaXRlX3JlZyhDTURfV1JFTiwgTlVMTCwgMCk7DQorCQkJICBzdGFydF90aW1lID0gY3B1X2Nsb2NrKDApPj4xMDsNCisJCQkgIHJldCA9IHNwaV9ub3Jfd3JpdGUodG8gKyBpLCBwYWdlX3NpemUsICgodWludDhfdCAqKWJ1ZiArIGkpKTsNCisJCQkgIGVuZF90aW1lID0gY3B1X2Nsb2NrKDApPj4xMDsNCisJCQkgIGRlbHRhX3RpbWUgPSBlbmRfdGltZSAtIHN0YXJ0X3RpbWU7DQorCQkJICAvL3ByaW50aygidGltZSBjb25zdW1lZDogJWxsZFxuIixkZWx0YV90aW1lKTsNCisJCQkgIHNwaV9ub3JfcmVhZCh0byArIGksIHBhZ2Vfc2l6ZSwgKCh1aW50OF90ICopdGVtcF9hZGRyKSk7IA0KKwkJCSAgd2hpbGUobWVtY21wKCgodWludDhfdCAqKWJ1ZiArIGkpLCAoKHVpbnQ4X3QgKil0ZW1wX2FkZHIpLGluZm8tPnBhZ2Vfc2l6ZSkpIHsNCisJCQkgIAkgICAgcHJpbnRrKCJhZGRyIDB4JXggd3JpdGUgZmFpbC5cbiIsdG8raSk7DQorCQkJCQlub3Jfd3JpdGVfcmVnKENNRF9XUkVOLCBOVUxMLCAwKTsNCisJCQkJCXN0YXJ0X3RpbWUgPSBjcHVfY2xvY2soMCk+PjEwOw0KKwkJCQkJcmV0ID0gc3BpX25vcl93cml0ZSh0byArIGksIHBhZ2Vfc2l6ZSwgKCh1aW50OF90ICopYnVmICsgaSkpOw0KKwkJCQkJZW5kX3RpbWUgPSBjcHVfY2xvY2soMCk+PjEwOw0KKwkJCQkJZGVsdGFfdGltZSA9IGVuZF90aW1lIC0gc3RhcnRfdGltZTsNCisJCQkJICAgIHByaW50aygidGltZSBjb25zdW1lZDogJWxsZFxuIixkZWx0YV90aW1lKTsNCisJCQkgICAgICAgIHNwaV9ub3JfcmVhZCh0byArIGksIHBhZ2Vfc2l6ZSwgKCh1aW50OF90ICopdGVtcF9hZGRyKSk7IA0KKwkJCSAgfQ0KKwkJICB9DQorCSAgfQ0KKw0KKwkgIG11dGV4X3VubG9jaygmb3RwTXV0ZXgpOw0KKwkgIHNvZnRfc3Bpbl91bmxvY2soTkFORF9TRkxPQ0spOw0KKyAgDQorCSAgcmV0dXJuIHJldDsNCisgIH0NCiAgIGludCBub3JfcmVhZCh1MzIgZnJvbSwgdTMyIGxlbiwgdTMyIHRvKQ0KICAgew0KIAkgIGludCByZXQ7DQpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zb2MvenRlL3RzYy96eC10c2Mtc3RyYXRlZ3kuYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvc29jL3p0ZS90c2MvengtdHNjLXN0cmF0ZWd5LmMKaW5kZXggYmY5MGIwYi4uM2FkODAwYyAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zb2MvenRlL3RzYy96eC10c2Mtc3RyYXRlZ3kuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3NvYy96dGUvdHNjL3p4LXRzYy1zdHJhdGVneS5jCkBAIC0xMDcsNiArMTA3LDggQEAKIGV4dGVybiBpbnQgengyOV9zZXRfZnJlcXVlbmN5KHVuc2lnbmVkIGludCBvbGRfaW5kZXgsdW5zaWduZWQgaW50IG5ld19pbmRleCk7DQogZXh0ZXJuIHVuc2lnbmVkIGludCB6eF9nZXRzcGVlZCh1bnNpZ25lZCBpbnQgY3B1KTsNCiAjZW5kaWYNCisNCitleHRlcm4gdm9pZCB6eDI5X3Jlc3RhcnQoY2hhciBzdHIsY29uc3QgY2hhciAqIGNtZCk7DQogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZnVuY3Rpb25zICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoNCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLw0KQEAgLTE3OCwxNyArMTgwLDIxIEBACiAJCXsNCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9VUFRSQU5TSU1JVFBPV0VSMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSAsU1RSVEVHWV9TVEFSVCk7DQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9MSU1JVF9MVEVfRE9XTlJBVEUyLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsNCisJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KIAkJfQ0KIAkJZWxzZSBpZih0ZW1wZXJhdHVyZT49VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzMpDQogCQl7ICAgDQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9MSU1JVF9MVEVfRE9XTlJBVEUyLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsNCisJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KIAkJfQ0KIAkJZWxzZSBpZih0ZW1wZXJhdHVyZT49VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzEpDQogCQl7CQ0KLQkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfTFRFX0RPV05SQVRFMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7DQorCQkJLy90c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KKwkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfUkFURSwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7DQogCQl9ICAgDQogCQllbHNlIGlmKHRlbXBlcmF0dXJlPj1Uc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfMCkNCiAJCXsNCisJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfSE9MRCk7DQogCQl9DQogCQllbHNlDQogCQl7CQ0KQEAgLTIwMiwxMiArMjA4LDE0IEBACiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfTFRFX1VQVFJBTlNJTUlUUE9XRVIyLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfTFRFX0RPV05SQVRFMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCisJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7DQogCQl9DQogCQllbHNlIGlmKHRlbXBlcmF0dXJlPFRzTnZEYXRhLlRocmVzaG9kc1twcm9iZV9udW1dLlRIUk9TSE9MRF8yKQ0KIAkJew0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfU0hVVERPV04sZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSxTVFJURUdZX1NUT1ApOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfQU5ZUkVTSURFTlQsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7DQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9MSU1JVF9MVEVfVVBUUkFOU0lNSVRQT1dFUjIgLGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7DQorCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9MSU1JVF9MVEVfRE9XTlJBVEUyLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOw0KIAkJfQ0KIAkJZWxzZSBpZih0ZW1wZXJhdHVyZTxUc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfNCkNCiAJCXsNCkBAIC0yNDEsMjQgKzI0OSwyMCBAQAogCQllbHNlIGlmKHRlbXBlcmF0dXJlPj1Uc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfNSkNCiAJCXsNCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9VUFRSQU5TSU1JVFBPV0VSMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSAsU1RSVEVHWV9TVEFSVCk7DQotCQkJLy8JdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9MSU1JVF9XX1VQVFJBTlNJTUlUUE9XRVIyLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dICxTVFJURUdZX1NUQVJUKTsJICAgDQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19SQVRFLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsNCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KLQkJCS8vCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfV19ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfREZTLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsvL3pEcnZQb3dfU2V0QXJtUHNDb3JlRnJlcShDTEszMTJNKTsJICAgDQogCQl9DQogCQllbHNlIGlmKHRlbXBlcmF0dXJlPj1Uc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfMykNCiAJCXsgICANCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfTFRFX0RPV05SQVRFMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7DQotCQkJLy8JdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9MSU1JVF9XX0RPV05SQVRFMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7CSAgIA0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfREZTLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsvL3pEcnZQb3dfU2V0QXJtUHNDb3JlRnJlcShDTEszMTJNKTsJICAgDQogCQl9DQogCQllbHNlIGlmKHRlbXBlcmF0dXJlPj1Uc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfMSkNCiAJCXsJDQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19SQVRFLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsNCi0JCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KLQkJCS8vCSAgIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfV19ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOwkgIAkJDQorCQkJLy90c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KIAkJfSAgIA0KIAkJZWxzZSBpZih0ZW1wZXJhdHVyZT49VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzApDQogCQl7DQpAQCAtMjc0LDEwICsyNzgsOCBAQAogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9TSFVURE9XTixnX2JpdF9wcm9iZVtwcm9iZV9udW1dLFNUUlRFR1lfU1RPUCk7DQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19BTllSRVNJREVOVCwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9VUFRSQU5TSU1JVFBPV0VSMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCi0JCQkvLwkgICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX1dfVVBUUkFOU0lNSVRQT1dFUjIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7CSAgIAkgICAJICAgDQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19SQVRFLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfTFRFX0RPV05SQVRFMiwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCi0JCQkvLwkgICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX1dfRE9XTlJBVEUyLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOwkgICANCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0RGUywgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsvLyB6RHJ2UG93X1NldEFybVBzQ29yZUZyZXEoQ0xLNjI0TSk7DQogCQl9DQogCQllbHNlIGlmKHRlbXBlcmF0dXJlPFRzTnZEYXRhLlRocmVzaG9kc1twcm9iZV9udW1dLlRIUk9TSE9MRF8yKQ0KQEAgLTI4NSw3ICsyODcsNyBAQAogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9TSFVURE9XTixnX2JpdF9wcm9iZVtwcm9iZV9udW1dLFNUUlRFR1lfU1RPUCk7DQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19BTllSRVNJREVOVCwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCiAJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9VUFRSQU5TSU1JVFBPV0VSMiAsZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCi0JCQkvLwkgICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX1dfVVBUUkFOU0lNSVRQT1dFUjIgLGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7CSAgIAkgICANCisJCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX0xURV9ET1dOUkFURTIsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7DQogCQkJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9ERlMsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7Ly8gekRydlBvd19TZXRBcm1Qc0NvcmVGcmVxKENMSzYyNE0pOw0KIAkJfQ0KIAkJZWxzZSBpZih0ZW1wZXJhdHVyZTxUc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfNCkNCkBAIC0yOTQsNyArMjk2LDYgQEAKIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfU0hVVERPV04sZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSxTVFJURUdZX1NUT1ApOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfQU5ZUkVTSURFTlQsZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSxTVFJURUdZX1NUT1ApOw0KIAkJCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfTElNSVRfTFRFX1VQVFJBTlNJTUlUUE9XRVIyLGdfYml0X3Byb2JlW3Byb2JlX251bV0sU1RSVEVHWV9TVE9QKTsNCi0JCQkvLwl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0xJTUlUX1dfVVBUUkFOU0lNSVRQT1dFUjIsZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSxTVFJURUdZX1NUT1ApOwkgICANCiAJCX0NCiAJCWVsc2UgaWYodGVtcGVyYXR1cmU8VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzYpDQogCQl7DQpAQCAtMzk4LDI1ICszOTksMjYgQEAKICAgIH0JDQogICAgZWxzZSBpZih0ZW1wZXJhdHVyZT49VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzcpDQogICAgew0KLQkgICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dICxTVFJURUdZX1NUQVJUKTsNCisJIC8vICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dICxTVFJURUdZX1NUQVJUKTsNCisJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9ERlMsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOwkgICANCiAgICB9DQogICAgZWxzZSBpZih0ZW1wZXJhdHVyZT49VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzUpDQogICAgew0KLQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KLQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0RGUywgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7Ly96RHJ2UG93X1NldEFybVBzQ29yZUZyZXEoQ0xLMzEyTSk7CSAgIA0KKwkvL3RzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfUkFURSwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7DQorCXRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfREZTLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsJICAgDQogICAgfQ0KICAgIGVsc2UgaWYodGVtcGVyYXR1cmU+PVRzTnZEYXRhLlRocmVzaG9kc1twcm9iZV9udW1dLlRIUk9TSE9MRF8zKQ0KICAgIHsgICANCi0JdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19SQVRFLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsNCi0JdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9ERlMsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOy8vekRydlBvd19TZXRBcm1Qc0NvcmVGcmVxKENMSzMxMk0pOwkgICANCisJLy90c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RBUlQpOw0KKwl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0RGUywgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7CSAgIA0KICAgIH0NCiAJZWxzZSBpZih0ZW1wZXJhdHVyZT49VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzEpDQogCXsJDQotCSAgIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfUkFURSwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVEFSVCk7DQorCSAgIC8vdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19SQVRFLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUQVJUKTsNCiAJfSAgIA0KIAllbHNlIGlmKHRlbXBlcmF0dXJlPj1Uc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfMCkNCiAgICB7DQotCQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX1JBVEUsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfSE9MRCk7DQorCQkvL3RzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfUkFURSwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9IT0xEKTsNCiAgICB9DQogICAgZWxzZQ0KICAgIHsJDQpAQCAtNDI3LDI1ICs0MjksMjUgQEAKICAgIGlmKHRlbXBlcmF0dXJlPFRzTnZEYXRhLlRocmVzaG9kc1twcm9iZV9udW1dLlRIUk9TSE9MRF8wKQ0KICAgIHsNCiAJICAgdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9TSFVURE9XTixnX2JpdF9wcm9iZVtwcm9iZV9udW1dLFNUUlRFR1lfU1RPUCk7DQotCSAgIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfQU5ZUkVTSURFTlQsIGdfYml0X3Byb2JlW3Byb2JlX251bV0sIFNUUlRFR1lfU1RPUCk7DQotCSAgIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfUkFURSwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCisJLy8gICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOw0KKwkgLy8gIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfUFNfUkFURSwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCiAJICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX0RGUywgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsvLyB6RHJ2UG93X1NldEFybVBzQ29yZUZyZXEoQ0xLNjI0TSk7DQogICAgfQ0KICAgIGVsc2UgaWYodGVtcGVyYXR1cmU8VHNOdkRhdGEuVGhyZXNob2RzW3Byb2JlX251bV0uVEhST1NIT0xEXzIpDQogICAgew0KIAkgICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1NIVVRET1dOLGdfYml0X3Byb2JlW3Byb2JlX251bV0sU1RSVEVHWV9TVE9QKTsNCi0JICAgdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9QU19BTllSRVNJREVOVCwgZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSwgU1RSVEVHWV9TVE9QKTsNCisJICAvLyB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOw0KIAkgIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfREZTLCBnX2JpdF9wcm9iZVtwcm9iZV9udW1dLCBTVFJURUdZX1NUT1ApOy8vIHpEcnZQb3dfU2V0QXJtUHNDb3JlRnJlcShDTEs2MjRNKTsNCiAgICB9DQogICAgZWxzZSBpZih0ZW1wZXJhdHVyZTxUc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfNCkNCiAgICB7DQogICAJdHNjdHJsX3NldF9zdHJhdGVneTJJcmFtKFRTQ1RSTF9TSFVURE9XTixnX2JpdF9wcm9iZVtwcm9iZV9udW1dLFNUUlRFR1lfU1RPUCk7IA0KLQl0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULGdfYml0X3Byb2JlW3Byb2JlX251bV0sU1RSVEVHWV9TVE9QKTsNCisJLy90c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULGdfYml0X3Byb2JlW3Byb2JlX251bV0sU1RSVEVHWV9TVE9QKTsNCiAgICB9DQogICAgZWxzZSBpZih0ZW1wZXJhdHVyZTxUc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfNikNCiAgICB7DQogCSAgIHRzY3RybF9zZXRfc3RyYXRlZ3kySXJhbShUU0NUUkxfU0hVVERPV04sZ19iaXRfcHJvYmVbcHJvYmVfbnVtXSxTVFJURUdZX1NUT1ApOw0KLQkgICB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULGdfYml0X3Byb2JlW3Byb2JlX251bV0sU1RSVEVHWV9TVE9QKTsNCisJICAvLyB0c2N0cmxfc2V0X3N0cmF0ZWd5MklyYW0oVFNDVFJMX1BTX0FOWVJFU0lERU5ULGdfYml0X3Byb2JlW3Byb2JlX251bV0sU1RSVEVHWV9TVE9QKTsNCiAgICB9ICAgDQogICAgZWxzZSBpZih0ZW1wZXJhdHVyZTxUc052RGF0YS5UaHJlc2hvZHNbcHJvYmVfbnVtXS5USFJPU0hPTERfOCkNCiAgICB7DQpAQCAtNTg3LDE0ICs1ODksMTUgQEAKIAlpZih6RHJ2VHNjX0dldFRzY0VuKCkgPT0gMHhCMikNCiAJew0KIAkJaWYoVHNOdkRhdGEuVXNlcl9FbiA9PSAweEIyKXsNCi0NCiAJCQkvKlVTRVIqLw0KIAkJCWlmKHRzY19yZWFkX3JlZyhUU0NUUkxfU0hVVERPV04pIT0wKXsNCiAJCQkJLyp1c2VyIHN0cmF0ZWd5IHN0YXJ0Ki8NCiAJCQkJdHNjX3NldF9yZWdfYml0cyhUU0NUUkxfQVAsQklUX1NIVVRET1dOLEJJVFNfRk9SX0FQUElSQU0sU1RSVEVHWV9TVEFSVCk7CQkJDQorCQkJCXNjX2RlYnVnX2luZm9fcmVjb3JkKE1PRFVMRV9JRF9BUF9UU0MsICJ0c2NfcmVib290ISEhXG4iICk7DQorCQkJCXp4MjlfcmVzdGFydChOVUxMLCAidHNjX3JlYm9vdCEhIVxuIik7DQogCQkJCQ0KIAkJCQlpZihnX3RzY19wcmludF9sb2dfZGVidWcpDQotCQkJCQl0c2NfcHJpbnRfbG9nKCJ1c2VyIHN0cmF0ZWd5IHN0YXJ0IHJlc2VydmUgXG4iKQ0KKwkJCQkJdHNjX3ByaW50X2xvZygidXNlciBzdHJhdGVneSBzdGFydCBcbiIpOw0KIAkJCX0NCiAJCQllbHNlew0KIAkJCQkvL3RzY19wcmludF9sb2coInVzZXIgc3RyYXRlZ3kgc3RvcCByZXNlcnZlIFxuIikNCmRpZmYgLS1naXQgYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3NvYy96dGUvdHNjL3p4LXRzYy5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zb2MvenRlL3RzYy96eC10c2MuYwppbmRleCA1ZDNiYmJhLi43YmQ0YjRhIDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3NvYy96dGUvdHNjL3p4LXRzYy5jCisrKyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvc29jL3p0ZS90c2MvengtdHNjLmMKQEAgLTM5LDYgKzM5LDEwIEBACiAjZGVmaW5lIElSQU1fVEVNUENPTVBfUkZEREFDIChJUkFNX0JBU0VfQUREUl9TTEFWRV9BRkMrMHg4KSAgLy9oaWdoMTZiaXQ6IHRoZSBBREMgdmFsdWUgb2YgdGVtcAkNCiAjZGVmaW5lIElSQU1fVEVNUENPTVBfUkZEVEVNUCAoSVJBTV9CQVNFX0FERFJfU0xBVkVfQUZDKzB4YykgIC8vdGVtcCBvZiBhZGNyZmQNCiANCisjZGVmaW5lIFJGRERBQ19MT1cJMQ0KKyNkZWZpbmUgUkZEREFDX0xPV0UJMTU5MQ0KKyNkZWZpbmUgUkZEREFDX0hJR0hFIDYwOTYNCisjZGVmaW5lIFJGRERBQ19ISUdICTgxOTENCiANCiB2b2xhdGlsZSB1MzIgZ19hZGMxX2ZsYWcgPSAwOy8vqKg/YWRjMaiuP6iuqLKorD8yYXBhMqikPz8/qKih6j8/qLBnX2FkYzFfZmxhZz0xDQogdm9sYXRpbGUgdTMyIGdfYWRjMl9mbGFnID0gMDsvL6ioP2FkYzKorj+orqiyqKw/MmFwYTKopD8/P6iooeo/P6iwZ19hZGMyX2ZsYWc9MQ0KQEAgLTU1NywxMSArNTYxLDQwIEBACiAJCWlmKGdfYWRjM19mbGFnPT0xKXsNCiAJCQlhZGNSZlZhbHVlID0gdHNjX2RhY19yZWFkKElSQU1fVEVNUENPTVBfREFDKTsgDQogCQkJdHNjX2dldF9wcm9iZV9hZGN2YWx1ZShhZGNSZlZhbHVlLCZ0ZW1wUmYsIDApOw0KKwkJCWlmKChhZGNSZlZhbHVlPFJGRERBQ19MT1cpfHwoYWRjUmZWYWx1ZT5SRkREQUNfSElHSCkpDQorCQkJew0KKwkJCQlwcmludGsoIiEhISEhISEoYWRjUmZWYWx1ZSA8ICVkKXx8KGFkY1JmVmFsdWUgPiAlZClcbiIsIFJGRERBQ19MT1csIFJGRERBQ19ISUdIKTsNCisJCQkJdGVtcFJmPTI1Ow0KKwkJCX0NCisJCQlpZigoYWRjUmZWYWx1ZT49UkZEREFDX0xPVykmJihhZGNSZlZhbHVlPD1SRkREQUNfTE9XRSkpDQorCQkJew0KKwkJCQlwcmludGsoImN1cmN1aXQgYnJlYWthZ2UoJWQ8PWFkY1JmVmFsdWU8PSAlZClcbiIsIFJGRERBQ19MT1csIFJGRERBQ19MT1dFKTsNCisJCQkJdGVtcFJmPSAtMTAwIDsNCisJCQl9DQorCQkJaWYoKGFkY1JmVmFsdWU+PVJGRERBQ19ISUdIRSkmJihhZGNSZlZhbHVlPD1SRkREQUNfSElHSCkpDQorCQkJew0KKwkJCQlwcmludGsoImN1cmN1aXQgc2hvcnQoJWQ8PWFkY1JmVmFsdWU8PSAlZClcbiIsIFJGRERBQ19ISUdIRSwgUkZEREFDX0hJR0gpOw0KKwkJCQl0ZW1wUmZkPSAtNzUgOw0KKwkJCX0JCQkNCiAJCX0NCiAJCWlmKFRzTnZEYXRhLkFkY1JGZF9Fbj09MHhCMil7CQ0KIAkJCWFkY1JmZFZhbHVlID0oenhfcmVhZF9yZWcoSVJBTV9URU1QQ09NUF9SRkREQUMpJjB4ZmZmZjAwMDApPj4xNjsgDQogCQkJdHNjX2dldF9wcm9iZV9hZGN2YWx1ZShhZGNSZmRWYWx1ZSwmdGVtcFJmZCwgMSk7DQotCQkJLy90ZW1wUmZkID0genhfcmVhZF9yZWcoSVJBTV9URU1QQ09NUF9SRkRURU1QKT4+MTA7IA0KKwkJCWlmKChhZGNSZmRWYWx1ZTxSRkREQUNfTE9XKXx8KGFkY1JmZFZhbHVlPlJGRERBQ19ISUdIKSkNCisJCQl7DQorCQkJCXByaW50aygiISEhISEhIShhZGNSZmRWYWx1ZSA8ICVkKXx8KGFkY1JmZFZhbHVlID4gJWQpXG4iLCBSRkREQUNfTE9XLCBSRkREQUNfSElHSCk7DQorCQkJCXRlbXBSZmQ9MjU7DQorCQkJfQ0KKwkJCWlmKChhZGNSZmRWYWx1ZT49UkZEREFDX0xPVykmJihhZGNSZmRWYWx1ZTw9UkZEREFDX0xPV0UpKQ0KKwkJCXsNCisJCQkJcHJpbnRrKCJjdXJjdWl0IGJyZWFrYWdlKCVkPD1hZGNSZmRWYWx1ZTw9ICVkKVxuIiwgUkZEREFDX0xPVywgUkZEREFDX0xPV0UpOw0KKwkJCQl0ZW1wUmZkPSAtMTAwIDsNCisJCQl9DQorCQkJaWYoKGFkY1JmZFZhbHVlPj1SRkREQUNfSElHSEUpJiYoYWRjUmZkVmFsdWU8PVJGRERBQ19ISUdIKSkNCisJCQl7DQorCQkJCXByaW50aygiY3VyY3VpdCBzaG9ydCglZDw9YWRjUmZkVmFsdWU8PSAlZClcbiIsIFJGRERBQ19ISUdIRSwgUkZEREFDX0hJR0gpOw0KKwkJCQl0ZW1wUmZkPSAtNzUgOw0KKwkJCX0JCQkNCiAJCX0NCiANCiAJCXRzY19sb2NrKCk7DQpAQCAtNTk4LDYgKzYzMSw4IEBACiAJCQkJdHNjX3ByaW50X2xvZygiYWRjMVZhbHVlPSVkLGFkYzJWYWx1ZT0lZCxhZGNSZlZhbHVlPSVkLHRlbXAxID0gJWQudGVtcDIgPSAlZC50ZW1wcmYgPSAlZC5cbiIsDQogCQkJCWFkYzFWYWx1ZSxhZGMyVmFsdWUsYWRjUmZWYWx1ZSx0ZW1wMSx0ZW1wMiwgZ190c19kYXRhX2luZm9bUFJPQkVfQURDUkZdW1RTX01FTUJFUl9URU1QXSApOw0KIAkJCX0NCisJCQl0c2NfcHJpbnRfbG9nKCJEZXRlY3RFbjoweCV4OyBBZGNSRmRfRW46MHgleDsgTW9kZW1yYXRlX0VuOjB4JXg7IFRhbnNtaXRQb3dlcl9FbjoweCV4OyBEZnNfRW46MHgleDsgVXNlcl9FbjoweCV4OyIsDQorCQkJCVRzTnZEYXRhLkRldGVjdEVuLCBUc052RGF0YS5BZGNSRmRfRW4sIFRzTnZEYXRhLk1vZGVtcmF0ZV9FbiwgVHNOdkRhdGEuVGFuc21pdFBvd2VyX0VuLCBUc052RGF0YS5EZnNfRW4sIFRzTnZEYXRhLlVzZXJfRW4gKTsNCiAJCX0NCiANCiAJCWlmKCgoKHRzY19yZWNvcmRfdGltZV9jbnQqVFNfUE9MTElOR19USU1FX1MpJXRzY19yZWNvcmRfdGltZSk9PTApICYmIHRzY19yZWNvcmRfZmxhZykNCmRpZmYgLS1naXQgYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3N0YWdpbmcvdm9pY2VkcnYvTWFrZWZpbGUgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3N0YWdpbmcvdm9pY2VkcnYvTWFrZWZpbGUKb2xkIG1vZGUgMTAwNjQ0Cm5ldyBtb2RlIDEwMDc1NQppbmRleCAyYTU0MGViLi5mMTYyMmRmCi0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvc3RhZ2luZy92b2ljZWRydi9NYWtlZmlsZQorKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3N0YWdpbmcvdm9pY2VkcnYvTWFrZWZpbGUKQEAgLTQsNiArNCw3IEBACiAKIAogY2NmbGFncy15ICs9IC1JZHJpdmVycy9zdGFnaW5nL3ZvaWNlZHJ2L2luY2x1ZGUKK2NjZmxhZ3MteSArPSAtSSQoVE9QRElSKS9wdWIvcHJvamVjdC8kKENISVBfTkFNRSkvaW5jbHVkZS9udgogCiBvYmotJChDT05GSUdfVk9JQ0VfRFJWKQkrPSB2b2ljZV9kcnYubwogdm9pY2VfZHJ2LSQoQ09ORklHX1ZPSUNFX0RSVikgOj0gdm9pY2UubwpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zdGFnaW5nL3ZvaWNlZHJ2L3ZvaWNlLmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3N0YWdpbmcvdm9pY2VkcnYvdm9pY2UuYwpvbGQgbW9kZSAxMDA2NDQKbmV3IG1vZGUgMTAwNzU1CmluZGV4IGE0ZTM5YTAuLmE0N2FjZjAKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zdGFnaW5nL3ZvaWNlZHJ2L3ZvaWNlLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy9zdGFnaW5nL3ZvaWNlZHJ2L3ZvaWNlLmMKQEAgLTExLDYgKzExLDcgQEAKIAogI2luY2x1ZGUgInZvaWNlLmgiCiAKKyNpbmNsdWRlICJSV052Q29uZmlnLmgiCiAKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIE1PRFVMRV9BVVRIT1IoInh4cSIpOwpAQCAtNDQsNiArNDUsMzQgQEAKIAogI2lmZGVmIF9VU0VfVkVISUNMRV9EQwogCisjZGVmaW5lIFZPSUNFX05WUldfTUFYX0xFTiAoOCAqIDEwMjQpCisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyICp2b2ljZV9udnJ3X3BhcmFtID0gTlVMTDsKKworc3RhdGljIHZvaWQgdm9pY2VfU2V0Vm9pY2VOVlJXKHZvaWQpCit7CisJdW5zaWduZWQgY2hhciB2b2ljZV9udl91cGRhdGUgPSAwOworCisgICAgd2hpbGUoMSl7CisgICAgICAgIENQUFNfRlVOQyhjcHBzX2NhbGxiYWNrcywgekRydlZwX1VwZGF0ZVZvaWNlTnYpKCZ2b2ljZV9udl91cGRhdGUpOworICAgICAgICAKKyAgICAgICAgaWYoMSA9PSB2b2ljZV9udl91cGRhdGUpeworICAgICAgICAgICAgcHJpbnRfYXVkaW8oInZvaWNlX1NldFZvaWNlTlZSVyB2b2ljZV9udl91cGRhdGUgPSAlZCFcbiIsIHZvaWNlX252X3VwZGF0ZSk7IAorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZihDUFBTX0ZVTkMoY3Bwc19jYWxsYmFja3MsIHpPc3NfTnZJdGVtV3JpdGUpKE9TX0ZMQVNIX1ZPSUNFX1JXX05PTkZBQ19CQVNFX0FERFIsIFwKKyAgICAgICAgKHZvaWNlX252cndfcGFyYW0gKyA4KSwgKigoaW50Kil2b2ljZV9udnJ3X3BhcmFtICsgMSkpKXsKKyAgICAJcHJpbnRfYXVkaW8oInZvaWNlX1NldFZvaWNlTlZSVyB6T3NzX052SXRlbVdyaXRlIGVycm9yLCB1cGRhdGUgdm9pY2VfbnZydyBmYWlsIVxuIik7CisgICAgfQorICAgIGVsc2V7CisgICAgICAgIHByaW50X2F1ZGlvKCJ2b2ljZV9TZXRWb2ljZU5WUlcgek9zc19Odkl0ZW1Xcml0ZSBlbmQsIHdyaXRlIGxlbiA9ICVkIVxuIiwgKigoaW50Kil2b2ljZV9udnJ3X3BhcmFtICsgMSkpOworICAgIH0KKyAgICAKKwlyZXR1cm47Cit9CisKIHN0YXRpYyBpbnQgdm9pY2VfU2V0TXV0ZShib29sIGVuYWJsZSkKIHsKIAlpbnQgcmV0ID0gMDsKQEAgLTMyNCw3ICszNTMsNyBAQAogCQlUX1ZvaWNlX1BhcmEgcGFyYTsKIAkJLy9wcl9pbmZvKCJzdGFydCB2b2x0ZSByZWFkIFxuIik7CiAJCWlmIChjb3B5X2Zyb21fdXNlcigmcGFyYSwgYXJncCwgc2l6ZW9mKHBhcmEpKSkgewotCQkJcHJpbnRfYXVkaW8oInZvbHRlX2lvY3RsICBzdG9wIGNvcHlfdG9fdXNlciBlcnIhXG4iKTsKKwkJCXByaW50X2F1ZGlvKCJ2b2ljZV9pb2N0bCAgc3RvcCBjb3B5X3RvX3VzZXIgZXJyIVxuIik7CiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJfQogCkBAIC0zMzgsNyArMzY3LDcgQEAKIAkJVF9Wb2ljZV9QYXJhIHBhcmE7CiAKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZwYXJhLCBhcmdwLCBzaXplb2YocGFyYSkpKSB7Ci0JCQlwcmludF9hdWRpbygidm9sdGVfaW9jdGwgIHN0b3AgY29weV90b191c2VyIGVyciFcbiIpOworCQkJcHJpbnRfYXVkaW8oInZvaWNlX2lvY3RsICBzdG9wIGNvcHlfdG9fdXNlciBlcnIhXG4iKTsKIAkJCXJldHVybiAtRUZBVUxUOwogCQl9CiAJCXJldCA9ICB2b2ljZV9zdG9wKHBhcmEpOwpAQCAtMzUyLDcgKzM4MSw3IEBACiAJCWludCBwYXJhOwogCiAJCWlmIChjb3B5X2Zyb21fdXNlcigmcGFyYSwgYXJncCwgc2l6ZW9mKHBhcmEpKSkgewotCQkJcHJpbnRfYXVkaW8oInZvbHRlX2lvY3RsICBzZXQgdm9sIGNvcHlfdG9fdXNlciBlcnIhXG4iKTsKKwkJCXByaW50X2F1ZGlvKCJ2b2ljZV9pb2N0bCAgc2V0IHZvbCBjb3B5X3RvX3VzZXIgZXJyIVxuIik7CiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJfQogCQlyZXQgPSB2b2ljZV9TZXRWb2wocGFyYSk7CkBAIC0zNzcsNyArNDA2LDcgQEAKIAkJYm9vbCBwYXJhOwogCiAJCWlmIChjb3B5X2Zyb21fdXNlcigmcGFyYSwgYXJncCwgc2l6ZW9mKHBhcmEpKSkgewotCQkJcHJpbnRfYXVkaW8oInZvbHRlX2lvY3RsICBzZXQgdm9sIGNvcHlfdG9fdXNlciBlcnIhXG4iKTsKKwkJCXByaW50X2F1ZGlvKCJ2b2ljZV9pb2N0bCAgc2V0IHZvbCBjb3B5X3RvX3VzZXIgZXJyIVxuIik7CiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJfQogCQlyZXQgPSB2b2ljZV9TZXRNdXRlKHBhcmEpOwpAQCAtNDAyLDcgKzQzMSw3IEBACiAJCWludCBwYXJhOwogCiAJCWlmIChjb3B5X2Zyb21fdXNlcigmcGFyYSwgYXJncCwgc2l6ZW9mKHBhcmEpKSkgewotCQkJcHJpbnRfYXVkaW8oInZvbHRlX2lvY3RsICBzZXQgcGF0aCBjb3B5X3RvX3VzZXIgZXJyIVxuIik7CisJCQlwcmludF9hdWRpbygidm9pY2VfaW9jdGwgIHNldCBwYXRoIGNvcHlfdG9fdXNlciBlcnIhXG4iKTsKIAkJCXJldHVybiAtRUZBVUxUOwogCQl9CiAJCXJldCA9IHZvaWNlX1NldFBhdGgocGFyYSk7CkBAIC00MjEsNiArNDUwLDI4IEBACiAJCX0KIAkJYnJlYWs7CiAJfQorCisgICAgY2FzZSBWT0lDRV9JT0NUTF9TRVRfVk9JQ0VfTlZSVzogeworICAgICAgICB2b2ljZV9udnJ3X3BhcmFtID0ga3phbGxvYygoMiAqIHNpemVvZihpbnQpICsgVk9JQ0VfTlZSV19NQVhfTEVOKSwgR0ZQX0tFUk5FTCk7CisgICAgICAgIGlmKCF2b2ljZV9udnJ3X3BhcmFtKXsKKyAgICAgICAgICAgIHByaW50X2F1ZGlvKCJ2b2ljZV9pb2N0bCB2b2ljZV9udnJ3X3BhcmFtIG1hbGxvYyBmYWlsIVxuIik7CisgICAgICAgICAgICByZXR1cm4gLUVGQVVMVDsKKyAgICAgICAgfQorICAgIAorCQlpZiAoY29weV9mcm9tX3VzZXIodm9pY2VfbnZyd19wYXJhbSwgYXJncCwgMiAqIHNpemVvZihpbnQpICsgVk9JQ0VfTlZSV19NQVhfTEVOKSl7CisJCQlwcmludF9hdWRpbygidm9pY2VfaW9jdGwgIHNldCB2b2ljZSBudnJ3IGNvcHlfZnJvbV91c2VyIGVyciFcbiIpOworCQkJcmV0dXJuIC1FRkFVTFQ7CisJCX0KKworICAgICAgICB2b2ljZV9TZXRWb2ljZU5WUlcoKTsKKworICAgICAgICBpZih2b2ljZV9udnJ3X3BhcmFtKXsKKyAgICAgICAgICAgIGtmcmVlKHZvaWNlX252cndfcGFyYW0pOworICAgICAgICAgICAgdm9pY2VfbnZyd19wYXJhbSA9IE5VTEw7CisgICAgICAgIH0KKyAgICAgICAgCisJCWJyZWFrOworCX0KICNlbmRpZgogCiAJY2FzZSBWT0lDRV9JT0NUTF9HRVRfU0xJQ19VU0VfRkxBRzogewpAQCAtNDQxLDcgKzQ5Miw3IEBACiAJCWludCBwYXRoOwogCiAJCWlmIChjb3B5X2Zyb21fdXNlcigmcGF0aCwgYXJncCwgc2l6ZW9mKHBhdGgpKSkgewotCQkJcHJpbnRfYXVkaW8oInZvbHRlX2lvY3RsICB6RHJ2VnBfTG9vcCBjb3B5X3RvX3VzZXIgZXJyIVxuIik7CisJCQlwcmludF9hdWRpbygidm9pY2VfaW9jdGwgIHpEcnZWcF9Mb29wIGNvcHlfdG9fdXNlciBlcnIhXG4iKTsKIAkJCXJldHVybiAtRUZBVUxUOwogCQl9CiAJCXJldCA9IENQUFNfRlVOQyhjcHBzX2NhbGxiYWNrcywgekRydlZwX0xvb3ApKHBhdGgpOwpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy90dHkvc2VyaWFsL3p4MjlfdWFydC5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy90dHkvc2VyaWFsL3p4MjlfdWFydC5jCmluZGV4IGU1OTlmNzkuLmJiNmUxYzYgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvdHR5L3NlcmlhbC96eDI5X3VhcnQuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3R0eS9zZXJpYWwvengyOV91YXJ0LmMKQEAgLTMzNjYsMTEgKzMzNjYsMTEgQEAKICNlbmRpZgogCiAjaWYgQ09ORklHX1NFUklBTF9aWDI5X0RNQQotCWlmKHBkZXYtPmlkICE9IDEpIC8vencud2FuZyBtb2RpZnkgZm9yIFQxMDZCVUctNTMxIG9uIDIwMjQwMzA0Ci0JCXsKKwlpZihwZGV2LT5pZCAhPSBERUJVR19DT05TT0xFKQorCXsKIAkJdWFydF9kbWFfaW5pdChwb3J0KTsKIAkJcHJpbnRrKEtFUk5fSU5GTyAiWyVzXVslZF1VQVJUIERNQSBpcyBPUEVORUQlZFxuIixfX2Z1bmNfXyxfX0xJTkVfXyxwZGV2LT5pZCk7Ci0JCX0KKwl9CiAjZW5kaWYKIAogICAgIHJldD11YXJ0X2FkZF9vbmVfcG9ydCgmengyOV91YXJ0X2RyaXZlciwgJnBvcnQtPnBvcnQpOwpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZHdjX290Zy9kd2Nfb3RnX2RyaXZlci5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZHdjX290Zy9kd2Nfb3RnX2RyaXZlci5jCmluZGV4IDk5N2FkM2MuLjNjNWZlZGIgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvdXNiL2R3Y19vdGcvZHdjX290Z19kcml2ZXIuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9kd2Nfb3RnL2R3Y19vdGdfZHJpdmVyLmMKQEAgLTgwMCw5ICs4MDAsOSBAQAogCWR3Y19vdGdfZGV2aWNlLT5vc19kZXAuYmFzZT0gaW9yZW1hcChpb21lbS0+c3RhcnQsIHJlc291cmNlX3NpemUoaW9tZW0pKTsKIAogI2lmZGVmIENPTkZJR19SQU1EVU1QCi0JcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoInVzYl9nbG9iYWwuYmluIiwgWlgyOV9VU0JfR0xPQkFMX1JFRywgVVNCX0dMT0JBTF9TSVpFLCAwLCBSQU1EVU1QX0ZMQUdfSEFTX0VYVEVSTkFMLCB1c2JfZ2xvYmFsX3JlZyk7Ci0JcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoInVzYl9kZXZpY2UuYmluIiwgWlgyOV9VU0JfREVWSUNFX1JFRywgVVNCX0RFVklDRV9TSVpFLCAwLCBSQU1EVU1QX0ZMQUdfSEFTX0VYVEVSTkFMLCB1c2JfZGV2aWNlX3JlZyk7Ci0JcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoInVzYl9wd3JfY2xrLmJpbiIsIFpYMjlfVVNCX1BXUl9DTEtfUkVHLCBVU0JfUFdSX0NMS19TSVpFLCAwLCBSQU1EVU1QX0ZMQUdfSEFTX0VYVEVSTkFMLCB1c2JfcHdyX2Nsa19yZWcpOworCXJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKCJ1c2JfZ2xvYmFsLmJpbiIsIFpYMjlfVVNCX0dMT0JBTF9SRUcsIFVTQl9HTE9CQUxfU0laRSwgMCwgUkFNRFVNUF9GTEFHX0hBU19FWFRFUk5BTHxSQU1EVU1QX0ZMQUdfTEVWRUxfTE9XLCB1c2JfZ2xvYmFsX3JlZyk7CisJcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoInVzYl9kZXZpY2UuYmluIiwgWlgyOV9VU0JfREVWSUNFX1JFRywgVVNCX0RFVklDRV9TSVpFLCAwLCBSQU1EVU1QX0ZMQUdfSEFTX0VYVEVSTkFMfFJBTURVTVBfRkxBR19MRVZFTF9MT1csIHVzYl9kZXZpY2VfcmVnKTsKKwlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgidXNiX3B3cl9jbGsuYmluIiwgWlgyOV9VU0JfUFdSX0NMS19SRUcsIFVTQl9QV1JfQ0xLX1NJWkUsIDAsIFJBTURVTVBfRkxBR19IQVNfRVhURVJOQUx8UkFNRFVNUF9GTEFHX0xFVkVMX0xPVywgdXNiX3B3cl9jbGtfcmVnKTsKICNlbmRpZgogCiAjaWYgMApkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZHdjX290Zy9kd2Nfb3RnX3B3ci5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZHdjX290Zy9kd2Nfb3RnX3B3ci5jCm9sZCBtb2RlIDEwMDY0NApuZXcgbW9kZSAxMDA3NTUKaW5kZXggY2IwYjQ4OC4uYjJiOWE4ZgotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9kd2Nfb3RnL2R3Y19vdGdfcHdyLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZHdjX290Zy9kd2Nfb3RnX3B3ci5jCkBAIC0yNzAsNyArMjcwLDcgQEAKIAkJfQogCQlkd2Nfb3RnX2hhbF9zdGF0ZS5jbGtfc3RhdGUgPSAxOwogCQljbGtfZW5hYmxlKHBjbGspOwotLy8JCWR3Y19jaGdfdWRlbGF5KDIwKTsKKwkJZHdjX2NoZ191ZGVsYXkoMjApOwogCQljbGtfZW5hYmxlKHdjbGspOwogCQlVU0JIQUxfREJHKCIqKkVOQUJMRSBDTE9DSyoqIik7CiAJfWVsc2V7CkBAIC0yODEsNiArMjgxLDcgQEAKIAkJZHdjX290Z19oYWxfc3RhdGUuY2xrX3N0YXRlID0gMDsKIC8vCQlkd2NfY2hnX3VkZWxheSg1KTsKIAkJY2xrX2Rpc2FibGUocGNsayk7CisJCWR3Y19jaGdfdWRlbGF5KDIwKTsKIAkJY2xrX2Rpc2FibGUod2Nsayk7CiAJCVVTQkhBTF9EQkcoIioqRElTQUJMRSBDTE9DSyoqIik7CiAJfQpAQCAtMzM3LDYgKzMzOCw3IEBACiAJLy91c2IgIGNsb2NrIGVuYWJsZQogCWR3Y19vdGdfY2xrX2VuYWJsZSgxKTsKIAkKKwlkd2NfY2hnX3VkZWxheSgyMDAwKTsKIAkvLyB1c2IgIGFoYiBidXMgcmVzZXQKIAlyZWdfc3Bpbl9sb2NrKCk7CiAJdmFsdWUgPSBpb3JlYWQzMihaWDI5X1NPQ19VU0JfUlNURU4pOwpAQCAtMzgyLDcgKzM4NCw3IEBACiAJdmFsdWUgIHw9ICgxPDwzKTsKIAlpb3dyaXRlMzIodmFsdWUsWlgyOV9TT0NfVVNCX1JTVEVOKTsKIAlyZWdfc3Bpbl91bmxvY2soKTsKLQlkd2NfY2hnX3VkZWxheSgxMCk7CisJZHdjX2NoZ191ZGVsYXkoMTAwMCk7CiAKIAl2YWx1ZSA9IDA7CiAJd2hpbGUoKGlvcmVhZDMyKFpYMjlfU09DX1VTQl9SRVNFVF9TVEFURSkmMHgwMikgPT0gMCkKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvdXNiL2dhZGdldC9hZGJfc2VydmVyLmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvYWRiX3NlcnZlci5jCmluZGV4IDg0MjY0MzEuLmUzYTI0ZmUgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvdXNiL2dhZGdldC9hZGJfc2VydmVyLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZ2FkZ2V0L2FkYl9zZXJ2ZXIuYwpAQCAtNTQ0LDcgKzU0NCw3IEBACiAJd2hpbGUoIWt0aHJlYWRfc2hvdWxkX3N0b3AoKSl7CQogCQkvKiB3ZSB3aWxsIGJsb2NrIHVudGlsIHdlJ3JlIG9ubGluZSAqLwogCQl3aGlsZSAoIWRldi0+YWdlbnRfc3RhcnQpIHsKLQkJCVVTQlNUQUNLX0RCRygiYWRiX3JwbXNnX3JlY3ZfdGhyZWFkOiB3YWl0aW5nIGZvcmFndF9zdGFydF93YWl0XG4iKTsKKwkJCVVTQlNUQUNLX0RCRygiYWRiX3JwbXNnX3JlY3ZfdGhyZWFkOiB3YWl0aW5nIGZvciBhZ3Rfc3RhcnRfd2FpdFxuIik7CiAJCQlyZXQgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoZGV2LT5hZ3Rfc3RhcnRfd2FpdCwKIAkJCQkJKCBkZXYtPmFnZW50X3N0YXJ0IHx8a3RocmVhZF9zaG91bGRfc3RvcCgpKSk7CiAJCQlpZiAocmV0IDwgMCkgewpAQCAtNTU4LDE4ICs1NTgsMjcgQEAKIAkJCVVTQlNUQUNLX0RCRygidW5iaW5kIHRocmVhZCBzdG9wIik7CiAJCQlicmVhazsKIAkJfQorCQlpZighZGV2LT5hZ2VudF9zdGFydCl7CisJCQlVU0JTVEFDS19EQkcoImFkYl9ycG1zZ19yZWN2X3RocmVhZDogYWdlbnRfc3RhcnQgbm90IHN0YXJ0XG4iKTsKKwkJCWNvbnRpbnVlOworCQl9CiAJCQlVU0JTVEFDS19EQkcoImFkYl9ycG1zZ19yZWN2X3RocmVhZDogbm93IHNlbmQgcmVxdWVzdFxuIik7CiAKIHJlcXVldWVfcmVxOgorCisJCWlmKCFkZXYtPm9ubGluZSl7CisJCQlVU0JTVEFDS19EQkcoInJwbXNnX3JlY3YgZGV2IGlzIG9mZmxpbmUsIGFnZW50X3N0YXJ0OiVkXG4iLCBkZXYtPmFnZW50X3N0YXJ0KTsKKwkJCXIgPSAtRUlPOworCQkJZ290byBkb25lOworCQl9CQorCQlpZighZGV2LT5yeF9yZXEpeworCQkJVVNCU1RBQ0tfREJHKCJhZGJfcnBtc2dfcmVjdl90aHJlYWQsIHJ4X3JlcSBpcyBOVUxMXG4iKTsKKwkJCWNvbnRpbnVlOworCQl9CiAJCS8qIHF1ZXVlIGEgcmVxdWVzdCAqLwogCQlyZXEgPSBkZXYtPnJ4X3JlcTsKIAkJcmVxLT5sZW5ndGggPSBBREJfQlVMS19CVUZGRVJfU0laRTsKIAkJZGV2LT5yeF9kb25lID0gMDsKLQkJaWYoIWRldi0+b25saW5lKXsKLQkJCVVTQlNUQUNLX0RCRygicnBtc2dfcmVjdiBkZXYgaXMgb2ZmbGluZVxuIik7Ci0JCQlyID0gLUVJTzsKLQkJCWdvdG8gZG9uZTsKLQkJfQogI2lmIDAJCQogCQlpZihhdG9taWNfcmVhZCgmZGV2LT5hZGJfcmVhZF9mbGFnKSl7CiAJCQlwcmludGsoIlxuYWRiX3JwbXNnX3JlY3ZfdGhyZWFkIGFkYl9yZWFkX2ZsYWcsIHdhaXRfcmVhZF93cVxuIik7CmRpZmYgLS1naXQgYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvYW5kcm9pZC5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZ2FkZ2V0L2FuZHJvaWQuYwppbmRleCBjYjRhNGNjLi5kNDU2ZGRkIDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvYW5kcm9pZC5jCisrKyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvdXNiL2dhZGdldC9hbmRyb2lkLmMKQEAgLTc5LDYgKzc5LDcgQEAKIAogI2lmbmRlZiBDT05GSUdfU1lTVEVNX1JFQ09WRVJZCiBpbnQgekRydk5hbmRfV3JpdGVCb290ZmxhZyggaW50IGZsYWcgKTsKK3Vuc2lnbmVkIGludCB6RHJ2TmFuZF9SZWFkQm9vdGZsYWcodm9pZCk7CiAjZW5kaWYKIAogI2RlZmluZSBwcl9lcnIJCVVTQl9ERUJVRwpAQCAtMzE5Myw4ICszMTk0LDE2IEBACiAJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjZGV2LT5sb2NrLCBmbGFncyk7CiAJCQkKIAkJCWJyZWFrOwotCQkvL2Nhc2UgOgotCQkvLwlicmVhazsKKwkJY2FzZSBVU0JfUlBNU0dfR0VUX1VTQl9ETF9TVEFURToKKwkJCXRfcmVzcC0+Y21kID0gVVNCX1JQTVNHX0dFVF9VU0JfRExfU1RBVEU7CisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmY2Rldi0+bG9jaywgZmxhZ3MpOworI2lmbmRlZiBDT05GSUdfU1lTVEVNX1JFQ09WRVJZCQkJCisJCQkvLzE6ZGxfb2ZmOzA6ZGxfb2VuCisJCQluID0gekRydk5hbmRfUmVhZEJvb3RmbGFnKCk7CQkJCisJCQlzcHJpbnRmKHRfcmVzcC0+cGFyYW0sICIlZFxuIixuKTsKKyNlbmRpZgkJCQorCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2Rldi0+bG9jaywgZmxhZ3MpOwkJCQorCQkJYnJlYWs7CiAJCS8vY2FzZSA6CiAJCS8vCWJyZWFrOwogCQlkZWZhdWx0OgpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfYWRiLmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvZl9hZGIuYwppbmRleCBhMmFlN2M5Li45MWMxYzYyIDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvZl9hZGIuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvZl9hZGIuYwpAQCAtMzc1LDE1ICszNzUsMTYgQEAKICNlbmRpZgkKIAogcmVxdWV1ZV9yZXE6Ci0JLyogcXVldWUgYSByZXF1ZXN0ICovCi0JcmVxID0gZGV2LT5yeF9yZXE7Ci0JcmVxLT5sZW5ndGggPSBjb3VudDsKLQlkZXYtPnJ4X2RvbmUgPSAwOwogCWlmKCFkZXYtPm9ubGluZSl7CiAJCVVTQlNUQUNLX0RCRygiYWRiX3JlYWQgZGV2IGlzIG9mZmxpbmVcbiIpOwogCQlyID0gLUVJTzsKIAkJZ290byBkb25lOwogCX0KKwkvKiBxdWV1ZSBhIHJlcXVlc3QgKi8KKwlyZXEgPSBkZXYtPnJ4X3JlcTsKKwlyZXEtPmxlbmd0aCA9IGNvdW50OworCWRldi0+cnhfZG9uZSA9IDA7CisKIAkJVVNCU1RBQ0tfREJHKCJhZGJfcmVhZCB3YWl0aW5nIHVzYl9lcF9xdWV1ZSBcbiIpOwogCXJldCA9IHVzYl9lcF9xdWV1ZShkZXYtPmVwX291dCwgcmVxLCBHRlBfQVRPTUlDKTsKIAlpZiAocmV0IDwgMCkgewpAQCAtNzExLDYgKzcxMiw3IEBACiAJfQogI2VuZGlmCQogCWFkYl9yZXF1ZXN0X2ZyZWUoZGV2LT5yeF9yZXEsIGRldi0+ZXBfb3V0KTsKKwlkZXYtPnJ4X3JlcSA9IE5VTEw7CiAJd2hpbGUgKChyZXEgPSBhZGJfcmVxX2dldChkZXYsICZkZXYtPnR4X2lkbGUpKSkKIAkJYWRiX3JlcXVlc3RfZnJlZShyZXEsIGRldi0+ZXBfaW4pOwogfQpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZ2FkZ2V0L3VzYl9uZXRsaW5rLmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvdXNiX25ldGxpbmsuYwppbmRleCBjMDQyYTc4Li45YWFmZDNiIDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvdXNiX25ldGxpbmsuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvdXNiX25ldGxpbmsuYwpAQCAtMzIsOCArMzIsOSBAQAogDQogZXh0ZXJuIGludCBhZGJfZW5hYmxlX3JwbXNnX2FnZW50KGludCBmbGFnKTsNCiBleHRlcm4gaW50IGFkYl9ycG1zZ19hZ2VudF9zdGF0ZSh2b2lkKTsNCi0JaW50IHN3aXRjaF9tb2RlID0gMDsNCi0JaW50IHNpbXVsYXRlX3BsdWcgPSAwOw0KK2ludCBzd2l0Y2hfbW9kZSA9IDA7DQorDQoraW50IHNpbXVsYXRlX3BsdWcgPSAwOw0KIAlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgc3dpdGNoX3VzYm1vZGU7DQogZXh0ZXJuIGludCB1c2JfcGx1Z19ub3RpZnlfYXAoZV91c2JfcnBtc2dfY21kX3R5cGUgcGx1Z190eXBlKTsNCiAJc3RydWN0IGRlbGF5ZWRfd29yayBwbHVnX25vdGlmeV9kd29yazsNCkBAIC0xMDQwLDcgKzEwNDEsNyBAQAogfQ0KIEVYUE9SVF9TWU1CT0xfR1BMKHVzYl9zZXRfcnBtc2dfcmVzcCk7DQogDQotdm9pZCB1c2JfcGFyc2VfY2FwX25vdGlmeShpbnQgdHlwZSkNCit2b2lkIHVzYl9wYXJzZV9jYXBfbm90aWZ5KGludCB0eXBlLCBpbnQgcGFyYW0pDQogewkNCiAJaW50IGN1cl91c2Jtb2RlID0gMDsNCiAJDQpAQCAtMTE0Niw4ICsxMTQ3LDI3IEBACiAjZW5kaWYJCQkNCiAJCQlicmVhazsNCiAJCWNhc2UgVVNCX1JQTVNHX1NJTVVMQVRFX1BMVUc6DQotCQkJc2ltdWxhdGVfcGx1ZyA9IDE7DQotCQkJdXNiX3JlY29yZF9kYmdpbmZvKFVTQl9TSU1VTEFURV9QTFVHLCAwLCAwKTsNCisJCQlpZihwYXJhbSAhPSAwKXsNCisJCQkJLyp0aGlzIGlzIGZvciB2ZWhpY2xlICAgDQorCQkJCSAqb24gdXNlcm1vZGUsb3Blbi9jbG9zZSBuZXQvYWRiIG5lZWQgdG8gdGFrZSBlZmZlY3QgaW1tZWRpYXRlbHksDQorCQkJCSAqc28gd2hpbGUgcGFyYW0gbm90IDAsIG1lYW5zIHdlIG5lZWQgdG8gZG8gdGhpcyBhY3Rpb24uDQorCQkJCSAqIGFuZCBzZW5kIG5ldGxpbmsgY2hhbmdlIHNnIHRvIHVzZXIgdGhyZWFkICAgdG8gcmVyZWFkIHRoZSBudiBjb25maWcNCisJCQkJICogYW5kIHJlZW51bSBhZ2Fpbg0KKwkJCQkgKi8NCisJCQkJY3VyX3VzYm1vZGUgPSBnZXRfdXNiX2VudW1fbW9kZSgpOwkNCisJCQkJcHJpbnRrKCJVU0JfUlBNU0dfU0lNVUxBVEVfUExVRywgY3VyX21vZGU6JWRcbiIsIGN1cl91c2Jtb2RlKTsNCisJCQkJaWYoY3VyX3VzYm1vZGUgPT0gMSl7CQ0KKwkJCQkJLy9vbmx5IHVzZXIgbW9kZSBuZWVkIHRvIGRvIHNvDQorCQkJCQlzd2l0Y2hfbW9kZSA9IFVTQl9TV0lUQ0hfVVNFUjsNCisJCQkJCXNjaGVkdWxlX3dvcmsoJnN3aXRjaF91c2Jtb2RlKTsNCisJCQkJCQ0KKwkJCQl9DQorCQkJCWJyZWFrOw0KKwkJCX1lbHNlew0KKwkJCQkvL2hlcmUganVzdCBzZW5kIGV4Y2VwdCB0byBkbyBzaW11bGF0ZSBwbHVnDQorCQkJCXNpbXVsYXRlX3BsdWcgPSAxOw0KKwkJCX0NCisJCQl1c2JfcmVjb3JkX2RiZ2luZm8oVVNCX1NJTVVMQVRFX1BMVUcsIDAsIHBhcmFtKTsNCiAJCQlzY2hlZHVsZV93b3JrKCZzd2l0Y2hfdXNibW9kZSk7DQogCQkJDQogCQkJYnJlYWs7DQpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZ2FkZ2V0L3VzYl9ycG1zZ19zZXJ2ZXIuYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2RyaXZlcnMvdXNiL2dhZGdldC91c2JfcnBtc2dfc2VydmVyLmMKaW5kZXggYzdkYWVkYS4uMzI3MTllMSAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvZHJpdmVycy91c2IvZ2FkZ2V0L3VzYl9ycG1zZ19zZXJ2ZXIuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9kcml2ZXJzL3VzYi9nYWRnZXQvdXNiX3JwbXNnX3NlcnZlci5jCkBAIC0zNSw3ICszNSw3IEBACiAKIGV4dGVybiB2b2lkIHVzYl9zZXRfcnBtc2dfcmVzcChpbnQgdHlwZSwgY2hhcipyZXNwKTsKIGV4dGVybiB2b2lkIGFuZHJvaWRfc2V0X3JwbXNnX3Jlc3AoaW50IHR5cGUsIGNoYXIqcmVzcCk7Ci1leHRlcm4gdm9pZCB1c2JfcGFyc2VfY2FwX25vdGlmeShpbnQgdHlwZSk7CitleHRlcm4gdm9pZCB1c2JfcGFyc2VfY2FwX25vdGlmeShpbnQgdHlwZSwgaW50IHBhcmFtKTsKIAogc3RydWN0IHRhc2tfc3RydWN0CSpycG1zZ190aHJlYWQ7CiB3YWl0X3F1ZXVlX2hlYWRfdCB1c2JfYWd0X3dxOwpAQCAtMTM4LDcgKzEzOCw3IEBACiB7CiAJaW50IGk7CiAJdW5zaWduZWQgY2hhciAqZGF0YTsKLQkKKwlpbnQgdl9wYXJhbSA9IDA7CiAJY2hhcip0bXA9IChjaGFyKilidWY7CiAJdXNiX3JwbXNnX2NtZCAqbXNnID0gTlVMTDsgCiAKQEAgLTE2Myw4ICsxNjMsMTAgQEAKIAltZW1jcHkodXNiX21zZyxidWYsIGxlbik7CiAJLy91c2JfcnBtc2cyYXAoKGNoYXIgKilidWYsIGxlbik7CiAJbXNnID0gKHVzYl9ycG1zZ19jbWQgKil1c2JfbXNnOwotCWlmKG1zZy0+Y21kID4gVVNCX1JQTVNHX0NNRF9NQVgpewotCQl1c2JfcGFyc2VfY2FwX25vdGlmeShtc2ctPmNtZCk7CisJaWYobXNnLT5jbWQgPiBVU0JfUlBNU0dfQ01EX01BWCl7CQkKKwkJdl9wYXJhbSA9IHNpbXBsZV9zdHJ0b3VsKG1zZy0+cGFyYW0sIE5VTEwsIDEwKTsKKwkJCisJCXVzYl9wYXJzZV9jYXBfbm90aWZ5KG1zZy0+Y21kLCB2X3BhcmFtKTsKIAkJcmV0dXJuOwogCX0KIAlhdG9taWNfc2V0KCZycG1zZ19mbGFnLCAxKTsKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvYW5kcm9pZF9ub3RpZnkuaCBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvYW5kcm9pZF9ub3RpZnkuaAppbmRleCBjMTg5ODFkLi5kNGY1ZWY4IDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9pbmNsdWRlL2xpbnV4L2FuZHJvaWRfbm90aWZ5LmgKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC9hbmRyb2lkX25vdGlmeS5oCkBAIC03OSw2ICs3OSw3IEBACiAJVVNCX1JQTVNHX0dFVF9VU0JfTElOS19TVEFURSwNCiAJVVNCX1JQTVNHX0dFVF9VU0JfRU5VTV9NT0RFLA0KIAlVU0JfUlBNU0dfR0VUX1VTQl9DVVJSX0NPTkZJRywNCisJVVNCX1JQTVNHX0dFVF9VU0JfRExfU1RBVEUsDQogCS8vVVNCX1JQTVNHX0dFVF8sDQogCS8vVVNCX1JQTVNHX0dFVF8sDQogCQ0KZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvbW9kdWxlLmggYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9pbmNsdWRlL2xpbnV4L21vZHVsZS5oCmluZGV4IDY5OGE2MzYuLjc4N2FkN2IgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvbW9kdWxlLmgKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC9tb2R1bGUuaApAQCAtNzU5LDYgKzc1OSw3IEBACiAgICAgaW50ICgqekRydlZwX0F1ZGlvRGF0YUNsb3NlKSh2b2lkKTsKIAogICAgIHZvaWQgKCp6RHJ2VnBfU3RhdHVzKSh1bnNpZ25lZCBpbnQgKiwgdW5zaWduZWQgaW50ICopOworICAgIHZvaWQgKCp6RHJ2VnBfVXBkYXRlVm9pY2VOdikodW5zaWduZWQgY2hhciAqKTsKICAgICAKIAl1bnNpZ25lZCBjaGFyICgqekRydkVkY3BfSXNCdXN5KShpbnQpOwogfTsKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvcmFtZHVtcC9yYW1kdW1wLmggYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9pbmNsdWRlL2xpbnV4L3JhbWR1bXAvcmFtZHVtcC5oCmluZGV4IDAxY2VmZWYuLjg2ZDVlMmMgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvcmFtZHVtcC9yYW1kdW1wLmgKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC9yYW1kdW1wL3JhbWR1bXAuaApAQCAtMjYsNiArMjYsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgILrqtqjS5SAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworI2RlZmluZSBSQU1EVU1QX0NMRUFSX1BSSU9fRkxBRyAgKDB4NykKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIMr9vt3A4NDNtqjS5SAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCkBAIC0zOSw3ICs0MCwxMCBAQAogICAgIFJBTURVTVBfRkxBR19ORUVEX0NPUFkgICAgICA9IDB4MDEsIC8qIENvcHkgZGVzdGluYXRpb24gYWRkcmVzcyAqLwogICAgIFJBTURVTVBfRkxBR19IQVNfRVhURVJOQUwgICA9IDB4MDIsIC8qIEV4dGVybmFsIGFkZHJlc3MgICAgICAgICAqLwogICAgIFJBTURVTVBfRkxBR19IQVNfQ0FMTEJBQ0sgICA9IDB4MDQsIC8qIENhbGxiYWNrIGZ1bnRpb24gICAgICAgICAqLwotfTsKKwlSQU1EVU1QX0ZMQUdfTEVWRUxfSElHSCAgICAgPSAweDA4LCAvKiBIaWdoIHByaW9yIGxldmVsICAgICAgICAgKi8KKyAgICBSQU1EVU1QX0ZMQUdfTEVWRUxfTUVESVVNICAgPSAweDEwLCAvKiBNZWRpdW0gcHJpb3IgbGV2ZWwgICAgICAgKi8KKyAgICBSQU1EVU1QX0ZMQUdfTEVWRUxfTE9XICAgICAgPSAweDIwLCAvKiBMb3cgcHJpb3IgbGV2ZWwgICAgICAgICAgKi8KKyB9OwogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgyKu+1rHkwb/J+cP3ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvcmFtZHVtcC9yYW1kdW1wX29zcy5oIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC9yYW1kdW1wL3JhbWR1bXBfb3NzLmgKaW5kZXggZjA1Zjk5Ni4uNzI1MTUwNyAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC9yYW1kdW1wL3JhbWR1bXBfb3NzLmgKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC9yYW1kdW1wL3JhbWR1bXBfb3NzLmgKQEAgLTgzLDYgKzgzLDggQEAKICNkZWZpbmUgUkFNRFVNUF9FTU1DX1RSQU5TX0ZMQUdfQUREUiAgICAoSVJBTV9CQVNFX0FERFJfUkFNRFVNUF9NT0RFKQogLyq5ss/txNq05rXY1rcqLwogI2lmZGVmIF9VU0VfVkVISUNMRV9EQworI2RlZmluZSBSQU1EVU1QX01PREVfRU1NQyAgICAgICAgICAgICAgICAgICAoMSkKKyNkZWZpbmUgUkFNRFVNUF9NT0RFX1NQSU5BTkQgICAgICAgICAgICAgICAgKDIpCiAjZGVmaW5lIFJBTURVTVBfTUVNX0JBU0UgICAgICAgICAgICAgICAgICAgIChSQU1EVU1QX0FQX1RPX0NBUF9CVUZfQUREUl9QQSkKICNkZWZpbmUgUkFNRFVNUF9NRU1fTEVOICAgICAgICAgICAgICAgICAgICAgKFJBTURVTVBfQVBfVE9fQ0FQX0JVRl9MRU4pCiAjZGVmaW5lIFJBTURVTVBfQ09NUFJFU1NfTEVOICAgICAgICAgICAgICAgIChMWk8xWF9NRU1fQ09NUFJFU1MpCkBAIC0xMTUsNiArMTE3LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICDIq77WseTBv8n5w/cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK2V4dGVybiB1bnNpZ25lZCBpbnQgIHJhbWR1bXBfZXhwb3J0X21vZGU7CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICDIq77Wuq/K/cn5w/cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKgpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC92b2x0ZV9kcnYuaCBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2luY2x1ZGUvbGludXgvdm9sdGVfZHJ2LmgKaW5kZXggMTE0YjU2MS4uNDdhNmMwMSAxMDA3NTUKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40LngvaW5jbHVkZS9saW51eC92b2x0ZV9kcnYuaAorKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9pbmNsdWRlL2xpbnV4L3ZvbHRlX2Rydi5oCkBAIC04NSw3ICs4NSw2IEBACiAjZGVmaW5lIFZPSUNFX0lPQ1RMX0dFVF9TTElDX1VTRV9GTEFHCV9JT1IgKCd2JywgMTIsIGludCkKICNkZWZpbmUgVk9JQ0VfSU9DVExfVlBMT09QCV9JT1coJ3YnLCAxMywgaW50KQogCi0jaWZkZWYgX1VTRV9WRUhJQ0xFX0RDCiAjZGVmaW5lIFZPSUNFX0lPQ1RMX1NFVF9WT0wJX0lPVygndicsIDE0LCBpbnQpCiAjZGVmaW5lIFZPSUNFX0lPQ1RMX0dFVF9WT0wJX0lPUigndicsIDE1LCBpbnQpIAogCkBAIC05NCw5ICs5Myw5IEBACiAKICNkZWZpbmUgVk9JQ0VfSU9DVExfU0VUX1BBVEgJX0lPVygndicsIDE4LCBpbnQpCiAjZGVmaW5lIFZPSUNFX0lPQ1RMX0dFVF9QQVRICV9JT1IoJ3YnLCAxOSwgaW50KSAKLSNlbmRpZgogCiAjZGVmaW5lIFZPSUNFX0lPQ1RMX0dFVF9GUwlfSU9SKCd2JywgMjAsIGludCkKKyNkZWZpbmUgVk9JQ0VfSU9DVExfU0VUX1ZPSUNFX05WUlcJX0lPVygndicsIDIxLCBpbnQpCiAKICNpZmRlZiBfX0tFUk5FTF9fCiAjZGVmaW5lICBwcmludF9hdWRpbyhmbXQsIC4uLikgIFwKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2tlcm5lbC9yZWxheS5jIGIvYXAvb3MvbGludXgvbGludXgtMy40Lngva2VybmVsL3JlbGF5LmMKb2xkIG1vZGUgMTAwNjQ0Cm5ldyBtb2RlIDEwMDc1NQppbmRleCA1NmJhNDRmLi5lMDBjYmVhCi0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2tlcm5lbC9yZWxheS5jCisrKyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2tlcm5lbC9yZWxheS5jCkBAIC0xMDUwLDcgKzEwNTAsOCBAQAogCXNpemVfdCBjb25zdW1lZCA9IGJ1Zi0+c3ViYnVmc19jb25zdW1lZCAlIG5fc3ViYnVmczsKIAogCWlmICghcmVhZF9wb3MpCi0JCXJlYWRfcG9zID0gY29uc3VtZWQgKiBzdWJidWZfc2l6ZSArIGJ1Zi0+Ynl0ZXNfY29uc3VtZWQ7CisJCXJlYWRfcG9zID0gKGNvbnN1bWVkICogc3ViYnVmX3NpemUgKyBidWYtPmJ5dGVzX2NvbnN1bWVkKQorCQkJCSUgKG5fc3ViYnVmcyAqIHN1YmJ1Zl9zaXplKTsKIAlyZWFkX3N1YmJ1ZiA9IHJlYWRfcG9zIC8gc3ViYnVmX3NpemU7CiAJcGFkZGluZyA9IGJ1Zi0+cGFkZGluZ1tyZWFkX3N1YmJ1Zl07CiAJcGFkZGluZ19zdGFydCA9IChyZWFkX3N1YmJ1ZiArIDEpICogc3ViYnVmX3NpemUgLSBwYWRkaW5nOwpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40Lngva2VybmVsL3NjaGVkL3J0LmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9rZXJuZWwvc2NoZWQvcnQuYwpvbGQgbW9kZSAxMDA2NDQKbmV3IG1vZGUgMTAwNzU1CmluZGV4IDg5YTk4NWEuLmYwNzEwMWQKLS0tIGEvYXAvb3MvbGludXgvbGludXgtMy40Lngva2VybmVsL3NjaGVkL3J0LmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40Lngva2VybmVsL3NjaGVkL3J0LmMKQEAgLTEzNzEsNiArMTM3MSw4IEBACiAJQlVHX09OKGlkeCA+PSBNQVhfUlRfUFJJTyk7CiAKIAlxdWV1ZSA9IGFycmF5LT5xdWV1ZSArIGlkeDsKKwlpZiAoU0NIRURfV0FSTl9PTihsaXN0X2VtcHR5KHF1ZXVlKSkpCisJCXJldHVybiBOVUxMOwogCW5leHQgPSBsaXN0X2VudHJ5KHF1ZXVlLT5uZXh0LCBzdHJ1Y3Qgc2NoZWRfcnRfZW50aXR5LCBydW5fbGlzdCk7CiAKIAlyZXR1cm4gbmV4dDsKQEAgLTEzOTIsNyArMTM5NCw4IEBACiAKIAlkbyB7CiAJCXJ0X3NlID0gcGlja19uZXh0X3J0X2VudGl0eShycSwgcnRfcnEpOwotCQlCVUdfT04oIXJ0X3NlKTsKKwkJaWYgKHVubGlrZWx5KCFydF9zZSkpCisJCQlyZXR1cm4gTlVMTDsKIAkJcnRfcnEgPSBncm91cF9ydF9ycShydF9zZSk7CiAJfSB3aGlsZSAocnRfcnEpOwogCmRpZmYgLS1naXQgYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9rZXJuZWwvc2NoZWQvc2NoZWQuaCBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L2tlcm5lbC9zY2hlZC9zY2hlZC5oCm9sZCBtb2RlIDEwMDY0NApuZXcgbW9kZSAxMDA3NTUKaW5kZXggZWQyYmFiNS4uNzI2MDY3OAotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9rZXJuZWwvc2NoZWQvc2NoZWQuaAorKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9rZXJuZWwvc2NoZWQvc2NoZWQuaApAQCAtNiw2ICs2LDEyIEBACiAKICNpbmNsdWRlICJjcHVwcmkuaCIKIAorI2lmZGVmIENPTkZJR19TQ0hFRF9ERUJVRworIyBkZWZpbmUgU0NIRURfV0FSTl9PTih4KQlXQVJOX09OQ0UoeCwgI3gpCisjZWxzZQorIyBkZWZpbmUgU0NIRURfV0FSTl9PTih4KQkoeyAodm9pZCkoeCksIDA7IH0pCisjZW5kaWYKKwogZXh0ZXJuIF9fcmVhZF9tb3N0bHkgaW50IHNjaGVkdWxlcl9ydW5uaW5nOwogCiAvKgpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvbGliL2ZsYWdzX3V0aWxzL2ZsYWdzX3V0aWxzLmMgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9saWIvZmxhZ3NfdXRpbHMvZmxhZ3NfdXRpbHMuYwppbmRleCA3ZGRlMjAwLi5lNDMzMjk2IDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9saWIvZmxhZ3NfdXRpbHMvZmxhZ3NfdXRpbHMuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9saWIvZmxhZ3NfdXRpbHMvZmxhZ3NfdXRpbHMuYwpAQCAtMzkyLDYgKzM5Miw3IEBACiAgICAgVF9GTEFHU19JTkZPIG1haW5fZmxhZyA9IHswfTsNCiAgICAgVF9GTEFHU19JTkZPIGJhY2t1cF9mbGFnID0gezB9Ow0KIAlUX0ZMQUdTX0lORk8gcF9mbGFnc19pbmZvX3RtcCA9IHswfTsNCisJY2hhciBkZWx0YV9GW0lNR19OQU1FX0xFTl0gPSB7MH07DQogDQogICAgIGludCBtYWluX2luZGV4ID0gMDsNCiAgICAgaW50IGJhY2t1cF9pbmRleCA9IDE7DQpAQCAtNDE0LDM3ICs0MTUsMzQgQEAKICAgICAgICAgcmV0dXJuIC0xOw0KICAgICB9DQogCQ0KLQlmbGFnc19pbmZvKCJtYWluX2ZsYWcgY3JjMzI9JXUiLCBtYWluX2ZsYWcuY3JjMzIpOw0KLQlmbGFnc19pbmZvKCJiYWNrdXBfZmxhZyBjcmMzMj0ldSIsIGJhY2t1cF9mbGFnLmNyYzMyKTsNCi0JDQotCWlmICgoMCA9PSBtYWluX2ZsYWcuY3JjMzIpICYmICgwID09IGJhY2t1cF9mbGFnLmNyYzMyKSkNCisJZmxhZ3NfaW5mbygibWFpbl9mbGFnIGNyYzMyPSV1LCBjcmMzMl8xPSV1IiwgbWFpbl9mbGFnLmNyYzMyLCBtYWluX2ZsYWcuY3JjMzJfMSk7DQorCWZsYWdzX2luZm8oImJhY2t1cF9mbGFnIGNyYzMyPSV1LCBjcmMzMl8xPSV1IiwgYmFja3VwX2ZsYWcuY3JjMzIsIGJhY2t1cF9mbGFnLmNyYzMyXzEpOw0KKw0KKwltZW1zZXQoZGVsdGFfRiwgMHhGRiwgSU1HX05BTUVfTEVOKTsNCisNCisJaWYgKCgwID09IG1lbWNtcChtYWluX2ZsYWcuaW1nX3NpemVbMF0ubmFtZSwgZGVsdGFfRiwgSU1HX05BTUVfTEVOKSkgJiYgKDAgPT0gbWVtY21wKGJhY2t1cF9mbGFnLmltZ19zaXplWzBdLm5hbWUsIGRlbHRhX0YsIElNR19OQU1FX0xFTikpKQ0KIAl7DQotCQlpZiAoKEZMQUdTX01BR0lDID09IG1haW5fZmxhZy5tYWdpY19zdGFydCkgJiYgKEZMQUdTX01BR0lDID09IG1haW5fZmxhZy5tYWdpY19lbmQpKQ0KKwkJbWVtY3B5KCZwX2ZsYWdzX2luZm9fdG1wLCAmbWFpbl9mbGFnLCBzaXplb2YoVF9GTEFHU19JTkZPKSk7DQorCQltZW1zZXQocF9mbGFnc19pbmZvX3RtcC5pbWdfc2l6ZVswXS5uYW1lLCAwLCBzaXplb2YoVF9GTEFHU19JTkZPKS01MTIpOw0KKw0KKwkJcF9mbGFnc19pbmZvX3RtcC5jcmMzMl8xID0gY3JjMzJfbGUoMCwgKHVuc2lnbmVkIGNoYXIgY29uc3QgKikoJnBfZmxhZ3NfaW5mb190bXApLCBzaXplb2YoVF9GTEFHU19JTkZPKSk7DQorCQlmbGFnc19pbmZvKCJmaXggb2xkLCBzZXQgY3JjMzJfMT0ldSIsIHBfZmxhZ3NfaW5mb190bXAuY3JjMzJfMSk7DQorCQkNCisJCWlmIChzZXRfZmxhZ3NfaW5mbygmcF9mbGFnc19pbmZvX3RtcCwgJm1haW5faW5kZXgsICZiYWNrdXBfaW5kZXgpICE9IDApDQogCQl7DQotCQkJaWYgKChGTEFHU19NQUdJQyA9PSBiYWNrdXBfZmxhZy5tYWdpY19zdGFydCkgJiYgKEZMQUdTX01BR0lDID09IGJhY2t1cF9mbGFnLm1hZ2ljX2VuZCkpDQotCQkJew0KLQkJCQltZW1jcHkoJnBfZmxhZ3NfaW5mb190bXAsICZtYWluX2ZsYWcsIHNpemVvZihUX0ZMQUdTX0lORk8pKTsNCi0JCQkJcF9mbGFnc19pbmZvX3RtcC5jcmMzMiA9IDA7DQotCQkJCXBfZmxhZ3NfaW5mb190bXAuY3JjMzIgPSBjcmMzMl9sZSgwLCAodW5zaWduZWQgY2hhciBjb25zdCAqKSgmcF9mbGFnc19pbmZvX3RtcCksIHNpemVvZihUX0ZMQUdTX0lORk8pKTsNCi0JCQkJZmxhZ3NfaW5mbygib2xkIHZlcnNpb24sIHNldCBjcmMzMj0ldSIsIHBfZmxhZ3NfaW5mb190bXAuY3JjMzIpOw0KLQkJCQkNCi0JCQkJaWYgKHNldF9mbGFnc19pbmZvKCZwX2ZsYWdzX2luZm9fdG1wLCAmbWFpbl9pbmRleCwgJmJhY2t1cF9pbmRleCkgIT0gMCkNCi0JCQkJew0KLQkJCQkJZmxhZ3NfZXJyKCJvbGQgdmVyc2lvbiwgc2V0IGZsYWdzIGluZm8gZmFpbCIpOw0KLQkJCQkJcmV0dXJuIC0xOw0KLQkJCQl9DQotCQkJCQ0KLQkJCQljb3B5X2ZsYWdzX2luZm8ocF9mbGFnc19pbmZvLCAmbWFpbl9mbGFnKTsNCi0JCQkJcmV0dXJuIDA7DQotCQkJfQ0KKwkJCWZsYWdzX2VycigiZml4IG9sZCwgc2V0IGZsYWdzIGluZm8gZmFpbCIpOw0KKwkJCXJldHVybiAtMTsNCiAJCX0NCisJCQ0KKwkJY29weV9mbGFnc19pbmZvKHBfZmxhZ3NfaW5mbywgJm1haW5fZmxhZyk7DQorCQlyZXR1cm4gMDsNCiAJfQ0KIA0KLQljcmMzMl9tYWluID0gbWFpbl9mbGFnLmNyYzMyOw0KLQljcmMzMl9iYWNrdXAgPSBiYWNrdXBfZmxhZy5jcmMzMjsNCisJY3JjMzJfbWFpbiA9IG1haW5fZmxhZy5jcmMzMl8xOw0KKwljcmMzMl9iYWNrdXAgPSBiYWNrdXBfZmxhZy5jcmMzMl8xOw0KIA0KLQltYWluX2ZsYWcuY3JjMzIgPSAwOw0KLQliYWNrdXBfZmxhZy5jcmMzMiA9IDA7DQorCW1haW5fZmxhZy5jcmMzMl8xID0gMDsNCisJYmFja3VwX2ZsYWcuY3JjMzJfMSA9IDA7DQogCQkNCiAJY3JjMzJfbGVfbWFpbiA9IGNyYzMyX2xlKDAsICh1bnNpZ25lZCBjaGFyIGNvbnN0ICopKCZtYWluX2ZsYWcpLCBzaXplb2YobWFpbl9mbGFnKSk7DQogCWZsYWdzX2luZm8oImNyYzMyX2xlX21haW4gY3JjMzI9JXUiLCBjcmMzMl9sZV9tYWluKTsNCkBAIC00OTUsOCArNDkzLDEyIEBACiAgICAgfQ0KIAkNCiAJcF9mbGFnc19pbmZvLT5jcmMzMiA9IDA7DQotCXBfZmxhZ3NfaW5mby0+Y3JjMzIgPSBjcmMzMl9sZSgwLCAodW5zaWduZWQgY2hhciBjb25zdCAqKXBfZmxhZ3NfaW5mbywgc2l6ZW9mKFRfRkxBR1NfSU5GTykpOw0KKwlwX2ZsYWdzX2luZm8tPmNyYzMyID0gY3JjMzJfbGUoMCwgKHVuc2lnbmVkIGNoYXIgY29uc3QgKilwX2ZsYWdzX2luZm8sIDUxMik7DQogCWZsYWdzX2luZm8oInNldCBjcmMzMj0ldSIsIHBfZmxhZ3NfaW5mby0+Y3JjMzIpOw0KKwkNCisJcF9mbGFnc19pbmZvLT5jcmMzMl8xID0gMDsNCisJcF9mbGFnc19pbmZvLT5jcmMzMl8xID0gY3JjMzJfbGUoMCwgKHVuc2lnbmVkIGNoYXIgY29uc3QgKilwX2ZsYWdzX2luZm8sIHNpemVvZihUX0ZMQUdTX0lORk8pKTsNCisJZmxhZ3NfaW5mbygic2V0IGNyYzMyXzE9JXUiLCBwX2ZsYWdzX2luZm8tPmNyYzMyXzEpOw0KIA0KICAgICBpZiAoc2V0X2ZsYWdzX2luZm8ocF9mbGFnc19pbmZvLCAmbWFpbl9pbmRleCwgJmJhY2t1cF9pbmRleCkgIT0gMCkNCiAgICAgew0KZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L21tL3JhbWR1bXAvcmFtZHVtcF9vc3MuYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L21tL3JhbWR1bXAvcmFtZHVtcF9vc3MuYwppbmRleCA4ZjUwNjg4Li41ZjE3YjBlIDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9tbS9yYW1kdW1wL3JhbWR1bXBfb3NzLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvbW0vcmFtZHVtcC9yYW1kdW1wX29zcy5jCkBAIC01Myw2ICs1Myw3IEBACiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogdW5zaWduZWQgY2hhciAqcmFtZHVtcF9tZW1fYmFzZSA9IE5VTEw7CiB1bnNpZ25lZCBjaGFyICpyYW1kdW1wX3NoYXJlZF9tZW1fYmFzZSA9IE5VTEw7Cit1bnNpZ25lZCBpbnQgIHJhbWR1bXBfZXhwb3J0X21vZGUgPSAweEZGOwogI2VuZGlmCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCkBAIC0zNTksOCArMzYwLDggQEAKIHsKICNpZmRlZiBfT1NfTElOVVggCiAjaWZkZWYgX1VTRV9WRUhJQ0xFX0RDCi0KLQlpZigqKHVuc2lnbmVkIGludCAqKVJBTURVTVBfRU1NQ19UUkFOU19GTEFHX0FERFIgIT0gMSkKKwlpZigocmFtZHVtcF9leHBvcnRfbW9kZSAhPSBSQU1EVU1QX01PREVfRU1NQykgCisJCSYmKHJhbWR1bXBfZXhwb3J0X21vZGUgIT0gUkFNRFVNUF9NT0RFX1NQSU5BTkQpKQogCXsKICNlbmRpZgogICAgIAl6RHJ2VXNiUG9sbF9Jbml0KCk7ICAgICAgICAgICAgICAgICAvKiCz9cq8u69VU0IgICAgICAgICovCkBAIC01NDksOCArNTUwLDggQEAKIHZvaWQgcmFtZHVtcF9vc3NfZGF0YV90cmFuc19yZWFkKHVuc2lnbmVkIGNoYXIgKmJ1ZmZlciwgdW5zaWduZWQgaW50IHNpemUpCiB7CiAjaWZkZWYgX1VTRV9WRUhJQ0xFX0RDCi0KLQlpZigqKHVuc2lnbmVkIGludCAqKVJBTURVTVBfRU1NQ19UUkFOU19GTEFHX0FERFIgPT0gMSkKKwlpZiAoKHJhbWR1bXBfZXhwb3J0X21vZGUgPT0gUkFNRFVNUF9NT0RFX0VNTUMpCisJCXx8IChyYW1kdW1wX2V4cG9ydF9tb2RlID09IFJBTURVTVBfTU9ERV9TUElOQU5EKSkKIAkJcmFtZHVtcF9zaG1fdHJhbnNfcmVhZChidWZmZXIsIHNpemUpOwogCWVsc2UKICNlbmRpZgpAQCAtNTY5LDggKzU3MCw4IEBACiB2b2lkIHJhbWR1bXBfb3NzX2RhdGFfdHJhbnNfd3JpdGUodW5zaWduZWQgY2hhciAqYnVmZmVyLCB1bnNpZ25lZCBpbnQgc2l6ZSkKIHsKICNpZmRlZiBfVVNFX1ZFSElDTEVfREMKLQotCWlmKCoodW5zaWduZWQgaW50ICopUkFNRFVNUF9FTU1DX1RSQU5TX0ZMQUdfQUREUiA9PSAxKQorCWlmICgocmFtZHVtcF9leHBvcnRfbW9kZSA9PSBSQU1EVU1QX01PREVfRU1NQykKKwkJfHwgKHJhbWR1bXBfZXhwb3J0X21vZGUgPT0gUkFNRFVNUF9NT0RFX1NQSU5BTkQpKQogCQlyYW1kdW1wX3NobV90cmFuc193cml0ZShidWZmZXIsIHNpemUpOwogCWVsc2UKICNlbmRpZgpAQCAtNTgxLDcgKzU4Miw4IEBACiB2b2lkIHJhbWR1bXBfb3NzX2RhdGFfdHJhbnNfd3JpdGVfZGF0YSh1bnNpZ25lZCBjaGFyICpidWZmZXIsIHVuc2lnbmVkIGludCBzaXplKQogewogI2lmZGVmIF9VU0VfVkVISUNMRV9EQwotCWlmKCoodW5zaWduZWQgaW50ICopUkFNRFVNUF9FTU1DX1RSQU5TX0ZMQUdfQUREUiA9PSAxKXsKKwlpZiAoKHJhbWR1bXBfZXhwb3J0X21vZGUgPT0gUkFNRFVNUF9NT0RFX0VNTUMpCisJCXx8IChyYW1kdW1wX2V4cG9ydF9tb2RlID09IFJBTURVTVBfTU9ERV9TUElOQU5EKSl7CiAJCQlyYW1kdW1wX3NobV90cmFuc193cml0ZV9kYXRhKGJ1ZmZlciwgc2l6ZSk7CiAJfQogCWVsc2UKQEAgLTYwMyw4ICs2MDUsOSBAQAogI2lmZGVmIF9PU19MSU5VWAogI2lmZGVmIF9VU0VfVkVISUNMRV9EQwogCi0gICAgLyogtci0/cr9vt23osvNzeq686Os1NnW2Mb0ICovCi0JaWYoKih1bnNpZ25lZCBpbnQgKilSQU1EVU1QX0VNTUNfVFJBTlNfRkxBR19BRERSID09IDEpCisJLyogtci0/cr9vt23osvNzeq686Os1NnW2Mb0ICovCisJaWYgKChyYW1kdW1wX2V4cG9ydF9tb2RlID09IFJBTURVTVBfTU9ERV9FTU1DKQorCQl8fCAocmFtZHVtcF9leHBvcnRfbW9kZSA9PSBSQU1EVU1QX01PREVfU1BJTkFORCkpCiAJCXJldHVybjsKIAllbHNlCiAjZW5kaWYKQEAgLTYxOSwxNSArNjIyLDE1IEBACiAKIAl1bnNpZ25lZCBsb25nIGFkZHI7CiAJdW5zaWduZWQgbG9uZyBzaXplOwotCQorCiAJZ2V0X2xvZ2J1Zl9pbmZvKCZhZGRyLCAmc2l6ZSk7Ci0JCisKIAlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKIAkJImFwX2xvZ19idWYiLCAKIAkJKHVuc2lnbmVkIGxvbmcpT1NTX1ZJUlRfVE9fUEhZKGFkZHIpLCAKIAkJc2l6ZSwgCiAJCWFkZHIsCi0JCVJBTURVTVBfRkxBR19OT05FLAorCQlSQU1EVU1QX0ZMQUdfTEVWRUxfSElHSCwKIAkJMCk7CiAjZW5kaWYKICNlbmRpZgpkaWZmIC0tZ2l0IGEvYXAvb3MvbGludXgvbGludXgtMy40LngvbW0vcmFtZHVtcC9yYW1kdW1wX3RyYW5zX3NlcnZlci5jIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvbW0vcmFtZHVtcC9yYW1kdW1wX3RyYW5zX3NlcnZlci5jCmluZGV4IGExODY4NjcuLjU5ZjY2NTYgMTAwNzU1Ci0tLSBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L21tL3JhbWR1bXAvcmFtZHVtcF90cmFuc19zZXJ2ZXIuYworKysgYi9hcC9vcy9saW51eC9saW51eC0zLjQueC9tbS9yYW1kdW1wL3JhbWR1bXBfdHJhbnNfc2VydmVyLmMKQEAgLTMyLDE0ICszMiwxNCBAQAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KICNkZWZpbmUgUkFNRFVNUF9PTl9ERUZBVUxUX1ZBTCAgKDEpCiAKLSNkZWZpbmUgUkFNRFVNUF9NTUFQX1NVQ0NFU1MgKFJBTURVTVBfU1VDQ0VTUykKLSNkZWZpbmUgUkFNRFVNUF9NTUFQX0ZBSUxFRCAgKFJBTURVTVBfRkFJTEVEKQorI2RlZmluZSBSQU1EVU1QX01NQVBfU1VDQ0VTUyAgICAoUkFNRFVNUF9TVUNDRVNTKQorI2RlZmluZSBSQU1EVU1QX01NQVBfRkFJTEVEICAgICAoUkFNRFVNUF9GQUlMRUQpCiAKLSNkZWZpbmUgUlBfTVNHX1BTX1BIWV9SQU1EVU1QX0NIQU5ORUwgICAgICAgY2hhbm5lbF80MCAgICAgLy9hcm2honpzcNauvOS1xHJhbWR1bXDNqLXACi0jZGVmaW5lIFJQX01TR19QU19QSFlfUkFNRFVNUF9TSVpFICAgICAgICAgIDB4NDAgICAgIC8vYXJtoaJ6c3DWrrzktcRyYW1kdW1wzai1wAorI2RlZmluZSBSUF9NU0dfUFNfUEhZX1JBTURVTVBfQ0hBTk5FTCAgY2hhbm5lbF80MCAvL2FybaGienNw1q685LXEcmFtZHVtcM2otcAKKyNkZWZpbmUgUlBfTVNHX1BTX1BIWV9SQU1EVU1QX1NJWkUgICAgIDB4NDAgICAgICAgLy9hcm2honpzcNauvOS1xHJhbWR1bXDNqLXACiAKICNpZmRlZiBfVVNFX0NBUF9TWVMKLSNkZWZpbmUgUkFNRFVNUF9JQ1BfTVNHX0NBUF9TSVpFICAgICAgICAgIAkweDQwIAorI2RlZmluZSBSQU1EVU1QX0lDUF9NU0dfQ0FQX1NJWkUgICAgICAgMHg0MCAKICNlbmRpZgogCiAvKiByYW1kdW1wILrNIFBDx/22r7T6wO29u7ulw/zB7tS8tqggKi8KQEAgLTgzLDcgKzgzLDYgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICDK/b7dwODQzbao0uUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQogLyoKICAqIHN0cnVjdCBUUkFOUyBXSVRIIFBDCiAgKi8KQEAgLTE4NywxMyArMTg2LDE1IEBACiB7CiAJImNhcF9kZHIuYmluIiwKIAkiY2FwLmNtbSIsCisjaWYgMCAKIAkiY2FwX2Vycl9sb2cudHh0IgorI2VuZGlmCiB9OwogCiB1bnNpZ25lZCBpbnQgcmFtZHVtcF9zaG1fZmlsZV9udW0gPSAwOwogdW5zaWduZWQgaW50IHJhbWR1bXBfZXhwcm90X2ZpbGVfbnVtID0gMDsKIHVuc2lnbmVkIGludCByYW1kdW1wX2V4cG9ydF9maWxlX2luZGV4W1JBTURVTVBfUkFNQ09ORl9UQUJMRV9NQVhfRU5UUllTXSA9IHswfTsKLXVuc2lnbmVkIGludCAqY2FwX2Rkcl9zaXplID0gKHVuc2lnbmVkIGludCAqKUlSQU1fQkFTRV9BRERSX0JPT1RfRERSOzsKK3Vuc2lnbmVkIGludCAqY2FwX2Rkcl9zaXplID0gKHVuc2lnbmVkIGludCAqKUlSQU1fQkFTRV9BRERSX0JPT1RfRERSOwogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgvtayv7qvyv3Ktc/WICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoKQEAgLTYzMiwzNCArNjMzLDM0IEBACiAgICAgaWYgKHJldCAhPSBSQU1EVU1QX1NVQ0NFU1MpIAogICAgICAgICByZXR1cm4gcmV0OwogI2VuZGlmCi0JcmV0ID0gcmFtZHVtcF9vc3NfaWNwX2NyZWF0ZV9jaGFubmVsKAotCQkJcmFtZHVtcF9jcHVfaWRbUkFNRFVNUF9DUFVfMl0sIAotCQkJUlBfTVNHX1BTX1BIWV9SQU1EVU1QX0NIQU5ORUwsIAotCQkJUlBfTVNHX1BTX1BIWV9SQU1EVU1QX1NJWkUpOwotCWlmIChyZXQgIT0gUkFNRFVNUF9TVUNDRVNTKSAKLQkJcmV0dXJuIHJldDsKKyAgICByZXQgPSByYW1kdW1wX29zc19pY3BfY3JlYXRlX2NoYW5uZWwoCisgICAgICAgICAgICByYW1kdW1wX2NwdV9pZFtSQU1EVU1QX0NQVV8yXSwgCisgICAgICAgICAgICBSUF9NU0dfUFNfUEhZX1JBTURVTVBfQ0hBTk5FTCwgCisgICAgICAgICAgICBSUF9NU0dfUFNfUEhZX1JBTURVTVBfU0laRSk7CisgICAgaWYgKHJldCAhPSBSQU1EVU1QX1NVQ0NFU1MpIAorICAgICAgICByZXR1cm4gcmV0OwogCi0JcmV0ID0gcmFtZHVtcF9vc3NfaWNwX3JlZ2NhbGxiYWNrKAotCQkJcmFtZHVtcF9jcHVfaWRbUkFNRFVNUF9DUFVfMl0sCi0JCQlSUF9NU0dfUFNfUEhZX1JBTURVTVBfQ0hBTk5FTCwgCi0JCQlyYW1kdW1wX2ljcF9tc2dfZnJvbV96c3ApOwotCWlmIChyZXQgIT0gUkFNRFVNUF9TVUNDRVNTKSAKLQkJcmV0dXJuIHJldDsKKyAgICByZXQgPSByYW1kdW1wX29zc19pY3BfcmVnY2FsbGJhY2soCisgICAgICAgICAgICByYW1kdW1wX2NwdV9pZFtSQU1EVU1QX0NQVV8yXSwKKyAgICAgICAgICAgIFJQX01TR19QU19QSFlfUkFNRFVNUF9DSEFOTkVMLCAKKyAgICAgICAgICAgIHJhbWR1bXBfaWNwX21zZ19mcm9tX3pzcCk7CisgICAgaWYgKHJldCAhPSBSQU1EVU1QX1NVQ0NFU1MpIAorICAgICAgICByZXR1cm4gcmV0OwogCi0JcmV0ID0gcmFtZHVtcF9vc3NfaWNwX2NyZWF0ZV9jaGFubmVsKAotCQkJTTBfSUQsIAotCQkJY2hhbm5lbF8zLCAKLQkJCTB4MTQpOwotCWlmIChyZXQgIT0gUkFNRFVNUF9TVUNDRVNTKSAKLQkJcmV0dXJuIHJldDsKKyAgICByZXQgPSByYW1kdW1wX29zc19pY3BfY3JlYXRlX2NoYW5uZWwoCisgICAgICAgICAgICBNMF9JRCwgCisgICAgICAgICAgICBjaGFubmVsXzMsIAorICAgICAgICAgICAgMHgxNCk7CisgICAgaWYgKHJldCAhPSBSQU1EVU1QX1NVQ0NFU1MpIAorICAgICAgICByZXR1cm4gcmV0OwogCi0JcmV0ID0gcmFtZHVtcF9vc3NfaWNwX3JlZ2NhbGxiYWNrKAotCQkJTTBfSUQsCi0JCQljaGFubmVsXzMsIAotCQkJcmFtZHVtcF9pY3BfbXNnX2Zyb21fbTApOworICAgIHJldCA9IHJhbWR1bXBfb3NzX2ljcF9yZWdjYWxsYmFjaygKKyAgICAgICAgICAgIE0wX0lELAorICAgICAgICAgICAgY2hhbm5lbF8zLCAKKyAgICAgICAgICAgIHJhbWR1bXBfaWNwX21zZ19mcm9tX20wKTsKIAotCWlmIChyZXQgIT0gUkFNRFVNUF9TVUNDRVNTKSAKLQkJcmV0dXJuIHJldDsKKyAgICBpZiAocmV0ICE9IFJBTURVTVBfU1VDQ0VTUykgCisgICAgICAgIHJldHVybiByZXQ7CiAKICNlbmRpZgogCkBAIC02OTgsNiArNjk5LDI2IEBACiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisqILmmxNzD6Mr2OiAgICAgcmFtZHVtcF9maWxlX3NraXAKKyogss7K/cu1w/c6ICAgICAKKyogICAotKvI67LOyv0pICBpbmRleCAKKyogICAotKuz9rLOyv0pICB2b2lkCisqILe1ILvYINa1OiAgICAgyse38cz4uf0KKyogxuTL/Mu1w/c6ICAgICBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgZm9yIGp1ZGdlIGZpbGUgaXMgc2tpcCBvciBub3QKKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCitib29sIHJhbWR1bXBfZmlsZV9za2lwKHVuc2lnbmVkIGludCBpbmRleCkKK3sKKyAgICB1bnNpZ25lZCBpbnQgY250ID0gMDsKKyAgICByYW1kdW1wX3NobV9maWxlX251bSA9IHNpemVvZihyYW1kdW1wX3NobV9leHBvcnRfZmlsZSkvc2l6ZW9mKHJhbWR1bXBfc2htX2V4cG9ydF9maWxlWzBdKTsKKworICAgIGZvciAoOyBjbnQgPCByYW1kdW1wX3NobV9maWxlX251bTsgY250KyspIHsKKyAgICAgICAgaWYoc3RyY21wKHJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2luZGV4XS5uYW1lLCByYW1kdW1wX3NobV9leHBvcnRfZmlsZVtjbnRdKSA9PSAwKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoguabE3MPoyvY6ICAgIHJhbWR1bXBfc2VydmVyX3N0b3JlX3JhbV9jb25mCiAqILLOyv3LtcP3OiAgICAgCiAqICAgKLSryOuyzsr9KSBtZW06IGFkZHIKQEAgLTcwNywyNCArNzI4LDM0IEBACiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogc3RhdGljIHVuc2lnbmVkIGNoYXIgKnJhbWR1bXBfc2VydmVyX3N0b3JlX3JhbV9jb25mKHVuc2lnbmVkIGNoYXIgKm1lbSkKIHsKLSAgICB1bnNpZ25lZCBsb25nIGlfcmFtX2NvbmYgPSAwOworICAgIHVuc2lnbmVkIGxvbmcgICAgICAgIGlfcmFtX2NvbmYgICAgPSAwOworICAgIHJhbWR1bXBfcmFtX2NvbmZpZ190ICpjb25maWdfZW50cnkgPSBOVUxMOworCiAgICAgd2hpbGUgKHJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2lfcmFtX2NvbmZdLnZpciAhPSAwICYmIAotICAgICAgICAgICByYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX3JhbV9jb25mXS5zaXplICE9IDApCi0gICAgewotICAgICAgICByYW1kdW1wX3JhbV9jb25maWdfdCAqY29uZmlnX2VudHJ5ID0gJihyYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX3JhbV9jb25mXSk7CisgICAgICAgICAgIHJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2lfcmFtX2NvbmZdLnNpemUgIT0gMCkgeworI2lmZGVmIF9VU0VfVkVISUNMRV9EQyAKKyAgICAgICAgaWYgKChyYW1kdW1wX2V4cG9ydF9tb2RlID09IFJBTURVTVBfTU9ERV9FTU1DKQorICAgICAgICAgICAgfHwgKHJhbWR1bXBfZXhwb3J0X21vZGUgPT0gUkFNRFVNUF9NT0RFX1NQSU5BTkQpKXsKKyAgICAgICAgICAgIGlmIChyYW1kdW1wX2ZpbGVfc2tpcChpX3JhbV9jb25mKSA9PSB0cnVlKSB7CisgICAgICAgICAgICAgICAgaV9yYW1fY29uZisrOworICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorICAgICAgICB9CisjZW5kaWYKKyAgICAgICAgY29uZmlnX2VudHJ5ID0gJihyYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX3JhbV9jb25mXSk7CiAgICAgICAgIC8qIHNlc3Npb24gY2FuIGJlIGFjY2VzcyAqLwogICAgICAgICBpZiAoY29uZmlnX2VudHJ5LT5jYWxsYmFjayA9PSBOVUxMIHx8Ci0gICAgICAgICAgICAoY29uZmlnX2VudHJ5LT5jYWxsYmFjayAhPSBOVUxMICYmCi0gICAgICAgICAgICAoKihjb25maWdfZW50cnktPmNhbGxiYWNrKSkoKSA9PSBSQU1EVU1QX1RSVUUpKQorICAgICAgICAoY29uZmlnX2VudHJ5LT5jYWxsYmFjayAhPSBOVUxMICYmCisgICAgICAgICgqKGNvbmZpZ19lbnRyeS0+Y2FsbGJhY2spKSgpID09IFJBTURVTVBfVFJVRSkpCiAgICAgICAgICAgICBtZW0gKz0gc3ByaW50ZigKLSAgICAgICAgICAgICAgICAgICAgbWVtLCAKLSAgICAgICAgICAgICAgICAgICAgImRhdGEubG9hZC5iaW5hcnkgJnJhbWR1bXBfZGlyXFwlcyAweCV4LS0weCV4IC9ub2NsZWFyXG4iLAotICAgICAgICAgICAgICAgICAgICAoY29uZmlnX2VudHJ5LT5uYW1lKSwKKyAgICAgICAgICAgICAgICBtZW0sIAorICAgICAgICAgICAgICAgICJkYXRhLmxvYWQuYmluYXJ5ICZyYW1kdW1wX2RpclxcJXMgMHgleC0tMHgleCAvbm9jbGVhclxuIiwKKyAgICAgICAgICAgICAgICAoY29uZmlnX2VudHJ5LT5uYW1lKSwKICAgICAgICAgICAgICAgICAgICAgKHVuc2lnbmVkIGludCljb25maWdfZW50cnktPnBoeSwgCi0gICAgICAgICAgICAgICAgICAgICh1bnNpZ25lZCBpbnQpKGNvbmZpZ19lbnRyeS0+cGh5ICsgY29uZmlnX2VudHJ5LT5zaXplKSk7CisgICAgICAgICAgICAgICAgKHVuc2lnbmVkIGludCkoY29uZmlnX2VudHJ5LT5waHkgKyBjb25maWdfZW50cnktPnNpemUpKTsKKyAgICAgICAgCiAgICAgICAgIGlfcmFtX2NvbmYrKzsKICAgICB9Ci0KICAgICByZXR1cm4gbWVtOwogfQogCkBAIC03NjksNyArODAwLDcgQEAKICAgICAgICAgICAgICh1bnNpZ25lZCBsb25nKU9TU19WSVJUX1RPX1BIWShyYW1kdW1wX3NlcnZlcl9jbW1fYnVmKSwgCiAgICAgICAgICAgICBjbW1fYnVmX2xlbiwgCiAgICAgICAgICAgICAodW5zaWduZWQgbG9uZylyYW1kdW1wX3NlcnZlcl9jbW1fYnVmLAotICAgICAgICAgICAgUkFNRFVNUF9GTEFHX05PTkUsCisgICAgICAgICAgICBSQU1EVU1QX0ZMQUdfTEVWRUxfSElHSCwKICAgICAgICAgICAgIDApOwogICAgIGVsc2UKICAgICAgICAgcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCkBAIC03NzcsNyArODA4LDcgQEAKICAgICAgICAgICAgICh1bnNpZ25lZCBsb25nKU9TU19WSVJUX1RPX1BIWShyYW1kdW1wX3NlcnZlcl9jbW1fYnVmKSwgCiAgICAgICAgICAgICBSQU1EVU1QX0NNTV9TSVpFLCAKICAgICAgICAgICAgICh1bnNpZ25lZCBsb25nKXJhbWR1bXBfc2VydmVyX2NtbV9idWYsCi0gICAgICAgICAgICBSQU1EVU1QX0ZMQUdfTk9ORSwKKyAgICAgICAgICAgIFJBTURVTVBfRkxBR19MRVZFTF9ISUdILAogICAgICAgICAgICAgMCk7CiB9CiAKQEAgLTc5MywxNiArODI0LDE2IEBACiB7CiAgICAgaW50IG9mZnNldCA9IDA7CiAgICAgY2hhciBlcnJfbG9nX25hbWVbUkFNRFVNUF9SQU1DT05GX0ZJTEVOQU1FX01BWExFTl0gPSB7MH07Ci0JCisgICAgCiAgICAgaWYgKHJhbWR1bXBfdHJhbnNfc2VydmVyX2ZvcmNlX3BhbmljX2ZsYWcgPT0gUkFNRFVNUF9DTElFTlRfWlNQKQogICAgICAgICBvZmZzZXQgPSBzcHJpbnRmKHJhbWR1bXBfc2VydmVyX2Vycm9yX2xvZywgInRyYW5zIHNlcnZlciByZWNlaXZlZCBmb3JjZSBkdW1wIHJlcXVlc3QgZnJvbSBaU1AgY2xpZW50ICFcbiIpOwotCWVsc2UgaWYgKHJhbWR1bXBfdHJhbnNfc2VydmVyX2ZvcmNlX3BhbmljX2ZsYWcgPT0gUkFNRFVNUF9DTElFTlRfTTApCi0JCW9mZnNldCA9IHNwcmludGYocmFtZHVtcF9zZXJ2ZXJfZXJyb3JfbG9nLCAidHJhbnMgc2VydmVyIHJlY2VpdmVkIGZvcmNlIGR1bXAgcmVxdWVzdCBmcm9tIE0wIGNsaWVudCAhXG4iKTsKKyAgICBlbHNlIGlmIChyYW1kdW1wX3RyYW5zX3NlcnZlcl9mb3JjZV9wYW5pY19mbGFnID09IFJBTURVTVBfQ0xJRU5UX00wKQorICAgICAgICBvZmZzZXQgPSBzcHJpbnRmKHJhbWR1bXBfc2VydmVyX2Vycm9yX2xvZywgInRyYW5zIHNlcnZlciByZWNlaXZlZCBmb3JjZSBkdW1wIHJlcXVlc3QgZnJvbSBNMCBjbGllbnQgIVxuIik7CiAgICAgZWxzZSBpZiAocmFtZHVtcF90cmFuc19zZXJ2ZXJfZm9yY2VfcGFuaWNfZmxhZyA9PSBSQU1EVU1QX0NMSUVOVF9DQVApCi0JCW9mZnNldCA9IHNwcmludGYocmFtZHVtcF9zZXJ2ZXJfZXJyb3JfbG9nLCAidHJhbnMgc2VydmVyIHJlY2VpdmVkIGZvcmNlIGR1bXAgcmVxdWVzdCBmcm9tIENBUCBjbGllbnQgIVxuIik7Ci0JZWxzZQorICAgICAgICBvZmZzZXQgPSBzcHJpbnRmKHJhbWR1bXBfc2VydmVyX2Vycm9yX2xvZywgInRyYW5zIHNlcnZlciByZWNlaXZlZCBmb3JjZSBkdW1wIHJlcXVlc3QgZnJvbSBDQVAgY2xpZW50ICFcbiIpOworICAgIGVsc2UKICAgICAgICAgb2Zmc2V0ID0gc3ByaW50ZihyYW1kdW1wX3NlcnZlcl9lcnJvcl9sb2csICJBUCBzZXJ2ZXIgYnJlYWtkb3duIGhhcHBlbnMgIVxuIik7Ci0JCisgICAgCiAgICAgcmFtZHVtcF9vc3NfZXJyb3JfbG9nX2NyZWF0KHJhbWR1bXBfc2VydmVyX2Vycm9yX2xvZyArIG9mZnNldCk7CiAgICAgLy8gZ2VuZXJhdGUgZXJyX2xvZyBuYW1lCiAgICAgc3ByaW50ZigKQEAgLTgxNiw0MiArODQ3LDQ2IEBACiAgICAgICAgICgoc3RybGVuKHJhbWR1bXBfc2VydmVyX2Vycm9yX2xvZykgPj0gUkFNRFVNUF9FUlJPUl9MT0dfU0laRSkgPyAKICAgICAgICAgUkFNRFVNUF9FUlJPUl9MT0dfU0laRSA6IHN0cmxlbihyYW1kdW1wX3NlcnZlcl9lcnJvcl9sb2cpKSwKICAgICAgICAgKHVuc2lnbmVkIGxvbmcpcmFtZHVtcF9zZXJ2ZXJfZXJyb3JfbG9nLAotICAgICAgICBSQU1EVU1QX0ZMQUdfTk9ORSwKKyAgICAgICAgUkFNRFVNUF9GTEFHX0xFVkVMX0hJR0gsCiAgICAgICAgIDApOwogfQogCi11bnNpZ25lZCBpbnQgcmFtZHVtcF9jYWxjX3RvdGFsX3JlZ2lvbnModm9pZCkKK3Vuc2lnbmVkIGludCByYW1kdW1wX2NhbGNfdG90YWxfcmVnaW9ucyh1bnNpZ25lZCBpbnQgcHJpb19leHApCiB7Ci0JdW5zaWduZWQgaW50IGluZGV4OwotCXVuc2lnbmVkIGludCBjbnQ7Ci0JaW50IHNraXAgPSAwOwotCi0JcmFtZHVtcF9zaG1fZmlsZV9udW0gPSBzaXplb2YocmFtZHVtcF9zaG1fZXhwb3J0X2ZpbGUpL3NpemVvZihyYW1kdW1wX3NobV9leHBvcnRfZmlsZVswXSk7Ci0KLQlmb3IgKGluZGV4ID0gMDsgaW5kZXggPCByYW1kdW1wX2ZpbGVfbnVtOyBpbmRleCsrKXsKKyAgICB1bnNpZ25lZCBpbnQgIGluZGV4OworICAgIHVuc2lnbmVkIGludCAgY250OworICAgIHVuc2lnbmVkIGxvbmcgZmxhZzsKKyAgICBib29sICBza2lwICAgICAgICAgPSBmYWxzZTsKKyAgICAgYm9vbCAgZXhwb3J0X29yZGVyID0gZmFsc2U7CisgICAgICAKKyAgICBmb3IgKGluZGV4ID0gMDsgaW5kZXggPCByYW1kdW1wX2ZpbGVfbnVtOyBpbmRleCsrKXsKICNpZmRlZiBfVVNFX1ZFSElDTEVfREMKLQkJaWYoKih1bnNpZ25lZCBpbnQgKilSQU1EVU1QX0VNTUNfVFJBTlNfRkxBR19BRERSID09IDEpewotCQkJZm9yIChjbnQgPSAwOyBjbnQgPCByYW1kdW1wX3NobV9maWxlX251bTsgY250KyspewotCQkJCWlmKHN0cmNtcChyYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpbmRleF0ubmFtZSwgcmFtZHVtcF9zaG1fZXhwb3J0X2ZpbGVbY250XSkgPT0gMCl7Ci0JCQkJCXNraXAgPSAxOwotCQkJCQlicmVhazsKLQkJCQl9Ci0JCQl9Ci0JCQlpZiAoc2tpcCA9PSAwKXsKLQkJCQlyYW1kdW1wX2V4cG9ydF9maWxlX2luZGV4W3JhbWR1bXBfZXhwcm90X2ZpbGVfbnVtXSA9IGluZGV4OwotCQkJCXJhbWR1bXBfZXhwcm90X2ZpbGVfbnVtKys7Ci0JCQl9Ci0JCQllbHNlCi0JCQkJc2tpcCA9IDA7Ci0JCX1lbHNleworICAgICAgICBpZiAoKHJhbWR1bXBfZXhwb3J0X21vZGUgPT0gUkFNRFVNUF9NT0RFX0VNTUMpCisgICAgICAgICAgICB8fCAocmFtZHVtcF9leHBvcnRfbW9kZSA9PSBSQU1EVU1QX01PREVfU1BJTkFORCkpIHsKKworICAgICAgICAgICAgc2tpcCA9IHJhbWR1bXBfZmlsZV9za2lwKGluZGV4KTsKKyAgICAgICAgICAgIGZsYWcgPSByYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpbmRleF0uZmxhZzsKKworICAgICAgICAgICAgaWYgKHByaW9fZXhwID09IFJBTURVTVBfRkxBR19OT05FKQorICAgICAgICAgICAgICAgIGV4cG9ydF9vcmRlciA9ICgoZmxhZyAmIFJBTURVTVBfQ0xFQVJfUFJJT19GTEFHKSA9PSBmbGFnKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBleHBvcnRfb3JkZXIgPSAgKChmbGFnICYgcHJpb19leHApID09IHByaW9fZXhwKTsKKworICAgICAgICAgICAgaWYgKHNraXAgPT0gZmFsc2UgJiYgKGV4cG9ydF9vcmRlciA9PSB0cnVlKSkgeworICAgICAgICAgICAgICAgIHJhbWR1bXBfZXhwb3J0X2ZpbGVfaW5kZXhbcmFtZHVtcF9leHByb3RfZmlsZV9udW1dID0gaW5kZXg7CisgICAgICAgICAgICAgICAgcmFtZHVtcF9leHByb3RfZmlsZV9udW0rKzsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBza2lwID0gZmFsc2U7CisgICAgICAgIH1lbHNlewogI2VuZGlmCi0JCQlyYW1kdW1wX2V4cG9ydF9maWxlX2luZGV4W3JhbWR1bXBfZXhwcm90X2ZpbGVfbnVtXSA9IGluZGV4OwotCQkJcmFtZHVtcF9leHByb3RfZmlsZV9udW0rKzsKKyAgICAgICAgICAgIHJhbWR1bXBfZXhwb3J0X2ZpbGVfaW5kZXhbcmFtZHVtcF9leHByb3RfZmlsZV9udW1dID0gaW5kZXg7CisgICAgICAgICAgICByYW1kdW1wX2V4cHJvdF9maWxlX251bSsrOwogI2lmZGVmIF9VU0VfVkVISUNMRV9EQwotCQl9CisgICAgICAgIH0KICNlbmRpZgotCX0KLQlyZXR1cm4gcmFtZHVtcF9leHByb3RfZmlsZV9udW07CisgICAgfQorICAgIHJldHVybiByYW1kdW1wX2V4cHJvdF9maWxlX251bTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIHJhbWR1bXBfd2FpdF9kZWxheSh1bnNpZ25lZCBsb25nIG1zKQpAQCAtODYwLDYgKzg5NSwyNiBAQAogICAgIGZvciAoaiA9IDA7IGogPCA1MDAwMCAqIG1zOyBqKyspOwogfQogCit2b2lkIHJhbWR1bXBfc29ydHByaW9fZ2V0bnVtKHZvaWQpCit7CisjaWZkZWYgX1VTRV9WRUhJQ0xFX0RDCisgICAgaWYoKHJhbWR1bXBfZXhwb3J0X21vZGUgIT0gUkFNRFVNUF9NT0RFX0VNTUMpIAorICAgICAgICAmJihyYW1kdW1wX2V4cG9ydF9tb2RlICE9IFJBTURVTVBfTU9ERV9TUElOQU5EKSkKKyAgICB7CisjZW5kaWYKKyAgICAgICAgcmFtZHVtcF9jYWxjX3RvdGFsX3JlZ2lvbnMoUkFNRFVNUF9GTEFHX05PTkUpOworI2lmZGVmIF9VU0VfVkVISUNMRV9EQworICAgIH0KKyAgICBlbHNlCisgICAgeworICAgICAgICByYW1kdW1wX2NhbGNfdG90YWxfcmVnaW9ucyhSQU1EVU1QX0ZMQUdfTEVWRUxfSElHSCk7CisgICAgICAgIHJhbWR1bXBfY2FsY190b3RhbF9yZWdpb25zKFJBTURVTVBfRkxBR19MRVZFTF9NRURJVU0pOworICAgICAgICByYW1kdW1wX2NhbGNfdG90YWxfcmVnaW9ucyhSQU1EVU1QX0ZMQUdfTEVWRUxfTE9XKTsKKyAgICAgICAgcmFtZHVtcF9jYWxjX3RvdGFsX3JlZ2lvbnMoUkFNRFVNUF9GTEFHX05PTkUpOworICAgIH0KKyNlbmRpZgorfQorCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiC5psTcw+jK9jogICAgcmFtZHVtcF9kYXRhX3RyYW5zZmVyX3RvX3BjCiAqILLOyv3LtcP3OiAgICAgCkBAIC04NzAsMTQgKzkyNSwxMiBAQAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIHN0YXRpYyB2b2lkIHJhbWR1bXBfZGF0YV90cmFuc2Zlcl90b19wYyh2b2lkKQogewotCWludCBmaWxlX2lkID0gMDsKLQl1bnNpZ25lZCBpbnQgcmFtZHVtcF9maWxlX25yID0gMDsKKyAgICBpbnQgZmlsZV9pZCA9IDA7CiAgICAgY2hhciByZXFfYnVmW1JBTURVTVBfSU5URVJBQ1RJVkVfREFUQV9MRU5dID0gezB9OwogCiAgICAgLyogaW50ZXJhY3RpdmUgYmVnaW4gKi8KICAgICByYW1kdW1wX29zc19kYXRhX3RyYW5zX2luaXQoKTsKLQotCXJhbWR1bXBfZmlsZV9uciA9IHJhbWR1bXBfY2FsY190b3RhbF9yZWdpb25zKCk7CisgICAgcmFtZHVtcF9zb3J0cHJpb19nZXRudW0oKTsKIAogICAgIGZvcig7OykKICAgICB7CkBAIC04ODgsNyArOTQxLDcgQEAKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICByYW1kdW1wX3RyYW5zX3NlcnZlcl9pbnRlcmFjdGl2ZV9yc3Agc2VydmVyX3RvX3BjX21zZyA9IHswfTsKICAgICAgICAgICAgICAgICBzZXJ2ZXJfdG9fcGNfbXNnLmNtZCA9IFJBTURVTVBfVFJBTlNfU0VSVkVSX0lOVEVSQUNUSVZFX1JTUDsKLSAgICAgICAgICAgICAgICBzZXJ2ZXJfdG9fcGNfbXNnLmZpbGVfbnVtID0gcmFtZHVtcF9maWxlX25yOworICAgICAgICAgICAgICAgIHNlcnZlcl90b19wY19tc2cuZmlsZV9udW0gPSByYW1kdW1wX2V4cHJvdF9maWxlX251bTsKIAogICAgICAgICAgICAgICAgIHJhbWR1bXBfb3NzX2RhdGFfdHJhbnNfd3JpdGUoCiAgICAgICAgICAgICAgICAgICAgICh1bnNpZ25lZCBjaGFyKikoJnNlcnZlcl90b19wY19tc2cpLApAQCAtMTAyNCwyMiArMTA3NywyMiBAQAogICAgICAgICB1bnNpZ25lZCBsb25nIHJhbV9leHRyYSkKIHsKICAgICBzdGF0aWMgdW5zaWduZWQgaW50IGlfZW50cnkgID0gMDsKLQkKKyAgICAKICAgICBpZiAoKHJhbV9waHkgPT0gMCkgJiYgKHJhbV9zaXplID09IDApKQogICAgICAgICByZXR1cm47CiAKICAgICBtdXRleF9sb2NrKCZyYW1kdW1wX211dGV4KTsKLQkKKyAgICAKICAgICBzdHJuY3B5KHJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2lfZW50cnldLm5hbWUsIAogICAgICAgICAgICAgcmFtX25hbWUsIAogICAgICAgICAgICAgUkFNRFVNUF9SQU1DT05GX0ZJTEVOQU1FX01BWExFTiAtIDEpOwotCXJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2lfZW50cnldLm5hbWVbUkFNRFVNUF9SQU1DT05GX0ZJTEVOQU1FX01BWExFTiAtIDFdID0gJ1wwJzsKKyAgICByYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX2VudHJ5XS5uYW1lW1JBTURVTVBfUkFNQ09ORl9GSUxFTkFNRV9NQVhMRU4gLSAxXSA9ICdcMCc7CiAgICAgcmFtZHVtcF90cmFuc19zZXJ2ZXJfcmFtX2NvbmZbaV9lbnRyeV0ucGh5ICAgPSByYW1fcGh5OwogICAgIHJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2lfZW50cnldLnNpemUgID0gcmFtX3NpemU7CiAgICAgcmFtZHVtcF90cmFuc19zZXJ2ZXJfcmFtX2NvbmZbaV9lbnRyeV0udmlyICAgPSByYW1fdmlydDsKICAgICByYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX2VudHJ5XS5mbGFnICA9IHJhbV9mbGFnOwogCi0gICAgc3dpdGNoIChyYW1fZmxhZykKKyAgICBzd2l0Y2ggKHJhbV9mbGFnICYgUkFNRFVNUF9DTEVBUl9QUklPX0ZMQUcpCiAgICAgewogICAgICAgICBjYXNlIFJBTURVTVBfRkxBR19ORUVEX0NPUFk6CiAgICAgICAgICAgICByYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX2VudHJ5XS5leHRlciAgPSByYW1fZXh0cmE7CkBAIC0xMDU4LDEyICsxMTExLDEyIEBACiAgICAgaWYgKHJhbV9waHkgIT0gMCAmJiByYW1fc2l6ZSAhPSAwKQogICAgICAgICByYW1kdW1wX3RyYW5zX3NlcnZlcl9yYW1fY29uZltpX2VudHJ5XS52aXIgPSByYW1kdW1wX3BoeV90b192aXIoJnJhbWR1bXBfdHJhbnNfc2VydmVyX3JhbV9jb25mW2lfZW50cnldKTsKICAgICAKLQlpX2VudHJ5Kys7Ci0JCisgICAgaV9lbnRyeSsrOworICAgIAogICAgIGlmIChpX2VudHJ5ID49IFJBTURVTVBfUkFNQ09ORl9UQUJMRV9NQVhfRU5UUllTKSAgICAgIAotCQlpX2VudHJ5ID0gMDsKKyAgICAgICAgaV9lbnRyeSA9IDA7CiAKLQlyYW1kdW1wX2ZpbGVfbnVtICsrOworICAgIHJhbWR1bXBfZmlsZV9udW0gKys7CiAgICAgbXV0ZXhfdW5sb2NrKCZyYW1kdW1wX211dGV4KTsgCiB9CiBFWFBPUlRfU1lNQk9MKHJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKTsKQEAgLTEwODcsMTggKzExNDAsMTggQEAKICAgICAgICAgcmV0dXJuIFJBTURVTVBfU1VDQ0VTUzsKIAogICAgIGludCByZXQgPSAwOwotCWludCBpID0gMDsKKyAgICBpbnQgaSA9IDA7CiAgICAgY2hhciBiaW5fbmFtZVtSQU1EVU1QX1JBTUNPTkZfRklMRU5BTUVfTUFYTEVOXSA9IHswfTsKLQkKLQlmb3IoaSA9IDA7aSA8IG1lbWluZm8ubnJfYmFua3M7aSsrKSB7Ci0JCWlmKG1lbWluZm8uYmFua1tpXS5zdGFydCA9PSBSQU1EVU1QX1NFUlZFUl9ERFJfQkFTRSkKLQkJCWRkcl9hcF9zaXplID0gbWVtaW5mby5iYW5rW2ldLnNpemU7Ci0JfQotCUJVR19PTihkZHJfYXBfc2l6ZSA9PSAwKTsKKyAgICAKKyAgICBmb3IoaSA9IDA7aSA8IG1lbWluZm8ubnJfYmFua3M7aSsrKSB7CisgICAgICAgIGlmKG1lbWluZm8uYmFua1tpXS5zdGFydCA9PSBSQU1EVU1QX1NFUlZFUl9ERFJfQkFTRSkKKyAgICAgICAgICAgIGRkcl9hcF9zaXplID0gbWVtaW5mby5iYW5rW2ldLnNpemU7CisgICAgfQorICAgIEJVR19PTihkZHJfYXBfc2l6ZSA9PSAwKTsKIAogICAgIC8qIGNoYW5nZSB0aGUgaW50ZXJhY3RpdmUgY3B1IHZhbHVlICovCi0JcmFtZHVtcF9jcHVfaWRbUkFNRFVNUF9DUFVfMl0gPSBJQ1BfTVNHX0FDVE9SX1pTUDsKLQkKKyAgICByYW1kdW1wX2NwdV9pZFtSQU1EVU1QX0NQVV8yXSA9IElDUF9NU0dfQUNUT1JfWlNQOworICAgIAogICAgIC8qIGNsaWVudCBpY3AgaW5pdCAqLwogICAgIHJldCA9IHJhbWR1bXBfaWNwX2luaXQoKTsKICAgICBpZiAocmV0ICE9IFJBTURVTVBfSUNQX1NVQ0NFU1MpCkBAIC0xMTE0LDcgKzExNjcsNyBAQAogICAgICAgICBSQU1EVU1QX1NFUlZFUl9ERFJfQkFTRSwgCiAgICAgICAgIGRkcl9hcF9zaXplLCAKICAgICAgICAgKHVuc2lnbmVkIGxvbmcpT1NTX1BIWV9UT19WSVJUKFJBTURVTVBfU0VSVkVSX0REUl9CQVNFKSwKLSAgICAgICAgUkFNRFVNUF9GTEFHX05PTkUsCisgICAgICAgIFJBTURVTVBfRkxBR19MRVZFTF9NRURJVU0sCiAgICAgICAgIDApOwogCiAgICAgcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCkBAIC0xMTIyLDgxICsxMTc1LDgxIEBACiAgICAgICAgIFJBTURVTVBfU0VSVkVSX0REUl9CQVNFLCAKICAgICAgICAgMHgxMDAwLCAKICAgICAgICAgKHVuc2lnbmVkIGxvbmcpT1NTX1BIWV9UT19WSVJUKFJBTURVTVBfU0VSVkVSX0REUl9CQVNFKSwKLSAgICAgICAgUkFNRFVNUF9GTEFHX0hBU19DQUxMQkFDSywKKyAgICAgICAgUkFNRFVNUF9GTEFHX0hBU19DQUxMQkFDS3xSQU1EVU1QX0ZMQUdfTEVWRUxfTE9XLAogICAgICAgICB0ZXN0X2Z1bik7Ci0JCi0jaWZkZWYgQ09ORklHX01FTV9UUkFDS0VSCQotCXJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAotCQkibWVtX3RyYWNrZXIuYmluIiwgCi0JCVpYMjlfTUVNX1RSQUNLRVJfUEhZUywgCi0JCVpYX01FTV9UUkFDS0VSX1NJWkUsCi0JCVpYX01FTV9UUkFDS0VSX0JBU0UsCi0JCVJBTURVTVBfRkxBR19OT05FLAotCQkwKTsKLQlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKLQkJImttYWxsb2NfdHJhY2tlci5iaW4iLCAKLQkJWlgyOV9LTUFMTE9DX1RSQUNLRVJfUEhZUywKLQkJWlhfS01BTExPQ19UUkFDS0VSX1NJWkUsCi0JCVpYX0tNQUxMT0NfVFJBQ0tFUl9CQVNFLAotCQlSQU1EVU1QX0ZMQUdfTk9ORSwKLQkJMCk7CisgICAgCisjaWZkZWYgQ09ORklHX01FTV9UUkFDS0VSICAgIAorICAgIHJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAorICAgICAgICAibWVtX3RyYWNrZXIuYmluIiwgCisgICAgICAgIFpYMjlfTUVNX1RSQUNLRVJfUEhZUywgCisgICAgICAgIFpYX01FTV9UUkFDS0VSX1NJWkUsCisgICAgICAgIFpYX01FTV9UUkFDS0VSX0JBU0UsCisgICAgICAgIFJBTURVTVBfRkxBR19MRVZFTF9MT1csCisgICAgICAgIDApOworICAgIHJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAorICAgICAgICAia21hbGxvY190cmFja2VyLmJpbiIsIAorICAgICAgICBaWDI5X0tNQUxMT0NfVFJBQ0tFUl9QSFlTLAorICAgICAgICBaWF9LTUFMTE9DX1RSQUNLRVJfU0laRSwKKyAgICAgICAgWlhfS01BTExPQ19UUkFDS0VSX0JBU0UsCisgICAgICAgIFJBTURVTVBfRkxBR19MRVZFTF9MT1csCisgICAgICAgIDApOwogI2VuZGlmCiAjaWZkZWYgX1VTRV9DQVBfU1lTCi0JLyogY2FwIHJhbWR1bXAgY21tICovCi0JcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCi0JCQkiY2FwX2Rkci5iaW4iLCAKLQkJCUREUl9CQVNFX0NBUF9BRERSX1BBLCAKLQkJCSpjYXBfZGRyX3NpemUsCi0JCQkwLAotCQkJUkFNRFVNUF9GTEFHX05PTkUsCi0JCQkwKTsKKyAgICAvKiBjYXAgcmFtZHVtcCBjbW0gKi8KKyAgICByYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKKyAgICAgICAgICAgICJjYXBfZGRyLmJpbiIsIAorICAgICAgICAgICAgRERSX0JBU0VfQ0FQX0FERFJfUEEsIAorICAgICAgICAgICAgKmNhcF9kZHJfc2l6ZSwKKyAgICAgICAgICAgIDAsCisgICAgICAgICAgICBSQU1EVU1QX0ZMQUdfTEVWRUxfTE9XLAorICAgICAgICAgICAgMCk7CiAKLQlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKKyAgICByYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKICAgICAgICAgImNhcC5jbW0iLCAKICAgICAgICAgUkFNRFVNUF9DQVBfQ01NX0JVRl9BRERSX1BIWSwKICAgICAgICAgUkFNRFVNUF9DQVBfQ01NX0JVRl9MRU5fUkVBTCwKICAgICAgICAgMCwKLSAgICAgICAgUkFNRFVNUF9GTEFHX05PTkUsCisgICAgICAgIFJBTURVTVBfRkxBR19MRVZFTF9MT1csCiAgICAgICAgIDApOwotCXJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAorICAgIHJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAogICAgICAgICAiY2FwX2Vycl9sb2cudHh0IiwgCiAgICAgICAgIFJBTURVTVBfQ0FQX0xPR19CVUZfQUREUiwKICAgICAgICAgUkFNRFVNUF9DQVBfTE9HX0JVRl9MRU4sCiAgICAgICAgIDAsCi0gICAgICAgIFJBTURVTVBfRkxBR19OT05FLAorICAgICAgICBSQU1EVU1QX0ZMQUdfTEVWRUxfTE9XLAogICAgICAgICAwKTsKLQlyYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKKyAgICByYW1kdW1wX3JhbV9jb25mX3RhYmxlX2FkZCgKICAgICAgICAgInJwbXNnX2NhcC5iaW4iLCAKICAgICAgICAgSUNQX0NBUF9CVUZfQUREUl9QQSwKICAgICAgICAgSUNQX0NBUF9CVUZfTEVOLAogICAgICAgICAwLAotICAgICAgICBSQU1EVU1QX0ZMQUdfTk9ORSwKKyAgICAgICAgUkFNRFVNUF9GTEFHX0xFVkVMX0xPVywKICAgICAgICAgMCk7Ci0JcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCisgICAgcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCiAgICAgICAgICJwaHlfbG9nX2J1ZmZlci5iaW4iLCAKICAgICAgICAgVE9PTF9aU1BfVE9fQ0FQX0xPR19BRERSX1BBLAogICAgICAgICBUT09MX1pTUF9UT19DQVBfTE9HX0xFTiwKICAgICAgICAgMCwKLSAgICAgICAgUkFNRFVNUF9GTEFHX05PTkUsCisgICAgICAgIFJBTURVTVBfRkxBR19MRVZFTF9MT1csCiAgICAgICAgIDApOwotCXJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAorICAgIHJhbWR1bXBfcmFtX2NvbmZfdGFibGVfYWRkKAogICAgICAgICAiVEVFLmJpbiIsIAogICAgICAgICBURUVfU0hBUkVfQlVGX0FERFJfUEEsCiAgICAgICAgIFRFRV9TSEFSRV9CVUZfTEVOLAogICAgICAgICAwLAotICAgICAgICBSQU1EVU1QX0ZMQUdfTk9ORSwKKyAgICAgICAgUkFNRFVNUF9GTEFHX0xFVkVMX0xPVywKICAgICAgICAgMCk7Ci0JcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCisgICAgcmFtZHVtcF9yYW1fY29uZl90YWJsZV9hZGQoCiAgICAgICAgICJjYXBfa2FwcF9sb2cuYmluIiwgCiAgICAgICAgIFRPT0xfQ0FQX0JVRl9BRERSX1BBLAogICAgICAgICBUT09MX0NBUF9CVUZfTEVOLAogICAgICAgICAwLAotICAgICAgICBSQU1EVU1QX0ZMQUdfTk9ORSwKKyAgICAgICAgUkFNRFVNUF9GTEFHX0xFVkVMX0xPVywKICAgICAgICAgMCk7CiAjZW5kaWYKIAogI2lmZGVmIF9VU0VfVkVISUNMRV9EQwotCXJhbWR1bXBfc2hhcmVkX21lbV9pbml0KCk7CisgICAgcmFtZHVtcF9zaGFyZWRfbWVtX2luaXQoKTsKICNlbmRpZgogCiAgICAgLyogc2V0IHRyYW5zIHJhbSBkYXRhIGRvbmUgZmxhZyAqLwpAQCAtMTIzNCw2ICsxMjg3LDIxIEBACiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisqILmmxNzD6Mr2OiAgICAgcmFtZHVtcF9nZXRfdHJhbnNfbW9kZQorKiCyzsr9y7XD9zogICAgIAorKiAgICi0q8jrss7K/SkgIHZvaWQKKyogICAotKuz9rLOyv0pICB2b2lkCisqILe1ILvYINa1OiAgICAgdm9pZAorKiDG5Mv8y7XD9zogICAgIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCBmb3IgcmVhZCByYW1kdW1wIG1vZGUKKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCit2b2lkIHJhbWR1bXBfZ2V0X3RyYW5zX21vZGUodm9pZCkKK3sKKyNpZmRlZiBfVVNFX1ZFSElDTEVfREMgCisgICAgcmFtZHVtcF9leHBvcnRfbW9kZSA9ICoodW5zaWduZWQgaW50ICopUkFNRFVNUF9FTU1DX1RSQU5TX0ZMQUdfQUREUjsgCisjZW5kaWYKK30KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoguabE3MPoyvY6ICAgICByYW1kdW1wX2VudHJ5CiAqILLOyv3LtcP3OiAgICAgCiAqICAgKLSryOuyzsr9KSAgdm9pZApAQCAtMTI1MiwxNCArMTMyMCwxNCBAQAogICAgICAgICAgICAgQ1BQU19GVU5DKGNwcHNfY2FsbGJhY2tzLCB6U3lzX0V4Y2VwdFJlYm9vdCkoMCk7CiAgICAgfQogI2Vsc2UKLQllbWVyZ2VuY3lfcmVzdGFydCgpOworICAgIGVtZXJnZW5jeV9yZXN0YXJ0KCk7CiAjZW5kaWYKIAogI2lmZGVmIENPTkZJR19aWDI5X1dBVENIRE9HCi0Jenhfd2R0X20wX3N0b3AoKTsKKyAgICB6eF93ZHRfbTBfc3RvcCgpOwogI2VuZGlmCiAKLQlpZiAoc3lzY3RsX3JhbWR1bXBfb25fcGFuaWMgPT0gRkFMU0UpCisgICAgaWYgKHN5c2N0bF9yYW1kdW1wX29uX3BhbmljID09IEZBTFNFKQogICAgICAgICByZXR1cm47CiAKICAgICAvKgpAQCAtMTI3NSw2ICsxMzQzLDggQEAKICAgICBpZiAoKytyYW1kdW1wX2NvdW50ID4gMSkKICAgICAgICAgd2hpbGUoVFJVRSk7IC8qIGVuZGxlc3MgY2lyY2xlICovCiAKKyAgICByYW1kdW1wX2dldF90cmFuc19tb2RlKCk7CisKICAgICAvKgogICAgICAqIHNhdmUgYWxsIHJlZ3MgZmlyc3QuCiAgICAgICovCkBAIC0xMjg2LDggKzEzNTYsOCBAQAogICAgIC8qIGVycm9yIGxvZyBmaWxlICovCiAgICAgcmFtZHVtcF90cmFuc19zZXJ2ZXJfZXJyb3JfbG9nX2NyZWF0ZSgpOwogCi0JLyogbG9nIGJ1ZiAqLwotCXJhbWR1bXBfb3NzX2xvZ2J1Zl9jcmVhdGUoKTsKKyAgICAvKiBsb2cgYnVmICovCisgICAgcmFtZHVtcF9vc3NfbG9nYnVmX2NyZWF0ZSgpOwogCiAgICAgLyogbm90aWZ5IGNsaWVudCByYW1kdW1wICovCiAgICAgcmFtZHVtcF9ub3RpZnlfY2xpZW50X2R1bXAoKTsKZGlmZiAtLWdpdCBhL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L25ldC9zb2NrZXRfcnBtc2cuYyBiL2FwL29zL2xpbnV4L2xpbnV4LTMuNC54L25ldC9zb2NrZXRfcnBtc2cuYwppbmRleCA4YjIyNWI2Li5lN2IyMDc2IDEwMDc1NQotLS0gYS9hcC9vcy9saW51eC9saW51eC0zLjQueC9uZXQvc29ja2V0X3JwbXNnLmMKKysrIGIvYXAvb3MvbGludXgvbGludXgtMy40LngvbmV0L3NvY2tldF9ycG1zZy5jCkBAIC0yNDEsOCArMjQxLDggQEAKIAlzcGluX2xvY2soJnNvY2tfdGFibGVfbG9jayk7DQogCWlmKGhsaXN0X2VtcHR5KCZnX2lwY19zb2NrZXRzKSkNCiAJew0KLQkJc2tfc29jX3dhcm4oInNvY2tfcHJpbnRfaXBjX3NvY2tldF9pbmZvICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlzcGluX3VubG9jaygmc29ja190YWJsZV9sb2NrKTsNCisJCXNrX3NvY193YXJuKCJzb2NrX3ByaW50X2lwY19zb2NrZXRfaW5mbyAgZ19pcGNfc29ja2V0cyBpcyBlbXB0eSIpOw0KIAkJcmV0dXJuIDA7DQogCX0NCiAJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwLCBwb3MsIG4sICZnX2lwY19zb2NrZXRzLCBobGlzdF9ub2RlKSB7DQpAQCAtMzI4LDggKzMyOCw4IEBACiAJc3Bpbl9sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KIAlpZihobGlzdF9lbXB0eSgmZ19pcGNfc29ja2V0cykpDQogCXsNCi0JCXNrX3NvY19pbmZvKCJzb2NrX3NvY19nZXRfaXBjc29ja2V0X2J5X3Byb3h5c29jayAgZ19pcGNfc29ja2V0cyBpcyBlbXB0eSIpOw0KIAkJc3Bpbl91bmxvY2soJnNvY2tfdGFibGVfbG9jayk7DQorCQlza19zb2NfaW5mbygic29ja19zb2NfZ2V0X2lwY3NvY2tldF9ieV9wcm94eXNvY2sgIGdfaXBjX3NvY2tldHMgaXMgZW1wdHkiKTsNCiAJCXJldHVybiBOVUxMOw0KIAl9DQogCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocCwgcG9zLCBuLCAmZ19pcGNfc29ja2V0cywgaGxpc3Rfbm9kZSkgew0KQEAgLTM1MCw4ICszNTAsOCBAQAogCXNwaW5fbG9jaygmc29ja190YWJsZV9sb2NrKTsNCiAJaWYoaGxpc3RfZW1wdHkoJmdfaXBjX3NvY2tldHMpKQ0KIAl7DQotCQlza19zb2NfaW5mbygic29ja19zb2NfZ2V0X2lwY3NvY2tldF9ieV9wcm94eXNvY2sgIGdfaXBjX3NvY2tldHMgaXMgZW1wdHkiKTsNCiAJCXNwaW5fdW5sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KKwkJc2tfc29jX2luZm8oInNvY2tfc29jX2dldF9pcGNzb2NrZXRfYnlfcHJveHlzb2NrICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlyZXR1cm4gTlVMTDsNCiAJfQ0KIAlobGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHAsIHBvcywgbiwgJmdfaXBjX3NvY2tldHMsIGhsaXN0X25vZGUpIHsNCkBAIC0zNzIsOCArMzcyLDggQEAKIAlzcGluX2xvY2soJnNvY2tfdGFibGVfbG9jayk7DQogCWlmKGhsaXN0X2VtcHR5KCZnX2lwY19zb2NrZXRzKSkNCiAJew0KLQkJc2tfc29jX2luZm8oInNvY2tfZ2V0X2lwY3NvY2tldF9ieV9sb2NhbF9hbmRfcmVtb3RlICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlzcGluX3VubG9jaygmc29ja190YWJsZV9sb2NrKTsNCisJCXNrX3NvY19pbmZvKCJzb2NrX2dldF9pcGNzb2NrZXRfYnlfbG9jYWxfYW5kX3JlbW90ZSAgZ19pcGNfc29ja2V0cyBpcyBlbXB0eSIpOw0KIAkJcmV0dXJuIE5VTEw7DQogCX0NCiAJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwLCBwb3MsIG4sICZnX2lwY19zb2NrZXRzLCBobGlzdF9ub2RlKSB7DQpAQCAtMzkzLDggKzM5Myw4IEBACiAJc3Bpbl9sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KIAlpZihobGlzdF9lbXB0eSgmZ19pcGNfc29ja2V0cykpDQogCXsNCi0JCXNrX3NvY19pbmZvKCJzb2NrX2RlbF9pcGNfc29ja2V0X2J5X3Byb3h5c29ja2V0ICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlzcGluX3VubG9jaygmc29ja190YWJsZV9sb2NrKTsNCisJCXNrX3NvY19pbmZvKCJzb2NrX2RlbF9pcGNfc29ja2V0X2J5X3Byb3h5c29ja2V0ICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlyZXR1cm4gLTE7DQogCX0NCiAJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwLCBwb3MsIG4sICZnX2lwY19zb2NrZXRzLCBobGlzdF9ub2RlKSB7DQpAQCAtNDE3LDggKzQxNyw4IEBACiAJc3Bpbl9sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KIAlpZihobGlzdF9lbXB0eSgmZ19pcGNfc29ja2V0cykpDQogCXsNCi0JCXNrX3NvY19pbmZvKCJzb2NrX2lzX3ZhbGlkZV9pcGNfc29ja2V0ICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlzcGluX3VubG9jaygmc29ja190YWJsZV9sb2NrKTsNCisJCXNrX3NvY19pbmZvKCJzb2NrX2lzX3ZhbGlkZV9pcGNfc29ja2V0ICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlyZXR1cm4gLTE7DQogCX0NCiAJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwLCBwb3MsIG4sICZnX2lwY19zb2NrZXRzLCBobGlzdF9ub2RlKSB7DQpAQCAtNTQxLDggKzU0MSw4IEBACiAJc3Bpbl9sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KIAlpZihobGlzdF9lbXB0eSgmZ19pcGNfc29ja2V0cykpDQogCXsNCi0JCXNrX3NvY19pbmZvKCJzb2NrX3NvY19zb2NrZXRfaXNfdmFsaWQgIGdfaXBjX3NvY2tldHMgaXMgZW1wdHkiKTsNCiAJCXNwaW5fdW5sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KKwkJc2tfc29jX2luZm8oInNvY2tfc29jX3NvY2tldF9pc192YWxpZCAgZ19pcGNfc29ja2V0cyBpcyBlbXB0eSIpOw0KIAkJcmV0dXJuIC0xOw0KIAl9DQogCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocCwgcG9zLCBuLCAmZ19pcGNfc29ja2V0cywgaGxpc3Rfbm9kZSkgew0KQEAgLTU2Myw4ICs1NjMsOCBAQAogCXNwaW5fbG9jaygmc29ja190YWJsZV9sb2NrKTsNCiAJaWYoaGxpc3RfZW1wdHkoJmdfaXBjX3NvY2tldHMpKQ0KIAl7DQotCQlza19zb2NfaW5mbygic29ja19zb2NfZGVsX3NvY2tldF9pbmZvICBnX2lwY19zb2NrZXRzIGlzIGVtcHR5Iik7DQogCQlzcGluX3VubG9jaygmc29ja190YWJsZV9sb2NrKTsNCisJCXNrX3NvY19pbmZvKCJzb2NrX3NvY19kZWxfc29ja2V0X2luZm8gIGdfaXBjX3NvY2tldHMgaXMgZW1wdHkiKTsNCiAJCXJldHVybiAtMTsNCiAJfQ0KIAlobGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHAsIHBvcywgbiwgJmdfaXBjX3NvY2tldHMsIGhsaXN0X25vZGUpIHsNCkBAIC01OTMsOCArNTkzLDggQEAKIAlzcGluX2xvY2soJnNvY2tfdGFibGVfbG9jayk7DQogCWlmKGhsaXN0X2VtcHR5KCZnX2lwY19zb2NrZXRzKSkNCiAJew0KLQkJc2tfc29jX2luZm8oInNvY2tfc29jX3NvY2tldF9pc192YWxpZF9pcGMgIGdfaXBjX3NvY2tldHMgaXMgZW1wdHkiKTsNCiAJCXNwaW5fdW5sb2NrKCZzb2NrX3RhYmxlX2xvY2spOw0KKwkJc2tfc29jX2luZm8oInNvY2tfc29jX3NvY2tldF9pc192YWxpZF9pcGMgIGdfaXBjX3NvY2tldHMgaXMgZW1wdHkiKTsNCiAJCXJldHVybiAtMTsNCiAJfQ0KIAlobGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHAsIHBvcywgbiwgJmdfaXBjX3NvY2tldHMsIGhsaXN0X25vZGUpIHsNCkBAIC02NzcsMTMgKzY3NywxMyBAQAogCQlpZigocC0+c29ja2FkZHIuc3VuX2ZhbWlseSA9PSBwc29ja2FkZHJfdW4tPnN1bl9mYW1pbHkpICYmICgwID09IHJldCkpew0KIAkJCWhsaXN0X2RlbCgmcC0+aGxpc3Rfbm9kZSk7CQkJDQogCQkJa2ZyZWUocCk7DQotCQkJc2tfc29jX2luZm8oInN1bl9wYXRoPSVzLCBkZWwgc3VjZXNzLiIsIHBzb2NrYWRkcl91bi0+c3VuX3BhdGgpOw0KIAkJCXNwaW5fdW5sb2NrKCZzb2NrX3NvY2tldGFkZHJfdGFibGVfbG9jayk7DQorCQkJc2tfc29jX2luZm8oInN1bl9wYXRoPSVzLCBkZWwgc3VjZXNzLiIsIHBzb2NrYWRkcl91bi0+c3VuX3BhdGgpOw0KIAkJCXJldHVybiAwOw0KIAkJfQ0KIAl9DQotCXNrX3NvY19pbmZvKCJzdW5fcGF0aD0lcywgZGVsIGZhaWxlZCIsIHBzb2NrYWRkcl91bi0+c3VuX3BhdGgpOw0KIAlzcGluX3VubG9jaygmc29ja19zb2NrZXRhZGRyX3RhYmxlX2xvY2spOw0KKwlza19zb2NfaW5mbygic3VuX3BhdGg9JXMsIGRlbCBmYWlsZWQiLCBwc29ja2FkZHJfdW4tPnN1bl9wYXRoKTsNCiAJcmV0dXJuIC0xOw0KIH0NCiANCkBAIC0yMzA5LDggKzIzMDksOCBAQAogCXNwaW5fbG9jaygmc29ja19yZWxlYXNlX2xvY2spOw0KIAkvL8XQts9zb2NrZXTQxc+iyse38bu51Nq0+sDtwbSx7dbQDQogCWlmKDAgIT0gc29ja19pc192YWxpZGVfaXBjX3NvY2tldChwc29ja19ycG1zZy0+c2VydmVyc29jaywgcHNvY2tfcnBtc2ctPnNlcnZlcnByb3h5c29jaywgcHNvY2tfcnBtc2ctPmNsaWVudHNvY2spKXsNCi0JCXNrX3NvY19pbmZvKCJzb2NrX3NvY19yZWxlYXNlX3BlZXJfcHJvYyBmYWlsZWQsIHNvY2tfaXNfdmFsaWRlX2lwY19zb2NrZXQ9ZmFsc2UgXG4iKTsNCiAJCXNwaW5fdW5sb2NrKCZzb2NrX3JlbGVhc2VfbG9jayk7DQorCQlza19zb2NfaW5mbygic29ja19zb2NfcmVsZWFzZV9wZWVyX3Byb2MgZmFpbGVkLCBzb2NrX2lzX3ZhbGlkZV9pcGNfc29ja2V0PWZhbHNlIFxuIik7DQogCQlyZXR1cm4gLTE7DQogCX0NCiAJDQo=