LyoKICogTW90aW9uIEV5ZSB2aWRlbzRsaW51eCBkcml2ZXIgZm9yIFNvbnkgVmFpbyBQaWN0dXJlQm9vawogKgogKiBDb3B5cmlnaHQgKEMpIDIwMDEtMjAwNCBTdGVsaWFuIFBvcCA8c3RlbGlhbkBwb3BpZXMubmV0PgogKgogKiBDb3B5cmlnaHQgKEMpIDIwMDEtMjAwMiBBbGP0dmUgPHd3dy5hbGNvdmUuY29tPgogKgogKiBDb3B5cmlnaHQgKEMpIDIwMDAgQW5kcmV3IFRyaWRnZWxsIDx0cmlkZ2VAdmFsaW51eC5jb20+CiAqCiAqIEVhcmxpZXIgd29yayBieSBXZXJuZXIgQWxtZXNiZXJnZXIsIFBhdWwgYFJ1c3R5JyBSdXNzZWxsIGFuZCBQYXVsIE1hY2tlcnJhcy4KICoKICogU29tZSBwYXJ0cyBib3Jyb3dlZCBmcm9tIHZhcmlvdXMgdmlkZW80bGludXggZHJpdmVycywgZXNwZWNpYWxseQogKiBidHR2LWRyaXZlci5jIGFuZCB6b3Jhbi5jLCBzZWUgb3JpZ2luYWwgZmlsZXMgZm9yIGNyZWRpdHMuCiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCiAqCiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqIEZvdW5kYXRpb24sIEluYy4sIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgogKi8KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvcGNpLmg+CiNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvdmlkZW9kZXYuaD4KI2luY2x1ZGUgPG1lZGlhL3Y0bDItY29tbW9uLmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgojaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+CiNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgoKI2luY2x1ZGUgIm1leWUuaCIKI2luY2x1ZGUgPGxpbnV4L21leWUuaD4KCk1PRFVMRV9BVVRIT1IoIlN0ZWxpYW4gUG9wIDxzdGVsaWFuQHBvcGllcy5uZXQ+Iik7Ck1PRFVMRV9ERVNDUklQVElPTigidjRsL3Y0bDIgZHJpdmVyIGZvciB0aGUgTW90aW9uRXllIGNhbWVyYSIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7Ck1PRFVMRV9WRVJTSU9OKE1FWUVfRFJJVkVSX1ZFUlNJT04pOwoKLyogZm9yY2UgdXNhZ2Ugb2YgVjRMMSBBUEkgKi8Kc3RhdGljIGludCBmb3JjZXY0bDE7IC8qID0gMCAqLwptb2R1bGVfcGFyYW0oZm9yY2V2NGwxLCBpbnQsIDA2NDQpOwpNT0RVTEVfUEFSTV9ERVNDKGZvcmNldjRsMSwgImZvcmNlIHVzZSBvZiBWNEwxIGluc3RlYWQgb2YgVjRMMiIpOwoKLyogbnVtYmVyIG9mIGdyYWIgYnVmZmVycyAqLwpzdGF0aWMgdW5zaWduZWQgaW50IGdidWZmZXJzID0gMjsKbW9kdWxlX3BhcmFtKGdidWZmZXJzLCBpbnQsIDA0NDQpOwpNT0RVTEVfUEFSTV9ERVNDKGdidWZmZXJzLCAibnVtYmVyIG9mIGNhcHR1cmUgYnVmZmVycywgZGVmYXVsdCBpcyAyICgzMiBtYXgpIik7CgovKiBzaXplIG9mIGEgZ3JhYiBidWZmZXIgKi8Kc3RhdGljIHVuc2lnbmVkIGludCBnYnVmc2l6ZSA9IE1FWUVfTUFYX0JVRlNJWkU7Cm1vZHVsZV9wYXJhbShnYnVmc2l6ZSwgaW50LCAwNDQ0KTsKTU9EVUxFX1BBUk1fREVTQyhnYnVmc2l6ZSwgInNpemUgb2YgdGhlIGNhcHR1cmUgYnVmZmVycywgZGVmYXVsdCBpcyA2MTQ0MDAiCgkJICIgKHdpbGwgYmUgcm91bmRlZCB1cCB0byBhIHBhZ2UgbXVsdGlwbGUpIik7CgovKiAvZGV2L3ZpZGVvWCByZWdpc3RyYXRpb24gbnVtYmVyICovCnN0YXRpYyBpbnQgdmlkZW9fbnIgPSAtMTsKbW9kdWxlX3BhcmFtKHZpZGVvX25yLCBpbnQsIDA0NDQpOwpNT0RVTEVfUEFSTV9ERVNDKHZpZGVvX25yLCAidmlkZW8gZGV2aWNlIHRvIHJlZ2lzdGVyICgwPS9kZXYvdmlkZW8wLCBldGMpIik7CgovKiBkcml2ZXIgc3RydWN0dXJlIC0gb25seSBvbmUgcG9zc2libGUgKi8Kc3RhdGljIHN0cnVjdCBtZXllIG1leWU7CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLyogTWVtb3J5IGFsbG9jYXRpb24gcm91dGluZXMgKHN0b2xlbiBmcm9tIGJ0dHYtZHJpdmVyLmMpICAgICAgICAgICAgICAgICAgICovCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpzdGF0aWMgdm9pZCAqcnZtYWxsb2ModW5zaWduZWQgbG9uZyBzaXplKQp7Cgl2b2lkICptZW07Cgl1bnNpZ25lZCBsb25nIGFkcjsKCglzaXplID0gUEFHRV9BTElHTihzaXplKTsKCW1lbSA9IHZtYWxsb2NfMzIoc2l6ZSk7CglpZiAobWVtKSB7CgkJbWVtc2V0KG1lbSwgMCwgc2l6ZSk7CgkJYWRyID0gKHVuc2lnbmVkIGxvbmcpIG1lbTsKCQl3aGlsZSAoc2l6ZSA+IDApIHsKCQkJU2V0UGFnZVJlc2VydmVkKHZtYWxsb2NfdG9fcGFnZSgodm9pZCAqKWFkcikpOwoJCQlhZHIgKz0gUEFHRV9TSVpFOwoJCQlzaXplIC09IFBBR0VfU0laRTsKCQl9Cgl9CglyZXR1cm4gbWVtOwp9CgpzdGF0aWMgdm9pZCBydmZyZWUodm9pZCAqIG1lbSwgdW5zaWduZWQgbG9uZyBzaXplKQp7Cgl1bnNpZ25lZCBsb25nIGFkcjsKCglpZiAobWVtKSB7CgkJYWRyID0gKHVuc2lnbmVkIGxvbmcpIG1lbTsKCQl3aGlsZSAoKGxvbmcpIHNpemUgPiAwKSB7CgkJCUNsZWFyUGFnZVJlc2VydmVkKHZtYWxsb2NfdG9fcGFnZSgodm9pZCAqKWFkcikpOwoJCQlhZHIgKz0gUEFHRV9TSVpFOwoJCQlzaXplIC09IFBBR0VfU0laRTsKCQl9CgkJdmZyZWUobWVtKTsKCX0KfQoKLyoKICogcmV0dXJuIGEgcGFnZSB0YWJsZSBwb2ludGluZyB0byBOIHBhZ2VzIG9mIGxvY2tlZCBtZW1vcnkKICoKICogTk9URTogVGhlIG1leWUgZGV2aWNlIGV4cGVjdHMgRE1BIGFkZHJlc3NlcyBvbiAzMiBiaXRzLCB3ZSBidWlsZAogKiBhIHRhYmxlIG9mIDEwMjQgZW50cmllcyA9IDQgYnl0ZXMgKiAxMDI0ID0gNDA5NiBieXRlcy4KICovCnN0YXRpYyBpbnQgcHRhYmxlX2FsbG9jKHZvaWQpCnsKCXUzMiAqcHQ7CglpbnQgaTsKCgltZW1zZXQobWV5ZS5tY2hpcF9wdGFibGUsIDAsIHNpemVvZihtZXllLm1jaGlwX3B0YWJsZSkpOwoKCS8qIGdpdmUgb25seSAzMiBiaXQgRE1BIGFkZHJlc3NlcyAqLwoJaWYgKGRtYV9zZXRfbWFzaygmbWV5ZS5tY2hpcF9kZXYtPmRldiwgRE1BXzMyQklUX01BU0spKQoJCXJldHVybiAtMTsKCgltZXllLm1jaGlwX3B0YWJsZV90b2MgPSBkbWFfYWxsb2NfY29oZXJlbnQoJm1leWUubWNoaXBfZGV2LT5kZXYsCgkJCQkJCSAgIFBBR0VfU0laRSwKCQkJCQkJICAgJm1leWUubWNoaXBfZG1haGFuZGxlLAoJCQkJCQkgICBHRlBfS0VSTkVMKTsKCWlmICghbWV5ZS5tY2hpcF9wdGFibGVfdG9jKSB7CgkJbWV5ZS5tY2hpcF9kbWFoYW5kbGUgPSAwOwoJCXJldHVybiAtMTsKCX0KCglwdCA9IG1leWUubWNoaXBfcHRhYmxlX3RvYzsKCWZvciAoaSA9IDA7IGkgPCBNQ0hJUF9OQl9QQUdFUzsgaSsrKSB7CgkJZG1hX2FkZHJfdCBkbWE7CgkJbWV5ZS5tY2hpcF9wdGFibGVbaV0gPSBkbWFfYWxsb2NfY29oZXJlbnQoJm1leWUubWNoaXBfZGV2LT5kZXYsCgkJCQkJCQkgIFBBR0VfU0laRSwKCQkJCQkJCSAgJmRtYSwKCQkJCQkJCSAgR0ZQX0tFUk5FTCk7CgkJaWYgKCFtZXllLm1jaGlwX3B0YWJsZVtpXSkgewoJCQlpbnQgajsKCQkJcHQgPSBtZXllLm1jaGlwX3B0YWJsZV90b2M7CgkJCWZvciAoaiA9IDA7IGogPCBpOyArK2opIHsKCQkJCWRtYSA9IChkbWFfYWRkcl90KSAqcHQ7CgkJCQlkbWFfZnJlZV9jb2hlcmVudCgmbWV5ZS5tY2hpcF9kZXYtPmRldiwKCQkJCQkJICBQQUdFX1NJWkUsCgkJCQkJCSAgbWV5ZS5tY2hpcF9wdGFibGVbal0sIGRtYSk7CgkJCQlwdCsrOwoJCQl9CgkJCWRtYV9mcmVlX2NvaGVyZW50KCZtZXllLm1jaGlwX2Rldi0+ZGV2LAoJCQkJCSAgUEFHRV9TSVpFLAoJCQkJCSAgbWV5ZS5tY2hpcF9wdGFibGVfdG9jLAoJCQkJCSAgbWV5ZS5tY2hpcF9kbWFoYW5kbGUpOwoJCQltZXllLm1jaGlwX3B0YWJsZV90b2MgPSBOVUxMOwoJCQltZXllLm1jaGlwX2RtYWhhbmRsZSA9IDA7CgkJCXJldHVybiAtMTsKCQl9CgkJKnB0ID0gKHUzMikgZG1hOwoJCXB0Kys7Cgl9CglyZXR1cm4gMDsKfQoKc3RhdGljIHZvaWQgcHRhYmxlX2ZyZWUodm9pZCkKewoJdTMyICpwdDsKCWludCBpOwoKCXB0ID0gbWV5ZS5tY2hpcF9wdGFibGVfdG9jOwoJZm9yIChpID0gMDsgaSA8IE1DSElQX05CX1BBR0VTOyBpKyspIHsKCQlkbWFfYWRkcl90IGRtYSA9IChkbWFfYWRkcl90KSAqcHQ7CgkJaWYgKG1leWUubWNoaXBfcHRhYmxlW2ldKQoJCQlkbWFfZnJlZV9jb2hlcmVudCgmbWV5ZS5tY2hpcF9kZXYtPmRldiwKCQkJCQkgIFBBR0VfU0laRSwKCQkJCQkgIG1leWUubWNoaXBfcHRhYmxlW2ldLCBkbWEpOwoJCXB0Kys7Cgl9CgoJaWYgKG1leWUubWNoaXBfcHRhYmxlX3RvYykKCQlkbWFfZnJlZV9jb2hlcmVudCgmbWV5ZS5tY2hpcF9kZXYtPmRldiwKCQkJCSAgUEFHRV9TSVpFLAoJCQkJICBtZXllLm1jaGlwX3B0YWJsZV90b2MsCgkJCQkgIG1leWUubWNoaXBfZG1haGFuZGxlKTsKCgltZW1zZXQobWV5ZS5tY2hpcF9wdGFibGUsIDAsIHNpemVvZihtZXllLm1jaGlwX3B0YWJsZSkpOwoJbWV5ZS5tY2hpcF9wdGFibGVfdG9jID0gTlVMTDsKCW1leWUubWNoaXBfZG1haGFuZGxlID0gMDsKfQoKLyogY29weSBkYXRhIGZyb20gcHRhYmxlIGludG8gYnVmICovCnN0YXRpYyB2b2lkIHB0YWJsZV9jb3B5KHU4ICpidWYsIGludCBzdGFydCwgaW50IHNpemUsIGludCBwdF9wYWdlcykKewoJaW50IGk7CgoJZm9yIChpID0gMDsgaSA8IChzaXplIC8gUEFHRV9TSVpFKSAqIFBBR0VfU0laRTsgaSArPSBQQUdFX1NJWkUpIHsKCQltZW1jcHkoYnVmICsgaSwgbWV5ZS5tY2hpcF9wdGFibGVbc3RhcnQrK10sIFBBR0VfU0laRSk7CgkJaWYgKHN0YXJ0ID49IHB0X3BhZ2VzKQoJCQlzdGFydCA9IDA7Cgl9CgltZW1jcHkoYnVmICsgaSwgbWV5ZS5tY2hpcF9wdGFibGVbc3RhcnRdLCBzaXplICUgUEFHRV9TSVpFKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qIEpQRUcgdGFibGVzIGF0IGRpZmZlcmVudCBxdWFsaXRpZXMgdG8gbG9hZCBpbnRvIHRoZSBWUkogY2hpcCAgICAgICAgICAgICAqLwovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCi8qIHJldHVybiBhIHNldCBvZiBxdWFudGlzYXRpb24gdGFibGVzIGJhc2VkIG9uIGEgcXVhbGl0eSBmcm9tIDEgdG8gMTAgKi8Kc3RhdGljIHUxNiAqanBlZ19xdWFudGlzYXRpb25fdGFibGVzKGludCAqbGVuZ3RoLCBpbnQgcXVhbGl0eSkKewoJc3RhdGljIHUxNiBqcGVnX3RhYmxlc1tdWzcwXSA9IHsgewoJCTB4ZGJmZiwgMHg0MzAwLCAweGZmMDAsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLAoJCTB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLAoJCTB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLAoJCTB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLAoJCTB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhkYmZmLCAweDQzMDAsIDB4ZmYwMSwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwKCX0sCgl7CgkJMHhkYmZmLCAweDQzMDAsIDB4NTAwMCwgMHgzYzM3LCAweDNjNDYsIDB4NTAzMiwgMHg0MTQ2LCAweDVhNDYsCgkJMHg1MDU1LCAweDc4NWYsIDB4ODJjOCwgMHg2ZTc4LCAweDc4NmUsIDB4YWZmNSwgMHg5MWI5LCAweGZmYzgsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsCgkJMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwKCQkweGRiZmYsIDB4NDMwMCwgMHg1NTAxLCAweDVhNWEsIDB4Njk3OCwgMHhlYjc4LCAweDgyODIsIDB4ZmZlYiwKCQkweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwKCQkweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwKCQkweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLCAweGZmZmYsIDB4ZmZmZiwKCQkweGZmZmYsIDB4ZmZmZiwgMHhmZmZmLAoJfSwKCXsKCQkweGRiZmYsIDB4NDMwMCwgMHgyODAwLCAweDFlMWMsIDB4MWUyMywgMHgyODE5LCAweDIxMjMsIDB4MmQyMywKCQkweDI4MmIsIDB4M2MzMCwgMHg0MTY0LCAweDM3M2MsIDB4M2MzNywgMHg1ODdiLCAweDQ5NWQsIDB4OTE2NCwKCQkweDk5ODAsIDB4OGY5NiwgMHg4YzgwLCAweGEwOGEsIDB4ZTZiNCwgMHhhMGMzLCAweGRhYWEsIDB4OGFhZCwKCQkweGM4OGMsIDB4Y2JmZiwgMHhlZWRhLCAweGZmZjUsIDB4ZmZmZiwgMHhjMTliLCAweGZmZmYsIDB4ZmFmZiwKCQkweGU2ZmYsIDB4ZmZmZCwgMHhmZmY4LAoJCTB4ZGJmZiwgMHg0MzAwLCAweDJiMDEsIDB4MmQyZCwgMHgzNTNjLCAweDc2M2MsIDB4NDE0MSwgMHhmODc2LAoJCTB4OGNhNSwgMHhmOGE1LCAweGY4ZjgsIDB4ZjhmOCwgMHhmOGY4LCAweGY4ZjgsIDB4ZjhmOCwgMHhmOGY4LAoJCTB4ZjhmOCwgMHhmOGY4LCAweGY4ZjgsIDB4ZjhmOCwgMHhmOGY4LCAweGY4ZjgsIDB4ZjhmOCwgMHhmOGY4LAoJCTB4ZjhmOCwgMHhmOGY4LCAweGY4ZjgsIDB4ZjhmOCwgMHhmOGY4LCAweGY4ZjgsIDB4ZjhmOCwgMHhmOGY4LAoJCTB4ZjhmOCwgMHhmOGY4LCAweGZmZjgsCgl9LAoJewoJCTB4ZGJmZiwgMHg0MzAwLCAweDFiMDAsIDB4MTQxMiwgMHgxNDE3LCAweDFiMTEsIDB4MTYxNywgMHgxZTE3LAoJCTB4MWIxYywgMHgyODIwLCAweDJiNDIsIDB4MjUyOCwgMHgyODI1LCAweDNhNTEsIDB4MzAzZCwgMHg2MDQyLAoJCTB4NjU1NSwgMHg1ZjY0LCAweDVkNTUsIDB4NmE1YiwgMHg5OTc4LCAweDZhODEsIDB4OTA3MSwgMHg1YjczLAoJCTB4ODU1ZCwgMHg4NmI1LCAweDllOTAsIDB4YWJhMywgMHhhYmFkLCAweDgwNjcsIDB4YzliYywgMHhhNmJhLAoJCTB4OTljNywgMHhhYmE4LCAweGZmYTQsCgkJMHhkYmZmLCAweDQzMDAsIDB4MWMwMSwgMHgxZTFlLCAweDIzMjgsIDB4NGUyOCwgMHgyYjJiLCAweGE0NGUsCgkJMHg1ZDZlLCAweGE0NmUsIDB4YTRhNCwgMHhhNGE0LCAweGE0YTQsIDB4YTRhNCwgMHhhNGE0LCAweGE0YTQsCgkJMHhhNGE0LCAweGE0YTQsIDB4YTRhNCwgMHhhNGE0LCAweGE0YTQsIDB4YTRhNCwgMHhhNGE0LCAweGE0YTQsCgkJMHhhNGE0LCAweGE0YTQsIDB4YTRhNCwgMHhhNGE0LCAweGE0YTQsIDB4YTRhNCwgMHhhNGE0LCAweGE0YTQsCgkJMHhhNGE0LCAweGE0YTQsIDB4ZmZhNCwKCX0sCgl7CgkJMHhkYmZmLCAweDQzMDAsIDB4MTQwMCwgMHgwZjBlLCAweDBmMTIsIDB4MTQwZCwgMHgxMDEyLCAweDE3MTIsCgkJMHgxNDE1LCAweDFlMTgsIDB4MjEzMiwgMHgxYzFlLCAweDFlMWMsIDB4MmMzZCwgMHgyNDJlLCAweDQ5MzIsCgkJMHg0YzQwLCAweDQ3NGIsIDB4NDY0MCwgMHg1MDQ1LCAweDczNWEsIDB4NTA2MiwgMHg2ZDU1LCAweDQ1NTYsCgkJMHg2NDQ2LCAweDY1ODgsIDB4Nzc2ZCwgMHg4MTdiLCAweDgxODIsIDB4NjA0ZSwgMHg5NzhkLCAweDdkOGMsCgkJMHg3Mzk2LCAweDgxN2UsIDB4ZmY3YywKCQkweGRiZmYsIDB4NDMwMCwgMHgxNTAxLCAweDE3MTcsIDB4MWExZSwgMHgzYjFlLCAweDIxMjEsIDB4N2MzYiwKCQkweDQ2NTMsIDB4N2M1MywgMHg3YzdjLCAweDdjN2MsIDB4N2M3YywgMHg3YzdjLCAweDdjN2MsIDB4N2M3YywKCQkweDdjN2MsIDB4N2M3YywgMHg3YzdjLCAweDdjN2MsIDB4N2M3YywgMHg3YzdjLCAweDdjN2MsIDB4N2M3YywKCQkweDdjN2MsIDB4N2M3YywgMHg3YzdjLCAweDdjN2MsIDB4N2M3YywgMHg3YzdjLCAweDdjN2MsIDB4N2M3YywKCQkweDdjN2MsIDB4N2M3YywgMHhmZjdjLAoJfSwKCXsKCQkweGRiZmYsIDB4NDMwMCwgMHgxMDAwLCAweDBjMGIsIDB4MGMwZSwgMHgxMDBhLCAweDBkMGUsIDB4MTIwZSwKCQkweDEwMTEsIDB4MTgxMywgMHgxYTI4LCAweDE2MTgsIDB4MTgxNiwgMHgyMzMxLCAweDFkMjUsIDB4M2EyOCwKCQkweDNkMzMsIDB4MzkzYywgMHgzODMzLCAweDQwMzcsIDB4NWM0OCwgMHg0MDRlLCAweDU3NDQsIDB4Mzc0NSwKCQkweDUwMzgsIDB4NTE2ZCwgMHg1ZjU3LCAweDY3NjIsIDB4Njc2OCwgMHg0ZDNlLCAweDc5NzEsIDB4NjQ3MCwKCQkweDVjNzgsIDB4Njc2NSwgMHhmZjYzLAoJCTB4ZGJmZiwgMHg0MzAwLCAweDExMDEsIDB4MTIxMiwgMHgxNTE4LCAweDJmMTgsIDB4MWExYSwgMHg2MzJmLAoJCTB4Mzg0MiwgMHg2MzQyLCAweDYzNjMsIDB4NjM2MywgMHg2MzYzLCAweDYzNjMsIDB4NjM2MywgMHg2MzYzLAoJCTB4NjM2MywgMHg2MzYzLCAweDYzNjMsIDB4NjM2MywgMHg2MzYzLCAweDYzNjMsIDB4NjM2MywgMHg2MzYzLAoJCTB4NjM2MywgMHg2MzYzLCAweDYzNjMsIDB4NjM2MywgMHg2MzYzLCAweDYzNjMsIDB4NjM2MywgMHg2MzYzLAoJCTB4NjM2MywgMHg2MzYzLCAweGZmNjMsCgl9LAoJewoJCTB4ZGJmZiwgMHg0MzAwLCAweDBkMDAsIDB4MGEwOSwgMHgwYTBiLCAweDBkMDgsIDB4MGEwYiwgMHgwZTBiLAoJCTB4MGQwZSwgMHgxMzBmLCAweDE1MjAsIDB4MTIxMywgMHgxMzEyLCAweDFjMjcsIDB4MTcxZSwgMHgyZTIwLAoJCTB4MzEyOSwgMHgyZTMwLCAweDJkMjksIDB4MzMyYywgMHg0YTNhLCAweDMzM2UsIDB4NDYzNiwgMHgyYzM3LAoJCTB4NDAyZCwgMHg0MTU3LCAweDRjNDYsIDB4NTI0ZSwgMHg1MjUzLCAweDNlMzIsIDB4NjE1YSwgMHg1MDVhLAoJCTB4NGE2MCwgMHg1MjUxLCAweGZmNGYsCgkJMHhkYmZmLCAweDQzMDAsIDB4MGUwMSwgMHgwZTBlLCAweDExMTMsIDB4MjYxMywgMHgxNTE1LCAweDRmMjYsCgkJMHgyZDM1LCAweDRmMzUsIDB4NGY0ZiwgMHg0ZjRmLCAweDRmNGYsIDB4NGY0ZiwgMHg0ZjRmLCAweDRmNGYsCgkJMHg0ZjRmLCAweDRmNGYsIDB4NGY0ZiwgMHg0ZjRmLCAweDRmNGYsIDB4NGY0ZiwgMHg0ZjRmLCAweDRmNGYsCgkJMHg0ZjRmLCAweDRmNGYsIDB4NGY0ZiwgMHg0ZjRmLCAweDRmNGYsIDB4NGY0ZiwgMHg0ZjRmLCAweDRmNGYsCgkJMHg0ZjRmLCAweDRmNGYsIDB4ZmY0ZiwKCX0sCgl7CgkJMHhkYmZmLCAweDQzMDAsIDB4MGEwMCwgMHgwNzA3LCAweDA3MDgsIDB4MGEwNiwgMHgwODA4LCAweDBiMDgsCgkJMHgwYTBhLCAweDBlMGIsIDB4MTAxOCwgMHgwZDBlLCAweDBlMGQsIDB4MTUxZCwgMHgxMTE2LCAweDIzMTgsCgkJMHgyNTFmLCAweDIyMjQsIDB4MjIxZiwgMHgyNjIxLCAweDM3MmIsIDB4MjYyZiwgMHgzNDI5LCAweDIxMjksCgkJMHgzMDIyLCAweDMxNDEsIDB4MzkzNCwgMHgzZTNiLCAweDNlM2UsIDB4MmUyNSwgMHg0OTQ0LCAweDNjNDMsCgkJMHgzNzQ4LCAweDNlM2QsIDB4ZmYzYiwKCQkweGRiZmYsIDB4NDMwMCwgMHgwYTAxLCAweDBiMGIsIDB4MGQwZSwgMHgxYzBlLCAweDEwMTAsIDB4M2IxYywKCQkweDIyMjgsIDB4M2IyOCwgMHgzYjNiLCAweDNiM2IsIDB4M2IzYiwgMHgzYjNiLCAweDNiM2IsIDB4M2IzYiwKCQkweDNiM2IsIDB4M2IzYiwgMHgzYjNiLCAweDNiM2IsIDB4M2IzYiwgMHgzYjNiLCAweDNiM2IsIDB4M2IzYiwKCQkweDNiM2IsIDB4M2IzYiwgMHgzYjNiLCAweDNiM2IsIDB4M2IzYiwgMHgzYjNiLCAweDNiM2IsIDB4M2IzYiwKCQkweDNiM2IsIDB4M2IzYiwgMHhmZjNiLAoJfSwKCXsKCQkweGRiZmYsIDB4NDMwMCwgMHgwNjAwLCAweDA1MDQsIDB4MDUwNiwgMHgwNjA0LCAweDA1MDYsIDB4MDcwNiwKCQkweDA2MDcsIDB4MGEwOCwgMHgwYTEwLCAweDA5MGEsIDB4MGEwOSwgMHgwZTE0LCAweDBjMGYsIDB4MTcxMCwKCQkweDE4MTQsIDB4MTcxOCwgMHgxNjE0LCAweDFhMTYsIDB4MjUxZCwgMHgxYTFmLCAweDIzMWIsIDB4MTYxYywKCQkweDIwMTYsIDB4MjAyYywgMHgyNjIzLCAweDI5MjcsIDB4MjkyYSwgMHgxZjE5LCAweDMwMmQsIDB4MjgyZCwKCQkweDI1MzAsIDB4MjkyOCwgMHhmZjI4LAoJCTB4ZGJmZiwgMHg0MzAwLCAweDA3MDEsIDB4MDcwNywgMHgwODBhLCAweDEzMGEsIDB4MGEwYSwgMHgyODEzLAoJCTB4MTYxYSwgMHgyODFhLCAweDI4MjgsIDB4MjgyOCwgMHgyODI4LCAweDI4MjgsIDB4MjgyOCwgMHgyODI4LAoJCTB4MjgyOCwgMHgyODI4LCAweDI4MjgsIDB4MjgyOCwgMHgyODI4LCAweDI4MjgsIDB4MjgyOCwgMHgyODI4LAoJCTB4MjgyOCwgMHgyODI4LCAweDI4MjgsIDB4MjgyOCwgMHgyODI4LCAweDI4MjgsIDB4MjgyOCwgMHgyODI4LAoJCTB4MjgyOCwgMHgyODI4LCAweGZmMjgsCgl9LAoJewoJCTB4ZGJmZiwgMHg0MzAwLCAweDAzMDAsIDB4MDIwMiwgMHgwMjAzLCAweDAzMDIsIDB4MDMwMywgMHgwNDAzLAoJCTB4MDMwMywgMHgwNTA0LCAweDA1MDgsIDB4MDQwNSwgMHgwNTA0LCAweDA3MGEsIDB4MDYwNywgMHgwYzA4LAoJCTB4MGMwYSwgMHgwYjBjLCAweDBiMGEsIDB4MGQwYiwgMHgxMjBlLCAweDBkMTAsIDB4MTEwZSwgMHgwYjBlLAoJCTB4MTAwYiwgMHgxMDE2LCAweDEzMTEsIDB4MTUxNCwgMHgxNTE1LCAweDBmMGMsIDB4MTgxNywgMHgxNDE2LAoJCTB4MTIxOCwgMHgxNTE0LCAweGZmMTQsCgkJMHhkYmZmLCAweDQzMDAsIDB4MDMwMSwgMHgwNDA0LCAweDA0MDUsIDB4MDkwNSwgMHgwNTA1LCAweDE0MDksCgkJMHgwYjBkLCAweDE0MGQsIDB4MTQxNCwgMHgxNDE0LCAweDE0MTQsIDB4MTQxNCwgMHgxNDE0LCAweDE0MTQsCgkJMHgxNDE0LCAweDE0MTQsIDB4MTQxNCwgMHgxNDE0LCAweDE0MTQsIDB4MTQxNCwgMHgxNDE0LCAweDE0MTQsCgkJMHgxNDE0LCAweDE0MTQsIDB4MTQxNCwgMHgxNDE0LCAweDE0MTQsIDB4MTQxNCwgMHgxNDE0LCAweDE0MTQsCgkJMHgxNDE0LCAweDE0MTQsIDB4ZmYxNCwKCX0sCgl7CgkJMHhkYmZmLCAweDQzMDAsIDB4MDEwMCwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsCgkJMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsCgkJMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsCgkJMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsCgkJMHgwMTAxLCAweDAxMDEsIDB4ZmYwMSwKCQkweGRiZmYsIDB4NDMwMCwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwKCQkweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwKCQkweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwKCQkweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDEwMSwKCQkweDAxMDEsIDB4MDEwMSwgMHhmZjAxLAoJfSB9OwoKCWlmIChxdWFsaXR5IDwgMCB8fCBxdWFsaXR5ID4gMTApIHsKCQlwcmludGsoS0VSTl9XQVJOSU5HCgkJICAgICAgICJtZXllOiBpbnZhbGlkIHF1YWxpdHkgbGV2ZWwgJWQgLSB1c2luZyA4XG4iLCBxdWFsaXR5KTsKCQlxdWFsaXR5ID0gODsKCX0KCgkqbGVuZ3RoID0gQVJSQVlfU0laRShqcGVnX3RhYmxlc1txdWFsaXR5XSk7CglyZXR1cm4ganBlZ190YWJsZXNbcXVhbGl0eV07Cn0KCi8qIHJldHVybiBhIGdlbmVyaWMgc2V0IG9mIGh1ZmZtYW4gdGFibGVzICovCnN0YXRpYyB1MTYgKmpwZWdfaHVmZm1hbl90YWJsZXMoaW50ICpsZW5ndGgpCnsKCXN0YXRpYyB1MTYgdGFibGVzW10gPSB7CgkJMHhDNEZGLCAweEI1MDAsIDB4MDAxMCwgMHgwMTAyLCAweDAzMDMsIDB4MDQwMiwgMHgwNTAzLCAweDA0MDUsCgkJMHgwMDA0LCAweDAxMDAsIDB4MDE3RCwgMHgwMzAyLCAweDA0MDAsIDB4MDUxMSwgMHgyMTEyLCAweDQxMzEsCgkJMHgxMzA2LCAweDYxNTEsIDB4MjIwNywgMHgxNDcxLCAweDgxMzIsIDB4QTE5MSwgMHgyMzA4LCAweEIxNDIsCgkJMHgxNUMxLCAweEQxNTIsIDB4MjRGMCwgMHg2MjMzLCAweDgyNzIsIDB4MEEwOSwgMHgxNzE2LCAweDE5MTgsCgkJMHgyNTFBLCAweDI3MjYsIDB4MjkyOCwgMHgzNDJBLCAweDM2MzUsIDB4MzgzNywgMHgzQTM5LCAweDQ0NDMsCgkJMHg0NjQ1LCAweDQ4NDcsIDB4NEE0OSwgMHg1NDUzLCAweDU2NTUsIDB4NTg1NywgMHg1QTU5LCAweDY0NjMsCgkJMHg2NjY1LCAweDY4NjcsIDB4NkE2OSwgMHg3NDczLCAweDc2NzUsIDB4Nzg3NywgMHg3QTc5LCAweDg0ODMsCgkJMHg4Njg1LCAweDg4ODcsIDB4OEE4OSwgMHg5MzkyLCAweDk1OTQsIDB4OTc5NiwgMHg5OTk4LCAweEEyOUEsCgkJMHhBNEEzLCAweEE2QTUsIDB4QThBNywgMHhBQUE5LCAweEIzQjIsIDB4QjVCNCwgMHhCN0I2LCAweEI5QjgsCgkJMHhDMkJBLCAweEM0QzMsIDB4QzZDNSwgMHhDOEM3LCAweENBQzksIDB4RDNEMiwgMHhENUQ0LCAweEQ3RDYsCgkJMHhEOUQ4LCAweEUxREEsIDB4RTNFMiwgMHhFNUU0LCAweEU3RTYsIDB4RTlFOCwgMHhGMUVBLCAweEYzRjIsCgkJMHhGNUY0LCAweEY3RjYsIDB4RjlGOCwgMHhGRkZBLAoJCTB4QzRGRiwgMHhCNTAwLCAweDAwMTEsIDB4MDEwMiwgMHgwNDAyLCAweDAzMDQsIDB4MDcwNCwgMHgwNDA1LAoJCTB4MDAwNCwgMHgwMjAxLCAweDAwNzcsIDB4MDIwMSwgMHgxMTAzLCAweDA1MDQsIDB4MzEyMSwgMHgxMjA2LAoJCTB4NTE0MSwgMHg2MTA3LCAweDEzNzEsIDB4MzIyMiwgMHgwODgxLCAweDQyMTQsIDB4QTE5MSwgMHhDMUIxLAoJCTB4MjMwOSwgMHg1MjMzLCAweDE1RjAsIDB4NzI2MiwgMHgwQUQxLCAweDI0MTYsIDB4RTEzNCwgMHhGMTI1LAoJCTB4MTgxNywgMHgxQTE5LCAweDI3MjYsIDB4MjkyOCwgMHgzNTJBLCAweDM3MzYsIDB4MzkzOCwgMHg0MzNBLAoJCTB4NDU0NCwgMHg0NzQ2LCAweDQ5NDgsIDB4NTM0QSwgMHg1NTU0LCAweDU3NTYsIDB4NTk1OCwgMHg2MzVBLAoJCTB4NjU2NCwgMHg2NzY2LCAweDY5NjgsIDB4NzM2QSwgMHg3NTc0LCAweDc3NzYsIDB4Nzk3OCwgMHg4MjdBLAoJCTB4ODQ4MywgMHg4Njg1LCAweDg4ODcsIDB4OEE4OSwgMHg5MzkyLCAweDk1OTQsIDB4OTc5NiwgMHg5OTk4LAoJCTB4QTI5QSwgMHhBNEEzLCAweEE2QTUsIDB4QThBNywgMHhBQUE5LCAweEIzQjIsIDB4QjVCNCwgMHhCN0I2LAoJCTB4QjlCOCwgMHhDMkJBLCAweEM0QzMsIDB4QzZDNSwgMHhDOEM3LCAweENBQzksIDB4RDNEMiwgMHhENUQ0LAoJCTB4RDdENiwgMHhEOUQ4LCAweEUyREEsIDB4RTRFMywgMHhFNkU1LCAweEU4RTcsIDB4RUFFOSwgMHhGM0YyLAoJCTB4RjVGNCwgMHhGN0Y2LCAweEY5RjgsIDB4RkZGQSwKCQkweEM0RkYsIDB4MUYwMCwgMHgwMDAwLCAweDA1MDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsIDB4MDAwMCwKCQkweDAwMDAsIDB4MDAwMCwgMHgwMDAwLCAweDAyMDEsIDB4MDQwMywgMHgwNjA1LCAweDA4MDcsIDB4MEEwOSwKCQkweEZGMEIsCgkJMHhDNEZGLCAweDFGMDAsIDB4MDAwMSwgMHgwMTAzLCAweDAxMDEsIDB4MDEwMSwgMHgwMTAxLCAweDAxMDEsCgkJMHgwMDAwLCAweDAwMDAsIDB4MDAwMCwgMHgwMjAxLCAweDA0MDMsIDB4MDYwNSwgMHgwODA3LCAweDBBMDksCgkJMHhGRjBCCgl9OwoKCSpsZW5ndGggPSBBUlJBWV9TSVpFKHRhYmxlcyk7CglyZXR1cm4gdGFibGVzOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLyogTUNISVAgbG93LWxldmVsIGZ1bmN0aW9ucyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyogcmV0dXJucyB0aGUgaG9yaXpvbnRhbCBjYXB0dXJlIHNpemUgKi8Kc3RhdGljIGlubGluZSBpbnQgbWNoaXBfaHNpemUodm9pZCkKewoJcmV0dXJuIG1leWUucGFyYW1zLnN1YnNhbXBsZSA/IDMyMCA6IDY0MDsKfQoKLyogcmV0dXJucyB0aGUgdmVydGljYWwgY2FwdHVyZSBzaXplICovCnN0YXRpYyBpbmxpbmUgaW50IG1jaGlwX3ZzaXplKHZvaWQpCnsKCXJldHVybiBtZXllLnBhcmFtcy5zdWJzYW1wbGUgPyAyNDAgOiA0ODA7Cn0KCi8qIHdhaXRzIGZvciBhIHJlZ2lzdGVyIHRvIGJlIGF2YWlsYWJsZSAqLwpzdGF0aWMgdm9pZCBtY2hpcF9zeW5jKGludCByZWcpCnsKCXUzMiBzdGF0dXM7CglpbnQgaTsKCglpZiAocmVnID09IE1DSElQX01NX0ZJRk9fREFUQSkgewoJCWZvciAoaSA9IDA7IGkgPCBNQ0hJUF9SRUdfVElNRU9VVDsgaSsrKSB7CgkJCXN0YXR1cyA9IHJlYWRsKG1leWUubWNoaXBfbW1yZWdzICsKCQkJCSAgICAgICBNQ0hJUF9NTV9GSUZPX1NUQVRVUyk7CgkJCWlmICghKHN0YXR1cyAmIE1DSElQX01NX0ZJRk9fV0FJVCkpIHsKCQkJCXByaW50ayhLRVJOX1dBUk5JTkcgIm1leWU6IGZpZm8gbm90IHJlYWR5XG4iKTsKCQkJCXJldHVybjsKCQkJfQoJCQlpZiAoc3RhdHVzICYgTUNISVBfTU1fRklGT19SRUFEWSkKCQkJCXJldHVybjsKCQkJdWRlbGF5KDEpOwoJCX0KCX0gZWxzZSBpZiAocmVnID4gMHg4MCkgewoJCXUzMiBtYXNrID0gKHJlZyA8IDB4MTAwKSA/IE1DSElQX0hJQ19TVEFUVVNfTUNDX1JEWQoJCQkJCSA6IE1DSElQX0hJQ19TVEFUVVNfVlJKX1JEWTsKCQlmb3IgKGkgPSAwOyBpIDwgTUNISVBfUkVHX1RJTUVPVVQ7IGkrKykgewoJCQlzdGF0dXMgPSByZWFkbChtZXllLm1jaGlwX21tcmVncyArIE1DSElQX0hJQ19TVEFUVVMpOwoJCQlpZiAoc3RhdHVzICYgbWFzaykKCQkJCXJldHVybjsKCQkJdWRlbGF5KDEpOwoJCX0KCX0gZWxzZQoJCXJldHVybjsKCXByaW50ayhLRVJOX1dBUk5JTkcKCSAgICAgICAibWV5ZTogbWNoaXBfc3luYygpIHRpbWVvdXQgb24gcmVnIDB4JXggc3RhdHVzPTB4JXhcbiIsCgkgICAgICAgcmVnLCBzdGF0dXMpOwp9CgovKiBzZXRzIGEgdmFsdWUgaW50byB0aGUgcmVnaXN0ZXIgKi8Kc3RhdGljIGlubGluZSB2b2lkIG1jaGlwX3NldChpbnQgcmVnLCB1MzIgdikKewoJbWNoaXBfc3luYyhyZWcpOwoJd3JpdGVsKHYsIG1leWUubWNoaXBfbW1yZWdzICsgcmVnKTsKfQoKLyogZ2V0IHRoZSByZWdpc3RlciB2YWx1ZSAqLwpzdGF0aWMgaW5saW5lIHUzMiBtY2hpcF9yZWFkKGludCByZWcpCnsKCW1jaGlwX3N5bmMocmVnKTsKCXJldHVybiByZWFkbChtZXllLm1jaGlwX21tcmVncyArIHJlZyk7Cn0KCi8qIHdhaXQgZm9yIGEgcmVnaXN0ZXIgdG8gYmVjb21lIGEgcGFydGljdWxhciB2YWx1ZSAqLwpzdGF0aWMgaW5saW5lIGludCBtY2hpcF9kZWxheSh1MzIgcmVnLCB1MzIgdikKewoJaW50IG4gPSAxMDsKCXdoaWxlICgtLW4gJiYgbWNoaXBfcmVhZChyZWcpICE9IHYpCgkJdWRlbGF5KDEpOwoJcmV0dXJuIG47Cn0KCi8qIHNldHVwIHN1YnNhbXBsaW5nICovCnN0YXRpYyB2b2lkIG1jaGlwX3N1YnNhbXBsZSh2b2lkKQp7CgltY2hpcF9zZXQoTUNISVBfTUNDX1JfU0FNUExJTkcsIG1leWUucGFyYW1zLnN1YnNhbXBsZSk7CgltY2hpcF9zZXQoTUNISVBfTUNDX1JfWFJBTkdFLCBtY2hpcF9oc2l6ZSgpKTsKCW1jaGlwX3NldChNQ0hJUF9NQ0NfUl9ZUkFOR0UsIG1jaGlwX3ZzaXplKCkpOwoJbWNoaXBfc2V0KE1DSElQX01DQ19CX1hSQU5HRSwgbWNoaXBfaHNpemUoKSk7CgltY2hpcF9zZXQoTUNISVBfTUNDX0JfWVJBTkdFLCBtY2hpcF92c2l6ZSgpKTsKCW1jaGlwX2RlbGF5KE1DSElQX0hJQ19TVEFUVVMsIE1DSElQX0hJQ19TVEFUVVNfSURMRSk7Cn0KCi8qIHNldCB0aGUgZnJhbWVyYXRlIGludG8gdGhlIG1jaGlwICovCnN0YXRpYyB2b2lkIG1jaGlwX3NldF9mcmFtZXJhdGUodm9pZCkKewoJbWNoaXBfc2V0KE1DSElQX0hJQ19TX1JBVEUsIG1leWUucGFyYW1zLmZyYW1lcmF0ZSk7Cn0KCi8qIGxvYWQgc29tZSBodWZmbWFuIGFuZCBxdWFudGlzYXRpb24gdGFibGVzIGludG8gdGhlIFZSSiBjaGlwIHJlYWR5CiAgIGZvciBKUEVHIGNvbXByZXNzaW9uICovCnN0YXRpYyB2b2lkIG1jaGlwX2xvYWRfdGFibGVzKHZvaWQpCnsKCWludCBpOwoJaW50IGxlbmd0aDsKCXUxNiAqdGFibGVzOwoKCXRhYmxlcyA9IGpwZWdfaHVmZm1hbl90YWJsZXMoJmxlbmd0aCk7Cglmb3IgKGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspCgkJd3JpdGVsKHRhYmxlc1tpXSwgbWV5ZS5tY2hpcF9tbXJlZ3MgKyBNQ0hJUF9WUkpfVEFCTEVfREFUQSk7CgoJdGFibGVzID0ganBlZ19xdWFudGlzYXRpb25fdGFibGVzKCZsZW5ndGgsIG1leWUucGFyYW1zLnF1YWxpdHkpOwoJZm9yIChpID0gMDsgaSA8IGxlbmd0aDsgaSsrKQoJCXdyaXRlbCh0YWJsZXNbaV0sIG1leWUubWNoaXBfbW1yZWdzICsgTUNISVBfVlJKX1RBQkxFX0RBVEEpOwp9CgovKiBzZXR1cCB0aGUgVlJKIHBhcmFtZXRlcnMgaW4gdGhlIGNoaXAgKi8Kc3RhdGljIHZvaWQgbWNoaXBfdnJqX3NldHVwKHU4IG1vZGUpCnsKCW1jaGlwX3NldChNQ0hJUF9WUkpfQlVTX01PREUsIDUpOwoJbWNoaXBfc2V0KE1DSElQX1ZSSl9TSUdOQUxfQUNUSVZFX0xFVkVMLCAweDFmKTsKCW1jaGlwX3NldChNQ0hJUF9WUkpfUERBVF9VU0UsIDEpOwoJbWNoaXBfc2V0KE1DSElQX1ZSSl9JUlFfRkxBRywgMHhhMCk7CgltY2hpcF9zZXQoTUNISVBfVlJKX01PREVfU1BFQ0lGWSwgbW9kZSk7CgltY2hpcF9zZXQoTUNISVBfVlJKX05VTV9MSU5FUywgbWNoaXBfdnNpemUoKSk7CgltY2hpcF9zZXQoTUNISVBfVlJKX05VTV9QSVhFTFMsIG1jaGlwX2hzaXplKCkpOwoJbWNoaXBfc2V0KE1DSElQX1ZSSl9OVU1fQ09NUE9ORU5UUywgMHgxYik7CgltY2hpcF9zZXQoTUNISVBfVlJKX0xJTUlUX0NPTVBSRVNTRURfTE8sIDB4RkZGRik7CgltY2hpcF9zZXQoTUNISVBfVlJKX0xJTUlUX0NPTVBSRVNTRURfSEksIDB4RkZGRik7CgltY2hpcF9zZXQoTUNISVBfVlJKX0NPTVBfREFUQV9GT1JNQVQsIDB4Qyk7CgltY2hpcF9zZXQoTUNISVBfVlJKX1JFU1RBUlRfSU5URVJWQUwsIDApOwoJbWNoaXBfc2V0KE1DSElQX1ZSSl9TT0YxLCAweDYwMSk7CgltY2hpcF9zZXQoTUNISVBfVlJKX1NPRjIsIDB4MTUwMik7CgltY2hpcF9zZXQoTUNISVBfVlJKX1NPRjMsIDB4MTUwMyk7CgltY2hpcF9zZXQoTUNISVBfVlJKX1NPRjQsIDB4MTU5Nik7CgltY2hpcF9zZXQoTUNISVBfVlJKX1NPUywgMHgwZWQwKTsKCgltY2hpcF9sb2FkX3RhYmxlcygpOwp9CgovKiBzZXRzIHRoZSBETUEgcGFyYW1ldGVycyBpbnRvIHRoZSBjaGlwICovCnN0YXRpYyB2b2lkIG1jaGlwX2RtYV9zZXR1cChkbWFfYWRkcl90IGRtYV9hZGRyKQp7CglpbnQgaTsKCgltY2hpcF9zZXQoTUNISVBfTU1fUFRfQUREUiwgKHUzMilkbWFfYWRkcik7Cglmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKQoJCW1jaGlwX3NldChNQ0hJUF9NTV9GSVIoaSksIDApOwoJbWV5ZS5tY2hpcF9mbnVtID0gMDsKfQoKLyogc2V0dXAgZm9yIERNQSB0cmFuc2ZlcnMgLSBhbHNvIHplcm9zIHRoZSBmcmFtZWJ1ZmZlciAqLwpzdGF0aWMgaW50IG1jaGlwX2RtYV9hbGxvYyh2b2lkKQp7CglpZiAoIW1leWUubWNoaXBfZG1haGFuZGxlKQoJCWlmIChwdGFibGVfYWxsb2MoKSkKCQkJcmV0dXJuIC0xOwoJcmV0dXJuIDA7Cn0KCi8qIGZyZWVzIHRoZSBETUEgYnVmZmVyICovCnN0YXRpYyB2b2lkIG1jaGlwX2RtYV9mcmVlKHZvaWQpCnsKCWlmIChtZXllLm1jaGlwX2RtYWhhbmRsZSkgewoJCW1jaGlwX2RtYV9zZXR1cCgwKTsKCQlwdGFibGVfZnJlZSgpOwoJfQp9CgovKiBzdG9wIGFueSBleGlzdGluZyBISUMgYWN0aW9uIGFuZCB3YWl0IGZvciBhbnkgZG1hIHRvIGNvbXBsZXRlIHRoZW4KICAgcmVzZXQgdGhlIGRtYSBlbmdpbmUgKi8Kc3RhdGljIHZvaWQgbWNoaXBfaGljX3N0b3Aodm9pZCkKewoJaW50IGksIGo7CgoJbWV5ZS5tY2hpcF9tb2RlID0gTUNISVBfSElDX01PREVfTk9PUDsKCWlmICghKG1jaGlwX3JlYWQoTUNISVBfSElDX1NUQVRVUykgJiBNQ0hJUF9ISUNfU1RBVFVTX0JVU1kpKQoJCXJldHVybjsKCWZvciAoaSA9IDA7IGkgPCAyMDsgKytpKSB7CgkJbWNoaXBfc2V0KE1DSElQX0hJQ19DTUQsIE1DSElQX0hJQ19DTURfU1RPUCk7CgkJbWNoaXBfZGVsYXkoTUNISVBfSElDX0NNRCwgMCk7CgkJZm9yIChqID0gMDsgaiA8IDEwMDsgKytqKSB7CgkJCWlmIChtY2hpcF9kZWxheShNQ0hJUF9ISUNfU1RBVFVTLAoJCQkJCU1DSElQX0hJQ19TVEFUVVNfSURMRSkpCgkJCQlyZXR1cm47CgkJCW1zbGVlcCgxKTsKCQl9CgkJcHJpbnRrKEtFUk5fRVJSICJtZXllOiBuZWVkIHRvIHJlc2V0IEhJQyFcbiIpOwoKCQltY2hpcF9zZXQoTUNISVBfSElDX0NUTCwgTUNISVBfSElDX0NUTF9TT0ZUX1JFU0VUKTsKCQltc2xlZXAoMjUwKTsKCX0KCXByaW50ayhLRVJOX0VSUiAibWV5ZTogcmVzZXR0aW5nIEhJQyBoYW5nZWQhXG4iKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qIE1DSElQIGZyYW1lIHByb2Nlc3NpbmcgZnVuY3Rpb25zICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCi8qIGdldCB0aGUgbmV4dCByZWFkeSBmcmFtZSBmcm9tIHRoZSBkbWEgZW5naW5lICovCnN0YXRpYyB1MzIgbWNoaXBfZ2V0X2ZyYW1lKHZvaWQpCnsKCXUzMiB2OwoKCXYgPSBtY2hpcF9yZWFkKE1DSElQX01NX0ZJUihtZXllLm1jaGlwX2ZudW0pKTsKCXJldHVybiB2Owp9CgovKiBmcmVlcyB0aGUgY3VycmVudCBmcmFtZSBmcm9tIHRoZSBkbWEgZW5naW5lICovCnN0YXRpYyB2b2lkIG1jaGlwX2ZyZWVfZnJhbWUodm9pZCkKewoJbWNoaXBfc2V0KE1DSElQX01NX0ZJUihtZXllLm1jaGlwX2ZudW0pLCAwKTsKCW1leWUubWNoaXBfZm51bSsrOwoJbWV5ZS5tY2hpcF9mbnVtICU9IDQ7Cn0KCi8qIHJlYWQgb25lIGZyYW1lIGZyb20gdGhlIGZyYW1lYnVmZmVyIGFzc3VtaW5nIGl0IHdhcyBjYXB0dXJlZCB1c2luZwogICBhIHVuY29tcHJlc3NlZCB0cmFuc2ZlciAqLwpzdGF0aWMgdm9pZCBtY2hpcF9jb250X3JlYWRfZnJhbWUodTMyIHYsIHU4ICpidWYsIGludCBzaXplKQp7CglpbnQgcHRfaWQ7CgoJcHRfaWQgPSAodiA+PiAxNykgJiAweDNGRjsKCglwdGFibGVfY29weShidWYsIHB0X2lkLCBzaXplLCBNQ0hJUF9OQl9QQUdFUyk7Cn0KCi8qIHJlYWQgYSBjb21wcmVzc2VkIGZyYW1lIGZyb20gdGhlIGZyYW1lYnVmZmVyICovCnN0YXRpYyBpbnQgbWNoaXBfY29tcF9yZWFkX2ZyYW1lKHUzMiB2LCB1OCAqYnVmLCBpbnQgc2l6ZSkKewoJaW50IHB0X3N0YXJ0LCBwdF9lbmQsIHRyYWlsZXI7CglpbnQgZnNpemU7CglpbnQgaTsKCglwdF9zdGFydCA9ICh2ID4+IDE5KSAmIDB4RkY7CglwdF9lbmQgPSAodiA+PiAxMSkgJiAweEZGOwoJdHJhaWxlciA9ICh2ID4+IDEpICYgMHgzRkY7CgoJaWYgKHB0X2VuZCA8IHB0X3N0YXJ0KQoJCWZzaXplID0gKE1DSElQX05CX1BBR0VTX01KUEVHIC0gcHRfc3RhcnQpICogUEFHRV9TSVpFICsKCQkJcHRfZW5kICogUEFHRV9TSVpFICsgdHJhaWxlciAqIDQ7CgllbHNlCgkJZnNpemUgPSAocHRfZW5kIC0gcHRfc3RhcnQpICogUEFHRV9TSVpFICsgdHJhaWxlciAqIDQ7CgoJaWYgKGZzaXplID4gc2l6ZSkgewoJCXByaW50ayhLRVJOX1dBUk5JTkcgIm1leWU6IG92ZXJzaXplZCBjb21wcmVzc2VkIGZyYW1lICVkXG4iLAoJCSAgICAgICBmc2l6ZSk7CgkJcmV0dXJuIC0xOwoJfQoKCXB0YWJsZV9jb3B5KGJ1ZiwgcHRfc3RhcnQsIGZzaXplLCBNQ0hJUF9OQl9QQUdFU19NSlBFRyk7CgojaWZkZWYgTUVZRV9KUEVHX0NPUlJFQ1RJT04KCgkvKiBTb21lIG1jaGlwIGdlbmVyYXRlZCBqcGVnIGZyYW1lcyBhcmUgaW5jb3JyZWN0LiBJbiBtb3N0CgkgKiAoYWxsID8pIG9mIHRob3NlIGNhc2VzLCB0aGUgZmluYWwgRU9JICgweGZmIDB4ZDkpIG1hcmtlcgoJICogaXMgbm90IHByZXNlbnQgYXQgdGhlIGVuZCBvZiB0aGUgZnJhbWUuCgkgKgoJICogU2luY2UgYWRkaW5nIHRoZSBmaW5hbCBtYXJrZXIgaXMgbm90IGVub3VnaCB0byByZXN0b3JlCgkgKiB0aGUganBlZyBpbnRlZ3JpdHksIHdlIGRyb3AgdGhlIGZyYW1lLgoJICovCgoJZm9yIChpID0gZnNpemUgLSAxOyBpID4gMCAmJiBidWZbaV0gPT0gMHhmZjsgaS0tKSA7CgoJaWYgKGkgPCAyIHx8IGJ1ZltpIC0gMV0gIT0gMHhmZiB8fCBidWZbaV0gIT0gMHhkOSkKCQlyZXR1cm4gLTE7CgojZW5kaWYKCglyZXR1cm4gZnNpemU7Cn0KCi8qIHRha2UgYSBwaWN0dXJlIGludG8gU0RSQU0gKi8Kc3RhdGljIHZvaWQgbWNoaXBfdGFrZV9waWN0dXJlKHZvaWQpCnsKCWludCBpOwoKCW1jaGlwX2hpY19zdG9wKCk7CgltY2hpcF9zdWJzYW1wbGUoKTsKCW1jaGlwX2RtYV9zZXR1cChtZXllLm1jaGlwX2RtYWhhbmRsZSk7CgoJbWNoaXBfc2V0KE1DSElQX0hJQ19NT0RFLCBNQ0hJUF9ISUNfTU9ERV9TVElMTF9DQVApOwoJbWNoaXBfc2V0KE1DSElQX0hJQ19DTUQsIE1DSElQX0hJQ19DTURfU1RBUlQpOwoKCW1jaGlwX2RlbGF5KE1DSElQX0hJQ19DTUQsIDApOwoKCWZvciAoaSA9IDA7IGkgPCAxMDA7ICsraSkgewoJCWlmIChtY2hpcF9kZWxheShNQ0hJUF9ISUNfU1RBVFVTLCBNQ0hJUF9ISUNfU1RBVFVTX0lETEUpKQoJCQlicmVhazsKCQltc2xlZXAoMSk7Cgl9Cn0KCi8qIGRtYSBhIHByZXZpb3VzbHkgdGFrZW4gcGljdHVyZSBpbnRvIGEgYnVmZmVyICovCnN0YXRpYyB2b2lkIG1jaGlwX2dldF9waWN0dXJlKHU4ICpidWYsIGludCBidWZzaXplKQp7Cgl1MzIgdjsKCWludCBpOwoKCW1jaGlwX3NldChNQ0hJUF9ISUNfTU9ERSwgTUNISVBfSElDX01PREVfU1RJTExfT1VUKTsKCW1jaGlwX3NldChNQ0hJUF9ISUNfQ01ELCBNQ0hJUF9ISUNfQ01EX1NUQVJUKTsKCgltY2hpcF9kZWxheShNQ0hJUF9ISUNfQ01ELCAwKTsKCWZvciAoaSA9IDA7IGkgPCAxMDA7ICsraSkgewoJCWlmIChtY2hpcF9kZWxheShNQ0hJUF9ISUNfU1RBVFVTLCBNQ0hJUF9ISUNfU1RBVFVTX0lETEUpKQoJCQlicmVhazsKCQltc2xlZXAoMSk7Cgl9Cglmb3IgKGkgPSAwOyBpIDwgNDsgKytpKSB7CgkJdiA9IG1jaGlwX2dldF9mcmFtZSgpOwoJCWlmICh2ICYgTUNISVBfTU1fRklSX1JEWSkgewoJCQltY2hpcF9jb250X3JlYWRfZnJhbWUodiwgYnVmLCBidWZzaXplKTsKCQkJYnJlYWs7CgkJfQoJCW1jaGlwX2ZyZWVfZnJhbWUoKTsKCX0KfQoKLyogc3RhcnQgY29udGludW91cyBkbWEgY2FwdHVyZSAqLwpzdGF0aWMgdm9pZCBtY2hpcF9jb250aW51b3VzX3N0YXJ0KHZvaWQpCnsKCW1jaGlwX2hpY19zdG9wKCk7CgltY2hpcF9zdWJzYW1wbGUoKTsKCW1jaGlwX3NldF9mcmFtZXJhdGUoKTsKCW1jaGlwX2RtYV9zZXR1cChtZXllLm1jaGlwX2RtYWhhbmRsZSk7CgoJbWV5ZS5tY2hpcF9tb2RlID0gTUNISVBfSElDX01PREVfQ09OVF9PVVQ7CgoJbWNoaXBfc2V0KE1DSElQX0hJQ19NT0RFLCBNQ0hJUF9ISUNfTU9ERV9DT05UX09VVCk7CgltY2hpcF9zZXQoTUNISVBfSElDX0NNRCwgTUNISVBfSElDX0NNRF9TVEFSVCk7CgoJbWNoaXBfZGVsYXkoTUNISVBfSElDX0NNRCwgMCk7Cn0KCi8qIGNvbXByZXNzIG9uZSBmcmFtZSBpbnRvIGEgYnVmZmVyICovCnN0YXRpYyBpbnQgbWNoaXBfY29tcHJlc3NfZnJhbWUodTggKmJ1ZiwgaW50IGJ1ZnNpemUpCnsKCXUzMiB2OwoJaW50IGxlbiA9IC0xLCBpOwoKCW1jaGlwX3Zyal9zZXR1cCgweDNmKTsKCXVkZWxheSg1MCk7CgoJbWNoaXBfc2V0KE1DSElQX0hJQ19NT0RFLCBNQ0hJUF9ISUNfTU9ERV9TVElMTF9DT01QKTsKCW1jaGlwX3NldChNQ0hJUF9ISUNfQ01ELCBNQ0hJUF9ISUNfQ01EX1NUQVJUKTsKCgltY2hpcF9kZWxheShNQ0hJUF9ISUNfQ01ELCAwKTsKCWZvciAoaSA9IDA7IGkgPCAxMDA7ICsraSkgewoJCWlmIChtY2hpcF9kZWxheShNQ0hJUF9ISUNfU1RBVFVTLCBNQ0hJUF9ISUNfU1RBVFVTX0lETEUpKQoJCQlicmVhazsKCQltc2xlZXAoMSk7Cgl9CgoJZm9yIChpID0gMDsgaSA8IDQ7ICsraSkgewoJCXYgPSBtY2hpcF9nZXRfZnJhbWUoKTsKCQlpZiAodiAmIE1DSElQX01NX0ZJUl9SRFkpIHsKCQkJbGVuID0gbWNoaXBfY29tcF9yZWFkX2ZyYW1lKHYsIGJ1ZiwgYnVmc2l6ZSk7CgkJCWJyZWFrOwoJCX0KCQltY2hpcF9mcmVlX2ZyYW1lKCk7Cgl9CglyZXR1cm4gbGVuOwp9CgojaWYgMAovKiB1bmNvbXByZXNzIG9uZSBpbWFnZSBpbnRvIGEgYnVmZmVyICovCnN0YXRpYyBpbnQgbWNoaXBfdW5jb21wcmVzc19mcmFtZSh1OCAqaW1nLCBpbnQgaW1nc2l6ZSwgdTggKmJ1ZiwgaW50IGJ1ZnNpemUpCnsKCW1jaGlwX3Zyal9zZXR1cCgweDNmKTsKCXVkZWxheSg1MCk7CgoJbWNoaXBfc2V0KE1DSElQX0hJQ19NT0RFLCBNQ0hJUF9ISUNfTU9ERV9TVElMTF9ERUNPTVApOwoJbWNoaXBfc2V0KE1DSElQX0hJQ19DTUQsIE1DSElQX0hJQ19DTURfU1RBUlQpOwoKCW1jaGlwX2RlbGF5KE1DSElQX0hJQ19DTUQsIDApOwoKCXJldHVybiBtY2hpcF9jb21wX3JlYWRfZnJhbWUoYnVmLCBidWZzaXplKTsKfQojZW5kaWYKCi8qIHN0YXJ0IGNvbnRpbnVvdXMgY29tcHJlc3NlZCBjYXB0dXJlICovCnN0YXRpYyB2b2lkIG1jaGlwX2NvbnRfY29tcHJlc3Npb25fc3RhcnQodm9pZCkKewoJbWNoaXBfaGljX3N0b3AoKTsKCW1jaGlwX3Zyal9zZXR1cCgweDNmKTsKCW1jaGlwX3N1YnNhbXBsZSgpOwoJbWNoaXBfc2V0X2ZyYW1lcmF0ZSgpOwoJbWNoaXBfZG1hX3NldHVwKG1leWUubWNoaXBfZG1haGFuZGxlKTsKCgltZXllLm1jaGlwX21vZGUgPSBNQ0hJUF9ISUNfTU9ERV9DT05UX0NPTVA7CgoJbWNoaXBfc2V0KE1DSElQX0hJQ19NT0RFLCBNQ0hJUF9ISUNfTU9ERV9DT05UX0NPTVApOwoJbWNoaXBfc2V0KE1DSElQX0hJQ19DTUQsIE1DSElQX0hJQ19DTURfU1RBUlQpOwoKCW1jaGlwX2RlbGF5KE1DSElQX0hJQ19DTUQsIDApOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLyogSW50ZXJydXB0IGhhbmRsaW5nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIGlycXJldHVybl90IG1leWVfaXJxKGludCBpcnEsIHZvaWQgKmRldl9pZCkKewoJdTMyIHY7CglpbnQgcmVxbnI7CglzdGF0aWMgaW50IHNlcXVlbmNlID0gMDsKCgl2ID0gbWNoaXBfcmVhZChNQ0hJUF9NTV9JTlRBKTsKCglpZiAobWV5ZS5tY2hpcF9tb2RlICE9IE1DSElQX0hJQ19NT0RFX0NPTlRfT1VUICYmCgkgICAgbWV5ZS5tY2hpcF9tb2RlICE9IE1DSElQX0hJQ19NT0RFX0NPTlRfQ09NUCkKCQlyZXR1cm4gSVJRX05PTkU7CgphZ2FpbjoKCXYgPSBtY2hpcF9nZXRfZnJhbWUoKTsKCWlmICghKHYgJiBNQ0hJUF9NTV9GSVJfUkRZKSkKCQlyZXR1cm4gSVJRX0hBTkRMRUQ7CgoJaWYgKG1leWUubWNoaXBfbW9kZSA9PSBNQ0hJUF9ISUNfTU9ERV9DT05UX09VVCkgewoJCWlmIChrZmlmb19nZXQobWV5ZS5ncmFicSwgKHVuc2lnbmVkIGNoYXIgKikmcmVxbnIsCgkJCSAgICAgIHNpemVvZihpbnQpKSAhPSBzaXplb2YoaW50KSkgewoJCQltY2hpcF9mcmVlX2ZyYW1lKCk7CgkJCXJldHVybiBJUlFfSEFORExFRDsKCQl9CgkJbWNoaXBfY29udF9yZWFkX2ZyYW1lKHYsIG1leWUuZ3JhYl9mYnVmZmVyICsgZ2J1ZnNpemUgKiByZXFuciwKCQkJCSAgICAgIG1jaGlwX2hzaXplKCkgKiBtY2hpcF92c2l6ZSgpICogMik7CgkJbWV5ZS5ncmFiX2J1ZmZlcltyZXFucl0uc2l6ZSA9IG1jaGlwX2hzaXplKCkgKiBtY2hpcF92c2l6ZSgpICogMjsKCQltZXllLmdyYWJfYnVmZmVyW3JlcW5yXS5zdGF0ZSA9IE1FWUVfQlVGX0RPTkU7CgkJZG9fZ2V0dGltZW9mZGF5KCZtZXllLmdyYWJfYnVmZmVyW3JlcW5yXS50aW1lc3RhbXApOwoJCW1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnNlcXVlbmNlID0gc2VxdWVuY2UrKzsKCQlrZmlmb19wdXQobWV5ZS5kb25lcSwgKHVuc2lnbmVkIGNoYXIgKikmcmVxbnIsIHNpemVvZihpbnQpKTsKCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJm1leWUucHJvY19saXN0KTsKCX0gZWxzZSB7CgkJaW50IHNpemU7CgkJc2l6ZSA9IG1jaGlwX2NvbXBfcmVhZF9mcmFtZSh2LCBtZXllLmdyYWJfdGVtcCwgZ2J1ZnNpemUpOwoJCWlmIChzaXplID09IC0xKSB7CgkJCW1jaGlwX2ZyZWVfZnJhbWUoKTsKCQkJZ290byBhZ2FpbjsKCQl9CgkJaWYgKGtmaWZvX2dldChtZXllLmdyYWJxLCAodW5zaWduZWQgY2hhciAqKSZyZXFuciwKCQkJICAgICAgc2l6ZW9mKGludCkpICE9IHNpemVvZihpbnQpKSB7CgkJCW1jaGlwX2ZyZWVfZnJhbWUoKTsKCQkJZ290byBhZ2FpbjsKCQl9CgkJbWVtY3B5KG1leWUuZ3JhYl9mYnVmZmVyICsgZ2J1ZnNpemUgKiByZXFuciwgbWV5ZS5ncmFiX3RlbXAsCgkJICAgICAgIHNpemUpOwoJCW1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnNpemUgPSBzaXplOwoJCW1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnN0YXRlID0gTUVZRV9CVUZfRE9ORTsKCQlkb19nZXR0aW1lb2ZkYXkoJm1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnRpbWVzdGFtcCk7CgkJbWV5ZS5ncmFiX2J1ZmZlcltyZXFucl0uc2VxdWVuY2UgPSBzZXF1ZW5jZSsrOwoJCWtmaWZvX3B1dChtZXllLmRvbmVxLCAodW5zaWduZWQgY2hhciAqKSZyZXFuciwgc2l6ZW9mKGludCkpOwoJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmbWV5ZS5wcm9jX2xpc3QpOwoJfQoJbWNoaXBfZnJlZV9mcmFtZSgpOwoJZ290byBhZ2FpbjsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qIHZpZGVvNGxpbnV4IGludGVncmF0aW9uICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCnN0YXRpYyBpbnQgbWV5ZV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQp7CglpbnQgaSwgZXJyOwoKCWVyciA9IHZpZGVvX2V4Y2x1c2l2ZV9vcGVuKGlub2RlLCBmaWxlKTsKCWlmIChlcnIgPCAwKQoJCXJldHVybiBlcnI7CgoJbWNoaXBfaGljX3N0b3AoKTsKCglpZiAobWNoaXBfZG1hX2FsbG9jKCkpIHsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IG1jaGlwIGZyYW1lYnVmZmVyIGFsbG9jYXRpb24gZmFpbGVkXG4iKTsKCQl2aWRlb19leGNsdXNpdmVfcmVsZWFzZShpbm9kZSwgZmlsZSk7CgkJcmV0dXJuIC1FTk9CVUZTOwoJfQoKCWZvciAoaSA9IDA7IGkgPCBNRVlFX01BWF9CVUZOQlJTOyBpKyspCgkJbWV5ZS5ncmFiX2J1ZmZlcltpXS5zdGF0ZSA9IE1FWUVfQlVGX1VOVVNFRDsKCWtmaWZvX3Jlc2V0KG1leWUuZ3JhYnEpOwoJa2ZpZm9fcmVzZXQobWV5ZS5kb25lcSk7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBtZXllX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCW1jaGlwX2hpY19zdG9wKCk7CgltY2hpcF9kbWFfZnJlZSgpOwoJdmlkZW9fZXhjbHVzaXZlX3JlbGVhc2UoaW5vZGUsIGZpbGUpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgbWV5ZV9kb19pb2N0bChzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSwKCQkJIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgKmFyZykKewoJc3dpdGNoIChjbWQpIHsKCgljYXNlIFZJRElPQ0dDQVA6IHsKCQlzdHJ1Y3QgdmlkZW9fY2FwYWJpbGl0eSAqYiA9IGFyZzsKCQlzdHJjcHkoYi0+bmFtZSxtZXllLnZpZGVvX2Rldi0+bmFtZSk7CgkJYi0+dHlwZSA9IFZJRF9UWVBFX0NBUFRVUkU7CgkJYi0+Y2hhbm5lbHMgPSAxOwoJCWItPmF1ZGlvcyA9IDA7CgkJYi0+bWF4d2lkdGggPSA2NDA7CgkJYi0+bWF4aGVpZ2h0ID0gNDgwOwoJCWItPm1pbndpZHRoID0gMzIwOwoJCWItPm1pbmhlaWdodCA9IDI0MDsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ0dDSEFOOiB7CgkJc3RydWN0IHZpZGVvX2NoYW5uZWwgKnYgPSBhcmc7CgkJdi0+ZmxhZ3MgPSAwOwoJCXYtPnR1bmVycyA9IDA7CgkJdi0+dHlwZSA9IFZJREVPX1RZUEVfQ0FNRVJBOwoJCWlmICh2LT5jaGFubmVsICE9IDApCgkJCXJldHVybiAtRUlOVkFMOwoJCXN0cmNweSh2LT5uYW1lLCJDYW1lcmEiKTsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ1NDSEFOOiB7CgkJc3RydWN0IHZpZGVvX2NoYW5uZWwgKnYgPSBhcmc7CgkJaWYgKHYtPmNoYW5uZWwgIT0gMCkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJYnJlYWs7Cgl9CgoJY2FzZSBWSURJT0NHUElDVDogewoJCXN0cnVjdCB2aWRlb19waWN0dXJlICpwID0gYXJnOwoJCSpwID0gbWV5ZS5waWN0dXJlOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DU1BJQ1Q6IHsKCQlzdHJ1Y3QgdmlkZW9fcGljdHVyZSAqcCA9IGFyZzsKCQlpZiAocC0+ZGVwdGggIT0gMTYpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChwLT5wYWxldHRlICE9IFZJREVPX1BBTEVUVEVfWVVWNDIyKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQltdXRleF9sb2NrKCZtZXllLmxvY2spOwoJCXNvbnlwaV9jYW1lcmFfY29tbWFuZChTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFCUklHSFRORVNTLAoJCQkJICAgICAgcC0+YnJpZ2h0bmVzcyA+PiAxMCk7CgkJc29ueXBpX2NhbWVyYV9jb21tYW5kKFNPTllQSV9DT01NQU5EX1NFVENBTUVSQUhVRSwKCQkJCSAgICAgIHAtPmh1ZSA+PiAxMCk7CgkJc29ueXBpX2NhbWVyYV9jb21tYW5kKFNPTllQSV9DT01NQU5EX1NFVENBTUVSQUNPTE9SLAoJCQkJICAgICAgcC0+Y29sb3VyID4+IDEwKTsKCQlzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBQ09OVFJBU1QsCgkJCQkgICAgICBwLT5jb250cmFzdCA+PiAxMCk7CgkJbWV5ZS5waWN0dXJlID0gKnA7CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DU1lOQzogewoJCWludCAqaSA9IGFyZzsKCQlpbnQgdW51c2VkOwoKCQlpZiAoKmkgPCAwIHx8ICppID49IGdidWZmZXJzKQoJCQlyZXR1cm4gLUVJTlZBTDsKCgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCgkJc3dpdGNoIChtZXllLmdyYWJfYnVmZmVyWyppXS5zdGF0ZSkgewoKCQljYXNlIE1FWUVfQlVGX1VOVVNFRDoKCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQlyZXR1cm4gLUVJTlZBTDsKCQljYXNlIE1FWUVfQlVGX1VTSU5HOgoJCQlpZiAoZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spIHsKCQkJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQkJCXJldHVybiAtRUFHQUlOOwoJCQl9CgkJCWlmICh3YWl0X2V2ZW50X2ludGVycnVwdGlibGUobWV5ZS5wcm9jX2xpc3QsCgkJCQkJCSAgICAgKG1leWUuZ3JhYl9idWZmZXJbKmldLnN0YXRlICE9IE1FWUVfQlVGX1VTSU5HKSkpIHsKCQkJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQkJCXJldHVybiAtRUlOVFI7CgkJCX0KCQkJLyogZmFsbCB0aHJvdWdoICovCgkJY2FzZSBNRVlFX0JVRl9ET05FOgoJCQltZXllLmdyYWJfYnVmZmVyWyppXS5zdGF0ZSA9IE1FWUVfQlVGX1VOVVNFRDsKCQkJa2ZpZm9fZ2V0KG1leWUuZG9uZXEsICh1bnNpZ25lZCBjaGFyICopJnVudXNlZCwgc2l6ZW9mKGludCkpOwoJCX0KCQltdXRleF91bmxvY2soJm1leWUubG9jayk7CgkJYnJlYWs7Cgl9CgoJY2FzZSBWSURJT0NNQ0FQVFVSRTogewoJCXN0cnVjdCB2aWRlb19tbWFwICp2bSA9IGFyZzsKCQlpbnQgcmVzdGFydCA9IDA7CgoJCWlmICh2bS0+ZnJhbWUgPj0gZ2J1ZmZlcnMgfHwgdm0tPmZyYW1lIDwgMCkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJaWYgKHZtLT5mb3JtYXQgIT0gVklERU9fUEFMRVRURV9ZVVY0MjIpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmICh2bS0+aGVpZ2h0ICogdm0tPndpZHRoICogMiA+IGdidWZzaXplKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoIW1leWUuZ3JhYl9mYnVmZmVyKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAobWV5ZS5ncmFiX2J1ZmZlclt2bS0+ZnJhbWVdLnN0YXRlICE9IE1FWUVfQlVGX1VOVVNFRCkKCQkJcmV0dXJuIC1FQlVTWTsKCgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQlpZiAodm0tPndpZHRoID09IDY0MCAmJiB2bS0+aGVpZ2h0ID09IDQ4MCkgewoJCQlpZiAobWV5ZS5wYXJhbXMuc3Vic2FtcGxlKSB7CgkJCQltZXllLnBhcmFtcy5zdWJzYW1wbGUgPSAwOwoJCQkJcmVzdGFydCA9IDE7CgkJCX0KCQl9IGVsc2UgaWYgKHZtLT53aWR0aCA9PSAzMjAgJiYgdm0tPmhlaWdodCA9PSAyNDApIHsKCQkJaWYgKCFtZXllLnBhcmFtcy5zdWJzYW1wbGUpIHsKCQkJCW1leWUucGFyYW1zLnN1YnNhbXBsZSA9IDE7CgkJCQlyZXN0YXJ0ID0gMTsKCQkJfQoJCX0gZWxzZSB7CgkJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQkJcmV0dXJuIC1FSU5WQUw7CgkJfQoKCQlpZiAocmVzdGFydCB8fCBtZXllLm1jaGlwX21vZGUgIT0gTUNISVBfSElDX01PREVfQ09OVF9PVVQpCgkJCW1jaGlwX2NvbnRpbnVvdXNfc3RhcnQoKTsKCQltZXllLmdyYWJfYnVmZmVyW3ZtLT5mcmFtZV0uc3RhdGUgPSBNRVlFX0JVRl9VU0lORzsKCQlrZmlmb19wdXQobWV5ZS5ncmFicSwgKHVuc2lnbmVkIGNoYXIgKikmdm0tPmZyYW1lLCBzaXplb2YoaW50KSk7CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DR01CVUY6IHsKCQlzdHJ1Y3QgdmlkZW9fbWJ1ZiAqdm0gPSBhcmc7CgkJaW50IGk7CgoJCW1lbXNldCh2bSwgMCAsIHNpemVvZigqdm0pKTsKCQl2bS0+c2l6ZSA9IGdidWZzaXplICogZ2J1ZmZlcnM7CgkJdm0tPmZyYW1lcyA9IGdidWZmZXJzOwoJCWZvciAoaSA9IDA7IGkgPCBnYnVmZmVyczsgaSsrKQoJCQl2bS0+b2Zmc2V0c1tpXSA9IGkgKiBnYnVmc2l6ZTsKCQlicmVhazsKCX0KCgljYXNlIE1FWUVJT0NfR19QQVJBTVM6IHsKCQlzdHJ1Y3QgbWV5ZV9wYXJhbXMgKnAgPSBhcmc7CgkJKnAgPSBtZXllLnBhcmFtczsKCQlicmVhazsKCX0KCgljYXNlIE1FWUVJT0NfU19QQVJBTVM6IHsKCQlzdHJ1Y3QgbWV5ZV9wYXJhbXMgKmpwID0gYXJnOwoJCWlmIChqcC0+c3Vic2FtcGxlID4gMSkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJaWYgKGpwLT5xdWFsaXR5ID4gMTApCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChqcC0+c2hhcnBuZXNzID4gNjMgfHwganAtPmFnYyA+IDYzIHx8IGpwLT5waWN0dXJlID4gNjMpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChqcC0+ZnJhbWVyYXRlID4gMzEpCgkJCXJldHVybiAtRUlOVkFMOwoJCW11dGV4X2xvY2soJm1leWUubG9jayk7CgkJaWYgKG1leWUucGFyYW1zLnN1YnNhbXBsZSAhPSBqcC0+c3Vic2FtcGxlIHx8CgkJICAgIG1leWUucGFyYW1zLnF1YWxpdHkgIT0ganAtPnF1YWxpdHkpCgkJCW1jaGlwX2hpY19zdG9wKCk7CS8qIG5lZWQgcmVzdGFydCAqLwoJCW1leWUucGFyYW1zID0gKmpwOwoJCXNvbnlwaV9jYW1lcmFfY29tbWFuZChTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFTSEFSUE5FU1MsCgkJCQkgICAgICBtZXllLnBhcmFtcy5zaGFycG5lc3MpOwoJCXNvbnlwaV9jYW1lcmFfY29tbWFuZChTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFBR0MsCgkJCQkgICAgICBtZXllLnBhcmFtcy5hZ2MpOwoJCXNvbnlwaV9jYW1lcmFfY29tbWFuZChTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFQSUNUVVJFLAoJCQkJICAgICAgbWV5ZS5wYXJhbXMucGljdHVyZSk7CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWJyZWFrOwoJfQoKCWNhc2UgTUVZRUlPQ19RQlVGX0NBUFQ6IHsKCQlpbnQgKm5iID0gYXJnOwoKCQlpZiAoIW1leWUuZ3JhYl9mYnVmZmVyKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoKm5iID49IGdidWZmZXJzKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoKm5iIDwgMCkgewoJCQkvKiBzdG9wIGNhcHR1cmUgKi8KCQkJbWNoaXBfaGljX3N0b3AoKTsKCQkJcmV0dXJuIDA7CgkJfQoJCWlmIChtZXllLmdyYWJfYnVmZmVyWypuYl0uc3RhdGUgIT0gTUVZRV9CVUZfVU5VU0VEKQoJCQlyZXR1cm4gLUVCVVNZOwoJCW11dGV4X2xvY2soJm1leWUubG9jayk7CgkJaWYgKG1leWUubWNoaXBfbW9kZSAhPSBNQ0hJUF9ISUNfTU9ERV9DT05UX0NPTVApCgkJCW1jaGlwX2NvbnRfY29tcHJlc3Npb25fc3RhcnQoKTsKCQltZXllLmdyYWJfYnVmZmVyWypuYl0uc3RhdGUgPSBNRVlFX0JVRl9VU0lORzsKCQlrZmlmb19wdXQobWV5ZS5ncmFicSwgKHVuc2lnbmVkIGNoYXIgKiluYiwgc2l6ZW9mKGludCkpOwoJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQlicmVhazsKCX0KCgljYXNlIE1FWUVJT0NfU1lOQzogewoJCWludCAqaSA9IGFyZzsKCQlpbnQgdW51c2VkOwoKCQlpZiAoKmkgPCAwIHx8ICppID49IGdidWZmZXJzKQoJCQlyZXR1cm4gLUVJTlZBTDsKCgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQlzd2l0Y2ggKG1leWUuZ3JhYl9idWZmZXJbKmldLnN0YXRlKSB7CgoJCWNhc2UgTUVZRV9CVUZfVU5VU0VEOgoJCQltdXRleF91bmxvY2soJm1leWUubG9jayk7CgkJCXJldHVybiAtRUlOVkFMOwoJCWNhc2UgTUVZRV9CVUZfVVNJTkc6CgkJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykgewoJCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQkJcmV0dXJuIC1FQUdBSU47CgkJCX0KCQkJaWYgKHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShtZXllLnByb2NfbGlzdCwKCQkJCQkJICAgICAobWV5ZS5ncmFiX2J1ZmZlclsqaV0uc3RhdGUgIT0gTUVZRV9CVUZfVVNJTkcpKSkgewoJCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQkJcmV0dXJuIC1FSU5UUjsKCQkJfQoJCQkvKiBmYWxsIHRocm91Z2ggKi8KCQljYXNlIE1FWUVfQlVGX0RPTkU6CgkJCW1leWUuZ3JhYl9idWZmZXJbKmldLnN0YXRlID0gTUVZRV9CVUZfVU5VU0VEOwoJCQlrZmlmb19nZXQobWV5ZS5kb25lcSwgKHVuc2lnbmVkIGNoYXIgKikmdW51c2VkLCBzaXplb2YoaW50KSk7CgkJfQoJCSppID0gbWV5ZS5ncmFiX2J1ZmZlclsqaV0uc2l6ZTsKCQltdXRleF91bmxvY2soJm1leWUubG9jayk7CgkJYnJlYWs7Cgl9CgoJY2FzZSBNRVlFSU9DX1NUSUxMQ0FQVDogewoKCQlpZiAoIW1leWUuZ3JhYl9mYnVmZmVyKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAobWV5ZS5ncmFiX2J1ZmZlclswXS5zdGF0ZSAhPSBNRVlFX0JVRl9VTlVTRUQpCgkJCXJldHVybiAtRUJVU1k7CgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQltZXllLmdyYWJfYnVmZmVyWzBdLnN0YXRlID0gTUVZRV9CVUZfVVNJTkc7CgkJbWNoaXBfdGFrZV9waWN0dXJlKCk7CgkJbWNoaXBfZ2V0X3BpY3R1cmUoCgkJCW1leWUuZ3JhYl9mYnVmZmVyLAoJCQltY2hpcF9oc2l6ZSgpICogbWNoaXBfdnNpemUoKSAqIDIpOwoJCW1leWUuZ3JhYl9idWZmZXJbMF0uc3RhdGUgPSBNRVlFX0JVRl9ET05FOwoJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQlicmVhazsKCX0KCgljYXNlIE1FWUVJT0NfU1RJTExKQ0FQVDogewoJCWludCAqbGVuID0gYXJnOwoKCQlpZiAoIW1leWUuZ3JhYl9mYnVmZmVyKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAobWV5ZS5ncmFiX2J1ZmZlclswXS5zdGF0ZSAhPSBNRVlFX0JVRl9VTlVTRUQpCgkJCXJldHVybiAtRUJVU1k7CgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQltZXllLmdyYWJfYnVmZmVyWzBdLnN0YXRlID0gTUVZRV9CVUZfVVNJTkc7CgkJKmxlbiA9IC0xOwoJCXdoaWxlICgqbGVuID09IC0xKSB7CgkJCW1jaGlwX3Rha2VfcGljdHVyZSgpOwoJCQkqbGVuID0gbWNoaXBfY29tcHJlc3NfZnJhbWUobWV5ZS5ncmFiX2ZidWZmZXIsIGdidWZzaXplKTsKCQl9CgkJbWV5ZS5ncmFiX2J1ZmZlclswXS5zdGF0ZSA9IE1FWUVfQlVGX0RPTkU7CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DX1FVRVJZQ0FQOiB7CgkJc3RydWN0IHY0bDJfY2FwYWJpbGl0eSAqY2FwID0gYXJnOwoKCQlpZiAoZm9yY2V2NGwxKQoJCQlyZXR1cm4gLUVJTlZBTDsKCgkJbWVtc2V0KGNhcCwgMCwgc2l6ZW9mKCpjYXApKTsKCQlzdHJjcHkoY2FwLT5kcml2ZXIsICJtZXllIik7CgkJc3RyY3B5KGNhcC0+Y2FyZCwgIm1leWUiKTsKCQlzcHJpbnRmKGNhcC0+YnVzX2luZm8sICJQQ0k6JXMiLCBwY2lfbmFtZShtZXllLm1jaGlwX2RldikpOwoJCWNhcC0+dmVyc2lvbiA9IChNRVlFX0RSSVZFUl9NQUpPUlZFUlNJT04gPDwgOCkgKwoJCQkgICAgICAgTUVZRV9EUklWRVJfTUlOT1JWRVJTSU9OOwoJCWNhcC0+Y2FwYWJpbGl0aWVzID0gVjRMMl9DQVBfVklERU9fQ0FQVFVSRSB8CgkJCQkgICAgVjRMMl9DQVBfU1RSRUFNSU5HOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DX0VOVU1JTlBVVDogewoJCXN0cnVjdCB2NGwyX2lucHV0ICppID0gYXJnOwoKCQlpZiAoaS0+aW5kZXggIT0gMCkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJbWVtc2V0KGksIDAsIHNpemVvZigqaSkpOwoJCWktPmluZGV4ID0gMDsKCQlzdHJjcHkoaS0+bmFtZSwgIkNhbWVyYSIpOwoJCWktPnR5cGUgPSBWNEwyX0lOUFVUX1RZUEVfQ0FNRVJBOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DX0dfSU5QVVQ6IHsKCQlpbnQgKmkgPSBhcmc7CgoJCSppID0gMDsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19TX0lOUFVUOiB7CgkJaW50ICppID0gYXJnOwoKCQlpZiAoKmkgIT0gMCkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJYnJlYWs7Cgl9CgoJY2FzZSBWSURJT0NfUVVFUllDVFJMOiB7CgkJc3RydWN0IHY0bDJfcXVlcnljdHJsICpjID0gYXJnOwoKCQlzd2l0Y2ggKGMtPmlkKSB7CgoJCWNhc2UgVjRMMl9DSURfQlJJR0hUTkVTUzoKCQkJYy0+dHlwZSA9IFY0TDJfQ1RSTF9UWVBFX0lOVEVHRVI7CgkJCXN0cmNweShjLT5uYW1lLCAiQnJpZ2h0bmVzcyIpOwoJCQljLT5taW5pbXVtID0gMDsKCQkJYy0+bWF4aW11bSA9IDYzOwoJCQljLT5zdGVwID0gMTsKCQkJYy0+ZGVmYXVsdF92YWx1ZSA9IDMyOwoJCQljLT5mbGFncyA9IDA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfSFVFOgoJCQljLT50eXBlID0gVjRMMl9DVFJMX1RZUEVfSU5URUdFUjsKCQkJc3RyY3B5KGMtPm5hbWUsICJIdWUiKTsKCQkJYy0+bWluaW11bSA9IDA7CgkJCWMtPm1heGltdW0gPSA2MzsKCQkJYy0+c3RlcCA9IDE7CgkJCWMtPmRlZmF1bHRfdmFsdWUgPSAzMjsKCQkJYy0+ZmxhZ3MgPSAwOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX0NPTlRSQVNUOgoJCQljLT50eXBlID0gVjRMMl9DVFJMX1RZUEVfSU5URUdFUjsKCQkJc3RyY3B5KGMtPm5hbWUsICJDb250cmFzdCIpOwoJCQljLT5taW5pbXVtID0gMDsKCQkJYy0+bWF4aW11bSA9IDYzOwoJCQljLT5zdGVwID0gMTsKCQkJYy0+ZGVmYXVsdF92YWx1ZSA9IDMyOwoJCQljLT5mbGFncyA9IDA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfU0FUVVJBVElPTjoKCQkJYy0+dHlwZSA9IFY0TDJfQ1RSTF9UWVBFX0lOVEVHRVI7CgkJCXN0cmNweShjLT5uYW1lLCAiU2F0dXJhdGlvbiIpOwoJCQljLT5taW5pbXVtID0gMDsKCQkJYy0+bWF4aW11bSA9IDYzOwoJCQljLT5zdGVwID0gMTsKCQkJYy0+ZGVmYXVsdF92YWx1ZSA9IDMyOwoJCQljLT5mbGFncyA9IDA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfQUdDOgoJCQljLT50eXBlID0gVjRMMl9DVFJMX1RZUEVfSU5URUdFUjsKCQkJc3RyY3B5KGMtPm5hbWUsICJBZ2MiKTsKCQkJYy0+bWluaW11bSA9IDA7CgkJCWMtPm1heGltdW0gPSA2MzsKCQkJYy0+c3RlcCA9IDE7CgkJCWMtPmRlZmF1bHRfdmFsdWUgPSA0ODsKCQkJYy0+ZmxhZ3MgPSAwOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX1NIQVJQTkVTUzoKCQkJYy0+dHlwZSA9IFY0TDJfQ1RSTF9UWVBFX0lOVEVHRVI7CgkJCXN0cmNweShjLT5uYW1lLCAiU2hhcnBuZXNzIik7CgkJCWMtPm1pbmltdW0gPSAwOwoJCQljLT5tYXhpbXVtID0gNjM7CgkJCWMtPnN0ZXAgPSAxOwoJCQljLT5kZWZhdWx0X3ZhbHVlID0gMzI7CgkJCWMtPmZsYWdzID0gMDsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9QSUNUVVJFOgoJCQljLT50eXBlID0gVjRMMl9DVFJMX1RZUEVfSU5URUdFUjsKCQkJc3RyY3B5KGMtPm5hbWUsICJQaWN0dXJlIik7CgkJCWMtPm1pbmltdW0gPSAwOwoJCQljLT5tYXhpbXVtID0gNjM7CgkJCWMtPnN0ZXAgPSAxOwoJCQljLT5kZWZhdWx0X3ZhbHVlID0gMDsKCQkJYy0+ZmxhZ3MgPSAwOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX0pQRUdRVUFMOgoJCQljLT50eXBlID0gVjRMMl9DVFJMX1RZUEVfSU5URUdFUjsKCQkJc3RyY3B5KGMtPm5hbWUsICJKUEVHIHF1YWxpdHkiKTsKCQkJYy0+bWluaW11bSA9IDA7CgkJCWMtPm1heGltdW0gPSAxMDsKCQkJYy0+c3RlcCA9IDE7CgkJCWMtPmRlZmF1bHRfdmFsdWUgPSA4OwoJCQljLT5mbGFncyA9IDA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfRlJBTUVSQVRFOgoJCQljLT50eXBlID0gVjRMMl9DVFJMX1RZUEVfSU5URUdFUjsKCQkJc3RyY3B5KGMtPm5hbWUsICJGcmFtZXJhdGUiKTsKCQkJYy0+bWluaW11bSA9IDA7CgkJCWMtPm1heGltdW0gPSAzMTsKCQkJYy0+c3RlcCA9IDE7CgkJCWMtPmRlZmF1bHRfdmFsdWUgPSAwOwoJCQljLT5mbGFncyA9IDA7CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCXJldHVybiAtRUlOVkFMOwoJCX0KCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19TX0NUUkw6IHsKCQlzdHJ1Y3QgdjRsMl9jb250cm9sICpjID0gYXJnOwoKCQltdXRleF9sb2NrKCZtZXllLmxvY2spOwoJCXN3aXRjaCAoYy0+aWQpIHsKCQljYXNlIFY0TDJfQ0lEX0JSSUdIVE5FU1M6CgkJCXNvbnlwaV9jYW1lcmFfY29tbWFuZCgKCQkJCVNPTllQSV9DT01NQU5EX1NFVENBTUVSQUJSSUdIVE5FU1MsIGMtPnZhbHVlKTsKCQkJbWV5ZS5waWN0dXJlLmJyaWdodG5lc3MgPSBjLT52YWx1ZSA8PCAxMDsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9IVUU6CgkJCXNvbnlwaV9jYW1lcmFfY29tbWFuZCgKCQkJCVNPTllQSV9DT01NQU5EX1NFVENBTUVSQUhVRSwgYy0+dmFsdWUpOwoJCQltZXllLnBpY3R1cmUuaHVlID0gYy0+dmFsdWUgPDwgMTA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfQ09OVFJBU1Q6CgkJCXNvbnlwaV9jYW1lcmFfY29tbWFuZCgKCQkJCVNPTllQSV9DT01NQU5EX1NFVENBTUVSQUNPTlRSQVNULCBjLT52YWx1ZSk7CgkJCW1leWUucGljdHVyZS5jb250cmFzdCA9IGMtPnZhbHVlIDw8IDEwOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX1NBVFVSQVRJT046CgkJCXNvbnlwaV9jYW1lcmFfY29tbWFuZCgKCQkJCVNPTllQSV9DT01NQU5EX1NFVENBTUVSQUNPTE9SLCBjLT52YWx1ZSk7CgkJCW1leWUucGljdHVyZS5jb2xvdXIgPSBjLT52YWx1ZSA8PCAxMDsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9BR0M6CgkJCXNvbnlwaV9jYW1lcmFfY29tbWFuZCgKCQkJCVNPTllQSV9DT01NQU5EX1NFVENBTUVSQUFHQywgYy0+dmFsdWUpOwoJCQltZXllLnBhcmFtcy5hZ2MgPSBjLT52YWx1ZTsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9TSEFSUE5FU1M6CgkJCXNvbnlwaV9jYW1lcmFfY29tbWFuZCgKCQkJCVNPTllQSV9DT01NQU5EX1NFVENBTUVSQVNIQVJQTkVTUywgYy0+dmFsdWUpOwoJCQltZXllLnBhcmFtcy5zaGFycG5lc3MgPSBjLT52YWx1ZTsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9QSUNUVVJFOgoJCQlzb255cGlfY2FtZXJhX2NvbW1hbmQoCgkJCQlTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFQSUNUVVJFLCBjLT52YWx1ZSk7CgkJCW1leWUucGFyYW1zLnBpY3R1cmUgPSBjLT52YWx1ZTsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9KUEVHUVVBTDoKCQkJbWV5ZS5wYXJhbXMucXVhbGl0eSA9IGMtPnZhbHVlOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX0ZSQU1FUkFURToKCQkJbWV5ZS5wYXJhbXMuZnJhbWVyYXRlID0gYy0+dmFsdWU7CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQkJcmV0dXJuIC1FSU5WQUw7CgkJfQoJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19HX0NUUkw6IHsKCQlzdHJ1Y3QgdjRsMl9jb250cm9sICpjID0gYXJnOwoKCQltdXRleF9sb2NrKCZtZXllLmxvY2spOwoJCXN3aXRjaCAoYy0+aWQpIHsKCQljYXNlIFY0TDJfQ0lEX0JSSUdIVE5FU1M6CgkJCWMtPnZhbHVlID0gbWV5ZS5waWN0dXJlLmJyaWdodG5lc3MgPj4gMTA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfSFVFOgoJCQljLT52YWx1ZSA9IG1leWUucGljdHVyZS5odWUgPj4gMTA7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfQ09OVFJBU1Q6CgkJCWMtPnZhbHVlID0gbWV5ZS5waWN0dXJlLmNvbnRyYXN0ID4+IDEwOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX1NBVFVSQVRJT046CgkJCWMtPnZhbHVlID0gbWV5ZS5waWN0dXJlLmNvbG91ciA+PiAxMDsKCQkJYnJlYWs7CgkJY2FzZSBWNEwyX0NJRF9BR0M6CgkJCWMtPnZhbHVlID0gbWV5ZS5wYXJhbXMuYWdjOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX1NIQVJQTkVTUzoKCQkJYy0+dmFsdWUgPSBtZXllLnBhcmFtcy5zaGFycG5lc3M7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfUElDVFVSRToKCQkJYy0+dmFsdWUgPSBtZXllLnBhcmFtcy5waWN0dXJlOwoJCQlicmVhazsKCQljYXNlIFY0TDJfQ0lEX0pQRUdRVUFMOgoJCQljLT52YWx1ZSA9IG1leWUucGFyYW1zLnF1YWxpdHk7CgkJCWJyZWFrOwoJCWNhc2UgVjRMMl9DSURfRlJBTUVSQVRFOgoJCQljLT52YWx1ZSA9IG1leWUucGFyYW1zLmZyYW1lcmF0ZTsKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQlyZXR1cm4gLUVJTlZBTDsKCQl9CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DX0VOVU1fRk1UOiB7CgkJc3RydWN0IHY0bDJfZm10ZGVzYyAqZiA9IGFyZzsKCgkJaWYgKGYtPmluZGV4ID4gMSkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJaWYgKGYtPnR5cGUgIT0gVjRMMl9CVUZfVFlQRV9WSURFT19DQVBUVVJFKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoZi0+aW5kZXggPT0gMCkgewoJCQkvKiBzdGFuZGFyZCBZVVYgNDIyIGNhcHR1cmUgKi8KCQkJbWVtc2V0KGYsIDAsIHNpemVvZigqZikpOwoJCQlmLT5pbmRleCA9IDA7CgkJCWYtPnR5cGUgPSBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkU7CgkJCWYtPmZsYWdzID0gMDsKCQkJc3RyY3B5KGYtPmRlc2NyaXB0aW9uLCAiWVVWNDIyIik7CgkJCWYtPnBpeGVsZm9ybWF0ID0gVjRMMl9QSVhfRk1UX1lVWVY7CgkJfSBlbHNlIHsKCQkJLyogY29tcHJlc3NlZCBNSlBFRyBjYXB0dXJlICovCgkJCW1lbXNldChmLCAwLCBzaXplb2YoKmYpKTsKCQkJZi0+aW5kZXggPSAxOwoJCQlmLT50eXBlID0gVjRMMl9CVUZfVFlQRV9WSURFT19DQVBUVVJFOwoJCQlmLT5mbGFncyA9IFY0TDJfRk1UX0ZMQUdfQ09NUFJFU1NFRDsKCQkJc3RyY3B5KGYtPmRlc2NyaXB0aW9uLCAiTUpQRUciKTsKCQkJZi0+cGl4ZWxmb3JtYXQgPSBWNEwyX1BJWF9GTVRfTUpQRUc7CgkJfQoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DX1RSWV9GTVQ6IHsKCQlzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYgPSBhcmc7CgoJCWlmIChmLT50eXBlICE9IFY0TDJfQlVGX1RZUEVfVklERU9fQ0FQVFVSRSkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJaWYgKGYtPmZtdC5waXgucGl4ZWxmb3JtYXQgIT0gVjRMMl9QSVhfRk1UX1lVWVYgJiYKCQkgICAgZi0+Zm10LnBpeC5waXhlbGZvcm1hdCAhPSBWNEwyX1BJWF9GTVRfTUpQRUcpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChmLT5mbXQucGl4LmZpZWxkICE9IFY0TDJfRklFTERfQU5ZICYmCgkJICAgIGYtPmZtdC5waXguZmllbGQgIT0gVjRMMl9GSUVMRF9OT05FKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlmLT5mbXQucGl4LmZpZWxkID0gVjRMMl9GSUVMRF9OT05FOwoJCWlmIChmLT5mbXQucGl4LndpZHRoIDw9IDMyMCkgewoJCQlmLT5mbXQucGl4LndpZHRoID0gMzIwOwoJCQlmLT5mbXQucGl4LmhlaWdodCA9IDI0MDsKCQl9IGVsc2UgewoJCQlmLT5mbXQucGl4LndpZHRoID0gNjQwOwoJCQlmLT5mbXQucGl4LmhlaWdodCA9IDQ4MDsKCQl9CgkJZi0+Zm10LnBpeC5ieXRlc3BlcmxpbmUgPSBmLT5mbXQucGl4LndpZHRoICogMjsKCQlmLT5mbXQucGl4LnNpemVpbWFnZSA9IGYtPmZtdC5waXguaGVpZ2h0ICoKCQkJCSAgICAgICBmLT5mbXQucGl4LmJ5dGVzcGVybGluZTsKCQlmLT5mbXQucGl4LmNvbG9yc3BhY2UgPSAwOwoJCWYtPmZtdC5waXgucHJpdiA9IDA7CgkJYnJlYWs7Cgl9CgoJY2FzZSBWSURJT0NfR19GTVQ6IHsKCQlzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYgPSBhcmc7CgoJCWlmIChmLT50eXBlICE9IFY0TDJfQlVGX1RZUEVfVklERU9fQ0FQVFVSRSkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJbWVtc2V0KCZmLT5mbXQucGl4LCAwLCBzaXplb2Yoc3RydWN0IHY0bDJfcGl4X2Zvcm1hdCkpOwoJCWYtPnR5cGUgPSBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkU7CgkJc3dpdGNoIChtZXllLm1jaGlwX21vZGUpIHsKCQljYXNlIE1DSElQX0hJQ19NT0RFX0NPTlRfT1VUOgoJCWRlZmF1bHQ6CgkJCWYtPmZtdC5waXgucGl4ZWxmb3JtYXQgPSBWNEwyX1BJWF9GTVRfWVVZVjsKCQkJYnJlYWs7CgkJY2FzZSBNQ0hJUF9ISUNfTU9ERV9DT05UX0NPTVA6CgkJCWYtPmZtdC5waXgucGl4ZWxmb3JtYXQgPSBWNEwyX1BJWF9GTVRfTUpQRUc7CgkJCWJyZWFrOwoJCX0KCQlmLT5mbXQucGl4LmZpZWxkID0gVjRMMl9GSUVMRF9OT05FOwoJCWYtPmZtdC5waXgud2lkdGggPSBtY2hpcF9oc2l6ZSgpOwoJCWYtPmZtdC5waXguaGVpZ2h0ID0gbWNoaXBfdnNpemUoKTsKCQlmLT5mbXQucGl4LmJ5dGVzcGVybGluZSA9IGYtPmZtdC5waXgud2lkdGggKiAyOwoJCWYtPmZtdC5waXguc2l6ZWltYWdlID0gZi0+Zm10LnBpeC5oZWlnaHQgKgoJCQkJICAgICAgIGYtPmZtdC5waXguYnl0ZXNwZXJsaW5lOwoJCWYtPmZtdC5waXguY29sb3JzcGFjZSA9IDA7CgkJZi0+Zm10LnBpeC5wcml2ID0gMDsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19TX0ZNVDogewoJCXN0cnVjdCB2NGwyX2Zvcm1hdCAqZiA9IGFyZzsKCgkJaWYgKGYtPnR5cGUgIT0gVjRMMl9CVUZfVFlQRV9WSURFT19DQVBUVVJFKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoZi0+Zm10LnBpeC5waXhlbGZvcm1hdCAhPSBWNEwyX1BJWF9GTVRfWVVZViAmJgoJCSAgICBmLT5mbXQucGl4LnBpeGVsZm9ybWF0ICE9IFY0TDJfUElYX0ZNVF9NSlBFRykKCQkJcmV0dXJuIC1FSU5WQUw7CgkJaWYgKGYtPmZtdC5waXguZmllbGQgIT0gVjRMMl9GSUVMRF9BTlkgJiYKCQkgICAgZi0+Zm10LnBpeC5maWVsZCAhPSBWNEwyX0ZJRUxEX05PTkUpCgkJCXJldHVybiAtRUlOVkFMOwoJCWYtPmZtdC5waXguZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7CgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQlpZiAoZi0+Zm10LnBpeC53aWR0aCA8PSAzMjApIHsKCQkJZi0+Zm10LnBpeC53aWR0aCA9IDMyMDsKCQkJZi0+Zm10LnBpeC5oZWlnaHQgPSAyNDA7CgkJCW1leWUucGFyYW1zLnN1YnNhbXBsZSA9IDE7CgkJfSBlbHNlIHsKCQkJZi0+Zm10LnBpeC53aWR0aCA9IDY0MDsKCQkJZi0+Zm10LnBpeC5oZWlnaHQgPSA0ODA7CgkJCW1leWUucGFyYW1zLnN1YnNhbXBsZSA9IDA7CgkJfQoJCXN3aXRjaCAoZi0+Zm10LnBpeC5waXhlbGZvcm1hdCkgewoJCWNhc2UgVjRMMl9QSVhfRk1UX1lVWVY6CgkJCW1leWUubWNoaXBfbW9kZSA9IE1DSElQX0hJQ19NT0RFX0NPTlRfT1VUOwoJCQlicmVhazsKCQljYXNlIFY0TDJfUElYX0ZNVF9NSlBFRzoKCQkJbWV5ZS5tY2hpcF9tb2RlID0gTUNISVBfSElDX01PREVfQ09OVF9DT01QOwoJCQlicmVhazsKCQl9CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWYtPmZtdC5waXguYnl0ZXNwZXJsaW5lID0gZi0+Zm10LnBpeC53aWR0aCAqIDI7CgkJZi0+Zm10LnBpeC5zaXplaW1hZ2UgPSBmLT5mbXQucGl4LmhlaWdodCAqCgkJCQkgICAgICAgZi0+Zm10LnBpeC5ieXRlc3BlcmxpbmU7CgkJZi0+Zm10LnBpeC5jb2xvcnNwYWNlID0gMDsKCQlmLT5mbXQucGl4LnByaXYgPSAwOwoKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19SRVFCVUZTOiB7CgkJc3RydWN0IHY0bDJfcmVxdWVzdGJ1ZmZlcnMgKnJlcSA9IGFyZzsKCQlpbnQgaTsKCgkJaWYgKHJlcS0+dHlwZSAhPSBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkUpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChyZXEtPm1lbW9yeSAhPSBWNEwyX01FTU9SWV9NTUFQKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAobWV5ZS5ncmFiX2ZidWZmZXIgJiYgcmVxLT5jb3VudCA9PSBnYnVmZmVycykgewoJCQkvKiBhbHJlYWR5IGFsbG9jYXRlZCwgbm8gbW9kaWZpY2F0aW9ucyAqLwoJCQlicmVhazsKCQl9CgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQlpZiAobWV5ZS5ncmFiX2ZidWZmZXIpIHsKCQkJZm9yIChpID0gMDsgaSA8IGdidWZmZXJzOyBpKyspCgkJCQlpZiAobWV5ZS52bWFfdXNlX2NvdW50W2ldKSB7CgkJCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQkJCXJldHVybiAtRUlOVkFMOwoJCQkJfQoJCQlydmZyZWUobWV5ZS5ncmFiX2ZidWZmZXIsIGdidWZmZXJzICogZ2J1ZnNpemUpOwoJCQltZXllLmdyYWJfZmJ1ZmZlciA9IE5VTEw7CgkJfQoJCWdidWZmZXJzID0gbWF4KDIsIG1pbigoaW50KXJlcS0+Y291bnQsIE1FWUVfTUFYX0JVRk5CUlMpKTsKCQlyZXEtPmNvdW50ID0gZ2J1ZmZlcnM7CgkJbWV5ZS5ncmFiX2ZidWZmZXIgPSBydm1hbGxvYyhnYnVmZmVycyAqIGdidWZzaXplKTsKCQlpZiAoIW1leWUuZ3JhYl9mYnVmZmVyKSB7CgkJCXByaW50ayhLRVJOX0VSUiAibWV5ZTogdjRsIGZyYW1lYnVmZmVyIGFsbG9jYXRpb24iCgkJCQkJIiBmYWlsZWRcbiIpOwoJCQltdXRleF91bmxvY2soJm1leWUubG9jayk7CgkJCXJldHVybiAtRU5PTUVNOwoJCX0KCQlmb3IgKGkgPSAwOyBpIDwgZ2J1ZmZlcnM7IGkrKykKCQkJbWV5ZS52bWFfdXNlX2NvdW50W2ldID0gMDsKCQltdXRleF91bmxvY2soJm1leWUubG9jayk7CgkJYnJlYWs7Cgl9CgoJY2FzZSBWSURJT0NfUVVFUllCVUY6IHsKCQlzdHJ1Y3QgdjRsMl9idWZmZXIgKmJ1ZiA9IGFyZzsKCQlpbnQgaW5kZXggPSBidWYtPmluZGV4OwoKCQlpZiAoaW5kZXggPCAwIHx8IGluZGV4ID49IGdidWZmZXJzKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQltZW1zZXQoYnVmLCAwLCBzaXplb2YoKmJ1ZikpOwoJCWJ1Zi0+dHlwZSA9IFY0TDJfQlVGX1RZUEVfVklERU9fQ0FQVFVSRTsKCQlidWYtPmluZGV4ID0gaW5kZXg7CgkJYnVmLT5ieXRlc3VzZWQgPSBtZXllLmdyYWJfYnVmZmVyW2luZGV4XS5zaXplOwoJCWJ1Zi0+ZmxhZ3MgPSBWNEwyX0JVRl9GTEFHX01BUFBFRDsKCQlpZiAobWV5ZS5ncmFiX2J1ZmZlcltpbmRleF0uc3RhdGUgPT0gTUVZRV9CVUZfVVNJTkcpCgkJCWJ1Zi0+ZmxhZ3MgfD0gVjRMMl9CVUZfRkxBR19RVUVVRUQ7CgkJaWYgKG1leWUuZ3JhYl9idWZmZXJbaW5kZXhdLnN0YXRlID09IE1FWUVfQlVGX0RPTkUpCgkJCWJ1Zi0+ZmxhZ3MgfD0gVjRMMl9CVUZfRkxBR19ET05FOwoJCWJ1Zi0+ZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7CgkJYnVmLT50aW1lc3RhbXAgPSBtZXllLmdyYWJfYnVmZmVyW2luZGV4XS50aW1lc3RhbXA7CgkJYnVmLT5zZXF1ZW5jZSA9IG1leWUuZ3JhYl9idWZmZXJbaW5kZXhdLnNlcXVlbmNlOwoJCWJ1Zi0+bWVtb3J5ID0gVjRMMl9NRU1PUllfTU1BUDsKCQlidWYtPm0ub2Zmc2V0ID0gaW5kZXggKiBnYnVmc2l6ZTsKCQlidWYtPmxlbmd0aCA9IGdidWZzaXplOwoJCWJyZWFrOwoJfQoKCWNhc2UgVklESU9DX1FCVUY6IHsKCQlzdHJ1Y3QgdjRsMl9idWZmZXIgKmJ1ZiA9IGFyZzsKCgkJaWYgKGJ1Zi0+dHlwZSAhPSBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkUpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChidWYtPm1lbW9yeSAhPSBWNEwyX01FTU9SWV9NTUFQKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoYnVmLT5pbmRleCA8IDAgfHwgYnVmLT5pbmRleCA+PSBnYnVmZmVycykKCQkJcmV0dXJuIC1FSU5WQUw7CgkJaWYgKG1leWUuZ3JhYl9idWZmZXJbYnVmLT5pbmRleF0uc3RhdGUgIT0gTUVZRV9CVUZfVU5VU0VEKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQltdXRleF9sb2NrKCZtZXllLmxvY2spOwoJCWJ1Zi0+ZmxhZ3MgfD0gVjRMMl9CVUZfRkxBR19RVUVVRUQ7CgkJYnVmLT5mbGFncyAmPSB+VjRMMl9CVUZfRkxBR19ET05FOwoJCW1leWUuZ3JhYl9idWZmZXJbYnVmLT5pbmRleF0uc3RhdGUgPSBNRVlFX0JVRl9VU0lORzsKCQlrZmlmb19wdXQobWV5ZS5ncmFicSwgKHVuc2lnbmVkIGNoYXIgKikmYnVmLT5pbmRleCwgc2l6ZW9mKGludCkpOwoJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19EUUJVRjogewoJCXN0cnVjdCB2NGwyX2J1ZmZlciAqYnVmID0gYXJnOwoJCWludCByZXFucjsKCgkJaWYgKGJ1Zi0+dHlwZSAhPSBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkUpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmIChidWYtPm1lbW9yeSAhPSBWNEwyX01FTU9SWV9NTUFQKQoJCQlyZXR1cm4gLUVJTlZBTDsKCgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQlpZiAoa2ZpZm9fbGVuKG1leWUuZG9uZXEpID09IDAgJiYgZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spIHsKCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQlyZXR1cm4gLUVBR0FJTjsKCQl9CgkJaWYgKHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShtZXllLnByb2NfbGlzdCwKCQkJCQkgICAgIGtmaWZvX2xlbihtZXllLmRvbmVxKSAhPSAwKSA8IDApIHsKCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQlyZXR1cm4gLUVJTlRSOwoJCX0KCQlpZiAoIWtmaWZvX2dldChtZXllLmRvbmVxLCAodW5zaWduZWQgY2hhciAqKSZyZXFuciwKCQkJICAgICAgIHNpemVvZihpbnQpKSkgewoJCQltdXRleF91bmxvY2soJm1leWUubG9jayk7CgkJCXJldHVybiAtRUJVU1k7CgkJfQoJCWlmIChtZXllLmdyYWJfYnVmZmVyW3JlcW5yXS5zdGF0ZSAhPSBNRVlFX0JVRl9ET05FKSB7CgkJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQkJcmV0dXJuIC1FSU5WQUw7CgkJfQoJCWJ1Zi0+aW5kZXggPSByZXFucjsKCQlidWYtPmJ5dGVzdXNlZCA9IG1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnNpemU7CgkJYnVmLT5mbGFncyA9IFY0TDJfQlVGX0ZMQUdfTUFQUEVEOwoJCWJ1Zi0+ZmllbGQgPSBWNEwyX0ZJRUxEX05PTkU7CgkJYnVmLT50aW1lc3RhbXAgPSBtZXllLmdyYWJfYnVmZmVyW3JlcW5yXS50aW1lc3RhbXA7CgkJYnVmLT5zZXF1ZW5jZSA9IG1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnNlcXVlbmNlOwoJCWJ1Zi0+bWVtb3J5ID0gVjRMMl9NRU1PUllfTU1BUDsKCQlidWYtPm0ub2Zmc2V0ID0gcmVxbnIgKiBnYnVmc2l6ZTsKCQlidWYtPmxlbmd0aCA9IGdidWZzaXplOwoJCW1leWUuZ3JhYl9idWZmZXJbcmVxbnJdLnN0YXRlID0gTUVZRV9CVUZfVU5VU0VEOwoJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19TVFJFQU1PTjogewoJCW11dGV4X2xvY2soJm1leWUubG9jayk7CgkJc3dpdGNoIChtZXllLm1jaGlwX21vZGUpIHsKCQljYXNlIE1DSElQX0hJQ19NT0RFX0NPTlRfT1VUOgoJCQltY2hpcF9jb250aW51b3VzX3N0YXJ0KCk7CgkJCWJyZWFrOwoJCWNhc2UgTUNISVBfSElDX01PREVfQ09OVF9DT01QOgoJCQltY2hpcF9jb250X2NvbXByZXNzaW9uX3N0YXJ0KCk7CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQkJcmV0dXJuIC1FSU5WQUw7CgkJfQoJCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCQlicmVhazsKCX0KCgljYXNlIFZJRElPQ19TVFJFQU1PRkY6IHsKCQlpbnQgaTsKCgkJbXV0ZXhfbG9jaygmbWV5ZS5sb2NrKTsKCQltY2hpcF9oaWNfc3RvcCgpOwoJCWtmaWZvX3Jlc2V0KG1leWUuZ3JhYnEpOwoJCWtmaWZvX3Jlc2V0KG1leWUuZG9uZXEpOwoJCWZvciAoaSA9IDA7IGkgPCBNRVlFX01BWF9CVUZOQlJTOyBpKyspCgkJCW1leWUuZ3JhYl9idWZmZXJbaV0uc3RhdGUgPSBNRVlFX0JVRl9VTlVTRUQ7CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCWJyZWFrOwoJfQoKCS8qCgkgKiBYWFggd2hhdCBhYm91dCBwcml2YXRlIHNuYXBzaG90IGlvY3RscyA/CgkgKiBEbyB0aGV5IG5lZWQgdG8gYmUgY29udmVydGVkIHRvIFY0TDIgPwoJKi8KCglkZWZhdWx0OgoJCXJldHVybiAtRU5PSU9DVExDTUQ7Cgl9CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgbWV5ZV9pb2N0bChzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSwKCQkgICAgIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQp7CglyZXR1cm4gdmlkZW9fdXNlcmNvcHkoaW5vZGUsIGZpbGUsIGNtZCwgYXJnLCBtZXllX2RvX2lvY3RsKTsKfQoKc3RhdGljIHVuc2lnbmVkIGludCBtZXllX3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHBvbGxfdGFibGUgKndhaXQpCnsKCXVuc2lnbmVkIGludCByZXMgPSAwOwoKCW11dGV4X2xvY2soJm1leWUubG9jayk7Cglwb2xsX3dhaXQoZmlsZSwgJm1leWUucHJvY19saXN0LCB3YWl0KTsKCWlmIChrZmlmb19sZW4obWV5ZS5kb25lcSkpCgkJcmVzID0gUE9MTElOIHwgUE9MTFJETk9STTsKCW11dGV4X3VubG9jaygmbWV5ZS5sb2NrKTsKCXJldHVybiByZXM7Cn0KCnN0YXRpYyB2b2lkIG1leWVfdm1fb3BlbihzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKewoJbG9uZyBpZHggPSAobG9uZyl2bWEtPnZtX3ByaXZhdGVfZGF0YTsKCW1leWUudm1hX3VzZV9jb3VudFtpZHhdKys7Cn0KCnN0YXRpYyB2b2lkIG1leWVfdm1fY2xvc2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCnsKCWxvbmcgaWR4ID0gKGxvbmcpdm1hLT52bV9wcml2YXRlX2RhdGE7CgltZXllLnZtYV91c2VfY291bnRbaWR4XS0tOwp9CgpzdGF0aWMgc3RydWN0IHZtX29wZXJhdGlvbnNfc3RydWN0IG1leWVfdm1fb3BzID0gewoJLm9wZW4JCT0gbWV5ZV92bV9vcGVuLAoJLmNsb3NlCQk9IG1leWVfdm1fY2xvc2UsCn07CgpzdGF0aWMgaW50IG1leWVfbW1hcChzdHJ1Y3QgZmlsZSAqZmlsZSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCnsKCXVuc2lnbmVkIGxvbmcgc3RhcnQgPSB2bWEtPnZtX3N0YXJ0OwoJdW5zaWduZWQgbG9uZyBzaXplID0gdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0OwoJdW5zaWduZWQgbG9uZyBvZmZzZXQgPSB2bWEtPnZtX3Bnb2ZmIDw8IFBBR0VfU0hJRlQ7Cgl1bnNpZ25lZCBsb25nIHBhZ2UsIHBvczsKCgltdXRleF9sb2NrKCZtZXllLmxvY2spOwoJaWYgKHNpemUgPiBnYnVmZmVycyAqIGdidWZzaXplKSB7CgkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCXJldHVybiAtRUlOVkFMOwoJfQoJaWYgKCFtZXllLmdyYWJfZmJ1ZmZlcikgewoJCWludCBpOwoKCQkvKiBsYXp5IGFsbG9jYXRpb24gKi8KCQltZXllLmdyYWJfZmJ1ZmZlciA9IHJ2bWFsbG9jKGdidWZmZXJzKmdidWZzaXplKTsKCQlpZiAoIW1leWUuZ3JhYl9mYnVmZmVyKSB7CgkJCXByaW50ayhLRVJOX0VSUiAibWV5ZTogdjRsIGZyYW1lYnVmZmVyIGFsbG9jYXRpb24gZmFpbGVkXG4iKTsKCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQlyZXR1cm4gLUVOT01FTTsKCQl9CgkJZm9yIChpID0gMDsgaSA8IGdidWZmZXJzOyBpKyspCgkJCW1leWUudm1hX3VzZV9jb3VudFtpXSA9IDA7Cgl9Cglwb3MgPSAodW5zaWduZWQgbG9uZyltZXllLmdyYWJfZmJ1ZmZlciArIG9mZnNldDsKCgl3aGlsZSAoc2l6ZSA+IDApIHsKCQlwYWdlID0gdm1hbGxvY190b19wZm4oKHZvaWQgKilwb3MpOwoJCWlmIChyZW1hcF9wZm5fcmFuZ2Uodm1hLCBzdGFydCwgcGFnZSwgUEFHRV9TSVpFLCBQQUdFX1NIQVJFRCkpIHsKCQkJbXV0ZXhfdW5sb2NrKCZtZXllLmxvY2spOwoJCQlyZXR1cm4gLUVBR0FJTjsKCQl9CgkJc3RhcnQgKz0gUEFHRV9TSVpFOwoJCXBvcyArPSBQQUdFX1NJWkU7CgkJaWYgKHNpemUgPiBQQUdFX1NJWkUpCgkJCXNpemUgLT0gUEFHRV9TSVpFOwoJCWVsc2UKCQkJc2l6ZSA9IDA7Cgl9CgoJdm1hLT52bV9vcHMgPSAmbWV5ZV92bV9vcHM7Cgl2bWEtPnZtX2ZsYWdzICY9IH5WTV9JTzsJLyogbm90IEkvTyBtZW1vcnkgKi8KCXZtYS0+dm1fZmxhZ3MgfD0gVk1fUkVTRVJWRUQ7CS8qIGF2b2lkIHRvIHN3YXAgb3V0IHRoaXMgVk1BICovCgl2bWEtPnZtX3ByaXZhdGVfZGF0YSA9ICh2b2lkICopIChvZmZzZXQgLyBnYnVmc2l6ZSk7CgltZXllX3ZtX29wZW4odm1hKTsKCgltdXRleF91bmxvY2soJm1leWUubG9jayk7CglyZXR1cm4gMDsKfQoKc3RhdGljIHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgbWV5ZV9mb3BzID0gewoJLm93bmVyCQk9IFRISVNfTU9EVUxFLAoJLm9wZW4JCT0gbWV5ZV9vcGVuLAoJLnJlbGVhc2UJPSBtZXllX3JlbGVhc2UsCgkubW1hcAkJPSBtZXllX21tYXAsCgkuaW9jdGwJCT0gbWV5ZV9pb2N0bCwKCS5jb21wYXRfaW9jdGwJPSB2NGxfY29tcGF0X2lvY3RsMzIsCgkucG9sbAkJPSBtZXllX3BvbGwsCgkubGxzZWVrCQk9IG5vX2xsc2VlaywKfTsKCnN0YXRpYyBzdHJ1Y3QgdmlkZW9fZGV2aWNlIG1leWVfdGVtcGxhdGUgPSB7Cgkub3duZXIJCT0gVEhJU19NT0RVTEUsCgkubmFtZQkJPSAibWV5ZSIsCgkudHlwZQkJPSBWSURfVFlQRV9DQVBUVVJFLAoJLmhhcmR3YXJlCT0gVklEX0hBUkRXQVJFX01FWUUsCgkuZm9wcwkJPSAmbWV5ZV9mb3BzLAoJLnJlbGVhc2UJPSB2aWRlb19kZXZpY2VfcmVsZWFzZSwKCS5taW5vcgkJPSAtMSwKfTsKCiNpZmRlZiBDT05GSUdfUE0Kc3RhdGljIGludCBtZXllX3N1c3BlbmQoc3RydWN0IHBjaV9kZXYgKnBkZXYsIHBtX21lc3NhZ2VfdCBzdGF0ZSkKewoJcGNpX3NhdmVfc3RhdGUocGRldik7CgltZXllLnBtX21jaGlwX21vZGUgPSBtZXllLm1jaGlwX21vZGU7CgltY2hpcF9oaWNfc3RvcCgpOwoJbWNoaXBfc2V0KE1DSElQX01NX0lOVEEsIDB4MCk7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBtZXllX3Jlc3VtZShzdHJ1Y3QgcGNpX2RldiAqcGRldikKewoJcGNpX3Jlc3RvcmVfc3RhdGUocGRldik7CglwY2lfd3JpdGVfY29uZmlnX3dvcmQobWV5ZS5tY2hpcF9kZXYsIE1DSElQX1BDSV9TT0ZUUkVTRVRfU0VULCAxKTsKCgltY2hpcF9kZWxheShNQ0hJUF9ISUNfQ01ELCAwKTsKCW1jaGlwX2RlbGF5KE1DSElQX0hJQ19TVEFUVVMsIE1DSElQX0hJQ19TVEFUVVNfSURMRSk7Cgltc2xlZXAoMSk7CgltY2hpcF9zZXQoTUNISVBfVlJKX1NPRlRfUkVTRVQsIDEpOwoJbXNsZWVwKDEpOwoJbWNoaXBfc2V0KE1DSElQX01NX1BDSV9NT0RFLCA1KTsKCW1zbGVlcCgxKTsKCW1jaGlwX3NldChNQ0hJUF9NTV9JTlRBLCBNQ0hJUF9NTV9JTlRBX0hJQ18xX01BU0spOwoKCXN3aXRjaCAobWV5ZS5wbV9tY2hpcF9tb2RlKSB7CgljYXNlIE1DSElQX0hJQ19NT0RFX0NPTlRfT1VUOgoJCW1jaGlwX2NvbnRpbnVvdXNfc3RhcnQoKTsKCQlicmVhazsKCWNhc2UgTUNISVBfSElDX01PREVfQ09OVF9DT01QOgoJCW1jaGlwX2NvbnRfY29tcHJlc3Npb25fc3RhcnQoKTsKCQlicmVhazsKCX0KCXJldHVybiAwOwp9CiNlbmRpZgoKc3RhdGljIGludCBfX2RldmluaXQgbWV5ZV9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGNpZGV2LAoJCQkJY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmVudCkKewoJaW50IHJldCA9IC1FQlVTWTsKCXVuc2lnbmVkIGxvbmcgbWNoaXBfYWRyOwoJdTggcmV2aXNpb247CgoJaWYgKG1leWUubWNoaXBfZGV2ICE9IE5VTEwpIHsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IG9ubHkgb25lIGRldmljZSBhbGxvd2VkIVxuIik7CgkJZ290byBvdXRub3RkZXY7Cgl9CgoJbWV5ZS5tY2hpcF9kZXYgPSBwY2lkZXY7CgltZXllLnZpZGVvX2RldiA9IHZpZGVvX2RldmljZV9hbGxvYygpOwoJaWYgKCFtZXllLnZpZGVvX2RldikgewoJCXByaW50ayhLRVJOX0VSUiAibWV5ZTogdmlkZW9fZGV2aWNlX2FsbG9jKCkgZmFpbGVkIVxuIik7CgkJZ290byBvdXRub3RkZXY7Cgl9CgoJcmV0ID0gLUVOT01FTTsKCW1leWUuZ3JhYl90ZW1wID0gdm1hbGxvYyhNQ0hJUF9OQl9QQUdFU19NSlBFRyAqIFBBR0VfU0laRSk7CglpZiAoIW1leWUuZ3JhYl90ZW1wKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJtZXllOiBncmFiIGJ1ZmZlciBhbGxvY2F0aW9uIGZhaWxlZFxuIik7CgkJZ290byBvdXR2bWFsbG9jOwoJfQoKCXNwaW5fbG9ja19pbml0KCZtZXllLmdyYWJxX2xvY2spOwoJbWV5ZS5ncmFicSA9IGtmaWZvX2FsbG9jKHNpemVvZihpbnQpICogTUVZRV9NQVhfQlVGTkJSUywgR0ZQX0tFUk5FTCwKCQkJCSAmbWV5ZS5ncmFicV9sb2NrKTsKCWlmIChJU19FUlIobWV5ZS5ncmFicSkpIHsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IGZpZm8gYWxsb2NhdGlvbiBmYWlsZWRcbiIpOwoJCWdvdG8gb3V0a2ZpZm9hbGxvYzE7Cgl9CglzcGluX2xvY2tfaW5pdCgmbWV5ZS5kb25lcV9sb2NrKTsKCW1leWUuZG9uZXEgPSBrZmlmb19hbGxvYyhzaXplb2YoaW50KSAqIE1FWUVfTUFYX0JVRk5CUlMsIEdGUF9LRVJORUwsCgkJCQkgJm1leWUuZG9uZXFfbG9jayk7CglpZiAoSVNfRVJSKG1leWUuZG9uZXEpKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJtZXllOiBmaWZvIGFsbG9jYXRpb24gZmFpbGVkXG4iKTsKCQlnb3RvIG91dGtmaWZvYWxsb2MyOwoJfQoKCW1lbWNweShtZXllLnZpZGVvX2RldiwgJm1leWVfdGVtcGxhdGUsIHNpemVvZihtZXllX3RlbXBsYXRlKSk7CgltZXllLnZpZGVvX2Rldi0+ZGV2ID0gJm1leWUubWNoaXBfZGV2LT5kZXY7CgoJaWYgKChyZXQgPSBzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBLCAxKSkpIHsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IHVuYWJsZSB0byBwb3dlciBvbiB0aGUgY2FtZXJhXG4iKTsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IGRpZCB5b3UgZW5hYmxlIHRoZSBjYW1lcmEgaW4gIgoJCQkJInNvbnlwaSB1c2luZyB0aGUgbW9kdWxlIG9wdGlvbnMgP1xuIik7CgkJZ290byBvdXRzb255cGllbmFibGU7Cgl9CgoJcmV0ID0gLUVJTzsKCWlmICgocmV0ID0gcGNpX2VuYWJsZV9kZXZpY2UobWV5ZS5tY2hpcF9kZXYpKSkgewoJCXByaW50ayhLRVJOX0VSUiAibWV5ZTogcGNpX2VuYWJsZV9kZXZpY2UgZmFpbGVkXG4iKTsKCQlnb3RvIG91dGVuYWJsZWRldjsKCX0KCgltY2hpcF9hZHIgPSBwY2lfcmVzb3VyY2Vfc3RhcnQobWV5ZS5tY2hpcF9kZXYsMCk7CglpZiAoIW1jaGlwX2FkcikgewoJCXByaW50ayhLRVJOX0VSUiAibWV5ZTogbWNoaXAgaGFzIG5vIGRldmljZSBiYXNlIGFkZHJlc3NcbiIpOwoJCWdvdG8gb3V0cmVnaW9uczsKCX0KCWlmICghcmVxdWVzdF9tZW1fcmVnaW9uKHBjaV9yZXNvdXJjZV9zdGFydChtZXllLm1jaGlwX2RldiwgMCksCgkJCQlwY2lfcmVzb3VyY2VfbGVuKG1leWUubWNoaXBfZGV2LCAwKSwKCQkJCSJtZXllIikpIHsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IHJlcXVlc3RfbWVtX3JlZ2lvbiBmYWlsZWRcbiIpOwoJCWdvdG8gb3V0cmVnaW9uczsKCX0KCW1leWUubWNoaXBfbW1yZWdzID0gaW9yZW1hcChtY2hpcF9hZHIsIE1DSElQX01NX1JFR1MpOwoJaWYgKCFtZXllLm1jaGlwX21tcmVncykgewoJCXByaW50ayhLRVJOX0VSUiAibWV5ZTogaW9yZW1hcCBmYWlsZWRcbiIpOwoJCWdvdG8gb3V0cmVtYXA7Cgl9CgoJbWV5ZS5tY2hpcF9pcnEgPSBwY2lkZXYtPmlycTsKCWlmIChyZXF1ZXN0X2lycShtZXllLm1jaGlwX2lycSwgbWV5ZV9pcnEsCgkJCUlSUUZfRElTQUJMRUQgfCBJUlFGX1NIQVJFRCwgIm1leWUiLCBtZXllX2lycSkpIHsKCQlwcmludGsoS0VSTl9FUlIgIm1leWU6IHJlcXVlc3RfaXJxIGZhaWxlZFxuIik7CgkJZ290byBvdXRyZXFpcnE7Cgl9CgoJcGNpX3JlYWRfY29uZmlnX2J5dGUobWV5ZS5tY2hpcF9kZXYsIFBDSV9SRVZJU0lPTl9JRCwgJnJldmlzaW9uKTsKCXBjaV93cml0ZV9jb25maWdfYnl0ZShtZXllLm1jaGlwX2RldiwgUENJX0NBQ0hFX0xJTkVfU0laRSwgOCk7CglwY2lfd3JpdGVfY29uZmlnX2J5dGUobWV5ZS5tY2hpcF9kZXYsIFBDSV9MQVRFTkNZX1RJTUVSLCA2NCk7CgoJcGNpX3NldF9tYXN0ZXIobWV5ZS5tY2hpcF9kZXYpOwoKCS8qIEFzayB0aGUgY2FtZXJhIHRvIHBlcmZvcm0gYSBzb2Z0IHJlc2V0LiAqLwoJcGNpX3dyaXRlX2NvbmZpZ193b3JkKG1leWUubWNoaXBfZGV2LCBNQ0hJUF9QQ0lfU09GVFJFU0VUX1NFVCwgMSk7CgoJbWNoaXBfZGVsYXkoTUNISVBfSElDX0NNRCwgMCk7CgltY2hpcF9kZWxheShNQ0hJUF9ISUNfU1RBVFVTLCBNQ0hJUF9ISUNfU1RBVFVTX0lETEUpOwoKCW1zbGVlcCgxKTsKCW1jaGlwX3NldChNQ0hJUF9WUkpfU09GVF9SRVNFVCwgMSk7CgoJbXNsZWVwKDEpOwoJbWNoaXBfc2V0KE1DSElQX01NX1BDSV9NT0RFLCA1KTsKCgltc2xlZXAoMSk7CgltY2hpcF9zZXQoTUNISVBfTU1fSU5UQSwgTUNISVBfTU1fSU5UQV9ISUNfMV9NQVNLKTsKCglpZiAodmlkZW9fcmVnaXN0ZXJfZGV2aWNlKG1leWUudmlkZW9fZGV2LCBWRkxfVFlQRV9HUkFCQkVSLAoJCQkJICB2aWRlb19ucikgPCAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJtZXllOiB2aWRlb19yZWdpc3Rlcl9kZXZpY2UgZmFpbGVkXG4iKTsKCQlnb3RvIG91dHZpZGVvcmVnOwoJfQoKCW11dGV4X2luaXQoJm1leWUubG9jayk7Cglpbml0X3dhaXRxdWV1ZV9oZWFkKCZtZXllLnByb2NfbGlzdCk7CgltZXllLnBpY3R1cmUuZGVwdGggPSAxNjsKCW1leWUucGljdHVyZS5wYWxldHRlID0gVklERU9fUEFMRVRURV9ZVVY0MjI7CgltZXllLnBpY3R1cmUuYnJpZ2h0bmVzcyA9IDMyIDw8IDEwOwoJbWV5ZS5waWN0dXJlLmh1ZSA9IDMyIDw8IDEwOwoJbWV5ZS5waWN0dXJlLmNvbG91ciA9IDMyIDw8IDEwOwoJbWV5ZS5waWN0dXJlLmNvbnRyYXN0ID0gMzIgPDwgMTA7CgltZXllLnBpY3R1cmUud2hpdGVuZXNzID0gMDsKCW1leWUucGFyYW1zLnN1YnNhbXBsZSA9IDA7CgltZXllLnBhcmFtcy5xdWFsaXR5ID0gODsKCW1leWUucGFyYW1zLnNoYXJwbmVzcyA9IDMyOwoJbWV5ZS5wYXJhbXMuYWdjID0gNDg7CgltZXllLnBhcmFtcy5waWN0dXJlID0gMDsKCW1leWUucGFyYW1zLmZyYW1lcmF0ZSA9IDA7CgoJc29ueXBpX2NhbWVyYV9jb21tYW5kKFNPTllQSV9DT01NQU5EX1NFVENBTUVSQUJSSUdIVE5FU1MsIDMyKTsKCXNvbnlwaV9jYW1lcmFfY29tbWFuZChTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFIVUUsIDMyKTsKCXNvbnlwaV9jYW1lcmFfY29tbWFuZChTT05ZUElfQ09NTUFORF9TRVRDQU1FUkFDT0xPUiwgMzIpOwoJc29ueXBpX2NhbWVyYV9jb21tYW5kKFNPTllQSV9DT01NQU5EX1NFVENBTUVSQUNPTlRSQVNULCAzMik7Cglzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBU0hBUlBORVNTLCAzMik7Cglzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBUElDVFVSRSwgMCk7Cglzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBQUdDLCA0OCk7CgoJcHJpbnRrKEtFUk5fSU5GTyAibWV5ZTogTW90aW9uIEV5ZSBDYW1lcmEgRHJpdmVyIHYlcy5cbiIsCgkgICAgICAgTUVZRV9EUklWRVJfVkVSU0lPTik7CglwcmludGsoS0VSTl9JTkZPICJtZXllOiBtY2hpcCBLTDVBNzIwMDIgcmV2LiAlZCwgYmFzZSAlbHgsIGlycSAlZFxuIiwKCSAgICAgICByZXZpc2lvbiwgbWNoaXBfYWRyLCBtZXllLm1jaGlwX2lycSk7CgoJcmV0dXJuIDA7CgpvdXR2aWRlb3JlZzoKCWZyZWVfaXJxKG1leWUubWNoaXBfaXJxLCBtZXllX2lycSk7Cm91dHJlcWlycToKCWlvdW5tYXAobWV5ZS5tY2hpcF9tbXJlZ3MpOwpvdXRyZW1hcDoKCXJlbGVhc2VfbWVtX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQobWV5ZS5tY2hpcF9kZXYsIDApLAoJCQkgICBwY2lfcmVzb3VyY2VfbGVuKG1leWUubWNoaXBfZGV2LCAwKSk7Cm91dHJlZ2lvbnM6CglwY2lfZGlzYWJsZV9kZXZpY2UobWV5ZS5tY2hpcF9kZXYpOwpvdXRlbmFibGVkZXY6Cglzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBLCAwKTsKb3V0c29ueXBpZW5hYmxlOgoJa2ZpZm9fZnJlZShtZXllLmRvbmVxKTsKb3V0a2ZpZm9hbGxvYzI6CglrZmlmb19mcmVlKG1leWUuZ3JhYnEpOwpvdXRrZmlmb2FsbG9jMToKCXZmcmVlKG1leWUuZ3JhYl90ZW1wKTsKb3V0dm1hbGxvYzoKCXZpZGVvX2RldmljZV9yZWxlYXNlKG1leWUudmlkZW9fZGV2KTsKb3V0bm90ZGV2OgoJcmV0dXJuIHJldDsKfQoKc3RhdGljIHZvaWQgX19kZXZleGl0IG1leWVfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwY2lkZXYpCnsKCXZpZGVvX3VucmVnaXN0ZXJfZGV2aWNlKG1leWUudmlkZW9fZGV2KTsKCgltY2hpcF9oaWNfc3RvcCgpOwoKCW1jaGlwX2RtYV9mcmVlKCk7CgoJLyogZGlzYWJsZSBpbnRlcnJ1cHRzICovCgltY2hpcF9zZXQoTUNISVBfTU1fSU5UQSwgMHgwKTsKCglmcmVlX2lycShtZXllLm1jaGlwX2lycSwgbWV5ZV9pcnEpOwoKCWlvdW5tYXAobWV5ZS5tY2hpcF9tbXJlZ3MpOwoKCXJlbGVhc2VfbWVtX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQobWV5ZS5tY2hpcF9kZXYsIDApLAoJCQkgICBwY2lfcmVzb3VyY2VfbGVuKG1leWUubWNoaXBfZGV2LCAwKSk7CgoJcGNpX2Rpc2FibGVfZGV2aWNlKG1leWUubWNoaXBfZGV2KTsKCglzb255cGlfY2FtZXJhX2NvbW1hbmQoU09OWVBJX0NPTU1BTkRfU0VUQ0FNRVJBLCAwKTsKCglrZmlmb19mcmVlKG1leWUuZG9uZXEpOwoJa2ZpZm9fZnJlZShtZXllLmdyYWJxKTsKCgl2ZnJlZShtZXllLmdyYWJfdGVtcCk7CgoJaWYgKG1leWUuZ3JhYl9mYnVmZmVyKSB7CgkJcnZmcmVlKG1leWUuZ3JhYl9mYnVmZmVyLCBnYnVmZmVycypnYnVmc2l6ZSk7CgkJbWV5ZS5ncmFiX2ZidWZmZXIgPSBOVUxMOwoJfQoKCXByaW50ayhLRVJOX0lORk8gIm1leWU6IHJlbW92ZWRcbiIpOwp9CgpzdGF0aWMgc3RydWN0IHBjaV9kZXZpY2VfaWQgbWV5ZV9wY2lfdGJsW10gPSB7Cgl7IFBDSV9WRU5ET1JfSURfS0FXQVNBS0ksIFBDSV9ERVZJQ0VfSURfTUNISVBfS0w1QTcyMDAyLAoJICBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwIH0sCgl7IH0KfTsKCk1PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBtZXllX3BjaV90YmwpOwoKc3RhdGljIHN0cnVjdCBwY2lfZHJpdmVyIG1leWVfZHJpdmVyID0gewoJLm5hbWUJCT0gIm1leWUiLAoJLmlkX3RhYmxlCT0gbWV5ZV9wY2lfdGJsLAoJLnByb2JlCQk9IG1leWVfcHJvYmUsCgkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKG1leWVfcmVtb3ZlKSwKI2lmZGVmIENPTkZJR19QTQoJLnN1c3BlbmQJPSBtZXllX3N1c3BlbmQsCgkucmVzdW1lCQk9IG1leWVfcmVzdW1lLAojZW5kaWYKfTsKCnN0YXRpYyBpbnQgX19pbml0IG1leWVfaW5pdCh2b2lkKQp7CglnYnVmZmVycyA9IG1heCgyLCBtaW4oKGludClnYnVmZmVycywgTUVZRV9NQVhfQlVGTkJSUykpOwoJaWYgKGdidWZzaXplIDwgMCB8fCBnYnVmc2l6ZSA+IE1FWUVfTUFYX0JVRlNJWkUpCgkJZ2J1ZnNpemUgPSBNRVlFX01BWF9CVUZTSVpFOwoJZ2J1ZnNpemUgPSBQQUdFX0FMSUdOKGdidWZzaXplKTsKCXByaW50ayhLRVJOX0lORk8gIm1leWU6IHVzaW5nICVkIGJ1ZmZlcnMgd2l0aCAlZGsgKCVkayB0b3RhbCkiCgkJCSAiZm9yIGNhcHR1cmVcbiIsCgkJCSBnYnVmZmVycywKCQkJIGdidWZzaXplIC8gMTAyNCwgZ2J1ZmZlcnMgKiBnYnVmc2l6ZSAvIDEwMjQpOwoJcmV0dXJuIHBjaV9yZWdpc3Rlcl9kcml2ZXIoJm1leWVfZHJpdmVyKTsKfQoKc3RhdGljIHZvaWQgX19leGl0IG1leWVfZXhpdCh2b2lkKQp7CglwY2lfdW5yZWdpc3Rlcl9kcml2ZXIoJm1leWVfZHJpdmVyKTsKfQoKbW9kdWxlX2luaXQobWV5ZV9pbml0KTsKbW9kdWxlX2V4aXQobWV5ZV9leGl0KTsK