LyoKICogIGxpbnV4L2tlcm5lbC9zeXMuYwogKgogKiAgQ29weXJpZ2h0IChDKSAxOTkxLCAxOTkyICBMaW51cyBUb3J2YWxkcwogKi8KCiNpbmNsdWRlIDxsaW51eC9jb25maWcuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvbW0uaD4KI2luY2x1ZGUgPGxpbnV4L3V0c25hbWUuaD4KI2luY2x1ZGUgPGxpbnV4L21tYW4uaD4KI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CiNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgojaW5jbHVkZSA8bGludXgvcmVib290Lmg+CiNpbmNsdWRlIDxsaW51eC9wcmN0bC5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvaGlnaHVpZC5oPgojaW5jbHVkZSA8bGludXgvZnMuaD4KI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgojaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiNpbmNsdWRlIDxsaW51eC9rZXkuaD4KI2luY2x1ZGUgPGxpbnV4L3RpbWVzLmg+CiNpbmNsdWRlIDxsaW51eC9wb3NpeC10aW1lcnMuaD4KI2luY2x1ZGUgPGxpbnV4L3NlY3VyaXR5Lmg+CiNpbmNsdWRlIDxsaW51eC9kY29va2llcy5oPgojaW5jbHVkZSA8bGludXgvc3VzcGVuZC5oPgojaW5jbHVkZSA8bGludXgvdHR5Lmg+CgojaW5jbHVkZSA8bGludXgvY29tcGF0Lmg+CiNpbmNsdWRlIDxsaW51eC9zeXNjYWxscy5oPgoKI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiNpbmNsdWRlIDxhc20vaW8uaD4KI2luY2x1ZGUgPGFzbS91bmlzdGQuaD4KCiNpZm5kZWYgU0VUX1VOQUxJR05fQ1RMCiMgZGVmaW5lIFNFVF9VTkFMSUdOX0NUTChhLGIpCSgtRUlOVkFMKQojZW5kaWYKI2lmbmRlZiBHRVRfVU5BTElHTl9DVEwKIyBkZWZpbmUgR0VUX1VOQUxJR05fQ1RMKGEsYikJKC1FSU5WQUwpCiNlbmRpZgojaWZuZGVmIFNFVF9GUEVNVV9DVEwKIyBkZWZpbmUgU0VUX0ZQRU1VX0NUTChhLGIpCSgtRUlOVkFMKQojZW5kaWYKI2lmbmRlZiBHRVRfRlBFTVVfQ1RMCiMgZGVmaW5lIEdFVF9GUEVNVV9DVEwoYSxiKQkoLUVJTlZBTCkKI2VuZGlmCiNpZm5kZWYgU0VUX0ZQRVhDX0NUTAojIGRlZmluZSBTRVRfRlBFWENfQ1RMKGEsYikJKC1FSU5WQUwpCiNlbmRpZgojaWZuZGVmIEdFVF9GUEVYQ19DVEwKIyBkZWZpbmUgR0VUX0ZQRVhDX0NUTChhLGIpCSgtRUlOVkFMKQojZW5kaWYKCi8qCiAqIHRoaXMgaXMgd2hlcmUgdGhlIHN5c3RlbS13aWRlIG92ZXJmbG93IFVJRCBhbmQgR0lEIGFyZSBkZWZpbmVkLCBmb3IKICogYXJjaGl0ZWN0dXJlcyB0aGF0IG5vdyBoYXZlIDMyLWJpdCBVSUQvR0lEIGJ1dCBkaWRuJ3QgaW4gdGhlIHBhc3QKICovCgppbnQgb3ZlcmZsb3d1aWQgPSBERUZBVUxUX09WRVJGTE9XVUlEOwppbnQgb3ZlcmZsb3dnaWQgPSBERUZBVUxUX09WRVJGTE9XR0lEOwoKI2lmZGVmIENPTkZJR19VSUQxNgpFWFBPUlRfU1lNQk9MKG92ZXJmbG93dWlkKTsKRVhQT1JUX1NZTUJPTChvdmVyZmxvd2dpZCk7CiNlbmRpZgoKLyoKICogdGhlIHNhbWUgYXMgYWJvdmUsIGJ1dCBmb3IgZmlsZXN5c3RlbXMgd2hpY2ggY2FuIG9ubHkgc3RvcmUgYSAxNi1iaXQKICogVUlEIGFuZCBHSUQuIGFzIHN1Y2gsIHRoaXMgaXMgbmVlZGVkIG9uIGFsbCBhcmNoaXRlY3R1cmVzCiAqLwoKaW50IGZzX292ZXJmbG93dWlkID0gREVGQVVMVF9GU19PVkVSRkxPV1VJRDsKaW50IGZzX292ZXJmbG93Z2lkID0gREVGQVVMVF9GU19PVkVSRkxPV1VJRDsKCkVYUE9SVF9TWU1CT0woZnNfb3ZlcmZsb3d1aWQpOwpFWFBPUlRfU1lNQk9MKGZzX292ZXJmbG93Z2lkKTsKCi8qCiAqIHRoaXMgaW5kaWNhdGVzIHdoZXRoZXIgeW91IGNhbiByZWJvb3Qgd2l0aCBjdHJsLWFsdC1kZWw6IHRoZSBkZWZhdWx0IGlzIHllcwogKi8KCmludCBDX0FfRCA9IDE7CmludCBjYWRfcGlkID0gMTsKCi8qCiAqCU5vdGlmaWVyIGxpc3QgZm9yIGtlcm5lbCBjb2RlIHdoaWNoIHdhbnRzIHRvIGJlIGNhbGxlZAogKglhdCBzaHV0ZG93bi4gVGhpcyBpcyB1c2VkIHRvIHN0b3AgYW55IGlkbGluZyBETUEgb3BlcmF0aW9ucwogKglhbmQgdGhlIGxpa2UuIAogKi8KCnN0YXRpYyBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnJlYm9vdF9ub3RpZmllcl9saXN0OwpzdGF0aWMgREVGSU5FX1JXTE9DSyhub3RpZmllcl9sb2NrKTsKCi8qKgogKglub3RpZmllcl9jaGFpbl9yZWdpc3RlcgktIEFkZCBub3RpZmllciB0byBhIG5vdGlmaWVyIGNoYWluCiAqCUBsaXN0OiBQb2ludGVyIHRvIHJvb3QgbGlzdCBwb2ludGVyCiAqCUBuOiBOZXcgZW50cnkgaW4gbm90aWZpZXIgY2hhaW4KICoKICoJQWRkcyBhIG5vdGlmaWVyIHRvIGEgbm90aWZpZXIgY2hhaW4uCiAqCiAqCUN1cnJlbnRseSBhbHdheXMgcmV0dXJucyB6ZXJvLgogKi8KIAppbnQgbm90aWZpZXJfY2hhaW5fcmVnaXN0ZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICoqbGlzdCwgc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuKQp7Cgl3cml0ZV9sb2NrKCZub3RpZmllcl9sb2NrKTsKCXdoaWxlKCpsaXN0KQoJewoJCWlmKG4tPnByaW9yaXR5ID4gKCpsaXN0KS0+cHJpb3JpdHkpCgkJCWJyZWFrOwoJCWxpc3Q9ICYoKCpsaXN0KS0+bmV4dCk7Cgl9CgluLT5uZXh0ID0gKmxpc3Q7CgkqbGlzdD1uOwoJd3JpdGVfdW5sb2NrKCZub3RpZmllcl9sb2NrKTsKCXJldHVybiAwOwp9CgpFWFBPUlRfU1lNQk9MKG5vdGlmaWVyX2NoYWluX3JlZ2lzdGVyKTsKCi8qKgogKglub3RpZmllcl9jaGFpbl91bnJlZ2lzdGVyIC0gUmVtb3ZlIG5vdGlmaWVyIGZyb20gYSBub3RpZmllciBjaGFpbgogKglAbmw6IFBvaW50ZXIgdG8gcm9vdCBsaXN0IHBvaW50ZXIKICoJQG46IE5ldyBlbnRyeSBpbiBub3RpZmllciBjaGFpbgogKgogKglSZW1vdmVzIGEgbm90aWZpZXIgZnJvbSBhIG5vdGlmaWVyIGNoYWluLgogKgogKglSZXR1cm5zIHplcm8gb24gc3VjY2Vzcywgb3IgJS1FTk9FTlQgb24gZmFpbHVyZS4KICovCiAKaW50IG5vdGlmaWVyX2NoYWluX3VucmVnaXN0ZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICoqbmwsIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbikKewoJd3JpdGVfbG9jaygmbm90aWZpZXJfbG9jayk7Cgl3aGlsZSgoKm5sKSE9TlVMTCkKCXsKCQlpZigoKm5sKT09bikKCQl7CgkJCSpubD1uLT5uZXh0OwoJCQl3cml0ZV91bmxvY2soJm5vdGlmaWVyX2xvY2spOwoJCQlyZXR1cm4gMDsKCQl9CgkJbmw9JigoKm5sKS0+bmV4dCk7Cgl9Cgl3cml0ZV91bmxvY2soJm5vdGlmaWVyX2xvY2spOwoJcmV0dXJuIC1FTk9FTlQ7Cn0KCkVYUE9SVF9TWU1CT0wobm90aWZpZXJfY2hhaW5fdW5yZWdpc3Rlcik7CgovKioKICoJbm90aWZpZXJfY2FsbF9jaGFpbiAtIENhbGwgZnVuY3Rpb25zIGluIGEgbm90aWZpZXIgY2hhaW4KICoJQG46IFBvaW50ZXIgdG8gcm9vdCBwb2ludGVyIG9mIG5vdGlmaWVyIGNoYWluCiAqCUB2YWw6IFZhbHVlIHBhc3NlZCB1bm1vZGlmaWVkIHRvIG5vdGlmaWVyIGZ1bmN0aW9uCiAqCUB2OiBQb2ludGVyIHBhc3NlZCB1bm1vZGlmaWVkIHRvIG5vdGlmaWVyIGZ1bmN0aW9uCiAqCiAqCUNhbGxzIGVhY2ggZnVuY3Rpb24gaW4gYSBub3RpZmllciBjaGFpbiBpbiB0dXJuLgogKgogKglJZiB0aGUgcmV0dXJuIHZhbHVlIG9mIHRoZSBub3RpZmllciBjYW4gYmUgYW5kJ2QKICoJd2l0aCAlTk9USUZZX1NUT1BfTUFTSywgdGhlbiBub3RpZmllcl9jYWxsX2NoYWluCiAqCXdpbGwgcmV0dXJuIGltbWVkaWF0ZWx5LCB3aXRoIHRoZSByZXR1cm4gdmFsdWUgb2YKICoJdGhlIG5vdGlmaWVyIGZ1bmN0aW9uIHdoaWNoIGhhbHRlZCBleGVjdXRpb24uCiAqCU90aGVyd2lzZSwgdGhlIHJldHVybiB2YWx1ZSBpcyB0aGUgcmV0dXJuIHZhbHVlCiAqCW9mIHRoZSBsYXN0IG5vdGlmaWVyIGZ1bmN0aW9uIGNhbGxlZC4KICovCiAKaW50IG5vdGlmaWVyX2NhbGxfY2hhaW4oc3RydWN0IG5vdGlmaWVyX2Jsb2NrICoqbiwgdW5zaWduZWQgbG9uZyB2YWwsIHZvaWQgKnYpCnsKCWludCByZXQ9Tk9USUZZX0RPTkU7CglzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iID0gKm47CgoJd2hpbGUobmIpCgl7CgkJcmV0PW5iLT5ub3RpZmllcl9jYWxsKG5iLHZhbCx2KTsKCQlpZihyZXQmTk9USUZZX1NUT1BfTUFTSykKCQl7CgkJCXJldHVybiByZXQ7CgkJfQoJCW5iPW5iLT5uZXh0OwoJfQoJcmV0dXJuIHJldDsKfQoKRVhQT1JUX1NZTUJPTChub3RpZmllcl9jYWxsX2NoYWluKTsKCi8qKgogKglyZWdpc3Rlcl9yZWJvb3Rfbm90aWZpZXIgLSBSZWdpc3RlciBmdW5jdGlvbiB0byBiZSBjYWxsZWQgYXQgcmVib290IHRpbWUKICoJQG5iOiBJbmZvIGFib3V0IG5vdGlmaWVyIGZ1bmN0aW9uIHRvIGJlIGNhbGxlZAogKgogKglSZWdpc3RlcnMgYSBmdW5jdGlvbiB3aXRoIHRoZSBsaXN0IG9mIGZ1bmN0aW9ucwogKgl0byBiZSBjYWxsZWQgYXQgcmVib290IHRpbWUuCiAqCiAqCUN1cnJlbnRseSBhbHdheXMgcmV0dXJucyB6ZXJvLCBhcyBub3RpZmllcl9jaGFpbl9yZWdpc3RlcgogKglhbHdheXMgcmV0dXJucyB6ZXJvLgogKi8KIAppbnQgcmVnaXN0ZXJfcmVib290X25vdGlmaWVyKHN0cnVjdCBub3RpZmllcl9ibG9jayAqIG5iKQp7CglyZXR1cm4gbm90aWZpZXJfY2hhaW5fcmVnaXN0ZXIoJnJlYm9vdF9ub3RpZmllcl9saXN0LCBuYik7Cn0KCkVYUE9SVF9TWU1CT0wocmVnaXN0ZXJfcmVib290X25vdGlmaWVyKTsKCi8qKgogKgl1bnJlZ2lzdGVyX3JlYm9vdF9ub3RpZmllciAtIFVucmVnaXN0ZXIgcHJldmlvdXNseSByZWdpc3RlcmVkIHJlYm9vdCBub3RpZmllcgogKglAbmI6IEhvb2sgdG8gYmUgdW5yZWdpc3RlcmVkCiAqCiAqCVVucmVnaXN0ZXJzIGEgcHJldmlvdXNseSByZWdpc3RlcmVkIHJlYm9vdAogKglub3RpZmllciBmdW5jdGlvbi4KICoKICoJUmV0dXJucyB6ZXJvIG9uIHN1Y2Nlc3MsIG9yICUtRU5PRU5UIG9uIGZhaWx1cmUuCiAqLwogCmludCB1bnJlZ2lzdGVyX3JlYm9vdF9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKiBuYikKewoJcmV0dXJuIG5vdGlmaWVyX2NoYWluX3VucmVnaXN0ZXIoJnJlYm9vdF9ub3RpZmllcl9saXN0LCBuYik7Cn0KCkVYUE9SVF9TWU1CT0wodW5yZWdpc3Rlcl9yZWJvb3Rfbm90aWZpZXIpOwoKc3RhdGljIGludCBzZXRfb25lX3ByaW8oc3RydWN0IHRhc2tfc3RydWN0ICpwLCBpbnQgbmljZXZhbCwgaW50IGVycm9yKQp7CglpbnQgbm9fbmljZTsKCglpZiAocC0+dWlkICE9IGN1cnJlbnQtPmV1aWQgJiYKCQlwLT5ldWlkICE9IGN1cnJlbnQtPmV1aWQgJiYgIWNhcGFibGUoQ0FQX1NZU19OSUNFKSkgewoJCWVycm9yID0gLUVQRVJNOwoJCWdvdG8gb3V0OwoJfQoJaWYgKG5pY2V2YWwgPCB0YXNrX25pY2UocCkgJiYgIWNhcGFibGUoQ0FQX1NZU19OSUNFKSkgewoJCWVycm9yID0gLUVBQ0NFUzsKCQlnb3RvIG91dDsKCX0KCW5vX25pY2UgPSBzZWN1cml0eV90YXNrX3NldG5pY2UocCwgbmljZXZhbCk7CglpZiAobm9fbmljZSkgewoJCWVycm9yID0gbm9fbmljZTsKCQlnb3RvIG91dDsKCX0KCWlmIChlcnJvciA9PSAtRVNSQ0gpCgkJZXJyb3IgPSAwOwoJc2V0X3VzZXJfbmljZShwLCBuaWNldmFsKTsKb3V0OgoJcmV0dXJuIGVycm9yOwp9Cgphc21saW5rYWdlIGxvbmcgc3lzX3NldHByaW9yaXR5KGludCB3aGljaCwgaW50IHdobywgaW50IG5pY2V2YWwpCnsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqZywgKnA7CglzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKnVzZXI7CglpbnQgZXJyb3IgPSAtRUlOVkFMOwoKCWlmICh3aGljaCA+IDIgfHwgd2hpY2ggPCAwKQoJCWdvdG8gb3V0OwoKCS8qIG5vcm1hbGl6ZTogYXZvaWQgc2lnbmVkIGRpdmlzaW9uIChyb3VuZGluZyBwcm9ibGVtcykgKi8KCWVycm9yID0gLUVTUkNIOwoJaWYgKG5pY2V2YWwgPCAtMjApCgkJbmljZXZhbCA9IC0yMDsKCWlmIChuaWNldmFsID4gMTkpCgkJbmljZXZhbCA9IDE5OwoKCXJlYWRfbG9jaygmdGFza2xpc3RfbG9jayk7Cglzd2l0Y2ggKHdoaWNoKSB7CgkJY2FzZSBQUklPX1BST0NFU1M6CgkJCWlmICghd2hvKQoJCQkJd2hvID0gY3VycmVudC0+cGlkOwoJCQlwID0gZmluZF90YXNrX2J5X3BpZCh3aG8pOwoJCQlpZiAocCkKCQkJCWVycm9yID0gc2V0X29uZV9wcmlvKHAsIG5pY2V2YWwsIGVycm9yKTsKCQkJYnJlYWs7CgkJY2FzZSBQUklPX1BHUlA6CgkJCWlmICghd2hvKQoJCQkJd2hvID0gcHJvY2Vzc19ncm91cChjdXJyZW50KTsKCQkJZG9fZWFjaF90YXNrX3BpZCh3aG8sIFBJRFRZUEVfUEdJRCwgcCkgewoJCQkJZXJyb3IgPSBzZXRfb25lX3ByaW8ocCwgbmljZXZhbCwgZXJyb3IpOwoJCQl9IHdoaWxlX2VhY2hfdGFza19waWQod2hvLCBQSURUWVBFX1BHSUQsIHApOwoJCQlicmVhazsKCQljYXNlIFBSSU9fVVNFUjoKCQkJdXNlciA9IGN1cnJlbnQtPnVzZXI7CgkJCWlmICghd2hvKQoJCQkJd2hvID0gY3VycmVudC0+dWlkOwoJCQllbHNlCgkJCQlpZiAoKHdobyAhPSBjdXJyZW50LT51aWQpICYmICEodXNlciA9IGZpbmRfdXNlcih3aG8pKSkKCQkJCQlnb3RvIG91dF91bmxvY2s7CS8qIE5vIHByb2Nlc3NlcyBmb3IgdGhpcyB1c2VyICovCgoJCQlkb19lYWNoX3RocmVhZChnLCBwKQoJCQkJaWYgKHAtPnVpZCA9PSB3aG8pCgkJCQkJZXJyb3IgPSBzZXRfb25lX3ByaW8ocCwgbmljZXZhbCwgZXJyb3IpOwoJCQl3aGlsZV9lYWNoX3RocmVhZChnLCBwKTsKCQkJaWYgKHdobyAhPSBjdXJyZW50LT51aWQpCgkJCQlmcmVlX3VpZCh1c2VyKTsJCS8qIEZvciBmaW5kX3VzZXIoKSAqLwoJCQlicmVhazsKCX0Kb3V0X3VubG9jazoKCXJlYWRfdW5sb2NrKCZ0YXNrbGlzdF9sb2NrKTsKb3V0OgoJcmV0dXJuIGVycm9yOwp9CgovKgogKiBVZ2guIFRvIGF2b2lkIG5lZ2F0aXZlIHJldHVybiB2YWx1ZXMsICJnZXRwcmlvcml0eSgpIiB3aWxsCiAqIG5vdCByZXR1cm4gdGhlIG5vcm1hbCBuaWNlLXZhbHVlLCBidXQgYSBuZWdhdGVkIHZhbHVlIHRoYXQKICogaGFzIGJlZW4gb2Zmc2V0IGJ5IDIwIChpZSBpdCByZXR1cm5zIDQwLi4xIGluc3RlYWQgb2YgLTIwLi4xOSkKICogdG8gc3RheSBjb21wYXRpYmxlLgogKi8KYXNtbGlua2FnZSBsb25nIHN5c19nZXRwcmlvcml0eShpbnQgd2hpY2gsIGludCB3aG8pCnsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqZywgKnA7CglzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKnVzZXI7Cglsb25nIG5pY2V2YWwsIHJldHZhbCA9IC1FU1JDSDsKCglpZiAod2hpY2ggPiAyIHx8IHdoaWNoIDwgMCkKCQlyZXR1cm4gLUVJTlZBTDsKCglyZWFkX2xvY2soJnRhc2tsaXN0X2xvY2spOwoJc3dpdGNoICh3aGljaCkgewoJCWNhc2UgUFJJT19QUk9DRVNTOgoJCQlpZiAoIXdobykKCQkJCXdobyA9IGN1cnJlbnQtPnBpZDsKCQkJcCA9IGZpbmRfdGFza19ieV9waWQod2hvKTsKCQkJaWYgKHApIHsKCQkJCW5pY2V2YWwgPSAyMCAtIHRhc2tfbmljZShwKTsKCQkJCWlmIChuaWNldmFsID4gcmV0dmFsKQoJCQkJCXJldHZhbCA9IG5pY2V2YWw7CgkJCX0KCQkJYnJlYWs7CgkJY2FzZSBQUklPX1BHUlA6CgkJCWlmICghd2hvKQoJCQkJd2hvID0gcHJvY2Vzc19ncm91cChjdXJyZW50KTsKCQkJZG9fZWFjaF90YXNrX3BpZCh3aG8sIFBJRFRZUEVfUEdJRCwgcCkgewoJCQkJbmljZXZhbCA9IDIwIC0gdGFza19uaWNlKHApOwoJCQkJaWYgKG5pY2V2YWwgPiByZXR2YWwpCgkJCQkJcmV0dmFsID0gbmljZXZhbDsKCQkJfSB3aGlsZV9lYWNoX3Rhc2tfcGlkKHdobywgUElEVFlQRV9QR0lELCBwKTsKCQkJYnJlYWs7CgkJY2FzZSBQUklPX1VTRVI6CgkJCXVzZXIgPSBjdXJyZW50LT51c2VyOwoJCQlpZiAoIXdobykKCQkJCXdobyA9IGN1cnJlbnQtPnVpZDsKCQkJZWxzZQoJCQkJaWYgKCh3aG8gIT0gY3VycmVudC0+dWlkKSAmJiAhKHVzZXIgPSBmaW5kX3VzZXIod2hvKSkpCgkJCQkJZ290byBvdXRfdW5sb2NrOwkvKiBObyBwcm9jZXNzZXMgZm9yIHRoaXMgdXNlciAqLwoKCQkJZG9fZWFjaF90aHJlYWQoZywgcCkKCQkJCWlmIChwLT51aWQgPT0gd2hvKSB7CgkJCQkJbmljZXZhbCA9IDIwIC0gdGFza19uaWNlKHApOwoJCQkJCWlmIChuaWNldmFsID4gcmV0dmFsKQoJCQkJCQlyZXR2YWwgPSBuaWNldmFsOwoJCQkJfQoJCQl3aGlsZV9lYWNoX3RocmVhZChnLCBwKTsKCQkJaWYgKHdobyAhPSBjdXJyZW50LT51aWQpCgkJCQlmcmVlX3VpZCh1c2VyKTsJCS8qIGZvciBmaW5kX3VzZXIoKSAqLwoJCQlicmVhazsKCX0Kb3V0X3VubG9jazoKCXJlYWRfdW5sb2NrKCZ0YXNrbGlzdF9sb2NrKTsKCglyZXR1cm4gcmV0dmFsOwp9CgoKLyoKICogUmVib290IHN5c3RlbSBjYWxsOiBmb3Igb2J2aW91cyByZWFzb25zIG9ubHkgcm9vdCBtYXkgY2FsbCBpdCwKICogYW5kIGV2ZW4gcm9vdCBuZWVkcyB0byBzZXQgdXAgc29tZSBtYWdpYyBudW1iZXJzIGluIHRoZSByZWdpc3RlcnMKICogc28gdGhhdCBzb21lIG1pc3Rha2Ugd29uJ3QgbWFrZSB0aGlzIHJlYm9vdCB0aGUgd2hvbGUgbWFjaGluZS4KICogWW91IGNhbiBhbHNvIHNldCB0aGUgbWVhbmluZyBvZiB0aGUgY3RybC1hbHQtZGVsLWtleSBoZXJlLgogKgogKiByZWJvb3QgZG9lc24ndCBzeW5jOiBkbyB0aGF0IHlvdXJzZWxmIGJlZm9yZSBjYWxsaW5nIHRoaXMuCiAqLwphc21saW5rYWdlIGxvbmcgc3lzX3JlYm9vdChpbnQgbWFnaWMxLCBpbnQgbWFnaWMyLCB1bnNpZ25lZCBpbnQgY21kLCB2b2lkIF9fdXNlciAqIGFyZykKewoJY2hhciBidWZmZXJbMjU2XTsKCgkvKiBXZSBvbmx5IHRydXN0IHRoZSBzdXBlcnVzZXIgd2l0aCByZWJvb3RpbmcgdGhlIHN5c3RlbS4gKi8KCWlmICghY2FwYWJsZShDQVBfU1lTX0JPT1QpKQoJCXJldHVybiAtRVBFUk07CgoJLyogRm9yIHNhZmV0eSwgd2UgcmVxdWlyZSAibWFnaWMiIGFyZ3VtZW50cy4gKi8KCWlmIChtYWdpYzEgIT0gTElOVVhfUkVCT09UX01BR0lDMSB8fAoJICAgIChtYWdpYzIgIT0gTElOVVhfUkVCT09UX01BR0lDMiAmJgoJICAgICAgICAgICAgICAgIG1hZ2ljMiAhPSBMSU5VWF9SRUJPT1RfTUFHSUMyQSAmJgoJCQltYWdpYzIgIT0gTElOVVhfUkVCT09UX01BR0lDMkIgJiYKCSAgICAgICAgICAgICAgICBtYWdpYzIgIT0gTElOVVhfUkVCT09UX01BR0lDMkMpKQoJCXJldHVybiAtRUlOVkFMOwoKCWxvY2tfa2VybmVsKCk7Cglzd2l0Y2ggKGNtZCkgewoJY2FzZSBMSU5VWF9SRUJPT1RfQ01EX1JFU1RBUlQ6CgkJbm90aWZpZXJfY2FsbF9jaGFpbigmcmVib290X25vdGlmaWVyX2xpc3QsIFNZU19SRVNUQVJULCBOVUxMKTsKCQlzeXN0ZW1fc3RhdGUgPSBTWVNURU1fUkVTVEFSVDsKCQlkZXZpY2Vfc2h1dGRvd24oKTsKCQlwcmludGsoS0VSTl9FTUVSRyAiUmVzdGFydGluZyBzeXN0ZW0uXG4iKTsKCQltYWNoaW5lX3Jlc3RhcnQoTlVMTCk7CgkJYnJlYWs7CgoJY2FzZSBMSU5VWF9SRUJPT1RfQ01EX0NBRF9PTjoKCQlDX0FfRCA9IDE7CgkJYnJlYWs7CgoJY2FzZSBMSU5VWF9SRUJPT1RfQ01EX0NBRF9PRkY6CgkJQ19BX0QgPSAwOwoJCWJyZWFrOwoKCWNhc2UgTElOVVhfUkVCT09UX0NNRF9IQUxUOgoJCW5vdGlmaWVyX2NhbGxfY2hhaW4oJnJlYm9vdF9ub3RpZmllcl9saXN0LCBTWVNfSEFMVCwgTlVMTCk7CgkJc3lzdGVtX3N0YXRlID0gU1lTVEVNX0hBTFQ7CgkJZGV2aWNlX3NodXRkb3duKCk7CgkJcHJpbnRrKEtFUk5fRU1FUkcgIlN5c3RlbSBoYWx0ZWQuXG4iKTsKCQltYWNoaW5lX2hhbHQoKTsKCQl1bmxvY2tfa2VybmVsKCk7CgkJZG9fZXhpdCgwKTsKCQlicmVhazsKCgljYXNlIExJTlVYX1JFQk9PVF9DTURfUE9XRVJfT0ZGOgoJCW5vdGlmaWVyX2NhbGxfY2hhaW4oJnJlYm9vdF9ub3RpZmllcl9saXN0LCBTWVNfUE9XRVJfT0ZGLCBOVUxMKTsKCQlzeXN0ZW1fc3RhdGUgPSBTWVNURU1fUE9XRVJfT0ZGOwoJCWRldmljZV9zaHV0ZG93bigpOwoJCXByaW50ayhLRVJOX0VNRVJHICJQb3dlciBkb3duLlxuIik7CgkJbWFjaGluZV9wb3dlcl9vZmYoKTsKCQl1bmxvY2tfa2VybmVsKCk7CgkJZG9fZXhpdCgwKTsKCQlicmVhazsKCgljYXNlIExJTlVYX1JFQk9PVF9DTURfUkVTVEFSVDI6CgkJaWYgKHN0cm5jcHlfZnJvbV91c2VyKCZidWZmZXJbMF0sIGFyZywgc2l6ZW9mKGJ1ZmZlcikgLSAxKSA8IDApIHsKCQkJdW5sb2NrX2tlcm5lbCgpOwoJCQlyZXR1cm4gLUVGQVVMVDsKCQl9CgkJYnVmZmVyW3NpemVvZihidWZmZXIpIC0gMV0gPSAnXDAnOwoKCQlub3RpZmllcl9jYWxsX2NoYWluKCZyZWJvb3Rfbm90aWZpZXJfbGlzdCwgU1lTX1JFU1RBUlQsIGJ1ZmZlcik7CgkJc3lzdGVtX3N0YXRlID0gU1lTVEVNX1JFU1RBUlQ7CgkJZGV2aWNlX3NodXRkb3duKCk7CgkJcHJpbnRrKEtFUk5fRU1FUkcgIlJlc3RhcnRpbmcgc3lzdGVtIHdpdGggY29tbWFuZCAnJXMnLlxuIiwgYnVmZmVyKTsKCQltYWNoaW5lX3Jlc3RhcnQoYnVmZmVyKTsKCQlicmVhazsKCiNpZmRlZiBDT05GSUdfU09GVFdBUkVfU1VTUEVORAoJY2FzZSBMSU5VWF9SRUJPT1RfQ01EX1NXX1NVU1BFTkQ6CgkJewoJCQlpbnQgcmV0ID0gc29mdHdhcmVfc3VzcGVuZCgpOwoJCQl1bmxvY2tfa2VybmVsKCk7CgkJCXJldHVybiByZXQ7CgkJfQojZW5kaWYKCglkZWZhdWx0OgoJCXVubG9ja19rZXJuZWwoKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCXVubG9ja19rZXJuZWwoKTsKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBkZWZlcnJlZF9jYWQodm9pZCAqZHVtbXkpCnsKCW5vdGlmaWVyX2NhbGxfY2hhaW4oJnJlYm9vdF9ub3RpZmllcl9saXN0LCBTWVNfUkVTVEFSVCwgTlVMTCk7CgltYWNoaW5lX3Jlc3RhcnQoTlVMTCk7Cn0KCi8qCiAqIFRoaXMgZnVuY3Rpb24gZ2V0cyBjYWxsZWQgYnkgY3RybC1hbHQtZGVsIC0gaWUgdGhlIGtleWJvYXJkIGludGVycnVwdC4KICogQXMgaXQncyBjYWxsZWQgd2l0aGluIGFuIGludGVycnVwdCwgaXQgbWF5IE5PVCBzeW5jOiB0aGUgb25seSBjaG9pY2UKICogaXMgd2hldGhlciB0byByZWJvb3QgYXQgb25jZSwgb3IganVzdCBpZ25vcmUgdGhlIGN0cmwtYWx0LWRlbC4KICovCnZvaWQgY3RybF9hbHRfZGVsKHZvaWQpCnsKCXN0YXRpYyBERUNMQVJFX1dPUksoY2FkX3dvcmssIGRlZmVycmVkX2NhZCwgTlVMTCk7CgoJaWYgKENfQV9EKQoJCXNjaGVkdWxlX3dvcmsoJmNhZF93b3JrKTsKCWVsc2UKCQlraWxsX3Byb2MoY2FkX3BpZCwgU0lHSU5ULCAxKTsKfQoJCgovKgogKiBVbnByaXZpbGVnZWQgdXNlcnMgbWF5IGNoYW5nZSB0aGUgcmVhbCBnaWQgdG8gdGhlIGVmZmVjdGl2ZSBnaWQKICogb3IgdmljZSB2ZXJzYS4gIChCU0Qtc3R5bGUpCiAqCiAqIElmIHlvdSBzZXQgdGhlIHJlYWwgZ2lkIGF0IGFsbCwgb3Igc2V0IHRoZSBlZmZlY3RpdmUgZ2lkIHRvIGEgdmFsdWUgbm90CiAqIGVxdWFsIHRvIHRoZSByZWFsIGdpZCwgdGhlbiB0aGUgc2F2ZWQgZ2lkIGlzIHNldCB0byB0aGUgbmV3IGVmZmVjdGl2ZSBnaWQuCiAqCiAqIFRoaXMgbWFrZXMgaXQgcG9zc2libGUgZm9yIGEgc2V0Z2lkIHByb2dyYW0gdG8gY29tcGxldGVseSBkcm9wIGl0cwogKiBwcml2aWxlZ2VzLCB3aGljaCBpcyBvZnRlbiBhIHVzZWZ1bCBhc3NlcnRpb24gdG8gbWFrZSB3aGVuIHlvdSBhcmUgZG9pbmcKICogYSBzZWN1cml0eSBhdWRpdCBvdmVyIGEgcHJvZ3JhbS4KICoKICogVGhlIGdlbmVyYWwgaWRlYSBpcyB0aGF0IGEgcHJvZ3JhbSB3aGljaCB1c2VzIGp1c3Qgc2V0cmVnaWQoKSB3aWxsIGJlCiAqIDEwMCUgY29tcGF0aWJsZSB3aXRoIEJTRC4gIEEgcHJvZ3JhbSB3aGljaCB1c2VzIGp1c3Qgc2V0Z2lkKCkgd2lsbCBiZQogKiAxMDAlIGNvbXBhdGlibGUgd2l0aCBQT1NJWCB3aXRoIHNhdmVkIElEcy4gCiAqCiAqIFNNUDogVGhlcmUgYXJlIG5vdCByYWNlcywgdGhlIEdJRHMgYXJlIGNoZWNrZWQgb25seSBieSBmaWxlc3lzdGVtCiAqICAgICAgb3BlcmF0aW9ucyAoYXMgZmFyIGFzIHNlbWFudGljIHByZXNlcnZhdGlvbiBpcyBjb25jZXJuZWQpLgogKi8KYXNtbGlua2FnZSBsb25nIHN5c19zZXRyZWdpZChnaWRfdCByZ2lkLCBnaWRfdCBlZ2lkKQp7CglpbnQgb2xkX3JnaWQgPSBjdXJyZW50LT5naWQ7CglpbnQgb2xkX2VnaWQgPSBjdXJyZW50LT5lZ2lkOwoJaW50IG5ld19yZ2lkID0gb2xkX3JnaWQ7CglpbnQgbmV3X2VnaWQgPSBvbGRfZWdpZDsKCWludCByZXR2YWw7CgoJcmV0dmFsID0gc2VjdXJpdHlfdGFza19zZXRnaWQocmdpZCwgZWdpZCwgKGdpZF90KS0xLCBMU01fU0VUSURfUkUpOwoJaWYgKHJldHZhbCkKCQlyZXR1cm4gcmV0dmFsOwoKCWlmIChyZ2lkICE9IChnaWRfdCkgLTEpIHsKCQlpZiAoKG9sZF9yZ2lkID09IHJnaWQpIHx8CgkJICAgIChjdXJyZW50LT5lZ2lkPT1yZ2lkKSB8fAoJCSAgICBjYXBhYmxlKENBUF9TRVRHSUQpKQoJCQluZXdfcmdpZCA9IHJnaWQ7CgkJZWxzZQoJCQlyZXR1cm4gLUVQRVJNOwoJfQoJaWYgKGVnaWQgIT0gKGdpZF90KSAtMSkgewoJCWlmICgob2xkX3JnaWQgPT0gZWdpZCkgfHwKCQkgICAgKGN1cnJlbnQtPmVnaWQgPT0gZWdpZCkgfHwKCQkgICAgKGN1cnJlbnQtPnNnaWQgPT0gZWdpZCkgfHwKCQkgICAgY2FwYWJsZShDQVBfU0VUR0lEKSkKCQkJbmV3X2VnaWQgPSBlZ2lkOwoJCWVsc2UgewoJCQlyZXR1cm4gLUVQRVJNOwoJCX0KCX0KCWlmIChuZXdfZWdpZCAhPSBvbGRfZWdpZCkKCXsKCQljdXJyZW50LT5tbS0+ZHVtcGFibGUgPSAwOwoJCXdtYigpOwoJfQoJaWYgKHJnaWQgIT0gKGdpZF90KSAtMSB8fAoJICAgIChlZ2lkICE9IChnaWRfdCkgLTEgJiYgZWdpZCAhPSBvbGRfcmdpZCkpCgkJY3VycmVudC0+c2dpZCA9IG5ld19lZ2lkOwoJY3VycmVudC0+ZnNnaWQgPSBuZXdfZWdpZDsKCWN1cnJlbnQtPmVnaWQgPSBuZXdfZWdpZDsKCWN1cnJlbnQtPmdpZCA9IG5ld19yZ2lkOwoJa2V5X2ZzZ2lkX2NoYW5nZWQoY3VycmVudCk7CglyZXR1cm4gMDsKfQoKLyoKICogc2V0Z2lkKCkgaXMgaW1wbGVtZW50ZWQgbGlrZSBTeXNWIHcvIFNBVkVEX0lEUyAKICoKICogU01QOiBTYW1lIGltcGxpY2l0IHJhY2VzIGFzIGFib3ZlLgogKi8KYXNtbGlua2FnZSBsb25nIHN5c19zZXRnaWQoZ2lkX3QgZ2lkKQp7CglpbnQgb2xkX2VnaWQgPSBjdXJyZW50LT5lZ2lkOwoJaW50IHJldHZhbDsKCglyZXR2YWwgPSBzZWN1cml0eV90YXNrX3NldGdpZChnaWQsIChnaWRfdCktMSwgKGdpZF90KS0xLCBMU01fU0VUSURfSUQpOwoJaWYgKHJldHZhbCkKCQlyZXR1cm4gcmV0dmFsOwoKCWlmIChjYXBhYmxlKENBUF9TRVRHSUQpKQoJewoJCWlmKG9sZF9lZ2lkICE9IGdpZCkKCQl7CgkJCWN1cnJlbnQtPm1tLT5kdW1wYWJsZT0wOwoJCQl3bWIoKTsKCQl9CgkJY3VycmVudC0+Z2lkID0gY3VycmVudC0+ZWdpZCA9IGN1cnJlbnQtPnNnaWQgPSBjdXJyZW50LT5mc2dpZCA9IGdpZDsKCX0KCWVsc2UgaWYgKChnaWQgPT0gY3VycmVudC0+Z2lkKSB8fCAoZ2lkID09IGN1cnJlbnQtPnNnaWQpKQoJewoJCWlmKG9sZF9lZ2lkICE9IGdpZCkKCQl7CgkJCWN1cnJlbnQtPm1tLT5kdW1wYWJsZT0wOwoJCQl3bWIoKTsKCQl9CgkJY3VycmVudC0+ZWdpZCA9IGN1cnJlbnQtPmZzZ2lkID0gZ2lkOwoJfQoJZWxzZQoJCXJldHVybiAtRVBFUk07CgoJa2V5X2ZzZ2lkX2NoYW5nZWQoY3VycmVudCk7CglyZXR1cm4gMDsKfQogIApzdGF0aWMgaW50IHNldF91c2VyKHVpZF90IG5ld19ydWlkLCBpbnQgZHVtcGNsZWFyKQp7CglzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKm5ld191c2VyOwoKCW5ld191c2VyID0gYWxsb2NfdWlkKG5ld19ydWlkKTsKCWlmICghbmV3X3VzZXIpCgkJcmV0dXJuIC1FQUdBSU47CgoJaWYgKGF0b21pY19yZWFkKCZuZXdfdXNlci0+cHJvY2Vzc2VzKSA+PQoJCQkJY3VycmVudC0+c2lnbmFsLT5ybGltW1JMSU1JVF9OUFJPQ10ucmxpbV9jdXIgJiYKCQkJbmV3X3VzZXIgIT0gJnJvb3RfdXNlcikgewoJCWZyZWVfdWlkKG5ld191c2VyKTsKCQlyZXR1cm4gLUVBR0FJTjsKCX0KCglzd2l0Y2hfdWlkKG5ld191c2VyKTsKCglpZihkdW1wY2xlYXIpCgl7CgkJY3VycmVudC0+bW0tPmR1bXBhYmxlID0gMDsKCQl3bWIoKTsKCX0KCWN1cnJlbnQtPnVpZCA9IG5ld19ydWlkOwoJcmV0dXJuIDA7Cn0KCi8qCiAqIFVucHJpdmlsZWdlZCB1c2VycyBtYXkgY2hhbmdlIHRoZSByZWFsIHVpZCB0byB0aGUgZWZmZWN0aXZlIHVpZAogKiBvciB2aWNlIHZlcnNhLiAgKEJTRC1zdHlsZSkKICoKICogSWYgeW91IHNldCB0aGUgcmVhbCB1aWQgYXQgYWxsLCBvciBzZXQgdGhlIGVmZmVjdGl2ZSB1aWQgdG8gYSB2YWx1ZSBub3QKICogZXF1YWwgdG8gdGhlIHJlYWwgdWlkLCB0aGVuIHRoZSBzYXZlZCB1aWQgaXMgc2V0IHRvIHRoZSBuZXcgZWZmZWN0aXZlIHVpZC4KICoKICogVGhpcyBtYWtlcyBpdCBwb3NzaWJsZSBmb3IgYSBzZXR1aWQgcHJvZ3JhbSB0byBjb21wbGV0ZWx5IGRyb3AgaXRzCiAqIHByaXZpbGVnZXMsIHdoaWNoIGlzIG9mdGVuIGEgdXNlZnVsIGFzc2VydGlvbiB0byBtYWtlIHdoZW4geW91IGFyZSBkb2luZwogKiBhIHNlY3VyaXR5IGF1ZGl0IG92ZXIgYSBwcm9ncmFtLgogKgogKiBUaGUgZ2VuZXJhbCBpZGVhIGlzIHRoYXQgYSBwcm9ncmFtIHdoaWNoIHVzZXMganVzdCBzZXRyZXVpZCgpIHdpbGwgYmUKICogMTAwJSBjb21wYXRpYmxlIHdpdGggQlNELiAgQSBwcm9ncmFtIHdoaWNoIHVzZXMganVzdCBzZXR1aWQoKSB3aWxsIGJlCiAqIDEwMCUgY29tcGF0aWJsZSB3aXRoIFBPU0lYIHdpdGggc2F2ZWQgSURzLiAKICovCmFzbWxpbmthZ2UgbG9uZyBzeXNfc2V0cmV1aWQodWlkX3QgcnVpZCwgdWlkX3QgZXVpZCkKewoJaW50IG9sZF9ydWlkLCBvbGRfZXVpZCwgb2xkX3N1aWQsIG5ld19ydWlkLCBuZXdfZXVpZDsKCWludCByZXR2YWw7CgoJcmV0dmFsID0gc2VjdXJpdHlfdGFza19zZXR1aWQocnVpZCwgZXVpZCwgKHVpZF90KS0xLCBMU01fU0VUSURfUkUpOwoJaWYgKHJldHZhbCkKCQlyZXR1cm4gcmV0dmFsOwoKCW5ld19ydWlkID0gb2xkX3J1aWQgPSBjdXJyZW50LT51aWQ7CgluZXdfZXVpZCA9IG9sZF9ldWlkID0gY3VycmVudC0+ZXVpZDsKCW9sZF9zdWlkID0gY3VycmVudC0+c3VpZDsKCglpZiAocnVpZCAhPSAodWlkX3QpIC0xKSB7CgkJbmV3X3J1aWQgPSBydWlkOwoJCWlmICgob2xkX3J1aWQgIT0gcnVpZCkgJiYKCQkgICAgKGN1cnJlbnQtPmV1aWQgIT0gcnVpZCkgJiYKCQkgICAgIWNhcGFibGUoQ0FQX1NFVFVJRCkpCgkJCXJldHVybiAtRVBFUk07Cgl9CgoJaWYgKGV1aWQgIT0gKHVpZF90KSAtMSkgewoJCW5ld19ldWlkID0gZXVpZDsKCQlpZiAoKG9sZF9ydWlkICE9IGV1aWQpICYmCgkJICAgIChjdXJyZW50LT5ldWlkICE9IGV1aWQpICYmCgkJICAgIChjdXJyZW50LT5zdWlkICE9IGV1aWQpICYmCgkJICAgICFjYXBhYmxlKENBUF9TRVRVSUQpKQoJCQlyZXR1cm4gLUVQRVJNOwoJfQoKCWlmIChuZXdfcnVpZCAhPSBvbGRfcnVpZCAmJiBzZXRfdXNlcihuZXdfcnVpZCwgbmV3X2V1aWQgIT0gb2xkX2V1aWQpIDwgMCkKCQlyZXR1cm4gLUVBR0FJTjsKCglpZiAobmV3X2V1aWQgIT0gb2xkX2V1aWQpCgl7CgkJY3VycmVudC0+bW0tPmR1bXBhYmxlPTA7CgkJd21iKCk7Cgl9CgljdXJyZW50LT5mc3VpZCA9IGN1cnJlbnQtPmV1aWQgPSBuZXdfZXVpZDsKCWlmIChydWlkICE9ICh1aWRfdCkgLTEgfHwKCSAgICAoZXVpZCAhPSAodWlkX3QpIC0xICYmIGV1aWQgIT0gb2xkX3J1aWQpKQoJCWN1cnJlbnQtPnN1aWQgPSBjdXJyZW50LT5ldWlkOwoJY3VycmVudC0+ZnN1aWQgPSBjdXJyZW50LT5ldWlkOwoKCWtleV9mc3VpZF9jaGFuZ2VkKGN1cnJlbnQpOwoKCXJldHVybiBzZWN1cml0eV90YXNrX3Bvc3Rfc2V0dWlkKG9sZF9ydWlkLCBvbGRfZXVpZCwgb2xkX3N1aWQsIExTTV9TRVRJRF9SRSk7Cn0KCgoJCQovKgogKiBzZXR1aWQoKSBpcyBpbXBsZW1lbnRlZCBsaWtlIFN5c1Ygd2l0aCBTQVZFRF9JRFMgCiAqIAogKiBOb3RlIHRoYXQgU0FWRURfSUQncyBpcyBkZWZpY2llbnQgaW4gdGhhdCBhIHNldHVpZCByb290IHByb2dyYW0KICogbGlrZSBzZW5kbWFpbCwgZm9yIGV4YW1wbGUsIGNhbm5vdCBzZXQgaXRzIHVpZCB0byBiZSBhIG5vcm1hbCAKICogdXNlciBhbmQgdGhlbiBzd2l0Y2ggYmFjaywgYmVjYXVzZSBpZiB5b3UncmUgcm9vdCwgc2V0dWlkKCkgc2V0cwogKiB0aGUgc2F2ZWQgdWlkIHRvby4gIElmIHlvdSBkb24ndCBsaWtlIHRoaXMsIGJsYW1lIHRoZSBicmlnaHQgcGVvcGxlCiAqIGluIHRoZSBQT1NJWCBjb21taXR0ZWUgYW5kL29yIFVTRy4gIE5vdGUgdGhhdCB0aGUgQlNELXN0eWxlIHNldHJldWlkKCkKICogd2lsbCBhbGxvdyBhIHJvb3QgcHJvZ3JhbSB0byB0ZW1wb3JhcmlseSBkcm9wIHByaXZpbGVnZXMgYW5kIGJlIGFibGUgdG8KICogcmVnYWluIHRoZW0gYnkgc3dhcHBpbmcgdGhlIHJlYWwgYW5kIGVmZmVjdGl2ZSB1aWQuICAKICovCmFzbWxpbmthZ2UgbG9uZyBzeXNfc2V0dWlkKHVpZF90IHVpZCkKewoJaW50IG9sZF9ldWlkID0gY3VycmVudC0+ZXVpZDsKCWludCBvbGRfcnVpZCwgb2xkX3N1aWQsIG5ld19ydWlkLCBuZXdfc3VpZDsKCWludCByZXR2YWw7CgoJcmV0dmFsID0gc2VjdXJpdHlfdGFza19zZXR1aWQodWlkLCAodWlkX3QpLTEsICh1aWRfdCktMSwgTFNNX1NFVElEX0lEKTsKCWlmIChyZXR2YWwpCgkJcmV0dXJuIHJldHZhbDsKCglvbGRfcnVpZCA9IG5ld19ydWlkID0gY3VycmVudC0+dWlkOwoJb2xkX3N1aWQgPSBjdXJyZW50LT5zdWlkOwoJbmV3X3N1aWQgPSBvbGRfc3VpZDsKCQoJaWYgKGNhcGFibGUoQ0FQX1NFVFVJRCkpIHsKCQlpZiAodWlkICE9IG9sZF9ydWlkICYmIHNldF91c2VyKHVpZCwgb2xkX2V1aWQgIT0gdWlkKSA8IDApCgkJCXJldHVybiAtRUFHQUlOOwoJCW5ld19zdWlkID0gdWlkOwoJfSBlbHNlIGlmICgodWlkICE9IGN1cnJlbnQtPnVpZCkgJiYgKHVpZCAhPSBuZXdfc3VpZCkpCgkJcmV0dXJuIC1FUEVSTTsKCglpZiAob2xkX2V1aWQgIT0gdWlkKQoJewoJCWN1cnJlbnQtPm1tLT5kdW1wYWJsZSA9IDA7CgkJd21iKCk7Cgl9CgljdXJyZW50LT5mc3VpZCA9IGN1cnJlbnQtPmV1aWQgPSB1aWQ7CgljdXJyZW50LT5zdWlkID0gbmV3X3N1aWQ7CgoJa2V5X2ZzdWlkX2NoYW5nZWQoY3VycmVudCk7CgoJcmV0dXJuIHNlY3VyaXR5X3Rhc2tfcG9zdF9zZXR1aWQob2xkX3J1aWQsIG9sZF9ldWlkLCBvbGRfc3VpZCwgTFNNX1NFVElEX0lEKTsKfQoKCi8qCiAqIFRoaXMgZnVuY3Rpb24gaW1wbGVtZW50cyBhIGdlbmVyaWMgYWJpbGl0eSB0byB1cGRhdGUgcnVpZCwgZXVpZCwKICogYW5kIHN1aWQuICBUaGlzIGFsbG93cyB5b3UgdG8gaW1wbGVtZW50IHRoZSA0LjQgY29tcGF0aWJsZSBzZXRldWlkKCkuCiAqLwphc21saW5rYWdlIGxvbmcgc3lzX3NldHJlc3VpZCh1aWRfdCBydWlkLCB1aWRfdCBldWlkLCB1aWRfdCBzdWlkKQp7CglpbnQgb2xkX3J1aWQgPSBjdXJyZW50LT51aWQ7CglpbnQgb2xkX2V1aWQgPSBjdXJyZW50LT5ldWlkOwoJaW50IG9sZF9zdWlkID0gY3VycmVudC0+c3VpZDsKCWludCByZXR2YWw7CgoJcmV0dmFsID0gc2VjdXJpdHlfdGFza19zZXR1aWQocnVpZCwgZXVpZCwgc3VpZCwgTFNNX1NFVElEX1JFUyk7CglpZiAocmV0dmFsKQoJCXJldHVybiByZXR2YWw7CgoJaWYgKCFjYXBhYmxlKENBUF9TRVRVSUQpKSB7CgkJaWYgKChydWlkICE9ICh1aWRfdCkgLTEpICYmIChydWlkICE9IGN1cnJlbnQtPnVpZCkgJiYKCQkgICAgKHJ1aWQgIT0gY3VycmVudC0+ZXVpZCkgJiYgKHJ1aWQgIT0gY3VycmVudC0+c3VpZCkpCgkJCXJldHVybiAtRVBFUk07CgkJaWYgKChldWlkICE9ICh1aWRfdCkgLTEpICYmIChldWlkICE9IGN1cnJlbnQtPnVpZCkgJiYKCQkgICAgKGV1aWQgIT0gY3VycmVudC0+ZXVpZCkgJiYgKGV1aWQgIT0gY3VycmVudC0+c3VpZCkpCgkJCXJldHVybiAtRVBFUk07CgkJaWYgKChzdWlkICE9ICh1aWRfdCkgLTEpICYmIChzdWlkICE9IGN1cnJlbnQtPnVpZCkgJiYKCQkgICAgKHN1aWQgIT0gY3VycmVudC0+ZXVpZCkgJiYgKHN1aWQgIT0gY3VycmVudC0+c3VpZCkpCgkJCXJldHVybiAtRVBFUk07Cgl9CglpZiAocnVpZCAhPSAodWlkX3QpIC0xKSB7CgkJaWYgKHJ1aWQgIT0gY3VycmVudC0+dWlkICYmIHNldF91c2VyKHJ1aWQsIGV1aWQgIT0gY3VycmVudC0+ZXVpZCkgPCAwKQoJCQlyZXR1cm4gLUVBR0FJTjsKCX0KCWlmIChldWlkICE9ICh1aWRfdCkgLTEpIHsKCQlpZiAoZXVpZCAhPSBjdXJyZW50LT5ldWlkKQoJCXsKCQkJY3VycmVudC0+bW0tPmR1bXBhYmxlID0gMDsKCQkJd21iKCk7CgkJfQoJCWN1cnJlbnQtPmV1aWQgPSBldWlkOwoJfQoJY3VycmVudC0+ZnN1aWQgPSBjdXJyZW50LT5ldWlkOwoJaWYgKHN1aWQgIT0gKHVpZF90KSAtMSkKCQljdXJyZW50LT5zdWlkID0gc3VpZDsKCglrZXlfZnN1aWRfY2hhbmdlZChjdXJyZW50KTsKCglyZXR1cm4gc2VjdXJpdHlfdGFza19wb3N0X3NldHVpZChvbGRfcnVpZCwgb2xkX2V1aWQsIG9sZF9zdWlkLCBMU01fU0VUSURfUkVTKTsKfQoKYXNtbGlua2FnZSBsb25nIHN5c19nZXRyZXN1aWQodWlkX3QgX191c2VyICpydWlkLCB1aWRfdCBfX3VzZXIgKmV1aWQsIHVpZF90IF9fdXNlciAqc3VpZCkKewoJaW50IHJldHZhbDsKCglpZiAoIShyZXR2YWwgPSBwdXRfdXNlcihjdXJyZW50LT51aWQsIHJ1aWQpKSAmJgoJICAgICEocmV0dmFsID0gcHV0X3VzZXIoY3VycmVudC0+ZXVpZCwgZXVpZCkpKQoJCXJldHZhbCA9IHB1dF91c2VyKGN1cnJlbnQtPnN1aWQsIHN1aWQpOwoKCXJldHVybiByZXR2YWw7Cn0KCi8qCiAqIFNhbWUgYXMgYWJvdmUsIGJ1dCBmb3IgcmdpZCwgZWdpZCwgc2dpZC4KICovCmFzbWxpbmthZ2UgbG9uZyBzeXNfc2V0cmVzZ2lkKGdpZF90IHJnaWQsIGdpZF90IGVnaWQsIGdpZF90IHNnaWQpCnsKCWludCByZXR2YWw7CgoJcmV0dmFsID0gc2VjdXJpdHlfdGFza19zZXRnaWQocmdpZCwgZWdpZCwgc2dpZCwgTFNNX1NFVElEX1JFUyk7CglpZiAocmV0dmFsKQoJCXJldHVybiByZXR2YWw7CgoJaWYgKCFjYXBhYmxlKENBUF9TRVRHSUQpKSB7CgkJaWYgKChyZ2lkICE9IChnaWRfdCkgLTEpICYmIChyZ2lkICE9IGN1cnJlbnQtPmdpZCkgJiYKCQkgICAgKHJnaWQgIT0gY3VycmVudC0+ZWdpZCkgJiYgKHJnaWQgIT0gY3VycmVudC0+c2dpZCkpCgkJCXJldHVybiAtRVBFUk07CgkJaWYgKChlZ2lkICE9IChnaWRfdCkgLTEpICYmIChlZ2lkICE9IGN1cnJlbnQtPmdpZCkgJiYKCQkgICAgKGVnaWQgIT0gY3VycmVudC0+ZWdpZCkgJiYgKGVnaWQgIT0gY3VycmVudC0+c2dpZCkpCgkJCXJldHVybiAtRVBFUk07CgkJaWYgKChzZ2lkICE9IChnaWRfdCkgLTEpICYmIChzZ2lkICE9IGN1cnJlbnQtPmdpZCkgJiYKCQkgICAgKHNnaWQgIT0gY3VycmVudC0+ZWdpZCkgJiYgKHNnaWQgIT0gY3VycmVudC0+c2dpZCkpCgkJCXJldHVybiAtRVBFUk07Cgl9CglpZiAoZWdpZCAhPSAoZ2lkX3QpIC0xKSB7CgkJaWYgKGVnaWQgIT0gY3VycmVudC0+ZWdpZCkKCQl7CgkJCWN1cnJlbnQtPm1tLT5kdW1wYWJsZSA9IDA7CgkJCXdtYigpOwoJCX0KCQljdXJyZW50LT5lZ2lkID0gZWdpZDsKCX0KCWN1cnJlbnQtPmZzZ2lkID0gY3VycmVudC0+ZWdpZDsKCWlmIChyZ2lkICE9IChnaWRfdCkgLTEpCgkJY3VycmVudC0+Z2lkID0gcmdpZDsKCWlmIChzZ2lkICE9IChnaWRfdCkgLTEpCgkJY3VycmVudC0+c2dpZCA9IHNnaWQ7CgoJa2V5X2ZzZ2lkX2NoYW5nZWQoY3VycmVudCk7CglyZXR1cm4gMDsKfQoKYXNtbGlua2FnZSBsb25nIHN5c19nZXRyZXNnaWQoZ2lkX3QgX191c2VyICpyZ2lkLCBnaWRfdCBfX3VzZXIgKmVnaWQsIGdpZF90IF9fdXNlciAqc2dpZCkKewoJaW50IHJldHZhbDsKCglpZiAoIShyZXR2YWwgPSBwdXRfdXNlcihjdXJyZW50LT5naWQsIHJnaWQpKSAmJgoJICAgICEocmV0dmFsID0gcHV0X3VzZXIoY3VycmVudC0+ZWdpZCwgZWdpZCkpKQoJCXJldHZhbCA9IHB1dF91c2VyKGN1cnJlbnQtPnNnaWQsIHNnaWQpOwoKCXJldHVybiByZXR2YWw7Cn0KCgovKgogKiAic2V0ZnN1aWQoKSIgc2V0cyB0aGUgZnN1aWQgLSB0aGUgdWlkIHVzZWQgZm9yIGZpbGVzeXN0ZW0gY2hlY2tzLiBUaGlzCiAqIGlzIHVzZWQgZm9yICJhY2Nlc3MoKSIgYW5kIGZvciB0aGUgTkZTIGRhZW1vbiAobGV0dGluZyBuZnNkIHN0YXkgYXQKICogd2hhdGV2ZXIgdWlkIGl0IHdhbnRzIHRvKS4gSXQgbm9ybWFsbHkgc2hhZG93cyAiZXVpZCIsIGV4Y2VwdCB3aGVuCiAqIGV4cGxpY2l0bHkgc2V0IGJ5IHNldGZzdWlkKCkgb3IgZm9yIGFjY2Vzcy4uCiAqLwphc21saW5rYWdlIGxvbmcgc3lzX3NldGZzdWlkKHVpZF90IHVpZCkKewoJaW50IG9sZF9mc3VpZDsKCglvbGRfZnN1aWQgPSBjdXJyZW50LT5mc3VpZDsKCWlmIChzZWN1cml0eV90YXNrX3NldHVpZCh1aWQsICh1aWRfdCktMSwgKHVpZF90KS0xLCBMU01fU0VUSURfRlMpKQoJCXJldHVybiBvbGRfZnN1aWQ7CgoJaWYgKHVpZCA9PSBjdXJyZW50LT51aWQgfHwgdWlkID09IGN1cnJlbnQtPmV1aWQgfHwKCSAgICB1aWQgPT0gY3VycmVudC0+c3VpZCB8fCB1aWQgPT0gY3VycmVudC0+ZnN1aWQgfHwgCgkgICAgY2FwYWJsZShDQVBfU0VUVUlEKSkKCXsKCQlpZiAodWlkICE9IG9sZF9mc3VpZCkKCQl7CgkJCWN1cnJlbnQtPm1tLT5kdW1wYWJsZSA9IDA7CgkJCXdtYigpOwoJCX0KCQljdXJyZW50LT5mc3VpZCA9IHVpZDsKCX0KCglrZXlfZnN1aWRfY2hhbmdlZChjdXJyZW50KTsKCglzZWN1cml0eV90YXNrX3Bvc3Rfc2V0dWlkKG9sZF9mc3VpZCwgKHVpZF90KS0xLCAodWlkX3QpLTEsIExTTV9TRVRJRF9GUyk7CgoJcmV0dXJuIG9sZF9mc3VpZDsKfQoKLyoKICogU2FtbWEgcOUgc3ZlbnNrYS4uCiAqLwphc21saW5rYWdlIGxvbmcgc3lzX3NldGZzZ2lkKGdpZF90IGdpZCkKewoJaW50IG9sZF9mc2dpZDsKCglvbGRfZnNnaWQgPSBjdXJyZW50LT5mc2dpZDsKCWlmIChzZWN1cml0eV90YXNrX3NldGdpZChnaWQsIChnaWRfdCktMSwgKGdpZF90KS0xLCBMU01fU0VUSURfRlMpKQoJCXJldHVybiBvbGRfZnNnaWQ7CgoJaWYgKGdpZCA9PSBjdXJyZW50LT5naWQgfHwgZ2lkID09IGN1cnJlbnQtPmVnaWQgfHwKCSAgICBnaWQgPT0gY3VycmVudC0+c2dpZCB8fCBnaWQgPT0gY3VycmVudC0+ZnNnaWQgfHwgCgkgICAgY2FwYWJsZShDQVBfU0VUR0lEKSkKCXsKCQlpZiAoZ2lkICE9IG9sZF9mc2dpZCkKCQl7CgkJCWN1cnJlbnQtPm1tLT5kdW1wYWJsZSA9IDA7CgkJCXdtYigpOwoJCX0KCQljdXJyZW50LT5mc2dpZCA9IGdpZDsKCQlrZXlfZnNnaWRfY2hhbmdlZChjdXJyZW50KTsKCX0KCXJldHVybiBvbGRfZnNnaWQ7Cn0KCmFzbWxpbmthZ2UgbG9uZyBzeXNfdGltZXMoc3RydWN0IHRtcyBfX3VzZXIgKiB0YnVmKQp7CgkvKgoJICoJSW4gdGhlIFNNUCB3b3JsZCB3ZSBtaWdodCBqdXN0IGJlIHVubHVja3kgYW5kIGhhdmUgb25lIG9mCgkgKgl0aGUgdGltZXMgaW5jcmVtZW50IGFzIHdlIHVzZSBpdC4gU2luY2UgdGhlIHZhbHVlIGlzIGFuCgkgKglhdG9taWNhbGx5IHNhZmUgdHlwZSB0aGlzIGlzIGp1c3QgZmluZS4gQ29uY2VwdHVhbGx5IGl0cwoJICoJYXMgaWYgdGhlIHN5c2NhbGwgdG9vayBhbiBpbnN0YW50IGxvbmdlciB0byBvY2N1ci4KCSAqLwoJaWYgKHRidWYpIHsKCQlzdHJ1Y3QgdG1zIHRtcDsKCQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzayA9IGN1cnJlbnQ7CgkJc3RydWN0IHRhc2tfc3RydWN0ICp0OwoJCWNwdXRpbWVfdCB1dGltZSwgc3RpbWUsIGN1dGltZSwgY3N0aW1lOwoKCQlyZWFkX2xvY2soJnRhc2tsaXN0X2xvY2spOwoJCXV0aW1lID0gdHNrLT5zaWduYWwtPnV0aW1lOwoJCXN0aW1lID0gdHNrLT5zaWduYWwtPnN0aW1lOwoJCXQgPSB0c2s7CgkJZG8gewoJCQl1dGltZSA9IGNwdXRpbWVfYWRkKHV0aW1lLCB0LT51dGltZSk7CgkJCXN0aW1lID0gY3B1dGltZV9hZGQoc3RpbWUsIHQtPnN0aW1lKTsKCQkJdCA9IG5leHRfdGhyZWFkKHQpOwoJCX0gd2hpbGUgKHQgIT0gdHNrKTsKCgkJLyoKCQkgKiBXaGlsZSB3ZSBoYXZlIHRhc2tsaXN0X2xvY2sgcmVhZC1sb2NrZWQsIG5vIGR5aW5nIHRocmVhZAoJCSAqIGNhbiBiZSB1cGRhdGluZyBjdXJyZW50LT5zaWduYWwtPlt1c110aW1lLiAgSW5zdGVhZCwKCQkgKiB3ZSBnb3QgdGhlaXIgY291bnRzIGluY2x1ZGVkIGluIHRoZSBsaXZlIHRocmVhZCBsb29wLgoJCSAqIEhvd2V2ZXIsIGFub3RoZXIgdGhyZWFkIGNhbiBjb21lIGluIHJpZ2h0IG5vdyBhbmQKCQkgKiBkbyBhIHdhaXQgY2FsbCB0aGF0IHVwZGF0ZXMgY3VycmVudC0+c2lnbmFsLT5jW3VzXXRpbWUuCgkJICogVG8gbWFrZSBzdXJlIHdlIGFsd2F5cyBzZWUgdGhhdCBwYWlyIHVwZGF0ZWQgYXRvbWljYWxseSwKCQkgKiB3ZSB0YWtlIHRoZSBzaWdsb2NrIGFyb3VuZCBmZXRjaGluZyB0aGVtLgoJCSAqLwoJCXNwaW5fbG9ja19pcnEoJnRzay0+c2lnaGFuZC0+c2lnbG9jayk7CgkJY3V0aW1lID0gdHNrLT5zaWduYWwtPmN1dGltZTsKCQljc3RpbWUgPSB0c2stPnNpZ25hbC0+Y3N0aW1lOwoJCXNwaW5fdW5sb2NrX2lycSgmdHNrLT5zaWdoYW5kLT5zaWdsb2NrKTsKCQlyZWFkX3VubG9jaygmdGFza2xpc3RfbG9jayk7CgoJCXRtcC50bXNfdXRpbWUgPSBjcHV0aW1lX3RvX2Nsb2NrX3QodXRpbWUpOwoJCXRtcC50bXNfc3RpbWUgPSBjcHV0aW1lX3RvX2Nsb2NrX3Qoc3RpbWUpOwoJCXRtcC50bXNfY3V0aW1lID0gY3B1dGltZV90b19jbG9ja190KGN1dGltZSk7CgkJdG1wLnRtc19jc3RpbWUgPSBjcHV0aW1lX3RvX2Nsb2NrX3QoY3N0aW1lKTsKCQlpZiAoY29weV90b191c2VyKHRidWYsICZ0bXAsIHNpemVvZihzdHJ1Y3QgdG1zKSkpCgkJCXJldHVybiAtRUZBVUxUOwoJfQoJcmV0dXJuIChsb25nKSBqaWZmaWVzXzY0X3RvX2Nsb2NrX3QoZ2V0X2ppZmZpZXNfNjQoKSk7Cn0KCi8qCiAqIFRoaXMgbmVlZHMgc29tZSBoZWF2eSBjaGVja2luZyAuLi4KICogSSBqdXN0IGhhdmVuJ3QgdGhlIHN0b21hY2ggZm9yIGl0LiBJIGFsc28gZG9uJ3QgZnVsbHkKICogdW5kZXJzdGFuZCBzZXNzaW9ucy9wZ3JwIGV0Yy4gTGV0IHNvbWVib2R5IHdobyBkb2VzIGV4cGxhaW4gaXQuCiAqCiAqIE9LLCBJIHRoaW5rIEkgaGF2ZSB0aGUgcHJvdGVjdGlvbiBzZW1hbnRpY3MgcmlnaHQuLi4uIHRoaXMgaXMgcmVhbGx5CiAqIG9ubHkgaW1wb3J0YW50IG9uIGEgbXVsdGktdXNlciBzeXN0ZW0gYW55d2F5LCB0byBtYWtlIHN1cmUgb25lIHVzZXIKICogY2FuJ3Qgc2VuZCBhIHNpZ25hbCB0byBhIHByb2Nlc3Mgb3duZWQgYnkgYW5vdGhlci4gIC1UWVQsIDEyLzEyLzkxCiAqCiAqIEF1Y2guIEhhZCB0byBhZGQgdGhlICdkaWRfZXhlYycgZmxhZyB0byBjb25mb3JtIGNvbXBsZXRlbHkgdG8gUE9TSVguCiAqIExCVCAwNC4wMy45NAogKi8KCmFzbWxpbmthZ2UgbG9uZyBzeXNfc2V0cGdpZChwaWRfdCBwaWQsIHBpZF90IHBnaWQpCnsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqcDsKCWludCBlcnIgPSAtRUlOVkFMOwoKCWlmICghcGlkKQoJCXBpZCA9IGN1cnJlbnQtPnBpZDsKCWlmICghcGdpZCkKCQlwZ2lkID0gcGlkOwoJaWYgKHBnaWQgPCAwKQoJCXJldHVybiAtRUlOVkFMOwoKCS8qIEZyb20gdGhpcyBwb2ludCBmb3J3YXJkIHdlIGtlZXAgaG9sZGluZyBvbnRvIHRoZSB0YXNrbGlzdCBsb2NrCgkgKiBzbyB0aGF0IG91ciBwYXJlbnQgZG9lcyBub3QgY2hhbmdlIGZyb20gdW5kZXIgdXMuIC1EYXZlTQoJICovCgl3cml0ZV9sb2NrX2lycSgmdGFza2xpc3RfbG9jayk7CgoJZXJyID0gLUVTUkNIOwoJcCA9IGZpbmRfdGFza19ieV9waWQocGlkKTsKCWlmICghcCkKCQlnb3RvIG91dDsKCgllcnIgPSAtRUlOVkFMOwoJaWYgKCF0aHJlYWRfZ3JvdXBfbGVhZGVyKHApKQoJCWdvdG8gb3V0OwoKCWlmIChwLT5wYXJlbnQgPT0gY3VycmVudCB8fCBwLT5yZWFsX3BhcmVudCA9PSBjdXJyZW50KSB7CgkJZXJyID0gLUVQRVJNOwoJCWlmIChwLT5zaWduYWwtPnNlc3Npb24gIT0gY3VycmVudC0+c2lnbmFsLT5zZXNzaW9uKQoJCQlnb3RvIG91dDsKCQllcnIgPSAtRUFDQ0VTOwoJCWlmIChwLT5kaWRfZXhlYykKCQkJZ290byBvdXQ7Cgl9IGVsc2UgewoJCWVyciA9IC1FU1JDSDsKCQlpZiAocCAhPSBjdXJyZW50KQoJCQlnb3RvIG91dDsKCX0KCgllcnIgPSAtRVBFUk07CglpZiAocC0+c2lnbmFsLT5sZWFkZXIpCgkJZ290byBvdXQ7CgoJaWYgKHBnaWQgIT0gcGlkKSB7CgkJc3RydWN0IHRhc2tfc3RydWN0ICpwOwoKCQlkb19lYWNoX3Rhc2tfcGlkKHBnaWQsIFBJRFRZUEVfUEdJRCwgcCkgewoJCQlpZiAocC0+c2lnbmFsLT5zZXNzaW9uID09IGN1cnJlbnQtPnNpZ25hbC0+c2Vzc2lvbikKCQkJCWdvdG8gb2tfcGdpZDsKCQl9IHdoaWxlX2VhY2hfdGFza19waWQocGdpZCwgUElEVFlQRV9QR0lELCBwKTsKCQlnb3RvIG91dDsKCX0KCm9rX3BnaWQ6CgllcnIgPSBzZWN1cml0eV90YXNrX3NldHBnaWQocCwgcGdpZCk7CglpZiAoZXJyKQoJCWdvdG8gb3V0OwoKCWlmIChwcm9jZXNzX2dyb3VwKHApICE9IHBnaWQpIHsKCQlkZXRhY2hfcGlkKHAsIFBJRFRZUEVfUEdJRCk7CgkJcC0+c2lnbmFsLT5wZ3JwID0gcGdpZDsKCQlhdHRhY2hfcGlkKHAsIFBJRFRZUEVfUEdJRCwgcGdpZCk7Cgl9CgoJZXJyID0gMDsKb3V0OgoJLyogQWxsIHBhdGhzIGxlYWQgdG8gaGVyZSwgdGh1cyB3ZSBhcmUgc2FmZS4gLURhdmVNICovCgl3cml0ZV91bmxvY2tfaXJxKCZ0YXNrbGlzdF9sb2NrKTsKCXJldHVybiBlcnI7Cn0KCmFzbWxpbmthZ2UgbG9uZyBzeXNfZ2V0cGdpZChwaWRfdCBwaWQpCnsKCWlmICghcGlkKSB7CgkJcmV0dXJuIHByb2Nlc3NfZ3JvdXAoY3VycmVudCk7Cgl9IGVsc2UgewoJCWludCByZXR2YWw7CgkJc3RydWN0IHRhc2tfc3RydWN0ICpwOwoKCQlyZWFkX2xvY2soJnRhc2tsaXN0X2xvY2spOwoJCXAgPSBmaW5kX3Rhc2tfYnlfcGlkKHBpZCk7CgoJCXJldHZhbCA9IC1FU1JDSDsKCQlpZiAocCkgewoJCQlyZXR2YWwgPSBzZWN1cml0eV90YXNrX2dldHBnaWQocCk7CgkJCWlmICghcmV0dmFsKQoJCQkJcmV0dmFsID0gcHJvY2Vzc19ncm91cChwKTsKCQl9CgkJcmVhZF91bmxvY2soJnRhc2tsaXN0X2xvY2spOwoJCXJldHVybiByZXR2YWw7Cgl9Cn0KCiNpZmRlZiBfX0FSQ0hfV0FOVF9TWVNfR0VUUEdSUAoKYXNtbGlua2FnZSBsb25nIHN5c19nZXRwZ3JwKHZvaWQpCnsKCS8qIFNNUCAtIGFzc3VtaW5nIHdyaXRlcyBhcmUgd29yZCBhdG9taWMgdGhpcyBpcyBmaW5lICovCglyZXR1cm4gcHJvY2Vzc19ncm91cChjdXJyZW50KTsKfQoKI2VuZGlmCgphc21saW5rYWdlIGxvbmcgc3lzX2dldHNpZChwaWRfdCBwaWQpCnsKCWlmICghcGlkKSB7CgkJcmV0dXJuIGN1cnJlbnQtPnNpZ25hbC0+c2Vzc2lvbjsKCX0gZWxzZSB7CgkJaW50IHJldHZhbDsKCQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnA7CgoJCXJlYWRfbG9jaygmdGFza2xpc3RfbG9jayk7CgkJcCA9IGZpbmRfdGFza19ieV9waWQocGlkKTsKCgkJcmV0dmFsID0gLUVTUkNIOwoJCWlmKHApIHsKCQkJcmV0dmFsID0gc2VjdXJpdHlfdGFza19nZXRzaWQocCk7CgkJCWlmICghcmV0dmFsKQoJCQkJcmV0dmFsID0gcC0+c2lnbmFsLT5zZXNzaW9uOwoJCX0KCQlyZWFkX3VubG9jaygmdGFza2xpc3RfbG9jayk7CgkJcmV0dXJuIHJldHZhbDsKCX0KfQoKYXNtbGlua2FnZSBsb25nIHN5c19zZXRzaWQodm9pZCkKewoJc3RydWN0IHBpZCAqcGlkOwoJaW50IGVyciA9IC1FUEVSTTsKCglpZiAoIXRocmVhZF9ncm91cF9sZWFkZXIoY3VycmVudCkpCgkJcmV0dXJuIC1FSU5WQUw7CgoJZG93bigmdHR5X3NlbSk7Cgl3cml0ZV9sb2NrX2lycSgmdGFza2xpc3RfbG9jayk7CgoJcGlkID0gZmluZF9waWQoUElEVFlQRV9QR0lELCBjdXJyZW50LT5waWQpOwoJaWYgKHBpZCkKCQlnb3RvIG91dDsKCgljdXJyZW50LT5zaWduYWwtPmxlYWRlciA9IDE7CglfX3NldF9zcGVjaWFsX3BpZHMoY3VycmVudC0+cGlkLCBjdXJyZW50LT5waWQpOwoJY3VycmVudC0+c2lnbmFsLT50dHkgPSBOVUxMOwoJY3VycmVudC0+c2lnbmFsLT50dHlfb2xkX3BncnAgPSAwOwoJZXJyID0gcHJvY2Vzc19ncm91cChjdXJyZW50KTsKb3V0OgoJd3JpdGVfdW5sb2NrX2lycSgmdGFza2xpc3RfbG9jayk7Cgl1cCgmdHR5X3NlbSk7CglyZXR1cm4gZXJyOwp9CgovKgogKiBTdXBwbGVtZW50YXJ5IGdyb3VwIElEcwogKi8KCi8qIGluaXQgdG8gMiAtIG9uZSBmb3IgaW5pdF90YXNrLCBvbmUgdG8gZW5zdXJlIGl0IGlzIG5ldmVyIGZyZWVkICovCnN0cnVjdCBncm91cF9pbmZvIGluaXRfZ3JvdXBzID0geyAudXNhZ2UgPSBBVE9NSUNfSU5JVCgyKSB9OwoKc3RydWN0IGdyb3VwX2luZm8gKmdyb3Vwc19hbGxvYyhpbnQgZ2lkc2V0c2l6ZSkKewoJc3RydWN0IGdyb3VwX2luZm8gKmdyb3VwX2luZm87CglpbnQgbmJsb2NrczsKCWludCBpOwoKCW5ibG9ja3MgPSAoZ2lkc2V0c2l6ZSArIE5HUk9VUFNfUEVSX0JMT0NLIC0gMSkgLyBOR1JPVVBTX1BFUl9CTE9DSzsKCS8qIE1ha2Ugc3VyZSB3ZSBhbHdheXMgYWxsb2NhdGUgYXQgbGVhc3Qgb25lIGluZGlyZWN0IGJsb2NrIHBvaW50ZXIgKi8KCW5ibG9ja3MgPSBuYmxvY2tzID8gOiAxOwoJZ3JvdXBfaW5mbyA9IGttYWxsb2Moc2l6ZW9mKCpncm91cF9pbmZvKSArIG5ibG9ja3Mqc2l6ZW9mKGdpZF90ICopLCBHRlBfVVNFUik7CglpZiAoIWdyb3VwX2luZm8pCgkJcmV0dXJuIE5VTEw7Cglncm91cF9pbmZvLT5uZ3JvdXBzID0gZ2lkc2V0c2l6ZTsKCWdyb3VwX2luZm8tPm5ibG9ja3MgPSBuYmxvY2tzOwoJYXRvbWljX3NldCgmZ3JvdXBfaW5mby0+dXNhZ2UsIDEpOwoKCWlmIChnaWRzZXRzaXplIDw9IE5HUk9VUFNfU01BTEwpIHsKCQlncm91cF9pbmZvLT5ibG9ja3NbMF0gPSBncm91cF9pbmZvLT5zbWFsbF9ibG9jazsKCX0gZWxzZSB7CgkJZm9yIChpID0gMDsgaSA8IG5ibG9ja3M7IGkrKykgewoJCQlnaWRfdCAqYjsKCQkJYiA9ICh2b2lkICopX19nZXRfZnJlZV9wYWdlKEdGUF9VU0VSKTsKCQkJaWYgKCFiKQoJCQkJZ290byBvdXRfdW5kb19wYXJ0aWFsX2FsbG9jOwoJCQlncm91cF9pbmZvLT5ibG9ja3NbaV0gPSBiOwoJCX0KCX0KCXJldHVybiBncm91cF9pbmZvOwoKb3V0X3VuZG9fcGFydGlhbF9hbGxvYzoKCXdoaWxlICgtLWkgPj0gMCkgewoJCWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylncm91cF9pbmZvLT5ibG9ja3NbaV0pOwoJfQoJa2ZyZWUoZ3JvdXBfaW5mbyk7CglyZXR1cm4gTlVMTDsKfQoKRVhQT1JUX1NZTUJPTChncm91cHNfYWxsb2MpOwoKdm9pZCBncm91cHNfZnJlZShzdHJ1Y3QgZ3JvdXBfaW5mbyAqZ3JvdXBfaW5mbykKewoJaWYgKGdyb3VwX2luZm8tPmJsb2Nrc1swXSAhPSBncm91cF9pbmZvLT5zbWFsbF9ibG9jaykgewoJCWludCBpOwoJCWZvciAoaSA9IDA7IGkgPCBncm91cF9pbmZvLT5uYmxvY2tzOyBpKyspCgkJCWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylncm91cF9pbmZvLT5ibG9ja3NbaV0pOwoJfQoJa2ZyZWUoZ3JvdXBfaW5mbyk7Cn0KCkVYUE9SVF9TWU1CT0woZ3JvdXBzX2ZyZWUpOwoKLyogZXhwb3J0IHRoZSBncm91cF9pbmZvIHRvIGEgdXNlci1zcGFjZSBhcnJheSAqLwpzdGF0aWMgaW50IGdyb3Vwc190b191c2VyKGdpZF90IF9fdXNlciAqZ3JvdXBsaXN0LAogICAgc3RydWN0IGdyb3VwX2luZm8gKmdyb3VwX2luZm8pCnsKCWludCBpOwoJaW50IGNvdW50ID0gZ3JvdXBfaW5mby0+bmdyb3VwczsKCglmb3IgKGkgPSAwOyBpIDwgZ3JvdXBfaW5mby0+bmJsb2NrczsgaSsrKSB7CgkJaW50IGNwX2NvdW50ID0gbWluKE5HUk9VUFNfUEVSX0JMT0NLLCBjb3VudCk7CgkJaW50IG9mZiA9IGkgKiBOR1JPVVBTX1BFUl9CTE9DSzsKCQlpbnQgbGVuID0gY3BfY291bnQgKiBzaXplb2YoKmdyb3VwbGlzdCk7CgoJCWlmIChjb3B5X3RvX3VzZXIoZ3JvdXBsaXN0K29mZiwgZ3JvdXBfaW5mby0+YmxvY2tzW2ldLCBsZW4pKQoJCQlyZXR1cm4gLUVGQVVMVDsKCgkJY291bnQgLT0gY3BfY291bnQ7Cgl9CglyZXR1cm4gMDsKfQoKLyogZmlsbCBhIGdyb3VwX2luZm8gZnJvbSBhIHVzZXItc3BhY2UgYXJyYXkgLSBpdCBtdXN0IGJlIGFsbG9jYXRlZCBhbHJlYWR5ICovCnN0YXRpYyBpbnQgZ3JvdXBzX2Zyb21fdXNlcihzdHJ1Y3QgZ3JvdXBfaW5mbyAqZ3JvdXBfaW5mbywKICAgIGdpZF90IF9fdXNlciAqZ3JvdXBsaXN0KQogewoJaW50IGk7CglpbnQgY291bnQgPSBncm91cF9pbmZvLT5uZ3JvdXBzOwoKCWZvciAoaSA9IDA7IGkgPCBncm91cF9pbmZvLT5uYmxvY2tzOyBpKyspIHsKCQlpbnQgY3BfY291bnQgPSBtaW4oTkdST1VQU19QRVJfQkxPQ0ssIGNvdW50KTsKCQlpbnQgb2ZmID0gaSAqIE5HUk9VUFNfUEVSX0JMT0NLOwoJCWludCBsZW4gPSBjcF9jb3VudCAqIHNpemVvZigqZ3JvdXBsaXN0KTsKCgkJaWYgKGNvcHlfZnJvbV91c2VyKGdyb3VwX2luZm8tPmJsb2Nrc1tpXSwgZ3JvdXBsaXN0K29mZiwgbGVuKSkKCQkJcmV0dXJuIC1FRkFVTFQ7CgoJCWNvdW50IC09IGNwX2NvdW50OwoJfQoJcmV0dXJuIDA7Cn0KCi8qIGEgc2ltcGxlIHNoZWxsLW1ldHpuZXIgc29ydCAqLwpzdGF0aWMgdm9pZCBncm91cHNfc29ydChzdHJ1Y3QgZ3JvdXBfaW5mbyAqZ3JvdXBfaW5mbykKewoJaW50IGJhc2UsIG1heCwgc3RyaWRlOwoJaW50IGdpZHNldHNpemUgPSBncm91cF9pbmZvLT5uZ3JvdXBzOwoKCWZvciAoc3RyaWRlID0gMTsgc3RyaWRlIDwgZ2lkc2V0c2l6ZTsgc3RyaWRlID0gMyAqIHN0cmlkZSArIDEpCgkJOyAvKiBub3RoaW5nICovCglzdHJpZGUgLz0gMzsKCgl3aGlsZSAoc3RyaWRlKSB7CgkJbWF4ID0gZ2lkc2V0c2l6ZSAtIHN0cmlkZTsKCQlmb3IgKGJhc2UgPSAwOyBiYXNlIDwgbWF4OyBiYXNlKyspIHsKCQkJaW50IGxlZnQgPSBiYXNlOwoJCQlpbnQgcmlnaHQgPSBsZWZ0ICsgc3RyaWRlOwoJCQlnaWRfdCB0bXAgPSBHUk9VUF9BVChncm91cF9pbmZvLCByaWdodCk7CgoJCQl3aGlsZSAobGVmdCA+PSAwICYmIEdST1VQX0FUKGdyb3VwX2luZm8sIGxlZnQpID4gdG1wKSB7CgkJCQlHUk9VUF9BVChncm91cF9pbmZvLCByaWdodCkgPQoJCQkJICAgIEdST1VQX0FUKGdyb3VwX2luZm8sIGxlZnQpOwoJCQkJcmlnaHQgPSBsZWZ0OwoJCQkJbGVmdCAtPSBzdHJpZGU7CgkJCX0KCQkJR1JPVVBfQVQoZ3JvdXBfaW5mbywgcmlnaHQpID0gdG1wOwoJCX0KCQlzdHJpZGUgLz0gMzsKCX0KfQoKLyogYSBzaW1wbGUgYnNlYXJjaCAqLwpzdGF0aWMgaW50IGdyb3Vwc19zZWFyY2goc3RydWN0IGdyb3VwX2luZm8gKmdyb3VwX2luZm8sIGdpZF90IGdycCkKewoJaW50IGxlZnQsIHJpZ2h0OwoKCWlmICghZ3JvdXBfaW5mbykKCQlyZXR1cm4gMDsKCglsZWZ0ID0gMDsKCXJpZ2h0ID0gZ3JvdXBfaW5mby0+bmdyb3VwczsKCXdoaWxlIChsZWZ0IDwgcmlnaHQpIHsKCQlpbnQgbWlkID0gKGxlZnQrcmlnaHQpLzI7CgkJaW50IGNtcCA9IGdycCAtIEdST1VQX0FUKGdyb3VwX2luZm8sIG1pZCk7CgkJaWYgKGNtcCA+IDApCgkJCWxlZnQgPSBtaWQgKyAxOwoJCWVsc2UgaWYgKGNtcCA8IDApCgkJCXJpZ2h0ID0gbWlkOwoJCWVsc2UKCQkJcmV0dXJuIDE7Cgl9CglyZXR1cm4gMDsKfQoKLyogdmFsaWRhdGUgYW5kIHNldCBjdXJyZW50LT5ncm91cF9pbmZvICovCmludCBzZXRfY3VycmVudF9ncm91cHMoc3RydWN0IGdyb3VwX2luZm8gKmdyb3VwX2luZm8pCnsKCWludCByZXR2YWw7CglzdHJ1Y3QgZ3JvdXBfaW5mbyAqb2xkX2luZm87CgoJcmV0dmFsID0gc2VjdXJpdHlfdGFza19zZXRncm91cHMoZ3JvdXBfaW5mbyk7CglpZiAocmV0dmFsKQoJCXJldHVybiByZXR2YWw7CgoJZ3JvdXBzX3NvcnQoZ3JvdXBfaW5mbyk7CglnZXRfZ3JvdXBfaW5mbyhncm91cF9pbmZvKTsKCgl0YXNrX2xvY2soY3VycmVudCk7CglvbGRfaW5mbyA9IGN1cnJlbnQtPmdyb3VwX2luZm87CgljdXJyZW50LT5ncm91cF9pbmZvID0gZ3JvdXBfaW5mbzsKCXRhc2tfdW5sb2NrKGN1cnJlbnQpOwoKCXB1dF9ncm91cF9pbmZvKG9sZF9pbmZvKTsKCglyZXR1cm4gMDsKfQoKRVhQT1JUX1NZTUJPTChzZXRfY3VycmVudF9ncm91cHMpOwoKYXNtbGlua2FnZSBsb25nIHN5c19nZXRncm91cHMoaW50IGdpZHNldHNpemUsIGdpZF90IF9fdXNlciAqZ3JvdXBsaXN0KQp7CglpbnQgaSA9IDA7CgoJLyoKCSAqCVNNUDogTm9ib2R5IGVsc2UgY2FuIGNoYW5nZSBvdXIgZ3JvdXBsaXN0LiBUaHVzIHdlIGFyZQoJICoJc2FmZS4KCSAqLwoKCWlmIChnaWRzZXRzaXplIDwgMCkKCQlyZXR1cm4gLUVJTlZBTDsKCgkvKiBubyBuZWVkIHRvIGdyYWIgdGFza19sb2NrIGhlcmU7IGl0IGNhbm5vdCBjaGFuZ2UgKi8KCWdldF9ncm91cF9pbmZvKGN1cnJlbnQtPmdyb3VwX2luZm8pOwoJaSA9IGN1cnJlbnQtPmdyb3VwX2luZm8tPm5ncm91cHM7CglpZiAoZ2lkc2V0c2l6ZSkgewoJCWlmIChpID4gZ2lkc2V0c2l6ZSkgewoJCQlpID0gLUVJTlZBTDsKCQkJZ290byBvdXQ7CgkJfQoJCWlmIChncm91cHNfdG9fdXNlcihncm91cGxpc3QsIGN1cnJlbnQtPmdyb3VwX2luZm8pKSB7CgkJCWkgPSAtRUZBVUxUOwoJCQlnb3RvIG91dDsKCQl9Cgl9Cm91dDoKCXB1dF9ncm91cF9pbmZvKGN1cnJlbnQtPmdyb3VwX2luZm8pOwoJcmV0dXJuIGk7Cn0KCi8qCiAqCVNNUDogT3VyIGdyb3VwcyBhcmUgY29weS1vbi13cml0ZS4gV2UgY2FuIHNldCB0aGVtIHNhZmVseQogKgl3aXRob3V0IGFub3RoZXIgdGFzayBpbnRlcmZlcmluZy4KICovCiAKYXNtbGlua2FnZSBsb25nIHN5c19zZXRncm91cHMoaW50IGdpZHNldHNpemUsIGdpZF90IF9fdXNlciAqZ3JvdXBsaXN0KQp7CglzdHJ1Y3QgZ3JvdXBfaW5mbyAqZ3JvdXBfaW5mbzsKCWludCByZXR2YWw7CgoJaWYgKCFjYXBhYmxlKENBUF9TRVRHSUQpKQoJCXJldHVybiAtRVBFUk07CglpZiAoKHVuc2lnbmVkKWdpZHNldHNpemUgPiBOR1JPVVBTX01BWCkKCQlyZXR1cm4gLUVJTlZBTDsKCglncm91cF9pbmZvID0gZ3JvdXBzX2FsbG9jKGdpZHNldHNpemUpOwoJaWYgKCFncm91cF9pbmZvKQoJCXJldHVybiAtRU5PTUVNOwoJcmV0dmFsID0gZ3JvdXBzX2Zyb21fdXNlcihncm91cF9pbmZvLCBncm91cGxpc3QpOwoJaWYgKHJldHZhbCkgewoJCXB1dF9ncm91cF9pbmZvKGdyb3VwX2luZm8pOwoJCXJldHVybiByZXR2YWw7Cgl9CgoJcmV0dmFsID0gc2V0X2N1cnJlbnRfZ3JvdXBzKGdyb3VwX2luZm8pOwoJcHV0X2dyb3VwX2luZm8oZ3JvdXBfaW5mbyk7CgoJcmV0dXJuIHJldHZhbDsKfQoKLyoKICogQ2hlY2sgd2hldGhlciB3ZSdyZSBmc2dpZC9lZ2lkIG9yIGluIHRoZSBzdXBwbGVtZW50YWwgZ3JvdXAuLgogKi8KaW50IGluX2dyb3VwX3AoZ2lkX3QgZ3JwKQp7CglpbnQgcmV0dmFsID0gMTsKCWlmIChncnAgIT0gY3VycmVudC0+ZnNnaWQpIHsKCQlnZXRfZ3JvdXBfaW5mbyhjdXJyZW50LT5ncm91cF9pbmZvKTsKCQlyZXR2YWwgPSBncm91cHNfc2VhcmNoKGN1cnJlbnQtPmdyb3VwX2luZm8sIGdycCk7CgkJcHV0X2dyb3VwX2luZm8oY3VycmVudC0+Z3JvdXBfaW5mbyk7Cgl9CglyZXR1cm4gcmV0dmFsOwp9CgpFWFBPUlRfU1lNQk9MKGluX2dyb3VwX3ApOwoKaW50IGluX2Vncm91cF9wKGdpZF90IGdycCkKewoJaW50IHJldHZhbCA9IDE7CglpZiAoZ3JwICE9IGN1cnJlbnQtPmVnaWQpIHsKCQlnZXRfZ3JvdXBfaW5mbyhjdXJyZW50LT5ncm91cF9pbmZvKTsKCQlyZXR2YWwgPSBncm91cHNfc2VhcmNoKGN1cnJlbnQtPmdyb3VwX2luZm8sIGdycCk7CgkJcHV0X2dyb3VwX2luZm8oY3VycmVudC0+Z3JvdXBfaW5mbyk7Cgl9CglyZXR1cm4gcmV0dmFsOwp9CgpFWFBPUlRfU1lNQk9MKGluX2Vncm91cF9wKTsKCkRFQ0xBUkVfUldTRU0odXRzX3NlbSk7CgpFWFBPUlRfU1lNQk9MKHV0c19zZW0pOwoKYXNtbGlua2FnZSBsb25nIHN5c19uZXd1bmFtZShzdHJ1Y3QgbmV3X3V0c25hbWUgX191c2VyICogbmFtZSkKewoJaW50IGVycm5vID0gMDsKCglkb3duX3JlYWQoJnV0c19zZW0pOwoJaWYgKGNvcHlfdG9fdXNlcihuYW1lLCZzeXN0ZW1fdXRzbmFtZSxzaXplb2YgKm5hbWUpKQoJCWVycm5vID0gLUVGQVVMVDsKCXVwX3JlYWQoJnV0c19zZW0pOwoJcmV0dXJuIGVycm5vOwp9Cgphc21saW5rYWdlIGxvbmcgc3lzX3NldGhvc3RuYW1lKGNoYXIgX191c2VyICpuYW1lLCBpbnQgbGVuKQp7CglpbnQgZXJybm87CgljaGFyIHRtcFtfX05FV19VVFNfTEVOXTsKCglpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCgkJcmV0dXJuIC1FUEVSTTsKCWlmIChsZW4gPCAwIHx8IGxlbiA+IF9fTkVXX1VUU19MRU4pCgkJcmV0dXJuIC1FSU5WQUw7Cglkb3duX3dyaXRlKCZ1dHNfc2VtKTsKCWVycm5vID0gLUVGQVVMVDsKCWlmICghY29weV9mcm9tX3VzZXIodG1wLCBuYW1lLCBsZW4pKSB7CgkJbWVtY3B5KHN5c3RlbV91dHNuYW1lLm5vZGVuYW1lLCB0bXAsIGxlbik7CgkJc3lzdGVtX3V0c25hbWUubm9kZW5hbWVbbGVuXSA9IDA7CgkJZXJybm8gPSAwOwoJfQoJdXBfd3JpdGUoJnV0c19zZW0pOwoJcmV0dXJuIGVycm5vOwp9CgojaWZkZWYgX19BUkNIX1dBTlRfU1lTX0dFVEhPU1ROQU1FCgphc21saW5rYWdlIGxvbmcgc3lzX2dldGhvc3RuYW1lKGNoYXIgX191c2VyICpuYW1lLCBpbnQgbGVuKQp7CglpbnQgaSwgZXJybm87CgoJaWYgKGxlbiA8IDApCgkJcmV0dXJuIC1FSU5WQUw7Cglkb3duX3JlYWQoJnV0c19zZW0pOwoJaSA9IDEgKyBzdHJsZW4oc3lzdGVtX3V0c25hbWUubm9kZW5hbWUpOwoJaWYgKGkgPiBsZW4pCgkJaSA9IGxlbjsKCWVycm5vID0gMDsKCWlmIChjb3B5X3RvX3VzZXIobmFtZSwgc3lzdGVtX3V0c25hbWUubm9kZW5hbWUsIGkpKQoJCWVycm5vID0gLUVGQVVMVDsKCXVwX3JlYWQoJnV0c19zZW0pOwoJcmV0dXJuIGVycm5vOwp9CgojZW5kaWYKCi8qCiAqIE9ubHkgc2V0ZG9tYWlubmFtZTsgZ2V0ZG9tYWlubmFtZSBjYW4gYmUgaW1wbGVtZW50ZWQgYnkgY2FsbGluZwogKiB1bmFtZSgpCiAqLwphc21saW5rYWdlIGxvbmcgc3lzX3NldGRvbWFpbm5hbWUoY2hhciBfX3VzZXIgKm5hbWUsIGludCBsZW4pCnsKCWludCBlcnJubzsKCWNoYXIgdG1wW19fTkVXX1VUU19MRU5dOwoKCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKCQlyZXR1cm4gLUVQRVJNOwoJaWYgKGxlbiA8IDAgfHwgbGVuID4gX19ORVdfVVRTX0xFTikKCQlyZXR1cm4gLUVJTlZBTDsKCglkb3duX3dyaXRlKCZ1dHNfc2VtKTsKCWVycm5vID0gLUVGQVVMVDsKCWlmICghY29weV9mcm9tX3VzZXIodG1wLCBuYW1lLCBsZW4pKSB7CgkJbWVtY3B5KHN5c3RlbV91dHNuYW1lLmRvbWFpbm5hbWUsIHRtcCwgbGVuKTsKCQlzeXN0ZW1fdXRzbmFtZS5kb21haW5uYW1lW2xlbl0gPSAwOwoJCWVycm5vID0gMDsKCX0KCXVwX3dyaXRlKCZ1dHNfc2VtKTsKCXJldHVybiBlcnJubzsKfQoKYXNtbGlua2FnZSBsb25nIHN5c19nZXRybGltaXQodW5zaWduZWQgaW50IHJlc291cmNlLCBzdHJ1Y3QgcmxpbWl0IF9fdXNlciAqcmxpbSkKewoJaWYgKHJlc291cmNlID49IFJMSU1fTkxJTUlUUykKCQlyZXR1cm4gLUVJTlZBTDsKCWVsc2UgewoJCXN0cnVjdCBybGltaXQgdmFsdWU7CgkJdGFza19sb2NrKGN1cnJlbnQtPmdyb3VwX2xlYWRlcik7CgkJdmFsdWUgPSBjdXJyZW50LT5zaWduYWwtPnJsaW1bcmVzb3VyY2VdOwoJCXRhc2tfdW5sb2NrKGN1cnJlbnQtPmdyb3VwX2xlYWRlcik7CgkJcmV0dXJuIGNvcHlfdG9fdXNlcihybGltLCAmdmFsdWUsIHNpemVvZigqcmxpbSkpID8gLUVGQVVMVCA6IDA7Cgl9Cn0KCiNpZmRlZiBfX0FSQ0hfV0FOVF9TWVNfT0xEX0dFVFJMSU1JVAoKLyoKICoJQmFjayBjb21wYXRpYmlsaXR5IGZvciBnZXRybGltaXQuIE5lZWRlZCBmb3Igc29tZSBhcHBzLgogKi8KIAphc21saW5rYWdlIGxvbmcgc3lzX29sZF9nZXRybGltaXQodW5zaWduZWQgaW50IHJlc291cmNlLCBzdHJ1Y3QgcmxpbWl0IF9fdXNlciAqcmxpbSkKewoJc3RydWN0IHJsaW1pdCB4OwoJaWYgKHJlc291cmNlID49IFJMSU1fTkxJTUlUUykKCQlyZXR1cm4gLUVJTlZBTDsKCgl0YXNrX2xvY2soY3VycmVudC0+Z3JvdXBfbGVhZGVyKTsKCXggPSBjdXJyZW50LT5zaWduYWwtPnJsaW1bcmVzb3VyY2VdOwoJdGFza191bmxvY2soY3VycmVudC0+Z3JvdXBfbGVhZGVyKTsKCWlmKHgucmxpbV9jdXIgPiAweDdGRkZGRkZGKQoJCXgucmxpbV9jdXIgPSAweDdGRkZGRkZGOwoJaWYoeC5ybGltX21heCA+IDB4N0ZGRkZGRkYpCgkJeC5ybGltX21heCA9IDB4N0ZGRkZGRkY7CglyZXR1cm4gY29weV90b191c2VyKHJsaW0sICZ4LCBzaXplb2YoeCkpPy1FRkFVTFQ6MDsKfQoKI2VuZGlmCgphc21saW5rYWdlIGxvbmcgc3lzX3NldHJsaW1pdCh1bnNpZ25lZCBpbnQgcmVzb3VyY2UsIHN0cnVjdCBybGltaXQgX191c2VyICpybGltKQp7CglzdHJ1Y3QgcmxpbWl0IG5ld19ybGltLCAqb2xkX3JsaW07CglpbnQgcmV0dmFsOwoKCWlmIChyZXNvdXJjZSA+PSBSTElNX05MSU1JVFMpCgkJcmV0dXJuIC1FSU5WQUw7CglpZihjb3B5X2Zyb21fdXNlcigmbmV3X3JsaW0sIHJsaW0sIHNpemVvZigqcmxpbSkpKQoJCXJldHVybiAtRUZBVUxUOwogICAgICAgaWYgKG5ld19ybGltLnJsaW1fY3VyID4gbmV3X3JsaW0ucmxpbV9tYXgpCiAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwoJb2xkX3JsaW0gPSBjdXJyZW50LT5zaWduYWwtPnJsaW0gKyByZXNvdXJjZTsKCWlmICgobmV3X3JsaW0ucmxpbV9tYXggPiBvbGRfcmxpbS0+cmxpbV9tYXgpICYmCgkgICAgIWNhcGFibGUoQ0FQX1NZU19SRVNPVVJDRSkpCgkJcmV0dXJuIC1FUEVSTTsKCWlmIChyZXNvdXJjZSA9PSBSTElNSVRfTk9GSUxFICYmIG5ld19ybGltLnJsaW1fbWF4ID4gTlJfT1BFTikKCQkJcmV0dXJuIC1FUEVSTTsKCglyZXR2YWwgPSBzZWN1cml0eV90YXNrX3NldHJsaW1pdChyZXNvdXJjZSwgJm5ld19ybGltKTsKCWlmIChyZXR2YWwpCgkJcmV0dXJuIHJldHZhbDsKCgl0YXNrX2xvY2soY3VycmVudC0+Z3JvdXBfbGVhZGVyKTsKCSpvbGRfcmxpbSA9IG5ld19ybGltOwoJdGFza191bmxvY2soY3VycmVudC0+Z3JvdXBfbGVhZGVyKTsKCglpZiAocmVzb3VyY2UgPT0gUkxJTUlUX0NQVSAmJiBuZXdfcmxpbS5ybGltX2N1ciAhPSBSTElNX0lORklOSVRZICYmCgkgICAgKGNwdXRpbWVfZXEoY3VycmVudC0+c2lnbmFsLT5pdF9wcm9mX2V4cGlyZXMsIGNwdXRpbWVfemVybykgfHwKCSAgICAgbmV3X3JsaW0ucmxpbV9jdXIgPD0gY3B1dGltZV90b19zZWNzKAoJCSAgICAgY3VycmVudC0+c2lnbmFsLT5pdF9wcm9mX2V4cGlyZXMpKSkgewoJCWNwdXRpbWVfdCBjcHV0aW1lID0gc2Vjc190b19jcHV0aW1lKG5ld19ybGltLnJsaW1fY3VyKTsKCQlyZWFkX2xvY2soJnRhc2tsaXN0X2xvY2spOwoJCXNwaW5fbG9ja19pcnEoJmN1cnJlbnQtPnNpZ2hhbmQtPnNpZ2xvY2spOwoJCXNldF9wcm9jZXNzX2NwdV90aW1lcihjdXJyZW50LCBDUFVDTE9DS19QUk9GLAoJCQkJICAgICAgJmNwdXRpbWUsIE5VTEwpOwoJCXNwaW5fdW5sb2NrX2lycSgmY3VycmVudC0+c2lnaGFuZC0+c2lnbG9jayk7CgkJcmVhZF91bmxvY2soJnRhc2tsaXN0X2xvY2spOwoJfQoKCXJldHVybiAwOwp9CgovKgogKiBJdCB3b3VsZCBtYWtlIHNlbnNlIHRvIHB1dCBzdHJ1Y3QgcnVzYWdlIGluIHRoZSB0YXNrX3N0cnVjdCwKICogZXhjZXB0IHRoYXQgd291bGQgbWFrZSB0aGUgdGFza19zdHJ1Y3QgYmUgKnJlYWxseSBiaWcqLiAgQWZ0ZXIKICogdGFza19zdHJ1Y3QgZ2V0cyBtb3ZlZCBpbnRvIG1hbGxvYydlZCBtZW1vcnksIGl0IHdvdWxkCiAqIG1ha2Ugc2Vuc2UgdG8gZG8gdGhpcy4gIEl0IHdpbGwgbWFrZSBtb3ZpbmcgdGhlIHJlc3Qgb2YgdGhlIGluZm9ybWF0aW9uCiAqIGEgbG90IHNpbXBsZXIhICAoV2hpY2ggd2UncmUgbm90IGRvaW5nIHJpZ2h0IG5vdyBiZWNhdXNlIHdlJ3JlIG5vdAogKiBtZWFzdXJpbmcgdGhlbSB5ZXQpLgogKgogKiBUaGlzIGV4cGVjdHMgdG8gYmUgY2FsbGVkIHdpdGggdGFza2xpc3RfbG9jayByZWFkLWxvY2tlZCBvciBiZXR0ZXIsCiAqIGFuZCB0aGUgc2lnbG9jayBub3QgbG9ja2VkLiAgSXQgbWF5IG1vbWVudGFyaWx5IHRha2UgdGhlIHNpZ2xvY2suCiAqCiAqIFdoZW4gc2FtcGxpbmcgbXVsdGlwbGUgdGhyZWFkcyBmb3IgUlVTQUdFX1NFTEYsIHVuZGVyIFNNUCB3ZSBtaWdodCBoYXZlCiAqIHJhY2VzIHdpdGggdGhyZWFkcyBpbmNyZW1lbnRpbmcgdGhlaXIgb3duIGNvdW50ZXJzLiAgQnV0IHNpbmNlIHdvcmQKICogcmVhZHMgYXJlIGF0b21pYywgd2UgZWl0aGVyIGdldCBuZXcgdmFsdWVzIG9yIG9sZCB2YWx1ZXMgYW5kIHdlIGRvbid0CiAqIGNhcmUgd2hpY2ggZm9yIHRoZSBzdW1zLiAgV2UgYWx3YXlzIHRha2UgdGhlIHNpZ2xvY2sgdG8gcHJvdGVjdCByZWFkaW5nCiAqIHRoZSBjKiBmaWVsZHMgZnJvbSBwLT5zaWduYWwgZnJvbSByYWNlcyB3aXRoIGV4aXQuYyB1cGRhdGluZyB0aG9zZQogKiBmaWVsZHMgd2hlbiByZWFwaW5nLCBzbyBhIHNhbXBsZSBlaXRoZXIgZ2V0cyBhbGwgdGhlIGFkZGl0aW9ucyBvZiBhCiAqIGdpdmVuIGNoaWxkIGFmdGVyIGl0J3MgcmVhcGVkLCBvciBub25lIHNvIHRoaXMgc2FtcGxlIGlzIGJlZm9yZSByZWFwaW5nLgogKi8KCnN0YXRpYyB2b2lkIGtfZ2V0cnVzYWdlKHN0cnVjdCB0YXNrX3N0cnVjdCAqcCwgaW50IHdobywgc3RydWN0IHJ1c2FnZSAqcikKewoJc3RydWN0IHRhc2tfc3RydWN0ICp0OwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWNwdXRpbWVfdCB1dGltZSwgc3RpbWU7CgoJbWVtc2V0KChjaGFyICopIHIsIDAsIHNpemVvZiAqcik7CgoJaWYgKHVubGlrZWx5KCFwLT5zaWduYWwpKQoJCXJldHVybjsKCglzd2l0Y2ggKHdobykgewoJCWNhc2UgUlVTQUdFX0NISUxEUkVOOgoJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcC0+c2lnaGFuZC0+c2lnbG9jaywgZmxhZ3MpOwoJCQl1dGltZSA9IHAtPnNpZ25hbC0+Y3V0aW1lOwoJCQlzdGltZSA9IHAtPnNpZ25hbC0+Y3N0aW1lOwoJCQlyLT5ydV9udmNzdyA9IHAtPnNpZ25hbC0+Y252Y3N3OwoJCQlyLT5ydV9uaXZjc3cgPSBwLT5zaWduYWwtPmNuaXZjc3c7CgkJCXItPnJ1X21pbmZsdCA9IHAtPnNpZ25hbC0+Y21pbl9mbHQ7CgkJCXItPnJ1X21hamZsdCA9IHAtPnNpZ25hbC0+Y21hal9mbHQ7CgkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnAtPnNpZ2hhbmQtPnNpZ2xvY2ssIGZsYWdzKTsKCQkJY3B1dGltZV90b190aW1ldmFsKHV0aW1lLCAmci0+cnVfdXRpbWUpOwoJCQljcHV0aW1lX3RvX3RpbWV2YWwoc3RpbWUsICZyLT5ydV9zdGltZSk7CgkJCWJyZWFrOwoJCWNhc2UgUlVTQUdFX1NFTEY6CgkJCXNwaW5fbG9ja19pcnFzYXZlKCZwLT5zaWdoYW5kLT5zaWdsb2NrLCBmbGFncyk7CgkJCXV0aW1lID0gc3RpbWUgPSBjcHV0aW1lX3plcm87CgkJCWdvdG8gc3VtX2dyb3VwOwoJCWNhc2UgUlVTQUdFX0JPVEg6CgkJCXNwaW5fbG9ja19pcnFzYXZlKCZwLT5zaWdoYW5kLT5zaWdsb2NrLCBmbGFncyk7CgkJCXV0aW1lID0gcC0+c2lnbmFsLT5jdXRpbWU7CgkJCXN0aW1lID0gcC0+c2lnbmFsLT5jc3RpbWU7CgkJCXItPnJ1X252Y3N3ID0gcC0+c2lnbmFsLT5jbnZjc3c7CgkJCXItPnJ1X25pdmNzdyA9IHAtPnNpZ25hbC0+Y25pdmNzdzsKCQkJci0+cnVfbWluZmx0ID0gcC0+c2lnbmFsLT5jbWluX2ZsdDsKCQkJci0+cnVfbWFqZmx0ID0gcC0+c2lnbmFsLT5jbWFqX2ZsdDsKCQlzdW1fZ3JvdXA6CgkJCXV0aW1lID0gY3B1dGltZV9hZGQodXRpbWUsIHAtPnNpZ25hbC0+dXRpbWUpOwoJCQlzdGltZSA9IGNwdXRpbWVfYWRkKHN0aW1lLCBwLT5zaWduYWwtPnN0aW1lKTsKCQkJci0+cnVfbnZjc3cgKz0gcC0+c2lnbmFsLT5udmNzdzsKCQkJci0+cnVfbml2Y3N3ICs9IHAtPnNpZ25hbC0+bml2Y3N3OwoJCQlyLT5ydV9taW5mbHQgKz0gcC0+c2lnbmFsLT5taW5fZmx0OwoJCQlyLT5ydV9tYWpmbHQgKz0gcC0+c2lnbmFsLT5tYWpfZmx0OwoJCQl0ID0gcDsKCQkJZG8gewoJCQkJdXRpbWUgPSBjcHV0aW1lX2FkZCh1dGltZSwgdC0+dXRpbWUpOwoJCQkJc3RpbWUgPSBjcHV0aW1lX2FkZChzdGltZSwgdC0+c3RpbWUpOwoJCQkJci0+cnVfbnZjc3cgKz0gdC0+bnZjc3c7CgkJCQlyLT5ydV9uaXZjc3cgKz0gdC0+bml2Y3N3OwoJCQkJci0+cnVfbWluZmx0ICs9IHQtPm1pbl9mbHQ7CgkJCQlyLT5ydV9tYWpmbHQgKz0gdC0+bWFqX2ZsdDsKCQkJCXQgPSBuZXh0X3RocmVhZCh0KTsKCQkJfSB3aGlsZSAodCAhPSBwKTsKCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcC0+c2lnaGFuZC0+c2lnbG9jaywgZmxhZ3MpOwoJCQljcHV0aW1lX3RvX3RpbWV2YWwodXRpbWUsICZyLT5ydV91dGltZSk7CgkJCWNwdXRpbWVfdG9fdGltZXZhbChzdGltZSwgJnItPnJ1X3N0aW1lKTsKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJQlVHKCk7Cgl9Cn0KCmludCBnZXRydXNhZ2Uoc3RydWN0IHRhc2tfc3RydWN0ICpwLCBpbnQgd2hvLCBzdHJ1Y3QgcnVzYWdlIF9fdXNlciAqcnUpCnsKCXN0cnVjdCBydXNhZ2UgcjsKCXJlYWRfbG9jaygmdGFza2xpc3RfbG9jayk7CglrX2dldHJ1c2FnZShwLCB3aG8sICZyKTsKCXJlYWRfdW5sb2NrKCZ0YXNrbGlzdF9sb2NrKTsKCXJldHVybiBjb3B5X3RvX3VzZXIocnUsICZyLCBzaXplb2YocikpID8gLUVGQVVMVCA6IDA7Cn0KCmFzbWxpbmthZ2UgbG9uZyBzeXNfZ2V0cnVzYWdlKGludCB3aG8sIHN0cnVjdCBydXNhZ2UgX191c2VyICpydSkKewoJaWYgKHdobyAhPSBSVVNBR0VfU0VMRiAmJiB3aG8gIT0gUlVTQUdFX0NISUxEUkVOKQoJCXJldHVybiAtRUlOVkFMOwoJcmV0dXJuIGdldHJ1c2FnZShjdXJyZW50LCB3aG8sIHJ1KTsKfQoKYXNtbGlua2FnZSBsb25nIHN5c191bWFzayhpbnQgbWFzaykKewoJbWFzayA9IHhjaGcoJmN1cnJlbnQtPmZzLT51bWFzaywgbWFzayAmIFNfSVJXWFVHTyk7CglyZXR1cm4gbWFzazsKfQogICAgCmFzbWxpbmthZ2UgbG9uZyBzeXNfcHJjdGwoaW50IG9wdGlvbiwgdW5zaWduZWQgbG9uZyBhcmcyLCB1bnNpZ25lZCBsb25nIGFyZzMsCgkJCSAgdW5zaWduZWQgbG9uZyBhcmc0LCB1bnNpZ25lZCBsb25nIGFyZzUpCnsKCWxvbmcgZXJyb3I7CglpbnQgc2lnOwoKCWVycm9yID0gc2VjdXJpdHlfdGFza19wcmN0bChvcHRpb24sIGFyZzIsIGFyZzMsIGFyZzQsIGFyZzUpOwoJaWYgKGVycm9yKQoJCXJldHVybiBlcnJvcjsKCglzd2l0Y2ggKG9wdGlvbikgewoJCWNhc2UgUFJfU0VUX1BERUFUSFNJRzoKCQkJc2lnID0gYXJnMjsKCQkJaWYgKHNpZyA8IDAgfHwgc2lnID4gX05TSUcpIHsKCQkJCWVycm9yID0gLUVJTlZBTDsKCQkJCWJyZWFrOwoJCQl9CgkJCWN1cnJlbnQtPnBkZWF0aF9zaWduYWwgPSBzaWc7CgkJCWJyZWFrOwoJCWNhc2UgUFJfR0VUX1BERUFUSFNJRzoKCQkJZXJyb3IgPSBwdXRfdXNlcihjdXJyZW50LT5wZGVhdGhfc2lnbmFsLCAoaW50IF9fdXNlciAqKWFyZzIpOwoJCQlicmVhazsKCQljYXNlIFBSX0dFVF9EVU1QQUJMRToKCQkJaWYgKGN1cnJlbnQtPm1tLT5kdW1wYWJsZSkKCQkJCWVycm9yID0gMTsKCQkJYnJlYWs7CgkJY2FzZSBQUl9TRVRfRFVNUEFCTEU6CgkJCWlmIChhcmcyICE9IDAgJiYgYXJnMiAhPSAxKSB7CgkJCQllcnJvciA9IC1FSU5WQUw7CgkJCQlicmVhazsKCQkJfQoJCQljdXJyZW50LT5tbS0+ZHVtcGFibGUgPSBhcmcyOwoJCQlicmVhazsKCgkJY2FzZSBQUl9TRVRfVU5BTElHTjoKCQkJZXJyb3IgPSBTRVRfVU5BTElHTl9DVEwoY3VycmVudCwgYXJnMik7CgkJCWJyZWFrOwoJCWNhc2UgUFJfR0VUX1VOQUxJR046CgkJCWVycm9yID0gR0VUX1VOQUxJR05fQ1RMKGN1cnJlbnQsIGFyZzIpOwoJCQlicmVhazsKCQljYXNlIFBSX1NFVF9GUEVNVToKCQkJZXJyb3IgPSBTRVRfRlBFTVVfQ1RMKGN1cnJlbnQsIGFyZzIpOwoJCQlicmVhazsKCQljYXNlIFBSX0dFVF9GUEVNVToKCQkJZXJyb3IgPSBHRVRfRlBFTVVfQ1RMKGN1cnJlbnQsIGFyZzIpOwoJCQlicmVhazsKCQljYXNlIFBSX1NFVF9GUEVYQzoKCQkJZXJyb3IgPSBTRVRfRlBFWENfQ1RMKGN1cnJlbnQsIGFyZzIpOwoJCQlicmVhazsKCQljYXNlIFBSX0dFVF9GUEVYQzoKCQkJZXJyb3IgPSBHRVRfRlBFWENfQ1RMKGN1cnJlbnQsIGFyZzIpOwoJCQlicmVhazsKCQljYXNlIFBSX0dFVF9USU1JTkc6CgkJCWVycm9yID0gUFJfVElNSU5HX1NUQVRJU1RJQ0FMOwoJCQlicmVhazsKCQljYXNlIFBSX1NFVF9USU1JTkc6CgkJCWlmIChhcmcyID09IFBSX1RJTUlOR19TVEFUSVNUSUNBTCkKCQkJCWVycm9yID0gMDsKCQkJZWxzZQoJCQkJZXJyb3IgPSAtRUlOVkFMOwoJCQlicmVhazsKCgkJY2FzZSBQUl9HRVRfS0VFUENBUFM6CgkJCWlmIChjdXJyZW50LT5rZWVwX2NhcGFiaWxpdGllcykKCQkJCWVycm9yID0gMTsKCQkJYnJlYWs7CgkJY2FzZSBQUl9TRVRfS0VFUENBUFM6CgkJCWlmIChhcmcyICE9IDAgJiYgYXJnMiAhPSAxKSB7CgkJCQllcnJvciA9IC1FSU5WQUw7CgkJCQlicmVhazsKCQkJfQoJCQljdXJyZW50LT5rZWVwX2NhcGFiaWxpdGllcyA9IGFyZzI7CgkJCWJyZWFrOwoJCWNhc2UgUFJfU0VUX05BTUU6IHsKCQkJc3RydWN0IHRhc2tfc3RydWN0ICptZSA9IGN1cnJlbnQ7CgkJCXVuc2lnbmVkIGNoYXIgbmNvbW1bc2l6ZW9mKG1lLT5jb21tKV07CgoJCQluY29tbVtzaXplb2YobWUtPmNvbW0pLTFdID0gMDsKCQkJaWYgKHN0cm5jcHlfZnJvbV91c2VyKG5jb21tLCAoY2hhciBfX3VzZXIgKilhcmcyLAoJCQkJCQlzaXplb2YobWUtPmNvbW0pLTEpIDwgMCkKCQkJCXJldHVybiAtRUZBVUxUOwoJCQlzZXRfdGFza19jb21tKG1lLCBuY29tbSk7CgkJCXJldHVybiAwOwoJCX0KCQljYXNlIFBSX0dFVF9OQU1FOiB7CgkJCXN0cnVjdCB0YXNrX3N0cnVjdCAqbWUgPSBjdXJyZW50OwoJCQl1bnNpZ25lZCBjaGFyIHRjb21tW3NpemVvZihtZS0+Y29tbSldOwoKCQkJZ2V0X3Rhc2tfY29tbSh0Y29tbSwgbWUpOwoJCQlpZiAoY29weV90b191c2VyKChjaGFyIF9fdXNlciAqKWFyZzIsIHRjb21tLCBzaXplb2YodGNvbW0pKSkKCQkJCXJldHVybiAtRUZBVUxUOwoJCQlyZXR1cm4gMDsKCQl9CgkJZGVmYXVsdDoKCQkJZXJyb3IgPSAtRUlOVkFMOwoJCQlicmVhazsKCX0KCXJldHVybiBlcnJvcjsKfQo=