LyoKICogREVDIDkzIEVyaWsgQm9zIDxlcmlrQHhzNGFsbC5ubD4KICoKICogQ29weXJpZ2h0IDE5OTYgTWFyY3VzIE1laXNzbmVyCiAqCiAqIENvcHlyaWdodCAyMDAxIE1pa2UgTWNDb3JtYWNrCiAqCiAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKICogdmVyc2lvbiAyLjEgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAqCiAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQogKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgogKgogKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCiAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQogKgogKiBIaXN0b3J5OgogKgogKiBNYXIgMzEsIDE5OTkuIE92ZSBL5XZlbiA8b3Zla0BhcmN0aWNuZXQubm8+CiAqIC0gSW1wbGVtZW50ZWQgYnVmZmVycyBhbmQgRW5hYmxlQ29tbU5vdGlmaWNhdGlvbi4KICoKICogQXByIDMsIDE5OTkuICBMYXdzb24gV2hpdG5leSA8bGF3c29uX3doaXRuZXlAanVuby5jb20+CiAqIC0gRml4ZWQgdGhlIG1vZGVtIGNvbnRyb2wgcGFydCBvZiBFc2NhcGVDb21tRnVuY3Rpb24xNi4KICoKICogTWFyIDMsIDE5OTkuIE92ZSBL5XZlbiA8b3Zla0BhcmN0aWNuZXQubm8+CiAqIC0gVXNlIHBvcnQgaW5kaWNlcyBpbnN0ZWFkIG9mIHVuaXhmZHMgZm9yIHdpbjE2CiAqIC0gTW92ZWQgdGhpbmdzIGFyb3VuZCAoc2VwYXJhdGVkIHdpbjE2IGFuZCB3aW4zMiByb3V0aW5lcykKICogLSBBZGRlZCBzb21lIGhpbnRzIG9uIGhvdyB0byBpbXBsZW1lbnQgYnVmZmVycyBhbmQgRW5hYmxlQ29tbU5vdGlmaWNhdGlvbi4KICoKICogTWF5IDI2LCAxOTk3LiAgRml4ZXMgYW5kIGNvbW1lbnRzIGJ5IFJpY2sgUmljaGFyZHNvbiA8cmlja0BkZ2lpLmNvbT4gW1JFUl0KICogLSBwdHItPmZkIHdhc24ndCBnZXR0aW5nIGNsZWFyZWQgb24gY2xvc2UuCiAqIC0gR2V0Q29tbUV2ZW50TWFzaygpIGFuZCBHZXRDb21tRXJyb3IoKSBkaWRuJ3QgZG8gbXVjaCBvZiBhbnl0aGluZy4KICogICBJTUhPLCB0aGV5IGFyZSBzdGlsbCB3cm9uZywgYnV0IHRoZXkgYXQgbGVhc3QgaW1wbGVtZW50IHRoZSBSWENIQVIKICogICBldmVudCBhbmQgcmV0dXJuIEkvTyBxdWV1ZSBzaXplcywgd2hpY2ggbWFrZXMgdGhlIGFwcCBJJ20gaW50ZXJlc3RlZAogKiAgIGluIChhbmFsb2cgZGV2aWNlcyBFWktJVCBEU1AgZGV2ZWxvcG1lbnQgc3lzdGVtKSB3b3JrLgogKgogKiBBdWd1c3QgMTIsIDE5OTcuICBUYWtlIGEgYmFzaCBhdCBTZXRDb21tRXZlbnRNYXNrIC0gTGF3c29uIFdoaXRuZXkKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGxhd3Nvbl93aGl0bmV5QGp1bm8uY29tPgogKiBKdWx5IDYsIDE5OTguIEZpeGVzIGFuZCBjb21tZW50cyBieSBWYWxlbnRpam4gU2Vzc2luawogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8dnNlc3NpbmtAaWMudXZhLm5sPiBbVl0KICogT2t0b2JlciA5OCwgUmVpbiBLbGF6ZXMgW1JIS10KICogQSBwcm9ncmFtIHRoYXQgd2FudHMgdG8gbW9uaXRvciB0aGUgbW9kZW0gc3RhdHVzIGxpbmUgKFJMU0QvRENEKSBtYXkKICogcG9sbCB0aGUgbW9kZW0gc3RhdHVzIHJlZ2lzdGVyIGluIHRoZSBjb21tTWFzayBzdHJ1Y3R1cmUuIEkgdXBkYXRlIHRoZSBiaXQKICogaW4gR2V0Q29tbUVycm9yLCB3YWl0aW5nIGZvciBhbiBpbXBsZW1lbnRhdGlvbiBvZiBjb21tdW5pY2F0aW9uIGV2ZW50cy4KICoKICovCgojaW5jbHVkZSAiY29uZmlnLmgiCiNpbmNsdWRlICJ3aW5lL3BvcnQuaCIKCiNpbmNsdWRlIDxzdGRsaWIuaD4KI2luY2x1ZGUgPHN0ZGFyZy5oPgojaW5jbHVkZSA8c3RkaW8uaD4KI2luY2x1ZGUgPHN0cmluZy5oPgojaW5jbHVkZSA8ZXJybm8uaD4KI2luY2x1ZGUgPGN0eXBlLmg+CgojaW5jbHVkZSAibnRzdGF0dXMuaCIKI2luY2x1ZGUgIndpbmRlZi5oIgojaW5jbHVkZSAid2luYmFzZS5oIgojaW5jbHVkZSAid2luZ2RpLmgiCiNpbmNsdWRlICJ3aW5lL3dpbnVzZXIxNi5oIgojaW5jbHVkZSAid2luLmgiCiNpbmNsdWRlICJ1c2VyX3ByaXZhdGUuaCIKCiNpbmNsdWRlICJ3aW5lL2RlYnVnLmgiCgpXSU5FX0RFRkFVTFRfREVCVUdfQ0hBTk5FTChjb21tKTsKCi8qIHdpbmRvdydzIHNlbWkgZG9jdW1lbnRlZCBtb2RlbSBzdGF0dXMgcmVnaXN0ZXIgKi8KI2RlZmluZSBDT01NX01TUl9PRkZTRVQgIDM1CiNkZWZpbmUgTVNSX0NUUyAgMHgxMAojZGVmaW5lIE1TUl9EU1IgIDB4MjAKI2RlZmluZSBNU1JfUkkgICAweDQwCiNkZWZpbmUgTVNSX1JMU0QgMHg4MAojZGVmaW5lIE1TUl9NQVNLIChNU1JfQ1RTfE1TUl9EU1J8TVNSX1JJfE1TUl9STFNEKQoKI2RlZmluZSBGTEFHX0xQVCAweDgwCgojZGVmaW5lIE1BWF9QT1JUUyAgIDkKCnN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgewogICAgSEFORExFIGhhbmRsZTsKICAgIGludCBzdXNwZW5kZWQ7CiAgICBpbnQgdW5nZXQseG1pdDsKICAgIGludCBldnRjaGFyOwogICAgLyogZXZlbnRzICovCiAgICBpbnQgY29tbWVycm9yLCBldmVudG1hc2s7CiAgICAvKiBidWZmZXJzICovCiAgICBjaGFyICppbmJ1Ziwqb3V0YnVmOwogICAgdW5zaWduZWQgaWJ1Zl9zaXplLGlidWZfaGVhZCxpYnVmX3RhaWw7CiAgICB1bnNpZ25lZCBvYnVmX3NpemUsb2J1Zl9oZWFkLG9idWZfdGFpbDsKICAgIC8qIG5vdGlmaWNhdGlvbnMgKi8KICAgIEhXTkQgd25kOwogICAgaW50IG5fcmVhZCwgbl93cml0ZTsKICAgIE9WRVJMQVBQRUQgcmVhZF9vdiwgd3JpdGVfb3Y7CiAgICAvKiBzYXZlIHRlcm1pbmFsIHN0YXRlcyAqLwogICAgRENCMTYgZGNiOwogICAgLyogcG9pbnRlciB0byB1bmtub3duKD09dW5kb2N1bWVudGVkKSBjb21tIHN0cnVjdHVyZSAqLwogICAgU0VHUFRSIHNlZ191bmtub3duOwogICAgQllURSB1bmtub3duWzQwXTsKfTsKCnN0YXRpYyBzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0IENPTVtNQVhfUE9SVFNdOwpzdGF0aWMgc3RydWN0IERvc0RldmljZVN0cnVjdCBMUFRbTUFYX1BPUlRTXTsKCi8qIHVwZGF0ZSB3aW5kb3cncyBzZW1pIGRvY3VtZW50ZWQgbW9kZW0gc3RhdHVzIHJlZ2lzdGVyICovCi8qIHNlZSBrbm93bGVkZ2UgYmFzZSBRMTAxNDE3ICovCnN0YXRpYyB2b2lkIENPTU1fTVNSVXBkYXRlKCBIQU5ETEUgaGFuZGxlLCBVQ0hBUiAqIHBNc3IgKQp7CiAgICBVQ0hBUiB0bXBtc3I9MDsKICAgIERXT1JEIG1zdGF0PTA7CgogICAgaWYoIUdldENvbW1Nb2RlbVN0YXR1cyhoYW5kbGUsJm1zdGF0KSkKICAgICAgICByZXR1cm47CgogICAgaWYobXN0YXQgJiBNU19DVFNfT04pIHRtcG1zciB8PSBNU1JfQ1RTOwogICAgaWYobXN0YXQgJiBNU19EU1JfT04pIHRtcG1zciB8PSBNU1JfRFNSOwogICAgaWYobXN0YXQgJiBNU19SSU5HX09OKSB0bXBtc3IgfD0gTVNSX1JJOwogICAgaWYobXN0YXQgJiBNU19STFNEX09OKSB0bXBtc3IgfD0gTVNSX1JMU0Q7CiAgICAqcE1zciA9ICgqcE1zciAmIH5NU1JfTUFTSykgfCB0bXBtc3I7Cn0KCnN0YXRpYyBzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpHZXREZXZpY2VTdHJ1Y3QoaW50IGluZGV4KQp7CglpZiAoKGluZGV4JjB4N0YpPD1NQVhfUE9SVFMpIHsKICAgICAgICAgICAgaWYgKCEoaW5kZXgmRkxBR19MUFQpKSB7CgkJaWYgKENPTVtpbmRleF0uaGFuZGxlKQoJCSAgICByZXR1cm4gJkNPTVtpbmRleF07CgkgICAgfSBlbHNlIHsKCQlpbmRleCAmPSAweDdmOwoJCWlmIChMUFRbaW5kZXhdLmhhbmRsZSkKCQkgICAgcmV0dXJuICZMUFRbaW5kZXhdOwoJICAgIH0KCX0KCglyZXR1cm4gTlVMTDsKfQoKc3RhdGljIGludCAgICBHZXRDb21tUG9ydF9vdihMUE9WRVJMQVBQRUQgb3YsIGludCB3cml0ZSkKewoJaW50IHg7CgoJZm9yICh4PTA7IHg8TUFYX1BPUlRTOyB4KyspIHsKCQlpZiAob3YgPT0gKHdyaXRlPyZDT01beF0ud3JpdGVfb3Y6JkNPTVt4XS5yZWFkX292KSkKCQkJcmV0dXJuIHg7Cgl9CgoJcmV0dXJuIC0xOwp9CgpzdGF0aWMgaW50IFdpbkVycm9yKHZvaWQpCnsKICAgICAgICBUUkFDRSgiZXJybm8gPSAlZFxuIiwgZXJybm8pOwoJc3dpdGNoIChlcnJubykgewoJCWRlZmF1bHQ6CgkJCXJldHVybiBDRV9JT0U7CgkJfQp9CgpzdGF0aWMgdW5zaWduZWQgY29tbV9pbmJ1ZihzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHIpCnsKICByZXR1cm4gKChwdHItPmlidWZfdGFpbCA+IHB0ci0+aWJ1Zl9oZWFkKSA/IHB0ci0+aWJ1Zl9zaXplIDogMCkKICAgICsgcHRyLT5pYnVmX2hlYWQgLSBwdHItPmlidWZfdGFpbDsKfQoKc3RhdGljIHVuc2lnbmVkIGNvbW1fb3V0YnVmKHN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cikKewogIHJldHVybiAoKHB0ci0+b2J1Zl90YWlsID4gcHRyLT5vYnVmX2hlYWQpID8gcHRyLT5vYnVmX3NpemUgOiAwKQogICAgKyBwdHItPm9idWZfaGVhZCAtIHB0ci0+b2J1Zl90YWlsOwp9CgpzdGF0aWMgdm9pZCBjb21tX3dhaXRyZWFkKHN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cik7CnN0YXRpYyB2b2lkIGNvbW1fd2FpdHdyaXRlKHN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cik7CgpzdGF0aWMgVk9JRCBXSU5BUEkgQ09NTTE2X1JlYWRDb21wbGV0ZShEV09SRCBzdGF0dXMsIERXT1JEIGxlbiwgTFBPVkVSTEFQUEVEIG92KQp7CglpbnQgcHJldiA7CglXT1JEIG1hc2sgPSAwOwoJaW50IGNpZCA9IEdldENvbW1Qb3J0X292KG92LDApOwoJc3RydWN0IERvc0RldmljZVN0cnVjdCAqcHRyOwoKCWlmKGNpZDwwKSB7CgkJRVJSKCJhc3luYyB3cml0ZSB3aXRoIGJhZCBvdmVybGFwcGVkIHBvaW50ZXJcbiIpOwoJCXJldHVybjsKCX0KCXB0ciA9ICZDT01bY2lkXTsKCgkvKiB3ZSBnZXQgY2FuY2VsbGVkIHdoZW4gQ2xvc2VDb21tIGlzIGNhbGxlZCAqLwoJaWYgKHN0YXR1cz09U1RBVFVTX0NBTkNFTExFRCkKCXsKCQlUUkFDRSgiQ2FuY2VsbGVkXG4iKTsKCQlyZXR1cm47Cgl9CgoJLyogcmVhZCBkYXRhIGZyb20gY29tbSBwb3J0ICovCglpZiAoc3RhdHVzICE9IFNUQVRVU19TVUNDRVNTKSB7CgkJRVJSKCJhc3luYyByZWFkIGZhaWxlZCAlMDhseFxuIixzdGF0dXMpOwoJCUNPTVtjaWRdLmNvbW1lcnJvciA9IENFX1JYT1ZFUjsKCQlyZXR1cm47Cgl9CglUUkFDRSgiYXN5bmMgcmVhZCBjb21wbGV0ZWQgJWxkIGJ5dGVzXG4iLGxlbik7CgoJcHJldiA9IGNvbW1faW5idWYocHRyKTsKCgkvKiBjaGVjayBmb3IgZXZlbnRzICovCglpZiAoKHB0ci0+ZXZlbnRtYXNrICYgRVZfUlhGTEFHKSAmJgoJICAgIG1lbWNocihwdHItPmluYnVmICsgcHRyLT5pYnVmX2hlYWQsIHB0ci0+ZXZ0Y2hhciwgbGVuKSkgewoJCSooV09SRCopKENPTVtjaWRdLnVua25vd24pIHw9IEVWX1JYRkxBRzsKCQltYXNrIHw9IENOX0VWRU5UOwoJfQoJaWYgKHB0ci0+ZXZlbnRtYXNrICYgRVZfUlhDSEFSKSB7CgkJKihXT1JEKikoQ09NW2NpZF0udW5rbm93bikgfD0gRVZfUlhDSEFSOwoJCW1hc2sgfD0gQ05fRVZFTlQ7Cgl9CgoJLyogYWR2YW5jZSBidWZmZXIgcG9zaXRpb24gKi8KCXB0ci0+aWJ1Zl9oZWFkICs9IGxlbjsKCWlmIChwdHItPmlidWZfaGVhZCA+PSBwdHItPmlidWZfc2l6ZSkKCQlwdHItPmlidWZfaGVhZCA9IDA7CgoJLyogY2hlY2sgZm9yIG5vdGlmaWNhdGlvbiAqLwoJaWYgKHB0ci0+d25kICYmIChwdHItPm5fcmVhZD4wKSAmJiAocHJldjxwdHItPm5fcmVhZCkgJiYKCSAgICAoY29tbV9pbmJ1ZihwdHIpPj1wdHItPm5fcmVhZCkpIHsKCQkvKiBwYXNzZWQgdGhlIHJlY2VpdmUgbm90aWZpY2F0aW9uIHRocmVzaG9sZCAqLwoJCW1hc2sgfD0gQ05fUkVDRUlWRTsKCX0KCgkvKiBzZW5kIG5vdGlmaWNhdGlvbnMsIGlmIGFueSAqLwoJaWYgKHB0ci0+d25kICYmIG1hc2spIHsKCQlUUkFDRSgibm90aWZ5aW5nICVwOiBjaWQ9JWQsIG1hc2s9JTAyeFxuIiwgcHRyLT53bmQsIGNpZCwgbWFzayk7CgkJUG9zdE1lc3NhZ2VBKHB0ci0+d25kLCBXTV9DT01NTk9USUZZLCBjaWQsIG1hc2spOwoJfQoKCS8qIG9uIHJlYWwgd2luZG93cywgdGhpcyBjb3VsZCBjYXVzZSBwcm9ibGVtcywgc2luY2UgaXQgaXMgcmVjdXJzaXZlICovCgkvKiByZXN0YXJ0IHRoZSByZWNlaXZlICovCgljb21tX3dhaXRyZWFkKHB0cik7Cn0KCi8qIHRoaXMgaXMgbWVhbnQgdG8gd29yayBsaWtlIHdyaXRlKCkgKi8Kc3RhdGljIElOVCBDT01NMTZfV3JpdGVGaWxlKEhBTkRMRSBoQ29tbSwgTFBDVk9JRCBidWZmZXIsIERXT1JEIGxlbikKewoJT1ZFUkxBUFBFRCBvdjsKCURXT1JEIGNvdW50PSAtMTsKCglaZXJvTWVtb3J5KCZvdixzaXplb2Yob3YpKTsKCW92LmhFdmVudCA9IENyZWF0ZUV2ZW50QShOVUxMLDAsMCxOVUxMKTsKCWlmKG92LmhFdmVudD09SU5WQUxJRF9IQU5ETEVfVkFMVUUpCgkJcmV0dXJuIC0xOwoKCWlmKCFXcml0ZUZpbGUoaENvbW0sYnVmZmVyLGxlbiwmY291bnQsJm92KSkKCXsKCQlpZihHZXRMYXN0RXJyb3IoKT09RVJST1JfSU9fUEVORElORykKCQl7CgkJCUdldE92ZXJsYXBwZWRSZXN1bHQoaENvbW0sJm92LCZjb3VudCxUUlVFKTsKCQl9Cgl9CglDbG9zZUhhbmRsZShvdi5oRXZlbnQpOwoKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIFZPSUQgV0lOQVBJIENPTU0xNl9Xcml0ZUNvbXBsZXRlKERXT1JEIHN0YXR1cywgRFdPUkQgbGVuLCBMUE9WRVJMQVBQRUQgb3YpCnsKCWludCBwcmV2LCBibGVmdDsKCVdPUkQgbWFzayA9IDA7CglpbnQgY2lkID0gR2V0Q29tbVBvcnRfb3Yob3YsMSk7CglzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHI7CgoJaWYoY2lkPDApIHsKCQlFUlIoImFzeW5jIHdyaXRlIHdpdGggYmFkIG92ZXJsYXBwZWQgcG9pbnRlclxuIik7CgkJcmV0dXJuOwoJfQoJcHRyID0gJkNPTVtjaWRdOwoKCS8qIHJlYWQgZGF0YSBmcm9tIGNvbW0gcG9ydCAqLwoJaWYgKHN0YXR1cyAhPSBTVEFUVVNfU1VDQ0VTUykgewoJCUVSUigiYXN5bmMgd3JpdGUgZmFpbGVkXG4iKTsKCQlDT01bY2lkXS5jb21tZXJyb3IgPSBDRV9SWE9WRVI7CgkJcmV0dXJuOwoJfQoJVFJBQ0UoImFzeW5jIHdyaXRlIGNvbXBsZXRlZCAlbGQgYnl0ZXNcbiIsbGVuKTsKCgkvKiB1cGRhdGUgdGhlIGJ1ZmZlciBwb2ludGVycyAqLwoJcHJldiA9IGNvbW1fb3V0YnVmKCZDT01bY2lkXSk7CglwdHItPm9idWZfdGFpbCArPSBsZW47CglpZiAocHRyLT5vYnVmX3RhaWwgPj0gcHRyLT5vYnVmX3NpemUpCgkJcHRyLT5vYnVmX3RhaWwgPSAwOwoKCS8qIHdyaXRlIGFueSBUcmFuc21pdENvbW1DaGFyIGNoYXJhY3RlciAqLwoJaWYgKHB0ci0+eG1pdD49MCkgewoJCWxlbiA9IENPTU0xNl9Xcml0ZUZpbGUocHRyLT5oYW5kbGUsICYocHRyLT54bWl0KSwgMSk7CgkJaWYgKGxlbiA+IDApIHB0ci0+eG1pdCA9IC0xOwoJfQoKCS8qIHdyaXRlIGZyb20gb3V0cHV0IHF1ZXVlICovCglibGVmdCA9ICgocHRyLT5vYnVmX3RhaWwgPD0gcHRyLT5vYnVmX2hlYWQpID8KCQlwdHItPm9idWZfaGVhZCA6IHB0ci0+b2J1Zl9zaXplKSAtIHB0ci0+b2J1Zl90YWlsOwoKCS8qIGNoZWNrIGZvciBub3RpZmljYXRpb24gKi8KCWlmIChwdHItPnduZCAmJiAocHRyLT5uX3dyaXRlPjApICYmIChwcmV2Pj1wdHItPm5fd3JpdGUpICYmCgkgIChjb21tX291dGJ1ZihwdHIpPHB0ci0+bl93cml0ZSkpIHsKCQkvKiBwYXNzZWQgdGhlIHRyYW5zbWl0IG5vdGlmaWNhdGlvbiB0aHJlc2hvbGQgKi8KCQltYXNrIHw9IENOX1RSQU5TTUlUOwoJfQoKCS8qIHNlbmQgbm90aWZpY2F0aW9ucywgaWYgYW55ICovCglpZiAocHRyLT53bmQgJiYgbWFzaykgewoJCVRSQUNFKCJub3RpZnlpbmcgJXA6IGNpZD0lZCwgbWFzaz0lMDJ4XG4iLCBwdHItPnduZCwgY2lkLCBtYXNrKTsKCQlQb3N0TWVzc2FnZUEocHRyLT53bmQsIFdNX0NPTU1OT1RJRlksIGNpZCwgbWFzayk7Cgl9CgoJLyogc3RhcnQgYWdhaW4gaWYgbmVjZXNzYXJ5ICovCglpZihibGVmdCkKCQljb21tX3dhaXR3cml0ZShwdHIpOwp9CgpzdGF0aWMgdm9pZCBjb21tX3dhaXRyZWFkKHN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cikKewoJdW5zaWduZWQgaW50IGJsZWZ0OwoJQ09NU1RBVCBzdGF0OwoKCS8qIEZJWE1FOiBnZXQgdGltZW91dHMgd29ya2luZyBwcm9wZXJseSBzbyB3ZSBjYW4gcmVhZCBibGVmdCBieXRlcyAqLwoJYmxlZnQgPSAoKHB0ci0+aWJ1Zl90YWlsID4gcHRyLT5pYnVmX2hlYWQpID8KCQkocHRyLT5pYnVmX3RhaWwtMSkgOiBwdHItPmlidWZfc2l6ZSkgLSBwdHItPmlidWZfaGVhZDsKCgkvKiBmaW5kIG91dCBob3cgbWFueSBieXRlcyBhcmUgbGVmdCBpbiB0aGUgYnVmZmVyICovCglpZihDbGVhckNvbW1FcnJvcihwdHItPmhhbmRsZSxOVUxMLCZzdGF0KSkKCQlibGVmdCA9IChibGVmdDxzdGF0LmNiSW5RdWUpID8gYmxlZnQgOiBzdGF0LmNiSW5RdWU7CgllbHNlCgkJYmxlZnQgPSAxOwoKCS8qIGFsd2F5cyByZWFkIGF0IGxlYXN0IG9uZSBieXRlICovCglpZihibGVmdD09MCkKCQlibGVmdCsrOwoKCVJlYWRGaWxlRXgocHRyLT5oYW5kbGUsCgkJcHRyLT5pbmJ1ZiArIHB0ci0+aWJ1Zl9oZWFkLAoJCWJsZWZ0LAoJCSZwdHItPnJlYWRfb3YsCgkJQ09NTTE2X1JlYWRDb21wbGV0ZSk7Cn0KCnN0YXRpYyB2b2lkIGNvbW1fd2FpdHdyaXRlKHN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cikKewoJaW50IGJsZWZ0OwoKCWJsZWZ0ID0gKChwdHItPm9idWZfdGFpbCA8PSBwdHItPm9idWZfaGVhZCkgPwoJCXB0ci0+b2J1Zl9oZWFkIDogcHRyLT5vYnVmX3NpemUpIC0gcHRyLT5vYnVmX3RhaWw7CglXcml0ZUZpbGVFeChwdHItPmhhbmRsZSwKCQlwdHItPm91dGJ1ZiArIHB0ci0+b2J1Zl90YWlsLAoJCWJsZWZ0LAoJCSZwdHItPndyaXRlX292LAoJCUNPTU0xNl9Xcml0ZUNvbXBsZXRlKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCUNPTU0xNl9EQ0J0b0RDQjE2CShJbnRlcm5hbCkKICovCklOVDE2IENPTU0xNl9EQ0J0b0RDQjE2KExQRENCIGxwZGNiLCBMUERDQjE2IGxwZGNiMTYpCnsKCWlmKGxwZGNiLT5CYXVkUmF0ZTwweDEwMDAwKQoJCWxwZGNiMTYtPkJhdWRSYXRlID0gbHBkY2ItPkJhdWRSYXRlOwoJZWxzZSBpZihscGRjYi0+QmF1ZFJhdGU9PTExNTIwMCkKCQkJbHBkY2IxNi0+QmF1ZFJhdGUgPSA1NzYwMTsKCWVsc2UgewoJCVdBUk4oIkJhdWQgcmF0ZSBjYW4ndCBiZSBjb252ZXJ0ZWRcbiIpOwoJCWxwZGNiMTYtPkJhdWRSYXRlID0gNTc2MDE7Cgl9CglscGRjYjE2LT5CeXRlU2l6ZSA9IGxwZGNiLT5CeXRlU2l6ZTsKCWxwZGNiMTYtPmZQYXJpdHkgPSBscGRjYi0+ZlBhcml0eTsKCWxwZGNiMTYtPlBhcml0eSA9IGxwZGNiLT5QYXJpdHk7CglscGRjYjE2LT5TdG9wQml0cyA9IGxwZGNiLT5TdG9wQml0czsKCglscGRjYjE2LT5SbHNUaW1lb3V0ID0gNTA7CglscGRjYjE2LT5DdHNUaW1lb3V0ID0gNTA7CglscGRjYjE2LT5Ec3JUaW1lb3V0ID0gNTA7CglscGRjYjE2LT5mTnVsbCA9IDA7CglscGRjYjE2LT5mQ2hFdnQgPSAwOwoJbHBkY2IxNi0+ZkJpbmFyeSA9IDE7CgoJbHBkY2IxNi0+ZkR0cmZsb3cgPSAobHBkY2ItPmZEdHJDb250cm9sPT1EVFJfQ09OVFJPTF9IQU5EU0hBS0UpOwoJbHBkY2IxNi0+ZlJ0c2Zsb3cgPSAobHBkY2ItPmZSdHNDb250cm9sPT1SVFNfQ09OVFJPTF9IQU5EU0hBS0UpOwoJbHBkY2IxNi0+Zk91dHhDdHNGbG93ID0gbHBkY2ItPmZPdXR4Q3RzRmxvdzsKCWxwZGNiMTYtPmZPdXR4RHNyRmxvdyA9IGxwZGNiLT5mT3V0eERzckZsb3c7CglscGRjYjE2LT5mRHRyRGlzYWJsZSA9IChscGRjYi0+ZkR0ckNvbnRyb2w9PURUUl9DT05UUk9MX0RJU0FCTEUpOwoKCWxwZGNiMTYtPmZJblggPSBscGRjYi0+ZkluWDsKCglscGRjYjE2LT5mT3V0WCA9IGxwZGNiLT5mT3V0WDsKLyoKCWxwZGNiMTYtPlhvbkNoYXIgPQoJbHBkY2IxNi0+WG9mZkNoYXIgPQogKi8KCWxwZGNiMTYtPlhvbkxpbSA9IDEwOwoJbHBkY2IxNi0+WG9mZkxpbSA9IDEwOwoKCXJldHVybiAwOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQnVpbGRDb21tRENCCQkoVVNFUi4yMTMpCiAqCiAqIEFjY29yZGluZyB0byB0aGUgRUNNQS0yMzQgKDM2OC4zKSB0aGUgZnVuY3Rpb24gd2lsbCByZXR1cm4gRkFMU0Ugb24KICogc3VjY2Vzcywgb3RoZXJ3aXNlIGl0IHdpbGwgcmV0dXJuIC0xLgogKi8KSU5UMTYgV0lOQVBJIEJ1aWxkQ29tbURDQjE2KExQQ1NUUiBkZXZpY2UsIExQRENCMTYgbHBkY2IpCnsKCS8qICJDT00xOjk2LG4sOCwxIgkqLwoJLyogIDAxMjM0NQkJKi8KCWludCBwb3J0OwoJRENCIGRjYjsKCglUUkFDRSgiKCVzKSwgcHRyICVwXG4iLCBkZXZpY2UsIGxwZGNiKTsKCglpZiAoc3RybmNhc2VjbXAoZGV2aWNlLCJDT00iLDMpKQoJCXJldHVybiAtMTsKCXBvcnQgPSBkZXZpY2VbM10gLSAnMCc7CgoJaWYgKHBvcnQtLSA9PSAwKSB7CgkJRVJSKCJCVUcgISBDT00wIGNhbid0IGV4aXN0IVxuIik7CgkJcmV0dXJuIC0xOwoJfQoKCW1lbXNldChscGRjYiwgMCwgc2l6ZW9mKERDQjE2KSk7IC8qIGluaXRpYWxpemUgKi8KCglscGRjYi0+SWQgPSBwb3J0OwoJZGNiLkRDQmxlbmd0aCA9IHNpemVvZihEQ0IpOwoKCWlmIChzdHJjaHIoZGV2aWNlLCc9JykpIC8qIGJsb2NrIG5ldyBzdHlsZSAqLwoJCXJldHVybiAtMTsKCglpZighQnVpbGRDb21tRENCQShkZXZpY2UsJmRjYikpCgkJcmV0dXJuIC0xOwoKCXJldHVybiBDT01NMTZfRENCdG9EQ0IxNigmZGNiLCBscGRjYik7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKglPcGVuQ29tbQkJKFVTRVIuMjAwKQogKi8KSU5UMTYgV0lOQVBJIE9wZW5Db21tMTYoTFBDU1RSIGRldmljZSxVSU5UMTYgY2JJblF1ZXVlLFVJTlQxNiBjYk91dFF1ZXVlKQp7CglpbnQgcG9ydDsKCUhBTkRMRSBoYW5kbGU7CgogICAgCVRSQUNFKCIlcywgJWQsICVkXG4iLCBkZXZpY2UsIGNiSW5RdWV1ZSwgY2JPdXRRdWV1ZSk7CgoJaWYgKHN0cmxlbihkZXZpY2UpIDwgNCkKCSAgIHJldHVybiBJRV9CQURJRDsKCglwb3J0ID0gZGV2aWNlWzNdIC0gJzAnOwoKCWlmIChwb3J0LS0gPT0gMCkKCQlFUlIoIkJVRyAhIENPTTAgb3IgTFBUMCBkb24ndCBleGlzdCAhXG4iKTsKCglpZiAoIXN0cm5jYXNlY21wKGRldmljZSwiQ09NIiwzKSkKICAgICAgICB7CgkJaWYgKENPTVtwb3J0XS5oYW5kbGUpCgkJCXJldHVybiBJRV9PUEVOOwoKCQloYW5kbGUgPSBDcmVhdGVGaWxlQShkZXZpY2UsIEdFTkVSSUNfUkVBRHxHRU5FUklDX1dSSVRFLAoJCQlGSUxFX1NIQVJFX1JFQUQgfCBGSUxFX1NIQVJFX1dSSVRFLCBOVUxMLCBDUkVBVEVfQUxXQVlTLAoJCQlGSUxFX0ZMQUdfT1ZFUkxBUFBFRHxGSUxFX0ZMQUdfTk9fQlVGRkVSSU5HLCAwICk7CgkJaWYgKGhhbmRsZSA9PSBJTlZBTElEX0hBTkRMRV9WQUxVRSkgewoJCQlyZXR1cm4gSUVfSEFSRFdBUkU7CgkJfSBlbHNlIHsKCQkJbWVtc2V0KENPTVtwb3J0XS51bmtub3duLCAwLCBzaXplb2YoQ09NW3BvcnRdLnVua25vd24pKTsKICAgICAgICAgICAgICAgICAgICAgICAgQ09NW3BvcnRdLnNlZ191bmtub3duID0gMDsKCQkJQ09NW3BvcnRdLmhhbmRsZSA9IGhhbmRsZTsKCQkJQ09NW3BvcnRdLmNvbW1lcnJvciA9IDA7CgkJCUNPTVtwb3J0XS5ldmVudG1hc2sgPSAwOwoJCQlDT01bcG9ydF0uZXZ0Y2hhciA9IDA7IC8qIEZJWE1FOiBkZWZhdWx0PyAqLwogICAgICAgICAgICAgICAgICAgICAgICAvKiBzYXZlIHRlcm1pbmFsIHN0YXRlICovCgkJCUdldENvbW1TdGF0ZTE2KHBvcnQsJkNPTVtwb3J0XS5kY2IpOwoJCQkvKiBpbml0IHByaW9yaXR5IGNoYXJhY3RlcnMgKi8KCQkJQ09NW3BvcnRdLnVuZ2V0ID0gLTE7CgkJCUNPTVtwb3J0XS54bWl0ID0gLTE7CgkJCS8qIGFsbG9jYXRlIGJ1ZmZlcnMgKi8KCQkJQ09NW3BvcnRdLmlidWZfc2l6ZSA9IGNiSW5RdWV1ZTsKCQkJQ09NW3BvcnRdLmlidWZfaGVhZCA9IENPTVtwb3J0XS5pYnVmX3RhaWwgPSAwOwoJCQlDT01bcG9ydF0ub2J1Zl9zaXplID0gY2JPdXRRdWV1ZTsKCQkJQ09NW3BvcnRdLm9idWZfaGVhZCA9IENPTVtwb3J0XS5vYnVmX3RhaWwgPSAwOwoKCQkJQ09NW3BvcnRdLmluYnVmID0gSGVhcEFsbG9jKEdldFByb2Nlc3NIZWFwKCksIDAsIGNiSW5RdWV1ZSk7CgkJCWlmIChDT01bcG9ydF0uaW5idWYpIHsKCQkJICBDT01bcG9ydF0ub3V0YnVmID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBjYk91dFF1ZXVlKTsKCQkJICBpZiAoIUNPTVtwb3J0XS5vdXRidWYpCgkJCSAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgQ09NW3BvcnRdLmluYnVmKTsKCQkJfSBlbHNlIENPTVtwb3J0XS5vdXRidWYgPSBOVUxMOwoJCQlpZiAoIUNPTVtwb3J0XS5vdXRidWYpIHsKCQkJICAvKiBub3QgZW5vdWdoIG1lbW9yeSAqLwoJCQkgIENsb3NlSGFuZGxlKENPTVtwb3J0XS5oYW5kbGUpOwoJCQkgIEVSUigib3V0IG9mIG1lbW9yeVxuIik7CgkJCSAgcmV0dXJuIElFX01FTU9SWTsKCQkJfQoKCQkJWmVyb01lbW9yeSgmQ09NW3BvcnRdLnJlYWRfb3Ysc2l6ZW9mIChPVkVSTEFQUEVEKSk7CgkJCVplcm9NZW1vcnkoJkNPTVtwb3J0XS53cml0ZV9vdixzaXplb2YgKE9WRVJMQVBQRUQpKTsKCiAgICAgICAgICAgICAgICAgICAgICAgIGNvbW1fd2FpdHJlYWQoICZDT01bcG9ydF0gKTsKCQkJVVNFUjE2X0FsZXJ0YWJsZVdhaXQrKzsKCgkJCXJldHVybiBwb3J0OwoJCX0KCX0KCWVsc2UKCWlmICghc3RybmNhc2VjbXAoZGV2aWNlLCJMUFQiLDMpKSB7CgoJCWlmIChMUFRbcG9ydF0uaGFuZGxlKQoJCQlyZXR1cm4gSUVfT1BFTjsKCgkJaGFuZGxlID0gQ3JlYXRlRmlsZUEoZGV2aWNlLCBHRU5FUklDX1JFQUR8R0VORVJJQ19XUklURSwKCQkJRklMRV9TSEFSRV9SRUFEIHwgRklMRV9TSEFSRV9XUklURSwgTlVMTCwgQ1JFQVRFX0FMV0FZUywgMCwgMCApOwoJCWlmIChoYW5kbGUgPT0gSU5WQUxJRF9IQU5ETEVfVkFMVUUpIHsKCQkJcmV0dXJuIElFX0hBUkRXQVJFOwoJCX0gZWxzZSB7CgkJCUxQVFtwb3J0XS5oYW5kbGUgPSBoYW5kbGU7CgkJCUxQVFtwb3J0XS5jb21tZXJyb3IgPSAwOwoJCQlMUFRbcG9ydF0uZXZlbnRtYXNrID0gMDsKCQkJcmV0dXJuIHBvcnR8RkxBR19MUFQ7CgkJfQoJfQoJcmV0dXJuIElFX0JBRElEOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJQ2xvc2VDb21tCQkoVVNFUi4yMDcpCiAqLwpJTlQxNiBXSU5BUEkgQ2xvc2VDb21tMTYoSU5UMTYgY2lkKQp7CglzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHI7CgogICAgCVRSQUNFKCJjaWQ9JWRcbiIsIGNpZCk7CglpZiAoKHB0ciA9IEdldERldmljZVN0cnVjdChjaWQpKSA9PSBOVUxMKSB7CgkJRklYTUUoIm5vIGNpZD0lZCBmb3VuZCFcbiIsIGNpZCk7CgkJcmV0dXJuIC0xOwoJfQoJaWYgKCEoY2lkJkZMQUdfTFBUKSkgewoJCS8qIENPTSBwb3J0ICovCiAgICAgICAgICAgICAgICBVbk1hcExTKCBDT01bY2lkXS5zZWdfdW5rbm93biApOwoJCVVTRVIxNl9BbGVydGFibGVXYWl0LS07CgkJQ2FuY2VsSW8ocHRyLT5oYW5kbGUpOwoKCQkvKiBmcmVlIGJ1ZmZlcnMgKi8KCQlIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgcHRyLT5vdXRidWYpOwoJCUhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBwdHItPmluYnVmKTsKCgkJLyogcmVzZXQgbW9kZW0gbGluZXMgKi8KCQlTZXRDb21tU3RhdGUxNigmQ09NW2NpZF0uZGNiKTsKCX0KCglpZiAoIUNsb3NlSGFuZGxlKHB0ci0+aGFuZGxlKSkgewoJCXB0ci0+Y29tbWVycm9yID0gV2luRXJyb3IoKTsKCQkvKiBGSVhNRTogc2hvdWxkIHdlIGNsZWFyIHB0ci0+aGFuZGxlIGhlcmU/ICovCgkJcmV0dXJuIC0xOwoJfSBlbHNlIHsKCQlwdHItPmNvbW1lcnJvciA9IDA7CgkJcHRyLT5oYW5kbGUgPSAwOwoJCXJldHVybiAwOwoJfQp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJU2V0Q29tbUJyZWFrCQkoVVNFUi4yMTApCiAqLwpJTlQxNiBXSU5BUEkgU2V0Q29tbUJyZWFrMTYoSU5UMTYgY2lkKQp7CglzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHI7CgoJVFJBQ0UoImNpZD0lZFxuIiwgY2lkKTsKCWlmICgocHRyID0gR2V0RGV2aWNlU3RydWN0KGNpZCkpID09IE5VTEwpIHsKCQlGSVhNRSgibm8gY2lkPSVkIGZvdW5kIVxuIiwgY2lkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJcHRyLT5zdXNwZW5kZWQgPSAxOwoJcHRyLT5jb21tZXJyb3IgPSAwOwoJcmV0dXJuIDA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKglDbGVhckNvbW1CcmVhawkoVVNFUi4yMTEpCiAqLwpJTlQxNiBXSU5BUEkgQ2xlYXJDb21tQnJlYWsxNihJTlQxNiBjaWQpCnsKCXN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cjsKCiAgICAJVFJBQ0UoImNpZD0lZFxuIiwgY2lkKTsKCWlmICghKHB0ciA9IEdldERldmljZVN0cnVjdChjaWQpKSkgewoJCUZJWE1FKCJubyBjaWQ9JWQgZm91bmQhXG4iLCBjaWQpOwoJCXJldHVybiAtMTsKCX0KCXB0ci0+c3VzcGVuZGVkID0gMDsKCXB0ci0+Y29tbWVycm9yID0gMDsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJRXNjYXBlQ29tbUZ1bmN0aW9uCShVU0VSLjIxNCkKICovCkxPTkcgV0lOQVBJIEVzY2FwZUNvbW1GdW5jdGlvbjE2KFVJTlQxNiBjaWQsVUlOVDE2IG5GdW5jdGlvbikKewoJc3RydWN0ICBEb3NEZXZpY2VTdHJ1Y3QgKnB0cjsKCiAgICAJVFJBQ0UoImNpZD0lZCwgZnVuY3Rpb249JWRcbiIsIGNpZCwgbkZ1bmN0aW9uKTsKCglzd2l0Y2gobkZ1bmN0aW9uKSB7CgljYXNlIEdFVE1BWENPTToKCSAgICAgICAgVFJBQ0UoIkdFVE1BWENPTVxuIik7CiAgICAgICAgICAgICAgICByZXR1cm4gNDsgIC8qIEZJWE1FICovCgoJY2FzZSBHRVRNQVhMUFQ6CgkJVFJBQ0UoIkdFVE1BWExQVFxuIik7CiAgICAgICAgICAgICAgICByZXR1cm4gRkxBR19MUFQgKyAzOyAgLyogRklYTUUgKi8KCgljYXNlIEdFVEJBU0VJUlE6CgkJVFJBQ0UoIkdFVEJBU0VJUlFcbiIpOwoJCS8qIEZJWE1FOiB1c2UgdGFibGVzICovCgkJLyoganVzdCBmYWtlIHNvbWV0aGluZyBmb3Igbm93ICovCgkJaWYgKGNpZCAmIEZMQUdfTFBUKSB7CgkJCS8qIExQVDE6IGlycSA3LCBMUFQyOiBpcnEgNSAqLwoJCQlyZXR1cm4gKGNpZCAmIDB4N2YpID8gNSA6IDc7CgkJfSBlbHNlIHsKCQkJLyogQ09NMTogaXJxIDQsIENPTTI6IGlycSAzLAoJCQkgICBDT00zOiBpcnEgNCwgQ09NNDogaXJxIDMgKi8KCQkJcmV0dXJuIDQgLSAoY2lkICYgMSk7CgkJfQoJfQoKCWlmICgocHRyID0gR2V0RGV2aWNlU3RydWN0KGNpZCkpID09IE5VTEwpIHsKCQlGSVhNRSgibm8gY2lkPSVkIGZvdW5kIVxuIiwgY2lkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJc3dpdGNoIChuRnVuY3Rpb24pIHsKCWNhc2UgUkVTRVRERVY6CgljYXNlIENMUkRUUjoKCWNhc2UgQ0xSUlRTOgoJY2FzZSBTRVREVFI6CgljYXNlIFNFVFJUUzoKCWNhc2UgU0VUWE9GRjoKCWNhc2UgU0VUWE9OOgoJCWlmKEVzY2FwZUNvbW1GdW5jdGlvbihwdHItPmhhbmRsZSxuRnVuY3Rpb24pKQoJCQlyZXR1cm4gMDsKCQllbHNlIHsKCQkJcHRyLT5jb21tZXJyb3IgPSBXaW5FcnJvcigpOwoJCQlyZXR1cm4gLTE7CgkJfQoKCWNhc2UgQ0xSQlJFQUs6CgljYXNlIFNFVEJSRUFLOgoJZGVmYXVsdDoKCQlXQVJOKCIoY2lkPSVkLG5GdW5jdGlvbj0lZCk6IFVua25vd24gZnVuY3Rpb25cbiIsCgkJCWNpZCwgbkZ1bmN0aW9uKTsKCX0KCXJldHVybiAtMTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCUZsdXNoQ29tbQkoVVNFUi4yMTUpCiAqLwpJTlQxNiBXSU5BUEkgRmx1c2hDb21tMTYoSU5UMTYgY2lkLElOVDE2IGZuUXVldWUpCnsKCURXT1JEIHF1ZXVlOwoJc3RydWN0IERvc0RldmljZVN0cnVjdCAqcHRyOwoKICAgIAlUUkFDRSgiY2lkPSVkLCBxdWV1ZT0lZFxuIiwgY2lkLCBmblF1ZXVlKTsKCWlmICgocHRyID0gR2V0RGV2aWNlU3RydWN0KGNpZCkpID09IE5VTEwpIHsKCQlGSVhNRSgibm8gY2lkPSVkIGZvdW5kIVxuIiwgY2lkKTsKCQlyZXR1cm4gLTE7Cgl9Cglzd2l0Y2ggKGZuUXVldWUpIHsKCWNhc2UgMDoKCQlxdWV1ZSA9IFBVUkdFX1RYQUJPUlQ7CgkJcHRyLT5vYnVmX3RhaWwgPSBwdHItPm9idWZfaGVhZDsKCQlicmVhazsKCWNhc2UgMToKCQlxdWV1ZSA9IFBVUkdFX1JYQUJPUlQ7CgkJcHRyLT5pYnVmX2hlYWQgPSBwdHItPmlidWZfdGFpbDsKCQlicmVhazsKCWRlZmF1bHQ6CgkJV0FSTigiKGNpZD0lZCxmblF1ZXVlPSVkKTpVbmtub3duIHF1ZXVlXG4iLAoJCSAgICAgICAgICAgIGNpZCwgZm5RdWV1ZSk7CgkJcmV0dXJuIC0xOwoJfQoKCWlmICghUHVyZ2VDb21tKHB0ci0+aGFuZGxlLHF1ZXVlKSkgewoJCXB0ci0+Y29tbWVycm9yID0gV2luRXJyb3IoKTsKCQlyZXR1cm4gLTE7Cgl9IGVsc2UgewoJCXB0ci0+Y29tbWVycm9yID0gMDsKCQlyZXR1cm4gMDsKCX0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCUdldENvbW1FcnJvcgkoVVNFUi4yMDMpCiAqLwpJTlQxNiBXSU5BUEkgR2V0Q29tbUVycm9yMTYoSU5UMTYgY2lkLExQQ09NU1RBVDE2IGxwU3RhdCkKewoJaW50CQl0ZW1wZXJyb3I7CglzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHI7CiAgICAgICAgdW5zaWduZWQgY2hhciAqc3RvbDsKCglpZiAoKHB0ciA9IEdldERldmljZVN0cnVjdChjaWQpKSA9PSBOVUxMKSB7CgkJRklYTUUoIm5vIGhhbmRsZSBmb3IgY2lkID0gJTB4IVxuIixjaWQpOwoJCXJldHVybiAtMTsKCX0KICAgICAgICBpZiAoY2lkJkZMQUdfTFBUKSB7CiAgICAgICAgICAgIFdBUk4oIiBjaWQgJWQgbm90IGNvbW0gcG9ydFxuIixjaWQpOwogICAgICAgICAgICByZXR1cm4gQ0VfTU9ERTsKICAgICAgICB9CiAgICAgICAgc3RvbCA9ICh1bnNpZ25lZCBjaGFyICopQ09NW2NpZF0udW5rbm93biArIENPTU1fTVNSX09GRlNFVDsKCUNPTU1fTVNSVXBkYXRlKCBwdHItPmhhbmRsZSwgc3RvbCApOwoKCWlmIChscFN0YXQpIHsKCQlscFN0YXQtPnN0YXR1cyA9IDA7CgoJCVNsZWVwRXgoMSxUUlVFKTsKCgkJbHBTdGF0LT5jYk91dFF1ZSA9IGNvbW1fb3V0YnVmKHB0cik7CgkJbHBTdGF0LT5jYkluUXVlID0gY29tbV9pbmJ1ZihwdHIpOwoKICAgIAkJVFJBQ0UoImNpZCAlZCwgZXJyb3IgJWQsIHN0YXQgJWQgaW4gJWQgb3V0ICVkLCBzdG9sICV4XG4iLAoJCQkgICAgIGNpZCwgcHRyLT5jb21tZXJyb3IsIGxwU3RhdC0+c3RhdHVzLCBscFN0YXQtPmNiSW5RdWUsCgkJCSAgICAgbHBTdGF0LT5jYk91dFF1ZSwgKnN0b2wpOwoJfQoJZWxzZQoJCVRSQUNFKCJjaWQgJWQsIGVycm9yICVkLCBscFN0YXQgTlVMTCBzdG9sICV4XG4iLAoJCQkgICAgIGNpZCwgcHRyLT5jb21tZXJyb3IsICpzdG9sKTsKCgkvKiBSZXR1cm4gYW55IGVycm9ycyBhbmQgY2xlYXIgaXQgKi8KCXRlbXBlcnJvciA9IHB0ci0+Y29tbWVycm9yOwoJcHRyLT5jb21tZXJyb3IgPSAwOwoJcmV0dXJuKHRlbXBlcnJvcik7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKglTZXRDb21tRXZlbnRNYXNrCShVU0VSLjIwOCkKICovClNFR1BUUiBXSU5BUEkgU2V0Q29tbUV2ZW50TWFzazE2KElOVDE2IGNpZCxVSU5UMTYgZnVFdnRNYXNrKQp7CglzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHI7CiAgICAgICAgdW5zaWduZWQgY2hhciAqc3RvbDsKCiAgICAJVFJBQ0UoImNpZCAlZCxtYXNrICVkXG4iLGNpZCxmdUV2dE1hc2spOwoJaWYgKChwdHIgPSBHZXREZXZpY2VTdHJ1Y3QoY2lkKSkgPT0gTlVMTCkgewoJCUZJWE1FKCJubyBoYW5kbGUgZm9yIGNpZCA9ICUweCFcbiIsY2lkKTsKCSAgICByZXR1cm4gKFNFR1BUUilOVUxMOwoJfQoKCXB0ci0+ZXZlbnRtYXNrID0gZnVFdnRNYXNrOwoKICAgICAgICBpZiAoY2lkJkZMQUdfTFBUKSB7CiAgICAgICAgICAgIFdBUk4oIiBjaWQgJWQgbm90IGNvbW0gcG9ydFxuIixjaWQpOwogICAgICAgICAgICByZXR1cm4gKFNFR1BUUilOVUxMOwogICAgICAgIH0KICAgICAgICAvKiBpdCdzIGEgQ09NIHBvcnQgPyAtPiBtb2RpZnkgZmxhZ3MgKi8KICAgICAgICBzdG9sID0gKHVuc2lnbmVkIGNoYXIgKilDT01bY2lkXS51bmtub3duICsgQ09NTV9NU1JfT0ZGU0VUOwoJQ09NTV9NU1JVcGRhdGUoIHB0ci0+aGFuZGxlLCBzdG9sICk7CgoJVFJBQ0UoIiBtb2RlbSBkY2QgY29uc3RydWN0ICV4XG4iLCpzdG9sKTsKICAgICAgICBpZiAoIUNPTVtjaWRdLnNlZ191bmtub3duKSBDT01bY2lkXS5zZWdfdW5rbm93biA9IE1hcExTKCBDT01bY2lkXS51bmtub3duICk7CiAgICAgICAgcmV0dXJuIENPTVtjaWRdLnNlZ191bmtub3duOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJR2V0Q29tbUV2ZW50TWFzawkoVVNFUi4yMDkpCiAqLwpVSU5UMTYgV0lOQVBJIEdldENvbW1FdmVudE1hc2sxNihJTlQxNiBjaWQsVUlOVDE2IGZuRXZ0Q2xlYXIpCnsKCXN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cjsKCVdPUkQgZXZlbnRzOwoKICAgIAlUUkFDRSgiY2lkICVkLCBtYXNrICVkXG4iLCBjaWQsIGZuRXZ0Q2xlYXIpOwoJaWYgKChwdHIgPSBHZXREZXZpY2VTdHJ1Y3QoY2lkKSkgPT0gTlVMTCkgewoJCUZJWE1FKCJubyBoYW5kbGUgZm9yIGNpZCA9ICUweCFcbiIsY2lkKTsKCSAgICByZXR1cm4gMDsKCX0KCiAgICAgICAgaWYgKGNpZCZGTEFHX0xQVCkgewogICAgICAgICAgICBXQVJOKCIgY2lkICVkIG5vdCBjb21tIHBvcnRcbiIsY2lkKTsKICAgICAgICAgICAgcmV0dXJuIDA7CiAgICAgICAgfQoKCWV2ZW50cyA9ICooV09SRCopKENPTVtjaWRdLnVua25vd24pICYgZm5FdnRDbGVhcjsKCSooV09SRCopKENPTVtjaWRdLnVua25vd24pICY9IH5mbkV2dENsZWFyOwoJcmV0dXJuIGV2ZW50czsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCVNldENvbW1TdGF0ZQkoVVNFUi4yMDEpCiAqLwpJTlQxNiBXSU5BUEkgU2V0Q29tbVN0YXRlMTYoTFBEQ0IxNiBscGRjYikKewoJc3RydWN0IERvc0RldmljZVN0cnVjdCAqcHRyOwoJRENCIGRjYjsKCiAgICAJVFJBQ0UoImNpZCAlZCwgcHRyICVwXG4iLCBscGRjYi0+SWQsIGxwZGNiKTsKCWlmICgocHRyID0gR2V0RGV2aWNlU3RydWN0KGxwZGNiLT5JZCkpID09IE5VTEwpIHsKCQlGSVhNRSgibm8gaGFuZGxlIGZvciBjaWQgPSAlMHghXG4iLGxwZGNiLT5JZCk7CgkJcmV0dXJuIC0xOwoJfQoKCW1lbXNldCgmZGNiLDAsc2l6ZW9mKGRjYikpOwoJZGNiLkRDQmxlbmd0aCA9IHNpemVvZihkY2IpOwoKCS8qCgkgKiBhY2NvcmRpbmcgdG8gTVNETiwgd2Ugc2hvdWxkIGZpcnN0IGludGVycHJldCBscGRjYi0+QmF1ZFJhdGUgYXMgZm9sbG93czoKCSAqIDEuIGlmIHRoZSBiYXVkIHJhdGUgaXMgYSBDQlIgY29uc3RhbnQsIGludGVycHJldCBpdC4KCSAqIDIuIGlmIGl0IGlzIGdyZWF0ZXIgdGhhbiA1NzYwMCwgdGhlIGJhdWQgcmF0ZSBpcyAxMTUyMDAKCSAqIDMuIHVzZSB0aGUgYWN0dWFsIGJhdWRyYXRlCgkgKiBzdGVwcyAyIGFuZCAzIGFyZSBlcXVpdmlsZW50IHRvIDE2NTUwIGJhdWRyYXRlIGRpdmlzb3IgPSAxMTUyMDAvQmF1ZFJhdGUKCSAqIHNlZSBodHRwOi8vc3VwcG9ydC5taWNyb3NvZnQuY29tL3N1cHBvcnQva2IvYXJ0aWNsZXMvcTEwOC85LzI4LmFzcAoJICovCglzd2l0Y2gobHBkY2ItPkJhdWRSYXRlKQoJewoJY2FzZSBDQlJfMTEwOiAgICBkY2IuQmF1ZFJhdGUgPSAxMTA7ICAgIGJyZWFrOwoJY2FzZSBDQlJfMzAwOiAgICBkY2IuQmF1ZFJhdGUgPSAzMDA7ICAgIGJyZWFrOwoJY2FzZSBDQlJfNjAwOiAgICBkY2IuQmF1ZFJhdGUgPSA2MDA7ICAgIGJyZWFrOwoJY2FzZSBDQlJfMTIwMDogICBkY2IuQmF1ZFJhdGUgPSAxMjAwOyAgIGJyZWFrOwoJY2FzZSBDQlJfMjQwMDogICBkY2IuQmF1ZFJhdGUgPSAyNDAwOyAgIGJyZWFrOwoJY2FzZSBDQlJfNDgwMDogICBkY2IuQmF1ZFJhdGUgPSA0ODAwOyAgIGJyZWFrOwoJY2FzZSBDQlJfOTYwMDogICBkY2IuQmF1ZFJhdGUgPSA5NjAwOyAgIGJyZWFrOwoJY2FzZSBDQlJfMTQ0MDA6ICBkY2IuQmF1ZFJhdGUgPSAxNDQwMDsgIGJyZWFrOwoJY2FzZSBDQlJfMTkyMDA6ICBkY2IuQmF1ZFJhdGUgPSAxOTIwMDsgIGJyZWFrOwoJY2FzZSBDQlJfMzg0MDA6ICBkY2IuQmF1ZFJhdGUgPSAzODQwMDsgIGJyZWFrOwoJY2FzZSBDQlJfNTYwMDA6ICBkY2IuQmF1ZFJhdGUgPSA1NjAwMDsgIGJyZWFrOwoJY2FzZSBDQlJfMTI4MDAwOiBkY2IuQmF1ZFJhdGUgPSAxMjgwMDA7IGJyZWFrOwoJY2FzZSBDQlJfMjU2MDAwOiBkY2IuQmF1ZFJhdGUgPSAyNTYwMDA7IGJyZWFrOwoJZGVmYXVsdDoKCQlpZihscGRjYi0+QmF1ZFJhdGU+NTc2MDApCgkJZGNiLkJhdWRSYXRlID0gMTE1MjAwOwogICAgICAgIGVsc2UKCQlkY2IuQmF1ZFJhdGUgPSBscGRjYi0+QmF1ZFJhdGU7CiAJfQoKICAgICAgICBkY2IuQnl0ZVNpemU9bHBkY2ItPkJ5dGVTaXplOwogICAgICAgIGRjYi5TdG9wQml0cz1scGRjYi0+U3RvcEJpdHM7CgoJZGNiLmZQYXJpdHk9bHBkY2ItPmZQYXJpdHk7CglkY2IuUGFyaXR5PWxwZGNiLT5QYXJpdHk7CgoJZGNiLmZPdXR4Q3RzRmxvdyA9IGxwZGNiLT5mT3V0eEN0c0Zsb3c7CgoJaWYgKGxwZGNiLT5mRHRyZmxvdyB8fCBscGRjYi0+ZlJ0c2Zsb3cpCgkJZGNiLmZSdHNDb250cm9sID0gVFJVRTsKCglpZiAobHBkY2ItPmZEdHJEaXNhYmxlKQoJCWRjYi5mRHRyQ29udHJvbCA9IFRSVUU7CgoJcHRyLT5ldnRjaGFyID0gbHBkY2ItPkV2dENoYXI7CgoJZGNiLmZJblggPSBscGRjYi0+ZkluWDsKCWRjYi5mT3V0WCA9IGxwZGNiLT5mT3V0WDsKCglpZiAoIVNldENvbW1TdGF0ZShwdHItPmhhbmRsZSwmZGNiKSkgewoJCXB0ci0+Y29tbWVycm9yID0gV2luRXJyb3IoKTsKCQlyZXR1cm4gLTE7Cgl9IGVsc2UgewoJCXB0ci0+Y29tbWVycm9yID0gMDsKCQlyZXR1cm4gMDsKCX0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCUdldENvbW1TdGF0ZQkoVVNFUi4yMDIpCiAqLwpJTlQxNiBXSU5BUEkgR2V0Q29tbVN0YXRlMTYoSU5UMTYgY2lkLCBMUERDQjE2IGxwZGNiKQp7CglzdHJ1Y3QgRG9zRGV2aWNlU3RydWN0ICpwdHI7CglEQ0IgZGNiOwoKICAgIAlUUkFDRSgiY2lkICVkLCBwdHIgJXBcbiIsIGNpZCwgbHBkY2IpOwoJaWYgKChwdHIgPSBHZXREZXZpY2VTdHJ1Y3QoY2lkKSkgPT0gTlVMTCkgewoJCUZJWE1FKCJubyBoYW5kbGUgZm9yIGNpZCA9ICUweCFcbiIsY2lkKTsKCQlyZXR1cm4gLTE7Cgl9CglpZiAoIUdldENvbW1TdGF0ZShwdHItPmhhbmRsZSwmZGNiKSkgewoJCXB0ci0+Y29tbWVycm9yID0gV2luRXJyb3IoKTsKCQlyZXR1cm4gLTE7Cgl9CgoJbHBkY2ItPklkID0gY2lkOwoKCUNPTU0xNl9EQ0J0b0RDQjE2KCZkY2IsbHBkY2IpOwoKCWxwZGNiLT5FdnRDaGFyID0gcHRyLT5ldnRjaGFyOwoKCXB0ci0+Y29tbWVycm9yID0gMDsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJVHJhbnNtaXRDb21tQ2hhcgkoVVNFUi4yMDYpCiAqLwpJTlQxNiBXSU5BUEkgVHJhbnNtaXRDb21tQ2hhcjE2KElOVDE2IGNpZCxDSEFSIGNoVHJhbnNtaXQpCnsKCXN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cjsKCiAgICAJVFJBQ0UoImNpZCAlZCwgZGF0YSAlZCBcbiIsIGNpZCwgY2hUcmFuc21pdCk7CglpZiAoKHB0ciA9IEdldERldmljZVN0cnVjdChjaWQpKSA9PSBOVUxMKSB7CgkJRklYTUUoIm5vIGhhbmRsZSBmb3IgY2lkID0gJTB4IVxuIixjaWQpOwoJCXJldHVybiAtMTsKCX0KCglpZiAocHRyLT5zdXNwZW5kZWQpIHsKCQlwdHItPmNvbW1lcnJvciA9IElFX0hBUkRXQVJFOwoJCXJldHVybiAtMTsKCX0KCglpZiAocHRyLT54bWl0ID49IDApIHsKCSAgLyogY2hhcmFjdGVyIGFscmVhZHkgcXVldWVkICovCgkgIC8qIEZJWE1FOiB3aGljaCBlcnJvciB3b3VsZCBXaW5kb3dzIHJldHVybj8gKi8KCSAgcHRyLT5jb21tZXJyb3IgPSBDRV9UWEZVTEw7CgkgIHJldHVybiAtMTsKCX0KCglpZiAocHRyLT5vYnVmX2hlYWQgPT0gcHRyLT5vYnVmX3RhaWwpIHsKCSAgLyogdHJhbnNtaXQgcXVldWUgZW1wdHksIHRyeSB0byB0cmFuc21pdCBkaXJlY3RseSAqLwoJICBpZigxIT1DT01NMTZfV3JpdGVGaWxlKHB0ci0+aGFuZGxlLCAmY2hUcmFuc21pdCwgMSkpCgkgIHsKCSAgICAvKiBkaWRuJ3Qgd29yaywgcXVldWUgaXQgKi8KCSAgICBwdHItPnhtaXQgPSBjaFRyYW5zbWl0OwoJICAgIGNvbW1fd2FpdHdyaXRlKHB0cik7CgkgIH0KCX0gZWxzZSB7CgkgIC8qIGRhdGEgaW4gcXVldWUsIGxldCB0aGlzIGNoYXIgYmUgdHJhbnNtaXR0ZWQgbmV4dCAqLwoJICBwdHItPnhtaXQgPSBjaFRyYW5zbWl0OwoJICBjb21tX3dhaXR3cml0ZShwdHIpOwoJfQoKCXB0ci0+Y29tbWVycm9yID0gMDsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJVW5nZXRDb21tQ2hhcgkoVVNFUi4yMTIpCiAqLwpJTlQxNiBXSU5BUEkgVW5nZXRDb21tQ2hhcjE2KElOVDE2IGNpZCxDSEFSIGNoVW5nZXQpCnsKCXN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cjsKCiAgICAJVFJBQ0UoImNpZCAlZCAoY2hhciAlZClcbiIsIGNpZCwgY2hVbmdldCk7CglpZiAoKHB0ciA9IEdldERldmljZVN0cnVjdChjaWQpKSA9PSBOVUxMKSB7CgkJRklYTUUoIm5vIGhhbmRsZSBmb3IgY2lkID0gJTB4IVxuIixjaWQpOwoJCXJldHVybiAtMTsKCX0KCglpZiAocHRyLT5zdXNwZW5kZWQpIHsKCQlwdHItPmNvbW1lcnJvciA9IElFX0hBUkRXQVJFOwoJCXJldHVybiAtMTsKCX0KCglpZiAocHRyLT51bmdldD49MCkgewoJICAvKiBjaGFyYWN0ZXIgYWxyZWFkeSBxdWV1ZWQgKi8KCSAgLyogRklYTUU6IHdoaWNoIGVycm9yIHdvdWxkIFdpbmRvd3MgcmV0dXJuPyAqLwoJICBwdHItPmNvbW1lcnJvciA9IENFX1JYT1ZFUjsKCSAgcmV0dXJuIC0xOwoJfQoKCXB0ci0+dW5nZXQgPSBjaFVuZ2V0OwoKCXB0ci0+Y29tbWVycm9yID0gMDsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJUmVhZENvbW0JKFVTRVIuMjA0KQogKi8KSU5UMTYgV0lOQVBJIFJlYWRDb21tMTYoSU5UMTYgY2lkLExQU1RSIGxwdkJ1ZixJTlQxNiBjYlJlYWQpCnsKCWludCBzdGF0dXMsIGxlbmd0aDsKCXN0cnVjdCBEb3NEZXZpY2VTdHJ1Y3QgKnB0cjsKCUxQU1RSIG9yZ0J1ZiA9IGxwdkJ1ZjsKCiAgICAJVFJBQ0UoImNpZCAlZCwgcHRyICVwLCBsZW5ndGggJWRcbiIsIGNpZCwgbHB2QnVmLCBjYlJlYWQpOwoJaWYgKChwdHIgPSBHZXREZXZpY2VTdHJ1Y3QoY2lkKSkgPT0gTlVMTCkgewoJCUZJWE1FKCJubyBoYW5kbGUgZm9yIGNpZCA9ICUweCFcbiIsY2lkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJaWYgKHB0ci0+c3VzcGVuZGVkKSB7CgkJcHRyLT5jb21tZXJyb3IgPSBJRV9IQVJEV0FSRTsKCQlyZXR1cm4gLTE7Cgl9CgoJaWYoMD09Y29tbV9pbmJ1ZihwdHIpKQoJCVNsZWVwRXgoMSxUUlVFKTsKCgkvKiByZWFkIHVuZ2V0IGNoYXJhY3RlciAqLwoJaWYgKHB0ci0+dW5nZXQ+PTApIHsKCQkqbHB2QnVmKysgPSBwdHItPnVuZ2V0OwoJCXB0ci0+dW5nZXQgPSAtMTsKCgkJbGVuZ3RoID0gMTsKCX0gZWxzZQoJIAlsZW5ndGggPSAwOwoKCS8qIHJlYWQgZnJvbSByZWNlaXZlIGJ1ZmZlciAqLwoJd2hpbGUgKGxlbmd0aCA8IGNiUmVhZCkgewoJICBzdGF0dXMgPSAoKHB0ci0+aWJ1Zl9oZWFkIDwgcHRyLT5pYnVmX3RhaWwpID8KCQkgICAgcHRyLT5pYnVmX3NpemUgOiBwdHItPmlidWZfaGVhZCkgLSBwdHItPmlidWZfdGFpbDsKCSAgaWYgKCFzdGF0dXMpIGJyZWFrOwoJICBpZiAoKGNiUmVhZCAtIGxlbmd0aCkgPCBzdGF0dXMpCgkgICAgc3RhdHVzID0gY2JSZWFkIC0gbGVuZ3RoOwoKCSAgbWVtY3B5KGxwdkJ1ZiwgcHRyLT5pbmJ1ZiArIHB0ci0+aWJ1Zl90YWlsLCBzdGF0dXMpOwoJICBwdHItPmlidWZfdGFpbCArPSBzdGF0dXM7CgkgIGlmIChwdHItPmlidWZfdGFpbCA+PSBwdHItPmlidWZfc2l6ZSkKCSAgICBwdHItPmlidWZfdGFpbCA9IDA7CgkgIGxwdkJ1ZiArPSBzdGF0dXM7CgkgIGxlbmd0aCArPSBzdGF0dXM7Cgl9CgoJVFJBQ0UoIiVzXG4iLCBkZWJ1Z3N0cl9hbiggb3JnQnVmLCBsZW5ndGggKSk7CglwdHItPmNvbW1lcnJvciA9IDA7CglyZXR1cm4gbGVuZ3RoOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJV3JpdGVDb21tCShVU0VSLjIwNSkKICovCklOVDE2IFdJTkFQSSBXcml0ZUNvbW0xNihJTlQxNiBjaWQsIExQU1RSIGxwdkJ1ZiwgSU5UMTYgY2JXcml0ZSkKewoJaW50IHN0YXR1cywgbGVuZ3RoOwoJc3RydWN0IERvc0RldmljZVN0cnVjdCAqcHRyOwoKICAgIAlUUkFDRSgiY2lkICVkLCBwdHIgJXAsIGxlbmd0aCAlZFxuIiwKCQljaWQsIGxwdkJ1ZiwgY2JXcml0ZSk7CglpZiAoKHB0ciA9IEdldERldmljZVN0cnVjdChjaWQpKSA9PSBOVUxMKSB7CgkJRklYTUUoIm5vIGhhbmRsZSBmb3IgY2lkID0gJTB4IVxuIixjaWQpOwoJCXJldHVybiAtMTsKCX0KCglpZiAocHRyLT5zdXNwZW5kZWQpIHsKCQlwdHItPmNvbW1lcnJvciA9IElFX0hBUkRXQVJFOwoJCXJldHVybiAtMTsKCX0KCglUUkFDRSgiJXNcbiIsIGRlYnVnc3RyX2FuKCBscHZCdWYsIGNiV3JpdGUgKSk7CgoJbGVuZ3RoID0gMDsKCXdoaWxlIChsZW5ndGggPCBjYldyaXRlKSB7CgkgIGlmICgocHRyLT5vYnVmX2hlYWQgPT0gcHRyLT5vYnVmX3RhaWwpICYmIChwdHItPnhtaXQgPCAwKSkgewoJICAgIC8qIG5vIGRhdGEgcXVldWVkLCB0cnkgdG8gd3JpdGUgZGlyZWN0bHkgKi8KCSAgICBzdGF0dXMgPSBDT01NMTZfV3JpdGVGaWxlKHB0ci0+aGFuZGxlLCBscHZCdWYsIGNiV3JpdGUgLSBsZW5ndGgpOwoJICAgIGlmIChzdGF0dXMgPiAwKSB7CgkgICAgICBscHZCdWYgKz0gc3RhdHVzOwoJICAgICAgbGVuZ3RoICs9IHN0YXR1czsKCSAgICAgIGNvbnRpbnVlOwoJICAgIH0KCSAgfQoJICAvKiBjYW4ndCB3cml0ZSBkaXJlY3RseSwgcHV0IGludG8gdHJhbnNtaXQgYnVmZmVyICovCgkgIHN0YXR1cyA9ICgocHRyLT5vYnVmX3RhaWwgPiBwdHItPm9idWZfaGVhZCkgPwoJCSAgICAocHRyLT5vYnVmX3RhaWwtMSkgOiBwdHItPm9idWZfc2l6ZSkgLSBwdHItPm9idWZfaGVhZDsKCSAgaWYgKCFzdGF0dXMpIGJyZWFrOwoJICBpZiAoKGNiV3JpdGUgLSBsZW5ndGgpIDwgc3RhdHVzKQoJICAgIHN0YXR1cyA9IGNiV3JpdGUgLSBsZW5ndGg7CgkgIG1lbWNweShscHZCdWYsIHB0ci0+b3V0YnVmICsgcHRyLT5vYnVmX2hlYWQsIHN0YXR1cyk7CgkgIHB0ci0+b2J1Zl9oZWFkICs9IHN0YXR1czsKCSAgaWYgKHB0ci0+b2J1Zl9oZWFkID49IHB0ci0+b2J1Zl9zaXplKQoJICAgIHB0ci0+b2J1Zl9oZWFkID0gMDsKCSAgbHB2QnVmICs9IHN0YXR1czsKCSAgbGVuZ3RoICs9IHN0YXR1czsKCSAgY29tbV93YWl0d3JpdGUocHRyKTsKCX0KCglwdHItPmNvbW1lcnJvciA9IDA7CglyZXR1cm4gbGVuZ3RoOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIEVuYWJsZUNvbW1Ob3RpZmljYXRpb24gICAoVVNFUi4yNDUpCiAqLwpCT09MMTYgV0lOQVBJIEVuYWJsZUNvbW1Ob3RpZmljYXRpb24xNiggSU5UMTYgY2lkLCBIV05EMTYgaHduZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJTlQxNiBjYldyaXRlTm90aWZ5LCBJTlQxNiBjYk91dFF1ZXVlICkKewoJc3RydWN0IERvc0RldmljZVN0cnVjdCAqcHRyOwoKCVRSQUNFKCIoJWQsICV4LCAlZCwgJWQpXG4iLCBjaWQsIGh3bmQsIGNiV3JpdGVOb3RpZnksIGNiT3V0UXVldWUpOwoJaWYgKChwdHIgPSBHZXREZXZpY2VTdHJ1Y3QoY2lkKSkgPT0gTlVMTCkgewoJCUZJWE1FKCJubyBoYW5kbGUgZm9yIGNpZCA9ICUweCFcbiIsY2lkKTsKCQlyZXR1cm4gLTE7Cgl9CglwdHItPnduZCA9IFdJTl9IYW5kbGUzMiggaHduZCApOwoJcHRyLT5uX3JlYWQgPSBjYldyaXRlTm90aWZ5OwoJcHRyLT5uX3dyaXRlID0gY2JPdXRRdWV1ZTsKCXJldHVybiBUUlVFOwp9Cg==