Ci8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogIFxmaWxlCiAqICAgICAgbWJ1ZmZlci5jCiAqCiAqICBcYnJpZWYKICogICAgICBGcmFtZSBidWZmZXIgZnVuY3Rpb25zCiAqCiAqICBcYXV0aG9yCiAqICAgICAgTWFpbiBjb250cmlidXRvcnMgKHNlZSBjb250cmlidXRvcnMuaCBmb3IgY29weXJpZ2h0LCBhZGRyZXNzIGFuZCBhZmZpbGlhdGlvbiBkZXRhaWxzKQogKiAgICAgIC0gS2Fyc3RlbiBT/GhyaW5nICAgICAgICAgICAgICAgICA8c3VlaHJpbmdAaGhpLmRlPgogKiAgICAgIC0gQWxleGlzIFRvdXJhcGlzICAgICAgICAgICAgICAgICA8YWxleGlzbXRAaWVlZS5vcmc+CiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KCiNpbmNsdWRlIDxzdGRsaWIuaD4KI2luY2x1ZGUgPGFzc2VydC5oPgojaW5jbHVkZSA8bGltaXRzLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4KCiNpbmNsdWRlICJnbG9iYWwuaCIKI2luY2x1ZGUgIm1idWZmZXIuaCIKI2luY2x1ZGUgIm1lbWFsbG9jLmgiCiNpbmNsdWRlICJvdXRwdXQuaCIKI2luY2x1ZGUgImltYWdlLmgiCgpzdGF0aWMgdm9pZCBpbnNlcnRfcGljdHVyZV9pbl9kcGIoRnJhbWVTdG9yZSogZnMsIFN0b3JhYmxlUGljdHVyZSogcCk7CnN0YXRpYyB2b2lkIG91dHB1dF9vbmVfZnJhbWVfZnJvbV9kcGIodm9pZCk7CnN0YXRpYyBpbnQgIGlzX3VzZWRfZm9yX3JlZmVyZW5jZShGcmFtZVN0b3JlKiBmcyk7CnN0YXRpYyB2b2lkIGdldF9zbWFsbGVzdF9wb2MoaW50ICpwb2MsaW50ICogcG9zKTsKc3RhdGljIGludCAgcmVtb3ZlX3VudXNlZF9mcmFtZV9mcm9tX2RwYih2b2lkKTsKc3RhdGljIGludCAgaXNfc2hvcnRfdGVybV9yZWZlcmVuY2UoRnJhbWVTdG9yZSogZnMpOwpzdGF0aWMgaW50ICBpc19sb25nX3Rlcm1fcmVmZXJlbmNlKEZyYW1lU3RvcmUqIGZzKTsKdm9pZCBnZW5fZmllbGRfcmVmX2lkcyhTdG9yYWJsZVBpY3R1cmUgKnApOwoKRGVjb2RlZFBpY3R1cmVCdWZmZXIgZHBiOwoKU3RvcmFibGVQaWN0dXJlICoqbGlzdFhbNl07CgpDb2xvY2F0ZWRQYXJhbXMgKkNvX2xvY2F0ZWQgPSBOVUxMOwoKCmludCBsaXN0WHNpemVbNl07CgojZGVmaW5lIE1BWF9MSVNUX1NJWkUgMzMKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBQcmludCBvdXQgbGlzdCBvZiBwaWN0dXJlcyBpbiBEUEIuIFVzZWQgZm9yIGRlYnVnIHB1cnBvc2VzLgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIGR1bXBfZHBiKHZvaWQpCnsKI2lmIERVTVBfRFBCCiAgdW5zaWduZWQgaTsKCiAgZm9yIChpPTA7IGk8ZHBiLnVzZWRfc2l6ZTtpKyspCiAgewogICAgcHJpbnRmKCIoIik7CiAgICBwcmludGYoImZuPSVkICAiLCBkcGIuZnNbaV0tPmZyYW1lX251bSk7CiAgICBpZiAoZHBiLmZzW2ldLT5pc191c2VkICYgMSkKICAgIHsKICAgICAgaWYgKGRwYi5mc1tpXS0+dG9wX2ZpZWxkKQogICAgICAgIHByaW50ZigiVDogcG9jPSVkICAiLCBkcGIuZnNbaV0tPnRvcF9maWVsZC0+cG9jKTsKICAgICAgZWxzZQogICAgICAgIHByaW50ZigiVDogcG9jPSVkICAiLCBkcGIuZnNbaV0tPmZyYW1lLT50b3BfcG9jKTsKICAgIH0KICAgIGlmIChkcGIuZnNbaV0tPmlzX3VzZWQgJiAyKQogICAgewogICAgICBpZiAoZHBiLmZzW2ldLT5ib3R0b21fZmllbGQpCiAgICAgICAgcHJpbnRmKCJCOiBwb2M9JWQgICIsIGRwYi5mc1tpXS0+Ym90dG9tX2ZpZWxkLT5wb2MpOwogICAgICBlbHNlCiAgICAgICAgcHJpbnRmKCJCOiBwb2M9JWQgICIsIGRwYi5mc1tpXS0+ZnJhbWUtPmJvdHRvbV9wb2MpOwogICAgfQogICAgaWYgKGRwYi5mc1tpXS0+aXNfdXNlZCA9PSAzKQogICAgICBwcmludGYoIkY6IHBvYz0lZCAgIiwgZHBiLmZzW2ldLT5mcmFtZS0+cG9jKTsKICAgIHByaW50ZigiRzogcG9jPSVkKSAgIiwgZHBiLmZzW2ldLT5wb2MpOwogICAgaWYgKGRwYi5mc1tpXS0+aXNfcmVmZXJlbmNlKSBwcmludGYgKCJyZWYgKCVkKSAiLCBkcGIuZnNbaV0tPmlzX3JlZmVyZW5jZSk7CiAgICBpZiAoZHBiLmZzW2ldLT5pc19sb25nX3Rlcm0pIHByaW50ZiAoImx0X3JlZiAoJWQpICIsIGRwYi5mc1tpXS0+aXNfcmVmZXJlbmNlKTsKICAgIGlmIChkcGIuZnNbaV0tPmlzX291dHB1dCkgcHJpbnRmICgib3V0ICAiKTsKICAgIGlmIChkcGIuZnNbaV0tPmlzX3VzZWQgPT0gMykKICAgIHsKICAgICAgaWYgKGRwYi5mc1tpXS0+ZnJhbWUtPm5vbl9leGlzdGluZykgcHJpbnRmICgibmUgICIpOwogICAgfQogICAgcHJpbnRmICgiXG4iKTsKICB9CiNlbmRpZgp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgUmV0dXJucyB0aGUgc2l6ZSBvZiB0aGUgZHBiIGRlcGVuZGluZyBvbiBsZXZlbCBhbmQgcGljdHVyZSBzaXplCiAqCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCmludCBnZXREcGJTaXplKHZvaWQpCnsKICBpbnQgcGljX3NpemUgPSAoYWN0aXZlX3Nwcy0+cGljX3dpZHRoX2luX21ic19taW51czEgKyAxKSAqIChhY3RpdmVfc3BzLT5waWNfaGVpZ2h0X2luX21hcF91bml0c19taW51czEgKyAxKSAqIChhY3RpdmVfc3BzLT5mcmFtZV9tYnNfb25seV9mbGFnPzE6MikgKiAzODQ7CgogIGludCBzaXplID0gMDsKCiAgc3dpdGNoIChhY3RpdmVfc3BzLT5sZXZlbF9pZGMpCiAgewogIGNhc2UgOToKICAgIHNpemUgPSAxNTIwNjQ7CiAgICBicmVhazsKICBjYXNlIDEwOgogICAgc2l6ZSA9IDE1MjA2NDsKICAgIGJyZWFrOwogIGNhc2UgMTE6CiAgICBpZiAoKGFjdGl2ZV9zcHMtPnByb2ZpbGVfaWRjIDwgRlJFWFRfSFApJiYoYWN0aXZlX3Nwcy0+Y29uc3RyYWluZWRfc2V0M19mbGFnID09IDApKQogICAgICBzaXplID0gMzQ1NjAwOwogICAgZWxzZQogICAgICBzaXplID0gMTUyMDY0OwogICAgYnJlYWs7CiAgY2FzZSAxMjoKICAgIHNpemUgPSA5MTIzODQ7CiAgICBicmVhazsKICBjYXNlIDEzOgogICAgc2l6ZSA9IDkxMjM4NDsKICAgIGJyZWFrOwogIGNhc2UgMjA6CiAgICBzaXplID0gOTEyMzg0OwogICAgYnJlYWs7CiAgY2FzZSAyMToKICAgIHNpemUgPSAxODI0NzY4OwogICAgYnJlYWs7CiAgY2FzZSAyMjoKICAgIHNpemUgPSAzMTEwNDAwOwogICAgYnJlYWs7CiAgY2FzZSAzMDoKICAgIHNpemUgPSAzMTEwNDAwOwogICAgYnJlYWs7CiAgY2FzZSAzMToKICAgIHNpemUgPSA2OTEyMDAwOwogICAgYnJlYWs7CiAgY2FzZSAzMjoKICAgIHNpemUgPSA3ODY0MzIwOwogICAgYnJlYWs7CiAgY2FzZSA0MDoKICAgIHNpemUgPSAxMjU4MjkxMjsKICAgIGJyZWFrOwogIGNhc2UgNDE6CiAgICBzaXplID0gMTI1ODI5MTI7CiAgICBicmVhazsKIGNhc2UgNDI6CiAgIGlmKCAgKGFjdGl2ZV9zcHMtPnByb2ZpbGVfaWRjPT1GUkVYVF9IUCAgICkgfHwgKGFjdGl2ZV9zcHMtPnByb2ZpbGVfaWRjPT1GUkVYVF9IaTEwUCkKICAgICB8fCAoYWN0aXZlX3Nwcy0+cHJvZmlsZV9pZGM9PUZSRVhUX0hpNDIyKSB8fCAoYWN0aXZlX3Nwcy0+cHJvZmlsZV9pZGM9PUZSRVhUX0hpNDQ0KSkKICAgICBzaXplID0gMTMzNjkzNDQ7CiAgIGVsc2UKICAgICBzaXplID0gMTI1ODI5MTI7CiAgIGJyZWFrOwogIGNhc2UgNTA6CiAgICBzaXplID0gNDIzOTM2MDA7CiAgICBicmVhazsKICBjYXNlIDUxOgogICAgc2l6ZSA9IDcwNzc4ODgwOwogICAgYnJlYWs7CiAgZGVmYXVsdDoKICAgIGVycm9yICgidW5kZWZpbmVkIGxldmVsIiwgNTAwKTsKICAgIGJyZWFrOwogIH0KCiAgc2l6ZSAvPSBwaWNfc2l6ZTsKICByZXR1cm4gaW1pbiggc2l6ZSwgMTYpOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQ2hlY2sgdGhlbiBudW1iZXIgb2YgZnJhbWVzIG1hcmtlZCAidXNlZCBmb3IgcmVmZXJlbmNlIiBhbmQgYnJlYWsKICogICAgaWYgbWF4aW11bSBpcyBleGNlZWRlZAogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIGNoZWNrX251bV9yZWYodm9pZCkKewogIGlmICgoaW50KShkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlciArICBkcGIucmVmX2ZyYW1lc19pbl9idWZmZXIgKSA+IChpbWF4KDEsaW1nLT5udW1fcmVmX2ZyYW1lcykpKQogIHsKICAgIGVycm9yICgiTWF4LiBudW1iZXIgb2YgcmVmZXJlbmNlIGZyYW1lcyBleGNlZWRlZC4gSW52YWxpZCBzdHJlYW0uIiwgNTAwKTsKICB9Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQWxsb2NhdGUgbWVtb3J5IGZvciBkZWNvZGVkIHBpY3R1cmUgYnVmZmVyIGFuZCBpbml0aWFsaXplIHdpdGggc2FuZSB2YWx1ZXMuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnZvaWQgaW5pdF9kcGIodm9pZCkKewogIHVuc2lnbmVkIGksajsKCiAgaWYgKGRwYi5pbml0X2RvbmUpCiAgewogICAgZnJlZV9kcGIoKTsKICB9CgogIGRwYi5zaXplICAgICAgPSBnZXREcGJTaXplKCk7CgogIGlmIChkcGIuc2l6ZSA8ICh1bnNpZ25lZCBpbnQpaW5wdXQtPm51bV9yZWZfZnJhbWVzKQogIHsKICAgIGVycm9yICgiRFBCIHNpemUgYXQgc3BlY2lmaWVkIGxldmVsIGlzIHNtYWxsZXIgdGhhbiB0aGUgc3BlY2lmaWVkIG51bWJlciBvZiByZWZlcmVuY2UgZnJhbWVzLiBUaGlzIGlzIG5vdCBhbGxvd2VkLlxuIiwgMTAwMCk7CiAgfQoKICBkcGIudXNlZF9zaXplID0gMDsKICBkcGIubGFzdF9waWN0dXJlID0gTlVMTDsKCiAgZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyID0gMDsKICBkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlciA9IDA7CgogIGRwYi5mcyA9IGNhbGxvYyhkcGIuc2l6ZSwgc2l6ZW9mIChGcmFtZVN0b3JlKikpOwogIGlmIChOVUxMPT1kcGIuZnMpCiAgICBub19tZW1fZXhpdCgiaW5pdF9kcGI6IGRwYi0+ZnMiKTsKCiAgZHBiLmZzX3JlZiA9IGNhbGxvYyhkcGIuc2l6ZSwgc2l6ZW9mIChGcmFtZVN0b3JlKikpOwogIGlmIChOVUxMPT1kcGIuZnNfcmVmKQogICAgbm9fbWVtX2V4aXQoImluaXRfZHBiOiBkcGItPmZzX3JlZiIpOwoKICBkcGIuZnNfbHRyZWYgPSBjYWxsb2MoZHBiLnNpemUsIHNpemVvZiAoRnJhbWVTdG9yZSopKTsKICBpZiAoTlVMTD09ZHBiLmZzX2x0cmVmKQogICAgbm9fbWVtX2V4aXQoImluaXRfZHBiOiBkcGItPmZzX2x0cmVmIik7CgogIGZvciAoaT0wOyBpPGRwYi5zaXplOyBpKyspCiAgewogICAgZHBiLmZzW2ldICAgICAgID0gYWxsb2NfZnJhbWVfc3RvcmUoKTsKICAgIGRwYi5mc19yZWZbaV0gICA9IE5VTEw7CiAgICBkcGIuZnNfbHRyZWZbaV0gPSBOVUxMOwogIH0KCiAgZm9yIChpPTA7IGk8NjsgaSsrKQogIHsKICAgIGxpc3RYW2ldID0gY2FsbG9jKE1BWF9MSVNUX1NJWkUsIHNpemVvZiAoU3RvcmFibGVQaWN0dXJlKikpOyAvLyArMSBmb3IgcmVvcmRlcmluZwogICAgaWYgKE5VTEw9PWxpc3RYW2ldKQogICAgICBub19tZW1fZXhpdCgiaW5pdF9kcGI6IGxpc3RYW2ldIik7CiAgfQoKICBmb3IgKGo9MDtqPDY7aisrKQogIHsKICAgIGZvciAoaT0wOyBpPE1BWF9MSVNUX1NJWkU7IGkrKykKICAgIHsKICAgICAgbGlzdFhbal1baV0gPSBOVUxMOwogICAgfQogICAgbGlzdFhzaXplW2pdPTA7CiAgfQoKICBkcGIubGFzdF9vdXRwdXRfcG9jID0gSU5UX01JTjsKCiAgaW1nLT5sYXN0X2hhc19tbWNvXzUgPSAwOwoKICBkcGIuaW5pdF9kb25lID0gMTsKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBGcmVlIG1lbW9yeSBmb3IgZGVjb2RlZCBwaWN0dXJlIGJ1ZmZlci4KICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBmcmVlX2RwYih2b2lkKQp7CiAgdW5zaWduZWQgaTsKICBpZiAoZHBiLmZzKQogIHsKICAgIGZvciAoaT0wOyBpPGRwYi5zaXplOyBpKyspCiAgICB7CiAgICAgIGZyZWVfZnJhbWVfc3RvcmUoZHBiLmZzW2ldKTsKICAgIH0KICAgIGZyZWUgKGRwYi5mcyk7CiAgICBkcGIuZnM9TlVMTDsKICB9CiAgaWYgKGRwYi5mc19yZWYpCiAgewogICAgZnJlZSAoZHBiLmZzX3JlZik7CiAgfQogIGlmIChkcGIuZnNfbHRyZWYpCiAgewogICAgZnJlZSAoZHBiLmZzX2x0cmVmKTsKICB9CiAgZHBiLmxhc3Rfb3V0cHV0X3BvYyA9IElOVF9NSU47CgogIGZvciAoaT0wOyBpPDY7IGkrKykKICAgIGlmIChsaXN0WFtpXSkKICAgIHsKICAgICAgZnJlZSAobGlzdFhbaV0pOwogICAgICBsaXN0WFtpXSA9IE5VTEw7CiAgICB9CgogIGRwYi5pbml0X2RvbmUgPSAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEFsbG9jYXRlIG1lbW9yeSBmb3IgZGVjb2RlZCBwaWN0dXJlIGJ1ZmZlciBmcmFtZSBzdG9yZXMgYW4gaW5pdGlhbGl6ZSB3aXRoIHNhbmUgdmFsdWVzLgogKgogKiBccmV0dXJuCiAqICAgIHRoZSBhbGxvY2F0ZWQgRnJhbWVTdG9yZSBzdHJ1Y3R1cmUKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KRnJhbWVTdG9yZSogYWxsb2NfZnJhbWVfc3RvcmUodm9pZCkKewogIEZyYW1lU3RvcmUgKmY7CgogIGYgPSBjYWxsb2MgKDEsIHNpemVvZihGcmFtZVN0b3JlKSk7CiAgaWYgKE5VTEw9PWYpCiAgICBub19tZW1fZXhpdCgiYWxsb2NfZnJhbWVfc3RvcmU6IGYiKTsKCiAgZi0+aXNfdXNlZCAgICAgID0gMDsKICBmLT5pc19yZWZlcmVuY2UgPSAwOwogIGYtPmlzX2xvbmdfdGVybSA9IDA7CiAgZi0+aXNfb3JpZ19yZWZlcmVuY2UgPSAwOwoKICBmLT5pc19vdXRwdXQgPSAwOwoKICBmLT5mcmFtZSAgICAgICAgPSBOVUxMOzsKICBmLT50b3BfZmllbGQgICAgPSBOVUxMOwogIGYtPmJvdHRvbV9maWVsZCA9IE5VTEw7CgogIHJldHVybiBmOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQWxsb2NhdGUgbWVtb3J5IGZvciBhIHN0b3JlZCBwaWN0dXJlLgogKgogKiBccGFyYW0gc3RydWN0dXJlCiAqICAgIHBpY3R1cmUgc3RydWN0dXJlCiAqIFxwYXJhbSBzaXplX3gKICogICAgaG9yaXpvbnRhbCBsdW1hIHNpemUKICogXHBhcmFtIHNpemVfeQogKiAgICB2ZXJ0aWNhbCBsdW1hIHNpemUKICogXHBhcmFtIHNpemVfeF9jcgogKiAgICBob3Jpem9udGFsIGNocm9tYSBzaXplCiAqIFxwYXJhbSBzaXplX3lfY3IKICogICAgdmVydGljYWwgY2hyb21hIHNpemUKICoKICogXHJldHVybgogKiAgICB0aGUgYWxsb2NhdGVkIFN0b3JhYmxlUGljdHVyZSBzdHJ1Y3R1cmUKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KU3RvcmFibGVQaWN0dXJlKiBhbGxvY19zdG9yYWJsZV9waWN0dXJlKFBpY3R1cmVTdHJ1Y3R1cmUgc3RydWN0dXJlLCBpbnQgc2l6ZV94LCBpbnQgc2l6ZV95LCBpbnQgc2l6ZV94X2NyLCBpbnQgc2l6ZV95X2NyKQp7CiAgU3RvcmFibGVQaWN0dXJlICpzOwoKICAvL3ByaW50ZiAoIkFsbG9jYXRpbmcgKCVzKSBwaWN0dXJlICh4PSVkLCB5PSVkLCB4X2NyPSVkLCB5X2NyPSVkKVxuIiwgKHR5cGUgPT0gRlJBTUUpPyJGUkFNRSI6KHR5cGUgPT0gVE9QX0ZJRUxEKT8iVE9QX0ZJRUxEIjoiQk9UVE9NX0ZJRUxEIiwgc2l6ZV94LCBzaXplX3ksIHNpemVfeF9jciwgc2l6ZV95X2NyKTsKCiAgcyA9IGNhbGxvYyAoMSwgc2l6ZW9mKFN0b3JhYmxlUGljdHVyZSkpOwogIGlmIChOVUxMPT1zKQogICAgbm9fbWVtX2V4aXQoImFsbG9jX3N0b3JhYmxlX3BpY3R1cmU6IHMiKTsKCiAgcy0+aW1nVVYgICAgICA9IE5VTEw7CiAgcy0+aW1nWV9zdWIgICA9IE5VTEw7CiAgcy0+aW1nVVZfc3ViICA9IE5VTEw7CgogIGdldF9tZW0yRHBlbCAoJihzLT5pbWdZKSwgc2l6ZV95LCBzaXplX3gpOwogIGlmIChpbWctPnl1dl9mb3JtYXQgIT0gWVVWNDAwKQogICAgZ2V0X21lbTNEcGVsICgmKHMtPmltZ1VWKSwgMiwgc2l6ZV95X2NyLCBzaXplX3hfY3IpOwoKICBzLT5tYl9maWVsZCA9IGNhbGxvYyAoaW1nLT5QaWNTaXplSW5NYnMsIHNpemVvZihpbnQpKTsKICBpZiAoTlVMTD09cy0+bWJfZmllbGQpCiAgICBub19tZW1fZXhpdCgiYWxsb2Nfc3RvcmFibGVfcGljdHVyZTogcy0+bWJfZmllbGQiKTsKCiAgZ2V0X21lbTNEICAgICAgKChieXRlKioqKikoJihzLT5yZWZfaWR4KSksICAgIDIsIHNpemVfeSAvIEJMT0NLX1NJWkUsIHNpemVfeCAvIEJMT0NLX1NJWkUpOwogIGdldF9tZW0zRGludDY0ICgmKHMtPnJlZl9waWNfaWQpLCA2LCBzaXplX3kgLyBCTE9DS19TSVpFLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKICBnZXRfbWVtM0RpbnQ2NCAoJihzLT5yZWZfaWQpLCAgICAgNiwgc2l6ZV95IC8gQkxPQ0tfU0laRSwgc2l6ZV94IC8gQkxPQ0tfU0laRSk7CiAgZ2V0X21lbTREc2hvcnQgKCYocy0+bXYpLCAgICAgICAgIDIsIHNpemVfeSAvIEJMT0NLX1NJWkUsIHNpemVfeCAvIEJMT0NLX1NJWkUsIDIpOwoKICBnZXRfbWVtMkQgKCYocy0+bW92aW5nX2Jsb2NrKSwgICAgICAgc2l6ZV95IC8gQkxPQ0tfU0laRSwgc2l6ZV94IC8gQkxPQ0tfU0laRSk7CiAgZ2V0X21lbTJEICgmKHMtPmZpZWxkX2ZyYW1lKSwgICAgICAgIHNpemVfeSAvIEJMT0NLX1NJWkUsIHNpemVfeCAvIEJMT0NLX1NJWkUpOwoKICBzLT5waWNfbnVtPTA7CiAgcy0+ZnJhbWVfbnVtPTA7CiAgcy0+bG9uZ190ZXJtX2ZyYW1lX2lkeD0wOwogIHMtPmxvbmdfdGVybV9waWNfbnVtPTA7CiAgcy0+dXNlZF9mb3JfcmVmZXJlbmNlPTA7CiAgcy0+aXNfbG9uZ190ZXJtPTA7CiAgcy0+bm9uX2V4aXN0aW5nPTA7CiAgcy0+aXNfb3V0cHV0ID0gMDsKCiAgcy0+c3RydWN0dXJlPXN0cnVjdHVyZTsKCiAgcy0+c2l6ZV94ID0gc2l6ZV94OwogIHMtPnNpemVfeSA9IHNpemVfeTsKICBzLT5zaXplX3hfcGFkID0gc2l6ZV94ICsgMiAqIElNR19QQURfU0laRSAtIDEgLSBNQl9CTE9DS19TSVpFOwogIHMtPnNpemVfeV9wYWQgPSBzaXplX3kgKyAyICogSU1HX1BBRF9TSVpFIC0gMSAtIE1CX0JMT0NLX1NJWkU7CiAgcy0+c2l6ZV94X2NyID0gc2l6ZV94X2NyOwogIHMtPnNpemVfeV9jciA9IHNpemVfeV9jcjsKICBzLT5zaXplX3hfY3JfcGFkID0gKGludCkgKHNpemVfeF9jciAtIDEpICsgKGltZ19wYWRfc2l6ZV91dl94IDw8IDEpIC0gKGltZy0+bWJfY3Jfc2l6ZV94KTsKICBzLT5zaXplX3lfY3JfcGFkID0gKGludCkgKHNpemVfeV9jciAtIDEpICsgKGltZ19wYWRfc2l6ZV91dl95IDw8IDEpIC0gKGltZy0+bWJfY3Jfc2l6ZV95KTsKCiAgcy0+dG9wX2ZpZWxkICAgID0gTlVMTDsKICBzLT5ib3R0b21fZmllbGQgPSBOVUxMOwogIHMtPmZyYW1lICAgICAgICA9IE5VTEw7CgogIHMtPmNvZGVkX2ZyYW1lICAgID0gMDsKICBzLT5NYmFmZkZyYW1lRmxhZyA9IDA7CgogIHJldHVybiBzOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgRnJlZSBmcmFtZSBzdG9yZSBtZW1vcnkuCiAqCiAqIFxwYXJhbSBmCiAqICAgIEZyYW1lU3RvcmUgdG8gYmUgZnJlZWQKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBmcmVlX2ZyYW1lX3N0b3JlKEZyYW1lU3RvcmUqIGYpCnsKICBpZiAoZikKICB7CiAgICBpZiAoZi0+ZnJhbWUpCiAgICB7CiAgICAgIGZyZWVfc3RvcmFibGVfcGljdHVyZShmLT5mcmFtZSk7CiAgICAgIGYtPmZyYW1lPU5VTEw7CiAgICB9CiAgICBpZiAoZi0+dG9wX2ZpZWxkKQogICAgewogICAgICBmcmVlX3N0b3JhYmxlX3BpY3R1cmUoZi0+dG9wX2ZpZWxkKTsKICAgICAgZi0+dG9wX2ZpZWxkPU5VTEw7CiAgICB9CiAgICBpZiAoZi0+Ym90dG9tX2ZpZWxkKQogICAgewogICAgICBmcmVlX3N0b3JhYmxlX3BpY3R1cmUoZi0+Ym90dG9tX2ZpZWxkKTsKICAgICAgZi0+Ym90dG9tX2ZpZWxkPU5VTEw7CiAgICB9CiAgICBmcmVlKGYpOwogIH0KfQoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEZyZWUgcGljdHVyZSBtZW1vcnkuCiAqCiAqIFxwYXJhbSBwCiAqICAgIFBpY3R1cmUgdG8gYmUgZnJlZWQKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBmcmVlX3N0b3JhYmxlX3BpY3R1cmUoU3RvcmFibGVQaWN0dXJlKiBwKQp7CiAgaWYgKHApCiAgewogICAgaWYgKHAtPnJlZl9pZHgpCiAgICB7CiAgICAgIGZyZWVfbWVtM0QgKChieXRlKioqKXAtPnJlZl9pZHgsIDIpOwogICAgICBwLT5yZWZfaWR4ID0gTlVMTDsKICAgIH0KCiAgICBpZiAocC0+cmVmX3BpY19pZCkKICAgIHsKICAgICAgZnJlZV9tZW0zRGludDY0IChwLT5yZWZfcGljX2lkLCA2KTsKICAgICAgcC0+cmVmX3BpY19pZCA9IE5VTEw7CiAgICB9CiAgICBpZiAocC0+cmVmX2lkKQogICAgewogICAgICBmcmVlX21lbTNEaW50NjQgKHAtPnJlZl9pZCwgNik7CiAgICAgIHAtPnJlZl9pZCA9IE5VTEw7CiAgICB9CiAgICBpZiAocC0+bXYpCiAgICB7CiAgICAgIGZyZWVfbWVtNERzaG9ydCAocC0+bXYsIDIsIHAtPnNpemVfeSAvIEJMT0NLX1NJWkUpOwogICAgICBwLT5tdiA9IE5VTEw7CiAgICB9CgogICAgaWYgKHAtPm1vdmluZ19ibG9jaykKICAgIHsKICAgICAgZnJlZV9tZW0yRCAocC0+bW92aW5nX2Jsb2NrKTsKICAgICAgcC0+bW92aW5nX2Jsb2NrPU5VTEw7CiAgICB9CgogICAgaWYgKHAtPmZpZWxkX2ZyYW1lKQogICAgewogICAgICBmcmVlX21lbTJEIChwLT5maWVsZF9mcmFtZSk7CiAgICAgIHAtPmZpZWxkX2ZyYW1lPU5VTEw7CiAgICB9CgogICAgaWYgKHAtPmltZ1kpCiAgICB7CiAgICAgIGZyZWVfbWVtMkRwZWwgKHAtPmltZ1kpOwogICAgICBwLT5pbWdZPU5VTEw7CiAgICB9CiAgICBpZiAocC0+aW1nWV9zdWIpCiAgICB7CiAgICAgIGZyZWVfbWVtNERwZWwgKHAtPmltZ1lfc3ViLDQsNCk7CiAgICAgIHAtPmltZ1lfc3ViPU5VTEw7CiAgICB9CiAgICBpZiAoIHAtPmltZ1VWX3N1YiAmJiBpbWctPnl1dl9mb3JtYXQgIT0gWVVWNDAwICYmIGlucHV0LT5DaHJvbWFNQ0J1ZmZlciApCiAgICB7CiAgICAgIGlmICggaW1nLT55dXZfZm9ybWF0ID09IFlVVjQyMCApCiAgICAgIHsKICAgICAgICBmcmVlX21lbTVEcGVsIChwLT5pbWdVVl9zdWIsIDIsIDgsIDggKTsKICAgICAgICBwLT5pbWdVVl9zdWIgPSBOVUxMOwogICAgICB9CiAgICAgIGVsc2UgaWYgKCBpbWctPnl1dl9mb3JtYXQgPT0gWVVWNDIyICkKICAgICAgewogICAgICAgIGZyZWVfbWVtNURwZWwgKHAtPmltZ1VWX3N1YiwgMiwgNCwgOCApOwogICAgICAgIHAtPmltZ1VWX3N1YiA9IE5VTEw7CiAgICAgIH0KICAgICAgZWxzZQogICAgICB7IC8vIFlVVjQ0NAogICAgICAgIGZyZWVfbWVtNURwZWwgKHAtPmltZ1VWX3N1YiwgMiwgNCwgNCApOwogICAgICAgIHAtPmltZ1VWX3N1YiA9IE5VTEw7CiAgICAgIH0KICAgIH0KCiAgICBpZiAocC0+aW1nVVYpCiAgICB7CiAgICAgIGZyZWVfbWVtM0RwZWwgKHAtPmltZ1VWLCAyKTsKICAgICAgcC0+aW1nVVY9TlVMTDsKICAgIH0KCiAgICBpZiAocC0+bWJfZmllbGQpCiAgICB7CiAgICAgIGZyZWUocC0+bWJfZmllbGQpOwogICAgICBwLT5tYl9maWVsZD1OVUxMOwogICAgfQoKICAgIGZyZWUocCk7CiAgICBwID0gTlVMTDsKICB9Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBtYXJrIEZyYW1lU3RvcmUgdW51c2VkIGZvciByZWZlcmVuY2UKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgdW5tYXJrX2Zvcl9yZWZlcmVuY2UoRnJhbWVTdG9yZSogZnMpCnsKCiAgaWYgKGZzLT5pc191c2VkICYgMSkKICB7CiAgICBpZiAoZnMtPnRvcF9maWVsZCkKICAgIHsKICAgICAgZnMtPnRvcF9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgIH0KICB9CiAgaWYgKGZzLT5pc191c2VkICYgMikKICB7CiAgICBpZiAoZnMtPmJvdHRvbV9maWVsZCkKICAgIHsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgIH0KICB9CiAgaWYgKGZzLT5pc191c2VkID09IDMpCiAgewogICAgaWYgKGZzLT50b3BfZmllbGQgJiYgZnMtPmJvdHRvbV9maWVsZCkKICAgIHsKICAgICAgZnMtPnRvcF9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgIH0KICAgIGZzLT5mcmFtZS0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICB9CgogIGZzLT5pc19yZWZlcmVuY2UgPSAwOwoKICBpZihmcy0+ZnJhbWUpCiAgewogICAgaWYgKGZzLT5mcmFtZS0+aW1nWV9zdWIpCiAgICB7CiAgICAgIGZyZWVfbWVtNERwZWwgKGZzLT5mcmFtZS0+aW1nWV9zdWIsIDQsIDQpOwogICAgICBmcy0+ZnJhbWUtPmltZ1lfc3ViPU5VTEw7CiAgICB9CgogICAgaWYgKGZzLT5mcmFtZS0+cmVmX3BpY19pZCkKICAgIHsKICAgICAgZnJlZV9tZW0zRGludDY0IChmcy0+ZnJhbWUtPnJlZl9waWNfaWQsIDYpOwogICAgICBmcy0+ZnJhbWUtPnJlZl9waWNfaWQgPSBOVUxMOwogICAgfQogICAgaWYgKGZzLT5mcmFtZS0+cmVmX2lkKQogICAgewogICAgICBmcmVlX21lbTNEaW50NjQgKGZzLT5mcmFtZS0+cmVmX2lkLCA2KTsKICAgICAgZnMtPmZyYW1lLT5yZWZfaWQgPSBOVUxMOwogICAgfQogIH0KCiAgaWYgKGZzLT50b3BfZmllbGQpCiAgewogICAgaWYgKGZzLT50b3BfZmllbGQtPmltZ1lfc3ViKQogICAgewogICAgICBmcmVlX21lbTREcGVsIChmcy0+dG9wX2ZpZWxkLT5pbWdZX3N1YiwgNCwgNCk7CiAgICAgIGZzLT50b3BfZmllbGQtPmltZ1lfc3ViPU5VTEw7CiAgICB9CgogICAgaWYgKGZzLT50b3BfZmllbGQtPnJlZl9waWNfaWQpCiAgICB7CiAgICAgIGZyZWVfbWVtM0RpbnQ2NCAoZnMtPnRvcF9maWVsZC0+cmVmX3BpY19pZCwgNik7CiAgICAgIGZzLT50b3BfZmllbGQtPnJlZl9waWNfaWQgPSBOVUxMOwogICAgfQogICAgaWYgKGZzLT50b3BfZmllbGQtPnJlZl9pZCkKICAgIHsKICAgICAgZnJlZV9tZW0zRGludDY0IChmcy0+dG9wX2ZpZWxkLT5yZWZfaWQsIDYpOwogICAgICBmcy0+dG9wX2ZpZWxkLT5yZWZfaWQgPSBOVUxMOwogICAgfQoKICB9CiAgaWYgKGZzLT5ib3R0b21fZmllbGQpCiAgewogICAgaWYgKGZzLT5ib3R0b21fZmllbGQtPmltZ1lfc3ViKQogICAgewogICAgICBmcmVlX21lbTREcGVsIChmcy0+Ym90dG9tX2ZpZWxkLT5pbWdZX3N1YiwgNCwgNCk7CiAgICAgIGZzLT5ib3R0b21fZmllbGQtPmltZ1lfc3ViPU5VTEw7CiAgICB9CiAgICBpZiAoZnMtPmJvdHRvbV9maWVsZC0+cmVmX3BpY19pZCkKICAgIHsKICAgICAgZnJlZV9tZW0zRGludDY0IChmcy0+Ym90dG9tX2ZpZWxkLT5yZWZfcGljX2lkLCA2KTsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+cmVmX3BpY19pZCA9IE5VTEw7CiAgICB9CiAgICBpZiAoZnMtPmJvdHRvbV9maWVsZC0+cmVmX2lkKQogICAgewogICAgICBmcmVlX21lbTNEaW50NjQgKGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZCwgNik7CiAgICAgIGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZCA9IE5VTEw7CiAgICB9CiAgfQoKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBtYXJrIEZyYW1lU3RvcmUgdW51c2VkIGZvciByZWZlcmVuY2UgYW5kIHJlc2V0IGxvbmcgdGVybSBmbGFncwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCB1bm1hcmtfZm9yX2xvbmdfdGVybV9yZWZlcmVuY2UoRnJhbWVTdG9yZSogZnMpCnsKCiAgaWYgKGZzLT5pc191c2VkICYgMSkKICB7CiAgICBpZiAoZnMtPnRvcF9maWVsZCkKICAgIHsKICAgICAgZnMtPnRvcF9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgZnMtPnRvcF9maWVsZC0+aXNfbG9uZ190ZXJtID0gMDsKICAgIH0KICB9CiAgaWYgKGZzLT5pc191c2VkICYgMikKICB7CiAgICBpZiAoZnMtPmJvdHRvbV9maWVsZCkKICAgIHsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+aXNfbG9uZ190ZXJtID0gMDsKICAgIH0KICB9CiAgaWYgKGZzLT5pc191c2VkID09IDMpCiAgewogICAgaWYgKGZzLT50b3BfZmllbGQgJiYgZnMtPmJvdHRvbV9maWVsZCkKICAgIHsKICAgICAgZnMtPnRvcF9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgZnMtPnRvcF9maWVsZC0+aXNfbG9uZ190ZXJtID0gMDsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+aXNfbG9uZ190ZXJtID0gMDsKICAgIH0KICAgIGZzLT5mcmFtZS0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgIGZzLT5mcmFtZS0+aXNfbG9uZ190ZXJtID0gMDsKICB9CgogIGZzLT5pc19yZWZlcmVuY2UgPSAwOwogIGZzLT5pc19sb25nX3Rlcm0gPSAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIGNvbXBhcmVzIHR3byBzdG9yZWQgcGljdHVyZXMgYnkgcGljdHVyZSBudW1iZXIgZm9yIHFzb3J0IGluIGRlc2NlbmRpbmcgb3JkZXIKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIGludCBjb21wYXJlX3BpY19ieV9waWNfbnVtX2Rlc2MoIGNvbnN0IHZvaWQgKmFyZzEsIGNvbnN0IHZvaWQgKmFyZzIgKQp7CiAgaWYgKCAoKihTdG9yYWJsZVBpY3R1cmUqKilhcmcxKS0+cGljX251bSA8ICgqKFN0b3JhYmxlUGljdHVyZSoqKWFyZzIpLT5waWNfbnVtKQogICAgcmV0dXJuIDE7CiAgaWYgKCAoKihTdG9yYWJsZVBpY3R1cmUqKilhcmcxKS0+cGljX251bSA+ICgqKFN0b3JhYmxlUGljdHVyZSoqKWFyZzIpLT5waWNfbnVtKQogICAgcmV0dXJuIC0xOwogIGVsc2UKICAgIHJldHVybiAwOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgY29tcGFyZXMgdHdvIHN0b3JlZCBwaWN0dXJlcyBieSBwaWN0dXJlIG51bWJlciBmb3IgcXNvcnQgaW4gZGVzY2VuZGluZyBvcmRlcgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgaW50IGNvbXBhcmVfcGljX2J5X2x0X3BpY19udW1fYXNjKCBjb25zdCB2b2lkICphcmcxLCBjb25zdCB2b2lkICphcmcyICkKewogIGlmICggKCooU3RvcmFibGVQaWN0dXJlKiopYXJnMSktPmxvbmdfdGVybV9waWNfbnVtIDwgKCooU3RvcmFibGVQaWN0dXJlKiopYXJnMiktPmxvbmdfdGVybV9waWNfbnVtKQogICAgcmV0dXJuIC0xOwogIGlmICggKCooU3RvcmFibGVQaWN0dXJlKiopYXJnMSktPmxvbmdfdGVybV9waWNfbnVtID4gKCooU3RvcmFibGVQaWN0dXJlKiopYXJnMiktPmxvbmdfdGVybV9waWNfbnVtKQogICAgcmV0dXJuIDE7CiAgZWxzZQogICAgcmV0dXJuIDA7Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBjb21wYXJlcyB0d28gZnJhbWUgc3RvcmVzIGJ5IHBpY19udW0gZm9yIHFzb3J0IGluIGRlc2NlbmRpbmcgb3JkZXIKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIGludCBjb21wYXJlX2ZzX2J5X2ZyYW1lX251bV9kZXNjKCBjb25zdCB2b2lkICphcmcxLCBjb25zdCB2b2lkICphcmcyICkKewogIGlmICggKCooRnJhbWVTdG9yZSoqKWFyZzEpLT5mcmFtZV9udW1fd3JhcCA8ICgqKEZyYW1lU3RvcmUqKilhcmcyKS0+ZnJhbWVfbnVtX3dyYXApCiAgICByZXR1cm4gMTsKICBpZiAoICgqKEZyYW1lU3RvcmUqKilhcmcxKS0+ZnJhbWVfbnVtX3dyYXAgPiAoKihGcmFtZVN0b3JlKiopYXJnMiktPmZyYW1lX251bV93cmFwKQogICAgcmV0dXJuIC0xOwogIGVsc2UKICAgIHJldHVybiAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIGNvbXBhcmVzIHR3byBmcmFtZSBzdG9yZXMgYnkgbHRfcGljX251bSBmb3IgcXNvcnQgaW4gZGVzY2VuZGluZyBvcmRlcgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgaW50IGNvbXBhcmVfZnNfYnlfbHRfcGljX2lkeF9hc2MoIGNvbnN0IHZvaWQgKmFyZzEsIGNvbnN0IHZvaWQgKmFyZzIgKQp7CiAgaWYgKCAoKihGcmFtZVN0b3JlKiopYXJnMSktPmxvbmdfdGVybV9mcmFtZV9pZHggPCAoKihGcmFtZVN0b3JlKiopYXJnMiktPmxvbmdfdGVybV9mcmFtZV9pZHgpCiAgICByZXR1cm4gLTE7CiAgaWYgKCAoKihGcmFtZVN0b3JlKiopYXJnMSktPmxvbmdfdGVybV9mcmFtZV9pZHggPiAoKihGcmFtZVN0b3JlKiopYXJnMiktPmxvbmdfdGVybV9mcmFtZV9pZHgpCiAgICByZXR1cm4gMTsKICBlbHNlCiAgICByZXR1cm4gMDsKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBjb21wYXJlcyB0d28gc3RvcmVkIHBpY3R1cmVzIGJ5IHBvYyBmb3IgcXNvcnQgaW4gYXNjZW5kaW5nIG9yZGVyCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyBpbnQgY29tcGFyZV9waWNfYnlfcG9jX2FzYyggY29uc3Qgdm9pZCAqYXJnMSwgY29uc3Qgdm9pZCAqYXJnMiApCnsKICBpZiAoICgqKFN0b3JhYmxlUGljdHVyZSoqKWFyZzEpLT5wb2MgPCAoKihTdG9yYWJsZVBpY3R1cmUqKilhcmcyKS0+cG9jKQogICAgcmV0dXJuIC0xOwogIGlmICggKCooU3RvcmFibGVQaWN0dXJlKiopYXJnMSktPnBvYyA+ICgqKFN0b3JhYmxlUGljdHVyZSoqKWFyZzIpLT5wb2MpCiAgICByZXR1cm4gMTsKICBlbHNlCiAgICByZXR1cm4gMDsKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBjb21wYXJlcyB0d28gc3RvcmVkIHBpY3R1cmVzIGJ5IHBvYyBmb3IgcXNvcnQgaW4gZGVzY2VuZGluZyBvcmRlcgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgaW50IGNvbXBhcmVfcGljX2J5X3BvY19kZXNjKCBjb25zdCB2b2lkICphcmcxLCBjb25zdCB2b2lkICphcmcyICkKewogIGlmICggKCooU3RvcmFibGVQaWN0dXJlKiopYXJnMSktPnBvYyA8ICgqKFN0b3JhYmxlUGljdHVyZSoqKWFyZzIpLT5wb2MpCiAgICByZXR1cm4gMTsKICBpZiAoICgqKFN0b3JhYmxlUGljdHVyZSoqKWFyZzEpLT5wb2MgPiAoKihTdG9yYWJsZVBpY3R1cmUqKilhcmcyKS0+cG9jKQogICAgcmV0dXJuIC0xOwogIGVsc2UKICAgIHJldHVybiAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIGNvbXBhcmVzIHR3byBmcmFtZSBzdG9yZXMgYnkgcG9jIGZvciBxc29ydCBpbiBhc2NlbmRpbmcgb3JkZXIKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIGludCBjb21wYXJlX2ZzX2J5X3BvY19hc2MoIGNvbnN0IHZvaWQgKmFyZzEsIGNvbnN0IHZvaWQgKmFyZzIgKQp7CiAgaWYgKCAoKihGcmFtZVN0b3JlKiopYXJnMSktPnBvYyA8ICgqKEZyYW1lU3RvcmUqKilhcmcyKS0+cG9jKQogICAgcmV0dXJuIC0xOwogIGlmICggKCooRnJhbWVTdG9yZSoqKWFyZzEpLT5wb2MgPiAoKihGcmFtZVN0b3JlKiopYXJnMiktPnBvYykKICAgIHJldHVybiAxOwogIGVsc2UKICAgIHJldHVybiAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIGNvbXBhcmVzIHR3byBmcmFtZSBzdG9yZXMgYnkgcG9jIGZvciBxc29ydCBpbiBkZXNjZW5kaW5nIG9yZGVyCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyBpbnQgY29tcGFyZV9mc19ieV9wb2NfZGVzYyggY29uc3Qgdm9pZCAqYXJnMSwgY29uc3Qgdm9pZCAqYXJnMiApCnsKICBpZiAoICgqKEZyYW1lU3RvcmUqKilhcmcxKS0+cG9jIDwgKCooRnJhbWVTdG9yZSoqKWFyZzIpLT5wb2MpCiAgICByZXR1cm4gMTsKICBpZiAoICgqKEZyYW1lU3RvcmUqKilhcmcxKS0+cG9jID4gKCooRnJhbWVTdG9yZSoqKWFyZzIpLT5wb2MpCiAgICByZXR1cm4gLTE7CiAgZWxzZQogICAgcmV0dXJuIDA7Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgcmV0dXJucyB0cnVlLCBpZiBwaWN0dXJlIGlzIHNob3J0IHRlcm0gcmVmZXJlbmNlIHBpY3R1cmUKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KaW50IGlzX3Nob3J0X3JlZihTdG9yYWJsZVBpY3R1cmUgKnMpCnsKICByZXR1cm4gKChzLT51c2VkX2Zvcl9yZWZlcmVuY2UpICYmICghKHMtPmlzX2xvbmdfdGVybSkpKTsKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICByZXR1cm5zIHRydWUsIGlmIHBpY3R1cmUgaXMgbG9uZyB0ZXJtIHJlZmVyZW5jZSBwaWN0dXJlCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCmludCBpc19sb25nX3JlZihTdG9yYWJsZVBpY3R1cmUgKnMpCnsKICByZXR1cm4gKChzLT51c2VkX2Zvcl9yZWZlcmVuY2UpICYmIChzLT5pc19sb25nX3Rlcm0pKTsKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBHZW5lcmF0ZXMgYSBhbHRlcm5hdGluZyBmaWVsZCBsaXN0IGZyb20gYSBnaXZlbiBGcmFtZVN0b3JlIGxpc3QKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgZ2VuX3BpY19saXN0X2Zyb21fZnJhbWVfbGlzdChQaWN0dXJlU3RydWN0dXJlIGN1cnJTdHJjdHVyZSwgRnJhbWVTdG9yZSAqKmZzX2xpc3QsIGludCBsaXN0X2lkeCwgU3RvcmFibGVQaWN0dXJlICoqbGlzdCwgaW50ICpsaXN0X3NpemUsIGludCBsb25nX3Rlcm0pCnsKICBpbnQgdG9wX2lkeCA9IDA7CiAgaW50IGJvdF9pZHggPSAwOwoKICBpbnQgKCppc19yZWYpKFN0b3JhYmxlUGljdHVyZSAqcyk7CgogIGlmIChsb25nX3Rlcm0pCiAgICBpc19yZWY9aXNfbG9uZ19yZWY7CiAgZWxzZQogICAgaXNfcmVmPWlzX3Nob3J0X3JlZjsKCiAgaWYgKGN1cnJTdHJjdHVyZSA9PSBUT1BfRklFTEQpCiAgewogICAgd2hpbGUgKCh0b3BfaWR4PGxpc3RfaWR4KXx8KGJvdF9pZHg8bGlzdF9pZHgpKQogICAgewogICAgICBmb3IgKCA7IHRvcF9pZHg8bGlzdF9pZHg7IHRvcF9pZHgrKykKICAgICAgewogICAgICAgIGlmKGZzX2xpc3RbdG9wX2lkeF0tPmlzX3VzZWQgJiAxKQogICAgICAgIHsKICAgICAgICAgIGlmKGlzX3JlZihmc19saXN0W3RvcF9pZHhdLT50b3BfZmllbGQpKQogICAgICAgICAgewogICAgICAgICAgICAvLyBzaG9ydCB0ZXJtIHJlZiBwaWMKICAgICAgICAgICAgbGlzdFsqbGlzdF9zaXplXSA9IGZzX2xpc3RbdG9wX2lkeF0tPnRvcF9maWVsZDsKICAgICAgICAgICAgKCpsaXN0X3NpemUpKys7CiAgICAgICAgICAgIHRvcF9pZHgrKzsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICAgIGZvciAoIDsgYm90X2lkeDxsaXN0X2lkeDsgYm90X2lkeCsrKQogICAgICB7CiAgICAgICAgaWYoZnNfbGlzdFtib3RfaWR4XS0+aXNfdXNlZCAmIDIpCiAgICAgICAgewogICAgICAgICAgaWYoaXNfcmVmKGZzX2xpc3RbYm90X2lkeF0tPmJvdHRvbV9maWVsZCkpCiAgICAgICAgICB7CiAgICAgICAgICAgIC8vIHNob3J0IHRlcm0gcmVmIHBpYwogICAgICAgICAgICBsaXN0WypsaXN0X3NpemVdID0gZnNfbGlzdFtib3RfaWR4XS0+Ym90dG9tX2ZpZWxkOwogICAgICAgICAgICAoKmxpc3Rfc2l6ZSkrKzsKICAgICAgICAgICAgYm90X2lkeCsrOwogICAgICAgICAgICBicmVhazsKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgIH0KICAgIH0KICB9CiAgaWYgKGN1cnJTdHJjdHVyZSA9PSBCT1RUT01fRklFTEQpCiAgewogICAgd2hpbGUgKCh0b3BfaWR4PGxpc3RfaWR4KXx8KGJvdF9pZHg8bGlzdF9pZHgpKQogICAgewogICAgICBmb3IgKCA7IGJvdF9pZHg8bGlzdF9pZHg7IGJvdF9pZHgrKykKICAgICAgewogICAgICAgIGlmKGZzX2xpc3RbYm90X2lkeF0tPmlzX3VzZWQgJiAyKQogICAgICAgIHsKICAgICAgICAgIGlmKGlzX3JlZihmc19saXN0W2JvdF9pZHhdLT5ib3R0b21fZmllbGQpKQogICAgICAgICAgewogICAgICAgICAgICAvLyBzaG9ydCB0ZXJtIHJlZiBwaWMKICAgICAgICAgICAgbGlzdFsqbGlzdF9zaXplXSA9IGZzX2xpc3RbYm90X2lkeF0tPmJvdHRvbV9maWVsZDsKICAgICAgICAgICAgKCpsaXN0X3NpemUpKys7CiAgICAgICAgICAgIGJvdF9pZHgrKzsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICAgIGZvciAoIDsgdG9wX2lkeDxsaXN0X2lkeDsgdG9wX2lkeCsrKQogICAgICB7CiAgICAgICAgaWYoZnNfbGlzdFt0b3BfaWR4XS0+aXNfdXNlZCAmIDEpCiAgICAgICAgewogICAgICAgICAgaWYoaXNfcmVmKGZzX2xpc3RbdG9wX2lkeF0tPnRvcF9maWVsZCkpCiAgICAgICAgICB7CiAgICAgICAgICAgIC8vIHNob3J0IHRlcm0gcmVmIHBpYwogICAgICAgICAgICBsaXN0WypsaXN0X3NpemVdID0gZnNfbGlzdFt0b3BfaWR4XS0+dG9wX2ZpZWxkOwogICAgICAgICAgICAoKmxpc3Rfc2l6ZSkrKzsKICAgICAgICAgICAgdG9wX2lkeCsrOwogICAgICAgICAgICBicmVhazsKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgIH0KICAgIH0KICB9Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgSW5pdGlhbGl6ZSBsaXN0WFswXSBhbmQgbGlzdCAxIGRlcGVuZGluZyBvbiBjdXJyZW50IHBpY3R1cmUgdHlwZQogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIGluaXRfbGlzdHMoaW50IGN1cnJTbGljZVR5cGUsIFBpY3R1cmVTdHJ1Y3R1cmUgY3VyclBpY1N0cnVjdHVyZSkKewogIGludCBhZGRfdG9wID0gMCwgYWRkX2JvdHRvbSA9IDA7CiAgdW5zaWduZWQgaTsKICBpbnQgajsKICBpbnQgTWF4RnJhbWVOdW0gPSAxIDw8IChsb2cyX21heF9mcmFtZV9udW1fbWludXM0ICsgNCk7CiAgaW50IGRpZmY7CgogIGludCBsaXN0MGlkeCA9IDA7CiAgaW50IGxpc3QwaWR4XzEgPSAwOwogIGludCBsaXN0bHRpZHggPSAwOwoKICBGcmFtZVN0b3JlICoqZnNfbGlzdDA7CiAgRnJhbWVTdG9yZSAqKmZzX2xpc3QxOwogIEZyYW1lU3RvcmUgKipmc19saXN0bHQ7CgogIFN0b3JhYmxlUGljdHVyZSAqdG1wX3M7CgogIGlmIChjdXJyUGljU3RydWN0dXJlID09IEZSQU1FKQogIHsKICAgIGZvciAoaT0wOyBpPGRwYi5yZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogICAgewogICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfdXNlZD09MykKICAgICAgewogICAgICAgIGlmICgoZHBiLmZzX3JlZltpXS0+ZnJhbWUtPnVzZWRfZm9yX3JlZmVyZW5jZSkmJighZHBiLmZzX3JlZltpXS0+ZnJhbWUtPmlzX2xvbmdfdGVybSkpCiAgICAgICAgewogICAgICAgICAgaWYoIGRwYi5mc19yZWZbaV0tPmZyYW1lX251bSA+IGltZy0+ZnJhbWVfbnVtICkKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWVfbnVtX3dyYXAgPSBkcGIuZnNfcmVmW2ldLT5mcmFtZV9udW0gLSBNYXhGcmFtZU51bTsKICAgICAgICAgIH0KICAgICAgICAgIGVsc2UKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWVfbnVtX3dyYXAgPSBkcGIuZnNfcmVmW2ldLT5mcmFtZV9udW07CiAgICAgICAgICB9CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5mcmFtZS0+cGljX251bSA9IGRwYi5mc19yZWZbaV0tPmZyYW1lX251bV93cmFwOwogICAgICAgIH0KICAgICAgfQogICAgfQogICAgLy8gdXBkYXRlIGxvbmdfdGVybV9waWNfbnVtCiAgICBmb3IgKGk9MDsgaTxkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogICAgewogICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5pc191c2VkPT0zKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19sdHJlZltpXS0+ZnJhbWUtPmlzX2xvbmdfdGVybSkKICAgICAgICB7CiAgICAgICAgICBkcGIuZnNfbHRyZWZbaV0tPmZyYW1lLT5sb25nX3Rlcm1fcGljX251bSA9IGRwYi5mc19sdHJlZltpXS0+ZnJhbWUtPmxvbmdfdGVybV9mcmFtZV9pZHg7CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQogIGVsc2UKICB7CiAgICBpZiAoY3VyclBpY1N0cnVjdHVyZSA9PSBUT1BfRklFTEQpCiAgICB7CiAgICAgIGFkZF90b3AgICAgPSAxOwogICAgICBhZGRfYm90dG9tID0gMDsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgYWRkX3RvcCAgICA9IDA7CiAgICAgIGFkZF9ib3R0b20gPSAxOwogICAgfQoKICAgIGZvciAoaT0wOyBpPGRwYi5yZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogICAgewogICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfcmVmZXJlbmNlKQogICAgICB7CiAgICAgICAgaWYoIGRwYi5mc19yZWZbaV0tPmZyYW1lX251bSA+IGltZy0+ZnJhbWVfbnVtICkKICAgICAgICB7CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5mcmFtZV9udW1fd3JhcCA9IGRwYi5mc19yZWZbaV0tPmZyYW1lX251bSAtIE1heEZyYW1lTnVtOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgewogICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWVfbnVtX3dyYXAgPSBkcGIuZnNfcmVmW2ldLT5mcmFtZV9udW07CiAgICAgICAgfQogICAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc19yZWZlcmVuY2UgJiAxKQogICAgICAgIHsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+cGljX251bSA9ICgyICogZHBiLmZzX3JlZltpXS0+ZnJhbWVfbnVtX3dyYXApICsgYWRkX3RvcDsKICAgICAgICB9CiAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSAmIDIpCiAgICAgICAgewogICAgICAgICAgZHBiLmZzX3JlZltpXS0+Ym90dG9tX2ZpZWxkLT5waWNfbnVtID0gKDIgKiBkcGIuZnNfcmVmW2ldLT5mcmFtZV9udW1fd3JhcCkgKyBhZGRfYm90dG9tOwogICAgICAgIH0KICAgICAgfQogICAgfQogICAgLy8gdXBkYXRlIGxvbmdfdGVybV9waWNfbnVtCiAgICBmb3IgKGk9MDsgaTxkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogICAgewogICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5pc19sb25nX3Rlcm0gJiAxKQogICAgICB7CiAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT50b3BfZmllbGQtPmxvbmdfdGVybV9waWNfbnVtID0gMiAqIGRwYi5mc19sdHJlZltpXS0+dG9wX2ZpZWxkLT5sb25nX3Rlcm1fZnJhbWVfaWR4ICsgYWRkX3RvcDsKICB9CiAgICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmlzX2xvbmdfdGVybSAmIDIpCiAgICAgIHsKICAgICAgICBkcGIuZnNfbHRyZWZbaV0tPmJvdHRvbV9maWVsZC0+bG9uZ190ZXJtX3BpY19udW0gPSAyICogZHBiLmZzX2x0cmVmW2ldLT5ib3R0b21fZmllbGQtPmxvbmdfdGVybV9mcmFtZV9pZHggKyBhZGRfYm90dG9tOwogICAgICB9CiAgICB9CiAgfQoKCgogIGlmICgoY3VyclNsaWNlVHlwZSA9PSBJX1NMSUNFKXx8KGN1cnJTbGljZVR5cGUgPT0gU0lfU0xJQ0UpKQogIHsKICAgIGxpc3RYc2l6ZVswXSA9IDA7CiAgICBsaXN0WHNpemVbMV0gPSAwOwogICAgcmV0dXJuOwogIH0KCiAgaWYgKChjdXJyU2xpY2VUeXBlID09IFBfU0xJQ0UpfHwoY3VyclNsaWNlVHlwZSA9PSBTUF9TTElDRSkpCiAgewogICAgLy8gQ2FsY3VsYXRlIEZyYW1lTnVtV3JhcCBhbmQgUGljTnVtCiAgICBpZiAoY3VyclBpY1N0cnVjdHVyZSA9PSBGUkFNRSkKICAgIHsKICAgICAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICAgIHsKICAgICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfdXNlZD09MykKICAgICAgICB7CiAgICAgICAgICBpZiAoKGRwYi5mc19yZWZbaV0tPmZyYW1lLT51c2VkX2Zvcl9yZWZlcmVuY2UpJiYoIWRwYi5mc19yZWZbaV0tPmZyYW1lLT5pc19sb25nX3Rlcm0pKQogICAgICAgICAgewogICAgICAgICAgICBsaXN0WFswXVtsaXN0MGlkeCsrXSA9IGRwYi5mc19yZWZbaV0tPmZyYW1lOwogICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICAgICAvLyBvcmRlciBsaXN0IDAgYnkgUGljTnVtCiAgICAgIHFzb3J0KCh2b2lkICopbGlzdFhbMF0sIGxpc3QwaWR4LCBzaXplb2YoU3RvcmFibGVQaWN0dXJlKiksIGNvbXBhcmVfcGljX2J5X3BpY19udW1fZGVzYyk7CiAgICAgIGxpc3RYc2l6ZVswXSA9IGxpc3QwaWR4OwogICAgICAvL3ByaW50ZigibGlzdFhbMF0gKFBpY051bSk6ICIpOyBmb3IgKGk9MDsgaTxsaXN0MGlkeDsgaSsrKXtwcmludGYgKCIlZCAgIiwgbGlzdFhbMF1baV0tPnBpY19udW0pO30gcHJpbnRmKCJcbiIpOwoKICAgICAgLy8gbG9uZyB0ZXJtIGhhbmRsaW5nCiAgICAgIGZvciAoaT0wOyBpPGRwYi5sdHJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICAgIHsKICAgICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5pc191c2VkPT0zKQogICAgICAgIHsKICAgICAgICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmZyYW1lLT5pc19sb25nX3Rlcm0pCiAgICAgICAgICB7CiAgICAgICAgICAgIGxpc3RYWzBdW2xpc3QwaWR4KytdPWRwYi5mc19sdHJlZltpXS0+ZnJhbWU7CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICAgIHFzb3J0KCh2b2lkICopJmxpc3RYWzBdW2xpc3RYc2l6ZVswXV0sIGxpc3QwaWR4LWxpc3RYc2l6ZVswXSwgc2l6ZW9mKFN0b3JhYmxlUGljdHVyZSopLCBjb21wYXJlX3BpY19ieV9sdF9waWNfbnVtX2FzYyk7CiAgICAgIGxpc3RYc2l6ZVswXSA9IGxpc3QwaWR4OwoKICAgICAgLy9wcmludGYoImxpc3RYWzBdIGN1cnJQb2M9JWQgKFBvYyk6ICIsIGltZy0+ZnJhbWVwb2MpOyBmb3IgKGk9MDsgaTxsaXN0WHNpemVbMF07IGkrKyl7cHJpbnRmICgiJWQgICIsIGxpc3RYWzBdW2ldLT5wb2MpO30gcHJpbnRmKCJcbiIpOwogICAgfQogICAgZWxzZQogICAgewogICAgICBmc19saXN0MCA9IGNhbGxvYyhkcGIuc2l6ZSwgc2l6ZW9mIChGcmFtZVN0b3JlKikpOwogICAgICBpZiAoTlVMTD09ZnNfbGlzdDApCiAgICAgICAgIG5vX21lbV9leGl0KCJpbml0X2xpc3RzOiBmc19saXN0MCIpOwogICAgICBmc19saXN0bHQgPSBjYWxsb2MoZHBiLnNpemUsIHNpemVvZiAoRnJhbWVTdG9yZSopKTsKICAgICAgaWYgKE5VTEw9PWZzX2xpc3RsdCkKICAgICAgICAgbm9fbWVtX2V4aXQoImluaXRfbGlzdHM6IGZzX2xpc3RsdCIpOwoKICAgICAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICAgIHsKICAgICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfcmVmZXJlbmNlKQogICAgICAgIHsKICAgICAgICAgIGZzX2xpc3QwW2xpc3QwaWR4KytdID0gZHBiLmZzX3JlZltpXTsKICAgICAgICB9CiAgICAgIH0KCiAgICAgIHFzb3J0KCh2b2lkICopZnNfbGlzdDAsIGxpc3QwaWR4LCBzaXplb2YoRnJhbWVTdG9yZSopLCBjb21wYXJlX2ZzX2J5X2ZyYW1lX251bV9kZXNjKTsKCiAgICAgIC8vcHJpbnRmKCJmc19saXN0MCAoRnJhbWVOdW0pOiAiKTsgZm9yIChpPTA7IGk8bGlzdDBpZHg7IGkrKyl7cHJpbnRmICgiJWQgICIsIGZzX2xpc3QwW2ldLT5mcmFtZV9udW1fd3JhcCk7fSBwcmludGYoIlxuIik7CgogICAgICBsaXN0WHNpemVbMF0gPSAwOwogICAgICBnZW5fcGljX2xpc3RfZnJvbV9mcmFtZV9saXN0KGN1cnJQaWNTdHJ1Y3R1cmUsIGZzX2xpc3QwLCBsaXN0MGlkeCwgbGlzdFhbMF0sICZsaXN0WHNpemVbMF0sIDApOwoKICAgICAgLy9wcmludGYoImxpc3RYWzBdIChQaWNOdW0pOiAiKTsgZm9yIChpPTA7IGk8bGlzdFhzaXplWzBdOyBpKyspe3ByaW50ZiAoIiVkICAiLCBsaXN0WFswXVtpXS0+cGljX251bSk7fSBwcmludGYoIlxuIik7CgogICAgICAvLyBsb25nIHRlcm0gaGFuZGxpbmcKICAgICAgZm9yIChpPTA7IGk8ZHBiLmx0cmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgICAgewogICAgICAgIGZzX2xpc3RsdFtsaXN0bHRpZHgrK109ZHBiLmZzX2x0cmVmW2ldOwogICAgICB9CgogICAgICBxc29ydCgodm9pZCAqKWZzX2xpc3RsdCwgbGlzdGx0aWR4LCBzaXplb2YoRnJhbWVTdG9yZSopLCBjb21wYXJlX2ZzX2J5X2x0X3BpY19pZHhfYXNjKTsKCiAgICAgIGdlbl9waWNfbGlzdF9mcm9tX2ZyYW1lX2xpc3QoY3VyclBpY1N0cnVjdHVyZSwgZnNfbGlzdGx0LCBsaXN0bHRpZHgsIGxpc3RYWzBdLCAmbGlzdFhzaXplWzBdLCAxKTsKCiAgICAgIGZyZWUoZnNfbGlzdDApOwogICAgICBmcmVlKGZzX2xpc3RsdCk7CiAgICB9CiAgICBsaXN0WHNpemVbMV0gPSAwOwogIH0KICBlbHNlCiAgewogICAgLy8gQi1TbGljZQogICAgaWYgKGN1cnJQaWNTdHJ1Y3R1cmUgPT0gRlJBTUUpCiAgICB7CiAgICAgIGZvciAoaT0wOyBpPGRwYi5yZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3VzZWQ9PTMpCiAgICAgICAgewogICAgICAgICAgaWYgKChkcGIuZnNfcmVmW2ldLT5mcmFtZS0+dXNlZF9mb3JfcmVmZXJlbmNlKSYmKCFkcGIuZnNfcmVmW2ldLT5mcmFtZS0+aXNfbG9uZ190ZXJtKSkKICAgICAgICAgIHsKICAgICAgICAgICAgaWYgKGltZy0+ZnJhbWVwb2MgPiBkcGIuZnNfcmVmW2ldLT5mcmFtZS0+cG9jKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgbGlzdFhbMF1bbGlzdDBpZHgrK10gPSBkcGIuZnNfcmVmW2ldLT5mcmFtZTsKICAgICAgICAgICAgfQogICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICAgICBxc29ydCgodm9pZCAqKWxpc3RYWzBdLCBsaXN0MGlkeCwgc2l6ZW9mKFN0b3JhYmxlUGljdHVyZSopLCBjb21wYXJlX3BpY19ieV9wb2NfZGVzYyk7CiAgICAgIGxpc3QwaWR4XzEgPSBsaXN0MGlkeDsKICAgICAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICAgIHsKICAgICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfdXNlZD09MykKICAgICAgICB7CiAgICAgICAgICBpZiAoKGRwYi5mc19yZWZbaV0tPmZyYW1lLT51c2VkX2Zvcl9yZWZlcmVuY2UpJiYoIWRwYi5mc19yZWZbaV0tPmZyYW1lLT5pc19sb25nX3Rlcm0pKQogICAgICAgICAgewogICAgICAgICAgICBpZiAoaW1nLT5mcmFtZXBvYyA8IGRwYi5mc19yZWZbaV0tPmZyYW1lLT5wb2MpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICBsaXN0WFswXVtsaXN0MGlkeCsrXSA9IGRwYi5mc19yZWZbaV0tPmZyYW1lOwogICAgICAgICAgICB9CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICAgIHFzb3J0KCh2b2lkICopJmxpc3RYWzBdW2xpc3QwaWR4XzFdLCBsaXN0MGlkeC1saXN0MGlkeF8xLCBzaXplb2YoU3RvcmFibGVQaWN0dXJlKiksIGNvbXBhcmVfcGljX2J5X3BvY19hc2MpOwoKICAgICAgZm9yIChqPTA7IGo8bGlzdDBpZHhfMTsgaisrKQogICAgICB7CiAgICAgICAgbGlzdFhbMV1bbGlzdDBpZHgtbGlzdDBpZHhfMStqXT1saXN0WFswXVtqXTsKICAgICAgfQogICAgICBmb3IgKGo9bGlzdDBpZHhfMTsgajxsaXN0MGlkeDsgaisrKQogICAgICB7CiAgICAgICAgbGlzdFhbMV1bai1saXN0MGlkeF8xXT1saXN0WFswXVtqXTsKICAgICAgfQoKICAgICAgbGlzdFhzaXplWzBdID0gbGlzdFhzaXplWzFdID0gbGlzdDBpZHg7CgovLyAgICAgIHByaW50ZigibGlzdFhbMF0gY3VyclBvYz0lZCAoUG9jKTogIiwgaW1nLT5mcmFtZXBvYyk7IGZvciAoaT0wOyBpPGxpc3RYc2l6ZVswXTsgaSsrKXtwcmludGYgKCIlZCAgIiwgbGlzdFhbMF1baV0tPnBvYyk7fSBwcmludGYoIlxuIik7Ci8vICAgICAgcHJpbnRmKCJsaXN0WFsxXSBjdXJyUG9jPSVkIChQb2MpOiAiLCBpbWctPmZyYW1lcG9jKTsgZm9yIChpPTA7IGk8bGlzdFhzaXplWzFdOyBpKyspe3ByaW50ZiAoIiVkICAiLCBsaXN0WFsxXVtpXS0+cG9jKTt9IHByaW50ZigiXG4iKTsKCiAgICAgIC8vIGxvbmcgdGVybSBoYW5kbGluZwogICAgICBmb3IgKGk9MDsgaTxkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19sdHJlZltpXS0+aXNfdXNlZD09MykKICAgICAgICB7CiAgICAgICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5mcmFtZS0+aXNfbG9uZ190ZXJtKQogICAgICAgICAgewogICAgICAgICAgICBsaXN0WFswXVtsaXN0MGlkeF0gID1kcGIuZnNfbHRyZWZbaV0tPmZyYW1lOwogICAgICAgICAgICBsaXN0WFsxXVtsaXN0MGlkeCsrXT1kcGIuZnNfbHRyZWZbaV0tPmZyYW1lOwogICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICAgICBxc29ydCgodm9pZCAqKSZsaXN0WFswXVtsaXN0WHNpemVbMF1dLCBsaXN0MGlkeC1saXN0WHNpemVbMF0sIHNpemVvZihTdG9yYWJsZVBpY3R1cmUqKSwgY29tcGFyZV9waWNfYnlfbHRfcGljX251bV9hc2MpOwogICAgICBxc29ydCgodm9pZCAqKSZsaXN0WFsxXVtsaXN0WHNpemVbMF1dLCBsaXN0MGlkeC1saXN0WHNpemVbMF0sIHNpemVvZihTdG9yYWJsZVBpY3R1cmUqKSwgY29tcGFyZV9waWNfYnlfbHRfcGljX251bV9hc2MpOwogICAgICBsaXN0WHNpemVbMF0gPSBsaXN0WHNpemVbMV0gPSBsaXN0MGlkeDsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgZnNfbGlzdDAgPSBjYWxsb2MoZHBiLnNpemUsIHNpemVvZiAoRnJhbWVTdG9yZSopKTsKICAgICAgaWYgKE5VTEw9PWZzX2xpc3QwKQogICAgICAgICBub19tZW1fZXhpdCgiaW5pdF9saXN0czogZnNfbGlzdDAiKTsKICAgICAgZnNfbGlzdDEgPSBjYWxsb2MoZHBiLnNpemUsIHNpemVvZiAoRnJhbWVTdG9yZSopKTsKICAgICAgaWYgKE5VTEw9PWZzX2xpc3QxKQogICAgICAgICBub19tZW1fZXhpdCgiaW5pdF9saXN0czogZnNfbGlzdDEiKTsKICAgICAgZnNfbGlzdGx0ID0gY2FsbG9jKGRwYi5zaXplLCBzaXplb2YgKEZyYW1lU3RvcmUqKSk7CiAgICAgIGlmIChOVUxMPT1mc19saXN0bHQpCiAgICAgICAgIG5vX21lbV9leGl0KCJpbml0X2xpc3RzOiBmc19saXN0bHQiKTsKCiAgICAgIGxpc3RYc2l6ZVswXSA9IDA7CiAgICAgIGxpc3RYc2l6ZVsxXSA9IDE7CgogICAgICBmb3IgKGk9MDsgaTxkcGIucmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgICAgewogICAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc191c2VkKQogICAgICAgIHsKICAgICAgICAgIGlmIChpbWctPlRoaXNQT0MgPj0gZHBiLmZzX3JlZltpXS0+cG9jKQogICAgICAgICAgewogICAgICAgICAgICBmc19saXN0MFtsaXN0MGlkeCsrXSA9IGRwYi5mc19yZWZbaV07CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICAgIHFzb3J0KCh2b2lkICopZnNfbGlzdDAsIGxpc3QwaWR4LCBzaXplb2YoRnJhbWVTdG9yZSopLCBjb21wYXJlX2ZzX2J5X3BvY19kZXNjKTsKICAgICAgbGlzdDBpZHhfMSA9IGxpc3QwaWR4OwogICAgICBmb3IgKGk9MDsgaTxkcGIucmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgICAgewogICAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc191c2VkKQogICAgICAgIHsKICAgICAgICAgIGlmIChpbWctPlRoaXNQT0MgPCBkcGIuZnNfcmVmW2ldLT5wb2MpCiAgICAgICAgICB7CiAgICAgICAgICAgIGZzX2xpc3QwW2xpc3QwaWR4KytdID0gZHBiLmZzX3JlZltpXTsKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgIH0KICAgICAgcXNvcnQoKHZvaWQgKikmZnNfbGlzdDBbbGlzdDBpZHhfMV0sIGxpc3QwaWR4LWxpc3QwaWR4XzEsIHNpemVvZihGcmFtZVN0b3JlKiksIGNvbXBhcmVfZnNfYnlfcG9jX2FzYyk7CgogICAgICBmb3IgKGo9MDsgajxsaXN0MGlkeF8xOyBqKyspCiAgICAgIHsKICAgICAgICBmc19saXN0MVtsaXN0MGlkeC1saXN0MGlkeF8xK2pdPWZzX2xpc3QwW2pdOwogICAgICB9CiAgICAgIGZvciAoaj1saXN0MGlkeF8xOyBqPGxpc3QwaWR4OyBqKyspCiAgICAgIHsKICAgICAgICBmc19saXN0MVtqLWxpc3QwaWR4XzFdPWZzX2xpc3QwW2pdOwogICAgICB9CgovLyAgICAgIHByaW50ZigiZnNfbGlzdDAgY3VyclBvYz0lZCAoUG9jKTogIiwgaW1nLT5UaGlzUE9DKTsgZm9yIChpPTA7IGk8bGlzdDBpZHg7IGkrKyl7cHJpbnRmICgiJWQgICIsIGZzX2xpc3QwW2ldLT5wb2MpO30gcHJpbnRmKCJcbiIpOwovLyAgICAgIHByaW50ZigiZnNfbGlzdDEgY3VyclBvYz0lZCAoUG9jKTogIiwgaW1nLT5UaGlzUE9DKTsgZm9yIChpPTA7IGk8bGlzdDBpZHg7IGkrKyl7cHJpbnRmICgiJWQgICIsIGZzX2xpc3QxW2ldLT5wb2MpO30gcHJpbnRmKCJcbiIpOwoKICAgICAgbGlzdFhzaXplWzBdID0gMDsKICAgICAgbGlzdFhzaXplWzFdID0gMDsKICAgICAgZ2VuX3BpY19saXN0X2Zyb21fZnJhbWVfbGlzdChjdXJyUGljU3RydWN0dXJlLCBmc19saXN0MCwgbGlzdDBpZHgsIGxpc3RYWzBdLCAmbGlzdFhzaXplWzBdLCAwKTsKICAgICAgZ2VuX3BpY19saXN0X2Zyb21fZnJhbWVfbGlzdChjdXJyUGljU3RydWN0dXJlLCBmc19saXN0MSwgbGlzdDBpZHgsIGxpc3RYWzFdLCAmbGlzdFhzaXplWzFdLCAwKTsKCi8vICAgICAgcHJpbnRmKCJsaXN0WFswXSBjdXJyUG9jPSVkIChQb2MpOiAiLCBpbWctPmZyYW1lcG9jKTsgZm9yIChpPTA7IGk8bGlzdFhzaXplWzBdOyBpKyspe3ByaW50ZiAoIiVkICAiLCBsaXN0WFswXVtpXS0+cG9jKTt9IHByaW50ZigiXG4iKTsKLy8gICAgICBwcmludGYoImxpc3RYWzFdIGN1cnJQb2M9JWQgKFBvYyk6ICIsIGltZy0+ZnJhbWVwb2MpOyBmb3IgKGk9MDsgaTxsaXN0WHNpemVbMV07IGkrKyl7cHJpbnRmICgiJWQgICIsIGxpc3RYWzFdW2ldLT5wb2MpO30gcHJpbnRmKCJcbiIpOwoKICAgICAgLy8gbG9uZyB0ZXJtIGhhbmRsaW5nCiAgICAgIGZvciAoaT0wOyBpPGRwYi5sdHJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICAgIHsKICAgICAgICBmc19saXN0bHRbbGlzdGx0aWR4KytdPWRwYi5mc19sdHJlZltpXTsKICAgICAgfQoKICAgICAgcXNvcnQoKHZvaWQgKilmc19saXN0bHQsIGxpc3RsdGlkeCwgc2l6ZW9mKEZyYW1lU3RvcmUqKSwgY29tcGFyZV9mc19ieV9sdF9waWNfaWR4X2FzYyk7CgogICAgICBnZW5fcGljX2xpc3RfZnJvbV9mcmFtZV9saXN0KGN1cnJQaWNTdHJ1Y3R1cmUsIGZzX2xpc3RsdCwgbGlzdGx0aWR4LCBsaXN0WFswXSwgJmxpc3RYc2l6ZVswXSwgMSk7CiAgICAgIGdlbl9waWNfbGlzdF9mcm9tX2ZyYW1lX2xpc3QoY3VyclBpY1N0cnVjdHVyZSwgZnNfbGlzdGx0LCBsaXN0bHRpZHgsIGxpc3RYWzFdLCAmbGlzdFhzaXplWzFdLCAxKTsKCiAgICAgIGZyZWUoZnNfbGlzdDApOwogICAgICBmcmVlKGZzX2xpc3QxKTsKICAgICAgZnJlZShmc19saXN0bHQpOwogICAgfQogIH0KCiAgaWYgKChsaXN0WHNpemVbMF0gPT0gbGlzdFhzaXplWzFdKSAmJiAobGlzdFhzaXplWzBdID4gMSkpCiAgewogICAgLy8gY2hlY2sgaWYgbGlzdHMgYXJlIGlkZW50aWNhbCwgaWYgeWVzIHN3YXAgZmlyc3QgdHdvIGVsZW1lbnRzIG9mIGxpc3RYWzFdCiAgICBkaWZmPTA7CiAgICBmb3IgKGogPSAwOyBqPCBsaXN0WHNpemVbMF07IGorKykKICAgIHsKICAgICAgaWYgKGxpc3RYWzBdW2pdIT1saXN0WFsxXVtqXSkKICAgICAgICBkaWZmPTE7CiAgICB9CiAgICBpZiAoIWRpZmYpCiAgICB7CiAgICAgIHRtcF9zID0gbGlzdFhbMV1bMF07CiAgICAgIGxpc3RYWzFdWzBdPWxpc3RYWzFdWzFdOwogICAgICBsaXN0WFsxXVsxXT10bXBfczsKICAgIH0KICB9CgogIC8vIHNldCBtYXggc2l6ZQogIGxpc3RYc2l6ZVswXSA9IGltaW4gKGxpc3RYc2l6ZVswXSwgaW1nLT5udW1fcmVmX2lkeF9sMF9hY3RpdmUpOwogIGxpc3RYc2l6ZVsxXSA9IGltaW4gKGxpc3RYc2l6ZVsxXSwgaW1nLT5udW1fcmVmX2lkeF9sMV9hY3RpdmUpOwoKICAvLyBzZXQgdGhlIHVudXNlZCBsaXN0IGVudHJpZXMgdG8gTlVMTAogIGZvciAoaT1saXN0WHNpemVbMF07IGk8IChNQVhfTElTVF9TSVpFKSA7IGkrKykKICB7CiAgICBsaXN0WFswXVtpXSA9IE5VTEw7CiAgfQogIGZvciAoaT1saXN0WHNpemVbMV07IGk8IChNQVhfTElTVF9TSVpFKSA7IGkrKykKICB7CiAgICBsaXN0WFsxXVtpXSA9IE5VTEw7CiAgfQp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgSW5pdGlhbGl6ZSBsaXN0WFsyLi41XSBmcm9tIGxpc3RzIDAgYW5kIDEKICogICAgbGlzdFhbMl06IGxpc3QwIGZvciBjdXJyZW50X2ZpZWxkPT10b3AKICogICAgbGlzdFhbM106IGxpc3QxIGZvciBjdXJyZW50X2ZpZWxkPT10b3AKICogICAgbGlzdFhbNF06IGxpc3QwIGZvciBjdXJyZW50X2ZpZWxkPT1ib3R0b20KICogICAgbGlzdFhbNV06IGxpc3QxIGZvciBjdXJyZW50X2ZpZWxkPT1ib3R0b20KICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBpbml0X21iYWZmX2xpc3RzKHZvaWQpCnsKICB1bnNpZ25lZCBqOwogIGludCBpOwoKICBmb3IgKGk9MjtpPDY7aSsrKQogIHsKICAgIGZvciAoaj0wOyBqPE1BWF9MSVNUX1NJWkU7IGorKykKICAgIHsKICAgICAgbGlzdFhbaV1bal0gPSBOVUxMOwogICAgfQogICAgbGlzdFhzaXplW2ldPTA7CiAgfQoKICBmb3IgKGk9MDsgaTxsaXN0WHNpemVbMF07IGkrKykKICB7CiAgICBsaXN0WFsyXVsyKmldICA9bGlzdFhbMF1baV0tPnRvcF9maWVsZDsKICAgIGxpc3RYWzJdWzIqaSsxXT1saXN0WFswXVtpXS0+Ym90dG9tX2ZpZWxkOwogICAgbGlzdFhbNF1bMippXSAgPWxpc3RYWzBdW2ldLT5ib3R0b21fZmllbGQ7CiAgICBsaXN0WFs0XVsyKmkrMV09bGlzdFhbMF1baV0tPnRvcF9maWVsZDsKICB9CiAgbGlzdFhzaXplWzJdPWxpc3RYc2l6ZVs0XT1saXN0WHNpemVbMF0gKiAyOwoKICBmb3IgKGk9MDsgaTxsaXN0WHNpemVbMV07IGkrKykKICB7CiAgICBsaXN0WFszXVsyKmldICA9bGlzdFhbMV1baV0tPnRvcF9maWVsZDsKICAgIGxpc3RYWzNdWzIqaSsxXT1saXN0WFsxXVtpXS0+Ym90dG9tX2ZpZWxkOwogICAgbGlzdFhbNV1bMippXSAgPWxpc3RYWzFdW2ldLT5ib3R0b21fZmllbGQ7CiAgICBsaXN0WFs1XVsyKmkrMV09bGlzdFhbMV1baV0tPnRvcF9maWVsZDsKICB9CiAgbGlzdFhzaXplWzNdPWxpc3RYc2l6ZVs1XT1saXN0WHNpemVbMV0gKiAyOwp9CgogLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIFJldHVybnMgc2hvcnQgdGVybSBwaWMgd2l0aCBnaXZlbiBwaWNOdW0KICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIFN0b3JhYmxlUGljdHVyZSogIGdldF9zaG9ydF90ZXJtX3BpYyhpbnQgcGljTnVtKQp7CiAgdW5zaWduZWQgaTsKCiAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgewogICAgaWYgKGltZy0+c3RydWN0dXJlPT1GUkFNRSkKICAgIHsKICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSA9PSAzKQogICAgICAgIGlmICgoIWRwYi5mc19yZWZbaV0tPmZyYW1lLT5pc19sb25nX3Rlcm0pJiYoZHBiLmZzX3JlZltpXS0+ZnJhbWUtPnBpY19udW0gPT0gcGljTnVtKSkKICAgICAgICAgIHJldHVybiBkcGIuZnNfcmVmW2ldLT5mcmFtZTsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSAmIDEpCiAgICAgICAgaWYgKCghZHBiLmZzX3JlZltpXS0+dG9wX2ZpZWxkLT5pc19sb25nX3Rlcm0pJiYoZHBiLmZzX3JlZltpXS0+dG9wX2ZpZWxkLT5waWNfbnVtID09IHBpY051bSkpCiAgICAgICAgICByZXR1cm4gZHBiLmZzX3JlZltpXS0+dG9wX2ZpZWxkOwogICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfcmVmZXJlbmNlICYgMikKICAgICAgICBpZiAoKCFkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPmlzX2xvbmdfdGVybSkmJihkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPnBpY19udW0gPT0gcGljTnVtKSkKICAgICAgICAgIHJldHVybiBkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQ7CiAgICB9CiAgfQogIHJldHVybiBOVUxMOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgUmV0dXJucyBzaG9ydCB0ZXJtIHBpYyB3aXRoIGdpdmVuIExvbmd0ZXJtUGljTnVtCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyBTdG9yYWJsZVBpY3R1cmUqICBnZXRfbG9uZ190ZXJtX3BpYyhpbnQgTG9uZ3Rlcm1QaWNOdW0pCnsKICB1bnNpZ25lZCBpOwoKICBmb3IgKGk9MDsgaTxkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogIHsKICAgIGlmIChpbWctPnN0cnVjdHVyZT09RlJBTUUpCiAgICB7CiAgICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmlzX3JlZmVyZW5jZSA9PSAzKQogICAgICAgIGlmICgoZHBiLmZzX2x0cmVmW2ldLT5mcmFtZS0+aXNfbG9uZ190ZXJtKSYmKGRwYi5mc19sdHJlZltpXS0+ZnJhbWUtPmxvbmdfdGVybV9waWNfbnVtID09IExvbmd0ZXJtUGljTnVtKSkKICAgICAgICAgIHJldHVybiBkcGIuZnNfbHRyZWZbaV0tPmZyYW1lOwogICAgfQogICAgZWxzZQogICAgewogICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5pc19yZWZlcmVuY2UgJiAxKQogICAgICAgIGlmICgoZHBiLmZzX2x0cmVmW2ldLT50b3BfZmllbGQtPmlzX2xvbmdfdGVybSkmJihkcGIuZnNfbHRyZWZbaV0tPnRvcF9maWVsZC0+bG9uZ190ZXJtX3BpY19udW0gPT0gTG9uZ3Rlcm1QaWNOdW0pKQogICAgICAgICAgcmV0dXJuIGRwYi5mc19sdHJlZltpXS0+dG9wX2ZpZWxkOwogICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5pc19yZWZlcmVuY2UgJiAyKQogICAgICAgIGlmICgoZHBiLmZzX2x0cmVmW2ldLT5ib3R0b21fZmllbGQtPmlzX2xvbmdfdGVybSkmJihkcGIuZnNfbHRyZWZbaV0tPmJvdHRvbV9maWVsZC0+bG9uZ190ZXJtX3BpY19udW0gPT0gTG9uZ3Rlcm1QaWNOdW0pKQogICAgICAgICAgcmV0dXJuIGRwYi5mc19sdHJlZltpXS0+Ym90dG9tX2ZpZWxkOwogICAgfQogIH0KICByZXR1cm4gTlVMTDsKfQoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIFJlb3JkZXJpbmcgcHJvY2VzcyBmb3Igc2hvcnQtdGVybSByZWZlcmVuY2UgcGljdHVyZXMKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgcmVvcmRlcl9zaG9ydF90ZXJtKFN0b3JhYmxlUGljdHVyZSAqKlJlZlBpY0xpc3RYLCBpbnQgbnVtX3JlZl9pZHhfbFhfYWN0aXZlX21pbnVzMSwgaW50IHBpY051bUxYLCBpbnQgKnJlZklkeExYKQp7CiAgaW50IGNJZHgsIG5JZHg7CgogIFN0b3JhYmxlUGljdHVyZSAqcGljTFg7CgogIHBpY0xYID0gZ2V0X3Nob3J0X3Rlcm1fcGljKHBpY051bUxYKTsKCiAgZm9yKCBjSWR4ID0gbnVtX3JlZl9pZHhfbFhfYWN0aXZlX21pbnVzMSsxOyBjSWR4ID4gKnJlZklkeExYOyBjSWR4LS0gKQogICAgUmVmUGljTGlzdFhbIGNJZHggXSA9IFJlZlBpY0xpc3RYWyBjSWR4IC0gMV07CgogIFJlZlBpY0xpc3RYWyAoKnJlZklkeExYKSsrIF0gPSBwaWNMWDsKCiAgbklkeCA9ICpyZWZJZHhMWDsKCiAgZm9yKCBjSWR4ID0gKnJlZklkeExYOyBjSWR4IDw9IG51bV9yZWZfaWR4X2xYX2FjdGl2ZV9taW51czErMTsgY0lkeCsrICkKICAgIGlmIChSZWZQaWNMaXN0WFsgY0lkeCBdKQogICAgICBpZiggKFJlZlBpY0xpc3RYWyBjSWR4IF0tPmlzX2xvbmdfdGVybSApIHx8ICAoUmVmUGljTGlzdFhbIGNJZHggXS0+cGljX251bSAhPSBwaWNOdW1MWCApKQogICAgICAgIFJlZlBpY0xpc3RYWyBuSWR4KysgXSA9IFJlZlBpY0xpc3RYWyBjSWR4IF07Cgp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIFJlb3JkZXJpbmcgcHJvY2VzcyBmb3Igc2hvcnQtdGVybSByZWZlcmVuY2UgcGljdHVyZXMKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgcmVvcmRlcl9sb25nX3Rlcm0oU3RvcmFibGVQaWN0dXJlICoqUmVmUGljTGlzdFgsIGludCBudW1fcmVmX2lkeF9sWF9hY3RpdmVfbWludXMxLCBpbnQgTG9uZ1Rlcm1QaWNOdW0sIGludCAqcmVmSWR4TFgpCnsKICBpbnQgY0lkeCwgbklkeDsKCiAgU3RvcmFibGVQaWN0dXJlICpwaWNMWDsKCiAgcGljTFggPSBnZXRfbG9uZ190ZXJtX3BpYyhMb25nVGVybVBpY051bSk7CgogIGZvciggY0lkeCA9IG51bV9yZWZfaWR4X2xYX2FjdGl2ZV9taW51czErMTsgY0lkeCA+ICpyZWZJZHhMWDsgY0lkeC0tICkKICAgIFJlZlBpY0xpc3RYWyBjSWR4IF0gPSBSZWZQaWNMaXN0WFsgY0lkeCAtIDFdOwoKICBSZWZQaWNMaXN0WFsgKCpyZWZJZHhMWCkrKyBdID0gcGljTFg7CgogIG5JZHggPSAqcmVmSWR4TFg7CgogIGZvciggY0lkeCA9ICpyZWZJZHhMWDsgY0lkeCA8PSBudW1fcmVmX2lkeF9sWF9hY3RpdmVfbWludXMxKzE7IGNJZHgrKyApCiAgICBpZiggKCFSZWZQaWNMaXN0WFsgY0lkeCBdLT5pc19sb25nX3Rlcm0gKSB8fCAgKFJlZlBpY0xpc3RYWyBjSWR4IF0tPmxvbmdfdGVybV9waWNfbnVtICE9IExvbmdUZXJtUGljTnVtICkpCiAgICAgIFJlZlBpY0xpc3RYWyBuSWR4KysgXSA9IFJlZlBpY0xpc3RYWyBjSWR4IF07Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgUmVvcmRlcmluZyBwcm9jZXNzIGZvciByZWZlcmVuY2UgcGljdHVyZSBsaXN0cwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIHJlb3JkZXJfcmVmX3BpY19saXN0KFN0b3JhYmxlUGljdHVyZSAqKmxpc3QsIGludCAqbGlzdF9zaXplLCBpbnQgbnVtX3JlZl9pZHhfbFhfYWN0aXZlX21pbnVzMSwgaW50ICpyZW9yZGVyaW5nX29mX3BpY19udW1zX2lkYywgaW50ICphYnNfZGlmZl9waWNfbnVtX21pbnVzMSwgaW50ICpsb25nX3Rlcm1fcGljX2lkeCkKewogIGludCBpOwoKICBpbnQgbWF4UGljTnVtLCBjdXJyUGljTnVtLCBwaWNOdW1MWE5vV3JhcCwgcGljTnVtTFhQcmVkLCBwaWNOdW1MWDsKICBpbnQgcmVmSWR4TFggPSAwOwogIGludCBNYXhGcmFtZU51bSA9IDEgPDwgKGxvZzJfbWF4X2ZyYW1lX251bV9taW51czQgKyA0KTsKCiAgaWYgKGltZy0+c3RydWN0dXJlPT1GUkFNRSkKICB7CiAgICBtYXhQaWNOdW0gID0gTWF4RnJhbWVOdW07CiAgICBjdXJyUGljTnVtID0gaW1nLT5mcmFtZV9udW07CiAgfQogIGVsc2UKICB7CiAgICBtYXhQaWNOdW0gID0gMiAqIE1heEZyYW1lTnVtOwogICAgY3VyclBpY051bSA9IDIgKiBpbWctPmZyYW1lX251bSArIDE7CiAgfQoKICBwaWNOdW1MWFByZWQgPSBjdXJyUGljTnVtOwoKICBmb3IgKGk9MDsgcmVvcmRlcmluZ19vZl9waWNfbnVtc19pZGNbaV0hPTM7IGkrKykKICB7CiAgICBpZiAocmVvcmRlcmluZ19vZl9waWNfbnVtc19pZGNbaV0+MykKICAgICAgZXJyb3IgKCJJbnZhbGlkIHJlbWFwcGluZ19vZl9waWNfbnVtc19pZGMgY29tbWFuZCIsIDUwMCk7CgogICAgaWYgKHJlb3JkZXJpbmdfb2ZfcGljX251bXNfaWRjW2ldIDwgMikKICAgIHsKICAgICAgaWYgKHJlb3JkZXJpbmdfb2ZfcGljX251bXNfaWRjW2ldID09IDApCiAgICAgIHsKICAgICAgICBpZiggcGljTnVtTFhQcmVkIC0gKCBhYnNfZGlmZl9waWNfbnVtX21pbnVzMVtpXSArIDEgKSA8IDAgKQogICAgICAgICAgcGljTnVtTFhOb1dyYXAgPSBwaWNOdW1MWFByZWQgLSAoIGFic19kaWZmX3BpY19udW1fbWludXMxW2ldICsgMSApICsgbWF4UGljTnVtOwogICAgICAgIGVsc2UKICAgICAgICAgIHBpY051bUxYTm9XcmFwID0gcGljTnVtTFhQcmVkIC0gKCBhYnNfZGlmZl9waWNfbnVtX21pbnVzMVtpXSArIDEgKTsKICAgICAgfQogICAgICBlbHNlIC8vIChyZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY1tpXSA9PSAxKQogICAgICB7CiAgICAgICAgaWYoIHBpY051bUxYUHJlZCArICggYWJzX2RpZmZfcGljX251bV9taW51czFbaV0gKyAxICkgID49ICBtYXhQaWNOdW0gKQogICAgICAgICAgcGljTnVtTFhOb1dyYXAgPSBwaWNOdW1MWFByZWQgKyAoIGFic19kaWZmX3BpY19udW1fbWludXMxW2ldICsgMSApIC0gbWF4UGljTnVtOwogICAgICAgIGVsc2UKICAgICAgICAgIHBpY051bUxYTm9XcmFwID0gcGljTnVtTFhQcmVkICsgKCBhYnNfZGlmZl9waWNfbnVtX21pbnVzMVtpXSArIDEgKTsKICAgICAgfQogICAgICBwaWNOdW1MWFByZWQgPSBwaWNOdW1MWE5vV3JhcDsKCiAgICAgIGlmKCBwaWNOdW1MWE5vV3JhcCA+IGN1cnJQaWNOdW0gKQogICAgICAgIHBpY051bUxYID0gcGljTnVtTFhOb1dyYXAgLSBtYXhQaWNOdW07CiAgICAgIGVsc2UKICAgICAgICBwaWNOdW1MWCA9IHBpY051bUxYTm9XcmFwOwoKICAgICAgcmVvcmRlcl9zaG9ydF90ZXJtKGxpc3QsIG51bV9yZWZfaWR4X2xYX2FjdGl2ZV9taW51czEsIHBpY051bUxYLCAmcmVmSWR4TFgpOwogICAgfQogICAgZWxzZSAvLyhyZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY1tpXSA9PSAyKQogICAgewogICAgICByZW9yZGVyX2xvbmdfdGVybShsaXN0LCBudW1fcmVmX2lkeF9sWF9hY3RpdmVfbWludXMxLCBsb25nX3Rlcm1fcGljX2lkeFtpXSwgJnJlZklkeExYKTsKICAgIH0KCiAgfQogIC8vIHRoYXQncyBhIGRlZmluaXRpb24KICAqbGlzdF9zaXplID0gbnVtX3JlZl9pZHhfbFhfYWN0aXZlX21pbnVzMSArIDE7Cn0KCgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIFVwZGF0ZSB0aGUgbGlzdCBvZiBmcmFtZSBzdG9yZXMgdGhhdCBjb250YWluIHJlZmVyZW5jZSBmcmFtZXMvZmllbGRzCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnZvaWQgdXBkYXRlX3JlZl9saXN0KHZvaWQpCnsKICB1bnNpZ25lZCBpLCBqOwogIGZvciAoaT0wLCBqPTA7IGk8ZHBiLnVzZWRfc2l6ZTsgaSsrKQogIHsKICAgIGlmIChpc19zaG9ydF90ZXJtX3JlZmVyZW5jZShkcGIuZnNbaV0pKQogICAgewogICAgICBkcGIuZnNfcmVmW2orK109ZHBiLmZzW2ldOwogICAgfQogIH0KCiAgZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyID0gajsKCiAgd2hpbGUgKGo8ZHBiLnNpemUpCiAgewogICAgZHBiLmZzX3JlZltqKytdPU5VTEw7CiAgfQp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIFVwZGF0ZSB0aGUgbGlzdCBvZiBmcmFtZSBzdG9yZXMgdGhhdCBjb250YWluIGxvbmctdGVybSByZWZlcmVuY2UKICogICAgZnJhbWVzL2ZpZWxkcwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIHVwZGF0ZV9sdHJlZl9saXN0KHZvaWQpCnsKICB1bnNpZ25lZCBpLCBqOwogIGZvciAoaT0wLCBqPTA7IGk8ZHBiLnVzZWRfc2l6ZTsgaSsrKQogIHsKICAgIGlmIChpc19sb25nX3Rlcm1fcmVmZXJlbmNlKGRwYi5mc1tpXSkpCiAgICB7CiAgICAgIGRwYi5mc19sdHJlZltqKytdPWRwYi5mc1tpXTsKICAgIH0KICB9CgogIGRwYi5sdHJlZl9mcmFtZXNfaW5fYnVmZmVyPWo7CgogIHdoaWxlIChqPGRwYi5zaXplKQogIHsKICAgIGRwYi5mc19sdHJlZltqKytdPU5VTEw7CiAgfQp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgUGVyZm9ybSBNZW1vcnkgbWFuYWdlbWVudCBmb3IgaWRyIHBpY3R1cmVzCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIGlkcl9tZW1vcnlfbWFuYWdlbWVudChTdG9yYWJsZVBpY3R1cmUqIHApCnsKICB1bnNpZ25lZCBpOwoKICBhc3NlcnQgKGltZy0+Y3VycmVudFBpY3R1cmUtPmlkcl9mbGFnKTsKCiAgaWYgKGltZy0+bm9fb3V0cHV0X29mX3ByaW9yX3BpY3NfZmxhZykKICB7CiAgICAvLyBmcmVlIGFsbCBzdG9yZWQgcGljdHVyZXMKICAgIGZvciAoaT0wOyBpPGRwYi51c2VkX3NpemU7IGkrKykKICAgIHsKICAgICAgLy8gcmVzZXQgYWxsIHJlZmVyZW5jZSBzZXR0aW5ncwogICAgICBmcmVlX2ZyYW1lX3N0b3JlKGRwYi5mc1tpXSk7CiAgICAgIGRwYi5mc1tpXSA9IGFsbG9jX2ZyYW1lX3N0b3JlKCk7CiAgICB9CiAgICBmb3IgKGk9MDsgaTxkcGIucmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgIHsKICAgICAgZHBiLmZzX3JlZltpXT1OVUxMOwogICAgfQogICAgZm9yIChpPTA7IGk8ZHBiLmx0cmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgIHsKICAgICAgZHBiLmZzX2x0cmVmW2ldPU5VTEw7CiAgICB9CiAgICBkcGIudXNlZF9zaXplPTA7CiAgfQogIGVsc2UKICB7CiAgICBmbHVzaF9kcGIoKTsKICB9CiAgZHBiLmxhc3RfcGljdHVyZSA9IE5VTEw7CgogIHVwZGF0ZV9yZWZfbGlzdCgpOwogIHVwZGF0ZV9sdHJlZl9saXN0KCk7CiAgZHBiLmxhc3Rfb3V0cHV0X3BvYyA9IElOVF9NSU47CgogIGlmIChpbWctPmxvbmdfdGVybV9yZWZlcmVuY2VfZmxhZykKICB7CiAgICBkcGIubWF4X2xvbmdfdGVybV9waWNfaWR4ID0gMDsKICAgIHAtPmlzX2xvbmdfdGVybSAgICAgICAgICAgPSAxOwogICAgcC0+bG9uZ190ZXJtX2ZyYW1lX2lkeCAgICA9IDA7CiAgfQogIGVsc2UKICB7CiAgICBkcGIubWF4X2xvbmdfdGVybV9waWNfaWR4ID0gLTE7CiAgICBwLT5pc19sb25nX3Rlcm0gICAgICAgICAgID0gMDsKICB9Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBQZXJmb3JtIFNsaWRpbmcgd2luZG93IGRlY29kZWQgcmVmZXJlbmNlIHBpY3R1cmUgbWFya2luZyBwcm9jZXNzCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIHNsaWRpbmdfd2luZG93X21lbW9yeV9tYW5hZ2VtZW50KFN0b3JhYmxlUGljdHVyZSogcCkKewogIHVuc2lnbmVkIGk7CgogIGFzc2VydCAoIWltZy0+Y3VycmVudFBpY3R1cmUtPmlkcl9mbGFnKTsKICAvLyBpZiB0aGlzIGlzIGEgcmVmZXJlbmNlIHBpYyB3aXRoIHNsaWRpbmcgc2xpZGluZyB3aW5kb3csIHVubWFyayBmaXJzdCByZWYgZnJhbWUKICBpZiAoZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyPT1hY3RpdmVfc3BzLT5udW1fcmVmX2ZyYW1lcyAtIGRwYi5sdHJlZl9mcmFtZXNfaW5fYnVmZmVyKQogIHsKICAgIGZvciAoaT0wOyBpPGRwYi51c2VkX3NpemU7aSsrKQogICAgewogICAgICBpZiAoZHBiLmZzW2ldLT5pc19yZWZlcmVuY2UgICYmICghKGRwYi5mc1tpXS0+aXNfbG9uZ190ZXJtKSkpCiAgICAgIHsKICAgICAgICB1bm1hcmtfZm9yX3JlZmVyZW5jZShkcGIuZnNbaV0pOwogICAgICAgIHVwZGF0ZV9yZWZfbGlzdCgpOwogICAgICAgIGJyZWFrOwogICAgICB9CiAgICB9CiAgfQoKICBwLT5pc19sb25nX3Rlcm0gPSAwOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQ2FsY3VsYXRlIHBpY051bVgKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIGludCBnZXRfcGljX251bV94IChTdG9yYWJsZVBpY3R1cmUgKnAsIGludCBkaWZmZXJlbmNlX29mX3BpY19udW1zX21pbnVzMSkKewogIGludCBjdXJyUGljTnVtOwoKICBpZiAocC0+c3RydWN0dXJlID09IEZSQU1FKQogICAgY3VyclBpY051bSA9IHAtPmZyYW1lX251bTsKICBlbHNlCiAgICBjdXJyUGljTnVtID0gMiAqIHAtPmZyYW1lX251bSArIDE7CgogIHJldHVybiBjdXJyUGljTnVtIC0gKGRpZmZlcmVuY2Vfb2ZfcGljX251bXNfbWludXMxICsgMSk7Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQWRhcHRpdmUgTWVtb3J5IE1hbmFnZW1lbnQ6IE1hcmsgc2hvcnQgdGVybSBwaWN0dXJlIHVudXNlZAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCBtbV91bm1hcmtfc2hvcnRfdGVybV9mb3JfcmVmZXJlbmNlKFN0b3JhYmxlUGljdHVyZSAqcCwgaW50IGRpZmZlcmVuY2Vfb2ZfcGljX251bXNfbWludXMxKQp7CiAgaW50IHBpY051bVg7CgogIHVuc2lnbmVkIGk7CgogIHBpY051bVggPSBnZXRfcGljX251bV94KHAsIGRpZmZlcmVuY2Vfb2ZfcGljX251bXNfbWludXMxKTsKCiAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgewogICAgaWYgKHAtPnN0cnVjdHVyZSA9PSBGUkFNRSkKICAgIHsKICAgICAgaWYgKChkcGIuZnNfcmVmW2ldLT5pc19yZWZlcmVuY2U9PTMpICYmIChkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm09PTApKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmZyYW1lLT5waWNfbnVtID09IHBpY051bVgpCiAgICAgICAgewogICAgICAgICAgdW5tYXJrX2Zvcl9yZWZlcmVuY2UoZHBiLmZzX3JlZltpXSk7CiAgICAgICAgICByZXR1cm47CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgIGlmICgoZHBiLmZzX3JlZltpXS0+aXNfcmVmZXJlbmNlICYgMSkgJiYgKCEoZHBiLmZzX3JlZltpXS0+aXNfbG9uZ190ZXJtICYgMSkpKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+cGljX251bSA9PSBwaWNOdW1YKQogICAgICAgIHsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSAmPSAyOwogICAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3VzZWQgPT0gMykKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWUtPnVzZWRfZm9yX3JlZmVyZW5jZSA9IDA7CiAgICAgICAgICB9CiAgICAgICAgICByZXR1cm47CiAgICAgICAgfQogICAgICB9CiAgICAgIGlmICgoZHBiLmZzX3JlZltpXS0+aXNfcmVmZXJlbmNlICYgMikgJiYgKCEoZHBiLmZzX3JlZltpXS0+aXNfbG9uZ190ZXJtICYgMikpKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmJvdHRvbV9maWVsZC0+cGljX251bSA9PSBwaWNOdW1YKQogICAgICAgIHsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmJvdHRvbV9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSAmPSAxOwogICAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3VzZWQgPT0gMykKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWUtPnVzZWRfZm9yX3JlZmVyZW5jZSA9IDA7CiAgICAgICAgICB9CiAgICAgICAgICByZXR1cm47CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEFkYXB0aXZlIE1lbW9yeSBNYW5hZ2VtZW50OiBNYXJrIGxvbmcgdGVybSBwaWN0dXJlIHVudXNlZAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCBtbV91bm1hcmtfbG9uZ190ZXJtX2Zvcl9yZWZlcmVuY2UoU3RvcmFibGVQaWN0dXJlICpwLCBpbnQgbG9uZ190ZXJtX3BpY19udW0pCnsKICB1bnNpZ25lZCBpOwogIGZvciAoaT0wOyBpPGRwYi5sdHJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgewogICAgaWYgKHAtPnN0cnVjdHVyZSA9PSBGUkFNRSkKICAgIHsKICAgICAgaWYgKChkcGIuZnNfbHRyZWZbaV0tPmlzX3JlZmVyZW5jZT09MykgJiYgKGRwYi5mc19sdHJlZltpXS0+aXNfbG9uZ190ZXJtPT0zKSkKICAgICAgewogICAgICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmZyYW1lLT5sb25nX3Rlcm1fcGljX251bSA9PSBsb25nX3Rlcm1fcGljX251bSkKICAgICAgICB7CiAgICAgICAgICB1bm1hcmtfZm9yX2xvbmdfdGVybV9yZWZlcmVuY2UoZHBiLmZzX2x0cmVmW2ldKTsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgaWYgKChkcGIuZnNfbHRyZWZbaV0tPmlzX3JlZmVyZW5jZSAmIDEpICYmICgoZHBiLmZzX2x0cmVmW2ldLT5pc19sb25nX3Rlcm0gJiAxKSkpCiAgICAgIHsKICAgICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT50b3BfZmllbGQtPmxvbmdfdGVybV9waWNfbnVtID09IGxvbmdfdGVybV9waWNfbnVtKQogICAgICAgIHsKICAgICAgICAgIGRwYi5mc19sdHJlZltpXS0+dG9wX2ZpZWxkLT51c2VkX2Zvcl9yZWZlcmVuY2UgPSAwOwogICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT50b3BfZmllbGQtPmlzX2xvbmdfdGVybSA9IDA7CiAgICAgICAgICBkcGIuZnNfbHRyZWZbaV0tPmlzX3JlZmVyZW5jZSAmPSAyOwogICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5pc19sb25nX3Rlcm0gJj0gMjsKICAgICAgICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmlzX3VzZWQgPT0gMykKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5mcmFtZS0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5mcmFtZS0+aXNfbG9uZ190ZXJtID0gMDsKICAgICAgICAgIH0KICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgIH0KICAgICAgaWYgKChkcGIuZnNfbHRyZWZbaV0tPmlzX3JlZmVyZW5jZSAmIDIpICYmICgoZHBiLmZzX2x0cmVmW2ldLT5pc19sb25nX3Rlcm0gJiAyKSkpCiAgICAgIHsKICAgICAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5ib3R0b21fZmllbGQtPmxvbmdfdGVybV9waWNfbnVtID09IGxvbmdfdGVybV9waWNfbnVtKQogICAgICAgIHsKICAgICAgICAgIGRwYi5mc19sdHJlZltpXS0+Ym90dG9tX2ZpZWxkLT51c2VkX2Zvcl9yZWZlcmVuY2UgPSAwOwogICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5ib3R0b21fZmllbGQtPmlzX2xvbmdfdGVybSA9IDA7CiAgICAgICAgICBkcGIuZnNfbHRyZWZbaV0tPmlzX3JlZmVyZW5jZSAmPSAxOwogICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5pc19sb25nX3Rlcm0gJj0gMTsKICAgICAgICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmlzX3VzZWQgPT0gMykKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5mcmFtZS0+dXNlZF9mb3JfcmVmZXJlbmNlID0gMDsKICAgICAgICAgICAgZHBiLmZzX2x0cmVmW2ldLT5mcmFtZS0+aXNfbG9uZ190ZXJtID0gMDsKICAgICAgICAgIH0KICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICB9Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgTWFyayBhIGxvbmctdGVybSByZWZlcmVuY2UgZnJhbWUgb3IgY29tcGxlbWVudGFyeSBmaWVsZCBwYWlyIHVudXNlZCBmb3IgcmVmZXJlbWNlCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIHVubWFya19sb25nX3Rlcm1fZnJhbWVfZm9yX3JlZmVyZW5jZV9ieV9mcmFtZV9pZHgoaW50IGxvbmdfdGVybV9mcmFtZV9pZHgpCnsKICB1bnNpZ25lZCBpOwogIGZvcihpPTA7IGk8ZHBiLmx0cmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICB7CiAgICBpZiAoZHBiLmZzX2x0cmVmW2ldLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID09IGxvbmdfdGVybV9mcmFtZV9pZHgpCiAgICAgIHVubWFya19mb3JfbG9uZ190ZXJtX3JlZmVyZW5jZShkcGIuZnNfbHRyZWZbaV0pOwogIH0KfQoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIE1hcmsgYSBsb25nLXRlcm0gcmVmZXJlbmNlIGZpZWxkIHVudXNlZCBmb3IgcmVmZXJlbmNlIG9ubHkgaWYgaXQncyBub3QKICogICAgdGhlIGNvbXBsZW1lbnRhcnkgZmllbGQgb2YgdGhlIHBpY3R1cmUgaW5kaWNhdGVkIGJ5IHBpY051bVgKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgdW5tYXJrX2xvbmdfdGVybV9maWVsZF9mb3JfcmVmZXJlbmNlX2J5X2ZyYW1lX2lkeChQaWN0dXJlU3RydWN0dXJlIHN0cnVjdHVyZSwgaW50IGxvbmdfdGVybV9mcmFtZV9pZHgsIGludCBtYXJrX2N1cnJlbnQsIHVuc2lnbmVkIGN1cnJfZnJhbWVfbnVtLCBpbnQgY3Vycl9waWNfbnVtKQp7CiAgdW5zaWduZWQgaTsKICBpbnQgTWF4RnJhbWVOdW0gPSAxIDw8IChsb2cyX21heF9mcmFtZV9udW1fbWludXM0ICsgNCk7CgogIGFzc2VydChzdHJ1Y3R1cmUhPUZSQU1FKTsKICBpZiAoY3Vycl9waWNfbnVtPDApCiAgICBjdXJyX3BpY19udW0rPSgyKk1heEZyYW1lTnVtKTsKCiAgZm9yKGk9MDsgaTxkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogIHsKICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmxvbmdfdGVybV9mcmFtZV9pZHggPT0gbG9uZ190ZXJtX2ZyYW1lX2lkeCkKICAgIHsKICAgICAgaWYgKHN0cnVjdHVyZSA9PSBUT1BfRklFTEQpCiAgICAgIHsKICAgICAgICBpZiAoKGRwYi5mc19sdHJlZltpXS0+aXNfbG9uZ190ZXJtID09IDMpKQogICAgICAgIHsKICAgICAgICAgIHVubWFya19mb3JfbG9uZ190ZXJtX3JlZmVyZW5jZShkcGIuZnNfbHRyZWZbaV0pOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgewogICAgICAgICAgaWYgKChkcGIuZnNfbHRyZWZbaV0tPmlzX2xvbmdfdGVybSA9PSAxKSkKICAgICAgICAgIHsKICAgICAgICAgICAgdW5tYXJrX2Zvcl9sb25nX3Rlcm1fcmVmZXJlbmNlKGRwYi5mc19sdHJlZltpXSk7CiAgICAgICAgICB9CiAgICAgICAgICBlbHNlCiAgICAgICAgICB7CiAgICAgICAgICAgIGlmIChtYXJrX2N1cnJlbnQpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICBpZiAoZHBiLmxhc3RfcGljdHVyZSkKICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAoICggZHBiLmxhc3RfcGljdHVyZSAhPSBkcGIuZnNfbHRyZWZbaV0gKXx8IGRwYi5sYXN0X3BpY3R1cmUtPmZyYW1lX251bSAhPSBjdXJyX2ZyYW1lX251bSkKICAgICAgICAgICAgICAgICAgdW5tYXJrX2Zvcl9sb25nX3Rlcm1fcmVmZXJlbmNlKGRwYi5mc19sdHJlZltpXSk7CiAgICAgICAgICAgICAgfQogICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICB1bm1hcmtfZm9yX2xvbmdfdGVybV9yZWZlcmVuY2UoZHBiLmZzX2x0cmVmW2ldKTsKICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZWxzZQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgaWYgKChkcGIuZnNfbHRyZWZbaV0tPmZyYW1lX251bSkgIT0gKHVuc2lnbmVkKShjdXJyX3BpY19udW0vMikpCiAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgdW5tYXJrX2Zvcl9sb25nX3Rlcm1fcmVmZXJlbmNlKGRwYi5mc19sdHJlZltpXSk7CiAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICAgIGlmIChzdHJ1Y3R1cmUgPT0gQk9UVE9NX0ZJRUxEKQogICAgICB7CiAgICAgICAgaWYgKChkcGIuZnNfbHRyZWZbaV0tPmlzX2xvbmdfdGVybSA9PSAzKSkKICAgICAgICB7CiAgICAgICAgICB1bm1hcmtfZm9yX2xvbmdfdGVybV9yZWZlcmVuY2UoZHBiLmZzX2x0cmVmW2ldKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgIGlmICgoZHBiLmZzX2x0cmVmW2ldLT5pc19sb25nX3Rlcm0gPT0gMikpCiAgICAgICAgICB7CiAgICAgICAgICAgIHVubWFya19mb3JfbG9uZ190ZXJtX3JlZmVyZW5jZShkcGIuZnNfbHRyZWZbaV0pOwogICAgICAgICAgfQogICAgICAgICAgZWxzZQogICAgICAgICAgewogICAgICAgICAgICBpZiAobWFya19jdXJyZW50KQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgaWYgKGRwYi5sYXN0X3BpY3R1cmUpCiAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKCAoIGRwYi5sYXN0X3BpY3R1cmUgIT0gZHBiLmZzX2x0cmVmW2ldICl8fCBkcGIubGFzdF9waWN0dXJlLT5mcmFtZV9udW0gIT0gY3Vycl9mcmFtZV9udW0pCiAgICAgICAgICAgICAgICAgIHVubWFya19mb3JfbG9uZ190ZXJtX3JlZmVyZW5jZShkcGIuZnNfbHRyZWZbaV0pOwogICAgICAgICAgICAgIH0KICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgdW5tYXJrX2Zvcl9sb25nX3Rlcm1fcmVmZXJlbmNlKGRwYi5mc19sdHJlZltpXSk7CiAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgIGlmICgoZHBiLmZzX2x0cmVmW2ldLT5mcmFtZV9udW0pICE9ICh1bnNpZ25lZCkoY3Vycl9waWNfbnVtLzIpKQogICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIHVubWFya19mb3JfbG9uZ190ZXJtX3JlZmVyZW5jZShkcGIuZnNfbHRyZWZbaV0pOwogICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBtYXJrIGEgcGljdHVyZSBhcyBsb25nLXRlcm0gcmVmZXJlbmNlCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIG1hcmtfcGljX2xvbmdfdGVybShTdG9yYWJsZVBpY3R1cmUqIHAsIGludCBsb25nX3Rlcm1fZnJhbWVfaWR4LCBpbnQgcGljTnVtWCkKewogIHVuc2lnbmVkIGk7CiAgaW50IGFkZF90b3AsIGFkZF9ib3R0b207CgogIGlmIChwLT5zdHJ1Y3R1cmUgPT0gRlJBTUUpCiAgewogICAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICB7CiAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc19yZWZlcmVuY2UgPT0gMykKICAgICAgewogICAgICAgIGlmICgoIWRwYi5mc19yZWZbaV0tPmZyYW1lLT5pc19sb25nX3Rlcm0pJiYoZHBiLmZzX3JlZltpXS0+ZnJhbWUtPnBpY19udW0gPT0gcGljTnVtWCkpCiAgICAgICAgewogICAgICAgICAgZHBiLmZzX3JlZltpXS0+bG9uZ190ZXJtX2ZyYW1lX2lkeCA9IGRwYi5mc19yZWZbaV0tPmZyYW1lLT5sb25nX3Rlcm1fZnJhbWVfaWR4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmZyYW1lLT5sb25nX3Rlcm1fcGljX251bSA9IGxvbmdfdGVybV9mcmFtZV9pZHg7CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5mcmFtZS0+aXNfbG9uZ190ZXJtID0gMTsKCiAgICAgICAgICBpZiAoZHBiLmZzX3JlZltpXS0+dG9wX2ZpZWxkICYmIGRwYi5mc19yZWZbaV0tPmJvdHRvbV9maWVsZCkKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+dG9wX2ZpZWxkLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gZHBiLmZzX3JlZltpXS0+Ym90dG9tX2ZpZWxkLT5sb25nX3Rlcm1fZnJhbWVfaWR4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA9IGxvbmdfdGVybV9mcmFtZV9pZHg7CiAgICAgICAgICAgIGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+bG9uZ190ZXJtX3BpY19udW0gPSBsb25nX3Rlcm1fZnJhbWVfaWR4OwogICAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPmxvbmdfdGVybV9waWNfbnVtID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKCiAgICAgICAgICAgIGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+aXNfbG9uZ190ZXJtID0gZHBiLmZzX3JlZltpXS0+Ym90dG9tX2ZpZWxkLT5pc19sb25nX3Rlcm0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPSAxOwoKICAgICAgICAgIH0KICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmlzX2xvbmdfdGVybSA9IDM7CiAgICAgICAgICByZXR1cm47CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgICBwcmludGYgKCJXYXJuaW5nOiByZWZlcmVuY2UgZnJhbWUgZm9yIGxvbmcgdGVybSBtYXJraW5nIG5vdCBmb3VuZFxuIik7CiAgfQogIGVsc2UKICB7CiAgICBpZiAocC0+c3RydWN0dXJlID09IFRPUF9GSUVMRCkKICAgIHsKICAgICAgYWRkX3RvcCAgICA9IDE7CiAgICAgIGFkZF9ib3R0b20gPSAwOwogICAgfQogICAgZWxzZQogICAgewogICAgICBhZGRfdG9wICAgID0gMDsKICAgICAgYWRkX2JvdHRvbSA9IDE7CiAgICB9CiAgICBmb3IgKGk9MDsgaTxkcGIucmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgIHsKICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSAmIDEpCiAgICAgIHsKICAgICAgICBpZiAoKCFkcGIuZnNfcmVmW2ldLT50b3BfZmllbGQtPmlzX2xvbmdfdGVybSkmJihkcGIuZnNfcmVmW2ldLT50b3BfZmllbGQtPnBpY19udW0gPT0gcGljTnVtWCkpCiAgICAgICAgewogICAgICAgICAgaWYgKChkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm0pICYmIChkcGIuZnNfcmVmW2ldLT5sb25nX3Rlcm1fZnJhbWVfaWR4ICE9IGxvbmdfdGVybV9mcmFtZV9pZHgpKQogICAgICAgICAgewogICAgICAgICAgICAgIHByaW50ZiAoIldhcm5pbmc6IGFzc2lnbmluZyBsb25nX3Rlcm1fZnJhbWVfaWR4IGRpZmZlcmVudCBmcm9tIG90aGVyIGZpZWxkXG4iKTsKICAgICAgICAgIH0KCiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gZHBiLmZzX3JlZltpXS0+dG9wX2ZpZWxkLT5sb25nX3Rlcm1fZnJhbWVfaWR4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+bG9uZ190ZXJtX3BpY19udW0gPSAyICogbG9uZ190ZXJtX2ZyYW1lX2lkeCArIGFkZF90b3A7CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT50b3BfZmllbGQtPmlzX2xvbmdfdGVybSA9IDE7CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm0gfD0gMTsKICAgICAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm0gPT0gMykKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWUtPmlzX2xvbmdfdGVybSA9IDE7CiAgICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmZyYW1lLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gZHBiLmZzX3JlZltpXS0+ZnJhbWUtPmxvbmdfdGVybV9waWNfbnVtID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKICAgICAgICAgIH0KICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgIH0KICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmlzX3JlZmVyZW5jZSAmIDIpCiAgICAgIHsKICAgICAgICBpZiAoKCFkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPmlzX2xvbmdfdGVybSkmJihkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPnBpY19udW0gPT0gcGljTnVtWCkpCiAgICAgICAgewogICAgICAgICAgaWYgKChkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm0pICYmIChkcGIuZnNfcmVmW2ldLT5sb25nX3Rlcm1fZnJhbWVfaWR4ICE9IGxvbmdfdGVybV9mcmFtZV9pZHgpKQogICAgICAgICAgewogICAgICAgICAgICAgIHByaW50ZiAoIldhcm5pbmc6IGFzc2lnbmluZyBsb25nX3Rlcm1fZnJhbWVfaWR4IGRpZmZlcmVudCBmcm9tIG90aGVyIGZpZWxkXG4iKTsKICAgICAgICAgIH0KCiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gZHBiLmZzX3JlZltpXS0+Ym90dG9tX2ZpZWxkLT5sb25nX3Rlcm1fZnJhbWVfaWR4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmJvdHRvbV9maWVsZC0+bG9uZ190ZXJtX3BpY19udW0gPSAyICogbG9uZ190ZXJtX2ZyYW1lX2lkeCArIGFkZF90b3A7CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPmlzX2xvbmdfdGVybSA9IDE7CiAgICAgICAgICBkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm0gfD0gMjsKICAgICAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc19sb25nX3Rlcm0gPT0gMykKICAgICAgICAgIHsKICAgICAgICAgICAgZHBiLmZzX3JlZltpXS0+ZnJhbWUtPmlzX2xvbmdfdGVybSA9IDE7CiAgICAgICAgICAgIGRwYi5mc19yZWZbaV0tPmZyYW1lLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gZHBiLmZzX3JlZltpXS0+ZnJhbWUtPmxvbmdfdGVybV9waWNfbnVtID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKICAgICAgICAgIH0KICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICAgIHByaW50ZiAoIldhcm5pbmc6IHJlZmVyZW5jZSBmaWVsZCBmb3IgbG9uZyB0ZXJtIG1hcmtpbmcgbm90IGZvdW5kXG4iKTsKICB9Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQXNzaWduIGEgbG9uZyB0ZXJtIGZyYW1lIGluZGV4IHRvIGEgc2hvcnQgdGVybSBwaWN0dXJlCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIG1tX2Fzc2lnbl9sb25nX3Rlcm1fZnJhbWVfaWR4KFN0b3JhYmxlUGljdHVyZSogcCwgaW50IGRpZmZlcmVuY2Vfb2ZfcGljX251bXNfbWludXMxLCBpbnQgbG9uZ190ZXJtX2ZyYW1lX2lkeCkKewogIGludCBwaWNOdW1YOwoKICBwaWNOdW1YID0gZ2V0X3BpY19udW1feChwLCBkaWZmZXJlbmNlX29mX3BpY19udW1zX21pbnVzMSk7CgogIC8vIHJlbW92ZSBmcmFtZXMvZmllbGRzIHdpdGggc2FtZSBsb25nX3Rlcm1fZnJhbWVfaWR4CiAgaWYgKHAtPnN0cnVjdHVyZSA9PSBGUkFNRSkKICB7CiAgICB1bm1hcmtfbG9uZ190ZXJtX2ZyYW1lX2Zvcl9yZWZlcmVuY2VfYnlfZnJhbWVfaWR4KGxvbmdfdGVybV9mcmFtZV9pZHgpOwogIH0KICBlbHNlCiAgewogICAgdW5zaWduZWQgaTsKICAgIFBpY3R1cmVTdHJ1Y3R1cmUgc3RydWN0dXJlID0gRlJBTUU7CgogICAgZm9yIChpPTA7IGk8ZHBiLnJlZl9mcmFtZXNfaW5fYnVmZmVyOyBpKyspCiAgICB7CiAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5pc19yZWZlcmVuY2UgJiAxKQogICAgICB7CiAgICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPnRvcF9maWVsZC0+cGljX251bSA9PSBwaWNOdW1YKQogICAgICAgIHsKICAgICAgICAgIHN0cnVjdHVyZSA9IFRPUF9GSUVMRDsKICAgICAgICAgIGJyZWFrOwogICAgICAgIH0KICAgICAgfQogICAgICBpZiAoZHBiLmZzX3JlZltpXS0+aXNfcmVmZXJlbmNlICYgMikKICAgICAgewogICAgICAgIGlmIChkcGIuZnNfcmVmW2ldLT5ib3R0b21fZmllbGQtPnBpY19udW0gPT0gcGljTnVtWCkKICAgICAgICB7CiAgICAgICAgICBzdHJ1Y3R1cmUgPSBCT1RUT01fRklFTEQ7CiAgICAgICAgICBicmVhazsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICAgIGlmIChzdHJ1Y3R1cmU9PUZSQU1FKQogICAgewogICAgICBlcnJvciAoImZpZWxkIGZvciBsb25nIHRlcm0gbWFya2luZyBub3QgZm91bmQiLDIwMCk7CiAgICB9CgogICAgdW5tYXJrX2xvbmdfdGVybV9maWVsZF9mb3JfcmVmZXJlbmNlX2J5X2ZyYW1lX2lkeChzdHJ1Y3R1cmUsIGxvbmdfdGVybV9mcmFtZV9pZHgsIDAsIDAsIHBpY051bVgpOwogIH0KCiAgbWFya19waWNfbG9uZ190ZXJtKHAsIGxvbmdfdGVybV9mcmFtZV9pZHgsIHBpY051bVgpOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgU2V0IG5ldyBtYXggbG9uZ190ZXJtX2ZyYW1lX2lkeAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIG1tX3VwZGF0ZV9tYXhfbG9uZ190ZXJtX2ZyYW1lX2lkeChpbnQgbWF4X2xvbmdfdGVybV9mcmFtZV9pZHhfcGx1czEpCnsKICB1bnNpZ25lZCBpOwoKICBkcGIubWF4X2xvbmdfdGVybV9waWNfaWR4ID0gbWF4X2xvbmdfdGVybV9mcmFtZV9pZHhfcGx1czEgLSAxOwoKICAvLyBjaGVjayBmb3IgaW52YWxpZCBmcmFtZXMKICBmb3IgKGk9MDsgaTxkcGIubHRyZWZfZnJhbWVzX2luX2J1ZmZlcjsgaSsrKQogIHsKICAgIGlmIChkcGIuZnNfbHRyZWZbaV0tPmxvbmdfdGVybV9mcmFtZV9pZHggPiBkcGIubWF4X2xvbmdfdGVybV9waWNfaWR4KQogICAgewogICAgICB1bm1hcmtfZm9yX2xvbmdfdGVybV9yZWZlcmVuY2UoZHBiLmZzX2x0cmVmW2ldKTsKICAgIH0KICB9Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgTWFyayBhbGwgbG9uZyB0ZXJtIHJlZmVyZW5jZSBwaWN0dXJlcyB1bnVzZWQgZm9yIHJlZmVyZW5jZQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCBtbV91bm1hcmtfYWxsX2xvbmdfdGVybV9mb3JfcmVmZXJlbmNlICh2b2lkKQp7CiAgbW1fdXBkYXRlX21heF9sb25nX3Rlcm1fZnJhbWVfaWR4KDApOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgTWFyayBhbGwgc2hvcnQgdGVybSByZWZlcmVuY2UgcGljdHVyZXMgdW51c2VkIGZvciByZWZlcmVuY2UKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgbW1fdW5tYXJrX2FsbF9zaG9ydF90ZXJtX2Zvcl9yZWZlcmVuY2UgKHZvaWQpCnsKICB1bnNpZ25lZCBpbnQgaTsKICBmb3IgKGk9MDsgaTxkcGIucmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICB7CiAgICB1bm1hcmtfZm9yX3JlZmVyZW5jZShkcGIuZnNfcmVmW2ldKTsKICB9CiAgdXBkYXRlX3JlZl9saXN0KCk7Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgTWFyayB0aGUgY3VycmVudCBwaWN0dXJlIHVzZWQgZm9yIGxvbmcgdGVybSByZWZlcmVuY2UKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIHZvaWQgbW1fbWFya19jdXJyZW50X3BpY3R1cmVfbG9uZ190ZXJtKFN0b3JhYmxlUGljdHVyZSAqcCwgaW50IGxvbmdfdGVybV9mcmFtZV9pZHgpCnsKICAvLyByZW1vdmUgbG9uZyB0ZXJtIHBpY3R1cmVzIHdpdGggc2FtZSBsb25nX3Rlcm1fZnJhbWVfaWR4CiAgaWYgKHAtPnN0cnVjdHVyZSA9PSBGUkFNRSkKICB7CiAgICB1bm1hcmtfbG9uZ190ZXJtX2ZyYW1lX2Zvcl9yZWZlcmVuY2VfYnlfZnJhbWVfaWR4KGxvbmdfdGVybV9mcmFtZV9pZHgpOwogIH0KICBlbHNlCiAgewogICAgdW5tYXJrX2xvbmdfdGVybV9maWVsZF9mb3JfcmVmZXJlbmNlX2J5X2ZyYW1lX2lkeChwLT5zdHJ1Y3R1cmUsIGxvbmdfdGVybV9mcmFtZV9pZHgsIDEsIHAtPnBpY19udW0sIDApOwogIH0KCiAgcC0+aXNfbG9uZ190ZXJtID0gMTsKICBwLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gbG9uZ190ZXJtX2ZyYW1lX2lkeDsKfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBQZXJmb3JtIEFkYXB0aXZlIG1lbW9yeSBjb250cm9sIGRlY29kZWQgcmVmZXJlbmNlIHBpY3R1cmUgbWFya2luZyBwcm9jZXNzCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIGFkYXB0aXZlX21lbW9yeV9tYW5hZ2VtZW50KFN0b3JhYmxlUGljdHVyZSogcCkKewogIERlY1JlZlBpY01hcmtpbmdfdCAqdG1wX2RycG07CgogIGltZy0+bGFzdF9oYXNfbW1jb181ID0gMDsKCiAgYXNzZXJ0ICghaW1nLT5jdXJyZW50UGljdHVyZS0+aWRyX2ZsYWcpOwogIGFzc2VydCAoaW1nLT5hZGFwdGl2ZV9yZWZfcGljX2J1ZmZlcmluZ19mbGFnKTsKCiAgd2hpbGUgKGltZy0+ZGVjX3JlZl9waWNfbWFya2luZ19idWZmZXIpCiAgewogICAgdG1wX2RycG0gPSBpbWctPmRlY19yZWZfcGljX21hcmtpbmdfYnVmZmVyOwogICAgc3dpdGNoICh0bXBfZHJwbS0+bWVtb3J5X21hbmFnZW1lbnRfY29udHJvbF9vcGVyYXRpb24pCiAgICB7CiAgICAgIGNhc2UgMDoKICAgICAgICBpZiAodG1wX2RycG0tPk5leHQgIT0gTlVMTCkKICAgICAgICB7CiAgICAgICAgICBlcnJvciAoIm1lbW9yeV9tYW5hZ2VtZW50X2NvbnRyb2xfb3BlcmF0aW9uID0gMCBub3QgbGFzdCBvcGVyYXRpb24gaW4gYnVmZmVyIiwgNTAwKTsKICAgICAgICB9CiAgICAgICAgYnJlYWs7CiAgICAgIGNhc2UgMToKICAgICAgICBtbV91bm1hcmtfc2hvcnRfdGVybV9mb3JfcmVmZXJlbmNlKHAsIHRtcF9kcnBtLT5kaWZmZXJlbmNlX29mX3BpY19udW1zX21pbnVzMSk7CiAgICAgICAgdXBkYXRlX3JlZl9saXN0KCk7CiAgICAgICAgYnJlYWs7CiAgICAgIGNhc2UgMjoKICAgICAgICBtbV91bm1hcmtfbG9uZ190ZXJtX2Zvcl9yZWZlcmVuY2UocCwgdG1wX2RycG0tPmxvbmdfdGVybV9waWNfbnVtKTsKICAgICAgICB1cGRhdGVfbHRyZWZfbGlzdCgpOwogICAgICAgIGJyZWFrOwogICAgICBjYXNlIDM6CiAgICAgICAgbW1fYXNzaWduX2xvbmdfdGVybV9mcmFtZV9pZHgocCwgdG1wX2RycG0tPmRpZmZlcmVuY2Vfb2ZfcGljX251bXNfbWludXMxLCB0bXBfZHJwbS0+bG9uZ190ZXJtX2ZyYW1lX2lkeCk7CiAgICAgICAgdXBkYXRlX3JlZl9saXN0KCk7CiAgICAgICAgdXBkYXRlX2x0cmVmX2xpc3QoKTsKICAgICAgICBicmVhazsKICAgICAgY2FzZSA0OgogICAgICAgIG1tX3VwZGF0ZV9tYXhfbG9uZ190ZXJtX2ZyYW1lX2lkeCAodG1wX2RycG0tPm1heF9sb25nX3Rlcm1fZnJhbWVfaWR4X3BsdXMxKTsKICAgICAgICB1cGRhdGVfbHRyZWZfbGlzdCgpOwogICAgICAgIGJyZWFrOwogICAgICBjYXNlIDU6CiAgICAgICAgbW1fdW5tYXJrX2FsbF9zaG9ydF90ZXJtX2Zvcl9yZWZlcmVuY2UoKTsKICAgICAgICBtbV91bm1hcmtfYWxsX2xvbmdfdGVybV9mb3JfcmVmZXJlbmNlKCk7CiAgICAgICBpbWctPmxhc3RfaGFzX21tY29fNSA9IDE7CiAgICAgICAgYnJlYWs7CiAgICAgIGNhc2UgNjoKICAgICAgICBtbV9tYXJrX2N1cnJlbnRfcGljdHVyZV9sb25nX3Rlcm0ocCwgdG1wX2RycG0tPmxvbmdfdGVybV9mcmFtZV9pZHgpOwogICAgICAgIGNoZWNrX251bV9yZWYoKTsKICAgICAgICBicmVhazsKICAgICAgZGVmYXVsdDoKICAgICAgICBlcnJvciAoImludmFsaWQgbWVtb3J5X21hbmFnZW1lbnRfY29udHJvbF9vcGVyYXRpb24gaW4gYnVmZmVyIiwgNTAwKTsKICAgIH0KICAgIGltZy0+ZGVjX3JlZl9waWNfbWFya2luZ19idWZmZXIgPSB0bXBfZHJwbS0+TmV4dDsKICAgIGZyZWUgKHRtcF9kcnBtKTsKICB9CiAgaWYgKCBpbWctPmxhc3RfaGFzX21tY29fNSApCiAgewogICAgcC0+cGljX251bSA9IHAtPmZyYW1lX251bSA9IDA7CgogICAgc3dpdGNoIChwLT5zdHJ1Y3R1cmUpCiAgICB7CiAgICBjYXNlIFRPUF9GSUVMRDoKICAgICAgewogICAgICAgIHAtPnBvYyA9IHAtPnRvcF9wb2MgPSBpbWctPnRvcHBvYyA9MDsKICAgICAgICBicmVhazsKICAgICAgfQogICAgY2FzZSBCT1RUT01fRklFTEQ6CiAgICAgIHsKICAgICAgICBwLT5wb2MgPSBwLT5ib3R0b21fcG9jID0gaW1nLT5ib3R0b21wb2MgPSAwOwogICAgICAgIGJyZWFrOwogICAgICB9CiAgICBjYXNlIEZSQU1FOgogICAgICB7CiAgICAgICAgcC0+dG9wX3BvYyAgICAtPSBwLT5wb2M7CiAgICAgICAgcC0+Ym90dG9tX3BvYyAtPSBwLT5wb2M7CgogICAgICAgIGltZy0+dG9wcG9jID0gcC0+dG9wX3BvYzsKICAgICAgICBpbWctPmJvdHRvbXBvYyA9IHAtPmJvdHRvbV9wb2M7CgogICAgICAgIHAtPnBvYyA9IGltaW4gKHAtPnRvcF9wb2MsIHAtPmJvdHRvbV9wb2MpOwogICAgICAgIGltZy0+ZnJhbWVwb2MgPSBwLT5wb2M7CiAgICAgICAgYnJlYWs7CiAgICAgIH0KICAgIH0KICAgIGltZy0+VGhpc1BPQyA9IHAtPnBvYzsKICAgIGZsdXNoX2RwYigpOwogIH0KfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBTdG9yZSBhIHBpY3R1cmUgaW4gRFBCLiBUaGlzIGluY2x1ZGVzIGNoZWtpbmcgZm9yIHNwYWNlIGluIERQQiBhbmQKICogICAgZmx1c2hpbmcgZnJhbWVzLgogKiAgICBJZiB3ZSByZWNlaXZlZCBhIGZyYW1lLCB3ZSBuZWVkIHRvIGNoZWNrIGZvciBhIG5ldyBzdG9yZSwgaWYgd2UKICogICAgZ290IGEgZmllbGQsIGNoZWNrIGlmIGl0J3MgdGhlIHNlY29uZCBmaWVsZCBvZiBhbiBhbHJlYWR5IGFsbG9jYXRlZAogKiAgICBzdG9yZS4KICoKICogXHBhcmFtIHAKICogICAgUGljdHVyZSB0byBiZSBzdG9yZWQKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBzdG9yZV9waWN0dXJlX2luX2RwYihTdG9yYWJsZVBpY3R1cmUqIHApCnsKICB1bnNpZ25lZCBpOwogIGludCBwb2MsIHBvczsKICAvLyBkaWFnbm9zdGljcwogIC8vcHJpbnRmICgiU3RvcmluZyAoJXMpIG5vbi1yZWYgcGljIHdpdGggZnJhbWVfbnVtICMlZFxuIiwgKHAtPnR5cGUgPT0gRlJBTUUpPyJGUkFNRSI6KHAtPnR5cGUgPT0gVE9QX0ZJRUxEKT8iVE9QX0ZJRUxEIjoiQk9UVE9NX0ZJRUxEIiwgcC0+cGljX251bSk7CiAgLy8gaWYgZnJhbWUsIGNoZWNrIGZvciBuZXcgc3RvcmUsCiAgYXNzZXJ0IChwIT1OVUxMKTsKCiAgcC0+dXNlZF9mb3JfcmVmZXJlbmNlID0gKGltZy0+bmFsX3JlZmVyZW5jZV9pZGMgIT0gMCk7CgogIGltZy0+bGFzdF9oYXNfbW1jb181PTA7CiAgaW1nLT5sYXN0X3BpY19ib3R0b21fZmllbGQgPSAoaW1nLT5zdHJ1Y3R1cmUgPT0gQk9UVE9NX0ZJRUxEKTsKCiAgaWYgKGltZy0+Y3VycmVudFBpY3R1cmUtPmlkcl9mbGFnKQogICAgaWRyX21lbW9yeV9tYW5hZ2VtZW50KHApOwogIGVsc2UKICB7CiAgICAvLyBhZGFwdGl2ZSBtZW1vcnkgbWFuYWdlbWVudAogICAgaWYgKHAtPnVzZWRfZm9yX3JlZmVyZW5jZSAmJiAoaW1nLT5hZGFwdGl2ZV9yZWZfcGljX2J1ZmZlcmluZ19mbGFnKSkKICAgICAgYWRhcHRpdmVfbWVtb3J5X21hbmFnZW1lbnQocCk7CiAgfQoKICBpZiAoKHAtPnN0cnVjdHVyZT09VE9QX0ZJRUxEKXx8KHAtPnN0cnVjdHVyZT09Qk9UVE9NX0ZJRUxEKSkKICB7CiAgICAvLyBjaGVjayBmb3IgZnJhbWUgc3RvcmUgd2l0aCBzYW1lIHBpY19udW1iZXIKICAgIGlmIChkcGIubGFzdF9waWN0dXJlKQogICAgewogICAgICBpZiAoKGludClkcGIubGFzdF9waWN0dXJlLT5mcmFtZV9udW0gPT0gcC0+cGljX251bSkKICAgICAgewogICAgICAgIGlmICgoKHAtPnN0cnVjdHVyZT09VE9QX0ZJRUxEKSYmKGRwYi5sYXN0X3BpY3R1cmUtPmlzX3VzZWQ9PTIpKXx8KChwLT5zdHJ1Y3R1cmU9PUJPVFRPTV9GSUVMRCkmJihkcGIubGFzdF9waWN0dXJlLT5pc191c2VkPT0xKSkpCiAgICAgICAgewogICAgICAgICAgaWYgKChwLT51c2VkX2Zvcl9yZWZlcmVuY2UgJiYgKGRwYi5sYXN0X3BpY3R1cmUtPmlzX29yaWdfcmVmZXJlbmNlIT0wKSl8fAogICAgICAgICAgICAgICghcC0+dXNlZF9mb3JfcmVmZXJlbmNlICYmIChkcGIubGFzdF9waWN0dXJlLT5pc19vcmlnX3JlZmVyZW5jZT09MCkpKQogICAgICAgICAgewogICAgICAgICAgICBpbnNlcnRfcGljdHVyZV9pbl9kcGIoZHBiLmxhc3RfcGljdHVyZSwgcCk7CiAgICAgICAgICAgIHVwZGF0ZV9yZWZfbGlzdCgpOwogICAgICAgICAgICB1cGRhdGVfbHRyZWZfbGlzdCgpOwogICAgICAgICAgICBkdW1wX2RwYigpOwogICAgICAgICAgICBkcGIubGFzdF9waWN0dXJlID0gTlVMTDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KCiAgLy8gdGhpcyBpcyBhIGZyYW1lIG9yIGEgZmllbGQgd2hpY2ggaGFzIG5vIHN0b3JlZCBjb21wbGVtZW50YXJ5IGZpZWxkCgogIC8vIHNsaWRpbmcgd2luZG93LCBpZiBuZWNlc3NhcnkKICBpZiAoKCFpbWctPmN1cnJlbnRQaWN0dXJlLT5pZHJfZmxhZykmJihwLT51c2VkX2Zvcl9yZWZlcmVuY2UgJiYgKCFpbWctPmFkYXB0aXZlX3JlZl9waWNfYnVmZmVyaW5nX2ZsYWcpKSkKICB7CiAgICBzbGlkaW5nX3dpbmRvd19tZW1vcnlfbWFuYWdlbWVudChwKTsKICB9CgogIC8vIGZpcnN0IHRyeSB0byByZW1vdmUgdW51c2VkIGZyYW1lcwogIGlmIChkcGIudXNlZF9zaXplPT1kcGIuc2l6ZSkKICB7CiAgICByZW1vdmVfdW51c2VkX2ZyYW1lX2Zyb21fZHBiKCk7CiAgfQoKICAvLyB0aGVuIG91dHB1dCBmcmFtZXMgdW50aWwgb25lIGNhbiBiZSByZW1vdmVkCiAgd2hpbGUgKGRwYi51c2VkX3NpemU9PWRwYi5zaXplKQogIHsKICAgIC8vIG5vbi1yZWZlcmVuY2UgZnJhbWVzIG1heSBiZSBvdXRwdXQgZGlyZWN0bHkKICAgIGlmICghcC0+dXNlZF9mb3JfcmVmZXJlbmNlKQogICAgewogICAgICBnZXRfc21hbGxlc3RfcG9jKCZwb2MsICZwb3MpOwogICAgICBpZiAoKC0xPT1wb3MpIHx8IChwLT5wb2MgPCBwb2MpKQogICAgICB7CiAgICAgICAgZGlyZWN0X291dHB1dChwLCBwX2RlYyk7CiAgICAgICAgcmV0dXJuOwogICAgICB9CiAgICB9CiAgICAvLyBmbHVzaCBhIGZyYW1lCiAgICBvdXRwdXRfb25lX2ZyYW1lX2Zyb21fZHBiKCk7CiAgfQoKICAvLyBjaGVjayBmb3IgZHVwbGljYXRlIGZyYW1lIG51bWJlciBpbiBzaG9ydCB0ZXJtIHJlZmVyZW5jZSBidWZmZXIKICBpZiAoKHAtPnVzZWRfZm9yX3JlZmVyZW5jZSkmJighcC0+aXNfbG9uZ190ZXJtKSkKICB7CiAgICBmb3IgKGk9MDsgaTxkcGIucmVmX2ZyYW1lc19pbl9idWZmZXI7IGkrKykKICAgIHsKICAgICAgaWYgKGRwYi5mc19yZWZbaV0tPmZyYW1lX251bSA9PSBwLT5mcmFtZV9udW0pCiAgICAgIHsKICAgICAgICBlcnJvcigiZHVwbGljYXRlIGZyYW1lX251bSBpbSBzaG9ydC10ZXJtIHJlZmVyZW5jZSBwaWN0dXJlIGJ1ZmZlciIsIDUwMCk7CiAgICAgIH0KICAgIH0KCiAgfQogIC8vIHN0b3JlIGF0IGVuZCBvZiBidWZmZXIKLy8gIHByaW50ZiAoInN0b3JlIGZyYW1lL2ZpZWxkIGF0IHBvcyAlZFxuIixkcGIudXNlZF9zaXplKTsKICBpbnNlcnRfcGljdHVyZV9pbl9kcGIoZHBiLmZzW2RwYi51c2VkX3NpemVdLHApOwoKICBpZiAocC0+c3RydWN0dXJlICE9IEZSQU1FKQogIHsKICAgIGRwYi5sYXN0X3BpY3R1cmUgPSBkcGIuZnNbZHBiLnVzZWRfc2l6ZV07CiAgfQogIGVsc2UKICB7CiAgICBkcGIubGFzdF9waWN0dXJlID0gTlVMTDsKICB9CgogIGRwYi51c2VkX3NpemUrKzsKCiAgdXBkYXRlX3JlZl9saXN0KCk7CiAgdXBkYXRlX2x0cmVmX2xpc3QoKTsKCiAgY2hlY2tfbnVtX3JlZigpOwoKICBkdW1wX2RwYigpOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEluc2VydCB0aGUgZnJhbWUgcGljdHVyZSBpbnRvIHRoZSBpZiB0aGUgdG9wIGZpZWxkIGhhcyBhbHJlYWR5CiAqICAgIGJlZW4gc3RvcmVkIGZvciB0aGUgY29kaW5nIGRlY2lzaW9uCiAqCiAqIFxwYXJhbSBwCiAqICAgIFN0b3JhYmxlUGljdHVyZSB0byBiZSBpbnNlcnRlZAogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIHJlcGxhY2VfdG9wX3BpY193aXRoX2ZyYW1lKFN0b3JhYmxlUGljdHVyZSogcCkKewogIEZyYW1lU3RvcmUqIGZzID0gTlVMTDsKICB1bnNpZ25lZCBpLCBmb3VuZDsKCiAgYXNzZXJ0IChwIT1OVUxMKTsKICBhc3NlcnQgKHAtPnN0cnVjdHVyZT09RlJBTUUpOwoKICBwLT51c2VkX2Zvcl9yZWZlcmVuY2UgPSAoaW1nLT5uYWxfcmVmZXJlbmNlX2lkYyAhPSAwKTsKICAvLyB1cHNhbXBsZSBhIHJlZmVyZW5jZSBwaWN0dXJlCiAgaWYgKHAtPnVzZWRfZm9yX3JlZmVyZW5jZSkKICB7CiAgICBVbmlmaWVkT25lRm9ydGhQaXgocCk7CiAgfQoKICBmb3VuZD0wOwoKICBmb3IgKGk9MDtpPGRwYi51c2VkX3NpemU7aSsrKQogIHsKICAgIGlmKChkcGIuZnNbaV0tPmZyYW1lX251bSA9PSBpbWctPmZyYW1lX251bSkmJihkcGIuZnNbaV0tPmlzX3VzZWQ9PTEpKQogICAgewogICAgICBmb3VuZD0xOwogICAgICBmcyA9IGRwYi5mc1tpXTsKICAgICAgYnJlYWs7CiAgICB9CiAgfQoKICBpZiAoIWZvdW5kKQogIHsKICAgIC8vIHRoaXMgc2hvdWxkIG9ubHkgaGFwcGVuIGZvciBub24tcmVmZXJlbmNlIHBpY3R1cmVzIHdoZW4gdGhlIGRwYiBpcyBmdWxsIG9mIHJlZmVyZW5jZSBwaWNzCiAgICBkaXJlY3Rfb3V0cHV0X3BhZmYocCwgcF9kZWMpOwogIH0KICBlbHNlCiAgewogICAgZnJlZV9zdG9yYWJsZV9waWN0dXJlKGZzLT50b3BfZmllbGQpOwogICAgZnMtPnRvcF9maWVsZD1OVUxMOwogICAgZnMtPmZyYW1lPXA7CiAgICBmcy0+aXNfdXNlZCA9IDM7CiAgICBpZiAocC0+dXNlZF9mb3JfcmVmZXJlbmNlKQogICAgewogICAgICBmcy0+aXNfcmVmZXJlbmNlID0gMzsKICAgICAgaWYgKHAtPmlzX2xvbmdfdGVybSkKICAgICAgewogICAgICAgIGZzLT5pc19sb25nX3Rlcm0gPSAzOwogICAgICB9CiAgICB9CiAgICAvLyBnZW5lcmF0ZSBmaWVsZCB2aWV3cwogICAgZHBiX3NwbGl0X2ZpZWxkKGZzKTsKICAgIHVwZGF0ZV9yZWZfbGlzdCgpOwogICAgdXBkYXRlX2x0cmVmX2xpc3QoKTsKICB9Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgSW5zZXJ0IHRoZSBwaWN0dXJlIGludG8gdGhlIERQQi4gQSBmcmVlIERQQiBwb3NpdGlvbiBpcyBuZWNlc3NhcnkKICogICAgZm9yIGZyYW1lcywgLgogKgogKiBccGFyYW0gZnMKICogICAgRnJhbWVTdG9yZSBpbnRvIHdoaWNoIHRoZSBwaWN0dXJlIHdpbGwgYmUgaW5zZXJ0ZWQKICogXHBhcmFtIHAKICogICAgU3RvcmFibGVQaWN0dXJlIHRvIGJlIGluc2VydGVkCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnN0YXRpYyB2b2lkIGluc2VydF9waWN0dXJlX2luX2RwYihGcmFtZVN0b3JlKiBmcywgU3RvcmFibGVQaWN0dXJlKiBwKQp7CiAgLy8gIHByaW50ZiAoImluc2VydCAoJXMpIHBpYyB3aXRoIGZyYW1lX251bSAjJWQsIHBvYyAlZFxuIiwgKHAtPnN0cnVjdHVyZSA9PSBGUkFNRSk/IkZSQU1FIjoocC0+c3RydWN0dXJlID09IFRPUF9GSUVMRCk/IlRPUF9GSUVMRCI6IkJPVFRPTV9GSUVMRCIsIHAtPnBpY19udW0sIHAtPnBvYyk7CiAgYXNzZXJ0IChwIT1OVUxMKTsKICBhc3NlcnQgKGZzIT1OVUxMKTsKCiAgLy8gdXBzYW1wbGUgYSByZWZlcmVuY2UgcGljdHVyZQogIGlmIChwLT51c2VkX2Zvcl9yZWZlcmVuY2UpCiAgewogICAgVW5pZmllZE9uZUZvcnRoUGl4KHApOwogIH0KCiAgc3dpdGNoIChwLT5zdHJ1Y3R1cmUpCiAgewogIGNhc2UgRlJBTUU6CiAgICBmcy0+ZnJhbWUgPSBwOwogICAgZnMtPmlzX3VzZWQgPSAzOwogICAgaWYgKHAtPnVzZWRfZm9yX3JlZmVyZW5jZSkKICAgIHsKICAgICAgZnMtPmlzX3JlZmVyZW5jZSA9IDM7CiAgICAgIGZzLT5pc19vcmlnX3JlZmVyZW5jZSA9IDM7CiAgICAgIGlmIChwLT5pc19sb25nX3Rlcm0pCiAgICAgIHsKICAgICAgICBmcy0+aXNfbG9uZ190ZXJtID0gMzsKICAgICAgICBmcy0+bG9uZ190ZXJtX2ZyYW1lX2lkeCA9IHAtPmxvbmdfdGVybV9mcmFtZV9pZHg7CiAgICAgIH0KICAgIH0KICAgIC8vIGdlbmVyYXRlIGZpZWxkIHZpZXdzCiAgICBkcGJfc3BsaXRfZmllbGQoZnMpOwogICAgYnJlYWs7CiAgY2FzZSBUT1BfRklFTEQ6CiAgICBmcy0+dG9wX2ZpZWxkID0gcDsKICAgIGZzLT5pc191c2VkIHw9IDE7CiAgICBpZiAocC0+dXNlZF9mb3JfcmVmZXJlbmNlKQogICAgewogICAgICBmcy0+aXNfcmVmZXJlbmNlIHw9IDE7CiAgICAgIGZzLT5pc19vcmlnX3JlZmVyZW5jZSB8PSAxOwogICAgICBpZiAocC0+aXNfbG9uZ190ZXJtKQogICAgICB7CiAgICAgICAgZnMtPmlzX2xvbmdfdGVybSB8PSAxOwogICAgICAgIGZzLT5sb25nX3Rlcm1fZnJhbWVfaWR4ID0gcC0+bG9uZ190ZXJtX2ZyYW1lX2lkeDsKICAgICAgfQogICAgfQogICAgaWYgKGZzLT5pc191c2VkID09IDMpCiAgICB7CiAgICAgIC8vIGdlbmVyYXRlIGZyYW1lIHZpZXcKICAgICAgZHBiX2NvbWJpbmVfZmllbGQoZnMpOwogICAgfQogICAgZWxzZQogICAgewogICAgICBmcy0+cG9jID0gcC0+cG9jOwogICAgICBnZW5fZmllbGRfcmVmX2lkcyhwKTsKICAgIH0KICAgIGJyZWFrOwogIGNhc2UgQk9UVE9NX0ZJRUxEOgogICAgZnMtPmJvdHRvbV9maWVsZCA9IHA7CiAgICBmcy0+aXNfdXNlZCB8PSAyOwogICAgaWYgKHAtPnVzZWRfZm9yX3JlZmVyZW5jZSkKICAgIHsKICAgICAgZnMtPmlzX3JlZmVyZW5jZSB8PSAyOwogICAgICBmcy0+aXNfb3JpZ19yZWZlcmVuY2UgfD0gMjsKICAgICAgaWYgKHAtPmlzX2xvbmdfdGVybSkKICAgICAgewogICAgICAgIGZzLT5pc19sb25nX3Rlcm0gfD0gMjsKICAgICAgICBmcy0+bG9uZ190ZXJtX2ZyYW1lX2lkeCA9IHAtPmxvbmdfdGVybV9mcmFtZV9pZHg7CiAgICAgIH0KICAgIH0KICAgIGlmIChmcy0+aXNfdXNlZCA9PSAzKQogICAgewogICAgICAvLyBnZW5lcmF0ZSBmcmFtZSB2aWV3CiAgICAgIGRwYl9jb21iaW5lX2ZpZWxkKGZzKTsKICAgIH0gZWxzZQogICAgewogICAgICBmcy0+cG9jID0gcC0+cG9jOwogICAgICBnZW5fZmllbGRfcmVmX2lkcyhwKTsKICAgIH0KICAgIGJyZWFrOwogIH0KICBmcy0+ZnJhbWVfbnVtID0gcC0+cGljX251bTsKICBmcy0+aXNfb3V0cHV0ID0gcC0+aXNfb3V0cHV0OwoKfQoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIENoZWNrIGlmIG9uZSBvZiB0aGUgZnJhbWVzL2ZpZWxkcyBpbiBmcmFtZSBzdG9yZSBpcyB1c2VkIGZvciByZWZlcmVuY2UKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIGludCBpc191c2VkX2Zvcl9yZWZlcmVuY2UoRnJhbWVTdG9yZSogZnMpCnsKICBpZiAoZnMtPmlzX3JlZmVyZW5jZSkKICB7CiAgICByZXR1cm4gMTsKICB9CgogIGlmIChmcy0+aXNfdXNlZCA9PSAzKSAvLyBmcmFtZQogIHsKICAgIGlmIChmcy0+ZnJhbWUtPnVzZWRfZm9yX3JlZmVyZW5jZSkKICAgIHsKICAgICAgcmV0dXJuIDE7CiAgICB9CiAgfQoKICBpZiAoZnMtPmlzX3VzZWQgJiAxKSAvLyB0b3AgZmllbGQKICB7CiAgICBpZiAoZnMtPnRvcF9maWVsZCkKICAgIHsKICAgICAgaWYgKGZzLT50b3BfZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZSkKICAgICAgewogICAgICAgIHJldHVybiAxOwogICAgICB9CiAgICB9CiAgfQoKICBpZiAoZnMtPmlzX3VzZWQgJiAyKSAvLyBib3R0b20gZmllbGQKICB7CiAgICBpZiAoZnMtPmJvdHRvbV9maWVsZCkKICAgIHsKICAgICAgaWYgKGZzLT5ib3R0b21fZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZSkKICAgICAgewogICAgICAgIHJldHVybiAxOwogICAgICB9CiAgICB9CiAgfQogIHJldHVybiAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIENoZWNrIGlmIG9uZSBvZiB0aGUgZnJhbWVzL2ZpZWxkcyBpbiBmcmFtZSBzdG9yZSBpcyB1c2VkIGZvciBzaG9ydC10ZXJtIHJlZmVyZW5jZQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgaW50IGlzX3Nob3J0X3Rlcm1fcmVmZXJlbmNlKEZyYW1lU3RvcmUqIGZzKQp7CgogIGlmIChmcy0+aXNfdXNlZD09MykgLy8gZnJhbWUKICB7CiAgICBpZiAoKGZzLT5mcmFtZS0+dXNlZF9mb3JfcmVmZXJlbmNlKSYmKCFmcy0+ZnJhbWUtPmlzX2xvbmdfdGVybSkpCiAgICB7CiAgICAgIHJldHVybiAxOwogICAgfQogIH0KCiAgaWYgKGZzLT5pc191c2VkICYgMSkgLy8gdG9wIGZpZWxkCiAgewogICAgaWYgKGZzLT50b3BfZmllbGQpCiAgICB7CiAgICAgIGlmICgoZnMtPnRvcF9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlKSYmKCFmcy0+dG9wX2ZpZWxkLT5pc19sb25nX3Rlcm0pKQogICAgICB7CiAgICAgICAgcmV0dXJuIDE7CiAgICAgIH0KICAgIH0KICB9CgogIGlmIChmcy0+aXNfdXNlZCAmIDIpIC8vIGJvdHRvbSBmaWVsZAogIHsKICAgIGlmIChmcy0+Ym90dG9tX2ZpZWxkKQogICAgewogICAgICBpZiAoKGZzLT5ib3R0b21fZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZSkmJighZnMtPmJvdHRvbV9maWVsZC0+aXNfbG9uZ190ZXJtKSkKICAgICAgewogICAgICAgIHJldHVybiAxOwogICAgICB9CiAgICB9CiAgfQogIHJldHVybiAwOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIENoZWNrIGlmIG9uZSBvZiB0aGUgZnJhbWVzL2ZpZWxkcyBpbiBmcmFtZSBzdG9yZSBpcyB1c2VkIGZvciBzaG9ydC10ZXJtIHJlZmVyZW5jZQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgaW50IGlzX2xvbmdfdGVybV9yZWZlcmVuY2UoRnJhbWVTdG9yZSogZnMpCnsKCiAgaWYgKGZzLT5pc191c2VkPT0zKSAvLyBmcmFtZQogIHsKICAgIGlmICgoZnMtPmZyYW1lLT51c2VkX2Zvcl9yZWZlcmVuY2UpJiYoZnMtPmZyYW1lLT5pc19sb25nX3Rlcm0pKQogICAgewogICAgICByZXR1cm4gMTsKICAgIH0KICB9CgogIGlmIChmcy0+aXNfdXNlZCAmIDEpIC8vIHRvcCBmaWVsZAogIHsKICAgIGlmIChmcy0+dG9wX2ZpZWxkKQogICAgewogICAgICBpZiAoKGZzLT50b3BfZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZSkmJihmcy0+dG9wX2ZpZWxkLT5pc19sb25nX3Rlcm0pKQogICAgICB7CiAgICAgICAgcmV0dXJuIDE7CiAgICAgIH0KICAgIH0KICB9CgogIGlmIChmcy0+aXNfdXNlZCAmIDIpIC8vIGJvdHRvbSBmaWVsZAogIHsKICAgIGlmIChmcy0+Ym90dG9tX2ZpZWxkKQogICAgewogICAgICBpZiAoKGZzLT5ib3R0b21fZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZSkmJihmcy0+Ym90dG9tX2ZpZWxkLT5pc19sb25nX3Rlcm0pKQogICAgICB7CiAgICAgICAgcmV0dXJuIDE7CiAgICAgIH0KICAgIH0KICB9CiAgcmV0dXJuIDA7Cn0KCgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgcmVtb3ZlIG9uZSBmcmFtZSBmcm9tIERQQgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCByZW1vdmVfZnJhbWVfZnJvbV9kcGIoaW50IHBvcykKewogIEZyYW1lU3RvcmUqIGZzID0gZHBiLmZzW3Bvc107CiAgRnJhbWVTdG9yZSogdG1wOwogIHVuc2lnbmVkIGk7CgovLyAgcHJpbnRmICgicmVtb3ZlIGZyYW1lIHdpdGggZnJhbWVfbnVtICMlZFxuIiwgZnMtPmZyYW1lX251bSk7CiAgc3dpdGNoIChmcy0+aXNfdXNlZCkKICB7CiAgY2FzZSAzOgogICAgZnJlZV9zdG9yYWJsZV9waWN0dXJlKGZzLT5mcmFtZSk7CiAgICBmcmVlX3N0b3JhYmxlX3BpY3R1cmUoZnMtPnRvcF9maWVsZCk7CiAgICBmcmVlX3N0b3JhYmxlX3BpY3R1cmUoZnMtPmJvdHRvbV9maWVsZCk7CiAgICBmcy0+ZnJhbWU9TlVMTDsKICAgIGZzLT50b3BfZmllbGQ9TlVMTDsKICAgIGZzLT5ib3R0b21fZmllbGQ9TlVMTDsKICAgIGJyZWFrOwogIGNhc2UgMjoKICAgIGZyZWVfc3RvcmFibGVfcGljdHVyZShmcy0+Ym90dG9tX2ZpZWxkKTsKICAgIGZzLT5ib3R0b21fZmllbGQ9TlVMTDsKICAgIGJyZWFrOwogIGNhc2UgMToKICAgIGZyZWVfc3RvcmFibGVfcGljdHVyZShmcy0+dG9wX2ZpZWxkKTsKICAgIGZzLT50b3BfZmllbGQ9TlVMTDsKICAgIGJyZWFrOwogIGNhc2UgMDoKICAgIGJyZWFrOwogIGRlZmF1bHQ6CiAgICBlcnJvcigiaW52YWxpZCBmcmFtZSBzdG9yZSB0eXBlIiw1MDApOwogIH0KICBmcy0+aXNfdXNlZCA9IDA7CiAgZnMtPmlzX2xvbmdfdGVybSA9IDA7CiAgZnMtPmlzX3JlZmVyZW5jZSA9IDA7CiAgZnMtPmlzX29yaWdfcmVmZXJlbmNlID0gMDsKCiAgLy8gbW92ZSBlbXB0eSBmcmFtZXN0b3JlIHRvIGVuZCBvZiBidWZmZXIKICB0bXAgPSBkcGIuZnNbcG9zXTsKCiAgZm9yIChpPXBvczsgaTxkcGIudXNlZF9zaXplLTE7aSsrKQogIHsKICAgIGRwYi5mc1tpXSA9IGRwYi5mc1tpKzFdOwogIH0KICBkcGIuZnNbZHBiLnVzZWRfc2l6ZS0xXSA9IHRtcDsKICBkcGIudXNlZF9zaXplLS07Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBmaW5kIHNtYWxsZXN0IFBPQyBpbiB0aGUgRFBCLgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCBnZXRfc21hbGxlc3RfcG9jKGludCAqcG9jLGludCAqIHBvcykKewogIHVuc2lnbmVkIGk7CgogIGlmIChkcGIudXNlZF9zaXplPDEpCiAgewogICAgZXJyb3IoIkNhbm5vdCBkZXRlcm1pbmUgc21hbGxlc3QgUE9DLCBEUEIgZW1wdHkuIiwxNTApOwogIH0KCiAgKnBvcz0tMTsKICAqcG9jID0gSU5UX01BWDsKICBmb3IgKGk9MDsgaTxkcGIudXNlZF9zaXplOyBpKyspCiAgewogICAgaWYgKCgqcG9jPmRwYi5mc1tpXS0+cG9jKSYmKCFkcGIuZnNbaV0tPmlzX291dHB1dCkpCiAgICB7CiAgICAgICpwb2MgPSBkcGIuZnNbaV0tPnBvYzsKICAgICAgKnBvcz1pOwogICAgfQogIH0KfQoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIFJlbW92ZSBhIHBpY3R1cmUgZnJvbSBEUEIgd2hpY2ggaXMgbm8gbG9uZ2VyIG5lZWRlZC4KICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kc3RhdGljIGludCByZW1vdmVfdW51c2VkX2ZyYW1lX2Zyb21fZHBiKHZvaWQpCnsKICB1bnNpZ25lZCBpOwoKICAvLyBjaGVjayBmb3IgZnJhbWVzIHRoYXQgd2VyZSBhbHJlYWR5IG91dHB1dCBhbmQgbm8gbG9uZ2VyIHVzZWQgZm9yIHJlZmVyZW5jZQogIGZvciAoaT0wOyBpPGRwYi51c2VkX3NpemU7IGkrKykKICB7CiAgICBpZiAoZHBiLmZzW2ldLT5pc19vdXRwdXQgJiYgKCFpc191c2VkX2Zvcl9yZWZlcmVuY2UoZHBiLmZzW2ldKSkpCiAgICB7CiAgICAgIHJlbW92ZV9mcmFtZV9mcm9tX2RwYihpKTsKICAgICAgcmV0dXJuIDE7CiAgICB9CiAgfQogIHJldHVybiAwOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgT3V0cHV0IG9uZSBwaWN0dXJlIHN0b3JlZCBpbiB0aGUgRFBCLgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwpzdGF0aWMgdm9pZCBvdXRwdXRfb25lX2ZyYW1lX2Zyb21fZHBiKHZvaWQpCnsKICBpbnQgcG9jLCBwb3M7CiAgLy9kaWFnbm9zdGljcwogIGlmIChkcGIudXNlZF9zaXplPDEpCiAgewogICAgZXJyb3IoIkNhbm5vdCBvdXRwdXQgZnJhbWUsIERQQiBlbXB0eS4iLDE1MCk7CiAgfQoKICAvLyBmaW5kIHNtYWxsZXN0IFBPQwogIGdldF9zbWFsbGVzdF9wb2MoJnBvYywgJnBvcyk7CgogIGlmKHBvcz09LTEpCiAgewogICAgZXJyb3IoIm5vIGZyYW1lcyBmb3Igb3V0cHV0IGF2YWlsYWJsZSIsIDE1MCk7CiAgfQoKICAvLyBjYWxsIHRoZSBvdXRwdXQgZnVuY3Rpb24KLy8gIHByaW50ZiAoIm91dHB1dCBmcmFtZSB3aXRoIGZyYW1lX251bSAjJWQsIHBvYyAlZCAoZHBiLiBkcGIuc2l6ZT0lZCwgZHBiLnVzZWRfc2l6ZT0lZClcbiIsIGRwYi5mc1twb3NdLT5mcmFtZV9udW0sIGRwYi5mc1twb3NdLT5mcmFtZS0+cG9jLCBkcGIuc2l6ZSwgZHBiLnVzZWRfc2l6ZSk7CgogIHdyaXRlX3N0b3JlZF9mcmFtZShkcGIuZnNbcG9zXSwgcF9kZWMpOwoKICAvLyBpZiByZWR1bmRhbnQgcGljdHVyZSBpbiB1c2UsIG91dHB1dCBQT0MgbWF5IGJlIG5vdCBpbiBhc2NlbmRpbmcgb3JkZXIKICBpZihpbnB1dC0+cmVkdW5kYW50X3BpY19mbGFnID09IDApCiAgewogICAgaWYgKGRwYi5sYXN0X291dHB1dF9wb2MgPj0gcG9jKQogICAgewogICAgICBlcnJvciAoIm91dHB1dCBQT0MgbXVzdCBiZSBpbiBhc2NlbmRpbmcgb3JkZXIiLCAxNTApOwogICAgfQogIH0KICBkcGIubGFzdF9vdXRwdXRfcG9jID0gcG9jOwoKICAvLyBmcmVlIGZyYW1lIHN0b3JlIGFuZCBtb3ZlIGVtcHR5IHN0b3JlIHRvIGVuZCBvZiBidWZmZXIKICBpZiAoIWlzX3VzZWRfZm9yX3JlZmVyZW5jZShkcGIuZnNbcG9zXSkpCiAgewogICAgcmVtb3ZlX2ZyYW1lX2Zyb21fZHBiKHBvcyk7CiAgfQp9CgoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBBbGwgc3RvcmVkIHBpY3R1cmUgYXJlIG91dHB1dC4gU2hvdWxkIGJlIGNhbGxlZCB0byBlbXB0eSB0aGUgYnVmZmVyCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnZvaWQgZmx1c2hfZHBiKHZvaWQpCnsKICB1bnNpZ25lZCBpOwoKICAvL2RpYWdub3N0aWNzCi8vICBwcmludGYoIkZsdXNoIHJlbWFpbmluZyBmcmFtZXMgZnJvbSBkcGIuIGRwYi5zaXplPSVkLCBkcGIudXNlZF9zaXplPSVkXG4iLGRwYi5zaXplLGRwYi51c2VkX3NpemUpOwoKICAvLyBtYXJrIGFsbCBmcmFtZXMgdW51c2VkCiAgZm9yIChpPTA7IGk8ZHBiLnVzZWRfc2l6ZTsgaSsrKQogIHsKICAgIHVubWFya19mb3JfcmVmZXJlbmNlIChkcGIuZnNbaV0pOwogIH0KCiAgd2hpbGUgKHJlbW92ZV91bnVzZWRfZnJhbWVfZnJvbV9kcGIoKSkgOwoKICAvLyBvdXRwdXQgZnJhbWVzIGluIFBPQyBvcmRlcgogIHdoaWxlIChkcGIudXNlZF9zaXplKQogIHsKICAgIG91dHB1dF9vbmVfZnJhbWVfZnJvbV9kcGIoKTsKICB9CgogIGRwYi5sYXN0X291dHB1dF9wb2MgPSBJTlRfTUlOOwp9CgoKdm9pZCBnZW5fZmllbGRfcmVmX2lkcyhTdG9yYWJsZVBpY3R1cmUgKnApCnsKICBpbnQgaSxqLCBkdW1teWxpc3QwLCBkdW1teWxpc3QxOwogICAvLyEgR2VuZXJhdGUgRnJhbWUgcGFyYW1ldGVycyBmcm9tIGZpZWxkIGluZm9ybWF0aW9uLgogIGZvciAoaT0wIDsgaTxwLT5zaXplX3gvNCA7IGkrKykKICB7CiAgICBmb3IgKGo9MCA7IGo8cC0+c2l6ZV95LzQgOyBqKyspCiAgICB7CiAgICAgICAgZHVtbXlsaXN0MD0gcC0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldOwogICAgICAgIGR1bW15bGlzdDE9IHAtPnJlZl9pZHhbTElTVF8xXVtqXVtpXTsKICAgICAgICAvLyEgYXNzb2NpYXRpb24gd2l0aCBpZCBhbHJlYWR5IGtub3duIGZvciBmaWVsZHMuCiAgICAgICAgcC0+cmVmX2lkW0xJU1RfMF1bal1baV0gPSAoZHVtbXlsaXN0MD49MCk/IHAtPnJlZl9waWNfbnVtW0xJU1RfMF1bZHVtbXlsaXN0MF0gOiAwOwogICAgICAgIHAtPnJlZl9pZFtMSVNUXzFdW2pdW2ldID0gKGR1bW15bGlzdDE+PTApPyBwLT5yZWZfcGljX251bVtMSVNUXzFdW2R1bW15bGlzdDFdIDogMDsKICAgICAgICBwLT5maWVsZF9mcmFtZVtqXVtpXT0xOwogICAgfQogIH0KfQoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEV4dHJhY3QgdG9wIGZpZWxkIGZyb20gYSBmcmFtZQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIGRwYl9zcGxpdF9maWVsZChGcmFtZVN0b3JlICpmcykKewogIGludCBpLCBqLCBpaSwgamosIGpqNDsKICBpbnQgaWRpdixqZGl2OwogIGludCBjdXJyZW50bWI7CiAgaW50IGR1bW15bGlzdDAsZHVtbXlsaXN0MTsKICBpbnQgdHdvc3oxNiA9IDIqKGZzLT5mcmFtZS0+c2l6ZV94Pj40KTsKCiAgZnMtPnBvYyA9IGZzLT5mcmFtZS0+cG9jOwoKICBpZiAoIWFjdGl2ZV9zcHMtPmZyYW1lX21ic19vbmx5X2ZsYWcpCiAgewogICAgZnMtPnRvcF9maWVsZCAgICA9IGFsbG9jX3N0b3JhYmxlX3BpY3R1cmUoVE9QX0ZJRUxELCAgICBmcy0+ZnJhbWUtPnNpemVfeCwgZnMtPmZyYW1lLT5zaXplX3kvMiwgZnMtPmZyYW1lLT5zaXplX3hfY3IsIGZzLT5mcmFtZS0+c2l6ZV95X2NyLzIpOwogICAgZnMtPmJvdHRvbV9maWVsZCA9IGFsbG9jX3N0b3JhYmxlX3BpY3R1cmUoQk9UVE9NX0ZJRUxELCBmcy0+ZnJhbWUtPnNpemVfeCwgZnMtPmZyYW1lLT5zaXplX3kvMiwgZnMtPmZyYW1lLT5zaXplX3hfY3IsIGZzLT5mcmFtZS0+c2l6ZV95X2NyLzIpOwoKICAgIGZvciAoaT0wOyBpPGZzLT5mcmFtZS0+c2l6ZV95LzI7IGkrKykKICAgIHsKICAgICAgbWVtY3B5KGZzLT50b3BfZmllbGQtPmltZ1lbaV0sIGZzLT5mcmFtZS0+aW1nWVtpKjJdLCBmcy0+ZnJhbWUtPnNpemVfeCpzaXplb2YoaW1ncGVsKSk7CiAgICB9CgogICAgZm9yIChpPTA7IGk8ZnMtPmZyYW1lLT5zaXplX3lfY3IvMjsgaSsrKQogICAgewogICAgICBtZW1jcHkoZnMtPnRvcF9maWVsZC0+aW1nVVZbMF1baV0sIGZzLT5mcmFtZS0+aW1nVVZbMF1baSoyXSwgZnMtPmZyYW1lLT5zaXplX3hfY3Iqc2l6ZW9mKGltZ3BlbCkpOwogICAgICBtZW1jcHkoZnMtPnRvcF9maWVsZC0+aW1nVVZbMV1baV0sIGZzLT5mcmFtZS0+aW1nVVZbMV1baSoyXSwgZnMtPmZyYW1lLT5zaXplX3hfY3Iqc2l6ZW9mKGltZ3BlbCkpOwogICAgfQoKICAgIGZvciAoaT0wOyBpPGZzLT5mcmFtZS0+c2l6ZV95LzI7IGkrKykKICAgIHsKICAgICAgbWVtY3B5KGZzLT5ib3R0b21fZmllbGQtPmltZ1lbaV0sIGZzLT5mcmFtZS0+aW1nWVtpKjIgKyAxXSwgZnMtPmZyYW1lLT5zaXplX3gqc2l6ZW9mKGltZ3BlbCkpOwogICAgfQoKICAgIGZvciAoaT0wOyBpPGZzLT5mcmFtZS0+c2l6ZV95X2NyLzI7IGkrKykKICAgIHsKICAgICAgbWVtY3B5KGZzLT5ib3R0b21fZmllbGQtPmltZ1VWWzBdW2ldLCBmcy0+ZnJhbWUtPmltZ1VWWzBdW2kqMiArIDFdLCBmcy0+ZnJhbWUtPnNpemVfeF9jcipzaXplb2YoaW1ncGVsKSk7CiAgICAgIG1lbWNweShmcy0+Ym90dG9tX2ZpZWxkLT5pbWdVVlsxXVtpXSwgZnMtPmZyYW1lLT5pbWdVVlsxXVtpKjIgKyAxXSwgZnMtPmZyYW1lLT5zaXplX3hfY3Iqc2l6ZW9mKGltZ3BlbCkpOwogICAgfQoKICAgIFVuaWZpZWRPbmVGb3J0aFBpeChmcy0+dG9wX2ZpZWxkKTsKICAgIFVuaWZpZWRPbmVGb3J0aFBpeChmcy0+Ym90dG9tX2ZpZWxkKTsKCiAgICBmcy0+dG9wX2ZpZWxkLT5wb2MgPSBmcy0+ZnJhbWUtPnRvcF9wb2M7CiAgICBmcy0+Ym90dG9tX2ZpZWxkLT5wb2MgPSAgZnMtPmZyYW1lLT5ib3R0b21fcG9jOwoKICAgIGZzLT50b3BfZmllbGQtPmZyYW1lX3BvYyA9ICBmcy0+ZnJhbWUtPmZyYW1lX3BvYzsKCiAgICBmcy0+dG9wX2ZpZWxkLT5ib3R0b21fcG9jID1mcy0+Ym90dG9tX2ZpZWxkLT5ib3R0b21fcG9jID0gIGZzLT5mcmFtZS0+Ym90dG9tX3BvYzsKICAgIGZzLT50b3BfZmllbGQtPnRvcF9wb2MgPWZzLT5ib3R0b21fZmllbGQtPnRvcF9wb2MgPSAgZnMtPmZyYW1lLT50b3BfcG9jOwogICAgZnMtPmJvdHRvbV9maWVsZC0+ZnJhbWVfcG9jID0gIGZzLT5mcmFtZS0+ZnJhbWVfcG9jOwoKICAgIGZzLT50b3BfZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZSA9IGZzLT5ib3R0b21fZmllbGQtPnVzZWRfZm9yX3JlZmVyZW5jZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gZnMtPmZyYW1lLT51c2VkX2Zvcl9yZWZlcmVuY2U7CiAgICBmcy0+dG9wX2ZpZWxkLT5pc19sb25nX3Rlcm0gPSBmcy0+Ym90dG9tX2ZpZWxkLT5pc19sb25nX3Rlcm0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA9IGZzLT5mcmFtZS0+aXNfbG9uZ190ZXJtOwogICAgZnMtPmxvbmdfdGVybV9mcmFtZV9pZHggPSBmcy0+dG9wX2ZpZWxkLT5sb25nX3Rlcm1fZnJhbWVfaWR4CiAgICAgICAgICAgICAgICAgICAgICAgICAgICA9IGZzLT5ib3R0b21fZmllbGQtPmxvbmdfdGVybV9mcmFtZV9pZHgKICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gZnMtPmZyYW1lLT5sb25nX3Rlcm1fZnJhbWVfaWR4OwoKICAgIGZzLT50b3BfZmllbGQtPmNvZGVkX2ZyYW1lID0gZnMtPmJvdHRvbV9maWVsZC0+Y29kZWRfZnJhbWUgPSAxOwogICAgZnMtPnRvcF9maWVsZC0+TWJhZmZGcmFtZUZsYWcgPSBmcy0+Ym90dG9tX2ZpZWxkLT5NYmFmZkZyYW1lRmxhZwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPSBmcy0+ZnJhbWUtPk1iYWZmRnJhbWVGbGFnOwoKICAgIGZzLT5mcmFtZS0+dG9wX2ZpZWxkICAgID0gZnMtPnRvcF9maWVsZDsKICAgIGZzLT5mcmFtZS0+Ym90dG9tX2ZpZWxkID0gZnMtPmJvdHRvbV9maWVsZDsKCiAgICBmcy0+dG9wX2ZpZWxkLT5ib3R0b21fZmllbGQgPSBmcy0+Ym90dG9tX2ZpZWxkOwogICAgZnMtPnRvcF9maWVsZC0+ZnJhbWUgICAgICAgID0gZnMtPmZyYW1lOwogICAgZnMtPmJvdHRvbV9maWVsZC0+dG9wX2ZpZWxkID0gZnMtPnRvcF9maWVsZDsKICAgIGZzLT5ib3R0b21fZmllbGQtPmZyYW1lICAgICA9IGZzLT5mcmFtZTsKCiAgICBmcy0+dG9wX2ZpZWxkLT5jaHJvbWFfZm9ybWF0X2lkYyA9IGZzLT5ib3R0b21fZmllbGQtPmNocm9tYV9mb3JtYXRfaWRjID0gZnMtPmZyYW1lLT5jaHJvbWFfZm9ybWF0X2lkYzsKCiAgICAvL3N0b3JlIHJlZmVyZW5jZSBwaWN0dXJlIGluZGV4CiAgICBtZW1jcHkoZnMtPnRvcF9maWVsZC0+cmVmX3BpY19udW1bTElTVF8xXSAgICwgZnMtPmZyYW1lLT5yZWZfcGljX251bVsyICsgTElTVF8xXSwgMipsaXN0WHNpemVbTElTVF8xXSAqIHNpemVvZihpbnQ2NCkpOwogICAgbWVtY3B5KGZzLT5ib3R0b21fZmllbGQtPnJlZl9waWNfbnVtW0xJU1RfMV0sIGZzLT5mcmFtZS0+cmVmX3BpY19udW1bNCArIExJU1RfMV0sIDIqbGlzdFhzaXplW0xJU1RfMV0gKiBzaXplb2YoaW50NjQpKTsKICAgIG1lbWNweShmcy0+dG9wX2ZpZWxkLT5yZWZfcGljX251bVtMSVNUXzBdICAgLCBmcy0+ZnJhbWUtPnJlZl9waWNfbnVtWzIgKyBMSVNUXzBdLCAyKmxpc3RYc2l6ZVtMSVNUXzBdICogc2l6ZW9mKGludDY0KSk7CiAgICBtZW1jcHkoZnMtPmJvdHRvbV9maWVsZC0+cmVmX3BpY19udW1bTElTVF8wXSwgZnMtPmZyYW1lLT5yZWZfcGljX251bVs0ICsgTElTVF8wXSwgMipsaXN0WHNpemVbTElTVF8wXSAqIHNpemVvZihpbnQ2NCkpOwoKICB9CiAgZWxzZQogIHsKICAgIGZzLT50b3BfZmllbGQ9TlVMTDsKICAgIGZzLT5ib3R0b21fZmllbGQ9TlVMTDsKICAgIGZzLT5mcmFtZS0+dG9wX2ZpZWxkPU5VTEw7CiAgICBmcy0+ZnJhbWUtPmJvdHRvbV9maWVsZD1OVUxMOwogIH0KCiAgZm9yIChqPTAgOyBqPGZzLT5mcmFtZS0+c2l6ZV95LzQgOyBqKyspCiAgewogICAgamRpdj1qLzQ7CiAgICBmb3IgKGk9MCA7IGk8ZnMtPmZyYW1lLT5zaXplX3gvNCA7IGkrKykKICAgIHsKICAgICAgaWRpdj1pLzQ7CiAgICAgIGN1cnJlbnRtYiA9IHR3b3N6MTYqKGpkaXYvMikrIChpZGl2KSoyICsgKGpkaXYlMik7CgogICAgICBpZiAoZnMtPmZyYW1lLT5NYmFmZkZyYW1lRmxhZyAgJiYgZnMtPmZyYW1lLT5tYl9maWVsZFtjdXJyZW50bWJdKQogICAgICB7CiAgICAgICAgaW50IGxpc3Rfb2Zmc2V0ID0gY3VycmVudG1iJTI/IDQ6IDI7CiAgICAgICAgZHVtbXlsaXN0MCA9IGZzLT5mcmFtZS0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldOwogICAgICAgIGR1bW15bGlzdDEgPSBmcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8xXVtqXVtpXTsKICAgICAgICAvLyEgYXNzb2NpYXRpb24gd2l0aCBpZCBhbHJlYWR5IGtub3duIGZvciBmaWVsZHMuCiAgICAgICAgZnMtPmZyYW1lLT5yZWZfaWRbTElTVF8wICsgbGlzdF9vZmZzZXRdW2pdW2ldID0gKGR1bW15bGlzdDA+PTApPyBmcy0+ZnJhbWUtPnJlZl9waWNfbnVtW0xJU1RfMCArIGxpc3Rfb2Zmc2V0XVtkdW1teWxpc3QwXSA6IDA7CiAgICAgICAgZnMtPmZyYW1lLT5yZWZfaWRbTElTVF8xICsgbGlzdF9vZmZzZXRdW2pdW2ldID0gKGR1bW15bGlzdDE+PTApPyBmcy0+ZnJhbWUtPnJlZl9waWNfbnVtW0xJU1RfMSArIGxpc3Rfb2Zmc2V0XVtkdW1teWxpc3QxXSA6IDA7CiAgICAgICAgLy8hIG5lZWQgdG8gbWFrZSBhc3NvY2lhdGlvbiB3aXRoIGZyYW1lcwogICAgICAgIGZzLT5mcmFtZS0+cmVmX2lkW0xJU1RfMF1bal1baV0gPSAoZHVtbXlsaXN0MD49MCk/IGZzLT5mcmFtZS0+ZnJtX3JlZl9waWNfbnVtW0xJU1RfMCArIGxpc3Rfb2Zmc2V0XVtkdW1teWxpc3QwXSA6IDA7CiAgICAgICAgZnMtPmZyYW1lLT5yZWZfaWRbTElTVF8xXVtqXVtpXSA9IChkdW1teWxpc3QxPj0wKT8gZnMtPmZyYW1lLT5mcm1fcmVmX3BpY19udW1bTElTVF8xICsgbGlzdF9vZmZzZXRdW2R1bW15bGlzdDFdIDogMDsKCiAgICAgIH0KICAgICAgZWxzZQogICAgICB7CiAgICAgICAgZHVtbXlsaXN0MCA9IGZzLT5mcmFtZS0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldOwogICAgICAgIGR1bW15bGlzdDEgPSBmcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8xXVtqXVtpXTsKICAgICAgICBmcy0+ZnJhbWUtPnJlZl9pZFtMSVNUXzBdW2pdW2ldID0gKGR1bW15bGlzdDA+PTApPyBmcy0+ZnJhbWUtPnJlZl9waWNfbnVtW0xJU1RfMF1bZHVtbXlsaXN0MF0gOiAtMTsKICAgICAgICBmcy0+ZnJhbWUtPnJlZl9pZFtMSVNUXzFdW2pdW2ldID0gKGR1bW15bGlzdDE+PTApPyBmcy0+ZnJhbWUtPnJlZl9waWNfbnVtW0xJU1RfMV1bZHVtbXlsaXN0MV0gOiAtMTsKICAgICAgfQogICAgfQogIH0KCiAgaWYgKCFhY3RpdmVfc3BzLT5mcmFtZV9tYnNfb25seV9mbGFnICYmIGZzLT5mcmFtZS0+TWJhZmZGcmFtZUZsYWcpCiAgewogICAgZm9yIChqPTAgOyBqPGZzLT5mcmFtZS0+c2l6ZV95Lzg7IGorKykKICAgIHsKICAgICAgamogPSAoai80KSo4ICsgaiU0OwogICAgICBqajQgPSBqaiArIDQ7CiAgICAgIGpkaXY9ai8yOwogICAgICBmb3IgKGk9MCA7IGk8ZnMtPmZyYW1lLT5zaXplX3gvNCA7IGkrKykKICAgICAgewogICAgICAgIGlkaXY9aS80OwoKICAgICAgICBjdXJyZW50bWIgPSB0d29zejE2KihqZGl2LzIpKyAoaWRpdikqMiArIChqZGl2JTIpOwogICAgICAgIC8vIEFzc2lnbiBmaWVsZCBtdnMgYXR0YWNoZWQgdG8gTUItRnJhbWUgYnVmZmVyIHRvIHRoZSBwcm9wZXIgYnVmZmVyCiAgICAgICAgaWYgKGZzLT5mcmFtZS0+bWJfZmllbGRbY3VycmVudG1iXSkKICAgICAgICB7CiAgICAgICAgICBmcy0+Ym90dG9tX2ZpZWxkLT5maWVsZF9mcmFtZVtqXVtpXSA9IGZzLT50b3BfZmllbGQtPmZpZWxkX2ZyYW1lW2pdW2ldPTE7CiAgICAgICAgICBmcy0+ZnJhbWUtPmZpZWxkX2ZyYW1lWzIqal1baV0gPSBmcy0+ZnJhbWUtPmZpZWxkX2ZyYW1lWzIqaisxXVtpXT0xOwoKICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMF1bal1baV1bMF0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMF1bamo0XVtpXVswXTsKICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMF1bal1baV1bMV0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMF1bamo0XVtpXVsxXTsKICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMV1bal1baV1bMF0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMV1bamo0XVtpXVswXTsKICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMV1bal1baV1bMV0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMV1bamo0XVtpXVsxXTsKICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZHhbTElTVF8wXVtqXVtpXSA9IGZzLT5mcmFtZS0+cmVmX2lkeFtMSVNUXzBdW2pqNF1baV07CiAgICAgICAgICBmcy0+Ym90dG9tX2ZpZWxkLT5yZWZfaWR4W0xJU1RfMV1bal1baV0gPSBmcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8xXVtqajRdW2ldOwogICAgICAgICAgZnMtPmJvdHRvbV9maWVsZC0+cmVmX2lkW0xJU1RfMF1bal1baV0gPSBmcy0+ZnJhbWUtPnJlZl9pZFtMSVNUXzArNF1bamo0XVtpXTsKICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZFtMSVNUXzFdW2pdW2ldID0gZnMtPmZyYW1lLT5yZWZfaWRbTElTVF8xKzRdW2pqNF1baV07CgoKICAgICAgICAgIGZzLT50b3BfZmllbGQtPm12W0xJU1RfMF1bal1baV1bMF0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMF1bampdW2ldWzBdOwogICAgICAgICAgZnMtPnRvcF9maWVsZC0+bXZbTElTVF8wXVtqXVtpXVsxXSA9IGZzLT5mcmFtZS0+bXZbTElTVF8wXVtqal1baV1bMV07CiAgICAgICAgICBmcy0+dG9wX2ZpZWxkLT5tdltMSVNUXzFdW2pdW2ldWzBdID0gZnMtPmZyYW1lLT5tdltMSVNUXzFdW2pqXVtpXVswXTsKICAgICAgICAgIGZzLT50b3BfZmllbGQtPm12W0xJU1RfMV1bal1baV1bMV0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMV1bampdW2ldWzFdOwogICAgICAgICAgZnMtPnRvcF9maWVsZC0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldID0gZnMtPmZyYW1lLT5yZWZfaWR4W0xJU1RfMF1bampdW2ldOwogICAgICAgICAgZnMtPnRvcF9maWVsZC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldID0gZnMtPmZyYW1lLT5yZWZfaWR4W0xJU1RfMV1bampdW2ldOwogICAgICAgICAgZnMtPnRvcF9maWVsZC0+cmVmX2lkW0xJU1RfMF1bal1baV0gPSBmcy0+ZnJhbWUtPnJlZl9pZFtMSVNUXzArMl1bampdW2ldOwogICAgICAgICAgZnMtPnRvcF9maWVsZC0+cmVmX2lkW0xJU1RfMV1bal1baV0gPSBmcy0+ZnJhbWUtPnJlZl9pZFtMSVNUXzErMl1bampdW2ldOwogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KCiAgLy8hIEdlbmVyYXRlIGZpZWxkIE1WcyBmcm9tIEZyYW1lIE1WcwogIGlmICghYWN0aXZlX3Nwcy0+ZnJhbWVfbWJzX29ubHlfZmxhZykKICB7CiAgICBmb3IgKGo9MCA7IGo8ZnMtPmZyYW1lLT5zaXplX3kvOCA7IGorKykKICAgIHsKICAgICAgamogPSAyKiBSU0Qoaik7CiAgICAgIGpkaXYgPSBqLzI7CiAgICAgIGZvciAoaT0wIDsgaTxmcy0+ZnJhbWUtPnNpemVfeC80IDsgaSsrKQogICAgICB7CiAgICAgICAgaWkgPSBSU0QoaSk7CiAgICAgICAgaWRpdiA9IGkvNDsKCiAgICAgICAgY3VycmVudG1iID0gdHdvc3oxNiooamRpdi8yKSsgKGlkaXYpKjIgKyAoamRpdiUyKTsKCiAgICAgICAgaWYgKCFmcy0+ZnJhbWUtPk1iYWZmRnJhbWVGbGFnICB8fCAhZnMtPmZyYW1lLT5tYl9maWVsZFtjdXJyZW50bWJdKQogICAgICAgIHsKICAgICAgICAgIGZzLT5mcmFtZS0+ZmllbGRfZnJhbWVbMipqKzFdW2ldID0gZnMtPmZyYW1lLT5maWVsZF9mcmFtZVsyKmpdW2ldPTA7CgogICAgICAgICAgZnMtPnRvcF9maWVsZC0+ZmllbGRfZnJhbWVbal1baV0gPSBmcy0+Ym90dG9tX2ZpZWxkLT5maWVsZF9mcmFtZVtqXVtpXSA9IDA7CgogICAgICAgICAgZnMtPnRvcF9maWVsZC0+bXZbTElTVF8wXVtqXVtpXVswXSA9IGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMF1bal1baV1bMF0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMF1bampdW2lpXVswXTsKICAgICAgICAgIGZzLT50b3BfZmllbGQtPm12W0xJU1RfMF1bal1baV1bMV0gPSBmcy0+Ym90dG9tX2ZpZWxkLT5tdltMSVNUXzBdW2pdW2ldWzFdID0gZnMtPmZyYW1lLT5tdltMSVNUXzBdW2pqXVtpaV1bMV07CiAgICAgICAgICBmcy0+dG9wX2ZpZWxkLT5tdltMSVNUXzFdW2pdW2ldWzBdID0gZnMtPmJvdHRvbV9maWVsZC0+bXZbTElTVF8xXVtqXVtpXVswXSA9IGZzLT5mcmFtZS0+bXZbTElTVF8xXVtqal1baWldWzBdOwogICAgICAgICAgZnMtPnRvcF9maWVsZC0+bXZbTElTVF8xXVtqXVtpXVsxXSA9IGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMV1bal1baV1bMV0gPSBmcy0+ZnJhbWUtPm12W0xJU1RfMV1bampdW2lpXVsxXTsKCiAgICAgICAgICAvLyBTY2FsaW5nIG9mIHJlZmVyZW5jZXMgaXMgZG9uZSBoZXJlIHNpbmNlIGl0IHdpbGwgbm90IGFmZmVjdCBzcGF0aWFsIGRpcmVjdCAoMiowID0wKQogICAgICAgICAgaWYgKGZzLT5mcmFtZS0+cmVmX2lkeFtMSVNUXzBdW2pqXVtpaV0gPT0gLTEpCiAgICAgICAgICAgIGZzLT50b3BfZmllbGQtPnJlZl9pZHhbTElTVF8wXVtqXVtpXSA9IGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZHhbTElTVF8wXVtqXVtpXSA9IC0gMTsKICAgICAgICAgIGVsc2UKICAgICAgICAgIHsKICAgICAgICAgICAgZHVtbXlsaXN0MD1mcy0+dG9wX2ZpZWxkLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gPSBmcy0+Ym90dG9tX2ZpZWxkLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gPSBmcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8wXVtqal1baWldOwogICAgICAgICAgICBmcy0+dG9wX2ZpZWxkICAgLT5yZWZfaWRbTElTVF8wXVtqXVtpXSA9IChkdW1teWxpc3QwPj0wKT8gZnMtPmZyYW1lLT50b3BfcmVmX3BpY19udW1bTElTVF8wXVtkdW1teWxpc3QwXSA6IDA7CiAgICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZFtMSVNUXzBdW2pdW2ldID0gKGR1bW15bGlzdDA+PTApPyBmcy0+ZnJhbWUtPmJvdHRvbV9yZWZfcGljX251bVtMSVNUXzBdW2R1bW15bGlzdDBdIDogMDsKICAgICAgICAgIH0KCiAgICAgICAgICBpZiAoZnMtPmZyYW1lLT5yZWZfaWR4W0xJU1RfMV1bampdW2lpXSA9PSAtMSkKICAgICAgICAgICAgZnMtPnRvcF9maWVsZC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldID0gZnMtPmJvdHRvbV9maWVsZC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldID0gLSAxOwogICAgICAgICAgZWxzZQogICAgICAgICAgewogICAgICAgICAgICBkdW1teWxpc3QxPWZzLT50b3BfZmllbGQtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSA9IGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSA9IGZzLT5mcmFtZS0+cmVmX2lkeFtMSVNUXzFdW2pqXVtpaV07CgogICAgICAgICAgICBmcy0+dG9wX2ZpZWxkICAgLT5yZWZfaWRbTElTVF8xXVtqXVtpXSA9IChkdW1teWxpc3QxPj0wKT8gZnMtPmZyYW1lLT50b3BfcmVmX3BpY19udW1bTElTVF8xXVtkdW1teWxpc3QxXSA6IDA7CiAgICAgICAgICAgIGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZFtMSVNUXzFdW2pdW2ldID0gKGR1bW15bGlzdDE+PTApPyBmcy0+ZnJhbWUtPmJvdHRvbV9yZWZfcGljX251bVtMSVNUXzFdW2R1bW15bGlzdDFdIDogMDsKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgIGZzLT5mcmFtZS0+ZmllbGRfZnJhbWVbMipqKzFdW2ldID0gZnMtPmZyYW1lLT5maWVsZF9mcmFtZVsyKmpdW2ldPSBmcy0+ZnJhbWUtPm1iX2ZpZWxkW2N1cnJlbnRtYl07CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQogIGVsc2UKICB7CiAgICBtZW1zZXQoICYoZnMtPmZyYW1lLT5maWVsZF9mcmFtZVswXVswXSksIDAsIGZzLT5mcmFtZS0+c2l6ZV95ICogKGZzLT5mcmFtZS0+c2l6ZV94ID4+NCkgKiBzaXplb2YoYnl0ZSkpOwogIH0KfQoKCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBHZW5lcmF0ZSBhIGZyYW1lIGZyb20gdG9wIGFuZCBib3R0b20gZmllbGRzLAogKiAgICBZVVYgY29tcG9uZW50cyBhbmQgZGlzcGxheSBpbmZvcm1hdGlvbiBvbmx5CiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnZvaWQgZHBiX2NvbWJpbmVfZmllbGRfeXV2KEZyYW1lU3RvcmUgKmZzKQp7CiAgaW50IGk7CgogIGZzLT5mcmFtZSA9IGFsbG9jX3N0b3JhYmxlX3BpY3R1cmUoRlJBTUUsIGZzLT50b3BfZmllbGQtPnNpemVfeCwgZnMtPnRvcF9maWVsZC0+c2l6ZV95KjIsIGZzLT50b3BfZmllbGQtPnNpemVfeF9jciwgZnMtPnRvcF9maWVsZC0+c2l6ZV95X2NyKjIpOwoKICBmb3IgKGk9MDsgaTxmcy0+dG9wX2ZpZWxkLT5zaXplX3k7IGkrKykKICB7CiAgICBtZW1jcHkoZnMtPmZyYW1lLT5pbWdZW2kqMl0sICAgICBmcy0+dG9wX2ZpZWxkLT5pbWdZW2ldICAgLCBmcy0+dG9wX2ZpZWxkLT5zaXplX3gqc2l6ZW9mKGltZ3BlbCkpOyAgICAgLy8gdG9wIGZpZWxkCiAgICBtZW1jcHkoZnMtPmZyYW1lLT5pbWdZW2kqMiArIDFdLCBmcy0+Ym90dG9tX2ZpZWxkLT5pbWdZW2ldLCBmcy0+Ym90dG9tX2ZpZWxkLT5zaXplX3gqc2l6ZW9mKGltZ3BlbCkpOyAvLyBib3R0b20gZmllbGQKICB9CgogIGZvciAoaT0wOyBpPGZzLT50b3BfZmllbGQtPnNpemVfeV9jcjsgaSsrKQogIHsKICAgIG1lbWNweShmcy0+ZnJhbWUtPmltZ1VWWzBdW2kqMl0sICAgICBmcy0+dG9wX2ZpZWxkLT5pbWdVVlswXVtpXSwgICAgZnMtPnRvcF9maWVsZC0+c2l6ZV94X2NyKnNpemVvZihpbWdwZWwpKTsKICAgIG1lbWNweShmcy0+ZnJhbWUtPmltZ1VWWzBdW2kqMiArIDFdLCBmcy0+Ym90dG9tX2ZpZWxkLT5pbWdVVlswXVtpXSwgZnMtPmJvdHRvbV9maWVsZC0+c2l6ZV94X2NyKnNpemVvZihpbWdwZWwpKTsKICAgIG1lbWNweShmcy0+ZnJhbWUtPmltZ1VWWzFdW2kqMl0sICAgICBmcy0+dG9wX2ZpZWxkLT5pbWdVVlsxXVtpXSwgICAgZnMtPnRvcF9maWVsZC0+c2l6ZV94X2NyKnNpemVvZihpbWdwZWwpKTsKICAgIG1lbWNweShmcy0+ZnJhbWUtPmltZ1VWWzFdW2kqMiArIDFdLCBmcy0+Ym90dG9tX2ZpZWxkLT5pbWdVVlsxXVtpXSwgZnMtPmJvdHRvbV9maWVsZC0+c2l6ZV94X2NyKnNpemVvZihpbWdwZWwpKTsKICB9CgogIGZzLT5wb2M9ZnMtPmZyYW1lLT5wb2MgPWZzLT5mcmFtZS0+ZnJhbWVfcG9jID0gaW1pbiAoZnMtPnRvcF9maWVsZC0+cG9jLCBmcy0+Ym90dG9tX2ZpZWxkLT5wb2MpOwoKICBmcy0+Ym90dG9tX2ZpZWxkLT5mcmFtZV9wb2M9ZnMtPnRvcF9maWVsZC0+ZnJhbWVfcG9jPWZzLT5mcmFtZS0+cG9jOwoKICBmcy0+Ym90dG9tX2ZpZWxkLT50b3BfcG9jPWZzLT5mcmFtZS0+dG9wX3BvYz1mcy0+dG9wX2ZpZWxkLT5wb2M7CiAgZnMtPnRvcF9maWVsZC0+Ym90dG9tX3BvYz1mcy0+ZnJhbWUtPmJvdHRvbV9wb2M9ZnMtPmJvdHRvbV9maWVsZC0+cG9jOwoKICBmcy0+ZnJhbWUtPnVzZWRfZm9yX3JlZmVyZW5jZSA9IChmcy0+dG9wX2ZpZWxkLT51c2VkX2Zvcl9yZWZlcmVuY2UgJiYgZnMtPmJvdHRvbV9maWVsZC0+dXNlZF9mb3JfcmVmZXJlbmNlICk7CiAgZnMtPmZyYW1lLT5pc19sb25nX3Rlcm0gPSAoZnMtPnRvcF9maWVsZC0+aXNfbG9uZ190ZXJtICYmIGZzLT5ib3R0b21fZmllbGQtPmlzX2xvbmdfdGVybSApOwoKICBpZiAoZnMtPmZyYW1lLT5pc19sb25nX3Rlcm0pCiAgICBmcy0+ZnJhbWUtPmxvbmdfdGVybV9mcmFtZV9pZHggPSBmcy0+bG9uZ190ZXJtX2ZyYW1lX2lkeDsKCiAgZnMtPmZyYW1lLT50b3BfZmllbGQgICAgPSBmcy0+dG9wX2ZpZWxkOwogIGZzLT5mcmFtZS0+Ym90dG9tX2ZpZWxkID0gZnMtPmJvdHRvbV9maWVsZDsKCiAgZnMtPmZyYW1lLT5jb2RlZF9mcmFtZSA9IDA7CgogIGZzLT5mcmFtZS0+Y2hyb21hX2Zvcm1hdF9pZGMgPSBmcy0+dG9wX2ZpZWxkLT5jaHJvbWFfZm9ybWF0X2lkYzsKICBmcy0+ZnJhbWUtPmZyYW1lX2Nyb3BwaW5nX2ZsYWcgPSBmcy0+dG9wX2ZpZWxkLT5mcmFtZV9jcm9wcGluZ19mbGFnOwogIGlmIChmcy0+ZnJhbWUtPmZyYW1lX2Nyb3BwaW5nX2ZsYWcpCiAgewogICAgZnMtPmZyYW1lLT5mcmFtZV9jcm9wcGluZ19yZWN0X3RvcF9vZmZzZXQgPSBmcy0+dG9wX2ZpZWxkLT5mcmFtZV9jcm9wcGluZ19yZWN0X3RvcF9vZmZzZXQ7CiAgICBmcy0+ZnJhbWUtPmZyYW1lX2Nyb3BwaW5nX3JlY3RfYm90dG9tX29mZnNldCA9IGZzLT50b3BfZmllbGQtPmZyYW1lX2Nyb3BwaW5nX3JlY3RfYm90dG9tX29mZnNldDsKICAgIGZzLT5mcmFtZS0+ZnJhbWVfY3JvcHBpbmdfcmVjdF9sZWZ0X29mZnNldCA9IGZzLT50b3BfZmllbGQtPmZyYW1lX2Nyb3BwaW5nX3JlY3RfbGVmdF9vZmZzZXQ7CiAgICBmcy0+ZnJhbWUtPmZyYW1lX2Nyb3BwaW5nX3JlY3RfcmlnaHRfb2Zmc2V0ID0gZnMtPnRvcF9maWVsZC0+ZnJhbWVfY3JvcHBpbmdfcmVjdF9yaWdodF9vZmZzZXQ7CiAgfQoKICBmcy0+dG9wX2ZpZWxkLT5mcmFtZSA9IGZzLT5ib3R0b21fZmllbGQtPmZyYW1lID0gZnMtPmZyYW1lOwp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEdlbmVyYXRlIGEgZnJhbWUgZnJvbSB0b3AgYW5kIGJvdHRvbSBmaWVsZHMKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBkcGJfY29tYmluZV9maWVsZChGcmFtZVN0b3JlICpmcykKewogIGludCBpLGosIGpqLCBqajQ7CiAgaW50IGR1bW15bGlzdDAsIGR1bW15bGlzdDE7CgogIGRwYl9jb21iaW5lX2ZpZWxkX3l1dihmcyk7CgogIFVuaWZpZWRPbmVGb3J0aFBpeChmcy0+ZnJhbWUpOwoKICAvL2NvbWJpbmUgZmllbGQgZm9yIGZyYW1lCiAgZm9yIChpPTA7aTwobGlzdFhzaXplW0xJU1RfMV0rMSkvMjtpKyspCiAgewogICAgZnMtPmZyYW1lLT5yZWZfcGljX251bVtMSVNUXzFdW2ldPSBpNjRtaW4gKChmcy0+dG9wX2ZpZWxkLT5yZWZfcGljX251bVtMSVNUXzFdWzIqaV0vMikqMiwgKGZzLT5ib3R0b21fZmllbGQtPnJlZl9waWNfbnVtW0xJU1RfMV1bMippXS8yKSoyKTsKICB9CgogIGZvciAoaT0wO2k8KGxpc3RYc2l6ZVtMSVNUXzBdKzEpLzI7aSsrKQogIHsKICAgIGZzLT5mcmFtZS0+cmVmX3BpY19udW1bTElTVF8wXVtpXT0gaTY0bWluICgoZnMtPnRvcF9maWVsZC0+cmVmX3BpY19udW1bTElTVF8wXVsyKmldLzIpKjIsIChmcy0+Ym90dG9tX2ZpZWxkLT5yZWZfcGljX251bVtMSVNUXzBdWzIqaV0vMikqMik7CiAgfQoKICAgLy8hIFVzZSBpbmZlcmVuY2UgZmxhZyB0byByZW1hcCBtdnMvcmVmZXJlbmNlcwoKICAvLyEgR2VuZXJhdGUgRnJhbWUgcGFyYW1ldGVycyBmcm9tIGZpZWxkIGluZm9ybWF0aW9uLgogIGZvciAoaj0wIDsgajxmcy0+dG9wX2ZpZWxkLT5zaXplX3kvNCA7IGorKykKICB7CiAgICBqaiA9IDgqKGovNCkgKyAoaiU0KTsKICAgIGpqNCA9IGpqICsgNDsKICAgIGZvciAoaT0wIDsgaTxmcy0+dG9wX2ZpZWxkLT5zaXplX3gvNCA7IGkrKykKICAgIHsKICAgICAgZnMtPmZyYW1lLT5maWVsZF9mcmFtZVtqal1baV09IGZzLT5mcmFtZS0+ZmllbGRfZnJhbWVbamo0XVtpXT0xOwoKICAgICAgZnMtPmZyYW1lLT5tdltMSVNUXzBdW2pqXVtpXVswXSA9IGZzLT50b3BfZmllbGQtPm12W0xJU1RfMF1bal1baV1bMF07CiAgICAgIGZzLT5mcmFtZS0+bXZbTElTVF8wXVtqal1baV1bMV0gPSBmcy0+dG9wX2ZpZWxkLT5tdltMSVNUXzBdW2pdW2ldWzFdIDsKICAgICAgZnMtPmZyYW1lLT5tdltMSVNUXzFdW2pqXVtpXVswXSA9IGZzLT50b3BfZmllbGQtPm12W0xJU1RfMV1bal1baV1bMF07CiAgICAgIGZzLT5mcmFtZS0+bXZbTElTVF8xXVtqal1baV1bMV0gPSBmcy0+dG9wX2ZpZWxkLT5tdltMSVNUXzFdW2pdW2ldWzFdIDsKCiAgICAgIGR1bW15bGlzdDA9ZnMtPmZyYW1lLT5yZWZfaWR4W0xJU1RfMF1bampdW2ldICA9IGZzLT50b3BfZmllbGQtPnJlZl9pZHhbTElTVF8wXVtqXVtpXTsKICAgICAgZHVtbXlsaXN0MT1mcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8xXVtqal1baV0gID0gZnMtPnRvcF9maWVsZC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldOwoKICAgICAgLy8hIGFzc29jaWF0aW9uIHdpdGggaWQgYWxyZWFkeSBrbm93biBmb3IgZmllbGRzLgogICAgICBmcy0+dG9wX2ZpZWxkLT5yZWZfaWRbTElTVF8wXVtqXVtpXSA9IChkdW1teWxpc3QwPj0wKT8gZnMtPnRvcF9maWVsZC0+cmVmX3BpY19udW1bTElTVF8wXVtkdW1teWxpc3QwXSA6IDA7CiAgICAgIGZzLT50b3BfZmllbGQtPnJlZl9pZFtMSVNUXzFdW2pdW2ldID0gKGR1bW15bGlzdDE+PTApPyBmcy0+dG9wX2ZpZWxkLT5yZWZfcGljX251bVtMSVNUXzFdW2R1bW15bGlzdDFdIDogMDsKCiAgICAgIC8vISBuZWVkIHRvIG1ha2UgYXNzb2NpYXRpb24gd2l0aCBmcmFtZXMKICAgICAgZnMtPmZyYW1lLT5yZWZfaWRbTElTVF8wXVtqal1baV0gPSAoZHVtbXlsaXN0MD49MCk/IGZzLT50b3BfZmllbGQtPmZybV9yZWZfcGljX251bVtMSVNUXzBdW2R1bW15bGlzdDBdIDogMDsKICAgICAgZnMtPmZyYW1lLT5yZWZfaWRbTElTVF8xXVtqal1baV0gPSAoZHVtbXlsaXN0MT49MCk/IGZzLT50b3BfZmllbGQtPmZybV9yZWZfcGljX251bVtMSVNUXzFdW2R1bW15bGlzdDFdIDogMDsKCiAgICAgIGZzLT5mcmFtZS0+bXZbTElTVF8wXVtqajRdW2ldWzBdID0gZnMtPmJvdHRvbV9maWVsZC0+bXZbTElTVF8wXVtqXVtpXVswXTsKICAgICAgZnMtPmZyYW1lLT5tdltMSVNUXzBdW2pqNF1baV1bMV0gPSBmcy0+Ym90dG9tX2ZpZWxkLT5tdltMSVNUXzBdW2pdW2ldWzFdIDsKICAgICAgZnMtPmZyYW1lLT5tdltMSVNUXzFdW2pqNF1baV1bMF0gPSBmcy0+Ym90dG9tX2ZpZWxkLT5tdltMSVNUXzFdW2pdW2ldWzBdOwogICAgICBmcy0+ZnJhbWUtPm12W0xJU1RfMV1bamo0XVtpXVsxXSA9IGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMV1bal1baV1bMV0gOwoKICAgICAgZHVtbXlsaXN0MD1mcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8wXVtqajRdW2ldICA9IGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZHhbTElTVF8wXVtqXVtpXTsKICAgICAgZHVtbXlsaXN0MT1mcy0+ZnJhbWUtPnJlZl9pZHhbTElTVF8xXVtqajRdW2ldICA9IGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZHhbTElTVF8xXVtqXVtpXTsKCiAgICAgIGZzLT5ib3R0b21fZmllbGQtPnJlZl9pZFtMSVNUXzBdW2pdW2ldID0gKGR1bW15bGlzdDA+PTApPyBmcy0+Ym90dG9tX2ZpZWxkLT5yZWZfcGljX251bVtMSVNUXzBdW2R1bW15bGlzdDBdIDogMDsKICAgICAgZnMtPmJvdHRvbV9maWVsZC0+cmVmX2lkW0xJU1RfMV1bal1baV0gPSAoZHVtbXlsaXN0MT49MCk/IGZzLT5ib3R0b21fZmllbGQtPnJlZl9waWNfbnVtW0xJU1RfMV1bZHVtbXlsaXN0MV0gOiAwOwoKICAgICAgLy8hIG5lZWQgdG8gbWFrZSBhc3NvY2lhdGlvbiB3aXRoIGZyYW1lcwogICAgICBmcy0+ZnJhbWUtPnJlZl9pZFtMSVNUXzBdW2pqNF1baV0gPSAoZHVtbXlsaXN0MD49MCk/IGZzLT5ib3R0b21fZmllbGQtPmZybV9yZWZfcGljX251bVtMSVNUXzBdW2R1bW15bGlzdDBdIDogLTE7CiAgICAgIGZzLT5mcmFtZS0+cmVmX2lkW0xJU1RfMV1bamo0XVtpXSA9IChkdW1teWxpc3QxPj0wKT8gZnMtPmJvdHRvbV9maWVsZC0+ZnJtX3JlZl9waWNfbnVtW0xJU1RfMV1bZHVtbXlsaXN0MV0gOiAtMTsKCiAgICAgIGZzLT50b3BfZmllbGQtPmZpZWxkX2ZyYW1lW2pdW2ldPTE7CiAgICAgIGZzLT5ib3R0b21fZmllbGQtPmZpZWxkX2ZyYW1lW2pdW2ldPTE7CiAgICB9CiAgfQp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEFsbG9jYXRlIG1lbW9yeSBmb3IgYnVmZmVyaW5nIG9mIHJlZmVyZW5jZSBwaWN0dXJlIHJlb3JkZXJpbmcgY29tbWFuZHMKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8Kdm9pZCBhbGxvY19yZWZfcGljX2xpc3RfcmVvcmRlcmluZ19idWZmZXIoU2xpY2UgKmN1cnJTbGljZSkKewogIGludCBzaXplID0gaW1nLT5udW1fcmVmX2lkeF9sMF9hY3RpdmUrMTsKCiAgaWYgKGltZy0+dHlwZSE9SV9TTElDRSAmJiBpbWctPnR5cGUhPVNJX1NMSUNFKQogIHsKICAgIGlmICgoY3VyclNsaWNlLT5yZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY19sMCA9IGNhbGxvYyhzaXplLHNpemVvZihpbnQpKSk9PU5VTEwpIG5vX21lbV9leGl0KCJhbGxvY19yZWZfcGljX2xpc3RfcmVvcmRlcmluZ19idWZmZXI6IHJlbWFwcGluZ19vZl9waWNfbnVtc19pZGNfbDAiKTsKICAgIGlmICgoY3VyclNsaWNlLT5hYnNfZGlmZl9waWNfbnVtX21pbnVzMV9sMCA9IGNhbGxvYyhzaXplLHNpemVvZihpbnQpKSk9PU5VTEwpIG5vX21lbV9leGl0KCJhbGxvY19yZWZfcGljX2xpc3RfcmVvcmRlcmluZ19idWZmZXI6IGFic19kaWZmX3BpY19udW1fbWludXMxX2wwIik7CiAgICBpZiAoKGN1cnJTbGljZS0+bG9uZ190ZXJtX3BpY19pZHhfbDAgPSBjYWxsb2Moc2l6ZSxzaXplb2YoaW50KSkpPT1OVUxMKSBub19tZW1fZXhpdCgiYWxsb2NfcmVmX3BpY19saXN0X3Jlb3JkZXJpbmdfYnVmZmVyOiBsb25nX3Rlcm1fcGljX2lkeF9sMCIpOwogIH0KICBlbHNlCiAgewogICAgY3VyclNsaWNlLT5yZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY19sMCA9IE5VTEw7CiAgICBjdXJyU2xpY2UtPmFic19kaWZmX3BpY19udW1fbWludXMxX2wwID0gTlVMTDsKICAgIGN1cnJTbGljZS0+bG9uZ190ZXJtX3BpY19pZHhfbDAgPSBOVUxMOwogIH0KCiAgc2l6ZSA9IGltZy0+bnVtX3JlZl9pZHhfbDFfYWN0aXZlKzE7CgogIGlmIChpbWctPnR5cGU9PUJfU0xJQ0UpCiAgewogICAgaWYgKChjdXJyU2xpY2UtPnJlb3JkZXJpbmdfb2ZfcGljX251bXNfaWRjX2wxID0gY2FsbG9jKHNpemUsc2l6ZW9mKGludCkpKT09TlVMTCkgbm9fbWVtX2V4aXQoImFsbG9jX3JlZl9waWNfbGlzdF9yZW9yZGVyaW5nX2J1ZmZlcjogcmVtYXBwaW5nX29mX3BpY19udW1zX2lkY19sMSIpOwogICAgaWYgKChjdXJyU2xpY2UtPmFic19kaWZmX3BpY19udW1fbWludXMxX2wxID0gY2FsbG9jKHNpemUsc2l6ZW9mKGludCkpKT09TlVMTCkgbm9fbWVtX2V4aXQoImFsbG9jX3JlZl9waWNfbGlzdF9yZW9yZGVyaW5nX2J1ZmZlcjogYWJzX2RpZmZfcGljX251bV9taW51czFfbDEiKTsKICAgIGlmICgoY3VyclNsaWNlLT5sb25nX3Rlcm1fcGljX2lkeF9sMSA9IGNhbGxvYyhzaXplLHNpemVvZihpbnQpKSk9PU5VTEwpIG5vX21lbV9leGl0KCJhbGxvY19yZWZfcGljX2xpc3RfcmVvcmRlcmluZ19idWZmZXI6IGxvbmdfdGVybV9waWNfaWR4X2wxIik7CiAgfQogIGVsc2UKICB7CiAgICBjdXJyU2xpY2UtPnJlb3JkZXJpbmdfb2ZfcGljX251bXNfaWRjX2wxID0gTlVMTDsKICAgIGN1cnJTbGljZS0+YWJzX2RpZmZfcGljX251bV9taW51czFfbDEgPSBOVUxMOwogICAgY3VyclNsaWNlLT5sb25nX3Rlcm1fcGljX2lkeF9sMSA9IE5VTEw7CiAgfQp9CgoKLyohCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogXGJyaWVmCiAqICAgIEZyZWUgbWVtb3J5IGZvciBidWZmZXJpbmcgb2YgcmVmZXJlbmNlIHBpY3R1cmUgcmVvcmRlcmluZyBjb21tYW5kcwogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIGZyZWVfcmVmX3BpY19saXN0X3Jlb3JkZXJpbmdfYnVmZmVyKFNsaWNlICpjdXJyU2xpY2UpCnsKCiAgaWYgKGN1cnJTbGljZS0+cmVvcmRlcmluZ19vZl9waWNfbnVtc19pZGNfbDApCiAgICBmcmVlKGN1cnJTbGljZS0+cmVvcmRlcmluZ19vZl9waWNfbnVtc19pZGNfbDApOwogIGlmIChjdXJyU2xpY2UtPmFic19kaWZmX3BpY19udW1fbWludXMxX2wwKQogICAgZnJlZShjdXJyU2xpY2UtPmFic19kaWZmX3BpY19udW1fbWludXMxX2wwKTsKICBpZiAoY3VyclNsaWNlLT5sb25nX3Rlcm1fcGljX2lkeF9sMCkKICAgIGZyZWUoY3VyclNsaWNlLT5sb25nX3Rlcm1fcGljX2lkeF9sMCk7CgogIGN1cnJTbGljZS0+cmVvcmRlcmluZ19vZl9waWNfbnVtc19pZGNfbDAgPSBOVUxMOwogIGN1cnJTbGljZS0+YWJzX2RpZmZfcGljX251bV9taW51czFfbDAgPSBOVUxMOwogIGN1cnJTbGljZS0+bG9uZ190ZXJtX3BpY19pZHhfbDAgPSBOVUxMOwoKICBpZiAoY3VyclNsaWNlLT5yZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY19sMSkKICAgIGZyZWUoY3VyclNsaWNlLT5yZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY19sMSk7CiAgaWYgKGN1cnJTbGljZS0+YWJzX2RpZmZfcGljX251bV9taW51czFfbDEpCiAgICBmcmVlKGN1cnJTbGljZS0+YWJzX2RpZmZfcGljX251bV9taW51czFfbDEpOwogIGlmIChjdXJyU2xpY2UtPmxvbmdfdGVybV9waWNfaWR4X2wxKQogICAgZnJlZShjdXJyU2xpY2UtPmxvbmdfdGVybV9waWNfaWR4X2wxKTsKCiAgY3VyclNsaWNlLT5yZW9yZGVyaW5nX29mX3BpY19udW1zX2lkY19sMSA9IE5VTEw7CiAgY3VyclNsaWNlLT5hYnNfZGlmZl9waWNfbnVtX21pbnVzMV9sMSA9IE5VTEw7CiAgY3VyclNsaWNlLT5sb25nX3Rlcm1fcGljX2lkeF9sMSA9IE5VTEw7Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICAgIFRpYW4gRG9uZwogKiAgICAgICAgICBKdW5lIDEzLCAyMDAyLCBNb2RpZmVkIG9uIEp1bHkgMzAsIDIwMDMKICoKICogICAgICBJZiBhIGdhcCBpbiBmcmFtZV9udW0gaXMgZm91bmQsIHRyeSB0byBmaWxsIHRoZSBnYXAKICogXHBhcmFtIGltZwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqLwp2b2lkIGZpbGxfZnJhbWVfbnVtX2dhcChJbWFnZVBhcmFtZXRlcnMgKmltZykKewogIGludCBDdXJyRnJhbWVOdW07CiAgaW50IFVudXNlZFNob3J0VGVybUZyYW1lTnVtOwogIFN0b3JhYmxlUGljdHVyZSAqcGljdHVyZSA9IE5VTEw7CiAgaW50IG5hbF9yZWZfaWRjX2JhazsKICBpbnQgTWF4RnJhbWVOdW0gPSAxIDw8IChsb2cyX21heF9mcmFtZV9udW1fbWludXM0ICsgNCk7CgovLyAgcHJpbnRmKCJBIGdhcCBpbiBmcmFtZSBudW1iZXIgaXMgZm91bmQsIHRyeSB0byBmaWxsIGl0LlxuIik7CgogIG5hbF9yZWZfaWRjX2JhayA9IGltZy0+bmFsX3JlZmVyZW5jZV9pZGM7CiAgaW1nLT5uYWxfcmVmZXJlbmNlX2lkYyA9IDE7CgogIFVudXNlZFNob3J0VGVybUZyYW1lTnVtID0gKGltZy0+cHJlX2ZyYW1lX251bSArIDEpICUgTWF4RnJhbWVOdW07CiAgQ3VyckZyYW1lTnVtID0gaW1nLT5mcmFtZV9udW07CgogIHdoaWxlIChDdXJyRnJhbWVOdW0gIT0gVW51c2VkU2hvcnRUZXJtRnJhbWVOdW0pCiAgewogICAgcGljdHVyZSA9IGFsbG9jX3N0b3JhYmxlX3BpY3R1cmUgKEZSQU1FLCBpbWctPndpZHRoLCBpbWctPmhlaWdodCwgaW1nLT53aWR0aF9jciwgaW1nLT5oZWlnaHRfY3IpOwogICAgcGljdHVyZS0+Y29kZWRfZnJhbWUgPSAxOwogICAgcGljdHVyZS0+cGljX251bSA9IFVudXNlZFNob3J0VGVybUZyYW1lTnVtOwogICAgcGljdHVyZS0+bm9uX2V4aXN0aW5nID0gMTsKICAgIHBpY3R1cmUtPmlzX291dHB1dCA9IDE7CgogICAgaW1nLT5hZGFwdGl2ZV9yZWZfcGljX2J1ZmZlcmluZ19mbGFnID0gMDsKCiAgICBzdG9yZV9waWN0dXJlX2luX2RwYihwaWN0dXJlKTsKCiAgICBwaWN0dXJlPU5VTEw7CiAgICBVbnVzZWRTaG9ydFRlcm1GcmFtZU51bSA9IChVbnVzZWRTaG9ydFRlcm1GcmFtZU51bSArIDEpICUgTWF4RnJhbWVOdW07CiAgfQoKICBpbWctPm5hbF9yZWZlcmVuY2VfaWRjID0gbmFsX3JlZl9pZGNfYmFrOwp9CgovKiEKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBcYnJpZWYKICogICAgQWxsb2NhdGUgY28tbG9jYXRlZCBtZW1vcnkKICoKICogXHBhcmFtIHNpemVfeAogKiAgICBob3Jpem9udGFsIGx1bWEgc2l6ZQogKiBccGFyYW0gc2l6ZV95CiAqICAgIHZlcnRpY2FsIGx1bWEgc2l6ZQogKiBccGFyYW0gbWJfYWRhcHRpdmVfZnJhbWVfZmllbGRfZmxhZwogKiAgICBmbGFnIHRoYXQgaW5kaWNhdGVzIG1hY3JvYmxvY2sgYWRhcHRpdmUgZnJhbWUvZmllbGQgY29kaW5nCiAqCiAqIFxyZXR1cm4KICogICAgdGhlIGFsbG9jYXRlZCBTdG9yYWJsZVBpY3R1cmUgc3RydWN0dXJlCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCkNvbG9jYXRlZFBhcmFtcyogYWxsb2NfY29sb2NhdGVkKGludCBzaXplX3gsIGludCBzaXplX3ksIGludCBtYl9hZGFwdGl2ZV9mcmFtZV9maWVsZF9mbGFnKQp7CiAgQ29sb2NhdGVkUGFyYW1zICpzOwoKICBzID0gY2FsbG9jKDEsIHNpemVvZihDb2xvY2F0ZWRQYXJhbXMpKTsKICBpZiAoTlVMTCA9PSBzKQogICAgbm9fbWVtX2V4aXQoImFsbG9jX2NvbG9jYXRlZDogcyIpOwoKICBzLT5zaXplX3ggPSBzaXplX3g7CiAgcy0+c2l6ZV95ID0gc2l6ZV95OwoKCiAgZ2V0X21lbTNEICAgICAgKChieXRlKioqKikoJihzLT5yZWZfaWR4KSkgICAsIDIsIHNpemVfeSAvIEJMT0NLX1NJWkUsIHNpemVfeCAvIEJMT0NLX1NJWkUpOwogIGdldF9tZW0zRGludDY0ICgmKHMtPnJlZl9waWNfaWQpLCAyLCBzaXplX3kgLyBCTE9DS19TSVpFLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKICBnZXRfbWVtNERzaG9ydCAoJihzLT5tdikgICAgICAgICwgMiwgc2l6ZV95IC8gQkxPQ0tfU0laRSwgc2l6ZV94IC8gQkxPQ0tfU0laRSwyICk7CgogIGdldF9tZW0yRCAgICAgICgmKHMtPm1vdmluZ19ibG9jayksICBzaXplX3kgLyBCTE9DS19TSVpFLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKICBnZXRfbWVtMkQgICAgICAoJihzLT5maWVsZF9mcmFtZSkgLCBzaXplX3kgLyBCTE9DS19TSVpFLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKCiAgaWYgKG1iX2FkYXB0aXZlX2ZyYW1lX2ZpZWxkX2ZsYWcpCiAgewogICAgZ2V0X21lbTNEICAgICAgKChieXRlKioqKikoJihzLT50b3BfcmVmX2lkeCkpICAgLCAyLCBzaXplX3kgLyBCTE9DS19TSVpFLzIsIHNpemVfeCAvIEJMT0NLX1NJWkUpOwogICAgZ2V0X21lbTNEaW50NjQgKCYocy0+dG9wX3JlZl9waWNfaWQpLCAgICAgICAgICAgICAyLCBzaXplX3kgLyBCTE9DS19TSVpFLzIsIHNpemVfeCAvIEJMT0NLX1NJWkUpOwogICAgZ2V0X21lbTREc2hvcnQgKCYocy0+dG9wX212KSwgICAgICAgICAgICAgICAgICAgICAyLCBzaXplX3kgLyBCTE9DS19TSVpFLzIsIHNpemVfeCAvIEJMT0NLX1NJWkUsIDIpOwogICAgZ2V0X21lbTJEICgmKHMtPnRvcF9tb3ZpbmdfYmxvY2spLCAgICAgICAgICAgICAgICAgICBzaXplX3kgLyBCTE9DS19TSVpFLzIsIHNpemVfeCAvIEJMT0NLX1NJWkUpOwoKICAgIGdldF9tZW0zRCAgICAgICgoYnl0ZSoqKiopKCYocy0+Ym90dG9tX3JlZl9pZHgpKSwgMiwgc2l6ZV95IC8gQkxPQ0tfU0laRS8yLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKICAgIGdldF9tZW0zRGludDY0ICgmKHMtPmJvdHRvbV9yZWZfcGljX2lkKSwgICAgICAgICAgMiwgc2l6ZV95IC8gQkxPQ0tfU0laRS8yLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKICAgIGdldF9tZW00RHNob3J0ICgmKHMtPmJvdHRvbV9tdiksICAgICAgICAgICAgICAgICAgMiwgc2l6ZV95IC8gQkxPQ0tfU0laRS8yLCBzaXplX3ggLyBCTE9DS19TSVpFLCAyKTsKICAgIGdldF9tZW0yRCAoJihzLT5ib3R0b21fbW92aW5nX2Jsb2NrKSwgICAgICAgICAgICAgICAgc2l6ZV95IC8gQkxPQ0tfU0laRS8yLCBzaXplX3ggLyBCTE9DS19TSVpFKTsKICB9CgogIHMtPm1iX2FkYXB0aXZlX2ZyYW1lX2ZpZWxkX2ZsYWcgID0gbWJfYWRhcHRpdmVfZnJhbWVfZmllbGRfZmxhZzsKCiAgcmV0dXJuIHM7Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBGcmVlIGNvLWxvY2F0ZWQgbWVtb3J5LgogKgogKiBccGFyYW0gcAogKiAgICBQaWN0dXJlIHRvIGJlIGZyZWVkCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCnZvaWQgZnJlZV9jb2xvY2F0ZWQoQ29sb2NhdGVkUGFyYW1zKiBwKQp7CiAgaWYgKHApCiAgewogICAgZnJlZV9tZW0zRCAgICAgICgoYnl0ZSoqKilwLT5yZWZfaWR4LCAyKTsKICAgIGZyZWVfbWVtM0RpbnQ2NCAocC0+cmVmX3BpY19pZCwgMik7CiAgICBmcmVlX21lbTREc2hvcnQgKHAtPm12LCAyLCBwLT5zaXplX3kgLyBCTE9DS19TSVpFKTsKCiAgICBpZiAocC0+bW92aW5nX2Jsb2NrKQogICAgewogICAgICBmcmVlX21lbTJEIChwLT5tb3ZpbmdfYmxvY2spOwogICAgICBwLT5tb3ZpbmdfYmxvY2s9TlVMTDsKICAgIH0KICAgIGlmIChwLT5maWVsZF9mcmFtZSkKICAgIHsKICAgICAgZnJlZV9tZW0yRCAocC0+ZmllbGRfZnJhbWUpOwogICAgICBwLT5maWVsZF9mcmFtZT1OVUxMOwogICAgfQoKICAgIGlmIChwLT5tYl9hZGFwdGl2ZV9mcmFtZV9maWVsZF9mbGFnKQogICAgewogICAgICBmcmVlX21lbTNEICAgICAgKChieXRlKioqKXAtPnRvcF9yZWZfaWR4LCAyKTsKICAgICAgZnJlZV9tZW0zRGludDY0IChwLT50b3BfcmVmX3BpY19pZCwgMik7CiAgICAgIGZyZWVfbWVtNERzaG9ydCAocC0+dG9wX212LCAyLCBwLT5zaXplX3kgLyBCTE9DS19TSVpFIC8gMik7CgoKICAgICAgaWYgKHAtPnRvcF9tb3ZpbmdfYmxvY2spCiAgICAgIHsKICAgICAgICBmcmVlX21lbTJEIChwLT50b3BfbW92aW5nX2Jsb2NrKTsKICAgICAgICBwLT50b3BfbW92aW5nX2Jsb2NrPU5VTEw7CiAgICAgIH0KCiAgICAgIGZyZWVfbWVtM0QgICAgICAoKGJ5dGUqKiopcC0+Ym90dG9tX3JlZl9pZHgsIDIpOwogICAgICBmcmVlX21lbTNEaW50NjQgKHAtPmJvdHRvbV9yZWZfcGljX2lkLCAyKTsKICAgICAgZnJlZV9tZW00RHNob3J0IChwLT5ib3R0b21fbXYsIDIsIHAtPnNpemVfeSAvIEJMT0NLX1NJWkUgLyAyKTsKCgogICAgICBpZiAocC0+Ym90dG9tX21vdmluZ19ibG9jaykKICAgICAgewogICAgICAgIGZyZWVfbWVtMkQgKHAtPmJvdHRvbV9tb3ZpbmdfYmxvY2spOwogICAgICAgIHAtPmJvdHRvbV9tb3ZpbmdfYmxvY2s9TlVMTDsKICAgICAgfQoKICAgIH0KCiAgICBmcmVlKHApOwoKICAgIHA9TlVMTDsKICB9Cn0KCi8qIQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIFxicmllZgogKiAgICBDb21wdXRlIGNvLWxvY2F0ZWQgbW90aW9uIGluZm8KICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KCnZvaWQgY29tcHV0ZV9jb2xvY2F0ZWQoQ29sb2NhdGVkUGFyYW1zKiBwLCBTdG9yYWJsZVBpY3R1cmUgKipsaXN0WFs2XSkKewogIFN0b3JhYmxlUGljdHVyZSAqZnMsICpmc190b3AsICpmc19ib3R0b207CiAgaW50IGksaiwgaWksIGpqLCBqZGl2OwoKICBmc190b3AgPSBmc19ib3R0b20gPSBmcyA9IGxpc3RYW0xJU1RfMSBdWzBdOwoKICBpZiAoaW1nLT5NYmFmZkZyYW1lRmxhZykKICB7CiAgICBmc190b3A9IGxpc3RYW0xJU1RfMSArIDJdWzBdOwogICAgZnNfYm90dG9tPSBsaXN0WFtMSVNUXzEgKyA0XVswXTsKICB9CiAgZWxzZQogIHsKICAgIGlmIChpbWctPnN0cnVjdHVyZSE9RlJBTUUpCiAgICB7CiAgICAgIGlmICgoaW1nLT5zdHJ1Y3R1cmUgIT0gZnMtPnN0cnVjdHVyZSkgJiYgKGZzLT5jb2RlZF9mcmFtZSkpCiAgICAgIHsKICAgICAgICBpZiAoaW1nLT5zdHJ1Y3R1cmU9PVRPUF9GSUVMRCkKICAgICAgICB7CiAgICAgICAgICBmc190b3AgPSBmc19ib3R0b20gPSBmcyA9IGxpc3RYW0xJU1RfMSBdWzBdLT50b3BfZmllbGQ7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICBmc190b3AgPSBmc19ib3R0b20gPSBmcyA9IGxpc3RYW0xJU1RfMSBdWzBdLT5ib3R0b21fZmllbGQ7CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQoKICBpZiAoIWFjdGl2ZV9zcHMtPmZyYW1lX21ic19vbmx5X2ZsYWcgfHwgYWN0aXZlX3Nwcy0+ZGlyZWN0Xzh4OF9pbmZlcmVuY2VfZmxhZykKICB7CiAgICBmb3IgKGo9MCA7IGo8ZnMtPnNpemVfeS80IDsgaisrKQogICAgewogICAgICBqZGl2ID0gai8yOwogICAgICBqaiA9IGovMiArIDQgKiAoai84KTsKICAgICAgZm9yIChpPTAgOyBpPGZzLT5zaXplX3gvNCA7IGkrKykKICAgICAgewoKICAgICAgICBpZiAoaW1nLT5NYmFmZkZyYW1lRmxhZyAmJiBmcy0+ZmllbGRfZnJhbWVbal1baV0pCiAgICAgICAgewogICAgICAgICAgLy8hIEFzc2lnbiBmcmFtZSBidWZmZXJzIGZvciBmaWVsZCBNQnMKICAgICAgICAgIC8vISBDaGVjayB3aGV0aGVyIHdlIHNob3VsZCB1c2UgdG9wIG9yIGJvdHRvbSBmaWVsZCBtdnMuCiAgICAgICAgICAvLyEgRGVwZW5kaW5nIG9uIHRoZSBhc3NpZ25lZCBwb2MgdmFsdWVzLgoKICAgICAgICAgIGlmIChpYWJzKGVuY19waWN0dXJlLT5wb2MgLSBmc19ib3R0b20tPnBvYykgPiBpYWJzKGVuY19waWN0dXJlLT5wb2MgLSBmc190b3AtPnBvYykgKQogICAgICAgICAgewogICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzBdICAgID0gZnNfdG9wLT5tdltMSVNUXzBdW2pkaXZdW2ldWzBdOwogICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzFdICAgID0gZnNfdG9wLT5tdltMSVNUXzBdW2pkaXZdW2ldWzFdIDsKICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVswXSAgICA9IGZzX3RvcC0+bXZbTElTVF8xXVtqZGl2XVtpXVswXTsKICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVsxXSAgICA9IGZzX3RvcC0+bXZbTElTVF8xXVtqZGl2XVtpXVsxXSA7CiAgICAgICAgICAgIHAtPnJlZl9pZHhbTElTVF8wXVtqXVtpXSAgPSBmc190b3AtPnJlZl9pZHhbTElTVF8wXVtqZGl2XVtpXTsKICAgICAgICAgICAgcC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldICA9IGZzX3RvcC0+cmVmX2lkeFtMSVNUXzFdW2pkaXZdW2ldOwogICAgICAgICAgICBwLT5yZWZfcGljX2lkW0xJU1RfMF1bal1baV0gICA9IGZzLT5yZWZfaWRbTElTVF8wXVtqal1baV07CiAgICAgICAgICAgIHAtPnJlZl9waWNfaWRbTElTVF8xXVtqXVtpXSAgID0gZnMtPnJlZl9pZFtMSVNUXzFdW2pqXVtpXTsKCiAgICAgICAgICAgIHAtPmlzX2xvbmdfdGVybSAgICAgICAgICAgICA9IGZzX3RvcC0+aXNfbG9uZ190ZXJtOwogICAgICAgICAgfQogICAgICAgICAgZWxzZQogICAgICAgICAgewogICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzBdICAgICAgPSBmc19ib3R0b20tPm12W0xJU1RfMF1bamRpdl1baV1bMF07CiAgICAgICAgICAgIHAtPm12W0xJU1RfMF1bal1baV1bMV0gICAgICA9IGZzX2JvdHRvbS0+bXZbTElTVF8wXVtqZGl2XVtpXVsxXSA7CiAgICAgICAgICAgIHAtPm12W0xJU1RfMV1bal1baV1bMF0gICAgICA9IGZzX2JvdHRvbS0+bXZbTElTVF8xXVtqZGl2XVtpXVswXTsKICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVsxXSAgICAgID0gZnNfYm90dG9tLT5tdltMSVNUXzFdW2pkaXZdW2ldWzFdIDsKICAgICAgICAgICAgcC0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldICAgID0gZnNfYm90dG9tLT5yZWZfaWR4W0xJU1RfMF1bamRpdl1baV07CiAgICAgICAgICAgIHAtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSAgICA9IGZzX2JvdHRvbS0+cmVmX2lkeFtMSVNUXzFdW2pkaXZdW2ldOwogICAgICAgICAgICBwLT5yZWZfcGljX2lkW0xJU1RfMF1bal1baV0gPSBmcy0+cmVmX2lkW0xJU1RfMF1bamogKyA0XVtpXTsKICAgICAgICAgICAgcC0+cmVmX3BpY19pZFtMSVNUXzFdW2pdW2ldID0gZnMtPnJlZl9pZFtMSVNUXzFdW2pqICsgNF1baV07CgogICAgICAgICAgICBwLT5pc19sb25nX3Rlcm0gICAgICAgICAgICAgPSBmc19ib3R0b20tPmlzX2xvbmdfdGVybTsKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgIHAtPm12W0xJU1RfMF1bal1baV1bMF0gICAgICA9IGZzLT5tdltMSVNUXzBdW2pdW2ldWzBdOwogICAgICAgICAgcC0+bXZbTElTVF8wXVtqXVtpXVsxXSAgICAgID0gZnMtPm12W0xJU1RfMF1bal1baV1bMV0gOwogICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVswXSAgICAgID0gZnMtPm12W0xJU1RfMV1bal1baV1bMF07CiAgICAgICAgICBwLT5tdltMSVNUXzFdW2pdW2ldWzFdICAgICAgPSBmcy0+bXZbTElTVF8xXVtqXVtpXVsxXSA7CiAgICAgICAgICBwLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gICAgPSBmcy0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldOwogICAgICAgICAgcC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldICAgID0gZnMtPnJlZl9pZHhbTElTVF8xXVtqXVtpXTsKICAgICAgICAgIHAtPnJlZl9waWNfaWRbTElTVF8wXVtqXVtpXSA9IGZzLT5yZWZfaWRbTElTVF8wXVtqXVtpXTsKICAgICAgICAgIHAtPnJlZl9waWNfaWRbTElTVF8xXVtqXVtpXSA9IGZzLT5yZWZfaWRbTElTVF8xXVtqXVtpXTsKCiAgICAgICAgICBwLT5pc19sb25nX3Rlcm0gICAgICAgICAgICAgPSBmcy0+aXNfbG9uZ190ZXJtOwogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KCgogIC8vISBHZW5lcmF0ZSBmaWVsZCBNVnMgZnJvbSBGcmFtZSBNVnMKICBpZiAoaW1nLT5zdHJ1Y3R1cmUgfHwgaW1nLT5NYmFmZkZyYW1lRmxhZykKICB7CiAgICBmb3IgKGo9MCA7IGo8ZnMtPnNpemVfeS84IDsgaisrKQogICAgewogICAgICBqaiA9IFJTRChqKTsKICAgICAgZm9yIChpPTAgOyBpPGZzLT5zaXplX3gvNCA7IGkrKykKICAgICAgewogICAgICAgIGlpID0gUlNEKGkpOwogICAgICAgIC8vISBEbyBub3RoaW5nIGlmIG1hY3JvYmxvY2sgYXMgZmllbGQgY29kZWQgaW4gTUItQUZGCiAgICAgICAgaWYgKCFpbWctPk1iYWZmRnJhbWVGbGFnICkKICAgICAgICB7CiAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzBdID0gZnMtPm12W0xJU1RfMF1bampdW2lpXVswXTsKICAgICAgICAgIHAtPm12W0xJU1RfMF1bal1baV1bMV0gPSBmcy0+bXZbTElTVF8wXVtqal1baWldWzFdOwogICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVswXSA9IGZzLT5tdltMSVNUXzFdW2pqXVtpaV1bMF07CiAgICAgICAgICBwLT5tdltMSVNUXzFdW2pdW2ldWzFdID0gZnMtPm12W0xJU1RfMV1bampdW2lpXVsxXTsKCiAgICAgICAgICAvLyBTY2FsaW5nIG9mIHJlZmVyZW5jZXMgaXMgZG9uZSBoZXJlIHNpbmNlIGl0IHdpbGwgbm90IGFmZmVjdCBzcGF0aWFsIGRpcmVjdCAoMiowID0wKQoKICAgICAgICAgIGlmIChmcy0+cmVmX2lkeFtMSVNUXzBdW2pqXVtpaV0gPT0gLTEpCiAgICAgICAgICB7CiAgICAgICAgICAgIHAtPnJlZl9pZHggICBbTElTVF8wXVtqXVtpXSA9IC0xOwogICAgICAgICAgICBwLT5yZWZfcGljX2lkW0xJU1RfMF1bal1baV0gPSAtMTsKICAgICAgICAgIH0KICAgICAgICAgIGVsc2UKICAgICAgICAgIHsKICAgICAgICAgICAgcC0+cmVmX2lkeCAgIFtMSVNUXzBdW2pdW2ldID0gZnMtPnJlZl9pZHhbTElTVF8wXVtqal1baWldIDsKICAgICAgICAgICAgcC0+cmVmX3BpY19pZFtMSVNUXzBdW2pdW2ldID0gZnMtPnJlZl9pZCBbTElTVF8wXVtqal1baWldOwogICAgICAgICAgfQoKICAgICAgICAgIGlmIChmcy0+cmVmX2lkeFtMSVNUXzFdW2pqXVtpaV0gPT0gLTEpCiAgICAgICAgICB7CiAgICAgICAgICAgIHAtPnJlZl9pZHggICBbTElTVF8xXVtqXVtpXSA9IC0xOwogICAgICAgICAgICBwLT5yZWZfcGljX2lkW0xJU1RfMV1bal1baV0gPSAtMTsKICAgICAgICAgIH0KICAgICAgICAgIGVsc2UKICAgICAgICAgIHsKICAgICAgICAgICAgcC0+cmVmX2lkeCAgIFtMSVNUXzFdW2pdW2ldID0gZnMtPnJlZl9pZHhbTElTVF8xXVtqal1baWldOwogICAgICAgICAgICBwLT5yZWZfcGljX2lkW0xJU1RfMV1bal1baV0gPSBmcy0+cmVmX2lkIFtMSVNUXzFdW2pqXVtpaV07CiAgICAgICAgICB9CgogICAgICAgICAgcC0+aXNfbG9uZ190ZXJtID0gZnMtPmlzX2xvbmdfdGVybTsKCiAgICAgICAgICBpZiAoaW1nLT5kaXJlY3Rfc3BhdGlhbF9tdl9wcmVkX2ZsYWcgPT0gMSkKICAgICAgICAgIHsKICAgICAgICAgICAgcC0+bW92aW5nX2Jsb2NrW2pdW2ldID0KICAgICAgICAgICAgICAhKCghcC0+aXNfbG9uZ190ZXJtCiAgICAgICAgICAgICAgJiYgKChwLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gPT0gMCkKICAgICAgICAgICAgICAmJiAgKGlhYnMocC0+bXZbTElTVF8wXVtqXVtpXVswXSk+PjEgPT0gMCkKICAgICAgICAgICAgICAmJiAgKGlhYnMocC0+bXZbTElTVF8wXVtqXVtpXVsxXSk+PjEgPT0gMCkpKQogICAgICAgICAgICAgIHx8ICgocC0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldID09IC0xKQogICAgICAgICAgICAgICYmICAocC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldID09IDApCiAgICAgICAgICAgICAgJiYgIChpYWJzKHAtPm12W0xJU1RfMV1bal1baV1bMF0pPj4xID09IDApCiAgICAgICAgICAgICAgJiYgIChpYWJzKHAtPm12W0xJU1RfMV1bal1baV1bMV0pPj4xID09IDApKSk7CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICBwLT5ib3R0b21fbXZbTElTVF8wXVtqXVtpXVswXSA9IGZzX2JvdHRvbS0+bXZbTElTVF8wXVtqal1baWldWzBdOwogICAgICAgICAgcC0+Ym90dG9tX212W0xJU1RfMF1bal1baV1bMV0gPSBmc19ib3R0b20tPm12W0xJU1RfMF1bampdW2lpXVsxXTsKICAgICAgICAgIHAtPmJvdHRvbV9tdltMSVNUXzFdW2pdW2ldWzBdID0gZnNfYm90dG9tLT5tdltMSVNUXzFdW2pqXVtpaV1bMF07CiAgICAgICAgICBwLT5ib3R0b21fbXZbTElTVF8xXVtqXVtpXVsxXSA9IGZzX2JvdHRvbS0+bXZbTElTVF8xXVtqal1baWldWzFdOwogICAgICAgICAgcC0+Ym90dG9tX3JlZl9pZHhbTElTVF8wXVtqXVtpXSA9IGZzX2JvdHRvbS0+cmVmX2lkeFtMSVNUXzBdW2pqXVtpaV07CiAgICAgICAgICBwLT5ib3R0b21fcmVmX2lkeFtMSVNUXzFdW2pdW2ldID0gZnNfYm90dG9tLT5yZWZfaWR4W0xJU1RfMV1bampdW2lpXTsKICAgICAgICAgIHAtPmJvdHRvbV9yZWZfcGljX2lkW0xJU1RfMF1bal1baV0gPSBmc19ib3R0b20tPnJlZl9pZFtMSVNUXzBdW2pqXVtpaV07CiAgICAgICAgICBwLT5ib3R0b21fcmVmX3BpY19pZFtMSVNUXzFdW2pdW2ldID0gZnNfYm90dG9tLT5yZWZfaWRbTElTVF8xXVtqal1baWldOwoKICAgICAgICAgIGlmIChpbWctPmRpcmVjdF9zcGF0aWFsX212X3ByZWRfZmxhZyA9PSAxKQogICAgICAgICAgewogICAgICAgICAgICBwLT5ib3R0b21fbW92aW5nX2Jsb2NrW2pdW2ldID0KICAgICAgICAgICAgICAhKCghZnNfYm90dG9tLT5pc19sb25nX3Rlcm0KICAgICAgICAgICAgICAmJiAoKHAtPmJvdHRvbV9yZWZfaWR4W0xJU1RfMF1bal1baV0gPT0gMCkKICAgICAgICAgICAgICAmJiAgKGlhYnMocC0+Ym90dG9tX212W0xJU1RfMF1bal1baV1bMF0pPj4xID09IDApCiAgICAgICAgICAgICAgJiYgIChpYWJzKHAtPmJvdHRvbV9tdltMSVNUXzBdW2pdW2ldWzFdKT4+MSA9PSAwKSkpCiAgICAgICAgICAgICAgfHwgKChwLT5ib3R0b21fcmVmX2lkeFtMSVNUXzBdW2pdW2ldID09IC0xKQogICAgICAgICAgICAgICYmICAocC0+Ym90dG9tX3JlZl9pZHhbTElTVF8xXVtqXVtpXSA9PSAwKQogICAgICAgICAgICAgICYmICAoaWFicyhwLT5ib3R0b21fbXZbTElTVF8xXVtqXVtpXVswXSk+PjEgPT0gMCkKICAgICAgICAgICAgICAmJiAgKGlhYnMocC0+Ym90dG9tX212W0xJU1RfMV1bal1baV1bMV0pPj4xID09IDApKSk7CiAgICAgICAgICB9CgogICAgICAgICAgcC0+dG9wX212W0xJU1RfMF1bal1baV1bMF0gPSBmc190b3AtPm12W0xJU1RfMF1bampdW2lpXVswXTsKICAgICAgICAgIHAtPnRvcF9tdltMSVNUXzBdW2pdW2ldWzFdID0gZnNfdG9wLT5tdltMSVNUXzBdW2pqXVtpaV1bMV07CiAgICAgICAgICBwLT50b3BfbXZbTElTVF8xXVtqXVtpXVswXSA9IGZzX3RvcC0+bXZbTElTVF8xXVtqal1baWldWzBdOwogICAgICAgICAgcC0+dG9wX212W0xJU1RfMV1bal1baV1bMV0gPSBmc190b3AtPm12W0xJU1RfMV1bampdW2lpXVsxXTsKICAgICAgICAgIHAtPnRvcF9yZWZfaWR4W0xJU1RfMF1bal1baV0gPSBmc190b3AtPnJlZl9pZHhbTElTVF8wXVtqal1baWldOwogICAgICAgICAgcC0+dG9wX3JlZl9pZHhbTElTVF8xXVtqXVtpXSA9IGZzX3RvcC0+cmVmX2lkeFtMSVNUXzFdW2pqXVtpaV07CiAgICAgICAgICBwLT50b3BfcmVmX3BpY19pZFtMSVNUXzBdW2pdW2ldID0gZnNfdG9wLT5yZWZfaWRbTElTVF8wXVtqal1baWldOwogICAgICAgICAgcC0+dG9wX3JlZl9waWNfaWRbTElTVF8xXVtqXVtpXSA9IGZzX3RvcC0+cmVmX2lkW0xJU1RfMV1bampdW2lpXTsKCiAgICAgICAgICBpZiAoaW1nLT5kaXJlY3Rfc3BhdGlhbF9tdl9wcmVkX2ZsYWcgPT0gMSkKICAgICAgICAgIHsKICAgICAgICAgICAgcC0+dG9wX21vdmluZ19ibG9ja1tqXVtpXSA9CiAgICAgICAgICAgICAgISgoIWZzX3RvcC0+aXNfbG9uZ190ZXJtCiAgICAgICAgICAgICAgJiYgKChwLT50b3BfcmVmX2lkeFtMSVNUXzBdW2pdW2ldID09IDApCiAgICAgICAgICAgICAgJiYgIChpYWJzKHAtPnRvcF9tdltMSVNUXzBdW2pdW2ldWzBdKT4+MSA9PSAwKQogICAgICAgICAgICAgICYmICAoaWFicyhwLT50b3BfbXZbTElTVF8wXVtqXVtpXVsxXSk+PjEgPT0gMCkpKQogICAgICAgICAgICAgIHx8ICgocC0+dG9wX3JlZl9pZHhbTElTVF8wXVtqXVtpXSA9PSAtMSkKICAgICAgICAgICAgICAmJiAgKHAtPnRvcF9yZWZfaWR4W0xJU1RfMV1bal1baV0gPT0gMCkKICAgICAgICAgICAgICAmJiAgKGlhYnMocC0+dG9wX212W0xJU1RfMV1bal1baV1bMF0pPj4xID09IDApCiAgICAgICAgICAgICAgJiYgIChpYWJzKHAtPnRvcF9tdltMSVNUXzFdW2pdW2ldWzFdKT4+MSA9PSAwKSkpOwogICAgICAgICAgfQoKICAgICAgICAgIGlmICgoaW1nLT5kaXJlY3Rfc3BhdGlhbF9tdl9wcmVkX2ZsYWcgPT0gMCApICYmICFmcy0+ZmllbGRfZnJhbWVbMipqXVtpXSkKICAgICAgICAgIHsKICAgICAgICAgICAgcC0+dG9wX212W0xJU1RfMF1bal1baV1bMV0gLz0gMjsKICAgICAgICAgICAgcC0+dG9wX212W0xJU1RfMV1bal1baV1bMV0gLz0gMjsKICAgICAgICAgICAgcC0+Ym90dG9tX212W0xJU1RfMF1bal1baV1bMV0gLz0gMjsKICAgICAgICAgICAgcC0+Ym90dG9tX212W0xJU1RfMV1bal1baV1bMV0gLz0gMjsKICAgICAgICAgIH0KCiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQoKCiAgaWYgKCFhY3RpdmVfc3BzLT5mcmFtZV9tYnNfb25seV9mbGFnIHx8IGFjdGl2ZV9zcHMtPmRpcmVjdF84eDhfaW5mZXJlbmNlX2ZsYWcpCiAgewogICAgLy8hIFVzZSBpbmZlcmVuY2UgZmxhZyB0byByZW1hcCBtdnMvcmVmZXJlbmNlcwogICAgLy8hIEZyYW1lIHdpdGggZmllbGQgY28tbG9jYXRlZAoKICAgIGlmICghaW1nLT5zdHJ1Y3R1cmUpCiAgICB7CiAgICAgIGZvciAoaj0wIDsgaiA8IChmcy0+c2l6ZV95Pj4yKSA7IGorKykKICAgICAgewogICAgICAgIGpkaXYgPSBqPj4xOwogICAgICAgIGpqID0gKGo+PjEpICsgNCooaj4+Myk7CiAgICAgICAgZm9yIChpPTAgOyBpIDwgKGZzLT5zaXplX3g+PjIpIDsgaSsrKQogICAgICAgIHsKCiAgICAgICAgICBpZiAoZnMtPmZpZWxkX2ZyYW1lW2pdW2ldKQogICAgICAgICAgewogICAgICAgICAgICBpZiAoaWFicyhlbmNfcGljdHVyZS0+cG9jIC0gZnMtPmJvdHRvbV9maWVsZC0+cG9jKSA+IGlhYnMoZW5jX3BpY3R1cmUtPnBvYyAtIGZzLT50b3BfZmllbGQtPnBvYykpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzBdID0gZnMtPnRvcF9maWVsZC0+bXZbTElTVF8wXVtqZGl2XVtpXVswXTsKICAgICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzFdID0gZnMtPnRvcF9maWVsZC0+bXZbTElTVF8wXVtqZGl2XVtpXVsxXSA7CiAgICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVswXSA9IGZzLT50b3BfZmllbGQtPm12W0xJU1RfMV1bamRpdl1baV1bMF07CiAgICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVsxXSA9IGZzLT50b3BfZmllbGQtPm12W0xJU1RfMV1bamRpdl1baV1bMV0gOwoKICAgICAgICAgICAgICBwLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gID0gZnMtPnRvcF9maWVsZC0+cmVmX2lkeFtMSVNUXzBdW2pkaXZdW2ldOwogICAgICAgICAgICAgIHAtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSAgPSBmcy0+dG9wX2ZpZWxkLT5yZWZfaWR4W0xJU1RfMV1bamRpdl1baV07CiAgICAgICAgICAgICAgcC0+cmVmX3BpY19pZFtMSVNUXzBdW2pdW2ldICAgPSBmcy0+cmVmX2lkW0xJU1RfMF1bampdW2ldOwogICAgICAgICAgICAgIHAtPnJlZl9waWNfaWRbTElTVF8xXVtqXVtpXSAgID0gZnMtPnJlZl9pZFtMSVNUXzFdW2pqXVtpXTsKICAgICAgICAgICAgICBwLT5pc19sb25nX3Rlcm0gICAgICAgICAgICAgICA9IGZzLT50b3BfZmllbGQtPmlzX2xvbmdfdGVybTsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzBdID0gZnMtPmJvdHRvbV9maWVsZC0+bXZbTElTVF8wXVtqZGl2XVtpXVswXTsKICAgICAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzFdID0gZnMtPmJvdHRvbV9maWVsZC0+bXZbTElTVF8wXVtqZGl2XVtpXVsxXSA7CiAgICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVswXSA9IGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMV1bamRpdl1baV1bMF07CiAgICAgICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVsxXSA9IGZzLT5ib3R0b21fZmllbGQtPm12W0xJU1RfMV1bamRpdl1baV1bMV0gOwoKICAgICAgICAgICAgICBwLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gID0gZnMtPmJvdHRvbV9maWVsZC0+cmVmX2lkeFtMSVNUXzBdW2pkaXZdW2ldOwogICAgICAgICAgICAgIHAtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSAgPSBmcy0+Ym90dG9tX2ZpZWxkLT5yZWZfaWR4W0xJU1RfMV1bamRpdl1baV07CiAgICAgICAgICAgICAgcC0+cmVmX3BpY19pZFtMSVNUXzBdW2pdW2ldID0gZnMtPnJlZl9pZFtMSVNUXzBdW2pqICsgNF1baV07CiAgICAgICAgICAgICAgcC0+cmVmX3BpY19pZFtMSVNUXzFdW2pdW2ldID0gZnMtPnJlZl9pZFtMSVNUXzFdW2pqICsgNF1baV07CiAgICAgICAgICAgICAgcC0+aXNfbG9uZ190ZXJtICAgICAgICAgICAgID0gZnMtPmJvdHRvbV9maWVsZC0+aXNfbG9uZ190ZXJtOwogICAgICAgICAgICB9CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQoKCiAgcC0+aXNfbG9uZ190ZXJtID0gZnMtPmlzX2xvbmdfdGVybTsKCiAgaWYgKCFhY3RpdmVfc3BzLT5mcmFtZV9tYnNfb25seV9mbGFnIHx8IGFjdGl2ZV9zcHMtPmRpcmVjdF84eDhfaW5mZXJlbmNlX2ZsYWcpCiAgewogICAgZm9yIChqPTAgOyBqIDwgKGZzLT5zaXplX3k+PjIpIDsgaisrKQogICAgewogICAgICBqaiA9IFJTRChqKTsKICAgICAgZm9yIChpPTAgOyBpIDwgKGZzLT5zaXplX3g+PjIpIDsgaSsrKQogICAgICB7CiAgICAgICAgaWkgPSBSU0QoaSk7CgogICAgICAgIHAtPm12W0xJU1RfMF1bal1baV1bMF09cC0+bXZbTElTVF8wXVtqal1baWldWzBdOwogICAgICAgIHAtPm12W0xJU1RfMF1bal1baV1bMV09cC0+bXZbTElTVF8wXVtqal1baWldWzFdOwogICAgICAgIHAtPm12W0xJU1RfMV1bal1baV1bMF09cC0+bXZbTElTVF8xXVtqal1baWldWzBdOwogICAgICAgIHAtPm12W0xJU1RfMV1bal1baV1bMV09cC0+bXZbTElTVF8xXVtqal1baWldWzFdOwoKICAgICAgICBwLT5yZWZfaWR4W0xJU1RfMF1bal1baV09cC0+cmVmX2lkeFtMSVNUXzBdW2pqXVtpaV07CiAgICAgICAgcC0+cmVmX2lkeFtMSVNUXzFdW2pdW2ldPXAtPnJlZl9pZHhbTElTVF8xXVtqal1baWldOwogICAgICAgIHAtPnJlZl9waWNfaWRbTElTVF8wXVtqXVtpXSA9IHAtPnJlZl9waWNfaWRbTElTVF8wXVtqal1baWldOwogICAgICAgIHAtPnJlZl9waWNfaWRbTElTVF8xXVtqXVtpXSA9IHAtPnJlZl9waWNfaWRbTElTVF8xXVtqal1baWldOwoKICAgICAgICBpZiAoaW1nLT5kaXJlY3Rfc3BhdGlhbF9tdl9wcmVkX2ZsYWcgPT0gMSkKICAgICAgICB7CiAgICAgICAgICBwLT5tb3ZpbmdfYmxvY2tbal1baV09CiAgICAgICAgICAgICEoKCFwLT5pc19sb25nX3Rlcm0KICAgICAgICAgICAgJiYgKChwLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gPT0gMCkKICAgICAgICAgICAgJiYgIChpYWJzKHAtPm12W0xJU1RfMF1bal1baV1bMF0pPj4xID09IDApCiAgICAgICAgICAgICYmICAoaWFicyhwLT5tdltMSVNUXzBdW2pdW2ldWzFdKT4+MSA9PSAwKSkpCiAgICAgICAgICAgIHx8ICgocC0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldID09IC0xKQogICAgICAgICAgICAmJiAgKHAtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSA9PSAwKQogICAgICAgICAgICAmJiAgKGlhYnMocC0+bXZbTElTVF8xXVtqXVtpXVswXSk+PjEgPT0gMCkKICAgICAgICAgICAgJiYgIChpYWJzKHAtPm12W0xJU1RfMV1bal1baV1bMV0pPj4xID09IDApKSk7CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQogIGVsc2UKICB7CiAgICBmb3IgKGo9MCA7IGo8ZnMtPnNpemVfeS80IDsgaisrKQogICAgewogICAgICBqaiA9IFJTRChqKTsKICAgICAgZm9yIChpPTAgOyBpPGZzLT5zaXplX3gvNCA7IGkrKykKICAgICAgewogICAgICAgIGlpID0gUlNEKGkpOwogICAgICAgIC8vISBVc2UgaW5mZXJlbmNlIGZsYWcgdG8gcmVtYXAgbXZzL3JlZmVyZW5jZXMKICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzBdPWZzLT5tdltMSVNUXzBdW2pdW2ldWzBdOwogICAgICAgIHAtPm12W0xJU1RfMF1bal1baV1bMV09ZnMtPm12W0xJU1RfMF1bal1baV1bMV07CiAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVswXT1mcy0+bXZbTElTVF8xXVtqXVtpXVswXTsKICAgICAgICBwLT5tdltMSVNUXzFdW2pdW2ldWzFdPWZzLT5tdltMSVNUXzFdW2pdW2ldWzFdOwoKICAgICAgICBwLT5yZWZfaWR4W0xJU1RfMF1bal1baV09ZnMtPnJlZl9pZHhbTElTVF8wXVtqXVtpXTsKICAgICAgICBwLT5yZWZfaWR4W0xJU1RfMV1bal1baV09ZnMtPnJlZl9pZHhbTElTVF8xXVtqXVtpXTsKICAgICAgICBwLT5yZWZfcGljX2lkW0xJU1RfMF1bal1baV0gPSBmcy0+cmVmX2lkW0xJU1RfMF1bal1baV07CiAgICAgICAgcC0+cmVmX3BpY19pZFtMSVNUXzFdW2pdW2ldID0gZnMtPnJlZl9pZFtMSVNUXzFdW2pdW2ldOwoKICAgICAgICBpZiAoaW1nLT5kaXJlY3Rfc3BhdGlhbF9tdl9wcmVkX2ZsYWcgPT0gMSkKICAgICAgICB7CiAgICAgICAgICBwLT5tb3ZpbmdfYmxvY2tbal1baV09CiAgICAgICAgICAgICEoKCFwLT5pc19sb25nX3Rlcm0KICAgICAgICAgICAgJiYgKChwLT5yZWZfaWR4W0xJU1RfMF1bal1baV0gPT0gMCkKICAgICAgICAgICAgJiYgIChpYWJzKHAtPm12W0xJU1RfMF1bal1baV1bMF0pPj4xID09IDApCiAgICAgICAgICAgICYmICAoaWFicyhwLT5tdltMSVNUXzBdW2pdW2ldWzFdKT4+MSA9PSAwKSkpCiAgICAgICAgICAgIHx8ICgocC0+cmVmX2lkeFtMSVNUXzBdW2pdW2ldID09IC0xKQogICAgICAgICAgICAmJiAgKHAtPnJlZl9pZHhbTElTVF8xXVtqXVtpXSA9PSAwKQogICAgICAgICAgICAmJiAgKGlhYnMocC0+bXZbTElTVF8xXVtqXVtpXVswXSk+PjEgPT0gMCkKICAgICAgICAgICAgJiYgIChpYWJzKHAtPm12W0xJU1RfMV1bal1baV1bMV0pPj4xID09IDApKSk7CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQoKCiAgaWYgKGltZy0+ZGlyZWN0X3NwYXRpYWxfbXZfcHJlZF9mbGFnID09MCkKICB7CiAgICBmb3IgKGo9MCA7IGo8ZnMtPnNpemVfeS80IDsgaisrKQogICAgewogICAgICBmb3IgKGk9MCA7IGk8ZnMtPnNpemVfeC80IDsgaSsrKQogICAgICB7CiAgICAgICAgaWYgKCghaW1nLT5NYmFmZkZyYW1lRmxhZyAmJiFpbWctPnN0cnVjdHVyZSAmJiBmcy0+ZmllbGRfZnJhbWVbal1baV0pIHx8IChpbWctPk1iYWZmRnJhbWVGbGFnICYmIGZzLT5maWVsZF9mcmFtZVtqXVtpXSkpCiAgICAgICAgewogICAgICAgICAgcC0+bXZbTElTVF8wXVtqXVtpXVsxXSAqPSAyOwogICAgICAgICAgcC0+bXZbTElTVF8xXVtqXVtpXVsxXSAqPSAyOwogICAgICAgIH0KICAgICAgICBlbHNlICBpZiAoaW1nLT5zdHJ1Y3R1cmUgJiYgIWZzLT5maWVsZF9mcmFtZVtqXVtpXSkKICAgICAgICB7CiAgICAgICAgICBwLT5tdltMSVNUXzBdW2pdW2ldWzFdIC89IDI7CiAgICAgICAgICBwLT5tdltMSVNUXzFdW2pdW2ldWzFdIC89IDI7CiAgICAgICAgfQoKICAgICAgfQogICAgfQoKICAgIGZvciAoaj0wOyBqPDIgKyAoaW1nLT5NYmFmZkZyYW1lRmxhZyAqIDQpO2orPTIpCiAgICB7CiAgICAgIGZvciAoaT0wOyBpPGxpc3RYc2l6ZVtqXTtpKyspCiAgICAgIHsKICAgICAgICBpbnQgcHJlc2NhbGUsIGlUUmIsIGlUUnA7CgogICAgICAgIGlmIChqPT0wKQogICAgICAgIHsKICAgICAgICAgIGlUUmIgPSBpQ2xpcDMoIC0xMjgsIDEyNywgZW5jX3BpY3R1cmUtPnBvYyAtIGxpc3RYW0xJU1RfMCArIGpdW2ldLT5wb2MgKTsKICAgICAgICB9CiAgICAgICAgZWxzZSBpZiAoaiA9PSAyKQogICAgICAgIHsKICAgICAgICAgIGlUUmIgPSBpQ2xpcDMoIC0xMjgsIDEyNywgZW5jX3BpY3R1cmUtPnRvcF9wb2MgLSBsaXN0WFtMSVNUXzAgKyBqXVtpXS0+cG9jICk7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICBpVFJiID0gaUNsaXAzKCAtMTI4LCAxMjcsIGVuY19waWN0dXJlLT5ib3R0b21fcG9jIC0gbGlzdFhbTElTVF8wICsgal1baV0tPnBvYyApOwogICAgICAgIH0KCiAgICAgICAgaVRScCA9IGlDbGlwMyggLTEyOCwgMTI3LCAgbGlzdFhbTElTVF8xICsgal1bMF0tPnBvYyAtIGxpc3RYW0xJU1RfMCArIGpdW2ldLT5wb2MpOwoKICAgICAgICBpZiAoaVRScCE9MCkKICAgICAgICB7CiAgICAgICAgICBwcmVzY2FsZSA9ICggMTYzODQgKyBpYWJzKCBpVFJwIC8gMiApICkgLyBpVFJwOwogICAgICAgICAgaW1nLT5tdnNjYWxlW2pdW2ldID0gaUNsaXAzKCAtMTAyNCwgMTAyMywgKCBpVFJiICogcHJlc2NhbGUgKyAzMiApID4+IDYgKSA7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICBpbWctPm12c2NhbGVbal1baV0gPSA5OTk5OwogICAgICAgIH0KICAgICAgfQogICAgfQogIH0KfQoK