Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIG1rc3dhcC5jIC0gc2V0IHVwIGEgbGludXggc3dhcCBkZXZpY2UKICoKICogKEMpIDE5OTEgTGludXMgVG9ydmFsZHMuIFRoaXMgZmlsZSBtYXkgYmUgcmVkaXN0cmlidXRlZCBhcyBwZXIKICogdGhlIExpbnV4IGNvcHlyaWdodC4KICovCgovKgogKiAyMC4xMi45MSAgLQl0aW1lIGJlZ2FuLiBHb3QgVk0gd29ya2luZyB5ZXN0ZXJkYXkgYnkgZG9pbmcgdGhpcyBieSBoYW5kLgogKgogKiBVc2FnZTogbWtzd2FwIFstY10gWy12Tl0gWy1mXSBkZXZpY2UgW3NpemUtaW4tYmxvY2tzXQogKgogKgktYyAgIGZvciByZWFkYWJpbGl0eSBjaGVja2luZy4gKFVzZSBpdCB1bmxlc3MgeW91IGFyZSBTVVJFISkKICoJLXZOICBmb3Igc3dhcCBhcmVhcyB2ZXJzaW9uIE4uIChPbmx5IE49MCwxIGtub3duIHRvZGF5LikKICogICAgICAtZiAgIGZvciBmb3JjaW5nIHN3YXAgY3JlYXRpb24gZXZlbiBpZiBpdCB3b3VsZCBzbWFzaCBwYXJ0aXRpb24gdGFibGUuCiAqCiAqIFRoZSBkZXZpY2UgbWF5IGJlIGEgYmxvY2sgZGV2aWNlIG9yIGFuIGltYWdlIG9mIG9uZSwgYnV0IHRoaXMgaXNuJ3QKICogZW5mb3JjZWQgKGJ1dCBpdCdzIG5vdCBtdWNoIGZ1biBvbiBhIGNoYXJhY3RlciBkZXZpY2UgOi0pLgogKgogKiBQYXRjaGVzIGZyb20gamFnZ3lAcHVycGxldC5kZW1vbi5jby51ayAoTWlrZSBKYWdkaXMpIHRvIG1ha2UgdGhlCiAqIHNpemUtaW4tYmxvY2tzIHBhcmFtZXRlciBvcHRpb25hbCBhZGRlZCBXZWQgRmViICA4IDEwOjMzOjQzIDE5OTUuCiAqCiAqIFZlcnNpb24gMSBzd2FwIGFyZWEgY29kZSAoZm9yIGtlcm5lbCAyLjEuMTE3KSwgYWViLCA5ODEwMTAuCiAqCiAqIFNwYXJjIGZpeGVzLCBqakB1bHRyYS5saW51eC5jeiAoSmFrdWIgSmVsaW5layksIDk4MTIwMSAtIG1hbmdsZWQgYnkgYWViLgogKiBWMV9NQVhfUEFHRVMgZml4ZXMsIGpqLCA5OTAzMjUuCiAqCiAqIDE5OTktMDItMjIgQXJrYWRpdXN6IE1ptmtpZXdpY3ogPG1pc2lla0BtaXNpZWsuZXUub3JnPgogKiAtIGFkZGVkIE5hdGl2ZSBMYW5ndWFnZSBTdXBwb3J0CiAqCiAqICBmcm9tIHV0aWwtbGludXggLS0gYWRhcHRlZCBmb3IgYnVzeWJveCBieQogKiAgRXJpayBBbmRlcnNlbiA8YW5kZXJzZW5AY29kZXBvZXQub3JnPi4gSSByaXBwZWQgb3V0IE5hdGl2ZSBMYW5ndWFnZQogKiAgU3VwcG9ydCwgbWFkZSBzb21lIHN0dWZmIHNtYWxsZXIsIGFuZCBmaXR0ZWQgZm9yIGxpZmUgaW4gYnVzeWJveC4KICoKICovCgojaW5jbHVkZSA8c3RkaW8uaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVkZSA8c3RyaW5nLmg+CiNpbmNsdWRlIDxmY250bC5oPgojaW5jbHVkZSA8c3RkbGliLmg+CiNpbmNsdWRlIDxzeXMvaW9jdGwuaD4JCQkvKiBmb3IgX0lPICovCiNpbmNsdWRlIDxzeXMvdXRzbmFtZS5oPgojaW5jbHVkZSA8YXNtL3BhZ2UuaD4JCQkvKiBmb3IgUEFHRV9TSVpFIGFuZCBQQUdFX1NISUZUICovCgkJCQkvKiB3ZSBhbHNvIGdldCBQQUdFX1NJWkUgdmlhIGdldHBhZ2VzaXplKCkgKi8KI2luY2x1ZGUgImJ1c3lib3guaCIKCiNpZm5kZWYgX0lPCi8qIHByZS0xLjMuNDUgKi8KZW51bSB7IEJMS0dFVFNJWkUgPSAweDEyNjAgfTsKI2Vsc2UKLyogc2FtZSBvbiBpMzg2LCBtNjhrLCBhcm07IGRpZmZlcmVudCBvbiBhbHBoYSwgbWlwcywgc3BhcmMsIHBwYyAqLwojZGVmaW5lIEJMS0dFVFNJWkUgX0lPKDB4MTIsOTYpCiNlbmRpZgoKc3RhdGljIGNoYXIgKmRldmljZV9uYW1lID0gTlVMTDsKc3RhdGljIGludCBERVYgPSAtMTsKc3RhdGljIGxvbmcgUEFHRVMgPSAwOwpzdGF0aWMgaW50IGNoZWNrID0gMDsKc3RhdGljIGludCBiYWRwYWdlcyA9IDA7CiNpZiBFTkFCTEVfRkVBVFVSRV9NS1NXQVBfVjAKc3RhdGljIGludCB2ZXJzaW9uID0gLTE7CiNkZWZpbmUgTUFLRV9WRVJTSU9OKHAscSxyKQkoNjU1MzYqKHApICsgMjU2KihxKSArIChyKSkKI2Vsc2UKI2RlZmluZSB2ZXJzaW9uIDEKLyogYW5kIG1ha2Ugc3VyZSB0aGF0IHdlIG9wdGltaXplIGF3YXkgYW55dGhpbmcgd2hpY2ggd291bGQgZGVhbCB3aXRoIGNoZWNraW5nCiAqIHRoZSBrZXJuZWwgcmV2aXNpb24gYXMgd2UgaGF2ZSB2MSBzdXBwb3J0IG9ubHkgYW55d2F5LgogKi8KI2RlZmluZSBNQUtFX1ZFUlNJT04ocCxxLHIpIDEKI2RlZmluZSBnZXRfa2VybmVsX3JldmlzaW9uKCkgMQojZW5kaWYKCi8qCiAqIFRoZSBkZWZpbml0aW9uIG9mIHRoZSB1bmlvbiBzd2FwX2hlYWRlciB1c2VzIHRoZSBjb25zdGFudCBQQUdFX1NJWkUuCiAqIFVuZm9ydHVuYXRlbHksIG9uIHNvbWUgYXJjaGl0ZWN0dXJlcyB0aGlzIGRlcGVuZHMgb24gdGhlIGhhcmR3YXJlIG1vZGVsLAogKiBhbmQgY2FuIG9ubHkgYmUgZm91bmQgYXQgcnVuIHRpbWUgLS0gd2UgdXNlIGdldHBhZ2VzaXplKCkuCiAqLwoKc3RhdGljIGludCBwYWdlc2l6ZTsKc3RhdGljIHVuc2lnbmVkIGludCAqc2lnbmF0dXJlX3BhZ2U7CgpzdGF0aWMgc3RydWN0IHN3YXBfaGVhZGVyX3YxIHsKCWNoYXIgYm9vdGJpdHNbMTAyNF07CQkvKiBTcGFjZSBmb3IgZGlza2xhYmVsIGV0Yy4gKi8KCXVuc2lnbmVkIGludCBzd2FwX3ZlcnNpb247Cgl1bnNpZ25lZCBpbnQgbGFzdF9wYWdlOwoJdW5zaWduZWQgaW50IG5yX2JhZHBhZ2VzOwoJdW5zaWduZWQgaW50IHBhZGRpbmdbMTI1XTsKCXVuc2lnbmVkIGludCBiYWRwYWdlc1sxXTsKfSAqcDsKCnN0YXRpYyBpbmxpbmUgdm9pZCBpbml0X3NpZ25hdHVyZV9wYWdlKHZvaWQpCnsKCXBhZ2VzaXplID0gZ2V0cGFnZXNpemUoKTsKCiNpZmRlZiBQQUdFX1NJWkUKCWlmIChwYWdlc2l6ZSAhPSBQQUdFX1NJWkUpCgkJYmJfZXJyb3JfbXNnKCJBc3N1bWluZyBwYWdlcyBvZiBzaXplICVkIiwgcGFnZXNpemUpOwojZW5kaWYKCXNpZ25hdHVyZV9wYWdlID0gKHVuc2lnbmVkIGludCAqKSB4bWFsbG9jKHBhZ2VzaXplKTsKCW1lbXNldChzaWduYXR1cmVfcGFnZSwgMCwgcGFnZXNpemUpOwoJcCA9IChzdHJ1Y3Qgc3dhcF9oZWFkZXJfdjEgKikgc2lnbmF0dXJlX3BhZ2U7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB3cml0ZV9zaWduYXR1cmUoY2hhciAqc2lnKQp7CgljaGFyICpzcCA9IChjaGFyICopIHNpZ25hdHVyZV9wYWdlOwoKCXN0cm5jcHkoc3AgKyBwYWdlc2l6ZSAtIDEwLCBzaWcsIDEwKTsKfQoKI2RlZmluZSBWMF9NQVhfUEFHRVMJKDggKiAocGFnZXNpemUgLSAxMCkpCi8qIEJlZm9yZSAyLjIuMHByZTkgKi8KI2RlZmluZSBWMV9PTERfTUFYX1BBR0VTCSgoMHg3ZmZmZmZmZiAvIHBhZ2VzaXplKSAtIDEpCi8qIFNpbmNlIDIuMi4wcHJlOToKICAgZXJyb3IgaWYgbnIgb2YgcGFnZXMgPj0gU1dQX09GRlNFVChTV1BfRU5UUlkoMCx+MFVMKSkKICAgd2l0aCB2YXJpYXRpb25zIG9uCgkjZGVmaW5lIFNXUF9FTlRSWSh0eXBlLG9mZnNldCkgKCgodHlwZSkgPDwgMSkgfCAoKG9mZnNldCkgPDwgOCkpCgkjZGVmaW5lIFNXUF9PRkZTRVQoZW50cnkpICgoZW50cnkpID4+IDgpCiAgIG9uIHRoZSB2YXJpb3VzIGFyY2hpdGVjdHVyZXMuIEJlbG93IHRoZSByZXN1bHQgLSB5dWsuCgogICBNYWNoaW5lCXBhZ2VzaXplCVNXUF9FTlRSWQlTV1BfT0ZGU0VUCWJvdW5kKzEJb2xkYm91bmQrMgogICBpMzg2CQkyXjEyCQlvPDw4CQllPj44CQkxPDwyNAkxPDwxOQogICBtaXBzCQkyXjEyCQlvPDwxNQkJZT4+MTUJCTE8PDE3CTE8PDE5CiAgIGFscGhhCTJeMTMJCW88PDQwCQllPj40MAkJMTw8MjQJMTw8MTgKICAgbTY4awkJMl4xMgkJbzw8MTIJCWU+PjEyCQkxPDwyMAkxPDwxOQogICBzcGFyYwkyXnsxMiwxM30JKG8mMHgzZmZmZik8PDkJKGU+PjkpJjB4M2ZmZmYJMTw8MTgJMTw8ezE5LDE4fQogICBzcGFyYzY0CTJeMTMJCW88PDEzCQllPj4xMwkJMTw8NTEJMTw8MTgKICAgcHBjCQkyXjEyCQlvPDw4CQllPj44CQkxPDwyNAkxPDwxOQogICBhcm1vCQkyXnsxMywxNCwxNX0Jbzw8OAkJZT4+OAkJMTw8MjQJMTw8ezE4LDE3LDE2fQogICBhcm12CQkyXjEyCQlvPDw5CQllPj45CQkxPDwyMwkxPDwxOQoKICAgYXNzdW1pbmcgdGhhdCBsb25ncyBoYXZlIDY0IGJpdHMgb24gYWxwaGEgYW5kIHNwYXJjNjQgYW5kIDMyIGJpdHMgZWxzZXdoZXJlLgoKICAgVGhlIGJhZCBwYXJ0IGlzIHRoYXQgd2UgbmVlZCB0byBrbm93IHRoaXMgc2luY2UgdGhlIGtlcm5lbCB3aWxsCiAgIHJlZnVzZSBhIHN3YXAgc3BhY2UgaWYgaXQgaXMgdG9vIGxhcmdlLgoqLwovKiBwYXRjaCBmcm9tIGpqIC0gd2h5IGRvZXMgdGhpcyBkaWZmZXIgZnJvbSB0aGUgYWJvdmU/ICovCiNpZiBkZWZpbmVkKF9fYWxwaGFfXykKI2RlZmluZSBWMV9NQVhfUEFHRVMgICAgICAgICAgICgoMSA8PCAyNCkgLSAxKQojZWxpZiBkZWZpbmVkKF9fbWlwc19fKQojZGVmaW5lIFYxX01BWF9QQUdFUyAgICAgICAgICAgKCgxIDw8IDE3KSAtIDEpCiNlbGlmIGRlZmluZWQoX19zcGFyY192OV9fKQojZGVmaW5lIFYxX01BWF9QQUdFUyAgICAgICAgICAgKCgzIDw8IDI5KSAtIDEpCiNlbGlmIGRlZmluZWQoX19zcGFyY19fKQojZGVmaW5lIFYxX01BWF9QQUdFUyAgICAgICAgICAgKHBhZ2VzaXplID09IDgxOTIgPyAoKDMgPDwgMjkpIC0gMSkgOiAoKDEgPDwgMTgpIC0gMSkpCiNlbHNlCiNkZWZpbmUgVjFfTUFYX1BBR0VTICAgICAgICAgICBWMV9PTERfTUFYX1BBR0VTCiNlbmRpZgovKiBtYW4gcGFnZSBub3cgc2F5czoKVGhlIG1heGltdW0gdXNlZnVsIHNpemUgb2YgYSBzd2FwIGFyZWEgbm93IGRlcGVuZHMgb24gdGhlIGFyY2hpdGVjdHVyZS4KSXQgaXMgcm91Z2hseSAyR0Igb24gaTM4NiwgUFBDLCBtNjhrLCBBUk0sIDFHQiBvbiBzcGFyYywgNTEyTUIgb24gbWlwcywKMTI4R0Igb24gYWxwaGEgYW5kIDNUQiBvbiBzcGFyYzY0LgoqLwoKI2RlZmluZSBNQVhfQkFEUEFHRVMJKChwYWdlc2l6ZS0xMDI0LTEyOCpzaXplb2YoaW50KS0xMCkvc2l6ZW9mKGludCkpCgpzdGF0aWMgaW5saW5lIHZvaWQgYml0X3NldCh1bnNpZ25lZCBpbnQgKmFkZHIsIHVuc2lnbmVkIGludCBucikKewoJdW5zaWduZWQgaW50IHIsIG07CgoJYWRkciArPSBuciAvICg4ICogc2l6ZW9mKGludCkpOwoKCXIgPSAqYWRkcjsKCW0gPSAxIDw8IChuciAmICg4ICogc2l6ZW9mKGludCkgLSAxKSk7CgoJKmFkZHIgPSByIHwgbTsKfQoKc3RhdGljIGludCBiaXRfdGVzdF9hbmRfY2xlYXIodW5zaWduZWQgaW50ICphZGRyLCB1bnNpZ25lZCBpbnQgbnIpCnsKCXVuc2lnbmVkIGludCByLCBtOwoKCWFkZHIgKz0gbnIgLyAoOCAqIHNpemVvZihpbnQpKTsKCglyID0gKmFkZHI7CgltID0gMSA8PCAobnIgJiAoOCAqIHNpemVvZihpbnQpIC0gMSkpOwoKCSphZGRyID0gciAmIH5tOwoJcmV0dXJuIChyICYgbSkgIT0gMDsKfQoKc3RhdGljIHZvaWQgcGFnZV9vayhpbnQgcGFnZSkKewoJaWYgKEVOQUJMRV9GRUFUVVJFX01LU1dBUF9WMCkgewoJCWJpdF9zZXQoc2lnbmF0dXJlX3BhZ2UsIHBhZ2UpOwoJfQp9CgpzdGF0aWMgdm9pZCBjaGVja19ibG9ja3Modm9pZCkKewoJdW5zaWduZWQgaW50IGN1cnJlbnRfcGFnZTsKCWludCBkb19zZWVrID0gMTsKCWNoYXIgKmJ1ZmZlcjsKCglidWZmZXIgPSB4bWFsbG9jKHBhZ2VzaXplKTsKCWN1cnJlbnRfcGFnZSA9IDA7Cgl3aGlsZSAoY3VycmVudF9wYWdlIDwgUEFHRVMpIHsKCQlpZiAoIWNoZWNrICYmIHZlcnNpb24gPT0gMCkgewoJCQlwYWdlX29rKGN1cnJlbnRfcGFnZSsrKTsKCQkJY29udGludWU7CgkJfQoJCWlmIChkb19zZWVrICYmIGxzZWVrKERFViwgY3VycmVudF9wYWdlICogcGFnZXNpemUsIFNFRUtfU0VUKSAhPQoJCQljdXJyZW50X3BhZ2UgKiBwYWdlc2l6ZSkKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoInNlZWsgZmFpbGVkIGluIGNoZWNrX2Jsb2NrcyIpOwoJCWlmICgoZG9fc2VlayA9IChwYWdlc2l6ZSAhPSByZWFkKERFViwgYnVmZmVyLCBwYWdlc2l6ZSkpKSkgewoJCQljdXJyZW50X3BhZ2UrKzsKCQkJaWYgKHZlcnNpb24gPT0gMCkKCQkJCWJpdF90ZXN0X2FuZF9jbGVhcihzaWduYXR1cmVfcGFnZSwgY3VycmVudF9wYWdlKTsKCQkJZWxzZSB7CgkJCQlpZiAoYmFkcGFnZXMgPT0gTUFYX0JBRFBBR0VTKQoJCQkJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJ0b28gbWFueSBiYWQgcGFnZXMiKTsKCQkJCXAtPmJhZHBhZ2VzW2JhZHBhZ2VzXSA9IGN1cnJlbnRfcGFnZTsKCQkJfQoJCQliYWRwYWdlcysrOwoJCQljb250aW51ZTsKCQl9CgkJcGFnZV9vayhjdXJyZW50X3BhZ2UrKyk7Cgl9CglpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApCgkJZnJlZShidWZmZXIpOwoJaWYgKGJhZHBhZ2VzID4gMCkKCQlwcmludGYoIiVkIGJhZCBwYWdlJXNcbiIsIGJhZHBhZ2VzLCAoYmFkcGFnZXM9PTEpPyIiOiJzIik7Cn0KCnN0YXRpYyBsb25nIHZhbGlkX29mZnNldChpbnQgZmQsIGludCBvZmZzZXQpCnsKCWNoYXIgY2g7CgoJaWYgKGxzZWVrKGZkLCBvZmZzZXQsIDApIDwgMCkKCQlyZXR1cm4gMDsKCWlmIChyZWFkKGZkLCAmY2gsIDEpIDwgMSkKCQlyZXR1cm4gMDsKCXJldHVybiAxOwp9CgpzdGF0aWMgaW50IGZpbmRfc2l6ZShpbnQgZmQpCnsKCXVuc2lnbmVkIGludCBoaWdoLCBsb3c7CgoJbG93ID0gMDsKCWZvciAoaGlnaCA9IDE7IGhpZ2ggPiAwICYmIHZhbGlkX29mZnNldChmZCwgaGlnaCk7IGhpZ2ggKj0gMikKCQlsb3cgPSBoaWdoOwoJd2hpbGUgKGxvdyA8IGhpZ2ggLSAxKSB7CgkJY29uc3QgaW50IG1pZCA9IChsb3cgKyBoaWdoKSAvIDI7CgoJCWlmICh2YWxpZF9vZmZzZXQoZmQsIG1pZCkpCgkJCWxvdyA9IG1pZDsKCQllbHNlCgkJCWhpZ2ggPSBtaWQ7Cgl9CglyZXR1cm4gKGxvdyArIDEpOwp9CgovKiByZXR1cm4gc2l6ZSBpbiBwYWdlcywgdG8gYXZvaWQgaW50ZWdlciBvdmVyZmxvdyAqLwpzdGF0aWMgaW5saW5lIGxvbmcgZ2V0X3NpemUoY29uc3QgY2hhciAqZmlsZSkKewoJaW50IGZkOwoJbG9uZyBzaXplOwoKCWZkID0gYmJfeG9wZW4zKGZpbGUsIE9fUkRPTkxZLCAwKTsKCWlmIChpb2N0bChmZCwgQkxLR0VUU0laRSwgJnNpemUpID49IDApIHsKCQlzaXplIC89IHBhZ2VzaXplIC8gNTEyOwoJfSBlbHNlIHsKCQlzaXplID0gZmluZF9zaXplKGZkKSAvIHBhZ2VzaXplOwoJfQoJY2xvc2UoZmQpOwoJcmV0dXJuIHNpemU7Cn0KCmludCBta3N3YXBfbWFpbihpbnQgYXJnYywgY2hhciAqKmFyZ3YpCnsKCWNoYXIgKnRtcDsKCXN0cnVjdCBzdGF0IHN0YXRidWY7CglpbnQgc3o7CglpbnQgbWF4cGFnZXM7CglpbnQgZ29vZHBhZ2VzOwojaWZkZWYgX19zcGFyY19fCglpbnQgZm9yY2UgPSAwOwojZW5kaWYKCglpbml0X3NpZ25hdHVyZV9wYWdlKCk7CQkvKiBnZXQgcGFnZXNpemUgKi8KCgliYl9vcHRfY29tcGxlbWVudGFsbHkgPSAiPyI7IC8qIGNhbGwgYmJfc2hvd191c2FnZSBpbnRlcm5hbGx5ICovCglzeiA9IGJiX2dldG9wdF91bGZsYWdzKGFyZ2MsIGFyZ3YsICIrY2Z2OiIsICZ0bXApOwoJaWYgKHN6ICYgMSkKCQljaGVjayA9IDE7CiNpZmRlZiBfX3NwYXJjX18KCWlmIChzeiAmIDIpCgkJZm9yY2UgPSAxOwojZW5kaWYKI2lmIEVOQUJMRV9GRUFUVVJFX01LU1dBUF9WMAoJaWYgKHN6ICYgNCkgewoJCXZlcnNpb24gPSBiYl94Z2V0bGFyZyh0bXAsIDEwLCAwLCAxKTsKCX0gZWxzZSB7CgkJaWYgKGdldF9rZXJuZWxfcmV2aXNpb24oKSA8IE1BS0VfVkVSU0lPTigyLCAxLCAxMTcpKQoJCQl2ZXJzaW9uID0gMDsKCQllbHNlCgkJCXZlcnNpb24gPSAxOwoJfQojZW5kaWYKCglhcmd2ICs9IG9wdGluZDsKCWFyZ2MgLT0gb3B0aW5kOwoKCWdvb2RwYWdlcyA9IHBhZ2VzaXplIC8gMTAyNDsgLyogY2FjaGUgZGl2aXNpb24gKi8KCXdoaWxlIChhcmdjLS0pIHsKCQlpZiAoZGV2aWNlX25hbWUpIHsKCQkJUEFHRVMgPSBiYl94Z2V0bGFyZyhhcmd2WzBdLCAwLCAxMCwgc3ogKiBnb29kcGFnZXMpIC8gZ29vZHBhZ2VzOwoJCQlhcmdjID0gMDsgLyogaWdub3JlIGFueSBzdXJwbHVzIGFyZ3MuLiAqLwoJCX0gZWxzZSB7CgkJCWRldmljZV9uYW1lID0gYXJndlswXTsKCQkJc3ogPSBnZXRfc2l6ZShkZXZpY2VfbmFtZSk7CgkJCWFyZ3YrKzsKCQl9Cgl9CgoJaWYgKCFkZXZpY2VfbmFtZSkgewoJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJlcnJvcjogTm93aGVyZSB0byBzZXQgdXAgc3dhcCBvbj8iKTsKCX0KCWlmICghUEFHRVMpIHsKCQlQQUdFUyA9IHN6OwoJfQoKI2lmIDAKCW1heHBhZ2VzID0gKCh2ZXJzaW9uID09IDApID8gVjBfTUFYX1BBR0VTIDogVjFfTUFYX1BBR0VTKTsKI2Vsc2UKCWlmICghdmVyc2lvbikKCQltYXhwYWdlcyA9IFYwX01BWF9QQUdFUzsKCWVsc2UgaWYgKGdldF9rZXJuZWxfcmV2aXNpb24oKSA+PSBNQUtFX1ZFUlNJT04oMiwgMiwgMSkpCgkJbWF4cGFnZXMgPSBWMV9NQVhfUEFHRVM7CgllbHNlIHsKCQltYXhwYWdlcyA9IFYxX09MRF9NQVhfUEFHRVM7CgkJaWYgKG1heHBhZ2VzID4gVjFfTUFYX1BBR0VTKQoJCQltYXhwYWdlcyA9IFYxX01BWF9QQUdFUzsKCX0KI2VuZGlmCglpZiAoUEFHRVMgPiBtYXhwYWdlcykgewoJCVBBR0VTID0gbWF4cGFnZXM7CgkJYmJfZXJyb3JfbXNnKCJ3YXJuaW5nOiB0cnVuY2F0aW5nIHN3YXAgYXJlYSB0byAlbGRrQiIsCgkJCQlQQUdFUyAqIGdvb2RwYWdlcyk7Cgl9CgoJREVWID0gYmJfeG9wZW4zKGRldmljZV9uYW1lLCBPX1JEV1IsIDApOwoJaWYgKGZzdGF0KERFViwgJnN0YXRidWYpIDwgMCkKCQliYl9wZXJyb3JfbXNnX2FuZF9kaWUoIiVzIiwgZGV2aWNlX25hbWUpOwoJaWYgKCFTX0lTQkxLKHN0YXRidWYuc3RfbW9kZSkpCgkJY2hlY2sgPSAwOwoJZWxzZSBpZiAoc3RhdGJ1Zi5zdF9yZGV2ID09IDB4MDMwMCB8fCBzdGF0YnVmLnN0X3JkZXYgPT0gMHgwMzQwKQoJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJXaWxsIG5vdCB0cnkgdG8gbWFrZSBzd2FwZGV2aWNlIG9uICclcyciLCBkZXZpY2VfbmFtZSk7CgojaWZkZWYgX19zcGFyY19fCglpZiAoIWZvcmNlICYmIHZlcnNpb24gPT0gMCkgewoJCS8qIERvbid0IG92ZXJ3cml0ZSBwYXJ0aXRpb24gdGFibGUgdW5sZXNzIGZvcmNlZCAqLwoJCXVuc2lnbmVkIGNoYXIgKmJ1ZmZlciA9ICh1bnNpZ25lZCBjaGFyICopIHNpZ25hdHVyZV9wYWdlOwoJCXVuc2lnbmVkIHNob3J0ICpxLCBzdW07CgoJCWlmIChyZWFkKERFViwgYnVmZmVyLCA1MTIpICE9IDUxMikKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImZhdGFsOiBmaXJzdCBwYWdlIHVucmVhZGFibGUiKTsKCQlpZiAoYnVmZmVyWzUwOF0gPT0gMHhEQSAmJiBidWZmZXJbNTA5XSA9PSAweEJFKSB7CgkJCXEgPSAodW5zaWduZWQgc2hvcnQgKikgKGJ1ZmZlciArIDUxMCk7CgkJCWZvciAoc3VtID0gMDsgcSA+PSAodW5zaWduZWQgc2hvcnQgKikgYnVmZmVyOykKCQkJCXN1bSBePSAqcS0tOwoJCQlpZiAoIXN1bSkgewoJCQkJYmJfZXJyb3JfbXNnKCJEZXZpY2UgJyVzJyBjb250YWlucyBhIHZhbGlkIFN1biBkaXNrbGFiZWwuXG4iCiJUaGlzIHByb2JhYmx5IG1lYW5zIGNyZWF0aW5nIHYwIHN3YXAgd291bGQgZGVzdHJveSB5b3VyIHBhcnRpdGlvbiB0YWJsZVxuIgoiTm8gc3dhcCBjcmVhdGVkLiBJZiB5b3UgcmVhbGx5IHdhbnQgdG8gY3JlYXRlIHN3YXAgdjAgb24gdGhhdCBkZXZpY2UsIHVzZVxuIgoidGhlIC1mIG9wdGlvbiB0byBmb3JjZSBpdC4iLCBkZXZpY2VfbmFtZSk7CgkJCQlyZXR1cm4gRVhJVF9GQUlMVVJFOwoJCQl9CgkJfQoJfQojZW5kaWYKCglpZiAodmVyc2lvbiA9PSAwIHx8IGNoZWNrKQoJCWNoZWNrX2Jsb2NrcygpOwoJaWYgKHZlcnNpb24gPT0gMCAmJiAhYml0X3Rlc3RfYW5kX2NsZWFyKHNpZ25hdHVyZV9wYWdlLCAwKSkKCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgiZmF0YWw6IGZpcnN0IHBhZ2UgdW5yZWFkYWJsZSIpOwoJaWYgKHZlcnNpb24gPT0gMSkgewoJCXAtPnN3YXBfdmVyc2lvbiA9IHZlcnNpb247CgkJcC0+bGFzdF9wYWdlID0gUEFHRVMgLSAxOwoJCXAtPm5yX2JhZHBhZ2VzID0gYmFkcGFnZXM7Cgl9CgoJZ29vZHBhZ2VzID0gUEFHRVMgLSBiYWRwYWdlcyAtIDE7CglpZiAoZ29vZHBhZ2VzIDw9IDApCgkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoIlVuYWJsZSB0byBzZXQgdXAgc3dhcC1zcGFjZTogdW5yZWFkYWJsZSIpOwoJcHJpbnRmKCJTZXR0aW5nIHVwIHN3YXBzcGFjZSB2ZXJzaW9uICVkLCBzaXplID0gJWxkIGJ5dGVzXG4iLAoJCSAgIHZlcnNpb24sIChsb25nKSAoZ29vZHBhZ2VzICogcGFnZXNpemUpKTsKCXdyaXRlX3NpZ25hdHVyZSgodmVyc2lvbiA9PSAwKSA/ICJTV0FQLVNQQUNFIiA6ICJTV0FQU1BBQ0UyIik7CgoJc3ogPSAoKHZlcnNpb24gPT0gMCkgPyAwIDogMTAyNCk7IC8qIG9mZnNldCAqLwoJaWYgKGxzZWVrKERFViwgc3osIFNFRUtfU0VUKSAhPSBzeikKCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgidW5hYmxlIHRvIHJld2luZCBzd2FwLWRldmljZSIpOwoJZ29vZHBhZ2VzID0gcGFnZXNpemUgLSBzejsgLyogY2FjaGUgc3Vic3RyYWN0aW9uICovCglpZiAod3JpdGUoREVWLCAoY2hhciAqKSBzaWduYXR1cmVfcGFnZSArIHN6LCBnb29kcGFnZXMpCgkJIT0gZ29vZHBhZ2VzKQoJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJ1bmFibGUgdG8gd3JpdGUgc2lnbmF0dXJlIHBhZ2UiKTsKCgkvKgoJICogQSBzdWJzZXF1ZW50IHN3YXBvbigpIHdpbGwgZmFpbCBpZiB0aGUgc2lnbmF0dXJlCgkgKiBpcyBub3QgYWN0dWFsbHkgb24gZGlzay4gKFRoaXMgaXMgYSBrZXJuZWwgYnVnLikKCSAqLwoJaWYgKGZzeW5jKERFVikpCgkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImZzeW5jIGZhaWxlZCIpOwoJaWYgKEVOQUJMRV9GRUFUVVJFX0NMRUFOX1VQKSB7CgkJY2xvc2UoREVWKTsKCQlmcmVlKHNpZ25hdHVyZV9wYWdlKTsKCX0KCXJldHVybiBFWElUX1NVQ0NFU1M7Cn0K