LyogaTJjLWNvcmUuYyAtIGEgZGV2aWNlIGRyaXZlciBmb3IgdGhlIGlpYy1idXMgaW50ZXJmYWNlCQkgICAgICovCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLyogICBDb3B5cmlnaHQgKEMpIDE5OTUtOTkgU2ltb24gRy4gVm9nbAoKICAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQogICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCgogICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQogICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KCiAgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQogICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICAgIEZvdW5kYXRpb24sIEluYy4sIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgkJICAgICAqLwovKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCgovKiBXaXRoIHNvbWUgY2hhbmdlcyBmcm9tIEt59nN0aSBN5Gxra2kgPGttYWxra2lAY2MuaHV0LmZpPi4KICAgQWxsIFNNQnVzLXJlbGF0ZWQgdGhpbmdzIGFyZSB3cml0dGVuIGJ5IEZyb2RvIExvb2lqYWFyZCA8ZnJvZG9sQGRkcy5ubD4KICAgU01CdXMgMi4wIHN1cHBvcnQgYnkgTWFyayBTdHVkZWJha2VyIDxtZHN4eXoxMjNAeWFob28uY29tPiBhbmQKICAgSmVhbiBEZWx2YXJlIDxraGFsaUBsaW51eC1mci5vcmc+ICovCgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiNpbmNsdWRlIDxsaW51eC9pMmMuaD4KI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KI2luY2x1ZGUgPGxpbnV4L2lkci5oPgojaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgojaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KI2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4KI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CgojaW5jbHVkZSAiaTJjLWNvcmUuaCIKCgpzdGF0aWMgTElTVF9IRUFEKGFkYXB0ZXJzKTsKc3RhdGljIExJU1RfSEVBRChkcml2ZXJzKTsKc3RhdGljIERFRklORV9NVVRFWChjb3JlX2xpc3RzKTsKc3RhdGljIERFRklORV9JRFIoaTJjX2FkYXB0ZXJfaWRyKTsKCiNkZWZpbmUgaXNfbmV3c3R5bGVfZHJpdmVyKGQpICgoZCktPnByb2JlIHx8IChkKS0+cmVtb3ZlKQoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIGludCBpMmNfZGV2aWNlX21hdGNoKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9kcml2ZXIgKmRydikKewoJc3RydWN0IGkyY19jbGllbnQJKmNsaWVudCA9IHRvX2kyY19jbGllbnQoZGV2KTsKCXN0cnVjdCBpMmNfZHJpdmVyCSpkcml2ZXIgPSB0b19pMmNfZHJpdmVyKGRydik7CgoJLyogbWFrZSBsZWdhY3kgaTJjIGRyaXZlcnMgYnlwYXNzIGRyaXZlciBtb2RlbCBwcm9iaW5nIGVudGlyZWx5OwoJICogc3VjaCBkcml2ZXJzIHNjYW4gZWFjaCBpMmMgYWRhcHRlci9idXMgdGhlbXNlbHZlcy4KCSAqLwoJaWYgKCFpc19uZXdzdHlsZV9kcml2ZXIoZHJpdmVyKSkKCQlyZXR1cm4gMDsKCgkvKiBuZXcgc3R5bGUgZHJpdmVycyB1c2UgdGhlIHNhbWUga2luZCBvZiBkcml2ZXIgbWF0Y2hpbmcgcG9saWN5CgkgKiBhcyBwbGF0Zm9ybSBkZXZpY2VzIG9yIFNQSTogIGNvbXBhcmUgZGV2aWNlIGFuZCBkcml2ZXIgSURzLgoJICovCglyZXR1cm4gc3RyY21wKGNsaWVudC0+ZHJpdmVyX25hbWUsIGRydi0+bmFtZSkgPT0gMDsKfQoKI2lmZGVmCUNPTkZJR19IT1RQTFVHCgovKiB1ZXZlbnQgaGVscHMgd2l0aCBob3RwbHVnOiBtb2Rwcm9iZSAtcSAkKE1PREFMSUFTKSAqLwpzdGF0aWMgaW50IGkyY19kZXZpY2VfdWV2ZW50KHN0cnVjdCBkZXZpY2UgKmRldiwgY2hhciAqKmVudnAsIGludCBudW1fZW52cCwKCQkgICAgICBjaGFyICpidWZmZXIsIGludCBidWZmZXJfc2l6ZSkKewoJc3RydWN0IGkyY19jbGllbnQJKmNsaWVudCA9IHRvX2kyY19jbGllbnQoZGV2KTsKCWludAkJCWkgPSAwLCBsZW5ndGggPSAwOwoKCS8qIGJ5IGRlZmluaXRpb24sIGxlZ2FjeSBkcml2ZXJzIGNhbid0IGhvdHBsdWcgKi8KCWlmIChkZXYtPmRyaXZlciB8fCAhY2xpZW50LT5kcml2ZXJfbmFtZSkKCQlyZXR1cm4gMDsKCglpZiAoYWRkX3VldmVudF92YXIoZW52cCwgbnVtX2VudnAsICZpLCBidWZmZXIsIGJ1ZmZlcl9zaXplLCAmbGVuZ3RoLAoJCQkiTU9EQUxJQVM9JXMiLCBjbGllbnQtPmRyaXZlcl9uYW1lKSkKCQlyZXR1cm4gLUVOT01FTTsKCWVudnBbaV0gPSBOVUxMOwoJZGV2X2RiZyhkZXYsICJ1ZXZlbnRcbiIpOwoJcmV0dXJuIDA7Cn0KCiNlbHNlCiNkZWZpbmUgaTJjX2RldmljZV91ZXZlbnQJTlVMTAojZW5kaWYJLyogQ09ORklHX0hPVFBMVUcgKi8KCnN0YXRpYyBpbnQgaTJjX2RldmljZV9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBpMmNfY2xpZW50CSpjbGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7CglzdHJ1Y3QgaTJjX2RyaXZlcgkqZHJpdmVyID0gdG9faTJjX2RyaXZlcihkZXYtPmRyaXZlcik7CgoJaWYgKCFkcml2ZXItPnByb2JlKQoJCXJldHVybiAtRU5PREVWOwoJY2xpZW50LT5kcml2ZXIgPSBkcml2ZXI7CglkZXZfZGJnKGRldiwgInByb2JlXG4iKTsKCXJldHVybiBkcml2ZXItPnByb2JlKGNsaWVudCk7Cn0KCnN0YXRpYyBpbnQgaTJjX2RldmljZV9yZW1vdmUoc3RydWN0IGRldmljZSAqZGV2KQp7CglzdHJ1Y3QgaTJjX2NsaWVudAkqY2xpZW50ID0gdG9faTJjX2NsaWVudChkZXYpOwoJc3RydWN0IGkyY19kcml2ZXIJKmRyaXZlcjsKCWludAkJCXN0YXR1czsKCglpZiAoIWRldi0+ZHJpdmVyKQoJCXJldHVybiAwOwoKCWRyaXZlciA9IHRvX2kyY19kcml2ZXIoZGV2LT5kcml2ZXIpOwoJaWYgKGRyaXZlci0+cmVtb3ZlKSB7CgkJZGV2X2RiZyhkZXYsICJyZW1vdmVcbiIpOwoJCXN0YXR1cyA9IGRyaXZlci0+cmVtb3ZlKGNsaWVudCk7Cgl9IGVsc2UgewoJCWRldi0+ZHJpdmVyID0gTlVMTDsKCQlzdGF0dXMgPSAwOwoJfQoJaWYgKHN0YXR1cyA9PSAwKQoJCWNsaWVudC0+ZHJpdmVyID0gTlVMTDsKCXJldHVybiBzdGF0dXM7Cn0KCnN0YXRpYyB2b2lkIGkyY19kZXZpY2Vfc2h1dGRvd24oc3RydWN0IGRldmljZSAqZGV2KQp7CglzdHJ1Y3QgaTJjX2RyaXZlciAqZHJpdmVyOwoKCWlmICghZGV2LT5kcml2ZXIpCgkJcmV0dXJuOwoJZHJpdmVyID0gdG9faTJjX2RyaXZlcihkZXYtPmRyaXZlcik7CglpZiAoZHJpdmVyLT5zaHV0ZG93bikKCQlkcml2ZXItPnNodXRkb3duKHRvX2kyY19jbGllbnQoZGV2KSk7Cn0KCnN0YXRpYyBpbnQgaTJjX2RldmljZV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKiBkZXYsIHBtX21lc3NhZ2VfdCBtZXNnKQp7CglzdHJ1Y3QgaTJjX2RyaXZlciAqZHJpdmVyOwoKCWlmICghZGV2LT5kcml2ZXIpCgkJcmV0dXJuIDA7Cglkcml2ZXIgPSB0b19pMmNfZHJpdmVyKGRldi0+ZHJpdmVyKTsKCWlmICghZHJpdmVyLT5zdXNwZW5kKQoJCXJldHVybiAwOwoJcmV0dXJuIGRyaXZlci0+c3VzcGVuZCh0b19pMmNfY2xpZW50KGRldiksIG1lc2cpOwp9CgpzdGF0aWMgaW50IGkyY19kZXZpY2VfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKiBkZXYpCnsKCXN0cnVjdCBpMmNfZHJpdmVyICpkcml2ZXI7CgoJaWYgKCFkZXYtPmRyaXZlcikKCQlyZXR1cm4gMDsKCWRyaXZlciA9IHRvX2kyY19kcml2ZXIoZGV2LT5kcml2ZXIpOwoJaWYgKCFkcml2ZXItPnJlc3VtZSkKCQlyZXR1cm4gMDsKCXJldHVybiBkcml2ZXItPnJlc3VtZSh0b19pMmNfY2xpZW50KGRldikpOwp9CgpzdGF0aWMgdm9pZCBpMmNfY2xpZW50X3JlbGVhc2Uoc3RydWN0IGRldmljZSAqZGV2KQp7CglzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdG9faTJjX2NsaWVudChkZXYpOwoJY29tcGxldGUoJmNsaWVudC0+cmVsZWFzZWQpOwp9CgpzdGF0aWMgdm9pZCBpMmNfY2xpZW50X2Rldl9yZWxlYXNlKHN0cnVjdCBkZXZpY2UgKmRldikKewoJa2ZyZWUodG9faTJjX2NsaWVudChkZXYpKTsKfQoKc3RhdGljIHNzaXplX3Qgc2hvd19jbGllbnRfbmFtZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7CglyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwgY2xpZW50LT5uYW1lKTsKfQoKc3RhdGljIHNzaXplX3Qgc2hvd19tb2RhbGlhcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7CglyZXR1cm4gY2xpZW50LT5kcml2ZXJfbmFtZQoJCT8gc3ByaW50ZihidWYsICIlc1xuIiwgY2xpZW50LT5kcml2ZXJfbmFtZSkKCQk6IDA7Cn0KCnN0YXRpYyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSBpMmNfZGV2X2F0dHJzW10gPSB7CglfX0FUVFIobmFtZSwgU19JUlVHTywgc2hvd19jbGllbnRfbmFtZSwgTlVMTCksCgkvKiBtb2RhbGlhcyBoZWxwcyBjb2xkcGx1ZzogIG1vZHByb2JlICQoY2F0IC4uLi9tb2RhbGlhcykgKi8KCV9fQVRUUihtb2RhbGlhcywgU19JUlVHTywgc2hvd19tb2RhbGlhcywgTlVMTCksCgl7IH0sCn07CgpzdHJ1Y3QgYnVzX3R5cGUgaTJjX2J1c190eXBlID0gewoJLm5hbWUJCT0gImkyYyIsCgkuZGV2X2F0dHJzCT0gaTJjX2Rldl9hdHRycywKCS5tYXRjaAkJPSBpMmNfZGV2aWNlX21hdGNoLAoJLnVldmVudAkJPSBpMmNfZGV2aWNlX3VldmVudCwKCS5wcm9iZQkJPSBpMmNfZGV2aWNlX3Byb2JlLAoJLnJlbW92ZQkJPSBpMmNfZGV2aWNlX3JlbW92ZSwKCS5zaHV0ZG93bgk9IGkyY19kZXZpY2Vfc2h1dGRvd24sCgkuc3VzcGVuZAk9IGkyY19kZXZpY2Vfc3VzcGVuZCwKCS5yZXN1bWUJCT0gaTJjX2RldmljZV9yZXN1bWUsCn07CkVYUE9SVF9TWU1CT0xfR1BMKGkyY19idXNfdHlwZSk7CgovKioKICogaTJjX25ld19kZXZpY2UgLSBpbnN0YW50aWF0ZSBhbiBpMmMgZGV2aWNlIGZvciB1c2Ugd2l0aCBhIG5ldyBzdHlsZSBkcml2ZXIKICogQGFkYXA6IHRoZSBhZGFwdGVyIG1hbmFnaW5nIHRoZSBkZXZpY2UKICogQGluZm86IGRlc2NyaWJlcyBvbmUgSTJDIGRldmljZTsgYnVzX251bSBpcyBpZ25vcmVkCiAqIENvbnRleHQ6IGNhbiBzbGVlcAogKgogKiBDcmVhdGUgYSBkZXZpY2UgdG8gd29yayB3aXRoIGEgbmV3IHN0eWxlIGkyYyBkcml2ZXIsIHdoZXJlIGJpbmRpbmcgaXMKICogaGFuZGxlZCB0aHJvdWdoIGRyaXZlciBtb2RlbCBwcm9iZSgpL3JlbW92ZSgpIG1ldGhvZHMuICBUaGlzIGNhbGwgaXMgbm90CiAqIGFwcHJvcHJpYXRlIGZvciB1c2UgYnkgbWFpbmJvYWQgaW5pdGlhbGl6YXRpb24gbG9naWMsIHdoaWNoIHVzdWFsbHkgcnVucwogKiBkdXJpbmcgYW4gYXJjaF9pbml0Y2FsbCgpIGxvbmcgYmVmb3JlIGFueSBpMmNfYWRhcHRlciBjb3VsZCBleGlzdC4KICoKICogVGhpcyByZXR1cm5zIHRoZSBuZXcgaTJjIGNsaWVudCwgd2hpY2ggbWF5IGJlIHNhdmVkIGZvciBsYXRlciB1c2Ugd2l0aAogKiBpMmNfdW5yZWdpc3Rlcl9kZXZpY2UoKTsgb3IgTlVMTCB0byBpbmRpY2F0ZSBhbiBlcnJvci4KICovCnN0cnVjdCBpMmNfY2xpZW50ICoKaTJjX25ld19kZXZpY2Uoc3RydWN0IGkyY19hZGFwdGVyICphZGFwLCBzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gY29uc3QgKmluZm8pCnsKCXN0cnVjdCBpMmNfY2xpZW50CSpjbGllbnQ7CglpbnQJCQlzdGF0dXM7CgoJY2xpZW50ID0ga3phbGxvYyhzaXplb2YgKmNsaWVudCwgR0ZQX0tFUk5FTCk7CglpZiAoIWNsaWVudCkKCQlyZXR1cm4gTlVMTDsKCgljbGllbnQtPmFkYXB0ZXIgPSBhZGFwOwoKCWNsaWVudC0+ZGV2LnBsYXRmb3JtX2RhdGEgPSBpbmZvLT5wbGF0Zm9ybV9kYXRhOwoJY2xpZW50LT5mbGFncyA9IGluZm8tPmZsYWdzOwoJY2xpZW50LT5hZGRyID0gaW5mby0+YWRkcjsKCWNsaWVudC0+aXJxID0gaW5mby0+aXJxOwoKCXN0cmxjcHkoY2xpZW50LT5kcml2ZXJfbmFtZSwgaW5mby0+ZHJpdmVyX25hbWUsCgkJc2l6ZW9mKGNsaWVudC0+ZHJpdmVyX25hbWUpKTsKCXN0cmxjcHkoY2xpZW50LT5uYW1lLCBpbmZvLT50eXBlLCBzaXplb2YoY2xpZW50LT5uYW1lKSk7CgoJLyogYSBuZXcgc3R5bGUgZHJpdmVyIG1heSBiZSBib3VuZCB0byB0aGlzIGRldmljZSB3aGVuIHdlCgkgKiByZXR1cm4gZnJvbSB0aGlzIGZ1bmN0aW9uLCBvciBhbnkgbGF0ZXIgbW9tZW50IChlLmcuIG1heWJlCgkgKiBob3RwbHVnZ2luZyB3aWxsIGxvYWQgdGhlIGRyaXZlciBtb2R1bGUpLiAgYW5kIHRoZSBkZXZpY2UKCSAqIHJlZmNvdW50IG1vZGVsIGlzIHRoZSBzdGFuZGFyZCBkcml2ZXIgbW9kZWwgb25lLgoJICovCglzdGF0dXMgPSBpMmNfYXR0YWNoX2NsaWVudChjbGllbnQpOwoJaWYgKHN0YXR1cyA8IDApIHsKCQlrZnJlZShjbGllbnQpOwoJCWNsaWVudCA9IE5VTEw7Cgl9CglyZXR1cm4gY2xpZW50Owp9CkVYUE9SVF9TWU1CT0xfR1BMKGkyY19uZXdfZGV2aWNlKTsKCgovKioKICogaTJjX3VucmVnaXN0ZXJfZGV2aWNlIC0gcmV2ZXJzZSBlZmZlY3Qgb2YgaTJjX25ld19kZXZpY2UoKQogKiBAY2xpZW50OiB2YWx1ZSByZXR1cm5lZCBmcm9tIGkyY19uZXdfZGV2aWNlKCkKICogQ29udGV4dDogY2FuIHNsZWVwCiAqLwp2b2lkIGkyY191bnJlZ2lzdGVyX2RldmljZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQp7CglzdHJ1Y3QgaTJjX2FkYXB0ZXIJKmFkYXB0ZXIgPSBjbGllbnQtPmFkYXB0ZXI7CglzdHJ1Y3QgaTJjX2RyaXZlcgkqZHJpdmVyID0gY2xpZW50LT5kcml2ZXI7CgoJaWYgKGRyaXZlciAmJiAhaXNfbmV3c3R5bGVfZHJpdmVyKGRyaXZlcikpIHsKCQlkZXZfZXJyKCZjbGllbnQtPmRldiwgImNhbid0IHVucmVnaXN0ZXIgZGV2aWNlcyAiCgkJCSJ3aXRoIGxlZ2FjeSBkcml2ZXJzXG4iKTsKCQlXQVJOX09OKDEpOwoJCXJldHVybjsKCX0KCgltdXRleF9sb2NrKCZhZGFwdGVyLT5jbGlzdF9sb2NrKTsKCWxpc3RfZGVsKCZjbGllbnQtPmxpc3QpOwoJbXV0ZXhfdW5sb2NrKCZhZGFwdGVyLT5jbGlzdF9sb2NrKTsKCglkZXZpY2VfdW5yZWdpc3RlcigmY2xpZW50LT5kZXYpOwp9CkVYUE9SVF9TWU1CT0xfR1BMKGkyY191bnJlZ2lzdGVyX2RldmljZSk7CgoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKLyogSTJDIGJ1cyBhZGFwdGVycyAtLSBvbmUgcm9vdHMgZWFjaCBJMkMgb3IgU01CVVMgc2VnbWVudCAqLwoKdm9pZCBpMmNfYWRhcHRlcl9kZXZfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcCA9IHRvX2kyY19hZGFwdGVyKGRldik7Cgljb21wbGV0ZSgmYWRhcC0+ZGV2X3JlbGVhc2VkKTsKfQpFWFBPUlRfU1lNQk9MX0dQTChpMmNfYWRhcHRlcl9kZXZfcmVsZWFzZSk7CS8qIGV4cG9ydGVkIHRvIGkyYy1pc2EgKi8KCnN0YXRpYyBzc2l6ZV90CnNob3dfYWRhcHRlcl9uYW1lKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKewoJc3RydWN0IGkyY19hZGFwdGVyICphZGFwID0gdG9faTJjX2FkYXB0ZXIoZGV2KTsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBhZGFwLT5uYW1lKTsKfQoKc3RhdGljIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlIGkyY19hZGFwdGVyX2F0dHJzW10gPSB7CglfX0FUVFIobmFtZSwgU19JUlVHTywgc2hvd19hZGFwdGVyX25hbWUsIE5VTEwpLAoJeyB9LAp9OwoKc3RydWN0IGNsYXNzIGkyY19hZGFwdGVyX2NsYXNzID0gewoJLm93bmVyCQkJPSBUSElTX01PRFVMRSwKCS5uYW1lCQkJPSAiaTJjLWFkYXB0ZXIiLAoJLmRldl9hdHRycwkJPSBpMmNfYWRhcHRlcl9hdHRycywKfTsKRVhQT1JUX1NZTUJPTF9HUEwoaTJjX2FkYXB0ZXJfY2xhc3MpOwkJLyogZXhwb3J0ZWQgdG8gaTJjLWlzYSAqLwoKc3RhdGljIHZvaWQgaTJjX3NjYW5fc3RhdGljX2JvYXJkX2luZm8oc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyKQp7CglzdHJ1Y3QgaTJjX2RldmluZm8JKmRldmluZm87CgoJbXV0ZXhfbG9jaygmX19pMmNfYm9hcmRfbG9jayk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGRldmluZm8sICZfX2kyY19ib2FyZF9saXN0LCBsaXN0KSB7CgkJaWYgKGRldmluZm8tPmJ1c251bSA9PSBhZGFwdGVyLT5ucgoJCQkJJiYgIWkyY19uZXdfZGV2aWNlKGFkYXB0ZXIsCgkJCQkJCSZkZXZpbmZvLT5ib2FyZF9pbmZvKSkKCQkJcHJpbnRrKEtFUk5fRVJSICJpMmMtY29yZTogY2FuJ3QgY3JlYXRlIGkyYyVkLSUwNHhcbiIsCgkJCQlpMmNfYWRhcHRlcl9pZChhZGFwdGVyKSwKCQkJCWRldmluZm8tPmJvYXJkX2luZm8uYWRkcik7Cgl9CgltdXRleF91bmxvY2soJl9faTJjX2JvYXJkX2xvY2spOwp9CgpzdGF0aWMgaW50IGkyY19yZWdpc3Rlcl9hZGFwdGVyKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcCkKewoJaW50IHJlcyA9IDA7CglzdHJ1Y3QgbGlzdF9oZWFkICAgKml0ZW07CglzdHJ1Y3QgaTJjX2RyaXZlciAgKmRyaXZlcjsKCgltdXRleF9pbml0KCZhZGFwLT5idXNfbG9jayk7CgltdXRleF9pbml0KCZhZGFwLT5jbGlzdF9sb2NrKTsKCUlOSVRfTElTVF9IRUFEKCZhZGFwLT5jbGllbnRzKTsKCgltdXRleF9sb2NrKCZjb3JlX2xpc3RzKTsKCWxpc3RfYWRkX3RhaWwoJmFkYXAtPmxpc3QsICZhZGFwdGVycyk7CgoJLyogQWRkIHRoZSBhZGFwdGVyIHRvIHRoZSBkcml2ZXIgY29yZS4KCSAqIElmIHRoZSBwYXJlbnQgcG9pbnRlciBpcyBub3Qgc2V0IHVwLAoJICogd2UgYWRkIHRoaXMgYWRhcHRlciB0byB0aGUgaG9zdCBidXMuCgkgKi8KCWlmIChhZGFwLT5kZXYucGFyZW50ID09IE5VTEwpIHsKCQlhZGFwLT5kZXYucGFyZW50ID0gJnBsYXRmb3JtX2J1czsKCQlwcl9kZWJ1ZygiSTJDIGFkYXB0ZXIgZHJpdmVyIFslc10gZm9yZ290IHRvIHNwZWNpZnkgIgoJCQkgInBoeXNpY2FsIGRldmljZVxuIiwgYWRhcC0+bmFtZSk7Cgl9CglzcHJpbnRmKGFkYXAtPmRldi5idXNfaWQsICJpMmMtJWQiLCBhZGFwLT5ucik7CglhZGFwLT5kZXYucmVsZWFzZSA9ICZpMmNfYWRhcHRlcl9kZXZfcmVsZWFzZTsKCWFkYXAtPmRldi5jbGFzcyA9ICZpMmNfYWRhcHRlcl9jbGFzczsKCXJlcyA9IGRldmljZV9yZWdpc3RlcigmYWRhcC0+ZGV2KTsKCWlmIChyZXMpCgkJZ290byBvdXRfbGlzdDsKCglkZXZfZGJnKCZhZGFwLT5kZXYsICJhZGFwdGVyIFslc10gcmVnaXN0ZXJlZFxuIiwgYWRhcC0+bmFtZSk7CgoJLyogY3JlYXRlIHByZS1kZWNsYXJlZCBkZXZpY2Ugbm9kZXMgZm9yIG5ldy1zdHlsZSBkcml2ZXJzICovCglpZiAoYWRhcC0+bnIgPCBfX2kyY19maXJzdF9keW5hbWljX2J1c19udW0pCgkJaTJjX3NjYW5fc3RhdGljX2JvYXJkX2luZm8oYWRhcCk7CgoJLyogbGV0IGxlZ2FjeSBkcml2ZXJzIHNjYW4gdGhpcyBidXMgZm9yIG1hdGNoaW5nIGRldmljZXMgKi8KCWxpc3RfZm9yX2VhY2goaXRlbSwmZHJpdmVycykgewoJCWRyaXZlciA9IGxpc3RfZW50cnkoaXRlbSwgc3RydWN0IGkyY19kcml2ZXIsIGxpc3QpOwoJCWlmIChkcml2ZXItPmF0dGFjaF9hZGFwdGVyKQoJCQkvKiBXZSBpZ25vcmUgdGhlIHJldHVybiBjb2RlOyBpZiBpdCBmYWlscywgdG9vIGJhZCAqLwoJCQlkcml2ZXItPmF0dGFjaF9hZGFwdGVyKGFkYXApOwoJfQoKb3V0X3VubG9jazoKCW11dGV4X3VubG9jaygmY29yZV9saXN0cyk7CglyZXR1cm4gcmVzOwoKb3V0X2xpc3Q6CglsaXN0X2RlbCgmYWRhcC0+bGlzdCk7CglpZHJfcmVtb3ZlKCZpMmNfYWRhcHRlcl9pZHIsIGFkYXAtPm5yKTsKCWdvdG8gb3V0X3VubG9jazsKfQoKLyoqCiAqIGkyY19hZGRfYWRhcHRlciAtIGRlY2xhcmUgaTJjIGFkYXB0ZXIsIHVzZSBkeW5hbWljIGJ1cyBudW1iZXIKICogQGFkYXB0ZXI6IHRoZSBhZGFwdGVyIHRvIGFkZAogKiBDb250ZXh0OiBjYW4gc2xlZXAKICoKICogVGhpcyByb3V0aW5lIGlzIHVzZWQgdG8gZGVjbGFyZSBhbiBJMkMgYWRhcHRlciB3aGVuIGl0cyBidXMgbnVtYmVyCiAqIGRvZXNuJ3QgbWF0dGVyLiAgRXhhbXBsZXM6IGZvciBJMkMgYWRhcHRlcnMgZHluYW1pY2FsbHkgYWRkZWQgYnkKICogVVNCIGxpbmtzIG9yIFBDSSBwbHVnaW4gY2FyZHMuCiAqCiAqIFdoZW4gdGhpcyByZXR1cm5zIHplcm8sIGEgbmV3IGJ1cyBudW1iZXIgd2FzIGFsbG9jYXRlZCBhbmQgc3RvcmVkCiAqIGluIGFkYXAtPm5yLCBhbmQgdGhlIHNwZWNpZmllZCBhZGFwdGVyIGJlY2FtZSBhdmFpbGFibGUgZm9yIGNsaWVudHMuCiAqIE90aGVyd2lzZSwgYSBuZWdhdGl2ZSBlcnJubyB2YWx1ZSBpcyByZXR1cm5lZC4KICovCmludCBpMmNfYWRkX2FkYXB0ZXIoc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyKQp7CglpbnQJaWQsIHJlcyA9IDA7CgpyZXRyeToKCWlmIChpZHJfcHJlX2dldCgmaTJjX2FkYXB0ZXJfaWRyLCBHRlBfS0VSTkVMKSA9PSAwKQoJCXJldHVybiAtRU5PTUVNOwoKCW11dGV4X2xvY2soJmNvcmVfbGlzdHMpOwoJLyogImFib3ZlIiBoZXJlIG1lYW5zICJhYm92ZSBvciBlcXVhbCB0byIsIHNpZ2ggKi8KCXJlcyA9IGlkcl9nZXRfbmV3X2Fib3ZlKCZpMmNfYWRhcHRlcl9pZHIsIGFkYXB0ZXIsCgkJCQlfX2kyY19maXJzdF9keW5hbWljX2J1c19udW0sICZpZCk7CgltdXRleF91bmxvY2soJmNvcmVfbGlzdHMpOwoKCWlmIChyZXMgPCAwKSB7CgkJaWYgKHJlcyA9PSAtRUFHQUlOKQoJCQlnb3RvIHJldHJ5OwoJCXJldHVybiByZXM7Cgl9CgoJYWRhcHRlci0+bnIgPSBpZDsKCXJldHVybiBpMmNfcmVnaXN0ZXJfYWRhcHRlcihhZGFwdGVyKTsKfQpFWFBPUlRfU1lNQk9MKGkyY19hZGRfYWRhcHRlcik7CgovKioKICogaTJjX2FkZF9udW1iZXJlZF9hZGFwdGVyIC0gZGVjbGFyZSBpMmMgYWRhcHRlciwgdXNlIHN0YXRpYyBidXMgbnVtYmVyCiAqIEBhZGFwOiB0aGUgYWRhcHRlciB0byByZWdpc3RlciAod2l0aCBhZGFwLT5uciBpbml0aWFsaXplZCkKICogQ29udGV4dDogY2FuIHNsZWVwCiAqCiAqIFRoaXMgcm91dGluZSBpcyB1c2VkIHRvIGRlY2xhcmUgYW4gSTJDIGFkYXB0ZXIgd2hlbiBpdHMgYnVzIG51bWJlcgogKiBtYXR0ZXJzLiAgRXhhbXBsZTogZm9yIEkyQyBhZGFwdGVycyBmcm9tIHN5c3RlbS1vbi1jaGlwIENQVXMsIG9yCiAqIG90aGVyd2lzZSBidWlsdCBpbiB0byB0aGUgc3lzdGVtJ3MgbWFpbmJvYXJkLCBhbmQgd2hlcmUgaTJjX2JvYXJkX2luZm8KICogaXMgdXNlZCB0byBwcm9wZXJseSBjb25maWd1cmUgSTJDIGRldmljZXMuCiAqCiAqIElmIG5vIGRldmljZXMgaGF2ZSBwcmUtYmVlbiBkZWNsYXJlZCBmb3IgdGhpcyBidXMsIHRoZW4gYmUgc3VyZSB0bwogKiByZWdpc3RlciB0aGUgYWRhcHRlciBiZWZvcmUgYW55IGR5bmFtaWNhbGx5IGFsbG9jYXRlZCBvbmVzLiAgT3RoZXJ3aXNlCiAqIHRoZSByZXF1aXJlZCBidXMgSUQgbWF5IG5vdCBiZSBhdmFpbGFibGUuCiAqCiAqIFdoZW4gdGhpcyByZXR1cm5zIHplcm8sIHRoZSBzcGVjaWZpZWQgYWRhcHRlciBiZWNhbWUgYXZhaWxhYmxlIGZvcgogKiBjbGllbnRzIHVzaW5nIHRoZSBidXMgbnVtYmVyIHByb3ZpZGVkIGluIGFkYXAtPm5yLiAgQWxzbywgdGhlIHRhYmxlCiAqIG9mIEkyQyBkZXZpY2VzIHByZS1kZWNsYXJlZCB1c2luZyBpMmNfcmVnaXN0ZXJfYm9hcmRfaW5mbygpIGlzIHNjYW5uZWQsCiAqIGFuZCB0aGUgYXBwcm9wcmlhdGUgZHJpdmVyIG1vZGVsIGRldmljZSBub2RlcyBhcmUgY3JlYXRlZC4gIE90aGVyd2lzZSwgYQogKiBuZWdhdGl2ZSBlcnJubyB2YWx1ZSBpcyByZXR1cm5lZC4KICovCmludCBpMmNfYWRkX251bWJlcmVkX2FkYXB0ZXIoc3RydWN0IGkyY19hZGFwdGVyICphZGFwKQp7CglpbnQJaWQ7CglpbnQJc3RhdHVzOwoKCWlmIChhZGFwLT5uciAmIH5NQVhfSURfTUFTSykKCQlyZXR1cm4gLUVJTlZBTDsKCnJldHJ5OgoJaWYgKGlkcl9wcmVfZ2V0KCZpMmNfYWRhcHRlcl9pZHIsIEdGUF9LRVJORUwpID09IDApCgkJcmV0dXJuIC1FTk9NRU07CgoJbXV0ZXhfbG9jaygmY29yZV9saXN0cyk7CgkvKiAiYWJvdmUiIGhlcmUgbWVhbnMgImFib3ZlIG9yIGVxdWFsIHRvIiwgc2lnaDsKCSAqIHdlIG5lZWQgdGhlICJlcXVhbCB0byIgcmVzdWx0IHRvIGZvcmNlIHRoZSByZXN1bHQKCSAqLwoJc3RhdHVzID0gaWRyX2dldF9uZXdfYWJvdmUoJmkyY19hZGFwdGVyX2lkciwgYWRhcCwgYWRhcC0+bnIsICZpZCk7CglpZiAoc3RhdHVzID09IDAgJiYgaWQgIT0gYWRhcC0+bnIpIHsKCQlzdGF0dXMgPSAtRUJVU1k7CgkJaWRyX3JlbW92ZSgmaTJjX2FkYXB0ZXJfaWRyLCBpZCk7Cgl9CgltdXRleF91bmxvY2soJmNvcmVfbGlzdHMpOwoJaWYgKHN0YXR1cyA9PSAtRUFHQUlOKQoJCWdvdG8gcmV0cnk7CgoJaWYgKHN0YXR1cyA9PSAwKQoJCXN0YXR1cyA9IGkyY19yZWdpc3Rlcl9hZGFwdGVyKGFkYXApOwoJcmV0dXJuIHN0YXR1czsKfQpFWFBPUlRfU1lNQk9MX0dQTChpMmNfYWRkX251bWJlcmVkX2FkYXB0ZXIpOwoKLyoqCiAqIGkyY19kZWxfYWRhcHRlciAtIHVucmVnaXN0ZXIgSTJDIGFkYXB0ZXIKICogQGFkYXA6IHRoZSBhZGFwdGVyIGJlaW5nIHVucmVnaXN0ZXJlZAogKiBDb250ZXh0OiBjYW4gc2xlZXAKICoKICogVGhpcyB1bnJlZ2lzdGVycyBhbiBJMkMgYWRhcHRlciB3aGljaCB3YXMgcHJldmlvdXNseSByZWdpc3RlcmVkCiAqIGJ5IEBpMmNfYWRkX2FkYXB0ZXIgb3IgQGkyY19hZGRfbnVtYmVyZWRfYWRhcHRlci4KICovCmludCBpMmNfZGVsX2FkYXB0ZXIoc3RydWN0IGkyY19hZGFwdGVyICphZGFwKQp7CglzdHJ1Y3QgbGlzdF9oZWFkICAqaXRlbSwgKl9uOwoJc3RydWN0IGkyY19hZGFwdGVyICphZGFwX2Zyb21fbGlzdDsKCXN0cnVjdCBpMmNfZHJpdmVyICpkcml2ZXI7CglzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50OwoJaW50IHJlcyA9IDA7CgoJbXV0ZXhfbG9jaygmY29yZV9saXN0cyk7CgoJLyogRmlyc3QgbWFrZSBzdXJlIHRoYXQgdGhpcyBhZGFwdGVyIHdhcyBldmVyIGFkZGVkICovCglsaXN0X2Zvcl9lYWNoX2VudHJ5KGFkYXBfZnJvbV9saXN0LCAmYWRhcHRlcnMsIGxpc3QpIHsKCQlpZiAoYWRhcF9mcm9tX2xpc3QgPT0gYWRhcCkKCQkJYnJlYWs7Cgl9CglpZiAoYWRhcF9mcm9tX2xpc3QgIT0gYWRhcCkgewoJCXByX2RlYnVnKCJpMmMtY29yZTogYXR0ZW1wdGluZyB0byBkZWxldGUgdW5yZWdpc3RlcmVkICIKCQkJICJhZGFwdGVyIFslc11cbiIsIGFkYXAtPm5hbWUpOwoJCXJlcyA9IC1FSU5WQUw7CgkJZ290byBvdXRfdW5sb2NrOwoJfQoKCWxpc3RfZm9yX2VhY2goaXRlbSwmZHJpdmVycykgewoJCWRyaXZlciA9IGxpc3RfZW50cnkoaXRlbSwgc3RydWN0IGkyY19kcml2ZXIsIGxpc3QpOwoJCWlmIChkcml2ZXItPmRldGFjaF9hZGFwdGVyKQoJCQlpZiAoKHJlcyA9IGRyaXZlci0+ZGV0YWNoX2FkYXB0ZXIoYWRhcCkpKSB7CgkJCQlkZXZfZXJyKCZhZGFwLT5kZXYsICJkZXRhY2hfYWRhcHRlciBmYWlsZWQgIgoJCQkJCSJmb3IgZHJpdmVyIFslc11cbiIsCgkJCQkJZHJpdmVyLT5kcml2ZXIubmFtZSk7CgkJCQlnb3RvIG91dF91bmxvY2s7CgkJCX0KCX0KCgkvKiBkZXRhY2ggYW55IGFjdGl2ZSBjbGllbnRzLiBUaGlzIG11c3QgYmUgZG9uZSBmaXJzdCwgYmVjYXVzZQoJICogaXQgY2FuIGZhaWw7IGluIHdoaWNoIGNhc2Ugd2UgZ2l2ZSB1cC4gKi8KCWxpc3RfZm9yX2VhY2hfc2FmZShpdGVtLCBfbiwgJmFkYXAtPmNsaWVudHMpIHsKCQlzdHJ1Y3QgaTJjX2RyaXZlcgkqZHJpdmVyOwoKCQljbGllbnQgPSBsaXN0X2VudHJ5KGl0ZW0sIHN0cnVjdCBpMmNfY2xpZW50LCBsaXN0KTsKCQlkcml2ZXIgPSBjbGllbnQtPmRyaXZlcjsKCgkJLyogbmV3IHN0eWxlLCBmb2xsb3cgc3RhbmRhcmQgZHJpdmVyIG1vZGVsICovCgkJaWYgKCFkcml2ZXIgfHwgaXNfbmV3c3R5bGVfZHJpdmVyKGRyaXZlcikpIHsKCQkJaTJjX3VucmVnaXN0ZXJfZGV2aWNlKGNsaWVudCk7CgkJCWNvbnRpbnVlOwoJCX0KCgkJLyogbGVnYWN5IGRyaXZlcnMgY3JlYXRlIGFuZCByZW1vdmUgY2xpZW50cyB0aGVtc2VsdmVzICovCgkJaWYgKChyZXMgPSBkcml2ZXItPmRldGFjaF9jbGllbnQoY2xpZW50KSkpIHsKCQkJZGV2X2VycigmYWRhcC0+ZGV2LCAiZGV0YWNoX2NsaWVudCBmYWlsZWQgZm9yIGNsaWVudCAiCgkJCQkiWyVzXSBhdCBhZGRyZXNzIDB4JTAyeFxuIiwgY2xpZW50LT5uYW1lLAoJCQkJY2xpZW50LT5hZGRyKTsKCQkJZ290byBvdXRfdW5sb2NrOwoJCX0KCX0KCgkvKiBjbGVhbiB1cCB0aGUgc3lzZnMgcmVwcmVzZW50YXRpb24gKi8KCWluaXRfY29tcGxldGlvbigmYWRhcC0+ZGV2X3JlbGVhc2VkKTsKCWRldmljZV91bnJlZ2lzdGVyKCZhZGFwLT5kZXYpOwoJbGlzdF9kZWwoJmFkYXAtPmxpc3QpOwoKCS8qIHdhaXQgZm9yIHN5c2ZzIHRvIGRyb3AgYWxsIHJlZmVyZW5jZXMgKi8KCXdhaXRfZm9yX2NvbXBsZXRpb24oJmFkYXAtPmRldl9yZWxlYXNlZCk7CgoJLyogZnJlZSBidXMgaWQgKi8KCWlkcl9yZW1vdmUoJmkyY19hZGFwdGVyX2lkciwgYWRhcC0+bnIpOwoKCWRldl9kYmcoJmFkYXAtPmRldiwgImFkYXB0ZXIgWyVzXSB1bnJlZ2lzdGVyZWRcbiIsIGFkYXAtPm5hbWUpOwoKIG91dF91bmxvY2s6CgltdXRleF91bmxvY2soJmNvcmVfbGlzdHMpOwoJcmV0dXJuIHJlczsKfQpFWFBPUlRfU1lNQk9MKGkyY19kZWxfYWRhcHRlcik7CgoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKLyoKICogQW4gaTJjX2RyaXZlciBpcyB1c2VkIHdpdGggb25lIG9yIG1vcmUgaTJjX2NsaWVudCAoZGV2aWNlKSBub2RlcyB0byBhY2Nlc3MKICogaTJjIHNsYXZlIGNoaXBzLCBvbiBhIGJ1cyBpbnN0YW5jZSBhc3NvY2lhdGVkIHdpdGggc29tZSBpMmNfYWRhcHRlci4gIFRoZXJlCiAqIGFyZSB0d28gbW9kZWxzIGZvciBiaW5kaW5nIHRoZSBkcml2ZXIgdG8gaXRzIGRldmljZTogICJuZXcgc3R5bGUiIGRyaXZlcnMKICogZm9sbG93IHRoZSBzdGFuZGFyZCBMaW51eCBkcml2ZXIgbW9kZWwgYW5kIGp1c3QgcmVzcG9uZCB0byBwcm9iZSgpIGNhbGxzCiAqIGlzc3VlZCBpZiB0aGUgZHJpdmVyIGNvcmUgc2VlcyB0aGV5IG1hdGNoKCk7ICJsZWdhY3kiIGRyaXZlcnMgY3JlYXRlIGRldmljZQogKiBub2RlcyB0aGVtc2VsdmVzLgogKi8KCmludCBpMmNfcmVnaXN0ZXJfZHJpdmVyKHN0cnVjdCBtb2R1bGUgKm93bmVyLCBzdHJ1Y3QgaTJjX2RyaXZlciAqZHJpdmVyKQp7CglpbnQgcmVzOwoKCS8qIG5ldyBzdHlsZSBkcml2ZXIgbWV0aG9kcyBjYW4ndCBtaXggd2l0aCBsZWdhY3kgb25lcyAqLwoJaWYgKGlzX25ld3N0eWxlX2RyaXZlcihkcml2ZXIpKSB7CgkJaWYgKGRyaXZlci0+YXR0YWNoX2FkYXB0ZXIgfHwgZHJpdmVyLT5kZXRhY2hfYWRhcHRlcgoJCQkJfHwgZHJpdmVyLT5kZXRhY2hfY2xpZW50KSB7CgkJCXByaW50ayhLRVJOX1dBUk5JTkcKCQkJCQkiaTJjLWNvcmU6IGRyaXZlciBbJXNdIGlzIGNvbmZ1c2VkXG4iLAoJCQkJCWRyaXZlci0+ZHJpdmVyLm5hbWUpOwoJCQlyZXR1cm4gLUVJTlZBTDsKCQl9Cgl9CgoJLyogYWRkIHRoZSBkcml2ZXIgdG8gdGhlIGxpc3Qgb2YgaTJjIGRyaXZlcnMgaW4gdGhlIGRyaXZlciBjb3JlICovCglkcml2ZXItPmRyaXZlci5vd25lciA9IG93bmVyOwoJZHJpdmVyLT5kcml2ZXIuYnVzID0gJmkyY19idXNfdHlwZTsKCgkvKiBmb3IgbmV3IHN0eWxlIGRyaXZlcnMsIHdoZW4gcmVnaXN0cmF0aW9uIHJldHVybnMgdGhlIGRyaXZlciBjb3JlCgkgKiB3aWxsIGhhdmUgY2FsbGVkIHByb2JlKCkgZm9yIGFsbCBtYXRjaGluZy1idXQtdW5ib3VuZCBkZXZpY2VzLgoJICovCglyZXMgPSBkcml2ZXJfcmVnaXN0ZXIoJmRyaXZlci0+ZHJpdmVyKTsKCWlmIChyZXMpCgkJcmV0dXJuIHJlczsKCgltdXRleF9sb2NrKCZjb3JlX2xpc3RzKTsKCglsaXN0X2FkZF90YWlsKCZkcml2ZXItPmxpc3QsJmRyaXZlcnMpOwoJcHJfZGVidWcoImkyYy1jb3JlOiBkcml2ZXIgWyVzXSByZWdpc3RlcmVkXG4iLCBkcml2ZXItPmRyaXZlci5uYW1lKTsKCgkvKiBsZWdhY3kgZHJpdmVycyBzY2FuIGkyYyBidXNzZXMgZGlyZWN0bHkgKi8KCWlmIChkcml2ZXItPmF0dGFjaF9hZGFwdGVyKSB7CgkJc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyOwoKCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGFkYXB0ZXIsICZhZGFwdGVycywgbGlzdCkgewoJCQlkcml2ZXItPmF0dGFjaF9hZGFwdGVyKGFkYXB0ZXIpOwoJCX0KCX0KCgltdXRleF91bmxvY2soJmNvcmVfbGlzdHMpOwoJcmV0dXJuIDA7Cn0KRVhQT1JUX1NZTUJPTChpMmNfcmVnaXN0ZXJfZHJpdmVyKTsKCi8qKgogKiBpMmNfZGVsX2RyaXZlciAtIHVucmVnaXN0ZXIgSTJDIGRyaXZlcgogKiBAZHJpdmVyOiB0aGUgZHJpdmVyIGJlaW5nIHVucmVnaXN0ZXJlZAogKiBDb250ZXh0OiBjYW4gc2xlZXAKICovCnZvaWQgaTJjX2RlbF9kcml2ZXIoc3RydWN0IGkyY19kcml2ZXIgKmRyaXZlcikKewoJc3RydWN0IGxpc3RfaGVhZCAgICppdGVtMSwgKml0ZW0yLCAqX247CglzdHJ1Y3QgaTJjX2NsaWVudCAgKmNsaWVudDsKCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcDsKCgltdXRleF9sb2NrKCZjb3JlX2xpc3RzKTsKCgkvKiBuZXctc3R5bGUgZHJpdmVyPyAqLwoJaWYgKGlzX25ld3N0eWxlX2RyaXZlcihkcml2ZXIpKQoJCWdvdG8gdW5yZWdpc3RlcjsKCgkvKiBIYXZlIGEgbG9vayBhdCBlYWNoIGFkYXB0ZXIsIGlmIGNsaWVudHMgb2YgdGhpcyBkcml2ZXIgYXJlIHN0aWxsCgkgKiBhdHRhY2hlZC4gSWYgc28sIGRldGFjaCB0aGVtIHRvIGJlIGFibGUgdG8ga2lsbCB0aGUgZHJpdmVyCgkgKiBhZnRlcndhcmRzLgoJICovCglsaXN0X2Zvcl9lYWNoKGl0ZW0xLCZhZGFwdGVycykgewoJCWFkYXAgPSBsaXN0X2VudHJ5KGl0ZW0xLCBzdHJ1Y3QgaTJjX2FkYXB0ZXIsIGxpc3QpOwoJCWlmIChkcml2ZXItPmRldGFjaF9hZGFwdGVyKSB7CgkJCWlmIChkcml2ZXItPmRldGFjaF9hZGFwdGVyKGFkYXApKSB7CgkJCQlkZXZfZXJyKCZhZGFwLT5kZXYsICJkZXRhY2hfYWRhcHRlciBmYWlsZWQgIgoJCQkJCSJmb3IgZHJpdmVyIFslc11cbiIsCgkJCQkJZHJpdmVyLT5kcml2ZXIubmFtZSk7CgkJCX0KCQl9IGVsc2UgewoJCQlsaXN0X2Zvcl9lYWNoX3NhZmUoaXRlbTIsIF9uLCAmYWRhcC0+Y2xpZW50cykgewoJCQkJY2xpZW50ID0gbGlzdF9lbnRyeShpdGVtMiwgc3RydWN0IGkyY19jbGllbnQsIGxpc3QpOwoJCQkJaWYgKGNsaWVudC0+ZHJpdmVyICE9IGRyaXZlcikKCQkJCQljb250aW51ZTsKCQkJCWRldl9kYmcoJmFkYXAtPmRldiwgImRldGFjaGluZyBjbGllbnQgWyVzXSAiCgkJCQkJImF0IDB4JTAyeFxuIiwgY2xpZW50LT5uYW1lLAoJCQkJCWNsaWVudC0+YWRkcik7CgkJCQlpZiAoZHJpdmVyLT5kZXRhY2hfY2xpZW50KGNsaWVudCkpIHsKCQkJCQlkZXZfZXJyKCZhZGFwLT5kZXYsICJkZXRhY2hfY2xpZW50ICIKCQkJCQkJImZhaWxlZCBmb3IgY2xpZW50IFslc10gYXQgIgoJCQkJCQkiMHglMDJ4XG4iLCBjbGllbnQtPm5hbWUsCgkJCQkJCWNsaWVudC0+YWRkcik7CgkJCQl9CgkJCX0KCQl9Cgl9CgogdW5yZWdpc3RlcjoKCWRyaXZlcl91bnJlZ2lzdGVyKCZkcml2ZXItPmRyaXZlcik7CglsaXN0X2RlbCgmZHJpdmVyLT5saXN0KTsKCXByX2RlYnVnKCJpMmMtY29yZTogZHJpdmVyIFslc10gdW5yZWdpc3RlcmVkXG4iLCBkcml2ZXItPmRyaXZlci5uYW1lKTsKCgltdXRleF91bmxvY2soJmNvcmVfbGlzdHMpOwp9CkVYUE9SVF9TWU1CT0woaTJjX2RlbF9kcml2ZXIpOwoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIGludCBfX2kyY19jaGVja19hZGRyKHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwgdW5zaWduZWQgaW50IGFkZHIpCnsKCXN0cnVjdCBsaXN0X2hlYWQgICAqaXRlbTsKCXN0cnVjdCBpMmNfY2xpZW50ICAqY2xpZW50OwoKCWxpc3RfZm9yX2VhY2goaXRlbSwmYWRhcHRlci0+Y2xpZW50cykgewoJCWNsaWVudCA9IGxpc3RfZW50cnkoaXRlbSwgc3RydWN0IGkyY19jbGllbnQsIGxpc3QpOwoJCWlmIChjbGllbnQtPmFkZHIgPT0gYWRkcikKCQkJcmV0dXJuIC1FQlVTWTsKCX0KCXJldHVybiAwOwp9CgppbnQgaTJjX2NoZWNrX2FkZHIoc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLCBpbnQgYWRkcikKewoJaW50IHJ2YWw7CgoJbXV0ZXhfbG9jaygmYWRhcHRlci0+Y2xpc3RfbG9jayk7CglydmFsID0gX19pMmNfY2hlY2tfYWRkcihhZGFwdGVyLCBhZGRyKTsKCW11dGV4X3VubG9jaygmYWRhcHRlci0+Y2xpc3RfbG9jayk7CgoJcmV0dXJuIHJ2YWw7Cn0KRVhQT1JUX1NZTUJPTChpMmNfY2hlY2tfYWRkcik7CgppbnQgaTJjX2F0dGFjaF9jbGllbnQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKewoJc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyID0gY2xpZW50LT5hZGFwdGVyOwoJaW50IHJlcyA9IDA7CgoJbXV0ZXhfbG9jaygmYWRhcHRlci0+Y2xpc3RfbG9jayk7CglpZiAoX19pMmNfY2hlY2tfYWRkcihjbGllbnQtPmFkYXB0ZXIsIGNsaWVudC0+YWRkcikpIHsKCQlyZXMgPSAtRUJVU1k7CgkJZ290byBvdXRfdW5sb2NrOwoJfQoJbGlzdF9hZGRfdGFpbCgmY2xpZW50LT5saXN0LCZhZGFwdGVyLT5jbGllbnRzKTsKCgljbGllbnQtPnVzYWdlX2NvdW50ID0gMDsKCgljbGllbnQtPmRldi5wYXJlbnQgPSAmY2xpZW50LT5hZGFwdGVyLT5kZXY7CgljbGllbnQtPmRldi5idXMgPSAmaTJjX2J1c190eXBlOwoKCWlmIChjbGllbnQtPmRyaXZlcikKCQljbGllbnQtPmRldi5kcml2ZXIgPSAmY2xpZW50LT5kcml2ZXItPmRyaXZlcjsKCglpZiAoY2xpZW50LT5kcml2ZXIgJiYgIWlzX25ld3N0eWxlX2RyaXZlcihjbGllbnQtPmRyaXZlcikpIHsKCQljbGllbnQtPmRldi5yZWxlYXNlID0gaTJjX2NsaWVudF9yZWxlYXNlOwoJCWNsaWVudC0+ZGV2LnVldmVudF9zdXBwcmVzcyA9IDE7Cgl9IGVsc2UKCQljbGllbnQtPmRldi5yZWxlYXNlID0gaTJjX2NsaWVudF9kZXZfcmVsZWFzZTsKCglzbnByaW50ZigmY2xpZW50LT5kZXYuYnVzX2lkWzBdLCBzaXplb2YoY2xpZW50LT5kZXYuYnVzX2lkKSwKCQkiJWQtJTA0eCIsIGkyY19hZGFwdGVyX2lkKGFkYXB0ZXIpLCBjbGllbnQtPmFkZHIpOwoJZGV2X2RiZygmYWRhcHRlci0+ZGV2LCAiY2xpZW50IFslc10gcmVnaXN0ZXJlZCB3aXRoIGJ1cyBpZCAlc1xuIiwKCQljbGllbnQtPm5hbWUsIGNsaWVudC0+ZGV2LmJ1c19pZCk7CglyZXMgPSBkZXZpY2VfcmVnaXN0ZXIoJmNsaWVudC0+ZGV2KTsKCWlmIChyZXMpCgkJZ290byBvdXRfbGlzdDsKCW11dGV4X3VubG9jaygmYWRhcHRlci0+Y2xpc3RfbG9jayk7CgoJaWYgKGFkYXB0ZXItPmNsaWVudF9yZWdpc3RlcikgIHsKCQlpZiAoYWRhcHRlci0+Y2xpZW50X3JlZ2lzdGVyKGNsaWVudCkpIHsKCQkJZGV2X2RiZygmYWRhcHRlci0+ZGV2LCAiY2xpZW50X3JlZ2lzdGVyICIKCQkJCSJmYWlsZWQgZm9yIGNsaWVudCBbJXNdIGF0IDB4JTAyeFxuIiwKCQkJCWNsaWVudC0+bmFtZSwgY2xpZW50LT5hZGRyKTsKCQl9Cgl9CgoJcmV0dXJuIDA7CgpvdXRfbGlzdDoKCWxpc3RfZGVsKCZjbGllbnQtPmxpc3QpOwoJZGV2X2VycigmYWRhcHRlci0+ZGV2LCAiRmFpbGVkIHRvIGF0dGFjaCBpMmMgY2xpZW50ICVzIGF0IDB4JTAyeCAiCgkJIiglZClcbiIsIGNsaWVudC0+bmFtZSwgY2xpZW50LT5hZGRyLCByZXMpOwpvdXRfdW5sb2NrOgoJbXV0ZXhfdW5sb2NrKCZhZGFwdGVyLT5jbGlzdF9sb2NrKTsKCXJldHVybiByZXM7Cn0KRVhQT1JUX1NZTUJPTChpMmNfYXR0YWNoX2NsaWVudCk7CgppbnQgaTJjX2RldGFjaF9jbGllbnQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKewoJc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyID0gY2xpZW50LT5hZGFwdGVyOwoJaW50IHJlcyA9IDA7CgoJaWYgKGNsaWVudC0+dXNhZ2VfY291bnQgPiAwKSB7CgkJZGV2X3dhcm4oJmNsaWVudC0+ZGV2LCAiQ2xpZW50IFslc10gc3RpbGwgYnVzeSwgIgoJCQkgImNhbid0IGRldGFjaFxuIiwgY2xpZW50LT5uYW1lKTsKCQlyZXR1cm4gLUVCVVNZOwoJfQoKCWlmIChhZGFwdGVyLT5jbGllbnRfdW5yZWdpc3RlcikgIHsKCQlyZXMgPSBhZGFwdGVyLT5jbGllbnRfdW5yZWdpc3RlcihjbGllbnQpOwoJCWlmIChyZXMpIHsKCQkJZGV2X2VycigmY2xpZW50LT5kZXYsCgkJCQkiY2xpZW50X3VucmVnaXN0ZXIgWyVzXSBmYWlsZWQsICIKCQkJCSJjbGllbnQgbm90IGRldGFjaGVkXG4iLCBjbGllbnQtPm5hbWUpOwoJCQlnb3RvIG91dDsKCQl9Cgl9CgoJbXV0ZXhfbG9jaygmYWRhcHRlci0+Y2xpc3RfbG9jayk7CglsaXN0X2RlbCgmY2xpZW50LT5saXN0KTsKCWluaXRfY29tcGxldGlvbigmY2xpZW50LT5yZWxlYXNlZCk7CglkZXZpY2VfdW5yZWdpc3RlcigmY2xpZW50LT5kZXYpOwoJbXV0ZXhfdW5sb2NrKCZhZGFwdGVyLT5jbGlzdF9sb2NrKTsKCXdhaXRfZm9yX2NvbXBsZXRpb24oJmNsaWVudC0+cmVsZWFzZWQpOwoKIG91dDoKCXJldHVybiByZXM7Cn0KRVhQT1JUX1NZTUJPTChpMmNfZGV0YWNoX2NsaWVudCk7CgpzdGF0aWMgaW50IGkyY19pbmNfdXNlX2NsaWVudChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQp7CgoJaWYgKCF0cnlfbW9kdWxlX2dldChjbGllbnQtPmRyaXZlci0+ZHJpdmVyLm93bmVyKSkKCQlyZXR1cm4gLUVOT0RFVjsKCWlmICghdHJ5X21vZHVsZV9nZXQoY2xpZW50LT5hZGFwdGVyLT5vd25lcikpIHsKCQltb2R1bGVfcHV0KGNsaWVudC0+ZHJpdmVyLT5kcml2ZXIub3duZXIpOwoJCXJldHVybiAtRU5PREVWOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBpMmNfZGVjX3VzZV9jbGllbnQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKewoJbW9kdWxlX3B1dChjbGllbnQtPmRyaXZlci0+ZHJpdmVyLm93bmVyKTsKCW1vZHVsZV9wdXQoY2xpZW50LT5hZGFwdGVyLT5vd25lcik7Cn0KCmludCBpMmNfdXNlX2NsaWVudChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQp7CglpbnQgcmV0OwoKCXJldCA9IGkyY19pbmNfdXNlX2NsaWVudChjbGllbnQpOwoJaWYgKHJldCkKCQlyZXR1cm4gcmV0OwoKCWNsaWVudC0+dXNhZ2VfY291bnQrKzsKCglyZXR1cm4gMDsKfQpFWFBPUlRfU1lNQk9MKGkyY191c2VfY2xpZW50KTsKCmludCBpMmNfcmVsZWFzZV9jbGllbnQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKewoJaWYgKCFjbGllbnQtPnVzYWdlX2NvdW50KSB7CgkJcHJfZGVidWcoImkyYy1jb3JlOiAlcyB1c2VkIG9uZSB0b28gbWFueSB0aW1lc1xuIiwKCQkJIF9fRlVOQ1RJT05fXyk7CgkJcmV0dXJuIC1FUEVSTTsKCX0KCgljbGllbnQtPnVzYWdlX2NvdW50LS07CglpMmNfZGVjX3VzZV9jbGllbnQoY2xpZW50KTsKCglyZXR1cm4gMDsKfQpFWFBPUlRfU1lNQk9MKGkyY19yZWxlYXNlX2NsaWVudCk7Cgp2b2lkIGkyY19jbGllbnRzX2NvbW1hbmQoc3RydWN0IGkyY19hZGFwdGVyICphZGFwLCB1bnNpZ25lZCBpbnQgY21kLCB2b2lkICphcmcpCnsKCXN0cnVjdCBsaXN0X2hlYWQgICppdGVtOwoJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudDsKCgltdXRleF9sb2NrKCZhZGFwLT5jbGlzdF9sb2NrKTsKCWxpc3RfZm9yX2VhY2goaXRlbSwmYWRhcC0+Y2xpZW50cykgewoJCWNsaWVudCA9IGxpc3RfZW50cnkoaXRlbSwgc3RydWN0IGkyY19jbGllbnQsIGxpc3QpOwoJCWlmICghdHJ5X21vZHVsZV9nZXQoY2xpZW50LT5kcml2ZXItPmRyaXZlci5vd25lcikpCgkJCWNvbnRpbnVlOwoJCWlmIChOVUxMICE9IGNsaWVudC0+ZHJpdmVyLT5jb21tYW5kKSB7CgkJCW11dGV4X3VubG9jaygmYWRhcC0+Y2xpc3RfbG9jayk7CgkJCWNsaWVudC0+ZHJpdmVyLT5jb21tYW5kKGNsaWVudCxjbWQsYXJnKTsKCQkJbXV0ZXhfbG9jaygmYWRhcC0+Y2xpc3RfbG9jayk7CgkJfQoJCW1vZHVsZV9wdXQoY2xpZW50LT5kcml2ZXItPmRyaXZlci5vd25lcik7CiAgICAgICB9CiAgICAgICBtdXRleF91bmxvY2soJmFkYXAtPmNsaXN0X2xvY2spOwp9CkVYUE9SVF9TWU1CT0woaTJjX2NsaWVudHNfY29tbWFuZCk7CgpzdGF0aWMgaW50IF9faW5pdCBpMmNfaW5pdCh2b2lkKQp7CglpbnQgcmV0dmFsOwoKCXJldHZhbCA9IGJ1c19yZWdpc3RlcigmaTJjX2J1c190eXBlKTsKCWlmIChyZXR2YWwpCgkJcmV0dXJuIHJldHZhbDsKCXJldHVybiBjbGFzc19yZWdpc3RlcigmaTJjX2FkYXB0ZXJfY2xhc3MpOwp9CgpzdGF0aWMgdm9pZCBfX2V4aXQgaTJjX2V4aXQodm9pZCkKewoJY2xhc3NfdW5yZWdpc3RlcigmaTJjX2FkYXB0ZXJfY2xhc3MpOwoJYnVzX3VucmVnaXN0ZXIoJmkyY19idXNfdHlwZSk7Cn0KCnN1YnN5c19pbml0Y2FsbChpMmNfaW5pdCk7Cm1vZHVsZV9leGl0KGkyY19leGl0KTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICogdGhlIGZ1bmN0aW9uYWwgaW50ZXJmYWNlIHRvIHRoZSBpMmMgYnVzc2VzLgogKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAqLwoKaW50IGkyY190cmFuc2ZlcihzdHJ1Y3QgaTJjX2FkYXB0ZXIgKiBhZGFwLCBzdHJ1Y3QgaTJjX21zZyAqbXNncywgaW50IG51bSkKewoJaW50IHJldDsKCglpZiAoYWRhcC0+YWxnby0+bWFzdGVyX3hmZXIpIHsKI2lmZGVmIERFQlVHCgkJZm9yIChyZXQgPSAwOyByZXQgPCBudW07IHJldCsrKSB7CgkJCWRldl9kYmcoJmFkYXAtPmRldiwgIm1hc3Rlcl94ZmVyWyVkXSAlYywgYWRkcj0weCUwMngsICIKCQkJCSJsZW49JWQlc1xuIiwgcmV0LCAobXNnc1tyZXRdLmZsYWdzICYgSTJDX01fUkQpCgkJCQk/ICdSJyA6ICdXJywgbXNnc1tyZXRdLmFkZHIsIG1zZ3NbcmV0XS5sZW4sCgkJCQkobXNnc1tyZXRdLmZsYWdzICYgSTJDX01fUkVDVl9MRU4pID8gIisiIDogIiIpOwoJCX0KI2VuZGlmCgoJCW11dGV4X2xvY2tfbmVzdGVkKCZhZGFwLT5idXNfbG9jaywgYWRhcC0+bGV2ZWwpOwoJCXJldCA9IGFkYXAtPmFsZ28tPm1hc3Rlcl94ZmVyKGFkYXAsbXNncyxudW0pOwoJCW11dGV4X3VubG9jaygmYWRhcC0+YnVzX2xvY2spOwoKCQlyZXR1cm4gcmV0OwoJfSBlbHNlIHsKCQlkZXZfZGJnKCZhZGFwLT5kZXYsICJJMkMgbGV2ZWwgdHJhbnNmZXJzIG5vdCBzdXBwb3J0ZWRcbiIpOwoJCXJldHVybiAtRU5PU1lTOwoJfQp9CkVYUE9SVF9TWU1CT0woaTJjX3RyYW5zZmVyKTsKCmludCBpMmNfbWFzdGVyX3NlbmQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCxjb25zdCBjaGFyICpidWYgLGludCBjb3VudCkKewoJaW50IHJldDsKCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcD1jbGllbnQtPmFkYXB0ZXI7CglzdHJ1Y3QgaTJjX21zZyBtc2c7CgoJbXNnLmFkZHIgPSBjbGllbnQtPmFkZHI7Cgltc2cuZmxhZ3MgPSBjbGllbnQtPmZsYWdzICYgSTJDX01fVEVOOwoJbXNnLmxlbiA9IGNvdW50OwoJbXNnLmJ1ZiA9IChjaGFyICopYnVmOwoKCXJldCA9IGkyY190cmFuc2ZlcihhZGFwLCAmbXNnLCAxKTsKCgkvKiBJZiBldmVyeXRoaW5nIHdlbnQgb2sgKGkuZS4gMSBtc2cgdHJhbnNtaXR0ZWQpLCByZXR1cm4gI2J5dGVzCgkgICB0cmFuc21pdHRlZCwgZWxzZSBlcnJvciBjb2RlLiAqLwoJcmV0dXJuIChyZXQgPT0gMSkgPyBjb3VudCA6IHJldDsKfQpFWFBPUlRfU1lNQk9MKGkyY19tYXN0ZXJfc2VuZCk7CgppbnQgaTJjX21hc3Rlcl9yZWN2KHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIGNoYXIgKmJ1ZiAsaW50IGNvdW50KQp7CglzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXA9Y2xpZW50LT5hZGFwdGVyOwoJc3RydWN0IGkyY19tc2cgbXNnOwoJaW50IHJldDsKCgltc2cuYWRkciA9IGNsaWVudC0+YWRkcjsKCW1zZy5mbGFncyA9IGNsaWVudC0+ZmxhZ3MgJiBJMkNfTV9URU47Cgltc2cuZmxhZ3MgfD0gSTJDX01fUkQ7Cgltc2cubGVuID0gY291bnQ7Cgltc2cuYnVmID0gYnVmOwoKCXJldCA9IGkyY190cmFuc2ZlcihhZGFwLCAmbXNnLCAxKTsKCgkvKiBJZiBldmVyeXRoaW5nIHdlbnQgb2sgKGkuZS4gMSBtc2cgdHJhbnNtaXR0ZWQpLCByZXR1cm4gI2J5dGVzCgkgICB0cmFuc21pdHRlZCwgZWxzZSBlcnJvciBjb2RlLiAqLwoJcmV0dXJuIChyZXQgPT0gMSkgPyBjb3VudCA6IHJldDsKfQpFWFBPUlRfU1lNQk9MKGkyY19tYXN0ZXJfcmVjdik7CgppbnQgaTJjX2NvbnRyb2woc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKCXVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQp7CglpbnQgcmV0ID0gMDsKCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcCA9IGNsaWVudC0+YWRhcHRlcjsKCglkZXZfZGJnKCZjbGllbnQtPmFkYXB0ZXItPmRldiwgImkyYyBpb2N0bCwgY21kOiAweCV4LCBhcmc6ICUjbHhcbiIsIGNtZCwgYXJnKTsKCXN3aXRjaCAoY21kKSB7CgkJY2FzZSBJMkNfUkVUUklFUzoKCQkJYWRhcC0+cmV0cmllcyA9IGFyZzsKCQkJYnJlYWs7CgkJY2FzZSBJMkNfVElNRU9VVDoKCQkJYWRhcC0+dGltZW91dCA9IGFyZzsKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJaWYgKGFkYXAtPmFsZ28tPmFsZ29fY29udHJvbCE9TlVMTCkKCQkJCXJldCA9IGFkYXAtPmFsZ28tPmFsZ29fY29udHJvbChhZGFwLGNtZCxhcmcpOwoJfQoJcmV0dXJuIHJldDsKfQpFWFBPUlRfU1lNQk9MKGkyY19jb250cm9sKTsKCi8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICogdGhlIGkyYyBhZGRyZXNzIHNjYW5uaW5nIGZ1bmN0aW9uCiAqIFdpbGwgbm90IHdvcmsgZm9yIDEwLWJpdCBhZGRyZXNzZXMhCiAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICovCnN0YXRpYyBpbnQgaTJjX3Byb2JlX2FkZHJlc3Moc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLCBpbnQgYWRkciwgaW50IGtpbmQsCgkJCSAgICAgaW50ICgqZm91bmRfcHJvYykgKHN0cnVjdCBpMmNfYWRhcHRlciAqLCBpbnQsIGludCkpCnsKCWludCBlcnI7CgoJLyogTWFrZSBzdXJlIHRoZSBhZGRyZXNzIGlzIHZhbGlkICovCglpZiAoYWRkciA8IDB4MDMgfHwgYWRkciA+IDB4NzcpIHsKCQlkZXZfd2FybigmYWRhcHRlci0+ZGV2LCAiSW52YWxpZCBwcm9iZSBhZGRyZXNzIDB4JTAyeFxuIiwKCQkJIGFkZHIpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCS8qIFNraXAgaWYgYWxyZWFkeSBpbiB1c2UgKi8KCWlmIChpMmNfY2hlY2tfYWRkcihhZGFwdGVyLCBhZGRyKSkKCQlyZXR1cm4gMDsKCgkvKiBNYWtlIHN1cmUgdGhlcmUgaXMgc29tZXRoaW5nIGF0IHRoaXMgYWRkcmVzcywgdW5sZXNzIGZvcmNlZCAqLwoJaWYgKGtpbmQgPCAwKSB7CgkJaWYgKGkyY19zbWJ1c194ZmVyKGFkYXB0ZXIsIGFkZHIsIDAsIDAsIDAsCgkJCQkgICBJMkNfU01CVVNfUVVJQ0ssIE5VTEwpIDwgMCkKCQkJcmV0dXJuIDA7CgoJCS8qIHByZXZlbnQgMjRSRjA4IGNvcnJ1cHRpb24gKi8KCQlpZiAoKGFkZHIgJiB+MHgwZikgPT0gMHg1MCkKCQkJaTJjX3NtYnVzX3hmZXIoYWRhcHRlciwgYWRkciwgMCwgMCwgMCwKCQkJCSAgICAgICBJMkNfU01CVVNfUVVJQ0ssIE5VTEwpOwoJfQoKCS8qIEZpbmFsbHkgY2FsbCB0aGUgY3VzdG9tIGRldGVjdGlvbiBmdW5jdGlvbiAqLwoJZXJyID0gZm91bmRfcHJvYyhhZGFwdGVyLCBhZGRyLCBraW5kKTsKCS8qIC1FTk9ERVYgY2FuIGJlIHJldHVybmVkIGlmIHRoZXJlIGlzIGEgY2hpcCBhdCB0aGUgZ2l2ZW4gYWRkcmVzcwoJICAgYnV0IGl0IGlzbid0IHN1cHBvcnRlZCBieSB0aGlzIGNoaXAgZHJpdmVyLiBXZSBjYXRjaCBpdCBoZXJlIGFzCgkgICB0aGlzIGlzbid0IGFuIGVycm9yLiAqLwoJaWYgKGVyciA9PSAtRU5PREVWKQoJCWVyciA9IDA7CgoJaWYgKGVycikKCQlkZXZfd2FybigmYWRhcHRlci0+ZGV2LCAiQ2xpZW50IGNyZWF0aW9uIGZhaWxlZCBhdCAweCV4ICglZClcbiIsCgkJCSBhZGRyLCBlcnIpOwoJcmV0dXJuIGVycjsKfQoKaW50IGkyY19wcm9iZShzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsCgkgICAgICBzdHJ1Y3QgaTJjX2NsaWVudF9hZGRyZXNzX2RhdGEgKmFkZHJlc3NfZGF0YSwKCSAgICAgIGludCAoKmZvdW5kX3Byb2MpIChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKiwgaW50LCBpbnQpKQp7CglpbnQgaSwgZXJyOwoJaW50IGFkYXBfaWQgPSBpMmNfYWRhcHRlcl9pZChhZGFwdGVyKTsKCgkvKiBGb3JjZSBlbnRyaWVzIGFyZSBkb25lIGZpcnN0LCBhbmQgYXJlIG5vdCBhZmZlY3RlZCBieSBpZ25vcmUKCSAgIGVudHJpZXMgKi8KCWlmIChhZGRyZXNzX2RhdGEtPmZvcmNlcykgewoJCXVuc2lnbmVkIHNob3J0ICoqZm9yY2VzID0gYWRkcmVzc19kYXRhLT5mb3JjZXM7CgkJaW50IGtpbmQ7CgoJCWZvciAoa2luZCA9IDA7IGZvcmNlc1traW5kXTsga2luZCsrKSB7CgkJCWZvciAoaSA9IDA7IGZvcmNlc1traW5kXVtpXSAhPSBJMkNfQ0xJRU5UX0VORDsKCQkJICAgICBpICs9IDIpIHsKCQkJCWlmIChmb3JjZXNba2luZF1baV0gPT0gYWRhcF9pZAoJCQkJIHx8IGZvcmNlc1traW5kXVtpXSA9PSBBTllfSTJDX0JVUykgewoJCQkJCWRldl9kYmcoJmFkYXB0ZXItPmRldiwgImZvdW5kIGZvcmNlICIKCQkJCQkJInBhcmFtZXRlciBmb3IgYWRhcHRlciAlZCwgIgoJCQkJCQkiYWRkciAweCUwMngsIGtpbmQgJWRcbiIsCgkJCQkJCWFkYXBfaWQsIGZvcmNlc1traW5kXVtpICsgMV0sCgkJCQkJCWtpbmQpOwoJCQkJCWVyciA9IGkyY19wcm9iZV9hZGRyZXNzKGFkYXB0ZXIsCgkJCQkJCWZvcmNlc1traW5kXVtpICsgMV0sCgkJCQkJCWtpbmQsIGZvdW5kX3Byb2MpOwoJCQkJCWlmIChlcnIpCgkJCQkJCXJldHVybiBlcnI7CgkJCQl9CgkJCX0KCQl9Cgl9CgoJLyogU3RvcCBoZXJlIGlmIHdlIGNhbid0IHVzZSBTTUJVU19RVUlDSyAqLwoJaWYgKCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShhZGFwdGVyLCBJMkNfRlVOQ19TTUJVU19RVUlDSykpIHsKCQlpZiAoYWRkcmVzc19kYXRhLT5wcm9iZVswXSA9PSBJMkNfQ0xJRU5UX0VORAoJCSAmJiBhZGRyZXNzX2RhdGEtPm5vcm1hbF9pMmNbMF0gPT0gSTJDX0NMSUVOVF9FTkQpCgkJCXJldHVybiAwOwoKCQlkZXZfd2FybigmYWRhcHRlci0+ZGV2LCAiU01CdXMgUXVpY2sgY29tbWFuZCBub3Qgc3VwcG9ydGVkLCAiCgkJCSAiY2FuJ3QgcHJvYmUgZm9yIGNoaXBzXG4iKTsKCQlyZXR1cm4gLTE7Cgl9CgoJLyogUHJvYmUgZW50cmllcyBhcmUgZG9uZSBzZWNvbmQsIGFuZCBhcmUgbm90IGFmZmVjdGVkIGJ5IGlnbm9yZQoJICAgZW50cmllcyBlaXRoZXIgKi8KCWZvciAoaSA9IDA7IGFkZHJlc3NfZGF0YS0+cHJvYmVbaV0gIT0gSTJDX0NMSUVOVF9FTkQ7IGkgKz0gMikgewoJCWlmIChhZGRyZXNzX2RhdGEtPnByb2JlW2ldID09IGFkYXBfaWQKCQkgfHwgYWRkcmVzc19kYXRhLT5wcm9iZVtpXSA9PSBBTllfSTJDX0JVUykgewoJCQlkZXZfZGJnKCZhZGFwdGVyLT5kZXYsICJmb3VuZCBwcm9iZSBwYXJhbWV0ZXIgZm9yICIKCQkJCSJhZGFwdGVyICVkLCBhZGRyIDB4JTAyeFxuIiwgYWRhcF9pZCwKCQkJCWFkZHJlc3NfZGF0YS0+cHJvYmVbaSArIDFdKTsKCQkJZXJyID0gaTJjX3Byb2JlX2FkZHJlc3MoYWRhcHRlciwKCQkJCQkJYWRkcmVzc19kYXRhLT5wcm9iZVtpICsgMV0sCgkJCQkJCS0xLCBmb3VuZF9wcm9jKTsKCQkJaWYgKGVycikKCQkJCXJldHVybiBlcnI7CgkJfQoJfQoKCS8qIE5vcm1hbCBlbnRyaWVzIGFyZSBkb25lIGxhc3QsIHVubGVzcyBzaGFkb3dlZCBieSBhbiBpZ25vcmUgZW50cnkgKi8KCWZvciAoaSA9IDA7IGFkZHJlc3NfZGF0YS0+bm9ybWFsX2kyY1tpXSAhPSBJMkNfQ0xJRU5UX0VORDsgaSArPSAxKSB7CgkJaW50IGosIGlnbm9yZTsKCgkJaWdub3JlID0gMDsKCQlmb3IgKGogPSAwOyBhZGRyZXNzX2RhdGEtPmlnbm9yZVtqXSAhPSBJMkNfQ0xJRU5UX0VORDsKCQkgICAgIGogKz0gMikgewoJCQlpZiAoKGFkZHJlc3NfZGF0YS0+aWdub3JlW2pdID09IGFkYXBfaWQgfHwKCQkJICAgICBhZGRyZXNzX2RhdGEtPmlnbm9yZVtqXSA9PSBBTllfSTJDX0JVUykKCQkJICYmIGFkZHJlc3NfZGF0YS0+aWdub3JlW2ogKyAxXQoJCQkgICAgPT0gYWRkcmVzc19kYXRhLT5ub3JtYWxfaTJjW2ldKSB7CgkJCQlkZXZfZGJnKCZhZGFwdGVyLT5kZXYsICJmb3VuZCBpZ25vcmUgIgoJCQkJCSJwYXJhbWV0ZXIgZm9yIGFkYXB0ZXIgJWQsICIKCQkJCQkiYWRkciAweCUwMnhcbiIsIGFkYXBfaWQsCgkJCQkJYWRkcmVzc19kYXRhLT5pZ25vcmVbaiArIDFdKTsKCQkJCWlnbm9yZSA9IDE7CgkJCQlicmVhazsKCQkJfQoJCX0KCQlpZiAoaWdub3JlKQoJCQljb250aW51ZTsKCgkJZGV2X2RiZygmYWRhcHRlci0+ZGV2LCAiZm91bmQgbm9ybWFsIGVudHJ5IGZvciBhZGFwdGVyICVkLCAiCgkJCSJhZGRyIDB4JTAyeFxuIiwgYWRhcF9pZCwKCQkJYWRkcmVzc19kYXRhLT5ub3JtYWxfaTJjW2ldKTsKCQllcnIgPSBpMmNfcHJvYmVfYWRkcmVzcyhhZGFwdGVyLCBhZGRyZXNzX2RhdGEtPm5vcm1hbF9pMmNbaV0sCgkJCQkJLTEsIGZvdW5kX3Byb2MpOwoJCWlmIChlcnIpCgkJCXJldHVybiBlcnI7Cgl9CgoJcmV0dXJuIDA7Cn0KRVhQT1JUX1NZTUJPTChpMmNfcHJvYmUpOwoKc3RydWN0IGkyY19jbGllbnQgKgppMmNfbmV3X3Byb2JlZF9kZXZpY2Uoc3RydWN0IGkyY19hZGFwdGVyICphZGFwLAoJCSAgICAgIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyAqaW5mbywKCQkgICAgICB1bnNpZ25lZCBzaG9ydCBjb25zdCAqYWRkcl9saXN0KQp7CglpbnQgaTsKCgkvKiBTdG9wIGhlcmUgaWYgdGhlIGJ1cyBkb2Vzbid0IHN1cHBvcnQgcHJvYmluZyAqLwoJaWYgKCFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShhZGFwLCBJMkNfRlVOQ19TTUJVU19SRUFEX0JZVEUpKSB7CgkJZGV2X2VycigmYWRhcC0+ZGV2LCAiUHJvYmluZyBub3Qgc3VwcG9ydGVkXG4iKTsKCQlyZXR1cm4gTlVMTDsKCX0KCgltdXRleF9sb2NrKCZhZGFwLT5jbGlzdF9sb2NrKTsKCWZvciAoaSA9IDA7IGFkZHJfbGlzdFtpXSAhPSBJMkNfQ0xJRU5UX0VORDsgaSsrKSB7CgkJLyogQ2hlY2sgYWRkcmVzcyB2YWxpZGl0eSAqLwoJCWlmIChhZGRyX2xpc3RbaV0gPCAweDAzIHx8IGFkZHJfbGlzdFtpXSA+IDB4NzcpIHsKCQkJZGV2X3dhcm4oJmFkYXAtPmRldiwgIkludmFsaWQgNy1iaXQgYWRkcmVzcyAiCgkJCQkgIjB4JTAyeFxuIiwgYWRkcl9saXN0W2ldKTsKCQkJY29udGludWU7CgkJfQoKCQkvKiBDaGVjayBhZGRyZXNzIGF2YWlsYWJpbGl0eSAqLwoJCWlmIChfX2kyY19jaGVja19hZGRyKGFkYXAsIGFkZHJfbGlzdFtpXSkpIHsKCQkJZGV2X2RiZygmYWRhcC0+ZGV2LCAiQWRkcmVzcyAweCUwMnggYWxyZWFkeSBpbiAiCgkJCQkidXNlLCBub3QgcHJvYmluZ1xuIiwgYWRkcl9saXN0W2ldKTsKCQkJY29udGludWU7CgkJfQoKCQkvKiBUZXN0IGFkZHJlc3MgcmVzcG9uc2l2ZW5lc3MKCQkgICBUaGUgZGVmYXVsdCBwcm9iZSBtZXRob2QgaXMgYSBxdWljayB3cml0ZSwgYnV0IGl0IGlzIGtub3duCgkJICAgdG8gY29ycnVwdCB0aGUgMjRSRjA4IEVFUFJPTXMgZHVlIHRvIGEgc3RhdGUgbWFjaGluZSBidWcsCgkJICAgYW5kIGNvdWxkIGFsc28gaXJyZXZlcnNpYmx5IHdyaXRlLXByb3RlY3Qgc29tZSBFRVBST01zLCBzbwoJCSAgIGZvciBhZGRyZXNzIHJhbmdlcyAweDMwLTB4MzcgYW5kIDB4NTAtMHg1Ziwgd2UgdXNlIGEgYnl0ZQoJCSAgIHJlYWQgaW5zdGVhZC4gQWxzbywgc29tZSBidXMgZHJpdmVycyBkb24ndCBpbXBsZW1lbnQKCQkgICBxdWljayB3cml0ZSwgc28gd2UgZmFsbGJhY2sgdG8gYSBieXRlIHJlYWQgaXQgdGhhdCBjYXNlCgkJICAgdG9vLiAqLwoJCWlmICgoYWRkcl9saXN0W2ldICYgfjB4MDcpID09IDB4MzAKCQkgfHwgKGFkZHJfbGlzdFtpXSAmIH4weDBmKSA9PSAweDUwCgkJIHx8ICFpMmNfY2hlY2tfZnVuY3Rpb25hbGl0eShhZGFwLCBJMkNfRlVOQ19TTUJVU19RVUlDSykpIHsKCQkJaWYgKGkyY19zbWJ1c194ZmVyKGFkYXAsIGFkZHJfbGlzdFtpXSwgMCwKCQkJCQkgICBJMkNfU01CVVNfUkVBRCwgMCwKCQkJCQkgICBJMkNfU01CVVNfQllURSwgTlVMTCkgPj0gMCkKCQkJCWJyZWFrOwoJCX0gZWxzZSB7CgkJCWlmIChpMmNfc21idXNfeGZlcihhZGFwLCBhZGRyX2xpc3RbaV0sIDAsCgkJCQkJICAgSTJDX1NNQlVTX1dSSVRFLCAwLAoJCQkJCSAgIEkyQ19TTUJVU19RVUlDSywgTlVMTCkgPj0gMCkKCQkJCWJyZWFrOwoJCX0KCX0KCW11dGV4X3VubG9jaygmYWRhcC0+Y2xpc3RfbG9jayk7CgoJaWYgKGFkZHJfbGlzdFtpXSA9PSBJMkNfQ0xJRU5UX0VORCkgewoJCWRldl9kYmcoJmFkYXAtPmRldiwgIlByb2JpbmcgZmFpbGVkLCBubyBkZXZpY2UgZm91bmRcbiIpOwoJCXJldHVybiBOVUxMOwoJfQoKCWluZm8tPmFkZHIgPSBhZGRyX2xpc3RbaV07CglyZXR1cm4gaTJjX25ld19kZXZpY2UoYWRhcCwgaW5mbyk7Cn0KRVhQT1JUX1NZTUJPTF9HUEwoaTJjX25ld19wcm9iZWRfZGV2aWNlKTsKCnN0cnVjdCBpMmNfYWRhcHRlciogaTJjX2dldF9hZGFwdGVyKGludCBpZCkKewoJc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyOwoKCW11dGV4X2xvY2soJmNvcmVfbGlzdHMpOwoJYWRhcHRlciA9IChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKilpZHJfZmluZCgmaTJjX2FkYXB0ZXJfaWRyLCBpZCk7CglpZiAoYWRhcHRlciAmJiAhdHJ5X21vZHVsZV9nZXQoYWRhcHRlci0+b3duZXIpKQoJCWFkYXB0ZXIgPSBOVUxMOwoKCW11dGV4X3VubG9jaygmY29yZV9saXN0cyk7CglyZXR1cm4gYWRhcHRlcjsKfQpFWFBPUlRfU1lNQk9MKGkyY19nZXRfYWRhcHRlcik7Cgp2b2lkIGkyY19wdXRfYWRhcHRlcihzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXApCnsKCW1vZHVsZV9wdXQoYWRhcC0+b3duZXIpOwp9CkVYUE9SVF9TWU1CT0woaTJjX3B1dF9hZGFwdGVyKTsKCi8qIFRoZSBTTUJ1cyBwYXJ0cyAqLwoKI2RlZmluZSBQT0xZICAgICgweDEwNzBVIDw8IDMpCnN0YXRpYyB1OApjcmM4KHUxNiBkYXRhKQp7CglpbnQgaTsKCglmb3IoaSA9IDA7IGkgPCA4OyBpKyspIHsKCQlpZiAoZGF0YSAmIDB4ODAwMCkKCQkJZGF0YSA9IGRhdGEgXiBQT0xZOwoJCWRhdGEgPSBkYXRhIDw8IDE7Cgl9CglyZXR1cm4gKHU4KShkYXRhID4+IDgpOwp9CgovKiBJbmNyZW1lbnRhbCBDUkM4IG92ZXIgY291bnQgYnl0ZXMgaW4gdGhlIGFycmF5IHBvaW50ZWQgdG8gYnkgcCAqLwpzdGF0aWMgdTggaTJjX3NtYnVzX3BlYyh1OCBjcmMsIHU4ICpwLCBzaXplX3QgY291bnQpCnsKCWludCBpOwoKCWZvcihpID0gMDsgaSA8IGNvdW50OyBpKyspCgkJY3JjID0gY3JjOCgoY3JjIF4gcFtpXSkgPDwgOCk7CglyZXR1cm4gY3JjOwp9CgovKiBBc3N1bWUgYSA3LWJpdCBhZGRyZXNzLCB3aGljaCBpcyByZWFzb25hYmxlIGZvciBTTUJ1cyAqLwpzdGF0aWMgdTggaTJjX3NtYnVzX21zZ19wZWModTggcGVjLCBzdHJ1Y3QgaTJjX21zZyAqbXNnKQp7CgkvKiBUaGUgYWRkcmVzcyB3aWxsIGJlIHNlbnQgZmlyc3QgKi8KCXU4IGFkZHIgPSAobXNnLT5hZGRyIDw8IDEpIHwgISEobXNnLT5mbGFncyAmIEkyQ19NX1JEKTsKCXBlYyA9IGkyY19zbWJ1c19wZWMocGVjLCAmYWRkciwgMSk7CgoJLyogVGhlIGRhdGEgYnVmZmVyIGZvbGxvd3MgKi8KCXJldHVybiBpMmNfc21idXNfcGVjKHBlYywgbXNnLT5idWYsIG1zZy0+bGVuKTsKfQoKLyogVXNlZCBmb3Igd3JpdGUgb25seSB0cmFuc2FjdGlvbnMgKi8Kc3RhdGljIGlubGluZSB2b2lkIGkyY19zbWJ1c19hZGRfcGVjKHN0cnVjdCBpMmNfbXNnICptc2cpCnsKCW1zZy0+YnVmW21zZy0+bGVuXSA9IGkyY19zbWJ1c19tc2dfcGVjKDAsIG1zZyk7Cgltc2ctPmxlbisrOwp9CgovKiBSZXR1cm4gPDAgb24gQ1JDIGVycm9yCiAgIElmIHRoZXJlIHdhcyBhIHdyaXRlIGJlZm9yZSB0aGlzIHJlYWQgKG1vc3QgY2FzZXMpIHdlIG5lZWQgdG8gdGFrZSB0aGUKICAgcGFydGlhbCBDUkMgZnJvbSB0aGUgd3JpdGUgcGFydCBpbnRvIGFjY291bnQuCiAgIE5vdGUgdGhhdCB0aGlzIGZ1bmN0aW9uIGRvZXMgbW9kaWZ5IHRoZSBtZXNzYWdlICh3ZSBuZWVkIHRvIGRlY3JlYXNlIHRoZQogICBtZXNzYWdlIGxlbmd0aCB0byBoaWRlIHRoZSBDUkMgYnl0ZSBmcm9tIHRoZSBjYWxsZXIpLiAqLwpzdGF0aWMgaW50IGkyY19zbWJ1c19jaGVja19wZWModTggY3BlYywgc3RydWN0IGkyY19tc2cgKm1zZykKewoJdTggcnBlYyA9IG1zZy0+YnVmWy0tbXNnLT5sZW5dOwoJY3BlYyA9IGkyY19zbWJ1c19tc2dfcGVjKGNwZWMsIG1zZyk7CgoJaWYgKHJwZWMgIT0gY3BlYykgewoJCXByX2RlYnVnKCJpMmMtY29yZTogQmFkIFBFQyAweCUwMnggdnMuIDB4JTAyeFxuIiwKCQkJcnBlYywgY3BlYyk7CgkJcmV0dXJuIC0xOwoJfQoJcmV0dXJuIDA7Cn0KCnMzMiBpMmNfc21idXNfd3JpdGVfcXVpY2soc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdTggdmFsdWUpCnsKCXJldHVybiBpMmNfc21idXNfeGZlcihjbGllbnQtPmFkYXB0ZXIsY2xpZW50LT5hZGRyLGNsaWVudC0+ZmxhZ3MsCgkgICAgICAgICAgICAgICAgICAgICAgdmFsdWUsMCxJMkNfU01CVVNfUVVJQ0ssTlVMTCk7Cn0KRVhQT1JUX1NZTUJPTChpMmNfc21idXNfd3JpdGVfcXVpY2spOwoKczMyIGkyY19zbWJ1c19yZWFkX2J5dGUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKewoJdW5pb24gaTJjX3NtYnVzX2RhdGEgZGF0YTsKCWlmIChpMmNfc21idXNfeGZlcihjbGllbnQtPmFkYXB0ZXIsY2xpZW50LT5hZGRyLGNsaWVudC0+ZmxhZ3MsCgkgICAgICAgICAgICAgICAgICAgSTJDX1NNQlVTX1JFQUQsMCxJMkNfU01CVVNfQllURSwgJmRhdGEpKQoJCXJldHVybiAtMTsKCWVsc2UKCQlyZXR1cm4gZGF0YS5ieXRlOwp9CkVYUE9SVF9TWU1CT0woaTJjX3NtYnVzX3JlYWRfYnl0ZSk7CgpzMzIgaTJjX3NtYnVzX3dyaXRlX2J5dGUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdTggdmFsdWUpCnsKCXJldHVybiBpMmNfc21idXNfeGZlcihjbGllbnQtPmFkYXB0ZXIsY2xpZW50LT5hZGRyLGNsaWVudC0+ZmxhZ3MsCgkgICAgICAgICAgICAgICAgICAgICAgSTJDX1NNQlVTX1dSSVRFLCB2YWx1ZSwgSTJDX1NNQlVTX0JZVEUsIE5VTEwpOwp9CkVYUE9SVF9TWU1CT0woaTJjX3NtYnVzX3dyaXRlX2J5dGUpOwoKczMyIGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCB1OCBjb21tYW5kKQp7Cgl1bmlvbiBpMmNfc21idXNfZGF0YSBkYXRhOwoJaWYgKGkyY19zbWJ1c194ZmVyKGNsaWVudC0+YWRhcHRlcixjbGllbnQtPmFkZHIsY2xpZW50LT5mbGFncywKCSAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfUkVBRCxjb21tYW5kLCBJMkNfU01CVVNfQllURV9EQVRBLCZkYXRhKSkKCQlyZXR1cm4gLTE7CgllbHNlCgkJcmV0dXJuIGRhdGEuYnl0ZTsKfQpFWFBPUlRfU1lNQk9MKGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YSk7CgpzMzIgaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCB1OCBjb21tYW5kLCB1OCB2YWx1ZSkKewoJdW5pb24gaTJjX3NtYnVzX2RhdGEgZGF0YTsKCWRhdGEuYnl0ZSA9IHZhbHVlOwoJcmV0dXJuIGkyY19zbWJ1c194ZmVyKGNsaWVudC0+YWRhcHRlcixjbGllbnQtPmFkZHIsY2xpZW50LT5mbGFncywKCSAgICAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfV1JJVEUsY29tbWFuZCwKCSAgICAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfQllURV9EQVRBLCZkYXRhKTsKfQpFWFBPUlRfU1lNQk9MKGkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEpOwoKczMyIGkyY19zbWJ1c19yZWFkX3dvcmRfZGF0YShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCB1OCBjb21tYW5kKQp7Cgl1bmlvbiBpMmNfc21idXNfZGF0YSBkYXRhOwoJaWYgKGkyY19zbWJ1c194ZmVyKGNsaWVudC0+YWRhcHRlcixjbGllbnQtPmFkZHIsY2xpZW50LT5mbGFncywKCSAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfUkVBRCxjb21tYW5kLCBJMkNfU01CVVNfV09SRF9EQVRBLCAmZGF0YSkpCgkJcmV0dXJuIC0xOwoJZWxzZQoJCXJldHVybiBkYXRhLndvcmQ7Cn0KRVhQT1JUX1NZTUJPTChpMmNfc21idXNfcmVhZF93b3JkX2RhdGEpOwoKczMyIGkyY19zbWJ1c193cml0ZV93b3JkX2RhdGEoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdTggY29tbWFuZCwgdTE2IHZhbHVlKQp7Cgl1bmlvbiBpMmNfc21idXNfZGF0YSBkYXRhOwoJZGF0YS53b3JkID0gdmFsdWU7CglyZXR1cm4gaTJjX3NtYnVzX3hmZXIoY2xpZW50LT5hZGFwdGVyLGNsaWVudC0+YWRkcixjbGllbnQtPmZsYWdzLAoJICAgICAgICAgICAgICAgICAgICAgIEkyQ19TTUJVU19XUklURSxjb21tYW5kLAoJICAgICAgICAgICAgICAgICAgICAgIEkyQ19TTUJVU19XT1JEX0RBVEEsJmRhdGEpOwp9CkVYUE9SVF9TWU1CT0woaTJjX3NtYnVzX3dyaXRlX3dvcmRfZGF0YSk7CgovKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgcmVhZCBieXRlcyAqLwpzMzIgaTJjX3NtYnVzX3JlYWRfYmxvY2tfZGF0YShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCB1OCBjb21tYW5kLAoJCQkgICAgICB1OCAqdmFsdWVzKQp7Cgl1bmlvbiBpMmNfc21idXNfZGF0YSBkYXRhOwoKCWlmIChpMmNfc21idXNfeGZlcihjbGllbnQtPmFkYXB0ZXIsIGNsaWVudC0+YWRkciwgY2xpZW50LT5mbGFncywKCSAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfUkVBRCwgY29tbWFuZCwKCSAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfQkxPQ0tfREFUQSwgJmRhdGEpKQoJCXJldHVybiAtMTsKCgltZW1jcHkodmFsdWVzLCAmZGF0YS5ibG9ja1sxXSwgZGF0YS5ibG9ja1swXSk7CglyZXR1cm4gZGF0YS5ibG9ja1swXTsKfQpFWFBPUlRfU1lNQk9MKGkyY19zbWJ1c19yZWFkX2Jsb2NrX2RhdGEpOwoKczMyIGkyY19zbWJ1c193cml0ZV9ibG9ja19kYXRhKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIHU4IGNvbW1hbmQsCgkJCSAgICAgICB1OCBsZW5ndGgsIGNvbnN0IHU4ICp2YWx1ZXMpCnsKCXVuaW9uIGkyY19zbWJ1c19kYXRhIGRhdGE7CgoJaWYgKGxlbmd0aCA+IEkyQ19TTUJVU19CTE9DS19NQVgpCgkJbGVuZ3RoID0gSTJDX1NNQlVTX0JMT0NLX01BWDsKCWRhdGEuYmxvY2tbMF0gPSBsZW5ndGg7CgltZW1jcHkoJmRhdGEuYmxvY2tbMV0sIHZhbHVlcywgbGVuZ3RoKTsKCXJldHVybiBpMmNfc21idXNfeGZlcihjbGllbnQtPmFkYXB0ZXIsY2xpZW50LT5hZGRyLGNsaWVudC0+ZmxhZ3MsCgkJCSAgICAgIEkyQ19TTUJVU19XUklURSxjb21tYW5kLAoJCQkgICAgICBJMkNfU01CVVNfQkxPQ0tfREFUQSwmZGF0YSk7Cn0KRVhQT1JUX1NZTUJPTChpMmNfc21idXNfd3JpdGVfYmxvY2tfZGF0YSk7CgovKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgcmVhZCBieXRlcyAqLwpzMzIgaTJjX3NtYnVzX3JlYWRfaTJjX2Jsb2NrX2RhdGEoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdTggY29tbWFuZCwKCQkJCSAgdTggbGVuZ3RoLCB1OCAqdmFsdWVzKQp7Cgl1bmlvbiBpMmNfc21idXNfZGF0YSBkYXRhOwoKCWlmIChsZW5ndGggPiBJMkNfU01CVVNfQkxPQ0tfTUFYKQoJCWxlbmd0aCA9IEkyQ19TTUJVU19CTE9DS19NQVg7CglkYXRhLmJsb2NrWzBdID0gbGVuZ3RoOwoJaWYgKGkyY19zbWJ1c194ZmVyKGNsaWVudC0+YWRhcHRlcixjbGllbnQtPmFkZHIsY2xpZW50LT5mbGFncywKCSAgICAgICAgICAgICAgICAgICAgICBJMkNfU01CVVNfUkVBRCxjb21tYW5kLAoJICAgICAgICAgICAgICAgICAgICAgIEkyQ19TTUJVU19JMkNfQkxPQ0tfREFUQSwmZGF0YSkpCgkJcmV0dXJuIC0xOwoKCW1lbWNweSh2YWx1ZXMsICZkYXRhLmJsb2NrWzFdLCBkYXRhLmJsb2NrWzBdKTsKCXJldHVybiBkYXRhLmJsb2NrWzBdOwp9CkVYUE9SVF9TWU1CT0woaTJjX3NtYnVzX3JlYWRfaTJjX2Jsb2NrX2RhdGEpOwoKczMyIGkyY19zbWJ1c193cml0ZV9pMmNfYmxvY2tfZGF0YShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCB1OCBjb21tYW5kLAoJCQkJICAgdTggbGVuZ3RoLCBjb25zdCB1OCAqdmFsdWVzKQp7Cgl1bmlvbiBpMmNfc21idXNfZGF0YSBkYXRhOwoKCWlmIChsZW5ndGggPiBJMkNfU01CVVNfQkxPQ0tfTUFYKQoJCWxlbmd0aCA9IEkyQ19TTUJVU19CTE9DS19NQVg7CglkYXRhLmJsb2NrWzBdID0gbGVuZ3RoOwoJbWVtY3B5KGRhdGEuYmxvY2sgKyAxLCB2YWx1ZXMsIGxlbmd0aCk7CglyZXR1cm4gaTJjX3NtYnVzX3hmZXIoY2xpZW50LT5hZGFwdGVyLCBjbGllbnQtPmFkZHIsIGNsaWVudC0+ZmxhZ3MsCgkJCSAgICAgIEkyQ19TTUJVU19XUklURSwgY29tbWFuZCwKCQkJICAgICAgSTJDX1NNQlVTX0kyQ19CTE9DS19EQVRBLCAmZGF0YSk7Cn0KRVhQT1JUX1NZTUJPTChpMmNfc21idXNfd3JpdGVfaTJjX2Jsb2NrX2RhdGEpOwoKLyogU2ltdWxhdGUgYSBTTUJ1cyBjb21tYW5kIHVzaW5nIHRoZSBpMmMgcHJvdG9jb2wKICAgTm8gY2hlY2tpbmcgb2YgcGFyYW1ldGVycyBpcyBkb25lISAgKi8Kc3RhdGljIHMzMiBpMmNfc21idXNfeGZlcl9lbXVsYXRlZChzdHJ1Y3QgaTJjX2FkYXB0ZXIgKiBhZGFwdGVyLCB1MTYgYWRkciwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBzaG9ydCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGFyIHJlYWRfd3JpdGUsIHU4IGNvbW1hbmQsIGludCBzaXplLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuaW9uIGkyY19zbWJ1c19kYXRhICogZGF0YSkKewoJLyogU28gd2UgbmVlZCB0byBnZW5lcmF0ZSBhIHNlcmllcyBvZiBtc2dzLiBJbiB0aGUgY2FzZSBvZiB3cml0aW5nLCB3ZQoJICBuZWVkIHRvIHVzZSBvbmx5IG9uZSBtZXNzYWdlOyB3aGVuIHJlYWRpbmcsIHdlIG5lZWQgdHdvLiBXZSBpbml0aWFsaXplCgkgIG1vc3QgdGhpbmdzIHdpdGggc2FuZSBkZWZhdWx0cywgdG8ga2VlcCB0aGUgY29kZSBiZWxvdyBzb21ld2hhdAoJICBzaW1wbGVyLiAqLwoJdW5zaWduZWQgY2hhciBtc2didWYwW0kyQ19TTUJVU19CTE9DS19NQVgrM107Cgl1bnNpZ25lZCBjaGFyIG1zZ2J1ZjFbSTJDX1NNQlVTX0JMT0NLX01BWCsyXTsKCWludCBudW0gPSByZWFkX3dyaXRlID09IEkyQ19TTUJVU19SRUFEPzI6MTsKCXN0cnVjdCBpMmNfbXNnIG1zZ1syXSA9IHsgeyBhZGRyLCBmbGFncywgMSwgbXNnYnVmMCB9LAoJICAgICAgICAgICAgICAgICAgICAgICAgICB7IGFkZHIsIGZsYWdzIHwgSTJDX01fUkQsIDAsIG1zZ2J1ZjEgfQoJICAgICAgICAgICAgICAgICAgICAgICAgfTsKCWludCBpOwoJdTggcGFydGlhbF9wZWMgPSAwOwoKCW1zZ2J1ZjBbMF0gPSBjb21tYW5kOwoJc3dpdGNoKHNpemUpIHsKCWNhc2UgSTJDX1NNQlVTX1FVSUNLOgoJCW1zZ1swXS5sZW4gPSAwOwoJCS8qIFNwZWNpYWwgY2FzZTogVGhlIHJlYWQvd3JpdGUgZmllbGQgaXMgdXNlZCBhcyBkYXRhICovCgkJbXNnWzBdLmZsYWdzID0gZmxhZ3MgfCAocmVhZF93cml0ZT09STJDX1NNQlVTX1JFQUQpP0kyQ19NX1JEOjA7CgkJbnVtID0gMTsKCQlicmVhazsKCWNhc2UgSTJDX1NNQlVTX0JZVEU6CgkJaWYgKHJlYWRfd3JpdGUgPT0gSTJDX1NNQlVTX1JFQUQpIHsKCQkJLyogU3BlY2lhbCBjYXNlOiBvbmx5IGEgcmVhZCEgKi8KCQkJbXNnWzBdLmZsYWdzID0gSTJDX01fUkQgfCBmbGFnczsKCQkJbnVtID0gMTsKCQl9CgkJYnJlYWs7CgljYXNlIEkyQ19TTUJVU19CWVRFX0RBVEE6CgkJaWYgKHJlYWRfd3JpdGUgPT0gSTJDX1NNQlVTX1JFQUQpCgkJCW1zZ1sxXS5sZW4gPSAxOwoJCWVsc2UgewoJCQltc2dbMF0ubGVuID0gMjsKCQkJbXNnYnVmMFsxXSA9IGRhdGEtPmJ5dGU7CgkJfQoJCWJyZWFrOwoJY2FzZSBJMkNfU01CVVNfV09SRF9EQVRBOgoJCWlmIChyZWFkX3dyaXRlID09IEkyQ19TTUJVU19SRUFEKQoJCQltc2dbMV0ubGVuID0gMjsKCQllbHNlIHsKCQkJbXNnWzBdLmxlbj0zOwoJCQltc2didWYwWzFdID0gZGF0YS0+d29yZCAmIDB4ZmY7CgkJCW1zZ2J1ZjBbMl0gPSBkYXRhLT53b3JkID4+IDg7CgkJfQoJCWJyZWFrOwoJY2FzZSBJMkNfU01CVVNfUFJPQ19DQUxMOgoJCW51bSA9IDI7IC8qIFNwZWNpYWwgY2FzZSAqLwoJCXJlYWRfd3JpdGUgPSBJMkNfU01CVVNfUkVBRDsKCQltc2dbMF0ubGVuID0gMzsKCQltc2dbMV0ubGVuID0gMjsKCQltc2didWYwWzFdID0gZGF0YS0+d29yZCAmIDB4ZmY7CgkJbXNnYnVmMFsyXSA9IGRhdGEtPndvcmQgPj4gODsKCQlicmVhazsKCWNhc2UgSTJDX1NNQlVTX0JMT0NLX0RBVEE6CgkJaWYgKHJlYWRfd3JpdGUgPT0gSTJDX1NNQlVTX1JFQUQpIHsKCQkJbXNnWzFdLmZsYWdzIHw9IEkyQ19NX1JFQ1ZfTEVOOwoJCQltc2dbMV0ubGVuID0gMTsgLyogYmxvY2sgbGVuZ3RoIHdpbGwgYmUgYWRkZWQgYnkKCQkJCQkgICB0aGUgdW5kZXJseWluZyBidXMgZHJpdmVyICovCgkJfSBlbHNlIHsKCQkJbXNnWzBdLmxlbiA9IGRhdGEtPmJsb2NrWzBdICsgMjsKCQkJaWYgKG1zZ1swXS5sZW4gPiBJMkNfU01CVVNfQkxPQ0tfTUFYICsgMikgewoJCQkJZGV2X2VycigmYWRhcHRlci0+ZGV2LCAic21idXNfYWNjZXNzIGNhbGxlZCB3aXRoICIKCQkJCSAgICAgICAiaW52YWxpZCBibG9jayB3cml0ZSBzaXplICglZClcbiIsCgkJCQkgICAgICAgZGF0YS0+YmxvY2tbMF0pOwoJCQkJcmV0dXJuIC0xOwoJCQl9CgkJCWZvciAoaSA9IDE7IGkgPCBtc2dbMF0ubGVuOyBpKyspCgkJCQltc2didWYwW2ldID0gZGF0YS0+YmxvY2tbaS0xXTsKCQl9CgkJYnJlYWs7CgljYXNlIEkyQ19TTUJVU19CTE9DS19QUk9DX0NBTEw6CgkJbnVtID0gMjsgLyogQW5vdGhlciBzcGVjaWFsIGNhc2UgKi8KCQlyZWFkX3dyaXRlID0gSTJDX1NNQlVTX1JFQUQ7CgkJaWYgKGRhdGEtPmJsb2NrWzBdID4gSTJDX1NNQlVTX0JMT0NLX01BWCkgewoJCQlkZXZfZXJyKCZhZGFwdGVyLT5kZXYsICIlcyBjYWxsZWQgd2l0aCBpbnZhbGlkICIKCQkJCSJibG9jayBwcm9jIGNhbGwgc2l6ZSAoJWQpXG4iLCBfX0ZVTkNUSU9OX18sCgkJCQlkYXRhLT5ibG9ja1swXSk7CgkJCXJldHVybiAtMTsKCQl9CgkJbXNnWzBdLmxlbiA9IGRhdGEtPmJsb2NrWzBdICsgMjsKCQlmb3IgKGkgPSAxOyBpIDwgbXNnWzBdLmxlbjsgaSsrKQoJCQltc2didWYwW2ldID0gZGF0YS0+YmxvY2tbaS0xXTsKCQltc2dbMV0uZmxhZ3MgfD0gSTJDX01fUkVDVl9MRU47CgkJbXNnWzFdLmxlbiA9IDE7IC8qIGJsb2NrIGxlbmd0aCB3aWxsIGJlIGFkZGVkIGJ5CgkJCQkgICB0aGUgdW5kZXJseWluZyBidXMgZHJpdmVyICovCgkJYnJlYWs7CgljYXNlIEkyQ19TTUJVU19JMkNfQkxPQ0tfREFUQToKCQlpZiAocmVhZF93cml0ZSA9PSBJMkNfU01CVVNfUkVBRCkgewoJCQltc2dbMV0ubGVuID0gZGF0YS0+YmxvY2tbMF07CgkJfSBlbHNlIHsKCQkJbXNnWzBdLmxlbiA9IGRhdGEtPmJsb2NrWzBdICsgMTsKCQkJaWYgKG1zZ1swXS5sZW4gPiBJMkNfU01CVVNfQkxPQ0tfTUFYICsgMSkgewoJCQkJZGV2X2VycigmYWRhcHRlci0+ZGV2LCAiaTJjX3NtYnVzX3hmZXJfZW11bGF0ZWQgY2FsbGVkIHdpdGggIgoJCQkJICAgICAgICJpbnZhbGlkIGJsb2NrIHdyaXRlIHNpemUgKCVkKVxuIiwKCQkJCSAgICAgICBkYXRhLT5ibG9ja1swXSk7CgkJCQlyZXR1cm4gLTE7CgkJCX0KCQkJZm9yIChpID0gMTsgaSA8PSBkYXRhLT5ibG9ja1swXTsgaSsrKQoJCQkJbXNnYnVmMFtpXSA9IGRhdGEtPmJsb2NrW2ldOwoJCX0KCQlicmVhazsKCWRlZmF1bHQ6CgkJZGV2X2VycigmYWRhcHRlci0+ZGV2LCAic21idXNfYWNjZXNzIGNhbGxlZCB3aXRoIGludmFsaWQgc2l6ZSAoJWQpXG4iLAoJCSAgICAgICBzaXplKTsKCQlyZXR1cm4gLTE7Cgl9CgoJaSA9ICgoZmxhZ3MgJiBJMkNfQ0xJRU5UX1BFQykgJiYgc2l6ZSAhPSBJMkNfU01CVVNfUVVJQ0sKCQkJCSAgICAgICYmIHNpemUgIT0gSTJDX1NNQlVTX0kyQ19CTE9DS19EQVRBKTsKCWlmIChpKSB7CgkJLyogQ29tcHV0ZSBQRUMgaWYgZmlyc3QgbWVzc2FnZSBpcyBhIHdyaXRlICovCgkJaWYgKCEobXNnWzBdLmZsYWdzICYgSTJDX01fUkQpKSB7CgkJCWlmIChudW0gPT0gMSkgLyogV3JpdGUgb25seSAqLwoJCQkJaTJjX3NtYnVzX2FkZF9wZWMoJm1zZ1swXSk7CgkJCWVsc2UgLyogV3JpdGUgZm9sbG93ZWQgYnkgcmVhZCAqLwoJCQkJcGFydGlhbF9wZWMgPSBpMmNfc21idXNfbXNnX3BlYygwLCAmbXNnWzBdKTsKCQl9CgkJLyogQXNrIGZvciBQRUMgaWYgbGFzdCBtZXNzYWdlIGlzIGEgcmVhZCAqLwoJCWlmIChtc2dbbnVtLTFdLmZsYWdzICYgSTJDX01fUkQpCgkJCW1zZ1tudW0tMV0ubGVuKys7Cgl9CgoJaWYgKGkyY190cmFuc2ZlcihhZGFwdGVyLCBtc2csIG51bSkgPCAwKQoJCXJldHVybiAtMTsKCgkvKiBDaGVjayBQRUMgaWYgbGFzdCBtZXNzYWdlIGlzIGEgcmVhZCAqLwoJaWYgKGkgJiYgKG1zZ1tudW0tMV0uZmxhZ3MgJiBJMkNfTV9SRCkpIHsKCQlpZiAoaTJjX3NtYnVzX2NoZWNrX3BlYyhwYXJ0aWFsX3BlYywgJm1zZ1tudW0tMV0pIDwgMCkKCQkJcmV0dXJuIC0xOwoJfQoKCWlmIChyZWFkX3dyaXRlID09IEkyQ19TTUJVU19SRUFEKQoJCXN3aXRjaChzaXplKSB7CgkJCWNhc2UgSTJDX1NNQlVTX0JZVEU6CgkJCQlkYXRhLT5ieXRlID0gbXNnYnVmMFswXTsKCQkJCWJyZWFrOwoJCQljYXNlIEkyQ19TTUJVU19CWVRFX0RBVEE6CgkJCQlkYXRhLT5ieXRlID0gbXNnYnVmMVswXTsKCQkJCWJyZWFrOwoJCQljYXNlIEkyQ19TTUJVU19XT1JEX0RBVEE6CgkJCWNhc2UgSTJDX1NNQlVTX1BST0NfQ0FMTDoKCQkJCWRhdGEtPndvcmQgPSBtc2didWYxWzBdIHwgKG1zZ2J1ZjFbMV0gPDwgOCk7CgkJCQlicmVhazsKCQkJY2FzZSBJMkNfU01CVVNfSTJDX0JMT0NLX0RBVEE6CgkJCQlmb3IgKGkgPSAwOyBpIDwgZGF0YS0+YmxvY2tbMF07IGkrKykKCQkJCQlkYXRhLT5ibG9ja1tpKzFdID0gbXNnYnVmMVtpXTsKCQkJCWJyZWFrOwoJCQljYXNlIEkyQ19TTUJVU19CTE9DS19EQVRBOgoJCQljYXNlIEkyQ19TTUJVU19CTE9DS19QUk9DX0NBTEw6CgkJCQlmb3IgKGkgPSAwOyBpIDwgbXNnYnVmMVswXSArIDE7IGkrKykKCQkJCQlkYXRhLT5ibG9ja1tpXSA9IG1zZ2J1ZjFbaV07CgkJCQlicmVhazsKCQl9CglyZXR1cm4gMDsKfQoKCnMzMiBpMmNfc21idXNfeGZlcihzdHJ1Y3QgaTJjX2FkYXB0ZXIgKiBhZGFwdGVyLCB1MTYgYWRkciwgdW5zaWduZWQgc2hvcnQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICBjaGFyIHJlYWRfd3JpdGUsIHU4IGNvbW1hbmQsIGludCBzaXplLAogICAgICAgICAgICAgICAgICAgdW5pb24gaTJjX3NtYnVzX2RhdGEgKiBkYXRhKQp7CglzMzIgcmVzOwoKCWZsYWdzICY9IEkyQ19NX1RFTiB8IEkyQ19DTElFTlRfUEVDOwoKCWlmIChhZGFwdGVyLT5hbGdvLT5zbWJ1c194ZmVyKSB7CgkJbXV0ZXhfbG9jaygmYWRhcHRlci0+YnVzX2xvY2spOwoJCXJlcyA9IGFkYXB0ZXItPmFsZ28tPnNtYnVzX3hmZXIoYWRhcHRlcixhZGRyLGZsYWdzLHJlYWRfd3JpdGUsCgkJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb21tYW5kLHNpemUsZGF0YSk7CgkJbXV0ZXhfdW5sb2NrKCZhZGFwdGVyLT5idXNfbG9jayk7Cgl9IGVsc2UKCQlyZXMgPSBpMmNfc21idXNfeGZlcl9lbXVsYXRlZChhZGFwdGVyLGFkZHIsZmxhZ3MscmVhZF93cml0ZSwKCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29tbWFuZCxzaXplLGRhdGEpOwoKCXJldHVybiByZXM7Cn0KRVhQT1JUX1NZTUJPTChpMmNfc21idXNfeGZlcik7CgpNT0RVTEVfQVVUSE9SKCJTaW1vbiBHLiBWb2dsIDxzaW1vbkB0ay51bmktbGluei5hYy5hdD4iKTsKTU9EVUxFX0RFU0NSSVBUSU9OKCJJMkMtQnVzIG1haW4gbW9kdWxlIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsK