LyoKICogRHJpdmVyIGZvciBEaWdpZ3JhbSBtaVhhcnQgc291bmRjYXJkcwogKgogKiBtYWluIGZpbGUgd2l0aCBhbHNhIGNhbGxiYWNrcwogKgogKiBDb3B5cmlnaHQgKGMpIDIwMDMgYnkgRGlnaWdyYW0gPGFsc2FAZGlnaWdyYW0uY29tPgogKgogKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAqICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgogKiAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAqCiAqICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAqICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiAqICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQogKiAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqICAgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgVVNBCiAqLwoKCiNpbmNsdWRlIDxzb3VuZC9kcml2ZXIuaD4KI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvcGNpLmg+CiNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgojaW5jbHVkZSA8bGludXgvbW9kdWxlcGFyYW0uaD4KI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CgojaW5jbHVkZSA8c291bmQvY29yZS5oPgojaW5jbHVkZSA8c291bmQvaW5pdHZhbC5oPgojaW5jbHVkZSA8c291bmQvaW5mby5oPgojaW5jbHVkZSA8c291bmQvY29udHJvbC5oPgojaW5jbHVkZSA8c291bmQvcGNtLmg+CiNpbmNsdWRlIDxzb3VuZC9wY21fcGFyYW1zLmg+CiNpbmNsdWRlICJtaXhhcnQuaCIKI2luY2x1ZGUgIm1peGFydF9od2RlcC5oIgojaW5jbHVkZSAibWl4YXJ0X2NvcmUuaCIKI2luY2x1ZGUgIm1peGFydF9taXhlci5oIgoKI2RlZmluZSBDQVJEX05BTUUgIm1pWGFydCIKCk1PRFVMRV9BVVRIT1IoIkRpZ2lncmFtIDxhbHNhQGRpZ2lncmFtLmNvbT4iKTsKTU9EVUxFX0RFU0NSSVBUSU9OKCJEaWdpZ3JhbSAiIENBUkRfTkFNRSk7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKTU9EVUxFX1NVUFBPUlRFRF9ERVZJQ0UoInt7RGlnaWdyYW0sIiBDQVJEX05BTUUgIn19Iik7CgpzdGF0aWMgaW50IGluZGV4W1NORFJWX0NBUkRTXSA9IFNORFJWX0RFRkFVTFRfSURYOyAgICAgICAgICAgICAvKiBJbmRleCAwLU1BWCAqLwpzdGF0aWMgY2hhciAqaWRbU05EUlZfQ0FSRFNdID0gU05EUlZfREVGQVVMVF9TVFI7ICAgICAgICAgICAgICAvKiBJRCBmb3IgdGhpcyBjYXJkICovCnN0YXRpYyBpbnQgZW5hYmxlW1NORFJWX0NBUkRTXSA9IFNORFJWX0RFRkFVTFRfRU5BQkxFX1BOUDsgICAgIC8qIEVuYWJsZSB0aGlzIGNhcmQgKi8KCm1vZHVsZV9wYXJhbV9hcnJheShpbmRleCwgaW50LCBOVUxMLCAwNDQ0KTsKTU9EVUxFX1BBUk1fREVTQyhpbmRleCwgIkluZGV4IHZhbHVlIGZvciBEaWdpZ3JhbSAiIENBUkRfTkFNRSAiIHNvdW5kY2FyZC4iKTsKbW9kdWxlX3BhcmFtX2FycmF5KGlkLCBjaGFycCwgTlVMTCwgMDQ0NCk7Ck1PRFVMRV9QQVJNX0RFU0MoaWQsICJJRCBzdHJpbmcgZm9yIERpZ2lncmFtICIgQ0FSRF9OQU1FICIgc291bmRjYXJkLiIpOwptb2R1bGVfcGFyYW1fYXJyYXkoZW5hYmxlLCBib29sLCBOVUxMLCAwNDQ0KTsKTU9EVUxFX1BBUk1fREVTQyhlbmFibGUsICJFbmFibGUgRGlnaWdyYW0gIiBDQVJEX05BTUUgIiBzb3VuZGNhcmQuIik7CgovKgogKi8KCnN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBzbmRfbWl4YXJ0X2lkc1tdID0gewoJeyAweDEwNTcsIDB4MDAwMywgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgMCwgfSwgLyogTUM4MjQwICovCgl7IDAsIH0KfTsKCk1PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBzbmRfbWl4YXJ0X2lkcyk7CgoKc3RhdGljIGludCBtaXhhcnRfc2V0X3BpcGVfc3RhdGUoc3RydWN0IG1peGFydF9tZ3IgKm1nciwKCQkJCSBzdHJ1Y3QgbWl4YXJ0X3BpcGUgKnBpcGUsIGludCBzdGFydCkKewoJc3RydWN0IG1peGFydF9ncm91cF9zdGF0ZV9yZXEgZ3JvdXBfc3RhdGU7CglzdHJ1Y3QgbWl4YXJ0X2dyb3VwX3N0YXRlX3Jlc3AgZ3JvdXBfc3RhdGVfcmVzcDsKCXN0cnVjdCBtaXhhcnRfbXNnIHJlcXVlc3Q7CglpbnQgZXJyOwoJdTMyIHN5c3RlbV9tc2dfdWlkOwoKCXN3aXRjaChwaXBlLT5zdGF0dXMpIHsKCWNhc2UgUElQRV9SVU5OSU5HOgoJY2FzZSBQSVBFX0NMT0NLX1NFVDoKCQlpZihzdGFydCkgcmV0dXJuIDA7IC8qIGFscmVhZHkgc3RhcnRlZCAqLwoJCWJyZWFrOwoJY2FzZSBQSVBFX1NUT1BQRUQ6CgkJaWYoIXN0YXJ0KSByZXR1cm4gMDsgLyogYWxyZWFkeSBzdG9wcGVkICovCgkJYnJlYWs7CglkZWZhdWx0OgoJCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yIG1peGFydF9zZXRfcGlwZV9zdGF0ZSBjYWxsZWQgd2l0aCB3cm9uZyBwaXBlLT5zdGF0dXMhXG4iKTsKCQlyZXR1cm4gLUVJTlZBTDsgICAgICAvKiBmdW5jdGlvbiBjYWxsZWQgd2l0aCB3cm9uZyBwaXBlIHN0YXR1cyAqLwoJfQoKCXN5c3RlbV9tc2dfdWlkID0gMHgxMjM0NTY3ODsgLyogdGhlIGV2ZW50ICEgKHRha2UgY2FyZTogdGhlIE1TQiBhbmQgdHdvIExTQidzIGhhdmUgdG8gYmUgMCkgKi8KCgkvKiB3YWl0IG9uIHRoZSBsYXN0IE1TR19TWVNURU1fU0VORF9TWU5DSFJPX0NNRCBjb21tYW5kIHRvIGJlIHJlYWxseSBmaW5pc2hlZCAqLwoKCXJlcXVlc3QubWVzc2FnZV9pZCA9IE1TR19TWVNURU1fV0FJVF9TWU5DSFJPX0NNRDsKCXJlcXVlc3QudWlkID0gKHN0cnVjdCBtaXhhcnRfdWlkKXswLDB9OwoJcmVxdWVzdC5kYXRhID0gJnN5c3RlbV9tc2dfdWlkOwoJcmVxdWVzdC5zaXplID0gc2l6ZW9mKHN5c3RlbV9tc2dfdWlkKTsKCgllcnIgPSBzbmRfbWl4YXJ0X3NlbmRfbXNnX3dhaXRfbm90aWYobWdyLCAmcmVxdWVzdCwgc3lzdGVtX21zZ191aWQpOwoJaWYoZXJyKSB7CgkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3IgOiBNU0dfU1lTVEVNX1dBSVRfU1lOQ0hST19DTUQgd2FzIG5vdCBub3RpZmllZCAhXG4iKTsKCQlyZXR1cm4gZXJyOwoJfQoKCS8qIHN0YXJ0IG9yIHN0b3AgdGhlIHBpcGUgKDEgcGlwZSkgKi8KCgltZW1zZXQoJmdyb3VwX3N0YXRlLCAwLCBzaXplb2YoZ3JvdXBfc3RhdGUpKTsKCWdyb3VwX3N0YXRlLnBpcGVfY291bnQgPSAxOwoJZ3JvdXBfc3RhdGUucGlwZV91aWRbMF0gPSBwaXBlLT5ncm91cF91aWQ7CgoJaWYoc3RhcnQpCgkJcmVxdWVzdC5tZXNzYWdlX2lkID0gTVNHX1NUUkVBTV9TVEFSVF9TVFJFQU1fR1JQX1BBQ0tFVDsKCWVsc2UKCQlyZXF1ZXN0Lm1lc3NhZ2VfaWQgPSBNU0dfU1RSRUFNX1NUT1BfU1RSRUFNX0dSUF9QQUNLRVQ7CgoJcmVxdWVzdC51aWQgPSBwaXBlLT5ncm91cF91aWQ7IC8qKHN0cnVjdCBtaXhhcnRfdWlkKXswLDB9OyovCglyZXF1ZXN0LmRhdGEgPSAmZ3JvdXBfc3RhdGU7CglyZXF1ZXN0LnNpemUgPSBzaXplb2YoZ3JvdXBfc3RhdGUpOwoKCWVyciA9IHNuZF9taXhhcnRfc2VuZF9tc2cobWdyLCAmcmVxdWVzdCwgc2l6ZW9mKGdyb3VwX3N0YXRlX3Jlc3ApLCAmZ3JvdXBfc3RhdGVfcmVzcCk7CglpZiAoZXJyIDwgMCB8fCBncm91cF9zdGF0ZV9yZXNwLnR4eF9zdGF0dXMgIT0gMCkgewoJCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yIE1TR19TVFJFQU1fU1QqKipfU1RSRUFNX0dSUF9QQUNLRVQgZXJyPSV4IHN0YXQ9JXggIVxuIiwgZXJyLCBncm91cF9zdGF0ZV9yZXNwLnR4eF9zdGF0dXMpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCWlmKHN0YXJ0KSB7CgkJdTMyIHN0YXQ7CgoJCWdyb3VwX3N0YXRlLnBpcGVfY291bnQgPSAwOyAvKiBpbiBjYXNlIG9mIHN0YXJ0IHNhbWUgY29tbWFuZCBvbmNlIGFnYWluIHdpdGggcGlwZV9jb3VudD0wICovCgoJCWVyciA9IHNuZF9taXhhcnRfc2VuZF9tc2cobWdyLCAmcmVxdWVzdCwgc2l6ZW9mKGdyb3VwX3N0YXRlX3Jlc3ApLCAmZ3JvdXBfc3RhdGVfcmVzcCk7CgkJaWYgKGVyciA8IDAgfHwgZ3JvdXBfc3RhdGVfcmVzcC50eHhfc3RhdHVzICE9IDApIHsKCQkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3IgTVNHX1NUUkVBTV9TVEFSVF9TVFJFQU1fR1JQX1BBQ0tFVCBlcnI9JXggc3RhdD0leCAhXG4iLCBlcnIsIGdyb3VwX3N0YXRlX3Jlc3AudHh4X3N0YXR1cyk7CiAJCQlyZXR1cm4gLUVJTlZBTDsKCQl9CgoJCS8qIGluIGNhc2Ugb2Ygc3RhcnQgc2VuZCBhIHN5bmNocm8gdG9wICovCgoJCXJlcXVlc3QubWVzc2FnZV9pZCA9IE1TR19TWVNURU1fU0VORF9TWU5DSFJPX0NNRDsKCQlyZXF1ZXN0LnVpZCA9IChzdHJ1Y3QgbWl4YXJ0X3VpZCl7MCwwfTsKCQlyZXF1ZXN0LmRhdGEgPSBOVUxMOwoJCXJlcXVlc3Quc2l6ZSA9IDA7CgoJCWVyciA9IHNuZF9taXhhcnRfc2VuZF9tc2cobWdyLCAmcmVxdWVzdCwgc2l6ZW9mKHN0YXQpLCAmc3RhdCk7CgkJaWYgKGVyciA8IDAgfHwgc3RhdCAhPSAwKSB7CgkJCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yIE1TR19TWVNURU1fU0VORF9TWU5DSFJPX0NNRCBlcnI9JXggc3RhdD0leCAhXG4iLCBlcnIsIHN0YXQpOwoJCQlyZXR1cm4gLUVJTlZBTDsKCQl9CgoJCXBpcGUtPnN0YXR1cyA9IFBJUEVfUlVOTklORzsKCX0KCWVsc2UgLyogIXN0YXJ0ICovCgkJcGlwZS0+c3RhdHVzID0gUElQRV9TVE9QUEVEOwoKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCBtaXhhcnRfc2V0X2Nsb2NrKHN0cnVjdCBtaXhhcnRfbWdyICptZ3IsCgkJCSAgICBzdHJ1Y3QgbWl4YXJ0X3BpcGUgKnBpcGUsIHVuc2lnbmVkIGludCByYXRlKQp7CglzdHJ1Y3QgbWl4YXJ0X21zZyByZXF1ZXN0OwoJc3RydWN0IG1peGFydF9jbG9ja19wcm9wZXJ0aWVzIGNsb2NrX3Byb3BlcnRpZXM7CglzdHJ1Y3QgbWl4YXJ0X2Nsb2NrX3Byb3BlcnRpZXNfcmVzcCBjbG9ja19wcm9wX3Jlc3A7CglpbnQgZXJyOwoKCXN3aXRjaChwaXBlLT5zdGF0dXMpIHsKCWNhc2UgUElQRV9DTE9DS19TRVQ6CgkJYnJlYWs7CgljYXNlIFBJUEVfUlVOTklORzoKCQlpZihyYXRlICE9IDApCgkJCWJyZWFrOwoJZGVmYXVsdDoKCQlpZihyYXRlID09IDApCgkJCXJldHVybiAwOyAvKiBub3RoaW5nIHRvIGRvICovCgkJZWxzZSB7CgkJCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yIG1peGFydF9zZXRfY2xvY2soJWQpIGNhbGxlZCB3aXRoIHdyb25nIHBpcGUtPnN0YXR1cyAhXG4iLCByYXRlKTsKCQkJcmV0dXJuIC1FSU5WQUw7CgkJfQoJfQoKCW1lbXNldCgmY2xvY2tfcHJvcGVydGllcywgMCwgc2l6ZW9mKGNsb2NrX3Byb3BlcnRpZXMpKTsKCWNsb2NrX3Byb3BlcnRpZXMuY2xvY2tfZ2VuZXJpY190eXBlID0gKHJhdGUgIT0gMCkgPyBDR1RfSU5URVJOQUxfQ0xPQ0sgOiBDR1RfTk9fQ0xPQ0s7CgljbG9ja19wcm9wZXJ0aWVzLmNsb2NrX21vZGUgPSBDTV9TVEFOREFMT05FOwoJY2xvY2tfcHJvcGVydGllcy5mcmVxdWVuY3kgPSByYXRlOwoJY2xvY2tfcHJvcGVydGllcy5uYl9jYWxsZXJzID0gMTsgLyogb25seSBvbmUgZW50cnkgaW4gdWlkX2NhbGxlciAhICovCgljbG9ja19wcm9wZXJ0aWVzLnVpZF9jYWxsZXJbMF0gPSBwaXBlLT5ncm91cF91aWQ7CgoJc25kX3ByaW50ZGQoIm1peGFydF9zZXRfY2xvY2sgdG8gJWQga0h6XG4iLCByYXRlKTsKCglyZXF1ZXN0Lm1lc3NhZ2VfaWQgPSBNU0dfQ0xPQ0tfU0VUX1BST1BFUlRJRVM7CglyZXF1ZXN0LnVpZCA9IG1nci0+dWlkX2NvbnNvbGVfbWFuYWdlcjsKCXJlcXVlc3QuZGF0YSA9ICZjbG9ja19wcm9wZXJ0aWVzOwoJcmVxdWVzdC5zaXplID0gc2l6ZW9mKGNsb2NrX3Byb3BlcnRpZXMpOwoKCWVyciA9IHNuZF9taXhhcnRfc2VuZF9tc2cobWdyLCAmcmVxdWVzdCwgc2l6ZW9mKGNsb2NrX3Byb3BfcmVzcCksICZjbG9ja19wcm9wX3Jlc3ApOwoJaWYgKGVyciA8IDAgfHwgY2xvY2tfcHJvcF9yZXNwLnN0YXR1cyAhPSAwIHx8IGNsb2NrX3Byb3BfcmVzcC5jbG9ja19tb2RlICE9IENNX1NUQU5EQUxPTkUpIHsKCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJlcnJvciBNU0dfQ0xPQ0tfU0VUX1BST1BFUlRJRVMgZXJyPSV4IHN0YXQ9JXggbW9kPSV4ICFcbiIsIGVyciwgY2xvY2tfcHJvcF9yZXNwLnN0YXR1cywgY2xvY2tfcHJvcF9yZXNwLmNsb2NrX21vZGUpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCWlmKHJhdGUpICBwaXBlLT5zdGF0dXMgPSBQSVBFX0NMT0NLX1NFVDsKCWVsc2UgICAgICBwaXBlLT5zdGF0dXMgPSBQSVBFX1JVTk5JTkc7CgoJcmV0dXJuIDA7Cn0KCgovKgogKiAgQWxsb2NhdGUgb3IgcmVmZXJlbmNlIG91dHB1dCBwaXBlIGZvciBhbmFsb2cgSU9zIChwY21wMC8xKQogKi8Kc3RydWN0IG1peGFydF9waXBlICoKc25kX21peGFydF9hZGRfcmVmX3BpcGUoc3RydWN0IHNuZF9taXhhcnQgKmNoaXAsIGludCBwY21fbnVtYmVyLCBpbnQgY2FwdHVyZSwKCQkJaW50IG1vbml0b3JpbmcpCnsKCWludCBzdHJlYW1fY291bnQ7CglzdHJ1Y3QgbWl4YXJ0X3BpcGUgKnBpcGU7CglzdHJ1Y3QgbWl4YXJ0X21zZyByZXF1ZXN0OwoKCWlmKGNhcHR1cmUpIHsKCQlpZiAocGNtX251bWJlciA9PSBNSVhBUlRfUENNX0FOQUxPRykgewoJCQlwaXBlID0gJihjaGlwLT5waXBlX2luX2FuYSk7ICAvKiBhbmFsb2cgaW5wdXRzICovCgkJfSBlbHNlIHsKCQkJcGlwZSA9ICYoY2hpcC0+cGlwZV9pbl9kaWcpOyAvKiBkaWdpdGFsIGlucHV0cyAqLwoJCX0KCQlyZXF1ZXN0Lm1lc3NhZ2VfaWQgPSBNU0dfU1RSRUFNX0FERF9PVVRQVVRfR1JPVVA7CgkJc3RyZWFtX2NvdW50ID0gTUlYQVJUX0NBUFRVUkVfU1RSRUFNUzsKCX0gZWxzZSB7CgkJaWYgKHBjbV9udW1iZXIgPT0gTUlYQVJUX1BDTV9BTkFMT0cpIHsKCQkJcGlwZSA9ICYoY2hpcC0+cGlwZV9vdXRfYW5hKTsgIC8qIGFuYWxvZyBvdXRwdXRzICovCgkJfSBlbHNlIHsKCQkJcGlwZSA9ICYoY2hpcC0+cGlwZV9vdXRfZGlnKTsgIC8qIGRpZ2l0YWwgb3V0cHV0cyAqLwoJCX0KCQlyZXF1ZXN0Lm1lc3NhZ2VfaWQgPSBNU0dfU1RSRUFNX0FERF9JTlBVVF9HUk9VUDsKCQlzdHJlYW1fY291bnQgPSBNSVhBUlRfUExBWUJBQ0tfU1RSRUFNUzsKCX0KCgkvKiBhIG5ldyBzdHJlYW0gaXMgb3BlbmVkIGFuZCB0aGVyZSBhcmUgYWxyZWFkeSBhbGwgc3RyZWFtcyBpbiB1c2UgKi8KCWlmKCAobW9uaXRvcmluZyA9PSAwKSAmJiAocGlwZS0+cmVmZXJlbmNlcyA+PSBzdHJlYW1fY291bnQpICkgewoJCXJldHVybiBOVUxMOwoJfQoKCS8qIHBpcGUgaXMgbm90IHlldCBkZWZpbmVkICovCglpZiggcGlwZS0+c3RhdHVzID09IFBJUEVfVU5ERUZJTkVEICkgewoJCWludCBlcnIsIGk7CgkJc3RydWN0IHsKCQkJc3RydWN0IG1peGFydF9zdHJlYW1pbmdfZ3JvdXBfcmVxIHNncm91cF9yZXE7CgkJCXN0cnVjdCBtaXhhcnRfc3RyZWFtaW5nX2dyb3VwIHNncm91cF9yZXNwOwoJCX0gKmJ1ZjsKCgkJc25kX3ByaW50ZGQoImFkZF9yZWZfcGlwZSBhdWRpbyBjaGlwKCVkKSBwY20oJWQpXG4iLCBjaGlwLT5jaGlwX2lkeCwgcGNtX251bWJlcik7CgoJCWJ1ZiA9IGttYWxsb2Moc2l6ZW9mKCpidWYpLCBHRlBfS0VSTkVMKTsKCQlpZiAoIWJ1ZikKCQkJcmV0dXJuIE5VTEw7CgoJCXJlcXVlc3QudWlkID0gKHN0cnVjdCBtaXhhcnRfdWlkKXswLDB9OyAgICAgIC8qIHNob3VsZCBiZSBTdHJlYW1NYW5hZ2VyVUlELCBidXQgemVybyBpcyBPSyBpZiB0aGVyZSBpcyBvbmx5IG9uZSAhICovCgkJcmVxdWVzdC5kYXRhID0gJmJ1Zi0+c2dyb3VwX3JlcTsKCQlyZXF1ZXN0LnNpemUgPSBzaXplb2YoYnVmLT5zZ3JvdXBfcmVxKTsKCgkJbWVtc2V0KCZidWYtPnNncm91cF9yZXEsIDAsIHNpemVvZihidWYtPnNncm91cF9yZXEpKTsKCgkJYnVmLT5zZ3JvdXBfcmVxLnN0cmVhbV9jb3VudCA9IHN0cmVhbV9jb3VudDsKCQlidWYtPnNncm91cF9yZXEuY2hhbm5lbF9jb3VudCA9IDI7CgkJYnVmLT5zZ3JvdXBfcmVxLmxhdGVuY3kgPSAyNTY7CgkJYnVmLT5zZ3JvdXBfcmVxLmNvbm5lY3RvciA9IHBpcGUtPnVpZF9sZWZ0X2Nvbm5lY3RvcjsgIC8qIHRoZSBsZWZ0IGNvbm5lY3RvciAqLwoKCQlmb3IgKGk9MDsgaTxzdHJlYW1fY291bnQ7IGkrKykgewoJCQlpbnQgajsKCQkJc3RydWN0IG1peGFydF9mbG93aW5mbyAqZmxvd2luZm87CgkJCXN0cnVjdCBtaXhhcnRfYnVmZmVyaW5mbyAqYnVmZmVyaW5mbzsKCQkJCgkJCS8qIHdlIGRvbid0IHlldCBrbm93IHRoZSBmb3JtYXQsIHNvIGNvbmZpZyAxNiBiaXQgcGNtIGF1ZGlvIGZvciBpbnN0YW5jZSAqLwoJCQlidWYtPnNncm91cF9yZXEuc3RyZWFtX2luZm9baV0uc2l6ZV9tYXhfYnl0ZV9mcmFtZSA9IDEwMjQ7CgkJCWJ1Zi0+c2dyb3VwX3JlcS5zdHJlYW1faW5mb1tpXS5zaXplX21heF9zYW1wbGVfZnJhbWUgPSAyNTY7CgkJCWJ1Zi0+c2dyb3VwX3JlcS5zdHJlYW1faW5mb1tpXS5uYl9ieXRlc19tYXhfcGVyX3NhbXBsZSA9IE1JWEFSVF9GTE9BVF9QX180XzBfVE9fSEVYOyAvKiBpcyA0LjBmICovCgoJCQkvKiBmaW5kIHRoZSByaWdodCBidWZmZXJpbmZvX2FycmF5ICovCgkJCWogPSAoY2hpcC0+Y2hpcF9pZHggKiBNSVhBUlRfTUFYX1NUUkVBTV9QRVJfQ0FSRCkgKyAocGNtX251bWJlciAqIChNSVhBUlRfUExBWUJBQ0tfU1RSRUFNUyArIE1JWEFSVF9DQVBUVVJFX1NUUkVBTVMpKSArIGk7CgkJCWlmKGNhcHR1cmUpIGogKz0gTUlYQVJUX1BMQVlCQUNLX1NUUkVBTVM7IC8qIGluIHRoZSBhcnJheSBjYXB0dXJlIGlzIGJlaGluZCBwbGF5YmFjayAqLwoKCQkJYnVmLT5zZ3JvdXBfcmVxLmZsb3dfZW50cnlbaV0gPSBqOwoKCQkJZmxvd2luZm8gPSAoc3RydWN0IG1peGFydF9mbG93aW5mbyAqKWNoaXAtPm1nci0+Zmxvd2luZm8uYXJlYTsKCQkJZmxvd2luZm9bal0uYnVmZmVyaW5mb19hcnJheV9waHlfYWRkcmVzcyA9ICh1MzIpY2hpcC0+bWdyLT5idWZmZXJpbmZvLmFkZHIgKyAoaiAqIHNpemVvZihzdHJ1Y3QgbWl4YXJ0X2J1ZmZlcmluZm8pKTsKCQkJZmxvd2luZm9bal0uYnVmZmVyaW5mb19jb3VudCA9IDE7ICAgICAgICAgICAgICAgLyogMSB3aWxsIHNldCB0aGUgbWlYYXJ0IHRvIHJpbmctYnVmZmVyIG1vZGUgISAqLwoKCQkJYnVmZmVyaW5mbyA9IChzdHJ1Y3QgbWl4YXJ0X2J1ZmZlcmluZm8gKiljaGlwLT5tZ3ItPmJ1ZmZlcmluZm8uYXJlYTsKCQkJYnVmZmVyaW5mb1tqXS5idWZmZXJfYWRkcmVzcyA9IDA7ICAgICAgICAgICAgICAgLyogYnVmZmVyIGlzIG5vdCB5ZXQgYWxsb2NhdGVkICovCgkJCWJ1ZmZlcmluZm9bal0uYXZhaWxhYmxlX2xlbmd0aCA9IDA7ICAgICAgICAgICAgIC8qIGJ1ZmZlciBpcyBub3QgeWV0IGFsbG9jYXRlZCAqLwoKCQkJLyogY29uc3RydWN0IHRoZSBpZGVudGlmaWVyIG9mIHRoZSBzdHJlYW0gYnVmZmVyIHJlY2VpdmVkIGluIHRoZSBpbnRlcnJ1cHRzICEgKi8KCQkJYnVmZmVyaW5mb1tqXS5idWZmZXJfaWQgPSAoY2hpcC0+Y2hpcF9pZHggPDwgTUlYQVJUX05PVElGWV9DQVJEX09GRlNFVCkgKyAocGNtX251bWJlciA8PCBNSVhBUlRfTk9USUZZX1BDTV9PRkZTRVQgKSArIGk7CgkJCWlmKGNhcHR1cmUpIHsKCQkJCWJ1ZmZlcmluZm9bal0uYnVmZmVyX2lkIHw9IE1JWEFSVF9OT1RJRllfQ0FQVF9NQVNLOwoJCQl9CgkJfQoKCQllcnIgPSBzbmRfbWl4YXJ0X3NlbmRfbXNnKGNoaXAtPm1nciwgJnJlcXVlc3QsIHNpemVvZihidWYtPnNncm91cF9yZXNwKSwgJmJ1Zi0+c2dyb3VwX3Jlc3ApOwoJCWlmKChlcnIgPCAwKSB8fCAoYnVmLT5zZ3JvdXBfcmVzcC5zdGF0dXMgIT0gMCkpIHsKCQkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3IgTVNHX1NUUkVBTV9BRERfKipQVVRfR1JPVVAgZXJyPSV4IHN0YXQ9JXggIVxuIiwgZXJyLCBidWYtPnNncm91cF9yZXNwLnN0YXR1cyk7CgkJCWtmcmVlKGJ1Zik7CgkJCXJldHVybiBOVUxMOwoJCX0KCgkJcGlwZS0+Z3JvdXBfdWlkID0gYnVmLT5zZ3JvdXBfcmVzcC5ncm91cDsgICAgIC8qIGlkIG9mIHRoZSBwaXBlLCBhcyByZXR1cm5lZCBieSBlbWJlZGRlZCAqLwoJCXBpcGUtPnN0cmVhbV9jb3VudCA9IGJ1Zi0+c2dyb3VwX3Jlc3Auc3RyZWFtX2NvdW50OwoJCS8qIHBpcGUtPnN0cmVhbV91aWRbaV0gPSBidWYtPnNncm91cF9yZXNwLnN0cmVhbVtpXS5zdHJlYW1fdWlkOyAqLwoKCQlwaXBlLT5zdGF0dXMgPSBQSVBFX1NUT1BQRUQ7CgkJa2ZyZWUoYnVmKTsKCX0KCglpZihtb25pdG9yaW5nKQlwaXBlLT5tb25pdG9yaW5nID0gMTsKCWVsc2UJCXBpcGUtPnJlZmVyZW5jZXMrKzsKCglyZXR1cm4gcGlwZTsKfQoKCmludCBzbmRfbWl4YXJ0X2tpbGxfcmVmX3BpcGUoc3RydWN0IG1peGFydF9tZ3IgKm1nciwKCQkJICAgICBzdHJ1Y3QgbWl4YXJ0X3BpcGUgKnBpcGUsIGludCBtb25pdG9yaW5nKQp7CglpbnQgZXJyID0gMDsKCglpZihwaXBlLT5zdGF0dXMgPT0gUElQRV9VTkRFRklORUQpCgkJcmV0dXJuIDA7CgoJaWYobW9uaXRvcmluZykKCQlwaXBlLT5tb25pdG9yaW5nID0gMDsKCWVsc2UKCQlwaXBlLT5yZWZlcmVuY2VzLS07CgoJaWYoKHBpcGUtPnJlZmVyZW5jZXMgPD0gMCkgJiYgKHBpcGUtPm1vbml0b3JpbmcgPT0gMCkpIHsKCgkJc3RydWN0IG1peGFydF9tc2cgcmVxdWVzdDsKCQlzdHJ1Y3QgbWl4YXJ0X2RlbGV0ZV9ncm91cF9yZXNwIGRlbGV0ZV9yZXNwOwoKCQkvKiByZWxlYXNlIHRoZSBjbG9jayAqLwoJCWVyciA9IG1peGFydF9zZXRfY2xvY2soIG1nciwgcGlwZSwgMCk7CgkJaWYoIGVyciA8IDAgKSB7CgkJCXNuZF9wcmludGsoS0VSTl9FUlIgIm1peGFydF9zZXRfY2xvY2soMCkgcmV0dXJuIGVycm9yIVxuIik7CgkJfQoKCQkvKiBzdG9wIHRoZSBwaXBlICovCgkJZXJyID0gbWl4YXJ0X3NldF9waXBlX3N0YXRlKG1nciwgcGlwZSwgMCk7CgkJaWYoIGVyciA8IDAgKSB7CgkJCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yIHN0b3BwaW5nIHBpcGUhXG4iKTsKCQl9CgoJCXJlcXVlc3QubWVzc2FnZV9pZCA9IE1TR19TVFJFQU1fREVMRVRFX0dST1VQOwoJCXJlcXVlc3QudWlkID0gKHN0cnVjdCBtaXhhcnRfdWlkKXswLDB9OwoJCXJlcXVlc3QuZGF0YSA9ICZwaXBlLT5ncm91cF91aWQ7ICAgICAgICAgICAgLyogdGhlIHN0cmVhbWluZyBncm91cCAhICovCgkJcmVxdWVzdC5zaXplID0gc2l6ZW9mKHBpcGUtPmdyb3VwX3VpZCk7CgoJCS8qIGRlbGV0ZSB0aGUgcGlwZSAqLwoJCWVyciA9IHNuZF9taXhhcnRfc2VuZF9tc2cobWdyLCAmcmVxdWVzdCwgc2l6ZW9mKGRlbGV0ZV9yZXNwKSwgJmRlbGV0ZV9yZXNwKTsKCQlpZiAoKGVyciA8IDApIHx8IChkZWxldGVfcmVzcC5zdGF0dXMgIT0gMCkpIHsKCQkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3IgTVNHX1NUUkVBTV9ERUxFVEVfR1JPVVAgZXJyKCV4KSwgc3RhdHVzKCV4KVxuIiwgZXJyLCBkZWxldGVfcmVzcC5zdGF0dXMpOwoJCX0KCgkJcGlwZS0+Z3JvdXBfdWlkID0gKHN0cnVjdCBtaXhhcnRfdWlkKXswLDB9OwoJCXBpcGUtPnN0cmVhbV9jb3VudCA9IDA7CgkJcGlwZS0+c3RhdHVzID0gUElQRV9VTkRFRklORUQ7Cgl9CgoJcmV0dXJuIGVycjsKfQoKc3RhdGljIGludCBtaXhhcnRfc2V0X3N0cmVhbV9zdGF0ZShzdHJ1Y3QgbWl4YXJ0X3N0cmVhbSAqc3RyZWFtLCBpbnQgc3RhcnQpCnsKCXN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwOwoJc3RydWN0IG1peGFydF9zdHJlYW1fc3RhdGVfcmVxIHN0cmVhbV9zdGF0ZV9yZXE7CglzdHJ1Y3QgbWl4YXJ0X21zZyByZXF1ZXN0OwoKCWlmKCFzdHJlYW0tPnN1YnN0cmVhbSkKCQlyZXR1cm4gLUVJTlZBTDsKCgltZW1zZXQoJnN0cmVhbV9zdGF0ZV9yZXEsIDAsIHNpemVvZihzdHJlYW1fc3RhdGVfcmVxKSk7CglzdHJlYW1fc3RhdGVfcmVxLnN0cmVhbV9jb3VudCA9IDE7CglzdHJlYW1fc3RhdGVfcmVxLnN0cmVhbV9pbmZvLnN0cmVhbV9kZXNjLnVpZF9waXBlID0gc3RyZWFtLT5waXBlLT5ncm91cF91aWQ7CglzdHJlYW1fc3RhdGVfcmVxLnN0cmVhbV9pbmZvLnN0cmVhbV9kZXNjLnN0cmVhbV9pZHggPSBzdHJlYW0tPnN1YnN0cmVhbS0+bnVtYmVyOwoKCWlmIChzdHJlYW0tPnN1YnN0cmVhbS0+c3RyZWFtID09IFNORFJWX1BDTV9TVFJFQU1fUExBWUJBQ0spCgkJcmVxdWVzdC5tZXNzYWdlX2lkID0gc3RhcnQgPyBNU0dfU1RSRUFNX1NUQVJUX0lOUFVUX1NUQUdFX1BBQ0tFVCA6IE1TR19TVFJFQU1fU1RPUF9JTlBVVF9TVEFHRV9QQUNLRVQ7CgllbHNlCgkJcmVxdWVzdC5tZXNzYWdlX2lkID0gc3RhcnQgPyBNU0dfU1RSRUFNX1NUQVJUX09VVFBVVF9TVEFHRV9QQUNLRVQgOiBNU0dfU1RSRUFNX1NUT1BfT1VUUFVUX1NUQUdFX1BBQ0tFVDsKCglyZXF1ZXN0LnVpZCA9IChzdHJ1Y3QgbWl4YXJ0X3VpZCl7MCwwfTsKCXJlcXVlc3QuZGF0YSA9ICZzdHJlYW1fc3RhdGVfcmVxOwoJcmVxdWVzdC5zaXplID0gc2l6ZW9mKHN0cmVhbV9zdGF0ZV9yZXEpOwoKCXN0cmVhbS0+YWJzX3BlcmlvZF9lbGFwc2VkID0gMDsgICAgICAgICAgICAvKiByZXNldCBzdHJlYW0gcG9zICAgICAgKi8KCXN0cmVhbS0+YnVmX3BlcmlvZHMgPSAwOwoJc3RyZWFtLT5idWZfcGVyaW9kX2ZyYWcgPSAwOwoKCWNoaXAgPSBzbmRfcGNtX3N1YnN0cmVhbV9jaGlwKHN0cmVhbS0+c3Vic3RyZWFtKTsKCglyZXR1cm4gc25kX21peGFydF9zZW5kX21zZ19ub25ibG9jayhjaGlwLT5tZ3IsICZyZXF1ZXN0KTsKfQoKLyoKICogIFRyaWdnZXIgY2FsbGJhY2sKICovCgpzdGF0aWMgaW50IHNuZF9taXhhcnRfdHJpZ2dlcihzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnMsIGludCBjbWQpCnsKCXN0cnVjdCBtaXhhcnRfc3RyZWFtICpzdHJlYW0gPSBzdWJzLT5ydW50aW1lLT5wcml2YXRlX2RhdGE7CgoJc3dpdGNoIChjbWQpIHsKCWNhc2UgU05EUlZfUENNX1RSSUdHRVJfU1RBUlQ6CgoJCXNuZF9wcmludGRkKCJTTkRSVl9QQ01fVFJJR0dFUl9TVEFSVFxuIik7CgoJCS8qIFNUQVJUX1NUUkVBTSAqLwoJCWlmKCBtaXhhcnRfc2V0X3N0cmVhbV9zdGF0ZShzdHJlYW0sIDEpICkKCQkJcmV0dXJuIC1FSU5WQUw7CgoJCXN0cmVhbS0+c3RhdHVzID0gTUlYQVJUX1NUUkVBTV9TVEFUVVNfUlVOTklORzsKCgkJYnJlYWs7CgljYXNlIFNORFJWX1BDTV9UUklHR0VSX1NUT1A6CgoJCS8qIFNUT1BfU1RSRUFNICovCgkJaWYoIG1peGFydF9zZXRfc3RyZWFtX3N0YXRlKHN0cmVhbSwgMCkgKQoJCQlyZXR1cm4gLUVJTlZBTDsKCgkJc3RyZWFtLT5zdGF0dXMgPSBNSVhBUlRfU1RSRUFNX1NUQVRVU19PUEVOOwoKCQlzbmRfcHJpbnRkZCgiU05EUlZfUENNX1RSSUdHRVJfU1RPUFxuIik7CgoJCWJyZWFrOwoKCWNhc2UgU05EUlZfUENNX1RSSUdHRVJfUEFVU0VfUFVTSDoKCQkvKiBUT0RPICovCgkJc3RyZWFtLT5zdGF0dXMgPSBNSVhBUlRfU1RSRUFNX1NUQVRVU19QQVVTRTsKCQlzbmRfcHJpbnRkZCgiU05EUlZfUENNX1BBVVNFX1BVU0hcbiIpOwoJCWJyZWFrOwoJY2FzZSBTTkRSVl9QQ01fVFJJR0dFUl9QQVVTRV9SRUxFQVNFOgoJCS8qIFRPRE8gKi8KCQlzdHJlYW0tPnN0YXR1cyA9IE1JWEFSVF9TVFJFQU1fU1RBVFVTX1JVTk5JTkc7CgkJc25kX3ByaW50ZGQoIlNORFJWX1BDTV9QQVVTRV9SRUxFQVNFXG4iKTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBtaXhhcnRfc3luY19ub25ibG9ja19ldmVudHMoc3RydWN0IG1peGFydF9tZ3IgKm1ncikKewoJdW5zaWduZWQgbG9uZyB0aW1lb3V0ID0gamlmZmllcyArIEhaOwoJd2hpbGUgKGF0b21pY19yZWFkKCZtZ3ItPm1zZ19wcm9jZXNzZWQpID4gMCkgewoJCWlmICh0aW1lX2FmdGVyKGppZmZpZXMsIHRpbWVvdXQpKSB7CgkJCXNuZF9wcmludGsoS0VSTl9FUlIgIm1peGFydDogY2Fubm90IHByb2Nlc3Mgbm9uYmxvY2sgZXZlbnRzIVxuIik7CgkJCXJldHVybiAtRUJVU1k7CgkJfQoJCXNjaGVkdWxlX3RpbWVvdXRfdW5pbnRlcnJ1cHRpYmxlKDEpOwoJfQoJcmV0dXJuIDA7Cn0KCi8qCiAqICBwcmVwYXJlIGNhbGxiYWNrIGZvciBhbGwgcGNtcwogKi8Kc3RhdGljIGludCBzbmRfbWl4YXJ0X3ByZXBhcmUoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzKQp7CglzdHJ1Y3Qgc25kX21peGFydCAqY2hpcCA9IHNuZF9wY21fc3Vic3RyZWFtX2NoaXAoc3Vicyk7CglzdHJ1Y3QgbWl4YXJ0X3N0cmVhbSAqc3RyZWFtID0gc3Vicy0+cnVudGltZS0+cHJpdmF0ZV9kYXRhOwoKCS8qIFRPRE8gZGUgZmHnb24gbm9uIGJsb3F1YW50ZSwgculhcHBsaXF1ZXIgbGVzIGh3X3BhcmFtcyAocmF0ZSwgYml0cywgY29kZWMpICovCgoJc25kX3ByaW50ZGQoInNuZF9taXhhcnRfcHJlcGFyZVxuIik7CgoJbWl4YXJ0X3N5bmNfbm9uYmxvY2tfZXZlbnRzKGNoaXAtPm1ncik7CgoJLyogb25seSB0aGUgZmlyc3Qgc3RyZWFtIGNhbiBjaG9vc2UgdGhlIHNhbXBsZSByYXRlICovCgkvKiB0aGUgZnVydGhlciBvcGVuZWQgc3RyZWFtcyB3aWxsIGJlIGxpbWl0ZWQgdG8gaXRzIGZyZXF1ZW5jeSAoc2VlIG9wZW4pICovCglpZihjaGlwLT5tZ3ItPnJlZl9jb3VudF9yYXRlID09IDEpCgkJY2hpcC0+bWdyLT5zYW1wbGVfcmF0ZSA9IHN1YnMtPnJ1bnRpbWUtPnJhdGU7CgoJLyogc2V0IHRoZSBjbG9jayBvbmx5IG9uY2UgKGZpcnN0IHN0cmVhbSkgb24gdGhlIHNhbWUgcGlwZSAqLwoJaWYoc3RyZWFtLT5waXBlLT5yZWZlcmVuY2VzID09IDEpIHsKCQlpZiggbWl4YXJ0X3NldF9jbG9jayhjaGlwLT5tZ3IsIHN0cmVhbS0+cGlwZSwgc3Vicy0+cnVudGltZS0+cmF0ZSkgKQoJCQlyZXR1cm4gLUVJTlZBTDsKCX0KCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgbWl4YXJ0X3NldF9mb3JtYXQoc3RydWN0IG1peGFydF9zdHJlYW0gKnN0cmVhbSwgc25kX3BjbV9mb3JtYXRfdCBmb3JtYXQpCnsKCWludCBlcnI7CglzdHJ1Y3Qgc25kX21peGFydCAqY2hpcDsKCXN0cnVjdCBtaXhhcnRfbXNnIHJlcXVlc3Q7CglzdHJ1Y3QgbWl4YXJ0X3N0cmVhbV9wYXJhbV9kZXNjIHN0cmVhbV9wYXJhbTsKCXN0cnVjdCBtaXhhcnRfcmV0dXJuX3VpZCByZXNwOwoKCWNoaXAgPSBzbmRfcGNtX3N1YnN0cmVhbV9jaGlwKHN0cmVhbS0+c3Vic3RyZWFtKTsKCgltZW1zZXQoJnN0cmVhbV9wYXJhbSwgMCwgc2l6ZW9mKHN0cmVhbV9wYXJhbSkpOwoKCXN0cmVhbV9wYXJhbS5jb2RpbmdfdHlwZSA9IENUX0xJTkVBUjsKCXN0cmVhbV9wYXJhbS5udW1iZXJfb2ZfY2hhbm5lbCA9IHN0cmVhbS0+Y2hhbm5lbHM7CgoJc3RyZWFtX3BhcmFtLnNhbXBsaW5nX2ZyZXEgPSBjaGlwLT5tZ3ItPnNhbXBsZV9yYXRlOwoJaWYoc3RyZWFtX3BhcmFtLnNhbXBsaW5nX2ZyZXEgPT0gMCkKCQlzdHJlYW1fcGFyYW0uc2FtcGxpbmdfZnJlcSA9IDQ0MTAwOyAvKiBpZiBmcmVxdWVuY3kgbm90IHlldCBkZWZpbmVkLCB1c2Ugc29tZSBkZWZhdWx0ICovCgoJc3dpdGNoKGZvcm1hdCl7CgljYXNlIFNORFJWX1BDTV9GT1JNQVRfVTg6CgkJc3RyZWFtX3BhcmFtLnNhbXBsZV90eXBlID0gU1RfSU5URUdFUl84OwoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfc2l6ZSA9IDg7CgkJYnJlYWs7CgljYXNlIFNORFJWX1BDTV9GT1JNQVRfUzE2X0xFOgoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfdHlwZSA9IFNUX0lOVEVHRVJfMTZMRTsKCQlzdHJlYW1fcGFyYW0uc2FtcGxlX3NpemUgPSAxNjsKCQlicmVhazsKCWNhc2UgU05EUlZfUENNX0ZPUk1BVF9TMTZfQkU6CgkJc3RyZWFtX3BhcmFtLnNhbXBsZV90eXBlID0gU1RfSU5URUdFUl8xNkJFOwoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfc2l6ZSA9IDE2OwoJCWJyZWFrOwoJY2FzZSBTTkRSVl9QQ01fRk9STUFUX1MyNF8zTEU6CgkJc3RyZWFtX3BhcmFtLnNhbXBsZV90eXBlID0gU1RfSU5URUdFUl8yNExFOwoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfc2l6ZSA9IDI0OwoJCWJyZWFrOwoJY2FzZSBTTkRSVl9QQ01fRk9STUFUX1MyNF8zQkU6CgkJc3RyZWFtX3BhcmFtLnNhbXBsZV90eXBlID0gU1RfSU5URUdFUl8yNEJFOwoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfc2l6ZSA9IDI0OwoJCWJyZWFrOwoJY2FzZSBTTkRSVl9QQ01fRk9STUFUX0ZMT0FUX0xFOgoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfdHlwZSA9IFNUX0ZMT0FUSU5HX1BPSU5UXzMyTEU7CgkJc3RyZWFtX3BhcmFtLnNhbXBsZV9zaXplID0gMzI7CgkJYnJlYWs7CgljYXNlICBTTkRSVl9QQ01fRk9STUFUX0ZMT0FUX0JFOgoJCXN0cmVhbV9wYXJhbS5zYW1wbGVfdHlwZSA9IFNUX0ZMT0FUSU5HX1BPSU5UXzMyQkU7CgkJc3RyZWFtX3BhcmFtLnNhbXBsZV9zaXplID0gMzI7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXNuZF9wcmludGsoS0VSTl9FUlIgImVycm9yIG1peGFydF9zZXRfZm9ybWF0KCkgOiB1bmtub3duIGZvcm1hdFxuIik7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJc25kX3ByaW50ZGQoInNldCBTTkRSVl9QQ01fRk9STUFUIHNhbXBsZV90eXBlKCVkKSBzYW1wbGVfc2l6ZSglZCkgZnJlcSglZCkgY2hhbm5lbHMoJWQpXG4iLAoJCSAgIHN0cmVhbV9wYXJhbS5zYW1wbGVfdHlwZSwgc3RyZWFtX3BhcmFtLnNhbXBsZV9zaXplLCBzdHJlYW1fcGFyYW0uc2FtcGxpbmdfZnJlcSwgc3RyZWFtLT5jaGFubmVscyk7CgoJLyogVE9ETzogd2hhdCBlbHNlIHRvIGNvbmZpZ3VyZSA/ICovCgkvKiBzdHJlYW1fcGFyYW0uc2FtcGxlc19wZXJfZnJhbWUgPSAyOyAqLwoJLyogc3RyZWFtX3BhcmFtLmJ5dGVzX3Blcl9mcmFtZSA9IDQ7ICovCgkvKiBzdHJlYW1fcGFyYW0uYnl0ZXNfcGVyX3NhbXBsZSA9IDI7ICovCgoJc3RyZWFtX3BhcmFtLnBpcGVfY291bnQgPSAxOyAgICAgIC8qIHNldCB0byAxICovCglzdHJlYW1fcGFyYW0uc3RyZWFtX2NvdW50ID0gMTsgICAgLyogc2V0IHRvIDEgKi8KCXN0cmVhbV9wYXJhbS5zdHJlYW1fZGVzY1swXS51aWRfcGlwZSA9IHN0cmVhbS0+cGlwZS0+Z3JvdXBfdWlkOwoJc3RyZWFtX3BhcmFtLnN0cmVhbV9kZXNjWzBdLnN0cmVhbV9pZHggPSBzdHJlYW0tPnN1YnN0cmVhbS0+bnVtYmVyOwoKCXJlcXVlc3QubWVzc2FnZV9pZCA9IE1TR19TVFJFQU1fU0VUX0lOUFVUX1NUQUdFX1BBUkFNOwoJcmVxdWVzdC51aWQgPSAoc3RydWN0IG1peGFydF91aWQpezAsMH07CglyZXF1ZXN0LmRhdGEgPSAmc3RyZWFtX3BhcmFtOwoJcmVxdWVzdC5zaXplID0gc2l6ZW9mKHN0cmVhbV9wYXJhbSk7CgoJZXJyID0gc25kX21peGFydF9zZW5kX21zZyhjaGlwLT5tZ3IsICZyZXF1ZXN0LCBzaXplb2YocmVzcCksICZyZXNwKTsKCWlmKChlcnIgPCAwKSB8fCByZXNwLmVycm9yX2NvZGUpIHsKCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJNU0dfU1RSRUFNX1NFVF9JTlBVVF9TVEFHRV9QQVJBTSBlcnI9JXg7IHJlc3A9JXhcbiIsIGVyciwgcmVzcC5lcnJvcl9jb2RlKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCXJldHVybiAwOwp9CgoKLyoKICogIEhXX1BBUkFNUyBjYWxsYmFjayBmb3IgYWxsIHBjbXMKICovCnN0YXRpYyBpbnQgc25kX21peGFydF9od19wYXJhbXMoc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzbmRfcGNtX2h3X3BhcmFtcyAqaHcpCnsKCXN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwID0gc25kX3BjbV9zdWJzdHJlYW1fY2hpcChzdWJzKTsKCXN0cnVjdCBtaXhhcnRfbWdyICptZ3IgPSBjaGlwLT5tZ3I7CglzdHJ1Y3QgbWl4YXJ0X3N0cmVhbSAqc3RyZWFtID0gc3Vicy0+cnVudGltZS0+cHJpdmF0ZV9kYXRhOwoJc25kX3BjbV9mb3JtYXRfdCBmb3JtYXQ7CglpbnQgZXJyOwoJaW50IGNoYW5uZWxzOwoKCS8qIHNldCB1cCBjaGFubmVscyAqLwoJY2hhbm5lbHMgPSBwYXJhbXNfY2hhbm5lbHMoaHcpOwoKCS8qICBzZXQgdXAgZm9ybWF0IGZvciB0aGUgc3RyZWFtICovCglmb3JtYXQgPSBwYXJhbXNfZm9ybWF0KGh3KTsKCgltdXRleF9sb2NrKCZtZ3ItPnNldHVwX211dGV4KTsKCgkvKiB1cGRhdGUgdGhlIHN0cmVhbSBsZXZlbHMgKi8KCWlmKCBzdHJlYW0tPnBjbV9udW1iZXIgPD0gTUlYQVJUX1BDTV9ESUdJVEFMICkgewoJCWludCBpc19hZXMgPSBzdHJlYW0tPnBjbV9udW1iZXIgPiBNSVhBUlRfUENNX0FOQUxPRzsKCQlpZiggc3Vicy0+c3RyZWFtID09IFNORFJWX1BDTV9TVFJFQU1fUExBWUJBQ0sgKQoJCQltaXhhcnRfdXBkYXRlX3BsYXliYWNrX3N0cmVhbV9sZXZlbChjaGlwLCBpc19hZXMsIHN1YnMtPm51bWJlcik7CgkJZWxzZQoJCQltaXhhcnRfdXBkYXRlX2NhcHR1cmVfc3RyZWFtX2xldmVsKCBjaGlwLCBpc19hZXMpOwoJfQoKCXN0cmVhbS0+Y2hhbm5lbHMgPSBjaGFubmVsczsKCgkvKiBzZXQgdGhlIGZvcm1hdCB0byB0aGUgYm9hcmQgKi8KCWVyciA9IG1peGFydF9zZXRfZm9ybWF0KHN0cmVhbSwgZm9ybWF0KTsKCWlmKGVyciA8IDApIHsKCQlyZXR1cm4gZXJyOwoJfQoKCS8qIGFsbG9jYXRlIGJ1ZmZlciAqLwoJZXJyID0gc25kX3BjbV9saWJfbWFsbG9jX3BhZ2VzKHN1YnMsIHBhcmFtc19idWZmZXJfYnl0ZXMoaHcpKTsKCglpZiAoZXJyID4gMCkgewoJCXN0cnVjdCBtaXhhcnRfYnVmZmVyaW5mbyAqYnVmZmVyaW5mbzsKCQlpbnQgaSA9IChjaGlwLT5jaGlwX2lkeCAqIE1JWEFSVF9NQVhfU1RSRUFNX1BFUl9DQVJEKSArIChzdHJlYW0tPnBjbV9udW1iZXIgKiAoTUlYQVJUX1BMQVlCQUNLX1NUUkVBTVMrTUlYQVJUX0NBUFRVUkVfU1RSRUFNUykpICsgc3Vicy0+bnVtYmVyOwoJCWlmKCBzdWJzLT5zdHJlYW0gPT0gU05EUlZfUENNX1NUUkVBTV9DQVBUVVJFICkgewoJCQlpICs9IE1JWEFSVF9QTEFZQkFDS19TVFJFQU1TOyAvKiBpbiBhcnJheSBjYXB0dXJlIGlzIGJlaGluZCBwbGF5YmFjayAqLwoJCX0KCQkKCQlidWZmZXJpbmZvID0gKHN0cnVjdCBtaXhhcnRfYnVmZmVyaW5mbyAqKWNoaXAtPm1nci0+YnVmZmVyaW5mby5hcmVhOwoJCWJ1ZmZlcmluZm9baV0uYnVmZmVyX2FkZHJlc3MgPSBzdWJzLT5ydW50aW1lLT5kbWFfYWRkcjsKCQlidWZmZXJpbmZvW2ldLmF2YWlsYWJsZV9sZW5ndGggPSBzdWJzLT5ydW50aW1lLT5kbWFfYnl0ZXM7CgkJLyogYnVmZmVyaW5mb1tpXS5idWZmZXJfaWQgIGlzIGFscmVhZHkgZGVmaW5lZCAqLwoKCQlzbmRfcHJpbnRkZCgic25kX21peGFydF9od19wYXJhbXMocGNtICVkKSA6IGRtYV9hZGRyKCV4KSBkbWFfYnl0ZXMoJXgpIHN1YnMtbnVtYmVyKCVkKVxuIiwgaSwKCQkJCWJ1ZmZlcmluZm9baV0uYnVmZmVyX2FkZHJlc3MsCgkJCQlidWZmZXJpbmZvW2ldLmF2YWlsYWJsZV9sZW5ndGgsCgkJCQlzdWJzLT5udW1iZXIpOwoJfQoJbXV0ZXhfdW5sb2NrKCZtZ3ItPnNldHVwX211dGV4KTsKCglyZXR1cm4gZXJyOwp9CgpzdGF0aWMgaW50IHNuZF9taXhhcnRfaHdfZnJlZShzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnMpCnsKCXN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwID0gc25kX3BjbV9zdWJzdHJlYW1fY2hpcChzdWJzKTsKCXNuZF9wY21fbGliX2ZyZWVfcGFnZXMoc3Vicyk7CgltaXhhcnRfc3luY19ub25ibG9ja19ldmVudHMoY2hpcC0+bWdyKTsKCXJldHVybiAwOwp9CgoKCi8qCiAqICBUT0RPIENPTkZJR1VSQVRJT04gU1BBQ0UgZm9yIGFsbCBwY21zLCBtb25vIHBjbSBtdXN0IHVwZGF0ZSBjaGFubmVsc19tYXgKICovCnN0YXRpYyBzdHJ1Y3Qgc25kX3BjbV9oYXJkd2FyZSBzbmRfbWl4YXJ0X2FuYWxvZ19jYXBzID0KewoJLmluZm8gICAgICAgICAgICAgPSAoIFNORFJWX1BDTV9JTkZPX01NQVAgfCBTTkRSVl9QQ01fSU5GT19JTlRFUkxFQVZFRCB8CgkJCSAgICAgIFNORFJWX1BDTV9JTkZPX01NQVBfVkFMSUQgfCBTTkRSVl9QQ01fSU5GT19TWU5DX1NUQVJUIHwKCQkJICAgICAgU05EUlZfUENNX0lORk9fUEFVU0UpLAoJLmZvcm1hdHMJICA9ICggU05EUlZfUENNX0ZNVEJJVF9VOCB8CgkJCSAgICAgIFNORFJWX1BDTV9GTVRCSVRfUzE2X0xFIHwgU05EUlZfUENNX0ZNVEJJVF9TMTZfQkUgfAoJCQkgICAgICBTTkRSVl9QQ01fRk1UQklUX1MyNF8zTEUgfCBTTkRSVl9QQ01fRk1UQklUX1MyNF8zQkUgfAoJCQkgICAgICBTTkRSVl9QQ01fRk1UQklUX0ZMT0FUX0xFIHwgU05EUlZfUENNX0ZNVEJJVF9GTE9BVF9CRSApLAoJLnJhdGVzICAgICAgICAgICAgPSBTTkRSVl9QQ01fUkFURV9DT05USU5VT1VTIHwgU05EUlZfUENNX1JBVEVfODAwMF80ODAwMCwKCS5yYXRlX21pbiAgICAgICAgID0gODAwMCwKCS5yYXRlX21heCAgICAgICAgID0gNDgwMDAsCgkuY2hhbm5lbHNfbWluICAgICA9IDEsCgkuY2hhbm5lbHNfbWF4ICAgICA9IDIsCgkuYnVmZmVyX2J5dGVzX21heCA9ICgzMioxMDI0KSwKCS5wZXJpb2RfYnl0ZXNfbWluID0gMjU2LCAgICAgICAgICAgICAgICAgIC8qIDI1NiBmcmFtZXMgVTggbW9ubyovCgkucGVyaW9kX2J5dGVzX21heCA9ICgxNioxMDI0KSwKCS5wZXJpb2RzX21pbiAgICAgID0gMiwKCS5wZXJpb2RzX21heCAgICAgID0gKDMyKjEwMjQvMjU2KSwKfTsKCnN0YXRpYyBzdHJ1Y3Qgc25kX3BjbV9oYXJkd2FyZSBzbmRfbWl4YXJ0X2RpZ2l0YWxfY2FwcyA9CnsKCS5pbmZvICAgICAgICAgICAgID0gKCBTTkRSVl9QQ01fSU5GT19NTUFQIHwgU05EUlZfUENNX0lORk9fSU5URVJMRUFWRUQgfAoJCQkgICAgICBTTkRSVl9QQ01fSU5GT19NTUFQX1ZBTElEIHwgU05EUlZfUENNX0lORk9fU1lOQ19TVEFSVCB8CgkJCSAgICAgIFNORFJWX1BDTV9JTkZPX1BBVVNFKSwKCS5mb3JtYXRzCSAgPSAoIFNORFJWX1BDTV9GTVRCSVRfVTggfAoJCQkgICAgICBTTkRSVl9QQ01fRk1UQklUX1MxNl9MRSB8IFNORFJWX1BDTV9GTVRCSVRfUzE2X0JFIHwKCQkJICAgICAgU05EUlZfUENNX0ZNVEJJVF9TMjRfM0xFIHwgU05EUlZfUENNX0ZNVEJJVF9TMjRfM0JFIHwKCQkJICAgICAgU05EUlZfUENNX0ZNVEJJVF9GTE9BVF9MRSB8IFNORFJWX1BDTV9GTVRCSVRfRkxPQVRfQkUgKSwKCS5yYXRlcyAgICAgICAgICAgID0gU05EUlZfUENNX1JBVEVfMzIwMDAgfCBTTkRSVl9QQ01fUkFURV80NDEwMCB8IFNORFJWX1BDTV9SQVRFXzQ4MDAwLAoJLnJhdGVfbWluICAgICAgICAgPSAzMjAwMCwKCS5yYXRlX21heCAgICAgICAgID0gNDgwMDAsCgkuY2hhbm5lbHNfbWluICAgICA9IDEsCgkuY2hhbm5lbHNfbWF4ICAgICA9IDIsCgkuYnVmZmVyX2J5dGVzX21heCA9ICgzMioxMDI0KSwKCS5wZXJpb2RfYnl0ZXNfbWluID0gMjU2LCAgICAgICAgICAgICAgICAgIC8qIDI1NiBmcmFtZXMgVTggbW9ubyovCgkucGVyaW9kX2J5dGVzX21heCA9ICgxNioxMDI0KSwKCS5wZXJpb2RzX21pbiAgICAgID0gMiwKCS5wZXJpb2RzX21heCAgICAgID0gKDMyKjEwMjQvMjU2KSwKfTsKCgpzdGF0aWMgaW50IHNuZF9taXhhcnRfcGxheWJhY2tfb3BlbihzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnMpCnsKCXN0cnVjdCBzbmRfbWl4YXJ0ICAgICAgICAgICAgKmNoaXAgPSBzbmRfcGNtX3N1YnN0cmVhbV9jaGlwKHN1YnMpOwoJc3RydWN0IG1peGFydF9tZ3IgICAgICAgICptZ3IgPSBjaGlwLT5tZ3I7CglzdHJ1Y3Qgc25kX3BjbV9ydW50aW1lICpydW50aW1lID0gc3Vicy0+cnVudGltZTsKCXN0cnVjdCBzbmRfcGNtICpwY20gPSBzdWJzLT5wY207CglzdHJ1Y3QgbWl4YXJ0X3N0cmVhbSAgICAgKnN0cmVhbTsKCXN0cnVjdCBtaXhhcnRfcGlwZSAgICAgICAqcGlwZTsKCWludCBlcnIgPSAwOwoJaW50IHBjbV9udW1iZXI7CgoJbXV0ZXhfbG9jaygmbWdyLT5zZXR1cF9tdXRleCk7CgoJaWYgKCBwY20gPT0gY2hpcC0+cGNtICkgewoJCXBjbV9udW1iZXIgPSBNSVhBUlRfUENNX0FOQUxPRzsKCQlydW50aW1lLT5odyA9IHNuZF9taXhhcnRfYW5hbG9nX2NhcHM7Cgl9IGVsc2UgewoJCXNuZF9hc3NlcnQgKCBwY20gPT0gY2hpcC0+cGNtX2RpZyApOyAKCQlwY21fbnVtYmVyID0gTUlYQVJUX1BDTV9ESUdJVEFMOwoJCXJ1bnRpbWUtPmh3ID0gc25kX21peGFydF9kaWdpdGFsX2NhcHM7Cgl9CglzbmRfcHJpbnRkZCgic25kX21peGFydF9wbGF5YmFja19vcGVuIEMlZC9QJWQvU3ViJWRcbiIsIGNoaXAtPmNoaXBfaWR4LCBwY21fbnVtYmVyLCBzdWJzLT5udW1iZXIpOwoKCS8qIGdldCBzdHJlYW0gaW5mbyAqLwoJc3RyZWFtID0gJihjaGlwLT5wbGF5YmFja19zdHJlYW1bcGNtX251bWJlcl1bc3Vicy0+bnVtYmVyXSk7CgoJaWYgKHN0cmVhbS0+c3RhdHVzICE9IE1JWEFSVF9TVFJFQU1fU1RBVFVTX0ZSRUUpewoJCS8qIHN0cmVhbXMgaW4gdXNlICovCgkJc25kX3ByaW50ayhLRVJOX0VSUiAic25kX21peGFydF9wbGF5YmFja19vcGVuIEMlZC9QJWQvU3ViJWQgaW4gdXNlXG4iLCBjaGlwLT5jaGlwX2lkeCwgcGNtX251bWJlciwgc3Vicy0+bnVtYmVyKTsKCQllcnIgPSAtRUJVU1k7CgkJZ290byBfZXhpdF9vcGVuOwoJfQoKCS8qIGdldCBwaXBlIHBvaW50ZXIgKG91dCBwaXBlKSAqLwoJcGlwZSA9IHNuZF9taXhhcnRfYWRkX3JlZl9waXBlKGNoaXAsIHBjbV9udW1iZXIsIDAsIDApOwoKCWlmIChwaXBlID09IE5VTEwpIHsKCQllcnIgPSAtRUlOVkFMOwoJCWdvdG8gX2V4aXRfb3BlbjsKCX0KCgkvKiBzdGFydCB0aGUgcGlwZSBpZiBuZWNlc3NhcnkgKi8KCWVyciA9IG1peGFydF9zZXRfcGlwZV9zdGF0ZShjaGlwLT5tZ3IsIHBpcGUsIDEpOwoJaWYoIGVyciA8IDAgKSB7CgkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3Igc3RhcnRpbmcgcGlwZSFcbiIpOwoJCXNuZF9taXhhcnRfa2lsbF9yZWZfcGlwZShjaGlwLT5tZ3IsIHBpcGUsIDApOwoJCWVyciA9IC1FSU5WQUw7CgkJZ290byBfZXhpdF9vcGVuOwoJfQoKCXN0cmVhbS0+cGlwZSAgICAgICAgPSBwaXBlOwoJc3RyZWFtLT5wY21fbnVtYmVyICA9IHBjbV9udW1iZXI7CglzdHJlYW0tPnN0YXR1cyAgICAgID0gTUlYQVJUX1NUUkVBTV9TVEFUVVNfT1BFTjsKCXN0cmVhbS0+c3Vic3RyZWFtICAgPSBzdWJzOwoJc3RyZWFtLT5jaGFubmVscyAgICA9IDA7IC8qIG5vdCBjb25maWd1cmVkIHlldCAqLwoKCXJ1bnRpbWUtPnByaXZhdGVfZGF0YSA9IHN0cmVhbTsKCglzbmRfcGNtX2h3X2NvbnN0cmFpbnRfc3RlcChydW50aW1lLCAwLCBTTkRSVl9QQ01fSFdfUEFSQU1fUEVSSU9EX0JZVEVTLCAzMik7CglzbmRfcGNtX2h3X2NvbnN0cmFpbnRfc3RlcChydW50aW1lLCAwLCBTTkRSVl9QQ01fSFdfUEFSQU1fQlVGRkVSX1NJWkUsIDY0KTsKCgkvKiBpZiBhIHNhbXBsZSByYXRlIGlzIGFscmVhZHkgdXNlZCwgYW5vdGhlciBzdHJlYW0gY2Fubm90IGNoYW5nZSAqLwoJaWYobWdyLT5yZWZfY291bnRfcmF0ZSsrKSB7CgkJaWYobWdyLT5zYW1wbGVfcmF0ZSkgewoJCQlydW50aW1lLT5ody5yYXRlX21pbiA9IHJ1bnRpbWUtPmh3LnJhdGVfbWF4ID0gbWdyLT5zYW1wbGVfcmF0ZTsKCQl9Cgl9CgogX2V4aXRfb3BlbjoKCW11dGV4X3VubG9jaygmbWdyLT5zZXR1cF9tdXRleCk7CgoJcmV0dXJuIGVycjsKfQoKCnN0YXRpYyBpbnQgc25kX21peGFydF9jYXB0dXJlX29wZW4oc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzKQp7CglzdHJ1Y3Qgc25kX21peGFydCAgICAgICAgICAgICpjaGlwID0gc25kX3BjbV9zdWJzdHJlYW1fY2hpcChzdWJzKTsKCXN0cnVjdCBtaXhhcnRfbWdyICAgICAgICAqbWdyID0gY2hpcC0+bWdyOwoJc3RydWN0IHNuZF9wY21fcnVudGltZSAqcnVudGltZSA9IHN1YnMtPnJ1bnRpbWU7CglzdHJ1Y3Qgc25kX3BjbSAqcGNtID0gc3Vicy0+cGNtOwoJc3RydWN0IG1peGFydF9zdHJlYW0gICAgICpzdHJlYW07CglzdHJ1Y3QgbWl4YXJ0X3BpcGUgICAgICAgKnBpcGU7CglpbnQgZXJyID0gMDsKCWludCBwY21fbnVtYmVyOwoKCW11dGV4X2xvY2soJm1nci0+c2V0dXBfbXV0ZXgpOwoKCWlmICggcGNtID09IGNoaXAtPnBjbSApIHsKCQlwY21fbnVtYmVyID0gTUlYQVJUX1BDTV9BTkFMT0c7CgkJcnVudGltZS0+aHcgPSBzbmRfbWl4YXJ0X2FuYWxvZ19jYXBzOwoJfSBlbHNlIHsKCQlzbmRfYXNzZXJ0ICggcGNtID09IGNoaXAtPnBjbV9kaWcgKTsgCgkJcGNtX251bWJlciA9IE1JWEFSVF9QQ01fRElHSVRBTDsKCQlydW50aW1lLT5odyA9IHNuZF9taXhhcnRfZGlnaXRhbF9jYXBzOwoJfQoKCXJ1bnRpbWUtPmh3LmNoYW5uZWxzX21pbiA9IDI7IC8qIGZvciBpbnN0YW5jZSwgbm8gbW9ubyAqLwoKCXNuZF9wcmludGRkKCJzbmRfbWl4YXJ0X2NhcHR1cmVfb3BlbiBDJWQvUCVkL1N1YiVkXG4iLCBjaGlwLT5jaGlwX2lkeCwgcGNtX251bWJlciwgc3Vicy0+bnVtYmVyKTsKCgkvKiBnZXQgc3RyZWFtIGluZm8gKi8KCXN0cmVhbSA9ICYoY2hpcC0+Y2FwdHVyZV9zdHJlYW1bcGNtX251bWJlcl0pOwoKCWlmIChzdHJlYW0tPnN0YXR1cyAhPSBNSVhBUlRfU1RSRUFNX1NUQVRVU19GUkVFKXsKCQkvKiBzdHJlYW1zIGluIHVzZSAqLwoJCXNuZF9wcmludGsoS0VSTl9FUlIgInNuZF9taXhhcnRfY2FwdHVyZV9vcGVuIEMlZC9QJWQvU3ViJWQgaW4gdXNlXG4iLCBjaGlwLT5jaGlwX2lkeCwgcGNtX251bWJlciwgc3Vicy0+bnVtYmVyKTsKCQllcnIgPSAtRUJVU1k7CgkJZ290byBfZXhpdF9vcGVuOwoJfQoKCS8qIGdldCBwaXBlIHBvaW50ZXIgKGluIHBpcGUpICovCglwaXBlID0gc25kX21peGFydF9hZGRfcmVmX3BpcGUoY2hpcCwgcGNtX251bWJlciwgMSwgMCk7CgoJaWYgKHBpcGUgPT0gTlVMTCkgewoJCWVyciA9IC1FSU5WQUw7CgkJZ290byBfZXhpdF9vcGVuOwoJfQoKCS8qIHN0YXJ0IHRoZSBwaXBlIGlmIG5lY2Vzc2FyeSAqLwoJZXJyID0gbWl4YXJ0X3NldF9waXBlX3N0YXRlKGNoaXAtPm1nciwgcGlwZSwgMSk7CglpZiggZXJyIDwgMCApIHsKCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJlcnJvciBzdGFydGluZyBwaXBlIVxuIik7CgkJc25kX21peGFydF9raWxsX3JlZl9waXBlKGNoaXAtPm1nciwgcGlwZSwgMCk7CgkJZXJyID0gLUVJTlZBTDsKCQlnb3RvIF9leGl0X29wZW47Cgl9CgoJc3RyZWFtLT5waXBlICAgICAgICA9IHBpcGU7CglzdHJlYW0tPnBjbV9udW1iZXIgID0gcGNtX251bWJlcjsKCXN0cmVhbS0+c3RhdHVzICAgICAgPSBNSVhBUlRfU1RSRUFNX1NUQVRVU19PUEVOOwoJc3RyZWFtLT5zdWJzdHJlYW0gICA9IHN1YnM7CglzdHJlYW0tPmNoYW5uZWxzICAgID0gMDsgLyogbm90IGNvbmZpZ3VyZWQgeWV0ICovCgoJcnVudGltZS0+cHJpdmF0ZV9kYXRhID0gc3RyZWFtOwoKCXNuZF9wY21faHdfY29uc3RyYWludF9zdGVwKHJ1bnRpbWUsIDAsIFNORFJWX1BDTV9IV19QQVJBTV9QRVJJT0RfQllURVMsIDMyKTsKCXNuZF9wY21faHdfY29uc3RyYWludF9zdGVwKHJ1bnRpbWUsIDAsIFNORFJWX1BDTV9IV19QQVJBTV9CVUZGRVJfU0laRSwgNjQpOwoKCS8qIGlmIGEgc2FtcGxlIHJhdGUgaXMgYWxyZWFkeSB1c2VkLCBhbm90aGVyIHN0cmVhbSBjYW5ub3QgY2hhbmdlICovCglpZihtZ3ItPnJlZl9jb3VudF9yYXRlKyspIHsKCQlpZihtZ3ItPnNhbXBsZV9yYXRlKSB7CgkJCXJ1bnRpbWUtPmh3LnJhdGVfbWluID0gcnVudGltZS0+aHcucmF0ZV9tYXggPSBtZ3ItPnNhbXBsZV9yYXRlOwoJCX0KCX0KCiBfZXhpdF9vcGVuOgoJbXV0ZXhfdW5sb2NrKCZtZ3ItPnNldHVwX211dGV4KTsKCglyZXR1cm4gZXJyOwp9CgoKCnN0YXRpYyBpbnQgc25kX21peGFydF9jbG9zZShzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnMpCnsKCXN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwID0gc25kX3BjbV9zdWJzdHJlYW1fY2hpcChzdWJzKTsKCXN0cnVjdCBtaXhhcnRfbWdyICptZ3IgPSBjaGlwLT5tZ3I7CglzdHJ1Y3QgbWl4YXJ0X3N0cmVhbSAqc3RyZWFtID0gc3Vicy0+cnVudGltZS0+cHJpdmF0ZV9kYXRhOwoKCW11dGV4X2xvY2soJm1nci0+c2V0dXBfbXV0ZXgpOwoKCXNuZF9wcmludGRkKCJzbmRfbWl4YXJ0X2Nsb3NlIEMlZC9QJWQvU3ViJWRcbiIsIGNoaXAtPmNoaXBfaWR4LCBzdHJlYW0tPnBjbV9udW1iZXIsIHN1YnMtPm51bWJlcik7CgoJLyogc2FtcGxlIHJhdGUgcmVsZWFzZWQgKi8KCWlmKC0tbWdyLT5yZWZfY291bnRfcmF0ZSA9PSAwKSB7CgkJbWdyLT5zYW1wbGVfcmF0ZSA9IDA7Cgl9CgoJLyogZGVsZXRlIHBpcGUgKi8KCWlmIChzbmRfbWl4YXJ0X2tpbGxfcmVmX3BpcGUobWdyLCBzdHJlYW0tPnBpcGUsIDAgKSA8IDApIHsKCgkJc25kX3ByaW50ayhLRVJOX0VSUiAiZXJyb3Igc25kX21peGFydF9raWxsX3JlZl9waXBlIEMlZFAlZFxuIiwgY2hpcC0+Y2hpcF9pZHgsIHN0cmVhbS0+cGNtX251bWJlcik7Cgl9CgoJc3RyZWFtLT5waXBlICAgICAgPSBOVUxMOwoJc3RyZWFtLT5zdGF0dXMgICAgPSBNSVhBUlRfU1RSRUFNX1NUQVRVU19GUkVFOwoJc3RyZWFtLT5zdWJzdHJlYW0gPSBOVUxMOwoKCW11dGV4X3VubG9jaygmbWdyLT5zZXR1cF9tdXRleCk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyBzbmRfcGNtX3VmcmFtZXNfdCBzbmRfbWl4YXJ0X3N0cmVhbV9wb2ludGVyKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3VicykKewoJc3RydWN0IHNuZF9wY21fcnVudGltZSAqcnVudGltZSA9IHN1YnMtPnJ1bnRpbWU7CglzdHJ1Y3QgbWl4YXJ0X3N0cmVhbSAgICpzdHJlYW0gID0gcnVudGltZS0+cHJpdmF0ZV9kYXRhOwoKCXJldHVybiAoc25kX3BjbV91ZnJhbWVzX3QpKChzdHJlYW0tPmJ1Zl9wZXJpb2RzICogcnVudGltZS0+cGVyaW9kX3NpemUpICsgc3RyZWFtLT5idWZfcGVyaW9kX2ZyYWcpOwp9CgoKCnN0YXRpYyBzdHJ1Y3Qgc25kX3BjbV9vcHMgc25kX21peGFydF9wbGF5YmFja19vcHMgPSB7Cgkub3BlbiAgICAgID0gc25kX21peGFydF9wbGF5YmFja19vcGVuLAoJLmNsb3NlICAgICA9IHNuZF9taXhhcnRfY2xvc2UsCgkuaW9jdGwgICAgID0gc25kX3BjbV9saWJfaW9jdGwsCgkucHJlcGFyZSAgID0gc25kX21peGFydF9wcmVwYXJlLAoJLmh3X3BhcmFtcyA9IHNuZF9taXhhcnRfaHdfcGFyYW1zLAoJLmh3X2ZyZWUgICA9IHNuZF9taXhhcnRfaHdfZnJlZSwKCS50cmlnZ2VyICAgPSBzbmRfbWl4YXJ0X3RyaWdnZXIsCgkucG9pbnRlciAgID0gc25kX21peGFydF9zdHJlYW1fcG9pbnRlciwKfTsKCnN0YXRpYyBzdHJ1Y3Qgc25kX3BjbV9vcHMgc25kX21peGFydF9jYXB0dXJlX29wcyA9IHsKCS5vcGVuICAgICAgPSBzbmRfbWl4YXJ0X2NhcHR1cmVfb3BlbiwKCS5jbG9zZSAgICAgPSBzbmRfbWl4YXJ0X2Nsb3NlLAoJLmlvY3RsICAgICA9IHNuZF9wY21fbGliX2lvY3RsLAoJLnByZXBhcmUgICA9IHNuZF9taXhhcnRfcHJlcGFyZSwKCS5od19wYXJhbXMgPSBzbmRfbWl4YXJ0X2h3X3BhcmFtcywKCS5od19mcmVlICAgPSBzbmRfbWl4YXJ0X2h3X2ZyZWUsCgkudHJpZ2dlciAgID0gc25kX21peGFydF90cmlnZ2VyLAoJLnBvaW50ZXIgICA9IHNuZF9taXhhcnRfc3RyZWFtX3BvaW50ZXIsCn07CgpzdGF0aWMgdm9pZCBwcmVhbGxvY2F0ZV9idWZmZXJzKHN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwLCBzdHJ1Y3Qgc25kX3BjbSAqcGNtKQp7CiNpZiAwCglzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKnN1YnM7CglpbnQgc3RyZWFtOwoKCWZvciAoc3RyZWFtID0gMDsgc3RyZWFtIDwgMjsgc3RyZWFtKyspIHsKCQlpbnQgaWR4ID0gMDsKCQlmb3IgKHN1YnMgPSBwY20tPnN0cmVhbXNbc3RyZWFtXS5zdWJzdHJlYW07IHN1YnM7IHN1YnMgPSBzdWJzLT5uZXh0LCBpZHgrKykKCQkJLyogc2V0IHVwIHRoZSB1bmlxdWUgZGV2aWNlIGlkIHdpdGggdGhlIGNoaXAgaW5kZXggKi8KCQkJc3Vicy0+ZG1hX2RldmljZS5pZCA9IHN1YnMtPnBjbS0+ZGV2aWNlIDw8IDE2IHwKCQkJCXN1YnMtPnN0cmVhbSA8PCA4IHwgKHN1YnMtPm51bWJlciArIDEpIHwKCQkJCShjaGlwLT5jaGlwX2lkeCArIDEpIDw8IDI0OwoJfQojZW5kaWYKCXNuZF9wY21fbGliX3ByZWFsbG9jYXRlX3BhZ2VzX2Zvcl9hbGwocGNtLCBTTkRSVl9ETUFfVFlQRV9ERVYsCgkJCQkJICAgICAgc25kX2RtYV9wY2lfZGF0YShjaGlwLT5tZ3ItPnBjaSksIDMyKjEwMjQsIDMyKjEwMjQpOwp9CgovKgogKi8Kc3RhdGljIGludCBzbmRfbWl4YXJ0X3BjbV9hbmFsb2coc3RydWN0IHNuZF9taXhhcnQgKmNoaXApCnsKCWludCBlcnI7CglzdHJ1Y3Qgc25kX3BjbSAqcGNtOwoJY2hhciBuYW1lWzMyXTsKCglzcHJpbnRmKG5hbWUsICJtaVhhcnQgYW5hbG9nICVkIiwgY2hpcC0+Y2hpcF9pZHgpOwoJaWYgKChlcnIgPSBzbmRfcGNtX25ldyhjaGlwLT5jYXJkLCBuYW1lLCBNSVhBUlRfUENNX0FOQUxPRywKCQkJICAgICAgIE1JWEFSVF9QTEFZQkFDS19TVFJFQU1TLAoJCQkgICAgICAgTUlYQVJUX0NBUFRVUkVfU1RSRUFNUywgJnBjbSkpIDwgMCkgewoJCXNuZF9wcmludGsoS0VSTl9FUlIgImNhbm5vdCBjcmVhdGUgdGhlIGFuYWxvZyBwY20gJWRcbiIsIGNoaXAtPmNoaXBfaWR4KTsKCQlyZXR1cm4gZXJyOwoJfQoKCXBjbS0+cHJpdmF0ZV9kYXRhID0gY2hpcDsKCglzbmRfcGNtX3NldF9vcHMocGNtLCBTTkRSVl9QQ01fU1RSRUFNX1BMQVlCQUNLLCAmc25kX21peGFydF9wbGF5YmFja19vcHMpOwoJc25kX3BjbV9zZXRfb3BzKHBjbSwgU05EUlZfUENNX1NUUkVBTV9DQVBUVVJFLCAmc25kX21peGFydF9jYXB0dXJlX29wcyk7CgoJcGNtLT5pbmZvX2ZsYWdzID0gMDsKCXN0cmNweShwY20tPm5hbWUsIG5hbWUpOwoKCXByZWFsbG9jYXRlX2J1ZmZlcnMoY2hpcCwgcGNtKTsKCgljaGlwLT5wY20gPSBwY207CglyZXR1cm4gMDsKfQoKCi8qCiAqLwpzdGF0aWMgaW50IHNuZF9taXhhcnRfcGNtX2RpZ2l0YWwoc3RydWN0IHNuZF9taXhhcnQgKmNoaXApCnsKCWludCBlcnI7CglzdHJ1Y3Qgc25kX3BjbSAqcGNtOwoJY2hhciBuYW1lWzMyXTsKCglzcHJpbnRmKG5hbWUsICJtaVhhcnQgQUVTL0VCVSAlZCIsIGNoaXAtPmNoaXBfaWR4KTsKCWlmICgoZXJyID0gc25kX3BjbV9uZXcoY2hpcC0+Y2FyZCwgbmFtZSwgTUlYQVJUX1BDTV9ESUdJVEFMLAoJCQkgICAgICAgTUlYQVJUX1BMQVlCQUNLX1NUUkVBTVMsCgkJCSAgICAgICBNSVhBUlRfQ0FQVFVSRV9TVFJFQU1TLCAmcGNtKSkgPCAwKSB7CgkJc25kX3ByaW50ayhLRVJOX0VSUiAiY2Fubm90IGNyZWF0ZSB0aGUgZGlnaXRhbCBwY20gJWRcbiIsIGNoaXAtPmNoaXBfaWR4KTsKCQlyZXR1cm4gZXJyOwoJfQoKCXBjbS0+cHJpdmF0ZV9kYXRhID0gY2hpcDsKCglzbmRfcGNtX3NldF9vcHMocGNtLCBTTkRSVl9QQ01fU1RSRUFNX1BMQVlCQUNLLCAmc25kX21peGFydF9wbGF5YmFja19vcHMpOwoJc25kX3BjbV9zZXRfb3BzKHBjbSwgU05EUlZfUENNX1NUUkVBTV9DQVBUVVJFLCAmc25kX21peGFydF9jYXB0dXJlX29wcyk7CgoJcGNtLT5pbmZvX2ZsYWdzID0gMDsKCXN0cmNweShwY20tPm5hbWUsIG5hbWUpOwoKCXByZWFsbG9jYXRlX2J1ZmZlcnMoY2hpcCwgcGNtKTsKCgljaGlwLT5wY21fZGlnID0gcGNtOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgc25kX21peGFydF9jaGlwX2ZyZWUoc3RydWN0IHNuZF9taXhhcnQgKmNoaXApCnsKCWtmcmVlKGNoaXApOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgc25kX21peGFydF9jaGlwX2Rldl9mcmVlKHN0cnVjdCBzbmRfZGV2aWNlICpkZXZpY2UpCnsKCXN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwID0gZGV2aWNlLT5kZXZpY2VfZGF0YTsKCXJldHVybiBzbmRfbWl4YXJ0X2NoaXBfZnJlZShjaGlwKTsKfQoKCi8qCiAqLwpzdGF0aWMgaW50IF9fZGV2aW5pdCBzbmRfbWl4YXJ0X2NyZWF0ZShzdHJ1Y3QgbWl4YXJ0X21nciAqbWdyLCBzdHJ1Y3Qgc25kX2NhcmQgKmNhcmQsIGludCBpZHgpCnsKCWludCBlcnI7CglzdHJ1Y3Qgc25kX21peGFydCAqY2hpcDsKCXN0YXRpYyBzdHJ1Y3Qgc25kX2RldmljZV9vcHMgb3BzID0gewoJCS5kZXZfZnJlZSA9IHNuZF9taXhhcnRfY2hpcF9kZXZfZnJlZSwKCX07CgoJbWdyLT5jaGlwW2lkeF0gPSBjaGlwID0ga3phbGxvYyhzaXplb2YoKmNoaXApLCBHRlBfS0VSTkVMKTsKCWlmICghIGNoaXApIHsKCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJjYW5ub3QgYWxsb2NhdGUgY2hpcFxuIik7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJY2hpcC0+Y2FyZCA9IGNhcmQ7CgljaGlwLT5jaGlwX2lkeCA9IGlkeDsKCWNoaXAtPm1nciA9IG1ncjsKCglpZiAoKGVyciA9IHNuZF9kZXZpY2VfbmV3KGNhcmQsIFNORFJWX0RFVl9MT1dMRVZFTCwgY2hpcCwgJm9wcykpIDwgMCkgewoJCXNuZF9taXhhcnRfY2hpcF9mcmVlKGNoaXApOwoJCXJldHVybiBlcnI7Cgl9CgoJc25kX2NhcmRfc2V0X2RldihjYXJkLCAmbWdyLT5wY2ktPmRldik7CgoJcmV0dXJuIDA7Cn0KCmludCBzbmRfbWl4YXJ0X2NyZWF0ZV9wY20oc3RydWN0IHNuZF9taXhhcnQqIGNoaXApCnsKCWludCBlcnI7CgoJZXJyID0gc25kX21peGFydF9wY21fYW5hbG9nKGNoaXApOwoJaWYgKGVyciA8IDApCgkJcmV0dXJuIGVycjsKCglpZihjaGlwLT5tZ3ItPmJvYXJkX3R5cGUgPT0gTUlYQVJUX0RBVUdIVEVSX1RZUEVfQUVTKSB7CgoJCWVyciA9IHNuZF9taXhhcnRfcGNtX2RpZ2l0YWwoY2hpcCk7CgkJaWYgKGVyciA8IDApCgkJCXJldHVybiBlcnI7Cgl9CglyZXR1cm4gZXJyOwp9CgoKLyoKICogcmVsZWFzZSBhbGwgdGhlIGNhcmRzIGFzc2lnbmVkIHRvIGEgbWFuYWdlciBpbnN0YW5jZQogKi8Kc3RhdGljIGludCBzbmRfbWl4YXJ0X2ZyZWUoc3RydWN0IG1peGFydF9tZ3IgKm1ncikKewoJdW5zaWduZWQgaW50IGk7CgoJZm9yIChpID0gMDsgaSA8IG1nci0+bnVtX2NhcmRzOyBpKyspIHsKCQlpZiAobWdyLT5jaGlwW2ldKQoJCQlzbmRfY2FyZF9mcmVlKG1nci0+Y2hpcFtpXS0+Y2FyZCk7Cgl9CgoJLyogc3RvcCBtYWlsYm94ICovCglzbmRfbWl4YXJ0X2V4aXRfbWFpbGJveChtZ3IpOwoKCS8qIHJlbGVhc2UgaXJxICAqLwoJaWYgKG1nci0+aXJxID49IDApCgkJZnJlZV9pcnEobWdyLT5pcnEsICh2b2lkICopbWdyKTsKCgkvKiByZXNldCBib2FyZCBpZiBzb21lIGZpcm13YXJlIHdhcyBsb2FkZWQgKi8KCWlmKG1nci0+ZHNwX2xvYWRlZCkgewoJCXNuZF9taXhhcnRfcmVzZXRfYm9hcmQobWdyKTsKCQlzbmRfcHJpbnRkZCgicmVzZXQgbWlYYXJ0ICFcbiIpOwoJfQoKCS8qIHJlbGVhc2UgdGhlIGkvbyBwb3J0cyAqLwoJZm9yIChpID0gMDsgaSA8IDI7IGkrKykgewoJCWlmIChtZ3ItPm1lbVtpXS52aXJ0KQoJCQlpb3VubWFwKG1nci0+bWVtW2ldLnZpcnQpOwoJfQoJcGNpX3JlbGVhc2VfcmVnaW9ucyhtZ3ItPnBjaSk7CgoJLyogZnJlZSBmbG93YXJyYXkgKi8KCWlmKG1nci0+Zmxvd2luZm8uYXJlYSkgewoJCXNuZF9kbWFfZnJlZV9wYWdlcygmbWdyLT5mbG93aW5mbyk7CgkJbWdyLT5mbG93aW5mby5hcmVhID0gTlVMTDsKCX0KCS8qIGZyZWUgYnVmZmVyYXJyYXkgKi8KCWlmKG1nci0+YnVmZmVyaW5mby5hcmVhKSB7CgkJc25kX2RtYV9mcmVlX3BhZ2VzKCZtZ3ItPmJ1ZmZlcmluZm8pOwoJCW1nci0+YnVmZmVyaW5mby5hcmVhID0gTlVMTDsKCX0KCglwY2lfZGlzYWJsZV9kZXZpY2UobWdyLT5wY2kpOwoJa2ZyZWUobWdyKTsKCXJldHVybiAwOwp9CgovKgogKiBwcm9jIGludGVyZmFjZQogKi8Kc3RhdGljIGxvbmcgbG9uZyBzbmRfbWl4YXJ0X0JBMF9sbHNlZWsoc3RydWN0IHNuZF9pbmZvX2VudHJ5ICplbnRyeSwKCQkJCSAgICAgICB2b2lkICpwcml2YXRlX2ZpbGVfZGF0YSwKCQkJCSAgICAgICBzdHJ1Y3QgZmlsZSAqZmlsZSwKCQkJCSAgICAgICBsb25nIGxvbmcgb2Zmc2V0LAoJCQkJICAgICAgIGludCBvcmlnKQp7CglvZmZzZXQgPSBvZmZzZXQgJiB+MzsgLyogNCBieXRlcyBhbGlnbmVkICovCgoJc3dpdGNoKG9yaWcpIHsKCWNhc2UgU0VFS19TRVQ6CgkJZmlsZS0+Zl9wb3MgPSBvZmZzZXQ7CgkJYnJlYWs7CgljYXNlIFNFRUtfQ1VSOgoJCWZpbGUtPmZfcG9zICs9IG9mZnNldDsKCQlicmVhazsKCWNhc2UgU0VFS19FTkQ6IC8qIG9mZnNldCBpcyBuZWdhdGl2ZSAqLwoJCWZpbGUtPmZfcG9zID0gTUlYQVJUX0JBMF9TSVpFICsgb2Zmc2V0OwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCWlmKGZpbGUtPmZfcG9zID4gTUlYQVJUX0JBMF9TSVpFKQoJCWZpbGUtPmZfcG9zID0gTUlYQVJUX0JBMF9TSVpFOwoJcmV0dXJuIGZpbGUtPmZfcG9zOwp9CgpzdGF0aWMgbG9uZyBsb25nIHNuZF9taXhhcnRfQkExX2xsc2VlayhzdHJ1Y3Qgc25kX2luZm9fZW50cnkgKmVudHJ5LAoJCQkJICAgICAgIHZvaWQgKnByaXZhdGVfZmlsZV9kYXRhLAoJCQkJICAgICAgIHN0cnVjdCBmaWxlICpmaWxlLAoJCQkJICAgICAgIGxvbmcgbG9uZyBvZmZzZXQsCgkJCQkgICAgICAgaW50IG9yaWcpCnsKCW9mZnNldCA9IG9mZnNldCAmIH4zOyAvKiA0IGJ5dGVzIGFsaWduZWQgKi8KCglzd2l0Y2gob3JpZykgewoJY2FzZSBTRUVLX1NFVDoKCQlmaWxlLT5mX3BvcyA9IG9mZnNldDsKCQlicmVhazsKCWNhc2UgU0VFS19DVVI6CgkJZmlsZS0+Zl9wb3MgKz0gb2Zmc2V0OwoJCWJyZWFrOwoJY2FzZSBTRUVLX0VORDogLyogb2Zmc2V0IGlzIG5lZ2F0aXZlICovCgkJZmlsZS0+Zl9wb3MgPSBNSVhBUlRfQkExX1NJWkUgKyBvZmZzZXQ7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXJldHVybiAtRUlOVkFMOwoJfQoJaWYoZmlsZS0+Zl9wb3MgPiBNSVhBUlRfQkExX1NJWkUpCgkJZmlsZS0+Zl9wb3MgPSBNSVhBUlRfQkExX1NJWkU7CglyZXR1cm4gZmlsZS0+Zl9wb3M7Cn0KCi8qCiAgbWl4YXJ0X0JBMCBwcm9jIGludGVyZmFjZSBmb3IgQkFSIDAgLSByZWFkIGNhbGxiYWNrCiAqLwpzdGF0aWMgbG9uZyBzbmRfbWl4YXJ0X0JBMF9yZWFkKHN0cnVjdCBzbmRfaW5mb19lbnRyeSAqZW50cnksIHZvaWQgKmZpbGVfcHJpdmF0ZV9kYXRhLAoJCQkJc3RydWN0IGZpbGUgKmZpbGUsIGNoYXIgX191c2VyICpidWYsCgkJCQl1bnNpZ25lZCBsb25nIGNvdW50LCB1bnNpZ25lZCBsb25nIHBvcykKewoJc3RydWN0IG1peGFydF9tZ3IgKm1nciA9IGVudHJ5LT5wcml2YXRlX2RhdGE7CgoJY291bnQgPSBjb3VudCAmIH4zOyAvKiBtYWtlIHN1cmUgdGhlIHJlYWQgc2l6ZSBpcyBhIG11bHRpcGxlIG9mIDQgYnl0ZXMgKi8KCWlmKGNvdW50IDw9IDApCgkJcmV0dXJuIDA7CglpZihwb3MgKyBjb3VudCA+IE1JWEFSVF9CQTBfU0laRSkKCQljb3VudCA9IChsb25nKShNSVhBUlRfQkEwX1NJWkUgLSBwb3MpOwoJaWYoY29weV90b191c2VyX2Zyb21pbyhidWYsIE1JWEFSVF9NRU0oIG1nciwgcG9zICksIGNvdW50KSkKCQlyZXR1cm4gLUVGQVVMVDsKCXJldHVybiBjb3VudDsKfQoKLyoKICBtaXhhcnRfQkExIHByb2MgaW50ZXJmYWNlIGZvciBCQVIgMSAtIHJlYWQgY2FsbGJhY2sKICovCnN0YXRpYyBsb25nIHNuZF9taXhhcnRfQkExX3JlYWQoc3RydWN0IHNuZF9pbmZvX2VudHJ5ICplbnRyeSwgdm9pZCAqZmlsZV9wcml2YXRlX2RhdGEsCgkJCQlzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1ZiwKCQkJCXVuc2lnbmVkIGxvbmcgY291bnQsIHVuc2lnbmVkIGxvbmcgcG9zKQp7CglzdHJ1Y3QgbWl4YXJ0X21nciAqbWdyID0gZW50cnktPnByaXZhdGVfZGF0YTsKCgljb3VudCA9IGNvdW50ICYgfjM7IC8qIG1ha2Ugc3VyZSB0aGUgcmVhZCBzaXplIGlzIGEgbXVsdGlwbGUgb2YgNCBieXRlcyAqLwoJaWYoY291bnQgPD0gMCkKCQlyZXR1cm4gMDsKCWlmKHBvcyArIGNvdW50ID4gTUlYQVJUX0JBMV9TSVpFKQoJCWNvdW50ID0gKGxvbmcpKE1JWEFSVF9CQTFfU0laRSAtIHBvcyk7CglpZihjb3B5X3RvX3VzZXJfZnJvbWlvKGJ1ZiwgTUlYQVJUX1JFRyggbWdyLCBwb3MgKSwgY291bnQpKQoJCXJldHVybiAtRUZBVUxUOwoJcmV0dXJuIGNvdW50Owp9CgpzdGF0aWMgc3RydWN0IHNuZF9pbmZvX2VudHJ5X29wcyBzbmRfbWl4YXJ0X3Byb2Nfb3BzX0JBMCA9IHsKCS5yZWFkICAgPSBzbmRfbWl4YXJ0X0JBMF9yZWFkLAoJLmxsc2VlayA9IHNuZF9taXhhcnRfQkEwX2xsc2Vlawp9OwoKc3RhdGljIHN0cnVjdCBzbmRfaW5mb19lbnRyeV9vcHMgc25kX21peGFydF9wcm9jX29wc19CQTEgPSB7CgkucmVhZCAgID0gc25kX21peGFydF9CQTFfcmVhZCwKCS5sbHNlZWsgPSBzbmRfbWl4YXJ0X0JBMV9sbHNlZWsKfTsKCgpzdGF0aWMgdm9pZCBzbmRfbWl4YXJ0X3Byb2NfcmVhZChzdHJ1Y3Qgc25kX2luZm9fZW50cnkgKmVudHJ5LCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHNuZF9pbmZvX2J1ZmZlciAqYnVmZmVyKQp7CglzdHJ1Y3Qgc25kX21peGFydCAqY2hpcCA9IGVudHJ5LT5wcml2YXRlX2RhdGE7ICAgICAgICAKCXUzMiByZWY7IAoKCXNuZF9pcHJpbnRmKGJ1ZmZlciwgIkRpZ2lncmFtIG1pWGFydCAoYWxzYSBjYXJkICVkKVxuXG4iLCBjaGlwLT5jaGlwX2lkeCk7CgoJLyogc3RhdHMgYXZhaWxhYmxlIHdoZW4gZW1iZWRkZWQgT1MgaXMgcnVubmluZyAqLwoJaWYgKGNoaXAtPm1nci0+ZHNwX2xvYWRlZCAmICggMSA8PCBNSVhBUlRfTU9USEVSQk9BUkRfRUxGX0lOREVYKSkgewoJCXNuZF9pcHJpbnRmKGJ1ZmZlciwgIi0gaGFyZHdhcmUgLVxuIik7CgkJc3dpdGNoIChjaGlwLT5tZ3ItPmJvYXJkX3R5cGUgKSB7CgkJY2FzZSBNSVhBUlRfREFVR0hURVJfVFlQRV9OT05FICAgICA6IHNuZF9pcHJpbnRmKGJ1ZmZlciwgIlx0bWlYYXJ0OCAobm8gZGF1Z2h0ZXIgYm9hcmQpXG5cbiIpOyBicmVhazsKCQljYXNlIE1JWEFSVF9EQVVHSFRFUl9UWVBFX0FFUyAgICAgIDogc25kX2lwcmludGYoYnVmZmVyLCAiXHRtaVhhcnQ4IEFFUy9FQlVcblxuIik7IGJyZWFrOwoJCWNhc2UgTUlYQVJUX0RBVUdIVEVSX1RZUEVfQ09CUkFORVQgOiBzbmRfaXByaW50ZihidWZmZXIsICJcdG1pWGFydDggQ29icmFuZXRcblxuIik7IGJyZWFrOwoJCWRlZmF1bHQ6ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzbmRfaXByaW50ZihidWZmZXIsICJcdFVOS05PV04hXG5cbiIpOyBicmVhazsKCQl9CgoJCXNuZF9pcHJpbnRmKGJ1ZmZlciwgIi0gc3lzdGVtIGxvYWQgLVxuIik7CSAKCgkJLyogZ2V0IHBlcmYgcmVmZXJlbmNlICovCgoJCXJlZiA9IHJlYWRsX2JlKCBNSVhBUlRfTUVNKCBjaGlwLT5tZ3IsIE1JWEFSVF9QU0VVRE9SRUdfUEVSRl9TWVNURU1fTE9BRF9PRkZTRVQpKTsKCgkJaWYgKHJlZikgewoJCQl1MzIgbWFpbGJveCAgID0gMTAwICogcmVhZGxfYmUoIE1JWEFSVF9NRU0oIGNoaXAtPm1nciwgTUlYQVJUX1BTRVVET1JFR19QRVJGX01BSUxCWF9MT0FEX09GRlNFVCkpIC8gcmVmOwoJCQl1MzIgc3RyZWFtaW5nID0gMTAwICogcmVhZGxfYmUoIE1JWEFSVF9NRU0oIGNoaXAtPm1nciwgTUlYQVJUX1BTRVVET1JFR19QRVJGX1NUUkVBTV9MT0FEX09GRlNFVCkpIC8gcmVmOwoJCQl1MzIgaW50ZXJyICAgID0gMTAwICogcmVhZGxfYmUoIE1JWEFSVF9NRU0oIGNoaXAtPm1nciwgTUlYQVJUX1BTRVVET1JFR19QRVJGX0lOVEVSUl9MT0FEX09GRlNFVCkpIC8gcmVmOwoKCQkJc25kX2lwcmludGYoYnVmZmVyLCAiXHRzdHJlYW1pbmcgICAgICAgICAgOiAlZFxuIiwgc3RyZWFtaW5nKTsKCQkJc25kX2lwcmludGYoYnVmZmVyLCAiXHRtYWlsYm94ICAgICAgICAgICAgOiAlZFxuIiwgbWFpbGJveCk7CgkJCXNuZF9pcHJpbnRmKGJ1ZmZlciwgIlx0aW50ZXJydXBzIGhhbmRsaW5nIDogJWRcblxuIiwgaW50ZXJyKTsKCQl9Cgl9IC8qIGVuZGlmIGVsZiBsb2FkZWQgKi8KfQoKc3RhdGljIHZvaWQgX19kZXZpbml0IHNuZF9taXhhcnRfcHJvY19pbml0KHN0cnVjdCBzbmRfbWl4YXJ0ICpjaGlwKQp7CglzdHJ1Y3Qgc25kX2luZm9fZW50cnkgKmVudHJ5OwoKCS8qIHRleHQgaW50ZXJmYWNlIHRvIHJlYWQgcGVyZiBhbmQgdGVtcCBtZXRlcnMgKi8KCWlmICghIHNuZF9jYXJkX3Byb2NfbmV3KGNoaXAtPmNhcmQsICJib2FyZF9pbmZvIiwgJmVudHJ5KSkgewoJCWVudHJ5LT5wcml2YXRlX2RhdGEgPSBjaGlwOwoJCWVudHJ5LT5jLnRleHQucmVhZCA9IHNuZF9taXhhcnRfcHJvY19yZWFkOwoJfQoKCWlmICghIHNuZF9jYXJkX3Byb2NfbmV3KGNoaXAtPmNhcmQsICJtaXhhcnRfQkEwIiwgJmVudHJ5KSkgewoJCWVudHJ5LT5jb250ZW50ID0gU05EUlZfSU5GT19DT05URU5UX0RBVEE7CgkJZW50cnktPnByaXZhdGVfZGF0YSA9IGNoaXAtPm1ncjsJCgkJZW50cnktPmMub3BzID0gJnNuZF9taXhhcnRfcHJvY19vcHNfQkEwOwoJCWVudHJ5LT5zaXplID0gTUlYQVJUX0JBMF9TSVpFOwoJfQoJaWYgKCEgc25kX2NhcmRfcHJvY19uZXcoY2hpcC0+Y2FyZCwgIm1peGFydF9CQTEiLCAmZW50cnkpKSB7CgkJZW50cnktPmNvbnRlbnQgPSBTTkRSVl9JTkZPX0NPTlRFTlRfREFUQTsKCQllbnRyeS0+cHJpdmF0ZV9kYXRhID0gY2hpcC0+bWdyOwoJCWVudHJ5LT5jLm9wcyA9ICZzbmRfbWl4YXJ0X3Byb2Nfb3BzX0JBMTsKCQllbnRyeS0+c2l6ZSA9IE1JWEFSVF9CQTFfU0laRTsKCX0KfQovKiBlbmQgb2YgcHJvYyBpbnRlcmZhY2UgKi8KCgovKgogKiAgICBwcm9iZSBmdW5jdGlvbiAtIGNyZWF0ZXMgdGhlIGNhcmQgbWFuYWdlcgogKi8Kc3RhdGljIGludCBfX2RldmluaXQgc25kX21peGFydF9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGNpLAoJCQkJICAgICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKnBjaV9pZCkKewoJc3RhdGljIGludCBkZXY7CglzdHJ1Y3QgbWl4YXJ0X21nciAqbWdyOwoJdW5zaWduZWQgaW50IGk7CglpbnQgZXJyOwoJc2l6ZV90IHNpemU7CgoJLyoKCSAqLwoJaWYgKGRldiA+PSBTTkRSVl9DQVJEUykKCQlyZXR1cm4gLUVOT0RFVjsKCWlmICghIGVuYWJsZVtkZXZdKSB7CgkJZGV2Kys7CgkJcmV0dXJuIC1FTk9FTlQ7Cgl9CgoJLyogZW5hYmxlIFBDSSBkZXZpY2UgKi8KCWlmICgoZXJyID0gcGNpX2VuYWJsZV9kZXZpY2UocGNpKSkgPCAwKQoJCXJldHVybiBlcnI7CglwY2lfc2V0X21hc3RlcihwY2kpOwoKCS8qIGNoZWNrIGlmIHdlIGNhbiByZXN0cmljdCBQQ0kgRE1BIHRyYW5zZmVycyB0byAzMiBiaXRzICovCglpZiAocGNpX3NldF9kbWFfbWFzayhwY2ksIERNQV8zMkJJVF9NQVNLKSA8IDApIHsKCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJhcmNoaXRlY3R1cmUgZG9lcyBub3Qgc3VwcG9ydCAzMmJpdCBQQ0kgYnVzbWFzdGVyIERNQVxuIik7CgkJcGNpX2Rpc2FibGVfZGV2aWNlKHBjaSk7CgkJcmV0dXJuIC1FTlhJTzsKCX0KCgkvKgoJICovCgltZ3IgPSBremFsbG9jKHNpemVvZigqbWdyKSwgR0ZQX0tFUk5FTCk7CglpZiAoISBtZ3IpIHsKCQlwY2lfZGlzYWJsZV9kZXZpY2UocGNpKTsKCQlyZXR1cm4gLUVOT01FTTsKCX0KCgltZ3ItPnBjaSA9IHBjaTsKCW1nci0+aXJxID0gLTE7CgoJLyogcmVzb3VyY2UgYXNzaWdubWVudCAqLwoJaWYgKChlcnIgPSBwY2lfcmVxdWVzdF9yZWdpb25zKHBjaSwgQ0FSRF9OQU1FKSkgPCAwKSB7CgkJa2ZyZWUobWdyKTsKCQlwY2lfZGlzYWJsZV9kZXZpY2UocGNpKTsKCQlyZXR1cm4gZXJyOwoJfQoJZm9yIChpID0gMDsgaSA8IDI7IGkrKykgewoJCW1nci0+bWVtW2ldLnBoeXMgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGNpLCBpKTsKCQltZ3ItPm1lbVtpXS52aXJ0ID0gaW9yZW1hcF9ub2NhY2hlKG1nci0+bWVtW2ldLnBoeXMsCgkJCQkJCSAgIHBjaV9yZXNvdXJjZV9sZW4ocGNpLCBpKSk7Cgl9CgoJaWYgKHJlcXVlc3RfaXJxKHBjaS0+aXJxLCBzbmRfbWl4YXJ0X2ludGVycnVwdCwgSVJRRl9ESVNBQkxFRHxJUlFGX1NIQVJFRCwgQ0FSRF9OQU1FLCAodm9pZCAqKW1ncikpIHsKCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJ1bmFibGUgdG8gZ3JhYiBJUlEgJWRcbiIsIHBjaS0+aXJxKTsKCQlzbmRfbWl4YXJ0X2ZyZWUobWdyKTsKCQlyZXR1cm4gLUVCVVNZOwoJfQoJbWdyLT5pcnEgPSBwY2ktPmlycTsKCglzcHJpbnRmKG1nci0+c2hvcnRuYW1lLCAiRGlnaWdyYW0gbWlYYXJ0Iik7CglzcHJpbnRmKG1nci0+bG9uZ25hbWUsICIlcyBhdCAweCVseCAmIDB4JWx4LCBpcnEgJWkiLCBtZ3ItPnNob3J0bmFtZSwgbWdyLT5tZW1bMF0ucGh5cywgbWdyLT5tZW1bMV0ucGh5cywgbWdyLT5pcnEpOwoKCS8qIElTUiBzcGlubG9jayAgKi8KCXNwaW5fbG9ja19pbml0KCZtZ3ItPmxvY2spOwoKCS8qIGluaXQgbWFpbGJveCAgKi8KCW1nci0+bXNnX2ZpZm9fcmVhZHB0ciA9IDA7CgltZ3ItPm1zZ19maWZvX3dyaXRlcHRyID0gMDsKCglzcGluX2xvY2tfaW5pdCgmbWdyLT5tc2dfbG9jayk7CgltdXRleF9pbml0KCZtZ3ItPm1zZ19tdXRleCk7Cglpbml0X3dhaXRxdWV1ZV9oZWFkKCZtZ3ItPm1zZ19zbGVlcCk7CglhdG9taWNfc2V0KCZtZ3ItPm1zZ19wcm9jZXNzZWQsIDApOwoKCS8qIGluaXQgc2V0dXAgbXV0ZXgqLwoJbXV0ZXhfaW5pdCgmbWdyLT5zZXR1cF9tdXRleCk7CgoJLyogaW5pdCBtZXNzYWdlIHRhc2xrZXQgKi8KCXRhc2tsZXRfaW5pdCgmbWdyLT5tc2dfdGFza3EsIHNuZF9taXhhcnRfbXNnX3Rhc2tsZXQsICh1bnNpZ25lZCBsb25nKSBtZ3IpOwoKCS8qIGNhcmQgYXNzaWdubWVudCAqLwoJbWdyLT5udW1fY2FyZHMgPSBNSVhBUlRfTUFYX0NBUkRTOyAvKiA0ICBGSVhNRTogY29uZmlndXJhYmxlPyAqLwoJZm9yIChpID0gMDsgaSA8IG1nci0+bnVtX2NhcmRzOyBpKyspIHsKCQlzdHJ1Y3Qgc25kX2NhcmQgKmNhcmQ7CgkJY2hhciB0bXBpZFsxNl07CgkJaW50IGlkeDsKCgkJaWYgKGluZGV4W2Rldl0gPCAwKQoJCQlpZHggPSBpbmRleFtkZXZdOwoJCWVsc2UKCQkJaWR4ID0gaW5kZXhbZGV2XSArIGk7CgkJc25wcmludGYodG1waWQsIHNpemVvZih0bXBpZCksICIlcy0lZCIsIGlkW2Rldl0gPyBpZFtkZXZdIDogIk1JWEFSVCIsIGkpOwoJCWNhcmQgPSBzbmRfY2FyZF9uZXcoaWR4LCB0bXBpZCwgVEhJU19NT0RVTEUsIDApOwoKCQlpZiAoISBjYXJkKSB7CgkJCXNuZF9wcmludGsoS0VSTl9FUlIgImNhbm5vdCBhbGxvY2F0ZSB0aGUgY2FyZCAlZFxuIiwgaSk7CgkJCXNuZF9taXhhcnRfZnJlZShtZ3IpOwoJCQlyZXR1cm4gLUVOT01FTTsKCQl9CgoJCXN0cmNweShjYXJkLT5kcml2ZXIsIENBUkRfTkFNRSk7CgkJc3ByaW50ZihjYXJkLT5zaG9ydG5hbWUsICIlcyBbUENNICMlZF0iLCBtZ3ItPnNob3J0bmFtZSwgaSk7CgkJc3ByaW50ZihjYXJkLT5sb25nbmFtZSwgIiVzIFtQQ00gIyVkXSIsIG1nci0+bG9uZ25hbWUsIGkpOwoKCQlpZiAoKGVyciA9IHNuZF9taXhhcnRfY3JlYXRlKG1nciwgY2FyZCwgaSkpIDwgMCkgewoJCQlzbmRfbWl4YXJ0X2ZyZWUobWdyKTsKCQkJcmV0dXJuIGVycjsKCQl9CgoJCWlmKGk9PTApIHsKCQkJLyogaW5pdCBwcm9jIGludGVyZmFjZSBvbmx5IGZvciBjaGlwMCAqLwoJCQlzbmRfbWl4YXJ0X3Byb2NfaW5pdChtZ3ItPmNoaXBbaV0pOwoJCX0KCgkJaWYgKChlcnIgPSBzbmRfY2FyZF9yZWdpc3RlcihjYXJkKSkgPCAwKSB7CgkJCXNuZF9taXhhcnRfZnJlZShtZ3IpOwoJCQlyZXR1cm4gZXJyOwoJCX0KCX0KCgkvKiBpbml0IGZpcm13YXJlIHN0YXR1cyAobWdyLT5kc3BfbG9hZGVkIHJlc2V0IGluIGh3ZGVwX25ldykgKi8KCW1nci0+Ym9hcmRfdHlwZSA9IE1JWEFSVF9EQVVHSFRFUl9UWVBFX05PTkU7CgoJLyogY3JlYXRlIGFycmF5IG9mIHN0cmVhbWluZm8gKi8KCXNpemUgPSBQQUdFX0FMSUdOKCAoTUlYQVJUX01BWF9TVFJFQU1fUEVSX0NBUkQgKiBNSVhBUlRfTUFYX0NBUkRTICoKCQkJICAgIHNpemVvZihzdHJ1Y3QgbWl4YXJ0X2Zsb3dpbmZvKSkgKTsKCWlmIChzbmRfZG1hX2FsbG9jX3BhZ2VzKFNORFJWX0RNQV9UWVBFX0RFViwgc25kX2RtYV9wY2lfZGF0YShwY2kpLAoJCQkJc2l6ZSwgJm1nci0+Zmxvd2luZm8pIDwgMCkgewoJCXNuZF9taXhhcnRfZnJlZShtZ3IpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoJLyogaW5pdCBzdHJlYW1pbmZvX2FycmF5ICovCgltZW1zZXQobWdyLT5mbG93aW5mby5hcmVhLCAwLCBzaXplKTsKCgkvKiBjcmVhdGUgYXJyYXkgb2YgYnVmZmVyaW5mbyAqLwoJc2l6ZSA9IFBBR0VfQUxJR04oIChNSVhBUlRfTUFYX1NUUkVBTV9QRVJfQ0FSRCAqIE1JWEFSVF9NQVhfQ0FSRFMgKgoJCQkgICAgc2l6ZW9mKHN0cnVjdCBtaXhhcnRfYnVmZmVyaW5mbykpICk7CglpZiAoc25kX2RtYV9hbGxvY19wYWdlcyhTTkRSVl9ETUFfVFlQRV9ERVYsIHNuZF9kbWFfcGNpX2RhdGEocGNpKSwKCQkJCXNpemUsICZtZ3ItPmJ1ZmZlcmluZm8pIDwgMCkgewoJCXNuZF9taXhhcnRfZnJlZShtZ3IpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoJLyogaW5pdCBidWZmZXJpbmZvX2FycmF5ICovCgltZW1zZXQobWdyLT5idWZmZXJpbmZvLmFyZWEsIDAsIHNpemUpOwoKCS8qIHNldCB1cCBmaXJtd2FyZSAqLwoJZXJyID0gc25kX21peGFydF9zZXR1cF9maXJtd2FyZShtZ3IpOwoJaWYgKGVyciA8IDApIHsKCQlzbmRfbWl4YXJ0X2ZyZWUobWdyKTsKCQlyZXR1cm4gZXJyOwoJfQoKCXBjaV9zZXRfZHJ2ZGF0YShwY2ksIG1ncik7CglkZXYrKzsKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBfX2RldmV4aXQgc25kX21peGFydF9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBjaSkKewoJc25kX21peGFydF9mcmVlKHBjaV9nZXRfZHJ2ZGF0YShwY2kpKTsKCXBjaV9zZXRfZHJ2ZGF0YShwY2ksIE5VTEwpOwp9CgpzdGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgZHJpdmVyID0gewoJLm5hbWUgPSAiRGlnaWdyYW0gbWlYYXJ0IiwKCS5pZF90YWJsZSA9IHNuZF9taXhhcnRfaWRzLAoJLnByb2JlID0gc25kX21peGFydF9wcm9iZSwKCS5yZW1vdmUgPSBfX2RldmV4aXRfcChzbmRfbWl4YXJ0X3JlbW92ZSksCn07CgpzdGF0aWMgaW50IF9faW5pdCBhbHNhX2NhcmRfbWl4YXJ0X2luaXQodm9pZCkKewoJcmV0dXJuIHBjaV9yZWdpc3Rlcl9kcml2ZXIoJmRyaXZlcik7Cn0KCnN0YXRpYyB2b2lkIF9fZXhpdCBhbHNhX2NhcmRfbWl4YXJ0X2V4aXQodm9pZCkKewoJcGNpX3VucmVnaXN0ZXJfZHJpdmVyKCZkcml2ZXIpOwp9Cgptb2R1bGVfaW5pdChhbHNhX2NhcmRfbWl4YXJ0X2luaXQpCm1vZHVsZV9leGl0KGFsc2FfY2FyZF9taXhhcnRfZXhpdCkK