LyoKICogaTJjLXhpaWMuYwogKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwNyBYaWxpbnggSW5jLgogKiBDb3B5cmlnaHQgKGMpIDIwMDktMjAxMCBJbnRlbCBDb3Jwb3JhdGlvbgogKgogKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwogKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNjc1IE1hc3MgQXZlLCBDYW1icmlkZ2UsIE1BIDAyMTM5LCBVU0EuCiAqCiAqCiAqIFRoaXMgY29kZSB3YXMgaW1wbGVtZW50ZWQgYnkgTW9jZWFuIExhYm9yYXRvcmllcyBBQiB3aGVuIHBvcnRpbmcgbGludXgKICogdG8gdGhlIGF1dG9tb3RpdmUgZGV2ZWxvcG1lbnQgYm9hcmQgUnVzc2VsbHZpbGxlLiBUaGUgY29weXJpZ2h0IGhvbGRlcgogKiBhcyBzZWVuIGluIHRoZSBoZWFkZXIgaXMgSW50ZWwgY29ycG9yYXRpb24uCiAqIE1vY2VhbiBMYWJvcmF0b3JpZXMgZm9ya2VkIG9mZiB0aGUgR05VL0xpbnV4IHBsYXRmb3JtIHdvcmsgaW50byBhCiAqIHNlcGFyYXRlIGNvbXBhbnkgY2FsbGVkIFBlbGFnaWNvcmUgQUIsIHdoaWNoIGNvbW1pdGVkIHRoZSBjb2RlIHRvIHRoZQogKiBrZXJuZWwuCiAqLwoKLyogU3VwcG9ydHM6CiAqIFhpbGlueCBJSUMKICovCiNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvZXJybm8uaD4KI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgojaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CiNpbmNsdWRlIDxsaW51eC9pMmMteGlpYy5oPgojaW5jbHVkZSA8bGludXgvaW8uaD4KI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KCiNkZWZpbmUgRFJJVkVSX05BTUUgInhpaWMtaTJjIgoKZW51bSB4aWxpbnhfaTJjX3N0YXRlIHsKCVNUQVRFX0RPTkUsCglTVEFURV9FUlJPUiwKCVNUQVRFX1NUQVJUCn07CgovKioKICogc3RydWN0IHhpaWNfaTJjIC0gSW50ZXJuYWwgcmVwcmVzZW50YXRpb24gb2YgdGhlIFhJSUMgSTJDIGJ1cwogKiBAYmFzZToJTWVtb3J5IGJhc2Ugb2YgdGhlIEhXIHJlZ2lzdGVycwogKiBAd2FpdDoJV2FpdCBxdWV1ZSBmb3IgY2FsbGVycwogKiBAYWRhcDoJS2VybmVsIGFkYXB0ZXIgcmVwcmVzZW50YXRpb24KICogQHR4X21zZzoJTWVzc2FnZXMgZnJvbSBhYm92ZSB0byBiZSBzZW50CiAqIEBsb2NrOglNdXR1YWwgZXhjbHVzaW9uCiAqIEB0eF9wb3M6CUN1cnJlbnQgcG9zIGluIFRYIG1lc3NhZ2UKICogQG5tc2dzOglOdW1iZXIgb2YgbWVzc2FnZXMgaW4gdHhfbXNnCiAqIEBzdGF0ZToJU2VlIFNUQVRFXwogKiBAcnhfbXNnOglDdXJyZW50IFJYIG1lc3NhZ2UKICogQHJ4X3BvczoJUG9zaXRpb24gd2l0aGluIGN1cnJlbnQgUlggbWVzc2FnZQogKi8Kc3RydWN0IHhpaWNfaTJjIHsKCXZvaWQgX19pb21lbQkJKmJhc2U7Cgl3YWl0X3F1ZXVlX2hlYWRfdAl3YWl0OwoJc3RydWN0IGkyY19hZGFwdGVyCWFkYXA7CglzdHJ1Y3QgaTJjX21zZwkJKnR4X21zZzsKCXNwaW5sb2NrX3QJCWxvY2s7Cgl1bnNpZ25lZCBpbnQgCQl0eF9wb3M7Cgl1bnNpZ25lZCBpbnQJCW5tc2dzOwoJZW51bSB4aWxpbnhfaTJjX3N0YXRlCXN0YXRlOwoJc3RydWN0IGkyY19tc2cJCSpyeF9tc2c7CglpbnQJCQlyeF9wb3M7Cn07CgoKI2RlZmluZSBYSUlDX01TQl9PRkZTRVQgMAojZGVmaW5lIFhJSUNfUkVHX09GRlNFVCAoMHgxMDArWElJQ19NU0JfT0ZGU0VUKQoKLyoKICogUmVnaXN0ZXIgb2Zmc2V0cyBpbiBieXRlcyBmcm9tIFJlZ2lzdGVyQmFzZS4gVGhyZWUgaXMgYWRkZWQgdG8gdGhlCiAqIGJhc2Ugb2Zmc2V0IHRvIGFjY2VzcyBMU0IgKElCTSBzdHlsZSkgb2YgdGhlIHdvcmQKICovCiNkZWZpbmUgWElJQ19DUl9SRUdfT0ZGU0VUICAgKDB4MDArWElJQ19SRUdfT0ZGU0VUKQkvKiBDb250cm9sIFJlZ2lzdGVyICAgKi8KI2RlZmluZSBYSUlDX1NSX1JFR19PRkZTRVQgICAoMHgwNCtYSUlDX1JFR19PRkZTRVQpCS8qIFN0YXR1cyBSZWdpc3RlciAgICAqLwojZGVmaW5lIFhJSUNfRFRSX1JFR19PRkZTRVQgICgweDA4K1hJSUNfUkVHX09GRlNFVCkJLyogRGF0YSBUeCBSZWdpc3RlciAgICovCiNkZWZpbmUgWElJQ19EUlJfUkVHX09GRlNFVCAgKDB4MEMrWElJQ19SRUdfT0ZGU0VUKQkvKiBEYXRhIFJ4IFJlZ2lzdGVyICAgKi8KI2RlZmluZSBYSUlDX0FEUl9SRUdfT0ZGU0VUICAoMHgxMCtYSUlDX1JFR19PRkZTRVQpCS8qIEFkZHJlc3MgUmVnaXN0ZXIgICAqLwojZGVmaW5lIFhJSUNfVEZPX1JFR19PRkZTRVQgICgweDE0K1hJSUNfUkVHX09GRlNFVCkJLyogVHggRklGTyBPY2N1cGFuY3kgICovCiNkZWZpbmUgWElJQ19SRk9fUkVHX09GRlNFVCAgKDB4MTgrWElJQ19SRUdfT0ZGU0VUKQkvKiBSeCBGSUZPIE9jY3VwYW5jeSAgKi8KI2RlZmluZSBYSUlDX1RCQV9SRUdfT0ZGU0VUICAoMHgxQytYSUlDX1JFR19PRkZTRVQpCS8qIDEwIEJpdCBBZGRyZXNzIHJlZyAqLwojZGVmaW5lIFhJSUNfUkZEX1JFR19PRkZTRVQgICgweDIwK1hJSUNfUkVHX09GRlNFVCkJLyogUnggRklGTyBEZXB0aCByZWcgICovCiNkZWZpbmUgWElJQ19HUE9fUkVHX09GRlNFVCAgKDB4MjQrWElJQ19SRUdfT0ZGU0VUKQkvKiBPdXRwdXQgUmVnaXN0ZXIgICAgKi8KCi8qIENvbnRyb2wgUmVnaXN0ZXIgbWFza3MgKi8KI2RlZmluZSBYSUlDX0NSX0VOQUJMRV9ERVZJQ0VfTUFTSyAgICAgICAgMHgwMQkvKiBEZXZpY2UgZW5hYmxlID0gMSAgICAgICovCiNkZWZpbmUgWElJQ19DUl9UWF9GSUZPX1JFU0VUX01BU0sgICAgICAgIDB4MDIJLyogVHJhbnNtaXQgRklGTyByZXNldD0xICAqLwojZGVmaW5lIFhJSUNfQ1JfTVNNU19NQVNLICAgICAgICAgICAgICAgICAweDA0CS8qIE1hc3RlciBzdGFydHMgVHhpbmc9MSAgKi8KI2RlZmluZSBYSUlDX0NSX0RJUl9JU19UWF9NQVNLICAgICAgICAgICAgMHgwOAkvKiBEaXIgb2YgdHguIFR4aW5nPTEgICAgICovCiNkZWZpbmUgWElJQ19DUl9OT19BQ0tfTUFTSyAgICAgICAgICAgICAgIDB4MTAJLyogVHggQWNrLiBOTyBhY2sgPSAxICAgICAqLwojZGVmaW5lIFhJSUNfQ1JfUkVQRUFURURfU1RBUlRfTUFTSyAgICAgICAweDIwCS8qIFJlcGVhdGVkIHN0YXJ0ID0gMSAgICAgKi8KI2RlZmluZSBYSUlDX0NSX0dFTkVSQUxfQ0FMTF9NQVNLICAgICAgICAgMHg0MAkvKiBHZW4gQ2FsbCBlbmFibGVkID0gMSAgICovCgovKiBTdGF0dXMgUmVnaXN0ZXIgbWFza3MgKi8KI2RlZmluZSBYSUlDX1NSX0dFTl9DQUxMX01BU0sgICAgICAgICAgICAgMHgwMQkvKiAxPWEgbXN0ciBpc3N1ZWQgYSBHQyAgICovCiNkZWZpbmUgWElJQ19TUl9BRERSX0FTX1NMQVZFX01BU0sgICAgICAgIDB4MDIJLyogMT13aGVuIGFkZHIgYXMgc2xhdmUgICAqLwojZGVmaW5lIFhJSUNfU1JfQlVTX0JVU1lfTUFTSyAgICAgICAgICAgICAweDA0CS8qIDEgPSBidXMgaXMgYnVzeSAgICAgICAgKi8KI2RlZmluZSBYSUlDX1NSX01TVFJfUkRJTkdfU0xBVkVfTUFTSyAgICAgMHgwOAkvKiAxPURpcjogbXN0ciA8LS0gc2xhdmUgICovCiNkZWZpbmUgWElJQ19TUl9UWF9GSUZPX0ZVTExfTUFTSyAgICAgICAgIDB4MTAJLyogMSA9IFR4IEZJRk8gZnVsbCAgICAgICAqLwojZGVmaW5lIFhJSUNfU1JfUlhfRklGT19GVUxMX01BU0sgICAgICAgICAweDIwCS8qIDEgPSBSeCBGSUZPIGZ1bGwgICAgICAgKi8KI2RlZmluZSBYSUlDX1NSX1JYX0ZJRk9fRU1QVFlfTUFTSyAgICAgICAgMHg0MAkvKiAxID0gUnggRklGTyBlbXB0eSAgICAgICovCiNkZWZpbmUgWElJQ19TUl9UWF9GSUZPX0VNUFRZX01BU0sgICAgICAgIDB4ODAJLyogMSA9IFR4IEZJRk8gZW1wdHkgICAgICAqLwoKLyogSW50ZXJydXB0IFN0YXR1cyBSZWdpc3RlciBtYXNrcyAgICBJbnRlcnJ1cHQgb2NjdXJzIHdoZW4uLi4gICAgICAgKi8KI2RlZmluZSBYSUlDX0lOVFJfQVJCX0xPU1RfTUFTSyAgICAgICAgICAgMHgwMQkvKiAxID0gYXJiaXRyYXRpb24gbG9zdCAgICovCiNkZWZpbmUgWElJQ19JTlRSX1RYX0VSUk9SX01BU0sgICAgICAgICAgIDB4MDIJLyogMT1UeCBlcnJvci9tc2cgY29tcGxldGUgKi8KI2RlZmluZSBYSUlDX0lOVFJfVFhfRU1QVFlfTUFTSyAgICAgICAgICAgMHgwNAkvKiAxID0gVHggRklGTy9yZWcgZW1wdHkgICovCiNkZWZpbmUgWElJQ19JTlRSX1JYX0ZVTExfTUFTSyAgICAgICAgICAgIDB4MDgJLyogMT1SeCBGSUZPL3JlZz1PQ1kgbGV2ZWwgKi8KI2RlZmluZSBYSUlDX0lOVFJfQk5CX01BU0sgICAgICAgICAgICAgICAgMHgxMAkvKiAxID0gQnVzIG5vdCBidXN5ICAgICAgICovCiNkZWZpbmUgWElJQ19JTlRSX0FBU19NQVNLICAgICAgICAgICAgICAgIDB4MjAJLyogMSA9IHdoZW4gYWRkciBhcyBzbGF2ZSAqLwojZGVmaW5lIFhJSUNfSU5UUl9OQUFTX01BU0sgICAgICAgICAgICAgICAweDQwCS8qIDEgPSBub3QgYWRkciBhcyBzbGF2ZSAgKi8KI2RlZmluZSBYSUlDX0lOVFJfVFhfSEFMRl9NQVNLICAgICAgICAgICAgMHg4MAkvKiAxID0gVFggRklGTyBoYWxmIGVtcHR5ICovCgovKiBUaGUgZm9sbG93aW5nIGNvbnN0YW50cyBzcGVjaWZ5IHRoZSBkZXB0aCBvZiB0aGUgRklGT3MgKi8KI2RlZmluZSBJSUNfUlhfRklGT19ERVBUSCAgICAgICAgIDE2CS8qIFJ4IGZpZm8gY2FwYWNpdHkgICAgICAgICAgICAgICAqLwojZGVmaW5lIElJQ19UWF9GSUZPX0RFUFRIICAgICAgICAgMTYJLyogVHggZmlmbyBjYXBhY2l0eSAgICAgICAgICAgICAgICovCgovKiBUaGUgZm9sbG93aW5nIGNvbnN0YW50cyBzcGVjaWZ5IGdyb3VwcyBvZiBpbnRlcnJ1cHRzIHRoYXQgYXJlIHR5cGljYWxseQogKiBlbmFibGVkIG9yIGRpc2FibGVzIGF0IHRoZSBzYW1lIHRpbWUKICovCiNkZWZpbmUgWElJQ19UWF9JTlRFUlJVUFRTICAgICAgICAgICAgICAgICAgICAgICAgICAgXAooWElJQ19JTlRSX1RYX0VSUk9SX01BU0sgfCBYSUlDX0lOVFJfVFhfRU1QVFlfTUFTSyB8IFhJSUNfSU5UUl9UWF9IQUxGX01BU0spCgojZGVmaW5lIFhJSUNfVFhfUlhfSU5URVJSVVBUUyAoWElJQ19JTlRSX1JYX0ZVTExfTUFTSyB8IFhJSUNfVFhfSU5URVJSVVBUUykKCi8qIFRoZSBmb2xsb3dpbmcgY29uc3RhbnRzIGFyZSB1c2VkIHdpdGggdGhlIGZvbGxvd2luZyBtYWNyb3MgdG8gc3BlY2lmeSB0aGUKICogb3BlcmF0aW9uLCBhIHJlYWQgb3Igd3JpdGUgb3BlcmF0aW9uLgogKi8KI2RlZmluZSBYSUlDX1JFQURfT1BFUkFUSU9OICAxCiNkZWZpbmUgWElJQ19XUklURV9PUEVSQVRJT04gMAoKLyoKICogVHggRmlmbyB1cHBlciBiaXQgbWFza3MuCiAqLwojZGVmaW5lIFhJSUNfVFhfRFlOX1NUQVJUX01BU0sgICAgICAgICAgICAweDAxMDAgLyogMSA9IFNldCBkeW5hbWljIHN0YXJ0ICovCiNkZWZpbmUgWElJQ19UWF9EWU5fU1RPUF9NQVNLICAgICAgICAgICAgIDB4MDIwMCAvKiAxID0gU2V0IGR5bmFtaWMgc3RvcCAqLwoKLyoKICogVGhlIGZvbGxvd2luZyBjb25zdGFudHMgZGVmaW5lIHRoZSByZWdpc3RlciBvZmZzZXRzIGZvciB0aGUgSW50ZXJydXB0CiAqIHJlZ2lzdGVycy4gVGhlcmUgYXJlIHNvbWUgaG9sZXMgaW4gdGhlIG1lbW9yeSBtYXAgZm9yIHJlc2VydmVkIGFkZHJlc3NlcwogKiB0byBhbGxvdyBvdGhlciByZWdpc3RlcnMgdG8gYmUgYWRkZWQgYW5kIHN0aWxsIG1hdGNoIHRoZSBtZW1vcnkgbWFwIG9mIHRoZQogKiBpbnRlcnJ1cHQgY29udHJvbGxlciByZWdpc3RlcnMKICovCiNkZWZpbmUgWElJQ19ER0lFUl9PRkZTRVQgICAgMHgxQyAvKiBEZXZpY2UgR2xvYmFsIEludGVycnVwdCBFbmFibGUgUmVnaXN0ZXIgKi8KI2RlZmluZSBYSUlDX0lJU1JfT0ZGU0VUICAgICAweDIwIC8qIEludGVycnVwdCBTdGF0dXMgUmVnaXN0ZXIgKi8KI2RlZmluZSBYSUlDX0lJRVJfT0ZGU0VUICAgICAweDI4IC8qIEludGVycnVwdCBFbmFibGUgUmVnaXN0ZXIgKi8KI2RlZmluZSBYSUlDX1JFU0VUUl9PRkZTRVQgICAweDQwIC8qIFJlc2V0IFJlZ2lzdGVyICovCgojZGVmaW5lIFhJSUNfUkVTRVRfTUFTSyAgICAgICAgICAgICAweEFVTAoKLyoKICogVGhlIGZvbGxvd2luZyBjb25zdGFudCBpcyB1c2VkIGZvciB0aGUgZGV2aWNlIGdsb2JhbCBpbnRlcnJ1cHQgZW5hYmxlCiAqIHJlZ2lzdGVyLCB0byBlbmFibGUgYWxsIGludGVycnVwdHMgZm9yIHRoZSBkZXZpY2UsIHRoaXMgaXMgdGhlIG9ubHkgYml0CiAqIGluIHRoZSByZWdpc3RlcgogKi8KI2RlZmluZSBYSUlDX0dJTlRSX0VOQUJMRV9NQVNLICAgICAgMHg4MDAwMDAwMFVMCgojZGVmaW5lIHhpaWNfdHhfc3BhY2UoaTJjKSAoKGkyYyktPnR4X21zZy0+bGVuIC0gKGkyYyktPnR4X3BvcykKI2RlZmluZSB4aWljX3J4X3NwYWNlKGkyYykgKChpMmMpLT5yeF9tc2ctPmxlbiAtIChpMmMpLT5yeF9wb3MpCgpzdGF0aWMgdm9pZCB4aWljX3N0YXJ0X3hmZXIoc3RydWN0IHhpaWNfaTJjICppMmMpOwpzdGF0aWMgdm9pZCBfX3hpaWNfc3RhcnRfeGZlcihzdHJ1Y3QgeGlpY19pMmMgKmkyYyk7CgpzdGF0aWMgaW5saW5lIHZvaWQgeGlpY19zZXRyZWc4KHN0cnVjdCB4aWljX2kyYyAqaTJjLCBpbnQgcmVnLCB1OCB2YWx1ZSkKewoJaW93cml0ZTgodmFsdWUsIGkyYy0+YmFzZSArIHJlZyk7Cn0KCnN0YXRpYyBpbmxpbmUgdTggeGlpY19nZXRyZWc4KHN0cnVjdCB4aWljX2kyYyAqaTJjLCBpbnQgcmVnKQp7CglyZXR1cm4gaW9yZWFkOChpMmMtPmJhc2UgKyByZWcpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgeGlpY19zZXRyZWcxNihzdHJ1Y3QgeGlpY19pMmMgKmkyYywgaW50IHJlZywgdTE2IHZhbHVlKQp7Cglpb3dyaXRlMTYodmFsdWUsIGkyYy0+YmFzZSArIHJlZyk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB4aWljX3NldHJlZzMyKHN0cnVjdCB4aWljX2kyYyAqaTJjLCBpbnQgcmVnLCBpbnQgdmFsdWUpCnsKCWlvd3JpdGUzMih2YWx1ZSwgaTJjLT5iYXNlICsgcmVnKTsKfQoKc3RhdGljIGlubGluZSBpbnQgeGlpY19nZXRyZWczMihzdHJ1Y3QgeGlpY19pMmMgKmkyYywgaW50IHJlZykKewoJcmV0dXJuIGlvcmVhZDMyKGkyYy0+YmFzZSArIHJlZyk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB4aWljX2lycV9kaXMoc3RydWN0IHhpaWNfaTJjICppMmMsIHUzMiBtYXNrKQp7Cgl1MzIgaWVyID0geGlpY19nZXRyZWczMihpMmMsIFhJSUNfSUlFUl9PRkZTRVQpOwoJeGlpY19zZXRyZWczMihpMmMsIFhJSUNfSUlFUl9PRkZTRVQsIGllciAmIH5tYXNrKTsKfQoKc3RhdGljIGlubGluZSB2b2lkIHhpaWNfaXJxX2VuKHN0cnVjdCB4aWljX2kyYyAqaTJjLCB1MzIgbWFzaykKewoJdTMyIGllciA9IHhpaWNfZ2V0cmVnMzIoaTJjLCBYSUlDX0lJRVJfT0ZGU0VUKTsKCXhpaWNfc2V0cmVnMzIoaTJjLCBYSUlDX0lJRVJfT0ZGU0VULCBpZXIgfCBtYXNrKTsKfQoKc3RhdGljIGlubGluZSB2b2lkIHhpaWNfaXJxX2NscihzdHJ1Y3QgeGlpY19pMmMgKmkyYywgdTMyIG1hc2spCnsKCXUzMiBpc3IgPSB4aWljX2dldHJlZzMyKGkyYywgWElJQ19JSVNSX09GRlNFVCk7Cgl4aWljX3NldHJlZzMyKGkyYywgWElJQ19JSVNSX09GRlNFVCwgaXNyICYgbWFzayk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB4aWljX2lycV9jbHJfZW4oc3RydWN0IHhpaWNfaTJjICppMmMsIHUzMiBtYXNrKQp7Cgl4aWljX2lycV9jbHIoaTJjLCBtYXNrKTsKCXhpaWNfaXJxX2VuKGkyYywgbWFzayk7Cn0KCnN0YXRpYyB2b2lkIHhpaWNfY2xlYXJfcnhfZmlmbyhzdHJ1Y3QgeGlpY19pMmMgKmkyYykKewoJdTggc3I7Cglmb3IgKHNyID0geGlpY19nZXRyZWc4KGkyYywgWElJQ19TUl9SRUdfT0ZGU0VUKTsKCQkhKHNyICYgWElJQ19TUl9SWF9GSUZPX0VNUFRZX01BU0spOwoJCXNyID0geGlpY19nZXRyZWc4KGkyYywgWElJQ19TUl9SRUdfT0ZGU0VUKSkKCQl4aWljX2dldHJlZzgoaTJjLCBYSUlDX0RSUl9SRUdfT0ZGU0VUKTsKfQoKc3RhdGljIHZvaWQgeGlpY19yZWluaXQoc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCXhpaWNfc2V0cmVnMzIoaTJjLCBYSUlDX1JFU0VUUl9PRkZTRVQsIFhJSUNfUkVTRVRfTUFTSyk7CgoJLyogU2V0IHJlY2VpdmUgRmlmbyBkZXB0aCB0byBtYXhpbXVtICh6ZXJvIGJhc2VkKS4gKi8KCXhpaWNfc2V0cmVnOChpMmMsIFhJSUNfUkZEX1JFR19PRkZTRVQsIElJQ19SWF9GSUZPX0RFUFRIIC0gMSk7CgoJLyogUmVzZXQgVHggRmlmby4gKi8KCXhpaWNfc2V0cmVnOChpMmMsIFhJSUNfQ1JfUkVHX09GRlNFVCwgWElJQ19DUl9UWF9GSUZPX1JFU0VUX01BU0spOwoKCS8qIEVuYWJsZSBJSUMgRGV2aWNlLCByZW1vdmUgVHggRmlmbyByZXNldCAmIGRpc2FibGUgZ2VuZXJhbCBjYWxsLiAqLwoJeGlpY19zZXRyZWc4KGkyYywgWElJQ19DUl9SRUdfT0ZGU0VULCBYSUlDX0NSX0VOQUJMRV9ERVZJQ0VfTUFTSyk7CgoJLyogbWFrZSBzdXJlIFJYIGZpZm8gaXMgZW1wdHkgKi8KCXhpaWNfY2xlYXJfcnhfZmlmbyhpMmMpOwoKCS8qIEVuYWJsZSBpbnRlcnJ1cHRzICovCgl4aWljX3NldHJlZzMyKGkyYywgWElJQ19ER0lFUl9PRkZTRVQsIFhJSUNfR0lOVFJfRU5BQkxFX01BU0spOwoKCXhpaWNfaXJxX2Nscl9lbihpMmMsIFhJSUNfSU5UUl9BQVNfTUFTSyB8IFhJSUNfSU5UUl9BUkJfTE9TVF9NQVNLKTsKfQoKc3RhdGljIHZvaWQgeGlpY19kZWluaXQoc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCXU4IGNyOwoKCXhpaWNfc2V0cmVnMzIoaTJjLCBYSUlDX1JFU0VUUl9PRkZTRVQsIFhJSUNfUkVTRVRfTUFTSyk7CgoJLyogRGlzYWJsZSBJSUMgRGV2aWNlLiAqLwoJY3IgPSB4aWljX2dldHJlZzgoaTJjLCBYSUlDX0NSX1JFR19PRkZTRVQpOwoJeGlpY19zZXRyZWc4KGkyYywgWElJQ19DUl9SRUdfT0ZGU0VULCBjciAmIH5YSUlDX0NSX0VOQUJMRV9ERVZJQ0VfTUFTSyk7Cn0KCnN0YXRpYyB2b2lkIHhpaWNfcmVhZF9yeChzdHJ1Y3QgeGlpY19pMmMgKmkyYykKewoJdTggYnl0ZXNfaW5fZmlmbzsKCWludCBpOwoKCWJ5dGVzX2luX2ZpZm8gPSB4aWljX2dldHJlZzgoaTJjLCBYSUlDX1JGT19SRUdfT0ZGU0VUKSArIDE7CgoJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGVudHJ5LCBieXRlcyBpbiBmaWZvOiAlZCwgbXNnOiAlZCIKCQkiLCBTUjogMHgleCwgQ1I6IDB4JXhcbiIsCgkJX19mdW5jX18sIGJ5dGVzX2luX2ZpZm8sIHhpaWNfcnhfc3BhY2UoaTJjKSwKCQl4aWljX2dldHJlZzgoaTJjLCBYSUlDX1NSX1JFR19PRkZTRVQpLAoJCXhpaWNfZ2V0cmVnOChpMmMsIFhJSUNfQ1JfUkVHX09GRlNFVCkpOwoKCWlmIChieXRlc19pbl9maWZvID4geGlpY19yeF9zcGFjZShpMmMpKQoJCWJ5dGVzX2luX2ZpZm8gPSB4aWljX3J4X3NwYWNlKGkyYyk7CgoJZm9yIChpID0gMDsgaSA8IGJ5dGVzX2luX2ZpZm87IGkrKykKCQlpMmMtPnJ4X21zZy0+YnVmW2kyYy0+cnhfcG9zKytdID0KCQkJeGlpY19nZXRyZWc4KGkyYywgWElJQ19EUlJfUkVHX09GRlNFVCk7CgoJeGlpY19zZXRyZWc4KGkyYywgWElJQ19SRkRfUkVHX09GRlNFVCwKCQkoeGlpY19yeF9zcGFjZShpMmMpID4gSUlDX1JYX0ZJRk9fREVQVEgpID8KCQlJSUNfUlhfRklGT19ERVBUSCAtIDEgOiAgeGlpY19yeF9zcGFjZShpMmMpIC0gMSk7Cn0KCnN0YXRpYyBpbnQgeGlpY190eF9maWZvX3NwYWNlKHN0cnVjdCB4aWljX2kyYyAqaTJjKQp7CgkvKiByZXR1cm4gdGhlIGFjdHVhbCBzcGFjZSBsZWZ0IGluIHRoZSBGSUZPICovCglyZXR1cm4gSUlDX1RYX0ZJRk9fREVQVEggLSB4aWljX2dldHJlZzgoaTJjLCBYSUlDX1RGT19SRUdfT0ZGU0VUKSAtIDE7Cn0KCnN0YXRpYyB2b2lkIHhpaWNfZmlsbF90eF9maWZvKHN0cnVjdCB4aWljX2kyYyAqaTJjKQp7Cgl1OCBmaWZvX3NwYWNlID0geGlpY190eF9maWZvX3NwYWNlKGkyYyk7CglpbnQgbGVuID0geGlpY190eF9zcGFjZShpMmMpOwoKCWxlbiA9IChsZW4gPiBmaWZvX3NwYWNlKSA/IGZpZm9fc3BhY2UgOiBsZW47CgoJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGVudHJ5LCBsZW46ICVkLCBmaWZvIHNwYWNlOiAlZFxuIiwKCQlfX2Z1bmNfXywgbGVuLCBmaWZvX3NwYWNlKTsKCgl3aGlsZSAobGVuLS0pIHsKCQl1MTYgZGF0YSA9IGkyYy0+dHhfbXNnLT5idWZbaTJjLT50eF9wb3MrK107CgkJaWYgKCh4aWljX3R4X3NwYWNlKGkyYykgPT0gMCkgJiYgKGkyYy0+bm1zZ3MgPT0gMSkpIHsKCQkJLyogbGFzdCBtZXNzYWdlIGluIHRyYW5zZmVyIC0+IFNUT1AgKi8KCQkJZGF0YSB8PSBYSUlDX1RYX0RZTl9TVE9QX01BU0s7CgkJCWRldl9kYmcoaTJjLT5hZGFwLmRldi5wYXJlbnQsICIlcyBUWCBTVE9QXG4iLCBfX2Z1bmNfXyk7CgoJCQl4aWljX3NldHJlZzE2KGkyYywgWElJQ19EVFJfUkVHX09GRlNFVCwgZGF0YSk7CgkJfSBlbHNlCgkJCXhpaWNfc2V0cmVnOChpMmMsIFhJSUNfRFRSX1JFR19PRkZTRVQsIGRhdGEpOwoJfQp9CgpzdGF0aWMgdm9pZCB4aWljX3dha2V1cChzdHJ1Y3QgeGlpY19pMmMgKmkyYywgaW50IGNvZGUpCnsKCWkyYy0+dHhfbXNnID0gTlVMTDsKCWkyYy0+cnhfbXNnID0gTlVMTDsKCWkyYy0+bm1zZ3MgPSAwOwoJaTJjLT5zdGF0ZSA9IGNvZGU7Cgl3YWtlX3VwKCZpMmMtPndhaXQpOwp9CgpzdGF0aWMgdm9pZCB4aWljX3Byb2Nlc3Moc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCXUzMiBwZW5kLCBpc3IsIGllcjsKCXUzMiBjbHIgPSAwOwoKCS8qIEdldCB0aGUgaW50ZXJydXB0IFN0YXR1cyBmcm9tIHRoZSBJUElGLiBUaGVyZSBpcyBubyBjbGVhcmluZyBvZgoJICogaW50ZXJydXB0cyBpbiB0aGUgSVBJRi4gSW50ZXJydXB0cyBtdXN0IGJlIGNsZWFyZWQgYXQgdGhlIHNvdXJjZS4KCSAqIFRvIGZpbmQgd2hpY2ggaW50ZXJydXB0cyBhcmUgcGVuZGluZzsgQU5EIGludGVycnVwdHMgcGVuZGluZyB3aXRoCgkgKiBpbnRlcnJ1cHRzIG1hc2tlZC4KCSAqLwoJaXNyID0geGlpY19nZXRyZWczMihpMmMsIFhJSUNfSUlTUl9PRkZTRVQpOwoJaWVyID0geGlpY19nZXRyZWczMihpMmMsIFhJSUNfSUlFUl9PRkZTRVQpOwoJcGVuZCA9IGlzciAmIGllcjsKCglkZXZfZGJnKGkyYy0+YWRhcC5kZXYucGFyZW50LCAiJXMgZW50cnksIElFUjogMHgleCwgSVNSOiAweCV4LCAiCgkJInBlbmQ6IDB4JXgsIFNSOiAweCV4LCBtc2c6ICVwLCBubXNnczogJWRcbiIsCgkJX19mdW5jX18sIGllciwgaXNyLCBwZW5kLCB4aWljX2dldHJlZzgoaTJjLCBYSUlDX1NSX1JFR19PRkZTRVQpLAoJCWkyYy0+dHhfbXNnLCBpMmMtPm5tc2dzKTsKCgkvKiBEbyBub3QgcHJvY2Vzc2VzIGEgZGV2aWNlcyBpbnRlcnJ1cHRzIGlmIHRoZSBkZXZpY2UgaGFzIG5vCgkgKiBpbnRlcnJ1cHRzIHBlbmRpbmcKCSAqLwoJaWYgKCFwZW5kKQoJCXJldHVybjsKCgkvKiBTZXJ2aWNlIHJlcXVlc3RpbmcgaW50ZXJydXB0ICovCglpZiAoKHBlbmQgJiBYSUlDX0lOVFJfQVJCX0xPU1RfTUFTSykgfHwKCQkoKHBlbmQgJiBYSUlDX0lOVFJfVFhfRVJST1JfTUFTSykgJiYKCQkhKHBlbmQgJiBYSUlDX0lOVFJfUlhfRlVMTF9NQVNLKSkpIHsKCQkvKiBidXMgYXJicml0cmF0aW9uIGxvc3QsIG9yLi4uCgkJICogVHJhbnNtaXQgZXJyb3IgX09SXyBSWCBjb21wbGV0ZWQKCQkgKiBpZiB0aGlzIGhhcHBlbnMgd2hlbiBSWF9GVUxMIGlzIG5vdCBzZXQKCQkgKiB0aGlzIGlzIHByb2JhYmx5IGEgVFggZXJyb3IKCQkgKi8KCgkJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGVycm9yXG4iLCBfX2Z1bmNfXyk7CgoJCS8qIGR5bmFtaWMgbW9kZSBzZWVtIHRvIHN1ZmZlciBmcm9tIHByb2JsZW1zIGlmIHdlIGp1c3QgZmx1c2hlcwoJCSAqIGZpZm9zIGFuZCB0aGUgbmV4dCBtZXNzYWdlIGlzIGEgVFggd2l0aCBsZW4gMCAob25seSBhZGRyKQoJCSAqIHJlc2V0IHRoZSBJUCBpbnN0ZWFkIG9mIGp1c3QgZmx1c2ggZmlmb3MKCQkgKi8KCQl4aWljX3JlaW5pdChpMmMpOwoKCQlpZiAoaTJjLT50eF9tc2cpCgkJCXhpaWNfd2FrZXVwKGkyYywgU1RBVEVfRVJST1IpOwoKCX0gZWxzZSBpZiAocGVuZCAmIFhJSUNfSU5UUl9SWF9GVUxMX01BU0spIHsKCQkvKiBSZWNlaXZlIHJlZ2lzdGVyL0ZJRk8gaXMgZnVsbCAqLwoKCQljbHIgPSBYSUlDX0lOVFJfUlhfRlVMTF9NQVNLOwoJCWlmICghaTJjLT5yeF9tc2cpIHsKCQkJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwKCQkJCSIlcyB1bmV4cGV4dGVkIFJYIElSUVxuIiwgX19mdW5jX18pOwoJCQl4aWljX2NsZWFyX3J4X2ZpZm8oaTJjKTsKCQkJZ290byBvdXQ7CgkJfQoKCQl4aWljX3JlYWRfcngoaTJjKTsKCQlpZiAoeGlpY19yeF9zcGFjZShpMmMpID09IDApIHsKCQkJLyogdGhpcyBpcyB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBtZXNzYWdlICovCgkJCWkyYy0+cnhfbXNnID0gTlVMTDsKCgkJCS8qIGFsc28gY2xlYXIgVFggZXJyb3IgaWYgdGhlcmUgKFJYIGNvbXBsZXRlKSAqLwoJCQljbHIgfD0gKGlzciAmIFhJSUNfSU5UUl9UWF9FUlJPUl9NQVNLKTsKCgkJCWRldl9kYmcoaTJjLT5hZGFwLmRldi5wYXJlbnQsCgkJCQkiJXMgZW5kIG9mIG1lc3NhZ2UsIG5tc2dzOiAlZFxuIiwKCQkJCV9fZnVuY19fLCBpMmMtPm5tc2dzKTsKCgkJCS8qIHNlbmQgbmV4dCBtZXNzYWdlIGlmIHRoaXMgd2Fzbid0IHRoZSBsYXN0LAoJCQkgKiBvdGhlcndpc2UgdGhlIHRyYW5zZmVyIHdpbGwgYmUgZmluaWFsaXNlIHdoZW4KCQkJICogcmVjZWl2aW5nIHRoZSBidXMgbm90IGJ1c3kgaW50ZXJydXB0CgkJCSAqLwoJCQlpZiAoaTJjLT5ubXNncyA+IDEpIHsKCQkJCWkyYy0+bm1zZ3MtLTsKCQkJCWkyYy0+dHhfbXNnKys7CgkJCQlkZXZfZGJnKGkyYy0+YWRhcC5kZXYucGFyZW50LAoJCQkJCSIlcyB3aWxsIHN0YXJ0IG5leHQuLi5cbiIsIF9fZnVuY19fKTsKCgkJCQlfX3hpaWNfc3RhcnRfeGZlcihpMmMpOwoJCQl9CgkJfQoJfSBlbHNlIGlmIChwZW5kICYgWElJQ19JTlRSX0JOQl9NQVNLKSB7CgkJLyogSUlDIGJ1cyBoYXMgdHJhbnNpdGlvbmVkIHRvIG5vdCBidXN5ICovCgkJY2xyID0gWElJQ19JTlRSX0JOQl9NQVNLOwoKCQkvKiBUaGUgYnVzIGlzIG5vdCBidXN5LCBkaXNhYmxlIEJ1c05vdEJ1c3kgaW50ZXJydXB0ICovCgkJeGlpY19pcnFfZGlzKGkyYywgWElJQ19JTlRSX0JOQl9NQVNLKTsKCgkJaWYgKCFpMmMtPnR4X21zZykKCQkJZ290byBvdXQ7CgoJCWlmICgoaTJjLT5ubXNncyA9PSAxKSAmJiAhaTJjLT5yeF9tc2cgJiYKCQkJeGlpY190eF9zcGFjZShpMmMpID09IDApCgkJCXhpaWNfd2FrZXVwKGkyYywgU1RBVEVfRE9ORSk7CgkJZWxzZQoJCQl4aWljX3dha2V1cChpMmMsIFNUQVRFX0VSUk9SKTsKCgl9IGVsc2UgaWYgKHBlbmQgJiAoWElJQ19JTlRSX1RYX0VNUFRZX01BU0sgfCBYSUlDX0lOVFJfVFhfSEFMRl9NQVNLKSkgewoJCS8qIFRyYW5zbWl0IHJlZ2lzdGVyL0ZJRk8gaXMgZW1wdHkgb3IgvSBlbXB0eSAqLwoKCQljbHIgPSBwZW5kICYKCQkJKFhJSUNfSU5UUl9UWF9FTVBUWV9NQVNLIHwgWElJQ19JTlRSX1RYX0hBTEZfTUFTSyk7CgoJCWlmICghaTJjLT50eF9tc2cpIHsKCQkJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwKCQkJCSIlcyB1bmV4cGV4dGVkIFRYIElSUVxuIiwgX19mdW5jX18pOwoJCQlnb3RvIG91dDsKCQl9CgoJCXhpaWNfZmlsbF90eF9maWZvKGkyYyk7CgoJCS8qIGN1cnJlbnQgbWVzc2FnZSBzZW50IGFuZCB0aGVyZSBpcyBzcGFjZSBpbiB0aGUgZmlmbyAqLwoJCWlmICgheGlpY190eF9zcGFjZShpMmMpICYmIHhpaWNfdHhfZmlmb19zcGFjZShpMmMpID49IDIpIHsKCQkJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwKCQkJCSIlcyBlbmQgb2YgbWVzc2FnZSBzZW50LCBubXNnczogJWRcbiIsCgkJCQlfX2Z1bmNfXywgaTJjLT5ubXNncyk7CgkJCWlmIChpMmMtPm5tc2dzID4gMSkgewoJCQkJaTJjLT5ubXNncy0tOwoJCQkJaTJjLT50eF9tc2crKzsKCQkJCV9feGlpY19zdGFydF94ZmVyKGkyYyk7CgkJCX0gZWxzZSB7CgkJCQl4aWljX2lycV9kaXMoaTJjLCBYSUlDX0lOVFJfVFhfSEFMRl9NQVNLKTsKCgkJCQlkZXZfZGJnKGkyYy0+YWRhcC5kZXYucGFyZW50LAoJCQkJCSIlcyBHb3QgVFggSVJRIGJ1dCBubyBtb3JlIHRvIGRvLi4uXG4iLAoJCQkJCV9fZnVuY19fKTsKCQkJfQoJCX0gZWxzZSBpZiAoIXhpaWNfdHhfc3BhY2UoaTJjKSAmJiAoaTJjLT5ubXNncyA9PSAxKSkKCQkJLyogY3VycmVudCBmcmFtZSBpcyBzZW50IGFuZCBpcyBsYXN0LAoJCQkgKiBtYWtlIHN1cmUgdG8gZGlzYWJsZSB0eCBoYWxmCgkJCSAqLwoJCQl4aWljX2lycV9kaXMoaTJjLCBYSUlDX0lOVFJfVFhfSEFMRl9NQVNLKTsKCX0gZWxzZSB7CgkJLyogZ290IElSUSB3aGljaCBpcyBub3QgYWNrZWQgKi8KCQlkZXZfZXJyKGkyYy0+YWRhcC5kZXYucGFyZW50LCAiJXMgR290IHVuZXhwZWN0ZWQgSVJRXG4iLAoJCQlfX2Z1bmNfXyk7CgkJY2xyID0gcGVuZDsKCX0Kb3V0OgoJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGNscjogMHgleFxuIiwgX19mdW5jX18sIGNscik7CgoJeGlpY19zZXRyZWczMihpMmMsIFhJSUNfSUlTUl9PRkZTRVQsIGNscik7Cn0KCnN0YXRpYyBpbnQgeGlpY19idXNfYnVzeShzdHJ1Y3QgeGlpY19pMmMgKmkyYykKewoJdTggc3IgPSB4aWljX2dldHJlZzgoaTJjLCBYSUlDX1NSX1JFR19PRkZTRVQpOwoKCXJldHVybiAoc3IgJiBYSUlDX1NSX0JVU19CVVNZX01BU0spID8gLUVCVVNZIDogMDsKfQoKc3RhdGljIGludCB4aWljX2J1c3koc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCWludCB0cmllcyA9IDM7CglpbnQgZXJyOwoKCWlmIChpMmMtPnR4X21zZykKCQlyZXR1cm4gLUVCVVNZOwoKCS8qIGZvciBpbnN0YW5jZSBpZiBwcmV2aW91cyB0cmFuc2ZlciB3YXMgdGVybWluYXRlZCBkdWUgdG8gVFggZXJyb3IKCSAqIGl0IG1pZ2h0IGJlIHRoYXQgdGhlIGJ1cyBpcyBvbiBpdCdzIHdheSB0byBiZWNvbWUgYXZhaWxhYmxlCgkgKiBnaXZlIGl0IGF0IG1vc3QgMyBtcyB0byB3YWtlCgkgKi8KCWVyciA9IHhpaWNfYnVzX2J1c3koaTJjKTsKCXdoaWxlIChlcnIgJiYgdHJpZXMtLSkgewoJCW1kZWxheSgxKTsKCQllcnIgPSB4aWljX2J1c19idXN5KGkyYyk7Cgl9CgoJcmV0dXJuIGVycjsKfQoKc3RhdGljIHZvaWQgeGlpY19zdGFydF9yZWN2KHN0cnVjdCB4aWljX2kyYyAqaTJjKQp7Cgl1OCByeF93YXRlcm1hcms7CglzdHJ1Y3QgaTJjX21zZyAqbXNnID0gaTJjLT5yeF9tc2cgPSBpMmMtPnR4X21zZzsKCgkvKiBDbGVhciBhbmQgZW5hYmxlIFJ4IGZ1bGwgaW50ZXJydXB0LiAqLwoJeGlpY19pcnFfY2xyX2VuKGkyYywgWElJQ19JTlRSX1JYX0ZVTExfTUFTSyB8IFhJSUNfSU5UUl9UWF9FUlJPUl9NQVNLKTsKCgkvKiB3ZSB3YW50IHRvIGdldCBhbGwgYnV0IGxhc3QgYnl0ZSwgYmVjYXVzZSB0aGUgVFhfRVJST1IgSVJRIGlzIHVzZWQKCSAqIHRvIGluaWRpY2F0ZSBlcnJvciBBQ0sgb24gdGhlIGFkZHJlc3MsIGFuZCBuZWdhdGl2ZSBhY2sgb24gdGhlIGxhc3QKCSAqIHJlY2VpdmVkIGJ5dGUsIHNvIHRvIG5vdCBtaXggdGhlbSByZWNlaXZlIGFsbCBidXQgbGFzdC4KCSAqIEluIHRoZSBjYXNlIHdoZXJlIHRoZXJlIGlzIG9ubHkgb25lIGJ5dGUgdG8gcmVjZWl2ZQoJICogd2UgY2FuIGNoZWNrIGlmIEVSUk9SIGFuZCBSWCBmdWxsIGlzIHNldCBhdCB0aGUgc2FtZSB0aW1lCgkgKi8KCXJ4X3dhdGVybWFyayA9IG1zZy0+bGVuOwoJaWYgKHJ4X3dhdGVybWFyayA+IElJQ19SWF9GSUZPX0RFUFRIKQoJCXJ4X3dhdGVybWFyayA9IElJQ19SWF9GSUZPX0RFUFRIOwoJeGlpY19zZXRyZWc4KGkyYywgWElJQ19SRkRfUkVHX09GRlNFVCwgcnhfd2F0ZXJtYXJrIC0gMSk7CgoJaWYgKCEobXNnLT5mbGFncyAmIEkyQ19NX05PU1RBUlQpKQoJCS8qIHdyaXRlIHRoZSBhZGRyZXNzICovCgkJeGlpY19zZXRyZWcxNihpMmMsIFhJSUNfRFRSX1JFR19PRkZTRVQsCgkJCShtc2ctPmFkZHIgPDwgMSkgfCBYSUlDX1JFQURfT1BFUkFUSU9OIHwKCQkJWElJQ19UWF9EWU5fU1RBUlRfTUFTSyk7CgoJeGlpY19pcnFfY2xyX2VuKGkyYywgWElJQ19JTlRSX0JOQl9NQVNLKTsKCgl4aWljX3NldHJlZzE2KGkyYywgWElJQ19EVFJfUkVHX09GRlNFVCwKCQltc2ctPmxlbiB8ICgoaTJjLT5ubXNncyA9PSAxKSA/IFhJSUNfVFhfRFlOX1NUT1BfTUFTSyA6IDApKTsKCWlmIChpMmMtPm5tc2dzID09IDEpCgkJLyogdmVyeSBsYXN0LCBlbmFibGUgYnVzIG5vdCBidXN5IGFzIHdlbGwgKi8KCQl4aWljX2lycV9jbHJfZW4oaTJjLCBYSUlDX0lOVFJfQk5CX01BU0spOwoKCS8qIHRoZSBtZXNzYWdlIGlzIHR4OmVkICovCglpMmMtPnR4X3BvcyA9IG1zZy0+bGVuOwp9CgpzdGF0aWMgdm9pZCB4aWljX3N0YXJ0X3NlbmQoc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCXN0cnVjdCBpMmNfbXNnICptc2cgPSBpMmMtPnR4X21zZzsKCgl4aWljX2lycV9jbHIoaTJjLCBYSUlDX0lOVFJfVFhfRVJST1JfTUFTSyk7CgoJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGVudHJ5LCBtc2c6ICVwLCBsZW46ICVkLCAiCgkJIklTUjogMHgleCwgQ1I6IDB4JXhcbiIsCgkJX19mdW5jX18sIG1zZywgbXNnLT5sZW4sIHhpaWNfZ2V0cmVnMzIoaTJjLCBYSUlDX0lJU1JfT0ZGU0VUKSwKCQl4aWljX2dldHJlZzgoaTJjLCBYSUlDX0NSX1JFR19PRkZTRVQpKTsKCglpZiAoIShtc2ctPmZsYWdzICYgSTJDX01fTk9TVEFSVCkpIHsKCQkvKiB3cml0ZSB0aGUgYWRkcmVzcyAqLwoJCXUxNiBkYXRhID0gKChtc2ctPmFkZHIgPDwgMSkgJiAweGZlKSB8IFhJSUNfV1JJVEVfT1BFUkFUSU9OIHwKCQkJWElJQ19UWF9EWU5fU1RBUlRfTUFTSzsKCQlpZiAoKGkyYy0+bm1zZ3MgPT0gMSkgJiYgbXNnLT5sZW4gPT0gMCkKCQkJLyogbm8gZGF0YSBhbmQgbGFzdCBtZXNzYWdlIC0+IGFkZCBTVE9QICovCgkJCWRhdGEgfD0gWElJQ19UWF9EWU5fU1RPUF9NQVNLOwoKCQl4aWljX3NldHJlZzE2KGkyYywgWElJQ19EVFJfUkVHX09GRlNFVCwgZGF0YSk7Cgl9CgoJeGlpY19maWxsX3R4X2ZpZm8oaTJjKTsKCgkvKiBDbGVhciBhbnkgcGVuZGluZyBUeCBlbXB0eSwgVHggRXJyb3IgYW5kIHRoZW4gZW5hYmxlIHRoZW0uICovCgl4aWljX2lycV9jbHJfZW4oaTJjLCBYSUlDX0lOVFJfVFhfRU1QVFlfTUFTSyB8IFhJSUNfSU5UUl9UWF9FUlJPUl9NQVNLIHwKCQlYSUlDX0lOVFJfQk5CX01BU0spOwp9CgpzdGF0aWMgaXJxcmV0dXJuX3QgeGlpY19pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKQp7CglzdHJ1Y3QgeGlpY19pMmMgKmkyYyA9IGRldl9pZDsKCglzcGluX2xvY2soJmkyYy0+bG9jayk7CgkvKiBkaXNhYmxlIGludGVycnVwdHMgZ2xvYmFsbHkgKi8KCXhpaWNfc2V0cmVnMzIoaTJjLCBYSUlDX0RHSUVSX09GRlNFVCwgMCk7CgoJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGVudHJ5XG4iLCBfX2Z1bmNfXyk7CgoJeGlpY19wcm9jZXNzKGkyYyk7CgoJeGlpY19zZXRyZWczMihpMmMsIFhJSUNfREdJRVJfT0ZGU0VULCBYSUlDX0dJTlRSX0VOQUJMRV9NQVNLKTsKCXNwaW5fdW5sb2NrKCZpMmMtPmxvY2spOwoKCXJldHVybiBJUlFfSEFORExFRDsKfQoKc3RhdGljIHZvaWQgX194aWljX3N0YXJ0X3hmZXIoc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCWludCBmaXJzdCA9IDE7CglpbnQgZmlmb19zcGFjZSA9IHhpaWNfdHhfZmlmb19zcGFjZShpMmMpOwoJZGV2X2RiZyhpMmMtPmFkYXAuZGV2LnBhcmVudCwgIiVzIGVudHJ5LCBtc2c6ICVwLCBmaWZvcyBzcGFjZTogJWRcbiIsCgkJX19mdW5jX18sIGkyYy0+dHhfbXNnLCBmaWZvX3NwYWNlKTsKCglpZiAoIWkyYy0+dHhfbXNnKQoJCXJldHVybjsKCglpMmMtPnJ4X3BvcyA9IDA7CglpMmMtPnR4X3BvcyA9IDA7CglpMmMtPnN0YXRlID0gU1RBVEVfU1RBUlQ7Cgl3aGlsZSAoKGZpZm9fc3BhY2UgPj0gMikgJiYgKGZpcnN0IHx8IChpMmMtPm5tc2dzID4gMSkpKSB7CgkJaWYgKCFmaXJzdCkgewoJCQlpMmMtPm5tc2dzLS07CgkJCWkyYy0+dHhfbXNnKys7CgkJCWkyYy0+dHhfcG9zID0gMDsKCQl9IGVsc2UKCQkJZmlyc3QgPSAwOwoKCQlpZiAoaTJjLT50eF9tc2ctPmZsYWdzICYgSTJDX01fUkQpIHsKCQkJLyogd2UgZG9udCBkYXRlIHB1dHRpbmcgc2V2ZXJhbCByZWFkcyBpbiB0aGUgRklGTyAqLwoJCQl4aWljX3N0YXJ0X3JlY3YoaTJjKTsKCQkJcmV0dXJuOwoJCX0gZWxzZSB7CgkJCXhpaWNfc3RhcnRfc2VuZChpMmMpOwoJCQlpZiAoeGlpY190eF9zcGFjZShpMmMpICE9IDApIHsKCQkJCS8qIHRoZSBtZXNzYWdlIGNvdWxkIG5vdCBiZSBjb21wbGV0ZWx5IHNlbnQgKi8KCQkJCWJyZWFrOwoJCQl9CgkJfQoKCQlmaWZvX3NwYWNlID0geGlpY190eF9maWZvX3NwYWNlKGkyYyk7Cgl9CgoJLyogdGhlcmUgYXJlIG1vcmUgbWVzc2FnZXMgb3IgdGhlIGN1cnJlbnQgb25lIGNvdWxkIG5vdCBiZSBjb21wbGV0ZWx5CgkgKiBwdXQgaW50byB0aGUgRklGTywgYWxzbyBlbmFibGUgdGhlIGhhbGYgZW1wdHkgaW50ZXJydXB0CgkgKi8KCWlmIChpMmMtPm5tc2dzID4gMSB8fCB4aWljX3R4X3NwYWNlKGkyYykpCgkJeGlpY19pcnFfY2xyX2VuKGkyYywgWElJQ19JTlRSX1RYX0hBTEZfTUFTSyk7Cgp9CgpzdGF0aWMgdm9pZCB4aWljX3N0YXJ0X3hmZXIoc3RydWN0IHhpaWNfaTJjICppMmMpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmkyYy0+bG9jaywgZmxhZ3MpOwoJeGlpY19yZWluaXQoaTJjKTsKCS8qIGRpc2FibGUgaW50ZXJydXB0cyBnbG9iYWxseSAqLwoJeGlpY19zZXRyZWczMihpMmMsIFhJSUNfREdJRVJfT0ZGU0VULCAwKTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmkyYy0+bG9jaywgZmxhZ3MpOwoKCV9feGlpY19zdGFydF94ZmVyKGkyYyk7Cgl4aWljX3NldHJlZzMyKGkyYywgWElJQ19ER0lFUl9PRkZTRVQsIFhJSUNfR0lOVFJfRU5BQkxFX01BU0spOwp9CgpzdGF0aWMgaW50IHhpaWNfeGZlcihzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXAsIHN0cnVjdCBpMmNfbXNnICptc2dzLCBpbnQgbnVtKQp7CglzdHJ1Y3QgeGlpY19pMmMgKmkyYyA9IGkyY19nZXRfYWRhcGRhdGEoYWRhcCk7CglpbnQgZXJyOwoKCWRldl9kYmcoYWRhcC0+ZGV2LnBhcmVudCwgIiVzIGVudHJ5IFNSOiAweCV4XG4iLCBfX2Z1bmNfXywKCQl4aWljX2dldHJlZzgoaTJjLCBYSUlDX1NSX1JFR19PRkZTRVQpKTsKCgllcnIgPSB4aWljX2J1c3koaTJjKTsKCWlmIChlcnIpCgkJcmV0dXJuIGVycjsKCglpMmMtPnR4X21zZyA9IG1zZ3M7CglpMmMtPm5tc2dzID0gbnVtOwoKCXhpaWNfc3RhcnRfeGZlcihpMmMpOwoKCWlmICh3YWl0X2V2ZW50X3RpbWVvdXQoaTJjLT53YWl0LCAoaTJjLT5zdGF0ZSA9PSBTVEFURV9FUlJPUikgfHwKCQkoaTJjLT5zdGF0ZSA9PSBTVEFURV9ET05FKSwgSFopKQoJCXJldHVybiAoaTJjLT5zdGF0ZSA9PSBTVEFURV9ET05FKSA/IG51bSA6IC1FSU87CgllbHNlIHsKCQlpMmMtPnR4X21zZyA9IE5VTEw7CgkJaTJjLT5yeF9tc2cgPSBOVUxMOwoJCWkyYy0+bm1zZ3MgPSAwOwoJCXJldHVybiAtRVRJTUVET1VUOwoJfQp9CgpzdGF0aWMgdTMyIHhpaWNfZnVuYyhzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXApCnsKCXJldHVybiBJMkNfRlVOQ19JMkMgfCBJMkNfRlVOQ19TTUJVU19FTVVMOwp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19hbGdvcml0aG0geGlpY19hbGdvcml0aG0gPSB7CgkubWFzdGVyX3hmZXIJPSB4aWljX3hmZXIsCgkuZnVuY3Rpb25hbGl0eQk9IHhpaWNfZnVuYywKfTsKCnN0YXRpYyBzdHJ1Y3QgaTJjX2FkYXB0ZXIgeGlpY19hZGFwdGVyID0gewoJLm93bmVyCQk9IFRISVNfTU9EVUxFLAoJLm5hbWUJCT0gRFJJVkVSX05BTUUsCgkuY2xhc3MJCT0gSTJDX0NMQVNTX0hXTU9OIHwgSTJDX0NMQVNTX1NQRCwKCS5hbGdvCQk9ICZ4aWljX2FsZ29yaXRobSwKfTsKCgpzdGF0aWMgaW50IF9fZGV2aW5pdCB4aWljX2kyY19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQp7CglzdHJ1Y3QgeGlpY19pMmMgKmkyYzsKCXN0cnVjdCB4aWljX2kyY19wbGF0Zm9ybV9kYXRhICpwZGF0YTsKCXN0cnVjdCByZXNvdXJjZSAqcmVzOwoJaW50IHJldCwgaXJxOwoJdTggaTsKCglyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOwoJaWYgKCFyZXMpCgkJZ290byByZXNvdXJjZV9taXNzaW5nOwoKCWlycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwgMCk7CglpZiAoaXJxIDwgMCkKCQlnb3RvIHJlc291cmNlX21pc3Npbmc7CgoJcGRhdGEgPSAoc3RydWN0IHhpaWNfaTJjX3BsYXRmb3JtX2RhdGEgKikgcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7CglpZiAoIXBkYXRhKQoJCXJldHVybiAtRUlOVkFMOwoKCWkyYyA9IGt6YWxsb2Moc2l6ZW9mKCppMmMpLCBHRlBfS0VSTkVMKTsKCWlmICghaTJjKQoJCXJldHVybiAtRU5PTUVNOwoKCWlmICghcmVxdWVzdF9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSwgcGRldi0+bmFtZSkpIHsKCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJNZW1vcnkgcmVnaW9uIGJ1c3lcbiIpOwoJCXJldCA9IC1FQlVTWTsKCQlnb3RvIHJlcXVlc3RfbWVtX2ZhaWxlZDsKCX0KCglpMmMtPmJhc2UgPSBpb3JlbWFwKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSk7CglpZiAoIWkyYy0+YmFzZSkgewoJCWRldl9lcnIoJnBkZXYtPmRldiwgIlVuYWJsZSB0byBtYXAgcmVnaXN0ZXJzXG4iKTsKCQlyZXQgPSAtRUlPOwoJCWdvdG8gbWFwX2ZhaWxlZDsKCX0KCgkvKiBob29rIHVwIGRyaXZlciB0byB0cmVlICovCglwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBpMmMpOwoJaTJjLT5hZGFwID0geGlpY19hZGFwdGVyOwoJaTJjX3NldF9hZGFwZGF0YSgmaTJjLT5hZGFwLCBpMmMpOwoJaTJjLT5hZGFwLmRldi5wYXJlbnQgPSAmcGRldi0+ZGV2OwoKCXhpaWNfcmVpbml0KGkyYyk7CgoJc3Bpbl9sb2NrX2luaXQoJmkyYy0+bG9jayk7Cglpbml0X3dhaXRxdWV1ZV9oZWFkKCZpMmMtPndhaXQpOwoJcmV0ID0gcmVxdWVzdF9pcnEoaXJxLCB4aWljX2lzciwgMCwgcGRldi0+bmFtZSwgaTJjKTsKCWlmIChyZXQpIHsKCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJDYW5ub3QgY2xhaW0gSVJRXG4iKTsKCQlnb3RvIHJlcXVlc3RfaXJxX2ZhaWxlZDsKCX0KCgkvKiBhZGQgaTJjIGFkYXB0ZXIgdG8gaTJjIHRyZWUgKi8KCXJldCA9IGkyY19hZGRfYWRhcHRlcigmaTJjLT5hZGFwKTsKCWlmIChyZXQpIHsKCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8gYWRkIGFkYXB0ZXJcbiIpOwoJCWdvdG8gYWRkX2FkYXB0ZXJfZmFpbGVkOwoJfQoKCS8qIGFkZCBpbiBrbm93biBkZXZpY2VzIHRvIHRoZSBidXMgKi8KCWZvciAoaSA9IDA7IGkgPCBwZGF0YS0+bnVtX2RldmljZXM7IGkrKykKCQlpMmNfbmV3X2RldmljZSgmaTJjLT5hZGFwLCBwZGF0YS0+ZGV2aWNlcyArIGkpOwoKCXJldHVybiAwOwoKYWRkX2FkYXB0ZXJfZmFpbGVkOgoJZnJlZV9pcnEoaXJxLCBpMmMpOwpyZXF1ZXN0X2lycV9mYWlsZWQ6Cgl4aWljX2RlaW5pdChpMmMpOwoJaW91bm1hcChpMmMtPmJhc2UpOwptYXBfZmFpbGVkOgoJcmVsZWFzZV9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSk7CnJlcXVlc3RfbWVtX2ZhaWxlZDoKCWtmcmVlKGkyYyk7CgoJcmV0dXJuIHJldDsKcmVzb3VyY2VfbWlzc2luZzoKCWRldl9lcnIoJnBkZXYtPmRldiwgIklSUSBvciBNZW1vcnkgcmVzb3VyY2UgaXMgbWlzc2luZ1xuIik7CglyZXR1cm4gLUVOT0VOVDsKfQoKc3RhdGljIGludCBfX2RldmV4aXQgeGlpY19pMmNfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UqIHBkZXYpCnsKCXN0cnVjdCB4aWljX2kyYyAqaTJjID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CglzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKCgkvKiByZW1vdmUgYWRhcHRlciAmIGRhdGEgKi8KCWkyY19kZWxfYWRhcHRlcigmaTJjLT5hZGFwKTsKCgl4aWljX2RlaW5pdChpMmMpOwoKCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIE5VTEwpOwoKCWZyZWVfaXJxKHBsYXRmb3JtX2dldF9pcnEocGRldiwgMCksIGkyYyk7CgoJaW91bm1hcChpMmMtPmJhc2UpOwoKCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CglpZiAocmVzKQoJCXJlbGVhc2VfbWVtX3JlZ2lvbihyZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcykpOwoKCWtmcmVlKGkyYyk7CgoJcmV0dXJuIDA7Cn0KCgovKiB3b3JrIHdpdGggaG90cGx1ZyBhbmQgY29sZHBsdWcgKi8KTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybToiRFJJVkVSX05BTUUpOwoKc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgeGlpY19pMmNfZHJpdmVyID0gewoJLnByb2JlICAgPSB4aWljX2kyY19wcm9iZSwKCS5yZW1vdmUgID0gX19kZXZleGl0X3AoeGlpY19pMmNfcmVtb3ZlKSwKCS5kcml2ZXIgID0gewoJCS5vd25lciA9IFRISVNfTU9EVUxFLAoJCS5uYW1lID0gRFJJVkVSX05BTUUsCgl9LAp9OwoKc3RhdGljIGludCBfX2luaXQgeGlpY19pMmNfaW5pdCh2b2lkKQp7CglyZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZ4aWljX2kyY19kcml2ZXIpOwp9CgpzdGF0aWMgdm9pZCBfX2V4aXQgeGlpY19pMmNfZXhpdCh2b2lkKQp7CglwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmeGlpY19pMmNfZHJpdmVyKTsKfQoKbW9kdWxlX2luaXQoeGlpY19pMmNfaW5pdCk7Cm1vZHVsZV9leGl0KHhpaWNfaTJjX2V4aXQpOwoKTU9EVUxFX0FVVEhPUigiaW5mb0Btb2NlYW4tbGFicy5jb20iKTsKTU9EVUxFX0RFU0NSSVBUSU9OKCJYaWxpbnggSTJDIGJ1cyBkcml2ZXIiKTsKTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo=