LyoKICogbGludXgvZHJpdmVycy9zMzkwL2Npby9jbWYuYwogKgogKiBMaW51eCBvbiB6U2VyaWVzIENoYW5uZWwgTWVhc3VyZW1lbnQgRmFjaWxpdHkgc3VwcG9ydAogKgogKiBDb3B5cmlnaHQgMjAwMCwyMDA2IElCTSBDb3Jwb3JhdGlvbgogKgogKiBBdXRob3JzOiBBcm5kIEJlcmdtYW5uIDxhcm5kYkBkZS5pYm0uY29tPgogKgkgICAgQ29ybmVsaWEgSHVjayA8Y29ybmVsaWEuaHVja0BkZS5pYm0uY29tPgogKgogKiBvcmlnaW5hbCBpZGVhIGZyb20gTmF0YXJhamFuIEtyaXNobmFzd2FtaSA8bmtyaXNobmFAdXMuaWJtLmNvbT4KICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQogKiBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNjc1IE1hc3MgQXZlLCBDYW1icmlkZ2UsIE1BIDAyMTM5LCBVU0EuCiAqLwoKI2luY2x1ZGUgPGxpbnV4L2Jvb3RtZW0uaD4KI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvbGlzdC5oPgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgojaW5jbHVkZSA8bGludXgvc2xhYi5oPgojaW5jbHVkZSA8bGludXgvdGltZXguaD4JLyogZ2V0X2Nsb2NrKCkgKi8KCiNpbmNsdWRlIDxhc20vY2N3ZGV2Lmg+CiNpbmNsdWRlIDxhc20vY2lvLmg+CiNpbmNsdWRlIDxhc20vY21iLmg+CiNpbmNsdWRlIDxhc20vZGl2NjQuaD4KCiNpbmNsdWRlICJjaW8uaCIKI2luY2x1ZGUgImNzcy5oIgojaW5jbHVkZSAiZGV2aWNlLmgiCiNpbmNsdWRlICJpb2FzbS5oIgojaW5jbHVkZSAiY2hzYy5oIgoKLyogcGFyYW1ldGVyIHRvIGVuYWJsZSBjbWYgZHVyaW5nIGJvb3QsIHBvc3NpYmxlIHVzZXMgYXJlOgogKiAgInMzOTBjbWYiIC0tIGVuYWJsZSBjbWYgYW5kIGFsbG9jYXRlIDIgTUIgb2YgcmFtIHNvIG1lYXN1cmluZyBjYW4gYmUKICogICAgICAgICAgICAgICB1c2VkIG9uIGFueSBzdWJjaGFubmVsCiAqICAiczM5MGNtZj08bnVtPiIgLS0gZW5hYmxlIGNtZiBhbmQgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSB0byBtZWFzdXJlCiAqICAgICAgICAgICAgICAgICAgICAgPG51bT4gc3ViY2hhbm5lbCwgd2hlcmUgPG51bT4gaXMgYW4gaW50ZWdlcgogKiAgICAgICAgICAgICAgICAgICAgIGJldHdlZW4gMSBhbmQgNjU1MzUsIGRlZmF1bHQgaXMgMTAyNAogKi8KI2RlZmluZSBBUkdTVFJJTkcgInMzOTBjbWYiCgovKiBpbmRpY2VzIGZvciBSRUFEQ01CICovCmVudW0gY21iX2luZGV4IHsKIC8qIGJhc2ljIGFuZCBleGVuZGVkIGZvcm1hdDogKi8KCWNtYl9zc2NoX3JzY2hfY291bnQsCgljbWJfc2FtcGxlX2NvdW50LAoJY21iX2RldmljZV9jb25uZWN0X3RpbWUsCgljbWJfZnVuY3Rpb25fcGVuZGluZ190aW1lLAoJY21iX2RldmljZV9kaXNjb25uZWN0X3RpbWUsCgljbWJfY29udHJvbF91bml0X3F1ZXVpbmdfdGltZSwKCWNtYl9kZXZpY2VfYWN0aXZlX29ubHlfdGltZSwKIC8qIGV4dGVuZGVkIGZvcm1hdCBvbmx5OiAqLwoJY21iX2RldmljZV9idXN5X3RpbWUsCgljbWJfaW5pdGlhbF9jb21tYW5kX3Jlc3BvbnNlX3RpbWUsCn07CgovKioKICogZW51bSBjbWJfZm9ybWF0IC0gdHlwZXMgb2Ygc3VwcG9ydGVkIG1lYXN1cmVtZW50IGJsb2NrIGZvcm1hdHMKICoKICogQENNRl9CQVNJQzogICAgICB0cmFkaXRpb25hbCBjaGFubmVsIG1lYXN1cmVtZW50IGJsb2NrcyBzdXBwb3J0ZWQKICogCQkgICAgYnkgYWxsIG1hY2hpbmVzIHRoYXQgd2UgcnVuIG9uCiAqIEBDTUZfRVhURU5ERUQ6ICAgaW1wcm92ZWQgZm9ybWF0IHRoYXQgd2FzIGludHJvZHVjZWQgd2l0aCB0aGUgejk5MAogKiAJCSAgICBtYWNoaW5lCiAqIEBDTUZfQVVUT0RFVEVDVDogZGVmYXVsdDogdXNlIGV4dGVuZGVkIGZvcm1hdCB3aGVuIHJ1bm5pbmcgb24gYSB6OTkwCiAqICAgICAgICAgICAgICAgICAgb3IgbGF0ZXIgbWFjaGluZSwgb3RoZXJ3aXNlIGZhbGwgYmFjayB0byBiYXNpYyBmb3JtYXQKICoqLwplbnVtIGNtYl9mb3JtYXQgewoJQ01GX0JBU0lDLAoJQ01GX0VYVEVOREVELAoJQ01GX0FVVE9ERVRFQ1QgPSAtMSwKfTsKLyoqCiAqIGZvcm1hdCAtIGFjdHVhbCBmb3JtYXQgZm9yIGFsbCBtZWFzdXJlbWVudCBibG9ja3MKICoKICogVGhlIGZvcm1hdCBtb2R1bGUgcGFyYW1ldGVyIGNhbiBiZSBzZXQgdG8gYSB2YWx1ZSBvZiAwICh6ZXJvKQogKiBvciAxLCBpbmRpY2F0aW5nIGJhc2ljIG9yIGV4dGVuZGVkIGZvcm1hdCBhcyBkZXNjcmliZWQgZm9yCiAqIGVudW0gY21iX2Zvcm1hdC4KICovCnN0YXRpYyBpbnQgZm9ybWF0ID0gQ01GX0FVVE9ERVRFQ1Q7Cm1vZHVsZV9wYXJhbShmb3JtYXQsIGJvb2wsIDA0NDQpOwoKLyoqCiAqIHN0cnVjdCBjbWJfb3BlcmF0aW9ucyAtIGZ1bmN0aW9ucyB0byB1c2UgZGVwZW5kaW5nIG9uIGNtYl9mb3JtYXQKICoKICogTW9zdCBvZiB0aGVzZSBmdW5jdGlvbnMgb3BlcmF0ZSBvbiBhIHN0cnVjdCBjY3dfZGV2aWNlLiBUaGVyZSBpcyBvbmx5CiAqIG9uZSBpbnN0YW5jZSBvZiBzdHJ1Y3QgY21iX29wZXJhdGlvbnMgYmVjYXVzZSB0aGUgZm9ybWF0IG9mIHRoZSBtZWFzdXJlbWVudAogKiBkYXRhIGlzIGd1YXJhbnRlZWQgdG8gYmUgdGhlIHNhbWUgZm9yIGV2ZXJ5IGNjd19kZXZpY2UuCiAqCiAqIEBhbGxvYzoJYWxsb2NhdGUgbWVtb3J5IGZvciBhIGNoYW5uZWwgbWVhc3VyZW1lbnQgYmxvY2ssCiAqCQllaXRoZXIgd2l0aCB0aGUgaGVscCBvZiBhIHNwZWNpYWwgcG9vbCBvciB3aXRoIGttYWxsb2MKICogQGZyZWU6CWZyZWUgbWVtb3J5IGFsbG9jYXRlZCB3aXRoIEBhbGxvYwogKiBAc2V0OgllbmFibGUgb3IgZGlzYWJsZSBtZWFzdXJlbWVudAogKiBAcmVhZGFsbDoJcmVhZCBhIG1lYXN1cmVtZW50IGJsb2NrIGluIGEgY29tbW9uIGZvcm1hdAogKiBAcmVzZXQ6CWNsZWFyIHRoZSBkYXRhIGluIHRoZSBhc3NvY2lhdGVkIG1lYXN1cmVtZW50IGJsb2NrIGFuZAogKgkJcmVzZXQgaXRzIHRpbWUgc3RhbXAKICogQGFsaWduOglhbGlnbiBhbiBhbGxvY2F0ZWQgYmxvY2sgc28gdGhhdCB0aGUgaGFyZHdhcmUgY2FuIHVzZSBpdAogKi8Kc3RydWN0IGNtYl9vcGVyYXRpb25zIHsKCWludCAoKmFsbG9jKSAgKHN0cnVjdCBjY3dfZGV2aWNlKik7Cgl2b2lkKCpmcmVlKSAgIChzdHJ1Y3QgY2N3X2RldmljZSopOwoJaW50ICgqc2V0KSAgICAoc3RydWN0IGNjd19kZXZpY2UqLCB1MzIpOwoJdTY0ICgqcmVhZCkgICAoc3RydWN0IGNjd19kZXZpY2UqLCBpbnQpOwoJaW50ICgqcmVhZGFsbCkoc3RydWN0IGNjd19kZXZpY2UqLCBzdHJ1Y3QgY21iZGF0YSAqKTsKCXZvaWQgKCpyZXNldCkgKHN0cnVjdCBjY3dfZGV2aWNlKik7Cgl2b2lkICogKCphbGlnbikgKHZvaWQgKik7CgoJc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqYXR0cl9ncm91cDsKfTsKc3RhdGljIHN0cnVjdCBjbWJfb3BlcmF0aW9ucyAqY21ib3BzOwoKc3RydWN0IGNtYl9kYXRhIHsKCXZvaWQgKmh3X2Jsb2NrOyAgIC8qIFBvaW50ZXIgdG8gYmxvY2sgdXBkYXRlZCBieSBoYXJkd2FyZSAqLwoJdm9pZCAqbGFzdF9ibG9jazsgLyogTGFzdCBjaGFuZ2VkIGJsb2NrIGNvcGllZCBmcm9tIGhhcmR3YXJlIGJsb2NrICovCglpbnQgc2l6ZTsJICAvKiBTaXplIG9mIGh3X2Jsb2NrIGFuZCBsYXN0X2Jsb2NrICovCgl1bnNpZ25lZCBsb25nIGxvbmcgbGFzdF91cGRhdGU7ICAvKiB3aGVuIGxhc3RfYmxvY2sgd2FzIHVwZGF0ZWQgKi8KfTsKCi8qIG91ciB1c2VyIGludGVyZmFjZSBpcyBkZXNpZ25lZCBpbiB0ZXJtcyBvZiBuYW5vc2Vjb25kcywKICogd2hpbGUgdGhlIGhhcmR3YXJlIG1lYXN1cmVzIHRvdGFsIHRpbWVzIGluIGl0cyBvd24KICogdW5pdC4qLwpzdGF0aWMgaW5saW5lIHU2NCB0aW1lX3RvX25zZWModTMyIHZhbHVlKQp7CglyZXR1cm4gKCh1NjQpdmFsdWUpICogMTI4MDAwdWxsOwp9CgovKgogKiBVc2VycyBhcmUgdXN1YWxseSBpbnRlcmVzdGVkIGluIGF2ZXJhZ2UgdGltZXMsCiAqIG5vdCBhY2N1bXVsYXRlZCB0aW1lLgogKiBUaGlzIGFsc28gaGVscHMgdXMgd2l0aCBhdG9taWNpdHkgcHJvYmxlbXMKICogd2hlbiByZWFkaW5nIHNpbmxnZSB2YWx1ZXMuCiAqLwpzdGF0aWMgaW5saW5lIHU2NCB0aW1lX3RvX2F2Z19uc2VjKHUzMiB2YWx1ZSwgdTMyIGNvdW50KQp7Cgl1NjQgcmV0OwoKCS8qIG5vIHNhbXBsZXMgeWV0LCBhdm9pZCBkaXZpc2lvbiBieSAwICovCglpZiAoY291bnQgPT0gMCkKCQlyZXR1cm4gMDsKCgkvKiB2YWx1ZSBjb21lcyBpbiB1bml0cyBvZiAxMjggtXNlYyAqLwoJcmV0ID0gdGltZV90b19uc2VjKHZhbHVlKTsKCWRvX2RpdihyZXQsIGNvdW50KTsKCglyZXR1cm4gcmV0Owp9CgovKiBhY3RpdmF0ZSBvciBkZWFjdGl2YXRlIHRoZSBjaGFubmVsIG1vbml0b3IuIFdoZW4gYXJlYSBpcyBOVUxMLAogKiB0aGUgbW9uaXRvciBpcyBkZWFjdGl2YXRlZC4gVGhlIGNoYW5uZWwgbW9uaXRvciBuZWVkcyB0bwogKiBiZSBhY3RpdmUgaW4gb3JkZXIgdG8gbWVhc3VyZSBzdWJjaGFubmVscywgd2hpY2ggYWxzbyBuZWVkCiAqIHRvIGJlIGVuYWJsZWQuICovCnN0YXRpYyBpbmxpbmUgdm9pZApjbWZfYWN0aXZhdGUodm9pZCAqYXJlYSwgdW5zaWduZWQgaW50IG9ub2ZmKQp7CglyZWdpc3RlciB2b2lkICogX19ncHIyIGFzbSgiMiIpOwoJcmVnaXN0ZXIgbG9uZyBfX2dwcjEgYXNtKCIxIik7CgoJX19ncHIyID0gYXJlYTsKCV9fZ3ByMSA9IG9ub2ZmID8gMiA6IDA7CgkvKiBhY3RpdmF0ZSBjaGFubmVsIG1lYXN1cmVtZW50ICovCglhc20oInNjaG0iIDogOiAiZCIgKF9fZ3ByMiksICJkIiAoX19ncHIxKSApOwp9CgpzdGF0aWMgaW50CnNldF9zY2hpYihzdHJ1Y3QgY2N3X2RldmljZSAqY2RldiwgdTMyIG1tZSwgaW50IG1iZmMsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcykKewoJaW50IHJldDsKCWludCByZXRyeTsKCXN0cnVjdCBzdWJjaGFubmVsICpzY2g7CglzdHJ1Y3Qgc2NoaWIgKnNjaGliOwoKCXNjaCA9IHRvX3N1YmNoYW5uZWwoY2Rldi0+ZGV2LnBhcmVudCk7CglzY2hpYiA9ICZzY2gtPnNjaGliOwoJLyogbXNjaCBjYW4gc2lsZW50bHkgZmFpbCwgc28gZG8gaXQgYWdhaW4gaWYgbmVjZXNzYXJ5ICovCglmb3IgKHJldHJ5ID0gMDsgcmV0cnkgPCAzOyByZXRyeSsrKSB7CgkJLyogcHJlcGFyZSBzY2hpYiAqLwoJCXN0c2NoKHNjaC0+c2NoaWQsIHNjaGliKTsKCQlzY2hpYi0+cG1jdy5tbWUgID0gbW1lOwoJCXNjaGliLT5wbWN3Lm1iZmMgPSBtYmZjOwoJCS8qIGFkZHJlc3MgY2FuIGJlIGVpdGhlciBhIGJsb2NrIGFkZHJlc3Mgb3IgYSBibG9jayBpbmRleCAqLwoJCWlmIChtYmZjKQoJCQlzY2hpYi0+bWJhID0gYWRkcmVzczsKCQllbHNlCgkJCXNjaGliLT5wbWN3Lm1iaSA9IGFkZHJlc3M7CgoJCS8qIHRyeSB0byBzdWJtaXQgaXQgKi8KCQlzd2l0Y2gocmV0ID0gbXNjaF9lcnIoc2NoLT5zY2hpZCwgc2NoaWIpKSB7CgkJCWNhc2UgMDoKCQkJCWJyZWFrOwoJCQljYXNlIDE6CgkJCWNhc2UgMjogLyogaW4gSS9PIG9yIHN0YXR1cyBwZW5kaW5nICovCgkJCQlyZXQgPSAtRUJVU1k7CgkJCQlicmVhazsKCQkJY2FzZSAzOiAvKiBzdWJjaGFubmVsIGlzIG5vIGxvbmdlciB2YWxpZCAqLwoJCQkJcmV0ID0gLUVOT0RFVjsKCQkJCWJyZWFrOwoJCQlkZWZhdWx0OiAvKiBtc2NoIGNhdWdodCBhbiBleGNlcHRpb24gKi8KCQkJCXJldCA9IC1FSU5WQUw7CgkJCQlicmVhazsKCQl9CgkJc3RzY2goc2NoLT5zY2hpZCwgc2NoaWIpOyAvKiByZXN0b3JlIHRoZSBzY2hpYiAqLwoKCQlpZiAocmV0KQoJCQlicmVhazsKCgkJLyogY2hlY2sgaWYgaXQgd29ya2VkICovCgkJaWYgKHNjaGliLT5wbWN3Lm1tZSAgPT0gbW1lICYmCgkJICAgIHNjaGliLT5wbWN3Lm1iZmMgPT0gbWJmYyAmJgoJCSAgICAobWJmYyA/IChzY2hpYi0+bWJhID09IGFkZHJlc3MpCgkJCSAgOiAoc2NoaWItPnBtY3cubWJpID09IGFkZHJlc3MpKSkKCQkJcmV0dXJuIDA7CgoJCXJldCA9IC1FSU5WQUw7Cgl9CgoJcmV0dXJuIHJldDsKfQoKc3RydWN0IHNldF9zY2hpYl9zdHJ1Y3QgewoJdTMyIG1tZTsKCWludCBtYmZjOwoJdW5zaWduZWQgbG9uZyBhZGRyZXNzOwoJd2FpdF9xdWV1ZV9oZWFkX3Qgd2FpdDsKCWludCByZXQ7CglzdHJ1Y3Qga3JlZiBrcmVmOwp9OwoKc3RhdGljIHZvaWQgY21mX3NldF9zY2hpYl9yZWxlYXNlKHN0cnVjdCBrcmVmICprcmVmKQp7CglzdHJ1Y3Qgc2V0X3NjaGliX3N0cnVjdCAqc2V0X2RhdGE7CgoJc2V0X2RhdGEgPSBjb250YWluZXJfb2Yoa3JlZiwgc3RydWN0IHNldF9zY2hpYl9zdHJ1Y3QsIGtyZWYpOwoJa2ZyZWUoc2V0X2RhdGEpOwp9CgojZGVmaW5lIENNRl9QRU5ESU5HIDEKCnN0YXRpYyBpbnQgc2V0X3NjaGliX3dhaXQoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYsIHUzMiBtbWUsCgkJCQlpbnQgbWJmYywgdW5zaWduZWQgbG9uZyBhZGRyZXNzKQp7CglzdHJ1Y3Qgc2V0X3NjaGliX3N0cnVjdCAqc2V0X2RhdGE7CglpbnQgcmV0OwoKCXNwaW5fbG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7CglpZiAoIWNkZXYtPnByaXZhdGUtPmNtYikgewoJCXJldCA9IC1FTk9ERVY7CgkJZ290byBvdXQ7Cgl9CglzZXRfZGF0YSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzZXRfc2NoaWJfc3RydWN0KSwgR0ZQX0FUT01JQyk7CglpZiAoIXNldF9kYXRhKSB7CgkJcmV0ID0gLUVOT01FTTsKCQlnb3RvIG91dDsKCX0KCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnNldF9kYXRhLT53YWl0KTsKCWtyZWZfaW5pdCgmc2V0X2RhdGEtPmtyZWYpOwoJc2V0X2RhdGEtPm1tZSA9IG1tZTsKCXNldF9kYXRhLT5tYmZjID0gbWJmYzsKCXNldF9kYXRhLT5hZGRyZXNzID0gYWRkcmVzczsKCglyZXQgPSBzZXRfc2NoaWIoY2RldiwgbW1lLCBtYmZjLCBhZGRyZXNzKTsKCWlmIChyZXQgIT0gLUVCVVNZKQoJCWdvdG8gb3V0X3B1dDsKCglpZiAoY2Rldi0+cHJpdmF0ZS0+c3RhdGUgIT0gREVWX1NUQVRFX09OTElORSkgewoJCS8qIGlmIHRoZSBkZXZpY2UgaXMgbm90IG9ubGluZSwgZG9uJ3QgZXZlbiB0cnkgYWdhaW4gKi8KCQlyZXQgPSAtRUJVU1k7CgkJZ290byBvdXRfcHV0OwoJfQoKCWNkZXYtPnByaXZhdGUtPnN0YXRlID0gREVWX1NUQVRFX0NNRkNIQU5HRTsKCXNldF9kYXRhLT5yZXQgPSBDTUZfUEVORElORzsKCWNkZXYtPnByaXZhdGUtPmNtYl93YWl0ID0gc2V0X2RhdGE7CgoJc3Bpbl91bmxvY2tfaXJxKGNkZXYtPmNjd2xvY2spOwoJaWYgKHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShzZXRfZGF0YS0+d2FpdCwKCQkJCSAgICAgc2V0X2RhdGEtPnJldCAhPSBDTUZfUEVORElORykpIHsKCQlzcGluX2xvY2tfaXJxKGNkZXYtPmNjd2xvY2spOwoJCWlmIChzZXRfZGF0YS0+cmV0ID09IENNRl9QRU5ESU5HKSB7CgkJCXNldF9kYXRhLT5yZXQgPSAtRVJFU1RBUlRTWVM7CgkJCWlmIChjZGV2LT5wcml2YXRlLT5zdGF0ZSA9PSBERVZfU1RBVEVfQ01GQ0hBTkdFKQoJCQkJY2Rldi0+cHJpdmF0ZS0+c3RhdGUgPSBERVZfU1RBVEVfT05MSU5FOwoJCX0KCQlzcGluX3VubG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7Cgl9CglzcGluX2xvY2tfaXJxKGNkZXYtPmNjd2xvY2spOwoJY2Rldi0+cHJpdmF0ZS0+Y21iX3dhaXQgPSBOVUxMOwoJcmV0ID0gc2V0X2RhdGEtPnJldDsKb3V0X3B1dDoKCWtyZWZfcHV0KCZzZXRfZGF0YS0+a3JlZiwgY21mX3NldF9zY2hpYl9yZWxlYXNlKTsKb3V0OgoJc3Bpbl91bmxvY2tfaXJxKGNkZXYtPmNjd2xvY2spOwoJcmV0dXJuIHJldDsKfQoKdm9pZCByZXRyeV9zZXRfc2NoaWIoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYpCnsKCXN0cnVjdCBzZXRfc2NoaWJfc3RydWN0ICpzZXRfZGF0YTsKCglzZXRfZGF0YSA9IGNkZXYtPnByaXZhdGUtPmNtYl93YWl0OwoJaWYgKCFzZXRfZGF0YSkgewoJCVdBUk5fT04oMSk7CgkJcmV0dXJuOwoJfQoJa3JlZl9nZXQoJnNldF9kYXRhLT5rcmVmKTsKCXNldF9kYXRhLT5yZXQgPSBzZXRfc2NoaWIoY2Rldiwgc2V0X2RhdGEtPm1tZSwgc2V0X2RhdGEtPm1iZmMsCgkJCQkgIHNldF9kYXRhLT5hZGRyZXNzKTsKCXdha2VfdXAoJnNldF9kYXRhLT53YWl0KTsKCWtyZWZfcHV0KCZzZXRfZGF0YS0+a3JlZiwgY21mX3NldF9zY2hpYl9yZWxlYXNlKTsKfQoKc3RhdGljIGludCBjbWZfY29weV9ibG9jayhzdHJ1Y3QgY2N3X2RldmljZSAqY2RldikKewoJc3RydWN0IHN1YmNoYW5uZWwgKnNjaDsKCXZvaWQgKnJlZmVyZW5jZV9idWY7Cgl2b2lkICpod19ibG9jazsKCXN0cnVjdCBjbWJfZGF0YSAqY21iX2RhdGE7CgoJc2NoID0gdG9fc3ViY2hhbm5lbChjZGV2LT5kZXYucGFyZW50KTsKCglpZiAoc3RzY2goc2NoLT5zY2hpZCwgJnNjaC0+c2NoaWIpKQoJCXJldHVybiAtRU5PREVWOwoKCWlmIChzY2gtPnNjaGliLnNjc3cuZmN0bCAmIFNDU1dfRkNUTF9TVEFSVF9GVU5DKSB7CgkJLyogRG9uJ3QgY29weSBpZiBhIHN0YXJ0IGZ1bmN0aW9uIGlzIGluIHByb2dyZXNzLiAqLwoJCWlmICgoIXNjaC0+c2NoaWIuc2Nzdy5hY3RsICYgU0NTV19BQ1RMX1NVU1BFTkRFRCkgJiYKCQkgICAgKHNjaC0+c2NoaWIuc2Nzdy5hY3RsICYKCQkgICAgIChTQ1NXX0FDVExfREVWQUNUIHwgU0NTV19BQ1RMX1NDSEFDVCkpICYmCgkJICAgICghc2NoLT5zY2hpYi5zY3N3LnN0Y3RsICYgU0NTV19TVENUTF9TRUNfU1RBVFVTKSkKCQkJcmV0dXJuIC1FQlVTWTsKCX0KCWNtYl9kYXRhID0gY2Rldi0+cHJpdmF0ZS0+Y21iOwoJaHdfYmxvY2sgPSBjbWJvcHMtPmFsaWduKGNtYl9kYXRhLT5od19ibG9jayk7CglpZiAoIW1lbWNtcChjbWJfZGF0YS0+bGFzdF9ibG9jaywgaHdfYmxvY2ssIGNtYl9kYXRhLT5zaXplKSkKCQkvKiBObyBuZWVkIHRvIGNvcHkuICovCgkJcmV0dXJuIDA7CglyZWZlcmVuY2VfYnVmID0ga3phbGxvYyhjbWJfZGF0YS0+c2l6ZSwgR0ZQX0FUT01JQyk7CglpZiAoIXJlZmVyZW5jZV9idWYpCgkJcmV0dXJuIC1FTk9NRU07CgkvKiBFbnN1cmUgY29uc2lzdGVuY3kgb2YgYmxvY2sgY29waWVkIGZyb20gaGFyZHdhcmUuICovCglkbyB7CgkJbWVtY3B5KGNtYl9kYXRhLT5sYXN0X2Jsb2NrLCBod19ibG9jaywgY21iX2RhdGEtPnNpemUpOwoJCW1lbWNweShyZWZlcmVuY2VfYnVmLCBod19ibG9jaywgY21iX2RhdGEtPnNpemUpOwoJfSB3aGlsZSAobWVtY21wKGNtYl9kYXRhLT5sYXN0X2Jsb2NrLCByZWZlcmVuY2VfYnVmLCBjbWJfZGF0YS0+c2l6ZSkpOwoJY21iX2RhdGEtPmxhc3RfdXBkYXRlID0gZ2V0X2Nsb2NrKCk7CglrZnJlZShyZWZlcmVuY2VfYnVmKTsKCXJldHVybiAwOwp9CgpzdHJ1Y3QgY29weV9ibG9ja19zdHJ1Y3QgewoJd2FpdF9xdWV1ZV9oZWFkX3Qgd2FpdDsKCWludCByZXQ7CglzdHJ1Y3Qga3JlZiBrcmVmOwp9OwoKc3RhdGljIHZvaWQgY21mX2NvcHlfYmxvY2tfcmVsZWFzZShzdHJ1Y3Qga3JlZiAqa3JlZikKewoJc3RydWN0IGNvcHlfYmxvY2tfc3RydWN0ICpjb3B5X2Jsb2NrOwoKCWNvcHlfYmxvY2sgPSBjb250YWluZXJfb2Yoa3JlZiwgc3RydWN0IGNvcHlfYmxvY2tfc3RydWN0LCBrcmVmKTsKCWtmcmVlKGNvcHlfYmxvY2spOwp9CgpzdGF0aWMgaW50IGNtZl9jbWJfY29weV93YWl0KHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQp7CglzdHJ1Y3QgY29weV9ibG9ja19zdHJ1Y3QgKmNvcHlfYmxvY2s7CglpbnQgcmV0OwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglzcGluX2xvY2tfaXJxc2F2ZShjZGV2LT5jY3dsb2NrLCBmbGFncyk7CglpZiAoIWNkZXYtPnByaXZhdGUtPmNtYikgewoJCXJldCA9IC1FTk9ERVY7CgkJZ290byBvdXQ7Cgl9Cgljb3B5X2Jsb2NrID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGNvcHlfYmxvY2tfc3RydWN0KSwgR0ZQX0FUT01JQyk7CglpZiAoIWNvcHlfYmxvY2spIHsKCQlyZXQgPSAtRU5PTUVNOwoJCWdvdG8gb3V0OwoJfQoJaW5pdF93YWl0cXVldWVfaGVhZCgmY29weV9ibG9jay0+d2FpdCk7CglrcmVmX2luaXQoJmNvcHlfYmxvY2stPmtyZWYpOwoKCXJldCA9IGNtZl9jb3B5X2Jsb2NrKGNkZXYpOwoJaWYgKHJldCAhPSAtRUJVU1kpCgkJZ290byBvdXRfcHV0OwoKCWlmIChjZGV2LT5wcml2YXRlLT5zdGF0ZSAhPSBERVZfU1RBVEVfT05MSU5FKSB7CgkJcmV0ID0gLUVCVVNZOwoJCWdvdG8gb3V0X3B1dDsKCX0KCgljZGV2LT5wcml2YXRlLT5zdGF0ZSA9IERFVl9TVEFURV9DTUZVUERBVEU7Cgljb3B5X2Jsb2NrLT5yZXQgPSBDTUZfUEVORElORzsKCWNkZXYtPnByaXZhdGUtPmNtYl93YWl0ID0gY29weV9ibG9jazsKCglzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCWlmICh3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoY29weV9ibG9jay0+d2FpdCwKCQkJCSAgICAgY29weV9ibG9jay0+cmV0ICE9IENNRl9QRU5ESU5HKSkgewoJCXNwaW5fbG9ja19pcnFzYXZlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCQlpZiAoY29weV9ibG9jay0+cmV0ID09IENNRl9QRU5ESU5HKSB7CgkJCWNvcHlfYmxvY2stPnJldCA9IC1FUkVTVEFSVFNZUzsKCQkJaWYgKGNkZXYtPnByaXZhdGUtPnN0YXRlID09IERFVl9TVEFURV9DTUZVUERBVEUpCgkJCQljZGV2LT5wcml2YXRlLT5zdGF0ZSA9IERFVl9TVEFURV9PTkxJTkU7CgkJfQoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJfQoJc3Bpbl9sb2NrX2lycXNhdmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJY2Rldi0+cHJpdmF0ZS0+Y21iX3dhaXQgPSBOVUxMOwoJcmV0ID0gY29weV9ibG9jay0+cmV0OwpvdXRfcHV0OgoJa3JlZl9wdXQoJmNvcHlfYmxvY2stPmtyZWYsIGNtZl9jb3B5X2Jsb2NrX3JlbGVhc2UpOwpvdXQ6CglzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCXJldHVybiByZXQ7Cn0KCnZvaWQgY21mX3JldHJ5X2NvcHlfYmxvY2soc3RydWN0IGNjd19kZXZpY2UgKmNkZXYpCnsKCXN0cnVjdCBjb3B5X2Jsb2NrX3N0cnVjdCAqY29weV9ibG9jazsKCgljb3B5X2Jsb2NrID0gY2Rldi0+cHJpdmF0ZS0+Y21iX3dhaXQ7CglpZiAoIWNvcHlfYmxvY2spIHsKCQlXQVJOX09OKDEpOwoJCXJldHVybjsKCX0KCWtyZWZfZ2V0KCZjb3B5X2Jsb2NrLT5rcmVmKTsKCWNvcHlfYmxvY2stPnJldCA9IGNtZl9jb3B5X2Jsb2NrKGNkZXYpOwoJd2FrZV91cCgmY29weV9ibG9jay0+d2FpdCk7CglrcmVmX3B1dCgmY29weV9ibG9jay0+a3JlZiwgY21mX2NvcHlfYmxvY2tfcmVsZWFzZSk7Cn0KCnN0YXRpYyB2b2lkIGNtZl9nZW5lcmljX3Jlc2V0KHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQp7CglzdHJ1Y3QgY21iX2RhdGEgKmNtYl9kYXRhOwoKCXNwaW5fbG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7CgljbWJfZGF0YSA9IGNkZXYtPnByaXZhdGUtPmNtYjsKCWlmIChjbWJfZGF0YSkgewoJCW1lbXNldChjbWJfZGF0YS0+bGFzdF9ibG9jaywgMCwgY21iX2RhdGEtPnNpemUpOwoJCS8qCgkJICogTmVlZCB0byByZXNldCBodyBibG9jayBhcyB3ZWxsIHRvIG1ha2UgdGhlIGhhcmR3YXJlIHN0YXJ0CgkJICogZnJvbSAwIGFnYWluLgoJCSAqLwoJCW1lbXNldChjbWJvcHMtPmFsaWduKGNtYl9kYXRhLT5od19ibG9jayksIDAsIGNtYl9kYXRhLT5zaXplKTsKCQljbWJfZGF0YS0+bGFzdF91cGRhdGUgPSAwOwoJfQoJY2Rldi0+cHJpdmF0ZS0+Y21iX3N0YXJ0X3RpbWUgPSBnZXRfY2xvY2soKTsKCXNwaW5fdW5sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKfQoKLyoqCiAqIHN0cnVjdCBjbWJfYXJlYSAtIGNvbnRhaW5lciBmb3IgZ2xvYmFsIGNtYiBkYXRhCiAqCiAqIEBtZW06CXBvaW50ZXIgdG8gQ01CcyAob25seSBpbiBiYXNpYyBtZWFzdXJlbWVudCBtb2RlKQogKiBAbGlzdDoJY29udGFpbnMgYSBsaW5rZWQgbGlzdCBvZiBhbGwgc3ViY2hhbm5lbHMKICogQGxvY2s6CXByb3RlY3QgY29uY3VycmVudCBhY2Nlc3MgdG8gQG1lbSBhbmQgQGxpc3QKICovCnN0cnVjdCBjbWJfYXJlYSB7CglzdHJ1Y3QgY21iICptZW07CglzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CglpbnQgbnVtX2NoYW5uZWxzOwoJc3BpbmxvY2tfdCBsb2NrOwp9OwoKc3RhdGljIHN0cnVjdCBjbWJfYXJlYSBjbWJfYXJlYSA9IHsKCS5sb2NrID0gU1BJTl9MT0NLX1VOTE9DS0VELAoJLmxpc3QgPSBMSVNUX0hFQURfSU5JVChjbWJfYXJlYS5saXN0KSwKCS5udW1fY2hhbm5lbHMgID0gMTAyNCwKfTsKCgwKLyogKioqKioqIG9sZCBzdHlsZSBDTUIgaGFuZGxpbmcgKioqKioqKiovCgovKiogaW50IG1heGNoYW5uZWxzCiAqCiAqIEJhc2ljIGNoYW5uZWwgbWVhc3VyZW1lbnQgYmxvY2tzIGFyZSBhbGxvY2F0ZWQgaW4gb25lIGNvbnRpZ3VvdXMKICogYmxvY2sgb2YgbWVtb3J5LCB3aGljaCBjYW4gbm90IGJlIG1vdmVkIGFzIGxvbmcgYXMgYW55IGNoYW5uZWwKICogaXMgYWN0aXZlLiBUaGVyZWZvcmUsIGEgbWF4aW11bSBudW1iZXIgb2Ygc3ViY2hhbm5lbHMgbmVlZHMgdG8KICogYmUgZGVmaW5lZCBzb21ld2hlcmUuIFRoaXMgaXMgYSBtb2R1bGUgcGFyYW1ldGVyLCBkZWZhdWx0aW5nIHRvCiAqIGEgcmVzb25hYmxlIHZhbHVlIG9mIDEwMjQsIG9yIDMyIGtiIG9mIG1lbW9yeS4KICogQ3VycmVudCBrZXJuZWxzIGRvbid0IGFsbG93IGttYWxsb2Mgd2l0aCBtb3JlIHRoYW4gMTI4a2IsIHNvIHRoZQogKiBtYXhpbXVtIGlzIDQwOTYKICovCgptb2R1bGVfcGFyYW1fbmFtZWQobWF4Y2hhbm5lbHMsIGNtYl9hcmVhLm51bV9jaGFubmVscywgdWludCwgMDQ0NCk7CgovKioKICogc3RydWN0IGNtYiAtIGJhc2ljIGNoYW5uZWwgbWVhc3VyZW1lbnQgYmxvY2sKICoKICogY21iIGFzIHVzZWQgYnkgdGhlIGhhcmR3YXJlIHRoZSBmaWVsZHMgYXJlIGRlc2NyaWJlZCBpbiB6L0FyY2hpdGVjdHVyZQogKiBQcmluY2lwbGVzIG9mIE9wZXJhdGlvbiwgY2hhcHRlciAxNy4KICogVGhlIGFyZWEgdG8gYmUgYSBjb250aWd1b3VzIGFycmF5IGFuZCBtYXkgbm90IGJlIHJlYWxsb2NhdGVkIG9yIGZyZWVkLgogKiBPbmx5IG9uZSBjbWIgYXJlYSBjYW4gYmUgcHJlc2VudCBpbiB0aGUgc3lzdGVtLgogKi8Kc3RydWN0IGNtYiB7Cgl1MTYgc3NjaF9yc2NoX2NvdW50OwoJdTE2IHNhbXBsZV9jb3VudDsKCXUzMiBkZXZpY2VfY29ubmVjdF90aW1lOwoJdTMyIGZ1bmN0aW9uX3BlbmRpbmdfdGltZTsKCXUzMiBkZXZpY2VfZGlzY29ubmVjdF90aW1lOwoJdTMyIGNvbnRyb2xfdW5pdF9xdWV1aW5nX3RpbWU7Cgl1MzIgZGV2aWNlX2FjdGl2ZV9vbmx5X3RpbWU7Cgl1MzIgcmVzZXJ2ZWRbMl07Cn07CgovKiBpbnNlcnQgYSBzaW5nbGUgZGV2aWNlIGludG8gdGhlIGNtYl9hcmVhIGxpc3QKICogY2FsbGVkIHdpdGggY21iX2FyZWEubG9jayBoZWxkIGZyb20gYWxsb2NfY21iCiAqLwpzdGF0aWMgaW5saW5lIGludCBhbGxvY19jbWJfc2luZ2xlIChzdHJ1Y3QgY2N3X2RldmljZSAqY2RldiwKCQkJCSAgICBzdHJ1Y3QgY21iX2RhdGEgKmNtYl9kYXRhKQp7CglzdHJ1Y3QgY21iICpjbWI7CglzdHJ1Y3QgY2N3X2RldmljZV9wcml2YXRlICpub2RlOwoJaW50IHJldDsKCglzcGluX2xvY2tfaXJxKGNkZXYtPmNjd2xvY2spOwoJaWYgKCFsaXN0X2VtcHR5KCZjZGV2LT5wcml2YXRlLT5jbWJfbGlzdCkpIHsKCQlyZXQgPSAtRUJVU1k7CgkJZ290byBvdXQ7Cgl9CgoJLyogZmluZCBmaXJzdCB1bnVzZWQgY21iIGluIGNtYl9hcmVhLm1lbS4KCSAqIHRoaXMgaXMgYSBsaXR0bGUgdHJpY2t5OiBjbWJfYXJlYS5saXN0CgkgKiByZW1haW5zIHNvcnRlZCBieSAtPmNtYi0+aHdfZGF0YSBwb2ludGVycyAqLwoJY21iID0gY21iX2FyZWEubWVtOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShub2RlLCAmY21iX2FyZWEubGlzdCwgY21iX2xpc3QpIHsKCQlzdHJ1Y3QgY21iX2RhdGEgKmRhdGE7CgkJZGF0YSA9IG5vZGUtPmNtYjsKCQlpZiAoKHN0cnVjdCBjbWIqKWRhdGEtPmh3X2Jsb2NrID4gY21iKQoJCQlicmVhazsKCQljbWIrKzsKCX0KCWlmIChjbWIgLSBjbWJfYXJlYS5tZW0gPj0gY21iX2FyZWEubnVtX2NoYW5uZWxzKSB7CgkJcmV0ID0gLUVOT01FTTsKCQlnb3RvIG91dDsKCX0KCgkvKiBpbnNlcnQgbmV3IGNtYiAqLwoJbGlzdF9hZGRfdGFpbCgmY2Rldi0+cHJpdmF0ZS0+Y21iX2xpc3QsICZub2RlLT5jbWJfbGlzdCk7CgljbWJfZGF0YS0+aHdfYmxvY2sgPSBjbWI7CgljZGV2LT5wcml2YXRlLT5jbWIgPSBjbWJfZGF0YTsKCXJldCA9IDA7Cm91dDoKCXNwaW5fdW5sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQKYWxsb2NfY21iIChzdHJ1Y3QgY2N3X2RldmljZSAqY2RldikKewoJaW50IHJldDsKCXN0cnVjdCBjbWIgKm1lbTsKCXNzaXplX3Qgc2l6ZTsKCXN0cnVjdCBjbWJfZGF0YSAqY21iX2RhdGE7CgoJLyogQWxsb2NhdGUgcHJpdmF0ZSBjbWJfZGF0YS4gKi8KCWNtYl9kYXRhID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGNtYl9kYXRhKSwgR0ZQX0tFUk5FTCk7CglpZiAoIWNtYl9kYXRhKQoJCXJldHVybiAtRU5PTUVNOwoKCWNtYl9kYXRhLT5sYXN0X2Jsb2NrID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGNtYiksIEdGUF9LRVJORUwpOwoJaWYgKCFjbWJfZGF0YS0+bGFzdF9ibG9jaykgewoJCWtmcmVlKGNtYl9kYXRhKTsKCQlyZXR1cm4gLUVOT01FTTsKCX0KCWNtYl9kYXRhLT5zaXplID0gc2l6ZW9mKHN0cnVjdCBjbWIpOwoJc3Bpbl9sb2NrKCZjbWJfYXJlYS5sb2NrKTsKCglpZiAoIWNtYl9hcmVhLm1lbSkgewoJCS8qIHRoZXJlIGlzIG5vIHVzZXIgeWV0LCBzbyB3ZSBuZWVkIGEgbmV3IGFyZWEgKi8KCQlzaXplID0gc2l6ZW9mKHN0cnVjdCBjbWIpICogY21iX2FyZWEubnVtX2NoYW5uZWxzOwoJCVdBUk5fT04oIWxpc3RfZW1wdHkoJmNtYl9hcmVhLmxpc3QpKTsKCgkJc3Bpbl91bmxvY2soJmNtYl9hcmVhLmxvY2spOwoJCW1lbSA9ICh2b2lkKilfX2dldF9mcmVlX3BhZ2VzKEdGUF9LRVJORUwgfCBHRlBfRE1BLAoJCQkJIGdldF9vcmRlcihzaXplKSk7CgkJc3Bpbl9sb2NrKCZjbWJfYXJlYS5sb2NrKTsKCgkJaWYgKGNtYl9hcmVhLm1lbSkgewoJCQkvKiBvaywgYW5vdGhlciB0aHJlYWQgd2FzIGZhc3RlciAqLwoJCQlmcmVlX3BhZ2VzKCh1bnNpZ25lZCBsb25nKW1lbSwgZ2V0X29yZGVyKHNpemUpKTsKCQl9IGVsc2UgaWYgKCFtZW0pIHsKCQkJLyogbm8gbHVjayAqLwoJCQlyZXQgPSAtRU5PTUVNOwoJCQlnb3RvIG91dDsKCQl9IGVsc2UgewoJCQkvKiBldmVyeXRoaW5nIG9rICovCgkJCW1lbXNldChtZW0sIDAsIHNpemUpOwoJCQljbWJfYXJlYS5tZW0gPSBtZW07CgkJCWNtZl9hY3RpdmF0ZShjbWJfYXJlYS5tZW0sIDEpOwoJCX0KCX0KCgkvKiBkbyB0aGUgYWN0dWFsIGFsbG9jYXRpb24gKi8KCXJldCA9IGFsbG9jX2NtYl9zaW5nbGUoY2RldiwgY21iX2RhdGEpOwpvdXQ6CglzcGluX3VubG9jaygmY21iX2FyZWEubG9jayk7CglpZiAocmV0KSB7CgkJa2ZyZWUoY21iX2RhdGEtPmxhc3RfYmxvY2spOwoJCWtmcmVlKGNtYl9kYXRhKTsKCX0KCXJldHVybiByZXQ7Cn0KCnN0YXRpYyB2b2lkIGZyZWVfY21iKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQp7CglzdHJ1Y3QgY2N3X2RldmljZV9wcml2YXRlICpwcml2OwoJc3RydWN0IGNtYl9kYXRhICpjbWJfZGF0YTsKCglzcGluX2xvY2soJmNtYl9hcmVhLmxvY2spOwoJc3Bpbl9sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKCglwcml2ID0gY2Rldi0+cHJpdmF0ZTsKCglpZiAobGlzdF9lbXB0eSgmcHJpdi0+Y21iX2xpc3QpKSB7CgkJLyogYWxyZWFkeSBmcmVlZCAqLwoJCWdvdG8gb3V0OwoJfQoKCWNtYl9kYXRhID0gcHJpdi0+Y21iOwoJcHJpdi0+Y21iID0gTlVMTDsKCWlmIChjbWJfZGF0YSkKCQlrZnJlZShjbWJfZGF0YS0+bGFzdF9ibG9jayk7CglrZnJlZShjbWJfZGF0YSk7CglsaXN0X2RlbF9pbml0KCZwcml2LT5jbWJfbGlzdCk7CgoJaWYgKGxpc3RfZW1wdHkoJmNtYl9hcmVhLmxpc3QpKSB7CgkJc3NpemVfdCBzaXplOwoJCXNpemUgPSBzaXplb2Yoc3RydWN0IGNtYikgKiBjbWJfYXJlYS5udW1fY2hhbm5lbHM7CgkJY21mX2FjdGl2YXRlKE5VTEwsIDApOwoJCWZyZWVfcGFnZXMoKHVuc2lnbmVkIGxvbmcpY21iX2FyZWEubWVtLCBnZXRfb3JkZXIoc2l6ZSkpOwoJCWNtYl9hcmVhLm1lbSA9IE5VTEw7Cgl9Cm91dDoKCXNwaW5fdW5sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKCXNwaW5fdW5sb2NrKCZjbWJfYXJlYS5sb2NrKTsKfQoKc3RhdGljIGludCBzZXRfY21iKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2LCB1MzIgbW1lKQp7Cgl1MTYgb2Zmc2V0OwoJc3RydWN0IGNtYl9kYXRhICpjbWJfZGF0YTsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJaWYgKCFjZGV2LT5wcml2YXRlLT5jbWIpIHsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCWNtYl9kYXRhID0gY2Rldi0+cHJpdmF0ZS0+Y21iOwoJb2Zmc2V0ID0gbW1lID8gKHN0cnVjdCBjbWIgKiljbWJfZGF0YS0+aHdfYmxvY2sgLSBjbWJfYXJlYS5tZW0gOiAwOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShjZGV2LT5jY3dsb2NrLCBmbGFncyk7CgoJcmV0dXJuIHNldF9zY2hpYl93YWl0KGNkZXYsIG1tZSwgMCwgb2Zmc2V0KTsKfQoKc3RhdGljIHU2NCByZWFkX2NtYiAoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYsIGludCBpbmRleCkKewoJc3RydWN0IGNtYiAqY21iOwoJdTMyIHZhbDsKCWludCByZXQ7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCXJldCA9IGNtZl9jbWJfY29weV93YWl0KGNkZXYpOwoJaWYgKHJldCA8IDApCgkJcmV0dXJuIDA7CgoJc3Bpbl9sb2NrX2lycXNhdmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJaWYgKCFjZGV2LT5wcml2YXRlLT5jbWIpIHsKCQlyZXQgPSAwOwoJCWdvdG8gb3V0OwoJfQoJY21iID0gKChzdHJ1Y3QgY21iX2RhdGEgKiljZGV2LT5wcml2YXRlLT5jbWIpLT5sYXN0X2Jsb2NrOwoKCXN3aXRjaCAoaW5kZXgpIHsKCWNhc2UgY21iX3NzY2hfcnNjaF9jb3VudDoKCQlyZXQgPSBjbWItPnNzY2hfcnNjaF9jb3VudDsKCQlnb3RvIG91dDsKCWNhc2UgY21iX3NhbXBsZV9jb3VudDoKCQlyZXQgPSBjbWItPnNhbXBsZV9jb3VudDsKCQlnb3RvIG91dDsKCWNhc2UgY21iX2RldmljZV9jb25uZWN0X3RpbWU6CgkJdmFsID0gY21iLT5kZXZpY2VfY29ubmVjdF90aW1lOwoJCWJyZWFrOwoJY2FzZSBjbWJfZnVuY3Rpb25fcGVuZGluZ190aW1lOgoJCXZhbCA9IGNtYi0+ZnVuY3Rpb25fcGVuZGluZ190aW1lOwoJCWJyZWFrOwoJY2FzZSBjbWJfZGV2aWNlX2Rpc2Nvbm5lY3RfdGltZToKCQl2YWwgPSBjbWItPmRldmljZV9kaXNjb25uZWN0X3RpbWU7CgkJYnJlYWs7CgljYXNlIGNtYl9jb250cm9sX3VuaXRfcXVldWluZ190aW1lOgoJCXZhbCA9IGNtYi0+Y29udHJvbF91bml0X3F1ZXVpbmdfdGltZTsKCQlicmVhazsKCWNhc2UgY21iX2RldmljZV9hY3RpdmVfb25seV90aW1lOgoJCXZhbCA9IGNtYi0+ZGV2aWNlX2FjdGl2ZV9vbmx5X3RpbWU7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXJldCA9IDA7CgkJZ290byBvdXQ7Cgl9CglyZXQgPSB0aW1lX3RvX2F2Z19uc2VjKHZhbCwgY21iLT5zYW1wbGVfY291bnQpOwpvdXQ6CglzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgcmVhZGFsbF9jbWIgKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2LCBzdHJ1Y3QgY21iZGF0YSAqZGF0YSkKewoJc3RydWN0IGNtYiAqY21iOwoJc3RydWN0IGNtYl9kYXRhICpjbWJfZGF0YTsKCXU2NCB0aW1lOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWludCByZXQ7CgoJcmV0ID0gY21mX2NtYl9jb3B5X3dhaXQoY2Rldik7CglpZiAocmV0IDwgMCkKCQlyZXR1cm4gcmV0OwoJc3Bpbl9sb2NrX2lycXNhdmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJY21iX2RhdGEgPSBjZGV2LT5wcml2YXRlLT5jbWI7CglpZiAoIWNtYl9kYXRhKSB7CgkJcmV0ID0gLUVOT0RFVjsKCQlnb3RvIG91dDsKCX0KCWlmIChjbWJfZGF0YS0+bGFzdF91cGRhdGUgPT0gMCkgewoJCXJldCA9IC1FQUdBSU47CgkJZ290byBvdXQ7Cgl9CgljbWIgPSBjbWJfZGF0YS0+bGFzdF9ibG9jazsKCXRpbWUgPSBjbWJfZGF0YS0+bGFzdF91cGRhdGUgLSBjZGV2LT5wcml2YXRlLT5jbWJfc3RhcnRfdGltZTsKCgltZW1zZXQoZGF0YSwgMCwgc2l6ZW9mKHN0cnVjdCBjbWJkYXRhKSk7CgoJLyogd2Ugb25seSBrbm93IHZhbHVlcyBiZWZvcmUgZGV2aWNlX2J1c3lfdGltZSAqLwoJZGF0YS0+c2l6ZSA9IG9mZnNldG9mKHN0cnVjdCBjbWJkYXRhLCBkZXZpY2VfYnVzeV90aW1lKTsKCgkvKiBjb252ZXJ0IHRvIG5hbm9zZWNvbmRzICovCglkYXRhLT5lbGFwc2VkX3RpbWUgPSAodGltZSAqIDEwMDApID4+IDEyOwoKCS8qIGNvcHkgZGF0YSB0byBuZXcgc3RydWN0dXJlICovCglkYXRhLT5zc2NoX3JzY2hfY291bnQgPSBjbWItPnNzY2hfcnNjaF9jb3VudDsKCWRhdGEtPnNhbXBsZV9jb3VudCA9IGNtYi0+c2FtcGxlX2NvdW50OwoKCS8qIHRpbWUgZmllbGRzIGFyZSBjb252ZXJ0ZWQgdG8gbmFub3NlY29uZHMgd2hpbGUgY29weWluZyAqLwoJZGF0YS0+ZGV2aWNlX2Nvbm5lY3RfdGltZSA9IHRpbWVfdG9fbnNlYyhjbWItPmRldmljZV9jb25uZWN0X3RpbWUpOwoJZGF0YS0+ZnVuY3Rpb25fcGVuZGluZ190aW1lID0gdGltZV90b19uc2VjKGNtYi0+ZnVuY3Rpb25fcGVuZGluZ190aW1lKTsKCWRhdGEtPmRldmljZV9kaXNjb25uZWN0X3RpbWUgPQoJCXRpbWVfdG9fbnNlYyhjbWItPmRldmljZV9kaXNjb25uZWN0X3RpbWUpOwoJZGF0YS0+Y29udHJvbF91bml0X3F1ZXVpbmdfdGltZQoJCT0gdGltZV90b19uc2VjKGNtYi0+Y29udHJvbF91bml0X3F1ZXVpbmdfdGltZSk7CglkYXRhLT5kZXZpY2VfYWN0aXZlX29ubHlfdGltZQoJCT0gdGltZV90b19uc2VjKGNtYi0+ZGV2aWNlX2FjdGl2ZV9vbmx5X3RpbWUpOwoJcmV0ID0gMDsKb3V0OgoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShjZGV2LT5jY3dsb2NrLCBmbGFncyk7CglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgdm9pZCByZXNldF9jbWIoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYpCnsKCWNtZl9nZW5lcmljX3Jlc2V0KGNkZXYpOwp9CgpzdGF0aWMgdm9pZCAqIGFsaWduX2NtYih2b2lkICphcmVhKQp7CglyZXR1cm4gYXJlYTsKfQoKc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgY21mX2F0dHJfZ3JvdXA7CgpzdGF0aWMgc3RydWN0IGNtYl9vcGVyYXRpb25zIGNtYm9wc19iYXNpYyA9IHsKCS5hbGxvYwk9IGFsbG9jX2NtYiwKCS5mcmVlCT0gZnJlZV9jbWIsCgkuc2V0CT0gc2V0X2NtYiwKCS5yZWFkCT0gcmVhZF9jbWIsCgkucmVhZGFsbCAgICA9IHJlYWRhbGxfY21iLAoJLnJlc2V0CSAgICA9IHJlc2V0X2NtYiwKCS5hbGlnbgkgICAgPSBhbGlnbl9jbWIsCgkuYXR0cl9ncm91cCA9ICZjbWZfYXR0cl9ncm91cCwKfTsKDAovKiAqKioqKioqKiBleHRlbmRlZCBjbWIgaGFuZGxpbmcgKioqKioqKiovCgovKioKICogc3RydWN0IGNtYmUgLSBleHRlbmRlZCBjaGFubmVsIG1lYXN1cmVtZW50IGJsb2NrCiAqCiAqIGNtYiBhcyB1c2VkIGJ5IHRoZSBoYXJkd2FyZSwgbWF5IGJlIGluIGFueSA2NCBiaXQgcGh5c2ljYWwgbG9jYXRpb24sCiAqIHRoZSBmaWVsZHMgYXJlIGRlc2NyaWJlZCBpbiB6L0FyY2hpdGVjdHVyZSBQcmluY2lwbGVzIG9mIE9wZXJhdGlvbiwKICogdGhpcmQgZWRpdGlvbiwgY2hhcHRlciAxNy4KICovCnN0cnVjdCBjbWJlIHsKCXUzMiBzc2NoX3JzY2hfY291bnQ7Cgl1MzIgc2FtcGxlX2NvdW50OwoJdTMyIGRldmljZV9jb25uZWN0X3RpbWU7Cgl1MzIgZnVuY3Rpb25fcGVuZGluZ190aW1lOwoJdTMyIGRldmljZV9kaXNjb25uZWN0X3RpbWU7Cgl1MzIgY29udHJvbF91bml0X3F1ZXVpbmdfdGltZTsKCXUzMiBkZXZpY2VfYWN0aXZlX29ubHlfdGltZTsKCXUzMiBkZXZpY2VfYnVzeV90aW1lOwoJdTMyIGluaXRpYWxfY29tbWFuZF9yZXNwb25zZV90aW1lOwoJdTMyIHJlc2VydmVkWzddOwp9OwoKLyoga21hbGxvYyBvbmx5IGd1YXJhbnRlZXMgOCBieXRlIGFsaWdubWVudCwgYnV0IHdlIG5lZWQgY21iZQogKiBwb2ludGVycyB0byBiZSBuYXR1cmFsbHkgYWxpZ25lZC4gTWFrZSBzdXJlIHRvIGFsbG9jYXRlCiAqIGVub3VnaCBzcGFjZSBmb3IgdHdvIGNtYmVzICovCnN0YXRpYyBpbmxpbmUgc3RydWN0IGNtYmUqIGNtYmVfYWxpZ24oc3RydWN0IGNtYmUgKmMpCnsKCXVuc2lnbmVkIGxvbmcgYWRkcjsKCWFkZHIgPSAoKHVuc2lnbmVkIGxvbmcpYyArIHNpemVvZiAoc3RydWN0IGNtYmUpIC0gc2l6ZW9mKGxvbmcpKSAmCgkJCQkgfihzaXplb2YgKHN0cnVjdCBjbWJlKSAtIHNpemVvZihsb25nKSk7CglyZXR1cm4gKHN0cnVjdCBjbWJlKilhZGRyOwp9CgpzdGF0aWMgaW50IGFsbG9jX2NtYmUgKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQp7CglzdHJ1Y3QgY21iZSAqY21iZTsKCXN0cnVjdCBjbWJfZGF0YSAqY21iX2RhdGE7CglpbnQgcmV0OwoKCWNtYmUgPSBremFsbG9jIChzaXplb2YgKCpjbWJlKSAqIDIsIEdGUF9LRVJORUwpOwoJaWYgKCFjbWJlKQoJCXJldHVybiAtRU5PTUVNOwoJY21iX2RhdGEgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgY21iX2RhdGEpLCBHRlBfS0VSTkVMKTsKCWlmICghY21iX2RhdGEpIHsKCQlyZXQgPSAtRU5PTUVNOwoJCWdvdG8gb3V0X2ZyZWU7Cgl9CgljbWJfZGF0YS0+bGFzdF9ibG9jayA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBjbWJlKSwgR0ZQX0tFUk5FTCk7CglpZiAoIWNtYl9kYXRhLT5sYXN0X2Jsb2NrKSB7CgkJcmV0ID0gLUVOT01FTTsKCQlnb3RvIG91dF9mcmVlOwoJfQoJY21iX2RhdGEtPnNpemUgPSBzaXplb2Yoc3RydWN0IGNtYmUpOwoJc3Bpbl9sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKCWlmIChjZGV2LT5wcml2YXRlLT5jbWIpIHsKCQlzcGluX3VubG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7CgkJcmV0ID0gLUVCVVNZOwoJCWdvdG8gb3V0X2ZyZWU7Cgl9CgljbWJfZGF0YS0+aHdfYmxvY2sgPSBjbWJlOwoJY2Rldi0+cHJpdmF0ZS0+Y21iID0gY21iX2RhdGE7CglzcGluX3VubG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7CgoJLyogYWN0aXZhdGUgZ2xvYmFsIG1lYXN1cmVtZW50IGlmIHRoaXMgaXMgdGhlIGZpcnN0IGNoYW5uZWwgKi8KCXNwaW5fbG9jaygmY21iX2FyZWEubG9jayk7CglpZiAobGlzdF9lbXB0eSgmY21iX2FyZWEubGlzdCkpCgkJY21mX2FjdGl2YXRlKE5VTEwsIDEpOwoJbGlzdF9hZGRfdGFpbCgmY2Rldi0+cHJpdmF0ZS0+Y21iX2xpc3QsICZjbWJfYXJlYS5saXN0KTsKCXNwaW5fdW5sb2NrKCZjbWJfYXJlYS5sb2NrKTsKCglyZXR1cm4gMDsKb3V0X2ZyZWU6CglpZiAoY21iX2RhdGEpCgkJa2ZyZWUoY21iX2RhdGEtPmxhc3RfYmxvY2spOwoJa2ZyZWUoY21iX2RhdGEpOwoJa2ZyZWUoY21iZSk7CglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgdm9pZCBmcmVlX2NtYmUgKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQp7CglzdHJ1Y3QgY21iX2RhdGEgKmNtYl9kYXRhOwoKCXNwaW5fbG9ja19pcnEoY2Rldi0+Y2N3bG9jayk7CgljbWJfZGF0YSA9IGNkZXYtPnByaXZhdGUtPmNtYjsKCWNkZXYtPnByaXZhdGUtPmNtYiA9IE5VTEw7CglpZiAoY21iX2RhdGEpCgkJa2ZyZWUoY21iX2RhdGEtPmxhc3RfYmxvY2spOwoJa2ZyZWUoY21iX2RhdGEpOwoJc3Bpbl91bmxvY2tfaXJxKGNkZXYtPmNjd2xvY2spOwoKCS8qIGRlYWN0aXZhdGUgZ2xvYmFsIG1lYXN1cmVtZW50IGlmIHRoaXMgaXMgdGhlIGxhc3QgY2hhbm5lbCAqLwoJc3Bpbl9sb2NrKCZjbWJfYXJlYS5sb2NrKTsKCWxpc3RfZGVsX2luaXQoJmNkZXYtPnByaXZhdGUtPmNtYl9saXN0KTsKCWlmIChsaXN0X2VtcHR5KCZjbWJfYXJlYS5saXN0KSkKCQljbWZfYWN0aXZhdGUoTlVMTCwgMCk7CglzcGluX3VubG9jaygmY21iX2FyZWEubG9jayk7Cn0KCnN0YXRpYyBpbnQgc2V0X2NtYmUoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYsIHUzMiBtbWUpCnsKCXVuc2lnbmVkIGxvbmcgbWJhOwoJc3RydWN0IGNtYl9kYXRhICpjbWJfZGF0YTsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJaWYgKCFjZGV2LT5wcml2YXRlLT5jbWIpIHsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCWNtYl9kYXRhID0gY2Rldi0+cHJpdmF0ZS0+Y21iOwoJbWJhID0gbW1lID8gKHVuc2lnbmVkIGxvbmcpIGNtYmVfYWxpZ24oY21iX2RhdGEtPmh3X2Jsb2NrKSA6IDA7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCglyZXR1cm4gc2V0X3NjaGliX3dhaXQoY2RldiwgbW1lLCAxLCBtYmEpOwp9CgoKc3RhdGljIHU2NCByZWFkX2NtYmUgKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2LCBpbnQgaW5kZXgpCnsKCXN0cnVjdCBjbWJlICpjbWI7CglzdHJ1Y3QgY21iX2RhdGEgKmNtYl9kYXRhOwoJdTMyIHZhbDsKCWludCByZXQ7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCXJldCA9IGNtZl9jbWJfY29weV93YWl0KGNkZXYpOwoJaWYgKHJldCA8IDApCgkJcmV0dXJuIDA7CgoJc3Bpbl9sb2NrX2lycXNhdmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJY21iX2RhdGEgPSBjZGV2LT5wcml2YXRlLT5jbWI7CglpZiAoIWNtYl9kYXRhKSB7CgkJcmV0ID0gMDsKCQlnb3RvIG91dDsKCX0KCWNtYiA9IGNtYl9kYXRhLT5sYXN0X2Jsb2NrOwoKCXN3aXRjaCAoaW5kZXgpIHsKCWNhc2UgY21iX3NzY2hfcnNjaF9jb3VudDoKCQlyZXQgPSBjbWItPnNzY2hfcnNjaF9jb3VudDsKCQlnb3RvIG91dDsKCWNhc2UgY21iX3NhbXBsZV9jb3VudDoKCQlyZXQgPSBjbWItPnNhbXBsZV9jb3VudDsKCQlnb3RvIG91dDsKCWNhc2UgY21iX2RldmljZV9jb25uZWN0X3RpbWU6CgkJdmFsID0gY21iLT5kZXZpY2VfY29ubmVjdF90aW1lOwoJCWJyZWFrOwoJY2FzZSBjbWJfZnVuY3Rpb25fcGVuZGluZ190aW1lOgoJCXZhbCA9IGNtYi0+ZnVuY3Rpb25fcGVuZGluZ190aW1lOwoJCWJyZWFrOwoJY2FzZSBjbWJfZGV2aWNlX2Rpc2Nvbm5lY3RfdGltZToKCQl2YWwgPSBjbWItPmRldmljZV9kaXNjb25uZWN0X3RpbWU7CgkJYnJlYWs7CgljYXNlIGNtYl9jb250cm9sX3VuaXRfcXVldWluZ190aW1lOgoJCXZhbCA9IGNtYi0+Y29udHJvbF91bml0X3F1ZXVpbmdfdGltZTsKCQlicmVhazsKCWNhc2UgY21iX2RldmljZV9hY3RpdmVfb25seV90aW1lOgoJCXZhbCA9IGNtYi0+ZGV2aWNlX2FjdGl2ZV9vbmx5X3RpbWU7CgkJYnJlYWs7CgljYXNlIGNtYl9kZXZpY2VfYnVzeV90aW1lOgoJCXZhbCA9IGNtYi0+ZGV2aWNlX2J1c3lfdGltZTsKCQlicmVhazsKCWNhc2UgY21iX2luaXRpYWxfY29tbWFuZF9yZXNwb25zZV90aW1lOgoJCXZhbCA9IGNtYi0+aW5pdGlhbF9jb21tYW5kX3Jlc3BvbnNlX3RpbWU7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXJldCA9IDA7CgkJZ290byBvdXQ7Cgl9CglyZXQgPSB0aW1lX3RvX2F2Z19uc2VjKHZhbCwgY21iLT5zYW1wbGVfY291bnQpOwpvdXQ6CglzcGluX3VubG9ja19pcnFyZXN0b3JlKGNkZXYtPmNjd2xvY2ssIGZsYWdzKTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgcmVhZGFsbF9jbWJlIChzdHJ1Y3QgY2N3X2RldmljZSAqY2Rldiwgc3RydWN0IGNtYmRhdGEgKmRhdGEpCnsKCXN0cnVjdCBjbWJlICpjbWI7CglzdHJ1Y3QgY21iX2RhdGEgKmNtYl9kYXRhOwoJdTY0IHRpbWU7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJaW50IHJldDsKCglyZXQgPSBjbWZfY21iX2NvcHlfd2FpdChjZGV2KTsKCWlmIChyZXQgPCAwKQoJCXJldHVybiByZXQ7CglzcGluX2xvY2tfaXJxc2F2ZShjZGV2LT5jY3dsb2NrLCBmbGFncyk7CgljbWJfZGF0YSA9IGNkZXYtPnByaXZhdGUtPmNtYjsKCWlmICghY21iX2RhdGEpIHsKCQlyZXQgPSAtRU5PREVWOwoJCWdvdG8gb3V0OwoJfQoJaWYgKGNtYl9kYXRhLT5sYXN0X3VwZGF0ZSA9PSAwKSB7CgkJcmV0ID0gLUVBR0FJTjsKCQlnb3RvIG91dDsKCX0KCXRpbWUgPSBjbWJfZGF0YS0+bGFzdF91cGRhdGUgLSBjZGV2LT5wcml2YXRlLT5jbWJfc3RhcnRfdGltZTsKCgltZW1zZXQgKGRhdGEsIDAsIHNpemVvZihzdHJ1Y3QgY21iZGF0YSkpOwoKCS8qIHdlIG9ubHkga25vdyB2YWx1ZXMgYmVmb3JlIGRldmljZV9idXN5X3RpbWUgKi8KCWRhdGEtPnNpemUgPSBvZmZzZXRvZihzdHJ1Y3QgY21iZGF0YSwgZGV2aWNlX2J1c3lfdGltZSk7CgoJLyogY29udmVyIHRvIG5hbm9zZWNvbmRzICovCglkYXRhLT5lbGFwc2VkX3RpbWUgPSAodGltZSAqIDEwMDApID4+IDEyOwoKCWNtYiA9IGNtYl9kYXRhLT5sYXN0X2Jsb2NrOwoJLyogY29weSBkYXRhIHRvIG5ldyBzdHJ1Y3R1cmUgKi8KCWRhdGEtPnNzY2hfcnNjaF9jb3VudCA9IGNtYi0+c3NjaF9yc2NoX2NvdW50OwoJZGF0YS0+c2FtcGxlX2NvdW50ID0gY21iLT5zYW1wbGVfY291bnQ7CgoJLyogdGltZSBmaWVsZHMgYXJlIGNvbnZlcnRlZCB0byBuYW5vc2Vjb25kcyB3aGlsZSBjb3B5aW5nICovCglkYXRhLT5kZXZpY2VfY29ubmVjdF90aW1lID0gdGltZV90b19uc2VjKGNtYi0+ZGV2aWNlX2Nvbm5lY3RfdGltZSk7CglkYXRhLT5mdW5jdGlvbl9wZW5kaW5nX3RpbWUgPSB0aW1lX3RvX25zZWMoY21iLT5mdW5jdGlvbl9wZW5kaW5nX3RpbWUpOwoJZGF0YS0+ZGV2aWNlX2Rpc2Nvbm5lY3RfdGltZSA9CgkJdGltZV90b19uc2VjKGNtYi0+ZGV2aWNlX2Rpc2Nvbm5lY3RfdGltZSk7CglkYXRhLT5jb250cm9sX3VuaXRfcXVldWluZ190aW1lCgkJPSB0aW1lX3RvX25zZWMoY21iLT5jb250cm9sX3VuaXRfcXVldWluZ190aW1lKTsKCWRhdGEtPmRldmljZV9hY3RpdmVfb25seV90aW1lCgkJPSB0aW1lX3RvX25zZWMoY21iLT5kZXZpY2VfYWN0aXZlX29ubHlfdGltZSk7CglkYXRhLT5kZXZpY2VfYnVzeV90aW1lID0gdGltZV90b19uc2VjKGNtYi0+ZGV2aWNlX2J1c3lfdGltZSk7CglkYXRhLT5pbml0aWFsX2NvbW1hbmRfcmVzcG9uc2VfdGltZQoJCT0gdGltZV90b19uc2VjKGNtYi0+aW5pdGlhbF9jb21tYW5kX3Jlc3BvbnNlX3RpbWUpOwoKCXJldCA9IDA7Cm91dDoKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoY2Rldi0+Y2N3bG9jaywgZmxhZ3MpOwoJcmV0dXJuIHJldDsKfQoKc3RhdGljIHZvaWQgcmVzZXRfY21iZShzdHJ1Y3QgY2N3X2RldmljZSAqY2RldikKewoJY21mX2dlbmVyaWNfcmVzZXQoY2Rldik7Cn0KCnN0YXRpYyB2b2lkICogYWxpZ25fY21iZSh2b2lkICphcmVhKQp7CglyZXR1cm4gY21iZV9hbGlnbihhcmVhKTsKfQoKc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgY21mX2F0dHJfZ3JvdXBfZXh0OwoKc3RhdGljIHN0cnVjdCBjbWJfb3BlcmF0aW9ucyBjbWJvcHNfZXh0ZW5kZWQgPSB7CgkuYWxsb2MJICAgID0gYWxsb2NfY21iZSwKCS5mcmVlCSAgICA9IGZyZWVfY21iZSwKCS5zZXQJICAgID0gc2V0X2NtYmUsCgkucmVhZAkgICAgPSByZWFkX2NtYmUsCgkucmVhZGFsbCAgICA9IHJlYWRhbGxfY21iZSwKCS5yZXNldAkgICAgPSByZXNldF9jbWJlLAoJLmFsaWduCSAgICA9IGFsaWduX2NtYmUsCgkuYXR0cl9ncm91cCA9ICZjbWZfYXR0cl9ncm91cF9leHQsCn07CgwKCnN0YXRpYyBzc2l6ZV90CmNtYl9zaG93X2F0dHIoc3RydWN0IGRldmljZSAqZGV2LCBjaGFyICpidWYsIGVudW0gY21iX2luZGV4IGlkeCkKewoJcmV0dXJuIHNwcmludGYoYnVmLCAiJWxsZFxuIiwKCQkodW5zaWduZWQgbG9uZyBsb25nKSBjbWZfcmVhZCh0b19jY3dkZXYoZGV2KSwgaWR4KSk7Cn0KCnN0YXRpYyBzc2l6ZV90CmNtYl9zaG93X2F2Z19zYW1wbGVfaW50ZXJ2YWwoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglzdHJ1Y3QgY2N3X2RldmljZSAqY2RldjsKCWxvbmcgaW50ZXJ2YWw7Cgl1bnNpZ25lZCBsb25nIGNvdW50OwoJc3RydWN0IGNtYl9kYXRhICpjbWJfZGF0YTsKCgljZGV2ID0gdG9fY2N3ZGV2KGRldik7Cgljb3VudCA9IGNtZl9yZWFkKGNkZXYsIGNtYl9zYW1wbGVfY291bnQpOwoJc3Bpbl9sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKCWNtYl9kYXRhID0gY2Rldi0+cHJpdmF0ZS0+Y21iOwoJaWYgKGNvdW50KSB7CgkJaW50ZXJ2YWwgPSBjbWJfZGF0YS0+bGFzdF91cGRhdGUgLQoJCQljZGV2LT5wcml2YXRlLT5jbWJfc3RhcnRfdGltZTsKCQlpbnRlcnZhbCA9IChpbnRlcnZhbCAqIDEwMDApID4+IDEyOwoJCWludGVydmFsIC89IGNvdW50OwoJfSBlbHNlCgkJaW50ZXJ2YWwgPSAtMTsKCXNwaW5fdW5sb2NrX2lycShjZGV2LT5jY3dsb2NrKTsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVsZFxuIiwgaW50ZXJ2YWwpOwp9CgpzdGF0aWMgc3NpemVfdApjbWJfc2hvd19hdmdfdXRpbGl6YXRpb24oc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglzdHJ1Y3QgY21iZGF0YSBkYXRhOwoJdTY0IHV0aWxpemF0aW9uOwoJdW5zaWduZWQgbG9uZyB0LCB1OwoJaW50IHJldDsKCglyZXQgPSBjbWZfcmVhZGFsbCh0b19jY3dkZXYoZGV2KSwgJmRhdGEpOwoJaWYgKHJldCA9PSAtRUFHQUlOIHx8IHJldCA9PSAtRU5PREVWKQoJCS8qIE5vIGRhdGEgKHlldC9jdXJyZW50bHkpIGF2YWlsYWJsZSB0byB1c2UgZm9yIGNhbGN1bGF0aW9uLiAqLwoJCXJldHVybiBzcHJpbnRmKGJ1ZiwgIm4vYVxuIik7CgllbHNlIGlmIChyZXQpCgkJcmV0dXJuIHJldDsKCgl1dGlsaXphdGlvbiA9IGRhdGEuZGV2aWNlX2Nvbm5lY3RfdGltZSArCgkJICAgICAgZGF0YS5mdW5jdGlvbl9wZW5kaW5nX3RpbWUgKwoJCSAgICAgIGRhdGEuZGV2aWNlX2Rpc2Nvbm5lY3RfdGltZTsKCgkvKiBzaGlmdCB0byBhdm9pZCBsb25nIGxvbmcgZGl2aXNpb24gKi8KCXdoaWxlICgtMXVsIDwgKGRhdGEuZWxhcHNlZF90aW1lIHwgdXRpbGl6YXRpb24pKSB7CgkJdXRpbGl6YXRpb24gPj49IDg7CgkJZGF0YS5lbGFwc2VkX3RpbWUgPj49IDg7Cgl9CgoJLyogY2FsY3VsYXRlIHZhbHVlIGluIDAuMSBwZXJjZW50IHVuaXRzICovCgl0ID0gKHVuc2lnbmVkIGxvbmcpIGRhdGEuZWxhcHNlZF90aW1lIC8gMTAwMDsKCXUgPSAodW5zaWduZWQgbG9uZykgdXRpbGl6YXRpb24gLyB0OwoKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiUwMmxkLiUwMWxkJSVcbiIsIHUvIDEwLCB1IC0gKHUvIDEwKSAqIDEwKTsKfQoKI2RlZmluZSBjbWZfYXR0cihuYW1lKSBcCnN0YXRpYyBzc2l6ZV90IHNob3dfICMjIG5hbWUgKHN0cnVjdCBkZXZpY2UgKiBkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICogYnVmKSBcCnsgcmV0dXJuIGNtYl9zaG93X2F0dHIoKGRldiksIGJ1ZiwgY21iXyAjIyBuYW1lKTsgfSBcCnN0YXRpYyBERVZJQ0VfQVRUUihuYW1lLCAwNDQ0LCBzaG93XyAjIyBuYW1lLCBOVUxMKTsKCiNkZWZpbmUgY21mX2F0dHJfYXZnKG5hbWUpIFwKc3RhdGljIHNzaXplX3Qgc2hvd19hdmdfICMjIG5hbWUgKHN0cnVjdCBkZXZpY2UgKiBkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICogYnVmKSBcCnsgcmV0dXJuIGNtYl9zaG93X2F0dHIoKGRldiksIGJ1ZiwgY21iXyAjIyBuYW1lKTsgfSBcCnN0YXRpYyBERVZJQ0VfQVRUUihhdmdfICMjIG5hbWUsIDA0NDQsIHNob3dfYXZnXyAjIyBuYW1lLCBOVUxMKTsKCmNtZl9hdHRyKHNzY2hfcnNjaF9jb3VudCk7CmNtZl9hdHRyKHNhbXBsZV9jb3VudCk7CmNtZl9hdHRyX2F2ZyhkZXZpY2VfY29ubmVjdF90aW1lKTsKY21mX2F0dHJfYXZnKGZ1bmN0aW9uX3BlbmRpbmdfdGltZSk7CmNtZl9hdHRyX2F2ZyhkZXZpY2VfZGlzY29ubmVjdF90aW1lKTsKY21mX2F0dHJfYXZnKGNvbnRyb2xfdW5pdF9xdWV1aW5nX3RpbWUpOwpjbWZfYXR0cl9hdmcoZGV2aWNlX2FjdGl2ZV9vbmx5X3RpbWUpOwpjbWZfYXR0cl9hdmcoZGV2aWNlX2J1c3lfdGltZSk7CmNtZl9hdHRyX2F2Zyhpbml0aWFsX2NvbW1hbmRfcmVzcG9uc2VfdGltZSk7CgpzdGF0aWMgREVWSUNFX0FUVFIoYXZnX3NhbXBsZV9pbnRlcnZhbCwgMDQ0NCwgY21iX3Nob3dfYXZnX3NhbXBsZV9pbnRlcnZhbCwgTlVMTCk7CnN0YXRpYyBERVZJQ0VfQVRUUihhdmdfdXRpbGl6YXRpb24sIDA0NDQsIGNtYl9zaG93X2F2Z191dGlsaXphdGlvbiwgTlVMTCk7CgpzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqY21mX2F0dHJpYnV0ZXNbXSA9IHsKCSZkZXZfYXR0cl9hdmdfc2FtcGxlX2ludGVydmFsLmF0dHIsCgkmZGV2X2F0dHJfYXZnX3V0aWxpemF0aW9uLmF0dHIsCgkmZGV2X2F0dHJfc3NjaF9yc2NoX2NvdW50LmF0dHIsCgkmZGV2X2F0dHJfc2FtcGxlX2NvdW50LmF0dHIsCgkmZGV2X2F0dHJfYXZnX2RldmljZV9jb25uZWN0X3RpbWUuYXR0ciwKCSZkZXZfYXR0cl9hdmdfZnVuY3Rpb25fcGVuZGluZ190aW1lLmF0dHIsCgkmZGV2X2F0dHJfYXZnX2RldmljZV9kaXNjb25uZWN0X3RpbWUuYXR0ciwKCSZkZXZfYXR0cl9hdmdfY29udHJvbF91bml0X3F1ZXVpbmdfdGltZS5hdHRyLAoJJmRldl9hdHRyX2F2Z19kZXZpY2VfYWN0aXZlX29ubHlfdGltZS5hdHRyLAoJTlVMTCwKfTsKCnN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGNtZl9hdHRyX2dyb3VwID0gewoJLm5hbWUgID0gImNtZiIsCgkuYXR0cnMgPSBjbWZfYXR0cmlidXRlcywKfTsKCnN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpjbWZfYXR0cmlidXRlc19leHRbXSA9IHsKCSZkZXZfYXR0cl9hdmdfc2FtcGxlX2ludGVydmFsLmF0dHIsCgkmZGV2X2F0dHJfYXZnX3V0aWxpemF0aW9uLmF0dHIsCgkmZGV2X2F0dHJfc3NjaF9yc2NoX2NvdW50LmF0dHIsCgkmZGV2X2F0dHJfc2FtcGxlX2NvdW50LmF0dHIsCgkmZGV2X2F0dHJfYXZnX2RldmljZV9jb25uZWN0X3RpbWUuYXR0ciwKCSZkZXZfYXR0cl9hdmdfZnVuY3Rpb25fcGVuZGluZ190aW1lLmF0dHIsCgkmZGV2X2F0dHJfYXZnX2RldmljZV9kaXNjb25uZWN0X3RpbWUuYXR0ciwKCSZkZXZfYXR0cl9hdmdfY29udHJvbF91bml0X3F1ZXVpbmdfdGltZS5hdHRyLAoJJmRldl9hdHRyX2F2Z19kZXZpY2VfYWN0aXZlX29ubHlfdGltZS5hdHRyLAoJJmRldl9hdHRyX2F2Z19kZXZpY2VfYnVzeV90aW1lLmF0dHIsCgkmZGV2X2F0dHJfYXZnX2luaXRpYWxfY29tbWFuZF9yZXNwb25zZV90aW1lLmF0dHIsCglOVUxMLAp9OwoKc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgY21mX2F0dHJfZ3JvdXBfZXh0ID0gewoJLm5hbWUgID0gImNtZiIsCgkuYXR0cnMgPSBjbWZfYXR0cmlidXRlc19leHQsCn07CgpzdGF0aWMgc3NpemVfdCBjbWJfZW5hYmxlX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgdG9fY2N3ZGV2KGRldiktPnByaXZhdGUtPmNtYiA/IDEgOiAwKTsKfQoKc3RhdGljIHNzaXplX3QgY21iX2VuYWJsZV9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjKQp7CglzdHJ1Y3QgY2N3X2RldmljZSAqY2RldjsKCWludCByZXQ7CgoJY2RldiA9IHRvX2Njd2RldihkZXYpOwoKCXN3aXRjaCAoYnVmWzBdKSB7CgljYXNlICcwJzoKCQlyZXQgPSBkaXNhYmxlX2NtZihjZGV2KTsKCQlpZiAocmV0KQoJCQlwcmludGsoS0VSTl9JTkZPICJkaXNhYmxlX2NtZiBmYWlsZWQgKCVkKVxuIiwgcmV0KTsKCQlicmVhazsKCWNhc2UgJzEnOgoJCXJldCA9IGVuYWJsZV9jbWYoY2Rldik7CgkJaWYgKHJldCAmJiByZXQgIT0gLUVCVVNZKQoJCQlwcmludGsoS0VSTl9JTkZPICJlbmFibGVfY21mIGZhaWxlZCAoJWQpXG4iLCByZXQpOwoJCWJyZWFrOwoJfQoKCXJldHVybiBjOwp9CgpERVZJQ0VfQVRUUihjbWJfZW5hYmxlLCAwNjQ0LCBjbWJfZW5hYmxlX3Nob3csIGNtYl9lbmFibGVfc3RvcmUpOwoKLyogZW5hYmxlX2NtZi9kaXNhYmxlX2NtZjogbW9kdWxlIGludGVyZmFjZSBmb3IgY21mIChkZSlhY3RpdmF0aW9uICovCmludAplbmFibGVfY21mKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQp7CglpbnQgcmV0OwoKCXJldCA9IGNtYm9wcy0+YWxsb2MoY2Rldik7CgljbWJvcHMtPnJlc2V0KGNkZXYpOwoJaWYgKHJldCkKCQlyZXR1cm4gcmV0OwoJcmV0ID0gY21ib3BzLT5zZXQoY2RldiwgMik7CglpZiAocmV0KSB7CgkJY21ib3BzLT5mcmVlKGNkZXYpOwoJCXJldHVybiByZXQ7Cgl9CglyZXQgPSBzeXNmc19jcmVhdGVfZ3JvdXAoJmNkZXYtPmRldi5rb2JqLCBjbWJvcHMtPmF0dHJfZ3JvdXApOwoJaWYgKCFyZXQpCgkJcmV0dXJuIDA7CgljbWJvcHMtPnNldChjZGV2LCAwKTsgIC8vRklYTUU6IHRoaXMgY2FuIGZhaWwKCWNtYm9wcy0+ZnJlZShjZGV2KTsKCXJldHVybiByZXQ7Cn0KCmludApkaXNhYmxlX2NtZihzdHJ1Y3QgY2N3X2RldmljZSAqY2RldikKewoJaW50IHJldDsKCglyZXQgPSBjbWJvcHMtPnNldChjZGV2LCAwKTsKCWlmIChyZXQpCgkJcmV0dXJuIHJldDsKCWNtYm9wcy0+ZnJlZShjZGV2KTsKCXN5c2ZzX3JlbW92ZV9ncm91cCgmY2Rldi0+ZGV2LmtvYmosIGNtYm9wcy0+YXR0cl9ncm91cCk7CglyZXR1cm4gcmV0Owp9Cgp1NjQKY21mX3JlYWQoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYsIGludCBpbmRleCkKewoJcmV0dXJuIGNtYm9wcy0+cmVhZChjZGV2LCBpbmRleCk7Cn0KCmludApjbWZfcmVhZGFsbChzdHJ1Y3QgY2N3X2RldmljZSAqY2Rldiwgc3RydWN0IGNtYmRhdGEgKmRhdGEpCnsKCXJldHVybiBjbWJvcHMtPnJlYWRhbGwoY2RldiwgZGF0YSk7Cn0KCi8qIFJlZW5hYmxlIGNtZiB3aGVuIGEgZGlzY29ubmVjdGVkIGRldmljZSBiZWNvbWVzIGF2YWlsYWJsZSBhZ2Fpbi4gKi8KaW50IGNtZl9yZWVuYWJsZShzdHJ1Y3QgY2N3X2RldmljZSAqY2RldikKewoJY21ib3BzLT5yZXNldChjZGV2KTsKCXJldHVybiBjbWJvcHMtPnNldChjZGV2LCAyKTsKfQoKc3RhdGljIGludCBfX2luaXQKaW5pdF9jbWYodm9pZCkKewoJY2hhciAqZm9ybWF0X3N0cmluZzsKCWNoYXIgKmRldGVjdF9zdHJpbmcgPSAicGFyYW1ldGVyIjsKCgkvKiBXZSBjYW5ub3QgcmVhbGx5IGF1dG9wcm9iZSB0aGlzLiBJZiB0aGUgdXNlciBkaWQgbm90IGdpdmUgYSBwYXJhbWV0ZXIsCgkgICBzZWUgaWYgd2UgYXJlIHJ1bm5pbmcgb24gejk5MCBvciB1cCwgb3RoZXJ3aXNlIGZhbGwgYmFjayB0byBiYXNpYyBtb2RlLiAqLwoKCWlmIChmb3JtYXQgPT0gQ01GX0FVVE9ERVRFQ1QpIHsKCQlpZiAoIWNzc19jaGFyYWN0ZXJpc3RpY3NfYXZhaWwgfHwKCQkgICAgIWNzc19nZW5lcmFsX2NoYXJhY3RlcmlzdGljcy5leHRfbWIpIHsKCQkJZm9ybWF0ID0gQ01GX0JBU0lDOwoJCX0gZWxzZSB7CgkJCWZvcm1hdCA9IENNRl9FWFRFTkRFRDsKCQl9CgkJZGV0ZWN0X3N0cmluZyA9ICJhdXRvZGV0ZWN0ZWQiOwoJfSBlbHNlIHsKCQlkZXRlY3Rfc3RyaW5nID0gInBhcmFtZXRlciI7Cgl9CgoJc3dpdGNoIChmb3JtYXQpIHsKCWNhc2UgQ01GX0JBU0lDOgoJCWZvcm1hdF9zdHJpbmcgPSAiYmFzaWMiOwoJCWNtYm9wcyA9ICZjbWJvcHNfYmFzaWM7CgkJaWYgKGNtYl9hcmVhLm51bV9jaGFubmVscyA+IDQwOTYgfHwgY21iX2FyZWEubnVtX2NoYW5uZWxzIDwgMSkgewoJCQlwcmludGsoS0VSTl9FUlIgIkJhc2ljIGNoYW5uZWwgbWVhc3VyZW1lbnQgZmFjaWxpdHkiCgkJCQkJIiBjYW4gb25seSB1c2UgMSB0byA0MDk2IGRldmljZXNcbiIKCQkJICAgICAgIEtFUk5fRVJSICJ3aGVuIHRoZSBjbWYgZHJpdmVyIGlzIGJ1aWx0IgoJCQkJCSIgYXMgYSBsb2FkYWJsZSBtb2R1bGVcbiIpOwoJCQlyZXR1cm4gMTsKCQl9CgkJYnJlYWs7CgljYXNlIENNRl9FWFRFTkRFRDoKIAkJZm9ybWF0X3N0cmluZyA9ICJleHRlbmRlZCI7CgkJY21ib3BzID0gJmNtYm9wc19leHRlbmRlZDsKCQlicmVhazsKCWRlZmF1bHQ6CgkJcHJpbnRrKEtFUk5fRVJSICJJbnZhbGlkIGZvcm1hdCAlZCBmb3IgY2hhbm5lbCAiCgkJCSJtZWFzdXJlbWVudCBmYWNpbGl0eVxuIiwgZm9ybWF0KTsKCQlyZXR1cm4gMTsKCX0KCglwcmludGsoS0VSTl9JTkZPICJDaGFubmVsIG1lYXN1cmVtZW50IGZhY2lsaXR5IHVzaW5nICVzIGZvcm1hdCAoJXMpXG4iLAoJCWZvcm1hdF9zdHJpbmcsIGRldGVjdF9zdHJpbmcpOwoJcmV0dXJuIDA7Cn0KCm1vZHVsZV9pbml0KGluaXRfY21mKTsKCgpNT0RVTEVfQVVUSE9SKCJBcm5kIEJlcmdtYW5uIDxhcm5kYkBkZS5pYm0uY29tPiIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7Ck1PRFVMRV9ERVNDUklQVElPTigiY2hhbm5lbCBtZWFzdXJlbWVudCBmYWNpbGl0eSBiYXNlIGRyaXZlclxuIgoJCSAgICJDb3B5cmlnaHQgMjAwMyBJQk0gQ29ycG9yYXRpb25cbiIpOwoKRVhQT1JUX1NZTUJPTF9HUEwoZW5hYmxlX2NtZik7CkVYUE9SVF9TWU1CT0xfR1BMKGRpc2FibGVfY21mKTsKRVhQT1JUX1NZTUJPTF9HUEwoY21mX3JlYWQpOwpFWFBPUlRfU1lNQk9MX0dQTChjbWZfcmVhZGFsbCk7Cg==