LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoKICogICAgICBlczEzNzEuYyAgLS0gIENyZWF0aXZlIEVuc29uaXEgRVMxMzcxLgogKgogKiAgICAgIENvcHlyaWdodCAoQykgMTk5OC0yMDAxLCAyMDAzICBUaG9tYXMgU2FpbGVyICh0LnNhaWxlckBhbHVtbmkuZXRoei5jaCkKICoKICogICAgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogKiAgICAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiAqICAgICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICogICAgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiAgICAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiAgICAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqICAgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQogKiAgICAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCiAqCiAqICAgICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogICAgICBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQogKiAgICAgIEZvdW5kYXRpb24sIEluYy4sIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgogKgogKiBTcGVjaWFsIHRoYW5rcyB0byBFbnNvbmlxCiAqCiAqICBTdXBwb3J0ZWQgZGV2aWNlczoKICogIC9kZXYvZHNwICAgIHN0YW5kYXJkIC9kZXYvZHNwIGRldmljZSwgKG1vc3RseSkgT1NTIGNvbXBhdGlibGUKICogIC9kZXYvbWl4ZXIgIHN0YW5kYXJkIC9kZXYvbWl4ZXIgZGV2aWNlLCAobW9zdGx5KSBPU1MgY29tcGF0aWJsZQogKiAgL2Rldi9kc3AxICAgYWRkaXRpb25hbCBEQUMsIGxpa2UgL2Rldi9kc3AsIGJ1dCBvdXRwdXRzIHRvIG1peGVyICJTWU5USCIgc2V0dGluZwogKiAgL2Rldi9taWRpICAgc2ltcGxlIE1JREkgVUFSVCBpbnRlcmZhY2UsIG5vIGlvY3RsCiAqCiAqICBOT1RFOiB0aGUgY2FyZCBkb2VzIG5vdCBoYXZlIGFueSBGTS9XYXZldGFibGUgc3ludGhlc2l6ZXIsIGl0IGlzIHN1cHBvc2VkCiAqICB0byBiZSBkb25lIGluIHNvZnR3YXJlLiBUaGF0IGlzIHdoYXQgL2Rldi9kYWMgaXMgZm9yLiBCeSBub3cgKFEyIDE5OTgpCiAqICB0aGVyZSBhcmUgc2V2ZXJhbCBNSURJIHRvIFBDTSAoV0FWKSBwYWNrYWdlcywgb25lIG9mIHRoZW0gaXMgdGltaWRpdHkuCiAqCiAqICBSZXZpc2lvbiBoaXN0b3J5CiAqICAgIDA0LjA2LjE5OTggICAwLjEgICBJbml0aWFsIHJlbGVhc2UKICogICAgICAgICAgICAgICAgICAgICAgIE1peGVyIHN0dWZmIHNob3VsZCBiZSBvdmVyaGF1bGVkOyBlc3BlY2lhbGx5IG9wdGlvbmFsIEFDOTcgbWl4ZXIgYml0cwogKiAgICAgICAgICAgICAgICAgICAgICAgc2hvdWxkIGJlIGRldGVjdGVkLiBUaGlzIHJlc3VsdHMgaW4gc3RyYW5nZSBiZWhhdmlvdXIgb2Ygc29tZSBtaXhlcgogKiAgICAgICAgICAgICAgICAgICAgICAgc2V0dGluZ3MsIGxpa2UgbWFzdGVyIHZvbHVtZSBhbmQgbWljLgogKiAgICAwOC4wNi4xOTk4ICAgMC4yICAgRmlyc3QgcmVsZWFzZSB1c2luZyBBbGFuIENveCcgc291bmRjb3JlIGluc3RlYWQgb2YgbWlzY2RldmljZQogKiAgICAwMy4wOC4xOTk4ICAgMC4zICAgRG8gbm90IGluY2x1ZGUgbW9kdmVyc2lvbnMuaAogKiAgICAgICAgICAgICAgICAgICAgICAgTm93IG1peGVyIGJlaGF2aW91ciBjYW4gYmFzaWNhbGx5IGJlIHNlbGVjdGVkIGJldHdlZW4KICogICAgICAgICAgICAgICAgICAgICAgICJPU1MgZG9jdW1lbnRlZCIgYW5kICJPU1MgYWN0dWFsIiBiZWhhdmlvdXIKICogICAgMzEuMDguMTk5OCAgIDAuNCAgIEZpeCByZWFscGxheWVyIHByb2JsZW1zIC0gZGFjLmNvdW50IGlzc3VlcwogKiAgICAyNy4xMC4xOTk4ICAgMC41ICAgRml4IGpveXN0aWNrIHN1cHBvcnQKICogICAgICAgICAgICAgICAgICAgICAgIC0tIE9saXZlciBOZXVrdW0gKGMxODhAb3JnLmNoZW1pZS51bmktbXVlbmNoZW4uZGUpCiAqICAgIDEwLjEyLjE5OTggICAwLjYgICBGaXggZHJhaW5fZGFjIHRyeWluZyB0byB3YWl0IG9uIG5vdCB5ZXQgaW5pdGlhbGl6ZWQgRE1BCiAqICAgIDIzLjEyLjE5OTggICAwLjcgICBGaXggYSBmZXcgZl9maWxlICYgRk1PREVfIGJ1Z3MKICogICAgICAgICAgICAgICAgICAgICAgIERvbid0IHdha2UgdXAgYXBwIHVudGlsIHRoZXJlIGFyZSBmcmFnc2l6ZSBieXRlcyB0byByZWFkL3dyaXRlCiAqICAgIDA2LjAxLjE5OTkgICAwLjggICByZW1vdmUgdGhlIHNpbGx5IFNBX0lOVEVSUlVQVCBmbGFnLgogKiAgICAgICAgICAgICAgICAgICAgICAgaG9wZWZ1bGx5IGtpbGxlZCB0aGUgZWdjcyBzZWN0aW9uIHR5cGUgY29uZmxpY3QKICogICAgMTIuMDMuMTk5OSAgIDAuOSAgIGNpbmZvLmJsb2NrcyBzaG91bGQgYmUgcmVzZXQgYWZ0ZXIgR0VUeFBUUiBpb2N0bC4KICogICAgICAgICAgICAgICAgICAgICAgIHJlcG9ydGVkIGJ5IEpvaGFuIE1hZXMgPGpvbWFAdGVsaW5kdXMuYmU+CiAqICAgIDIyLjAzLjE5OTkgICAwLjEwICByZXR1cm4gRUFHQUlOIGluc3RlYWQgb2YgRUJVU1kgd2hlbiBPX05PTkJMT0NLCiAqICAgICAgICAgICAgICAgICAgICAgICByZWFkL3dyaXRlIGNhbm5vdCBiZSBleGVjdXRlZAogKiAgICAwNy4wNC4xOTk5ICAgMC4xMSAgaW1wbGVtZW50ZWQgdGhlIGZvbGxvd2luZyBpb2N0bCdzOiBTT1VORF9QQ01fUkVBRF9SQVRFLCAKICogICAgICAgICAgICAgICAgICAgICAgIFNPVU5EX1BDTV9SRUFEX0NIQU5ORUxTLCBTT1VORF9QQ01fUkVBRF9CSVRTOyAKICogICAgICAgICAgICAgICAgICAgICAgIEFscGhhIGZpeGVzIHJlcG9ydGVkIGJ5IFBldGVyIEpvbmVzIDxwam9uZXNAcmVkaGF0LmNvbT4KICogICAgICAgICAgICAgICAgICAgICAgIEFub3RoZXIgQWxwaGEgZml4ICh3YWl0X3NyY19yZWFkeSBpbiBpbml0IHJvdXRpbmUpCiAqICAgICAgICAgICAgICAgICAgICAgICByZXBvcnRlZCBieSAiSXZhbiBOLiBLb2tzaGF5c2t5IiA8aW5rQGp1cmFzc2ljLnBhcmsubXN1LnJ1PgogKiAgICAgICAgICAgICAgICAgICAgICAgTm90ZTogam95c3RpY2sgYWRkcmVzcyBoYW5kbGluZyBtaWdodCBzdGlsbCBiZSB3cm9uZyBvbiBhcmNocwogKiAgICAgICAgICAgICAgICAgICAgICAgb3RoZXIgdGhhbiBpMzg2CiAqICAgIDE1LjA2LjE5OTkgICAwLjEyICBGaXggYmFkIGFsbG9jYXRpb24gYnVnLgogKiAgICAgICAgICAgICAgICAgICAgICAgVGhhbmtzIHRvIERldGkgRmxpZWdsIDxmbGllZ2xAaW4udHVtLmRlPgogKiAgICAyOC4wNi4xOTk5ICAgMC4xMyAgQWRkIHBjaV9zZXRfbWFzdGVyCiAqICAgIDAzLjA4LjE5OTkgICAwLjE0ICBhZGFwdCB0byBMaW51cycgbmV3IF9fc2V0dXAvX19pbml0Y2FsbAogKiAgICAgICAgICAgICAgICAgICAgICAgYWRkZWQga2VybmVsIGNvbW1hbmQgbGluZSBvcHRpb24gImVzMTM3MT1qb3lzdGlja2FkZHIiCiAqICAgICAgICAgICAgICAgICAgICAgICByZW1vdmVkIENPTkZJR19TT1VORF9FUzEzNzFfSk9ZUE9SVF9CT09UIGtsdWRnZQogKiAgICAxMC4wOC4xOTk5ICAgMC4xNSAgKFJlKWFkZGVkIFMvUERJRiBtb2R1bGUgb3B0aW9uIGZvciBjYXJkcyByZXZpc2lvbiA+PSA0LgogKiAgICAgICAgICAgICAgICAgICAgICAgSW5pdGlhbCB2ZXJzaW9uIGJ5IERhdmUgUGxhdHQgPGRwbGF0dEBzbnVsYnVnLm10dmlldy5jYS51cz4uCiAqICAgICAgICAgICAgICAgICAgICAgICBtb2R1bGVfaW5pdC9fX3NldHVwIGZpeGVzCiAqICAgIDA4LjE2LjE5OTkgICAwLjE2ICBKb2UgQ290ZWxsZXNlIDxqb2VjQGVuc29uaXEuY29tPgogKiAgICAgICAgICAgICAgICAgICAgICAgQWRkZWQgZGV0ZWN0aW9uIGZvciBFUzEzNzEgcmV2aXNpb24gSUQgc28gdGhhdCB3ZSBjYW4KICogICAgICAgICAgICAgICAgICAgICAgIGRldGVjdCB0aGUgRVMxMzczIGFuZCBsYXRlciBwYXJ0cy4KICogICAgICAgICAgICAgICAgICAgICAgIGFkZGVkIEFDOTcgI2RlZmluZXMgZm9yIHJlYWRhYmlsaXR5CiAqICAgICAgICAgICAgICAgICAgICAgICBhZGRlZCBhIC9wcm9jIGZpbGUgc3lzdGVtIGZvciBkdW1waW5nIGhhcmR3YXJlIHN0YXRlCiAqICAgICAgICAgICAgICAgICAgICAgICB1cGRhdGVkIFNSQyBhbmQgQ09ERUMgdy9yIGZ1bmN0aW9ucyB0byBhY2NvbW1vZGF0ZSBidWdzCiAqICAgICAgICAgICAgICAgICAgICAgICBpbiBzb21lIHZlcnNpb25zIG9mIHRoZSBFUzEzN3ggY2hpcHMuCiAqICAgIDMxLjA4LjE5OTkgICAwLjE3ICBhZGQgc3Bpbl9sb2NrX2luaXQKICogICAgICAgICAgICAgICAgICAgICAgIHJlcGxhY2VkIGN1cnJlbnQtPnN0YXRlID0geCB3aXRoIHNldF9jdXJyZW50X3N0YXRlKHgpCiAqICAgIDAzLjA5LjE5OTkgICAwLjE4ICBjaGFuZ2UgcmVhZCBzZW1hbnRpY3MgZm9yIE1JREkgdG8gbWF0Y2gKICogICAgICAgICAgICAgICAgICAgICAgIE9TUyBtb3JlIGNsb3NlbHk7IHJlbW92ZSBwb3NzaWJsZSB3YWtldXAgcmFjZQogKiAgICAyMS4xMC4xOTk5ICAgMC4xOSAgUm91bmQgc2FtcGxpbmcgcmF0ZXMsIHJlcXVlc3RlZCBieQogKiAgICAgICAgICAgICAgICAgICAgICAgS2FzYW1hdHN1IEtlbmljaGkgPHQyOXcwMjY3QGlwLm1lZGlhLmt5b3RvLXUuYWMuanA+CiAqICAgIDI3LjEwLjE5OTkgICAwLjIwICBBZGRlZCBTaWdtYVRlbCAzRCBlbmhhbmNlbWVudCBzdHJpbmcKICogICAgICAgICAgICAgICAgICAgICAgIENvZGVjIElEIHByaW50aW5nIGNoYW5nZXMKICogICAgMjguMTAuMTk5OSAgIDAuMjEgIE1vcmUgd2FpdHF1ZXVlIHJhY2VzIGZpeGVkCiAqICAgICAgICAgICAgICAgICAgICAgICBKb2UgQ290ZWxsZXNlIDxqb2VjQGVuc29uaXEuY29tPgogKiAgICAgICAgICAgICAgICAgICAgICAgQ2hhbmdlZCBQQ0kgZGV0ZWN0aW9uIHJvdXRpbmUgc28gd2UgY2FuIG1vcmUgZWFzaWx5CiAqICAgICAgICAgICAgICAgICAgICAgICBkZXRlY3QgRVMxMzd4IGNoaXAgYW5kIGRlcml2YXRpdmVzLgogKiAgICAwNS4wMS4yMDAwICAgMC4yMiAgU2hvdWxkIG5vdyB3b3JrIHdpdGggcmV2NyBib2FyZHM7IHBhdGNoIGJ5CiAqICAgICAgICAgICAgICAgICAgICAgICBFcmljIExlbWFyLCBlbGVtYXJAY3Mud2FzaGluZ3Rvbi5lZHUKICogICAgMDguMDEuMjAwMCAgIDAuMjMgIFByZXZlbnQgc29tZSBpb2N0bCdzIGZyb20gcmV0dXJuaW5nIGJhZCBjb3VudCB2YWx1ZXMgb24gdW5kZXJydW4vb3ZlcnJ1bjsKICogICAgICAgICAgICAgICAgICAgICAgIFRpbSBKYW5paydzIEJTRSAoQmVkZXZpbGxlZCBTb3VuZCBFbmdpbmUpIGZvdW5kIHRoaXMKICogICAgMDcuMDIuMjAwMCAgIDAuMjQgIFVzZSBwY2lfYWxsb2NfY29uc2lzdGVudCBhbmQgcGNpX3JlZ2lzdGVyX2RyaXZlcgogKiAgICAwNy4wMi4yMDAwICAgMC4yNSAgVXNlIGFjOTdfY29kZWMKICogICAgMDEuMDMuMjAwMCAgIDAuMjYgIFNQRElGIHBhdGNoIGJ5IE1pa2FlbCBCb3VpbGxvdCA8bWlrYWVsLmJvdWlsbG90QGJpZ2Zvb3QuY29tPgogKiAgICAgICAgICAgICAgICAgICAgICAgVXNlIHBjaV9tb2R1bGVfaW5pdAogKiAgICAyMS4xMS4yMDAwICAgMC4yNyAgSW5pdGlhbGl6ZSBkbWEgYnVmZmVycyBpbiBwb2xsLCBvdGhlcndpc2UgcG9sbCBtYXkgcmV0dXJuIGEgYm9ndXMgbWFzawogKiAgICAxMi4xMi4yMDAwICAgMC4yOCAgTW9yZSBkbWEgYnVmZmVyIGluaXRpYWxpemF0aW9ucywgcGF0Y2ggZnJvbQogKiAgICAgICAgICAgICAgICAgICAgICAgVGplZXJkIE11bGRlciA8dGplZXJkLm11bGRlckBmdWppdHN1LXNpZW1lbnMuY29tPgogKiAgICAwNS4wMS4yMDAxICAgMC4yOSAgSG9wZWZ1bGx5IHVwZGF0ZXMgd2lsbCBub3QgYmUgcmVxdWlyZWQgYW55bW9yZSB3aGVuIENyZWF0aXZlIGJ1bXBzCiAqICAgICAgICAgICAgICAgICAgICAgICB0aGUgQ1Q1ODgwIHJldmlzaW9uLgogKiAgICAgICAgICAgICAgICAgICAgICAgc3VnZ2VzdGVkIGJ5IFN0ZXBoYW4gTfxsbGVyIDxzbXVlbGxlckBjaHJvbm94LmRlPgogKiAgICAzMS4wMS4yMDAxICAgMC4zMCAgUmVnaXN0ZXIvVW5yZWdpc3RlciBnYW1lcG9ydAogKiAgICAgICAgICAgICAgICAgICAgICAgRml4IFNFVFRSSUdHRVIgbm9uIE9TUyBBUEkgY29uZm9ybWl0eQogKiAgICAxNC4wNy4yMDAxICAgMC4zMSAgQWRkIGxpc3Qgb2YgbGFwdG9wcyBuZWVkaW5nIGFtcGxpZmllciBjb250cm9sCiAqICAgIDAzLjAxLjIwMDMgICAwLjMyICBvcGVuX21vZGUgZml4ZXMgZnJvbSBHZW9yZyBBY2hlciA8YWNoZXJAaW4udHVtLmRlPgogKi8KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KICAgICAgCiNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiNpbmNsdWRlIDxsaW51eC9pb3BvcnQuaD4KI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgojaW5jbHVkZSA8bGludXgvc291bmQuaD4KI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KI2luY2x1ZGUgPGxpbnV4L3NvdW5kY2FyZC5oPgojaW5jbHVkZSA8bGludXgvcGNpLmg+CiNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CiNpbmNsdWRlIDxsaW51eC9iaXRvcHMuaD4KI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgojaW5jbHVkZSA8bGludXgvYWM5N19jb2RlYy5oPgojaW5jbHVkZSA8bGludXgvZ2FtZXBvcnQuaD4KI2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KCiNpbmNsdWRlIDxhc20vaW8uaD4KI2luY2x1ZGUgPGFzbS9wYWdlLmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCgojdW5kZWYgT1NTX0RPQ1VNRU5URURfTUlYRVJfU0VNQU5USUNTCiNkZWZpbmUgRVMxMzcxX0RFQlVHCiNkZWZpbmUgREJHKHgpIHt9Ci8qI2RlZmluZSBEQkcoeCkge3h9Ki8KCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKI2lmbmRlZiBQQ0lfVkVORE9SX0lEX0VOU09OSVEKI2RlZmluZSBQQ0lfVkVORE9SX0lEX0VOU09OSVEgICAgICAgIDB4MTI3NCAgICAKI2VuZGlmCgojaWZuZGVmIFBDSV9WRU5ET1JfSURfRUNUSVZBCiNkZWZpbmUgUENJX1ZFTkRPUl9JRF9FQ1RJVkEgICAgICAgICAweDExMDIKI2VuZGlmCgojaWZuZGVmIFBDSV9ERVZJQ0VfSURfRU5TT05JUV9FUzEzNzEKI2RlZmluZSBQQ0lfREVWSUNFX0lEX0VOU09OSVFfRVMxMzcxIDB4MTM3MQojZW5kaWYKCiNpZm5kZWYgUENJX0RFVklDRV9JRF9FTlNPTklRX0NUNTg4MAojZGVmaW5lIFBDSV9ERVZJQ0VfSURfRU5TT05JUV9DVDU4ODAgMHg1ODgwCiNlbmRpZgoKI2lmbmRlZiBQQ0lfREVWSUNFX0lEX0VDVElWQV9FVjE5MzgKI2RlZmluZSBQQ0lfREVWSUNFX0lEX0VDVElWQV9FVjE5MzggMHg4OTM4CiNlbmRpZgoKLyogRVMxMzcxIGNoaXAgSUQgKi8KLyogVGhpcyBpcyBhIGxpdHRsZSBjb25mdXNpbmcgYmVjYXVzZSBhbGwgRVMxMzcxIGNvbXBhdGlibGUgY2hpcHMgaGF2ZSB0aGUKICAgc2FtZSBERVZJQ0VfSUQsIHRoZSBvbmx5IHRoaW5nIGRpZmZlcmVudGlhdGluZyB0aGVtIGlzIHRoZSBSRVZfSUQgZmllbGQuCiAgIFRoaXMgaXMgb25seSBzaWduaWZpY2FudCBpZiB5b3Ugd2FudCB0byBlbmFibGUgZmVhdHVyZXMgb24gdGhlIGxhdGVyIHBhcnRzLgogICBZZXMsIEkga25vdyBpdCdzIHN0dXBpZCBhbmQgd2h5IGRpZG4ndCB3ZSB1c2UgdGhlIHN1YiBJRHM/CiovCiNkZWZpbmUgRVMxMzcxUkVWX0VTMTM3M19BICAweDA0CiNkZWZpbmUgRVMxMzcxUkVWX0VTMTM3M19CICAweDA2CiNkZWZpbmUgRVMxMzcxUkVWX0NUNTg4MF9BICAweDA3CiNkZWZpbmUgQ1Q1ODgwUkVWX0NUNTg4MF9DICAweDAyCiNkZWZpbmUgQ1Q1ODgwUkVWX0NUNTg4MF9EICAweDAzCiNkZWZpbmUgRVMxMzcxUkVWX0VTMTM3MV9CICAweDA5CiNkZWZpbmUgRVYxOTM4UkVWX0VWMTkzOF9BICAweDAwCiNkZWZpbmUgRVMxMzcxUkVWX0VTMTM3M184ICAweDA4CgojZGVmaW5lIEVTMTM3MV9NQUdJQyAgKChQQ0lfVkVORE9SX0lEX0VOU09OSVE8PDE2KXxQQ0lfREVWSUNFX0lEX0VOU09OSVFfRVMxMzcxKQoKI2RlZmluZSBFUzEzNzFfRVhURU5UICAgICAgICAgICAgIDB4NDAKI2RlZmluZSBKT1lfRVhURU5UICAgICAgICAgICAgICAgIDgKCiNkZWZpbmUgRVMxMzcxX1JFR19DT05UUk9MICAgICAgICAweDAwCiNkZWZpbmUgRVMxMzcxX1JFR19TVEFUVVMgICAgICAgICAweDA0IC8qIG9uIHRoZSA1ODgwIGl0IGlzIGNvbnRyb2wvc3RhdHVzICovCiNkZWZpbmUgRVMxMzcxX1JFR19VQVJUX0RBVEEgICAgICAweDA4CiNkZWZpbmUgRVMxMzcxX1JFR19VQVJUX1NUQVRVUyAgICAweDA5CiNkZWZpbmUgRVMxMzcxX1JFR19VQVJUX0NPTlRST0wgICAweDA5CiNkZWZpbmUgRVMxMzcxX1JFR19VQVJUX1RFU1QgICAgICAweDBhCiNkZWZpbmUgRVMxMzcxX1JFR19NRU1QQUdFICAgICAgICAweDBjCiNkZWZpbmUgRVMxMzcxX1JFR19TUkNPTlYgICAgICAgICAweDEwCiNkZWZpbmUgRVMxMzcxX1JFR19DT0RFQyAgICAgICAgICAweDE0CiNkZWZpbmUgRVMxMzcxX1JFR19MRUdBQ1kgICAgICAgICAweDE4CiNkZWZpbmUgRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCAweDIwCiNkZWZpbmUgRVMxMzcxX1JFR19EQUMxX1NDT1VOVCAgICAweDI0CiNkZWZpbmUgRVMxMzcxX1JFR19EQUMyX1NDT1VOVCAgICAweDI4CiNkZWZpbmUgRVMxMzcxX1JFR19BRENfU0NPVU5UICAgICAweDJjCgojZGVmaW5lIEVTMTM3MV9SRUdfREFDMV9GUkFNRUFEUiAgMHhjMzAKI2RlZmluZSBFUzEzNzFfUkVHX0RBQzFfRlJBTUVDTlQgIDB4YzM0CiNkZWZpbmUgRVMxMzcxX1JFR19EQUMyX0ZSQU1FQURSICAweGMzOAojZGVmaW5lIEVTMTM3MV9SRUdfREFDMl9GUkFNRUNOVCAgMHhjM2MKI2RlZmluZSBFUzEzNzFfUkVHX0FEQ19GUkFNRUFEUiAgIDB4ZDMwCiNkZWZpbmUgRVMxMzcxX1JFR19BRENfRlJBTUVDTlQgICAweGQzNAoKI2RlZmluZSBFUzEzNzFfRk1UX1U4X01PTk8gICAgIDAKI2RlZmluZSBFUzEzNzFfRk1UX1U4X1NURVJFTyAgIDEKI2RlZmluZSBFUzEzNzFfRk1UX1MxNl9NT05PICAgIDIKI2RlZmluZSBFUzEzNzFfRk1UX1MxNl9TVEVSRU8gIDMKI2RlZmluZSBFUzEzNzFfRk1UX1NURVJFTyAgICAgIDEKI2RlZmluZSBFUzEzNzFfRk1UX1MxNiAgICAgICAgIDIKI2RlZmluZSBFUzEzNzFfRk1UX01BU0sgICAgICAgIDMKCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBzYW1wbGVfc2l6ZVtdID0geyAxLCAyLCAyLCA0IH07CnN0YXRpYyBjb25zdCB1bnNpZ25lZCBzYW1wbGVfc2hpZnRbXSA9IHsgMCwgMSwgMSwgMiB9OwoKI2RlZmluZSBDVFJMX1JFQ0VOX0IgICAgMHgwODAwMDAwMCAgLyogMSA9IGRvbid0IG1peCBhbmFsb2cgaW4gdG8gZGlnaXRhbCBvdXQgKi8KI2RlZmluZSBDVFJMX1NQRElGRU5fQiAgMHgwNDAwMDAwMAojZGVmaW5lIENUUkxfSk9ZX1NISUZUICAyNAojZGVmaW5lIENUUkxfSk9ZX01BU0sgICAzCiNkZWZpbmUgQ1RSTF9KT1lfMjAwICAgIDB4MDAwMDAwMDAgIC8qIGpveXN0aWNrIGJhc2UgYWRkcmVzcyAqLwojZGVmaW5lIENUUkxfSk9ZXzIwOCAgICAweDAxMDAwMDAwCiNkZWZpbmUgQ1RSTF9KT1lfMjEwICAgIDB4MDIwMDAwMDAKI2RlZmluZSBDVFJMX0pPWV8yMTggICAgMHgwMzAwMDAwMAojZGVmaW5lIENUUkxfR1BJT19JTjAgICAweDAwMTAwMDAwICAvKiBnZW5lcmFsIHB1cnBvc2UgaW5wdXRzL291dHB1dHMgKi8KI2RlZmluZSBDVFJMX0dQSU9fSU4xICAgMHgwMDIwMDAwMAojZGVmaW5lIENUUkxfR1BJT19JTjIgICAweDAwNDAwMDAwCiNkZWZpbmUgQ1RSTF9HUElPX0lOMyAgIDB4MDA4MDAwMDAKI2RlZmluZSBDVFJMX0dQSU9fT1VUMCAgMHgwMDAxMDAwMAojZGVmaW5lIENUUkxfR1BJT19PVVQxICAweDAwMDIwMDAwCiNkZWZpbmUgQ1RSTF9HUElPX09VVDIgIDB4MDAwNDAwMDAKI2RlZmluZSBDVFJMX0dQSU9fT1VUMyAgMHgwMDA4MDAwMAojZGVmaW5lIENUUkxfTVNGTVRTRUwgICAweDAwMDA4MDAwICAvKiBNUEVHIHNlcmlhbCBkYXRhIGZtdDogMCA9IFNvbnksIDEgPSBJMlMgKi8KI2RlZmluZSBDVFJMX1NZTkNSRVMgICAgMHgwMDAwNDAwMCAgLyogQUM5NyB3YXJtIHJlc2V0ICovCiNkZWZpbmUgQ1RSTF9BRENTVE9QICAgIDB4MDAwMDIwMDAgIC8qIHN0b3AgQURDIHRyYW5zZmVycyAqLwojZGVmaW5lIENUUkxfUFdSX0lOVFJNICAweDAwMDAxMDAwICAvKiAxID0gcG93ZXIgbGV2ZWwgaW50cyBlbmFibGVkICovCiNkZWZpbmUgQ1RSTF9NX0NCICAgICAgIDB4MDAwMDA4MDAgIC8qIHJlY29yZGluZyBzb3VyY2U6IDAgPSBBREMsIDEgPSBNUEVHICovCiNkZWZpbmUgQ1RSTF9DQ0JfSU5UUk0gIDB4MDAwMDA0MDAgIC8qIDEgPSBDQ0IgInZvaWNlIiBpbnRzIGVuYWJsZWQgKi8KI2RlZmluZSBDVFJMX1BETEVWMCAgICAgMHgwMDAwMDAwMCAgLyogcG93ZXIgZG93biBsZXZlbCAqLwojZGVmaW5lIENUUkxfUERMRVYxICAgICAweDAwMDAwMTAwCiNkZWZpbmUgQ1RSTF9QRExFVjIgICAgIDB4MDAwMDAyMDAKI2RlZmluZSBDVFJMX1BETEVWMyAgICAgMHgwMDAwMDMwMAojZGVmaW5lIENUUkxfQlJFUSAgICAgICAweDAwMDAwMDgwICAvKiAxID0gdGVzdCBtb2RlIChpbnRlcm5hbCBtZW0gdGVzdCkgKi8KI2RlZmluZSBDVFJMX0RBQzFfRU4gICAgMHgwMDAwMDA0MCAgLyogZW5hYmxlIERBQzEgKi8KI2RlZmluZSBDVFJMX0RBQzJfRU4gICAgMHgwMDAwMDAyMCAgLyogZW5hYmxlIERBQzIgKi8KI2RlZmluZSBDVFJMX0FEQ19FTiAgICAgMHgwMDAwMDAxMCAgLyogZW5hYmxlIEFEQyAqLwojZGVmaW5lIENUUkxfVUFSVF9FTiAgICAweDAwMDAwMDA4ICAvKiBlbmFibGUgTUlESSB1YXJ0ICovCiNkZWZpbmUgQ1RSTF9KWVNUS19FTiAgIDB4MDAwMDAwMDQgIC8qIGVuYWJsZSBKb3lzdGljayBwb3J0ICovCiNkZWZpbmUgQ1RSTF9YVEFMQ0xLRElTIDB4MDAwMDAwMDIgIC8qIDEgPSBkaXNhYmxlIGNyeXN0YWwgY2xvY2sgaW5wdXQgKi8KI2RlZmluZSBDVFJMX1BDSUNMS0RJUyAgMHgwMDAwMDAwMSAgLyogMSA9IGRpc2FibGUgUENJIGNsb2NrIGRpc3RyaWJ1dGlvbiAqLwoKCiNkZWZpbmUgU1RBVF9JTlRSICAgICAgIDB4ODAwMDAwMDAgIC8qIHdpcmVkIG9yIG9mIGFsbCBpbnRlcnJ1cHQgYml0cyAqLwojZGVmaW5lIENTVEFUXzU4ODBfQUM5N19SU1QgMHgyMDAwMDAwMCAvKiBDVDU4ODAgUmVzZXQgYml0ICovCiNkZWZpbmUgU1RBVF9FTl9TUERJRiAgIDB4MDAwNDAwMDAgIC8qIGVuYWJsZSBTL1BESUYgY2lyY3VpdHJ5ICovCiNkZWZpbmUgU1RBVF9UU19TUERJRiAgIDB4MDAwMjAwMDAgIC8qIHRlc3QgUy9QRElGIGNpcmN1aXRyeSAqLwojZGVmaW5lIFNUQVRfVEVTVE1PREUgICAweDAwMDEwMDAwICAvKiB0ZXN0IEFTSUMgKi8KI2RlZmluZSBTVEFUX1NZTkNfRVJSICAgMHgwMDAwMDEwMCAgLyogMSA9IGNvZGVjIHN5bmMgZXJyb3IgKi8KI2RlZmluZSBTVEFUX1ZDICAgICAgICAgMHgwMDAwMDBjMCAgLyogQ0NCIGludCBzb3VyY2UsIDA9REFDMSwgMT1EQUMyLCAyPUFEQywgMz11bmRlZiAqLwojZGVmaW5lIFNUQVRfU0hfVkMgICAgICA2CiNkZWZpbmUgU1RBVF9NUFdSICAgICAgIDB4MDAwMDAwMjAgIC8qIHBvd2VyIGxldmVsIGludGVycnVwdCAqLwojZGVmaW5lIFNUQVRfTUNDQiAgICAgICAweDAwMDAwMDEwICAvKiBDQ0IgaW50IHBlbmRpbmcgKi8KI2RlZmluZSBTVEFUX1VBUlQgICAgICAgMHgwMDAwMDAwOCAgLyogVUFSVCBpbnQgcGVuZGluZyAqLwojZGVmaW5lIFNUQVRfREFDMSAgICAgICAweDAwMDAwMDA0ICAvKiBEQUMxIGludCBwZW5kaW5nICovCiNkZWZpbmUgU1RBVF9EQUMyICAgICAgIDB4MDAwMDAwMDIgIC8qIERBQzIgaW50IHBlbmRpbmcgKi8KI2RlZmluZSBTVEFUX0FEQyAgICAgICAgMHgwMDAwMDAwMSAgLyogQURDIGludCBwZW5kaW5nICovCgojZGVmaW5lIFVTVEFUX1JYSU5UICAgICAweDgwICAgICAgICAvKiBVQVJUIHJ4IGludCBwZW5kaW5nICovCiNkZWZpbmUgVVNUQVRfVFhJTlQgICAgIDB4MDQgICAgICAgIC8qIFVBUlQgdHggaW50IHBlbmRpbmcgKi8KI2RlZmluZSBVU1RBVF9UWFJEWSAgICAgMHgwMiAgICAgICAgLyogVUFSVCB0eCByZWFkeSAqLwojZGVmaW5lIFVTVEFUX1JYUkRZICAgICAweDAxICAgICAgICAvKiBVQVJUIHJ4IHJlYWR5ICovCgojZGVmaW5lIFVDVFJMX1JYSU5URU4gICAweDgwICAgICAgICAvKiAxID0gZW5hYmxlIFJYIGludHMgKi8KI2RlZmluZSBVQ1RSTF9UWElOVEVOICAgMHg2MCAgICAgICAgLyogVFggaW50IGVuYWJsZSBmaWVsZCBtYXNrICovCiNkZWZpbmUgVUNUUkxfRU5BX1RYSU5UIDB4MjAgICAgICAgIC8qIGVuYWJsZSBUWCBpbnQgKi8KI2RlZmluZSBVQ1RSTF9DTlRSTCAgICAgMHgwMyAgICAgICAgLyogY29udHJvbCBmaWVsZCAqLwojZGVmaW5lIFVDVFJMX0NOVFJMX1NXUiAweDAzICAgICAgICAvKiBzb2Z0d2FyZSByZXNldCBjb21tYW5kICovCgovKiBzYW1wbGUgcmF0ZSBjb252ZXJ0ZXIgKi8KI2RlZmluZSBTUkNfT0tTVEFURSAgICAgICAgMQoKI2RlZmluZSBTUkNfUkFNQUREUl9NQVNLICAgMHhmZTAwMDAwMAojZGVmaW5lIFNSQ19SQU1BRERSX1NISUZUICAyNQojZGVmaW5lIFNSQ19EQUMxRlJFRVpFICAgICAoMVVMIDw8IDIxKQojZGVmaW5lIFNSQ19EQUMyRlJFRVpFICAgICAgKDFVTCA8PCAyMCkKI2RlZmluZSBTUkNfQURDRlJFRVpFICAgICAgKDFVTCA8PCAxOSkKCgojZGVmaW5lIFNSQ19XRSAgICAgICAgICAgICAweDAxMDAwMDAwICAvKiByZWFkL3dyaXRlIGNvbnRyb2wgZm9yIFNSQyBSQU0gKi8KI2RlZmluZSBTUkNfQlVTWSAgICAgICAgICAgMHgwMDgwMDAwMCAgLyogU1JDIGJ1c3kgKi8KI2RlZmluZSBTUkNfRElTICAgICAgICAgICAgMHgwMDQwMDAwMCAgLyogMSA9IGRpc2FibGUgU1JDICovCiNkZWZpbmUgU1JDX0REQUMxICAgICAgICAgIDB4MDAyMDAwMDAgIC8qIDEgPSBkaXNhYmxlIGFjY3VtIHVwZGF0ZSBmb3IgREFDMSAqLwojZGVmaW5lIFNSQ19EREFDMiAgICAgICAgICAweDAwMTAwMDAwICAvKiAxID0gZGlzYWJsZSBhY2N1bSB1cGRhdGUgZm9yIERBQzIgKi8KI2RlZmluZSBTUkNfREFEQyAgICAgICAgICAgMHgwMDA4MDAwMCAgLyogMSA9IGRpc2FibGUgYWNjdW0gdXBkYXRlIGZvciBBREMyICovCiNkZWZpbmUgU1JDX0NUTE1BU0sgICAgICAgIDB4MDA3ODAwMDAKI2RlZmluZSBTUkNfUkFNREFUQV9NQVNLICAgMHgwMDAwZmZmZgojZGVmaW5lIFNSQ19SQU1EQVRBX1NISUZUICAwCgojZGVmaW5lIFNSQ1JFR19BREMgICAgICAweDc4CiNkZWZpbmUgU1JDUkVHX0RBQzEgICAgIDB4NzAKI2RlZmluZSBTUkNSRUdfREFDMiAgICAgMHg3NAojZGVmaW5lIFNSQ1JFR19WT0xfQURDICAweDZjCiNkZWZpbmUgU1JDUkVHX1ZPTF9EQUMxIDB4N2MKI2RlZmluZSBTUkNSRUdfVk9MX0RBQzIgMHg3ZQoKI2RlZmluZSBTUkNSRUdfVFJVTkNfTiAgICAgMHgwMAojZGVmaW5lIFNSQ1JFR19JTlRfUkVHUyAgICAweDAxCiNkZWZpbmUgU1JDUkVHX0FDQ1VNX0ZSQUMgIDB4MDIKI2RlZmluZSBTUkNSRUdfVkZSRVFfRlJBQyAgMHgwMwoKI2RlZmluZSBDT0RFQ19QSVJEICAgICAgICAweDAwODAwMDAwICAvKiAwID0gd3JpdGUgQUM5NyByZWdpc3RlciAqLwojZGVmaW5lIENPREVDX1BJQUREX01BU0sgIDB4MDA3ZjAwMDAKI2RlZmluZSBDT0RFQ19QSUFERF9TSElGVCAxNgojZGVmaW5lIENPREVDX1BJREFUX01BU0sgIDB4MDAwMGZmZmYKI2RlZmluZSBDT0RFQ19QSURBVF9TSElGVCAwCgojZGVmaW5lIENPREVDX1JEWSAgICAgICAgIDB4ODAwMDAwMDAgIC8qIEFDOTcgcmVhZCBkYXRhIHZhbGlkICovCiNkZWZpbmUgQ09ERUNfV0lQICAgICAgICAgMHg0MDAwMDAwMCAgLyogQUM5NyB3cml0ZSBpbiBwcm9ncmVzcyAqLwojZGVmaW5lIENPREVDX1BPUkQgICAgICAgIDB4MDA4MDAwMDAgIC8qIDAgPSB3cml0ZSBBQzk3IHJlZ2lzdGVyICovCiNkZWZpbmUgQ09ERUNfUE9BRERfTUFTSyAgMHgwMDdmMDAwMAojZGVmaW5lIENPREVDX1BPQUREX1NISUZUIDE2CiNkZWZpbmUgQ09ERUNfUE9EQVRfTUFTSyAgMHgwMDAwZmZmZgojZGVmaW5lIENPREVDX1BPREFUX1NISUZUIDAKCgojZGVmaW5lIExFR0FDWV9KRkFTVCAgICAgIDB4ODAwMDAwMDAgIC8qIGZhc3Qgam95c3RpY2sgdGltaW5nICovCiNkZWZpbmUgTEVHQUNZX0ZJUlEgICAgICAgMHgwMTAwMDAwMCAgLyogZm9yY2UgSVJRICovCgojZGVmaW5lIFNDVFJMX0RBQ1RFU1QgICAgIDB4MDA0MDAwMDAgIC8qIDEgPSBEQUMgdGVzdCwgdGVzdCB2ZWN0b3IgZ2VuZXJhdGlvbiBwdXJwb3NlcyAqLwojZGVmaW5lIFNDVFJMX1AyRU5ESU5DICAgIDB4MDAzODAwMDAgIC8qICAqLwojZGVmaW5lIFNDVFJMX1NIX1AyRU5ESU5DIDE5CiNkZWZpbmUgU0NUUkxfUDJTVElOQyAgICAgMHgwMDA3MDAwMCAgLyogICovCiNkZWZpbmUgU0NUUkxfU0hfUDJTVElOQyAgMTYKI2RlZmluZSBTQ1RSTF9SMUxPT1BTRUwgICAweDAwMDA4MDAwICAvKiAwID0gbG9vcCBtb2RlICovCiNkZWZpbmUgU0NUUkxfUDJMT09QU0VMICAgMHgwMDAwNDAwMCAgLyogMCA9IGxvb3AgbW9kZSAqLwojZGVmaW5lIFNDVFJMX1AxTE9PUFNFTCAgIDB4MDAwMDIwMDAgIC8qIDAgPSBsb29wIG1vZGUgKi8KI2RlZmluZSBTQ1RSTF9QMlBBVVNFICAgICAweDAwMDAxMDAwICAvKiAxID0gcGF1c2UgbW9kZSAqLwojZGVmaW5lIFNDVFJMX1AxUEFVU0UgICAgIDB4MDAwMDA4MDAgIC8qIDEgPSBwYXVzZSBtb2RlICovCiNkZWZpbmUgU0NUUkxfUjFJTlRFTiAgICAgMHgwMDAwMDQwMCAgLyogZW5hYmxlIGludGVycnVwdCAqLwojZGVmaW5lIFNDVFJMX1AySU5URU4gICAgIDB4MDAwMDAyMDAgIC8qIGVuYWJsZSBpbnRlcnJ1cHQgKi8KI2RlZmluZSBTQ1RSTF9QMUlOVEVOICAgICAweDAwMDAwMTAwICAvKiBlbmFibGUgaW50ZXJydXB0ICovCiNkZWZpbmUgU0NUUkxfUDFTQ1RSTEQgICAgMHgwMDAwMDA4MCAgLyogcmVsb2FkIHNhbXBsZSBjb3VudCByZWdpc3RlciBmb3IgREFDMSAqLwojZGVmaW5lIFNDVFJMX1AyREFDU0VOICAgIDB4MDAwMDAwNDAgIC8qIDEgPSBEQUMyIHBsYXkgYmFjayBsYXN0IHNhbXBsZSB3aGVuIGRpc2FibGVkICovCiNkZWZpbmUgU0NUUkxfUjFTRUIgICAgICAgMHgwMDAwMDAyMCAgLyogMSA9IDE2Yml0ICovCiNkZWZpbmUgU0NUUkxfUjFTTUIgICAgICAgMHgwMDAwMDAxMCAgLyogMSA9IHN0ZXJlbyAqLwojZGVmaW5lIFNDVFJMX1IxRk1UICAgICAgIDB4MDAwMDAwMzAgIC8qIGZvcm1hdCBtYXNrICovCiNkZWZpbmUgU0NUUkxfU0hfUjFGTVQgICAgNAojZGVmaW5lIFNDVFJMX1AyU0VCICAgICAgIDB4MDAwMDAwMDggIC8qIDEgPSAxNmJpdCAqLwojZGVmaW5lIFNDVFJMX1AyU01CICAgICAgIDB4MDAwMDAwMDQgIC8qIDEgPSBzdGVyZW8gKi8KI2RlZmluZSBTQ1RSTF9QMkZNVCAgICAgICAweDAwMDAwMDBjICAvKiBmb3JtYXQgbWFzayAqLwojZGVmaW5lIFNDVFJMX1NIX1AyRk1UICAgIDIKI2RlZmluZSBTQ1RSTF9QMVNFQiAgICAgICAweDAwMDAwMDAyICAvKiAxID0gMTZiaXQgKi8KI2RlZmluZSBTQ1RSTF9QMVNNQiAgICAgICAweDAwMDAwMDAxICAvKiAxID0gc3RlcmVvICovCiNkZWZpbmUgU0NUUkxfUDFGTVQgICAgICAgMHgwMDAwMDAwMyAgLyogZm9ybWF0IG1hc2sgKi8KI2RlZmluZSBTQ1RSTF9TSF9QMUZNVCAgICAwCgoKLyogbWlzYyBzdHVmZiAqLwojZGVmaW5lIFBPTExfQ09VTlQgICAweDEwMDAKI2RlZmluZSBGTU9ERV9EQUMgICAgICAgICA0ICAgICAgICAgICAvKiBzbGlnaHQgbWlzdXNlIG9mIG1vZGVfdCAqLwoKLyogTUlESSBidWZmZXIgc2l6ZXMgKi8KCiNkZWZpbmUgTUlESUlOQlVGICAyNTYKI2RlZmluZSBNSURJT1VUQlVGIDI1NgoKI2RlZmluZSBGTU9ERV9NSURJX1NISUZUIDMKI2RlZmluZSBGTU9ERV9NSURJX1JFQUQgIChGTU9ERV9SRUFEIDw8IEZNT0RFX01JRElfU0hJRlQpCiNkZWZpbmUgRk1PREVfTUlESV9XUklURSAoRk1PREVfV1JJVEUgPDwgRk1PREVfTUlESV9TSElGVCkKCiNkZWZpbmUgRVMxMzcxX01PRFVMRV9OQU1FICJlczEzNzEiCiNkZWZpbmUgUEZYIEVTMTM3MV9NT0RVTEVfTkFNRSAiOiAiCgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCnN0cnVjdCBlczEzNzFfc3RhdGUgewoJLyogbWFnaWMgKi8KCXVuc2lnbmVkIGludCBtYWdpYzsKCgkvKiBsaXN0IG9mIGVzMTM3MSBkZXZpY2VzICovCglzdHJ1Y3QgbGlzdF9oZWFkIGRldnM7CgoJLyogdGhlIGNvcnJlc3BvbmRpbmcgcGNpX2RldiBzdHJ1Y3R1cmUgKi8KCXN0cnVjdCBwY2lfZGV2ICpkZXY7CgoJLyogc291bmRjb3JlIHN0dWZmICovCglpbnQgZGV2X2F1ZGlvOwoJaW50IGRldl9kYWM7CglpbnQgZGV2X21pZGk7CgkKCS8qIGhhcmR3YXJlIHJlc291cmNlcyAqLwoJdW5zaWduZWQgbG9uZyBpbzsgLyogbG9uZyBmb3IgU1BBUkMgKi8KCXVuc2lnbmVkIGludCBpcnE7CgoJLyogUENJIElEJ3MgKi8KCXUxNiB2ZW5kb3I7Cgl1MTYgZGV2aWNlOwogICAgICAgIHU4IHJldjsgLyogdGhlIGNoaXAgcmV2aXNpb24gKi8KCgkvKiBvcHRpb25zICovCglpbnQgc3BkaWZfdm9sdW1lOyAvKiBTL1BESUYgb3V0cHV0IGlzIGVuYWJsZWQgaWYgIT0gLTEgKi8KCiNpZmRlZiBFUzEzNzFfREVCVUcKICAgICAgICAvKiBkZWJ1ZyAvcHJvYyBlbnRyeSAqLwoJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpwczsKI2VuZGlmIC8qIEVTMTM3MV9ERUJVRyAqLwoKCXN0cnVjdCBhYzk3X2NvZGVjICpjb2RlYzsKCgkvKiB3YXZlIHN0dWZmICovCgl1bnNpZ25lZCBjdHJsOwoJdW5zaWduZWQgc2N0cmw7Cgl1bnNpZ25lZCBkYWMxcmF0ZSwgZGFjMnJhdGUsIGFkY3JhdGU7CgoJc3BpbmxvY2tfdCBsb2NrOwoJc3RydWN0IHNlbWFwaG9yZSBvcGVuX3NlbTsKCW1vZGVfdCBvcGVuX21vZGU7Cgl3YWl0X3F1ZXVlX2hlYWRfdCBvcGVuX3dhaXQ7CgoJc3RydWN0IGRtYWJ1ZiB7CgkJdm9pZCAqcmF3YnVmOwoJCWRtYV9hZGRyX3QgZG1hYWRkcjsKCQl1bnNpZ25lZCBidWZvcmRlcjsKCQl1bnNpZ25lZCBudW1mcmFnOwoJCXVuc2lnbmVkIGZyYWdzaGlmdDsKCQl1bnNpZ25lZCBod3B0ciwgc3dwdHI7CgkJdW5zaWduZWQgdG90YWxfYnl0ZXM7CgkJaW50IGNvdW50OwoJCXVuc2lnbmVkIGVycm9yOyAvKiBvdmVyL3VuZGVycnVuICovCgkJd2FpdF9xdWV1ZV9oZWFkX3Qgd2FpdDsKCQkvKiByZWR1bmRhbnQsIGJ1dCBtYWtlcyBjYWxjdWxhdGlvbnMgZWFzaWVyICovCgkJdW5zaWduZWQgZnJhZ3NpemU7CgkJdW5zaWduZWQgZG1hc2l6ZTsKCQl1bnNpZ25lZCBmcmFnc2FtcGxlczsKCQkvKiBPU1Mgc3R1ZmYgKi8KCQl1bnNpZ25lZCBtYXBwZWQ6MTsKCQl1bnNpZ25lZCByZWFkeToxOwoJCXVuc2lnbmVkIGVuZGNsZWFyZWQ6MTsKCQl1bnNpZ25lZCBlbmFibGVkOjE7CgkJdW5zaWduZWQgb3NzZnJhZ3NoaWZ0OwoJCWludCBvc3NtYXhmcmFnczsKCQl1bnNpZ25lZCBzdWJkaXZpc2lvbjsKCX0gZG1hX2RhYzEsIGRtYV9kYWMyLCBkbWFfYWRjOwoKCS8qIG1pZGkgc3R1ZmYgKi8KCXN0cnVjdCB7CgkJdW5zaWduZWQgaXJkLCBpd3IsIGljbnQ7CgkJdW5zaWduZWQgb3JkLCBvd3IsIG9jbnQ7CgkJd2FpdF9xdWV1ZV9oZWFkX3QgaXdhaXQ7CgkJd2FpdF9xdWV1ZV9oZWFkX3Qgb3dhaXQ7CgkJdW5zaWduZWQgY2hhciBpYnVmW01JRElJTkJVRl07CgkJdW5zaWduZWQgY2hhciBvYnVmW01JRElPVVRCVUZdOwoJfSBtaWRpOwoKCXN0cnVjdCBnYW1lcG9ydCAqZ2FtZXBvcnQ7CglzdHJ1Y3Qgc2VtYXBob3JlIHNlbTsKfTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIExJU1RfSEVBRChkZXZzKTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIGlubGluZSB1bnNpZ25lZCBsZDIodW5zaWduZWQgaW50IHgpCnsKCXVuc2lnbmVkIHIgPSAwOwoJCglpZiAoeCA+PSAweDEwMDAwKSB7CgkJeCA+Pj0gMTY7CgkJciArPSAxNjsKCX0KCWlmICh4ID49IDB4MTAwKSB7CgkJeCA+Pj0gODsKCQlyICs9IDg7Cgl9CglpZiAoeCA+PSAweDEwKSB7CgkJeCA+Pj0gNDsKCQlyICs9IDQ7Cgl9CglpZiAoeCA+PSA0KSB7CgkJeCA+Pj0gMjsKCQlyICs9IDI7Cgl9CglpZiAoeCA+PSAyKQoJCXIrKzsKCXJldHVybiByOwp9CgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCnN0YXRpYyB1bnNpZ25lZCB3YWl0X3NyY19yZWFkeShzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzKQp7Cgl1bnNpZ25lZCBpbnQgdCwgcjsKCglmb3IgKHQgPSAwOyB0IDwgUE9MTF9DT1VOVDsgdCsrKSB7CgkJaWYgKCEoKHIgPSBpbmwocy0+aW8gKyBFUzEzNzFfUkVHX1NSQ09OVikpICYgU1JDX0JVU1kpKQoJCQlyZXR1cm4gcjsKCQl1ZGVsYXkoMSk7Cgl9CglwcmludGsoS0VSTl9ERUJVRyBQRlggInNhbXBsZSByYXRlIGNvbnZlcnRlciB0aW1lb3V0IHIgPSAweCUwOHhcbiIsIHIpOwoJcmV0dXJuIHI7Cn0KCnN0YXRpYyB1bnNpZ25lZCBzcmNfcmVhZChzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzLCB1bnNpZ25lZCByZWcpCnsKICAgICAgICB1bnNpZ25lZCBpbnQgdGVtcCxpLG9yaWc7CgogICAgICAgIC8qIHdhaXQgZm9yIHJlYWR5ICovCiAgICAgICAgdGVtcCA9IHdhaXRfc3JjX3JlYWR5IChzKTsKCiAgICAgICAgLyogd2UgY2FuIG9ubHkgYWNjZXNzIHRoZSBTUkMgYXQgY2VydGFpbiB0aW1lcywgbWFrZSBzdXJlCiAgICAgICAgICAgd2UncmUgYWxsb3dlZCB0byBiZWZvcmUgd2UgcmVhZCAqLwogICAgICAgICAgIAogICAgICAgIG9yaWcgPSB0ZW1wOwogICAgICAgIC8qIGV4cG9zZSB0aGUgU1JDIHN0YXRlIGJpdHMgKi8KICAgICAgICBvdXRsICggKHRlbXAgJiBTUkNfQ1RMTUFTSykgfCAocmVnIDw8IFNSQ19SQU1BRERSX1NISUZUKSB8IDB4MTAwMDBVTCwKICAgICAgICAgICAgICAgcy0+aW8gKyBFUzEzNzFfUkVHX1NSQ09OVik7CgogICAgICAgIC8qIG5vdywgd2FpdCBmb3IgYnVzeSBhbmQgdGhlIGNvcnJlY3QgdGltZSB0byByZWFkICovCiAgICAgICAgdGVtcCA9IHdhaXRfc3JjX3JlYWR5IChzKTsKCiAgICAgICAgaWYgKCAodGVtcCAmIDB4MDA4NzAwMDBVTCApICE9ICggU1JDX09LU1RBVEUgPDwgMTYgKSl7CiAgICAgICAgICAgICAgICAvKiB3YWl0IGZvciB0aGUgcmlnaHQgc3RhdGUgKi8KICAgICAgICAgICAgICAgIGZvciAoaT0wOyBpPFBPTExfQ09VTlQ7IGkrKyl7CiAgICAgICAgICAgICAgICAgICAgICAgIHRlbXAgPSBpbmwgKHMtPmlvICsgRVMxMzcxX1JFR19TUkNPTlYpOwogICAgICAgICAgICAgICAgICAgICAgICBpZiAoICh0ZW1wICYgMHgwMDg3MDAwMFVMICkgPT0gKCBTUkNfT0tTVEFURSA8PCAxNiApKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgLyogaGlkZSB0aGUgc3RhdGUgYml0cyAqLwogICAgICAgIG91dGwgKChvcmlnICYgU1JDX0NUTE1BU0spIHwgKHJlZyA8PCBTUkNfUkFNQUREUl9TSElGVCksIHMtPmlvICsgRVMxMzcxX1JFR19TUkNPTlYpOwogICAgICAgIHJldHVybiB0ZW1wOwogICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgIAp9CgpzdGF0aWMgdm9pZCBzcmNfd3JpdGUoc3RydWN0IGVzMTM3MV9zdGF0ZSAqcywgdW5zaWduZWQgcmVnLCB1bnNpZ25lZCBkYXRhKQp7CiAgICAgIAoJdW5zaWduZWQgaW50IHI7CgoJciA9IHdhaXRfc3JjX3JlYWR5KHMpICYgKFNSQ19ESVMgfCBTUkNfRERBQzEgfCBTUkNfRERBQzIgfCBTUkNfREFEQyk7CglyIHw9IChyZWcgPDwgU1JDX1JBTUFERFJfU0hJRlQpICYgU1JDX1JBTUFERFJfTUFTSzsKCXIgfD0gKGRhdGEgPDwgU1JDX1JBTURBVEFfU0hJRlQpICYgU1JDX1JBTURBVEFfTUFTSzsKCW91dGwociB8IFNSQ19XRSwgcy0+aW8gKyBFUzEzNzFfUkVHX1NSQ09OVik7Cgp9CgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCi8qIG1vc3Qgb2YgdGhlIGZvbGxvd2luZyBoZXJlIGlzIGJsYWNrIG1hZ2ljICovCnN0YXRpYyB2b2lkIHNldF9hZGNfcmF0ZShzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzLCB1bnNpZ25lZCByYXRlKQp7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgaW50IG4sIHRydW5jbSwgZnJlcTsKCglpZiAocmF0ZSA+IDQ4MDAwKQoJCXJhdGUgPSA0ODAwMDsKCWlmIChyYXRlIDwgNDAwMCkKCQlyYXRlID0gNDAwMDsKCW4gPSByYXRlIC8gMzAwMDsKCWlmICgoMSA8PCBuKSAmICgoMSA8PCAxNSkgfCAoMSA8PCAxMykgfCAoMSA8PCAxMSkgfCAoMSA8PCA5KSkpCgkJbi0tOwoJdHJ1bmNtID0gKDIxICogbiAtIDEpIHwgMTsKICAgICAgICBmcmVxID0gKCg0ODAwMFVMIDw8IDE1KSAvIHJhdGUpICogbjsKCXMtPmFkY3JhdGUgPSAoNDgwMDBVTCA8PCAxNSkgLyAoZnJlcSAvIG4pOwoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCWlmIChyYXRlID49IDI0MDAwKSB7CgkJaWYgKHRydW5jbSA+IDIzOSkKCQkJdHJ1bmNtID0gMjM5OwoJCXNyY193cml0ZShzLCBTUkNSRUdfQURDK1NSQ1JFR19UUlVOQ19OLCAKCQkJICAoKCgyMzkgLSB0cnVuY20pID4+IDEpIDw8IDkpIHwgKG4gPDwgNCkpOwoJfSBlbHNlIHsKCQlpZiAodHJ1bmNtID4gMTE5KQoJCQl0cnVuY20gPSAxMTk7CgkJc3JjX3dyaXRlKHMsIFNSQ1JFR19BREMrU1JDUkVHX1RSVU5DX04sIAoJCQkgIDB4ODAwMCB8ICgoKDExOSAtIHRydW5jbSkgPj4gMSkgPDwgOSkgfCAobiA8PCA0KSk7Cgl9CQkKCXNyY193cml0ZShzLCBTUkNSRUdfQURDK1NSQ1JFR19JTlRfUkVHUywgCgkJICAoc3JjX3JlYWQocywgU1JDUkVHX0FEQytTUkNSRUdfSU5UX1JFR1MpICYgMHgwMGZmKSB8CgkJICAoKGZyZXEgPj4gNSkgJiAweGZjMDApKTsKCXNyY193cml0ZShzLCBTUkNSRUdfQURDK1NSQ1JFR19WRlJFUV9GUkFDLCBmcmVxICYgMHg3ZmZmKTsKCXNyY193cml0ZShzLCBTUkNSRUdfVk9MX0FEQywgbiA8PCA4KTsKCXNyY193cml0ZShzLCBTUkNSRUdfVk9MX0FEQysxLCBuIDw8IDgpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwp9CgoKc3RhdGljIHZvaWQgc2V0X2RhYzFfcmF0ZShzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzLCB1bnNpZ25lZCByYXRlKQp7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgaW50IGZyZXEsIHI7CgoJaWYgKHJhdGUgPiA0ODAwMCkKCQlyYXRlID0gNDgwMDA7CglpZiAocmF0ZSA8IDQwMDApCgkJcmF0ZSA9IDQwMDA7CiAgICAgICAgZnJlcSA9ICgocmF0ZSA8PCAxNSkgKyAxNTAwKSAvIDMwMDA7CglzLT5kYWMxcmF0ZSA9IChmcmVxICogMzAwMCArIDE2Mzg0KSA+PiAxNTsKCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CglyID0gKHdhaXRfc3JjX3JlYWR5KHMpICYgKFNSQ19ESVMgfCBTUkNfRERBQzIgfCBTUkNfREFEQykpIHwgU1JDX0REQUMxOwoJb3V0bChyLCBzLT5pbyArIEVTMTM3MV9SRUdfU1JDT05WKTsKCXNyY193cml0ZShzLCBTUkNSRUdfREFDMStTUkNSRUdfSU5UX1JFR1MsIAoJCSAgKHNyY19yZWFkKHMsIFNSQ1JFR19EQUMxK1NSQ1JFR19JTlRfUkVHUykgJiAweDAwZmYpIHwKCQkgICgoZnJlcSA+PiA1KSAmIDB4ZmMwMCkpOwoJc3JjX3dyaXRlKHMsIFNSQ1JFR19EQUMxK1NSQ1JFR19WRlJFUV9GUkFDLCBmcmVxICYgMHg3ZmZmKTsKCXIgPSAod2FpdF9zcmNfcmVhZHkocykgJiAoU1JDX0RJUyB8IFNSQ19EREFDMiB8IFNSQ19EQURDKSk7CglvdXRsKHIsIHMtPmlvICsgRVMxMzcxX1JFR19TUkNPTlYpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZCBzZXRfZGFjMl9yYXRlKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMsIHVuc2lnbmVkIHJhdGUpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBpbnQgZnJlcSwgcjsKCglpZiAocmF0ZSA+IDQ4MDAwKQoJCXJhdGUgPSA0ODAwMDsKCWlmIChyYXRlIDwgNDAwMCkKCQlyYXRlID0gNDAwMDsKICAgICAgICBmcmVxID0gKChyYXRlIDw8IDE1KSArIDE1MDApIC8gMzAwMDsKCXMtPmRhYzJyYXRlID0gKGZyZXEgKiAzMDAwICsgMTYzODQpID4+IDE1OwoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCXIgPSAod2FpdF9zcmNfcmVhZHkocykgJiAoU1JDX0RJUyB8IFNSQ19EREFDMSB8IFNSQ19EQURDKSkgfCBTUkNfRERBQzI7CglvdXRsKHIsIHMtPmlvICsgRVMxMzcxX1JFR19TUkNPTlYpOwoJc3JjX3dyaXRlKHMsIFNSQ1JFR19EQUMyK1NSQ1JFR19JTlRfUkVHUywgCgkJICAoc3JjX3JlYWQocywgU1JDUkVHX0RBQzIrU1JDUkVHX0lOVF9SRUdTKSAmIDB4MDBmZikgfAoJCSAgKChmcmVxID4+IDUpICYgMHhmYzAwKSk7CglzcmNfd3JpdGUocywgU1JDUkVHX0RBQzIrU1JDUkVHX1ZGUkVRX0ZSQUMsIGZyZXEgJiAweDdmZmYpOwoJciA9ICh3YWl0X3NyY19yZWFkeShzKSAmIChTUkNfRElTIHwgU1JDX0REQUMxIHwgU1JDX0RBREMpKTsKCW91dGwociwgcy0+aW8gKyBFUzEzNzFfUkVHX1NSQ09OVik7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7Cn0KCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIHZvaWQgX19kZXZpbml0IHNyY19pbml0KHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKICAgICAgICB1bnNpZ25lZCBpbnQgaTsKCiAgICAgICAgLyogYmVmb3JlIHdlIGVuYWJsZSBvciBkaXNhYmxlIHRoZSBTUkMgd2UgbmVlZAogICAgICAgICAgIHRvIHdhaXQgZm9yIGl0IHRvIGJlY29tZSByZWFkeSAqLwogICAgICAgIHdhaXRfc3JjX3JlYWR5KHMpOwoKICAgICAgICBvdXRsKFNSQ19ESVMsIHMtPmlvICsgRVMxMzcxX1JFR19TUkNPTlYpOwoKICAgICAgICBmb3IgKGkgPSAwOyBpIDwgMHg4MDsgaSsrKQogICAgICAgICAgICAgICAgc3JjX3dyaXRlKHMsIGksIDApOwoKICAgICAgICBzcmNfd3JpdGUocywgU1JDUkVHX0RBQzErU1JDUkVHX1RSVU5DX04sIDE2IDw8IDQpOwogICAgICAgIHNyY193cml0ZShzLCBTUkNSRUdfREFDMStTUkNSRUdfSU5UX1JFR1MsIDE2IDw8IDEwKTsKICAgICAgICBzcmNfd3JpdGUocywgU1JDUkVHX0RBQzIrU1JDUkVHX1RSVU5DX04sIDE2IDw8IDQpOwogICAgICAgIHNyY193cml0ZShzLCBTUkNSRUdfREFDMitTUkNSRUdfSU5UX1JFR1MsIDE2IDw8IDEwKTsKICAgICAgICBzcmNfd3JpdGUocywgU1JDUkVHX1ZPTF9BREMsIDEgPDwgMTIpOwogICAgICAgIHNyY193cml0ZShzLCBTUkNSRUdfVk9MX0FEQysxLCAxIDw8IDEyKTsKICAgICAgICBzcmNfd3JpdGUocywgU1JDUkVHX1ZPTF9EQUMxLCAxIDw8IDEyKTsKICAgICAgICBzcmNfd3JpdGUocywgU1JDUkVHX1ZPTF9EQUMxKzEsIDEgPDwgMTIpOwogICAgICAgIHNyY193cml0ZShzLCBTUkNSRUdfVk9MX0RBQzIsIDEgPDwgMTIpOwogICAgICAgIHNyY193cml0ZShzLCBTUkNSRUdfVk9MX0RBQzIrMSwgMSA8PCAxMik7CiAgICAgICAgc2V0X2FkY19yYXRlKHMsIDIyMDUwKTsKICAgICAgICBzZXRfZGFjMV9yYXRlKHMsIDIyMDUwKTsKICAgICAgICBzZXRfZGFjMl9yYXRlKHMsIDIyMDUwKTsKCiAgICAgICAgLyogV0FSTklORzoKICAgICAgICAgKiBlbmFibGluZyB0aGUgc2FtcGxlIHJhdGUgY29udmVydGVyIHdpdGhvdXQgcHJvcGVybHkgcHJvZ3JhbW1pbmcKICAgICAgICAgKiBpdHMgcGFyYW1ldGVycyBjYXVzZXMgdGhlIGNoaXAgdG8gbG9jayB1cCAodGhlIFNSQyBidXN5IGJpdCB3aWxsCiAgICAgICAgICogYmUgc3R1Y2sgaGlnaCwgYW5kIEkndmUgZm91bmQgbm8gd2F5IHRvIHJlY3RpZnkgdGhpcyBvdGhlciB0aGFuCiAgICAgICAgICogcG93ZXIgY3ljbGUpCiAgICAgICAgICovCiAgICAgICAgd2FpdF9zcmNfcmVhZHkocyk7CiAgICAgICAgb3V0bCgwLCBzLT5pbytFUzEzNzFfUkVHX1NSQ09OVik7Cn0KCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIHZvaWQgd3Jjb2RlYyhzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWMsIHU4IGFkZHIsIHUxNiBkYXRhKQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gKHN0cnVjdCBlczEzNzFfc3RhdGUgKiljb2RlYy0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXVuc2lnbmVkIHQsIHg7CiAgICAgICAgCglzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJZm9yICh0ID0gMDsgdCA8IFBPTExfQ09VTlQ7IHQrKykKCQlpZiAoIShpbmwocy0+aW8rRVMxMzcxX1JFR19DT0RFQykgJiBDT0RFQ19XSVApKQoJCQlicmVhazsKCiAgICAgICAgLyogc2F2ZSB0aGUgY3VycmVudCBzdGF0ZSBmb3IgbGF0ZXIgKi8KICAgICAgICB4ID0gd2FpdF9zcmNfcmVhZHkocyk7CgogICAgICAgIC8qIGVuYWJsZSBTUkMgc3RhdGUgZGF0YSBpbiBTUkMgbXV4ICovCglvdXRsKCh4ICYgKFNSQ19ESVMgfCBTUkNfRERBQzEgfCBTUkNfRERBQzIgfCBTUkNfREFEQykpIHwgMHgwMDAxMDAwMCwKCSAgICAgcy0+aW8rRVMxMzcxX1JFR19TUkNPTlYpOwoKICAgICAgICAvKiB3YWl0IGZvciBub3QgYnVzeSAoc3RhdGUgMCkgZmlyc3QgdG8gYXZvaWQKICAgICAgICAgICB0cmFuc2l0aW9uIHN0YXRlcyAqLwogICAgICAgIGZvciAodD0wOyB0PFBPTExfQ09VTlQ7IHQrKyl7CiAgICAgICAgICAgICAgICBpZigoaW5sKHMtPmlvK0VTMTM3MV9SRUdfU1JDT05WKSAmIDB4MDA4NzAwMDApID09MCApCiAgICAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICAgICB1ZGVsYXkoMSk7CiAgICAgICAgfQogICAgICAgIAogICAgICAgIC8qIHdhaXQgZm9yIGEgU0FGRSB0aW1lIHRvIHdyaXRlIGFkZHIvZGF0YSBhbmQgdGhlbiBkbyBpdCwgZGFtbWl0ICovCiAgICAgICAgZm9yICh0PTA7IHQ8UE9MTF9DT1VOVDsgdCsrKXsKICAgICAgICAgICAgICAgIGlmKChpbmwocy0+aW8rRVMxMzcxX1JFR19TUkNPTlYpICYgMHgwMDg3MDAwMCkgPT0weDAwMDEwMDAwKQogICAgICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgICAgdWRlbGF5KDEpOwogICAgICAgIH0KCglvdXRsKCgoYWRkciA8PCBDT0RFQ19QT0FERF9TSElGVCkgJiBDT0RFQ19QT0FERF9NQVNLKSB8CgkgICAgICgoZGF0YSA8PCBDT0RFQ19QT0RBVF9TSElGVCkgJiBDT0RFQ19QT0RBVF9NQVNLKSwgcy0+aW8rRVMxMzcxX1JFR19DT0RFQyk7CgoJLyogcmVzdG9yZSBTUkMgcmVnICovCgl3YWl0X3NyY19yZWFkeShzKTsKCW91dGwoeCwgcy0+aW8rRVMxMzcxX1JFR19TUkNPTlYpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdTE2IHJkY29kZWMoc3RydWN0IGFjOTdfY29kZWMgKmNvZGVjLCB1OCBhZGRyKQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gKHN0cnVjdCBlczEzNzFfc3RhdGUgKiljb2RlYy0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXVuc2lnbmVkIHQsIHg7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQogICAgICAgIC8qIHdhaXQgZm9yIFdJUCB0byBnbyBhd2F5ICovCglmb3IgKHQgPSAwOyB0IDwgMHgxMDAwOyB0KyspCgkJaWYgKCEoaW5sKHMtPmlvK0VTMTM3MV9SRUdfQ09ERUMpICYgQ09ERUNfV0lQKSkKCQkJYnJlYWs7CgoJLyogc2F2ZSB0aGUgY3VycmVudCBzdGF0ZSBmb3IgbGF0ZXIgKi8KCXggPSAod2FpdF9zcmNfcmVhZHkocykgJiAoU1JDX0RJUyB8IFNSQ19EREFDMSB8IFNSQ19EREFDMiB8IFNSQ19EQURDKSk7CgoJLyogZW5hYmxlIFNSQyBzdGF0ZSBkYXRhIGluIFNSQyBtdXggKi8KCW91dGwoIHggfCAweDAwMDEwMDAwLAogICAgICAgICAgICAgIHMtPmlvK0VTMTM3MV9SRUdfU1JDT05WKTsKCiAgICAgICAgLyogd2FpdCBmb3Igbm90IGJ1c3kgKHN0YXRlIDApIGZpcnN0IHRvIGF2b2lkCiAgICAgICAgICAgdHJhbnNpdGlvbiBzdGF0ZXMgKi8KICAgICAgICBmb3IgKHQ9MDsgdDxQT0xMX0NPVU5UOyB0KyspewogICAgICAgICAgICAgICAgaWYoKGlubChzLT5pbytFUzEzNzFfUkVHX1NSQ09OVikgJiAweDAwODcwMDAwKSA9PTAgKQogICAgICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgICAgdWRlbGF5KDEpOwogICAgICAgIH0KICAgICAgICAKICAgICAgICAvKiB3YWl0IGZvciBhIFNBRkUgdGltZSB0byB3cml0ZSBhZGRyL2RhdGEgYW5kIHRoZW4gZG8gaXQsIGRhbW1pdCAqLwogICAgICAgIGZvciAodD0wOyB0PFBPTExfQ09VTlQ7IHQrKyl7CiAgICAgICAgICAgICAgICBpZigoaW5sKHMtPmlvK0VTMTM3MV9SRUdfU1JDT05WKSAmIDB4MDA4NzAwMDApID09MHgwMDAxMDAwMCkKICAgICAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgICAgIHVkZWxheSgxKTsKICAgICAgICB9CgoJb3V0bCgoKGFkZHIgPDwgQ09ERUNfUE9BRERfU0hJRlQpICYgQ09ERUNfUE9BRERfTUFTSykgfCBDT0RFQ19QT1JELCBzLT5pbytFUzEzNzFfUkVHX0NPREVDKTsKCS8qIHJlc3RvcmUgU1JDIHJlZyAqLwoJd2FpdF9zcmNfcmVhZHkocyk7CglvdXRsKHgsIHMtPmlvK0VTMTM3MV9SRUdfU1JDT05WKTsKCiAgICAgICAgLyogd2FpdCBmb3IgV0lQIGFnYWluICovCglmb3IgKHQgPSAwOyB0IDwgMHgxMDAwOyB0KyspCgkJaWYgKCEoaW5sKHMtPmlvK0VTMTM3MV9SRUdfQ09ERUMpICYgQ09ERUNfV0lQKSkKCQkJYnJlYWs7CiAgICAgICAgCgkvKiBub3cgd2FpdCBmb3IgdGhlIHN0aW5raW4nIGRhdGEgKFJEWSkgKi8KCWZvciAodCA9IDA7IHQgPCBQT0xMX0NPVU5UOyB0KyspCgkJaWYgKCh4ID0gaW5sKHMtPmlvK0VTMTM3MV9SRUdfQ09ERUMpKSAmIENPREVDX1JEWSkKCQkJYnJlYWs7CiAgICAgICAgCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CglyZXR1cm4gKCh4ICYgQ09ERUNfUElEQVRfTUFTSykgPj4gQ09ERUNfUElEQVRfU0hJRlQpOwp9CgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCnN0YXRpYyBpbmxpbmUgdm9pZCBzdG9wX2FkYyhzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzKQp7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CglzLT5jdHJsICY9IH5DVFJMX0FEQ19FTjsKCW91dGwocy0+Y3RybCwgcy0+aW8rRVMxMzcxX1JFR19DT05UUk9MKTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKfQkKCnN0YXRpYyBpbmxpbmUgdm9pZCBzdG9wX2RhYzEoc3RydWN0IGVzMTM3MV9zdGF0ZSAqcykKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJcy0+Y3RybCAmPSB+Q1RSTF9EQUMxX0VOOwoJb3V0bChzLT5jdHJsLCBzLT5pbytFUzEzNzFfUkVHX0NPTlRST0wpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwp9CQoKc3RhdGljIGlubGluZSB2b2lkIHN0b3BfZGFjMihzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzKQp7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CglzLT5jdHJsICY9IH5DVFJMX0RBQzJfRU47CglvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7Cn0JCgpzdGF0aWMgdm9pZCBzdGFydF9kYWMxKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBmcmFncmVtYWluLCBmc2hpZnQ7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCWlmICghKHMtPmN0cmwgJiBDVFJMX0RBQzFfRU4pICYmIChzLT5kbWFfZGFjMS5tYXBwZWQgfHwgcy0+ZG1hX2RhYzEuY291bnQgPiAwKQoJICAgICYmIHMtPmRtYV9kYWMxLnJlYWR5KSB7CgkJcy0+Y3RybCB8PSBDVFJMX0RBQzFfRU47CgkJcy0+c2N0cmwgPSAocy0+c2N0cmwgJiB+KFNDVFJMX1AxTE9PUFNFTCB8IFNDVFJMX1AxUEFVU0UgfCBTQ1RSTF9QMVNDVFJMRCkpIHwgU0NUUkxfUDFJTlRFTjsKCQlvdXRsKHMtPnNjdHJsLCBzLT5pbytFUzEzNzFfUkVHX1NFUklBTF9DT05UUk9MKTsKCQlmcmFncmVtYWluID0gKCgtIHMtPmRtYV9kYWMxLmh3cHRyKSAmIChzLT5kbWFfZGFjMS5mcmFnc2l6ZS0xKSk7CgkJZnNoaWZ0ID0gc2FtcGxlX3NoaWZ0WyhzLT5zY3RybCAmIFNDVFJMX1AxRk1UKSA+PiBTQ1RSTF9TSF9QMUZNVF07CgkJaWYgKGZyYWdyZW1haW4gPCAyKmZzaGlmdCkKCQkJZnJhZ3JlbWFpbiA9IHMtPmRtYV9kYWMxLmZyYWdzaXplOwoJCW91dGwoKGZyYWdyZW1haW4gPj4gZnNoaWZ0KSAtIDEsIHMtPmlvK0VTMTM3MV9SRUdfREFDMV9TQ09VTlQpOwoJCW91dGwocy0+Y3RybCwgcy0+aW8rRVMxMzcxX1JFR19DT05UUk9MKTsKCQlvdXRsKChzLT5kbWFfZGFjMS5mcmFnc2l6ZSA+PiBmc2hpZnQpIC0gMSwgcy0+aW8rRVMxMzcxX1JFR19EQUMxX1NDT1VOVCk7Cgl9CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7Cn0JCgpzdGF0aWMgdm9pZCBzdGFydF9kYWMyKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBmcmFncmVtYWluLCBmc2hpZnQ7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCWlmICghKHMtPmN0cmwgJiBDVFJMX0RBQzJfRU4pICYmIChzLT5kbWFfZGFjMi5tYXBwZWQgfHwgcy0+ZG1hX2RhYzIuY291bnQgPiAwKQoJICAgICYmIHMtPmRtYV9kYWMyLnJlYWR5KSB7CgkJcy0+Y3RybCB8PSBDVFJMX0RBQzJfRU47CgkJcy0+c2N0cmwgPSAocy0+c2N0cmwgJiB+KFNDVFJMX1AyTE9PUFNFTCB8IFNDVFJMX1AyUEFVU0UgfCBTQ1RSTF9QMkRBQ1NFTiB8IAoJCQkJCSBTQ1RSTF9QMkVORElOQyB8IFNDVFJMX1AyU1RJTkMpKSB8IFNDVFJMX1AySU5URU4gfAoJCQkoKChzLT5zY3RybCAmIFNDVFJMX1AyRk1UKSA/IDIgOiAxKSA8PCBTQ1RSTF9TSF9QMkVORElOQykgfCAKCQkJKDAgPDwgU0NUUkxfU0hfUDJTVElOQyk7CgkJb3V0bChzLT5zY3RybCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7CgkJZnJhZ3JlbWFpbiA9ICgoLSBzLT5kbWFfZGFjMi5od3B0cikgJiAocy0+ZG1hX2RhYzIuZnJhZ3NpemUtMSkpOwoJCWZzaGlmdCA9IHNhbXBsZV9zaGlmdFsocy0+c2N0cmwgJiBTQ1RSTF9QMkZNVCkgPj4gU0NUUkxfU0hfUDJGTVRdOwoJCWlmIChmcmFncmVtYWluIDwgMipmc2hpZnQpCgkJCWZyYWdyZW1haW4gPSBzLT5kbWFfZGFjMi5mcmFnc2l6ZTsKCQlvdXRsKChmcmFncmVtYWluID4+IGZzaGlmdCkgLSAxLCBzLT5pbytFUzEzNzFfUkVHX0RBQzJfU0NPVU5UKTsKCQlvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CgkJb3V0bCgocy0+ZG1hX2RhYzIuZnJhZ3NpemUgPj4gZnNoaWZ0KSAtIDEsIHMtPmlvK0VTMTM3MV9SRUdfREFDMl9TQ09VTlQpOwoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwp9CQoKc3RhdGljIHZvaWQgc3RhcnRfYWRjKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBmcmFncmVtYWluLCBmc2hpZnQ7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCWlmICghKHMtPmN0cmwgJiBDVFJMX0FEQ19FTikgJiYgKHMtPmRtYV9hZGMubWFwcGVkIHx8IHMtPmRtYV9hZGMuY291bnQgPCAoc2lnbmVkKShzLT5kbWFfYWRjLmRtYXNpemUgLSAyKnMtPmRtYV9hZGMuZnJhZ3NpemUpKQoJICAgICYmIHMtPmRtYV9hZGMucmVhZHkpIHsKCQlzLT5jdHJsIHw9IENUUkxfQURDX0VOOwoJCXMtPnNjdHJsID0gKHMtPnNjdHJsICYgflNDVFJMX1IxTE9PUFNFTCkgfCBTQ1RSTF9SMUlOVEVOOwoJCW91dGwocy0+c2N0cmwsIHMtPmlvK0VTMTM3MV9SRUdfU0VSSUFMX0NPTlRST0wpOwoJCWZyYWdyZW1haW4gPSAoKC0gcy0+ZG1hX2FkYy5od3B0cikgJiAocy0+ZG1hX2FkYy5mcmFnc2l6ZS0xKSk7CgkJZnNoaWZ0ID0gc2FtcGxlX3NoaWZ0WyhzLT5zY3RybCAmIFNDVFJMX1IxRk1UKSA+PiBTQ1RSTF9TSF9SMUZNVF07CgkJaWYgKGZyYWdyZW1haW4gPCAyKmZzaGlmdCkKCQkJZnJhZ3JlbWFpbiA9IHMtPmRtYV9hZGMuZnJhZ3NpemU7CgkJb3V0bCgoZnJhZ3JlbWFpbiA+PiBmc2hpZnQpIC0gMSwgcy0+aW8rRVMxMzcxX1JFR19BRENfU0NPVU5UKTsKCQlvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CgkJb3V0bCgocy0+ZG1hX2FkYy5mcmFnc2l6ZSA+PiBmc2hpZnQpIC0gMSwgcy0+aW8rRVMxMzcxX1JFR19BRENfU0NPVU5UKTsKCX0KCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKfQkKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKI2RlZmluZSBETUFCVUZfREVGQVVMVE9SREVSICgxNy1QQUdFX1NISUZUKQojZGVmaW5lIERNQUJVRl9NSU5PUkRFUiAxCgoKc3RhdGljIGlubGluZSB2b2lkIGRlYWxsb2NfZG1hYnVmKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMsIHN0cnVjdCBkbWFidWYgKmRiKQp7CglzdHJ1Y3QgcGFnZSAqcGFnZSwgKnBlbmQ7CgoJaWYgKGRiLT5yYXdidWYpIHsKCQkvKiB1bmRvIG1hcmtpbmcgdGhlIHBhZ2VzIGFzIHJlc2VydmVkICovCgkJcGVuZCA9IHZpcnRfdG9fcGFnZShkYi0+cmF3YnVmICsgKFBBR0VfU0laRSA8PCBkYi0+YnVmb3JkZXIpIC0gMSk7CgkJZm9yIChwYWdlID0gdmlydF90b19wYWdlKGRiLT5yYXdidWYpOyBwYWdlIDw9IHBlbmQ7IHBhZ2UrKykKCQkJQ2xlYXJQYWdlUmVzZXJ2ZWQocGFnZSk7CgkJcGNpX2ZyZWVfY29uc2lzdGVudChzLT5kZXYsIFBBR0VfU0laRSA8PCBkYi0+YnVmb3JkZXIsIGRiLT5yYXdidWYsIGRiLT5kbWFhZGRyKTsKCX0KCWRiLT5yYXdidWYgPSBOVUxMOwoJZGItPm1hcHBlZCA9IGRiLT5yZWFkeSA9IDA7Cn0KCnN0YXRpYyBpbnQgcHJvZ19kbWFidWYoc3RydWN0IGVzMTM3MV9zdGF0ZSAqcywgc3RydWN0IGRtYWJ1ZiAqZGIsIHVuc2lnbmVkIHJhdGUsIHVuc2lnbmVkIGZtdCwgdW5zaWduZWQgcmVnKQp7CglpbnQgb3JkZXI7Cgl1bnNpZ25lZCBieXRlcGVyc2VjOwoJdW5zaWduZWQgYnVmczsKCXN0cnVjdCBwYWdlICpwYWdlLCAqcGVuZDsKCglkYi0+aHdwdHIgPSBkYi0+c3dwdHIgPSBkYi0+dG90YWxfYnl0ZXMgPSBkYi0+Y291bnQgPSBkYi0+ZXJyb3IgPSBkYi0+ZW5kY2xlYXJlZCA9IDA7CglpZiAoIWRiLT5yYXdidWYpIHsKCQlkYi0+cmVhZHkgPSBkYi0+bWFwcGVkID0gMDsKCQlmb3IgKG9yZGVyID0gRE1BQlVGX0RFRkFVTFRPUkRFUjsgb3JkZXIgPj0gRE1BQlVGX01JTk9SREVSOyBvcmRlci0tKQoJCQlpZiAoKGRiLT5yYXdidWYgPSBwY2lfYWxsb2NfY29uc2lzdGVudChzLT5kZXYsIFBBR0VfU0laRSA8PCBvcmRlciwgJmRiLT5kbWFhZGRyKSkpCgkJCQlicmVhazsKCQlpZiAoIWRiLT5yYXdidWYpCgkJCXJldHVybiAtRU5PTUVNOwoJCWRiLT5idWZvcmRlciA9IG9yZGVyOwoJCS8qIG5vdyBtYXJrIHRoZSBwYWdlcyBhcyByZXNlcnZlZDsgb3RoZXJ3aXNlIHJlbWFwX3Bmbl9yYW5nZSBkb2Vzbid0IGRvIHdoYXQgd2Ugd2FudCAqLwoJCXBlbmQgPSB2aXJ0X3RvX3BhZ2UoZGItPnJhd2J1ZiArIChQQUdFX1NJWkUgPDwgZGItPmJ1Zm9yZGVyKSAtIDEpOwoJCWZvciAocGFnZSA9IHZpcnRfdG9fcGFnZShkYi0+cmF3YnVmKTsgcGFnZSA8PSBwZW5kOyBwYWdlKyspCgkJCVNldFBhZ2VSZXNlcnZlZChwYWdlKTsKCX0KCWZtdCAmPSBFUzEzNzFfRk1UX01BU0s7CglieXRlcGVyc2VjID0gcmF0ZSA8PCBzYW1wbGVfc2hpZnRbZm10XTsKCWJ1ZnMgPSBQQUdFX1NJWkUgPDwgZGItPmJ1Zm9yZGVyOwoJaWYgKGRiLT5vc3NmcmFnc2hpZnQpIHsKCQlpZiAoKDEwMDAgPDwgZGItPm9zc2ZyYWdzaGlmdCkgPCBieXRlcGVyc2VjKQoJCQlkYi0+ZnJhZ3NoaWZ0ID0gbGQyKGJ5dGVwZXJzZWMvMTAwMCk7CgkJZWxzZQoJCQlkYi0+ZnJhZ3NoaWZ0ID0gZGItPm9zc2ZyYWdzaGlmdDsKCX0gZWxzZSB7CgkJZGItPmZyYWdzaGlmdCA9IGxkMihieXRlcGVyc2VjLzEwMC8oZGItPnN1YmRpdmlzaW9uID8gZGItPnN1YmRpdmlzaW9uIDogMSkpOwoJCWlmIChkYi0+ZnJhZ3NoaWZ0IDwgMykKCQkJZGItPmZyYWdzaGlmdCA9IDM7Cgl9CglkYi0+bnVtZnJhZyA9IGJ1ZnMgPj4gZGItPmZyYWdzaGlmdDsKCXdoaWxlIChkYi0+bnVtZnJhZyA8IDQgJiYgZGItPmZyYWdzaGlmdCA+IDMpIHsKCQlkYi0+ZnJhZ3NoaWZ0LS07CgkJZGItPm51bWZyYWcgPSBidWZzID4+IGRiLT5mcmFnc2hpZnQ7Cgl9CglkYi0+ZnJhZ3NpemUgPSAxIDw8IGRiLT5mcmFnc2hpZnQ7CglpZiAoZGItPm9zc21heGZyYWdzID49IDQgJiYgZGItPm9zc21heGZyYWdzIDwgZGItPm51bWZyYWcpCgkJZGItPm51bWZyYWcgPSBkYi0+b3NzbWF4ZnJhZ3M7CglkYi0+ZnJhZ3NhbXBsZXMgPSBkYi0+ZnJhZ3NpemUgPj4gc2FtcGxlX3NoaWZ0W2ZtdF07CglkYi0+ZG1hc2l6ZSA9IGRiLT5udW1mcmFnIDw8IGRiLT5mcmFnc2hpZnQ7CgltZW1zZXQoZGItPnJhd2J1ZiwgKGZtdCAmIEVTMTM3MV9GTVRfUzE2KSA/IDAgOiAweDgwLCBkYi0+ZG1hc2l6ZSk7CglvdXRsKChyZWcgPj4gOCkgJiAxNSwgcy0+aW8rRVMxMzcxX1JFR19NRU1QQUdFKTsKCW91dGwoZGItPmRtYWFkZHIsIHMtPmlvKyhyZWcgJiAweGZmKSk7CglvdXRsKChkYi0+ZG1hc2l6ZSA+PiAyKS0xLCBzLT5pbysoKHJlZyArIDQpICYgMHhmZikpOwoJZGItPmVuYWJsZWQgPSAxOwoJZGItPnJlYWR5ID0gMTsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW5saW5lIGludCBwcm9nX2RtYWJ1Zl9hZGMoc3RydWN0IGVzMTM3MV9zdGF0ZSAqcykKewoJc3RvcF9hZGMocyk7CglyZXR1cm4gcHJvZ19kbWFidWYocywgJnMtPmRtYV9hZGMsIHMtPmFkY3JhdGUsIChzLT5zY3RybCA+PiBTQ1RSTF9TSF9SMUZNVCkgJiBFUzEzNzFfRk1UX01BU0ssIAoJCQkgICBFUzEzNzFfUkVHX0FEQ19GUkFNRUFEUik7Cn0KCnN0YXRpYyBpbmxpbmUgaW50IHByb2dfZG1hYnVmX2RhYzIoc3RydWN0IGVzMTM3MV9zdGF0ZSAqcykKewoJc3RvcF9kYWMyKHMpOwoJcmV0dXJuIHByb2dfZG1hYnVmKHMsICZzLT5kbWFfZGFjMiwgcy0+ZGFjMnJhdGUsIChzLT5zY3RybCA+PiBTQ1RSTF9TSF9QMkZNVCkgJiBFUzEzNzFfRk1UX01BU0ssIAoJCQkgICBFUzEzNzFfUkVHX0RBQzJfRlJBTUVBRFIpOwp9CgpzdGF0aWMgaW5saW5lIGludCBwcm9nX2RtYWJ1Zl9kYWMxKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKCXN0b3BfZGFjMShzKTsKCXJldHVybiBwcm9nX2RtYWJ1ZihzLCAmcy0+ZG1hX2RhYzEsIHMtPmRhYzFyYXRlLCAocy0+c2N0cmwgPj4gU0NUUkxfU0hfUDFGTVQpICYgRVMxMzcxX0ZNVF9NQVNLLAoJCQkgICBFUzEzNzFfUkVHX0RBQzFfRlJBTUVBRFIpOwp9CgpzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGdldF9od3B0cihzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzLCBzdHJ1Y3QgZG1hYnVmICpkYiwgdW5zaWduZWQgcmVnKQp7Cgl1bnNpZ25lZCBod3B0ciwgZGlmZjsKCglvdXRsKChyZWcgPj4gOCkgJiAxNSwgcy0+aW8rRVMxMzcxX1JFR19NRU1QQUdFKTsKCWh3cHRyID0gKGlubChzLT5pbysocmVnICYgMHhmZikpID4+IDE0KSAmIDB4M2ZmZmM7CglkaWZmID0gKGRiLT5kbWFzaXplICsgaHdwdHIgLSBkYi0+aHdwdHIpICUgZGItPmRtYXNpemU7CglkYi0+aHdwdHIgPSBod3B0cjsKCXJldHVybiBkaWZmOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgY2xlYXJfYWR2YW5jZSh2b2lkICpidWYsIHVuc2lnbmVkIGJzaXplLCB1bnNpZ25lZCBicHRyLCB1bnNpZ25lZCBsZW4sIHVuc2lnbmVkIGNoYXIgYykKewoJaWYgKGJwdHIgKyBsZW4gPiBic2l6ZSkgewoJCXVuc2lnbmVkIHggPSBic2l6ZSAtIGJwdHI7CgkJbWVtc2V0KCgoY2hhciAqKWJ1ZikgKyBicHRyLCBjLCB4KTsKCQlicHRyID0gMDsKCQlsZW4gLT0geDsKCX0KCW1lbXNldCgoKGNoYXIgKilidWYpICsgYnB0ciwgYywgbGVuKTsKfQoKLyogY2FsbCB3aXRoIHNwaW5sb2NrIGhlbGQhICovCnN0YXRpYyB2b2lkIGVzMTM3MV91cGRhdGVfcHRyKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKCWludCBkaWZmOwoKCS8qIHVwZGF0ZSBBREMgcG9pbnRlciAqLwoJaWYgKHMtPmN0cmwgJiBDVFJMX0FEQ19FTikgewoJCWRpZmYgPSBnZXRfaHdwdHIocywgJnMtPmRtYV9hZGMsIEVTMTM3MV9SRUdfQURDX0ZSQU1FQ05UKTsKCQlzLT5kbWFfYWRjLnRvdGFsX2J5dGVzICs9IGRpZmY7CgkJcy0+ZG1hX2FkYy5jb3VudCArPSBkaWZmOwoJCWlmIChzLT5kbWFfYWRjLmNvdW50ID49IChzaWduZWQpcy0+ZG1hX2FkYy5mcmFnc2l6ZSkgCgkJCXdha2VfdXAoJnMtPmRtYV9hZGMud2FpdCk7CgkJaWYgKCFzLT5kbWFfYWRjLm1hcHBlZCkgewoJCQlpZiAocy0+ZG1hX2FkYy5jb3VudCA+IChzaWduZWQpKHMtPmRtYV9hZGMuZG1hc2l6ZSAtICgoMyAqIHMtPmRtYV9hZGMuZnJhZ3NpemUpID4+IDEpKSkgewoJCQkJcy0+Y3RybCAmPSB+Q1RSTF9BRENfRU47CgkJCQlvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CgkJCQlzLT5kbWFfYWRjLmVycm9yKys7CgkJCX0KCQl9Cgl9CgkvKiB1cGRhdGUgREFDMSBwb2ludGVyICovCglpZiAocy0+Y3RybCAmIENUUkxfREFDMV9FTikgewoJCWRpZmYgPSBnZXRfaHdwdHIocywgJnMtPmRtYV9kYWMxLCBFUzEzNzFfUkVHX0RBQzFfRlJBTUVDTlQpOwoJCXMtPmRtYV9kYWMxLnRvdGFsX2J5dGVzICs9IGRpZmY7CgkJaWYgKHMtPmRtYV9kYWMxLm1hcHBlZCkgewoJCQlzLT5kbWFfZGFjMS5jb3VudCArPSBkaWZmOwoJCQlpZiAocy0+ZG1hX2RhYzEuY291bnQgPj0gKHNpZ25lZClzLT5kbWFfZGFjMS5mcmFnc2l6ZSkKCQkJCXdha2VfdXAoJnMtPmRtYV9kYWMxLndhaXQpOwoJCX0gZWxzZSB7CgkJCXMtPmRtYV9kYWMxLmNvdW50IC09IGRpZmY7CgkJCWlmIChzLT5kbWFfZGFjMS5jb3VudCA8PSAwKSB7CgkJCQlzLT5jdHJsICY9IH5DVFJMX0RBQzFfRU47CgkJCQlvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CgkJCQlzLT5kbWFfZGFjMS5lcnJvcisrOwoJCQl9IGVsc2UgaWYgKHMtPmRtYV9kYWMxLmNvdW50IDw9IChzaWduZWQpcy0+ZG1hX2RhYzEuZnJhZ3NpemUgJiYgIXMtPmRtYV9kYWMxLmVuZGNsZWFyZWQpIHsKCQkJCWNsZWFyX2FkdmFuY2Uocy0+ZG1hX2RhYzEucmF3YnVmLCBzLT5kbWFfZGFjMS5kbWFzaXplLCBzLT5kbWFfZGFjMS5zd3B0ciwgCgkJCQkJICAgICAgcy0+ZG1hX2RhYzEuZnJhZ3NpemUsIChzLT5zY3RybCAmIFNDVFJMX1AxU0VCKSA/IDAgOiAweDgwKTsKCQkJCXMtPmRtYV9kYWMxLmVuZGNsZWFyZWQgPSAxOwoJCQl9CgkJCWlmIChzLT5kbWFfZGFjMS5jb3VudCArIChzaWduZWQpcy0+ZG1hX2RhYzEuZnJhZ3NpemUgPD0gKHNpZ25lZClzLT5kbWFfZGFjMS5kbWFzaXplKQoJCQkJd2FrZV91cCgmcy0+ZG1hX2RhYzEud2FpdCk7CgkJfQoJfQoJLyogdXBkYXRlIERBQzIgcG9pbnRlciAqLwoJaWYgKHMtPmN0cmwgJiBDVFJMX0RBQzJfRU4pIHsKCQlkaWZmID0gZ2V0X2h3cHRyKHMsICZzLT5kbWFfZGFjMiwgRVMxMzcxX1JFR19EQUMyX0ZSQU1FQ05UKTsKCQlzLT5kbWFfZGFjMi50b3RhbF9ieXRlcyArPSBkaWZmOwoJCWlmIChzLT5kbWFfZGFjMi5tYXBwZWQpIHsKCQkJcy0+ZG1hX2RhYzIuY291bnQgKz0gZGlmZjsKCQkJaWYgKHMtPmRtYV9kYWMyLmNvdW50ID49IChzaWduZWQpcy0+ZG1hX2RhYzIuZnJhZ3NpemUpCgkJCQl3YWtlX3VwKCZzLT5kbWFfZGFjMi53YWl0KTsKCQl9IGVsc2UgewoJCQlzLT5kbWFfZGFjMi5jb3VudCAtPSBkaWZmOwoJCQlpZiAocy0+ZG1hX2RhYzIuY291bnQgPD0gMCkgewoJCQkJcy0+Y3RybCAmPSB+Q1RSTF9EQUMyX0VOOwoJCQkJb3V0bChzLT5jdHJsLCBzLT5pbytFUzEzNzFfUkVHX0NPTlRST0wpOwoJCQkJcy0+ZG1hX2RhYzIuZXJyb3IrKzsKCQkJfSBlbHNlIGlmIChzLT5kbWFfZGFjMi5jb3VudCA8PSAoc2lnbmVkKXMtPmRtYV9kYWMyLmZyYWdzaXplICYmICFzLT5kbWFfZGFjMi5lbmRjbGVhcmVkKSB7CgkJCQljbGVhcl9hZHZhbmNlKHMtPmRtYV9kYWMyLnJhd2J1Ziwgcy0+ZG1hX2RhYzIuZG1hc2l6ZSwgcy0+ZG1hX2RhYzIuc3dwdHIsIAoJCQkJCSAgICAgIHMtPmRtYV9kYWMyLmZyYWdzaXplLCAocy0+c2N0cmwgJiBTQ1RSTF9QMlNFQikgPyAwIDogMHg4MCk7CgkJCQlzLT5kbWFfZGFjMi5lbmRjbGVhcmVkID0gMTsKCQkJfQoJCQlpZiAocy0+ZG1hX2RhYzIuY291bnQgKyAoc2lnbmVkKXMtPmRtYV9kYWMyLmZyYWdzaXplIDw9IChzaWduZWQpcy0+ZG1hX2RhYzIuZG1hc2l6ZSkKCQkJCXdha2VfdXAoJnMtPmRtYV9kYWMyLndhaXQpOwoJCX0KCX0KfQoKLyogaG9sZCBzcGlubG9jayBmb3IgdGhlIGZvbGxvd2luZyEgKi8Kc3RhdGljIHZvaWQgZXMxMzcxX2hhbmRsZV9taWRpKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMpCnsKCXVuc2lnbmVkIGNoYXIgY2g7CglpbnQgd2FrZTsKCglpZiAoIShzLT5jdHJsICYgQ1RSTF9VQVJUX0VOKSkKCQlyZXR1cm47Cgl3YWtlID0gMDsKCXdoaWxlIChpbmIocy0+aW8rRVMxMzcxX1JFR19VQVJUX1NUQVRVUykgJiBVU1RBVF9SWFJEWSkgewoJCWNoID0gaW5iKHMtPmlvK0VTMTM3MV9SRUdfVUFSVF9EQVRBKTsKCQlpZiAocy0+bWlkaS5pY250IDwgTUlESUlOQlVGKSB7CgkJCXMtPm1pZGkuaWJ1ZltzLT5taWRpLml3cl0gPSBjaDsKCQkJcy0+bWlkaS5pd3IgPSAocy0+bWlkaS5pd3IgKyAxKSAlIE1JRElJTkJVRjsKCQkJcy0+bWlkaS5pY250Kys7CgkJfQoJCXdha2UgPSAxOwoJfQoJaWYgKHdha2UpCgkJd2FrZV91cCgmcy0+bWlkaS5pd2FpdCk7Cgl3YWtlID0gMDsKCXdoaWxlICgoaW5iKHMtPmlvK0VTMTM3MV9SRUdfVUFSVF9TVEFUVVMpICYgVVNUQVRfVFhSRFkpICYmIHMtPm1pZGkub2NudCA+IDApIHsKCQlvdXRiKHMtPm1pZGkub2J1ZltzLT5taWRpLm9yZF0sIHMtPmlvK0VTMTM3MV9SRUdfVUFSVF9EQVRBKTsKCQlzLT5taWRpLm9yZCA9IChzLT5taWRpLm9yZCArIDEpICUgTUlESU9VVEJVRjsKCQlzLT5taWRpLm9jbnQtLTsKCQlpZiAocy0+bWlkaS5vY250IDwgTUlESU9VVEJVRi0xNikKCQkJd2FrZSA9IDE7Cgl9CglpZiAod2FrZSkKCQl3YWtlX3VwKCZzLT5taWRpLm93YWl0KTsKCW91dGIoKHMtPm1pZGkub2NudCA+IDApID8gVUNUUkxfUlhJTlRFTiB8IFVDVFJMX0VOQV9UWElOVCA6IFVDVFJMX1JYSU5URU4sIHMtPmlvK0VTMTM3MV9SRUdfVUFSVF9DT05UUk9MKTsKfQoKc3RhdGljIGlycXJldHVybl90IGVzMTM3MV9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewogICAgICAgIHN0cnVjdCBlczEzNzFfc3RhdGUgKnMgPSAoc3RydWN0IGVzMTM3MV9zdGF0ZSAqKWRldl9pZDsKCXVuc2lnbmVkIGludCBpbnRzcmMsIHNjdGw7CgkKCS8qIGZhc3RwYXRoIG91dCwgdG8gZWFzZSBpbnRlcnJ1cHQgc2hhcmluZyAqLwoJaW50c3JjID0gaW5sKHMtPmlvK0VTMTM3MV9SRUdfU1RBVFVTKTsKCWlmICghKGludHNyYyAmIDB4ODAwMDAwMDApKQoJCXJldHVybiBJUlFfTk9ORTsKCXNwaW5fbG9jaygmcy0+bG9jayk7CgkvKiBjbGVhciBhdWRpbyBpbnRlcnJ1cHRzIGZpcnN0ICovCglzY3RsID0gcy0+c2N0cmw7CglpZiAoaW50c3JjICYgU1RBVF9BREMpCgkJc2N0bCAmPSB+U0NUUkxfUjFJTlRFTjsKCWlmIChpbnRzcmMgJiBTVEFUX0RBQzEpCgkJc2N0bCAmPSB+U0NUUkxfUDFJTlRFTjsKCWlmIChpbnRzcmMgJiBTVEFUX0RBQzIpCgkJc2N0bCAmPSB+U0NUUkxfUDJJTlRFTjsKCW91dGwoc2N0bCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7CglvdXRsKHMtPnNjdHJsLCBzLT5pbytFUzEzNzFfUkVHX1NFUklBTF9DT05UUk9MKTsKCWVzMTM3MV91cGRhdGVfcHRyKHMpOwoJZXMxMzcxX2hhbmRsZV9taWRpKHMpOwoJc3Bpbl91bmxvY2soJnMtPmxvY2spOwoJcmV0dXJuIElSUV9IQU5ETEVEOwp9CgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCnN0YXRpYyBjb25zdCBjaGFyIGludmFsaWRfbWFnaWNbXSA9IEtFUk5fQ1JJVCBQRlggImludmFsaWQgbWFnaWMgdmFsdWVcbiI7CgojZGVmaW5lIFZBTElEQVRFX1NUQVRFKHMpICAgICAgICAgICAgICAgICAgICAgICAgIFwKKHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCglpZiAoIShzKSB8fCAocyktPm1hZ2ljICE9IEVTMTM3MV9NQUdJQykgeyBcCgkJcHJpbnRrKGludmFsaWRfbWFnaWMpOyAgICAgICAgICAgIFwKCQlyZXR1cm4gLUVOWElPOyAgICAgICAgICAgICAgICAgICAgXAoJfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAp9KQoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCgovKiBDb252ZXJzaW9uIHRhYmxlIGZvciBTL1BESUYgUENNIHZvbHVtZSBlbXVsYXRpb24gdGhyb3VnaCB0aGUgU1JDICovCi8qIGRCLWxpbmVhciB0YWJsZSBvZiBEQUMgdm9sIHZhbHVlczsgLTBkQiB0byAtNDYuNWRCIHdpdGggbXV0ZSAqLwpzdGF0aWMgY29uc3QgdW5zaWduZWQgc2hvcnQgREFDVm9sVGFibGVbMTAxXSA9CnsKCTB4MTAwMCwgMHgwZjJhLCAweDBlNjAsIDB4MGRhMCwgMHgwY2VhLCAweDBjM2UsIDB4MGI5YSwgMHgwYWZmLAoJMHgwYTZkLCAweDA5ZTEsIDB4MDk1ZSwgMHgwOGUxLCAweDA4NmEsIDB4MDdmYSwgMHgwNzhmLCAweDA3MmEsCgkweDA2Y2IsIDB4MDY3MCwgMHgwNjFhLCAweDA1YzksIDB4MDU3YiwgMHgwNTMyLCAweDA0ZWQsIDB4MDRhYiwKCTB4MDQ2ZCwgMHgwNDMyLCAweDAzZmEsIDB4MDNjNSwgMHgwMzkyLCAweDAzNjMsIDB4MDMzNSwgMHgwMzBiLAoJMHgwMmUyLCAweDAyYmMsIDB4MDI5NywgMHgwMjc1LCAweDAyNTQsIDB4MDIzNSwgMHgwMjE3LCAweDAxZmIsCgkweDAxZTEsIDB4MDFjOCwgMHgwMWIwLCAweDAxOTksIDB4MDE4NCwgMHgwMTcwLCAweDAxNWQsIDB4MDE0YiwKCTB4MDEzOSwgMHgwMTI5LCAweDAxMTksIDB4MDEwYiwgMHgwMGZkLCAweDAwZjAsIDB4MDBlMywgMHgwMGQ3LAoJMHgwMGNjLCAweDAwYzEsIDB4MDBiNywgMHgwMGFlLCAweDAwYTUsIDB4MDA5YywgMHgwMDk0LCAweDAwOGMsCgkweDAwODUsIDB4MDA3ZSwgMHgwMDc3LCAweDAwNzEsIDB4MDA2YiwgMHgwMDY2LCAweDAwNjAsIDB4MDA1YiwKCTB4MDA1NywgMHgwMDUyLCAweDAwNGUsIDB4MDA0YSwgMHgwMDQ2LCAweDAwNDIsIDB4MDAzZiwgMHgwMDNjLAoJMHgwMDM4LCAweDAwMzYsIDB4MDAzMywgMHgwMDMwLCAweDAwMmUsIDB4MDAyYiwgMHgwMDI5LCAweDAwMjcsCgkweDAwMjUsIDB4MDAyMywgMHgwMDIxLCAweDAwMWYsIDB4MDAxZSwgMHgwMDFjLCAweDAwMWIsIDB4MDAxOSwKCTB4MDAxOCwgMHgwMDE3LCAweDAwMTYsIDB4MDAxNCwgMHgwMDAwCn07CgovKgogKiB3aGVuIHdlIGFyZSBpbiBTL1BESUYgbW9kZSwgd2Ugd2FudCB0byBkaXNhYmxlIGFueSBhbmFsb2cgb3V0cHV0IHNvCiAqIHdlIGZpbHRlciB0aGUgbWl4ZXIgaW9jdGxzIAogKi8Kc3RhdGljIGludCBtaXhkZXZfaW9jdGwoc3RydWN0IGFjOTdfY29kZWMgKmNvZGVjLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopY29kZWMtPnByaXZhdGVfZGF0YTsKCWludCB2YWw7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgaW50IGxlZnQsIHJpZ2h0OwoKCVZBTElEQVRFX1NUQVRFKHMpOwoJLyogZmlsdGVyIG1peGVyIGlvY3RscyB0byBjYXRjaCBQQ00gYW5kIE1BU1RFUiB2b2x1bWUgd2hlbiBpbiBTL1BESUYgbW9kZSAqLwoJaWYgKHMtPnNwZGlmX3ZvbHVtZSA9PSAtMSkKCQlyZXR1cm4gY29kZWMtPm1peGVyX2lvY3RsKGNvZGVjLCBjbWQsIGFyZyk7Cglzd2l0Y2ggKGNtZCkgewoJY2FzZSBTT1VORF9NSVhFUl9XUklURV9WT0xVTUU6CgkJcmV0dXJuIDA7CgoJY2FzZSBTT1VORF9NSVhFUl9XUklURV9QQ006ICAgLyogdXNlIFNSQyBmb3IgUENNIHZvbHVtZSAqLwoJCWlmIChnZXRfdXNlcih2YWwsIChpbnQgX191c2VyICopYXJnKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJcmlnaHQgPSAoKHZhbCA+PiA4KSAgJiAweGZmKTsKCQlsZWZ0ID0gKHZhbCAgJiAweGZmKTsKCQlpZiAocmlnaHQgPiAxMDApCgkJCXJpZ2h0ID0gMTAwOwoJCWlmIChsZWZ0ID4gMTAwKQoJCQlsZWZ0ID0gMTAwOwoJCXMtPnNwZGlmX3ZvbHVtZSA9IChyaWdodCA8PCA4KSB8IGxlZnQ7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlzcmNfd3JpdGUocywgU1JDUkVHX1ZPTF9EQUMyLCBEQUNWb2xUYWJsZVsxMDAgLSBsZWZ0XSk7CgkJc3JjX3dyaXRlKHMsIFNSQ1JFR19WT0xfREFDMisxLCBEQUNWb2xUYWJsZVsxMDAgLSByaWdodF0pOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlyZXR1cm4gMDsKCQoJY2FzZSBTT1VORF9NSVhFUl9SRUFEX1BDTToKCQlyZXR1cm4gcHV0X3VzZXIocy0+c3BkaWZfdm9sdW1lLCAoaW50IF9fdXNlciAqKWFyZyk7Cgl9CglyZXR1cm4gY29kZWMtPm1peGVyX2lvY3RsKGNvZGVjLCBjbWQsIGFyZyk7Cn0KCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKLyoKICogQUM5NyBNaXhlciBSZWdpc3RlciB0byBDb25uZWN0aW9ucyBtYXBwaW5nIG9mIHRoZSBDb25jZXJ0IDk3IGJvYXJkCiAqCiAqIEFDOTdfTUFTVEVSX1ZPTF9TVEVSRU8gICBMaW5lIE91dAogKiBBQzk3X01BU1RFUl9WT0xfTU9OTyAgICAgVEFEIE91dHB1dAogKiBBQzk3X1BDQkVFUF9WT0wgICAgICAgICAgbm9uZQogKiBBQzk3X1BIT05FX1ZPTCAgICAgICAgICAgVEFEIElucHV0IChtb25vKQogKiBBQzk3X01JQ19WT0wgICAgICAgICAgICAgTUlDIElucHV0IChtb25vKQogKiBBQzk3X0xJTkVJTl9WT0wgICAgICAgICAgTGluZSBJbnB1dCAoc3RlcmVvKQogKiBBQzk3X0NEX1ZPTCAgICAgICAgICAgICAgQ0QgSW5wdXQgKHN0ZXJlbykKICogQUM5N19WSURFT19WT0wgICAgICAgICAgIG5vbmUKICogQUM5N19BVVhfVk9MICAgICAgICAgICAgIEF1eCBJbnB1dCAoc3RlcmVvKQogKiBBQzk3X1BDTU9VVF9WT0wgICAgICAgICAgV2F2ZSBPdXRwdXQgKHN0ZXJlbykKICovCgpzdGF0aWMgaW50IGVzMTM3MV9vcGVuX21peGRldihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJaW50IG1pbm9yID0gaW1pbm9yKGlub2RlKTsKCXN0cnVjdCBsaXN0X2hlYWQgKmxpc3Q7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzOwoKCWZvciAobGlzdCA9IGRldnMubmV4dDsgOyBsaXN0ID0gbGlzdC0+bmV4dCkgewoJCWlmIChsaXN0ID09ICZkZXZzKQoJCQlyZXR1cm4gLUVOT0RFVjsKCQlzID0gbGlzdF9lbnRyeShsaXN0LCBzdHJ1Y3QgZXMxMzcxX3N0YXRlLCBkZXZzKTsKCQlpZiAocy0+Y29kZWMtPmRldl9taXhlciA9PSBtaW5vcikKCQkJYnJlYWs7Cgl9CiAgICAgICAJVkFMSURBVEVfU1RBVEUocyk7CglmaWxlLT5wcml2YXRlX2RhdGEgPSBzOwoJcmV0dXJuIG5vbnNlZWthYmxlX29wZW4oaW5vZGUsIGZpbGUpOwp9CgpzdGF0aWMgaW50IGVzMTM3MV9yZWxlYXNlX21peGRldihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJCglWQUxJREFURV9TVEFURShzKTsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IGVzMTM3MV9pb2N0bF9taXhkZXYoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gKHN0cnVjdCBlczEzNzFfc3RhdGUgKilmaWxlLT5wcml2YXRlX2RhdGE7CglzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWMgPSBzLT5jb2RlYzsKCglyZXR1cm4gbWl4ZGV2X2lvY3RsKGNvZGVjLCBjbWQsIGFyZyk7Cn0KCnN0YXRpYyAvKmNvbnN0Ki8gc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBlczEzNzFfbWl4ZXJfZm9wcyA9IHsKCS5vd25lcgkJPSBUSElTX01PRFVMRSwKCS5sbHNlZWsJCT0gbm9fbGxzZWVrLAoJLmlvY3RsCQk9IGVzMTM3MV9pb2N0bF9taXhkZXYsCgkub3BlbgkJPSBlczEzNzFfb3Blbl9taXhkZXYsCgkucmVsZWFzZQk9IGVzMTM3MV9yZWxlYXNlX21peGRldiwKfTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIGludCBkcmFpbl9kYWMxKHN0cnVjdCBlczEzNzFfc3RhdGUgKnMsIGludCBub25ibG9jaykKewoJREVDTEFSRV9XQUlUUVVFVUUod2FpdCwgY3VycmVudCk7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJaW50IGNvdW50LCB0bW87CgkKCWlmIChzLT5kbWFfZGFjMS5tYXBwZWQgfHwgIXMtPmRtYV9kYWMxLnJlYWR5KQoJCXJldHVybiAwOwogICAgICAgIGFkZF93YWl0X3F1ZXVlKCZzLT5kbWFfZGFjMS53YWl0LCAmd2FpdCk7CiAgICAgICAgZm9yICg7OykgewoJCV9fc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19JTlRFUlJVUFRJQkxFKTsKICAgICAgICAgICAgICAgIHNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJY291bnQgPSBzLT5kbWFfZGFjMS5jb3VudDsKICAgICAgICAgICAgICAgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlpZiAoY291bnQgPD0gMCkKCQkJYnJlYWs7CgkJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKQogICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgICAgIGlmIChub25ibG9jaykgewogICAgICAgICAgICAgICAgICAgICAgICByZW1vdmVfd2FpdF9xdWV1ZSgmcy0+ZG1hX2RhYzEud2FpdCwgJndhaXQpOwogICAgICAgICAgICAgICAgICAgICAgICBzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwogICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gLUVCVVNZOwogICAgICAgICAgICAgICAgfQoJCXRtbyA9IDMgKiBIWiAqIChjb3VudCArIHMtPmRtYV9kYWMxLmZyYWdzaXplKSAvIDIgLyBzLT5kYWMxcmF0ZTsKCQl0bW8gPj49IHNhbXBsZV9zaGlmdFsocy0+c2N0cmwgJiBTQ1RSTF9QMUZNVCkgPj4gU0NUUkxfU0hfUDFGTVRdOwoJCWlmICghc2NoZWR1bGVfdGltZW91dCh0bW8gKyAxKSkKCQkJREJHKHByaW50ayhLRVJOX0RFQlVHIFBGWCAiZGFjMSBkbWEgdGltZWQgb3V0Pz9cbiIpOykKICAgICAgICB9CiAgICAgICAgcmVtb3ZlX3dhaXRfcXVldWUoJnMtPmRtYV9kYWMxLndhaXQsICZ3YWl0KTsKICAgICAgICBzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwogICAgICAgIGlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKICAgICAgICAgICAgICAgIHJldHVybiAtRVJFU1RBUlRTWVM7CiAgICAgICAgcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgZHJhaW5fZGFjMihzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzLCBpbnQgbm9uYmxvY2spCnsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWludCBjb3VudCwgdG1vOwoKCWlmIChzLT5kbWFfZGFjMi5tYXBwZWQgfHwgIXMtPmRtYV9kYWMyLnJlYWR5KQoJCXJldHVybiAwOwogICAgICAgIGFkZF93YWl0X3F1ZXVlKCZzLT5kbWFfZGFjMi53YWl0LCAmd2FpdCk7CiAgICAgICAgZm9yICg7OykgewoJCV9fc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19VTklOVEVSUlVQVElCTEUpOwogICAgICAgICAgICAgICAgc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQljb3VudCA9IHMtPmRtYV9kYWMyLmNvdW50OwogICAgICAgICAgICAgICAgc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCWlmIChjb3VudCA8PSAwKQoJCQlicmVhazsKCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCiAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICAgICAgaWYgKG5vbmJsb2NrKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIHJlbW92ZV93YWl0X3F1ZXVlKCZzLT5kbWFfZGFjMi53YWl0LCAmd2FpdCk7CiAgICAgICAgICAgICAgICAgICAgICAgIHNldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7CiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAtRUJVU1k7CiAgICAgICAgICAgICAgICB9CgkJdG1vID0gMyAqIEhaICogKGNvdW50ICsgcy0+ZG1hX2RhYzIuZnJhZ3NpemUpIC8gMiAvIHMtPmRhYzJyYXRlOwoJCXRtbyA+Pj0gc2FtcGxlX3NoaWZ0WyhzLT5zY3RybCAmIFNDVFJMX1AyRk1UKSA+PiBTQ1RSTF9TSF9QMkZNVF07CgkJaWYgKCFzY2hlZHVsZV90aW1lb3V0KHRtbyArIDEpKQoJCQlEQkcocHJpbnRrKEtFUk5fREVCVUcgUEZYICJkYWMyIGRtYSB0aW1lZCBvdXQ/P1xuIik7KQogICAgICAgIH0KICAgICAgICByZW1vdmVfd2FpdF9xdWV1ZSgmcy0+ZG1hX2RhYzIud2FpdCwgJndhaXQpOwogICAgICAgIHNldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7CiAgICAgICAgaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKQogICAgICAgICAgICAgICAgcmV0dXJuIC1FUkVTVEFSVFNZUzsKICAgICAgICByZXR1cm4gMDsKfQoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCgpzdGF0aWMgc3NpemVfdCBlczEzNzFfcmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCnsKCXN0cnVjdCBlczEzNzFfc3RhdGUgKnMgPSAoc3RydWN0IGVzMTM3MV9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJc3NpemVfdCByZXQgPSAwOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXVuc2lnbmVkIHN3cHRyOwoJaW50IGNudDsKCglWQUxJREFURV9TVEFURShzKTsKCWlmIChzLT5kbWFfYWRjLm1hcHBlZCkKCQlyZXR1cm4gLUVOWElPOwoJaWYgKCFhY2Nlc3Nfb2soVkVSSUZZX1dSSVRFLCBidWZmZXIsIGNvdW50KSkKCQlyZXR1cm4gLUVGQVVMVDsKCWRvd24oJnMtPnNlbSk7CglpZiAoIXMtPmRtYV9hZGMucmVhZHkgJiYgKHJldCA9IHByb2dfZG1hYnVmX2FkYyhzKSkpCgkJZ290byBvdXQyOwoJCglhZGRfd2FpdF9xdWV1ZSgmcy0+ZG1hX2FkYy53YWl0LCAmd2FpdCk7Cgl3aGlsZSAoY291bnQgPiAwKSB7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlzd3B0ciA9IHMtPmRtYV9hZGMuc3dwdHI7CgkJY250ID0gcy0+ZG1hX2FkYy5kbWFzaXplLXN3cHRyOwoJCWlmIChzLT5kbWFfYWRjLmNvdW50IDwgY250KQoJCQljbnQgPSBzLT5kbWFfYWRjLmNvdW50OwoJCWlmIChjbnQgPD0gMCkKCQkJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlpZiAoY250ID4gY291bnQpCgkJCWNudCA9IGNvdW50OwoJCWlmIChjbnQgPD0gMCkgewoJCQlpZiAocy0+ZG1hX2FkYy5lbmFibGVkKQoJCQkJc3RhcnRfYWRjKHMpOwoJCQlpZiAoZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spIHsKCQkJCWlmICghcmV0KQoJCQkJCXJldCA9IC1FQUdBSU47CgkJCQlnb3RvIG91dDsKCQkJfQoJCQl1cCgmcy0+c2VtKTsKCQkJc2NoZWR1bGUoKTsKCQkJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRVJFU1RBUlRTWVM7CgkJCQlnb3RvIG91dDI7CgkJCX0KCQkJZG93bigmcy0+c2VtKTsKCQkJaWYgKHMtPmRtYV9hZGMubWFwcGVkKQoJCQl7CgkJCQlyZXQgPSAtRU5YSU87CgkJCQlnb3RvIG91dDsKCQkJfQoJCQljb250aW51ZTsKCQl9CgkJaWYgKGNvcHlfdG9fdXNlcihidWZmZXIsIHMtPmRtYV9hZGMucmF3YnVmICsgc3dwdHIsIGNudCkpIHsKCQkJaWYgKCFyZXQpCgkJCQlyZXQgPSAtRUZBVUxUOwoJCQlnb3RvIG91dDsKCQl9CgkJc3dwdHIgPSAoc3dwdHIgKyBjbnQpICUgcy0+ZG1hX2FkYy5kbWFzaXplOwoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJcy0+ZG1hX2FkYy5zd3B0ciA9IHN3cHRyOwoJCXMtPmRtYV9hZGMuY291bnQgLT0gY250OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQljb3VudCAtPSBjbnQ7CgkJYnVmZmVyICs9IGNudDsKCQlyZXQgKz0gY250OwoJCWlmIChzLT5kbWFfYWRjLmVuYWJsZWQpCgkJCXN0YXJ0X2FkYyhzKTsKCX0Kb3V0OgoJdXAoJnMtPnNlbSk7Cm91dDI6CglyZW1vdmVfd2FpdF9xdWV1ZSgmcy0+ZG1hX2FkYy53YWl0LCAmd2FpdCk7CglzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwoJcmV0dXJuIHJldDsKfQoKc3RhdGljIHNzaXplX3QgZXMxMzcxX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqYnVmZmVyLCBzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcykKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJREVDTEFSRV9XQUlUUVVFVUUod2FpdCwgY3VycmVudCk7Cglzc2l6ZV90IHJldDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBzd3B0cjsKCWludCBjbnQ7CgoJVkFMSURBVEVfU1RBVEUocyk7CglpZiAocy0+ZG1hX2RhYzIubWFwcGVkKQoJCXJldHVybiAtRU5YSU87CglpZiAoIWFjY2Vzc19vayhWRVJJRllfUkVBRCwgYnVmZmVyLCBjb3VudCkpCgkJcmV0dXJuIC1FRkFVTFQ7Cglkb3duKCZzLT5zZW0pOwkKCWlmICghcy0+ZG1hX2RhYzIucmVhZHkgJiYgKHJldCA9IHByb2dfZG1hYnVmX2RhYzIocykpKQoJCWdvdG8gb3V0MzsKCXJldCA9IDA7CglhZGRfd2FpdF9xdWV1ZSgmcy0+ZG1hX2RhYzIud2FpdCwgJndhaXQpOwoJd2hpbGUgKGNvdW50ID4gMCkgewoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJaWYgKHMtPmRtYV9kYWMyLmNvdW50IDwgMCkgewoJCQlzLT5kbWFfZGFjMi5jb3VudCA9IDA7CgkJCXMtPmRtYV9kYWMyLnN3cHRyID0gcy0+ZG1hX2RhYzIuaHdwdHI7CgkJfQoJCXN3cHRyID0gcy0+ZG1hX2RhYzIuc3dwdHI7CgkJY250ID0gcy0+ZG1hX2RhYzIuZG1hc2l6ZS1zd3B0cjsKCQlpZiAocy0+ZG1hX2RhYzIuY291bnQgKyBjbnQgPiBzLT5kbWFfZGFjMi5kbWFzaXplKQoJCQljbnQgPSBzLT5kbWFfZGFjMi5kbWFzaXplIC0gcy0+ZG1hX2RhYzIuY291bnQ7CgkJaWYgKGNudCA8PSAwKQoJCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCWlmIChjbnQgPiBjb3VudCkKCQkJY250ID0gY291bnQ7CgkJaWYgKGNudCA8PSAwKSB7CgkJCWlmIChzLT5kbWFfZGFjMi5lbmFibGVkKQoJCQkJc3RhcnRfZGFjMihzKTsKCQkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRUFHQUlOOwoJCQkJZ290byBvdXQ7CgkJCX0JCgkJCXVwKCZzLT5zZW0pOwoJCQlzY2hlZHVsZSgpOwoJCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpIHsKCQkJCWlmICghcmV0KQoJCQkJCXJldCA9IC1FUkVTVEFSVFNZUzsKCQkJCWdvdG8gb3V0MjsKCQkJfQoJCQlkb3duKCZzLT5zZW0pOwoJCQlpZiAocy0+ZG1hX2RhYzIubWFwcGVkKQoJCQl7CgkJCQlyZXQgPSAtRU5YSU87CgkJCQlnb3RvIG91dDsKCQkJfQoJCQljb250aW51ZTsKCQl9CgkJaWYgKGNvcHlfZnJvbV91c2VyKHMtPmRtYV9kYWMyLnJhd2J1ZiArIHN3cHRyLCBidWZmZXIsIGNudCkpIHsKCQkJaWYgKCFyZXQpCgkJCQlyZXQgPSAtRUZBVUxUOwoJCQlnb3RvIG91dDsKCQl9CgkJc3dwdHIgPSAoc3dwdHIgKyBjbnQpICUgcy0+ZG1hX2RhYzIuZG1hc2l6ZTsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJCXMtPmRtYV9kYWMyLnN3cHRyID0gc3dwdHI7CgkJcy0+ZG1hX2RhYzIuY291bnQgKz0gY250OwoJCXMtPmRtYV9kYWMyLmVuZGNsZWFyZWQgPSAwOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQljb3VudCAtPSBjbnQ7CgkJYnVmZmVyICs9IGNudDsKCQlyZXQgKz0gY250OwoJCWlmIChzLT5kbWFfZGFjMi5lbmFibGVkKQoJCQlzdGFydF9kYWMyKHMpOwoJfQpvdXQ6Cgl1cCgmcy0+c2VtKTsKb3V0MjoKCXJlbW92ZV93YWl0X3F1ZXVlKCZzLT5kbWFfZGFjMi53YWl0LCAmd2FpdCk7Cm91dDM6CQoJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKTsKCXJldHVybiByZXQ7Cn0KCi8qIE5vIGtlcm5lbCBsb2NrIC0gd2UgaGF2ZSBvdXIgb3duIHNwaW5sb2NrICovCnN0YXRpYyB1bnNpZ25lZCBpbnQgZXMxMzcxX3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHN0cnVjdCBwb2xsX3RhYmxlX3N0cnVjdCAqd2FpdCkKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXVuc2lnbmVkIGludCBtYXNrID0gMDsKCglWQUxJREFURV9TVEFURShzKTsKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCWlmICghcy0+ZG1hX2RhYzIucmVhZHkgJiYgcHJvZ19kbWFidWZfZGFjMihzKSkKCQkJcmV0dXJuIDA7CgkJcG9sbF93YWl0KGZpbGUsICZzLT5kbWFfZGFjMi53YWl0LCB3YWl0KTsKCX0KCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJaWYgKCFzLT5kbWFfYWRjLnJlYWR5ICYmIHByb2dfZG1hYnVmX2FkYyhzKSkKCQkJcmV0dXJuIDA7CgkJcG9sbF93YWl0KGZpbGUsICZzLT5kbWFfYWRjLndhaXQsIHdhaXQpOwoJfQoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCWVzMTM3MV91cGRhdGVfcHRyKHMpOwoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkJaWYgKHMtPmRtYV9hZGMuY291bnQgPj0gKHNpZ25lZClzLT5kbWFfYWRjLmZyYWdzaXplKQoJCQkJbWFzayB8PSBQT0xMSU4gfCBQT0xMUkROT1JNOwoJfQoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJaWYgKHMtPmRtYV9kYWMyLm1hcHBlZCkgewoJCQlpZiAocy0+ZG1hX2RhYzIuY291bnQgPj0gKHNpZ25lZClzLT5kbWFfZGFjMi5mcmFnc2l6ZSkgCgkJCQltYXNrIHw9IFBPTExPVVQgfCBQT0xMV1JOT1JNOwoJCX0gZWxzZSB7CgkJCWlmICgoc2lnbmVkKXMtPmRtYV9kYWMyLmRtYXNpemUgPj0gcy0+ZG1hX2RhYzIuY291bnQgKyAoc2lnbmVkKXMtPmRtYV9kYWMyLmZyYWdzaXplKQoJCQkJbWFzayB8PSBQT0xMT1VUIHwgUE9MTFdSTk9STTsKCQl9Cgl9CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CglyZXR1cm4gbWFzazsKfQoKc3RhdGljIGludCBlczEzNzFfbW1hcChzdHJ1Y3QgZmlsZSAqZmlsZSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCnsKCXN0cnVjdCBlczEzNzFfc3RhdGUgKnMgPSAoc3RydWN0IGVzMTM3MV9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCXN0cnVjdCBkbWFidWYgKmRiOwoJaW50IHJldCA9IDA7Cgl1bnNpZ25lZCBsb25nIHNpemU7CgoJVkFMSURBVEVfU1RBVEUocyk7Cglsb2NrX2tlcm5lbCgpOwoJZG93bigmcy0+c2VtKTsKCQoJaWYgKHZtYS0+dm1fZmxhZ3MgJiBWTV9XUklURSkgewoJCWlmICgocmV0ID0gcHJvZ19kbWFidWZfZGFjMihzKSkgIT0gMCkgewoJCQlnb3RvIG91dDsKCQl9CgkJZGIgPSAmcy0+ZG1hX2RhYzI7Cgl9IGVsc2UgaWYgKHZtYS0+dm1fZmxhZ3MgJiBWTV9SRUFEKSB7CgkJaWYgKChyZXQgPSBwcm9nX2RtYWJ1Zl9hZGMocykpICE9IDApIHsKCQkJZ290byBvdXQ7CgkJfQoJCWRiID0gJnMtPmRtYV9hZGM7Cgl9IGVsc2UgewoJCXJldCA9IC1FSU5WQUw7CgkJZ290byBvdXQ7Cgl9CglpZiAodm1hLT52bV9wZ29mZiAhPSAwKSB7CgkJcmV0ID0gLUVJTlZBTDsKCQlnb3RvIG91dDsKCX0KCXNpemUgPSB2bWEtPnZtX2VuZCAtIHZtYS0+dm1fc3RhcnQ7CglpZiAoc2l6ZSA+IChQQUdFX1NJWkUgPDwgZGItPmJ1Zm9yZGVyKSkgewoJCXJldCA9IC1FSU5WQUw7CgkJZ290byBvdXQ7Cgl9CglpZiAocmVtYXBfcGZuX3JhbmdlKHZtYSwgdm1hLT52bV9zdGFydCwKCQkJCXZpcnRfdG9fcGh5cyhkYi0+cmF3YnVmKSA+PiBQQUdFX1NISUZULAoJCQkJc2l6ZSwgdm1hLT52bV9wYWdlX3Byb3QpKSB7CgkJcmV0ID0gLUVBR0FJTjsKCQlnb3RvIG91dDsKCX0KCWRiLT5tYXBwZWQgPSAxOwpvdXQ6Cgl1cCgmcy0+c2VtKTsKCXVubG9ja19rZXJuZWwoKTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgZXMxMzcxX2lvY3RsKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKICAgICAgICBhdWRpb19idWZfaW5mbyBhYmluZm87CiAgICAgICAgY291bnRfaW5mbyBjaW5mbzsKCWludCBjb3VudDsKCWludCB2YWwsIG1hcHBlZCwgcmV0OwoJdm9pZCBfX3VzZXIgKmFyZ3AgPSAodm9pZCBfX3VzZXIgKilhcmc7CglpbnQgX191c2VyICpwID0gYXJncDsKCglWQUxJREFURV9TVEFURShzKTsKICAgICAgICBtYXBwZWQgPSAoKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSAmJiBzLT5kbWFfZGFjMi5tYXBwZWQpIHx8CgkJKChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSAmJiBzLT5kbWFfYWRjLm1hcHBlZCk7Cglzd2l0Y2ggKGNtZCkgewoJY2FzZSBPU1NfR0VUVkVSU0lPTjoKCQlyZXR1cm4gcHV0X3VzZXIoU09VTkRfVkVSU0lPTiwgcCk7CgoJY2FzZSBTTkRDVExfRFNQX1NZTkM6CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKQoJCQlyZXR1cm4gZHJhaW5fZGFjMihzLCAwLypmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSyovKTsKCQlyZXR1cm4gMDsKCQkKCWNhc2UgU05EQ1RMX0RTUF9TRVREVVBMRVg6CgkJcmV0dXJuIDA7CgoJY2FzZSBTTkRDVExfRFNQX0dFVENBUFM6CgkJcmV0dXJuIHB1dF91c2VyKERTUF9DQVBfRFVQTEVYIHwgRFNQX0NBUF9SRUFMVElNRSB8IERTUF9DQVBfVFJJR0dFUiB8IERTUF9DQVBfTU1BUCwgcCk7CgkJCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX1JFU0VUOgoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCQlzdG9wX2RhYzIocyk7CgkJCXN5bmNocm9uaXplX2lycShzLT5pcnEpOwoJCQlzLT5kbWFfZGFjMi5zd3B0ciA9IHMtPmRtYV9kYWMyLmh3cHRyID0gcy0+ZG1hX2RhYzIuY291bnQgPSBzLT5kbWFfZGFjMi50b3RhbF9ieXRlcyA9IDA7CgkJfQoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCXN0b3BfYWRjKHMpOwoJCQlzeW5jaHJvbml6ZV9pcnEocy0+aXJxKTsKCQkJcy0+ZG1hX2FkYy5zd3B0ciA9IHMtPmRtYV9hZGMuaHdwdHIgPSBzLT5kbWFfYWRjLmNvdW50ID0gcy0+ZG1hX2FkYy50b3RhbF9ieXRlcyA9IDA7CgkJfQoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfU1BFRUQ6CiAgICAgICAgICAgICAgICBpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHZhbCA+PSAwKSB7CgkJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCQlzdG9wX2FkYyhzKTsKCQkJCXMtPmRtYV9hZGMucmVhZHkgPSAwOwoJCQkJc2V0X2FkY19yYXRlKHMsIHZhbCk7CgkJCX0KCQkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJCQlzdG9wX2RhYzIocyk7CgkJCQlzLT5kbWFfZGFjMi5yZWFkeSA9IDA7CgkJCQlzZXRfZGFjMl9yYXRlKHMsIHZhbCk7CgkJCX0KCQl9CgkJcmV0dXJuIHB1dF91c2VyKChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSA/IHMtPmFkY3JhdGUgOiBzLT5kYWMycmF0ZSwgcCk7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9TVEVSRU86CgkJaWYgKGdldF91c2VyKHZhbCwgcCkpCgkJCXJldHVybiAtRUZBVUxUOwoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCXN0b3BfYWRjKHMpOwoJCQlzLT5kbWFfYWRjLnJlYWR5ID0gMDsKCQkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQkJaWYgKHZhbCkKCQkJCXMtPnNjdHJsIHw9IFNDVFJMX1IxU01COwoJCQllbHNlCgkJCQlzLT5zY3RybCAmPSB+U0NUUkxfUjFTTUI7CgkJCW91dGwocy0+c2N0cmwsIHMtPmlvK0VTMTM3MV9SRUdfU0VSSUFMX0NPTlRST0wpOwoJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CgkJfQoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCQlzdG9wX2RhYzIocyk7CgkJCXMtPmRtYV9kYWMyLnJlYWR5ID0gMDsKCQkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQkJaWYgKHZhbCkKCQkJCXMtPnNjdHJsIHw9IFNDVFJMX1AyU01COwoJCQllbHNlCgkJCQlzLT5zY3RybCAmPSB+U0NUUkxfUDJTTUI7CgkJCW91dGwocy0+c2N0cmwsIHMtPmlvK0VTMTM3MV9SRUdfU0VSSUFMX0NPTlRST0wpOwoJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CiAgICAgICAgICAgICAgICB9CgkJcmV0dXJuIDA7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9DSEFOTkVMUzoKICAgICAgICAgICAgICAgIGlmIChnZXRfdXNlcih2YWwsIHApKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlpZiAodmFsICE9IDApIHsKCQkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkJCXN0b3BfYWRjKHMpOwoJCQkJcy0+ZG1hX2FkYy5yZWFkeSA9IDA7CgkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJCQkJaWYgKHZhbCA+PSAyKQoJCQkJCXMtPnNjdHJsIHw9IFNDVFJMX1IxU01COwoJCQkJZWxzZQoJCQkJCXMtPnNjdHJsICY9IH5TQ1RSTF9SMVNNQjsKCQkJCW91dGwocy0+c2N0cmwsIHMtPmlvK0VTMTM3MV9SRUdfU0VSSUFMX0NPTlRST0wpOwoJCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCQl9CgkJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCQkJc3RvcF9kYWMyKHMpOwoJCQkJcy0+ZG1hX2RhYzIucmVhZHkgPSAwOwoJCQkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQkJCWlmICh2YWwgPj0gMikKCQkJCQlzLT5zY3RybCB8PSBTQ1RSTF9QMlNNQjsKCQkJCWVsc2UKCQkJCQlzLT5zY3RybCAmPSB+U0NUUkxfUDJTTUI7CgkJCQlvdXRsKHMtPnNjdHJsLCBzLT5pbytFUzEzNzFfUkVHX1NFUklBTF9DT05UUk9MKTsKCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQkJfQoJCX0KCQlyZXR1cm4gcHV0X3VzZXIoKHMtPnNjdHJsICYgKChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSA/IFNDVFJMX1IxU01CIDogU0NUUkxfUDJTTUIpKSA/IDIgOiAxLCBwKTsKCQkKCWNhc2UgU05EQ1RMX0RTUF9HRVRGTVRTOiAvKiBSZXR1cm5zIGEgbWFzayAqLwogICAgICAgICAgICAgICAgcmV0dXJuIHB1dF91c2VyKEFGTVRfUzE2X0xFfEFGTVRfVTgsIHApOwoJCQoJY2FzZSBTTkRDVExfRFNQX1NFVEZNVDogLyogU2VsZWN0cyBPTkUgZm10Ki8KCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHZhbCAhPSBBRk1UX1FVRVJZKSB7CgkJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCQlzdG9wX2FkYyhzKTsKCQkJCXMtPmRtYV9hZGMucmVhZHkgPSAwOwoJCQkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQkJCWlmICh2YWwgPT0gQUZNVF9TMTZfTEUpCgkJCQkJcy0+c2N0cmwgfD0gU0NUUkxfUjFTRUI7CgkJCQllbHNlCgkJCQkJcy0+c2N0cmwgJj0gflNDVFJMX1IxU0VCOwoJCQkJb3V0bChzLT5zY3RybCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7CgkJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CgkJCX0KCQkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJCQlzdG9wX2RhYzIocyk7CgkJCQlzLT5kbWFfZGFjMi5yZWFkeSA9IDA7CgkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJCQkJaWYgKHZhbCA9PSBBRk1UX1MxNl9MRSkKCQkJCQlzLT5zY3RybCB8PSBTQ1RSTF9QMlNFQjsKCQkJCWVsc2UKCQkJCQlzLT5zY3RybCAmPSB+U0NUUkxfUDJTRUI7CgkJCQlvdXRsKHMtPnNjdHJsLCBzLT5pbytFUzEzNzFfUkVHX1NFUklBTF9DT05UUk9MKTsKCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQkJfQoJCX0KCQlyZXR1cm4gcHV0X3VzZXIoKHMtPnNjdHJsICYgKChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSA/IFNDVFJMX1IxU0VCIDogU0NUUkxfUDJTRUIpKSA/IAoJCQkJQUZNVF9TMTZfTEUgOiBBRk1UX1U4LCBwKTsKCQkKCWNhc2UgU05EQ1RMX0RTUF9QT1NUOgogICAgICAgICAgICAgICAgcmV0dXJuIDA7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9HRVRUUklHR0VSOgoJCXZhbCA9IDA7CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQgJiYgcy0+Y3RybCAmIENUUkxfQURDX0VOKSAKCQkJdmFsIHw9IFBDTV9FTkFCTEVfSU5QVVQ7CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFICYmIHMtPmN0cmwgJiBDVFJMX0RBQzJfRU4pIAoJCQl2YWwgfD0gUENNX0VOQUJMRV9PVVRQVVQ7CgkJcmV0dXJuIHB1dF91c2VyKHZhbCwgcCk7CgkJCgljYXNlIFNORENUTF9EU1BfU0VUVFJJR0dFUjoKCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkJaWYgKHZhbCAmIFBDTV9FTkFCTEVfSU5QVVQpIHsKCQkJCWlmICghcy0+ZG1hX2FkYy5yZWFkeSAmJiAocmV0ID0gcHJvZ19kbWFidWZfYWRjKHMpKSkKCQkJCQlyZXR1cm4gcmV0OwoJCQkJcy0+ZG1hX2FkYy5lbmFibGVkID0gMTsKCQkJCXN0YXJ0X2FkYyhzKTsKCQkJfSBlbHNlIHsKCQkJCXMtPmRtYV9hZGMuZW5hYmxlZCA9IDA7CgkJCQlzdG9wX2FkYyhzKTsKCQkJfQoJCX0KCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQkJaWYgKHZhbCAmIFBDTV9FTkFCTEVfT1VUUFVUKSB7CgkJCQlpZiAoIXMtPmRtYV9kYWMyLnJlYWR5ICYmIChyZXQgPSBwcm9nX2RtYWJ1Zl9kYWMyKHMpKSkKCQkJCQlyZXR1cm4gcmV0OwoJCQkJcy0+ZG1hX2RhYzIuZW5hYmxlZCA9IDE7CgkJCQlzdGFydF9kYWMyKHMpOwoJCQl9IGVsc2UgewoJCQkJcy0+ZG1hX2RhYzIuZW5hYmxlZCA9IDA7CgkJCQlzdG9wX2RhYzIocyk7CgkJCX0KCQl9CgkJcmV0dXJuIDA7CgoJY2FzZSBTTkRDVExfRFNQX0dFVE9TUEFDRToKCQlpZiAoIShmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmICghcy0+ZG1hX2RhYzIucmVhZHkgJiYgKHZhbCA9IHByb2dfZG1hYnVmX2RhYzIocykpICE9IDApCgkJCXJldHVybiB2YWw7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQllczEzNzFfdXBkYXRlX3B0cihzKTsKCQlhYmluZm8uZnJhZ3NpemUgPSBzLT5kbWFfZGFjMi5mcmFnc2l6ZTsKCQljb3VudCA9IHMtPmRtYV9kYWMyLmNvdW50OwoJCWlmIChjb3VudCA8IDApCgkJCWNvdW50ID0gMDsKICAgICAgICAgICAgICAgIGFiaW5mby5ieXRlcyA9IHMtPmRtYV9kYWMyLmRtYXNpemUgLSBjb3VudDsKICAgICAgICAgICAgICAgIGFiaW5mby5mcmFnc3RvdGFsID0gcy0+ZG1hX2RhYzIubnVtZnJhZzsKICAgICAgICAgICAgICAgIGFiaW5mby5mcmFnbWVudHMgPSBhYmluZm8uYnl0ZXMgPj4gcy0+ZG1hX2RhYzIuZnJhZ3NoaWZ0OyAgICAgIAoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlyZXR1cm4gY29weV90b191c2VyKGFyZ3AsICZhYmluZm8sIHNpemVvZihhYmluZm8pKSA/IC1FRkFVTFQgOiAwOwoKCWNhc2UgU05EQ1RMX0RTUF9HRVRJU1BBQ0U6CgkJaWYgKCEoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmICghcy0+ZG1hX2FkYy5yZWFkeSAmJiAodmFsID0gcHJvZ19kbWFidWZfYWRjKHMpKSAhPSAwKQoJCQlyZXR1cm4gdmFsOwoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJZXMxMzcxX3VwZGF0ZV9wdHIocyk7CgkJYWJpbmZvLmZyYWdzaXplID0gcy0+ZG1hX2FkYy5mcmFnc2l6ZTsKCQljb3VudCA9IHMtPmRtYV9hZGMuY291bnQ7CgkJaWYgKGNvdW50IDwgMCkKCQkJY291bnQgPSAwOwogICAgICAgICAgICAgICAgYWJpbmZvLmJ5dGVzID0gY291bnQ7CiAgICAgICAgICAgICAgICBhYmluZm8uZnJhZ3N0b3RhbCA9IHMtPmRtYV9hZGMubnVtZnJhZzsKICAgICAgICAgICAgICAgIGFiaW5mby5mcmFnbWVudHMgPSBhYmluZm8uYnl0ZXMgPj4gcy0+ZG1hX2FkYy5mcmFnc2hpZnQ7ICAgICAgCgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCXJldHVybiBjb3B5X3RvX3VzZXIoYXJncCwgJmFiaW5mbywgc2l6ZW9mKGFiaW5mbykpID8gLUVGQVVMVCA6IDA7CgkJCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX05PTkJMT0NLOgogICAgICAgICAgICAgICAgZmlsZS0+Zl9mbGFncyB8PSBPX05PTkJMT0NLOwogICAgICAgICAgICAgICAgcmV0dXJuIDA7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9HRVRPREVMQVk6CgkJaWYgKCEoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpKQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoIXMtPmRtYV9kYWMyLnJlYWR5ICYmICh2YWwgPSBwcm9nX2RtYWJ1Zl9kYWMyKHMpKSAhPSAwKQoJCQlyZXR1cm4gdmFsOwoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJZXMxMzcxX3VwZGF0ZV9wdHIocyk7CiAgICAgICAgICAgICAgICBjb3VudCA9IHMtPmRtYV9kYWMyLmNvdW50OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlpZiAoY291bnQgPCAwKQoJCQljb3VudCA9IDA7CgkJcmV0dXJuIHB1dF91c2VyKGNvdW50LCBwKTsKCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX0dFVElQVFI6CgkJaWYgKCEoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmICghcy0+ZG1hX2FkYy5yZWFkeSAmJiAodmFsID0gcHJvZ19kbWFidWZfYWRjKHMpKSAhPSAwKQoJCQlyZXR1cm4gdmFsOwoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJZXMxMzcxX3VwZGF0ZV9wdHIocyk7CiAgICAgICAgICAgICAgICBjaW5mby5ieXRlcyA9IHMtPmRtYV9hZGMudG90YWxfYnl0ZXM7CgkJY291bnQgPSBzLT5kbWFfYWRjLmNvdW50OwoJCWlmIChjb3VudCA8IDApCgkJCWNvdW50ID0gMDsKICAgICAgICAgICAgICAgIGNpbmZvLmJsb2NrcyA9IGNvdW50ID4+IHMtPmRtYV9hZGMuZnJhZ3NoaWZ0OwogICAgICAgICAgICAgICAgY2luZm8ucHRyID0gcy0+ZG1hX2FkYy5od3B0cjsKCQlpZiAocy0+ZG1hX2FkYy5tYXBwZWQpCgkJCXMtPmRtYV9hZGMuY291bnQgJj0gcy0+ZG1hX2FkYy5mcmFnc2l6ZS0xOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZjaW5mbywgc2l6ZW9mKGNpbmZvKSkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfR0VUT1BUUjoKCQlpZiAoIShmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkpCgkJCXJldHVybiAtRUlOVkFMOwoJCWlmICghcy0+ZG1hX2RhYzIucmVhZHkgJiYgKHZhbCA9IHByb2dfZG1hYnVmX2RhYzIocykpICE9IDApCgkJCXJldHVybiB2YWw7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQllczEzNzFfdXBkYXRlX3B0cihzKTsKICAgICAgICAgICAgICAgIGNpbmZvLmJ5dGVzID0gcy0+ZG1hX2RhYzIudG90YWxfYnl0ZXM7CgkJY291bnQgPSBzLT5kbWFfZGFjMi5jb3VudDsKCQlpZiAoY291bnQgPCAwKQoJCQljb3VudCA9IDA7CiAgICAgICAgICAgICAgICBjaW5mby5ibG9ja3MgPSBjb3VudCA+PiBzLT5kbWFfZGFjMi5mcmFnc2hpZnQ7CiAgICAgICAgICAgICAgICBjaW5mby5wdHIgPSBzLT5kbWFfZGFjMi5od3B0cjsKCQlpZiAocy0+ZG1hX2RhYzIubWFwcGVkKQoJCQlzLT5kbWFfZGFjMi5jb3VudCAmPSBzLT5kbWFfZGFjMi5mcmFnc2l6ZS0xOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZjaW5mbywgc2l6ZW9mKGNpbmZvKSkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfR0VUQkxLU0laRToKCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQkJaWYgKCh2YWwgPSBwcm9nX2RtYWJ1Zl9kYWMyKHMpKSkKCQkJCXJldHVybiB2YWw7CgkJCXJldHVybiBwdXRfdXNlcihzLT5kbWFfZGFjMi5mcmFnc2l6ZSwgcCk7CgkJfQoJCWlmICgodmFsID0gcHJvZ19kbWFidWZfYWRjKHMpKSkKCQkJcmV0dXJuIHZhbDsKCQlyZXR1cm4gcHV0X3VzZXIocy0+ZG1hX2FkYy5mcmFnc2l6ZSwgcCk7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9TRVRGUkFHTUVOVDoKICAgICAgICAgICAgICAgIGlmIChnZXRfdXNlcih2YWwsIHApKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgewoJCQlzLT5kbWFfYWRjLm9zc2ZyYWdzaGlmdCA9IHZhbCAmIDB4ZmZmZjsKCQkJcy0+ZG1hX2FkYy5vc3NtYXhmcmFncyA9ICh2YWwgPj4gMTYpICYgMHhmZmZmOwoJCQlpZiAocy0+ZG1hX2FkYy5vc3NmcmFnc2hpZnQgPCA0KQoJCQkJcy0+ZG1hX2FkYy5vc3NmcmFnc2hpZnQgPSA0OwoJCQlpZiAocy0+ZG1hX2FkYy5vc3NmcmFnc2hpZnQgPiAxNSkKCQkJCXMtPmRtYV9hZGMub3NzZnJhZ3NoaWZ0ID0gMTU7CgkJCWlmIChzLT5kbWFfYWRjLm9zc21heGZyYWdzIDwgNCkKCQkJCXMtPmRtYV9hZGMub3NzbWF4ZnJhZ3MgPSA0OwoJCX0KCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQkJcy0+ZG1hX2RhYzIub3NzZnJhZ3NoaWZ0ID0gdmFsICYgMHhmZmZmOwoJCQlzLT5kbWFfZGFjMi5vc3NtYXhmcmFncyA9ICh2YWwgPj4gMTYpICYgMHhmZmZmOwoJCQlpZiAocy0+ZG1hX2RhYzIub3NzZnJhZ3NoaWZ0IDwgNCkKCQkJCXMtPmRtYV9kYWMyLm9zc2ZyYWdzaGlmdCA9IDQ7CgkJCWlmIChzLT5kbWFfZGFjMi5vc3NmcmFnc2hpZnQgPiAxNSkKCQkJCXMtPmRtYV9kYWMyLm9zc2ZyYWdzaGlmdCA9IDE1OwoJCQlpZiAocy0+ZG1hX2RhYzIub3NzbWF4ZnJhZ3MgPCA0KQoJCQkJcy0+ZG1hX2RhYzIub3NzbWF4ZnJhZ3MgPSA0OwoJCX0KCQlyZXR1cm4gMDsKCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX1NVQkRJVklERToKCQlpZiAoKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQgJiYgcy0+ZG1hX2FkYy5zdWJkaXZpc2lvbikgfHwKCQkgICAgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFICYmIHMtPmRtYV9kYWMyLnN1YmRpdmlzaW9uKSkKCQkJcmV0dXJuIC1FSU5WQUw7CiAgICAgICAgICAgICAgICBpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHZhbCAhPSAxICYmIHZhbCAhPSAyICYmIHZhbCAhPSA0KQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkKCQkJcy0+ZG1hX2FkYy5zdWJkaXZpc2lvbiA9IHZhbDsKCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpCgkJCXMtPmRtYV9kYWMyLnN1YmRpdmlzaW9uID0gdmFsOwoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNPVU5EX1BDTV9SRUFEX1JBVEU6CgkJcmV0dXJuIHB1dF91c2VyKChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSA/IHMtPmFkY3JhdGUgOiBzLT5kYWMycmF0ZSwgcCk7CgogICAgICAgIGNhc2UgU09VTkRfUENNX1JFQURfQ0hBTk5FTFM6CgkJcmV0dXJuIHB1dF91c2VyKChzLT5zY3RybCAmICgoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgPyBTQ1RSTF9SMVNNQiA6IFNDVFJMX1AyU01CKSkgPyAyIDogMSwgcCk7CgkJCiAgICAgICAgY2FzZSBTT1VORF9QQ01fUkVBRF9CSVRTOgoJCXJldHVybiBwdXRfdXNlcigocy0+c2N0cmwgJiAoKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpID8gU0NUUkxfUjFTRUIgOiBTQ1RSTF9QMlNFQikpID8gMTYgOiA4LCBwKTsKCiAgICAgICAgY2FzZSBTT1VORF9QQ01fV1JJVEVfRklMVEVSOgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9TRVRTWU5DUk86CiAgICAgICAgY2FzZSBTT1VORF9QQ01fUkVBRF9GSUxURVI6CiAgICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKCQkKCX0KCXJldHVybiBtaXhkZXZfaW9jdGwocy0+Y29kZWMsIGNtZCwgYXJnKTsKfQoKc3RhdGljIGludCBlczEzNzFfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJaW50IG1pbm9yID0gaW1pbm9yKGlub2RlKTsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXN0cnVjdCBsaXN0X2hlYWQgKmxpc3Q7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzOwoKCWZvciAobGlzdCA9IGRldnMubmV4dDsgOyBsaXN0ID0gbGlzdC0+bmV4dCkgewoJCWlmIChsaXN0ID09ICZkZXZzKQoJCQlyZXR1cm4gLUVOT0RFVjsKCQlzID0gbGlzdF9lbnRyeShsaXN0LCBzdHJ1Y3QgZXMxMzcxX3N0YXRlLCBkZXZzKTsKCQlpZiAoISgocy0+ZGV2X2F1ZGlvIF4gbWlub3IpICYgfjB4ZikpCgkJCWJyZWFrOwoJfQogICAgICAgCVZBTElEQVRFX1NUQVRFKHMpOwoJZmlsZS0+cHJpdmF0ZV9kYXRhID0gczsKCS8qIHdhaXQgZm9yIGRldmljZSB0byBiZWNvbWUgZnJlZSAqLwoJZG93bigmcy0+b3Blbl9zZW0pOwoJd2hpbGUgKHMtPm9wZW5fbW9kZSAmIGZpbGUtPmZfbW9kZSkgewoJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykgewoJCQl1cCgmcy0+b3Blbl9zZW0pOwoJCQlyZXR1cm4gLUVCVVNZOwoJCX0KCQlhZGRfd2FpdF9xdWV1ZSgmcy0+b3Blbl93YWl0LCAmd2FpdCk7CgkJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOwoJCXVwKCZzLT5vcGVuX3NlbSk7CgkJc2NoZWR1bGUoKTsKCQlyZW1vdmVfd2FpdF9xdWV1ZSgmcy0+b3Blbl93YWl0LCAmd2FpdCk7CgkJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKTsKCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCgkJCXJldHVybiAtRVJFU1RBUlRTWVM7CgkJZG93bigmcy0+b3Blbl9zZW0pOwoJfQoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQlzLT5kbWFfYWRjLm9zc2ZyYWdzaGlmdCA9IHMtPmRtYV9hZGMub3NzbWF4ZnJhZ3MgPSBzLT5kbWFfYWRjLnN1YmRpdmlzaW9uID0gMDsKCQlzLT5kbWFfYWRjLmVuYWJsZWQgPSAxOwoJCXNldF9hZGNfcmF0ZShzLCA4MDAwKTsKCX0KCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCXMtPmRtYV9kYWMyLm9zc2ZyYWdzaGlmdCA9IHMtPmRtYV9kYWMyLm9zc21heGZyYWdzID0gcy0+ZG1hX2RhYzIuc3ViZGl2aXNpb24gPSAwOwoJCXMtPmRtYV9kYWMyLmVuYWJsZWQgPSAxOwoJCXNldF9kYWMyX3JhdGUocywgODAwMCk7Cgl9CglzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQlzLT5zY3RybCAmPSB+U0NUUkxfUjFGTVQ7CgkJaWYgKChtaW5vciAmIDB4ZikgPT0gU05EX0RFVl9EU1AxNikKCQkJcy0+c2N0cmwgfD0gRVMxMzcxX0ZNVF9TMTZfTU9OTyA8PCBTQ1RSTF9TSF9SMUZNVDsKCQllbHNlCgkJCXMtPnNjdHJsIHw9IEVTMTM3MV9GTVRfVThfTU9OTyA8PCBTQ1RSTF9TSF9SMUZNVDsKCX0KCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCXMtPnNjdHJsICY9IH5TQ1RSTF9QMkZNVDsKCQlpZiAoKG1pbm9yICYgMHhmKSA9PSBTTkRfREVWX0RTUDE2KQoJCQlzLT5zY3RybCB8PSBFUzEzNzFfRk1UX1MxNl9NT05PIDw8IFNDVFJMX1NIX1AyRk1UOwoJCWVsc2UKCQkJcy0+c2N0cmwgfD0gRVMxMzcxX0ZNVF9VOF9NT05PIDw8IFNDVFJMX1NIX1AyRk1UOwoJfQoJb3V0bChzLT5zY3RybCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CglzLT5vcGVuX21vZGUgfD0gZmlsZS0+Zl9tb2RlICYgKEZNT0RFX1JFQUQgfCBGTU9ERV9XUklURSk7Cgl1cCgmcy0+b3Blbl9zZW0pOwoJaW5pdF9NVVRFWCgmcy0+c2VtKTsKCXJldHVybiBub25zZWVrYWJsZV9vcGVuKGlub2RlLCBmaWxlKTsKfQoKc3RhdGljIGludCBlczEzNzFfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoKCVZBTElEQVRFX1NUQVRFKHMpOwoJbG9ja19rZXJuZWwoKTsKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkKCQlkcmFpbl9kYWMyKHMsIGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKTsKCWRvd24oJnMtPm9wZW5fc2VtKTsKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCXN0b3BfZGFjMihzKTsKCQlkZWFsbG9jX2RtYWJ1ZihzLCAmcy0+ZG1hX2RhYzIpOwoJfQoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQlzdG9wX2FkYyhzKTsKCQlkZWFsbG9jX2RtYWJ1ZihzLCAmcy0+ZG1hX2FkYyk7Cgl9CglzLT5vcGVuX21vZGUgJj0gfihmaWxlLT5mX21vZGUgJiAoRk1PREVfUkVBRHxGTU9ERV9XUklURSkpOwoJdXAoJnMtPm9wZW5fc2VtKTsKCXdha2VfdXAoJnMtPm9wZW5fd2FpdCk7Cgl1bmxvY2tfa2VybmVsKCk7CglyZXR1cm4gMDsKfQoKc3RhdGljIC8qY29uc3QqLyBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGVzMTM3MV9hdWRpb19mb3BzID0gewoJLm93bmVyCQk9IFRISVNfTU9EVUxFLAoJLmxsc2VlawkJPSBub19sbHNlZWssCgkucmVhZAkJPSBlczEzNzFfcmVhZCwKCS53cml0ZQkJPSBlczEzNzFfd3JpdGUsCgkucG9sbAkJPSBlczEzNzFfcG9sbCwKCS5pb2N0bAkJPSBlczEzNzFfaW9jdGwsCgkubW1hcAkJPSBlczEzNzFfbW1hcCwKCS5vcGVuCQk9IGVzMTM3MV9vcGVuLAoJLnJlbGVhc2UJPSBlczEzNzFfcmVsZWFzZSwKfTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIHNzaXplX3QgZXMxMzcxX3dyaXRlX2RhYyhzdHJ1Y3QgZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCnsKCXN0cnVjdCBlczEzNzFfc3RhdGUgKnMgPSAoc3RydWN0IGVzMTM3MV9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJc3NpemVfdCByZXQgPSAwOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXVuc2lnbmVkIHN3cHRyOwoJaW50IGNudDsKCglWQUxJREFURV9TVEFURShzKTsKCWlmIChzLT5kbWFfZGFjMS5tYXBwZWQpCgkJcmV0dXJuIC1FTlhJTzsKCWlmICghcy0+ZG1hX2RhYzEucmVhZHkgJiYgKHJldCA9IHByb2dfZG1hYnVmX2RhYzEocykpKQoJCXJldHVybiByZXQ7CglpZiAoIWFjY2Vzc19vayhWRVJJRllfUkVBRCwgYnVmZmVyLCBjb3VudCkpCgkJcmV0dXJuIC1FRkFVTFQ7CglhZGRfd2FpdF9xdWV1ZSgmcy0+ZG1hX2RhYzEud2FpdCwgJndhaXQpOwoJd2hpbGUgKGNvdW50ID4gMCkgewoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJaWYgKHMtPmRtYV9kYWMxLmNvdW50IDwgMCkgewoJCQlzLT5kbWFfZGFjMS5jb3VudCA9IDA7CgkJCXMtPmRtYV9kYWMxLnN3cHRyID0gcy0+ZG1hX2RhYzEuaHdwdHI7CgkJfQoJCXN3cHRyID0gcy0+ZG1hX2RhYzEuc3dwdHI7CgkJY250ID0gcy0+ZG1hX2RhYzEuZG1hc2l6ZS1zd3B0cjsKCQlpZiAocy0+ZG1hX2RhYzEuY291bnQgKyBjbnQgPiBzLT5kbWFfZGFjMS5kbWFzaXplKQoJCQljbnQgPSBzLT5kbWFfZGFjMS5kbWFzaXplIC0gcy0+ZG1hX2RhYzEuY291bnQ7CgkJaWYgKGNudCA8PSAwKQoJCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCWlmIChjbnQgPiBjb3VudCkKCQkJY250ID0gY291bnQ7CgkJaWYgKGNudCA8PSAwKSB7CgkJCWlmIChzLT5kbWFfZGFjMS5lbmFibGVkKQoJCQkJc3RhcnRfZGFjMShzKTsKCQkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRUFHQUlOOwoJCQkJYnJlYWs7CgkJCX0KCQkJc2NoZWR1bGUoKTsKCQkJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRVJFU1RBUlRTWVM7CgkJCQlicmVhazsKCQkJfQoJCQljb250aW51ZTsKCQl9CgkJaWYgKGNvcHlfZnJvbV91c2VyKHMtPmRtYV9kYWMxLnJhd2J1ZiArIHN3cHRyLCBidWZmZXIsIGNudCkpIHsKCQkJaWYgKCFyZXQpCgkJCQlyZXQgPSAtRUZBVUxUOwoJCQlicmVhazsKCQl9CgkJc3dwdHIgPSAoc3dwdHIgKyBjbnQpICUgcy0+ZG1hX2RhYzEuZG1hc2l6ZTsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJCXMtPmRtYV9kYWMxLnN3cHRyID0gc3dwdHI7CgkJcy0+ZG1hX2RhYzEuY291bnQgKz0gY250OwoJCXMtPmRtYV9kYWMxLmVuZGNsZWFyZWQgPSAwOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQljb3VudCAtPSBjbnQ7CgkJYnVmZmVyICs9IGNudDsKCQlyZXQgKz0gY250OwoJCWlmIChzLT5kbWFfZGFjMS5lbmFibGVkKQoJCQlzdGFydF9kYWMxKHMpOwoJfQoJcmVtb3ZlX3dhaXRfcXVldWUoJnMtPmRtYV9kYWMxLndhaXQsICZ3YWl0KTsKCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7CglyZXR1cm4gcmV0Owp9CgovKiBObyBrZXJuZWwgbG9jayAtIHdlIGhhdmUgb3VyIG93biBzcGlubG9jayAqLwpzdGF0aWMgdW5zaWduZWQgaW50IGVzMTM3MV9wb2xsX2RhYyhzdHJ1Y3QgZmlsZSAqZmlsZSwgc3RydWN0IHBvbGxfdGFibGVfc3RydWN0ICp3YWl0KQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gKHN0cnVjdCBlczEzNzFfc3RhdGUgKilmaWxlLT5wcml2YXRlX2RhdGE7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgaW50IG1hc2sgPSAwOwoKCVZBTElEQVRFX1NUQVRFKHMpOwoJaWYgKCFzLT5kbWFfZGFjMS5yZWFkeSAmJiBwcm9nX2RtYWJ1Zl9kYWMxKHMpKQoJCXJldHVybiAwOwoJcG9sbF93YWl0KGZpbGUsICZzLT5kbWFfZGFjMS53YWl0LCB3YWl0KTsKCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgllczEzNzFfdXBkYXRlX3B0cihzKTsKCWlmIChzLT5kbWFfZGFjMS5tYXBwZWQpIHsKCQlpZiAocy0+ZG1hX2RhYzEuY291bnQgPj0gKHNpZ25lZClzLT5kbWFfZGFjMS5mcmFnc2l6ZSkKCQkJbWFzayB8PSBQT0xMT1VUIHwgUE9MTFdSTk9STTsKCX0gZWxzZSB7CgkJaWYgKChzaWduZWQpcy0+ZG1hX2RhYzEuZG1hc2l6ZSA+PSBzLT5kbWFfZGFjMS5jb3VudCArIChzaWduZWQpcy0+ZG1hX2RhYzEuZnJhZ3NpemUpCgkJCW1hc2sgfD0gUE9MTE9VVCB8IFBPTExXUk5PUk07Cgl9CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CglyZXR1cm4gbWFzazsKfQoKc3RhdGljIGludCBlczEzNzFfbW1hcF9kYWMoc3RydWN0IGZpbGUgKmZpbGUsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gKHN0cnVjdCBlczEzNzFfc3RhdGUgKilmaWxlLT5wcml2YXRlX2RhdGE7CglpbnQgcmV0OwoJdW5zaWduZWQgbG9uZyBzaXplOwoKCVZBTElEQVRFX1NUQVRFKHMpOwoJaWYgKCEodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKSkKCQlyZXR1cm4gLUVJTlZBTDsKCWxvY2tfa2VybmVsKCk7CglpZiAoKHJldCA9IHByb2dfZG1hYnVmX2RhYzEocykpICE9IDApCgkJZ290byBvdXQ7CglyZXQgPSAtRUlOVkFMOwoJaWYgKHZtYS0+dm1fcGdvZmYgIT0gMCkKCQlnb3RvIG91dDsKCXNpemUgPSB2bWEtPnZtX2VuZCAtIHZtYS0+dm1fc3RhcnQ7CglpZiAoc2l6ZSA+IChQQUdFX1NJWkUgPDwgcy0+ZG1hX2RhYzEuYnVmb3JkZXIpKQoJCWdvdG8gb3V0OwoJcmV0ID0gLUVBR0FJTjsKCWlmIChyZW1hcF9wZm5fcmFuZ2Uodm1hLCB2bWEtPnZtX3N0YXJ0LAoJCQl2aXJ0X3RvX3BoeXMocy0+ZG1hX2RhYzEucmF3YnVmKSA+PiBQQUdFX1NISUZULAoJCQlzaXplLCB2bWEtPnZtX3BhZ2VfcHJvdCkpCgkJZ290byBvdXQ7CglzLT5kbWFfZGFjMS5tYXBwZWQgPSAxOwoJcmV0ID0gMDsKb3V0OgoJdW5sb2NrX2tlcm5lbCgpOwoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGludCBlczEzNzFfaW9jdGxfZGFjKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKICAgICAgICBhdWRpb19idWZfaW5mbyBhYmluZm87CiAgICAgICAgY291bnRfaW5mbyBjaW5mbzsKCWludCBjb3VudDsKCWludCB2YWwsIHJldDsKCWludCBfX3VzZXIgKnAgPSAoaW50IF9fdXNlciAqKWFyZzsKCglWQUxJREFURV9TVEFURShzKTsKCXN3aXRjaCAoY21kKSB7CgljYXNlIE9TU19HRVRWRVJTSU9OOgoJCXJldHVybiBwdXRfdXNlcihTT1VORF9WRVJTSU9OLCBwKTsKCgljYXNlIFNORENUTF9EU1BfU1lOQzoKCQlyZXR1cm4gZHJhaW5fZGFjMShzLCAwLypmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSyovKTsKCQkKCWNhc2UgU05EQ1RMX0RTUF9TRVREVVBMRVg6CgkJcmV0dXJuIC1FSU5WQUw7CgoJY2FzZSBTTkRDVExfRFNQX0dFVENBUFM6CgkJcmV0dXJuIHB1dF91c2VyKERTUF9DQVBfUkVBTFRJTUUgfCBEU1BfQ0FQX1RSSUdHRVIgfCBEU1BfQ0FQX01NQVAsIHApOwoJCQogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9SRVNFVDoKCQlzdG9wX2RhYzEocyk7CgkJc3luY2hyb25pemVfaXJxKHMtPmlycSk7CgkJcy0+ZG1hX2RhYzEuc3dwdHIgPSBzLT5kbWFfZGFjMS5od3B0ciA9IHMtPmRtYV9kYWMxLmNvdW50ID0gcy0+ZG1hX2RhYzEudG90YWxfYnl0ZXMgPSAwOwoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfU1BFRUQ6CiAgICAgICAgICAgICAgICBpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHZhbCA+PSAwKSB7CgkJCXN0b3BfZGFjMShzKTsKCQkJcy0+ZG1hX2RhYzEucmVhZHkgPSAwOwoJCQlzZXRfZGFjMV9yYXRlKHMsIHZhbCk7CgkJfQoJCXJldHVybiBwdXRfdXNlcihzLT5kYWMxcmF0ZSwgcCk7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9TVEVSRU86CgkJaWYgKGdldF91c2VyKHZhbCwgcCkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXN0b3BfZGFjMShzKTsKCQlzLT5kbWFfZGFjMS5yZWFkeSA9IDA7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlpZiAodmFsKQoJCQlzLT5zY3RybCB8PSBTQ1RSTF9QMVNNQjsKCQllbHNlCgkJCXMtPnNjdHJsICY9IH5TQ1RSTF9QMVNNQjsKCQlvdXRsKHMtPnNjdHJsLCBzLT5pbytFUzEzNzFfUkVHX1NFUklBTF9DT05UUk9MKTsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CgkJcmV0dXJuIDA7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9DSEFOTkVMUzoKICAgICAgICAgICAgICAgIGlmIChnZXRfdXNlcih2YWwsIHApKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlpZiAodmFsICE9IDApIHsKCQkJc3RvcF9kYWMxKHMpOwoJCQlzLT5kbWFfZGFjMS5yZWFkeSA9IDA7CgkJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJCWlmICh2YWwgPj0gMikKCQkJCXMtPnNjdHJsIHw9IFNDVFJMX1AxU01COwoJCQllbHNlCgkJCQlzLT5zY3RybCAmPSB+U0NUUkxfUDFTTUI7CgkJCW91dGwocy0+c2N0cmwsIHMtPmlvK0VTMTM3MV9SRUdfU0VSSUFMX0NPTlRST0wpOwoJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CgkJfQoJCXJldHVybiBwdXRfdXNlcigocy0+c2N0cmwgJiBTQ1RSTF9QMVNNQikgPyAyIDogMSwgcCk7CgkJCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX0dFVEZNVFM6IC8qIFJldHVybnMgYSBtYXNrICovCiAgICAgICAgICAgICAgICByZXR1cm4gcHV0X3VzZXIoQUZNVF9TMTZfTEV8QUZNVF9VOCwgcCk7CgkJCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX1NFVEZNVDogLyogU2VsZWN0cyBPTkUgZm10Ki8KCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHZhbCAhPSBBRk1UX1FVRVJZKSB7CgkJCXN0b3BfZGFjMShzKTsKCQkJcy0+ZG1hX2RhYzEucmVhZHkgPSAwOwoJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJCQlpZiAodmFsID09IEFGTVRfUzE2X0xFKQoJCQkJcy0+c2N0cmwgfD0gU0NUUkxfUDFTRUI7CgkJCWVsc2UKCQkJCXMtPnNjdHJsICY9IH5TQ1RSTF9QMVNFQjsKCQkJb3V0bChzLT5zY3RybCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7CgkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQl9CgkJcmV0dXJuIHB1dF91c2VyKChzLT5zY3RybCAmIFNDVFJMX1AxU0VCKSA/IEFGTVRfUzE2X0xFIDogQUZNVF9VOCwgcCk7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9QT1NUOgogICAgICAgICAgICAgICAgcmV0dXJuIDA7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9HRVRUUklHR0VSOgoJCXJldHVybiBwdXRfdXNlcigocy0+Y3RybCAmIENUUkxfREFDMV9FTikgPyBQQ01fRU5BQkxFX09VVFBVVCA6IDAsIHApOwoJCQkJCQkKCWNhc2UgU05EQ1RMX0RTUF9TRVRUUklHR0VSOgoJCWlmIChnZXRfdXNlcih2YWwsIHApKQoJCQlyZXR1cm4gLUVGQVVMVDsKCQlpZiAodmFsICYgUENNX0VOQUJMRV9PVVRQVVQpIHsKCQkJaWYgKCFzLT5kbWFfZGFjMS5yZWFkeSAmJiAocmV0ID0gcHJvZ19kbWFidWZfZGFjMShzKSkpCgkJCQlyZXR1cm4gcmV0OwoJCQlzLT5kbWFfZGFjMS5lbmFibGVkID0gMTsKCQkJc3RhcnRfZGFjMShzKTsKCQl9IGVsc2UgewoJCQlzLT5kbWFfZGFjMS5lbmFibGVkID0gMDsKCQkJc3RvcF9kYWMxKHMpOwoJCX0KCQlyZXR1cm4gMDsKCgljYXNlIFNORENUTF9EU1BfR0VUT1NQQUNFOgoJCWlmICghcy0+ZG1hX2RhYzEucmVhZHkgJiYgKHZhbCA9IHByb2dfZG1hYnVmX2RhYzEocykpICE9IDApCgkJCXJldHVybiB2YWw7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQllczEzNzFfdXBkYXRlX3B0cihzKTsKCQlhYmluZm8uZnJhZ3NpemUgPSBzLT5kbWFfZGFjMS5mcmFnc2l6ZTsKCQljb3VudCA9IHMtPmRtYV9kYWMxLmNvdW50OwoJCWlmIChjb3VudCA8IDApCgkJCWNvdW50ID0gMDsKICAgICAgICAgICAgICAgIGFiaW5mby5ieXRlcyA9IHMtPmRtYV9kYWMxLmRtYXNpemUgLSBjb3VudDsKICAgICAgICAgICAgICAgIGFiaW5mby5mcmFnc3RvdGFsID0gcy0+ZG1hX2RhYzEubnVtZnJhZzsKICAgICAgICAgICAgICAgIGFiaW5mby5mcmFnbWVudHMgPSBhYmluZm8uYnl0ZXMgPj4gcy0+ZG1hX2RhYzEuZnJhZ3NoaWZ0OyAgICAgIAoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlyZXR1cm4gY29weV90b191c2VyKCh2b2lkIF9fdXNlciAqKWFyZywgJmFiaW5mbywgc2l6ZW9mKGFiaW5mbykpID8gLUVGQVVMVCA6IDA7CgogICAgICAgIGNhc2UgU05EQ1RMX0RTUF9OT05CTE9DSzoKICAgICAgICAgICAgICAgIGZpbGUtPmZfZmxhZ3MgfD0gT19OT05CTE9DSzsKICAgICAgICAgICAgICAgIHJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfR0VUT0RFTEFZOgoJCWlmICghcy0+ZG1hX2RhYzEucmVhZHkgJiYgKHZhbCA9IHByb2dfZG1hYnVmX2RhYzEocykpICE9IDApCgkJCXJldHVybiB2YWw7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQllczEzNzFfdXBkYXRlX3B0cihzKTsKICAgICAgICAgICAgICAgIGNvdW50ID0gcy0+ZG1hX2RhYzEuY291bnQ7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCWlmIChjb3VudCA8IDApCgkJCWNvdW50ID0gMDsKCQlyZXR1cm4gcHV0X3VzZXIoY291bnQsIHApOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfR0VUT1BUUjoKCQlpZiAoIXMtPmRtYV9kYWMxLnJlYWR5ICYmICh2YWwgPSBwcm9nX2RtYWJ1Zl9kYWMxKHMpKSAhPSAwKQoJCQlyZXR1cm4gdmFsOwoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJZXMxMzcxX3VwZGF0ZV9wdHIocyk7CiAgICAgICAgICAgICAgICBjaW5mby5ieXRlcyA9IHMtPmRtYV9kYWMxLnRvdGFsX2J5dGVzOwoJCWNvdW50ID0gcy0+ZG1hX2RhYzEuY291bnQ7CgkJaWYgKGNvdW50IDwgMCkKCQkJY291bnQgPSAwOwogICAgICAgICAgICAgICAgY2luZm8uYmxvY2tzID0gY291bnQgPj4gcy0+ZG1hX2RhYzEuZnJhZ3NoaWZ0OwogICAgICAgICAgICAgICAgY2luZm8ucHRyID0gcy0+ZG1hX2RhYzEuaHdwdHI7CgkJaWYgKHMtPmRtYV9kYWMxLm1hcHBlZCkKCQkJcy0+ZG1hX2RhYzEuY291bnQgJj0gcy0+ZG1hX2RhYzEuZnJhZ3NpemUtMTsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CgkJaWYgKGNvcHlfdG9fdXNlcigodm9pZCBfX3VzZXIgKilhcmcsICZjaW5mbywgc2l6ZW9mKGNpbmZvKSkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfR0VUQkxLU0laRToKCQlpZiAoKHZhbCA9IHByb2dfZG1hYnVmX2RhYzEocykpKQoJCQlyZXR1cm4gdmFsOwogICAgICAgICAgICAgICAgcmV0dXJuIHB1dF91c2VyKHMtPmRtYV9kYWMxLmZyYWdzaXplLCBwKTsKCiAgICAgICAgY2FzZSBTTkRDVExfRFNQX1NFVEZSQUdNRU5UOgogICAgICAgICAgICAgICAgaWYgKGdldF91c2VyKHZhbCwgcCkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXMtPmRtYV9kYWMxLm9zc2ZyYWdzaGlmdCA9IHZhbCAmIDB4ZmZmZjsKCQlzLT5kbWFfZGFjMS5vc3NtYXhmcmFncyA9ICh2YWwgPj4gMTYpICYgMHhmZmZmOwoJCWlmIChzLT5kbWFfZGFjMS5vc3NmcmFnc2hpZnQgPCA0KQoJCQlzLT5kbWFfZGFjMS5vc3NmcmFnc2hpZnQgPSA0OwoJCWlmIChzLT5kbWFfZGFjMS5vc3NmcmFnc2hpZnQgPiAxNSkKCQkJcy0+ZG1hX2RhYzEub3NzZnJhZ3NoaWZ0ID0gMTU7CgkJaWYgKHMtPmRtYV9kYWMxLm9zc21heGZyYWdzIDwgNCkKCQkJcy0+ZG1hX2RhYzEub3NzbWF4ZnJhZ3MgPSA0OwoJCXJldHVybiAwOwoKICAgICAgICBjYXNlIFNORENUTF9EU1BfU1VCRElWSURFOgoJCWlmIChzLT5kbWFfZGFjMS5zdWJkaXZpc2lvbikKCQkJcmV0dXJuIC1FSU5WQUw7CiAgICAgICAgICAgICAgICBpZiAoZ2V0X3VzZXIodmFsLCBwKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHZhbCAhPSAxICYmIHZhbCAhPSAyICYmIHZhbCAhPSA0KQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlzLT5kbWFfZGFjMS5zdWJkaXZpc2lvbiA9IHZhbDsKCQlyZXR1cm4gMDsKCiAgICAgICAgY2FzZSBTT1VORF9QQ01fUkVBRF9SQVRFOgoJCXJldHVybiBwdXRfdXNlcihzLT5kYWMxcmF0ZSwgcCk7CgogICAgICAgIGNhc2UgU09VTkRfUENNX1JFQURfQ0hBTk5FTFM6CgkJcmV0dXJuIHB1dF91c2VyKChzLT5zY3RybCAmIFNDVFJMX1AxU01CKSA/IDIgOiAxLCBwKTsKCiAgICAgICAgY2FzZSBTT1VORF9QQ01fUkVBRF9CSVRTOgoJCXJldHVybiBwdXRfdXNlcigocy0+c2N0cmwgJiBTQ1RSTF9QMVNFQikgPyAxNiA6IDgsIHApOwoKICAgICAgICBjYXNlIFNPVU5EX1BDTV9XUklURV9GSUxURVI6CiAgICAgICAgY2FzZSBTTkRDVExfRFNQX1NFVFNZTkNSTzoKICAgICAgICBjYXNlIFNPVU5EX1BDTV9SRUFEX0ZJTFRFUjoKICAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwoJCQoJfQoJcmV0dXJuIG1peGRldl9pb2N0bChzLT5jb2RlYywgY21kLCBhcmcpOwp9CgpzdGF0aWMgaW50IGVzMTM3MV9vcGVuX2RhYyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJaW50IG1pbm9yID0gaW1pbm9yKGlub2RlKTsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXN0cnVjdCBsaXN0X2hlYWQgKmxpc3Q7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzOwoKCWZvciAobGlzdCA9IGRldnMubmV4dDsgOyBsaXN0ID0gbGlzdC0+bmV4dCkgewoJCWlmIChsaXN0ID09ICZkZXZzKQoJCQlyZXR1cm4gLUVOT0RFVjsKCQlzID0gbGlzdF9lbnRyeShsaXN0LCBzdHJ1Y3QgZXMxMzcxX3N0YXRlLCBkZXZzKTsKCQlpZiAoISgocy0+ZGV2X2RhYyBeIG1pbm9yKSAmIH4weGYpKQoJCQlicmVhazsKCX0KICAgICAgIAlWQUxJREFURV9TVEFURShzKTsKICAgICAgIAkvKiB3ZSBhbGxvdyBvcGVuaW5nIHdpdGggT19SRFdSLCBtb3N0IHByb2dyYW1zIGRvIGl0IGFsdGhvdWdoIHRoZXkgd2lsbCBvbmx5IHdyaXRlICovCiNpZiAwCglpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkKCQlyZXR1cm4gLUVQRVJNOwojZW5kaWYKCWlmICghKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSkKCQlyZXR1cm4gLUVJTlZBTDsKICAgICAgIAlmaWxlLT5wcml2YXRlX2RhdGEgPSBzOwoJLyogd2FpdCBmb3IgZGV2aWNlIHRvIGJlY29tZSBmcmVlICovCglkb3duKCZzLT5vcGVuX3NlbSk7Cgl3aGlsZSAocy0+b3Blbl9tb2RlICYgRk1PREVfREFDKSB7CgkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKSB7CgkJCXVwKCZzLT5vcGVuX3NlbSk7CgkJCXJldHVybiAtRUJVU1k7CgkJfQoJCWFkZF93YWl0X3F1ZXVlKCZzLT5vcGVuX3dhaXQsICZ3YWl0KTsKCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJdXAoJnMtPm9wZW5fc2VtKTsKCQlzY2hlZHVsZSgpOwoJCXJlbW92ZV93YWl0X3F1ZXVlKCZzLT5vcGVuX3dhaXQsICZ3YWl0KTsKCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwoJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKCQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKCQlkb3duKCZzLT5vcGVuX3NlbSk7Cgl9CglzLT5kbWFfZGFjMS5vc3NmcmFnc2hpZnQgPSBzLT5kbWFfZGFjMS5vc3NtYXhmcmFncyA9IHMtPmRtYV9kYWMxLnN1YmRpdmlzaW9uID0gMDsKCXMtPmRtYV9kYWMxLmVuYWJsZWQgPSAxOwoJc2V0X2RhYzFfcmF0ZShzLCA4MDAwKTsKCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CglzLT5zY3RybCAmPSB+U0NUUkxfUDFGTVQ7CglpZiAoKG1pbm9yICYgMHhmKSA9PSBTTkRfREVWX0RTUDE2KQoJCXMtPnNjdHJsIHw9IEVTMTM3MV9GTVRfUzE2X01PTk8gPDwgU0NUUkxfU0hfUDFGTVQ7CgllbHNlCgkJcy0+c2N0cmwgfD0gRVMxMzcxX0ZNVF9VOF9NT05PIDw8IFNDVFJMX1NIX1AxRk1UOwoJb3V0bChzLT5zY3RybCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CglzLT5vcGVuX21vZGUgfD0gRk1PREVfREFDOwoJdXAoJnMtPm9wZW5fc2VtKTsKCXJldHVybiBub25zZWVrYWJsZV9vcGVuKGlub2RlLCBmaWxlKTsKfQoKc3RhdGljIGludCBlczEzNzFfcmVsZWFzZV9kYWMoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCXN0cnVjdCBlczEzNzFfc3RhdGUgKnMgPSAoc3RydWN0IGVzMTM3MV9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCglWQUxJREFURV9TVEFURShzKTsKCWxvY2tfa2VybmVsKCk7CglkcmFpbl9kYWMxKHMsIGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKTsKCWRvd24oJnMtPm9wZW5fc2VtKTsKCXN0b3BfZGFjMShzKTsKCWRlYWxsb2NfZG1hYnVmKHMsICZzLT5kbWFfZGFjMSk7CglzLT5vcGVuX21vZGUgJj0gfkZNT0RFX0RBQzsKCXVwKCZzLT5vcGVuX3NlbSk7Cgl3YWtlX3VwKCZzLT5vcGVuX3dhaXQpOwoJdW5sb2NrX2tlcm5lbCgpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyAvKmNvbnN0Ki8gc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBlczEzNzFfZGFjX2ZvcHMgPSB7Cgkub3duZXIJCT0gVEhJU19NT0RVTEUsCgkubGxzZWVrCQk9IG5vX2xsc2VlaywKCS53cml0ZQkJPSBlczEzNzFfd3JpdGVfZGFjLAoJLnBvbGwJCT0gZXMxMzcxX3BvbGxfZGFjLAoJLmlvY3RsCQk9IGVzMTM3MV9pb2N0bF9kYWMsCgkubW1hcAkJPSBlczEzNzFfbW1hcF9kYWMsCgkub3BlbgkJPSBlczEzNzFfb3Blbl9kYWMsCgkucmVsZWFzZQk9IGVzMTM3MV9yZWxlYXNlX2RhYywKfTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIHNzaXplX3QgZXMxMzcxX21pZGlfcmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCnsKCXN0cnVjdCBlczEzNzFfc3RhdGUgKnMgPSAoc3RydWN0IGVzMTM3MV9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJc3NpemVfdCByZXQ7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgcHRyOwoJaW50IGNudDsKCglWQUxJREFURV9TVEFURShzKTsKCWlmICghYWNjZXNzX29rKFZFUklGWV9XUklURSwgYnVmZmVyLCBjb3VudCkpCgkJcmV0dXJuIC1FRkFVTFQ7CglpZiAoY291bnQgPT0gMCkKCQlyZXR1cm4gMDsKCXJldCA9IDA7CiAgICAgICAgYWRkX3dhaXRfcXVldWUoJnMtPm1pZGkuaXdhaXQsICZ3YWl0KTsKCXdoaWxlIChjb3VudCA+IDApIHsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJCXB0ciA9IHMtPm1pZGkuaXJkOwoJCWNudCA9IE1JRElJTkJVRiAtIHB0cjsKCQlpZiAocy0+bWlkaS5pY250IDwgY250KQoJCQljbnQgPSBzLT5taWRpLmljbnQ7CgkJaWYgKGNudCA8PSAwKQoJCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCWlmIChjbnQgPiBjb3VudCkKCQkJY250ID0gY291bnQ7CgkJaWYgKGNudCA8PSAwKSB7CgkJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykgewoJCQkJaWYgKCFyZXQpCgkJCQkJcmV0ID0gLUVBR0FJTjsKCQkJCWJyZWFrOwoJCQl9CgkJCXNjaGVkdWxlKCk7CgkJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgewoJCQkJaWYgKCFyZXQpCgkJCQkJcmV0ID0gLUVSRVNUQVJUU1lTOwoJCQkJYnJlYWs7CgkJCX0KCQkJY29udGludWU7CgkJfQoJCWlmIChjb3B5X3RvX3VzZXIoYnVmZmVyLCBzLT5taWRpLmlidWYgKyBwdHIsIGNudCkpIHsKCQkJaWYgKCFyZXQpCgkJCQlyZXQgPSAtRUZBVUxUOwoJCQlicmVhazsKCQl9CgkJcHRyID0gKHB0ciArIGNudCkgJSBNSURJSU5CVUY7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlzLT5taWRpLmlyZCA9IHB0cjsKCQlzLT5taWRpLmljbnQgLT0gY250OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQljb3VudCAtPSBjbnQ7CgkJYnVmZmVyICs9IGNudDsKCQlyZXQgKz0gY250OwoJCWJyZWFrOwoJfQoJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwoJcmVtb3ZlX3dhaXRfcXVldWUoJnMtPm1pZGkuaXdhaXQsICZ3YWl0KTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBzc2l6ZV90IGVzMTM3MV9taWRpX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqYnVmZmVyLCBzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcykKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJREVDTEFSRV9XQUlUUVVFVUUod2FpdCwgY3VycmVudCk7Cglzc2l6ZV90IHJldDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBwdHI7CglpbnQgY250OwoKCVZBTElEQVRFX1NUQVRFKHMpOwoJaWYgKCFhY2Nlc3Nfb2soVkVSSUZZX1JFQUQsIGJ1ZmZlciwgY291bnQpKQoJCXJldHVybiAtRUZBVUxUOwoJaWYgKGNvdW50ID09IDApCgkJcmV0dXJuIDA7CglyZXQgPSAwOwogICAgICAgIGFkZF93YWl0X3F1ZXVlKCZzLT5taWRpLm93YWl0LCAmd2FpdCk7Cgl3aGlsZSAoY291bnQgPiAwKSB7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlwdHIgPSBzLT5taWRpLm93cjsKCQljbnQgPSBNSURJT1VUQlVGIC0gcHRyOwoJCWlmIChzLT5taWRpLm9jbnQgKyBjbnQgPiBNSURJT1VUQlVGKQoJCQljbnQgPSBNSURJT1VUQlVGIC0gcy0+bWlkaS5vY250OwoJCWlmIChjbnQgPD0gMCkgewoJCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJCWVzMTM3MV9oYW5kbGVfbWlkaShzKTsKCQl9CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJCWlmIChjbnQgPiBjb3VudCkKCQkJY250ID0gY291bnQ7CgkJaWYgKGNudCA8PSAwKSB7CgkJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykgewoJCQkJaWYgKCFyZXQpCgkJCQkJcmV0ID0gLUVBR0FJTjsKCQkJCWJyZWFrOwoJCQl9CgkJCXNjaGVkdWxlKCk7CgkJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgewoJCQkJaWYgKCFyZXQpCgkJCQkJcmV0ID0gLUVSRVNUQVJUU1lTOwoJCQkJYnJlYWs7CgkJCX0KCQkJY29udGludWU7CgkJfQoJCWlmIChjb3B5X2Zyb21fdXNlcihzLT5taWRpLm9idWYgKyBwdHIsIGJ1ZmZlciwgY250KSkgewoJCQlpZiAoIXJldCkKCQkJCXJldCA9IC1FRkFVTFQ7CgkJCWJyZWFrOwoJCX0KCQlwdHIgPSAocHRyICsgY250KSAlIE1JRElPVVRCVUY7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCQlzLT5taWRpLm93ciA9IHB0cjsKCQlzLT5taWRpLm9jbnQgKz0gY250OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCQljb3VudCAtPSBjbnQ7CgkJYnVmZmVyICs9IGNudDsKCQlyZXQgKz0gY250OwoJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJZXMxMzcxX2hhbmRsZV9taWRpKHMpOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCX0KCV9fc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKTsKCXJlbW92ZV93YWl0X3F1ZXVlKCZzLT5taWRpLm93YWl0LCAmd2FpdCk7CglyZXR1cm4gcmV0Owp9CgovKiBObyBrZXJuZWwgbG9jayAtIHdlIGhhdmUgb3VyIG93biBzcGlubG9jayAqLwpzdGF0aWMgdW5zaWduZWQgaW50IGVzMTM3MV9taWRpX3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHN0cnVjdCBwb2xsX3RhYmxlX3N0cnVjdCAqd2FpdCkKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqcyA9IChzdHJ1Y3QgZXMxMzcxX3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXVuc2lnbmVkIGludCBtYXNrID0gMDsKCglWQUxJREFURV9TVEFURShzKTsKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkKCQlwb2xsX3dhaXQoZmlsZSwgJnMtPm1pZGkub3dhaXQsIHdhaXQpOwoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpCgkJcG9sbF93YWl0KGZpbGUsICZzLT5taWRpLml3YWl0LCB3YWl0KTsKCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CglpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgewoJCWlmIChzLT5taWRpLmljbnQgPiAwKQoJCQltYXNrIHw9IFBPTExJTiB8IFBPTExSRE5PUk07Cgl9CglpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQlpZiAocy0+bWlkaS5vY250IDwgTUlESU9VVEJVRikKCQkJbWFzayB8PSBQT0xMT1VUIHwgUE9MTFdSTk9STTsKCX0KCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCXJldHVybiBtYXNrOwp9CgpzdGF0aWMgaW50IGVzMTM3MV9taWRpX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCWludCBtaW5vciA9IGltaW5vcihpbm9kZSk7CglERUNMQVJFX1dBSVRRVUVVRSh3YWl0LCBjdXJyZW50KTsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0OwoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqczsKCglmb3IgKGxpc3QgPSBkZXZzLm5leHQ7IDsgbGlzdCA9IGxpc3QtPm5leHQpIHsKCQlpZiAobGlzdCA9PSAmZGV2cykKCQkJcmV0dXJuIC1FTk9ERVY7CgkJcyA9IGxpc3RfZW50cnkobGlzdCwgc3RydWN0IGVzMTM3MV9zdGF0ZSwgZGV2cyk7CgkJaWYgKHMtPmRldl9taWRpID09IG1pbm9yKQoJCQlicmVhazsKCX0KICAgICAgIAlWQUxJREFURV9TVEFURShzKTsKCWZpbGUtPnByaXZhdGVfZGF0YSA9IHM7CgkvKiB3YWl0IGZvciBkZXZpY2UgdG8gYmVjb21lIGZyZWUgKi8KCWRvd24oJnMtPm9wZW5fc2VtKTsKCXdoaWxlIChzLT5vcGVuX21vZGUgJiAoZmlsZS0+Zl9tb2RlIDw8IEZNT0RFX01JRElfU0hJRlQpKSB7CgkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKSB7CgkJCXVwKCZzLT5vcGVuX3NlbSk7CgkJCXJldHVybiAtRUJVU1k7CgkJfQoJCWFkZF93YWl0X3F1ZXVlKCZzLT5vcGVuX3dhaXQsICZ3YWl0KTsKCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJdXAoJnMtPm9wZW5fc2VtKTsKCQlzY2hlZHVsZSgpOwoJCXJlbW92ZV93YWl0X3F1ZXVlKCZzLT5vcGVuX3dhaXQsICZ3YWl0KTsKCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwoJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKCQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKCQlkb3duKCZzLT5vcGVuX3NlbSk7Cgl9CglzcGluX2xvY2tfaXJxc2F2ZSgmcy0+bG9jaywgZmxhZ3MpOwoJaWYgKCEocy0+b3Blbl9tb2RlICYgKEZNT0RFX01JRElfUkVBRCB8IEZNT0RFX01JRElfV1JJVEUpKSkgewoJCXMtPm1pZGkuaXJkID0gcy0+bWlkaS5pd3IgPSBzLT5taWRpLmljbnQgPSAwOwoJCXMtPm1pZGkub3JkID0gcy0+bWlkaS5vd3IgPSBzLT5taWRpLm9jbnQgPSAwOwoJCW91dGIoVUNUUkxfQ05UUkxfU1dSLCBzLT5pbytFUzEzNzFfUkVHX1VBUlRfQ09OVFJPTCk7CgkJb3V0YigwLCBzLT5pbytFUzEzNzFfUkVHX1VBUlRfQ09OVFJPTCk7CgkJb3V0YigwLCBzLT5pbytFUzEzNzFfUkVHX1VBUlRfVEVTVCk7Cgl9CglpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgewoJCXMtPm1pZGkuaXJkID0gcy0+bWlkaS5pd3IgPSBzLT5taWRpLmljbnQgPSAwOwoJfQoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJcy0+bWlkaS5vcmQgPSBzLT5taWRpLm93ciA9IHMtPm1pZGkub2NudCA9IDA7Cgl9CglzLT5jdHJsIHw9IENUUkxfVUFSVF9FTjsKCW91dGwocy0+Y3RybCwgcy0+aW8rRVMxMzcxX1JFR19DT05UUk9MKTsKCWVzMTM3MV9oYW5kbGVfbWlkaShzKTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmxvY2ssIGZsYWdzKTsKCXMtPm9wZW5fbW9kZSB8PSAoZmlsZS0+Zl9tb2RlIDw8IEZNT0RFX01JRElfU0hJRlQpICYgKEZNT0RFX01JRElfUkVBRCB8IEZNT0RFX01JRElfV1JJVEUpOwoJdXAoJnMtPm9wZW5fc2VtKTsKCXJldHVybiBub25zZWVrYWJsZV9vcGVuKGlub2RlLCBmaWxlKTsKfQoKc3RhdGljIGludCBlczEzNzFfbWlkaV9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gKHN0cnVjdCBlczEzNzFfc3RhdGUgKilmaWxlLT5wcml2YXRlX2RhdGE7CglERUNMQVJFX1dBSVRRVUVVRSh3YWl0LCBjdXJyZW50KTsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBjb3VudCwgdG1vOwoKCVZBTElEQVRFX1NUQVRFKHMpOwoJbG9ja19rZXJuZWwoKTsKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCWFkZF93YWl0X3F1ZXVlKCZzLT5taWRpLm93YWl0LCAmd2FpdCk7CgkJZm9yICg7OykgewoJCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CgkJCXNwaW5fbG9ja19pcnFzYXZlKCZzLT5sb2NrLCBmbGFncyk7CgkJCWNvdW50ID0gcy0+bWlkaS5vY250OwoJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5sb2NrLCBmbGFncyk7CgkJCWlmIChjb3VudCA8PSAwKQoJCQkJYnJlYWs7CgkJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKCQkJCWJyZWFrOwoJCQlpZiAoZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spCgkJCQlicmVhazsKCQkJdG1vID0gKGNvdW50ICogSFopIC8gMzEwMDsKCQkJaWYgKCFzY2hlZHVsZV90aW1lb3V0KHRtbyA/IDogMSkgJiYgdG1vKQoJCQkJcHJpbnRrKEtFUk5fREVCVUcgUEZYICJtaWRpIHRpbWVkIG91dD8/XG4iKTsKCQl9CgkJcmVtb3ZlX3dhaXRfcXVldWUoJnMtPm1pZGkub3dhaXQsICZ3YWl0KTsKCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwoJfQoJZG93bigmcy0+b3Blbl9zZW0pOwoJcy0+b3Blbl9tb2RlICY9IH4oKGZpbGUtPmZfbW9kZSA8PCBGTU9ERV9NSURJX1NISUZUKSAmIChGTU9ERV9NSURJX1JFQUR8Rk1PREVfTUlESV9XUklURSkpOwoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmxvY2ssIGZsYWdzKTsKCWlmICghKHMtPm9wZW5fbW9kZSAmIChGTU9ERV9NSURJX1JFQUQgfCBGTU9ERV9NSURJX1dSSVRFKSkpIHsKCQlzLT5jdHJsICY9IH5DVFJMX1VBUlRfRU47CgkJb3V0bChzLT5jdHJsLCBzLT5pbytFUzEzNzFfUkVHX0NPTlRST0wpOwoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+bG9jaywgZmxhZ3MpOwoJdXAoJnMtPm9wZW5fc2VtKTsKCXdha2VfdXAoJnMtPm9wZW5fd2FpdCk7Cgl1bmxvY2tfa2VybmVsKCk7CglyZXR1cm4gMDsKfQoKc3RhdGljIC8qY29uc3QqLyBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGVzMTM3MV9taWRpX2ZvcHMgPSB7Cgkub3duZXIJCT0gVEhJU19NT0RVTEUsCgkubGxzZWVrCQk9IG5vX2xsc2VlaywKCS5yZWFkCQk9IGVzMTM3MV9taWRpX3JlYWQsCgkud3JpdGUJCT0gZXMxMzcxX21pZGlfd3JpdGUsCgkucG9sbAkJPSBlczEzNzFfbWlkaV9wb2xsLAoJLm9wZW4JCT0gZXMxMzcxX21pZGlfb3BlbiwKCS5yZWxlYXNlCT0gZXMxMzcxX21pZGlfcmVsZWFzZSwKfTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKLyoKICogZm9yIGRlYnVnZ2luZyBwdXJwb3Nlcywgd2UnbGwgY3JlYXRlIGEgcHJvYyBkZXZpY2UgdGhhdCBkdW1wcyB0aGUKICogQ09ERUMgY2hpcHN0YXRlCiAqLwoKI2lmZGVmIEVTMTM3MV9ERUJVRwpzdGF0aWMgaW50IHByb2NfZXMxMzcxX2R1bXAgKGNoYXIgKmJ1ZiwgY2hhciAqKnN0YXJ0LCBvZmZfdCBmcG9zLCBpbnQgbGVuZ3RoLCBpbnQgKmVvZiwgdm9pZCAqZGF0YSkKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqczsKICAgICAgICBpbnQgY250LCBsZW4gPSAwOwoKCWlmIChsaXN0X2VtcHR5KCZkZXZzKSkKCQlyZXR1cm4gMDsKCXMgPSBsaXN0X2VudHJ5KGRldnMubmV4dCwgc3RydWN0IGVzMTM3MV9zdGF0ZSwgZGV2cyk7CiAgICAgICAgLyogcHJpbnQgb3V0IGhlYWRlciAqLwogICAgICAgIGxlbiArPSBzcHJpbnRmKGJ1ZiArIGxlbiwgIlx0XHRDcmVhdGl2ZSBFUzEzN3ggRGVidWcgRHVtcC1vLW1hdGljXG4iKTsKCiAgICAgICAgLyogcHJpbnQgb3V0IENPREVDIHN0YXRlICovCiAgICAgICAgbGVuICs9IHNwcmludGYgKGJ1ZiArIGxlbiwgIkFDOTcgQ09ERUMgc3RhdGVcbiIpOwoJZm9yIChjbnQ9MDsgY250IDw9IDB4N2U7IGNudCA9IGNudCArMikKICAgICAgICAgICAgICAgIGxlbis9IHNwcmludGYgKGJ1ZiArIGxlbiwgInJlZzoweCUwMnggIHZhbDoweCUwNHhcbiIsIGNudCwgcmRjb2RlYyhzLT5jb2RlYywgY250KSk7CgogICAgICAgIGlmIChmcG9zID49bGVuKXsKICAgICAgICAgICAgICAgICpzdGFydCA9IGJ1ZjsKICAgICAgICAgICAgICAgICplb2YgPTE7CiAgICAgICAgICAgICAgICByZXR1cm4gMDsKICAgICAgICB9CiAgICAgICAgKnN0YXJ0ID0gYnVmICsgZnBvczsKICAgICAgICBpZiAoKGxlbiAtPSBmcG9zKSA+IGxlbmd0aCkKICAgICAgICAgICAgICAgIHJldHVybiBsZW5ndGg7CiAgICAgICAgKmVvZiA9MTsKICAgICAgICByZXR1cm4gbGVuOwoKfQojZW5kaWYgLyogRVMxMzcxX0RFQlVHICovCgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCi8qIG1heGltdW0gbnVtYmVyIG9mIGRldmljZXM7IG9ubHkgdXNlZCBmb3IgY29tbWFuZCBsaW5lIHBhcmFtcyAqLwojZGVmaW5lIE5SX0RFVklDRSA1CgpzdGF0aWMgaW50IHNwZGlmW05SX0RFVklDRV07CnN0YXRpYyBpbnQgbm9taXhbTlJfREVWSUNFXTsKc3RhdGljIGludCBhbXBsaWZpZXJbTlJfREVWSUNFXTsKCnN0YXRpYyB1bnNpZ25lZCBpbnQgZGV2aW5kZXg7Cgptb2R1bGVfcGFyYW1fYXJyYXkoc3BkaWYsIGJvb2wsIE5VTEwsIDApOwpNT0RVTEVfUEFSTV9ERVNDKHNwZGlmLCAiaWYgMSB0aGUgb3V0cHV0IGlzIGluIFMvUERJRiBkaWdpdGFsIG1vZGUiKTsKbW9kdWxlX3BhcmFtX2FycmF5KG5vbWl4LCBib29sLCBOVUxMLCAwKTsKTU9EVUxFX1BBUk1fREVTQyhub21peCwgImlmIDEgbm8gYW5hbG9nIGF1ZGlvIGlzIG1peGVkIHRvIHRoZSBkaWdpdGFsIG91dHB1dCIpOwptb2R1bGVfcGFyYW1fYXJyYXkoYW1wbGlmaWVyLCBib29sLCBOVUxMLCAwKTsKTU9EVUxFX1BBUk1fREVTQyhhbXBsaWZpZXIsICJTZXQgdG8gMSBpZiB0aGUgbWFjaGluZSBuZWVkcyB0aGUgYW1wIGNvbnRyb2wgZW5hYmxpbmcgKG1hbnkgbGFwdG9wcykiKTsKCk1PRFVMRV9BVVRIT1IoIlRob21hcyBNLiBTYWlsZXIsIHNhaWxlckBpZmUuZWUuZXRoei5jaCwgaGI5am54QGhiOXcuY2hlLmV1Iik7Ck1PRFVMRV9ERVNDUklQVElPTigiRVMxMzcxIEF1ZGlvUENJOTcgRHJpdmVyIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKCgovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KCnN0YXRpYyBzdHJ1Y3QgaW5pdHZvbCB7CglpbnQgbWl4Y2g7CglpbnQgdm9sOwp9IGluaXR2b2xbXSBfX2RldmluaXRkYXRhID0gewoJeyBTT1VORF9NSVhFUl9XUklURV9MSU5FLCAweDQwNDAgfSwKCXsgU09VTkRfTUlYRVJfV1JJVEVfQ0QsIDB4NDA0MCB9LAoJeyBNSVhFUl9XUklURShTT1VORF9NSVhFUl9WSURFTyksIDB4NDA0MCB9LAoJeyBTT1VORF9NSVhFUl9XUklURV9MSU5FMSwgMHg0MDQwIH0sCgl7IFNPVU5EX01JWEVSX1dSSVRFX1BDTSwgMHg0MDQwIH0sCgl7IFNPVU5EX01JWEVSX1dSSVRFX1ZPTFVNRSwgMHg0MDQwIH0sCgl7IE1JWEVSX1dSSVRFKFNPVU5EX01JWEVSX1BIT05FT1VUKSwgMHg0MDQwIH0sCgl7IFNPVU5EX01JWEVSX1dSSVRFX09HQUlOLCAweDQwNDAgfSwKCXsgTUlYRVJfV1JJVEUoU09VTkRfTUlYRVJfUEhPTkVJTiksIDB4NDA0MCB9LAoJeyBTT1VORF9NSVhFUl9XUklURV9TUEVBS0VSLCAweDQwNDAgfSwKCXsgU09VTkRfTUlYRVJfV1JJVEVfTUlDLCAweDQwNDAgfSwKCXsgU09VTkRfTUlYRVJfV1JJVEVfUkVDTEVWLCAweDQwNDAgfSwKCXsgU09VTkRfTUlYRVJfV1JJVEVfSUdBSU4sIDB4NDA0MCB9Cn07CgpzdGF0aWMgc3RydWN0CnsKCXNob3J0IHN2aWQsIHNkaWQ7Cn0gYW1wbGlmaWVyX25lZWRlZFtdID0gCnsKCXsgMHgxMDdCLCAweDIxNTAgfSwJCS8qIEdhdGV3YXkgU29sbyAyMTUwICovCgl7IDB4MTNCRCwgMHgxMDBDIH0sCQkvKiBNZWJpdXMgUEMtTUoxMDBWICovCgl7IDB4MTEwMiwgMHg1OTM4IH0sCQkvKiBUYXJnYSBYdGVuZGVyIDMwMCAqLwoJeyAweDExMDIsIDB4ODkzOCB9LAkJLyogSVBDIG5vdGVib29rICovCgl7IFBDSV9BTllfSUQsIFBDSV9BTllfSUQgfQp9OwoKc3RhdGljIGludCBfX2RldmluaXQgZXMxMzcxX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwY2lkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICpwY2lpZCkKewoJc3RydWN0IGVzMTM3MV9zdGF0ZSAqczsKCXN0cnVjdCBnYW1lcG9ydCAqZ3A7CgltbV9zZWdtZW50X3QgZnM7CglpbnQgaSwgZ3BpbywgdmFsLCByZXMgPSAtMTsKCWludCBpZHg7Cgl1bnNpZ25lZCBsb25nIHRtbzsKCXNpZ25lZCBsb25nIHRtbzI7Cgl1bnNpZ25lZCBpbnQgY3NzcjsKCglpZiAoKHJlcz1wY2lfZW5hYmxlX2RldmljZShwY2lkZXYpKSkKCQlyZXR1cm4gcmVzOwoKCWlmICghKHBjaV9yZXNvdXJjZV9mbGFncyhwY2lkZXYsIDApICYgSU9SRVNPVVJDRV9JTykpCgkJcmV0dXJuIC1FTk9ERVY7CglpZiAocGNpZGV2LT5pcnEgPT0gMCkgCgkJcmV0dXJuIC1FTk9ERVY7CglpID0gcGNpX3NldF9kbWFfbWFzayhwY2lkZXYsIDB4ZmZmZmZmZmYpOwoJaWYgKGkpIHsKCQlwcmludGsoS0VSTl9XQVJOSU5HICJlczEzNzE6IGFyY2hpdGVjdHVyZSBkb2VzIG5vdCBzdXBwb3J0IDMyYml0IFBDSSBidXNtYXN0ZXIgRE1BXG4iKTsKCQlyZXR1cm4gaTsKCX0KCWlmICghKHMgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgZXMxMzcxX3N0YXRlKSwgR0ZQX0tFUk5FTCkpKSB7CgkJcHJpbnRrKEtFUk5fV0FSTklORyBQRlggIm91dCBvZiBtZW1vcnlcbiIpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoJbWVtc2V0KHMsIDAsIHNpemVvZihzdHJ1Y3QgZXMxMzcxX3N0YXRlKSk7CgkKCXMtPmNvZGVjID0gYWM5N19hbGxvY19jb2RlYygpOwoJaWYocy0+Y29kZWMgPT0gTlVMTCkKCQlnb3RvIGVycl9jb2RlYzsKCQkKCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnMtPmRtYV9hZGMud2FpdCk7Cglpbml0X3dhaXRxdWV1ZV9oZWFkKCZzLT5kbWFfZGFjMS53YWl0KTsKCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnMtPmRtYV9kYWMyLndhaXQpOwoJaW5pdF93YWl0cXVldWVfaGVhZCgmcy0+b3Blbl93YWl0KTsKCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnMtPm1pZGkuaXdhaXQpOwoJaW5pdF93YWl0cXVldWVfaGVhZCgmcy0+bWlkaS5vd2FpdCk7Cglpbml0X01VVEVYKCZzLT5vcGVuX3NlbSk7CglzcGluX2xvY2tfaW5pdCgmcy0+bG9jayk7CglzLT5tYWdpYyA9IEVTMTM3MV9NQUdJQzsKCXMtPmRldiA9IHBjaWRldjsKCXMtPmlvID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBjaWRldiwgMCk7CglzLT5pcnEgPSBwY2lkZXYtPmlycTsKCXMtPnZlbmRvciA9IHBjaWRldi0+dmVuZG9yOwoJcy0+ZGV2aWNlID0gcGNpZGV2LT5kZXZpY2U7CglwY2lfcmVhZF9jb25maWdfYnl0ZShwY2lkZXYsIFBDSV9SRVZJU0lPTl9JRCwgJnMtPnJldik7CglzLT5jb2RlYy0+cHJpdmF0ZV9kYXRhID0gczsKCXMtPmNvZGVjLT5pZCA9IDA7CglzLT5jb2RlYy0+Y29kZWNfcmVhZCA9IHJkY29kZWM7CglzLT5jb2RlYy0+Y29kZWNfd3JpdGUgPSB3cmNvZGVjOwoJcHJpbnRrKEtFUk5fSU5GTyBQRlggImZvdW5kIGNoaXAsIHZlbmRvciBpZCAweCUwNHggZGV2aWNlIGlkIDB4JTA0eCByZXZpc2lvbiAweCUwMnhcbiIsCgkgICAgICAgcy0+dmVuZG9yLCBzLT5kZXZpY2UsIHMtPnJldik7CglpZiAoIXJlcXVlc3RfcmVnaW9uKHMtPmlvLCBFUzEzNzFfRVhURU5ULCAiZXMxMzcxIikpIHsKCQlwcmludGsoS0VSTl9FUlIgUEZYICJpbyBwb3J0cyAlI2x4LSUjbHggaW4gdXNlXG4iLCBzLT5pbywgcy0+aW8rRVMxMzcxX0VYVEVOVC0xKTsKCQlyZXMgPSAtRUJVU1k7CgkJZ290byBlcnJfcmVnaW9uOwoJfQoJaWYgKChyZXM9cmVxdWVzdF9pcnEocy0+aXJxLCBlczEzNzFfaW50ZXJydXB0LCBTQV9TSElSUSwgImVzMTM3MSIscykpKSB7CgkJcHJpbnRrKEtFUk5fRVJSIFBGWCAiaXJxICV1IGluIHVzZVxuIiwgcy0+aXJxKTsKCQlnb3RvIGVycl9pcnE7Cgl9CglwcmludGsoS0VSTl9JTkZPIFBGWCAiZm91bmQgZXMxMzcxIHJldiAlZCBhdCBpbyAlI2x4IGlycSAldVxuIiwKCSAgICAgICBzLT5yZXYsIHMtPmlvLCBzLT5pcnEpOwoJLyogcmVnaXN0ZXIgZGV2aWNlcyAqLwoJaWYgKChyZXM9KHMtPmRldl9hdWRpbyA9IHJlZ2lzdGVyX3NvdW5kX2RzcCgmZXMxMzcxX2F1ZGlvX2ZvcHMsLTEpKSk8MCkKCQlnb3RvIGVycl9kZXYxOwoJaWYgKChyZXM9KHMtPmNvZGVjLT5kZXZfbWl4ZXIgPSByZWdpc3Rlcl9zb3VuZF9taXhlcigmZXMxMzcxX21peGVyX2ZvcHMsIC0xKSkpIDwgMCkKCQlnb3RvIGVycl9kZXYyOwoJaWYgKChyZXM9KHMtPmRldl9kYWMgPSByZWdpc3Rlcl9zb3VuZF9kc3AoJmVzMTM3MV9kYWNfZm9wcywgLTEpKSkgPCAwKQoJCWdvdG8gZXJyX2RldjM7CglpZiAoKHJlcz0ocy0+ZGV2X21pZGkgPSByZWdpc3Rlcl9zb3VuZF9taWRpKCZlczEzNzFfbWlkaV9mb3BzLCAtMSkpKTwwICkKCQlnb3RvIGVycl9kZXY0OwojaWZkZWYgRVMxMzcxX0RFQlVHCgkvKiBpbml0aWFsaXplIHRoZSBkZWJ1ZyBwcm9jIGRldmljZSAqLwoJcy0+cHMgPSBjcmVhdGVfcHJvY19yZWFkX2VudHJ5KCJlczEzNzEiLDAsTlVMTCxwcm9jX2VzMTM3MV9kdW1wLE5VTEwpOwojZW5kaWYgLyogRVMxMzcxX0RFQlVHICovCgkKCS8qIGluaXRpYWxpemUgY29kZWMgcmVnaXN0ZXJzICovCglzLT5jdHJsID0gMDsKCgkvKiBDaGVjayBhbXBsaWZpZXIgcmVxdWlyZW1lbnRzICovCgkKCWlmIChhbXBsaWZpZXJbZGV2aW5kZXhdKQoJCXMtPmN0cmwgfD0gQ1RSTF9HUElPX09VVDA7CgllbHNlIGZvcihpZHggPSAwOyBhbXBsaWZpZXJfbmVlZGVkW2lkeF0uc3ZpZCAhPSBQQ0lfQU5ZX0lEOyBpZHgrKykKCXsKCQlpZihwY2lkZXYtPnN1YnN5c3RlbV92ZW5kb3IgPT0gYW1wbGlmaWVyX25lZWRlZFtpZHhdLnN2aWQgJiYKCQkgICBwY2lkZXYtPnN1YnN5c3RlbV9kZXZpY2UgPT0gYW1wbGlmaWVyX25lZWRlZFtpZHhdLnNkaWQpCgkJewogICAgICAgICAgICAgICAgICAgIAlzLT5jdHJsIHw9IENUUkxfR1BJT19PVVQwOyAgIC8qIHR1cm4gaW50ZXJuYWwgYW1wbGlmaWVyIG9uICovCiAgICAgICAgICAgICAgICAgICAgCXByaW50ayhLRVJOX0lORk8gUEZYICJFbmFibGluZyBpbnRlcm5hbCBhbXBsaWZpZXIuXG4iKTsKCQl9Cgl9CgoJZm9yIChncGlvID0gMHgyMTg7IGdwaW8gPj0gMHgyMDA7IGdwaW8gLT0gMHgwOCkKCQlpZiAocmVxdWVzdF9yZWdpb24oZ3BpbywgSk9ZX0VYVEVOVCwgImVzMTM3MSIpKQoJCQlicmVhazsKCglpZiAoZ3BpbyA8IDB4MjAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSIFBGWCAibm8gZnJlZSBqb3lzdGljayBhZGRyZXNzIGZvdW5kXG4iKTsKCX0gZWxzZSBpZiAoIShzLT5nYW1lcG9ydCA9IGdwID0gZ2FtZXBvcnRfYWxsb2NhdGVfcG9ydCgpKSkgewoJCXByaW50ayhLRVJOX0VSUiBQRlggImNhbiBub3QgYWxsb2NhdGUgbWVtb3J5IGZvciBnYW1lcG9ydFxuIik7CgkJcmVsZWFzZV9yZWdpb24oZ3BpbywgSk9ZX0VYVEVOVCk7Cgl9IGVsc2UgewoJCWdhbWVwb3J0X3NldF9uYW1lKGdwLCAiRVNTMTM3MSBHYW1lcG9ydCIpOwoJCWdhbWVwb3J0X3NldF9waHlzKGdwLCAiaXNhJTA0eC9nYW1lcG9ydDAiLCBncGlvKTsKCQlncC0+ZGV2LnBhcmVudCA9ICZzLT5kZXYtPmRldjsKCQlncC0+aW8gPSBncGlvOwoJCXMtPmN0cmwgfD0gQ1RSTF9KWVNUS19FTiB8ICgoKGdwaW8gPj4gMykgJiBDVFJMX0pPWV9NQVNLKSA8PCBDVFJMX0pPWV9TSElGVCk7Cgl9CgoJcy0+c2N0cmwgPSAwOwoJY3NzciA9IDA7CglzLT5zcGRpZl92b2x1bWUgPSAtMTsKCS8qIGNoZWNrIHRvIHNlZSBpZiBzL3BkaWYgbW9kZSBpcyBiZWluZyByZXF1ZXN0ZWQgKi8KCWlmIChzcGRpZltkZXZpbmRleF0pIHsKCQlpZiAocy0+cmV2ID49IDQpIHsKCQkJcHJpbnRrKEtFUk5fSU5GTyBQRlggImVuYWJsaW5nIFMvUERJRiBvdXRwdXRcbiIpOwoJCQlzLT5zcGRpZl92b2x1bWUgPSAwOwoJCQljc3NyIHw9IFNUQVRfRU5fU1BESUY7CgkJCXMtPmN0cmwgfD0gQ1RSTF9TUERJRkVOX0I7CgkJCWlmIChub21peFtkZXZpbmRleF0pIC8qIGRvbid0IG1peCBhbmFsb2cgaW5wdXRzIHRvIHMvcGRpZiBvdXRwdXQgKi8KCQkJCXMtPmN0cmwgfD0gQ1RSTF9SRUNFTl9COwoJCX0gZWxzZSB7CgkJCXByaW50ayhLRVJOX0VSUiBQRlggInJldmlzaW9uICVkIGRvZXMgbm90IHN1cHBvcnQgUy9QRElGXG4iLCBzLT5yZXYpOwoJCX0KCX0KCS8qIGluaXRpYWxpemUgdGhlIGNoaXBzICovCglvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CglvdXRsKHMtPnNjdHJsLCBzLT5pbytFUzEzNzFfUkVHX1NFUklBTF9DT05UUk9MKTsKCW91dGwoTEVHQUNZX0pGQVNULCBzLT5pbytFUzEzNzFfUkVHX0xFR0FDWSk7CglwY2lfc2V0X21hc3RlcihwY2lkZXYpOyAgLyogZW5hYmxlIGJ1cyBtYXN0ZXJpbmcgKi8KCS8qIGlmIHdlIGFyZSBhIDU4ODAgdHVybiBvbiB0aGUgQUM5NyAqLwoJaWYgKHMtPnZlbmRvciA9PSBQQ0lfVkVORE9SX0lEX0VOU09OSVEgJiYKCSAgICAoKHMtPmRldmljZSA9PSBQQ0lfREVWSUNFX0lEX0VOU09OSVFfQ1Q1ODgwICYmIHMtPnJldiA+PSBDVDU4ODBSRVZfQ1Q1ODgwX0MpIHx8IAoJICAgICAocy0+ZGV2aWNlID09IFBDSV9ERVZJQ0VfSURfRU5TT05JUV9FUzEzNzEgJiYgcy0+cmV2ID09IEVTMTM3MVJFVl9DVDU4ODBfQSkgfHwgCgkgICAgIChzLT5kZXZpY2UgPT0gUENJX0RFVklDRV9JRF9FTlNPTklRX0VTMTM3MSAmJiBzLT5yZXYgPT0gRVMxMzcxUkVWX0VTMTM3M184KSkpIHsgCgkJY3NzciB8PSBDU1RBVF81ODgwX0FDOTdfUlNUOwoJCW91dGwoY3Nzciwgcy0+aW8rRVMxMzcxX1JFR19TVEFUVVMpOwoJCS8qIG5lZWQgdG8gZGVsYXkgYXJvdW5kIDIwbXMoYmxlZWNoKSB0byBnaXZlCgkJICAgc29tZSBDT0RFQ3MgZW5vdWdoIHRpbWUgdG8gd2FrZXVwICovCgkJdG1vID0gamlmZmllcyArIChIWiAvIDUwKSArIDE7CgkJZm9yICg7OykgewoJCQl0bW8yID0gdG1vIC0gamlmZmllczsKCQkJaWYgKHRtbzIgPD0gMCkKCQkJCWJyZWFrOwoJCQlzY2hlZHVsZV90aW1lb3V0KHRtbzIpOwoJCX0KCX0KCS8qIEFDOTcgd2FybSByZXNldCB0byBzdGFydCB0aGUgYml0Y2xrICovCglvdXRsKHMtPmN0cmwgfCBDVFJMX1NZTkNSRVMsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7Cgl1ZGVsYXkoMik7CglvdXRsKHMtPmN0cmwsIHMtPmlvK0VTMTM3MV9SRUdfQ09OVFJPTCk7CgkvKiBpbml0IHRoZSBzYW1wbGUgcmF0ZSBjb252ZXJ0ZXIgKi8KCXNyY19pbml0KHMpOwoJLyogY29kZWMgaW5pdCAqLwoJaWYgKCFhYzk3X3Byb2JlX2NvZGVjKHMtPmNvZGVjKSkgewoJCXJlcyA9IC1FTk9ERVY7CgkJZ290byBlcnJfZ3A7Cgl9CgkvKiBzZXQgZGVmYXVsdCB2YWx1ZXMgKi8KCglmcyA9IGdldF9mcygpOwoJc2V0X2ZzKEtFUk5FTF9EUyk7Cgl2YWwgPSBTT1VORF9NQVNLX0xJTkU7CgltaXhkZXZfaW9jdGwocy0+Y29kZWMsIFNPVU5EX01JWEVSX1dSSVRFX1JFQ1NSQywgKHVuc2lnbmVkIGxvbmcpJnZhbCk7Cglmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKGluaXR2b2wpL3NpemVvZihpbml0dm9sWzBdKTsgaSsrKSB7CgkJdmFsID0gaW5pdHZvbFtpXS52b2w7CgkJbWl4ZGV2X2lvY3RsKHMtPmNvZGVjLCBpbml0dm9sW2ldLm1peGNoLCAodW5zaWduZWQgbG9uZykmdmFsKTsKCX0KCS8qIG11dGUgbWFzdGVyIGFuZCBQQ00gd2hlbiBpbiBTL1BESUYgbW9kZSAqLwoJaWYgKHMtPnNwZGlmX3ZvbHVtZSAhPSAtMSkgewoJCXZhbCA9IDB4MDAwMDsKCQlzLT5jb2RlYy0+bWl4ZXJfaW9jdGwocy0+Y29kZWMsIFNPVU5EX01JWEVSX1dSSVRFX1ZPTFVNRSwgKHVuc2lnbmVkIGxvbmcpJnZhbCk7CgkJcy0+Y29kZWMtPm1peGVyX2lvY3RsKHMtPmNvZGVjLCBTT1VORF9NSVhFUl9XUklURV9QQ00sICh1bnNpZ25lZCBsb25nKSZ2YWwpOwoJfQoJc2V0X2ZzKGZzKTsKCS8qIHR1cm4gb24gUy9QRElGIG91dHB1dCBkcml2ZXIgaWYgcmVxdWVzdGVkICovCglvdXRsKGNzc3IsIHMtPmlvK0VTMTM3MV9SRUdfU1RBVFVTKTsKCgkvKiByZWdpc3RlciBnYW1lcG9ydCAqLwoJaWYgKHMtPmdhbWVwb3J0KQoJCWdhbWVwb3J0X3JlZ2lzdGVyX3BvcnQocy0+Z2FtZXBvcnQpOwoKCS8qIHN0b3JlIGl0IGluIHRoZSBkcml2ZXIgZmllbGQgKi8KCXBjaV9zZXRfZHJ2ZGF0YShwY2lkZXYsIHMpOwoJLyogcHV0IGl0IGludG8gZHJpdmVyIGxpc3QgKi8KCWxpc3RfYWRkX3RhaWwoJnMtPmRldnMsICZkZXZzKTsKCS8qIGluY3JlbWVudCBkZXZpbmRleCAqLwoJaWYgKGRldmluZGV4IDwgTlJfREVWSUNFLTEpCgkJZGV2aW5kZXgrKzsKICAgICAgIAlyZXR1cm4gMDsKCiBlcnJfZ3A6CglpZiAocy0+Z2FtZXBvcnQpIHsKCQlyZWxlYXNlX3JlZ2lvbihzLT5nYW1lcG9ydC0+aW8sIEpPWV9FWFRFTlQpOwoJCWdhbWVwb3J0X2ZyZWVfcG9ydChzLT5nYW1lcG9ydCk7Cgl9CiNpZmRlZiBFUzEzNzFfREVCVUcKCWlmIChzLT5wcykKCQlyZW1vdmVfcHJvY19lbnRyeSgiZXMxMzcxIiwgTlVMTCk7CiNlbmRpZgoJdW5yZWdpc3Rlcl9zb3VuZF9taWRpKHMtPmRldl9taWRpKTsKIGVycl9kZXY0OgoJdW5yZWdpc3Rlcl9zb3VuZF9kc3Aocy0+ZGV2X2RhYyk7CiBlcnJfZGV2MzoKCXVucmVnaXN0ZXJfc291bmRfbWl4ZXIocy0+Y29kZWMtPmRldl9taXhlcik7CiBlcnJfZGV2MjoKCXVucmVnaXN0ZXJfc291bmRfZHNwKHMtPmRldl9hdWRpbyk7CiBlcnJfZGV2MToKCXByaW50ayhLRVJOX0VSUiBQRlggImNhbm5vdCByZWdpc3RlciBtaXNjIGRldmljZVxuIik7CglmcmVlX2lycShzLT5pcnEsIHMpOwogZXJyX2lycToKCXJlbGVhc2VfcmVnaW9uKHMtPmlvLCBFUzEzNzFfRVhURU5UKTsKIGVycl9yZWdpb246CiBlcnJfY29kZWM6CglhYzk3X3JlbGVhc2VfY29kZWMocy0+Y29kZWMpOwoJa2ZyZWUocyk7CglyZXR1cm4gcmVzOwp9CgpzdGF0aWMgdm9pZCBfX2RldmV4aXQgZXMxMzcxX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQp7CglzdHJ1Y3QgZXMxMzcxX3N0YXRlICpzID0gcGNpX2dldF9kcnZkYXRhKGRldik7CgoJaWYgKCFzKQoJCXJldHVybjsKCWxpc3RfZGVsKCZzLT5kZXZzKTsKI2lmZGVmIEVTMTM3MV9ERUJVRwoJaWYgKHMtPnBzKQoJCXJlbW92ZV9wcm9jX2VudHJ5KCJlczEzNzEiLCBOVUxMKTsKI2VuZGlmIC8qIEVTMTM3MV9ERUJVRyAqLwoJb3V0bCgwLCBzLT5pbytFUzEzNzFfUkVHX0NPTlRST0wpOyAvKiBzd2l0Y2ggZXZlcnl0aGluZyBvZmYgKi8KCW91dGwoMCwgcy0+aW8rRVMxMzcxX1JFR19TRVJJQUxfQ09OVFJPTCk7IC8qIGNsZWFyIHNlcmlhbCBpbnRlcnJ1cHRzICovCglzeW5jaHJvbml6ZV9pcnEocy0+aXJxKTsKCWZyZWVfaXJxKHMtPmlycSwgcyk7CglpZiAocy0+Z2FtZXBvcnQpIHsKCQlpbnQgZ3BpbyA9IHMtPmdhbWVwb3J0LT5pbzsKCQlnYW1lcG9ydF91bnJlZ2lzdGVyX3BvcnQocy0+Z2FtZXBvcnQpOwoJCXJlbGVhc2VfcmVnaW9uKGdwaW8sIEpPWV9FWFRFTlQpOwoJfQoJcmVsZWFzZV9yZWdpb24ocy0+aW8sIEVTMTM3MV9FWFRFTlQpOwoJdW5yZWdpc3Rlcl9zb3VuZF9kc3Aocy0+ZGV2X2F1ZGlvKTsKCXVucmVnaXN0ZXJfc291bmRfbWl4ZXIocy0+Y29kZWMtPmRldl9taXhlcik7Cgl1bnJlZ2lzdGVyX3NvdW5kX2RzcChzLT5kZXZfZGFjKTsKCXVucmVnaXN0ZXJfc291bmRfbWlkaShzLT5kZXZfbWlkaSk7CglhYzk3X3JlbGVhc2VfY29kZWMocy0+Y29kZWMpOwoJa2ZyZWUocyk7CglwY2lfc2V0X2RydmRhdGEoZGV2LCBOVUxMKTsKfQoKc3RhdGljIHN0cnVjdCBwY2lfZGV2aWNlX2lkIGlkX3RhYmxlW10gPSB7Cgl7IFBDSV9WRU5ET1JfSURfRU5TT05JUSwgUENJX0RFVklDRV9JRF9FTlNPTklRX0VTMTM3MSwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCB9LAoJeyBQQ0lfVkVORE9SX0lEX0VOU09OSVEsIFBDSV9ERVZJQ0VfSURfRU5TT05JUV9DVDU4ODAsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAgfSwKCXsgUENJX1ZFTkRPUl9JRF9FQ1RJVkEsIFBDSV9ERVZJQ0VfSURfRUNUSVZBX0VWMTkzOCwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCB9LAoJeyAwLCB9Cn07CgpNT0RVTEVfREVWSUNFX1RBQkxFKHBjaSwgaWRfdGFibGUpOwoKc3RhdGljIHN0cnVjdCBwY2lfZHJpdmVyIGVzMTM3MV9kcml2ZXIgPSB7CgkubmFtZQkJPSAiZXMxMzcxIiwKCS5pZF90YWJsZQk9IGlkX3RhYmxlLAoJLnByb2JlCQk9IGVzMTM3MV9wcm9iZSwKCS5yZW1vdmUJCT0gX19kZXZleGl0X3AoZXMxMzcxX3JlbW92ZSksCn07CgpzdGF0aWMgaW50IF9faW5pdCBpbml0X2VzMTM3MSh2b2lkKQp7CglwcmludGsoS0VSTl9JTkZPIFBGWCAidmVyc2lvbiB2MC4zMiB0aW1lICIgX19USU1FX18gIiAiIF9fREFURV9fICJcbiIpOwoJcmV0dXJuIHBjaV9tb2R1bGVfaW5pdCgmZXMxMzcxX2RyaXZlcik7Cn0KCnN0YXRpYyB2b2lkIF9fZXhpdCBjbGVhbnVwX2VzMTM3MSh2b2lkKQp7CglwcmludGsoS0VSTl9JTkZPIFBGWCAidW5sb2FkaW5nXG4iKTsKCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmZXMxMzcxX2RyaXZlcik7Cn0KCm1vZHVsZV9pbml0KGluaXRfZXMxMzcxKTsKbW9kdWxlX2V4aXQoY2xlYW51cF9lczEzNzEpOwoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCgojaWZuZGVmIE1PRFVMRQoKLyogZm9ybWF0IGlzOiBlczEzNzE9W3NwZGlmLFtub21peCxbYW1wbGlmaWVyXV1dICovCgpzdGF0aWMgaW50IF9faW5pdCBlczEzNzFfc2V0dXAoY2hhciAqc3RyKQp7CglzdGF0aWMgdW5zaWduZWQgX19pbml0ZGF0YSBucl9kZXYgPSAwOwoKCWlmIChucl9kZXYgPj0gTlJfREVWSUNFKQoJCXJldHVybiAwOwoKCSh2b2lkKQogICAgICAgICgoZ2V0X29wdGlvbigmc3RyLCAmc3BkaWZbbnJfZGV2XSkgPT0gMikKICAgICAgICAgJiYgKGdldF9vcHRpb24oJnN0ciwgJm5vbWl4W25yX2Rldl0pID09IDIpCiAgICAgICAgICYmIChnZXRfb3B0aW9uKCZzdHIsICZhbXBsaWZpZXJbbnJfZGV2XSkpKTsKCglucl9kZXYrKzsKCXJldHVybiAxOwp9CgpfX3NldHVwKCJlczEzNzE9IiwgZXMxMzcxX3NldHVwKTsKCiNlbmRpZiAvKiBNT0RVTEUgKi8K