LyoKICAgIHNpczU1OTUuYyAtIFBhcnQgb2YgbG1fc2Vuc29ycywgTGludXgga2VybmVsIG1vZHVsZXMKCQlmb3IgaGFyZHdhcmUgbW9uaXRvcmluZwoKICAgIENvcHlyaWdodCAoQykgMTk5OCAtIDIwMDEgRnJvZG8gTG9vaWphYXJkIDxmcm9kb2xAZGRzLm5sPiwKCQkJS3n2c3RpIE3kbGtraSA8a21hbGtraUBjYy5odXQuZmk+LCBhbmQKCQkJTWFyayBELiBTdHVkZWJha2VyIDxtZHN4eXoxMjNAeWFob28uY29tPgogICAgUG9ydGVkIHRvIExpbnV4IDIuNiBieSBBdXJlbGllbiBKYXJubyA8YXVyZWxpZW5AYXVyZWwzMi5uZXQ+IHdpdGgKICAgIHRoZSBoZWxwIG9mIEplYW4gRGVsdmFyZSA8a2hhbGlAbGludXgtZnIub3JnPgoKICAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQogICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCgogICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQogICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KCiAgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQogICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICAgIEZvdW5kYXRpb24sIEluYy4sIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgoqLwoKLyoKICAgU2lTIHNvdXRoYnJpZGdlIGhhcyBhIExNNzgtbGlrZSBjaGlwIGludGVncmF0ZWQgb24gdGhlIHNhbWUgSUMuCiAgIFRoaXMgZHJpdmVyIGlzIGEgY3VzdG9taXplZCBjb3B5IG9mIGxtNzguYwogICAKICAgU3VwcG9ydHMgZm9sbG93aW5nIHJldmlzaW9uczoKCVZlcnNpb24JCVBDSSBJRAkJUENJIFJldmlzaW9uCgkxCQkxMDM5LzAwMDgJQUYgb3IgbGVzcwoJMgkJMTAzOS8wMDA4CUIwIG9yIGdyZWF0ZXIKCiAgIE5vdGU6IHRoZXNlIGNoaXBzIGNvbnRhaW4gYSAwMDA4IGRldmljZSB3aGljaCBpcyBpbmNvbXBhdGlibGUgd2l0aCB0aGUKCSA1NTk1LiBXZSByZWNvZ25pemUgdGhlc2UgYnkgdGhlIHByZXNlbmNlIG9mIHRoZSBsaXN0ZWQKCSAiYmxhY2tsaXN0IiBQQ0kgSUQgYW5kIHJlZnVzZSB0byBsb2FkLgoKICAgTk9UIFNVUFBPUlRFRAlQQ0kgSUQJCUJMQUNLTElTVCBQQ0kgSUQJCgkgNTQwCQkwMDA4CQkwNTQwCgkgNTUwCQkwMDA4CQkwNTUwCgk1NTEzCQkwMDA4CQk1NTExCgk1NTgxCQkwMDA4CQk1NTk3Cgk1NTgyCQkwMDA4CQk1NTk3Cgk1NTk3CQkwMDA4CQk1NTk3Cgk1NTk4CQkwMDA4CQk1NTk3LzU1OTgKCSA2MzAJCTAwMDgJCTA2MzAKCSA2NDUJCTAwMDgJCTA2NDUKCSA3MzAJCTAwMDgJCTA3MzAKCSA3MzUJCTAwMDgJCTA3MzUKKi8KCiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgojaW5jbHVkZSA8bGludXgvcGNpLmg+CiNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2h3bW9uLmg+CiNpbmNsdWRlIDxsaW51eC9od21vbi1zeXNmcy5oPgojaW5jbHVkZSA8bGludXgvZXJyLmg+CiNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiNpbmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+CiNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgojaW5jbHVkZSA8bGludXgvc3lzZnMuaD4KI2luY2x1ZGUgPGFzbS9pby5oPgoKCi8qIElmIGZvcmNlX2FkZHIgaXMgc2V0IHRvIGFueXRoaW5nIGRpZmZlcmVudCBmcm9tIDAsIHdlIGZvcmNpYmx5IGVuYWJsZQogICB0aGUgZGV2aWNlIGF0IHRoZSBnaXZlbiBhZGRyZXNzLiAqLwpzdGF0aWMgdTE2IGZvcmNlX2FkZHI7Cm1vZHVsZV9wYXJhbShmb3JjZV9hZGRyLCB1c2hvcnQsIDApOwpNT0RVTEVfUEFSTV9ERVNDKGZvcmNlX2FkZHIsCgkJICJJbml0aWFsaXplIHRoZSBiYXNlIGFkZHJlc3Mgb2YgdGhlIHNlbnNvcnMiKTsKCnN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OwoKLyogTWFueSBTSVM1NTk1IGNvbnN0YW50cyBzcGVjaWZpZWQgYmVsb3cgKi8KCi8qIExlbmd0aCBvZiBJU0EgYWRkcmVzcyBzZWdtZW50ICovCiNkZWZpbmUgU0lTNTU5NV9FWFRFTlQgOAovKiBQQ0kgQ29uZmlnIFJlZ2lzdGVycyAqLwojZGVmaW5lIFNJUzU1OTVfQkFTRV9SRUcgMHg2OAojZGVmaW5lIFNJUzU1OTVfUElOX1JFRyAweDdBCiNkZWZpbmUgU0lTNTU5NV9FTkFCTEVfUkVHIDB4N0IKCi8qIFdoZXJlIGFyZSB0aGUgSVNBIGFkZHJlc3MvZGF0YSByZWdpc3RlcnMgcmVsYXRpdmUgdG8gdGhlIGJhc2UgYWRkcmVzcyAqLwojZGVmaW5lIFNJUzU1OTVfQUREUl9SRUdfT0ZGU0VUIDUKI2RlZmluZSBTSVM1NTk1X0RBVEFfUkVHX09GRlNFVCA2CgovKiBUaGUgU0lTNTU5NSByZWdpc3RlcnMgKi8KI2RlZmluZSBTSVM1NTk1X1JFR19JTl9NQVgobnIpICgweDJiICsgKG5yKSAqIDIpCiNkZWZpbmUgU0lTNTU5NV9SRUdfSU5fTUlOKG5yKSAoMHgyYyArIChucikgKiAyKQojZGVmaW5lIFNJUzU1OTVfUkVHX0lOKG5yKSAoMHgyMCArIChucikpCgojZGVmaW5lIFNJUzU1OTVfUkVHX0ZBTl9NSU4obnIpICgweDNiICsgKG5yKSkKI2RlZmluZSBTSVM1NTk1X1JFR19GQU4obnIpICgweDI4ICsgKG5yKSkKCi8qIE9uIHRoZSBmaXJzdCB2ZXJzaW9uIG9mIHRoZSBjaGlwLCB0aGUgdGVtcCByZWdpc3RlcnMgYXJlIHNlcGFyYXRlLgogICBPbiB0aGUgc2Vjb25kIHZlcnNpb24sCiAgIFRFTVAgcGluIGlzIHNoYXJlZCB3aXRoIElONCwgY29uZmlndXJlZCBpbiBQQ0kgcmVnaXN0ZXIgMHg3QS4KICAgVGhlIHJlZ2lzdGVycyBhcmUgdGhlIHNhbWUgYXMgd2VsbC4KICAgT1ZFUiBhbmQgSFlTVCBhcmUgcmVhbGx5IE1BWCBhbmQgTUlOLiAqLwoKI2RlZmluZSBSRVYyTUlOCTB4YjAKI2RlZmluZSBTSVM1NTk1X1JFR19URU1QIAkoKCBkYXRhLT5yZXZpc2lvbikgPj0gUkVWMk1JTikgPyBcCgkJCQkJU0lTNTU5NV9SRUdfSU4oNCkgOiAweDI3CiNkZWZpbmUgU0lTNTU5NV9SRUdfVEVNUF9PVkVSCSgoIGRhdGEtPnJldmlzaW9uKSA+PSBSRVYyTUlOKSA/IFwKCQkJCQlTSVM1NTk1X1JFR19JTl9NQVgoNCkgOiAweDM5CiNkZWZpbmUgU0lTNTU5NV9SRUdfVEVNUF9IWVNUCSgoIGRhdGEtPnJldmlzaW9uKSA+PSBSRVYyTUlOKSA/IFwKCQkJCQlTSVM1NTk1X1JFR19JTl9NSU4oNCkgOiAweDNhCgojZGVmaW5lIFNJUzU1OTVfUkVHX0NPTkZJRyAweDQwCiNkZWZpbmUgU0lTNTU5NV9SRUdfQUxBUk0xIDB4NDEKI2RlZmluZSBTSVM1NTk1X1JFR19BTEFSTTIgMHg0MgojZGVmaW5lIFNJUzU1OTVfUkVHX0ZBTkRJViAweDQ3CgovKiBDb252ZXJzaW9ucy4gTGltaXQgY2hlY2tpbmcgaXMgb25seSBkb25lIG9uIHRoZSBUT19SRUcKICAgdmFyaWFudHMuICovCgovKiBJTjogbVYsICgwViB0byA0LjA4VikKICAgUkVHOiAxNm1WL2JpdCAqLwpzdGF0aWMgaW5saW5lIHU4IElOX1RPX1JFRyh1bnNpZ25lZCBsb25nIHZhbCkKewoJdW5zaWduZWQgbG9uZyBudmFsID0gU0VOU09SU19MSU1JVCh2YWwsIDAsIDQwODApOwoJcmV0dXJuIChudmFsICsgOCkgLyAxNjsKfQojZGVmaW5lIElOX0ZST01fUkVHKHZhbCkgKCh2YWwpICogIDE2KQoKc3RhdGljIGlubGluZSB1OCBGQU5fVE9fUkVHKGxvbmcgcnBtLCBpbnQgZGl2KQp7CglpZiAocnBtIDw9IDApCgkJcmV0dXJuIDI1NTsKCXJldHVybiBTRU5TT1JTX0xJTUlUKCgxMzUwMDAwICsgcnBtICogZGl2IC8gMikgLyAocnBtICogZGl2KSwgMSwgMjU0KTsKfQoKc3RhdGljIGlubGluZSBpbnQgRkFOX0ZST01fUkVHKHU4IHZhbCwgaW50IGRpdikKewoJcmV0dXJuIHZhbD09MCA/IC0xIDogdmFsPT0yNTUgPyAwIDogMTM1MDAwMC8odmFsKmRpdik7Cn0KCi8qIFRFTVA6IG1DICgtNTQuMTJDIHRvICsxNTcuNTNDKQogICBSRUc6IDAuODNDL2JpdCArIDUyLjEyLCB0d28ncyBjb21wbGVtZW50ICAqLwpzdGF0aWMgaW5saW5lIGludCBURU1QX0ZST01fUkVHKHM4IHZhbCkKewoJcmV0dXJuIHZhbCAqIDgzMCArIDUyMTIwOwp9CnN0YXRpYyBpbmxpbmUgczggVEVNUF9UT19SRUcoaW50IHZhbCkKewoJaW50IG52YWwgPSBTRU5TT1JTX0xJTUlUKHZhbCwgLTU0MTIwLCAxNTc1MzApIDsKCXJldHVybiBudmFsPDAgPyAobnZhbC01MjEyLTQxNSkvODMwIDogKG52YWwtNTIxMis0MTUpLzgzMDsKfQoKLyogRkFOIERJVjogMSwgMiwgNCwgb3IgOCAoZGVmYXVsdHMgdG8gMikKICAgUkVHOiAwLCAxLCAyLCBvciAzIChyZXNwZWN0aXZlbHkpIChkZWZhdWx0cyB0byAxKSAqLwpzdGF0aWMgaW5saW5lIHU4IERJVl9UT19SRUcoaW50IHZhbCkKewoJcmV0dXJuIHZhbD09OCA/IDMgOiB2YWw9PTQgPyAyIDogdmFsPT0xID8gMCA6IDE7Cn0KI2RlZmluZSBESVZfRlJPTV9SRUcodmFsKSAoMSA8PCAodmFsKSkKCi8qIEZvciBlYWNoIHJlZ2lzdGVyZWQgY2hpcCwgd2UgbmVlZCB0byBrZWVwIHNvbWUgZGF0YSBpbiBtZW1vcnkuCiAgIFRoZSBzdHJ1Y3R1cmUgaXMgZHluYW1pY2FsbHkgYWxsb2NhdGVkLiAqLwpzdHJ1Y3Qgc2lzNTU5NV9kYXRhIHsKCXVuc2lnbmVkIHNob3J0IGFkZHI7Cgljb25zdCBjaGFyICpuYW1lOwoJc3RydWN0IGRldmljZSAqaHdtb25fZGV2OwoJc3RydWN0IG11dGV4IGxvY2s7CgoJc3RydWN0IG11dGV4IHVwZGF0ZV9sb2NrOwoJY2hhciB2YWxpZDsJCS8qICE9MCBpZiBmb2xsb3dpbmcgZmllbGRzIGFyZSB2YWxpZCAqLwoJdW5zaWduZWQgbG9uZyBsYXN0X3VwZGF0ZWQ7CS8qIEluIGppZmZpZXMgKi8KCWNoYXIgbWF4aW5zOwkJLyogPT0gMyBpZiB0ZW1wIGVuYWJsZWQsIG90aGVyd2lzZSA9PSA0ICovCgl1OCByZXZpc2lvbjsJCS8qIFJlZy4gdmFsdWUgKi8KCgl1OCBpbls1XTsJCS8qIFJlZ2lzdGVyIHZhbHVlICovCgl1OCBpbl9tYXhbNV07CQkvKiBSZWdpc3RlciB2YWx1ZSAqLwoJdTggaW5fbWluWzVdOwkJLyogUmVnaXN0ZXIgdmFsdWUgKi8KCXU4IGZhblsyXTsJCS8qIFJlZ2lzdGVyIHZhbHVlICovCgl1OCBmYW5fbWluWzJdOwkJLyogUmVnaXN0ZXIgdmFsdWUgKi8KCXM4IHRlbXA7CQkvKiBSZWdpc3RlciB2YWx1ZSAqLwoJczggdGVtcF9vdmVyOwkJLyogUmVnaXN0ZXIgdmFsdWUgKi8KCXM4IHRlbXBfaHlzdDsJCS8qIFJlZ2lzdGVyIHZhbHVlICovCgl1OCBmYW5fZGl2WzJdOwkJLyogUmVnaXN0ZXIgZW5jb2RpbmcsIHNoaWZ0ZWQgcmlnaHQgKi8KCXUxNiBhbGFybXM7CQkvKiBSZWdpc3RlciBlbmNvZGluZywgY29tYmluZWQgKi8KfTsKCnN0YXRpYyBzdHJ1Y3QgcGNpX2RldiAqc19icmlkZ2U7CS8qIHBvaW50ZXIgdG8gdGhlIChvbmx5KSBzaXM1NTk1ICovCgpzdGF0aWMgaW50IHNpczU1OTVfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldik7CnN0YXRpYyBpbnQgX19kZXZleGl0IHNpczU1OTVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpOwoKc3RhdGljIGludCBzaXM1NTk1X3JlYWRfdmFsdWUoc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSwgdTggcmVnKTsKc3RhdGljIHZvaWQgc2lzNTU5NV93cml0ZV92YWx1ZShzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhLCB1OCByZWcsIHU4IHZhbHVlKTsKc3RhdGljIHN0cnVjdCBzaXM1NTk1X2RhdGEgKnNpczU1OTVfdXBkYXRlX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYpOwpzdGF0aWMgdm9pZCBzaXM1NTk1X2luaXRfZGV2aWNlKHN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEpOwoKc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgc2lzNTU5NV9kcml2ZXIgPSB7CgkuZHJpdmVyID0gewoJCS5vd25lcgk9IFRISVNfTU9EVUxFLAoJCS5uYW1lCT0gInNpczU1OTUiLAoJfSwKCS5wcm9iZQkJPSBzaXM1NTk1X3Byb2JlLAoJLnJlbW92ZQkJPSBfX2RldmV4aXRfcChzaXM1NTk1X3JlbW92ZSksCn07CgovKiA0IFZvbHRhZ2VzICovCnN0YXRpYyBzc2l6ZV90IHNob3dfaW4oc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGEsCgkJICAgICAgIGNoYXIgKmJ1ZikKewoJc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSA9IHNpczU1OTVfdXBkYXRlX2RldmljZShkZXYpOwoJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRhKTsKCWludCBuciA9IGF0dHItPmluZGV4OwoJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIElOX0ZST01fUkVHKGRhdGEtPmluW25yXSkpOwp9CgpzdGF0aWMgc3NpemVfdCBzaG93X2luX21pbihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkYSwKCQkJICAgY2hhciAqYnVmKQp7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhID0gc2lzNTU5NV91cGRhdGVfZGV2aWNlKGRldik7CglzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKmF0dHIgPSB0b19zZW5zb3JfZGV2X2F0dHIoZGEpOwoJaW50IG5yID0gYXR0ci0+aW5kZXg7CglyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgSU5fRlJPTV9SRUcoZGF0YS0+aW5fbWluW25yXSkpOwp9CgpzdGF0aWMgc3NpemVfdCBzaG93X2luX21heChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkYSwKCQkJICAgY2hhciAqYnVmKQp7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhID0gc2lzNTU5NV91cGRhdGVfZGV2aWNlKGRldik7CglzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKmF0dHIgPSB0b19zZW5zb3JfZGV2X2F0dHIoZGEpOwoJaW50IG5yID0gYXR0ci0+aW5kZXg7CglyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgSU5fRlJPTV9SRUcoZGF0YS0+aW5fbWF4W25yXSkpOwp9CgpzdGF0aWMgc3NpemVfdCBzZXRfaW5fbWluKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRhLAoJCQkgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQp7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhID0gZGV2X2dldF9kcnZkYXRhKGRldik7CglzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKmF0dHIgPSB0b19zZW5zb3JfZGV2X2F0dHIoZGEpOwoJaW50IG5yID0gYXR0ci0+aW5kZXg7Cgl1bnNpZ25lZCBsb25nIHZhbCA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgTlVMTCwgMTApOwoKCW11dGV4X2xvY2soJmRhdGEtPnVwZGF0ZV9sb2NrKTsKCWRhdGEtPmluX21pbltucl0gPSBJTl9UT19SRUcodmFsKTsKCXNpczU1OTVfd3JpdGVfdmFsdWUoZGF0YSwgU0lTNTU5NV9SRUdfSU5fTUlOKG5yKSwgZGF0YS0+aW5fbWluW25yXSk7CgltdXRleF91bmxvY2soJmRhdGEtPnVwZGF0ZV9sb2NrKTsKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIHNzaXplX3Qgc2V0X2luX21heChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkYSwKCQkJICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKewoJc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwoJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRhKTsKCWludCBuciA9IGF0dHItPmluZGV4OwoJdW5zaWduZWQgbG9uZyB2YWwgPSBzaW1wbGVfc3RydG91bChidWYsIE5VTEwsIDEwKTsKCgltdXRleF9sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CglkYXRhLT5pbl9tYXhbbnJdID0gSU5fVE9fUkVHKHZhbCk7CglzaXM1NTk1X3dyaXRlX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0lOX01BWChuciksIGRhdGEtPmluX21heFtucl0pOwoJbXV0ZXhfdW5sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CglyZXR1cm4gY291bnQ7Cn0KCiNkZWZpbmUgc2hvd19pbl9vZmZzZXQob2Zmc2V0KQkJCQkJXApzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKGluIyNvZmZzZXQjI19pbnB1dCwgU19JUlVHTywJCVwKCQlzaG93X2luLCBOVUxMLCBvZmZzZXQpOwkJCQlcCnN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoaW4jI29mZnNldCMjX21pbiwgU19JUlVHTyB8IFNfSVdVU1IsCVwKCQlzaG93X2luX21pbiwgc2V0X2luX21pbiwgb2Zmc2V0KTsJCVwKc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihpbiMjb2Zmc2V0IyNfbWF4LCBTX0lSVUdPIHwgU19JV1VTUiwJXAoJCXNob3dfaW5fbWF4LCBzZXRfaW5fbWF4LCBvZmZzZXQpOwoKc2hvd19pbl9vZmZzZXQoMCk7CnNob3dfaW5fb2Zmc2V0KDEpOwpzaG93X2luX29mZnNldCgyKTsKc2hvd19pbl9vZmZzZXQoMyk7CnNob3dfaW5fb2Zmc2V0KDQpOwoKLyogVGVtcGVyYXR1cmUgKi8Kc3RhdGljIHNzaXplX3Qgc2hvd190ZW1wKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKewoJc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSA9IHNpczU1OTVfdXBkYXRlX2RldmljZShkZXYpOwoJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIFRFTVBfRlJPTV9SRUcoZGF0YS0+dGVtcCkpOwp9CgpzdGF0aWMgc3NpemVfdCBzaG93X3RlbXBfb3ZlcihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBzaXM1NTk1X3VwZGF0ZV9kZXZpY2UoZGV2KTsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBURU1QX0ZST01fUkVHKGRhdGEtPnRlbXBfb3ZlcikpOwp9CgpzdGF0aWMgc3NpemVfdCBzZXRfdGVtcF9vdmVyKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQp7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cglsb25nIHZhbCA9IHNpbXBsZV9zdHJ0b2woYnVmLCBOVUxMLCAxMCk7CgoJbXV0ZXhfbG9jaygmZGF0YS0+dXBkYXRlX2xvY2spOwoJZGF0YS0+dGVtcF9vdmVyID0gVEVNUF9UT19SRUcodmFsKTsKCXNpczU1OTVfd3JpdGVfdmFsdWUoZGF0YSwgU0lTNTU5NV9SRUdfVEVNUF9PVkVSLCBkYXRhLT50ZW1wX292ZXIpOwoJbXV0ZXhfdW5sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CglyZXR1cm4gY291bnQ7Cn0KCnN0YXRpYyBzc2l6ZV90IHNob3dfdGVtcF9oeXN0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKewoJc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSA9IHNpczU1OTVfdXBkYXRlX2RldmljZShkZXYpOwoJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIFRFTVBfRlJPTV9SRUcoZGF0YS0+dGVtcF9oeXN0KSk7Cn0KCnN0YXRpYyBzc2l6ZV90IHNldF90ZW1wX2h5c3Qoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKCWxvbmcgdmFsID0gc2ltcGxlX3N0cnRvbChidWYsIE5VTEwsIDEwKTsKCgltdXRleF9sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CglkYXRhLT50ZW1wX2h5c3QgPSBURU1QX1RPX1JFRyh2YWwpOwoJc2lzNTU5NV93cml0ZV92YWx1ZShkYXRhLCBTSVM1NTk1X1JFR19URU1QX0hZU1QsIGRhdGEtPnRlbXBfaHlzdCk7CgltdXRleF91bmxvY2soJmRhdGEtPnVwZGF0ZV9sb2NrKTsKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIERFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCBzaG93X3RlbXAsIE5VTEwpOwpzdGF0aWMgREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lSVUdPIHwgU19JV1VTUiwKCQlzaG93X3RlbXBfb3Zlciwgc2V0X3RlbXBfb3Zlcik7CnN0YXRpYyBERVZJQ0VfQVRUUih0ZW1wMV9tYXhfaHlzdCwgU19JUlVHTyB8IFNfSVdVU1IsCgkJc2hvd190ZW1wX2h5c3QsIHNldF90ZW1wX2h5c3QpOwoKLyogMiBGYW5zICovCnN0YXRpYyBzc2l6ZV90IHNob3dfZmFuKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRhLAoJCQljaGFyICpidWYpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBzaXM1NTk1X3VwZGF0ZV9kZXZpY2UoZGV2KTsKCXN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciA9IHRvX3NlbnNvcl9kZXZfYXR0cihkYSk7CglpbnQgbnIgPSBhdHRyLT5pbmRleDsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBGQU5fRlJPTV9SRUcoZGF0YS0+ZmFuW25yXSwKCQlESVZfRlJPTV9SRUcoZGF0YS0+ZmFuX2Rpdltucl0pKSApOwp9CgpzdGF0aWMgc3NpemVfdCBzaG93X2Zhbl9taW4oc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGEsCgkJCSAgICBjaGFyICpidWYpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBzaXM1NTk1X3VwZGF0ZV9kZXZpY2UoZGV2KTsKCXN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciA9IHRvX3NlbnNvcl9kZXZfYXR0cihkYSk7CglpbnQgbnIgPSBhdHRyLT5pbmRleDsKCXJldHVybiBzcHJpbnRmKGJ1ZiwiJWRcbiIsIEZBTl9GUk9NX1JFRyhkYXRhLT5mYW5fbWluW25yXSwKCQlESVZfRlJPTV9SRUcoZGF0YS0+ZmFuX2Rpdltucl0pKSApOwp9CgpzdGF0aWMgc3NpemVfdCBzZXRfZmFuX21pbihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkYSwKCQkJICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKCXN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciA9IHRvX3NlbnNvcl9kZXZfYXR0cihkYSk7CglpbnQgbnIgPSBhdHRyLT5pbmRleDsKCXVuc2lnbmVkIGxvbmcgdmFsID0gc2ltcGxlX3N0cnRvdWwoYnVmLCBOVUxMLCAxMCk7CgoJbXV0ZXhfbG9jaygmZGF0YS0+dXBkYXRlX2xvY2spOwoJZGF0YS0+ZmFuX21pbltucl0gPSBGQU5fVE9fUkVHKHZhbCwgRElWX0ZST01fUkVHKGRhdGEtPmZhbl9kaXZbbnJdKSk7CglzaXM1NTk1X3dyaXRlX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0ZBTl9NSU4obnIpLCBkYXRhLT5mYW5fbWluW25yXSk7CgltdXRleF91bmxvY2soJmRhdGEtPnVwZGF0ZV9sb2NrKTsKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIHNzaXplX3Qgc2hvd19mYW5fZGl2KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRhLAoJCQkgICAgY2hhciAqYnVmKQp7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhID0gc2lzNTU5NV91cGRhdGVfZGV2aWNlKGRldik7CglzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKmF0dHIgPSB0b19zZW5zb3JfZGV2X2F0dHIoZGEpOwoJaW50IG5yID0gYXR0ci0+aW5kZXg7CglyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgRElWX0ZST01fUkVHKGRhdGEtPmZhbl9kaXZbbnJdKSApOwp9CgovKiBOb3RlOiB3ZSBzYXZlIGFuZCByZXN0b3JlIHRoZSBmYW4gbWluaW11bSBoZXJlLCBiZWNhdXNlIGl0cyB2YWx1ZSBpcwogICBkZXRlcm1pbmVkIGluIHBhcnQgYnkgdGhlIGZhbiBkaXZpc29yLiAgVGhpcyBmb2xsb3dzIHRoZSBwcmluY2lwbGUgb2YKICAgbGVhc3Qgc3VycHJpc2U7IHRoZSB1c2VyIGRvZXNuJ3QgZXhwZWN0IHRoZSBmYW4gbWluaW11bSB0byBjaGFuZ2UganVzdAogICBiZWNhdXNlIHRoZSBkaXZpc29yIGNoYW5nZWQuICovCnN0YXRpYyBzc2l6ZV90IHNldF9mYW5fZGl2KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRhLAoJCQkgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKewoJc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwoJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRhKTsKCWludCBuciA9IGF0dHItPmluZGV4OwoJdW5zaWduZWQgbG9uZyBtaW47Cgl1bnNpZ25lZCBsb25nIHZhbCA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgTlVMTCwgMTApOwoJaW50IHJlZzsKCgltdXRleF9sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CgltaW4gPSBGQU5fRlJPTV9SRUcoZGF0YS0+ZmFuX21pbltucl0sCgkJCURJVl9GUk9NX1JFRyhkYXRhLT5mYW5fZGl2W25yXSkpOwoJcmVnID0gc2lzNTU5NV9yZWFkX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0ZBTkRJVik7CgoJc3dpdGNoICh2YWwpIHsKCWNhc2UgMTogZGF0YS0+ZmFuX2Rpdltucl0gPSAwOyBicmVhazsKCWNhc2UgMjogZGF0YS0+ZmFuX2Rpdltucl0gPSAxOyBicmVhazsKCWNhc2UgNDogZGF0YS0+ZmFuX2Rpdltucl0gPSAyOyBicmVhazsKCWNhc2UgODogZGF0YS0+ZmFuX2Rpdltucl0gPSAzOyBicmVhazsKCWRlZmF1bHQ6CgkJZGV2X2VycihkZXYsICJmYW5fZGl2IHZhbHVlICVsZCBub3QgIgoJCQkic3VwcG9ydGVkLiBDaG9vc2Ugb25lIG9mIDEsIDIsIDQgb3IgOCFcbiIsIHZhbCk7CgkJbXV0ZXhfdW5sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgkKCXN3aXRjaCAobnIpIHsKCWNhc2UgMDoKCQlyZWcgPSAocmVnICYgMHhjZikgfCAoZGF0YS0+ZmFuX2Rpdltucl0gPDwgNCk7CgkJYnJlYWs7CgljYXNlIDE6CgkJcmVnID0gKHJlZyAmIDB4M2YpIHwgKGRhdGEtPmZhbl9kaXZbbnJdIDw8IDYpOwoJCWJyZWFrOwoJfQoJc2lzNTU5NV93cml0ZV92YWx1ZShkYXRhLCBTSVM1NTk1X1JFR19GQU5ESVYsIHJlZyk7CglkYXRhLT5mYW5fbWluW25yXSA9CgkJRkFOX1RPX1JFRyhtaW4sIERJVl9GUk9NX1JFRyhkYXRhLT5mYW5fZGl2W25yXSkpOwoJc2lzNTU5NV93cml0ZV92YWx1ZShkYXRhLCBTSVM1NTk1X1JFR19GQU5fTUlOKG5yKSwgZGF0YS0+ZmFuX21pbltucl0pOwoJbXV0ZXhfdW5sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CglyZXR1cm4gY291bnQ7Cn0KCiNkZWZpbmUgc2hvd19mYW5fb2Zmc2V0KG9mZnNldCkJCQkJCQlcCnN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuIyNvZmZzZXQjI19pbnB1dCwgU19JUlVHTywJCQlcCgkJc2hvd19mYW4sIE5VTEwsIG9mZnNldCAtIDEpOwkJCQlcCnN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIoZmFuIyNvZmZzZXQjI19taW4sIFNfSVJVR08gfCBTX0lXVVNSLAkJXAoJCXNob3dfZmFuX21pbiwgc2V0X2Zhbl9taW4sIG9mZnNldCAtIDEpOwkJCVwKc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUihmYW4jI29mZnNldCMjX2RpdiwgU19JUlVHTyB8IFNfSVdVU1IsCQlcCgkJc2hvd19mYW5fZGl2LCBzZXRfZmFuX2Rpdiwgb2Zmc2V0IC0gMSk7CgpzaG93X2Zhbl9vZmZzZXQoMSk7CnNob3dfZmFuX29mZnNldCgyKTsKCi8qIEFsYXJtcyAqLwpzdGF0aWMgc3NpemVfdCBzaG93X2FsYXJtcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBzaXM1NTk1X3VwZGF0ZV9kZXZpY2UoZGV2KTsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBkYXRhLT5hbGFybXMpOwp9CnN0YXRpYyBERVZJQ0VfQVRUUihhbGFybXMsIFNfSVJVR08sIHNob3dfYWxhcm1zLCBOVUxMKTsKCnN0YXRpYyBzc2l6ZV90IHNob3dfbmFtZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAoJCQkgY2hhciAqYnVmKQp7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhID0gZGV2X2dldF9kcnZkYXRhKGRldik7CglyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwgZGF0YS0+bmFtZSk7Cn0Kc3RhdGljIERFVklDRV9BVFRSKG5hbWUsIFNfSVJVR08sIHNob3dfbmFtZSwgTlVMTCk7CgpzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqc2lzNTU5NV9hdHRyaWJ1dGVzW10gPSB7Cgkmc2Vuc29yX2Rldl9hdHRyX2luMF9pbnB1dC5kZXZfYXR0ci5hdHRyLAoJJnNlbnNvcl9kZXZfYXR0cl9pbjBfbWluLmRldl9hdHRyLmF0dHIsCgkmc2Vuc29yX2Rldl9hdHRyX2luMF9tYXguZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfaW4xX2lucHV0LmRldl9hdHRyLmF0dHIsCgkmc2Vuc29yX2Rldl9hdHRyX2luMV9taW4uZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfaW4xX21heC5kZXZfYXR0ci5hdHRyLAoJJnNlbnNvcl9kZXZfYXR0cl9pbjJfaW5wdXQuZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfaW4yX21pbi5kZXZfYXR0ci5hdHRyLAoJJnNlbnNvcl9kZXZfYXR0cl9pbjJfbWF4LmRldl9hdHRyLmF0dHIsCgkmc2Vuc29yX2Rldl9hdHRyX2luM19pbnB1dC5kZXZfYXR0ci5hdHRyLAoJJnNlbnNvcl9kZXZfYXR0cl9pbjNfbWluLmRldl9hdHRyLmF0dHIsCgkmc2Vuc29yX2Rldl9hdHRyX2luM19tYXguZGV2X2F0dHIuYXR0ciwKCgkmc2Vuc29yX2Rldl9hdHRyX2ZhbjFfaW5wdXQuZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfZmFuMV9taW4uZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfZmFuMV9kaXYuZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfZmFuMl9pbnB1dC5kZXZfYXR0ci5hdHRyLAoJJnNlbnNvcl9kZXZfYXR0cl9mYW4yX21pbi5kZXZfYXR0ci5hdHRyLAoJJnNlbnNvcl9kZXZfYXR0cl9mYW4yX2Rpdi5kZXZfYXR0ci5hdHRyLAoKCSZkZXZfYXR0cl9hbGFybXMuYXR0ciwKCSZkZXZfYXR0cl9uYW1lLmF0dHIsCglOVUxMCn07CgpzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBzaXM1NTk1X2dyb3VwID0gewoJLmF0dHJzID0gc2lzNTU5NV9hdHRyaWJ1dGVzLAp9OwoKc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnNpczU1OTVfYXR0cmlidXRlc19vcHRbXSA9IHsKCSZzZW5zb3JfZGV2X2F0dHJfaW40X2lucHV0LmRldl9hdHRyLmF0dHIsCgkmc2Vuc29yX2Rldl9hdHRyX2luNF9taW4uZGV2X2F0dHIuYXR0ciwKCSZzZW5zb3JfZGV2X2F0dHJfaW40X21heC5kZXZfYXR0ci5hdHRyLAoKCSZkZXZfYXR0cl90ZW1wMV9pbnB1dC5hdHRyLAoJJmRldl9hdHRyX3RlbXAxX21heC5hdHRyLAoJJmRldl9hdHRyX3RlbXAxX21heF9oeXN0LmF0dHIsCglOVUxMCn07CgpzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBzaXM1NTk1X2dyb3VwX29wdCA9IHsKCS5hdHRycyA9IHNpczU1OTVfYXR0cmlidXRlc19vcHQsCn07CiAKLyogVGhpcyBpcyBjYWxsZWQgd2hlbiB0aGUgbW9kdWxlIGlzIGxvYWRlZCAqLwpzdGF0aWMgaW50IF9fZGV2aW5pdCBzaXM1NTk1X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCnsKCWludCBlcnIgPSAwOwoJaW50IGk7CglzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhOwoJc3RydWN0IHJlc291cmNlICpyZXM7CgljaGFyIHZhbDsKCgkvKiBSZXNlcnZlIHRoZSBJU0EgcmVnaW9uICovCglyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9JTywgMCk7CglpZiAoIXJlcXVlc3RfcmVnaW9uKHJlcy0+c3RhcnQsIFNJUzU1OTVfRVhURU5ULAoJCQkgICAgc2lzNTU5NV9kcml2ZXIuZHJpdmVyLm5hbWUpKSB7CgkJZXJyID0gLUVCVVNZOwoJCWdvdG8gZXhpdDsKCX0KCglpZiAoIShkYXRhID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNpczU1OTVfZGF0YSksIEdGUF9LRVJORUwpKSkgewoJCWVyciA9IC1FTk9NRU07CgkJZ290byBleGl0X3JlbGVhc2U7Cgl9CgoJbXV0ZXhfaW5pdCgmZGF0YS0+bG9jayk7CgltdXRleF9pbml0KCZkYXRhLT51cGRhdGVfbG9jayk7CglkYXRhLT5hZGRyID0gcmVzLT5zdGFydDsKCWRhdGEtPm5hbWUgPSAic2lzNTU5NSI7CglwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYXRhKTsKCgkvKiBDaGVjayByZXZpc2lvbiBhbmQgcGluIHJlZ2lzdGVycyB0byBkZXRlcm1pbmUgd2hldGhlciA0IG9yIDUgdm9sdGFnZXMgKi8KCWRhdGEtPnJldmlzaW9uID0gc19icmlkZ2UtPnJldmlzaW9uOwoJLyogNCB2b2x0YWdlcywgMSB0ZW1wICovCglkYXRhLT5tYXhpbnMgPSAzOwoJaWYgKGRhdGEtPnJldmlzaW9uID49IFJFVjJNSU4pIHsKCQlwY2lfcmVhZF9jb25maWdfYnl0ZShzX2JyaWRnZSwgU0lTNTU5NV9QSU5fUkVHLCAmdmFsKTsKCQlpZiAoISh2YWwgJiAweDgwKSkKCQkJLyogNSB2b2x0YWdlcywgbm8gdGVtcHMgKi8KCQkJZGF0YS0+bWF4aW5zID0gNDsKCX0KCQoJLyogSW5pdGlhbGl6ZSB0aGUgU0lTNTU5NSBjaGlwICovCglzaXM1NTk1X2luaXRfZGV2aWNlKGRhdGEpOwoKCS8qIEEgZmV3IHZhcnMgbmVlZCB0byBiZSBmaWxsZWQgdXBvbiBzdGFydHVwICovCglmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CgkJZGF0YS0+ZmFuX21pbltpXSA9IHNpczU1OTVfcmVhZF92YWx1ZShkYXRhLAoJCQkJCVNJUzU1OTVfUkVHX0ZBTl9NSU4oaSkpOwoJfQoKCS8qIFJlZ2lzdGVyIHN5c2ZzIGhvb2tzICovCglpZiAoKGVyciA9IHN5c2ZzX2NyZWF0ZV9ncm91cCgmcGRldi0+ZGV2LmtvYmosICZzaXM1NTk1X2dyb3VwKSkpCgkJZ290byBleGl0X2ZyZWU7CglpZiAoZGF0YS0+bWF4aW5zID09IDQpIHsKCQlpZiAoKGVyciA9IGRldmljZV9jcmVhdGVfZmlsZSgmcGRldi0+ZGV2LAoJCQkJCSZzZW5zb3JfZGV2X2F0dHJfaW40X2lucHV0LmRldl9hdHRyKSkKCQkgfHwgKGVyciA9IGRldmljZV9jcmVhdGVfZmlsZSgmcGRldi0+ZGV2LAoJCQkJCSZzZW5zb3JfZGV2X2F0dHJfaW40X21pbi5kZXZfYXR0cikpCgkJIHx8IChlcnIgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnBkZXYtPmRldiwKCQkJCQkmc2Vuc29yX2Rldl9hdHRyX2luNF9tYXguZGV2X2F0dHIpKSkKCQkJZ290byBleGl0X3JlbW92ZV9maWxlczsKCX0gZWxzZSB7CgkJaWYgKChlcnIgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnBkZXYtPmRldiwKCQkJCQkgICAgICAmZGV2X2F0dHJfdGVtcDFfaW5wdXQpKQoJCSB8fCAoZXJyID0gZGV2aWNlX2NyZWF0ZV9maWxlKCZwZGV2LT5kZXYsCgkJCQkJICAgICAgJmRldl9hdHRyX3RlbXAxX21heCkpCgkJIHx8IChlcnIgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnBkZXYtPmRldiwKCQkJCQkgICAgICAmZGV2X2F0dHJfdGVtcDFfbWF4X2h5c3QpKSkKCQkJZ290byBleGl0X3JlbW92ZV9maWxlczsKCX0KCglkYXRhLT5od21vbl9kZXYgPSBod21vbl9kZXZpY2VfcmVnaXN0ZXIoJnBkZXYtPmRldik7CglpZiAoSVNfRVJSKGRhdGEtPmh3bW9uX2RldikpIHsKCQllcnIgPSBQVFJfRVJSKGRhdGEtPmh3bW9uX2Rldik7CgkJZ290byBleGl0X3JlbW92ZV9maWxlczsKCX0KCglyZXR1cm4gMDsKCmV4aXRfcmVtb3ZlX2ZpbGVzOgoJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJnNpczU1OTVfZ3JvdXApOwoJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJnNpczU1OTVfZ3JvdXBfb3B0KTsKZXhpdF9mcmVlOgoJa2ZyZWUoZGF0YSk7CmV4aXRfcmVsZWFzZToKCXJlbGVhc2VfcmVnaW9uKHJlcy0+c3RhcnQsIFNJUzU1OTVfRVhURU5UKTsKZXhpdDoKCXJldHVybiBlcnI7Cn0KCnN0YXRpYyBpbnQgX19kZXZleGl0IHNpczU1OTVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCnsKCXN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKCglod21vbl9kZXZpY2VfdW5yZWdpc3RlcihkYXRhLT5od21vbl9kZXYpOwoJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJnNpczU1OTVfZ3JvdXApOwoJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJnNpczU1OTVfZ3JvdXBfb3B0KTsKCglyZWxlYXNlX3JlZ2lvbihkYXRhLT5hZGRyLCBTSVM1NTk1X0VYVEVOVCk7CglwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKCWtmcmVlKGRhdGEpOwoKCXJldHVybiAwOwp9CgoKLyogSVNBIGFjY2VzcyBtdXN0IGJlIGxvY2tlZCBleHBsaWNpdGx5LiAqLwpzdGF0aWMgaW50IHNpczU1OTVfcmVhZF92YWx1ZShzdHJ1Y3Qgc2lzNTU5NV9kYXRhICpkYXRhLCB1OCByZWcpCnsKCWludCByZXM7CgoJbXV0ZXhfbG9jaygmZGF0YS0+bG9jayk7CglvdXRiX3AocmVnLCBkYXRhLT5hZGRyICsgU0lTNTU5NV9BRERSX1JFR19PRkZTRVQpOwoJcmVzID0gaW5iX3AoZGF0YS0+YWRkciArIFNJUzU1OTVfREFUQV9SRUdfT0ZGU0VUKTsKCW11dGV4X3VubG9jaygmZGF0YS0+bG9jayk7CglyZXR1cm4gcmVzOwp9CgpzdGF0aWMgdm9pZCBzaXM1NTk1X3dyaXRlX3ZhbHVlKHN0cnVjdCBzaXM1NTk1X2RhdGEgKmRhdGEsIHU4IHJlZywgdTggdmFsdWUpCnsKCW11dGV4X2xvY2soJmRhdGEtPmxvY2spOwoJb3V0Yl9wKHJlZywgZGF0YS0+YWRkciArIFNJUzU1OTVfQUREUl9SRUdfT0ZGU0VUKTsKCW91dGJfcCh2YWx1ZSwgZGF0YS0+YWRkciArIFNJUzU1OTVfREFUQV9SRUdfT0ZGU0VUKTsKCW11dGV4X3VubG9jaygmZGF0YS0+bG9jayk7Cn0KCi8qIENhbGxlZCB3aGVuIHdlIGhhdmUgZm91bmQgYSBuZXcgU0lTNTU5NS4gKi8Kc3RhdGljIHZvaWQgX19kZXZpbml0IHNpczU1OTVfaW5pdF9kZXZpY2Uoc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSkKewoJdTggY29uZmlnID0gc2lzNTU5NV9yZWFkX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0NPTkZJRyk7CglpZiAoIShjb25maWcgJiAweDAxKSkKCQlzaXM1NTk1X3dyaXRlX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0NPTkZJRywKCQkJCShjb25maWcgJiAweGY3KSB8IDB4MDEpOwp9CgpzdGF0aWMgc3RydWN0IHNpczU1OTVfZGF0YSAqc2lzNTU5NV91cGRhdGVfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldikKewoJc3RydWN0IHNpczU1OTVfZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwoJaW50IGk7CgoJbXV0ZXhfbG9jaygmZGF0YS0+dXBkYXRlX2xvY2spOwoKCWlmICh0aW1lX2FmdGVyKGppZmZpZXMsIGRhdGEtPmxhc3RfdXBkYXRlZCArIEhaICsgSFogLyAyKQoJICAgIHx8ICFkYXRhLT52YWxpZCkgewoKCQlmb3IgKGkgPSAwOyBpIDw9IGRhdGEtPm1heGluczsgaSsrKSB7CgkJCWRhdGEtPmluW2ldID0KCQkJICAgIHNpczU1OTVfcmVhZF92YWx1ZShkYXRhLCBTSVM1NTk1X1JFR19JTihpKSk7CgkJCWRhdGEtPmluX21pbltpXSA9CgkJCSAgICBzaXM1NTk1X3JlYWRfdmFsdWUoZGF0YSwKCQkJCQkgICAgICAgU0lTNTU5NV9SRUdfSU5fTUlOKGkpKTsKCQkJZGF0YS0+aW5fbWF4W2ldID0KCQkJICAgIHNpczU1OTVfcmVhZF92YWx1ZShkYXRhLAoJCQkJCSAgICAgICBTSVM1NTk1X1JFR19JTl9NQVgoaSkpOwoJCX0KCQlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CgkJCWRhdGEtPmZhbltpXSA9CgkJCSAgICBzaXM1NTk1X3JlYWRfdmFsdWUoZGF0YSwgU0lTNTU5NV9SRUdfRkFOKGkpKTsKCQkJZGF0YS0+ZmFuX21pbltpXSA9CgkJCSAgICBzaXM1NTk1X3JlYWRfdmFsdWUoZGF0YSwKCQkJCQkgICAgICAgU0lTNTU5NV9SRUdfRkFOX01JTihpKSk7CgkJfQoJCWlmIChkYXRhLT5tYXhpbnMgPT0gMykgewoJCQlkYXRhLT50ZW1wID0KCQkJICAgIHNpczU1OTVfcmVhZF92YWx1ZShkYXRhLCBTSVM1NTk1X1JFR19URU1QKTsKCQkJZGF0YS0+dGVtcF9vdmVyID0KCQkJICAgIHNpczU1OTVfcmVhZF92YWx1ZShkYXRhLCBTSVM1NTk1X1JFR19URU1QX09WRVIpOwoJCQlkYXRhLT50ZW1wX2h5c3QgPQoJCQkgICAgc2lzNTU5NV9yZWFkX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX1RFTVBfSFlTVCk7CgkJfQoJCWkgPSBzaXM1NTk1X3JlYWRfdmFsdWUoZGF0YSwgU0lTNTU5NV9SRUdfRkFORElWKTsKCQlkYXRhLT5mYW5fZGl2WzBdID0gKGkgPj4gNCkgJiAweDAzOwoJCWRhdGEtPmZhbl9kaXZbMV0gPSBpID4+IDY7CgkJZGF0YS0+YWxhcm1zID0KCQkgICAgc2lzNTU5NV9yZWFkX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0FMQVJNMSkgfAoJCSAgICAoc2lzNTU5NV9yZWFkX3ZhbHVlKGRhdGEsIFNJUzU1OTVfUkVHX0FMQVJNMikgPDwgOCk7CgkJZGF0YS0+bGFzdF91cGRhdGVkID0gamlmZmllczsKCQlkYXRhLT52YWxpZCA9IDE7Cgl9CgoJbXV0ZXhfdW5sb2NrKCZkYXRhLT51cGRhdGVfbG9jayk7CgoJcmV0dXJuIGRhdGE7Cn0KCnN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBzaXM1NTk1X3BjaV9pZHNbXSA9IHsKCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX1NJLCBQQ0lfREVWSUNFX0lEX1NJXzUwMykgfSwKCXsgMCwgfQp9OwoKTU9EVUxFX0RFVklDRV9UQUJMRShwY2ksIHNpczU1OTVfcGNpX2lkcyk7CgpzdGF0aWMgaW50IGJsYWNrbGlzdFtdIF9fZGV2aW5pdGRhdGEgPSB7CglQQ0lfREVWSUNFX0lEX1NJXzU0MCwKCVBDSV9ERVZJQ0VfSURfU0lfNTUwLAoJUENJX0RFVklDRV9JRF9TSV82MzAsCglQQ0lfREVWSUNFX0lEX1NJXzY0NSwKCVBDSV9ERVZJQ0VfSURfU0lfNzMwLAoJUENJX0RFVklDRV9JRF9TSV83MzUsCglQQ0lfREVWSUNFX0lEX1NJXzU1MTEsIC8qIDU1MTMgY2hpcCBoYXMgdGhlIDAwMDggZGV2aWNlIGJ1dAoJCQkJICB0aGF0IElEIHNob3dzIHVwIGluIG90aGVyIGNoaXBzIHNvIHdlCgkJCQkgIHVzZSB0aGUgNTUxMSBJRCBmb3IgcmVjb2duaXRpb24gKi8KCVBDSV9ERVZJQ0VfSURfU0lfNTU5NywKCVBDSV9ERVZJQ0VfSURfU0lfNTU5OCwKCTAgfTsKCnN0YXRpYyBpbnQgX19kZXZpbml0IHNpczU1OTVfZGV2aWNlX2FkZCh1bnNpZ25lZCBzaG9ydCBhZGRyZXNzKQp7CglzdHJ1Y3QgcmVzb3VyY2UgcmVzID0gewoJCS5zdGFydAk9IGFkZHJlc3MsCgkJLmVuZAk9IGFkZHJlc3MgKyBTSVM1NTk1X0VYVEVOVCAtIDEsCgkJLm5hbWUJPSAic2lzNTU5NSIsCgkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JTywKCX07CglpbnQgZXJyOwoKCXBkZXYgPSBwbGF0Zm9ybV9kZXZpY2VfYWxsb2MoInNpczU1OTUiLCBhZGRyZXNzKTsKCWlmICghcGRldikgewoJCWVyciA9IC1FTk9NRU07CgkJcHJpbnRrKEtFUk5fRVJSICJzaXM1NTk1OiBEZXZpY2UgYWxsb2NhdGlvbiBmYWlsZWRcbiIpOwoJCWdvdG8gZXhpdDsKCX0KCgllcnIgPSBwbGF0Zm9ybV9kZXZpY2VfYWRkX3Jlc291cmNlcyhwZGV2LCAmcmVzLCAxKTsKCWlmIChlcnIpIHsKCQlwcmludGsoS0VSTl9FUlIgInNpczU1OTU6IERldmljZSByZXNvdXJjZSBhZGRpdGlvbiBmYWlsZWQgIgoJCSAgICAgICAiKCVkKVxuIiwgZXJyKTsKCQlnb3RvIGV4aXRfZGV2aWNlX3B1dDsKCX0KCgllcnIgPSBwbGF0Zm9ybV9kZXZpY2VfYWRkKHBkZXYpOwoJaWYgKGVycikgewoJCXByaW50ayhLRVJOX0VSUiAic2lzNTU5NTogRGV2aWNlIGFkZGl0aW9uIGZhaWxlZCAoJWQpXG4iLAoJCSAgICAgICBlcnIpOwoJCWdvdG8gZXhpdF9kZXZpY2VfcHV0OwoJfQoKCXJldHVybiAwOwoKZXhpdF9kZXZpY2VfcHV0OgoJcGxhdGZvcm1fZGV2aWNlX3B1dChwZGV2KTsKZXhpdDoKCXJldHVybiBlcnI7Cn0KCnN0YXRpYyBpbnQgX19kZXZpbml0IHNpczU1OTVfcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpkZXYsCgkJCQkgICAgICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQp7Cgl1MTYgYWRkcmVzczsKCXU4IGVuYWJsZTsKCWludCAqaTsKCglmb3IgKGkgPSBibGFja2xpc3Q7ICppICE9IDA7IGkrKykgewoJCXN0cnVjdCBwY2lfZGV2ICpkOwoJCWlmICgoZCA9IHBjaV9nZXRfZGV2aWNlKFBDSV9WRU5ET1JfSURfU0ksICppLCBOVUxMKSkpIHsKCQkJZGV2X2VycigmZC0+ZGV2LCAiTG9va2VkIGZvciBTSVM1NTk1IGJ1dCBmb3VuZCB1bnN1cHBvcnRlZCBkZXZpY2UgJS40eFxuIiwgKmkpOwoJCQlwY2lfZGV2X3B1dChkKTsKCQkJcmV0dXJuIC1FTk9ERVY7CgkJfQoJfQoJCglmb3JjZV9hZGRyICY9IH4oU0lTNTU5NV9FWFRFTlQgLSAxKTsKCWlmIChmb3JjZV9hZGRyKSB7CgkJZGV2X3dhcm4oJmRldi0+ZGV2LCAiRm9yY2luZyBJU0EgYWRkcmVzcyAweCV4XG4iLCBmb3JjZV9hZGRyKTsKCQlwY2lfd3JpdGVfY29uZmlnX3dvcmQoZGV2LCBTSVM1NTk1X0JBU0VfUkVHLCBmb3JjZV9hZGRyKTsKCX0KCglpZiAoUENJQklPU19TVUNDRVNTRlVMICE9CgkgICAgcGNpX3JlYWRfY29uZmlnX3dvcmQoZGV2LCBTSVM1NTk1X0JBU0VfUkVHLCAmYWRkcmVzcykpIHsKCQlkZXZfZXJyKCZkZXYtPmRldiwgIkZhaWxlZCB0byByZWFkIElTQSBhZGRyZXNzXG4iKTsKCQlyZXR1cm4gLUVOT0RFVjsKCX0KCQoJYWRkcmVzcyAmPSB+KFNJUzU1OTVfRVhURU5UIC0gMSk7CglpZiAoIWFkZHJlc3MpIHsKCQlkZXZfZXJyKCZkZXYtPmRldiwgIkJhc2UgYWRkcmVzcyBub3Qgc2V0IC0gdXBncmFkZSBCSU9TIG9yIHVzZSBmb3JjZV9hZGRyPTB4YWRkclxuIik7CgkJcmV0dXJuIC1FTk9ERVY7Cgl9CglpZiAoZm9yY2VfYWRkciAmJiBhZGRyZXNzICE9IGZvcmNlX2FkZHIpIHsKCQkvKiBkb2Vzbid0IHdvcmsgZm9yIHNvbWUgY2hpcHM/ICovCgkJZGV2X2VycigmZGV2LT5kZXYsICJGYWlsZWQgdG8gZm9yY2UgSVNBIGFkZHJlc3NcbiIpOwoJCXJldHVybiAtRU5PREVWOwoJfQoKCWlmIChQQ0lCSU9TX1NVQ0NFU1NGVUwgIT0KCSAgICBwY2lfcmVhZF9jb25maWdfYnl0ZShkZXYsIFNJUzU1OTVfRU5BQkxFX1JFRywgJmVuYWJsZSkpIHsKCQlkZXZfZXJyKCZkZXYtPmRldiwgIkZhaWxlZCB0byByZWFkIGVuYWJsZSByZWdpc3RlclxuIik7CgkJcmV0dXJuIC1FTk9ERVY7Cgl9CglpZiAoIShlbmFibGUgJiAweDgwKSkgewoJCWlmICgoUENJQklPU19TVUNDRVNTRlVMICE9CgkJICAgICBwY2lfd3JpdGVfY29uZmlnX2J5dGUoZGV2LCBTSVM1NTk1X0VOQUJMRV9SRUcsCgkJCQkJICAgZW5hYmxlIHwgMHg4MCkpCgkJIHx8IChQQ0lCSU9TX1NVQ0NFU1NGVUwgIT0KCQkgICAgIHBjaV9yZWFkX2NvbmZpZ19ieXRlKGRldiwgU0lTNTU5NV9FTkFCTEVfUkVHLCAmZW5hYmxlKSkKCQkgfHwgKCEoZW5hYmxlICYgMHg4MCkpKSB7CgkJCS8qIGRvZXNuJ3Qgd29yayBmb3Igc29tZSBjaGlwcyEgKi8KCQkJZGV2X2VycigmZGV2LT5kZXYsICJGYWlsZWQgdG8gZW5hYmxlIEhXTSBkZXZpY2VcbiIpOwoJCQlyZXR1cm4gLUVOT0RFVjsKCQl9Cgl9CgoJaWYgKHBsYXRmb3JtX2RyaXZlcl9yZWdpc3Rlcigmc2lzNTU5NV9kcml2ZXIpKSB7CgkJZGV2X2RiZygmZGV2LT5kZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgc2lzNTU5NSBkcml2ZXJcbiIpOwoJCWdvdG8gZXhpdDsKCX0KCglzX2JyaWRnZSA9IHBjaV9kZXZfZ2V0KGRldik7CgkvKiBTZXRzIGdsb2JhbCBwZGV2IGFzIGEgc2lkZSBlZmZlY3QgKi8KCWlmIChzaXM1NTk1X2RldmljZV9hZGQoYWRkcmVzcykpCgkJZ290byBleGl0X3VucmVnaXN0ZXI7CgoJLyogQWx3YXlzIHJldHVybiBmYWlsdXJlIGhlcmUuICBUaGlzIGlzIHRvIGFsbG93IG90aGVyIGRyaXZlcnMgdG8gYmluZAoJICogdG8gdGhpcyBwY2kgZGV2aWNlLiAgV2UgZG9uJ3QgcmVhbGx5IHdhbnQgdG8gaGF2ZSBjb250cm9sIG92ZXIgdGhlCgkgKiBwY2kgZGV2aWNlLCB3ZSBvbmx5IHdhbnRlZCB0byByZWFkIGFzIGZldyByZWdpc3RlciB2YWx1ZXMgZnJvbSBpdC4KCSAqLwoJcmV0dXJuIC1FTk9ERVY7CgpleGl0X3VucmVnaXN0ZXI6CglwY2lfZGV2X3B1dChkZXYpOwoJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJnNpczU1OTVfZHJpdmVyKTsKZXhpdDoKCXJldHVybiAtRU5PREVWOwp9CgpzdGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgc2lzNTU5NV9wY2lfZHJpdmVyID0gewoJLm5hbWUgICAgICAgICAgICA9ICJzaXM1NTk1IiwKCS5pZF90YWJsZSAgICAgICAgPSBzaXM1NTk1X3BjaV9pZHMsCgkucHJvYmUgICAgICAgICAgID0gc2lzNTU5NV9wY2lfcHJvYmUsCn07CgpzdGF0aWMgaW50IF9faW5pdCBzbV9zaXM1NTk1X2luaXQodm9pZCkKewoJcmV0dXJuIHBjaV9yZWdpc3Rlcl9kcml2ZXIoJnNpczU1OTVfcGNpX2RyaXZlcik7Cn0KCnN0YXRpYyB2b2lkIF9fZXhpdCBzbV9zaXM1NTk1X2V4aXQodm9pZCkKewoJcGNpX3VucmVnaXN0ZXJfZHJpdmVyKCZzaXM1NTk1X3BjaV9kcml2ZXIpOwoJaWYgKHNfYnJpZGdlICE9IE5VTEwpIHsKCQlwbGF0Zm9ybV9kZXZpY2VfdW5yZWdpc3RlcihwZGV2KTsKCQlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3Rlcigmc2lzNTU5NV9kcml2ZXIpOwoJCXBjaV9kZXZfcHV0KHNfYnJpZGdlKTsKCQlzX2JyaWRnZSA9IE5VTEw7Cgl9Cn0KCk1PRFVMRV9BVVRIT1IoIkF1cmVsaWVuIEphcm5vIDxhdXJlbGllbkBhdXJlbDMyLm5ldD4iKTsKTU9EVUxFX0RFU0NSSVBUSU9OKCJTaVMgNTU5NSBTZW5zb3IgZGV2aWNlIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKCm1vZHVsZV9pbml0KHNtX3NpczU1OTVfaW5pdCk7Cm1vZHVsZV9leGl0KHNtX3NpczU1OTVfZXhpdCk7Cg==