LyoKICogbGludXgvZHJpdmVycy9zZXJpYWwvczNjMjQxMC5jCiAqCiAqIERyaXZlciBmb3Igb25ib2FyZCBVQVJUcyBvbiB0aGUgU2Ftc3VuZyBTM0MyNFhYCiAqCiAqIEJhc2VkIG9uIGRyaXZlcnMvY2hhci9zZXJpYWwuYyBhbmQgZHJpdmVycy9jaGFyLzIxMjg1LmMKICoKICogQmVuIERvb2tzLCAoYykgMjAwMy0yMDA1IFNpbXRlYyBFbGVjdHJvbmljcwogKglodHRwOi8vd3d3LnNpbXRlYy5jby51ay9wcm9kdWN0cy9TV0xJTlVYLwogKgogKiBDaGFuZ2Vsb2c6CiAqCiAqIDIyLUp1bC0yMDA0ICBCSkQgIEZpbmlzaGVkIG9mZiBkZXZpY2UgcmV3cml0ZQogKgogKiAyMS1KdWwtMjAwNCAgQkpEICBUaGFua3MgdG8gPGhlcmJldEAxM3RoZmxvb3IuYXQ+IGZvciBwb2ludGluZyBvdXQKICogICAgICAgICAgICAgICAgICAgcHJvYmxlbXMgd2l0aCBiYXVkIHJhdGUgYW5kIGxvc3Mgb2YgSVIgc2V0dGluZ3MuIFVwZGF0ZQogKiAgICAgICAgICAgICAgICAgICB0byBhZGQgY29uZmlndXJhdGlvbiB2aWEgcGxhdGZvcm1fZGV2aWNlIHN0cnVjdHVyZQogKgogKiAyOC1TZXAtMjAwNCAgQkpEICBSZS13cml0ZSBmb3IgdGhlIGZvbGxvd2luZyBpdGVtcwogKgkJICAgICAtIFMzQzI0MTAgYW5kIFMzQzI0NDAgc2VyaWFsIHN1cHBvcnQKICoJCSAgICAgLSBQb3dlciBNYW5hZ2VtZW50IHN1cHBvcnQKICoJCSAgICAgLSBGaXggY29uc29sZSB2aWEgSXJEQSBkZXZpY2VzCiAqCQkgICAgIC0gU3lzUmVxIChIZXJiZXJ0IFD2dHpsKQogKgkJICAgICAtIEJyZWFrIGNoYXJhY3RlciBoYW5kbGluZyAoSGVyYmVydCBQ9nR6bCkKICoJCSAgICAgLSBzcGluLWxvY2sgaW5pdGlhbGlzYXRpb24gKERpbWl0cnkgQW5kcmljKQogKgkJICAgICAtIGFkZGVkIGNsb2NrIGNvbnRyb2wKICoJCSAgICAgLSB1cGRhdGVkIGluaXQgY29kZSB0byB1c2UgcGxhdGZvcm1fZGV2aWNlIGluZm8KICoKICogMDYtTWFyLTIwMDUgIEJKRCAgQWRkIHMzYzI0NDAgZmNsayBjbG9jayBzb3VyY2UKICoKICogMDktTWFyLTIwMDUgIEJKRCAgQWRkIHMzYzI0MDAgc3VwcG9ydAogKgogKiAxMC1NYXItMjAwNSAgTENWUiBDaGFuZ2VkIFMzQzI0MTBfVkFfVUFSVCB0byBTM0MyNFhYX1ZBX1VBUlQKKi8KCi8qIE5vdGUgb24gMjQ0MCBmY2xrIGNsb2NrIHNvdXJjZSBoYW5kbGluZwogKgogKiBXaGlsc3QgaXQgaXMgcG9zc2libGUgdG8gdXNlIHRoZSBmY2xrIGFzIGNsb2NrIHNvdXJjZSwgdGhlIG1ldGhvZAogKiBvZiBwcm9wZXJseSBzd2l0Y2hpbmcgdG9vL2Zyb20gdGhpcyBpcyBjdXJyZW50bHkgdW4taW1wbGVtZW50ZWQsIHNvCiAqIHdoaWNoZXZlciB3YXkgaXMgY29uZmlndXJlZCBhdCBzdGFydHVwIGlzIHRoZSBvbmUgdGhhdCB3aWxsIGJlIHVzZWQuCiovCgovKiBIb3RlIG9uIDI0MTAgZXJyb3IgaGFuZGxpbmcKICoKICogVGhlIHMzYzI0MTAgbWFudWFsIGhhcyBhIGxvdmUvaGF0ZSBhZmZhaXIgd2l0aCB0aGUgY29udGVudHMgb2YgdGhlCiAqIFVFUlNUQVQgcmVnaXN0ZXIgaW4gdGhlIFVBUlQgYmxvY2tzLCBhbmQga2VlcHMgbWFya2luZyBzb21lIG9mIHRoZQogKiBlcnJvciBiaXRzIGFzIHJlc2VydmVkLiBIYXZpbmcgY2hlY2tlZCB3aXRoIHRoZSBzM2MyNDEweDAxLAogKiBpdCBjb3BlcyB3aXRoIEJSRUFLcyBwcm9wZXJseSwgc28gSSBhbSBoYXBweSB0byBpZ25vcmUgdGhlIFJFU0VSVkVECiAqIGZlYXR1cmUgZnJvbSB0aGUgbGF0dGVyIHZlcnNpb25zIG9mIHRoZSBtYW51YWwuCiAqCiAqIElmIGl0IGJlY29tZXMgYXBhcnJlbnQgdGhhdCBsYXR0ZXIgdmVyc2lvbnMgb2YgdGhlIDI0MTAgcmVtb3ZlIHRoZXNlCiAqIGJpdHMsIHRoZW4gYWN0aW9uIHdpbGwgaGF2ZSB0byBiZSB0YWtlbiB0byBkaWZmZXJlbnRpYXRlIHRoZSB2ZXJzaW9ucwogKiBhbmQgY2hhbmdlIHRoZSBwb2xpY3kgb24gQlJFQUsKICoKICogQkpELCAwNC1Ob3YtMjAwNAoqLwoKI2luY2x1ZGUgPGxpbnV4L2NvbmZpZy5oPgoKI2lmIGRlZmluZWQoQ09ORklHX1NFUklBTF9TM0MyNDEwX0NPTlNPTEUpICYmIGRlZmluZWQoQ09ORklHX01BR0lDX1NZU1JRKQojZGVmaW5lIFNVUFBPUlRfU1lTUlEKI2VuZGlmCgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxsaW51eC9pb3BvcnQuaD4KI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvc3lzcnEuaD4KI2luY2x1ZGUgPGxpbnV4L2NvbnNvbGUuaD4KI2luY2x1ZGUgPGxpbnV4L3R0eS5oPgojaW5jbHVkZSA8bGludXgvdHR5X2ZsaXAuaD4KI2luY2x1ZGUgPGxpbnV4L3NlcmlhbF9jb3JlLmg+CiNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxhc20vaXJxLmg+CgojaW5jbHVkZSA8YXNtL2hhcmR3YXJlLmg+CiNpbmNsdWRlIDxhc20vaGFyZHdhcmUvY2xvY2suaD4KCiNpbmNsdWRlIDxhc20vYXJjaC9yZWdzLXNlcmlhbC5oPgojaW5jbHVkZSA8YXNtL2FyY2gvcmVncy1ncGlvLmg+CgojaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KCi8qIHN0cnVjdHVyZXMgKi8KCnN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyB7CgljaGFyCQkJKm5hbWU7Cgl1bnNpZ25lZCBpbnQJCXR5cGU7Cgl1bnNpZ25lZCBpbnQJCWZpZm9zaXplOwoJdW5zaWduZWQgbG9uZwkJcnhfZmlmb21hc2s7Cgl1bnNpZ25lZCBsb25nCQlyeF9maWZvc2hpZnQ7Cgl1bnNpZ25lZCBsb25nCQlyeF9maWZvZnVsbDsKCXVuc2lnbmVkIGxvbmcJCXR4X2ZpZm9tYXNrOwoJdW5zaWduZWQgbG9uZwkJdHhfZmlmb3NoaWZ0OwoJdW5zaWduZWQgbG9uZwkJdHhfZmlmb2Z1bGw7CgoJLyogY2xvY2sgc291cmNlIGNvbnRyb2wgKi8KCglpbnQgKCpnZXRfY2xrc3JjKShzdHJ1Y3QgdWFydF9wb3J0ICosIHN0cnVjdCBzM2MyNHh4X3VhcnRfY2xrc3JjICpjbGspOwoJaW50ICgqc2V0X2Nsa3NyYykoc3RydWN0IHVhcnRfcG9ydCAqLCBzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyAqY2xrKTsKCgkvKiB1YXJ0IGNvbnRyb2xzICovCglpbnQgKCpyZXNldF9wb3J0KShzdHJ1Y3QgdWFydF9wb3J0ICosIHN0cnVjdCBzM2MyNDEwX3VhcnRjZmcgKik7Cn07CgpzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQgewoJdW5zaWduZWQgY2hhcgkJCXJ4X2NsYWltZWQ7Cgl1bnNpZ25lZCBjaGFyCQkJdHhfY2xhaW1lZDsKCglzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8JKmluZm87CglzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYwkqY2xrc3JjOwoJc3RydWN0IGNsawkJCSpjbGs7CglzdHJ1Y3QgY2xrCQkJKmJhdWRjbGs7CglzdHJ1Y3QgdWFydF9wb3J0CQlwb3J0Owp9OwoKCi8qIGNvbmZpZ3VyYXRpb24gZGVmaW5lcyAqLwoKI2lmIDAKI2lmIDEKLyogc2VuZCBkZWJ1ZyB0byB0aGUgbG93LWxldmVsIG91dHB1dCByb3V0aW5lcyAqLwoKZXh0ZXJuIHZvaWQgcHJpbnRhc2NpaShjb25zdCBjaGFyICopOwoKc3RhdGljIHZvaWQKczNjMjR4eF9zZXJpYWxfZGJnKGNvbnN0IGNoYXIgKmZtdCwgLi4uKQp7Cgl2YV9saXN0IHZhOwoJY2hhciBidWZmWzI1Nl07CgoJdmFfc3RhcnQodmEsIGZtdCk7Cgl2c3ByaW50ZihidWZmLCBmbXQsIHZhKTsKCXZhX2VuZCh2YSk7CgoJcHJpbnRhc2NpaShidWZmKTsKfQoKI2RlZmluZSBkYmcoeC4uLikgczNjMjR4eF9zZXJpYWxfZGJnKHgpCgojZWxzZQojZGVmaW5lIGRiZyh4Li4uKSBwcmludGsoS0VSTl9ERUJVRyAiczNjMjR4eDogIik7CiNlbmRpZgojZWxzZSAvKiBubyBkZWJ1ZyAqLwojZGVmaW5lIGRiZyh4Li4uKSBkbyB7fSB3aGlsZSgwKQojZW5kaWYKCi8qIFVBUlQgbmFtZSBhbmQgZGV2aWNlIGRlZmluaXRpb25zICovCgojZGVmaW5lIFMzQzI0WFhfU0VSSUFMX05BTUUJInR0eVNBQyIKI2RlZmluZSBTM0MyNFhYX1NFUklBTF9ERVZGUyAgICAidHRzLyIKI2RlZmluZSBTM0MyNFhYX1NFUklBTF9NQUpPUgkyMDQKI2RlZmluZSBTM0MyNFhYX1NFUklBTF9NSU5PUgk2NAoKCi8qIGNvbnZlcnNpb24gZnVuY3Rpb25zICovCgojZGVmaW5lIHMzYzI0eHhfZGV2X3RvX3BvcnQoX19kZXYpIChzdHJ1Y3QgdWFydF9wb3J0ICopZGV2X2dldF9kcnZkYXRhKF9fZGV2KQojZGVmaW5lIHMzYzI0eHhfZGV2X3RvX2NmZyhfX2RldikgKHN0cnVjdCBzM2MyNDEwX3VhcnRjZmcgKikoKF9fZGV2KS0+cGxhdGZvcm1fZGF0YSkKCi8qIHdlIGNhbiBzdXBwb3J0IDMgdWFydHMsIGJ1dCBub3QgYWx3YXlzIHVzZSB0aGVtICovCgojZGVmaW5lIE5SX1BPUlRTICgzKQoKLyogcG9ydCBpcnEgbnVtYmVycyAqLwoKI2RlZmluZSBUWF9JUlEocG9ydCkgKChwb3J0KS0+aXJxICsgMSkKI2RlZmluZSBSWF9JUlEocG9ydCkgKChwb3J0KS0+aXJxKQoKLyogcmVnaXN0ZXIgYWNjZXNzIGNvbnRyb2xzICovCgojZGVmaW5lIHBvcnRhZGRyKHBvcnQsIHJlZykgKChwb3J0KS0+bWVtYmFzZSArIChyZWcpKQoKI2RlZmluZSByZF9yZWdiKHBvcnQsIHJlZykgKF9fcmF3X3JlYWRiKHBvcnRhZGRyKHBvcnQsIHJlZykpKQojZGVmaW5lIHJkX3JlZ2wocG9ydCwgcmVnKSAoX19yYXdfcmVhZGwocG9ydGFkZHIocG9ydCwgcmVnKSkpCgojZGVmaW5lIHdyX3JlZ2IocG9ydCwgcmVnLCB2YWwpIFwKICBkbyB7IF9fcmF3X3dyaXRlYih2YWwsIHBvcnRhZGRyKHBvcnQsIHJlZykpOyB9IHdoaWxlKDApCgojZGVmaW5lIHdyX3JlZ2wocG9ydCwgcmVnLCB2YWwpIFwKICBkbyB7IF9fcmF3X3dyaXRlbCh2YWwsIHBvcnRhZGRyKHBvcnQsIHJlZykpOyB9IHdoaWxlKDApCgovKiBtYWNyb3MgdG8gY2hhbmdlIG9uZSB0aGluZyB0byBhbm90aGVyICovCgojZGVmaW5lIHR4X2VuYWJsZWQocG9ydCkgKChwb3J0KS0+dW51c2VkWzBdKQojZGVmaW5lIHJ4X2VuYWJsZWQocG9ydCkgKChwb3J0KS0+dW51c2VkWzFdKQoKLyogZmxhZyB0byBpZ25vcmUgYWxsIGNoYXJhY3RlcnMgY29tbWluZyBpbiAqLwojZGVmaW5lIFJYU1RBVF9EVU1NWV9SRUFEICgweDEwMDAwMDAwKQoKc3RhdGljIGlubGluZSBzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQgKnRvX291cnBvcnQoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKewoJcmV0dXJuIGNvbnRhaW5lcl9vZihwb3J0LCBzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQsIHBvcnQpOwp9CgovKiB0cmFuc2xhdGUgYSBwb3J0IHRvIHRoZSBkZXZpY2UgbmFtZSAqLwoKc3RhdGljIGlubGluZSBjaGFyICpzM2MyNHh4X3NlcmlhbF9wb3J0bmFtZShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQp7CglyZXR1cm4gdG9fcGxhdGZvcm1fZGV2aWNlKHBvcnQtPmRldiktPm5hbWU7Cn0KCnN0YXRpYyBpbnQgczNjMjR4eF9zZXJpYWxfdHhlbXB0eV9ub2ZpZm8oc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKewoJcmV0dXJuIChyZF9yZWdsKHBvcnQsIFMzQzI0MTBfVVRSU1RBVCkgJiBTM0MyNDEwX1VUUlNUQVRfVFhFKTsKfQoKc3RhdGljIHZvaWQgczNjMjR4eF9zZXJpYWxfcnhfZW5hYmxlKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBpbnQgdWNvbiwgdWZjb247CglpbnQgY291bnQgPSAxMDAwMDsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwoKCXdoaWxlICgtLWNvdW50ICYmICFzM2MyNHh4X3NlcmlhbF90eGVtcHR5X25vZmlmbyhwb3J0KSkKCQl1ZGVsYXkoMTAwKTsKCgl1ZmNvbiA9IHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VRkNPTik7Cgl1ZmNvbiB8PSBTM0MyNDEwX1VGQ09OX1JFU0VUUlg7Cgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04sIHVmY29uKTsKCgl1Y29uID0gcmRfcmVnbChwb3J0LCBTM0MyNDEwX1VDT04pOwoJdWNvbiB8PSBTM0MyNDEwX1VDT05fUlhJUlFNT0RFOwoJd3JfcmVnbChwb3J0LCBTM0MyNDEwX1VDT04sIHVjb24pOwoKCXJ4X2VuYWJsZWQocG9ydCkgPSAxOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZCBzM2MyNHh4X3NlcmlhbF9yeF9kaXNhYmxlKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBpbnQgdWNvbjsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwoKCXVjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7Cgl1Y29uICY9IH5TM0MyNDEwX1VDT05fUlhJUlFNT0RFOwoJd3JfcmVnbChwb3J0LCBTM0MyNDEwX1VDT04sIHVjb24pOwoKCXJ4X2VuYWJsZWQocG9ydCkgPSAwOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZApzM2MyNHh4X3NlcmlhbF9zdG9wX3R4KHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHVuc2lnbmVkIGludCB0dHlfc3RvcCkKewoJaWYgKHR4X2VuYWJsZWQocG9ydCkpIHsKCQlkaXNhYmxlX2lycShUWF9JUlEocG9ydCkpOwoJCXR4X2VuYWJsZWQocG9ydCkgPSAwOwoJCWlmIChwb3J0LT5mbGFncyAmIFVQRl9DT05TX0ZMT1cpCgkJCXMzYzI0eHhfc2VyaWFsX3J4X2VuYWJsZShwb3J0KTsKCX0KfQoKc3RhdGljIHZvaWQKczNjMjR4eF9zZXJpYWxfc3RhcnRfdHgoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgdW5zaWduZWQgaW50IHR0eV9zdGFydCkKewoJaWYgKCF0eF9lbmFibGVkKHBvcnQpKSB7CgkJaWYgKHBvcnQtPmZsYWdzICYgVVBGX0NPTlNfRkxPVykKCQkJczNjMjR4eF9zZXJpYWxfcnhfZGlzYWJsZShwb3J0KTsKCgkJZW5hYmxlX2lycShUWF9JUlEocG9ydCkpOwoJCXR4X2VuYWJsZWQocG9ydCkgPSAxOwoJfQp9CgoKc3RhdGljIHZvaWQgczNjMjR4eF9zZXJpYWxfc3RvcF9yeChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQp7CglpZiAocnhfZW5hYmxlZChwb3J0KSkgewoJCWRiZygiczNjMjR4eF9zZXJpYWxfc3RvcF9yeDogcG9ydD0lcFxuIiwgcG9ydCk7CgkJZGlzYWJsZV9pcnEoUlhfSVJRKHBvcnQpKTsKCQlyeF9lbmFibGVkKHBvcnQpID0gMDsKCX0KfQoKc3RhdGljIHZvaWQgczNjMjR4eF9zZXJpYWxfZW5hYmxlX21zKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCnsKfQoKc3RhdGljIGlubGluZSBzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKnMzYzI0eHhfcG9ydF90b19pbmZvKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCnsKCXJldHVybiB0b19vdXJwb3J0KHBvcnQpLT5pbmZvOwp9CgpzdGF0aWMgaW5saW5lIHN0cnVjdCBzM2MyNDEwX3VhcnRjZmcgKnMzYzI0eHhfcG9ydF90b19jZmcoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKewoJaWYgKHBvcnQtPmRldiA9PSBOVUxMKQoJCXJldHVybiBOVUxMOwoKCXJldHVybiAoc3RydWN0IHMzYzI0MTBfdWFydGNmZyAqKXBvcnQtPmRldi0+cGxhdGZvcm1fZGF0YTsKfQoKc3RhdGljIGludCBzM2MyNHh4X3NlcmlhbF9yeF9maWZvY250KHN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqb3VycG9ydCwKCQkJCSAgICAgdW5zaWduZWQgbG9uZyB1ZnN0YXQpCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyAqaW5mbyA9IG91cnBvcnQtPmluZm87CgoJaWYgKHVmc3RhdCAmIGluZm8tPnJ4X2ZpZm9mdWxsKQoJCXJldHVybiBpbmZvLT5maWZvc2l6ZTsKCglyZXR1cm4gKHVmc3RhdCAmIGluZm8tPnJ4X2ZpZm9tYXNrKSA+PiBpbmZvLT5yeF9maWZvc2hpZnQ7Cn0KCgovKiA/IC0gd2hlcmUgaGFzIHBhcml0eSBnb25lPz8gKi8KI2RlZmluZSBTM0MyNDEwX1VFUlNUQVRfUEFSSVRZICgweDEwMDApCgpzdGF0aWMgaXJxcmV0dXJuX3QKczNjMjR4eF9zZXJpYWxfcnhfY2hhcnMoaW50IGlycSwgdm9pZCAqZGV2X2lkLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJc3RydWN0IHMzYzI0eHhfdWFydF9wb3J0ICpvdXJwb3J0ID0gZGV2X2lkOwoJc3RydWN0IHVhcnRfcG9ydCAqcG9ydCA9ICZvdXJwb3J0LT5wb3J0OwoJc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSA9IHBvcnQtPmluZm8tPnR0eTsKCXVuc2lnbmVkIGludCB1ZmNvbiwgY2gsIGZsYWcsIHVmc3RhdCwgdWVyc3RhdDsKCWludCBtYXhfY291bnQgPSA2NDsKCgl3aGlsZSAobWF4X2NvdW50LS0gPiAwKSB7CgkJdWZjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04pOwoJCXVmc3RhdCA9IHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VRlNUQVQpOwoKCQlpZiAoczNjMjR4eF9zZXJpYWxfcnhfZmlmb2NudChvdXJwb3J0LCB1ZnN0YXQpID09IDApCgkJCWJyZWFrOwoKCQlpZiAodHR5LT5mbGlwLmNvdW50ID49IFRUWV9GTElQQlVGX1NJWkUpIHsKCQkJaWYgKHR0eS0+bG93X2xhdGVuY3kpCgkJCQl0dHlfZmxpcF9idWZmZXJfcHVzaCh0dHkpOwoKCQkJLyoKCQkJICogSWYgdGhpcyBmYWlsZWQgdGhlbiB3ZSB3aWxsIHRocm93IGF3YXkgdGhlCgkJCSAqIGJ5dGVzIGJ1dCBtdXN0IGRvIHNvIHRvIGNsZWFyIGludGVycnVwdHMKCQkJICovCgkJfQoKCQl1ZXJzdGF0ID0gcmRfcmVnbChwb3J0LCBTM0MyNDEwX1VFUlNUQVQpOwoJCWNoID0gcmRfcmVnYihwb3J0LCBTM0MyNDEwX1VSWEgpOwoKCQlpZiAocG9ydC0+ZmxhZ3MgJiBVUEZfQ09OU19GTE9XKSB7CgkJCWludCB0eGUgPSBzM2MyNHh4X3NlcmlhbF90eGVtcHR5X25vZmlmbyhwb3J0KTsKCgkJCWlmIChyeF9lbmFibGVkKHBvcnQpKSB7CgkJCQlpZiAoIXR4ZSkgewoJCQkJCXJ4X2VuYWJsZWQocG9ydCkgPSAwOwoJCQkJCWNvbnRpbnVlOwoJCQkJfQoJCQl9IGVsc2UgewoJCQkJaWYgKHR4ZSkgewoJCQkJCXVmY29uIHw9IFMzQzI0MTBfVUZDT05fUkVTRVRSWDsKCQkJCQl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04sIHVmY29uKTsKCQkJCQlyeF9lbmFibGVkKHBvcnQpID0gMTsKCQkJCQlnb3RvIG91dDsKCQkJCX0KCQkJCWNvbnRpbnVlOwoJCQl9CgkJfQoKCQkvKiBpbnNlcnQgdGhlIGNoYXJhY3RlciBpbnRvIHRoZSBidWZmZXIgKi8KCgkJZmxhZyA9IFRUWV9OT1JNQUw7CgkJcG9ydC0+aWNvdW50LnJ4Kys7CgoJCWlmICh1ZXJzdGF0ICYgUzNDMjQxMF9VRVJTVEFUX0FOWSkgewoJCQlkYmcoInJ4ZXJyOiBwb3J0IGNoPTB4JTAyeCwgcnhzPTB4JTA4eFxuIiwKCQkJICAgIGNoLCB1ZXJzdGF0KTsKCgkJCS8qIGNoZWNrIGZvciBicmVhayAqLwoJCQlpZiAodWVyc3RhdCAmIFMzQzI0MTBfVUVSU1RBVF9CUkVBSykgewoJCQkJZGJnKCJicmVhayFcbiIpOwoJCQkJcG9ydC0+aWNvdW50LmJyaysrOwoJCQkJaWYgKHVhcnRfaGFuZGxlX2JyZWFrKHBvcnQpKQoJCQkJICAgIGdvdG8gaWdub3JlX2NoYXI7CgkJCX0KCgkJCWlmICh1ZXJzdGF0ICYgUzNDMjQxMF9VRVJTVEFUX0ZSQU1FKQoJCQkJcG9ydC0+aWNvdW50LmZyYW1lKys7CgkJCWlmICh1ZXJzdGF0ICYgUzNDMjQxMF9VRVJTVEFUX09WRVJSVU4pCgkJCQlwb3J0LT5pY291bnQub3ZlcnJ1bisrOwoKCQkJdWVyc3RhdCAmPSBwb3J0LT5yZWFkX3N0YXR1c19tYXNrOwoKCQkJaWYgKHVlcnN0YXQgJiBTM0MyNDEwX1VFUlNUQVRfQlJFQUspCgkJCQlmbGFnID0gVFRZX0JSRUFLOwoJCQllbHNlIGlmICh1ZXJzdGF0ICYgUzNDMjQxMF9VRVJTVEFUX1BBUklUWSkKCQkJCWZsYWcgPSBUVFlfUEFSSVRZOwoJCQllbHNlIGlmICh1ZXJzdGF0ICYgKCBTM0MyNDEwX1VFUlNUQVRfRlJBTUUgfCBTM0MyNDEwX1VFUlNUQVRfT1ZFUlJVTikpCgkJCQlmbGFnID0gVFRZX0ZSQU1FOwoJCX0KCgkJaWYgKHVhcnRfaGFuZGxlX3N5c3JxX2NoYXIocG9ydCwgY2gsIHJlZ3MpKQoJCQlnb3RvIGlnbm9yZV9jaGFyOwoKCQlpZiAoKHVlcnN0YXQgJiBwb3J0LT5pZ25vcmVfc3RhdHVzX21hc2spID09IDApIHsKCQkJdHR5X2luc2VydF9mbGlwX2NoYXIodHR5LCBjaCwgZmxhZyk7CgkJfQoKCQlpZiAoKHVlcnN0YXQgJiBTM0MyNDEwX1VFUlNUQVRfT1ZFUlJVTikgJiYKCQkgICAgdHR5LT5mbGlwLmNvdW50IDwgVFRZX0ZMSVBCVUZfU0laRSkgewoJCQkvKgoJCQkgKiBPdmVycnVuIGlzIHNwZWNpYWwsIHNpbmNlIGl0J3MgcmVwb3J0ZWQKCQkJICogaW1tZWRpYXRlbHksIGFuZCBkb2Vzbid0IGFmZmVjdCB0aGUgY3VycmVudAoJCQkgKiBjaGFyYWN0ZXIuCgkJCSAqLwoKCQkJdHR5X2luc2VydF9mbGlwX2NoYXIodHR5LCAwLCBUVFlfT1ZFUlJVTik7CgkJfQoKCWlnbm9yZV9jaGFyOgoJCWNvbnRpbnVlOwoJfQoJdHR5X2ZsaXBfYnVmZmVyX3B1c2godHR5KTsKCiBvdXQ6CglyZXR1cm4gSVJRX0hBTkRMRUQ7Cn0KCnN0YXRpYyBpcnFyZXR1cm5fdCBzM2MyNHh4X3NlcmlhbF90eF9jaGFycyhpbnQgaXJxLCB2b2lkICppZCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqb3VycG9ydCA9IGlkOwoJc3RydWN0IHVhcnRfcG9ydCAqcG9ydCA9ICZvdXJwb3J0LT5wb3J0OwoJc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnBvcnQtPmluZm8tPnhtaXQ7CglpbnQgY291bnQgPSAyNTY7CgoJaWYgKHBvcnQtPnhfY2hhcikgewoJCXdyX3JlZ2IocG9ydCwgUzNDMjQxMF9VVFhILCBwb3J0LT54X2NoYXIpOwoJCXBvcnQtPmljb3VudC50eCsrOwoJCXBvcnQtPnhfY2hhciA9IDA7CgkJZ290byBvdXQ7Cgl9CgoJLyogaWYgdGhlcmUgaXNudCBhbnl0aGluZyBtb3JlIHRvIHRyYW5zbWl0LCBvciB0aGUgdWFydCBpcyBub3cKCSAqIHN0b3BwZWQsIGRpc2FibGUgdGhlIHVhcnQgYW5kIGV4aXQKCSovCgoJaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKCQlzM2MyNHh4X3NlcmlhbF9zdG9wX3R4KHBvcnQsIDApOwoJCWdvdG8gb3V0OwoJfQoKCS8qIHRyeSBhbmQgZHJhaW4gdGhlIGJ1ZmZlci4uLiAqLwoKCXdoaWxlICghdWFydF9jaXJjX2VtcHR5KHhtaXQpICYmIGNvdW50LS0gPiAwKSB7CgkJaWYgKHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VRlNUQVQpICYgb3VycG9ydC0+aW5mby0+dHhfZmlmb2Z1bGwpCgkJCWJyZWFrOwoKCQl3cl9yZWdiKHBvcnQsIFMzQzI0MTBfVVRYSCwgeG1pdC0+YnVmW3htaXQtPnRhaWxdKTsKCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAxKSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwoJCXBvcnQtPmljb3VudC50eCsrOwoJfQoKCWlmICh1YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0KSA8IFdBS0VVUF9DSEFSUykKCQl1YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsKCglpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpKQoJCXMzYzI0eHhfc2VyaWFsX3N0b3BfdHgocG9ydCwgMCk7Cgogb3V0OgoJcmV0dXJuIElSUV9IQU5ETEVEOwp9CgpzdGF0aWMgdW5zaWduZWQgaW50IHMzYzI0eHhfc2VyaWFsX3R4X2VtcHR5KHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyAqaW5mbyA9IHMzYzI0eHhfcG9ydF90b19pbmZvKHBvcnQpOwoJdW5zaWduZWQgbG9uZyB1ZnN0YXQgPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUZTVEFUKTsKCXVuc2lnbmVkIGxvbmcgdWZjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04pOwoKCWlmICh1ZmNvbiAmIFMzQzI0MTBfVUZDT05fRklGT01PREUpIHsKCQlpZiAoKHVmc3RhdCAmIGluZm8tPnR4X2ZpZm9tYXNrKSAhPSAwIHx8CgkJICAgICh1ZnN0YXQgJiBpbmZvLT50eF9maWZvZnVsbCkpCgkJCXJldHVybiAwOwoKCQlyZXR1cm4gMTsKCX0KCglyZXR1cm4gczNjMjR4eF9zZXJpYWxfdHhlbXB0eV9ub2ZpZm8ocG9ydCk7Cn0KCi8qIG5vIG1vZGVtIGNvbnRyb2wgbGluZXMgKi8Kc3RhdGljIHVuc2lnbmVkIGludCBzM2MyNHh4X3NlcmlhbF9nZXRfbWN0cmwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKewoJdW5zaWduZWQgaW50IHVtc3RhdCA9IHJkX3JlZ2IocG9ydCxTM0MyNDEwX1VNU1RBVCk7CgoJaWYgKHVtc3RhdCAmIFMzQzI0MTBfVU1TVEFUX0NUUykKCQlyZXR1cm4gVElPQ01fQ0FSIHwgVElPQ01fRFNSIHwgVElPQ01fQ1RTOwoJZWxzZQoJCXJldHVybiBUSU9DTV9DQVIgfCBUSU9DTV9EU1I7Cn0KCnN0YXRpYyB2b2lkIHMzYzI0eHhfc2VyaWFsX3NldF9tY3RybChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQgbWN0cmwpCnsKCS8qIHRvZG8gLSBwb3NzaWJseSByZW1vdmUgQUZDIGFuZCBkbyBtYW51YWwgQ1RTICovCn0KCnN0YXRpYyB2b2lkIHMzYzI0eHhfc2VyaWFsX2JyZWFrX2N0bChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCBpbnQgYnJlYWtfc3RhdGUpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBpbnQgdWNvbjsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwoKCXVjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7CgoJaWYgKGJyZWFrX3N0YXRlKQoJCXVjb24gfD0gUzNDMjQxMF9VQ09OX1NCUkVBSzsKCWVsc2UKCQl1Y29uICY9IH5TM0MyNDEwX1VDT05fU0JSRUFLOwoKCXdyX3JlZ2wocG9ydCwgUzNDMjQxMF9VQ09OLCB1Y29uKTsKCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb3J0LT5sb2NrLCBmbGFncyk7Cn0KCnN0YXRpYyB2b2lkIHMzYzI0eHhfc2VyaWFsX3NodXRkb3duKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqb3VycG9ydCA9IHRvX291cnBvcnQocG9ydCk7CgoJaWYgKG91cnBvcnQtPnR4X2NsYWltZWQpIHsKCQlmcmVlX2lycShUWF9JUlEocG9ydCksIG91cnBvcnQpOwoJCXR4X2VuYWJsZWQocG9ydCkgPSAwOwoJCW91cnBvcnQtPnR4X2NsYWltZWQgPSAwOwoJfQoKCWlmIChvdXJwb3J0LT5yeF9jbGFpbWVkKSB7CgkJZnJlZV9pcnEoUlhfSVJRKHBvcnQpLCBvdXJwb3J0KTsKCQlvdXJwb3J0LT5yeF9jbGFpbWVkID0gMDsKCQlyeF9lbmFibGVkKHBvcnQpID0gMDsKCX0KfQoKCnN0YXRpYyBpbnQgczNjMjR4eF9zZXJpYWxfc3RhcnR1cChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQp7CglzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQgKm91cnBvcnQgPSB0b19vdXJwb3J0KHBvcnQpOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWludCByZXQ7CgoJZGJnKCJzM2MyNHh4X3NlcmlhbF9zdGFydHVwOiBwb3J0PSVwICglMDhseCwlcClcbiIsCgkgICAgcG9ydC0+bWFwYmFzZSwgcG9ydC0+bWVtYmFzZSk7CgoJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwoKCXJ4X2VuYWJsZWQocG9ydCkgPSAxOwoKCXJldCA9IHJlcXVlc3RfaXJxKFJYX0lSUShwb3J0KSwKCQkJICBzM2MyNHh4X3NlcmlhbF9yeF9jaGFycywgMCwKCQkJICBzM2MyNHh4X3NlcmlhbF9wb3J0bmFtZShwb3J0KSwgb3VycG9ydCk7CgoJaWYgKHJldCAhPSAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJjYW5ub3QgZ2V0IGlycSAlZFxuIiwgUlhfSVJRKHBvcnQpKTsKCQlyZXR1cm4gcmV0OwoJfQoKCW91cnBvcnQtPnJ4X2NsYWltZWQgPSAxOwoKCWRiZygicmVxdWVzdGluZyB0eCBpcnEuLi5cbiIpOwoKCXR4X2VuYWJsZWQocG9ydCkgPSAxOwoKCXJldCA9IHJlcXVlc3RfaXJxKFRYX0lSUShwb3J0KSwKCQkJICBzM2MyNHh4X3NlcmlhbF90eF9jaGFycywgMCwKCQkJICBzM2MyNHh4X3NlcmlhbF9wb3J0bmFtZShwb3J0KSwgb3VycG9ydCk7CgoJaWYgKHJldCkgewoJCXByaW50ayhLRVJOX0VSUiAiY2Fubm90IGdldCBpcnEgJWRcbiIsIFRYX0lSUShwb3J0KSk7CgkJZ290byBlcnI7Cgl9CgoJb3VycG9ydC0+dHhfY2xhaW1lZCA9IDE7CgoJZGJnKCJzM2MyNHh4X3NlcmlhbF9zdGFydHVwIG9rXG4iKTsKCgkvKiB0aGUgcG9ydCByZXNldCBjb2RlIHNob3VsZCBoYXZlIGRvbmUgdGhlIGNvcnJlY3QKCSAqIHJlZ2lzdGVyIHNldHVwIGZvciB0aGUgcG9ydCBjb250cm9scyAqLwoKCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCXJldHVybiByZXQ7CgogZXJyOgoJczNjMjR4eF9zZXJpYWxfc2h1dGRvd24ocG9ydCk7Cglsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CglyZXR1cm4gcmV0Owp9CgovKiBwb3dlciBwb3dlciBtYW5hZ2VtZW50IGNvbnRyb2wgKi8KCnN0YXRpYyB2b2lkIHMzYzI0eHhfc2VyaWFsX3BtKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHVuc2lnbmVkIGludCBsZXZlbCwKCQkJICAgICAgdW5zaWduZWQgaW50IG9sZCkKewoJc3RydWN0IHMzYzI0eHhfdWFydF9wb3J0ICpvdXJwb3J0ID0gdG9fb3VycG9ydChwb3J0KTsKCglzd2l0Y2ggKGxldmVsKSB7CgljYXNlIDM6CgkJaWYgKCFJU19FUlIob3VycG9ydC0+YmF1ZGNsaykgJiYgb3VycG9ydC0+YmF1ZGNsayAhPSBOVUxMKQoJCQljbGtfZGlzYWJsZShvdXJwb3J0LT5iYXVkY2xrKTsKCgkJY2xrX2Rpc2FibGUob3VycG9ydC0+Y2xrKTsKCQlicmVhazsKCgljYXNlIDA6CgkJY2xrX2VuYWJsZShvdXJwb3J0LT5jbGspOwoKCQlpZiAoIUlTX0VSUihvdXJwb3J0LT5iYXVkY2xrKSAmJiBvdXJwb3J0LT5iYXVkY2xrICE9IE5VTEwpCgkJCWNsa19lbmFibGUob3VycG9ydC0+YmF1ZGNsayk7CgoJCWJyZWFrOwoJZGVmYXVsdDoKCQlwcmludGsoS0VSTl9FUlIgInMzYzI0eHhfc2VyaWFsOiB1bmtub3duIHBtICVkXG4iLCBsZXZlbCk7Cgl9Cn0KCi8qIGJhdWQgcmF0ZSBjYWxjdWxhdGlvbgogKgogKiBUaGUgVUFSVHMgb24gdGhlIFMzQzI0MTAvUzNDMjQ0MCBjYW4gdGFrZSB0aGVpciBjbG9ja3MgZnJvbSBhIG51bWJlcgogKiBvZiBkaWZmZXJlbnQgc291cmNlcywgaW5jbHVkaW5nIHRoZSBwZXJpcGhlcmFsIGNsb2NrICgicGNsayIpIGFuZCBhbgogKiBleHRlcm5hbCBjbG9jayAoInVjbGsiKS4gVGhlIFMzQzI0NDAgYWxzbyBhZGRzIHRoZSBjb3JlIGNsb2NrICgiZmNsayIpCiAqIHdpdGggYSBwcm9ncmFtbWFibGUgZXh0cmEgZGl2aXNvci4KICoKICogVGhlIGZvbGxvd2luZyBjb2RlIGdvZXMgdGhyb3VnaCB0aGUgY2xvY2sgc291cmNlcywgYW5kIGNhbGN1bGF0ZXMgdGhlCiAqIGJhdWQgY2xvY2tzIChhbmQgdGhlIHJlc3VsdGFudCBhY3R1YWwgYmF1ZCByYXRlcykgYW5kIHRoZW4gdHJpZXMgdG8KICogcGljayB0aGUgY2xvc2VzdCBvbmUgYW5kIHNlbGVjdCB0aGF0LgogKgoqLwoKCiNkZWZpbmUgTUFYX0NMS1MgKDgpCgpzdGF0aWMgc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMgdG1wX2Nsa3NyYyA9IHsKCS5uYW1lCQk9ICJwY2xrIiwKCS5taW5fYmF1ZAk9IDAsCgkubWF4X2JhdWQJPSAwLAoJLmRpdmlzb3IJPSAxLAp9OwoKc3RhdGljIGlubGluZSBpbnQKczNjMjR4eF9zZXJpYWxfZ2V0c291cmNlKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHN0cnVjdCBzM2MyNHh4X3VhcnRfY2xrc3JjICpjKQp7CglzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKmluZm8gPSBzM2MyNHh4X3BvcnRfdG9faW5mbyhwb3J0KTsKCglyZXR1cm4gKGluZm8tPmdldF9jbGtzcmMpKHBvcnQsIGMpOwp9CgpzdGF0aWMgaW5saW5lIGludApzM2MyNHh4X3NlcmlhbF9zZXRzb3VyY2Uoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMgKmMpCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyAqaW5mbyA9IHMzYzI0eHhfcG9ydF90b19pbmZvKHBvcnQpOwoKCXJldHVybiAoaW5mby0+c2V0X2Nsa3NyYykocG9ydCwgYyk7Cn0KCnN0cnVjdCBiYXVkX2NhbGMgewoJc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMJKmNsa3NyYzsKCXVuc2lnbmVkIGludAkJCSBjYWxjOwoJdW5zaWduZWQgaW50CQkJIHF1b3Q7CglzdHJ1Y3QgY2xrCQkJKnNyYzsKfTsKCnN0YXRpYyBpbnQgczNjMjR4eF9zZXJpYWxfY2FsY2JhdWQoc3RydWN0IGJhdWRfY2FsYyAqY2FsYywKCQkJCSAgIHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsCgkJCQkgICBzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyAqY2xrc3JjLAoJCQkJICAgdW5zaWduZWQgaW50IGJhdWQpCnsKCXVuc2lnbmVkIGxvbmcgcmF0ZTsKCgljYWxjLT5zcmMgPSBjbGtfZ2V0KHBvcnQtPmRldiwgY2xrc3JjLT5uYW1lKTsKCWlmIChjYWxjLT5zcmMgPT0gTlVMTCB8fCBJU19FUlIoY2FsYy0+c3JjKSkKCQlyZXR1cm4gMDsKCglyYXRlID0gY2xrX2dldF9yYXRlKGNhbGMtPnNyYyk7CglyYXRlIC89IGNsa3NyYy0+ZGl2aXNvcjsKCgljYWxjLT5jbGtzcmMgPSBjbGtzcmM7CgljYWxjLT5xdW90ID0gKHJhdGUgKyAoOCAqIGJhdWQpKSAvICgxNiAqIGJhdWQpOwoJY2FsYy0+Y2FsYyA9IChyYXRlIC8gKGNhbGMtPnF1b3QgKiAxNikpOwoKCWNhbGMtPnF1b3QtLTsKCXJldHVybiAxOwp9CgpzdGF0aWMgdW5zaWduZWQgaW50IHMzYzI0eHhfc2VyaWFsX2dldGNsayhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LAoJCQkJCSAgc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMgKipjbGtzcmMsCgkJCQkJICBzdHJ1Y3QgY2xrICoqY2xrLAoJCQkJCSAgdW5zaWduZWQgaW50IGJhdWQpCnsKCXN0cnVjdCBzM2MyNDEwX3VhcnRjZmcgKmNmZyA9IHMzYzI0eHhfcG9ydF90b19jZmcocG9ydCk7CglzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyAqY2xrcDsKCXN0cnVjdCBiYXVkX2NhbGMgcmVzW01BWF9DTEtTXTsKCXN0cnVjdCBiYXVkX2NhbGMgKnJlc3B0ciwgKmJlc3QsICpzcHRyOwoJaW50IGk7CgoJY2xrcCA9IGNmZy0+Y2xvY2tzOwoJYmVzdCA9IE5VTEw7CgoJaWYgKGNmZy0+Y2xvY2tzX3NpemUgPCAyKSB7CgkJaWYgKGNmZy0+Y2xvY2tzX3NpemUgPT0gMCkKCQkJY2xrcCA9ICZ0bXBfY2xrc3JjOwoKCQkvKiBjaGVjayB0byBzZWUgaWYgd2UncmUgc291cmNpbmcgZmNsaywgYW5kIGlmIHNvIHdlJ3JlCgkJICogZ29pbmcgdG8gaGF2ZSB0byB1cGRhdGUgdGhlIGNsb2NrIHNvdXJjZQoJCSAqLwoKCQlpZiAoc3RyY21wKGNsa3AtPm5hbWUsICJmY2xrIikgPT0gMCkgewoJCQlzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyBzcmM7CgoJCQlzM2MyNHh4X3NlcmlhbF9nZXRzb3VyY2UocG9ydCwgJnNyYyk7CgoJCQkvKiBjaGVjayB0aGF0IHRoZSBwb3J0IGFscmVhZHkgdXNpbmcgZmNsaywgYW5kIGlmCgkJCSAqIG5vdCwgdGhlbiByZS1zZWxlY3QgZmNsawoJCQkgKi8KCgkJCWlmIChzdHJjbXAoc3JjLm5hbWUsIGNsa3AtPm5hbWUpID09IDApIHsKCQkJCXMzYzI0eHhfc2VyaWFsX3NldHNvdXJjZShwb3J0LCBjbGtwKTsKCQkJCXMzYzI0eHhfc2VyaWFsX2dldHNvdXJjZShwb3J0LCAmc3JjKTsKCQkJfQoKCQkJY2xrcC0+ZGl2aXNvciA9IHNyYy5kaXZpc29yOwoJCX0KCgkJczNjMjR4eF9zZXJpYWxfY2FsY2JhdWQocmVzLCBwb3J0LCBjbGtwLCBiYXVkKTsKCQliZXN0ID0gcmVzOwoJCXJlc3B0ciA9IGJlc3QgKyAxOwoJfSBlbHNlIHsKCQlyZXNwdHIgPSByZXM7CgoJCWZvciAoaSA9IDA7IGkgPCBjZmctPmNsb2Nrc19zaXplOyBpKyssIGNsa3ArKykgewoJCQlpZiAoczNjMjR4eF9zZXJpYWxfY2FsY2JhdWQocmVzcHRyLCBwb3J0LCBjbGtwLCBiYXVkKSkKCQkJCXJlc3B0cisrOwoJCX0KCX0KCgkvKiBvaywgd2Ugbm93IG5lZWQgdG8gc2VsZWN0IHRoZSBiZXN0IGNsb2NrIHdlIGZvdW5kICovCgoJaWYgKCFiZXN0KSB7CgkJdW5zaWduZWQgaW50IGRldmlhdGlvbiA9ICgxPDwzMCl8KCgxPDwzMCktMSk7CgkJaW50IGNhbGNfZGV2aWF0aW9uOwoKCQlmb3IgKHNwdHIgPSByZXM7IHNwdHIgPCByZXNwdHI7IHNwdHIrKykgewoJCQlwcmludGsoS0VSTl9ERUJVRwoJCQkgICAgICAgImZvdW5kIGNsayAlcCAoJXMpIHF1b3QgJWQsIGNhbGMgJWRcbiIsCgkJCSAgICAgICBzcHRyLT5jbGtzcmMsIHNwdHItPmNsa3NyYy0+bmFtZSwKCQkJICAgICAgIHNwdHItPnF1b3QsIHNwdHItPmNhbGMpOwoKCQkJY2FsY19kZXZpYXRpb24gPSBiYXVkIC0gc3B0ci0+Y2FsYzsKCQkJaWYgKGNhbGNfZGV2aWF0aW9uIDwgMCkKCQkJCWNhbGNfZGV2aWF0aW9uID0gLWNhbGNfZGV2aWF0aW9uOwoKCQkJaWYgKGNhbGNfZGV2aWF0aW9uIDwgZGV2aWF0aW9uKSB7CgkJCQliZXN0ID0gc3B0cjsKCQkJCWRldmlhdGlvbiA9IGNhbGNfZGV2aWF0aW9uOwoJCQl9CgkJfQoKCQlwcmludGsoS0VSTl9ERUJVRyAiYmVzdCAlcCAoZGV2aWF0aW9uICVkKVxuIiwgYmVzdCwgZGV2aWF0aW9uKTsKCX0KCglwcmludGsoS0VSTl9ERUJVRyAic2VsZWN0ZWQgY2xvY2sgJXAgKCVzKSBxdW90ICVkLCBjYWxjICVkXG4iLAoJICAgICAgIGJlc3QtPmNsa3NyYywgYmVzdC0+Y2xrc3JjLT5uYW1lLCBiZXN0LT5xdW90LCBiZXN0LT5jYWxjKTsKCgkvKiBzdG9yZSByZXN1bHRzIHRvIHBhc3MgYmFjayAqLwoKCSpjbGtzcmMgPSBiZXN0LT5jbGtzcmM7CgkqY2xrICAgID0gYmVzdC0+c3JjOwoKCXJldHVybiBiZXN0LT5xdW90Owp9CgpzdGF0aWMgdm9pZCBzM2MyNHh4X3NlcmlhbF9zZXRfdGVybWlvcyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LAoJCQkJICAgICAgIHN0cnVjdCB0ZXJtaW9zICp0ZXJtaW9zLAoJCQkJICAgICAgIHN0cnVjdCB0ZXJtaW9zICpvbGQpCnsKCXN0cnVjdCBzM2MyNDEwX3VhcnRjZmcgKmNmZyA9IHMzYzI0eHhfcG9ydF90b19jZmcocG9ydCk7CglzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQgKm91cnBvcnQgPSB0b19vdXJwb3J0KHBvcnQpOwoJc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMgKmNsa3NyYzsKCXN0cnVjdCBjbGsgKmNsazsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBpbnQgYmF1ZCwgcXVvdDsKCXVuc2lnbmVkIGludCB1bGNvbjsKCXVuc2lnbmVkIGludCB1bWNvbjsKCgkvKgoJICogV2UgZG9uJ3Qgc3VwcG9ydCBtb2RlbSBjb250cm9sIGxpbmVzLgoJICovCgl0ZXJtaW9zLT5jX2NmbGFnICY9IH4oSFVQQ0wgfCBDTVNQQVIpOwoJdGVybWlvcy0+Y19jZmxhZyB8PSBDTE9DQUw7CgoJLyoKCSAqIEFzayB0aGUgY29yZSB0byBjYWxjdWxhdGUgdGhlIGRpdmlzb3IgZm9yIHVzLgoJICovCgoJYmF1ZCA9IHVhcnRfZ2V0X2JhdWRfcmF0ZShwb3J0LCB0ZXJtaW9zLCBvbGQsIDAsIDExNTIwMCo4KTsKCglpZiAoYmF1ZCA9PSAzODQwMCAmJiAocG9ydC0+ZmxhZ3MgJiBVUEZfU1BEX01BU0spID09IFVQRl9TUERfQ1VTVCkKCQlxdW90ID0gcG9ydC0+Y3VzdG9tX2Rpdmlzb3I7CgllbHNlCgkJcXVvdCA9IHMzYzI0eHhfc2VyaWFsX2dldGNsayhwb3J0LCAmY2xrc3JjLCAmY2xrLCBiYXVkKTsKCgkvKiBjaGVjayB0byBzZWUgaWYgd2UgbmVlZCAgdG8gY2hhbmdlIGNsb2NrIHNvdXJjZSAqLwoKCWlmIChvdXJwb3J0LT5jbGtzcmMgIT0gY2xrc3JjIHx8IG91cnBvcnQtPmJhdWRjbGsgIT0gY2xrKSB7CgkJczNjMjR4eF9zZXJpYWxfc2V0c291cmNlKHBvcnQsIGNsa3NyYyk7CgoJCWlmIChvdXJwb3J0LT5iYXVkY2xrICE9IE5VTEwgJiYgIUlTX0VSUihvdXJwb3J0LT5iYXVkY2xrKSkgewoJCQljbGtfZGlzYWJsZShvdXJwb3J0LT5iYXVkY2xrKTsKCQkJY2xrX3VudXNlKG91cnBvcnQtPmJhdWRjbGspOwoJCQlvdXJwb3J0LT5iYXVkY2xrICA9IE5VTEw7CgkJfQoKCQljbGtfdXNlKGNsayk7CgkJY2xrX2VuYWJsZShjbGspOwoKCQlvdXJwb3J0LT5jbGtzcmMgPSBjbGtzcmM7CgkJb3VycG9ydC0+YmF1ZGNsayA9IGNsazsKCX0KCglzd2l0Y2ggKHRlcm1pb3MtPmNfY2ZsYWcgJiBDU0laRSkgewoJY2FzZSBDUzU6CgkJZGJnKCJjb25maWc6IDViaXRzL2NoYXJcbiIpOwoJCXVsY29uID0gUzNDMjQxMF9MQ09OX0NTNTsKCQlicmVhazsKCWNhc2UgQ1M2OgoJCWRiZygiY29uZmlnOiA2Yml0cy9jaGFyXG4iKTsKCQl1bGNvbiA9IFMzQzI0MTBfTENPTl9DUzY7CgkJYnJlYWs7CgljYXNlIENTNzoKCQlkYmcoImNvbmZpZzogN2JpdHMvY2hhclxuIik7CgkJdWxjb24gPSBTM0MyNDEwX0xDT05fQ1M3OwoJCWJyZWFrOwoJY2FzZSBDUzg6CglkZWZhdWx0OgoJCWRiZygiY29uZmlnOiA4Yml0cy9jaGFyXG4iKTsKCQl1bGNvbiA9IFMzQzI0MTBfTENPTl9DUzg7CgkJYnJlYWs7Cgl9CgoJLyogcHJlc2VydmUgb3JpZ2luYWwgbGNvbiBJUiBzZXR0aW5ncyAqLwoJdWxjb24gfD0gKGNmZy0+dWxjb24gJiBTM0MyNDEwX0xDT05fSVJNKTsKCglpZiAodGVybWlvcy0+Y19jZmxhZyAmIENTVE9QQikKCQl1bGNvbiB8PSBTM0MyNDEwX0xDT05fU1RPUEI7CgoJdW1jb24gPSAodGVybWlvcy0+Y19jZmxhZyAmIENSVFNDVFMpID8gUzNDMjQxMF9VTUNPTV9BRkMgOiAwOwoKCWlmICh0ZXJtaW9zLT5jX2NmbGFnICYgUEFSRU5CKSB7CgkJaWYgKHRlcm1pb3MtPmNfY2ZsYWcgJiBQQVJPREQpCgkJCXVsY29uIHw9IFMzQzI0MTBfTENPTl9QT0REOwoJCWVsc2UKCQkJdWxjb24gfD0gUzNDMjQxMF9MQ09OX1BFVkVOOwoJfSBlbHNlIHsKCQl1bGNvbiB8PSBTM0MyNDEwX0xDT05fUE5PTkU7Cgl9CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnBvcnQtPmxvY2ssIGZsYWdzKTsKCglkYmcoInNldHRpbmcgdWxjb24gdG8gJTA4eCwgYnJkZGl2IHRvICVkXG4iLCB1bGNvbiwgcXVvdCk7CgoJd3JfcmVnbChwb3J0LCBTM0MyNDEwX1VMQ09OLCB1bGNvbik7Cgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUJSRElWLCBxdW90KTsKCXdyX3JlZ2wocG9ydCwgUzNDMjQxMF9VTUNPTiwgdW1jb24pOwoKCWRiZygidWFydDogdWxjb24gPSAweCUwOHgsIHVjb24gPSAweCUwOHgsIHVmY29uID0gMHglMDh4XG4iLAoJICAgIHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VTENPTiksCgkgICAgcmRfcmVnbChwb3J0LCBTM0MyNDEwX1VDT04pLAoJICAgIHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VRkNPTikpOwoKCS8qCgkgKiBVcGRhdGUgdGhlIHBlci1wb3J0IHRpbWVvdXQuCgkgKi8KCXVhcnRfdXBkYXRlX3RpbWVvdXQocG9ydCwgdGVybWlvcy0+Y19jZmxhZywgYmF1ZCk7CgoJLyoKCSAqIFdoaWNoIGNoYXJhY3RlciBzdGF0dXMgZmxhZ3MgYXJlIHdlIGludGVyZXN0ZWQgaW4/CgkgKi8KCXBvcnQtPnJlYWRfc3RhdHVzX21hc2sgPSBTM0MyNDEwX1VFUlNUQVRfT1ZFUlJVTjsKCWlmICh0ZXJtaW9zLT5jX2lmbGFnICYgSU5QQ0spCgkJcG9ydC0+cmVhZF9zdGF0dXNfbWFzayB8PSBTM0MyNDEwX1VFUlNUQVRfRlJBTUUgfCBTM0MyNDEwX1VFUlNUQVRfUEFSSVRZOwoKCS8qCgkgKiBXaGljaCBjaGFyYWN0ZXIgc3RhdHVzIGZsYWdzIHNob3VsZCB3ZSBpZ25vcmU/CgkgKi8KCXBvcnQtPmlnbm9yZV9zdGF0dXNfbWFzayA9IDA7CglpZiAodGVybWlvcy0+Y19pZmxhZyAmIElHTlBBUikKCQlwb3J0LT5pZ25vcmVfc3RhdHVzX21hc2sgfD0gUzNDMjQxMF9VRVJTVEFUX09WRVJSVU47CglpZiAodGVybWlvcy0+Y19pZmxhZyAmIElHTkJSSyAmJiB0ZXJtaW9zLT5jX2lmbGFnICYgSUdOUEFSKQoJCXBvcnQtPmlnbm9yZV9zdGF0dXNfbWFzayB8PSBTM0MyNDEwX1VFUlNUQVRfRlJBTUU7CgoJLyoKCSAqIElnbm9yZSBhbGwgY2hhcmFjdGVycyBpZiBDUkVBRCBpcyBub3Qgc2V0LgoJICovCglpZiAoKHRlcm1pb3MtPmNfY2ZsYWcgJiBDUkVBRCkgPT0gMCkKCQlwb3J0LT5pZ25vcmVfc3RhdHVzX21hc2sgfD0gUlhTVEFUX0RVTU1ZX1JFQUQ7CgoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgY29uc3QgY2hhciAqczNjMjR4eF9zZXJpYWxfdHlwZShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQp7Cglzd2l0Y2ggKHBvcnQtPnR5cGUpIHsKCWNhc2UgUE9SVF9TM0MyNDEwOgoJCXJldHVybiAiUzNDMjQxMCI7CgljYXNlIFBPUlRfUzNDMjQ0MDoKCQlyZXR1cm4gIlMzQzI0NDAiOwoJZGVmYXVsdDoKCQlyZXR1cm4gTlVMTDsKCX0KfQoKI2RlZmluZSBNQVBfU0laRSAoMHgxMDApCgpzdGF0aWMgdm9pZCBzM2MyNHh4X3NlcmlhbF9yZWxlYXNlX3BvcnQoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKewoJcmVsZWFzZV9tZW1fcmVnaW9uKHBvcnQtPm1hcGJhc2UsIE1BUF9TSVpFKTsKfQoKc3RhdGljIGludCBzM2MyNHh4X3NlcmlhbF9yZXF1ZXN0X3BvcnQoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKewoJY2hhciAqbmFtZSA9IHMzYzI0eHhfc2VyaWFsX3BvcnRuYW1lKHBvcnQpOwoJcmV0dXJuIHJlcXVlc3RfbWVtX3JlZ2lvbihwb3J0LT5tYXBiYXNlLCBNQVBfU0laRSwgbmFtZSkgPyAwIDogLUVCVVNZOwp9CgpzdGF0aWMgdm9pZCBzM2MyNHh4X3NlcmlhbF9jb25maWdfcG9ydChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCBpbnQgZmxhZ3MpCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyAqaW5mbyA9IHMzYzI0eHhfcG9ydF90b19pbmZvKHBvcnQpOwoKCWlmIChmbGFncyAmIFVBUlRfQ09ORklHX1RZUEUgJiYKCSAgICBzM2MyNHh4X3NlcmlhbF9yZXF1ZXN0X3BvcnQocG9ydCkgPT0gMCkKCQlwb3J0LT50eXBlID0gaW5mby0+dHlwZTsKfQoKLyoKICogdmVyaWZ5IHRoZSBuZXcgc2VyaWFsX3N0cnVjdCAoZm9yIFRJT0NTU0VSSUFMKS4KICovCnN0YXRpYyBpbnQKczNjMjR4eF9zZXJpYWxfdmVyaWZ5X3BvcnQoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgc3RydWN0IHNlcmlhbF9zdHJ1Y3QgKnNlcikKewoJc3RydWN0IHMzYzI0eHhfdWFydF9pbmZvICppbmZvID0gczNjMjR4eF9wb3J0X3RvX2luZm8ocG9ydCk7CgoJaWYgKHNlci0+dHlwZSAhPSBQT1JUX1VOS05PV04gJiYgc2VyLT50eXBlICE9IGluZm8tPnR5cGUpCgkJcmV0dXJuIC1FSU5WQUw7CgoJcmV0dXJuIDA7Cn0KCgojaWZkZWYgQ09ORklHX1NFUklBTF9TM0MyNDEwX0NPTlNPTEUKCnN0YXRpYyBzdHJ1Y3QgY29uc29sZSBzM2MyNHh4X3NlcmlhbF9jb25zb2xlOwoKI2RlZmluZSBTM0MyNFhYX1NFUklBTF9DT05TT0xFICZzM2MyNHh4X3NlcmlhbF9jb25zb2xlCiNlbHNlCiNkZWZpbmUgUzNDMjRYWF9TRVJJQUxfQ09OU09MRSBOVUxMCiNlbmRpZgoKc3RhdGljIHN0cnVjdCB1YXJ0X29wcyBzM2MyNHh4X3NlcmlhbF9vcHMgPSB7CgkucG0JCT0gczNjMjR4eF9zZXJpYWxfcG0sCgkudHhfZW1wdHkJPSBzM2MyNHh4X3NlcmlhbF90eF9lbXB0eSwKCS5nZXRfbWN0cmwJPSBzM2MyNHh4X3NlcmlhbF9nZXRfbWN0cmwsCgkuc2V0X21jdHJsCT0gczNjMjR4eF9zZXJpYWxfc2V0X21jdHJsLAoJLnN0b3BfdHgJPSBzM2MyNHh4X3NlcmlhbF9zdG9wX3R4LAoJLnN0YXJ0X3R4CT0gczNjMjR4eF9zZXJpYWxfc3RhcnRfdHgsCgkuc3RvcF9yeAk9IHMzYzI0eHhfc2VyaWFsX3N0b3BfcngsCgkuZW5hYmxlX21zCT0gczNjMjR4eF9zZXJpYWxfZW5hYmxlX21zLAoJLmJyZWFrX2N0bAk9IHMzYzI0eHhfc2VyaWFsX2JyZWFrX2N0bCwKCS5zdGFydHVwCT0gczNjMjR4eF9zZXJpYWxfc3RhcnR1cCwKCS5zaHV0ZG93bgk9IHMzYzI0eHhfc2VyaWFsX3NodXRkb3duLAoJLnNldF90ZXJtaW9zCT0gczNjMjR4eF9zZXJpYWxfc2V0X3Rlcm1pb3MsCgkudHlwZQkJPSBzM2MyNHh4X3NlcmlhbF90eXBlLAoJLnJlbGVhc2VfcG9ydAk9IHMzYzI0eHhfc2VyaWFsX3JlbGVhc2VfcG9ydCwKCS5yZXF1ZXN0X3BvcnQJPSBzM2MyNHh4X3NlcmlhbF9yZXF1ZXN0X3BvcnQsCgkuY29uZmlnX3BvcnQJPSBzM2MyNHh4X3NlcmlhbF9jb25maWdfcG9ydCwKCS52ZXJpZnlfcG9ydAk9IHMzYzI0eHhfc2VyaWFsX3ZlcmlmeV9wb3J0LAp9OwoKCnN0YXRpYyBzdHJ1Y3QgdWFydF9kcml2ZXIgczNjMjR4eF91YXJ0X2RydiA9IHsKCS5vd25lcgkJPSBUSElTX01PRFVMRSwKCS5kZXZfbmFtZQk9ICJzM2MyNDEwX3NlcmlhbCIsCgkubnIJCT0gMywKCS5jb25zCQk9IFMzQzI0WFhfU0VSSUFMX0NPTlNPTEUsCgkuZHJpdmVyX25hbWUJPSBTM0MyNFhYX1NFUklBTF9OQU1FLAoJLmRldmZzX25hbWUJPSBTM0MyNFhYX1NFUklBTF9ERVZGUywKCS5tYWpvcgkJPSBTM0MyNFhYX1NFUklBTF9NQUpPUiwKCS5taW5vcgkJPSBTM0MyNFhYX1NFUklBTF9NSU5PUiwKfTsKCnN0YXRpYyBzdHJ1Y3QgczNjMjR4eF91YXJ0X3BvcnQgczNjMjR4eF9zZXJpYWxfcG9ydHNbTlJfUE9SVFNdID0gewoJWzBdID0gewoJCS5wb3J0ID0gewoJCQkubG9jawkJPSBTUElOX0xPQ0tfVU5MT0NLRUQsCgkJCS5pb3R5cGUJCT0gVVBJT19NRU0sCgkJCS5pcnEJCT0gSVJRX1MzQ1VBUlRfUlgwLAoJCQkudWFydGNsawk9IDAsCgkJCS5maWZvc2l6ZQk9IDE2LAoJCQkub3BzCQk9ICZzM2MyNHh4X3NlcmlhbF9vcHMsCgkJCS5mbGFncwkJPSBVUEZfQk9PVF9BVVRPQ09ORiwKCQkJLmxpbmUJCT0gMCwKCQl9Cgl9LAoJWzFdID0gewoJCS5wb3J0ID0gewoJCQkubG9jawkJPSBTUElOX0xPQ0tfVU5MT0NLRUQsCgkJCS5pb3R5cGUJCT0gVVBJT19NRU0sCgkJCS5pcnEJCT0gSVJRX1MzQ1VBUlRfUlgxLAoJCQkudWFydGNsawk9IDAsCgkJCS5maWZvc2l6ZQk9IDE2LAoJCQkub3BzCQk9ICZzM2MyNHh4X3NlcmlhbF9vcHMsCgkJCS5mbGFncwkJPSBVUEZfQk9PVF9BVVRPQ09ORiwKCQkJLmxpbmUJCT0gMSwKCQl9Cgl9LAojaWYgTlJfUE9SVFMgPiAyCgoJWzJdID0gewoJCS5wb3J0ID0gewoJCQkubG9jawkJPSBTUElOX0xPQ0tfVU5MT0NLRUQsCgkJCS5pb3R5cGUJCT0gVVBJT19NRU0sCgkJCS5pcnEJCT0gSVJRX1MzQ1VBUlRfUlgyLAoJCQkudWFydGNsawk9IDAsCgkJCS5maWZvc2l6ZQk9IDE2LAoJCQkub3BzCQk9ICZzM2MyNHh4X3NlcmlhbF9vcHMsCgkJCS5mbGFncwkJPSBVUEZfQk9PVF9BVVRPQ09ORiwKCQkJLmxpbmUJCT0gMiwKCQl9Cgl9CiNlbmRpZgp9OwoKLyogczNjMjR4eF9zZXJpYWxfcmVzZXRwb3J0CiAqCiAqIHdyYXBwZXIgdG8gY2FsbCB0aGUgc3BlY2lmaWMgcmVzZXQgZm9yIHRoaXMgcG9ydCAocmVzZXQgdGhlIGZpZm9zCiAqIGFuZCB0aGUgc2V0dGluZ3MpCiovCgpzdGF0aWMgaW5saW5lIGludCBzM2MyNHh4X3NlcmlhbF9yZXNldHBvcnQoc3RydWN0IHVhcnRfcG9ydCAqIHBvcnQsCgkJCQkJICAgc3RydWN0IHMzYzI0MTBfdWFydGNmZyAqY2ZnKQp7CglzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKmluZm8gPSBzM2MyNHh4X3BvcnRfdG9faW5mbyhwb3J0KTsKCglyZXR1cm4gKGluZm8tPnJlc2V0X3BvcnQpKHBvcnQsIGNmZyk7Cn0KCi8qIHMzYzI0eHhfc2VyaWFsX2luaXRfcG9ydAogKgogKiBpbml0aWFsaXNlIGEgc2luZ2xlIHNlcmlhbCBwb3J0IGZyb20gdGhlIHBsYXRmb3JtIGRldmljZSBnaXZlbgogKi8KCnN0YXRpYyBpbnQgczNjMjR4eF9zZXJpYWxfaW5pdF9wb3J0KHN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqb3VycG9ydCwKCQkJCSAgICBzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKmluZm8sCgkJCQkgICAgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGxhdGRldikKewoJc3RydWN0IHVhcnRfcG9ydCAqcG9ydCA9ICZvdXJwb3J0LT5wb3J0OwoJc3RydWN0IHMzYzI0MTBfdWFydGNmZyAqY2ZnOwoJc3RydWN0IHJlc291cmNlICpyZXM7CgoJZGJnKCJzM2MyNHh4X3NlcmlhbF9pbml0X3BvcnQ6IHBvcnQ9JXAsIHBsYXRkZXY9JXBcbiIsIHBvcnQsIHBsYXRkZXYpOwoKCWlmIChwbGF0ZGV2ID09IE5VTEwpCgkJcmV0dXJuIC1FTk9ERVY7CgoJY2ZnID0gczNjMjR4eF9kZXZfdG9fY2ZnKCZwbGF0ZGV2LT5kZXYpOwoKCWlmIChwb3J0LT5tYXBiYXNlICE9IDApCgkJcmV0dXJuIDA7CgoJaWYgKGNmZy0+aHdwb3J0ID4gMykKCQlyZXR1cm4gLUVJTlZBTDsKCgkvKiBzZXR1cCBpbmZvIGZvciBwb3J0ICovCglwb3J0LT5kZXYJPSAmcGxhdGRldi0+ZGV2OwoJb3VycG9ydC0+aW5mbwk9IGluZm87CgoJLyogY29weSB0aGUgaW5mbyBpbiBmcm9tIHByb3ZpZGVkIHN0cnVjdHVyZSAqLwoJb3VycG9ydC0+cG9ydC5maWZvc2l6ZSA9IGluZm8tPmZpZm9zaXplOwoKCWRiZygiczNjMjR4eF9zZXJpYWxfaW5pdF9wb3J0OiAlcCAoaHcgJWQpLi4uXG4iLCBwb3J0LCBjZmctPmh3cG9ydCk7CgoJcG9ydC0+dWFydGNsayA9IDE7CgoJaWYgKGNmZy0+dWFydF9mbGFncyAmIFVQRl9DT05TX0ZMT1cpIHsKCQlkYmcoInMzYzI0eHhfc2VyaWFsX2luaXRfcG9ydDogZW5hYmxpbmcgZmxvdyBjb250cm9sXG4iKTsKCQlwb3J0LT5mbGFncyB8PSBVUEZfQ09OU19GTE9XOwoJfQoKCS8qIHNvcnQgb3VyIHRoZSBwaHlzaWNhbCBhbmQgdmlydHVhbCBhZGRyZXNzZXMgZm9yIGVhY2ggVUFSVCAqLwoKCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwbGF0ZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CglpZiAocmVzID09IE5VTEwpIHsKCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCB0byBmaW5kIG1lbW9yeSByZXNvdXJjZSBmb3IgdWFydFxuIik7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJZGJnKCJyZXNvdXJjZSAlcCAoJWx4Li4lbHgpXG4iLCByZXMsIHJlcy0+c3RhcnQsIHJlcy0+ZW5kKTsKCglwb3J0LT5tYXBiYXNlCT0gcmVzLT5zdGFydDsKCXBvcnQtPm1lbWJhc2UJPSBTM0MyNFhYX1ZBX1VBUlQgKyAocmVzLT5zdGFydCAtIFMzQzI0MTBfUEFfVUFSVCk7Cglwb3J0LT5pcnEJPSBwbGF0Zm9ybV9nZXRfaXJxKHBsYXRkZXYsIDApOwoKCW91cnBvcnQtPmNsawk9IGNsa19nZXQoJnBsYXRkZXYtPmRldiwgInVhcnQiKTsKCglpZiAob3VycG9ydC0+Y2xrICE9IE5VTEwgJiYgIUlTX0VSUihvdXJwb3J0LT5jbGspKQoJCWNsa191c2Uob3VycG9ydC0+Y2xrKTsKCglkYmcoInBvcnQ6IG1hcD0lMDh4LCBtZW09JTA4eCwgaXJxPSVkLCBjbG9jaz0lbGRcbiIsCgkgICAgcG9ydC0+bWFwYmFzZSwgcG9ydC0+bWVtYmFzZSwgcG9ydC0+aXJxLCBwb3J0LT51YXJ0Y2xrKTsKCgkvKiByZXNldCB0aGUgZmlmb3MgKGFuZCBzZXR1cCB0aGUgdWFydCkgKi8KCXMzYzI0eHhfc2VyaWFsX3Jlc2V0cG9ydChwb3J0LCBjZmcpOwoJcmV0dXJuIDA7Cn0KCi8qIERldmljZSBkcml2ZXIgc2VyaWFsIHBvcnQgcHJvYmUgKi8KCnN0YXRpYyBpbnQgcHJvYmVfaW5kZXggPSAwOwoKaW50IHMzYzI0eHhfc2VyaWFsX3Byb2JlKHN0cnVjdCBkZXZpY2UgKl9kZXYsCgkJCSBzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKmluZm8pCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqb3VycG9ydDsKCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldiA9IHRvX3BsYXRmb3JtX2RldmljZShfZGV2KTsKCWludCByZXQ7CgoJZGJnKCJzM2MyNHh4X3NlcmlhbF9wcm9iZSglcCwgJXApICVkXG4iLCBfZGV2LCBpbmZvLCBwcm9iZV9pbmRleCk7CgoJb3VycG9ydCA9ICZzM2MyNHh4X3NlcmlhbF9wb3J0c1twcm9iZV9pbmRleF07Cglwcm9iZV9pbmRleCsrOwoKCWRiZygiJXM6IGluaXRpYWxpc2luZyBwb3J0ICVwLi4uXG4iLCBfX0ZVTkNUSU9OX18sIG91cnBvcnQpOwoKCXJldCA9IHMzYzI0eHhfc2VyaWFsX2luaXRfcG9ydChvdXJwb3J0LCBpbmZvLCBkZXYpOwoJaWYgKHJldCA8IDApCgkJZ290byBwcm9iZV9lcnI7CgoJZGJnKCIlczogYWRkaW5nIHBvcnRcbiIsIF9fRlVOQ1RJT05fXyk7Cgl1YXJ0X2FkZF9vbmVfcG9ydCgmczNjMjR4eF91YXJ0X2RydiwgJm91cnBvcnQtPnBvcnQpOwoJZGV2X3NldF9kcnZkYXRhKF9kZXYsICZvdXJwb3J0LT5wb3J0KTsKCglyZXR1cm4gMDsKCiBwcm9iZV9lcnI6CglyZXR1cm4gcmV0Owp9CgppbnQgczNjMjR4eF9zZXJpYWxfcmVtb3ZlKHN0cnVjdCBkZXZpY2UgKl9kZXYpCnsKCXN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQgPSBzM2MyNHh4X2Rldl90b19wb3J0KF9kZXYpOwoKCWlmIChwb3J0KQoJCXVhcnRfcmVtb3ZlX29uZV9wb3J0KCZzM2MyNHh4X3VhcnRfZHJ2LCBwb3J0KTsKCglyZXR1cm4gMDsKfQoKLyogVUFSVCBwb3dlciBtYW5hZ2VtZW50IGNvZGUgKi8KCiNpZmRlZiBDT05GSUdfUE0KCmludCBzM2MyNHh4X3NlcmlhbF9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldiwgdTMyIHN0YXRlLCB1MzIgbGV2ZWwpCnsKCXN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQgPSBzM2MyNHh4X2Rldl90b19wb3J0KGRldik7CgoJaWYgKHBvcnQgJiYgbGV2ZWwgPT0gU1VTUEVORF9ESVNBQkxFKQoJCXVhcnRfc3VzcGVuZF9wb3J0KCZzM2MyNHh4X3VhcnRfZHJ2LCBwb3J0KTsKCglyZXR1cm4gMDsKfQoKaW50IHMzYzI0eHhfc2VyaWFsX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHUzMiBsZXZlbCkKewoJc3RydWN0IHVhcnRfcG9ydCAqcG9ydCA9IHMzYzI0eHhfZGV2X3RvX3BvcnQoZGV2KTsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqb3VycG9ydCA9IHRvX291cnBvcnQocG9ydCk7CgoJaWYgKHBvcnQgJiYgbGV2ZWwgPT0gUkVTVU1FX0VOQUJMRSkgewoJCWNsa19lbmFibGUob3VycG9ydC0+Y2xrKTsKCQlzM2MyNHh4X3NlcmlhbF9yZXNldHBvcnQocG9ydCwgczNjMjR4eF9wb3J0X3RvX2NmZyhwb3J0KSk7CgkJY2xrX2Rpc2FibGUob3VycG9ydC0+Y2xrKTsKCgkJdWFydF9yZXN1bWVfcG9ydCgmczNjMjR4eF91YXJ0X2RydiwgcG9ydCk7Cgl9CgoJcmV0dXJuIDA7Cn0KCiNlbHNlCiNkZWZpbmUgczNjMjR4eF9zZXJpYWxfc3VzcGVuZCBOVUxMCiNkZWZpbmUgczNjMjR4eF9zZXJpYWxfcmVzdW1lICBOVUxMCiNlbmRpZgoKaW50IHMzYzI0eHhfc2VyaWFsX2luaXQoc3RydWN0IGRldmljZV9kcml2ZXIgKmRydiwKCQkJc3RydWN0IHMzYzI0eHhfdWFydF9pbmZvICppbmZvKQp7CglkYmcoInMzYzI0eHhfc2VyaWFsX2luaXQoJXAsJXApXG4iLCBkcnYsIGluZm8pOwoJcmV0dXJuIGRyaXZlcl9yZWdpc3RlcihkcnYpOwp9CgoKLyogbm93IGNvbWVzIHRoZSBjb2RlIHRvIGluaXRpYWxpc2UgZWl0aGVyIHRoZSBzM2MyNDEwIG9yIHMzYzI0NDAgc2VyaWFsCiAqIHBvcnQgaW5mb3JtYXRpb24KKi8KCi8qIGNwdSBzcGVjaWZpYyB2YXJpYXRpb25zIG9uIHRoZSBzZXJpYWwgcG9ydCBzdXBwb3J0ICovCgojaWZkZWYgQ09ORklHX0NQVV9TM0MyNDAwCgpzdGF0aWMgaW50IHMzYzI0MDBfc2VyaWFsX2dldHNvdXJjZShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LAoJCQkJICAgIHN0cnVjdCBzM2MyNHh4X3VhcnRfY2xrc3JjICpjbGspCnsKCWNsay0+ZGl2aXNvciA9IDE7CgljbGstPm5hbWUgPSAicGNsayI7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgczNjMjQwMF9zZXJpYWxfc2V0c291cmNlKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsCgkJCQkgICAgc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMgKmNsaykKewoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgczNjMjQwMF9zZXJpYWxfcmVzZXRwb3J0KHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsCgkJCQkgICAgc3RydWN0IHMzYzI0MTBfdWFydGNmZyAqY2ZnKQp7CglkYmcoInMzYzI0MDBfc2VyaWFsX3Jlc2V0cG9ydDogcG9ydD0lcCAoJTA4bHgpLCBjZmc9JXBcbiIsCgkgICAgcG9ydCwgcG9ydC0+bWFwYmFzZSwgY2ZnKTsKCgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTiwgIGNmZy0+dWNvbik7Cgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUxDT04sIGNmZy0+dWxjb24pOwoKCS8qIHJlc2V0IGJvdGggZmlmb3MgKi8KCgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04sIGNmZy0+dWZjb24gfCBTM0MyNDEwX1VGQ09OX1JFU0VUQk9USCk7Cgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04sIGNmZy0+dWZjb24pOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IHMzYzI0eHhfdWFydF9pbmZvIHMzYzI0MDBfdWFydF9pbmYgPSB7CgkubmFtZQkJPSAiU2Ftc3VuZyBTM0MyNDAwIFVBUlQiLAoJLnR5cGUJCT0gUE9SVF9TM0MyNDAwLAoJLmZpZm9zaXplCT0gMTYsCgkucnhfZmlmb21hc2sJPSBTM0MyNDEwX1VGU1RBVF9SWE1BU0ssCgkucnhfZmlmb3NoaWZ0CT0gUzNDMjQxMF9VRlNUQVRfUlhTSElGVCwKCS5yeF9maWZvZnVsbAk9IFMzQzI0MTBfVUZTVEFUX1JYRlVMTCwKCS50eF9maWZvZnVsbAk9IFMzQzI0MTBfVUZTVEFUX1RYRlVMTCwKCS50eF9maWZvbWFzawk9IFMzQzI0MTBfVUZTVEFUX1RYTUFTSywKCS50eF9maWZvc2hpZnQJPSBTM0MyNDEwX1VGU1RBVF9UWFNISUZULAoJLmdldF9jbGtzcmMJPSBzM2MyNDAwX3NlcmlhbF9nZXRzb3VyY2UsCgkuc2V0X2Nsa3NyYwk9IHMzYzI0MDBfc2VyaWFsX3NldHNvdXJjZSwKCS5yZXNldF9wb3J0CT0gczNjMjQwMF9zZXJpYWxfcmVzZXRwb3J0LAp9OwoKc3RhdGljIGludCBzM2MyNDAwX3NlcmlhbF9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYpCnsKCXJldHVybiBzM2MyNHh4X3NlcmlhbF9wcm9iZShkZXYsICZzM2MyNDAwX3VhcnRfaW5mKTsKfQoKc3RhdGljIHN0cnVjdCBkZXZpY2VfZHJpdmVyIHMzYzI0MDBfc2VyaWFsX2RydiA9IHsKCS5uYW1lCQk9ICJzM2MyNDAwLXVhcnQiLAoJLmJ1cwkJPSAmcGxhdGZvcm1fYnVzX3R5cGUsCgkucHJvYmUJCT0gczNjMjQwMF9zZXJpYWxfcHJvYmUsCgkucmVtb3ZlCQk9IHMzYzI0eHhfc2VyaWFsX3JlbW92ZSwKCS5zdXNwZW5kCT0gczNjMjR4eF9zZXJpYWxfc3VzcGVuZCwKCS5yZXN1bWUJCT0gczNjMjR4eF9zZXJpYWxfcmVzdW1lLAp9OwoKc3RhdGljIGlubGluZSBpbnQgczNjMjQwMF9zZXJpYWxfaW5pdCh2b2lkKQp7CglyZXR1cm4gczNjMjR4eF9zZXJpYWxfaW5pdCgmczNjMjQwMF9zZXJpYWxfZHJ2LCAmczNjMjQwMF91YXJ0X2luZik7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBzM2MyNDAwX3NlcmlhbF9leGl0KHZvaWQpCnsKCWRyaXZlcl91bnJlZ2lzdGVyKCZzM2MyNDAwX3NlcmlhbF9kcnYpOwp9CgojZGVmaW5lIHMzYzI0MDBfdWFydF9pbmZfYXQgJnMzYzI0MDBfdWFydF9pbmYKI2Vsc2UKCnN0YXRpYyBpbmxpbmUgaW50IHMzYzI0MDBfc2VyaWFsX2luaXQodm9pZCkKewoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBzM2MyNDAwX3NlcmlhbF9leGl0KHZvaWQpCnsKfQoKI2RlZmluZSBzM2MyNDAwX3VhcnRfaW5mX2F0IE5VTEwKCiNlbmRpZiAvKiBDT05GSUdfQ1BVX1MzQzI0MDAgKi8KCi8qIFMzQzI0MTAgc3VwcG9ydCAqLwoKI2lmZGVmIENPTkZJR19DUFVfUzNDMjQxMAoKc3RhdGljIGludCBzM2MyNDEwX3NlcmlhbF9zZXRzb3VyY2Uoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwKCQkJCSAgICBzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyAqY2xrKQp7Cgl1bnNpZ25lZCBsb25nIHVjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7CgoJaWYgKHN0cmNtcChjbGstPm5hbWUsICJ1Y2xrIikgPT0gMCkKCQl1Y29uIHw9IFMzQzI0MTBfVUNPTl9VQ0xLOwoJZWxzZQoJCXVjb24gJj0gflMzQzI0MTBfVUNPTl9VQ0xLOwoKCXdyX3JlZ2wocG9ydCwgUzNDMjQxMF9VQ09OLCB1Y29uKTsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IHMzYzI0MTBfc2VyaWFsX2dldHNvdXJjZShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LAoJCQkJICAgIHN0cnVjdCBzM2MyNHh4X3VhcnRfY2xrc3JjICpjbGspCnsKCXVuc2lnbmVkIGxvbmcgdWNvbiA9IHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VQ09OKTsKCgljbGstPmRpdmlzb3IgPSAxOwoJY2xrLT5uYW1lID0gKHVjb24gJiBTM0MyNDEwX1VDT05fVUNMSykgPyAidWNsayIgOiAicGNsayI7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgczNjMjQxMF9zZXJpYWxfcmVzZXRwb3J0KHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsCgkJCQkgICAgc3RydWN0IHMzYzI0MTBfdWFydGNmZyAqY2ZnKQp7CglkYmcoInMzYzI0MTBfc2VyaWFsX3Jlc2V0cG9ydDogcG9ydD0lcCAoJTA4bHgpLCBjZmc9JXBcbiIsCgkgICAgcG9ydCwgcG9ydC0+bWFwYmFzZSwgY2ZnKTsKCgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTiwgIGNmZy0+dWNvbik7Cgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUxDT04sIGNmZy0+dWxjb24pOwoKCS8qIHJlc2V0IGJvdGggZmlmb3MgKi8KCgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04sIGNmZy0+dWZjb24gfCBTM0MyNDEwX1VGQ09OX1JFU0VUQk9USCk7Cgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUZDT04sIGNmZy0+dWZjb24pOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IHMzYzI0eHhfdWFydF9pbmZvIHMzYzI0MTBfdWFydF9pbmYgPSB7CgkubmFtZQkJPSAiU2Ftc3VuZyBTM0MyNDEwIFVBUlQiLAoJLnR5cGUJCT0gUE9SVF9TM0MyNDEwLAoJLmZpZm9zaXplCT0gMTYsCgkucnhfZmlmb21hc2sJPSBTM0MyNDEwX1VGU1RBVF9SWE1BU0ssCgkucnhfZmlmb3NoaWZ0CT0gUzNDMjQxMF9VRlNUQVRfUlhTSElGVCwKCS5yeF9maWZvZnVsbAk9IFMzQzI0MTBfVUZTVEFUX1JYRlVMTCwKCS50eF9maWZvZnVsbAk9IFMzQzI0MTBfVUZTVEFUX1RYRlVMTCwKCS50eF9maWZvbWFzawk9IFMzQzI0MTBfVUZTVEFUX1RYTUFTSywKCS50eF9maWZvc2hpZnQJPSBTM0MyNDEwX1VGU1RBVF9UWFNISUZULAoJLmdldF9jbGtzcmMJPSBzM2MyNDEwX3NlcmlhbF9nZXRzb3VyY2UsCgkuc2V0X2Nsa3NyYwk9IHMzYzI0MTBfc2VyaWFsX3NldHNvdXJjZSwKCS5yZXNldF9wb3J0CT0gczNjMjQxMF9zZXJpYWxfcmVzZXRwb3J0LAp9OwoKLyogZGV2aWNlIG1hbmFnZW1lbnQgKi8KCnN0YXRpYyBpbnQgczNjMjQxMF9zZXJpYWxfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2KQp7CglyZXR1cm4gczNjMjR4eF9zZXJpYWxfcHJvYmUoZGV2LCAmczNjMjQxMF91YXJ0X2luZik7Cn0KCnN0YXRpYyBzdHJ1Y3QgZGV2aWNlX2RyaXZlciBzM2MyNDEwX3NlcmlhbF9kcnYgPSB7CgkubmFtZQkJPSAiczNjMjQxMC11YXJ0IiwKCS5idXMJCT0gJnBsYXRmb3JtX2J1c190eXBlLAoJLnByb2JlCQk9IHMzYzI0MTBfc2VyaWFsX3Byb2JlLAoJLnJlbW92ZQkJPSBzM2MyNHh4X3NlcmlhbF9yZW1vdmUsCgkuc3VzcGVuZAk9IHMzYzI0eHhfc2VyaWFsX3N1c3BlbmQsCgkucmVzdW1lCQk9IHMzYzI0eHhfc2VyaWFsX3Jlc3VtZSwKfTsKCnN0YXRpYyBpbmxpbmUgaW50IHMzYzI0MTBfc2VyaWFsX2luaXQodm9pZCkKewoJcmV0dXJuIHMzYzI0eHhfc2VyaWFsX2luaXQoJnMzYzI0MTBfc2VyaWFsX2RydiwgJnMzYzI0MTBfdWFydF9pbmYpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgczNjMjQxMF9zZXJpYWxfZXhpdCh2b2lkKQp7Cglkcml2ZXJfdW5yZWdpc3RlcigmczNjMjQxMF9zZXJpYWxfZHJ2KTsKfQoKI2RlZmluZSBzM2MyNDEwX3VhcnRfaW5mX2F0ICZzM2MyNDEwX3VhcnRfaW5mCiNlbHNlCgpzdGF0aWMgaW5saW5lIGludCBzM2MyNDEwX3NlcmlhbF9pbml0KHZvaWQpCnsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgczNjMjQxMF9zZXJpYWxfZXhpdCh2b2lkKQp7Cn0KCiNkZWZpbmUgczNjMjQxMF91YXJ0X2luZl9hdCBOVUxMCgojZW5kaWYgLyogQ09ORklHX0NQVV9TM0MyNDEwICovCgojaWZkZWYgQ09ORklHX0NQVV9TM0MyNDQwCgpzdGF0aWMgaW50IHMzYzI0NDBfc2VyaWFsX3NldHNvdXJjZShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LAoJCQkJICAgICBzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyAqY2xrKQp7Cgl1bnNpZ25lZCBsb25nIHVjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7CgoJLy8gdG9kbyAtIHByb3BlciBmY2xrPD5ub25mY2xrIHN3aXRjaCAvLwoKCXVjb24gJj0gflMzQzI0NDBfVUNPTl9DTEtNQVNLOwoKCWlmIChzdHJjbXAoY2xrLT5uYW1lLCAidWNsayIpID09IDApCgkJdWNvbiB8PSBTM0MyNDQwX1VDT05fVUNMSzsKCWVsc2UgaWYgKHN0cmNtcChjbGstPm5hbWUsICJwY2xrIikgPT0gMCkKCQl1Y29uIHw9IFMzQzI0NDBfVUNPTl9QQ0xLOwoJZWxzZSBpZiAoc3RyY21wKGNsay0+bmFtZSwgImZjbGsiKSA9PSAwKQoJCXVjb24gfD0gUzNDMjQ0MF9VQ09OX0ZDTEs7CgllbHNlIHsKCQlwcmludGsoS0VSTl9FUlIgInVua25vd24gY2xvY2sgc291cmNlICVzXG4iLCBjbGstPm5hbWUpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCXdyX3JlZ2wocG9ydCwgUzNDMjQxMF9VQ09OLCB1Y29uKTsKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCBzM2MyNDQwX3NlcmlhbF9nZXRzb3VyY2Uoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwKCQkJCSAgICBzdHJ1Y3QgczNjMjR4eF91YXJ0X2Nsa3NyYyAqY2xrKQp7Cgl1bnNpZ25lZCBsb25nIHVjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7Cgl1bnNpZ25lZCBsb25nIHVjb24wLCB1Y29uMSwgdWNvbjI7CgoJc3dpdGNoICh1Y29uICYgUzNDMjQ0MF9VQ09OX0NMS01BU0spIHsKCWNhc2UgUzNDMjQ0MF9VQ09OX1VDTEs6CgkJY2xrLT5kaXZpc29yID0gMTsKCQljbGstPm5hbWUgPSAidWNsayI7CgkJYnJlYWs7CgoJY2FzZSBTM0MyNDQwX1VDT05fUENMSzoKCWNhc2UgUzNDMjQ0MF9VQ09OX1BDTEsyOgoJCWNsay0+ZGl2aXNvciA9IDE7CgkJY2xrLT5uYW1lID0gInBjbGsiOwoJCWJyZWFrOwoKCWNhc2UgUzNDMjQ0MF9VQ09OX0ZDTEs6CgkJLyogdGhlIGZ1biBvZiBjYWxjdWxhdGluZyB0aGUgdWFydCBkaXZpc29ycyBvbgoJCSAqIHRoZSBzM2MyNDQwICovCgoJCXVjb24wID0gX19yYXdfcmVhZGwoUzNDMjRYWF9WQV9VQVJUMCArIFMzQzI0MTBfVUNPTik7CgkJdWNvbjEgPSBfX3Jhd19yZWFkbChTM0MyNFhYX1ZBX1VBUlQxICsgUzNDMjQxMF9VQ09OKTsKCQl1Y29uMiA9IF9fcmF3X3JlYWRsKFMzQzI0WFhfVkFfVUFSVDIgKyBTM0MyNDEwX1VDT04pOwoKCQlwcmludGsoInVjb25zOiAlMDhseCwgJTA4bHgsICUwOGx4XG4iLCB1Y29uMCwgdWNvbjEsIHVjb24yKTsKCgkJdWNvbjAgJj0gUzNDMjQ0MF9VQ09OMF9ESVZNQVNLOwoJCXVjb24xICY9IFMzQzI0NDBfVUNPTjFfRElWTUFTSzsKCQl1Y29uMiAmPSBTM0MyNDQwX1VDT04yX0RJVk1BU0s7CgoJCWlmICh1Y29uMCAhPSAwKSB7CgkJCWNsay0+ZGl2aXNvciA9IHVjb24wID4+IFMzQzI0NDBfVUNPTl9ESVZTSElGVDsKCQkJY2xrLT5kaXZpc29yICs9IDY7CgkJfSBlbHNlIGlmICh1Y29uMSAhPSAwKSB7CgkJCWNsay0+ZGl2aXNvciA9IHVjb24xID4+IFMzQzI0NDBfVUNPTl9ESVZTSElGVDsKCQkJY2xrLT5kaXZpc29yICs9IDIxOwoJCX0gZWxzZSBpZiAodWNvbjIgIT0gMCkgewoJCQljbGstPmRpdmlzb3IgPSB1Y29uMiA+PiBTM0MyNDQwX1VDT05fRElWU0hJRlQ7CgkJCWNsay0+ZGl2aXNvciArPSAzNjsKCQl9IGVsc2UgewoJCQkvKiBtYW51YWwgY2FsaW1zIDQ0LCBzZWVtcyB0byBiZSA5ICovCgkJCWNsay0+ZGl2aXNvciA9IDk7CgkJfQoKCQljbGstPm5hbWUgPSAiZmNsayI7CgkJYnJlYWs7Cgl9CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgczNjMjQ0MF9zZXJpYWxfcmVzZXRwb3J0KHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsCgkJCQkgICAgc3RydWN0IHMzYzI0MTBfdWFydGNmZyAqY2ZnKQp7Cgl1bnNpZ25lZCBsb25nIHVjb24gPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7CgoJZGJnKCJzM2MyNDQwX3NlcmlhbF9yZXNldHBvcnQ6IHBvcnQ9JXAgKCUwOGx4KSwgY2ZnPSVwXG4iLAoJICAgIHBvcnQsIHBvcnQtPm1hcGJhc2UsIGNmZyk7CgoJLyogZW5zdXJlIHdlIGRvbid0IGNoYW5nZSB0aGUgY2xvY2sgc2V0dGluZ3MuLi4gKi8KCgl1Y29uICY9IChTM0MyNDQwX1VDT04wX0RJVk1BU0sgfCAoMzw8MTApKTsKCgl3cl9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTiwgIHVjb24gfCBjZmctPnVjb24pOwoJd3JfcmVnbChwb3J0LCBTM0MyNDEwX1VMQ09OLCBjZmctPnVsY29uKTsKCgkvKiByZXNldCBib3RoIGZpZm9zICovCgoJd3JfcmVnbChwb3J0LCBTM0MyNDEwX1VGQ09OLCBjZmctPnVmY29uIHwgUzNDMjQxMF9VRkNPTl9SRVNFVEJPVEgpOwoJd3JfcmVnbChwb3J0LCBTM0MyNDEwX1VGQ09OLCBjZmctPnVmY29uKTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIHN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyBzM2MyNDQwX3VhcnRfaW5mID0gewoJLm5hbWUJCT0gIlNhbXN1bmcgUzNDMjQ0MCBVQVJUIiwKCS50eXBlCQk9IFBPUlRfUzNDMjQ0MCwKCS5maWZvc2l6ZQk9IDY0LAoJLnJ4X2ZpZm9tYXNrCT0gUzNDMjQ0MF9VRlNUQVRfUlhNQVNLLAoJLnJ4X2ZpZm9zaGlmdAk9IFMzQzI0NDBfVUZTVEFUX1JYU0hJRlQsCgkucnhfZmlmb2Z1bGwJPSBTM0MyNDQwX1VGU1RBVF9SWEZVTEwsCgkudHhfZmlmb2Z1bGwJPSBTM0MyNDQwX1VGU1RBVF9UWEZVTEwsCgkudHhfZmlmb21hc2sJPSBTM0MyNDQwX1VGU1RBVF9UWE1BU0ssCgkudHhfZmlmb3NoaWZ0CT0gUzNDMjQ0MF9VRlNUQVRfVFhTSElGVCwKCS5nZXRfY2xrc3JjCT0gczNjMjQ0MF9zZXJpYWxfZ2V0c291cmNlLAoJLnNldF9jbGtzcmMJPSBzM2MyNDQwX3NlcmlhbF9zZXRzb3VyY2UsCgkucmVzZXRfcG9ydAk9IHMzYzI0NDBfc2VyaWFsX3Jlc2V0cG9ydCwKfTsKCi8qIGRldmljZSBtYW5hZ2VtZW50ICovCgpzdGF0aWMgaW50IHMzYzI0NDBfc2VyaWFsX3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldikKewoJZGJnKCJzM2MyNDQwX3NlcmlhbF9wcm9iZTogZGV2PSVwXG4iLCBkZXYpOwoJcmV0dXJuIHMzYzI0eHhfc2VyaWFsX3Byb2JlKGRldiwgJnMzYzI0NDBfdWFydF9pbmYpOwp9CgpzdGF0aWMgc3RydWN0IGRldmljZV9kcml2ZXIgczNjMjQ0MF9zZXJpYWxfZHJ2ID0gewoJLm5hbWUJCT0gInMzYzI0NDAtdWFydCIsCgkuYnVzCQk9ICZwbGF0Zm9ybV9idXNfdHlwZSwKCS5wcm9iZQkJPSBzM2MyNDQwX3NlcmlhbF9wcm9iZSwKCS5yZW1vdmUJCT0gczNjMjR4eF9zZXJpYWxfcmVtb3ZlLAoJLnN1c3BlbmQJPSBzM2MyNHh4X3NlcmlhbF9zdXNwZW5kLAoJLnJlc3VtZQkJPSBzM2MyNHh4X3NlcmlhbF9yZXN1bWUsCn07CgoKc3RhdGljIGlubGluZSBpbnQgczNjMjQ0MF9zZXJpYWxfaW5pdCh2b2lkKQp7CglyZXR1cm4gczNjMjR4eF9zZXJpYWxfaW5pdCgmczNjMjQ0MF9zZXJpYWxfZHJ2LCAmczNjMjQ0MF91YXJ0X2luZik7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBzM2MyNDQwX3NlcmlhbF9leGl0KHZvaWQpCnsKCWRyaXZlcl91bnJlZ2lzdGVyKCZzM2MyNDQwX3NlcmlhbF9kcnYpOwp9CgojZGVmaW5lIHMzYzI0NDBfdWFydF9pbmZfYXQgJnMzYzI0NDBfdWFydF9pbmYKI2Vsc2UKCnN0YXRpYyBpbmxpbmUgaW50IHMzYzI0NDBfc2VyaWFsX2luaXQodm9pZCkKewoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBzM2MyNDQwX3NlcmlhbF9leGl0KHZvaWQpCnsKfQoKI2RlZmluZSBzM2MyNDQwX3VhcnRfaW5mX2F0IE5VTEwKI2VuZGlmIC8qIENPTkZJR19DUFVfUzNDMjQ0MCAqLwoKLyogbW9kdWxlIGluaXRpYWxpc2F0aW9uIGNvZGUgKi8KCnN0YXRpYyBpbnQgX19pbml0IHMzYzI0eHhfc2VyaWFsX21vZGluaXQodm9pZCkKewoJaW50IHJldDsKCglyZXQgPSB1YXJ0X3JlZ2lzdGVyX2RyaXZlcigmczNjMjR4eF91YXJ0X2Rydik7CglpZiAocmV0IDwgMCkgewoJCXByaW50ayhLRVJOX0VSUiAiZmFpbGVkIHRvIHJlZ2lzdGVyIFVBUlQgZHJpdmVyXG4iKTsKCQlyZXR1cm4gLTE7Cgl9CgoJczNjMjQwMF9zZXJpYWxfaW5pdCgpOwoJczNjMjQxMF9zZXJpYWxfaW5pdCgpOwoJczNjMjQ0MF9zZXJpYWxfaW5pdCgpOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBfX2V4aXQgczNjMjR4eF9zZXJpYWxfbW9kZXhpdCh2b2lkKQp7CglzM2MyNDAwX3NlcmlhbF9leGl0KCk7CglzM2MyNDEwX3NlcmlhbF9leGl0KCk7CglzM2MyNDQwX3NlcmlhbF9leGl0KCk7CgoJdWFydF91bnJlZ2lzdGVyX2RyaXZlcigmczNjMjR4eF91YXJ0X2Rydik7Cn0KCgptb2R1bGVfaW5pdChzM2MyNHh4X3NlcmlhbF9tb2Rpbml0KTsKbW9kdWxlX2V4aXQoczNjMjR4eF9zZXJpYWxfbW9kZXhpdCk7CgovKiBDb25zb2xlIGNvZGUgKi8KCiNpZmRlZiBDT05GSUdfU0VSSUFMX1MzQzI0MTBfQ09OU09MRQoKc3RhdGljIHN0cnVjdCB1YXJ0X3BvcnQgKmNvbnNfdWFydDsKCnN0YXRpYyBpbnQKczNjMjR4eF9zZXJpYWxfY29uc29sZV90eHJkeShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQgdWZjb24pCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfaW5mbyAqaW5mbyA9IHMzYzI0eHhfcG9ydF90b19pbmZvKHBvcnQpOwoJdW5zaWduZWQgbG9uZyB1ZnN0YXQsIHV0cnN0YXQ7CgoJaWYgKHVmY29uICYgUzNDMjQxMF9VRkNPTl9GSUZPTU9ERSkgewoJCS8qIGZpZm8gbW9kZSAtIGNoZWNrIGFtbW91bnQgb2YgZGF0YSBpbiBmaWZvIHJlZ2lzdGVycy4uLiAqLwoKCQl1ZnN0YXQgPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUZTVEFUKTsKCQlyZXR1cm4gKHVmc3RhdCAmIGluZm8tPnR4X2ZpZm9mdWxsKSA/IDAgOiAxOwoJfQoKCS8qIGluIG5vbi1maWZvIG1vZGUsIHdlIGdvIGFuZCB1c2UgdGhlIHR4IGJ1ZmZlciBlbXB0eSAqLwoKCXV0cnN0YXQgPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVVRSU1RBVCk7CglyZXR1cm4gKHV0cnN0YXQgJiBTM0MyNDEwX1VUUlNUQVRfVFhFKSA/IDEgOiAwOwp9CgpzdGF0aWMgdm9pZApzM2MyNHh4X3NlcmlhbF9jb25zb2xlX3dyaXRlKHN0cnVjdCBjb25zb2xlICpjbywgY29uc3QgY2hhciAqcywKCQkJICAgICB1bnNpZ25lZCBpbnQgY291bnQpCnsKCWludCBpOwoJdW5zaWduZWQgaW50IHVmY29uID0gcmRfcmVnbChjb25zX3VhcnQsIFMzQzI0MTBfVUZDT04pOwoKCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CgkJd2hpbGUgKCFzM2MyNHh4X3NlcmlhbF9jb25zb2xlX3R4cmR5KGNvbnNfdWFydCwgdWZjb24pKQoJCQliYXJyaWVyKCk7CgoJCXdyX3JlZ2IoY29uc191YXJ0LCBTM0MyNDEwX1VUWEgsIHNbaV0pOwoKCQlpZiAoc1tpXSA9PSAnXG4nKSB7CgkJCXdoaWxlICghczNjMjR4eF9zZXJpYWxfY29uc29sZV90eHJkeShjb25zX3VhcnQsIHVmY29uKSkKCQkJCWJhcnJpZXIoKTsKCgkJCXdyX3JlZ2IoY29uc191YXJ0LCBTM0MyNDEwX1VUWEgsICdccicpOwoJCX0KCX0KfQoKc3RhdGljIHZvaWQgX19pbml0CnMzYzI0eHhfc2VyaWFsX2dldF9vcHRpb25zKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIGludCAqYmF1ZCwKCQkJICAgaW50ICpwYXJpdHksIGludCAqYml0cykKewoJc3RydWN0IHMzYzI0eHhfdWFydF9jbGtzcmMgY2xrc3JjOwoJc3RydWN0IGNsayAqY2xrOwoJdW5zaWduZWQgaW50IHVsY29uOwoJdW5zaWduZWQgaW50IHVjb247Cgl1bnNpZ25lZCBpbnQgdWJyZGl2OwoJdW5zaWduZWQgbG9uZyByYXRlOwoKCXVsY29uICA9IHJkX3JlZ2wocG9ydCwgUzNDMjQxMF9VTENPTik7Cgl1Y29uICAgPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUNPTik7Cgl1YnJkaXYgPSByZF9yZWdsKHBvcnQsIFMzQzI0MTBfVUJSRElWKTsKCglkYmcoInMzYzI0eHhfc2VyaWFsX2dldF9vcHRpb25zOiBwb3J0PSVwXG4iCgkgICAgInJlZ2lzdGVyczogdWxjb249JTA4eCwgdWNvbj0lMDh4LCB1YmRyaXY9JTA4eFxuIiwKCSAgICBwb3J0LCB1bGNvbiwgdWNvbiwgdWJyZGl2KTsKCglpZiAoKHVjb24gJiAweGYpICE9IDApIHsKCQkvKiBjb25zaWRlciB0aGUgc2VyaWFsIHBvcnQgY29uZmlndXJlZCBpZiB0aGUgdHgvcnggbW9kZSBzZXQgKi8KCgkJc3dpdGNoICh1bGNvbiAmIFMzQzI0MTBfTENPTl9DU01BU0spIHsKCQljYXNlIFMzQzI0MTBfTENPTl9DUzU6CgkJCSpiaXRzID0gNTsKCQkJYnJlYWs7CgkJY2FzZSBTM0MyNDEwX0xDT05fQ1M2OgoJCQkqYml0cyA9IDY7CgkJCWJyZWFrOwoJCWNhc2UgUzNDMjQxMF9MQ09OX0NTNzoKCQkJKmJpdHMgPSA3OwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCWNhc2UgUzNDMjQxMF9MQ09OX0NTODoKCQkJKmJpdHMgPSA4OwoJCQlicmVhazsKCQl9CgoJCXN3aXRjaCAodWxjb24gJiBTM0MyNDEwX0xDT05fUE1BU0spIHsKCQljYXNlIFMzQzI0MTBfTENPTl9QRVZFTjoKCQkJKnBhcml0eSA9ICdlJzsKCQkJYnJlYWs7CgoJCWNhc2UgUzNDMjQxMF9MQ09OX1BPREQ6CgkJCSpwYXJpdHkgPSAnbyc7CgkJCWJyZWFrOwoKCQljYXNlIFMzQzI0MTBfTENPTl9QTk9ORToKCQlkZWZhdWx0OgoJCQkqcGFyaXR5ID0gJ24nOwoJCX0KCgkJLyogbm93IGNhbGN1bGF0ZSB0aGUgYmF1ZCByYXRlICovCgoJCXMzYzI0eHhfc2VyaWFsX2dldHNvdXJjZShwb3J0LCAmY2xrc3JjKTsKCgkJY2xrID0gY2xrX2dldChwb3J0LT5kZXYsIGNsa3NyYy5uYW1lKTsKCQlpZiAoIUlTX0VSUihjbGspICYmIGNsayAhPSBOVUxMKQoJCQlyYXRlID0gY2xrX2dldF9yYXRlKGNsaykgLyBjbGtzcmMuZGl2aXNvcjsKCQllbHNlCgkJCXJhdGUgPSAxOwoKCgkJKmJhdWQgPSByYXRlIC8gKCAxNiAqICh1YnJkaXYgKyAxKSk7CgkJZGJnKCJjYWxjdWxhdGVkIGJhdWQgJWRcbiIsICpiYXVkKTsKCX0KCn0KCi8qIHMzYzI0eHhfc2VyaWFsX2luaXRfcG9ydHMKICoKICogaW5pdGlhbGlzZSB0aGUgc2VyaWFsIHBvcnRzIGZyb20gdGhlIG1hY2hpbmUgcHJvdmlkZWQgaW5pdGlhbGlzYXRpb24KICogZGF0YS4KKi8KCnN0YXRpYyBpbnQgczNjMjR4eF9zZXJpYWxfaW5pdF9wb3J0cyhzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKmluZm8pCnsKCXN0cnVjdCBzM2MyNHh4X3VhcnRfcG9ydCAqcHRyID0gczNjMjR4eF9zZXJpYWxfcG9ydHM7CglzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICoqcGxhdGRldl9wdHI7CglpbnQgaTsKCglkYmcoInMzYzI0eHhfc2VyaWFsX2luaXRfcG9ydHM6IGluaXRpYWxpc2luZyBwb3J0cy4uLlxuIik7CgoJcGxhdGRldl9wdHIgPSBzM2MyNHh4X3VhcnRfZGV2czsKCglmb3IgKGkgPSAwOyBpIDwgTlJfUE9SVFM7IGkrKywgcHRyKyssIHBsYXRkZXZfcHRyKyspIHsKCQlzM2MyNHh4X3NlcmlhbF9pbml0X3BvcnQocHRyLCBpbmZvLCAqcGxhdGRldl9wdHIpOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IF9faW5pdApzM2MyNHh4X3NlcmlhbF9jb25zb2xlX3NldHVwKHN0cnVjdCBjb25zb2xlICpjbywgY2hhciAqb3B0aW9ucykKewoJc3RydWN0IHVhcnRfcG9ydCAqcG9ydDsKCWludCBiYXVkID0gOTYwMDsKCWludCBiaXRzID0gODsKCWludCBwYXJpdHkgPSAnbic7CglpbnQgZmxvdyA9ICduJzsKCglkYmcoInMzYzI0eHhfc2VyaWFsX2NvbnNvbGVfc2V0dXA6IGNvPSVwICglZCksICVzXG4iLAoJICAgIGNvLCBjby0+aW5kZXgsIG9wdGlvbnMpOwoKCS8qIGlzIHRoaXMgYSB2YWxpZCBwb3J0ICovCgoJaWYgKGNvLT5pbmRleCA9PSAtMSB8fCBjby0+aW5kZXggPj0gTlJfUE9SVFMpCgkJY28tPmluZGV4ID0gMDsKCglwb3J0ID0gJnMzYzI0eHhfc2VyaWFsX3BvcnRzW2NvLT5pbmRleF0ucG9ydDsKCgkvKiBpcyB0aGUgcG9ydCBjb25maWd1cmVkPyAqLwoKCWlmIChwb3J0LT5tYXBiYXNlID09IDB4MCkgewoJCWNvLT5pbmRleCA9IDA7CgkJcG9ydCA9ICZzM2MyNHh4X3NlcmlhbF9wb3J0c1tjby0+aW5kZXhdLnBvcnQ7Cgl9CgoJY29uc191YXJ0ID0gcG9ydDsKCglkYmcoInMzYzI0eHhfc2VyaWFsX2NvbnNvbGVfc2V0dXA6IHBvcnQ9JXAgKCVkKVxuIiwgcG9ydCwgY28tPmluZGV4KTsKCgkvKgoJICogQ2hlY2sgd2hldGhlciBhbiBpbnZhbGlkIHVhcnQgbnVtYmVyIGhhcyBiZWVuIHNwZWNpZmllZCwgYW5kCgkgKiBpZiBzbywgc2VhcmNoIGZvciB0aGUgZmlyc3QgYXZhaWxhYmxlIHBvcnQgdGhhdCBkb2VzIGhhdmUKCSAqIGNvbnNvbGUgc3VwcG9ydC4KCSAqLwoJaWYgKG9wdGlvbnMpCgkJdWFydF9wYXJzZV9vcHRpb25zKG9wdGlvbnMsICZiYXVkLCAmcGFyaXR5LCAmYml0cywgJmZsb3cpOwoJZWxzZQoJCXMzYzI0eHhfc2VyaWFsX2dldF9vcHRpb25zKHBvcnQsICZiYXVkLCAmcGFyaXR5LCAmYml0cyk7CgoJZGJnKCJzM2MyNHh4X3NlcmlhbF9jb25zb2xlX3NldHVwOiBiYXVkICVkXG4iLCBiYXVkKTsKCglyZXR1cm4gdWFydF9zZXRfb3B0aW9ucyhwb3J0LCBjbywgYmF1ZCwgcGFyaXR5LCBiaXRzLCBmbG93KTsKfQoKLyogczNjMjR4eF9zZXJpYWxfaW5pdGNvbnNvbGUKICoKICogaW5pdGlhbGlzZSB0aGUgY29uc29sZSBmcm9tIG9uZSBvZiB0aGUgdWFydCBkcml2ZXJzCiovCgpzdGF0aWMgc3RydWN0IGNvbnNvbGUgczNjMjR4eF9zZXJpYWxfY29uc29sZSA9CnsKCS5uYW1lCQk9IFMzQzI0WFhfU0VSSUFMX05BTUUsCgkuZGV2aWNlCQk9IHVhcnRfY29uc29sZV9kZXZpY2UsCgkuZmxhZ3MJCT0gQ09OX1BSSU5UQlVGRkVSLAoJLmluZGV4CQk9IC0xLAoJLndyaXRlCQk9IHMzYzI0eHhfc2VyaWFsX2NvbnNvbGVfd3JpdGUsCgkuc2V0dXAJCT0gczNjMjR4eF9zZXJpYWxfY29uc29sZV9zZXR1cAp9OwoKc3RhdGljIGludCBzM2MyNHh4X3NlcmlhbF9pbml0Y29uc29sZSh2b2lkKQp7CglzdHJ1Y3QgczNjMjR4eF91YXJ0X2luZm8gKmluZm87CglzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkZXYgPSBzM2MyNHh4X3VhcnRfZGV2c1swXTsKCglkYmcoInMzYzI0eHhfc2VyaWFsX2luaXRjb25zb2xlXG4iKTsKCgkvKiBzZWxlY3QgZHJpdmVyIGJhc2VkIG9uIHRoZSBjcHUgKi8KCglpZiAoZGV2ID09IE5VTEwpIHsKCQlwcmludGsoS0VSTl9FUlIgInMzYzI0eHg6IG5vIGRldmljZXMgZm9yIGNvbnNvbGUgaW5pdFxuIik7CgkJcmV0dXJuIDA7Cgl9CgoJaWYgKHN0cmNtcChkZXYtPm5hbWUsICJzM2MyNDAwLXVhcnQiKSA9PSAwKSB7CgkJaW5mbyA9IHMzYzI0MDBfdWFydF9pbmZfYXQ7Cgl9IGVsc2UgaWYgKHN0cmNtcChkZXYtPm5hbWUsICJzM2MyNDEwLXVhcnQiKSA9PSAwKSB7CgkJaW5mbyA9IHMzYzI0MTBfdWFydF9pbmZfYXQ7Cgl9IGVsc2UgaWYgKHN0cmNtcChkZXYtPm5hbWUsICJzM2MyNDQwLXVhcnQiKSA9PSAwKSB7CgkJaW5mbyA9IHMzYzI0NDBfdWFydF9pbmZfYXQ7Cgl9IGVsc2UgewoJCXByaW50ayhLRVJOX0VSUiAiczNjMjR4eDogbm8gZHJpdmVyIGZvciAlc1xuIiwgZGV2LT5uYW1lKTsKCQlyZXR1cm4gMDsKCX0KCglpZiAoaW5mbyA9PSBOVUxMKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJzM2MyNHh4OiBubyBkcml2ZXIgZm9yIGNvbnNvbGVcbiIpOwoJCXJldHVybiAwOwoJfQoKCXMzYzI0eHhfc2VyaWFsX2NvbnNvbGUuZGF0YSA9ICZzM2MyNHh4X3VhcnRfZHJ2OwoJczNjMjR4eF9zZXJpYWxfaW5pdF9wb3J0cyhpbmZvKTsKCglyZWdpc3Rlcl9jb25zb2xlKCZzM2MyNHh4X3NlcmlhbF9jb25zb2xlKTsKCXJldHVybiAwOwp9Cgpjb25zb2xlX2luaXRjYWxsKHMzYzI0eHhfc2VyaWFsX2luaXRjb25zb2xlKTsKCiNlbmRpZiAvKiBDT05GSUdfU0VSSUFMX1MzQzI0MTBfQ09OU09MRSAqLwoKTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwpNT0RVTEVfQVVUSE9SKCJCZW4gRG9va3MgPGJlbkBzaW10ZWMuY28udWs+Iik7Ck1PRFVMRV9ERVNDUklQVElPTigiU2Ftc3VuZyBTM0MyNDEwL1MzQzI0NDAgU2VyaWFsIHBvcnQgZHJpdmVyIik7Cg==