ZGlmZiAtLWdpdCBhL3J1bnRpbWUvZG9jL2luc2VydC50eHQgYi9ydW50aW1lL2RvYy9pbnNlcnQudHh0CmluZGV4IDQzYjNkNGYuLmFlOTBlYjkgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvZG9jL2luc2VydC50eHQKKysrIGIvcnVudGltZS9kb2MvaW5zZXJ0LnR4dApAQCAtMSw0ICsxLDQgQEAKLSppbnNlcnQudHh0KiAgICBGb3IgVmltIHZlcnNpb24gNy4wYWEuICBMYXN0IGNoYW5nZTogMjAwNSBBdWcgMTEKKyppbnNlcnQudHh0KiAgICBGb3IgVmltIHZlcnNpb24gNy4wYWEuICBMYXN0IGNoYW5nZTogMjAwNSBBdWcgMTcKIAogCiAJCSAgVklNIFJFRkVSRU5DRSBNQU5VQUwgICAgYnkgQnJhbSBNb29sZW5hYXIKQEAgLTg5OSw4ICs4OTksMTEgQEAKIAogU3BlbGxpbmcgc3VnZ2VzdGlvbnMJCQkJCSpjb21wbC1zcGVsbGluZyoKIAotVGhlIHdvcmQgaW4gZnJvbnQgb2YgdGhlIGN1cnNvciBpcyBsb2NhdGVkIGFuZCBjb3JyZWN0bHkgc3BlbGxlZCB3b3JkcyBhcmUKLXN1Z2dlc3RlZCB0byByZXBsYWNlIGl0LiAgVGhlIHdvcmQgZG9lc24ndCBhY3R1YWxseSBoYXZlIHRvIGJlIGJhZGx5IHNwZWxsZWQuCitBIHdvcmQgYmVmb3JlIG9yIGF0IHRoZSBjdXJzb3IgaXMgbG9jYXRlZCBhbmQgY29ycmVjdGx5IHNwZWxsZWQgd29yZHMgYXJlCitzdWdnZXN0ZWQgdG8gcmVwbGFjZSBpdC4gIElmIHRoZXJlIGlzIGEgYmFkbHkgc3BlbGxlZCB3b3JkIGluIHRoZSBsaW5lLCBiZWZvcmUKK29yIHVuZGVyIHRoZSBjdXJzb3IsIHRoZSBjdXJzb3IgaXMgbW92ZWQgdG8gYWZ0ZXIgaXQuICBPdGhlcndpc2UgdGhlIHdvcmQganVzdAorYmVmb3JlIHRoZSBjdXJzb3IgaXMgdXNlZCBmb3Igc3VnZ2VzdGlvbnMsIGV2ZW4gdGhvdWdoIGl0IGlzbid0IGJhZGx5IHNwZWxsZWQuCisKIE5PVEU6IENUUkwtUyBzdXNwZW5kcyBkaXNwbGF5IGluIG1hbnkgVW5peCB0ZXJtaW5hbHMuICBVc2UgJ3MnIGluc3RlYWQuICBUeXBlCiBDVFJMLVEgdG8gcmVzdW1lIGRpc3BsYXlpbmcuCiAKZGlmZiAtLWdpdCBhL3J1bnRpbWUvZG9jL21hcC50eHQgYi9ydW50aW1lL2RvYy9tYXAudHh0CmluZGV4IGExMzVhNDguLjVmYjAzZTkgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvZG9jL21hcC50eHQKKysrIGIvcnVudGltZS9kb2MvbWFwLnR4dApAQCAtMjgxLDEwICsyODEsNyBAQAogCW4gIDxDLVc+KiAgICAgICogPEMtVz48Qy1TPioKIAkgICAgICAgIExhc3Qgc2V0IGZyb20gL2hvbWUvYWJjZC8udmltcmMKIAotV2hlbiB0aGUgbWFwIHdhcyBkZWZpbmVkIGJ5IGhhbmQgdGhlcmUgaXMgbm8gIkxhc3Qgc2V0IiBtZXNzYWdlLiAgV2hlbiB0aGUgbWFwCi13YXMgZGVmaW5lZCB3aGlsZSBleGVjdXRpbmcgYSBmdW5jdGlvbiwgdXNlciBjb21tYW5kIG9yIGF1dG9jb21tYW5kLCB0aGUKLXNjcmlwdCBpbiB3aGljaCBpdCB3YXMgZGVmaW5lZCBpcyByZXBvcnRlZC4KLXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgK2V2YWwgZmVhdHVyZX0KK1NlZSB8OnZlcmJvc2UtY21kfCBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KIAogCQkJCQkJCSptYXBfYmFja3NsYXNoKgogTm90ZSB0aGF0IG9ubHkgQ1RSTC1WIGlzIG1lbnRpb25lZCBoZXJlIGFzIGEgc3BlY2lhbCBjaGFyYWN0ZXIgZm9yIG1hcHBpbmdzCkBAIC04NzcsMTAgKzg3NCw3IEBACiAJVE9odG1sICAgICAgMCAgICAlICAgICAgICAgICAgICAgOmNhbGwgQ29udmVydDJIVE1MKDxsaW5lMT4sIDxsaW5lMj4pCiAJICAgIExhc3Qgc2V0IGZyb20gL3Vzci9zaGFyZS92aW0vdmltLTcuMC9wbHVnaW4vdG9odG1sLnZpbQogPAotV2hlbiB0aGUgY29tbWFuZCB3YXMgZGVmaW5lZCBieSBoYW5kIHRoZXJlIGlzIG5vICJMYXN0IHNldCIgbWVzc2FnZS4gIFdoZW4gdGhlCi1jb21tYW5kIHdhcyBkZWZpbmVkIHdoaWxlIGV4ZWN1dGluZyBhIGZ1bmN0aW9uLCB1c2VyIGNvbW1hbmQgb3IgYXV0b2NvbW1hbmQsCi10aGUgc2NyaXB0IGluIHdoaWNoIGl0IHdhcyBkZWZpbmVkIGlzIHJlcG9ydGVkLgote25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSArZXZhbCBmZWF0dXJlfQorU2VlIHw6dmVyYm9zZS1jbWR8IGZvciBtb3JlIGluZm9ybWF0aW9uLgogCiAJCQkJCQkJKkUxNzQqICpFMTgyKgogOmNvbVttYW5kXVshXSBbe2F0dHJ9Li4uXSB7Y21kfSB7cmVwfQpkaWZmIC0tZ2l0IGEvcnVudGltZS9zcGVsbC9lbi5hc2NpaS5zcGwgYi9ydW50aW1lL3NwZWxsL2VuLmFzY2lpLnNwbAppbmRleCA5ZDJiMDY4Li4zNjBlMWFlIDEwMDY0NAotLS0gYS9ydW50aW1lL3NwZWxsL2VuLmFzY2lpLnNwbAorKysgYi9ydW50aW1lL3NwZWxsL2VuLmFzY2lpLnNwbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9ydW50aW1lL3NwZWxsL2VuLnV0Zi04LnNwbCBiL3J1bnRpbWUvc3BlbGwvZW4udXRmLTguc3BsCmluZGV4IDhiMmVkYzYuLjliYTg1M2MgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvc3BlbGwvZW4udXRmLTguc3BsCisrKyBiL3J1bnRpbWUvc3BlbGwvZW4udXRmLTguc3BsCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL3J1bnRpbWUvc3BlbGwvaHUvaHVfSFUuZGlmZiBiL3J1bnRpbWUvc3BlbGwvaHUvaHVfSFUuZGlmZgppbmRleCBkZTIyYzc5Li4yYjlhNmRkIDEwMDY0NAotLS0gYS9ydW50aW1lL3NwZWxsL2h1L2h1X0hVLmRpZmYKKysrIGIvcnVudGltZS9zcGVsbC9odS9odV9IVS5kaWZmCkBAIC0xLDUgKzEsNSBAQAogKioqIGh1X0hVLm9yaWcuYWZmCVR1ZSBBdWcgMTYgMTg6MjE6MTAgMjAwNQotLS0tIGh1X0hVLmFmZglUdWUgQXVnIDE2IDE5OjQyOjM0IDIwMDUKKy0tLSBodV9IVS5hZmYJRnJpIEF1ZyAxOSAyMToyODo0NSAyMDA1CiAqKioqKioqKioqKioqKioKICoqKiA1Nyw2MiAqKioqCiAgIApAQCAtMTYsOCArMTYsOSBAQAogISAjVkVSU0lPTiBNYWd5YXIgMC45OS40LjIKICAgU0VUIElTTzg4NTktMgogKioqKioqKioqKioqKioqCi0qKiogNjUsNzcgKioqKgotICBDT01QT1VOREZMQUcgWQorKioqIDY0LDc3ICoqKioKKyAgQ09NUE9VTkRNSU4gMgorISBDT01QT1VOREZMQUcgWQogISBDT01QT1VORFdPUkQgMiB5CiAhIENPTVBPVU5EU1lMTEFCTEUgNiBh4WXpae1v8/b1dfr8+wogISBTWUxMQUJMRU5VTSBrbG1jCkBAIC0zMCwyNCArMzEsODUgQEAKICEgV09SRENIQVJTIC0upyWwMDEyMzQ1Njc4OQogISBIVV9LT1RPSEFOR1pPIFoKICAgCi0tLS0gNjUsODAgLS0tLQotICBDT01QT1VOREZMQUcgWQorLS0tIDY0LDExNiAtLS0tCisgIENPTVBPVU5ETUlOIDIKICEgI0NPTVBPVU5EV09SRCAyIHkKKyEgQ09NUE9VTkRNQVggMgorISAjIEkgZG9uJ3QgdW5kZXJzdGFuZCB3aGF0IHRoZSAieSIgaXMgZm9yOyBpZiBpdCdzIHRvIGRpc2FibGUgY29tcG91bmRpbmcgc2ltcGx5CishICMgcmVtb3ZlIHRoZSBjb21wb3VuZCBmbGFnIGZyb20gdGhlIHdvcmQuCishIAogISAjQ09NUE9VTkRTWUxMQUJMRSA2IGHhZelp7W/z9vV1+vz7CishIENPTVBPVU5EU1lMTUFYIDYKKyEgU1lMTEFCTEUgYS/hL2Uv6S9pL+0vby/zL/Yv9S91L/ov/C/7CishICMgU3RyYW5nZSB0aGF0IGV2ZXJ5IHZvd2VsIGlzIGNvdW50ZWQgYXMgYSBzeWxsYWJsZSwgdGhhdCdzIGhvdyB0aGUgaHVuc3BlbGwKKyEgIyBjb2RlIHdvcmtzLgorISAKICEgI1NZTExBQkxFTlVNIGtsbWMKKyEgIyBEb24ndCB1bmRlcnN0YW5kIHdoYXQgdGhpcyBpcyBmb3IKKyEgCishICNDT01QT1VOREZMQUcgWQogISAjQ09NUE9VTkRGSVJTVCB2CiAhICNDT01QT1VORExBU1QgeAorISBDT01QT1VOREZMQUdTIFkrCishIENPTVBPVU5ERkxBR1MgdlkqeAorISBDT01QT1VOREZMQUdTIFkreAorISBDT01QT1VOREZMQUdTIHZZKworISAKICEgI0ZPUkJJRERFTldPUkQgdwotISBCQUQgdworISAjICBJIGRvbid0IHVuZGVyc3RhbmQgd2hhdCBGT1JCSURERU5XT1JEIGlzIG5lZWRlZCBmb3IsIHVzaW5nIE5FRURBRkZJWAorISAjICAoT05MWVJPT1QpIHNob3VsZCBiZSBzdWZmaWNpZW50LgorISAKICEgI09OTFlST09UIHUKKyEgTkVFREFGRklYIHUKKyEgCiAhICNBQ0NFTlQg4ent8/b1+vz7IGFlaW9vb3V1dQorISBNQVAgNQorISBNQVAgYeHkCishIE1BUCBl6QorISBNQVAgae0KKyEgTUFQIG/z9vUKKyEgTUFQIHX6/PsKKyEgCiAhICNDSEVDS05VTQorISAjIFZpbSBhbHdheXMgaGFuZGxlcyBudW1iZXJzIGluIHRoZSBzYW1lIHdheS4KKyEgCiAhICNXT1JEQ0hBUlMgLS6nJbAwMTIzNDU2Nzg5CishIEZPTCCxorO1tqi5uru8vr+xsrO0tba3uLm6u7y9vr/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vj5+vv8/f7f/y2nJbAKKyEgTE9XILGis7W2qLm6u7y+v7Gys7S1tre4ubq7vL2+v+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX2+Pn6+/z9/t//LaclsAorISBVUFAgoaKjpaaoqaqrrK6vsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbY2drb3N3e3/8tpyWwCishIE1JRFdPUkQgLgorISAKICEgI0hVX0tPVE9IQU5HWk8gWgogISAKKyEgIyBUaGVyZSBhcmUgc29vb28gbWFueSBhZmZpeGVzLiAgUG9zdHBvbmUgdGhlIHByZWZpeGVzIHRvIGtlZXAgdGhlIHRpbWUgbmVlZGVkCishICMgZm9yIGdlbmVyYXRpbmcgdGhlIC5zcGwgd2l0aGluIHJlYXNvbmFibGUgbGltaXRzLgogISBQRlhQT1NUUE9ORQogICAKICoqKioqKioqKioqKioqKgorKioqIDgxLDk2ICoqKioKKyAgCishIFJFUCA4OQorISBSRVAg7SBpCishIFJFUCBpIO0KKyEgUkVQIPMgbworISBSRVAgbyDzCishIFJFUCBvIPUKKyEgUkVQIPogdQorISBSRVAgdSD6CishIFJFUCB1IPsKKyEgUkVQIPsg/AorISBSRVAg/CD7CisgIFJFUCBqIGx5CisgIFJFUCBseSBqCistIFJFUCBhIOQgIyBIYW5kZWwtPkjkbmRlbAorICBSRVAgUyCpICMgU2tvZGEtPqlrb2RhCistLS0gMTIwLDEyNCAtLS0tCisgIAorISBSRVAgNzgKKyAgUkVQIGogbHkKKyAgUkVQIGx5IGoKKyAgUkVQIFMgqSAjIFNrb2RhLT6pa29kYQorKioqKioqKioqKioqKioqCiAqKiogMTczLDI0MSAqKioqCiAgIAogLSAjIGNoYXJhY3RlciBjb252ZXJzaW9uIHRhYmxlCkBAIC0xMTgsMTEgKzE4MCwxMSBAQAogLSBDSFIgMTIzIFUzINsKIC0gCiAgIFNGWCB6IFkgNgotLS0tIDE3NiwxNzcgLS0tLQorLS0tIDIwMSwyMDIgLS0tLQogKioqKioqKioqKioqKioqCiAqKiogMTc2NzgsMTc2ODEgKioqKgogICBQRlggRCAgIDAgICAgbGVnICAgICAgICAgIC4KIC0gCiAtICAgIDEKIC0gCi0tLS0gMTc2MTQgLS0tLQorLS0tIDE3NjM5IC0tLS0KZGlmZiAtLWdpdCBhL3J1bnRpbWUvc3BlbGwvbWFpbi5hYXAgYi9ydW50aW1lL3NwZWxsL21haW4uYWFwCmluZGV4IDFlMzdjMWMuLjVhYWFhYTEgMTAwNjQ0Ci0tLSBhL3J1bnRpbWUvc3BlbGwvbWFpbi5hYXAKKysrIGIvcnVudGltZS9zcGVsbC9tYWluLmFhcApAQCAtNCwxOSArNCwyMiBAQAogIyBhYXAgICAgICAgIGdlbmVyYXRlIGFsbCB0aGUgLnNwbCBmaWxlcwogIyBhYXAgZGlmZiAgIGNyZWF0ZSBhbGwgdGhlIGRpZmYgZmlsZXMKIAotTEFORyA9IGFmIGJnIGNhIGNzIGRhIGRlIGVsIGVuIGVvIGZyIGZvIGdsIGhlIGhyIGl0IG5sIG55IHBsIHNrIHlpCitMQU5HID0gYWYgYmcgY2EgY3MgZGEgZGUgZWwgZW4gZW8gZnIgZm8gZ2wgaGUgaHIgaXQgbmwgbnkgcGwgc2sgeWkgaHUKIAorIyAiaHUiIGlzIGF0IHRoZSBlbmQsIGJlY2F1c2UgaXQgdGFrZXMgc28gbXVjaCB0aW1lLgorIwogIyBUT0RPOgogIyBGaW5uaXNoIGRvZXNuJ3Qgd29yaywgdGhlIGRpY3Rpb25hcnkgZmlfRkkuemlwIGZpbGUgY29udGFpbnMgaHlwaGVuYXRpb24uLi4KIAogZGlmZjogJCpMQU5HL2RpZmYKLSAgICAgICAgOnByaW50IGRvbmUKKyAgICAgICAgOnByaW50IERvbmUuCiAKIEBmb3IgbCBpbiBzdHJpbmcuc3BsaXQoX25vLkxBTkcpOgogICAgICAgICA6Y2hpbGQgJGwvbWFpbi5hYXAKIAogIyBUaGUgZXhpc3RpbmcgLnNwbCBmaWxlcyBuZWVkIHRvIGJlIGdlbmVyYXRlZCB3aGVuIHRoZSBzcGVsbCBmaWxlIGZvcm1hdAogIyBjaGFuZ2VzLiAgRGVwZW5kaW5nIG9uIHRoZSBWaW0gZXhlY3V0YWJsZSBkb2VzIHRoYXQsIGJ1dCByZXN1bHRzIGluIGRvaW5nIGl0Ci0jIG11Y2ggdG9vIG9mdGVuLiAgR2VuZXJhdGUgYSBkdW1teSAuc3BsIGZpbGUgYW5kIGNoZWNrIGlmIGl0IGNoYW5nZWQuCisjIG11Y2ggdG9vIG9mdGVuLiAgR2VuZXJhdGUgYSBkdW1teSAuc3BsIGZpbGUgYW5kIGxldCB0aGUgLnNwbCBkZXBlbmQgb24gaXQsIHNvCisjIHRoYXQgdGhleSBhcmUgb3V0ZGF0ZWQgd2hlbiBpdCBjaGFuZ2VzLgogOmNoaWxkIGNoZWNrL21haW4uYWFwCiAqLnNwbDogY2hlY2svY2hlY2subGF0aW4xLnNwbApkaWZmIC0tZ2l0IGEvc3JjL3NwZWxsLmMgYi9zcmMvc3BlbGwuYwppbmRleCBhM2ZjMjRmLi4zMGIwOGFlIDEwMDY0NAotLS0gYS9zcmMvc3BlbGwuYworKysgYi9zcmMvc3BlbGwuYwpAQCAtNTYsMTYgKzU2LDYgQEAKICMgZGVmaW5lIFNQRUxMX1BSSU5UVFJFRQogI2VuZGlmCiAKLS8qIFNQRUxMX0NPTVBSRVNTX0NOVCBpcyBhZnRlciBob3cgbWFueSBhbGxvY2F0ZWQgYmxvY2tzIHdlIGNvbXByZXNzIHRoZSB0cmVlCi0gKiB0byBsaW1pdCB0aGUgYW1vdW50IG9mIG1lbW9yeSB1c2VkIChlc3AuIGZvciBJdGFsaWFuIGFuZCBIdW5nYXJpYW4pLiAgVGhlCi0gKiBhbW91bnQgb2YgbWVtb3J5IHVzZWQgZm9yIG5vZGVzIHRoZW4gaXMgU1BFTExfQ09NUFJFU1NfQ05UIHRpbWVzCi0gKiBTQkxPQ0tTSVpFLgotICogVGhlbiBjb21wcmVzcyBhZ2FpbiBhZnRlciBhbGxvY2F0aW5nIFNQRUxMX0NPTVBSRVNTX0lOQyBtb3JlIGJsb2NrcyBvcgotICogYWRkaW5nIFNQRUxMX0NPTVBSRVNTX0FEREVEIHdvcmRzIGFuZCBydW5uaW5nIG91dCBvZiBtZW1vcnkgYWdhaW4uICAqLwotI2RlZmluZSBTUEVMTF9DT01QUkVTU19DTlQgMzAwMDAKLSNkZWZpbmUgU1BFTExfQ09NUFJFU1NfSU5DIDEwMAotI2RlZmluZSBTUEVMTF9DT01QUkVTU19BRERFRCA1MDAwMDAKLQogLyoKICAqIFVzZSB0aGlzIHRvIGFkanVzdCB0aGUgc2NvcmUgYWZ0ZXIgZmluZGluZyBzdWdnZXN0aW9ucywgYmFzZWQgb24gdGhlCiAgKiBzdWdnZXN0ZWQgd29yZCBzb3VuZGluZyBsaWtlIHRoZSBiYWQgd29yZC4gIFRoaXMgaXMgbXVjaCBmYXN0ZXIgdGhhbiBkb2luZwpAQCAtNzgsOTQgKzY4LDEwMiBAQAogCiAvKgogICogVmltIHNwZWxsIGZpbGUgZm9ybWF0OiA8SEVBREVSPgotICoJCQkgIDxTVUdHRVNUPgorICoJCQkgIDxTRUNUSU9OUz4KICAqCQkJICA8TFdPUkRUUkVFPgogICoJCQkgIDxLV09SRFRSRUU+CiAgKgkJCSAgPFBSRUZJWFRSRUU+CiAgKgotICogPEhFQURFUj46IDxmaWxlSUQ+Ci0gKgkJPHJlZ2lvbmNudD4gPHJlZ2lvbm5hbWU+IC4uLgotICoJCTxjaGFyZmxhZ3NsZW4+IDxjaGFyZmxhZ3M+Ci0gKgkJPGZjaGFyc2xlbj4gPGZjaGFycz4KLSAqCQk8bWlkd29yZGxlbj4gPG1pZHdvcmQ+Ci0gKgkJPGNvbXBvdW5kbGVuPiA8Y29tcG91bmR0eXBlPiA8Y29tcG91bmRpbmZvPgotICoJCTxwcmVmY29uZGNudD4gPHByZWZjb25kPiAuLi4KKyAqIDxIRUFERVI+OiA8ZmlsZUlEPiA8dmVyc2lvbm5yPgogICoKLSAqIDxmaWxlSUQ+ICAgICAxMCBieXRlcyAgICAiVklNc3BlbGwxMCIKLSAqIDxyZWdpb25jbnQ+ICAxIGJ5dGUJICAgIG51bWJlciBvZiByZWdpb25zIGZvbGxvd2luZyAoOCBzdXBwb3J0ZWQpCi0gKiA8cmVnaW9ubmFtZT4JMiBieXRlcyAgICAgUmVnaW9uIG5hbWU6IGNhLCBhdSwgZXRjLiAgTG93ZXIgY2FzZS4KKyAqIDxmaWxlSUQ+ICAgICA4IGJ5dGVzICAgICJWSU1zcGVsbCIKKyAqIDx2ZXJzaW9ubnI+ICAxIGJ5dGUJICAgIFZJTVNQRUxMVkVSU0lPTgorICoKKyAqCisgKiBTZWN0aW9ucyBtYWtlIGl0IHBvc3NpYmxlIHRvIGFkZCBpbmZvcm1hdGlvbiB0byB0aGUgLnNwbCBmaWxlIHdpdGhvdXQKKyAqIG1ha2luZyBpdCBpbmNvbXBhdGlibGUgd2l0aCBwcmV2aW91cyB2ZXJzaW9ucy4gIFRoZXJlIGFyZSB0d28ga2luZHMgb2YKKyAqIHNlY3Rpb25zOgorICogMS4gTm90IGVzc2VudGlhbCBmb3IgY29ycmVjdCBzcGVsbCBjaGVja2luZy4gIEUuZy4gZm9yIG1ha2luZyBzdWdnZXN0aW9ucy4KKyAqICAgIFRoZXNlIGFyZSBza2lwcGVkIHdoZW4gbm90IHN1cHBvcnRlZC4KKyAqIDIuIE9wdGlvbmFsIGluZm9ybWF0aW9uLCBidXQgZXNzZW50aWFsIGZvciBzcGVsbCBjaGVja2luZyB3aGVuIHByZXNlbnQuCisgKiAgICBFLmcuIGNvbmRpdGlvbnMgZm9yIGFmZml4ZXMuICBXaGVuIHRoaXMgc2VjdGlvbiBpcyBwcmVzZW50IGJ1dCBub3QKKyAqICAgIHN1cHBvcnRlZCBhbiBlcnJvciBtZXNzYWdlIGlzIGdpdmVuLgorICoKKyAqIDxTRUNUSU9OUz46IDxzZWN0aW9uPiAuLi4gPHNlY3Rpb25lbmQ+CisgKgorICogPHNlY3Rpb24+OiA8c2VjdGlvbklEPiA8c2VjdGlvbmZsYWdzPiA8c2VjdGlvbmxlbj4gKHNlY3Rpb24gY29udGVudHMpCisgKgorICogPHNlY3Rpb25JRD4JICAxIGJ5dGUgICAgbnVtYmVyIGZyb20gMCB0byAyNTQgaWRlbnRpZnlpbmcgdGhlIHNlY3Rpb24KKyAqCisgKiA8c2VjdGlvbmZsYWdzPiAxIGJ5dGUgICAgU05GX1JFUVVJUkVEOiB0aGlzIHNlY3Rpb24gaXMgcmVxdWlyZWQgZm9yIGNvcnJlY3QKKyAqCQkJCQkgICAgc3BlbGwgY2hlY2tpbmcKKyAqCisgKiA8c2VjdGlvbmxlbj4gICA0IGJ5dGVzICAgbGVuZ3RoIG9mIHNlY3Rpb24gY29udGVudHMsIE1TQiBmaXJzdAorICoKKyAqIDxzZWN0aW9uZW5kPgkgIDEgYnl0ZSAgICBTTl9FTkQKKyAqCisgKgorICogc2VjdGlvbklEID09IFNOX1JFR0lPTjogPHJlZ2lvbm5hbWU+IC4uLgorICogPHJlZ2lvbm5hbWU+CSAyIGJ5dGVzICAgIFVwIHRvIDggcmVnaW9uIG5hbWVzOiBjYSwgYXUsIGV0Yy4gIExvd2VyIGNhc2UuCiAgKgkJCSAgICBGaXJzdCA8cmVnaW9ubmFtZT4gaXMgcmVnaW9uIDEuCiAgKgorICogc2VjdGlvbklEID09IFNOX0NIQVJGTEFHUzogPGNoYXJmbGFnc2xlbj4gPGNoYXJmbGFncz4KKyAqCQkJCTxmb2xjaGFyc2xlbj4gPGZvbGNoYXJzPgogICogPGNoYXJmbGFnc2xlbj4gMSBieXRlICAgIE51bWJlciBvZiBieXRlcyBpbiA8Y2hhcmZsYWdzPiAoc2hvdWxkIGJlIDEyOCkuCiAgKiA8Y2hhcmZsYWdzPiAgTiBieXRlcyAgICAgTGlzdCBvZiBmbGFncyAoZmlyc3Qgb25lIGlzIGZvciBjaGFyYWN0ZXIgMTI4KToKICAqCQkJICAgIDB4MDEgIHdvcmQgY2hhcmFjdGVyCUNGX1dPUkQKICAqCQkJICAgIDB4MDIgIHVwcGVyLWNhc2UgY2hhcmFjdGVyCUNGX1VQUEVSCi0gKiA8ZmNoYXJzbGVuPiAgMiBieXRlcyAgICAgTnVtYmVyIG9mIGJ5dGVzIGluIDxmY2hhcnM+LgotICogPGZjaGFycz4gICAgIE4gYnl0ZXMJICAgIEZvbGRlZCBjaGFyYWN0ZXJzLCBmaXJzdCBvbmUgaXMgZm9yIGNoYXJhY3RlciAxMjguCisgKiA8Zm9sY2hhcnNsZW4+ICAyIGJ5dGVzICAgTnVtYmVyIG9mIGJ5dGVzIGluIDxmb2xjaGFycz4uCisgKiA8Zm9sY2hhcnM+ICAgICBOIGJ5dGVzICAgRm9sZGVkIGNoYXJhY3RlcnMsIGZpcnN0IG9uZSBpcyBmb3IgY2hhcmFjdGVyIDEyOC4KICAqCi0gKiA8bWlkd29yZGxlbj4gMiBieXRlcyAgICAgTnVtYmVyIG9mIGJ5dGVzIGluIDxtaWR3b3JkPi4KLSAqIDxtaWR3b3JkPiAgICBOIGJ5dGVzCSAgICBDaGFyYWN0ZXJzIHRoYXQgYXJlIHdvcmQgY2hhcmFjdGVycyBvbmx5IHdoZW4gdXNlZAorICogc2VjdGlvbklEID09IFNOX01JRFdPUkQ6IDxtaWR3b3JkPgorICogPG1pZHdvcmQ+ICAgICBOIGJ5dGVzICAgIENoYXJhY3RlcnMgdGhhdCBhcmUgd29yZCBjaGFyYWN0ZXJzIG9ubHkgd2hlbiB1c2VkCiAgKgkJCSAgICBpbiB0aGUgbWlkZGxlIG9mIGEgd29yZC4KICAqCi0gKiA8Y29tcG91bmRsZW4+IDIgYnl0ZXMgICAgTnVtYmVyIG9mIGJ5dGVzIGZvbGxvd2luZyBmb3IgY29tcG91bmQgaW5mbyAoY2FuCi0gKgkJCSAgICBiZSB1c2VkIHRvIHNraXAgaXQgd2hlbiBpdCdzIG5vdCB1bmRlcnN0b29kKS4KLSAqCi0gKiA8Y29tcG91bmR0eXBlIDEgYnl0ZQkgICAgMTogY29tcG91bmQgd29yZHMgdXNpbmcgPGNvbXAxbWlubGVuPiBhbmQKLSAqCQkJICAgIDxjb21wMWZsYWdzPgotICoKLSAqIDxjb21wMW1pbmxlbj4gMSBieXRlICAgICBtaW5pbWFsIHdvcmQgbGVuZ3RoIGZvciBjb21wb3VuZGluZwotICoKLSAqIDxjb21wMWZsYWdzPiAgTiBieXRlcyAgICBmbGFncyB1c2VkIGZvciBjb21wb3VuZGluZyB3b3JkcwotICoKLSAqCisgKiBzZWN0aW9uSUQgPT0gU05fUFJFRkNPTkQ6IDxwcmVmY29uZGNudD4gPHByZWZjb25kPiAuLi4KICAqIDxwcmVmY29uZGNudD4gMiBieXRlcyAgICBOdW1iZXIgb2YgPHByZWZjb25kPiBpdGVtcyBmb2xsb3dpbmcuCi0gKgogICogPHByZWZjb25kPiA6IDxjb25kbGVuPiA8Y29uZHN0cj4KLSAqCiAgKiA8Y29uZGxlbj4JMSBieXRlCSAgICBMZW5ndGggb2YgPGNvbmRzdHI+LgotICoKICAqIDxjb25kc3RyPglOIGJ5dGVzCSAgICBDb25kaXRpb24gZm9yIHRoZSBwcmVmaXguCiAgKgotICoKLSAqIDxTVUdHRVNUPiA6IDxyZXBjb3VudD4gPHJlcD4gLi4uCi0gKgkgICAgICAgPHNhbGZsYWdzPiA8c2FsY291bnQ+IDxzYWw+IC4uLgotICoJICAgICAgIDxtYXBsZW4+IDxtYXBzdHI+Ci0gKgotICogPHJlcGNvdW50PgkyIGJ5dGVzCSAgICBudW1iZXIgb2YgPHJlcD4gaXRlbXMsIE1TQiBmaXJzdC4KLSAqCisgKiBzZWN0aW9uSUQgPT0gU05fUkVQOiA8cmVwY291bnQ+IDxyZXA+IC4uLgorICogPHJlcGNvdW50PgkgMiBieXRlcyAgICBudW1iZXIgb2YgPHJlcD4gaXRlbXMsIE1TQiBmaXJzdC4KICAqIDxyZXA+IDogPHJlcGZyb21sZW4+IDxyZXBmcm9tPiA8cmVwdG9sZW4+IDxyZXB0bz4KKyAqIDxyZXBmcm9tbGVuPgkgMSBieXRlCSAgICBsZW5ndGggb2YgPHJlcGZyb20+CisgKiA8cmVwZnJvbT4JIE4gYnl0ZXMgICAgImZyb20iIHBhcnQgb2YgcmVwbGFjZW1lbnQKKyAqIDxyZXB0b2xlbj4JIDEgYnl0ZQkgICAgbGVuZ3RoIG9mIDxyZXB0bz4KKyAqIDxyZXB0bz4JIE4gYnl0ZXMgICAgInRvIiBwYXJ0IG9mIHJlcGxhY2VtZW50CiAgKgotICogPHJlcGZyb21sZW4+CTEgYnl0ZQkgICAgbGVuZ3RoIG9mIDxyZXBmcm9tPgotICoKLSAqIDxyZXBmcm9tPglOIGJ5dGVzCSAgICAiZnJvbSIgcGFydCBvZiByZXBsYWNlbWVudAotICoKLSAqIDxyZXB0b2xlbj4JMSBieXRlCSAgICBsZW5ndGggb2YgPHJlcHRvPgotICoKLSAqIDxyZXB0bz4JTiBieXRlcwkgICAgInRvIiBwYXJ0IG9mIHJlcGxhY2VtZW50Ci0gKgotICogPHNhbGZsYWdzPgkxIGJ5dGUJICAgIGZsYWdzIGZvciBzb3VuZHNhbGlrZSBjb252ZXJzaW9uOgorICogc2VjdGlvbklEID09IFNOX1NBTDogPHNhbGZsYWdzPiA8c2FsY291bnQ+IDxzYWw+IC4uLgorICogPHNhbGZsYWdzPgkgMSBieXRlCSAgICBmbGFncyBmb3Igc291bmRzYWxpa2UgY29udmVyc2lvbjoKICAqCQkJICAgIFNBTF9GMExMT1dVUAogICoJCQkgICAgU0FMX0NPTExBUFNFCiAgKgkJCSAgICBTQUxfUkVNX0FDQ0VOVFMKLSAqCQkJICAgIFNBTF9TT0ZPOiBTT0ZPRlJPTSBhbmQgU09GT1RPIHVzZWQgaW5zdGVhZCBvZiBTQUwKLSAqCi0gKiA8c2FsY291bnQ+ICAgMiBieXRlcwkgICAgbnVtYmVyIG9mIDxzYWw+IGl0ZW1zIGZvbGxvd2luZwotICoKKyAqIDxzYWxjb3VudD4gICAgMiBieXRlcyAgICBudW1iZXIgb2YgPHNhbD4gaXRlbXMgZm9sbG93aW5nCiAgKiA8c2FsPiA6IDxzYWxmcm9tbGVuPiA8c2FsZnJvbT4gPHNhbHRvbGVuPiA8c2FsdG8+CisgKiA8c2FsZnJvbWxlbj4JIDEgYnl0ZQkgICAgbGVuZ3RoIG9mIDxzYWxmcm9tPgorICogPHNhbGZyb20+CSBOIGJ5dGVzICAgICJmcm9tIiBwYXJ0IG9mIHNvdW5kc2FsaWtlCisgKiA8c2FsdG9sZW4+CSAxIGJ5dGUJICAgIGxlbmd0aCBvZiA8c2FsdG8+CisgKiA8c2FsdG8+CSBOIGJ5dGVzICAgICJ0byIgcGFydCBvZiBzb3VuZHNhbGlrZQogICoKLSAqIDxzYWxmcm9tbGVuPgkxLTIgYnl0ZXMgICAgbGVuZ3RoIG9mIDxzYWxmcm9tPiAoMiBieXRlcyBmb3IgU0FMX1NPRk8pCisgKiBzZWN0aW9uSUQgPT0gU05fU09GTzogPHNvZm9mcm9tbGVuPiA8c29mb2Zyb20+IDxzb2ZvdG9sZW4+IDxzb2ZvdG8+CisgKiA8c29mb2Zyb21sZW4+IDIgYnl0ZXMgICAgbGVuZ3RoIG9mIDxzb2ZvZnJvbT4KKyAqIDxzb2ZvZnJvbT4JIE4gYnl0ZXMgICAgImZyb20iIHBhcnQgb2Ygc291bmRmb2xkCisgKiA8c29mb3RvbGVuPgkgMiBieXRlcyAgICBsZW5ndGggb2YgPHNvZm90bz4KKyAqIDxzb2ZvdG8+CSBOIGJ5dGVzICAgICJ0byIgcGFydCBvZiBzb3VuZGZvbGQKICAqCi0gKiA8c2FsZnJvbT4JTiBieXRlcwkgICAgImZyb20iIHBhcnQgb2Ygc291bmRzYWxpa2UKLSAqCi0gKiA8c2FsdG9sZW4+CTEtMiBieXRlcyAgICBsZW5ndGggb2YgPHNhbHRvPiAoMiBieXRlcyBmb3IgU0FMX1NPRk8pCi0gKgotICogPHNhbHRvPglOIGJ5dGVzCSAgICAidG8iIHBhcnQgb2Ygc291bmRzYWxpa2UKLSAqCi0gKiA8bWFwbGVuPgkyIGJ5dGVzCSAgICBsZW5ndGggb2YgPG1hcHN0cj4sIE1TQiBmaXJzdAotICoKLSAqIDxtYXBzdHI+CU4gYnl0ZXMJICAgIFN0cmluZyB3aXRoIHNlcXVlbmNlcyBvZiBzaW1pbGFyIGNoYXJhY3RlcnMsCisgKiBzZWN0aW9uSUQgPT0gU05fTUFQOiA8bWFwc3RyPgorICogPG1hcHN0cj4JIE4gYnl0ZXMgICAgU3RyaW5nIHdpdGggc2VxdWVuY2VzIG9mIHNpbWlsYXIgY2hhcmFjdGVycywKICAqCQkJICAgIHNlcGFyYXRlZCBieSBzbGFzaGVzLgogICoKKyAqIHNlY3Rpb25JRCA9PSBTTl9DT01QT1VORDogPGNvbXBtYXg+IDxjb21wbWlubGVuPiA8Y29tcHN5bG1heD4gPGNvbXBmbGFncz4KKyAqIDxjb21wbWF4PiAgICAgMSBieXRlCSAgICBNYXhpbXVtIG5yIG9mIHdvcmRzIGluIGNvbXBvdW5kIHdvcmQuCisgKiA8Y29tcG1pbmxlbj4gIDEgYnl0ZQkgICAgTWluaW1hbCB3b3JkIGxlbmd0aCBmb3IgY29tcG91bmRpbmcuCisgKiA8Y29tcHN5bG1heD4gIDEgYnl0ZQkgICAgTWF4aW11bSBuciBvZiBzeWxsYWJsZXMgaW4gY29tcG91bmQgd29yZC4KKyAqIDxjb21wZmxhZ3M+ICAgTiBieXRlcyAgICBGbGFncyBmcm9tIENPTVBPVU5ERkxBR1MgaXRlbXMsIHNlcGFyYXRlZCBieQorICoJCQkgICAgc2xhc2hlcy4KKyAqCisgKiBzZWN0aW9uSUQgPT0gU05fU1lMTEFCTEU6IDxzeWxsYWJsZT4KKyAqIDxzeWxsYWJsZT4gICAgTiBieXRlcyAgICBTdHJpbmcgZnJvbSBTWUxMQUJMRSBpdGVtLgogICoKICAqIDxMV09SRFRSRUU+OiA8d29yZHRyZWU+CiAgKgpAQCAtMzMzLDYgKzMzMSwxMiBAQAogdHlwZWRlZiBzaG9ydCBzYWxmaXJzdF9UOwogI2VuZGlmCiAKKy8qIFZhbHVlcyBmb3IgU1BfKkVSUk9SIGFyZSBuZWdhdGl2ZSwgcG9zaXRpdmUgdmFsdWVzIGFyZSB1c2VkIGJ5CisgKiByZWFkX2NudF9zdHJpbmcoKS4gKi8KKyNkZWZpbmUJU1BfVFJVTkNFUlJPUgktMQkvKiBzcGVsbCBmaWxlIHRydW5jYXRlZCBlcnJvciAqLworI2RlZmluZQlTUF9GT1JNRVJST1IJLTIJLyogZm9ybWF0IGVycm9yIGluIHNwZWxsIGZpbGUgKi8KKyNkZWZpbmUgU1BfRVJST1IJLTMJLyogb3RoZXIgZXJyb3Igd2hpbGUgcmVhZGluZyBzcGVsbCBmaWxlICovCisKIC8qCiAgKiBTdHJ1Y3R1cmUgdXNlZCB0byBzdG9yZSB3b3JkcyBhbmQgb3RoZXIgaW5mbyBmb3Igb25lIGxhbmd1YWdlLCBsb2FkZWQgZnJvbQogICogYSAuc3BsIGZpbGUuCkBAIC0zNjcsOCArMzcxLDE0IEBACiAKICAgICBjaGFyX3UJKnNsX21pZHdvcmQ7CS8qIE1JRFdPUkQgc3RyaW5nIG9yIE5VTEwgKi8KIAotICAgIGludAkJc2xfY29tcG1pbmxlbjsJLyogQ09NUE9VTkRNSU4gKi8KLSAgICBjaGFyX3UJKnNsX2NvbXBmbGFnczsJLyogQ09NUE9VTkRGTEFHUyAoTlVMTCB3aGVuIG5vIGNvbXBvdW5kaW5nKSAqLworICAgIGludAkJc2xfY29tcG1heDsJLyogQ09NUE9VTkRNQVggKGRlZmF1bHQ6IE1BWFdMRU4pICovCisgICAgaW50CQlzbF9jb21wbWlubGVuOwkvKiBDT01QT1VORE1JTiAoZGVmYXVsdDogTUFYV0xFTikgKi8KKyAgICBpbnQJCXNsX2NvbXBzeWxtYXg7CS8qIENPTVBPVU5EU1lMTUFYIChkZWZhdWx0OiBNQVhXTEVOKSAqLworICAgIHJlZ3Byb2dfVAkqc2xfY29tcHByb2c7CS8qIENPTVBPVU5ERkxBR1MgdHVybmVkIGludG8gYSByZWdleHAgcHJvZ3JtCisJCQkJICogKE5VTEwgd2hlbiBubyBjb21wb3VuZGluZykgKi8KKyAgICBjaGFyX3UJKnNsX2NvbXBzdGFydGZsYWdzOyAvKiBmbGFncyBmb3IgZmlyc3QgY29tcG91bmQgd29yZCAqLworICAgIGNoYXJfdQkqc2xfc3lsbGFibGU7CS8qIFNZTExBQkxFIHJlcGVhdGFibGUgY2hhcnMgb3IgTlVMTCAqLworICAgIGdhcnJheV9UCXNsX3N5bF9pdGVtczsJLyogc3lsbGFibGUgaXRlbXMgKi8KIAogICAgIGludAkJc2xfcHJlZml4Y250OwkvKiBudW1iZXIgb2YgaXRlbXMgaW4gInNsX3ByZWZwcm9nIiAqLwogICAgIHJlZ3Byb2dfVAkqKnNsX3ByZWZwcm9nOwkvKiB0YWJsZSB3aXRoIHJlZ3Byb2dzIGZvciBwcmVmaXhlcyAqLwpAQCAtNDAyLDcgKzQxMiw2IEBACiAjZGVmaW5lIFNBTF9GMExMT1dVUAkJMQogI2RlZmluZSBTQUxfQ09MTEFQU0UJCTIKICNkZWZpbmUgU0FMX1JFTV9BQ0NFTlRTCQk0Ci0jZGVmaW5lIFNBTF9TT0ZPCQk4ICAgLyogU09GT0ZST00gYW5kIFNPRk9UTyBpbnN0ZWFkIG9mIFNBTCAqLwogCiAvKgogICogU3RydWN0dXJlIHVzZWQgaW4gImJfbGFuZ3AiLCBmaWxsZWQgZnJvbSAnc3BlbGxsYW5nJy4KQEAgLTQxNyw2ICs0MjYsMjUgQEAKIAogI2RlZmluZSBSRUdJT05fQUxMIDB4ZmYJCS8qIHdvcmQgdmFsaWQgaW4gYWxsIHJlZ2lvbnMgKi8KIAorI2RlZmluZSBWSU1TUEVMTE1BR0lDICJWSU1zcGVsbCIgIC8qIHN0cmluZyBhdCBzdGFydCBvZiBWaW0gc3BlbGwgZmlsZSAqLworI2RlZmluZSBWSU1TUEVMTE1BR0lDTCA4CisjZGVmaW5lIFZJTVNQRUxMVkVSU0lPTiA1MAorCisvKiBTZWN0aW9uIElEcy4gIE9ubHkgcmVudW1iZXIgdGhlbSB3aGVuIFZJTVNQRUxMVkVSU0lPTiBjaGFuZ2VzISAqLworI2RlZmluZSBTTl9SRUdJT04JMAkvKiA8cmVnaW9ubmFtZT4gc2VjdGlvbiAqLworI2RlZmluZSBTTl9DSEFSRkxBR1MJMQkvKiBjaGFyZmxhZ3Mgc2VjdGlvbiAqLworI2RlZmluZSBTTl9NSURXT1JECTIJLyogPG1pZHdvcmQ+IHNlY3Rpb24gKi8KKyNkZWZpbmUgU05fUFJFRkNPTkQJMwkvKiA8cHJlZmNvbmQ+IHNlY3Rpb24gKi8KKyNkZWZpbmUgU05fUkVQCQk0CS8qIFJFUCBpdGVtcyBzZWN0aW9uICovCisjZGVmaW5lIFNOX1NBTAkJNQkvKiBTQUwgaXRlbXMgc2VjdGlvbiAqLworI2RlZmluZSBTTl9TT0ZPCQk2CS8qIHNvdW5kZm9sZGluZyBzZWN0aW9uICovCisjZGVmaW5lIFNOX01BUAkJNwkvKiBNQVAgaXRlbXMgc2VjdGlvbiAqLworI2RlZmluZSBTTl9DT01QT1VORAk4CS8qIGNvbXBvdW5kIHdvcmRzIHNlY3Rpb24gKi8KKyNkZWZpbmUgU05fU1lMTEFCTEUJOQkvKiBzeWxsYWJsZSBzZWN0aW9uICovCisjZGVmaW5lIFNOX0VORAkJMjU1CS8qIGVuZCBvZiBzZWN0aW9ucyAqLworCisjZGVmaW5lIFNORl9SRVFVSVJFRAkxCS8qIDxzZWN0aW9uZmxhZ3M+OiByZXF1aXJlZCBzZWN0aW9uICovCisKIC8qIFJlc3VsdCB2YWx1ZXMuICBMb3dlciBudW1iZXIgaXMgYWNjZXB0ZWQgb3ZlciBoaWdoZXIgb25lLiAqLwogI2RlZmluZSBTUF9CQU5ORUQJLTEKICNkZWZpbmUgU1BfT0sJCTAKQEAgLTQyNCw5ICs0NTIsNiBAQAogI2RlZmluZSBTUF9MT0NBTAkyCiAjZGVmaW5lIFNQX0JBRAkJMwogCi0jZGVmaW5lIFZJTVNQRUxMTUFHSUMgIlZJTXNwZWxsMTAiICAvKiBzdHJpbmcgYXQgc3RhcnQgb2YgVmltIHNwZWxsIGZpbGUgKi8KLSNkZWZpbmUgVklNU1BFTExNQUdJQ0wgMTAKLQogLyogZmlsZSB1c2VkIGZvciAiekciIGFuZCAielciICovCiBzdGF0aWMgY2hhcl91CSppbnRfd29yZGxpc3QgPSBOVUxMOwogCkBAIC00NzIsNyArNDk3LDcgQEAKIC8qIHNjb3JlIGZvciB2YXJpb3VzIGNoYW5nZXMgKi8KICNkZWZpbmUgU0NPUkVfU1BMSVQJMTQ5CS8qIHNwbGl0IGJhZCB3b3JkICovCiAjZGVmaW5lIFNDT1JFX0lDQVNFCTUyCS8qIHNsaWdodGx5IGRpZmZlcmVudCBjYXNlICovCi0jZGVmaW5lIFNDT1JFX1JFR0lPTgk3MAkvKiB3b3JkIGlzIGZvciBkaWZmZXJlbnQgcmVnaW9uICovCisjZGVmaW5lIFNDT1JFX1JFR0lPTgkyMDAJLyogd29yZCBpcyBmb3IgZGlmZmVyZW50IHJlZ2lvbiAqLwogI2RlZmluZSBTQ09SRV9SQVJFCTE4MAkvKiByYXJlIHdvcmQgKi8KICNkZWZpbmUgU0NPUkVfU1dBUAk5MAkvKiBzd2FwIHR3byBjaGFyYWN0ZXJzICovCiAjZGVmaW5lIFNDT1JFX1NXQVAzCTExMAkvKiBzd2FwIHR3byBjaGFyYWN0ZXJzIGluIHRocmVlICovCkBAIC01MjcsNiArNTUyLDggQEAKIAogICAgIC8qIGZvciB3aGVuIGNoZWNraW5nIGEgY29tcG91bmQgd29yZCAqLwogICAgIGludAkJbWlfY29tcG9mZjsJCS8qIHN0YXJ0IG9mIGZvbGxvd2luZyB3b3JkIG9mZnNldCAqLworICAgIGNoYXJfdQltaV9jb21wZmxhZ3NbTUFYV0xFTl07CS8qIGZsYWdzIGZvciBjb21wb3VuZCB3b3JkcyB1c2VkICovCisgICAgaW50CQltaV9jb21wbGVuOwkJLyogbnIgb2YgY29tcG91bmQgd29yZHMgdXNlZCAqLwogCiAgICAgLyogb3RoZXJzICovCiAgICAgaW50CQltaV9yZXN1bHQ7CQkvKiByZXN1bHQgc28gZmFyOiBTUF9CQUQsIFNQX09LLCBldGMuICovCkBAIC01NTksNyArNTg2LDcgQEAKICNpZmRlZiBGRUFUX01CWVRFCiBzdGF0aWMgaW50IHNwZWxsX2lzd29yZHBfdyBfX0FSR1MoKGludCAqcCwgYnVmX1QgKmJ1ZikpOwogI2VuZGlmCi1zdGF0aWMgdm9pZCB3cml0ZV9zcGVsbF9wcmVmY29uZCBfX0FSR1MoKEZJTEUgKmZkLCBnYXJyYXlfVCAqZ2FwKSk7CitzdGF0aWMgaW50IHdyaXRlX3NwZWxsX3ByZWZjb25kIF9fQVJHUygoRklMRSAqZmQsIGdhcnJheV9UICpnYXApKTsKIAogLyoKICAqIEZvciBmaW5kaW5nIHN1Z2dlc3Rpb25zOiBBdCBlYWNoIG5vZGUgaW4gdGhlIHRyZWUgdGhlc2Ugc3RhdGVzIGFyZSB0cmllZDoKQEAgLTYwOCw4ICs2MzUsOSBAQAogICAgIGNoYXJfdQl0c19pc2RpZmY7CS8qIERJRkZfIHZhbHVlcyAqLwogICAgIGNoYXJfdQl0c19mY2hhcnN0YXJ0OwkvKiBpbmRleCBpbiBmd29yZCB3aGVyZSBiYWR3b3JkIGNoYXIgc3RhcnRlZCAqLwogI2VuZGlmCi0gICAgY2hhcl91CXRzX3NhdmVfcHJld29yZGxlbjsgLyogc2F2ZWQgInByZXdvcmRsZW4iICovCi0gICAgY2hhcl91CXRzX3NhdmVfc3BsaXRvZmY7ICAgLyogc3Vfc3BsaXRvZmYgc2F2ZWQgaGVyZSAqLworICAgIGNoYXJfdQl0c19wcmV3b3JkbGVuOwkvKiBsZW5ndGggb2Ygd29yZCBpbiAicHJld29yZFtdIiAqLworICAgIGNoYXJfdQl0c19zcGxpdG9mZjsJLyogaW5kZXggaW4gInR3b3JkIiBhZnRlciBsYXN0IHNwbGl0ICovCisgICAgY2hhcl91CXRzX2NvbXBsZW47CS8qIG5yIG9mIGNvbXBvdW5kIHdvcmRzIHVzZWQgKi8KICAgICBjaGFyX3UJdHNfc2F2ZV9iYWRmbGFnczsgICAvKiBzdV9iYWRmbGFncyBzYXZlZCBoZXJlICovCiB9IHRyeXN0YXRlX1Q7CiAKQEAgLTYzNCw3ICs2NjIsNyBAQAogc3RhdGljIHZvaWQgc2xhbmdfZnJlZSBfX0FSR1MoKHNsYW5nX1QgKmxwKSk7CiBzdGF0aWMgdm9pZCBzbGFuZ19jbGVhciBfX0FSR1MoKHNsYW5nX1QgKmxwKSk7CiBzdGF0aWMgdm9pZCBmaW5kX3dvcmQgX19BUkdTKChtYXRjaGluZl9UICptaXAsIGludCBtb2RlKSk7Ci1zdGF0aWMgaW50IGNhbl9jb21wb3VuZCBfX0FSR1MoKHNsYW5nX1QgKnNsYW5nLCBpbnQgZmxhZ3MpKTsKK3N0YXRpYyBpbnQgY2FuX2NvbXBvdW5kIF9fQVJHUygoc2xhbmdfVCAqc2xhbmcsIGNoYXJfdSAqd29yZCwgY2hhcl91ICpmbGFncykpOwogc3RhdGljIGludCB2YWxpZF93b3JkX3ByZWZpeCBfX0FSR1MoKGludCB0b3RwcmVmY250LCBpbnQgYXJyaWR4LCBpbnQgZmxhZ3MsIGNoYXJfdSAqd29yZCwgc2xhbmdfVCAqc2xhbmcsIGludCBjb25kX3JlcSkpOwogc3RhdGljIHZvaWQgZmluZF9wcmVmaXggX19BUkdTKChtYXRjaGluZl9UICptaXApKTsKIHN0YXRpYyBpbnQgZm9sZF9tb3JlIF9fQVJHUygobWF0Y2hpbmZfVCAqbWlwKSk7CkBAIC02NDYsNiArNjc0LDE2IEBACiBzdGF0aWMgdm9pZCBzcGVsbF9sb2FkX2NiIF9fQVJHUygoY2hhcl91ICpmbmFtZSwgdm9pZCAqY29va2llKSk7CiBzdGF0aWMgc2xhbmdfVCAqc3BlbGxfbG9hZF9maWxlIF9fQVJHUygoY2hhcl91ICpmbmFtZSwgY2hhcl91ICpsYW5nLCBzbGFuZ19UICpvbGRfbHAsIGludCBzaWxlbnQpKTsKIHN0YXRpYyBjaGFyX3UgKnJlYWRfY250X3N0cmluZyBfX0FSR1MoKEZJTEUgKmZkLCBpbnQgY250X2J5dGVzLCBpbnQgKmxlbnApKTsKK3N0YXRpYyBjaGFyX3UgKnJlYWRfc3RyaW5nIF9fQVJHUygoRklMRSAqZmQsIGludCBjbnQpKTsKK3N0YXRpYyBpbnQgcmVhZF9yZWdpb25fc2VjdGlvbiBfX0FSR1MoKEZJTEUgKmZkLCBzbGFuZ19UICpzbGFuZywgaW50IGxlbikpOworc3RhdGljIGludCByZWFkX2NoYXJmbGFnc19zZWN0aW9uIF9fQVJHUygoRklMRSAqZmQpKTsKK3N0YXRpYyBpbnQgcmVhZF9wcmVmY29uZF9zZWN0aW9uIF9fQVJHUygoRklMRSAqZmQsIHNsYW5nX1QgKmxwKSk7CitzdGF0aWMgaW50IHJlYWRfcmVwX3NlY3Rpb24gX19BUkdTKChGSUxFICpmZCwgc2xhbmdfVCAqc2xhbmcpKTsKK3N0YXRpYyBpbnQgcmVhZF9zYWxfc2VjdGlvbiBfX0FSR1MoKEZJTEUgKmZkLCBzbGFuZ19UICpzbGFuZykpOworc3RhdGljIGludCByZWFkX3NvZm9fc2VjdGlvbiBfX0FSR1MoKEZJTEUgKmZkLCBzbGFuZ19UICpzbGFuZykpOworc3RhdGljIGludCByZWFkX2NvbXBvdW5kIF9fQVJHUygoRklMRSAqZmQsIHNsYW5nX1QgKnNsYW5nLCBpbnQgbGVuKSk7CitzdGF0aWMgaW50IGluaXRfc3lsX3RhYiBfX0FSR1MoKHNsYW5nX1QgKnNsYW5nKSk7CitzdGF0aWMgaW50IGNvdW50X3N5bGxhYmxlcyBfX0FSR1MoKHNsYW5nX1QgKnNsYW5nLCBjaGFyX3UgKndvcmQpKTsKIHN0YXRpYyBpbnQgc2V0X3NvZm8gX19BUkdTKChzbGFuZ19UICpscCwgY2hhcl91ICpmcm9tLCBjaGFyX3UgKnRvKSk7CiBzdGF0aWMgdm9pZCBzZXRfc2FsX2ZpcnN0IF9fQVJHUygoc2xhbmdfVCAqbHApKTsKICNpZmRlZiBGRUFUX01CWVRFCkBAIC02NTgsOSArNjk2LDggQEAKIHN0YXRpYyBpbnQgY2FwdHlwZSBfX0FSR1MoKGNoYXJfdSAqd29yZCwgY2hhcl91ICplbmQpKTsKIHN0YXRpYyBpbnQgYmFkd29yZF9jYXB0eXBlIF9fQVJHUygoY2hhcl91ICp3b3JkLCBjaGFyX3UgKmVuZCkpOwogc3RhdGljIHZvaWQgc3BlbGxfcmVsb2FkX29uZSBfX0FSR1MoKGNoYXJfdSAqZm5hbWUsIGludCBhZGRlZF93b3JkKSk7Ci1zdGF0aWMgaW50IHNldF9zcGVsbF9jaGFyZmxhZ3MgX19BUkdTKChjaGFyX3UgKmZsYWdzLCBpbnQgY250LCBjaGFyX3UgKnVwcCkpOworc3RhdGljIHZvaWQgc2V0X3NwZWxsX2NoYXJmbGFncyBfX0FSR1MoKGNoYXJfdSAqZmxhZ3MsIGludCBjbnQsIGNoYXJfdSAqdXBwKSk7CiBzdGF0aWMgaW50IHNldF9zcGVsbF9jaGFydGFiIF9fQVJHUygoY2hhcl91ICpmb2wsIGNoYXJfdSAqbG93LCBjaGFyX3UgKnVwcCkpOwotc3RhdGljIHZvaWQgd3JpdGVfc3BlbGxfY2hhcnRhYiBfX0FSR1MoKEZJTEUgKmZkKSk7CiBzdGF0aWMgaW50IHNwZWxsX2Nhc2Vmb2xkIF9fQVJHUygoY2hhcl91ICpwLCBpbnQgbGVuLCBjaGFyX3UgKmJ1ZiwgaW50IGJ1ZmxlbikpOwogc3RhdGljIGludCBjaGVja19uZWVkX2NhcCBfX0FSR1MoKGxpbmVucl9UIGxudW0sIGNvbG5yX1QgY29sKSk7CiBzdGF0aWMgdm9pZCBzcGVsbF9maW5kX3N1Z2dlc3QgX19BUkdTKChjaGFyX3UgKmJhZHB0ciwgc3VnaW5mb19UICpzdSwgaW50IG1heGNvdW50LCBpbnQgYmFuYmFkd29yZCwgaW50IG5lZWRfY2FwKSk7CkBAIC03NzcsMTEgKzgxNCwxMyBAQAogCQkJCSAgIGJlIHBhc3NlZCB0byBmdW5jdGlvbnMgcXVpY2tseS4gKi8KICAgICBpbnQJCW5ybGVuID0gMDsJLyogZm91bmQgYSBudW1iZXIgZmlyc3QgKi8KICAgICBpbnQJCWM7CisgICAgaW50CQl3cm9uZ2NhcGxlbiA9IDA7CiAKICAgICAvKiBBIHdvcmQgbmV2ZXIgc3RhcnRzIGF0IGEgc3BhY2Ugb3IgYSBjb250cm9sIGNoYXJhY3Rlci4gIFJldHVybiBxdWlja2x5CiAgICAgICogdGhlbiwgc2tpcHBpbmcgb3ZlciB0aGUgY2hhcmFjdGVyLiAqLwogICAgIGlmICgqcHRyIDw9ICcgJykKIAlyZXR1cm4gMTsKKyAgICB2aW1fbWVtc2V0KCZtaSwgMCwgc2l6ZW9mKG1hdGNoaW5mX1QpKTsKIAogICAgIC8qIEEgbnVtYmVyIGlzIGFsd2F5cyBPSy4gIEFsc28gc2tpcCBoZXhhZGVjaW1hbCBudW1iZXJzIDB4RkY5OSBhbmQKICAgICAgKiAwWDk5RkYuICBCdXQgd2hlbiBhIHdvcmQgY2hhcmFjdGVyIGZvbGxvd3MgZG8gY2hlY2sgc3BlbGxpbmcgdG8gZmluZApAQCAtODE4LDEwICs4NTcsNyBAQAogCSAgICAvKiBDaGVjayB3b3JkIHN0YXJ0aW5nIHdpdGggY2FwaXRhbCBsZXR0ZXIuICovCiAJICAgIGMgPSBQVFIyQ0hBUihwdHIpOwogCSAgICBpZiAoIVNQRUxMX0lTVVBQRVIoYykpCi0JICAgIHsKLQkJKmF0dHJwID0gaGlnaGxpZ2h0X2F0dHJbSExGX1NQQ107Ci0JCXJldHVybiAoaW50KShtaS5taV9mZW5kIC0gcHRyKTsKLQkgICAgfQorCQl3cm9uZ2NhcGxlbiA9IChpbnQpKG1pLm1pX2ZlbmQgLSBwdHIpOwogCX0KICAgICB9CiAgICAgaWYgKGNhcGNvbCAhPSBOVUxMKQpAQCAtODMyLDEyICs4NjgsMTAgQEAKICAgICBtaS5taV9lbmQgPSBtaS5taV9mZW5kOwogCiAgICAgLyogQ2hlY2sgY2FwcyB0eXBlIGxhdGVyLiAqLwotICAgIG1pLm1pX2NhcGZsYWdzID0gMDsKLSAgICBtaS5taV9jZW5kID0gTlVMTDsKICAgICBtaS5taV9idWYgPSB3cC0+d19idWZmZXI7CiAKLSAgICAvKiBJbmNsdWRlIG9uZSBub24td29yZCBjaGFyYWN0ZXIgc28gdGhhdCB3ZSBjYW4gY2hlY2sgZm9yIHRoZQotICAgICAqIHdvcmQgZW5kLiAqLworICAgIC8qIGNhc2UtZm9sZCB0aGUgd29yZCB3aXRoIG9uZSBub24td29yZCBjaGFyYWN0ZXIsIHNvIHRoYXQgd2UgY2FuIGNoZWNrCisgICAgICogZm9yIHRoZSB3b3JkIGVuZC4gKi8KICAgICBpZiAoKm1pLm1pX2ZlbmQgIT0gTlVMKQogCW1iX3B0cl9hZHYobWkubWlfZmVuZCk7CiAKQEAgLTg5Nyw2ICs5MzEsMTAgQEAKICNlbmRpZgogCSAgICByZXR1cm4gMTsKIAl9CisJZWxzZSBpZiAobWkubWlfZW5kID09IHB0cikKKwkgICAgLyogQWx3YXlzIGluY2x1ZGUgYXQgbGVhc3Qgb25lIGNoYXJhY3Rlci4gIFJlcXVpcmVkIGZvciB3aGVuIHRoZXJlCisJICAgICAqIGlzIGEgbWl4dXAgaW4gIm1pZHdvcmQiLiAqLworCSAgICBtYl9wdHJfYWR2KG1pLm1pX2VuZCk7CiAKIAlpZiAobWkubWlfcmVzdWx0ID09IFNQX0JBRCB8fCBtaS5taV9yZXN1bHQgPT0gU1BfQkFOTkVEKQogCSAgICAqYXR0cnAgPSBoaWdobGlnaHRfYXR0cltITEZfU1BCXTsKQEAgLTkwNiw2ICs5NDQsMTMgQEAKIAkgICAgKmF0dHJwID0gaGlnaGxpZ2h0X2F0dHJbSExGX1NQTF07CiAgICAgfQogCisgICAgaWYgKHdyb25nY2FwbGVuID4gMCAmJiAobWkubWlfcmVzdWx0ID09IFNQX09LIHx8IG1pLm1pX3Jlc3VsdCA9PSBTUF9SQVJFKSkKKyAgICB7CisJLyogUmVwb3J0IFNwZWxsQ2FwIG9ubHkgd2hlbiB0aGUgd29yZCBpc24ndCBiYWRseSBzcGVsbGVkLiAqLworCSphdHRycCA9IGhpZ2hsaWdodF9hdHRyW0hMRl9TUENdOworCXJldHVybiB3cm9uZ2NhcGxlbjsKKyAgICB9CisKICAgICByZXR1cm4gKGludCkobWkubWlfZW5kIC0gcHRyKTsKIH0KIApAQCAtMTA4NSw3ICsxMTMwLDcgQEAKICNlbmRpZgogCWlmIChzcGVsbF9pc3dvcmRwKHB0ciArIHdsZW4sIG1pcC0+bWlfYnVmKSkKIAl7Ci0JICAgIGlmIChzbGFuZy0+c2xfY29tcGZsYWdzID09IE5VTEwpCisJICAgIGlmIChzbGFuZy0+c2xfY29tcHByb2cgPT0gTlVMTCkKIAkJY29udGludWU7CSAgICAvKiBuZXh0IGNoYXIgaXMgYSB3b3JkIGNoYXJhY3RlciAqLwogCSAgICB3b3JkX2VuZHMgPSBGQUxTRTsKIAl9CkBAIC0xMTU3LDE2ICsxMjAyLDQ1IEBACiAJICAgIGlmIChtb2RlID09IEZJTkRfQ09NUE9VTkQgfHwgbW9kZSA9PSBGSU5EX0tFRVBDT01QT1VORAogCQkJCQkJCQl8fCAhd29yZF9lbmRzKQogCSAgICB7Ci0JCS8qIE1ha2VzIHlvdSB3b25kZXIgd2h5IHNvbWVvbmUgcHV0cyBhIGNvbXBvdW5kIGZsYWcgb24gYSB3b3JkCisJCS8qIElmIHRoZXJlIGlzIG5vICBmbGFnIG9yIHRoZSB3b3JkIGlzIHNob3J0ZXIgdGhhbgorCQkgKiBDT01QT1VORE1JTiByZWplY3QgaXQgcXVpY2tseS4KKwkJICogTWFrZXMgeW91IHdvbmRlciB3aHkgc29tZW9uZSBwdXRzIGEgY29tcG91bmQgZmxhZyBvbiBhIHdvcmQKIAkJICogdGhhdCdzIHRvbyBzaG9ydC4uLiAgTXlzcGVsbCBjb21wYXRpYmlsaXR5IHJlcXVpcmVzIHRoaXMKIAkJICogYW55d2F5LiAqLwotCQlpZiAod2xlbiA8IHNsYW5nLT5zbF9jb21wbWlubGVuKQorCQlpZiAoKCh1bnNpZ25lZClmbGFncyA+PiAyNCkgPT0gMCB8fCB3bGVuIDwgc2xhbmctPnNsX2NvbXBtaW5sZW4pCiAJCSAgICBjb250aW51ZTsKIAotCQkvKiBUaGUgd29yZCBkb2Vzbid0IGVuZCBvciBpdCBjb21lcyBhZnRlciBhbm90aGVyOiBpdCBtdXN0Ci0JCSAqIGhhdmUgYSBjb21wb3VuZCBmbGFnLiAqLwotCQlpZiAoIWNhbl9jb21wb3VuZChzbGFuZywgZmxhZ3MpKQorCQkvKiBMaW1pdCB0aGUgbnVtYmVyIG9mIGNvbXBvdW5kIHdvcmRzIHRvIENPTVBPVU5ETUFYLiAqLworCQlpZiAoIXdvcmRfZW5kcyAmJiBtaXAtPm1pX2NvbXBsZW4gKyAyID4gc2xhbmctPnNsX2NvbXBtYXgpCiAJCSAgICBjb250aW51ZTsKKworCQkvKiBBdCBzdGFydCBvZiB3b3JkIHF1aWNrbHkgY2hlY2sgaWYgY29tcG91bmRpbmcgaXMgcG9zc2libGUKKwkJICogd2l0aCB0aGlzIGZsYWcuICovCisJCWlmIChtaXAtPm1pX2NvbXBsZW4gPT0gMAorCQkJCSYmIHZpbV9zdHJjaHIoc2xhbmctPnNsX2NvbXBzdGFydGZsYWdzLAorCQkJCQkgICAgKCh1bnNpZ25lZClmbGFncyA+PiAyNCkpID09IE5VTEwpCisJCSAgICBjb250aW51ZTsKKworCQkvKiBJZiB0aGUgd29yZCBlbmRzIHRoZSBzZXF1ZW5jZSBvZiBjb21wb3VuZCBmbGFncyBvZiB0aGUKKwkJICogd29yZHMgbXVzdCBtYXRjaCB3aXRoIG9uZSBvZiB0aGUgQ09NUE9VTkRGTEFHUyBpdGVtcyBhbmQKKwkJICogdGhlIG51bWJlciBvZiBzeWxsYWJsZXMgbXVzdCBub3QgYmUgdG9vIGxhcmdlLiAqLworCQltaXAtPm1pX2NvbXBmbGFnc1ttaXAtPm1pX2NvbXBsZW5dID0gKCh1bnNpZ25lZClmbGFncyA+PiAyNCk7CisJCW1pcC0+bWlfY29tcGZsYWdzW21pcC0+bWlfY29tcGxlbiArIDFdID0gTlVMOworCQlpZiAod29yZF9lbmRzKQorCQl7CisJCSAgICBjaGFyX3UJZndvcmRbTUFYV0xFTl07CisKKwkJICAgIGlmIChzbGFuZy0+c2xfY29tcHN5bG1heCA8IE1BWFdMRU4pCisJCSAgICB7CisJCQkvKiAiZndvcmQiIGlzIG9ubHkgbmVlZGVkIGZvciBjaGVja2luZyBzeWxsYWJsZXMuICovCisJCQlpZiAocHRyID09IG1pcC0+bWlfd29yZCkKKwkJCSAgICAodm9pZClzcGVsbF9jYXNlZm9sZChwdHIsIHdsZW4sIGZ3b3JkLCBNQVhXTEVOKTsKKwkJCWVsc2UKKwkJCSAgICB2aW1fc3RybmNweShmd29yZCwgcHRyLCBlbmRsZW5bZW5kaWR4Y250XSk7CisJCSAgICB9CisJCSAgICBpZiAoIWNhbl9jb21wb3VuZChzbGFuZywgZndvcmQsIG1pcC0+bWlfY29tcGZsYWdzKSkKKwkJCWNvbnRpbnVlOworCQl9CiAJICAgIH0KIAogCSAgICBpZiAoIXdvcmRfZW5kcykKQEAgLTExOTMsMTMgKzEyNjcsMTcgQEAKIAkJICAgIH0KIAkJfQogI2VuZGlmCisJCSsrbWlwLT5taV9jb21wbGVuOwogCQlmaW5kX3dvcmQobWlwLCBGSU5EX0NPTVBPVU5EKTsKKwkJLS1taXAtPm1pX2NvbXBsZW47CiAJCWlmIChtaXAtPm1pX3Jlc3VsdCA9PSBTUF9PSykKIAkJICAgIGJyZWFrOwogCiAJCS8qIEZpbmQgZm9sbG93aW5nIHdvcmQgaW4ga2VlcC1jYXNlIHRyZWUuICovCiAJCW1pcC0+bWlfY29tcG9mZiA9IHdsZW47CisJCSsrbWlwLT5taV9jb21wbGVuOwogCQlmaW5kX3dvcmQobWlwLCBGSU5EX0tFRVBDT01QT1VORCk7CisJCS0tbWlwLT5taV9jb21wbGVuOwogCQlpZiAobWlwLT5taV9yZXN1bHQgPT0gU1BfT0spCiAJCSAgICBicmVhazsKIAkJY29udGludWU7CkBAIC0xMjM5LDE2ICsxMzE3LDI5IEBACiB9CiAKIC8qCi0gKiBSZXR1cm4gVFJVRSBpZiAiZmxhZ3MiIGhhcyBhIHZhbGlkIGNvbXBvdW5kIGZsYWcuCi0gKiBUT0RPOiBjaGVjayBmbGFncyBpbiBhIG1vcmUgYWR2YW5jZWQgd2F5LgorICogUmV0dXJuIFRSVUUgaWYgImZsYWdzIiBpcyBhIHZhbGlkIHNlcXVlbmNlIG9mIGNvbXBvdW5kIGZsYWdzIGFuZAorICogIndvcmRbbGVuXSIgZG9lcyBub3QgaGF2ZSB0b28gbWFueSBzeWxsYWJsZXMuCiAgKi8KICAgICBzdGF0aWMgaW50Ci1jYW5fY29tcG91bmQoc2xhbmcsIGZsYWdzKQorY2FuX2NvbXBvdW5kKHNsYW5nLCB3b3JkLCBmbGFncykKICAgICBzbGFuZ19UCSpzbGFuZzsKLSAgICBpbnQJCWZsYWdzOworICAgIGNoYXJfdQkqd29yZDsKKyAgICBjaGFyX3UJKmZsYWdzOwogewotICAgIHJldHVybiBzbGFuZy0+c2xfY29tcGZsYWdzICE9IE5VTEwKLQkJCSAgICYmICpzbGFuZy0+c2xfY29tcGZsYWdzID09ICgodW5zaWduZWQpZmxhZ3MgPj4gMjQpOworICAgIHJlZ21hdGNoX1QJcmVnbWF0Y2g7CisKKyAgICBpZiAoc2xhbmctPnNsX2NvbXBwcm9nID09IE5VTEwpCisJcmV0dXJuIEZBTFNFOworICAgIHJlZ21hdGNoLnJlZ3Byb2cgPSBzbGFuZy0+c2xfY29tcHByb2c7CisgICAgcmVnbWF0Y2gucm1faWMgPSBGQUxTRTsKKyAgICBpZiAoIXZpbV9yZWdleGVjKCZyZWdtYXRjaCwgZmxhZ3MsIDApKQorCXJldHVybiBGQUxTRTsKKworICAgIC8qIENvdW50IHRoZSBudW1iZXIgb2Ygc3lsbGFibGVzLiAgVGhpcyBtYXkgYmUgc2xvdywgZG8gaXQgbGFzdC4gKi8KKyAgICBpZiAoc2xhbmctPnNsX2NvbXBzeWxtYXggPCBNQVhXTEVOCisJCSAgICAgICAmJiBjb3VudF9zeWxsYWJsZXMoc2xhbmcsIHdvcmQpID4gc2xhbmctPnNsX2NvbXBzeWxtYXgpCisJcmV0dXJuIEZBTFNFOworICAgIHJldHVybiBUUlVFOwogfQogCiAvKgpAQCAtMTQ4MCw2ICsxNTcxLDggQEAKIC8qCiAgKiBNb3ZlIHRvIG5leHQgc3BlbGwgZXJyb3IuCiAgKiAiY3VybGluZSIgaXMgVFJVRSBmb3IgIno/IjogZmluZCB3b3JkIHVuZGVyL2FmdGVyIGN1cnNvciBpbiB0aGUgc2FtZSBsaW5lLgorICogRm9yIEluc2VydCBtb2RlIGNvbXBsZXRpb24gImRpciIgaXMgQkFDS1dBUkQgYW5kICJjdXJsaW5lIiBpcyBUUlVFOiBtb3ZlCisgKiB0byBhZnRlciBiYWRseSBzcGVsbGVkIHdvcmQgYmVmb3JlIHRoZSBjdXJzb3IuCiAgKiBSZXR1cm4gT0sgaWYgZm91bmQsIEZBSUwgb3RoZXJ3aXNlLgogICovCiAgICAgaW50CkBAIC0xNTk5LDYgKzE2OTIsMTAgQEAKIAkJCQl2aW1fZnJlZShidWYpOwogCQkJCXJldHVybiBPSzsKIAkJCSAgICB9CisJCQkgICAgZWxzZSBpZiAoY3VybGluZSkKKwkJCQkvKiBJbnNlcnQgbW9kZSBjb21wbGV0aW9uOiBwdXQgY3Vyc29yIGFmdGVyCisJCQkJICogdGhlIGJhZCB3b3JkLiAqLworCQkJCWZvdW5kX3Bvcy5jb2wgKz0gbGVuOwogCQkJfQogCQkgICAgfQogCQl9CkBAIC0xNjA5LDE5ICsxNzA2LDIwIEBACiAJICAgIGNhcGNvbCAtPSBsZW47CiAJfQogCisJaWYgKGRpciA9PSBCQUNLV0FSRCAmJiBmb3VuZF9wb3MubG51bSAhPSAwKQorCXsKKwkgICAgLyogVXNlIHRoZSBsYXN0IG1hdGNoIGluIHRoZSBsaW5lLiAqLworCSAgICBjdXJ3aW4tPndfY3Vyc29yID0gZm91bmRfcG9zOworCSAgICB2aW1fZnJlZShidWYpOworCSAgICByZXR1cm4gT0s7CisJfQorCiAJaWYgKGN1cmxpbmUpCiAJICAgIGJyZWFrOwkvKiBvbmx5IGNoZWNrIGN1cnNvciBsaW5lICovCiAKIAkvKiBBZHZhbmNlIHRvIG5leHQgbGluZS4gKi8KIAlpZiAoZGlyID09IEJBQ0tXQVJEKQogCXsKLQkgICAgaWYgKGZvdW5kX3Bvcy5sbnVtICE9IDApCi0JICAgIHsKLQkJLyogVXNlIHRoZSBsYXN0IG1hdGNoIGluIHRoZSBsaW5lLiAqLwotCQljdXJ3aW4tPndfY3Vyc29yID0gZm91bmRfcG9zOwotCQl2aW1fZnJlZShidWYpOwotCQlyZXR1cm4gT0s7Ci0JICAgIH0KIAkgICAgaWYgKGxudW0gPT0gMSkKIAkJYnJlYWs7CiAJICAgIC0tbG51bTsKQEAgLTE3MTUsOCArMTgxMyw4IEBACiAgICAgfQogCiAgICAgaWYgKHIgPT0gRkFJTCkKLQlzbXNnKChjaGFyX3UgKilfKCJXYXJuaW5nOiBDYW5ub3QgZmluZCB3b3JkIGxpc3QgXCIlc1wiIiksCi0JCQkJCQkJICAgICAgIGZuYW1lX2VuYyArIDYpOworCXNtc2coKGNoYXJfdSAqKV8oIldhcm5pbmc6IENhbm5vdCBmaW5kIHdvcmQgbGlzdCBcIiVzLiVzLnNwbFwiIG9yIFwiJXMuYXNjaWkuc3BsXCIiKSwKKwkJCQkJCSAgICAgbGFuZywgc3BlbGxfZW5jKCksIGxhbmcpOwogICAgIGVsc2UgaWYgKCpsYW5nY3AgIT0gTlVMKQogICAgIHsKIAkvKiBMb2FkIGFsbCB0aGUgYWRkaXRpb25zLiAqLwpAQCAtMTc2Nyw2ICsxODY1LDkgQEAKICAgICB7CiAJbHAtPnNsX25hbWUgPSB2aW1fc3Ryc2F2ZShsYW5nKTsKIAlnYV9pbml0MigmbHAtPnNsX3JlcCwgc2l6ZW9mKGZyb210b19UKSwgMTApOworCWxwLT5zbF9jb21wbWF4ID0gTUFYV0xFTjsKKwlscC0+c2xfY29tcG1pbmxlbiA9IE1BWFdMRU47CisJbHAtPnNsX2NvbXBzeWxtYXggPSBNQVhXTEVOOwogICAgIH0KICAgICByZXR1cm4gbHA7CiB9CkBAIC0xODUzLDggKzE5NTQsMTQgQEAKICAgICB2aW1fZnJlZShscC0+c2xfbWlkd29yZCk7CiAgICAgbHAtPnNsX21pZHdvcmQgPSBOVUxMOwogCi0gICAgdmltX2ZyZWUobHAtPnNsX2NvbXBmbGFncyk7Ci0gICAgbHAtPnNsX2NvbXBmbGFncyA9IE5VTEw7CisgICAgdmltX2ZyZWUobHAtPnNsX2NvbXBwcm9nKTsKKyAgICB2aW1fZnJlZShscC0+c2xfY29tcHN0YXJ0ZmxhZ3MpOworICAgIGxwLT5zbF9jb21wcHJvZyA9IE5VTEw7CisgICAgbHAtPnNsX2NvbXBzdGFydGZsYWdzID0gTlVMTDsKKworICAgIHZpbV9mcmVlKGxwLT5zbF9zeWxsYWJsZSk7CisgICAgbHAtPnNsX3N5bGxhYmxlID0gTlVMTDsKKyAgICBnYV9jbGVhcigmbHAtPnNsX3N5bF9pdGVtcyk7CiAKICNpZmRlZiBGRUFUX01CWVRFCiAgICAgewpAQCAtMTg3MCw2ICsxOTc3LDExIEBACiAgICAgfQogICAgIGhhc2hfY2xlYXIoJmxwLT5zbF9tYXBfaGFzaCk7CiAjZW5kaWYKKworICAgIGxwLT5zbF9jb21wbWF4ID0gTUFYV0xFTjsKKyAgICBscC0+c2xfY29tcG1pbmxlbiA9IE1BWFdMRU47CisgICAgbHAtPnNsX2NvbXBzeWxtYXggPSBNQVhXTEVOOworICAgIGxwLT5zbF9yZWdpb25zWzBdID0gTlVMOwogfQogCiAvKgpAQCAtMTkwMiw3ICsyMDE0LDcgQEAKICAgICBpbnQJCXNpbGVudDsJCS8qIG5vIGVycm9yIGlmIGZpbGUgZG9lc24ndCBleGlzdCAqLwogewogICAgIEZJTEUJKmZkOwotICAgIGNoYXJfdQlidWZbTUFYV0xFTiArIDFdOworICAgIGNoYXJfdQlidWZbVklNU1BFTExNQUdJQ0xdOwogICAgIGNoYXJfdQkqcDsKICAgICBjaGFyX3UJKmJwOwogICAgIGlkeF9UCSppcDsKQEAgLTE5MTIsMTUgKzIwMjQsMTAgQEAKICAgICBpbnQJCXJvdW5kOwogICAgIGNoYXJfdQkqc2F2ZV9zb3VyY2luZ19uYW1lID0gc291cmNpbmdfbmFtZTsKICAgICBsaW5lbnJfVAlzYXZlX3NvdXJjaW5nX2xudW0gPSBzb3VyY2luZ19sbnVtOwotICAgIGludAkJY250LCBjY250OwotICAgIGNoYXJfdQkqZm9sOwogICAgIHNsYW5nX1QJKmxwID0gTlVMTDsKLSAgICBnYXJyYXlfVAkqZ2FwOwotICAgIGZyb210b19UCSpmdHA7Ci0gICAgc2FsaXRlbV9UCSpzbXA7Ci0gICAgc2hvcnQJKmZpcnN0OwogICAgIGlkeF9UCWlkeDsKICAgICBpbnQJCWMgPSAwOworICAgIGludAkJcmVzOwogCiAgICAgZmQgPSBtY2hfZm9wZW4oKGNoYXIgKilmbmFtZSwgInIiKTsKICAgICBpZiAoZmQgPT0gTlVMTCkKQEAgLTE5NjQsMzMyICsyMDcxLDEyMiBAQAogICAgIHNvdXJjaW5nX2xudW0gPSAwOwogCiAgICAgLyogPEhFQURFUj46IDxmaWxlSUQ+Ci0gICAgICoJCTxyZWdpb25jbnQ+IDxyZWdpb25uYW1lPiAuLi4KLSAgICAgKgkJPGNoYXJmbGFnc2xlbj4gPGNoYXJmbGFncz4KLSAgICAgKgkJPGZjaGFyc2xlbj4gPGZjaGFycz4KLSAgICAgKgkJPG1pZHdvcmRsZW4+IDxtaWR3b3JkPgotICAgICAqCQk8Y29tcG91bmRsZW4+IDxjb21wb3VuZHR5cGU+IDxjb21wb3VuZGluZm8+Ci0gICAgICoJCTxwcmVmY29uZGNudD4gPHByZWZjb25kPiAuLi4KICAgICAgKi8KICAgICBmb3IgKGkgPSAwOyBpIDwgVklNU1BFTExNQUdJQ0w7ICsraSkKIAlidWZbaV0gPSBnZXRjKGZkKTsJCQkJLyogPGZpbGVJRD4gKi8KICAgICBpZiAoU1RSTkNNUChidWYsIFZJTVNQRUxMTUFHSUMsIFZJTVNQRUxMTUFHSUNMKSAhPSAwKQogICAgIHsKLQlFTVNHKF8oIkU3NTc6IFdyb25nIGZpbGUgSUQgaW4gc3BlbGwgZmlsZSIpKTsKKwlFTVNHKF8oIkU3NTc6IFRoaXMgZG9lcyBub3QgbG9vayBsaWtlIGEgc3BlbGwgZmlsZSIpKTsKKwlnb3RvIGVuZEZBSUw7CisgICAgfQorICAgIGMgPSBnZXRjKGZkKTsJCQkJCS8qIDx2ZXJzaW9ubnI+ICovCisgICAgaWYgKGMgPCBWSU1TUEVMTFZFUlNJT04pCisgICAgeworCUVNU0coXygiRTc3MTogT2xkIHNwZWxsIGZpbGUsIG5lZWRzIHRvIGJlIHVwZGF0ZWQiKSk7CisJZ290byBlbmRGQUlMOworICAgIH0KKyAgICBlbHNlIGlmIChjID4gVklNU1BFTExWRVJTSU9OKQorICAgIHsKKwlFTVNHKF8oIkU3NzI6IFNwZWxsIGZpbGUgaXMgZm9yIG5ld2VyIHZlcnNpb24gb2YgVmltIikpOwogCWdvdG8gZW5kRkFJTDsKICAgICB9CiAKLSAgICBjbnQgPSBnZXRjKGZkKTsJCQkJCS8qIDxyZWdpb25jbnQ+ICovCi0gICAgaWYgKGNudCA8IDApCisKKyAgICAvKgorICAgICAqIDxTRUNUSU9OUz46IDxzZWN0aW9uPiAuLi4gPHNlY3Rpb25lbmQ+CisgICAgICogPHNlY3Rpb24+OiA8c2VjdGlvbklEPiA8c2VjdGlvbmZsYWdzPiA8c2VjdGlvbmxlbj4gKHNlY3Rpb24gY29udGVudHMpCisgICAgICovCisgICAgZm9yICg7OykKICAgICB7Ci10cnVuY2VycjoKLQlFTVNHKF8oZV9zcGVsbF90cnVuYykpOwotCWdvdG8gZW5kRkFJTDsKLSAgICB9Ci0gICAgaWYgKGNudCA+IDgpCi0gICAgewotZm9ybWVycjoKLQlFTVNHKF8oZV9mb3JtYXQpKTsKLQlnb3RvIGVuZEZBSUw7Ci0gICAgfQotICAgIGZvciAoaSA9IDA7IGkgPCBjbnQ7ICsraSkKLSAgICB7Ci0JbHAtPnNsX3JlZ2lvbnNbaSAqIDJdID0gZ2V0YyhmZCk7CQkvKiA8cmVnaW9ubmFtZT4gKi8KLQlscC0+c2xfcmVnaW9uc1tpICogMiArIDFdID0gZ2V0YyhmZCk7Ci0gICAgfQotICAgIGxwLT5zbF9yZWdpb25zW2NudCAqIDJdID0gTlVMOworCW4gPSBnZXRjKGZkKTsJCQkgICAgLyogPHNlY3Rpb25JRD4gb3IgPHNlY3Rpb25lbmQ+ICovCisJaWYgKG4gPT0gU05fRU5EKQorCSAgICBicmVhazsKKwljID0gZ2V0YyhmZCk7CQkJCQkvKiA8c2VjdGlvbmZsYWdzPiAqLworCWxlbiA9IChnZXRjKGZkKSA8PCAyNCkgKyAoZ2V0YyhmZCkgPDwgMTYpICsgKGdldGMoZmQpIDw8IDgpICsgZ2V0YyhmZCk7CisJCQkJCQkJLyogPHNlY3Rpb25sZW4+ICovCisJaWYgKGxlbiA8IDApCisJICAgIGdvdG8gdHJ1bmNlcnI7CiAKLSAgICAvKiA8Y2hhcmZsYWdzbGVuPiA8Y2hhcmZsYWdzPiAqLwotICAgIHAgPSByZWFkX2NudF9zdHJpbmcoZmQsIDEsICZjbnQpOwotICAgIGlmIChjbnQgPCAwKQotCWdvdG8gZW5kRkFJTDsKLQotICAgIC8qIDxmY2hhcnNsZW4+IDxmY2hhcnM+ICovCi0gICAgZm9sID0gcmVhZF9jbnRfc3RyaW5nKGZkLCAyLCAmY2NudCk7Ci0gICAgaWYgKGNjbnQgPCAwKQotICAgIHsKLQl2aW1fZnJlZShwKTsKLQlnb3RvIGVuZEZBSUw7Ci0gICAgfQotCi0gICAgLyogU2V0IHRoZSB3b3JkLWNoYXIgZmxhZ3MgYW5kIGZpbGwgU1BFTExfSVNVUFBFUigpIHRhYmxlLiAqLwotICAgIGlmIChwICE9IE5VTEwgJiYgZm9sICE9IE5VTEwpCi0JaSA9IHNldF9zcGVsbF9jaGFyZmxhZ3MocCwgY250LCBmb2wpOwotCi0gICAgdmltX2ZyZWUocCk7Ci0gICAgdmltX2ZyZWUoZm9sKTsKLQotICAgIC8qIFdoZW4gPGNoYXJmbGFnc2xlbj4gaXMgemVybyB0aGVuIDxmY2hhcmxlbj4gbXVzdCBhbHNvIGJlIHplcm8uICovCi0gICAgaWYgKChwID09IE5VTEwpICE9IChmb2wgPT0gTlVMTCkpCi0JZ290byBmb3JtZXJyOwotCi0gICAgLyogPG1pZHdvcmRsZW4+IDxtaWR3b3JkPiAqLwotICAgIGxwLT5zbF9taWR3b3JkID0gcmVhZF9jbnRfc3RyaW5nKGZkLCAyLCAmY250KTsKLSAgICBpZiAoY250IDwgMCkKLQlnb3RvIGVuZEZBSUw7Ci0KLSAgICAvKiA8Y29tcG91bmRsZW4+IDxjb21wb3VuZHR5cGU+IDxjb21wb3VuZGluZm8+ICovCi0gICAgY250ID0gKGdldGMoZmQpIDw8IDgpICsgZ2V0YyhmZCk7CQkJLyogPGNvbXBvdW5kbGVuPiAqLwotICAgIGlmIChjbnQgPCAwKQotCWdvdG8gZW5kRkFJTDsKLSAgICBpZiAoY250ID4gMCkKLSAgICB7Ci0JLS1jbnQ7Ci0JYyA9IGdldGMoZmQpOwkJCQkJLyogPGNvbXBvdW5kdHlwZT4gKi8KLQlpZiAoYyAhPSAxKQorCXJlcyA9IDA7CisJc3dpdGNoIChuKQogCXsKLQkgICAgLyogVW5rbm93biBraW5kIG9mIGNvbXBvdW5kIHdvcmRzLCBza2lwIHRoZSBpbmZvLiAqLwotCSAgICB3aGlsZSAoY250LS0gPiAwKQotCQlnZXRjKGZkKTsKLQl9Ci0JZWxzZSBpZiAoY250IDwgMikKLQkgICAgZ290byBmb3JtZXJyOwotCWVsc2UKLQl7Ci0JICAgIC0tY250OwotCSAgICBjID0gZ2V0YyhmZCk7CQkJCS8qIDxjb21wMW1pbmxlbj4gKi8KLQkgICAgaWYgKGMgPCAxIHx8IGMgPiA1MCkKLQkJYyA9IDM7Ci0JICAgIGxwLT5zbF9jb21wbWlubGVuID0gYzsKKwkgICAgY2FzZSBTTl9SRUdJT046CisJCXJlcyA9IHJlYWRfcmVnaW9uX3NlY3Rpb24oZmQsIGxwLCBsZW4pOworCQlicmVhazsKIAotCSAgICBwID0gYWxsb2MoY250ICsgMSk7Ci0JICAgIGlmIChwID09IE5VTEwpCi0JCWdvdG8gZW5kRkFJTDsKLQkgICAgbHAtPnNsX2NvbXBmbGFncyA9IHA7Ci0JICAgIHdoaWxlIChjbnQtLSA+IDApCi0JCSpwKysgPSBnZXRjKGZkKTsJCQkvKiA8Y29tcDFmbGFncz4gKi8KLQkgICAgKnAgPSBOVUw7Ci0JfQotICAgIH0KKwkgICAgY2FzZSBTTl9DSEFSRkxBR1M6CisJCXJlcyA9IHJlYWRfY2hhcmZsYWdzX3NlY3Rpb24oZmQpOworCQlicmVhazsKIAorCSAgICBjYXNlIFNOX01JRFdPUkQ6CisJCWxwLT5zbF9taWR3b3JkID0gcmVhZF9zdHJpbmcoZmQsIGxlbik7CS8qIDxtaWR3b3JkPiAqLworCQlpZiAobHAtPnNsX21pZHdvcmQgPT0gTlVMTCkKKwkJICAgIGdvdG8gZW5kRkFJTDsKKwkJYnJlYWs7CiAKLSAgICAvKiA8cHJlZmNvbmRjbnQ+IDxwcmVmY29uZD4gLi4uICovCi0gICAgY250ID0gKGdldGMoZmQpIDw8IDgpICsgZ2V0YyhmZCk7CQkJLyogPHByZWZjb25kY250PiAqLwotICAgIGlmIChjbnQgPiAwKQotICAgIHsKLQlscC0+c2xfcHJlZnByb2cgPSAocmVncHJvZ19UICoqKWFsbG9jX2NsZWFyKAotCQkJCQkgKHVuc2lnbmVkKXNpemVvZihyZWdwcm9nX1QgKikgKiBjbnQpOwotCWlmIChscC0+c2xfcHJlZnByb2cgPT0gTlVMTCkKLQkgICAgZ290byBlbmRGQUlMOwotCWxwLT5zbF9wcmVmaXhjbnQgPSBjbnQ7CisJICAgIGNhc2UgU05fUFJFRkNPTkQ6CisJCXJlcyA9IHJlYWRfcHJlZmNvbmRfc2VjdGlvbihmZCwgbHApOworCQlicmVhazsKIAotCWZvciAoaSA9IDA7IGkgPCBjbnQ7ICsraSkKLQl7Ci0JICAgIC8qIDxwcmVmY29uZD4gOiA8Y29uZGxlbj4gPGNvbmRzdHI+ICovCi0JICAgIG4gPSBnZXRjKGZkKTsJCQkJLyogPGNvbmRsZW4+ICovCi0JICAgIGlmIChuIDwgMCB8fCBuID49IE1BWFdMRU4pCi0JCWdvdG8gZm9ybWVycjsKLQkgICAgLyogV2hlbiA8Y29uZGxlbj4gaXMgemVybyB3ZSBoYXZlIGFuIGVtcHR5IGNvbmRpdGlvbi4gIE90aGVyd2lzZQotCSAgICAgKiBjb21waWxlIHRoZSByZWdleHAgcHJvZ3JhbSB1c2VkIHRvIGNoZWNrIGZvciB0aGUgY29uZGl0aW9uLiAqLwotCSAgICBpZiAobiA+IDApCi0JICAgIHsKLQkJYnVmWzBdID0gJ14nOwkgICAgLyogYWx3YXlzIG1hdGNoIGF0IG9uZSBwb3NpdGlvbiBvbmx5ICovCi0JCXAgPSBidWYgKyAxOwotCQl3aGlsZSAobi0tID4gMCkKLQkJICAgICpwKysgPSBnZXRjKGZkKTsJCQkvKiA8Y29uZHN0cj4gKi8KLQkJKnAgPSBOVUw7Ci0JCWxwLT5zbF9wcmVmcHJvZ1tpXSA9IHZpbV9yZWdjb21wKGJ1ZiwgUkVfTUFHSUMgKyBSRV9TVFJJTkcpOwotCSAgICB9Ci0JfQotICAgIH0KKwkgICAgY2FzZSBTTl9SRVA6CisJCXJlcyA9IHJlYWRfcmVwX3NlY3Rpb24oZmQsIGxwKTsKKwkJYnJlYWs7CiAKKwkgICAgY2FzZSBTTl9TQUw6CisJCXJlcyA9IHJlYWRfc2FsX3NlY3Rpb24oZmQsIGxwKTsKKwkJYnJlYWs7CiAKLSAgICAvKiA8U1VHR0VTVD4gOiA8cmVwY291bnQ+IDxyZXA+IC4uLgotICAgICAqICAgICAgICAgICAgIDxzYWxmbGFncz4gPHNhbGNvdW50PiA8c2FsPiAuLi4KLSAgICAgKiAgICAgICAgICAgICA8bWFwbGVuPiA8bWFwc3RyPiAqLworCSAgICBjYXNlIFNOX1NPRk86CisJCXJlcyA9IHJlYWRfc29mb19zZWN0aW9uKGZkLCBscCk7CisJCWJyZWFrOwogCi0gICAgY250ID0gKGdldGMoZmQpIDw8IDgpICsgZ2V0YyhmZCk7CQkJLyogPHJlcGNvdW50PiAqLwotICAgIGlmIChjbnQgPCAwKQotCWdvdG8gZm9ybWVycjsKKwkgICAgY2FzZSBTTl9NQVA6CisJCXAgPSByZWFkX3N0cmluZyhmZCwgbGVuKTsJCS8qIDxtYXBzdHI+ICovCisJCWlmIChwID09IE5VTEwpCisJCSAgICBnb3RvIGVuZEZBSUw7CisJCXNldF9tYXBfc3RyKGxwLCBwKTsKKwkJdmltX2ZyZWUocCk7CisJCWJyZWFrOwogCi0gICAgZ2FwID0gJmxwLT5zbF9yZXA7Ci0gICAgaWYgKGdhX2dyb3coZ2FwLCBjbnQpID09IEZBSUwpCi0JZ290byBlbmRGQUlMOworCSAgICBjYXNlIFNOX0NPTVBPVU5EOgorCQlyZXMgPSByZWFkX2NvbXBvdW5kKGZkLCBscCwgbGVuKTsKKwkJYnJlYWs7CiAKLSAgICAvKiA8cmVwPiA6IDxyZXBmcm9tbGVuPiA8cmVwZnJvbT4gPHJlcHRvbGVuPiA8cmVwdG8+ICovCi0gICAgZm9yICg7IGdhcC0+Z2FfbGVuIDwgY250OyArK2dhcC0+Z2FfbGVuKQotICAgIHsKLQlmdHAgPSAmKChmcm9tdG9fVCAqKWdhcC0+Z2FfZGF0YSlbZ2FwLT5nYV9sZW5dOwotCWZ0cC0+ZnRfZnJvbSA9IHJlYWRfY250X3N0cmluZyhmZCwgMSwgJmkpOwotCWlmIChpIDw9IDApCi0JICAgIGdvdG8gZW5kRkFJTDsKLQlmdHAtPmZ0X3RvID0gcmVhZF9jbnRfc3RyaW5nKGZkLCAxLCAmaSk7Ci0JaWYgKGkgPD0gMCkKLQl7Ci0JICAgIHZpbV9mcmVlKGZ0cC0+ZnRfZnJvbSk7Ci0JICAgIGdvdG8gZW5kRkFJTDsKLQl9Ci0gICAgfQorCSAgICBjYXNlIFNOX1NZTExBQkxFOgorCQlscC0+c2xfc3lsbGFibGUgPSByZWFkX3N0cmluZyhmZCwgbGVuKTsJLyogPHN5bGxhYmxlPiAqLworCQlpZiAobHAtPnNsX3N5bGxhYmxlID09IE5VTEwpCisJCSAgICBnb3RvIGVuZEZBSUw7CisJCWlmIChpbml0X3N5bF90YWIobHApID09IEZBSUwpCisJCSAgICBnb3RvIGVuZEZBSUw7CisJCWJyZWFrOwogCi0gICAgLyogRmlsbCB0aGUgZmlyc3QtaW5kZXggdGFibGUuICovCi0gICAgZmlyc3QgPSBscC0+c2xfcmVwX2ZpcnN0OwotICAgIGZvciAoaSA9IDA7IGkgPCAyNTY7ICsraSkKLQlmaXJzdFtpXSA9IC0xOwotICAgIGZvciAoaSA9IDA7IGkgPCBnYXAtPmdhX2xlbjsgKytpKQotICAgIHsKLQlmdHAgPSAmKChmcm9tdG9fVCAqKWdhcC0+Z2FfZGF0YSlbaV07Ci0JaWYgKGZpcnN0WypmdHAtPmZ0X2Zyb21dID09IC0xKQotCSAgICBmaXJzdFsqZnRwLT5mdF9mcm9tXSA9IGk7Ci0gICAgfQotCi0gICAgaSA9IGdldGMoZmQpOwkJCQkvKiA8c2FsZmxhZ3M+ICovCi0gICAgaWYgKGkgJiBTQUxfRjBMTE9XVVApCi0JbHAtPnNsX2ZvbGxvd3VwID0gVFJVRTsKLSAgICBpZiAoaSAmIFNBTF9DT0xMQVBTRSkKLQlscC0+c2xfY29sbGFwc2UgPSBUUlVFOwotICAgIGlmIChpICYgU0FMX1JFTV9BQ0NFTlRTKQotCWxwLT5zbF9yZW1fYWNjZW50cyA9IFRSVUU7Ci0gICAgaWYgKGkgJiBTQUxfU09GTykKLQlscC0+c2xfc29mbyA9IFRSVUU7Ci0gICAgZWxzZQotCWxwLT5zbF9zb2ZvID0gRkFMU0U7Ci0KLSAgICBjbnQgPSAoZ2V0YyhmZCkgPDwgOCkgKyBnZXRjKGZkKTsJCS8qIDxzYWxjb3VudD4gKi8KLSAgICBpZiAoY250IDwgMCkKLQlnb3RvIGZvcm1lcnI7Ci0KLSAgICBpZiAobHAtPnNsX3NvZm8pCi0gICAgewotCS8qCi0JICogU09GT0ZST00gYW5kIFNPRk9UTyBpdGVtcyBjb21lIGluIG9uZSA8c2FsZnJvbT4gYW5kIDxzYWx0bz4KLQkgKi8KLQlpZiAoY250ICE9IDEpCi0JICAgIGdvdG8gZm9ybWVycjsKLQotCS8qIDxzYWxmcm9tbGVuPiA8c2FsZnJvbT4gKi8KLQlicCA9IHJlYWRfY250X3N0cmluZyhmZCwgMiwgJmNudCk7Ci0JaWYgKGNudCA8IDApCi0JICAgIGdvdG8gZW5kRkFJTDsKLQotCS8qIDxzYWx0b2xlbj4gPHNhbHRvPiAqLwotCWZvbCA9IHJlYWRfY250X3N0cmluZyhmZCwgMiwgJmNudCk7Ci0JaWYgKGNudCA8IDApCi0JewotCSAgICB2aW1fZnJlZShicCk7Ci0JICAgIGdvdG8gZW5kRkFJTDsKLQl9Ci0KLQkvKiBTdG9yZSB0aGUgaW5mbyBpbiBscC0+c2xfc2FsIGFuZC9vciBscC0+c2xfc2FsX2ZpcnN0LiAqLwotCWlmIChicCAhPSBOVUxMICYmIGZvbCAhPSBOVUxMKQotCSAgICBpID0gc2V0X3NvZm8obHAsIGJwLCBmb2wpOwotCWVsc2UgaWYgKGJwICE9IE5VTEwgfHwgZm9sICE9IE5VTEwpCi0JICAgIGkgPSBGQUlMOwkgICAgLyogb25seSBvbmUgb2YgdHdvIHN0cmluZ3MgaXMgYW4gZXJyb3IgKi8KLQllbHNlCi0JICAgIGkgPSBPSzsKLQotCXZpbV9mcmVlKGJwKTsKLQl2aW1fZnJlZShmb2wpOwotCWlmIChpID09IEZBSUwpCi0JICAgIGdvdG8gZm9ybWVycjsKLSAgICB9Ci0gICAgZWxzZQotICAgIHsKLQkvKgotCSAqIFNBTCBpdGVtcwotCSAqLwotCWdhcCA9ICZscC0+c2xfc2FsOwotCWdhX2luaXQyKGdhcCwgc2l6ZW9mKHNhbGl0ZW1fVCksIDEwKTsKLQlpZiAoZ2FfZ3JvdyhnYXAsIGNudCkgPT0gRkFJTCkKLQkgICAgZ290byBlbmRGQUlMOwotCi0JLyogPHNhbD4gOiA8c2FsZnJvbWxlbj4gPHNhbGZyb20+IDxzYWx0b2xlbj4gPHNhbHRvPiAqLwotCWZvciAoOyBnYXAtPmdhX2xlbiA8IGNudDsgKytnYXAtPmdhX2xlbikKLQl7Ci0JICAgIHNtcCA9ICYoKHNhbGl0ZW1fVCAqKWdhcC0+Z2FfZGF0YSlbZ2FwLT5nYV9sZW5dOwotCSAgICBjY250ID0gZ2V0YyhmZCk7CQkJLyogPHNhbGZyb21sZW4+ICovCi0JICAgIGlmIChjY250IDwgMCkKLQkJZ290byBmb3JtZXJyOwotCSAgICBpZiAoKHAgPSBhbGxvYyhjY250ICsgMikpID09IE5VTEwpCi0JCWdvdG8gZW5kRkFJTDsKLQkgICAgc21wLT5zbV9sZWFkID0gcDsKLQotCSAgICAvKiBSZWFkIHVwIHRvIHRoZSBmaXJzdCBzcGVjaWFsIGNoYXIgaW50byBzbV9sZWFkLiAqLwotCSAgICBmb3IgKGkgPSAwOyBpIDwgY2NudDsgKytpKQotCSAgICB7Ci0JCWMgPSBnZXRjKGZkKTsJCQkvKiA8c2FsZnJvbT4gKi8KLQkJaWYgKHZpbV9zdHJjaHIoKGNoYXJfdSAqKSIwMTIzNDU2Nzg5KC08XiQiLCBjKSAhPSBOVUxMKQotCQkgICAgYnJlYWs7Ci0JCSpwKysgPSBjOwotCSAgICB9Ci0JICAgIHNtcC0+c21fbGVhZGxlbiA9IHAgLSBzbXAtPnNtX2xlYWQ7Ci0JICAgICpwKysgPSBOVUw7Ci0KLQkgICAgLyogUHV0IChhYmMpIGNoYXJzIGluIHNtX29uZW9mLCBpZiBhbnkuICovCi0JICAgIGlmIChjID09ICcoJykKLQkgICAgewotCQlzbXAtPnNtX29uZW9mID0gcDsKLQkJZm9yICgrK2k7IGkgPCBjY250OyArK2kpCisJICAgIGRlZmF1bHQ6CisJCS8qIFVuc3VwcG9ydGVkIHNlY3Rpb24uICBXaGVuIGl0J3MgcmVxdWlyZWQgZ2l2ZSBhbiBlcnJvcgorCQkgKiBtZXNzYWdlLiAgV2hlbiBpdCdzIG5vdCByZXF1aXJlZCBza2lwIHRoZSBjb250ZW50cy4gKi8KKwkJaWYgKGMgJiBTTkZfUkVRVUlSRUQpCiAJCXsKLQkJICAgIGMgPSBnZXRjKGZkKTsJCQkvKiA8c2FsZnJvbT4gKi8KLQkJICAgIGlmIChjID09ICcpJykKLQkJCWJyZWFrOwotCQkgICAgKnArKyA9IGM7Ci0JCX0KLQkJKnArKyA9IE5VTDsKLQkJaWYgKCsraSA8IGNjbnQpCi0JCSAgICBjID0gZ2V0YyhmZCk7Ci0JICAgIH0KLQkgICAgZWxzZQotCQlzbXAtPnNtX29uZW9mID0gTlVMTDsKLQotCSAgICAvKiBBbnkgZm9sbG93aW5nIGNoYXJzIGdvIGluIHNtX3J1bGVzLiAqLwotCSAgICBzbXAtPnNtX3J1bGVzID0gcDsKLQkgICAgaWYgKGkgPCBjY250KQotCQkvKiBzdG9yZSB0aGUgY2hhciB3ZSBnb3Qgd2hpbGUgY2hlY2tpbmcgZm9yIGVuZCBvZiBzbV9sZWFkICovCi0JCSpwKysgPSBjOwotCSAgICBmb3IgKCsraTsgaSA8IGNjbnQ7ICsraSkKLQkJKnArKyA9IGdldGMoZmQpOwkJCS8qIDxzYWxmcm9tPiAqLwotCSAgICAqcCsrID0gTlVMOwotCi0JICAgIC8qIDxzYWx0b2xlbj4gPHNhbHRvPiAqLwotCSAgICBzbXAtPnNtX3RvID0gcmVhZF9jbnRfc3RyaW5nKGZkLCAxLCAmY2NudCk7Ci0JICAgIGlmIChjY250IDwgMCkKLQkgICAgewotCQl2aW1fZnJlZShzbXAtPnNtX2xlYWQpOwotCQlnb3RvIGZvcm1lcnI7Ci0JICAgIH0KLQotI2lmZGVmIEZFQVRfTUJZVEUKLQkgICAgaWYgKGhhc19tYnl0ZSkKLQkgICAgewotCQkvKiBjb252ZXJ0IHRoZSBtdWx0aS1ieXRlIHN0cmluZ3MgdG8gd2lkZSBjaGFyIHN0cmluZ3MgKi8KLQkJc21wLT5zbV9sZWFkX3cgPSBtYl9zdHIyd2lkZShzbXAtPnNtX2xlYWQpOwotCQlzbXAtPnNtX2xlYWRsZW4gPSBtYl9jaGFybGVuKHNtcC0+c21fbGVhZCk7Ci0JCWlmIChzbXAtPnNtX29uZW9mID09IE5VTEwpCi0JCSAgICBzbXAtPnNtX29uZW9mX3cgPSBOVUxMOwotCQllbHNlCi0JCSAgICBzbXAtPnNtX29uZW9mX3cgPSBtYl9zdHIyd2lkZShzbXAtPnNtX29uZW9mKTsKLQkJaWYgKHNtcC0+c21fdG8gPT0gTlVMTCkKLQkJICAgIHNtcC0+c21fdG9fdyA9IE5VTEw7Ci0JCWVsc2UKLQkJICAgIHNtcC0+c21fdG9fdyA9IG1iX3N0cjJ3aWRlKHNtcC0+c21fdG8pOwotCQlpZiAoc21wLT5zbV9sZWFkX3cgPT0gTlVMTAotCQkJfHwgKHNtcC0+c21fb25lb2ZfdyA9PSBOVUxMICYmIHNtcC0+c21fb25lb2YgIT0gTlVMTCkKLQkJCXx8IChzbXAtPnNtX3RvX3cgPT0gTlVMTCAmJiBzbXAtPnNtX3RvICE9IE5VTEwpKQotCQl7Ci0JCSAgICB2aW1fZnJlZShzbXAtPnNtX2xlYWQpOwotCQkgICAgdmltX2ZyZWUoc21wLT5zbV90byk7Ci0JCSAgICB2aW1fZnJlZShzbXAtPnNtX2xlYWRfdyk7Ci0JCSAgICB2aW1fZnJlZShzbXAtPnNtX29uZW9mX3cpOwotCQkgICAgdmltX2ZyZWUoc21wLT5zbV90b193KTsKKwkJICAgIEVNU0coXygiRTc3MDogVW5zdXBwb3J0ZWQgc2VjdGlvbiBpbiBzcGVsbCBmaWxlIikpOwogCQkgICAgZ290byBlbmRGQUlMOwogCQl9Ci0JICAgIH0KLSNlbmRpZgorCQl3aGlsZSAoLS1sZW4gPj0gMCkKKwkJICAgIGlmIChnZXRjKGZkKSA8IDApCisJCQlnb3RvIHRydW5jZXJyOworCQlicmVhazsKIAl9Ci0KLQkvKiBGaWxsIHRoZSBmaXJzdC1pbmRleCB0YWJsZS4gKi8KLQlzZXRfc2FsX2ZpcnN0KGxwKTsKLSAgICB9Ci0KLSAgICAvKiA8bWFwbGVuPiA8bWFwc3RyPiAqLwotICAgIHAgPSByZWFkX2NudF9zdHJpbmcoZmQsIDIsICZjbnQpOwotICAgIGlmIChjbnQgPCAwKQotCWdvdG8gZW5kRkFJTDsKLSAgICBpZiAocCAhPSBOVUxMKQotICAgIHsKLQlzZXRfbWFwX3N0cihscCwgcCk7Ci0JdmltX2ZyZWUocCk7CisJaWYgKHJlcyA9PSBTUF9GT1JNRVJST1IpCisJeworZm9ybWVycjoKKwkgICAgRU1TRyhfKGVfZm9ybWF0KSk7CisJICAgIGdvdG8gZW5kRkFJTDsKKwl9CisJaWYgKHJlcyA9PSBTUF9UUlVOQ0VSUk9SKQorCXsKK3RydW5jZXJyOgorCSAgICBFTVNHKF8oZV9zcGVsbF90cnVuYykpOworCSAgICBnb3RvIGVuZEZBSUw7CisJfQorCWlmIChyZXMgPT0gU1BfRVJST1IpCisJICAgIGdvdG8gZW5kRkFJTDsKICAgICB9CiAKICAgICAvKiByb3VuZCAxOiA8TFdPUkRUUkVFPgpAQCAtMjM2Nyw3ICsyMjY0LDggQEAKICAqIFJlYWQgYSBsZW5ndGggZmllbGQgZnJvbSAiZmQiIGluICJjbnRfYnl0ZXMiIGJ5dGVzLgogICogQWxsb2NhdGUgbWVtb3J5LCByZWFkIHRoZSBzdHJpbmcgaW50byBpdCBhbmQgYWRkIGEgTlVMIGF0IHRoZSBlbmQuCiAgKiBSZXR1cm5zIE5VTEwgd2hlbiB0aGUgY291bnQgaXMgemVyby4KLSAqIFNldHMgIipjbnRwIiB0byAtMSB3aGVuIHRoZXJlIGlzIGFuIGVycm9yLCBsZW5ndGggb2YgdGhlIHJlc3VsdCBvdGhlcndpc2UuCisgKiBTZXRzICIqY250cCIgdG8gU1BfKkVSUk9SIHdoZW4gdGhlcmUgaXMgYW4gZXJyb3IsIGxlbmd0aCBvZiB0aGUgcmVzdWx0CisgKiBvdGhlcndpc2UuCiAgKi8KICAgICBzdGF0aWMgY2hhcl91ICoKIHJlYWRfY250X3N0cmluZyhmZCwgY250X2J5dGVzLCBjbnRwKQpAQCAtMjM4NCwzMyArMjI4Miw2MDAgQEAKIAljbnQgPSAoY250IDw8IDgpICsgZ2V0YyhmZCk7CiAgICAgaWYgKGNudCA8IDApCiAgICAgewotCUVNU0coXyhlX3NwZWxsX3RydW5jKSk7Ci0JKmNudHAgPSAtMTsKKwkqY250cCA9IFNQX1RSVU5DRVJST1I7CiAJcmV0dXJuIE5VTEw7CiAgICAgfQogICAgICpjbnRwID0gY250OwogICAgIGlmIChjbnQgPT0gMCkKIAlyZXR1cm4gTlVMTDsJICAgIC8qIG5vdGhpbmcgdG8gcmVhZCwgcmV0dXJuIE5VTEwgKi8KIAotICAgIC8qIGFsbG9jYXRlIG1lbW9yeSAqLwotICAgIHN0ciA9IGFsbG9jKCh1bnNpZ25lZCljbnQgKyAxKTsKKyAgICBzdHIgPSByZWFkX3N0cmluZyhmZCwgY250KTsKICAgICBpZiAoc3RyID09IE5VTEwpCi0gICAgewotCSpjbnRwID0gLTE7Ci0JcmV0dXJuIE5VTEw7Ci0gICAgfQotCi0gICAgLyogUmVhZCB0aGUgc3RyaW5nLiAgRG9lc24ndCBjaGVjayBmb3IgdHJ1bmNhdGVkIGZpbGUuICovCi0gICAgZm9yIChpID0gMDsgaSA8IGNudDsgKytpKQotCXN0cltpXSA9IGdldGMoZmQpOwotICAgIHN0cltpXSA9IE5VTDsKLQorCSpjbnRwID0gU1BfRVJST1I7CiAgICAgcmV0dXJuIHN0cjsKIH0KIAogLyoKKyAqIFJlYWQgYSBzdHJpbmcgb2YgbGVuZ3RoICJjbnQiIGZyb20gImZkIiBpbnRvIGFsbG9jYXRlZCBtZW1vcnkuCisgKiBSZXR1cm5zIE5VTEwgd2hlbiBvdXQgb2YgbWVtb3J5LgorICovCisgICAgc3RhdGljIGNoYXJfdSAqCityZWFkX3N0cmluZyhmZCwgY250KQorICAgIEZJTEUJKmZkOworICAgIGludAkJY250OworeworICAgIGNoYXJfdQkqc3RyOworICAgIGludAkJaTsKKworICAgIC8qIGFsbG9jYXRlIG1lbW9yeSAqLworICAgIHN0ciA9IGFsbG9jKCh1bnNpZ25lZCljbnQgKyAxKTsKKyAgICBpZiAoc3RyICE9IE5VTEwpCisgICAgeworCS8qIFJlYWQgdGhlIHN0cmluZy4gIERvZXNuJ3QgY2hlY2sgZm9yIHRydW5jYXRlZCBmaWxlLiAqLworCWZvciAoaSA9IDA7IGkgPCBjbnQ7ICsraSkKKwkgICAgc3RyW2ldID0gZ2V0YyhmZCk7CisJc3RyW2ldID0gTlVMOworICAgIH0KKyAgICByZXR1cm4gc3RyOworfQorCisvKgorICogUmVhZCBTTl9SRUdJT046IDxyZWdpb25uYW1lPiAuLi4KKyAqIFJldHVybiBTUF8qRVJST1IgZmxhZ3MuCisgKi8KKyAgICBzdGF0aWMgaW50CityZWFkX3JlZ2lvbl9zZWN0aW9uKGZkLCBscCwgbGVuKQorICAgIEZJTEUJKmZkOworICAgIHNsYW5nX1QJKmxwOworICAgIGludAkJbGVuOworeworICAgIGludAkJaTsKKworICAgIGlmIChsZW4gPiAxNikKKwlyZXR1cm4gU1BfRk9STUVSUk9SOworICAgIGZvciAoaSA9IDA7IGkgPCBsZW47ICsraSkKKwlscC0+c2xfcmVnaW9uc1tpXSA9IGdldGMoZmQpOwkJCS8qIDxyZWdpb25uYW1lPiAqLworICAgIGxwLT5zbF9yZWdpb25zW2xlbl0gPSBOVUw7CisgICAgcmV0dXJuIDA7Cit9CisKKy8qCisgKiBSZWFkIFNOX0NIQVJGTEFHUyBzZWN0aW9uOiA8Y2hhcmZsYWdzbGVuPiA8Y2hhcmZsYWdzPgorICoJCQkJPGZvbGNoYXJzbGVuPiA8Zm9sY2hhcnM+CisgKiBSZXR1cm4gU1BfKkVSUk9SIGZsYWdzLgorICovCisgICAgc3RhdGljIGludAorcmVhZF9jaGFyZmxhZ3Nfc2VjdGlvbihmZCkKKyAgICBGSUxFCSpmZDsKK3sKKyAgICBjaGFyX3UJKmZsYWdzOworICAgIGNoYXJfdQkqZm9sOworICAgIGludAkJZmxhZ3NsZW4sIGZvbGxlbjsKKworICAgIC8qIDxjaGFyZmxhZ3NsZW4+IDxjaGFyZmxhZ3M+ICovCisgICAgZmxhZ3MgPSByZWFkX2NudF9zdHJpbmcoZmQsIDEsICZmbGFnc2xlbik7CisgICAgaWYgKGZsYWdzbGVuIDwgMCkKKwlyZXR1cm4gZmxhZ3NsZW47CisKKyAgICAvKiA8Zm9sY2hhcnNsZW4+IDxmb2xjaGFycz4gKi8KKyAgICBmb2wgPSByZWFkX2NudF9zdHJpbmcoZmQsIDIsICZmb2xsZW4pOworICAgIGlmIChmb2xsZW4gPCAwKQorICAgIHsKKwl2aW1fZnJlZShmbGFncyk7CisJcmV0dXJuIGZvbGxlbjsKKyAgICB9CisKKyAgICAvKiBTZXQgdGhlIHdvcmQtY2hhciBmbGFncyBhbmQgZmlsbCBTUEVMTF9JU1VQUEVSKCkgdGFibGUuICovCisgICAgaWYgKGZsYWdzICE9IE5VTEwgJiYgZm9sICE9IE5VTEwpCisJc2V0X3NwZWxsX2NoYXJmbGFncyhmbGFncywgZmxhZ3NsZW4sIGZvbCk7CisKKyAgICB2aW1fZnJlZShmbGFncyk7CisgICAgdmltX2ZyZWUoZm9sKTsKKworICAgIC8qIFdoZW4gPGNoYXJmbGFnc2xlbj4gaXMgemVybyB0aGVuIDxmY2hhcmxlbj4gbXVzdCBhbHNvIGJlIHplcm8uICovCisgICAgaWYgKChmbGFncyA9PSBOVUxMKSAhPSAoZm9sID09IE5VTEwpKQorCXJldHVybiBTUF9GT1JNRVJST1I7CisgICAgcmV0dXJuIDA7Cit9CisKKy8qCisgKiBSZWFkIFNOX1BSRUZDT05EIHNlY3Rpb24uCisgKiBSZXR1cm4gU1BfKkVSUk9SIGZsYWdzLgorICovCisgICAgc3RhdGljIGludAorcmVhZF9wcmVmY29uZF9zZWN0aW9uKGZkLCBscCkKKyAgICBGSUxFCSpmZDsKKyAgICBzbGFuZ19UCSpscDsKK3sKKyAgICBpbnQJCWNudDsKKyAgICBpbnQJCWk7CisgICAgaW50CQluOworICAgIGNoYXJfdQkqcDsKKyAgICBjaGFyX3UJYnVmW01BWFdMRU4gKyAxXTsKKworICAgIC8qIDxwcmVmY29uZGNudD4gPHByZWZjb25kPiAuLi4gKi8KKyAgICBjbnQgPSAoZ2V0YyhmZCkgPDwgOCkgKyBnZXRjKGZkKTsJCQkvKiA8cHJlZmNvbmRjbnQ+ICovCisgICAgaWYgKGNudCA8PSAwKQorCXJldHVybiBTUF9GT1JNRVJST1I7CisKKyAgICBscC0+c2xfcHJlZnByb2cgPSAocmVncHJvZ19UICoqKWFsbG9jX2NsZWFyKAorCQkJCQkgKHVuc2lnbmVkKXNpemVvZihyZWdwcm9nX1QgKikgKiBjbnQpOworICAgIGlmIChscC0+c2xfcHJlZnByb2cgPT0gTlVMTCkKKwlyZXR1cm4gU1BfRVJST1I7CisgICAgbHAtPnNsX3ByZWZpeGNudCA9IGNudDsKKworICAgIGZvciAoaSA9IDA7IGkgPCBjbnQ7ICsraSkKKyAgICB7CisJLyogPHByZWZjb25kPiA6IDxjb25kbGVuPiA8Y29uZHN0cj4gKi8KKwluID0gZ2V0YyhmZCk7CQkJCQkvKiA8Y29uZGxlbj4gKi8KKwlpZiAobiA8IDAgfHwgbiA+PSBNQVhXTEVOKQorCSAgICByZXR1cm4gU1BfRk9STUVSUk9SOworCisJLyogV2hlbiA8Y29uZGxlbj4gaXMgemVybyB3ZSBoYXZlIGFuIGVtcHR5IGNvbmRpdGlvbi4gIE90aGVyd2lzZQorCSAqIGNvbXBpbGUgdGhlIHJlZ2V4cCBwcm9ncmFtIHVzZWQgdG8gY2hlY2sgZm9yIHRoZSBjb25kaXRpb24uICovCisJaWYgKG4gPiAwKQorCXsKKwkgICAgYnVmWzBdID0gJ14nOwkgICAgLyogYWx3YXlzIG1hdGNoIGF0IG9uZSBwb3NpdGlvbiBvbmx5ICovCisJICAgIHAgPSBidWYgKyAxOworCSAgICB3aGlsZSAobi0tID4gMCkKKwkJKnArKyA9IGdldGMoZmQpOwkJCS8qIDxjb25kc3RyPiAqLworCSAgICAqcCA9IE5VTDsKKwkgICAgbHAtPnNsX3ByZWZwcm9nW2ldID0gdmltX3JlZ2NvbXAoYnVmLCBSRV9NQUdJQyArIFJFX1NUUklORyk7CisJfQorICAgIH0KKyAgICByZXR1cm4gMDsKK30KKworLyoKKyAqIFJlYWQgUkVQIGl0ZW1zIHNlY3Rpb24gZnJvbSAiZmQiOiA8cmVwY291bnQ+IDxyZXA+IC4uLgorICogUmV0dXJuIFNQXypFUlJPUiBmbGFncy4KKyAqLworICAgIHN0YXRpYyBpbnQKK3JlYWRfcmVwX3NlY3Rpb24oZmQsIHNsYW5nKQorICAgIEZJTEUJKmZkOworICAgIHNsYW5nX1QJKnNsYW5nOworeworICAgIGludAkJY250OworICAgIGdhcnJheV9UCSpnYXA7CisgICAgZnJvbXRvX1QJKmZ0cDsKKyAgICBzaG9ydAkqZmlyc3Q7CisgICAgaW50CQlpOworCisgICAgY250ID0gKGdldGMoZmQpIDw8IDgpICsgZ2V0YyhmZCk7CQkJLyogPHJlcGNvdW50PiAqLworICAgIGlmIChjbnQgPCAwKQorCXJldHVybiBTUF9UUlVOQ0VSUk9SOworCisgICAgZ2FwID0gJnNsYW5nLT5zbF9yZXA7CisgICAgaWYgKGdhX2dyb3coZ2FwLCBjbnQpID09IEZBSUwpCisJcmV0dXJuIFNQX0VSUk9SOworCisgICAgLyogPHJlcD4gOiA8cmVwZnJvbWxlbj4gPHJlcGZyb20+IDxyZXB0b2xlbj4gPHJlcHRvPiAqLworICAgIGZvciAoOyBnYXAtPmdhX2xlbiA8IGNudDsgKytnYXAtPmdhX2xlbikKKyAgICB7CisJZnRwID0gJigoZnJvbXRvX1QgKilnYXAtPmdhX2RhdGEpW2dhcC0+Z2FfbGVuXTsKKwlmdHAtPmZ0X2Zyb20gPSByZWFkX2NudF9zdHJpbmcoZmQsIDEsICZpKTsKKwlpZiAoaSA8IDApCisJICAgIHJldHVybiBpOworCWlmIChpID09IDApCisJICAgIHJldHVybiBTUF9GT1JNRVJST1I7CisJZnRwLT5mdF90byA9IHJlYWRfY250X3N0cmluZyhmZCwgMSwgJmkpOworCWlmIChpIDw9IDApCisJeworCSAgICB2aW1fZnJlZShmdHAtPmZ0X2Zyb20pOworCSAgICBpZiAoaSA8IDApCisJCXJldHVybiBpOworCSAgICByZXR1cm4gU1BfRk9STUVSUk9SOworCX0KKyAgICB9CisKKyAgICAvKiBGaWxsIHRoZSBmaXJzdC1pbmRleCB0YWJsZS4gKi8KKyAgICBmaXJzdCA9IHNsYW5nLT5zbF9yZXBfZmlyc3Q7CisgICAgZm9yIChpID0gMDsgaSA8IDI1NjsgKytpKQorCWZpcnN0W2ldID0gLTE7CisgICAgZm9yIChpID0gMDsgaSA8IGdhcC0+Z2FfbGVuOyArK2kpCisgICAgeworCWZ0cCA9ICYoKGZyb210b19UICopZ2FwLT5nYV9kYXRhKVtpXTsKKwlpZiAoZmlyc3RbKmZ0cC0+ZnRfZnJvbV0gPT0gLTEpCisJICAgIGZpcnN0WypmdHAtPmZ0X2Zyb21dID0gaTsKKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKKy8qCisgKiBSZWFkIFNOX1NBTCBzZWN0aW9uOiA8c2FsZmxhZ3M+IDxzYWxjb3VudD4gPHNhbD4gLi4uCisgKiBSZXR1cm4gU1BfKkVSUk9SIGZsYWdzLgorICovCisgICAgc3RhdGljIGludAorcmVhZF9zYWxfc2VjdGlvbihmZCwgc2xhbmcpCisgICAgRklMRQkqZmQ7CisgICAgc2xhbmdfVAkqc2xhbmc7Cit7CisgICAgaW50CQlpOworICAgIGludAkJY250OworICAgIGdhcnJheV9UCSpnYXA7CisgICAgc2FsaXRlbV9UCSpzbXA7CisgICAgaW50CQljY250OworICAgIGNoYXJfdQkqcDsKKyAgICBpbnQJCWM7CisKKyAgICBzbGFuZy0+c2xfc29mbyA9IEZBTFNFOworCisgICAgaSA9IGdldGMoZmQpOwkJCQkvKiA8c2FsZmxhZ3M+ICovCisgICAgaWYgKGkgJiBTQUxfRjBMTE9XVVApCisJc2xhbmctPnNsX2ZvbGxvd3VwID0gVFJVRTsKKyAgICBpZiAoaSAmIFNBTF9DT0xMQVBTRSkKKwlzbGFuZy0+c2xfY29sbGFwc2UgPSBUUlVFOworICAgIGlmIChpICYgU0FMX1JFTV9BQ0NFTlRTKQorCXNsYW5nLT5zbF9yZW1fYWNjZW50cyA9IFRSVUU7CisKKyAgICBjbnQgPSAoZ2V0YyhmZCkgPDwgOCkgKyBnZXRjKGZkKTsJCS8qIDxzYWxjb3VudD4gKi8KKyAgICBpZiAoY250IDwgMCkKKwlyZXR1cm4gU1BfVFJVTkNFUlJPUjsKKworICAgIGdhcCA9ICZzbGFuZy0+c2xfc2FsOworICAgIGdhX2luaXQyKGdhcCwgc2l6ZW9mKHNhbGl0ZW1fVCksIDEwKTsKKyAgICBpZiAoZ2FfZ3JvdyhnYXAsIGNudCkgPT0gRkFJTCkKKwlyZXR1cm4gU1BfRVJST1I7CisKKyAgICAvKiA8c2FsPiA6IDxzYWxmcm9tbGVuPiA8c2FsZnJvbT4gPHNhbHRvbGVuPiA8c2FsdG8+ICovCisgICAgZm9yICg7IGdhcC0+Z2FfbGVuIDwgY250OyArK2dhcC0+Z2FfbGVuKQorICAgIHsKKwlzbXAgPSAmKChzYWxpdGVtX1QgKilnYXAtPmdhX2RhdGEpW2dhcC0+Z2FfbGVuXTsKKwljY250ID0gZ2V0YyhmZCk7CQkJLyogPHNhbGZyb21sZW4+ICovCisJaWYgKGNjbnQgPCAwKQorCSAgICByZXR1cm4gU1BfVFJVTkNFUlJPUjsKKwlpZiAoKHAgPSBhbGxvYyhjY250ICsgMikpID09IE5VTEwpCisJICAgIHJldHVybiBTUF9FUlJPUjsKKwlzbXAtPnNtX2xlYWQgPSBwOworCisJLyogUmVhZCB1cCB0byB0aGUgZmlyc3Qgc3BlY2lhbCBjaGFyIGludG8gc21fbGVhZC4gKi8KKwlmb3IgKGkgPSAwOyBpIDwgY2NudDsgKytpKQorCXsKKwkgICAgYyA9IGdldGMoZmQpOwkJCS8qIDxzYWxmcm9tPiAqLworCSAgICBpZiAodmltX3N0cmNocigoY2hhcl91ICopIjAxMjM0NTY3ODkoLTxeJCIsIGMpICE9IE5VTEwpCisJCWJyZWFrOworCSAgICAqcCsrID0gYzsKKwl9CisJc21wLT5zbV9sZWFkbGVuID0gcCAtIHNtcC0+c21fbGVhZDsKKwkqcCsrID0gTlVMOworCisJLyogUHV0IChhYmMpIGNoYXJzIGluIHNtX29uZW9mLCBpZiBhbnkuICovCisJaWYgKGMgPT0gJygnKQorCXsKKwkgICAgc21wLT5zbV9vbmVvZiA9IHA7CisJICAgIGZvciAoKytpOyBpIDwgY2NudDsgKytpKQorCSAgICB7CisJCWMgPSBnZXRjKGZkKTsJCQkvKiA8c2FsZnJvbT4gKi8KKwkJaWYgKGMgPT0gJyknKQorCQkgICAgYnJlYWs7CisJCSpwKysgPSBjOworCSAgICB9CisJICAgICpwKysgPSBOVUw7CisJICAgIGlmICgrK2kgPCBjY250KQorCQljID0gZ2V0YyhmZCk7CisJfQorCWVsc2UKKwkgICAgc21wLT5zbV9vbmVvZiA9IE5VTEw7CisKKwkvKiBBbnkgZm9sbG93aW5nIGNoYXJzIGdvIGluIHNtX3J1bGVzLiAqLworCXNtcC0+c21fcnVsZXMgPSBwOworCWlmIChpIDwgY2NudCkKKwkgICAgLyogc3RvcmUgdGhlIGNoYXIgd2UgZ290IHdoaWxlIGNoZWNraW5nIGZvciBlbmQgb2Ygc21fbGVhZCAqLworCSAgICAqcCsrID0gYzsKKwlmb3IgKCsraTsgaSA8IGNjbnQ7ICsraSkKKwkgICAgKnArKyA9IGdldGMoZmQpOwkJCS8qIDxzYWxmcm9tPiAqLworCSpwKysgPSBOVUw7CisKKwkvKiA8c2FsdG9sZW4+IDxzYWx0bz4gKi8KKwlzbXAtPnNtX3RvID0gcmVhZF9jbnRfc3RyaW5nKGZkLCAxLCAmY2NudCk7CisJaWYgKGNjbnQgPCAwKQorCXsKKwkgICAgdmltX2ZyZWUoc21wLT5zbV9sZWFkKTsKKwkgICAgcmV0dXJuIGNjbnQ7CisJfQorCisjaWZkZWYgRkVBVF9NQllURQorCWlmIChoYXNfbWJ5dGUpCisJeworCSAgICAvKiBjb252ZXJ0IHRoZSBtdWx0aS1ieXRlIHN0cmluZ3MgdG8gd2lkZSBjaGFyIHN0cmluZ3MgKi8KKwkgICAgc21wLT5zbV9sZWFkX3cgPSBtYl9zdHIyd2lkZShzbXAtPnNtX2xlYWQpOworCSAgICBzbXAtPnNtX2xlYWRsZW4gPSBtYl9jaGFybGVuKHNtcC0+c21fbGVhZCk7CisJICAgIGlmIChzbXAtPnNtX29uZW9mID09IE5VTEwpCisJCXNtcC0+c21fb25lb2ZfdyA9IE5VTEw7CisJICAgIGVsc2UKKwkJc21wLT5zbV9vbmVvZl93ID0gbWJfc3RyMndpZGUoc21wLT5zbV9vbmVvZik7CisJICAgIGlmIChzbXAtPnNtX3RvID09IE5VTEwpCisJCXNtcC0+c21fdG9fdyA9IE5VTEw7CisJICAgIGVsc2UKKwkJc21wLT5zbV90b193ID0gbWJfc3RyMndpZGUoc21wLT5zbV90byk7CisJICAgIGlmIChzbXAtPnNtX2xlYWRfdyA9PSBOVUxMCisJCSAgICB8fCAoc21wLT5zbV9vbmVvZl93ID09IE5VTEwgJiYgc21wLT5zbV9vbmVvZiAhPSBOVUxMKQorCQkgICAgfHwgKHNtcC0+c21fdG9fdyA9PSBOVUxMICYmIHNtcC0+c21fdG8gIT0gTlVMTCkpCisJICAgIHsKKwkJdmltX2ZyZWUoc21wLT5zbV9sZWFkKTsKKwkJdmltX2ZyZWUoc21wLT5zbV90byk7CisJCXZpbV9mcmVlKHNtcC0+c21fbGVhZF93KTsKKwkJdmltX2ZyZWUoc21wLT5zbV9vbmVvZl93KTsKKwkJdmltX2ZyZWUoc21wLT5zbV90b193KTsKKwkJcmV0dXJuIFNQX0VSUk9SOworCSAgICB9CisJfQorI2VuZGlmCisgICAgfQorCisgICAgLyogRmlsbCB0aGUgZmlyc3QtaW5kZXggdGFibGUuICovCisgICAgc2V0X3NhbF9maXJzdChzbGFuZyk7CisKKyAgICByZXR1cm4gMDsKK30KKworLyoKKyAqIFNOX1NPRk86IDxzb2ZvZnJvbWxlbj4gPHNvZm9mcm9tPiA8c29mb3RvbGVuPiA8c29mb3RvPgorICogUmV0dXJuIFNQXypFUlJPUiBmbGFncy4KKyAqLworICAgIHN0YXRpYyBpbnQKK3JlYWRfc29mb19zZWN0aW9uKGZkLCBzbGFuZykKKyAgICBGSUxFCSpmZDsKKyAgICBzbGFuZ19UCSpzbGFuZzsKK3sKKyAgICBpbnQJCWNudDsKKyAgICBjaGFyX3UJKmZyb20sICp0bzsKKyAgICBpbnQJCXJlczsKKworICAgIHNsYW5nLT5zbF9zb2ZvID0gVFJVRTsKKworICAgIC8qIDxzb2ZvZnJvbWxlbj4gPHNvZm9mcm9tPiAqLworICAgIGZyb20gPSByZWFkX2NudF9zdHJpbmcoZmQsIDIsICZjbnQpOworICAgIGlmIChjbnQgPCAwKQorCXJldHVybiBjbnQ7CisKKyAgICAvKiA8c29mb3RvbGVuPiA8c29mb3RvPiAqLworICAgIHRvID0gcmVhZF9jbnRfc3RyaW5nKGZkLCAyLCAmY250KTsKKyAgICBpZiAoY250IDwgMCkKKyAgICB7CisJdmltX2ZyZWUoZnJvbSk7CisJcmV0dXJuIGNudDsKKyAgICB9CisKKyAgICAvKiBTdG9yZSB0aGUgaW5mbyBpbiBzbGFuZy0+c2xfc2FsIGFuZC9vciBzbGFuZy0+c2xfc2FsX2ZpcnN0LiAqLworICAgIGlmIChmcm9tICE9IE5VTEwgJiYgdG8gIT0gTlVMTCkKKwlyZXMgPSBzZXRfc29mbyhzbGFuZywgZnJvbSwgdG8pOworICAgIGVsc2UgaWYgKGZyb20gIT0gTlVMTCB8fCB0byAhPSBOVUxMKQorCXJlcyA9IFNQX0ZPUk1FUlJPUjsgICAgLyogb25seSBvbmUgb2YgdHdvIHN0cmluZ3MgaXMgYW4gZXJyb3IgKi8KKyAgICBlbHNlCisJcmVzID0gMDsKKworICAgIHZpbV9mcmVlKGZyb20pOworICAgIHZpbV9mcmVlKHRvKTsKKyAgICByZXR1cm4gcmVzOworfQorCisvKgorICogUmVhZCB0aGUgY29tcG91bmQgc2VjdGlvbiBmcm9tIHRoZSAuc3BsIGZpbGU6CisgKgk8Y29tcG1heD4gPGNvbXBtaW5sZW4+IDxjb21wc3lsbWF4PiA8Y29tcGZsYWdzPgorICogUmV0dXJucyBTUF8qRVJST1IgZmxhZ3MuCisgKi8KKyAgICBzdGF0aWMgaW50CityZWFkX2NvbXBvdW5kKGZkLCBzbGFuZywgbGVuKQorICAgIEZJTEUJKmZkOworICAgIHNsYW5nX1QJKnNsYW5nOworICAgIGludAkJbGVuOworeworICAgIGludAkJdG9kbyA9IGxlbjsKKyAgICBpbnQJCWM7CisgICAgaW50CQlhdHN0YXJ0OworICAgIGNoYXJfdQkqcGF0OworICAgIGNoYXJfdQkqcHA7CisgICAgY2hhcl91CSpjcDsKKworICAgIGlmICh0b2RvIDwgMikKKwlyZXR1cm4gU1BfRk9STUVSUk9SOwkvKiBuZWVkIGF0IGxlYXN0IHR3byBieXRlcyAqLworCisgICAgLS10b2RvOworICAgIGMgPSBnZXRjKGZkKTsJCQkJCS8qIDxjb21wbWF4PiAqLworICAgIGlmIChjIDwgMikKKwljID0gTUFYV0xFTjsKKyAgICBzbGFuZy0+c2xfY29tcG1heCA9IGM7CisKKyAgICAtLXRvZG87CisgICAgYyA9IGdldGMoZmQpOwkJCQkJLyogPGNvbXBtaW5sZW4+ICovCisgICAgaWYgKGMgPCAxKQorCWMgPSAzOworICAgIHNsYW5nLT5zbF9jb21wbWlubGVuID0gYzsKKworICAgIC0tdG9kbzsKKyAgICBjID0gZ2V0YyhmZCk7CQkJCQkvKiA8Y29tcHN5bG1heD4gKi8KKyAgICBpZiAoYyA8IDEpCisJYyA9IE1BWFdMRU47CisgICAgc2xhbmctPnNsX2NvbXBzeWxtYXggPSBjOworCisgICAgLyogVHVybiB0aGUgQ09NUE9VTkRGTEFHUyBpdGVtcyBpbnRvIGEgcmVnZXhwIHBhdHRlcm46CisgICAgICogImFbYmNdL2EqYisiIC0+ICJeXChhW2JjXVx8YSpiXCtcKSQiLgorICAgICAqIEluc2VydGluZyBiYWNrc2xhc2hlcyBtYXkgZG91YmxlIHRoZSBsZW5ndGgsICJeXChcKSQ8TnVsPiIgaXMgNyBieXRlcy4gKi8KKyAgICBwYXQgPSBhbGxvYygodW5zaWduZWQpdG9kbyAqIDIgKyA3KTsKKyAgICBpZiAocGF0ID09IE5VTEwpCisJcmV0dXJuIFNQX0VSUk9SOworCisgICAgLyogV2UgYWxzbyBuZWVkIGEgbGlzdCBvZiBhbGwgZmxhZ3MgdGhhdCBjYW4gYXBwZWFyIGF0IHRoZSBzdGFydC4gKi8KKyAgICBjcCA9IGFsbG9jKHRvZG8gKyAxKTsKKyAgICBpZiAoY3AgPT0gTlVMTCkKKyAgICB7CisJdmltX2ZyZWUocGF0KTsKKwlyZXR1cm4gU1BfRVJST1I7CisgICAgfQorICAgIHNsYW5nLT5zbF9jb21wc3RhcnRmbGFncyA9IGNwOworICAgICpjcCA9IE5VTDsKKworICAgIHBwID0gcGF0OworICAgICpwcCsrID0gJ14nOworICAgICpwcCsrID0gJ1xcJzsKKyAgICAqcHArKyA9ICcoJzsKKworICAgIGF0c3RhcnQgPSAxOworICAgIHdoaWxlICh0b2RvLS0gPiAwKQorICAgIHsKKwljID0gZ2V0YyhmZCk7CQkJCQkvKiA8Y29tcGZsYWdzPiAqLworCWlmIChhdHN0YXJ0ICE9IDApCisJeworCSAgICAvKiBBdCBzdGFydCBvZiBpdGVtOiBjb3B5IGZsYWdzIHRvICJzbF9jb21wc3RhcnRmbGFncyIuICBGb3IgYQorCSAgICAgKiBbYWJjXSBpdGVtIHNldCAiYXRzdGFydCIgdG8gMiBhbmQgY29weSB1cCB0byB0aGUgJ10nLiAqLworCSAgICBpZiAoYyA9PSAnWycpCisJCWF0c3RhcnQgPSAyOworCSAgICBlbHNlIGlmIChjID09ICddJykKKwkJYXRzdGFydCA9IDA7CisJICAgIGVsc2UKKwkgICAgeworCQlpZiAodmltX3N0cmNocihzbGFuZy0+c2xfY29tcHN0YXJ0ZmxhZ3MsIGMpID09IE5VTEwpCisJCXsKKwkJICAgICpjcCsrID0gYzsKKwkJICAgICpjcCA9IE5VTDsKKwkJfQorCQlpZiAoYXRzdGFydCA9PSAxKQorCQkgICAgYXRzdGFydCA9IDA7CisJICAgIH0KKwl9CisJaWYgKGMgPT0gJy8nKQkgICAgLyogc2xhc2ggc2VwYXJhdGVzIHR3byBpdGVtcyAqLworCXsKKwkgICAgKnBwKysgPSAnXFwnOworCSAgICAqcHArKyA9ICd8JzsKKwkgICAgYXRzdGFydCA9IDE7CisJfQorCWVsc2UJCSAgICAvKiBub3JtYWwgY2hhciwgIlthYmNdIiBhbmQgJyonIGFyZSBjb3BpZWQgYXMtaXMgKi8KKwl7CisJICAgIGlmIChjID09ICcrJykKKwkJKnBwKysgPSAnXFwnOwkgICAgLyogImErIiBiZWNvbWVzICJhXCsiICovCisJICAgICpwcCsrID0gYzsKKwl9CisgICAgfQorCisgICAgKnBwKysgPSAnXFwnOworICAgICpwcCsrID0gJyknOworICAgICpwcCsrID0gJyQnOworICAgICpwcCA9IE5VTDsKKworICAgIHNsYW5nLT5zbF9jb21wcHJvZyA9IHZpbV9yZWdjb21wKHBhdCwgUkVfTUFHSUMgKyBSRV9TVFJJTkcgKyBSRV9TVFJJQ1QpOworICAgIHZpbV9mcmVlKHBhdCk7CisgICAgaWYgKHNsYW5nLT5zbF9jb21wcHJvZyA9PSBOVUxMKQorCXJldHVybiBTUF9GT1JNRVJST1I7CisKKyAgICByZXR1cm4gMDsKK30KKworI2RlZmluZSBTWV9NQVhMRU4gICAzMAordHlwZWRlZiBzdHJ1Y3Qgc3lsX2l0ZW1fUworeworICAgIGNoYXJfdQlzeV9jaGFyc1tTWV9NQVhMRU5dOwkgICAgLyogdGhlIHNlcXVlbmNlIG9mIGNoYXJzICovCisgICAgaW50CQlzeV9sZW47Cit9IHN5bF9pdGVtX1Q7CisKKy8qCisgKiBUcnVuY2F0ZSAic2xhbmctPnNsX3N5bGxhYmxlIiBhdCB0aGUgZmlyc3Qgc2xhc2ggYW5kIHB1dCB0aGUgZm9sbG93aW5nIGl0ZW1zCisgKiBpbiAic2xhbmctPnNsX3N5bF9pdGVtcyIuCisgKi8KKyAgICBzdGF0aWMgaW50Citpbml0X3N5bF90YWIoc2xhbmcpCisgICAgc2xhbmdfVAkqc2xhbmc7Cit7CisgICAgY2hhcl91CSpwOworICAgIGNoYXJfdQkqczsKKyAgICBpbnQJCWw7CisgICAgc3lsX2l0ZW1fVAkqc3lsOworCisgICAgZ2FfaW5pdDIoJnNsYW5nLT5zbF9zeWxfaXRlbXMsIHNpemVvZihzeWxfaXRlbV9UKSwgNCk7CisgICAgcCA9IHZpbV9zdHJjaHIoc2xhbmctPnNsX3N5bGxhYmxlLCAnLycpOworICAgIHdoaWxlIChwICE9IE5VTEwpCisgICAgeworCSpwKysgPSBOVUw7CisJaWYgKHAgPT0gTlVMKQorCSAgICBicmVhazsKKwlzID0gcDsKKwlwID0gdmltX3N0cmNocihwLCAnLycpOworCWlmIChwID09IE5VTEwpCisJICAgIGwgPSBTVFJMRU4ocyk7CisJZWxzZQorCSAgICBsID0gcCAtIHM7CisJaWYgKGwgPj0gU1lfTUFYTEVOKQorCSAgICByZXR1cm4gU1BfRk9STUVSUk9SOworCWlmIChnYV9ncm93KCZzbGFuZy0+c2xfc3lsX2l0ZW1zLCAxKSA9PSBGQUlMKQorCSAgICByZXR1cm4gU1BfRVJST1I7CisJc3lsID0gKChzeWxfaXRlbV9UICopc2xhbmctPnNsX3N5bF9pdGVtcy5nYV9kYXRhKQorCQkJCQkgICAgICAgKyBzbGFuZy0+c2xfc3lsX2l0ZW1zLmdhX2xlbisrOworCXZpbV9zdHJuY3B5KHN5bC0+c3lfY2hhcnMsIHMsIGwpOworCXN5bC0+c3lfbGVuID0gbDsKKyAgICB9CisgICAgcmV0dXJuIE9LOworfQorCisvKgorICogQ291bnQgdGhlIG51bWJlciBvZiBzeWxsYWJsZXMgaW4gIndvcmQiLgorICogV2hlbiAid29yZCIgY29udGFpbnMgc3BhY2VzIHRoZSBzeWxsYWJsZXMgYWZ0ZXIgdGhlIGxhc3Qgc3BhY2UgYXJlIGNvdW50ZWQuCisgKiBSZXR1cm5zIHplcm8gaWYgc3lsbGFibGVzIGFyZSBub3QgZGVmaW5lcy4KKyAqLworICAgIHN0YXRpYyBpbnQKK2NvdW50X3N5bGxhYmxlcyhzbGFuZywgd29yZCkKKyAgICBzbGFuZ19UCSpzbGFuZzsKKyAgICBjaGFyX3UJKndvcmQ7Cit7CisgICAgaW50CQljbnQgPSAwOworICAgIGludAkJc2tpcCA9IEZBTFNFOworICAgIGNoYXJfdQkqcDsKKyAgICBpbnQJCWxlbjsKKyAgICBpbnQJCWk7CisgICAgc3lsX2l0ZW1fVAkqc3lsOworICAgIGludAkJYzsKKworICAgIGlmIChzbGFuZy0+c2xfc3lsbGFibGUgPT0gTlVMTCkKKwlyZXR1cm4gMDsKKworICAgIGZvciAocCA9IHdvcmQ7ICpwICE9IE5VTDsgcCArPSBsZW4pCisgICAgeworCS8qIFdoZW4gcnVubmluZyBpbnRvIGEgc3BhY2UgcmVzZXQgY291bnRlci4gKi8KKwlpZiAoKnAgPT0gJyAnKQorCXsKKwkgICAgbGVuID0gMTsKKwkgICAgY250ID0gMDsKKwkgICAgY29udGludWU7CisJfQorCisJLyogRmluZCBsb25nZXN0IG1hdGNoIG9mIHN5bGxhYmxlIGl0ZW1zLiAqLworCWxlbiA9IDA7CisJZm9yIChpID0gMDsgaSA8IHNsYW5nLT5zbF9zeWxfaXRlbXMuZ2FfbGVuOyArK2kpCisJeworCSAgICBzeWwgPSAoKHN5bF9pdGVtX1QgKilzbGFuZy0+c2xfc3lsX2l0ZW1zLmdhX2RhdGEpICsgaTsKKwkgICAgaWYgKHN5bC0+c3lfbGVuID4gbGVuCisJCQkgICAgICAgJiYgU1RSTkNNUChwLCBzeWwtPnN5X2NoYXJzLCBzeWwtPnN5X2xlbikgPT0gMCkKKwkJbGVuID0gc3lsLT5zeV9sZW47CisJfQorCWlmIChsZW4gIT0gMCkJLyogZm91bmQgYSBtYXRjaCwgY291bnQgc3lsbGFibGUgICovCisJeworCSAgICArK2NudDsKKwkgICAgc2tpcCA9IEZBTFNFOworCX0KKwllbHNlCisJeworCSAgICAvKiBObyByZWNvZ25pemVkIHN5bGxhYmxlIGl0ZW0sIGF0IGxlYXN0IGEgc3lsbGFibGUgY2hhciB0aGVuPyAqLworI2lmZGVmIEZFQVRfTUJZVEUKKwkgICAgYyA9IG1iX3B0cjJjaGFyKHApOworCSAgICBsZW4gPSAoKm1iX3B0cjJsZW4pKHApOworI2Vsc2UKKwkgICAgYyA9ICpwOworCSAgICBsZW4gPSAxOworI2VuZGlmCisJICAgIGlmICh2aW1fc3RyY2hyKHNsYW5nLT5zbF9zeWxsYWJsZSwgYykgPT0gTlVMTCkKKwkJc2tpcCA9IEZBTFNFOwkgICAgLyogTm8sIHNlYXJjaCBmb3IgbmV4dCBzeWxsYWJsZSAqLworCSAgICBlbHNlIGlmICghc2tpcCkKKwkgICAgeworCQkrK2NudDsJCSAgICAvKiBZZXMsIGNvdW50IGl0ICovCisJCXNraXAgPSBUUlVFOwkgICAgLyogZG9uJ3QgY291bnQgZm9sbG93aW5nIHN5bGxhYmxlIGNoYXJzICovCisJICAgIH0KKwl9CisgICAgfQorICAgIHJldHVybiBjbnQ7Cit9CisKKy8qCiAgKiBTZXQgdGhlIFNPRk9GUk9NIGFuZCBTT0ZPVE8gaXRlbXMgaW4gbGFuZ3VhZ2UgImxwIi4KLSAqIFJldHVybnMgRkFJTCB3aGVuIHRoZXJlIGlzIHNvbWV0aGluZyB3cm9uZy4KKyAqIFJldHVybnMgU1BfKkVSUk9SIGZsYWdzIHdoZW4gdGhlcmUgaXMgc29tZXRoaW5nIHdyb25nLgogICovCiAgICAgc3RhdGljIGludAogc2V0X3NvZm8obHAsIGZyb20sIHRvKQpAQCAtMjQzNiw3ICsyOTAxLDcgQEAKIAlnYXAgPSAmbHAtPnNsX3NhbDsKIAlnYV9pbml0MihnYXAsIHNpemVvZihpbnQgKiksIDEpOwogCWlmIChnYV9ncm93KGdhcCwgMjU2KSA9PSBGQUlMKQotCSAgICByZXR1cm4gRkFJTDsKKwkgICAgcmV0dXJuIFNQX0VSUk9SOwogCXZpbV9tZW1zZXQoZ2FwLT5nYV9kYXRhLCAwLCBzaXplb2YoaW50ICopICogMjU2KTsKIAlnYXAtPmdhX2xlbiA9IDI1NjsKIApAQCAtMjQ1MCw3ICsyOTE1LDcgQEAKIAkJKytscC0+c2xfc2FsX2ZpcnN0W2MgJiAweGZmXTsKIAl9CiAJaWYgKCpwICE9IE5VTCB8fCAqcyAhPSBOVUwpCSAgICAvKiBsZW5ndGhzIGRpZmZlciAqLwotCSAgICByZXR1cm4gRkFJTDsKKwkgICAgcmV0dXJuIFNQX0ZPUk1FUlJPUjsKIAogCS8qIEFsbG9jYXRlIHRoZSBsaXN0cy4gKi8KIAlmb3IgKGkgPSAwOyBpIDwgMjU2OyArK2kpCkBAIC0yNDU4LDcgKzI5MjMsNyBAQAogCSAgICB7CiAJCXAgPSBhbGxvYyhzaXplb2YoaW50KSAqIChscC0+c2xfc2FsX2ZpcnN0W2ldICogMiArIDEpKTsKIAkJaWYgKHAgPT0gTlVMTCkKLQkJICAgIHJldHVybiBGQUlMOworCQkgICAgcmV0dXJuIFNQX0VSUk9SOwogCQkoKGludCAqKilnYXAtPmdhX2RhdGEpW2ldID0gKGludCAqKXA7CiAJCSooaW50ICopcCA9IDA7CiAJICAgIH0KQEAgLTI0OTEsMTQgKzI5NTYsMTQgQEAKICAgICB7CiAJLyogbWFwcGluZyBieXRlcyB0byBieXRlcyBpcyBkb25lIGluIHNsX3NhbF9maXJzdFtdICovCiAJaWYgKFNUUkxFTihmcm9tKSAhPSBTVFJMRU4odG8pKQotCSAgICByZXR1cm4gRkFJTDsKKwkgICAgcmV0dXJuIFNQX0ZPUk1FUlJPUjsKIAogCWZvciAoaSA9IDA7IHRvW2ldICE9IE5VTDsgKytpKQogCSAgICBscC0+c2xfc2FsX2ZpcnN0W2Zyb21baV1dID0gdG9baV07CiAJbHAtPnNsX3NhbC5nYV9sZW4gPSAxOwkJLyogaW5kaWNhdGVzIHdlIGhhdmUgc291bmRmb2xkaW5nICovCiAgICAgfQogCi0gICAgcmV0dXJuIE9LOworICAgIHJldHVybiAwOwogfQogCiAvKgpAQCAtMzI0OCw4ICszNzEzLDEyIEBACiAgICAgaW50CQlhZl9yYXI7CQkvKiBSQVIgSUQgZm9yIHJhcmUgd29yZCAqLwogICAgIGludAkJYWZfa2VwOwkJLyogS0VQIElEIGZvciBrZWVwLWNhc2Ugd29yZCAqLwogICAgIGludAkJYWZfYmFkOwkJLyogQkFEIElEIGZvciBiYW5uZWQgd29yZCAqLwotICAgIGNoYXJfdQkqYWZfY29tcGZsYWdzOwkvKiBDT01QT1VOREZMQUcgb3IgQ09NUE9VTkRGTEFHUyAqLworICAgIGludAkJYWZfbmVlZGFmZml4OwkvKiBORUVEQUZGSVggSUQgKi8KKyAgICBjaGFyX3UJKmFmX2NvbXBmbGFnczsJLyogQ09NUE9VTkRGTEFHIGFuZCBDT01QT1VOREZMQUdTIGNvbmNhdCdlZCAqLworICAgIGludAkJYWZfY29tcG1heDsJLyogQ09NUE9VTkRNQVggKi8KICAgICBpbnQJCWFmX2NvbXBtaW5sZW47CS8qIENPTVBPVU5ETUlOICovCisgICAgaW50CQlhZl9jb21wc3lsbWF4OwkvKiBDT01QT1VORFNZTE1BWCAqLworICAgIGNoYXJfdQkqYWZfc3lsbGFibGU7CS8qIFNZTExBQkxFICovCiAgICAgaW50CQlhZl9wZnhwb3N0cG9uZTsJLyogcG9zdHBvbmUgcHJlZml4ZXMgd2l0aG91dCBjaG9wIHN0cmluZyAqLwogICAgIGhhc2h0YWJfVAlhZl9wcmVmOwkvKiBoYXNodGFibGUgZm9yIHByZWZpeGVzLCBhZmZoZWFkZXJfVCAqLwogICAgIGhhc2h0YWJfVAlhZl9zdWZmOwkvKiBoYXNodGFibGUgZm9yIHN1ZmZpeGVzLCBhZmZoZWFkZXJfVCAqLwpAQCAtMzI2NCw3ICszNzMzLDggQEAKICAgICBjaGFyX3UJKmFlX2FkZDsJLyogdGV4dCB0byBhZGQgdG8gYmFzaWMgd29yZCAoY2FuIGJlIE5VTEwpICovCiAgICAgY2hhcl91CSphZV9jb25kOwkvKiBjb25kaXRpb24gKE5VTEwgZm9yICIuIikgKi8KICAgICByZWdwcm9nX1QJKmFlX3Byb2c7CS8qIHJlZ2V4cCBwcm9ncmFtIGZvciBhZV9jb25kIG9yIE5VTEwgKi8KLSAgICBpbnQJCWFlX3JhcmU7CS8qIHJhcmUgYWZmaXggKi8KKyAgICBjaGFyX3UJYWVfcmFyZTsJLyogcmFyZSBhZmZpeCAqLworICAgIGNoYXJfdQlhZV9ub2NvbXA7CS8qIHdvcmQgd2l0aCBhZmZpeCBub3QgY29tcG91bmRhYmxlICovCiB9OwogCiAjZGVmaW5lIEFIX0tFWV9MRU4gMTAKQEAgLTMzNzMsNyArMzg0Myw4IEBACiAgICAgaW50CQlzaV9tc2dfY291bnQ7CS8qIG51bWJlciBvZiB3b3JkcyBhZGRlZCBzaW5jZSBsYXN0IG1lc3NhZ2UgKi8KICAgICBpbnQJCXNpX3JlZ2lvbl9jb3VudDsgLyogbnVtYmVyIG9mIHJlZ2lvbnMgc3VwcG9ydGVkICgxIHdoZW4gdGhlcmUKIAkJCQkgICAgYXJlIG5vIHJlZ2lvbnMpICovCi0gICAgY2hhcl91CXNpX3JlZ2lvbl9uYW1lWzE2XTsgLyogcmVnaW9uIG5hbWVzIChpZiBjb3VudCA+IDEpICovCisgICAgY2hhcl91CXNpX3JlZ2lvbl9uYW1lWzE2XTsgLyogcmVnaW9uIG5hbWVzOyB1c2VkIG9ubHkgaWYKKwkJCQkgICAgICogc2lfcmVnaW9uX2NvdW50ID4gMSkgKi8KIAogICAgIGdhcnJheV9UCXNpX3JlcDsJCS8qIGxpc3Qgb2YgZnJvbXRvX1QgZW50cmllcyBmcm9tIFJFUCBsaW5lcyAqLwogICAgIGdhcnJheV9UCXNpX3NhbDsJCS8qIGxpc3Qgb2YgZnJvbXRvX1QgZW50cmllcyBmcm9tIFNBTCBsaW5lcyAqLwpAQCAtMzM4NCw4ICszODU1LDExIEBACiAgICAgaW50CQlzaV9yZW1fYWNjZW50czsJLyogc291bmRzYWxpa2U6IHJlbW92ZSBhY2NlbnRzICovCiAgICAgZ2FycmF5X1QJc2lfbWFwOwkJLyogTUFQIGluZm8gY29uY2F0ZW5hdGVkICovCiAgICAgY2hhcl91CSpzaV9taWR3b3JkOwkvKiBNSURXT1JEIGNoYXJzLCBhbGxvYydlZCBzdHJpbmcgb3IgTlVMTCAgKi8KKyAgICBpbnQJCXNpX2NvbXBtYXg7CS8qIG1heCBuciBvZiB3b3JkcyBmb3IgY29tcG91bmRpbmcgKi8KICAgICBpbnQJCXNpX2NvbXBtaW5sZW47CS8qIG1pbmltYWwgbGVuZ3RoIGZvciBjb21wb3VuZGluZyAqLworICAgIGludAkJc2lfY29tcHN5bG1heDsJLyogbWF4IG5yIG9mIHN5bGxhYmxlcyBmb3IgY29tcG91bmRpbmcgKi8KICAgICBjaGFyX3UJKnNpX2NvbXBmbGFnczsJLyogZmxhZ3MgdXNlZCBmb3IgY29tcG91bmRpbmcgKi8KKyAgICBjaGFyX3UJKnNpX3N5bGxhYmxlOwkvKiBzeWxsYWJsZSBzdHJpbmcgKi8KICAgICBnYXJyYXlfVAlzaV9wcmVmY29uZDsJLyogdGFibGUgd2l0aCBjb25kaXRpb25zIGZvciBwb3N0cG9uZWQKIAkJCQkgKiBwcmVmaXhlcywgZWFjaCBzdG9yZWQgYXMgYSBzdHJpbmcgKi8KICAgICBpbnQJCXNpX25ld0lEOwkvKiBjdXJyZW50IHZhbHVlIGZvciBhaF9uZXdJRCAqLwpAQCAtMzM5OCwxNSArMzg3MiwxNSBAQAogc3RhdGljIGludCBoYXNfbm9uX2FzY2lpIF9fQVJHUygoY2hhcl91ICpzKSk7CiBzdGF0aWMgdm9pZCBzcGVsbF9mcmVlX2FmZiBfX0FSR1MoKGFmZmZpbGVfVCAqYWZmKSk7CiBzdGF0aWMgaW50IHNwZWxsX3JlYWRfZGljIF9fQVJHUygoc3BlbGxpbmZvX1QgKnNwaW4sIGNoYXJfdSAqZm5hbWUsIGFmZmZpbGVfVCAqYWZmaWxlKSk7Ci1zdGF0aWMgY2hhcl91ICpnZXRfcGZ4bGlzdCBfX0FSR1MoKHNwZWxsaW5mb19UICpzcGluLCBhZmZmaWxlX1QgKmFmZmlsZSwgY2hhcl91ICphZmZsaXN0KSk7Ci1zdGF0aWMgY2hhcl91ICpnZXRfY29tcGZsYWdzIF9fQVJHUygoc3BlbGxpbmZvX1QgKnNwaW4sIGNoYXJfdSAqYWZmbGlzdCkpOwotc3RhdGljIGludCBzdG9yZV9hZmZfd29yZCBfX0FSR1MoKHNwZWxsaW5mb19UICpzcGluLCBjaGFyX3UgKndvcmQsIGNoYXJfdSAqYWZmbGlzdCwgYWZmZmlsZV9UICphZmZpbGUsIGhhc2h0YWJfVCAqaHQsIGhhc2h0YWJfVCAqeGh0LCBpbnQgY29tYiwgaW50IGZsYWdzLCBjaGFyX3UgKnBmeGxpc3QpKTsKK3N0YXRpYyBpbnQgZ2V0X3BmeGxpc3QgX19BUkdTKChhZmZmaWxlX1QgKmFmZmlsZSwgY2hhcl91ICphZmZsaXN0LCBjaGFyX3UgKnN0b3JlX2FmZmxpc3QpKTsKK3N0YXRpYyB2b2lkIGdldF9jb21wZmxhZ3MgX19BUkdTKChzcGVsbGluZm9fVCAqc3BpbiwgY2hhcl91ICphZmZsaXN0LCBjaGFyX3UgKnN0b3JlX2FmZmxpc3QpKTsKK3N0YXRpYyBpbnQgc3RvcmVfYWZmX3dvcmQgX19BUkdTKChzcGVsbGluZm9fVCAqc3BpbiwgY2hhcl91ICp3b3JkLCBjaGFyX3UgKmFmZmxpc3QsIGFmZmZpbGVfVCAqYWZmaWxlLCBoYXNodGFiX1QgKmh0LCBoYXNodGFiX1QgKnhodCwgaW50IGNvbWIsIGludCBmbGFncywgY2hhcl91ICpwZnhsaXN0LCBpbnQgcGZ4bGVuKSk7CiBzdGF0aWMgaW50IHNwZWxsX3JlYWRfd29yZGZpbGUgX19BUkdTKChzcGVsbGluZm9fVCAqc3BpbiwgY2hhcl91ICpmbmFtZSkpOwogc3RhdGljIHZvaWQgKmdldHJvb20gX19BUkdTKChzcGVsbGluZm9fVCAqc3Bpbiwgc2l6ZV90IGxlbiwgaW50IGFsaWduKSk7CiBzdGF0aWMgY2hhcl91ICpnZXRyb29tX3NhdmUgX19BUkdTKChzcGVsbGluZm9fVCAqc3BpbiwgY2hhcl91ICpzKSk7CiBzdGF0aWMgdm9pZCBmcmVlX2Jsb2NrcyBfX0FSR1MoKHNibG9ja19UICpibCkpOwogc3RhdGljIHdvcmRub2RlX1QgKndvcmR0cmVlX2FsbG9jIF9fQVJHUygoc3BlbGxpbmZvX1QgKnNwaW4pKTsKLXN0YXRpYyBpbnQgc3RvcmVfd29yZCBfX0FSR1MoKHNwZWxsaW5mb19UICpzcGluLCBjaGFyX3UgKndvcmQsIGludCBmbGFncywgaW50IHJlZ2lvbiwgY2hhcl91ICpwZnhsaXN0KSk7CitzdGF0aWMgaW50IHN0b3JlX3dvcmQgX19BUkdTKChzcGVsbGluZm9fVCAqc3BpbiwgY2hhcl91ICp3b3JkLCBpbnQgZmxhZ3MsIGludCByZWdpb24sIGNoYXJfdSAqcGZ4bGlzdCwgaW50IG5lZWRfYWZmaXgpKTsKIHN0YXRpYyBpbnQgdHJlZV9hZGRfd29yZCBfX0FSR1MoKHNwZWxsaW5mb19UICpzcGluLCBjaGFyX3UgKndvcmQsIHdvcmRub2RlX1QgKnRyZWUsIGludCBmbGFncywgaW50IHJlZ2lvbiwgaW50IGFmZml4SUQpKTsKIHN0YXRpYyB3b3Jkbm9kZV9UICpnZXRfd29yZG5vZGUgX19BUkdTKChzcGVsbGluZm9fVCAqc3BpbikpOwogc3RhdGljIHZvaWQgZGVyZWZfd29yZG5vZGUgX19BUkdTKChzcGVsbGluZm9fVCAqc3Bpbiwgd29yZG5vZGVfVCAqbm9kZSkpOwpAQCAtMzQyNSw2ICszODk5LDEzIEBACiAgKiBVc2UgYSBuZWdhdGl2ZSBudW1iZXIgd2l0aCB0aGUgbG93ZXIgOCBiaXRzIHplcm8uICovCiAjZGVmaW5lIFBGWF9GTEFHUwktMjU2CiAKKy8qCisgKiBUdW5hYmxlIHBhcmFtZXRlcnMgZm9yIHdoZW4gdGhlIHRyZWUgaXMgY29tcHJlc3NlZC4gIFNlZSAnbWtzcGVsbG1lbScuCisgKi8KK3N0YXRpYyBsb25nIGNvbXByZXNzX3N0YXJ0ID0gMzAwMDA7CS8qIG1lbW9yeSAvIFNCTE9DS1NJWkUgKi8KK3N0YXRpYyBsb25nIGNvbXByZXNzX2luYyA9IDEwMDsJCS8qIG1lbW9yeSAvIFNCTE9DS1NJWkUgKi8KK3N0YXRpYyBsb25nIGNvbXByZXNzX2FkZGVkID0gNTAwMDAwOwkvKiB3b3JkIGNvdW50ICovCisKICNpZmRlZiBTUEVMTF9QUklOVFRSRUUKIC8qCiAgKiBGb3IgZGVidWdnaW5nIHRoZSB0cmVlIGNvZGU6IHByaW50IHRoZSBjdXJyZW50IHRyZWUgaW4gYSAobW9yZSBvciBsZXNzKQpAQCAtMzcxOCwxNyArNDE5OSw1NSBAQAogCQlpZiAoaXRlbXNbMV1bMV0gIT0gTlVMKQogCQkgICAgc21zZygoY2hhcl91ICopXyhlX2FmZm5hbWUpLCBmbmFtZSwgbG51bSwgaXRlbXNbMV0pOwogCSAgICB9Ci0JICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIkNPTVBPVU5ERkxBRyIpID09IDAgJiYgaXRlbWNudCA9PSAyCi0JCQkJCQkgICAgJiYgYWZmLT5hZl9jb21wZmxhZ3MgPT0gMCkKKwkgICAgZWxzZSBpZiAoU1RSQ01QKGl0ZW1zWzBdLCAiTkVFREFGRklYIikgPT0gMCAmJiBpdGVtY250ID09IDIKKwkJCQkJCSAgICAmJiBhZmYtPmFmX25lZWRhZmZpeCA9PSAwKQogCSAgICB7Ci0JCWFmZi0+YWZfY29tcGZsYWdzID0gZ2V0cm9vbV9zYXZlKHNwaW4sIGl0ZW1zWzFdKTsKKwkJYWZmLT5hZl9uZWVkYWZmaXggPSBpdGVtc1sxXVswXTsKIAkJaWYgKGl0ZW1zWzFdWzFdICE9IE5VTCkKIAkJICAgIHNtc2coKGNoYXJfdSAqKV8oZV9hZmZuYW1lKSwgZm5hbWUsIGxudW0sIGl0ZW1zWzFdKTsKIAkgICAgfQotCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VOREZMQUdTIikgPT0gMCAmJiBpdGVtY250ID09IDIKLQkJCQkJCSAgICAmJiBhZmYtPmFmX2NvbXBmbGFncyA9PSAwKQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VOREZMQUciKSA9PSAwICYmIGl0ZW1jbnQgPT0gMgorCQkJCQkJICYmIGFmZi0+YWZfY29tcGZsYWdzID09IE5VTEwpCiAJICAgIHsKLQkJYWZmLT5hZl9jb21wZmxhZ3MgPSBnZXRyb29tX3NhdmUoc3BpbiwgaXRlbXNbMV0pOworCQlwID0gZ2V0cm9vbShzcGluLCAzLCBGQUxTRSk7CisJCWlmIChwICE9IE5VTEwpCisJCXsKKwkJICAgIC8qIFR1cm4gc2luZ2xlIGZsYWcgImMiIGludG8gQ09NUE9VTkRGTEFHUyBjb21wYXRpYmxlCisJCSAgICAgKiBzdHJpbmcgImMrIi4gKi8KKwkJICAgIHBbMF0gPSBpdGVtc1sxXVswXTsKKwkJICAgIHBbMV0gPSAnKyc7CisJCSAgICBwWzJdID0gTlVMOworCQkgICAgYWZmLT5hZl9jb21wZmxhZ3MgPSBwOworCQl9CisJCWlmIChpdGVtc1sxXVsxXSAhPSBOVUwpCisJCSAgICBzbXNnKChjaGFyX3UgKilfKGVfYWZmbmFtZSksIGZuYW1lLCBsbnVtLCBpdGVtc1sxXSk7CisJICAgIH0KKwkgICAgZWxzZSBpZiAoU1RSQ01QKGl0ZW1zWzBdLCAiQ09NUE9VTkRGTEFHUyIpID09IDAgJiYgaXRlbWNudCA9PSAyKQorCSAgICB7CisJCS8qIENvbmNhdGVuYXRlIHRoaXMgc3RyaW5nIHRvIHByZXZpb3VzbHkgZGVmaW5lZCBvbmVzLCB1c2luZyBhCisJCSAqIHNsYXNoIHRvIHNlcGFyYXRlIHRoZW0uICovCisJCWwgPSBTVFJMRU4oaXRlbXNbMV0pICsgMTsKKwkJaWYgKGFmZi0+YWZfY29tcGZsYWdzICE9IE5VTEwpCisJCSAgICBsICs9IFNUUkxFTihhZmYtPmFmX2NvbXBmbGFncykgKyAxOworCQlwID0gZ2V0cm9vbShzcGluLCBsLCBGQUxTRSk7CisJCWlmIChwICE9IE5VTEwpCisJCXsKKwkJICAgIGlmIChhZmYtPmFmX2NvbXBmbGFncyAhPSBOVUxMKQorCQkgICAgeworCQkJU1RSQ1BZKHAsIGFmZi0+YWZfY29tcGZsYWdzKTsKKwkJCVNUUkNBVChwLCAiLyIpOworCQkgICAgfQorCQkgICAgU1RSQ0FUKHAsIGl0ZW1zWzFdKTsKKwkJICAgIGFmZi0+YWZfY29tcGZsYWdzID0gcDsKKwkJfQorCSAgICB9CisJICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIkNPTVBPVU5ETUFYIikgPT0gMCAmJiBpdGVtY250ID09IDIKKwkJCQkJCSAgICAgICYmIGFmZi0+YWZfY29tcG1heCA9PSAwKQorCSAgICB7CisJCWFmZi0+YWZfY29tcG1heCA9IGF0b2koKGNoYXIgKilpdGVtc1sxXSk7CisJCWlmIChhZmYtPmFmX2NvbXBtYXggPT0gMCkKKwkJICAgIHNtc2coKGNoYXJfdSAqKV8oIldyb25nIENPTVBPVU5ETUFYIHZhbHVlIGluICVzIGxpbmUgJWQ6ICVzIiksCisJCQkJCQkgICAgICAgZm5hbWUsIGxudW0sIGl0ZW1zWzFdKTsKIAkgICAgfQogCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VORE1JTiIpID09IDAgJiYgaXRlbWNudCA9PSAyCiAJCQkJCQkgICAmJiBhZmYtPmFmX2NvbXBtaW5sZW4gPT0gMCkKQEAgLTM3MzgsNiArNDI1NywxOSBAQAogCQkgICAgc21zZygoY2hhcl91ICopXygiV3JvbmcgQ09NUE9VTkRNSU4gdmFsdWUgaW4gJXMgbGluZSAlZDogJXMiKSwKIAkJCQkJCSAgICAgICBmbmFtZSwgbG51bSwgaXRlbXNbMV0pOwogCSAgICB9CisJICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIkNPTVBPVU5EU1lMTUFYIikgPT0gMCAmJiBpdGVtY250ID09IDIKKwkJCQkJCSAgICYmIGFmZi0+YWZfY29tcHN5bG1heCA9PSAwKQorCSAgICB7CisJCWFmZi0+YWZfY29tcHN5bG1heCA9IGF0b2koKGNoYXIgKilpdGVtc1sxXSk7CisJCWlmIChhZmYtPmFmX2NvbXBzeWxtYXggPT0gMCkKKwkJICAgIHNtc2coKGNoYXJfdSAqKV8oIldyb25nIENPTVBPVU5EU1lMTUFYIHZhbHVlIGluICVzIGxpbmUgJWQ6ICVzIiksCisJCQkJCQkgICAgICAgZm5hbWUsIGxudW0sIGl0ZW1zWzFdKTsKKwkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJTWUxMQUJMRSIpID09IDAgJiYgaXRlbWNudCA9PSAyCisJCQkJCQkgJiYgYWZmLT5hZl9zeWxsYWJsZSA9PSBOVUxMKQorCSAgICB7CisJCWFmZi0+YWZfc3lsbGFibGUgPSBnZXRyb29tX3NhdmUoc3BpbiwgaXRlbXNbMV0pOworCSAgICB9CiAJICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIlBGWFBPU1RQT05FIikgPT0gMCAmJiBpdGVtY250ID09IDEpCiAJICAgIHsKIAkJYWZmLT5hZl9wZnhwb3N0cG9uZSA9IFRSVUU7CkBAIC0zODExLDE0ICs0MzQzLDI1IEBACiAJICAgIHsKIAkJYWZmZW50cnlfVAkqYWZmX2VudHJ5OwogCQlpbnQJCXJhcmUgPSBGQUxTRTsKKwkJaW50CQlub2NvbXAgPSBGQUxTRTsKIAkJaW50CQl1cHBlciA9IEZBTFNFOwogCQlpbnQJCWxhc3RpID0gNTsKIAotCQkvKiBDaGVjayBmb3IgInJhcmUiIGFmdGVyIHRoZSBvdGhlciBpbmZvLiAqLwotCQlpZiAoaXRlbWNudCA+IDUgJiYgU1RSSUNNUChpdGVtc1s1XSwgInJhcmUiKSA9PSAwKQorCQkvKiBDaGVjayBmb3IgInJhcmUiIGFuZCAibm9jb21wIiBhZnRlciB0aGUgb3RoZXIgaW5mby4gKi8KKwkJd2hpbGUgKGl0ZW1jbnQgPiBsYXN0aSkKIAkJewotCQkgICAgcmFyZSA9IFRSVUU7Ci0JCSAgICBsYXN0aSA9IDY7CisJCSAgICBpZiAoIXJhcmUgJiYgU1RSSUNNUChpdGVtc1tsYXN0aV0sICJyYXJlIikgPT0gMCkKKwkJICAgIHsKKwkJCXJhcmUgPSBUUlVFOworCQkJKytsYXN0aTsKKwkJICAgIH0KKwkJICAgIGVsc2UgaWYgKCFub2NvbXAgJiYgU1RSSUNNUChpdGVtc1tsYXN0aV0sICJub2NvbXAiKSA9PSAwKQorCQkgICAgeworCQkJbm9jb21wID0gVFJVRTsKKwkJCSsrbGFzdGk7CisJCSAgICB9CisJCSAgICBlbHNlCisJCQlicmVhazsKIAkJfQogCiAJCS8qIE15c3BlbGwgYWxsb3dzIGV4dHJhIHRleHQgYWZ0ZXIgdGhlIGl0ZW0sIGJ1dCB0aGF0IG1pZ2h0CkBAIC0zODMzLDYgKzQzNzYsNyBAQAogCQlpZiAoYWZmX2VudHJ5ID09IE5VTEwpCiAJCSAgICBicmVhazsKIAkJYWZmX2VudHJ5LT5hZV9yYXJlID0gcmFyZTsKKwkJYWZmX2VudHJ5LT5hZV9ub2NvbXAgPSBub2NvbXA7CiAKIAkJaWYgKFNUUkNNUChpdGVtc1syXSwgIjAiKSAhPSAwKQogCQkgICAgYWZmX2VudHJ5LT5hZV9jaG9wID0gZ2V0cm9vbV9zYXZlKHNwaW4sIGl0ZW1zWzJdKTsKQEAgLTQxMjksNiArNDY3MywxNCBAQAogICAgIH0KIAogICAgIC8qIFVzZSBjb21wb3VuZCBzcGVjaWZpY2F0aW9ucyBvZiB0aGUgLmFmZiBmaWxlIGZvciB0aGUgc3BlbGwgaW5mby4gKi8KKyAgICBpZiAoYWZmLT5hZl9jb21wbWF4ICE9IDApCisgICAgeworCWlmIChzcGluLT5zaV9jb21wbWF4ICE9IDAgJiYgc3Bpbi0+c2lfY29tcG1heCAhPSBhZmYtPmFmX2NvbXBtYXgpCisJICAgIHNtc2coKGNoYXJfdSAqKV8oIkNPTVBPVU5ETUFYIHZhbHVlIGRpZmZlcnMgZnJvbSB3aGF0IGlzIHVzZWQgaW4gYW5vdGhlciAuYWZmIGZpbGUiKSk7CisJZWxzZQorCSAgICBzcGluLT5zaV9jb21wbWF4ID0gYWZmLT5hZl9jb21wbWF4OworICAgIH0KKwogICAgIGlmIChhZmYtPmFmX2NvbXBtaW5sZW4gIT0gMCkKICAgICB7CiAJaWYgKHNwaW4tPnNpX2NvbXBtaW5sZW4gIT0gMApAQCAtNDEzOCw2ICs0NjkwLDE4IEBACiAJICAgIHNwaW4tPnNpX2NvbXBtaW5sZW4gPSBhZmYtPmFmX2NvbXBtaW5sZW47CiAgICAgfQogCisgICAgaWYgKGFmZi0+YWZfY29tcHN5bG1heCAhPSAwKQorICAgIHsKKwlpZiAoYWZmLT5hZl9zeWxsYWJsZSA9PSBOVUxMKQorCSAgICBzbXNnKChjaGFyX3UgKilfKCJDT01QT1VORFNZTE1BWCB3aXRob3V0IFNZTExBQkxFIikpOworCisJaWYgKHNwaW4tPnNpX2NvbXBzeWxtYXggIT0gMAorCQkJCSAmJiBzcGluLT5zaV9jb21wc3lsbWF4ICE9IGFmZi0+YWZfY29tcHN5bG1heCkKKwkgICAgc21zZygoY2hhcl91ICopXygiQ09NUE9VTkRTWUxNQVggdmFsdWUgZGlmZmVycyBmcm9tIHdoYXQgaXMgdXNlZCBpbiBhbm90aGVyIC5hZmYgZmlsZSIpKTsKKwllbHNlCisJICAgIHNwaW4tPnNpX2NvbXBzeWxtYXggPSBhZmYtPmFmX2NvbXBzeWxtYXg7CisgICAgfQorCiAgICAgaWYgKGFmZi0+YWZfY29tcGZsYWdzICE9IE5VTEwpCiAgICAgewogCWlmIChzcGluLT5zaV9jb21wZmxhZ3MgIT0gTlVMTApAQCAtNDE0Nyw2ICs0NzExLDE1IEBACiAJICAgIHNwaW4tPnNpX2NvbXBmbGFncyA9IGFmZi0+YWZfY29tcGZsYWdzOwogICAgIH0KIAorICAgIGlmIChhZmYtPmFmX3N5bGxhYmxlICE9IE5VTEwpCisgICAgeworCWlmIChzcGluLT5zaV9zeWxsYWJsZSAhPSBOVUxMCisJCSYmIFNUUkNNUChzcGluLT5zaV9zeWxsYWJsZSwgYWZmLT5hZl9zeWxsYWJsZSkgIT0gMCkKKwkgICAgc21zZygoY2hhcl91ICopXygiU1lMTEFCTEUgdmFsdWUgZGlmZmVycyBmcm9tIHdoYXQgaXMgdXNlZCBpbiBhbm90aGVyIC5hZmYgZmlsZSIpKTsKKwllbHNlCisJICAgIHNwaW4tPnNpX3N5bGxhYmxlID0gYWZmLT5hZl9zeWxsYWJsZTsKKyAgICB9CisKICAgICB2aW1fZnJlZShwYyk7CiAgICAgZmNsb3NlKGZkKTsKICAgICByZXR1cm4gYWZmOwpAQCAtNDI2OSw3ICs0ODQyLDkgQEAKICAgICBjaGFyX3UJbGluZVtNQVhMSU5FTEVOXTsKICAgICBjaGFyX3UJKnA7CiAgICAgY2hhcl91CSphZmZsaXN0OwotICAgIGNoYXJfdQkqc3RvcmVfYWZmbGlzdDsKKyAgICBjaGFyX3UJc3RvcmVfYWZmbGlzdFtNQVhXTEVOXTsKKyAgICBpbnQJCXBmeGxlbjsKKyAgICBpbnQJCW5lZWRfYWZmaXg7CiAgICAgY2hhcl91CSpkdzsKICAgICBjaGFyX3UJKnBjOwogICAgIGNoYXJfdQkqdzsKQEAgLTQ0MTcsNyArNDk5Miw5IEBACiAJICAgIGhhc2hfYWRkX2l0ZW0oJmh0LCBoaSwgZHcsIGhhc2gpOwogCiAJZmxhZ3MgPSAwOwotCXN0b3JlX2FmZmxpc3QgPSBOVUxMOworCXN0b3JlX2FmZmxpc3RbMF0gPSBOVUw7CisJcGZ4bGVuID0gMDsKKwluZWVkX2FmZml4ID0gRkFMU0U7CiAJaWYgKGFmZmxpc3QgIT0gTlVMTCkKIAl7CiAJICAgIC8qIENoZWNrIGZvciBhZmZpeCBuYW1lIHRoYXQgc3RhbmRzIGZvciBrZWVwLWNhc2Ugd29yZCBhbmQgc3RhbmRzCkBAIC00NDMxLDQwICs1MDA4LDIzIEBACiAJICAgIGlmIChhZmZpbGUtPmFmX2JhZCAhPSBOVUwKIAkJICAgICYmIHZpbV9zdHJjaHIoYWZmbGlzdCwgYWZmaWxlLT5hZl9iYWQpICE9IE5VTEwpCiAJCWZsYWdzIHw9IFdGX0JBTk5FRDsKKwkgICAgaWYgKGFmZmlsZS0+YWZfbmVlZGFmZml4ICE9IE5VTAorCQkgICAgJiYgdmltX3N0cmNocihhZmZsaXN0LCBhZmZpbGUtPmFmX25lZWRhZmZpeCkgIT0gTlVMTCkKKwkJbmVlZF9hZmZpeCA9IFRSVUU7CiAKIAkgICAgaWYgKGFmZmlsZS0+YWZfcGZ4cG9zdHBvbmUpCiAJCS8qIE5lZWQgdG8gc3RvcmUgdGhlIGxpc3Qgb2YgcHJlZml4IElEcyB3aXRoIHRoZSB3b3JkLiAqLwotCQlzdG9yZV9hZmZsaXN0ID0gZ2V0X3BmeGxpc3Qoc3BpbiwgYWZmaWxlLCBhZmZsaXN0KTsKKwkJcGZ4bGVuID0gZ2V0X3BmeGxpc3QoYWZmaWxlLCBhZmZsaXN0LCBzdG9yZV9hZmZsaXN0KTsKIAotCSAgICBpZiAoc3Bpbi0+c2lfY29tcGZsYWdzKQotCSAgICB7Ci0JCS8qIE5lZWQgdG8gc3RvcmUgdGhlIGxpc3Qgb2YgY29tcG91bmQgZmxhZ3Mgd2l0aCB0aGUgd29yZC4gKi8KLQkJcCA9IGdldF9jb21wZmxhZ3Moc3BpbiwgYWZmbGlzdCk7Ci0JCWlmIChwICE9IE5VTEwpCi0JCXsKLQkJICAgIGlmIChzdG9yZV9hZmZsaXN0ICE9IE5VTEwpCi0JCSAgICB7Ci0JCQljaGFyX3UgKnM7Ci0KLQkJCS8qIENvbmNhdGVuYXRlIHRoZSBwcmVmaXggSURzIHdpdGggdGhlIGNvbXBvdW5kIGZsYWdzLgotCQkJICovCi0JCQlzID0gZ2V0cm9vbShzcGluLCBTVFJMRU4oc3RvcmVfYWZmbGlzdCkKLQkJCQkJCSAgICAgICsgU1RSTEVOKHApICsgMSwgRkFMU0UpOwotCQkJaWYgKHMgIT0gTlVMTCkKLQkJCXsKLQkJCSAgICBTVFJDUFkocywgc3RvcmVfYWZmbGlzdCk7Ci0JCQkgICAgU1RSQ0FUKHMsIHApOwotCQkJICAgIHN0b3JlX2FmZmxpc3QgPSBzOwotCQkJfQotCQkgICAgfQotCQkgICAgZWxzZQotCQkJc3RvcmVfYWZmbGlzdCA9IHA7Ci0JCX0KLQkgICAgfQorCSAgICBpZiAoc3Bpbi0+c2lfY29tcGZsYWdzICE9IE5VTEwpCisJCS8qIE5lZWQgdG8gc3RvcmUgdGhlIGxpc3Qgb2YgY29tcG91bmQgZmxhZ3Mgd2l0aCB0aGUgd29yZC4KKwkJICogQ29uY2F0ZW5hdGUgdGhlbSB0byB0aGUgbGlzdCBvZiBwcmVmaXggSURzLiAqLworCQlnZXRfY29tcGZsYWdzKHNwaW4sIGFmZmxpc3QsIHN0b3JlX2FmZmxpc3QgKyBwZnhsZW4pOwogCX0KIAogCS8qIEFkZCB0aGUgd29yZCB0byB0aGUgd29yZCB0cmVlKHMpLiAqLwotCWlmIChzdG9yZV93b3JkKHNwaW4sIGR3LCBmbGFncywgc3Bpbi0+c2lfcmVnaW9uLCBzdG9yZV9hZmZsaXN0KSA9PSBGQUlMKQorCWlmIChzdG9yZV93b3JkKHNwaW4sIGR3LCBmbGFncywgc3Bpbi0+c2lfcmVnaW9uLAorCQkJCQkgICBzdG9yZV9hZmZsaXN0LCBuZWVkX2FmZml4KSA9PSBGQUlMKQogCSAgICByZXR2YWwgPSBGQUlMOwogCiAJaWYgKGFmZmxpc3QgIT0gTlVMTCkKQEAgLTQ0NzMsMTMgKzUwMzMsMTMgQEAKIAkgICAgICogQWRkaXRpb25hbGx5IGRvIG1hdGNoaW5nIHByZWZpeGVzIHRoYXQgY29tYmluZS4gKi8KIAkgICAgaWYgKHN0b3JlX2FmZl93b3JkKHNwaW4sIGR3LCBhZmZsaXN0LCBhZmZpbGUsCiAJCQkgICAmYWZmaWxlLT5hZl9zdWZmLCAmYWZmaWxlLT5hZl9wcmVmLAotCQkJCQkgRkFMU0UsIGZsYWdzLCBzdG9yZV9hZmZsaXN0KSA9PSBGQUlMKQorCQkJCSBGQUxTRSwgZmxhZ3MsIHN0b3JlX2FmZmxpc3QsIHBmeGxlbikgPT0gRkFJTCkKIAkJcmV0dmFsID0gRkFJTDsKIAogCSAgICAvKiBGaW5kIGFsbCBtYXRjaGluZyBwcmVmaXhlcyBhbmQgYWRkIHRoZSByZXN1bHRpbmcgd29yZHMuICovCiAJICAgIGlmIChzdG9yZV9hZmZfd29yZChzcGluLCBkdywgYWZmbGlzdCwgYWZmaWxlLAogCQkJICAmYWZmaWxlLT5hZl9wcmVmLCBOVUxMLAotCQkJCQkgRkFMU0UsIGZsYWdzLCBzdG9yZV9hZmZsaXN0KSA9PSBGQUlMKQorCQkJCSBGQUxTRSwgZmxhZ3MsIHN0b3JlX2FmZmxpc3QsIHBmeGxlbikgPT0gRkFJTCkKIAkJcmV0dmFsID0gRkFJTDsKIAl9CiAgICAgfQpAQCAtNDQ5OCw5MyArNTA1OCw1NiBAQAogLyoKICAqIEdldCB0aGUgbGlzdCBvZiBwcmVmaXggSURzIGZyb20gdGhlIGFmZml4IGxpc3QgImFmZmxpc3QiLgogICogVXNlZCBmb3IgUEZYUE9TVFBPTkUuCi0gKiBSZXR1cm5zIGEgc3RyaW5nIGFsbG9jYXRlZCB3aXRoIGdldHJvb20oKS4gTlVMTCB3aGVuIHRoZXJlIGFyZSBubyBwcmVmaXhlcwotICogb3Igd2hlbiBvdXQgb2YgbWVtb3J5LgorICogUHV0IHRoZSByZXN1bHRpbmcgZmxhZ3MgaW4gInN0b3JlX2FmZmxpc3RbTUFYV0xFTl0iIHdpdGggYSB0ZXJtaW5hdGluZyBOVUwKKyAqIGFuZCByZXR1cm4gdGhlIG51bWJlciBvZiBhZmZpeGVzLgogICovCi0gICAgc3RhdGljIGNoYXJfdSAqCi1nZXRfcGZ4bGlzdChzcGluLCBhZmZpbGUsIGFmZmxpc3QpCi0gICAgc3BlbGxpbmZvX1QJKnNwaW47CisgICAgc3RhdGljIGludAorZ2V0X3BmeGxpc3QoYWZmaWxlLCBhZmZsaXN0LCBzdG9yZV9hZmZsaXN0KQogICAgIGFmZmZpbGVfVAkqYWZmaWxlOwogICAgIGNoYXJfdQkqYWZmbGlzdDsKKyAgICBjaGFyX3UJKnN0b3JlX2FmZmxpc3Q7CiB7CiAgICAgY2hhcl91CSpwOwotICAgIGludAkJY250OwotICAgIGludAkJcm91bmQ7Ci0gICAgY2hhcl91CSpyZXMgPSBOVUxMOworICAgIGludAkJY250ID0gMDsKICAgICBjaGFyX3UJa2V5WzJdOwogICAgIGhhc2hpdGVtX1QJKmhpOwogCiAgICAga2V5WzFdID0gTlVMOwotCi0gICAgLyogcm91bmQgMTogY291bnQgdGhlIG51bWJlciBvZiBwcmVmaXggSURzLgotICAgICAqIHJvdW5kIDI6IG1vdmUgcHJlZml4IElEcyB0byAicmVzIiAqLwotICAgIGZvciAocm91bmQgPSAxOyByb3VuZCA8PSAyOyArK3JvdW5kKQorICAgIGZvciAocCA9IGFmZmxpc3Q7ICpwICE9IE5VTDsgKytwKQogICAgIHsKLQljbnQgPSAwOwotCWZvciAocCA9IGFmZmxpc3Q7ICpwICE9IE5VTDsgKytwKQotCXsKLQkgICAga2V5WzBdID0gKnA7Ci0JICAgIGhpID0gaGFzaF9maW5kKCZhZmZpbGUtPmFmX3ByZWYsIGtleSk7Ci0JICAgIGlmICghSEFTSElURU1fRU1QVFkoaGkpKQotCSAgICB7Ci0JCS8qIFRoaXMgaXMgYSBwcmVmaXggSUQsIHVzZSB0aGUgbmV3IG51bWJlci4gKi8KLQkJaWYgKHJvdW5kID09IDIpCi0JCSAgICByZXNbY250XSA9IEhJMkFIKGhpKS0+YWhfbmV3SUQ7Ci0JCSsrY250OwotCSAgICB9Ci0JfQotCWlmIChyb3VuZCA9PSAxICYmIGNudCA+IDApCi0JICAgIHJlcyA9IGdldHJvb20oc3BpbiwgY250ICsgMSwgRkFMU0UpOwotCWlmIChyZXMgPT0gTlVMTCkKLQkgICAgYnJlYWs7CisJa2V5WzBdID0gKnA7CisJaGkgPSBoYXNoX2ZpbmQoJmFmZmlsZS0+YWZfcHJlZiwga2V5KTsKKwlpZiAoIUhBU0hJVEVNX0VNUFRZKGhpKSkKKwkgICAgLyogVGhpcyBpcyBhIHByZWZpeCBJRCwgdXNlIHRoZSBuZXcgbnVtYmVyLiAqLworCSAgICBzdG9yZV9hZmZsaXN0W2NudCsrXSA9IEhJMkFIKGhpKS0+YWhfbmV3SUQ7CiAgICAgfQogCi0gICAgaWYgKHJlcyAhPSBOVUxMKQotCXJlc1tjbnRdID0gTlVMOwotICAgIHJldHVybiByZXM7CisgICAgc3RvcmVfYWZmbGlzdFtjbnRdID0gTlVMOworICAgIHJldHVybiBjbnQ7CiB9CiAKIC8qCiAgKiBHZXQgdGhlIGxpc3Qgb2YgYWZmaXggSURzIGZyb20gdGhlIGFmZml4IGxpc3QgImFmZmxpc3QiIHRoYXQgYXJlIHVzZWQgZm9yCiAgKiBjb21wb3VuZCB3b3Jkcy4KLSAqIFJldHVybnMgYSBzdHJpbmcgYWxsb2NhdGVkIHdpdGggZ2V0cm9vbSgpLiAgTlVMTCB3aGVuIHRoZXJlIGFyZSBubyByZWxldmFudAotICogYWZmaXhlcyBvciB3aGVuIG91dCBvZiBtZW1vcnkuCisgKiBQdXRzIHRoZSBmbGFncyBpbiAic3RvcmVfYWZmbGlzdFtdIi4KICAqLwotICAgIHN0YXRpYyBjaGFyX3UgKgotZ2V0X2NvbXBmbGFncyhzcGluLCBhZmZsaXN0KQorICAgIHN0YXRpYyB2b2lkCitnZXRfY29tcGZsYWdzKHNwaW4sIGFmZmxpc3QsIHN0b3JlX2FmZmxpc3QpCiAgICAgc3BlbGxpbmZvX1QJKnNwaW47CiAgICAgY2hhcl91CSphZmZsaXN0OworICAgIGNoYXJfdQkqc3RvcmVfYWZmbGlzdDsKIHsKICAgICBjaGFyX3UJKnA7Ci0gICAgaW50CQljbnQ7Ci0gICAgaW50CQlyb3VuZDsKLSAgICBjaGFyX3UJKnJlcyA9IE5VTEw7CisgICAgaW50CQljbnQgPSAwOwogCi0gICAgLyogcm91bmQgMTogY291bnQgdGhlIG51bWJlciBvZiBhZmZpeCBJRHMuCi0gICAgICogcm91bmQgMjogbW92ZSBhZmZpeCBJRHMgdG8gInJlcyIgKi8KLSAgICBmb3IgKHJvdW5kID0gMTsgcm91bmQgPD0gMjsgKytyb3VuZCkKLSAgICB7Ci0JY250ID0gMDsKLQlmb3IgKHAgPSBhZmZsaXN0OyAqcCAhPSBOVUw7ICsrcCkKLQl7Ci0JICAgIGlmICgqcCAhPSAnLCcgJiYgKnAgIT0gJy0nCi0JCQkJJiYgdmltX3N0cmNocihzcGluLT5zaV9jb21wZmxhZ3MsICpwKSAhPSBOVUxMKQotCSAgICB7Ci0JCS8qIFRoaXMgaXMgYSBjb21wb3VudCBhZmZpeCBJRC4gKi8KLQkJaWYgKHJvdW5kID09IDIpCi0JCSAgICByZXNbY250XSA9ICpwOwotCQkrK2NudDsKLQkgICAgfQotCX0KLQlpZiAocm91bmQgPT0gMSAmJiBjbnQgPiAwKQotCSAgICByZXMgPSBnZXRyb29tKHNwaW4sIGNudCArIDEsIEZBTFNFKTsKLQlpZiAocmVzID09IE5VTEwpCi0JICAgIGJyZWFrOwotICAgIH0KKyAgICBmb3IgKHAgPSBhZmZsaXN0OyAqcCAhPSBOVUw7ICsrcCkKKwkvKiBBIGZsYWcgaXMgYSBjb21wb3VuZCBmbGFnIGlmIGl0IGFwcGVhcnMgaW4gInNpX2NvbXBmbGFncyIgYW5kCisJICogaXQncyBub3QgYSBzcGVjaWFsIGNoYXJhY3Rlci4gKi8KKwlpZiAodmltX3N0cmNocihzcGluLT5zaV9jb21wZmxhZ3MsICpwKSAhPSBOVUxMCisJCQkgICAgICYmIHZpbV9zdHJjaHIoKGNoYXJfdSAqKSIrKltdLyIsICpwKSA9PSBOVUxMKQorCSAgICBzdG9yZV9hZmZsaXN0W2NudCsrXSA9ICpwOwogCi0gICAgaWYgKHJlcyAhPSBOVUxMKQotCXJlc1tjbnRdID0gTlVMOwotICAgIHJldHVybiByZXM7CisgICAgc3RvcmVfYWZmbGlzdFtjbnRdID0gTlVMOwogfQogCiAvKgpAQCAtNDU5Nyw3ICs1MTIwLDggQEAKICAqIFJldHVybnMgRkFJTCB3aGVuIG91dCBvZiBtZW1vcnkuCiAgKi8KICAgICBzdGF0aWMgaW50Ci1zdG9yZV9hZmZfd29yZChzcGluLCB3b3JkLCBhZmZsaXN0LCBhZmZpbGUsIGh0LCB4aHQsIGNvbWIsIGZsYWdzLCBwZnhsaXN0KQorc3RvcmVfYWZmX3dvcmQoc3Bpbiwgd29yZCwgYWZmbGlzdCwgYWZmaWxlLCBodCwgeGh0LCBjb21iLCBmbGFncywKKwkJCQkJCQkgICAgICBwZnhsaXN0LCBwZnhsZW4pCiAgICAgc3BlbGxpbmZvX1QJKnNwaW47CQkvKiBzcGVsbCBpbmZvICovCiAgICAgY2hhcl91CSp3b3JkOwkJLyogYmFzaWMgd29yZCBzdGFydCAqLwogICAgIGNoYXJfdQkqYWZmbGlzdDsJLyogbGlzdCBvZiBuYW1lcyBvZiBzdXBwb3J0ZWQgYWZmaXhlcyAqLwpAQCAtNDYwNyw2ICs1MTMxLDggQEAKICAgICBpbnQJCWNvbWI7CQkvKiBvbmx5IHVzZSBhZmZpeGVzIHRoYXQgY29tYmluZSAqLwogICAgIGludAkJZmxhZ3M7CQkvKiBmbGFncyBmb3IgdGhlIHdvcmQgKi8KICAgICBjaGFyX3UJKnBmeGxpc3Q7CS8qIGxpc3Qgb2YgcHJlZml4IElEcyAqLworICAgIGludAkJcGZ4bGVuOwkJLyogbnIgb2YgZmxhZ3MgaW4gInBmeGxpc3QiIGZvciBwcmVmaXhlcywgcmVzdAorCQkJCSAqIGlzIGNvbXBvdW5kIGZsYWdzICovCiB7CiAgICAgaW50CQl0b2RvOwogICAgIGhhc2hpdGVtX1QJKmhpOwpAQCAtNDYxOSw4ICs1MTQ1LDkgQEAKICAgICBjaGFyX3UJKnA7CiAgICAgaW50CQl1c2VfZmxhZ3M7CiAgICAgY2hhcl91CSp1c2VfcGZ4bGlzdDsKKyAgICBjaGFyX3UJcGZ4X3BmeGxpc3RbTUFYV0xFTl07CiAgICAgaW50CQljOwotICAgIGludAkJd29yZGxlbiA9IFNUUkxFTih3b3JkKTsKKyAgICBzaXplX3QJd29yZGxlbiA9IFNUUkxFTih3b3JkKTsKIAogICAgIHRvZG8gPSBodC0+aHRfdXNlZDsKICAgICBmb3IgKGhpID0gaHQtPmh0X2FycmF5OyB0b2RvID4gMCAmJiByZXR2YWwgPT0gT0s7ICsraGkpCkBAIC00NzAxLDcgKzUyMjgsMTUgQEAKIAkJCSAgICB1c2VfZmxhZ3MgPSBmbGFncyB8IFdGX1JBUkU7CiAJCQllbHNlCiAJCQkgICAgdXNlX2ZsYWdzID0gZmxhZ3M7CisKKwkJCS8qIE9iZXkgdGhlICJub2NvbXAiIGZsYWcgb2YgdGhlIGFmZml4OiBkb24ndCB1c2UgdGhlCisJCQkgKiBjb21wb3VuZCBmbGFncy4gKi8KIAkJCXVzZV9wZnhsaXN0ID0gcGZ4bGlzdDsKKwkJCWlmIChhZS0+YWVfbm9jb21wICYmIHBmeGxpc3QgIT0gTlVMTCkKKwkJCXsKKwkJCSAgICB2aW1fc3RybmNweShwZnhfcGZ4bGlzdCwgcGZ4bGlzdCwgcGZ4bGVuKTsKKwkJCSAgICB1c2VfcGZ4bGlzdCA9IHBmeF9wZnhsaXN0OworCQkJfQogCiAJCQkvKiBXaGVuIHRoZXJlIGFyZSBwb3N0cG9uZWQgcHJlZml4ZXMuLi4gKi8KIAkJCWlmIChzcGluLT5zaV9wcmVmcm9vdCAhPSBOVUxMCkBAIC00NzExLDE0ICs1MjQ2LDE1IEBACiAJCQkgICAgdXNlX2ZsYWdzIHw9IFdGX0hBU19BRkY7CiAKIAkJCSAgICAvKiAuLi4gZG9uJ3QgdXNlIGEgcHJlZml4IGxpc3QgaWYgY29tYmluaW5nCi0JCQkgICAgICogYWZmaXhlcyBpcyBub3QgYWxsb3dlZCAqLwotCQkJICAgIGlmICghYWgtPmFoX2NvbWJpbmUgfHwgY29tYikKLQkJCQl1c2VfcGZ4bGlzdCA9IE5VTEw7CisJCQkgICAgICogYWZmaXhlcyBpcyBub3QgYWxsb3dlZC4gIEJ1dCBkbyB1c2UgdGhlCisJCQkgICAgICogY29tcG91bmQgZmxhZ3MgYWZ0ZXIgdGhlbS4gKi8KKwkJCSAgICBpZiAoKCFhaC0+YWhfY29tYmluZSB8fCBjb21iKSAmJiBwZnhsaXN0ICE9IE5VTEwpCisJCQkJdXNlX3BmeGxpc3QgKz0gcGZ4bGVuOwogCQkJfQogCiAJCQkvKiBTdG9yZSB0aGUgbW9kaWZpZWQgd29yZC4gKi8KIAkJCWlmIChzdG9yZV93b3JkKHNwaW4sIG5ld3dvcmQsIHVzZV9mbGFncywKLQkJCQkJc3Bpbi0+c2lfcmVnaW9uLCB1c2VfcGZ4bGlzdCkgPT0gRkFJTCkKKwkJCQkgc3Bpbi0+c2lfcmVnaW9uLCB1c2VfcGZ4bGlzdCwgRkFMU0UpID09IEZBSUwpCiAJCQkgICAgcmV0dmFsID0gRkFJTDsKIAogCQkJLyogV2hlbiBhZGRlZCBhIHN1ZmZpeCBhbmQgY29tYmluaW5nIGlzIGFsbG93ZWQgYWxzbwpAQCAtNDcyNiw3ICs1MjYyLDcgQEAKIAkJCWlmICh4aHQgIT0gTlVMTCAmJiBhaC0+YWhfY29tYmluZSkKIAkJCSAgICBpZiAoc3RvcmVfYWZmX3dvcmQoc3BpbiwgbmV3d29yZCwgYWZmbGlzdCwgYWZmaWxlLAogCQkJCQkgIHhodCwgTlVMTCwgVFJVRSwKLQkJCQkJICB1c2VfZmxhZ3MsIHVzZV9wZnhsaXN0KSA9PSBGQUlMKQorCQkJCSAgICAgIHVzZV9mbGFncywgdXNlX3BmeGxpc3QsIHBmeGxlbikgPT0gRkFJTCkKIAkJCQlyZXR2YWwgPSBGQUlMOwogCQkgICAgfQogCQl9CkBAIC00OTI5LDcgKzU0NjUsNyBAQAogCX0KIAogCS8qIE5vcm1hbCB3b3JkOiBzdG9yZSBpdC4gKi8KLQlpZiAoc3RvcmVfd29yZChzcGluLCBsaW5lLCBmbGFncywgcmVnaW9ubWFzaywgTlVMTCkgPT0gRkFJTCkKKwlpZiAoc3RvcmVfd29yZChzcGluLCBsaW5lLCBmbGFncywgcmVnaW9ubWFzaywgTlVMTCwgRkFMU0UpID09IEZBSUwpCiAJewogCSAgICByZXR2YWwgPSBGQUlMOwogCSAgICBicmVhazsKQEAgLTUwNDYsMTIgKzU1ODIsMTMgQEAKICAqIGNvbXBvdW5kIGZsYWcuCiAgKi8KICAgICBzdGF0aWMgaW50Ci1zdG9yZV93b3JkKHNwaW4sIHdvcmQsIGZsYWdzLCByZWdpb24sIHBmeGxpc3QpCitzdG9yZV93b3JkKHNwaW4sIHdvcmQsIGZsYWdzLCByZWdpb24sIHBmeGxpc3QsIG5lZWRfYWZmaXgpCiAgICAgc3BlbGxpbmZvX1QJKnNwaW47CiAgICAgY2hhcl91CSp3b3JkOwogICAgIGludAkJZmxhZ3M7CQkvKiBleHRyYSBmbGFncywgV0ZfQkFOTkVEICovCiAgICAgaW50CQlyZWdpb247CQkvKiBzdXBwb3J0ZWQgcmVnaW9uKHMpICovCiAgICAgY2hhcl91CSpwZnhsaXN0OwkvKiBsaXN0IG9mIHByZWZpeCBJRHMgb3IgTlVMTCAqLworICAgIGludAkJbmVlZF9hZmZpeDsJLyogb25seSBzdG9yZSB3b3JkIHdpdGggYWZmaXggSUQgKi8KIHsKICAgICBpbnQJCWxlbiA9IFNUUkxFTih3b3JkKTsKICAgICBpbnQJCWN0ID0gY2FwdHlwZSh3b3JkLCB3b3JkICsgbGVuKTsKQEAgLTUwNjIsNyArNTU5OSw4IEBACiAgICAgKHZvaWQpc3BlbGxfY2FzZWZvbGQod29yZCwgbGVuLCBmb2xkd29yZCwgTUFYV0xFTik7CiAgICAgZm9yIChwID0gcGZ4bGlzdDsgcmVzID09IE9LOyArK3ApCiAgICAgewotCXJlcyA9IHRyZWVfYWRkX3dvcmQoc3BpbiwgZm9sZHdvcmQsIHNwaW4tPnNpX2ZvbGRyb290LCBjdCB8IGZsYWdzLAorCWlmICghbmVlZF9hZmZpeCB8fCAocCAhPSBOVUxMICYmICpwICE9IE5VTCkpCisJICAgIHJlcyA9IHRyZWVfYWRkX3dvcmQoc3BpbiwgZm9sZHdvcmQsIHNwaW4tPnNpX2ZvbGRyb290LCBjdCB8IGZsYWdzLAogCQkJCQkJICByZWdpb24sIHAgPT0gTlVMTCA/IDAgOiAqcCk7CiAJaWYgKHAgPT0gTlVMTCB8fCAqcCA9PSBOVUwpCiAJICAgIGJyZWFrOwpAQCAtNTA3Myw3ICs1NjExLDggQEAKICAgICB7CiAJZm9yIChwID0gcGZ4bGlzdDsgcmVzID09IE9LOyArK3ApCiAJewotCSAgICByZXMgPSB0cmVlX2FkZF93b3JkKHNwaW4sIHdvcmQsIHNwaW4tPnNpX2tlZXByb290LCBmbGFncywKKwkgICAgaWYgKCFuZWVkX2FmZml4IHx8IChwICE9IE5VTEwgJiYgKnAgIT0gTlVMKSkKKwkJcmVzID0gdHJlZV9hZGRfd29yZChzcGluLCB3b3JkLCBzcGluLT5zaV9rZWVwcm9vdCwgZmxhZ3MsCiAJCQkJCQkgIHJlZ2lvbiwgcCA9PSBOVUxMID8gMCA6ICpwKTsKIAkgICAgaWYgKHAgPT0gTlVMTCB8fCAqcCA9PSBOVUwpCiAJCWJyZWFrOwpAQCAtNTIwOSw3ICs1NzQ4LDcgQEAKICAgICB7CiAJaWYgKC0tc3Bpbi0+c2lfY29tcHJlc3NfY250ID09IDEpCiAJICAgIC8qIERpZCBlbm91Z2ggd29yZHMgdG8gbG93ZXIgdGhlIGJsb2NrIGNvdW50IGxpbWl0LiAqLwotCSAgICBzcGluLT5zaV9ibG9ja3NfY250ICs9IFNQRUxMX0NPTVBSRVNTX0lOQzsKKwkgICAgc3Bpbi0+c2lfYmxvY2tzX2NudCArPSBjb21wcmVzc19pbmM7CiAgICAgfQogCiAgICAgLyoKQEAgLTUyMTcsMjUgKzU3NTYsMjUgQEAKICAgICAgKiB0byBmcmVlIHVwIHNvbWUgcm9vbS4gIEJ1dCBjb21wcmVzc2lvbiBpcyBzbG93LCBhbmQgd2UgbWlnaHQgYWN0dWFsbHkKICAgICAgKiBuZWVkIHRoYXQgcm9vbSwgdGh1cyBvbmx5IGNvbXByZXNzIGluIHRoZSBmb2xsb3dpbmcgc2l0dWF0aW9uczoKICAgICAgKiAxLiBXaGVuIG5vdCBjb21wcmVzc2VkIGJlZm9yZSAoc2lfY29tcHJlc3NfY250ID09IDApOiB3aGVuIHVzaW5nCi0gICAgICogICAgU1BFTExfQ09NUFJFU1NfQ05UIGJsb2Nrcy4KLSAgICAgKiAyLiBXaGVuIGNvbXByZXNzZWQgYmVmb3JlIGFuZCB1c2VkIFNQRUxMX0NPTVBSRVNTX0lOQyBibG9ja3MgYmVmb3JlCi0gICAgICogICAgYWRkaW5nIFNQRUxMX0NPTVBSRVNTX0FEREVEIHdvcmRzIChzaV9jb21wcmVzc19jbnQgPiAxKS4KLSAgICAgKiAzLiBXaGVuIGNvbXByZXNzZWQgYmVmb3JlLCBhZGRlZCBTUEVMTF9DT01QUkVTU19BRERFRCB3b3JkcworICAgICAqICAgICJjb21wcmVzc19zdGFydCIgYmxvY2tzLgorICAgICAqIDIuIFdoZW4gY29tcHJlc3NlZCBiZWZvcmUgYW5kIHVzZWQgImNvbXByZXNzX2luYyIgYmxvY2tzIGJlZm9yZQorICAgICAqICAgIGFkZGluZyAiY29tcHJlc3NfYWRkZWQiIHdvcmRzIChzaV9jb21wcmVzc19jbnQgPiAxKS4KKyAgICAgKiAzLiBXaGVuIGNvbXByZXNzZWQgYmVmb3JlLCBhZGRlZCAiY29tcHJlc3NfYWRkZWQiIHdvcmRzCiAgICAgICogICAgKHNpX2NvbXByZXNzX2NudCA9PSAxKSBhbmQgdGhlIG51bWJlciBvZiBmcmVlIG5vZGVzIGRyb3BzIGJlbG93IHRoZQogICAgICAqICAgIG1heGltdW0gd29yZCBsZW5ndGguCiAgICAgICovCiAjaWZuZGVmIFNQRUxMX1BSSU5UVFJFRQogICAgIGlmIChzcGluLT5zaV9jb21wcmVzc19jbnQgPT0gMQogCSAgICA/IHNwaW4tPnNpX2ZyZWVfY291bnQgPCBNQVhXTEVOCi0JICAgIDogc3Bpbi0+c2lfYmxvY2tzX2NudCA+PSBTUEVMTF9DT01QUkVTU19DTlQpCisJICAgIDogc3Bpbi0+c2lfYmxvY2tzX2NudCA+PSBjb21wcmVzc19zdGFydCkKICNlbmRpZgogICAgIHsKIAkvKiBEZWNyZW1lbnQgdGhlIGJsb2NrIGNvdW50ZXIuICBUaGUgZWZmZWN0IGlzIHRoYXQgd2UgY29tcHJlc3MgYWdhaW4KLQkgKiB3aGVuIHRoZSBmcmVlZCB1cCByb29tIGhhcyBiZWVuIHVzZWQgYW5kIGFub3RoZXIgU1BFTExfQ09NUFJFU1NfSU5DCi0JICogYmxvY2tzIGhhdmUgYmVlbiBhbGxvY2F0ZWQuICBVbmxlc3MgU1BFTExfQ09NUFJFU1NfQURERUQgd29yZHMgaGF2ZQorCSAqIHdoZW4gdGhlIGZyZWVkIHVwIHJvb20gaGFzIGJlZW4gdXNlZCBhbmQgYW5vdGhlciAiY29tcHJlc3NfaW5jIgorCSAqIGJsb2NrcyBoYXZlIGJlZW4gYWxsb2NhdGVkLiAgVW5sZXNzICJjb21wcmVzc19hZGRlZCIgd29yZHMgaGF2ZQogCSAqIGJlZW4gYWRkZWQsIHRoZW4gdGhlIGxpbWl0IGlzIHB1dCBiYWNrIGFnYWluLiAqLwotCXNwaW4tPnNpX2Jsb2Nrc19jbnQgLT0gU1BFTExfQ09NUFJFU1NfSU5DOwotCXNwaW4tPnNpX2NvbXByZXNzX2NudCA9IFNQRUxMX0NPTVBSRVNTX0FEREVEOworCXNwaW4tPnNpX2Jsb2Nrc19jbnQgLT0gY29tcHJlc3NfaW5jOworCXNwaW4tPnNpX2NvbXByZXNzX2NudCA9IGNvbXByZXNzX2FkZGVkOwogCiAJaWYgKHNwaW4tPnNpX3ZlcmJvc2UpCiAJewpAQCAtNTI1OCw2ICs1Nzk3LDQ3IEBACiB9CiAKIC8qCisgKiBDaGVjayB0aGUgJ21rc3BlbGxtZW0nIG9wdGlvbi4gIFJldHVybiBGQUlMIGlmIGl0J3Mgd3JvbmcuCisgKiBTZXRzICJzcHNfZmxhZ3MiLgorICovCisgICAgaW50CitzcGVsbF9jaGVja19tc20oKQoreworICAgIGNoYXJfdQkqcCA9IHBfbXNtOworICAgIGxvbmcJc3RhcnQgPSAwOworICAgIGxvbmcJaW5jID0gMDsKKyAgICBsb25nCWFkZGVkID0gMDsKKworICAgIGlmICghVklNX0lTRElHSVQoKnApKQorCXJldHVybiBGQUlMOworICAgIC8qIGJsb2NrIGNvdW50ID0gKHZhbHVlICogMTAyNCkgLyBTQkxPQ0tTSVpFIChidXQgYXZvaWQgb3ZlcmZsb3cpKi8KKyAgICBzdGFydCA9IChnZXRkaWdpdHMoJnApICogMTApIC8gKFNCTE9DS1NJWkUgLyAxMDIpOworICAgIGlmICgqcCAhPSAnLCcpCisJcmV0dXJuIEZBSUw7CisgICAgKytwOworICAgIGlmICghVklNX0lTRElHSVQoKnApKQorCXJldHVybiBGQUlMOworICAgIGluYyA9IChnZXRkaWdpdHMoJnApICogMTAyKSAvIChTQkxPQ0tTSVpFIC8gMTApOworICAgIGlmICgqcCAhPSAnLCcpCisJcmV0dXJuIEZBSUw7CisgICAgKytwOworICAgIGlmICghVklNX0lTRElHSVQoKnApKQorCXJldHVybiBGQUlMOworICAgIGFkZGVkID0gZ2V0ZGlnaXRzKCZwKSAqIDEwMjQ7CisgICAgaWYgKCpwICE9IE5VTCkKKwlyZXR1cm4gRkFJTDsKKworICAgIGlmIChzdGFydCA9PSAwIHx8IGluYyA9PSAwIHx8IGFkZGVkID09IDAgfHwgaW5jID4gc3RhcnQpCisJcmV0dXJuIEZBSUw7CisKKyAgICBjb21wcmVzc19zdGFydCA9IHN0YXJ0OworICAgIGNvbXByZXNzX2luYyA9IGluYzsKKyAgICBjb21wcmVzc19hZGRlZCA9IGFkZGVkOworICAgIHJldHVybiBPSzsKK30KKworCisvKgogICogR2V0IGEgd29yZG5vZGVfVCwgZWl0aGVyIGZyb20gdGhlIGxpc3Qgb2YgcHJldmlvdXNseSBmcmVlZCBub2RlcyBvcgogICogYWxsb2NhdGUgYSBuZXcgb25lLgogICovCkBAIC01NTMyLDcgKzYxMTIsNyBAQAogfQogCiAvKgotICogV3JpdGUgdGhlIFZpbSBzcGVsbCBmaWxlICJmbmFtZSIuCisgKiBXcml0ZSB0aGUgVmltIC5zcGwgZmlsZSAiZm5hbWUiLgogICovCiAgICAgc3RhdGljIHZvaWQKIHdyaXRlX3ZpbV9zcGVsbChzcGluLCBmbmFtZSkKQEAgLTU1NTgsOTQgKzYxMzgsMTQyIEBACiAJcmV0dXJuOwogICAgIH0KIAotICAgIC8qIDxIRUFERVI+OiA8ZmlsZUlEPiA8cmVnaW9uY250PiA8cmVnaW9ubmFtZT4gLi4uCi0gICAgICoJCSA8Y2hhcmZsYWdzbGVuPiA8Y2hhcmZsYWdzPgotICAgICAqCQkgPGZjaGFyc2xlbj4gPGZjaGFycz4KLSAgICAgKgkJIDxtaWR3b3JkbGVuPiA8bWlkd29yZD4KLSAgICAgKgkJIDxjb21wb3VuZGxlbj4gPGNvbXBvdW5kdHlwZT4gPGNvbXBvdW5kaW5mbz4KLSAgICAgKgkJIDxwcmVmY29uZGNudD4gPHByZWZjb25kPiAuLi4gKi8KLQorICAgIC8qIDxIRUFERVI+OiA8ZmlsZUlEPiA8dmVyc2lvbm5yPiAqLwogCQkJCQkJCSAgICAvKiA8ZmlsZUlEPiAqLwogICAgIGlmIChmd3JpdGUoVklNU1BFTExNQUdJQywgVklNU1BFTExNQUdJQ0wsIChzaXplX3QpMSwgZmQpICE9IDEpCiAJRU1TRyhfKGVfd3JpdGUpKTsKKyAgICBwdXRjKFZJTVNQRUxMVkVSU0lPTiwgZmQpOwkJCQkgICAgLyogPHZlcnNpb25ucj4gKi8KIAotICAgIC8qIHdyaXRlIHRoZSByZWdpb24gbmFtZXMgaWYgdGhlcmUgaXMgbW9yZSB0aGFuIG9uZSAqLworICAgIC8qCisgICAgICogPFNFQ1RJT05TPjogPHNlY3Rpb24+IC4uLiA8c2VjdGlvbmVuZD4KKyAgICAgKi8KKworICAgIC8qIFNOX1JFR0lPTjogPHJlZ2lvbm5hbWU+IC4uLgorICAgICAqIFdyaXRlIHRoZSByZWdpb24gbmFtZXMgb25seSBpZiB0aGVyZSBpcyBtb3JlIHRoYW4gb25lLiAqLwogICAgIGlmIChzcGluLT5zaV9yZWdpb25fY291bnQgPiAxKQogICAgIHsKLQlwdXRjKHNwaW4tPnNpX3JlZ2lvbl9jb3VudCwgZmQpOyAgIC8qIDxyZWdpb25jbnQ+IDxyZWdpb25uYW1lPiAuLi4gKi8KLQlmd3JpdGUoc3Bpbi0+c2lfcmVnaW9uX25hbWUsIChzaXplX3QpKHNwaW4tPnNpX3JlZ2lvbl9jb3VudCAqIDIpLAotCQkJCQkJCSAgICAgICAoc2l6ZV90KTEsIGZkKTsKKwlwdXRjKFNOX1JFR0lPTiwgZmQpOwkJCQkvKiA8c2VjdGlvbklEPiAqLworCXB1dGMoU05GX1JFUVVJUkVELCBmZCk7CQkJCS8qIDxzZWN0aW9uZmxhZ3M+ICovCisJbCA9IHNwaW4tPnNpX3JlZ2lvbl9jb3VudCAqIDI7CisJcHV0X2J5dGVzKGZkLCAobG9uZ191KWwsIDQpOwkJCS8qIDxzZWN0aW9ubGVuPiAqLworCWZ3cml0ZShzcGluLT5zaV9yZWdpb25fbmFtZSwgKHNpemVfdClsLCAoc2l6ZV90KTEsIGZkKTsKKwkJCQkJCQkvKiA8cmVnaW9ubmFtZT4gLi4uICovCiAJcmVnaW9ubWFzayA9ICgxIDw8IHNwaW4tPnNpX3JlZ2lvbl9jb3VudCkgLSAxOwogICAgIH0KICAgICBlbHNlCi0gICAgewotCXB1dGMoMCwgZmQpOwogCXJlZ2lvbm1hc2sgPSAwOwotICAgIH0KIAotICAgIC8qCi0gICAgICogV3JpdGUgdGhlIHRhYmxlIHdpdGggY2hhcmFjdGVyIGZsYWdzIGFuZCB0YWJsZSBmb3IgY2FzZSBmb2xkaW5nLgotICAgICAqIDxjaGFyZmxhZ3NsZW4+IDxjaGFyZmxhZ3M+ICA8ZmNoYXJsZW4+IDxmY2hhcnM+CisgICAgLyogU05fQ0hBUkZMQUdTOiA8Y2hhcmZsYWdzbGVuPiA8Y2hhcmZsYWdzPiA8Zm9sY2hhcnNsZW4+IDxmb2xjaGFycz4KKyAgICAgKgorICAgICAqIFRoZSB0YWJsZSB3aXRoIGNoYXJhY3RlciBmbGFncyBhbmQgdGhlIHRhYmxlIGZvciBjYXNlIGZvbGRpbmcuCisgICAgICogVGhpcyBtYWtlcyBzdXJlIHRoZSBzYW1lIGNoYXJhY3RlcnMgYXJlIHJlY29nbml6ZWQgYXMgd29yZCBjaGFyYWN0ZXJzCisgICAgICogd2hlbiBnZW5lcmF0aW5nIGFuIHdoZW4gdXNpbmcgYSBzcGVsbCBmaWxlLgogICAgICAqIFNraXAgdGhpcyBmb3IgQVNDSUksIHRoZSB0YWJsZSBtYXkgY29uZmxpY3Qgd2l0aCB0aGUgb25lIHVzZWQgZm9yCiAgICAgICogJ2VuY29kaW5nJy4KICAgICAgKiBBbHNvIHNraXAgdGhpcyBmb3IgYW4gLmFkZC5zcGwgZmlsZSwgdGhlIG1haW4gc3BlbGwgZmlsZSBtdXN0IGNvbnRhaW4KICAgICAgKiB0aGUgdGFibGUgKGF2b2lkcyB0aGF0IGl0IGNvbmZsaWN0cykuICBGaWxlIGlzIHNob3J0ZXIgdG9vLgogICAgICAqLwotICAgIGlmIChzcGluLT5zaV9hc2NpaSB8fCBzcGluLT5zaV9hZGQpCisgICAgaWYgKCFzcGluLT5zaV9hc2NpaSAmJiAhc3Bpbi0+c2lfYWRkKQogICAgIHsKLQlwdXRjKDAsIGZkKTsKLQlwdXRjKDAsIGZkKTsKLQlwdXRjKDAsIGZkKTsKKwljaGFyX3UJZm9sY2hhcnNbMTI4ICogOF07CisJaW50CWZsYWdzOworCisJcHV0YyhTTl9NSURXT1JELCBmZCk7CQkJCS8qIDxzZWN0aW9uSUQ+ICovCisJcHV0YyhTTkZfUkVRVUlSRUQsIGZkKTsJCQkJLyogPHNlY3Rpb25mbGFncz4gKi8KKworCS8qIEZvcm0gdGhlIDxmb2xjaGFycz4gc3RyaW5nIGZpcnN0LCB3ZSBuZWVkIHRvIGtub3cgaXRzIGxlbmd0aC4gKi8KKwlsID0gMDsKKwlmb3IgKGkgPSAxMjg7IGkgPCAyNTY7ICsraSkKKwl7CisjaWZkZWYgRkVBVF9NQllURQorCSAgICBpZiAoaGFzX21ieXRlKQorCQlsICs9IG1iX2NoYXIyYnl0ZXMoc3BlbGx0YWIuc3RfZm9sZFtpXSwgZm9sY2hhcnMgKyBsKTsKKwkgICAgZWxzZQorI2VuZGlmCisJCWZvbGNoYXJzW2wrK10gPSBzcGVsbHRhYi5zdF9mb2xkW2ldOworCX0KKwlwdXRfYnl0ZXMoZmQsIChsb25nX3UpKDEgKyAxMjggKyAyICsgbCksIDQpOwkvKiA8c2VjdGlvbmxlbj4gKi8KKworCWZwdXRjKDEyOCwgZmQpOwkJCQkJLyogPGNoYXJmbGFnc2xlbj4gKi8KKwlmb3IgKGkgPSAxMjg7IGkgPCAyNTY7ICsraSkKKwl7CisJICAgIGZsYWdzID0gMDsKKwkgICAgaWYgKHNwZWxsdGFiLnN0X2lzd1tpXSkKKwkJZmxhZ3MgfD0gQ0ZfV09SRDsKKwkgICAgaWYgKHNwZWxsdGFiLnN0X2lzdVtpXSkKKwkJZmxhZ3MgfD0gQ0ZfVVBQRVI7CisJICAgIGZwdXRjKGZsYWdzLCBmZCk7CQkJCS8qIDxjaGFyZmxhZ3M+ICovCisJfQorCisJcHV0X2J5dGVzKGZkLCAobG9uZ191KWwsIDIpOwkJCS8qIDxmb2xjaGFyc2xlbj4gKi8KKwlmd3JpdGUoZm9sY2hhcnMsIChzaXplX3QpbCwgKHNpemVfdCkxLCBmZCk7CS8qIDxmb2xjaGFycz4gKi8KICAgICB9Ci0gICAgZWxzZQotCXdyaXRlX3NwZWxsX2NoYXJ0YWIoZmQpOwogCi0KLSAgICBpZiAoc3Bpbi0+c2lfbWlkd29yZCA9PSBOVUxMKQotCXB1dF9ieXRlcyhmZCwgMEwsIDIpOwkJCS8qIDxtaWR3b3JkbGVuPiAqLwotICAgIGVsc2UKKyAgICAvKiBTTl9NSURXT1JEOiA8bWlkd29yZD4gKi8KKyAgICBpZiAoc3Bpbi0+c2lfbWlkd29yZCAhPSBOVUxMKQogICAgIHsKKwlwdXRjKFNOX01JRFdPUkQsIGZkKTsJCQkJLyogPHNlY3Rpb25JRD4gKi8KKwlwdXRjKFNORl9SRVFVSVJFRCwgZmQpOwkJCQkvKiA8c2VjdGlvbmZsYWdzPiAqLworCiAJaSA9IFNUUkxFTihzcGluLT5zaV9taWR3b3JkKTsKLQlwdXRfYnl0ZXMoZmQsIChsb25nX3UpaSwgMik7CQkvKiA8bWlkd29yZGxlbj4gKi8KKwlwdXRfYnl0ZXMoZmQsIChsb25nX3UpaSwgNCk7CQkJLyogPHNlY3Rpb25sZW4+ICovCiAJZndyaXRlKHNwaW4tPnNpX21pZHdvcmQsIChzaXplX3QpaSwgKHNpemVfdCkxLCBmZCk7IC8qIDxtaWR3b3JkPiAqLwogICAgIH0KIAotCi0gICAgLyogV3JpdGUgdGhlIGNvbXBvdW5kIGluZm8uICovCi0gICAgaWYgKHNwaW4tPnNpX2NvbXBmbGFncyA9PSBOVUxMKQotCXB1dF9ieXRlcyhmZCwgMEwsIDIpOwkJCS8qIDxjb21wb3VuZGxlbj4gKi8KLSAgICBlbHNlCisgICAgLyogU05fUFJFRkNPTkQ6IDxwcmVmY29uZGNudD4gPHByZWZjb25kPiAuLi4gKi8KKyAgICBpZiAoc3Bpbi0+c2lfcHJlZmNvbmQuZ2FfbGVuID4gMCkKICAgICB7Ci0JbCA9IFNUUkxFTihzcGluLT5zaV9jb21wZmxhZ3MpOwotCXB1dF9ieXRlcyhmZCwgKGxvbmdfdSkobCArIDIpLCAyKTsJLyogPGNvbXBvdW5kbGVuPiAqLwotCXB1dGMoMSwgZmQpOwkJCQkvKiA8Y29tcG91bmR0eXBlPiAqLwotCXB1dGMoc3Bpbi0+c2lfY29tcG1pbmxlbiwgZmQpOwkJLyogPGNvbXAxbWlubGVuPiAqLwotCWZ3cml0ZShzcGluLT5zaV9jb21wZmxhZ3MsIChzaXplX3QpbCwgKHNpemVfdCkxLCBmZCk7Ci0JCQkJCQkvKiA8Y29tcDFmbGFncz4gKi8KKwlwdXRjKFNOX1BSRUZDT05ELCBmZCk7CQkJCS8qIDxzZWN0aW9uSUQ+ICovCisJcHV0YyhTTkZfUkVRVUlSRUQsIGZkKTsJCQkJLyogPHNlY3Rpb25mbGFncz4gKi8KKworCWwgPSB3cml0ZV9zcGVsbF9wcmVmY29uZChOVUxMLCAmc3Bpbi0+c2lfcHJlZmNvbmQpOworCXB1dF9ieXRlcyhmZCwgKGxvbmdfdSlsLCA0KTsJCQkvKiA8c2VjdGlvbmxlbj4gKi8KKworCXdyaXRlX3NwZWxsX3ByZWZjb25kKGZkLCAmc3Bpbi0+c2lfcHJlZmNvbmQpOwogICAgIH0KIAotCi0gICAgLyogV3JpdGUgdGhlIHByZWZpeCBjb25kaXRpb25zLiAqLwotICAgIHdyaXRlX3NwZWxsX3ByZWZjb25kKGZkLCAmc3Bpbi0+c2lfcHJlZmNvbmQpOwotCi0gICAgLyogPFNVR0dFU1Q+IDogPHJlcGNvdW50PiA8cmVwPiAuLi4KLSAgICAgKiAgICAgICAgICAgICA8c2FsZmxhZ3M+IDxzYWxjb3VudD4gPHNhbD4gLi4uCi0gICAgICogICAgICAgICAgICAgPG1hcGxlbj4gPG1hcHN0cj4gKi8KKyAgICAvKiBTTl9SRVA6IDxyZXBjb3VudD4gPHJlcD4gLi4uCisgICAgICogU05fU0FMOiA8c2FsZmxhZ3M+IDxzYWxjb3VudD4gPHNhbD4gLi4uICovCiAKICAgICAvKiBTb3J0IHRoZSBSRVAgaXRlbXMuICovCiAgICAgcXNvcnQoc3Bpbi0+c2lfcmVwLmdhX2RhdGEsIChzaXplX3Qpc3Bpbi0+c2lfcmVwLmdhX2xlbiwKIAkJCQkJICAgICAgIHNpemVvZihmcm9tdG9fVCksIHJlcF9jb21wYXJlKTsKIAotICAgIC8qIHJvdW5kIDE6IFJFUCBpdGVtcwotICAgICAqIHJvdW5kIDI6IFNBTCBpdGVtcyAodW5sZXNzIFNPRk8gaXMgdXNlZCkgKi8KKyAgICAvKiByb3VuZCAxOiBTTl9SRVAgc2VjdGlvbgorICAgICAqIHJvdW5kIDI6IFNOX1NBTCBzZWN0aW9uICh1bmxlc3MgU05fU09GTyBpcyB1c2VkKSAqLwogICAgIGZvciAocm91bmQgPSAxOyByb3VuZCA8PSAyOyArK3JvdW5kKQogICAgIHsKIAlpZiAocm91bmQgPT0gMSkKKwl7CiAJICAgIGdhcCA9ICZzcGluLT5zaV9yZXA7CisJICAgIHB1dGMoU05fUkVQLCBmZCk7CQkJCS8qIDxzZWN0aW9uSUQ+ICovCisJfQogCWVsc2UKIAl7CisJICAgIGlmIChzcGluLT5zaV9zb2ZvZnIgIT0gTlVMTCAmJiBzcGluLT5zaV9zb2ZvdG8gIT0gTlVMTCkKKwkJLyogdXNpbmcgU05fU09GTyBzZWN0aW9uIGluc3RlYWQgb2YgU05fU0FMICovCisJCWJyZWFrOwogCSAgICBnYXAgPSAmc3Bpbi0+c2lfc2FsOworCSAgICBwdXRjKFNOX1NBTCwgZmQpOwkJCQkvKiA8c2VjdGlvbklEPiAqLworCX0KIAorCS8qIFRoaXMgaXMgZm9yIG1ha2luZyBzdWdnZXN0aW9ucywgc2VjdGlvbiBpcyBub3QgcmVxdWlyZWQuICovCisJcHV0YygwLCBmZCk7CQkJCQkvKiA8c2VjdGlvbmZsYWdzPiAqLworCisJLyogQ29tcHV0ZSB0aGUgbGVuZ3RoIG9mIHdoYXQgZm9sbG93cy4gKi8KKwlsID0gMjsJICAgIC8qIGNvdW50IDxyZXBjb3VudD4gb3IgPHNhbGNvdW50PiAqLworCWZvciAoaSA9IDA7IGkgPCBnYXAtPmdhX2xlbjsgKytpKQorCXsKKwkgICAgZnRwID0gJigoZnJvbXRvX1QgKilnYXAtPmdhX2RhdGEpW2ldOworCSAgICBsICs9IDEgKyBTVFJMRU4oZnRwLT5mdF9mcm9tKTsgIC8qIGNvdW50IDwqZnJvbWxlbj4gYW5kIDwqZnJvbT4gKi8KKwkgICAgbCArPSAxICsgU1RSTEVOKGZ0cC0+ZnRfdG8pOyAgICAvKiBjb3VudCA8KnRvbGVuPiBhbmQgPCp0bz4gKi8KKwl9CisJaWYgKHJvdW5kID09IDIpCisJICAgICsrbDsJLyogY291bnQgPHNhbGZsYWdzPiAqLworCXB1dF9ieXRlcyhmZCwgKGxvbmdfdSlsLCA0KTsJCQkvKiA8c2VjdGlvbmxlbj4gKi8KKworCWlmIChyb3VuZCA9PSAyKQorCXsKIAkgICAgaSA9IDA7CiAJICAgIGlmIChzcGluLT5zaV9mb2xsb3d1cCkKIAkJaSB8PSBTQUxfRjBMTE9XVVA7CkBAIC01NjUzLDExICs2MjgxLDcgQEAKIAkJaSB8PSBTQUxfQ09MTEFQU0U7CiAJICAgIGlmIChzcGluLT5zaV9yZW1fYWNjZW50cykKIAkJaSB8PSBTQUxfUkVNX0FDQ0VOVFM7Ci0JICAgIGlmIChzcGluLT5zaV9zb2ZvZnIgIT0gTlVMTCAmJiBzcGluLT5zaV9zb2ZvdG8gIT0gTlVMTCkKLQkJaSB8PSBTQUxfU09GTzsKIAkgICAgcHV0YyhpLCBmZCk7CQkJLyogPHNhbGZsYWdzPiAqLwotCSAgICBpZiAoaSAmIFNBTF9TT0ZPKQotCQlicmVhazsKIAl9CiAKIAlwdXRfYnl0ZXMoZmQsIChsb25nX3UpZ2FwLT5nYV9sZW4sIDIpOwkvKiA8cmVwY291bnQ+IG9yIDxzYWxjb3VudD4gKi8KQEAgLTU2NzQsMjYgKzYyOTgsNzMgQEAKIAkJZndyaXRlKHAsIGwsIChzaXplX3QpMSwgZmQpOwogCSAgICB9CiAJfQorCiAgICAgfQogCi0gICAgLyogU09GT0ZST00gYW5kIFNPRk9UTyAqLworICAgIC8qIFNOX1NPRk86IDxzb2ZvZnJvbWxlbj4gPHNvZm9mcm9tPiA8c29mb3RvbGVuPiA8c29mb3RvPgorICAgICAqIFRoaXMgaXMgZm9yIG1ha2luZyBzdWdnZXN0aW9ucywgc2VjdGlvbiBpcyBub3QgcmVxdWlyZWQuICovCiAgICAgaWYgKHNwaW4tPnNpX3NvZm9mciAhPSBOVUxMICYmIHNwaW4tPnNpX3NvZm90byAhPSBOVUxMKQogICAgIHsKLQlwdXRfYnl0ZXMoZmQsIDFMLCAyKTsJCQkJLyogPHNhbGNvdW50PiAqLworCXB1dGMoU05fU09GTywgZmQpOwkJCQkvKiA8c2VjdGlvbklEPiAqLworCXB1dGMoMCwgZmQpOwkJCQkJLyogPHNlY3Rpb25mbGFncz4gKi8KIAogCWwgPSBTVFJMRU4oc3Bpbi0+c2lfc29mb2ZyKTsKLQlwdXRfYnl0ZXMoZmQsIChsb25nX3UpbCwgMik7CQkJLyogPHNhbGZyb21sZW4+ICovCi0JZndyaXRlKHNwaW4tPnNpX3NvZm9mciwgbCwgKHNpemVfdCkxLCBmZCk7CS8qIDxzYWxmcm9tPiAqLworCXB1dF9ieXRlcyhmZCwgKGxvbmdfdSkobCArIFNUUkxFTihzcGluLT5zaV9zb2ZvdG8pICsgNCksIDQpOworCQkJCQkJCS8qIDxzZWN0aW9ubGVuPiAqLworCisJcHV0X2J5dGVzKGZkLCAobG9uZ191KWwsIDIpOwkJCS8qIDxzb2ZvZnJvbWxlbj4gKi8KKwlmd3JpdGUoc3Bpbi0+c2lfc29mb2ZyLCBsLCAoc2l6ZV90KTEsIGZkKTsJLyogPHNvZm9mcm9tPiAqLwogCiAJbCA9IFNUUkxFTihzcGluLT5zaV9zb2ZvdG8pOwotCXB1dF9ieXRlcyhmZCwgKGxvbmdfdSlsLCAyKTsJCQkvKiA8c2FsdG9sZW4+ICovCi0JZndyaXRlKHNwaW4tPnNpX3NvZm90bywgbCwgKHNpemVfdCkxLCBmZCk7CS8qIDxzYWx0bz4gKi8KKwlwdXRfYnl0ZXMoZmQsIChsb25nX3UpbCwgMik7CQkJLyogPHNvZm90b2xlbj4gKi8KKwlmd3JpdGUoc3Bpbi0+c2lfc29mb3RvLCBsLCAoc2l6ZV90KTEsIGZkKTsJLyogPHNvZm90bz4gKi8KICAgICB9CiAKLSAgICBwdXRfYnl0ZXMoZmQsIChsb25nX3Upc3Bpbi0+c2lfbWFwLmdhX2xlbiwgMik7CS8qIDxtYXBsZW4+ICovCi0gICAgaWYgKHNwaW4tPnNpX21hcC5nYV9sZW4gPiAwKQkJCS8qIDxtYXBzdHI+ICovCi0JZndyaXRlKHNwaW4tPnNpX21hcC5nYV9kYXRhLCAoc2l6ZV90KXNwaW4tPnNpX21hcC5nYV9sZW4sCi0JCQkJCQkJICAgICAgIChzaXplX3QpMSwgZmQpOworICAgIC8qIFNOX01BUDogPG1hcHN0cj4KKyAgICAgKiBUaGlzIGlzIGZvciBtYWtpbmcgc3VnZ2VzdGlvbnMsIHNlY3Rpb24gaXMgbm90IHJlcXVpcmVkLiAqLworICAgIGlmIChzcGluLT5zaV9tYXAuZ2FfbGVuID4gMCkKKyAgICB7CisJcHV0YyhTTl9NQVAsIGZkKTsJCQkJLyogPHNlY3Rpb25JRD4gKi8KKwlwdXRjKDAsIGZkKTsJCQkJCS8qIDxzZWN0aW9uZmxhZ3M+ICovCisJbCA9IHNwaW4tPnNpX21hcC5nYV9sZW47CisJcHV0X2J5dGVzKGZkLCAobG9uZ191KWwsIDQpOwkJCS8qIDxzZWN0aW9ubGVuPiAqLworCWZ3cml0ZShzcGluLT5zaV9tYXAuZ2FfZGF0YSwgKHNpemVfdClsLCAoc2l6ZV90KTEsIGZkKTsKKwkJCQkJCQkvKiA8bWFwc3RyPiAqLworICAgIH0KKworICAgIC8qIFNOX0NPTVBPVU5EOiBjb21wb3VuZCBpbmZvLgorICAgICAqIFdlIGRvbid0IG1hcmsgaXQgcmVxdWlyZWQsIHdoZW4gbm90IHN1cHBvcnRlZCBhbGwgY29tcG91bmQgd29yZHMgd2lsbAorICAgICAqIGJlIGJhZCB3b3Jkcy4gKi8KKyAgICBpZiAoc3Bpbi0+c2lfY29tcGZsYWdzICE9IE5VTEwpCisgICAgeworCXB1dGMoU05fQ09NUE9VTkQsIGZkKTsJCQkJLyogPHNlY3Rpb25JRD4gKi8KKwlwdXRjKDAsIGZkKTsJCQkJCS8qIDxzZWN0aW9uZmxhZ3M+ICovCisKKwlsID0gU1RSTEVOKHNwaW4tPnNpX2NvbXBmbGFncyk7CisJcHV0X2J5dGVzKGZkLCAobG9uZ191KShsICsgMyksIDQpOwkJLyogPHNlY3Rpb25sZW4+ICovCisJcHV0YyhzcGluLT5zaV9jb21wbWF4LCBmZCk7CQkJLyogPGNvbXBtYXg+ICovCisJcHV0YyhzcGluLT5zaV9jb21wbWlubGVuLCBmZCk7CQkJLyogPGNvbXBtaW5sZW4+ICovCisJcHV0YyhzcGluLT5zaV9jb21wc3lsbWF4LCBmZCk7CQkJLyogPGNvbXBzeWxtYXg+ICovCisJCQkJCQkJLyogPGNvbXBmbGFncz4gKi8KKwlmd3JpdGUoc3Bpbi0+c2lfY29tcGZsYWdzLCAoc2l6ZV90KWwsIChzaXplX3QpMSwgZmQpOworICAgIH0KKworICAgIC8qIFNOX1NZTExBQkxFOiBzeWxsYWJsZSBpbmZvLgorICAgICAqIFdlIGRvbid0IG1hcmsgaXQgcmVxdWlyZWQsIHdoZW4gbm90IHN1cHBvcnRlZCBzeWxsYWJsZXMgd2lsbCBub3QgYmUKKyAgICAgKiBjb3VudGVkLiAqLworICAgIGlmIChzcGluLT5zaV9zeWxsYWJsZSAhPSBOVUxMKQorICAgIHsKKwlwdXRjKFNOX1NZTExBQkxFLCBmZCk7CQkJCS8qIDxzZWN0aW9uSUQ+ICovCisJcHV0YygwLCBmZCk7CQkJCQkvKiA8c2VjdGlvbmZsYWdzPiAqLworCisJbCA9IFNUUkxFTihzcGluLT5zaV9zeWxsYWJsZSk7CisJcHV0X2J5dGVzKGZkLCAobG9uZ191KWwsIDQpOwkJCS8qIDxzZWN0aW9ubGVuPiAqLworCWZ3cml0ZShzcGluLT5zaV9zeWxsYWJsZSwgKHNpemVfdClsLCAoc2l6ZV90KTEsIGZkKTsgLyogPHN5bGxhYmxlPiAqLworICAgIH0KKworICAgIC8qIGVuZCBvZiA8U0VDVElPTlM+ICovCisgICAgcHV0YyhTTl9FTkQsIGZkKTsJCQkJCS8qIDxzZWN0aW9uZW5kPiAqLworCiAKICAgICAvKgogICAgICAqIDxMV09SRFRSRUU+ICA8S1dPUkRUUkVFPiAgPFBSRUZJWFRSRUU+CkBAIC02NTQwLDcgKzcyMTEsNyBAQAogLyoKICAqIFNldCB0aGUgc3BlbGwgY2hhcmFjdGVyIHRhYmxlcyBmcm9tIHN0cmluZ3MgaW4gdGhlIC5zcGwgZmlsZS4KICAqLwotICAgIHN0YXRpYyBpbnQKKyAgICBzdGF0aWMgdm9pZAogc2V0X3NwZWxsX2NoYXJmbGFncyhmbGFncywgY250LCBmb2wpCiAgICAgY2hhcl91CSpmbGFnczsKICAgICBpbnQJCWNudDsJICAgIC8qIGxlbmd0aCBvZiAiZmxhZ3MiICovCkBAIC02NTc2LDcgKzcyNDcsNyBAQAogCX0KICAgICB9CiAKLSAgICByZXR1cm4gc2V0X3NwZWxsX2ZpbmlzaCgmbmV3X3N0KTsKKyAgICAodm9pZClzZXRfc3BlbGxfZmluaXNoKCZuZXdfc3QpOwogfQogCiAgICAgc3RhdGljIGludApAQCAtNjcxNiw4ICs3Mzg3LDkgQEAKIAogLyoKICAqIFdyaXRlIHRoZSB0YWJsZSB3aXRoIHByZWZpeCBjb25kaXRpb25zIHRvIHRoZSAuc3BsIGZpbGUuCisgKiBXaGVuICJmZCIgaXMgTlVMTCBvbmx5IGNvdW50IHRoZSBsZW5ndGggb2Ygd2hhdCBpcyB3cml0dGVuLgogICovCi0gICAgc3RhdGljIHZvaWQKKyAgICBzdGF0aWMgaW50CiB3cml0ZV9zcGVsbF9wcmVmY29uZChmZCwgZ2FwKQogICAgIEZJTEUJKmZkOwogICAgIGdhcnJheV9UCSpnYXA7CkBAIC02NzI1LDU4ICs3Mzk3LDMyIEBACiAgICAgaW50CQlpOwogICAgIGNoYXJfdQkqcDsKICAgICBpbnQJCWxlbjsKKyAgICBpbnQJCXRvdGxlbjsKIAotICAgIHB1dF9ieXRlcyhmZCwgKGxvbmdfdSlnYXAtPmdhX2xlbiwgMik7CSAgICAvKiA8cHJlZmNvbmRjbnQ+ICovCisgICAgaWYgKGZkICE9IE5VTEwpCisJcHV0X2J5dGVzKGZkLCAobG9uZ191KWdhcC0+Z2FfbGVuLCAyKTsJICAgIC8qIDxwcmVmY29uZGNudD4gKi8KKworICAgIHRvdGxlbiA9IDIgKyBnYXAtPmdhX2xlbjsgLyogbGVuZ3RoIG9mIDxwcmVmY29uZGNudD4gYW5kIDxjb25kbGVuPiBieXRlcyAqLwogCiAgICAgZm9yIChpID0gMDsgaSA8IGdhcC0+Z2FfbGVuOyArK2kpCiAgICAgewogCS8qIDxwcmVmY29uZD4gOiA8Y29uZGxlbj4gPGNvbmRzdHI+ICovCiAJcCA9ICgoY2hhcl91ICoqKWdhcC0+Z2FfZGF0YSlbaV07Ci0JaWYgKHAgPT0gTlVMTCkKLQkgICAgZnB1dGMoMCwgZmQpOwotCWVsc2UKKwlpZiAocCAhPSBOVUxMKQogCXsKIAkgICAgbGVuID0gU1RSTEVOKHApOwotCSAgICBmcHV0YyhsZW4sIGZkKTsKLQkgICAgZndyaXRlKHAsIChzaXplX3QpbGVuLCAoc2l6ZV90KTEsIGZkKTsKKwkgICAgaWYgKGZkICE9IE5VTEwpCisJICAgIHsKKwkJZnB1dGMobGVuLCBmZCk7CisJCWZ3cml0ZShwLCAoc2l6ZV90KWxlbiwgKHNpemVfdCkxLCBmZCk7CisJICAgIH0KKwkgICAgdG90bGVuICs9IGxlbjsKIAl9Ci0gICAgfQotfQotCi0vKgotICogV3JpdGUgdGhlIGN1cnJlbnQgdGFibGVzIGludG8gdGhlIC5zcGwgZmlsZS4KLSAqIFRoaXMgbWFrZXMgc3VyZSB0aGUgc2FtZSBjaGFyYWN0ZXJzIGFyZSByZWNvZ25pemVkIGFzIHdvcmQgY2hhcmFjdGVycyB3aGVuCi0gKiBnZW5lcmF0aW5nIGFuIHdoZW4gdXNpbmcgYSBzcGVsbCBmaWxlLgotICovCi0gICAgc3RhdGljIHZvaWQKLXdyaXRlX3NwZWxsX2NoYXJ0YWIoZmQpCi0gICAgRklMRQkqZmQ7Ci17Ci0gICAgY2hhcl91CWNoYXJidWZbMjU2ICogNF07Ci0gICAgaW50CQlsZW4gPSAwOwotICAgIGludAkJZmxhZ3M7Ci0gICAgaW50CQlpOwotCi0gICAgZnB1dGMoMTI4LCBmZCk7CQkJCSAgICAvKiA8Y2hhcmZsYWdzbGVuPiAqLwotICAgIGZvciAoaSA9IDEyODsgaSA8IDI1NjsgKytpKQotICAgIHsKLQlmbGFncyA9IDA7Ci0JaWYgKHNwZWxsdGFiLnN0X2lzd1tpXSkKLQkgICAgZmxhZ3MgfD0gQ0ZfV09SRDsKLQlpZiAoc3BlbGx0YWIuc3RfaXN1W2ldKQotCSAgICBmbGFncyB8PSBDRl9VUFBFUjsKLQlmcHV0YyhmbGFncywgZmQpOwkJCSAgICAvKiA8Y2hhcmZsYWdzPiAqLwotCi0jaWZkZWYgRkVBVF9NQllURQotCWlmIChoYXNfbWJ5dGUpCi0JICAgIGxlbiArPSBtYl9jaGFyMmJ5dGVzKHNwZWxsdGFiLnN0X2ZvbGRbaV0sIGNoYXJidWYgKyBsZW4pOwotCWVsc2UKLSNlbmRpZgotCSAgICBjaGFyYnVmW2xlbisrXSA9IHNwZWxsdGFiLnN0X2ZvbGRbaV07CisJZWxzZSBpZiAoZmQgIT0gTlVMTCkKKwkgICAgZnB1dGMoMCwgZmQpOwogICAgIH0KIAotICAgIHB1dF9ieXRlcyhmZCwgKGxvbmdfdSlsZW4sIDIpOwkJICAgIC8qIDxmY2hhcmxlbj4gKi8KLSAgICBmd3JpdGUoY2hhcmJ1ZiwgKHNpemVfdClsZW4sIChzaXplX3QpMSwgZmQpOyAgICAvKiA8ZmNoYXJzPiAqLworICAgIHJldHVybiB0b3RsZW47CiB9CiAKIC8qCkBAIC02ODM3LDI2ICs3NDgzLDM2IEBACiAjZGVmaW5lIFNQU19ET1VCTEUgIDQKIAogc3RhdGljIGludCBzcHNfZmxhZ3MgPSBTUFNfQkVTVDsKK3N0YXRpYyBpbnQgc3BzX2xpbWl0ID0gOTk5OTsKIAogLyoKICAqIENoZWNrIHRoZSAnc3BlbGxzdWdnZXN0JyBvcHRpb24uICBSZXR1cm4gRkFJTCBpZiBpdCdzIHdyb25nLgotICogU2V0cyAic3BzX2ZsYWdzIi4KKyAqIFNldHMgInNwc19mbGFncyIgYW5kICJzcHNfbGltaXQiLgogICovCiAgICAgaW50CiBzcGVsbF9jaGVja19zcHMoKQogewogICAgIGNoYXJfdQkqcDsKKyAgICBjaGFyX3UJKnM7CiAgICAgY2hhcl91CWJ1ZltNQVhQQVRITF07CiAgICAgaW50CQlmOwogCiAgICAgc3BzX2ZsYWdzID0gMDsKKyAgICBzcHNfbGltaXQgPSA5OTk5OwogCiAgICAgZm9yIChwID0gcF9zcHM7ICpwICE9IE5VTDsgKQogICAgIHsKIAljb3B5X29wdGlvbl9wYXJ0KCZwLCBidWYsIE1BWFBBVEhMLCAiLCIpOwogCiAJZiA9IDA7Ci0JaWYgKFNUUkNNUChidWYsICJiZXN0IikgPT0gMCkKKwlpZiAoVklNX0lTRElHSVQoKmJ1ZikpCisJeworCSAgICBzID0gYnVmOworCSAgICBzcHNfbGltaXQgPSBnZXRkaWdpdHMoJnMpOworCSAgICBpZiAoKnMgIT0gTlVMICYmICFWSU1fSVNESUdJVCgqcykpCisJCWYgPSAtMTsKKwl9CisJZWxzZSBpZiAoU1RSQ01QKGJ1ZiwgImJlc3QiKSA9PSAwKQogCSAgICBmID0gU1BTX0JFU1Q7CiAJZWxzZSBpZiAoU1RSQ01QKGJ1ZiwgImZhc3QiKSA9PSAwKQogCSAgICBmID0gU1BTX0ZBU1Q7CkBAIC02ODY5LDYgKzc1MjUsNyBAQAogCWlmIChmID09IC0xIHx8IChzcHNfZmxhZ3MgIT0gMCAmJiBmICE9IDApKQogCXsKIAkgICAgc3BzX2ZsYWdzID0gU1BTX0JFU1Q7CisJICAgIHNwc19saW1pdCA9IDk5OTk7CiAJICAgIHJldHVybiBGQUlMOwogCX0KIAlpZiAoZiAhPSAwKQpAQCAtNjkwMiw2ICs3NTU5LDcgQEAKICAgICBzdWdnZXN0X1QJKnN0cDsKICAgICBpbnQJCW1vdXNlX3VzZWQ7CiAgICAgaW50CQluZWVkX2NhcDsKKyAgICBpbnQJCWxpbWl0OwogCiAgICAgLyogRmluZCB0aGUgc3RhcnQgb2YgdGhlIGJhZGx5IHNwZWxsZWQgd29yZC4gKi8KICAgICBpZiAoc3BlbGxfbW92ZV90byhGT1JXQVJELCBUUlVFLCBUUlVFKSA9PSBGQUlMCkBAIC02OTM3LDggKzc1OTUsMTMgQEAKIAogICAgIGxpbmUgPSBtbF9nZXRfY3VybGluZSgpOwogCi0gICAgLyogR2V0IHRoZSBsaXN0IG9mIHN1Z2dlc3Rpb25zICovCi0gICAgc3BlbGxfZmluZF9zdWdnZXN0KGxpbmUgKyBjdXJ3aW4tPndfY3Vyc29yLmNvbCwgJnN1ZywgKGludClSb3dzIC0gMiwKKyAgICAvKiBHZXQgdGhlIGxpc3Qgb2Ygc3VnZ2VzdGlvbnMuICBMaW1pdCB0byAnbGluZXMnIC0gMiBvciB0aGUgbnVtYmVyIGluCisgICAgICogJ3NwZWxsc3VnZ2VzdCcsIHdoYXRldmVyIGlzIHNtYWxsZXIuICovCisgICAgaWYgKHNwc19saW1pdCA+IChpbnQpUm93cyAtIDIpCisJbGltaXQgPSAoaW50KVJvd3MgLSAyOworICAgIGVsc2UKKwlsaW1pdCA9IHNwc19saW1pdDsKKyAgICBzcGVsbF9maW5kX3N1Z2dlc3QobGluZSArIGN1cndpbi0+d19jdXJzb3IuY29sLCAmc3VnLCBsaW1pdCwKIAkJCQkJCQkgICAgICBUUlVFLCBuZWVkX2NhcCk7CiAKICAgICBpZiAoc3VnLnN1X2dhLmdhX2xlbiA9PSAwKQpAQCAtNzE1MSw4ICs3ODE0LDggQEAKICAgICBpbnQJCWFkZGxlbjsKICAgICBjaGFyX3UJKmxpbmU7CiAgICAgY2hhcl91CSpwOwotICAgIGludAkJZGlkb25lID0gRkFMU0U7CiAgICAgaW50CQlzYXZlX3dzID0gcF93czsKKyAgICBsaW5lbnJfVAlwcmV2X2xudW0gPSAwOwogCiAgICAgaWYgKHJlcGxfZnJvbSA9PSBOVUxMIHx8IHJlcGxfdG8gPT0gTlVMTCkKICAgICB7CkBAIC03MTY3LDYgKzc4MzAsOCBAQAogICAgIHNwcmludGYoKGNoYXIgKilmcm9tcGF0LCAiXFxWXFw8JXNcXD4iLCByZXBsX2Zyb20pOwogICAgIHBfd3MgPSBGQUxTRTsKIAorICAgIHN1Yl9uc3VicyA9IDA7CisgICAgc3ViX25saW5lcyA9IDA7CiAgICAgY3Vyd2luLT53X2N1cnNvci5sbnVtID0gMDsKICAgICB3aGlsZSAoIWdvdF9pbnQpCiAgICAgewpAQCAtNzE4OCw3ICs3ODUzLDEzIEBACiAJICAgIFNUUkNBVChwLCBsaW5lICsgY3Vyd2luLT53X2N1cnNvci5jb2wgKyBTVFJMRU4ocmVwbF9mcm9tKSk7CiAJICAgIG1sX3JlcGxhY2UoY3Vyd2luLT53X2N1cnNvci5sbnVtLCBwLCBGQUxTRSk7CiAJICAgIGNoYW5nZWRfYnl0ZXMoY3Vyd2luLT53X2N1cnNvci5sbnVtLCBjdXJ3aW4tPndfY3Vyc29yLmNvbCk7Ci0JICAgIGRpZG9uZSA9IFRSVUU7CisKKwkgICAgaWYgKGN1cndpbi0+d19jdXJzb3IubG51bSAhPSBwcmV2X2xudW0pCisJICAgIHsKKwkJKytzdWJfbmxpbmVzOworCQlwcmV2X2xudW0gPSBjdXJ3aW4tPndfY3Vyc29yLmxudW07CisJICAgIH0KKwkgICAgKytzdWJfbnN1YnM7CiAJfQogCWN1cndpbi0+d19jdXJzb3IuY29sICs9IFNUUkxFTihyZXBsX3RvKTsKICAgICB9CkBAIC03MTk3LDggKzc4NjgsMTAgQEAKICAgICBjdXJ3aW4tPndfY3Vyc29yID0gcG9zOwogICAgIHZpbV9mcmVlKGZyb21wYXQpOwogCi0gICAgaWYgKCFkaWRvbmUpCisgICAgaWYgKHN1Yl9uc3VicyA9PSAwKQogCUVNU0cyKF8oIkU3NTM6IE5vdCBmb3VuZDogJXMiKSwgcmVwbF9mcm9tKTsKKyAgICBlbHNlCisJZG9fc3ViX21zZyhGQUxTRSk7CiB9CiAKIC8qCkBAIC03NjUyLDEwICs4MzI1LDEyIEBACiAgICAgY2hhcl91CWZ3b3JkW01BWFdMRU5dOwkgICAgLyogY29weSBvZiB0aGUgYmFkIHdvcmQsIGNhc2UtZm9sZGVkICovCiAgICAgY2hhcl91CXR3b3JkW01BWFdMRU5dOwkgICAgLyogZ29vZCB3b3JkIGNvbGxlY3RlZCBzbyBmYXIgKi8KICAgICB0cnlzdGF0ZV9UCXN0YWNrW01BWFdMRU5dOwotICAgIGNoYXJfdQlwcmV3b3JkW01BWFdMRU4gKiAzXTsgLyogd29yZCBmb3VuZCB3aXRoIHByb3BlciBjYXNlIChhcHBlbmRlZAotCQkJCSAgICAgICAqIHRvIGZvciB3b3JkIHNwbGl0KSAqLwotICAgIGNoYXJfdQlwcmV3b3JkbGVuID0gMDsJICAgIC8qIGxlbmd0aCBvZiB3b3JkIGluICJwcmV3b3JkIiAqLwotICAgIGludAkJc3BsaXRvZmYgPSAwOwkgICAgLyogaW5kZXggaW4gdHdvcmQgYWZ0ZXIgbGFzdCBzcGxpdCAqLworICAgIGNoYXJfdQlwcmV3b3JkW01BWFdMRU4gKiAzXTsgLyogd29yZCBmb3VuZCB3aXRoIHByb3BlciBjYXNlOworCQkJCSAgICAgICAqIGNvbmNhdGFuYXRpb24gb2YgcHJlZml4IGNvbXBvdW5kCisJCQkJICAgICAgICogd29yZHMgYW5kIHNwbGl0IHdvcmQuICBOVUwgdGVybWluYXRlZAorCQkJCSAgICAgICAqIHdoZW4gZ29pbmcgZGVlcGVyIGJ1dCBub3Qgd2hlbiBjb21pbmcKKwkJCQkgICAgICAgKiBiYWNrLiAqLworICAgIGNoYXJfdQljb21wZmxhZ3NbTUFYV0xFTl07CS8qIGNvbXBvdW5kIGZsYWdzLCBvbmUgZm9yIGVhY2ggd29yZCAqLwogICAgIHRyeXN0YXRlX1QJKnNwOwogICAgIGludAkJbmV3c2NvcmU7CiAgICAgbGFuZ3BfVAkqbHA7CkBAIC03Njk2LDE2ICs4MzcxLDkgQEAKIAkgKi8KIAlkZXB0aCA9IDA7CiAJc3AgPSAmc3RhY2tbMF07CisJdmltX21lbXNldChzcCwgMCwgc2l6ZW9mKHRyeXN0YXRlX1QpKTsKIAlzcC0+dHNfc3RhdGUgPSBTVEFURV9TVEFSVDsKLQlzcC0+dHNfc2NvcmUgPSAwOwogCXNwLT50c19jdXJpID0gMTsKLQlzcC0+dHNfZmlkeCA9IDA7Ci0Jc3AtPnRzX2ZpZHh0cnkgPSAwOwotCXNwLT50c190d29yZGxlbiA9IDA7Ci0Jc3AtPnRzX2FycmlkeCA9IDA7Ci0jaWZkZWYgRkVBVF9NQllURQotCXNwLT50c190Y2hhcmxlbiA9IDA7Ci0jZW5kaWYKIAogCS8qCiAJICogV2hlbiB0aGVyZSBhcmUgcG9zdHBvbmVkIHByZWZpeGVzIHdlIG5lZWQgdG8gdXNlIHRoZXNlIGZpcnN0LiAgQXQKQEAgLTc3OTIsMTAgKzg0NjAsMTAgQEAKIAogCQkJLyogTW92ZSB0aGUgcHJlZml4IHRvIHByZXdvcmRbXSB3aXRoIHRoZSByaWdodCBjYXNlCiAJCQkgKiBhbmQgbWFrZSBmaW5kX2tlZXBjYXBfd29yZCgpIHdvcmtzLiAqLwotCQkJc3BsaXRvZmYgPSBzcC0+dHNfdHdvcmRsZW47Ci0JCQl0d29yZFtzcGxpdG9mZl0gPSBOVUw7CisJCQlzcC0+dHNfc3BsaXRvZmYgPSBzcC0+dHNfdHdvcmRsZW47CisJCQl0d29yZFtzcC0+dHNfc3BsaXRvZmZdID0gTlVMOwogCQkJbWFrZV9jYXNlX3dvcmQodHdvcmQsIHByZXdvcmQsIGZsYWdzKTsKLQkJCXByZXdvcmRsZW4gPSBTVFJMRU4ocHJld29yZCk7CisJCQlzcC0+dHNfcHJld29yZGxlbiA9IFNUUkxFTihwcmV3b3JkKTsKIAkJICAgIH0KIAkJICAgIGJyZWFrOwogCQl9CkBAIC03ODE0LDYgKzg0ODIsOSBAQAogCQkrK3NwLT50c19jdXJpOwkJLyogZWF0IG9uZSBOVUwgYnl0ZSAqLwogCiAJCWZsYWdzID0gKGludClpZHhzW2FycmlkeF07CisJCWZ3b3JkX2VuZHMgPSAoZndvcmRbc3AtPnRzX2ZpZHhdID09IE5VTAorCQkJICAgICAgIHx8ICFzcGVsbF9pc3dvcmRwKGZ3b3JkICsgc3AtPnRzX2ZpZHgsIGN1cmJ1ZikpOworCQl0d29yZFtzcC0+dHNfdHdvcmRsZW5dID0gTlVMOwogCiAJCWlmIChzcC0+dHNfcHJlZml4ZGVwdGggPT0gUEZEX0NPTVBPVU5EKQogCQl7CkBAIC03ODIxLDggKzg0OTIsMTMgQEAKIAkJICAgICAqIHdvcmQgZG9lcyBub3Qgc3VwcG9ydCBjb21wb3VuZGluZyB0aGVuIGdpdmUgdXAKIAkJICAgICAqIChzcGxpdHRpbmcgaXMgdHJpZWQgZm9yIHRoZSB3b3JkIHdpdGhvdXQgY29tcG91bmQKIAkJICAgICAqIGZsYWcpLiAqLwotCQkgICAgaWYgKHNwLT50c190d29yZGxlbiAtIHNwbGl0b2ZmIDwgc2xhbmctPnNsX2NvbXBtaW5sZW4KLQkJCQkJICAgICAgIHx8ICFjYW5fY29tcG91bmQoc2xhbmcsIGZsYWdzKSkKKwkJICAgIGlmICgoKHVuc2lnbmVkKWZsYWdzID4+IDI0KSA9PSAwCisJCQkgICAgfHwgc3AtPnRzX3R3b3JkbGVuIC0gc3AtPnRzX3NwbGl0b2ZmCisJCQkJCQkgICAgICAgPCBzbGFuZy0+c2xfY29tcG1pbmxlbikKKwkJCWJyZWFrOworCQkgICAgY29tcGZsYWdzW3NwLT50c19jb21wbGVuXSA9ICgodW5zaWduZWQpZmxhZ3MgPj4gMjQpOworCQkgICAgY29tcGZsYWdzW3NwLT50c19jb21wbGVuICsgMV0gPSBOVUw7CisJCSAgICBpZiAoZndvcmRfZW5kcyAmJiAhY2FuX2NvbXBvdW5kKHNsYW5nLCB0d29yZCwgY29tcGZsYWdzKSkKIAkJCWJyZWFrOwogCQl9CiAJCWVsc2UgaWYgKHNwLT50c19wcmVmaXhkZXB0aCA8IE1BWFdMRU4pCkBAIC03ODM5LDcgKzg1MTUsNyBAQAogCQkgICAgaWYgKGMgPiAwKQogCQkgICAgewogCQkJYyA9IHZhbGlkX3dvcmRfcHJlZml4KGMsIG4sIGZsYWdzLAotCQkJCQkgICAgICB0d29yZCArIHNwbGl0b2ZmLCBzbGFuZywgRkFMU0UpOworCQkJCSAgICAgICB0d29yZCArIHNwLT50c19zcGxpdG9mZiwgc2xhbmcsIEZBTFNFKTsKIAkJCWlmIChjID09IDApCiAJCQkgICAgYnJlYWs7CiAKQEAgLTc4NTMsMTEgKzg1MjksMTAgQEAKIAkJICogRm9ybSB0aGUgd29yZCB3aXRoIHByb3BlciBjYXNlIGluIHByZXdvcmQuCiAJCSAqIElmIHRoZXJlIGlzIGEgd29yZCBmcm9tIGEgcHJldmlvdXMgc3BsaXQsIGFwcGVuZC4KIAkJICovCi0JCXR3b3JkW3NwLT50c190d29yZGxlbl0gPSBOVUw7CiAJCWlmIChmbGFncyAmIFdGX0tFRVBDQVApCiAJCSAgICAvKiBNdXN0IGZpbmQgdGhlIHdvcmQgaW4gdGhlIGtlZXAtY2FzZSB0cmVlLiAqLwotCQkgICAgZmluZF9rZWVwY2FwX3dvcmQoc2xhbmcsIHR3b3JkICsgc3BsaXRvZmYsCi0JCQkJCQkJcHJld29yZCArIHByZXdvcmRsZW4pOworCQkgICAgZmluZF9rZWVwY2FwX3dvcmQoc2xhbmcsIHR3b3JkICsgc3AtPnRzX3NwbGl0b2ZmLAorCQkJCQkJIHByZXdvcmQgKyBzcC0+dHNfcHJld29yZGxlbik7CiAJCWVsc2UKIAkJewogCQkgICAgLyogSW5jbHVkZSBiYWRmbGFnczogaWYgdGhlIGJhZHdvcmQgaXMgb25lY2FwIG9yIGFsbGNhcApAQCAtNzg3MiwxOCArODU0NywxOCBAQAogI2VuZGlmCiAJCQkgICAgKQogCQkJYyA9IFdGX09ORUNBUDsKLQkJICAgIG1ha2VfY2FzZV93b3JkKHR3b3JkICsgc3BsaXRvZmYsCi0JCQkJCSAgICAgcHJld29yZCArIHByZXdvcmRsZW4sIGZsYWdzIHwgYyk7CisJCSAgICBtYWtlX2Nhc2Vfd29yZCh0d29yZCArIHNwLT50c19zcGxpdG9mZiwKKwkJCQkgICAgICBwcmV3b3JkICsgc3AtPnRzX3ByZXdvcmRsZW4sIGZsYWdzIHwgYyk7CiAJCX0KIAogCQkvKiBEb24ndCB1c2UgYSBiYW5uZWQgd29yZC4gIEl0IG1heSBhcHBlYXIgYWdhaW4gYXMgYSBnb29kCiAJCSAqIHdvcmQsIHRodXMgcmVtZW1iZXIgaXQuICovCiAJCWlmIChmbGFncyAmIFdGX0JBTk5FRCkKIAkJewotCQkgICAgYWRkX2Jhbm5lZChzdSwgcHJld29yZCArIHByZXdvcmRsZW4pOworCQkgICAgYWRkX2Jhbm5lZChzdSwgcHJld29yZCArIHNwLT50c19wcmV3b3JkbGVuKTsKIAkJICAgIGJyZWFrOwogCQl9Ci0JCWlmICh3YXNfYmFubmVkKHN1LCBwcmV3b3JkICsgcHJld29yZGxlbikKKwkJaWYgKHdhc19iYW5uZWQoc3UsIHByZXdvcmQgKyBzcC0+dHNfcHJld29yZGxlbikKIAkJCQkJCSAgIHx8IHdhc19iYW5uZWQoc3UsIHByZXdvcmQpKQogCQkgICAgYnJlYWs7CiAKQEAgLTc4OTUsMTEgKzg1NzAsOSBAQAogCQkgICAgbmV3c2NvcmUgKz0gU0NPUkVfUkFSRTsKIAogCQlpZiAoIXNwZWxsX3ZhbGlkX2Nhc2Uoc3UtPnN1X2JhZGZsYWdzLAotCQkJCQkgY2FwdHlwZShwcmV3b3JkICsgcHJld29yZGxlbiwgTlVMTCkpKQorCQkJCSAgY2FwdHlwZShwcmV3b3JkICsgc3AtPnRzX3ByZXdvcmRsZW4sIE5VTEwpKSkKIAkJICAgIG5ld3Njb3JlICs9IFNDT1JFX0lDQVNFOwogCi0JCWZ3b3JkX2VuZHMgPSAoZndvcmRbc3AtPnRzX2ZpZHhdID09IE5VTAotCQkJICAgICAgIHx8ICFzcGVsbF9pc3dvcmRwKGZ3b3JkICsgc3AtPnRzX2ZpZHgsIGN1cmJ1ZikpOwogCQlpZiAoZndvcmRfZW5kcyAmJiBzcC0+dHNfZmlkeCA+PSBzcC0+dHNfZmlkeHRyeSkKIAkJewogCQkgICAgLyogVGhlIGJhZHdvcmQgYWxzbyBlbmRzOiBhZGQgc3VnZ2VzdGlvbnMuICBHaXZlIGEgcGVuYWx0eQpAQCAtNzk0OCwxMSArODYyMSwxOCBAQAogCQkgICAgICogICAgdGhlIGZvbGxvd2luZyB3b3JkIGlzIHZhbGlkLgogCQkgICAgICovCiAJCSAgICBpZiAoIWZ3b3JkX2VuZHMKLQkJCSAgICAmJiBzcGVsbF9pc3dvcmRwKGZ3b3JkICsgc3AtPnRzX2ZpZHgsIGN1cmJ1ZikKLQkJCSAgICAmJiBzcC0+dHNfdHdvcmRsZW4gLSBzcGxpdG9mZgorCQkJICAgICYmICgodW5zaWduZWQpZmxhZ3MgPj4gMjQpICE9IDAKKwkJCSAgICAmJiBzcC0+dHNfdHdvcmRsZW4gLSBzcC0+dHNfc3BsaXRvZmYKIAkJCQkJCSAgICAgID49IHNsYW5nLT5zbF9jb21wbWlubGVuCi0JCQkgICAgJiYgY2FuX2NvbXBvdW5kKHNsYW5nLCBmbGFncykpCisJCQkgICAgJiYgc3AtPnRzX2NvbXBsZW4gKyAxIDw9IHNsYW5nLT5zbF9jb21wbWF4CisJCQkgICAgJiYgKHNwLT50c19jb21wbGVuID4gMAorCQkJCXx8IHZpbV9zdHJjaHIoc2xhbmctPnNsX2NvbXBzdGFydGZsYWdzLAorCQkJCQkgICAgKCh1bnNpZ25lZClmbGFncyA+PiAyNCkpICE9IE5VTEwpKQorCQkgICAgewogCQkJdHJ5X2NvbXBvdW5kID0gVFJVRTsKKwkJCWNvbXBmbGFnc1tzcC0+dHNfY29tcGxlbl0gPSAoKHVuc2lnbmVkKWZsYWdzID4+IDI0KTsKKwkJCWNvbXBmbGFnc1tzcC0+dHNfY29tcGxlbiArIDFdID0gTlVMOworCQkgICAgfQogCQkgICAgZWxzZQogCQkgICAgewogCQkJdHJ5X2NvbXBvdW5kID0gRkFMU0U7CkBAIC03OTYzLDkgKzg2NDMsNyBAQAogCQkgICAgaWYgKHRyeV9kZWVwZXIoc3UsIHN0YWNrLCBkZXB0aCwgbmV3c2NvcmUpKQogCQkgICAgewogCQkJLyogU2F2ZSB0aGluZ3MgdG8gYmUgcmVzdG9yZWQgYXQgU1RBVEVfU1BMSVRVTkRPLiAqLwotCQkJc3AtPnRzX3NhdmVfcHJld29yZGxlbiA9IHByZXdvcmRsZW47CiAJCQlzcC0+dHNfc2F2ZV9iYWRmbGFncyA9IHN1LT5zdV9iYWRmbGFnczsKLQkJCXNwLT50c19zYXZlX3NwbGl0b2ZmID0gc3BsaXRvZmY7CiAJCQlzcC0+dHNfc3RhdGUgPSBTVEFURV9TUExJVFVORE87CiAKIAkJCSsrZGVwdGg7CkBAIC03OTc0LDggKzg2NTIsOCBAQAogCQkJLyogQXBwZW5kIGEgc3BhY2UgdG8gcHJld29yZCB3aGVuIHNwbGl0dGluZy4gKi8KIAkJCWlmICghdHJ5X2NvbXBvdW5kICYmICFmd29yZF9lbmRzKQogCQkJICAgIFNUUkNBVChwcmV3b3JkLCAiICIpOwotCQkJcHJld29yZGxlbiA9IFNUUkxFTihwcmV3b3JkKTsKLQkJCXNwbGl0b2ZmID0gc3AtPnRzX3R3b3JkbGVuOworCQkJc3AtPnRzX3ByZXdvcmRsZW4gPSBTVFJMRU4ocHJld29yZCk7CisJCQlzcC0+dHNfc3BsaXRvZmYgPSBzcC0+dHNfdHdvcmRsZW47CiAKIAkJCS8qIElmIHRoZSBiYWR3b3JkIGhhcyBhIG5vbi13b3JkIGNoYXJhY3RlciBhdCB0aGlzCiAJCQkgKiBwb3NpdGlvbiBza2lwIGl0LiAgVGhhdCBtZWFucyByZXBsYWNpbmcgdGhlCkBAIC03OTk2LDEwICs4Njc0LDEwIEBACiAJCQkgICAgaWYgKGZ3b3JkX2VuZHMpCiAJCQkgICAgewogCQkJCS8qIENvcHkgdGhlIHNraXBwZWQgY2hhcmFjdGVyIHRvIHByZXdvcmQuICovCi0JCQkJbWNoX21lbW1vdmUocHJld29yZCArIHByZXdvcmRsZW4sCisJCQkJbWNoX21lbW1vdmUocHJld29yZCArIHNwLT50c19wcmV3b3JkbGVuLAogCQkJCQkJICAgICAgZndvcmQgKyBzcC0+dHNfZmlkeCwgbCk7Ci0JCQkJcHJld29yZGxlbiArPSBsOwotCQkJCXByZXdvcmRbcHJld29yZGxlbl0gPSBOVUw7CisJCQkJc3AtPnRzX3ByZXdvcmRsZW4gKz0gbDsKKwkJCQlwcmV3b3JkW3NwLT50c19wcmV3b3JkbGVuXSA9IE5VTDsKIAkJCSAgICB9CiAJCQkgICAgZWxzZQogCQkJCXNwLT50c19zY29yZSAtPSBTQ09SRV9TUExJVCAtIFNDT1JFX1NVQlNUOwpAQCAtODAwOCw3ICs4Njg2LDEwIEBACiAKIAkJCS8qIHNldCBmbGFnIHRvIGNoZWNrIGNvbXBvdW5kIGZsYWcgb24gZm9sbG93aW5nIHdvcmQgKi8KIAkJCWlmICh0cnlfY29tcG91bmQpCisJCQl7CiAJCQkgICAgc3AtPnRzX3ByZWZpeGRlcHRoID0gUEZEX0NPTVBPVU5EOworCQkJICAgICsrc3AtPnRzX2NvbXBsZW47CisJCQl9CiAJCQllbHNlCiAJCQkgICAgc3AtPnRzX3ByZWZpeGRlcHRoID0gUEZEX05PUFJFRklYOwogCkBAIC04MDMyLDggKzg3MTMsNiBAQAogCSAgICBjYXNlIFNUQVRFX1NQTElUVU5ETzoKIAkJLyogVW5kbyB0aGUgY2hhbmdlcyBkb25lIGZvciB3b3JkIHNwbGl0IG9yIGNvbXBvdW5kIHdvcmQuICovCiAJCXN1LT5zdV9iYWRmbGFncyA9IHNwLT50c19zYXZlX2JhZGZsYWdzOwotCQlzcGxpdG9mZiA9IHNwLT50c19zYXZlX3NwbGl0b2ZmOwotCQlwcmV3b3JkbGVuID0gc3AtPnRzX3NhdmVfcHJld29yZGxlbjsKIAogCQkvKiBDb250aW51ZSBsb29raW5nIGZvciBOVUwgYnl0ZXMuICovCiAJCXNwLT50c19zdGF0ZSA9IFNUQVRFX1NUQVJUOwpAQCAtODY0NCw3ICs5MzIzLDYgQEAKIAkJICAgIC8qIENvbnRpbnVlIGluIG9yIGdvIGJhY2sgdG8gdGhlIHByZWZpeCB0cmVlLiAqLwogCQkgICAgYnl0cyA9IHBieXRzOwogCQkgICAgaWR4cyA9IHBpZHhzOwotCQkgICAgc3BsaXRvZmYgPSAwOwogCQl9CiAKIAkJLyogRG9uJ3QgY2hlY2sgZm9yIENUUkwtQyB0b28gb2Z0ZW4sIGl0IHRha2VzIHRpbWUuICovCkBAIC05MDc1LDYgKzk3NTMsNyBAQAogICAgIGludAkJcm91bmQ7CiAgICAgaW50CQlmbGFnczsKICAgICBpbnQJCXNvdW5kX3Njb3JlOworICAgIGludAkJbG9jYWxfc2NvcmU7CiAKICAgICAvKiBEbyB0aGlzIGZvciBhbGwgbGFuZ3VhZ2VzIHRoYXQgc3VwcG9ydCBzb3VuZCBmb2xkaW5nLiAqLwogICAgIGZvciAobHAgPSBMQU5HUF9FTlRSWShjdXJ3aW4tPndfYnVmZmVyLT5iX2xhbmdwLCAwKTsKQEAgLTkxMzgsNiArOTgxNywxNSBAQAogCQkJCSAqIHNvdW5kLWEtbGlrZSB3b3Jkcy4gKi8KIAkJCQlzb3VuZF9zY29yZSA9IHNvdW5kYWxpa2Vfc2NvcmUoc2Fsd29yZCwKIAkJCQkJCQkJICAgIHRzYWx3b3JkKTsKKworCQkJCS8qIEFkZCBhIHBlbmFsdHkgZm9yIHdvcmRzIGluIGFub3RoZXIgcmVnaW9uLiAqLworCQkJCWlmICgoZmxhZ3MgJiBXRl9SRUdJT04pICYmICgoKHVuc2lnbmVkKWZsYWdzCisJCQkJCQkgPj4gMTYpICYgbHAtPmxwX3JlZ2lvbikgPT0gMCkKKwkJCQkgICAgbG9jYWxfc2NvcmUgPSBTQ09SRV9SRUdJT047CisJCQkJZWxzZQorCQkJCSAgICBsb2NhbF9zY29yZSA9IDA7CisJCQkJc291bmRfc2NvcmUgKz0gbG9jYWxfc2NvcmU7CisKIAkJCQlpZiAoc291bmRfc2NvcmUgPCBTQ09SRV9NQVhNQVgpCiAJCQkJewogCQkJCSAgICBjaGFyX3UJY3dvcmRbTUFYV0xFTl07CkBAIC05MTYzLDcgKzk4NTEsOCBAQAogCQkJCSAgICB7CiAJCQkJCS8qIENvbXB1dGUgdGhlIHNjb3JlLiAqLwogCQkJCQlzY29yZSA9IHNwZWxsX2VkaXRfc2NvcmUoCi0JCQkJCQkJICAgc3UtPnN1X2JhZHdvcmQsIHApOworCQkJCQkJCSAgIHN1LT5zdV9iYWR3b3JkLCBwKQorCQkJCQkJICAgICsgbG9jYWxfc2NvcmU7CiAJCQkJCWlmIChzcHNfZmxhZ3MgJiBTUFNfQkVTVCkKIAkJCQkJICAgIC8qIGdpdmUgYSBib251cyBmb3IgdGhlIGdvb2Qgd29yZAogCQkJCQkgICAgICogc291bmRpbmcgdGhlIHNhbWUgYXMgdGhlIGJhZAo=