LyogLSotIGMtYmFzaWMtb2Zmc2V0OiA4IC0qLQogKgogKiBhbWR0cC5jIC0gQXVkaW8gYW5kIE11c2ljIERhdGEgVHJhbnNtaXNzaW9uIFByb3RvY29sIERyaXZlcgogKiBDb3B5cmlnaHQgKEMpIDIwMDEgS3Jpc3RpYW4gSPhnc2JlcmcKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKICogSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KICovCgovKiBPVkVSVklFVwogKiAtLS0tLS0tLQogKgogKiBUaGUgQU1EVFAgZHJpdmVyIGlzIGRlc2lnbmVkIHRvIGV4cG9zZSB0aGUgSUVFRTEzOTQgYnVzIGFzIGEKICogcmVndWxhciBPU1Mgc291bmRjYXJkLCBpLmUuIHlvdSBjYW4gbGluayAvZGV2L2RzcCB0byAvZGV2L2FtZHRwIGFuZAogKiB0aGVuIHlvdXIgZmF2b3VyaXRlIE1QMyBwbGF5ZXIsIGdhbWUgb3Igd2hhdGV2ZXIgc291bmQgcHJvZ3JhbSB3aWxsCiAqIG91dHB1dCB0byBhbiBJRUVFMTM5NCBpc29jaHJvbm91cyBjaGFubmVsLiAgVGhlIHNpZ25hbCBkZXN0aW5hdGlvbgogKiBjb3VsZCBiZSBhIHNldCBvZiBJRUVFMTM5NCBsb3Vkc3BlYWtlcnMgKGlmIGFuZCB3aGVuIHN1Y2ggdGhpbmdzCiAqIGJlY29tZSBhdmFpbGFibGUpIG9yIGFuIGFtcGxpZmllciB3aXRoIElFRUUxMzk0IGlucHV0IChsaWtlIHRoZQogKiBTb255IFNUUi1MU0ExKS4gIFRoZSBkcml2ZXIgb25seSBoYW5kbGVzIHRoZSBhY3R1YWwgc3RyZWFtaW5nLCBzb21lCiAqIGNvbm5lY3Rpb24gbWFuYWdlbWVudCBpcyBhbHNvIHJlcXVpcmVkIGZvciB0aGlzIHRvIGFjdHVhbGx5IHdvcmsuCiAqIFRoYXQgaXMgb3V0c2lkZSB0aGUgc2NvcGUgb2YgdGhpcyBkcml2ZXIsIGFuZCBmdXJ0aGVybW9yZSBpdCBpcyBub3QKICogcmVhbGx5IHN0YW5kYXJkaXplZCB5ZXQuCiAqCiAqIFRoZSBBdWRpbyBhbmQgTXVzaWMgRGF0YSBUcmFubWlzc2lvbiBQcm90b2NvbCBpcyBhdmFpbGFibGUgYXQKICoKICogICAgIGh0dHA6Ly93d3cuMTM5NHRhLm9yZy9Eb3dubG9hZC9UZWNobm9sb2d5L1NwZWNpZmljYXRpb25zLzIwMDEvQU0yMEZpbmFsLWpmMi5wZGYKICoKICoKICogVE9ETwogKiAtLS0tCiAqCiAqIC0gV2Ugc2hvdWxkIGJlIGFibGUgdG8gY2hhbmdlIGlucHV0IHNhbXBsZSBmb3JtYXQgYmV0d2VlbiBMRS9CRSwgYXMKICogICB3ZSBhbHJlYWR5IHNoaWZ0IHRoZSBieXRlcyBhcm91bmQgd2hlbiB3ZSBjb25zdHJ1Y3QgdGhlIGlzbwogKiAgIHBhY2tldHMuCiAqCiAqIC0gRml4IERNQSBzdG9wIGFmdGVyIGJ1cyByZXNldCEKICoKICogLSBDbGVhbiB1cCBpc28gY29udGV4dCBoYW5kbGluZyBpbiBvaGNpMTM5NC4KICoKICoKICogTUFZQkUgVE9ETwogKiAtLS0tLS0tLS0tCiAqCiAqIC0gUmVjZWl2ZSBkYXRhIGZvciBsb2NhbCBwbGF5YmFjayBvciByZWNvcmRpbmcuICBQbGF5YmFjayByZXF1aXJlcwogKiAgIHNvZnQgc3luY2luZyB3aXRoIHRoZSBzb3VuZCBjYXJkLgogKgogKiAtIFNpZ25hbCBwcm9jZXNzaW5nLCBpLmUuIHJlY2VpdmUgcGFja2V0cywgZG8gc29tZSBwcm9jZXNzaW5nLCBhbmQKICogICB0cmFuc21pdCB0aGVtIGFnYWluIHVzaW5nIHRoZSBzYW1lIHBhY2tldCBzdHJ1Y3R1cmUgYW5kIHRpbWVzdGFtcHMKICogICBvZmZzZXQgYnkgcHJvY2Vzc2luZyB0aW1lLgogKgogKiAtIE1heWJlIG1ha2UgYW4gQUxTQSBpbnRlcmZhY2UsIHRoYXQgaXMsIGNyZWF0ZSBhIGZpbGVfb3BzCiAqICAgaW1wbGVtZW50YXRpb24gdGhhdCByZWNvZ25pemVzIEFMU0EgaW9jdGxzIGFuZCB1c2VzIGRlZmF1bHRzIGZvcgogKiAgIHRoaW5ncyB0aGF0IGNhbid0IGJlIGNvbnRyb2xsZWQgdGhyb3VnaCBBTFNBIChpc28gY2hhbm5lbCkuCiAqCiAqICAgQ2hhbmdlczoKICoKICogLSBBdWRpdCBjb3B5X2Zyb21fdXNlciBpbiBhbWR0cF93cml0ZS4KICogICAgICAgICAgICAgICAgICAgICAgICAgICBEYW5pZWxlIEJlbGx1Y2NpIDxiZWxsdWNkYUB0aXNjYWxpLml0PgogKgogKi8KCiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgojaW5jbHVkZSA8bGludXgvZnMuaD4KI2luY2x1ZGUgPGxpbnV4L2lvY3RsLmg+CiNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CiNpbmNsdWRlIDxsaW51eC9wY2kuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvcG9sbC5oPgojaW5jbHVkZSA8bGludXgvaW9jdGwzMi5oPgojaW5jbHVkZSA8bGludXgvY29tcGF0Lmg+CiNpbmNsdWRlIDxsaW51eC9jZGV2Lmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgojaW5jbHVkZSA8YXNtL2F0b21pYy5oPgoKI2luY2x1ZGUgImhvc3RzLmgiCiNpbmNsdWRlICJoaWdobGV2ZWwuaCIKI2luY2x1ZGUgImllZWUxMzk0LmgiCiNpbmNsdWRlICJpZWVlMTM5NF9jb3JlLmgiCiNpbmNsdWRlICJvaGNpMTM5NC5oIgoKI2luY2x1ZGUgImFtZHRwLmgiCiNpbmNsdWRlICJjbXAuaCIKCiNkZWZpbmUgRk1UX0FNRFRQIDB4MTAKI2RlZmluZSBGREZfQU04MjQgMHgwMAojZGVmaW5lIEZERl9TRkNfMzJLSFogICAweDAwCiNkZWZpbmUgRkRGX1NGQ180NEsxSFogIDB4MDEKI2RlZmluZSBGREZfU0ZDXzQ4S0haICAgMHgwMgojZGVmaW5lIEZERl9TRkNfODhLMkhaICAweDAzCiNkZWZpbmUgRkRGX1NGQ185NktIWiAgIDB4MDQKI2RlZmluZSBGREZfU0ZDXzE3Nks0SFogMHgwNQojZGVmaW5lIEZERl9TRkNfMTkyS0haICAweDA2CgpzdHJ1Y3QgZGVzY3JpcHRvcl9ibG9jayB7CglzdHJ1Y3Qgb3V0cHV0X21vcmVfaW1tZWRpYXRlIHsKCQl1MzIgY29udHJvbDsKCQl1MzIgcGFkMDsKCQl1MzIgc2tpcDsKCQl1MzIgcGFkMTsKCQl1MzIgaGVhZGVyWzRdOwoJfSBoZWFkZXJfZGVzYzsKCglzdHJ1Y3Qgb3V0cHV0X2xhc3QgewoJCXUzMiBjb250cm9sOwoJCXUzMiBkYXRhX2FkZHJlc3M7CgkJdTMyIGJyYW5jaDsKCQl1MzIgc3RhdHVzOwoJfSBwYXlsb2FkX2Rlc2M7Cn07CgpzdHJ1Y3QgcGFja2V0IHsKCXN0cnVjdCBkZXNjcmlwdG9yX2Jsb2NrICpkYjsKCWRtYV9hZGRyX3QgZGJfYnVzOwoJc3RydWN0IGlzb19wYWNrZXQgKnBheWxvYWQ7CglkbWFfYWRkcl90IHBheWxvYWRfYnVzOwp9OwoKI2luY2x1ZGUgPGFzbS9ieXRlb3JkZXIuaD4KCiNpZiBkZWZpbmVkIF9fQklHX0VORElBTl9CSVRGSUVMRAoKc3RydWN0IGlzb19wYWNrZXQgewoJLyogRmlyc3QgcXVhZGxldCAqLwoJdW5zaWduZWQgaW50IGRicyAgICAgIDogODsKCXVuc2lnbmVkIGludCBlb2gwICAgICA6IDI7Cgl1bnNpZ25lZCBpbnQgc2lkICAgICAgOiA2OwoKCXVuc2lnbmVkIGludCBkYmMgICAgICA6IDg7Cgl1bnNpZ25lZCBpbnQgZm4gICAgICAgOiAyOwoJdW5zaWduZWQgaW50IHFwYyAgICAgIDogMzsKCXVuc2lnbmVkIGludCBzcGggICAgICA6IDE7Cgl1bnNpZ25lZCBpbnQgcmVzZXJ2ZWQgOiAyOwoKCS8qIFNlY29uZCBxdWFkbGV0ICovCgl1bnNpZ25lZCBpbnQgZmRmICAgICAgOiA4OwoJdW5zaWduZWQgaW50IGVvaDEgICAgIDogMjsKCXVuc2lnbmVkIGludCBmbXQgICAgICA6IDY7CgoJdW5zaWduZWQgaW50IHN5dCAgICAgIDogMTY7CgogICAgICAgIHF1YWRsZXRfdCBkYXRhWzBdOwp9OwoKI2VsaWYgZGVmaW5lZCBfX0xJVFRMRV9FTkRJQU5fQklURklFTEQKCnN0cnVjdCBpc29fcGFja2V0IHsKCS8qIEZpcnN0IHF1YWRsZXQgKi8KCXVuc2lnbmVkIGludCBzaWQgICAgICA6IDY7Cgl1bnNpZ25lZCBpbnQgZW9oMCAgICAgOiAyOwoJdW5zaWduZWQgaW50IGRicyAgICAgIDogODsKCgl1bnNpZ25lZCBpbnQgcmVzZXJ2ZWQgOiAyOwoJdW5zaWduZWQgaW50IHNwaCAgICAgIDogMTsKCXVuc2lnbmVkIGludCBxcGMgICAgICA6IDM7Cgl1bnNpZ25lZCBpbnQgZm4gICAgICAgOiAyOwoJdW5zaWduZWQgaW50IGRiYyAgICAgIDogODsKCgkvKiBTZWNvbmQgcXVhZGxldCAqLwoJdW5zaWduZWQgaW50IGZtdCAgICAgIDogNjsKCXVuc2lnbmVkIGludCBlb2gxICAgICA6IDI7Cgl1bnNpZ25lZCBpbnQgZmRmICAgICAgOiA4OwoKCXVuc2lnbmVkIGludCBzeXQgICAgICA6IDE2OwoKCXF1YWRsZXRfdCBkYXRhWzBdOwp9OwoKI2Vsc2UKCiNlcnJvciBVbmtub3duIGJpdGZpZWxkIHR5cGUKCiNlbmRpZgoKc3RydWN0IGZyYWN0aW9uIHsKCWludCBpbnRlZ2VyOwoJaW50IG51bWVyYXRvcjsKCWludCBkZW5vbWluYXRvcjsKfTsKCiNkZWZpbmUgUEFDS0VUX0xJU1RfU0laRSAyNTYKI2RlZmluZSBNQVhfUEFDS0VUX0xJU1RTIDQKCnN0cnVjdCBwYWNrZXRfbGlzdCB7CglzdHJ1Y3QgbGlzdF9oZWFkIGxpbms7CglpbnQgbGFzdF9jeWNsZV9jb3VudDsKCXN0cnVjdCBwYWNrZXQgcGFja2V0c1tQQUNLRVRfTElTVF9TSVpFXTsKfTsKCiNkZWZpbmUgQlVGRkVSX1NJWkUgMTI4CgovKiBUaGlzIGltcGxlbWVudHMgYSBjaXJjdWxhciBidWZmZXIgZm9yIGluY29taW5nIHNhbXBsZXMuICovCgpzdHJ1Y3QgYnVmZmVyIHsKCXNpemVfdCBoZWFkLCB0YWlsLCBsZW5ndGgsIHNpemU7Cgl1bnNpZ25lZCBjaGFyIGRhdGFbMF07Cn07CgpzdHJ1Y3Qgc3RyZWFtIHsKCWludCBpc29fY2hhbm5lbDsKCWludCBmb3JtYXQ7CglpbnQgcmF0ZTsKCWludCBkaW1lbnNpb247CglpbnQgZmRmOwoJaW50IG1vZGU7CglpbnQgc2FtcGxlX2Zvcm1hdDsKCXN0cnVjdCBjbXBfcGNyICpvcGNyOwoKCS8qIElucHV0IHNhbXBsZXMgYXJlIGNvcGllZCBoZXJlLiAqLwoJc3RydWN0IGJ1ZmZlciAqaW5wdXQ7CgoJLyogSVNPIFBhY2tlciBzdGF0ZSAqLwoJdW5zaWduZWQgY2hhciBkYmM7CglzdHJ1Y3QgcGFja2V0X2xpc3QgKmN1cnJlbnRfcGFja2V0X2xpc3Q7CglpbnQgY3VycmVudF9wYWNrZXQ7CglzdHJ1Y3QgZnJhY3Rpb24gcmVhZHlfc2FtcGxlcywgc2FtcGxlc19wZXJfY3ljbGU7CgoJLyogV2UgdXNlIHRoZXNlIHRvIGdlbmVyYXRlIGNvbnRyb2wgYml0cyB3aGVuIHdlIGFyZSBwYWNraW5nCgkgKiBpZWM5NTggZGF0YS4KCSAqLwoJaW50IGllYzk1OF9mcmFtZV9jb3VudDsKCWludCBpZWM5NThfcmF0ZV9jb2RlOwoKCS8qIFRoZSBjeWNsZV9jb3VudCBhbmQgY3ljbGVfb2Zmc2V0IGZpZWxkcyBhcmUgdXNlZCBmb3IgdGhlCgkgKiBzeW5jaHJvbml6YXRpb24gdGltZXN0YW1wcyAoc3l0KSBpbiB0aGUgY2lwIGhlYWRlci4gIFRoZXkKCSAqIGFyZSBpbmNyZW1lbnRlZCBieSBhdCBsZWFzdCBhIGN5Y2xlIGV2ZXJ5IHRpbWUgd2UgcHV0IGEKCSAqIHRpbWUgc3RhbXAgaW4gYSBwYWNrZXQuICBBcyB3ZSBkb24ndCB0aW1lIHN0YW1wIGFsbAoJICogcGFja2FnZXMsIGN5Y2xlX2NvdW50IGlzbid0IHVwZGF0ZWQgaW4gZXZlcnkgY3ljbGUsIGFuZAoJICogc29tZXRpbWVzIGl0J3MgaW5jcmVtZW50ZWQgYnkgMi4gIFRodXMsIHdlIGhhdmUKCSAqIGN5Y2xlX2NvdW50Miwgd2hpY2ggaXMgc2ltcGx5IGluY3JlbWVudGVkIGJ5IG9uZSB3aXRoIGVhY2gKCSAqIHBhY2tldCwgc28gd2UgY2FuIGNvbXBhcmUgaXQgdG8gdGhlIHRyYW5zbWlzc2lvbiB0aW1lCgkgKiB3cml0dGVuIGJhY2sgaW4gdGhlIGRtYSBwcm9ncmFtcy4KCSAqLwoJYXRvbWljX3QgY3ljbGVfY291bnQsIGN5Y2xlX2NvdW50MjsKCXN0cnVjdCBmcmFjdGlvbiBjeWNsZV9vZmZzZXQsIHRpY2tzX3Blcl9zeXRfb2Zmc2V0OwoJaW50IHN5dF9pbnRlcnZhbDsKCWludCBzdGFsZV9jb3VudDsKCgkvKiBUaGVzZXMgZmllbGRzIGNvbnRyb2wgdGhlIHNhbXBsZSBvdXRwdXQgdG8gdGhlIERNQSBlbmdpbmUuCgkgKiBUaGUgZG1hX3BhY2tldF9saXN0cyBsaXN0IGhvbGRzIHBhY2tldCBsaXN0cyBjdXJyZW50bHkKCSAqIHF1ZXVlZCBmb3IgZG1hOyB0aGUgaGVhZCBvZiB0aGUgbGlzdCBpcyBjdXJyZW50bHkgYmVpbmcKCSAqIHByb2Nlc3NlZC4gIFRoZSBsYXN0IHByb2dyYW0gaW4gYSBwYWNrZXQgbGlzdCBnZW5lcmF0ZXMgYW4KCSAqIGludGVycnVwdCwgd2hpY2ggcmVtb3ZlcyB0aGUgaGVhZCBmcm9tIGRtYV9wYWNrZXRfbGlzdHMgYW5kCgkgKiBwdXRzIGl0IGJhY2sgb24gdGhlIGZyZWUgbGlzdC4KCSAqLwoJc3RydWN0IGxpc3RfaGVhZCBkbWFfcGFja2V0X2xpc3RzOwoJc3RydWN0IGxpc3RfaGVhZCBmcmVlX3BhY2tldF9saXN0czsKICAgICAgICB3YWl0X3F1ZXVlX2hlYWRfdCBwYWNrZXRfbGlzdF93YWl0OwoJc3BpbmxvY2tfdCBwYWNrZXRfbGlzdF9sb2NrOwoJc3RydWN0IG9oY2kxMzk0X2lzb190YXNrbGV0IGlzb190YXNrbGV0OwoJc3RydWN0IHBjaV9wb29sICpkZXNjcmlwdG9yX3Bvb2wsICpwYWNrZXRfcG9vbDsKCgkvKiBTdHJlYW1zIGF0IGEgaG9zdCBjb250cm9sbGVyIGFyZSBjaGFpbmVkIHRocm91Z2ggdGhpcyBmaWVsZC4gKi8KCXN0cnVjdCBsaXN0X2hlYWQgbGluazsKCXN0cnVjdCBhbWR0cF9ob3N0ICpob3N0Owp9OwoKc3RydWN0IGFtZHRwX2hvc3QgewoJc3RydWN0IGhwc2JfaG9zdCAqaG9zdDsKCXN0cnVjdCB0aV9vaGNpICpvaGNpOwoJc3RydWN0IGxpc3RfaGVhZCBzdHJlYW1fbGlzdDsKCXNwaW5sb2NrX3Qgc3RyZWFtX2xpc3RfbG9jazsKfTsKCnN0YXRpYyBzdHJ1Y3QgaHBzYl9oaWdobGV2ZWwgYW1kdHBfaGlnaGxldmVsOwoKCi8qIEZJWE1FOiBUaGlzIGRvZXNuJ3QgYmVsb25nIGhlcmUuLi4gKi8KCiNkZWZpbmUgT0hDSTEzOTRfQ09OVEVYVF9DWUNMRV9NQVRDSCAweDgwMDAwMDAwCiNkZWZpbmUgT0hDSTEzOTRfQ09OVEVYVF9SVU4gICAgICAgICAweDAwMDA4MDAwCiNkZWZpbmUgT0hDSTEzOTRfQ09OVEVYVF9XQUtFICAgICAgICAweDAwMDAxMDAwCiNkZWZpbmUgT0hDSTEzOTRfQ09OVEVYVF9ERUFEICAgICAgICAweDAwMDAwODAwCiNkZWZpbmUgT0hDSTEzOTRfQ09OVEVYVF9BQ1RJVkUgICAgICAweDAwMDAwNDAwCgpzdGF0aWMgdm9pZCBvaGNpMTM5NF9zdGFydF9pdF9jdHgoc3RydWN0IHRpX29oY2kgKm9oY2ksIGludCBjdHgsCgkJCSAgIGRtYV9hZGRyX3QgZmlyc3RfY21kLCBpbnQgeiwgaW50IGN5Y2xlX21hdGNoKQp7CglyZWdfd3JpdGUob2hjaSwgT0hDSTEzOTRfSXNvWG1pdEludE1hc2tTZXQsIDEgPDwgY3R4KTsKCXJlZ193cml0ZShvaGNpLCBPSENJMTM5NF9Jc29YbWl0Q29tbWFuZFB0ciArIGN0eCAqIDE2LCBmaXJzdF9jbWQgfCB6KTsKCXJlZ193cml0ZShvaGNpLCBPSENJMTM5NF9Jc29YbWl0Q29udGV4dENvbnRyb2xDbGVhciArIGN0eCAqIDE2LCB+MCk7Cgl3bWIoKTsKCXJlZ193cml0ZShvaGNpLCBPSENJMTM5NF9Jc29YbWl0Q29udGV4dENvbnRyb2xTZXQgKyBjdHggKiAxNiwKCQkgIE9IQ0kxMzk0X0NPTlRFWFRfQ1lDTEVfTUFUQ0ggfCAoY3ljbGVfbWF0Y2ggPDwgMTYpIHwKCQkgIE9IQ0kxMzk0X0NPTlRFWFRfUlVOKTsKfQoKc3RhdGljIHZvaWQgb2hjaTEzOTRfd2FrZV9pdF9jdHgoc3RydWN0IHRpX29oY2kgKm9oY2ksIGludCBjdHgpCnsKCXJlZ193cml0ZShvaGNpLCBPSENJMTM5NF9Jc29YbWl0Q29udGV4dENvbnRyb2xTZXQgKyBjdHggKiAxNiwKCQkgIE9IQ0kxMzk0X0NPTlRFWFRfV0FLRSk7Cn0KCnN0YXRpYyB2b2lkIG9oY2kxMzk0X3N0b3BfaXRfY3R4KHN0cnVjdCB0aV9vaGNpICpvaGNpLCBpbnQgY3R4LCBpbnQgc3luY2hyb25vdXMpCnsKCXUzMiBjb250cm9sOwoJaW50IHdhaXQ7CgoJcmVnX3dyaXRlKG9oY2ksIE9IQ0kxMzk0X0lzb1htaXRJbnRNYXNrQ2xlYXIsIDEgPDwgY3R4KTsKCXJlZ193cml0ZShvaGNpLCBPSENJMTM5NF9Jc29YbWl0Q29udGV4dENvbnRyb2xDbGVhciArIGN0eCAqIDE2LAoJCSAgT0hDSTEzOTRfQ09OVEVYVF9SVU4pOwoJd21iKCk7CgoJaWYgKHN5bmNocm9ub3VzKSB7CgkJZm9yICh3YWl0ID0gMDsgd2FpdCA8IDU7IHdhaXQrKykgewoJCQljb250cm9sID0gcmVnX3JlYWQob2hjaSwgT0hDSTEzOTRfSXNvWG1pdENvbnRleHRDb250cm9sU2V0ICsgY3R4ICogMTYpOwoJCQlpZiAoKGNvbnRyb2wgJiBPSENJMTM5NF9DT05URVhUX0FDVElWRSkgPT0gMCkKCQkJCWJyZWFrOwoKCQkJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19JTlRFUlJVUFRJQkxFKTsKCQkJc2NoZWR1bGVfdGltZW91dCgxKTsKCQl9Cgl9Cn0KCi8qIE5vdGU6IHdlIGNhbiB0ZXN0IGlmIGZyZWVfcGFja2V0X2xpc3RzIGlzIGVtcHR5IHdpdGhvdXQgYXF1aXJpbmcKICogdGhlIHBhY2tldF9saXN0X2xvY2suICBUaGUgaW50ZXJydXB0IGhhbmRsZXIgb25seSBhZGRzIHRvIHRoZSBmcmVlCiAqIGxpc3QsIHRoZXJlIGlzIG5vIHJhY2UgY29uZGl0aW9uIGJldHdlZW4gdGVzdGluZyB0aGUgbGlzdCBub24tZW1wdHkKICogYW5kIGFjcXVpcmluZyB0aGUgbG9jay4KICovCgpzdGF0aWMgc3RydWN0IHBhY2tldF9saXN0ICpzdHJlYW1fZ2V0X2ZyZWVfcGFja2V0X2xpc3Qoc3RydWN0IHN0cmVhbSAqcykKewoJc3RydWN0IHBhY2tldF9saXN0ICpwbDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJaWYgKGxpc3RfZW1wdHkoJnMtPmZyZWVfcGFja2V0X2xpc3RzKSkKCQlyZXR1cm4gTlVMTDsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcy0+cGFja2V0X2xpc3RfbG9jaywgZmxhZ3MpOwoJcGwgPSBsaXN0X2VudHJ5KHMtPmZyZWVfcGFja2V0X2xpc3RzLm5leHQsIHN0cnVjdCBwYWNrZXRfbGlzdCwgbGluayk7CglsaXN0X2RlbCgmcGwtPmxpbmspOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+cGFja2V0X2xpc3RfbG9jaywgZmxhZ3MpOwoKCXJldHVybiBwbDsKfQoKc3RhdGljIHZvaWQgc3RyZWFtX3N0YXJ0X2RtYShzdHJ1Y3Qgc3RyZWFtICpzLCBzdHJ1Y3QgcGFja2V0X2xpc3QgKnBsKQp7Cgl1MzIgc3l0X2N5Y2xlLCBjeWNsZV9jb3VudCwgc3RhcnRfY3ljbGU7CgoJY3ljbGVfY291bnQgPSByZWdfcmVhZChzLT5ob3N0LT5vaGNpLAoJCQkgICAgICAgT0hDSTEzOTRfSXNvY2hyb25vdXNDeWNsZVRpbWVyKSA+PiAxMjsKCXN5dF9jeWNsZSA9IChwbC0+bGFzdF9jeWNsZV9jb3VudCAtIFBBQ0tFVF9MSVNUX1NJWkUgKyAxKSAmIDB4MGY7CgoJLyogV2UgcHJvZ3JhbSB0aGUgRE1BIGNvbnRyb2xsZXIgdG8gc3RhcnQgdHJhbnNtaXNzaW9uIGF0CgkgKiBsZWFzdCAxNyBjeWNsZXMgZnJvbSBub3cgLSB0aGlzIGhhcHBlbnMgd2hlbiB0aGUgbG93ZXIgZm91cgoJICogYml0cyBvZiBjeWNsZV9jb3VudCBpcyAweDBmIGFuZCBzeXRfY3ljbGUgaXMgMCwgaW4gdGhpcwoJICogY2FzZSB0aGUgc3RhcnQgY3ljbGUgaXMgY3ljbGVfY291bnQgLSAxNSArIDMyLiAqLwoJc3RhcnRfY3ljbGUgPSAoY3ljbGVfY291bnQgJiB+MHgwZikgKyAzMiArIHN5dF9jeWNsZTsKCWlmICgoc3RhcnRfY3ljbGUgJiAweDFmZmYpID49IDgwMDApCgkJc3RhcnRfY3ljbGUgPSBzdGFydF9jeWNsZSAtIDgwMDAgKyAweDIwMDA7CgoJb2hjaTEzOTRfc3RhcnRfaXRfY3R4KHMtPmhvc3QtPm9oY2ksIHMtPmlzb190YXNrbGV0LmNvbnRleHQsCgkJCSAgICAgIHBsLT5wYWNrZXRzWzBdLmRiX2J1cywgMywKCQkJICAgICAgc3RhcnRfY3ljbGUgJiAweDdmZmYpOwp9CgpzdGF0aWMgdm9pZCBzdHJlYW1fcHV0X2RtYV9wYWNrZXRfbGlzdChzdHJ1Y3Qgc3RyZWFtICpzLAoJCQkJICAgICAgIHN0cnVjdCBwYWNrZXRfbGlzdCAqcGwpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglzdHJ1Y3QgcGFja2V0X2xpc3QgKnByZXY7CgoJLyogUmVtZW1iZXIgdGhlIGN5Y2xlX2NvdW50IHVzZWQgZm9yIHRpbWVzdGFtcGluZyB0aGUgbGFzdCBwYWNrZXQuICovCglwbC0+bGFzdF9jeWNsZV9jb3VudCA9IGF0b21pY19yZWFkKCZzLT5jeWNsZV9jb3VudDIpIC0gMTsKCXBsLT5wYWNrZXRzW1BBQ0tFVF9MSVNUX1NJWkUgLSAxXS5kYi0+cGF5bG9hZF9kZXNjLmJyYW5jaCA9IDA7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPnBhY2tldF9saXN0X2xvY2ssIGZsYWdzKTsKCWxpc3RfYWRkX3RhaWwoJnBsLT5saW5rLCAmcy0+ZG1hX3BhY2tldF9saXN0cyk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzLT5wYWNrZXRfbGlzdF9sb2NrLCBmbGFncyk7CgoJcHJldiA9IGxpc3RfZW50cnkocGwtPmxpbmsucHJldiwgc3RydWN0IHBhY2tldF9saXN0LCBsaW5rKTsKCWlmIChwbC0+bGluay5wcmV2ICE9ICZzLT5kbWFfcGFja2V0X2xpc3RzKSB7CgkJc3RydWN0IHBhY2tldCAqbGFzdCA9ICZwcmV2LT5wYWNrZXRzW1BBQ0tFVF9MSVNUX1NJWkUgLSAxXTsKCQlsYXN0LT5kYi0+cGF5bG9hZF9kZXNjLmJyYW5jaCA9IHBsLT5wYWNrZXRzWzBdLmRiX2J1cyB8IDM7CgkJbGFzdC0+ZGItPmhlYWRlcl9kZXNjLnNraXAgPSBwbC0+cGFja2V0c1swXS5kYl9idXMgfCAzOwoJCW9oY2kxMzk0X3dha2VfaXRfY3R4KHMtPmhvc3QtPm9oY2ksIHMtPmlzb190YXNrbGV0LmNvbnRleHQpOwoJfQoJZWxzZQoJCXN0cmVhbV9zdGFydF9kbWEocywgcGwpOwp9CgpzdGF0aWMgdm9pZCBzdHJlYW1fc2hpZnRfcGFja2V0X2xpc3RzKHVuc2lnbmVkIGxvbmcgbCkKewoJc3RydWN0IHN0cmVhbSAqcyA9IChzdHJ1Y3Qgc3RyZWFtICopIGw7CglzdHJ1Y3QgcGFja2V0X2xpc3QgKnBsOwoJc3RydWN0IHBhY2tldCAqbGFzdDsKCWludCBkaWZmOwoKCWlmIChsaXN0X2VtcHR5KCZzLT5kbWFfcGFja2V0X2xpc3RzKSkgewoJCUhQU0JfRVJSKCJlbXB0eSBkbWFfcGFja2V0X2xpc3RzIGluICVzIiwgX19GVU5DVElPTl9fKTsKCQlyZXR1cm47Cgl9CgoJLyogTm93IHRoYXQgd2Uga25vdyB0aGUgbGlzdCBpcyBub24tZW1wdHksIHdlIGNhbiBnZXQgdGhlIGhlYWQKCSAqIG9mIHRoZSBsaXN0IHdpdGhvdXQgbG9ja2luZywgYmVjYXVzZSB0aGUgcHJvY2VzcyBjb250ZXh0CgkgKiBvbmx5IGFkZHMgdG8gdGhlIHRhaWwuCgkgKi8KCXBsID0gbGlzdF9lbnRyeShzLT5kbWFfcGFja2V0X2xpc3RzLm5leHQsIHN0cnVjdCBwYWNrZXRfbGlzdCwgbGluayk7CglsYXN0ID0gJnBsLT5wYWNrZXRzW1BBQ0tFVF9MSVNUX1NJWkUgLSAxXTsKCgkvKiBUaGlzIGlzIHdlaXJkLi4uIGlmIHdlIHN0b3AgZG1hIHByb2Nlc3NpbmcgaW4gdGhlIG1pZGRsZSBvZgoJICogYSBwYWNrZXQgbGlzdCwgdGhlIGRtYSBjb250ZXh0IGltbWVkaWF0ZWx5IGdlbmVyYXRlcyBhbgoJICogaW50ZXJydXB0IGlmIHdlIGVuYWJsZSBpdCBhZ2FpbiBsYXRlci4gIFRoaXMgb25seSBoYXBwZW5zCgkgKiB3aGVuIGFtZHRwX3JlbGVhc2UgaXMgaW50ZXJydXB0ZWQgd2hpbGUgd2FpdGluZyBmb3IgZG1hIHRvCgkgKiBjb21wbGV0ZSwgdGhvdWdoLiAgQW55d2F5LCB3ZSBkZXRlY3QgdGhpcyBieSBzZWVpbmcgdGhhdAoJICogdGhlIHN0YXR1cyBvZiB0aGUgZG1hIGRlc2NyaXB0b3IgdGhhdCB3ZSBleHBlY3RlZCBhbgoJICogaW50ZXJydXB0IGZyb20gaXMgc3RpbGwgMC4KCSAqLwoJaWYgKGxhc3QtPmRiLT5wYXlsb2FkX2Rlc2Muc3RhdHVzID09IDApIHsKCQlIUFNCX0lORk8oIndlaXJkIGludGVycnVwdC4uLiIpOwoJCXJldHVybjsKCX0KCgkvKiBJZiB0aGUgbGFzdCBkZXNjcmlwdG9yIGJsb2NrIGRvZXMgbm90IHNwZWNpZnkgYSBicmFuY2gKCSAqIGFkZHJlc3MsIHdlIGhhdmUgYSBzYW1wbGUgdW5kZXJmbG93LgoJICovCglpZiAobGFzdC0+ZGItPnBheWxvYWRfZGVzYy5icmFuY2ggPT0gMCkKCQlIUFNCX0lORk8oIkZJWE1FOiBzYW1wbGUgdW5kZXJmbG93Li4uIik7CgoJLyogSGVyZSB3ZSBjaGVjayB3aGVuICh3aGljaCBjeWNsZSkgdGhlIGxhc3QgcGFja2V0IHdhcyBzZW50CgkgKiBhbmQgY29tcGFyZSBpdCB0byB3aGF0IHRoZSBpc28gcGFja2VyIHdhcyB1c2luZyBhdCB0aGUKCSAqIHRpbWUuICBJZiB0aGVyZSBpcyBhIG1pc21hdGNoLCB3ZSBhZGp1c3QgdGhlIGN5Y2xlIGNvdW50IGluCgkgKiB0aGUgaXNvIHBhY2tlci4gIEhvd2V2ZXIsIHRoZXJlIGFyZSBzdGlsbCB1cCB0bwoJICogTUFYX1BBQ0tFVF9MSVNUUyBwYWNrZXQgbGlzdHMgcXVldWVkIHdpdGggYmFkIHRpbWUgc3RhbXBzLAoJICogc28gd2UgZGlzYWJsZSB0aW1lIHN0YW1wIG1vbml0b3JpbmcgZm9yIHRoZSBuZXh0CgkgKiBNQVhfUEFDS0VUX0xJU1RTIHBhY2tldCBsaXN0cy4KCSAqLwoJZGlmZiA9IChsYXN0LT5kYi0+cGF5bG9hZF9kZXNjLnN0YXR1cyAtIHBsLT5sYXN0X2N5Y2xlX2NvdW50KSAmIDB4ZjsKCWlmIChkaWZmID4gMCAmJiBzLT5zdGFsZV9jb3VudCA9PSAwKSB7CgkJYXRvbWljX2FkZChkaWZmLCAmcy0+Y3ljbGVfY291bnQpOwoJCWF0b21pY19hZGQoZGlmZiwgJnMtPmN5Y2xlX2NvdW50Mik7CgkJcy0+c3RhbGVfY291bnQgPSBNQVhfUEFDS0VUX0xJU1RTOwoJfQoKCWlmIChzLT5zdGFsZV9jb3VudCA+IDApCgkJcy0+c3RhbGVfY291bnQtLTsKCgkvKiBGaW5hbGx5LCB3ZSBtb3ZlIHRoZSBwYWNrZXQgbGlzdCB0aGF0IHdhcyBqdXN0IHByb2Nlc3NlZAoJICogYmFjayB0byB0aGUgZnJlZSBsaXN0LCBhbmQgbm90aWZ5IGFueSB3YWl0ZXJzLgoJICovCglzcGluX2xvY2soJnMtPnBhY2tldF9saXN0X2xvY2spOwoJbGlzdF9kZWwoJnBsLT5saW5rKTsKCWxpc3RfYWRkX3RhaWwoJnBsLT5saW5rLCAmcy0+ZnJlZV9wYWNrZXRfbGlzdHMpOwoJc3Bpbl91bmxvY2soJnMtPnBhY2tldF9saXN0X2xvY2spOwoKCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmcy0+cGFja2V0X2xpc3Rfd2FpdCk7Cn0KCnN0YXRpYyBzdHJ1Y3QgcGFja2V0ICpzdHJlYW1fY3VycmVudF9wYWNrZXQoc3RydWN0IHN0cmVhbSAqcykKewoJaWYgKHMtPmN1cnJlbnRfcGFja2V0X2xpc3QgPT0gTlVMTCAmJgoJICAgIChzLT5jdXJyZW50X3BhY2tldF9saXN0ID0gc3RyZWFtX2dldF9mcmVlX3BhY2tldF9saXN0KHMpKSA9PSBOVUxMKQoJCXJldHVybiBOVUxMOwoKCXJldHVybiAmcy0+Y3VycmVudF9wYWNrZXRfbGlzdC0+cGFja2V0c1tzLT5jdXJyZW50X3BhY2tldF07Cn0KCnN0YXRpYyB2b2lkIHN0cmVhbV9xdWV1ZV9wYWNrZXQoc3RydWN0IHN0cmVhbSAqcykKewoJcy0+Y3VycmVudF9wYWNrZXQrKzsKCWlmIChzLT5jdXJyZW50X3BhY2tldCA9PSBQQUNLRVRfTElTVF9TSVpFKSB7CgkJc3RyZWFtX3B1dF9kbWFfcGFja2V0X2xpc3Qocywgcy0+Y3VycmVudF9wYWNrZXRfbGlzdCk7CgkJcy0+Y3VycmVudF9wYWNrZXRfbGlzdCA9IE5VTEw7CgkJcy0+Y3VycmVudF9wYWNrZXQgPSAwOwoJfQp9CgovKiBJbnRlZ2VyIGZyYWN0aW9uYWwgbWF0aC4gIFdoZW4gd2UgdHJhbnNtaXQgYSA0NGsxSHogc2lnbmFsIHdlIG11c3QKICogc2VuZCA1IDQxLzgwIHNhbXBsZXMgcGVyIGlzb2Nocm9ub3VzIGN5Y2xlLCBhcyB0aGVzZSBvY2N1ciA4MDAwCiAqIHRpbWVzIGEgc2Vjb25kLiAgT2YgY291cnNlLCB3ZSBtdXN0IHNlbmQgYW4gaW50ZWdyYWwgbnVtYmVyIG9mCiAqIHNhbXBsZXMgaW4gYSBwYWNrZXQsIHNvIHdlIHVzZSB0aGUgaW50ZWdlciBtYXRoIHRvIGFsdGVybmF0ZQogKiBiZXR3ZWVuIHNlbmRpbmcgNSBhbmQgNiBzYW1wbGVzIHBlciBwYWNrZXQuCiAqLwoKc3RhdGljIHZvaWQgZnJhY3Rpb25faW5pdChzdHJ1Y3QgZnJhY3Rpb24gKmYsIGludCBudW1lcmF0b3IsIGludCBkZW5vbWluYXRvcikKewoJZi0+aW50ZWdlciA9IG51bWVyYXRvciAvIGRlbm9taW5hdG9yOwoJZi0+bnVtZXJhdG9yID0gbnVtZXJhdG9yICUgZGVub21pbmF0b3I7CglmLT5kZW5vbWluYXRvciA9IGRlbm9taW5hdG9yOwp9CgpzdGF0aWMgX19pbmxpbmVfXyB2b2lkIGZyYWN0aW9uX2FkZChzdHJ1Y3QgZnJhY3Rpb24gKmRzdCwKCQkJCSAgICBzdHJ1Y3QgZnJhY3Rpb24gKnNyYzEsCgkJCQkgICAgc3RydWN0IGZyYWN0aW9uICpzcmMyKQp7CgkvKiBhc3NlcnQ6IHNyYzEtPmRlbm9taW5hdG9yID09IHNyYzItPmRlbm9taW5hdG9yICovCgoJaW50IHN1bSwgZGVub207CgoJLyogV2UgdXNlIHRoZXNlIHR3byBsb2NhbCB2YXJpYWJsZXMgdG8gYWxsb3cgZ2NjIHRvIG9wdGltaXplCgkgKiB0aGUgZGl2aXNpb24gYW5kIHRoZSBtb2R1bG8gaW50byBvbmx5IG9uZSBkaXZpc2lvbi4gKi8KCglzdW0gPSBzcmMxLT5udW1lcmF0b3IgKyBzcmMyLT5udW1lcmF0b3I7CglkZW5vbSA9IHNyYzEtPmRlbm9taW5hdG9yOwoJZHN0LT5pbnRlZ2VyID0gc3JjMS0+aW50ZWdlciArIHNyYzItPmludGVnZXIgKyBzdW0gLyBkZW5vbTsKCWRzdC0+bnVtZXJhdG9yID0gc3VtICUgZGVub207Cglkc3QtPmRlbm9taW5hdG9yID0gZGVub207Cn0KCnN0YXRpYyBfX2lubGluZV9fIHZvaWQgZnJhY3Rpb25fc3ViX2ludChzdHJ1Y3QgZnJhY3Rpb24gKmRzdCwKCQkJCQlzdHJ1Y3QgZnJhY3Rpb24gKnNyYywgaW50IGludGVnZXIpCnsKCWRzdC0+aW50ZWdlciA9IHNyYy0+aW50ZWdlciAtIGludGVnZXI7Cglkc3QtPm51bWVyYXRvciA9IHNyYy0+bnVtZXJhdG9yOwoJZHN0LT5kZW5vbWluYXRvciA9IHNyYy0+ZGVub21pbmF0b3I7Cn0KCnN0YXRpYyBfX2lubGluZV9fIGludCBmcmFjdGlvbl9mbG9vcihzdHJ1Y3QgZnJhY3Rpb24gKmZyYWMpCnsKCXJldHVybiBmcmFjLT5pbnRlZ2VyOwp9CgpzdGF0aWMgX19pbmxpbmVfXyBpbnQgZnJhY3Rpb25fY2VpbChzdHJ1Y3QgZnJhY3Rpb24gKmZyYWMpCnsKCXJldHVybiBmcmFjLT5pbnRlZ2VyICsgKGZyYWMtPm51bWVyYXRvciA+IDAgPyAxIDogMCk7Cn0KCnN0YXRpYyB2b2lkIHBhY2tldF9pbml0aWFsaXplKHN0cnVjdCBwYWNrZXQgKnAsIHN0cnVjdCBwYWNrZXQgKm5leHQpCnsKCS8qIEhlcmUgd2UgaW5pdGlhbGl6ZSB0aGUgZG1hIGRlc2NyaXB0b3IgYmxvY2sgZm9yCgkgKiB0cmFuc2ZlcnJpbmcgb25lIGlzbyBwYWNrZXQuICBXZSB1c2UgdHdvIGRlc2NyaXB0b3JzIHBlcgoJICogcGFja2V0OiBhbiBPVVRQVVRfTU9SRV9JTU1NRURJQVRFIGRlc2NyaXB0b3IgZm9yIHRoZQoJICogSUVFRTEzOTQgaXNvIHBhY2tldCBoZWFkZXIgYW5kIGFuIE9VVFBVVF9MQVNUIGRlc2NyaXB0b3IKCSAqIGZvciB0aGUgcGF5bG9hZC4KCSAqLwoKCXAtPmRiLT5oZWFkZXJfZGVzYy5jb250cm9sID0KCQlETUFfQ1RMX09VVFBVVF9NT1JFIHwgRE1BX0NUTF9JTU1FRElBVEUgfCA4OwoKCWlmIChuZXh0KSB7CgkJcC0+ZGItPnBheWxvYWRfZGVzYy5jb250cm9sID0KCQkJRE1BX0NUTF9PVVRQVVRfTEFTVCB8IERNQV9DVExfQlJBTkNIOwoJCXAtPmRiLT5wYXlsb2FkX2Rlc2MuYnJhbmNoID0gbmV4dC0+ZGJfYnVzIHwgMzsKCQlwLT5kYi0+aGVhZGVyX2Rlc2Muc2tpcCA9IG5leHQtPmRiX2J1cyB8IDM7Cgl9CgllbHNlIHsKCQlwLT5kYi0+cGF5bG9hZF9kZXNjLmNvbnRyb2wgPQoJCQlETUFfQ1RMX09VVFBVVF9MQVNUIHwgRE1BX0NUTF9CUkFOQ0ggfAoJCQlETUFfQ1RMX1VQREFURSB8IERNQV9DVExfSVJROwoJCXAtPmRiLT5wYXlsb2FkX2Rlc2MuYnJhbmNoID0gMDsKCQlwLT5kYi0+aGVhZGVyX2Rlc2Muc2tpcCA9IDA7Cgl9CglwLT5kYi0+cGF5bG9hZF9kZXNjLmRhdGFfYWRkcmVzcyA9IHAtPnBheWxvYWRfYnVzOwoJcC0+ZGItPnBheWxvYWRfZGVzYy5zdGF0dXMgPSAwOwp9CgpzdGF0aWMgc3RydWN0IHBhY2tldF9saXN0ICpwYWNrZXRfbGlzdF9hbGxvYyhzdHJ1Y3Qgc3RyZWFtICpzKQp7CglpbnQgaTsKCXN0cnVjdCBwYWNrZXRfbGlzdCAqcGw7CglzdHJ1Y3QgcGFja2V0ICpuZXh0OwoKCXBsID0ga21hbGxvYyhzaXplb2YgKnBsLCBTTEFCX0tFUk5FTCk7CglpZiAocGwgPT0gTlVMTCkKCQlyZXR1cm4gTlVMTDsKCglmb3IgKGkgPSAwOyBpIDwgUEFDS0VUX0xJU1RfU0laRTsgaSsrKSB7CgkJc3RydWN0IHBhY2tldCAqcCA9ICZwbC0+cGFja2V0c1tpXTsKCQlwLT5kYiA9IHBjaV9wb29sX2FsbG9jKHMtPmRlc2NyaXB0b3JfcG9vbCwgU0xBQl9LRVJORUwsCgkJCQkgICAgICAgJnAtPmRiX2J1cyk7CgkJcC0+cGF5bG9hZCA9IHBjaV9wb29sX2FsbG9jKHMtPnBhY2tldF9wb29sLCBTTEFCX0tFUk5FTCwKCQkJCQkgICAgJnAtPnBheWxvYWRfYnVzKTsKCX0KCglmb3IgKGkgPSAwOyBpIDwgUEFDS0VUX0xJU1RfU0laRTsgaSsrKSB7CgkJaWYgKGkgPCBQQUNLRVRfTElTVF9TSVpFIC0gMSkKCQkJbmV4dCA9ICZwbC0+cGFja2V0c1tpICsgMV07CgkJZWxzZQoJCQluZXh0ID0gTlVMTDsKCQlwYWNrZXRfaW5pdGlhbGl6ZSgmcGwtPnBhY2tldHNbaV0sIG5leHQpOwoJfQoKCXJldHVybiBwbDsKfQoKc3RhdGljIHZvaWQgcGFja2V0X2xpc3RfZnJlZShzdHJ1Y3QgcGFja2V0X2xpc3QgKnBsLCBzdHJ1Y3Qgc3RyZWFtICpzKQp7CglpbnQgaTsKCglmb3IgKGkgPSAwOyBpIDwgUEFDS0VUX0xJU1RfU0laRTsgaSsrKSB7CgkJc3RydWN0IHBhY2tldCAqcCA9ICZwbC0+cGFja2V0c1tpXTsKCQlwY2lfcG9vbF9mcmVlKHMtPmRlc2NyaXB0b3JfcG9vbCwgcC0+ZGIsIHAtPmRiX2J1cyk7CgkJcGNpX3Bvb2xfZnJlZShzLT5wYWNrZXRfcG9vbCwgcC0+cGF5bG9hZCwgcC0+cGF5bG9hZF9idXMpOwoJfQoJa2ZyZWUocGwpOwp9CgpzdGF0aWMgc3RydWN0IGJ1ZmZlciAqYnVmZmVyX2FsbG9jKGludCBzaXplKQp7CglzdHJ1Y3QgYnVmZmVyICpiOwoKCWIgPSBrbWFsbG9jKHNpemVvZiAqYiArIHNpemUsIFNMQUJfS0VSTkVMKTsKCWlmIChiID09IE5VTEwpCgkJcmV0dXJuIE5VTEw7CgliLT5oZWFkID0gMDsKCWItPnRhaWwgPSAwOwoJYi0+bGVuZ3RoID0gMDsKCWItPnNpemUgPSBzaXplOwoKCXJldHVybiBiOwp9CgpzdGF0aWMgdW5zaWduZWQgY2hhciAqYnVmZmVyX2dldF9ieXRlcyhzdHJ1Y3QgYnVmZmVyICpidWZmZXIsIGludCBzaXplKQp7Cgl1bnNpZ25lZCBjaGFyICpwOwoKCWlmIChidWZmZXItPmhlYWQgKyBzaXplID4gYnVmZmVyLT5zaXplKQoJCUJVRygpOwoKCXAgPSAmYnVmZmVyLT5kYXRhW2J1ZmZlci0+aGVhZF07CglidWZmZXItPmhlYWQgKz0gc2l6ZTsKCWlmIChidWZmZXItPmhlYWQgPT0gYnVmZmVyLT5zaXplKQoJCWJ1ZmZlci0+aGVhZCA9IDA7CglidWZmZXItPmxlbmd0aCAtPSBzaXplOwoKCXJldHVybiBwOwp9CgpzdGF0aWMgdW5zaWduZWQgY2hhciAqYnVmZmVyX3B1dF9ieXRlcyhzdHJ1Y3QgYnVmZmVyICpidWZmZXIsCgkJCQkgICAgICAgc2l6ZV90IG1heCwgc2l6ZV90ICphY3R1YWwpCnsKCXNpemVfdCBsZW5ndGg7Cgl1bnNpZ25lZCBjaGFyICpwOwoKCXAgPSAmYnVmZmVyLT5kYXRhW2J1ZmZlci0+dGFpbF07CglsZW5ndGggPSBtaW4oYnVmZmVyLT5zaXplIC0gYnVmZmVyLT5sZW5ndGgsIG1heCk7CglpZiAoYnVmZmVyLT50YWlsICsgbGVuZ3RoIDwgYnVmZmVyLT5zaXplKSB7CgkJKmFjdHVhbCA9IGxlbmd0aDsKCQlidWZmZXItPnRhaWwgKz0gbGVuZ3RoOwoJfQoJZWxzZSB7CgkJKmFjdHVhbCA9IGJ1ZmZlci0+c2l6ZSAtIGJ1ZmZlci0+dGFpbDsKCQkgYnVmZmVyLT50YWlsID0gMDsKCX0KCglidWZmZXItPmxlbmd0aCArPSAqYWN0dWFsOwoJcmV0dXJuIHA7Cn0KCnN0YXRpYyB1MzIgZ2V0X2llYzk1OF9oZWFkZXJfYml0cyhzdHJ1Y3Qgc3RyZWFtICpzLCBpbnQgc3ViX2ZyYW1lLCB1MzIgc2FtcGxlKQp7CglpbnQgY3NpLCBwYXJpdHksIHNoaWZ0OwoJaW50IGJsb2NrX3N0YXJ0OwoJdTMyIGJpdHM7CgoJc3dpdGNoIChzLT5pZWM5NThfZnJhbWVfY291bnQpIHsKCWNhc2UgMToKCQljc2kgPSBzLT5mb3JtYXQgPT0gQU1EVFBfRk9STUFUX0lFQzk1OF9BQzM7CgkJYnJlYWs7CgljYXNlIDI6CgljYXNlIDk6CgkJY3NpID0gMTsKCQlicmVhazsKCWNhc2UgMjQgLi4uIDI3OgoJCWNzaSA9IChzLT5pZWM5NThfcmF0ZV9jb2RlID4+ICgyNyAtIHMtPmllYzk1OF9mcmFtZV9jb3VudCkpICYgMHgwMTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJY3NpID0gMDsKCQlicmVhazsKCX0KCglibG9ja19zdGFydCA9IChzLT5pZWM5NThfZnJhbWVfY291bnQgPT0gMCAmJiBzdWJfZnJhbWUgPT0gMCk7CgoJLyogVGhlIHBhcml0eSBiaXQgaXMgdGhlIHhvciBvZiB0aGUgc2FtcGxlIGJpdHMgYW5kIHRoZQoJICogY2hhbm5lbCBzdGF0dXMgaW5mbyBiaXQuICovCglmb3IgKHNoaWZ0ID0gMTYsIHBhcml0eSA9IHNhbXBsZSBeIGNzaTsgc2hpZnQgPiAwOyBzaGlmdCA+Pj0gMSkKCQlwYXJpdHkgXj0gKHBhcml0eSA+PiBzaGlmdCk7CgoJYml0cyA9ICAoYmxvY2tfc3RhcnQgPDwgNSkgfAkJLyogQmxvY2sgc3RhcnQgYml0ICovCgkJKChzdWJfZnJhbWUgPT0gMCkgPDwgNCkgfAkvKiBTdWJmcmFtZSBiaXQgKi8KCQkoKHBhcml0eSAmIDEpIDw8IDMpIHwJCS8qIFBhcml0eSBiaXQgKi8KCQkoY3NpIDw8IDIpOwkJCS8qIENoYW5uZWwgc3RhdHVzIGluZm8gYml0ICovCgoJcmV0dXJuIGJpdHM7Cn0KCnN0YXRpYyB1MzIgZ2V0X2hlYWRlcl9iaXRzKHN0cnVjdCBzdHJlYW0gKnMsIGludCBzdWJfZnJhbWUsIHUzMiBzYW1wbGUpCnsKCXN3aXRjaCAocy0+Zm9ybWF0KSB7CgljYXNlIEFNRFRQX0ZPUk1BVF9JRUM5NThfUENNOgoJY2FzZSBBTURUUF9GT1JNQVRfSUVDOTU4X0FDMzoKCQlyZXR1cm4gZ2V0X2llYzk1OF9oZWFkZXJfYml0cyhzLCBzdWJfZnJhbWUsIHNhbXBsZSk7CgoJY2FzZSBBTURUUF9GT1JNQVRfUkFXOgoJCXJldHVybiAweDQwOwoKCWRlZmF1bHQ6CgkJcmV0dXJuIDA7Cgl9Cn0KCnN0YXRpYyB2b2lkIGZpbGxfcGF5bG9hZF9sZTE2KHN0cnVjdCBzdHJlYW0gKnMsIHF1YWRsZXRfdCAqZGF0YSwgaW50IG5ldmVudHMpCnsKCXF1YWRsZXRfdCAqZXZlbnQsIHNhbXBsZSwgYml0czsKCXVuc2lnbmVkIGNoYXIgKnA7CglpbnQgaSwgajsKCglmb3IgKGkgPSAwLCBldmVudCA9IGRhdGE7IGkgPCBuZXZlbnRzOyBpKyspIHsKCgkJZm9yIChqID0gMDsgaiA8IHMtPmRpbWVuc2lvbjsgaisrKSB7CgkJCXAgPSBidWZmZXJfZ2V0X2J5dGVzKHMtPmlucHV0LCAyKTsKCQkJc2FtcGxlID0gKHBbMV0gPDwgMTYpIHwgKHBbMF0gPDwgOCk7CgkJCWJpdHMgPSBnZXRfaGVhZGVyX2JpdHMocywgaiwgc2FtcGxlKTsKCQkJZXZlbnRbal0gPSBjcHVfdG9fYmUzMigoYml0cyA8PCAyNCkgfCBzYW1wbGUpOwoJCX0KCgkJZXZlbnQgKz0gcy0+ZGltZW5zaW9uOwoJCWlmICgrK3MtPmllYzk1OF9mcmFtZV9jb3VudCA9PSAxOTIpCgkJCXMtPmllYzk1OF9mcmFtZV9jb3VudCA9IDA7Cgl9Cn0KCnN0YXRpYyB2b2lkIGZpbGxfcGFja2V0KHN0cnVjdCBzdHJlYW0gKnMsIHN0cnVjdCBwYWNrZXQgKnBhY2tldCwgaW50IG5ldmVudHMpCnsKCWludCBzeXRfaW5kZXgsIHN5dCwgc2l6ZTsKCXUzMiBjb250cm9sOwoKCXNpemUgPSAobmV2ZW50cyAqIHMtPmRpbWVuc2lvbiArIDIpICogc2l6ZW9mKHF1YWRsZXRfdCk7CgoJLyogVXBkYXRlIERNQSBkZXNjcmlwdG9ycyAqLwoJcGFja2V0LT5kYi0+cGF5bG9hZF9kZXNjLnN0YXR1cyA9IDA7Cgljb250cm9sID0gcGFja2V0LT5kYi0+cGF5bG9hZF9kZXNjLmNvbnRyb2wgJiAweGZmZmYwMDAwOwoJcGFja2V0LT5kYi0+cGF5bG9hZF9kZXNjLmNvbnRyb2wgPSBjb250cm9sIHwgc2l6ZTsKCgkvKiBGaWxsIElFRUUxMzk0IGhlYWRlcnMgKi8KCXBhY2tldC0+ZGItPmhlYWRlcl9kZXNjLmhlYWRlclswXSA9CgkJKElFRUUxMzk0X1NQRUVEXzEwMCA8PCAxNikgfCAoMHgwMSA8PCAxNCkgfAoJCShzLT5pc29fY2hhbm5lbCA8PCA4KSB8IChUQ09ERV9JU09fREFUQSA8PCA0KTsKCXBhY2tldC0+ZGItPmhlYWRlcl9kZXNjLmhlYWRlclsxXSA9IHNpemUgPDwgMTY7CgoJLyogQ2FsY3VsYXRlIHN5bmNocm9uaXphdGlvbiB0aW1lc3RhbXAgKHN5dCkuIEZpcnN0IHdlCgkgKiBkZXRlcm1pbmUgc3l0X2luZGV4LCB0aGF0IGlzLCB0aGUgaW5kZXggaW4gdGhlIHBhY2tldCBvZgoJICogdGhlIHNhbXBsZSBmb3Igd2hpY2ggdGhlIHRpbWVzdGFtcCBpcyB2YWxpZC4gKi8KCXN5dF9pbmRleCA9IChzLT5zeXRfaW50ZXJ2YWwgLSBzLT5kYmMpICYgKHMtPnN5dF9pbnRlcnZhbCAtIDEpOwoJaWYgKHN5dF9pbmRleCA8IG5ldmVudHMpIHsKCQlzeXQgPSAoKGF0b21pY19yZWFkKCZzLT5jeWNsZV9jb3VudCkgPDwgMTIpIHwKCQkgICAgICAgcy0+Y3ljbGVfb2Zmc2V0LmludGVnZXIpICYgMHhmZmZmOwoJCWZyYWN0aW9uX2FkZCgmcy0+Y3ljbGVfb2Zmc2V0LAoJCQkgICAgICZzLT5jeWNsZV9vZmZzZXQsICZzLT50aWNrc19wZXJfc3l0X29mZnNldCk7CgoJCS8qIFRoaXMgbmV4dCBhZGRpdGlvbiBzaG91bGQgYmUgbW9kdWxvIDgwMDAgKDB4MWY0MCksCgkJICogYnV0IHdlIG9ubHkgdXNlIHRoZSBsb3dlciA0IGJpdHMgb2YgY3ljbGVfY291bnQsIHNvCgkJICogd2UgZG9uJ3QgbmVlZCB0aGUgbW9kdWxvLiAqLwoJCWF0b21pY19hZGQocy0+Y3ljbGVfb2Zmc2V0LmludGVnZXIgLyAzMDcyLCAmcy0+Y3ljbGVfY291bnQpOwoJCXMtPmN5Y2xlX29mZnNldC5pbnRlZ2VyICU9IDMwNzI7Cgl9CgllbHNlCgkJc3l0ID0gMHhmZmZmOwoKCWF0b21pY19pbmMoJnMtPmN5Y2xlX2NvdW50Mik7CgoJLyogRmlsbCBjaXAgaGVhZGVyICovCglwYWNrZXQtPnBheWxvYWQtPmVvaDAgPSAwOwoJcGFja2V0LT5wYXlsb2FkLT5zaWQgPSBzLT5ob3N0LT5ob3N0LT5ub2RlX2lkICYgMHgzZjsKCXBhY2tldC0+cGF5bG9hZC0+ZGJzID0gcy0+ZGltZW5zaW9uOwoJcGFja2V0LT5wYXlsb2FkLT5mbiA9IDA7CglwYWNrZXQtPnBheWxvYWQtPnFwYyA9IDA7CglwYWNrZXQtPnBheWxvYWQtPnNwaCA9IDA7CglwYWNrZXQtPnBheWxvYWQtPnJlc2VydmVkID0gMDsKCXBhY2tldC0+cGF5bG9hZC0+ZGJjID0gcy0+ZGJjOwoJcGFja2V0LT5wYXlsb2FkLT5lb2gxID0gMjsKCXBhY2tldC0+cGF5bG9hZC0+Zm10ID0gRk1UX0FNRFRQOwoJcGFja2V0LT5wYXlsb2FkLT5mZGYgPSBzLT5mZGY7CglwYWNrZXQtPnBheWxvYWQtPnN5dCA9IGNwdV90b19iZTE2KHN5dCk7CgoJc3dpdGNoIChzLT5zYW1wbGVfZm9ybWF0KSB7CgljYXNlIEFNRFRQX0lOUFVUX0xFMTY6CgkJZmlsbF9wYXlsb2FkX2xlMTYocywgcGFja2V0LT5wYXlsb2FkLT5kYXRhLCBuZXZlbnRzKTsKCQlicmVhazsKCX0KCglzLT5kYmMgKz0gbmV2ZW50czsKfQoKc3RhdGljIHZvaWQgc3RyZWFtX2ZsdXNoKHN0cnVjdCBzdHJlYW0gKnMpCnsKCXN0cnVjdCBwYWNrZXQgKnA7CglpbnQgbmV2ZW50czsKCXN0cnVjdCBmcmFjdGlvbiBuZXh0OwoKCS8qIFRoZSBBTURUUCBzcGVjaWZpZXMgdHdvIHRyYW5zbWlzc2lvbiBtb2RlczogYmxvY2tpbmcgYW5kCgkgKiBub24tYmxvY2tpbmcuICBJbiBibG9ja2luZyBtb2RlIHlvdSBhbHdheXMgdHJhbnNmZXIKCSAqIHN5dF9pbnRlcnZhbCBvciB6ZXJvIHNhbXBsZXMsIHdoZXJlYXMgaW4gbm9uLWJsb2NraW5nIG1vZGUKCSAqIHlvdSBzZW5kIGFzIG1hbnkgc2FtcGxlcyBhcyB5b3UgaGF2ZSBhdmFpbGFibGUgYXQgdHJhbnNmZXIKCSAqIHRpbWUuCgkgKgoJICogVGhlIGZyYWN0aW9uIHNhbXBsZXNfcGVyX2N5Y2xlIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mCgkgKiBzYW1wbGVzIHRoYXQgYmVjb21lIGF2YWlsYWJsZSBwZXIgY3ljbGUuICBXZSBhZGQgdGhpcyB0bwoJICogdGhlIGZyYWN0aW9uIHJlYWR5X3NhbXBsZXMsIHdoaWNoIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mCgkgKiBsZWZ0b3ZlciBzYW1wbGVzIGZyb20gdGhlIHByZXZpb3VzIHRyYW5zbWlzc2lvbi4gIFRoZSBzdW0sCgkgKiBzdG9yZWQgaW4gdGhlIGZyYWN0aW9uIG5leHQsIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mCgkgKiBzYW1wbGVzIGF2YWlsYWJsZSBmb3IgdHJhbnNtaXNzaW9uLCBhbmQgZnJvbSB0aGlzIHdlCgkgKiBkZXRlcm1pbmUgdGhlIG51bWJlciBvZiBzYW1wbGVzIHRvIGFjdHVhbGx5IHRyYW5zbWl0LgoJICovCgoJd2hpbGUgKDEpIHsKCQlmcmFjdGlvbl9hZGQoJm5leHQsICZzLT5yZWFkeV9zYW1wbGVzLCAmcy0+c2FtcGxlc19wZXJfY3ljbGUpOwoJCWlmIChzLT5tb2RlID09IEFNRFRQX01PREVfQkxPQ0tJTkcpIHsKCQkJaWYgKGZyYWN0aW9uX2Zsb29yKCZuZXh0KSA+PSBzLT5zeXRfaW50ZXJ2YWwpCgkJCQluZXZlbnRzID0gcy0+c3l0X2ludGVydmFsOwoJCQllbHNlCgkJCQluZXZlbnRzID0gMDsKCQl9CgkJZWxzZQoJCQluZXZlbnRzID0gZnJhY3Rpb25fZmxvb3IoJm5leHQpOwoKCQlwID0gc3RyZWFtX2N1cnJlbnRfcGFja2V0KHMpOwoJCWlmIChzLT5pbnB1dC0+bGVuZ3RoIDwgbmV2ZW50cyAqIHMtPmRpbWVuc2lvbiAqIDIgfHwgcCA9PSBOVUxMKQoJCQlicmVhazsKCgkJZmlsbF9wYWNrZXQocywgcCwgbmV2ZW50cyk7CgkJc3RyZWFtX3F1ZXVlX3BhY2tldChzKTsKCgkJLyogTm93IHRoYXQgd2UgaGF2ZSBzdWNjZXNzZnVsbHkgcXVldWVkIHRoZSBwYWNrZXQgZm9yCgkJICogdHJhbnNtaXNzaW9uLCB3ZSB1cGRhdGUgdGhlIGZyYWN0aW9uIHJlYWR5X3NhbXBsZXMuICovCgkJZnJhY3Rpb25fc3ViX2ludCgmcy0+cmVhZHlfc2FtcGxlcywgJm5leHQsIG5ldmVudHMpOwoJfQp9CgpzdGF0aWMgaW50IHN0cmVhbV9hbGxvY19wYWNrZXRfbGlzdHMoc3RydWN0IHN0cmVhbSAqcykKewoJaW50IG1heF9uZXZlbnRzLCBtYXhfcGFja2V0X3NpemUsIGk7CgoJaWYgKHMtPm1vZGUgPT0gQU1EVFBfTU9ERV9CTE9DS0lORykKCQltYXhfbmV2ZW50cyA9IHMtPnN5dF9pbnRlcnZhbDsKCWVsc2UKCQltYXhfbmV2ZW50cyA9IGZyYWN0aW9uX2NlaWwoJnMtPnNhbXBsZXNfcGVyX2N5Y2xlKTsKCgltYXhfcGFja2V0X3NpemUgPSBtYXhfbmV2ZW50cyAqIHMtPmRpbWVuc2lvbiAqIDQgKyA4OwoJcy0+cGFja2V0X3Bvb2wgPSBwY2lfcG9vbF9jcmVhdGUoInBhY2tldCBwb29sIiwgcy0+aG9zdC0+b2hjaS0+ZGV2LAoJCQkJCSBtYXhfcGFja2V0X3NpemUsIDAsIDApOwoKCWlmIChzLT5wYWNrZXRfcG9vbCA9PSBOVUxMKQoJCXJldHVybiAtMTsKCglJTklUX0xJU1RfSEVBRCgmcy0+ZnJlZV9wYWNrZXRfbGlzdHMpOwoJSU5JVF9MSVNUX0hFQUQoJnMtPmRtYV9wYWNrZXRfbGlzdHMpOwoJZm9yIChpID0gMDsgaSA8IE1BWF9QQUNLRVRfTElTVFM7IGkrKykgewoJCXN0cnVjdCBwYWNrZXRfbGlzdCAqcGwgPSBwYWNrZXRfbGlzdF9hbGxvYyhzKTsKCQlpZiAocGwgPT0gTlVMTCkKCQkJYnJlYWs7CgkJbGlzdF9hZGRfdGFpbCgmcGwtPmxpbmssICZzLT5mcmVlX3BhY2tldF9saXN0cyk7Cgl9CgoJcmV0dXJuIGkgPCBNQVhfUEFDS0VUX0xJU1RTID8gLTEgOiAwOwp9CgpzdGF0aWMgdm9pZCBzdHJlYW1fZnJlZV9wYWNrZXRfbGlzdHMoc3RydWN0IHN0cmVhbSAqcykKewoJc3RydWN0IHBhY2tldF9saXN0ICpwYWNrZXRfbCwgKnBhY2tldF9sX25leHQ7CgoJaWYgKHMtPmN1cnJlbnRfcGFja2V0X2xpc3QgIT0gTlVMTCkKCQlwYWNrZXRfbGlzdF9mcmVlKHMtPmN1cnJlbnRfcGFja2V0X2xpc3QsIHMpOwoJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHBhY2tldF9sLCBwYWNrZXRfbF9uZXh0LCAmcy0+ZG1hX3BhY2tldF9saXN0cywgbGluaykKCQlwYWNrZXRfbGlzdF9mcmVlKHBhY2tldF9sLCBzKTsKCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwYWNrZXRfbCwgcGFja2V0X2xfbmV4dCwgJnMtPmZyZWVfcGFja2V0X2xpc3RzLCBsaW5rKQoJCXBhY2tldF9saXN0X2ZyZWUocGFja2V0X2wsIHMpOwoJaWYgKHMtPnBhY2tldF9wb29sICE9IE5VTEwpCgkJcGNpX3Bvb2xfZGVzdHJveShzLT5wYWNrZXRfcG9vbCk7CgoJcy0+Y3VycmVudF9wYWNrZXRfbGlzdCA9IE5VTEw7CglJTklUX0xJU1RfSEVBRCgmcy0+ZnJlZV9wYWNrZXRfbGlzdHMpOwoJSU5JVF9MSVNUX0hFQUQoJnMtPmRtYV9wYWNrZXRfbGlzdHMpOwoJcy0+cGFja2V0X3Bvb2wgPSBOVUxMOwp9CgpzdGF0aWMgdm9pZCBwbHVnX3VwZGF0ZShzdHJ1Y3QgY21wX3BjciAqcGx1Zywgdm9pZCAqZGF0YSkKewoJc3RydWN0IHN0cmVhbSAqcyA9IGRhdGE7CgoJSFBTQl9JTkZPKCJwbHVnIHVwZGF0ZTogcDJwX2NvdW50PSVkLCBjaGFubmVsPSVkIiwKCQkgIHBsdWctPnAycF9jb3VudCwgcGx1Zy0+Y2hhbm5lbCk7CglzLT5pc29fY2hhbm5lbCA9IHBsdWctPmNoYW5uZWw7CglpZiAocGx1Zy0+cDJwX2NvdW50ID4gMCkgewoJCXN0cnVjdCBwYWNrZXRfbGlzdCAqcGw7CgoJCXBsID0gbGlzdF9lbnRyeShzLT5kbWFfcGFja2V0X2xpc3RzLm5leHQsIHN0cnVjdCBwYWNrZXRfbGlzdCwgbGluayk7CgkJc3RyZWFtX3N0YXJ0X2RtYShzLCBwbCk7Cgl9CgllbHNlIHsKCQlvaGNpMTM5NF9zdG9wX2l0X2N0eChzLT5ob3N0LT5vaGNpLCBzLT5pc29fdGFza2xldC5jb250ZXh0LCAwKTsKCX0KfQoKc3RhdGljIGludCBzdHJlYW1fY29uZmlndXJlKHN0cnVjdCBzdHJlYW0gKnMsIGludCBjbWQsIHN0cnVjdCBhbWR0cF9pb2N0bCAqY2ZnKQp7Cgljb25zdCBpbnQgdHJhbnNmZXJfZGVsYXkgPSA5MDAwOwoKCWlmIChjZmctPmZvcm1hdCA8PSBBTURUUF9GT1JNQVRfSUVDOTU4X0FDMykKCQlzLT5mb3JtYXQgPSBjZmctPmZvcm1hdDsKCWVsc2UKCQlyZXR1cm4gLUVJTlZBTDsKCglzd2l0Y2ggKGNmZy0+cmF0ZSkgewoJY2FzZSAzMjAwMDoKCQlzLT5zeXRfaW50ZXJ2YWwgPSA4OwoJCXMtPmZkZiA9IEZERl9TRkNfMzJLSFo7CgkJcy0+aWVjOTU4X3JhdGVfY29kZSA9IDB4MGM7CgkJYnJlYWs7CgljYXNlIDQ0MTAwOgoJCXMtPnN5dF9pbnRlcnZhbCA9IDg7CgkJcy0+ZmRmID0gRkRGX1NGQ180NEsxSFo7CgkJcy0+aWVjOTU4X3JhdGVfY29kZSA9IDB4MDA7CgkJYnJlYWs7CgljYXNlIDQ4MDAwOgoJCXMtPnN5dF9pbnRlcnZhbCA9IDg7CgkJcy0+ZmRmID0gRkRGX1NGQ180OEtIWjsKCQlzLT5pZWM5NThfcmF0ZV9jb2RlID0gMHgwNDsKCQlicmVhazsKCWNhc2UgODgyMDA6CgkJcy0+c3l0X2ludGVydmFsID0gMTY7CgkJcy0+ZmRmID0gRkRGX1NGQ184OEsySFo7CgkJcy0+aWVjOTU4X3JhdGVfY29kZSA9IDB4MDA7CgkJYnJlYWs7CgljYXNlIDk2MDAwOgoJCXMtPnN5dF9pbnRlcnZhbCA9IDE2OwoJCXMtPmZkZiA9IEZERl9TRkNfOTZLSFo7CgkJcy0+aWVjOTU4X3JhdGVfY29kZSA9IDB4MDA7CgkJYnJlYWs7CgljYXNlIDE3NjQwMDoKCQlzLT5zeXRfaW50ZXJ2YWwgPSAzMjsKCQlzLT5mZGYgPSBGREZfU0ZDXzE3Nks0SFo7CgkJcy0+aWVjOTU4X3JhdGVfY29kZSA9IDB4MDA7CgkJYnJlYWs7CgljYXNlIDE5MjAwMDoKCQlzLT5zeXRfaW50ZXJ2YWwgPSAzMjsKCQlzLT5mZGYgPSBGREZfU0ZDXzE5MktIWjsKCQlzLT5pZWM5NThfcmF0ZV9jb2RlID0gMHgwMDsKCQlicmVhazsKCglkZWZhdWx0OgoJCXJldHVybiAtRUlOVkFMOwoJfQoKCXMtPnJhdGUgPSBjZmctPnJhdGU7CglmcmFjdGlvbl9pbml0KCZzLT5zYW1wbGVzX3Blcl9jeWNsZSwgcy0+cmF0ZSwgODAwMCk7CglmcmFjdGlvbl9pbml0KCZzLT5yZWFkeV9zYW1wbGVzLCAwLCA4MDAwKTsKCgkvKiBUaGUgdGlja3NfcGVyX3N5dF9vZmZzZXQgaXMgaW5pdGlhbGl6ZWQgdG8gdGhlIG51bWJlciBvZgoJICogdGlja3MgYmV0d2VlbiBzeXRfaW50ZXJ2YWwgZXZlbnRzLiAgVGhlIG51bWJlciBvZiB0aWNrcyBwZXIKCSAqIHNlY29uZCBpcyAyNC41NzZlNiwgc28gdGhlIG51bWJlciBvZiB0aWNrcyBiZXR3ZWVuCgkgKiBzeXRfaW50ZXJ2YWwgZXZlbnRzIGlzIDI0LjU3NmU2ICogc3l0X2ludGVydmFsIC8gcmF0ZS4KCSAqLwoJZnJhY3Rpb25faW5pdCgmcy0+dGlja3NfcGVyX3N5dF9vZmZzZXQsCgkJICAgICAgMjQ1NzYwMDAgKiBzLT5zeXRfaW50ZXJ2YWwsIHMtPnJhdGUpOwoJZnJhY3Rpb25faW5pdCgmcy0+Y3ljbGVfb2Zmc2V0LCAodHJhbnNmZXJfZGVsYXkgJSAzMDcyKSAqIHMtPnJhdGUsIHMtPnJhdGUpOwoJYXRvbWljX3NldCgmcy0+Y3ljbGVfY291bnQsIHRyYW5zZmVyX2RlbGF5IC8gMzA3Mik7CglhdG9taWNfc2V0KCZzLT5jeWNsZV9jb3VudDIsIDApOwoKCXMtPm1vZGUgPSBjZmctPm1vZGU7CglzLT5zYW1wbGVfZm9ybWF0ID0gQU1EVFBfSU5QVVRfTEUxNjsKCgkvKiBXaGVuIHVzaW5nIHRoZSBBTTgyNCByYXcgc3ViZm9ybWF0IHdlIGNhbiBzdHJlYW0gc2lnbmFscyBvZgoJICogYW55IGRpbWVuc2lvbi4gIFRoZSBJRUM5NTggc3ViZm9ybWF0LCBob3dldmVyLCBvbmx5CgkgKiBzdXBwb3J0cyAyIGNoYW5uZWxzLgoJICovCglpZiAocy0+Zm9ybWF0ID09IEFNRFRQX0ZPUk1BVF9SQVcgfHwgY2ZnLT5kaW1lbnNpb24gPT0gMikKCQlzLT5kaW1lbnNpb24gPSBjZmctPmRpbWVuc2lvbjsKCWVsc2UKCQlyZXR1cm4gLUVJTlZBTDsKCglpZiAocy0+b3BjciAhPSBOVUxMKSB7CgkJY21wX3VucmVnaXN0ZXJfb3BjcihzLT5ob3N0LT5ob3N0LCBzLT5vcGNyKTsKCQlzLT5vcGNyID0gTlVMTDsKCX0KCglzd2l0Y2goY21kKSB7CgljYXNlIEFNRFRQX0lPQ19QTFVHOgoJCXMtPm9wY3IgPSBjbXBfcmVnaXN0ZXJfb3BjcihzLT5ob3N0LT5ob3N0LCBjZmctPnUucGx1ZywKCQkJCQkgICAvKnBheWxvYWQqLyAxMiwgcGx1Z191cGRhdGUsIHMpOwoJCWlmIChzLT5vcGNyID09IE5VTEwpCgkJCXJldHVybiAtRUlOVkFMOwoJCXMtPmlzb19jaGFubmVsID0gcy0+b3Bjci0+Y2hhbm5lbDsKCQlicmVhazsKCgljYXNlIEFNRFRQX0lPQ19DSEFOTkVMOgoJCWlmIChjZmctPnUuY2hhbm5lbCA+PSAwICYmIGNmZy0+dS5jaGFubmVsIDwgNjQpCgkJCXMtPmlzb19jaGFubmVsID0gY2ZnLT51LmNoYW5uZWw7CgkJZWxzZQoJCQlyZXR1cm4gLUVJTlZBTDsKCQlicmVhazsKCX0KCgkvKiBUaGUgaW9jdGwgc2V0dGluZ3Mgd2VyZSBhbGwgdmFsaWQsIHNvIHdlIHJlYWxsb2MgdGhlIHBhY2tldAoJICogbGlzdHMgdG8gbWFrZSBzdXJlIHRoZSBwYWNrZXQgc2l6ZSBpcyBiaWcgZW5vdWdoLgoJICovCglpZiAocy0+cGFja2V0X3Bvb2wgIT0gTlVMTCkKCQlzdHJlYW1fZnJlZV9wYWNrZXRfbGlzdHMocyk7CgoJaWYgKHN0cmVhbV9hbGxvY19wYWNrZXRfbGlzdHMocykgPCAwKSB7CgkJc3RyZWFtX2ZyZWVfcGFja2V0X2xpc3RzKHMpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IHN0cmVhbSAqc3RyZWFtX2FsbG9jKHN0cnVjdCBhbWR0cF9ob3N0ICpob3N0KQp7CglzdHJ1Y3Qgc3RyZWFtICpzOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCiAgICAgICAgcyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBzdHJlYW0pLCBTTEFCX0tFUk5FTCk7CiAgICAgICAgaWYgKHMgPT0gTlVMTCkKICAgICAgICAgICAgICAgIHJldHVybiBOVUxMOwoKICAgICAgICBtZW1zZXQocywgMCwgc2l6ZW9mKHN0cnVjdCBzdHJlYW0pKTsKCXMtPmhvc3QgPSBob3N0OwoKCXMtPmlucHV0ID0gYnVmZmVyX2FsbG9jKEJVRkZFUl9TSVpFKTsKCWlmIChzLT5pbnB1dCA9PSBOVUxMKSB7CgkJa2ZyZWUocyk7CgkJcmV0dXJuIE5VTEw7Cgl9CgoJcy0+ZGVzY3JpcHRvcl9wb29sID0gcGNpX3Bvb2xfY3JlYXRlKCJkZXNjcmlwdG9yIHBvb2wiLCBob3N0LT5vaGNpLT5kZXYsCgkJCQkJICAgICBzaXplb2Yoc3RydWN0IGRlc2NyaXB0b3JfYmxvY2spLAoJCQkJCSAgICAgMTYsIDApOwoKCWlmIChzLT5kZXNjcmlwdG9yX3Bvb2wgPT0gTlVMTCkgewoJCWtmcmVlKHMtPmlucHV0KTsKCQlrZnJlZShzKTsKCQlyZXR1cm4gTlVMTDsKCX0KCglJTklUX0xJU1RfSEVBRCgmcy0+ZnJlZV9wYWNrZXRfbGlzdHMpOwoJSU5JVF9MSVNUX0hFQUQoJnMtPmRtYV9wYWNrZXRfbGlzdHMpOwoKICAgICAgICBpbml0X3dhaXRxdWV1ZV9oZWFkKCZzLT5wYWNrZXRfbGlzdF93YWl0KTsKICAgICAgICBzcGluX2xvY2tfaW5pdCgmcy0+cGFja2V0X2xpc3RfbG9jayk7CgoJb2hjaTEzOTRfaW5pdF9pc29fdGFza2xldCgmcy0+aXNvX3Rhc2tsZXQsIE9IQ0lfSVNPX1RSQU5TTUlULAoJCQkJICBzdHJlYW1fc2hpZnRfcGFja2V0X2xpc3RzLAoJCQkJICAodW5zaWduZWQgbG9uZykgcyk7CgoJaWYgKG9oY2kxMzk0X3JlZ2lzdGVyX2lzb190YXNrbGV0KGhvc3QtPm9oY2ksICZzLT5pc29fdGFza2xldCkgPCAwKSB7CgkJcGNpX3Bvb2xfZGVzdHJveShzLT5kZXNjcmlwdG9yX3Bvb2wpOwoJCWtmcmVlKHMtPmlucHV0KTsKCQlrZnJlZShzKTsKCQlyZXR1cm4gTlVMTDsKCX0KCglzcGluX2xvY2tfaXJxc2F2ZSgmaG9zdC0+c3RyZWFtX2xpc3RfbG9jaywgZmxhZ3MpOwoJbGlzdF9hZGRfdGFpbCgmcy0+bGluaywgJmhvc3QtPnN0cmVhbV9saXN0KTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhvc3QtPnN0cmVhbV9saXN0X2xvY2ssIGZsYWdzKTsKCglyZXR1cm4gczsKfQoKc3RhdGljIHZvaWQgc3RyZWFtX2ZyZWUoc3RydWN0IHN0cmVhbSAqcykKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCgkvKiBTdG9wIHRoZSBETUEuICBXZSB3YWl0IGZvciB0aGUgZG1hIHBhY2tldCBsaXN0IHRvIGJlY29tZQoJICogZW1wdHkgYW5kIGxldCB0aGUgZG1hIGNvbnRyb2xsZXIgcnVuIG91dCBvZiBwcm9ncmFtcy4gIFRoaXMKCSAqIHNlZW1zIHRvIGJlIG1vcmUgcmVsaWFibGUgdGhhbiBzdG9wcGluZyBpdCBkaXJlY3RseSwgc2luY2UKCSAqIHRoYXQgc29tZXRpbWVzIGdlbmVyYXRlcyBhbiBpdCB0cmFuc21pdCBpbnRlcnJ1cHQgaWYgd2UKCSAqIGxhdGVyIHJlLWVuYWJsZSB0aGUgY29udGV4dC4KCSAqLwoJd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlKHMtPnBhY2tldF9saXN0X3dhaXQsCgkJCQkgbGlzdF9lbXB0eSgmcy0+ZG1hX3BhY2tldF9saXN0cykpOwoKCW9oY2kxMzk0X3N0b3BfaXRfY3R4KHMtPmhvc3QtPm9oY2ksIHMtPmlzb190YXNrbGV0LmNvbnRleHQsIDEpOwoJb2hjaTEzOTRfdW5yZWdpc3Rlcl9pc29fdGFza2xldChzLT5ob3N0LT5vaGNpLCAmcy0+aXNvX3Rhc2tsZXQpOwoKCWlmIChzLT5vcGNyICE9IE5VTEwpCgkJY21wX3VucmVnaXN0ZXJfb3BjcihzLT5ob3N0LT5ob3N0LCBzLT5vcGNyKTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcy0+aG9zdC0+c3RyZWFtX2xpc3RfbG9jaywgZmxhZ3MpOwoJbGlzdF9kZWwoJnMtPmxpbmspOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+aG9zdC0+c3RyZWFtX2xpc3RfbG9jaywgZmxhZ3MpOwoKCWtmcmVlKHMtPmlucHV0KTsKCglzdHJlYW1fZnJlZV9wYWNrZXRfbGlzdHMocyk7CglwY2lfcG9vbF9kZXN0cm95KHMtPmRlc2NyaXB0b3JfcG9vbCk7CgoJa2ZyZWUocyk7Cn0KCi8qIEZpbGUgb3BlcmF0aW9ucyAqLwoKc3RhdGljIHNzaXplX3QgYW1kdHBfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWZmZXIsIHNpemVfdCBjb3VudCwKCQkJICAgbG9mZl90ICpvZmZzZXRfaXNfaWdub3JlZCkKewoJc3RydWN0IHN0cmVhbSAqcyA9IGZpbGUtPnByaXZhdGVfZGF0YTsKCXVuc2lnbmVkIGNoYXIgKnA7CglpbnQgaTsKCXNpemVfdCBsZW5ndGg7CgoJaWYgKHMtPnBhY2tldF9wb29sID09IE5VTEwpCgkJcmV0dXJuIC1FQkFERkQ7CgoJLyogRmlsbCB0aGUgY2lyY3VsYXIgYnVmZmVyIGZyb20gdGhlIGlucHV0IGJ1ZmZlciBhbmQgY2FsbCB0aGUKCSAqIGlzbyBwYWNrZXIgd2hlbiB0aGUgYnVmZmVyIGlzIGZ1bGwuICBUaGUgaXNvIHBhY2tlciBtYXkKCSAqIGxlYXZlIGJ5dGVzIGluIHRoZSBidWZmZXIgZm9yIHR3byByZWFzb25zOiBlaXRoZXIgdGhlCgkgKiByZW1haW5pbmcgYnl0ZXMgd2Fzbid0IGVub3VnaCB0byBidWlsZCBhIG5ldyBwYWNrZXQsIG9yCgkgKiB0aGVyZSB3ZXJlIG5vIGZyZWUgcGFja2V0IGxpc3RzLiAgSW4gdGhlIGZpcnN0IGNhc2Ugd2UKCSAqIHJlLWZpbGwgdGhlIGJ1ZmZlciBhbmQgY2FsbCB0aGUgaXNvIHBhY2tlciBhZ2FpbiBvciByZXR1cm4KCSAqIGlmIHdlIHVzZWQgYWxsIHRoZSBkYXRhIGZyb20gdXNlcnNwYWNlLiAgSW4gdGhlIHNlY29uZAoJICogY2FzZSwgdGhlIHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZSB3aWxsIGJsb2NrIHVudGlsIHRoZSBpcnEKCSAqIGhhbmRsZXIgZnJlZXMgYSBwYWNrZXQgbGlzdC4KCSAqLwoKCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSArPSBsZW5ndGgpIHsKCQlwID0gYnVmZmVyX3B1dF9ieXRlcyhzLT5pbnB1dCwgY291bnQgLSBpLCAmbGVuZ3RoKTsKCQlpZiAoY29weV9mcm9tX3VzZXIocCwgYnVmZmVyICsgaSwgbGVuZ3RoKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJaWYgKHMtPmlucHV0LT5sZW5ndGggPCBzLT5pbnB1dC0+c2l6ZSkKCQkJY29udGludWU7CgoJCXN0cmVhbV9mbHVzaChzKTsKCgkJaWYgKHMtPmN1cnJlbnRfcGFja2V0X2xpc3QgIT0gTlVMTCkKCQkJY29udGludWU7CgoJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykKCQkJcmV0dXJuIGkgKyBsZW5ndGggPiAwID8gaSArIGxlbmd0aCA6IC1FQUdBSU47CgoJCWlmICh3YWl0X2V2ZW50X2ludGVycnVwdGlibGUocy0+cGFja2V0X2xpc3Rfd2FpdCwKCQkJCQkgICAgICFsaXN0X2VtcHR5KCZzLT5mcmVlX3BhY2tldF9saXN0cykpKQoJCQlyZXR1cm4gLUVJTlRSOwoJfQoKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIGxvbmcgYW1kdHBfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQp7CglzdHJ1Y3Qgc3RyZWFtICpzID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwoJc3RydWN0IGFtZHRwX2lvY3RsIGNmZzsKCWludCBlcnI7Cglsb2NrX2tlcm5lbCgpOwoJc3dpdGNoKGNtZCkKCXsKCWNhc2UgQU1EVFBfSU9DX1BMVUc6CgljYXNlIEFNRFRQX0lPQ19DSEFOTkVMOgoJCWlmIChjb3B5X2Zyb21fdXNlcigmY2ZnLCAoc3RydWN0IGFtZHRwX2lvY3RsIF9fdXNlciAqKSBhcmcsIHNpemVvZiBjZmcpKQoJCQllcnIgPSAtRUZBVUxUOwoJCWVsc2UKCQkJZXJyID0gc3RyZWFtX2NvbmZpZ3VyZShzLCBjbWQsICZjZmcpOwoJCWJyZWFrOwoKCWRlZmF1bHQ6CgkJZXJyID0gLUVJTlZBTDsKCQlicmVhazsKCX0KCXVubG9ja19rZXJuZWwoKTsKCXJldHVybiBlcnI7Cn0KCnN0YXRpYyB1bnNpZ25lZCBpbnQgYW1kdHBfcG9sbChzdHJ1Y3QgZmlsZSAqZmlsZSwgcG9sbF90YWJsZSAqcHQpCnsKCXN0cnVjdCBzdHJlYW0gKnMgPSBmaWxlLT5wcml2YXRlX2RhdGE7CgoJcG9sbF93YWl0KGZpbGUsICZzLT5wYWNrZXRfbGlzdF93YWl0LCBwdCk7CgoJaWYgKCFsaXN0X2VtcHR5KCZzLT5mcmVlX3BhY2tldF9saXN0cykpCgkJcmV0dXJuIFBPTExPVVQgfCBQT0xMV1JOT1JNOwoJZWxzZQoJCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IGFtZHRwX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCXN0cnVjdCBhbWR0cF9ob3N0ICpob3N0OwoJaW50IGkgPSBpZWVlMTM5NF9maWxlX3RvX2luc3RhbmNlKGZpbGUpOwoKCWhvc3QgPSBocHNiX2dldF9ob3N0aW5mb19ieWtleSgmYW1kdHBfaGlnaGxldmVsLCBpKTsKCWlmIChob3N0ID09IE5VTEwpCgkJcmV0dXJuIC1FTk9ERVY7CgoJZmlsZS0+cHJpdmF0ZV9kYXRhID0gc3RyZWFtX2FsbG9jKGhvc3QpOwoJaWYgKGZpbGUtPnByaXZhdGVfZGF0YSA9PSBOVUxMKQoJCXJldHVybiAtRU5PTUVNOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IGFtZHRwX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCXN0cnVjdCBzdHJlYW0gKnMgPSBmaWxlLT5wcml2YXRlX2RhdGE7CgoJc3RyZWFtX2ZyZWUocyk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBzdHJ1Y3QgY2RldiBhbWR0cF9jZGV2OwpzdGF0aWMgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBhbWR0cF9mb3BzID0KewoJLm93bmVyID0JVEhJU19NT0RVTEUsCgkud3JpdGUgPQlhbWR0cF93cml0ZSwKCS5wb2xsID0JCWFtZHRwX3BvbGwsCgkudW5sb2NrZWRfaW9jdGwgPSBhbWR0cF9pb2N0bCwKCS5jb21wYXRfaW9jdGwgPSBhbWR0cF9pb2N0bCwgLyogQWxsIGFtZHRwIGlvY3RscyBhcmUgY29tcGF0aWJsZSAqLwoJLm9wZW4gPQkJYW1kdHBfb3BlbiwKCS5yZWxlYXNlID0JYW1kdHBfcmVsZWFzZQp9OwoKLyogSUVFRTEzOTQgU3Vic3lzdGVtIGZ1bmN0aW9ucyAqLwoKc3RhdGljIHZvaWQgYW1kdHBfYWRkX2hvc3Qoc3RydWN0IGhwc2JfaG9zdCAqaG9zdCkKewoJc3RydWN0IGFtZHRwX2hvc3QgKmFoOwoJaW50IG1pbm9yOwoKCWlmIChzdHJjbXAoaG9zdC0+ZHJpdmVyLT5uYW1lLCBPSENJMTM5NF9EUklWRVJfTkFNRSkgIT0gMCkKCQlyZXR1cm47CgoJYWggPSBocHNiX2NyZWF0ZV9ob3N0aW5mbygmYW1kdHBfaGlnaGxldmVsLCBob3N0LCBzaXplb2YoKmFoKSk7CglpZiAoIWFoKSB7CgkJSFBTQl9FUlIoImFtZHRwOiBVbmFibGUgYWJsZSB0byBhbGxvYyBob3N0aW5mbyIpOwoJCXJldHVybjsKCX0KCglhaC0+aG9zdCA9IGhvc3Q7CglhaC0+b2hjaSA9IGhvc3QtPmhvc3RkYXRhOwoKCWhwc2Jfc2V0X2hvc3RpbmZvX2tleSgmYW1kdHBfaGlnaGxldmVsLCBob3N0LCBhaC0+aG9zdC0+aWQpOwoKCW1pbm9yID0gSUVFRTEzOTRfTUlOT1JfQkxPQ0tfQU1EVFAgKiAxNiArIGFoLT5ob3N0LT5pZDsKCglJTklUX0xJU1RfSEVBRCgmYWgtPnN0cmVhbV9saXN0KTsKCXNwaW5fbG9ja19pbml0KCZhaC0+c3RyZWFtX2xpc3RfbG9jayk7CgoJZGV2ZnNfbWtfY2RldihNS0RFVihJRUVFMTM5NF9NQUpPUiwgbWlub3IpLAoJCQlTX0lGQ0hSfFNfSVJVU1J8U19JV1VTUiwgImFtZHRwLyVkIiwgYWgtPmhvc3QtPmlkKTsKfQoKc3RhdGljIHZvaWQgYW1kdHBfcmVtb3ZlX2hvc3Qoc3RydWN0IGhwc2JfaG9zdCAqaG9zdCkKewoJc3RydWN0IGFtZHRwX2hvc3QgKmFoID0gaHBzYl9nZXRfaG9zdGluZm8oJmFtZHRwX2hpZ2hsZXZlbCwgaG9zdCk7CgoJaWYgKGFoKQoJCWRldmZzX3JlbW92ZSgiYW1kdHAvJWQiLCBhaC0+aG9zdC0+aWQpOwoKCXJldHVybjsKfQoKc3RhdGljIHN0cnVjdCBocHNiX2hpZ2hsZXZlbCBhbWR0cF9oaWdobGV2ZWwgPSB7CgkubmFtZSA9CQkiYW1kdHAiLAoJLmFkZF9ob3N0ID0JYW1kdHBfYWRkX2hvc3QsCgkucmVtb3ZlX2hvc3QgPQlhbWR0cF9yZW1vdmVfaG9zdCwKfTsKCi8qIE1vZHVsZSBpbnRlcmZhY2UgKi8KCk1PRFVMRV9BVVRIT1IoIktyaXN0aWFuIEhvZ3NiZXJnIDxob2dzYmVyZ0B1c2Vycy5zZi5uZXQ+Iik7Ck1PRFVMRV9ERVNDUklQVElPTigiRHJpdmVyIGZvciBBdWRpbyAmIE11c2ljIERhdGEgVHJhbnNtaXNzaW9uIFByb3RvY29sICIKCQkgICAib24gT0hDSSBib2FyZHMuIik7Ck1PRFVMRV9TVVBQT1JURURfREVWSUNFKCJhbWR0cCIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7CgpzdGF0aWMgaW50IF9faW5pdCBhbWR0cF9pbml0X21vZHVsZSAodm9pZCkKewoJY2Rldl9pbml0KCZhbWR0cF9jZGV2LCAmYW1kdHBfZm9wcyk7CglhbWR0cF9jZGV2Lm93bmVyID0gVEhJU19NT0RVTEU7Cglrb2JqZWN0X3NldF9uYW1lKCZhbWR0cF9jZGV2LmtvYmosICJhbWR0cCIpOwoJaWYgKGNkZXZfYWRkKCZhbWR0cF9jZGV2LCBJRUVFMTM5NF9BTURUUF9ERVYsIDE2KSkgewoJCUhQU0JfRVJSKCJhbWR0cDogdW5hYmxlIHRvIGFkZCBjaGFyIGRldmljZSIpOwogCQlyZXR1cm4gLUVJTzsKIAl9CgoJZGV2ZnNfbWtfZGlyKCJhbWR0cCIpOwoKCWhwc2JfcmVnaXN0ZXJfaGlnaGxldmVsKCZhbWR0cF9oaWdobGV2ZWwpOwoKCUhQU0JfSU5GTygiTG9hZGVkIEFNRFRQIGRyaXZlciIpOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBfX2V4aXQgYW1kdHBfZXhpdF9tb2R1bGUgKHZvaWQpCnsKICAgICAgICBocHNiX3VucmVnaXN0ZXJfaGlnaGxldmVsKCZhbWR0cF9oaWdobGV2ZWwpOwoJZGV2ZnNfcmVtb3ZlKCJhbWR0cCIpOwoJY2Rldl9kZWwoJmFtZHRwX2NkZXYpOwoKCUhQU0JfSU5GTygiVW5sb2FkZWQgQU1EVFAgZHJpdmVyIik7Cn0KCm1vZHVsZV9pbml0KGFtZHRwX2luaXRfbW9kdWxlKTsKbW9kdWxlX2V4aXQoYW1kdHBfZXhpdF9tb2R1bGUpOwpNT0RVTEVfQUxJQVNfQ0hBUkRFVihJRUVFMTM5NF9NQUpPUiwgSUVFRTEzOTRfTUlOT1JfQkxPQ0tfQU1EVFAgKiAxNik7Cg==