LyoKICogc2NoZW1hcy5jIDogaW1wbGVtZW50YXRpb24gb2YgdGhlIFhNTCBTY2hlbWEgaGFuZGxpbmcgYW5kCiAqICAgICAgICAgICAgIHNjaGVtYSB2YWxpZGl0eSBjaGVja2luZwogKgogKiBTZWUgQ29weXJpZ2h0IGZvciB0aGUgc3RhdHVzIG9mIHRoaXMgc29mdHdhcmUuCiAqCiAqIERhbmllbCBWZWlsbGFyZCA8dmVpbGxhcmRAcmVkaGF0LmNvbT4KICovCgovKgogKiBUT0RPOgogKiAgIC0gd2hlbiB0eXBlcyBhcmUgcmVkZWZpbmVkIGluIGluY2x1ZGVzLCBjaGVjayB0aGF0IGFsbAogKiAgICAgdHlwZXMgaW4gdGhlIHJlZGVmIGxpc3QgYXJlIGVxdWFsCiAqICAgICAtPiBuZWVkIGEgdHlwZSBlcXVhbGl0eSBvcGVyYXRpb24uCiAqICAgLSBpZiB3ZSBkb24ndCBpbnRlbmQgdG8gdXNlIHRoZSBzY2hlbWEgZm9yIHNjaGVtYXMsIHdlCiAqICAgICBuZWVkIHRvIHZhbGlkYXRlIGFsbCBzY2hlbWEgYXR0cmlidXRlcyAocmVmLCB0eXBlLCBuYW1lKQogKiAgICAgYWdhaW5zdCB0aGVpciB0eXBlcy4KICogICAtIEVsaW1pbmF0ZSBpdGVtIGNyZWF0aW9uIGZvcjogPz8KICoKICogVVJHRU5UIFRPRE86CiAqICAgLSBGb3IgeHNpLWRyaXZlbiBzY2hlbWEgYWNxdWlzaXRpb24sIGF1Z21lbnQgdGhlIElEQ3MgYWZ0ZXIgZXZlcnkKICogICAgIGFjcXVpc2l0aW9uIGVwaXNvZGUgKHhtbFNjaGVtYUF1Z21lbnRJREMpLgogKgogKiBOT1RFUzoKICogICAtIEVsaW1hdGVkIGl0ZW0gY3JlYXRpb24gZm9yOiA8cmVzdHJpY3Rpb24+LCA8ZXh0ZW5zaW9uPiwKICogICAgIDxzaW1wbGVDb250ZW50PiwgPGNvbXBsZXhDb250ZW50PiwgPGxpc3Q+LCA8dW5pb24+CiAqCiAqIFBST0JMRU1TOgogKiAgIC0gaHR0cDovL2xpc3RzLnczLm9yZy9BcmNoaXZlcy9QdWJsaWMvd3d3LXhtbC1zY2hlbWEtY29tbWVudHMvMjAwNUp1bFNlcC8wMzM3Lmh0bWwKICogICAgIElEQyBYUGF0aCBleHByZXNzaW9uIGFuZCBjaGFtZWxlb24gaW5jbHVkZXM6IHRoZSB0YXJnZXROYW1lc3BhY2UgaXMgY2hhbmdlZCwgc28KICogICAgIFhQYXRoIHdpbGwgaGF2ZSB0cm91YmxlIHRvIHJlc29sdmUgdG8gdGhpcyBuYW1lc3BhY2UsIHNpbmNlIG5vdCBrbm93bi4KICoKICoKICogQ09OU1RSQUlOVFM6CiAqCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogICBBbGwgR3JvdXAgTGltaXRlZCAoY29zLWFsbC1saW1pdGVkKQogKiAgIFN0YXR1czogY29tcGxldGUKICogICAoMS4yKQogKiAgICAgSW4geG1sU2NoZW1hR3JvdXBEZWZSZWZlcmVuY2VUZXJtRml4dXAoKSBhbmQKICogICAoMikKICogICAgIEluIHhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cCgpCiAqICAgICBUT0RPOiBBY3R1YWxseSB0aGlzIHNob3VsZCBnbyB0byBjb21wb25lbnQtbGV2ZWwgY2hlY2tzLAogKiAgICAgYnV0IGlzIGRvbmUgaGVyZSBkdWUgdG8gcGVyZm9ybWFuY2UuIE1vdmUgaXQgdG8gYW4gb3RoZXIgbGF5ZXIKICogICAgIGlzIHNjaGVtYSBjb25zdHJ1Y3Rpb24gdmlhIGFuIEFQSSBpcyBpbXBsZW1lbnRlZC4KICovCiNkZWZpbmUgSU5fTElCWE1MCiNpbmNsdWRlICJsaWJ4bWwuaCIKCiNpZmRlZiBMSUJYTUxfU0NIRU1BU19FTkFCTEVECgojaW5jbHVkZSA8c3RyaW5nLmg+CiNpbmNsdWRlIDxsaWJ4bWwveG1sbWVtb3J5Lmg+CiNpbmNsdWRlIDxsaWJ4bWwvcGFyc2VyLmg+CiNpbmNsdWRlIDxsaWJ4bWwvcGFyc2VySW50ZXJuYWxzLmg+CiNpbmNsdWRlIDxsaWJ4bWwvaGFzaC5oPgojaW5jbHVkZSA8bGlieG1sL3VyaS5oPgojaW5jbHVkZSA8bGlieG1sL3htbHNjaGVtYXMuaD4KI2luY2x1ZGUgPGxpYnhtbC9zY2hlbWFzSW50ZXJuYWxzLmg+CiNpbmNsdWRlIDxsaWJ4bWwveG1sc2NoZW1hc3R5cGVzLmg+CiNpbmNsdWRlIDxsaWJ4bWwveG1sYXV0b21hdGEuaD4KI2luY2x1ZGUgPGxpYnhtbC94bWxyZWdleHAuaD4KI2luY2x1ZGUgPGxpYnhtbC9kaWN0Lmg+CiNpbmNsdWRlIDxsaWJ4bWwvZW5jb2RpbmcuaD4KI2luY2x1ZGUgPGxpYnhtbC94bWxJTy5oPgojaWZkZWYgTElCWE1MX1BBVFRFUk5fRU5BQkxFRAojaW5jbHVkZSA8bGlieG1sL3BhdHRlcm4uaD4KI2VuZGlmCiNpZmRlZiBMSUJYTUxfUkVBREVSX0VOQUJMRUQKI2luY2x1ZGUgPGxpYnhtbC94bWxyZWFkZXIuaD4KI2VuZGlmCgovKiAjZGVmaW5lIERFQlVHIDEgKi8KCi8qICNkZWZpbmUgREVCVUdfQ09OVEVOVCAxICovCgovKiAjZGVmaW5lIERFQlVHX1RZUEUgMSAqLwoKLyogI2RlZmluZSBERUJVR19DT05URU5UX1JFR0VYUCAxICovCgovKiAjZGVmaW5lIERFQlVHX0FVVE9NQVRBIDEgKi8KCi8qICNkZWZpbmUgREVCVUdfSURDICovCgovKiAjZGVmaW5lIERFQlVHX0lEQ19OT0RFX1RBQkxFICovCgojaWZkZWYgREVCVUdfSURDCiAjaWZuZGVmIERFQlVHX0lEQ19OT0RFX1RBQkxFCiAgI2RlZmluZSBERUJVR19JRENfTk9ERV9UQUJMRQogI2VuZGlmCiNlbmRpZiAgIAoKLyogI2RlZmluZSBFTkFCTEVfUEFSVElDTEVfUkVTVFJJQ1RJT04gMSAqLwoKI2RlZmluZSBFTkFCTEVfUkVERUZJTkUKCi8qICNkZWZpbmUgRU5BQkxFX05BTUVEX0xPQ0FMUyAqLwoKLyogI2RlZmluZSBFTkFCTEVfSURDX05PREVfVEFCTEVTX1RFU1QgKi8KCiNkZWZpbmUgRFVNUF9DT05URU5UX01PREVMCgojaWZkZWYgTElCWE1MX1JFQURFUl9FTkFCTEVECi8qICNkZWZpbmUgWE1MX1NDSEVNQV9SRUFERVJfRU5BQkxFRCAqLwojZW5kaWYKCiNkZWZpbmUgVU5CT1VOREVEICgxIDw8IDMwKQojZGVmaW5lIFRPRE8gCQkJCQkJCQlcCiAgICB4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwJCQkJXAoJICAgICJVbmltcGxlbWVudGVkIGJsb2NrIGF0ICVzOiVkXG4iLAkJCQlcCiAgICAgICAgICAgIF9fRklMRV9fLCBfX0xJTkVfXyk7CgojZGVmaW5lIFhNTF9TQ0hFTUFTX05PX05BTUVTUEFDRSAoY29uc3QgeG1sQ2hhciAqKSAiIyMiCgovKgogKiBUaGUgWE1MIFNjaGVtYXMgbmFtZXNwYWNlcwogKi8Kc3RhdGljIGNvbnN0IHhtbENoYXIgKnhtbFNjaGVtYU5zID0gKGNvbnN0IHhtbENoYXIgKikKICAgICJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYSI7CgpzdGF0aWMgY29uc3QgeG1sQ2hhciAqeG1sU2NoZW1hSW5zdGFuY2VOcyA9IChjb25zdCB4bWxDaGFyICopCiAgICAiaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiOwoKc3RhdGljIGNvbnN0IHhtbENoYXIgKnhtbE5hbWVzcGFjZU5zID0gKGNvbnN0IHhtbENoYXIgKikKICAgICJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3htbG5zLyI7CgovKgoqIENvbWUgY2FzdGluZyBtYWNyb3MuCiovCiNkZWZpbmUgQUNUWFRfQ0FTVCAoeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyKQojZGVmaW5lIFBDVFhUX0NBU1QgKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIpCiNkZWZpbmUgVkNUWFRfQ0FTVCAoeG1sU2NoZW1hVmFsaWRDdHh0UHRyKQojZGVmaW5lIFdYU19CQVNJQ19DQVNUICh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIpCiNkZWZpbmUgV1hTX1RSRUVfQ0FTVCAoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpCiNkZWZpbmUgV1hTX1BUQ19DQVNUICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikKI2RlZmluZSBXWFNfVFlQRV9DQVNUICh4bWxTY2hlbWFUeXBlUHRyKQojZGVmaW5lIFdYU19FTEVNX0NBU1QgKHhtbFNjaGVtYUVsZW1lbnRQdHIpCiNkZWZpbmUgV1hTX0FUVFJfR1JPVVBfQ0FTVCAoeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIpCiNkZWZpbmUgV1hTX0FUVFJfQ0FTVCAoeG1sU2NoZW1hQXR0cmlidXRlUHRyKQojZGVmaW5lIFdYU19BVFRSX1VTRV9DQVNUICh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIpCiNkZWZpbmUgV1hTX0FUVFJfUFJPSElCX0NBU1QgKHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYlB0cikKI2RlZmluZSBXWFNfTU9ERUxfR1JPVVBERUZfQ0FTVCAoeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cikKI2RlZmluZSBXWFNfTU9ERUxfR1JPVVBfQ0FTVCAoeG1sU2NoZW1hTW9kZWxHcm91cFB0cikKI2RlZmluZSBXWFNfSURDX0NBU1QgKHhtbFNjaGVtYUlEQ1B0cikKI2RlZmluZSBXWFNfUU5BTUVfQ0FTVCAoeG1sU2NoZW1hUU5hbWVSZWZQdHIpCiNkZWZpbmUgV1hTX0xJU1RfQ0FTVCAoeG1sU2NoZW1hSXRlbUxpc3RQdHIpCgovKgoqIE1hY3JvcyB0byBxdWVyeSBjb21tb24gcHJvcGVydGllcyBvZiBjb21wb25lbnRzLgoqLwojZGVmaW5lIFdYU19JVEVNX05PREUoaSkgeG1sU2NoZW1hR2V0Q29tcG9uZW50Tm9kZShXWFNfQkFTSUNfQ0FTVCAoaSkpCgojZGVmaW5lIFdYU19JVEVNX1RZUEVfTkFNRShpKSB4bWxTY2hlbWFHZXRDb21wb25lbnRUeXBlU3RyKFdYU19CQVNJQ19DQVNUIChpKSkKLyoKKiBNYWNyb3MgZm9yIGVsZW1lbnQgZGVjbGFyYXRpb25zLgoqLwojZGVmaW5lIFdYU19FTEVNX1RZUEVERUYoZSkgKGUpLT5zdWJ0eXBlcwoKI2RlZmluZSBXWFNfU1VCU1RfSEVBRChpdGVtKSAoaXRlbSktPnJlZkRlY2wKLyoKKiBNYWNyb3MgZm9yIGF0dHJpYnV0ZSBkZWNsYXJhdGlvbnMuCiovCiNkZWZpbmUgV1hTX0FUVFJfVFlQRURFRihhKSAoYSktPnN1YnR5cGVzCi8qCiogTWFjcm9zIGZvciBhdHRyaWJ1dGUgdXNlcy4KKi8KI2RlZmluZSBXWFNfQVRUUlVTRV9ERUNMKGF1KSBXWFNfQVRUUl9DQVNUIChXWFNfQVRUUl9VU0VfQ0FTVCAoYXUpKS0+YXR0ckRlY2wKCiNkZWZpbmUgV1hTX0FUVFJVU0VfVFlQRURFRihhdSkgV1hTX0FUVFJfVFlQRURFRihXWFNfQVRUUlVTRV9ERUNMKCBXWFNfQVRUUl9VU0VfQ0FTVCBhdSkpCgojZGVmaW5lIFdYU19BVFRSVVNFX0RFQ0xfTkFNRShhdSkgKFdYU19BVFRSVVNFX0RFQ0woYXUpKS0+bmFtZQoKI2RlZmluZSBXWFNfQVRUUlVTRV9ERUNMX1ROUyhhdSkgKFdYU19BVFRSVVNFX0RFQ0woYXUpKS0+dGFyZ2V0TmFtZXNwYWNlCi8qCiogTWFjcm9zIGZvciBhdHRyaWJ1dGUgZ3JvdXBzLgoqLwojZGVmaW5lIFdYU19BVFRSX0dST1VQX0hBU19SRUZTKGFnKSAoKFdYU19BVFRSX0dST1VQX0NBU1QgKGFnKSktPmZsYWdzICYgWE1MX1NDSEVNQVNfQVRUUkdST1VQX0hBU19SRUZTKQojZGVmaW5lIFdYU19BVFRSX0dST1VQX0VYUEFOREVEKGFnKSAoKFdYU19BVFRSX0dST1VQX0NBU1QgKGFnKSktPmZsYWdzICYgWE1MX1NDSEVNQVNfQVRUUkdST1VQX1dJTERDQVJEX0JVSUxERUQpCi8qCiogTWFjcm9zIGZvciBwYXJ0aWNsZXMuCiovCiNkZWZpbmUgV1hTX1BBUlRJQ0xFKHApIFdYU19QVENfQ0FTVCAocCkKCiNkZWZpbmUgV1hTX1BBUlRJQ0xFX1RFUk0ocCkgKFdYU19QQVJUSUNMRShwKSktPmNoaWxkcmVuCgojZGVmaW5lIFdYU19QQVJUSUNMRV9NT0RFTChwKSBXWFNfTU9ERUxfR1JPVVBfQ0FTVCBXWFNfUEFSVElDTEUocCktPmNoaWxkcmVuCi8qCiogTWFjcm9zIGZvciBtb2RlbCBncm91cHMgZGVmaW5pdGlvbnMuCiovCiNkZWZpbmUgV1hTX01PREVMR1JPVVBERUZfTU9ERUwobWdkKSAoV1hTX01PREVMX0dST1VQX0NBU1QgKG1nZCkpLT5jaGlsZHJlbgovKgoqIE1hY3JvcyBmb3IgbW9kZWwgZ3JvdXBzLgoqLwojZGVmaW5lIFdYU19JU19NT0RFTF9HUk9VUChpKSBcCiAgICAoKChpKS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UpIHx8IFwKICAgICAoKGkpLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0UpIHx8IFwKICAgICAoKGkpLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTEwpKQoKI2RlZmluZSBXWFNfTU9ERUxHUk9VUF9QQVJUSUNMRShtZykgV1hTX1BUQ19DQVNUIChtZyktPmNoaWxkcmVuCi8qCiogTWFjcm9zIGZvciBzY2hlbWEgYnVja2V0cy4KKi8KI2RlZmluZSBXWFNfSVNfQlVDS0VUX0lOQ1JFREVGKHQpICgoKHQpID09IFhNTF9TQ0hFTUFfU0NIRU1BX0lOQ0xVREUpIHx8IFwKICAgICgodCkgPT0gWE1MX1NDSEVNQV9TQ0hFTUFfUkVERUZJTkUpKQoKI2RlZmluZSBXWFNfSVNfQlVDS0VUX0lNUE1BSU4odCkgKCgodCkgPT0gWE1MX1NDSEVNQV9TQ0hFTUFfTUFJTikgfHwgXAogICAgKCh0KSA9PSBYTUxfU0NIRU1BX1NDSEVNQV9JTVBPUlQpKQoKI2RlZmluZSBXWFNfSU1QQlVDS0VUKGIpICgoeG1sU2NoZW1hSW1wb3J0UHRyKSAoYikpCgojZGVmaW5lIFdYU19JTkNCVUNLRVQoYikgKCh4bWxTY2hlbWFJbmNsdWRlUHRyKSAoYikpCi8qCiogTWFjcm9zIGZvciBjb21wbGV4L3NpbXBsZSB0eXBlcy4KKi8KI2RlZmluZSBXWFNfSVNfQU5ZVFlQRShpKSBcCiAgICAgKCggKGkpLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgJiYgXAogICAgICAoIChXWFNfVFlQRV9DQVNUIChpKSktPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX0FOWVRZUEUpKQoKI2RlZmluZSBXWFNfSVNfQ09NUExFWChpKSBcCiAgICAoKChpKS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWCkgfHwgXAogICAgICgoaSktPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX0FOWVRZUEUpKQoKI2RlZmluZSBXWFNfSVNfU0lNUExFKGl0ZW0pIFwKICAgICgoaXRlbS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFKSB8fCBcCiAgICAgKChpdGVtLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgJiYgXAogICAgICAoaXRlbS0+YnVpbHRJblR5cGUgIT0gWE1MX1NDSEVNQVNfQU5ZVFlQRSkpKQoKI2RlZmluZSBXWFNfSVNfQU5ZX1NJTVBMRV9UWVBFKGkpIFwKICAgICgoKGkpLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgJiYgXAogICAgICAoKGkpLT5idWlsdEluVHlwZSA9PSBYTUxfU0NIRU1BU19BTllTSU1QTEVUWVBFKSkKCiNkZWZpbmUgV1hTX0lTX1JFU1RSSUNUSU9OKHQpIFwKICAgICgodCktPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9ERVJJVkFUSU9OX01FVEhPRF9SRVNUUklDVElPTikKCiNkZWZpbmUgV1hTX0lTX0VYVEVOU0lPTih0KSBcCiAgICAoKHQpLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfREVSSVZBVElPTl9NRVRIT0RfRVhURU5TSU9OKQoKI2RlZmluZSBXWFNfSVNfVFlQRV9OT1RfRklYRUQoaSkgXAogICAgKCgoaSktPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKSAmJiBcCiAgICAgKCgoaSktPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9JTlRFUk5BTF9SRVNPTFZFRCkgPT0gMCkpCgojZGVmaW5lIFdYU19JU19UWVBFX05PVF9GSVhFRF8xKGl0ZW0pIFwKICAgICgoKGl0ZW0pLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgJiYgXAogICAgICgoKGl0ZW0pLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfRklYVVBfMSkgPT0gMCkpCi8qCiogTWFjcm9zIGZvciBleGNsdXNpdmVseSBmb3IgY29tcGxleCB0eXBlcy4KKi8KI2RlZmluZSBXWFNfSEFTX0NPTVBMRVhfQ09OVEVOVChpdGVtKSBcCiAgICAoKGl0ZW0tPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9NSVhFRCkgfHwgXAogICAgIChpdGVtLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfRU1QVFkpIHx8IFwKICAgICAoaXRlbS0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX0VMRU1FTlRTKSkKCiNkZWZpbmUgV1hTX0hBU19TSU1QTEVfQ09OVEVOVChpdGVtKSBcCiAgICAoKGl0ZW0tPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9TSU1QTEUpIHx8IFwKICAgICAoaXRlbS0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX0JBU0lDKSkKCiNkZWZpbmUgV1hTX0hBU19NSVhFRF9DT05URU5UKGl0ZW0pIFwKICAgIChpdGVtLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfTUlYRUQpCgojZGVmaW5lIFdYU19FTVBUSUFCTEUodCkgXAogICAgKHhtbFNjaGVtYUlzUGFydGljbGVFbXB0aWFibGUoV1hTX1BUQ19DQVNUICh0KS0+c3VidHlwZXMpKQoKI2RlZmluZSBXWFNfVFlQRV9DT05URU5UVFlQRSh0KSAodCktPnN1YnR5cGVzCgojZGVmaW5lIFdYU19UWVBFX1BBUlRJQ0xFKHQpIFdYU19QVENfQ0FTVCAodCktPnN1YnR5cGVzCgojZGVmaW5lIFdYU19UWVBFX1BBUlRJQ0xFX1RFUk0odCkgV1hTX1BBUlRJQ0xFX1RFUk0oV1hTX1RZUEVfUEFSVElDTEUodCkpCi8qCiogTWFjcm9zIGZvciBleGNsdXNpdmVseSBmb3Igc2ltcGxlIHR5cGVzLgoqLwojZGVmaW5lIFdYU19MSVNUX0lURU1UWVBFKHQpICh0KS0+c3VidHlwZXMKCiNkZWZpbmUgV1hTX0lTX0FUT01JQyh0KSAodC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX1ZBUklFVFlfQVRPTUlDKQoKI2RlZmluZSBXWFNfSVNfTElTVCh0KSAodC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX1ZBUklFVFlfTElTVCkKCiNkZWZpbmUgV1hTX0lTX1VOSU9OKHQpICh0LT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfVkFSSUVUWV9VTklPTikKLyoKKiBNaXNjIHBhcnNlciBjb250ZXh0IG1hY3Jvcy4KKi8KI2RlZmluZSBXWFNfQ09OU1RSVUNUT1IoY3R4KSAoY3R4KS0+Y29uc3RydWN0b3IKCiNkZWZpbmUgV1hTX0hBU19CVUNLRVRTKGN0eCkgXAooIChXWFNfQ09OU1RSVUNUT1IoKGN0eCkpLT5idWNrZXRzICE9IE5VTEwpICYmIFwKKFdYU19DT05TVFJVQ1RPUigoY3R4KSktPmJ1Y2tldHMtPm5iSXRlbXMgPiAwKSApCgojZGVmaW5lIFdYU19TVUJTVF9HUk9VUFMoY3R4KSBXWFNfQ09OU1RSVUNUT1IoKGN0eCkpLT5zdWJzdEdyb3VwcwoKI2RlZmluZSBXWFNfQlVDS0VUKGN0eCkgV1hTX0NPTlNUUlVDVE9SKChjdHgpKS0+YnVja2V0CgojZGVmaW5lIFdYU19TQ0hFTUEoY3R4KSAoY3R4KS0+c2NoZW1hCgojZGVmaW5lIFdYU19BRERfTE9DQUwoY3R4LCBpdGVtKSBcCiAgICB4bWxTY2hlbWFBZGRJdGVtU2l6ZSgmKFdYU19CVUNLRVQoY3R4KS0+bG9jYWxzKSwgMTAsIGl0ZW0pCgojZGVmaW5lIFdYU19BRERfR0xPQkFMKGN0eCwgaXRlbSkgXAogICAgeG1sU2NoZW1hQWRkSXRlbVNpemUoJihXWFNfQlVDS0VUKGN0eCktPmdsb2JhbHMpLCA1LCBpdGVtKQoKI2RlZmluZSBXWFNfQUREX1BFTkRJTkcoY3R4LCBpdGVtKSBcCiAgICB4bWxTY2hlbWFBZGRJdGVtU2l6ZSgmKChjdHgpLT5jb25zdHJ1Y3Rvci0+cGVuZGluZyksIDEwLCBpdGVtKQovKgoqIHhtbFNjaGVtYUl0ZW1MaXN0IG1hY3Jvcy4KKi8KI2RlZmluZSBXWFNfSUxJU1RfSVNfRU1QVFkobCkgKChsID09IE5VTEwpIHx8ICgobCktPm5iSXRlbXMgPT0gMCkpCi8qCiogTWlzYyBtYWNyb3MuCiovCiNkZWZpbmUgSVNfU0NIRU1BKG5vZGUsIHR5cGUpIFwKICAgKChub2RlICE9IE5VTEwpICYmIChub2RlLT5ucyAhPSBOVUxMKSAmJiBcCiAgICAoeG1sU3RyRXF1YWwobm9kZS0+bmFtZSwgKGNvbnN0IHhtbENoYXIgKikgdHlwZSkpICYmIFwKICAgICh4bWxTdHJFcXVhbChub2RlLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSkKCiNkZWZpbmUgRlJFRV9BTkRfTlVMTChzdHIpIGlmICgoc3RyKSAhPSBOVUxMKSB7IHhtbEZyZWUoKHhtbENoYXIgKikgKHN0cikpOyBzdHIgPSBOVUxMOyB9CgovKgoqIFNpbmNlIHdlIHB1dCB0aGUgZGVmYXVsdC9maXhlZCB2YWx1ZXMgaW50byB0aGUgZGljdCwgd2UgY2FuCiogdXNlIHBvaW50ZXIgY29tcGFyaXNvbiBmb3IgdGhvc2UgdmFsdWVzLgoqIFJFTU9WRUQ6ICh4bWxTdHJFcXVhbCgodjEpLCAodjIpKSkKKi8KI2RlZmluZSBXWFNfQVJFX0RFRkFVTFRfU1RSX0VRVUFMKHYxLCB2MikgKCh2MSkgPT0gKHYyKSkKCiNkZWZpbmUgSU5PREVfTklMTEVEKGl0ZW0pIChpdGVtLT5mbGFncyAmIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX05JTExFRCkKCiNkZWZpbmUgQ0FOX1BBUlNFX1NDSEVNQShiKSAoKChiKS0+ZG9jICE9IE5VTEwpICYmICgoYiktPnBhcnNlZCA9PSAwKSkKCiNkZWZpbmUgSEZBSUxVUkUgaWYgKHJlcyA9PSAtMSkgZ290byBleGl0X2ZhaWx1cmU7CgojZGVmaW5lIEhFUlJPUiBpZiAocmVzICE9IDApIGdvdG8gZXhpdF9lcnJvcjsKCiNkZWZpbmUgSFNUT1AoY3R4KSBpZiAoKGN0eCktPnN0b3ApIGdvdG8gZXhpdDsKLyoKKiBTb21lIGZsYWdzIHVzZWQgZm9yIHZhcmlvdXMgc2NoZW1hIGNvbnN0cmFpbnRzLgoqLwojZGVmaW5lIFNVQlNFVF9SRVNUUklDVElPTiAgMTw8MAojZGVmaW5lIFNVQlNFVF9FWFRFTlNJT04gICAgMTw8MQojZGVmaW5lIFNVQlNFVF9TVUJTVElUVVRJT04gMTw8MgojZGVmaW5lIFNVQlNFVF9MSVNUICAgICAgICAgMTw8MwojZGVmaW5lIFNVQlNFVF9VTklPTiAgICAgICAgMTw8NAoKdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYU5vZGVJbmZvIHhtbFNjaGVtYU5vZGVJbmZvOwp0eXBlZGVmIHhtbFNjaGVtYU5vZGVJbmZvICp4bWxTY2hlbWFOb2RlSW5mb1B0cjsKCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFJdGVtTGlzdCB4bWxTY2hlbWFJdGVtTGlzdDsKdHlwZWRlZiB4bWxTY2hlbWFJdGVtTGlzdCAqeG1sU2NoZW1hSXRlbUxpc3RQdHI7CnN0cnVjdCBfeG1sU2NoZW1hSXRlbUxpc3QgewogICAgdm9pZCAqKml0ZW1zOyAgLyogdXNlZCBmb3IgZHluYW1pYyBhZGRpdGlvbiBvZiBzY2hlbWF0YSAqLwogICAgaW50IG5iSXRlbXM7IC8qIHVzZWQgZm9yIGR5bmFtaWMgYWRkaXRpb24gb2Ygc2NoZW1hdGEgKi8KICAgIGludCBzaXplSXRlbXM7IC8qIHVzZWQgZm9yIGR5bmFtaWMgYWRkaXRpb24gb2Ygc2NoZW1hdGEgKi8KfTsKCiNkZWZpbmUgWE1MX1NDSEVNQV9DVFhUX1BBUlNFUiAxCiNkZWZpbmUgWE1MX1NDSEVNQV9DVFhUX1ZBTElEQVRPUiAyCgp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hQWJzdHJhY3RDdHh0IHhtbFNjaGVtYUFic3RyYWN0Q3R4dDsKdHlwZWRlZiB4bWxTY2hlbWFBYnN0cmFjdEN0eHQgKnhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0cjsKc3RydWN0IF94bWxTY2hlbWFBYnN0cmFjdEN0eHQgewogICAgaW50IHR5cGU7IC8qIEUuZy4gWE1MX1NDSEVNQV9DVFhUX1ZBTElEQVRPUiAqLwp9OwoKdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYUJ1Y2tldCB4bWxTY2hlbWFCdWNrZXQ7CnR5cGVkZWYgeG1sU2NoZW1hQnVja2V0ICp4bWxTY2hlbWFCdWNrZXRQdHI7CgojZGVmaW5lIFhNTF9TQ0hFTUFfU0NIRU1BX01BSU4gMAojZGVmaW5lIFhNTF9TQ0hFTUFfU0NIRU1BX0lNUE9SVCAxCiNkZWZpbmUgWE1MX1NDSEVNQV9TQ0hFTUFfSU5DTFVERSAyCiNkZWZpbmUgWE1MX1NDSEVNQV9TQ0hFTUFfUkVERUZJTkUgMwoKLyoqCiAqIHhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uOiAKICoKICogVXNlZCB0byBjcmVhdGUgYSBncmFwaCBvZiBzY2hlbWEgcmVsYXRpb25zaGlwcy4KICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFTY2hlbWFSZWxhdGlvbiB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvbjsKdHlwZWRlZiB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvbiAqeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25QdHI7CnN0cnVjdCBfeG1sU2NoZW1hU2NoZW1hUmVsYXRpb24gewogICAgeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25QdHIgbmV4dDsKICAgIGludCB0eXBlOyAvKiBFLmcuIFhNTF9TQ0hFTUFfU0NIRU1BX0lNUE9SVCAqLwogICAgY29uc3QgeG1sQ2hhciAqaW1wb3J0TmFtZXNwYWNlOwogICAgeG1sU2NoZW1hQnVja2V0UHRyIGJ1Y2tldDsKfTsKCiNkZWZpbmUgWE1MX1NDSEVNQV9CVUNLRVRfTUFSS0VEIDE8PDAKI2RlZmluZSBYTUxfU0NIRU1BX0JVQ0tFVF9DT01QU19BRERFRCAxPDwxCgpzdHJ1Y3QgX3htbFNjaGVtYUJ1Y2tldCB7CiAgICBpbnQgdHlwZTsKICAgIGludCBmbGFnczsKICAgIGNvbnN0IHhtbENoYXIgKnNjaGVtYUxvY2F0aW9uOwogICAgY29uc3QgeG1sQ2hhciAqb3JpZ1RhcmdldE5hbWVzcGFjZTsKICAgIGNvbnN0IHhtbENoYXIgKnRhcmdldE5hbWVzcGFjZTsKICAgIHhtbERvY1B0ciBkb2M7CiAgICB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvblB0ciByZWxhdGlvbnM7CiAgICBpbnQgbG9jYXRlZDsKICAgIGludCBwYXJzZWQ7CiAgICBpbnQgaW1wb3J0ZWQ7CiAgICBpbnQgcHJlc2VydmVEb2M7CiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBnbG9iYWxzOyAvKiBHbG9iYWwgY29tcG9uZW50cy4gKi8gCiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBsb2NhbHM7IC8qIExvY2FsIGNvbXBvbmVudHMuICovCn07CgovKioKICogeG1sU2NoZW1hSW1wb3J0OiAKICogKGV4dGVuZHMgeG1sU2NoZW1hQnVja2V0KQogKgogKiBSZWZsZWN0cyBhIHNjaGVtYS4gSG9sZHMgc29tZSBpbmZvcm1hdGlvbgogKiBhYm91dCB0aGUgc2NoZW1hIGFuZCBpdHMgdG9wbGV2ZWwgY29tcG9uZW50cy4gRHVwbGljYXRlCiAqIHRvcGxldmVsIGNvbXBvbmVudHMgYXJlIG5vdCBjaGVja2VkIGF0IHRoaXMgbGV2ZWwuCiAqLwp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hSW1wb3J0IHhtbFNjaGVtYUltcG9ydDsKdHlwZWRlZiB4bWxTY2hlbWFJbXBvcnQgKnhtbFNjaGVtYUltcG9ydFB0cjsKc3RydWN0IF94bWxTY2hlbWFJbXBvcnQgewogICAgaW50IHR5cGU7IC8qIE1haW4gT1IgaW1wb3J0IE9SIGluY2x1ZGUuICovCiAgICBpbnQgZmxhZ3M7CiAgICBjb25zdCB4bWxDaGFyICpzY2hlbWFMb2NhdGlvbjsgLyogVGhlIFVSSSBvZiB0aGUgc2NoZW1hIGRvY3VtZW50LiAqLwogICAgLyogRm9yIGNoYW1lbGVvbiBpbmNsdWRlcywgQG9yaWdUYXJnZXROYW1lc3BhY2Ugd2lsbCBiZSBOVUxMICovCiAgICBjb25zdCB4bWxDaGFyICpvcmlnVGFyZ2V0TmFtZXNwYWNlOwogICAgLyogCiAgICAqIEZvciBjaGFtZWxlb24gaW5jbHVkZXMsIEB0YXJnZXROYW1lc3BhY2Ugd2lsbCBiZSB0aGUKICAgICogdGFyZ2V0TmFtZXNwYWNlIG9mIHRoZSBpbmNsdWRpbmcgc2NoZW1hLiAKICAgICovCiAgICBjb25zdCB4bWxDaGFyICp0YXJnZXROYW1lc3BhY2U7CiAgICB4bWxEb2NQdHIgZG9jOyAvKiBUaGUgc2NoZW1hIG5vZGUtdHJlZS4gKi8KICAgIC8qIEByZWxhdGlvbnMgd2lsbCBob2xkIGFueSBpbmNsdWRlZC9pbXBvcnRlZC9yZWRlZmluZWQgc2NoZW1hcy4gKi8KICAgIHhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uUHRyIHJlbGF0aW9uczsKICAgIGludCBsb2NhdGVkOwogICAgaW50IHBhcnNlZDsKICAgIGludCBpbXBvcnRlZDsKICAgIGludCBwcmVzZXJ2ZURvYzsKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGdsb2JhbHM7CiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBsb2NhbHM7CiAgICAvKiBUaGUgaW1wb3J0ZWQgc2NoZW1hLiAqLwogICAgeG1sU2NoZW1hUHRyIHNjaGVtYTsKfTsKCi8qCiogKGV4dGVuZHMgeG1sU2NoZW1hQnVja2V0KQoqLwp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hSW5jbHVkZSB4bWxTY2hlbWFJbmNsdWRlOwp0eXBlZGVmIHhtbFNjaGVtYUluY2x1ZGUgKnhtbFNjaGVtYUluY2x1ZGVQdHI7CnN0cnVjdCBfeG1sU2NoZW1hSW5jbHVkZSB7CiAgICBpbnQgdHlwZTsKICAgIGludCBmbGFnczsKICAgIGNvbnN0IHhtbENoYXIgKnNjaGVtYUxvY2F0aW9uOwogICAgY29uc3QgeG1sQ2hhciAqb3JpZ1RhcmdldE5hbWVzcGFjZTsKICAgIGNvbnN0IHhtbENoYXIgKnRhcmdldE5hbWVzcGFjZTsKICAgIHhtbERvY1B0ciBkb2M7CiAgICB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvblB0ciByZWxhdGlvbnM7CiAgICBpbnQgbG9jYXRlZDsKICAgIGludCBwYXJzZWQ7CiAgICBpbnQgaW1wb3J0ZWQ7CiAgICBpbnQgcHJlc2VydmVEb2M7CiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBnbG9iYWxzOyAvKiBHbG9iYWwgY29tcG9uZW50cy4gKi8gCiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBsb2NhbHM7IC8qIExvY2FsIGNvbXBvbmVudHMuICovCgogICAgLyogVGhlIG93bmluZyBtYWluIG9yIGltcG9ydCBzY2hlbWEgYnVja2V0LiAqLwogICAgeG1sU2NoZW1hSW1wb3J0UHRyIG93bmVySW1wb3J0Owp9OwoKLyoqCiAqIHhtbFNjaGVtYUJhc2ljSXRlbToKICoKICogVGhlIGFic3RyYWN0IGJhc2UgdHlwZSBmb3Igc2NoZW1hIGNvbXBvbmVudHMuCiAqLwp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hQmFzaWNJdGVtIHhtbFNjaGVtYUJhc2ljSXRlbTsKdHlwZWRlZiB4bWxTY2hlbWFCYXNpY0l0ZW0gKnhtbFNjaGVtYUJhc2ljSXRlbVB0cjsKc3RydWN0IF94bWxTY2hlbWFCYXNpY0l0ZW0gewogICAgeG1sU2NoZW1hVHlwZVR5cGUgdHlwZTsKfTsKCi8qKgogKiB4bWxTY2hlbWFBbm5vdEl0ZW06CiAqCiAqIFRoZSBhYnN0cmFjdCBiYXNlIHR5cGUgZm9yIGFubm90YXRlZCBzY2hlbWEgY29tcG9uZW50cy4KICogKEV4dGVuZHMgeG1sU2NoZW1hQmFzaWNJdGVtKQogKi8KdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYUFubm90SXRlbSB4bWxTY2hlbWFBbm5vdEl0ZW07CnR5cGVkZWYgeG1sU2NoZW1hQW5ub3RJdGVtICp4bWxTY2hlbWFBbm5vdEl0ZW1QdHI7CnN0cnVjdCBfeG1sU2NoZW1hQW5ub3RJdGVtIHsKICAgIHhtbFNjaGVtYVR5cGVUeXBlIHR5cGU7CiAgICB4bWxTY2hlbWFBbm5vdFB0ciBhbm5vdDsKfTsKCi8qKgogKiB4bWxTY2hlbWFUcmVlSXRlbToKICoKICogVGhlIGFic3RyYWN0IGJhc2UgdHlwZSBmb3IgdHJlZS1saWtlIHN0cnVjdHVyZWQgc2NoZW1hIGNvbXBvbmVudHMuCiAqIChFeHRlbmRzIHhtbFNjaGVtYUFubm90SXRlbSkKICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFUcmVlSXRlbSB4bWxTY2hlbWFUcmVlSXRlbTsKdHlwZWRlZiB4bWxTY2hlbWFUcmVlSXRlbSAqeG1sU2NoZW1hVHJlZUl0ZW1QdHI7CnN0cnVjdCBfeG1sU2NoZW1hVHJlZUl0ZW0gewogICAgeG1sU2NoZW1hVHlwZVR5cGUgdHlwZTsKICAgIHhtbFNjaGVtYUFubm90UHRyIGFubm90OwogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgbmV4dDsKICAgIHhtbFNjaGVtYVRyZWVJdGVtUHRyIGNoaWxkcmVuOwp9OwoKCiNkZWZpbmUgWE1MX1NDSEVNQV9BVFRSX1VTRV9GSVhFRCAxPDwwCi8qKgogKiB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHI6CiAqCiAqIFRoZSBhYnN0cmFjdCBiYXNlIHR5cGUgZm9yIHRyZWUtbGlrZSBzdHJ1Y3R1cmVkIHNjaGVtYSBjb21wb25lbnRzLgogKiAoRXh0ZW5kcyB4bWxTY2hlbWFUcmVlSXRlbSkKICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFBdHRyaWJ1dGVVc2UgeG1sU2NoZW1hQXR0cmlidXRlVXNlOwp0eXBlZGVmIHhtbFNjaGVtYUF0dHJpYnV0ZVVzZSAqeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyOwpzdHJ1Y3QgX3htbFNjaGVtYUF0dHJpYnV0ZVVzZSB7CiAgICB4bWxTY2hlbWFUeXBlVHlwZSB0eXBlOwogICAgeG1sU2NoZW1hQW5ub3RQdHIgYW5ub3Q7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgbmV4dDsgLyogVGhlIG5leHQgYXR0ci4gdXNlLiAqLwogICAgLyogCiAgICAqIFRoZSBhdHRyLiBkZWNsLiBPUiBhIFFOYW1lLXJlZi4gdG8gYW4gYXR0ci4gZGVjbC4gT1IKICAgICogYSBRTmFtZS1yZWYuIHRvIGFuIGF0dHJpYnV0ZSBncm91cCBkZWZpbml0aW9uLgogICAgKi8KICAgIHhtbFNjaGVtYUF0dHJpYnV0ZVB0ciBhdHRyRGVjbDsKCiAgICBpbnQgZmxhZ3M7CiAgICB4bWxOb2RlUHRyIG5vZGU7CiAgICBpbnQgb2NjdXJzOyAvKiByZXF1aXJlZCwgb3B0aW9uYWwgKi8KICAgIGNvbnN0IHhtbENoYXIgKiBkZWZWYWx1ZTsKICAgIHhtbFNjaGVtYVZhbFB0ciBkZWZWYWw7Cn07CgovKioKICogeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliUHRyOgogKgogKiBBIGhlbHBlciBjb21wb25lbnQgdG8gcmVmbGVjdCBhdHRyaWJ1dGUgcHJvaGliaXRpb25zLgogKiAoRXh0ZW5kcyB4bWxTY2hlbWFCYXNpY0l0ZW0pCiAqLwp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliIHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYjsKdHlwZWRlZiB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQcm9oaWIgKnhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYlB0cjsKc3RydWN0IF94bWxTY2hlbWFBdHRyaWJ1dGVVc2VQcm9oaWIgewogICAgeG1sU2NoZW1hVHlwZVR5cGUgdHlwZTsgLyogPT0gWE1MX1NDSEVNQV9FWFRSQV9BVFRSX1VTRV9QUk9ISUIgKi8KICAgIHhtbE5vZGVQdHIgbm9kZTsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWU7CiAgICBjb25zdCB4bWxDaGFyICp0YXJnZXROYW1lc3BhY2U7CiAgICBpbnQgaXNSZWY7Cn07CgovKioKICogeG1sU2NoZW1hUmVkZWY6CiAqLwp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hUmVkZWYgeG1sU2NoZW1hUmVkZWY7CnR5cGVkZWYgeG1sU2NoZW1hUmVkZWYgKnhtbFNjaGVtYVJlZGVmUHRyOwpzdHJ1Y3QgX3htbFNjaGVtYVJlZGVmIHsKICAgIHhtbFNjaGVtYVJlZGVmUHRyIG5leHQ7CiAgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbTsgLyogVGhlIHJlZGVmaW5pbmcgY29tcG9uZW50LiAqLwogICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIHJlZmVyZW5jZTsgLyogVGhlIHJlZmVyZW5jaW5nIGNvbXBvbmVudC4gKi8KICAgIHhtbFNjaGVtYUJhc2ljSXRlbVB0ciB0YXJnZXQ7IC8qIFRoZSB0by1iZS1yZWRlZmluZWQgY29tcG9uZW50LiAqLwogICAgY29uc3QgeG1sQ2hhciAqcmVmTmFtZTsgLyogVGhlIG5hbWUgb2YgdGhlIHRvLWJlLXJlZGVmaW5lZCBjb21wb25lbnQuICovCiAgICBjb25zdCB4bWxDaGFyICpyZWZUYXJnZXROczsgLyogVGhlIHRhcmdldCBuYW1lc3BhY2Ugb2YgdGhlCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdG8tYmUtcmVkZWZpbmVkIGNvbXAuICovCiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgdGFyZ2V0QnVja2V0OyAvKiBUaGUgcmVkZWZpbmVkIHNjaGVtYS4gKi8KfTsKCi8qKgogKiB4bWxTY2hlbWFDb25zdHJ1Y3Rpb25DdHh0OgogKi8KdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHQgeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dDsKdHlwZWRlZiB4bWxTY2hlbWFDb25zdHJ1Y3Rpb25DdHh0ICp4bWxTY2hlbWFDb25zdHJ1Y3Rpb25DdHh0UHRyOwpzdHJ1Y3QgX3htbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHQgewogICAgeG1sU2NoZW1hUHRyIG1haW5TY2hlbWE7IC8qIFRoZSBtYWluIHNjaGVtYS4gKi8KICAgIHhtbFNjaGVtYUJ1Y2tldFB0ciBtYWluQnVja2V0OyAvKiBUaGUgbWFpbiBzY2hlbWEgYnVja2V0ICovCiAgICB4bWxEaWN0UHRyIGRpY3Q7CiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBidWNrZXRzOyAvKiBMaXN0IG9mIHNjaGVtYSBidWNrZXRzLiAqLwogICAgLyogeG1sU2NoZW1hSXRlbUxpc3RQdHIgcmVsYXRpb25zOyAqLyAvKiBMaXN0IG9mIHNjaGVtYSByZWxhdGlvbnMuICovCiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgYnVja2V0OyAvKiBUaGUgY3VycmVudCBzY2hlbWEgYnVja2V0ICovICAgIAogICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgcGVuZGluZzsgLyogQWxsIENvbXBvbmVudHMgb2YgYWxsIHNjaGVtYXMgdGhhdAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmVlZCB0byBiZSBmaXhlZC4gKi8KICAgIHhtbEhhc2hUYWJsZVB0ciBzdWJzdEdyb3VwczsKICAgIHhtbFNjaGVtYVJlZGVmUHRyIHJlZGVmczsKICAgIHhtbFNjaGVtYVJlZGVmUHRyIGxhc3RSZWRlZjsKfTsKCiNkZWZpbmUgWE1MX1NDSEVNQVNfUEFSU0VfRVJST1IJCTEKI2RlZmluZSBTQ0hFTUFTX1BBUlNFX09QVElPTlMgWE1MX1BBUlNFX05PRU5UCgpzdHJ1Y3QgX3htbFNjaGVtYVBhcnNlckN0eHQgewogICAgaW50IHR5cGU7CiAgICB2b2lkICplcnJDdHh0OyAgICAgICAgICAgICAvKiB1c2VyIHNwZWNpZmljIGVycm9yIGNvbnRleHQgKi8gICAgCiAgICB4bWxTY2hlbWFWYWxpZGl0eUVycm9yRnVuYyBlcnJvcjsgICAvKiB0aGUgY2FsbGJhY2sgaW4gY2FzZSBvZiBlcnJvcnMgKi8KICAgIHhtbFNjaGVtYVZhbGlkaXR5V2FybmluZ0Z1bmMgd2FybmluZzsgICAgICAgLyogdGhlIGNhbGxiYWNrIGluIGNhc2Ugb2Ygd2FybmluZyAqLwogICAgaW50IGVycjsKICAgIGludCBuYmVycm9yczsKICAgIHhtbFN0cnVjdHVyZWRFcnJvckZ1bmMgc2Vycm9yOwoKICAgIHhtbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHRQdHIgY29uc3RydWN0b3I7CiAgICBpbnQgb3duc0NvbnN0cnVjdG9yOyAvKiBUT0RPOiBNb3ZlIHRoaXMgdG8gcGFyc2VyICpmbGFncyouICovCgogICAgLyogeG1sU2NoZW1hUHRyIHRvcHNjaGVtYTsJKi8KICAgIC8qIHhtbEhhc2hUYWJsZVB0ciBuYW1lc3BhY2VzOyAgKi8KCiAgICB4bWxTY2hlbWFQdHIgc2NoZW1hOyAgICAgICAgLyogVGhlIG1haW4gc2NoZW1hIGluIHVzZSAqLwogICAgaW50IGNvdW50ZXI7CgogICAgY29uc3QgeG1sQ2hhciAqVVJMOwogICAgeG1sRG9jUHRyIGRvYzsKICAgIGludCBwcmVzZXJ2ZTsJCS8qIFdoZXRoZXIgdGhlIGRvYyBzaG91bGQgYmUgZnJlZWQgICovCgogICAgY29uc3QgY2hhciAqYnVmZmVyOwogICAgaW50IHNpemU7CgogICAgLyoKICAgICAqIFVzZWQgdG8gYnVpbGQgY29tcGxleCBlbGVtZW50IGNvbnRlbnQgbW9kZWxzCiAgICAgKi8KICAgIHhtbEF1dG9tYXRhUHRyIGFtOwogICAgeG1sQXV0b21hdGFTdGF0ZVB0ciBzdGFydDsKICAgIHhtbEF1dG9tYXRhU3RhdGVQdHIgZW5kOwogICAgeG1sQXV0b21hdGFTdGF0ZVB0ciBzdGF0ZTsKCiAgICB4bWxEaWN0UHRyIGRpY3Q7CQkvKiBkaWN0aW9ubmFyeSBmb3IgaW50ZXJuZWQgc3RyaW5nIG5hbWVzICovCiAgICB4bWxTY2hlbWFUeXBlUHRyIGN0eHRUeXBlOyAvKiBUaGUgY3VycmVudCBjb250ZXh0IHNpbXBsZS9jb21wbGV4IHR5cGUgKi8KICAgIGludCBvcHRpb25zOwogICAgeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0OwogICAgaW50IGlzUzRTOwogICAgaW50IGlzUmVkZWZpbmU7CiAgICBpbnQgeHNpQXNzZW1ibGU7CiAgICBpbnQgc3RvcDsgLyogSWYgdGhlIHBhcnNlciBzaG91bGQgc3RvcDsgaS5lLiBhIGNyaXRpY2FsIGVycm9yLiAqLwogICAgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TmFtZXNwYWNlOwogICAgeG1sU2NoZW1hQnVja2V0UHRyIHJlZGVmaW5lZDsgLyogVGhlIHNjaGVtYSB0byBiZSByZWRlZmluZWQuICovCgogICAgeG1sU2NoZW1hUmVkZWZQdHIgcmVkZWY7IC8qIFVzZWQgZm9yIHJlZGVmaW5pdGlvbnMuICovCiAgICBpbnQgcmVkZWZDb3VudGVyOyAvKiBVc2VkIGZvciByZWRlZmluaXRpb25zLiAqLyAKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGF0dHJQcm9oaWJzOwp9OwoKLyoqCiAqIHhtbFNjaGVtYVFOYW1lUmVmOgogKgogKiBBIGNvbXBvbmVudCByZWZlcmVuY2UgaXRlbSAobm90IGEgc2NoZW1hIGNvbXBvbmVudCkKICogKEV4dGVuZHMgeG1sU2NoZW1hQmFzaWNJdGVtKQogKi8KdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYVFOYW1lUmVmIHhtbFNjaGVtYVFOYW1lUmVmOwp0eXBlZGVmIHhtbFNjaGVtYVFOYW1lUmVmICp4bWxTY2hlbWFRTmFtZVJlZlB0cjsKc3RydWN0IF94bWxTY2hlbWFRTmFtZVJlZiB7CiAgICB4bWxTY2hlbWFUeXBlVHlwZSB0eXBlOwogICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIGl0ZW07IC8qIFRoZSByZXNvbHZlZCByZWZlcmVuY2VkIGl0ZW0uICovCiAgICB4bWxTY2hlbWFUeXBlVHlwZSBpdGVtVHlwZTsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWU7CiAgICBjb25zdCB4bWxDaGFyICp0YXJnZXROYW1lc3BhY2U7CiAgICB4bWxOb2RlUHRyIG5vZGU7Cn07CgovKioKICogeG1sU2NoZW1hUGFydGljbGU6CiAqCiAqIEEgcGFydGljbGUgY29tcG9uZW50LgogKiAoRXh0ZW5kcyB4bWxTY2hlbWFUcmVlSXRlbSkKICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFQYXJ0aWNsZSB4bWxTY2hlbWFQYXJ0aWNsZTsKdHlwZWRlZiB4bWxTY2hlbWFQYXJ0aWNsZSAqeG1sU2NoZW1hUGFydGljbGVQdHI7CnN0cnVjdCBfeG1sU2NoZW1hUGFydGljbGUgewogICAgeG1sU2NoZW1hVHlwZVR5cGUgdHlwZTsKICAgIHhtbFNjaGVtYUFubm90UHRyIGFubm90OwogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgbmV4dDsgLyogbmV4dCBwYXJ0aWNsZSAqLwogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgY2hpbGRyZW47IC8qIHRoZSAidGVybSIgKGUuZy4gYSBtb2RlbCBncm91cCwKCWEgZ3JvdXAgZGVmaW5pdGlvbiwgYSBYTUxfU0NIRU1BX0VYVFJBX1FOQU1FUkVGIChpZiBhIHJlZmVyZW5jZSksCiAgICAgICAgZXRjLikgKi8KICAgIGludCBtaW5PY2N1cnM7CiAgICBpbnQgbWF4T2NjdXJzOwogICAgeG1sTm9kZVB0ciBub2RlOwp9OwoKLyoqCiAqIHhtbFNjaGVtYU1vZGVsR3JvdXA6CiAqCiAqIEEgbW9kZWwgZ3JvdXAgY29tcG9uZW50LgogKiAoRXh0ZW5kcyB4bWxTY2hlbWFUcmVlSXRlbSkKICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFNb2RlbEdyb3VwIHhtbFNjaGVtYU1vZGVsR3JvdXA7CnR5cGVkZWYgeG1sU2NoZW1hTW9kZWxHcm91cCAqeG1sU2NoZW1hTW9kZWxHcm91cFB0cjsKc3RydWN0IF94bWxTY2hlbWFNb2RlbEdyb3VwIHsKICAgIHhtbFNjaGVtYVR5cGVUeXBlIHR5cGU7IC8qIFhNTF9TQ0hFTUFfVFlQRV9TRVFVRU5DRSwgWE1MX1NDSEVNQV9UWVBFX0NIT0lDRSwgWE1MX1NDSEVNQV9UWVBFX0FMTCAqLwogICAgeG1sU2NoZW1hQW5ub3RQdHIgYW5ub3Q7CiAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciBuZXh0OyAvKiBub3QgdXNlZCAqLwogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgY2hpbGRyZW47IC8qIGZpcnN0IHBhcnRpY2xlIChPUiAiZWxlbWVudCBkZWNsIiBPUiAid2lsZGNhcmQiKSAqLwogICAgeG1sTm9kZVB0ciBub2RlOwp9OwoKI2RlZmluZSBYTUxfU0NIRU1BX01PREVMX0dST1VQX0RFRl9NQVJLRUQgMTw8MAojZGVmaW5lIFhNTF9TQ0hFTUFfTU9ERUxfR1JPVVBfREVGX1JFREVGSU5FRCAxPDwxCi8qKgogKiB4bWxTY2hlbWFNb2RlbEdyb3VwRGVmOgogKgogKiBBIG1vZGVsIGdyb3VwIGRlZmluaXRpb24gY29tcG9uZW50LgogKiAoRXh0ZW5kcyB4bWxTY2hlbWFUcmVlSXRlbSkKICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFNb2RlbEdyb3VwRGVmIHhtbFNjaGVtYU1vZGVsR3JvdXBEZWY7CnR5cGVkZWYgeG1sU2NoZW1hTW9kZWxHcm91cERlZiAqeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cjsKc3RydWN0IF94bWxTY2hlbWFNb2RlbEdyb3VwRGVmIHsKICAgIHhtbFNjaGVtYVR5cGVUeXBlIHR5cGU7IC8qIFhNTF9TQ0hFTUFfVFlQRV9HUk9VUCAqLwogICAgeG1sU2NoZW1hQW5ub3RQdHIgYW5ub3Q7CiAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciBuZXh0OyAvKiBub3QgdXNlZCAqLwogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgY2hpbGRyZW47IC8qIHRoZSAibW9kZWwgZ3JvdXAiICovCiAgICBjb25zdCB4bWxDaGFyICpuYW1lOwogICAgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TmFtZXNwYWNlOwogICAgeG1sTm9kZVB0ciBub2RlOwogICAgaW50IGZsYWdzOwp9OwoKdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYUlEQyB4bWxTY2hlbWFJREM7CnR5cGVkZWYgeG1sU2NoZW1hSURDICp4bWxTY2hlbWFJRENQdHI7CgovKioKICogeG1sU2NoZW1hSURDU2VsZWN0OgogKgogKiBUaGUgaWRlbnRpdHktY29uc3RyYWludCAiZmllbGQiIGFuZCAic2VsZWN0b3IiIGl0ZW0sIGhvbGRpbmcgdGhlCiAqIFhQYXRoIGV4cHJlc3Npb24uCiAqLwp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hSURDU2VsZWN0IHhtbFNjaGVtYUlEQ1NlbGVjdDsKdHlwZWRlZiB4bWxTY2hlbWFJRENTZWxlY3QgKnhtbFNjaGVtYUlEQ1NlbGVjdFB0cjsKc3RydWN0IF94bWxTY2hlbWFJRENTZWxlY3QgewogICAgeG1sU2NoZW1hSURDU2VsZWN0UHRyIG5leHQ7CiAgICB4bWxTY2hlbWFJRENQdHIgaWRjOwogICAgaW50IGluZGV4OyAvKiBhbiBpbmRleCBwb3NpdGlvbiBpZiBzaWduaWZpY2FudCBmb3IgSURDIGtleS1zZXF1ZW5jZXMgKi8KICAgIGNvbnN0IHhtbENoYXIgKnhwYXRoOyAvKiB0aGUgWFBhdGggZXhwcmVzc2lvbiAqLwogICAgdm9pZCAqeHBhdGhDb21wOyAvKiB0aGUgY29tcGlsZWQgWFBhdGggZXhwcmVzc2lvbiAqLwp9OwoKLyoqCiAqIHhtbFNjaGVtYUlEQzoKICoKICogVGhlIGlkZW50aXR5LWNvbnN0cmFpbnQgZGVmaW5pdGlvbiBjb21wb25lbnQuCiAqIChFeHRlbmRzIHhtbFNjaGVtYUFubm90SXRlbSkKICovCgpzdHJ1Y3QgX3htbFNjaGVtYUlEQyB7CiAgICB4bWxTY2hlbWFUeXBlVHlwZSB0eXBlOwogICAgeG1sU2NoZW1hQW5ub3RQdHIgYW5ub3Q7CiAgICB4bWxTY2hlbWFJRENQdHIgbmV4dDsKICAgIHhtbE5vZGVQdHIgbm9kZTsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWU7CiAgICBjb25zdCB4bWxDaGFyICp0YXJnZXROYW1lc3BhY2U7CiAgICB4bWxTY2hlbWFJRENTZWxlY3RQdHIgc2VsZWN0b3I7CiAgICB4bWxTY2hlbWFJRENTZWxlY3RQdHIgZmllbGRzOwogICAgaW50IG5iRmllbGRzOwogICAgeG1sU2NoZW1hUU5hbWVSZWZQdHIgcmVmOwp9OwoKLyoqCiAqIHhtbFNjaGVtYUlEQ0F1ZzoKICoKICogVGhlIGF1Z21lbnRlZCBJREMgaW5mb3JtYXRpb24gdXNlZCBmb3IgdmFsaWRhdGlvbi4KICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFJRENBdWcgeG1sU2NoZW1hSURDQXVnOwp0eXBlZGVmIHhtbFNjaGVtYUlEQ0F1ZyAqeG1sU2NoZW1hSURDQXVnUHRyOwpzdHJ1Y3QgX3htbFNjaGVtYUlEQ0F1ZyB7CiAgICB4bWxTY2hlbWFJRENBdWdQdHIgbmV4dDsgLyogbmV4dCBpbiBhIGxpc3QgKi8KICAgIHhtbFNjaGVtYUlEQ1B0ciBkZWY7IC8qIHRoZSBJREMgZGVmaW5pdGlvbiAqLwogICAgaW50IGtleXJlZkRlcHRoOyAvKiB0aGUgbG93ZXN0IHRyZWUgbGV2ZWwgdG8gd2hpY2ggSURDCiAgICAgICAgICAgICAgICAgICAgICAgIHRhYmxlcyBuZWVkIHRvIGJlIGJ1YmJsZWQgdXB3YXJkcyAqLwp9OwoKLyoqCiAqIHhtbFNjaGVtYVBTVklJRENLZXlTZXF1ZW5jZToKICoKICogVGhlIGtleSBzZXF1ZW5jZSBvZiBhIG5vZGUgdGFibGUgaXRlbS4KICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFQU1ZJSURDS2V5IHhtbFNjaGVtYVBTVklJRENLZXk7CnR5cGVkZWYgeG1sU2NoZW1hUFNWSUlEQ0tleSAqeG1sU2NoZW1hUFNWSUlEQ0tleVB0cjsKc3RydWN0IF94bWxTY2hlbWFQU1ZJSURDS2V5IHsKICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZTsKICAgIHhtbFNjaGVtYVZhbFB0ciB2YWw7Cn07CgovKioKICogeG1sU2NoZW1hUFNWSUlEQ05vZGU6CiAqCiAqIFRoZSBub2RlIHRhYmxlIGl0ZW0gb2YgYSBub2RlIHRhYmxlLgogKi8KdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYVBTVklJRENOb2RlIHhtbFNjaGVtYVBTVklJRENOb2RlOwp0eXBlZGVmIHhtbFNjaGVtYVBTVklJRENOb2RlICp4bWxTY2hlbWFQU1ZJSURDTm9kZVB0cjsKc3RydWN0IF94bWxTY2hlbWFQU1ZJSURDTm9kZSB7CiAgICB4bWxOb2RlUHRyIG5vZGU7CiAgICB4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICprZXlzOwogICAgaW50IG5vZGVMaW5lOwogICAgaW50IG5vZGVRTmFtZUlEOyAgICAKCn07CgovKioKICogeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmc6CiAqCiAqIFRoZSBpZGVudGl0eS1jb25zdHJhaW50IGJpbmRpbmcgaXRlbSBvZiB0aGUgW2lkZW50aXR5LWNvbnN0cmFpbnQgdGFibGVdLgogKi8KdHlwZWRlZiBzdHJ1Y3QgX3htbFNjaGVtYVBTVklJRENCaW5kaW5nIHhtbFNjaGVtYVBTVklJRENCaW5kaW5nOwp0eXBlZGVmIHhtbFNjaGVtYVBTVklJRENCaW5kaW5nICp4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0cjsKc3RydWN0IF94bWxTY2hlbWFQU1ZJSURDQmluZGluZyB7CiAgICB4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0ciBuZXh0OyAvKiBuZXh0IGJpbmRpbmcgb2YgYSBzcGVjaWZpYyBub2RlICovCiAgICB4bWxTY2hlbWFJRENQdHIgZGVmaW5pdGlvbjsgLyogdGhlIElEQyBkZWZpbml0aW9uICovCiAgICB4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciAqbm9kZVRhYmxlOyAvKiBhcnJheSBvZiBrZXktc2VxdWVuY2VzICovCiAgICBpbnQgbmJOb2RlczsgLyogbnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlIG5vZGUgdGFibGUgKi8KICAgIGludCBzaXplTm9kZXM7IC8qIHNpemUgb2YgdGhlIG5vZGUgdGFibGUgKi8KICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGR1cGxzOwp9OwoKCiNkZWZpbmUgWFBBVEhfU1RBVEVfT0JKX1RZUEVfSURDX1NFTEVDVE9SIDEKI2RlZmluZSBYUEFUSF9TVEFURV9PQkpfVFlQRV9JRENfRklFTEQgMgoKI2RlZmluZSBYUEFUSF9TVEFURV9PQkpfTUFUQ0hFUyAtMgojZGVmaW5lIFhQQVRIX1NUQVRFX09CSl9CTE9DS0VEIC0zCgp0eXBlZGVmIHN0cnVjdCBfeG1sU2NoZW1hSURDTWF0Y2hlciB4bWxTY2hlbWFJRENNYXRjaGVyOwp0eXBlZGVmIHhtbFNjaGVtYUlEQ01hdGNoZXIgKnhtbFNjaGVtYUlEQ01hdGNoZXJQdHI7CgovKioKICogeG1sU2NoZW1hSURDU3RhdGVPYmo6CiAqCiAqIFRoZSBzdGF0ZSBvYmplY3QgdXNlZCB0byBldmFsdWF0ZSBYUGF0aCBleHByZXNzaW9ucy4KICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFJRENTdGF0ZU9iaiB4bWxTY2hlbWFJRENTdGF0ZU9iajsKdHlwZWRlZiB4bWxTY2hlbWFJRENTdGF0ZU9iaiAqeG1sU2NoZW1hSURDU3RhdGVPYmpQdHI7CnN0cnVjdCBfeG1sU2NoZW1hSURDU3RhdGVPYmogewogICAgaW50IHR5cGU7CiAgICB4bWxTY2hlbWFJRENTdGF0ZU9ialB0ciBuZXh0OyAvKiBuZXh0IGlmIGluIGEgbGlzdCAqLwogICAgaW50IGRlcHRoOyAvKiBkZXB0aCBvZiBjcmVhdGlvbiAqLwogICAgaW50ICpoaXN0b3J5OyAvKiBsaXN0IG9mIChkZXB0aCwgc3RhdGUtaWQpIHR1cGxlcyAqLwogICAgaW50IG5iSGlzdG9yeTsKICAgIGludCBzaXplSGlzdG9yeTsKICAgIHhtbFNjaGVtYUlEQ01hdGNoZXJQdHIgbWF0Y2hlcjsgLyogdGhlIGNvcnJlc3BvbmRlbnQgZmllbGQvc2VsZWN0b3IKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWF0Y2hlciAqLwogICAgeG1sU2NoZW1hSURDU2VsZWN0UHRyIHNlbDsKICAgIHZvaWQgKnhwYXRoQ3R4dDsKfTsKCiNkZWZpbmUgSURDX01BVENIRVIgMAoKLyoqCiAqIHhtbFNjaGVtYUlEQ01hdGNoZXI6CiAqCiAqIFVzZWQgdG8gZXZhbHVhdGUgSURDIHNlbGVjdG9ycyAoYW5kIGZpZWxkcykuCiAqLwpzdHJ1Y3QgX3htbFNjaGVtYUlEQ01hdGNoZXIgewogICAgaW50IHR5cGU7CiAgICBpbnQgZGVwdGg7IC8qIHRoZSB0cmVlIGRlcHRoIGF0IGNyZWF0aW9uIHRpbWUgKi8KICAgIHhtbFNjaGVtYUlEQ01hdGNoZXJQdHIgbmV4dDsgLyogbmV4dCBpbiB0aGUgbGlzdCAqLwogICAgeG1sU2NoZW1hSURDQXVnUHRyIGFpZGM7IC8qIHRoZSBhdWdtZW50ZWQgSURDIGl0ZW0gKi8KICAgIGludCBpZGNUeXBlOwogICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciAqKmtleVNlcXM7IC8qIHRoZSBrZXktc2VxdWVuY2VzIG9mIHRoZSB0YXJnZXQKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbGVtZW50cyAqLwogICAgaW50IHNpemVLZXlTZXFzOwogICAgaW50IHRhcmdldERlcHRoOwogICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgdGFyZ2V0czsgLyogbGlzdCBvZiB0YXJnZXQtbm9kZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyKSBlbnRyaWVzICovCn07CgovKgoqIEVsZW1lbnQgaW5mbyBmbGFncy4KKi8KI2RlZmluZSBYTUxfU0NIRU1BX05PREVfSU5GT19GTEFHX09XTkVEX05BTUVTICAxPDwwCiNkZWZpbmUgWE1MX1NDSEVNQV9OT0RFX0lORk9fRkxBR19PV05FRF9WQUxVRVMgMTw8MQojZGVmaW5lIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX05JTExFRAkgICAgICAgMTw8MgojZGVmaW5lIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0xPQ0FMX1RZUEUJICAgICAgIDE8PDMKCiNkZWZpbmUgWE1MX1NDSEVNQV9OT0RFX0lORk9fVkFMVUVfTkVFREVEICAgICAgMTw8NAojZGVmaW5lIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZICAgICAgICAgICAgIDE8PDUKI2RlZmluZSBYTUxfU0NIRU1BX0VMRU1fSU5GT19IQVNfQ09OVEVOVCAgICAgICAxPDw2CgojZGVmaW5lIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0hBU19FTEVNX0NPTlRFTlQgIDE8PDcKI2RlZmluZSBYTUxfU0NIRU1BX0VMRU1fSU5GT19FUlJfQkFEX0NPTlRFTlQgIDE8PDgKI2RlZmluZSBYTUxfU0NIRU1BX05PREVfSU5GT19FUlJfTk9UX0VYUEVDVEVEICAxPDw5CiNkZWZpbmUgWE1MX1NDSEVNQV9OT0RFX0lORk9fRVJSX0JBRF9UWVBFICAxPDwxMAoKLyoqCiAqIHhtbFNjaGVtYU5vZGVJbmZvOgogKgogKiBIb2xkcyBpbmZvcm1hdGlvbiBvZiBhbiBlbGVtZW50IG5vZGUuCiAqLwpzdHJ1Y3QgX3htbFNjaGVtYU5vZGVJbmZvIHsKICAgIGludCBub2RlVHlwZTsKICAgIHhtbE5vZGVQdHIgbm9kZTsKICAgIGludCBub2RlTGluZTsgICAgCiAgICBjb25zdCB4bWxDaGFyICpsb2NhbE5hbWU7CiAgICBjb25zdCB4bWxDaGFyICpuc05hbWU7CiAgICBjb25zdCB4bWxDaGFyICp2YWx1ZTsKICAgIHhtbFNjaGVtYVZhbFB0ciB2YWw7IC8qIHRoZSBwcmUtY29tcHV0ZWQgdmFsdWUgaWYgYW55ICovCiAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGVEZWY7IC8qIHRoZSBjb21wbGV4L3NpbXBsZSB0eXBlIGRlZmluaXRpb24gaWYgYW55ICovCgogICAgaW50IGZsYWdzOyAvKiBjb21iaW5hdGlvbiBvZiBub2RlIGluZm8gZmxhZ3MgKi8KCiAgICBpbnQgdmFsTmVlZGVkOwogICAgaW50IG5vcm1WYWw7CgogICAgeG1sU2NoZW1hRWxlbWVudFB0ciBkZWNsOyAvKiB0aGUgZWxlbWVudC9hdHRyaWJ1dGUgZGVjbGFyYXRpb24gKi8KICAgIGludCBkZXB0aDsKICAgIHhtbFNjaGVtYVBTVklJRENCaW5kaW5nUHRyIGlkY1RhYmxlOyAvKiB0aGUgdGFibGUgb2YgUFNWSSBJREMgYmluZGluZ3MKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmb3IgdGhlIHNjb3BlIGVsZW1lbnQqLwogICAgeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBpZGNNYXRjaGVyczsgLyogdGhlIElEQyBtYXRjaGVycyBmb3IgdGhlIHNjb3BlCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbGVtZW50ICovCiAgICB4bWxSZWdFeGVjQ3R4dFB0ciByZWdleEN0eHQ7CgogICAgY29uc3QgeG1sQ2hhciAqKm5zQmluZGluZ3M7IC8qIE5hbWVzcGFjZSBiaW5kaW5ncyBvbiB0aGlzIGVsZW1lbnQgKi8KICAgIGludCBuYk5zQmluZGluZ3M7CiAgICBpbnQgc2l6ZU5zQmluZGluZ3M7ICAgIAoKICAgIGludCBoYXNLZXlyZWZzOwogICAgaW50IGFwcGxpZWRYUGF0aDsgLyogSW5kaWNhdGVzIHRoYXQgYW4gWFBhdGggaGFzIGJlZW4gYXBwbGllZC4gKi8KfTsKCiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9VTktOT1dOIDEKI2RlZmluZSBYTUxfU0NIRU1BU19BVFRSX0FTU0VTU0VEIDIKI2RlZmluZSBYTUxfU0NIRU1BU19BVFRSX1BST0hJQklURUQgMwojZGVmaW5lIFhNTF9TQ0hFTUFTX0FUVFJfRVJSX01JU1NJTkcgNAojZGVmaW5lIFhNTF9TQ0hFTUFTX0FUVFJfSU5WQUxJRF9WQUxVRSA1CiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9FUlJfTk9fVFlQRSA2CiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9FUlJfRklYRURfVkFMVUUgNwojZGVmaW5lIFhNTF9TQ0hFTUFTX0FUVFJfREVGQVVMVCA4CiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9WQUxJREFURV9WQUxVRSA5CiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9FUlJfV0lMRF9TVFJJQ1RfTk9fREVDTCAxMAojZGVmaW5lIFhNTF9TQ0hFTUFTX0FUVFJfSEFTX0FUVFJfVVNFIDExCiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9IQVNfQVRUUl9ERUNMIDEyCiNkZWZpbmUgWE1MX1NDSEVNQVNfQVRUUl9XSUxEX1NLSVAgMTMKI2RlZmluZSBYTUxfU0NIRU1BU19BVFRSX1dJTERfTEFYX05PX0RFQ0wgMTQKI2RlZmluZSBYTUxfU0NIRU1BU19BVFRSX0VSUl9XSUxEX0RVUExJQ0FURV9JRCAxNQojZGVmaW5lIFhNTF9TQ0hFTUFTX0FUVFJfRVJSX1dJTERfQU5EX1VTRV9JRCAxNgojZGVmaW5lIFhNTF9TQ0hFTUFTX0FUVFJfTUVUQSAxNwovKgoqIEBtZXRhVHlwZSB2YWx1ZXMgb2YgeG1sU2NoZW1hQXR0ckluZm8uCiovCiNkZWZpbmUgWE1MX1NDSEVNQV9BVFRSX0lORk9fTUVUQV9YU0lfVFlQRSAxCiNkZWZpbmUgWE1MX1NDSEVNQV9BVFRSX0lORk9fTUVUQV9YU0lfTklMIDIKI2RlZmluZSBYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hTSV9TQ0hFTUFfTE9DIDMKI2RlZmluZSBYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hTSV9OT19OU19TQ0hFTUFfTE9DIDQKI2RlZmluZSBYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hNTE5TIDUKCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFBdHRySW5mbyB4bWxTY2hlbWFBdHRySW5mbzsKdHlwZWRlZiB4bWxTY2hlbWFBdHRySW5mbyAqeG1sU2NoZW1hQXR0ckluZm9QdHI7CnN0cnVjdCBfeG1sU2NoZW1hQXR0ckluZm8gewogICAgaW50IG5vZGVUeXBlOwogICAgeG1sTm9kZVB0ciBub2RlOwogICAgaW50IG5vZGVMaW5lOyAgICAKICAgIGNvbnN0IHhtbENoYXIgKmxvY2FsTmFtZTsKICAgIGNvbnN0IHhtbENoYXIgKm5zTmFtZTsKICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlOwogICAgeG1sU2NoZW1hVmFsUHRyIHZhbDsgLyogdGhlIHByZS1jb21wdXRlZCB2YWx1ZSBpZiBhbnkgKi8KICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZURlZjsgLyogdGhlIGNvbXBsZXgvc2ltcGxlIHR5cGUgZGVmaW5pdGlvbiBpZiBhbnkgKi8KICAgIGludCBmbGFnczsgLyogY29tYmluYXRpb24gb2Ygbm9kZSBpbmZvIGZsYWdzICovCgogICAgeG1sU2NoZW1hQXR0cmlidXRlUHRyIGRlY2w7IC8qIHRoZSBhdHRyaWJ1dGUgZGVjbGFyYXRpb24gKi8KICAgIHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVB0ciB1c2U7ICAvKiB0aGUgYXR0cmlidXRlIHVzZSAqLwogICAgaW50IHN0YXRlOwogICAgaW50IG1ldGFUeXBlOwogICAgY29uc3QgeG1sQ2hhciAqdmNWYWx1ZTsgLyogdGhlIHZhbHVlIGNvbnN0cmFpbnQgdmFsdWUgKi8KICAgIHhtbFNjaGVtYU5vZGVJbmZvUHRyIHBhcmVudDsKfTsKCgojZGVmaW5lIFhNTF9TQ0hFTUFfVkFMSURfQ1RYVF9GTEFHX1NUUkVBTSAxCi8qKgogKiB4bWxTY2hlbWFWYWxpZEN0eHQ6CiAqCiAqIEEgU2NoZW1hcyB2YWxpZGF0aW9uIGNvbnRleHQKICovCnN0cnVjdCBfeG1sU2NoZW1hVmFsaWRDdHh0IHsKICAgIGludCB0eXBlOwogICAgdm9pZCAqZXJyQ3R4dDsgICAgICAgICAgICAgLyogdXNlciBzcGVjaWZpYyBkYXRhIGJsb2NrICovCiAgICB4bWxTY2hlbWFWYWxpZGl0eUVycm9yRnVuYyBlcnJvcjsgICAvKiB0aGUgY2FsbGJhY2sgaW4gY2FzZSBvZiBlcnJvcnMgKi8KICAgIHhtbFNjaGVtYVZhbGlkaXR5V2FybmluZ0Z1bmMgd2FybmluZzsgLyogdGhlIGNhbGxiYWNrIGluIGNhc2Ugb2Ygd2FybmluZyAqLwogICAgeG1sU3RydWN0dXJlZEVycm9yRnVuYyBzZXJyb3I7CgogICAgeG1sU2NoZW1hUHRyIHNjaGVtYTsgICAgICAgIC8qIFRoZSBzY2hlbWEgaW4gdXNlICovCiAgICB4bWxEb2NQdHIgZG9jOwogICAgeG1sUGFyc2VySW5wdXRCdWZmZXJQdHIgaW5wdXQ7CiAgICB4bWxDaGFyRW5jb2RpbmcgZW5jOwogICAgeG1sU0FYSGFuZGxlclB0ciBzYXg7CiAgICB4bWxQYXJzZXJDdHh0UHRyIHBhcnNlckN0eHQ7CiAgICB2b2lkICp1c2VyX2RhdGE7IC8qIFRPRE86IFdoYXQgaXMgdGhpcyBmb3I/ICovCgogICAgaW50IGVycjsKICAgIGludCBuYmVycm9yczsKCiAgICB4bWxOb2RlUHRyIG5vZGU7CiAgICB4bWxOb2RlUHRyIGN1cjsKICAgIC8qIHhtbFNjaGVtYVR5cGVQdHIgdHlwZTsgKi8KCiAgICB4bWxSZWdFeGVjQ3R4dFB0ciByZWdleHA7CiAgICB4bWxTY2hlbWFWYWxQdHIgdmFsdWU7CgogICAgaW50IHZhbHVlV1M7CiAgICBpbnQgb3B0aW9uczsKICAgIHhtbE5vZGVQdHIgdmFsaWRhdGlvblJvb3Q7CiAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0OwogICAgaW50IHhzaUFzc2VtYmxlOwoKICAgIGludCBkZXB0aDsKICAgIHhtbFNjaGVtYU5vZGVJbmZvUHRyICplbGVtSW5mb3M7IC8qIGFycmF5IG9mIGVsZW1lbnQgaW5mb3JtYXRpb25zICovCiAgICBpbnQgc2l6ZUVsZW1JbmZvczsKICAgIHhtbFNjaGVtYU5vZGVJbmZvUHRyIGlub2RlOyAvKiB0aGUgY3VycmVudCBlbGVtZW50IGluZm9ybWF0aW9uICovCgogICAgeG1sU2NoZW1hSURDQXVnUHRyIGFpZGNzOyAvKiBhIGxpc3Qgb2YgYXVnbWVudGVkIElEQyBpbmZvcm1hdGlvbnMgKi8KCiAgICB4bWxTY2hlbWFJRENTdGF0ZU9ialB0ciB4cGF0aFN0YXRlczsgLyogZmlyc3QgYWN0aXZlIHN0YXRlIG9iamVjdC4gKi8KICAgIHhtbFNjaGVtYUlEQ1N0YXRlT2JqUHRyIHhwYXRoU3RhdGVQb29sOyAvKiBmaXJzdCBzdG9yZWQgc3RhdGUgb2JqZWN0LiAqLwoKICAgIHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICppZGNOb2RlczsgLyogbGlzdCBvZiBhbGwgSURDIG5vZGUtdGFibGUgZW50cmllcyovCiAgICBpbnQgbmJJZGNOb2RlczsKICAgIGludCBzaXplSWRjTm9kZXM7CgogICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciAqaWRjS2V5czsgLyogbGlzdCBvZiBhbGwgSURDIG5vZGUtdGFibGUgZW50cmllcyAqLwogICAgaW50IG5iSWRjS2V5czsKICAgIGludCBzaXplSWRjS2V5czsKCiAgICBpbnQgZmxhZ3M7CgogICAgeG1sRGljdFB0ciBkaWN0OwoKI2lmZGVmIExJQlhNTF9SRUFERVJfRU5BQkxFRAogICAgeG1sVGV4dFJlYWRlclB0ciByZWFkZXI7CiNlbmRpZgoKICAgIHhtbFNjaGVtYUF0dHJJbmZvUHRyICphdHRySW5mb3M7CiAgICBpbnQgbmJBdHRySW5mb3M7CiAgICBpbnQgc2l6ZUF0dHJJbmZvczsKCiAgICBpbnQgc2tpcERlcHRoOwogICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgbm9kZVFOYW1lczsKICAgIGludCBoYXNLZXlyZWZzOwogICAgaW50IGNyZWF0ZUlEQ05vZGVUYWJsZXM7CiAgICBpbnQgcHN2aUV4cG9zZUlEQ05vZGVUYWJsZXM7Cn07CgovKioKICogeG1sU2NoZW1hU3Vic3RHcm91cDoKICoKICoKICovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFTdWJzdEdyb3VwIHhtbFNjaGVtYVN1YnN0R3JvdXA7CnR5cGVkZWYgeG1sU2NoZW1hU3Vic3RHcm91cCAqeG1sU2NoZW1hU3Vic3RHcm91cFB0cjsKc3RydWN0IF94bWxTY2hlbWFTdWJzdEdyb3VwIHsKICAgIHhtbFNjaGVtYUVsZW1lbnRQdHIgaGVhZDsKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIG1lbWJlcnM7Cn07CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQkJCQkJCSoKICogCQkJU29tZSBwcmVkZWNsYXJhdGlvbnMJCQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgaW50IHhtbFNjaGVtYVBhcnNlSW5jbHVkZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSk7CnN0YXRpYyBpbnQgeG1sU2NoZW1hUGFyc2VSZWRlZmluZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSk7CnN0YXRpYyBpbnQKeG1sU2NoZW1hVHlwZUZpeHVwKHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBjdHh0KTsKc3RhdGljIGNvbnN0IHhtbENoYXIgKgp4bWxTY2hlbWFGYWNldFR5cGVUb1N0cmluZyh4bWxTY2hlbWFUeXBlVHlwZSB0eXBlKTsKc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZUltcG9ydCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSk7CnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tGYWNldFZhbHVlcyh4bWxTY2hlbWFUeXBlUHRyIHR5cGVEZWNsLAogICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCk7CnN0YXRpYyB2b2lkCnhtbFNjaGVtYUNsZWFyVmFsaWRDdHh0KHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCk7CnN0YXRpYyB4bWxTY2hlbWFXaGl0ZXNwYWNlVmFsdWVUeXBlCnhtbFNjaGVtYUdldFdoaXRlU3BhY2VGYWNldFZhbHVlKHhtbFNjaGVtYVR5cGVQdHIgdHlwZSk7CnN0YXRpYyB4bWxTY2hlbWFUcmVlSXRlbVB0cgp4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkgeG1sTm9kZVB0ciBub2RlLCB4bWxTY2hlbWFUeXBlVHlwZSB0eXBlLAoJCQkgaW50IHdpdGhQYXJ0aWNsZSk7CnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hR2V0Q29tcG9uZW50VHlwZVN0cih4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSk7CnN0YXRpYyB4bWxTY2hlbWFUeXBlTGlua1B0cgp4bWxTY2hlbWFHZXRVbmlvblNpbXBsZVR5cGVNZW1iZXJUeXBlcyh4bWxTY2hlbWFUeXBlUHRyIHR5cGUpOwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFJbnRlcm5hbEVycih4bWxTY2hlbWFBYnN0cmFjdEN0eHRQdHIgYWN0eHQsCgkJICAgICBjb25zdCBjaGFyICpmdW5jTmFtZSwKCQkgICAgIGNvbnN0IGNoYXIgKm1lc3NhZ2UpOwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ09TU1REZXJpdmVkT0soeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGN0eHQsCgkJCSAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQkgICAgIHhtbFNjaGVtYVR5cGVQdHIgYmFzZVR5cGUsCgkJCSAgICAgaW50IHN1YnNldCk7CnN0YXRpYyB2b2lkCnhtbFNjaGVtYUNoZWNrRWxlbWVudERlY2xDb21wb25lbnQoeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtRGVjbCwKCQkJCSAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCk7CnN0YXRpYyB2b2lkCnhtbFNjaGVtYUNvbXBvbmVudExpc3RGcmVlKHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QpOwpzdGF0aWMgeG1sU2NoZW1hUU5hbWVSZWZQdHIKeG1sU2NoZW1hUGFyc2VBdHRyaWJ1dGVHcm91cFJlZih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkJeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJCXhtbE5vZGVQdHIgbm9kZSk7CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQkJCQkJCQkJKgogKiAJCQlIZWxwZXIgZnVuY3Rpb25zCQkJICAgICAgICAqCiAqCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoqCiAqIHhtbFNjaGVtYUl0ZW1UeXBlVG9TdHI6CiAqIEB0eXBlOiB0aGUgdHlwZSBvZiB0aGUgc2NoZW1hIGl0ZW0KICoKICogUmV0dXJucyB0aGUgY29tcG9uZW50IG5hbWUgb2YgYSBzY2hlbWEgaXRlbS4KICovCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hSXRlbVR5cGVUb1N0cih4bWxTY2hlbWFUeXBlVHlwZSB0eXBlKQp7CiAgICBzd2l0Y2ggKHR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0JBU0lDOgoJICAgIHJldHVybihCQURfQ0FTVCAic2ltcGxlIHR5cGUgZGVmaW5pdGlvbiIpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJICAgIHJldHVybihCQURfQ0FTVCAic2ltcGxlIHR5cGUgZGVmaW5pdGlvbiIpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCSAgICByZXR1cm4oQkFEX0NBU1QgImNvbXBsZXggdHlwZSBkZWZpbml0aW9uIik7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOgoJICAgIHJldHVybihCQURfQ0FTVCAiZWxlbWVudCBkZWNsYXJhdGlvbiIpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFX1VTRToKCSAgICByZXR1cm4oQkFEX0NBU1QgImF0dHJpYnV0ZSB1c2UiKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURToKCSAgICByZXR1cm4oQkFEX0NBU1QgImF0dHJpYnV0ZSBkZWNsYXJhdGlvbiIpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkgICAgcmV0dXJuKEJBRF9DQVNUICJtb2RlbCBncm91cCBkZWZpbml0aW9uIik7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUDoKCSAgICByZXR1cm4oQkFEX0NBU1QgImF0dHJpYnV0ZSBncm91cCBkZWZpbml0aW9uIik7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9OT1RBVElPTjoKCSAgICByZXR1cm4oQkFEX0NBU1QgIm5vdGF0aW9uIGRlY2xhcmF0aW9uIik7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9TRVFVRU5DRToKCSAgICByZXR1cm4oQkFEX0NBU1QgIm1vZGVsIGdyb3VwIChzZXF1ZW5jZSkiKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0NIT0lDRToKCSAgICByZXR1cm4oQkFEX0NBU1QgIm1vZGVsIGdyb3VwIChjaG9pY2UpIik7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTEw6CgkgICAgcmV0dXJuKEJBRF9DQVNUICJtb2RlbCBncm91cCAoYWxsKSIpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfUEFSVElDTEU6CgkgICAgcmV0dXJuKEJBRF9DQVNUICJwYXJ0aWNsZSIpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX1VOSVFVRToKCSAgICByZXR1cm4oQkFEX0NBU1QgInVuaXF1ZSBpZGVudGl0eS1jb25zdHJhaW50Iik7CgkgICAgLyogcmV0dXJuKEJBRF9DQVNUICJJREMgKHVuaXF1ZSkiKTsgKi8KCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVk6CgkgICAgcmV0dXJuKEJBRF9DQVNUICJrZXkgaWRlbnRpdHktY29uc3RyYWludCIpOwoJICAgIC8qIHJldHVybihCQURfQ0FTVCAiSURDIChrZXkpIik7ICovCgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGOgoJICAgIHJldHVybihCQURfQ0FTVCAia2V5cmVmIGlkZW50aXR5LWNvbnN0cmFpbnQiKTsKCSAgICAvKiByZXR1cm4oQkFEX0NBU1QgIklEQyAoa2V5cmVmKSIpOyAqLwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZOgoJICAgIHJldHVybihCQURfQ0FTVCAid2lsZGNhcmQgKGFueSkiKTsKCWNhc2UgWE1MX1NDSEVNQV9FWFRSQV9RTkFNRVJFRjoKCSAgICByZXR1cm4oQkFEX0NBU1QgIltoZWxwZXIgY29tcG9uZW50XSBRTmFtZSByZWZlcmVuY2UiKTsKCWNhc2UgWE1MX1NDSEVNQV9FWFRSQV9BVFRSX1VTRV9QUk9ISUI6CgkgICAgcmV0dXJuKEJBRF9DQVNUICJbaGVscGVyIGNvbXBvbmVudF0gYXR0cmlidXRlIHVzZSBwcm9oaWJpdGlvbiIpOwoJZGVmYXVsdDoKCSAgICByZXR1cm4oQkFEX0NBU1QgIk5vdCBhIHNjaGVtYSBjb21wb25lbnQiKTsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUdldENvbXBvbmVudFR5cGVTdHI6CiAqIEB0eXBlOiB0aGUgdHlwZSBvZiB0aGUgc2NoZW1hIGl0ZW0KICoKICogUmV0dXJucyB0aGUgY29tcG9uZW50IG5hbWUgb2YgYSBzY2hlbWEgaXRlbS4KICovCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hR2V0Q29tcG9uZW50VHlwZVN0cih4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSkKewogICAgc3dpdGNoIChpdGVtLT50eXBlKSB7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9CQVNJQzoKCSAgICBpZiAoV1hTX0lTX0NPTVBMRVgoV1hTX1RZUEVfQ0FTVCBpdGVtKSkKCQlyZXR1cm4oQkFEX0NBU1QgImNvbXBsZXggdHlwZSBkZWZpbml0aW9uIik7CgkgICAgZWxzZQoJCXJldHVybihCQURfQ0FTVCAic2ltcGxlIHR5cGUgZGVmaW5pdGlvbiIpOwkKCWRlZmF1bHQ6CgkgICAgcmV0dXJuKHhtbFNjaGVtYUl0ZW1UeXBlVG9TdHIoaXRlbS0+dHlwZSkpOwogICAgfQp9CgovKioKICogeG1sU2NoZW1hR2V0Q29tcG9uZW50Tm9kZToKICogQGl0ZW06IGEgc2NoZW1hIGNvbXBvbmVudAogKgogKiBSZXR1cm5zIG5vZGUgYXNzb2NpYXRlZCB3aXRoIHRoZSBzY2hlbWEgY29tcG9uZW50LgogKiBOT1RFIHRoYXQgc3VjaCBhIG5vZGUgbmVlZCBub3QgYmUgYXZhaWxhYmxlOyBwbHVzLCBhIGNvbXBvbmVudCdzCiAqIG5vZGUgbmVlZCBub3QgdG8gcmVmbGVjdCB0aGUgY29tcG9uZW50IGRpcmVjdGx5LCBzaW5jZSB0aGVyZSBpcyBubwogKiBvbmUtdG8tb25lIHJlbGF0aW9uc2hpcCBiZXR3ZWVuIHRoZSBYTUwgU2NoZW1hIHJlcHJlc2VudGF0aW9uIGFuZAogKiB0aGUgY29tcG9uZW50IHJlcHJlc2VudGF0aW9uLgogKi8Kc3RhdGljIHhtbE5vZGVQdHIKeG1sU2NoZW1hR2V0Q29tcG9uZW50Tm9kZSh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSkKewogICAgc3dpdGNoIChpdGVtLT50eXBlKSB7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFFbGVtZW50UHRyKSBpdGVtKS0+bm9kZSk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEU6CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYUF0dHJpYnV0ZVB0cikgaXRlbSktPm5vZGUpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX1NJTVBMRToKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hVHlwZVB0cikgaXRlbSktPm5vZGUpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZX0FUVFJJQlVURToKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hV2lsZGNhcmRQdHIpIGl0ZW0pLT5ub2RlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX1BBUlRJQ0xFOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgaXRlbSktPm5vZGUpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0U6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0U6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTEw6CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYU1vZGVsR3JvdXBQdHIpIGl0ZW0pLT5ub2RlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyKSBpdGVtKS0+bm9kZSk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUDoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIpIGl0ZW0pLT5ub2RlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19VTklRVUU6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRjoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hSURDUHRyKSBpdGVtKS0+bm9kZSk7CgljYXNlIFhNTF9TQ0hFTUFfRVhUUkFfUU5BTUVSRUY6CgkgICAgcmV0dXJuKCgoeG1sU2NoZW1hUU5hbWVSZWZQdHIpIGl0ZW0pLT5ub2RlKTsKCS8qIFRPRE86IFdoYXQgdG8gZG8gd2l0aCBOT1RBVElPTnM/CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9OT1RBVElPTjoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hTm90YXRpb25QdHIpIGl0ZW0pLT5ub2RlKTsKCSovCgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVfVVNFOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIpIGl0ZW0pLT5ub2RlKTsKCWRlZmF1bHQ6CgkgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KfQoKI2lmIDAKLyoqCiAqIHhtbFNjaGVtYUdldE5leHRDb21wb25lbnQ6CiAqIEBpdGVtOiBhIHNjaGVtYSBjb21wb25lbnQKICoKICogUmV0dXJucyB0aGUgbmV4dCBzaWJsaW5nIG9mIHRoZSBzY2hlbWEgY29tcG9uZW50LgogKi8Kc3RhdGljIHhtbFNjaGVtYUJhc2ljSXRlbVB0cgp4bWxTY2hlbWFHZXROZXh0Q29tcG9uZW50KHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBpdGVtKQp7CiAgICBzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQ6CgkgICAgcmV0dXJuICgoeG1sU2NoZW1hQmFzaWNJdGVtUHRyKSAoKHhtbFNjaGVtYUVsZW1lbnRQdHIpIGl0ZW0pLT5uZXh0KTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURToKCSAgICByZXR1cm4gKCh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIpICgoeG1sU2NoZW1hQXR0cmlidXRlUHRyKSBpdGVtKS0+bmV4dCk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJICAgIHJldHVybiAoKHhtbFNjaGVtYUJhc2ljSXRlbVB0cikgKCh4bWxTY2hlbWFUeXBlUHRyKSBpdGVtKS0+bmV4dCk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTlk6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTllfQVRUUklCVVRFOgoJICAgIHJldHVybiAoTlVMTCk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9QQVJUSUNMRToKCSAgICByZXR1cm4gKCh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIpICgoeG1sU2NoZW1hUGFydGljbGVQdHIpIGl0ZW0pLT5uZXh0KTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQUxMOgoJICAgIHJldHVybiAoTlVMTCk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9HUk9VUDoKCSAgICByZXR1cm4gKE5VTEwpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVA6CgkgICAgcmV0dXJuICgoeG1sU2NoZW1hQmFzaWNJdGVtUHRyKSAoKHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyKSBpdGVtKS0+bmV4dCk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfVU5JUVVFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWToKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUY6CgkgICAgcmV0dXJuICgoeG1sU2NoZW1hQmFzaWNJdGVtUHRyKSAoKHhtbFNjaGVtYUlEQ1B0cikgaXRlbSktPm5leHQpOwoJZGVmYXVsdDoKCSAgICByZXR1cm4gKE5VTEwpOwogICAgfQp9CiNlbmRpZgoKCi8qKgogKiB4bWxTY2hlbWFGb3JtYXRRTmFtZToKICogQGJ1ZjogdGhlIHN0cmluZyBidWZmZXIKICogQG5hbWVzcGFjZU5hbWU6ICB0aGUgbmFtZXNwYWNlIG5hbWUKICogQGxvY2FsTmFtZTogdGhlIGxvY2FsIG5hbWUKICoKICogUmV0dXJucyB0aGUgZ2l2ZW4gUU5hbWUgaW4gdGhlIGZvcm1hdCAie25hbWVzcGFjZU5hbWV9bG9jYWxOYW1lIiBvcgogKiBqdXN0ICJsb2NhbE5hbWUiIGlmIEBuYW1lc3BhY2VOYW1lIGlzIE5VTEwuCiAqCiAqIFJldHVybnMgdGhlIGxvY2FsTmFtZSBpZiBAbmFtZXNwYWNlTmFtZSBpcyBOVUxMLCBhIGZvcm1hdHRlZAogKiBzdHJpbmcgb3RoZXJ3aXNlLgogKi8Kc3RhdGljIGNvbnN0IHhtbENoYXIqCnhtbFNjaGVtYUZvcm1hdFFOYW1lKHhtbENoYXIgKipidWYsCgkJICAgICBjb25zdCB4bWxDaGFyICpuYW1lc3BhY2VOYW1lLAoJCSAgICAgY29uc3QgeG1sQ2hhciAqbG9jYWxOYW1lKQp7CiAgICBGUkVFX0FORF9OVUxMKCpidWYpCiAgICBpZiAobmFtZXNwYWNlTmFtZSAhPSBOVUxMKSB7CgkqYnVmID0geG1sU3RyZHVwKEJBRF9DQVNUICJ7Iik7CgkqYnVmID0geG1sU3RyY2F0KCpidWYsIG5hbWVzcGFjZU5hbWUpOwoJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAifSIpOwogICAgfQogICAgaWYgKGxvY2FsTmFtZSAhPSBOVUxMKSB7CglpZiAobmFtZXNwYWNlTmFtZSA9PSBOVUxMKQoJICAgIHJldHVybihsb2NhbE5hbWUpOwoJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBsb2NhbE5hbWUpOwogICAgfSBlbHNlIHsKCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIihOVUxMKSIpOwogICAgfSAgICAKICAgIHJldHVybiAoKGNvbnN0IHhtbENoYXIgKikgKmJ1Zik7Cn0KCnN0YXRpYyBjb25zdCB4bWxDaGFyKiAgIAp4bWxTY2hlbWFGb3JtYXRRTmFtZU5zKHhtbENoYXIgKipidWYsIHhtbE5zUHRyIG5zLCBjb25zdCB4bWxDaGFyICpsb2NhbE5hbWUpCnsKICAgIGlmIChucyAhPSBOVUxMKQoJcmV0dXJuICh4bWxTY2hlbWFGb3JtYXRRTmFtZShidWYsIG5zLT5ocmVmLCBsb2NhbE5hbWUpKTsKICAgIGVsc2UKCXJldHVybiAoeG1sU2NoZW1hRm9ybWF0UU5hbWUoYnVmLCBOVUxMLCBsb2NhbE5hbWUpKTsKfQoKc3RhdGljIGNvbnN0IHhtbENoYXIgKgp4bWxTY2hlbWFHZXRDb21wb25lbnROYW1lKHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBpdGVtKQp7CiAgICBzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQ6CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYUVsZW1lbnRQdHIpIGl0ZW0pLT5uYW1lKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURToKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hQXR0cmlidXRlUHRyKSBpdGVtKS0+bmFtZSk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUDoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIpIGl0ZW0pLT5uYW1lKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0JBU0lDOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hVHlwZVB0cikgaXRlbSktPm5hbWUpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYU1vZGVsR3JvdXBEZWZQdHIpIGl0ZW0pLT5uYW1lKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVk6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfVU5JUVVFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRjoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hSURDUHRyKSBpdGVtKS0+bmFtZSk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVfVVNFOgoJICAgIGlmIChXWFNfQVRUUlVTRV9ERUNMKGl0ZW0pICE9IE5VTEwpIHsKCQlyZXR1cm4oeG1sU2NoZW1hR2V0Q29tcG9uZW50TmFtZSgKCQkgICAgV1hTX0JBU0lDX0NBU1QgV1hTX0FUVFJVU0VfREVDTChpdGVtKSkpOwoJICAgIH0gZWxzZQoJCXJldHVybihOVUxMKTsKCWNhc2UgWE1MX1NDSEVNQV9FWFRSQV9RTkFNRVJFRjoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hUU5hbWVSZWZQdHIpIGl0ZW0pLT5uYW1lKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX05PVEFUSU9OOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFOb3RhdGlvblB0cikgaXRlbSktPm5hbWUpOwoJZGVmYXVsdDoKCSAgICAvKgoJICAgICogT3RoZXIgY29tcG9uZW50cyBjYW5ub3QgaGF2ZSBuYW1lcy4KCSAgICAqLwoJICAgIGJyZWFrOwogICAgfQogICAgcmV0dXJuIChOVUxMKTsKfQoKI2RlZmluZSB4bWxTY2hlbWFHZXRRTmFtZVJlZk5hbWUocikgKFdYU19RTkFNRV9DQVNUIChyKSktPm5hbWUKI2RlZmluZSB4bWxTY2hlbWFHZXRRTmFtZVJlZlRhcmdldE5zKHIpIChXWFNfUU5BTUVfQ0FTVCAocikpLT50YXJnZXROYW1lc3BhY2UKLyoKc3RhdGljIGNvbnN0IHhtbENoYXIgKgp4bWxTY2hlbWFHZXRRTmFtZVJlZk5hbWUodm9pZCAqcmVmKQp7CiAgICByZXR1cm4oKCh4bWxTY2hlbWFRTmFtZVJlZlB0cikgcmVmKS0+bmFtZSk7Cn0KCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hR2V0UU5hbWVSZWZUYXJnZXROcyh2b2lkICpyZWYpCnsKICAgIHJldHVybigoKHhtbFNjaGVtYVFOYW1lUmVmUHRyKSByZWYpLT50YXJnZXROYW1lc3BhY2UpOwp9CiovCgpzdGF0aWMgY29uc3QgeG1sQ2hhciAqCnhtbFNjaGVtYUdldENvbXBvbmVudFRhcmdldE5zKHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBpdGVtKQp7CiAgICBzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQ6CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYUVsZW1lbnRQdHIpIGl0ZW0pLT50YXJnZXROYW1lc3BhY2UpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIpIGl0ZW0pLT50YXJnZXROYW1lc3BhY2UpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVA6CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyKSBpdGVtKS0+dGFyZ2V0TmFtZXNwYWNlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0JBU0lDOgoJICAgIHJldHVybiAoQkFEX0NBU1QgImh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hIik7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFUeXBlUHRyKSBpdGVtKS0+dGFyZ2V0TmFtZXNwYWNlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOgoJICAgIHJldHVybiAoKCh4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyKSBpdGVtKS0+dGFyZ2V0TmFtZXNwYWNlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVk6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfVU5JUVVFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRjoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hSURDUHRyKSBpdGVtKS0+dGFyZ2V0TmFtZXNwYWNlKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURV9VU0U6CgkgICAgaWYgKFdYU19BVFRSVVNFX0RFQ0woaXRlbSkgIT0gTlVMTCkgewoJCXJldHVybih4bWxTY2hlbWFHZXRDb21wb25lbnRUYXJnZXROcygKCQkgICAgV1hTX0JBU0lDX0NBU1QgV1hTX0FUVFJVU0VfREVDTChpdGVtKSkpOwoJICAgIH0KCSAgICAvKiBUT0RPOiBXaWxsIHJldHVybmluZyBOVUxMIGJyZWFrIHNvbWV0aGluZz8gKi8KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9FWFRSQV9RTkFNRVJFRjoKCSAgICByZXR1cm4gKCgoeG1sU2NoZW1hUU5hbWVSZWZQdHIpIGl0ZW0pLT50YXJnZXROYW1lc3BhY2UpOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfTk9UQVRJT046CgkgICAgcmV0dXJuICgoKHhtbFNjaGVtYU5vdGF0aW9uUHRyKSBpdGVtKS0+dGFyZ2V0TmFtZXNwYWNlKTsKCWRlZmF1bHQ6CgkgICAgLyoKCSAgICAqIE90aGVyIGNvbXBvbmVudHMgY2Fubm90IGhhdmUgbmFtZXMuCgkgICAgKi8KCSAgICBicmVhazsKICAgIH0KICAgIHJldHVybiAoTlVMTCk7Cn0KCnN0YXRpYyBjb25zdCB4bWxDaGFyKgp4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSh4bWxDaGFyICoqYnVmLAoJCQkgICB2b2lkICppdGVtKQp7CiAgICByZXR1cm4gKHhtbFNjaGVtYUZvcm1hdFFOYW1lKGJ1ZiwKCXhtbFNjaGVtYUdldENvbXBvbmVudFRhcmdldE5zKCh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIpIGl0ZW0pLAoJeG1sU2NoZW1hR2V0Q29tcG9uZW50TmFtZSgoeG1sU2NoZW1hQmFzaWNJdGVtUHRyKSBpdGVtKSkpOwp9CgpzdGF0aWMgY29uc3QgeG1sQ2hhcioKeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oeG1sQ2hhciAqKmJ1Ziwgdm9pZCAqaXRlbSkKewogICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCiAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIFdYU19JVEVNX1RZUEVfTkFNRShpdGVtKSk7CiAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICIgJyIpOwogICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCB4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLAoJKHhtbFNjaGVtYUJhc2ljSXRlbVB0cikgaXRlbSkpOwogICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwogICAgRlJFRV9BTkRfTlVMTChzdHIpOwogICAgcmV0dXJuKCpidWYpOwp9CgpzdGF0aWMgY29uc3QgeG1sQ2hhcioKeG1sU2NoZW1hR2V0SURDRGVzaWduYXRpb24oeG1sQ2hhciAqKmJ1ZiwgeG1sU2NoZW1hSURDUHRyIGlkYykKewogICAgcmV0dXJuKHhtbFNjaGVtYUdldENvbXBvbmVudERlc2lnbmF0aW9uKGJ1ZiwgaWRjKSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFXaWxkY2FyZFBDVG9TdHJpbmc6CiAqIEBwYzogdGhlIHR5cGUgb2YgcHJvY2Vzc0NvbnRlbnRzCiAqCiAqIFJldHVybnMgYSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIHR5cGUgb2YKICogcHJvY2Vzc0NvbnRlbnRzLgogKi8Kc3RhdGljIGNvbnN0IHhtbENoYXIgKgp4bWxTY2hlbWFXaWxkY2FyZFBDVG9TdHJpbmcoaW50IHBjKQp7CiAgICBzd2l0Y2ggKHBjKSB7CgljYXNlIFhNTF9TQ0hFTUFTX0FOWV9TS0lQOgoJICAgIHJldHVybiAoQkFEX0NBU1QgInNraXAiKTsKCWNhc2UgWE1MX1NDSEVNQVNfQU5ZX0xBWDoKCSAgICByZXR1cm4gKEJBRF9DQVNUICJsYXgiKTsKCWNhc2UgWE1MX1NDSEVNQVNfQU5ZX1NUUklDVDoKCSAgICByZXR1cm4gKEJBRF9DQVNUICJzdHJpY3QiKTsKCWRlZmF1bHQ6CgkgICAgcmV0dXJuIChCQURfQ0FTVCAiaW52YWxpZCBwcm9jZXNzIGNvbnRlbnRzIik7CiAgICB9Cn0KCi8qKgogKiB4bWxTY2hlbWFHZXRDYW5vblZhbHVlV2h0c3BFeHQ6CiAqIEB2YWw6IHRoZSBwcmVjb21wdXRlZCB2YWx1ZQogKiBAcmV0VmFsdWU6IHRoZSByZXR1cm5lZCB2YWx1ZQogKiBAd3M6IHRoZSB3aGl0ZXNwYWNlIHR5cGUgb2YgdGhlIHZhbHVlCiAqCiAqIEdldCBhIHRoZSBjb25vbmljYWwgcmVwcmVzZW50YXRpb24gb2YgdGhlIHZhbHVlLgogKiBUaGUgY2FsbGVyIGhhcyB0byBmcmVlIHRoZSByZXR1cm5lZCByZXRWYWx1ZS4KICoKICogUmV0dXJucyAwIGlmIHRoZSB2YWx1ZSBjb3VsZCBiZSBidWlsdCBhbmQgLTEgaW4gY2FzZSBvZgogKiAgICAgICAgIEFQSSBlcnJvcnMgb3IgaWYgdGhlIHZhbHVlIHR5cGUgaXMgbm90IHN1cHBvcnRlZCB5ZXQuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUdldENhbm9uVmFsdWVXaHRzcEV4dCh4bWxTY2hlbWFWYWxQdHIgdmFsLAoJCQkgICAgICAgeG1sU2NoZW1hV2hpdGVzcGFjZVZhbHVlVHlwZSB3cywKCQkJICAgICAgIHhtbENoYXIgKipyZXRWYWx1ZSkKewogICAgaW50IGxpc3Q7CiAgICB4bWxTY2hlbWFWYWxUeXBlIHZhbFR5cGU7CiAgICBjb25zdCB4bWxDaGFyICp2YWx1ZSwgKnZhbHVlMiA9IE5VTEw7CiAgICAKCiAgICBpZiAoKHJldFZhbHVlID09IE5VTEwpIHx8ICh2YWwgPT0gTlVMTCkpCglyZXR1cm4gKC0xKTsKICAgIGxpc3QgPSB4bWxTY2hlbWFWYWx1ZUdldE5leHQodmFsKSA/IDEgOiAwOwogICAgKnJldFZhbHVlID0gTlVMTDsKICAgIGRvIHsKCXZhbHVlID0gTlVMTDsJCgl2YWxUeXBlID0geG1sU2NoZW1hR2V0VmFsVHlwZSh2YWwpOyAgICAKCXN3aXRjaCAodmFsVHlwZSkgewkgICAgCgkgICAgY2FzZSBYTUxfU0NIRU1BU19TVFJJTkc6CgkgICAgY2FzZSBYTUxfU0NIRU1BU19OT1JNU1RSSU5HOgoJICAgIGNhc2UgWE1MX1NDSEVNQVNfQU5ZU0lNUExFVFlQRToKCQl2YWx1ZSA9IHhtbFNjaGVtYVZhbHVlR2V0QXNTdHJpbmcodmFsKTsKCQlpZiAodmFsdWUgIT0gTlVMTCkgewoJCSAgICBpZiAod3MgPT0gWE1MX1NDSEVNQV9XSElURVNQQUNFX0NPTExBUFNFKQoJCQl2YWx1ZTIgPSB4bWxTY2hlbWFDb2xsYXBzZVN0cmluZyh2YWx1ZSk7CgkJICAgIGVsc2UgaWYgKHdzID09IFhNTF9TQ0hFTUFfV0hJVEVTUEFDRV9SRVBMQUNFKQoJCQl2YWx1ZTIgPSB4bWxTY2hlbWFXaGl0ZVNwYWNlUmVwbGFjZSh2YWx1ZSk7CgkJICAgIGlmICh2YWx1ZTIgIT0gTlVMTCkKCQkJdmFsdWUgPSB2YWx1ZTI7CgkJfQoJCWJyZWFrOwkgICAKCSAgICBkZWZhdWx0OgoJCWlmICh4bWxTY2hlbWFHZXRDYW5vblZhbHVlKHZhbCwgJnZhbHVlMikgPT0gLTEpIHsKCQkgICAgaWYgKHZhbHVlMiAhPSBOVUxMKQoJCQl4bWxGcmVlKCh4bWxDaGFyICopIHZhbHVlMik7CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJCXZhbHVlID0gdmFsdWUyOwoJfQoJaWYgKCpyZXRWYWx1ZSA9PSBOVUxMKQoJICAgIGlmICh2YWx1ZSA9PSBOVUxMKSB7CgkJaWYgKCEgbGlzdCkKCQkgICAgKnJldFZhbHVlID0geG1sU3RyZHVwKEJBRF9DQVNUICIiKTsKCSAgICB9IGVsc2UKCQkqcmV0VmFsdWUgPSB4bWxTdHJkdXAodmFsdWUpOwoJZWxzZSBpZiAodmFsdWUgIT0gTlVMTCkgewoJICAgIC8qIExpc3QuICovCgkgICAgKnJldFZhbHVlID0geG1sU3RyY2F0KCh4bWxDaGFyICopICpyZXRWYWx1ZSwgQkFEX0NBU1QgIiAiKTsKCSAgICAqcmV0VmFsdWUgPSB4bWxTdHJjYXQoKHhtbENoYXIgKikgKnJldFZhbHVlLCB2YWx1ZSk7Cgl9CglGUkVFX0FORF9OVUxMKHZhbHVlMikKCXZhbCA9IHhtbFNjaGVtYVZhbHVlR2V0TmV4dCh2YWwpOwogICAgfSB3aGlsZSAodmFsICE9IE5VTEwpOwoKICAgIHJldHVybiAoMCk7CmludGVybmFsX2Vycm9yOgogICAgaWYgKCpyZXRWYWx1ZSAhPSBOVUxMKQoJeG1sRnJlZSgoeG1sQ2hhciAqKSAoKnJldFZhbHVlKSk7CiAgICBpZiAodmFsdWUyICE9IE5VTEwpCgl4bWxGcmVlKCh4bWxDaGFyICopIHZhbHVlMik7CiAgICByZXR1cm4gKC0xKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQ6CiAqIEBidWY6IHRoZSBzdHJpbmcgYnVmZmVyCiAqIEBpdGVtRGVzOiB0aGUgZGVzaWduYXRpb24gb2YgdGhlIGl0ZW0KICogQGl0ZW1OYW1lOiB0aGUgbmFtZSBvZiB0aGUgaXRlbQogKiBAaXRlbTogdGhlIGl0ZW0gYXMgYW4gb2JqZWN0IAogKiBAaXRlbU5vZGU6IHRoZSBub2RlIG9mIHRoZSBpdGVtCiAqIEBsb2NhbDogdGhlIGxvY2FsIG5hbWUKICogQHBhcnNpbmc6IGlmIHRoZSBmdW5jdGlvbiBpcyB1c2VkIGR1cmluZyB0aGUgcGFyc2UKICoKICogUmV0dXJucyBhIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBnaXZlbiBpdGVtIHVzZWQKICogZm9yIGVycm9yIHJlcG9ydHMuIAogKgogKiBUaGUgZm9sbG93aW5nIG9yZGVyIGlzIHVzZWQgdG8gYnVpbGQgdGhlIHJlc3VsdGluZyAKICogZGVzaWduYXRpb24gaWYgdGhlIGFyZ3VtZW50cyBhcmUgbm90IE5VTEw6CiAqIDFhLiBJZiBpdGVtRGVzIG5vdCBOVUxMIC0+IGl0ZW1EZXMKICogMWIuIElmIChpdGVtRGVzIG5vdCBOVUxMKSBhbmQgKGl0ZW1OYW1lIG5vdCBOVUxMKQogKiAgICAgLT4gaXRlbURlcyArIGl0ZW1OYW1lCiAqIDIuIElmIHRoZSBwcmVjZWRpbmcgd2FzIE5VTEwgYW5kIChpdGVtIG5vdCBOVUxMKSAtPiBpdGVtCiAqIDMuIElmIHRoZSBwcmVjZWRpbmcgd2FzIE5VTEwgYW5kIChpdGVtTm9kZSBub3QgTlVMTCkgLT4gaXRlbU5vZGUKICogCiAqIElmIHRoZSBpdGVtTm9kZSBpcyBhbiBhdHRyaWJ1dGUgbm9kZSwgdGhlIG5hbWUgb2YgdGhlIGF0dHJpYnV0ZQogKiB3aWxsIGJlIGFwcGVuZGVkIHRvIHRoZSByZXN1bHQuCiAqCiAqIFJldHVybnMgdGhlIGZvcm1hdHRlZCBzdHJpbmcgYW5kIHNldHMgQGJ1ZiB0byB0aGUgcmVzdWx0aW5nIHZhbHVlLgogKi8gIApzdGF0aWMgeG1sQ2hhciogICAKeG1sU2NoZW1hRm9ybWF0SXRlbUZvclJlcG9ydCh4bWxDaGFyICoqYnVmLAkJICAgICAKCQkgICAgIGNvbnN0IHhtbENoYXIgKml0ZW1EZXMsCgkJICAgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSwKCQkgICAgIHhtbE5vZGVQdHIgaXRlbU5vZGUpCnsKICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CiAgICBpbnQgbmFtZWQgPSAxOwoKICAgIGlmICgqYnVmICE9IE5VTEwpIHsKCXhtbEZyZWUoKmJ1Zik7CgkqYnVmID0gTlVMTDsKICAgIH0KICAgICAgICAgICAgCiAgICBpZiAoaXRlbURlcyAhPSBOVUxMKSB7CgkqYnVmID0geG1sU3RyZHVwKGl0ZW1EZXMpOwkKICAgIH0gZWxzZSBpZiAoaXRlbSAhPSBOVUxMKSB7Cglzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0JBU0lDOiB7CgkgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlID0gV1hTX1RZUEVfQ0FTVCBpdGVtOwoKCSAgICBpZiAoV1hTX0lTX0FUT01JQyh0eXBlKSkKCQkqYnVmID0geG1sU3RyZHVwKEJBRF9DQVNUICJhdG9taWMgdHlwZSAneHM6Iik7CgkgICAgZWxzZSBpZiAoV1hTX0lTX0xJU1QodHlwZSkpCgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAibGlzdCB0eXBlICd4czoiKTsKCSAgICBlbHNlIGlmIChXWFNfSVNfVU5JT04odHlwZSkpCgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAidW5pb24gdHlwZSAneHM6Iik7CgkgICAgZWxzZQoJCSpidWYgPSB4bWxTdHJkdXAoQkFEX0NBU1QgInNpbXBsZSB0eXBlICd4czoiKTsKCSAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIHR5cGUtPm5hbWUpOwoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiciKTsKCSAgICB9CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6IHsKCSAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUgPSBXWFNfVFlQRV9DQVNUIGl0ZW07CgoJICAgIGlmICh0eXBlLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfR0xPQkFMKSB7CgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCIiKTsKCSAgICB9IGVsc2UgewoJCSpidWYgPSB4bWxTdHJkdXAoQkFEX0NBU1QgImxvY2FsICIpOwoJICAgIH0KCSAgICBpZiAoV1hTX0lTX0FUT01JQyh0eXBlKSkKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICJhdG9taWMgdHlwZSIpOwoJICAgIGVsc2UgaWYgKFdYU19JU19MSVNUKHR5cGUpKQoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgImxpc3QgdHlwZSIpOwoJICAgIGVsc2UgaWYgKFdYU19JU19VTklPTih0eXBlKSkKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICJ1bmlvbiB0eXBlIik7CgkgICAgZWxzZQoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgInNpbXBsZSB0eXBlIik7CgkgICAgaWYgKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9HTE9CQUwpIHsKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICIgJyIpOwoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgdHlwZS0+bmFtZSk7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwoJICAgIH0KCSAgICB9CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYOiB7CgkgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlID0gV1hTX1RZUEVfQ0FTVCBpdGVtOwoKCSAgICBpZiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0dMT0JBTCkKCQkqYnVmID0geG1sU3RyZHVwKEJBRF9DQVNUICIiKTsKCSAgICBlbHNlCgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAibG9jYWwgIik7CgkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiY29tcGxleCB0eXBlIik7CgkgICAgaWYgKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9HTE9CQUwpIHsKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICIgJyIpOwoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgdHlwZS0+bmFtZSk7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwoJICAgIH0KCSAgICB9CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVfVVNFOiB7CgkJeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIGF1c2U7CgkgICAgCgkJYXVzZSA9IFdYU19BVFRSX1VTRV9DQVNUIGl0ZW07CgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAiYXR0cmlidXRlIHVzZSAiKTsKCQlpZiAoV1hTX0FUVFJVU0VfREVDTChhdXNlKSAhPSBOVUxMKSB7CgkJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiciKTsKCQkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBXWFNfQVRUUlVTRV9ERUNMKGF1c2UpKSk7CgkJICAgIEZSRUVfQU5EX05VTEwoc3RyKQoJCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICInIik7CgkJfSBlbHNlIHsKCQkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiKHVua25vd24pIik7CgkJfQoJICAgIH0KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURTogewoJCXhtbFNjaGVtYUF0dHJpYnV0ZVB0ciBhdHRyOwoJICAgIAoJCWF0dHIgPSAoeG1sU2NoZW1hQXR0cmlidXRlUHRyKSBpdGVtOwoJCSpidWYgPSB4bWxTdHJkdXAoQkFEX0NBU1QgImF0dHJpYnV0ZSBkZWNsLiIpOwoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiAnIik7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCB4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCSAgICBhdHRyLT50YXJnZXROYW1lc3BhY2UsIGF0dHItPm5hbWUpKTsKCQlGUkVFX0FORF9OVUxMKHN0cikKCQkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwoJICAgIH0KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQOgoJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudERlc2lnbmF0aW9uKGJ1ZiwgaXRlbSk7CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOiB7CgkJeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtOwoKCQllbGVtID0gKHhtbFNjaGVtYUVsZW1lbnRQdHIpIGl0ZW07CSAgICAKCQkqYnVmID0geG1sU3RyZHVwKEJBRF9DQVNUICJlbGVtZW50IGRlY2wuIik7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiICciKTsKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkJICAgIGVsZW0tPnRhcmdldE5hbWVzcGFjZSwgZWxlbS0+bmFtZSkpOwoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiciKTsKCSAgICB9CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfVU5JUVVFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWToKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUY6CQkKCSAgICBpZiAoaXRlbS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfSURDX1VOSVFVRSkKCQkqYnVmID0geG1sU3RyZHVwKEJBRF9DQVNUICJ1bmlxdWUgJyIpOwoJICAgIGVsc2UgaWYgKGl0ZW0tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVkpCgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAia2V5ICciKTsKCSAgICBlbHNlCgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAia2V5UmVmICciKTsKCSAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsICgoeG1sU2NoZW1hSURDUHRyKSBpdGVtKS0+bmFtZSk7CgkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZX0FUVFJJQlVURToKCSAgICAqYnVmID0geG1sU3RyZHVwKHhtbFNjaGVtYVdpbGRjYXJkUENUb1N0cmluZygKCQkgICAgKCh4bWxTY2hlbWFXaWxkY2FyZFB0cikgaXRlbSktPnByb2Nlc3NDb250ZW50cykpOwoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiB3aWxkY2FyZCIpOwoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTklOQ0xVU0lWRToKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NSU5FWENMVVNJVkU6CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYSU5DTFVTSVZFOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01BWEVYQ0xVU0lWRToKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9UT1RBTERJR0lUUzoKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9GUkFDVElPTkRJR0lUUzoKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9QQVRURVJOOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0VOVU1FUkFUSU9OOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1dISVRFU1BBQ0U6CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTEVOR1RIOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01BWExFTkdUSDoKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NSU5MRU5HVEg6CgkgICAgKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAiZmFjZXQgJyIpOwoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgeG1sU2NoZW1hRmFjZXRUeXBlVG9TdHJpbmcoaXRlbS0+dHlwZSkpOwoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiciKTsKCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOiB7CgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAibW9kZWwgZ3JvdXAgZGVmLiIpOwoJCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiAnIik7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCB4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBpdGVtKSk7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwoJCUZSRUVfQU5EX05VTEwoc3RyKQoJICAgIH0KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQUxMOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfUEFSVElDTEU6CgkgICAgKmJ1ZiA9IHhtbFN0cmR1cChXWFNfSVRFTV9UWVBFX05BTUUoaXRlbSkpOwoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfTk9UQVRJT046IHsKCQkqYnVmID0geG1sU3RyZHVwKFdYU19JVEVNX1RZUEVfTkFNRShpdGVtKSk7CgkJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiICciKTsKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGl0ZW0pKTsKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICInIik7CgkJRlJFRV9BTkRfTlVMTChzdHIpOwoJICAgIH0KCWRlZmF1bHQ6CgkgICAgbmFtZWQgPSAwOwoJfQogICAgfSBlbHNlIAoJbmFtZWQgPSAwOwoKICAgIGlmICgobmFtZWQgPT0gMCkgJiYgKGl0ZW1Ob2RlICE9IE5VTEwpKSB7Cgl4bWxOb2RlUHRyIGVsZW07CgoJaWYgKGl0ZW1Ob2RlLT50eXBlID09IFhNTF9BVFRSSUJVVEVfTk9ERSkKCSAgICBlbGVtID0gaXRlbU5vZGUtPnBhcmVudDsKCWVsc2UgCgkgICAgZWxlbSA9IGl0ZW1Ob2RlOwoJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAiRWxlbWVudCAnIik7CglpZiAoZWxlbS0+bnMgIT0gTlVMTCkgewoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwKCQl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLCBlbGVtLT5ucy0+aHJlZiwgZWxlbS0+bmFtZSkpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKQoJfSBlbHNlCgkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBlbGVtLT5uYW1lKTsKCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiciKTsKCQogICAgfQogICAgaWYgKChpdGVtTm9kZSAhPSBOVUxMKSAmJiAoaXRlbU5vZGUtPnR5cGUgPT0gWE1MX0FUVFJJQlVURV9OT0RFKSkgewoJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiLCBhdHRyaWJ1dGUgJyIpOwoJaWYgKGl0ZW1Ob2RlLT5ucyAhPSBOVUxMKSB7CgkgICAgKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCB4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCWl0ZW1Ob2RlLT5ucy0+aHJlZiwgaXRlbU5vZGUtPm5hbWUpKTsKCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCX0gZWxzZQoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgaXRlbU5vZGUtPm5hbWUpOwoJKmJ1ZiA9IHhtbFN0cmNhdCgqYnVmLCBCQURfQ0FTVCAiJyIpOwogICAgfQogICAgRlJFRV9BTkRfTlVMTChzdHIpCiAgICAKICAgIHJldHVybiAoKmJ1Zik7Cn0KCi8qKgogKiB4bWxTY2hlbWFGb3JtYXRGYWNldEVudW1TZXQ6CiAqIEBidWY6IHRoZSBzdHJpbmcgYnVmZmVyCiAqIEB0eXBlOiB0aGUgdHlwZSBob2xkaW5nIHRoZSBlbnVtZXJhdGlvbiBmYWNldHMKICoKICogQnVpbGRzIGEgc3RyaW5nIGNvbnNpc3Rpbmcgb2YgYWxsIGVudW1lcmF0aW9uIGVsZW1lbnRzLgogKgogKiBSZXR1cm5zIGEgc3RyaW5nIG9mIGFsbCBlbnVtZXJhdGlvbiBlbGVtZW50cy4KICovCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hRm9ybWF0RmFjZXRFbnVtU2V0KHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkJICAgIHhtbENoYXIgKipidWYsIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgeG1sU2NoZW1hRmFjZXRQdHIgZmFjZXQ7CiAgICB4bWxTY2hlbWFXaGl0ZXNwYWNlVmFsdWVUeXBlIHdzOwogICAgeG1sQ2hhciAqdmFsdWUgPSBOVUxMOwogICAgaW50IHJlczsKCiAgICBpZiAoKmJ1ZiAhPSBOVUxMKQoJeG1sRnJlZSgqYnVmKTsgICAgCiAgICAqYnVmID0gTlVMTDsKCiAgICBkbyB7CgkvKgoJKiBVc2UgdGhlIHdoaXRlc3BhY2UgdHlwZSBvZiB0aGUgYmFzZSB0eXBlLgoJKi8JCgl3cyA9IHhtbFNjaGVtYUdldFdoaXRlU3BhY2VGYWNldFZhbHVlKHR5cGUtPmJhc2VUeXBlKTsKCWZvciAoZmFjZXQgPSB0eXBlLT5mYWNldHM7IGZhY2V0ICE9IE5VTEw7IGZhY2V0ID0gZmFjZXQtPm5leHQpIHsKCSAgICBpZiAoZmFjZXQtPnR5cGUgIT0gWE1MX1NDSEVNQV9GQUNFVF9FTlVNRVJBVElPTikKCQljb250aW51ZTsKCSAgICByZXMgPSB4bWxTY2hlbWFHZXRDYW5vblZhbHVlV2h0c3BFeHQoZmFjZXQtPnZhbCwKCQl3cywgJnZhbHVlKTsKCSAgICBpZiAocmVzID09IC0xKSB7CgkJeG1sU2NoZW1hSW50ZXJuYWxFcnIoYWN0eHQsCgkJICAgICJ4bWxTY2hlbWFGb3JtYXRGYWNldEVudW1TZXQiLAoJCSAgICAiY29tcHV0ZSB0aGUgY2Fub25pY2FsIGxleGljYWwgcmVwcmVzZW50YXRpb24iKTsKCQlpZiAoKmJ1ZiAhPSBOVUxMKQoJCSAgICB4bWxGcmVlKCpidWYpOwoJCSpidWYgPSBOVUxMOwoJCXJldHVybiAoTlVMTCk7CgkgICAgfQoJICAgIGlmICgqYnVmID09IE5VTEwpCgkJKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAiJyIpOwoJICAgIGVsc2UKCQkqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICIsICciKTsKCSAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUIHZhbHVlKTsKCSAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICInIik7CgkgICAgaWYgKHZhbHVlICE9IE5VTEwpIHsKCQl4bWxGcmVlKCh4bWxDaGFyICopdmFsdWUpOwoJCXZhbHVlID0gTlVMTDsKCSAgICB9Cgl9Cgl0eXBlID0gdHlwZS0+YmFzZVR5cGU7CiAgICB9IHdoaWxlICgodHlwZSAhPSBOVUxMKSAmJiAodHlwZS0+dHlwZSAhPSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpKTsKCiAgICByZXR1cm4gKChjb25zdCB4bWxDaGFyICopICpidWYpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQkJCQkJCQkJKgogKiAJCQlFcnJvciBmdW5jdGlvbnMJCQkJICAgICAgICAqCiAqCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKI2lmIDAKc3RhdGljIHZvaWQKeG1sU2NoZW1hRXJyTWVtb3J5KGNvbnN0IGNoYXIgKm1zZykKewogICAgX194bWxTaW1wbGVFcnJvcihYTUxfRlJPTV9TQ0hFTUFTUCwgWE1MX0VSUl9OT19NRU1PUlksIE5VTEwsIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgIG1zZyk7Cn0KI2VuZGlmCgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFQU2ltcGxlRXJyKGNvbnN0IGNoYXIgKm1zZykKewogICAgX194bWxTaW1wbGVFcnJvcihYTUxfRlJPTV9TQ0hFTUFTUCwgWE1MX0VSUl9OT19NRU1PUlksIE5VTEwsIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgIG1zZyk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQRXJyTWVtb3J5OgogKiBAbm9kZTogYSBjb250ZXh0IG5vZGUKICogQGV4dHJhOiAgZXh0cmEgaW5mb3JtYXRpb25zCiAqCiAqIEhhbmRsZSBhbiBvdXQgb2YgbWVtb3J5IGNvbmRpdGlvbgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUEVyck1lbW9yeSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCiAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqZXh0cmEsIHhtbE5vZGVQdHIgbm9kZSkKewogICAgaWYgKGN0eHQgIT0gTlVMTCkKICAgICAgICBjdHh0LT5uYmVycm9ycysrOwogICAgX194bWxTaW1wbGVFcnJvcihYTUxfRlJPTV9TQ0hFTUFTUCwgWE1MX0VSUl9OT19NRU1PUlksIG5vZGUsIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgIGV4dHJhKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBFcnI6CiAqIEBjdHh0OiB0aGUgcGFyc2luZyBjb250ZXh0CiAqIEBub2RlOiB0aGUgY29udGV4dCBub2RlCiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQG1zZzogdGhlIGVycm9yIG1lc3NhZ2UKICogQHN0cjE6IGV4dHJhIGRhdGEKICogQHN0cjI6IGV4dHJhIGRhdGEKICogCiAqIEhhbmRsZSBhIHBhcnNlciBlcnJvcgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUEVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbE5vZGVQdHIgbm9kZSwgaW50IGVycm9yLAogICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm1zZywgY29uc3QgeG1sQ2hhciAqIHN0cjEsIGNvbnN0IHhtbENoYXIgKiBzdHIyKQp7CiAgICB4bWxHZW5lcmljRXJyb3JGdW5jIGNoYW5uZWwgPSBOVUxMOwogICAgeG1sU3RydWN0dXJlZEVycm9yRnVuYyBzY2hhbm5lbCA9IE5VTEw7CiAgICB2b2lkICpkYXRhID0gTlVMTDsKCiAgICBpZiAoY3R4dCAhPSBOVUxMKSB7CiAgICAgICAgY3R4dC0+bmJlcnJvcnMrKzsKCWN0eHQtPmVyciA9IGVycm9yOwogICAgICAgIGNoYW5uZWwgPSBjdHh0LT5lcnJvcjsKICAgICAgICBkYXRhID0gY3R4dC0+ZXJyQ3R4dDsKCXNjaGFubmVsID0gY3R4dC0+c2Vycm9yOwogICAgfQogICAgX194bWxSYWlzZUVycm9yKHNjaGFubmVsLCBjaGFubmVsLCBkYXRhLCBjdHh0LCBub2RlLCBYTUxfRlJPTV9TQ0hFTUFTUCwKICAgICAgICAgICAgICAgICAgICBlcnJvciwgWE1MX0VSUl9FUlJPUiwgTlVMTCwgMCwKICAgICAgICAgICAgICAgICAgICAoY29uc3QgY2hhciAqKSBzdHIxLCAoY29uc3QgY2hhciAqKSBzdHIyLCBOVUxMLCAwLCAwLAogICAgICAgICAgICAgICAgICAgIG1zZywgc3RyMSwgc3RyMik7Cn0KCi8qKgogKiB4bWxTY2hlbWFQRXJyMjoKICogQGN0eHQ6IHRoZSBwYXJzaW5nIGNvbnRleHQKICogQG5vZGU6IHRoZSBjb250ZXh0IG5vZGUKICogQG5vZGU6IHRoZSBjdXJyZW50IGNoaWxkCiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQG1zZzogdGhlIGVycm9yIG1lc3NhZ2UKICogQHN0cjE6IGV4dHJhIGRhdGEKICogQHN0cjI6IGV4dHJhIGRhdGEKICogCiAqIEhhbmRsZSBhIHBhcnNlciBlcnJvcgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUEVycjIoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxOb2RlUHRyIG5vZGUsCiAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgY2hpbGQsIGludCBlcnJvciwKICAgICAgICAgICAgICAgY29uc3QgY2hhciAqbXNnLCBjb25zdCB4bWxDaGFyICogc3RyMSwgY29uc3QgeG1sQ2hhciAqIHN0cjIpCnsKICAgIGlmIChjaGlsZCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYVBFcnIoY3R4dCwgY2hpbGQsIGVycm9yLCBtc2csIHN0cjEsIHN0cjIpOwogICAgZWxzZQogICAgICAgIHhtbFNjaGVtYVBFcnIoY3R4dCwgbm9kZSwgZXJyb3IsIG1zZywgc3RyMSwgc3RyMik7Cn0KCgovKioKICogeG1sU2NoZW1hUEVyckV4dDoKICogQGN0eHQ6IHRoZSBwYXJzaW5nIGNvbnRleHQKICogQG5vZGU6IHRoZSBjb250ZXh0IG5vZGUKICogQGVycm9yOiB0aGUgZXJyb3IgY29kZSAKICogQHN0ckRhdGExOiBleHRyYSBkYXRhCiAqIEBzdHJEYXRhMjogZXh0cmEgZGF0YQogKiBAc3RyRGF0YTM6IGV4dHJhIGRhdGEKICogQG1zZzogdGhlIG1lc3NhZ2UKICogQHN0cjE6ICBleHRyYSBwYXJhbWV0ZXIgZm9yIHRoZSBtZXNzYWdlIGRpc3BsYXkKICogQHN0cjI6ICBleHRyYSBwYXJhbWV0ZXIgZm9yIHRoZSBtZXNzYWdlIGRpc3BsYXkKICogQHN0cjM6ICBleHRyYSBwYXJhbWV0ZXIgZm9yIHRoZSBtZXNzYWdlIGRpc3BsYXkKICogQHN0cjQ6ICBleHRyYSBwYXJhbWV0ZXIgZm9yIHRoZSBtZXNzYWdlIGRpc3BsYXkKICogQHN0cjU6ICBleHRyYSBwYXJhbWV0ZXIgZm9yIHRoZSBtZXNzYWdlIGRpc3BsYXkKICogCiAqIEhhbmRsZSBhIHBhcnNlciBlcnJvcgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUEVyckV4dCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbE5vZGVQdHIgbm9kZSwgaW50IGVycm9yLAoJCWNvbnN0IHhtbENoYXIgKiBzdHJEYXRhMSwgY29uc3QgeG1sQ2hhciAqIHN0ckRhdGEyLCAKCQljb25zdCB4bWxDaGFyICogc3RyRGF0YTMsIGNvbnN0IGNoYXIgKm1zZywgY29uc3QgeG1sQ2hhciAqIHN0cjEsIAoJCWNvbnN0IHhtbENoYXIgKiBzdHIyLCBjb25zdCB4bWxDaGFyICogc3RyMywgY29uc3QgeG1sQ2hhciAqIHN0cjQsCgkJY29uc3QgeG1sQ2hhciAqIHN0cjUpCnsKCiAgICB4bWxHZW5lcmljRXJyb3JGdW5jIGNoYW5uZWwgPSBOVUxMOwogICAgeG1sU3RydWN0dXJlZEVycm9yRnVuYyBzY2hhbm5lbCA9IE5VTEw7CiAgICB2b2lkICpkYXRhID0gTlVMTDsKCiAgICBpZiAoY3R4dCAhPSBOVUxMKSB7CiAgICAgICAgY3R4dC0+bmJlcnJvcnMrKzsKCWN0eHQtPmVyciA9IGVycm9yOwogICAgICAgIGNoYW5uZWwgPSBjdHh0LT5lcnJvcjsKICAgICAgICBkYXRhID0gY3R4dC0+ZXJyQ3R4dDsKCXNjaGFubmVsID0gY3R4dC0+c2Vycm9yOwogICAgfQogICAgX194bWxSYWlzZUVycm9yKHNjaGFubmVsLCBjaGFubmVsLCBkYXRhLCBjdHh0LCBub2RlLCBYTUxfRlJPTV9TQ0hFTUFTUCwKICAgICAgICAgICAgICAgICAgICBlcnJvciwgWE1MX0VSUl9FUlJPUiwgTlVMTCwgMCwKICAgICAgICAgICAgICAgICAgICAoY29uc3QgY2hhciAqKSBzdHJEYXRhMSwgKGNvbnN0IGNoYXIgKikgc3RyRGF0YTIsIAoJCSAgICAoY29uc3QgY2hhciAqKSBzdHJEYXRhMywgMCwgMCwgbXNnLCBzdHIxLCBzdHIyLCAKCQkgICAgc3RyMywgc3RyNCwgc3RyNSk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCQkJCQkJCQkqCiAqIAkJCUFsbHJvdW5kIGVycm9yIGZ1bmN0aW9ucwkJCSoKICoJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgovKioKICogeG1sU2NoZW1hVlR5cGVFcnJNZW1vcnk6CiAqIEBub2RlOiBhIGNvbnRleHQgbm9kZQogKiBAZXh0cmE6ICBleHRyYSBpbmZvcm1hdGlvbnMKICoKICogSGFuZGxlIGFuIG91dCBvZiBtZW1vcnkgY29uZGl0aW9uCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFWRXJyTWVtb3J5KHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKmV4dHJhLCB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIGlmIChjdHh0ICE9IE5VTEwpIHsKICAgICAgICBjdHh0LT5uYmVycm9ycysrOwogICAgICAgIGN0eHQtPmVyciA9IFhNTF9TQ0hFTUFWX0lOVEVSTkFMOwogICAgfQogICAgX194bWxTaW1wbGVFcnJvcihYTUxfRlJPTV9TQ0hFTUFTViwgWE1MX0VSUl9OT19NRU1PUlksIG5vZGUsIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgIGV4dHJhKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hUFNpbXBsZUludGVybmFsRXJyKHhtbE5vZGVQdHIgbm9kZSwKCQkJICAgIGNvbnN0IGNoYXIgKm1zZywgY29uc3QgeG1sQ2hhciAqc3RyKQp7CiAgICAgX194bWxTaW1wbGVFcnJvcihYTUxfRlJPTV9TQ0hFTUFTUCwgWE1MX1NDSEVNQVBfSU5URVJOQUwsIG5vZGUsCgkgbXNnLCAoY29uc3QgY2hhciAqKSBzdHIpOwp9CgojZGVmaW5lIFdYU19FUlJPUl9UWVBFX0VSUk9SIDEKI2RlZmluZSBXWFNfRVJST1JfVFlQRV9XQVJOSU5HIDIKLyoqCiAqIHhtbFNjaGVtYUVycjM6CiAqIEBjdHh0OiB0aGUgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBub2RlOiB0aGUgY29udGV4dCBub2RlCiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQG1zZzogdGhlIGVycm9yIG1lc3NhZ2UKICogQHN0cjE6IGV4dHJhIGRhdGEKICogQHN0cjI6IGV4dHJhIGRhdGEKICogQHN0cjM6IGV4dHJhIGRhdGEKICogCiAqIEhhbmRsZSBhIHZhbGlkYXRpb24gZXJyb3IKICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUVycjRMaW5lKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBjdHh0LAoJCSAgeG1sRXJyb3JMZXZlbCBlcnJvckxldmVsLAoJCSAgaW50IGVycm9yLCB4bWxOb2RlUHRyIG5vZGUsIGludCBsaW5lLCBjb25zdCBjaGFyICptc2csCgkJICBjb25zdCB4bWxDaGFyICpzdHIxLCBjb25zdCB4bWxDaGFyICpzdHIyLAoJCSAgY29uc3QgeG1sQ2hhciAqc3RyMywgY29uc3QgeG1sQ2hhciAqc3RyNCkKewogICAgeG1sU3RydWN0dXJlZEVycm9yRnVuYyBzY2hhbm5lbCA9IE5VTEw7CiAgICB4bWxHZW5lcmljRXJyb3JGdW5jIGNoYW5uZWwgPSBOVUxMOwogICAgdm9pZCAqZGF0YSA9IE5VTEw7ICAgIAogICAgCiAgICBpZiAoY3R4dCAhPSBOVUxMKSB7CglpZiAoY3R4dC0+dHlwZSA9PSBYTUxfU0NIRU1BX0NUWFRfVkFMSURBVE9SKSB7CgkgICAgeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0ID0gKHhtbFNjaGVtYVZhbGlkQ3R4dFB0cikgY3R4dDsKCSAgICBjb25zdCBjaGFyICpmaWxlID0gTlVMTDsKCSAgICBpZiAoZXJyb3JMZXZlbCAhPSBYTUxfRVJSX1dBUk5JTkcpIHsKCQl2Y3R4dC0+bmJlcnJvcnMrKzsKCQl2Y3R4dC0+ZXJyID0gZXJyb3I7CgkJY2hhbm5lbCA9IHZjdHh0LT5lcnJvcjsJCQoJICAgIH0gZWxzZSB7CgkJY2hhbm5lbCA9IHZjdHh0LT53YXJuaW5nOwoJICAgIH0KCSAgICBzY2hhbm5lbCA9IHZjdHh0LT5zZXJyb3I7CgkgICAgZGF0YSA9IHZjdHh0LT5lcnJDdHh0OwoKCSAgICAvKgoJICAgICogRXJyb3Igbm9kZS4gSWYgd2Ugc3BlY2lmeSBhIGxpbmUgbnVtYmVyLCB0aGVuCgkgICAgKiBkbyBub3QgY2hhbm5lbCBhbnkgbm9kZSB0byB0aGUgZXJyb3IgZnVuY3Rpb24uCgkgICAgKi8KCSAgICBpZiAobGluZSA9PSAwKSB7CgkJaWYgKChub2RlID09IE5VTEwpICYmCgkJICAgICh2Y3R4dC0+ZGVwdGggPj0gMCkgJiYKCQkgICAgKHZjdHh0LT5pbm9kZSAhPSBOVUxMKSkgewoJCSAgICBub2RlID0gdmN0eHQtPmlub2RlLT5ub2RlOwoJCX0KCQkvKgoJCSogR2V0IGZpbGVuYW1lIGFuZCBsaW5lIGlmIG5vIG5vZGUtdHJlZS4KCQkqLwoJCWlmICgobm9kZSA9PSBOVUxMKSAmJgoJCSAgICAodmN0eHQtPnBhcnNlckN0eHQgIT0gTlVMTCkgJiYKCQkgICAgKHZjdHh0LT5wYXJzZXJDdHh0LT5pbnB1dCAhPSBOVUxMKSkgewoJCSAgICBmaWxlID0gdmN0eHQtPnBhcnNlckN0eHQtPmlucHV0LT5maWxlbmFtZTsKCQkgICAgbGluZSA9IHZjdHh0LT5wYXJzZXJDdHh0LT5pbnB1dC0+bGluZTsKCQl9CgkgICAgfSBlbHNlIHsKCQkvKgoJCSogT3ZlcnJpZGUgdGhlIGdpdmVuIG5vZGUncyAoaWYgYW55KSBwb3NpdGlvbgoJCSogYW5kIGNoYW5uZWwgb25seSB0aGUgZ2l2ZW4gbGluZSBudW1iZXIuCgkJKi8KCQlub2RlID0gTlVMTDsKCQkvKgoJCSogR2V0IGZpbGVuYW1lLgoJCSovCgkJaWYgKHZjdHh0LT5kb2MgIT0gTlVMTCkKCQkgICAgZmlsZSA9IChjb25zdCBjaGFyICopIHZjdHh0LT5kb2MtPlVSTDsKCQllbHNlIGlmICgodmN0eHQtPnBhcnNlckN0eHQgIT0gTlVMTCkgJiYKCQkgICAgKHZjdHh0LT5wYXJzZXJDdHh0LT5pbnB1dCAhPSBOVUxMKSkKCQkgICAgZmlsZSA9IHZjdHh0LT5wYXJzZXJDdHh0LT5pbnB1dC0+ZmlsZW5hbWU7CgkgICAgfQkgICAgICAgCgkgICAgX194bWxSYWlzZUVycm9yKHNjaGFubmVsLCBjaGFubmVsLCBkYXRhLCBjdHh0LAoJCW5vZGUsIFhNTF9GUk9NX1NDSEVNQVNWLAoJCWVycm9yLCBlcnJvckxldmVsLCBmaWxlLCBsaW5lLAoJCShjb25zdCBjaGFyICopIHN0cjEsIChjb25zdCBjaGFyICopIHN0cjIsCgkJKGNvbnN0IGNoYXIgKikgc3RyMywgMCwgMCwgbXNnLCBzdHIxLCBzdHIyLCBzdHIzLCBzdHI0KTsKCgl9IGVsc2UgaWYgKGN0eHQtPnR5cGUgPT0gWE1MX1NDSEVNQV9DVFhUX1BBUlNFUikgewoJICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQgPSAoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0cikgY3R4dDsKCSAgICBpZiAoZXJyb3JMZXZlbCAhPSBYTUxfRVJSX1dBUk5JTkcpIHsKCQlwY3R4dC0+bmJlcnJvcnMrKzsKCQlwY3R4dC0+ZXJyID0gZXJyb3I7CgkJY2hhbm5lbCA9IHBjdHh0LT5lcnJvcjsJCQoJICAgIH0gZWxzZSB7CgkJY2hhbm5lbCA9IHBjdHh0LT53YXJuaW5nOwoJICAgIH0KCSAgICBzY2hhbm5lbCA9IHBjdHh0LT5zZXJyb3I7CgkgICAgZGF0YSA9IHBjdHh0LT5lcnJDdHh0OwoJICAgIF9feG1sUmFpc2VFcnJvcihzY2hhbm5lbCwgY2hhbm5lbCwgZGF0YSwgY3R4dCwKCQlub2RlLCBYTUxfRlJPTV9TQ0hFTUFTUCwgZXJyb3IsCgkJZXJyb3JMZXZlbCwgTlVMTCwgMCwKCQkoY29uc3QgY2hhciAqKSBzdHIxLCAoY29uc3QgY2hhciAqKSBzdHIyLAoJCShjb25zdCBjaGFyICopIHN0cjMsIDAsIDAsIG1zZywgc3RyMSwgc3RyMiwgc3RyMywgc3RyNCk7Cgl9IGVsc2UgewoJICAgIFRPRE8KCX0KICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUVycjM6CiAqIEBjdHh0OiB0aGUgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBub2RlOiB0aGUgY29udGV4dCBub2RlCiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQG1zZzogdGhlIGVycm9yIG1lc3NhZ2UKICogQHN0cjE6IGV4dHJhIGRhdGEKICogQHN0cjI6IGV4dHJhIGRhdGEKICogQHN0cjM6IGV4dHJhIGRhdGEKICogCiAqIEhhbmRsZSBhIHZhbGlkYXRpb24gZXJyb3IKICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUVycjMoeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LCAgCgkgICAgICBpbnQgZXJyb3IsIHhtbE5vZGVQdHIgbm9kZSwgY29uc3QgY2hhciAqbXNnLAoJICAgICAgY29uc3QgeG1sQ2hhciAqc3RyMSwgY29uc3QgeG1sQ2hhciAqc3RyMiwgY29uc3QgeG1sQ2hhciAqc3RyMykKewogICAgeG1sU2NoZW1hRXJyNExpbmUoYWN0eHQsIFhNTF9FUlJfRVJST1IsIGVycm9yLCBub2RlLCAwLAoJbXNnLCBzdHIxLCBzdHIyLCBzdHIzLCBOVUxMKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hRXJyNCh4bWxTY2hlbWFBYnN0cmFjdEN0eHRQdHIgYWN0eHQsICAKCSAgICAgIGludCBlcnJvciwgeG1sTm9kZVB0ciBub2RlLCBjb25zdCBjaGFyICptc2csCgkgICAgICBjb25zdCB4bWxDaGFyICpzdHIxLCBjb25zdCB4bWxDaGFyICpzdHIyLAoJICAgICAgY29uc3QgeG1sQ2hhciAqc3RyMywgY29uc3QgeG1sQ2hhciAqc3RyNCkKewogICAgeG1sU2NoZW1hRXJyNExpbmUoYWN0eHQsIFhNTF9FUlJfRVJST1IsIGVycm9yLCBub2RlLCAwLAoJbXNnLCBzdHIxLCBzdHIyLCBzdHIzLCBzdHI0KTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hRXJyKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCSAgICAgaW50IGVycm9yLCB4bWxOb2RlUHRyIG5vZGUsIGNvbnN0IGNoYXIgKm1zZywKCSAgICAgY29uc3QgeG1sQ2hhciAqc3RyMSwgY29uc3QgeG1sQ2hhciAqc3RyMikKewogICAgeG1sU2NoZW1hRXJyNChhY3R4dCwgZXJyb3IsIG5vZGUsIG1zZywgc3RyMSwgc3RyMiwgTlVMTCwgTlVMTCk7Cn0KCnN0YXRpYyB4bWxDaGFyICoKeG1sU2NoZW1hRm9ybWF0Tm9kZUZvckVycm9yKHhtbENoYXIgKiogbXNnLAoJCQkgICAgeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCQkgICAgeG1sTm9kZVB0ciBub2RlKQp7CiAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoKICAgICptc2cgPSBOVUxMOwogICAgaWYgKChub2RlICE9IE5VTEwpICYmCgkobm9kZS0+dHlwZSAhPSBYTUxfRUxFTUVOVF9OT0RFKSAmJgoJKG5vZGUtPnR5cGUgIT0gWE1MX0FUVFJJQlVURV9OT0RFKSkKICAgIHsKCS8qIAoJKiBEb24ndCB0cnkgdG8gZm9ybWF0IG90aGVyIG5vZGVzIHRoYW4gZWxlbWVudCBhbmQKCSogYXR0cmlidXRlIG5vZGVzLgoJKiBQbGF5IHNhdmUgYW5kIHJldHVybiBhbiBlbXB0eSBzdHJpbmcuCgkqLwoJKm1zZyA9IHhtbFN0cmR1cChCQURfQ0FTVCAiIik7CglyZXR1cm4oKm1zZyk7CiAgICB9CiAgICBpZiAobm9kZSAhPSBOVUxMKSB7CgkvKgoJKiBXb3JrIG9uIHRyZWUgbm9kZXMuCgkqLwoJaWYgKG5vZGUtPnR5cGUgPT0gWE1MX0FUVFJJQlVURV9OT0RFKSB7CgkgICAgeG1sTm9kZVB0ciBlbGVtID0gbm9kZS0+cGFyZW50OwoJICAgIAoJICAgICptc2cgPSB4bWxTdHJkdXAoQkFEX0NBU1QgIkVsZW1lbnQgJyIpOwoJICAgIGlmIChlbGVtLT5ucyAhPSBOVUxMKQoJCSptc2cgPSB4bWxTdHJjYXQoKm1zZywgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwKCQkgICAgZWxlbS0+bnMtPmhyZWYsIGVsZW0tPm5hbWUpKTsKCSAgICBlbHNlCgkJKm1zZyA9IHhtbFN0cmNhdCgqbXNnLCB4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCSAgICBOVUxMLCBlbGVtLT5uYW1lKSk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHIpOwoJICAgICptc2cgPSB4bWxTdHJjYXQoKm1zZywgQkFEX0NBU1QgIicsICIpOwoJICAgICptc2cgPSB4bWxTdHJjYXQoKm1zZywgQkFEX0NBU1QgImF0dHJpYnV0ZSAnIik7CSAgICAKCX0gZWxzZSB7CgkgICAgKm1zZyA9IHhtbFN0cmR1cChCQURfQ0FTVCAiRWxlbWVudCAnIik7Cgl9CglpZiAobm9kZS0+bnMgIT0gTlVMTCkKCSAgICAqbXNnID0geG1sU3RyY2F0KCptc2csIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkgICAgbm9kZS0+bnMtPmhyZWYsIG5vZGUtPm5hbWUpKTsKCWVsc2UKCSAgICAqbXNnID0geG1sU3RyY2F0KCptc2csIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkgICAgTlVMTCwgbm9kZS0+bmFtZSkpOwoJRlJFRV9BTkRfTlVMTChzdHIpOwoJKm1zZyA9IHhtbFN0cmNhdCgqbXNnLCBCQURfQ0FTVCAiJzogIik7CiAgICB9IGVsc2UgaWYgKGFjdHh0LT50eXBlID09IFhNTF9TQ0hFTUFfQ1RYVF9WQUxJREFUT1IpIHsKCXhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCA9ICh4bWxTY2hlbWFWYWxpZEN0eHRQdHIpIGFjdHh0OwoJLyoKCSogV29yayBvbiBub2RlIGluZm9zLgoJKi8JCglpZiAodmN0eHQtPmlub2RlLT5ub2RlVHlwZSA9PSBYTUxfQVRUUklCVVRFX05PREUpIHsKCSAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBpZWxlbSA9CgkJdmN0eHQtPmVsZW1JbmZvc1t2Y3R4dC0+ZGVwdGhdOwoKCSAgICAqbXNnID0geG1sU3RyZHVwKEJBRF9DQVNUICJFbGVtZW50ICciKTsKCSAgICAqbXNnID0geG1sU3RyY2F0KCptc2csIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkJaWVsZW0tPm5zTmFtZSwgaWVsZW0tPmxvY2FsTmFtZSkpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKTsKCSAgICAqbXNnID0geG1sU3RyY2F0KCptc2csIEJBRF9DQVNUICInLCAiKTsKCSAgICAqbXNnID0geG1sU3RyY2F0KCptc2csIEJBRF9DQVNUICJhdHRyaWJ1dGUgJyIpOwkgICAgCgl9IGVsc2UgewoJICAgICptc2cgPSB4bWxTdHJkdXAoQkFEX0NBU1QgIkVsZW1lbnQgJyIpOwoJfQoJKm1zZyA9IHhtbFN0cmNhdCgqbXNnLCB4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJICAgIHZjdHh0LT5pbm9kZS0+bnNOYW1lLCB2Y3R4dC0+aW5vZGUtPmxvY2FsTmFtZSkpOwoJRlJFRV9BTkRfTlVMTChzdHIpOwoJKm1zZyA9IHhtbFN0cmNhdCgqbXNnLCBCQURfQ0FTVCAiJzogIik7CiAgICB9IGVsc2UgaWYgKGFjdHh0LT50eXBlID09IFhNTF9TQ0hFTUFfQ1RYVF9QQVJTRVIpIHsKCS8qIAoJKiBIbW0sIG5vIG5vZGUgd2hpbGUgcGFyc2luZz8KCSogUmV0dXJuIGFuIGVtcHR5IHN0cmluZywgaW4gY2FzZSBOVUxMIHdpbGwgYnJlYWsgc29tZXRoaW5nLgoJKi8KCSptc2cgPSB4bWxTdHJkdXAoQkFEX0NBU1QgIiIpOwogICAgfSBlbHNlIHsKCVRPRE8KCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICAvKgogICAgKiBWQUwgVE9ETzogVGhlIG91dHB1dCBvZiB0aGUgZ2l2ZW4gc2NoZW1hIGNvbXBvbmVudCBpcyBjdXJyZW50bHkKICAgICogZGlzYWJsZWQuCiAgICAqLwojaWYgMAogICAgaWYgKCh0eXBlICE9IE5VTEwpICYmICh4bWxTY2hlbWFJc0dsb2JhbEl0ZW0odHlwZSkpKSB7CgkqbXNnID0geG1sU3RyY2F0KCptc2csIEJBRF9DQVNUICIgWyIpOwoJKm1zZyA9IHhtbFN0cmNhdCgqbXNnLCB4bWxTY2hlbWFGb3JtYXRJdGVtRm9yUmVwb3J0KCZzdHIsCgkgICAgTlVMTCwgdHlwZSwgTlVMTCwgMCkpOwoJRlJFRV9BTkRfTlVMTChzdHIpCgkqbXNnID0geG1sU3RyY2F0KCptc2csIEJBRF9DQVNUICJdIik7CiAgICB9CiNlbmRpZgogICAgcmV0dXJuICgqbXNnKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hSW50ZXJuYWxFcnIyKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkgICAgIGNvbnN0IGNoYXIgKmZ1bmNOYW1lLAoJCSAgICAgY29uc3QgY2hhciAqbWVzc2FnZSwKCQkgICAgIGNvbnN0IHhtbENoYXIgKnN0cjEsCgkJICAgICBjb25zdCB4bWxDaGFyICpzdHIyKQp7CiAgICB4bWxDaGFyICptc2cgPSBOVUxMOwoKICAgIG1zZyA9IHhtbFN0cmR1cChCQURfQ0FTVCAiSW50ZXJuYWwgZXJyb3I6ICIpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgZnVuY05hbWUpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIiwgIik7ICAgIAogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgbWVzc2FnZSk7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiLlxuIik7CgogICAgaWYgKGFjdHh0LT50eXBlID09IFhNTF9TQ0hFTUFfQ1RYVF9WQUxJREFUT1IpCgl4bWxTY2hlbWFFcnIoYWN0eHQsIFhNTF9TQ0hFTUFWX0lOVEVSTkFMLCBOVUxMLAoJICAgIChjb25zdCBjaGFyICopIG1zZywgc3RyMSwgc3RyMik7CgogICAgZWxzZSBpZiAoYWN0eHQtPnR5cGUgPT0gWE1MX1NDSEVNQV9DVFhUX1BBUlNFUikJCgl4bWxTY2hlbWFFcnIoYWN0eHQsIFhNTF9TQ0hFTUFQX0lOVEVSTkFMLCBOVUxMLAoJICAgIChjb25zdCBjaGFyICopIG1zZywgc3RyMSwgc3RyMik7CgogICAgRlJFRV9BTkRfTlVMTChtc2cpCn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUludGVybmFsRXJyKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkgICAgIGNvbnN0IGNoYXIgKmZ1bmNOYW1lLAoJCSAgICAgY29uc3QgY2hhciAqbWVzc2FnZSkKewogICAgeG1sU2NoZW1hSW50ZXJuYWxFcnIyKGFjdHh0LCBmdW5jTmFtZSwgbWVzc2FnZSwgTlVMTCwgTlVMTCk7Cn0KCiNpZiAwCnN0YXRpYyB2b2lkCnhtbFNjaGVtYVBJbnRlcm5hbEVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCSAgICAgY29uc3QgY2hhciAqZnVuY05hbWUsCgkJICAgICBjb25zdCBjaGFyICptZXNzYWdlLAoJCSAgICAgY29uc3QgeG1sQ2hhciAqc3RyMSwKCQkgICAgIGNvbnN0IHhtbENoYXIgKnN0cjIpCnsKICAgIHhtbFNjaGVtYUludGVybmFsRXJyMihBQ1RYVF9DQVNUIHBjdHh0LCBmdW5jTmFtZSwgbWVzc2FnZSwKCXN0cjEsIHN0cjIpOwp9CiNlbmRpZgoKc3RhdGljIHZvaWQKeG1sU2NoZW1hQ3VzdG9tRXJyNCh4bWxTY2hlbWFBYnN0cmFjdEN0eHRQdHIgYWN0eHQsCgkJICAgeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCSAgIHhtbE5vZGVQdHIgbm9kZSwKCQkgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSwKCQkgICBjb25zdCBjaGFyICptZXNzYWdlLAoJCSAgIGNvbnN0IHhtbENoYXIgKnN0cjEsIGNvbnN0IHhtbENoYXIgKnN0cjIsCgkJICAgY29uc3QgeG1sQ2hhciAqc3RyMywgY29uc3QgeG1sQ2hhciAqc3RyNCkKewogICAgeG1sQ2hhciAqbXNnID0gTlVMTDsKCiAgICBpZiAoKG5vZGUgPT0gTlVMTCkgJiYgKGl0ZW0gIT0gTlVMTCkgJiYKCShhY3R4dC0+dHlwZSA9PSBYTUxfU0NIRU1BX0NUWFRfUEFSU0VSKSkgewoJbm9kZSA9IFdYU19JVEVNX05PREUoaXRlbSk7Cgl4bWxTY2hlbWFGb3JtYXRJdGVtRm9yUmVwb3J0KCZtc2csIE5VTEwsIGl0ZW0sIE5VTEwpOwoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIjogIik7CiAgICB9IGVsc2UKCXhtbFNjaGVtYUZvcm1hdE5vZGVGb3JFcnJvcigmbXNnLCBhY3R4dCwgbm9kZSk7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCAoY29uc3QgeG1sQ2hhciAqKSBtZXNzYWdlKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICIuXG4iKTsgICAKICAgIHhtbFNjaGVtYUVycjQoYWN0eHQsIGVycm9yLCBub2RlLAoJKGNvbnN0IGNoYXIgKikgbXNnLCBzdHIxLCBzdHIyLCBzdHIzLCBzdHI0KTsKICAgIEZSRUVfQU5EX05VTEwobXNnKQp9CgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDdXN0b21FcnIoeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCSAgIHhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkgICB4bWxOb2RlUHRyIG5vZGUsCgkJICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIGl0ZW0sCgkJICAgY29uc3QgY2hhciAqbWVzc2FnZSwKCQkgICBjb25zdCB4bWxDaGFyICpzdHIxLAoJCSAgIGNvbnN0IHhtbENoYXIgKnN0cjIpCnsKICAgIHhtbFNjaGVtYUN1c3RvbUVycjQoYWN0eHQsIGVycm9yLCBub2RlLCBpdGVtLAoJbWVzc2FnZSwgc3RyMSwgc3RyMiwgTlVMTCwgTlVMTCk7ICAgIAp9CgoKCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUN1c3RvbVdhcm5pbmcoeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCSAgIHhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkgICB4bWxOb2RlUHRyIG5vZGUsCgkJICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlIEFUVFJJQlVURV9VTlVTRUQsCgkJICAgY29uc3QgY2hhciAqbWVzc2FnZSwKCQkgICBjb25zdCB4bWxDaGFyICpzdHIxLAoJCSAgIGNvbnN0IHhtbENoYXIgKnN0cjIsCgkJICAgY29uc3QgeG1sQ2hhciAqc3RyMykKewogICAgeG1sQ2hhciAqbXNnID0gTlVMTDsKCiAgICB4bWxTY2hlbWFGb3JtYXROb2RlRm9yRXJyb3IoJm1zZywgYWN0eHQsIG5vZGUpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgKGNvbnN0IHhtbENoYXIgKikgbWVzc2FnZSk7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiLlxuIik7IAogICAgCiAgICAvKiBVUkdFTlQgVE9ETzogU2V0IHRoZSBlcnJvciBjb2RlIHRvIHNvbWV0aGluZyBzYW5lLiAqLwogICAgeG1sU2NoZW1hRXJyNExpbmUoYWN0eHQsIFhNTF9FUlJfV0FSTklORywgZXJyb3IsIG5vZGUsIDAsCgkoY29uc3QgY2hhciAqKSBtc2csIHN0cjEsIHN0cjIsIHN0cjMsIE5VTEwpOwoKICAgIEZSRUVfQU5EX05VTEwobXNnKQp9CgoKCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUtleXJlZkVycih4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJICAgeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCSAgIHhtbFNjaGVtYVBTVklJRENOb2RlUHRyIGlkY05vZGUsCgkJICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlIEFUVFJJQlVURV9VTlVTRUQsCgkJICAgY29uc3QgY2hhciAqbWVzc2FnZSwKCQkgICBjb25zdCB4bWxDaGFyICpzdHIxLAoJCSAgIGNvbnN0IHhtbENoYXIgKnN0cjIpCnsKICAgIHhtbENoYXIgKm1zZyA9IE5VTEwsICpxbmFtZSA9IE5VTEw7CiAgICAKICAgIG1zZyA9IHhtbFN0cmR1cChCQURfQ0FTVCAiRWxlbWVudCAnJXMnOiAiKTsgICAgICAgIAogICAgbXNnID0geG1sU3RyY2F0KG1zZywgKGNvbnN0IHhtbENoYXIgKikgbWVzc2FnZSk7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiLlxuIik7CiAgICB4bWxTY2hlbWFFcnI0TGluZShBQ1RYVF9DQVNUIHZjdHh0LCBYTUxfRVJSX0VSUk9SLAoJZXJyb3IsIE5VTEwsIGlkY05vZGUtPm5vZGVMaW5lLCAoY29uc3QgY2hhciAqKSBtc2csCgl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmcW5hbWUsCgkgICAgdmN0eHQtPm5vZGVRTmFtZXMtPml0ZW1zW2lkY05vZGUtPm5vZGVRTmFtZUlEICsxXSwKCSAgICB2Y3R4dC0+bm9kZVFOYW1lcy0+aXRlbXNbaWRjTm9kZS0+bm9kZVFOYW1lSURdKSwgCglzdHIxLCBzdHIyLCBOVUxMKTsKICAgIEZSRUVfQU5EX05VTEwocW5hbWUpOwogICAgRlJFRV9BTkRfTlVMTChtc2cpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYUV2YWxFcnJvck5vZGVUeXBlKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkJICAgeG1sTm9kZVB0ciBub2RlKQp7CiAgICBpZiAobm9kZSAhPSBOVUxMKQoJcmV0dXJuIChub2RlLT50eXBlKTsKICAgIGlmICgoYWN0eHQtPnR5cGUgPT0gWE1MX1NDSEVNQV9DVFhUX1ZBTElEQVRPUikgJiYKCSgoKHhtbFNjaGVtYVZhbGlkQ3R4dFB0cikgYWN0eHQpLT5pbm9kZSAhPSBOVUxMKSkKCXJldHVybiAoICgoeG1sU2NoZW1hVmFsaWRDdHh0UHRyKSBhY3R4dCktPmlub2RlLT5ub2RlVHlwZSk7CiAgICByZXR1cm4gKC0xKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFJc0dsb2JhbEl0ZW0oeG1sU2NoZW1hVHlwZVB0ciBpdGVtKQp7CiAgICBzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVg6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkgICAgaWYgKGl0ZW0tPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9HTE9CQUwpCgkJcmV0dXJuKDEpOwoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkgICAgcmV0dXJuICgxKTsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQ6CgkgICAgaWYgKCAoKHhtbFNjaGVtYUVsZW1lbnRQdHIpIGl0ZW0pLT5mbGFncyAmCgkJWE1MX1NDSEVNQVNfRUxFTV9HTE9CQUwpCgkJcmV0dXJuKDEpOwoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFOgoJICAgIGlmICggKCh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIpIGl0ZW0pLT5mbGFncyAmCgkJWE1MX1NDSEVNQVNfQVRUUl9HTE9CQUwpCgkJcmV0dXJuKDEpOwoJICAgIGJyZWFrOwoJLyogTm90ZSB0aGF0IGF0dHJpYnV0ZSBncm91cHMgYXJlIGFsd2F5cyBnbG9iYWwuICovCglkZWZhdWx0OgoJICAgIHJldHVybigxKTsKICAgIH0KICAgIHJldHVybiAoMCk7Cn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYVNpbXBsZVR5cGVFcnIoeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCSAgICAgICB4bWxQYXJzZXJFcnJvcnMgZXJyb3IsCgkJICAgICAgIHhtbE5vZGVQdHIgbm9kZSwKCQkgICAgICAgY29uc3QgeG1sQ2hhciAqdmFsdWUsCgkJICAgICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKCQkgICAgICAgaW50IGRpc3BsYXlWYWx1ZSkKewogICAgeG1sQ2hhciAqbXNnID0gTlVMTDsKCiAgICB4bWxTY2hlbWFGb3JtYXROb2RlRm9yRXJyb3IoJm1zZywgYWN0eHQsIG5vZGUpOwoKICAgIGlmIChkaXNwbGF5VmFsdWUgfHwgKHhtbFNjaGVtYUV2YWxFcnJvck5vZGVUeXBlKGFjdHh0LCBub2RlKSA9PQoJICAgIFhNTF9BVFRSSUJVVEVfTk9ERSkpCgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiJyVzJyBpcyBub3QgYSB2YWxpZCB2YWx1ZSBvZiAiKTsKICAgIGVsc2UKCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgY2hhcmFjdGVyIGNvbnRlbnQgaXMgbm90IGEgdmFsaWQgIgoJICAgICJ2YWx1ZSBvZiAiKTsKCiAgICBpZiAoISB4bWxTY2hlbWFJc0dsb2JhbEl0ZW0odHlwZSkpCgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAidGhlIGxvY2FsICIpOwogICAgZWxzZQoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgInRoZSAiKTsKCiAgICBpZiAoV1hTX0lTX0FUT01JQyh0eXBlKSkKCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJhdG9taWMgdHlwZSIpOwogICAgZWxzZSBpZiAoV1hTX0lTX0xJU1QodHlwZSkpCgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAibGlzdCB0eXBlIik7CiAgICBlbHNlIGlmIChXWFNfSVNfVU5JT04odHlwZSkpCgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAidW5pb24gdHlwZSIpOwoKICAgIGlmICh4bWxTY2hlbWFJc0dsb2JhbEl0ZW0odHlwZSkpIHsKCXhtbENoYXIgKnN0ciA9IE5VTEw7Cgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiICciKTsKCWlmICh0eXBlLT5idWlsdEluVHlwZSAhPSAwKSB7CgkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgInhzOiIpOwoJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIHR5cGUtPm5hbWUpOwoJfSBlbHNlIAoJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csCgkJeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwKCQkgICAgdHlwZS0+dGFyZ2V0TmFtZXNwYWNlLCB0eXBlLT5uYW1lKSk7Cgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiJyIpOwoJRlJFRV9BTkRfTlVMTChzdHIpOwogICAgfQogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIi5cbiIpOwogICAgaWYgKGRpc3BsYXlWYWx1ZSB8fCAoeG1sU2NoZW1hRXZhbEVycm9yTm9kZVR5cGUoYWN0eHQsIG5vZGUpID09CgkgICAgWE1MX0FUVFJJQlVURV9OT0RFKSkKCXhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywgdmFsdWUsIE5VTEwpOwogICAgZWxzZQoJeG1sU2NoZW1hRXJyKGFjdHh0LCBlcnJvciwgbm9kZSwgKGNvbnN0IGNoYXIgKikgbXNnLCBOVUxMLCBOVUxMKTsKICAgIEZSRUVfQU5EX05VTEwobXNnKQp9CgpzdGF0aWMgY29uc3QgeG1sQ2hhciAqCnhtbFNjaGVtYUZvcm1hdEVycm9yTm9kZVFOYW1lKHhtbENoYXIgKiogc3RyLAoJCQkgICAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBuaSwKCQkJICAgICAgeG1sTm9kZVB0ciBub2RlKQp7CiAgICBpZiAobm9kZSAhPSBOVUxMKSB7CglpZiAobm9kZS0+bnMgIT0gTlVMTCkKCSAgICByZXR1cm4gKHhtbFNjaGVtYUZvcm1hdFFOYW1lKHN0ciwgbm9kZS0+bnMtPmhyZWYsIG5vZGUtPm5hbWUpKTsKCWVsc2UKCSAgICByZXR1cm4gKHhtbFNjaGVtYUZvcm1hdFFOYW1lKHN0ciwgTlVMTCwgbm9kZS0+bmFtZSkpOwogICAgfSBlbHNlIGlmIChuaSAhPSBOVUxMKQoJcmV0dXJuICh4bWxTY2hlbWFGb3JtYXRRTmFtZShzdHIsIG5pLT5uc05hbWUsIG5pLT5sb2NhbE5hbWUpKTsKICAgIHJldHVybiAoTlVMTCk7Cn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUlsbGVnYWxBdHRyRXJyKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkJeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCQl4bWxTY2hlbWFBdHRySW5mb1B0ciBuaSwKCQkJeG1sTm9kZVB0ciBub2RlKQp7CiAgICB4bWxDaGFyICptc2cgPSBOVUxMLCAqc3RyID0gTlVMTDsKICAgIAogICAgeG1sU2NoZW1hRm9ybWF0Tm9kZUZvckVycm9yKCZtc2csIGFjdHh0LCBub2RlKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgYXR0cmlidXRlICclcycgaXMgbm90IGFsbG93ZWQuXG4iKTsKICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywKCXhtbFNjaGVtYUZvcm1hdEVycm9yTm9kZVFOYW1lKCZzdHIsICh4bWxTY2hlbWFOb2RlSW5mb1B0cikgbmksIG5vZGUpLAoJTlVMTCk7ICAgICAgICAKICAgIEZSRUVfQU5EX05VTEwoc3RyKQogICAgRlJFRV9BTkRfTlVMTChtc2cpCn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUNvbXBsZXhUeXBlRXJyKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkgICAgICAgIHhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkgICAgICAgIHhtbE5vZGVQdHIgbm9kZSwKCQkJeG1sU2NoZW1hVHlwZVB0ciB0eXBlIEFUVFJJQlVURV9VTlVTRUQsCgkJCWNvbnN0IGNoYXIgKm1lc3NhZ2UsCgkJCWludCBuYnZhbCwKCQkJaW50IG5ibmVnLAoJCQl4bWxDaGFyICoqdmFsdWVzKQp7CiAgICB4bWxDaGFyICpzdHIgPSBOVUxMLCAqbXNnID0gTlVMTDsKICAgIHhtbENoYXIgKmxvY2FsTmFtZSwgKm5zTmFtZTsKICAgIGNvbnN0IHhtbENoYXIgKmN1ciwgKmVuZDsKICAgIGludCBpOwogICAgCiAgICB4bWxTY2hlbWFGb3JtYXROb2RlRm9yRXJyb3IoJm1zZywgYWN0eHQsIG5vZGUpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgKGNvbnN0IHhtbENoYXIgKikgbWVzc2FnZSk7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiLiIpOwogICAgLyoKICAgICogTm90ZSB0aGF0IGlzIGRvZXMgbm90IG1ha2Ugc2Vuc2UgdG8gcmVwb3J0IHRoYXQgd2UgaGF2ZSBhCiAgICAqIHdpbGRjYXJkIGhlcmUsIHNpbmNlIHRoZSB3aWxkY2FyZCBtaWdodCBiZSB1bmZvbGRlZCBpbnRvCiAgICAqIG11bHRpcGxlIHRyYW5zaXRpb25zLgogICAgKi8KICAgIGlmIChuYnZhbCArIG5ibmVnID4gMCkgewoJaWYgKG5idmFsICsgbmJuZWcgPiAxKSB7CgkgICAgc3RyID0geG1sU3RyZHVwKEJBRF9DQVNUICIgRXhwZWN0ZWQgaXMgb25lIG9mICggIik7Cgl9IGVsc2UKCSAgICBzdHIgPSB4bWxTdHJkdXAoQkFEX0NBU1QgIiBFeHBlY3RlZCBpcyAoICIpOwoJbnNOYW1lID0gTlVMTDsKICAgIAkgICAgCglmb3IgKGkgPSAwOyBpIDwgbmJ2YWwgKyBuYm5lZzsgaSsrKSB7CgkgICAgY3VyID0gdmFsdWVzW2ldOwoJICAgIGlmIChjdXIgPT0gTlVMTCkKCSAgICAgICAgY29udGludWU7CgkgICAgaWYgKChjdXJbMF0gPT0gJ24nKSAmJiAoY3VyWzFdID09ICdvJykgJiYgKGN1clsyXSA9PSAndCcpICYmCgkgICAgICAgIChjdXJbM10gPT0gJyAnKSkgewoJCWN1ciArPSA0OwoJCXN0ciA9IHhtbFN0cmNhdChzdHIsIEJBRF9DQVNUICIjI290aGVyIik7CgkgICAgfQoJICAgIC8qCgkgICAgKiBHZXQgdGhlIGxvY2FsIG5hbWUuCgkgICAgKi8KCSAgICBsb2NhbE5hbWUgPSBOVUxMOwoJICAgIAoJICAgIGVuZCA9IGN1cjsKCSAgICBpZiAoKmVuZCA9PSAnKicpIHsKCQlsb2NhbE5hbWUgPSB4bWxTdHJkdXAoQkFEX0NBU1QgIioiKTsKCQllbmQrKzsKCSAgICB9IGVsc2UgewoJCXdoaWxlICgoKmVuZCAhPSAwKSAmJiAoKmVuZCAhPSAnfCcpKQoJCSAgICBlbmQrKzsKCQlsb2NhbE5hbWUgPSB4bWxTdHJuY2F0KGxvY2FsTmFtZSwgQkFEX0NBU1QgY3VyLCBlbmQgLSBjdXIpOwoJICAgIH0JCQoJICAgIGlmICgqZW5kICE9IDApIHsJCSAgICAKCQllbmQrKzsKCQkvKgoJCSogU2tpcCAiKnwqIiBpZiB0aGV5IGNvbWUgd2l0aCBuZWdhdGVkIGV4cHJlc3Npb25zLCBzaW5jZQoJCSogdGhleSByZXByZXNlbnQgdGhlIHNhbWUgbmVnYXRlZCB3aWxkY2FyZC4KCQkqLwoJCWlmICgobmJuZWcgPT0gMCkgfHwgKCplbmQgIT0gJyonKSB8fCAoKmxvY2FsTmFtZSAhPSAnKicpKSB7CgkJICAgIC8qCgkJICAgICogR2V0IHRoZSBuYW1lc3BhY2UgbmFtZS4KCQkgICAgKi8KCQkgICAgY3VyID0gZW5kOwoJCSAgICBpZiAoKmVuZCA9PSAnKicpIHsKCQkJbnNOYW1lID0geG1sU3RyZHVwKEJBRF9DQVNUICJ7Kn0iKTsKCQkgICAgfSBlbHNlIHsKCQkJd2hpbGUgKCplbmQgIT0gMCkKCQkJICAgIGVuZCsrOwoJCQkKCQkJaWYgKGkgPj0gbmJ2YWwpCgkJCSAgICBuc05hbWUgPSB4bWxTdHJkdXAoQkFEX0NBU1QgInsjI290aGVyOiIpOwoJCQllbHNlCgkJCSAgICBuc05hbWUgPSB4bWxTdHJkdXAoQkFEX0NBU1QgInsiKTsKCQkJCgkJCW5zTmFtZSA9IHhtbFN0cm5jYXQobnNOYW1lLCBCQURfQ0FTVCBjdXIsIGVuZCAtIGN1cik7CgkJCW5zTmFtZSA9IHhtbFN0cmNhdChuc05hbWUsIEJBRF9DQVNUICJ9Iik7CgkJICAgIH0KCQkgICAgc3RyID0geG1sU3RyY2F0KHN0ciwgQkFEX0NBU1QgbnNOYW1lKTsKCQkgICAgRlJFRV9BTkRfTlVMTChuc05hbWUpCgkJfSBlbHNlIHsKCQkgICAgRlJFRV9BTkRfTlVMTChsb2NhbE5hbWUpOwoJCSAgICBjb250aW51ZTsKCQl9CgkgICAgfQkgICAgICAgIAoJICAgIHN0ciA9IHhtbFN0cmNhdChzdHIsIEJBRF9DQVNUIGxvY2FsTmFtZSk7CgkgICAgRlJFRV9BTkRfTlVMTChsb2NhbE5hbWUpOwoJCQoJICAgIGlmIChpIDwgbmJ2YWwgKyBuYm5lZyAtMSkKCQlzdHIgPSB4bWxTdHJjYXQoc3RyLCBCQURfQ0FTVCAiLCAiKTsKCX0JCglzdHIgPSB4bWxTdHJjYXQoc3RyLCBCQURfQ0FTVCAiICkuXG4iKTsKCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUIHN0cik7CglGUkVFX0FORF9OVUxMKHN0cikKICAgIH0gZWxzZQogICAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiXG4iKTsKICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywgTlVMTCwgTlVMTCk7CiAgICB4bWxGcmVlKG1zZyk7Cn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZhY2V0RXJyKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkgIHhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkgIHhtbE5vZGVQdHIgbm9kZSwKCQkgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCSAgdW5zaWduZWQgbG9uZyBsZW5ndGgsCgkJICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUsCgkJICB4bWxTY2hlbWFGYWNldFB0ciBmYWNldCwKCQkgIGNvbnN0IGNoYXIgKm1lc3NhZ2UsCgkJICBjb25zdCB4bWxDaGFyICpzdHIxLAoJCSAgY29uc3QgeG1sQ2hhciAqc3RyMikKewogICAgeG1sQ2hhciAqc3RyID0gTlVMTCwgKm1zZyA9IE5VTEw7CiAgICB4bWxTY2hlbWFUeXBlVHlwZSBmYWNldFR5cGU7CiAgICBpbnQgbm9kZVR5cGUgPSB4bWxTY2hlbWFFdmFsRXJyb3JOb2RlVHlwZShhY3R4dCwgbm9kZSk7CgogICAgeG1sU2NoZW1hRm9ybWF0Tm9kZUZvckVycm9yKCZtc2csIGFjdHh0LCBub2RlKTsKICAgIGlmIChlcnJvciA9PSBYTUxfU0NIRU1BVl9DVkNfRU5VTUVSQVRJT05fVkFMSUQpIHsKCWZhY2V0VHlwZSA9IFhNTF9TQ0hFTUFfRkFDRVRfRU5VTUVSQVRJT047CgkvKgoJKiBJZiBlbnVtZXJhdGlvbnMgYXJlIHZhbGlkYXRlZCwgb25lIG11c3Qgbm90IGV4cGVjdCB0aGUKCSogZmFjZXQgdG8gYmUgZ2l2ZW4uCgkqLwkKICAgIH0gZWxzZQkKCWZhY2V0VHlwZSA9IGZhY2V0LT50eXBlOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIlsiKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJmYWNldCAnIik7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCB4bWxTY2hlbWFGYWNldFR5cGVUb1N0cmluZyhmYWNldFR5cGUpKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICInXSAiKTsKICAgIGlmIChtZXNzYWdlID09IE5VTEwpIHsKCS8qCgkqIFVzZSBhIGRlZmF1bHQgbWVzc2FnZS4KCSovCglpZiAoKGZhY2V0VHlwZSA9PSBYTUxfU0NIRU1BX0ZBQ0VUX0xFTkdUSCkgfHwKCSAgICAoZmFjZXRUeXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfTUlOTEVOR1RIKSB8fAoJICAgIChmYWNldFR5cGUgPT0gWE1MX1NDSEVNQV9GQUNFVF9NQVhMRU5HVEgpKSB7CgoJICAgIGNoYXIgbGVuWzI1XSwgYWN0TGVuWzI1XTsKCgkgICAgLyogRklYTUUsIFRPRE86IFdoYXQgaXMgdGhlIG1heCBleHBlY3RlZCBzdHJpbmcgbGVuZ3RoIG9mIHRoZQoJICAgICogdGhpcyB2YWx1ZT8KCSAgICAqLwoJICAgIGlmIChub2RlVHlwZSA9PSBYTUxfQVRUUklCVVRFX05PREUpCgkJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIlRoZSB2YWx1ZSAnJXMnIGhhcyBhIGxlbmd0aCBvZiAnJXMnOyAiKTsKCSAgICBlbHNlCgkJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIlRoZSB2YWx1ZSBoYXMgYSBsZW5ndGggb2YgJyVzJzsgIik7CgoJICAgIHNucHJpbnRmKGxlbiwgMjQsICIlbHUiLCB4bWxTY2hlbWFHZXRGYWNldFZhbHVlQXNVTG9uZyhmYWNldCkpOwoJICAgIHNucHJpbnRmKGFjdExlbiwgMjQsICIlbHUiLCBsZW5ndGgpOwoKCSAgICBpZiAoZmFjZXRUeXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfTEVOR1RIKQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIAoJCUJBRF9DQVNUICJ0aGlzIGRpZmZlcnMgZnJvbSB0aGUgYWxsb3dlZCBsZW5ndGggb2YgJyVzJy5cbiIpOyAgICAgCgkgICAgZWxzZSBpZiAoZmFjZXRUeXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIKQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIAoJCUJBRF9DQVNUICJ0aGlzIGV4Y2VlZHMgdGhlIGFsbG93ZWQgbWF4aW11bSBsZW5ndGggb2YgJyVzJy5cbiIpOwoJICAgIGVsc2UgaWYgKGZhY2V0VHlwZSA9PSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkxFTkdUSCkKCQltc2cgPSB4bWxTdHJjYXQobXNnLCAKCQlCQURfQ0FTVCAidGhpcyB1bmRlcnJ1bnMgdGhlIGFsbG93ZWQgbWluaW11bSBsZW5ndGggb2YgJyVzJy5cbiIpOwoJICAgIAoJICAgIGlmIChub2RlVHlwZSA9PSBYTUxfQVRUUklCVVRFX05PREUpCgkJeG1sU2NoZW1hRXJyMyhhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywKCQkgICAgdmFsdWUsIChjb25zdCB4bWxDaGFyICopIGFjdExlbiwgKGNvbnN0IHhtbENoYXIgKikgbGVuKTsKCSAgICBlbHNlIAoJCXhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywKCQkgICAgKGNvbnN0IHhtbENoYXIgKikgYWN0TGVuLCAoY29uc3QgeG1sQ2hhciAqKSBsZW4pOwoJCgl9IGVsc2UgaWYgKGZhY2V0VHlwZSA9PSBYTUxfU0NIRU1BX0ZBQ0VUX0VOVU1FUkFUSU9OKSB7CgkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIlRoZSB2YWx1ZSAnJXMnIGlzIG5vdCBhbiBlbGVtZW50ICIKCQkib2YgdGhlIHNldCB7JXN9LlxuIik7CgkgICAgeG1sU2NoZW1hRXJyKGFjdHh0LCBlcnJvciwgbm9kZSwgKGNvbnN0IGNoYXIgKikgbXNnLCB2YWx1ZSwgCgkJeG1sU2NoZW1hRm9ybWF0RmFjZXRFbnVtU2V0KGFjdHh0LCAmc3RyLCB0eXBlKSk7Cgl9IGVsc2UgaWYgKGZhY2V0VHlwZSA9PSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk4pIHsKCSAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiVGhlIHZhbHVlICclcycgaXMgbm90IGFjY2VwdGVkICIKCQkiYnkgdGhlIHBhdHRlcm4gJyVzJy5cbiIpOwoJICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywgdmFsdWUsIAoJCWZhY2V0LT52YWx1ZSk7Cgl9IGVsc2UgaWYgKGZhY2V0VHlwZSA9PSBYTUxfU0NIRU1BX0ZBQ0VUX01JTklOQ0xVU0lWRSkgewoJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgdmFsdWUgJyVzJyBpcyBsZXNzIHRoYW4gdGhlICIKCQkibWluaW11bSB2YWx1ZSBhbGxvd2VkICgnJXMnKS5cbiIpOwoJICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywgdmFsdWUsCgkJZmFjZXQtPnZhbHVlKTsKCX0gZWxzZSBpZiAoZmFjZXRUeXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfTUFYSU5DTFVTSVZFKSB7CgkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIlRoZSB2YWx1ZSAnJXMnIGlzIGdyZWF0ZXIgdGhhbiB0aGUgIgoJCSJtYXhpbXVtIHZhbHVlIGFsbG93ZWQgKCclcycpLlxuIik7CgkgICAgeG1sU2NoZW1hRXJyKGFjdHh0LCBlcnJvciwgbm9kZSwgKGNvbnN0IGNoYXIgKikgbXNnLCB2YWx1ZSwKCQlmYWNldC0+dmFsdWUpOwoJfSBlbHNlIGlmIChmYWNldFR5cGUgPT0gWE1MX1NDSEVNQV9GQUNFVF9NSU5FWENMVVNJVkUpIHsKCSAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiVGhlIHZhbHVlICclcycgbXVzdCBiZSBncmVhdGVyIHRoYW4gIgoJCSInJXMnLlxuIik7CgkgICAgeG1sU2NoZW1hRXJyKGFjdHh0LCBlcnJvciwgbm9kZSwgKGNvbnN0IGNoYXIgKikgbXNnLCB2YWx1ZSwKCQlmYWNldC0+dmFsdWUpOwoJfSBlbHNlIGlmIChmYWNldFR5cGUgPT0gWE1MX1NDSEVNQV9GQUNFVF9NQVhFWENMVVNJVkUpIHsKCSAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiVGhlIHZhbHVlICclcycgbXVzdCBiZSBsZXNzIHRoYW4gIgoJCSInJXMnLlxuIik7CgkgICAgeG1sU2NoZW1hRXJyKGFjdHh0LCBlcnJvciwgbm9kZSwgKGNvbnN0IGNoYXIgKikgbXNnLCB2YWx1ZSwKCQlmYWNldC0+dmFsdWUpOwoJfSBlbHNlIGlmIChmYWNldFR5cGUgPT0gWE1MX1NDSEVNQV9GQUNFVF9UT1RBTERJR0lUUykgewoJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgdmFsdWUgJyVzJyBoYXMgbW9yZSAiCgkJImRpZ2l0cyB0aGFuIGFyZSBhbGxvd2VkICgnJXMnKS5cbiIpOwoJICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyKikgbXNnLCB2YWx1ZSwKCQlmYWNldC0+dmFsdWUpOwoJfSBlbHNlIGlmIChmYWNldFR5cGUgPT0gWE1MX1NDSEVNQV9GQUNFVF9GUkFDVElPTkRJR0lUUykgewoJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgdmFsdWUgJyVzJyBoYXMgbW9yZSBmcmFjdGlvbmFsICIKCQkiZGlnaXRzIHRoYW4gYXJlIGFsbG93ZWQgKCclcycpLlxuIik7CgkgICAgeG1sU2NoZW1hRXJyKGFjdHh0LCBlcnJvciwgbm9kZSwgKGNvbnN0IGNoYXIqKSBtc2csIHZhbHVlLAoJCWZhY2V0LT52YWx1ZSk7Cgl9IGVsc2UgaWYgKG5vZGVUeXBlID09IFhNTF9BVFRSSUJVVEVfTk9ERSkgewkJCgkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIlRoZSB2YWx1ZSAnJXMnIGlzIG5vdCBmYWNldC12YWxpZC5cbiIpOwoJICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywgdmFsdWUsIE5VTEwpOwkKCX0gZWxzZSB7CSAgICAKCSAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiVGhlIHZhbHVlIGlzIG5vdCBmYWNldC12YWxpZC5cbiIpOwoJICAgIHhtbFNjaGVtYUVycihhY3R4dCwgZXJyb3IsIG5vZGUsIChjb25zdCBjaGFyICopIG1zZywgTlVMTCwgTlVMTCk7Cgl9CiAgICB9IGVsc2UgewoJbXNnID0geG1sU3RyY2F0KG1zZywgKGNvbnN0IHhtbENoYXIgKikgbWVzc2FnZSk7Cgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiLlxuIik7Cgl4bWxTY2hlbWFFcnIoYWN0eHQsIGVycm9yLCBub2RlLCAoY29uc3QgY2hhciAqKSBtc2csIHN0cjEsIHN0cjIpOwogICAgfSAgICAgICAgCiAgICBGUkVFX0FORF9OVUxMKHN0cikKICAgIHhtbEZyZWUobXNnKTsKfQoKI2RlZmluZSBWRVJST1IoZXJyLCB0eXBlLCBtc2cpIFwKICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHZjdHh0LCBlcnIsIE5VTEwsIHR5cGUsIG1zZywgTlVMTCwgTlVMTCk7CgojZGVmaW5lIFZFUlJPUl9JTlQoZnVuYywgbXNnKSB4bWxTY2hlbWFJbnRlcm5hbEVycihBQ1RYVF9DQVNUIHZjdHh0LCBmdW5jLCBtc2cpOwoKI2RlZmluZSBQRVJST1JfSU5UKGZ1bmMsIG1zZykgeG1sU2NoZW1hSW50ZXJuYWxFcnIoQUNUWFRfQ0FTVCBwY3R4dCwgZnVuYywgbXNnKTsKI2RlZmluZSBQRVJST1JfSU5UMihmdW5jLCBtc2cpIHhtbFNjaGVtYUludGVybmFsRXJyKEFDVFhUX0NBU1QgY3R4dCwgZnVuYywgbXNnKTsKCiNkZWZpbmUgQUVSUk9SX0lOVChmdW5jLCBtc2cpIHhtbFNjaGVtYUludGVybmFsRXJyKGFjdHh0LCBmdW5jLCBtc2cpOwoKCi8qKgogKiB4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnI6CiAqIEBjdHh0OiB0aGUgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAb3duZXJEZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiAgdGhlIG93bmVyCiAqIEBvd25lck5hbWU6IHRoZSBuYW1lIG9mIHRoZSBvd25lcgogKiBAb3duZXJJdGVtOiB0aGUgb3duZXIgYXMgYSBzY2hlbWEgb2JqZWN0CiAqIEBvd25lckVsZW06IHRoZSBvd25lciBhcyBhbiBlbGVtZW50IG5vZGUKICogQG5vZGU6IHRoZSBwYXJlbnQgZWxlbWVudCBub2RlIG9mIHRoZSBtaXNzaW5nIGF0dHJpYnV0ZSBub2RlCiAqIEB0eXBlOiB0aGUgY29ycmVzcG9uZGluZyB0eXBlIG9mIHRoZSBhdHRyaWJ1dGUgbm9kZQogKgogKiBSZXBvcnRzIGFuIGlsbGVnYWwgYXR0cmlidXRlLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUE1pc3NpbmdBdHRyRXJyKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJIHhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkJIHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBvd25lckl0ZW0sCgkJCSB4bWxOb2RlUHRyIG93bmVyRWxlbSwKCQkJIGNvbnN0IGNoYXIgKm5hbWUsCgkJCSBjb25zdCBjaGFyICptZXNzYWdlKQp7CiAgICB4bWxDaGFyICpkZXMgPSBOVUxMOwoKICAgIHhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJmRlcywgTlVMTCwgb3duZXJJdGVtLCBvd25lckVsZW0pOwoKICAgIGlmIChtZXNzYWdlICE9IE5VTEwpCgl4bWxTY2hlbWFQRXJyKGN0eHQsIG93bmVyRWxlbSwgZXJyb3IsICIlczogJXMuXG4iLCBCQURfQ0FTVCBkZXMsIEJBRF9DQVNUIG1lc3NhZ2UpOwogICAgZWxzZQoJeG1sU2NoZW1hUEVycihjdHh0LCBvd25lckVsZW0sIGVycm9yLAoJICAgICIlczogVGhlIGF0dHJpYnV0ZSAnJXMnIGlzIHJlcXVpcmVkIGJ1dCBtaXNzaW5nLlxuIiwKCSAgICBCQURfQ0FTVCBkZXMsIEJBRF9DQVNUIG5hbWUpOwogICAgRlJFRV9BTkRfTlVMTChkZXMpOwp9CgoKLyoqCiAqIHhtbFNjaGVtYVBSZXNDb21wQXR0ckVycjoKICogQGN0eHQ6IHRoZSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQG93bmVyRGVzOiB0aGUgZGVzaWduYXRpb24gb2YgIHRoZSBvd25lcgogKiBAb3duZXJJdGVtOiB0aGUgb3duZXIgYXMgYSBzY2hlbWEgb2JqZWN0CiAqIEBvd25lckVsZW06IHRoZSBvd25lciBhcyBhbiBlbGVtZW50IG5vZGUKICogQG5hbWU6IHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUgaG9sZGluZyB0aGUgUU5hbWUKICogQHJlZk5hbWU6IHRoZSByZWZlcmVuY2VkIGxvY2FsIG5hbWUKICogQHJlZlVSSTogdGhlIHJlZmVyZW5jZWQgbmFtZXNwYWNlIFVSSQogKiBAbWVzc2FnZTogb3B0aW9uYWwgbWVzc2FnZQogKgogKiBVc2VkIHRvIHJlcG9ydCBRTmFtZSBhdHRyaWJ1dGUgdmFsdWVzIHRoYXQgZmFpbGVkIHRvIHJlc29sdmUKICogdG8gc2NoZW1hIGNvbXBvbmVudHMuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFQUmVzQ29tcEF0dHJFcnIoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCQkgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIG93bmVySXRlbSwKCQkJIHhtbE5vZGVQdHIgb3duZXJFbGVtLAoJCQkgY29uc3QgY2hhciAqbmFtZSwKCQkJIGNvbnN0IHhtbENoYXIgKnJlZk5hbWUsCgkJCSBjb25zdCB4bWxDaGFyICpyZWZVUkksCgkJCSB4bWxTY2hlbWFUeXBlVHlwZSByZWZUeXBlLAoJCQkgY29uc3QgY2hhciAqcmVmVHlwZVN0cikKewogICAgeG1sQ2hhciAqZGVzID0gTlVMTCwgKnN0ckEgPSBOVUxMOwoKICAgIHhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJmRlcywgTlVMTCwgb3duZXJJdGVtLCBvd25lckVsZW0pOwogICAgaWYgKHJlZlR5cGVTdHIgPT0gTlVMTCkKCXJlZlR5cGVTdHIgPSAoY29uc3QgY2hhciAqKSB4bWxTY2hlbWFJdGVtVHlwZVRvU3RyKHJlZlR5cGUpOwoJeG1sU2NoZW1hUEVyckV4dChjdHh0LCBvd25lckVsZW0sIGVycm9yLAoJICAgIE5VTEwsIE5VTEwsIE5VTEwsCgkgICAgIiVzLCBhdHRyaWJ1dGUgJyVzJzogVGhlIFFOYW1lIHZhbHVlICclcycgZG9lcyBub3QgcmVzb2x2ZSB0byBhKG4pICIKCSAgICAiJXMuXG4iLCBCQURfQ0FTVCBkZXMsIEJBRF9DQVNUIG5hbWUsCgkgICAgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ckEsIHJlZlVSSSwgcmVmTmFtZSksCgkgICAgQkFEX0NBU1QgcmVmVHlwZVN0ciwgTlVMTCk7CiAgICBGUkVFX0FORF9OVUxMKGRlcykKICAgIEZSRUVfQU5EX05VTEwoc3RyQSkKfQoKLyoqCiAqIHhtbFNjaGVtYVBDdXN0b21BdHRyRXJyOgogKiBAY3R4dDogdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAZXJyb3I6IHRoZSBlcnJvciBjb2RlCiAqIEBvd25lckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBvd25lcgogKiBAb3duZXJJdGVtOiB0aGUgb3duZXIgYXMgYSBzY2hlbWEgb2JqZWN0CiAqIEBhdHRyOiB0aGUgaWxsZWdhbCBhdHRyaWJ1dGUgbm9kZQogKgogKiBSZXBvcnRzIGFuIGlsbGVnYWwgYXR0cmlidXRlIGR1cmluZyB0aGUgcGFyc2UuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFQQ3VzdG9tQXR0ckVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCXhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkJeG1sQ2hhciAqKm93bmVyRGVzLAoJCQl4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJJdGVtLAoJCQl4bWxBdHRyUHRyIGF0dHIsCgkJCWNvbnN0IGNoYXIgKm1zZykKewogICAgeG1sQ2hhciAqZGVzID0gTlVMTDsKCiAgICBpZiAob3duZXJEZXMgPT0gTlVMTCkKCXhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJmRlcywgTlVMTCwgb3duZXJJdGVtLCBhdHRyLT5wYXJlbnQpOwogICAgZWxzZSBpZiAoKm93bmVyRGVzID09IE5VTEwpIHsKCXhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQob3duZXJEZXMsIE5VTEwsIG93bmVySXRlbSwgYXR0ci0+cGFyZW50KTsKCWRlcyA9ICpvd25lckRlczsKICAgIH0gZWxzZQoJZGVzID0gKm93bmVyRGVzOwogICAgeG1sU2NoZW1hUEVyckV4dChjdHh0LCAoeG1sTm9kZVB0cikgYXR0ciwgZXJyb3IsIE5VTEwsIE5VTEwsIE5VTEwsCgkiJXMsIGF0dHJpYnV0ZSAnJXMnOiAlcy5cbiIsCglCQURfQ0FTVCBkZXMsIGF0dHItPm5hbWUsIChjb25zdCB4bWxDaGFyICopIG1zZywgTlVMTCwgTlVMTCk7CiAgICBpZiAob3duZXJEZXMgPT0gTlVMTCkKCUZSRUVfQU5EX05VTEwoZGVzKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycjoKICogQGN0eHQ6IHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQGVycm9yOiB0aGUgZXJyb3IgY29kZQogKiBAb3duZXJEZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiB0aGUgYXR0cmlidXRlJ3Mgb3duZXIKICogQG93bmVySXRlbTogdGhlIGF0dHJpYnV0ZSdzIG93bmVyIGl0ZW0KICogQGF0dHI6IHRoZSBpbGxlZ2FsIGF0dHJpYnV0ZSBub2RlCiAqCiAqIFJlcG9ydHMgYW4gaWxsZWdhbCBhdHRyaWJ1dGUgZHVyaW5nIHRoZSBwYXJzZS4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSB4bWxQYXJzZXJFcnJvcnMgZXJyb3IsCgkJCSB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJDb21wIEFUVFJJQlVURV9VTlVTRUQsCgkJCSB4bWxBdHRyUHRyIGF0dHIpCnsKICAgIHhtbENoYXIgKnN0ckEgPSBOVUxMLCAqc3RyQiA9IE5VTEw7CgogICAgeG1sU2NoZW1hRm9ybWF0Tm9kZUZvckVycm9yKCZzdHJBLCBBQ1RYVF9DQVNUIGN0eHQsIGF0dHItPnBhcmVudCk7CiAgICB4bWxTY2hlbWFFcnI0KEFDVFhUX0NBU1QgY3R4dCwgZXJyb3IsICh4bWxOb2RlUHRyKSBhdHRyLAoJIiVzVGhlIGF0dHJpYnV0ZSAnJXMnIGlzIG5vdCBhbGxvd2VkLlxuIiwgQkFEX0NBU1Qgc3RyQSwKCXhtbFNjaGVtYUZvcm1hdFFOYW1lTnMoJnN0ckIsIGF0dHItPm5zLCBhdHRyLT5uYW1lKSwKCU5VTEwsIE5VTEwpOwogICAgRlJFRV9BTkRfTlVMTChzdHJBKTsKICAgIEZSRUVfQU5EX05VTEwoc3RyQik7Cn0KCi8qKgogKiB4bWxTY2hlbWFQQ3VzdG9tRXJyOgogKiBAY3R4dDogdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAZXJyb3I6IHRoZSBlcnJvciBjb2RlCiAqIEBpdGVtRGVzOiB0aGUgZGVzaWduYXRpb24gb2YgdGhlIHNjaGVtYSBpdGVtCiAqIEBpdGVtOiB0aGUgc2NoZW1hIGl0ZW0KICogQGl0ZW1FbGVtOiB0aGUgbm9kZSBvZiB0aGUgc2NoZW1hIGl0ZW0KICogQG1lc3NhZ2U6IHRoZSBlcnJvciBtZXNzYWdlCiAqIEBzdHIxOiBhbiBvcHRpb25hbCBwYXJhbSBmb3IgdGhlIGVycm9yIG1lc3NhZ2UKICogQHN0cjI6IGFuIG9wdGlvbmFsIHBhcmFtIGZvciB0aGUgZXJyb3IgbWVzc2FnZQogKiBAc3RyMzogYW4gb3B0aW9uYWwgcGFyYW0gZm9yIHRoZSBlcnJvciBtZXNzYWdlCiAqCiAqIFJlcG9ydHMgYW4gZXJyb3IgZHVyaW5nIHBhcnNpbmcuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFQQ3VzdG9tRXJyRXh0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkgICAgeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCSAgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSwKCQkgICAgeG1sTm9kZVB0ciBpdGVtRWxlbSwKCQkgICAgY29uc3QgY2hhciAqbWVzc2FnZSwKCQkgICAgY29uc3QgeG1sQ2hhciAqc3RyMSwKCQkgICAgY29uc3QgeG1sQ2hhciAqc3RyMiwKCQkgICAgY29uc3QgeG1sQ2hhciAqc3RyMykKewogICAgeG1sQ2hhciAqZGVzID0gTlVMTCwgKm1zZyA9IE5VTEw7CgogICAgeG1sU2NoZW1hRm9ybWF0SXRlbUZvclJlcG9ydCgmZGVzLCBOVUxMLCBpdGVtLCBpdGVtRWxlbSk7CiAgICBtc2cgPSB4bWxTdHJkdXAoQkFEX0NBU1QgIiVzOiAiKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIChjb25zdCB4bWxDaGFyICopIG1lc3NhZ2UpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIi5cbiIpOwogICAgaWYgKChpdGVtRWxlbSA9PSBOVUxMKSAmJiAoaXRlbSAhPSBOVUxMKSkKCWl0ZW1FbGVtID0gV1hTX0lURU1fTk9ERShpdGVtKTsKICAgIHhtbFNjaGVtYVBFcnJFeHQoY3R4dCwgaXRlbUVsZW0sIGVycm9yLCBOVUxMLCBOVUxMLCBOVUxMLAoJKGNvbnN0IGNoYXIgKikgbXNnLCBCQURfQ0FTVCBkZXMsIHN0cjEsIHN0cjIsIHN0cjMsIE5VTEwpOwogICAgRlJFRV9BTkRfTlVMTChkZXMpOwogICAgRlJFRV9BTkRfTlVMTChtc2cpOwp9CgovKioKICogeG1sU2NoZW1hUEN1c3RvbUVycjoKICogQGN0eHQ6IHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQGVycm9yOiB0aGUgZXJyb3IgY29kZQogKiBAaXRlbURlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBzY2hlbWEgaXRlbQogKiBAaXRlbTogdGhlIHNjaGVtYSBpdGVtCiAqIEBpdGVtRWxlbTogdGhlIG5vZGUgb2YgdGhlIHNjaGVtYSBpdGVtCiAqIEBtZXNzYWdlOiB0aGUgZXJyb3IgbWVzc2FnZQogKiBAc3RyMTogdGhlIG9wdGlvbmFsIHBhcmFtIGZvciB0aGUgZXJyb3IgbWVzc2FnZQogKgogKiBSZXBvcnRzIGFuIGVycm9yIGR1cmluZyBwYXJzaW5nLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUEN1c3RvbUVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJICAgIHhtbFBhcnNlckVycm9ycyBlcnJvciwKCQkgICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIGl0ZW0sCgkJICAgIHhtbE5vZGVQdHIgaXRlbUVsZW0sCgkJICAgIGNvbnN0IGNoYXIgKm1lc3NhZ2UsCgkJICAgIGNvbnN0IHhtbENoYXIgKnN0cjEpCnsKICAgIHhtbFNjaGVtYVBDdXN0b21FcnJFeHQoY3R4dCwgZXJyb3IsIGl0ZW0sIGl0ZW1FbGVtLCBtZXNzYWdlLAoJc3RyMSwgTlVMTCwgTlVMTCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQQXR0clVzZUVycjoKICogQGN0eHQ6IHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQGVycm9yOiB0aGUgZXJyb3IgY29kZQogKiBAaXRlbURlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBzY2hlbWEgdHlwZQogKiBAaXRlbTogdGhlIHNjaGVtYSB0eXBlCiAqIEBpdGVtRWxlbTogdGhlIG5vZGUgb2YgdGhlIHNjaGVtYSB0eXBlCiAqIEBhdHRyOiB0aGUgaW52YWxpZCBzY2hlbWEgYXR0cmlidXRlCiAqIEBtZXNzYWdlOiB0aGUgZXJyb3IgbWVzc2FnZQogKiBAc3RyMTogdGhlIG9wdGlvbmFsIHBhcmFtIGZvciB0aGUgZXJyb3IgbWVzc2FnZQogKgogKiBSZXBvcnRzIGFuIGF0dHJpYnV0ZSB1c2UgZXJyb3IgZHVyaW5nIHBhcnNpbmcuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFQQXR0clVzZUVycjQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCSAgICB4bWxQYXJzZXJFcnJvcnMgZXJyb3IsCgkJICAgIHhtbE5vZGVQdHIgbm9kZSwKCQkgICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIG93bmVySXRlbSwKCQkgICAgY29uc3QgeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIGF0dHJ1c2UsCgkJICAgIGNvbnN0IGNoYXIgKm1lc3NhZ2UsCgkJICAgIGNvbnN0IHhtbENoYXIgKnN0cjEsIGNvbnN0IHhtbENoYXIgKnN0cjIsCgkJICAgIGNvbnN0IHhtbENoYXIgKnN0cjMsY29uc3QgeG1sQ2hhciAqc3RyNCkKewogICAgeG1sQ2hhciAqc3RyID0gTlVMTCwgKm1zZyA9IE5VTEw7CiAgICAKICAgIHhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJm1zZywgTlVMTCwgb3duZXJJdGVtLCBOVUxMKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICIsICIpOyAgICAKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csCglCQURfQ0FTVCB4bWxTY2hlbWFGb3JtYXRJdGVtRm9yUmVwb3J0KCZzdHIsIE5VTEwsCglXWFNfQkFTSUNfQ0FTVCBhdHRydXNlLCBOVUxMKSk7CiAgICBGUkVFX0FORF9OVUxMKHN0cik7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiOiAiKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIChjb25zdCB4bWxDaGFyICopIG1lc3NhZ2UpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIi5cbiIpOwogICAgeG1sU2NoZW1hRXJyNChBQ1RYVF9DQVNUIGN0eHQsIGVycm9yLCBub2RlLCAKCShjb25zdCBjaGFyICopIG1zZywgc3RyMSwgc3RyMiwgc3RyMywgc3RyNCk7CiAgICB4bWxGcmVlKG1zZyk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQSWxsZWdhbEZhY2V0QXRvbWljRXJyOgogKiBAY3R4dDogdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAZXJyb3I6IHRoZSBlcnJvciBjb2RlCiAqIEB0eXBlOiB0aGUgc2NoZW1hIHR5cGUKICogQGJhc2VUeXBlOiB0aGUgYmFzZSB0eXBlIG9mIHR5cGUKICogQGZhY2V0OiB0aGUgaWxsZWdhbCBmYWNldAogKgogKiBSZXBvcnRzIGFuIGlsbGVnYWwgZmFjZXQgZm9yIGF0b21pYyBzaW1wbGUgdHlwZXMuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFQSWxsZWdhbEZhY2V0QXRvbWljRXJyKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICB4bWxQYXJzZXJFcnJvcnMgZXJyb3IsCgkJCSAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQkgIHhtbFNjaGVtYVR5cGVQdHIgYmFzZVR5cGUsCgkJCSAgeG1sU2NoZW1hRmFjZXRQdHIgZmFjZXQpCnsKICAgIHhtbENoYXIgKmRlcyA9IE5VTEwsICpzdHJUID0gTlVMTDsKCiAgICB4bWxTY2hlbWFGb3JtYXRJdGVtRm9yUmVwb3J0KCZkZXMsIE5VTEwsIFdYU19CQVNJQ19DQVNUIHR5cGUsIHR5cGUtPm5vZGUpOwogICAgeG1sU2NoZW1hUEVyckV4dChjdHh0LCB0eXBlLT5ub2RlLCBlcnJvciwgTlVMTCwgTlVMTCwgTlVMTCwKCSIlczogVGhlIGZhY2V0ICclcycgaXMgbm90IGFsbG93ZWQgb24gdHlwZXMgZGVyaXZlZCBmcm9tIHRoZSAiCgkidHlwZSAlcy5cbiIsCglCQURfQ0FTVCBkZXMsIHhtbFNjaGVtYUZhY2V0VHlwZVRvU3RyaW5nKGZhY2V0LT50eXBlKSwKCXhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJnN0clQsIE5VTEwsIFdYU19CQVNJQ19DQVNUIGJhc2VUeXBlLCBOVUxMKSwKCU5VTEwsIE5VTEwpOwogICAgRlJFRV9BTkRfTlVMTChkZXMpOwogICAgRlJFRV9BTkRfTlVMTChzdHJUKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBJbGxlZ2FsRmFjZXRMaXN0VW5pb25FcnI6CiAqIEBjdHh0OiB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQGl0ZW1EZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiB0aGUgc2NoZW1hIGl0ZW0gaW52b2x2ZWQKICogQGl0ZW06IHRoZSBzY2hlbWEgaXRlbSBpbnZvbHZlZAogKiBAZmFjZXQ6IHRoZSBpbGxlZ2FsIGZhY2V0CiAqCiAqIFJlcG9ydHMgYW4gaWxsZWdhbCBmYWNldCBmb3IgPGxpc3Q+IGFuZCA8dW5pb24+LgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUElsbGVnYWxGYWNldExpc3RVbmlvbkVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSAgeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCQkgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKCQkJICB4bWxTY2hlbWFGYWNldFB0ciBmYWNldCkKewogICAgeG1sQ2hhciAqZGVzID0gTlVMTCwgKnN0clQgPSBOVUxMOwoKICAgIHhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJmRlcywgTlVMTCwgV1hTX0JBU0lDX0NBU1QgdHlwZSwKCXR5cGUtPm5vZGUpOwogICAgeG1sU2NoZW1hUEVycihjdHh0LCB0eXBlLT5ub2RlLCBlcnJvciwKCSIlczogVGhlIGZhY2V0ICclcycgaXMgbm90IGFsbG93ZWQuXG4iLAoJQkFEX0NBU1QgZGVzLCB4bWxTY2hlbWFGYWNldFR5cGVUb1N0cmluZyhmYWNldC0+dHlwZSkpOwogICAgRlJFRV9BTkRfTlVMTChkZXMpOwogICAgRlJFRV9BTkRfTlVMTChzdHJUKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBNdXR1YWxFeGNsQXR0ckVycjoKICogQGN0eHQ6IHRoZSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBlcnJvcjogdGhlIGVycm9yIGNvZGUKICogQGVsZW1EZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiB0aGUgcGFyZW50IGVsZW1lbnQgbm9kZQogKiBAYXR0cjogdGhlIGJhZCBhdHRyaWJ1dGUgbm9kZQogKiBAdHlwZTogdGhlIGNvcnJlc3BvbmRpbmcgdHlwZSBvZiB0aGUgYXR0cmlidXRlIG5vZGUKICoKICogUmVwb3J0cyBhbiBpbGxlZ2FsIGF0dHJpYnV0ZS4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYVBNdXR1YWxFeGNsQXR0ckVycih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSB4bWxQYXJzZXJFcnJvcnMgZXJyb3IsCgkJCSB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJJdGVtLAoJCQkgeG1sQXR0clB0ciBhdHRyLAoJCQkgY29uc3QgY2hhciAqbmFtZTEsCgkJCSBjb25zdCBjaGFyICpuYW1lMikKewogICAgeG1sQ2hhciAqZGVzID0gTlVMTDsKCiAgICB4bWxTY2hlbWFGb3JtYXRJdGVtRm9yUmVwb3J0KCZkZXMsIE5VTEwsIFdYU19CQVNJQ19DQVNUIG93bmVySXRlbSwgYXR0ci0+cGFyZW50KTsKICAgIHhtbFNjaGVtYVBFcnJFeHQoY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIsIGVycm9yLCBOVUxMLCBOVUxMLCBOVUxMLAoJIiVzOiBUaGUgYXR0cmlidXRlcyAnJXMnIGFuZCAnJXMnIGFyZSBtdXR1YWxseSBleGNsdXNpdmUuXG4iLAoJQkFEX0NBU1QgZGVzLCBCQURfQ0FTVCBuYW1lMSwgQkFEX0NBU1QgbmFtZTIsIE5VTEwsIE5VTEwpOwogICAgRlJFRV9BTkRfTlVMTChkZXMpOwp9CgovKioKICogeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnI6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQGVycm9yOiB0aGUgZXJyb3IgY29kZQogKiBAdHlwZTogdGhlIHR5cGUgc3BlY2lmaWVyCiAqIEBvd25lckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBvd25lcgogKiBAb3duZXJJdGVtOiB0aGUgc2NoZW1hIG9iamVjdCBpZiBleGlzdGVudCAKICogQG5vZGU6IHRoZSB2YWxpZGF0ZWQgbm9kZQogKiBAdmFsdWU6IHRoZSB2YWxpZGF0ZWQgdmFsdWUKICoKICogUmVwb3J0cyBhIHNpbXBsZSB0eXBlIHZhbGlkYXRpb24gZXJyb3IuCiAqIFRPRE86IFNob3VsZCB0aGlzIHJlcG9ydCB0aGUgdmFsdWUgb2YgYW4gZWxlbWVudCBhcyB3ZWxsPwogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCAKCQkJeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCQl4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJJdGVtIEFUVFJJQlVURV9VTlVTRUQsCgkJCXhtbE5vZGVQdHIgbm9kZSwKCQkJeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQljb25zdCBjaGFyICpleHBlY3RlZCwKCQkJY29uc3QgeG1sQ2hhciAqdmFsdWUsCgkJCWNvbnN0IGNoYXIgKm1lc3NhZ2UsCgkJCWNvbnN0IHhtbENoYXIgKnN0cjEsCgkJCWNvbnN0IHhtbENoYXIgKnN0cjIpCnsKICAgIHhtbENoYXIgKm1zZyA9IE5VTEw7CiAgICAKICAgIHhtbFNjaGVtYUZvcm1hdE5vZGVGb3JFcnJvcigmbXNnLCBBQ1RYVF9DQVNUIGN0eHQsIG5vZGUpOwogICAgaWYgKG1lc3NhZ2UgPT0gTlVMTCkgewoJLyoKCSogVXNlIGRlZmF1bHQgbWVzc2FnZXMuCgkqLwkKCWlmICh0eXBlICE9IE5VTEwpIHsKCSAgICBpZiAobm9kZS0+dHlwZSA9PSBYTUxfQVRUUklCVVRFX05PREUpCgkJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIiclcycgaXMgbm90IGEgdmFsaWQgdmFsdWUgb2YgIik7CgkgICAgZWxzZQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgY2hhcmFjdGVyIGNvbnRlbnQgaXMgbm90IGEgIgoJCSJ2YWxpZCB2YWx1ZSBvZiAiKTsJCgkgICAgaWYgKCEgeG1sU2NoZW1hSXNHbG9iYWxJdGVtKHR5cGUpKQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJ0aGUgbG9jYWwgIik7CgkgICAgZWxzZQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJ0aGUgIik7CgkgICAgCgkgICAgaWYgKFdYU19JU19BVE9NSUModHlwZSkpCgkJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgImF0b21pYyB0eXBlIik7CgkgICAgZWxzZSBpZiAoV1hTX0lTX0xJU1QodHlwZSkpCgkJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgImxpc3QgdHlwZSIpOwoJICAgIGVsc2UgaWYgKFdYU19JU19VTklPTih0eXBlKSkKCQltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAidW5pb24gdHlwZSIpOwoJICAgIAoJICAgIGlmICh4bWxTY2hlbWFJc0dsb2JhbEl0ZW0odHlwZSkpIHsKCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoJCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICIgJyIpOwoJCWlmICh0eXBlLT5idWlsdEluVHlwZSAhPSAwKSB7CgkJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJ4czoiKTsKCQkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgdHlwZS0+bmFtZSk7CgkJfSBlbHNlIAoJCSAgICBtc2cgPSB4bWxTdHJjYXQobXNnLAoJCQl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCQkgICAgdHlwZS0+dGFyZ2V0TmFtZXNwYWNlLCB0eXBlLT5uYW1lKSk7CgkJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIicuIik7CgkJRlJFRV9BTkRfTlVMTChzdHIpOwoJICAgIH0KCX0gZWxzZSB7CgkgICAgaWYgKG5vZGUtPnR5cGUgPT0gWE1MX0FUVFJJQlVURV9OT0RFKQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgdmFsdWUgJyVzJyBpcyBub3QgdmFsaWQuIik7CgkgICAgZWxzZQoJCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICJUaGUgY2hhcmFjdGVyIGNvbnRlbnQgaXMgbm90ICIKCQkidmFsaWQuIik7Cgl9CQoJaWYgKGV4cGVjdGVkKSB7CgkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIiBFeHBlY3RlZCBpcyAnIik7CgkgICAgbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgZXhwZWN0ZWQpOwoJICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICInLlxuIik7Cgl9IGVsc2UKCSAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiXG4iKTsKCWlmIChub2RlLT50eXBlID09IFhNTF9BVFRSSUJVVEVfTk9ERSkKCSAgICB4bWxTY2hlbWFQRXJyKGN0eHQsIG5vZGUsIGVycm9yLCAoY29uc3QgY2hhciAqKSBtc2csIHZhbHVlLCBOVUxMKTsKCWVsc2UKCSAgICB4bWxTY2hlbWFQRXJyKGN0eHQsIG5vZGUsIGVycm9yLCAoY29uc3QgY2hhciAqKSBtc2csIE5VTEwsIE5VTEwpOwogICAgfSBlbHNlIHsKCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUIG1lc3NhZ2UpOwoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIi5cbiIpOwoJeG1sU2NoZW1hUEVyckV4dChjdHh0LCBub2RlLCBlcnJvciwgTlVMTCwgTlVMTCwgTlVMTCwKCSAgICAgKGNvbnN0IGNoYXIqKSBtc2csIHN0cjEsIHN0cjIsIE5VTEwsIE5VTEwsIE5VTEwpOwogICAgfQogICAgLyogQ2xlYW51cC4gKi8gICAgCiAgICBGUkVFX0FORF9OVUxMKG1zZykKfQoKLyoqCiAqIHhtbFNjaGVtYVBDb250ZW50RXJyOgogKiBAY3R4dDogdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAZXJyb3I6IHRoZSBlcnJvciBjb2RlCiAqIEBvbndlckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBob2xkZXIgb2YgdGhlIGNvbnRlbnQKICogQG93bmVySXRlbTogdGhlIG93bmVyIGl0ZW0gb2YgdGhlIGhvbGRlciBvZiB0aGUgY29udGVudAogKiBAb3duZXJFbGVtOiB0aGUgbm9kZSBvZiB0aGUgaG9sZGVyIG9mIHRoZSBjb250ZW50CiAqIEBjaGlsZDogdGhlIGludmFsaWQgY2hpbGQgbm9kZQogKiBAbWVzc2FnZTogdGhlIG9wdGlvbmFsIGVycm9yIG1lc3NhZ2UKICogQGNvbnRlbnQ6IHRoZSBvcHRpb25hbCBzdHJpbmcgZGVzY3JpYmluZyB0aGUgY29ycmVjdCBjb250ZW50CiAqCiAqIFJlcG9ydHMgYW4gZXJyb3IgY29uY2VybmluZyB0aGUgY29udGVudCBvZiBhIHNjaGVtYSBlbGVtZW50LgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hUENvbnRlbnRFcnIoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCSAgICAgeG1sUGFyc2VyRXJyb3JzIGVycm9yLAoJCSAgICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIG93bmVySXRlbSwKCQkgICAgIHhtbE5vZGVQdHIgb3duZXJFbGVtLAoJCSAgICAgeG1sTm9kZVB0ciBjaGlsZCwKCQkgICAgIGNvbnN0IGNoYXIgKm1lc3NhZ2UsCgkJICAgICBjb25zdCBjaGFyICpjb250ZW50KQp7CiAgICB4bWxDaGFyICpkZXMgPSBOVUxMOwoKICAgIHhtbFNjaGVtYUZvcm1hdEl0ZW1Gb3JSZXBvcnQoJmRlcywgTlVMTCwgb3duZXJJdGVtLCBvd25lckVsZW0pOwogICAgaWYgKG1lc3NhZ2UgIT0gTlVMTCkKCXhtbFNjaGVtYVBFcnIyKGN0eHQsIG93bmVyRWxlbSwgY2hpbGQsIGVycm9yLAoJICAgICIlczogJXMuXG4iLAoJICAgIEJBRF9DQVNUIGRlcywgQkFEX0NBU1QgbWVzc2FnZSk7CiAgICBlbHNlIHsKCWlmIChjb250ZW50ICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyMihjdHh0LCBvd25lckVsZW0sIGNoaWxkLCBlcnJvciwKCQkiJXM6IFRoZSBjb250ZW50IGlzIG5vdCB2YWxpZC4gRXhwZWN0ZWQgaXMgJXMuXG4iLAoJCUJBRF9DQVNUIGRlcywgQkFEX0NBU1QgY29udGVudCk7Cgl9IGVsc2UgewoJICAgIHhtbFNjaGVtYVBFcnIyKGN0eHQsIG93bmVyRWxlbSwgY2hpbGQsIGVycm9yLAoJCSIlczogVGhlIGNvbnRlbnQgaXMgbm90IHZhbGlkLlxuIiwKCQlCQURfQ0FTVCBkZXMsIE5VTEwpOwoJfQogICAgfQogICAgRlJFRV9BTkRfTlVMTChkZXMpCn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCQkJCQkJKgogKiAJCQlTdHJlYW1hYmxlIGVycm9yIGZ1bmN0aW9ucyAgICAgICAgICAgICAgICAgICAgICAqCiAqIAkJCQkJCQkJCSoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCgoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCQkJCQkJKgogKiAJCQlWYWxpZGF0aW9uIGhlbHBlciBmdW5jdGlvbnMJCQkqCiAqIAkJCQkJCQkJCSoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQkJCQkJCSoKICogCQkJQWxsb2NhdGlvbiBmdW5jdGlvbnMJCQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgovKioKICogeG1sU2NoZW1hTmV3U2NoZW1hRm9yUGFyc2VyQ3R4dDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICoKICogQWxsb2NhdGUgYSBuZXcgU2NoZW1hIHN0cnVjdHVyZS4KICoKICogUmV0dXJucyB0aGUgbmV3bHkgYWxsb2NhdGVkIHN0cnVjdHVyZSBvciBOVUxMIGluIGNhc2Ugb3IgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFQdHIKeG1sU2NoZW1hTmV3U2NoZW1hKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCkKewogICAgeG1sU2NoZW1hUHRyIHJldDsKCiAgICByZXQgPSAoeG1sU2NoZW1hUHRyKSB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYSkpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEVyck1lbW9yeShjdHh0LCAiYWxsb2NhdGluZyBzY2hlbWEiLCBOVUxMKTsKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYSkpOwogICAgcmV0LT5kaWN0ID0gY3R4dC0+ZGljdDsKICAgIHhtbERpY3RSZWZlcmVuY2UocmV0LT5kaWN0KTsKCiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFOZXdGYWNldDoKICoKICogQWxsb2NhdGUgYSBuZXcgRmFjZXQgc3RydWN0dXJlLgogKgogKiBSZXR1cm5zIHRoZSBuZXdseSBhbGxvY2F0ZWQgc3RydWN0dXJlIG9yIE5VTEwgaW4gY2FzZSBvciBlcnJvcgogKi8KeG1sU2NoZW1hRmFjZXRQdHIKeG1sU2NoZW1hTmV3RmFjZXQodm9pZCkKewogICAgeG1sU2NoZW1hRmFjZXRQdHIgcmV0OwoKICAgIHJldCA9ICh4bWxTY2hlbWFGYWNldFB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFGYWNldCkpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFGYWNldCkpOwoKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYU5ld0Fubm90OgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAbm9kZTogIGEgbm9kZQogKgogKiBBbGxvY2F0ZSBhIG5ldyBhbm5vdGF0aW9uIHN0cnVjdHVyZS4KICoKICogUmV0dXJucyB0aGUgbmV3bHkgYWxsb2NhdGVkIHN0cnVjdHVyZSBvciBOVUxMIGluIGNhc2Ugb3IgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFBbm5vdFB0cgp4bWxTY2hlbWFOZXdBbm5vdCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbE5vZGVQdHIgbm9kZSkKewogICAgeG1sU2NoZW1hQW5ub3RQdHIgcmV0OwoKICAgIHJldCA9ICh4bWxTY2hlbWFBbm5vdFB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFBbm5vdCkpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEVyck1lbW9yeShjdHh0LCAiYWxsb2NhdGluZyBhbm5vdGF0aW9uIiwgbm9kZSk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFBbm5vdCkpOwogICAgcmV0LT5jb250ZW50ID0gbm9kZTsKICAgIHJldHVybiAocmV0KTsKfQoKc3RhdGljIHhtbFNjaGVtYUl0ZW1MaXN0UHRyCnhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKHZvaWQpCnsKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIHJldDsKCiAgICByZXQgPSB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYUl0ZW1MaXN0KSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwKCSAgICAiYWxsb2NhdGluZyBhbiBpdGVtIGxpc3Qgc3RydWN0dXJlIiwgTlVMTCk7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYUl0ZW1MaXN0KSk7CiAgICByZXR1cm4gKHJldCk7Cn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUl0ZW1MaXN0Q2xlYXIoeG1sU2NoZW1hSXRlbUxpc3RQdHIgbGlzdCkKewogICAgaWYgKGxpc3QtPml0ZW1zICE9IE5VTEwpIHsKCXhtbEZyZWUobGlzdC0+aXRlbXMpOwoJbGlzdC0+aXRlbXMgPSBOVUxMOwogICAgfQogICAgbGlzdC0+bmJJdGVtcyA9IDA7CiAgICBsaXN0LT5zaXplSXRlbXMgPSAwOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYUl0ZW1MaXN0QWRkKHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QsIHZvaWQgKml0ZW0pCnsKICAgIGlmIChsaXN0LT5pdGVtcyA9PSBOVUxMKSB7CglsaXN0LT5pdGVtcyA9ICh2b2lkICoqKSB4bWxNYWxsb2MoCgkgICAgMjAgKiBzaXplb2Yodm9pZCAqKSk7CglpZiAobGlzdC0+aXRlbXMgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwgImFsbG9jYXRpbmcgbmV3IGl0ZW0gbGlzdCIsIE5VTEwpOwoJICAgIHJldHVybigtMSk7Cgl9CglsaXN0LT5zaXplSXRlbXMgPSAyMDsKICAgIH0gZWxzZSBpZiAobGlzdC0+c2l6ZUl0ZW1zIDw9IGxpc3QtPm5iSXRlbXMpIHsKCWxpc3QtPnNpemVJdGVtcyAqPSAyOwoJbGlzdC0+aXRlbXMgPSAodm9pZCAqKikgeG1sUmVhbGxvYyhsaXN0LT5pdGVtcywKCSAgICBsaXN0LT5zaXplSXRlbXMgKiBzaXplb2Yodm9pZCAqKSk7CglpZiAobGlzdC0+aXRlbXMgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwgImdyb3dpbmcgaXRlbSBsaXN0IiwgTlVMTCk7CgkgICAgbGlzdC0+c2l6ZUl0ZW1zID0gMDsKCSAgICByZXR1cm4oLTEpOwoJfQogICAgfQogICAgbGlzdC0+aXRlbXNbbGlzdC0+bmJJdGVtcysrXSA9IGl0ZW07CiAgICByZXR1cm4oMCk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hSXRlbUxpc3RBZGRTaXplKHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QsCgkJCSBpbnQgaW5pdGlhbFNpemUsCgkJCSB2b2lkICppdGVtKQp7CiAgICBpZiAobGlzdC0+aXRlbXMgPT0gTlVMTCkgewoJaWYgKGluaXRpYWxTaXplIDw9IDApCgkgICAgaW5pdGlhbFNpemUgPSAxOwoJbGlzdC0+aXRlbXMgPSAodm9pZCAqKikgeG1sTWFsbG9jKAoJICAgIGluaXRpYWxTaXplICogc2l6ZW9mKHZvaWQgKikpOwoJaWYgKGxpc3QtPml0ZW1zID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KE5VTEwsICJhbGxvY2F0aW5nIG5ldyBpdGVtIGxpc3QiLCBOVUxMKTsKCSAgICByZXR1cm4oLTEpOwoJfQoJbGlzdC0+c2l6ZUl0ZW1zID0gaW5pdGlhbFNpemU7CiAgICB9IGVsc2UgaWYgKGxpc3QtPnNpemVJdGVtcyA8PSBsaXN0LT5uYkl0ZW1zKSB7CglsaXN0LT5zaXplSXRlbXMgKj0gMjsKCWxpc3QtPml0ZW1zID0gKHZvaWQgKiopIHhtbFJlYWxsb2MobGlzdC0+aXRlbXMsCgkgICAgbGlzdC0+c2l6ZUl0ZW1zICogc2l6ZW9mKHZvaWQgKikpOwoJaWYgKGxpc3QtPml0ZW1zID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KE5VTEwsICJncm93aW5nIGl0ZW0gbGlzdCIsIE5VTEwpOwoJICAgIGxpc3QtPnNpemVJdGVtcyA9IDA7CgkgICAgcmV0dXJuKC0xKTsKCX0KICAgIH0KICAgIGxpc3QtPml0ZW1zW2xpc3QtPm5iSXRlbXMrK10gPSBpdGVtOwogICAgcmV0dXJuKDApOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYUl0ZW1MaXN0SW5zZXJ0KHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QsIHZvaWQgKml0ZW0sIGludCBpZHgpCnsgICAgCiAgICBpZiAobGlzdC0+aXRlbXMgPT0gTlVMTCkgewoJbGlzdC0+aXRlbXMgPSAodm9pZCAqKikgeG1sTWFsbG9jKAoJICAgIDIwICogc2l6ZW9mKHZvaWQgKikpOwoJaWYgKGxpc3QtPml0ZW1zID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KE5VTEwsICJhbGxvY2F0aW5nIG5ldyBpdGVtIGxpc3QiLCBOVUxMKTsKCSAgICByZXR1cm4oLTEpOwoJfQoJbGlzdC0+c2l6ZUl0ZW1zID0gMjA7CiAgICB9IGVsc2UgaWYgKGxpc3QtPnNpemVJdGVtcyA8PSBsaXN0LT5uYkl0ZW1zKSB7CglsaXN0LT5zaXplSXRlbXMgKj0gMjsKCWxpc3QtPml0ZW1zID0gKHZvaWQgKiopIHhtbFJlYWxsb2MobGlzdC0+aXRlbXMsCgkgICAgbGlzdC0+c2l6ZUl0ZW1zICogc2l6ZW9mKHZvaWQgKikpOwoJaWYgKGxpc3QtPml0ZW1zID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KE5VTEwsICJncm93aW5nIGl0ZW0gbGlzdCIsIE5VTEwpOwoJICAgIGxpc3QtPnNpemVJdGVtcyA9IDA7CgkgICAgcmV0dXJuKC0xKTsKCX0KICAgIH0KICAgIC8qCiAgICAqIEp1c3QgYXBwZW5kIGlmIHRoZSBpbmRleCBpcyBncmVhdGVyL2VxdWFsIHRoYW4gdGhlIGl0ZW0gY291bnQuCiAgICAqLwogICAgaWYgKGlkeCA+PSBsaXN0LT5uYkl0ZW1zKSB7CglsaXN0LT5pdGVtc1tsaXN0LT5uYkl0ZW1zKytdID0gaXRlbTsKICAgIH0gZWxzZSB7CglpbnQgaTsKCWZvciAoaSA9IGxpc3QtPm5iSXRlbXM7IGkgPiBpZHg7IGktLSkKCSAgICBsaXN0LT5pdGVtc1tpXSA9IGxpc3QtPml0ZW1zW2ktMV07CglsaXN0LT5pdGVtc1tpZHhdID0gaXRlbTsKCWxpc3QtPm5iSXRlbXMrKzsKICAgIH0KICAgIHJldHVybigwKTsKfQoKI2lmIDAgLyogZW5hYmxlIGlmIGV2ZXIgbmVlZGVkICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hSXRlbUxpc3RJbnNlcnRTaXplKHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QsCgkJCSAgICBpbnQgaW5pdGlhbFNpemUsCgkJCSAgICB2b2lkICppdGVtLAoJCQkgICAgaW50IGlkeCkKeyAgICAKICAgIGlmIChsaXN0LT5pdGVtcyA9PSBOVUxMKSB7CglpZiAoaW5pdGlhbFNpemUgPD0gMCkKCSAgICBpbml0aWFsU2l6ZSA9IDE7CglsaXN0LT5pdGVtcyA9ICh2b2lkICoqKSB4bWxNYWxsb2MoCgkgICAgaW5pdGlhbFNpemUgKiBzaXplb2Yodm9pZCAqKSk7CglpZiAobGlzdC0+aXRlbXMgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwgImFsbG9jYXRpbmcgbmV3IGl0ZW0gbGlzdCIsIE5VTEwpOwoJICAgIHJldHVybigtMSk7Cgl9CglsaXN0LT5zaXplSXRlbXMgPSBpbml0aWFsU2l6ZTsKICAgIH0gZWxzZSBpZiAobGlzdC0+c2l6ZUl0ZW1zIDw9IGxpc3QtPm5iSXRlbXMpIHsKCWxpc3QtPnNpemVJdGVtcyAqPSAyOwoJbGlzdC0+aXRlbXMgPSAodm9pZCAqKikgeG1sUmVhbGxvYyhsaXN0LT5pdGVtcywKCSAgICBsaXN0LT5zaXplSXRlbXMgKiBzaXplb2Yodm9pZCAqKSk7CglpZiAobGlzdC0+aXRlbXMgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwgImdyb3dpbmcgaXRlbSBsaXN0IiwgTlVMTCk7CgkgICAgbGlzdC0+c2l6ZUl0ZW1zID0gMDsKCSAgICByZXR1cm4oLTEpOwoJfQogICAgfQogICAgLyoKICAgICogSnVzdCBhcHBlbmQgaWYgdGhlIGluZGV4IGlzIGdyZWF0ZXIvZXF1YWwgdGhhbiB0aGUgaXRlbSBjb3VudC4KICAgICovCiAgICBpZiAoaWR4ID49IGxpc3QtPm5iSXRlbXMpIHsKCWxpc3QtPml0ZW1zW2xpc3QtPm5iSXRlbXMrK10gPSBpdGVtOwogICAgfSBlbHNlIHsKCWludCBpOwoJZm9yIChpID0gbGlzdC0+bmJJdGVtczsgaSA+IGlkeDsgaS0tKQoJICAgIGxpc3QtPml0ZW1zW2ldID0gbGlzdC0+aXRlbXNbaS0xXTsKCWxpc3QtPml0ZW1zW2lkeF0gPSBpdGVtOwoJbGlzdC0+bmJJdGVtcysrOwogICAgfQogICAgcmV0dXJuKDApOwp9CiNlbmRpZgoKc3RhdGljIGludAp4bWxTY2hlbWFJdGVtTGlzdFJlbW92ZSh4bWxTY2hlbWFJdGVtTGlzdFB0ciBsaXN0LCBpbnQgaWR4KQp7CiAgICBpbnQgaTsKICAgIGlmICgobGlzdC0+aXRlbXMgPT0gTlVMTCkgfHwgKGlkeCA+PSBsaXN0LT5uYkl0ZW1zKSkgewoJeG1sU2NoZW1hUFNpbXBsZUVycigiSW50ZXJuYWwgZXJyb3I6IHhtbFNjaGVtYUl0ZW1MaXN0UmVtb3ZlLCAiCgkgICAgImluZGV4IGVycm9yLlxuIik7CglyZXR1cm4oLTEpOwogICAgfQoKICAgIGlmIChsaXN0LT5uYkl0ZW1zID09IDEpIHsKCS8qIFRPRE86IFJlYWxseSBmcmVlIHRoZSBsaXN0PyAqLwoJeG1sRnJlZShsaXN0LT5pdGVtcyk7CglsaXN0LT5pdGVtcyA9IE5VTEw7CglsaXN0LT5uYkl0ZW1zID0gMDsKCWxpc3QtPnNpemVJdGVtcyA9IDA7CiAgICB9IGVsc2UgaWYgKGxpc3QtPm5iSXRlbXMgLTEgPT0gaWR4KSB7CglsaXN0LT5uYkl0ZW1zLS07CiAgICB9IGVsc2UgewkKCWZvciAoaSA9IGlkeDsgaSA8IGxpc3QtPm5iSXRlbXMgLTE7IGkrKykKCSAgICBsaXN0LT5pdGVtc1tpXSA9IGxpc3QtPml0ZW1zW2krMV07CglsaXN0LT5uYkl0ZW1zLS07CiAgICB9CiAgICByZXR1cm4oMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFJdGVtTGlzdEZyZWU6CiAqIEBhbm5vdDogIGEgc2NoZW1hIHR5cGUgc3RydWN0dXJlCiAqCiAqIERlYWxsb2NhdGUgYSBhbm5vdGF0aW9uIHN0cnVjdHVyZQogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hSXRlbUxpc3RGcmVlKHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QpCnsKICAgIGlmIChsaXN0ID09IE5VTEwpCglyZXR1cm47CiAgICBpZiAobGlzdC0+aXRlbXMgIT0gTlVMTCkKCXhtbEZyZWUobGlzdC0+aXRlbXMpOwogICAgeG1sRnJlZShsaXN0KTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hQnVja2V0RnJlZSh4bWxTY2hlbWFCdWNrZXRQdHIgYnVja2V0KQp7CiAgICBpZiAoYnVja2V0ID09IE5VTEwpCglyZXR1cm47CiAgICBpZiAoYnVja2V0LT5nbG9iYWxzICE9IE5VTEwpIHsKCXhtbFNjaGVtYUNvbXBvbmVudExpc3RGcmVlKGJ1Y2tldC0+Z2xvYmFscyk7Cgl4bWxTY2hlbWFJdGVtTGlzdEZyZWUoYnVja2V0LT5nbG9iYWxzKTsKICAgIH0KICAgIGlmIChidWNrZXQtPmxvY2FscyAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFDb21wb25lbnRMaXN0RnJlZShidWNrZXQtPmxvY2Fscyk7Cgl4bWxTY2hlbWFJdGVtTGlzdEZyZWUoYnVja2V0LT5sb2NhbHMpOwkKICAgIH0KICAgIGlmIChidWNrZXQtPnJlbGF0aW9ucyAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFTY2hlbWFSZWxhdGlvblB0ciBwcmV2LCBjdXIgPSBidWNrZXQtPnJlbGF0aW9uczsKCWRvIHsKCSAgICBwcmV2ID0gY3VyOwkgICAgCgkgICAgY3VyID0gY3VyLT5uZXh0OwoJICAgIHhtbEZyZWUocHJldik7Cgl9IHdoaWxlIChjdXIgIT0gTlVMTCk7CiAgICB9CiAgICBpZiAoKCEgYnVja2V0LT5wcmVzZXJ2ZURvYykgJiYgKGJ1Y2tldC0+ZG9jICE9IE5VTEwpKSB7Cgl4bWxGcmVlRG9jKGJ1Y2tldC0+ZG9jKTsKICAgIH0gCiAgICBpZiAoYnVja2V0LT50eXBlID09IFhNTF9TQ0hFTUFfU0NIRU1BX0lNUE9SVCkgewoJaWYgKFdYU19JTVBCVUNLRVQoYnVja2V0KS0+c2NoZW1hICE9IE5VTEwpCgkgICAgeG1sU2NoZW1hRnJlZShXWFNfSU1QQlVDS0VUKGJ1Y2tldCktPnNjaGVtYSk7CiAgICB9CiAgICB4bWxGcmVlKGJ1Y2tldCk7Cn0KCnN0YXRpYyB4bWxTY2hlbWFCdWNrZXRQdHIKeG1sU2NoZW1hQnVja2V0Q3JlYXRlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCSBpbnQgdHlwZSwgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TmFtZXNwYWNlKQp7CiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgcmV0OwogICAgaW50IHNpemU7CiAgICB4bWxTY2hlbWFQdHIgbWFpblNjaGVtYTsKCiAgICBpZiAoV1hTX0NPTlNUUlVDVE9SKHBjdHh0KS0+bWFpblNjaGVtYSA9PSBOVUxMKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFCdWNrZXRDcmVhdGUiLAoJICAgICJubyBtYWluIHNjaGVtYSBvbiBjb25zdHJ1Y3RvciIpOwoJcmV0dXJuKE5VTEwpOwogICAgfQogICAgbWFpblNjaGVtYSA9IFdYU19DT05TVFJVQ1RPUihwY3R4dCktPm1haW5TY2hlbWE7CiAgICAvKiBDcmVhdGUgdGhlIHNjaGVtYSBidWNrZXQuICovCiAgICBpZiAoV1hTX0lTX0JVQ0tFVF9JTkNSRURFRih0eXBlKSkKCXNpemUgPSBzaXplb2YoeG1sU2NoZW1hSW5jbHVkZSk7CiAgICBlbHNlCglzaXplID0gc2l6ZW9mKHhtbFNjaGVtYUltcG9ydCk7CiAgICByZXQgPSAoeG1sU2NoZW1hQnVja2V0UHRyKSB4bWxNYWxsb2Moc2l6ZSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwgImFsbG9jYXRpbmcgc2NoZW1hIGJ1Y2tldCIsIE5VTEwpOwoJcmV0dXJuKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZSk7CiAgICByZXQtPnRhcmdldE5hbWVzcGFjZSA9IHRhcmdldE5hbWVzcGFjZTsKICAgIHJldC0+dHlwZSA9IHR5cGU7CiAgICByZXQtPmdsb2JhbHMgPSB4bWxTY2hlbWFJdGVtTGlzdENyZWF0ZSgpOwogICAgaWYgKHJldC0+Z2xvYmFscyA9PSBOVUxMKSB7Cgl4bWxGcmVlKHJldCk7CglyZXR1cm4oTlVMTCk7CiAgICB9CiAgICByZXQtPmxvY2FscyA9IHhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKCk7CiAgICBpZiAocmV0LT5sb2NhbHMgPT0gTlVMTCkgewoJeG1sRnJlZShyZXQpOwoJcmV0dXJuKE5VTEwpOwogICAgfQogICAgLyogCiAgICAqIFRoZSBmb2xsb3dpbmcgd2lsbCBhc3N1cmUgdGhhdCBvbmx5IHRoZSBmaXJzdCBidWNrZXQgaXMgbWFya2VkIGFzCiAgICAqIFhNTF9TQ0hFTUFfU0NIRU1BX01BSU4gYW5kIGl0IHBvaW50cyB0byB0aGUgKm1haW4qIHNjaGVtYS4KICAgICogRm9yIGVhY2ggZm9sbG93aW5nIGltcG9ydCBidWNrZXRzIGFuIHhtbFNjaGVtYSB3aWxsIGJlIGNyZWF0ZWQuCiAgICAqLwogICAgaWYgKCEgV1hTX0hBU19CVUNLRVRTKHBjdHh0KSkgewoJaWYgKFdYU19JU19CVUNLRVRfSU5DUkVERUYodHlwZSkpIHsKCSAgICBQRVJST1JfSU5UKCJ4bWxTY2hlbWFCdWNrZXRDcmVhdGUiLAoJCSJmaXJzdCBidWNrZXQgYnV0IGl0J3MgYW4gaW5jbHVkZSBvciByZWRlZmluZSIpOwoJICAgIHhtbFNjaGVtYUJ1Y2tldEZyZWUocmV0KTsKCSAgICByZXR1cm4oTlVMTCk7Cgl9CgkvKiBGb3JjZSB0aGUgdHlwZSB0byBiZSBYTUxfU0NIRU1BX1NDSEVNQV9NQUlOLiAqLyAKCXJldC0+dHlwZSA9IFhNTF9TQ0hFTUFfU0NIRU1BX01BSU47CgkvKiBQb2ludCB0byB0aGUgKm1haW4qIHNjaGVtYS4gKi8KCVdYU19DT05TVFJVQ1RPUihwY3R4dCktPm1haW5CdWNrZXQgPSByZXQ7CglXWFNfSU1QQlVDS0VUKHJldCktPnNjaGVtYSA9IG1haW5TY2hlbWE7CiAgICB9IGVsc2UgewoJaWYgKHR5cGUgPT0gWE1MX1NDSEVNQV9TQ0hFTUFfTUFJTikgewkgICAgCgkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hQnVja2V0Q3JlYXRlIiwKCQkibWFpbiBidWNrZXQgYnV0IGl0J3Mgbm90IHRoZSBmaXJzdCBvbmUiKTsKCSAgICB4bWxTY2hlbWFCdWNrZXRGcmVlKHJldCk7CgkgICAgcmV0dXJuKE5VTEwpOwoJfSBlbHNlIGlmICh0eXBlID09IFhNTF9TQ0hFTUFfU0NIRU1BX0lNUE9SVCkgewkgICAgCgkgICAgLyoKCSAgICAqIENyZWF0ZSBhIHNjaGVtYSBmb3IgaW1wb3J0cy4KCSAgICAqLwoJICAgIFdYU19JTVBCVUNLRVQocmV0KS0+c2NoZW1hID0geG1sU2NoZW1hTmV3U2NoZW1hKHBjdHh0KTsKCSAgICBpZiAoV1hTX0lNUEJVQ0tFVChyZXQpLT5zY2hlbWEgPT0gTlVMTCkgewoJCXhtbFNjaGVtYUJ1Y2tldEZyZWUocmV0KTsKCQlyZXR1cm4oTlVMTCk7CgkgICAgfQoJfQogICAgfSAgICAKICAgIGlmIChXWFNfSVNfQlVDS0VUX0lNUE1BSU4odHlwZSkpIHsKCWludCByZXM7CgkvKiBJbXBvcnRzIGdvIGludG8gdGhlICJzY2hlbWFzSW1wb3J0cyIgc2xvdCBvZiB0aGUgbWFpbiAqc2NoZW1hKi4gKi8KCWlmIChtYWluU2NoZW1hLT5zY2hlbWFzSW1wb3J0cyA9PSBOVUxMKSB7CgkgICAgbWFpblNjaGVtYS0+c2NoZW1hc0ltcG9ydHMgPSB4bWxIYXNoQ3JlYXRlRGljdCg1LAoJCVdYU19DT05TVFJVQ1RPUihwY3R4dCktPmRpY3QpOwoJICAgIGlmIChtYWluU2NoZW1hLT5zY2hlbWFzSW1wb3J0cyA9PSBOVUxMKSB7CgkJeG1sU2NoZW1hQnVja2V0RnJlZShyZXQpOwoJCXJldHVybihOVUxMKTsKCSAgICB9Cgl9CglpZiAodGFyZ2V0TmFtZXNwYWNlID09IE5VTEwpCgkgICAgcmVzID0geG1sSGFzaEFkZEVudHJ5KG1haW5TY2hlbWEtPnNjaGVtYXNJbXBvcnRzLAoJCVhNTF9TQ0hFTUFTX05PX05BTUVTUEFDRSwgcmV0KTsKCWVsc2UKCSAgICByZXMgPSB4bWxIYXNoQWRkRW50cnkobWFpblNjaGVtYS0+c2NoZW1hc0ltcG9ydHMsCgkJdGFyZ2V0TmFtZXNwYWNlLCByZXQpOwoJaWYgKHJlcyAhPSAwKSB7CgkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hQnVja2V0Q3JlYXRlIiwKCQkiZmFpbGVkIHRvIGFkZCB0aGUgc2NoZW1hIGJ1Y2tldCB0byB0aGUgaGFzaCIpOwoJICAgIHhtbFNjaGVtYUJ1Y2tldEZyZWUocmV0KTsKCSAgICByZXR1cm4oTlVMTCk7Cgl9CiAgICB9IGVsc2UgewoJLyogU2V0IHRoZSBAb3duZXJJbXBvcnQgb2YgYW4gaW5jbHVkZSBidWNrZXQuICovCglpZiAoV1hTX0lTX0JVQ0tFVF9JTVBNQUlOKFdYU19DT05TVFJVQ1RPUihwY3R4dCktPmJ1Y2tldC0+dHlwZSkpCgkgICAgV1hTX0lOQ0JVQ0tFVChyZXQpLT5vd25lckltcG9ydCA9CgkJV1hTX0lNUEJVQ0tFVChXWFNfQ09OU1RSVUNUT1IocGN0eHQpLT5idWNrZXQpOwoJZWxzZQoJICAgIFdYU19JTkNCVUNLRVQocmV0KS0+b3duZXJJbXBvcnQgPQoJCVdYU19JTkNCVUNLRVQoV1hTX0NPTlNUUlVDVE9SKHBjdHh0KS0+YnVja2V0KS0+b3duZXJJbXBvcnQ7CgoJLyogSW5jbHVkZXMgZ290IGludG8gdGhlICJpbmNsdWRlcyIgc2xvdCBvZiB0aGUgKm1haW4qIHNjaGVtYS4gKi8KCWlmIChtYWluU2NoZW1hLT5pbmNsdWRlcyA9PSBOVUxMKSB7CgkgICAgbWFpblNjaGVtYS0+aW5jbHVkZXMgPSB4bWxTY2hlbWFJdGVtTGlzdENyZWF0ZSgpOwoJICAgIGlmIChtYWluU2NoZW1hLT5pbmNsdWRlcyA9PSBOVUxMKSB7CgkJeG1sU2NoZW1hQnVja2V0RnJlZShyZXQpOwoJCXJldHVybihOVUxMKTsKCSAgICB9CSAgICAKCX0KCXhtbFNjaGVtYUl0ZW1MaXN0QWRkKG1haW5TY2hlbWEtPmluY2x1ZGVzLCByZXQpOwogICAgfQogICAgLyogCiAgICAqIEFkZCB0byBsaXN0IG9mIGFsbCBidWNrZXRzOyB0aGlzIGlzIHVzZWQgZm9yIGxvb2t1cAogICAgKiBkdXJpbmcgc2NoZW1hIGNvbnN0cnVjdGlvbiB0aW1lIG9ubHkuCiAgICAqLwogICAgaWYgKHhtbFNjaGVtYUl0ZW1MaXN0QWRkKFdYU19DT05TVFJVQ1RPUihwY3R4dCktPmJ1Y2tldHMsIHJldCkgPT0gLTEpCglyZXR1cm4oTlVMTCk7CiAgICByZXR1cm4ocmV0KTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFBZGRJdGVtU2l6ZSh4bWxTY2hlbWFJdGVtTGlzdFB0ciAqbGlzdCwgaW50IGluaXRpYWxTaXplLCB2b2lkICppdGVtKQp7CiAgICBpZiAoKmxpc3QgPT0gTlVMTCkgewoJKmxpc3QgPSB4bWxTY2hlbWFJdGVtTGlzdENyZWF0ZSgpOwoJaWYgKCpsaXN0ID09IE5VTEwpCgkgICAgcmV0dXJuKC0xKTsKICAgIH0KICAgIHhtbFNjaGVtYUl0ZW1MaXN0QWRkU2l6ZSgqbGlzdCwgaW5pdGlhbFNpemUsIGl0ZW0pOwogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hRnJlZUFubm90OgogKiBAYW5ub3Q6ICBhIHNjaGVtYSB0eXBlIHN0cnVjdHVyZQogKgogKiBEZWFsbG9jYXRlIGEgYW5ub3RhdGlvbiBzdHJ1Y3R1cmUKICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZyZWVBbm5vdCh4bWxTY2hlbWFBbm5vdFB0ciBhbm5vdCkKewogICAgaWYgKGFubm90ID09IE5VTEwpCiAgICAgICAgcmV0dXJuOwogICAgaWYgKGFubm90LT5uZXh0ID09IE5VTEwpIHsKCXhtbEZyZWUoYW5ub3QpOwogICAgfSBlbHNlIHsKCXhtbFNjaGVtYUFubm90UHRyIHByZXY7CgoJZG8gewoJICAgIHByZXYgPSBhbm5vdDsKCSAgICBhbm5vdCA9IGFubm90LT5uZXh0OwoJICAgIHhtbEZyZWUocHJldik7Cgl9IHdoaWxlIChhbm5vdCAhPSBOVUxMKTsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUZyZWVOb3RhdGlvbjoKICogQHNjaGVtYTogIGEgc2NoZW1hIG5vdGF0aW9uIHN0cnVjdHVyZQogKgogKiBEZWFsbG9jYXRlIGEgU2NoZW1hIE5vdGF0aW9uIHN0cnVjdHVyZS4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZyZWVOb3RhdGlvbih4bWxTY2hlbWFOb3RhdGlvblB0ciBub3RhKQp7CiAgICBpZiAobm90YSA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIHhtbEZyZWUobm90YSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlQXR0cmlidXRlOgogKiBAYXR0cjogIGFuIGF0dHJpYnV0ZSBkZWNsYXJhdGlvbgogKgogKiBEZWFsbG9jYXRlcyBhbiBhdHRyaWJ1dGUgZGVjbGFyYXRpb24gc3RydWN0dXJlLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hRnJlZUF0dHJpYnV0ZSh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgYXR0cikKewogICAgaWYgKGF0dHIgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoYXR0ci0+YW5ub3QgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVBbm5vdChhdHRyLT5hbm5vdCk7CiAgICBpZiAoYXR0ci0+ZGVmVmFsICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlVmFsdWUoYXR0ci0+ZGVmVmFsKTsKICAgIHhtbEZyZWUoYXR0cik7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlQXR0cmlidXRlVXNlOgogKiBAdXNlOiAgYW4gYXR0cmlidXRlIHVzZQogKgogKiBEZWFsbG9jYXRlcyBhbiBhdHRyaWJ1dGUgdXNlIHN0cnVjdHVyZS4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZyZWVBdHRyaWJ1dGVVc2UoeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIHVzZSkKewogICAgaWYgKHVzZSA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIGlmICh1c2UtPmFubm90ICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlQW5ub3QodXNlLT5hbm5vdCk7CiAgICBpZiAodXNlLT5kZWZWYWwgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVWYWx1ZSh1c2UtPmRlZlZhbCk7CiAgICB4bWxGcmVlKHVzZSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlQXR0cmlidXRlVXNlUHJvaGliOgogKiBAcHJvaGliOiAgYW4gYXR0cmlidXRlIHVzZSBwcm9oaWJpdGlvbgogKgogKiBEZWFsbG9jYXRlcyBhbiBhdHRyaWJ1dGUgdXNlIHN0cnVjdHVyZS4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZyZWVBdHRyaWJ1dGVVc2VQcm9oaWIoeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliUHRyIHByb2hpYikKewogICAgaWYgKHByb2hpYiA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIHhtbEZyZWUocHJvaGliKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUZyZWVXaWxkY2FyZE5zU2V0OgogKiBzZXQ6ICBhIHNjaGVtYSB3aWxkY2FyZCBuYW1lc3BhY2UKICoKICogRGVhbGxvY2F0ZXMgYSBsaXN0IG9mIHdpbGRjYXJkIGNvbnN0cmFpbnQgc3RydWN0dXJlcy4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZyZWVXaWxkY2FyZE5zU2V0KHhtbFNjaGVtYVdpbGRjYXJkTnNQdHIgc2V0KQp7CiAgICB4bWxTY2hlbWFXaWxkY2FyZE5zUHRyIG5leHQ7CgogICAgd2hpbGUgKHNldCAhPSBOVUxMKSB7CgluZXh0ID0gc2V0LT5uZXh0OwoJeG1sRnJlZShzZXQpOwoJc2V0ID0gbmV4dDsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUZyZWVXaWxkY2FyZDoKICogQHdpbGRjYXJkOiAgYSB3aWxkY2FyZCBzdHJ1Y3R1cmUKICoKICogRGVhbGxvY2F0ZXMgYSB3aWxkY2FyZCBzdHJ1Y3R1cmUuCiAqLwp2b2lkCnhtbFNjaGVtYUZyZWVXaWxkY2FyZCh4bWxTY2hlbWFXaWxkY2FyZFB0ciB3aWxkY2FyZCkKewogICAgaWYgKHdpbGRjYXJkID09IE5VTEwpCiAgICAgICAgcmV0dXJuOwogICAgaWYgKHdpbGRjYXJkLT5hbm5vdCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYUZyZWVBbm5vdCh3aWxkY2FyZC0+YW5ub3QpOwogICAgaWYgKHdpbGRjYXJkLT5uc1NldCAhPSBOVUxMKQoJeG1sU2NoZW1hRnJlZVdpbGRjYXJkTnNTZXQod2lsZGNhcmQtPm5zU2V0KTsKICAgIGlmICh3aWxkY2FyZC0+bmVnTnNTZXQgIT0gTlVMTCkKCXhtbEZyZWUod2lsZGNhcmQtPm5lZ05zU2V0KTsKICAgIHhtbEZyZWUod2lsZGNhcmQpOwp9CgovKioKICogeG1sU2NoZW1hRnJlZUF0dHJpYnV0ZUdyb3VwOgogKiBAc2NoZW1hOiAgYSBzY2hlbWEgYXR0cmlidXRlIGdyb3VwIHN0cnVjdHVyZQogKgogKiBEZWFsbG9jYXRlIGEgU2NoZW1hIEF0dHJpYnV0ZSBHcm91cCBzdHJ1Y3R1cmUuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFGcmVlQXR0cmlidXRlR3JvdXAoeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIgYXR0ckdyKQp7CiAgICBpZiAoYXR0ckdyID09IE5VTEwpCiAgICAgICAgcmV0dXJuOwogICAgaWYgKGF0dHJHci0+YW5ub3QgIT0gTlVMTCkKICAgICAgICB4bWxTY2hlbWFGcmVlQW5ub3QoYXR0ckdyLT5hbm5vdCk7CiAgICBpZiAoYXR0ckdyLT5hdHRyVXNlcyAhPSBOVUxMKQoJeG1sU2NoZW1hSXRlbUxpc3RGcmVlKFdYU19MSVNUX0NBU1QgYXR0ckdyLT5hdHRyVXNlcyk7CiAgICB4bWxGcmVlKGF0dHJHcik7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlUU5hbWVSZWY6CiAqIEBpdGVtOiBhIFFOYW1lIHJlZmVyZW5jZSBzdHJ1Y3R1cmUKICoKICogRGVhbGxvY2F0ZWEgYSBRTmFtZSByZWZlcmVuY2Ugc3RydWN0dXJlLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hRnJlZVFOYW1lUmVmKHhtbFNjaGVtYVFOYW1lUmVmUHRyIGl0ZW0pCnsKICAgIHhtbEZyZWUoaXRlbSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlVHlwZUxpbmtMaXN0OgogKiBAYWxpbms6IGEgdHlwZSBsaW5rCiAqCiAqIERlYWxsb2NhdGUgYSBsaXN0IG9mIHR5cGVzLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hRnJlZVR5cGVMaW5rTGlzdCh4bWxTY2hlbWFUeXBlTGlua1B0ciBsaW5rKQp7CiAgICB4bWxTY2hlbWFUeXBlTGlua1B0ciBuZXh0OwoKICAgIHdoaWxlIChsaW5rICE9IE5VTEwpIHsKCW5leHQgPSBsaW5rLT5uZXh0OwoJeG1sRnJlZShsaW5rKTsKCWxpbmsgPSBuZXh0OwogICAgfQp9CgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFGcmVlSURDU3RhdGVPYmpMaXN0KHhtbFNjaGVtYUlEQ1N0YXRlT2JqUHRyIHN0bykKewogICAgeG1sU2NoZW1hSURDU3RhdGVPYmpQdHIgbmV4dDsKICAgIHdoaWxlIChzdG8gIT0gTlVMTCkgewoJbmV4dCA9IHN0by0+bmV4dDsKCWlmIChzdG8tPmhpc3RvcnkgIT0gTlVMTCkKCSAgICB4bWxGcmVlKHN0by0+aGlzdG9yeSk7CglpZiAoc3RvLT54cGF0aEN0eHQgIT0gTlVMTCkKCSAgICB4bWxGcmVlU3RyZWFtQ3R4dCgoeG1sU3RyZWFtQ3R4dFB0cikgc3RvLT54cGF0aEN0eHQpOwoJeG1sRnJlZShzdG8pOwoJc3RvID0gbmV4dDsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUZyZWVJREM6CiAqIEBpZGM6IGEgaWRlbnRpdHktY29uc3RyYWludCBkZWZpbml0aW9uCiAqCiAqIERlYWxsb2NhdGVzIGFuIGlkZW50aXR5LWNvbnN0cmFpbnQgZGVmaW5pdGlvbi4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUZyZWVJREMoeG1sU2NoZW1hSURDUHRyIGlkY0RlZikKewogICAgeG1sU2NoZW1hSURDU2VsZWN0UHRyIGN1ciwgcHJldjsKCiAgICBpZiAoaWRjRGVmID09IE5VTEwpCglyZXR1cm47CiAgICBpZiAoaWRjRGVmLT5hbm5vdCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYUZyZWVBbm5vdChpZGNEZWYtPmFubm90KTsKICAgIC8qIFNlbGVjdG9yICovCiAgICBpZiAoaWRjRGVmLT5zZWxlY3RvciAhPSBOVUxMKSB7CglpZiAoaWRjRGVmLT5zZWxlY3Rvci0+eHBhdGhDb21wICE9IE5VTEwpCgkgICAgeG1sRnJlZVBhdHRlcm4oKHhtbFBhdHRlcm5QdHIpIGlkY0RlZi0+c2VsZWN0b3ItPnhwYXRoQ29tcCk7Cgl4bWxGcmVlKGlkY0RlZi0+c2VsZWN0b3IpOwogICAgfQogICAgLyogRmllbGRzICovCiAgICBpZiAoaWRjRGVmLT5maWVsZHMgIT0gTlVMTCkgewoJY3VyID0gaWRjRGVmLT5maWVsZHM7CglkbyB7CgkgICAgcHJldiA9IGN1cjsKCSAgICBjdXIgPSBjdXItPm5leHQ7CgkgICAgaWYgKHByZXYtPnhwYXRoQ29tcCAhPSBOVUxMKQoJCXhtbEZyZWVQYXR0ZXJuKCh4bWxQYXR0ZXJuUHRyKSBwcmV2LT54cGF0aENvbXApOwoJICAgIHhtbEZyZWUocHJldik7Cgl9IHdoaWxlIChjdXIgIT0gTlVMTCk7CiAgICB9CiAgICB4bWxGcmVlKGlkY0RlZik7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlRWxlbWVudDoKICogQHNjaGVtYTogIGEgc2NoZW1hIGVsZW1lbnQgc3RydWN0dXJlCiAqCiAqIERlYWxsb2NhdGUgYSBTY2hlbWEgRWxlbWVudCBzdHJ1Y3R1cmUuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFGcmVlRWxlbWVudCh4bWxTY2hlbWFFbGVtZW50UHRyIGVsZW0pCnsKICAgIGlmIChlbGVtID09IE5VTEwpCiAgICAgICAgcmV0dXJuOwogICAgaWYgKGVsZW0tPmFubm90ICE9IE5VTEwpCiAgICAgICAgeG1sU2NoZW1hRnJlZUFubm90KGVsZW0tPmFubm90KTsKICAgIGlmIChlbGVtLT5jb250TW9kZWwgIT0gTlVMTCkKICAgICAgICB4bWxSZWdGcmVlUmVnZXhwKGVsZW0tPmNvbnRNb2RlbCk7CiAgICBpZiAoZWxlbS0+ZGVmVmFsICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlVmFsdWUoZWxlbS0+ZGVmVmFsKTsKICAgIHhtbEZyZWUoZWxlbSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFGcmVlRmFjZXQ6CiAqIEBmYWNldDogIGEgc2NoZW1hIGZhY2V0IHN0cnVjdHVyZQogKgogKiBEZWFsbG9jYXRlIGEgU2NoZW1hIEZhY2V0IHN0cnVjdHVyZS4KICovCnZvaWQKeG1sU2NoZW1hRnJlZUZhY2V0KHhtbFNjaGVtYUZhY2V0UHRyIGZhY2V0KQp7CiAgICBpZiAoZmFjZXQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoZmFjZXQtPnZhbCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYUZyZWVWYWx1ZShmYWNldC0+dmFsKTsKICAgIGlmIChmYWNldC0+cmVnZXhwICE9IE5VTEwpCiAgICAgICAgeG1sUmVnRnJlZVJlZ2V4cChmYWNldC0+cmVnZXhwKTsKICAgIGlmIChmYWNldC0+YW5ub3QgIT0gTlVMTCkKICAgICAgICB4bWxTY2hlbWFGcmVlQW5ub3QoZmFjZXQtPmFubm90KTsKICAgIHhtbEZyZWUoZmFjZXQpOwp9CgovKioKICogeG1sU2NoZW1hRnJlZVR5cGU6CiAqIEB0eXBlOiAgYSBzY2hlbWEgdHlwZSBzdHJ1Y3R1cmUKICoKICogRGVhbGxvY2F0ZSBhIFNjaGVtYSBUeXBlIHN0cnVjdHVyZS4KICovCnZvaWQKeG1sU2NoZW1hRnJlZVR5cGUoeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICBpZiAodHlwZSA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIGlmICh0eXBlLT5hbm5vdCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYUZyZWVBbm5vdCh0eXBlLT5hbm5vdCk7CiAgICBpZiAodHlwZS0+ZmFjZXRzICE9IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFGYWNldFB0ciBmYWNldCwgbmV4dDsKCiAgICAgICAgZmFjZXQgPSB0eXBlLT5mYWNldHM7CiAgICAgICAgd2hpbGUgKGZhY2V0ICE9IE5VTEwpIHsKICAgICAgICAgICAgbmV4dCA9IGZhY2V0LT5uZXh0OwogICAgICAgICAgICB4bWxTY2hlbWFGcmVlRmFjZXQoZmFjZXQpOwogICAgICAgICAgICBmYWNldCA9IG5leHQ7CiAgICAgICAgfQogICAgfQogICAgaWYgKHR5cGUtPmF0dHJVc2VzICE9IE5VTEwpCgl4bWxTY2hlbWFJdGVtTGlzdEZyZWUoKHhtbFNjaGVtYUl0ZW1MaXN0UHRyKSB0eXBlLT5hdHRyVXNlcyk7CiAgICBpZiAodHlwZS0+bWVtYmVyVHlwZXMgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVUeXBlTGlua0xpc3QodHlwZS0+bWVtYmVyVHlwZXMpOwogICAgaWYgKHR5cGUtPmZhY2V0U2V0ICE9IE5VTEwpIHsKCXhtbFNjaGVtYUZhY2V0TGlua1B0ciBuZXh0LCBsaW5rOwoKCWxpbmsgPSB0eXBlLT5mYWNldFNldDsKCWRvIHsKCSAgICBuZXh0ID0gbGluay0+bmV4dDsKCSAgICB4bWxGcmVlKGxpbmspOwoJICAgIGxpbmsgPSBuZXh0OwoJfSB3aGlsZSAobGluayAhPSBOVUxMKTsKICAgIH0KICAgIGlmICh0eXBlLT5jb250TW9kZWwgIT0gTlVMTCkKICAgICAgICB4bWxSZWdGcmVlUmVnZXhwKHR5cGUtPmNvbnRNb2RlbCk7CiAgICB4bWxGcmVlKHR5cGUpOwp9CgovKioKICogeG1sU2NoZW1hRnJlZU1vZGVsR3JvdXBEZWY6CiAqIEBpdGVtOiAgYSBzY2hlbWEgbW9kZWwgZ3JvdXAgZGVmaW5pdGlvbgogKgogKiBEZWFsbG9jYXRlcyBhIHNjaGVtYSBtb2RlbCBncm91cCBkZWZpbml0aW9uLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hRnJlZU1vZGVsR3JvdXBEZWYoeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0ciBpdGVtKQp7CiAgICBpZiAoaXRlbS0+YW5ub3QgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVBbm5vdChpdGVtLT5hbm5vdCk7CiAgICB4bWxGcmVlKGl0ZW0pOwp9CgovKioKICogeG1sU2NoZW1hRnJlZU1vZGVsR3JvdXA6CiAqIEBpdGVtOiAgYSBzY2hlbWEgbW9kZWwgZ3JvdXAKICoKICogRGVhbGxvY2F0ZXMgYSBzY2hlbWEgbW9kZWwgZ3JvdXAgc3RydWN0dXJlLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hRnJlZU1vZGVsR3JvdXAoeG1sU2NoZW1hTW9kZWxHcm91cFB0ciBpdGVtKQp7CiAgICBpZiAoaXRlbS0+YW5ub3QgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVBbm5vdChpdGVtLT5hbm5vdCk7CiAgICB4bWxGcmVlKGl0ZW0pOwp9CgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDb21wb25lbnRMaXN0RnJlZSh4bWxTY2hlbWFJdGVtTGlzdFB0ciBsaXN0KQp7CiAgICBpZiAoKGxpc3QgPT0gTlVMTCkgfHwgKGxpc3QtPm5iSXRlbXMgPT0gMCkpCglyZXR1cm47CiAgICB7Cgl4bWxTY2hlbWFUcmVlSXRlbVB0ciBpdGVtOwoJeG1sU2NoZW1hVHJlZUl0ZW1QdHIgKml0ZW1zID0gKHhtbFNjaGVtYVRyZWVJdGVtUHRyICopIGxpc3QtPml0ZW1zOwoJaW50IGk7CgoJZm9yIChpID0gMDsgaSA8IGxpc3QtPm5iSXRlbXM7IGkrKykgewoJICAgIGl0ZW0gPSBpdGVtc1tpXTsKCSAgICBpZiAoaXRlbSA9PSBOVUxMKQoJCWNvbnRpbnVlOwkgICAgCgkgICAgc3dpdGNoIChpdGVtLT50eXBlKSB7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVg6CgkJICAgIHhtbFNjaGVtYUZyZWVUeXBlKCh4bWxTY2hlbWFUeXBlUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFOgoJCSAgICB4bWxTY2hlbWFGcmVlQXR0cmlidXRlKCh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIpIGl0ZW0pOwoJCSAgICBicmVhazsKCQljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVfVVNFOgoJCSAgICB4bWxTY2hlbWFGcmVlQXR0cmlidXRlVXNlKCh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIpIGl0ZW0pOwoJCSAgICBicmVhazsKCQljYXNlIFhNTF9TQ0hFTUFfRVhUUkFfQVRUUl9VU0VfUFJPSElCOgoJCSAgICB4bWxTY2hlbWFGcmVlQXR0cmlidXRlVXNlUHJvaGliKAoJCQkoeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfRUxFTUVOVDoKCQkgICAgeG1sU2NoZW1hRnJlZUVsZW1lbnQoKHhtbFNjaGVtYUVsZW1lbnRQdHIpIGl0ZW0pOwoJCSAgICBicmVhazsKCQljYXNlIFhNTF9TQ0hFTUFfVFlQRV9QQVJUSUNMRToKCQkgICAgaWYgKGl0ZW0tPmFubm90ICE9IE5VTEwpCgkJCXhtbFNjaGVtYUZyZWVBbm5vdChpdGVtLT5hbm5vdCk7CgkJICAgIHhtbEZyZWUoaXRlbSk7CgkJICAgIGJyZWFrOwoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFOgoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0NIT0lDRToKCQljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTEw6CgkJICAgIHhtbFNjaGVtYUZyZWVNb2RlbEdyb3VwKCh4bWxTY2hlbWFNb2RlbEdyb3VwUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVA6CgkJICAgIHhtbFNjaGVtYUZyZWVBdHRyaWJ1dGVHcm91cCgKCQkJKHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkJICAgIHhtbFNjaGVtYUZyZWVNb2RlbEdyb3VwRGVmKAoJCQkoeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cikgaXRlbSk7CgkJICAgIGJyZWFrOwoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FOWToKCQljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTllfQVRUUklCVVRFOgoJCSAgICB4bWxTY2hlbWFGcmVlV2lsZGNhcmQoKHhtbFNjaGVtYVdpbGRjYXJkUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWToKCQljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfVU5JUVVFOgoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUY6CgkJICAgIHhtbFNjaGVtYUZyZWVJREMoKHhtbFNjaGVtYUlEQ1B0cikgaXRlbSk7CgkJICAgIGJyZWFrOwoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX05PVEFUSU9OOgoJCSAgICB4bWxTY2hlbWFGcmVlTm90YXRpb24oKHhtbFNjaGVtYU5vdGF0aW9uUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX0VYVFJBX1FOQU1FUkVGOgoJCSAgICB4bWxTY2hlbWFGcmVlUU5hbWVSZWYoKHhtbFNjaGVtYVFOYW1lUmVmUHRyKSBpdGVtKTsKCQkgICAgYnJlYWs7CgkJZGVmYXVsdDogewoJCSAgICAvKiBUT0RPOiBUaGlzIHNob3VsZCBuZXZlciBiZSBoaXQuICovCgkJICAgIHhtbFNjaGVtYVBTaW1wbGVJbnRlcm5hbEVycihOVUxMLAoJCQkiSW50ZXJuYWwgZXJyb3I6IHhtbFNjaGVtYUNvbXBvbmVudExpc3RGcmVlLCAiCgkJCSJ1bmV4cGVjdGVkIGNvbXBvbmVudCB0eXBlICclcydcbiIsCgkJCShjb25zdCB4bWxDaGFyICopIFdYU19JVEVNX1RZUEVfTkFNRShpdGVtKSk7CgkJCSB9CgkJICAgIGJyZWFrOwoJICAgIH0KCX0KCWxpc3QtPm5iSXRlbXMgPSAwOwogICAgfQp9CgovKioKICogeG1sU2NoZW1hRnJlZToKICogQHNjaGVtYTogIGEgc2NoZW1hIHN0cnVjdHVyZQogKgogKiBEZWFsbG9jYXRlIGEgU2NoZW1hIHN0cnVjdHVyZS4KICovCnZvaWQKeG1sU2NoZW1hRnJlZSh4bWxTY2hlbWFQdHIgc2NoZW1hKQp7CiAgICBpZiAoc2NoZW1hID09IE5VTEwpCiAgICAgICAgcmV0dXJuOwogICAgLyogQHZvbGF0aWxlcyBpcyBub3QgdXNlZCBhbnltb3JlIDotLyAqLwogICAgaWYgKHNjaGVtYS0+dm9sYXRpbGVzICE9IE5VTEwpCglUT0RPCiAgICAvKgogICAgKiBOb3RlIHRoYXQgdGhvc2Ugc2xvdHMgYXJlIG5vdCByZXNwb25zaWJsZSBmb3IgZnJlZWluZwogICAgKiBzY2hlbWEgY29tcG9uZW50cyBhbnltb3JlOyB0aGlzIHdpbGwgbm93IGJlIGRvbmUgYnkKICAgICogdGhlIHNjaGVtYSBidWNrZXRzLgogICAgKi8KICAgIGlmIChzY2hlbWEtPm5vdGFEZWNsICE9IE5VTEwpCiAgICAgICAgeG1sSGFzaEZyZWUoc2NoZW1hLT5ub3RhRGVjbCwgTlVMTCk7CiAgICBpZiAoc2NoZW1hLT5hdHRyRGVjbCAhPSBOVUxMKQogICAgICAgIHhtbEhhc2hGcmVlKHNjaGVtYS0+YXR0ckRlY2wsIE5VTEwpOwogICAgaWYgKHNjaGVtYS0+YXR0cmdycERlY2wgIT0gTlVMTCkKICAgICAgICB4bWxIYXNoRnJlZShzY2hlbWEtPmF0dHJncnBEZWNsLCBOVUxMKTsKICAgIGlmIChzY2hlbWEtPmVsZW1EZWNsICE9IE5VTEwpCiAgICAgICAgeG1sSGFzaEZyZWUoc2NoZW1hLT5lbGVtRGVjbCwgTlVMTCk7CiAgICBpZiAoc2NoZW1hLT50eXBlRGVjbCAhPSBOVUxMKQogICAgICAgIHhtbEhhc2hGcmVlKHNjaGVtYS0+dHlwZURlY2wsIE5VTEwpOwogICAgaWYgKHNjaGVtYS0+Z3JvdXBEZWNsICE9IE5VTEwpCiAgICAgICAgeG1sSGFzaEZyZWUoc2NoZW1hLT5ncm91cERlY2wsIE5VTEwpOwogICAgaWYgKHNjaGVtYS0+aWRjRGVmICE9IE5VTEwpCiAgICAgICAgeG1sSGFzaEZyZWUoc2NoZW1hLT5pZGNEZWYsIE5VTEwpOwoKICAgIGlmIChzY2hlbWEtPnNjaGVtYXNJbXBvcnRzICE9IE5VTEwpCgl4bWxIYXNoRnJlZShzY2hlbWEtPnNjaGVtYXNJbXBvcnRzLAoJCSAgICAoeG1sSGFzaERlYWxsb2NhdG9yKSB4bWxTY2hlbWFCdWNrZXRGcmVlKTsKICAgIGlmIChzY2hlbWEtPmluY2x1ZGVzICE9IE5VTEwpIHsKCXhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QgPSAoeG1sU2NoZW1hSXRlbUxpc3RQdHIpIHNjaGVtYS0+aW5jbHVkZXM7CglpbnQgaTsKCWZvciAoaSA9IDA7IGkgPCBsaXN0LT5uYkl0ZW1zOyBpKyspIHsKCSAgICB4bWxTY2hlbWFCdWNrZXRGcmVlKCh4bWxTY2hlbWFCdWNrZXRQdHIpIGxpc3QtPml0ZW1zW2ldKTsJCgl9Cgl4bWxTY2hlbWFJdGVtTGlzdEZyZWUobGlzdCk7CiAgICB9CiAgICBpZiAoc2NoZW1hLT5hbm5vdCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYUZyZWVBbm5vdChzY2hlbWEtPmFubm90KTsKICAgIC8qIE5ldmVyIGZyZWUgdGhlIGRvYyBoZXJlLCBzaW5jZSB0aGlzIHdpbGwgYmUgZG9uZSBieSB0aGUgYnVja2V0cy4gKi8KCiAgICB4bWxEaWN0RnJlZShzY2hlbWEtPmRpY3QpOwogICAgeG1sRnJlZShzY2hlbWEpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQkJCQkJCSoKICogCQkJRGVidWcgZnVuY3Rpb25zCQkJCQkqCiAqIAkJCQkJCQkJCSoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCiNpZmRlZiBMSUJYTUxfT1VUUFVUX0VOQUJMRUQKCnN0YXRpYyB2b2lkCnhtbFNjaGVtYVR5cGVEdW1wKHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwgRklMRSAqIG91dHB1dCk7IC8qIGZvcndhcmQgKi8KCi8qKgogKiB4bWxTY2hlbWFFbGVtZW50RHVtcDoKICogQGVsZW06ICBhbiBlbGVtZW50CiAqIEBvdXRwdXQ6ICB0aGUgZmlsZSBvdXRwdXQKICoKICogRHVtcCB0aGUgZWxlbWVudAogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hRWxlbWVudER1bXAoeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtLCBGSUxFICogb3V0cHV0LAogICAgICAgICAgICAgICAgICAgICBjb25zdCB4bWxDaGFyICogbmFtZSBBVFRSSUJVVEVfVU5VU0VELAoJCSAgICAgY29uc3QgeG1sQ2hhciAqIG5hbWVzcGFjZSBBVFRSSUJVVEVfVU5VU0VELAogICAgICAgICAgICAgICAgICAgICBjb25zdCB4bWxDaGFyICogY29udGV4dCBBVFRSSUJVVEVfVU5VU0VEKQp7CiAgICBpZiAoZWxlbSA9PSBOVUxMKQogICAgICAgIHJldHVybjsKCgogICAgZnByaW50ZihvdXRwdXQsICJFbGVtZW50Iik7CiAgICBpZiAoZWxlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0dMT0JBTCkKCWZwcmludGYob3V0cHV0LCAiIChnbG9iYWwpIik7CiAgICBmcHJpbnRmKG91dHB1dCwgIjogJyVzJyAiLCBlbGVtLT5uYW1lKTsKICAgIGlmIChuYW1lc3BhY2UgIT0gTlVMTCkKCWZwcmludGYob3V0cHV0LCAibnMgJyVzJyIsIG5hbWVzcGFjZSk7CiAgICBmcHJpbnRmKG91dHB1dCwgIlxuIik7CiNpZiAwCiAgICBpZiAoKGVsZW0tPm1pbk9jY3VycyAhPSAxKSB8fCAoZWxlbS0+bWF4T2NjdXJzICE9IDEpKSB7CglmcHJpbnRmKG91dHB1dCwgIiAgbWluICVkICIsIGVsZW0tPm1pbk9jY3Vycyk7CiAgICAgICAgaWYgKGVsZW0tPm1heE9jY3VycyA+PSBVTkJPVU5ERUQpCiAgICAgICAgICAgIGZwcmludGYob3V0cHV0LCAibWF4OiB1bmJvdW5kZWRcbiIpOwogICAgICAgIGVsc2UgaWYgKGVsZW0tPm1heE9jY3VycyAhPSAxKQogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIm1heDogJWRcbiIsIGVsZW0tPm1heE9jY3Vycyk7CiAgICAgICAgZWxzZQogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIlxuIik7CiAgICB9CiNlbmRpZgogICAgLyoKICAgICogTWlzYyBvdGhlciBwcm9wZXJ0aWVzLgogICAgKi8KICAgIGlmICgoZWxlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX05JTExBQkxFKSB8fAoJKGVsZW0tPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9BQlNUUkFDVCkgfHwKCShlbGVtLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fRklYRUQpIHx8CgkoZWxlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0RFRkFVTFQpKSB7CglmcHJpbnRmKG91dHB1dCwgIiAgcHJvcHM6ICIpOwoJaWYgKGVsZW0tPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9GSVhFRCkKCSAgICBmcHJpbnRmKG91dHB1dCwgIltmaXhlZF0gIik7CglpZiAoZWxlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0RFRkFVTFQpCgkgICAgZnByaW50ZihvdXRwdXQsICJbZGVmYXVsdF0gIik7CglpZiAoZWxlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0FCU1RSQUNUKQoJICAgIGZwcmludGYob3V0cHV0LCAiW2Fic3RyYWN0XSAiKTsKCWlmIChlbGVtLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fTklMTEFCTEUpCgkgICAgZnByaW50ZihvdXRwdXQsICJbbmlsbGFibGVdICIpOwoJZnByaW50ZihvdXRwdXQsICJcbiIpOwogICAgfQogICAgLyoKICAgICogRGVmYXVsdC9maXhlZCB2YWx1ZS4KICAgICovCiAgICBpZiAoZWxlbS0+dmFsdWUgIT0gTlVMTCkKCWZwcmludGYob3V0cHV0LCAiICB2YWx1ZTogJyVzJ1xuIiwgZWxlbS0+dmFsdWUpOwogICAgLyoKICAgICogVHlwZS4KICAgICovCiAgICBpZiAoZWxlbS0+bmFtZWRUeXBlICE9IE5VTEwpIHsKCWZwcmludGYob3V0cHV0LCAiICB0eXBlOiAnJXMnICIsIGVsZW0tPm5hbWVkVHlwZSk7CglpZiAoZWxlbS0+bmFtZWRUeXBlTnMgIT0gTlVMTCkKCSAgICBmcHJpbnRmKG91dHB1dCwgIm5zICclcydcbiIsIGVsZW0tPm5hbWVkVHlwZU5zKTsKCWVsc2UKCSAgICBmcHJpbnRmKG91dHB1dCwgIlxuIik7CiAgICB9IGVsc2UgaWYgKGVsZW0tPnN1YnR5cGVzICE9IE5VTEwpIHsKCS8qCgkqIER1bXAgbG9jYWwgdHlwZXMuCgkqLwoJeG1sU2NoZW1hVHlwZUR1bXAoZWxlbS0+c3VidHlwZXMsIG91dHB1dCk7CiAgICB9CiAgICAvKgogICAgKiBTdWJzdGl0dXRpb24gZ3JvdXAuCiAgICAqLwogICAgaWYgKGVsZW0tPnN1YnN0R3JvdXAgIT0gTlVMTCkgewoJZnByaW50ZihvdXRwdXQsICIgIHN1YnN0aXR1dGlvbkdyb3VwOiAnJXMnICIsIGVsZW0tPnN1YnN0R3JvdXApOwoJaWYgKGVsZW0tPnN1YnN0R3JvdXBOcyAhPSBOVUxMKQoJICAgIGZwcmludGYob3V0cHV0LCAibnMgJyVzJ1xuIiwgZWxlbS0+c3Vic3RHcm91cE5zKTsKCWVsc2UKCSAgICBmcHJpbnRmKG91dHB1dCwgIlxuIik7CiAgICB9Cn0KCi8qKgogKiB4bWxTY2hlbWFBbm5vdER1bXA6CiAqIEBvdXRwdXQ6ICB0aGUgZmlsZSBvdXRwdXQKICogQGFubm90OiAgYSBhbm5vdGF0aW9uCiAqCiAqIER1bXAgdGhlIGFubm90YXRpb24KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUFubm90RHVtcChGSUxFICogb3V0cHV0LCB4bWxTY2hlbWFBbm5vdFB0ciBhbm5vdCkKewogICAgeG1sQ2hhciAqY29udGVudDsKCiAgICBpZiAoYW5ub3QgPT0gTlVMTCkKICAgICAgICByZXR1cm47CgogICAgY29udGVudCA9IHhtbE5vZGVHZXRDb250ZW50KGFubm90LT5jb250ZW50KTsKICAgIGlmIChjb250ZW50ICE9IE5VTEwpIHsKICAgICAgICBmcHJpbnRmKG91dHB1dCwgIiAgQW5ub3Q6ICVzXG4iLCBjb250ZW50KTsKICAgICAgICB4bWxGcmVlKGNvbnRlbnQpOwogICAgfSBlbHNlCiAgICAgICAgZnByaW50ZihvdXRwdXQsICIgIEFubm90OiBlbXB0eVxuIik7Cn0KCi8qKgogKiB4bWxTY2hlbWFDb250ZW50TW9kZWxEdW1wOgogKiBAcGFydGljbGU6IHRoZSBzY2hlbWEgcGFydGljbGUKICogQG91dHB1dDogdGhlIGZpbGUgb3V0cHV0CiAqIEBkZXB0aDogdGhlIGRlcHRoIHVzZWQgZm9yIGludGVudGF0aW9uCiAqCiAqIER1bXAgYSBTY2hlbWFUeXBlIHN0cnVjdHVyZQogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hQ29udGVudE1vZGVsRHVtcCh4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0aWNsZSwgRklMRSAqIG91dHB1dCwgaW50IGRlcHRoKQp7CiAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgdGVybTsKICAgIGNoYXIgc2hpZnRbMTAwXTsKICAgIGludCBpOwoKICAgIGlmIChwYXJ0aWNsZSA9PSBOVUxMKQoJcmV0dXJuOwogICAgZm9yIChpID0gMDsoKGkgPCBkZXB0aCkgJiYgKGkgPCAyNSkpO2krKykKICAgICAgICBzaGlmdFsyICogaV0gPSBzaGlmdFsyICogaSArIDFdID0gJyAnOwogICAgc2hpZnRbMiAqIGldID0gc2hpZnRbMiAqIGkgKyAxXSA9IDA7CiAgICBmcHJpbnRmKG91dHB1dCwgc2hpZnQpOwogICAgaWYgKHBhcnRpY2xlLT5jaGlsZHJlbiA9PSBOVUxMKSB7CglmcHJpbnRmKG91dHB1dCwgIk1JU1NJTkcgcGFydGljbGUgdGVybVxuIik7CglyZXR1cm47CiAgICB9CiAgICB0ZXJtID0gcGFydGljbGUtPmNoaWxkcmVuOwogICAgaWYgKHRlcm0gPT0gTlVMTCkgewoJZnByaW50ZihvdXRwdXQsICIoTlVMTCkiKTsKICAgIH0gZWxzZSB7Cglzd2l0Y2ggKHRlcm0tPnR5cGUpIHsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOgoJCWZwcmludGYob3V0cHV0LCAiRUxFTSAnJXMnIiwgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwKCQkgICAgKCh4bWxTY2hlbWFFbGVtZW50UHRyKXRlcm0pLT50YXJnZXROYW1lc3BhY2UsCgkJICAgICgoeG1sU2NoZW1hRWxlbWVudFB0cil0ZXJtKS0+bmFtZSkpOwoJCUZSRUVfQU5EX05VTEwoc3RyKTsKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TRVFVRU5DRToKCQlmcHJpbnRmKG91dHB1dCwgIlNFUVVFTkNFIik7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFOgoJCWZwcmludGYob3V0cHV0LCAiQ0hPSUNFIik7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQUxMOgoJCWZwcmludGYob3V0cHV0LCAiQUxMIik7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZOgoJCWZwcmludGYob3V0cHV0LCAiQU5ZIik7CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlmcHJpbnRmKG91dHB1dCwgIlVOS05PV05cbiIpOwoJCXJldHVybjsKCX0KICAgIH0KICAgIGlmIChwYXJ0aWNsZS0+bWluT2NjdXJzICE9IDEpCglmcHJpbnRmKG91dHB1dCwgIiBtaW46ICVkIiwgcGFydGljbGUtPm1pbk9jY3Vycyk7CiAgICBpZiAocGFydGljbGUtPm1heE9jY3VycyA+PSBVTkJPVU5ERUQpCglmcHJpbnRmKG91dHB1dCwgIiBtYXg6IHVuYm91bmRlZCIpOwogICAgZWxzZSBpZiAocGFydGljbGUtPm1heE9jY3VycyAhPSAxKQoJZnByaW50ZihvdXRwdXQsICIgbWF4OiAlZCIsIHBhcnRpY2xlLT5tYXhPY2N1cnMpOwogICAgZnByaW50ZihvdXRwdXQsICJcbiIpOwogICAgaWYgKHRlcm0gJiYKCSgodGVybS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UpIHx8CgkgKHRlcm0tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NIT0lDRSkgfHwKCSAodGVybS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQUxMKSkgJiYKCSAodGVybS0+Y2hpbGRyZW4gIT0gTlVMTCkpIHsKCXhtbFNjaGVtYUNvbnRlbnRNb2RlbER1bXAoKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSB0ZXJtLT5jaGlsZHJlbiwKCSAgICBvdXRwdXQsIGRlcHRoICsxKTsKICAgIH0KICAgIGlmIChwYXJ0aWNsZS0+bmV4dCAhPSBOVUxMKQoJeG1sU2NoZW1hQ29udGVudE1vZGVsRHVtcCgoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnRpY2xlLT5uZXh0LAoJCW91dHB1dCwgZGVwdGgpOwp9CgovKioKICogeG1sU2NoZW1hQXR0clVzZXNEdW1wOgogKiBAdXNlczogIGF0dHJpYnV0ZSB1c2VzIGxpc3QKICogQG91dHB1dDogIHRoZSBmaWxlIG91dHB1dCAKICoKICogRHVtcHMgYSBsaXN0IG9mIGF0dHJpYnV0ZSB1c2UgY29tcG9uZW50cy4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUF0dHJVc2VzRHVtcCh4bWxTY2hlbWFJdGVtTGlzdFB0ciB1c2VzLCBGSUxFICogb3V0cHV0KQp7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgdXNlOwogICAgeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliUHRyIHByb2hpYjsKICAgIHhtbFNjaGVtYVFOYW1lUmVmUHRyIHJlZjsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWUsICp0bnM7CiAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwogICAgaW50IGk7CgogICAgaWYgKCh1c2VzID09IE5VTEwpIHx8ICh1c2VzLT5uYkl0ZW1zID09IDApKQogICAgICAgIHJldHVybjsKCiAgICBmcHJpbnRmKG91dHB1dCwgIiAgYXR0cmlidXRlczpcbiIpOyAgICAKICAgIGZvciAoaSA9IDA7IGkgPCB1c2VzLT5uYkl0ZW1zOyBpKyspIHsKCXVzZSA9IHVzZXMtPml0ZW1zW2ldOwoJaWYgKHVzZS0+dHlwZSA9PSBYTUxfU0NIRU1BX0VYVFJBX0FUVFJfVVNFX1BST0hJQikgewoJICAgIGZwcmludGYob3V0cHV0LCAiICBbcHJvaGliaXRpb25dICIpOwoJICAgIHByb2hpYiA9ICh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQcm9oaWJQdHIpIHVzZTsKCSAgICBuYW1lID0gcHJvaGliLT5uYW1lOwoJICAgIHRucyA9IHByb2hpYi0+dGFyZ2V0TmFtZXNwYWNlOwoJfSBlbHNlIGlmICh1c2UtPnR5cGUgPT0gWE1MX1NDSEVNQV9FWFRSQV9RTkFNRVJFRikgewoJICAgIGZwcmludGYob3V0cHV0LCAiICBbcmVmZXJlbmNlXSAiKTsKCSAgICByZWYgPSAoeG1sU2NoZW1hUU5hbWVSZWZQdHIpIHVzZTsKCSAgICBuYW1lID0gcmVmLT5uYW1lOwoJICAgIHRucyA9IHJlZi0+dGFyZ2V0TmFtZXNwYWNlOwoJfSBlbHNlIHsKCSAgICBmcHJpbnRmKG91dHB1dCwgIiAgW3VzZV0gIik7CgkgICAgbmFtZSA9IFdYU19BVFRSVVNFX0RFQ0xfTkFNRSh1c2UpOwoJICAgIHRucyA9IFdYU19BVFRSVVNFX0RFQ0xfVE5TKHVzZSk7Cgl9CglmcHJpbnRmKG91dHB1dCwgIiclcydcbiIsCgkgICAgKGNvbnN0IGNoYXIgKikgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwgdG5zLCBuYW1lKSk7CglGUkVFX0FORF9OVUxMKHN0cik7CiAgICB9Cn0KCi8qKgogKiB4bWxTY2hlbWFUeXBlRHVtcDoKICogQG91dHB1dDogIHRoZSBmaWxlIG91dHB1dAogKiBAdHlwZTogIGEgdHlwZSBzdHJ1Y3R1cmUKICoKICogRHVtcCBhIFNjaGVtYVR5cGUgc3RydWN0dXJlCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFUeXBlRHVtcCh4bWxTY2hlbWFUeXBlUHRyIHR5cGUsIEZJTEUgKiBvdXRwdXQpCnsKICAgIGlmICh0eXBlID09IE5VTEwpIHsKICAgICAgICBmcHJpbnRmKG91dHB1dCwgIlR5cGU6IE5VTExcbiIpOwogICAgICAgIHJldHVybjsKICAgIH0KICAgIGZwcmludGYob3V0cHV0LCAiVHlwZTogIik7CiAgICBpZiAodHlwZS0+bmFtZSAhPSBOVUxMKQogICAgICAgIGZwcmludGYob3V0cHV0LCAiJyVzJyAiLCB0eXBlLT5uYW1lKTsKICAgIGVsc2UKICAgICAgICBmcHJpbnRmKG91dHB1dCwgIihubyBuYW1lKSAiKTsKICAgIGlmICh0eXBlLT50YXJnZXROYW1lc3BhY2UgIT0gTlVMTCkKCWZwcmludGYob3V0cHV0LCAibnMgJyVzJyAiLCB0eXBlLT50YXJnZXROYW1lc3BhY2UpOwogICAgc3dpdGNoICh0eXBlLT50eXBlKSB7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQkFTSUM6CiAgICAgICAgICAgIGZwcmludGYob3V0cHV0LCAiW2Jhc2ljXSAiKTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIltzaW1wbGVdICIpOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIltjb21wbGV4XSAiKTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0U6CiAgICAgICAgICAgIGZwcmludGYob3V0cHV0LCAiW3NlcXVlbmNlXSAiKTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIltjaG9pY2VdICIpOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTEw6CiAgICAgICAgICAgIGZwcmludGYob3V0cHV0LCAiW2FsbF0gIik7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX1VSOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIlt1cl0gIik7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX1JFU1RSSUNUSU9OOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIltyZXN0cmljdGlvbl0gIik7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0VYVEVOU0lPTjoKICAgICAgICAgICAgZnByaW50ZihvdXRwdXQsICJbZXh0ZW5zaW9uXSAiKTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgZGVmYXVsdDoKICAgICAgICAgICAgZnByaW50ZihvdXRwdXQsICJbdW5rbm93biB0eXBlICVkXSAiLCB0eXBlLT50eXBlKTsKICAgICAgICAgICAgYnJlYWs7CiAgICB9CiAgICBmcHJpbnRmKG91dHB1dCwgImNvbnRlbnQ6ICIpOwogICAgc3dpdGNoICh0eXBlLT5jb250ZW50VHlwZSkgewogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX1VOS05PV046CiAgICAgICAgICAgIGZwcmludGYob3V0cHV0LCAiW3Vua25vd25dICIpOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWToKICAgICAgICAgICAgZnByaW50ZihvdXRwdXQsICJbZW1wdHldICIpOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfQ09OVEVOVF9FTEVNRU5UUzoKICAgICAgICAgICAgZnByaW50ZihvdXRwdXQsICJbZWxlbWVudF0gIik7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX01JWEVEOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIlttaXhlZF0gIik7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX01JWEVEX09SX0VMRU1FTlRTOgoJLyogbm90IHVzZWQuICovCiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX0JBU0lDOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIltiYXNpY10gIik7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRToKICAgICAgICAgICAgZnByaW50ZihvdXRwdXQsICJbc2ltcGxlXSAiKTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0NPTlRFTlRfQU5ZOgogICAgICAgICAgICBmcHJpbnRmKG91dHB1dCwgIlthbnldICIpOwogICAgICAgICAgICBicmVhazsKICAgIH0KICAgIGZwcmludGYob3V0cHV0LCAiXG4iKTsKICAgIGlmICh0eXBlLT5iYXNlICE9IE5VTEwpIHsKICAgICAgICBmcHJpbnRmKG91dHB1dCwgIiAgYmFzZSB0eXBlOiAnJXMnIiwgdHlwZS0+YmFzZSk7CglpZiAodHlwZS0+YmFzZU5zICE9IE5VTEwpCgkgICAgZnByaW50ZihvdXRwdXQsICIgbnMgJyVzJ1xuIiwgdHlwZS0+YmFzZU5zKTsKCWVsc2UKCSAgICBmcHJpbnRmKG91dHB1dCwgIlxuIik7CiAgICB9CiAgICBpZiAodHlwZS0+YXR0clVzZXMgIT0gTlVMTCkKCXhtbFNjaGVtYUF0dHJVc2VzRHVtcCh0eXBlLT5hdHRyVXNlcywgb3V0cHV0KTsKICAgIGlmICh0eXBlLT5hbm5vdCAhPSBOVUxMKQogICAgICAgIHhtbFNjaGVtYUFubm90RHVtcChvdXRwdXQsIHR5cGUtPmFubm90KTsKI2lmZGVmIERVTVBfQ09OVEVOVF9NT0RFTAogICAgaWYgKCh0eXBlLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYKSAmJgoJKHR5cGUtPnN1YnR5cGVzICE9IE5VTEwpKSB7Cgl4bWxTY2hlbWFDb250ZW50TW9kZWxEdW1wKCh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgdHlwZS0+c3VidHlwZXMsCgkgICAgb3V0cHV0LCAxKTsKICAgIH0KI2VuZGlmCn0KCi8qKgogKiB4bWxTY2hlbWFEdW1wOgogKiBAb3V0cHV0OiAgdGhlIGZpbGUgb3V0cHV0CiAqIEBzY2hlbWE6ICBhIHNjaGVtYSBzdHJ1Y3R1cmUKICoKICogRHVtcCBhIFNjaGVtYSBzdHJ1Y3R1cmUuCiAqLwp2b2lkCnhtbFNjaGVtYUR1bXAoRklMRSAqIG91dHB1dCwgeG1sU2NoZW1hUHRyIHNjaGVtYSkKewogICAgaWYgKG91dHB1dCA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIGlmIChzY2hlbWEgPT0gTlVMTCkgewogICAgICAgIGZwcmludGYob3V0cHV0LCAiU2NoZW1hczogTlVMTFxuIik7CiAgICAgICAgcmV0dXJuOwogICAgfQogICAgZnByaW50ZihvdXRwdXQsICJTY2hlbWFzOiAiKTsKICAgIGlmIChzY2hlbWEtPm5hbWUgIT0gTlVMTCkKICAgICAgICBmcHJpbnRmKG91dHB1dCwgIiVzLCAiLCBzY2hlbWEtPm5hbWUpOwogICAgZWxzZQogICAgICAgIGZwcmludGYob3V0cHV0LCAibm8gbmFtZSwgIik7CiAgICBpZiAoc2NoZW1hLT50YXJnZXROYW1lc3BhY2UgIT0gTlVMTCkKICAgICAgICBmcHJpbnRmKG91dHB1dCwgIiVzIiwgKGNvbnN0IGNoYXIgKikgc2NoZW1hLT50YXJnZXROYW1lc3BhY2UpOwogICAgZWxzZQogICAgICAgIGZwcmludGYob3V0cHV0LCAibm8gdGFyZ2V0IG5hbWVzcGFjZSIpOwogICAgZnByaW50ZihvdXRwdXQsICJcbiIpOwogICAgaWYgKHNjaGVtYS0+YW5ub3QgIT0gTlVMTCkKICAgICAgICB4bWxTY2hlbWFBbm5vdER1bXAob3V0cHV0LCBzY2hlbWEtPmFubm90KTsKICAgIHhtbEhhc2hTY2FuKHNjaGVtYS0+dHlwZURlY2wsICh4bWxIYXNoU2Nhbm5lcikgeG1sU2NoZW1hVHlwZUR1bXAsCiAgICAgICAgICAgICAgICBvdXRwdXQpOwogICAgeG1sSGFzaFNjYW5GdWxsKHNjaGVtYS0+ZWxlbURlY2wsCiAgICAgICAgICAgICAgICAgICAgKHhtbEhhc2hTY2FubmVyRnVsbCkgeG1sU2NoZW1hRWxlbWVudER1bXAsIG91dHB1dCk7Cn0KCiNpZmRlZiBERUJVR19JRENfTk9ERV9UQUJMRQovKioKICogeG1sU2NoZW1hRGVidWdEdW1wSURDVGFibGU6CiAqIEB2Y3R4dDogdGhlIFdYUyB2YWxpZGF0aW9uIGNvbnRleHQKICoKICogRGlzcGxheXMgdGhlIGN1cnJlbnQgSURDIHRhYmxlIGZvciBkZWJ1ZyBwdXJwb3Nlcy4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYURlYnVnRHVtcElEQ1RhYmxlKEZJTEUgKiBvdXRwdXQsCgkJCSAgIGNvbnN0IHhtbENoYXIgKm5hbWVzcGFjZU5hbWUsCgkJCSAgIGNvbnN0IHhtbENoYXIgKmxvY2FsTmFtZSwKCQkJICAgeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmdQdHIgYmluZCkKewogICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlOwogICAgeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIgdGFiOwogICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciBrZXk7CiAgICBpbnQgaSwgaiwgcmVzOwoKICAgIGZwcmludGYob3V0cHV0LCAiSURDOiBUQUJMRVMgb24gJyVzJ1xuIiwKCXhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIG5hbWVzcGFjZU5hbWUsIGxvY2FsTmFtZSkpOwogICAgRlJFRV9BTkRfTlVMTChzdHIpCgogICAgaWYgKGJpbmQgPT0gTlVMTCkKCXJldHVybjsKICAgIGRvIHsKCWZwcmludGYob3V0cHV0LCAiSURDOiAgIEJJTkRJTkcgJyVzJyAoJWQpXG4iLAoJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIAoJCWJpbmQtPmRlZmluaXRpb24pLCBiaW5kLT5uYk5vZGVzKTsKCUZSRUVfQU5EX05VTEwoc3RyKQoJZm9yIChpID0gMDsgaSA8IGJpbmQtPm5iTm9kZXM7IGkrKykgewoJICAgIHRhYiA9IGJpbmQtPm5vZGVUYWJsZVtpXTsKCSAgICBmcHJpbnRmKG91dHB1dCwgIiAgICAgICAgICggIik7CgkgICAgZm9yIChqID0gMDsgaiA8IGJpbmQtPmRlZmluaXRpb24tPm5iRmllbGRzOyBqKyspIHsKCQlrZXkgPSB0YWItPmtleXNbal07CgkJaWYgKChrZXkgIT0gTlVMTCkgJiYgKGtleS0+dmFsICE9IE5VTEwpKSB7CgkJICAgIHJlcyA9IHhtbFNjaGVtYUdldENhbm9uVmFsdWUoa2V5LT52YWwsICZ2YWx1ZSk7CgkJICAgIGlmIChyZXMgPj0gMCkKCQkJZnByaW50ZihvdXRwdXQsICInJXMnICIsIHZhbHVlKTsKCQkgICAgZWxzZQoJCQlmcHJpbnRmKG91dHB1dCwgIkNBTk9OLVZBTFVFLUZBSUxFRCAiKTsKCQkgICAgaWYgKHJlcyA9PSAwKQoJCQlGUkVFX0FORF9OVUxMKHZhbHVlKQoJCX0gZWxzZSBpZiAoa2V5ICE9IE5VTEwpCgkJICAgIGZwcmludGYob3V0cHV0LCAiKG5vIHZhbCksICIpOwoJCWVsc2UKCQkgICAgZnByaW50ZihvdXRwdXQsICIoa2V5IG1pc3NpbmcpLCAiKTsKCSAgICB9CgkgICAgZnByaW50ZihvdXRwdXQsICIpXG4iKTsKCX0KCWlmIChiaW5kLT5kdXBscyAmJiBiaW5kLT5kdXBscy0+bmJJdGVtcykgewoJICAgIGZwcmludGYob3V0cHV0LCAiSURDOiAgICAgZHVwbHMgKCVkKTpcbiIsIGJpbmQtPmR1cGxzLT5uYkl0ZW1zKTsKCSAgICBmb3IgKGkgPSAwOyBpIDwgYmluZC0+ZHVwbHMtPm5iSXRlbXM7IGkrKykgewoJCXRhYiA9IGJpbmQtPmR1cGxzLT5pdGVtc1tpXTsKCQlmcHJpbnRmKG91dHB1dCwgIiAgICAgICAgICggIik7CgkJZm9yIChqID0gMDsgaiA8IGJpbmQtPmRlZmluaXRpb24tPm5iRmllbGRzOyBqKyspIHsKCQkgICAga2V5ID0gdGFiLT5rZXlzW2pdOwoJCSAgICBpZiAoKGtleSAhPSBOVUxMKSAmJiAoa2V5LT52YWwgIT0gTlVMTCkpIHsKCQkJcmVzID0geG1sU2NoZW1hR2V0Q2Fub25WYWx1ZShrZXktPnZhbCwgJnZhbHVlKTsKCQkJaWYgKHJlcyA+PSAwKQoJCQkgICAgZnByaW50ZihvdXRwdXQsICInJXMnICIsIHZhbHVlKTsKCQkJZWxzZQoJCQkgICAgZnByaW50ZihvdXRwdXQsICJDQU5PTi1WQUxVRS1GQUlMRUQgIik7CgkJCWlmIChyZXMgPT0gMCkKCQkJICAgIEZSRUVfQU5EX05VTEwodmFsdWUpCgkJICAgIH0gZWxzZSBpZiAoa2V5ICE9IE5VTEwpCgkJICAgIGZwcmludGYob3V0cHV0LCAiKG5vIHZhbCksICIpOwoJCQllbHNlCgkJCSAgICBmcHJpbnRmKG91dHB1dCwgIihrZXkgbWlzc2luZyksICIpOwoJCX0KCQlmcHJpbnRmKG91dHB1dCwgIilcbiIpOwoJICAgIH0KCX0KCWJpbmQgPSBiaW5kLT5uZXh0OwogICAgfSB3aGlsZSAoYmluZCAhPSBOVUxMKTsKfQojZW5kaWYgLyogREVCVUdfSURDICovCiNlbmRpZiAvKiBMSUJYTUxfT1VUUFVUX0VOQUJMRUQgKi8KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCQkJCQkJCQkqCiAqIAkJCVV0aWxpdGllcwkJCQkJKgogKgkJCQkJCQkJCSoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCi8qKgogKiB4bWxTY2hlbWFHZXRQcm9wTm9kZToKICogQG5vZGU6IHRoZSBlbGVtZW50IG5vZGUKICogQG5hbWU6IHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUKICoKICogU2Vla3MgYW4gYXR0cmlidXRlIHdpdGggYSBuYW1lIG9mIEBuYW1lIGluCiAqIG5vIG5hbWVzcGFjZS4KICoKICogUmV0dXJucyB0aGUgYXR0cmlidXRlIG9yIE5VTEwgaWYgbm90IHByZXNlbnQuCiAqLwpzdGF0aWMgeG1sQXR0clB0cgp4bWxTY2hlbWFHZXRQcm9wTm9kZSh4bWxOb2RlUHRyIG5vZGUsIGNvbnN0IGNoYXIgKm5hbWUpCnsKICAgIHhtbEF0dHJQdHIgcHJvcDsKCiAgICBpZiAoKG5vZGUgPT0gTlVMTCkgfHwgKG5hbWUgPT0gTlVMTCkpCglyZXR1cm4oTlVMTCk7CiAgICBwcm9wID0gbm9kZS0+cHJvcGVydGllczsKICAgIHdoaWxlIChwcm9wICE9IE5VTEwpIHsKICAgICAgICBpZiAoKHByb3AtPm5zID09IE5VTEwpICYmIHhtbFN0ckVxdWFsKHByb3AtPm5hbWUsIEJBRF9DQVNUIG5hbWUpKQoJICAgIHJldHVybihwcm9wKTsKCXByb3AgPSBwcm9wLT5uZXh0OwogICAgfQogICAgcmV0dXJuIChOVUxMKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUdldFByb3BOb2RlTnM6CiAqIEBub2RlOiB0aGUgZWxlbWVudCBub2RlCiAqIEB1cmk6IHRoZSB1cmkKICogQG5hbWU6IHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUKICoKICogU2Vla3MgYW4gYXR0cmlidXRlIHdpdGggYSBsb2NhbCBuYW1lIG9mIEBuYW1lIGFuZAogKiBhIG5hbWVzcGFjZSBVUkkgb2YgQHVyaS4KICoKICogUmV0dXJucyB0aGUgYXR0cmlidXRlIG9yIE5VTEwgaWYgbm90IHByZXNlbnQuCiAqLwpzdGF0aWMgeG1sQXR0clB0cgp4bWxTY2hlbWFHZXRQcm9wTm9kZU5zKHhtbE5vZGVQdHIgbm9kZSwgY29uc3QgY2hhciAqdXJpLCBjb25zdCBjaGFyICpuYW1lKQp7CiAgICB4bWxBdHRyUHRyIHByb3A7CgogICAgaWYgKChub2RlID09IE5VTEwpIHx8IChuYW1lID09IE5VTEwpKQoJcmV0dXJuKE5VTEwpOyAgICAKICAgIHByb3AgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKHByb3AgIT0gTlVMTCkgewoJaWYgKChwcm9wLT5ucyAhPSBOVUxMKSAmJgoJICAgIHhtbFN0ckVxdWFsKHByb3AtPm5hbWUsIEJBRF9DQVNUIG5hbWUpICYmCgkgICAgeG1sU3RyRXF1YWwocHJvcC0+bnMtPmhyZWYsIEJBRF9DQVNUIHVyaSkpCgkgICAgcmV0dXJuKHByb3ApOwoJcHJvcCA9IHByb3AtPm5leHQ7CiAgICB9CiAgICByZXR1cm4gKE5VTEwpOwp9CgpzdGF0aWMgY29uc3QgeG1sQ2hhciAqCnhtbFNjaGVtYUdldE5vZGVDb250ZW50KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sTm9kZVB0ciBub2RlKQp7CiAgICB4bWxDaGFyICp2YWw7CiAgICBjb25zdCB4bWxDaGFyICpyZXQ7CgogICAgdmFsID0geG1sTm9kZUdldENvbnRlbnQobm9kZSk7CiAgICBpZiAodmFsID09IE5VTEwpCgl2YWwgPSB4bWxTdHJkdXAoKHhtbENoYXIgKikiIik7CiAgICByZXQgPSB4bWxEaWN0TG9va3VwKGN0eHQtPmRpY3QsIHZhbCwgLTEpOwogICAgeG1sRnJlZSh2YWwpOwogICAgcmV0dXJuKHJldCk7Cn0KCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnROb0RpY3QoeG1sTm9kZVB0ciBub2RlKQp7CiAgICByZXR1cm4oKGNvbnN0IHhtbENoYXIqKSB4bWxOb2RlR2V0Q29udGVudChub2RlKSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFHZXRQcm9wOgogKiBAY3R4dDogdGhlIHBhcnNlciBjb250ZXh0CiAqIEBub2RlOiB0aGUgbm9kZQogKiBAbmFtZTogdGhlIHByb3BlcnR5IG5hbWUKICoKICogUmVhZCBhIGF0dHJpYnV0ZSB2YWx1ZSBhbmQgaW50ZXJuYWxpemUgdGhlIHN0cmluZwogKgogKiBSZXR1cm5zIHRoZSBzdHJpbmcgb3IgTlVMTCBpZiBub3QgcHJlc2VudC4KICovCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hR2V0UHJvcCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbE5vZGVQdHIgbm9kZSwKICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpuYW1lKQp7CiAgICB4bWxDaGFyICp2YWw7CiAgICBjb25zdCB4bWxDaGFyICpyZXQ7CgogICAgdmFsID0geG1sR2V0Tm9Oc1Byb3Aobm9kZSwgQkFEX0NBU1QgbmFtZSk7CiAgICBpZiAodmFsID09IE5VTEwpCiAgICAgICAgcmV0dXJuKE5VTEwpOwogICAgcmV0ID0geG1sRGljdExvb2t1cChjdHh0LT5kaWN0LCB2YWwsIC0xKTsKICAgIHhtbEZyZWUodmFsKTsKICAgIHJldHVybihyZXQpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQkJCQkJCSoKICogCQkJUGFyc2luZyBmdW5jdGlvbnMJCQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgojZGVmaW5lIFdYU19GSU5EX0dMT0JBTF9JVEVNKHNsb3QpCQkJXAogICAgaWYgKHhtbFN0ckVxdWFsKG5zTmFtZSwgc2NoZW1hLT50YXJnZXROYW1lc3BhY2UpKSB7IFwKCXJldCA9IHhtbEhhc2hMb29rdXAoc2NoZW1hLT5zbG90LCBuYW1lKTsgXAoJaWYgKHJldCAhPSBOVUxMKSBnb3RvIGV4aXQ7IFwKICAgIH0gXAogICAgaWYgKHhtbEhhc2hTaXplKHNjaGVtYS0+c2NoZW1hc0ltcG9ydHMpID4gMSkgeyBcCgl4bWxTY2hlbWFJbXBvcnRQdHIgaW1wb3J0OyBcCglpZiAobnNOYW1lID09IE5VTEwpIFwKCSAgICBpbXBvcnQgPSB4bWxIYXNoTG9va3VwKHNjaGVtYS0+c2NoZW1hc0ltcG9ydHMsIFwKCQlYTUxfU0NIRU1BU19OT19OQU1FU1BBQ0UpOyBcCgllbHNlIFwKCSAgICBpbXBvcnQgPSB4bWxIYXNoTG9va3VwKHNjaGVtYS0+c2NoZW1hc0ltcG9ydHMsIG5zTmFtZSk7IFwKCWlmIChpbXBvcnQgPT0gTlVMTCkgXAoJICAgIGdvdG8gZXhpdDsgXAoJcmV0ID0geG1sSGFzaExvb2t1cChpbXBvcnQtPnNjaGVtYS0+c2xvdCwgbmFtZSk7IFwKICAgIH0KCi8qKgogKiB4bWxTY2hlbWFHZXRFbGVtOgogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBjb250ZXh0CiAqIEBuYW1lOiAgdGhlIGVsZW1lbnQgbmFtZQogKiBAbnM6ICB0aGUgZWxlbWVudCBuYW1lc3BhY2UKICoKICogTG9va3VwIGEgZ2xvYmFsIGVsZW1lbnQgZGVjbGFyYXRpb24gaW4gdGhlIHNjaGVtYS4KICoKICogUmV0dXJucyB0aGUgZWxlbWVudCBkZWNsYXJhdGlvbiBvciBOVUxMIGlmIG5vdCBmb3VuZC4KICovCnN0YXRpYyB4bWxTY2hlbWFFbGVtZW50UHRyCnhtbFNjaGVtYUdldEVsZW0oeG1sU2NoZW1hUHRyIHNjaGVtYSwgY29uc3QgeG1sQ2hhciAqIG5hbWUsCiAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhciAqIG5zTmFtZSkKewogICAgeG1sU2NoZW1hRWxlbWVudFB0ciByZXQgPSBOVUxMOwogICAgCiAgICBpZiAoKG5hbWUgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4oTlVMTCk7CiAgICBpZiAoc2NoZW1hICE9IE5VTEwpIHsKCVdYU19GSU5EX0dMT0JBTF9JVEVNKGVsZW1EZWNsKQogICAgfSAgIApleGl0OgojaWZkZWYgREVCVUcKICAgIGlmIChyZXQgPT0gTlVMTCkgewogICAgICAgIGlmIChuc05hbWUgPT0gTlVMTCkKICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJVbmFibGUgdG8gbG9va3VwIGVsZW1lbnQgZGVjbC4gJXMiLCBuYW1lKTsKICAgICAgICBlbHNlCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCBlbGVtZW50IGRlY2wuICVzOiVzIiwgbmFtZSwKICAgICAgICAgICAgICAgICAgICBuc05hbWUpOwogICAgfQojZW5kaWYKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUdldFR5cGU6CiAqIEBzY2hlbWE6ICB0aGUgbWFpbiBzY2hlbWEKICogQG5hbWU6ICB0aGUgdHlwZSdzIG5hbWUKICogbnNOYW1lOiAgdGhlIHR5cGUncyBuYW1lc3BhY2UKICoKICogTG9va3VwIGEgdHlwZSBpbiB0aGUgc2NoZW1hcyBvciB0aGUgcHJlZGVmaW5lZCB0eXBlcwogKgogKiBSZXR1cm5zIHRoZSBncm91cCBkZWZpbml0aW9uIG9yIE5VTEwgaWYgbm90IGZvdW5kLgogKi8Kc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIKeG1sU2NoZW1hR2V0VHlwZSh4bWxTY2hlbWFQdHIgc2NoZW1hLCBjb25zdCB4bWxDaGFyICogbmFtZSwKICAgICAgICAgICAgICAgICBjb25zdCB4bWxDaGFyICogbnNOYW1lKQp7CiAgICB4bWxTY2hlbWFUeXBlUHRyIHJldCA9IE5VTEw7CgogICAgaWYgKG5hbWUgPT0gTlVMTCkKICAgICAgICByZXR1cm4gKE5VTEwpOyAgICAKICAgIC8qIEZpcnN0IHRyeSB0aGUgYnVpbHQtaW4gdHlwZXMuICovCiAgICBpZiAoKG5zTmFtZSAhPSBOVUxMKSAmJiB4bWxTdHJFcXVhbChuc05hbWUsIHhtbFNjaGVtYU5zKSkgewkKCXJldCA9IHhtbFNjaGVtYUdldFByZWRlZmluZWRUeXBlKG5hbWUsIG5zTmFtZSk7CglpZiAocmV0ICE9IE5VTEwpCgkgICAgZ290byBleGl0OwoJLyoKCSogTm90ZSB0aGF0IHdlIHRyeSB0aGUgcGFyc2VkIHNjaGVtYXMgYXMgd2VsbCBoZXJlCgkqIHNpbmNlIG9uZSBtaWdodCBoYXZlIHBhcnNlZCB0aGUgUzRTLCB3aGljaCBjb250YWluIG1vcmUKCSogdGhhbiB0aGUgYnVpbHQtaW4gdHlwZXMuCgkqIFRPRE86IENhbiB3ZSBvcHRpbWl6ZSB0aGlzPwoJKi8KICAgIH0KICAgIGlmIChzY2hlbWEgIT0gTlVMTCkgewoJV1hTX0ZJTkRfR0xPQkFMX0lURU0odHlwZURlY2wpCiAgICB9IApleGl0OgoKI2lmZGVmIERFQlVHCiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICBpZiAobnNOYW1lID09IE5VTEwpCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCB0eXBlICVzIiwgbmFtZSk7CiAgICAgICAgZWxzZQogICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlVuYWJsZSB0byBsb29rdXAgdHlwZSAlczolcyIsIG5hbWUsCiAgICAgICAgICAgICAgICAgICAgbnNOYW1lKTsKICAgIH0KI2VuZGlmCiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFHZXRBdHRyaWJ1dGVEZWNsOgogKiBAc2NoZW1hOiAgdGhlIGNvbnRleHQgb2YgdGhlIHNjaGVtYQogKiBAbmFtZTogIHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUKICogQG5zOiAgdGhlIHRhcmdldCBuYW1lc3BhY2Ugb2YgdGhlIGF0dHJpYnV0ZQogKgogKiBMb29rdXAgYSBhbiBhdHRyaWJ1dGUgaW4gdGhlIHNjaGVtYSBvciBpbXBvcnRlZCBzY2hlbWFzCiAqCiAqIFJldHVybnMgdGhlIGF0dHJpYnV0ZSBkZWNsYXJhdGlvbiBvciBOVUxMIGlmIG5vdCBmb3VuZC4KICovCnN0YXRpYyB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIKeG1sU2NoZW1hR2V0QXR0cmlidXRlRGVjbCh4bWxTY2hlbWFQdHIgc2NoZW1hLCBjb25zdCB4bWxDaGFyICogbmFtZSwKICAgICAgICAgICAgICAgICBjb25zdCB4bWxDaGFyICogbnNOYW1lKQp7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKG5hbWUgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgaWYgKHNjaGVtYSAhPSBOVUxMKSB7CglXWFNfRklORF9HTE9CQUxfSVRFTShhdHRyRGVjbCkKICAgIH0KZXhpdDoKI2lmZGVmIERFQlVHCiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICBpZiAobnNOYW1lID09IE5VTEwpCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCBhdHRyaWJ1dGUgJXMiLCBuYW1lKTsKICAgICAgICBlbHNlCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCBhdHRyaWJ1dGUgJXM6JXMiLCBuYW1lLAogICAgICAgICAgICAgICAgICAgIG5zTmFtZSk7CiAgICB9CiNlbmRpZgogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sU2NoZW1hR2V0QXR0cmlidXRlR3JvdXA6CiAqIEBzY2hlbWE6ICB0aGUgY29udGV4dCBvZiB0aGUgc2NoZW1hCiAqIEBuYW1lOiAgdGhlIG5hbWUgb2YgdGhlIGF0dHJpYnV0ZSBncm91cAogKiBAbnM6ICB0aGUgdGFyZ2V0IG5hbWVzcGFjZSBvZiB0aGUgYXR0cmlidXRlIGdyb3VwCiAqCiAqIExvb2t1cCBhIGFuIGF0dHJpYnV0ZSBncm91cCBpbiB0aGUgc2NoZW1hIG9yIGltcG9ydGVkIHNjaGVtYXMKICoKICogUmV0dXJucyB0aGUgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb24gb3IgTlVMTCBpZiBub3QgZm91bmQuCiAqLwpzdGF0aWMgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIKeG1sU2NoZW1hR2V0QXR0cmlidXRlR3JvdXAoeG1sU2NoZW1hUHRyIHNjaGVtYSwgY29uc3QgeG1sQ2hhciAqIG5hbWUsCiAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhciAqIG5zTmFtZSkKewogICAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKG5hbWUgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgaWYgKHNjaGVtYSAhPSBOVUxMKSB7CglXWFNfRklORF9HTE9CQUxfSVRFTShhdHRyZ3JwRGVjbCkKICAgIH0KZXhpdDoKICAgIC8qIFRPRE86CiAgICBpZiAoKHJldCAhPSBOVUxMKSAmJiAocmV0LT5yZWRlZiAhPSBOVUxMKSkgewoJKiBSZXR1cm4gdGhlIGxhc3QgcmVkZWZpbml0aW9uLiAqCglyZXQgPSByZXQtPnJlZGVmOwogICAgfQogICAgKi8KI2lmZGVmIERFQlVHCiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICBpZiAobnNOYW1lID09IE5VTEwpCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCBhdHRyaWJ1dGUgZ3JvdXAgJXMiLCBuYW1lKTsKICAgICAgICBlbHNlCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCBhdHRyaWJ1dGUgZ3JvdXAgJXM6JXMiLCBuYW1lLAogICAgICAgICAgICAgICAgICAgIG5zTmFtZSk7CiAgICB9CiNlbmRpZgogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sU2NoZW1hR2V0R3JvdXA6CiAqIEBzY2hlbWE6ICB0aGUgY29udGV4dCBvZiB0aGUgc2NoZW1hCiAqIEBuYW1lOiAgdGhlIG5hbWUgb2YgdGhlIGdyb3VwCiAqIEBuczogIHRoZSB0YXJnZXQgbmFtZXNwYWNlIG9mIHRoZSBncm91cAogKgogKiBMb29rdXAgYSBncm91cCBpbiB0aGUgc2NoZW1hIG9yIGltcG9ydGVkIHNjaGVtYXMKICoKICogUmV0dXJucyB0aGUgZ3JvdXAgZGVmaW5pdGlvbiBvciBOVUxMIGlmIG5vdCBmb3VuZC4KICovCnN0YXRpYyB4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyCnhtbFNjaGVtYUdldEdyb3VwKHhtbFNjaGVtYVB0ciBzY2hlbWEsIGNvbnN0IHhtbENoYXIgKiBuYW1lLAogICAgICAgICAgICAgICAgIGNvbnN0IHhtbENoYXIgKiBuc05hbWUpCnsKICAgIHhtbFNjaGVtYU1vZGVsR3JvdXBEZWZQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKG5hbWUgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgaWYgKHNjaGVtYSAhPSBOVUxMKSB7CglXWFNfRklORF9HTE9CQUxfSVRFTShncm91cERlY2wpCiAgICB9CmV4aXQ6CiAgICAKI2lmZGVmIERFQlVHCiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICBpZiAobnNOYW1lID09IE5VTEwpCiAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiVW5hYmxlIHRvIGxvb2t1cCBncm91cCAlcyIsIG5hbWUpOwogICAgICAgIGVsc2UKICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJVbmFibGUgdG8gbG9va3VwIGdyb3VwICVzOiVzIiwgbmFtZSwKICAgICAgICAgICAgICAgICAgICBuc05hbWUpOwogICAgfQojZW5kaWYKICAgIHJldHVybiAocmV0KTsKfQoKc3RhdGljIHhtbFNjaGVtYU5vdGF0aW9uUHRyCnhtbFNjaGVtYUdldE5vdGF0aW9uKHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJICAgICBjb25zdCB4bWxDaGFyICpuYW1lLAoJCSAgICAgY29uc3QgeG1sQ2hhciAqbnNOYW1lKQp7CiAgICB4bWxTY2hlbWFOb3RhdGlvblB0ciByZXQgPSBOVUxMOwoKICAgIGlmICgobmFtZSA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICBpZiAoc2NoZW1hICE9IE5VTEwpIHsKCVdYU19GSU5EX0dMT0JBTF9JVEVNKG5vdGFEZWNsKQogICAgfQpleGl0OgogICAgcmV0dXJuIChyZXQpOwp9CgpzdGF0aWMgeG1sU2NoZW1hSURDUHRyCnhtbFNjaGVtYUdldElEQyh4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCWNvbnN0IHhtbENoYXIgKm5hbWUsCgkJY29uc3QgeG1sQ2hhciAqbnNOYW1lKQp7CiAgICB4bWxTY2hlbWFJRENQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKG5hbWUgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgaWYgKHNjaGVtYSAhPSBOVUxMKSB7CglXWFNfRklORF9HTE9CQUxfSVRFTShpZGNEZWYpCiAgICB9CmV4aXQ6CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFHZXROYW1lZENvbXBvbmVudDoKICogQHNjaGVtYTogIHRoZSBzY2hlbWEKICogQG5hbWU6ICB0aGUgbmFtZSBvZiB0aGUgZ3JvdXAKICogQG5zOiAgdGhlIHRhcmdldCBuYW1lc3BhY2Ugb2YgdGhlIGdyb3VwCiAqCiAqIExvb2t1cCBhIGdyb3VwIGluIHRoZSBzY2hlbWEgb3IgaW1wb3J0ZWQgc2NoZW1hcwogKgogKiBSZXR1cm5zIHRoZSBncm91cCBkZWZpbml0aW9uIG9yIE5VTEwgaWYgbm90IGZvdW5kLgogKi8Kc3RhdGljIHhtbFNjaGVtYUJhc2ljSXRlbVB0cgp4bWxTY2hlbWFHZXROYW1lZENvbXBvbmVudCh4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkgICB4bWxTY2hlbWFUeXBlVHlwZSBpdGVtVHlwZSwKCQkJICAgY29uc3QgeG1sQ2hhciAqbmFtZSwKCQkJICAgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TnMpCnsKICAgIHN3aXRjaCAoaXRlbVR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOgoJICAgIHJldHVybiAoKHhtbFNjaGVtYUJhc2ljSXRlbVB0cikgeG1sU2NoZW1hR2V0R3JvdXAoc2NoZW1hLAoJCW5hbWUsIHRhcmdldE5zKSk7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOgoJICAgIHJldHVybiAoKHhtbFNjaGVtYUJhc2ljSXRlbVB0cikgeG1sU2NoZW1hR2V0RWxlbShzY2hlbWEsCgkJbmFtZSwgdGFyZ2V0TnMpKTsKCWRlZmF1bHQ6CgkgICAgVE9ETwoJICAgIHJldHVybiAoTlVMTCk7CiAgICB9Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCQkJCQkJKgogKiAJCQlQYXJzaW5nIGZ1bmN0aW9ucwkJCQkqCiAqIAkJCQkJCQkJCSoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCiNkZWZpbmUgSVNfQkxBTktfTk9ERShuKQkJCQkJCVwKICAgICgoKG4pLT50eXBlID09IFhNTF9URVhUX05PREUpICYmICh4bWxTY2hlbWFJc0JsYW5rKChuKS0+Y29udGVudCwgLTEpKSkKCi8qKgogKiB4bWxTY2hlbWFJc0JsYW5rOgogKiBAc3RyOiAgYSBzdHJpbmcKICogQGxlbjogdGhlIGxlbmd0aCBvZiB0aGUgc3RyaW5nIG9yIC0xCiAqCiAqIENoZWNrIGlmIGEgc3RyaW5nIGlzIGlnbm9yYWJsZQogKgogKiBSZXR1cm5zIDEgaWYgdGhlIHN0cmluZyBpcyBOVUxMIG9yIG1hZGUgb2YgYmxhbmtzIGNoYXJzLCAwIG90aGVyd2lzZQogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFJc0JsYW5rKHhtbENoYXIgKiBzdHIsIGludCBsZW4pCnsKICAgIGlmIChzdHIgPT0gTlVMTCkKICAgICAgICByZXR1cm4gKDEpOwogICAgaWYgKGxlbiA8IDApIHsKCXdoaWxlICgqc3RyICE9IDApIHsKCSAgICBpZiAoIShJU19CTEFOS19DSCgqc3RyKSkpCgkJcmV0dXJuICgwKTsKCSAgICBzdHIrKzsKCX0KICAgIH0gZWxzZSB3aGlsZSAoKCpzdHIgIT0gMCkgJiYgKGxlbiAhPSAwKSkgewoJaWYgKCEoSVNfQkxBTktfQ0goKnN0cikpKQoJICAgIHJldHVybiAoMCk7CglzdHIrKzsKCWxlbi0tOwogICAgfQogICAgCiAgICByZXR1cm4gKDEpOwp9CgojZGVmaW5lIFdYU19DT01QX05BTUUoYywgdCkgKCh0KSAoYykpLT5uYW1lCiNkZWZpbmUgV1hTX0NPTVBfVE5TKGMsIHQpICgodCkgKGMpKS0+dGFyZ2V0TmFtZXNwYWNlCi8qCiogeG1sU2NoZW1hRmluZFJlZGVmQ29tcEluR3JhcGg6CiogQVRURU5USU9OIFRPRE86IFRoaXMgdXNlcyBwb2ludGVyIGNvbXAuIGZvciBzdHJpbmdzLgoqLwpzdGF0aWMgeG1sU2NoZW1hQmFzaWNJdGVtUHRyCnhtbFNjaGVtYUZpbmRSZWRlZkNvbXBJbkdyYXBoKHhtbFNjaGVtYUJ1Y2tldFB0ciBidWNrZXQsCgkJCSAgICAgIHhtbFNjaGVtYVR5cGVUeXBlIHR5cGUsCgkJCSAgICAgIGNvbnN0IHhtbENoYXIgKm5hbWUsCgkJCSAgICAgIGNvbnN0IHhtbENoYXIgKm5zTmFtZSkKewogICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIHJldDsKICAgIGludCBpOwoKICAgIGlmICgoYnVja2V0ID09IE5VTEwpIHx8IChuYW1lID09IE5VTEwpKQoJcmV0dXJuKE5VTEwpOwogICAgaWYgKChidWNrZXQtPmdsb2JhbHMgPT0gTlVMTCkgfHwKCShidWNrZXQtPmdsb2JhbHMtPm5iSXRlbXMgPT0gMCkpCglnb3RvIHN1YnNjaGVtYXM7CiAgICAvKgogICAgKiBTZWFyY2ggaW4gZ2xvYmFsIGNvbXBvbmVudHMuCiAgICAqLwogICAgZm9yIChpID0gMDsgaSA8IGJ1Y2tldC0+Z2xvYmFscy0+bmJJdGVtczsgaSsrKSB7CglyZXQgPSBidWNrZXQtPmdsb2JhbHMtPml0ZW1zW2ldOwoJaWYgKHJldC0+dHlwZSA9PSB0eXBlKSB7CgkgICAgc3dpdGNoICh0eXBlKSB7CgkJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCQljYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkJICAgIGlmICgoV1hTX0NPTVBfTkFNRShyZXQsIHhtbFNjaGVtYVR5cGVQdHIpID09IG5hbWUpICYmCgkJCShXWFNfQ09NUF9UTlMocmV0LCB4bWxTY2hlbWFUeXBlUHRyKSA9PQoJCQluc05hbWUpKQoJCSAgICB7CgkJCXJldHVybihyZXQpOwoJCSAgICB9CgkJICAgIGJyZWFrOwoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOgoJCSAgICBpZiAoKFdYU19DT01QX05BTUUocmV0LAoJCQkgICAgeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cikgPT0gbmFtZSkgJiYKCQkJKFdYU19DT01QX1ROUyhyZXQsCgkJCSAgICB4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyKSA9PSBuc05hbWUpKQoJCSAgICB7CgkJCXJldHVybihyZXQpOwoJCSAgICB9CgkJICAgIGJyZWFrOwoJCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQOgoJCSAgICBpZiAoKFdYU19DT01QX05BTUUocmV0LAoJCQkgICAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIpID09IG5hbWUpICYmCgkJCShXWFNfQ09NUF9UTlMocmV0LAoJCQkgICAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIpID09IG5zTmFtZSkpCgkJICAgIHsKCQkJcmV0dXJuKHJldCk7CgkJICAgIH0KCQkgICAgYnJlYWs7CgkJZGVmYXVsdDoKCQkgICAgLyogU2hvdWxkIG5vdCBiZSBoaXQuICovCgkJICAgIHJldHVybihOVUxMKTsKCSAgICB9CQkKCX0KICAgIH0Kc3Vic2NoZW1hczoKICAgIC8qCiAgICAqIFByb2Nlc3MgaW1wb3J0ZWQvaW5jbHVkZWQgc2NoZW1hcy4KICAgICovCiAgICBpZiAoYnVja2V0LT5yZWxhdGlvbnMgIT0gTlVMTCkgewoJeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25QdHIgcmVsID0gYnVja2V0LT5yZWxhdGlvbnM7CgoJLyoKCSogVE9ETzogTWFya2luZyB0aGUgYnVja2V0IHdpbGwgbm90IGF2b2lkIG11bHRpcGxlIHNlYXJjaGVzCgkqIGluIHRoZSBzYW1lIHNjaGVtYSwgYnV0IGF2b2lkcyBhdCBsZWFzdCBjaXJjdWxhcml0eS4KCSovCglidWNrZXQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfQlVDS0VUX01BUktFRDsKCWRvIHsKCSAgICBpZiAoKHJlbC0+YnVja2V0ICE9IE5VTEwpICYmCgkJKChyZWwtPmJ1Y2tldC0+ZmxhZ3MgJiBYTUxfU0NIRU1BX0JVQ0tFVF9NQVJLRUQpID09IDApKSB7CgkJcmV0ID0geG1sU2NoZW1hRmluZFJlZGVmQ29tcEluR3JhcGgocmVsLT5idWNrZXQsCgkJICAgIHR5cGUsIG5hbWUsIG5zTmFtZSk7CgkJaWYgKHJldCAhPSBOVUxMKQoJCSAgICByZXR1cm4ocmV0KTsKCSAgICB9CgkgICAgcmVsID0gcmVsLT5uZXh0OwoJfSB3aGlsZSAocmVsICE9IE5VTEwpOwoJIGJ1Y2tldC0+ZmxhZ3MgXj0gWE1MX1NDSEVNQV9CVUNLRVRfTUFSS0VEOwogICAgfQogICAgcmV0dXJuKE5VTEwpOwp9CgovKioKICogeG1sU2NoZW1hQWRkTm90YXRpb246CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5hbWU6ICB0aGUgaXRlbSBuYW1lCiAqCiAqIEFkZCBhbiBYTUwgc2NoZW1hIGFubm90YXRpb24gZGVjbGFyYXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIHRoZSBuZXcgc3RydXR1cmUgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgeG1sU2NoZW1hTm90YXRpb25QdHIKeG1sU2NoZW1hQWRkTm90YXRpb24oeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICBjb25zdCB4bWxDaGFyICpuYW1lLCBjb25zdCB4bWxDaGFyICpuc05hbWUsCgkJICAgICB4bWxOb2RlUHRyIG5vZGUgQVRUUklCVVRFX1VOVVNFRCkKewogICAgeG1sU2NoZW1hTm90YXRpb25QdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobmFtZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9ICh4bWxTY2hlbWFOb3RhdGlvblB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFOb3RhdGlvbikpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEVyck1lbW9yeShjdHh0LCAiYWRkIGFubm90YXRpb24iLCBOVUxMKTsKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYU5vdGF0aW9uKSk7CiAgICByZXQtPnR5cGUgPSBYTUxfU0NIRU1BX1RZUEVfTk9UQVRJT047CiAgICByZXQtPm5hbWUgPSBuYW1lOwogICAgcmV0LT50YXJnZXROYW1lc3BhY2UgPSBuc05hbWU7CiAgICAvKiBUT0RPOiBkbyB3ZSBuZWVkIHRoZSBub2RlIHRvIGJlIHNldD8KICAgICogcmV0LT5ub2RlID0gbm9kZTsqLwogICAgV1hTX0FERF9HTE9CQUwoY3R4dCwgcmV0KTsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUFkZEF0dHJpYnV0ZToKICogQGN0eHQ6ICBhIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbmFtZTogIHRoZSBpdGVtIG5hbWUKICogQG5hbWVzcGFjZTogIHRoZSBuYW1lc3BhY2UKICoKICogQWRkIGFuIFhNTCBzY2hlbWEgQXR0cnJpYnV0ZSBkZWNsYXJhdGlvbgogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgdGhlIG5ldyBzdHJ1dHVyZSBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIKeG1sU2NoZW1hQWRkQXR0cmlidXRlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sU2NoZW1hUHRyIHNjaGVtYSwKICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHhtbENoYXIgKiBuYW1lLCBjb25zdCB4bWxDaGFyICogbnNOYW1lLAoJCSAgICAgIHhtbE5vZGVQdHIgbm9kZSwgaW50IHRvcExldmVsKQp7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9ICh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hQXR0cmlidXRlKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIGF0dHJpYnV0ZSIsIE5VTEwpOwogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hQXR0cmlidXRlKSk7CiAgICByZXQtPnR5cGUgPSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFOwogICAgcmV0LT5ub2RlID0gbm9kZTsKICAgIHJldC0+bmFtZSA9IG5hbWU7CiAgICByZXQtPnRhcmdldE5hbWVzcGFjZSA9IG5zTmFtZTsKCiAgICBpZiAodG9wTGV2ZWwpCglXWFNfQUREX0dMT0JBTChjdHh0LCByZXQpOwogICAgZWxzZQoJV1hTX0FERF9MT0NBTChjdHh0LCByZXQpOwogICAgV1hTX0FERF9QRU5ESU5HKGN0eHQsIHJldCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFBZGRBdHRyaWJ1dGVVc2U6CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5hbWU6ICB0aGUgaXRlbSBuYW1lCiAqIEBuYW1lc3BhY2U6ICB0aGUgbmFtZXNwYWNlCiAqCiAqIEFkZCBhbiBYTUwgc2NoZW1hIEF0dHJyaWJ1dGUgZGVjbGFyYXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIHRoZSBuZXcgc3RydXR1cmUgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyCnhtbFNjaGVtYUFkZEF0dHJpYnV0ZVVzZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkgeG1sTm9kZVB0ciBub2RlKQp7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAocGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9ICh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hQXR0cmlidXRlVXNlKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KHBjdHh0LCAiYWxsb2NhdGluZyBhdHRyaWJ1dGUiLCBOVUxMKTsKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYUF0dHJpYnV0ZVVzZSkpOwogICAgcmV0LT50eXBlID0gWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURV9VU0U7CiAgICByZXQtPm5vZGUgPSBub2RlOwoKICAgIFdYU19BRERfTE9DQUwocGN0eHQsIHJldCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qCiogeG1sU2NoZW1hQWRkUmVkZWY6CioKKiBBZGRzIGEgcmVkZWZpbml0aW9uIGluZm9ybWF0aW9uLiBUaGlzIGlzIHVzZWQgYXQgYSBsYXRlciBzdGFnZSB0bzoKKiByZXNvbHZlIHJlZmVyZW5jZXMgdG8gdGhlIHJlZGVmaW5lZCBjb21wb25lbnRzIGFuZCB0byBjaGVjayBjb25zdHJhaW50cy4KKi8Kc3RhdGljIHhtbFNjaGVtYVJlZGVmUHRyCnhtbFNjaGVtYUFkZFJlZGVmKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCQkgIAoJCSAgeG1sU2NoZW1hQnVja2V0UHRyIHRhcmdldEJ1Y2tldCwKCQkgIHZvaWQgKml0ZW0sCgkJICBjb25zdCB4bWxDaGFyICpyZWZOYW1lLAoJCSAgY29uc3QgeG1sQ2hhciAqcmVmVGFyZ2V0TnMpCnsKICAgIHhtbFNjaGVtYVJlZGVmUHRyIHJldDsKCiAgICByZXQgPSAoeG1sU2NoZW1hUmVkZWZQdHIpCgl4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYVJlZGVmKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkocGN0eHQsCgkgICAgImFsbG9jYXRpbmcgcmVkZWZpbml0aW9uIGluZm8iLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hUmVkZWYpKTsKICAgIHJldC0+aXRlbSA9IGl0ZW07CiAgICByZXQtPnRhcmdldEJ1Y2tldCA9IHRhcmdldEJ1Y2tldDsKICAgIHJldC0+cmVmTmFtZSA9IHJlZk5hbWU7CiAgICByZXQtPnJlZlRhcmdldE5zID0gcmVmVGFyZ2V0TnM7CiAgICBpZiAoV1hTX0NPTlNUUlVDVE9SKHBjdHh0KS0+cmVkZWZzID09IE5VTEwpCglXWFNfQ09OU1RSVUNUT1IocGN0eHQpLT5yZWRlZnMgPSByZXQ7CiAgICBlbHNlCglXWFNfQ09OU1RSVUNUT1IocGN0eHQpLT5sYXN0UmVkZWYtPm5leHQgPSByZXQ7CiAgICBXWFNfQ09OU1RSVUNUT1IocGN0eHQpLT5sYXN0UmVkZWYgPSByZXQ7CgogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sU2NoZW1hQWRkQXR0cmlidXRlR3JvdXBEZWZpbml0aW9uOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBuYW1lOiAgdGhlIGl0ZW0gbmFtZQogKiBAbnNOYW1lOiAgdGhlIHRhcmdldCBuYW1lc3BhY2UKICogQG5vZGU6IHRoZSBjb3JyZXNwb25kaW5nIG5vZGUKICoKICogQWRkIGFuIFhNTCBzY2hlbWEgQXR0cnJpYnV0ZSBHcm91cCBkZWZpbml0aW9uLgogKgogKiBSZXR1cm5zIHRoZSBuZXcgc3RydXR1cmUgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIKeG1sU2NoZW1hQWRkQXR0cmlidXRlR3JvdXBEZWZpbml0aW9uKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEgQVRUUklCVVRFX1VOVVNFRCwKCQkJICAgY29uc3QgeG1sQ2hhciAqbmFtZSwKCQkJICAgY29uc3QgeG1sQ2hhciAqbnNOYW1lLAoJCQkgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyIHJldCA9IE5VTEw7CgogICAgaWYgKChwY3R4dCA9PSBOVUxMKSB8fCAobmFtZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9ICh4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0cikKICAgICAgICB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkocGN0eHQsICJhbGxvY2F0aW5nIGF0dHJpYnV0ZSBncm91cCIsIE5VTEwpOwoJcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cCkpOwogICAgcmV0LT50eXBlID0gWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQOwogICAgcmV0LT5uYW1lID0gbmFtZTsKICAgIHJldC0+dGFyZ2V0TmFtZXNwYWNlID0gbnNOYW1lOwogICAgcmV0LT5ub2RlID0gbm9kZTsgICAKCiAgICAvKiBUT0RPOiBSZW1vdmUgdGhlIGZsYWcuICovCiAgICByZXQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9HTE9CQUw7CiAgICBpZiAocGN0eHQtPmlzUmVkZWZpbmUpIHsKCXBjdHh0LT5yZWRlZiA9IHhtbFNjaGVtYUFkZFJlZGVmKHBjdHh0LCBwY3R4dC0+cmVkZWZpbmVkLAoJICAgIHJldCwgbmFtZSwgbnNOYW1lKTsKCWlmIChwY3R4dC0+cmVkZWYgPT0gTlVMTCkgewoJICAgIHhtbEZyZWUocmV0KTsKCSAgICByZXR1cm4oTlVMTCk7Cgl9CSAgICAKCXBjdHh0LT5yZWRlZkNvdW50ZXIgPSAwOwogICAgfQogICAgV1hTX0FERF9HTE9CQUwocGN0eHQsIHJldCk7CiAgICBXWFNfQUREX1BFTkRJTkcocGN0eHQsIHJldCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFBZGRFbGVtZW50OgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBuYW1lOiAgdGhlIHR5cGUgbmFtZQogKiBAbmFtZXNwYWNlOiAgdGhlIHR5cGUgbmFtZXNwYWNlCiAqCiAqIEFkZCBhbiBYTUwgc2NoZW1hIEVsZW1lbnQgZGVjbGFyYXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIHRoZSBuZXcgc3RydXR1cmUgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgeG1sU2NoZW1hRWxlbWVudFB0cgp4bWxTY2hlbWFBZGRFbGVtZW50KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKICAgICAgICAgICAgICAgICAgICBjb25zdCB4bWxDaGFyICogbmFtZSwgY29uc3QgeG1sQ2hhciAqIG5zTmFtZSwKCQkgICAgeG1sTm9kZVB0ciBub2RlLCBpbnQgdG9wTGV2ZWwpCnsKICAgIHhtbFNjaGVtYUVsZW1lbnRQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKG5hbWUgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKCiAgICByZXQgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFFbGVtZW50KSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIGVsZW1lbnQiLCBOVUxMKTsKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYUVsZW1lbnQpKTsKICAgIHJldC0+dHlwZSA9IFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOwogICAgcmV0LT5uYW1lID0gbmFtZTsKICAgIHJldC0+dGFyZ2V0TmFtZXNwYWNlID0gbnNOYW1lOwogICAgcmV0LT5ub2RlID0gbm9kZTsKCiAgICBpZiAodG9wTGV2ZWwpCglXWFNfQUREX0dMT0JBTChjdHh0LCByZXQpOwogICAgZWxzZQoJV1hTX0FERF9MT0NBTChjdHh0LCByZXQpOwogICAgV1hTX0FERF9QRU5ESU5HKGN0eHQsIHJldCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFBZGRUeXBlOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBuYW1lOiAgdGhlIGl0ZW0gbmFtZQogKiBAbmFtZXNwYWNlOiAgdGhlIG5hbWVzcGFjZQogKgogKiBBZGQgYW4gWE1MIHNjaGVtYSBpdGVtCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgbmV3IHN0cnV0dXJlIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8Kc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIKeG1sU2NoZW1hQWRkVHlwZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJIHhtbFNjaGVtYVR5cGVUeXBlIHR5cGUsCiAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhciAqIG5hbWUsIGNvbnN0IHhtbENoYXIgKiBuc05hbWUsCgkJIHhtbE5vZGVQdHIgbm9kZSwgaW50IHRvcExldmVsKQp7CiAgICB4bWxTY2hlbWFUeXBlUHRyIHJldCA9IE5VTEw7CgogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKCiAgICByZXQgPSAoeG1sU2NoZW1hVHlwZVB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFUeXBlKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIHR5cGUiLCBOVUxMKTsKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYVR5cGUpKTsKICAgIHJldC0+dHlwZSA9IHR5cGU7CiAgICByZXQtPm5hbWUgPSBuYW1lOwogICAgcmV0LT50YXJnZXROYW1lc3BhY2UgPSBuc05hbWU7CiAgICByZXQtPm5vZGUgPSBub2RlOwogICAgaWYgKHRvcExldmVsKSB7CglpZiAoY3R4dC0+aXNSZWRlZmluZSkgewoJICAgIGN0eHQtPnJlZGVmID0geG1sU2NoZW1hQWRkUmVkZWYoY3R4dCwgY3R4dC0+cmVkZWZpbmVkLAoJCXJldCwgbmFtZSwgbnNOYW1lKTsKCSAgICBpZiAoY3R4dC0+cmVkZWYgPT0gTlVMTCkgewoJCXhtbEZyZWUocmV0KTsKCQlyZXR1cm4oTlVMTCk7CgkgICAgfQkgICAgCgkgICAgY3R4dC0+cmVkZWZDb3VudGVyID0gMDsKCX0KCVdYU19BRERfR0xPQkFMKGN0eHQsIHJldCk7CiAgICB9IGVsc2UKCVdYU19BRERfTE9DQUwoY3R4dCwgcmV0KTsKICAgIFdYU19BRERfUEVORElORyhjdHh0LCByZXQpOyAgICAKICAgIHJldHVybiAocmV0KTsKfQoKc3RhdGljIHhtbFNjaGVtYVFOYW1lUmVmUHRyCnhtbFNjaGVtYU5ld1FOYW1lUmVmKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJICAgICB4bWxTY2hlbWFUeXBlVHlwZSByZWZUeXBlLAoJCSAgICAgY29uc3QgeG1sQ2hhciAqcmVmTmFtZSwKCQkgICAgIGNvbnN0IHhtbENoYXIgKnJlZk5zKQp7CiAgICB4bWxTY2hlbWFRTmFtZVJlZlB0ciByZXQ7CgogICAgcmV0ID0gKHhtbFNjaGVtYVFOYW1lUmVmUHRyKQoJeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFRTmFtZVJlZikpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQRXJyTWVtb3J5KHBjdHh0LAoJICAgICJhbGxvY2F0aW5nIFFOYW1lIHJlZmVyZW5jZSBpdGVtIiwgTlVMTCk7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgcmV0LT5ub2RlID0gTlVMTDsKICAgIHJldC0+dHlwZSA9IFhNTF9TQ0hFTUFfRVhUUkFfUU5BTUVSRUY7CiAgICByZXQtPm5hbWUgPSByZWZOYW1lOwogICAgcmV0LT50YXJnZXROYW1lc3BhY2UgPSByZWZOczsKICAgIHJldC0+aXRlbSA9IE5VTEw7CiAgICByZXQtPml0ZW1UeXBlID0gcmVmVHlwZTsKICAgIC8qCiAgICAqIFN0b3JlIHRoZSByZWZlcmVuY2UgaXRlbSBpbiB0aGUgc2NoZW1hLgogICAgKi8KICAgIFdYU19BRERfTE9DQUwocGN0eHQsIHJldCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCnN0YXRpYyB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQcm9oaWJQdHIKeG1sU2NoZW1hQWRkQXR0cmlidXRlVXNlUHJvaGliKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQpCnsKICAgIHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYlB0ciByZXQ7CgogICAgcmV0ID0gKHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYlB0cikKCXhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkocGN0eHQsCgkgICAgImFsbG9jYXRpbmcgYXR0cmlidXRlIHVzZSBwcm9oaWJpdGlvbiIsIE5VTEwpOwoJcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQcm9oaWIpKTsKICAgIHJldC0+dHlwZSA9IFhNTF9TQ0hFTUFfRVhUUkFfQVRUUl9VU0VfUFJPSElCOwogICAgV1hTX0FERF9MT0NBTChwY3R4dCwgcmV0KTsKICAgIHJldHVybiAocmV0KTsKfQoKCi8qKgogKiB4bWxTY2hlbWFBZGRNb2RlbEdyb3VwOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEB0eXBlOiB0aGUgImNvbXBvc2l0b3IiIHR5cGUgb2YgdGhlIG1vZGVsIGdyb3VwCiAqIEBub2RlOiB0aGUgbm9kZSBpbiB0aGUgc2NoZW1hIGRvYwogKgogKiBBZGRzIGEgc2NoZW1hIG1vZGVsIGdyb3VwCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgbmV3IHN0cnV0dXJlIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8Kc3RhdGljIHhtbFNjaGVtYU1vZGVsR3JvdXBQdHIKeG1sU2NoZW1hQWRkTW9kZWxHcm91cCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJICAgICAgIHhtbFNjaGVtYVR5cGVUeXBlIHR5cGUsCgkJICAgICAgIHhtbE5vZGVQdHIgbm9kZSkKewogICAgeG1sU2NoZW1hTW9kZWxHcm91cFB0ciByZXQgPSBOVUxMOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CgogICAgcmV0ID0gKHhtbFNjaGVtYU1vZGVsR3JvdXBQdHIpCgl4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYU1vZGVsR3JvdXApKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewoJeG1sU2NoZW1hUEVyck1lbW9yeShjdHh0LCAiYWxsb2NhdGluZyBtb2RlbCBncm91cCBjb21wb25lbnQiLAoJICAgIE5VTEwpOwoJcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFNb2RlbEdyb3VwKSk7CiAgICByZXQtPnR5cGUgPSB0eXBlOwogICAgcmV0LT5ub2RlID0gbm9kZTsKICAgIFdYU19BRERfTE9DQUwoY3R4dCwgcmV0KTsKICAgIGlmICgodHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UpIHx8CgkodHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFKSkKCVdYU19BRERfUEVORElORyhjdHh0LCByZXQpOwogICAgcmV0dXJuIChyZXQpOwp9CgoKLyoqCiAqIHhtbFNjaGVtYUFkZFBhcnRpY2xlOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiB0aGUgY29ycmVzcG9uZGluZyBub2RlIGluIHRoZSBzY2hlbWEgZG9jCiAqIEBtaW46IHRoZSBtaW5PY2N1cnMKICogQG1heDogdGhlIG1heE9jY3VycwogKgogKiBBZGRzIGFuIFhNTCBzY2hlbWEgcGFydGljbGUgY29tcG9uZW50LgogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgdGhlIG5ldyBzdHJ1dHVyZSBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFQYXJ0aWNsZVB0cgp4bWxTY2hlbWFBZGRQYXJ0aWNsZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJICAgICB4bWxOb2RlUHRyIG5vZGUsIGludCBtaW4sIGludCBtYXgpCnsKICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHJldCA9IE5VTEw7CiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKI2lmZGVmIERFQlVHCiAgICBmcHJpbnRmKHN0ZGVyciwgIkFkZGluZyBwYXJ0aWNsZSBjb21wb25lbnRcbiIpOwojZW5kaWYKICAgIHJldCA9ICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikKCXhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hUGFydGljbGUpKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewoJeG1sU2NoZW1hUEVyck1lbW9yeShjdHh0LCAiYWxsb2NhdGluZyBwYXJ0aWNsZSBjb21wb25lbnQiLAoJICAgIE5VTEwpOwoJcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIHJldC0+dHlwZSA9IFhNTF9TQ0hFTUFfVFlQRV9QQVJUSUNMRTsKICAgIHJldC0+YW5ub3QgPSBOVUxMOwogICAgcmV0LT5ub2RlID0gbm9kZTsKICAgIHJldC0+bWluT2NjdXJzID0gbWluOwogICAgcmV0LT5tYXhPY2N1cnMgPSBtYXg7CiAgICByZXQtPm5leHQgPSBOVUxMOwogICAgcmV0LT5jaGlsZHJlbiA9IE5VTEw7CgogICAgV1hTX0FERF9MT0NBTChjdHh0LCByZXQpOwogICAgLyogCiAgICAqIE5vdGUgdGhhdCBhZGRpdGlvbiB0byBwZW5kaW5nIGNvbXBvbmVudHMgd2lsbCBiZSBkb25lIGxvY2FsbHkKICAgICogdG8gdGhlIHNwZWNpZmljIHBhcnNpbmcgZnVuY3Rpb24sIHNpbmNlIHRoZSBtb3N0IHBhcnRpY2xlcwogICAgKiBuZWVkIG5vdCB0byBiZSBmaXhlZCB1cCAoaS5lLiB0aGUgcmVmZXJlbmNlIHRvIGJlIHJlc29sdmVkKS4KICAgICogUkVNT1ZFRDogV1hTX0FERF9QRU5ESU5HKGN0eHQsIHJldCk7CiAgICAqLwogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sU2NoZW1hQWRkTW9kZWxHcm91cERlZmluaXRpb246CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBuYW1lOiAgdGhlIGdyb3VwIG5hbWUKICoKICogQWRkIGFuIFhNTCBzY2hlbWEgR3JvdXAgZGVmaW5pdGlvbgogKgogKiBSZXR1cm5zIHRoZSBuZXcgc3RydXR1cmUgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cgp4bWxTY2hlbWFBZGRNb2RlbEdyb3VwRGVmaW5pdGlvbih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCQkgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJCSBjb25zdCB4bWxDaGFyICpuYW1lLAoJCQkJIGNvbnN0IHhtbENoYXIgKm5zTmFtZSwKCQkJCSB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYU1vZGVsR3JvdXBEZWZQdHIgcmV0ID0gTlVMTDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobmFtZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9ICh4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyKQoJeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFNb2RlbEdyb3VwRGVmKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhZGRpbmcgZ3JvdXAiLCBOVUxMKTsKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgfQogICAgbWVtc2V0KHJldCwgMCwgc2l6ZW9mKHhtbFNjaGVtYU1vZGVsR3JvdXBEZWYpKTsKICAgIHJldC0+bmFtZSA9IG5hbWU7CiAgICByZXQtPnR5cGUgPSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA7CiAgICByZXQtPm5vZGUgPSBub2RlOwogICAgcmV0LT50YXJnZXROYW1lc3BhY2UgPSBuc05hbWU7CgogICAgaWYgKGN0eHQtPmlzUmVkZWZpbmUpIHsKCWN0eHQtPnJlZGVmID0geG1sU2NoZW1hQWRkUmVkZWYoY3R4dCwgY3R4dC0+cmVkZWZpbmVkLAoJICAgIHJldCwgbmFtZSwgbnNOYW1lKTsKCWlmIChjdHh0LT5yZWRlZiA9PSBOVUxMKSB7CgkgICAgeG1sRnJlZShyZXQpOwoJICAgIHJldHVybihOVUxMKTsKCX0JICAgIAoJY3R4dC0+cmVkZWZDb3VudGVyID0gMDsKICAgIH0KICAgIFdYU19BRERfR0xPQkFMKGN0eHQsIHJldCk7CiAgICBXWFNfQUREX1BFTkRJTkcoY3R4dCwgcmV0KTsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYU5ld1dpbGRjYXJkTnM6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqCiAqIENyZWF0ZXMgYSBuZXcgd2lsZGNhcmQgbmFtZXNwYWNlIGNvbnN0cmFpbnQuCiAqCiAqIFJldHVybnMgdGhlIG5ldyBzdHJ1dHVyZSBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFXaWxkY2FyZE5zUHRyCnhtbFNjaGVtYU5ld1dpbGRjYXJkTnNDb25zdHJhaW50KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCkKewogICAgeG1sU2NoZW1hV2lsZGNhcmROc1B0ciByZXQ7CgogICAgcmV0ID0gKHhtbFNjaGVtYVdpbGRjYXJkTnNQdHIpCgl4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYVdpbGRjYXJkTnMpKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewoJeG1sU2NoZW1hUEVyck1lbW9yeShjdHh0LCAiY3JlYXRpbmcgd2lsZGNhcmQgbmFtZXNwYWNlIGNvbnN0cmFpbnQiLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICByZXQtPnZhbHVlID0gTlVMTDsKICAgIHJldC0+bmV4dCA9IE5VTEw7CiAgICByZXR1cm4gKHJldCk7Cn0KCnN0YXRpYyB4bWxTY2hlbWFJRENQdHIKeG1sU2NoZW1hQWRkSURDKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sU2NoZW1hUHRyIHNjaGVtYSwKICAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhciAqbmFtZSwgY29uc3QgeG1sQ2hhciAqbnNOYW1lLAoJCSAgaW50IGNhdGVnb3J5LCB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYUlEQ1B0ciByZXQgPSBOVUxMOyAgICAKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobmFtZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9ICh4bWxTY2hlbWFJRENQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hSURDKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsCgkgICAgImFsbG9jYXRpbmcgYW4gaWRlbnRpdHktY29uc3RyYWludCBkZWZpbml0aW9uIiwgTlVMTCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFJREMpKTsKICAgIC8qIFRoZSB0YXJnZXQgbmFtZXNwYWNlIG9mIHRoZSBwYXJlbnQgZWxlbWVudCBkZWNsYXJhdGlvbi4gKi8KICAgIHJldC0+dGFyZ2V0TmFtZXNwYWNlID0gbnNOYW1lOwogICAgcmV0LT5uYW1lID0gbmFtZTsKICAgIHJldC0+dHlwZSA9IGNhdGVnb3J5OwogICAgcmV0LT5ub2RlID0gbm9kZTsgICAgICAgIAogICAgCiAgICBXWFNfQUREX0dMT0JBTChjdHh0LCByZXQpOwogICAgLyoKICAgICogT25seSBrZXlyZWZzIG5lZWQgdG8gYmUgZml4dXAgdXAuCiAgICAqLwogICAgaWYgKGNhdGVnb3J5ID09IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGKQoJV1hTX0FERF9QRU5ESU5HKGN0eHQsIHJldCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFBZGRXaWxkY2FyZDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogYSBzY2hlbWEKICoKICogQWRkcyBhIHdpbGRjYXJkLgogKiBJdCBjb3JyZXNwb25kcyB0byBhIHhzZDphbnlBdHRyaWJ1dGUgYW5kIHhzZDphbnkuCiAqCiAqIFJldHVybnMgdGhlIG5ldyBzdHJ1dHVyZSBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFXaWxkY2FyZFB0cgp4bWxTY2hlbWFBZGRXaWxkY2FyZCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJICAgICB4bWxTY2hlbWFUeXBlVHlwZSB0eXBlLCB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYVdpbGRjYXJkUHRyIHJldCA9IE5VTEw7CgogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKCiAgICByZXQgPSAoeG1sU2NoZW1hV2lsZGNhcmRQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hV2lsZGNhcmQpKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewogICAgICAgIHhtbFNjaGVtYVBFcnJNZW1vcnkoY3R4dCwgImFkZGluZyB3aWxkY2FyZCIsIE5VTEwpOwogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hV2lsZGNhcmQpKTsKICAgIHJldC0+dHlwZSA9IHR5cGU7CiAgICByZXQtPm5vZGUgPSBub2RlOyAgICAKICAgIFdYU19BRERfTE9DQUwoY3R4dCwgcmV0KTsKICAgIHJldHVybiAocmV0KTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hU3Vic3RHcm91cEZyZWUoeG1sU2NoZW1hU3Vic3RHcm91cFB0ciBncm91cCkKewogICAgaWYgKGdyb3VwID09IE5VTEwpCglyZXR1cm47CiAgICBpZiAoZ3JvdXAtPm1lbWJlcnMgIT0gTlVMTCkKCXhtbFNjaGVtYUl0ZW1MaXN0RnJlZShncm91cC0+bWVtYmVycyk7CiAgICB4bWxGcmVlKGdyb3VwKTsKfQoKc3RhdGljIHhtbFNjaGVtYVN1YnN0R3JvdXBQdHIKeG1sU2NoZW1hU3Vic3RHcm91cEFkZCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCSAgICAgICB4bWxTY2hlbWFFbGVtZW50UHRyIGhlYWQpCnsKICAgIHhtbFNjaGVtYVN1YnN0R3JvdXBQdHIgcmV0OwoKICAgIC8qIEluaXQgc3Vic3QgZ3JvdXAgaGFzaC4gKi8KICAgIGlmIChXWFNfU1VCU1RfR1JPVVBTKHBjdHh0KSA9PSBOVUxMKSB7CglXWFNfU1VCU1RfR1JPVVBTKHBjdHh0KSA9IHhtbEhhc2hDcmVhdGVEaWN0KDEwLCBwY3R4dC0+ZGljdCk7CglpZiAoV1hTX1NVQlNUX0dST1VQUyhwY3R4dCkgPT0gTlVMTCkKCSAgICByZXR1cm4oTlVMTCk7CiAgICB9CiAgICAvKiBDcmVhdGUgYSBuZXcgc3Vic3RpdHV0aW9uIGdyb3VwLiAqLwogICAgcmV0ID0gKHhtbFNjaGVtYVN1YnN0R3JvdXBQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hU3Vic3RHcm91cCkpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQRXJyTWVtb3J5KE5VTEwsCgkgICAgImFsbG9jYXRpbmcgYSBzdWJzdGl0dXRpb24gZ3JvdXAgY29udGFpbmVyIiwgTlVMTCk7CglyZXR1cm4oTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hU3Vic3RHcm91cCkpOwogICAgcmV0LT5oZWFkID0gaGVhZDsKICAgIC8qIENyZWF0ZSBsaXN0IG9mIG1lbWJlcnMuICovCiAgICByZXQtPm1lbWJlcnMgPSB4bWxTY2hlbWFJdGVtTGlzdENyZWF0ZSgpOwogICAgaWYgKHJldC0+bWVtYmVycyA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFTdWJzdEdyb3VwRnJlZShyZXQpOwoJcmV0dXJuKE5VTEwpOwogICAgfQogICAgLyogQWRkIHN1YnN0IGdyb3VwIHRvIGhhc2guICovCiAgICBpZiAoeG1sSGFzaEFkZEVudHJ5MihXWFNfU1VCU1RfR1JPVVBTKHBjdHh0KSwKCWhlYWQtPm5hbWUsIGhlYWQtPnRhcmdldE5hbWVzcGFjZSwgcmV0KSAhPSAwKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFTdWJzdEdyb3VwQWRkIiwKCSAgICAiZmFpbGVkIHRvIGFkZCBhIG5ldyBzdWJzdGl0dXRpb24gY29udGFpbmVyIik7Cgl4bWxTY2hlbWFTdWJzdEdyb3VwRnJlZShyZXQpOwoJcmV0dXJuKE5VTEwpOwogICAgfQogICAgcmV0dXJuKHJldCk7Cn0KCnN0YXRpYyB4bWxTY2hlbWFTdWJzdEdyb3VwUHRyCnhtbFNjaGVtYVN1YnN0R3JvdXBHZXQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkgICAgICAgeG1sU2NoZW1hRWxlbWVudFB0ciBoZWFkKQp7ICAgCiAgICBpZiAoV1hTX1NVQlNUX0dST1VQUyhwY3R4dCkgPT0gTlVMTCkKCXJldHVybihOVUxMKTsKICAgIHJldHVybih4bWxIYXNoTG9va3VwMihXWFNfU1VCU1RfR1JPVVBTKHBjdHh0KSwKCWhlYWQtPm5hbWUsIGhlYWQtPnRhcmdldE5hbWVzcGFjZSkpOwoKfQoKLyoqCiAqIHhtbFNjaGVtYUFkZEVsZW1lbnRTdWJzdGl0dXRpb25NZW1iZXI6CiAqIEBwY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBoZWFkOiAgdGhlIGhlYWQgb2YgdGhlIHN1YnN0aXR1dGlvbiBncm91cAogKiBAbWVtYmVyOiB0aGUgbmV3IG1lbWJlciBvZiB0aGUgc3Vic3RpdHV0aW9uIGdyb3VwCiAqCiAqIEFsbG9jYXRlIGEgbmV3IGFubm90YXRpb24gc3RydWN0dXJlLgogKgogKiBSZXR1cm5zIHRoZSBuZXdseSBhbGxvY2F0ZWQgc3RydWN0dXJlIG9yIE5VTEwgaW4gY2FzZSBvciBlcnJvcgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFBZGRFbGVtZW50U3Vic3RpdHV0aW9uTWVtYmVyKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgICAgICB4bWxTY2hlbWFFbGVtZW50UHRyIGhlYWQsCgkJCQkgICAgICB4bWxTY2hlbWFFbGVtZW50UHRyIG1lbWJlcikKewogICAgeG1sU2NoZW1hU3Vic3RHcm91cFB0ciBzdWJzdEdyb3VwID0gTlVMTDsKCiAgICBpZiAoKHBjdHh0ID09IE5VTEwpIHx8IChoZWFkID09IE5VTEwpIHx8IChtZW1iZXIgPT0gTlVMTCkpCglyZXR1cm4gKC0xKTsKCiAgICBzdWJzdEdyb3VwID0geG1sU2NoZW1hU3Vic3RHcm91cEdldChwY3R4dCwgaGVhZCk7CiAgICBpZiAoc3Vic3RHcm91cCA9PSBOVUxMKQoJc3Vic3RHcm91cCA9IHhtbFNjaGVtYVN1YnN0R3JvdXBBZGQocGN0eHQsIGhlYWQpOwogICAgaWYgKHN1YnN0R3JvdXAgPT0gTlVMTCkKCXJldHVybigtMSk7CiAgICBpZiAoeG1sU2NoZW1hSXRlbUxpc3RBZGQoc3Vic3RHcm91cC0+bWVtYmVycywgbWVtYmVyKSA9PSAtMSkKCXJldHVybigtMSk7CiAgICByZXR1cm4oMCk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCQkJCQkJKgogKgkJVXRpbGl0aWVzIGZvciBwYXJzaW5nCQkJCQkqCiAqIAkJCQkJCQkJCSoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCi8qKgogKiB4bWxTY2hlbWFQVmFsQXR0ck5vZGVRTmFtZVZhbHVlOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6IHRoZSBzY2hlbWEgY29udGV4dAogKiBAb3duZXJEZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiB0aGUgcGFyZW50IGVsZW1lbnQKICogQG93bmVySXRlbTogdGhlIHBhcmVudCBhcyBhIHNjaGVtYSBvYmplY3QKICogQHZhbHVlOiAgdGhlIFFOYW1lIHZhbHVlCiAqIEBsb2NhbDogdGhlIHJlc3VsdGluZyBsb2NhbCBwYXJ0IGlmIGZvdW5kLCB0aGUgYXR0cmlidXRlIHZhbHVlIG90aGVyd2lzZQogKiBAdXJpOiAgdGhlIHJlc3VsdGluZyBuYW1lc3BhY2UgVVJJIGlmIGZvdW5kCiAqCiAqIEV4dHJhY3RzIHRoZSBsb2NhbCBuYW1lIGFuZCB0aGUgVVJJIG9mIGEgUU5hbWUgdmFsdWUgYW5kIHZhbGlkYXRlcyBpdC4KICogVGhpcyBvbmUgaXMgaW50ZW5kZWQgdG8gYmUgdXNlZCBvbiBhdHRyaWJ1dGUgdmFsdWVzIHRoYXQKICogc2hvdWxkIHJlc29sdmUgdG8gc2NoZW1hIGNvbXBvbmVudHMuCiAqCiAqIFJldHVybnMgMCwgaW4gY2FzZSB0aGUgUU5hbWUgaXMgdmFsaWQsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiBpZiBub3QgdmFsaWQgYW5kIC0xIGlmIGFuIGludGVybmFsIGVycm9yIG9jY3Vycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHJOb2RlUU5hbWVWYWx1ZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCQkgICAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJCSAgICAgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJJdGVtLAoJCQkJICAgICAgIHhtbEF0dHJQdHIgYXR0ciwKCQkJCSAgICAgICBjb25zdCB4bWxDaGFyICp2YWx1ZSwKCQkJCSAgICAgICBjb25zdCB4bWxDaGFyICoqdXJpLAoJCQkJICAgICAgIGNvbnN0IHhtbENoYXIgKipsb2NhbCkKewogICAgY29uc3QgeG1sQ2hhciAqcHJlZjsKICAgIHhtbE5zUHRyIG5zOwogICAgaW50IGxlbiwgcmV0OwoKICAgICp1cmkgPSBOVUxMOwogICAgKmxvY2FsID0gTlVMTDsKICAgIHJldCA9IHhtbFZhbGlkYXRlUU5hbWUodmFsdWUsIDEpOwogICAgaWYgKHJldCA+IDApIHsKCXhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCSAgICBvd25lckl0ZW0sICh4bWxOb2RlUHRyKSBhdHRyLAoJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX1FOQU1FKSwKCSAgICBOVUxMLCB2YWx1ZSwgTlVMTCwgTlVMTCwgTlVMTCk7CgkqbG9jYWwgPSB2YWx1ZTsKCXJldHVybiAoY3R4dC0+ZXJyKTsKICAgIH0gZWxzZSBpZiAocmV0IDwgMCkKCXJldHVybiAoLTEpOwoKICAgIGlmICghc3RyY2hyKChjaGFyICopIHZhbHVlLCAnOicpKSB7CglucyA9IHhtbFNlYXJjaE5zKGF0dHItPmRvYywgYXR0ci0+cGFyZW50LCBOVUxMKTsKCWlmIChucykKCSAgICAqdXJpID0geG1sRGljdExvb2t1cChjdHh0LT5kaWN0LCBucy0+aHJlZiwgLTEpOwoJZWxzZSBpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0lOQ0xVRElOR19DT05WRVJUX05TKSB7CgkgICAgLyogVE9ETzogbW92ZSBYTUxfU0NIRU1BU19JTkNMVURJTkdfQ09OVkVSVF9OUyB0byB0aGUKCSAgICAqIHBhcnNlciBjb250ZXh0LiAqLwoJICAgIC8qCgkgICAgKiBUaGlzIG9uZSB0YWtlcyBjYXJlIG9mIGluY2x1ZGVkIHNjaGVtYXMgd2l0aCBubwoJICAgICogdGFyZ2V0IG5hbWVzcGFjZS4KCSAgICAqLwoJICAgICp1cmkgPSBjdHh0LT50YXJnZXROYW1lc3BhY2U7Cgl9CgkqbG9jYWwgPSB4bWxEaWN0TG9va3VwKGN0eHQtPmRpY3QsIHZhbHVlLCAtMSk7CglyZXR1cm4gKDApOwogICAgfQogICAgLyoKICAgICogQXQgdGhpcyBwb2ludCB4bWxTcGxpdFFOYW1lMyBoYXMgdG8gcmV0dXJuIGEgbG9jYWwgbmFtZS4KICAgICovCiAgICAqbG9jYWwgPSB4bWxTcGxpdFFOYW1lMyh2YWx1ZSwgJmxlbik7CiAgICAqbG9jYWwgPSB4bWxEaWN0TG9va3VwKGN0eHQtPmRpY3QsICpsb2NhbCwgLTEpOwogICAgcHJlZiA9IHhtbERpY3RMb29rdXAoY3R4dC0+ZGljdCwgdmFsdWUsIGxlbik7CiAgICBucyA9IHhtbFNlYXJjaE5zKGF0dHItPmRvYywgYXR0ci0+cGFyZW50LCBwcmVmKTsKICAgIGlmIChucyA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkgICAgb3duZXJJdGVtLCAoeG1sTm9kZVB0cikgYXR0ciwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19RTkFNRSksIE5VTEwsIHZhbHVlLAoJICAgICJUaGUgdmFsdWUgJyVzJyBvZiBzaW1wbGUgdHlwZSAneHM6UU5hbWUnIGhhcyBubyAiCgkgICAgImNvcnJlc3BvbmRpbmcgbmFtZXNwYWNlIGRlY2xhcmF0aW9uIGluIHNjb3BlIiwgdmFsdWUsIE5VTEwpOwoJcmV0dXJuIChjdHh0LT5lcnIpOwogICAgfSBlbHNlIHsKICAgICAgICAqdXJpID0geG1sRGljdExvb2t1cChjdHh0LT5kaWN0LCBucy0+aHJlZiwgLTEpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBWYWxBdHRyTm9kZVFOYW1lOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6IHRoZSBzY2hlbWEgY29udGV4dAogKiBAb3duZXJEZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiB0aGUgb3duZXIgZWxlbWVudAogKiBAb3duZXJJdGVtOiB0aGUgb3duZXIgYXMgYSBzY2hlbWEgb2JqZWN0CiAqIEBhdHRyOiAgdGhlIGF0dHJpYnV0ZSBub2RlCiAqIEBsb2NhbDogdGhlIHJlc3VsdGluZyBsb2NhbCBwYXJ0IGlmIGZvdW5kLCB0aGUgYXR0cmlidXRlIHZhbHVlIG90aGVyd2lzZQogKiBAdXJpOiAgdGhlIHJlc3VsdGluZyBuYW1lc3BhY2UgVVJJIGlmIGZvdW5kCiAqCiAqIEV4dHJhY3RzIGFuZCB2YWxpZGF0ZXMgdGhlIFFOYW1lIG9mIGFuIGF0dHJpYnV0ZSB2YWx1ZS4KICogVGhpcyBvbmUgaXMgaW50ZW5kZWQgdG8gYmUgdXNlZCBvbiBhdHRyaWJ1dGUgdmFsdWVzIHRoYXQKICogc2hvdWxkIHJlc29sdmUgdG8gc2NoZW1hIGNvbXBvbmVudHMuCiAqCiAqIFJldHVybnMgMCwgaW4gY2FzZSB0aGUgUU5hbWUgaXMgdmFsaWQsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiBpZiBub3QgdmFsaWQgYW5kIC0xIGlmIGFuIGludGVybmFsIGVycm9yIG9jY3Vycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHJOb2RlUU5hbWUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJCQkgICAgICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIG93bmVySXRlbSwKCQkJCSAgICAgICB4bWxBdHRyUHRyIGF0dHIsCgkJCQkgICAgICAgY29uc3QgeG1sQ2hhciAqKnVyaSwKCQkJCSAgICAgICBjb25zdCB4bWxDaGFyICoqbG9jYWwpCnsKICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlOwoKICAgIHZhbHVlID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQoY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwogICAgcmV0dXJuICh4bWxTY2hlbWFQVmFsQXR0ck5vZGVRTmFtZVZhbHVlKGN0eHQsIHNjaGVtYSwKCW93bmVySXRlbSwgYXR0ciwgdmFsdWUsIHVyaSwgbG9jYWwpKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBWYWxBdHRyUU5hbWU6CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHNjaGVtYTogdGhlIHNjaGVtYSBjb250ZXh0CiAqIEBvd25lckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBwYXJlbnQgZWxlbWVudAogKiBAb3duZXJJdGVtOiB0aGUgb3duZXIgYXMgYSBzY2hlbWEgb2JqZWN0CiAqIEBvd25lckVsZW06ICB0aGUgcGFyZW50IG5vZGUgb2YgdGhlIGF0dHJpYnV0ZQogKiBAbmFtZTogIHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUKICogQGxvY2FsOiB0aGUgcmVzdWx0aW5nIGxvY2FsIHBhcnQgaWYgZm91bmQsIHRoZSBhdHRyaWJ1dGUgdmFsdWUgb3RoZXJ3aXNlCiAqIEB1cmk6ICB0aGUgcmVzdWx0aW5nIG5hbWVzcGFjZSBVUkkgaWYgZm91bmQKICoKICogRXh0cmFjdHMgYW5kIHZhbGlkYXRlcyB0aGUgUU5hbWUgb2YgYW4gYXR0cmlidXRlIHZhbHVlLgogKgogKiBSZXR1cm5zIDAsIGluIGNhc2UgdGhlIFFOYW1lIGlzIHZhbGlkLCBhIHBvc2l0aXZlIGVycm9yIGNvZGUKICogaWYgbm90IHZhbGlkIGFuZCAtMSBpZiBhbiBpbnRlcm5hbCBlcnJvciBvY2N1cnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVBWYWxBdHRyUU5hbWUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJCSAgIHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBvd25lckl0ZW0sCgkJCQkgICB4bWxOb2RlUHRyIG93bmVyRWxlbSwKCQkJCSAgIGNvbnN0IGNoYXIgKm5hbWUsCgkJCQkgICBjb25zdCB4bWxDaGFyICoqdXJpLAoJCQkJICAgY29uc3QgeG1sQ2hhciAqKmxvY2FsKQp7CiAgICB4bWxBdHRyUHRyIGF0dHI7CgogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG93bmVyRWxlbSwgbmFtZSk7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7CgkqbG9jYWwgPSBOVUxMOwoJKnVyaSA9IE5VTEw7CglyZXR1cm4gKDApOwogICAgfQogICAgcmV0dXJuICh4bWxTY2hlbWFQVmFsQXR0ck5vZGVRTmFtZShjdHh0LCBzY2hlbWEsCglvd25lckl0ZW0sIGF0dHIsIHVyaSwgbG9jYWwpKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBWYWxBdHRySUQ6CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHNjaGVtYTogdGhlIHNjaGVtYSBjb250ZXh0CiAqIEBvd25lckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBwYXJlbnQgZWxlbWVudAogKiBAb3duZXJJdGVtOiB0aGUgb3duZXIgYXMgYSBzY2hlbWEgb2JqZWN0CiAqIEBvd25lckVsZW06ICB0aGUgcGFyZW50IG5vZGUgb2YgdGhlIGF0dHJpYnV0ZQogKiBAbmFtZTogIHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUKICoKICogRXh0cmFjdHMgYW5kIHZhbGlkYXRlcyB0aGUgSUQgb2YgYW4gYXR0cmlidXRlIHZhbHVlLgogKgogKiBSZXR1cm5zIDAsIGluIGNhc2UgdGhlIElEIGlzIHZhbGlkLCBhIHBvc2l0aXZlIGVycm9yIGNvZGUKICogaWYgbm90IHZhbGlkIGFuZCAtMSBpZiBhbiBpbnRlcm5hbCBlcnJvciBvY2N1cnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVBWYWxBdHRyTm9kZUlEKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sQXR0clB0ciBhdHRyKQp7CiAgICBpbnQgcmV0OwogICAgY29uc3QgeG1sQ2hhciAqdmFsdWU7CgogICAgaWYgKGF0dHIgPT0gTlVMTCkKCXJldHVybigwKTsKICAgIHZhbHVlID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnROb0RpY3QoKHhtbE5vZGVQdHIpIGF0dHIpOwogICAgcmV0ID0geG1sVmFsaWRhdGVOQ05hbWUodmFsdWUsIDEpOwogICAgaWYgKHJldCA9PSAwKSB7CgkvKgoJKiBOT1RFOiB0aGUgSURuZXNzIG1pZ2h0IGhhdmUgYWxyZWFkeSBiZSBkZWNsYXJlZCBpbiB0aGUgRFRECgkqLwoJaWYgKGF0dHItPmF0eXBlICE9IFhNTF9BVFRSSUJVVEVfSUQpIHsKCSAgICB4bWxJRFB0ciByZXM7CgkgICAgeG1sQ2hhciAqc3RyaXA7CgoJICAgIC8qCgkgICAgKiBUT0RPOiBVc2UgeG1sU2NoZW1hU3RyaXAgaGVyZTsgaXQncyBub3QgZXhwb3J0ZWQgYXQgdGhpcwoJICAgICogbW9tZW50LgoJICAgICovCgkgICAgc3RyaXAgPSB4bWxTY2hlbWFDb2xsYXBzZVN0cmluZyh2YWx1ZSk7CgkgICAgaWYgKHN0cmlwICE9IE5VTEwpIHsKCQl4bWxGcmVlKCh4bWxDaGFyICopIHZhbHVlKTsKCQl2YWx1ZSA9IHN0cmlwOwoJICAgIH0KICAgIAkgICAgcmVzID0geG1sQWRkSUQoTlVMTCwgYXR0ci0+ZG9jLCB2YWx1ZSwgYXR0cik7CgkgICAgaWYgKHJlcyA9PSBOVUxMKSB7CgkJcmV0ID0gWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRTsKCQl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9JTlZBTElEX1ZBTFVFLAoJCSAgICBOVUxMLCAoeG1sTm9kZVB0cikgYXR0ciwKCQkgICAgeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfSUQpLAoJCSAgICBOVUxMLCBOVUxMLCAiRHVwbGljYXRlIHZhbHVlICclcycgb2Ygc2ltcGxlICIKCQkgICAgInR5cGUgJ3hzOklEJyIsIHZhbHVlLCBOVUxMKTsKCSAgICB9IGVsc2UKCQlhdHRyLT5hdHlwZSA9IFhNTF9BVFRSSUJVVEVfSUQ7Cgl9CiAgICB9IGVsc2UgaWYgKHJldCA+IDApIHsKCXJldCA9IFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUU7Cgl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsCgkgICAgeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfSUQpLAoJICAgIE5VTEwsIE5VTEwsICJUaGUgdmFsdWUgJyVzJyBvZiBzaW1wbGUgdHlwZSAneHM6SUQnIGlzICIKCSAgICAibm90IGEgdmFsaWQgJ3hzOk5DTmFtZSciLAoJICAgIHZhbHVlLCBOVUxMKTsKICAgIH0KICAgIGlmICh2YWx1ZSAhPSBOVUxMKQoJeG1sRnJlZSgoeG1sQ2hhciAqKXZhbHVlKTsKCiAgICByZXR1cm4gKHJldCk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHJJRCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJICAgIHhtbE5vZGVQdHIgb3duZXJFbGVtLAoJCSAgICBjb25zdCB4bWxDaGFyICpuYW1lKQp7CiAgICB4bWxBdHRyUHRyIGF0dHI7CgogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG93bmVyRWxlbSwgKGNvbnN0IGNoYXIgKikgbmFtZSk7CiAgICBpZiAoYXR0ciA9PSBOVUxMKQoJcmV0dXJuKDApOwogICAgcmV0dXJuKHhtbFNjaGVtYVBWYWxBdHRyTm9kZUlEKGN0eHQsIGF0dHIpKTsKCn0KCi8qKgogKiB4bWxHZXRNYXhPY2N1cnM6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogR2V0IHRoZSBtYXhPY2N1cnMgcHJvcGVydHkKICoKICogUmV0dXJucyB0aGUgZGVmYXVsdCBpZiBub3QgZm91bmQsIG9yIHRoZSB2YWx1ZQogKi8Kc3RhdGljIGludAp4bWxHZXRNYXhPY2N1cnMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxOb2RlUHRyIG5vZGUsCgkJaW50IG1pbiwgaW50IG1heCwgaW50IGRlZiwgY29uc3QgY2hhciAqZXhwZWN0ZWQpCnsKICAgIGNvbnN0IHhtbENoYXIgKnZhbCwgKmN1cjsKICAgIGludCByZXQgPSAwOwogICAgeG1sQXR0clB0ciBhdHRyOwoKICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibWF4T2NjdXJzIik7CiAgICBpZiAoYXR0ciA9PSBOVUxMKQoJcmV0dXJuIChkZWYpOwogICAgdmFsID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQoY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwoKICAgIGlmICh4bWxTdHJFcXVhbCh2YWwsIChjb25zdCB4bWxDaGFyICopICJ1bmJvdW5kZWQiKSkgewoJaWYgKG1heCAhPSBVTkJPVU5ERUQpIHsKCSAgICB4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkJLyogWE1MX1NDSEVNQVBfSU5WQUxJRF9NSU5PQ0NVUlMsICovCgkJTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsIE5VTEwsIGV4cGVjdGVkLAoJCXZhbCwgTlVMTCwgTlVMTCwgTlVMTCk7CgkgICAgcmV0dXJuIChkZWYpOwoJfSBlbHNlCgkgICAgcmV0dXJuIChVTkJPVU5ERUQpOyAgLyogZW5jb2RpbmcgaXQgd2l0aCAtMSBtaWdodCBiZSBhbm90aGVyIG9wdGlvbiAqLwogICAgfQoKICAgIGN1ciA9IHZhbDsKICAgIHdoaWxlIChJU19CTEFOS19DSCgqY3VyKSkKICAgICAgICBjdXIrKzsKICAgIGlmICgqY3VyID09IDApIHsKICAgICAgICB4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkgICAgLyogWE1MX1NDSEVNQVBfSU5WQUxJRF9NSU5PQ0NVUlMsICovCgkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsIE5VTEwsIGV4cGVjdGVkLAoJICAgIHZhbCwgTlVMTCwgTlVMTCwgTlVMTCk7CglyZXR1cm4gKGRlZik7CiAgICB9CiAgICB3aGlsZSAoKCpjdXIgPj0gJzAnKSAmJiAoKmN1ciA8PSAnOScpKSB7CiAgICAgICAgcmV0ID0gcmV0ICogMTAgKyAoKmN1ciAtICcwJyk7CiAgICAgICAgY3VyKys7CiAgICB9CiAgICB3aGlsZSAoSVNfQkxBTktfQ0goKmN1cikpCiAgICAgICAgY3VyKys7CiAgICAvKgogICAgKiBUT0RPOiBSZXN0cmljdCB0aGUgbWF4aW1hbCB2YWx1ZSB0byBJbnRlZ2VyLgogICAgKi8KICAgIGlmICgoKmN1ciAhPSAwKSB8fCAocmV0IDwgbWluKSB8fCAoKG1heCAhPSAtMSkgJiYgKHJldCA+IG1heCkpKSB7Cgl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkgICAgLyogWE1MX1NDSEVNQVBfSU5WQUxJRF9NSU5PQ0NVUlMsICovCgkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsIE5VTEwsIGV4cGVjdGVkLAoJICAgIHZhbCwgTlVMTCwgTlVMTCwgTlVMTCk7CiAgICAgICAgcmV0dXJuIChkZWYpOwogICAgfQogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sR2V0TWluT2NjdXJzOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqCiAqIEdldCB0aGUgbWluT2NjdXJzIHByb3BlcnR5CiAqCiAqIFJldHVybnMgdGhlIGRlZmF1bHQgaWYgbm90IGZvdW5kLCBvciB0aGUgdmFsdWUKICovCnN0YXRpYyBpbnQKeG1sR2V0TWluT2NjdXJzKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sTm9kZVB0ciBub2RlLAoJCWludCBtaW4sIGludCBtYXgsIGludCBkZWYsIGNvbnN0IGNoYXIgKmV4cGVjdGVkKQp7CiAgICBjb25zdCB4bWxDaGFyICp2YWwsICpjdXI7CiAgICBpbnQgcmV0ID0gMDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKCiAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgIm1pbk9jY3VycyIpOwogICAgaWYgKGF0dHIgPT0gTlVMTCkKCXJldHVybiAoZGVmKTsKICAgIHZhbCA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKICAgIGN1ciA9IHZhbDsKICAgIHdoaWxlIChJU19CTEFOS19DSCgqY3VyKSkKICAgICAgICBjdXIrKzsKICAgIGlmICgqY3VyID09IDApIHsKICAgICAgICB4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkgICAgLyogWE1MX1NDSEVNQVBfSU5WQUxJRF9NSU5PQ0NVUlMsICovCgkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsIE5VTEwsIGV4cGVjdGVkLAoJICAgIHZhbCwgTlVMTCwgTlVMTCwgTlVMTCk7CiAgICAgICAgcmV0dXJuIChkZWYpOwogICAgfQogICAgd2hpbGUgKCgqY3VyID49ICcwJykgJiYgKCpjdXIgPD0gJzknKSkgewogICAgICAgIHJldCA9IHJldCAqIDEwICsgKCpjdXIgLSAnMCcpOwogICAgICAgIGN1cisrOwogICAgfQogICAgd2hpbGUgKElTX0JMQU5LX0NIKCpjdXIpKQogICAgICAgIGN1cisrOwogICAgLyoKICAgICogVE9ETzogUmVzdHJpY3QgdGhlIG1heGltYWwgdmFsdWUgdG8gSW50ZWdlci4KICAgICovCiAgICBpZiAoKCpjdXIgIT0gMCkgfHwgKHJldCA8IG1pbikgfHwgKChtYXggIT0gLTEpICYmIChyZXQgPiBtYXgpKSkgewoJeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9JTlZBTElEX1ZBTFVFLAoJICAgIC8qIFhNTF9TQ0hFTUFQX0lOVkFMSURfTUlOT0NDVVJTLCAqLwoJICAgIE5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLCBOVUxMLCBleHBlY3RlZCwKCSAgICB2YWwsIE5VTEwsIE5VTEwsIE5VTEwpOwogICAgICAgIHJldHVybiAoZGVmKTsKICAgIH0KICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBHZXRCb29sTm9kZVZhbHVlOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAb3duZXJEZXM6ICBvd25lciBkZXNpZ25hdGlvbgogKiBAb3duZXJJdGVtOiAgdGhlIG93bmVyIGFzIGEgc2NoZW1hIGl0ZW0KICogQG5vZGU6IHRoZSBub2RlIGhvbGRpbmcgdGhlIHZhbHVlCiAqCiAqIENvbnZlcnRzIGEgYm9vbGVhbiBzdHJpbmcgdmFsdWUgaW50byAxIG9yIDAuCiAqCiAqIFJldHVybnMgMCBvciAxLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFQR2V0Qm9vbE5vZGVWYWx1ZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSAgIHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBvd25lckl0ZW0sCgkJCSAgIHhtbE5vZGVQdHIgbm9kZSkKewogICAgeG1sQ2hhciAqdmFsdWUgPSBOVUxMOwogICAgaW50IHJlcyA9IDA7CgogICAgdmFsdWUgPSB4bWxOb2RlR2V0Q29udGVudChub2RlKTsKICAgIC8qCiAgICAqIDMuMi4yLjEgTGV4aWNhbCByZXByZXNlbnRhdGlvbgogICAgKiBBbiBpbnN0YW5jZSBvZiBhIGRhdGF0eXBlIHRoYXQgaXMgZGVmaW5lZCBhcyC3Ym9vbGVhbrcKICAgICogY2FuIGhhdmUgdGhlIGZvbGxvd2luZyBsZWdhbCBsaXRlcmFscyB7dHJ1ZSwgZmFsc2UsIDEsIDB9LgogICAgKi8KICAgIGlmICh4bWxTdHJFcXVhbChCQURfQ0FTVCB2YWx1ZSwgQkFEX0NBU1QgInRydWUiKSkKICAgICAgICByZXMgPSAxOwogICAgZWxzZSBpZiAoeG1sU3RyRXF1YWwoQkFEX0NBU1QgdmFsdWUsIEJBRF9DQVNUICJmYWxzZSIpKQogICAgICAgIHJlcyA9IDA7CiAgICBlbHNlIGlmICh4bWxTdHJFcXVhbChCQURfQ0FTVCB2YWx1ZSwgQkFEX0NBU1QgIjEiKSkKCXJlcyA9IDE7CiAgICBlbHNlIGlmICh4bWxTdHJFcXVhbChCQURfQ0FTVCB2YWx1ZSwgQkFEX0NBU1QgIjAiKSkKICAgICAgICByZXMgPSAwOwogICAgZWxzZSB7CiAgICAgICAgeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9JTlZBTElEX0JPT0xFQU4sCgkgICAgb3duZXJJdGVtLCBub2RlLAoJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0JPT0xFQU4pLAoJICAgIE5VTEwsIEJBRF9DQVNUIHZhbHVlLAoJICAgIE5VTEwsIE5VTEwsIE5VTEwpOwogICAgfQogICAgaWYgKHZhbHVlICE9IE5VTEwpCgl4bWxGcmVlKHZhbHVlKTsKICAgIHJldHVybiAocmVzKTsKfQoKLyoqCiAqIHhtbEdldEJvb2xlYW5Qcm9wOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqIEBuYW1lOiAgdGhlIGF0dHJpYnV0ZSBuYW1lCiAqIEBkZWY6ICB0aGUgZGVmYXVsdCB2YWx1ZQogKgogKiBFdmFsdWF0ZSBpZiBhIGJvb2xlYW4gcHJvcGVydHkgaXMgc2V0CiAqCiAqIFJldHVybnMgdGhlIGRlZmF1bHQgaWYgbm90IGZvdW5kLCAwIGlmIGZvdW5kIHRvIGJlIGZhbHNlLAogKiAxIGlmIGZvdW5kIHRvIGJlIHRydWUKICovCnN0YXRpYyBpbnQKeG1sR2V0Qm9vbGVhblByb3AoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCSAgeG1sTm9kZVB0ciBub2RlLAogICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpuYW1lLCBpbnQgZGVmKQp7CiAgICBjb25zdCB4bWxDaGFyICp2YWw7CgogICAgdmFsID0geG1sU2NoZW1hR2V0UHJvcChjdHh0LCBub2RlLCBuYW1lKTsKICAgIGlmICh2YWwgPT0gTlVMTCkKICAgICAgICByZXR1cm4gKGRlZik7CiAgICAvKgogICAgKiAzLjIuMi4xIExleGljYWwgcmVwcmVzZW50YXRpb24KICAgICogQW4gaW5zdGFuY2Ugb2YgYSBkYXRhdHlwZSB0aGF0IGlzIGRlZmluZWQgYXMgt2Jvb2xlYW63CiAgICAqIGNhbiBoYXZlIHRoZSBmb2xsb3dpbmcgbGVnYWwgbGl0ZXJhbHMge3RydWUsIGZhbHNlLCAxLCAwfS4KICAgICovCiAgICBpZiAoeG1sU3RyRXF1YWwodmFsLCBCQURfQ0FTVCAidHJ1ZSIpKQogICAgICAgIGRlZiA9IDE7CiAgICBlbHNlIGlmICh4bWxTdHJFcXVhbCh2YWwsIEJBRF9DQVNUICJmYWxzZSIpKQogICAgICAgIGRlZiA9IDA7CiAgICBlbHNlIGlmICh4bWxTdHJFcXVhbCh2YWwsIEJBRF9DQVNUICIxIikpCglkZWYgPSAxOwogICAgZWxzZSBpZiAoeG1sU3RyRXF1YWwodmFsLCBCQURfQ0FTVCAiMCIpKQogICAgICAgIGRlZiA9IDA7CiAgICBlbHNlIHsKICAgICAgICB4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX0lOVkFMSURfQk9PTEVBTiwKCSAgICBOVUxMLAoJICAgICh4bWxOb2RlUHRyKSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCBuYW1lKSwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19CT09MRUFOKSwKCSAgICBOVUxMLCB2YWwsIE5VTEwsIE5VTEwsIE5VTEwpOwogICAgfQogICAgcmV0dXJuIChkZWYpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQkJCQkJCSoKICoJCVNoZW1hIGV4dHJhY3Rpb24gZnJvbSBhbiBJbmZvc2V0CQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCnN0YXRpYyB4bWxTY2hlbWFUeXBlUHRyIHhtbFNjaGVtYVBhcnNlU2ltcGxlVHlwZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1sTm9kZVB0ciBub2RlLAoJCQkJCQkgaW50IHRvcExldmVsKTsKc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIgeG1sU2NoZW1hUGFyc2VDb21wbGV4VHlwZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY3R4dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSwKCQkJCQkJICBpbnQgdG9wTGV2ZWwpOwpzdGF0aWMgeG1sU2NoZW1hVHlwZVB0ciB4bWxTY2hlbWFQYXJzZVJlc3RyaWN0aW9uKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1sTm9kZVB0ciBub2RlLAoJCQkJCQkgIHhtbFNjaGVtYVR5cGVUeXBlIHBhcmVudFR5cGUpOwpzdGF0aWMgeG1sU2NoZW1hQmFzaWNJdGVtUHRyCnhtbFNjaGVtYVBhcnNlTG9jYWxBdHRyaWJ1dGUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJICAgICB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkgICAgIHhtbE5vZGVQdHIgbm9kZSwKCQkJICAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciB1c2VzLAoJCQkgICAgIGludCBwYXJlbnRUeXBlKTsKc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIgeG1sU2NoZW1hUGFyc2VMaXN0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUpOwpzdGF0aWMgeG1sU2NoZW1hV2lsZGNhcmRQdHIKeG1sU2NoZW1hUGFyc2VBbnlBdHRyaWJ1dGUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFQdHIgc2NoZW1hLCB4bWxOb2RlUHRyIG5vZGUpOwoKLyoqCiAqIHhtbFNjaGVtYVBWYWxBdHRyTm9kZVZhbHVlOgogKgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBvd25lckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBwYXJlbnQgZWxlbWVudAogKiBAb3duZXJJdGVtOiB0aGUgc2NoZW1hIG9iamVjdCBvd25lciBpZiBleGlzdGVudAogKiBAYXR0cjogIHRoZSBzY2hlbWEgYXR0cmlidXRlIG5vZGUgYmVpbmcgdmFsaWRhdGVkCiAqIEB2YWx1ZTogdGhlIHZhbHVlCiAqIEB0eXBlOiB0aGUgYnVpbHQtaW4gdHlwZSB0byBiZSB2YWxpZGF0ZWQgYWdhaW5zdAogKgogKiBWYWxpZGF0ZXMgYSB2YWx1ZSBhZ2FpbnN0IHRoZSBnaXZlbiBidWlsdC1pbiB0eXBlLgogKiBUaGlzIG9uZSBpcyBpbnRlbmRlZCB0byBiZSB1c2VkIGludGVybmFsbHkgZm9yIHZhbGlkYXRpb24KICogb2Ygc2NoZW1hIGF0dHJpYnV0ZSB2YWx1ZXMgZHVyaW5nIHBhcnNpbmcgb2YgdGhlIHNjaGVtYS4KICoKICogUmV0dXJucyAwIGlmIHRoZSB2YWx1ZSBpcyB2YWxpZCwgYSBwb3NpdGl2ZSBlcnJvciBjb2RlCiAqIG51bWJlciBvdGhlcndpc2UgYW5kIC0xIGluIGNhc2Ugb2YgYW4gaW50ZXJuYWwgb3IgQVBJIGVycm9yLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFQVmFsQXR0ck5vZGVWYWx1ZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJJdGVtLAoJCQkgICB4bWxBdHRyUHRyIGF0dHIsCgkJCSAgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKCiAgICBpbnQgcmV0ID0gMDsKCiAgICAvKgogICAgKiBOT1RFOiBTaG91bGQgd2UgbW92ZSB0aGlzIHRvIHhtbHNjaGVtYXR5cGVzLmM/IEhtbSwgYnV0IHRoaXMKICAgICogb25lIGlzIHJlYWxseSBtZWFudCB0byBiZSB1c2VkIGludGVybmFsbHksIHNvIGJldHRlciBub3QuCiAgICAqLwogICAgaWYgKChwY3R4dCA9PSBOVUxMKSB8fCAodHlwZSA9PSBOVUxMKSB8fCAoYXR0ciA9PSBOVUxMKSkKCXJldHVybiAoLTEpOwogICAgaWYgKHR5cGUtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFQVmFsQXR0ck5vZGVWYWx1ZSIsCgkgICAgInRoZSBnaXZlbiB0eXBlIGlzIG5vdCBhIGJ1aWx0LWluIHR5cGUiKTsKCXJldHVybiAoLTEpOwogICAgfQogICAgc3dpdGNoICh0eXBlLT5idWlsdEluVHlwZSkgewoJY2FzZSBYTUxfU0NIRU1BU19OQ05BTUU6CgljYXNlIFhNTF9TQ0hFTUFTX1FOQU1FOgoJY2FzZSBYTUxfU0NIRU1BU19BTllVUkk6CgljYXNlIFhNTF9TQ0hFTUFTX1RPS0VOOgoJY2FzZSBYTUxfU0NIRU1BU19MQU5HVUFHRToKCSAgICByZXQgPSB4bWxTY2hlbWFWYWxQcmVkZWZUeXBlTm9kZSh0eXBlLCB2YWx1ZSwgTlVMTCwKCQkoeG1sTm9kZVB0cikgYXR0cik7CgkgICAgYnJlYWs7CglkZWZhdWx0OiB7CgkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hUFZhbEF0dHJOb2RlVmFsdWUiLAoJCSJ2YWxpZGF0aW9uIHVzaW5nIHRoZSBnaXZlbiB0eXBlIGlzIG5vdCBzdXBwb3J0ZWQgd2hpbGUgIgoJCSJwYXJzaW5nIGEgc2NoZW1hIik7CgkgICAgcmV0dXJuICgtMSk7Cgl9CiAgICB9CiAgICAvKgogICAgKiBUT0RPOiBTaG91bGQgd2UgdXNlIHRoZSBTNFMgZXJyb3IgY29kZXMgaW5zdGVhZD8KICAgICovCiAgICBpZiAocmV0IDwgMCkgewoJUEVSUk9SX0lOVCgieG1sU2NoZW1hUFZhbEF0dHJOb2RlVmFsdWUiLAoJICAgICJmYWlsZWQgdG8gdmFsaWRhdGUgYSBzY2hlbWEgYXR0cmlidXRlIHZhbHVlIik7CglyZXR1cm4gKC0xKTsKICAgIH0gZWxzZSBpZiAocmV0ID4gMCkgewoJaWYgKFdYU19JU19MSVNUKHR5cGUpKQoJICAgIHJldCA9IFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMjsKCWVsc2UKCSAgICByZXQgPSBYTUxfU0NIRU1BVl9DVkNfREFUQVRZUEVfVkFMSURfMV8yXzE7Cgl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihwY3R4dCwgCgkgICAgcmV0LCBvd25lckl0ZW0sICh4bWxOb2RlUHRyKSBhdHRyLAoJICAgIHR5cGUsIE5VTEwsIHZhbHVlLCBOVUxMLCBOVUxMLCBOVUxMKTsKICAgIH0KICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBWYWxBdHRyTm9kZToKICoKICogQGN0eHQ6ICBhIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAb3duZXJEZXM6IHRoZSBkZXNpZ25hdGlvbiBvZiB0aGUgcGFyZW50IGVsZW1lbnQKICogQG93bmVySXRlbTogdGhlIHNjaGVtYSBvYmplY3Qgb3duZXIgaWYgZXhpc3RlbnQKICogQGF0dHI6ICB0aGUgc2NoZW1hIGF0dHJpYnV0ZSBub2RlIGJlaW5nIHZhbGlkYXRlZAogKiBAdHlwZTogdGhlIGJ1aWx0LWluIHR5cGUgdG8gYmUgdmFsaWRhdGVkIGFnYWluc3QKICogQHZhbHVlOiB0aGUgcmVzdWx0aW5nIHZhbHVlIGlmIGFueQogKgogKiBFeHRyYWN0cyBhbmQgdmFsaWRhdGVzIGEgdmFsdWUgYWdhaW5zdCB0aGUgZ2l2ZW4gYnVpbHQtaW4gdHlwZS4KICogVGhpcyBvbmUgaXMgaW50ZW5kZWQgdG8gYmUgdXNlZCBpbnRlcm5hbGx5IGZvciB2YWxpZGF0aW9uCiAqIG9mIHNjaGVtYSBhdHRyaWJ1dGUgdmFsdWVzIGR1cmluZyBwYXJzaW5nIG9mIHRoZSBzY2hlbWEuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgdmFsdWUgaXMgdmFsaWQsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiBudW1iZXIgb3RoZXJ3aXNlIGFuZCAtMSBpbiBjYXNlIG9mIGFuIGludGVybmFsIG9yIEFQSSBlcnJvci4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHJOb2RlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIG93bmVySXRlbSwKCQkJICAgeG1sQXR0clB0ciBhdHRyLAoJCQkgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUsCgkJCSAgIGNvbnN0IHhtbENoYXIgKip2YWx1ZSkKewogICAgY29uc3QgeG1sQ2hhciAqdmFsOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAodHlwZSA9PSBOVUxMKSB8fCAoYXR0ciA9PSBOVUxMKSkKCXJldHVybiAoLTEpOwoKICAgIHZhbCA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKICAgIGlmICh2YWx1ZSAhPSBOVUxMKQoJKnZhbHVlID0gdmFsOwoKICAgIHJldHVybiAoeG1sU2NoZW1hUFZhbEF0dHJOb2RlVmFsdWUoY3R4dCwgb3duZXJJdGVtLCBhdHRyLAoJdmFsLCB0eXBlKSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQVmFsQXR0cjoKICoKICogQGN0eHQ6ICBhIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAbm9kZTogdGhlIGVsZW1lbnQgbm9kZSBvZiB0aGUgYXR0cmlidXRlCiAqIEBvd25lckRlczogdGhlIGRlc2lnbmF0aW9uIG9mIHRoZSBwYXJlbnQgZWxlbWVudAogKiBAb3duZXJJdGVtOiB0aGUgc2NoZW1hIG9iamVjdCBvd25lciBpZiBleGlzdGVudAogKiBAb3duZXJFbGVtOiB0aGUgb3duZXIgZWxlbWVudCBub2RlCiAqIEBuYW1lOiAgdGhlIG5hbWUgb2YgdGhlIHNjaGVtYSBhdHRyaWJ1dGUgbm9kZQogKiBAdHlwZTogdGhlIGJ1aWx0LWluIHR5cGUgdG8gYmUgdmFsaWRhdGVkIGFnYWluc3QKICogQHZhbHVlOiB0aGUgcmVzdWx0aW5nIHZhbHVlIGlmIGFueQogKgogKiBFeHRyYWN0cyBhbmQgdmFsaWRhdGVzIGEgdmFsdWUgYWdhaW5zdCB0aGUgZ2l2ZW4gYnVpbHQtaW4gdHlwZS4KICogVGhpcyBvbmUgaXMgaW50ZW5kZWQgdG8gYmUgdXNlZCBpbnRlcm5hbGx5IGZvciB2YWxpZGF0aW9uCiAqIG9mIHNjaGVtYSBhdHRyaWJ1dGUgdmFsdWVzIGR1cmluZyBwYXJzaW5nIG9mIHRoZSBzY2hlbWEuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgdmFsdWUgaXMgdmFsaWQsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiBudW1iZXIgb3RoZXJ3aXNlIGFuZCAtMSBpbiBjYXNlIG9mIGFuIGludGVybmFsIG9yIEFQSSBlcnJvci4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHIoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAkJICAgICAgIAoJCSAgICAgICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgb3duZXJJdGVtLAoJCSAgICAgICB4bWxOb2RlUHRyIG93bmVyRWxlbSwKCQkgICAgICAgY29uc3QgY2hhciAqbmFtZSwKCQkgICAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCSAgICAgICBjb25zdCB4bWxDaGFyICoqdmFsdWUpCnsKICAgIHhtbEF0dHJQdHIgYXR0cjsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHR5cGUgPT0gTlVMTCkpIHsKCWlmICh2YWx1ZSAhPSBOVUxMKQoJICAgICp2YWx1ZSA9IE5VTEw7CglyZXR1cm4gKC0xKTsKICAgIH0KICAgIGlmICh0eXBlLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgewoJaWYgKHZhbHVlICE9IE5VTEwpCgkgICAgKnZhbHVlID0gTlVMTDsKCXhtbFNjaGVtYVBFcnIoY3R4dCwgb3duZXJFbGVtLAoJICAgIFhNTF9TQ0hFTUFQX0lOVEVSTkFMLAoJICAgICJJbnRlcm5hbCBlcnJvcjogeG1sU2NoZW1hUFZhbEF0dHIsIHRoZSBnaXZlbiAiCgkgICAgInR5cGUgJyVzJyBpcyBub3QgYSBidWlsdC1pbiB0eXBlLlxuIiwKCSAgICB0eXBlLT5uYW1lLCBOVUxMKTsKCXJldHVybiAoLTEpOwogICAgfQogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG93bmVyRWxlbSwgbmFtZSk7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7CglpZiAodmFsdWUgIT0gTlVMTCkKCSAgICAqdmFsdWUgPSBOVUxMOwoJcmV0dXJuICgwKTsKICAgIH0KICAgIHJldHVybiAoeG1sU2NoZW1hUFZhbEF0dHJOb2RlKGN0eHQsIG93bmVySXRlbSwgYXR0ciwKCXR5cGUsIHZhbHVlKSk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tSZWZlcmVuY2UoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkgIHhtbFNjaGVtYVB0ciBzY2hlbWEgQVRUUklCVVRFX1VOVVNFRCwKCQkgIHhtbE5vZGVQdHIgbm9kZSwKCQkgIHhtbEF0dHJQdHIgYXR0ciwKCQkgIGNvbnN0IHhtbENoYXIgKm5hbWVzcGFjZU5hbWUpCnsKICAgIC8qIFRPRE86IFBvaW50ZXIgY29tcGFyaXNvbiBpbnN0ZWFkPyAqLwogICAgaWYgKHhtbFN0ckVxdWFsKHBjdHh0LT50YXJnZXROYW1lc3BhY2UsIG5hbWVzcGFjZU5hbWUpKQoJcmV0dXJuICgwKTsKICAgIGlmICh4bWxTdHJFcXVhbCh4bWxTY2hlbWFOcywgbmFtZXNwYWNlTmFtZSkpCglyZXR1cm4gKDApOwogICAgLyoKICAgICogQ2hlY2sgaWYgdGhlIHJlZmVyZW5jZWQgbmFtZXNwYWNlIHdhcyA8aW1wb3J0PmVkLgogICAgKi8KICAgIGlmIChXWFNfQlVDS0VUKHBjdHh0KS0+cmVsYXRpb25zICE9IE5VTEwpIHsKCXhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uUHRyIHJlbDsKCglyZWwgPSBXWFNfQlVDS0VUKHBjdHh0KS0+cmVsYXRpb25zOwoJZG8gewoJICAgIGlmIChXWFNfSVNfQlVDS0VUX0lNUE1BSU4ocmVsLT50eXBlKSAmJgoJCXhtbFN0ckVxdWFsKG5hbWVzcGFjZU5hbWUsIHJlbC0+aW1wb3J0TmFtZXNwYWNlKSkKCQlyZXR1cm4gKDApOwoJICAgIHJlbCA9IHJlbC0+bmV4dDsKCX0gd2hpbGUgKHJlbCAhPSBOVUxMKTsKICAgIH0KICAgIC8qCiAgICAqIE5vIG1hdGNoaW5nIDxpbXBvcnQ+ZWQgbmFtZXNwYWNlIGZvdW5kLgogICAgKi8KICAgIHsKCXhtbE5vZGVQdHIgbiA9IChhdHRyICE9IE5VTEwpID8gKHhtbE5vZGVQdHIpIGF0dHIgOiBub2RlOwoKCWlmIChuYW1lc3BhY2VOYW1lID09IE5VTEwpCgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUsIG4sIE5VTEwsCgkJIlJlZmVyZW5jZXMgZnJvbSB0aGlzIHNjaGVtYSB0byBjb21wb25lbnRzIGluIG5vICIKCQkibmFtZXNwYWNlIGFyZSBub3QgYWxsb3dlZCwgc2luY2Ugbm90IGluZGljYXRlZCBieSBhbiAiCgkJImltcG9ydCBzdGF0ZW1lbnQiLCBOVUxMLCBOVUxMKTsKCWVsc2UKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQlYTUxfU0NIRU1BUF9TUkNfUkVTT0xWRSwgbiwgTlVMTCwKCQkiUmVmZXJlbmNlcyBmcm9tIHRoaXMgc2NoZW1hIHRvIGNvbXBvbmVudHMgaW4gdGhlICIKCQkibmFtZXNwYWNlICclcycgYXJlIG5vdCBhbGxvd2VkLCBzaW5jZSBub3QgaW5kaWNhdGVkIGJ5IGFuICIKCQkiaW1wb3J0IHN0YXRlbWVudCIsIG5hbWVzcGFjZU5hbWUsIE5VTEwpOwogICAgfQogICAgcmV0dXJuIChYTUxfU0NIRU1BUF9TUkNfUkVTT0xWRSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZUxvY2FsQXR0cmlidXRlczoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKiBAdHlwZTogIHRoZSBob3N0aW5nIHR5cGUgd2hlcmUgdGhlIGF0dHJpYnV0ZXMgd2lsbCBiZSBhbmNob3JlZAogKgogKiBQYXJzZXMgYXR0cmlidXRlIHVzZXMgYW5kIGF0dHJpYnV0ZSBkZWNsYXJhdGlvbnMgYW5kCiAqIGF0dHJpYnV0ZSBncm91cCByZWZlcmVuY2VzLiAKICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUGFyc2VMb2NhbEF0dHJpYnV0ZXMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyICpjaGlsZCwgeG1sU2NoZW1hSXRlbUxpc3RQdHIgKmxpc3QsCgkJCWludCBwYXJlbnRUeXBlLCBpbnQgKmhhc1JlZnMpCnsKICAgIHZvaWQgKml0ZW07CgogICAgd2hpbGUgKChJU19TQ0hFTUEoKCpjaGlsZCksICJhdHRyaWJ1dGUiKSkgfHwKICAgICAgICAgICAoSVNfU0NIRU1BKCgqY2hpbGQpLCAiYXR0cmlidXRlR3JvdXAiKSkpIHsKICAgICAgICBpZiAoSVNfU0NIRU1BKCgqY2hpbGQpLCAiYXR0cmlidXRlIikpIHsKCSAgICBpdGVtID0geG1sU2NoZW1hUGFyc2VMb2NhbEF0dHJpYnV0ZShjdHh0LCBzY2hlbWEsICpjaGlsZCwKCQkqbGlzdCwgcGFyZW50VHlwZSk7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgaXRlbSA9IHhtbFNjaGVtYVBhcnNlQXR0cmlidXRlR3JvdXBSZWYoY3R4dCwgc2NoZW1hLCAqY2hpbGQpOwoJICAgIGlmICgoaXRlbSAhPSBOVUxMKSAmJiAoaGFzUmVmcyAhPSBOVUxMKSkKCQkqaGFzUmVmcyA9IDE7CiAgICAgICAgfQoJaWYgKGl0ZW0gIT0gTlVMTCkgewoJICAgIGlmICgqbGlzdCA9PSBOVUxMKSB7CgkJLyogVE9ETzogQ3VzdG9taXplIGdyb3cgZmFjdG9yLiAqLwoJCSpsaXN0ID0geG1sU2NoZW1hSXRlbUxpc3RDcmVhdGUoKTsKCQlpZiAoKmxpc3QgPT0gTlVMTCkKCQkgICAgcmV0dXJuKC0xKTsKCSAgICB9CgkgICAgaWYgKHhtbFNjaGVtYUl0ZW1MaXN0QWRkU2l6ZSgqbGlzdCwgMiwgaXRlbSkgPT0gLTEpCgkJcmV0dXJuKC0xKTsKCX0KICAgICAgICAqY2hpbGQgPSAoKmNoaWxkKS0+bmV4dDsKICAgIH0KICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZUFubm90YXRpb246CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogcGFyc2UgYSBYTUwgc2NoZW1hIEF0dHJyaWJ1dGUgZGVjbGFyYXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIC0xIGluIGNhc2Ugb2YgZXJyb3IsIDAgaWYgdGhlIGRlY2xhcmF0aW9uIGlzIGltcHJvcGVyIGFuZAogKiAgICAgICAgIDEgaW4gY2FzZSBvZiBzdWNjZXNzLgogKi8Kc3RhdGljIHhtbFNjaGVtYUFubm90UHRyCnhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUsIGludCBuZWVkZWQpCnsKICAgIHhtbFNjaGVtYUFubm90UHRyIHJldDsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwogICAgaW50IGJhcmtlZCA9IDA7CgogICAgLyoKICAgICogSU5GTzogUzRTIGNvbXBsZXRlZC4KICAgICovCiAgICAvKgogICAgKiBpZCA9IElECiAgICAqIHthbnkgYXR0cmlidXRlcyB3aXRoIG5vbi1zY2hlbWEgbmFtZXNwYWNlIC4gLiAufT4KICAgICogQ29udGVudDogKGFwcGluZm8gfCBkb2N1bWVudGF0aW9uKSoKICAgICovCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgaWYgKG5lZWRlZCkKCXJldCA9IHhtbFNjaGVtYU5ld0Fubm90KGN0eHQsIG5vZGUpOwogICAgZWxzZQoJcmV0ID0gTlVMTDsKICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKCgoYXR0ci0+bnMgPT0gTlVMTCkgJiYKCSAgICAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSkgfHwKCSAgICAoKGF0dHItPm5zICE9IE5VTEwpICYmCgkgICAgeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkpIHsKCgkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJfQoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9CiAgICB4bWxTY2hlbWFQVmFsQXR0cklEKGN0eHQsIG5vZGUsIEJBRF9DQVNUICJpZCIpOwogICAgLyoKICAgICogQW5kIG5vdyBmb3IgdGhlIGNoaWxkcmVuLi4uCiAgICAqLwogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIHdoaWxlIChjaGlsZCAhPSBOVUxMKSB7CglpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYXBwaW5mbyIpKSB7CgkgICAgLyogVE9ETzogbWFrZSBhdmFpbGFibGUgdGhlIGNvbnRlbnQgb2YgImFwcGluZm8iLiAqLwoJICAgIC8qCgkgICAgKiBzb3VyY2UgPSBhbnlVUkkKCSAgICAqIHthbnkgYXR0cmlidXRlcyB3aXRoIG5vbi1zY2hlbWEgbmFtZXNwYWNlIC4gLiAufT4KCSAgICAqIENvbnRlbnQ6ICh7YW55fSkqCgkgICAgKi8KCSAgICBhdHRyID0gY2hpbGQtPnByb3BlcnRpZXM7CgkgICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJCWlmICgoKGF0dHItPm5zID09IE5VTEwpICYmCgkJICAgICAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJzb3VyY2UiKSkpIHx8CgkJICAgICAoKGF0dHItPm5zICE9IE5VTEwpICYmCgkJICAgICAgeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkpIHsKCgkJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkJfQoJCWF0dHIgPSBhdHRyLT5uZXh0OwoJICAgIH0KCSAgICB4bWxTY2hlbWFQVmFsQXR0cihjdHh0LCBOVUxMLCBjaGlsZCwgInNvdXJjZSIsCgkJeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfQU5ZVVJJKSwgTlVMTCk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiZG9jdW1lbnRhdGlvbiIpKSB7CgkgICAgLyogVE9ETzogbWFrZSBhdmFpbGFibGUgdGhlIGNvbnRlbnQgb2YgImRvY3VtZW50YXRpb24iLiAqLwoJICAgIC8qCgkgICAgKiBzb3VyY2UgPSBhbnlVUkkKCSAgICAqIHthbnkgYXR0cmlidXRlcyB3aXRoIG5vbi1zY2hlbWEgbmFtZXNwYWNlIC4gLiAufT4KCSAgICAqIENvbnRlbnQ6ICh7YW55fSkqCgkgICAgKi8KCSAgICBhdHRyID0gY2hpbGQtPnByb3BlcnRpZXM7CgkgICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJCWlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkJICAgIGlmICgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgInNvdXJjZSIpKSB7CgkJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJCSAgICB9CgkJfSBlbHNlIHsKCQkgICAgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykgfHwKCQkJKHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJsYW5nIikgJiYKCQkJKCF4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgWE1MX1hNTF9OQU1FU1BBQ0UpKSkpIHsKCgkJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJCSAgICB9CgkJfQoJCWF0dHIgPSBhdHRyLT5uZXh0OwoJICAgIH0KCSAgICAvKgoJICAgICogQXR0cmlidXRlICJ4bWw6bGFuZyIuCgkgICAgKi8KCSAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGVOcyhjaGlsZCwgKGNvbnN0IGNoYXIgKikgWE1MX1hNTF9OQU1FU1BBQ0UsICJsYW5nIik7CgkgICAgaWYgKGF0dHIgIT0gTlVMTCkKCQl4bWxTY2hlbWFQVmFsQXR0ck5vZGUoY3R4dCwgTlVMTCwgYXR0ciwKCQl4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19MQU5HVUFHRSksIE5VTEwpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9IGVsc2UgewoJICAgIGlmICghYmFya2VkKQoJCXhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJCSAgICBOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwgIihhcHBpbmZvIHwgZG9jdW1lbnRhdGlvbikqIik7CgkgICAgYmFya2VkID0gMTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQogICAgfQoKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlRmFjZXQ6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogcGFyc2UgYSBYTUwgc2NoZW1hIEZhY2V0IGRlY2xhcmF0aW9uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgbmV3IHR5cGUgc3RydWN0dXJlIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8Kc3RhdGljIHhtbFNjaGVtYUZhY2V0UHRyCnhtbFNjaGVtYVBhcnNlRmFjZXQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSkKewogICAgeG1sU2NoZW1hRmFjZXRQdHIgZmFjZXQ7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CgogICAgZmFjZXQgPSB4bWxTY2hlbWFOZXdGYWNldCgpOwogICAgaWYgKGZhY2V0ID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIGZhY2V0Iiwgbm9kZSk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIGZhY2V0LT5ub2RlID0gbm9kZTsKICAgIHZhbHVlID0geG1sU2NoZW1hR2V0UHJvcChjdHh0LCBub2RlLCAidmFsdWUiKTsKICAgIGlmICh2YWx1ZSA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEVycjIoY3R4dCwgbm9kZSwgY2hpbGQsIFhNTF9TQ0hFTUFQX0ZBQ0VUX05PX1ZBTFVFLAogICAgICAgICAgICAgICAgICAgICAgICJGYWNldCAlcyBoYXMgbm8gdmFsdWVcbiIsIG5vZGUtPm5hbWUsIE5VTEwpOwogICAgICAgIHhtbFNjaGVtYUZyZWVGYWNldChmYWNldCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIGlmIChJU19TQ0hFTUEobm9kZSwgIm1pbkluY2x1c2l2ZSIpKSB7CiAgICAgICAgZmFjZXQtPnR5cGUgPSBYTUxfU0NIRU1BX0ZBQ0VUX01JTklOQ0xVU0lWRTsKICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKG5vZGUsICJtaW5FeGNsdXNpdmUiKSkgewogICAgICAgIGZhY2V0LT50eXBlID0gWE1MX1NDSEVNQV9GQUNFVF9NSU5FWENMVVNJVkU7CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShub2RlLCAibWF4SW5jbHVzaXZlIikpIHsKICAgICAgICBmYWNldC0+dHlwZSA9IFhNTF9TQ0hFTUFfRkFDRVRfTUFYSU5DTFVTSVZFOwogICAgfSBlbHNlIGlmIChJU19TQ0hFTUEobm9kZSwgIm1heEV4Y2x1c2l2ZSIpKSB7CiAgICAgICAgZmFjZXQtPnR5cGUgPSBYTUxfU0NIRU1BX0ZBQ0VUX01BWEVYQ0xVU0lWRTsKICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKG5vZGUsICJ0b3RhbERpZ2l0cyIpKSB7CiAgICAgICAgZmFjZXQtPnR5cGUgPSBYTUxfU0NIRU1BX0ZBQ0VUX1RPVEFMRElHSVRTOwogICAgfSBlbHNlIGlmIChJU19TQ0hFTUEobm9kZSwgImZyYWN0aW9uRGlnaXRzIikpIHsKICAgICAgICBmYWNldC0+dHlwZSA9IFhNTF9TQ0hFTUFfRkFDRVRfRlJBQ1RJT05ESUdJVFM7CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShub2RlLCAicGF0dGVybiIpKSB7CiAgICAgICAgZmFjZXQtPnR5cGUgPSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk47CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShub2RlLCAiZW51bWVyYXRpb24iKSkgewogICAgICAgIGZhY2V0LT50eXBlID0gWE1MX1NDSEVNQV9GQUNFVF9FTlVNRVJBVElPTjsKICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKG5vZGUsICJ3aGl0ZVNwYWNlIikpIHsKICAgICAgICBmYWNldC0+dHlwZSA9IFhNTF9TQ0hFTUFfRkFDRVRfV0hJVEVTUEFDRTsKICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKG5vZGUsICJsZW5ndGgiKSkgewogICAgICAgIGZhY2V0LT50eXBlID0gWE1MX1NDSEVNQV9GQUNFVF9MRU5HVEg7CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShub2RlLCAibWF4TGVuZ3RoIikpIHsKICAgICAgICBmYWNldC0+dHlwZSA9IFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIOwogICAgfSBlbHNlIGlmIChJU19TQ0hFTUEobm9kZSwgIm1pbkxlbmd0aCIpKSB7CiAgICAgICAgZmFjZXQtPnR5cGUgPSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkxFTkdUSDsKICAgIH0gZWxzZSB7CiAgICAgICAgeG1sU2NoZW1hUEVycjIoY3R4dCwgbm9kZSwgY2hpbGQsIFhNTF9TQ0hFTUFQX1VOS05PV05fRkFDRVRfVFlQRSwKICAgICAgICAgICAgICAgICAgICAgICAiVW5rbm93biBmYWNldCB0eXBlICVzXG4iLCBub2RlLT5uYW1lLCBOVUxMKTsKICAgICAgICB4bWxTY2hlbWFGcmVlRmFjZXQoZmFjZXQpOwogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB9CiAgICB4bWxTY2hlbWFQVmFsQXR0cklEKGN0eHQsIG5vZGUsIEJBRF9DQVNUICJpZCIpOwogICAgZmFjZXQtPnZhbHVlID0gdmFsdWU7CiAgICBpZiAoKGZhY2V0LT50eXBlICE9IFhNTF9TQ0hFTUFfRkFDRVRfUEFUVEVSTikgJiYKCShmYWNldC0+dHlwZSAhPSBYTUxfU0NIRU1BX0ZBQ0VUX0VOVU1FUkFUSU9OKSkgewoJY29uc3QgeG1sQ2hhciAqZml4ZWQ7CgoJZml4ZWQgPSB4bWxTY2hlbWFHZXRQcm9wKGN0eHQsIG5vZGUsICJmaXhlZCIpOwoJaWYgKGZpeGVkICE9IE5VTEwpIHsKCSAgICBpZiAoeG1sU3RyRXF1YWwoZml4ZWQsIEJBRF9DQVNUICJ0cnVlIikpCgkJZmFjZXQtPmZpeGVkID0gMTsKCX0KICAgIH0KICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CgogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewogICAgICAgIGZhY2V0LT5hbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyMihjdHh0LCBub2RlLCBjaGlsZCwgWE1MX1NDSEVNQVBfVU5LTk9XTl9GQUNFVF9DSElMRCwKICAgICAgICAgICAgICAgICAgICAgICAiRmFjZXQgJXMgaGFzIHVuZXhwZWN0ZWQgY2hpbGQgY29udGVudFxuIiwKICAgICAgICAgICAgICAgICAgICAgICBub2RlLT5uYW1lLCBOVUxMKTsKICAgIH0KICAgIHJldHVybiAoZmFjZXQpOwp9CgovKioKICogeG1sU2NoZW1hUGFyc2VXaWxkY2FyZE5zOgogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEB3aWxkYzogIHRoZSB3aWxkY2FyZCwgYWxyZWFkeSBjcmVhdGVkCiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogUGFyc2VzIHRoZSBhdHRyaWJ1dGUgInByb2Nlc3NDb250ZW50cyIgYW5kICJuYW1lc3BhY2UiCiAqIG9mIGEgeHNkOmFueUF0dHJpYnV0ZSBhbmQgeHNkOmFueS4KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIDAgaWYgZXZlcnl0aGluZyBnb2VzIGZpbmUsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiBpZiBzb21ldGhpbmcgaXMgbm90IHZhbGlkIGFuZCAtMSBpZiBhbiBpbnRlcm5hbCBlcnJvciBvY2N1cnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlV2lsZGNhcmROcyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSB4bWxTY2hlbWFQdHIgc2NoZW1hIEFUVFJJQlVURV9VTlVTRUQsCgkJCSB4bWxTY2hlbWFXaWxkY2FyZFB0ciB3aWxkYywKCQkJIHhtbE5vZGVQdHIgbm9kZSkKewogICAgY29uc3QgeG1sQ2hhciAqcGMsICpucywgKmRpY3Ruc0l0ZW07CiAgICBpbnQgcmV0ID0gMDsKICAgIHhtbENoYXIgKm5zSXRlbTsKICAgIHhtbFNjaGVtYVdpbGRjYXJkTnNQdHIgdG1wLCBsYXN0TnMgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwoKICAgIHBjID0geG1sU2NoZW1hR2V0UHJvcChjdHh0LCBub2RlLCAicHJvY2Vzc0NvbnRlbnRzIik7CiAgICBpZiAoKHBjID09IE5VTEwpCiAgICAgICAgfHwgKHhtbFN0ckVxdWFsKHBjLCAoY29uc3QgeG1sQ2hhciAqKSAic3RyaWN0IikpKSB7CiAgICAgICAgd2lsZGMtPnByb2Nlc3NDb250ZW50cyA9IFhNTF9TQ0hFTUFTX0FOWV9TVFJJQ1Q7CiAgICB9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKHBjLCAoY29uc3QgeG1sQ2hhciAqKSAic2tpcCIpKSB7CiAgICAgICAgd2lsZGMtPnByb2Nlc3NDb250ZW50cyA9IFhNTF9TQ0hFTUFTX0FOWV9TS0lQOwogICAgfSBlbHNlIGlmICh4bWxTdHJFcXVhbChwYywgKGNvbnN0IHhtbENoYXIgKikgImxheCIpKSB7CiAgICAgICAgd2lsZGMtPnByb2Nlc3NDb250ZW50cyA9IFhNTF9TQ0hFTUFTX0FOWV9MQVg7CiAgICB9IGVsc2UgewogICAgICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCSAgICBOVUxMLCBub2RlLAoJICAgIE5VTEwsICIoc3RyaWN0IHwgc2tpcCB8IGxheCkiLCBwYywKCSAgICBOVUxMLCBOVUxMLCBOVUxMKTsKICAgICAgICB3aWxkYy0+cHJvY2Vzc0NvbnRlbnRzID0gWE1MX1NDSEVNQVNfQU5ZX1NUUklDVDsKCXJldCA9IFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUU7CiAgICB9CiAgICAvKgogICAgICogQnVpbGQgdGhlIG5hbWVzcGFjZSBjb25zdHJhaW50cy4KICAgICAqLwogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJuYW1lc3BhY2UiKTsKICAgIG5zID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQoY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwogICAgaWYgKChhdHRyID09IE5VTEwpIHx8ICh4bWxTdHJFcXVhbChucywgQkFEX0NBU1QgIiMjYW55IikpKQoJd2lsZGMtPmFueSA9IDE7CiAgICBlbHNlIGlmICh4bWxTdHJFcXVhbChucywgQkFEX0NBU1QgIiMjb3RoZXIiKSkgewoJd2lsZGMtPm5lZ05zU2V0ID0geG1sU2NoZW1hTmV3V2lsZGNhcmROc0NvbnN0cmFpbnQoY3R4dCk7CglpZiAod2lsZGMtPm5lZ05zU2V0ID09IE5VTEwpIHsKCSAgICByZXR1cm4gKC0xKTsKCX0KCXdpbGRjLT5uZWdOc1NldC0+dmFsdWUgPSBjdHh0LT50YXJnZXROYW1lc3BhY2U7CiAgICB9IGVsc2UgewoJY29uc3QgeG1sQ2hhciAqZW5kLCAqY3VyOwoKCWN1ciA9IG5zOwoJZG8gewoJICAgIHdoaWxlIChJU19CTEFOS19DSCgqY3VyKSkKCQljdXIrKzsKCSAgICBlbmQgPSBjdXI7CgkgICAgd2hpbGUgKCgqZW5kICE9IDApICYmICghKElTX0JMQU5LX0NIKCplbmQpKSkpCgkJZW5kKys7CgkgICAgaWYgKGVuZCA9PSBjdXIpCgkJYnJlYWs7CgkgICAgbnNJdGVtID0geG1sU3RybmR1cChjdXIsIGVuZCAtIGN1cik7CgkgICAgaWYgKCh4bWxTdHJFcXVhbChuc0l0ZW0sIEJBRF9DQVNUICIjI290aGVyIikpIHx8CgkJICAgICh4bWxTdHJFcXVhbChuc0l0ZW0sIEJBRF9DQVNUICIjI2FueSIpKSkgewoJCXhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1dJTERDQVJEX0lOVkFMSURfTlNfTUVNQkVSLAoJCSAgICBOVUxMLCAoeG1sTm9kZVB0cikgYXR0ciwKCQkgICAgTlVMTCwKCQkgICAgIigoIyNhbnkgfCAjI290aGVyKSB8IExpc3Qgb2YgKHhzOmFueVVSSSB8ICIKCQkgICAgIigjI3RhcmdldE5hbWVzcGFjZSB8ICMjbG9jYWwpKSkiLAoJCSAgICBuc0l0ZW0sIE5VTEwsIE5VTEwsIE5VTEwpOwoJCXJldCA9IFhNTF9TQ0hFTUFQX1dJTERDQVJEX0lOVkFMSURfTlNfTUVNQkVSOwoJICAgIH0gZWxzZSB7CgkJaWYgKHhtbFN0ckVxdWFsKG5zSXRlbSwgQkFEX0NBU1QgIiMjdGFyZ2V0TmFtZXNwYWNlIikpIHsKCQkgICAgZGljdG5zSXRlbSA9IGN0eHQtPnRhcmdldE5hbWVzcGFjZTsKCQl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKG5zSXRlbSwgQkFEX0NBU1QgIiMjbG9jYWwiKSkgewoJCSAgICBkaWN0bnNJdGVtID0gTlVMTDsKCQl9IGVsc2UgewoJCSAgICAvKgoJCSAgICAqIFZhbGlkYXRlIHRoZSBpdGVtIChhbnlVUkkpLgoJCSAgICAqLwoJCSAgICB4bWxTY2hlbWFQVmFsQXR0ck5vZGVWYWx1ZShjdHh0LCBOVUxMLCBhdHRyLAoJCQluc0l0ZW0sIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVVSSSkpOwoJCSAgICBkaWN0bnNJdGVtID0geG1sRGljdExvb2t1cChjdHh0LT5kaWN0LCBuc0l0ZW0sIC0xKTsKCQl9CgkJLyoKCQkqIEF2b2lkIGR1YmxpY2F0ZSBuYW1lc3BhY2VzLgoJCSovCgkJdG1wID0gd2lsZGMtPm5zU2V0OwoJCXdoaWxlICh0bXAgIT0gTlVMTCkgewoJCSAgICBpZiAoZGljdG5zSXRlbSA9PSB0bXAtPnZhbHVlKQoJCQlicmVhazsKCQkgICAgdG1wID0gdG1wLT5uZXh0OwoJCX0KCQlpZiAodG1wID09IE5VTEwpIHsKCQkgICAgdG1wID0geG1sU2NoZW1hTmV3V2lsZGNhcmROc0NvbnN0cmFpbnQoY3R4dCk7CgkJICAgIGlmICh0bXAgPT0gTlVMTCkgewoJCQl4bWxGcmVlKG5zSXRlbSk7CgkJCXJldHVybiAoLTEpOwoJCSAgICB9CgkJICAgIHRtcC0+dmFsdWUgPSBkaWN0bnNJdGVtOwoJCSAgICB0bXAtPm5leHQgPSBOVUxMOwoJCSAgICBpZiAod2lsZGMtPm5zU2V0ID09IE5VTEwpCgkJCXdpbGRjLT5uc1NldCA9IHRtcDsKCQkgICAgZWxzZQoJCQlsYXN0TnMtPm5leHQgPSB0bXA7CgkJICAgIGxhc3ROcyA9IHRtcDsKCQl9CgoJICAgIH0KCSAgICB4bWxGcmVlKG5zSXRlbSk7CgkgICAgY3VyID0gZW5kOwoJfSB3aGlsZSAoKmN1ciAhPSAwKTsKICAgIH0KICAgIHJldHVybiAocmV0KTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFQQ2hlY2tQYXJ0aWNsZUNvcnJlY3RfMih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCQkgeG1sU2NoZW1hUGFydGljbGVQdHIgaXRlbSBBVFRSSUJVVEVfVU5VU0VELAoJCQkJIHhtbE5vZGVQdHIgbm9kZSwKCQkJCSBpbnQgbWluT2NjdXJzLAoJCQkJIGludCBtYXhPY2N1cnMpIHsKCiAgICBpZiAoKG1heE9jY3VycyA9PSAwKSAmJiAoIG1pbk9jY3VycyA9PSAwKSkKCXJldHVybiAoMCk7CiAgICBpZiAobWF4T2NjdXJzICE9IFVOQk9VTkRFRCkgewoJLyoKCSogVE9ETzogTWF5YmUgd2Ugc2hvdWxkIGJldHRlciBub3QgY3JlYXRlIHRoZSBwYXJ0aWNsZSwKCSogaWYgbWluL21heCBpcyBpbnZhbGlkLCBzaW5jZSBpdCBjb3VsZCBjb25mdXNlIHRoZSBidWlsZCBvZiB0aGUKCSogY29udGVudCBtb2RlbC4KCSovCgkvKgoJKiAzLjkuNiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IFBhcnRpY2xlIENvcnJlY3QKCSoKCSovCglpZiAobWF4T2NjdXJzIDwgMSkgewoJICAgIC8qCgkgICAgKiAyLjIge21heCBvY2N1cnN9IG11c3QgYmUgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvIDEuCgkgICAgKi8KCSAgICB4bWxTY2hlbWFQQ3VzdG9tQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1BfUFJPUFNfQ09SUkVDVF8yXzIsCgkJTlVMTCwgTlVMTCwKCQl4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibWF4T2NjdXJzIiksCgkJIlRoZSB2YWx1ZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiBvciBlcXVhbCB0byAxIik7CgkgICAgcmV0dXJuIChYTUxfU0NIRU1BUF9QX1BST1BTX0NPUlJFQ1RfMl8yKTsKCX0gZWxzZSBpZiAobWluT2NjdXJzID4gbWF4T2NjdXJzKSB7CgkgICAgLyoKCSAgICAqIDIuMSB7bWluIG9jY3Vyc30gbXVzdCBub3QgYmUgZ3JlYXRlciB0aGFuIHttYXggb2NjdXJzfS4KCSAgICAqLwoJICAgIHhtbFNjaGVtYVBDdXN0b21BdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUF9QUk9QU19DT1JSRUNUXzJfMSwKCQlOVUxMLCBOVUxMLAoJCXhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJtaW5PY2N1cnMiKSwKCQkiVGhlIHZhbHVlIG11c3Qgbm90IGJlIGdyZWF0ZXIgdGhhbiB0aGUgdmFsdWUgb2YgJ21heE9jY3VycyciKTsKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX1BfUFJPUFNfQ09SUkVDVF8yXzEpOwoJfQogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlQW55OgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqCiAqIFBhcnNlYSBhIFhNTCBzY2hlbWEgPGFueT4gZWxlbWVudC4gQSBwYXJ0aWNsZSBhbmQgd2lsZGNhcmQKICogd2lsbCBiZSBjcmVhdGVkIChleGNlcHQgaWYgbWluT2NjdXJzPT1tYXhPY2N1cnM9PTAsIGluIHRoaXMgY2FzZQogKiBub3RoaW5nIHdpbGwgYmUgY3JlYXRlZCkuCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgcGFydGljbGUgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yIG9yIGlmIG1pbk9jY3Vycz09bWF4T2NjdXJzPT0wCiAqLwpzdGF0aWMgeG1sU2NoZW1hUGFydGljbGVQdHIKeG1sU2NoZW1hUGFyc2VBbnkoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnRpY2xlOwogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICB4bWxTY2hlbWFXaWxkY2FyZFB0ciB3aWxkOwogICAgaW50IG1pbiwgbWF4OwogICAgeG1sQXR0clB0ciBhdHRyOwogICAgeG1sU2NoZW1hQW5ub3RQdHIgYW5ub3QgPSBOVUxMOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtaW5PY2N1cnMiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtYXhPY2N1cnMiKSkgJiYKCSAgICAgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibmFtZXNwYWNlIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAicHJvY2Vzc0NvbnRlbnRzIikpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7Cgl9CglhdHRyID0gYXR0ci0+bmV4dDsKICAgIH0KICAgIHhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CiAgICAvKgogICAgKiBtaW5PY2N1cnMvbWF4T2NjdXJzLgogICAgKi8KICAgIG1heCA9IHhtbEdldE1heE9jY3VycyhjdHh0LCBub2RlLCAwLCBVTkJPVU5ERUQsIDEsCgkiKHhzOm5vbk5lZ2F0aXZlSW50ZWdlciB8IHVuYm91bmRlZCkiKTsKICAgIG1pbiA9IHhtbEdldE1pbk9jY3VycyhjdHh0LCBub2RlLCAwLCAtMSwgMSwKCSJ4czpub25OZWdhdGl2ZUludGVnZXIiKTsKICAgIHhtbFNjaGVtYVBDaGVja1BhcnRpY2xlQ29ycmVjdF8yKGN0eHQsIE5VTEwsIG5vZGUsIG1pbiwgbWF4KTsKICAgIC8qCiAgICAqIENyZWF0ZSAmIHBhcnNlIHRoZSB3aWxkY2FyZC4KICAgICovCiAgICB3aWxkID0geG1sU2NoZW1hQWRkV2lsZGNhcmQoY3R4dCwgc2NoZW1hLCBYTUxfU0NIRU1BX1RZUEVfQU5ZLCBub2RlKTsKICAgIGlmICh3aWxkID09IE5VTEwpCglyZXR1cm4gKE5VTEwpOwogICAgeG1sU2NoZW1hUGFyc2VXaWxkY2FyZE5zKGN0eHQsIHNjaGVtYSwgd2lsZCwgbm9kZSk7CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewogICAgICAgIGFubm90ID0geG1sU2NoZW1hUGFyc2VBbm5vdGF0aW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwKCSAgICBOVUxMLCAiKGFubm90YXRpb24/KSIpOwogICAgfQogICAgLyoKICAgICogTm8gY29tcG9uZW50IGlmIG1pbk9jY3Vycz09bWF4T2NjdXJzPT0wLgogICAgKi8KICAgIGlmICgobWluID09IDApICYmIChtYXggPT0gMCkpIHsKCS8qIERvbid0IGZyZWUgdGhlIHdpbGRjYXJkLCBzaW5jZSBpdCdzIGFscmVhZHkgb24gdGhlIGxpc3QuICovCglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgLyoKICAgICogQ3JlYXRlIHRoZSBwYXJ0aWNsZS4KICAgICovCiAgICBwYXJ0aWNsZSA9IHhtbFNjaGVtYUFkZFBhcnRpY2xlKGN0eHQsIHNjaGVtYSwgbm9kZSwgbWluLCBtYXgpOwogICAgaWYgKHBhcnRpY2xlID09IE5VTEwpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIHBhcnRpY2xlLT5hbm5vdCA9IGFubm90OwogICAgcGFydGljbGUtPmNoaWxkcmVuID0gKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSB3aWxkOwoKICAgIHJldHVybiAocGFydGljbGUpOwp9CgovKioKICogeG1sU2NoZW1hUGFyc2VOb3RhdGlvbjoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgTm90YXRpb24gZGVjbGFyYXRpb24KICoKICogUmV0dXJucyB0aGUgbmV3IHN0cnVjdHVyZSBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFOb3RhdGlvblB0cgp4bWxTY2hlbWFQYXJzZU5vdGF0aW9uKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sU2NoZW1hUHRyIHNjaGVtYSwKICAgICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWU7CiAgICB4bWxTY2hlbWFOb3RhdGlvblB0ciByZXQ7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgbmFtZSA9IHhtbFNjaGVtYUdldFByb3AoY3R4dCwgbm9kZSwgIm5hbWUiKTsKICAgIGlmIChuYW1lID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyMihjdHh0LCBub2RlLCBjaGlsZCwgWE1MX1NDSEVNQVBfTk9UQVRJT05fTk9fTkFNRSwKICAgICAgICAgICAgICAgICAgICAgICAiTm90YXRpb24gaGFzIG5vIG5hbWVcbiIsIE5VTEwsIE5VTEwpOwogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB9CiAgICByZXQgPSB4bWxTY2hlbWFBZGROb3RhdGlvbihjdHh0LCBzY2hlbWEsIG5hbWUsCgljdHh0LT50YXJnZXROYW1lc3BhY2UsIG5vZGUpOwogICAgaWYgKHJldCA9PSBOVUxMKQogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB4bWxTY2hlbWFQVmFsQXR0cklEKGN0eHQsIG5vZGUsIEJBRF9DQVNUICJpZCIpOwoKICAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CiAgICAgICAgcmV0LT5hbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQoKICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CiAgICAgICAgcmV0LT5hbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKCXhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkgICAgTlVMTCwgbm9kZSwgY2hpbGQsCgkgICAgTlVMTCwgIihhbm5vdGF0aW9uPykiKTsKICAgIH0KCiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZUFueUF0dHJpYnV0ZToKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgQW55QXR0cnJpYnV0ZSBkZWNsYXJhdGlvbgogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgYSB3aWxkY2FyZCBvciBOVUxMLgogKi8Kc3RhdGljIHhtbFNjaGVtYVdpbGRjYXJkUHRyCnhtbFNjaGVtYVBhcnNlQW55QXR0cmlidXRlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwgeG1sTm9kZVB0ciBub2RlKQp7CiAgICB4bWxTY2hlbWFXaWxkY2FyZFB0ciByZXQ7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIHJldCA9IHhtbFNjaGVtYUFkZFdpbGRjYXJkKGN0eHQsIHNjaGVtYSwgWE1MX1NDSEVNQV9UWVBFX0FOWV9BVFRSSUJVVEUsCglub2RlKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB9CiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCSAgICAgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibmFtZXNwYWNlIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAicHJvY2Vzc0NvbnRlbnRzIikpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7Cgl9CglhdHRyID0gYXR0ci0+bmV4dDsKICAgIH0KICAgIHhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CiAgICAvKgogICAgKiBQYXJzZSB0aGUgbmFtZXNwYWNlIGxpc3QuCiAgICAqLwogICAgaWYgKHhtbFNjaGVtYVBhcnNlV2lsZGNhcmROcyhjdHh0LCBzY2hlbWEsIHJldCwgbm9kZSkgIT0gMCkKCXJldHVybiAoTlVMTCk7CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewogICAgICAgIHJldC0+YW5ub3QgPSB4bWxTY2hlbWFQYXJzZUFubm90YXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJICAgIE5VTEwsIG5vZGUsIGNoaWxkLAoJICAgIE5VTEwsICIoYW5ub3RhdGlvbj8pIik7CiAgICB9CgogICAgcmV0dXJuIChyZXQpOwp9CgoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlQXR0cmlidXRlOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqCiAqIHBhcnNlIGEgWE1MIHNjaGVtYSBBdHRycmlidXRlIGRlY2xhcmF0aW9uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgYXR0cmlidXRlIGRlY2xhcmF0aW9uLgogKi8Kc3RhdGljIHhtbFNjaGVtYUJhc2ljSXRlbVB0cgp4bWxTY2hlbWFQYXJzZUxvY2FsQXR0cmlidXRlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCSAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJICAgICB4bWxOb2RlUHRyIG5vZGUsCgkJCSAgICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgdXNlcywKCQkJICAgICBpbnQgcGFyZW50VHlwZSkKewogICAgY29uc3QgeG1sQ2hhciAqYXR0clZhbHVlLCAqbmFtZSA9IE5VTEwsICpucyA9IE5VTEw7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgdXNlID0gTlVMTDsgICAgCiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGNvbnN0IHhtbENoYXIgKnRtcE5zID0gTlVMTCwgKnRtcE5hbWUgPSBOVUxMLCAqZGVmVmFsdWUgPSBOVUxMOwogICAgaW50IGlzUmVmID0gMCwgb2NjdXJzID0gWE1MX1NDSEVNQVNfQVRUUl9VU0VfT1BUSU9OQUw7CiAgICBpbnQJbmJlcnJvcnMsIGhhc0Zvcm0gPSAwLCBkZWZWYWx1ZVR5cGUgPSAwOwoKI2RlZmluZSBXWFNfQVRUUl9ERUZfVkFMX0RFRkFVTFQgMQojZGVmaW5lIFdYU19BVFRSX0RFRl9WQUxfRklYRUQgMgoKICAgIC8qCiAgICAgKiAzLjIuMyBDb25zdHJhaW50cyBvbiBYTUwgUmVwcmVzZW50YXRpb25zIG9mIEF0dHJpYnV0ZSBEZWNsYXJhdGlvbnMKICAgICAqLwoKICAgIGlmICgocGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJyZWYiKTsKICAgIGlmIChhdHRyICE9IE5VTEwpIHsKCWlmICh4bWxTY2hlbWFQVmFsQXR0ck5vZGVRTmFtZShwY3R4dCwgc2NoZW1hLAoJICAgIE5VTEwsIGF0dHIsICZ0bXBOcywgJnRtcE5hbWUpICE9IDApIHsKCSAgICByZXR1cm4gKE5VTEwpOwoJfQoJaWYgKHhtbFNjaGVtYUNoZWNrUmVmZXJlbmNlKHBjdHh0LCBzY2hlbWEsIG5vZGUsIGF0dHIsIHRtcE5zKSAhPSAwKQoJICAgIHJldHVybihOVUxMKTsKCWlzUmVmID0gMTsKICAgIH0KICAgIG5iZXJyb3JzID0gcGN0eHQtPm5iZXJyb3JzOwogICAgLyoKICAgICogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KICAgICovCiAgICBhdHRyID0gbm9kZS0+cHJvcGVydGllczsKICAgIHdoaWxlIChhdHRyICE9IE5VTEwpIHsKCWlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkgICAgaWYgKGlzUmVmKSB7CgkJaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSB7CgkJICAgIHhtbFNjaGVtYVBWYWxBdHRyTm9kZUlEKHBjdHh0LCBhdHRyKTsKCQkgICAgZ290byBhdHRyX25leHQ7CgkJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAicmVmIikpIHsKCQkgICAgZ290byBhdHRyX25leHQ7CgkJfQoJICAgIH0gZWxzZSB7CgkJaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuYW1lIikpIHsKCQkgICAgZ290byBhdHRyX25leHQ7CgkJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgewoJCSAgICB4bWxTY2hlbWFQVmFsQXR0ck5vZGVJRChwY3R4dCwgYXR0cik7CgkJICAgIGdvdG8gYXR0cl9uZXh0OwoJCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgInR5cGUiKSkgewoJCSAgICB4bWxTY2hlbWFQVmFsQXR0ck5vZGVRTmFtZShwY3R4dCwgc2NoZW1hLCBOVUxMLAoJCQlhdHRyLCAmdG1wTnMsICZ0bXBOYW1lKTsKCQkgICAgZ290byBhdHRyX25leHQ7CgkJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiZm9ybSIpKSB7CgkJICAgIC8qCgkJICAgICogRXZhbHVhdGUgdGhlIHRhcmdldCBuYW1lc3BhY2UKCQkgICAgKi8KCQkgICAgaGFzRm9ybSA9IDE7CQkgICAgCgkJICAgIGF0dHJWYWx1ZSA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KHBjdHh0LAoJCQkoeG1sTm9kZVB0cikgYXR0cik7CgkJICAgIGlmICh4bWxTdHJFcXVhbChhdHRyVmFsdWUsIEJBRF9DQVNUICJxdWFsaWZpZWQiKSkgewoJCQlucyA9IHBjdHh0LT50YXJnZXROYW1lc3BhY2U7CgkJICAgIH0gZWxzZSBpZiAoIXhtbFN0ckVxdWFsKGF0dHJWYWx1ZSwgQkFEX0NBU1QgInVucXVhbGlmaWVkIikpCgkJICAgIHsKCQkJeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIocGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9JTlZBTElEX1ZBTFVFLAoJCQkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsCgkJCSAgICBOVUxMLCAiKHF1YWxpZmllZCB8IHVucXVhbGlmaWVkKSIsCgkJCSAgICBhdHRyVmFsdWUsIE5VTEwsIE5VTEwsIE5VTEwpOwoJCSAgICB9CgkJICAgIGdvdG8gYXR0cl9uZXh0OwoJCX0KCSAgICB9CgkgICAgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJ1c2UiKSkgewoKCQlhdHRyVmFsdWUgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChwY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwoJCS8qIFRPRE86IE1heWJlIHdlIG5lZWQgdG8gbm9ybWFsaXplIHRoZSB2YWx1ZSBiZWZvcmVoYW5kLiAqLwoJCWlmICh4bWxTdHJFcXVhbChhdHRyVmFsdWUsIEJBRF9DQVNUICJvcHRpb25hbCIpKQoJCSAgICBvY2N1cnMgPSBYTUxfU0NIRU1BU19BVFRSX1VTRV9PUFRJT05BTDsKCQllbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyVmFsdWUsIEJBRF9DQVNUICJwcm9oaWJpdGVkIikpCgkJICAgIG9jY3VycyA9IFhNTF9TQ0hFTUFTX0FUVFJfVVNFX1BST0hJQklURUQ7CgkJZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0clZhbHVlLCBCQURfQ0FTVCAicmVxdWlyZWQiKSkKCQkgICAgb2NjdXJzID0gWE1MX1NDSEVNQVNfQVRUUl9VU0VfUkVRVUlSRUQ7CgkJZWxzZSB7CgkJICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKHBjdHh0LAoJCQlYTUxfU0NIRU1BUF9JTlZBTElEX0FUVFJfVVNFLAoJCQlOVUxMLCAoeG1sTm9kZVB0cikgYXR0ciwKCQkJTlVMTCwgIihvcHRpb25hbCB8IHByb2hpYml0ZWQgfCByZXF1aXJlZCkiLAoJCQlhdHRyVmFsdWUsIE5VTEwsIE5VTEwsIE5VTEwpOwoJCX0KCQlnb3RvIGF0dHJfbmV4dDsKCSAgICB9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJkZWZhdWx0IikpIHsKCQkvKgoJCSogMy4yLjMgOiAxCgkJKiBkZWZhdWx0IGFuZCBmaXhlZCBtdXN0IG5vdCBib3RoIGJlIHByZXNlbnQuCgkJKi8KCQlpZiAoZGVmVmFsdWUpIHsKCQkgICAgeG1sU2NoZW1hUE11dHVhbEV4Y2xBdHRyRXJyKHBjdHh0LAoJCQlYTUxfU0NIRU1BUF9TUkNfQVRUUklCVVRFXzEsCgkJCU5VTEwsIGF0dHIsICJkZWZhdWx0IiwgImZpeGVkIik7CgkJfSBlbHNlIHsKCQkgICAgZGVmVmFsdWUgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChwY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwoJCSAgICBkZWZWYWx1ZVR5cGUgPSBXWFNfQVRUUl9ERUZfVkFMX0RFRkFVTFQ7CgkJfQoJCWdvdG8gYXR0cl9uZXh0OwoJICAgIH0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImZpeGVkIikpIHsKCQkvKgoJCSogMy4yLjMgOiAxCgkJKiBkZWZhdWx0IGFuZCBmaXhlZCBtdXN0IG5vdCBib3RoIGJlIHByZXNlbnQuCgkJKi8KCQlpZiAoZGVmVmFsdWUpIHsKCQkgICAgeG1sU2NoZW1hUE11dHVhbEV4Y2xBdHRyRXJyKHBjdHh0LAoJCQlYTUxfU0NIRU1BUF9TUkNfQVRUUklCVVRFXzEsCgkJCU5VTEwsIGF0dHIsICJkZWZhdWx0IiwgImZpeGVkIik7CgkJfSBlbHNlIHsKCQkgICAgZGVmVmFsdWUgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChwY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwoJCSAgICBkZWZWYWx1ZVR5cGUgPSBXWFNfQVRUUl9ERUZfVkFMX0ZJWEVEOwoJCX0KCQlnb3RvIGF0dHJfbmV4dDsKCSAgICB9Cgl9IGVsc2UgaWYgKCEgeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkKCSAgICBnb3RvIGF0dHJfbmV4dDsKCgl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIocGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoKYXR0cl9uZXh0OgoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9ICAgICAgICAKICAgIC8qCiAgICAqIDMuMi4zIDogMgogICAgKiBJZiBkZWZhdWx0IGFuZCB1c2UgYXJlIGJvdGggcHJlc2VudCwgdXNlIG11c3QgaGF2ZQogICAgKiB0aGUgYWN0dWFsIHZhbHVlIG9wdGlvbmFsLgogICAgKi8KICAgIGlmICgoZGVmVmFsdWVUeXBlID09IFdYU19BVFRSX0RFRl9WQUxfREVGQVVMVCkgJiYKCShvY2N1cnMgIT0gWE1MX1NDSEVNQVNfQVRUUl9VU0VfT1BUSU9OQUwpKSB7Cgl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TUkNfQVRUUklCVVRFXzIsCgkgICAgTlVMTCwgbm9kZSwgTlVMTCwKCSAgICAiKG9wdGlvbmFsIHwgcHJvaGliaXRlZCB8IHJlcXVpcmVkKSIsIE5VTEwsCgkgICAgIlRoZSB2YWx1ZSBvZiB0aGUgYXR0cmlidXRlICd1c2UnIG11c3QgYmUgJ29wdGlvbmFsJyAiCgkgICAgImlmIHRoZSBhdHRyaWJ1dGUgJ2RlZmF1bHQnIGlzIHByZXNlbnQiLAoJICAgIE5VTEwsIE5VTEwpOwogICAgfQogICAgLyoKICAgICogV2Ugd2FudCBjb3JyZWN0IGF0dHJpYnV0ZXMuCiAgICAqLwogICAgaWYgKG5iZXJyb3JzICE9IHBjdHh0LT5uYmVycm9ycykKCXJldHVybihOVUxMKTsKICAgIGlmICghIGlzUmVmKSB7Cgl4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgYXR0ckRlY2w7CgoJLyogVE9ETzogbW92ZSBYTUxfU0NIRU1BU19RVUFMSUZfQVRUUiB0byB0aGUgcGFyc2VyLiAqLwoJaWYgKCghIGhhc0Zvcm0pICYmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfUVVBTElGX0FUVFIpKQoJICAgIG5zID0gcGN0eHQtPnRhcmdldE5hbWVzcGFjZTsJCQoJLyoKCSogMy4yLjYgU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiB4c2k6IE5vdCBBbGxvd2VkCgkqIFRPRE86IE1vdmUgdGhpcyB0byB0aGUgY29tcG9uZW50IGxheWVyLgoJKi8KCWlmICh4bWxTdHJFcXVhbChucywgeG1sU2NoZW1hSW5zdGFuY2VOcykpIHsKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQlYTUxfU0NIRU1BUF9OT19YU0ksCgkJbm9kZSwgTlVMTCwKCQkiVGhlIHRhcmdldCBuYW1lc3BhY2UgbXVzdCBub3QgbWF0Y2ggJyVzJyIsCgkJeG1sU2NoZW1hSW5zdGFuY2VOcywgTlVMTCk7Cgl9CglhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgIm5hbWUiKTsKCWlmIChhdHRyID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnIocGN0eHQsIFhNTF9TQ0hFTUFQX1M0U19BVFRSX01JU1NJTkcsCgkJTlVMTCwgbm9kZSwgIm5hbWUiLCBOVUxMKTsKCSAgICByZXR1cm4gKE5VTEwpOwoJfQoJaWYgKHhtbFNjaGVtYVBWYWxBdHRyTm9kZShwY3R4dCwgTlVMTCwgYXR0ciwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19OQ05BTUUpLCAmbmFtZSkgIT0gMCkgewoJICAgIHJldHVybiAoTlVMTCk7Cgl9CgkvKgoJKiAzLjIuNiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IHhtbG5zIE5vdCBBbGxvd2VkCgkqIFRPRE86IE1vdmUgdGhpcyB0byB0aGUgY29tcG9uZW50IGxheWVyLgoJKi8KCWlmICh4bWxTdHJFcXVhbChuYW1lLCBCQURfQ0FTVCAieG1sbnMiKSkgewoJICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX05PX1hNTE5TLAoJCU5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLAoJCXhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05DTkFNRSksIE5VTEwsIE5VTEwsCgkJIlRoZSB2YWx1ZSBvZiB0aGUgYXR0cmlidXRlIG11c3Qgbm90IG1hdGNoICd4bWxucyciLAoJCU5VTEwsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9CglpZiAob2NjdXJzID09IFhNTF9TQ0hFTUFTX0FUVFJfVVNFX1BST0hJQklURUQpCgkgICAgZ290byBjaGVja19jaGlsZHJlbjsKCS8qCgkqIENyZWF0ZSB0aGUgYXR0cmlidXRlIHVzZSBjb21wb25lbnQuCgkqLwoJdXNlID0geG1sU2NoZW1hQWRkQXR0cmlidXRlVXNlKHBjdHh0LCBub2RlKTsKCWlmICh1c2UgPT0gTlVMTCkKCSAgICByZXR1cm4oTlVMTCk7Cgl1c2UtPm9jY3VycyA9IG9jY3VyczsKCS8qCgkqIENyZWF0ZSB0aGUgYXR0cmlidXRlIGRlY2xhcmF0aW9uLgoJKi8KCWF0dHJEZWNsID0geG1sU2NoZW1hQWRkQXR0cmlidXRlKHBjdHh0LCBzY2hlbWEsIG5hbWUsIG5zLCBub2RlLCAwKTsKCWlmIChhdHRyRGVjbCA9PSBOVUxMKQoJICAgIHJldHVybiAoTlVMTCk7CglpZiAodG1wTmFtZSAhPSBOVUxMKSB7CgkgICAgYXR0ckRlY2wtPnR5cGVOYW1lID0gdG1wTmFtZTsKCSAgICBhdHRyRGVjbC0+dHlwZU5zID0gdG1wTnM7Cgl9Cgl1c2UtPmF0dHJEZWNsID0gYXR0ckRlY2w7CgkvKgoJKiBWYWx1ZSBjb25zdHJhaW50LgoJKi8JCglpZiAoZGVmVmFsdWUgIT0gTlVMTCkgewoJICAgIGF0dHJEZWNsLT5kZWZWYWx1ZSA9IGRlZlZhbHVlOwoJICAgIGlmIChkZWZWYWx1ZVR5cGUgPT0gV1hTX0FUVFJfREVGX1ZBTF9GSVhFRCkKCQlhdHRyRGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfQVRUUl9GSVhFRDsKCX0KICAgIH0gZWxzZSBpZiAob2NjdXJzICE9IFhNTF9TQ0hFTUFTX0FUVFJfVVNFX1BST0hJQklURUQpIHsKCXhtbFNjaGVtYVFOYW1lUmVmUHRyIHJlZjsKCgkvKgoJKiBDcmVhdGUgdGhlIGF0dHJpYnV0ZSB1c2UgY29tcG9uZW50LgoJKi8KCXVzZSA9IHhtbFNjaGVtYUFkZEF0dHJpYnV0ZVVzZShwY3R4dCwgbm9kZSk7CglpZiAodXNlID09IE5VTEwpCgkgICAgcmV0dXJuKE5VTEwpOwoJLyoKCSogV2UgbmVlZCB0byByZXNvbHZlIHRoZSByZWZlcmVuY2UgYXQgbGF0ZXIgc3RhZ2UuCgkqLwoJV1hTX0FERF9QRU5ESU5HKHBjdHh0LCB1c2UpOwoJdXNlLT5vY2N1cnMgPSBvY2N1cnM7CgkvKgoJKiBDcmVhdGUgYSBRTmFtZSByZWZlcmVuY2UgdG8gdGhlIGF0dHJpYnV0ZSBkZWNsYXJhdGlvbi4KCSovCglyZWYgPSB4bWxTY2hlbWFOZXdRTmFtZVJlZihwY3R4dCwgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURSwKCSAgICB0bXBOYW1lLCB0bXBOcyk7CglpZiAocmVmID09IE5VTEwpCgkgICAgcmV0dXJuKE5VTEwpOwoJLyoKCSogQXNzaWduIHRoZSByZWZlcmVuY2UuIFRoaXMgd2lsbCBiZSBzdWJzdGl0dXRlZCBmb3IgdGhlCgkqIHJlZmVyZW5jZWQgYXR0cmlidXRlIGRlY2xhcmF0aW9uIHdoZW4gdGhlIFFOYW1lIGlzIHJlc29sdmVkLgoJKi8KCXVzZS0+YXR0ckRlY2wgPSBXWFNfQVRUUl9DQVNUIHJlZjsKCS8qCgkqIFZhbHVlIGNvbnN0cmFpbnQuCgkqLwoJaWYgKGRlZlZhbHVlICE9IE5VTEwpCgkgICAgdXNlLT5kZWZWYWx1ZSA9IGRlZlZhbHVlOwoJICAgIGlmIChkZWZWYWx1ZVR5cGUgPT0gV1hTX0FUVFJfREVGX1ZBTF9GSVhFRCkKCQl1c2UtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfQVRUUl9VU0VfRklYRUQ7CiAgICB9CiAgICAKY2hlY2tfY2hpbGRyZW46CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKG9jY3VycyA9PSBYTUxfU0NIRU1BU19BVFRSX1VTRV9QUk9ISUJJVEVEKSB7Cgl4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQcm9oaWJQdHIgcHJvaGliOwkKCglpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CgkgICAgeG1sU2NoZW1hUGFyc2VBbm5vdGF0aW9uKHBjdHh0LCBzY2hlbWEsIGNoaWxkLCAwKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQoJaWYgKGNoaWxkICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ29udGVudEVycihwY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQlOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCQkiKGFubm90YXRpb24/KSIpOwoJfQoJLyoKCSogQ2hlY2sgZm9yIHBvaW50bGVzc25lc3Mgb2YgYXR0cmlidXRlIHByb2hpYml0aW9ucy4KCSovCglpZiAocGFyZW50VHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVApIHsJCQoJICAgIHhtbFNjaGVtYUN1c3RvbVdhcm5pbmcoQUNUWFRfQ0FTVCBwY3R4dCwKCQlYTUxfU0NIRU1BUF9XQVJOX0FUVFJfUE9JTlRMRVNTX1BST0gsCgkJbm9kZSwgTlVMTCwKCQkiU2tpcHBpbmcgYXR0cmlidXRlIHVzZSBwcm9oaWJpdGlvbiwgc2luY2UgaXQgaXMgIgoJCSJwb2ludGxlc3MgaW5zaWRlIGFuIDxhdHRyaWJ1dGVHcm91cD4iLAoJCU5VTEwsIE5VTEwsIE5VTEwpOwoJICAgIHJldHVybihOVUxMKTsKCX0gZWxzZSBpZiAocGFyZW50VHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfRVhURU5TSU9OKSB7CgkgICAgeG1sU2NoZW1hQ3VzdG9tV2FybmluZyhBQ1RYVF9DQVNUIHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1dBUk5fQVRUUl9QT0lOVExFU1NfUFJPSCwKCQlub2RlLCBOVUxMLAoJCSJTa2lwcGluZyBhdHRyaWJ1dGUgdXNlIHByb2hpYml0aW9uLCBzaW5jZSBpdCBpcyAiCgkJInBvaW50bGVzcyB3aGVuIGV4dGVuZGluZyBhIHR5cGUiLAoJCU5VTEwsIE5VTEwsIE5VTEwpOwoJICAgIHJldHVybihOVUxMKTsKCX0KCWlmICghIGlzUmVmKSB7CgkgICAgdG1wTmFtZSA9IG5hbWU7IAoJICAgIHRtcE5zID0gbnM7Cgl9CgkvKgoJKiBDaGVjayBmb3IgZHVwbGljYXRlIGF0dHJpYnV0ZSBwcm9oaWJpdGlvbnMuCgkqLwoJaWYgKHVzZXMpIHsKCSAgICBpbnQgaTsKCSAgICAKCSAgICBmb3IgKGkgPSAwOyBpIDwgdXNlcy0+bmJJdGVtczsgaSsrKSB7CgkJdXNlID0gdXNlcy0+aXRlbXNbaV07CgkJaWYgKCh1c2UtPnR5cGUgPT0gWE1MX1NDSEVNQV9FWFRSQV9BVFRSX1VTRV9QUk9ISUIpICYmCgkJICAgICh0bXBOYW1lID09IChXWFNfQVRUUl9QUk9ISUJfQ0FTVCB1c2UpLT5uYW1lKSAmJgoJCSAgICAodG1wTnMgPT0gKFdYU19BVFRSX1BST0hJQl9DQVNUIHVzZSktPnRhcmdldE5hbWVzcGFjZSkpCgkJewoJCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJCSAgICAKCQkgICAgeG1sU2NoZW1hQ3VzdG9tV2FybmluZyhBQ1RYVF9DQVNUIHBjdHh0LAoJCQlYTUxfU0NIRU1BUF9XQVJOX0FUVFJfUE9JTlRMRVNTX1BST0gsCgkJCW5vZGUsIE5VTEwsCgkJCSJTa2lwcGluZyBkdXBsaWNhdGUgYXR0cmlidXRlIHVzZSBwcm9oaWJpdGlvbiAnJXMnIiwKCQkJeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwgdG1wTnMsIHRtcE5hbWUpLAoJCQlOVUxMLCBOVUxMKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpCQkJCgkJICAgIHJldHVybihOVUxMKTsKCQl9CQoJICAgIH0KCX0KCS8qCgkqIENyZWF0ZSB0aGUgYXR0cmlidXRlIHByb2hpYml0aW9uIGhlbHBlciBjb21wb25lbnQuCgkqLwoJcHJvaGliID0geG1sU2NoZW1hQWRkQXR0cmlidXRlVXNlUHJvaGliKHBjdHh0KTsKCWlmIChwcm9oaWIgPT0gTlVMTCkKCSAgICByZXR1cm4oTlVMTCk7Cglwcm9oaWItPm5vZGUgPSBub2RlOwoJcHJvaGliLT5uYW1lID0gdG1wTmFtZTsKCXByb2hpYi0+dGFyZ2V0TmFtZXNwYWNlID0gdG1wTnM7CglpZiAoaXNSZWYpIHsKCSAgICAvKgoJICAgICogV2UgbmVlZCBhdCBsZWFzdCB0byByZXNvbHZlIHRvIHRoZSBhdHRyaWJ1dGUgZGVjbGFyYXRpb24uCgkgICAgKi8KCSAgICBXWFNfQUREX1BFTkRJTkcocGN0eHQsIHByb2hpYik7Cgl9CglyZXR1cm4oV1hTX0JBU0lDX0NBU1QgcHJvaGliKTsKICAgIH0gZWxzZSB7ICAgICAgICAKCWlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCSAgICAvKgoJICAgICogVE9ETzogU2hvdWxkIHRoaXMgZ28gaW50byB0aGUgYXR0ciBkZWNsPwoJICAgICovCgkgICAgdXNlLT5hbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihwY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0KCWlmIChpc1JlZikgewoJICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7CgkJaWYgKElTX1NDSEVNQShjaGlsZCwgInNpbXBsZVR5cGUiKSkKCQkgICAgLyoKCQkgICAgKiAzLjIuMyA6IDMuMgoJCSAgICAqIElmIHJlZiBpcyBwcmVzZW50LCB0aGVuIGFsbCBvZiA8c2ltcGxlVHlwZT4sCgkJICAgICogZm9ybSBhbmQgdHlwZSBtdXN0IGJlIGFic2VudC4KCQkgICAgKi8KCQkgICAgeG1sU2NoZW1hUENvbnRlbnRFcnIocGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1NSQ19BVFRSSUJVVEVfM18yLAoJCQlOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCQkJIihhbm5vdGF0aW9uPykiKTsKCQllbHNlCgkJICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKHBjdHh0LAoJCQlYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQkJTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkJCSIoYW5ub3RhdGlvbj8pIik7CgkgICAgfQoJfSBlbHNlIHsKCSAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAic2ltcGxlVHlwZSIpKSB7CgkJaWYgKFdYU19BVFRSVVNFX0RFQ0wodXNlKS0+dHlwZU5hbWUgIT0gTlVMTCkgewoJCSAgICAvKgoJCSAgICAqIDMuMi4zIDogNAoJCSAgICAqIHR5cGUgYW5kIDxzaW1wbGVUeXBlPiBtdXN0IG5vdCBib3RoIGJlIHByZXNlbnQuCgkJICAgICovCgkJICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKHBjdHh0LCBYTUxfU0NIRU1BUF9TUkNfQVRUUklCVVRFXzQsCgkJCU5VTEwsIG5vZGUsIGNoaWxkLAoJCQkiVGhlIGF0dHJpYnV0ZSAndHlwZScgYW5kIHRoZSA8c2ltcGxlVHlwZT4gY2hpbGQgIgoJCQkiYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIsIE5VTEwpOwoJCX0gZWxzZQoJCSAgICBXWFNfQVRUUlVTRV9UWVBFREVGKHVzZSkgPQoJCQl4bWxTY2hlbWFQYXJzZVNpbXBsZVR5cGUocGN0eHQsIHNjaGVtYSwgY2hpbGQsIDApOwoJCWNoaWxkID0gY2hpbGQtPm5leHQ7CgkgICAgfQoJICAgIGlmIChjaGlsZCAhPSBOVUxMKQoJCXhtbFNjaGVtYVBDb250ZW50RXJyKHBjdHh0LCBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQlOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCQkiKGFubm90YXRpb24/LCBzaW1wbGVUeXBlPykiKTsKCX0KICAgIH0gICAKICAgIHJldHVybiAoV1hTX0JBU0lDX0NBU1QgdXNlKTsKfQoKCnN0YXRpYyB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIKeG1sU2NoZW1hUGFyc2VHbG9iYWxBdHRyaWJ1dGUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJICAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJICAgICAgeG1sTm9kZVB0ciBub2RlKQp7CiAgICBjb25zdCB4bWxDaGFyICphdHRyVmFsdWU7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgcmV0OwogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICB4bWxBdHRyUHRyIGF0dHI7CgogICAgLyoKICAgICAqIE5vdGUgdGhhdCB0aGUgdzNjIHNwZWMgYXNzdW1lcyB0aGUgc2NoZW1hIHRvIGJlIHZhbGlkYXRlZCB3aXRoIHNjaGVtYQogICAgICogZm9yIHNjaGVtYXMgYmVmb3JlaGFuZC4KICAgICAqCiAgICAgKiAzLjIuMyBDb25zdHJhaW50cyBvbiBYTUwgUmVwcmVzZW50YXRpb25zIG9mIEF0dHJpYnV0ZSBEZWNsYXJhdGlvbnMKICAgICAqLwogICAgaWYgKChwY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7ICAgICAgICAKICAgIC8qCiAgICAqIDMuMi4zIDogMy4xCiAgICAqIE9uZSBvZiByZWYgb3IgbmFtZSBtdXN0IGJlIHByZXNlbnQsIGJ1dCBub3QgYm90aAogICAgKi8KICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibmFtZSIpOwogICAgaWYgKGF0dHIgPT0gTlVMTCkgewoJeG1sU2NoZW1hUE1pc3NpbmdBdHRyRXJyKHBjdHh0LCBYTUxfU0NIRU1BUF9TNFNfQVRUUl9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsICJuYW1lIiwgTlVMTCk7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgaWYgKHhtbFNjaGVtYVBWYWxBdHRyTm9kZShwY3R4dCwgTlVMTCwgYXR0ciwKCXhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05DTkFNRSksICZhdHRyVmFsdWUpICE9IDApIHsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICAvKgogICAgKiAzLjIuNiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IHhtbG5zIE5vdCBBbGxvd2VkCiAgICAqIFRPRE86IE1vdmUgdGhpcyB0byB0aGUgY29tcG9uZW50IGxheWVyLgogICAgKi8KICAgIGlmICh4bWxTdHJFcXVhbChhdHRyVmFsdWUsIEJBRF9DQVNUICJ4bWxucyIpKSB7Cgl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9OT19YTUxOUywKCSAgICBOVUxMLCAoeG1sTm9kZVB0cikgYXR0ciwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19OQ05BTUUpLCBOVUxMLCBOVUxMLAoJICAgICJUaGUgdmFsdWUgb2YgdGhlIGF0dHJpYnV0ZSBtdXN0IG5vdCBtYXRjaCAneG1sbnMnIiwKCSAgICBOVUxMLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICAvKgogICAgKiAzLjIuNiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IHhzaTogTm90IEFsbG93ZWQKICAgICogVE9ETzogTW92ZSB0aGlzIHRvIHRoZSBjb21wb25lbnQgbGF5ZXIuCiAgICAqICAgICAgIE9yIGJldHRlciBsZWF2ZSBpdCBoZXJlIGFuZCBhZGQgaXQgdG8gdGhlIGNvbXBvbmVudCBsYXllcgogICAgKiAgICAgICBpZiB3ZSBoYXZlIGEgc2NoZW1hIGNvbnN0cnVjdGlvbiBBUEkuCiAgICAqLwogICAgaWYgKHhtbFN0ckVxdWFsKHBjdHh0LT50YXJnZXROYW1lc3BhY2UsIHhtbFNjaGVtYUluc3RhbmNlTnMpKSB7Cgl4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9OT19YU0ksIG5vZGUsIE5VTEwsCgkgICAgIlRoZSB0YXJnZXQgbmFtZXNwYWNlIG11c3Qgbm90IG1hdGNoICclcyciLAoJICAgIHhtbFNjaGVtYUluc3RhbmNlTnMsIE5VTEwpOwogICAgfQoKICAgIHJldCA9IHhtbFNjaGVtYUFkZEF0dHJpYnV0ZShwY3R4dCwgc2NoZW1hLCBhdHRyVmFsdWUsCglwY3R4dC0+dGFyZ2V0TmFtZXNwYWNlLCBub2RlLCAxKTsKICAgIGlmIChyZXQgPT0gTlVMTCkKCXJldHVybiAoTlVMTCk7CiAgICByZXQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0FUVFJfR0xPQkFMOwoJCiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJkZWZhdWx0IikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiZml4ZWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuYW1lIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAidHlwZSIpKSkKCSAgICB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CQkKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIocGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJfQoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9CiAgICB4bWxTY2hlbWFQVmFsQXR0clFOYW1lKHBjdHh0LCBzY2hlbWEsIE5VTEwsCglub2RlLCAidHlwZSIsICZyZXQtPnR5cGVOcywgJnJldC0+dHlwZU5hbWUpOwogICAgCiAgICB4bWxTY2hlbWFQVmFsQXR0cklEKHBjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIC8qCiAgICAqIEF0dHJpYnV0ZSAiZml4ZWQiLgogICAgKi8KICAgIHJldC0+ZGVmVmFsdWUgPSB4bWxTY2hlbWFHZXRQcm9wKHBjdHh0LCBub2RlLCAiZml4ZWQiKTsKICAgIGlmIChyZXQtPmRlZlZhbHVlICE9IE5VTEwpCglyZXQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0FUVFJfRklYRUQ7CiAgICAvKgogICAgKiBBdHRyaWJ1dGUgImRlZmF1bHQiLgogICAgKi8KICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAiZGVmYXVsdCIpOwogICAgaWYgKGF0dHIgIT0gTlVMTCkgewoJLyoKCSogMy4yLjMgOiAxCgkqIGRlZmF1bHQgYW5kIGZpeGVkIG11c3Qgbm90IGJvdGggYmUgcHJlc2VudC4KCSovCglpZiAocmV0LT5mbGFncyAmIFhNTF9TQ0hFTUFTX0FUVFJfRklYRUQpIHsKCSAgICB4bWxTY2hlbWFQTXV0dWFsRXhjbEF0dHJFcnIocGN0eHQsIFhNTF9TQ0hFTUFQX1NSQ19BVFRSSUJVVEVfMSwKCQlXWFNfQkFTSUNfQ0FTVCByZXQsIGF0dHIsICJkZWZhdWx0IiwgImZpeGVkIik7Cgl9IGVsc2UKCSAgICByZXQtPmRlZlZhbHVlID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQocGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKICAgIH0KICAgIC8qCiAgICAqIEFuZCBub3cgZm9yIHRoZSBjaGlsZHJlbi4uLgogICAgKi8KICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CiAgICAgICAgcmV0LT5hbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihwY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCWlmIChyZXQtPnR5cGVOYW1lICE9IE5VTEwpIHsKCSAgICAvKgoJICAgICogMy4yLjMgOiA0CgkgICAgKiB0eXBlIGFuZCA8c2ltcGxlVHlwZT4gbXVzdCBub3QgYm90aCBiZSBwcmVzZW50LgoJICAgICovCgkgICAgeG1sU2NoZW1hUENvbnRlbnRFcnIocGN0eHQsIFhNTF9TQ0hFTUFQX1NSQ19BVFRSSUJVVEVfNCwKCQlOVUxMLCBub2RlLCBjaGlsZCwKCQkiVGhlIGF0dHJpYnV0ZSAndHlwZScgYW5kIHRoZSA8c2ltcGxlVHlwZT4gY2hpbGQgIgoJCSJhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIiwgTlVMTCk7Cgl9IGVsc2UKCSAgICByZXQtPnN1YnR5cGVzID0geG1sU2NoZW1hUGFyc2VTaW1wbGVUeXBlKHBjdHh0LCBzY2hlbWEsIGNoaWxkLCAwKTsKCWNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkKCXhtbFNjaGVtYVBDb250ZW50RXJyKHBjdHh0LCBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/LCBzaW1wbGVUeXBlPykiKTsKCiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZUF0dHJpYnV0ZUdyb3VwUmVmOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqCiAqIFBhcnNlIGFuIGF0dHJpYnV0ZSBncm91cCBkZWZpbml0aW9uIHJlZmVyZW5jZS4KICogTm90ZSB0aGF0IGEgcmVmZXJlbmNlIHRvIGFuIGF0dHJpYnV0ZSBncm91cCBkb2VzIG5vdAogKiBjb3JyZXNwb25kIHRvIGFueSBjb21wb25lbnQgYXQgYWxsLgogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgdGhlIGF0dHJpYnV0ZSBncm91cCBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IuCiAqLwpzdGF0aWMgeG1sU2NoZW1hUU5hbWVSZWZQdHIKeG1sU2NoZW1hUGFyc2VBdHRyaWJ1dGVHcm91cFJlZih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkJeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJCXhtbE5vZGVQdHIgbm9kZSkKewogICAgeG1sU2NoZW1hUU5hbWVSZWZQdHIgcmV0OwogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICB4bWxBdHRyUHRyIGF0dHI7CiAgICBjb25zdCB4bWxDaGFyICpyZWZOcyA9IE5VTEwsICpyZWYgPSBOVUxMOwoKICAgIGlmICgocGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAicmVmIik7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnIocGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTUlTU0lORywKCSAgICBOVUxMLCBub2RlLCAicmVmIiwgTlVMTCk7CglyZXR1cm4gKE5VTEwpOwogICAgfQkKICAgIHhtbFNjaGVtYVBWYWxBdHRyTm9kZVFOYW1lKHBjdHh0LCBzY2hlbWEsCglOVUxMLCBhdHRyLCAmcmVmTnMsICZyZWYpOwogICAgaWYgKHhtbFNjaGVtYUNoZWNrUmVmZXJlbmNlKHBjdHh0LCBzY2hlbWEsIG5vZGUsIGF0dHIsIHJlZk5zKSAhPSAwKQoJcmV0dXJuKE5VTEwpOwogICAKICAgIC8qCiAgICAqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJyZWYiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSkKCSAgICB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSB7CgkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQogICAgLyogQXR0cmlidXRlIElEICovCiAgICB4bWxTY2hlbWFQVmFsQXR0cklEKHBjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKCiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewoJLyoKCSogVE9ETzogV2UgZG8gbm90IGhhdmUgYSBwbGFjZSB0byBzdG9yZSB0aGUgYW5ub3RhdGlvbiwgZG8gd2U/CgkqLwogICAgICAgIHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihwY3R4dCwgc2NoZW1hLCBjaGlsZCwgMCk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/KSIpOwogICAgfQoKICAgIC8qCiAgICAqIEhhbmRsZSBhdHRyaWJ1dGUgZ3JvdXAgcmVkZWZpbml0aW9ucy4KICAgICovCiAgICBpZiAocGN0eHQtPmlzUmVkZWZpbmUgJiYgcGN0eHQtPnJlZGVmICYmCgkocGN0eHQtPnJlZGVmLT5pdGVtLT50eXBlID09CgkgICAgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQKSAmJgoJKHJlZiA9PSBwY3R4dC0+cmVkZWYtPnJlZk5hbWUpICYmCgkocmVmTnMgPT0gcGN0eHQtPnJlZGVmLT5yZWZUYXJnZXROcykpCiAgICB7CgkvKgoJKiBTUEVDIHNyYy1yZWRlZmluZToKCSogKDcuMSkgIklmIGl0IGhhcyBhbiA8YXR0cmlidXRlR3JvdXA+IGFtb25nIGl0cyBjb250ZW50cwoJKiB0aGUgt2FjdHVhbCB2YWx1Zbcgb2Ygd2hvc2UgcmVmIFthdHRyaWJ1dGVdIGlzIHRoZSBzYW1lCgkqIGFzIHRoZSC3YWN0dWFsIHZhbHVltyBvZiBpdHMgb3duIG5hbWUgYXR0cmlidXRlIHBsdXMKCSogdGFyZ2V0IG5hbWVzcGFjZSwgdGhlbiBpdCBtdXN0IGhhdmUgZXhhY3RseSBvbmUgc3VjaCBncm91cC4iCgkqLwoJaWYgKHBjdHh0LT5yZWRlZkNvdW50ZXIgIT0gMCkgewoJICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgkgICAgCgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FLCBub2RlLCBOVUxMLAoJCSJUaGUgcmVkZWZpbmluZyBhdHRyaWJ1dGUgZ3JvdXAgZGVmaW5pdGlvbiAiCgkJIiclcycgbXVzdCBub3QgY29udGFpbiBtb3JlIHRoYW4gb25lICIKCQkicmVmZXJlbmNlIHRvIHRoZSByZWRlZmluZWQgZGVmaW5pdGlvbiIsCgkJeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwgcmVmTnMsIHJlZiksIE5VTEwpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKTsKCSAgICByZXR1cm4oTlVMTCk7Cgl9CglwY3R4dC0+cmVkZWZDb3VudGVyKys7CgkvKgoJKiBVUkdFTlQgVE9ETzogSG93IHRvIGVuc3VyZSB0aGF0IHRoZSByZWZlcmVuY2Ugd2lsbCBub3QgYmUKCSogaGFuZGxlZCBieSB0aGUgbm9ybWFsIGNvbXBvbmVudCByZXNvbHV0aW9uIG1lY2hhbmlzbT8KCSovCglyZXQgPSB4bWxTY2hlbWFOZXdRTmFtZVJlZihwY3R4dCwKCSAgICBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVAsIHJlZiwgcmVmTnMpOwoJaWYgKHJldCA9PSBOVUxMKQoJICAgIHJldHVybihOVUxMKTsKCXJldC0+bm9kZSA9IG5vZGU7CglwY3R4dC0+cmVkZWYtPnJlZmVyZW5jZSA9IFdYU19CQVNJQ19DQVNUIHJldDsKICAgIH0gZWxzZSB7CgkvKgoJKiBDcmVhdGUgYSBRTmFtZS1yZWZlcmVuY2UgaGVscGVyIGNvbXBvbmVudC4gV2Ugd2lsbCBzdWJzdGl0dXRlIHRoaXMKCSogY29tcG9uZW50IGZvciB0aGUgYXR0cmlidXRlIHVzZXMgb2YgdGhlIHJlZmVyZW5jZWQgYXR0cmlidXRlIGdyb3VwCgkqIGRlZmluaXRpb24uCgkqLwoJcmV0ID0geG1sU2NoZW1hTmV3UU5hbWVSZWYocGN0eHQsCgkgICAgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQLCByZWYsIHJlZk5zKTsKCWlmIChyZXQgPT0gTlVMTCkKCSAgICByZXR1cm4oTlVMTCk7CglyZXQtPm5vZGUgPSBub2RlOwoJLyogQWRkIHRvIHBlbmRpbmcgaXRlbXMsIHRvIGJlIGFibGUgdG8gcmVzb2x2ZSB0aGUgcmVmZXJlbmNlLiAqLwoJV1hTX0FERF9QRU5ESU5HKHBjdHh0LCByZXQpOwogICAgfSAgICAKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlQXR0cmlidXRlR3JvdXBEZWZpbml0aW9uOgogKiBAcGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgQXR0cmlidXRlIEdyb3VwIGRlY2xhcmF0aW9uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb24gb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yLgogKi8Kc3RhdGljIHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyCnhtbFNjaGVtYVBhcnNlQXR0cmlidXRlR3JvdXBEZWZpbml0aW9uKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgICAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJCSAgICAgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWU7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0ciByZXQ7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGludCBoYXNSZWZzID0gMDsKCiAgICBpZiAoKHBjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkgfHwgKG5vZGUgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKCiAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgIm5hbWUiKTsKICAgIGlmIChhdHRyID09IE5VTEwpIHsKCXhtbFNjaGVtYVBNaXNzaW5nQXR0ckVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsICJuYW1lIiwgTlVMTCk7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgLyoKICAgICogVGhlIG5hbWUgaXMgY3J1Y2lhbCwgZXhpdCBpZiBpbnZhbGlkLgogICAgKi8KICAgIGlmICh4bWxTY2hlbWFQVmFsQXR0ck5vZGUocGN0eHQsCglOVUxMLCBhdHRyLAoJeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfTkNOQU1FKSwgJm5hbWUpICE9IDApIHsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICByZXQgPSB4bWxTY2hlbWFBZGRBdHRyaWJ1dGVHcm91cERlZmluaXRpb24ocGN0eHQsIHNjaGVtYSwKCW5hbWUsIHBjdHh0LT50YXJnZXROYW1lc3BhY2UsIG5vZGUpOwogICAgaWYgKHJldCA9PSBOVUxMKQoJcmV0dXJuIChOVUxMKTsJCiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibmFtZSIpKSAmJgoJCSgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImlkIikpKQoJICAgIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIocGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIocGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJfQoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9CiAgICAvKiBBdHRyaWJ1dGUgSUQgKi8KICAgIHhtbFNjaGVtYVBWYWxBdHRySUQocGN0eHQsIG5vZGUsIEJBRF9DQVNUICJpZCIpOwogICAgLyoKICAgICogQW5kIG5vdyBmb3IgdGhlIGNoaWxkcmVuLi4uCiAgICAqLwogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKICAgICAgICByZXQtPmFubm90ID0geG1sU2NoZW1hUGFyc2VBbm5vdGF0aW9uKHBjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgLyoKICAgICogUGFyc2UgY29udGFpbmVkIGF0dHJpYnV0ZSBkZWNscy9yZWZzLgogICAgKi8KICAgIGlmICh4bWxTY2hlbWFQYXJzZUxvY2FsQXR0cmlidXRlcyhwY3R4dCwgc2NoZW1hLCAmY2hpbGQsCgkoeG1sU2NoZW1hSXRlbUxpc3RQdHIgKikgJihyZXQtPmF0dHJVc2VzKSwKCVhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUCwgJmhhc1JlZnMpID09IC0xKQoJcmV0dXJuKE5VTEwpOwogICAgaWYgKGhhc1JlZnMpCglyZXQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9IQVNfUkVGUzsKICAgIC8qCiAgICAqIFBhcnNlIHRoZSBhdHRyaWJ1dGUgd2lsZGNhcmQuCiAgICAqLwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFueUF0dHJpYnV0ZSIpKSB7CglyZXQtPmF0dHJpYnV0ZVdpbGRjYXJkID0geG1sU2NoZW1hUGFyc2VBbnlBdHRyaWJ1dGUocGN0eHQsCgkgICAgc2NoZW1hLCBjaGlsZCk7CgljaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKCXhtbFNjaGVtYVBDb250ZW50RXJyKHBjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJICAgIE5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLAoJICAgICIoYW5ub3RhdGlvbj8sICgoYXR0cmlidXRlIHwgYXR0cmlidXRlR3JvdXApKiwgYW55QXR0cmlidXRlPykpIik7CiAgICB9CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQVmFsQXR0ckZvcm1EZWZhdWx0OgogKiBAdmFsdWU6ICB0aGUgdmFsdWUKICogQGZsYWdzOiB0aGUgZmxhZ3MgdG8gYmUgbW9kaWZpZWQKICogQGZsYWdRdWFsaWZpZWQ6IHRoZSBzcGVjaWZpYyBmbGFnIGZvciAicXVhbGlmaWVkIgogKgogKiBSZXR1cm5zIDAgaWYgdGhlIHZhbHVlIGlzIHZhbGlkLCAxIG90aGVyd2lzZS4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHJGb3JtRGVmYXVsdChjb25zdCB4bWxDaGFyICp2YWx1ZSwKCQkJICAgICBpbnQgKmZsYWdzLAoJCQkgICAgIGludCBmbGFnUXVhbGlmaWVkKQp7CiAgICBpZiAoeG1sU3RyRXF1YWwodmFsdWUsIEJBRF9DQVNUICJxdWFsaWZpZWQiKSkgewoJaWYgICgoKmZsYWdzICYgZmxhZ1F1YWxpZmllZCkgPT0gMCkKCSAgICAqZmxhZ3MgfD0gZmxhZ1F1YWxpZmllZDsKICAgIH0gZWxzZSBpZiAoIXhtbFN0ckVxdWFsKHZhbHVlLCBCQURfQ0FTVCAidW5xdWFsaWZpZWQiKSkKCXJldHVybiAoMSk7CgogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBWYWxBdHRyQmxvY2tGaW5hbDoKICogQHZhbHVlOiAgdGhlIHZhbHVlCiAqIEBmbGFnczogdGhlIGZsYWdzIHRvIGJlIG1vZGlmaWVkCiAqIEBmbGFnQWxsOiB0aGUgc3BlY2lmaWMgZmxhZyBmb3IgIiNhbGwiCiAqIEBmbGFnRXh0ZW5zaW9uOiB0aGUgc3BlY2lmaWMgZmxhZyBmb3IgImV4dGVuc2lvbiIKICogQGZsYWdSZXN0cmljdGlvbjogdGhlIHNwZWNpZmljIGZsYWcgZm9yICJyZXN0cmljdGlvbiIKICogQGZsYWdTdWJzdGl0dXRpb246IHRoZSBzcGVjaWZpYyBmbGFnIGZvciAic3Vic3RpdHV0aW9uIgogKiBAZmxhZ0xpc3Q6IHRoZSBzcGVjaWZpYyBmbGFnIGZvciAibGlzdCIKICogQGZsYWdVbmlvbjogdGhlIHNwZWNpZmljIGZsYWcgZm9yICJ1bmlvbiIKICoKICogVmFsaWRhdGVzIHRoZSB2YWx1ZSBvZiB0aGUgYXR0cmlidXRlICJmaW5hbCIgYW5kICJibG9jayIuIFRoZSB2YWx1ZQogKiBpcyBjb252ZXJ0ZWQgaW50byB0aGUgc3BlY2lmaWVkIGZsYWcgdmFsdWVzIGFuZCByZXR1cm5lZCBpbiBAZmxhZ3MuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgdmFsdWUgaXMgdmFsaWQsIDEgb3RoZXJ3aXNlLgogKi8KCnN0YXRpYyBpbnQKeG1sU2NoZW1hUFZhbEF0dHJCbG9ja0ZpbmFsKGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkgICAgaW50ICpmbGFncywKCQkJICAgIGludCBmbGFnQWxsLAoJCQkgICAgaW50IGZsYWdFeHRlbnNpb24sCgkJCSAgICBpbnQgZmxhZ1Jlc3RyaWN0aW9uLAoJCQkgICAgaW50IGZsYWdTdWJzdGl0dXRpb24sCgkJCSAgICBpbnQgZmxhZ0xpc3QsCgkJCSAgICBpbnQgZmxhZ1VuaW9uKQp7CiAgICBpbnQgcmV0ID0gMDsKCiAgICAvKgogICAgKiBUT0RPOiBUaGlzIGRvZXMgbm90IGNoZWNrIGZvciBkdWJsaWNhdGUgZW50cmllcy4KICAgICovCiAgICBpZiAoKGZsYWdzID09IE5VTEwpIHx8ICh2YWx1ZSA9PSBOVUxMKSkKCXJldHVybiAoLTEpOwogICAgaWYgKHZhbHVlWzBdID09IDApCglyZXR1cm4gKDApOwogICAgaWYgKHhtbFN0ckVxdWFsKHZhbHVlLCBCQURfQ0FTVCAiI2FsbCIpKSB7CglpZiAoZmxhZ0FsbCAhPSAtMSkKCSAgICAqZmxhZ3MgfD0gZmxhZ0FsbDsKCWVsc2UgewoJICAgIGlmIChmbGFnRXh0ZW5zaW9uICE9IC0xKQoJCSpmbGFncyB8PSBmbGFnRXh0ZW5zaW9uOwoJICAgIGlmIChmbGFnUmVzdHJpY3Rpb24gIT0gLTEpCgkJKmZsYWdzIHw9IGZsYWdSZXN0cmljdGlvbjsKCSAgICBpZiAoZmxhZ1N1YnN0aXR1dGlvbiAhPSAtMSkKCQkqZmxhZ3MgfD0gZmxhZ1N1YnN0aXR1dGlvbjsKCSAgICBpZiAoZmxhZ0xpc3QgIT0gLTEpCgkJKmZsYWdzIHw9IGZsYWdMaXN0OwoJICAgIGlmIChmbGFnVW5pb24gIT0gLTEpCgkJKmZsYWdzIHw9IGZsYWdVbmlvbjsKCX0KICAgIH0gZWxzZSB7Cgljb25zdCB4bWxDaGFyICplbmQsICpjdXIgPSB2YWx1ZTsKCXhtbENoYXIgKml0ZW07CgoJZG8gewoJICAgIHdoaWxlIChJU19CTEFOS19DSCgqY3VyKSkKCQljdXIrKzsKCSAgICBlbmQgPSBjdXI7CgkgICAgd2hpbGUgKCgqZW5kICE9IDApICYmICghKElTX0JMQU5LX0NIKCplbmQpKSkpCgkJZW5kKys7CgkgICAgaWYgKGVuZCA9PSBjdXIpCgkJYnJlYWs7CgkgICAgaXRlbSA9IHhtbFN0cm5kdXAoY3VyLCBlbmQgLSBjdXIpOwoJICAgIGlmICh4bWxTdHJFcXVhbChpdGVtLCBCQURfQ0FTVCAiZXh0ZW5zaW9uIikpIHsKCQlpZiAoZmxhZ0V4dGVuc2lvbiAhPSAtMSkgewoJCSAgICBpZiAoKCpmbGFncyAmIGZsYWdFeHRlbnNpb24pID09IDApCgkJCSpmbGFncyB8PSBmbGFnRXh0ZW5zaW9uOwoJCX0gZWxzZQoJCSAgICByZXQgPSAxOwoJICAgIH0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoaXRlbSwgQkFEX0NBU1QgInJlc3RyaWN0aW9uIikpIHsKCQlpZiAoZmxhZ1Jlc3RyaWN0aW9uICE9IC0xKSB7CgkJICAgIGlmICgoKmZsYWdzICYgZmxhZ1Jlc3RyaWN0aW9uKSA9PSAwKQoJCQkqZmxhZ3MgfD0gZmxhZ1Jlc3RyaWN0aW9uOwoJCX0gZWxzZQoJCSAgICByZXQgPSAxOwoJICAgIH0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoaXRlbSwgQkFEX0NBU1QgInN1YnN0aXR1dGlvbiIpKSB7CgkJaWYgKGZsYWdTdWJzdGl0dXRpb24gIT0gLTEpIHsKCQkgICAgaWYgKCgqZmxhZ3MgJiBmbGFnU3Vic3RpdHV0aW9uKSA9PSAwKQoJCQkqZmxhZ3MgfD0gZmxhZ1N1YnN0aXR1dGlvbjsKCQl9IGVsc2UKCQkgICAgcmV0ID0gMTsKCSAgICB9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGl0ZW0sIEJBRF9DQVNUICJsaXN0IikpIHsKCQlpZiAoZmxhZ0xpc3QgIT0gLTEpIHsKCQkgICAgaWYgKCgqZmxhZ3MgJiBmbGFnTGlzdCkgPT0gMCkKCQkJKmZsYWdzIHw9IGZsYWdMaXN0OwoJCX0gZWxzZQoJCSAgICByZXQgPSAxOwoJICAgIH0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoaXRlbSwgQkFEX0NBU1QgInVuaW9uIikpIHsKCQlpZiAoZmxhZ1VuaW9uICE9IC0xKSB7CgkJICAgIGlmICgoKmZsYWdzICYgZmxhZ1VuaW9uKSA9PSAwKQoJCQkqZmxhZ3MgfD0gZmxhZ1VuaW9uOwoJCX0gZWxzZQoJCSAgICByZXQgPSAxOwoJICAgIH0gZWxzZQoJCXJldCA9IDE7CgkgICAgaWYgKGl0ZW0gIT0gTlVMTCkKCQl4bWxGcmVlKGl0ZW0pOwoJICAgIGN1ciA9IGVuZDsKCX0gd2hpbGUgKChyZXQgPT0gMCkgJiYgKCpjdXIgIT0gMCkpOwogICAgfQoKICAgIHJldHVybiAocmV0KTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFDaGVja0NTZWxlY3RvclhQYXRoKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICAgICB4bWxTY2hlbWFJRENQdHIgaWRjLAoJCQkgICAgIHhtbFNjaGVtYUlEQ1NlbGVjdFB0ciBzZWxlY3RvciwKCQkJICAgICB4bWxBdHRyUHRyIGF0dHIsCgkJCSAgICAgaW50IGlzRmllbGQpCnsKICAgIHhtbE5vZGVQdHIgbm9kZTsKCiAgICAvKgogICAgKiBjLXNlbGVjdG9yLXhwYXRoOgogICAgKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IFNlbGVjdG9yIFZhbHVlIE9LCiAgICAqCiAgICAqIFRPRE86IDEgVGhlIHtzZWxlY3Rvcn0gbXVzdCBiZSBhIHZhbGlkIFhQYXRoIGV4cHJlc3Npb24sIGFzIGRlZmluZWQKICAgICogaW4gW1hQYXRoXS4KICAgICovCiAgICBpZiAoc2VsZWN0b3IgPT0gTlVMTCkgewoJeG1sU2NoZW1hUEVycihjdHh0LCBpZGMtPm5vZGUsCgkgICAgWE1MX1NDSEVNQVBfSU5URVJOQUwsCgkgICAgIkludGVybmFsIGVycm9yOiB4bWxTY2hlbWFDaGVja0NTZWxlY3RvclhQYXRoLCAiCgkgICAgInRoZSBzZWxlY3RvciBpcyBub3Qgc3BlY2lmaWVkLlxuIiwgTlVMTCwgTlVMTCk7CglyZXR1cm4gKC0xKTsKICAgIH0KICAgIGlmIChhdHRyID09IE5VTEwpCglub2RlID0gaWRjLT5ub2RlOwogICAgZWxzZQoJbm9kZSA9ICh4bWxOb2RlUHRyKSBhdHRyOwogICAgaWYgKHNlbGVjdG9yLT54cGF0aCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkgICAgLyogVE9ETzogQWRqdXN0IGVycm9yIGNvZGUuICovCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCSAgICBOVUxMLCBub2RlLAoJICAgICJUaGUgWFBhdGggZXhwcmVzc2lvbiBvZiB0aGUgc2VsZWN0b3IgaXMgbm90IHZhbGlkIiwgTlVMTCk7CglyZXR1cm4gKFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUpOwogICAgfSBlbHNlIHsKCWNvbnN0IHhtbENoYXIgKipuc0FycmF5ID0gTlVMTDsKCXhtbE5zUHRyICpuc0xpc3QgPSBOVUxMOwoJLyoKCSogQ29tcGlsZSB0aGUgWFBhdGggZXhwcmVzc2lvbi4KCSovCgkvKgoJKiBUT0RPOiBXZSBuZWVkIHRoZSBhcnJheSBvZiBpbi1zY29wZSBuYW1lc3BhY2VzIGZvciBjb21waWxhdGlvbi4KCSogVE9ETzogQ2FsbCB4bWxQYXR0ZXJuY29tcGlsZSB3aXRoIGRpZmZlcmVudCBvcHRpb25zIGZvciBzZWxlY3Rvci8KCSogZmllbGQuCgkqLwoJbnNMaXN0ID0geG1sR2V0TnNMaXN0KGF0dHItPmRvYywgYXR0ci0+cGFyZW50KTsKCS8qCgkqIEJ1aWxkIGFuIGFycmF5IG9mIHByZWZpeGVzIGFuZCBuYW1lc3BhY2VzLgoJKi8KCWlmIChuc0xpc3QgIT0gTlVMTCkgewoJICAgIGludCBpLCBjb3VudCA9IDA7CgoJICAgIGZvciAoaSA9IDA7IG5zTGlzdFtpXSAhPSBOVUxMOyBpKyspCgkJY291bnQrKzsKCgkgICAgbnNBcnJheSA9IChjb25zdCB4bWxDaGFyICoqKSB4bWxNYWxsb2MoCgkJKGNvdW50ICogMiArIDEpICogc2l6ZW9mKGNvbnN0IHhtbENoYXIgKikpOwoJICAgIGlmIChuc0FycmF5ID09IE5VTEwpIHsKCQl4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIGEgbmFtZXNwYWNlIGFycmF5IiwKCQkgICAgTlVMTCk7CgkJeG1sRnJlZShuc0xpc3QpOwoJCXJldHVybiAoLTEpOwoJICAgIH0KCSAgICBmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgewoJCW5zQXJyYXlbMiAqIGldID0gbnNMaXN0W2ldLT5ocmVmOwoJCW5zQXJyYXlbMiAqIGkgKyAxXSA9IG5zTGlzdFtpXS0+cHJlZml4OwoJICAgIH0KCSAgICBuc0FycmF5W2NvdW50ICogMl0gPSBOVUxMOwoJICAgIHhtbEZyZWUobnNMaXN0KTsKCX0KCS8qCgkqIFRPRE86IERpZmZlcmVudGlhdGUgYmV0d2VlbiAic2VsZWN0b3IiIGFuZCAiZmllbGQiLgoJKi8KCWlmIChpc0ZpZWxkKQoJICAgIHNlbGVjdG9yLT54cGF0aENvbXAgPSAodm9pZCAqKSB4bWxQYXR0ZXJuY29tcGlsZShzZWxlY3Rvci0+eHBhdGgsCgkJTlVMTCwgWE1MX1BBVFRFUk5fWFNGSUVMRCwgbnNBcnJheSk7CgllbHNlCgkgICAgc2VsZWN0b3ItPnhwYXRoQ29tcCA9ICh2b2lkICopIHhtbFBhdHRlcm5jb21waWxlKHNlbGVjdG9yLT54cGF0aCwKCQlOVUxMLCBYTUxfUEFUVEVSTl9YU1NFTCwgbnNBcnJheSk7CglpZiAobnNBcnJheSAhPSBOVUxMKQoJICAgIHhtbEZyZWUoKHhtbENoYXIgKiopIG5zQXJyYXkpOwoKCWlmIChzZWxlY3Rvci0+eHBhdGhDb21wID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJLyogVE9ETzogQWRqdXN0IGVycm9yIGNvZGU/ICovCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCQlOVUxMLCBub2RlLAoJCSJUaGUgWFBhdGggZXhwcmVzc2lvbiAnJXMnIGNvdWxkIG5vdCBiZSAiCgkJImNvbXBpbGVkIiwgc2VsZWN0b3ItPnhwYXRoKTsKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUpOwoJfQogICAgfQogICAgcmV0dXJuICgwKTsKfQoKI2RlZmluZSBBRERfQU5OT1RBVElPTihhbm5vdCkgICBcCiAgICB4bWxTY2hlbWFBbm5vdFB0ciBjdXIgPSBpdGVtLT5hbm5vdDsgXAogICAgaWYgKGl0ZW0tPmFubm90ID09IE5VTEwpIHsgIFwKCWl0ZW0tPmFubm90ID0gYW5ub3Q7ICAgIFwKCXJldHVybiAoYW5ub3QpOyAgICAgICAgIFwKICAgIH0gICAgICAgICAgICAgICAgICAgICAgICAgICBcCiAgICBjdXIgPSBpdGVtLT5hbm5vdDsgICAgICAgICAgXAogICAgaWYgKGN1ci0+bmV4dCAhPSBOVUxMKSB7ICAgIFwKCWN1ciA9IGN1ci0+bmV4dDsJXAogICAgfSAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKICAgIGN1ci0+bmV4dCA9IGFubm90OwoKLyoqCiAqIHhtbFNjaGVtYUFzc2lnbkFubm90YXRpb246CiAqIEBpdGVtOiB0aGUgc2NoZW1hIGNvbXBvbmVudAogKiBAYW5ub3Q6IHRoZSBhbm5vdGF0aW9uCiAqCiAqIEFkZHMgdGhlIGFubm90YXRpb24gdG8gdGhlIGdpdmVuIHNjaGVtYSBjb21wb25lbnQuCiAqCiAqIFJldHVybnMgdGhlIGdpdmVuIGFubm90YWlvbi4KICovCnN0YXRpYyB4bWxTY2hlbWFBbm5vdFB0cgp4bWxTY2hlbWFBZGRBbm5vdGF0aW9uKHhtbFNjaGVtYUFubm90SXRlbVB0ciBhbm5JdGVtLAoJCSAgICAgICB4bWxTY2hlbWFBbm5vdFB0ciBhbm5vdCkKewogICAgaWYgKChhbm5JdGVtID09IE5VTEwpIHx8IChhbm5vdCA9PSBOVUxMKSkKCXJldHVybiAoTlVMTCk7CiAgICBzd2l0Y2ggKGFubkl0ZW0tPnR5cGUpIHsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQ6IHsKCQl4bWxTY2hlbWFFbGVtZW50UHRyIGl0ZW0gPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgYW5uSXRlbTsKCQlBRERfQU5OT1RBVElPTihhbm5vdCkKCSAgICB9CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEU6IHsKCQl4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgaXRlbSA9ICh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIpIGFubkl0ZW07CgkJQUREX0FOTk9UQVRJT04oYW5ub3QpCgkgICAgfQoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZX0FUVFJJQlVURToKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0FOWTogewoJCXhtbFNjaGVtYVdpbGRjYXJkUHRyIGl0ZW0gPSAoeG1sU2NoZW1hV2lsZGNhcmRQdHIpIGFubkl0ZW07CgkJQUREX0FOTk9UQVRJT04oYW5ub3QpCgkgICAgfQoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfUEFSVElDTEU6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRjoKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19VTklRVUU6IHsKCQl4bWxTY2hlbWFBbm5vdEl0ZW1QdHIgaXRlbSA9ICh4bWxTY2hlbWFBbm5vdEl0ZW1QdHIpIGFubkl0ZW07CgkJQUREX0FOTk9UQVRJT04oYW5ub3QpCgkgICAgfQoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVA6IHsKCQl4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0ciBpdGVtID0KCQkgICAgKHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyKSBhbm5JdGVtOwoJCUFERF9BTk5PVEFUSU9OKGFubm90KQoJICAgIH0KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX05PVEFUSU9OOiB7CgkJeG1sU2NoZW1hTm90YXRpb25QdHIgaXRlbSA9ICh4bWxTY2hlbWFOb3RhdGlvblB0cikgYW5uSXRlbTsKCQlBRERfQU5OT1RBVElPTihhbm5vdCkKCSAgICB9CgkgICAgYnJlYWs7CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlOSU5DTFVTSVZFOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkVYQ0xVU0lWRToKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NQVhJTkNMVVNJVkU6CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYRVhDTFVTSVZFOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1RPVEFMRElHSVRTOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0ZSQUNUSU9ORElHSVRTOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk46CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfRU5VTUVSQVRJT046CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfV0hJVEVTUEFDRToKCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9MRU5HVEg6CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIOgoJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkxFTkdUSDogewoJCXhtbFNjaGVtYUZhY2V0UHRyIGl0ZW0gPSAoeG1sU2NoZW1hRmFjZXRQdHIpIGFubkl0ZW07CgkJQUREX0FOTk9UQVRJT04oYW5ub3QpCgkgICAgfQoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDogewoJCXhtbFNjaGVtYVR5cGVQdHIgaXRlbSA9ICh4bWxTY2hlbWFUeXBlUHRyKSBhbm5JdGVtOwoJCUFERF9BTk5PVEFUSU9OKGFubm90KQoJICAgIH0KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOiB7CgkJeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0ciBpdGVtID0gKHhtbFNjaGVtYU1vZGVsR3JvdXBEZWZQdHIpIGFubkl0ZW07CgkJQUREX0FOTk9UQVRJT04oYW5ub3QpCgkgICAgfQoJICAgIGJyZWFrOwoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0U6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0U6CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTEw6IHsKCQl4bWxTY2hlbWFNb2RlbEdyb3VwUHRyIGl0ZW0gPSAoeG1sU2NoZW1hTW9kZWxHcm91cFB0cikgYW5uSXRlbTsKCQlBRERfQU5OT1RBVElPTihhbm5vdCkKCSAgICB9CgkgICAgYnJlYWs7CglkZWZhdWx0OgoJICAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKE5VTEwsCgkJWE1MX1NDSEVNQVBfSU5URVJOQUwsCgkJTlVMTCwgTlVMTCwKCQkiSW50ZXJuYWwgZXJyb3I6IHhtbFNjaGVtYUFkZEFubm90YXRpb24sICIKCQkiVGhlIGl0ZW0gaXMgbm90IGEgYW5ub3RhdGVkIHNjaGVtYSBjb21wb25lbnQiLCBOVUxMKTsKCSAgICAgYnJlYWs7CiAgICB9CiAgICByZXR1cm4gKGFubm90KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlSURDU2VsZWN0b3JBbmRGaWVsZDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBQYXJzZXMgYSBYTUwgU2NoZW1hIGlkZW50aXR5LWNvbnRyYWludCBkZWZpbml0aW9uJ3MKICogPHNlbGVjdG9yPiBhbmQgPGZpZWxkPiBlbGVtZW50cy4KICoKICogUmV0dXJucyB0aGUgcGFyc2VkIGlkZW50aXR5LWNvbnN0cmFpbnQgZGVmaW5pdGlvbi4KICovCnN0YXRpYyB4bWxTY2hlbWFJRENTZWxlY3RQdHIKeG1sU2NoZW1hUGFyc2VJRENTZWxlY3RvckFuZEZpZWxkKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkgIHhtbFNjaGVtYUlEQ1B0ciBpZGMsCgkJCSAgeG1sTm9kZVB0ciBub2RlLAoJCQkgIGludCBpc0ZpZWxkKQp7CiAgICB4bWxTY2hlbWFJRENTZWxlY3RQdHIgaXRlbTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwoKICAgIC8qCiAgICAqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSAmJgoJCSgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgInhwYXRoIikpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7Cgl9CglhdHRyID0gYXR0ci0+bmV4dDsKICAgIH0KICAgIC8qCiAgICAqIENyZWF0ZSB0aGUgaXRlbS4KICAgICovCiAgICBpdGVtID0gKHhtbFNjaGVtYUlEQ1NlbGVjdFB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFJRENTZWxlY3QpKTsKICAgIGlmIChpdGVtID09IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsCgkgICAgImFsbG9jYXRpbmcgYSAnc2VsZWN0b3InIG9mIGFuIGlkZW50aXR5LWNvbnN0cmFpbnQgZGVmaW5pdGlvbiIsCgkgICAgTlVMTCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChpdGVtLCAwLCBzaXplb2YoeG1sU2NoZW1hSURDU2VsZWN0KSk7CiAgICAvKgogICAgKiBBdHRyaWJ1dGUgInhwYXRoIiAobWFuZGF0b3J5KS4KICAgICovCiAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgInhwYXRoIik7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7CiAgICAJeG1sU2NoZW1hUE1pc3NpbmdBdHRyRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTUlTU0lORywKCSAgICBOVUxMLCBub2RlLAoJICAgICJuYW1lIiwgTlVMTCk7CiAgICB9IGVsc2UgewoJaXRlbS0+eHBhdGggPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChjdHh0LCAoeG1sTm9kZVB0cikgYXR0cik7CgkvKgoJKiBVUkdFTlQgVE9ETzogImZpZWxkInMgaGF2ZSBhbiBvdGhlciBzeW50YXggdGhhbiAic2VsZWN0b3Iicy4KCSovCgoJaWYgKHhtbFNjaGVtYUNoZWNrQ1NlbGVjdG9yWFBhdGgoY3R4dCwgaWRjLCBpdGVtLCBhdHRyLAoJICAgIGlzRmllbGQpID09IC0xKSB7CgkgICAgeG1sU2NoZW1hUEVycihjdHh0LAoJCSh4bWxOb2RlUHRyKSBhdHRyLAoJCVhNTF9TQ0hFTUFQX0lOVEVSTkFMLAoJCSJJbnRlcm5hbCBlcnJvcjogeG1sU2NoZW1hUGFyc2VJRENTZWxlY3RvckFuZEZpZWxkLCAiCgkJInZhbGlkYXRpbmcgdGhlIFhQYXRoIGV4cHJlc3Npb24gb2YgYSBJREMgc2VsZWN0b3IuXG4iLAoJCU5VTEwsIE5VTEwpOwoJfQoKICAgIH0KICAgIHhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewoJLyoKCSogQWRkIHRoZSBhbm5vdGF0aW9uIHRvIHRoZSBwYXJlbnQgSURDLgoJKi8KCXhtbFNjaGVtYUFkZEFubm90YXRpb24oKHhtbFNjaGVtYUFubm90SXRlbVB0cikgaWRjLAoJICAgIHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKSk7CgljaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKCXhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkgICAgTlVMTCwgbm9kZSwgY2hpbGQsCgkgICAgTlVMTCwgIihhbm5vdGF0aW9uPykiKTsKICAgIH0KCiAgICByZXR1cm4gKGl0ZW0pOwp9CgovKioKICogeG1sU2NoZW1hUGFyc2VJREM6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogUGFyc2VzIGEgWE1MIFNjaGVtYSBpZGVudGl0eS1jb250cmFpbnQgZGVmaW5pdGlvbi4KICoKICogUmV0dXJucyB0aGUgcGFyc2VkIGlkZW50aXR5LWNvbnN0cmFpbnQgZGVmaW5pdGlvbi4KICovCnN0YXRpYyB4bWxTY2hlbWFJRENQdHIKeG1sU2NoZW1hUGFyc2VJREMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCSAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkgIHhtbE5vZGVQdHIgbm9kZSwKCQkgIHhtbFNjaGVtYVR5cGVUeXBlIGlkY0NhdGVnb3J5LAoJCSAgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TmFtZXNwYWNlKQp7CiAgICB4bWxTY2hlbWFJRENQdHIgaXRlbSA9IE5VTEw7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGNvbnN0IHhtbENoYXIgKm5hbWUgPSBOVUxMOwogICAgeG1sU2NoZW1hSURDU2VsZWN0UHRyIGZpZWxkID0gTlVMTCwgbGFzdEZpZWxkID0gTlVMTDsKCiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuYW1lIikpICYmCgkJKChpZGNDYXRlZ29yeSAhPSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRikgfHwKCQkgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAicmVmZXIiKSkpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7Cgl9CglhdHRyID0gYXR0ci0+bmV4dDsKICAgIH0KICAgIC8qCiAgICAqIEF0dHJpYnV0ZSAibmFtZSIgKG1hbmRhdG9yeSkuCiAgICAqLwogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJuYW1lIik7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsCgkgICAgIm5hbWUiLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9IGVsc2UgaWYgKHhtbFNjaGVtYVBWYWxBdHRyTm9kZShjdHh0LAoJTlVMTCwgYXR0ciwKCXhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05DTkFNRSksICZuYW1lKSAhPSAwKSB7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgLyogQ3JlYXRlIHRoZSBjb21wb25lbnQuICovCiAgICBpdGVtID0geG1sU2NoZW1hQWRkSURDKGN0eHQsIHNjaGVtYSwgbmFtZSwgdGFyZ2V0TmFtZXNwYWNlLAoJaWRjQ2F0ZWdvcnksIG5vZGUpOwogICAgaWYgKGl0ZW0gPT0gTlVMTCkKCXJldHVybihOVUxMKTsKCiAgICB4bWxTY2hlbWFQVmFsQXR0cklEKGN0eHQsIG5vZGUsIEJBRF9DQVNUICJpZCIpOwogICAgaWYgKGlkY0NhdGVnb3J5ID09IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGKSB7CgkvKgoJKiBBdHRyaWJ1dGUgInJlZmVyIiAobWFuZGF0b3J5KS4KCSovCglhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgInJlZmVyIik7CglpZiAoYXR0ciA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hUE1pc3NpbmdBdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTUlTU0lORywKCQlOVUxMLCBub2RlLAoJCSJyZWZlciIsIE5VTEwpOwoJfSBlbHNlIHsKCSAgICAvKgoJICAgICogQ3JlYXRlIGEgcmVmZXJlbmNlIGl0ZW0uCgkgICAgKi8KCSAgICBpdGVtLT5yZWYgPSB4bWxTY2hlbWFOZXdRTmFtZVJlZihjdHh0LCBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWSwKCQlOVUxMLCBOVUxMKTsKCSAgICBpZiAoaXRlbS0+cmVmID09IE5VTEwpCgkJcmV0dXJuIChOVUxMKTsKCSAgICB4bWxTY2hlbWFQVmFsQXR0ck5vZGVRTmFtZShjdHh0LCBzY2hlbWEsCgkJTlVMTCwgYXR0ciwKCQkmKGl0ZW0tPnJlZi0+dGFyZ2V0TmFtZXNwYWNlKSwKCQkmKGl0ZW0tPnJlZi0+bmFtZSkpOwoJICAgIHhtbFNjaGVtYUNoZWNrUmVmZXJlbmNlKGN0eHQsIHNjaGVtYSwgbm9kZSwgYXR0ciwKCQlpdGVtLT5yZWYtPnRhcmdldE5hbWVzcGFjZSk7Cgl9CiAgICB9CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewoJaXRlbS0+YW5ub3QgPSB4bWxTY2hlbWFQYXJzZUFubm90YXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSk7CgljaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKGNoaWxkID09IE5VTEwpIHsKCXhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0VMRU1fTUlTU0lORywKCQlOVUxMLCBub2RlLCBjaGlsZCwKCQkiQSBjaGlsZCBlbGVtZW50IGlzIG1pc3NpbmciLAoJCSIoYW5ub3RhdGlvbj8sIChzZWxlY3RvciwgZmllbGQrKSkiKTsKICAgIH0KICAgIC8qCiAgICAqIENoaWxkIGVsZW1lbnQgPHNlbGVjdG9yPi4KICAgICovCiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAic2VsZWN0b3IiKSkgewoJaXRlbS0+c2VsZWN0b3IgPSB4bWxTY2hlbWFQYXJzZUlEQ1NlbGVjdG9yQW5kRmllbGQoY3R4dCwgc2NoZW1hLAoJICAgIGl0ZW0sIGNoaWxkLCAwKTsKCWNoaWxkID0gY2hpbGQtPm5leHQ7CgkvKgoJKiBDaGlsZCBlbGVtZW50cyA8ZmllbGQ+LgoJKi8KCWlmIChJU19TQ0hFTUEoY2hpbGQsICJmaWVsZCIpKSB7CgkgICAgZG8gewoJCWZpZWxkID0geG1sU2NoZW1hUGFyc2VJRENTZWxlY3RvckFuZEZpZWxkKGN0eHQsIHNjaGVtYSwKCQkgICAgaXRlbSwgY2hpbGQsIDEpOwoJCWlmIChmaWVsZCAhPSBOVUxMKSB7CgkJICAgIGZpZWxkLT5pbmRleCA9IGl0ZW0tPm5iRmllbGRzOwoJCSAgICBpdGVtLT5uYkZpZWxkcysrOwoJCSAgICBpZiAobGFzdEZpZWxkICE9IE5VTEwpCgkJCWxhc3RGaWVsZC0+bmV4dCA9IGZpZWxkOwoJCSAgICBlbHNlCgkJCWl0ZW0tPmZpZWxkcyA9IGZpZWxkOwoJCSAgICBsYXN0RmllbGQgPSBmaWVsZDsKCQl9CgkJY2hpbGQgPSBjaGlsZC0+bmV4dDsKCSAgICB9IHdoaWxlIChJU19TQ0hFTUEoY2hpbGQsICJmaWVsZCIpKTsKCX0gZWxzZSB7CgkgICAgeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQlOVUxMLCBub2RlLCBjaGlsZCwKCQlOVUxMLCAiKGFubm90YXRpb24/LCAoc2VsZWN0b3IsIGZpZWxkKykpIik7Cgl9CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwKCSAgICBOVUxMLCAiKGFubm90YXRpb24/LCAoc2VsZWN0b3IsIGZpZWxkKykpIik7CiAgICB9CgogICAgcmV0dXJuIChpdGVtKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlRWxlbWVudDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKiBAdG9wTGV2ZWw6IGluZGljYXRlcyBpZiB0aGlzIGlzIGdsb2JhbCBkZWNsYXJhdGlvbgogKgogKiBQYXJzZXMgYSBYTUwgc2NoZW1hIGVsZW1lbnQgZGVjbGFyYXRpb24uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgZWxlbWVudCBkZWNsYXJhdGlvbiBvciBhIHBhcnRpY2xlOyBOVUxMIGluIGNhc2UKICogb2YgYW4gZXJyb3Igb3IgaWYgdGhlIHBhcnRpY2xlIGhhcyBtaW5PY2N1cnM9PW1heE9jY3Vycz09MC4KICovCnN0YXRpYyB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIKeG1sU2NoZW1hUGFyc2VFbGVtZW50KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwgeG1sU2NoZW1hUHRyIHNjaGVtYSwKICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSwgaW50ICppc0VsZW1SZWYsIGludCB0b3BMZXZlbCkKewogICAgeG1sU2NoZW1hRWxlbWVudFB0ciBkZWNsID0gTlVMTDsKICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnRpY2xlID0gTlVMTDsKICAgIHhtbFNjaGVtYUFubm90UHRyIGFubm90ID0gTlVMTDsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyLCBuYW1lQXR0cjsKICAgIGludCBtaW4sIG1heCwgaXNSZWYgPSAwOwogICAgeG1sQ2hhciAqZGVzID0gTlVMTDsKCiAgICAvKiAzLjMuMyBDb25zdHJhaW50cyBvbiBYTUwgUmVwcmVzZW50YXRpb25zIG9mIEVsZW1lbnQgRGVjbGFyYXRpb25zICovCiAgICAvKiBUT0RPOiBDb21wbGV0ZSBpbXBsZW1lbnRhdGlvbiBvZiAzLjMuNiAqLwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CgogICAgaWYgKGlzRWxlbVJlZiAhPSBOVUxMKQoJKmlzRWxlbVJlZiA9IDA7CiAgICAvKgogICAgKiBJZiB3ZSBnZXQgYSAicmVmIiBhdHRyaWJ1dGUgb24gYSBsb2NhbCA8ZWxlbWVudD4gd2Ugd2lsbCBhc3N1bWUgaXQncwogICAgKiBhIHJlZmVyZW5jZSAtIGV2ZW4gaWYgdGhlcmUncyBhICJuYW1lIiBhdHRyaWJ1dGU7IHRoaXMgc2VlbXMgdG8gYmUgbW9yZQogICAgKiByb2J1c3QuCiAgICAqLwogICAgbmFtZUF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibmFtZSIpOwogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJyZWYiKTsKICAgIGlmICgodG9wTGV2ZWwpIHx8IChhdHRyID09IE5VTEwpKSB7CglpZiAobmFtZUF0dHIgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBNaXNzaW5nQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX01JU1NJTkcsCgkJTlVMTCwgbm9kZSwgIm5hbWUiLCBOVUxMKTsKCSAgICByZXR1cm4gKE5VTEwpOwoJfQogICAgfSBlbHNlCglpc1JlZiA9IDE7CgogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7Cglhbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKCWNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICAvKgogICAgKiBTa2lwIHBhcnRpY2xlIHBhcnQgaWYgYSBnbG9iYWwgZGVjbGFyYXRpb24uCiAgICAqLwogICAgaWYgKHRvcExldmVsKQoJZ290byBkZWNsYXJhdGlvbl9wYXJ0OwogICAgLyoKICAgICogVGhlIHBhcnRpY2xlIHBhcnQgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICAgICovCiAgICBtaW4gPSB4bWxHZXRNaW5PY2N1cnMoY3R4dCwgbm9kZSwgMCwgLTEsIDEsICJ4czpub25OZWdhdGl2ZUludGVnZXIiKTsKICAgIG1heCA9IHhtbEdldE1heE9jY3VycyhjdHh0LCBub2RlLCAwLCBVTkJPVU5ERUQsIDEsICIoeHM6bm9uTmVnYXRpdmVJbnRlZ2VyIHwgdW5ib3VuZGVkKSIpOwogICAgeG1sU2NoZW1hUENoZWNrUGFydGljbGVDb3JyZWN0XzIoY3R4dCwgTlVMTCwgbm9kZSwgbWluLCBtYXgpOwogICAgcGFydGljbGUgPSB4bWxTY2hlbWFBZGRQYXJ0aWNsZShjdHh0LCBzY2hlbWEsIG5vZGUsIG1pbiwgbWF4KTsKICAgIGlmIChwYXJ0aWNsZSA9PSBOVUxMKQoJZ290byByZXR1cm5fbnVsbDsKCiAgICAvKiByZXQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0VMRU1fUkVGOyAqLwoKICAgIGlmIChpc1JlZikgewoJY29uc3QgeG1sQ2hhciAqcmVmTnMgPSBOVUxMLCAqcmVmID0gTlVMTDsKCXhtbFNjaGVtYVFOYW1lUmVmUHRyIHJlZmVyID0gTlVMTDsKCS8qCgkqIFRoZSByZWZlcmVuY2UgcGFydCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KCSovCglpZiAoaXNFbGVtUmVmICE9IE5VTEwpCgkgICAgKmlzRWxlbVJlZiA9IDE7CgoJeG1sU2NoZW1hUFZhbEF0dHJOb2RlUU5hbWUoY3R4dCwgc2NoZW1hLAoJICAgIE5VTEwsIGF0dHIsICZyZWZOcywgJnJlZik7Cgl4bWxTY2hlbWFDaGVja1JlZmVyZW5jZShjdHh0LCBzY2hlbWEsIG5vZGUsIGF0dHIsIHJlZk5zKTsKCS8qCgkqIFNQRUMgKDMuMy4zIDogMi4xKSAiT25lIG9mIHJlZiBvciBuYW1lIG11c3QgYmUgcHJlc2VudCwgYnV0IG5vdCBib3RoIgoJKi8KCWlmIChuYW1lQXR0ciAhPSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hUE11dHVhbEV4Y2xBdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfU1JDX0VMRU1FTlRfMl8xLCBOVUxMLCBuYW1lQXR0ciwgInJlZiIsICJuYW1lIik7Cgl9CgkvKgoJKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgoJKi8KCWF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwoJd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJICAgIGlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkJaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJyZWYiKSB8fAoJCSAgICB4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibmFtZSIpIHx8CgkJICAgIHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpIHx8CgkJICAgIHhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtYXhPY2N1cnMiKSB8fAoJCSAgICB4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibWluT2NjdXJzIikpCgkJewoJCSAgICBhdHRyID0gYXR0ci0+bmV4dDsKCQkgICAgY29udGludWU7CgkJfSBlbHNlIHsKCQkgICAgLyogU1BFQyAoMy4zLjMgOiAyLjIpICovCgkJICAgIHhtbFNjaGVtYVBDdXN0b21BdHRyRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1NSQ19FTEVNRU5UXzJfMiwKCQkJTlVMTCwgTlVMTCwgYXR0ciwKCQkJIk9ubHkgdGhlIGF0dHJpYnV0ZXMgJ21pbk9jY3VycycsICdtYXhPY2N1cnMnIGFuZCAiCgkJCSInaWQnIGFyZSBhbGxvd2VkIGluIGFkZGl0aW9uIHRvICdyZWYnIik7CgkJICAgIGJyZWFrOwoJCX0KCSAgICB9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCSAgICBhdHRyID0gYXR0ci0+bmV4dDsKCX0KCS8qCgkqIE5vIGNoaWxkcmVuIGV4Y2VwdCA8YW5ub3RhdGlvbj4gZXhwZWN0ZWQuCgkqLwoJaWYgKGNoaWxkICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LCBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQlOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwgIihhbm5vdGF0aW9uPykiKTsKCX0KCWlmICgobWluID09IDApICYmIChtYXggPT0gMCkpCgkgICAgZ290byByZXR1cm5fbnVsbDsKCS8qCgkqIENyZWF0ZSB0aGUgcmVmZXJlbmNlIGl0ZW0gYW5kIGF0dGFjaCBpdCB0byB0aGUgcGFydGljbGUuCgkqLwoJcmVmZXIgPSB4bWxTY2hlbWFOZXdRTmFtZVJlZihjdHh0LCBYTUxfU0NIRU1BX1RZUEVfRUxFTUVOVCwKCSAgICByZWYsIHJlZk5zKTsKCWlmIChyZWZlciA9PSBOVUxMKQoJICAgIGdvdG8gcmV0dXJuX251bGw7CglwYXJ0aWNsZS0+Y2hpbGRyZW4gPSAoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpIHJlZmVyOwoJcGFydGljbGUtPmFubm90ID0gYW5ub3Q7CgkvKgoJKiBBZGQgdGhlIHBhcnRpY2xlIHRvIHBlbmRpbmcgY29tcG9uZW50cywgc2luY2UgdGhlIHJlZmVyZW5jZQoJKiBuZWVkIHRvIGJlIHJlc29sdmVkLgoJKi8KCVdYU19BRERfUEVORElORyhjdHh0LCBwYXJ0aWNsZSk7CglyZXR1cm4gKCh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIpIHBhcnRpY2xlKTsKICAgIH0KICAgIC8qCiAgICAqIFRoZSBkZWNsYXJhdGlvbiBwYXJ0ID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAgICAqLwpkZWNsYXJhdGlvbl9wYXJ0OgogICAgewoJY29uc3QgeG1sQ2hhciAqbnMgPSBOVUxMLCAqZml4ZWQsICpuYW1lLCAqYXR0clZhbHVlOwoJeG1sU2NoZW1hSURDUHRyIGN1cklEQyA9IE5VTEwsIGxhc3RJREMgPSBOVUxMOwoKCWlmICh4bWxTY2hlbWFQVmFsQXR0ck5vZGUoY3R4dCwgTlVMTCwgbmFtZUF0dHIsCgkgICAgeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfTkNOQU1FKSwgJm5hbWUpICE9IDApCgkgICAgZ290byByZXR1cm5fbnVsbDsKCS8qCgkqIEV2YWx1YXRlIHRoZSB0YXJnZXQgbmFtZXNwYWNlLgoJKi8KCWlmICh0b3BMZXZlbCkgewoJICAgIG5zID0gY3R4dC0+dGFyZ2V0TmFtZXNwYWNlOwoJfSBlbHNlIHsKCSAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgImZvcm0iKTsKCSAgICBpZiAoYXR0ciAhPSBOVUxMKSB7CgkJYXR0clZhbHVlID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQoY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwoJCWlmICh4bWxTdHJFcXVhbChhdHRyVmFsdWUsIEJBRF9DQVNUICJxdWFsaWZpZWQiKSkgewoJCSAgICBucyA9IGN0eHQtPnRhcmdldE5hbWVzcGFjZTsKCQl9IGVsc2UgaWYgKCF4bWxTdHJFcXVhbChhdHRyVmFsdWUsIEJBRF9DQVNUICJ1bnF1YWxpZmllZCIpKSB7CgkJICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkJCU5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLAoJCQlOVUxMLCAiKHF1YWxpZmllZCB8IHVucXVhbGlmaWVkKSIsCgkJCWF0dHJWYWx1ZSwgTlVMTCwgTlVMTCwgTlVMTCk7CgkJfQoJICAgIH0gZWxzZSBpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1FVQUxJRl9FTEVNKQoJCW5zID0gY3R4dC0+dGFyZ2V0TmFtZXNwYWNlOwoJfQoJZGVjbCA9IHhtbFNjaGVtYUFkZEVsZW1lbnQoY3R4dCwgbmFtZSwgbnMsIG5vZGUsIHRvcExldmVsKTsKCWlmIChkZWNsID09IE5VTEwpIHsKCSAgICBnb3RvIHJldHVybl9udWxsOwoJfQoJLyoKCSogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KCSovCglhdHRyID0gbm9kZS0+cHJvcGVydGllczsKCXdoaWxlIChhdHRyICE9IE5VTEwpIHsKCSAgICBpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJCWlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuYW1lIikpICYmCgkJICAgICgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgInR5cGUiKSkgJiYKCQkgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiZGVmYXVsdCIpKSAmJgoJCSAgICAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJmaXhlZCIpKSAmJgoJCSAgICAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJibG9jayIpKSAmJgoJCSAgICAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuaWxsYWJsZSIpKSkKCQl7CgkJICAgIGlmICh0b3BMZXZlbCA9PSAwKSB7CgkJCWlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtYXhPY2N1cnMiKSkgJiYKCQkJICAgICgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgIm1pbk9jY3VycyIpKSAmJgoJCQkgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiZm9ybSIpKSkKCQkJewoJCQkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkJCX0KCQkgICAgfSBlbHNlIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJmaW5hbCIpKSAmJgoJCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJhYnN0cmFjdCIpKSAmJgoJCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJzdWJzdGl0dXRpb25Hcm91cCIpKSkgewoKCQkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkJICAgIH0KCQl9CgkgICAgfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSB7CgoJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJICAgIGF0dHIgPSBhdHRyLT5uZXh0OwoJfQoJLyoKCSogRXh0cmFjdC92YWxpZGF0ZSBhdHRyaWJ1dGVzLgoJKi8KCWlmICh0b3BMZXZlbCkgewoJICAgIC8qCgkgICAgKiBQcm9jZXNzIHRvcCBhdHRyaWJ1dGVzIG9mIGdsb2JhbCBlbGVtZW50IGRlY2xhcmF0aW9ucyBoZXJlLgoJICAgICovCgkgICAgZGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9HTE9CQUw7CgkgICAgZGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9UT1BMRVZFTDsKCSAgICB4bWxTY2hlbWFQVmFsQXR0clFOYW1lKGN0eHQsIHNjaGVtYSwKCQlOVUxMLCBub2RlLCAic3Vic3RpdHV0aW9uR3JvdXAiLAoJCSYoZGVjbC0+c3Vic3RHcm91cE5zKSwgJihkZWNsLT5zdWJzdEdyb3VwKSk7CgkgICAgaWYgKHhtbEdldEJvb2xlYW5Qcm9wKGN0eHQsIG5vZGUsICJhYnN0cmFjdCIsIDApKQoJCWRlY2wtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0VMRU1fQUJTVFJBQ1Q7CgkgICAgLyoKCSAgICAqIEF0dHJpYnV0ZSAiZmluYWwiLgoJICAgICovCgkgICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJmaW5hbCIpOwoJICAgIGlmIChhdHRyID09IE5VTEwpIHsKCQlpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0ZJTkFMX0RFRkFVTFRfRVhURU5TSU9OKQoJCSAgICBkZWNsLT5mbGFncyB8PSBYTUxfU0NIRU1BU19FTEVNX0ZJTkFMX0VYVEVOU0lPTjsKCQlpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0ZJTkFMX0RFRkFVTFRfUkVTVFJJQ1RJT04pCgkJICAgIGRlY2wtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0VMRU1fRklOQUxfUkVTVFJJQ1RJT047CgkgICAgfSBlbHNlIHsKCQlhdHRyVmFsdWUgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChjdHh0LCAoeG1sTm9kZVB0cikgYXR0cik7CgkJaWYgKHhtbFNjaGVtYVBWYWxBdHRyQmxvY2tGaW5hbChhdHRyVmFsdWUsICYoZGVjbC0+ZmxhZ3MpLAoJCSAgICAtMSwKCQkgICAgWE1MX1NDSEVNQVNfRUxFTV9GSU5BTF9FWFRFTlNJT04sCgkJICAgIFhNTF9TQ0hFTUFTX0VMRU1fRklOQUxfUkVTVFJJQ1RJT04sIC0xLCAtMSwgLTEpICE9IDApIHsKCQkgICAgeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIoY3R4dCwKCQkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCQkJTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsCgkJCU5VTEwsICIoI2FsbCB8IExpc3Qgb2YgKGV4dGVuc2lvbiB8IHJlc3RyaWN0aW9uKSkiLAoJCQlhdHRyVmFsdWUsIE5VTEwsIE5VTEwsIE5VTEwpOwoJCX0KCSAgICB9Cgl9CgkvKgoJKiBBdHRyaWJ1dGUgImJsb2NrIi4KCSovCglhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgImJsb2NrIik7CglpZiAoYXR0ciA9PSBOVUxMKSB7CgkgICAgLyoKCSAgICAqIEFwcGx5IGRlZmF1bHQgImJsb2NrIiB2YWx1ZXMuCgkgICAgKi8KCSAgICBpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfUkVTVFJJQ1RJT04pCgkJZGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9CTE9DS19SRVNUUklDVElPTjsKCSAgICBpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfRVhURU5TSU9OKQoJCWRlY2wtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfRVhURU5TSU9OOwoJICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfQkxPQ0tfREVGQVVMVF9TVUJTVElUVVRJT04pCgkJZGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9CTE9DS19TVUJTVElUVVRJT047Cgl9IGVsc2UgewoJICAgIGF0dHJWYWx1ZSA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKCSAgICBpZiAoeG1sU2NoZW1hUFZhbEF0dHJCbG9ja0ZpbmFsKGF0dHJWYWx1ZSwgJihkZWNsLT5mbGFncyksCgkJLTEsCgkJWE1MX1NDSEVNQVNfRUxFTV9CTE9DS19FWFRFTlNJT04sCgkJWE1MX1NDSEVNQVNfRUxFTV9CTE9DS19SRVNUUklDVElPTiwKCQlYTUxfU0NIRU1BU19FTEVNX0JMT0NLX1NVQlNUSVRVVElPTiwgLTEsIC0xKSAhPSAwKSB7CgkJeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCQkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsCgkJICAgIE5VTEwsICIoI2FsbCB8IExpc3Qgb2YgKGV4dGVuc2lvbiB8ICIKCQkgICAgInJlc3RyaWN0aW9uIHwgc3Vic3RpdHV0aW9uKSkiLCBhdHRyVmFsdWUsCgkJICAgIE5VTEwsIE5VTEwsIE5VTEwpOwoJICAgIH0KCX0KCWlmICh4bWxHZXRCb29sZWFuUHJvcChjdHh0LCBub2RlLCAibmlsbGFibGUiLCAwKSkKCSAgICBkZWNsLT5mbGFncyB8PSBYTUxfU0NIRU1BU19FTEVNX05JTExBQkxFOwoKCWF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAidHlwZSIpOwoJaWYgKGF0dHIgIT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBWYWxBdHRyTm9kZVFOYW1lKGN0eHQsIHNjaGVtYSwKCQlOVUxMLCBhdHRyLAoJCSYoZGVjbC0+bmFtZWRUeXBlTnMpLCAmKGRlY2wtPm5hbWVkVHlwZSkpOwoJICAgIHhtbFNjaGVtYUNoZWNrUmVmZXJlbmNlKGN0eHQsIHNjaGVtYSwgbm9kZSwKCQlhdHRyLCBkZWNsLT5uYW1lZFR5cGVOcyk7Cgl9CglkZWNsLT52YWx1ZSA9IHhtbFNjaGVtYUdldFByb3AoY3R4dCwgbm9kZSwgImRlZmF1bHQiKTsKCWF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAiZml4ZWQiKTsKCWlmIChhdHRyICE9IE5VTEwpIHsKCSAgICBmaXhlZCA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKCSAgICBpZiAoZGVjbC0+dmFsdWUgIT0gTlVMTCkgewoJCS8qCgkJKiAzLjMuMyA6IDEKCQkqIGRlZmF1bHQgYW5kIGZpeGVkIG11c3Qgbm90IGJvdGggYmUgcHJlc2VudC4KCQkqLwoJCXhtbFNjaGVtYVBNdXR1YWxFeGNsQXR0ckVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TUkNfRUxFTUVOVF8xLAoJCSAgICBOVUxMLCBhdHRyLCAiZGVmYXVsdCIsICJmaXhlZCIpOwoJICAgIH0gZWxzZSB7CgkJZGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9GSVhFRDsKCQlkZWNsLT52YWx1ZSA9IGZpeGVkOwoJICAgIH0KCX0KCS8qCgkqIEFuZCBub3cgZm9yIHRoZSBjaGlsZHJlbi4uLgoJKi8KCWlmIChJU19TQ0hFTUEoY2hpbGQsICJjb21wbGV4VHlwZSIpKSB7CgkgICAgLyoKCSAgICAqIDMuMy4zIDogMwoJICAgICogInR5cGUiIGFuZCBlaXRoZXIgPHNpbXBsZVR5cGU+IG9yIDxjb21wbGV4VHlwZT4gYXJlIG11dHVhbGx5CgkgICAgKiBleGNsdXNpdmUKCSAgICAqLwoJICAgIGlmIChkZWNsLT5uYW1lZFR5cGUgIT0gTlVMTCkgewoJCXhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1NSQ19FTEVNRU5UXzMsCgkJICAgIE5VTEwsIG5vZGUsIGNoaWxkLAoJCSAgICAiVGhlIGF0dHJpYnV0ZSAndHlwZScgYW5kIHRoZSA8Y29tcGxleFR5cGU+IGNoaWxkIGFyZSAiCgkJICAgICJtdXR1YWxseSBleGNsdXNpdmUiLCBOVUxMKTsKCSAgICB9IGVsc2UKCQlXWFNfRUxFTV9UWVBFREVGKGRlY2wpID0geG1sU2NoZW1hUGFyc2VDb21wbGV4VHlwZShjdHh0LCBzY2hlbWEsIGNoaWxkLCAwKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCSAgICAvKgoJICAgICogMy4zLjMgOiAzCgkgICAgKiAidHlwZSIgYW5kIGVpdGhlciA8c2ltcGxlVHlwZT4gb3IgPGNvbXBsZXhUeXBlPiBhcmUKCSAgICAqIG11dHVhbGx5IGV4Y2x1c2l2ZQoJICAgICovCgkgICAgaWYgKGRlY2wtPm5hbWVkVHlwZSAhPSBOVUxMKSB7CgkJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfU1JDX0VMRU1FTlRfMywKCQkgICAgTlVMTCwgbm9kZSwgY2hpbGQsCgkJICAgICJUaGUgYXR0cmlidXRlICd0eXBlJyBhbmQgdGhlIDxzaW1wbGVUeXBlPiBjaGlsZCBhcmUgIgoJCSAgICAibXV0dWFsbHkgZXhjbHVzaXZlIiwgTlVMTCk7CgkgICAgfSBlbHNlCgkJV1hTX0VMRU1fVFlQRURFRihkZWNsKSA9IHhtbFNjaGVtYVBhcnNlU2ltcGxlVHlwZShjdHh0LCBzY2hlbWEsIGNoaWxkLCAwKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQoJd2hpbGUgKChJU19TQ0hFTUEoY2hpbGQsICJ1bmlxdWUiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAia2V5IikpIHx8IChJU19TQ0hFTUEoY2hpbGQsICJrZXlyZWYiKSkpIHsKCSAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAidW5pcXVlIikpIHsKCQljdXJJREMgPSB4bWxTY2hlbWFQYXJzZUlEQyhjdHh0LCBzY2hlbWEsIGNoaWxkLAoJCSAgICBYTUxfU0NIRU1BX1RZUEVfSURDX1VOSVFVRSwgZGVjbC0+dGFyZ2V0TmFtZXNwYWNlKTsKCSAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgImtleSIpKSB7CgkJY3VySURDID0geG1sU2NoZW1hUGFyc2VJREMoY3R4dCwgc2NoZW1hLCBjaGlsZCwKCQkgICAgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVksIGRlY2wtPnRhcmdldE5hbWVzcGFjZSk7CgkgICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJrZXlyZWYiKSkgewoJCWN1cklEQyA9IHhtbFNjaGVtYVBhcnNlSURDKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkJICAgIFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGLCBkZWNsLT50YXJnZXROYW1lc3BhY2UpOwoJICAgIH0KCSAgICBpZiAobGFzdElEQyAhPSBOVUxMKQoJCWxhc3RJREMtPm5leHQgPSBjdXJJREM7CgkgICAgZWxzZQoJCWRlY2wtPmlkY3MgPSAodm9pZCAqKSBjdXJJREM7CgkgICAgbGFzdElEQyA9IGN1cklEQzsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQoJaWYgKGNoaWxkICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJCU5VTEwsIG5vZGUsIGNoaWxkLAoJCU5VTEwsICIoYW5ub3RhdGlvbj8sICgoc2ltcGxlVHlwZSB8IGNvbXBsZXhUeXBlKT8sICIKCQkiKHVuaXF1ZSB8IGtleSB8IGtleXJlZikqKSkiKTsKCX0KCWRlY2wtPmFubm90ID0gYW5ub3Q7CiAgICB9CiAgICAvKgogICAgKiBOT1RFOiBFbGVtZW50IERlY2xhcmF0aW9uIFJlcHJlc2VudGF0aW9uIE9LIDQuIHdpbGwgYmUgY2hlY2tlZCBhdCBhCiAgICAqIGRpZmZlcmVudCBsYXllci4KICAgICovCiAgICBGUkVFX0FORF9OVUxMKGRlcykKICAgIGlmICh0b3BMZXZlbCkKCXJldHVybiAoKHhtbFNjaGVtYUJhc2ljSXRlbVB0cikgZGVjbCk7CiAgICBlbHNlIHsKCXBhcnRpY2xlLT5jaGlsZHJlbiA9ICh4bWxTY2hlbWFUcmVlSXRlbVB0cikgZGVjbDsKCXJldHVybiAoKHhtbFNjaGVtYUJhc2ljSXRlbVB0cikgcGFydGljbGUpOwogICAgfQoKcmV0dXJuX251bGw6CiAgICBGUkVFX0FORF9OVUxMKGRlcyk7CiAgICBpZiAoYW5ub3QgIT0gTlVMTCkgewoJaWYgKHBhcnRpY2xlICE9IE5VTEwpCgkgICAgcGFydGljbGUtPmFubm90ID0gTlVMTDsKCWlmIChkZWNsICE9IE5VTEwpCgkgICAgZGVjbC0+YW5ub3QgPSBOVUxMOwoJeG1sU2NoZW1hRnJlZUFubm90KGFubm90KTsKICAgIH0KICAgIHJldHVybiAoTlVMTCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZVVuaW9uOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqCiAqIHBhcnNlIGEgWE1MIHNjaGVtYSBVbmlvbiBkZWZpbml0aW9uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyAtMSBpbiBjYXNlIG9mIGludGVybmFsIGVycm9yLCAwIGluIGNhc2Ugb2Ygc3VjY2VzcyBhbmQgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIG90aGVyd2lzZS4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUGFyc2VVbmlvbih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgeG1sTm9kZVB0ciBub2RlKQp7CiAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGU7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGNvbnN0IHhtbENoYXIgKmN1ciA9IE5VTEw7CgogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkgfHwgKG5vZGUgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuICgtMSk7CiAgICAvKiBOb3QgYSBjb21wb25lbnQsIGRvbid0IGNyZWF0ZSBpdC4gKi8KICAgIHR5cGUgPSBjdHh0LT5jdHh0VHlwZTsKICAgIC8qCiAgICAqIE1hcmsgdGhlIHNpbXBsZSB0eXBlIGFzIGJlaW5nIG9mIHZhcmlldHkgInVuaW9uIi4KICAgICovCiAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX1ZBUklFVFlfVU5JT047CiAgICAvKgogICAgKiBTUEVDIChCYXNlIHR5cGUpICgyKSAiSWYgdGhlIDxsaXN0PiBvciA8dW5pb24+IGFsdGVybmF0aXZlIGlzIGNob3NlbiwKICAgICogdGhlbiB0aGUgt3NpbXBsZSB1ci10eXBlIGRlZmluaXRpb263LiIKICAgICovCiAgICB0eXBlLT5iYXNlVHlwZSA9IHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVNJTVBMRVRZUEUpOwogICAgLyoKICAgICogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KICAgICovCiAgICBhdHRyID0gbm9kZS0+cHJvcGVydGllczsKICAgIHdoaWxlIChhdHRyICE9IE5VTEwpIHsKCWlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkgICAgaWYgKCgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImlkIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibWVtYmVyVHlwZXMiKSkpIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIC8qCiAgICAqIEF0dHJpYnV0ZSAibWVtYmVyVHlwZXMiLiBUaGlzIGlzIGEgbGlzdCBvZiBRTmFtZXMuCiAgICAqIFRPRE86IENoZWNrIHRoZSB2YWx1ZSB0byBjb250YWluIGFueXRoaW5nLgogICAgKi8KICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibWVtYmVyVHlwZXMiKTsKICAgIGlmIChhdHRyICE9IE5VTEwpIHsKCWNvbnN0IHhtbENoYXIgKmVuZDsKCXhtbENoYXIgKnRtcDsKCWNvbnN0IHhtbENoYXIgKmxvY2FsTmFtZSwgKm5zTmFtZTsKCXhtbFNjaGVtYVR5cGVMaW5rUHRyIGxpbmssIGxhc3RMaW5rID0gTlVMTDsKCXhtbFNjaGVtYVFOYW1lUmVmUHRyIHJlZjsKCgljdXIgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChjdHh0LCAoeG1sTm9kZVB0cikgYXR0cik7Cgl0eXBlLT5iYXNlID0gY3VyOwoJZG8gewoJICAgIHdoaWxlIChJU19CTEFOS19DSCgqY3VyKSkKCQljdXIrKzsKCSAgICBlbmQgPSBjdXI7CgkgICAgd2hpbGUgKCgqZW5kICE9IDApICYmICghKElTX0JMQU5LX0NIKCplbmQpKSkpCgkJZW5kKys7CgkgICAgaWYgKGVuZCA9PSBjdXIpCgkJYnJlYWs7CgkgICAgdG1wID0geG1sU3RybmR1cChjdXIsIGVuZCAtIGN1cik7CgkgICAgaWYgKHhtbFNjaGVtYVBWYWxBdHRyTm9kZVFOYW1lVmFsdWUoY3R4dCwgc2NoZW1hLAoJCU5VTEwsIGF0dHIsIEJBRF9DQVNUIHRtcCwgJm5zTmFtZSwgJmxvY2FsTmFtZSkgPT0gMCkgewoJCS8qCgkJKiBDcmVhdGUgdGhlIG1lbWJlciB0eXBlIGxpbmsuCgkJKi8KCQlsaW5rID0gKHhtbFNjaGVtYVR5cGVMaW5rUHRyKQoJCSAgICB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYVR5cGVMaW5rKSk7CgkJaWYgKGxpbmsgPT0gTlVMTCkgewoJCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJ4bWxTY2hlbWFQYXJzZVVuaW9uLCAiCgkJCSJhbGxvY2F0aW5nIGEgdHlwZSBsaW5rIiwgTlVMTCk7CgkJICAgIHJldHVybiAoLTEpOwoJCX0KCQlsaW5rLT50eXBlID0gTlVMTDsKCQlsaW5rLT5uZXh0ID0gTlVMTDsKCQlpZiAobGFzdExpbmsgPT0gTlVMTCkKCQkgICAgdHlwZS0+bWVtYmVyVHlwZXMgPSBsaW5rOwoJCWVsc2UKCQkgICAgbGFzdExpbmstPm5leHQgPSBsaW5rOwoJCWxhc3RMaW5rID0gbGluazsKCQkvKgoJCSogQ3JlYXRlIGEgcmVmZXJlbmNlIGl0ZW0uCgkJKi8KCQlyZWYgPSB4bWxTY2hlbWFOZXdRTmFtZVJlZihjdHh0LCBYTUxfU0NIRU1BX1RZUEVfU0lNUExFLAoJCSAgICBsb2NhbE5hbWUsIG5zTmFtZSk7CgkJaWYgKHJlZiA9PSBOVUxMKSB7CgkJICAgIEZSRUVfQU5EX05VTEwodG1wKQoJCSAgICByZXR1cm4gKC0xKTsKCQl9CgkJLyoKCQkqIEFzc2lnbiB0aGUgcmVmZXJlbmNlIHRvIHRoZSBsaW5rLCBpdCB3aWxsIGJlIHJlc29sdmVkCgkJKiBsYXRlciBkdXJpbmcgZml4dXAgb2YgdGhlIHVuaW9uIHNpbXBsZSB0eXBlLgoJCSovCgkJbGluay0+dHlwZSA9ICh4bWxTY2hlbWFUeXBlUHRyKSByZWY7CgkgICAgfQoJICAgIEZSRUVfQU5EX05VTEwodG1wKQoJICAgIGN1ciA9IGVuZDsKCX0gd2hpbGUgKCpjdXIgIT0gMCk7CgogICAgfQogICAgLyoKICAgICogQW5kIG5vdyBmb3IgdGhlIGNoaWxkcmVuLi4uCiAgICAqLwogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCS8qCgkqIEFkZCB0aGUgYW5ub3RhdGlvbiB0byB0aGUgc2ltcGxlIHR5cGUgYW5jZXN0b3IuCgkqLwoJeG1sU2NoZW1hQWRkQW5ub3RhdGlvbigoeG1sU2NoZW1hQW5ub3RJdGVtUHRyKSB0eXBlLAoJICAgIHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCXhtbFNjaGVtYVR5cGVQdHIgc3VidHlwZSwgbGFzdCA9IE5VTEw7CgoJLyoKCSogQW5jaG9yIHRoZSBtZW1iZXIgdHlwZXMgaW4gdGhlICJzdWJ0eXBlcyIgZmllbGQgb2YgdGhlCgkqIHNpbXBsZSB0eXBlLgoJKi8KCXdoaWxlIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCSAgICBzdWJ0eXBlID0gKHhtbFNjaGVtYVR5cGVQdHIpCgkJeG1sU2NoZW1hUGFyc2VTaW1wbGVUeXBlKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDApOwoJICAgIGlmIChzdWJ0eXBlICE9IE5VTEwpIHsKCQlpZiAobGFzdCA9PSBOVUxMKSB7CgkJICAgIHR5cGUtPnN1YnR5cGVzID0gc3VidHlwZTsKCQkgICAgbGFzdCA9IHN1YnR5cGU7CgkJfSBlbHNlIHsKCQkgICAgbGFzdC0+bmV4dCA9IHN1YnR5cGU7CgkJICAgIGxhc3QgPSBzdWJ0eXBlOwoJCX0KCQlsYXN0LT5uZXh0ID0gTlVMTDsKCSAgICB9CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0KICAgIH0KICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJICAgIE5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLCAiKGFubm90YXRpb24/LCBzaW1wbGVUeXBlKikiKTsKICAgIH0KICAgIGlmICgoYXR0ciA9PSBOVUxMKSAmJiAodHlwZS0+c3VidHlwZXMgPT0gTlVMTCkpIHsKCSAvKgoJKiBzcmMtdW5pb24tbWVtYmVyVHlwZXMtb3Itc2ltcGxlVHlwZXMKCSogRWl0aGVyIHRoZSBtZW1iZXJUeXBlcyBbYXR0cmlidXRlXSBvZiB0aGUgPHVuaW9uPiBlbGVtZW50IG11c3QKCSogYmUgbm9uLWVtcHR5IG9yIHRoZXJlIG11c3QgYmUgYXQgbGVhc3Qgb25lIHNpbXBsZVR5cGUgW2NoaWxkXS4KCSovCgl4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfU1JDX1VOSU9OX01FTUJFUlRZUEVTX09SX1NJTVBMRVRZUEVTLAoJICAgIE5VTEwsIG5vZGUsCgkgICAgIkVpdGhlciB0aGUgYXR0cmlidXRlICdtZW1iZXJUeXBlcycgb3IgIgoJICAgICJhdCBsZWFzdCBvbmUgPHNpbXBsZVR5cGU+IGNoaWxkIG11c3QgYmUgcHJlc2VudCIsIE5VTEwpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlTGlzdDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgTGlzdCBkZWZpbml0aW9uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyAtMSBpbiBjYXNlIG9mIGVycm9yLCAwIGlmIHRoZSBkZWNsYXJhdGlvbiBpcyBpbXByb3BlciBhbmQKICogICAgICAgICAxIGluIGNhc2Ugb2Ygc3VjY2Vzcy4KICovCnN0YXRpYyB4bWxTY2hlbWFUeXBlUHRyCnhtbFNjaGVtYVBhcnNlTGlzdCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICAvKiBOb3QgYSBjb21wb25lbnQsIGRvbid0IGNyZWF0ZSBpdC4gKi8KICAgIHR5cGUgPSBjdHh0LT5jdHh0VHlwZTsKICAgIC8qCiAgICAqIE1hcmsgdGhlIHR5cGUgYXMgYmVpbmcgb2YgdmFyaWV0eSAibGlzdCIuCiAgICAqLwogICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9WQVJJRVRZX0xJU1Q7CiAgICAvKgogICAgKiBTUEVDIChCYXNlIHR5cGUpICgyKSAiSWYgdGhlIDxsaXN0PiBvciA8dW5pb24+IGFsdGVybmF0aXZlIGlzIGNob3NlbiwKICAgICogdGhlbiB0aGUgt3NpbXBsZSB1ci10eXBlIGRlZmluaXRpb263LiIKICAgICovCiAgICB0eXBlLT5iYXNlVHlwZSA9IHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVNJTVBMRVRZUEUpOwogICAgLyoKICAgICogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KICAgICovCiAgICBhdHRyID0gbm9kZS0+cHJvcGVydGllczsKICAgIHdoaWxlIChhdHRyICE9IE5VTEwpIHsKCWlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkgICAgaWYgKCgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImlkIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaXRlbVR5cGUiKSkpIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQoKICAgIHhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CgogICAgLyoKICAgICogQXR0cmlidXRlICJpdGVtVHlwZSIuIE5PVEUgdGhhdCB3ZSB3aWxsIHVzZSB0aGUgInJlZiIgYW5kICJyZWZOcyIKICAgICogZmllbGRzIGZvciBob2xkaW5nIHRoZSByZWZlcmVuY2UgdG8gdGhlIGl0ZW1UeXBlLgogICAgKgogICAgKiBSRVZBTVAgVE9ETzogVXNlIHRoZSAiYmFzZSIgYW5kICJiYXNlTnMiIGZpZWxkcywgc2luY2Ugd2Ugd2lsbCByZW1vdmUKICAgICogdGhlICJyZWYiIGZpZWxkcy4KICAgICovCiAgICB4bWxTY2hlbWFQVmFsQXR0clFOYW1lKGN0eHQsIHNjaGVtYSwgTlVMTCwKCW5vZGUsICJpdGVtVHlwZSIsICYodHlwZS0+YmFzZU5zKSwgJih0eXBlLT5iYXNlKSk7CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewoJeG1sU2NoZW1hQWRkQW5ub3RhdGlvbigoeG1sU2NoZW1hQW5ub3RJdGVtUHRyKSB0eXBlLAoJICAgIHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCS8qCgkqIHNyYy1saXN0LWl0ZW1UeXBlLW9yLXNpbXBsZVR5cGUKCSogRWl0aGVyIHRoZSBpdGVtVHlwZSBbYXR0cmlidXRlXSBvciB0aGUgPHNpbXBsZVR5cGU+IFtjaGlsZF0gb2YKCSogdGhlIDxsaXN0PiBlbGVtZW50IG11c3QgYmUgcHJlc2VudCwgYnV0IG5vdCBib3RoLgoJKi8KCWlmICh0eXBlLT5iYXNlICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfU1JDX1NJTVBMRV9UWVBFXzEsCgkJTlVMTCwgbm9kZSwKCQkiVGhlIGF0dHJpYnV0ZSAnaXRlbVR5cGUnIGFuZCB0aGUgPHNpbXBsZVR5cGU+IGNoaWxkICIKCQkiYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIsIE5VTEwpOwoJfSBlbHNlIHsKCSAgICB0eXBlLT5zdWJ0eXBlcyA9IHhtbFNjaGVtYVBhcnNlU2ltcGxlVHlwZShjdHh0LCBzY2hlbWEsIGNoaWxkLCAwKTsKCX0KICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfSBlbHNlIGlmICh0eXBlLT5iYXNlID09IE5VTEwpIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TUkNfU0lNUExFX1RZUEVfMSwKCSAgICBOVUxMLCBub2RlLAoJICAgICJFaXRoZXIgdGhlIGF0dHJpYnV0ZSAnaXRlbVR5cGUnIG9yIHRoZSA8c2ltcGxlVHlwZT4gY2hpbGQgIgoJICAgICJtdXN0IGJlIHByZXNlbnQiLCBOVUxMKTsKICAgIH0KICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJICAgIE5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLCAiKGFubm90YXRpb24/LCBzaW1wbGVUeXBlPykiKTsKICAgIH0KICAgIGlmICgodHlwZS0+YmFzZSA9PSBOVUxMKSAmJgoJKHR5cGUtPnN1YnR5cGVzID09IE5VTEwpICYmCgkoeG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgIml0ZW1UeXBlIikgPT0gTlVMTCkpIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TUkNfU0lNUExFX1RZUEVfMSwKCSAgICBOVUxMLCBub2RlLAoJICAgICJFaXRoZXIgdGhlIGF0dHJpYnV0ZSAnaXRlbVR5cGUnIG9yIHRoZSA8c2ltcGxlVHlwZT4gY2hpbGQgIgoJICAgICJtdXN0IGJlIHByZXNlbnQiLCBOVUxMKTsKICAgIH0KICAgIHJldHVybiAoTlVMTCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZVNpbXBsZVR5cGU6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogcGFyc2UgYSBYTUwgc2NoZW1hIFNpbXBsZSBUeXBlIGRlZmluaXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIC0xIGluIGNhc2Ugb2YgZXJyb3IsIDAgaWYgdGhlIGRlY2xhcmF0aW9uIGlzIGltcHJvcGVyIGFuZAogKiAxIGluIGNhc2Ugb2Ygc3VjY2Vzcy4KICovCnN0YXRpYyB4bWxTY2hlbWFUeXBlUHRyCnhtbFNjaGVtYVBhcnNlU2ltcGxlVHlwZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUsIGludCB0b3BMZXZlbCkKewogICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLCBvbGRDdHh0VHlwZTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgY29uc3QgeG1sQ2hhciAqYXR0clZhbHVlID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGludCBoYXNSZXN0cmljdGlvbiA9IDA7CgogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkgfHwgKG5vZGUgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKCiAgICBpZiAodG9wTGV2ZWwpIHsKCWF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibmFtZSIpOwoJaWYgKGF0dHIgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBNaXNzaW5nQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX01JU1NJTkcsCgkJTlVMTCwgbm9kZSwKCQkibmFtZSIsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9IGVsc2UgewoJICAgIGlmICh4bWxTY2hlbWFQVmFsQXR0ck5vZGUoY3R4dCwKCQlOVUxMLCBhdHRyLAoJCXhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05DTkFNRSksICZhdHRyVmFsdWUpICE9IDApCgkJcmV0dXJuIChOVUxMKTsKCSAgICAvKgoJICAgICogU2tpcCBidWlsdC1pbiB0eXBlcy4KCSAgICAqLwoJICAgIGlmIChjdHh0LT5pc1M0UykgewoJCXhtbFNjaGVtYVR5cGVQdHIgYmlUeXBlOwoKCQlpZiAoY3R4dC0+aXNSZWRlZmluZSkgewoJCSAgICAvKgoJCSAgICAqIFJFREVGSU5FOiBEaXNhbGxvdyByZWRlZmluaXRpb24gb2YgYnVpbHQtaW4tdHlwZXMuCgkJICAgICogVE9ETzogSXQgc2VlbXMgdGhhdCB0aGUgc3BlYyBkb2VzIG5vdCBzYXkgYW55dGhpbmcKCQkgICAgKiBhYm91dCB0aGlzIGNhc2UuCgkJICAgICovCgkJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwgWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FLAoJCQlOVUxMLCBub2RlLAoJCQkiUmVkZWZpbml0aW9uIG9mIGJ1aWx0LWluIHNpbXBsZSB0eXBlcyBpcyBub3QgIgoJCQkic3VwcG9ydGVkIiwgTlVMTCk7CgkJICAgIHJldHVybihOVUxMKTsKCQl9CgkJYmlUeXBlID0geG1sU2NoZW1hR2V0UHJlZGVmaW5lZFR5cGUoYXR0clZhbHVlLCB4bWxTY2hlbWFOcyk7CgkJaWYgKGJpVHlwZSAhPSBOVUxMKQoJCSAgICByZXR1cm4gKGJpVHlwZSk7CgkgICAgfQoJfQogICAgfQogICAgLyoKICAgICogVGFyZ2V0TmFtZXNwYWNlOgogICAgKiBTUEVDICJUaGUgt2FjdHVhbCB2YWx1Zbcgb2YgdGhlIHRhcmdldE5hbWVzcGFjZSBbYXR0cmlidXRlXQogICAgKiBvZiB0aGUgPHNjaGVtYT4gYW5jZXN0b3IgZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtIGlmIHByZXNlbnQsCiAgICAqIG90aGVyd2lzZSC3YWJzZW50ty4KICAgICovCiAgICBpZiAodG9wTGV2ZWwgPT0gMCkgewojaWZkZWYgRU5BQkxFX05BTUVEX0xPQ0FMUwogICAgICAgIGNoYXIgYnVmWzQwXTsKI2VuZGlmCgkvKgoJKiBQYXJzZSBhcyBsb2NhbCBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLgoJKi8KI2lmZGVmIEVOQUJMRV9OQU1FRF9MT0NBTFMKICAgICAgICBzbnByaW50ZihidWYsIDM5LCAiI1NUJWQiLCBjdHh0LT5jb3VudGVyKysgKyAxKTsKCXR5cGUgPSB4bWxTY2hlbWFBZGRUeXBlKGN0eHQsIHNjaGVtYSwKCSAgICBYTUxfU0NIRU1BX1RZUEVfU0lNUExFLAoJICAgIHhtbERpY3RMb29rdXAoY3R4dC0+ZGljdCwgKGNvbnN0IHhtbENoYXIgKilidWYsIC0xKSwKCSAgICBjdHh0LT50YXJnZXROYW1lc3BhY2UsIG5vZGUsIDApOwojZWxzZQoJdHlwZSA9IHhtbFNjaGVtYUFkZFR5cGUoY3R4dCwgc2NoZW1hLAoJICAgIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUsCgkgICAgTlVMTCwgY3R4dC0+dGFyZ2V0TmFtZXNwYWNlLCBub2RlLCAwKTsKI2VuZGlmCglpZiAodHlwZSA9PSBOVUxMKQoJICAgIHJldHVybiAoTlVMTCk7Cgl0eXBlLT50eXBlID0gWE1MX1NDSEVNQV9UWVBFX1NJTVBMRTsKCXR5cGUtPmNvbnRlbnRUeXBlID0gWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRTsKCS8qCgkqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCgkqLwoJYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7Cgl3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CgkgICAgaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCQlpZiAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSB7CgkJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7IAoJCX0KCSAgICB9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCQkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9CgkgICAgYXR0ciA9IGF0dHItPm5leHQ7Cgl9CiAgICB9IGVsc2UgewoJLyoKCSogUGFyc2UgYXMgZ2xvYmFsIHNpbXBsZSB0eXBlIGRlZmluaXRpb24uCgkqCgkqIE5vdGUgdGhhdCBhdHRyVmFsdWUgaXMgdGhlIHZhbHVlIG9mIHRoZSBhdHRyaWJ1dGUgIm5hbWUiIGhlcmUuCgkqLwoJdHlwZSA9IHhtbFNjaGVtYUFkZFR5cGUoY3R4dCwgc2NoZW1hLCBYTUxfU0NIRU1BX1RZUEVfU0lNUExFLAoJICAgIGF0dHJWYWx1ZSwgY3R4dC0+dGFyZ2V0TmFtZXNwYWNlLCBub2RlLCAxKTsKCWlmICh0eXBlID09IE5VTEwpCgkgICAgcmV0dXJuIChOVUxMKTsKCXR5cGUtPnR5cGUgPSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOwoJdHlwZS0+Y29udGVudFR5cGUgPSBYTUxfU0NIRU1BX0NPTlRFTlRfU0lNUExFOwoJdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9HTE9CQUw7CgkvKgoJKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgoJKi8KCWF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwoJd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJICAgIGlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkJaWYgKCgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImlkIikpICYmCgkJICAgICgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgIm5hbWUiKSkgJiYKCQkgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiZmluYWwiKSkpIHsKCQkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCQl9CgkgICAgfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9CgkgICAgYXR0ciA9IGF0dHItPm5leHQ7Cgl9CgkvKgoJKiBBdHRyaWJ1dGUgImZpbmFsIi4KCSovCglhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgImZpbmFsIik7CglpZiAoYXR0ciA9PSBOVUxMKSB7CgkgICAgaWYgKHNjaGVtYS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX1JFU1RSSUNUSU9OKQoJCXR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfUkVTVFJJQ1RJT047CgkgICAgaWYgKHNjaGVtYS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX0xJU1QpCgkJdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9GSU5BTF9MSVNUOwoJICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfRklOQUxfREVGQVVMVF9VTklPTikKCQl0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX1VOSU9OOwoJfSBlbHNlIHsKCSAgICBhdHRyVmFsdWUgPSB4bWxTY2hlbWFHZXRQcm9wKGN0eHQsIG5vZGUsICJmaW5hbCIpOwoJICAgIGlmICh4bWxTY2hlbWFQVmFsQXR0ckJsb2NrRmluYWwoYXR0clZhbHVlLCAmKHR5cGUtPmZsYWdzKSwKCQktMSwgLTEsIFhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfUkVTVFJJQ1RJT04sIC0xLAoJCVhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfTElTVCwKCQlYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX1VOSU9OKSAhPSAwKSB7CgoJCXhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkJICAgIFdYU19CQVNJQ19DQVNUIHR5cGUsICh4bWxOb2RlUHRyKSBhdHRyLAoJCSAgICBOVUxMLCAiKCNhbGwgfCBMaXN0IG9mIChsaXN0IHwgdW5pb24gfCByZXN0cmljdGlvbikiLAoJCSAgICBhdHRyVmFsdWUsIE5VTEwsIE5VTEwsIE5VTEwpOwoJICAgIH0KCX0KICAgIH0KICAgIHR5cGUtPnRhcmdldE5hbWVzcGFjZSA9IGN0eHQtPnRhcmdldE5hbWVzcGFjZTsKICAgIHhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBvbGRDdHh0VHlwZSA9IGN0eHQtPmN0eHRUeXBlOwogICAgCiAgICBjdHh0LT5jdHh0VHlwZSA9IHR5cGU7CiAgICAKICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CiAgICAgICAgdHlwZS0+YW5ub3QgPSB4bWxTY2hlbWFQYXJzZUFubm90YXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChjaGlsZCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LCBYTUxfU0NIRU1BUF9TNFNfRUxFTV9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLAoJICAgICIoYW5ub3RhdGlvbj8sIChyZXN0cmljdGlvbiB8IGxpc3QgfCB1bmlvbikpIik7CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgInJlc3RyaWN0aW9uIikpIHsJCiAgICAgICAgeG1sU2NoZW1hUGFyc2VSZXN0cmljdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLAoJICAgIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUpOwkKCWhhc1Jlc3RyaWN0aW9uID0gMTsJCiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAibGlzdCIpKSB7CiAgICAgICAgeG1sU2NoZW1hUGFyc2VMaXN0KGN0eHQsIHNjaGVtYSwgY2hpbGQpOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgInVuaW9uIikpIHsKICAgICAgICB4bWxTY2hlbWFQYXJzZVVuaW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQpOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwgWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkgICAgTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkgICAgIihhbm5vdGF0aW9uPywgKHJlc3RyaWN0aW9uIHwgbGlzdCB8IHVuaW9uKSkiKTsKICAgIH0KICAgIC8qCiAgICAqIFJFREVGSU5FOiBTUEVDIHNyYy1yZWRlZmluZSAoNSkKICAgICogIldpdGhpbiB0aGUgW2NoaWxkcmVuXSwgZWFjaCA8c2ltcGxlVHlwZT4gbXVzdCBoYXZlIGEKICAgICogPHJlc3RyaWN0aW9uPiBhbW9uZyBpdHMgW2NoaWxkcmVuXSAuLi4gdGhlILdhY3R1YWwgdmFsdWW3IG9mIHdob3NlCiAgICAqIGJhc2UgW2F0dHJpYnV0ZV0gbXVzdCBiZSB0aGUgc2FtZSBhcyB0aGUgt2FjdHVhbCB2YWx1Zbcgb2YgaXRzIG93bgogICAgKiBuYW1lIGF0dHJpYnV0ZSBwbHVzIHRhcmdldCBuYW1lc3BhY2U7IgogICAgKi8KICAgIGlmICh0b3BMZXZlbCAmJiBjdHh0LT5pc1JlZGVmaW5lICYmICghIGhhc1Jlc3RyaWN0aW9uKSkgewoJeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LCBYTUxfU0NIRU1BUF9TUkNfUkVERUZJTkUsCgkgICAgTlVMTCwgbm9kZSwgIlRoaXMgaXMgYSByZWRlZmluaXRpb24sIHRodXMgdGhlICIKCSAgICAiPHNpbXBsZVR5cGU+IG11c3QgaGF2ZSBhIDxyZXN0cmljdGlvbj4gY2hpbGQiLCBOVUxMKTsKICAgIH0KICAgIAogICAgY3R4dC0+Y3R4dFR5cGUgPSBvbGRDdHh0VHlwZTsKICAgIHJldHVybiAodHlwZSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXBEZWZSZWY6CiAqIEBjdHh0OiAgdGhlIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWE6IHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICB0aGUgbm9kZQogKgogKiBQYXJzZXMgYSByZWZlcmVuY2UgdG8gYSBtb2RlbCBncm91cCBkZWZpbml0aW9uLgogKgogKiBXZSB3aWxsIHJldHVybiBhIHBhcnRpY2xlIGNvbXBvbmVudCB3aXRoIGEgcW5hbWUtY29tcG9uZW50IG9yCiAqIE5VTEwgaW4gY2FzZSBvZiBhbiBlcnJvci4KICovCnN0YXRpYyB4bWxTY2hlbWFUcmVlSXRlbVB0cgp4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXBEZWZSZWYoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgICAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJICAgICAgIHhtbE5vZGVQdHIgbm9kZSkKewogICAgeG1sU2NoZW1hUGFydGljbGVQdHIgaXRlbTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwogICAgY29uc3QgeG1sQ2hhciAqcmVmID0gTlVMTCwgKnJlZk5zID0gTlVMTDsKICAgIGludCBtaW4sIG1heDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAicmVmIik7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsICJyZWYiLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9IGVsc2UgaWYgKHhtbFNjaGVtYVBWYWxBdHRyTm9kZVFOYW1lKGN0eHQsIHNjaGVtYSwgTlVMTCwKCWF0dHIsICZyZWZOcywgJnJlZikgIT0gMCkgewoJcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIHhtbFNjaGVtYUNoZWNrUmVmZXJlbmNlKGN0eHQsIHNjaGVtYSwgbm9kZSwgYXR0ciwgcmVmTnMpOwogICAgbWluID0geG1sR2V0TWluT2NjdXJzKGN0eHQsIG5vZGUsIDAsIC0xLCAxLCAieHM6bm9uTmVnYXRpdmVJbnRlZ2VyIik7CiAgICBtYXggPSB4bWxHZXRNYXhPY2N1cnMoY3R4dCwgbm9kZSwgMCwgVU5CT1VOREVELCAxLAoJIih4czpub25OZWdhdGl2ZUludGVnZXIgfCB1bmJvdW5kZWQpIik7CiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAicmVmIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtaW5PY2N1cnMiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtYXhPY2N1cnMiKSkpIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIGl0ZW0gPSB4bWxTY2hlbWFBZGRQYXJ0aWNsZShjdHh0LCBzY2hlbWEsIG5vZGUsIG1pbiwgbWF4KTsKICAgIGlmIChpdGVtID09IE5VTEwpCglyZXR1cm4gKE5VTEwpOyAgICAKICAgIC8qCiAgICAqIENyZWF0ZSBhIHFuYW1lLXJlZmVyZW5jZSBhbmQgc2V0IGFzIHRoZSB0ZXJtOyBpdCB3aWxsIGJlIHN1YnN0aXR1dGVkCiAgICAqIGZvciB0aGUgbW9kZWwgZ3JvdXAgYWZ0ZXIgdGhlIHJlZmVyZW5jZSBoYXMgYmVlbiByZXNvbHZlZC4KICAgICovCiAgICBpdGVtLT5jaGlsZHJlbiA9ICh4bWxTY2hlbWFUcmVlSXRlbVB0cikKCXhtbFNjaGVtYU5ld1FOYW1lUmVmKGN0eHQsIFhNTF9TQ0hFTUFfVFlQRV9HUk9VUCwgcmVmLCByZWZOcyk7ICAgIAogICAgeG1sU2NoZW1hUENoZWNrUGFydGljbGVDb3JyZWN0XzIoY3R4dCwgaXRlbSwgbm9kZSwgbWluLCBtYXgpOwogICAgLyoKICAgICogQW5kIG5vdyBmb3IgdGhlIGNoaWxkcmVuLi4uCiAgICAqLwogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIC8qIFRPRE86IElzIGFubm90YXRpb24gZXZlbiBhbGxvd2VkIGZvciBhIG1vZGVsIGdyb3VwIHJlZmVyZW5jZT8gKi8KICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCS8qCgkqIFRPRE86IFdoYXQgdG8gZG8gZXhhY3RseSB3aXRoIHRoZSBhbm5vdGF0aW9uPwoJKi8KCWl0ZW0tPmFubm90ID0geG1sU2NoZW1hUGFyc2VBbm5vdGF0aW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpOwoJY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJICAgIE5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLAoJICAgICIoYW5ub3RhdGlvbj8pIik7CiAgICB9CiAgICAvKgogICAgKiBDb3JyZXNwb25kcyB0byBubyBjb21wb25lbnQgYXQgYWxsIGlmIG1pbk9jY3Vycz09bWF4T2NjdXJzPT0wLgogICAgKi8KICAgIGlmICgobWluID09IDApICYmIChtYXggPT0gMCkpCglyZXR1cm4gKE5VTEwpOwoKICAgIHJldHVybiAoKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSBpdGVtKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cERlZmluaXRpb246CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogUGFyc2VzIGEgWE1MIHNjaGVtYSBtb2RlbCBncm91cCBkZWZpbml0aW9uLgogKgogKiBOb3RlIHRoYXQgdGhlIGNvbnRyYWludCBzcmMtcmVkZWZpbmUgKDYuMikgY2FuJ3QgYmUgYXBwbGllZCB1bnRpbAogKiByZWZlcmVuY2VzIGhhdmUgYmVlbiByZXNvbHZlZC4gU28gd2Ugd2lsbCBkbyB0aGlzIGF0IHRoZQogKiBjb21wb25lbnQgZml4dXAgbGV2ZWwuCiAqICAgIAogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgLTEgaW4gY2FzZSBvZiBlcnJvciwgMCBpZiB0aGUgZGVjbGFyYXRpb24gaXMgaW1wcm9wZXIgYW5kCiAqICAgICAgICAgMSBpbiBjYXNlIG9mIHN1Y2Nlc3MuCiAqLwpzdGF0aWMgeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cgp4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXBEZWZpbml0aW9uKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJCSAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJCQkgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbFNjaGVtYU1vZGVsR3JvdXBEZWZQdHIgaXRlbTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwogICAgY29uc3QgeG1sQ2hhciAqbmFtZTsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAibmFtZSIpOwogICAgaWYgKGF0dHIgPT0gTlVMTCkgewoJeG1sU2NoZW1hUE1pc3NpbmdBdHRyRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTUlTU0lORywKCSAgICBOVUxMLCBub2RlLAoJICAgICJuYW1lIiwgTlVMTCk7CglyZXR1cm4gKE5VTEwpOwogICAgfSBlbHNlIGlmICh4bWxTY2hlbWFQVmFsQXR0ck5vZGUoY3R4dCwgTlVMTCwgYXR0ciwKCXhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05DTkFNRSksICZuYW1lKSAhPSAwKSB7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgaXRlbSA9IHhtbFNjaGVtYUFkZE1vZGVsR3JvdXBEZWZpbml0aW9uKGN0eHQsIHNjaGVtYSwgbmFtZSwKCWN0eHQtPnRhcmdldE5hbWVzcGFjZSwgbm9kZSk7CiAgICBpZiAoaXRlbSA9PSBOVUxMKQoJcmV0dXJuIChOVUxMKTsKICAgIC8qCiAgICAqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuYW1lIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkpIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIC8qCiAgICAqIEFuZCBub3cgZm9yIHRoZSBjaGlsZHJlbi4uLgogICAgKi8KICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CglpdGVtLT5hbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKCWNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYWxsIikpIHsKCWl0ZW0tPmNoaWxkcmVuID0geG1sU2NoZW1hUGFyc2VNb2RlbEdyb3VwKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkgICAgWE1MX1NDSEVNQV9UWVBFX0FMTCwgMCk7CgljaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJjaG9pY2UiKSkgewoJaXRlbS0+Y2hpbGRyZW4gPSB4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoY3R4dCwgc2NoZW1hLCBjaGlsZCwKCSAgICBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFLCAwKTsKCWNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgInNlcXVlbmNlIikpIHsKCWl0ZW0tPmNoaWxkcmVuID0geG1sU2NoZW1hUGFyc2VNb2RlbEdyb3VwKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkgICAgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFLCAwKTsKCWNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CgogICAKCiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/LCAoYWxsIHwgY2hvaWNlIHwgc2VxdWVuY2UpPykiKTsKICAgIH0KICAgIHJldHVybiAoaXRlbSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDbGVhbnVwRG9jOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAbm9kZTogIHRoZSByb290IG9mIHRoZSBkb2N1bWVudC4KICoKICogcmVtb3ZlcyB1bndhbnRlZCBub2RlcyBpbiBhIHNjaGVtYXMgZG9jdW1lbnQgdHJlZQogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hQ2xlYW51cERvYyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsIHhtbE5vZGVQdHIgcm9vdCkKewogICAgeG1sTm9kZVB0ciBkZWxldGUsIGN1cjsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHJvb3QgPT0gTlVMTCkpIHJldHVybjsKCiAgICAvKgogICAgICogUmVtb3ZlIGFsbCB0aGUgYmxhbmsgdGV4dCBub2RlcwogICAgICovCiAgICBkZWxldGUgPSBOVUxMOwogICAgY3VyID0gcm9vdDsKICAgIHdoaWxlIChjdXIgIT0gTlVMTCkgewogICAgICAgIGlmIChkZWxldGUgIT0gTlVMTCkgewogICAgICAgICAgICB4bWxVbmxpbmtOb2RlKGRlbGV0ZSk7CiAgICAgICAgICAgIHhtbEZyZWVOb2RlKGRlbGV0ZSk7CiAgICAgICAgICAgIGRlbGV0ZSA9IE5VTEw7CiAgICAgICAgfQogICAgICAgIGlmIChjdXItPnR5cGUgPT0gWE1MX1RFWFRfTk9ERSkgewogICAgICAgICAgICBpZiAoSVNfQkxBTktfTk9ERShjdXIpKSB7CiAgICAgICAgICAgICAgICBpZiAoeG1sTm9kZUdldFNwYWNlUHJlc2VydmUoY3VyKSAhPSAxKSB7CiAgICAgICAgICAgICAgICAgICAgZGVsZXRlID0gY3VyOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfSBlbHNlIGlmICgoY3VyLT50eXBlICE9IFhNTF9FTEVNRU5UX05PREUpICYmCiAgICAgICAgICAgICAgICAgICAoY3VyLT50eXBlICE9IFhNTF9DREFUQV9TRUNUSU9OX05PREUpKSB7CiAgICAgICAgICAgIGRlbGV0ZSA9IGN1cjsKICAgICAgICAgICAgZ290byBza2lwX2NoaWxkcmVuOwogICAgICAgIH0KCiAgICAgICAgLyoKICAgICAgICAgKiBTa2lwIHRvIG5leHQgbm9kZQogICAgICAgICAqLwogICAgICAgIGlmIChjdXItPmNoaWxkcmVuICE9IE5VTEwpIHsKICAgICAgICAgICAgaWYgKChjdXItPmNoaWxkcmVuLT50eXBlICE9IFhNTF9FTlRJVFlfREVDTCkgJiYKICAgICAgICAgICAgICAgIChjdXItPmNoaWxkcmVuLT50eXBlICE9IFhNTF9FTlRJVFlfUkVGX05PREUpICYmCiAgICAgICAgICAgICAgICAoY3VyLT5jaGlsZHJlbi0+dHlwZSAhPSBYTUxfRU5USVRZX05PREUpKSB7CiAgICAgICAgICAgICAgICBjdXIgPSBjdXItPmNoaWxkcmVuOwogICAgICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICAgIHNraXBfY2hpbGRyZW46CiAgICAgICAgaWYgKGN1ci0+bmV4dCAhPSBOVUxMKSB7CiAgICAgICAgICAgIGN1ciA9IGN1ci0+bmV4dDsKICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgfQoKICAgICAgICBkbyB7CiAgICAgICAgICAgIGN1ciA9IGN1ci0+cGFyZW50OwogICAgICAgICAgICBpZiAoY3VyID09IE5VTEwpCiAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgaWYgKGN1ciA9PSByb290KSB7CiAgICAgICAgICAgICAgICBjdXIgPSBOVUxMOwogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgaWYgKGN1ci0+bmV4dCAhPSBOVUxMKSB7CiAgICAgICAgICAgICAgICBjdXIgPSBjdXItPm5leHQ7CiAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgfQogICAgICAgIH0gd2hpbGUgKGN1ciAhPSBOVUxMKTsKICAgIH0KICAgIGlmIChkZWxldGUgIT0gTlVMTCkgewogICAgICAgIHhtbFVubGlua05vZGUoZGVsZXRlKTsKICAgICAgICB4bWxGcmVlTm9kZShkZWxldGUpOwogICAgICAgIGRlbGV0ZSA9IE5VTEw7CiAgICB9Cn0KCgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDbGVhclNjaGVtYURlZmF1bHRzKHhtbFNjaGVtYVB0ciBzY2hlbWEpCnsKICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfUVVBTElGX0VMRU0pCglzY2hlbWEtPmZsYWdzIF49IFhNTF9TQ0hFTUFTX1FVQUxJRl9FTEVNOwoKICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfUVVBTElGX0FUVFIpCglzY2hlbWEtPmZsYWdzIF49IFhNTF9TQ0hFTUFTX1FVQUxJRl9BVFRSOwoKICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfRklOQUxfREVGQVVMVF9FWFRFTlNJT04pCglzY2hlbWEtPmZsYWdzIF49IFhNTF9TQ0hFTUFTX0ZJTkFMX0RFRkFVTFRfRVhURU5TSU9OOwogICAgaWYgKHNjaGVtYS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX1JFU1RSSUNUSU9OKQoJc2NoZW1hLT5mbGFncyBePSBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX1JFU1RSSUNUSU9OOwogICAgaWYgKHNjaGVtYS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX0xJU1QpCglzY2hlbWEtPmZsYWdzIF49IFhNTF9TQ0hFTUFTX0ZJTkFMX0RFRkFVTFRfTElTVDsKICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfRklOQUxfREVGQVVMVF9VTklPTikKCXNjaGVtYS0+ZmxhZ3MgXj0gWE1MX1NDSEVNQVNfRklOQUxfREVGQVVMVF9VTklPTjsKCiAgICBpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfRVhURU5TSU9OKQoJc2NoZW1hLT5mbGFncyBePSBYTUxfU0NIRU1BU19CTE9DS19ERUZBVUxUX0VYVEVOU0lPTjsKICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfQkxPQ0tfREVGQVVMVF9SRVNUUklDVElPTikKCXNjaGVtYS0+ZmxhZ3MgXj0gWE1MX1NDSEVNQVNfQkxPQ0tfREVGQVVMVF9SRVNUUklDVElPTjsKICAgIGlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfQkxPQ0tfREVGQVVMVF9TVUJTVElUVVRJT04pCglzY2hlbWEtPmZsYWdzIF49IFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfU1VCU1RJVFVUSU9OOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlU2NoZW1hRWxlbWVudCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwKCQkJICAgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGNvbnN0IHhtbENoYXIgKnZhbDsKICAgIGludCByZXMgPSAwLCBvbGRFcnJzID0gY3R4dC0+bmJlcnJvcnM7CgogICAgLyoKICAgICogVGhvc2UgZmxhZ3Mgc2hvdWxkIGJlIG1vdmVkIHRvIHRoZSBwYXJzZXIgY29udGV4dCBmbGFncywKICAgICogc2luY2UgdGhleSBhcmUgbm90IHZpc2libGUgYXQgdGhlIGNvbXBvbmVudCBsZXZlbC4gSS5lLgogICAgKiB0aGV5IGFyZSB1c2VkIGlmIHByb2Nlc3Npbmcgc2NoZW1hICpkb2N1bWVudHMqIG9ubHkuCiAgICAqLwogICAgcmVzID0geG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIEhGQUlMVVJFOwoKICAgIC8qCiAgICAqIFNpbmNlIHRoZSB2ZXJzaW9uIGlzIG9mIHR5cGUgeHM6dG9rZW4sIHdlIHdvbid0IGJvdGhlciB0bwogICAgKiBjaGVjayBpdC4KICAgICovCiAgICAvKiBSRU1PVkVEOgogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJ2ZXJzaW9uIik7CiAgICBpZiAoYXR0ciAhPSBOVUxMKSB7CglyZXMgPSB4bWxTY2hlbWFQVmFsQXR0ck5vZGUoY3R4dCwgTlVMTCwgTlVMTCwgYXR0ciwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19UT0tFTiksICZ2YWwpOyAgICAKCUhGQUlMVVJFOwogICAgfQogICAgKi8KICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAidGFyZ2V0TmFtZXNwYWNlIik7CiAgICBpZiAoYXR0ciAhPSBOVUxMKSB7CglyZXMgPSB4bWxTY2hlbWFQVmFsQXR0ck5vZGUoY3R4dCwgTlVMTCwgYXR0ciwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19BTllVUkkpLCBOVUxMKTsKCUhGQUlMVVJFOwoJaWYgKHJlcyAhPSAwKSB7CgkgICAgY3R4dC0+c3RvcCA9IFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUU7CgkgICAgZ290byBleGl0OwoJfQogICAgfQogICAgYXR0ciA9IHhtbFNjaGVtYUdldFByb3BOb2RlKG5vZGUsICJlbGVtZW50Rm9ybURlZmF1bHQiKTsKICAgIGlmIChhdHRyICE9IE5VTEwpIHsKCXZhbCA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKCXJlcyA9IHhtbFNjaGVtYVBWYWxBdHRyRm9ybURlZmF1bHQodmFsLCAmc2NoZW1hLT5mbGFncywKCSAgICBYTUxfU0NIRU1BU19RVUFMSUZfRUxFTSk7CglIRkFJTFVSRTsKCWlmIChyZXMgIT0gMCkgewoJICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfRUxFTUZPUk1ERUZBVUxUX1ZBTFVFLAoJCU5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLCBOVUxMLAoJCSIocXVhbGlmaWVkIHwgdW5xdWFsaWZpZWQpIiwgdmFsLCBOVUxMLCBOVUxMLCBOVUxMKTsKCX0KICAgIH0KICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAiYXR0cmlidXRlRm9ybURlZmF1bHQiKTsKICAgIGlmIChhdHRyICE9IE5VTEwpIHsKCXZhbCA9IHhtbFNjaGVtYUdldE5vZGVDb250ZW50KGN0eHQsICh4bWxOb2RlUHRyKSBhdHRyKTsKCXJlcyA9IHhtbFNjaGVtYVBWYWxBdHRyRm9ybURlZmF1bHQodmFsLCAmc2NoZW1hLT5mbGFncywKCSAgICBYTUxfU0NIRU1BU19RVUFMSUZfQVRUUik7CglIRkFJTFVSRTsKCWlmIChyZXMgIT0gMCkgewoJICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfQVRUUkZPUk1ERUZBVUxUX1ZBTFVFLAoJCU5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLCBOVUxMLAoJCSIocXVhbGlmaWVkIHwgdW5xdWFsaWZpZWQpIiwgdmFsLCBOVUxMLCBOVUxMLCBOVUxMKTsKCX0KICAgIH0KICAgIGF0dHIgPSB4bWxTY2hlbWFHZXRQcm9wTm9kZShub2RlLCAiZmluYWxEZWZhdWx0Iik7CiAgICBpZiAoYXR0ciAhPSBOVUxMKSB7Cgl2YWwgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChjdHh0LCAoeG1sTm9kZVB0cikgYXR0cik7CglyZXMgPSB4bWxTY2hlbWFQVmFsQXR0ckJsb2NrRmluYWwodmFsLCAmKHNjaGVtYS0+ZmxhZ3MpLCAtMSwKCSAgICBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX0VYVEVOU0lPTiwKCSAgICBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX1JFU1RSSUNUSU9OLAoJICAgIC0xLAoJICAgIFhNTF9TQ0hFTUFTX0ZJTkFMX0RFRkFVTFRfTElTVCwKCSAgICBYTUxfU0NIRU1BU19GSU5BTF9ERUZBVUxUX1VOSU9OKTsKCUhGQUlMVVJFOwoJaWYgKHJlcyAhPSAwKSB7CgkgICAgeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9JTlZBTElEX1ZBTFVFLAoJCU5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLCBOVUxMLAoJCSIoI2FsbCB8IExpc3Qgb2YgKGV4dGVuc2lvbiB8IHJlc3RyaWN0aW9uIHwgbGlzdCB8IHVuaW9uKSkiLAoJCXZhbCwgTlVMTCwgTlVMTCwgTlVMTCk7Cgl9CiAgICB9CiAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgImJsb2NrRGVmYXVsdCIpOwogICAgaWYgKGF0dHIgIT0gTlVMTCkgewoJdmFsID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQoY3R4dCwgKHhtbE5vZGVQdHIpIGF0dHIpOwkKCXJlcyA9IHhtbFNjaGVtYVBWYWxBdHRyQmxvY2tGaW5hbCh2YWwsICYoc2NoZW1hLT5mbGFncyksIC0xLAoJICAgIFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfRVhURU5TSU9OLAoJICAgIFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfUkVTVFJJQ1RJT04sCgkgICAgWE1MX1NDSEVNQVNfQkxPQ0tfREVGQVVMVF9TVUJTVElUVVRJT04sIC0xLCAtMSk7CglIRkFJTFVSRTsKCWlmIChyZXMgIT0gMCkgewoJICAgIHhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCQlOVUxMLCAoeG1sTm9kZVB0cikgYXR0ciwgTlVMTCwKCQkiKCNhbGwgfCBMaXN0IG9mIChleHRlbnNpb24gfCByZXN0cmljdGlvbiB8IHN1YnN0aXR1dGlvbikpIiwKCQl2YWwsIE5VTEwsIE5VTEwsIE5VTEwpOwoJfQogICAgfQoKZXhpdDoKICAgIGlmIChvbGRFcnJzICE9IGN0eHQtPm5iZXJyb3JzKQoJcmVzID0gY3R4dC0+ZXJyOwogICAgcmV0dXJuKHJlcyk7CmV4aXRfZmFpbHVyZToKICAgIHJldHVybigtMSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZVNjaGVtYVRvcExldmVsOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYXMKICogQG5vZGVzOiAgdGhlIGxpc3Qgb2YgdG9wIGxldmVsIG5vZGVzCiAqCiAqIFJldHVybnMgdGhlIGludGVybmFsIFhNTCBTY2hlbWEgc3RydWN0dXJlIGJ1aWx0IGZyb20gdGhlIHJlc291cmNlIG9yCiAqICAgICAgICAgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlU2NoZW1hVG9wTGV2ZWwoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsIHhtbE5vZGVQdHIgbm9kZXMpCnsKICAgIHhtbE5vZGVQdHIgY2hpbGQ7CiAgICB4bWxTY2hlbWFBbm5vdFB0ciBhbm5vdDsKICAgIGludCByZXMgPSAwLCBvbGRFcnJzLCB0bXBPbGRFcnJzOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlcyA9PSBOVUxMKSkKICAgICAgICByZXR1cm4oLTEpOwoKICAgIG9sZEVycnMgPSBjdHh0LT5uYmVycm9yczsKICAgIGNoaWxkID0gbm9kZXM7CiAgICB3aGlsZSAoKElTX1NDSEVNQShjaGlsZCwgImluY2x1ZGUiKSkgfHwKCSAgIChJU19TQ0hFTUEoY2hpbGQsICJpbXBvcnQiKSkgfHwKCSAgIChJU19TQ0hFTUEoY2hpbGQsICJyZWRlZmluZSIpKSB8fAoJICAgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkpIHsKCWlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCSAgICBhbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKCSAgICBpZiAoc2NoZW1hLT5hbm5vdCA9PSBOVUxMKQoJCXNjaGVtYS0+YW5ub3QgPSBhbm5vdDsKCSAgICBlbHNlCgkJeG1sU2NoZW1hRnJlZUFubm90KGFubm90KTsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiaW1wb3J0IikpIHsKCSAgICB0bXBPbGRFcnJzID0gY3R4dC0+bmJlcnJvcnM7CgkgICAgcmVzID0geG1sU2NoZW1hUGFyc2VJbXBvcnQoY3R4dCwgc2NoZW1hLCBjaGlsZCk7CgkgICAgSEZBSUxVUkU7CgkgICAgSFNUT1AoY3R4dCk7CgkgICAgaWYgKHRtcE9sZEVycnMgIT0gY3R4dC0+bmJlcnJvcnMpCgkJZ290byBleGl0OwkgICAgCgl9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgImluY2x1ZGUiKSkgewoJICAgIHRtcE9sZEVycnMgPSBjdHh0LT5uYmVycm9yczsKCSAgICByZXMgPSB4bWxTY2hlbWFQYXJzZUluY2x1ZGUoY3R4dCwgc2NoZW1hLCBjaGlsZCk7CgkgICAgSEZBSUxVUkU7CgkgICAgSFNUT1AoY3R4dCk7CgkgICAgaWYgKHRtcE9sZEVycnMgIT0gY3R4dC0+bmJlcnJvcnMpCgkJZ290byBleGl0OwkgICAgCgl9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgInJlZGVmaW5lIikpIHsKCSAgICB0bXBPbGRFcnJzID0gY3R4dC0+bmJlcnJvcnM7CgkgICAgcmVzID0geG1sU2NoZW1hUGFyc2VSZWRlZmluZShjdHh0LCBzY2hlbWEsIGNoaWxkKTsKCSAgICBIRkFJTFVSRTsKCSAgICBIU1RPUChjdHh0KTsKCSAgICBpZiAodG1wT2xkRXJycyAhPSBjdHh0LT5uYmVycm9ycykKCQlnb3RvIGV4aXQ7Cgl9CgljaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgLyoKICAgICogVVJHRU5UIFRPRE86IENoYW5nZSB0aGUgZnVuY3Rpb25zIHRvIHJldHVybiBpbnQgcmVzdWx0cy4KICAgICogV2UgbmVlZCBlc3BlY2lhbGx5IHRvIGNhdGNoIGludGVybmFsIGVycm9ycy4KICAgICovCiAgICB3aGlsZSAoY2hpbGQgIT0gTlVMTCkgewoJaWYgKElTX1NDSEVNQShjaGlsZCwgImNvbXBsZXhUeXBlIikpIHsKCSAgICB4bWxTY2hlbWFQYXJzZUNvbXBsZXhUeXBlKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgInNpbXBsZVR5cGUiKSkgewoJICAgIHhtbFNjaGVtYVBhcnNlU2ltcGxlVHlwZShjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJlbGVtZW50IikpIHsKCSAgICB4bWxTY2hlbWFQYXJzZUVsZW1lbnQoY3R4dCwgc2NoZW1hLCBjaGlsZCwgTlVMTCwgMSk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYXR0cmlidXRlIikpIHsKCSAgICB4bWxTY2hlbWFQYXJzZUdsb2JhbEF0dHJpYnV0ZShjdHh0LCBzY2hlbWEsIGNoaWxkKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhdHRyaWJ1dGVHcm91cCIpKSB7CgkgICAgeG1sU2NoZW1hUGFyc2VBdHRyaWJ1dGVHcm91cERlZmluaXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiZ3JvdXAiKSkgewoJICAgIHhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cERlZmluaXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAibm90YXRpb24iKSkgewoJICAgIHhtbFNjaGVtYVBhcnNlTm90YXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSB7CgkgICAgeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQlOVUxMLCBjaGlsZC0+cGFyZW50LCBjaGlsZCwKCQlOVUxMLCAiKChpbmNsdWRlIHwgaW1wb3J0IHwgcmVkZWZpbmUgfCBhbm5vdGF0aW9uKSosICIKCQkiKCgoc2ltcGxlVHlwZSB8IGNvbXBsZXhUeXBlIHwgZ3JvdXAgfCBhdHRyaWJ1dGVHcm91cCkgIgoJCSJ8IGVsZW1lbnQgfCBhdHRyaWJ1dGUgfCBub3RhdGlvbiksIGFubm90YXRpb24qKSopIik7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0KCXdoaWxlIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCSAgICAvKgoJICAgICogVE9ETzogV2Ugc2hvdWxkIGFkZCBhbGwgYW5ub3RhdGlvbnMuCgkgICAgKi8KCSAgICBhbm5vdCA9IHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKTsKCSAgICBpZiAoc2NoZW1hLT5hbm5vdCA9PSBOVUxMKQoJCXNjaGVtYS0+YW5ub3QgPSBhbm5vdDsKCSAgICBlbHNlCgkJeG1sU2NoZW1hRnJlZUFubm90KGFubm90KTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQogICAgfQpleGl0OgogICAgY3R4dC0+Y3R4dFR5cGUgPSBOVUxMOwogICAgaWYgKG9sZEVycnMgIT0gY3R4dC0+bmJlcnJvcnMpCglyZXMgPSBjdHh0LT5lcnI7CiAgICByZXR1cm4ocmVzKTsKZXhpdF9mYWlsdXJlOgogICAgcmV0dXJuKC0xKTsKfQoKc3RhdGljIHhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uUHRyCnhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uQ3JlYXRlKHZvaWQpCnsKICAgIHhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uUHRyIHJldDsKCiAgICByZXQgPSAoeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25QdHIpCgl4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uKSk7CiAgICBpZiAocmV0ID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwgImFsbG9jYXRpbmcgc2NoZW1hIHJlbGF0aW9uIiwgTlVMTCk7CglyZXR1cm4oTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hU2NoZW1hUmVsYXRpb24pKTsKICAgIHJldHVybihyZXQpOwp9CgojaWYgMApzdGF0aWMgdm9pZAp4bWxTY2hlbWFTY2hlbWFSZWxhdGlvbkZyZWUoeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25QdHIgcmVsKQp7CiAgICB4bWxGcmVlKHJlbCk7Cn0KI2VuZGlmCgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFSZWRlZkxpc3RGcmVlKHhtbFNjaGVtYVJlZGVmUHRyIHJlZGVmKQp7CiAgICB4bWxTY2hlbWFSZWRlZlB0ciBwcmV2OwoKICAgIHdoaWxlIChyZWRlZiAhPSBOVUxMKSB7CglwcmV2ID0gcmVkZWY7CglyZWRlZiA9IHJlZGVmLT5uZXh0OwoJeG1sRnJlZShwcmV2KTsKICAgIH0KfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dEZyZWUoeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dFB0ciBjb24pCnsKICAgIC8qCiAgICAqIEFmdGVyIHRoZSBjb25zdHJ1Y3Rpb24gY29udGV4dCBoYXMgYmVlbiBmcmVlZCwgdGhlcmUgd2lsbCBiZQogICAgKiBubyBzY2hlbWEgZ3JhcGggYXZhaWxhYmxlIGFueSBtb3JlLiBPbmx5IHRoZSBzY2hlbWEgYnVja2V0cwogICAgKiB3aWxsIHN0YXkgYWxpdmUsIHdoaWNoIGFyZSBwdXQgaW50byB0aGUgInNjaGVtYXNJbXBvcnRzIiBhbmQKICAgICogImluY2x1ZGVzIiBzbG90cyBvZiB0aGUgeG1sU2NoZW1hLgogICAgKi8KICAgIGlmIChjb24tPmJ1Y2tldHMgIT0gTlVMTCkKCXhtbFNjaGVtYUl0ZW1MaXN0RnJlZShjb24tPmJ1Y2tldHMpOwogICAgaWYgKGNvbi0+cGVuZGluZyAhPSBOVUxMKQoJeG1sU2NoZW1hSXRlbUxpc3RGcmVlKGNvbi0+cGVuZGluZyk7CiAgICBpZiAoY29uLT5zdWJzdEdyb3VwcyAhPSBOVUxMKQoJeG1sSGFzaEZyZWUoY29uLT5zdWJzdEdyb3VwcywKCSAgICAoeG1sSGFzaERlYWxsb2NhdG9yKSB4bWxTY2hlbWFTdWJzdEdyb3VwRnJlZSk7CiAgICBpZiAoY29uLT5yZWRlZnMgIT0gTlVMTCkKCXhtbFNjaGVtYVJlZGVmTGlzdEZyZWUoY29uLT5yZWRlZnMpOwogICAgaWYgKGNvbi0+ZGljdCAhPSBOVUxMKQoJeG1sRGljdEZyZWUoY29uLT5kaWN0KTsKICAgIHhtbEZyZWUoY29uKTsKfQoKc3RhdGljIHhtbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHRQdHIgCnhtbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHRDcmVhdGUoeG1sRGljdFB0ciBkaWN0KQp7CiAgICB4bWxTY2hlbWFDb25zdHJ1Y3Rpb25DdHh0UHRyIHJldDsKCiAgICByZXQgPSAoeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dFB0cikKCXhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dCkpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEVyck1lbW9yeShOVUxMLAoJICAgICJhbGxvY2F0aW5nIHNjaGVtYSBjb25zdHJ1Y3Rpb24gY29udGV4dCIsIE5VTEwpOwogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dCkpOwoKICAgIHJldC0+YnVja2V0cyA9IHhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKCk7CiAgICBpZiAocmV0LT5idWNrZXRzID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwKCSAgICAiYWxsb2NhdGluZyBsaXN0IG9mIHNjaGVtYSBidWNrZXRzIiwgTlVMTCk7Cgl4bWxGcmVlKHJldCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIHJldC0+cGVuZGluZyA9IHhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKCk7CiAgICBpZiAocmV0LT5wZW5kaW5nID09IE5VTEwpIHsKCXhtbFNjaGVtYVBFcnJNZW1vcnkoTlVMTCwKCSAgICAiYWxsb2NhdGluZyBsaXN0IG9mIHBlbmRpbmcgZ2xvYmFsIGNvbXBvbmVudHMiLCBOVUxMKTsKCXhtbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHRGcmVlKHJldCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIHJldC0+ZGljdCA9IGRpY3Q7CiAgICB4bWxEaWN0UmVmZXJlbmNlKGRpY3QpOwogICAgcmV0dXJuKHJldCk7Cn0KCnN0YXRpYyB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyCnhtbFNjaGVtYVBhcnNlckN0eHRDcmVhdGUodm9pZCkKewogICAgeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciByZXQ7CgogICAgcmV0ID0gKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hUGFyc2VyQ3R4dCkpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEVyck1lbW9yeShOVUxMLCAiYWxsb2NhdGluZyBzY2hlbWEgcGFyc2VyIGNvbnRleHQiLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFQYXJzZXJDdHh0KSk7CiAgICByZXQtPnR5cGUgPSBYTUxfU0NIRU1BX0NUWFRfUEFSU0VSOwogICAgcmV0LT5hdHRyUHJvaGlicyA9IHhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKCk7CiAgICBpZiAocmV0LT5hdHRyUHJvaGlicyA9PSBOVUxMKSB7Cgl4bWxGcmVlKHJldCk7CglyZXR1cm4oTlVMTCk7CiAgICB9CiAgICByZXR1cm4ocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYU5ld1BhcnNlckN0eHRVc2VEaWN0OgogKiBAVVJMOiAgdGhlIGxvY2F0aW9uIG9mIHRoZSBzY2hlbWEKICogQGRpY3Q6IHRoZSBkaWN0aW9uYXJ5IHRvIGJlIHVzZWQKICoKICogQ3JlYXRlIGFuIFhNTCBTY2hlbWFzIHBhcnNlIGNvbnRleHQgZm9yIHRoYXQgZmlsZS9yZXNvdXJjZSBleHBlY3RlZAogKiB0byBjb250YWluIGFuIFhNTCBTY2hlbWFzIGZpbGUuCiAqCiAqIFJldHVybnMgdGhlIHBhcnNlciBjb250ZXh0IG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8Kc3RhdGljIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIKeG1sU2NoZW1hTmV3UGFyc2VyQ3R4dFVzZURpY3QoY29uc3QgY2hhciAqVVJMLCB4bWxEaWN0UHRyIGRpY3QpCnsKICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcmV0OwoKICAgIHJldCA9IHhtbFNjaGVtYVBhcnNlckN0eHRDcmVhdGUoKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgICAgICAgIAogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICByZXQtPmRpY3QgPSBkaWN0OwogICAgeG1sRGljdFJlZmVyZW5jZShkaWN0KTsgICAgCiAgICBpZiAoVVJMICE9IE5VTEwpCglyZXQtPlVSTCA9IHhtbERpY3RMb29rdXAoZGljdCwgKGNvbnN0IHhtbENoYXIgKikgVVJMLCAtMSk7CiAgICByZXR1cm4gKHJldCk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ3JlYXRlUEN0eHRPblZDdHh0KHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgaWYgKHZjdHh0LT5wY3R4dCA9PSBOVUxMKSB7CiAgICAgICAgaWYgKHZjdHh0LT5zY2hlbWEgIT0gTlVMTCkKCSAgICB2Y3R4dC0+cGN0eHQgPQoJCXhtbFNjaGVtYU5ld1BhcnNlckN0eHRVc2VEaWN0KCIqIiwgdmN0eHQtPnNjaGVtYS0+ZGljdCk7CgllbHNlCgkgICAgdmN0eHQtPnBjdHh0ID0geG1sU2NoZW1hTmV3UGFyc2VyQ3R4dCgiKiIpOwoJaWYgKHZjdHh0LT5wY3R4dCA9PSBOVUxMKSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hQ3JlYXRlUEN0eHRPblZDdHh0IiwKCQkiZmFpbGVkIHRvIGNyZWF0ZSBhIHRlbXAuIHBhcnNlciBjb250ZXh0Iik7CgkgICAgcmV0dXJuICgtMSk7Cgl9CgkvKiBUT0RPOiBQYXNzIHVzZXIgZGF0YS4gKi8KCXhtbFNjaGVtYVNldFBhcnNlckVycm9ycyh2Y3R4dC0+cGN0eHQsIHZjdHh0LT5lcnJvciwKCSAgICB2Y3R4dC0+d2FybmluZywgdmN0eHQtPmVyckN0eHQpOwoJeG1sU2NoZW1hU2V0UGFyc2VyU3RydWN0dXJlZEVycm9ycyh2Y3R4dC0+cGN0eHQsIHZjdHh0LT5zZXJyb3IsCgkgICAgdmN0eHQtPmVyckN0eHQpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUdldFNjaGVtYUJ1Y2tldDoKICogQHBjdHh0OiB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBzY2hlbWFMb2NhdGlvbjogdGhlIFVSSSBvZiB0aGUgc2NoZW1hIGRvY3VtZW50CiAqCiAqIFJldHVybnMgYSBzY2hlbWEgYnVja2V0IGlmIGl0IHdhcyBhbHJlYWR5IHBhcnNlZC4KICoKICogUmV0dXJucyBhIHNjaGVtYSBidWNrZXQgaWYgaXQgd2FzIGFscmVhZHkgcGFyc2VkIGZyb20KICogICAgICAgICBAc2NoZW1hTG9jYXRpb24sIE5VTEwgb3RoZXJ3aXNlLgogKi8Kc3RhdGljIHhtbFNjaGVtYUJ1Y2tldFB0cgp4bWxTY2hlbWFHZXRTY2hlbWFCdWNrZXQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJICAgIGNvbnN0IHhtbENoYXIgKnNjaGVtYUxvY2F0aW9uKQp7CiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgY3VyOwogICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgbGlzdDsKCiAgICBsaXN0ID0gcGN0eHQtPmNvbnN0cnVjdG9yLT5idWNrZXRzOwogICAgaWYgKGxpc3QtPm5iSXRlbXMgPT0gMCkKCXJldHVybihOVUxMKTsKICAgIGVsc2UgewoJaW50IGk7Cglmb3IgKGkgPSAwOyBpIDwgbGlzdC0+bmJJdGVtczsgaSsrKSB7CgkgICAgY3VyID0gKHhtbFNjaGVtYUJ1Y2tldFB0cikgbGlzdC0+aXRlbXNbaV07CgkgICAgLyogUG9pbnRlciBjb21wYXJpc29uISAqLwoJICAgIGlmIChjdXItPnNjaGVtYUxvY2F0aW9uID09IHNjaGVtYUxvY2F0aW9uKQoJCXJldHVybihjdXIpOwoJfQogICAgfQogICAgcmV0dXJuKE5VTEwpOwp9CgpzdGF0aWMgeG1sU2NoZW1hQnVja2V0UHRyCnhtbFNjaGVtYUdldENoYW1lbGVvblNjaGVtYUJ1Y2tldCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkJICAgICBjb25zdCB4bWxDaGFyICpzY2hlbWFMb2NhdGlvbiwKCQkJCSAgICAgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TmFtZXNwYWNlKQp7CiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgY3VyOwogICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgbGlzdDsKCiAgICBsaXN0ID0gcGN0eHQtPmNvbnN0cnVjdG9yLT5idWNrZXRzOwogICAgaWYgKGxpc3QtPm5iSXRlbXMgPT0gMCkKCXJldHVybihOVUxMKTsKICAgIGVsc2UgewoJaW50IGk7Cglmb3IgKGkgPSAwOyBpIDwgbGlzdC0+bmJJdGVtczsgaSsrKSB7CgkgICAgY3VyID0gKHhtbFNjaGVtYUJ1Y2tldFB0cikgbGlzdC0+aXRlbXNbaV07CgkgICAgLyogUG9pbnRlciBjb21wYXJpc29uISAqLwoJICAgIGlmICgoY3VyLT5vcmlnVGFyZ2V0TmFtZXNwYWNlID09IE5VTEwpICYmCgkJKGN1ci0+c2NoZW1hTG9jYXRpb24gPT0gc2NoZW1hTG9jYXRpb24pICYmCgkJKGN1ci0+dGFyZ2V0TmFtZXNwYWNlID09IHRhcmdldE5hbWVzcGFjZSkpCgkJcmV0dXJuKGN1cik7Cgl9CiAgICB9CiAgICByZXR1cm4oTlVMTCk7Cn0KCgojZGVmaW5lIElTX0JBRF9TQ0hFTUFfRE9DKGIpIFwKICAgICgoKGIpLT5kb2MgPT0gTlVMTCkgJiYgKChiKS0+c2NoZW1hTG9jYXRpb24gIT0gTlVMTCkpCgpzdGF0aWMgeG1sU2NoZW1hQnVja2V0UHRyCnhtbFNjaGVtYUdldFNjaGVtYUJ1Y2tldEJ5VE5TKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgY29uc3QgeG1sQ2hhciAqdGFyZ2V0TmFtZXNwYWNlLAoJCQkJIGludCBpbXBvcnRlZCkKewogICAgeG1sU2NoZW1hQnVja2V0UHRyIGN1cjsKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3Q7CgogICAgbGlzdCA9IHBjdHh0LT5jb25zdHJ1Y3Rvci0+YnVja2V0czsKICAgIGlmIChsaXN0LT5uYkl0ZW1zID09IDApCglyZXR1cm4oTlVMTCk7CiAgICBlbHNlIHsKCWludCBpOwoJZm9yIChpID0gMDsgaSA8IGxpc3QtPm5iSXRlbXM7IGkrKykgewoJICAgIGN1ciA9ICh4bWxTY2hlbWFCdWNrZXRQdHIpIGxpc3QtPml0ZW1zW2ldOwoJICAgIGlmICgoISBJU19CQURfU0NIRU1BX0RPQyhjdXIpKSAmJgoJCShjdXItPm9yaWdUYXJnZXROYW1lc3BhY2UgPT0gdGFyZ2V0TmFtZXNwYWNlKSAmJgoJCSgoaW1wb3J0ZWQgJiYgY3VyLT5pbXBvcnRlZCkgfHwKCQkgKCghaW1wb3J0ZWQpICYmICghY3VyLT5pbXBvcnRlZCkpKSkKCQlyZXR1cm4oY3VyKTsKCX0KICAgIH0KICAgIHJldHVybihOVUxMKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZU5ld0RvY1dpdGhDb250ZXh0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJICAgICB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCSAgICAgeG1sU2NoZW1hQnVja2V0UHRyIGJ1Y2tldCkKewogICAgaW50IG9sZEZsYWdzOwogICAgeG1sRG9jUHRyIG9sZERvYzsKICAgIHhtbE5vZGVQdHIgbm9kZTsKICAgIGludCByZXQsIG9sZEVycnM7CiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgb2xkYnVja2V0ID0gcGN0eHQtPmNvbnN0cnVjdG9yLT5idWNrZXQ7CiAgICAKICAgIC8qIAogICAgKiBTYXZlIG9sZCB2YWx1ZXM7IHJlc2V0IHRoZSAqbWFpbiogc2NoZW1hLgogICAgKiBVUkdFTlQgVE9ETzogVGhpcyBpcyBub3QgZ29vZDsgbW92ZSB0aGUgcGVyLWRvY3VtZW50IGluZm9ybWF0aW9uCiAgICAqIHRvIHRoZSBwYXJzZXIuCiAgICAqLwogICAgb2xkRmxhZ3MgPSBzY2hlbWEtPmZsYWdzOwogICAgb2xkRG9jID0gc2NoZW1hLT5kb2M7CiAgICBpZiAoc2NoZW1hLT5mbGFncyAhPSAwKQoJeG1sU2NoZW1hQ2xlYXJTY2hlbWFEZWZhdWx0cyhzY2hlbWEpOwogICAgc2NoZW1hLT5kb2MgPSBidWNrZXQtPmRvYzsKICAgIC8qICEhIFJFTU9WRUQ6IHNjaGVtYS0+dGFyZ2V0TmFtZXNwYWNlID0gYnVja2V0LT50YXJnZXROYW1lc3BhY2U7ICovCiAgICBwY3R4dC0+c2NoZW1hID0gc2NoZW1hOwogICAgLyogCiAgICAqIEtlZXAgdGhlIGN1cnJlbnQgdGFyZ2V0IG5hbWVzcGFjZSBvbiB0aGUgcGFyc2VyICpub3QqIG9uIHRoZQogICAgKiBtYWluIHNjaGVtYS4KICAgICovCiAgICBwY3R4dC0+dGFyZ2V0TmFtZXNwYWNlID0gYnVja2V0LT50YXJnZXROYW1lc3BhY2U7CiAgICBXWFNfQ09OU1RSVUNUT1IocGN0eHQpLT5idWNrZXQgPSBidWNrZXQ7CgogICAgaWYgKChidWNrZXQtPnRhcmdldE5hbWVzcGFjZSAhPSBOVUxMKSAmJgoJeG1sU3RyRXF1YWwoYnVja2V0LT50YXJnZXROYW1lc3BhY2UsIHhtbFNjaGVtYU5zKSkgewoJLyoKCSogV2UgYXJlIHBhcnNpbmcgdGhlIHNjaGVtYSBmb3Igc2NoZW1hcyEKCSovCglwY3R4dC0+aXNTNFMgPSAxOwogICAgfSAgICAKICAgIC8qIE1hcmsgaXQgYXMgcGFyc2VkLCBldmVuIGlmIHBhcnNpbmcgZmFpbHMuICovCiAgICBidWNrZXQtPnBhcnNlZCsrOwogICAgLyogQ29tcGlsZSB0aGUgc2NoZW1hIGRvYy4gKi8KICAgIG5vZGUgPSB4bWxEb2NHZXRSb290RWxlbWVudChidWNrZXQtPmRvYyk7CiAgICByZXQgPSB4bWxTY2hlbWFQYXJzZVNjaGVtYUVsZW1lbnQocGN0eHQsIHNjaGVtYSwgbm9kZSk7CiAgICBpZiAocmV0ICE9IDApCglnb3RvIGV4aXQ7CiAgICAvKiBBbiBlbXB0eSBzY2hlbWE7IGp1c3QgZ2V0IG91dC4gKi8KICAgIGlmIChub2RlLT5jaGlsZHJlbiA9PSBOVUxMKQoJZ290byBleGl0OwogICAgb2xkRXJycyA9IHBjdHh0LT5uYmVycm9yczsKICAgIHJldCA9IHhtbFNjaGVtYVBhcnNlU2NoZW1hVG9wTGV2ZWwocGN0eHQsIHNjaGVtYSwgbm9kZS0+Y2hpbGRyZW4pOwogICAgaWYgKHJldCAhPSAwKQoJZ290byBleGl0OwogICAgLyoKICAgICogVE9ETzogTm90IG5pY2UsIGJ1dCBJJ20gbm90IDEwMCUgc3VyZSB3ZSB3aWxsIGdldCBhbHdheXMgYW4gZXJyb3IKICAgICogYXMgYSByZXN1bHQgb2YgdGhlIG9ib3ZlIGZ1bmN0aW9uczsgc28gYmV0dGVyIHJlbHkgb24gcGN0eHQtPmVycgogICAgKiBhcyB3ZWxsLgogICAgKi8KICAgIGlmICgocmV0ID09IDApICYmIChvbGRFcnJzICE9IHBjdHh0LT5uYmVycm9ycykpIHsKCXJldCA9IHBjdHh0LT5lcnI7Cglnb3RvIGV4aXQ7CiAgICB9CiAgICAKZXhpdDoKICAgIFdYU19DT05TVFJVQ1RPUihwY3R4dCktPmJ1Y2tldCA9IG9sZGJ1Y2tldDsKICAgIC8qIFJlc3RvcmUgc2NoZW1hIHZhbHVlcy4gKi8KICAgIHNjaGVtYS0+ZG9jID0gb2xkRG9jOwogICAgc2NoZW1hLT5mbGFncyA9IG9sZEZsYWdzOwogICAgcmV0dXJuKHJldCk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hUGFyc2VOZXdEb2MoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJICAgICB4bWxTY2hlbWFCdWNrZXRQdHIgYnVja2V0KQp7CiAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIG5ld3BjdHh0OwogICAgaW50IHJlcyA9IDA7CgogICAgaWYgKGJ1Y2tldCA9PSBOVUxMKQoJcmV0dXJuKDApOwogICAgaWYgKGJ1Y2tldC0+cGFyc2VkKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFQYXJzZU5ld0RvYyIsCgkgICAgInJlcGFyc2luZyBhIHNjaGVtYSBkb2MiKTsKCXJldHVybigtMSk7CiAgICB9CiAgICBpZiAoYnVja2V0LT5kb2MgPT0gTlVMTCkgewoJUEVSUk9SX0lOVCgieG1sU2NoZW1hUGFyc2VOZXdEb2MiLAoJICAgICJwYXJzaW5nIGEgc2NoZW1hIGRvYywgYnV0IHRoZXJlJ3Mgbm8gZG9jIik7CglyZXR1cm4oLTEpOwogICAgfQogICAgaWYgKHBjdHh0LT5jb25zdHJ1Y3RvciA9PSBOVUxMKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFQYXJzZU5ld0RvYyIsCgkgICAgIm5vIGNvbnN0cnVjdG9yIik7CglyZXR1cm4oLTEpOwogICAgfSAgICAKICAgIC8qIENyZWF0ZSBhbmQgaW5pdCB0aGUgdGVtcG9yYXJ5IHBhcnNlciBjb250ZXh0LiAqLwogICAgbmV3cGN0eHQgPSB4bWxTY2hlbWFOZXdQYXJzZXJDdHh0VXNlRGljdCgKCShjb25zdCBjaGFyICopIGJ1Y2tldC0+c2NoZW1hTG9jYXRpb24sIHBjdHh0LT5kaWN0KTsKICAgIGlmIChuZXdwY3R4dCA9PSBOVUxMKQoJcmV0dXJuKC0xKTsKICAgIG5ld3BjdHh0LT5jb25zdHJ1Y3RvciA9IHBjdHh0LT5jb25zdHJ1Y3RvcjsKICAgIC8qCiAgICAqIFRPRE86IENhbiB3ZSBhdm9pZCB0aGF0IHRoZSBwYXJzZXIga25vd3MgYWJvdXQgdGhlIG1haW4gc2NoZW1hPyAKICAgICogSXQgd291bGQgYmUgYmV0dGVyIGlmIGhlIGtub3dzIGFib3V0IHRoZSBjdXJyZW50IHNjaGVtYSBidWNrZXQKICAgICogb25seS4KICAgICovCiAgICBuZXdwY3R4dC0+c2NoZW1hID0gc2NoZW1hOwogICAgeG1sU2NoZW1hU2V0UGFyc2VyRXJyb3JzKG5ld3BjdHh0LCBwY3R4dC0+ZXJyb3IsIHBjdHh0LT53YXJuaW5nLAoJcGN0eHQtPmVyckN0eHQpOwogICAgeG1sU2NoZW1hU2V0UGFyc2VyU3RydWN0dXJlZEVycm9ycyhuZXdwY3R4dCwgcGN0eHQtPnNlcnJvciwKCXBjdHh0LT5lcnJDdHh0KTsKICAgIG5ld3BjdHh0LT5jb3VudGVyID0gcGN0eHQtPmNvdW50ZXI7CiAgICAKCiAgICByZXMgPSB4bWxTY2hlbWFQYXJzZU5ld0RvY1dpdGhDb250ZXh0KG5ld3BjdHh0LCBzY2hlbWEsIGJ1Y2tldCk7CiAgICAKICAgIC8qIENoYW5uZWwgYmFjayBlcnJvcnMgYW5kIGNsZWFudXAgdGhlIHRlbXBvcmFyeSBwYXJzZXIgY29udGV4dC4gKi8KICAgIGlmIChyZXMgIT0gMCkKCXBjdHh0LT5lcnIgPSByZXM7CiAgICBwY3R4dC0+bmJlcnJvcnMgKz0gbmV3cGN0eHQtPm5iZXJyb3JzOwogICAgcGN0eHQtPmNvdW50ZXIgPSBuZXdwY3R4dC0+Y291bnRlcjsKICAgIG5ld3BjdHh0LT5jb25zdHJ1Y3RvciA9IE5VTEw7ICAgIAogICAgLyogRnJlZSB0aGUgcGFyc2VyIGNvbnRleHQuICovCiAgICB4bWxTY2hlbWFGcmVlUGFyc2VyQ3R4dChuZXdwY3R4dCk7CiAgICByZXR1cm4ocmVzKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25BZGRDaGlsZCh4bWxTY2hlbWFCdWNrZXRQdHIgYnVja2V0LAoJCQkJeG1sU2NoZW1hU2NoZW1hUmVsYXRpb25QdHIgcmVsKQp7CiAgICB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvblB0ciBjdXIgPSBidWNrZXQtPnJlbGF0aW9uczsKCiAgICBpZiAoY3VyID09IE5VTEwpIHsKCWJ1Y2tldC0+cmVsYXRpb25zID0gcmVsOwoJcmV0dXJuOwogICAgfQogICAgd2hpbGUgKGN1ci0+bmV4dCAhPSBOVUxMKQoJY3VyID0gY3VyLT5uZXh0OwogICAgY3VyLT5uZXh0ID0gcmVsOwp9CgoKc3RhdGljIGNvbnN0IHhtbENoYXIgKgp4bWxTY2hlbWFCdWlsZEFic29sdXRlVVJJKHhtbERpY3RQdHIgZGljdCwgY29uc3QgeG1sQ2hhciogbG9jYXRpb24sCgkJCSAgeG1sTm9kZVB0ciBjdHh0Tm9kZSkKeyAgICAKICAgIC8qCiAgICAqIEJ1aWxkIGFuIGFic29sdWUgbG9jYXRpb24gVVJJLgogICAgKi8KICAgIGlmIChsb2NhdGlvbiAhPSBOVUxMKSB7CQoJaWYgKGN0eHROb2RlID09IE5VTEwpCgkgICAgcmV0dXJuKGxvY2F0aW9uKTsKCWVsc2UgewoJICAgIHhtbENoYXIgKmJhc2UsICpVUkk7CgkgICAgY29uc3QgeG1sQ2hhciAqcmV0ID0gTlVMTDsKCgkgICAgYmFzZSA9IHhtbE5vZGVHZXRCYXNlKGN0eHROb2RlLT5kb2MsIGN0eHROb2RlKTsKCSAgICBpZiAoYmFzZSA9PSBOVUxMKSB7CgkJVVJJID0geG1sQnVpbGRVUkkobG9jYXRpb24sIGN0eHROb2RlLT5kb2MtPlVSTCk7CgkgICAgfSBlbHNlIHsKCQlVUkkgPSB4bWxCdWlsZFVSSShsb2NhdGlvbiwgYmFzZSk7CgkJeG1sRnJlZShiYXNlKTsKCSAgICB9CgkgICAgaWYgKFVSSSAhPSBOVUxMKSB7CgkJcmV0ID0geG1sRGljdExvb2t1cChkaWN0LCBVUkksIC0xKTsKCQl4bWxGcmVlKFVSSSk7CgkJcmV0dXJuKHJldCk7CgkgICAgfQoJfQogICAgfQogICAgcmV0dXJuKE5VTEwpOwp9CiAgICAKCgovKioKICogeG1sU2NoZW1hQWRkU2NoZW1hRG9jOgogKiBAcGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBQYXJzZSBhbiBpbmNsdWRlZCAoYW5kIHRvLWJlLXJlZGVmaW5lZCkgWE1MIHNjaGVtYSBkb2N1bWVudC4KICoKICogUmV0dXJucyAwIG9uIHN1Y2Nlc3MsIGEgcG9zaXRpdmUgZXJyb3IgY29kZSBvbiBlcnJvcnMgYW5kCiAqICAgICAgICAgLTEgaW4gY2FzZSBvZiBhbiBpbnRlcm5hbCBvciBBUEkgZXJyb3IuCiAqLwoKc3RhdGljIGludAp4bWxTY2hlbWFBZGRTY2hlbWFEb2MoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQlpbnQgdHlwZSwgLyogaW1wb3J0IG9yIGluY2x1ZGUgb3IgcmVkZWZpbmUgKi8KCQljb25zdCB4bWxDaGFyICpzY2hlbWFMb2NhdGlvbiwKCQl4bWxEb2NQdHIgc2NoZW1hRG9jLAoJCWNvbnN0IGNoYXIgKnNjaGVtYUJ1ZmZlciwKCQlpbnQgc2NoZW1hQnVmZmVyTGVuLAoJCXhtbE5vZGVQdHIgaW52b2tpbmdOb2RlLAoJCWNvbnN0IHhtbENoYXIgKnNvdXJjZVRhcmdldE5hbWVzcGFjZSwJCQoJCWNvbnN0IHhtbENoYXIgKmltcG9ydE5hbWVzcGFjZSwJCgkJeG1sU2NoZW1hQnVja2V0UHRyICpidWNrZXQpCnsKICAgIGNvbnN0IHhtbENoYXIgKnRhcmdldE5hbWVzcGFjZSA9IE5VTEw7CiAgICB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvblB0ciByZWxhdGlvbiA9IE5VTEw7CiAgICB4bWxEb2NQdHIgZG9jID0gTlVMTDsKICAgIGludCByZXMgPSAwLCBlcnIgPSAwLCBsb2NhdGVkID0gMCwgcHJlc2VydmVEb2MgPSAwOwogICAgeG1sU2NoZW1hQnVja2V0UHRyIGJrdCA9IE5VTEw7CgogICAgaWYgKGJ1Y2tldCAhPSBOVUxMKQoJKmJ1Y2tldCA9IE5VTEw7CiAgICAKICAgIHN3aXRjaCAodHlwZSkgewoJY2FzZSBYTUxfU0NIRU1BX1NDSEVNQV9JTVBPUlQ6CgljYXNlIFhNTF9TQ0hFTUFfU0NIRU1BX01BSU46CgkgICAgZXJyID0gWE1MX1NDSEVNQVBfU1JDX0lNUE9SVDsKCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9TQ0hFTUFfSU5DTFVERToKCSAgICBlcnIgPSBYTUxfU0NIRU1BUF9TUkNfSU5DTFVERTsKCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9TQ0hFTUFfUkVERUZJTkU6CgkgICAgZXJyID0gWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FOwoJICAgIGJyZWFrOwogICAgfSAgICAKICAgICAgIAoKICAgIC8qIFNwZWNpYWwgaGFuZGxpbmcgZm9yIHRoZSBtYWluIHNjaGVtYToKICAgICogc2tpcCB0aGUgbG9jYXRpb24gYW5kIHJlbGF0aW9uIGxvZ2ljIGFuZCBqdXN0IHBhcnNlIHRoZSBkb2MuCiAgICAqIFdlIG5lZWQganVzdCBhIGJ1Y2tldCB0byBiZSByZXR1cm5lZCBpbiB0aGlzIGNhc2UuCiAgICAqLyAgICAKICAgIGlmICgodHlwZSA9PSBYTUxfU0NIRU1BX1NDSEVNQV9NQUlOKSB8fCAoISBXWFNfSEFTX0JVQ0tFVFMocGN0eHQpKSkKCWdvdG8gZG9jX2xvYWQ7CQoKICAgIC8qIE5vdGUgdGhhdCB3ZSBleHBlY3QgdGhlIGxvY2F0aW9uIHRvIGJlIGFuIGFic3VsdXRlIFVSSS4gKi8gCiAgICBpZiAoc2NoZW1hTG9jYXRpb24gIT0gTlVMTCkgewoJYmt0ID0geG1sU2NoZW1hR2V0U2NoZW1hQnVja2V0KHBjdHh0LCBzY2hlbWFMb2NhdGlvbik7CglpZiAoKGJrdCAhPSBOVUxMKSAmJgoJICAgIChwY3R4dC0+Y29uc3RydWN0b3ItPmJ1Y2tldCA9PSBia3QpKSB7CgkgICAgLyogUmVwb3J0IHNlbGYtaW1wb3J0cy9pbmNsdXNpb25zL3JlZGVmaW5pdGlvbnMuICovCgkgICAgCgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsIGVyciwKCQlpbnZva2luZ05vZGUsIE5VTEwsCgkJIlRoZSBzY2hlbWEgbXVzdCBub3QgaW1wb3J0L2luY2x1ZGUvcmVkZWZpbmUgaXRzZWxmIiwKCQlOVUxMLCBOVUxMKTsKCSAgICBnb3RvIGV4aXQ7Cgl9CiAgICB9CiAgICAvKgogICAgKiBDcmVhdGUgYSByZWxhdGlvbiBmb3IgdGhlIGdyYXBoIG9mIHNjaGVtYXMuCiAgICAqLwogICAgcmVsYXRpb24gPSB4bWxTY2hlbWFTY2hlbWFSZWxhdGlvbkNyZWF0ZSgpOwogICAgaWYgKHJlbGF0aW9uID09IE5VTEwpCglyZXR1cm4oLTEpOyAgICAKICAgIHhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uQWRkQ2hpbGQocGN0eHQtPmNvbnN0cnVjdG9yLT5idWNrZXQsCglyZWxhdGlvbik7CiAgICByZWxhdGlvbi0+dHlwZSA9IHR5cGU7CgogICAgLyoKICAgICogU2F2ZSB0aGUgbmFtZXNwYWNlIGltcG9ydCBpbmZvcm1hdGlvbi4KICAgICovCiAgICBpZiAoV1hTX0lTX0JVQ0tFVF9JTVBNQUlOKHR5cGUpKSB7CglyZWxhdGlvbi0+aW1wb3J0TmFtZXNwYWNlID0gaW1wb3J0TmFtZXNwYWNlOwkKCWlmIChzY2hlbWFMb2NhdGlvbiA9PSBOVUxMKSB7CgkgICAgLyoKCSAgICAqIE5vIGxvY2F0aW9uOyB0aGlzIGlzIGp1c3QgYW4gaW1wb3J0IG9mIHRoZSBuYW1lc3BhY2UuCgkgICAgKiBOb3RlIHRoYXQgd2UgZG9uJ3QgYXNzaWduIGEgYnVja2V0IHRvIHRoZSByZWxhdGlvbgoJICAgICogaW4gdGhpcyBjYXNlLgoJICAgICovCgkgICAgZ290byBleGl0OwoJfQoJdGFyZ2V0TmFtZXNwYWNlID0gaW1wb3J0TmFtZXNwYWNlOwogICAgfQoKICAgIC8qIERpZCB3ZSBhbHJlYWR5IGZldGNoIHRoZSBkb2M/ICovCiAgICBpZiAoYmt0ICE9IE5VTEwpIHsJCQoJLyogVE9ETzogVGhlIGZvbGxvd2luZyBuYXN0eSBjYXNlcyB3aWxsIHByb2R1Y2UgYW4gZXJyb3IuICovCglpZiAoKFdYU19JU19CVUNLRVRfSU1QTUFJTih0eXBlKSkgJiYgKCEgYmt0LT5pbXBvcnRlZCkpIHsKCSAgICAvKiBXZSBpbmNsdWRlZC9yZWRlZmluZWQgYW5kIHRoZW4gdHJ5IHRvIGltcG9ydCBhIHNjaGVtYS4gKi8KCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwgZXJyLAoJCWludm9raW5nTm9kZSwgTlVMTCwKCQkiVGhlIHNjaGVtYSBkb2N1bWVudCAnJXMnIGNhbm5vdCBiZSBpbXBvcnRlZCwgc2luY2UgIgoJCSJpdCB3YXMgYWxyZWFkeSBpbmNsdWRlZCBvciByZWRlZmluZWQiLAoJCXNjaGVtYUxvY2F0aW9uLCBOVUxMKTsKCSAgICBnb3RvIGV4aXQ7Cgl9IGVsc2UgaWYgKCghIFdYU19JU19CVUNLRVRfSU1QTUFJTih0eXBlKSkgJiYgKGJrdC0+aW1wb3J0ZWQpKSB7CgkgICAgLyogV2UgaW1wb3J0ZWQgYW5kIHRoZW4gdHJ5IHRvIGluY2x1ZGUvcmVkZWZpbmUgYSBzY2hlbWEuICovCgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsIGVyciwKCQlpbnZva2luZ05vZGUsIE5VTEwsCgkJIlRoZSBzY2hlbWEgZG9jdW1lbnQgJyVzJyBjYW5ub3QgYmUgaW5jbHVkZWQgb3IgIgoJCSJyZWRlZmluZWQsIHNpbmNlIGl0IHdhcyBhbHJlYWR5IGltcG9ydGVkIiwKCQlzY2hlbWFMb2NhdGlvbiwgTlVMTCk7CgkgICAgZ290byBleGl0OwoJfQkKICAgIH0KICAgIAkKICAgIGlmIChXWFNfSVNfQlVDS0VUX0lNUE1BSU4odHlwZSkpIHsKCS8qCgkqIEdpdmVuIHRoYXQgdGhlIHNjaGVtYUxvY2F0aW9uIFthdHRyaWJ1dGVdIGlzIG9ubHkgYSBoaW50LCBpdCBpcyBvcGVuCgkqIHRvIGFwcGxpY2F0aW9ucyB0byBpZ25vcmUgYWxsIGJ1dCB0aGUgZmlyc3QgPGltcG9ydD4gZm9yIGEgZ2l2ZW4KCSogbmFtZXNwYWNlLCByZWdhcmRsZXNzIG9mIHRoZSC3YWN0dWFsIHZhbHVltyBvZiBzY2hlbWFMb2NhdGlvbiwgYnV0CgkqIHN1Y2ggYSBzdHJhdGVneSByaXNrcyBtaXNzaW5nIHVzZWZ1bCBpbmZvcm1hdGlvbiB3aGVuIG5ldwoJKiBzY2hlbWFMb2NhdGlvbnMgYXJlIG9mZmVyZWQuCgkqCgkqIFdlIHdpbGwgdXNlIHRoZSBmaXJzdCA8aW1wb3J0PiB0aGF0IGNvbWVzIHdpdGggYSBsb2NhdGlvbi4KCSogRnVydGhlciA8aW1wb3J0PnMgKndpdGgqIGEgbG9jYXRpb24sIHdpbGwgcmVzdWx0IGluIGFuIGVycm9yLgoJKiBUT0RPOiBCZXR0ZXIgd291bGQgYmUgdG8ganVzdCByZXBvcnQgYSB3YXJuaW5nIGhlcmUsIGJ1dAoJKiB3ZSdsbCB0cnkgaXQgdGhpcyB3YXkgdW50aWwgc29tZW9uZSBjb21wbGFpbnMuCgkqCgkqIFNjaGVtYSBEb2N1bWVudCBMb2NhdGlvbiBTdHJhdGVneToKCSogMyBCYXNlZCBvbiB0aGUgbmFtZXNwYWNlIG5hbWUsIGlkZW50aWZ5IGFuIGV4aXN0aW5nIHNjaGVtYSBkb2N1bWVudCwKCSogZWl0aGVyIGFzIGEgcmVzb3VyY2Ugd2hpY2ggaXMgYW4gWE1MIGRvY3VtZW50IG9yIGEgPHNjaGVtYT4gZWxlbWVudAoJKiBpbmZvcm1hdGlvbiBpdGVtLCBpbiBzb21lIGxvY2FsIHNjaGVtYSByZXBvc2l0b3J5OwoJKiA1IEF0dGVtcHQgdG8gcmVzb2x2ZSB0aGUgbmFtZXNwYWNlIG5hbWUgdG8gbG9jYXRlIHN1Y2ggYSByZXNvdXJjZS4KCSoKCSogTk9URTogKDMpIGFuZCAoNSkgYXJlIG5vdCBzdXBwb3J0ZWQuCgkqLwkKCWlmIChia3QgIT0gTlVMTCkgewoJICAgIHJlbGF0aW9uLT5idWNrZXQgPSBia3Q7CgkgICAgZ290byBleGl0OwoJfQoJYmt0ID0geG1sU2NoZW1hR2V0U2NoZW1hQnVja2V0QnlUTlMocGN0eHQsCgkgICAgaW1wb3J0TmFtZXNwYWNlLCAxKTsKCglpZiAoYmt0ICE9IE5VTEwpIHsJICAgIAoJICAgIHJlbGF0aW9uLT5idWNrZXQgPSBia3Q7CgkgICAgaWYgKGJrdC0+c2NoZW1hTG9jYXRpb24gPT0gTlVMTCkgewoJCS8qIEZpcnN0IGdpdmVuIGxvY2F0aW9uIG9mIHRoZSBzY2hlbWE7IGxvYWQgdGhlIGRvYy4gKi8KCQlia3QtPnNjaGVtYUxvY2F0aW9uID0gc2NoZW1hTG9jYXRpb247CgkgICAgfSBlbHNlIHsKCQlpZiAoIXhtbFN0ckVxdWFsKHNjaGVtYUxvY2F0aW9uLAoJCSAgICBia3QtPnNjaGVtYUxvY2F0aW9uKSkgewoJCSAgICAvKgoJCSAgICAqIEFkZGl0aW9uYWwgbG9jYXRpb24gZ2l2ZW47IGp1c3Qgc2tpcCBpdC4KCQkgICAgKiBVUkdFTlQgVE9ETzogV2Ugc2hvdWxkIHJlcG9ydCBhIHdhcm5pbmcgaGVyZS4KCQkgICAgKiByZXMgPSBYTUxfU0NIRU1BUF9TUkNfSU1QT1JUOwoJCSAgICAqLwoJCSAgICB4bWxTY2hlbWFDdXN0b21XYXJuaW5nKEFDVFhUX0NBU1QgcGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1dBUk5fU0tJUF9TQ0hFTUEsCgkJCWludm9raW5nTm9kZSwgTlVMTCwKCQkJIlNraXBwaW5nIGltcG9ydCBvZiBzY2hlbWEgbG9jYXRlZCBhdCAnJXMnIGZvciB0aGUgIgoJCQkibmFtZXNwYWNlICclcycsIHNpbmNlIHRoaXMgbmFtZXNwYWNlIHdhcyBhbHJlYWR5ICIKCQkJImltcG9ydGVkIHdpdGggdGhlIHNjaGVtYSBsb2NhdGVkIGF0ICclcyciLAoJCQlzY2hlbWFMb2NhdGlvbiwgaW1wb3J0TmFtZXNwYWNlLCBia3QtPnNjaGVtYUxvY2F0aW9uKTsKCQl9CgkJZ290byBleGl0OwoJICAgIH0KCX0JCgkvKiAKCSogTm8gYnVja2V0ICsgZmlyc3QgbG9jYXRpb246IGxvYWQgdGhlIGRvYyBhbmQgY3JlYXRlIGEKCSogYnVja2V0LgoJKi8KICAgIH0gZWxzZSB7CgkvKiA8aW5jbHVkZT4gYW5kIDxyZWRlZmluZT4gKi8KCWlmIChia3QgIT0gTlVMTCkgewoJICAgIAkgICAgCgkgICAgaWYgKChia3QtPm9yaWdUYXJnZXROYW1lc3BhY2UgPT0gTlVMTCkgJiYKCQkoYmt0LT50YXJnZXROYW1lc3BhY2UgIT0gc291cmNlVGFyZ2V0TmFtZXNwYWNlKSkgewoJCXhtbFNjaGVtYUJ1Y2tldFB0ciBjaGFtZWw7CgkJCgkJLyoKCQkqIENoYW1lbGVvbiBpbmNsdWRlL3JlZGVmaW5lOiBza2lwIGxvYWRpbmcgb25seSBpZiBpdCB3YXMKCQkqIGFsZWFkeSBidWlsZCBmb3IgdGhlIHRhcmdldE5hbWVzcGFjZSBvZiB0aGUgaW5jbHVkaW5nCgkJKiBzY2hlbWEuCgkJKi8KCQkvKgoJCSogVVJHRU5UIFRPRE86IElmIHRoZSBzY2hlbWEgaXMgYSBjaGFtZWxlb24taW5jbHVkZSB0aGVuIGNvcHkKCQkqIHRoZSBjb21wb25lbnRzIGludG8gdGhlIGluY2x1ZGluZyBzY2hlbWEgYW5kIG1vZGlmeSB0aGUKCQkqIHRhcmdldE5hbWVzcGFjZSBvZiB0aG9zZSBjb21wb25lbnRzLCBkbyBub3RoaW5nIG90aGVyd2lzZS4KCQkqIE5PVEU6IFRoaXMgaXMgY3VycmVudGx5IHdvcmtlZC1hcm91bmQgYnkgY29tcGlsaW5nIHRoZQoJCSogY2hhbWVsZW9uIGZvciBldmVyeSBkZXN0aW5jdCBpbmNsdWRpbmcgdGFyZ2V0TmFtZXNwYWNlOyB0aHVzCgkJKiBub3QgcGVyZm9ybWFudCBhdCB0aGUgbW9tZW50LgoJCSogVE9ETzogQ2hlY2sgd2hlbiB0aGUgbmFtZXNwYWNlIGluIHdpbGRjYXJkcyBmb3IgY2hhbWVsZW9ucwoJCSogbmVlZHMgdG8gYmUgY29udmVydGVkOiBiZWZvcmUgd2UgYnVpbHQgd2lsZGNhcmQgaW50ZXJzZWN0aW9ucwoJCSogb3IgYWZ0ZXIuCgkJKiAgIEFuc3dlcjogYWZ0ZXIhCgkJKi8KCQljaGFtZWwgPSB4bWxTY2hlbWFHZXRDaGFtZWxlb25TY2hlbWFCdWNrZXQocGN0eHQsCgkJICAgIHNjaGVtYUxvY2F0aW9uLCBzb3VyY2VUYXJnZXROYW1lc3BhY2UpOwoJCWlmIChjaGFtZWwgIT0gTlVMTCkgewoJCSAgICAvKiBBIGZpdHRpbmcgY2hhbWVsZW9uIHdhcyBhbHJlYWR5IHBhcnNlZDsgTk9QLiAqLwoJCSAgICByZWxhdGlvbi0+YnVja2V0ID0gY2hhbWVsOwoJCSAgICBnb3RvIGV4aXQ7CgkJfQoJCS8qIAoJCSogV2UgbmVlZCB0byBwYXJzZSB0aGUgY2hhbWVsZW9uIGFnYWluIGZvciBhIGRpZmZlcmVudAoJCSogdGFyZ2V0TmFtZXNwYWNlLgoJCSogQ0hBTUVMRU9OIFRPRE86IE9wdGltaXplIHRoaXMgYnkgb25seSBwYXJzaW5nIHRoZQoJCSogY2hhbWVsZW9uIG9uY2UsIGFuZCB0aGVuIGNvcHlpbmcgdGhlIGNvbXBvbmVudHMgdG8KCQkqIHRoZSBuZXcgdGFyZ2V0TmFtZXNwYWNlLgoJCSovCgkJYmt0ID0gTlVMTDsKCSAgICB9IGVsc2UgewoJCXJlbGF0aW9uLT5idWNrZXQgPSBia3Q7CgkJZ290byBleGl0OwoJICAgIH0JICAgIAoJfQogICAgfQogICAgaWYgKChia3QgIT0gTlVMTCkgJiYgKGJrdC0+ZG9jICE9IE5VTEwpKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFBZGRTY2hlbWFEb2MiLAoJICAgICJ0cnlpbmcgdG8gbG9hZCBhIHNjaGVtYSBkb2MsIGJ1dCBhIGRvYyBpcyBhbHJlYWR5ICIKCSAgICAiYXNzaWduZWQgdG8gdGhlIHNjaGVtYSBidWNrZXQiKTsKCWdvdG8gZXhpdF9mYWlsdXJlOwogICAgfQoKZG9jX2xvYWQ6CiAgICAvKgogICAgKiBMb2FkIHRoZSBkb2N1bWVudC4KICAgICovCiAgICBpZiAoc2NoZW1hRG9jICE9IE5VTEwpIHsKCWRvYyA9IHNjaGVtYURvYzsKCS8qIERvbicgZnJlZSB0aGlzIG9uZSwgc2luY2UgaXQgd2FzIHByb3ZpZGVkIGJ5IHRoZSBjYWxsZXIuICovCglwcmVzZXJ2ZURvYyA9IDE7CgkvKiBUT0RPOiBEb2VzIHRoZSBjb250ZXh0IG9yIHRoZSBkb2MgaG9sZCB0aGUgbG9jYXRpb24/ICovCglpZiAoc2NoZW1hRG9jLT5VUkwgIT0gTlVMTCkKCSAgICBzY2hlbWFMb2NhdGlvbiA9IHhtbERpY3RMb29rdXAocGN0eHQtPmRpY3QsCgkJc2NoZW1hRG9jLT5VUkwsIC0xKTsKCiAgICB9IGVsc2UgaWYgKChzY2hlbWFMb2NhdGlvbiAhPSBOVUxMKSB8fCAoc2NoZW1hQnVmZmVyICE9IE5VTEwpKSB7Cgl4bWxQYXJzZXJDdHh0UHRyIHBhcnNlckN0eHQ7CgoJcGFyc2VyQ3R4dCA9IHhtbE5ld1BhcnNlckN0eHQoKTsKCWlmIChwYXJzZXJDdHh0ID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KE5VTEwsICJ4bWxTY2hlbWFHZXREb2MsICIKCQkiYWxsb2NhdGluZyBhIHBhcnNlciBjb250ZXh0IiwgTlVMTCk7CgkgICAgZ290byBleGl0X2ZhaWx1cmU7Cgl9CglpZiAoKHBjdHh0LT5kaWN0ICE9IE5VTEwpICYmIChwYXJzZXJDdHh0LT5kaWN0ICE9IE5VTEwpKSB7CgkgICAgLyoKCSAgICAqIFRPRE86IERvIHdlIGhhdmUgdG8gYnVyZGVuIHRoZSBzY2hlbWEgcGFyc2VyIGRpY3Qgd2l0aCBhbGwKCSAgICAqIHRoZSBjb250ZW50IG9mIHRoZSBzY2hlbWEgZG9jPwoJICAgICovCgkgICAgeG1sRGljdEZyZWUocGFyc2VyQ3R4dC0+ZGljdCk7CgkgICAgcGFyc2VyQ3R4dC0+ZGljdCA9IHBjdHh0LT5kaWN0OwoJICAgIHhtbERpY3RSZWZlcmVuY2UocGFyc2VyQ3R4dC0+ZGljdCk7Cgl9CglpZiAoc2NoZW1hTG9jYXRpb24gIT0gTlVMTCkgewoJICAgIC8qIFBhcnNlIGZyb20gZmlsZS4gKi8KCSAgICBkb2MgPSB4bWxDdHh0UmVhZEZpbGUocGFyc2VyQ3R4dCwgKGNvbnN0IGNoYXIgKikgc2NoZW1hTG9jYXRpb24sCgkJTlVMTCwgU0NIRU1BU19QQVJTRV9PUFRJT05TKTsKCX0gZWxzZSBpZiAoc2NoZW1hQnVmZmVyICE9IE5VTEwpIHsKCSAgICAvKiBQYXJzZSBmcm9tIG1lbW9yeSBidWZmZXIuICovCgkgICAgZG9jID0geG1sQ3R4dFJlYWRNZW1vcnkocGFyc2VyQ3R4dCwgc2NoZW1hQnVmZmVyLCBzY2hlbWFCdWZmZXJMZW4sCgkJTlVMTCwgTlVMTCwgU0NIRU1BU19QQVJTRV9PUFRJT05TKTsKCSAgICBzY2hlbWFMb2NhdGlvbiA9IHhtbFN0cmR1cChCQURfQ0FTVCAiaW5fbWVtb3J5X2J1ZmZlciIpOwoJICAgIGlmIChkb2MgIT0gTlVMTCkKCQlkb2MtPlVSTCA9IHNjaGVtYUxvY2F0aW9uOwkgICAgCgl9CgkvKgoJKiBGb3IgPGltcG9ydD46CgkqIDIuMSBUaGUgcmVmZXJlbnQgaXMgKGEgZnJhZ21lbnQgb2YpIGEgcmVzb3VyY2Ugd2hpY2ggaXMgYW4KCSogWE1MIGRvY3VtZW50IChzZWUgY2xhdXNlIDEuMSksIHdoaWNoIGluIHR1cm4gY29ycmVzcG9uZHMgdG8KCSogYSA8c2NoZW1hPiBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0gaW4gYSB3ZWxsLWZvcm1lZCBpbmZvcm1hdGlvbgoJKiBzZXQsIHdoaWNoIGluIHR1cm4gY29ycmVzcG9uZHMgdG8gYSB2YWxpZCBzY2hlbWEuCgkqIFRPRE86ICgyLjEpIGZyYWdtZW50cyBvZiBYTUwgZG9jdW1lbnRzIGFyZSBub3Qgc3VwcG9ydGVkLgoJKgoJKiAyLjIgVGhlIHJlZmVyZW50IGlzIGEgPHNjaGVtYT4gZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtIGluCgkqIGEgd2VsbC1mb3JtZWQgaW5mb3JtYXRpb24gc2V0LCB3aGljaCBpbiB0dXJuIGNvcnJlc3BvbmRzCgkqIHRvIGEgdmFsaWQgc2NoZW1hLgoJKiBUT0RPOiAoMi4yKSBpcyBub3Qgc3VwcG9ydGVkLgoJKi8KCWlmIChkb2MgPT0gTlVMTCkgewoJICAgIHhtbEVycm9yUHRyIGxlcnI7CgkgICAgbGVyciA9IHhtbEdldExhc3RFcnJvcigpOwoJICAgIC8qCgkgICAgKiBDaGVjayBpZiB0aGlzIGEgcGFyc2VyIGVycm9yLCBvciBpZiB0aGUgZG9jdW1lbnQgY291bGQKCSAgICAqIGp1c3Qgbm90IGJlIGxvY2F0ZWQuCgkgICAgKiBUT0RPOiBUcnkgdG8gZmluZCBzcGVjaWZpYyBlcnJvciBjb2RlcyB0byByZWFjdCBvbmx5IG9uCgkgICAgKiBsb2NhbGlzYXRpb24gZmFpbHVyZXMuCgkgICAgKi8KCSAgICBpZiAoKGxlcnIgPT0gTlVMTCkgfHwgKGxlcnItPmRvbWFpbiAhPSBYTUxfRlJPTV9JTykpIHsKCQkvKgoJCSogV2UgYXNzdW1lIGEgcGFyc2VyIGVycm9yIGhlcmUuCgkJKi8KCQlsb2NhdGVkID0gMTsKCQkvKiBUT0RPOiBFcnJvciBjb2RlID8/ICovCgkJcmVzID0gWE1MX1NDSEVNQVBfU1JDX0lNUE9SVF8yXzE7CgkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsIHJlcywKCQkgICAgaW52b2tpbmdOb2RlLCBOVUxMLAoJCSAgICAiRmFpbGVkIHRvIHBhcnNlIHRoZSBYTUwgcmVzb3VyY2UgJyVzJyIsCgkJICAgIHNjaGVtYUxvY2F0aW9uLCBOVUxMKTsJCQoJICAgIH0KCX0KCXhtbEZyZWVQYXJzZXJDdHh0KHBhcnNlckN0eHQpOwoJaWYgKChkb2MgPT0gTlVMTCkgJiYgbG9jYXRlZCkKCSAgICBnb3RvIGV4aXRfZXJyb3I7CiAgICB9IGVsc2UgewoJeG1sU2NoZW1hUEVycihwY3R4dCwgTlVMTCwKCSAgICBYTUxfU0NIRU1BUF9OT1RISU5HX1RPX1BBUlNFLAoJICAgICJObyBpbmZvcm1hdGlvbiBmb3IgcGFyc2luZyB3YXMgcHJvdmlkZWQgd2l0aCB0aGUgIgoJICAgICJnaXZlbiBzY2hlbWEgcGFyc2VyIGNvbnRleHQuXG4iLAoJICAgIE5VTEwsIE5VTEwpOwoJZ290byBleGl0X2ZhaWx1cmU7CiAgICB9CiAgICAvKgogICAgKiBQcmVwcm9jZXNzIHRoZSBkb2N1bWVudC4KICAgICovCiAgICBpZiAoZG9jICE9IE5VTEwpIHsKCXhtbE5vZGVQdHIgZG9jRWxlbSA9IE5VTEw7CgoJbG9jYXRlZCA9IDE7CQoJZG9jRWxlbSA9IHhtbERvY0dldFJvb3RFbGVtZW50KGRvYyk7CglpZiAoZG9jRWxlbSA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsIFhNTF9TQ0hFTUFQX05PUk9PVCwKCQlpbnZva2luZ05vZGUsIE5VTEwsIAoJCSJUaGUgZG9jdW1lbnQgJyVzJyBoYXMgbm8gZG9jdW1lbnQgZWxlbWVudCIsCgkJc2NoZW1hTG9jYXRpb24sIE5VTEwpOwoJICAgIHhtbEZyZWVEb2MoZG9jKTsKCSAgICBkb2MgPSBOVUxMOwoJICAgIGdvdG8gZXhpdF9lcnJvcjsKCX0KCS8qCgkqIFJlbW92ZSBhbGwgdGhlIGJsYW5rIHRleHQgbm9kZXMuCgkqLwoJeG1sU2NoZW1hQ2xlYW51cERvYyhwY3R4dCwgZG9jRWxlbSk7CgkvKgoJKiBDaGVjayB0aGUgc2NoZW1hJ3MgdG9wIGxldmVsIGVsZW1lbnQuCgkqLwoJaWYgKCFJU19TQ0hFTUEoZG9jRWxlbSwgInNjaGVtYSIpKSB7CgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsIFhNTF9TQ0hFTUFQX05PVF9TQ0hFTUEsCgkJaW52b2tpbmdOb2RlLCBOVUxMLAoJCSJUaGUgWE1MIGRvY3VtZW50ICclcycgaXMgbm90IGEgc2NoZW1hIGRvY3VtZW50IiwKCQlzY2hlbWFMb2NhdGlvbiwgTlVMTCk7CgkgICAgeG1sRnJlZURvYyhkb2MpOwoJICAgIGRvYyA9IE5VTEw7CgkgICAgZ290byBleGl0X2Vycm9yOwoJfQoJLyogCgkqIE5vdGUgdGhhdCB3ZSBkb24ndCBhcHBseSBhIHR5cGUgY2hlY2sgZm9yIHRoZQoJKiB0YXJnZXROYW1lc3BhY2UgdmFsdWUgaGVyZS4KCSovCgl0YXJnZXROYW1lc3BhY2UgPSB4bWxTY2hlbWFHZXRQcm9wKHBjdHh0LCBkb2NFbGVtLAoJICAgICJ0YXJnZXROYW1lc3BhY2UiKTsKICAgIH0KICAgIAovKiBhZnRlcl9kb2NfbG9hZGluZzogKi8KICAgIGlmICgoYmt0ID09IE5VTEwpICYmIGxvY2F0ZWQpIHsKCS8qIE9ubHkgY3JlYXRlIGEgYnVja2V0IGlmIHRoZSBzY2hlbWEgd2FzIGxvY2F0ZWQuICovCiAgICAgICAgYmt0ID0geG1sU2NoZW1hQnVja2V0Q3JlYXRlKHBjdHh0LCB0eXBlLAoJICAgIHRhcmdldE5hbWVzcGFjZSk7CglpZiAoYmt0ID09IE5VTEwpCgkgICAgZ290byBleGl0X2ZhaWx1cmU7CiAgICB9CiAgICBpZiAoYmt0ICE9IE5VTEwpIHsKCWJrdC0+c2NoZW1hTG9jYXRpb24gPSBzY2hlbWFMb2NhdGlvbjsKCWJrdC0+bG9jYXRlZCA9IGxvY2F0ZWQ7CglpZiAoZG9jICE9IE5VTEwpIHsKCSAgICBia3QtPmRvYyA9IGRvYzsKCSAgICBia3QtPnRhcmdldE5hbWVzcGFjZSA9IHRhcmdldE5hbWVzcGFjZTsKCSAgICBia3QtPm9yaWdUYXJnZXROYW1lc3BhY2UgPSB0YXJnZXROYW1lc3BhY2U7CgkgICAgaWYgKHByZXNlcnZlRG9jKQoJCWJrdC0+cHJlc2VydmVEb2MgPSAxOwoJfQoJaWYgKFdYU19JU19CVUNLRVRfSU1QTUFJTih0eXBlKSkKCSAgICBia3QtPmltcG9ydGVkKys7CgkgICAgLyoKCSAgICAqIEFkZCBpdCB0byB0aGUgZ3JhcGggb2Ygc2NoZW1hcy4KCSAgICAqLwoJaWYgKHJlbGF0aW9uICE9IE5VTEwpCgkgICAgcmVsYXRpb24tPmJ1Y2tldCA9IGJrdDsKICAgIH0KICAKZXhpdDoKICAgIC8qCiAgICAqIFJldHVybiB0aGUgYnVja2V0IGV4cGxpY2l0ZWx5OyB0aGlzIGlzIG5lZWRlZCBmb3IgdGhlCiAgICAqIG1haW4gc2NoZW1hLgogICAgKi8KICAgIGlmIChidWNrZXQgIT0gTlVMTCkKCSpidWNrZXQgPSBia3Q7ICAgIAogICAgcmV0dXJuICgwKTsKCmV4aXRfZXJyb3I6CiAgICBpZiAoKGRvYyAhPSBOVUxMKSAmJiAoISBwcmVzZXJ2ZURvYykpIHsKCXhtbEZyZWVEb2MoZG9jKTsKCWlmIChia3QgIT0gTlVMTCkKCSAgICBia3QtPmRvYyA9IE5VTEw7CiAgICB9CiAgICByZXR1cm4ocGN0eHQtPmVycik7CgpleGl0X2ZhaWx1cmU6CiAgICBpZiAoKGRvYyAhPSBOVUxMKSAmJiAoISBwcmVzZXJ2ZURvYykpIHsKCXhtbEZyZWVEb2MoZG9jKTsKCWlmIChia3QgIT0gTlVMTCkKCSAgICBia3QtPmRvYyA9IE5VTEw7CiAgICB9ICAgIAogICAgcmV0dXJuICgtMSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZUltcG9ydDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgSW1wb3J0IGRlZmluaXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIDAgaW4gY2FzZSBvZiBzdWNjZXNzLCBhIHBvc2l0aXZlIGVycm9yIGNvZGUgaWYKICogbm90IHZhbGlkIGFuZCAtMSBpbiBjYXNlIG9mIGFuIGludGVybmFsIGVycm9yLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZUltcG9ydCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUpCnsKICAgIHhtbE5vZGVQdHIgY2hpbGQ7CiAgICBjb25zdCB4bWxDaGFyICpuYW1lc3BhY2VOYW1lID0gTlVMTCwgKnNjaGVtYUxvY2F0aW9uID0gTlVMTDsKICAgIGNvbnN0IHhtbENoYXIgKnRoaXNUYXJnZXROYW1lc3BhY2U7CiAgICB4bWxBdHRyUHRyIGF0dHI7CiAgICBpbnQgcmV0ID0gMDsKICAgIHhtbFNjaGVtYUJ1Y2tldFB0ciBidWNrZXQgPSBOVUxMOwoKICAgIGlmICgocGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKC0xKTsKCiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJuYW1lc3BhY2UiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJzY2hlbWFMb2NhdGlvbiIpKSkgewoJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihwY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihwY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7Cgl9CglhdHRyID0gYXR0ci0+bmV4dDsKICAgIH0KICAgIC8qCiAgICAqIEV4dHJhY3QgYW5kIHZhbGlkYXRlIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgaWYgKHhtbFNjaGVtYVBWYWxBdHRyKHBjdHh0LCBOVUxMLCBub2RlLAoJIm5hbWVzcGFjZSIsIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVVSSSksCgkmbmFtZXNwYWNlTmFtZSkgIT0gMCkgewoJeG1sU2NoZW1hUFNpbXBsZVR5cGVFcnIocGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCSAgICBOVUxMLCBub2RlLAoJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVVSSSksCgkgICAgTlVMTCwgbmFtZXNwYWNlTmFtZSwgTlVMTCwgTlVMTCwgTlVMTCk7CglyZXR1cm4gKHBjdHh0LT5lcnIpOwogICAgfQoKICAgIGlmICh4bWxTY2hlbWFQVmFsQXR0cihwY3R4dCwgTlVMTCwgbm9kZSwKCSJzY2hlbWFMb2NhdGlvbiIsIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVVSSSksCgkmc2NoZW1hTG9jYXRpb24pICE9IDApIHsKCXhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKHBjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX0lOVkFMSURfVkFMVUUsCgkgICAgTlVMTCwgbm9kZSwKCSAgICB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19BTllVUkkpLAoJICAgIE5VTEwsIG5hbWVzcGFjZU5hbWUsIE5VTEwsIE5VTEwsIE5VTEwpOwoJcmV0dXJuIChwY3R4dC0+ZXJyKTsKICAgIH0KICAgIC8qCiAgICAqIEFuZCBub3cgZm9yIHRoZSBjaGlsZHJlbi4uLgogICAgKi8KICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CiAgICAgICAgLyoKICAgICAgICAgKiB0aGUgYW5ub3RhdGlvbiBoZXJlIGlzIHNpbXBseSBkaXNjYXJkZWQgLi4uCgkgKiBUT0RPOiByZWFsbHk/CiAgICAgICAgICovCiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChjaGlsZCAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/KSIpOwogICAgfQogICAgLyoKICAgICogQXBwbHkgYWRkaXRpb25hbCBjb25zdHJhaW50cy4KICAgICoKICAgICogTm90ZSB0aGF0IGl0IGlzIGltcG9ydGFudCB0byB1c2UgdGhlIG9yaWdpbmFsIEB0YXJnZXROYW1lc3BhY2UKICAgICogKG9yIG5vbmUgYXQgYWxsKSwgdG8gcnVsZSBvdXQgaW1wb3J0cyBvZiBzY2hlbWFzIF93aXRoXyBhCiAgICAqIEB0YXJnZXROYW1lc3BhY2UgaWYgdGhlIGltcG9ydGluZyBzY2hlbWEgaXMgYSBjaGFtZWxlb24gc2NoZW1hCiAgICAqICh3aXRoIG5vIEB0YXJnZXROYW1lc3BhY2UpLgogICAgKi8KICAgIHRoaXNUYXJnZXROYW1lc3BhY2UgPSBXWFNfQlVDS0VUKHBjdHh0KS0+b3JpZ1RhcmdldE5hbWVzcGFjZTsKICAgIGlmIChuYW1lc3BhY2VOYW1lICE9IE5VTEwpIHsKCS8qCgkqIDEuMSBJZiB0aGUgbmFtZXNwYWNlIFthdHRyaWJ1dGVdIGlzIHByZXNlbnQsIHRoZW4gaXRzILdhY3R1YWwgdmFsdWW3CgkqIG11c3Qgbm90IG1hdGNoIHRoZSC3YWN0dWFsIHZhbHVltyBvZiB0aGUgZW5jbG9zaW5nIDxzY2hlbWE+J3MKCSogdGFyZ2V0TmFtZXNwYWNlIFthdHRyaWJ1dGVdLgoJKi8KCWlmICh4bWxTdHJFcXVhbCh0aGlzVGFyZ2V0TmFtZXNwYWNlLCBuYW1lc3BhY2VOYW1lKSkgewoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJWE1MX1NDSEVNQVBfU1JDX0lNUE9SVF8xXzEsCgkJTlVMTCwgbm9kZSwKCQkiVGhlIHZhbHVlIG9mIHRoZSBhdHRyaWJ1dGUgJ25hbWVzcGFjZScgbXVzdCBub3QgbWF0Y2ggIgoJCSJ0aGUgdGFyZ2V0IG5hbWVzcGFjZSAnJXMnIG9mIHRoZSBpbXBvcnRpbmcgc2NoZW1hIiwKCQl0aGlzVGFyZ2V0TmFtZXNwYWNlKTsKCSAgICByZXR1cm4gKHBjdHh0LT5lcnIpOwoJfQogICAgfSBlbHNlIHsKCS8qCgkqIDEuMiBJZiB0aGUgbmFtZXNwYWNlIFthdHRyaWJ1dGVdIGlzIG5vdCBwcmVzZW50LCB0aGVuIHRoZSBlbmNsb3NpbmcKCSogPHNjaGVtYT4gbXVzdCBoYXZlIGEgdGFyZ2V0TmFtZXNwYWNlIFthdHRyaWJ1dGVdLgoJKi8KCWlmICh0aGlzVGFyZ2V0TmFtZXNwYWNlID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19JTVBPUlRfMV8yLAoJCU5VTEwsIG5vZGUsCgkJIlRoZSBhdHRyaWJ1dGUgJ25hbWVzcGFjZScgbXVzdCBiZSBleGlzdGVudCBpZiAiCgkJInRoZSBpbXBvcnRpbmcgc2NoZW1hIGhhcyBubyB0YXJnZXQgbmFtZXNwYWNlIiwKCQlOVUxMKTsKCSAgICByZXR1cm4gKHBjdHh0LT5lcnIpOwoJfQogICAgfQogICAgLyoKICAgICogTG9jYXRlIGFuZCBhY3F1aXJlIHRoZSBzY2hlbWEgZG9jdW1lbnQuCiAgICAqLwogICAgaWYgKHNjaGVtYUxvY2F0aW9uICE9IE5VTEwpCglzY2hlbWFMb2NhdGlvbiA9IHhtbFNjaGVtYUJ1aWxkQWJzb2x1dGVVUkkocGN0eHQtPmRpY3QsCgkgICAgc2NoZW1hTG9jYXRpb24sIG5vZGUpOwogICAgcmV0ID0geG1sU2NoZW1hQWRkU2NoZW1hRG9jKHBjdHh0LCBYTUxfU0NIRU1BX1NDSEVNQV9JTVBPUlQsCglzY2hlbWFMb2NhdGlvbiwgTlVMTCwgTlVMTCwgMCwgbm9kZSwgdGhpc1RhcmdldE5hbWVzcGFjZSwKCW5hbWVzcGFjZU5hbWUsICZidWNrZXQpOwoKICAgIGlmIChyZXQgIT0gMCkKCXJldHVybihyZXQpOwoKICAgIC8qCiAgICAqIEZvciA8aW1wb3J0PjogIkl0IGlzICpub3QqIGFuIGVycm9yIGZvciB0aGUgYXBwbGljYXRpb24KICAgICogc2NoZW1hIHJlZmVyZW5jZSBzdHJhdGVneSB0byBmYWlsLiIKICAgICogU28ganVzdCBkb24ndCBwYXJzZSBpZiBubyBzY2hlbWEgZG9jdW1lbnQgd2FzIGZvdW5kLgogICAgKiBOb3RlIHRoYXQgd2Ugd2lsbCBnZXQgbm8gYnVja2V0IGlmIHRoZSBzY2hlbWEgY291bGQgbm90IGJlCiAgICAqIGxvY2F0ZWQgb3IgaWYgdGhlcmUgd2FzIG5vIHNjaGVtYUxvY2F0aW9uLgogICAgKi8KICAgIGlmICgoYnVja2V0ID09IE5VTEwpICYmIChzY2hlbWFMb2NhdGlvbiAhPSBOVUxMKSkgewoJeG1sU2NoZW1hQ3VzdG9tV2FybmluZyhBQ1RYVF9DQVNUIHBjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1dBUk5fVU5MT0NBVEVEX1NDSEVNQSwKCSAgICBub2RlLCBOVUxMLAoJICAgICJGYWlsZWQgdG8gbG9jYXRlIGEgc2NoZW1hIGF0IGxvY2F0aW9uICclcycuICIKCSAgICAiU2tpcHBpbmcgdGhlIGltcG9ydCIsIHNjaGVtYUxvY2F0aW9uLCBOVUxMLCBOVUxMKTsKICAgIH0KICAgIAogICAgaWYgKChidWNrZXQgIT0gTlVMTCkgJiYgQ0FOX1BBUlNFX1NDSEVNQShidWNrZXQpKSB7CQoJcmV0ID0geG1sU2NoZW1hUGFyc2VOZXdEb2MocGN0eHQsIHNjaGVtYSwgYnVja2V0KTsKICAgIH0KICAgIAogICAgcmV0dXJuIChyZXQpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlSW5jbHVkZU9yUmVkZWZpbmVBdHRycyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkJICAgICB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkJICAgICB4bWxOb2RlUHRyIG5vZGUsCgkJCQkgICAgIHhtbENoYXIgKipzY2hlbWFMb2NhdGlvbiwKCQkJCSAgICAgaW50IHR5cGUpCnsKICAgIHhtbEF0dHJQdHIgYXR0cjsKCiAgICBpZiAoKHBjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkgfHwgKG5vZGUgPT0gTlVMTCkgfHwKCShzY2hlbWFMb2NhdGlvbiA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKC0xKTsKCiAgICAqc2NoZW1hTG9jYXRpb24gPSBOVUxMOwogICAgLyoKICAgICogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KICAgICogQXBwbGllcyBmb3IgYm90aCA8aW5jbHVkZT4gYW5kIDxyZWRlZmluZT4uCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSAmJgoJCSgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgInNjaGVtYUxvY2F0aW9uIikpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSB7CgkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChwY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CiAgICAvKgogICAgKiBQcmVsaW1pbmFyeSBzdGVwLCBleHRyYWN0IHRoZSBVUkktUmVmZXJlbmNlIGFuZCBtYWtlIGFuIFVSSQogICAgKiBmcm9tIHRoZSBiYXNlLgogICAgKi8KICAgIC8qCiAgICAqIEF0dHJpYnV0ZSAic2NoZW1hTG9jYXRpb24iIGlzIG1hbmRhdG9yeS4KICAgICovCiAgICBhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgInNjaGVtYUxvY2F0aW9uIik7CiAgICBpZiAoYXR0ciAhPSBOVUxMKSB7CiAgICAgICAgeG1sQ2hhciAqYmFzZSA9IE5VTEw7CiAgICAgICAgeG1sQ2hhciAqdXJpID0gTlVMTDsKCglpZiAoeG1sU2NoZW1hUFZhbEF0dHJOb2RlKHBjdHh0LCBOVUxMLCBhdHRyLAoJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVVSSSksCgkgICAgKGNvbnN0IHhtbENoYXIgKiopIHNjaGVtYUxvY2F0aW9uKSAhPSAwKQoJICAgIGdvdG8gZXhpdF9lcnJvcjsKCWJhc2UgPSB4bWxOb2RlR2V0QmFzZShub2RlLT5kb2MsIG5vZGUpOwoJaWYgKGJhc2UgPT0gTlVMTCkgewoJICAgIHVyaSA9IHhtbEJ1aWxkVVJJKCpzY2hlbWFMb2NhdGlvbiwgbm9kZS0+ZG9jLT5VUkwpOwoJfSBlbHNlIHsKCSAgICB1cmkgPSB4bWxCdWlsZFVSSSgqc2NoZW1hTG9jYXRpb24sIGJhc2UpOwoJICAgIHhtbEZyZWUoYmFzZSk7Cgl9CglpZiAodXJpID09IE5VTEwpIHsKCSAgICBQRVJST1JfSU5UKCJ4bWxTY2hlbWFQYXJzZUluY2x1ZGVPclJlZGVmaW5lIiwKCQkiY291bGQgbm90IGJ1aWxkIGFuIFVSSSBmcm9tIHRoZSBzY2hlbWFMb2NhdGlvbiIpCgkgICAgZ290byBleGl0X2ZhaWx1cmU7Cgl9CgkoKnNjaGVtYUxvY2F0aW9uKSA9ICh4bWxDaGFyICopIHhtbERpY3RMb29rdXAocGN0eHQtPmRpY3QsIHVyaSwgLTEpOwoJeG1sRnJlZSh1cmkpOwogICAgfSBlbHNlIHsKCXhtbFNjaGVtYVBNaXNzaW5nQXR0ckVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsICJzY2hlbWFMb2NhdGlvbiIsIE5VTEwpOwoJZ290byBleGl0X2Vycm9yOwogICAgfQogICAgLyoKICAgICogUmVwb3J0IHNlbGYtaW5jbHVzaW9uIGFuZCBzZWxmLXJlZGVmaW5pdGlvbi4KICAgICovCiAgICBpZiAoeG1sU3RyRXF1YWwoKnNjaGVtYUxvY2F0aW9uLCBwY3R4dC0+VVJMKSkgewoJaWYgKHR5cGUgPT0gWE1MX1NDSEVNQV9TQ0hFTUFfUkVERUZJTkUpIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19SRURFRklORSwKCQlOVUxMLCBub2RlLAoJCSJUaGUgc2NoZW1hIGRvY3VtZW50ICclcycgY2Fubm90IHJlZGVmaW5lIGl0c2VsZi4iLAoJCSpzY2hlbWFMb2NhdGlvbik7CSAgICAKCX0gZWxzZSB7CgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQlYTUxfU0NIRU1BUF9TUkNfSU5DTFVERSwKCQlOVUxMLCBub2RlLAoJCSJUaGUgc2NoZW1hIGRvY3VtZW50ICclcycgY2Fubm90IGluY2x1ZGUgaXRzZWxmLiIsCgkJKnNjaGVtYUxvY2F0aW9uKTsKCX0KCWdvdG8gZXhpdF9lcnJvcjsKICAgIH0KICAgIAogICAgcmV0dXJuKDApOwpleGl0X2Vycm9yOgogICAgcmV0dXJuKHBjdHh0LT5lcnIpOwpleGl0X2ZhaWx1cmU6CiAgICByZXR1cm4oLTEpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlSW5jbHVkZU9yUmVkZWZpbmUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJCXhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJCQl4bWxOb2RlUHRyIG5vZGUsCgkJCQlpbnQgdHlwZSkKewogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICBjb25zdCB4bWxDaGFyICpzY2hlbWFMb2NhdGlvbiA9IE5VTEw7CiAgICBpbnQgcmVzID0gMDsgLyogaGFzUmVkZWZpbml0aW9ucyA9IDAgKi8KICAgIGludCBpc0NoYW1lbGVvbiA9IDAsIHdhc0NoYW1lbGVvbiA9IDA7CiAgICB4bWxTY2hlbWFCdWNrZXRQdHIgYnVja2V0ID0gTlVMTDsKCiAgICBpZiAoKHBjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkgfHwgKG5vZGUgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuICgtMSk7CgogICAgLyoKICAgICogUGFyc2UgYXR0cmlidXRlcy4gTm90ZSB0aGF0IHRoZSByZXR1cm5lZCBzY2hlbWFMb2NhdGlvbiB3aWxsCiAgICAqIGJlIGFscmVhZHkgY29udmVydGVkIHRvIGFuIGFic29sdXRlIFVSSS4KICAgICovCiAgICByZXMgPSB4bWxTY2hlbWFQYXJzZUluY2x1ZGVPclJlZGVmaW5lQXR0cnMocGN0eHQsIHNjaGVtYSwKCW5vZGUsICh4bWxDaGFyICoqKSAoJnNjaGVtYUxvY2F0aW9uKSwgdHlwZSk7CiAgICBpZiAocmVzICE9IDApCglyZXR1cm4ocmVzKTsgICAgCSAgIAogICAgLyoKICAgICogTG9hZCBhbmQgYWRkIHRoZSBzY2hlbWEgZG9jdW1lbnQuCiAgICAqLwogICAgcmVzID0geG1sU2NoZW1hQWRkU2NoZW1hRG9jKHBjdHh0LCB0eXBlLCBzY2hlbWFMb2NhdGlvbiwgTlVMTCwKCU5VTEwsIDAsIG5vZGUsIHBjdHh0LT50YXJnZXROYW1lc3BhY2UsIE5VTEwsICZidWNrZXQpOwogICAgaWYgKHJlcyAhPSAwKQoJcmV0dXJuKHJlcyk7ICAgIAogICAgLyoKICAgICogSWYgd2UgZ2V0IG5vIHNjaGVtYSBidWNrZXQgYmFjaywgdGhlbiB0aGlzIG1lYW5zIHRoYXQgdGhlIHNjaGVtYQogICAgKiBkb2N1bWVudCBjb3VsZCBub3QgYmUgbG9jYXRlZCBvciB3YXMgYnJva2VuIFhNTCBvciB3YXMgbm90CiAgICAqIGEgc2NoZW1hIGRvY3VtZW50LgogICAgKi8gICAgCiAgICBpZiAoKGJ1Y2tldCA9PSBOVUxMKSB8fCAoYnVja2V0LT5kb2MgPT0gTlVMTCkpIHsKCWlmICh0eXBlID09IFhNTF9TQ0hFTUFfU0NIRU1BX0lOQ0xVREUpIHsKCSAgICAvKgoJICAgICogV0FSTklORyBmb3IgPGluY2x1ZGU+OgoJICAgICogV2Ugd2lsbCByYWlzZSBhbiBlcnJvciBpZiB0aGUgc2NoZW1hIGNhbm5vdCBiZSBsb2NhdGVkCgkgICAgKiBmb3IgaW5jbHVzaW9ucywgc2luY2UgdGhlIHRoYXQgd2FzIHRoZSBmZWVkYmFjayBmcm9tIHRoZQoJICAgICogc2NoZW1hIHBlb3BsZS4gSS5lLiB0aGUgZm9sbG93aW5nIHNwZWMgcGllY2Ugd2lsbCAqbm90KiBiZQoJICAgICogc2F0aXNmaWVkOgoJICAgICogU1BFQyBzcmMtaW5jbHVkZTogIkl0IGlzIG5vdCBhbiBlcnJvciBmb3IgdGhlILdhY3R1YWwgdmFsdWW3IG9mIHRoZQoJICAgICogc2NoZW1hTG9jYXRpb24gW2F0dHJpYnV0ZV0gdG8gZmFpbCB0byByZXNvbHZlIGl0IGFsbCwgaW4gd2hpY2gKCSAgICAqIGNhc2Ugbm8gY29ycmVzcG9uZGluZyBpbmNsdXNpb24gaXMgcGVyZm9ybWVkLgoJICAgICogU28gZG8gd2UgbmVlZCBhIHdhcm5pbmcgcmVwb3J0IGhlcmU/IgoJICAgICovCgkgICAgcmVzID0gWE1MX1NDSEVNQVBfU1JDX0lOQ0xVREU7CgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsIHJlcywKCQlub2RlLCBOVUxMLAoJCSJGYWlsZWQgdG8gbG9hZCB0aGUgZG9jdW1lbnQgJyVzJyBmb3IgaW5jbHVzaW9uIiwKCQlzY2hlbWFMb2NhdGlvbiwgTlVMTCk7Cgl9IGVsc2UgewoJICAgIC8qCgkgICAgKiBOT1RFOiBUaGlzIHdhcyBjaGFuZ2VkIHRvIHJhaXNlIGFuIGVycm9yIGV2ZW4gaWYgbm8gcmVkZWZpbml0aW9ucwoJICAgICogYXJlIHNwZWNpZmllZC4KCSAgICAqCgkgICAgKiBTUEVDIHNyYy1yZWRlZmluZSAoMSkKCSAgICAqICJJZiB0aGVyZSBhcmUgYW55IGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbXMgYW1vbmcgdGhlIFtjaGlsZHJlbl0KCSAgICAqIG90aGVyIHRoYW4gPGFubm90YXRpb24+IHRoZW4gdGhlILdhY3R1YWwgdmFsdWW3IG9mIHRoZQoJICAgICogc2NoZW1hTG9jYXRpb24gW2F0dHJpYnV0ZV0gbXVzdCBzdWNjZXNzZnVsbHkgcmVzb2x2ZS4iCgkgICAgKiBUT0RPOiBBc2sgdGhlIFdHIGlmIGEgdGhlIGxvY2F0aW9uIGhhcyBhbHdheXMgdG8gcmVzb2x2ZQoJICAgICogaGVyZSBhcyB3ZWxsIQoJICAgICovCgkgICAgcmVzID0gWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FOwoJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LCByZXMsCgkJbm9kZSwgTlVMTCwKCQkiRmFpbGVkIHRvIGxvYWQgdGhlIGRvY3VtZW50ICclcycgZm9yIHJlZGVmaW5pdGlvbiIsCgkJc2NoZW1hTG9jYXRpb24sIE5VTEwpOwoJfQogICAgfSBlbHNlIHsKCS8qCgkqIENoZWNrIHRhcmdldE5hbWVzcGFjZSBzYW5pdHkgYmVmb3JlIHBhcnNpbmcgdGhlIG5ldyBzY2hlbWEuCgkqIFRPRE86IE5vdGUgdGhhdCB3ZSB3b24ndCBjaGVjayBmdXJ0aGVyIGNvbnRlbnQgaWYgdGhlCgkqIHRhcmdldE5hbWVzcGFjZSB3YXMgYmFkLgoJKi8gICAgCglpZiAoYnVja2V0LT5vcmlnVGFyZ2V0TmFtZXNwYWNlICE9IE5VTEwpIHsJICAgIAoJICAgIC8qCgkgICAgKiBTUEVDIHNyYy1pbmNsdWRlICgyLjEpCgkgICAgKiAiU0lJIGhhcyBhIHRhcmdldE5hbWVzcGFjZSBbYXR0cmlidXRlXSwgYW5kIGl0cyC3YWN0dWFsCgkgICAgKiB2YWx1ZbcgaXMgaWRlbnRpY2FsIHRvIHRoZSC3YWN0dWFsIHZhbHVltyBvZiB0aGUgdGFyZ2V0TmFtZXNwYWNlCgkgICAgKiBbYXR0cmlidXRlXSBvZiBTSUmSICh3aGljaCBtdXN0IGhhdmUgc3VjaCBhbiBbYXR0cmlidXRlXSkuIgoJICAgICovCgkgICAgaWYgKHBjdHh0LT50YXJnZXROYW1lc3BhY2UgPT0gTlVMTCkgewoJCXhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TUkNfSU5DTFVERSwKCQkgICAgbm9kZSwgTlVMTCwKCQkgICAgIlRoZSB0YXJnZXQgbmFtZXNwYWNlIG9mIHRoZSBpbmNsdWRlZC9yZWRlZmluZWQgc2NoZW1hICIKCQkgICAgIiclcycgaGFzIHRvIGJlIGFic2VudCwgc2luY2UgdGhlIGluY2x1ZGluZy9yZWRlZmluaW5nICIKCQkgICAgInNjaGVtYSBoYXMgbm8gdGFyZ2V0IG5hbWVzcGFjZSIsCgkJICAgIHNjaGVtYUxvY2F0aW9uLCBOVUxMKTsKCQlnb3RvIGV4aXRfZXJyb3I7CgkgICAgfSBlbHNlIGlmICgheG1sU3RyRXF1YWwoYnVja2V0LT5vcmlnVGFyZ2V0TmFtZXNwYWNlLAoJCXBjdHh0LT50YXJnZXROYW1lc3BhY2UpKSB7CgkJLyogVE9ETzogQ2hhbmdlIGVycm9yIGZ1bmN0aW9uLiAqLwoJCXhtbFNjaGVtYVBDdXN0b21FcnJFeHQocGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1NSQ19JTkNMVURFLAoJCSAgICBOVUxMLCBub2RlLAoJCSAgICAiVGhlIHRhcmdldCBuYW1lc3BhY2UgJyVzJyBvZiB0aGUgaW5jbHVkZWQvcmVkZWZpbmVkICIKCQkgICAgInNjaGVtYSAnJXMnIGRpZmZlcnMgZnJvbSAnJXMnIG9mIHRoZSAiCgkJICAgICJpbmNsdWRpbmcvcmVkZWZpbmluZyBzY2hlbWEiLAoJCSAgICBidWNrZXQtPm9yaWdUYXJnZXROYW1lc3BhY2UsIHNjaGVtYUxvY2F0aW9uLAoJCSAgICBwY3R4dC0+dGFyZ2V0TmFtZXNwYWNlKTsKCQlnb3RvIGV4aXRfZXJyb3I7CgkgICAgfQoJfSBlbHNlIGlmIChwY3R4dC0+dGFyZ2V0TmFtZXNwYWNlICE9IE5VTEwpIHsJICAgIAoJICAgIC8qCgkgICAgKiBDaGFtZWxlb25zOiB0aGUgb3JpZ2luYWwgdGFyZ2V0IG5hbWVzcGFjZSB3aWxsCgkgICAgKiBkaWZmZXIgZnJvbSB0aGUgcmVzdWx0aW5nIG5hbWVzcGFjZS4KCSAgICAqLwoJICAgIGlzQ2hhbWVsZW9uID0gMTsKCSAgICBpZiAoYnVja2V0LT5wYXJzZWQgJiYKCQkoYnVja2V0LT50YXJnZXROYW1lc3BhY2UgIT0gcGN0eHQtPnRhcmdldE5hbWVzcGFjZSkpIHsKCQkvKgoJCSogVGhpcyBpcyBhIHNhbml0eSBjaGVjaywgSSBkdW5ubyB5ZXQgaWYgdGhpcyBjYW4gaGFwcGVuLgoJCSovCgkJUEVSUk9SX0lOVCgieG1sU2NoZW1hUGFyc2VJbmNsdWRlT3JSZWRlZmluZSIsCgkJICAgICJ0cnlpbmcgdG8gdXNlIGFuIGFscmVhZHkgcGFyc2VkIHNjaGVtYSBmb3IgYSAiCgkJICAgICJkaWZmZXJlbnQgdGFyZ2V0TmFtZXNwYWNlIik7CgkJcmV0dXJuKC0xKTsKCSAgICB9CgkgICAgYnVja2V0LT50YXJnZXROYW1lc3BhY2UgPSBwY3R4dC0+dGFyZ2V0TmFtZXNwYWNlOwoJfQogICAgfSAgICAKICAgIC8qCiAgICAqIFBhcnNlIHRoZSBzY2hlbWEuCiAgICAqLyAgIAogICAgaWYgKGJ1Y2tldCAmJiAoIWJ1Y2tldC0+cGFyc2VkKSAmJiAoYnVja2V0LT5kb2MgIT0gTlVMTCkpIHsKCWlmIChpc0NoYW1lbGVvbikgewoJICAgIC8qIFRPRE86IEdldCByaWQgb2YgdGhpcyBmbGFnIG9uIHRoZSBzY2hlbWEgaXRzZWxmLiAqLwoJICAgIGlmICgoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0lOQ0xVRElOR19DT05WRVJUX05TKSA9PSAwKSB7CgkJc2NoZW1hLT5mbGFncyB8PSBYTUxfU0NIRU1BU19JTkNMVURJTkdfQ09OVkVSVF9OUzsKCSAgICB9IGVsc2UKCQl3YXNDaGFtZWxlb24gPSAxOwoJfQoJeG1sU2NoZW1hUGFyc2VOZXdEb2MocGN0eHQsIHNjaGVtYSwgYnVja2V0KTsKCS8qIFJlc3RvcmUgY2hhbWVsZW9uIGZsYWcuICovCglpZiAoaXNDaGFtZWxlb24gJiYgKCF3YXNDaGFtZWxlb24pKQoJICAgIHNjaGVtYS0+ZmxhZ3MgXj0gWE1MX1NDSEVNQVNfSU5DTFVESU5HX0NPTlZFUlRfTlM7CiAgICB9CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOyAgICAKICAgIGlmICh0eXBlID09IFhNTF9TQ0hFTUFfU0NIRU1BX1JFREVGSU5FKSB7CQoJLyoKCSogUGFyc2UgKHNpbXBsZVR5cGUgfCBjb21wbGV4VHlwZSB8IGdyb3VwIHwgYXR0cmlidXRlR3JvdXApKSoKCSovCglwY3R4dC0+cmVkZWZpbmVkID0gYnVja2V0OwoJLyoKCSogSG93IHRvIHByb2NlZWQgaWYgdGhlIHJlZGVmaW5lZCBzY2hlbWEgd2FzIG5vdCBsb2NhdGVkPwoJKi8KCXBjdHh0LT5pc1JlZGVmaW5lID0gMTsKCXdoaWxlIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikgfHwKCSAgICBJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikgfHwKCSAgICBJU19TQ0hFTUEoY2hpbGQsICJjb21wbGV4VHlwZSIpIHx8CgkgICAgSVNfU0NIRU1BKGNoaWxkLCAiZ3JvdXAiKSB8fAoJICAgIElTX1NDSEVNQShjaGlsZCwgImF0dHJpYnV0ZUdyb3VwIikpIHsKCSAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CgkJLyoKCQkqIFRPRE86IGRpc2NhcmQgb3Igbm90PwoJCSovCgkgICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCQl4bWxTY2hlbWFQYXJzZVNpbXBsZVR5cGUocGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpOwoJICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiY29tcGxleFR5cGUiKSkgewoJCXhtbFNjaGVtYVBhcnNlQ29tcGxleFR5cGUocGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpOwoJCS8qIGhhc1JlZGVmaW5pdGlvbnMgPSAxOyAqLwoJICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiZ3JvdXAiKSkgewkJCgkJLyogaGFzUmVkZWZpbml0aW9ucyA9IDE7ICovCgkJeG1sU2NoZW1hUGFyc2VNb2RlbEdyb3VwRGVmaW5pdGlvbihwY3R4dCwKCQkgICAgc2NoZW1hLCBjaGlsZCk7CgkgICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhdHRyaWJ1dGVHcm91cCIpKSB7CgkJLyogaGFzUmVkZWZpbml0aW9ucyA9IDE7ICovCgkJeG1sU2NoZW1hUGFyc2VBdHRyaWJ1dGVHcm91cERlZmluaXRpb24ocGN0eHQsIHNjaGVtYSwKCQkgICAgY2hpbGQpOwoJICAgIH0KCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQoJcGN0eHQtPnJlZGVmaW5lZCA9IE5VTEw7CglwY3R4dC0+aXNSZWRlZmluZSA9IDA7CiAgICB9IGVsc2UgewoJaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewoJICAgIC8qCgkgICAgKiBUT0RPOiBkaXNjYXJkIG9yIG5vdD8KCSAgICAqLwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CiAgICB9ICAgIAogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKCXJlcyA9IFhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VEOwoJaWYgKHR5cGUgPT0gWE1MX1NDSEVNQV9TQ0hFTUFfUkVERUZJTkUpIHsKCSAgICB4bWxTY2hlbWFQQ29udGVudEVycihwY3R4dCwgcmVzLAoJCU5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLAoJCSIoYW5ub3RhdGlvbiB8IChzaW1wbGVUeXBlIHwgY29tcGxleFR5cGUgfCBncm91cCB8IGF0dHJpYnV0ZUdyb3VwKSkqIik7Cgl9IGVsc2UgewoJICAgICB4bWxTY2hlbWFQQ29udGVudEVycihwY3R4dCwgcmVzLAoJCU5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLAoJCSIoYW5ub3RhdGlvbj8pIik7Cgl9CQogICAgfSAgICAgICAKICAgIHJldHVybihyZXMpOwoKZXhpdF9lcnJvcjoKICAgIHJldHVybihwY3R4dC0+ZXJyKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZVJlZGVmaW5lKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsIHhtbFNjaGVtYVB0ciBzY2hlbWEsCiAgICAgICAgICAgICAgICAgICAgICAgeG1sTm9kZVB0ciBub2RlKQp7CiAgICBpbnQgcmVzOwojaWZuZGVmIEVOQUJMRV9SRURFRklORQogICAgVE9ETwogICAgcmV0dXJuKDApOwojZW5kaWYKICAgIHJlcyA9IHhtbFNjaGVtYVBhcnNlSW5jbHVkZU9yUmVkZWZpbmUocGN0eHQsIHNjaGVtYSwgbm9kZSwKCVhNTF9TQ0hFTUFfU0NIRU1BX1JFREVGSU5FKTsKICAgIGlmIChyZXMgIT0gMCkKCXJldHVybihyZXMpOwogICAgcmV0dXJuKDApOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlSW5jbHVkZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSkKewogICAgaW50IHJlczsKCiAgICByZXMgPSB4bWxTY2hlbWFQYXJzZUluY2x1ZGVPclJlZGVmaW5lKHBjdHh0LCBzY2hlbWEsIG5vZGUsCglYTUxfU0NIRU1BX1NDSEVNQV9JTkNMVURFKTsKICAgIGlmIChyZXMgIT0gMCkKCXJldHVybihyZXMpOwogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hUGFyc2VNb2RlbEdyb3VwOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqIEB0eXBlOiB0aGUgImNvbXBvc2l0b3IiIHR5cGUKICogQHBhcnRpY2xlTmVlZGVkOiBpZiBhIGEgbW9kZWwgZ3JvdXAgd2l0aCBhIHBhcnRpY2xlCiAqCiAqIHBhcnNlIGEgWE1MIHNjaGVtYSBTZXF1ZW5jZSBkZWZpbml0aW9uLgogKiBBcHBsaWVzIHBhcnRzIG9mOgogKiAgIFNjaGVtYSBSZXByZXNlbnRhdGlvbiBDb25zdHJhaW50OgogKiAgICAgUmVkZWZpbml0aW9uIENvbnN0cmFpbnRzIGFuZCBTZW1hbnRpY3MgKHNyYy1yZWRlZmluZSkKICogICAgICg2LjEpLCAoNi4xLjEpLCAoNi4xLjIpCiAqCiAqICAgU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiAKICogICAgIEFsbCBHcm91cCBMaW1pdGVkIChjb3MtYWxsLWxpbWl0ZWQpICgyKQogKiAgICAgVE9ETzogQWN0dWFsbHkgdGhpcyBzaG91bGQgZ28gdG8gY29tcG9uZW50LWxldmVsIGNoZWNrcywKICogICAgIGJ1dCBpcyBkb25lIGhlcmUgZHVlIHRvIHBlcmZvcm1hbmNlLiBNb3ZlIGl0IHRvIGFuIG90aGVyIGxheWVyCiAqICAgICBpcyBzY2hlbWEgY29uc3RydWN0aW9uIHZpYSBhbiBBUEkgaXMgaW1wbGVtZW50ZWQuCiAqCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyAtMSBpbiBjYXNlIG9mIGVycm9yLCAwIGlmIHRoZSBkZWNsYXJhdGlvbiBpcyBpbXByb3BlciBhbmQKICogICAgICAgICAxIGluIGNhc2Ugb2Ygc3VjY2Vzcy4KICovCnN0YXRpYyB4bWxTY2hlbWFUcmVlSXRlbVB0cgp4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkgeG1sTm9kZVB0ciBub2RlLCB4bWxTY2hlbWFUeXBlVHlwZSB0eXBlLAoJCQkgaW50IHdpdGhQYXJ0aWNsZSkKewogICAgeG1sU2NoZW1hTW9kZWxHcm91cFB0ciBpdGVtOwogICAgeG1sU2NoZW1hUGFydGljbGVQdHIgcGFydGljbGUgPSBOVUxMOwogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICB4bWxBdHRyUHRyIGF0dHI7CiAgICBpbnQgbWluID0gMSwgbWF4ID0gMSwgaXNFbGVtUmVmLCBoYXNSZWZzID0gMDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwogICAgLyoKICAgICogQ3JlYXRlIGEgbW9kZWwgZ3JvdXAgd2l0aCB0aGUgZ2l2ZW4gY29tcG9zaXRvci4KICAgICovCiAgICBpdGVtID0geG1sU2NoZW1hQWRkTW9kZWxHcm91cChjdHh0LCBzY2hlbWEsIHR5cGUsIG5vZGUpOwogICAgaWYgKGl0ZW0gPT0gTlVMTCkKCXJldHVybiAoTlVMTCk7CgogICAgaWYgKHdpdGhQYXJ0aWNsZSkgewoJaWYgKHR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0FMTCkgewoJICAgIG1pbiA9IHhtbEdldE1pbk9jY3VycyhjdHh0LCBub2RlLCAwLCAxLCAxLCAiKDAgfCAxKSIpOwoJICAgIG1heCA9IHhtbEdldE1heE9jY3VycyhjdHh0LCBub2RlLCAxLCAxLCAxLCAiMSIpOwoJfSBlbHNlIHsKCSAgICAvKiBjaG9pY2UgKyBzZXF1ZW5jZSAqLwoJICAgIG1pbiA9IHhtbEdldE1pbk9jY3VycyhjdHh0LCBub2RlLCAwLCAtMSwgMSwgInhzOm5vbk5lZ2F0aXZlSW50ZWdlciIpOwoJICAgIG1heCA9IHhtbEdldE1heE9jY3VycyhjdHh0LCBub2RlLCAwLCBVTkJPVU5ERUQsIDEsCgkJIih4czpub25OZWdhdGl2ZUludGVnZXIgfCB1bmJvdW5kZWQpIik7Cgl9Cgl4bWxTY2hlbWFQQ2hlY2tQYXJ0aWNsZUNvcnJlY3RfMihjdHh0LCBOVUxMLCBub2RlLCBtaW4sIG1heCk7CgkvKgoJKiBDcmVhdGUgYSBwYXJ0aWNsZQoJKi8KCXBhcnRpY2xlID0geG1sU2NoZW1hQWRkUGFydGljbGUoY3R4dCwgc2NoZW1hLCBub2RlLCBtaW4sIG1heCk7CglpZiAocGFydGljbGUgPT0gTlVMTCkKCSAgICByZXR1cm4gKE5VTEwpOwoJcGFydGljbGUtPmNoaWxkcmVuID0gKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSBpdGVtOwoJLyoKCSogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KCSovCglhdHRyID0gbm9kZS0+cHJvcGVydGllczsKCXdoaWxlIChhdHRyICE9IE5VTEwpIHsKCSAgICBpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJCWlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSAmJgoJCSAgICAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJtYXhPY2N1cnMiKSkgJiYKCQkgICAgKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibWluT2NjdXJzIikpKSB7CgkJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkJfQoJICAgIH0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJICAgIGF0dHIgPSBhdHRyLT5uZXh0OwoJfQogICAgfSBlbHNlIHsKCS8qCgkqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCgkqLwoJYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7Cgl3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CgkgICAgaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCQlpZiAoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSB7CgkJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkJfQoJICAgIH0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJICAgIGF0dHIgPSBhdHRyLT5uZXh0OwoJfQogICAgfQoKICAgIC8qCiAgICAqIEV4dHJhY3QgYW5kIHZhbGlkYXRlIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIC8qCiAgICAqIEFuZCBub3cgZm9yIHRoZSBjaGlsZHJlbi4uLgogICAgKi8KICAgIGNoaWxkID0gbm9kZS0+Y2hpbGRyZW47CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW5ub3RhdGlvbiIpKSB7CiAgICAgICAgaXRlbS0+YW5ub3QgPSB4bWxTY2hlbWFQYXJzZUFubm90YXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmICh0eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTEwpIHsKCXhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnQsIGxhc3QgPSBOVUxMOwoKCXdoaWxlIChJU19TQ0hFTUEoY2hpbGQsICJlbGVtZW50IikpIHsKCSAgICBwYXJ0ID0gKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSB4bWxTY2hlbWFQYXJzZUVsZW1lbnQoY3R4dCwKCQlzY2hlbWEsIGNoaWxkLCAmaXNFbGVtUmVmLCAwKTsKCSAgICAvKgoJICAgICogU1BFQyBjb3MtYWxsLWxpbWl0ZWQgKDIpCgkgICAgKiAiVGhlIHttYXggb2NjdXJzfSBvZiBhbGwgdGhlIHBhcnRpY2xlcyBpbiB0aGUge3BhcnRpY2xlc30KCSAgICAqIG9mIHRoZSAoJ2FsbCcpIGdyb3VwIG11c3QgYmUgMCBvciAxLgoJICAgICovCgkgICAgaWYgKHBhcnQgIT0gTlVMTCkgewoJCWlmIChpc0VsZW1SZWYpCgkJICAgIGhhc1JlZnMrKzsKCQlpZiAocGFydC0+bWluT2NjdXJzID4gMSkgewoJCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX0NPU19BTExfTElNSVRFRCwKCQkJTlVMTCwgY2hpbGQsCgkJCSJJbnZhbGlkIHZhbHVlIGZvciBtaW5PY2N1cnMgKG11c3QgYmUgMCBvciAxKSIsCgkJCU5VTEwpOwoJCSAgICAvKiBSZXNldCB0byAxLiAqLwoJCSAgICBwYXJ0LT5taW5PY2N1cnMgPSAxOwoJCX0KCQlpZiAocGFydC0+bWF4T2NjdXJzID4gMSkgewoJCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX0NPU19BTExfTElNSVRFRCwKCQkJTlVMTCwgY2hpbGQsCgkJCSJJbnZhbGlkIHZhbHVlIGZvciBtYXhPY2N1cnMgKG11c3QgYmUgMCBvciAxKSIsCgkJCU5VTEwpOwoJCSAgICAvKiBSZXNldCB0byAxLiAqLwoJCSAgICBwYXJ0LT5tYXhPY2N1cnMgPSAxOwoJCX0KCQlpZiAobGFzdCA9PSBOVUxMKQoJCSAgICBpdGVtLT5jaGlsZHJlbiA9ICh4bWxTY2hlbWFUcmVlSXRlbVB0cikgcGFydDsKCQllbHNlCgkJICAgIGxhc3QtPm5leHQgPSAoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpIHBhcnQ7CgkJbGFzdCA9IHBhcnQ7CgkgICAgfQoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CglpZiAoY2hpbGQgIT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkJTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkJIihhbm5vdGF0aW9uPywgKGFubm90YXRpb24/LCBlbGVtZW50KikiKTsKCX0KICAgIH0gZWxzZSB7CgkvKiBjaG9pY2UgKyBzZXF1ZW5jZSAqLwoJeG1sU2NoZW1hVHJlZUl0ZW1QdHIgcGFydCA9IE5VTEwsIGxhc3QgPSBOVUxMOwoKCXdoaWxlICgoSVNfU0NIRU1BKGNoaWxkLCAiZWxlbWVudCIpKSB8fAoJICAgIChJU19TQ0hFTUEoY2hpbGQsICJncm91cCIpKSB8fAoJICAgIChJU19TQ0hFTUEoY2hpbGQsICJhbnkiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAiY2hvaWNlIikpIHx8CgkgICAgKElTX1NDSEVNQShjaGlsZCwgInNlcXVlbmNlIikpKSB7CgoJICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJlbGVtZW50IikpIHsKCQlwYXJ0ID0gKHhtbFNjaGVtYVRyZWVJdGVtUHRyKQoJCSAgICB4bWxTY2hlbWFQYXJzZUVsZW1lbnQoY3R4dCwgc2NoZW1hLCBjaGlsZCwgJmlzRWxlbVJlZiwgMCk7CgkJaWYgKHBhcnQgJiYgaXNFbGVtUmVmKQoJCSAgICBoYXNSZWZzKys7CgkgICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJncm91cCIpKSB7CgkJcGFydCA9CgkJICAgIHhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cERlZlJlZihjdHh0LCBzY2hlbWEsIGNoaWxkKTsKCQlpZiAocGFydCAhPSBOVUxMKQoJCSAgICBoYXNSZWZzKys7CgkJLyoKCQkqIEhhbmRsZSByZWRlZmluaXRpb25zLgoJCSovCgkJaWYgKGN0eHQtPmlzUmVkZWZpbmUgJiYgY3R4dC0+cmVkZWYgJiYKCQkgICAgKGN0eHQtPnJlZGVmLT5pdGVtLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9HUk9VUCkgJiYKCQkgICAgcGFydCAmJiBwYXJ0LT5jaGlsZHJlbikKCQl7CgkJICAgIGlmICgoeG1sU2NoZW1hR2V0UU5hbWVSZWZOYW1lKHBhcnQtPmNoaWxkcmVuKSA9PQoJCQkgICAgY3R4dC0+cmVkZWYtPnJlZk5hbWUpICYmCgkJCSh4bWxTY2hlbWFHZXRRTmFtZVJlZlRhcmdldE5zKHBhcnQtPmNoaWxkcmVuKSA9PQoJCQkgICAgY3R4dC0+cmVkZWYtPnJlZlRhcmdldE5zKSkKCQkgICAgewoJCQkvKgoJCQkqIFNQRUMgc3JjLXJlZGVmaW5lOgoJCQkqICg2LjEpICJJZiBpdCBoYXMgYSA8Z3JvdXA+IGFtb25nIGl0cyBjb250ZW50cyBhdAoJCQkqIHNvbWUgbGV2ZWwgdGhlILdhY3R1YWwgdmFsdWW3IG9mIHdob3NlIHJlZgoJCQkqIFthdHRyaWJ1dGVdIGlzIHRoZSBzYW1lIGFzIHRoZSC3YWN0dWFsIHZhbHVltyBvZgoJCQkqIGl0cyBvd24gbmFtZSBhdHRyaWJ1dGUgcGx1cyB0YXJnZXQgbmFtZXNwYWNlLCB0aGVuCgkJCSogYWxsIG9mIHRoZSBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlOiIKCQkJKiAoNi4xLjEpICJJdCBtdXN0IGhhdmUgZXhhY3RseSBvbmUgc3VjaCBncm91cC4iCgkJCSovCgkJCWlmIChjdHh0LT5yZWRlZkNvdW50ZXIgIT0gMCkgewoJCQkgICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCgkJCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBjdHh0LAoJCQkJWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FLCBjaGlsZCwgTlVMTCwKCQkJCSJUaGUgcmVkZWZpbmluZyBtb2RlbCBncm91cCBkZWZpbml0aW9uICIKCQkJCSInJXMnIG11c3Qgbm90IGNvbnRhaW4gbW9yZSB0aGFuIG9uZSAiCgkJCQkicmVmZXJlbmNlIHRvIHRoZSByZWRlZmluZWQgZGVmaW5pdGlvbiIsCgkJCQl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCQkJICAgIGN0eHQtPnJlZGVmLT5yZWZUYXJnZXROcywKCQkJCSAgICBjdHh0LT5yZWRlZi0+cmVmTmFtZSksCgkJCQlOVUxMKTsKCQkJICAgIEZSRUVfQU5EX05VTEwoc3RyKQoJCQkgICAgcGFydCA9IE5VTEw7CgkJCX0gZWxzZSBpZiAoKChXWFNfUEFSVElDTEUocGFydCkpLT5taW5PY2N1cnMgIT0gMSkgfHwKCQkJICAgICgoV1hTX1BBUlRJQ0xFKHBhcnQpKS0+bWF4T2NjdXJzICE9IDEpKQoJCQl7CgkJCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJCQkgICAgLyoKCQkJICAgICogU1BFQyBzcmMtcmVkZWZpbmU6CgkJCSAgICAqICg2LjEuMikgIlRoZSC3YWN0dWFsIHZhbHVltyBvZiBib3RoIHRoYXQKCQkJICAgICogZ3JvdXAncyBtaW5PY2N1cnMgYW5kIG1heE9jY3VycyBbYXR0cmlidXRlXQoJCQkgICAgKiBtdXN0IGJlIDEgKG9yILdhYnNlbnS3KS4KCQkJICAgICovCgkJCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBjdHh0LAoJCQkJWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FLCBjaGlsZCwgTlVMTCwKCQkJCSJUaGUgcmVkZWZpbmluZyBtb2RlbCBncm91cCBkZWZpbml0aW9uICIKCQkJCSInJXMnIG11c3Qgbm90IGNvbnRhaW4gYSByZWZlcmVuY2UgdG8gdGhlICIKCQkJCSJyZWRlZmluZWQgZGVmaW5pdGlvbiB3aXRoIGEgIgoJCQkJIm1heE9jY3Vycy9taW5PY2N1cnMgb3RoZXIgdGhhbiAxIiwKCQkJCXhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkJCQkgICAgY3R4dC0+cmVkZWYtPnJlZlRhcmdldE5zLAoJCQkJICAgIGN0eHQtPnJlZGVmLT5yZWZOYW1lKSwKCQkJCU5VTEwpOwoJCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpCgkJCSAgICBwYXJ0ID0gTlVMTDsKCQkJfQoJCQljdHh0LT5yZWRlZi0+cmVmZXJlbmNlID0gV1hTX0JBU0lDX0NBU1QgcGFydDsKCQkJY3R4dC0+cmVkZWZDb3VudGVyKys7CgkJICAgIH0JCSAgICAgICAgCQkgICAKCQl9CgkgICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbnkiKSkgewoJCXBhcnQgPSAoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpCgkJICAgIHhtbFNjaGVtYVBhcnNlQW55KGN0eHQsIHNjaGVtYSwgY2hpbGQpOwoJICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiY2hvaWNlIikpIHsKCQlwYXJ0ID0geG1sU2NoZW1hUGFyc2VNb2RlbEdyb3VwKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkJICAgIFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0UsIDEpOwoJICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAic2VxdWVuY2UiKSkgewoJCXBhcnQgPSB4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoY3R4dCwgc2NoZW1hLCBjaGlsZCwKCQkgICAgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFLCAxKTsKCSAgICB9CgkgICAgaWYgKHBhcnQgIT0gTlVMTCkgewoJCWlmIChsYXN0ID09IE5VTEwpCgkJICAgIGl0ZW0tPmNoaWxkcmVuID0gcGFydDsKCQllbHNlCgkJICAgIGxhc3QtPm5leHQgPSBwYXJ0OwoJCWxhc3QgPSBwYXJ0OwoJICAgIH0KCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQoJaWYgKGNoaWxkICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19FTEVNX05PVF9BTExPV0VELAoJCU5VTEwsIG5vZGUsIGNoaWxkLCBOVUxMLAoJCSIoYW5ub3RhdGlvbj8sIChlbGVtZW50IHwgZ3JvdXAgfCBjaG9pY2UgfCBzZXF1ZW5jZSB8IGFueSkqKSIpOwoJfQogICAgfQogICAgaWYgKChtYXggPT0gMCkgJiYgKG1pbiA9PSAwKSkKCXJldHVybiAoTlVMTCk7CiAgICBpZiAoaGFzUmVmcykgewoJLyoKCSogV2UgbmVlZCB0byByZXNvbHZlIHJlZmVyZW5jZXMuCgkqLwoJV1hTX0FERF9QRU5ESU5HKGN0eHQsIGl0ZW0pOwogICAgfQogICAgaWYgKHdpdGhQYXJ0aWNsZSkKCXJldHVybiAoKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSBwYXJ0aWNsZSk7CQogICAgZWxzZQoJcmV0dXJuICgoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpIGl0ZW0pOwp9CgovKioKICogeG1sU2NoZW1hUGFyc2VSZXN0cmljdGlvbjoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgUmVzdHJpY3Rpb24gZGVmaW5pdGlvbgogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgdGhlIHR5cGUgZGVmaW5pdGlvbiBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFUeXBlUHRyCnhtbFNjaGVtYVBhcnNlUmVzdHJpY3Rpb24oeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSwgeG1sU2NoZW1hVHlwZVR5cGUgcGFyZW50VHlwZSkKewogICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlOwogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICB4bWxBdHRyUHRyIGF0dHI7CgogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChzY2hlbWEgPT0gTlVMTCkgfHwgKG5vZGUgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIC8qIE5vdCBhIGNvbXBvbmVudCwgZG9uJ3QgY3JlYXRlIGl0LiAqLwogICAgdHlwZSA9IGN0eHQtPmN0eHRUeXBlOwogICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9ERVJJVkFUSU9OX01FVEhPRF9SRVNUUklDVElPTjsKCiAgICAvKgogICAgKiBDaGVjayBmb3IgaWxsZWdhbCBhdHRyaWJ1dGVzLgogICAgKi8KICAgIGF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwogICAgd2hpbGUgKGF0dHIgIT0gTlVMTCkgewoJaWYgKGF0dHItPm5zID09IE5VTEwpIHsKCSAgICBpZiAoKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgJiYKCQkoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJiYXNlIikpKSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7Cgl9CglhdHRyID0gYXR0ci0+bmV4dDsKICAgIH0KICAgIC8qCiAgICAqIEV4dHJhY3QgYW5kIHZhbGlkYXRlIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKICAgIC8qCiAgICAqIEF0dHJpYnV0ZSAKICAgICovCiAgICAvKgogICAgKiBFeHRyYWN0IHRoZSBiYXNlIHR5cGUuIFRoZSAiYmFzZSIgYXR0cmlidXRlIGlzIG1hbmRhdG9yeSBpZiBpbnNpZGUKICAgICogYSBjb21wbGV4IHR5cGUgb3IgaWYgcmVkZWZpbmluZy4KICAgICoKICAgICogU1BFQyAoMS4yKSAiLi4ub3RoZXJ3aXNlICg8cmVzdHJpY3Rpb24+IGhhcyBubyA8c2ltcGxlVHlwZT4gIgogICAgKiBhbW9uZyBpdHMgW2NoaWxkcmVuXSksIHRoZSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIHdoaWNoIGlzCiAgICAqIHRoZSB7Y29udGVudCB0eXBlfSBvZiB0aGUgdHlwZSBkZWZpbml0aW9uILdyZXNvbHZlZLcgdG8gYnkKICAgICogdGhlILdhY3R1YWwgdmFsdWW3IG9mIHRoZSBiYXNlIFthdHRyaWJ1dGVdIgogICAgKi8KICAgIGlmICh4bWxTY2hlbWFQVmFsQXR0clFOYW1lKGN0eHQsIHNjaGVtYSwgTlVMTCwgbm9kZSwgImJhc2UiLAoJJih0eXBlLT5iYXNlTnMpLCAmKHR5cGUtPmJhc2UpKSA9PSAwKQogICAgewoJaWYgKCh0eXBlLT5iYXNlID09IE5VTEwpICYmICh0eXBlLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYKSkgewoJICAgIHhtbFNjaGVtYVBNaXNzaW5nQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX01JU1NJTkcsCgkJTlVMTCwgbm9kZSwgImJhc2UiLCBOVUxMKTsKCX0gZWxzZSBpZiAoKGN0eHQtPmlzUmVkZWZpbmUpICYmCgkgICAgKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9HTE9CQUwpKQoJewoJICAgIGlmICh0eXBlLT5iYXNlID09IE5VTEwpIHsKCQl4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTUlTU0lORywKCQkgICAgTlVMTCwgbm9kZSwgImJhc2UiLCBOVUxMKTsKCSAgICB9IGVsc2UgaWYgKCghIHhtbFN0ckVxdWFsKHR5cGUtPmJhc2UsIHR5cGUtPm5hbWUpKSB8fAoJCSghIHhtbFN0ckVxdWFsKHR5cGUtPmJhc2VOcywgdHlwZS0+dGFyZ2V0TmFtZXNwYWNlKSkpCgkgICAgewoJCXhtbENoYXIgKnN0cjEgPSBOVUxMLCAqc3RyMiA9IE5VTEw7CgkJLyoKCQkqIFJFREVGSU5FOiBTUEVDIHNyYy1yZWRlZmluZSAoNSkKCQkqICJXaXRoaW4gdGhlIFtjaGlsZHJlbl0sIGVhY2ggPHNpbXBsZVR5cGU+IG11c3QgaGF2ZSBhCgkJKiA8cmVzdHJpY3Rpb24+IGFtb25nIGl0cyBbY2hpbGRyZW5dIC4uLiB0aGUgt2FjdHVhbCB2YWx1Zbcgb2YKCQkqIHdob3NlIGJhc2UgW2F0dHJpYnV0ZV0gbXVzdCBiZSB0aGUgc2FtZSBhcyB0aGUgt2FjdHVhbCB2YWx1ZbcKCQkqIG9mIGl0cyBvd24gbmFtZSBhdHRyaWJ1dGUgcGx1cyB0YXJnZXQgbmFtZXNwYWNlOyIKCQkqLwoJCXhtbFNjaGVtYVBDdXN0b21FcnJFeHQoY3R4dCwgWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FLAoJCSAgICBOVUxMLCBub2RlLCAiVGhpcyBpcyBhIHJlZGVmaW5pdGlvbiwgYnV0IHRoZSBRTmFtZSAiCgkJICAgICJ2YWx1ZSAnJXMnIG9mIHRoZSAnYmFzZScgYXR0cmlidXRlIGRvZXMgbm90IG1hdGNoIHRoZSAiCgkJICAgICJ0eXBlJ3MgZGVzaWduYXRpb24gJyVzJyIsCgkJICAgIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIxLCB0eXBlLT5iYXNlTnMsIHR5cGUtPmJhc2UpLAoJCSAgICB4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyMSwgdHlwZS0+dGFyZ2V0TmFtZXNwYWNlLAoJCQl0eXBlLT5uYW1lKSwgTlVMTCk7CgkJRlJFRV9BTkRfTlVMTChzdHIxKTsKCQlGUkVFX0FORF9OVUxMKHN0cjIpOwoJCS8qIEF2b2lkIGNvbmZ1c2lvbiBhbmQgZXJhc2UgdGhlIHZhbHVlcy4gKi8KCQl0eXBlLT5iYXNlID0gTlVMTDsKCQl0eXBlLT5iYXNlTnMgPSBOVUxMOwoJICAgIH0KCX0JCQogICAgfQogICAgLyoKICAgICogQW5kIG5vdyBmb3IgdGhlIGNoaWxkcmVuLi4uCiAgICAqLwogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCS8qCgkqIEFkZCB0aGUgYW5ub3RhdGlvbiB0byB0aGUgc2ltcGxlIHR5cGUgYW5jZXN0b3IuCgkqLwoJeG1sU2NoZW1hQWRkQW5ub3RhdGlvbigoeG1sU2NoZW1hQW5ub3RJdGVtUHRyKSB0eXBlLAoJICAgIHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChwYXJlbnRUeXBlID09IFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUpIHsKCS8qCgkqIENvcnJlc3BvbmRzIHRvIDxzaW1wbGVUeXBlPjxyZXN0cmljdGlvbj48c2ltcGxlVHlwZT4uCgkqLwoJaWYgKElTX1NDSEVNQShjaGlsZCwgInNpbXBsZVR5cGUiKSkgewoJICAgIGlmICh0eXBlLT5iYXNlICE9IE5VTEwpIHsKCQkvKgoJCSogc3JjLXJlc3RyaWN0aW9uLWJhc2Utb3Itc2ltcGxlVHlwZQoJCSogRWl0aGVyIHRoZSBiYXNlIFthdHRyaWJ1dGVdIG9yIHRoZSBzaW1wbGVUeXBlIFtjaGlsZF0gb2YgdGhlCgkJKiA8cmVzdHJpY3Rpb24+IGVsZW1lbnQgbXVzdCBiZSBwcmVzZW50LCBidXQgbm90IGJvdGguCgkJKi8KCQl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TUkNfUkVTVFJJQ1RJT05fQkFTRV9PUl9TSU1QTEVUWVBFLAoJCSAgICBOVUxMLCBub2RlLCBjaGlsZCwKCQkgICAgIlRoZSBhdHRyaWJ1dGUgJ2Jhc2UnIGFuZCB0aGUgPHNpbXBsZVR5cGU+IGNoaWxkIGFyZSAiCgkJICAgICJtdXR1YWxseSBleGNsdXNpdmUiLCBOVUxMKTsKCSAgICB9IGVsc2UgewoJCXR5cGUtPmJhc2VUeXBlID0gKHhtbFNjaGVtYVR5cGVQdHIpCgkJICAgIHhtbFNjaGVtYVBhcnNlU2ltcGxlVHlwZShjdHh0LCBzY2hlbWEsIGNoaWxkLCAwKTsKCSAgICB9CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAodHlwZS0+YmFzZSA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TUkNfUkVTVFJJQ1RJT05fQkFTRV9PUl9TSU1QTEVUWVBFLAoJCU5VTEwsIG5vZGUsIGNoaWxkLAoJCSJFaXRoZXIgdGhlIGF0dHJpYnV0ZSAnYmFzZScgb3IgYSA8c2ltcGxlVHlwZT4gY2hpbGQgIgoJCSJtdXN0IGJlIHByZXNlbnQiLCBOVUxMKTsKCX0KICAgIH0gZWxzZSBpZiAocGFyZW50VHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWF9DT05URU5UKSB7CgkvKgoJKiBDb3JyZXNwb25kcyB0byA8Y29tcGxleFR5cGU+PGNvbXBsZXhDb250ZW50PjxyZXN0cmljdGlvbj4uLi4KCSogZm9sbG93ZWQgYnk6CgkqCgkqIE1vZGVsIGdyb3VwcyA8YWxsPiwgPGNob2ljZT4gYW5kIDxzZXF1ZW5jZT4uCgkqLwoJaWYgKElTX1NDSEVNQShjaGlsZCwgImFsbCIpKSB7CgkgICAgdHlwZS0+c3VidHlwZXMgPSAoeG1sU2NoZW1hVHlwZVB0cikKCQl4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoY3R4dCwgc2NoZW1hLCBjaGlsZCwKCQkgICAgWE1MX1NDSEVNQV9UWVBFX0FMTCwgMSk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiY2hvaWNlIikpIHsKCSAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cChjdHh0LAoJCSAgICBzY2hlbWEsIGNoaWxkLCBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFLCAxKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzZXF1ZW5jZSIpKSB7CgkgICAgdHlwZS0+c3VidHlwZXMgPSAoeG1sU2NoZW1hVHlwZVB0cikKCQl4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoY3R4dCwgc2NoZW1hLCBjaGlsZCwKCQkgICAgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFLCAxKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJLyoKCSogTW9kZWwgZ3JvdXAgcmVmZXJlbmNlIDxncm91cD4uCgkqLwoJfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJncm91cCIpKSB7CSAgICAKCSAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cERlZlJlZihjdHh0LCBzY2hlbWEsIGNoaWxkKTsKCSAgICAvKgoJICAgICogTm90ZSB0aGF0IHRoZSByZWZlcmVuY2Ugd2lsbCBiZSByZXNvbHZlZCBpbgoJICAgICogeG1sU2NoZW1hUmVzb2x2ZVR5cGVSZWZlcmVuY2VzKCk7CgkgICAgKi8KCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQogICAgfSBlbHNlIGlmIChwYXJlbnRUeXBlID09IFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEVfQ09OVEVOVCkgewoJLyoKCSogQ29ycmVzcG9uZHMgdG8gPGNvbXBsZXhUeXBlPjxzaW1wbGVDb250ZW50PjxyZXN0cmljdGlvbj4uLi4KCSoKCSogIjEuMSB0aGUgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbiBjb3JyZXNwb25kaW5nIHRvIHRoZSA8c2ltcGxlVHlwZT4KCSogYW1vbmcgdGhlIFtjaGlsZHJlbl0gb2YgPHJlc3RyaWN0aW9uPiBpZiB0aGVyZSBpcyBvbmU7IgoJKi8KCWlmIChJU19TQ0hFTUEoY2hpbGQsICJzaW1wbGVUeXBlIikpIHsKCSAgICAvKgoJICAgICogV2Ugd2lsbCBzdG9yZSB0aGUgdG8tYmUtcmVzdHJpY3RlZCBzaW1wbGUgdHlwZSBpbgoJICAgICogdHlwZS0+Y29udGVudFR5cGVEZWYgKnRlbXBvcmFyaWx5Ki4KCSAgICAqLwoJICAgIHR5cGUtPmNvbnRlbnRUeXBlRGVmID0gKHhtbFNjaGVtYVR5cGVQdHIpCgkJeG1sU2NoZW1hUGFyc2VTaW1wbGVUeXBlKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDApOwoJICAgIGlmICggdHlwZS0+Y29udGVudFR5cGVEZWYgPT0gTlVMTCkKCQlyZXR1cm4gKE5VTEwpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CiAgICB9CgogICAgaWYgKChwYXJlbnRUeXBlID09IFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUpIHx8CgkocGFyZW50VHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFX0NPTlRFTlQpKSB7Cgl4bWxTY2hlbWFGYWNldFB0ciBmYWNldCwgbGFzdGZhY2V0ID0gTlVMTDsKCS8qCgkqIENvcnJlc3BvbmRzIHRvIDxjb21wbGV4VHlwZT48c2ltcGxlQ29udGVudD48cmVzdHJpY3Rpb24+Li4uCgkqIDxzaW1wbGVUeXBlPjxyZXN0cmljdGlvbj4uLi4KCSovCgoJLyoKCSogQWRkIHRoZSBmYWNldHMgdG8gdGhlIHNpbXBsZSB0eXBlIGFuY2VzdG9yLgoJKi8KCS8qCgkqIFRPRE86IERhdGF0eXBlczogNC4xLjMgQ29uc3RyYWludHMgb24gWE1MIFJlcHJlc2VudGF0aW9uIG9mCgkqIFNpbXBsZSBUeXBlIERlZmluaXRpb24gU2NoZW1hIFJlcHJlc2VudGF0aW9uIENvbnN0cmFpbnQ6CgkqICpTaW5nbGUgRmFjZXQgVmFsdWUqCgkqLwoJd2hpbGUgKChJU19TQ0hFTUEoY2hpbGQsICJtaW5JbmNsdXNpdmUiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAibWluRXhjbHVzaXZlIikpIHx8CgkgICAgKElTX1NDSEVNQShjaGlsZCwgIm1heEluY2x1c2l2ZSIpKSB8fAoJICAgIChJU19TQ0hFTUEoY2hpbGQsICJtYXhFeGNsdXNpdmUiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAidG90YWxEaWdpdHMiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAiZnJhY3Rpb25EaWdpdHMiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAicGF0dGVybiIpKSB8fAoJICAgIChJU19TQ0hFTUEoY2hpbGQsICJlbnVtZXJhdGlvbiIpKSB8fAoJICAgIChJU19TQ0hFTUEoY2hpbGQsICJ3aGl0ZVNwYWNlIikpIHx8CgkgICAgKElTX1NDSEVNQShjaGlsZCwgImxlbmd0aCIpKSB8fAoJICAgIChJU19TQ0hFTUEoY2hpbGQsICJtYXhMZW5ndGgiKSkgfHwKCSAgICAoSVNfU0NIRU1BKGNoaWxkLCAibWluTGVuZ3RoIikpKSB7CgkgICAgZmFjZXQgPSB4bWxTY2hlbWFQYXJzZUZhY2V0KGN0eHQsIHNjaGVtYSwgY2hpbGQpOwoJICAgIGlmIChmYWNldCAhPSBOVUxMKSB7CgkJaWYgKGxhc3RmYWNldCA9PSBOVUxMKQoJCSAgICB0eXBlLT5mYWNldHMgPSBmYWNldDsKCQllbHNlCgkJICAgIGxhc3RmYWNldC0+bmV4dCA9IGZhY2V0OwoJCWxhc3RmYWNldCA9IGZhY2V0OwoJCWxhc3RmYWNldC0+bmV4dCA9IE5VTEw7CgkgICAgfQoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CgkvKgoJKiBDcmVhdGUgbGlua3MgZm9yIGRlcml2YXRpb24gYW5kIHZhbGlkYXRpb24uCgkqLwoJaWYgKHR5cGUtPmZhY2V0cyAhPSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hRmFjZXRMaW5rUHRyIGZhY2V0TGluaywgbGFzdEZhY2V0TGluayA9IE5VTEw7CgoJICAgIGZhY2V0ID0gdHlwZS0+ZmFjZXRzOwoJICAgIGRvIHsKCQlmYWNldExpbmsgPSAoeG1sU2NoZW1hRmFjZXRMaW5rUHRyKQoJCSAgICB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYUZhY2V0TGluaykpOwoJCWlmIChmYWNldExpbmsgPT0gTlVMTCkgewoJCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIGEgZmFjZXQgbGluayIsIE5VTEwpOwoJCSAgICB4bWxGcmVlKGZhY2V0TGluayk7CgkJICAgIHJldHVybiAoTlVMTCk7CgkJfQoJCWZhY2V0TGluay0+ZmFjZXQgPSBmYWNldDsKCQlmYWNldExpbmstPm5leHQgPSBOVUxMOwoJCWlmIChsYXN0RmFjZXRMaW5rID09IE5VTEwpCgkJICAgIHR5cGUtPmZhY2V0U2V0ID0gZmFjZXRMaW5rOwoJCWVsc2UKCQkgICAgbGFzdEZhY2V0TGluay0+bmV4dCA9IGZhY2V0TGluazsKCQlsYXN0RmFjZXRMaW5rID0gZmFjZXRMaW5rOwoJCWZhY2V0ID0gZmFjZXQtPm5leHQ7CgkgICAgfSB3aGlsZSAoZmFjZXQgIT0gTlVMTCk7Cgl9CiAgICB9CiAgICBpZiAodHlwZS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWCkgewoJLyoKCSogQXR0cmlidXRlIHVzZXMvZGVjbGFyYXRpb25zLgoJKi8KCWlmICh4bWxTY2hlbWFQYXJzZUxvY2FsQXR0cmlidXRlcyhjdHh0LCBzY2hlbWEsICZjaGlsZCwKCSAgICAoeG1sU2NoZW1hSXRlbUxpc3RQdHIgKikgJih0eXBlLT5hdHRyVXNlcyksCgkgICAgWE1MX1NDSEVNQV9UWVBFX1JFU1RSSUNUSU9OLCBOVUxMKSA9PSAtMSkKCSAgICByZXR1cm4oTlVMTCk7CgkvKgoJKiBBdHRyaWJ1dGUgd2lsZGNhcmQuCgkqLwoJaWYgKElTX1NDSEVNQShjaGlsZCwgImFueUF0dHJpYnV0ZSIpKSB7CgkgICAgdHlwZS0+YXR0cmlidXRlV2lsZGNhcmQgPQoJCXhtbFNjaGVtYVBhcnNlQW55QXR0cmlidXRlKGN0eHQsIHNjaGVtYSwgY2hpbGQpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJaWYgKHBhcmVudFR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVhfQ09OVEVOVCkgewoJICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkJTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkJImFubm90YXRpb24/LCAoZ3JvdXAgfCBhbGwgfCBjaG9pY2UgfCBzZXF1ZW5jZSk/LCAiCgkJIigoYXR0cmlidXRlIHwgYXR0cmlidXRlR3JvdXApKiwgYW55QXR0cmlidXRlPykpIik7Cgl9IGVsc2UgaWYgKHBhcmVudFR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX1NJTVBMRV9DT05URU5UKSB7CgkgICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkJTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkJIihhbm5vdGF0aW9uPywgKHNpbXBsZVR5cGU/LCAobWluRXhjbHVzaXZlIHwgbWluSW5jbHVzaXZlIHwgIgoJCSJtYXhFeGNsdXNpdmUgfCBtYXhJbmNsdXNpdmUgfCB0b3RhbERpZ2l0cyB8IGZyYWN0aW9uRGlnaXRzIHwgIgoJCSJsZW5ndGggfCBtaW5MZW5ndGggfCBtYXhMZW5ndGggfCBlbnVtZXJhdGlvbiB8IHdoaXRlU3BhY2UgfCAiCgkJInBhdHRlcm4pKik/LCAoKGF0dHJpYnV0ZSB8IGF0dHJpYnV0ZUdyb3VwKSosIGFueUF0dHJpYnV0ZT8pKSIpOwoJfSBlbHNlIHsKCSAgICAvKiBTaW1wbGUgdHlwZSAqLwoJICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkJTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkJIihhbm5vdGF0aW9uPywgKHNpbXBsZVR5cGU/LCAobWluRXhjbHVzaXZlIHwgbWluSW5jbHVzaXZlIHwgIgoJCSJtYXhFeGNsdXNpdmUgfCBtYXhJbmNsdXNpdmUgfCB0b3RhbERpZ2l0cyB8IGZyYWN0aW9uRGlnaXRzIHwgIgoJCSJsZW5ndGggfCBtaW5MZW5ndGggfCBtYXhMZW5ndGggfCBlbnVtZXJhdGlvbiB8IHdoaXRlU3BhY2UgfCAiCgkJInBhdHRlcm4pKikpIik7Cgl9CiAgICB9CiAgICByZXR1cm4gKE5VTEwpOwp9CgovKioKICogeG1sU2NoZW1hUGFyc2VFeHRlbnNpb246CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogUGFyc2VzIGFuIDxleHRlbnNpb24+LCB3aGljaCBpcyBmb3VuZCBpbnNpZGUgYQogKiA8c2ltcGxlQ29udGVudD4gb3IgPGNvbXBsZXhDb250ZW50Pi4KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZS4KICoKICogVE9ETzogUmV0dXJucyB0aGUgdHlwZSBkZWZpbml0aW9uIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8Kc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIKeG1sU2NoZW1hUGFyc2VFeHRlbnNpb24oeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgICB4bWxOb2RlUHRyIG5vZGUsIHhtbFNjaGVtYVR5cGVUeXBlIHBhcmVudFR5cGUpCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpKQogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICAvKiBOb3QgYSBjb21wb25lbnQsIGRvbid0IGNyZWF0ZSBpdC4gKi8KICAgIHR5cGUgPSBjdHh0LT5jdHh0VHlwZTsKICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfREVSSVZBVElPTl9NRVRIT0RfRVhURU5TSU9OOwoKICAgIC8qCiAgICAqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSAmJgoJCSgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImJhc2UiKSkpIHsKCQl4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnMtPmhyZWYsIHhtbFNjaGVtYU5zKSkgewoJICAgIHhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCX0KCWF0dHIgPSBhdHRyLT5uZXh0OwogICAgfQoKICAgIHhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CgogICAgLyoKICAgICogQXR0cmlidXRlICJiYXNlIiAtIG1hbmRhdG9yeS4KICAgICovCiAgICBpZiAoKHhtbFNjaGVtYVBWYWxBdHRyUU5hbWUoY3R4dCwgc2NoZW1hLCBOVUxMLCBub2RlLAoJImJhc2UiLCAmKHR5cGUtPmJhc2VOcyksICYodHlwZS0+YmFzZSkpID09IDApICYmCgkodHlwZS0+YmFzZSA9PSBOVUxMKSkgewoJeG1sU2NoZW1hUE1pc3NpbmdBdHRyRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfTUlTU0lORywKCSAgICBOVUxMLCBub2RlLCAiYmFzZSIsIE5VTEwpOwogICAgfQogICAgLyoKICAgICogQW5kIG5vdyBmb3IgdGhlIGNoaWxkcmVuLi4uCiAgICAqLwogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCS8qCgkqIEFkZCB0aGUgYW5ub3RhdGlvbiB0byB0aGUgdHlwZSBhbmNlc3Rvci4KCSovCgl4bWxTY2hlbWFBZGRBbm5vdGF0aW9uKCh4bWxTY2hlbWFBbm5vdEl0ZW1QdHIpIHR5cGUsCgkgICAgeG1sU2NoZW1hUGFyc2VBbm5vdGF0aW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpKTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKHBhcmVudFR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVhfQ09OVEVOVCkgewoJLyoKCSogQ29ycmVzcG9uZHMgdG8gPGNvbXBsZXhUeXBlPjxjb21wbGV4Q29udGVudD48ZXh0ZW5zaW9uPi4uLiBhbmQ6CgkqCgkqIE1vZGVsIGdyb3VwcyA8YWxsPiwgPGNob2ljZT4sIDxzZXF1ZW5jZT4gYW5kIDxncm91cD4uCgkqLwoJaWYgKElTX1NDSEVNQShjaGlsZCwgImFsbCIpKSB7CgkgICAgdHlwZS0+c3VidHlwZXMgPSAoeG1sU2NoZW1hVHlwZVB0cikKCQl4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoY3R4dCwgc2NoZW1hLAoJCSAgICBjaGlsZCwgWE1MX1NDSEVNQV9UWVBFX0FMTCwgMSk7CgkgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKCX0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiY2hvaWNlIikpIHsKCSAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cChjdHh0LCBzY2hlbWEsCgkJICAgIGNoaWxkLCBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFLCAxKTsKCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJzZXF1ZW5jZSIpKSB7CgkgICAgdHlwZS0+c3VidHlwZXMgPSAoeG1sU2NoZW1hVHlwZVB0cikKCQl4bWxTY2hlbWFQYXJzZU1vZGVsR3JvdXAoY3R4dCwgc2NoZW1hLAoJCWNoaWxkLCBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UsIDEpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgImdyb3VwIikpIHsKCSAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cERlZlJlZihjdHh0LCBzY2hlbWEsIGNoaWxkKTsKCSAgICAvKgoJICAgICogTm90ZSB0aGF0IHRoZSByZWZlcmVuY2Ugd2lsbCBiZSByZXNvbHZlZCBpbgoJICAgICogeG1sU2NoZW1hUmVzb2x2ZVR5cGVSZWZlcmVuY2VzKCk7CgkgICAgKi8KCSAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwoJfQogICAgfQogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKCS8qCgkqIEF0dHJpYnV0ZSB1c2VzL2RlY2xhcmF0aW9ucy4KCSovCglpZiAoeG1sU2NoZW1hUGFyc2VMb2NhbEF0dHJpYnV0ZXMoY3R4dCwgc2NoZW1hLCAmY2hpbGQsCgkgICAgKHhtbFNjaGVtYUl0ZW1MaXN0UHRyICopICYodHlwZS0+YXR0clVzZXMpLAoJICAgIFhNTF9TQ0hFTUFfVFlQRV9FWFRFTlNJT04sIE5VTEwpID09IC0xKQoJICAgIHJldHVybihOVUxMKTsKCS8qCgkqIEF0dHJpYnV0ZSB3aWxkY2FyZC4KCSovCglpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW55QXR0cmlidXRlIikpIHsKCSAgICBjdHh0LT5jdHh0VHlwZS0+YXR0cmlidXRlV2lsZGNhcmQgPQoJCXhtbFNjaGVtYVBhcnNlQW55QXR0cmlidXRlKGN0eHQsIHNjaGVtYSwgY2hpbGQpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJaWYgKHBhcmVudFR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVhfQ09OVEVOVCkgewoJICAgIC8qIENvbXBsZXggY29udGVudCBleHRlbnNpb24uICovCgkgICAgeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCQlOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCQkiKGFubm90YXRpb24/LCAoKGdyb3VwIHwgYWxsIHwgY2hvaWNlIHwgc2VxdWVuY2UpPywgIgoJCSIoKGF0dHJpYnV0ZSB8IGF0dHJpYnV0ZUdyb3VwKSosIGFueUF0dHJpYnV0ZT8pKSkiKTsKCX0gZWxzZSB7CgkgICAgLyogU2ltcGxlIGNvbnRlbnQgZXh0ZW5zaW9uLiAqLwoJICAgIHhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkJTlVMTCwgbm9kZSwgY2hpbGQsIE5VTEwsCgkJIihhbm5vdGF0aW9uPywgKChhdHRyaWJ1dGUgfCBhdHRyaWJ1dGVHcm91cCkqLCAiCgkJImFueUF0dHJpYnV0ZT8pKSIpOwoJfQogICAgfQogICAgcmV0dXJuIChOVUxMKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlU2ltcGxlQ29udGVudDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogIHRoZSBzY2hlbWEgYmVpbmcgYnVpbHQKICogQG5vZGU6ICBhIHN1YnRyZWUgY29udGFpbmluZyBYTUwgU2NoZW1hIGluZm9ybWF0aW9ucwogKgogKiBwYXJzZSBhIFhNTCBzY2hlbWEgU2ltcGxlQ29udGVudCBkZWZpbml0aW9uCiAqICpXQVJOSU5HKiB0aGlzIGludGVyZmFjZSBpcyBoaWdobHkgc3ViamVjdCB0byBjaGFuZ2UKICoKICogUmV0dXJucyB0aGUgdHlwZSBkZWZpbml0aW9uIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZVNpbXBsZUNvbnRlbnQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1sU2NoZW1hUHRyIHNjaGVtYSwgeG1sTm9kZVB0ciBub2RlLAoJCQkgICAgaW50ICpoYXNSZXN0cmljdGlvbk9yRXh0ZW5zaW9uKQp7CiAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGU7CiAgICB4bWxOb2RlUHRyIGNoaWxkID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSB8fAoJKGhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24gPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuICgtMSk7CiAgICAqaGFzUmVzdHJpY3Rpb25PckV4dGVuc2lvbiA9IDA7CiAgICAvKiBOb3QgYSBjb21wb25lbnQsIGRvbid0IGNyZWF0ZSBpdC4gKi8KICAgIHR5cGUgPSBjdHh0LT5jdHh0VHlwZTsKICAgIHR5cGUtPmNvbnRlbnRUeXBlID0gWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRTsKICAgIC8qCiAgICAqIENoZWNrIGZvciBpbGxlZ2FsIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICgoIXhtbFN0ckVxdWFsKGF0dHItPm5hbWUsIEJBRF9DQVNUICJpZCIpKSkgewoJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSB7CgkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJfQoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9CgogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKCiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewoJLyoKCSogQWRkIHRoZSBhbm5vdGF0aW9uIHRvIHRoZSBjb21wbGV4IHR5cGUgYW5jZXN0b3IuCgkqLwoJeG1sU2NoZW1hQWRkQW5ub3RhdGlvbigoeG1sU2NoZW1hQW5ub3RJdGVtUHRyKSB0eXBlLAoJICAgIHhtbFNjaGVtYVBhcnNlQW5ub3RhdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLCAxKSk7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0KICAgIGlmIChjaGlsZCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX01JU1NJTkcsCgkgICAgTlVMTCwgbm9kZSwgTlVMTCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/LCAocmVzdHJpY3Rpb24gfCBleHRlbnNpb24pKSIpOwkKICAgIH0KICAgIGlmIChjaGlsZCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX01JU1NJTkcsCgkgICAgTlVMTCwgbm9kZSwgTlVMTCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/LCAocmVzdHJpY3Rpb24gfCBleHRlbnNpb24pKSIpOwkKICAgIH0KICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJyZXN0cmljdGlvbiIpKSB7CiAgICAgICAgeG1sU2NoZW1hUGFyc2VSZXN0cmljdGlvbihjdHh0LCBzY2hlbWEsIGNoaWxkLAoJICAgIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEVfQ09OVEVOVCk7CgkoKmhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24pID0gMTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJleHRlbnNpb24iKSkgewogICAgICAgIHhtbFNjaGVtYVBhcnNlRXh0ZW5zaW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkgICAgWE1MX1NDSEVNQV9UWVBFX1NJTVBMRV9DT05URU5UKTsKCSgqaGFzUmVzdHJpY3Rpb25PckV4dGVuc2lvbikgPSAxOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwgTlVMTCwKCSAgICAiKGFubm90YXRpb24/LCAocmVzdHJpY3Rpb24gfCBleHRlbnNpb24pKSIpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVBhcnNlQ29tcGxleENvbnRlbnQ6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBzY2hlbWE6ICB0aGUgc2NoZW1hIGJlaW5nIGJ1aWx0CiAqIEBub2RlOiAgYSBzdWJ0cmVlIGNvbnRhaW5pbmcgWE1MIFNjaGVtYSBpbmZvcm1hdGlvbnMKICoKICogcGFyc2UgYSBYTUwgc2NoZW1hIENvbXBsZXhDb250ZW50IGRlZmluaXRpb24KICogKldBUk5JTkcqIHRoaXMgaW50ZXJmYWNlIGlzIGhpZ2hseSBzdWJqZWN0IHRvIGNoYW5nZQogKgogKiBSZXR1cm5zIHRoZSB0eXBlIGRlZmluaXRpb24gb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlQ29tcGxleENvbnRlbnQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsIHhtbE5vZGVQdHIgbm9kZSwKCQkJICAgICBpbnQgKmhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24pCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZTsKICAgIHhtbE5vZGVQdHIgY2hpbGQgPSBOVUxMOwogICAgeG1sQXR0clB0ciBhdHRyOwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpIHx8IChub2RlID09IE5VTEwpIHx8CgkoaGFzUmVzdHJpY3Rpb25PckV4dGVuc2lvbiA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKC0xKTsKICAgICpoYXNSZXN0cmljdGlvbk9yRXh0ZW5zaW9uID0gMDsKICAgIC8qIE5vdCBhIGNvbXBvbmVudCwgZG9uJ3QgY3JlYXRlIGl0LiAqLwogICAgdHlwZSA9IGN0eHQtPmN0eHRUeXBlOwogICAgLyoKICAgICogQ2hlY2sgZm9yIGlsbGVnYWwgYXR0cmlidXRlcy4KICAgICovCiAgICBhdHRyID0gbm9kZS0+cHJvcGVydGllczsKICAgIHdoaWxlIChhdHRyICE9IE5VTEwpIHsKCWlmIChhdHRyLT5ucyA9PSBOVUxMKSB7CgkgICAgaWYgKCgheG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImlkIikpICYmCgkJKCF4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibWl4ZWQiKSkpCgkgICAgewoJCXhtbFNjaGVtYVBJbGxlZ2FsQXR0ckVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkgICAgfQoJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5ucy0+aHJlZiwgeG1sU2NoZW1hTnMpKSB7CgkgICAgeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJfQoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9CgogICAgeG1sU2NoZW1hUFZhbEF0dHJJRChjdHh0LCBub2RlLCBCQURfQ0FTVCAiaWQiKTsKCiAgICAvKgogICAgKiBTZXQgdGhlICdtaXhlZCcgb24gdGhlIGNvbXBsZXggdHlwZSBhbmNlc3Rvci4KICAgICovCiAgICBpZiAoeG1sR2V0Qm9vbGVhblByb3AoY3R4dCwgbm9kZSwgIm1peGVkIiwgMCkpICB7CglpZiAoKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9NSVhFRCkgPT0gMCkKCSAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX01JWEVEOwogICAgfQogICAgY2hpbGQgPSBub2RlLT5jaGlsZHJlbjsKICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbm5vdGF0aW9uIikpIHsKCS8qCgkqIEFkZCB0aGUgYW5ub3RhdGlvbiB0byB0aGUgY29tcGxleCB0eXBlIGFuY2VzdG9yLgoJKi8KCXhtbFNjaGVtYUFkZEFubm90YXRpb24oKHhtbFNjaGVtYUFubm90SXRlbVB0cikgdHlwZSwKCSAgICB4bWxTY2hlbWFQYXJzZUFubm90YXRpb24oY3R4dCwgc2NoZW1hLCBjaGlsZCwgMSkpOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBpZiAoY2hpbGQgPT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9NSVNTSU5HLAoJICAgIE5VTEwsIG5vZGUsIE5VTEwsCgkgICAgTlVMTCwgIihhbm5vdGF0aW9uPywgKHJlc3RyaWN0aW9uIHwgZXh0ZW5zaW9uKSkiKTsKICAgIH0KICAgIGlmIChjaGlsZCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQQ29udGVudEVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1M0U19FTEVNX01JU1NJTkcsCgkgICAgTlVMTCwgbm9kZSwgTlVMTCwKCSAgICBOVUxMLCAiKGFubm90YXRpb24/LCAocmVzdHJpY3Rpb24gfCBleHRlbnNpb24pKSIpOwogICAgfQogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgInJlc3RyaWN0aW9uIikpIHsKICAgICAgICB4bWxTY2hlbWFQYXJzZVJlc3RyaWN0aW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkgICAgWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVhfQ09OVEVOVCk7CgkoKmhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24pID0gMTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfSBlbHNlIGlmIChJU19TQ0hFTUEoY2hpbGQsICJleHRlbnNpb24iKSkgewogICAgICAgIHhtbFNjaGVtYVBhcnNlRXh0ZW5zaW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkgICAgWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVhfQ09OVEVOVCk7CgkoKmhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24pID0gMTsKICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgfQogICAgaWYgKGNoaWxkICE9IE5VTEwpIHsKCXhtbFNjaGVtYVBDb250ZW50RXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfUzRTX0VMRU1fTk9UX0FMTE9XRUQsCgkgICAgTlVMTCwgbm9kZSwgY2hpbGQsCgkgICAgTlVMTCwgIihhbm5vdGF0aW9uPywgKHJlc3RyaWN0aW9uIHwgZXh0ZW5zaW9uKSkiKTsKICAgIH0KICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFQYXJzZUNvbXBsZXhUeXBlOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYSBiZWluZyBidWlsdAogKiBAbm9kZTogIGEgc3VidHJlZSBjb250YWluaW5nIFhNTCBTY2hlbWEgaW5mb3JtYXRpb25zCiAqCiAqIHBhcnNlIGEgWE1MIHNjaGVtYSBDb21wbGV4IFR5cGUgZGVmaW5pdGlvbgogKiAqV0FSTklORyogdGhpcyBpbnRlcmZhY2UgaXMgaGlnaGx5IHN1YmplY3QgdG8gY2hhbmdlCiAqCiAqIFJldHVybnMgdGhlIHR5cGUgZGVmaW5pdGlvbiBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnN0YXRpYyB4bWxTY2hlbWFUeXBlUHRyCnhtbFNjaGVtYVBhcnNlQ29tcGxleFR5cGUoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LCB4bWxTY2hlbWFQdHIgc2NoZW1hLAogICAgICAgICAgICAgICAgICAgICAgICAgIHhtbE5vZGVQdHIgbm9kZSwgaW50IHRvcExldmVsKQp7CiAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUsIGN0eHRUeXBlOwogICAgeG1sTm9kZVB0ciBjaGlsZCA9IE5VTEw7CiAgICBjb25zdCB4bWxDaGFyICpuYW1lID0gTlVMTDsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGNvbnN0IHhtbENoYXIgKmF0dHJWYWx1ZTsKI2lmZGVmIEVOQUJMRV9OQU1FRF9MT0NBTFMKICAgIGNoYXIgYnVmWzQwXTsKI2VuZGlmCiAgICBpbnQgZmluYWwgPSAwLCBibG9jayA9IDAsIGhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24gPSAwOwoKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKHNjaGVtYSA9PSBOVUxMKSB8fCAobm9kZSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4gKE5VTEwpOwoKICAgIGN0eHRUeXBlID0gY3R4dC0+Y3R4dFR5cGU7CgogICAgaWYgKHRvcExldmVsKSB7CglhdHRyID0geG1sU2NoZW1hR2V0UHJvcE5vZGUobm9kZSwgIm5hbWUiKTsKCWlmIChhdHRyID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQTWlzc2luZ0F0dHJFcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TNFNfQVRUUl9NSVNTSU5HLCBOVUxMLCBub2RlLCAibmFtZSIsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9IGVsc2UgaWYgKHhtbFNjaGVtYVBWYWxBdHRyTm9kZShjdHh0LCBOVUxMLCBhdHRyLAoJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05DTkFNRSksICZuYW1lKSAhPSAwKSB7CgkgICAgcmV0dXJuIChOVUxMKTsKCX0JCiAgICB9CgogICAgaWYgKHRvcExldmVsID09IDApIHsKCS8qCgkqIFBhcnNlIGFzIGxvY2FsIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uLgoJKi8KI2lmZGVmIEVOQUJMRV9OQU1FRF9MT0NBTFMKICAgICAgICBzbnByaW50ZihidWYsIDM5LCAiI0NUJWQiLCBjdHh0LT5jb3VudGVyKysgKyAxKTsKCXR5cGUgPSB4bWxTY2hlbWFBZGRUeXBlKGN0eHQsIHNjaGVtYSwKCSAgICBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWCwKCSAgICB4bWxEaWN0TG9va3VwKGN0eHQtPmRpY3QsIChjb25zdCB4bWxDaGFyICopYnVmLCAtMSksCgkgICAgY3R4dC0+dGFyZ2V0TmFtZXNwYWNlLCBub2RlLCAwKTsKI2Vsc2UKCXR5cGUgPSB4bWxTY2hlbWFBZGRUeXBlKGN0eHQsIHNjaGVtYSwKCSAgICBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWCwKCSAgICBOVUxMLCBjdHh0LT50YXJnZXROYW1lc3BhY2UsIG5vZGUsIDApOwojZW5kaWYKCWlmICh0eXBlID09IE5VTEwpCgkgICAgcmV0dXJuIChOVUxMKTsKCW5hbWUgPSB0eXBlLT5uYW1lOwoJdHlwZS0+bm9kZSA9IG5vZGU7Cgl0eXBlLT50eXBlID0gWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVg7CgkvKgoJKiBUT0RPOiBXZSBuZWVkIHRoZSB0YXJnZXQgbmFtZXNwYWNlLgoJKi8KICAgIH0gZWxzZSB7CgkvKgoJKiBQYXJzZSBhcyBnbG9iYWwgY29tcGxleCB0eXBlIGRlZmluaXRpb24uCgkqLwoJdHlwZSA9IHhtbFNjaGVtYUFkZFR5cGUoY3R4dCwgc2NoZW1hLAoJICAgIFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYLAoJICAgIG5hbWUsIGN0eHQtPnRhcmdldE5hbWVzcGFjZSwgbm9kZSwgMSk7CglpZiAodHlwZSA9PSBOVUxMKQoJICAgIHJldHVybiAoTlVMTCk7Cgl0eXBlLT5ub2RlID0gbm9kZTsKCXR5cGUtPnR5cGUgPSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDsKCXR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfR0xPQkFMOwogICAgfQogICAgdHlwZS0+dGFyZ2V0TmFtZXNwYWNlID0gY3R4dC0+dGFyZ2V0TmFtZXNwYWNlOwogICAgLyoKICAgICogSGFuZGxlIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgYXR0ciA9IG5vZGUtPnByb3BlcnRpZXM7CiAgICB3aGlsZSAoYXR0ciAhPSBOVUxMKSB7CglpZiAoYXR0ci0+bnMgPT0gTlVMTCkgewoJICAgIGlmICh4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiaWQiKSkgewoJCS8qCgkJKiBBdHRyaWJ1dGUgImlkIi4KCQkqLwoJCXhtbFNjaGVtYVBWYWxBdHRySUQoY3R4dCwgbm9kZSwgQkFEX0NBU1QgImlkIik7CgkgICAgfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAibWl4ZWQiKSkgewoJCS8qCgkJKiBBdHRyaWJ1dGUgIm1peGVkIi4KCQkqLwoJCWlmICh4bWxTY2hlbWFQR2V0Qm9vbE5vZGVWYWx1ZShjdHh0LAoJCQlOVUxMLCAoeG1sTm9kZVB0cikgYXR0cikpCgkJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfTUlYRUQ7CgkgICAgfSBlbHNlIGlmICh0b3BMZXZlbCkgewoJCS8qCgkJKiBBdHRyaWJ1dGVzIG9mIGdsb2JhbCBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbnMuCgkJKi8KCQlpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgIm5hbWUiKSkgewoJCSAgICAvKiBQYXNzLiAqLwoJCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImFic3RyYWN0IikpIHsKCQkgICAgLyoKCQkgICAgKiBBdHRyaWJ1dGUgImFic3RyYWN0Ii4KCQkgICAgKi8KCQkgICAgaWYgKHhtbFNjaGVtYVBHZXRCb29sTm9kZVZhbHVlKGN0eHQsCgkJCSAgICBOVUxMLCAoeG1sTm9kZVB0cikgYXR0cikpCgkJCXR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfQUJTVFJBQ1Q7CgkJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChhdHRyLT5uYW1lLCBCQURfQ0FTVCAiZmluYWwiKSkgewoJCSAgICAvKgoJCSAgICAqIEF0dHJpYnV0ZSAiZmluYWwiLgoJCSAgICAqLwoJCSAgICBhdHRyVmFsdWUgPSB4bWxTY2hlbWFHZXROb2RlQ29udGVudChjdHh0LAoJCQkoeG1sTm9kZVB0cikgYXR0cik7CgkJICAgIGlmICh4bWxTY2hlbWFQVmFsQXR0ckJsb2NrRmluYWwoYXR0clZhbHVlLAoJCQkmKHR5cGUtPmZsYWdzKSwKCQkJLTEsCgkJCVhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfRVhURU5TSU9OLAoJCQlYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX1JFU1RSSUNUSU9OLAoJCQktMSwgLTEsIC0xKSAhPSAwKQoJCSAgICB7CgkJCXhtbFNjaGVtYVBTaW1wbGVUeXBlRXJyKGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9JTlZBTElEX1ZBTFVFLAoJCQkgICAgTlVMTCwgKHhtbE5vZGVQdHIpIGF0dHIsIE5VTEwsCgkJCSAgICAiKCNhbGwgfCBMaXN0IG9mIChleHRlbnNpb24gfCByZXN0cmljdGlvbikpIiwKCQkJICAgIGF0dHJWYWx1ZSwgTlVMTCwgTlVMTCwgTlVMTCk7CgkJICAgIH0gZWxzZSAKCQkJZmluYWwgPSAxOwoJCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bmFtZSwgQkFEX0NBU1QgImJsb2NrIikpIHsKCQkgICAgLyoKCQkgICAgKiBBdHRyaWJ1dGUgImJsb2NrIi4KCQkgICAgKi8KCQkgICAgYXR0clZhbHVlID0geG1sU2NoZW1hR2V0Tm9kZUNvbnRlbnQoY3R4dCwKCQkJKHhtbE5vZGVQdHIpIGF0dHIpOwoJCSAgICBpZiAoeG1sU2NoZW1hUFZhbEF0dHJCbG9ja0ZpbmFsKGF0dHJWYWx1ZSwgJih0eXBlLT5mbGFncyksCgkJCS0xLAoJCQlYTUxfU0NIRU1BU19UWVBFX0JMT0NLX0VYVEVOU0lPTiwKCQkJWE1MX1NDSEVNQVNfVFlQRV9CTE9DS19SRVNUUklDVElPTiwKCQkJLTEsIC0xLCAtMSkgIT0gMCkgewoJCQl4bWxTY2hlbWFQU2ltcGxlVHlwZUVycihjdHh0LAoJCQkgICAgWE1MX1NDSEVNQVBfUzRTX0FUVFJfSU5WQUxJRF9WQUxVRSwKCQkJICAgIE5VTEwsICh4bWxOb2RlUHRyKSBhdHRyLCBOVUxMLAoJCQkgICAgIigjYWxsIHwgTGlzdCBvZiAoZXh0ZW5zaW9uIHwgcmVzdHJpY3Rpb24pKSAiLAoJCQkgICAgYXR0clZhbHVlLCBOVUxMLCBOVUxMLCBOVUxMKTsKCQkgICAgfSBlbHNlIAoJCQlibG9jayA9IDE7CgkJfSBlbHNlIHsKCQkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9TNFNfQVRUUl9OT1RfQUxMT1dFRCwgTlVMTCwgYXR0cik7CgkJfQoJICAgIH0gZWxzZSB7CgkJeG1sU2NoZW1hUElsbGVnYWxBdHRyRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1M0U19BVFRSX05PVF9BTExPV0VELCBOVUxMLCBhdHRyKTsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zLT5ocmVmLCB4bWxTY2hlbWFOcykpIHsKCSAgICB4bWxTY2hlbWFQSWxsZWdhbEF0dHJFcnIoY3R4dCwgCgkJWE1MX1NDSEVNQVBfUzRTX0FUVFJfTk9UX0FMTE9XRUQsIE5VTEwsIGF0dHIpOwoJfQoJYXR0ciA9IGF0dHItPm5leHQ7CiAgICB9CiAgICBpZiAoISBibG9jaykgewoJLyoKCSogQXBwbHkgZGVmYXVsdCAiYmxvY2siIHZhbHVlcy4KCSovCglpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0JMT0NLX0RFRkFVTFRfUkVTVFJJQ1RJT04pCgkgICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9CTE9DS19SRVNUUklDVElPTjsKCWlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfQkxPQ0tfREVGQVVMVF9FWFRFTlNJT04pCgkgICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9CTE9DS19FWFRFTlNJT047CiAgICB9CiAgICBpZiAoISBmaW5hbCkgewoJLyoKCSogQXBwbHkgZGVmYXVsdCAiYmxvY2siIHZhbHVlcy4KCSovCglpZiAoc2NoZW1hLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0ZJTkFMX0RFRkFVTFRfUkVTVFJJQ1RJT04pCgkgICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9GSU5BTF9SRVNUUklDVElPTjsKCWlmIChzY2hlbWEtPmZsYWdzICYgWE1MX1NDSEVNQVNfRklOQUxfREVGQVVMVF9FWFRFTlNJT04pCgkgICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9GSU5BTF9FWFRFTlNJT047CiAgICB9CiAgICAvKgogICAgKiBBbmQgbm93IGZvciB0aGUgY2hpbGRyZW4uLi4KICAgICovCiAgICBjaGlsZCA9IG5vZGUtPmNoaWxkcmVuOwogICAgaWYgKElTX1NDSEVNQShjaGlsZCwgImFubm90YXRpb24iKSkgewogICAgICAgIHR5cGUtPmFubm90ID0geG1sU2NoZW1hUGFyc2VBbm5vdGF0aW9uKGN0eHQsIHNjaGVtYSwgY2hpbGQsIDEpOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9CiAgICBjdHh0LT5jdHh0VHlwZSA9IHR5cGU7CiAgICBpZiAoSVNfU0NIRU1BKGNoaWxkLCAic2ltcGxlQ29udGVudCIpKSB7CgkvKgoJKiA8Y29tcGxleFR5cGU+PHNpbXBsZUNvbnRlbnQ+Li4uCgkqIDMuNC4zIDogMi4yCgkqIFNwZWNpZnlpbmcgbWl4ZWQ9J3RydWUnIHdoZW4gdGhlIDxzaW1wbGVDb250ZW50PgoJKiBhbHRlcm5hdGl2ZSBpcyBjaG9zZW4gaGFzIG5vIGVmZmVjdAoJKi8KCWlmICh0eXBlLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfTUlYRUQpCgkgICAgdHlwZS0+ZmxhZ3MgXj0gWE1MX1NDSEVNQVNfVFlQRV9NSVhFRDsKICAgICAgICB4bWxTY2hlbWFQYXJzZVNpbXBsZUNvbnRlbnQoY3R4dCwgc2NoZW1hLCBjaGlsZCwKCSAgICAmaGFzUmVzdHJpY3Rpb25PckV4dGVuc2lvbik7CiAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiY29tcGxleENvbnRlbnQiKSkgewoJLyoKCSogPGNvbXBsZXhUeXBlPjxjb21wbGV4Q29udGVudD4uLi4KCSovCgl0eXBlLT5jb250ZW50VHlwZSA9IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWTsKICAgICAgICB4bWxTY2hlbWFQYXJzZUNvbXBsZXhDb250ZW50KGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkgICAgJmhhc1Jlc3RyaWN0aW9uT3JFeHRlbnNpb24pOwogICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7CiAgICB9IGVsc2UgewoJLyoKCSogRS5nIDxjb21wbGV4VHlwZT48c2VxdWVuY2U+Li4uIG9yIDxjb21wbGV4VHlwZT48YXR0cmlidXRlPi4uLiBldGMuCgkqCgkqIFNQRUMKCSogIi4uLnRoZSB0aGlyZCBhbHRlcm5hdGl2ZSAobmVpdGhlciA8c2ltcGxlQ29udGVudD4gbm9yCgkqIDxjb21wbGV4Q29udGVudD4pIGlzIGNob3Nlbi4gVGhpcyBjYXNlIGlzIHVuZGVyc3Rvb2QgYXMgc2hvcnRoYW5kCgkqIGZvciBjb21wbGV4IGNvbnRlbnQgcmVzdHJpY3RpbmcgdGhlILd1ci10eXBlIGRlZmluaXRpb263LCBhbmQgdGhlCgkqIGRldGFpbHMgb2YgdGhlIG1hcHBpbmdzIHNob3VsZCBiZSBtb2RpZmllZCBhcyBuZWNlc3NhcnkuCgkqLwoJdHlwZS0+YmFzZVR5cGUgPSB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19BTllUWVBFKTsKCXR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfREVSSVZBVElPTl9NRVRIT0RfUkVTVFJJQ1RJT047CgkvKgoJKiBQYXJzZSBtb2RlbCBncm91cHMuCgkqLwogICAgICAgIGlmIChJU19TQ0hFTUEoY2hpbGQsICJhbGwiKSkgewogICAgICAgICAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cChjdHh0LCBzY2hlbWEsIGNoaWxkLAoJCSAgICBYTUxfU0NIRU1BX1RZUEVfQUxMLCAxKTsKICAgICAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgICAgICB9IGVsc2UgaWYgKElTX1NDSEVNQShjaGlsZCwgImNob2ljZSIpKSB7CiAgICAgICAgICAgIHR5cGUtPnN1YnR5cGVzID0gKHhtbFNjaGVtYVR5cGVQdHIpCgkJeG1sU2NoZW1hUGFyc2VNb2RlbEdyb3VwKGN0eHQsIHNjaGVtYSwgY2hpbGQsCgkJICAgIFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0UsIDEpOwogICAgICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAic2VxdWVuY2UiKSkgewogICAgICAgICAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cChjdHh0LCBzY2hlbWEsIGNoaWxkLAoJCSAgICBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UsIDEpOwogICAgICAgICAgICBjaGlsZCA9IGNoaWxkLT5uZXh0OwogICAgICAgIH0gZWxzZSBpZiAoSVNfU0NIRU1BKGNoaWxkLCAiZ3JvdXAiKSkgewogICAgICAgICAgICB0eXBlLT5zdWJ0eXBlcyA9ICh4bWxTY2hlbWFUeXBlUHRyKQoJCXhtbFNjaGVtYVBhcnNlTW9kZWxHcm91cERlZlJlZihjdHh0LCBzY2hlbWEsIGNoaWxkKTsKCSAgICAvKgoJICAgICogTm90ZSB0aGF0IHRoZSByZWZlcmVuY2Ugd2lsbCBiZSByZXNvbHZlZCBpbgoJICAgICogeG1sU2NoZW1hUmVzb2x2ZVR5cGVSZWZlcmVuY2VzKCk7CgkgICAgKi8KICAgICAgICAgICAgY2hpbGQgPSBjaGlsZC0+bmV4dDsKICAgICAgICB9CgkvKgoJKiBQYXJzZSBhdHRyaWJ1dGUgZGVjbHMvcmVmcy4KCSovCiAgICAgICAgaWYgKHhtbFNjaGVtYVBhcnNlTG9jYWxBdHRyaWJ1dGVzKGN0eHQsIHNjaGVtYSwgJmNoaWxkLAoJICAgICh4bWxTY2hlbWFJdGVtTGlzdFB0ciAqKSAmKHR5cGUtPmF0dHJVc2VzKSwKCSAgICBYTUxfU0NIRU1BX1RZUEVfUkVTVFJJQ1RJT04sIE5VTEwpID09IC0xKQoJICAgIHJldHVybihOVUxMKTsKCS8qCgkqIFBhcnNlIGF0dHJpYnV0ZSB3aWxkY2FyZC4KCSovCglpZiAoSVNfU0NIRU1BKGNoaWxkLCAiYW55QXR0cmlidXRlIikpIHsKCSAgICB0eXBlLT5hdHRyaWJ1dGVXaWxkY2FyZCA9IHhtbFNjaGVtYVBhcnNlQW55QXR0cmlidXRlKGN0eHQsIHNjaGVtYSwgY2hpbGQpOwoJICAgIGNoaWxkID0gY2hpbGQtPm5leHQ7Cgl9CiAgICB9CiAgICBpZiAoY2hpbGQgIT0gTlVMTCkgewoJeG1sU2NoZW1hUENvbnRlbnRFcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TNFNfRUxFTV9OT1RfQUxMT1dFRCwKCSAgICBOVUxMLCBub2RlLCBjaGlsZCwKCSAgICBOVUxMLCAiKGFubm90YXRpb24/LCAoc2ltcGxlQ29udGVudCB8IGNvbXBsZXhDb250ZW50IHwgIgoJICAgICIoKGdyb3VwIHwgYWxsIHwgY2hvaWNlIHwgc2VxdWVuY2UpPywgKChhdHRyaWJ1dGUgfCAiCgkgICAgImF0dHJpYnV0ZUdyb3VwKSosIGFueUF0dHJpYnV0ZT8pKSkpIik7CiAgICB9CiAgICAvKgogICAgKiBSRURFRklORTogU1BFQyBzcmMtcmVkZWZpbmUgKDUpCiAgICAqLwogICAgaWYgKHRvcExldmVsICYmIGN0eHQtPmlzUmVkZWZpbmUgJiYgKCEgaGFzUmVzdHJpY3Rpb25PckV4dGVuc2lvbikpIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwgWE1MX1NDSEVNQVBfU1JDX1JFREVGSU5FLAoJICAgIE5VTEwsIG5vZGUsICJUaGlzIGlzIGEgcmVkZWZpbml0aW9uLCB0aHVzIHRoZSAiCgkgICAgIjxjb21wbGV4VHlwZT4gbXVzdCBoYXZlIGEgPHJlc3RyaWN0aW9uPiBvciA8ZXh0ZW5zaW9uPiAiCgkgICAgImdyYW5kLWNoaWxkIiwgTlVMTCk7CiAgICB9CiAgICBjdHh0LT5jdHh0VHlwZSA9IGN0eHRUeXBlOwogICAgcmV0dXJuICh0eXBlKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJCVZhbGlkYXRpbmcgdXNpbmcgU2NoZW1hcwkJCSoKICogCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJCVJlYWRpbmcvV3JpdGluZyBTY2hlbWFzCQkJCSoKICogCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKI2lmIDAgLyogV2lsbCBiZSBlbmFibGVkIGlmIGl0IGlzIGNsZWFyIHdoYXQgb3B0aW9ucyBhcmUgbmVlZGVkLiAqLwovKioKICogeG1sU2NoZW1hUGFyc2VyQ3R4dFNldE9wdGlvbnM6CiAqIEBjdHh0OglhIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAb3B0aW9uczogYSBjb21iaW5hdGlvbiBvZiB4bWxTY2hlbWFQYXJzZXJPcHRpb24KICoKICogU2V0cyB0aGUgb3B0aW9ucyB0byBiZSB1c2VkIGR1cmluZyB0aGUgcGFyc2UuCiAqCiAqIFJldHVybnMgMCBpbiBjYXNlIG9mIHN1Y2Nlc3MsIC0xIGluIGNhc2Ugb2YgYW4KICogQVBJIGVycm9yLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZXJDdHh0U2V0T3B0aW9ucyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSAgICAgIGludCBvcHRpb25zKQoKewogICAgaW50IGk7CgogICAgaWYgKGN0eHQgPT0gTlVMTCkKCXJldHVybiAoLTEpOwogICAgLyoKICAgICogV0FSTklORzogQ2hhbmdlIHRoZSBzdGFydCB2YWx1ZSBpZiBhZGRpbmcgdG8gdGhlCiAgICAqIHhtbFNjaGVtYVBhcnNlT3B0aW9uLgogICAgKi8KICAgIGZvciAoaSA9IDE7IGkgPCAoaW50KSBzaXplb2YoaW50KSAqIDg7IGkrKykgewogICAgICAgIGlmIChvcHRpb25zICYgMTw8aSkgewoJICAgIHJldHVybiAoLTEpOwogICAgICAgIH0KICAgIH0KICAgIGN0eHQtPm9wdGlvbnMgPSBvcHRpb25zOwogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVZhbGlkQ3R4dEdldE9wdGlvbnM6CiAqIEBjdHh0OiBhIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKgogKiBSZXR1cm5zIHRoZSBvcHRpb24gY29tYmluYXRpb24gb2YgdGhlIHBhcnNlciBjb250ZXh0LgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFQYXJzZXJDdHh0R2V0T3B0aW9ucyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQpCgp7CiAgICBpZiAoY3R4dCA9PSBOVUxMKQoJcmV0dXJuICgtMSk7CiAgICBlbHNlCglyZXR1cm4gKGN0eHQtPm9wdGlvbnMpOwp9CiNlbmRpZgoKLyoqCiAqIHhtbFNjaGVtYU5ld1BhcnNlckN0eHQ6CiAqIEBVUkw6ICB0aGUgbG9jYXRpb24gb2YgdGhlIHNjaGVtYQogKgogKiBDcmVhdGUgYW4gWE1MIFNjaGVtYXMgcGFyc2UgY29udGV4dCBmb3IgdGhhdCBmaWxlL3Jlc291cmNlIGV4cGVjdGVkCiAqIHRvIGNvbnRhaW4gYW4gWE1MIFNjaGVtYXMgZmlsZS4KICoKICogUmV0dXJucyB0aGUgcGFyc2VyIGNvbnRleHQgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwp4bWxTY2hlbWFQYXJzZXJDdHh0UHRyCnhtbFNjaGVtYU5ld1BhcnNlckN0eHQoY29uc3QgY2hhciAqVVJMKQp7CiAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHJldDsKCiAgICBpZiAoVVJMID09IE5VTEwpCiAgICAgICAgcmV0dXJuIChOVUxMKTsKCiAgICByZXQgPSB4bWxTY2hlbWFQYXJzZXJDdHh0Q3JlYXRlKCk7CiAgICBpZiAocmV0ID09IE5VTEwpCglyZXR1cm4oTlVMTCk7CiAgICByZXQtPmRpY3QgPSB4bWxEaWN0Q3JlYXRlKCk7CiAgICByZXQtPlVSTCA9IHhtbERpY3RMb29rdXAocmV0LT5kaWN0LCAoY29uc3QgeG1sQ2hhciAqKSBVUkwsIC0xKTsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYU5ld01lbVBhcnNlckN0eHQ6CiAqIEBidWZmZXI6ICBhIHBvaW50ZXIgdG8gYSBjaGFyIGFycmF5IGNvbnRhaW5pbmcgdGhlIHNjaGVtYXMKICogQHNpemU6ICB0aGUgc2l6ZSBvZiB0aGUgYXJyYXkKICoKICogQ3JlYXRlIGFuIFhNTCBTY2hlbWFzIHBhcnNlIGNvbnRleHQgZm9yIHRoYXQgbWVtb3J5IGJ1ZmZlciBleHBlY3RlZAogKiB0byBjb250YWluIGFuIFhNTCBTY2hlbWFzIGZpbGUuCiAqCiAqIFJldHVybnMgdGhlIHBhcnNlciBjb250ZXh0IG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcgogKi8KeG1sU2NoZW1hUGFyc2VyQ3R4dFB0cgp4bWxTY2hlbWFOZXdNZW1QYXJzZXJDdHh0KGNvbnN0IGNoYXIgKmJ1ZmZlciwgaW50IHNpemUpCnsKICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcmV0OwoKICAgIGlmICgoYnVmZmVyID09IE5VTEwpIHx8IChzaXplIDw9IDApKQogICAgICAgIHJldHVybiAoTlVMTCk7CiAgICByZXQgPSB4bWxTY2hlbWFQYXJzZXJDdHh0Q3JlYXRlKCk7CiAgICBpZiAocmV0ID09IE5VTEwpCglyZXR1cm4oTlVMTCk7CiAgICByZXQtPmJ1ZmZlciA9IGJ1ZmZlcjsKICAgIHJldC0+c2l6ZSA9IHNpemU7CiAgICByZXQtPmRpY3QgPSB4bWxEaWN0Q3JlYXRlKCk7ICAgIAogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sU2NoZW1hTmV3RG9jUGFyc2VyQ3R4dDoKICogQGRvYzogIGEgcHJlcGFyc2VkIGRvY3VtZW50IHRyZWUKICoKICogQ3JlYXRlIGFuIFhNTCBTY2hlbWFzIHBhcnNlIGNvbnRleHQgZm9yIHRoYXQgZG9jdW1lbnQuCiAqIE5CLiBUaGUgZG9jdW1lbnQgbWF5IGJlIG1vZGlmaWVkIGR1cmluZyB0aGUgcGFyc2luZyBwcm9jZXNzLgogKgogKiBSZXR1cm5zIHRoZSBwYXJzZXIgY29udGV4dCBvciBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnhtbFNjaGVtYVBhcnNlckN0eHRQdHIKeG1sU2NoZW1hTmV3RG9jUGFyc2VyQ3R4dCh4bWxEb2NQdHIgZG9jKQp7CiAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHJldDsKCiAgICBpZiAoZG9jID09IE5VTEwpCiAgICAgIHJldHVybiAoTlVMTCk7CiAgICByZXQgPSB4bWxTY2hlbWFQYXJzZXJDdHh0Q3JlYXRlKCk7CiAgICBpZiAocmV0ID09IE5VTEwpCglyZXR1cm4oTlVMTCk7CiAgICByZXQtPmRvYyA9IGRvYzsKICAgIHJldC0+ZGljdCA9IHhtbERpY3RDcmVhdGUoKTsKICAgIC8qIFRoZSBhcHBsaWNhdGlvbiBoYXMgcmVzcG9uc2liaWxpdHkgZm9yIHRoZSBkb2N1bWVudCAqLwogICAgcmV0LT5wcmVzZXJ2ZSA9IDE7CgogICAgcmV0dXJuIChyZXQpOwp9CgovKioKICogeG1sU2NoZW1hRnJlZVBhcnNlckN0eHQ6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKgogKiBGcmVlIHRoZSByZXNvdXJjZXMgYXNzb2NpYXRlZCB0byB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqLwp2b2lkCnhtbFNjaGVtYUZyZWVQYXJzZXJDdHh0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCkKewogICAgaWYgKGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoY3R4dC0+ZG9jICE9IE5VTEwgJiYgIWN0eHQtPnByZXNlcnZlKQogICAgICAgIHhtbEZyZWVEb2MoY3R4dC0+ZG9jKTsgICAgCiAgICBpZiAoY3R4dC0+dmN0eHQgIT0gTlVMTCkgewoJeG1sU2NoZW1hRnJlZVZhbGlkQ3R4dChjdHh0LT52Y3R4dCk7CiAgICB9CiAgICBpZiAoY3R4dC0+b3duc0NvbnN0cnVjdG9yICYmIChjdHh0LT5jb25zdHJ1Y3RvciAhPSBOVUxMKSkgewoJeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dEZyZWUoY3R4dC0+Y29uc3RydWN0b3IpOwoJY3R4dC0+Y29uc3RydWN0b3IgPSBOVUxMOwoJY3R4dC0+b3duc0NvbnN0cnVjdG9yID0gMDsKICAgIH0KICAgIGlmIChjdHh0LT5hdHRyUHJvaGlicyAhPSBOVUxMKQoJeG1sU2NoZW1hSXRlbUxpc3RGcmVlKGN0eHQtPmF0dHJQcm9oaWJzKTsKICAgIHhtbERpY3RGcmVlKGN0eHQtPmRpY3QpOwogICAgeG1sRnJlZShjdHh0KTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJCQkJCQkJCSoKICoJCQlCdWlsZGluZyB0aGUgY29udGVudCBtb2RlbHMJCQkqCiAqCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIHZvaWQKeG1sU2NoZW1hQnVpbGRDb250ZW50TW9kZWxGb3JTdWJzdEdyb3VwKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgl4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0aWNsZSwgaW50IGNvdW50ZXIsIHhtbEF1dG9tYXRhU3RhdGVQdHIgZW5kKQp7CiAgICB4bWxBdXRvbWF0YVN0YXRlUHRyIHN0YXJ0LCB0bXA7CiAgICB4bWxTY2hlbWFFbGVtZW50UHRyIGVsZW1EZWNsLCBtZW1iZXI7CiAgICB4bWxTY2hlbWFTdWJzdEdyb3VwUHRyIHN1YnN0R3JvdXA7CiAgICBpbnQgaTsKCiAgICBlbGVtRGVjbCA9ICh4bWxTY2hlbWFFbGVtZW50UHRyKSBwYXJ0aWNsZS0+Y2hpbGRyZW47CiAgICAvKgogICAgKiBXcmFwIHRoZSBzdWJzdGl0dXRpb24gZ3JvdXAgd2l0aCBhIENIT0lDRS4KICAgICovCiAgICBzdGFydCA9IHBjdHh0LT5zdGF0ZTsKICAgIGlmIChlbmQgPT0gTlVMTCkKCWVuZCA9IHhtbEF1dG9tYXRhTmV3U3RhdGUocGN0eHQtPmFtKTsKICAgIHN1YnN0R3JvdXAgPSB4bWxTY2hlbWFTdWJzdEdyb3VwR2V0KHBjdHh0LCBlbGVtRGVjbCk7CiAgICBpZiAoc3Vic3RHcm91cCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFQRXJyKHBjdHh0LCBXWFNfSVRFTV9OT0RFKHBhcnRpY2xlKSwKCSAgICBYTUxfU0NIRU1BUF9JTlRFUk5BTCwKCSAgICAiSW50ZXJuYWwgZXJyb3I6IHhtbFNjaGVtYUJ1aWxkQ29udGVudE1vZGVsRm9yU3Vic3RHcm91cCwgIgoJICAgICJkZWNsYXJhdGlvbiBpcyBtYXJrZWQgaGF2aW5nIGEgc3Vic3QuIGdyb3VwIGJ1dCBub25lICIKCSAgICAiYXZhaWxhYmxlLlxuIiwgZWxlbURlY2wtPm5hbWUsIE5VTEwpOwoJcmV0dXJuOwogICAgfQogICAgaWYgKGNvdW50ZXIgPj0gMCkgewoJLyoKCSogTk9URSB0aGF0IHdlIHB1dCB0aGUgZGVjbGFyYXRpb24gaW4sIGV2ZW4gaWYgaXQncyBhYnN0cmFjdC4KCSogSG93ZXZlciwgYW4gZXJyb3Igd2lsbCBiZSByYWlzZWQgZHVyaW5nICp2YWxpZGF0aW9uKiBpZiBhbiBlbGVtZW50CgkqIGluZm9ybWF0aW9uIGl0ZW0gc2hhbGwgYmUgdmFsaWRhdGVkIGFnYWluc3QgYW4gYWJzdHJhY3QgZWxlbWVudAoJKiBkZWNsYXJhdGlvbi4KCSovCgl0bXAgPSB4bWxBdXRvbWF0YU5ld0NvdW50ZWRUcmFucyhwY3R4dC0+YW0sIHN0YXJ0LCBOVUxMLCBjb3VudGVyKTsKICAgICAgICB4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKHBjdHh0LT5hbSwgdG1wLCBlbmQsCgkgICAgICAgICAgICBlbGVtRGVjbC0+bmFtZSwgZWxlbURlY2wtPnRhcmdldE5hbWVzcGFjZSwgZWxlbURlY2wpOwoJLyoKCSogQWRkIHN1YnN0LiBncm91cCBtZW1iZXJzLgoJKi8KCWZvciAoaSA9IDA7IGkgPCBzdWJzdEdyb3VwLT5tZW1iZXJzLT5uYkl0ZW1zOyBpKyspIHsKCSAgICBtZW1iZXIgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgc3Vic3RHcm91cC0+bWVtYmVycy0+aXRlbXNbaV07CiAgICAgICAgICAgIHhtbEF1dG9tYXRhTmV3VHJhbnNpdGlvbjIocGN0eHQtPmFtLCB0bXAsIGVuZCwKCQkgICAgICAgICAgICAgICBtZW1iZXItPm5hbWUsIG1lbWJlci0+dGFyZ2V0TmFtZXNwYWNlLCBtZW1iZXIpOwoJfQogICAgfSBlbHNlIGlmIChwYXJ0aWNsZS0+bWF4T2NjdXJzID09IDEpIHsKCS8qCgkqIE5PVEUgdGhhdCB3ZSBwdXQgdGhlIGRlY2xhcmF0aW9uIGluLCBldmVuIGlmIGl0J3MgYWJzdHJhY3QsCgkqLwoJeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwKCSAgICB4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKHBjdHh0LT5hbSwKCSAgICBzdGFydCwgTlVMTCwKCSAgICBlbGVtRGVjbC0+bmFtZSwgZWxlbURlY2wtPnRhcmdldE5hbWVzcGFjZSwgZWxlbURlY2wpLCBlbmQpOwoJLyoKCSogQWRkIHN1YnN0LiBncm91cCBtZW1iZXJzLgoJKi8KCWZvciAoaSA9IDA7IGkgPCBzdWJzdEdyb3VwLT5tZW1iZXJzLT5uYkl0ZW1zOyBpKyspIHsKCSAgICBtZW1iZXIgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgc3Vic3RHcm91cC0+bWVtYmVycy0+aXRlbXNbaV07CgkgICAgdG1wID0geG1sQXV0b21hdGFOZXdPbmNlVHJhbnMyKHBjdHh0LT5hbSwgc3RhcnQsIE5VTEwsCgkJICAgICAgICAgICAgICAgbWVtYmVyLT5uYW1lLCBtZW1iZXItPnRhcmdldE5hbWVzcGFjZSwKCQkJICAgICAgIDEsIDEsIG1lbWJlcik7CgkgICAgeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgdG1wLCBlbmQpOwoJfQogICAgfSBlbHNlIHsKCXhtbEF1dG9tYXRhU3RhdGVQdHIgaG9wOwoJaW50IG1heE9jY3VycyA9IHBhcnRpY2xlLT5tYXhPY2N1cnMgPT0gVU5CT1VOREVEID8KCSAgICBVTkJPVU5ERUQgOiBwYXJ0aWNsZS0+bWF4T2NjdXJzIC0gMTsKCWludCBtaW5PY2N1cnMgPSBwYXJ0aWNsZS0+bWluT2NjdXJzIDwgMSA/IDAgOiBwYXJ0aWNsZS0+bWluT2NjdXJzIC0gMTsKCgljb3VudGVyID0KCSAgICB4bWxBdXRvbWF0YU5ld0NvdW50ZXIocGN0eHQtPmFtLCBtaW5PY2N1cnMsCgkgICAgbWF4T2NjdXJzKTsKCWhvcCA9IHhtbEF1dG9tYXRhTmV3U3RhdGUocGN0eHQtPmFtKTsKCgl4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLAoJICAgIHhtbEF1dG9tYXRhTmV3VHJhbnNpdGlvbjIocGN0eHQtPmFtLAoJICAgIHN0YXJ0LCBOVUxMLAoJICAgIGVsZW1EZWNsLT5uYW1lLCBlbGVtRGVjbC0+dGFyZ2V0TmFtZXNwYWNlLCBlbGVtRGVjbCksCgkgICAgaG9wKTsKCS8qCgkgKiBBZGQgc3Vic3QuIGdyb3VwIG1lbWJlcnMuCgkgKi8KCWZvciAoaSA9IDA7IGkgPCBzdWJzdEdyb3VwLT5tZW1iZXJzLT5uYkl0ZW1zOyBpKyspIHsKCSAgICBtZW1iZXIgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgc3Vic3RHcm91cC0+bWVtYmVycy0+aXRlbXNbaV07CgkgICAgeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwKCQl4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKHBjdHh0LT5hbSwKCQlzdGFydCwgTlVMTCwKCQltZW1iZXItPm5hbWUsIG1lbWJlci0+dGFyZ2V0TmFtZXNwYWNlLCBtZW1iZXIpLAoJCWhvcCk7Cgl9Cgl4bWxBdXRvbWF0YU5ld0NvdW50ZWRUcmFucyhwY3R4dC0+YW0sIGhvcCwgc3RhcnQsIGNvdW50ZXIpOwoJeG1sQXV0b21hdGFOZXdDb3VudGVyVHJhbnMocGN0eHQtPmFtLCBob3AsIGVuZCwgY291bnRlcik7CiAgICB9CiAgICBpZiAocGFydGljbGUtPm1pbk9jY3VycyA9PSAwKQoJeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgc3RhcnQsIGVuZCk7CiAgICBwY3R4dC0+c3RhdGUgPSBlbmQ7Cn0KCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUJ1aWxkQ29udGVudE1vZGVsRm9yRWxlbWVudCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCQkgICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnRpY2xlKQp7CiAgICBpZiAoKCh4bWxTY2hlbWFFbGVtZW50UHRyKSBwYXJ0aWNsZS0+Y2hpbGRyZW4pLT5mbGFncyAmCglYTUxfU0NIRU1BU19FTEVNX1NVQlNUX0dST1VQX0hFQUQpIHsKCS8qCgkqIFN1YnN0aXR1dGlvbiBncm91cHMuCgkqLwoJeG1sU2NoZW1hQnVpbGRDb250ZW50TW9kZWxGb3JTdWJzdEdyb3VwKGN0eHQsIHBhcnRpY2xlLCAtMSwgTlVMTCk7CiAgICB9IGVsc2UgewoJeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtRGVjbDsKCXhtbEF1dG9tYXRhU3RhdGVQdHIgc3RhcnQ7CgoJZWxlbURlY2wgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgcGFydGljbGUtPmNoaWxkcmVuOwoKCWlmIChlbGVtRGVjbC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0FCU1RSQUNUKQoJICAgIHJldHVybjsKCWlmIChwYXJ0aWNsZS0+bWF4T2NjdXJzID09IDEpIHsKCSAgICBzdGFydCA9IGN0eHQtPnN0YXRlOwoJICAgIGN0eHQtPnN0YXRlID0geG1sQXV0b21hdGFOZXdUcmFuc2l0aW9uMihjdHh0LT5hbSwgc3RhcnQsIE5VTEwsCgkJICAgIGVsZW1EZWNsLT5uYW1lLCBlbGVtRGVjbC0+dGFyZ2V0TmFtZXNwYWNlLCBlbGVtRGVjbCk7Cgl9IGVsc2UgaWYgKChwYXJ0aWNsZS0+bWF4T2NjdXJzID49IFVOQk9VTkRFRCkgJiYKCSAgICAgICAgICAgKHBhcnRpY2xlLT5taW5PY2N1cnMgPCAyKSkgewoJICAgIC8qIFNwZWNpYWwgY2FzZS4gKi8KCSAgICBzdGFydCA9IGN0eHQtPnN0YXRlOwkgICAgCgkgICAgY3R4dC0+c3RhdGUgPSB4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKGN0eHQtPmFtLCBzdGFydCwgTlVMTCwKCQllbGVtRGVjbC0+bmFtZSwgZWxlbURlY2wtPnRhcmdldE5hbWVzcGFjZSwgZWxlbURlY2wpOwkgICAgCgkgICAgY3R4dC0+c3RhdGUgPSB4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKGN0eHQtPmFtLCBjdHh0LT5zdGF0ZSwgY3R4dC0+c3RhdGUsCgkJZWxlbURlY2wtPm5hbWUsIGVsZW1EZWNsLT50YXJnZXROYW1lc3BhY2UsIGVsZW1EZWNsKTsJICAgIAoJfSBlbHNlIHsKCSAgICBpbnQgY291bnRlcjsKCSAgICBpbnQgbWF4T2NjdXJzID0gcGFydGljbGUtPm1heE9jY3VycyA9PSBVTkJPVU5ERUQgPwoJCQkgICAgVU5CT1VOREVEIDogcGFydGljbGUtPm1heE9jY3VycyAtIDE7CgkgICAgaW50IG1pbk9jY3VycyA9IHBhcnRpY2xlLT5taW5PY2N1cnMgPCAxID8KCQkJICAgIDAgOiBwYXJ0aWNsZS0+bWluT2NjdXJzIC0gMTsKCgkgICAgc3RhcnQgPSB4bWxBdXRvbWF0YU5ld0Vwc2lsb24oY3R4dC0+YW0sIGN0eHQtPnN0YXRlLCBOVUxMKTsKCSAgICBjb3VudGVyID0geG1sQXV0b21hdGFOZXdDb3VudGVyKGN0eHQtPmFtLCBtaW5PY2N1cnMsIG1heE9jY3Vycyk7CgkgICAgY3R4dC0+c3RhdGUgPSB4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKGN0eHQtPmFtLCBzdGFydCwgTlVMTCwKCQllbGVtRGVjbC0+bmFtZSwgZWxlbURlY2wtPnRhcmdldE5hbWVzcGFjZSwgZWxlbURlY2wpOwoJICAgIHhtbEF1dG9tYXRhTmV3Q291bnRlZFRyYW5zKGN0eHQtPmFtLCBjdHh0LT5zdGF0ZSwgc3RhcnQsIGNvdW50ZXIpOwoJICAgIGN0eHQtPnN0YXRlID0geG1sQXV0b21hdGFOZXdDb3VudGVyVHJhbnMoY3R4dC0+YW0sIGN0eHQtPnN0YXRlLAoJCU5VTEwsIGNvdW50ZXIpOwoJfQoJaWYgKHBhcnRpY2xlLT5taW5PY2N1cnMgPT0gMCkKCSAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24oY3R4dC0+YW0sIHN0YXJ0LCBjdHh0LT5zdGF0ZSk7CiAgICB9Cn0KCi8qKgogKiB4bWxTY2hlbWFCdWlsZEFDb250ZW50TW9kZWw6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAcGFydGljbGU6ICB0aGUgcGFydGljbGUgY29tcG9uZW50CiAqIEBuYW1lOiAgdGhlIGNvbXBsZXggdHlwZSdzIG5hbWUgd2hvc2UgY29udGVudCBpcyBiZWluZyBidWlsdAogKgogKiBDcmVhdGUgdGhlIGF1dG9tYXRvbiBmb3IgdGhlIHtjb250ZW50IHR5cGV9IG9mIGEgY29tcGxleCB0eXBlLgogKgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hQnVpbGRBQ29udGVudE1vZGVsKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCSAgICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0aWNsZSkKewogICAgaWYgKHBhcnRpY2xlID09IE5VTEwpIHsKCVBFUlJPUl9JTlQoInhtbFNjaGVtYUJ1aWxkQUNvbnRlbnRNb2RlbCIsICJwYXJ0aWNsZSBpcyBOVUxMIik7CSAgICAKCXJldHVybjsKICAgIH0KICAgIGlmIChwYXJ0aWNsZS0+Y2hpbGRyZW4gPT0gTlVMTCkgewoJLyoKCSogSnVzdCByZXR1cm4gaW4gdGhpcyBjYXNlLiBBIG1pc3NpbmcgInRlcm0iIG9mIHRoZSBwYXJ0aWNsZQoJKiBtaWdodCBhcmlzZSBkdWUgdG8gYW4gaW52YWxpZCAidGVybSIgY29tcG9uZW50LgoJKi8KCXJldHVybjsKICAgIH0KCiAgICBzd2l0Y2ggKHBhcnRpY2xlLT5jaGlsZHJlbi0+dHlwZSkgewoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQU5ZOiB7CgkgICAgeG1sQXV0b21hdGFTdGF0ZVB0ciBzdGFydCwgZW5kOwoJICAgIHhtbFNjaGVtYVdpbGRjYXJkUHRyIHdpbGQ7CgkgICAgeG1sU2NoZW1hV2lsZGNhcmROc1B0ciBuczsKCgkgICAgd2lsZCA9ICh4bWxTY2hlbWFXaWxkY2FyZFB0cikgcGFydGljbGUtPmNoaWxkcmVuOwoKCSAgICBzdGFydCA9IHBjdHh0LT5zdGF0ZTsKCSAgICBlbmQgPSB4bWxBdXRvbWF0YU5ld1N0YXRlKHBjdHh0LT5hbSk7CgoJICAgIGlmIChwYXJ0aWNsZS0+bWF4T2NjdXJzID09IDEpIHsKCQlpZiAod2lsZC0+YW55ID09IDEpIHsKCQkgICAgLyoKCQkgICAgKiBXZSBuZWVkIHRvIGFkZCBib3RoIHRyYW5zaXRpb25zOgoJCSAgICAqCgkJICAgICogMS4gdGhlIHsiKiIsICIqIn0gZm9yIGVsZW1lbnRzIGluIGEgbmFtZXNwYWNlLgoJCSAgICAqLwoJCSAgICBwY3R4dC0+c3RhdGUgPQoJCQl4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKHBjdHh0LT5hbSwKCQkJc3RhcnQsIE5VTEwsIEJBRF9DQVNUICIqIiwgQkFEX0NBU1QgIioiLCB3aWxkKTsKCQkgICAgeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgcGN0eHQtPnN0YXRlLCBlbmQpOwoJCSAgICAvKgoJCSAgICAqIDIuIHRoZSB7IioifSBmb3IgZWxlbWVudHMgaW4gbm8gbmFtZXNwYWNlLgoJCSAgICAqLwoJCSAgICBwY3R4dC0+c3RhdGUgPQoJCQl4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKHBjdHh0LT5hbSwKCQkJc3RhcnQsIE5VTEwsIEJBRF9DQVNUICIqIiwgTlVMTCwgd2lsZCk7CgkJICAgIHhtbEF1dG9tYXRhTmV3RXBzaWxvbihwY3R4dC0+YW0sIHBjdHh0LT5zdGF0ZSwgZW5kKTsKCgkJfSBlbHNlIGlmICh3aWxkLT5uc1NldCAhPSBOVUxMKSB7CgkJICAgIG5zID0gd2lsZC0+bnNTZXQ7CgkJICAgIGRvIHsKCQkJcGN0eHQtPnN0YXRlID0gc3RhcnQ7CgkJCXBjdHh0LT5zdGF0ZSA9IHhtbEF1dG9tYXRhTmV3VHJhbnNpdGlvbjIocGN0eHQtPmFtLAoJCQkgICAgcGN0eHQtPnN0YXRlLCBOVUxMLCBCQURfQ0FTVCAiKiIsIG5zLT52YWx1ZSwgd2lsZCk7CgkJCXhtbEF1dG9tYXRhTmV3RXBzaWxvbihwY3R4dC0+YW0sIHBjdHh0LT5zdGF0ZSwgZW5kKTsKCQkJbnMgPSBucy0+bmV4dDsKCQkgICAgfSB3aGlsZSAobnMgIT0gTlVMTCk7CgoJCX0gZWxzZSBpZiAod2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgewoJCSAgICBwY3R4dC0+c3RhdGUgPSB4bWxBdXRvbWF0YU5ld05lZ1RyYW5zKHBjdHh0LT5hbSwKCQkJc3RhcnQsIGVuZCwgQkFEX0NBU1QgIioiLCB3aWxkLT5uZWdOc1NldC0+dmFsdWUsCgkJCXdpbGQpOwoJCX0KCSAgICB9IGVsc2UgewoJCWludCBjb3VudGVyOwoJCXhtbEF1dG9tYXRhU3RhdGVQdHIgaG9wOwoJCWludCBtYXhPY2N1cnMgPQoJCSAgICBwYXJ0aWNsZS0+bWF4T2NjdXJzID09IFVOQk9VTkRFRCA/IFVOQk9VTkRFRCA6IHBhcnRpY2xlLT5tYXhPY2N1cnMgLSAxOwoJCWludCBtaW5PY2N1cnMgPQoJCSAgICBwYXJ0aWNsZS0+bWluT2NjdXJzIDwgMSA/IDAgOiBwYXJ0aWNsZS0+bWluT2NjdXJzIC0gMTsKCgkJY291bnRlciA9IHhtbEF1dG9tYXRhTmV3Q291bnRlcihwY3R4dC0+YW0sIG1pbk9jY3VycywgbWF4T2NjdXJzKTsKCQlob3AgPSB4bWxBdXRvbWF0YU5ld1N0YXRlKHBjdHh0LT5hbSk7CgkJaWYgKHdpbGQtPmFueSA9PSAxKSB7CgkJICAgIHBjdHh0LT5zdGF0ZSA9CgkJCXhtbEF1dG9tYXRhTmV3VHJhbnNpdGlvbjIocGN0eHQtPmFtLAoJCQlzdGFydCwgTlVMTCwgQkFEX0NBU1QgIioiLCBCQURfQ0FTVCAiKiIsIHdpbGQpOwoJCSAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLCBwY3R4dC0+c3RhdGUsIGhvcCk7CgkJICAgIHBjdHh0LT5zdGF0ZSA9CgkJCXhtbEF1dG9tYXRhTmV3VHJhbnNpdGlvbjIocGN0eHQtPmFtLAoJCQlzdGFydCwgTlVMTCwgQkFEX0NBU1QgIioiLCBOVUxMLCB3aWxkKTsKCQkgICAgeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgcGN0eHQtPnN0YXRlLCBob3ApOwoJCX0gZWxzZSBpZiAod2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJCSAgICBucyA9IHdpbGQtPm5zU2V0OwoJCSAgICBkbyB7CgkJCXBjdHh0LT5zdGF0ZSA9CgkJCSAgICB4bWxBdXRvbWF0YU5ld1RyYW5zaXRpb24yKHBjdHh0LT5hbSwKCQkJCXN0YXJ0LCBOVUxMLCBCQURfQ0FTVCAiKiIsIG5zLT52YWx1ZSwgd2lsZCk7CgkJCXhtbEF1dG9tYXRhTmV3RXBzaWxvbihwY3R4dC0+YW0sIHBjdHh0LT5zdGF0ZSwgaG9wKTsKCQkJbnMgPSBucy0+bmV4dDsKCQkgICAgfSB3aGlsZSAobnMgIT0gTlVMTCk7CgoJCX0gZWxzZSBpZiAod2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgewoJCSAgICBwY3R4dC0+c3RhdGUgPSB4bWxBdXRvbWF0YU5ld05lZ1RyYW5zKHBjdHh0LT5hbSwKCQkJc3RhcnQsIGhvcCwgQkFEX0NBU1QgIioiLCB3aWxkLT5uZWdOc1NldC0+dmFsdWUsCgkJCXdpbGQpOwoJCX0KCQl4bWxBdXRvbWF0YU5ld0NvdW50ZWRUcmFucyhwY3R4dC0+YW0sIGhvcCwgc3RhcnQsIGNvdW50ZXIpOwoJCXhtbEF1dG9tYXRhTmV3Q291bnRlclRyYW5zKHBjdHh0LT5hbSwgaG9wLCBlbmQsIGNvdW50ZXIpOwoJICAgIH0KCSAgICBpZiAocGFydGljbGUtPm1pbk9jY3VycyA9PSAwKSB7CgkJeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgc3RhcnQsIGVuZCk7CgkgICAgfQoJICAgIHBjdHh0LT5zdGF0ZSA9IGVuZDsKICAgICAgICAgICAgYnJlYWs7Cgl9CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfRUxFTUVOVDoKCSAgICB4bWxTY2hlbWFCdWlsZENvbnRlbnRNb2RlbEZvckVsZW1lbnQocGN0eHQsIHBhcnRpY2xlKTsKCSAgICBicmVhazsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TRVFVRU5DRTp7CiAgICAgICAgICAgICAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciBzdWI7CgogICAgICAgICAgICAgICAgLyoKICAgICAgICAgICAgICAgICAqIElmIG1heCBhbmQgbWluIG9jY3VyYW5jZXMgYXJlIGRlZmF1bHQgKDEpIHRoZW4KICAgICAgICAgICAgICAgICAqIHNpbXBseSBpdGVyYXRlIG92ZXIgdGhlIHBhcnRpY2xlcyBvZiB0aGUgPHNlcXVlbmNlPi4KICAgICAgICAgICAgICAgICAqLwogICAgICAgICAgICAgICAgaWYgKChwYXJ0aWNsZS0+bWluT2NjdXJzID09IDEpICYmIChwYXJ0aWNsZS0+bWF4T2NjdXJzID09IDEpKSB7CiAgICAgICAgICAgICAgICAgICAgc3ViID0gcGFydGljbGUtPmNoaWxkcmVuLT5jaGlsZHJlbjsKICAgICAgICAgICAgICAgICAgICB3aGlsZSAoc3ViICE9IE5VTEwpIHsKICAgICAgICAgICAgICAgICAgICAgICAgeG1sU2NoZW1hQnVpbGRBQ29udGVudE1vZGVsKHBjdHh0LAoJCQkgICAgKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSBzdWIpOwogICAgICAgICAgICAgICAgICAgICAgICBzdWIgPSBzdWItPm5leHQ7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YVN0YXRlUHRyIG9sZHN0YXRlID0gcGN0eHQtPnN0YXRlOwoKICAgICAgICAgICAgICAgICAgICBpZiAocGFydGljbGUtPm1heE9jY3VycyA+PSBVTkJPVU5ERUQpIHsKICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHBhcnRpY2xlLT5taW5PY2N1cnMgPiAxKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YVN0YXRlUHRyIHRtcDsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludCBjb3VudGVyOwoKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBjdHh0LT5zdGF0ZSA9IHhtbEF1dG9tYXRhTmV3RXBzaWxvbihwY3R4dC0+YW0sCgkJCQlvbGRzdGF0ZSwgTlVMTCk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICBvbGRzdGF0ZSA9IHBjdHh0LT5zdGF0ZTsKCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb3VudGVyID0geG1sQXV0b21hdGFOZXdDb3VudGVyKHBjdHh0LT5hbSwKCQkJCXBhcnRpY2xlLT5taW5PY2N1cnMgLSAxLCBVTkJPVU5ERUQpOwoKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN1YiA9IHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW47CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB3aGlsZSAoc3ViICE9IE5VTEwpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFCdWlsZEFDb250ZW50TW9kZWwocGN0eHQsCgkJCQkgICAgKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSBzdWIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN1YiA9IHN1Yi0+bmV4dDsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRtcCA9IHBjdHh0LT5zdGF0ZTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbEF1dG9tYXRhTmV3Q291bnRlZFRyYW5zKHBjdHh0LT5hbSwgdG1wLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb2xkc3RhdGUsIGNvdW50ZXIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgcGN0eHQtPnN0YXRlID0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0NvdW50ZXJUcmFucyhwY3R4dC0+YW0sIHRtcCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMLCBjb3VudGVyKTsKCiAgICAgICAgICAgICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICBwY3R4dC0+c3RhdGUgPSB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLAoJCQkJb2xkc3RhdGUsIE5VTEwpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgb2xkc3RhdGUgPSBwY3R4dC0+c3RhdGU7CgoJCQkgICAgc3ViID0gcGFydGljbGUtPmNoaWxkcmVuLT5jaGlsZHJlbjsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdoaWxlIChzdWIgIT0gTlVMTCkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYUJ1aWxkQUNvbnRlbnRNb2RlbChwY3R4dCwKCQkJCSAgICAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHN1Yik7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3ViID0gc3ViLT5uZXh0OwogICAgICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgcGN0eHQtPnN0YXRlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG9sZHN0YXRlKTsKCQkJICAgIC8qCgkJCSAgICAgKiBlcHNpbG9uIG5lZWRlZCB0byBibG9jayBwcmV2aW91cyB0cmFucyBmcm9tCgkJCSAgICAgKiBiZWluZyBhbGxvd2VkIHRvIGVudGVyIGJhY2sgZnJvbSBhbm90aGVyCgkJCSAgICAgKiBjb25zdHJ1Y3QKCQkJICAgICAqLwoJCQkgICAgcGN0eHQtPnN0YXRlID0geG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwKCQkJCQkJcGN0eHQtPnN0YXRlLCBOVUxMKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChwYXJ0aWNsZS0+bWluT2NjdXJzID09IDApIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLAoJCQkJICAgIG9sZHN0YXRlLCBwY3R4dC0+c3RhdGUpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgfSBlbHNlIGlmICgocGFydGljbGUtPm1heE9jY3VycyA+IDEpCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8fCAocGFydGljbGUtPm1pbk9jY3VycyA+IDEpKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIHhtbEF1dG9tYXRhU3RhdGVQdHIgdG1wOwogICAgICAgICAgICAgICAgICAgICAgICBpbnQgY291bnRlcjsKCiAgICAgICAgICAgICAgICAgICAgICAgIHBjdHh0LT5zdGF0ZSA9IHhtbEF1dG9tYXRhTmV3RXBzaWxvbihwY3R4dC0+YW0sCgkJCSAgICBvbGRzdGF0ZSwgTlVMTCk7CiAgICAgICAgICAgICAgICAgICAgICAgIG9sZHN0YXRlID0gcGN0eHQtPnN0YXRlOwoKICAgICAgICAgICAgICAgICAgICAgICAgY291bnRlciA9IHhtbEF1dG9tYXRhTmV3Q291bnRlcihwY3R4dC0+YW0sCgkJCSAgICBwYXJ0aWNsZS0+bWluT2NjdXJzIC0gMSwKCQkJICAgIHBhcnRpY2xlLT5tYXhPY2N1cnMgLSAxKTsKCiAgICAgICAgICAgICAgICAgICAgICAgIHN1YiA9IHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW47CiAgICAgICAgICAgICAgICAgICAgICAgIHdoaWxlIChzdWIgIT0gTlVMTCkgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1sU2NoZW1hQnVpbGRBQ29udGVudE1vZGVsKHBjdHh0LAoJCQkJKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSBzdWIpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgc3ViID0gc3ViLT5uZXh0OwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgIHRtcCA9IHBjdHh0LT5zdGF0ZTsKICAgICAgICAgICAgICAgICAgICAgICAgeG1sQXV0b21hdGFOZXdDb3VudGVkVHJhbnMocGN0eHQtPmFtLAoJCQkgICAgdG1wLCBvbGRzdGF0ZSwgY291bnRlcik7CiAgICAgICAgICAgICAgICAgICAgICAgIHBjdHh0LT5zdGF0ZSA9CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0NvdW50ZXJUcmFucyhwY3R4dC0+YW0sIHRtcCwgTlVMTCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvdW50ZXIpOwogICAgICAgICAgICAgICAgICAgICAgICBpZiAocGFydGljbGUtPm1pbk9jY3VycyA9PSAwKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLAoJCQkJb2xkc3RhdGUsIHBjdHh0LT5zdGF0ZSk7CiAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgICAgICAgICBzdWIgPSBwYXJ0aWNsZS0+Y2hpbGRyZW4tPmNoaWxkcmVuOwogICAgICAgICAgICAgICAgICAgICAgICB3aGlsZSAoc3ViICE9IE5VTEwpIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYUJ1aWxkQUNvbnRlbnRNb2RlbChwY3R4dCwKCQkJCSh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgc3ViKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN1YiA9IHN1Yi0+bmV4dDsKICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICBpZiAocGFydGljbGUtPm1pbk9jY3VycyA9PSAwKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLCBvbGRzdGF0ZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwY3R4dC0+c3RhdGUpOwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgIH0KICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0U6ewogICAgICAgICAgICAgICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgc3ViOwogICAgICAgICAgICAgICAgeG1sQXV0b21hdGFTdGF0ZVB0ciBzdGFydCwgZW5kOwoKICAgICAgICAgICAgICAgIHN0YXJ0ID0gcGN0eHQtPnN0YXRlOwogICAgICAgICAgICAgICAgZW5kID0geG1sQXV0b21hdGFOZXdTdGF0ZShwY3R4dC0+YW0pOwoKICAgICAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAgICAgKiBpdGVyYXRlIG92ZXIgdGhlIHN1YnR5cGVzIGFuZCByZW1lcmdlIHRoZSBlbmQgd2l0aCBhbgogICAgICAgICAgICAgICAgICogZXBzaWxvbiB0cmFuc2l0aW9uCiAgICAgICAgICAgICAgICAgKi8KICAgICAgICAgICAgICAgIGlmIChwYXJ0aWNsZS0+bWF4T2NjdXJzID09IDEpIHsKCQkgICAgc3ViID0gcGFydGljbGUtPmNoaWxkcmVuLT5jaGlsZHJlbjsKICAgICAgICAgICAgICAgICAgICB3aGlsZSAoc3ViICE9IE5VTEwpIHsKICAgICAgICAgICAgICAgICAgICAgICAgcGN0eHQtPnN0YXRlID0gc3RhcnQ7CiAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYUJ1aWxkQUNvbnRlbnRNb2RlbChwY3R4dCwKCQkJICAgICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgc3ViKTsKICAgICAgICAgICAgICAgICAgICAgICAgeG1sQXV0b21hdGFOZXdFcHNpbG9uKHBjdHh0LT5hbSwgcGN0eHQtPnN0YXRlLCBlbmQpOwogICAgICAgICAgICAgICAgICAgICAgICBzdWIgPSBzdWItPm5leHQ7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICAgICBpbnQgY291bnRlcjsKICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YVN0YXRlUHRyIGhvcCwgYmFzZTsKICAgICAgICAgICAgICAgICAgICBpbnQgbWF4T2NjdXJzID0gcGFydGljbGUtPm1heE9jY3VycyA9PSBVTkJPVU5ERUQgPwogICAgICAgICAgICAgICAgICAgICAgICBVTkJPVU5ERUQgOiBwYXJ0aWNsZS0+bWF4T2NjdXJzIC0gMTsKICAgICAgICAgICAgICAgICAgICBpbnQgbWluT2NjdXJzID0KICAgICAgICAgICAgICAgICAgICAgICAgcGFydGljbGUtPm1pbk9jY3VycyA8IDEgPyAwIDogcGFydGljbGUtPm1pbk9jY3VycyAtIDE7CgogICAgICAgICAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAgICAgICAgICogdXNlIGEgY291bnRlciB0byBrZWVwIHRyYWNrIG9mIHRoZSBudW1iZXIgb2YgdHJhbnN0aW9ucwogICAgICAgICAgICAgICAgICAgICAqIHdoaWNoIHdlbnQgdGhyb3VnaCB0aGUgY2hvaWNlLgogICAgICAgICAgICAgICAgICAgICAqLwogICAgICAgICAgICAgICAgICAgIGNvdW50ZXIgPQogICAgICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0NvdW50ZXIocGN0eHQtPmFtLCBtaW5PY2N1cnMsIG1heE9jY3Vycyk7CiAgICAgICAgICAgICAgICAgICAgaG9wID0geG1sQXV0b21hdGFOZXdTdGF0ZShwY3R4dC0+YW0pOwogICAgICAgICAgICAgICAgICAgIGJhc2UgPSB4bWxBdXRvbWF0YU5ld1N0YXRlKHBjdHh0LT5hbSk7CgoJCSAgICBzdWIgPSBwYXJ0aWNsZS0+Y2hpbGRyZW4tPmNoaWxkcmVuOwogICAgICAgICAgICAgICAgICAgIHdoaWxlIChzdWIgIT0gTlVMTCkgewogICAgICAgICAgICAgICAgICAgICAgICBwY3R4dC0+c3RhdGUgPSBiYXNlOwogICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFCdWlsZEFDb250ZW50TW9kZWwocGN0eHQsCgkJCSAgICAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHN1Yik7CiAgICAgICAgICAgICAgICAgICAgICAgIHhtbEF1dG9tYXRhTmV3RXBzaWxvbihwY3R4dC0+YW0sIHBjdHh0LT5zdGF0ZSwgaG9wKTsKICAgICAgICAgICAgICAgICAgICAgICAgc3ViID0gc3ViLT5uZXh0OwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLCBzdGFydCwgYmFzZSk7CgkJICAgIHhtbEF1dG9tYXRhTmV3Q291bnRlZFRyYW5zKHBjdHh0LT5hbSwgaG9wLCBiYXNlLCBjb3VudGVyKTsKICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0NvdW50ZXJUcmFucyhwY3R4dC0+YW0sIGhvcCwgZW5kLCBjb3VudGVyKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGlmIChwYXJ0aWNsZS0+bWluT2NjdXJzID09IDApIHsKICAgICAgICAgICAgICAgICAgICB4bWxBdXRvbWF0YU5ld0Vwc2lsb24ocGN0eHQtPmFtLCBzdGFydCwgZW5kKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIHBjdHh0LT5zdGF0ZSA9IGVuZDsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQUxMOnsKICAgICAgICAgICAgICAgIHhtbEF1dG9tYXRhU3RhdGVQdHIgc3RhcnQ7CgkJeG1sU2NoZW1hUGFydGljbGVQdHIgc3ViOwoJCXhtbFNjaGVtYUVsZW1lbnRQdHIgZWxlbURlY2w7CiAgICAgICAgICAgICAgICBpbnQgbGF4OwoKCQlzdWIgPSAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW47CiAgICAgICAgICAgICAgICBpZiAoc3ViID09IE5VTEwpCiAgICAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICAgICBzdGFydCA9IHBjdHh0LT5zdGF0ZTsKICAgICAgICAgICAgICAgIHdoaWxlIChzdWIgIT0gTlVMTCkgewogICAgICAgICAgICAgICAgICAgIHBjdHh0LT5zdGF0ZSA9IHN0YXJ0OwoKCQkgICAgZWxlbURlY2wgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgc3ViLT5jaGlsZHJlbjsKCQkgICAgaWYgKGVsZW1EZWNsID09IE5VTEwpIHsKCQkJUEVSUk9SX0lOVCgieG1sU2NoZW1hQnVpbGRBQ29udGVudE1vZGVsIiwKCQkJICAgICI8ZWxlbWVudD4gcGFydGljbGUgaGFzIG5vIHRlcm0iKTsKCQkJcmV0dXJuOwoJCSAgICB9OwoJCSAgICAvKgoJCSAgICAqIE5PVEU6IFRoZSB7bWF4IG9jY3Vyc30gb2YgYWxsIHRoZSBwYXJ0aWNsZXMgaW4gdGhlCgkJICAgICoge3BhcnRpY2xlc30gb2YgdGhlIGdyb3VwIG11c3QgYmUgMCBvciAxOyB0aGlzIGlzCgkJICAgICogYWxyZWFkeSBlbnN1cmVkIGR1cmluZyB0aGUgcGFyc2Ugb2YgdGhlIGNvbnRlbnQgb2YKCQkgICAgKiA8YWxsPi4KCQkgICAgKi8KCQkgICAgaWYgKGVsZW1EZWNsLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fU1VCU1RfR1JPVVBfSEVBRCkgewoJCQlpbnQgY291bnRlcjsKCgkJICAgICAgICAvKgoJCQkgKiBUaGlzIGlzIGFuIGFic3RyYWN0IGdyb3VwLCB3ZSBuZWVkIHRvIHNoYXJlCgkJCSAqIHRoZSBzYW1lIGNvdW50ZXIgZm9yIGFsbCB0aGUgZWxlbWVudCB0cmFuc2l0aW9ucwoJCQkgKiBkZXJpdmVkIGZyb20gdGhlIGdyb3VwCgkJCSAqLwoJCQljb3VudGVyID0geG1sQXV0b21hdGFOZXdDb3VudGVyKHBjdHh0LT5hbSwKCQkJICAgICAgICAgICAgICAgICAgIHN1Yi0+bWluT2NjdXJzLCBzdWItPm1heE9jY3Vycyk7CgkJCXhtbFNjaGVtYUJ1aWxkQ29udGVudE1vZGVsRm9yU3Vic3RHcm91cChwY3R4dCwKCQkJCQkgICBzdWIsIGNvdW50ZXIsIHBjdHh0LT5zdGF0ZSk7CgkJICAgIH0gZWxzZSB7CgkJCWlmICgoc3ViLT5taW5PY2N1cnMgPT0gMSkgJiYKCQkJICAgIChzdWItPm1heE9jY3VycyA9PSAxKSkgewoJCQkgICAgeG1sQXV0b21hdGFOZXdPbmNlVHJhbnMyKHBjdHh0LT5hbSwgcGN0eHQtPnN0YXRlLAoJCQkJCQkgICAgcGN0eHQtPnN0YXRlLAoJCQkJCQkgICAgZWxlbURlY2wtPm5hbWUsCgkJCQkJCSAgICBlbGVtRGVjbC0+dGFyZ2V0TmFtZXNwYWNlLAoJCQkJCQkgICAgMSwgMSwgZWxlbURlY2wpOwoJCQl9IGVsc2UgaWYgKChzdWItPm1pbk9jY3VycyA9PSAwKSAmJgoJCQkgICAgKHN1Yi0+bWF4T2NjdXJzID09IDEpKSB7CgoJCQkgICAgeG1sQXV0b21hdGFOZXdDb3VudFRyYW5zMihwY3R4dC0+YW0sIHBjdHh0LT5zdGF0ZSwKCQkJCQkJICAgICBwY3R4dC0+c3RhdGUsCgkJCQkJCSAgICAgZWxlbURlY2wtPm5hbWUsCgkJCQkJCSAgICAgZWxlbURlY2wtPnRhcmdldE5hbWVzcGFjZSwKCQkJCQkJICAgICAwLAoJCQkJCQkgICAgIDEsCgkJCQkJCSAgICAgZWxlbURlY2wpOwoJCQl9CgkJICAgIH0KICAgICAgICAgICAgICAgICAgICBzdWIgPSAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHN1Yi0+bmV4dDsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGxheCA9IHBhcnRpY2xlLT5taW5PY2N1cnMgPT0gMDsKICAgICAgICAgICAgICAgIHBjdHh0LT5zdGF0ZSA9CiAgICAgICAgICAgICAgICAgICAgeG1sQXV0b21hdGFOZXdBbGxUcmFucyhwY3R4dC0+YW0sIHBjdHh0LT5zdGF0ZSwgTlVMTCwgbGF4KTsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9CgljYXNlIFhNTF9TQ0hFTUFfVFlQRV9HUk9VUDoKCSAgICAvKgoJICAgICogSWYgd2UgaGl0IGEgbW9kZWwgZ3JvdXAgZGVmaW5pdGlvbiwgdGhlbiB0aGlzIG1lYW5zIHRoYXQKCSAgICAqIGl0IHdhcyBlbXB0eSwgdGh1cyB3YXMgbm90IHN1YnN0aXR1dGVkIGZvciB0aGUgY29udGFpbmluZwoJICAgICogbW9kZWwgZ3JvdXAuIEp1c3QgZG8gbm90aGluZyBpbiB0aGlzIGNhc2UuCgkgICAgKiBUT0RPOiBCdXQgdGhlIGdyb3VwIHNob3VsZCBiZSBzdWJzdGl0dXRlZCBhbmQgbm90IG9jY3VyIGF0CgkgICAgKiBhbGwgaW4gdGhlIGNvbnRlbnQgbW9kZWwgYXQgdGhpcyBwb2ludC4gRml4IHRoaXMuCgkgICAgKi8KCSAgICBicmVhazsKICAgICAgICBkZWZhdWx0OgoJICAgIHhtbFNjaGVtYUludGVybmFsRXJyMihBQ1RYVF9DQVNUIHBjdHh0LAoJCSJ4bWxTY2hlbWFCdWlsZEFDb250ZW50TW9kZWwiLAoJCSJmb3VuZCB1bmV4cGVjdGVkIHRlcm0gb2YgdHlwZSAnJXMnIGluIGNvbnRlbnQgbW9kZWwiLAoJCVdYU19JVEVNX1RZUEVfTkFNRShwYXJ0aWNsZS0+Y2hpbGRyZW4pLCBOVUxMKTsKICAgICAgICAgICAgcmV0dXJuOwogICAgfQp9CgovKioKICogeG1sU2NoZW1hQnVpbGRDb250ZW50TW9kZWw6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKiBAbmFtZTogIHRoZSBlbGVtZW50IG5hbWUKICoKICogQnVpbGRzIHRoZSBjb250ZW50IG1vZGVsIG9mIHRoZSBjb21wbGV4IHR5cGUuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFCdWlsZENvbnRlbnRNb2RlbCh4bWxTY2hlbWFUeXBlUHRyIHR5cGUsCgkJCSAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCkKewogICAgaWYgKCh0eXBlLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYKSB8fAoJKHR5cGUtPmNvbnRNb2RlbCAhPSBOVUxMKSB8fAoJKCh0eXBlLT5jb250ZW50VHlwZSAhPSBYTUxfU0NIRU1BX0NPTlRFTlRfRUxFTUVOVFMpICYmCgkodHlwZS0+Y29udGVudFR5cGUgIT0gWE1MX1NDSEVNQV9DT05URU5UX01JWEVEKSkpCglyZXR1cm47CgojaWZkZWYgREVCVUdfQ09OVEVOVAogICAgeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsCiAgICAgICAgICAgICAgICAgICAgIkJ1aWxkaW5nIGNvbnRlbnQgbW9kZWwgZm9yICVzXG4iLCBuYW1lKTsKI2VuZGlmCiAgICBjdHh0LT5hbSA9IE5VTEw7CiAgICBjdHh0LT5hbSA9IHhtbE5ld0F1dG9tYXRhKCk7CiAgICBpZiAoY3R4dC0+YW0gPT0gTlVMTCkgewogICAgICAgIHhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LAoJICAgICJDYW5ub3QgY3JlYXRlIGF1dG9tYXRhIGZvciBjb21wbGV4IHR5cGUgJXNcbiIsIHR5cGUtPm5hbWUpOwogICAgICAgIHJldHVybjsKICAgIH0KICAgIGN0eHQtPnN0YXRlID0geG1sQXV0b21hdGFHZXRJbml0U3RhdGUoY3R4dC0+YW0pOwogICAgLyoKICAgICogQnVpbGQgdGhlIGF1dG9tYXRvbi4KICAgICovCiAgICB4bWxTY2hlbWFCdWlsZEFDb250ZW50TW9kZWwoY3R4dCwgV1hTX1RZUEVfUEFSVElDTEUodHlwZSkpOwogICAgeG1sQXV0b21hdGFTZXRGaW5hbFN0YXRlKGN0eHQtPmFtLCBjdHh0LT5zdGF0ZSk7CiAgICB0eXBlLT5jb250TW9kZWwgPSB4bWxBdXRvbWF0YUNvbXBpbGUoY3R4dC0+YW0pOwogICAgaWYgKHR5cGUtPmNvbnRNb2RlbCA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX0lOVEVSTkFMLAoJICAgIFdYU19CQVNJQ19DQVNUIHR5cGUsIHR5cGUtPm5vZGUsCgkgICAgIkZhaWxlZCB0byBjb21waWxlIHRoZSBjb250ZW50IG1vZGVsIiwgTlVMTCk7CiAgICB9IGVsc2UgaWYgKHhtbFJlZ2V4cElzRGV0ZXJtaW5pc3QodHlwZS0+Y29udE1vZGVsKSAhPSAxKSB7CiAgICAgICAgeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX05PVF9ERVRFUk1JTklTVElDLAoJICAgIC8qIFhNTF9TQ0hFTUFTX0VSUl9OT1RERVRFUk1JTklTVCwgKi8KCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCB0eXBlLT5ub2RlLAoJICAgICJUaGUgY29udGVudCBtb2RlbCBpcyBub3QgZGV0ZXJtaW5pc3QiLCBOVUxMKTsKICAgIH0gZWxzZSB7CiNpZmRlZiBERUJVR19DT05URU5UX1JFR0VYUAogICAgICAgIHhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LAogICAgICAgICAgICAgICAgICAgICAgICAiQ29udGVudCBtb2RlbCBvZiAlczpcbiIsIHR5cGUtPm5hbWUpOwogICAgICAgIHhtbFJlZ2V4cFByaW50KHN0ZGVyciwgdHlwZS0+Y29udE1vZGVsKTsKI2VuZGlmCiAgICB9CiAgICBjdHh0LT5zdGF0ZSA9IE5VTEw7CiAgICB4bWxGcmVlQXV0b21hdGEoY3R4dC0+YW0pOwogICAgY3R4dC0+YW0gPSBOVUxMOwp9CgovKioKICogeG1sU2NoZW1hUmVzb2x2ZUVsZW1lbnRSZWZlcmVuY2VzOgogKiBAZWxlbTogIHRoZSBzY2hlbWEgZWxlbWVudCBjb250ZXh0CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKgogKiBSZXNvbHZlcyB0aGUgcmVmZXJlbmNlcyBvZiBhbiBlbGVtZW50IGRlY2xhcmF0aW9uCiAqIG9yIHBhcnRpY2xlLCB3aGljaCBoYXMgYW4gZWxlbWVudCBkZWNsYXJhdGlvbiBhcyBpdCdzCiAqIHRlcm0uCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFSZXNvbHZlRWxlbWVudFJlZmVyZW5jZXMoeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtRGVjbCwKCQkJCSAgeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0KQp7CiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKGVsZW1EZWNsID09IE5VTEwpIHx8CgkoKGVsZW1EZWNsICE9IE5VTEwpICYmCgkoZWxlbURlY2wtPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9JTlRFUk5BTF9SRVNPTFZFRCkpKQogICAgICAgIHJldHVybjsKICAgIGVsZW1EZWNsLT5mbGFncyB8PSBYTUxfU0NIRU1BU19FTEVNX0lOVEVSTkFMX1JFU09MVkVEOwoKICAgIGlmICgoZWxlbURlY2wtPnN1YnR5cGVzID09IE5VTEwpICYmIChlbGVtRGVjbC0+bmFtZWRUeXBlICE9IE5VTEwpKSB7Cgl4bWxTY2hlbWFUeXBlUHRyIHR5cGU7CgoJLyogKHR5cGUgZGVmaW5pdGlvbikgLi4uIG90aGVyd2lzZSB0aGUgdHlwZSBkZWZpbml0aW9uILdyZXNvbHZlZLcKCSogdG8gYnkgdGhlILdhY3R1YWwgdmFsdWW3IG9mIHRoZSB0eXBlIFthdHRyaWJ1dGVdIC4uLgoJKi8KCXR5cGUgPSB4bWxTY2hlbWFHZXRUeXBlKGN0eHQtPnNjaGVtYSwgZWxlbURlY2wtPm5hbWVkVHlwZSwKCSAgICBlbGVtRGVjbC0+bmFtZWRUeXBlTnMpOwoJaWYgKHR5cGUgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBSZXNDb21wQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19SRVNPTFZFLAoJCVdYU19CQVNJQ19DQVNUIGVsZW1EZWNsLCBlbGVtRGVjbC0+bm9kZSwKCQkidHlwZSIsIGVsZW1EZWNsLT5uYW1lZFR5cGUsIGVsZW1EZWNsLT5uYW1lZFR5cGVOcywKCQlYTUxfU0NIRU1BX1RZUEVfQkFTSUMsICJ0eXBlIGRlZmluaXRpb24iKTsKCX0gZWxzZQoJICAgIGVsZW1EZWNsLT5zdWJ0eXBlcyA9IHR5cGU7CiAgICB9CiAgICBpZiAoZWxlbURlY2wtPnN1YnN0R3JvdXAgIT0gTlVMTCkgewoJeG1sU2NoZW1hRWxlbWVudFB0ciBzdWJzdEhlYWQ7CgoJLyoKCSogRklYTUUgVE9ETzogRG8gd2UgbmVlZCBhIG5ldyBmaWVsZCBpbiBfeG1sU2NoZW1hRWxlbWVudCBmb3IKCSogc3Vic3RpdHV0aW9uR3JvdXA/CgkqLwoJc3Vic3RIZWFkID0geG1sU2NoZW1hR2V0RWxlbShjdHh0LT5zY2hlbWEsIGVsZW1EZWNsLT5zdWJzdEdyb3VwLAoJICAgIGVsZW1EZWNsLT5zdWJzdEdyb3VwTnMpOwoJaWYgKHN1YnN0SGVhZCA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hUFJlc0NvbXBBdHRyRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUsCgkJV1hTX0JBU0lDX0NBU1QgZWxlbURlY2wsIE5VTEwsCgkJInN1YnN0aXR1dGlvbkdyb3VwIiwgZWxlbURlY2wtPnN1YnN0R3JvdXAsCgkJZWxlbURlY2wtPnN1YnN0R3JvdXBOcywgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQsIE5VTEwpOwoJfSBlbHNlIHsKCSAgICB4bWxTY2hlbWFSZXNvbHZlRWxlbWVudFJlZmVyZW5jZXMoc3Vic3RIZWFkLCBjdHh0KTsKCSAgICAvKgoJICAgICogU2V0IHRoZSAic3Vic3RpdHV0aW9uIGdyb3VwIGFmZmlsaWF0aW9uIi4KCSAgICAqIE5PVEUgdGhhdCBub3cgd2UgdXNlIHRoZSAicmVmRGVjbCIgZmllbGQgZm9yIHRoaXMuCgkgICAgKi8KCSAgICBXWFNfU1VCU1RfSEVBRChlbGVtRGVjbCkgPSBzdWJzdEhlYWQ7CgkgICAgLyoKCSAgICAqIFRoZSB0eXBlIGRlZmluaXRpb25zIGlzIHNldCB0bzoKCSAgICAqIFNQRUMgIi4uLnRoZSB7dHlwZSBkZWZpbml0aW9ufSBvZiB0aGUgZWxlbWVudAoJICAgICogZGVjbGFyYXRpb24gt3Jlc29sdmVktyB0byBieSB0aGUgt2FjdHVhbCB2YWx1ZbcKCSAgICAqIG9mIHRoZSBzdWJzdGl0dXRpb25Hcm91cCBbYXR0cmlidXRlXSwgaWYgcHJlc2VudCIKCSAgICAqLwoJICAgIGlmIChlbGVtRGVjbC0+c3VidHlwZXMgPT0gTlVMTCkKCQllbGVtRGVjbC0+c3VidHlwZXMgPSBzdWJzdEhlYWQtPnN1YnR5cGVzOwoJfQogICAgfQogICAgLyoKICAgICogU1BFQyAiVGhlIGRlZmluaXRpb24gb2YgYW55VHlwZSBzZXJ2ZXMgYXMgdGhlIGRlZmF1bHQgdHlwZSBkZWZpbml0aW9uCiAgICAqIGZvciBlbGVtZW50IGRlY2xhcmF0aW9ucyB3aG9zZSBYTUwgcmVwcmVzZW50YXRpb24gZG9lcyBub3Qgc3BlY2lmeSBvbmUuIgogICAgKi8KICAgIGlmICgoZWxlbURlY2wtPnN1YnR5cGVzID09IE5VTEwpICYmCgkoZWxlbURlY2wtPm5hbWVkVHlwZSA9PSBOVUxMKSAmJgoJKGVsZW1EZWNsLT5zdWJzdEdyb3VwID09IE5VTEwpKQoJZWxlbURlY2wtPnN1YnR5cGVzID0geG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfQU5ZVFlQRSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFSZXNvbHZlVW5pb25NZW1iZXJUeXBlczoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEB0eXBlOiAgdGhlIHNjaGVtYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uCiAqCiAqIENoZWNrcyBhbmQgYnVpbGRzIHRoZSAibWVtYmVyIHR5cGUgZGVmaW5pdGlvbnMiIHByb3BlcnR5IG9mIHRoZSB1bmlvbgogKiBzaW1wbGUgdHlwZS4gVGhpcyBoYW5kbGVzIHBhcnQgKDEpLCBwYXJ0ICgyKSBpcyBkb25lIGluCiAqIHhtbFNjaGVtYUZpbmlzaE1lbWJlclR5cGVEZWZpbml0aW9uc1Byb3BlcnR5KCkKICoKICogUmV0dXJucyAtMSBpbiBjYXNlIG9mIGFuIGludGVybmFsIGVycm9yLCAwIG90aGVyd2lzZS4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUmVzb2x2ZVVuaW9uTWVtYmVyVHlwZXMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewoKICAgIHhtbFNjaGVtYVR5cGVMaW5rUHRyIGxpbmssIGxhc3RMaW5rLCBuZXdMaW5rOwogICAgeG1sU2NoZW1hVHlwZVB0ciBtZW1iZXJUeXBlOwoKICAgIC8qCiAgICAqIFNQRUMgKDEpICJJZiB0aGUgPHVuaW9uPiBhbHRlcm5hdGl2ZSBpcyBjaG9zZW4sIHRoZW4gW0RlZmluaXRpb246XQogICAgKiBkZWZpbmUgdGhlIGV4cGxpY2l0IG1lbWJlcnMgYXMgdGhlIHR5cGUgZGVmaW5pdGlvbnMgt3Jlc29sdmVktwogICAgKiB0byBieSB0aGUgaXRlbXMgaW4gdGhlILdhY3R1YWwgdmFsdWW3IG9mIHRoZSBtZW1iZXJUeXBlcyBbYXR0cmlidXRlXSwKICAgICogaWYgYW55LCBmb2xsb3dlZCBieSB0aGUgdHlwZSBkZWZpbml0aW9ucyBjb3JyZXNwb25kaW5nIHRvIHRoZQogICAgKiA8c2ltcGxlVHlwZT5zIGFtb25nIHRoZSBbY2hpbGRyZW5dIG9mIDx1bmlvbj4sIGlmIGFueS4iCiAgICAqLwogICAgLyoKICAgICogUmVzb2x2ZSByZWZlcmVuY2VzLgogICAgKi8KICAgIGxpbmsgPSB0eXBlLT5tZW1iZXJUeXBlczsKICAgIGxhc3RMaW5rID0gTlVMTDsKICAgIHdoaWxlIChsaW5rICE9IE5VTEwpIHsKCWNvbnN0IHhtbENoYXIgKm5hbWUsICpuc05hbWU7CgoJbmFtZSA9ICgoeG1sU2NoZW1hUU5hbWVSZWZQdHIpIGxpbmstPnR5cGUpLT5uYW1lOwoJbnNOYW1lID0gKCh4bWxTY2hlbWFRTmFtZVJlZlB0cikgbGluay0+dHlwZSktPnRhcmdldE5hbWVzcGFjZTsKCgltZW1iZXJUeXBlID0geG1sU2NoZW1hR2V0VHlwZShjdHh0LT5zY2hlbWEsIG5hbWUsIG5zTmFtZSk7CglpZiAoKG1lbWJlclR5cGUgPT0gTlVMTCkgfHwgKCEgV1hTX0lTX1NJTVBMRShtZW1iZXJUeXBlKSkpIHsKCSAgICB4bWxTY2hlbWFQUmVzQ29tcEF0dHJFcnIoY3R4dCwgWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUsCgkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgdHlwZS0+bm9kZSwgIm1lbWJlclR5cGVzIiwKCQluYW1lLCBuc05hbWUsIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUsIE5VTEwpOwoJICAgIC8qCgkgICAgKiBSZW1vdmUgdGhlIG1lbWJlciB0eXBlIGxpbmsuCgkgICAgKi8KCSAgICBpZiAobGFzdExpbmsgPT0gTlVMTCkKCQl0eXBlLT5tZW1iZXJUeXBlcyA9IGxpbmstPm5leHQ7CgkgICAgZWxzZQoJCWxhc3RMaW5rLT5uZXh0ID0gbGluay0+bmV4dDsKCSAgICBuZXdMaW5rID0gbGluazsKCSAgICBsaW5rID0gbGluay0+bmV4dDsKCSAgICB4bWxGcmVlKG5ld0xpbmspOwoJfSBlbHNlIHsKCSAgICBsaW5rLT50eXBlID0gbWVtYmVyVHlwZTsKCSAgICBsYXN0TGluayA9IGxpbms7CgkgICAgbGluayA9IGxpbmstPm5leHQ7Cgl9CiAgICB9CiAgICAvKgogICAgKiBBZGQgbG9jYWwgc2ltcGxlIHR5cGVzLAogICAgKi8KICAgIG1lbWJlclR5cGUgPSB0eXBlLT5zdWJ0eXBlczsKICAgIHdoaWxlIChtZW1iZXJUeXBlICE9IE5VTEwpIHsKCWxpbmsgPSAoeG1sU2NoZW1hVHlwZUxpbmtQdHIpIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hVHlwZUxpbmspKTsKCWlmIChsaW5rID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyTWVtb3J5KGN0eHQsICJhbGxvY2F0aW5nIGEgdHlwZSBsaW5rIiwgTlVMTCk7CgkgICAgcmV0dXJuICgtMSk7Cgl9CglsaW5rLT50eXBlID0gbWVtYmVyVHlwZTsKCWxpbmstPm5leHQgPSBOVUxMOwoJaWYgKGxhc3RMaW5rID09IE5VTEwpCgkgICAgdHlwZS0+bWVtYmVyVHlwZXMgPSBsaW5rOwoJZWxzZQoJICAgIGxhc3RMaW5rLT5uZXh0ID0gbGluazsKCWxhc3RMaW5rID0gbGluazsKCW1lbWJlclR5cGUgPSBtZW1iZXJUeXBlLT5uZXh0OwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUlzRGVyaXZlZEZyb21CdWlsdEluVHlwZToKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEB0eXBlOiAgdGhlIHR5cGUgZGVmaW5pdGlvbgogKiBAdmFsVHlwZTogdGhlIHZhbHVlIHR5cGUKICoKICoKICogUmV0dXJucyAxIGlmIHRoZSB0eXBlIGhhcyB0aGUgZ2l2ZW4gdmFsdWUgdHlwZSwgb3IKICogaXMgZGVyaXZlZCBmcm9tIHN1Y2ggYSB0eXBlLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFJc0Rlcml2ZWRGcm9tQnVpbHRJblR5cGUoeG1sU2NoZW1hVHlwZVB0ciB0eXBlLCBpbnQgdmFsVHlwZSkKewogICAgaWYgKHR5cGUgPT0gTlVMTCkKCXJldHVybiAoMCk7CiAgICBpZiAoV1hTX0lTX0NPTVBMRVgodHlwZSkpCglyZXR1cm4gKDApOwogICAgaWYgKHR5cGUtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKSB7CglpZiAodHlwZS0+YnVpbHRJblR5cGUgPT0gdmFsVHlwZSkKCSAgICByZXR1cm4oMSk7CglpZiAoKHR5cGUtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX0FOWVNJTVBMRVRZUEUpIHx8CgkgICAgKHR5cGUtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX0FOWVRZUEUpKQoJICAgIHJldHVybiAoMCk7CglyZXR1cm4oeG1sU2NoZW1hSXNEZXJpdmVkRnJvbUJ1aWx0SW5UeXBlKHR5cGUtPnN1YnR5cGVzLCB2YWxUeXBlKSk7CiAgICB9CiAgICByZXR1cm4oeG1sU2NoZW1hSXNEZXJpdmVkRnJvbUJ1aWx0SW5UeXBlKHR5cGUtPnN1YnR5cGVzLCB2YWxUeXBlKSk7Cn0KCiNpZiAwCi8qKgogKiB4bWxTY2hlbWFJc0Rlcml2ZWRGcm9tQnVpbHRJblR5cGU6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSB0eXBlIGRlZmluaXRpb24KICogQHZhbFR5cGU6IHRoZSB2YWx1ZSB0eXBlCiAqCiAqCiAqIFJldHVybnMgMSBpZiB0aGUgdHlwZSBoYXMgdGhlIGdpdmVuIHZhbHVlIHR5cGUsIG9yCiAqIGlzIGRlcml2ZWQgZnJvbSBzdWNoIGEgdHlwZS4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hSXNVc2VyRGVyaXZlZEZyb21CdWlsdEluVHlwZSh4bWxTY2hlbWFUeXBlUHRyIHR5cGUsIGludCB2YWxUeXBlKQp7CiAgICBpZiAodHlwZSA9PSBOVUxMKQoJcmV0dXJuICgwKTsKICAgIGlmIChXWFNfSVNfQ09NUExFWCh0eXBlKSkKCXJldHVybiAoMCk7CiAgICBpZiAodHlwZS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpIHsKCWlmICh0eXBlLT5idWlsdEluVHlwZSA9PSB2YWxUeXBlKQoJICAgIHJldHVybigxKTsKCXJldHVybiAoMCk7CiAgICB9IGVsc2UKCXJldHVybih4bWxTY2hlbWFJc0Rlcml2ZWRGcm9tQnVpbHRJblR5cGUodHlwZS0+c3VidHlwZXMsIHZhbFR5cGUpKTsKCiAgICByZXR1cm4gKDApOwp9CiNlbmRpZgoKc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIKeG1sU2NoZW1hUXVlcnlCdWlsdEluVHlwZSh4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIGlmICh0eXBlID09IE5VTEwpCglyZXR1cm4gKE5VTEwpOwogICAgaWYgKFdYU19JU19DT01QTEVYKHR5cGUpKQoJcmV0dXJuIChOVUxMKTsKICAgIGlmICh0eXBlLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykKCXJldHVybih0eXBlKTsKICAgIHJldHVybih4bWxTY2hlbWFRdWVyeUJ1aWx0SW5UeXBlKHR5cGUtPnN1YnR5cGVzKSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFHZXRQcmltaXRpdmVUeXBlOgogKiBAdHlwZTogIHRoZSBzaW1wbGVUeXBlIGRlZmluaXRpb24KICoKICogUmV0dXJucyB0aGUgcHJpbWl0aXZlIHR5cGUgb2YgdGhlIGdpdmVuIHR5cGUgb3IKICogTlVMTCBpbiBjYXNlIG9mIGVycm9yLgogKi8Kc3RhdGljIHhtbFNjaGVtYVR5cGVQdHIKeG1sU2NoZW1hR2V0UHJpbWl0aXZlVHlwZSh4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKCiAgICB3aGlsZSAodHlwZSAhPSBOVUxMKSB7CgkvKgoJKiBOb3RlIHRoYXQgYW55U2ltcGxlVHlwZSBpcyBhY3R1YWxseSBub3QgYSBwcmltaXRpdmUgdHlwZQoJKiBidXQgd2UgbmVlZCB0aGF0IGhlcmUuCgkqLwoJaWYgKCh0eXBlLT5idWlsdEluVHlwZSA9PSBYTUxfU0NIRU1BU19BTllTSU1QTEVUWVBFKSB8fAoJICAgKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9CVUlMVElOX1BSSU1JVElWRSkpCgkgICAgcmV0dXJuICh0eXBlKTsKCXR5cGUgPSB0eXBlLT5iYXNlVHlwZTsKICAgIH0KCiAgICByZXR1cm4gKE5VTEwpOwp9CgojaWYgMAovKioKICogeG1sU2NoZW1hR2V0QnVpbHRJblR5cGVBbmNlc3RvcjoKICogQHR5cGU6ICB0aGUgc2ltcGxlVHlwZSBkZWZpbml0aW9uCiAqCiAqIFJldHVybnMgdGhlIHByaW1pdGl2ZSB0eXBlIG9mIHRoZSBnaXZlbiB0eXBlIG9yCiAqIE5VTEwgaW4gY2FzZSBvZiBlcnJvci4KICovCnN0YXRpYyB4bWxTY2hlbWFUeXBlUHRyCnhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlQW5jZXN0b3IoeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICBpZiAoV1hTX0lTX0xJU1QodHlwZSkgfHwgV1hTX0lTX1VOSU9OKHR5cGUpKQoJcmV0dXJuICgwKTsKICAgIHdoaWxlICh0eXBlICE9IE5VTEwpIHsKCWlmICh0eXBlLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykKCSAgICByZXR1cm4gKHR5cGUpOwoJdHlwZSA9IHR5cGUtPmJhc2VUeXBlOwogICAgfQoKICAgIHJldHVybiAoTlVMTCk7Cn0KI2VuZGlmCgovKioKICogeG1sU2NoZW1hQ2xvbmVXaWxkY2FyZE5zQ29uc3RyYWludHM6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAZGVzdDogIHRoZSBkZXN0aW5hdGlvbiB3aWxkY2FyZAogKiBAc291cmNlOiB0aGUgc291cmNlIHdpbGRjYXJkCiAqCiAqIENsb25lcyB0aGUgbmFtZXNwYWNlIGNvbnN0cmFpbnRzIG9mIHNvdXJjZQogKiBhbmQgYXNzaWduZXMgdGhlbSB0byBkZXN0LgogKiBSZXR1cm5zIC0xIG9uIGludGVybmFsIGVycm9yLCAwIG90aGVyd2lzZS4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2xvbmVXaWxkY2FyZE5zQ29uc3RyYWludHMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJICAgIHhtbFNjaGVtYVdpbGRjYXJkUHRyIGRlc3QsCgkJCQkgICAgeG1sU2NoZW1hV2lsZGNhcmRQdHIgc291cmNlKQp7CiAgICB4bWxTY2hlbWFXaWxkY2FyZE5zUHRyIGN1ciwgdG1wLCBsYXN0OwoKICAgIGlmICgoc291cmNlID09IE5VTEwpIHx8IChkZXN0ID09IE5VTEwpKQoJcmV0dXJuKC0xKTsKICAgIGRlc3QtPmFueSA9IHNvdXJjZS0+YW55OwogICAgY3VyID0gc291cmNlLT5uc1NldDsKICAgIGxhc3QgPSBOVUxMOwogICAgd2hpbGUgKGN1ciAhPSBOVUxMKSB7Cgl0bXAgPSB4bWxTY2hlbWFOZXdXaWxkY2FyZE5zQ29uc3RyYWludChjdHh0KTsKCWlmICh0bXAgPT0gTlVMTCkKCSAgICByZXR1cm4oLTEpOwoJdG1wLT52YWx1ZSA9IGN1ci0+dmFsdWU7CglpZiAobGFzdCA9PSBOVUxMKQoJICAgIGRlc3QtPm5zU2V0ID0gdG1wOwoJZWxzZQoJICAgIGxhc3QtPm5leHQgPSB0bXA7CglsYXN0ID0gdG1wOwoJY3VyID0gY3VyLT5uZXh0OwogICAgfQogICAgaWYgKGRlc3QtPm5lZ05zU2V0ICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlV2lsZGNhcmROc1NldChkZXN0LT5uZWdOc1NldCk7CiAgICBpZiAoc291cmNlLT5uZWdOc1NldCAhPSBOVUxMKSB7CglkZXN0LT5uZWdOc1NldCA9IHhtbFNjaGVtYU5ld1dpbGRjYXJkTnNDb25zdHJhaW50KGN0eHQpOwoJaWYgKGRlc3QtPm5lZ05zU2V0ID09IE5VTEwpCgkgICAgcmV0dXJuKC0xKTsKCWRlc3QtPm5lZ05zU2V0LT52YWx1ZSA9IHNvdXJjZS0+bmVnTnNTZXQtPnZhbHVlOwogICAgfSBlbHNlCglkZXN0LT5uZWdOc1NldCA9IE5VTEw7CiAgICByZXR1cm4oMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFVbmlvbldpbGRjYXJkczoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBjb21wbGV0ZVdpbGQ6ICB0aGUgZmlyc3Qgd2lsZGNhcmQKICogQGN1cldpbGQ6IHRoZSBzZWNvbmQgd2lsZGNhcmQKICoKICogVW5pb25zIHRoZSBuYW1lc3BhY2UgY29uc3RyYWludHMgb2YgdGhlIGdpdmVuIHdpbGRjYXJkcy4KICogQGNvbXBsZXRlV2lsZCB3aWxsIGhvbGQgdGhlIHJlc3VsdGluZyB1bmlvbi4KICogUmV0dXJucyBhIHBvc2l0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZSwgLTEgaW4gY2FzZSBvZiBhbgogKiBpbnRlcm5hbCBlcnJvciwgMCBvdGhlcndpc2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVVuaW9uV2lsZGNhcmRzKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICAgIHhtbFNjaGVtYVdpbGRjYXJkUHRyIGNvbXBsZXRlV2lsZCwKCQkJICAgIHhtbFNjaGVtYVdpbGRjYXJkUHRyIGN1cldpbGQpCnsKICAgIHhtbFNjaGVtYVdpbGRjYXJkTnNQdHIgY3VyLCBjdXJCLCB0bXA7CgogICAgLyoKICAgICogMSBJZiBPMSBhbmQgTzIgYXJlIHRoZSBzYW1lIHZhbHVlLCB0aGVuIHRoYXQgdmFsdWUgbXVzdCBiZSB0aGUKICAgICogdmFsdWUuCiAgICAqLwogICAgaWYgKChjb21wbGV0ZVdpbGQtPmFueSA9PSBjdXJXaWxkLT5hbnkpICYmCgkoKGNvbXBsZXRlV2lsZC0+bnNTZXQgPT0gTlVMTCkgPT0gKGN1cldpbGQtPm5zU2V0ID09IE5VTEwpKSAmJgoJKChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ID09IE5VTEwpID09IChjdXJXaWxkLT5uZWdOc1NldCA9PSBOVUxMKSkpIHsKCglpZiAoKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgPT0gTlVMTCkgfHwKCSAgICAoY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgPT0gY3VyV2lsZC0+bmVnTnNTZXQtPnZhbHVlKSkgewoKCSAgICBpZiAoY29tcGxldGVXaWxkLT5uc1NldCAhPSBOVUxMKSB7CgkJaW50IGZvdW5kID0gMDsKCgkJLyoKCQkqIENoZWNrIGVxdWFsaXR5IG9mIHNldHMuCgkJKi8KCQljdXIgPSBjb21wbGV0ZVdpbGQtPm5zU2V0OwoJCXdoaWxlIChjdXIgIT0gTlVMTCkgewoJCSAgICBmb3VuZCA9IDA7CgkJICAgIGN1ckIgPSBjdXJXaWxkLT5uc1NldDsKCQkgICAgd2hpbGUgKGN1ckIgIT0gTlVMTCkgewoJCQlpZiAoY3VyLT52YWx1ZSA9PSBjdXJCLT52YWx1ZSkgewoJCQkgICAgZm91bmQgPSAxOwoJCQkgICAgYnJlYWs7CgkJCX0KCQkJY3VyQiA9IGN1ckItPm5leHQ7CgkJICAgIH0KCQkgICAgaWYgKCFmb3VuZCkKCQkJYnJlYWs7CgkJICAgIGN1ciA9IGN1ci0+bmV4dDsKCQl9CgkJaWYgKGZvdW5kKQoJCSAgICByZXR1cm4oMCk7CgkgICAgfSBlbHNlCgkJcmV0dXJuKDApOwoJfQogICAgfQogICAgLyoKICAgICogMiBJZiBlaXRoZXIgTzEgb3IgTzIgaXMgYW55LCB0aGVuIGFueSBtdXN0IGJlIHRoZSB2YWx1ZQogICAgKi8KICAgIGlmIChjb21wbGV0ZVdpbGQtPmFueSAhPSBjdXJXaWxkLT5hbnkpIHsKCWlmIChjb21wbGV0ZVdpbGQtPmFueSA9PSAwKSB7CgkgICAgY29tcGxldGVXaWxkLT5hbnkgPSAxOwoJICAgIGlmIChjb21wbGV0ZVdpbGQtPm5zU2V0ICE9IE5VTEwpIHsKCQl4bWxTY2hlbWFGcmVlV2lsZGNhcmROc1NldChjb21wbGV0ZVdpbGQtPm5zU2V0KTsKCQljb21wbGV0ZVdpbGQtPm5zU2V0ID0gTlVMTDsKCSAgICB9CgkgICAgaWYgKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgewoJCXhtbEZyZWUoY29tcGxldGVXaWxkLT5uZWdOc1NldCk7CgkJY29tcGxldGVXaWxkLT5uZWdOc1NldCA9IE5VTEw7CgkgICAgfQoJfQoJcmV0dXJuICgwKTsKICAgIH0KICAgIC8qCiAgICAqIDMgSWYgYm90aCBPMSBhbmQgTzIgYXJlIHNldHMgb2YgKG5hbWVzcGFjZSBuYW1lcyBvciC3YWJzZW50tyksCiAgICAqIHRoZW4gdGhlIHVuaW9uIG9mIHRob3NlIHNldHMgbXVzdCBiZSB0aGUgdmFsdWUuCiAgICAqLwogICAgaWYgKChjb21wbGV0ZVdpbGQtPm5zU2V0ICE9IE5VTEwpICYmIChjdXJXaWxkLT5uc1NldCAhPSBOVUxMKSkgewoJaW50IGZvdW5kOwoJeG1sU2NoZW1hV2lsZGNhcmROc1B0ciBzdGFydDsKCgljdXIgPSBjdXJXaWxkLT5uc1NldDsKCXN0YXJ0ID0gY29tcGxldGVXaWxkLT5uc1NldDsKCXdoaWxlIChjdXIgIT0gTlVMTCkgewoJICAgIGZvdW5kID0gMDsKCSAgICBjdXJCID0gc3RhcnQ7CgkgICAgd2hpbGUgKGN1ckIgIT0gTlVMTCkgewoJCWlmIChjdXItPnZhbHVlID09IGN1ckItPnZhbHVlKSB7CgkJICAgIGZvdW5kID0gMTsKCQkgICAgYnJlYWs7CgkJfQoJCWN1ckIgPSBjdXJCLT5uZXh0OwoJICAgIH0KCSAgICBpZiAoIWZvdW5kKSB7CgkJdG1wID0geG1sU2NoZW1hTmV3V2lsZGNhcmROc0NvbnN0cmFpbnQoY3R4dCk7CgkJaWYgKHRtcCA9PSBOVUxMKQoJCSAgICByZXR1cm4gKC0xKTsKCQl0bXAtPnZhbHVlID0gY3VyLT52YWx1ZTsKCQl0bXAtPm5leHQgPSBjb21wbGV0ZVdpbGQtPm5zU2V0OwoJCWNvbXBsZXRlV2lsZC0+bnNTZXQgPSB0bXA7CgkgICAgfQoJICAgIGN1ciA9IGN1ci0+bmV4dDsKCX0KCglyZXR1cm4oMCk7CiAgICB9CiAgICAvKgogICAgKiA0IElmIHRoZSB0d28gYXJlIG5lZ2F0aW9ucyBvZiBkaWZmZXJlbnQgdmFsdWVzIChuYW1lc3BhY2UgbmFtZXMKICAgICogb3Igt2Fic2VudLcpLCB0aGVuIGEgcGFpciBvZiBub3QgYW5kILdhYnNlbnS3IG11c3QgYmUgdGhlIHZhbHVlLgogICAgKi8KICAgIGlmICgoY29tcGxldGVXaWxkLT5uZWdOc1NldCAhPSBOVUxMKSAmJgoJKGN1cldpbGQtPm5lZ05zU2V0ICE9IE5VTEwpICYmCgkoY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgIT0gY3VyV2lsZC0+bmVnTnNTZXQtPnZhbHVlKSkgewoJY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgPSBOVUxMOwoKCXJldHVybigwKTsKICAgIH0KICAgIC8qCiAgICAgKiA1LgogICAgICovCiAgICBpZiAoKChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ICE9IE5VTEwpICYmCgkoY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgIT0gTlVMTCkgJiYKCShjdXJXaWxkLT5uc1NldCAhPSBOVUxMKSkgfHwKCSgoY3VyV2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgJiYKCShjdXJXaWxkLT5uZWdOc1NldC0+dmFsdWUgIT0gTlVMTCkgJiYKCShjb21wbGV0ZVdpbGQtPm5zU2V0ICE9IE5VTEwpKSkgewoKCWludCBuc0ZvdW5kLCBhYnNlbnRGb3VuZCA9IDA7CgoJaWYgKGNvbXBsZXRlV2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJICAgIGN1ciA9IGNvbXBsZXRlV2lsZC0+bnNTZXQ7CgkgICAgY3VyQiA9IGN1cldpbGQtPm5lZ05zU2V0OwoJfSBlbHNlIHsKCSAgICBjdXIgPSBjdXJXaWxkLT5uc1NldDsKCSAgICBjdXJCID0gY29tcGxldGVXaWxkLT5uZWdOc1NldDsKCX0KCW5zRm91bmQgPSAwOwoJd2hpbGUgKGN1ciAhPSBOVUxMKSB7CgkgICAgaWYgKGN1ci0+dmFsdWUgPT0gTlVMTCkKCQlhYnNlbnRGb3VuZCA9IDE7CgkgICAgZWxzZSBpZiAoY3VyLT52YWx1ZSA9PSBjdXJCLT52YWx1ZSkKCQluc0ZvdW5kID0gMTsKCSAgICBpZiAobnNGb3VuZCAmJiBhYnNlbnRGb3VuZCkKCQlicmVhazsKCSAgICBjdXIgPSBjdXItPm5leHQ7Cgl9CgoJaWYgKG5zRm91bmQgJiYgYWJzZW50Rm91bmQpIHsKCSAgICAvKgoJICAgICogNS4xIElmIHRoZSBzZXQgUyBpbmNsdWRlcyBib3RoIHRoZSBuZWdhdGVkIG5hbWVzcGFjZQoJICAgICogbmFtZSBhbmQgt2Fic2VudLcsIHRoZW4gYW55IG11c3QgYmUgdGhlIHZhbHVlLgoJICAgICovCgkgICAgY29tcGxldGVXaWxkLT5hbnkgPSAxOwoJICAgIGlmIChjb21wbGV0ZVdpbGQtPm5zU2V0ICE9IE5VTEwpIHsKCQl4bWxTY2hlbWFGcmVlV2lsZGNhcmROc1NldChjb21wbGV0ZVdpbGQtPm5zU2V0KTsKCQljb21wbGV0ZVdpbGQtPm5zU2V0ID0gTlVMTDsKCSAgICB9CgkgICAgaWYgKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgewoJCXhtbEZyZWUoY29tcGxldGVXaWxkLT5uZWdOc1NldCk7CgkJY29tcGxldGVXaWxkLT5uZWdOc1NldCA9IE5VTEw7CgkgICAgfQoJfSBlbHNlIGlmIChuc0ZvdW5kICYmICghYWJzZW50Rm91bmQpKSB7CgkgICAgLyoKCSAgICAqIDUuMiBJZiB0aGUgc2V0IFMgaW5jbHVkZXMgdGhlIG5lZ2F0ZWQgbmFtZXNwYWNlIG5hbWUKCSAgICAqIGJ1dCBub3Qgt2Fic2VudLcsIHRoZW4gYSBwYWlyIG9mIG5vdCBhbmQgt2Fic2VudLcgbXVzdAoJICAgICogYmUgdGhlIHZhbHVlLgoJICAgICovCgkgICAgaWYgKGNvbXBsZXRlV2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJCXhtbFNjaGVtYUZyZWVXaWxkY2FyZE5zU2V0KGNvbXBsZXRlV2lsZC0+bnNTZXQpOwoJCWNvbXBsZXRlV2lsZC0+bnNTZXQgPSBOVUxMOwoJICAgIH0KCSAgICBpZiAoY29tcGxldGVXaWxkLT5uZWdOc1NldCA9PSBOVUxMKSB7CgkJY29tcGxldGVXaWxkLT5uZWdOc1NldCA9IHhtbFNjaGVtYU5ld1dpbGRjYXJkTnNDb25zdHJhaW50KGN0eHQpOwoJCWlmIChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ID09IE5VTEwpCgkJICAgIHJldHVybiAoLTEpOwoJICAgIH0KCSAgICBjb21wbGV0ZVdpbGQtPm5lZ05zU2V0LT52YWx1ZSA9IE5VTEw7Cgl9IGVsc2UgaWYgKCghbnNGb3VuZCkgJiYgYWJzZW50Rm91bmQpIHsKCSAgICAvKgoJICAgICogNS4zIElmIHRoZSBzZXQgUyBpbmNsdWRlcyC3YWJzZW50tyBidXQgbm90IHRoZSBuZWdhdGVkCgkgICAgKiBuYW1lc3BhY2UgbmFtZSwgdGhlbiB0aGUgdW5pb24gaXMgbm90IGV4cHJlc3NpYmxlLgoJICAgICovCgkgICAgeG1sU2NoZW1hUEVycihjdHh0LCBjb21wbGV0ZVdpbGQtPm5vZGUsCgkJWE1MX1NDSEVNQVBfVU5JT05fTk9UX0VYUFJFU1NJQkxFLAoJCSJUaGUgdW5pb24gb2YgdGhlIHdpbGNhcmQgaXMgbm90IGV4cHJlc3NpYmxlLlxuIiwKCQlOVUxMLCBOVUxMKTsKCSAgICByZXR1cm4oWE1MX1NDSEVNQVBfVU5JT05fTk9UX0VYUFJFU1NJQkxFKTsKCX0gZWxzZSBpZiAoKCFuc0ZvdW5kKSAmJiAoIWFic2VudEZvdW5kKSkgewoJICAgIC8qCgkgICAgKiA1LjQgSWYgdGhlIHNldCBTIGRvZXMgbm90IGluY2x1ZGUgZWl0aGVyIHRoZSBuZWdhdGVkIG5hbWVzcGFjZQoJICAgICogbmFtZSBvciC3YWJzZW50tywgdGhlbiB3aGljaGV2ZXIgb2YgTzEgb3IgTzIgaXMgYSBwYWlyIG9mIG5vdAoJICAgICogYW5kIGEgbmFtZXNwYWNlIG5hbWUgbXVzdCBiZSB0aGUgdmFsdWUuCgkgICAgKi8KCSAgICBpZiAoY29tcGxldGVXaWxkLT5uZWdOc1NldCA9PSBOVUxMKSB7CgkJaWYgKGNvbXBsZXRlV2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJCSAgICB4bWxTY2hlbWFGcmVlV2lsZGNhcmROc1NldChjb21wbGV0ZVdpbGQtPm5zU2V0KTsKCQkgICAgY29tcGxldGVXaWxkLT5uc1NldCA9IE5VTEw7CgkJfQoJCWNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgPSB4bWxTY2hlbWFOZXdXaWxkY2FyZE5zQ29uc3RyYWludChjdHh0KTsKCQlpZiAoY29tcGxldGVXaWxkLT5uZWdOc1NldCA9PSBOVUxMKQoJCSAgICByZXR1cm4gKC0xKTsKCQljb21wbGV0ZVdpbGQtPm5lZ05zU2V0LT52YWx1ZSA9IGN1cldpbGQtPm5lZ05zU2V0LT52YWx1ZTsKCSAgICB9Cgl9CglyZXR1cm4gKDApOwogICAgfQogICAgLyoKICAgICAqIDYuCiAgICAgKi8KICAgIGlmICgoKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgJiYKCShjb21wbGV0ZVdpbGQtPm5lZ05zU2V0LT52YWx1ZSA9PSBOVUxMKSAmJgoJKGN1cldpbGQtPm5zU2V0ICE9IE5VTEwpKSB8fAoJKChjdXJXaWxkLT5uZWdOc1NldCAhPSBOVUxMKSAmJgoJKGN1cldpbGQtPm5lZ05zU2V0LT52YWx1ZSA9PSBOVUxMKSAmJgoJKGNvbXBsZXRlV2lsZC0+bnNTZXQgIT0gTlVMTCkpKSB7CgoJaWYgKGNvbXBsZXRlV2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJICAgIGN1ciA9IGNvbXBsZXRlV2lsZC0+bnNTZXQ7Cgl9IGVsc2UgewoJICAgIGN1ciA9IGN1cldpbGQtPm5zU2V0OwoJfQoJd2hpbGUgKGN1ciAhPSBOVUxMKSB7CgkgICAgaWYgKGN1ci0+dmFsdWUgPT0gTlVMTCkgewoJCS8qCgkJKiA2LjEgSWYgdGhlIHNldCBTIGluY2x1ZGVzILdhYnNlbnS3LCB0aGVuIGFueSBtdXN0IGJlIHRoZQoJCSogdmFsdWUuCgkJKi8KCQljb21wbGV0ZVdpbGQtPmFueSA9IDE7CgkJaWYgKGNvbXBsZXRlV2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJCSAgICB4bWxTY2hlbWFGcmVlV2lsZGNhcmROc1NldChjb21wbGV0ZVdpbGQtPm5zU2V0KTsKCQkgICAgY29tcGxldGVXaWxkLT5uc1NldCA9IE5VTEw7CgkJfQoJCWlmIChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ICE9IE5VTEwpIHsKCQkgICAgeG1sRnJlZShjb21wbGV0ZVdpbGQtPm5lZ05zU2V0KTsKCQkgICAgY29tcGxldGVXaWxkLT5uZWdOc1NldCA9IE5VTEw7CgkJfQoJCXJldHVybiAoMCk7CgkgICAgfQoJICAgIGN1ciA9IGN1ci0+bmV4dDsKCX0KCWlmIChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ID09IE5VTEwpIHsKCSAgICAvKgoJICAgICogNi4yIElmIHRoZSBzZXQgUyBkb2VzIG5vdCBpbmNsdWRlILdhYnNlbnS3LCB0aGVuIGEgcGFpciBvZiBub3QKCSAgICAqIGFuZCC3YWJzZW50tyBtdXN0IGJlIHRoZSB2YWx1ZS4KCSAgICAqLwoJICAgIGlmIChjb21wbGV0ZVdpbGQtPm5zU2V0ICE9IE5VTEwpIHsKCQl4bWxTY2hlbWFGcmVlV2lsZGNhcmROc1NldChjb21wbGV0ZVdpbGQtPm5zU2V0KTsKCQljb21wbGV0ZVdpbGQtPm5zU2V0ID0gTlVMTDsKCSAgICB9CgkgICAgY29tcGxldGVXaWxkLT5uZWdOc1NldCA9IHhtbFNjaGVtYU5ld1dpbGRjYXJkTnNDb25zdHJhaW50KGN0eHQpOwoJICAgIGlmIChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ID09IE5VTEwpCgkJcmV0dXJuICgtMSk7CgkgICAgY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgPSBOVUxMOwoJfQoJcmV0dXJuICgwKTsKICAgIH0KICAgIHJldHVybiAoMCk7Cgp9CgovKioKICogeG1sU2NoZW1hSW50ZXJzZWN0V2lsZGNhcmRzOgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQGNvbXBsZXRlV2lsZDogIHRoZSBmaXJzdCB3aWxkY2FyZAogKiBAY3VyV2lsZDogdGhlIHNlY29uZCB3aWxkY2FyZAogKgogKiBJbnRlcnNlY3RzIHRoZSBuYW1lc3BhY2UgY29uc3RyYWludHMgb2YgdGhlIGdpdmVuIHdpbGRjYXJkcy4KICogQGNvbXBsZXRlV2lsZCB3aWxsIGhvbGQgdGhlIHJlc3VsdGluZyBpbnRlcnNlY3Rpb24uCiAqIFJldHVybnMgYSBwb3NpdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUsIC0xIGluIGNhc2Ugb2YgYW4KICogaW50ZXJuYWwgZXJyb3IsIDAgb3RoZXJ3aXNlLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFJbnRlcnNlY3RXaWxkY2FyZHMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgICAgeG1sU2NoZW1hV2lsZGNhcmRQdHIgY29tcGxldGVXaWxkLAoJCQkgICAgeG1sU2NoZW1hV2lsZGNhcmRQdHIgY3VyV2lsZCkKewogICAgeG1sU2NoZW1hV2lsZGNhcmROc1B0ciBjdXIsIGN1ckIsIHByZXYsICB0bXA7CgogICAgLyoKICAgICogMSBJZiBPMSBhbmQgTzIgYXJlIHRoZSBzYW1lIHZhbHVlLCB0aGVuIHRoYXQgdmFsdWUgbXVzdCBiZSB0aGUKICAgICogdmFsdWUuCiAgICAqLwogICAgaWYgKChjb21wbGV0ZVdpbGQtPmFueSA9PSBjdXJXaWxkLT5hbnkpICYmCgkoKGNvbXBsZXRlV2lsZC0+bnNTZXQgPT0gTlVMTCkgPT0gKGN1cldpbGQtPm5zU2V0ID09IE5VTEwpKSAmJgoJKChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ID09IE5VTEwpID09IChjdXJXaWxkLT5uZWdOc1NldCA9PSBOVUxMKSkpIHsKCglpZiAoKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgPT0gTlVMTCkgfHwKCSAgICAoY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgPT0gY3VyV2lsZC0+bmVnTnNTZXQtPnZhbHVlKSkgewoKCSAgICBpZiAoY29tcGxldGVXaWxkLT5uc1NldCAhPSBOVUxMKSB7CgkJaW50IGZvdW5kID0gMDsKCgkJLyoKCQkqIENoZWNrIGVxdWFsaXR5IG9mIHNldHMuCgkJKi8KCQljdXIgPSBjb21wbGV0ZVdpbGQtPm5zU2V0OwoJCXdoaWxlIChjdXIgIT0gTlVMTCkgewoJCSAgICBmb3VuZCA9IDA7CgkJICAgIGN1ckIgPSBjdXJXaWxkLT5uc1NldDsKCQkgICAgd2hpbGUgKGN1ckIgIT0gTlVMTCkgewoJCQlpZiAoY3VyLT52YWx1ZSA9PSBjdXJCLT52YWx1ZSkgewoJCQkgICAgZm91bmQgPSAxOwoJCQkgICAgYnJlYWs7CgkJCX0KCQkJY3VyQiA9IGN1ckItPm5leHQ7CgkJICAgIH0KCQkgICAgaWYgKCFmb3VuZCkKCQkJYnJlYWs7CgkJICAgIGN1ciA9IGN1ci0+bmV4dDsKCQl9CgkJaWYgKGZvdW5kKQoJCSAgICByZXR1cm4oMCk7CgkgICAgfSBlbHNlCgkJcmV0dXJuKDApOwoJfQogICAgfQogICAgLyoKICAgICogMiBJZiBlaXRoZXIgTzEgb3IgTzIgaXMgYW55LCB0aGVuIHRoZSBvdGhlciBtdXN0IGJlIHRoZSB2YWx1ZS4KICAgICovCiAgICBpZiAoKGNvbXBsZXRlV2lsZC0+YW55ICE9IGN1cldpbGQtPmFueSkgJiYgKGNvbXBsZXRlV2lsZC0+YW55KSkgewoJaWYgKHhtbFNjaGVtYUNsb25lV2lsZGNhcmROc0NvbnN0cmFpbnRzKGN0eHQsIGNvbXBsZXRlV2lsZCwgY3VyV2lsZCkgPT0gLTEpCgkgICAgcmV0dXJuKC0xKTsKCXJldHVybigwKTsKICAgIH0KICAgIC8qCiAgICAqIDMgSWYgZWl0aGVyIE8xIG9yIE8yIGlzIGEgcGFpciBvZiBub3QgYW5kIGEgdmFsdWUgKGEgbmFtZXNwYWNlCiAgICAqIG5hbWUgb3Igt2Fic2VudLcpIGFuZCB0aGUgb3RoZXIgaXMgYSBzZXQgb2YgKG5hbWVzcGFjZSBuYW1lcyBvcgogICAgKiC3YWJzZW50tyksIHRoZW4gdGhhdCBzZXQsIG1pbnVzIHRoZSBuZWdhdGVkIHZhbHVlIGlmIGl0IHdhcyBpbgogICAgKiB0aGUgc2V0LCBtaW51cyC3YWJzZW50tyBpZiBpdCB3YXMgaW4gdGhlIHNldCwgbXVzdCBiZSB0aGUgdmFsdWUuCiAgICAqLwogICAgaWYgKCgoY29tcGxldGVXaWxkLT5uZWdOc1NldCAhPSBOVUxMKSAmJiAoY3VyV2lsZC0+bnNTZXQgIT0gTlVMTCkpIHx8CgkoKGN1cldpbGQtPm5lZ05zU2V0ICE9IE5VTEwpICYmIChjb21wbGV0ZVdpbGQtPm5zU2V0ICE9IE5VTEwpKSkgewoJY29uc3QgeG1sQ2hhciAqbmVnOwoKCWlmIChjb21wbGV0ZVdpbGQtPm5zU2V0ID09IE5VTEwpIHsKCSAgICBuZWcgPSBjb21wbGV0ZVdpbGQtPm5lZ05zU2V0LT52YWx1ZTsKCSAgICBpZiAoeG1sU2NoZW1hQ2xvbmVXaWxkY2FyZE5zQ29uc3RyYWludHMoY3R4dCwgY29tcGxldGVXaWxkLCBjdXJXaWxkKSA9PSAtMSkKCQlyZXR1cm4oLTEpOwoJfSBlbHNlCgkgICAgbmVnID0gY3VyV2lsZC0+bmVnTnNTZXQtPnZhbHVlOwoJLyoKCSogUmVtb3ZlIGFic2VudCBhbmQgbmVnYXRlZC4KCSovCglwcmV2ID0gTlVMTDsKCWN1ciA9IGNvbXBsZXRlV2lsZC0+bnNTZXQ7Cgl3aGlsZSAoY3VyICE9IE5VTEwpIHsKCSAgICBpZiAoY3VyLT52YWx1ZSA9PSBOVUxMKSB7CgkJaWYgKHByZXYgPT0gTlVMTCkKCQkgICAgY29tcGxldGVXaWxkLT5uc1NldCA9IGN1ci0+bmV4dDsKCQllbHNlCgkJICAgIHByZXYtPm5leHQgPSBjdXItPm5leHQ7CgkJeG1sRnJlZShjdXIpOwoJCWJyZWFrOwoJICAgIH0KCSAgICBwcmV2ID0gY3VyOwoJICAgIGN1ciA9IGN1ci0+bmV4dDsKCX0KCWlmIChuZWcgIT0gTlVMTCkgewoJICAgIHByZXYgPSBOVUxMOwoJICAgIGN1ciA9IGNvbXBsZXRlV2lsZC0+bnNTZXQ7CgkgICAgd2hpbGUgKGN1ciAhPSBOVUxMKSB7CgkJaWYgKGN1ci0+dmFsdWUgPT0gbmVnKSB7CgkJICAgIGlmIChwcmV2ID09IE5VTEwpCgkJCWNvbXBsZXRlV2lsZC0+bnNTZXQgPSBjdXItPm5leHQ7CgkJICAgIGVsc2UKCQkJcHJldi0+bmV4dCA9IGN1ci0+bmV4dDsKCQkgICAgeG1sRnJlZShjdXIpOwoJCSAgICBicmVhazsKCQl9CgkJcHJldiA9IGN1cjsKCQljdXIgPSBjdXItPm5leHQ7CgkgICAgfQoJfQoKCXJldHVybigwKTsKICAgIH0KICAgIC8qCiAgICAqIDQgSWYgYm90aCBPMSBhbmQgTzIgYXJlIHNldHMgb2YgKG5hbWVzcGFjZSBuYW1lcyBvciC3YWJzZW50tyksCiAgICAqIHRoZW4gdGhlIGludGVyc2VjdGlvbiBvZiB0aG9zZSBzZXRzIG11c3QgYmUgdGhlIHZhbHVlLgogICAgKi8KICAgIGlmICgoY29tcGxldGVXaWxkLT5uc1NldCAhPSBOVUxMKSAmJiAoY3VyV2lsZC0+bnNTZXQgIT0gTlVMTCkpIHsKCWludCBmb3VuZDsKCgljdXIgPSBjb21wbGV0ZVdpbGQtPm5zU2V0OwoJcHJldiA9IE5VTEw7Cgl3aGlsZSAoY3VyICE9IE5VTEwpIHsKCSAgICBmb3VuZCA9IDA7CgkgICAgY3VyQiA9IGN1cldpbGQtPm5zU2V0OwoJICAgIHdoaWxlIChjdXJCICE9IE5VTEwpIHsKCQlpZiAoY3VyLT52YWx1ZSA9PSBjdXJCLT52YWx1ZSkgewoJCSAgICBmb3VuZCA9IDE7CgkJICAgIGJyZWFrOwoJCX0KCQljdXJCID0gY3VyQi0+bmV4dDsKCSAgICB9CgkgICAgaWYgKCFmb3VuZCkgewoJCWlmIChwcmV2ID09IE5VTEwpCgkJICAgIGNvbXBsZXRlV2lsZC0+bnNTZXQgPSBjdXItPm5leHQ7CgkJZWxzZQoJCSAgICBwcmV2LT5uZXh0ID0gY3VyLT5uZXh0OwoJCXRtcCA9IGN1ci0+bmV4dDsKCQl4bWxGcmVlKGN1cik7CgkJY3VyID0gdG1wOwoJCWNvbnRpbnVlOwoJICAgIH0KCSAgICBwcmV2ID0gY3VyOwoJICAgIGN1ciA9IGN1ci0+bmV4dDsKCX0KCglyZXR1cm4oMCk7CiAgICB9CiAgICAvKiA1IElmIHRoZSB0d28gYXJlIG5lZ2F0aW9ucyBvZiBkaWZmZXJlbnQgbmFtZXNwYWNlIG5hbWVzLAogICAgKiB0aGVuIHRoZSBpbnRlcnNlY3Rpb24gaXMgbm90IGV4cHJlc3NpYmxlCiAgICAqLwogICAgaWYgKChjb21wbGV0ZVdpbGQtPm5lZ05zU2V0ICE9IE5VTEwpICYmCgkoY3VyV2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgJiYKCShjb21wbGV0ZVdpbGQtPm5lZ05zU2V0LT52YWx1ZSAhPSBjdXJXaWxkLT5uZWdOc1NldC0+dmFsdWUpICYmCgkoY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgIT0gTlVMTCkgJiYKCShjdXJXaWxkLT5uZWdOc1NldC0+dmFsdWUgIT0gTlVMTCkpIHsKCgl4bWxTY2hlbWFQRXJyKGN0eHQsIGNvbXBsZXRlV2lsZC0+bm9kZSwgWE1MX1NDSEVNQVBfSU5URVJTRUNUSU9OX05PVF9FWFBSRVNTSUJMRSwKCSAgICAiVGhlIGludGVyc2VjdGlvbiBvZiB0aGUgd2lsY2FyZCBpcyBub3QgZXhwcmVzc2libGUuXG4iLAoJICAgIE5VTEwsIE5VTEwpOwoJcmV0dXJuKFhNTF9TQ0hFTUFQX0lOVEVSU0VDVElPTl9OT1RfRVhQUkVTU0lCTEUpOwogICAgfQogICAgLyoKICAgICogNiBJZiB0aGUgb25lIGlzIGEgbmVnYXRpb24gb2YgYSBuYW1lc3BhY2UgbmFtZSBhbmQgdGhlIG90aGVyCiAgICAqIGlzIGEgbmVnYXRpb24gb2Ygt2Fic2VudLcsIHRoZW4gdGhlIG9uZSB3aGljaCBpcyB0aGUgbmVnYXRpb24KICAgICogb2YgYSBuYW1lc3BhY2UgbmFtZSBtdXN0IGJlIHRoZSB2YWx1ZS4KICAgICovCiAgICBpZiAoKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQgIT0gTlVMTCkgJiYgKGN1cldpbGQtPm5lZ05zU2V0ICE9IE5VTEwpICYmCgkoY29tcGxldGVXaWxkLT5uZWdOc1NldC0+dmFsdWUgIT0gY3VyV2lsZC0+bmVnTnNTZXQtPnZhbHVlKSAmJgoJKGNvbXBsZXRlV2lsZC0+bmVnTnNTZXQtPnZhbHVlID09IE5VTEwpKSB7Cgljb21wbGV0ZVdpbGQtPm5lZ05zU2V0LT52YWx1ZSA9ICBjdXJXaWxkLT5uZWdOc1NldC0+dmFsdWU7CiAgICB9CiAgICByZXR1cm4oMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFJc1dpbGRjYXJkTnNDb25zdHJhaW50U3Vic2V0OgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHN1YjogIHRoZSBmaXJzdCB3aWxkY2FyZAogKiBAc3VwZXI6IHRoZSBzZWNvbmQgd2lsZGNhcmQKICoKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiBXaWxkY2FyZCBTdWJzZXQgKGNvcy1ucy1zdWJzZXQpCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgbmFtZXNwYWNlIGNvbnN0cmFpbnQgb2YgQHN1YiBpcyBhbiBpbnRlbnNpb25hbAogKiBzdWJzZXQgb2YgQHN1cGVyLCAxIG90aGVyd2lzZS4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tDT1NOU1N1YnNldCh4bWxTY2hlbWFXaWxkY2FyZFB0ciBzdWIsCgkJCSAgeG1sU2NoZW1hV2lsZGNhcmRQdHIgc3VwZXIpCnsKICAgIC8qCiAgICAqIDEgc3VwZXIgbXVzdCBiZSBhbnkuCiAgICAqLwogICAgaWYgKHN1cGVyLT5hbnkpCglyZXR1cm4gKDApOwogICAgLyoKICAgICogMi4xIHN1YiBtdXN0IGJlIGEgcGFpciBvZiBub3QgYW5kIGEgbmFtZXNwYWNlIG5hbWUgb3Igt2Fic2VudLcuCiAgICAqIDIuMiBzdXBlciBtdXN0IGJlIGEgcGFpciBvZiBub3QgYW5kIHRoZSBzYW1lIHZhbHVlLgogICAgKi8KICAgIGlmICgoc3ViLT5uZWdOc1NldCAhPSBOVUxMKSAmJgoJKHN1cGVyLT5uZWdOc1NldCAhPSBOVUxMKSAmJgoJKHN1Yi0+bmVnTnNTZXQtPnZhbHVlID09IHN1Yi0+bmVnTnNTZXQtPnZhbHVlKSkKCXJldHVybiAoMCk7CiAgICAvKgogICAgKiAzLjEgc3ViIG11c3QgYmUgYSBzZXQgd2hvc2UgbWVtYmVycyBhcmUgZWl0aGVyIG5hbWVzcGFjZSBuYW1lcyBvciC3YWJzZW50ty4KICAgICovCiAgICBpZiAoc3ViLT5uc1NldCAhPSBOVUxMKSB7CgkvKgoJKiAzLjIuMSBzdXBlciBtdXN0IGJlIHRoZSBzYW1lIHNldCBvciBhIHN1cGVyc2V0IHRoZXJlb2YuCgkqLwoJaWYgKHN1cGVyLT5uc1NldCAhPSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hV2lsZGNhcmROc1B0ciBjdXIsIGN1ckI7CgkgICAgaW50IGZvdW5kID0gMDsKCgkgICAgY3VyID0gc3ViLT5uc1NldDsKCSAgICB3aGlsZSAoY3VyICE9IE5VTEwpIHsKCQlmb3VuZCA9IDA7CgkJY3VyQiA9IHN1cGVyLT5uc1NldDsKCQl3aGlsZSAoY3VyQiAhPSBOVUxMKSB7CgkJICAgIGlmIChjdXItPnZhbHVlID09IGN1ckItPnZhbHVlKSB7CgkJCWZvdW5kID0gMTsKCQkJYnJlYWs7CgkJICAgIH0KCQkgICAgY3VyQiA9IGN1ckItPm5leHQ7CgkJfQoJCWlmICghZm91bmQpCgkJICAgIHJldHVybiAoMSk7CgkJY3VyID0gY3VyLT5uZXh0OwoJICAgIH0KCSAgICBpZiAoZm91bmQpCgkJcmV0dXJuICgwKTsKCX0gZWxzZSBpZiAoc3VwZXItPm5lZ05zU2V0ICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFXaWxkY2FyZE5zUHRyIGN1cjsKCSAgICAvKgoJICAgICogMy4yLjIgc3VwZXIgbXVzdCBiZSBhIHBhaXIgb2Ygbm90IGFuZCBhIG5hbWVzcGFjZSBuYW1lIG9yCgkgICAgKiC3YWJzZW50tyBhbmQgdGhhdCB2YWx1ZSBtdXN0IG5vdCBiZSBpbiBzdWIncyBzZXQuCgkgICAgKi8KCSAgICBjdXIgPSBzdWItPm5zU2V0OwoJICAgIHdoaWxlIChjdXIgIT0gTlVMTCkgewoJCWlmIChjdXItPnZhbHVlID09IHN1cGVyLT5uZWdOc1NldC0+dmFsdWUpCgkJICAgIHJldHVybiAoMSk7CgkJY3VyID0gY3VyLT5uZXh0OwoJICAgIH0KCSAgICByZXR1cm4gKDApOwoJfQogICAgfQogICAgcmV0dXJuICgxKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFHZXRFZmZlY3RpdmVWYWx1ZUNvbnN0cmFpbnQoeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIGF0dHJ1c2UsCgkJCQkgICAgIGludCAqZml4ZWQsCgkJCQkgICAgIGNvbnN0IHhtbENoYXIgKip2YWx1ZSwKCQkJCSAgICAgeG1sU2NoZW1hVmFsUHRyICp2YWwpCnsKICAgICpmaXhlZCA9IDA7CiAgICAqdmFsdWUgPSBOVUxMOwogICAgaWYgKHZhbCAhPSAwKQoJKnZhbCA9IE5VTEw7CgogICAgaWYgKGF0dHJ1c2UtPmRlZlZhbHVlICE9IE5VTEwpIHsJICAgIAoJKnZhbHVlID0gYXR0cnVzZS0+ZGVmVmFsdWU7CglpZiAodmFsICE9IE5VTEwpCgkgICAgKnZhbCA9IGF0dHJ1c2UtPmRlZlZhbDsKCWlmIChhdHRydXNlLT5mbGFncyAmIFhNTF9TQ0hFTUFfQVRUUl9VU0VfRklYRUQpCgkgICAgKmZpeGVkID0gMTsKCXJldHVybigxKTsKICAgIH0gZWxzZSBpZiAoKGF0dHJ1c2UtPmF0dHJEZWNsICE9IE5VTEwpICYmCgkoYXR0cnVzZS0+YXR0ckRlY2wtPmRlZlZhbHVlICE9IE5VTEwpKSB7CgkqdmFsdWUgPSBhdHRydXNlLT5hdHRyRGVjbC0+ZGVmVmFsdWU7CglpZiAodmFsICE9IE5VTEwpCgkgICAgKnZhbCA9IGF0dHJ1c2UtPmF0dHJEZWNsLT5kZWZWYWw7CglpZiAoYXR0cnVzZS0+YXR0ckRlY2wtPmZsYWdzICYgWE1MX1NDSEVNQVNfQVRUUl9GSVhFRCkKCSAgICAqZml4ZWQgPSAxOwoJcmV0dXJuKDEpOwogICAgfQogICAgcmV0dXJuKDApOwp9Ci8qKgogKiB4bWxTY2hlbWFDaGVja0NWQ1dpbGRjYXJkTmFtZXNwYWNlOgogKiBAd2lsZDogIHRoZSB3aWxkY2FyZAogKiBAbnM6ICB0aGUgbmFtZXNwYWNlCiAqCiAqIFZhbGlkYXRpb24gUnVsZTogV2lsZGNhcmQgYWxsb3dzIE5hbWVzcGFjZSBOYW1lCiAqIChjdmMtd2lsZGNhcmQtbmFtZXNwYWNlKQogKgogKiBSZXR1cm5zIDAgaWYgdGhlIGdpdmVuIG5hbWVzcGFjZSBtYXRjaGVzIHRoZSB3aWxkY2FyZCwKICogMSBvdGhlcndpc2UgYW5kIC0xIG9uIEFQSSBlcnJvcnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ1ZDV2lsZGNhcmROYW1lc3BhY2UoeG1sU2NoZW1hV2lsZGNhcmRQdHIgd2lsZCwKCQkJCSAgIGNvbnN0IHhtbENoYXIqIG5zKQp7CiAgICBpZiAod2lsZCA9PSBOVUxMKQoJcmV0dXJuKC0xKTsKCiAgICBpZiAod2lsZC0+YW55KQoJcmV0dXJuKDApOwogICAgZWxzZSBpZiAod2lsZC0+bnNTZXQgIT0gTlVMTCkgewoJeG1sU2NoZW1hV2lsZGNhcmROc1B0ciBjdXI7CgoJY3VyID0gd2lsZC0+bnNTZXQ7Cgl3aGlsZSAoY3VyICE9IE5VTEwpIHsKCSAgICBpZiAoeG1sU3RyRXF1YWwoY3VyLT52YWx1ZSwgbnMpKQoJCXJldHVybigwKTsKCSAgICBjdXIgPSBjdXItPm5leHQ7Cgl9CiAgICB9IGVsc2UgaWYgKCh3aWxkLT5uZWdOc1NldCAhPSBOVUxMKSAmJiAobnMgIT0gTlVMTCkgJiYKCSgheG1sU3RyRXF1YWwod2lsZC0+bmVnTnNTZXQtPnZhbHVlLCBucykpKQoJcmV0dXJuKDApOwoKICAgIHJldHVybigxKTsKfQoKI2RlZmluZSBYTUxfU0NIRU1BX0FDVElPTl9ERVJJVkUgMAojZGVmaW5lIFhNTF9TQ0hFTUFfQUNUSU9OX1JFREVGSU5FIDEKCiNkZWZpbmUgV1hTX0FDVElPTl9TVFIoYSkgXAooKGEpID09IFhNTF9TQ0hFTUFfQUNUSU9OX0RFUklWRSkgPyAoY29uc3QgeG1sQ2hhciAqKSAiYmFzZSIgOiAoY29uc3QgeG1sQ2hhciAqKSAicmVkZWZpbmVkIgoKLyoKKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiogICBEZXJpdmF0aW9uIFZhbGlkIChSZXN0cmljdGlvbiwgQ29tcGxleCkKKiAgIGRlcml2YXRpb24tb2stcmVzdHJpY3Rpb24gKDIpIC0gKDQpCioKKiBBVFRFTlRJT046CiogSW4gWE1MIFNjaGVtYSAxLjEgdGhpcyB3aWxsIGJlOgoqIFZhbGlkYXRpb24gUnVsZToKKiAgICAgQ2hlY2tpbmcgY29tcGxleCB0eXBlIHN1YnN1bXB0aW9uIChwcmFjdGljYWxTdWJzdW1wdGlvbikgKDEsIDIgYW5kIDMpCioKKi8Kc3RhdGljIGludAp4bWxTY2hlbWFDaGVja0Rlcml2YXRpb25PS1Jlc3RyaWN0aW9uMnRvNCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkJICAgICAgIGludCBhY3Rpb24sCgkJCQkgICAgICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIGl0ZW0sCgkJCQkgICAgICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIGJhc2VJdGVtLAoJCQkJICAgICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIHVzZXMsCgkJCQkgICAgICAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgYmFzZVVzZXMsCgkJCQkgICAgICAgeG1sU2NoZW1hV2lsZGNhcmRQdHIgd2lsZCwKCQkJCSAgICAgICB4bWxTY2hlbWFXaWxkY2FyZFB0ciBiYXNlV2lsZCkKeyAgICAgICAgCiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgY3VyID0gTlVMTCwgYmN1cjsKICAgIGludCBpLCBqLCBmb3VuZDsgLyogZXJyID0gMDsgKi8KICAgIGNvbnN0IHhtbENoYXIgKmJFZmZWYWx1ZTsKICAgIGludCBlZmZGaXhlZDsKICAgIAogICAgaWYgKHVzZXMgIT0gTlVMTCkgewoJZm9yIChpID0gMDsgaSA8IHVzZXMtPm5iSXRlbXM7IGkrKykgewoJICAgIGN1ciA9IHVzZXMtPml0ZW1zW2ldOwoJICAgIGZvdW5kID0gMDsKCSAgICBpZiAoYmFzZVVzZXMgPT0gTlVMTCkKCQlnb3RvIG5vdF9mb3VuZDsKCSAgICBmb3IgKGogPSAwOyBqIDwgYmFzZVVzZXMtPm5iSXRlbXM7IGorKykgewoJCWJjdXIgPSBiYXNlVXNlcy0+aXRlbXNbal07CQoJCWlmICgoV1hTX0FUVFJVU0VfREVDTF9OQU1FKGN1cikgPT0KCQkJV1hTX0FUVFJVU0VfREVDTF9OQU1FKGJjdXIpKSAmJgoJCSAgICAoV1hTX0FUVFJVU0VfREVDTF9UTlMoY3VyKSA9PQoJCQlXWFNfQVRUUlVTRV9ERUNMX1ROUyhiY3VyKSkpCgkJewoJCSAgICAvKgoJCSAgICAqICgyLjEpICJJZiB0aGVyZSBpcyBhbiBhdHRyaWJ1dGUgdXNlIGluIHRoZSB7YXR0cmlidXRlCgkJICAgICogdXNlc30gb2YgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gKGNhbGwgdGhpcyBCKSB3aG9zZQoJCSAgICAqIHthdHRyaWJ1dGUgZGVjbGFyYXRpb259IGhhcyB0aGUgc2FtZSB7bmFtZX0gYW5kIHt0YXJnZXQKCQkgICAgKiBuYW1lc3BhY2V9LCB0aGVuICBhbGwgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6IgoJCSAgICAqLwoJCSAgICBmb3VuZCA9IDE7CgkJICAgIAoJCSAgICBpZiAoKGN1ci0+b2NjdXJzID09IFhNTF9TQ0hFTUFTX0FUVFJfVVNFX09QVElPTkFMKSAmJgoJCQkoYmN1ci0+b2NjdXJzID09IFhNTF9TQ0hFTUFTX0FUVFJfVVNFX1JFUVVJUkVEKSkKCQkgICAgewoJCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoJCQkvKgoJCQkqICgyLjEuMSkgIm9uZSBvZiB0aGUgZm9sbG93aW5nIG11c3QgYmUgdHJ1ZToiCgkJCSogKDIuMS4xLjEpICJCJ3Mge3JlcXVpcmVkfSBpcyBmYWxzZS4iCgkJCSogKDIuMS4xLjIpICJSJ3Mge3JlcXVpcmVkfSBpcyB0cnVlLiIKCQkJKi8KCQkJeG1sU2NoZW1hUEF0dHJVc2VFcnI0KHBjdHh0LAoJCQkgICAgWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl8yXzFfMSwKCQkJICAgIFdYU19JVEVNX05PREUoaXRlbSksIGl0ZW0sIGN1ciwKCQkJICAgICJUaGUgJ29wdGlvbmFsJyBhdHRyaWJ1dGUgdXNlIGlzIGluY29uc2lzdGVudCAiCgkJCSAgICAid2l0aCB0aGUgY29ycmVzcG9uZGluZyAncmVxdWlyZWQnIGF0dHJpYnV0ZSB1c2Ugb2YgIgoJCQkgICAgInRoZSAlcyAlcyIsCgkJCSAgICBXWFNfQUNUSU9OX1NUUihhY3Rpb24pLAoJCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ciwgYmFzZUl0ZW0pLAoJCQkgICAgTlVMTCwgTlVMTCk7CgkJCUZSRUVfQU5EX05VTEwoc3RyKTsKCQkJLyogZXJyID0gcGN0eHQtPmVycjsgKi8KCQkgICAgfSBlbHNlIGlmICh4bWxTY2hlbWFDaGVja0NPU1NURGVyaXZlZE9LKEFDVFhUX0NBU1QgcGN0eHQsCgkJCVdYU19BVFRSVVNFX1RZUEVERUYoY3VyKSwKCQkJV1hTX0FUVFJVU0VfVFlQRURFRihiY3VyKSwgMCkgIT0gMCkKCQkgICAgewoJCQl4bWxDaGFyICpzdHJBID0gTlVMTCwgKnN0ckIgPSBOVUxMLCAqc3RyQyA9IE5VTEw7CgkJCQoJCQkvKgoJCQkqIFNQRUMgKDIuMS4yKSAiUidzIHthdHRyaWJ1dGUgZGVjbGFyYXRpb259J3MKCQkJKiB7dHlwZSBkZWZpbml0aW9ufSBtdXN0IGJlIHZhbGlkbHkgZGVyaXZlZCBmcm9tCgkJCSogQidzIHt0eXBlIGRlZmluaXRpb259IGdpdmVuIHRoZSBlbXB0eSBzZXQgYXMKCQkJKiBkZWZpbmVkIGluIFR5cGUgRGVyaXZhdGlvbiBPSyAoU2ltcGxlKSAopzMuMTQuNikuIgoJCQkqLwoJCQl4bWxTY2hlbWFQQXR0clVzZUVycjQocGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9ERVJJVkFUSU9OX09LX1JFU1RSSUNUSU9OXzJfMV8yLAoJCQkgICAgV1hTX0lURU1fTk9ERShpdGVtKSwgaXRlbSwgY3VyLAoJCQkgICAgIlRoZSBhdHRyaWJ1dGUgZGVjbGFyYXRpb24ncyAlcyAiCgkJCSAgICAiaXMgbm90IHZhbGlkbHkgZGVyaXZlZCBmcm9tICIKCQkJICAgICJ0aGUgY29ycmVzcG9uZGluZyAlcyBvZiB0aGUgIgoJCQkgICAgImF0dHJpYnV0ZSBkZWNsYXJhdGlvbiBpbiB0aGUgJXMgJXMiLAoJCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ckEsCgkJCQlXWFNfQVRUUlVTRV9UWVBFREVGKGN1cikpLAoJCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ckIsCgkJCQlXWFNfQVRUUlVTRV9UWVBFREVGKGJjdXIpKSwKCQkJICAgIFdYU19BQ1RJT05fU1RSKGFjdGlvbiksCgkJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyQywgYmFzZUl0ZW0pKTsKCQkJICAgIC8qIHhtbFNjaGVtYUdldENvbXBvbmVudERlc2lnbmF0aW9uKCZzdHIsIGJhc2VJdGVtKSwgKi8KCQkJRlJFRV9BTkRfTlVMTChzdHJBKTsKCQkJRlJFRV9BTkRfTlVMTChzdHJCKTsKCQkJRlJFRV9BTkRfTlVMTChzdHJDKTsKCQkJLyogZXJyID0gcGN0eHQtPmVycjsgKi8KCQkgICAgfSBlbHNlIHsKCQkJLyoKCQkJKiAyLjEuMyBbRGVmaW5pdGlvbjpdICBMZXQgdGhlIGVmZmVjdGl2ZSB2YWx1ZQoJCQkqIGNvbnN0cmFpbnQgb2YgYW4gYXR0cmlidXRlIHVzZSBiZSBpdHMge3ZhbHVlCgkJCSogY29uc3RyYWludH0sIGlmIHByZXNlbnQsIG90aGVyd2lzZSBpdHMge2F0dHJpYnV0ZQoJCQkqIGRlY2xhcmF0aW9ufSdzIHt2YWx1ZSBjb25zdHJhaW50fSAuCgkJCSovCgkJCXhtbFNjaGVtYUdldEVmZmVjdGl2ZVZhbHVlQ29uc3RyYWludChiY3VyLAoJCQkgICAgJmVmZkZpeGVkLCAmYkVmZlZhbHVlLCBOVUxMKTsKCQkJLyoKCQkJKiAyLjEuMyAuLi4gb25lIG9mIHRoZSBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlCgkJCSoKCQkJKiAyLjEuMy4xIEIncyC3ZWZmZWN0aXZlIHZhbHVlIGNvbnN0cmFpbnS3IGlzCgkJCSogt2Fic2VudLcgb3IgZGVmYXVsdC4KCQkJKi8KCQkJaWYgKChiRWZmVmFsdWUgIT0gTlVMTCkgJiYKCQkJICAgIChlZmZGaXhlZCA9PSAxKSkgewoJCQkgICAgY29uc3QgeG1sQ2hhciAqckVmZlZhbHVlID0gTlVMTDsKCQkJICAgIAoJCQkgICAgeG1sU2NoZW1hR2V0RWZmZWN0aXZlVmFsdWVDb25zdHJhaW50KGJjdXIsCgkJCQkmZWZmRml4ZWQsICZyRWZmVmFsdWUsIE5VTEwpOwoJCQkgICAgLyoKCQkJICAgICogMi4xLjMuMiBSJ3Mgt2VmZmVjdGl2ZSB2YWx1ZSBjb25zdHJhaW50tyBpcwoJCQkgICAgKiBmaXhlZCB3aXRoIHRoZSBzYW1lIHN0cmluZyBhcyBCJ3MuCgkJCSAgICAqIE1BWUJFIFRPRE86IENvbXBhcmUgdGhlIGNvbXB1dGVkIHZhbHVlcy4KCQkJICAgICogICAgICAgSG1tLCBpdCBzYXlzICJzYW1lIHN0cmluZyIgc28KCQkJICAgICogICAgICAgc3RyaW5nLWVxdWFsaXR5IG1pZ2h0IHJlYWxseSBiZSBzdWZmaWNpZW50LgoJCQkgICAgKi8KCQkJICAgIGlmICgoZWZmRml4ZWQgPT0gMCkgfHwKCQkJCSghIFdYU19BUkVfREVGQVVMVF9TVFJfRVFVQUwockVmZlZhbHVlLCBiRWZmVmFsdWUpKSkKCQkJICAgIHsKCQkJCXhtbENoYXIgKnN0ciA9IE5VTEw7CgkJCQkKCQkJCXhtbFNjaGVtYVBBdHRyVXNlRXJyNChwY3R4dCwKCQkJCSAgICBYTUxfU0NIRU1BUF9ERVJJVkFUSU9OX09LX1JFU1RSSUNUSU9OXzJfMV8zLAoJCQkJICAgIFdYU19JVEVNX05PREUoaXRlbSksIGl0ZW0sIGN1ciwKCQkJCSAgICAiVGhlIGVmZmVjdGl2ZSB2YWx1ZSBjb25zdHJhaW50IG9mIHRoZSAiCgkJCQkgICAgImF0dHJpYnV0ZSB1c2UgaXMgaW5jb25zaXN0ZW50IHdpdGggIgoJCQkJICAgICJpdHMgY29ycmVzcG9uZGVudCBpbiB0aGUgJXMgJXMiLAoJCQkJICAgIFdYU19BQ1RJT05fU1RSKGFjdGlvbiksCgkJCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ciwKCQkJCQliYXNlSXRlbSksCgkJCQkgICAgTlVMTCwgTlVMTCk7CgkJCQlGUkVFX0FORF9OVUxMKHN0cik7CgkJCQkvKiBlcnIgPSBwY3R4dC0+ZXJyOyAqLwoJCQkgICAgfQoJCQl9CgkJICAgIH0KCQkgICAgYnJlYWs7CgkJfQoJICAgIH0Kbm90X2ZvdW5kOgkKCSAgICBpZiAoIWZvdW5kKSB7CgkJLyoKCQkqICgyLjIpICJvdGhlcndpc2UgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gbXVzdCBoYXZlIGFuCgkJKiB7YXR0cmlidXRlIHdpbGRjYXJkfSBhbmQgdGhlIHt0YXJnZXQgbmFtZXNwYWNlfSBvZiB0aGUKCQkqIFIncyB7YXR0cmlidXRlIGRlY2xhcmF0aW9ufSBtdXN0IGJlILd2YWxpZLcgd2l0aCByZXNwZWN0CgkJKiB0byB0aGF0IHdpbGRjYXJkLCBhcyBkZWZpbmVkIGluIFdpbGRjYXJkIGFsbG93cyBOYW1lc3BhY2UKCQkqIE5hbWUgKKczLjEwLjQpLiIKCQkqLwoJCWlmICgoYmFzZVdpbGQgPT0gTlVMTCkgfHwKCQkgICAgKHhtbFNjaGVtYUNoZWNrQ1ZDV2lsZGNhcmROYW1lc3BhY2UoYmFzZVdpbGQsCgkJICAgIChXWFNfQVRUUlVTRV9ERUNMKGN1cikpLT50YXJnZXROYW1lc3BhY2UpICE9IDApKQoJCXsKCQkgICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCQkgICAgCgkJICAgIHhtbFNjaGVtYVBBdHRyVXNlRXJyNChwY3R4dCwKCQkJWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl8yXzIsCgkJCVdYU19JVEVNX05PREUoaXRlbSksIGl0ZW0sIGN1ciwKCQkJIk5laXRoZXIgYSBtYXRjaGluZyBhdHRyaWJ1dGUgdXNlLCAiCgkJCSJub3IgYSBtYXRjaGluZyB3aWxkY2FyZCBleGlzdHMgaW4gdGhlICVzICVzIiwKCQkJV1hTX0FDVElPTl9TVFIoYWN0aW9uKSwKCQkJeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ciwgYmFzZUl0ZW0pLAoJCQlOVUxMLCBOVUxMKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpOwoJCSAgICAvKiBlcnIgPSBwY3R4dC0+ZXJyOyAqLwoJCX0KCSAgICB9Cgl9CiAgICB9CiAgICAvKgogICAgKiBTUEVDIGRlcml2YXRpb24tb2stcmVzdHJpY3Rpb24gKDMpOiAgICAKICAgICogKDMpICJGb3IgZWFjaCBhdHRyaWJ1dGUgdXNlIGluIHRoZSB7YXR0cmlidXRlIHVzZXN9IG9mIHRoZSB7YmFzZSB0eXBlCiAgICAqIGRlZmluaXRpb259IHdob3NlIHtyZXF1aXJlZH0gaXMgdHJ1ZSwgdGhlcmUgbXVzdCBiZSBhbiBhdHRyaWJ1dGUKICAgICogdXNlIHdpdGggYW4ge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0gd2l0aCB0aGUgc2FtZSB7bmFtZX0gYW5kCiAgICAqIHt0YXJnZXQgbmFtZXNwYWNlfSBhcyBpdHMge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0gaW4gdGhlIHthdHRyaWJ1dGUKICAgICogdXNlc30gb2YgdGhlIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uIGl0c2VsZiB3aG9zZSB7cmVxdWlyZWR9IGlzIHRydWUuCiAgICAqLwogICAgaWYgKGJhc2VVc2VzICE9IE5VTEwpIHsKCWZvciAoaiA9IDA7IGogPCBiYXNlVXNlcy0+bmJJdGVtczsgaisrKSB7CgkgICAgYmN1ciA9IGJhc2VVc2VzLT5pdGVtc1tqXTsKCSAgICBpZiAoYmN1ci0+b2NjdXJzICE9IFhNTF9TQ0hFTUFTX0FUVFJfVVNFX1JFUVVJUkVEKQoJCWNvbnRpbnVlOwoJICAgIGZvdW5kID0gMDsKCSAgICBpZiAodXNlcyAhPSBOVUxMKSB7CgkJZm9yIChpID0gMDsgaSA8IHVzZXMtPm5iSXRlbXM7IGkrKykgewoJCSAgICBjdXIgPSB1c2VzLT5pdGVtc1tpXTsJCgkJICAgIGlmICgoV1hTX0FUVFJVU0VfREVDTF9OQU1FKGN1cikgPT0KCQkJV1hTX0FUVFJVU0VfREVDTF9OQU1FKGJjdXIpKSAmJgoJCQkoV1hTX0FUVFJVU0VfREVDTF9UTlMoY3VyKSA9PQoJCQlXWFNfQVRUUlVTRV9ERUNMX1ROUyhiY3VyKSkpIHsKCQkJZm91bmQgPSAxOwoJCQlicmVhazsKCQkgICAgfQoJCX0KCSAgICB9CgkgICAgaWYgKCFmb3VuZCkgewoJCXhtbENoYXIgKnN0ckEgPSBOVUxMLCAqc3RyQiA9IE5VTEw7CgkJCgkJeG1sU2NoZW1hQ3VzdG9tRXJyNChBQ1RYVF9DQVNUIHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9ERVJJVkFUSU9OX09LX1JFU1RSSUNUSU9OXzMsCgkJICAgIE5VTEwsIGl0ZW0sCgkJICAgICJBIG1hdGNoaW5nIGF0dHJpYnV0ZSB1c2UgZm9yIHRoZSAiCgkJICAgICIncmVxdWlyZWQnICVzIG9mIHRoZSAlcyAlcyBpcyBtaXNzaW5nIiwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ckEsIGJjdXIpLAoJCSAgICBXWFNfQUNUSU9OX1NUUihhY3Rpb24pLAoJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyQiwgYmFzZUl0ZW0pLAoJCSAgICBOVUxMKTsKCQlGUkVFX0FORF9OVUxMKHN0ckEpOwoJCUZSRUVfQU5EX05VTEwoc3RyQik7CgkgICAgfQoJfQogICAgfQogICAgLyoKICAgICogZGVyaXZhdGlvbi1vay1yZXN0cmljdGlvbiAoNCkKICAgICovCiAgICBpZiAod2lsZCAhPSBOVUxMKSB7CgkvKgoJKiAoNCkgIklmIHRoZXJlIGlzIGFuIHthdHRyaWJ1dGUgd2lsZGNhcmR9LCBhbGwgb2YgdGhlCgkqIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6IgoJKi8gICAKCWlmIChiYXNlV2lsZCA9PSBOVUxMKSB7CgkgICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCgkgICAgLyoKCSAgICAqICg0LjEpICJUaGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBtdXN0IGFsc28gaGF2ZSBvbmUuIgoJICAgICovCSAgICAKCSAgICB4bWxTY2hlbWFDdXN0b21FcnI0KEFDVFhUX0NBU1QgcGN0eHQsCgkJWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl80XzEsCgkJTlVMTCwgaXRlbSwKCQkiVGhlICVzIGhhcyBhbiBhdHRyaWJ1dGUgd2lsZGNhcmQsICIKCQkiYnV0IHRoZSAlcyAlcyAnJXMnIGRvZXMgbm90IGhhdmUgb25lIiwKCQlXWFNfSVRFTV9UWVBFX05BTUUoaXRlbSksCQkgICAgCgkJV1hTX0FDVElPTl9TVFIoYWN0aW9uKSwKCQlXWFNfSVRFTV9UWVBFX05BTUUoYmFzZUl0ZW0pLAoJCXhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGJhc2VJdGVtKSk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHIpOwoJICAgIHJldHVybihwY3R4dC0+ZXJyKTsKCX0gZWxzZSBpZiAoKGJhc2VXaWxkLT5hbnkgPT0gMCkgJiYKCQl4bWxTY2hlbWFDaGVja0NPU05TU3Vic2V0KHdpbGQsIGJhc2VXaWxkKSkKCXsKCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJICAgIC8qCgkgICAgKiAoNC4yKSAiVGhlIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uJ3Mge2F0dHJpYnV0ZSB3aWxkY2FyZH0ncwoJICAgICoge25hbWVzcGFjZSBjb25zdHJhaW50fSBtdXN0IGJlIGEgc3Vic2V0IG9mIHRoZSB7YmFzZSB0eXBlCgkgICAgKiBkZWZpbml0aW9ufSdzIHthdHRyaWJ1dGUgd2lsZGNhcmR9J3Mge25hbWVzcGFjZSBjb25zdHJhaW50fSwKCSAgICAqIGFzIGRlZmluZWQgYnkgV2lsZGNhcmQgU3Vic2V0ICinMy4xMC42KS4iCgkgICAgKi8KCSAgICB4bWxTY2hlbWFDdXN0b21FcnI0KEFDVFhUX0NBU1QgcGN0eHQsCgkJWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl80XzIsCgkJTlVMTCwgaXRlbSwKCQkiVGhlIGF0dHJpYnV0ZSB3aWxkY2FyZCBpcyBub3QgYSB2YWxpZCAiCgkJInN1YnNldCBvZiB0aGUgd2lsZGNhcmQgaW4gdGhlICVzICVzICclcyciLAoJCVdYU19BQ1RJT05fU1RSKGFjdGlvbiksCgkJV1hTX0lURU1fVFlQRV9OQU1FKGJhc2VJdGVtKSwKCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBiYXNlSXRlbSksCgkJTlVMTCk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHIpOwoJICAgIHJldHVybihwY3R4dC0+ZXJyKTsKCX0KCS8qIDQuMyBVbmxlc3MgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gaXMgdGhlILd1ci10eXBlCgkqIGRlZmluaXRpb263LCB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24ncyB7YXR0cmlidXRlCgkqIHdpbGRjYXJkfSdzIHtwcm9jZXNzIGNvbnRlbnRzfSBtdXN0IGJlIGlkZW50aWNhbCB0byBvcgoJKiBzdHJvbmdlciB0aGFuIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259J3Mge2F0dHJpYnV0ZQoJKiB3aWxkY2FyZH0ncyB7cHJvY2VzcyBjb250ZW50c30sIHdoZXJlIHN0cmljdCBpcyBzdHJvbmdlcgoJKiB0aGFuIGxheCBpcyBzdHJvbmdlciB0aGFuIHNraXAuCgkqLwoJaWYgKCghIFdYU19JU19BTllUWVBFKGJhc2VJdGVtKSkgJiYKCSAgICAod2lsZC0+cHJvY2Vzc0NvbnRlbnRzIDwgYmFzZVdpbGQtPnByb2Nlc3NDb250ZW50cykpIHsKCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJICAgIHhtbFNjaGVtYUN1c3RvbUVycjQoQUNUWFRfQ0FTVCBwY3R4dCwKCQlYTUxfU0NIRU1BUF9ERVJJVkFUSU9OX09LX1JFU1RSSUNUSU9OXzRfMywKCQlOVUxMLCBiYXNlSXRlbSwKCQkiVGhlIHtwcm9jZXNzIGNvbnRlbnRzfSBvZiB0aGUgYXR0cmlidXRlIHdpbGRjYXJkIGlzICIKCQkid2Vha2VyIHRoYW4gdGhlIG9uZSBpbiB0aGUgJXMgJXMgJyVzJyIsCgkJV1hTX0FDVElPTl9TVFIoYWN0aW9uKSwKCQlXWFNfSVRFTV9UWVBFX05BTUUoYmFzZUl0ZW0pLAoJCXhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGJhc2VJdGVtKSwKCQlOVUxMKTsKCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCQlyZXR1cm4ocGN0eHQtPmVycik7Cgl9CiAgICB9CiAgICByZXR1cm4oMCk7Cn0KCgpzdGF0aWMgaW50CnhtbFNjaGVtYUV4cGFuZEF0dHJpYnV0ZUdyb3VwUmVmcyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkJICB4bWxTY2hlbWFCYXNpY0l0ZW1QdHIgaXRlbSwKCQkJCSAgeG1sU2NoZW1hV2lsZGNhcmRQdHIgKmNvbXBsZXRlV2lsZCwKCQkJCSAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgbGlzdCwKCQkJCSAgeG1sU2NoZW1hSXRlbUxpc3RQdHIgcHJvaGlicyk7Ci8qKgogKiB4bWxTY2hlbWFGaXh1cFR5cGVBdHRyaWJ1dGVVc2VzOgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHR5cGU6ICB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24KICoKICoKICogQnVpbGRzIHRoZSB3aWxkY2FyZCBhbmQgdGhlIGF0dHJpYnV0ZSB1c2VzIG9uIHRoZSBnaXZlbiBjb21wbGV4IHR5cGUuCiAqIFJldHVybnMgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJzLCAwIG90aGVyd2lzZS4KICoKICogQVRURU5USU9OIFRPRE86IEV4cGVyaW1hbnRhbGx5IHRoaXMgdXNlcyBwb2ludGVyIGNvbXBhcmlzb25zIGZvcgogKiBzdHJpbmdzLCBzbyByZWNoZWNrIHRoaXMgaWYgd2Ugc3RhcnQgdG8gaGFyZGNvZGUgc29tZSBzY2hlbWF0YSwgc2luY2UKICogdGhleSBtaWdodCBub3QgYmUgaW4gdGhlIHNhbWUgZGljdC4KICogTk9URTogSXQgaXMgYWxsb3dlZCB0byAiZXh0ZW5kIiB0aGUgeHM6YW55VHlwZSB0eXBlLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFGaXh1cFR5cGVBdHRyaWJ1dGVVc2VzKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgeG1sU2NoZW1hVHlwZVB0ciBiYXNlVHlwZSA9IE5VTEw7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgdXNlOyAgICAKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIHVzZXMsIGJhc2VVc2VzLCBwcm9oaWJzID0gTlVMTDsKCiAgICBpZiAodHlwZS0+YmFzZVR5cGUgPT0gTlVMTCkgewoJUEVSUk9SX0lOVCgieG1sU2NoZW1hRml4dXBUeXBlQXR0cmlidXRlVXNlcyIsCgkgICAgIm5vIGJhc2UgdHlwZSIpOwogICAgICAgIHJldHVybiAoLTEpOwogICAgfQogICAgYmFzZVR5cGUgPSB0eXBlLT5iYXNlVHlwZTsgICAgICAgIAogICAgaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRChiYXNlVHlwZSkpCglpZiAoeG1sU2NoZW1hVHlwZUZpeHVwKGJhc2VUeXBlLCBBQ1RYVF9DQVNUIHBjdHh0KSA9PSAtMSkKCSAgICByZXR1cm4oLTEpOwoKICAgIHVzZXMgPSB0eXBlLT5hdHRyVXNlczsKICAgIGJhc2VVc2VzID0gYmFzZVR5cGUtPmF0dHJVc2VzOwogICAgLyoKICAgICogRXhwYW5kIGF0dHJpYnV0ZSBncm91cCByZWZlcmVuY2VzLiBBbmQgYnVpbGQgdGhlICdjb21wbGV0ZScKICAgICogd2lsZGNhcmQsIGkuZS4gaW50ZXJzZWN0IG11bHRpcGxlIHdpbGRjYXJkcy4KICAgICogTW92ZSBhdHRyaWJ1dGUgcHJvaGliaXRpb25zIGludG8gYSBzZXBhcmF0ZSBsaXN0LgogICAgKi8KICAgIGlmICh1c2VzICE9IE5VTEwpIHsJCglpZiAoV1hTX0lTX1JFU1RSSUNUSU9OKHR5cGUpKSB7CgkgICAgLyoKCSAgICAqIFRoaXMgb25lIHdpbGwgdHJhbnNmZXIgYWxsIGF0dHIuIHByb2hpYml0aW9ucwoJICAgICogaW50byBwY3R4dC0+YXR0clByb2hpYnMuCgkgICAgKi8KCSAgICBpZiAoeG1sU2NoZW1hRXhwYW5kQXR0cmlidXRlR3JvdXBSZWZzKHBjdHh0LAoJCVdYU19CQVNJQ19DQVNUIHR5cGUsICYodHlwZS0+YXR0cmlidXRlV2lsZGNhcmQpLCB1c2VzLAoJCXBjdHh0LT5hdHRyUHJvaGlicykgPT0gLTEpCgkgICAgewoJCVBFUlJPUl9JTlQoInhtbFNjaGVtYUZpeHVwVHlwZUF0dHJpYnV0ZVVzZXMiLAoJCSJmYWlsZWQgdG8gZXhwYW5kIGF0dHJpYnV0ZXMiKTsKCSAgICB9CgkgICAgaWYgKHBjdHh0LT5hdHRyUHJvaGlicy0+bmJJdGVtcyAhPSAwKQoJCXByb2hpYnMgPSBwY3R4dC0+YXR0clByb2hpYnM7Cgl9IGVsc2UgewoJICAgIGlmICh4bWxTY2hlbWFFeHBhbmRBdHRyaWJ1dGVHcm91cFJlZnMocGN0eHQsCgkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgJih0eXBlLT5hdHRyaWJ1dGVXaWxkY2FyZCksIHVzZXMsCgkJTlVMTCkgPT0gLTEpCgkgICAgewoJCVBFUlJPUl9JTlQoInhtbFNjaGVtYUZpeHVwVHlwZUF0dHJpYnV0ZVVzZXMiLAoJCSJmYWlsZWQgdG8gZXhwYW5kIGF0dHJpYnV0ZXMiKTsKCSAgICB9Cgl9CiAgICB9CiAgICAvKgogICAgKiBJbmhlcml0IHRoZSBhdHRyaWJ1dGUgdXNlcyBvZiB0aGUgYmFzZSB0eXBlLgogICAgKi8KICAgIGlmIChiYXNlVXNlcyAhPSBOVUxMKSB7CglpbnQgaSwgajsKCXhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYlB0ciBwcm87CgoJaWYgKFdYU19JU19SRVNUUklDVElPTih0eXBlKSkgewoJICAgIGludCB1c2VzQ291bnQ7CgkgICAgeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIHRtcDsgCgoJICAgIGlmICh1c2VzICE9IE5VTEwpCgkJdXNlc0NvdW50ID0gdXNlcy0+bmJJdGVtczsKCSAgICBlbHNlCgkJdXNlc0NvdW50ID0gMDsKCgkgICAgLyogUmVzdHJpY3Rpb24uICovCgkgICAgZm9yIChpID0gMDsgaSA8IGJhc2VVc2VzLT5uYkl0ZW1zOyBpKyspIHsKCQl1c2UgPSBiYXNlVXNlcy0+aXRlbXNbaV07CgkJaWYgKHByb2hpYnMpIHsKCQkgICAgLyoKCQkgICAgKiBGaWx0ZXIgb3V0IHByb2hpYml0ZWQgdXNlcy4KCQkgICAgKi8KCQkgICAgZm9yIChqID0gMDsgaiA8IHByb2hpYnMtPm5iSXRlbXM7IGorKykgewoJCQlwcm8gPSBwcm9oaWJzLT5pdGVtc1tqXTsKCQkJaWYgKChXWFNfQVRUUlVTRV9ERUNMX05BTUUodXNlKSA9PSBwcm8tPm5hbWUpICYmCgkJCSAgICAoV1hTX0FUVFJVU0VfREVDTF9UTlModXNlKSA9PQoJCQkJcHJvLT50YXJnZXROYW1lc3BhY2UpKQoJCQl7CgkJCSAgICBnb3RvIGluaGVyaXRfbmV4dDsKCQkJfQoJCSAgICB9CgkJfQoJCWlmICh1c2VzQ291bnQpIHsKCQkgICAgLyoKCQkgICAgKiBGaWx0ZXIgb3V0IGV4aXN0aW5nIHVzZXMuCgkJICAgICovCgkJICAgIGZvciAoaiA9IDA7IGogPCB1c2VzQ291bnQ7IGorKykgewoJCQl0bXAgPSB1c2VzLT5pdGVtc1tqXTsKCQkJaWYgKChXWFNfQVRUUlVTRV9ERUNMX05BTUUodXNlKSA9PQoJCQkJV1hTX0FUVFJVU0VfREVDTF9OQU1FKHRtcCkpICYmCgkJCSAgICAoV1hTX0FUVFJVU0VfREVDTF9UTlModXNlKSA9PQoJCQkJV1hTX0FUVFJVU0VfREVDTF9UTlModG1wKSkpCgkJCXsKCQkJICAgIGdvdG8gaW5oZXJpdF9uZXh0OwoJCQl9CgkJICAgIH0KCQl9CgkJaWYgKHVzZXMgPT0gTlVMTCkgewoJCSAgICB0eXBlLT5hdHRyVXNlcyA9IHhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKCk7CgkJICAgIGlmICh0eXBlLT5hdHRyVXNlcyA9PSBOVUxMKQoJCQlnb3RvIGV4aXRfZmFpbHVyZTsKCQkgICAgdXNlcyA9IHR5cGUtPmF0dHJVc2VzOwoJCX0KCQl4bWxTY2hlbWFJdGVtTGlzdEFkZFNpemUodXNlcywgMiwgdXNlKTsKaW5oZXJpdF9uZXh0OiB7fQoJICAgIH0KCX0gZWxzZSB7CgkgICAgLyogRXh0ZW5zaW9uLiAqLwoJICAgIGZvciAoaSA9IDA7IGkgPCBiYXNlVXNlcy0+bmJJdGVtczsgaSsrKSB7CSAgICAKCQl1c2UgPSBiYXNlVXNlcy0+aXRlbXNbaV07CQkKCQlpZiAodXNlcyA9PSBOVUxMKSB7CgkJICAgIHR5cGUtPmF0dHJVc2VzID0geG1sU2NoZW1hSXRlbUxpc3RDcmVhdGUoKTsKCQkgICAgaWYgKHR5cGUtPmF0dHJVc2VzID09IE5VTEwpCgkJCWdvdG8gZXhpdF9mYWlsdXJlOwoJCSAgICB1c2VzID0gdHlwZS0+YXR0clVzZXM7CgkJfQoJCXhtbFNjaGVtYUl0ZW1MaXN0QWRkU2l6ZSh1c2VzLCBiYXNlVXNlcy0+bmJJdGVtcywgdXNlKTsgCgkgICAgfQoJfQogICAgfQogICAgLyoKICAgICogU2hyaW5rIGF0dHIuIHVzZXMuCiAgICAqLwogICAgaWYgKHVzZXMpIHsKCWlmICh1c2VzLT5uYkl0ZW1zID09IDApIHsKCSAgICB4bWxTY2hlbWFJdGVtTGlzdEZyZWUodXNlcyk7CgkgICAgdHlwZS0+YXR0clVzZXMgPSBOVUxMOwoJfQoJLyoKCSogVE9ETzogV2UgY291bGQgc2hyaW5rIHRoZSBzaXplIG9mIHRoZSBhcnJheQoJKiB0byBmaXQgdGhlIGFjdHVhbCBudW1iZXIgb2YgaXRlbXMuCgkqLwogICAgfQogICAgLyoKICAgICogQ29tcHV0ZSB0aGUgY29tcGxldGUgd2lsZGNhcmQuCiAgICAqLwogICAgaWYgKFdYU19JU19FWFRFTlNJT04odHlwZSkpIHsJCglpZiAoYmFzZVR5cGUtPmF0dHJpYnV0ZVdpbGRjYXJkICE9IE5VTEwpIHsKCSAgICAvKgoJICAgICogKDMuMi4yLjEpICJJZiB0aGUgt2Jhc2Ugd2lsZGNhcmS3IGlzIG5vbi23YWJzZW50tywgdGhlbgoJICAgICogdGhlIGFwcHJvcHJpYXRlIGNhc2UgYW1vbmcgdGhlIGZvbGxvd2luZzoiCgkgICAgKi8KCSAgICBpZiAodHlwZS0+YXR0cmlidXRlV2lsZGNhcmQgIT0gTlVMTCkgewoJCS8qCgkJKiBVbmlvbiB0aGUgY29tcGxldGUgd2lsZGNhcmQgd2l0aCB0aGUgYmFzZSB3aWxkY2FyZC4KCQkqIFNQRUMge2F0dHJpYnV0ZSB3aWxkY2FyZH0KCQkqICgzLjIuMi4xLjIpICJvdGhlcndpc2UgYSB3aWxkY2FyZCB3aG9zZSB7cHJvY2VzcyBjb250ZW50c30KCQkqIGFuZCB7YW5ub3RhdGlvbn0gYXJlIHRob3NlIG9mIHRoZSC3Y29tcGxldGUgd2lsZGNhcmS3LAoJCSogYW5kIHdob3NlIHtuYW1lc3BhY2UgY29uc3RyYWludH0gaXMgdGhlIGludGVuc2lvbmFsIHVuaW9uCgkJKiBvZiB0aGUge25hbWVzcGFjZSBjb25zdHJhaW50fSBvZiB0aGUgt2NvbXBsZXRlIHdpbGRjYXJktwoJCSogYW5kIG9mIHRoZSC3YmFzZSB3aWxkY2FyZLcsIGFzIGRlZmluZWQgaW4gQXR0cmlidXRlCgkJKiBXaWxkY2FyZCBVbmlvbiAopzMuMTAuNikuIgoJCSovCgkJaWYgKHhtbFNjaGVtYVVuaW9uV2lsZGNhcmRzKHBjdHh0LCB0eXBlLT5hdHRyaWJ1dGVXaWxkY2FyZCwKCQkgICAgYmFzZVR5cGUtPmF0dHJpYnV0ZVdpbGRjYXJkKSA9PSAtMSkKCQkgICAgZ290byBleGl0X2ZhaWx1cmU7CQkKCSAgICB9IGVsc2UgewoJCS8qCgkJKiAoMy4yLjIuMS4xKSAiSWYgdGhlILdjb21wbGV0ZSB3aWxkY2FyZLcgaXMgt2Fic2VudLcsCgkJKiB0aGVuIHRoZSC3YmFzZSB3aWxkY2FyZLcuIgoJCSovCgkJdHlwZS0+YXR0cmlidXRlV2lsZGNhcmQgPSBiYXNlVHlwZS0+YXR0cmlidXRlV2lsZGNhcmQ7CgkgICAgfQkgCgl9IGVsc2UgewoJICAgIC8qCgkgICAgKiAoMy4yLjIuMikgIm90aGVyd2lzZSAodGhlILdiYXNlIHdpbGRjYXJktyBpcyC3YWJzZW50tykgdGhlCgkgICAgKiC3Y29tcGxldGUgd2lsZGNhcmQiCgkgICAgKiBOT09QCgkgICAgKi8KCX0KICAgIH0gZWxzZSB7CgkvKgoJKiBTUEVDIHthdHRyaWJ1dGUgd2lsZGNhcmR9CgkqICgzLjEpICJJZiB0aGUgPHJlc3RyaWN0aW9uPiBhbHRlcm5hdGl2ZSBpcyBjaG9zZW4sIHRoZW4gdGhlCgkqILdjb21wbGV0ZSB3aWxkY2FyZLc7IgoJKiBOT09QCgkqLwogICAgfQogICAgCiAgICByZXR1cm4gKDApOwoKZXhpdF9mYWlsdXJlOgogICAgcmV0dXJuKC0xKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVR5cGVGaW5hbENvbnRhaW5zOgogKiBAc2NoZW1hOiAgdGhlIHNjaGVtYQogKiBAdHlwZTogIHRoZSB0eXBlIGRlZmluaXRpb24KICogQGZpbmFsOiB0aGUgZmluYWwKICoKICogRXZhbHVhdGVzIGlmIGEgdHlwZSBkZWZpbml0aW9uIGNvbnRhaW5zIHRoZSBnaXZlbiAiZmluYWwiLgogKiBUaGlzIGRvZXMgdGFrZSAiZmluYWxEZWZhdWx0IiBpbnRvIGFjY291bnQgYXMgd2VsbC4KICoKICogUmV0dXJucyAxIGlmIHRoZSB0eXBlIGRvZXMgY29udGFpbnQgdGhlIGdpdmVuICJmaW5hbCIsCiAqIDAgb3RoZXJ3aXNlLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFUeXBlRmluYWxDb250YWlucyh4bWxTY2hlbWFUeXBlUHRyIHR5cGUsIGludCBmaW5hbCkKewogICAgaWYgKHR5cGUgPT0gTlVMTCkKCXJldHVybiAoMCk7CiAgICBpZiAodHlwZS0+ZmxhZ3MgJiBmaW5hbCkKCXJldHVybiAoMSk7CiAgICBlbHNlCglyZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hR2V0VW5pb25TaW1wbGVUeXBlTWVtYmVyVHlwZXM6CiAqIEB0eXBlOiAgdGhlIFVuaW9uIFNpbXBsZSBUeXBlCiAqCiAqIFJldHVybnMgYSBsaXN0IG9mIG1lbWJlciB0eXBlcyBvZiBAdHlwZSBpZiBleGlzdGluZywKICogcmV0dXJucyBOVUxMIG90aGVyd2lzZS4KICovCnN0YXRpYyB4bWxTY2hlbWFUeXBlTGlua1B0cgp4bWxTY2hlbWFHZXRVbmlvblNpbXBsZVR5cGVNZW1iZXJUeXBlcyh4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHdoaWxlICgodHlwZSAhPSBOVUxMKSAmJiAodHlwZS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFKSkgewoJaWYgKHR5cGUtPm1lbWJlclR5cGVzICE9IE5VTEwpCgkgICAgcmV0dXJuICh0eXBlLT5tZW1iZXJUeXBlcyk7CgllbHNlCgkgICAgdHlwZSA9IHR5cGUtPmJhc2VUeXBlOwogICAgfQogICAgcmV0dXJuIChOVUxMKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUdldFBhcnRpY2xlVG90YWxSYW5nZU1pbjoKICogQHBhcnRpY2xlOiB0aGUgcGFydGljbGUKICoKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiBFZmZlY3RpdmUgVG90YWwgUmFuZ2UKICogKGFsbCBhbmQgc2VxdWVuY2UpICsgKGNob2ljZSkKICoKICogUmV0dXJucyB0aGUgbWluaW11biBFZmZlY3RpdmUgVG90YWwgUmFuZ2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUdldFBhcnRpY2xlVG90YWxSYW5nZU1pbih4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0aWNsZSkKewogICAgaWYgKChwYXJ0aWNsZS0+Y2hpbGRyZW4gPT0gTlVMTCkgfHwKCShwYXJ0aWNsZS0+bWluT2NjdXJzID09IDApKQoJcmV0dXJuICgwKTsKICAgIGlmIChwYXJ0aWNsZS0+Y2hpbGRyZW4tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NIT0lDRSkgewoJaW50IG1pbiA9IC0xLCBjdXI7Cgl4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0ID0KCSAgICAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW47CgoJaWYgKHBhcnQgPT0gTlVMTCkKCSAgICByZXR1cm4gKDApOwoJd2hpbGUgKHBhcnQgIT0gTlVMTCkgewoJICAgIGlmICgocGFydC0+Y2hpbGRyZW4tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQpIHx8CgkJKHBhcnQtPmNoaWxkcmVuLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTlkpKQoJCWN1ciA9IHBhcnQtPm1pbk9jY3VyczsKCSAgICBlbHNlCgkJY3VyID0geG1sU2NoZW1hR2V0UGFydGljbGVUb3RhbFJhbmdlTWluKHBhcnQpOwoJICAgIGlmIChjdXIgPT0gMCkKCQlyZXR1cm4gKDApOwoJICAgIGlmICgobWluID4gY3VyKSB8fCAobWluID09IC0xKSkKCQltaW4gPSBjdXI7CgkgICAgcGFydCA9ICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgcGFydC0+bmV4dDsKCX0KCXJldHVybiAocGFydGljbGUtPm1pbk9jY3VycyAqIG1pbik7CiAgICB9IGVsc2UgewoJLyogPGFsbD4gYW5kIDxzZXF1ZW5jZT4gKi8KCWludCBzdW0gPSAwOwoJeG1sU2NoZW1hUGFydGljbGVQdHIgcGFydCA9CgkgICAgKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSBwYXJ0aWNsZS0+Y2hpbGRyZW4tPmNoaWxkcmVuOwoKCWlmIChwYXJ0ID09IE5VTEwpCgkgICAgcmV0dXJuICgwKTsKCWRvIHsKCSAgICBpZiAoKHBhcnQtPmNoaWxkcmVuLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UKSB8fAoJCShwYXJ0LT5jaGlsZHJlbi0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQU5ZKSkKCQlzdW0gKz0gcGFydC0+bWluT2NjdXJzOwoJICAgIGVsc2UKCQlzdW0gKz0geG1sU2NoZW1hR2V0UGFydGljbGVUb3RhbFJhbmdlTWluKHBhcnQpOwoJICAgIHBhcnQgPSAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnQtPm5leHQ7Cgl9IHdoaWxlIChwYXJ0ICE9IE5VTEwpOwoJcmV0dXJuIChwYXJ0aWNsZS0+bWluT2NjdXJzICogc3VtKTsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUdldFBhcnRpY2xlVG90YWxSYW5nZU1heDoKICogQHBhcnRpY2xlOiB0aGUgcGFydGljbGUKICoKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiBFZmZlY3RpdmUgVG90YWwgUmFuZ2UKICogKGFsbCBhbmQgc2VxdWVuY2UpICsgKGNob2ljZSkKICoKICogUmV0dXJucyB0aGUgbWF4aW11bSBFZmZlY3RpdmUgVG90YWwgUmFuZ2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUdldFBhcnRpY2xlVG90YWxSYW5nZU1heCh4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0aWNsZSkKewogICAgaWYgKChwYXJ0aWNsZS0+Y2hpbGRyZW4gPT0gTlVMTCkgfHwKCShwYXJ0aWNsZS0+Y2hpbGRyZW4tPmNoaWxkcmVuID09IE5VTEwpKQoJcmV0dXJuICgwKTsKICAgIGlmIChwYXJ0aWNsZS0+Y2hpbGRyZW4tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NIT0lDRSkgewoJaW50IG1heCA9IC0xLCBjdXI7Cgl4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0ID0KCSAgICAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW47CgoJZm9yICg7IHBhcnQgIT0gTlVMTDsgcGFydCA9ICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgcGFydC0+bmV4dCkgewoJICAgIGlmIChwYXJ0LT5jaGlsZHJlbiA9PSBOVUxMKQoJCWNvbnRpbnVlOwoJICAgIGlmICgocGFydC0+Y2hpbGRyZW4tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQpIHx8CgkJKHBhcnQtPmNoaWxkcmVuLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTlkpKQoJCWN1ciA9IHBhcnQtPm1heE9jY3VyczsKCSAgICBlbHNlCgkJY3VyID0geG1sU2NoZW1hR2V0UGFydGljbGVUb3RhbFJhbmdlTWF4KHBhcnQpOwoJICAgIGlmIChjdXIgPT0gVU5CT1VOREVEKQoJCXJldHVybiAoVU5CT1VOREVEKTsKCSAgICBpZiAoKG1heCA8IGN1cikgfHwgKG1heCA9PSAtMSkpCgkJbWF4ID0gY3VyOwoJfQoJLyogVE9ETzogSGFuZGxlIG92ZXJmbG93cz8gKi8KCXJldHVybiAocGFydGljbGUtPm1heE9jY3VycyAqIG1heCk7CiAgICB9IGVsc2UgewoJLyogPGFsbD4gYW5kIDxzZXF1ZW5jZT4gKi8KCWludCBzdW0gPSAwLCBjdXI7Cgl4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0ID0KCSAgICAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW47CgoJZm9yICg7IHBhcnQgIT0gTlVMTDsgcGFydCA9ICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgcGFydC0+bmV4dCkgewoJICAgIGlmIChwYXJ0LT5jaGlsZHJlbiA9PSBOVUxMKQoJCWNvbnRpbnVlOwoJICAgIGlmICgocGFydC0+Y2hpbGRyZW4tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQpIHx8CgkJKHBhcnQtPmNoaWxkcmVuLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTlkpKQoJCWN1ciA9IHBhcnQtPm1heE9jY3VyczsKCSAgICBlbHNlCgkJY3VyID0geG1sU2NoZW1hR2V0UGFydGljbGVUb3RhbFJhbmdlTWF4KHBhcnQpOwoJICAgIGlmIChjdXIgPT0gVU5CT1VOREVEKQoJCXJldHVybiAoVU5CT1VOREVEKTsKCSAgICBpZiAoKGN1ciA+IDApICYmIChwYXJ0aWNsZS0+bWF4T2NjdXJzID09IFVOQk9VTkRFRCkpCgkJcmV0dXJuIChVTkJPVU5ERUQpOwoJICAgIHN1bSArPSBjdXI7Cgl9CgkvKiBUT0RPOiBIYW5kbGUgb3ZlcmZsb3dzPyAqLwoJcmV0dXJuIChwYXJ0aWNsZS0+bWF4T2NjdXJzICogc3VtKTsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUlzUGFydGljbGVFbXB0aWFibGU6CiAqIEBwYXJ0aWNsZTogdGhlIHBhcnRpY2xlCiAqCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDogUGFydGljbGUgRW1wdGlhYmxlCiAqIENoZWNrcyB3aGV0aGVyIHRoZSBnaXZlbiBwYXJ0aWNsZSBpcyBlbXB0aWFibGUuCiAqCiAqIFJldHVybnMgMSBpZiBlbXB0aWFibGUsIDAgb3RoZXJ3aXNlLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFJc1BhcnRpY2xlRW1wdGlhYmxlKHhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnRpY2xlKQp7CiAgICAvKgogICAgKiBTUEVDICgxKSAiSXRzIHttaW4gb2NjdXJzfSBpcyAwLiIKICAgICovCiAgICBpZiAoKHBhcnRpY2xlID09IE5VTEwpIHx8IChwYXJ0aWNsZS0+bWluT2NjdXJzID09IDApIHx8CgkocGFydGljbGUtPmNoaWxkcmVuID09IE5VTEwpKQoJcmV0dXJuICgxKTsKICAgIC8qCiAgICAqIFNQRUMgKDIpICJJdHMge3Rlcm19IGlzIGEgZ3JvdXAgYW5kIHRoZSBtaW5pbXVtIHBhcnQgb2YgdGhlCiAgICAqIGVmZmVjdGl2ZSB0b3RhbCByYW5nZSBvZiB0aGF0IGdyb3VwLCBbLi4uXSBpcyAwLiIKICAgICovCiAgICBpZiAoV1hTX0lTX01PREVMX0dST1VQKHBhcnRpY2xlLT5jaGlsZHJlbikpIHsKCWlmICh4bWxTY2hlbWFHZXRQYXJ0aWNsZVRvdGFsUmFuZ2VNaW4ocGFydGljbGUpID09IDApCgkgICAgcmV0dXJuICgxKTsKICAgIH0KICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0NPU1NURGVyaXZlZE9LOgogKiBAYWN0eHQ6IGEgY29udGV4dAogKiBAdHlwZTogIHRoZSBkZXJpdmVkIHNpbXBsZSB0eXBlIGRlZmluaXRpb24KICogQGJhc2VUeXBlOiAgdGhlIGJhc2UgdHlwZSBkZWZpbml0aW9uCiAqIEBzdWJzZXQ6IHRoZSBzdWJzZXQgb2YgKCdyZXN0cmljdGlvbicsIGVjdC4pCiAqCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogVHlwZSBEZXJpdmF0aW9uIE9LIChTaW1wbGUpIChjb3Mtc3QtZGVyaXZlZC1PSykKICoKICogQ2hlY2tzIHdoZXRlciBAdHlwZSBjYW4gYmUgdmFsaWRseQogKiBkZXJpdmVkIGZyb20gQGJhc2VUeXBlLgogKgogKiBSZXR1cm5zIDAgb24gc3VjY2VzcywgYW4gcG9zaXRpdmUgZXJyb3IgY29kZSBvdGhlcndpc2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ09TU1REZXJpdmVkT0soeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCQkgICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKCQkJICAgICB4bWxTY2hlbWFUeXBlUHRyIGJhc2VUeXBlLAoJCQkgICAgIGludCBzdWJzZXQpCnsKICAgIC8qCiAgICAqIDEgVGhleSBhcmUgdGhlIHNhbWUgdHlwZSBkZWZpbml0aW9uLgogICAgKiBUT0RPOiBUaGUgaWRlbnR5IGNoZWNrIG1pZ2h0IGhhdmUgdG8gYmUgbW9yZSBjb21wbGV4IHRoYW4gdGhpcy4KICAgICovCiAgICBpZiAodHlwZSA9PSBiYXNlVHlwZSkKCXJldHVybiAoMCk7CiAgICAvKgogICAgKiAyLjEgcmVzdHJpY3Rpb24gaXMgbm90IGluIHRoZSBzdWJzZXQsIG9yIGluIHRoZSB7ZmluYWx9CiAgICAqIG9mIGl0cyBvd24ge2Jhc2UgdHlwZSBkZWZpbml0aW9ufTsKICAgICoKICAgICogTk9URSB0aGF0IHRoaXMgd2lsbCBiZSB1c2VkIGFsc28gdmlhICJ4c2k6dHlwZSIuCiAgICAqCiAgICAqIFRPRE86IFJldmlzZSB0aGlzLCBpdCBsb29rcyBzdHJhbmdlLiBIb3cgY2FuIHRoZSAidHlwZSIKICAgICogbm90IGJlIGZpeGVkIG9yICppbiogZml4aW5nPwogICAgKi8KICAgIGlmIChXWFNfSVNfVFlQRV9OT1RfRklYRUQodHlwZSkpCglpZiAoeG1sU2NoZW1hVHlwZUZpeHVwKHR5cGUsIGFjdHh0KSA9PSAtMSkKCSAgICByZXR1cm4oLTEpOwogICAgaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRChiYXNlVHlwZSkpCglpZiAoeG1sU2NoZW1hVHlwZUZpeHVwKGJhc2VUeXBlLCBhY3R4dCkgPT0gLTEpCgkgICAgcmV0dXJuKC0xKTsKICAgIGlmICgoc3Vic2V0ICYgU1VCU0VUX1JFU1RSSUNUSU9OKSB8fAoJKHhtbFNjaGVtYVR5cGVGaW5hbENvbnRhaW5zKHR5cGUtPmJhc2VUeXBlLAoJICAgIFhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfUkVTVFJJQ1RJT04pKSkgewoJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfREVSSVZFRF9PS18yXzEpOwogICAgfQogICAgLyogMi4yICovCiAgICBpZiAodHlwZS0+YmFzZVR5cGUgPT0gYmFzZVR5cGUpIHsKCS8qCgkqIDIuMi4xIEQncyC3YmFzZSB0eXBlIGRlZmluaXRpb263IGlzIEIuCgkqLwoJcmV0dXJuICgwKTsKICAgIH0KICAgIC8qCiAgICAqIDIuMi4yIEQncyC3YmFzZSB0eXBlIGRlZmluaXRpb263IGlzIG5vdCB0aGUgt3VyLXR5cGUgZGVmaW5pdGlvbrcKICAgICogYW5kIGlzIHZhbGlkbHkgZGVyaXZlZCBmcm9tIEIgZ2l2ZW4gdGhlIHN1YnNldCwgYXMgZGVmaW5lZCBieSB0aGlzCiAgICAqIGNvbnN0cmFpbnQuCiAgICAqLwogICAgaWYgKCghIFdYU19JU19BTllUWVBFKHR5cGUtPmJhc2VUeXBlKSkgJiYKCSh4bWxTY2hlbWFDaGVja0NPU1NURGVyaXZlZE9LKGFjdHh0LCB0eXBlLT5iYXNlVHlwZSwKCSAgICBiYXNlVHlwZSwgc3Vic2V0KSA9PSAwKSkgewoJcmV0dXJuICgwKTsKICAgIH0KICAgIC8qCiAgICAqIDIuMi4zIEQncyB7dmFyaWV0eX0gaXMgbGlzdCBvciB1bmlvbiBhbmQgQiBpcyB0aGUgt3NpbXBsZSB1ci10eXBlCiAgICAqIGRlZmluaXRpb263LgogICAgKi8KICAgIGlmIChXWFNfSVNfQU5ZX1NJTVBMRV9UWVBFKGJhc2VUeXBlKSAmJgoJKFdYU19JU19MSVNUKHR5cGUpIHx8IFdYU19JU19VTklPTih0eXBlKSkpIHsKCXJldHVybiAoMCk7CiAgICB9CiAgICAvKgogICAgKiAyLjIuNCBCJ3Mge3ZhcmlldHl9IGlzIHVuaW9uIGFuZCBEIGlzIHZhbGlkbHkgZGVyaXZlZCBmcm9tIGEgdHlwZQogICAgKiBkZWZpbml0aW9uIGluIEIncyB7bWVtYmVyIHR5cGUgZGVmaW5pdGlvbnN9IGdpdmVuIHRoZSBzdWJzZXQsIGFzCiAgICAqIGRlZmluZWQgYnkgdGhpcyBjb25zdHJhaW50LgogICAgKgogICAgKiBOT1RFOiBUaGlzIHNlZW1zIG5vdCB0byBpbnZvbHZlIGJ1aWx0LWluIHR5cGVzLCBzaW5jZSB0aGVyZSBpcyBubwogICAgKiBidWlsdC1pbiBVbmlvbiBTaW1wbGUgVHlwZS4KICAgICovCiAgICBpZiAoV1hTX0lTX1VOSU9OKGJhc2VUeXBlKSkgewoJeG1sU2NoZW1hVHlwZUxpbmtQdHIgY3VyOwoKCWN1ciA9IGJhc2VUeXBlLT5tZW1iZXJUeXBlczsKCXdoaWxlIChjdXIgIT0gTlVMTCkgewoJICAgIGlmIChXWFNfSVNfVFlQRV9OT1RfRklYRUQoY3VyLT50eXBlKSkKCQlpZiAoeG1sU2NoZW1hVHlwZUZpeHVwKGN1ci0+dHlwZSwgYWN0eHQpID09IC0xKQoJCSAgICByZXR1cm4oLTEpOwoJICAgIGlmICh4bWxTY2hlbWFDaGVja0NPU1NURGVyaXZlZE9LKGFjdHh0LAoJCSAgICB0eXBlLCBjdXItPnR5cGUsIHN1YnNldCkgPT0gMCkKCSAgICB7CgkJLyoKCQkqIEl0IGp1c3QgaGFzIHRvIGJlIHZhbGlkbHkgZGVyaXZlZCBmcm9tIGF0IGxlYXN0IG9uZQoJCSogbWVtYmVyLXR5cGUuCgkJKi8KCQlyZXR1cm4gKDApOwoJICAgIH0KCSAgICBjdXIgPSBjdXItPm5leHQ7Cgl9CiAgICB9CiAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19TVF9ERVJJVkVEX09LXzJfMik7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja1R5cGVEZWZDaXJjdWxhckludGVybmFsOgogKiBAcGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBjdHh0VHlwZTogIHRoZSB0eXBlIGRlZmluaXRpb24KICogQGFuY2VzdG9yOiBhbiBhbmNlc3RvciBvZiBAY3R4dFR5cGUKICoKICogQ2hlY2tzIHN0LXByb3BzLWNvcnJlY3QgKDIpICsgY3QtcHJvcHMtY29ycmVjdCAoMykuCiAqIENpcmN1bGFyIHR5cGUgZGVmaW5pdGlvbnMgYXJlIG5vdCBhbGxvd2VkLgogKgogKiBSZXR1cm5zIFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMiBpZiB0aGUgZ2l2ZW4gdHlwZSBpcwogKiBjaXJjdWxhciwgMCBvdGhlcndpc2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrVHlwZURlZkNpcmN1bGFySW50ZXJuYWwoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJICAgeG1sU2NoZW1hVHlwZVB0ciBjdHh0VHlwZSwKCQkJICAgeG1sU2NoZW1hVHlwZVB0ciBhbmNlc3RvcikKewogICAgaW50IHJldDsKCiAgICBpZiAoKGFuY2VzdG9yID09IE5VTEwpIHx8IChhbmNlc3Rvci0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpKQoJcmV0dXJuICgwKTsKCiAgICBpZiAoY3R4dFR5cGUgPT0gYW5jZXN0b3IpIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfU1RfUFJPUFNfQ09SUkVDVF8yLAoJICAgIFdYU19CQVNJQ19DQVNUIGN0eHRUeXBlLCBXWFNfSVRFTV9OT0RFKGN0eHRUeXBlKSwKCSAgICAiVGhlIGRlZmluaXRpb24gaXMgY2lyY3VsYXIiLCBOVUxMKTsKCXJldHVybiAoWE1MX1NDSEVNQVBfU1RfUFJPUFNfQ09SUkVDVF8yKTsKICAgIH0KICAgIGlmIChhbmNlc3Rvci0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX01BUktFRCkgewoJLyoKCSogQXZvaWQgaW5pZmluaXRlIHJlY3Vyc2lvbiBvbiBjaXJjdWxhciB0eXBlcyBub3QgeWV0IGNoZWNrZWQuCgkqLwoJcmV0dXJuICgwKTsKICAgIH0KICAgIGFuY2VzdG9yLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX01BUktFRDsKICAgIHJldCA9IHhtbFNjaGVtYUNoZWNrVHlwZURlZkNpcmN1bGFySW50ZXJuYWwocGN0eHQsIGN0eHRUeXBlLAoJYW5jZXN0b3ItPmJhc2VUeXBlKTsKICAgIGFuY2VzdG9yLT5mbGFncyBePSBYTUxfU0NIRU1BU19UWVBFX01BUktFRDsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrVHlwZURlZkNpcmN1bGFyOgogKiBAaXRlbTogIHRoZSBjb21wbGV4L3NpbXBsZSB0eXBlIGRlZmluaXRpb24KICogQGN0eHQ6ICB0aGUgcGFyc2VyIGNvbnRleHQKICogQG5hbWU6ICB0aGUgbmFtZQogKgogKiBDaGVja3MgZm9yIGNpcmN1bGFyIHR5cGUgZGVmaW5pdGlvbnMuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDaGVja1R5cGVEZWZDaXJjdWxhcih4bWxTY2hlbWFUeXBlUHRyIGl0ZW0sCgkJCSAgICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCkKewogICAgaWYgKChpdGVtID09IE5VTEwpIHx8CgkoaXRlbS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpIHx8CgkoaXRlbS0+YmFzZVR5cGUgPT0gTlVMTCkpCglyZXR1cm47CiAgICB4bWxTY2hlbWFDaGVja1R5cGVEZWZDaXJjdWxhckludGVybmFsKGN0eHQsIGl0ZW0sCglpdGVtLT5iYXNlVHlwZSk7Cn0KCi8qCiogU2ltcGxlIFR5cGUgRGVmaW5pdGlvbiBSZXByZXNlbnRhdGlvbiBPSyAoc3JjLXNpbXBsZS10eXBlKSA0CioKKiAiNCBDaXJjdWxhciB1bmlvbiB0eXBlIGRlZmluaXRpb24gaXMgZGlzYWxsb3dlZC4gVGhhdCBpcywgaWYgdGhlCiogPHVuaW9uPiBhbHRlcm5hdGl2ZSBpcyBjaG9zZW4sIHRoZXJlIG11c3Qgbm90IGJlIGFueSBlbnRyaWVzIGluIHRoZQoqIG1lbWJlclR5cGVzIFthdHRyaWJ1dGVdIGF0IGFueSBkZXB0aCB3aGljaCByZXNvbHZlIHRvIHRoZSBjb21wb25lbnQKKiBjb3JyZXNwb25kaW5nIHRvIHRoZSA8c2ltcGxlVHlwZT4uIgoqCiogTm90ZSB0aGF0IHRoaXMgc2hvdWxkIHdvcmsgb24gdGhlICpyZXByZXNlbnRhdGlvbiogb2YgYSBjb21wb25lbnQsCiogdGh1cyBhc3N1bWVzIGFueSB1bmlvbiB0eXBlcyBpbiB0aGUgbWVtYmVyIHR5cGVzIG5vdCBiZWluZyB5ZXQKKiBzdWJzdGl0dXRlZC4gQXQgdGhpcyBzdGFnZSB3ZSBuZWVkIHRoZSB2YXJpZXR5IG9mIHRoZSB0eXBlcwoqIHRvIGJlIGFscmVhZHkgY29tcHV0ZWQuCiovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tVbmlvblR5cGVEZWZDaXJjdWxhclJlY3VyKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkJeG1sU2NoZW1hVHlwZVB0ciBjdHhUeXBlLAoJCQkJCXhtbFNjaGVtYVR5cGVMaW5rUHRyIG1lbWJlcnMpCnsgICAgCiAgICB4bWxTY2hlbWFUeXBlTGlua1B0ciBtZW1iZXI7CiAgICB4bWxTY2hlbWFUeXBlUHRyIG1lbWJlclR5cGU7CiAgICAKICAgIG1lbWJlciA9IG1lbWJlcnM7CiAgICB3aGlsZSAobWVtYmVyICE9IE5VTEwpIHsKCW1lbWJlclR5cGUgPSBtZW1iZXItPnR5cGU7Cgl3aGlsZSAoKG1lbWJlclR5cGUgIT0gTlVMTCkgJiYKCSAgICAobWVtYmVyVHlwZS0+dHlwZSAhPSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpKSB7CgkgICAgaWYgKG1lbWJlclR5cGUgPT0gY3R4VHlwZSkgewoJCXhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1NSQ19TSU1QTEVfVFlQRV80LAoJCSAgICBXWFNfQkFTSUNfQ0FTVCBjdHhUeXBlLCBOVUxMLAoJCSAgICAiVGhlIHVuaW9uIHR5cGUgZGVmaW5pdGlvbiBpcyBjaXJjdWxhciIsIE5VTEwpOwoJCXJldHVybiAoWE1MX1NDSEVNQVBfU1JDX1NJTVBMRV9UWVBFXzQpOwoJICAgIH0KCSAgICBpZiAoKFdYU19JU19VTklPTihtZW1iZXJUeXBlKSkgJiYKCQkoKG1lbWJlclR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9NQVJLRUQpID09IDApKQoJICAgIHsKCQlpbnQgcmVzOwoJCW1lbWJlclR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfTUFSS0VEOwoJCXJlcyA9IHhtbFNjaGVtYUNoZWNrVW5pb25UeXBlRGVmQ2lyY3VsYXJSZWN1cihwY3R4dCwKCQkgICAgY3R4VHlwZSwKCQkgICAgeG1sU2NoZW1hR2V0VW5pb25TaW1wbGVUeXBlTWVtYmVyVHlwZXMobWVtYmVyVHlwZSkpOwoJCW1lbWJlclR5cGUtPmZsYWdzIF49IFhNTF9TQ0hFTUFTX1RZUEVfTUFSS0VEOwoJCWlmIChyZXMgIT0gMCkKCQkgICAgcmV0dXJuKHJlcyk7CgkgICAgfQoJICAgIG1lbWJlclR5cGUgPSBtZW1iZXJUeXBlLT5iYXNlVHlwZTsKCX0KCW1lbWJlciA9IG1lbWJlci0+bmV4dDsKICAgIH0KICAgIHJldHVybigwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFDaGVja1VuaW9uVHlwZURlZkNpcmN1bGFyKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIGlmICghIFdYU19JU19VTklPTih0eXBlKSkKCXJldHVybigwKTsKICAgIHJldHVybih4bWxTY2hlbWFDaGVja1VuaW9uVHlwZURlZkNpcmN1bGFyUmVjdXIocGN0eHQsIHR5cGUsCgl0eXBlLT5tZW1iZXJUeXBlcykpOwp9CgovKioKICogeG1sU2NoZW1hUmVzb2x2ZVR5cGVSZWZlcmVuY2VzOgogKiBAaXRlbTogIHRoZSBjb21wbGV4L3NpbXBsZSB0eXBlIGRlZmluaXRpb24KICogQGN0eHQ6ICB0aGUgcGFyc2VyIGNvbnRleHQKICogQG5hbWU6ICB0aGUgbmFtZQogKgogKiBSZXNvbHZlc2UgdHlwZSBkZWZpbml0aW9uIHJlZmVyZW5jZXMKICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYVJlc29sdmVUeXBlUmVmZXJlbmNlcyh4bWxTY2hlbWFUeXBlUHRyIHR5cGVEZWYsCgkJCSB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQpCnsKICAgIGlmICh0eXBlRGVmID09IE5VTEwpCglyZXR1cm47CgogICAgLyoKICAgICogUmVzb2x2ZSB0aGUgYmFzZSB0eXBlLgogICAgKi8KICAgIGlmICh0eXBlRGVmLT5iYXNlVHlwZSA9PSBOVUxMKSB7Cgl0eXBlRGVmLT5iYXNlVHlwZSA9IHhtbFNjaGVtYUdldFR5cGUoY3R4dC0+c2NoZW1hLAoJICAgIHR5cGVEZWYtPmJhc2UsIHR5cGVEZWYtPmJhc2VOcyk7CglpZiAodHlwZURlZi0+YmFzZVR5cGUgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVBSZXNDb21wQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19SRVNPTFZFLAoJCVdYU19CQVNJQ19DQVNUIHR5cGVEZWYsIHR5cGVEZWYtPm5vZGUsCgkJImJhc2UiLCB0eXBlRGVmLT5iYXNlLCB0eXBlRGVmLT5iYXNlTnMsCgkJWE1MX1NDSEVNQV9UWVBFX1NJTVBMRSwgTlVMTCk7CgkgICAgcmV0dXJuOwoJfQogICAgfQogICAgaWYgKFdYU19JU19TSU1QTEUodHlwZURlZikpIHsKCWlmIChXWFNfSVNfVU5JT04odHlwZURlZikpIHsKCSAgICAvKgoJICAgICogUmVzb2x2ZSB0aGUgbWVtYmVyVHlwZXMuCgkgICAgKi8KCSAgICB4bWxTY2hlbWFSZXNvbHZlVW5pb25NZW1iZXJUeXBlcyhjdHh0LCB0eXBlRGVmKTsKCSAgICByZXR1cm47Cgl9IGVsc2UgaWYgKFdYU19JU19MSVNUKHR5cGVEZWYpKSB7CgkgICAgLyoKCSAgICAqIFJlc29sdmUgdGhlIGl0ZW1UeXBlLgoJICAgICovCgkgICAgaWYgKCh0eXBlRGVmLT5zdWJ0eXBlcyA9PSBOVUxMKSAmJiAodHlwZURlZi0+YmFzZSAhPSBOVUxMKSkgewoKCQl0eXBlRGVmLT5zdWJ0eXBlcyA9IHhtbFNjaGVtYUdldFR5cGUoY3R4dC0+c2NoZW1hLAoJCSAgICB0eXBlRGVmLT5iYXNlLCB0eXBlRGVmLT5iYXNlTnMpOwoKCQlpZiAoKHR5cGVEZWYtPnN1YnR5cGVzID09IE5VTEwpIHx8CgkJICAgICghIFdYU19JU19TSU1QTEUodHlwZURlZi0+c3VidHlwZXMpKSkKCQl7CgkJICAgIHR5cGVEZWYtPnN1YnR5cGVzID0gTlVMTDsKCQkgICAgeG1sU2NoZW1hUFJlc0NvbXBBdHRyRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX1NSQ19SRVNPTFZFLAoJCQlXWFNfQkFTSUNfQ0FTVCB0eXBlRGVmLCB0eXBlRGVmLT5ub2RlLAoJCQkiaXRlbVR5cGUiLCB0eXBlRGVmLT5iYXNlLCB0eXBlRGVmLT5iYXNlTnMsCgkJCVhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUsIE5VTEwpOwoJCX0KCSAgICB9CgkgICAgcmV0dXJuOwoJfQogICAgfSAKICAgIC8qCiAgICAqIFRoZSBiYWxsIG9mIGxldHRlcnMgYmVsb3cgbWVhbnMsIHRoYXQgaWYgd2UgaGF2ZSBhIHBhcnRpY2xlCiAgICAqIHdoaWNoIGhhcyBhIFFOYW1lLWhlbHBlciBjb21wb25lbnQgYXMgaXRzIHt0ZXJtfSwgd2Ugd2FudAogICAgKiB0byByZXNvbHZlIGl0Li4uCiAgICAqLwogICAgZWxzZSBpZiAoKFdYU19UWVBFX0NPTlRFTlRUWVBFKHR5cGVEZWYpICE9IE5VTEwpICYmCgkoKFdYU19UWVBFX0NPTlRFTlRUWVBFKHR5cGVEZWYpKS0+dHlwZSA9PQoJICAgIFhNTF9TQ0hFTUFfVFlQRV9QQVJUSUNMRSkgJiYKCShXWFNfVFlQRV9QQVJUSUNMRV9URVJNKHR5cGVEZWYpICE9IE5VTEwpICYmCgkoKFdYU19UWVBFX1BBUlRJQ0xFX1RFUk0odHlwZURlZikpLT50eXBlID09CgkgICAgWE1MX1NDSEVNQV9FWFRSQV9RTkFNRVJFRikpCiAgICB7Cgl4bWxTY2hlbWFRTmFtZVJlZlB0ciByZWYgPQoJICAgIFdYU19RTkFNRV9DQVNUIFdYU19UWVBFX1BBUlRJQ0xFX1RFUk0odHlwZURlZik7Cgl4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyIGdyb3VwRGVmOwoKCS8qCgkqIFVSR0VOVCBUT0RPOiBUZXN0IHRoaXMuCgkqLwoJV1hTX1RZUEVfUEFSVElDTEVfVEVSTSh0eXBlRGVmKSA9IE5VTEw7CgkvKgoJKiBSZXNvbHZlIHRoZSBNRyBkZWZpbml0aW9uIHJlZmVyZW5jZS4KCSovCglncm91cERlZiA9CgkgICAgV1hTX01PREVMX0dST1VQREVGX0NBU1QgeG1sU2NoZW1hR2V0TmFtZWRDb21wb25lbnQoY3R4dC0+c2NoZW1hLAoJCXJlZi0+aXRlbVR5cGUsIHJlZi0+bmFtZSwgcmVmLT50YXJnZXROYW1lc3BhY2UpOwoJaWYgKGdyb3VwRGVmID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQUmVzQ29tcEF0dHJFcnIoY3R4dCwgWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUsCgkJTlVMTCwgV1hTX0lURU1fTk9ERShXWFNfVFlQRV9QQVJUSUNMRSh0eXBlRGVmKSksCgkJInJlZiIsIHJlZi0+bmFtZSwgcmVmLT50YXJnZXROYW1lc3BhY2UsIHJlZi0+aXRlbVR5cGUsCgkJTlVMTCk7CgkgICAgLyogUmVtb3ZlIHRoZSBwYXJ0aWNsZS4gKi8KCSAgICBXWFNfVFlQRV9DT05URU5UVFlQRSh0eXBlRGVmKSA9IE5VTEw7Cgl9IGVsc2UgaWYgKFdYU19NT0RFTEdST1VQREVGX01PREVMKGdyb3VwRGVmKSA9PSBOVUxMKQoJICAgIC8qIFJlbW92ZSB0aGUgcGFydGljbGUuICovCgkgICAgV1hTX1RZUEVfQ09OVEVOVFRZUEUodHlwZURlZikgPSBOVUxMOwoJZWxzZSB7CgkgICAgLyoKCSAgICAqIEFzc2lnbiB0aGUgTUcgZGVmaW5pdGlvbidzIHttb2RlbCBncm91cH0gdG8gdGhlCgkgICAgKiBwYXJ0aWNsZSdzIHt0ZXJtfS4KCSAgICAqLwoJICAgIFdYU19UWVBFX1BBUlRJQ0xFX1RFUk0odHlwZURlZikgPSBXWFNfTU9ERUxHUk9VUERFRl9NT0RFTChncm91cERlZik7CgkgICAgCgkgICAgaWYgKFdYU19NT0RFTEdST1VQREVGX01PREVMKGdyb3VwRGVmKS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQUxMKSB7CgkJLyoKCQkqIFNQRUMgY29zLWFsbC1saW1pdGVkICgxLjIpCgkJKiAiMS4yIHRoZSB7dGVybX0gcHJvcGVydHkgb2YgYSBwYXJ0aWNsZSB3aXRoCgkJKiB7bWF4IG9jY3Vyc309MSB3aGljaCBpcyBwYXJ0IG9mIGEgcGFpciB3aGljaCBjb25zdGl0dXRlcwoJCSogdGhlIHtjb250ZW50IHR5cGV9IG9mIGEgY29tcGxleCB0eXBlIGRlZmluaXRpb24uIgoJCSovCgkJaWYgKChXWFNfVFlQRV9QQVJUSUNMRSh0eXBlRGVmKSktPm1heE9jY3VycyAhPSAxKSB7CgkJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIGN0eHQsCgkJCS8qIFRPRE86IGVycm9yIGNvZGUgKi8KCQkJWE1MX1NDSEVNQVBfQ09TX0FMTF9MSU1JVEVELAoJCQlXWFNfSVRFTV9OT0RFKFdYU19UWVBFX1BBUlRJQ0xFKHR5cGVEZWYpKSwgTlVMTCwKCQkJIlRoZSBwYXJ0aWNsZSdzIHttYXggb2NjdXJzfSBtdXN0IGJlIDEsIHNpbmNlIHRoZSAiCgkJCSJyZWZlcmVuY2UgcmVzb2x2ZXMgdG8gYW4gJ2FsbCcgbW9kZWwgZ3JvdXAiLAoJCQlOVUxMLCBOVUxMKTsKCQl9CgkgICAgfQoJfQogICAgfQp9CgoKCi8qKgogKiB4bWxTY2hlbWFDaGVja1NUUHJvcHNDb3JyZWN0OgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHR5cGU6ICB0aGUgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbgogKgogKiBDaGVja3Mgc3QtcHJvcHMtY29ycmVjdC4KICoKICogUmV0dXJucyAwIGlmIHRoZSBwcm9wZXJ0aWVzIGFyZSBjb3JyZWN0LAogKiBpZiBub3QsIGEgcG9zaXRpdmUgZXJyb3IgY29kZSBhbmQgLTEgb24gaW50ZXJuYWwKICogZXJyb3JzLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFDaGVja1NUUHJvcHNDb3JyZWN0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgYmFzZVR5cGUgPSB0eXBlLT5iYXNlVHlwZTsKICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgogICAgLyogU1RBVEU6IGVycm9yIGZ1bmNzIGNvbnZlcnRlZC4gKi8KICAgIC8qCiAgICAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDogU2ltcGxlIFR5cGUgRGVmaW5pdGlvbiBQcm9wZXJ0aWVzIENvcnJlY3QKICAgICoKICAgICogTk9URTogVGhpcyBpcyBzb21laG93IHJlZHVuZGFudCwgc2luY2Ugd2UgYWN0dWFsbHkgYnVpbHQgYSBzaW1wbGUgdHlwZQogICAgKiB0byBoYXZlIGFsbCB0aGUgbmVlZGVkIGluZm9ybWF0aW9uOyB0aGlzIGFjdHMgYXMgYW4gc2VsZiB0ZXN0LgogICAgKi8KICAgIC8qIEJhc2UgdHlwZTogSWYgdGhlIGRhdGF0eXBlIGhhcyBiZWVuILdkZXJpdmVktyBieSC3cmVzdHJpY3Rpb263CiAgICAqIHRoZW4gdGhlIFNpbXBsZSBUeXBlIERlZmluaXRpb24gY29tcG9uZW50IGZyb20gd2hpY2ggaXQgaXMgt2Rlcml2ZWS3LAogICAgKiBvdGhlcndpc2UgdGhlIFNpbXBsZSBUeXBlIERlZmluaXRpb24gZm9yIGFueVNpbXBsZVR5cGUgKKc0LjEuNikuCiAgICAqLwogICAgaWYgKGJhc2VUeXBlID09IE5VTEwpIHsKCS8qCgkqIFRPRE86IFRoaW5rIGFib3V0OiAibW9kdWxvIHRoZSBpbXBhY3Qgb2YgTWlzc2luZwoJKiBTdWItY29tcG9uZW50cyAopzUuMykuIgoJKi8KCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TVF9QUk9QU19DT1JSRUNUXzEsCgkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCSAgICAiTm8gYmFzZSB0eXBlIGV4aXN0ZW50IiwgTlVMTCk7CglyZXR1cm4gKFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMSk7CgogICAgfQogICAgaWYgKCEgV1hTX0lTX1NJTVBMRShiYXNlVHlwZSkpIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TVF9QUk9QU19DT1JSRUNUXzEsCgkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCSAgICAiVGhlIGJhc2UgdHlwZSAnJXMnIGlzIG5vdCBhIHNpbXBsZSB0eXBlIiwKCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBiYXNlVHlwZSkpOwoJRlJFRV9BTkRfTlVMTChzdHIpCglyZXR1cm4gKFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMSk7CiAgICB9CiAgICBpZiAoIChXWFNfSVNfTElTVCh0eXBlKSB8fCBXWFNfSVNfVU5JT04odHlwZSkpICYmCgkgKFdYU19JU19SRVNUUklDVElPTih0eXBlKSA9PSAwKSAmJgoJICghIFdYU19JU19BTllfU0lNUExFX1RZUEUoYmFzZVR5cGUpKSkgewoJeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMSwKCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJICAgICJBIHR5cGUsIGRlcml2ZWQgYnkgbGlzdCBvciB1bmlvbiwgbXVzdCBoYXZlIgoJICAgICJ0aGUgc2ltcGxlIHVyLXR5cGUgZGVmaW5pdGlvbiBhcyBiYXNlIHR5cGUsIG5vdCAnJXMnIiwKCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBiYXNlVHlwZSkpOwoJRlJFRV9BTkRfTlVMTChzdHIpCglyZXR1cm4gKFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMSk7CiAgICB9CiAgICAvKgogICAgKiBWYXJpZXR5OiBPbmUgb2Yge2F0b21pYywgbGlzdCwgdW5pb259LgogICAgKi8KICAgIGlmICgoISBXWFNfSVNfQVRPTUlDKHR5cGUpKSAmJiAoISBXWFNfSVNfVU5JT04odHlwZSkpICYmCgkoISBXWFNfSVNfTElTVCh0eXBlKSkpIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TVF9QUk9QU19DT1JSRUNUXzEsCgkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCSAgICAiVGhlIHZhcmlldHkgaXMgYWJzZW50IiwgTlVMTCk7CglyZXR1cm4gKFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMSk7CiAgICB9CiAgICAvKiBUT0RPOiBGaW5pc2ggdGhpcy4gSG1tLCBpcyB0aGlzIGZpbmlzaGVkPyAqLwoKICAgIC8qCiAgICAqIDMgVGhlIHtmaW5hbH0gb2YgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gbXVzdCBub3QgY29udGFpbiByZXN0cmljdGlvbi4KICAgICovCiAgICBpZiAoeG1sU2NoZW1hVHlwZUZpbmFsQ29udGFpbnMoYmFzZVR5cGUsCglYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX1JFU1RSSUNUSU9OKSkgewoJeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJICAgIFhNTF9TQ0hFTUFQX1NUX1BST1BTX0NPUlJFQ1RfMywKCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJICAgICJUaGUgJ2ZpbmFsJyBvZiBpdHMgYmFzZSB0eXBlICclcycgbXVzdCBub3QgY29udGFpbiAiCgkgICAgIidyZXN0cmljdGlvbiciLAoJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGJhc2VUeXBlKSk7CglGUkVFX0FORF9OVUxMKHN0cikKCXJldHVybiAoWE1MX1NDSEVNQVBfU1RfUFJPUFNfQ09SUkVDVF8zKTsKICAgIH0KCiAgICAvKgogICAgKiAyIEFsbCBzaW1wbGUgdHlwZSBkZWZpbml0aW9ucyBtdXN0IGJlIGRlcml2ZWQgdWx0aW1hdGVseSBmcm9tIHRoZSC3c2ltcGxlCiAgICAqIHVyLXR5cGUgZGVmaW5pdGlvbiAoc2+3IGNpcmN1bGFyIGRlZmluaXRpb25zIGFyZSBkaXNhbGxvd2VkKS4gVGhhdCBpcywgaXQKICAgICogbXVzdCBiZSBwb3NzaWJsZSB0byByZWFjaCBhIGJ1aWx0LWluIHByaW1pdGl2ZSBkYXRhdHlwZSBvciB0aGUgt3NpbXBsZQogICAgKiB1ci10eXBlIGRlZmluaXRpb263IGJ5IHJlcGVhdGVkbHkgZm9sbG93aW5nIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259LgogICAgKgogICAgKiBOT1RFOiB0aGlzIGlzIGRvbmUgaW4geG1sU2NoZW1hQ2hlY2tUeXBlRGVmQ2lyY3VsYXIoKS4KICAgICovCiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tDT1NTVFJlc3RyaWN0czoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEB0eXBlOiAgdGhlIHNpbXBsZSB0eXBlIGRlZmluaXRpb24KICoKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OgogKiBEZXJpdmF0aW9uIFZhbGlkIChSZXN0cmljdGlvbiwgU2ltcGxlKSAoY29zLXN0LXJlc3RyaWN0cykKCiAqIENoZWNrcyBpZiB0aGUgZ2l2ZW4gQHR5cGUgKHNpbXBsZVR5cGUpIGlzIGRlcml2ZWQgdmFsaWRseSBieSByZXN0cmljdGlvbi4KICogU1RBVFVTOgogKgogKiBSZXR1cm5zIC0xIG9uIGludGVybmFsIGVycm9ycywgMCBpZiB0aGUgdHlwZSBpcyB2YWxpZGx5IGRlcml2ZWQsCiAqIGEgcG9zaXRpdmUgZXJyb3IgY29kZSBvdGhlcndpc2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ09TU1RSZXN0cmljdHMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJICAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgogICAgaWYgKHR5cGUtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX1NJTVBMRSkgewoJUEVSUk9SX0lOVCgieG1sU2NoZW1hQ2hlY2tDT1NTVFJlc3RyaWN0cyIsCgkgICAgImdpdmVuIHR5cGUgaXMgbm90IGEgdXNlci1kZXJpdmVkIHNpbXBsZVR5cGUiKTsKCXJldHVybiAoLTEpOwogICAgfQoKICAgIGlmIChXWFNfSVNfQVRPTUlDKHR5cGUpKSB7Cgl4bWxTY2hlbWFUeXBlUHRyIHByaW1pdGl2ZTsKCS8qCgkqIDEuMSBUaGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBtdXN0IGJlIGFuIGF0b21pYyBzaW1wbGUKCSogdHlwZSBkZWZpbml0aW9uIG9yIGEgYnVpbHQtaW4gcHJpbWl0aXZlIGRhdGF0eXBlLgoJKi8KCWlmICghIFdYU19JU19BVE9NSUModHlwZS0+YmFzZVR5cGUpKSB7CgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQlYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzFfMSwKCQlXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSJUaGUgYmFzZSB0eXBlICclcycgaXMgbm90IGFuIGF0b21pYyBzaW1wbGUgdHlwZSIsCgkJeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ciwgdHlwZS0+YmFzZVR5cGUpKTsKCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMV8xKTsKCX0KCS8qIDEuMiBUaGUge2ZpbmFsfSBvZiB0aGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBtdXN0IG5vdCBjb250YWluCgkqIHJlc3RyaWN0aW9uLgoJKi8KCS8qIE9QVElNSVpFIFRPRE8gOiBUaGlzIGlzIGFscmVhZHkgZG9uZSBpbiB4bWxTY2hlbWFDaGVja1N0UHJvcHNDb3JyZWN0ICovCglpZiAoeG1sU2NoZW1hVHlwZUZpbmFsQ29udGFpbnModHlwZS0+YmFzZVR5cGUsCgkgICAgWE1MX1NDSEVNQVNfVFlQRV9GSU5BTF9SRVNUUklDVElPTikpIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMV8yLAoJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJIlRoZSBmaW5hbCBvZiBpdHMgYmFzZSB0eXBlICclcycgbXVzdCBub3QgY29udGFpbiAncmVzdHJpY3Rpb24nIiwKCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCB0eXBlLT5iYXNlVHlwZSkpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKQoJICAgIHJldHVybiAoWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18xXzIpOwoJfQoKCS8qCgkqIDEuMy4xIERGIG11c3QgYmUgYW4gYWxsb3dlZCBjb25zdHJhaW5pbmcgZmFjZXQgZm9yIHRoZSB7cHJpbWl0aXZlCgkqIHR5cGUgZGVmaW5pdGlvbn0sIGFzIHNwZWNpZmllZCBpbiB0aGUgYXBwcm9wcmlhdGUgc3Vic2VjdGlvbiBvZiAzLjIKCSogUHJpbWl0aXZlIGRhdGF0eXBlcy4KCSovCglpZiAodHlwZS0+ZmFjZXRzICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFGYWNldFB0ciBmYWNldDsKCSAgICBpbnQgb2sgPSAxOwoKCSAgICBwcmltaXRpdmUgPSB4bWxTY2hlbWFHZXRQcmltaXRpdmVUeXBlKHR5cGUpOwoJICAgIGlmIChwcmltaXRpdmUgPT0gTlVMTCkgewoJCVBFUlJPUl9JTlQoInhtbFNjaGVtYUNoZWNrQ09TU1RSZXN0cmljdHMiLAoJCSAgICAiZmFpbGVkIHRvIGdldCBwcmltaXRpdmUgdHlwZSIpOwoJCXJldHVybiAoLTEpOwoJICAgIH0KCSAgICBmYWNldCA9IHR5cGUtPmZhY2V0czsKCSAgICBkbyB7CgkJaWYgKHhtbFNjaGVtYUlzQnVpbHRJblR5cGVGYWNldChwcmltaXRpdmUsIGZhY2V0LT50eXBlKSA9PSAwKSB7CgkJICAgIG9rID0gMDsKCQkgICAgeG1sU2NoZW1hUElsbGVnYWxGYWNldEF0b21pY0VycihwY3R4dCwKCQkJWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18xXzNfMSwKCQkJdHlwZSwgcHJpbWl0aXZlLCBmYWNldCk7CgkJfQoJCWZhY2V0ID0gZmFjZXQtPm5leHQ7CgkgICAgfSB3aGlsZSAoZmFjZXQgIT0gTlVMTCk7CgkgICAgaWYgKG9rID09IDApCgkJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzFfM18xKTsKCX0KCS8qCgkqIFNQRUMgKDEuMy4yKSAiSWYgdGhlcmUgaXMgYSBmYWNldCBvZiB0aGUgc2FtZSBraW5kIGluIHRoZSB7ZmFjZXRzfQoJKiBvZiB0aGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSAoY2FsbCB0aGlzIEJGKSx0aGVuIHRoZSBERidzIHt2YWx1ZX0KCSogbXVzdCBiZSBhIHZhbGlkIHJlc3RyaWN0aW9uIG9mIEJGJ3Mge3ZhbHVlfSBhcyBkZWZpbmVkIGluCgkqIFtYTUwgU2NoZW1hczogRGF0YXR5cGVzXS4iCgkqCgkqIE5PVEUgKDEuMy4yKSBGYWNldCBkZXJpdmF0aW9uIGNvbnN0cmFpbnRzIGFyZSBjdXJyZW50bHkgaGFuZGxlZCBpbgoJKiB4bWxTY2hlbWFEZXJpdmVBbmRWYWxpZGF0ZUZhY2V0cygpCgkqLwogICAgfSBlbHNlIGlmIChXWFNfSVNfTElTVCh0eXBlKSkgewoJeG1sU2NoZW1hVHlwZVB0ciBpdGVtVHlwZSA9IE5VTEw7CgoJaXRlbVR5cGUgPSB0eXBlLT5zdWJ0eXBlczsKCWlmICgoaXRlbVR5cGUgPT0gTlVMTCkgfHwgKCEgV1hTX0lTX1NJTVBMRShpdGVtVHlwZSkpKSB7CgkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hQ2hlY2tDT1NTVFJlc3RyaWN0cyIsCgkJImZhaWxlZCB0byBldmFsdWF0ZSB0aGUgaXRlbSB0eXBlIik7CgkgICAgcmV0dXJuICgtMSk7Cgl9CglpZiAoV1hTX0lTX1RZUEVfTk9UX0ZJWEVEKGl0ZW1UeXBlKSkKCSAgICB4bWxTY2hlbWFUeXBlRml4dXAoaXRlbVR5cGUsIEFDVFhUX0NBU1QgcGN0eHQpOwoJLyoKCSogMi4xIFRoZSB7aXRlbSB0eXBlIGRlZmluaXRpb259IG11c3QgaGF2ZSBhIHt2YXJpZXR5fSBvZiBhdG9taWMgb3IKCSogdW5pb24gKGluIHdoaWNoIGNhc2UgYWxsIHRoZSB7bWVtYmVyIHR5cGUgZGVmaW5pdGlvbnN9CgkqIG11c3QgYmUgYXRvbWljKS4KCSovCglpZiAoKCEgV1hTX0lTX0FUT01JQyhpdGVtVHlwZSkpICYmCgkgICAgKCEgV1hTX0lTX1VOSU9OKGl0ZW1UeXBlKSkpIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMl8xLAoJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJIlRoZSBpdGVtIHR5cGUgJyVzJyBkb2VzIG5vdCBoYXZlIGEgdmFyaWV0eSBvZiBhdG9taWMgb3IgdW5pb24iLAoJCXhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGl0ZW1UeXBlKSk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHIpCgkgICAgcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzJfMSk7Cgl9IGVsc2UgaWYgKFdYU19JU19VTklPTihpdGVtVHlwZSkpIHsKCSAgICB4bWxTY2hlbWFUeXBlTGlua1B0ciBtZW1iZXI7CgoJICAgIG1lbWJlciA9IGl0ZW1UeXBlLT5tZW1iZXJUeXBlczsKCSAgICB3aGlsZSAobWVtYmVyICE9IE5VTEwpIHsKCQlpZiAoISBXWFNfSVNfQVRPTUlDKG1lbWJlci0+dHlwZSkpIHsKCQkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQkJWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18yXzEsCgkJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJCSJUaGUgaXRlbSB0eXBlIGlzIGEgdW5pb24gdHlwZSwgYnV0IHRoZSAiCgkJCSJtZW1iZXIgdHlwZSAnJXMnIG9mIHRoaXMgaXRlbSB0eXBlIGlzIG5vdCBhdG9taWMiLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBtZW1iZXItPnR5cGUpKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpCgkJICAgIHJldHVybiAoWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18yXzEpOwoJCX0KCQltZW1iZXIgPSBtZW1iZXItPm5leHQ7CgkgICAgfQoJfQoKCWlmIChXWFNfSVNfQU5ZX1NJTVBMRV9UWVBFKHR5cGUtPmJhc2VUeXBlKSkgewoJICAgIHhtbFNjaGVtYUZhY2V0UHRyIGZhY2V0OwoJICAgIC8qCgkgICAgKiBUaGlzIGlzIHRoZSBjYXNlIGlmIHdlIGhhdmU6IDxzaW1wbGVUeXBlPjxsaXN0IC4uCgkgICAgKi8KCSAgICAvKgoJICAgICogMi4zLjEKCSAgICAqIDIuMy4xLjEgVGhlIHtmaW5hbH0gb2YgdGhlIHtpdGVtIHR5cGUgZGVmaW5pdGlvbn0gbXVzdCBub3QKCSAgICAqIGNvbnRhaW4gbGlzdC4KCSAgICAqLwoJICAgIGlmICh4bWxTY2hlbWFUeXBlRmluYWxDb250YWlucyhpdGVtVHlwZSwKCQlYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX0xJU1QpKSB7CgkJeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18yXzNfMV8xLAoJCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSAgICAiVGhlIGZpbmFsIG9mIGl0cyBpdGVtIHR5cGUgJyVzJyBtdXN0IG5vdCBjb250YWluICdsaXN0JyIsCgkJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGl0ZW1UeXBlKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgkJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzJfM18xXzEpOwoJICAgIH0KCSAgICAvKgoJICAgICogMi4zLjEuMiBUaGUge2ZhY2V0c30gbXVzdCBvbmx5IGNvbnRhaW4gdGhlIHdoaXRlU3BhY2UKCSAgICAqIGZhY2V0IGNvbXBvbmVudC4KCSAgICAqIE9QVElNSVpFIFRPRE86IHRoZSBTNFMgYWxyZWFkeSBkaXNhbGxvd3MgYW55IGZhY2V0CgkgICAgKiB0byBiZSBzcGVjaWZpZWQuCgkgICAgKi8KCSAgICBpZiAodHlwZS0+ZmFjZXRzICE9IE5VTEwpIHsKCQlmYWNldCA9IHR5cGUtPmZhY2V0czsKCQlkbyB7CgkJICAgIGlmIChmYWNldC0+dHlwZSAhPSBYTUxfU0NIRU1BX0ZBQ0VUX1dISVRFU1BBQ0UpIHsKCQkJeG1sU2NoZW1hUElsbGVnYWxGYWNldExpc3RVbmlvbkVycihwY3R4dCwKCQkJICAgIFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMl8zXzFfMiwKCQkJICAgIHR5cGUsIGZhY2V0KTsKCQkJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzJfM18xXzIpOwoJCSAgICB9CgkJICAgIGZhY2V0ID0gZmFjZXQtPm5leHQ7CgkJfSB3aGlsZSAoZmFjZXQgIT0gTlVMTCk7CgkgICAgfQoJICAgIC8qCgkgICAgKiBNQVlCRSBUT0RPOiAoSG1tLCBub3QgcmVhbGx5KSBEYXRhdHlwZXMgc3RhdGVzOgoJICAgICogQSC3bGlzdLcgZGF0YXR5cGUgY2FuIGJlILdkZXJpdmVktyBmcm9tIGFuILdhdG9taWO3IGRhdGF0eXBlCgkgICAgKiB3aG9zZSC3bGV4aWNhbCBzcGFjZbcgYWxsb3dzIHNwYWNlIChzdWNoIGFzIHN0cmluZyBvciBhbnlVUkkpb3IKCSAgICAqIGEgt3VuaW9utyBkYXRhdHlwZSBhbnkgb2Ygd2hvc2Uge21lbWJlciB0eXBlIGRlZmluaXRpb25zfSdzCgkgICAgKiC3bGV4aWNhbCBzcGFjZbcgYWxsb3dzIHNwYWNlLgoJICAgICovCgl9IGVsc2UgewoJICAgIC8qCgkgICAgKiBUaGlzIGlzIHRoZSBjYXNlIGlmIHdlIGhhdmU6IDxzaW1wbGVUeXBlPjxyZXN0cmljdGlvbiAuLi4KCSAgICAqIEkuZS4gdGhlIHZhcmlldHkgb2YgImxpc3QiIGlzIGluaGVyaXRlZC4KCSAgICAqLwoJICAgIC8qCgkgICAgKiAyLjMuMgoJICAgICogMi4zLjIuMSBUaGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBtdXN0IGhhdmUgYSB7dmFyaWV0eX0gb2YgbGlzdC4KCSAgICAqLwoJICAgIGlmICghIFdYU19JU19MSVNUKHR5cGUtPmJhc2VUeXBlKSkgewoJCXhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMl8zXzJfMSwKCQkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkgICAgIlRoZSBiYXNlIHR5cGUgJyVzJyBtdXN0IGJlIGEgbGlzdCB0eXBlIiwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ciwgdHlwZS0+YmFzZVR5cGUpKTsKCQlGUkVFX0FORF9OVUxMKHN0cikKCQlyZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMl8zXzJfMSk7CgkgICAgfQoJICAgIC8qCgkgICAgKiAyLjMuMi4yIFRoZSB7ZmluYWx9IG9mIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259IG11c3Qgbm90CgkgICAgKiBjb250YWluIHJlc3RyaWN0aW9uLgoJICAgICovCgkgICAgaWYgKHhtbFNjaGVtYVR5cGVGaW5hbENvbnRhaW5zKHR5cGUtPmJhc2VUeXBlLAoJCVhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfUkVTVFJJQ1RJT04pKSB7CgkJeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18yXzNfMl8yLAoJCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSAgICAiVGhlICdmaW5hbCcgb2YgdGhlIGJhc2UgdHlwZSAnJXMnIG11c3Qgbm90IGNvbnRhaW4gJ3Jlc3RyaWN0aW9uJyIsCgkJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIHR5cGUtPmJhc2VUeXBlKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgkJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzJfM18yXzIpOwoJICAgIH0KCSAgICAvKgoJICAgICogMi4zLjIuMyBUaGUge2l0ZW0gdHlwZSBkZWZpbml0aW9ufSBtdXN0IGJlIHZhbGlkbHkgZGVyaXZlZAoJICAgICogZnJvbSB0aGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSdzIHtpdGVtIHR5cGUgZGVmaW5pdGlvbn0gZ2l2ZW4KCSAgICAqIHRoZSBlbXB0eSBzZXQsIGFzIGRlZmluZWQgaW4gVHlwZSBEZXJpdmF0aW9uIE9LIChTaW1wbGUpICinMy4xNC42KS4KCSAgICAqLwoJICAgIHsKCQl4bWxTY2hlbWFUeXBlUHRyIGJhc2VJdGVtVHlwZTsKCgkJYmFzZUl0ZW1UeXBlID0gdHlwZS0+YmFzZVR5cGUtPnN1YnR5cGVzOwoJCWlmICgoYmFzZUl0ZW1UeXBlID09IE5VTEwpIHx8ICghIFdYU19JU19TSU1QTEUoYmFzZUl0ZW1UeXBlKSkpIHsKCQkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hQ2hlY2tDT1NTVFJlc3RyaWN0cyIsCgkJCSJmYWlsZWQgdG8gZXZhbCB0aGUgaXRlbSB0eXBlIG9mIGEgYmFzZSB0eXBlIik7CgkJICAgIHJldHVybiAoLTEpOwoJCX0KCQlpZiAoKGl0ZW1UeXBlICE9IGJhc2VJdGVtVHlwZSkgJiYKCQkgICAgKHhtbFNjaGVtYUNoZWNrQ09TU1REZXJpdmVkT0soQUNUWFRfQ0FTVCBwY3R4dCwgaXRlbVR5cGUsCgkJCWJhc2VJdGVtVHlwZSwgMCkgIT0gMCkpIHsKCQkgICAgeG1sQ2hhciAqc3RyQklUID0gTlVMTCwgKnN0ckJUID0gTlVMTDsKCQkgICAgeG1sU2NoZW1hUEN1c3RvbUVyckV4dChwY3R4dCwKCQkJWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18yXzNfMl8zLAoJCQlXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCQkiVGhlIGl0ZW0gdHlwZSAnJXMnIGlzIG5vdCB2YWxpZGx5IGRlcml2ZWQgZnJvbSAiCgkJCSJ0aGUgaXRlbSB0eXBlICclcycgb2YgdGhlIGJhc2UgdHlwZSAnJXMnIiwKCQkJeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ciwgaXRlbVR5cGUpLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyQklULCBiYXNlSXRlbVR5cGUpLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyQlQsIHR5cGUtPmJhc2VUeXBlKSk7CgoJCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCQkgICAgRlJFRV9BTkRfTlVMTChzdHJCSVQpCgkJICAgIEZSRUVfQU5EX05VTEwoc3RyQlQpCgkJICAgIHJldHVybiAoWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18yXzNfMl8zKTsKCQl9CgkgICAgfQoKCSAgICBpZiAodHlwZS0+ZmFjZXRzICE9IE5VTEwpIHsKCQl4bWxTY2hlbWFGYWNldFB0ciBmYWNldDsKCQlpbnQgb2sgPSAxOwoJCS8qCgkJKiAyLjMuMi40IE9ubHkgbGVuZ3RoLCBtaW5MZW5ndGgsIG1heExlbmd0aCwgd2hpdGVTcGFjZSwgcGF0dGVybgoJCSogYW5kIGVudW1lcmF0aW9uIGZhY2V0IGNvbXBvbmVudHMgYXJlIGFsbG93ZWQgYW1vbmcgdGhlIHtmYWNldHN9LgoJCSovCgkJZmFjZXQgPSB0eXBlLT5mYWNldHM7CgkJZG8gewoJCSAgICBzd2l0Y2ggKGZhY2V0LT50eXBlKSB7CgkJCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9MRU5HVEg6CgkJCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NSU5MRU5HVEg6CgkJCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NQVhMRU5HVEg6CgkJCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9XSElURVNQQUNFOgoJCQkgICAgLyoKCQkJICAgICogVE9ETzogMi41LjEuMiBMaXN0IGRhdGF0eXBlcwoJCQkgICAgKiBUaGUgdmFsdWUgb2Ygt3doaXRlU3BhY2W3IGlzIGZpeGVkIHRvIHRoZSB2YWx1ZSBjb2xsYXBzZS4KCQkJICAgICovCgkJCWNhc2UgWE1MX1NDSEVNQV9GQUNFVF9QQVRURVJOOgoJCQljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfRU5VTUVSQVRJT046CgkJCSAgICBicmVhazsKCQkJZGVmYXVsdDogewoJCQkgICAgeG1sU2NoZW1hUElsbGVnYWxGYWNldExpc3RVbmlvbkVycihwY3R4dCwKCQkJCVhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMl8zXzJfNCwKCQkJCXR5cGUsIGZhY2V0KTsKCQkJICAgIC8qCgkJCSAgICAqIFdlIGNvdWxkIHJldHVybiwgYnV0IGl0J3MgbmljZXIgdG8gcmVwb3J0IGFsbAoJCQkgICAgKiBpbnZhbGlkIGZhY2V0cy4KCQkJICAgICovCgkJCSAgICBvayA9IDA7CgkJCX0KCQkgICAgfQoJCSAgICBmYWNldCA9IGZhY2V0LT5uZXh0OwoJCX0gd2hpbGUgKGZhY2V0ICE9IE5VTEwpOwoJCWlmIChvayA9PSAwKQoJCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfMl8zXzJfNCk7CgkJLyoKCQkqIFNQRUMgKDIuMy4yLjUpIChzYW1lIGFzIDEuMy4yKQoJCSoKCQkqIE5PVEUgKDIuMy4yLjUpIFRoaXMgaXMgY3VycmVudGx5IGRvbmUgaW4KCQkqIHhtbFNjaGVtYURlcml2ZUFuZFZhbGlkYXRlRmFjZXRzKCkKCQkqLwoJICAgIH0KCX0KICAgIH0gZWxzZSBpZiAoV1hTX0lTX1VOSU9OKHR5cGUpKSB7CgkvKgoJKiAzLjEgVGhlIHttZW1iZXIgdHlwZSBkZWZpbml0aW9uc30gbXVzdCBhbGwgaGF2ZSB7dmFyaWV0eX0gb2YKCSogYXRvbWljIG9yIGxpc3QuCgkqLwoJeG1sU2NoZW1hVHlwZUxpbmtQdHIgbWVtYmVyOwoKCW1lbWJlciA9IHR5cGUtPm1lbWJlclR5cGVzOwoJd2hpbGUgKG1lbWJlciAhPSBOVUxMKSB7CgkgICAgaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRChtZW1iZXItPnR5cGUpKQoJCXhtbFNjaGVtYVR5cGVGaXh1cChtZW1iZXItPnR5cGUsIEFDVFhUX0NBU1QgcGN0eHQpOwoKCSAgICBpZiAoKCEgV1hTX0lTX0FUT01JQyhtZW1iZXItPnR5cGUpKSAmJgoJCSghIFdYU19JU19MSVNUKG1lbWJlci0+dHlwZSkpKSB7CgkJeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18zXzEsCgkJICAgIFdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJICAgICJUaGUgbWVtYmVyIHR5cGUgJyVzJyBpcyBuZWl0aGVyIGFuIGF0b21pYywgbm9yIGEgbGlzdCB0eXBlIiwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ciwgbWVtYmVyLT50eXBlKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgkJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzNfMSk7CgkgICAgfQoJICAgIG1lbWJlciA9IG1lbWJlci0+bmV4dDsKCX0KCS8qCgkqIDMuMy4xIElmIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259IGlzIHRoZSC3c2ltcGxlIHVyLXR5cGUKCSogZGVmaW5pdGlvbrcKCSovCglpZiAodHlwZS0+YmFzZVR5cGUtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX0FOWVNJTVBMRVRZUEUpIHsKCSAgICAvKgoJICAgICogMy4zLjEuMSBBbGwgb2YgdGhlIHttZW1iZXIgdHlwZSBkZWZpbml0aW9uc30gbXVzdCBoYXZlIGEKCSAgICAqIHtmaW5hbH0gd2hpY2ggZG9lcyBub3QgY29udGFpbiB1bmlvbi4KCSAgICAqLwoJICAgIG1lbWJlciA9IHR5cGUtPm1lbWJlclR5cGVzOwoJICAgIHdoaWxlIChtZW1iZXIgIT0gTlVMTCkgewoJCWlmICh4bWxTY2hlbWFUeXBlRmluYWxDb250YWlucyhtZW1iZXItPnR5cGUsCgkJICAgIFhNTF9TQ0hFTUFTX1RZUEVfRklOQUxfVU5JT04pKSB7CgkJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJCVhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfM18zXzEsCgkJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJCSJUaGUgJ2ZpbmFsJyBvZiBtZW1iZXIgdHlwZSAnJXMnIGNvbnRhaW5zICd1bmlvbiciLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBtZW1iZXItPnR5cGUpKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpCgkJICAgIHJldHVybiAoWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18zXzNfMSk7CgkJfQoJCW1lbWJlciA9IG1lbWJlci0+bmV4dDsKCSAgICB9CgkgICAgLyoKCSAgICAqIDMuMy4xLjIgVGhlIHtmYWNldHN9IG11c3QgYmUgZW1wdHkuCgkgICAgKi8KCSAgICBpZiAodHlwZS0+ZmFjZXRTZXQgIT0gTlVMTCkgewoJCXhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfM18zXzFfMiwKCQkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkgICAgIk5vIGZhY2V0cyBhbGxvd2VkIiwgTlVMTCk7CgkJcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzNfM18xXzIpOwoJICAgIH0KCX0gZWxzZSB7CgkgICAgLyoKCSAgICAqIDMuMy4yLjEgVGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gbXVzdCBoYXZlIGEge3ZhcmlldHl9IG9mIHVuaW9uLgoJICAgICogSS5lLiB0aGUgdmFyaWV0eSBvZiAibGlzdCIgaXMgaW5oZXJpdGVkLgoJICAgICovCgkgICAgaWYgKCEgV1hTX0lTX1VOSU9OKHR5cGUtPmJhc2VUeXBlKSkgewoJCXhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfM18zXzJfMSwKCQkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkgICAgIlRoZSBiYXNlIHR5cGUgJyVzJyBpcyBub3QgYSB1bmlvbiB0eXBlIiwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ciwgdHlwZS0+YmFzZVR5cGUpKTsKCQlGUkVFX0FORF9OVUxMKHN0cikKCQlyZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfM18zXzJfMSk7CgkgICAgfQoJICAgIC8qCgkgICAgKiAzLjMuMi4yIFRoZSB7ZmluYWx9IG9mIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259IG11c3Qgbm90IGNvbnRhaW4gcmVzdHJpY3Rpb24uCgkgICAgKi8KCSAgICBpZiAoeG1sU2NoZW1hVHlwZUZpbmFsQ29udGFpbnModHlwZS0+YmFzZVR5cGUsCgkJWE1MX1NDSEVNQVNfVFlQRV9GSU5BTF9SRVNUUklDVElPTikpIHsKCQl4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzNfM18yXzIsCgkJICAgIFdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJICAgICJUaGUgJ2ZpbmFsJyBvZiBpdHMgYmFzZSB0eXBlICclcycgbXVzdCBub3QgY29udGFpbiAncmVzdHJpY3Rpb24nIiwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ciwgdHlwZS0+YmFzZVR5cGUpKTsKCQlGUkVFX0FORF9OVUxMKHN0cikKCQlyZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19TVF9SRVNUUklDVFNfM18zXzJfMik7CgkgICAgfQoJICAgIC8qCgkgICAgKiAzLjMuMi4zIFRoZSB7bWVtYmVyIHR5cGUgZGVmaW5pdGlvbnN9LCBpbiBvcmRlciwgbXVzdCBiZSB2YWxpZGx5CgkgICAgKiBkZXJpdmVkIGZyb20gdGhlIGNvcnJlc3BvbmRpbmcgdHlwZSBkZWZpbml0aW9ucyBpbiB0aGUge2Jhc2UKCSAgICAqIHR5cGUgZGVmaW5pdGlvbn0ncyB7bWVtYmVyIHR5cGUgZGVmaW5pdGlvbnN9IGdpdmVuIHRoZSBlbXB0eSBzZXQsCgkgICAgKiBhcyBkZWZpbmVkIGluIFR5cGUgRGVyaXZhdGlvbiBPSyAoU2ltcGxlKSAopzMuMTQuNikuCgkgICAgKi8KCSAgICB7CgkJeG1sU2NoZW1hVHlwZUxpbmtQdHIgYmFzZU1lbWJlcjsKCgkJLyoKCQkqIE9QVElNSVpFOiBpZiB0aGUgdHlwZSBpcyByZXN0cmljdGluZywgaXQgaGFzIG5vIGxvY2FsIGRlZmluZWQKCQkqIG1lbWJlciB0eXBlcyBhbmQgaW5oZXJpdHMgdGhlIG1lbWJlciB0eXBlcyBvZiB0aGUgYmFzZSB0eXBlOwoJCSogdGh1cyBhIGNoZWNrIGZvciBlcXVhbGl0eSBjYW4gYmUgc2tpcHBlZC4KCQkqLwoJCS8qCgkJKiBFdmVuIHdvcnNlOiBJIGNhbm5vdCBzZWUgYSBzY2VuYXJpbyB3aGVyZSBhIHJlc3RyaWN0aW5nCgkJKiB1bmlvbiBzaW1wbGUgdHlwZSBjYW4gaGF2ZSBvdGhlciBtZW1iZXIgdHlwZXMgYXMgdGhlIG1lbWJlcgoJCSogdHlwZXMgb2YgaXQncyBiYXNlIHR5cGUuIFRoaXMgY2hlY2sgc2VlbXMgbm90IG5lY2Vzc2FyeSB3aXRoCgkJKiByZXNwZWN0IHRvIHRoZSBkZXJpdmF0aW9uIHByb2Nlc3MgaW4gbGlieG1sMi4KCQkqIEJ1dCBuZWNlc3NhcnkgaWYgY29uc3RydWN0aW5nIHR5cGVzIHdpdGggYW4gQVBJLgoJCSovCgkJaWYgKHR5cGUtPm1lbWJlclR5cGVzICE9IE5VTEwpIHsKCQkgICAgbWVtYmVyID0gdHlwZS0+bWVtYmVyVHlwZXM7CgkJICAgIGJhc2VNZW1iZXIgPSB4bWxTY2hlbWFHZXRVbmlvblNpbXBsZVR5cGVNZW1iZXJUeXBlcyh0eXBlLT5iYXNlVHlwZSk7CgkJICAgIGlmICgobWVtYmVyID09IE5VTEwpICYmIChiYXNlTWVtYmVyICE9IE5VTEwpKSB7CgkJCVBFUlJPUl9JTlQoInhtbFNjaGVtYUNoZWNrQ09TU1RSZXN0cmljdHMiLAoJCQkgICAgImRpZmZlcmVudCBudW1iZXIgb2YgbWVtYmVyIHR5cGVzIGluIGJhc2UiKTsKCQkgICAgfQoJCSAgICB3aGlsZSAobWVtYmVyICE9IE5VTEwpIHsKCQkJaWYgKGJhc2VNZW1iZXIgPT0gTlVMTCkgewoJCQkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hQ2hlY2tDT1NTVFJlc3RyaWN0cyIsCgkJCSAgICAiZGlmZmVyZW50IG51bWJlciBvZiBtZW1iZXIgdHlwZXMgaW4gYmFzZSIpOwoJCQl9CgkJCWlmICgobWVtYmVyLT50eXBlICE9IGJhc2VNZW1iZXItPnR5cGUpICYmCgkJCSAgICAoeG1sU2NoZW1hQ2hlY2tDT1NTVERlcml2ZWRPSyhBQ1RYVF9DQVNUIHBjdHh0LAoJCQkJbWVtYmVyLT50eXBlLCBiYXNlTWVtYmVyLT50eXBlLCAwKSAhPSAwKSkgewoJCQkgICAgeG1sQ2hhciAqc3RyQk1UID0gTlVMTCwgKnN0ckJUID0gTlVMTDsKCgkJCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyRXh0KHBjdHh0LAoJCQkJWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18zXzNfMl8zLAoJCQkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkJCSJUaGUgbWVtYmVyIHR5cGUgJXMgaXMgbm90IHZhbGlkbHkgIgoJCQkJImRlcml2ZWQgZnJvbSBpdHMgY29ycmVzcG9uZGluZyBtZW1iZXIgIgoJCQkJInR5cGUgJXMgb2YgdGhlIGJhc2UgdHlwZSAlcyIsCgkJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBtZW1iZXItPnR5cGUpLAoJCQkJeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ckJNVCwgYmFzZU1lbWJlci0+dHlwZSksCgkJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyQlQsIHR5cGUtPmJhc2VUeXBlKSk7CgkJCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCQkJICAgIEZSRUVfQU5EX05VTEwoc3RyQk1UKQoJCQkgICAgRlJFRV9BTkRfTlVMTChzdHJCVCkKCQkJICAgIHJldHVybiAoWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18zXzNfMl8zKTsKCQkJfQoJCQltZW1iZXIgPSBtZW1iZXItPm5leHQ7CgkJCWJhc2VNZW1iZXIgPSBiYXNlTWVtYmVyLT5uZXh0OwoJCSAgICB9CgkJfQoJICAgIH0KCSAgICAvKgoJICAgICogMy4zLjIuNCBPbmx5IHBhdHRlcm4gYW5kIGVudW1lcmF0aW9uIGZhY2V0IGNvbXBvbmVudHMgYXJlCgkgICAgKiBhbGxvd2VkIGFtb25nIHRoZSB7ZmFjZXRzfS4KCSAgICAqLwoJICAgIGlmICh0eXBlLT5mYWNldHMgIT0gTlVMTCkgewoJCXhtbFNjaGVtYUZhY2V0UHRyIGZhY2V0OwoJCWludCBvayA9IDE7CgoJCWZhY2V0ID0gdHlwZS0+ZmFjZXRzOwoJCWRvIHsKCQkgICAgaWYgKChmYWNldC0+dHlwZSAhPSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk4pICYmCgkJCShmYWNldC0+dHlwZSAhPSBYTUxfU0NIRU1BX0ZBQ0VUX0VOVU1FUkFUSU9OKSkgewoJCQl4bWxTY2hlbWFQSWxsZWdhbEZhY2V0TGlzdFVuaW9uRXJyKHBjdHh0LAoJCQkJWE1MX1NDSEVNQVBfQ09TX1NUX1JFU1RSSUNUU18zXzNfMl80LAoJCQkJdHlwZSwgZmFjZXQpOwoJCQlvayA9IDA7CgkJICAgIH0KCQkgICAgZmFjZXQgPSBmYWNldC0+bmV4dDsKCQl9IHdoaWxlIChmYWNldCAhPSBOVUxMKTsKCQlpZiAob2sgPT0gMCkKCQkgICAgcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfU1RfUkVTVFJJQ1RTXzNfM18yXzQpOwoKCSAgICB9CgkgICAgLyoKCSAgICAqIFNQRUMgKDMuMy4yLjUpIChzYW1lIGFzIDEuMy4yKQoJICAgICoKCSAgICAqIE5PVEUgKDMuMy4yLjUpIFRoaXMgaXMgY3VycmVudGx5IGRvbmUgaW4KCSAgICAqIHhtbFNjaGVtYURlcml2ZUFuZFZhbGlkYXRlRmFjZXRzKCkKCSAgICAqLwoJfQogICAgfQoKICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja1NSQ1NpbXBsZVR5cGU6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uCiAqCiAqIENoZWNrcyBjcmMtc2ltcGxlLXR5cGUgY29uc3RyYWludHMuIAogKgogKiBSZXR1cm5zIDAgaWYgdGhlIGNvbnN0cmFpbnRzIGFyZSBzYXRpc2ZpZWQsCiAqIGlmIG5vdCBhIHBvc2l0aXZlIGVycm9yIGNvZGUgYW5kIC0xIG9uIGludGVybmFsCiAqIGVycm9ycy4KICovCiNpZiAwCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tTUkNTaW1wbGVUeXBlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgLyoKICAgICogc3JjLXNpbXBsZS10eXBlLjEgVGhlIGNvcnJlc3BvbmRpbmcgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbiwgaWYgYW55LAogICAgKiBtdXN0IHNhdGlzZnkgdGhlIGNvbmRpdGlvbnMgc2V0IG91dCBpbiBDb25zdHJhaW50cyBvbiBTaW1wbGUgVHlwZQogICAgKiBEZWZpbml0aW9uIFNjaGVtYSBDb21wb25lbnRzICinMy4xNC42KS4KICAgICovICAgIAogICAgaWYgKFdYU19JU19SRVNUUklDVElPTih0eXBlKSkgewoJLyoKCSogc3JjLXNpbXBsZS10eXBlLjIgIklmIHRoZSA8cmVzdHJpY3Rpb24+IGFsdGVybmF0aXZlIGlzIGNob3NlbiwKCSogZWl0aGVyIGl0IG11c3QgaGF2ZSBhIGJhc2UgW2F0dHJpYnV0ZV0gb3IgYSA8c2ltcGxlVHlwZT4gYW1vbmcgaXRzCgkqIFtjaGlsZHJlbl0sIGJ1dCBub3QgYm90aC4iCgkqIE5PVEU6IFRoaXMgaXMgY2hlY2tlZCBpbiB0aGUgcGFyc2UgZnVuY3Rpb24gb2YgPHJlc3RyaWN0aW9uPi4KCSovCgkvKgoJKiAKCSovCiAgICB9IGVsc2UgaWYgKFdYU19JU19MSVNUKHR5cGUpKSB7CgkvKiBzcmMtc2ltcGxlLXR5cGUuMyAiSWYgdGhlIDxsaXN0PiBhbHRlcm5hdGl2ZSBpcyBjaG9zZW4sIGVpdGhlciBpdCBtdXN0IGhhdmUKCSogYW4gaXRlbVR5cGUgW2F0dHJpYnV0ZV0gb3IgYSA8c2ltcGxlVHlwZT4gYW1vbmcgaXRzIFtjaGlsZHJlbl0sCgkqIGJ1dCBub3QgYm90aC4iCgkqCgkqIE5PVEU6IFRoaXMgaXMgY2hlY2tlZCBpbiB0aGUgcGFyc2UgZnVuY3Rpb24gb2YgPGxpc3Q+LgoJKi8KICAgIH0gZWxzZSBpZiAoV1hTX0lTX1VOSU9OKHR5cGUpKSB7CQoJLyogCgkqIHNyYy1zaW1wbGUtdHlwZS40IGlzIGNoZWNrZWQgaW4geG1sU2NoZW1hQ2hlY2tVbmlvblR5cGVEZWZDaXJjdWxhcigpLgoJKi8KICAgIH0KICAgIHJldHVybiAoMCk7Cn0KI2VuZGlmCgpzdGF0aWMgaW50CnhtbFNjaGVtYUNyZWF0ZVZDdHh0T25QQ3R4dCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQpCnsKICAgaWYgKGN0eHQtPnZjdHh0ID09IE5VTEwpIHsKCWN0eHQtPnZjdHh0ID0geG1sU2NoZW1hTmV3VmFsaWRDdHh0KE5VTEwpOwoJaWYgKGN0eHQtPnZjdHh0ID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyKGN0eHQsIE5VTEwsCgkJWE1MX1NDSEVNQVBfSU5URVJOQUwsCgkJIkludGVybmFsIGVycm9yOiB4bWxTY2hlbWFDcmVhdGVWQ3R4dE9uUEN0eHQsICIKCQkiZmFpbGVkIHRvIGNyZWF0ZSBhIHRlbXAuIHZhbGlkYXRpb24gY29udGV4dC5cbiIsCgkJTlVMTCwgTlVMTCk7CgkgICAgcmV0dXJuICgtMSk7Cgl9CgkvKiBUT0RPOiBQYXNzIHVzZXIgZGF0YS4gKi8KCXhtbFNjaGVtYVNldFZhbGlkRXJyb3JzKGN0eHQtPnZjdHh0LAoJICAgIGN0eHQtPmVycm9yLCBjdHh0LT53YXJuaW5nLCBjdHh0LT5lcnJDdHh0KTsKCXhtbFNjaGVtYVNldFZhbGlkU3RydWN0dXJlZEVycm9ycyhjdHh0LT52Y3R4dCwKCSAgICBjdHh0LT5zZXJyb3IsIGN0eHQtPmVyckN0eHQpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkJICAgICB4bWxOb2RlUHRyIG5vZGUsCgkJCSAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQkgICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkgICAgIHhtbFNjaGVtYVZhbFB0ciAqcmV0VmFsLAoJCQkgICAgIGludCBmaXJlRXJyb3JzLAoJCQkgICAgIGludCBub3JtYWxpemUsCgkJCSAgICAgaW50IGlzTm9ybWFsaXplZCk7CgovKioKICogeG1sU2NoZW1hUGFyc2VDaGVja0NPU1ZhbGlkRGVmYXVsdDoKICogQHBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uCiAqIEB2YWx1ZTogdGhlIGRlZmF1bHQgdmFsdWUKICogQG5vZGU6IGFuIG9wdGlvbmFsIG5vZGUgKHRoZSBob2xkZXIgb2YgdGhlIHZhbHVlKQogKgogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IEVsZW1lbnQgRGVmYXVsdCBWYWxpZCAoSW1tZWRpYXRlKQogKiAoY29zLXZhbGlkLWRlZmF1bHQpCiAqIFRoaXMgd2lsbCBiZSB1c2VkIGJ5IHRoZSBwYXJzZXIgb25seS4gRm9yIHRoZSB2YWxpZGF0b3IgdGhlcmUncwogKiBhbiBvdGhlciB2ZXJzaW9uLgogKgogKiBSZXR1cm5zIDAgaWYgdGhlIGNvbnN0cmFpbnRzIGFyZSBzYXRpc2ZpZWQsCiAqIGlmIG5vdCwgYSBwb3NpdGl2ZSBlcnJvciBjb2RlIGFuZCAtMSBvbiBpbnRlcm5hbAogKiBlcnJvcnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVBhcnNlQ2hlY2tDT1NWYWxpZERlZmF1bHQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJCSAgIHhtbE5vZGVQdHIgbm9kZSwKCQkJCSAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKCQkJCSAgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkJICAgeG1sU2NoZW1hVmFsUHRyICp2YWwpCnsKICAgIGludCByZXQgPSAwOwoKICAgIC8qCiAgICAqIGNvcy12YWxpZC1kZWZhdWx0OgogICAgKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IEVsZW1lbnQgRGVmYXVsdCBWYWxpZCAoSW1tZWRpYXRlKQogICAgKiBGb3IgYSBzdHJpbmcgdG8gYmUgYSB2YWxpZCBkZWZhdWx0IHdpdGggcmVzcGVjdCB0byBhIHR5cGUKICAgICogZGVmaW5pdGlvbiB0aGUgYXBwcm9wcmlhdGUgY2FzZSBhbW9uZyB0aGUgZm9sbG93aW5nIG11c3QgYmUgdHJ1ZToKICAgICovCiAgICBpZiBXWFNfSVNfQ09NUExFWCh0eXBlKSB7CgkvKgoJKiBDb21wbGV4IHR5cGUuCgkqCgkqIFNQRUMgKDIuMSkgIml0cyB7Y29udGVudCB0eXBlfSBtdXN0IGJlIGEgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbgoJKiBvciBtaXhlZC4iCgkqIFNQRUMgKDIuMi4yKSAiSWYgdGhlIHtjb250ZW50IHR5cGV9IGlzIG1peGVkLCB0aGVuIHRoZSB7Y29udGVudAoJKiB0eXBlfSdzIHBhcnRpY2xlIG11c3QgYmUgt2VtcHRpYWJsZbcgYXMgZGVmaW5lZCBieQoJKiBQYXJ0aWNsZSBFbXB0aWFibGUgKKczLjkuNikuIgoJKi8KCWlmICgoISBXWFNfSEFTX1NJTVBMRV9DT05URU5UKHR5cGUpKSAmJgoJICAgICgoISBXWFNfSEFTX01JWEVEX0NPTlRFTlQodHlwZSkpIHx8ICghIFdYU19FTVBUSUFCTEUodHlwZSkpKSkgewoJICAgIC8qIE5PVEUgdGhhdCB0aGlzIGNvdmVycyAoMi4yLjIpIGFzIHdlbGwuICovCgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQlYTUxfU0NIRU1BUF9DT1NfVkFMSURfREVGQVVMVF8yXzEsCgkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgdHlwZS0+bm9kZSwKCQkiRm9yIGEgc3RyaW5nIHRvIGJlIGEgdmFsaWQgZGVmYXVsdCwgdGhlIHR5cGUgZGVmaW5pdGlvbiAiCgkJIm11c3QgYmUgYSBzaW1wbGUgdHlwZSBvciBhIGNvbXBsZXggdHlwZSB3aXRoIG1peGVkIGNvbnRlbnQgIgoJCSJhbmQgYSBwYXJ0aWNsZSBlbXB0aWFibGUiLCBOVUxMKTsKCSAgICByZXR1cm4oWE1MX1NDSEVNQVBfQ09TX1ZBTElEX0RFRkFVTFRfMl8xKTsKCX0KICAgIH0KICAgIC8qCiAgICAqIDEgSWYgdGhlIHR5cGUgZGVmaW5pdGlvbiBpcyBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24sIHRoZW4gdGhlIHN0cmluZwogICAgKiBtdXN0IGJlILd2YWxpZLcgd2l0aCByZXNwZWN0IHRvIHRoYXQgZGVmaW5pdGlvbiBhcyBkZWZpbmVkIGJ5IFN0cmluZwogICAgKiBWYWxpZCAopzMuMTQuNCkuCiAgICAqCiAgICAqIEFORAogICAgKgogICAgKiAyLjIuMSBJZiB0aGUge2NvbnRlbnQgdHlwZX0gaXMgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLCB0aGVuIHRoZQogICAgKiBzdHJpbmcgbXVzdCBiZSC3dmFsaWS3IHdpdGggcmVzcGVjdCB0byB0aGF0IHNpbXBsZSB0eXBlIGRlZmluaXRpb24KICAgICogYXMgZGVmaW5lZCBieSBTdHJpbmcgVmFsaWQgKKczLjE0LjQpLgogICAgKi8KICAgIGlmIChXWFNfSVNfU0lNUExFKHR5cGUpKQoJcmV0ID0geG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZShBQ1RYVF9DQVNUIHBjdHh0LCBub2RlLAoJICAgIHR5cGUsIHZhbHVlLCB2YWwsIDEsIDEsIDApOwogICAgZWxzZSBpZiAoV1hTX0hBU19TSU1QTEVfQ09OVEVOVCh0eXBlKSkKCXJldCA9IHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoQUNUWFRfQ0FTVCBwY3R4dCwgbm9kZSwKCSAgICB0eXBlLT5jb250ZW50VHlwZURlZiwgdmFsdWUsIHZhbCwgMSwgMSwgMCk7CiAgICBlbHNlCglyZXR1cm4gKHJldCk7CgogICAgaWYgKHJldCA8IDApIHsKCVBFUlJPUl9JTlQoInhtbFNjaGVtYVBhcnNlQ2hlY2tDT1NWYWxpZERlZmF1bHQiLAoJICAgICJjYWxsaW5nIHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoKSIpOwogICAgfQoKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrQ1RQcm9wc0NvcnJlY3Q6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKgogKi4oNC42KSBDb25zdHJhaW50cyBvbiBDb21wbGV4IFR5cGUgRGVmaW5pdGlvbiBTY2hlbWEgQ29tcG9uZW50cwogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqIENvbXBsZXggVHlwZSBEZWZpbml0aW9uIFByb3BlcnRpZXMgQ29ycmVjdCAoY3QtcHJvcHMtY29ycmVjdCkKICogU1RBVFVTOiAoc2VlbXMpIGNvbXBsZXRlCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tDVFByb3BzQ29ycmVjdCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkgICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgLyoKICAgICogVE9ETzogQ29ycmVjdCB0aGUgZXJyb3IgY29kZTsgWE1MX1NDSEVNQVBfU1JDX0NUXzEgaXMgdXNlZCB0ZW1wb3JhcmlseS4KICAgICoKICAgICogU1BFQyAoMSkgIlRoZSB2YWx1ZXMgb2YgdGhlIHByb3BlcnRpZXMgb2YgYSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiBtdXN0CiAgICAqIGJlIGFzIGRlc2NyaWJlZCBpbiB0aGUgcHJvcGVydHkgdGFibGVhdSBpbiBUaGUgQ29tcGxleCBUeXBlIERlZmluaXRpb24KICAgICogU2NoZW1hIENvbXBvbmVudCAopzMuNC4xKSwgbW9kdWxvIHRoZSBpbXBhY3Qgb2YgTWlzc2luZwogICAgKiBTdWItY29tcG9uZW50cyAopzUuMykuIgogICAgKi8KICAgIGlmICgodHlwZS0+YmFzZVR5cGUgIT0gTlVMTCkgJiYKCShXWFNfSVNfU0lNUExFKHR5cGUtPmJhc2VUeXBlKSkgJiYKCShXWFNfSVNfRVhURU5TSU9OKHR5cGUpID09IDApKSB7CgkvKgoJKiBTUEVDICgyKSAiSWYgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gaXMgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLAoJKiB0aGUge2Rlcml2YXRpb24gbWV0aG9kfSBtdXN0IGJlIGV4dGVuc2lvbi4iCgkqLwoJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfU1JDX0NUXzEsCgkgICAgTlVMTCwgV1hTX0JBU0lDX0NBU1QgdHlwZSwgCgkgICAgIklmIHRoZSBiYXNlIHR5cGUgaXMgYSBzaW1wbGUgdHlwZSwgdGhlIGRlcml2YXRpb24gbWV0aG9kIG11c3QgYmUgIgoJICAgICInZXh0ZW5zaW9uJyIsIE5VTEwsIE5VTEwpOwoJcmV0dXJuIChYTUxfU0NIRU1BUF9TUkNfQ1RfMSk7CiAgICB9CiAgICAvKgogICAgKiBTUEVDICgzKSAiQ2lyY3VsYXIgZGVmaW5pdGlvbnMgYXJlIGRpc2FsbG93ZWQsIGV4Y2VwdCBmb3IgdGhlILd1ci10eXBlCiAgICAqIGRlZmluaXRpb263LiBUaGF0IGlzLCBpdCBtdXN0IGJlIHBvc3NpYmxlIHRvIHJlYWNoIHRoZSC3dXItdHlwZQogICAgKiBkZWZpbml0aW9uIGJ5IHJlcGVhdGVkbHkgZm9sbG93aW5nIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259LiIKICAgICoKICAgICogTk9URSAoMykgaXMgZG9uZSBpbiB4bWxTY2hlbWFDaGVja1R5cGVEZWZDaXJjdWxhcigpLgogICAgKi8KICAgIC8qCiAgICAqIE5PVEUgdGhhdCAoNCkgYW5kICg1KSBuZWVkIHRoZSBmb2xsb3dpbmc6CiAgICAqICAgLSBhdHRyaWJ1dGUgdXNlcyBuZWVkIHRvIGJlIGFscmVhZHkgaW5oZXJpdGVkIChhcHBseSBhdHRyLiBwcm9oaWJpdGlvbnMpCiAgICAqICAgLSBhdHRyaWJ1dGUgZ3JvdXAgcmVmZXJlbmNlcyBuZWVkIHRvIGJlIGV4cGFuZGVkIGFscmVhZHkKICAgICogICAtIHNpbXBsZSB0eXBlcyBuZWVkIHRvIGJlIHR5cGVmaXhlZCBhbHJlYWR5CiAgICAqLyAgICAKICAgIGlmICh0eXBlLT5hdHRyVXNlcyAmJgoJKCgoeG1sU2NoZW1hSXRlbUxpc3RQdHIpIHR5cGUtPmF0dHJVc2VzKS0+bmJJdGVtcyA+IDEpKQogICAgewoJeG1sU2NoZW1hSXRlbUxpc3RQdHIgdXNlcyA9ICh4bWxTY2hlbWFJdGVtTGlzdFB0cikgdHlwZS0+YXR0clVzZXM7Cgl4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgdXNlLCB0bXA7CglpbnQgaSwgaiwgaGFzSWQgPSAwOwoKCWZvciAoaSA9IHVzZXMtPm5iSXRlbXMgLTE7IGkgPj0gMDsgaS0tKSB7CgkgICAgdXNlID0gdXNlcy0+aXRlbXNbaV07CgkgICAgCgkgICAgLyogCgkgICAgKiBTUEVDIGN0LXByb3BzLWNvcnJlY3QKCSAgICAqICg0KSAiVHdvIGRpc3RpbmN0IGF0dHJpYnV0ZSBkZWNsYXJhdGlvbnMgaW4gdGhlCgkgICAgKiB7YXR0cmlidXRlIHVzZXN9IG11c3Qgbm90IGhhdmUgaWRlbnRpY2FsIHtuYW1lfXMgYW5kCgkgICAgKiB7dGFyZ2V0IG5hbWVzcGFjZX1zLiIKCSAgICAqLwoJICAgIGlmIChpID4gMCkgewoJCWZvciAoaiA9IGkgLTE7IGogPj0gMDsgai0tKSB7CgkJICAgIHRtcCA9IHVzZXMtPml0ZW1zW2pdOwoJCSAgICBpZiAoKFdYU19BVFRSVVNFX0RFQ0xfTkFNRSh1c2UpID09CgkJCVdYU19BVFRSVVNFX0RFQ0xfTkFNRSh0bXApKSAmJgoJCQkoV1hTX0FUVFJVU0VfREVDTF9UTlModXNlKSA9PQoJCQlXWFNfQVRUUlVTRV9ERUNMX1ROUyh0bXApKSkKCQkgICAgewoJCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoKCQkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9BR19QUk9QU19DT1JSRUNULAoJCQkgICAgTlVMTCwgV1hTX0JBU0lDX0NBU1QgdHlwZSwKCQkJICAgICJEdXBsaWNhdGUgJXMiLAoJCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ciwgdXNlKSwKCQkJICAgIE5VTEwpOwoJCQlGUkVFX0FORF9OVUxMKHN0cik7CgkJCS8qCgkJCSogUmVtb3ZlIHRoZSBkdXBsaWNhdGUuCgkJCSovCgkJCWlmICh4bWxTY2hlbWFJdGVtTGlzdFJlbW92ZSh1c2VzLCBpKSA9PSAtMSkKCQkJICAgIGdvdG8gZXhpdF9mYWlsdXJlOwoJCQlnb3RvIG5leHRfdXNlOwoJCSAgICB9CgkJfQoJICAgIH0KCSAgICAvKgoJICAgICogU1BFQyBjdC1wcm9wcy1jb3JyZWN0CgkgICAgKiAoNSkgIlR3byBkaXN0aW5jdCBhdHRyaWJ1dGUgZGVjbGFyYXRpb25zIGluIHRoZQoJICAgICoge2F0dHJpYnV0ZSB1c2VzfSBtdXN0IG5vdCBoYXZlIHt0eXBlIGRlZmluaXRpb259cyB3aGljaAoJICAgICogYXJlIG9yIGFyZSBkZXJpdmVkIGZyb20gSUQuIgoJICAgICovCgkgICAgaWYgKFdYU19BVFRSVVNFX1RZUEVERUYodXNlKSAhPSBOVUxMKSB7CgkJaWYgKHhtbFNjaGVtYUlzRGVyaXZlZEZyb21CdWlsdEluVHlwZSgKCQkgICAgV1hTX0FUVFJVU0VfVFlQRURFRih1c2UpLCBYTUxfU0NIRU1BU19JRCkpCgkJewkJCgkJICAgIGlmIChoYXNJZCkgewoJCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoJCQkKCQkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9BR19QUk9QU19DT1JSRUNULAoJCQkgICAgTlVMTCwgV1hTX0JBU0lDX0NBU1QgdHlwZSwKCQkJICAgICJUaGVyZSBtdXN0IG5vdCBleGlzdCBtb3JlIHRoYW4gb25lIGF0dHJpYnV0ZSAiCgkJCSAgICAiZGVjbGFyYXRpb24gb2YgdHlwZSAneHM6SUQnICIKCQkJICAgICIob3IgZGVyaXZlZCBmcm9tICd4czpJRCcpLiBUaGUgJXMgdmlvbGF0ZXMgdGhpcyAiCgkJCSAgICAiY29uc3RyYWludCIsCgkJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyLCB1c2UpLAoJCQkgICAgTlVMTCk7CgkJCUZSRUVfQU5EX05VTEwoc3RyKTsKCQkJaWYgKHhtbFNjaGVtYUl0ZW1MaXN0UmVtb3ZlKHVzZXMsIGkpID09IC0xKQoJCQkgICAgZ290byBleGl0X2ZhaWx1cmU7CgkJICAgIH0KCQkgICAgCgkJICAgIGhhc0lkID0gMTsKCQl9CgkgICAgfQpuZXh0X3VzZToge30KCX0KICAgIH0KICAgIHJldHVybiAoMCk7CmV4aXRfZmFpbHVyZToKICAgIHJldHVybigtMSk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hQXJlRXF1YWxUeXBlcyh4bWxTY2hlbWFUeXBlUHRyIHR5cGVBLAoJCSAgICAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGVCKQp7CiAgICAvKgogICAgKiBUT0RPOiBUaGlzIHNob3VsZCBpbXBsZW1lbnQgY29tcG9uZW50LWlkZW50aXR5CiAgICAqIGluIHRoZSBmdXR1cmUuCiAgICAqLwogICAgaWYgKCh0eXBlQSA9PSBOVUxMKSB8fCAodHlwZUIgPT0gTlVMTCkpCglyZXR1cm4gKDApOwogICAgcmV0dXJuICh0eXBlQSA9PSB0eXBlQik7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0NPU0NURGVyaXZlZE9LOgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHR5cGU6ICB0aGUgdG8tYmUgZGVyaXZlZCBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKiBAYmFzZVR5cGU6ICB0aGUgYmFzZSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKiBAc2V0OiB0aGUgZ2l2ZW4gc2V0CiAqCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogVHlwZSBEZXJpdmF0aW9uIE9LIChDb21wbGV4KSAoY29zLWN0LWRlcml2ZWQtb2spCiAqCiAqIFNUQVRVUzogY29tcGxldGVkCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgb3IgMQogKiBpZiBub3QuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ09TQ1REZXJpdmVkT0soeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCQkgICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKCQkJICAgICB4bWxTY2hlbWFUeXBlUHRyIGJhc2VUeXBlLAoJCQkgICAgIGludCBzZXQpCnsKICAgIGludCBlcXVhbCA9IHhtbFNjaGVtYUFyZUVxdWFsVHlwZXModHlwZSwgYmFzZVR5cGUpOwogICAgLyogVE9ETzogRXJyb3IgY29kZXMuICovCiAgICAvKgogICAgKiBTUEVDICJGb3IgYSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiAoY2FsbCBpdCBELCBmb3IgZGVyaXZlZCkKICAgICogdG8gYmUgdmFsaWRseSBkZXJpdmVkIGZyb20gYSB0eXBlIGRlZmluaXRpb24gKGNhbGwgdGhpcwogICAgKiBCLCBmb3IgYmFzZSkgZ2l2ZW4gYSBzdWJzZXQgb2Yge2V4dGVuc2lvbiwgcmVzdHJpY3Rpb259CiAgICAqIGFsbCBvZiB0aGUgZm9sbG93aW5nIG11c3QgYmUgdHJ1ZToiCiAgICAqLwogICAgaWYgKCEgZXF1YWwpIHsKCS8qCgkqIFNQRUMgKDEpICJJZiBCIGFuZCBEIGFyZSBub3QgdGhlIHNhbWUgdHlwZSBkZWZpbml0aW9uLCB0aGVuIHRoZQoJKiB7ZGVyaXZhdGlvbiBtZXRob2R9IG9mIEQgbXVzdCBub3QgYmUgaW4gdGhlIHN1YnNldC4iCgkqLwoJaWYgKCgoc2V0ICYgU1VCU0VUX0VYVEVOU0lPTikgJiYgKFdYU19JU19FWFRFTlNJT04odHlwZSkpKSB8fAoJICAgICgoc2V0ICYgU1VCU0VUX1JFU1RSSUNUSU9OKSAmJiAoV1hTX0lTX1JFU1RSSUNUSU9OKHR5cGUpKSkpCgkgICAgcmV0dXJuICgxKTsKICAgIH0gZWxzZSB7CgkvKgoJKiBTUEVDICgyLjEpICJCIGFuZCBEIG11c3QgYmUgdGhlIHNhbWUgdHlwZSBkZWZpbml0aW9uLiIKCSovCglyZXR1cm4gKDApOwogICAgfQogICAgLyoKICAgICogU1BFQyAoMi4yKSAiQiBtdXN0IGJlIEQncyB7YmFzZSB0eXBlIGRlZmluaXRpb259LiIKICAgICovCiAgICBpZiAodHlwZS0+YmFzZVR5cGUgPT0gYmFzZVR5cGUpCglyZXR1cm4gKDApOwogICAgLyoKICAgICogU1BFQyAoMi4zLjEpICJEJ3Mge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBtdXN0IG5vdCBiZSB0aGUgt3VyLXR5cGUKICAgICogZGVmaW5pdGlvbrcuIgogICAgKi8KICAgIGlmIChXWFNfSVNfQU5ZVFlQRSh0eXBlLT5iYXNlVHlwZSkpCglyZXR1cm4gKDEpOwoKICAgIGlmIChXWFNfSVNfQ09NUExFWCh0eXBlLT5iYXNlVHlwZSkpIHsKCS8qCgkqIFNQRUMgKDIuMy4yLjEpICJJZiBEJ3Mge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBpcyBjb21wbGV4LCB0aGVuIGl0CgkqIG11c3QgYmUgdmFsaWRseSBkZXJpdmVkIGZyb20gQiBnaXZlbiB0aGUgc3Vic2V0IGFzIGRlZmluZWQgYnkgdGhpcwoJKiBjb25zdHJhaW50LiIKCSovCglyZXR1cm4gKHhtbFNjaGVtYUNoZWNrQ09TQ1REZXJpdmVkT0soYWN0eHQsIHR5cGUtPmJhc2VUeXBlLAoJICAgIGJhc2VUeXBlLCBzZXQpKTsKICAgIH0gZWxzZSB7CgkvKgoJKiBTUEVDICgyLjMuMi4yKSAiSWYgRCdzIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gaXMgc2ltcGxlLCB0aGVuIGl0CgkqIG11c3QgYmUgdmFsaWRseSBkZXJpdmVkIGZyb20gQiBnaXZlbiB0aGUgc3Vic2V0IGFzIGRlZmluZWQgaW4gVHlwZQoJKiBEZXJpdmF0aW9uIE9LIChTaW1wbGUpICinMy4xNC42KS4KCSovCglyZXR1cm4gKHhtbFNjaGVtYUNoZWNrQ09TU1REZXJpdmVkT0soYWN0eHQsIHR5cGUtPmJhc2VUeXBlLAoJICAgIGJhc2VUeXBlLCBzZXQpKTsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrQ09TRGVyaXZlZE9LOgogKiBAdHlwZTogIHRoZSBkZXJpdmVkIHNpbXBsZSB0eXBlIGRlZmluaXRpb24KICogQGJhc2VUeXBlOiAgdGhlIGJhc2UgdHlwZSBkZWZpbml0aW9uCiAqCiAqIENhbGxzOgogKiBUeXBlIERlcml2YXRpb24gT0sgKFNpbXBsZSkgQU5EIFR5cGUgRGVyaXZhdGlvbiBPSyAoQ29tcGxleCkKICoKICogQ2hlY2tzIHdoZXRlciBAdHlwZSBjYW4gYmUgdmFsaWRseSBkZXJpdmVkIGZyb20gQGJhc2VUeXBlLgogKgogKiBSZXR1cm5zIDAgb24gc3VjY2VzcywgYW4gcG9zaXRpdmUgZXJyb3IgY29kZSBvdGhlcndpc2UuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ09TRGVyaXZlZE9LKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkJICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQkgICB4bWxTY2hlbWFUeXBlUHRyIGJhc2VUeXBlLAoJCQkgICBpbnQgc2V0KQp7CiAgICBpZiAoV1hTX0lTX1NJTVBMRSh0eXBlKSkKCXJldHVybiAoeG1sU2NoZW1hQ2hlY2tDT1NTVERlcml2ZWRPSyhhY3R4dCwgdHlwZSwgYmFzZVR5cGUsIHNldCkpOwogICAgZWxzZQoJcmV0dXJuICh4bWxTY2hlbWFDaGVja0NPU0NURGVyaXZlZE9LKGFjdHh0LCB0eXBlLCBiYXNlVHlwZSwgc2V0KSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0NPU0NURXh0ZW5kczoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEB0eXBlOiAgdGhlIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uCiAqCiAqICgzLjQuNikgQ29uc3RyYWludHMgb24gQ29tcGxleCBUeXBlIERlZmluaXRpb24gU2NoZW1hIENvbXBvbmVudHMKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OgogKiBEZXJpdmF0aW9uIFZhbGlkIChFeHRlbnNpb24pIChjb3MtY3QtZXh0ZW5kcykKICoKICogU1RBVFVTOgogKiAgIG1pc3Npbmc6CiAqICAgICAoMS41KQogKiAgICAgKDEuNC4zLjIuMi4yKSAiUGFydGljbGUgVmFsaWQgKEV4dGVuc2lvbikiCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tDT1NDVEV4dGVuZHMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgYmFzZSA9IHR5cGUtPmJhc2VUeXBlOwogICAgLyoKICAgICogVE9ETzogQ29ycmVjdCB0aGUgZXJyb3IgY29kZTsgWE1MX1NDSEVNQVBfQ09TX0NUX0VYVEVORFNfMV8xIGlzIHVzZWQKICAgICogdGVtcG9yYXJpbHkgb25seS4KICAgICovCiAgICAvKgogICAgKiBTUEVDICgxKSAiSWYgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gaXMgYSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiwKICAgICogdGhlbiBhbGwgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6IgogICAgKi8KICAgIGlmIChXWFNfSVNfQ09NUExFWChiYXNlKSkgewkKCS8qCgkqIFNQRUMgKDEuMSkgIlRoZSB7ZmluYWx9IG9mIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259IG11c3Qgbm90CgkqIGNvbnRhaW4gZXh0ZW5zaW9uLiIKCSovCglpZiAoYmFzZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX0VYVEVOU0lPTikgewoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9DT1NfQ1RfRVhURU5EU18xXzEsCgkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkiVGhlICdmaW5hbCcgb2YgdGhlIGJhc2UgdHlwZSBkZWZpbml0aW9uICIKCQkiY29udGFpbnMgJ2V4dGVuc2lvbiciLCBOVUxMKTsKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMSk7Cgl9CgkKCS8qCgkqIEFUVEVOVElPTjogVGhlIGNvbnN0cmFpbnMgKDEuMikgYW5kICgxLjMpIGFyZSBub3QgYXBwbGllZCwKCSogc2luY2UgdGhleSBhcmUgYXV0b21hdGljYWxseSBzYXRpc2ZpZWQgdGhyb3VnaCB0aGUKCSogaW5oZXJpdGluZyBtZWNoYW5pc20uCgkqIE5vdGUgdGhhdCBldmVuIGlmIHJlZGVmaW5pbmcgY29tcG9uZW50cywgdGhlIGluaGVyaXRpbmcgbWVjaGFuaXNtCgkqIGlzIHVzZWQuCgkqLwojaWYgMAoJLyoKCSogU1BFQyAoMS4yKSAiSXRzIHthdHRyaWJ1dGUgdXNlc30gbXVzdCBiZSBhIHN1YnNldCBvZiB0aGUge2F0dHJpYnV0ZQoJKiB1c2VzfQoJKiBvZiB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24gaXRzZWxmLCB0aGF0IGlzLCBmb3IgZXZlcnkgYXR0cmlidXRlCgkqIHVzZSBpbiB0aGUge2F0dHJpYnV0ZSB1c2VzfSBvZiB0aGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSwgdGhlcmUKCSogbXVzdCBiZSBhbiBhdHRyaWJ1dGUgdXNlIGluIHRoZSB7YXR0cmlidXRlIHVzZXN9IG9mIHRoZSBjb21wbGV4CgkqIHR5cGUgZGVmaW5pdGlvbiBpdHNlbGYgd2hvc2Uge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0gaGFzIHRoZSBzYW1lCgkqIHtuYW1lfSwge3RhcmdldCBuYW1lc3BhY2V9IGFuZCB7dHlwZSBkZWZpbml0aW9ufSBhcyBpdHMgYXR0cmlidXRlCgkqIGRlY2xhcmF0aW9uIgoJKi8KCWlmIChiYXNlLT5hdHRyVXNlcyAhPSBOVUxMKSB7CgkgICAgaW50IGksIGosIGZvdW5kOwoJICAgIHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVB0ciB1c2UsIGJ1c2U7CgoJICAgIGZvciAoaSA9IDA7IGkgPCAoV1hTX0xJU1RfQ0FTVCBiYXNlLT5hdHRyVXNlcyktPm5iSXRlbXM7IGkgKyspIHsKCQlidXNlID0gKFdYU19MSVNUX0NBU1QgYmFzZS0+YXR0clVzZXMpLT5pdGVtc1tpXTsKCQlmb3VuZCA9IDA7CgkJaWYgKHR5cGUtPmF0dHJVc2VzICE9IE5VTEwpIHsKCQkgICAgdXNlID0gKFdYU19MSVNUX0NBU1QgdHlwZS0+YXR0clVzZXMpLT5pdGVtc1tqXTsKCQkgICAgZm9yIChqID0gMDsgaiA8IChXWFNfTElTVF9DQVNUIHR5cGUtPmF0dHJVc2VzKS0+bmJJdGVtczsgaiArKykKCQkgICAgewoJCQlpZiAoKFdYU19BVFRSVVNFX0RFQ0xfTkFNRSh1c2UpID09CgkJCQlXWFNfQVRUUlVTRV9ERUNMX05BTUUoYnVzZSkpICYmCgkJCSAgICAoV1hTX0FUVFJVU0VfREVDTF9UTlModXNlKSA9PQoJCQkJV1hTX0FUVFJVU0VfREVDTF9UTlMoYnVzZSkpICYmCgkJCSAgICAoV1hTX0FUVFJVU0VfVFlQRURFRih1c2UpID09CgkJCQlXWFNfQVRUUlVTRV9UWVBFREVGKGJ1c2UpKQoJCQl7CgkJCSAgICBmb3VuZCA9IDE7CgkJCSAgICBicmVhazsKCQkJfQoJCSAgICB9CgkJfQoJCWlmICghIGZvdW5kKSB7CgkJICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgkJCgkJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIGN0eHQsCgkJCVhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMiwKCQkJTlVMTCwgV1hTX0JBU0lDX0NBU1QgdHlwZSwKCQkJLyogCgkJCSogVE9ETzogVGhlIHJlcG9ydCBkb2VzIG5vdCBpbmRpY2F0ZSB0aGF0IGFsc28gdGhlCgkJCSogdHlwZSBuZWVkcyB0byBiZSB0aGUgc2FtZS4KCQkJKi8KCQkJIlRoaXMgdHlwZSBpcyBtaXNzaW5nIGEgbWF0Y2hpbmcgY29ycmVzcG9uZGVudCAiCgkJCSJmb3IgaXRzIHtiYXNlIHR5cGV9J3MgJXMgaW4gaXRzIHthdHRyaWJ1dGUgdXNlc30iLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyLAoJCQkgICAgYnVzZS0+Y2hpbGRyZW4pLAoJCQlOVUxMKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpCgkJfQoJICAgIH0KCX0KCS8qCgkqIFNQRUMgKDEuMykgIklmIGl0IGhhcyBhbiB7YXR0cmlidXRlIHdpbGRjYXJkfSwgdGhlIGNvbXBsZXggdHlwZQoJKiBkZWZpbml0aW9uIG11c3QgYWxzbyBoYXZlIG9uZSwgYW5kIHRoZSBiYXNlIHR5cGUgZGVmaW5pdGlvbidzCgkqIHthdHRyaWJ1dGUgIHdpbGRjYXJkfSdzIHtuYW1lc3BhY2UgY29uc3RyYWludH0gbXVzdCBiZSBhIHN1YnNldAoJKiBvZiB0aGUgY29tcGxleCAgdHlwZSBkZWZpbml0aW9uJ3Mge2F0dHJpYnV0ZSB3aWxkY2FyZH0ncyB7bmFtZXNwYWNlCgkqIGNvbnN0cmFpbnR9LCBhcyBkZWZpbmVkIGJ5IFdpbGRjYXJkIFN1YnNldCAopzMuMTAuNikuIgoJKi8KICAKCS8qCgkqIE1BWUJFIFRPRE86IEVuYWJsZSBpZiBldmVyIG5lZWRlZC4gQnV0IHRoaXMgd2lsbCBiZSBuZWVkZWQgb25seQoJKiBpZiBjcmVhdGVkIHRoZSB0eXBlIHZpYSBhIHNjaGVtYSBjb25zdHJ1Y3Rpb24gQVBJLgoJKi8KCWlmIChiYXNlLT5hdHRyaWJ1dGVXaWxkY2FyZCAhPSBOVUxMKSB7CgkgICAgaWYgKHR5cGUtPmF0dHJpYnV0ZVdpbGNhcmQgPT0gTlVMTCkgewoJCXhtbENoYXIgKnN0ciA9IE5VTEw7CgkJCgkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMywKCQkgICAgTlVMTCwgdHlwZSwKCQkgICAgIlRoZSBiYXNlICVzIGhhcyBhbiBhdHRyaWJ1dGUgd2lsZGNhcmQsICIKCQkgICAgImJ1dCB0aGlzIHR5cGUgaXMgbWlzc2luZyBhbiBhdHRyaWJ1dGUgd2lsZGNhcmQiLAoJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyLCBiYXNlKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgoJICAgIH0gZWxzZSBpZiAoeG1sU2NoZW1hQ2hlY2tDT1NOU1N1YnNldCgKCQliYXNlLT5hdHRyaWJ1dGVXaWxkY2FyZCwgdHlwZS0+YXR0cmlidXRlV2lsZGNhcmQpKQoJICAgIHsKCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoJCQoJCXhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9DT1NfQ1RfRVhURU5EU18xXzMsCgkJICAgIE5VTEwsIHR5cGUsCgkJICAgICJUaGUgYXR0cmlidXRlIHdpbGRjYXJkIGlzIG5vdCBhIHZhbGlkICIKCQkgICAgInN1cGVyc2V0IG9mIHRoZSBvbmUgaW4gdGhlIGJhc2UgJXMiLAoJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyLCBiYXNlKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgkgICAgfQoJfQojZW5kaWYKCS8qCgkqIFNQRUMgKDEuNCkgIk9uZSBvZiB0aGUgZm9sbG93aW5nIG11c3QgYmUgdHJ1ZToiCgkqLwoJaWYgKCh0eXBlLT5jb250ZW50VHlwZURlZiAhPSBOVUxMKSAmJgoJICAgICh0eXBlLT5jb250ZW50VHlwZURlZiA9PSBiYXNlLT5jb250ZW50VHlwZURlZikpIHsKCSAgICAvKgoJICAgICogU1BFQyAoMS40LjEpICJUaGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0KCSAgICAqIGFuZCB0aGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uIGl0c2VsZgoJICAgICogbXVzdCBiZSB0aGUgc2FtZSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIgoJICAgICogUEFTUwoJICAgICovCgl9IGVsc2UgaWYgKCh0eXBlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfRU1QVFkpICYmCgkgICAgKGJhc2UtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWSkgKSB7CgkgICAgLyoKCSAgICAqIFNQRUMgKDEuNC4yKSAiVGhlIHtjb250ZW50IHR5cGV9IG9mIGJvdGggdGhlIHtiYXNlIHR5cGUKCSAgICAqIGRlZmluaXRpb259IGFuZCB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24gaXRzZWxmIG11c3QKCSAgICAqIGJlIGVtcHR5LiIKCSAgICAqIFBBU1MKCSAgICAqLwoJfSBlbHNlIHsKCSAgICAvKgoJICAgICogU1BFQyAoMS40LjMpICJBbGwgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6IgoJICAgICovCgkgICAgaWYgKHR5cGUtPnN1YnR5cGVzID09IE5VTEwpIHsKCQkvKgoJCSogU1BFQyAxLjQuMy4xIFRoZSB7Y29udGVudCB0eXBlfSBvZiB0aGUgY29tcGxleCB0eXBlCgkJKiBkZWZpbml0aW9uIGl0c2VsZiBtdXN0IHNwZWNpZnkgYSBwYXJ0aWNsZS4KCQkqLwoJCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfQ09TX0NUX0VYVEVORFNfMV8xLAoJCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSAgICAiVGhlIGNvbnRlbnQgdHlwZSBtdXN0IHNwZWNpZnkgYSBwYXJ0aWNsZSIsIE5VTEwpOwoJCXJldHVybiAoWE1MX1NDSEVNQVBfQ09TX0NUX0VYVEVORFNfMV8xKTsKCSAgICB9CgkgICAgLyoKCSAgICAqIFNQRUMgKDEuNC4zLjIpICJPbmUgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6IgoJICAgICovCgkgICAgaWYgKGJhc2UtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWSkgewoJCS8qCgkJKiBTUEVDICgxLjQuMy4yLjEpICJUaGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlIHtiYXNlIHR5cGUKCQkqIGRlZmluaXRpb259IG11c3QgYmUgZW1wdHkuCgkJKiBQQVNTCgkJKi8KCSAgICB9IGVsc2UgewoJCS8qCgkJKiBTUEVDICgxLjQuMy4yLjIpICJBbGwgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6IgoJCSovCgkJaWYgKCh0eXBlLT5jb250ZW50VHlwZSAhPSBiYXNlLT5jb250ZW50VHlwZSkgfHwKCQkgICAgKCh0eXBlLT5jb250ZW50VHlwZSAhPSBYTUxfU0NIRU1BX0NPTlRFTlRfTUlYRUQpICYmCgkJICAgICh0eXBlLT5jb250ZW50VHlwZSAhPSBYTUxfU0NIRU1BX0NPTlRFTlRfRUxFTUVOVFMpKSkgewoJCSAgICAvKgoJCSAgICAqIFNQRUMgKDEuNC4zLjIuMi4xKSAiQm90aCB7Y29udGVudCB0eXBlfXMgbXVzdCBiZSBtaXhlZAoJCSAgICAqIG9yIGJvdGggbXVzdCBiZSBlbGVtZW50LW9ubHkuIgoJCSAgICAqLwoJCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJCVhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMSwKCQkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkJIlRoZSBjb250ZW50IHR5cGUgb2YgYm90aCwgdGhlIHR5cGUgYW5kIGl0cyBiYXNlICIKCQkJInR5cGUsIG11c3QgZWl0aGVyICdtaXhlZCcgb3IgJ2VsZW1lbnQtb25seSciLCBOVUxMKTsKCQkgICAgcmV0dXJuIChYTUxfU0NIRU1BUF9DT1NfQ1RfRVhURU5EU18xXzEpOwoJCX0KCQkvKgoJCSogVVJHRU5UIFRPRE8gU1BFQyAoMS40LjMuMi4yLjIpICJUaGUgcGFydGljbGUgb2YgdGhlCgkJKiBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiBtdXN0IGJlIGEgt3ZhbGlkIGV4dGVuc2lvbrcKCQkqIG9mIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259J3MgcGFydGljbGUsIGFzIGRlZmluZWQKCQkqIGluIFBhcnRpY2xlIFZhbGlkIChFeHRlbnNpb24pICinMy45LjYpLiIKCQkqCgkJKiBOT1RFIHRoYXQgd2Ugd29uJ3QgY2hlY2sgIlBhcnRpY2xlIFZhbGlkIChFeHRlbnNpb24pIiwKCQkqIHNpbmNlIGl0IGlzIGVuc3VyZWQgYnkgdGhlIGRlcml2YXRpb24gcHJvY2VzcyBpbgoJCSogeG1sU2NoZW1hVHlwZUZpeHVwKCkuIFdlIG5lZWQgdG8gaW1wbGVtZW50IHRoaXMgd2hlbiBoZWFkaW5nCgkJKiBmb3IgYSBjb25zdHJ1Y3Rpb24gQVBJCgkJKiBUT0RPOiAhISBUaGlzIGlzIG5lZWRlZCB0byBiZSBjaGVja2VkIGlmIHJlZGVmaW5pbmcgYSB0eXBlICEhCgkJKi8KCSAgICB9CgkgICAgLyoKCSAgICAqIFVSR0VOVCBUT0RPICgxLjUpCgkgICAgKi8KCX0KICAgIH0gZWxzZSB7CgkvKgoJKiBTUEVDICgyKSAiSWYgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gaXMgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLAoJKiB0aGVuIGFsbCBvZiB0aGUgZm9sbG93aW5nIG11c3QgYmUgdHJ1ZToiCgkqLwoJaWYgKHR5cGUtPmNvbnRlbnRUeXBlRGVmICE9IGJhc2UpIHsKCSAgICAvKgoJICAgICogU1BFQyAoMi4xKSAiVGhlIHtjb250ZW50IHR5cGV9IG11c3QgYmUgdGhlIHNhbWUgc2ltcGxlIHR5cGUKCSAgICAqIGRlZmluaXRpb24uIgoJICAgICovCgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMSwKCQlXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSJUaGUgY29udGVudCB0eXBlIG11c3QgYmUgdGhlIHNpbXBsZSBiYXNlIHR5cGUiLCBOVUxMKTsKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMSk7Cgl9CglpZiAoYmFzZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX0VYVEVOU0lPTikgewoJICAgIC8qCgkgICAgKiBTUEVDICgyLjIpICJUaGUge2ZpbmFsfSBvZiB0aGUge2Jhc2UgdHlwZSBkZWZpbml0aW9ufSBtdXN0IG5vdAoJICAgICogY29udGFpbiBleHRlbnNpb24iCgkgICAgKiBOT1RFIHRoYXQgdGhpcyBpcyB0aGUgc2FtZSBhcyAoMS4xKS4KCSAgICAqLwoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9DT1NfQ1RfRVhURU5EU18xXzEsCgkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkiVGhlICdmaW5hbCcgb2YgdGhlIGJhc2UgdHlwZSBkZWZpbml0aW9uICIKCQkiY29udGFpbnMgJ2V4dGVuc2lvbiciLCBOVUxMKTsKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFQX0NPU19DVF9FWFRFTkRTXzFfMSk7Cgl9CiAgICB9CiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tEZXJpdmF0aW9uT0tSZXN0cmljdGlvbjoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEB0eXBlOiAgdGhlIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uCiAqCiAqICgzLjQuNikgQ29uc3RyYWludHMgb24gQ29tcGxleCBUeXBlIERlZmluaXRpb24gU2NoZW1hIENvbXBvbmVudHMKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OgogKiBEZXJpdmF0aW9uIFZhbGlkIChSZXN0cmljdGlvbiwgQ29tcGxleCkgKGRlcml2YXRpb24tb2stcmVzdHJpY3Rpb24pCiAqCiAqIFNUQVRVUzoKICogICBtaXNzaW5nOgogKiAgICAgKDUuNC4yKSA/Pz8KICoKICogQVRURU5USU9OOgogKiBJbiBYTUwgU2NoZW1hIDEuMSB0aGlzIHdpbGwgYmU6CiAqIFZhbGlkYXRpb24gUnVsZTogQ2hlY2tpbmcgY29tcGxleCB0eXBlIHN1YnN1bXB0aW9uCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tEZXJpdmF0aW9uT0tSZXN0cmljdGlvbih4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCQkgICAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgYmFzZTsKCiAgICAvKgogICAgKiBUT0RPOiBDb3JyZWN0IHRoZSBlcnJvciBjb2RlOyBYTUxfU0NIRU1BUF9ERVJJVkFUSU9OX09LX1JFU1RSSUNUSU9OXzEgaXMgdXNlZAogICAgKiB0ZW1wb3JhcmlseSBvbmx5LgogICAgKi8KICAgIGJhc2UgPSB0eXBlLT5iYXNlVHlwZTsKICAgIGlmICghIFdYU19JU19DT01QTEVYKGJhc2UpKSB7Cgl4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBjdHh0LAkgICAgCgkgICAgWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl8xLAoJICAgIHR5cGUtPm5vZGUsIFdYU19CQVNJQ19DQVNUIHR5cGUsCgkgICAgIlRoZSBiYXNlIHR5cGUgbXVzdCBiZSBhIGNvbXBsZXggdHlwZSIsIE5VTEwsIE5VTEwpOwoJcmV0dXJuKGN0eHQtPmVycik7CiAgICB9CiAgICBpZiAoYmFzZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0ZJTkFMX1JFU1RSSUNUSU9OKSB7CgkvKgoJKiBTUEVDICgxKSAiVGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gbXVzdCBiZSBhIGNvbXBsZXggdHlwZQoJKiBkZWZpbml0aW9uIHdob3NlIHtmaW5hbH0gZG9lcyBub3QgY29udGFpbiByZXN0cmljdGlvbi4iCgkqLwoJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgY3R4dCwJICAgIAoJICAgIFhNTF9TQ0hFTUFQX0RFUklWQVRJT05fT0tfUkVTVFJJQ1RJT05fMSwKCSAgICB0eXBlLT5ub2RlLCBXWFNfQkFTSUNfQ0FTVCB0eXBlLAoJICAgICJUaGUgJ2ZpbmFsJyBvZiB0aGUgYmFzZSB0eXBlIGRlZmluaXRpb24gIgoJICAgICJjb250YWlucyAncmVzdHJpY3Rpb24nIiwgTlVMTCwgTlVMTCk7CglyZXR1cm4gKGN0eHQtPmVycik7CiAgICB9CiAgICAvKgogICAgKiBTUEVDICgyKSwgKDMpIGFuZCAoNCkKICAgICogVGhvc2UgYXJlIGhhbmRsZWQgaW4gYSBzZXBhcmF0ZSBmdW5jdGlvbiwgc2luY2UgdGhlCiAgICAqIHNhbWUgY29uc3RyYWludHMgYXJlIG5lZWRlZCBmb3IgcmVkZWZpbml0aW9uIG9mCiAgICAqIGF0dHJpYnV0ZSBncm91cHMgYXMgd2VsbC4KICAgICovCiAgICBpZiAoeG1sU2NoZW1hQ2hlY2tEZXJpdmF0aW9uT0tSZXN0cmljdGlvbjJ0bzQoY3R4dCwKCVhNTF9TQ0hFTUFfQUNUSU9OX0RFUklWRSwKCVdYU19CQVNJQ19DQVNUIHR5cGUsIFdYU19CQVNJQ19DQVNUIGJhc2UsCgl0eXBlLT5hdHRyVXNlcywgYmFzZS0+YXR0clVzZXMsCgl0eXBlLT5hdHRyaWJ1dGVXaWxkY2FyZCwKCWJhc2UtPmF0dHJpYnV0ZVdpbGRjYXJkKSA9PSAtMSkKICAgIHsKCXJldHVybigtMSk7CiAgICB9CiAgICAvKgogICAgKiBTUEVDICg1KSAiT25lIG9mIHRoZSBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlOiIKICAgICovCiAgICBpZiAoYmFzZS0+YnVpbHRJblR5cGUgPT0gWE1MX1NDSEVNQVNfQU5ZVFlQRSkgewoJLyoKCSogU1BFQyAoNS4xKSAiVGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gbXVzdCBiZSB0aGUKCSogt3VyLXR5cGUgZGVmaW5pdGlvbrcuIgoJKiBQQVNTCgkqLwogICAgfSBlbHNlIGlmICgodHlwZS0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRSkgfHwKCSAgICAodHlwZS0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX0JBU0lDKSkgewoJLyoKCSogU1BFQyAoNS4yLjEpICJUaGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlIGNvbXBsZXggdHlwZSBkZWZpbml0aW9uCgkqIG11c3QgYmUgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIgoJKgoJKiBTUEVDICg1LjIuMikgIk9uZSBvZiB0aGUgZm9sbG93aW5nIG11c3QgYmUgdHJ1ZToiCgkqLwoJaWYgKChiYXNlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfU0lNUExFKSB8fAoJICAgIChiYXNlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfQkFTSUMpKQoJewoJICAgIGludCBlcnI7CgkgICAgLyoKCSAgICAqIFNQRUMgKDUuMi4yLjEpICJUaGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlIHtiYXNlIHR5cGUKCSAgICAqIGRlZmluaXRpb259IG11c3QgYmUgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIGZyb20gd2hpY2gKCSAgICAqIHRoZSB7Y29udGVudCB0eXBlfSBpcyB2YWxpZGx5IGRlcml2ZWQgZ2l2ZW4gdGhlIGVtcHR5CgkgICAgKiBzZXQgYXMgZGVmaW5lZCBpbiBUeXBlIERlcml2YXRpb24gT0sgKFNpbXBsZSkgKKczLjE0LjYpLiIKCSAgICAqCgkgICAgKiBBVFRFTlRJT04gVE9ETzogVGhpcyBzZWVtcyBub3QgbmVlZGVkIGlmIHRoZSB0eXBlIGltcGxpY2l0ZWx5CgkgICAgKiBkZXJpdmVkIGZyb20gdGhlIGJhc2UgdHlwZS4KCSAgICAqIAoJICAgICovCgkgICAgZXJyID0geG1sU2NoZW1hQ2hlY2tDT1NTVERlcml2ZWRPSyhBQ1RYVF9DQVNUIGN0eHQsCgkJdHlwZS0+Y29udGVudFR5cGVEZWYsIGJhc2UtPmNvbnRlbnRUeXBlRGVmLCAwKTsKCSAgICBpZiAoZXJyICE9IDApIHsKCQl4bWxDaGFyICpzdHJBID0gTlVMTCwgKnN0ckIgPSBOVUxMOwoKCQlpZiAoZXJyID09IC0xKQoJCSAgICByZXR1cm4oLTEpOwoJCXhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX0RFUklWQVRJT05fT0tfUkVTVFJJQ1RJT05fMSwKCQkgICAgTlVMTCwgV1hTX0JBU0lDX0NBU1QgdHlwZSwKCQkgICAgIlRoZSB7Y29udGVudCB0eXBlfSAlcyBpcyBub3QgdmFsaWRseSBkZXJpdmVkIGZyb20gdGhlICIKCQkgICAgImJhc2UgdHlwZSdzIHtjb250ZW50IHR5cGV9ICVzIiwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ckEsCgkJCXR5cGUtPmNvbnRlbnRUeXBlRGVmKSwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ckIsCgkJCWJhc2UtPmNvbnRlbnRUeXBlRGVmKSk7CgkJRlJFRV9BTkRfTlVMTChzdHJBKTsKCQlGUkVFX0FORF9OVUxMKHN0ckIpOwoJCXJldHVybihjdHh0LT5lcnIpOwoJICAgIH0KCX0gZWxzZSBpZiAoKGJhc2UtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9NSVhFRCkgJiYKCSAgICAoeG1sU2NoZW1hSXNQYXJ0aWNsZUVtcHRpYWJsZSgKCQkoeG1sU2NoZW1hUGFydGljbGVQdHIpIGJhc2UtPnN1YnR5cGVzKSkpIHsKCSAgICAvKgoJICAgICogU1BFQyAoNS4yLjIuMikgIlRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259IG11c3QgYmUgbWl4ZWQKCSAgICAqIGFuZCBoYXZlIGEgcGFydGljbGUgd2hpY2ggaXMgt2VtcHRpYWJsZbcgYXMgZGVmaW5lZCBpbgoJICAgICogUGFydGljbGUgRW1wdGlhYmxlICinMy45LjYpLiIKCSAgICAqIFBBU1MKCSAgICAqLwoJfSBlbHNlIHsKCSAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl8xLAoJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJIlRoZSBjb250ZW50IHR5cGUgb2YgdGhlIGJhc2UgdHlwZSBtdXN0IGJlIGVpdGhlciAiCgkJImEgc2ltcGxlIHR5cGUgb3IgJ21peGVkJyBhbmQgYW4gZW1wdGlhYmxlIHBhcnRpY2xlIiwgTlVMTCk7CgkgICAgcmV0dXJuIChjdHh0LT5lcnIpOwoJfQogICAgfSBlbHNlIGlmICh0eXBlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfRU1QVFkpIHsKCS8qCgkqIFNQRUMgKDUuMy4xKSAiVGhlIHtjb250ZW50IHR5cGV9IG9mIHRoZSBjb21wbGV4IHR5cGUgaXRzZWxmIG11c3QKCSogYmUgZW1wdHkiCgkqLwoJaWYgKGJhc2UtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWSkgewoJICAgIC8qCgkgICAgKiBTUEVDICg1LjMuMi4xKSAiVGhlIHtjb250ZW50IHR5cGV9IG9mIHRoZSB7YmFzZSB0eXBlCgkgICAgKiBkZWZpbml0aW9ufSBtdXN0IGFsc28gYmUgZW1wdHkuIgoJICAgICogUEFTUwoJICAgICovCgl9IGVsc2UgaWYgKCgoYmFzZS0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX0VMRU1FTlRTKSB8fAoJICAgIChiYXNlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfTUlYRUQpKSAmJgoJICAgIHhtbFNjaGVtYUlzUGFydGljbGVFbXB0aWFibGUoCgkJKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSBiYXNlLT5zdWJ0eXBlcykpIHsKCSAgICAvKgoJICAgICogU1BFQyAoNS4zLjIuMikgIlRoZSB7Y29udGVudCB0eXBlfSBvZiB0aGUge2Jhc2UgdHlwZQoJICAgICogZGVmaW5pdGlvbn0gbXVzdCBiZSBlbGVtZW50T25seSBvciBtaXhlZCBhbmQgaGF2ZSBhIHBhcnRpY2xlCgkgICAgKiB3aGljaCBpcyC3ZW1wdGlhYmxltyBhcyBkZWZpbmVkIGluIFBhcnRpY2xlIEVtcHRpYWJsZSAopzMuOS42KS4iCgkgICAgKiBQQVNTCgkgICAgKi8KCX0gZWxzZSB7CgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX0RFUklWQVRJT05fT0tfUkVTVFJJQ1RJT05fMSwKCQlXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSJUaGUgY29udGVudCB0eXBlIG9mIHRoZSBiYXNlIHR5cGUgbXVzdCBiZSBlaXRoZXIgIgoJCSJlbXB0eSBvciAnbWl4ZWQnIChvciAnZWxlbWVudHMtb25seScpIGFuZCBhbiBlbXB0aWFibGUgIgoJCSJwYXJ0aWNsZSIsIE5VTEwpOwoJICAgIHJldHVybiAoY3R4dC0+ZXJyKTsKCX0KICAgIH0gZWxzZSBpZiAoKHR5cGUtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTEVNRU5UUykgfHwKCVdYU19IQVNfTUlYRURfQ09OVEVOVCh0eXBlKSkgewoJLyoKCSogU1BFQyAoNS40LjEuMSkgIlRoZSB7Y29udGVudCB0eXBlfSBvZiB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24KCSogaXRzZWxmIG11c3QgYmUgZWxlbWVudC1vbmx5IgoJKi8JIAoJaWYgKFdYU19IQVNfTUlYRURfQ09OVEVOVCh0eXBlKSAmJiAoISBXWFNfSEFTX01JWEVEX0NPTlRFTlQoYmFzZSkpKSB7CgkgICAgLyoKCSAgICAqIFNQRUMgKDUuNC4xLjIpICJUaGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlIGNvbXBsZXggdHlwZQoJICAgICogZGVmaW5pdGlvbiBpdHNlbGYgYW5kIG9mIHRoZSB7YmFzZSB0eXBlIGRlZmluaXRpb259IG11c3QgYmUKCSAgICAqIG1peGVkIgoJICAgICovCgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX0RFUklWQVRJT05fT0tfUkVTVFJJQ1RJT05fMSwKCQlXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSJJZiB0aGUgY29udGVudCB0eXBlIGlzICdtaXhlZCcsIHRoZW4gdGhlIGNvbnRlbnQgdHlwZSBvZiB0aGUgIgoJCSJiYXNlIHR5cGUgbXVzdCBhbHNvIGJlICdtaXhlZCciLCBOVUxMKTsKCSAgICByZXR1cm4gKGN0eHQtPmVycik7Cgl9CgkvKgoJKiBTUEVDICg1LjQuMikgIlRoZSBwYXJ0aWNsZSBvZiB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24gaXRzZWxmCgkqIG11c3QgYmUgYSC3dmFsaWQgcmVzdHJpY3Rpb263IG9mIHRoZSBwYXJ0aWNsZSBvZiB0aGUge2NvbnRlbnQKCSogdHlwZX0gb2YgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0gYXMgZGVmaW5lZCBpbiBQYXJ0aWNsZSBWYWxpZAoJKiAoUmVzdHJpY3Rpb24pICinMy45LjYpLgoJKgoJKiBVUkdFTlQgVE9ETzogKDUuNC4yKQoJKi8KICAgIH0gZWxzZSB7Cgl4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfREVSSVZBVElPTl9PS19SRVNUUklDVElPTl8xLAoJICAgIFdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkgICAgIlRoZSB0eXBlIGlzIG5vdCBhIHZhbGlkIHJlc3RyaWN0aW9uIG9mIGl0cyBiYXNlIHR5cGUiLCBOVUxMKTsKCXJldHVybiAoY3R4dC0+ZXJyKTsKICAgIH0KICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0NUQ29tcG9uZW50OgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHR5cGU6ICB0aGUgY29tcGxleCB0eXBlIGRlZmluaXRpb24KICoKICogKDMuNC42KSBDb25zdHJhaW50cyBvbiBDb21wbGV4IFR5cGUgRGVmaW5pdGlvbiBTY2hlbWEgQ29tcG9uZW50cwogKgogKiBSZXR1cm5zIDAgaWYgdGhlIGNvbnN0cmFpbnRzIGFyZSBzYXRpc2ZpZWQsIGEgcG9zaXRpdmUKICogZXJyb3IgY29kZSBpZiBub3QgYW5kIC0xIGlmIGFuIGludGVybmFsIGVycm9yIG9jY3VyZWQuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ1RDb21wb25lbnQoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgaW50IHJldDsKICAgIC8qCiAgICAqIENvbXBsZXggVHlwZSBEZWZpbml0aW9uIFByb3BlcnRpZXMgQ29ycmVjdAogICAgKi8KICAgIHJldCA9IHhtbFNjaGVtYUNoZWNrQ1RQcm9wc0NvcnJlY3QoY3R4dCwgdHlwZSk7CiAgICBpZiAocmV0ICE9IDApCglyZXR1cm4gKHJldCk7CiAgICBpZiAoV1hTX0lTX0VYVEVOU0lPTih0eXBlKSkKCXJldCA9IHhtbFNjaGVtYUNoZWNrQ09TQ1RFeHRlbmRzKGN0eHQsIHR5cGUpOwogICAgZWxzZQoJcmV0ID0geG1sU2NoZW1hQ2hlY2tEZXJpdmF0aW9uT0tSZXN0cmljdGlvbihjdHh0LCB0eXBlKTsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrU1JDQ1Q6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKgogKiAoMy40LjMpIENvbnN0cmFpbnRzIG9uIFhNTCBSZXByZXNlbnRhdGlvbnMgb2YgQ29tcGxleCBUeXBlIERlZmluaXRpb25zOgogKiBTY2hlbWEgUmVwcmVzZW50YXRpb24gQ29uc3RyYWludDoKICogQ29tcGxleCBUeXBlIERlZmluaXRpb24gUmVwcmVzZW50YXRpb24gT0sgKHNyYy1jdCkKICoKICogUmV0dXJucyAwIGlmIHRoZSBjb25zdHJhaW50cyBhcmUgc2F0aXNmaWVkLCBhIHBvc2l0aXZlCiAqIGVycm9yIGNvZGUgaWYgbm90IGFuZCAtMSBpZiBhbiBpbnRlcm5hbCBlcnJvciBvY2N1cmVkLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFDaGVja1NSQ0NUKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICB4bWxTY2hlbWFUeXBlUHRyIGJhc2U7CiAgICBpbnQgcmV0ID0gMDsKCiAgICAvKgogICAgKiBUT0RPOiBBZGp1c3QgdGhlIGVycm9yIGNvZGVzIGhlcmUsIGFzIEkgdXNlZAogICAgKiBYTUxfU0NIRU1BUF9TUkNfQ1RfMSBvbmx5IHlldC4KICAgICovCiAgICBiYXNlID0gdHlwZS0+YmFzZVR5cGU7CiAgICBpZiAoISBXWFNfSEFTX1NJTVBMRV9DT05URU5UKHR5cGUpKSB7CgkvKgoJKiAxIElmIHRoZSA8Y29tcGxleENvbnRlbnQ+IGFsdGVybmF0aXZlIGlzIGNob3NlbiwgdGhlIHR5cGUgZGVmaW5pdGlvbgoJKiC3cmVzb2x2ZWS3IHRvIGJ5IHRoZSC3YWN0dWFsIHZhbHVltyBvZiB0aGUgYmFzZSBbYXR0cmlidXRlXQoJKiBtdXN0IGJlIGEgY29tcGxleCB0eXBlIGRlZmluaXRpb247CgkqLwoJaWYgKCEgV1hTX0lTX0NPTVBMRVgoYmFzZSkpIHsKCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9TUkNfQ1RfMSwKCQlXWFNfQkFTSUNfQ0FTVCB0eXBlLCB0eXBlLT5ub2RlLAoJCSJJZiB1c2luZyA8Y29tcGxleENvbnRlbnQ+LCB0aGUgYmFzZSB0eXBlIGlzIGV4cGVjdGVkIHRvIGJlICIKCQkiYSBjb21wbGV4IHR5cGUuIFRoZSBiYXNlIHR5cGUgJyVzJyBpcyBhIHNpbXBsZSB0eXBlIiwKCQl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLCBiYXNlLT50YXJnZXROYW1lc3BhY2UsCgkJYmFzZS0+bmFtZSkpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKQoJICAgIHJldHVybiAoWE1MX1NDSEVNQVBfU1JDX0NUXzEpOwoJfQogICAgfSBlbHNlIHsKCS8qCgkqIFNQRUMKCSogMiBJZiB0aGUgPHNpbXBsZUNvbnRlbnQ+IGFsdGVybmF0aXZlIGlzIGNob3NlbiwgYWxsIG9mIHRoZQoJKiBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlOgoJKiAyLjEgVGhlIHR5cGUgZGVmaW5pdGlvbiC3cmVzb2x2ZWS3IHRvIGJ5IHRoZSC3YWN0dWFsIHZhbHVltyBvZiB0aGUKCSogYmFzZSBbYXR0cmlidXRlXSBtdXN0IGJlIG9uZSBvZiB0aGUgZm9sbG93aW5nOgoJKi8KCWlmIChXWFNfSVNfU0lNUExFKGJhc2UpKSB7CgkgICAgaWYgKFdYU19JU19FWFRFTlNJT04odHlwZSkgPT0gMCkgewoJCXhtbENoYXIgKnN0ciA9IE5VTEw7CgkJLyoKCQkqIDIuMS4zIG9ubHkgaWYgdGhlIDxleHRlbnNpb24+IGFsdGVybmF0aXZlIGlzIGFsc28KCQkqIGNob3NlbiwgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLgoJCSovCgkJLyogVE9ETzogQ2hhbmdlIGVycm9yIGNvZGUgdG8gLi4uX1NSQ19DVF8yXzFfMy4gKi8KCQl4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1NSQ19DVF8xLAoJCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSAgICAiSWYgdXNpbmcgPHNpbXBsZUNvbnRlbnQ+IGFuZCA8cmVzdHJpY3Rpb24+LCB0aGUgYmFzZSAiCgkJICAgICJ0eXBlIG11c3QgYmUgYSBjb21wbGV4IHR5cGUuIFRoZSBiYXNlIHR5cGUgJyVzJyBpcyAiCgkJICAgICJhIHNpbXBsZSB0eXBlIiwKCQkgICAgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwgYmFzZS0+dGFyZ2V0TmFtZXNwYWNlLAoJCQliYXNlLT5uYW1lKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgkJcmV0dXJuIChYTUxfU0NIRU1BUF9TUkNfQ1RfMSk7CgkgICAgfQoJfSBlbHNlIHsKCSAgICAvKiBCYXNlIHR5cGUgaXMgYSBjb21wbGV4IHR5cGUuICovCgkgICAgaWYgKChiYXNlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfU0lNUExFKSB8fAoJCShiYXNlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfQkFTSUMpKSB7CgkJLyoKCQkqIDIuMS4xIGEgY29tcGxleCB0eXBlIGRlZmluaXRpb24gd2hvc2Uge2NvbnRlbnQgdHlwZX0gaXMgYQoJCSogc2ltcGxlIHR5cGUgZGVmaW5pdGlvbjsKCQkqIFBBU1MKCQkqLwoJCWlmIChiYXNlLT5jb250ZW50VHlwZURlZiA9PSBOVUxMKSB7CgkJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwgWE1MX1NDSEVNQVBfSU5URVJOQUwsCgkJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJCSJJbnRlcm5hbCBlcnJvcjogeG1sU2NoZW1hQ2hlY2tTUkNDVCwgIgoJCQkiJyVzJywgYmFzZSB0eXBlIGhhcyBubyBjb250ZW50IHR5cGUiLAoJCQl0eXBlLT5uYW1lKTsKCQkgICAgcmV0dXJuICgtMSk7CgkJfQoJICAgIH0gZWxzZSBpZiAoKGJhc2UtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9NSVhFRCkgJiYKCQkoV1hTX0lTX1JFU1RSSUNUSU9OKHR5cGUpKSkgewoKCQkvKgoJCSogMi4xLjIgb25seSBpZiB0aGUgPHJlc3RyaWN0aW9uPiBhbHRlcm5hdGl2ZSBpcyBhbHNvCgkJKiBjaG9zZW4sIGEgY29tcGxleCB0eXBlIGRlZmluaXRpb24gd2hvc2Uge2NvbnRlbnQgdHlwZX0KCQkqIGlzIG1peGVkIGFuZCBhIHBhcnRpY2xlIGVtcHRpYWJsZS4KCQkqLwoJCWlmICghIHhtbFNjaGVtYUlzUGFydGljbGVFbXB0aWFibGUoCgkJICAgICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgYmFzZS0+c3VidHlwZXMpKSB7CgkJICAgIHJldCA9IFhNTF9TQ0hFTUFQX1NSQ19DVF8xOwoJCX0gZWxzZSAKCQkgICAgLyoKCQkgICAgKiBBdHRlbnRpb246IGF0IHRoaXMgcG9pbnQgdGhlIDxzaW1wbGVUeXBlPiBjaGlsZCBpcyBpbgoJCSAgICAqIC0+Y29udGVudFR5cGVEZWYgKHB1dCB0aGVyZSBkdXJpbmcgcGFyc2luZykuCgkJICAgICovCQkgICAgCgkJICAgIGlmICh0eXBlLT5jb250ZW50VHlwZURlZiA9PSBOVUxMKSB7CgkJICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgkJICAgIC8qCgkJICAgICogMi4yIElmIGNsYXVzZSAyLjEuMiBhYm92ZSBpcyBzYXRpc2ZpZWQsIHRoZW4gdGhlcmUKCQkgICAgKiBtdXN0IGJlIGEgPHNpbXBsZVR5cGU+IGFtb25nIHRoZSBbY2hpbGRyZW5dIG9mCgkJICAgICogPHJlc3RyaWN0aW9uPi4KCQkgICAgKi8KCQkgICAgLyogVE9ETzogQ2hhbmdlIGVycm9yIGNvZGUgdG8gLi4uX1NSQ19DVF8yXzIuICovCgkJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQkJWE1MX1NDSEVNQVBfU1JDX0NUXzEsCgkJCVdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJCSJBIDxzaW1wbGVUeXBlPiBpcyBleHBlY3RlZCBhbW9uZyB0aGUgY2hpbGRyZW4gIgoJCQkib2YgPHJlc3RyaWN0aW9uPiwgaWYgPHNpbXBsZUNvbnRlbnQ+IGlzIHVzZWQgYW5kICIKCQkJInRoZSBiYXNlIHR5cGUgJyVzJyBpcyBhIGNvbXBsZXggdHlwZSIsCgkJCXhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIGJhc2UtPnRhcmdldE5hbWVzcGFjZSwKCQkJYmFzZS0+bmFtZSkpOwoJCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCQkgICAgcmV0dXJuIChYTUxfU0NIRU1BUF9TUkNfQ1RfMSk7CgkJfQoJICAgIH0gZWxzZSB7CgkJcmV0ID0gWE1MX1NDSEVNQVBfU1JDX0NUXzE7CgkgICAgfQoJfQoJaWYgKHJldCA+IDApIHsKCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJICAgIGlmIChXWFNfSVNfUkVTVFJJQ1RJT04odHlwZSkpIHsKCQl4bWxTY2hlbWFQQ3VzdG9tRXJyKGN0eHQsCgkJICAgIFhNTF9TQ0hFTUFQX1NSQ19DVF8xLAoJCSAgICBXWFNfQkFTSUNfQ0FTVCB0eXBlLCBOVUxMLAoJCSAgICAiSWYgPHNpbXBsZUNvbnRlbnQ+IGFuZCA8cmVzdHJpY3Rpb24+IGlzIHVzZWQsIHRoZSAiCgkJICAgICJiYXNlIHR5cGUgbXVzdCBiZSBhIHNpbXBsZSB0eXBlIG9yIGEgY29tcGxleCB0eXBlIHdpdGggIgoJCSAgICAibWl4ZWQgY29udGVudCBhbmQgcGFydGljbGUgZW1wdGlhYmxlLiBUaGUgYmFzZSB0eXBlICIKCQkgICAgIiclcycgaXMgbm9uZSBvZiB0aG9zZSIsCgkJICAgIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIGJhc2UtPnRhcmdldE5hbWVzcGFjZSwKCQkgICAgYmFzZS0+bmFtZSkpOwoJICAgIH0gZWxzZSB7CgkJeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9TUkNfQ1RfMSwKCQkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkgICAgIklmIDxzaW1wbGVDb250ZW50PiBhbmQgPGV4dGVuc2lvbj4gaXMgdXNlZCwgdGhlICIKCQkgICAgImJhc2UgdHlwZSBtdXN0IGJlIGEgc2ltcGxlIHR5cGUuIFRoZSBiYXNlIHR5cGUgJyVzJyAiCgkJICAgICJpcyBhIGNvbXBsZXggdHlwZSIsCgkJICAgIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIGJhc2UtPnRhcmdldE5hbWVzcGFjZSwKCQkgICAgYmFzZS0+bmFtZSkpOwoJICAgIH0KCSAgICBGUkVFX0FORF9OVUxMKHN0cikKCX0KICAgIH0KICAgIC8qCiAgICAqIFNQRUMgKDMpICJUaGUgY29ycmVzcG9uZGluZyBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiBjb21wb25lbnQgbXVzdAogICAgKiBzYXRpc2Z5IHRoZSBjb25kaXRpb25zIHNldCBvdXQgaW4gQ29uc3RyYWludHMgb24gQ29tcGxleCBUeXBlCiAgICAqIERlZmluaXRpb24gU2NoZW1hIENvbXBvbmVudHMgKKczLjQuNik7IgogICAgKiBOT1RFICgzKSB3aWxsIGJlIGRvbmUgaW4geG1sU2NoZW1hVHlwZUZpeHVwKCkuCiAgICAqLwogICAgLyoKICAgICogU1BFQyAoNCkgSWYgY2xhdXNlIDIuMi4xIG9yIGNsYXVzZSAyLjIuMiBpbiB0aGUgY29ycmVzcG9uZGVuY2Ugc3BlY2lmaWNhdGlvbgogICAgKiBhYm92ZSBmb3Ige2F0dHJpYnV0ZSB3aWxkY2FyZH0gaXMgc2F0aXNmaWVkLCB0aGUgaW50ZW5zaW9uYWwKICAgICogaW50ZXJzZWN0aW9uIG11c3QgYmUgZXhwcmVzc2libGUsIGFzIGRlZmluZWQgaW4gQXR0cmlidXRlIFdpbGRjYXJkCiAgICAqIEludGVyc2VjdGlvbiAopzMuMTAuNikuCiAgICAqIE5PVEUgKDQpIGlzIGRvbmUgaW4geG1sU2NoZW1hRml4dXBUeXBlQXR0cmlidXRlVXNlcygpLgogICAgKi8KICAgIHJldHVybiAocmV0KTsKfQoKI2lmZGVmIEVOQUJMRV9QQVJUSUNMRV9SRVNUUklDVElPTgovKioKICogeG1sU2NoZW1hQ2hlY2tQYXJ0aWNsZVJhbmdlT0s6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKgogKiAoMy45LjYpIENvbnN0cmFpbnRzIG9uIFBhcnRpY2xlIFNjaGVtYSBDb21wb25lbnRzCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogT2NjdXJyZW5jZSBSYW5nZSBPSyAocmFuZ2Utb2spCiAqCiAqIFNUQVRVUzogY29tcGxldGUKICoKICogUmV0dXJucyAwIGlmIHRoZSBjb25zdHJhaW50cyBhcmUgc2F0aXNmaWVkLCBhIHBvc2l0aXZlCiAqIGVycm9yIGNvZGUgaWYgbm90IGFuZCAtMSBpZiBhbiBpbnRlcm5hbCBlcnJvciBvY2N1cmVkLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFDaGVja1BhcnRpY2xlUmFuZ2VPSyhpbnQgcm1pbiwgaW50IHJtYXgsCgkJCSAgICAgIGludCBibWluLCBpbnQgYm1heCkKewogICAgaWYgKHJtaW4gPCBibWluKQoJcmV0dXJuICgxKTsKICAgIGlmICgoYm1heCAhPSBVTkJPVU5ERUQpICYmCgkocm1heCA+IGJtYXgpKQoJcmV0dXJuICgxKTsKICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja1JDYXNlTmFtZUFuZFR5cGVPSzoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEByOiB0aGUgcmVzdHJpY3RpbmcgZWxlbWVudCBkZWNsYXJhdGlvbiBwYXJ0aWNsZQogKiBAYjogdGhlIGJhc2UgZWxlbWVudCBkZWNsYXJhdGlvbiBwYXJ0aWNsZQogKgogKiAoMy45LjYpIENvbnN0cmFpbnRzIG9uIFBhcnRpY2xlIFNjaGVtYSBDb21wb25lbnRzCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogUGFydGljbGUgUmVzdHJpY3Rpb24gT0sgKEVsdDpFbHQgLS0gTmFtZUFuZFR5cGVPSykKICogKHJjYXNlLU5hbWVBbmRUeXBlT0spCiAqCiAqIFNUQVRVUzoKICogICBNSVNTSU5HICgzLjIuMykKICogICBDTEFSSUZZOiAoMy4yLjIpCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tSQ2FzZU5hbWVBbmRUeXBlT0soeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHIsCgkJCQkgeG1sU2NoZW1hUGFydGljbGVQdHIgYikKewogICAgeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtUiwgZWxlbUI7CgogICAgLyogVE9ETzogRXJyb3IgY29kZXMgKHJjYXNlLU5hbWVBbmRUeXBlT0spLiAqLwogICAgZWxlbVIgPSAoeG1sU2NoZW1hRWxlbWVudFB0cikgci0+Y2hpbGRyZW47CiAgICBlbGVtQiA9ICh4bWxTY2hlbWFFbGVtZW50UHRyKSBiLT5jaGlsZHJlbjsKICAgIC8qCiAgICAqIFNQRUMgKDEpICJUaGUgZGVjbGFyYXRpb25zJyB7bmFtZX1zIGFuZCB7dGFyZ2V0IG5hbWVzcGFjZX1zIGFyZQogICAgKiB0aGUgc2FtZS4iCiAgICAqLwogICAgaWYgKChlbGVtUiAhPSBlbGVtQikgJiYKCSgoISB4bWxTdHJFcXVhbChlbGVtUi0+bmFtZSwgZWxlbUItPm5hbWUpKSB8fAoJKCEgeG1sU3RyRXF1YWwoZWxlbVItPnRhcmdldE5hbWVzcGFjZSwgZWxlbUItPnRhcmdldE5hbWVzcGFjZSkpKSkKCXJldHVybiAoMSk7CiAgICAvKgogICAgKiBTUEVDICgyKSAiUidzIG9jY3VycmVuY2UgcmFuZ2UgaXMgYSB2YWxpZCByZXN0cmljdGlvbiBvZiBCJ3MKICAgICogb2NjdXJyZW5jZSByYW5nZSBhcyBkZWZpbmVkIGJ5IE9jY3VycmVuY2UgUmFuZ2UgT0sgKKczLjkuNikuIgogICAgKi8KICAgIGlmICh4bWxTY2hlbWFDaGVja1BhcnRpY2xlUmFuZ2VPSyhyLT5taW5PY2N1cnMsIHItPm1heE9jY3VycywKCSAgICBiLT5taW5PY2N1cnMsIGItPm1heE9jY3VycykgIT0gMCkKCXJldHVybiAoMSk7CiAgICAvKgogICAgKiBTUEVDICgzLjEpICJCb3RoIEIncyBkZWNsYXJhdGlvbidzIHtzY29wZX0gYW5kIFIncyBkZWNsYXJhdGlvbidzCiAgICAqIHtzY29wZX0gYXJlIGdsb2JhbC4iCiAgICAqLwogICAgaWYgKGVsZW1SID09IGVsZW1CKQoJcmV0dXJuICgwKTsKICAgIC8qCiAgICAqIFNQRUMgKDMuMi4xKSAiRWl0aGVyIEIncyB7bmlsbGFibGV9IGlzIHRydWUgb3IgUidzIHtuaWxsYWJsZX0gaXMgZmFsc2UuIgogICAgKi8KICAgIGlmICgoKGVsZW1CLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fTklMTEFCTEUpID09IDApICYmCgkoZWxlbVItPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9OSUxMQUJMRSkpCgkgcmV0dXJuICgxKTsKICAgIC8qCiAgICAqIFNQRUMgKDMuMi4yKSAiZWl0aGVyIEIncyBkZWNsYXJhdGlvbidzIHt2YWx1ZSBjb25zdHJhaW50fSBpcyBhYnNlbnQsCiAgICAqIG9yIGlzIG5vdCBmaXhlZCwgb3IgUidzIGRlY2xhcmF0aW9uJ3Mge3ZhbHVlIGNvbnN0cmFpbnR9IGlzIGZpeGVkCiAgICAqIHdpdGggdGhlIHNhbWUgdmFsdWUuIgogICAgKi8KICAgIGlmICgoZWxlbUItPnZhbHVlICE9IE5VTEwpICYmIChlbGVtQi0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0ZJWEVEKSAmJgoJKChlbGVtUi0+dmFsdWUgPT0gTlVMTCkgfHwKCSAoKGVsZW1SLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fRklYRUQpID09IDApIHx8CgkgLyogVE9ETzogRXF1YWxpdHkgb2YgdGhlIGluaXRpYWwgdmFsdWUgb3Igbm9ybWFsaXplZCBvciBjYW5vbmljYWw/ICovCgkgKCEgeG1sU3RyRXF1YWwoZWxlbVItPnZhbHVlLCBlbGVtQi0+dmFsdWUpKSkpCgkgcmV0dXJuICgxKTsKICAgIC8qCiAgICAqIFRPRE86IFNQRUMgKDMuMi4zKSAiUidzIGRlY2xhcmF0aW9uJ3Mge2lkZW50aXR5LWNvbnN0cmFpbnQKICAgICogZGVmaW5pdGlvbnN9IGlzIGEgc3Vic2V0IG9mIEIncyBkZWNsYXJhdGlvbidzIHtpZGVudGl0eS1jb25zdHJhaW50CiAgICAqIGRlZmluaXRpb25zfSwgaWYgYW55LiIKICAgICovCiAgICBpZiAoZWxlbUItPmlkY3MgIT0gTlVMTCkgewoJLyogVE9ETyAqLwogICAgfQogICAgLyoKICAgICogU1BFQyAoMy4yLjQpICJSJ3MgZGVjbGFyYXRpb24ncyB7ZGlzYWxsb3dlZCBzdWJzdGl0dXRpb25zfSBpcyBhCiAgICAqIHN1cGVyc2V0IG9mIEIncyBkZWNsYXJhdGlvbidzIHtkaXNhbGxvd2VkIHN1YnN0aXR1dGlvbnN9LiIKICAgICovCiAgICBpZiAoKChlbGVtQi0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0JMT0NLX0VYVEVOU0lPTikgJiYKCSAoKGVsZW1SLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfRVhURU5TSU9OKSA9PSAwKSkgfHwKCSgoZWxlbUItPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9CTE9DS19SRVNUUklDVElPTikgJiYKCSAoKGVsZW1SLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfUkVTVFJJQ1RJT04pID09IDApKSB8fAoJKChlbGVtQi0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0JMT0NLX1NVQlNUSVRVVElPTikgJiYKCSAoKGVsZW1SLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfU1VCU1RJVFVUSU9OKSA9PSAwKSkpCgkgcmV0dXJuICgxKTsKICAgIC8qCiAgICAqIFNQRUMgKDMuMi41KSAiUidzIHt0eXBlIGRlZmluaXRpb259IGlzIHZhbGlkbHkgZGVyaXZlZCBnaXZlbgogICAgKiB7ZXh0ZW5zaW9uLCBsaXN0LCB1bmlvbn0gZnJvbSBCJ3Mge3R5cGUgZGVmaW5pdGlvbn0iCiAgICAqCiAgICAqIEJBRFNQRUMgVE9ETzogV2hhdCdzIHRoZSBwb2ludCBvZiBhZGRpbmcgImxpc3QiIGFuZCAidW5pb24iIHRvIHRoZQogICAgKiBzZXQsIGlmIHRoZSBjb3JyZXNwb25kaW5nIGNvbnN0cmFpbnRzIGhhbmRsZSAicmVzdHJpY3Rpb24iIGFuZAogICAgKiAiZXh0ZW5zaW9uIiBvbmx5PwogICAgKgogICAgKi8KICAgIHsKCWludCBzZXQgPSAwOwoKCXNldCB8PSBTVUJTRVRfRVhURU5TSU9OOwoJc2V0IHw9IFNVQlNFVF9MSVNUOwoJc2V0IHw9IFNVQlNFVF9VTklPTjsKCWlmICh4bWxTY2hlbWFDaGVja0NPU0Rlcml2ZWRPSyhBQ1RYVF9DQVNUIGN0eHQsIGVsZW1SLT5zdWJ0eXBlcywKCSAgICBlbGVtQi0+c3VidHlwZXMsIHNldCkgIT0gMCkKCSAgICByZXR1cm4gKDEpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrUkNhc2VOU0NvbXBhdDoKICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEByOiB0aGUgcmVzdHJpY3RpbmcgZWxlbWVudCBkZWNsYXJhdGlvbiBwYXJ0aWNsZQogKiBAYjogdGhlIGJhc2Ugd2lsZGNhcmQgcGFydGljbGUKICoKICogKDMuOS42KSBDb25zdHJhaW50cyBvbiBQYXJ0aWNsZSBTY2hlbWEgQ29tcG9uZW50cwogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqIFBhcnRpY2xlIERlcml2YXRpb24gT0sgKEVsdDpBbnkgLS0gTlNDb21wYXQpCiAqIChyY2FzZS1OU0NvbXBhdCkKICoKICogU1RBVFVTOiBjb21wbGV0ZQogKgogKiBSZXR1cm5zIDAgaWYgdGhlIGNvbnN0cmFpbnRzIGFyZSBzYXRpc2ZpZWQsIGEgcG9zaXRpdmUKICogZXJyb3IgY29kZSBpZiBub3QgYW5kIC0xIGlmIGFuIGludGVybmFsIGVycm9yIG9jY3VyZWQuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrUkNhc2VOU0NvbXBhdCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSAgICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciByLAoJCQkgICAgeG1sU2NoZW1hUGFydGljbGVQdHIgYikKewogICAgLyogVE9ETzpFcnJvciBjb2RlcyAocmNhc2UtTlNDb21wYXQpLiAqLwogICAgLyoKICAgICogU1BFQyAiRm9yIGFuIGVsZW1lbnQgZGVjbGFyYXRpb24gcGFydGljbGUgdG8gYmUgYSC3dmFsaWQgcmVzdHJpY3Rpb263CiAgICAqIG9mIGEgd2lsZGNhcmQgcGFydGljbGUgYWxsIG9mIHRoZSBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlOiIKICAgICoKICAgICogU1BFQyAoMSkgIlRoZSBlbGVtZW50IGRlY2xhcmF0aW9uJ3Mge3RhcmdldCBuYW1lc3BhY2V9IGlzILd2YWxpZLcKICAgICogd2l0aCByZXNwZWN0IHRvIHRoZSB3aWxkY2FyZCdzIHtuYW1lc3BhY2UgY29uc3RyYWludH0gYXMgZGVmaW5lZCBieQogICAgKiBXaWxkY2FyZCBhbGxvd3MgTmFtZXNwYWNlIE5hbWUgKKczLjEwLjQpLiIKICAgICovCiAgICBpZiAoeG1sU2NoZW1hQ2hlY2tDVkNXaWxkY2FyZE5hbWVzcGFjZSgoeG1sU2NoZW1hV2lsZGNhcmRQdHIpIGItPmNoaWxkcmVuLAoJKCh4bWxTY2hlbWFFbGVtZW50UHRyKSByLT5jaGlsZHJlbiktPnRhcmdldE5hbWVzcGFjZSkgIT0gMCkKCXJldHVybiAoMSk7CiAgICAvKgogICAgKiBTUEVDICgyKSAiUidzIG9jY3VycmVuY2UgcmFuZ2UgaXMgYSB2YWxpZCByZXN0cmljdGlvbiBvZiBCJ3MKICAgICogb2NjdXJyZW5jZSByYW5nZSBhcyBkZWZpbmVkIGJ5IE9jY3VycmVuY2UgUmFuZ2UgT0sgKKczLjkuNikuIgogICAgKi8KICAgIGlmICh4bWxTY2hlbWFDaGVja1BhcnRpY2xlUmFuZ2VPSyhyLT5taW5PY2N1cnMsIHItPm1heE9jY3VycywKCSAgICBiLT5taW5PY2N1cnMsIGItPm1heE9jY3VycykgIT0gMCkKCXJldHVybiAoMSk7CgogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrUkNhc2VSZWN1cnNlQXNJZkdyb3VwOgogKiBAY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHI6IHRoZSByZXN0cmljdGluZyBlbGVtZW50IGRlY2xhcmF0aW9uIHBhcnRpY2xlCiAqIEBiOiB0aGUgYmFzZSBtb2RlbCBncm91cCBwYXJ0aWNsZQogKgogKiAoMy45LjYpIENvbnN0cmFpbnRzIG9uIFBhcnRpY2xlIFNjaGVtYSBDb21wb25lbnRzCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogUGFydGljbGUgRGVyaXZhdGlvbiBPSyAoRWx0OkFsbC9DaG9pY2UvU2VxdWVuY2UgLS0gUmVjdXJzZUFzSWZHcm91cCkKICogKHJjYXNlLVJlY3Vyc2VBc0lmR3JvdXApCiAqCiAqIFNUQVRVUzogVE9ETwogKgogKiBSZXR1cm5zIDAgaWYgdGhlIGNvbnN0cmFpbnRzIGFyZSBzYXRpc2ZpZWQsIGEgcG9zaXRpdmUKICogZXJyb3IgY29kZSBpZiBub3QgYW5kIC0xIGlmIGFuIGludGVybmFsIGVycm9yIG9jY3VyZWQuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrUkNhc2VSZWN1cnNlQXNJZkdyb3VwKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJCSAgICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciByLAoJCQkJICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIGIpCnsKICAgIC8qIFRPRE86IEVycm9yIGNvZGVzIChyY2FzZS1SZWN1cnNlQXNJZkdyb3VwKS4gKi8KICAgIFRPRE8KICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja1JDYXNlTlNTdWJzZXQ6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAcjogdGhlIHJlc3RyaWN0aW5nIHdpbGRjYXJkIHBhcnRpY2xlCiAqIEBiOiB0aGUgYmFzZSB3aWxkY2FyZCBwYXJ0aWNsZQogKgogKiAoMy45LjYpIENvbnN0cmFpbnRzIG9uIFBhcnRpY2xlIFNjaGVtYSBDb21wb25lbnRzCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogUGFydGljbGUgRGVyaXZhdGlvbiBPSyAoQW55OkFueSAtLSBOU1N1YnNldCkKICogKHJjYXNlLU5TU3Vic2V0KQogKgogKiBTVEFUVVM6IGNvbXBsZXRlCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tSQ2FzZU5TU3Vic2V0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJCSAgICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciByLAoJCQkJICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIGIsCgkJCQkgICAgaW50IGlzQW55VHlwZUJhc2UpCnsKICAgIC8qIFRPRE86IEVycm9yIGNvZGVzIChyY2FzZS1OU1N1YnNldCkuICovCiAgICAvKgogICAgKiBTUEVDICgxKSAiUidzIG9jY3VycmVuY2UgcmFuZ2UgaXMgYSB2YWxpZCByZXN0cmljdGlvbiBvZiBCJ3MKICAgICogb2NjdXJyZW5jZSByYW5nZSBhcyBkZWZpbmVkIGJ5IE9jY3VycmVuY2UgUmFuZ2UgT0sgKKczLjkuNikuIgogICAgKi8KICAgIGlmICh4bWxTY2hlbWFDaGVja1BhcnRpY2xlUmFuZ2VPSyhyLT5taW5PY2N1cnMsIHItPm1heE9jY3VycywKCSAgICBiLT5taW5PY2N1cnMsIGItPm1heE9jY3VycykpCglyZXR1cm4gKDEpOwogICAgLyoKICAgICogU1BFQyAoMikgIlIncyB7bmFtZXNwYWNlIGNvbnN0cmFpbnR9IG11c3QgYmUgYW4gaW50ZW5zaW9uYWwgc3Vic2V0CiAgICAqIG9mIEIncyB7bmFtZXNwYWNlIGNvbnN0cmFpbnR9IGFzIGRlZmluZWQgYnkgV2lsZGNhcmQgU3Vic2V0ICinMy4xMC42KS4iCiAgICAqLwogICAgaWYgKHhtbFNjaGVtYUNoZWNrQ09TTlNTdWJzZXQoKHhtbFNjaGVtYVdpbGRjYXJkUHRyKSByLT5jaGlsZHJlbiwKCSh4bWxTY2hlbWFXaWxkY2FyZFB0cikgYi0+Y2hpbGRyZW4pKQoJcmV0dXJuICgxKTsKICAgIC8qCiAgICAqIFNQRUMgKDMpICJVbmxlc3MgQiBpcyB0aGUgY29udGVudCBtb2RlbCB3aWxkY2FyZCBvZiB0aGUgt3VyLXR5cGUKICAgICogZGVmaW5pdGlvbrcsIFIncyB7cHJvY2VzcyBjb250ZW50c30gbXVzdCBiZSBpZGVudGljYWwgdG8gb3Igc3Ryb25nZXIKICAgICogdGhhbiBCJ3Mge3Byb2Nlc3MgY29udGVudHN9LCB3aGVyZSBzdHJpY3QgaXMgc3Ryb25nZXIgdGhhbiBsYXggaXMKICAgICogc3Ryb25nZXIgdGhhbiBza2lwLiIKICAgICovCiAgICBpZiAoISBpc0FueVR5cGVCYXNlKSB7CglpZiAoICgoeG1sU2NoZW1hV2lsZGNhcmRQdHIpIHItPmNoaWxkcmVuKS0+cHJvY2Vzc0NvbnRlbnRzIDwKCSAgICAoKHhtbFNjaGVtYVdpbGRjYXJkUHRyKSBiLT5jaGlsZHJlbiktPnByb2Nlc3NDb250ZW50cykKCSAgICByZXR1cm4gKDEpOwogICAgfQoKICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0NPU1BhcnRpY2xlUmVzdHJpY3Q6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdHlwZTogIHRoZSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbgogKgogKiAoMy45LjYpIENvbnN0cmFpbnRzIG9uIFBhcnRpY2xlIFNjaGVtYSBDb21wb25lbnRzCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogUGFydGljbGUgVmFsaWQgKFJlc3RyaWN0aW9uKSAoY29zLXBhcnRpY2xlLXJlc3RyaWN0KQogKgogKiBTVEFUVVM6IFRPRE8KICoKICogUmV0dXJucyAwIGlmIHRoZSBjb25zdHJhaW50cyBhcmUgc2F0aXNmaWVkLCBhIHBvc2l0aXZlCiAqIGVycm9yIGNvZGUgaWYgbm90IGFuZCAtMSBpZiBhbiBpbnRlcm5hbCBlcnJvciBvY2N1cmVkLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFDaGVja0NPU1BhcnRpY2xlUmVzdHJpY3QoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciByLAoJCQkJICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciBiKQp7CiAgICBpbnQgcmV0ID0gMDsKCiAgICAvKnBhcnQgPSBXWFNfVFlQRV9QQVJUSUNMRSh0eXBlKTsKICAgIGJhc2VQYXJ0ID0gV1hTX1RZUEVfUEFSVElDTEUoYmFzZSk7CiAgICAqLwoKICAgIFRPRE8KCiAgICAvKgogICAgKiBTUEVDICgxKSAiVGhleSBhcmUgdGhlIHNhbWUgcGFydGljbGUuIgogICAgKi8KICAgIGlmIChyID09IGIpCglyZXR1cm4gKDApOwoKCiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tSQ2FzZU5TUmVjdXJzZUNoZWNrQ2FyZGluYWxpdHk6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAcjogdGhlIG1vZGVsIGdyb3VwIHBhcnRpY2xlCiAqIEBiOiB0aGUgYmFzZSB3aWxkY2FyZCBwYXJ0aWNsZQogKgogKiAoMy45LjYpIENvbnN0cmFpbnRzIG9uIFBhcnRpY2xlIFNjaGVtYSBDb21wb25lbnRzCiAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDoKICogUGFydGljbGUgRGVyaXZhdGlvbiBPSyAoQWxsL0Nob2ljZS9TZXF1ZW5jZTpBbnkgLS0KICogICAgICAgICAgICAgICAgICAgICAgICAgTlNSZWN1cnNlQ2hlY2tDYXJkaW5hbGl0eSkKICogKHJjYXNlLU5TUmVjdXJzZUNoZWNrQ2FyZGluYWxpdHkpCiAqCiAqIFNUQVRVUzogVE9ETzogc3Vic3QtZ3JvdXBzCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tSQ2FzZU5TUmVjdXJzZUNoZWNrQ2FyZGluYWxpdHkoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkJCSAgICAgeG1sU2NoZW1hUGFydGljbGVQdHIgciwKCQkJCQkgICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIGIpCnsKICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnQ7CiAgICAvKiBUT0RPOiBFcnJvciBjb2RlcyAocmNhc2UtTlNSZWN1cnNlQ2hlY2tDYXJkaW5hbGl0eSkuICovCiAgICBpZiAoKHItPmNoaWxkcmVuID09IE5VTEwpIHx8IChyLT5jaGlsZHJlbi0+Y2hpbGRyZW4gPT0gTlVMTCkpCglyZXR1cm4gKC0xKTsKICAgIC8qCiAgICAqIFNQRUMgIkZvciBhIGdyb3VwIHBhcnRpY2xlIHRvIGJlIGEgt3ZhbGlkIHJlc3RyaWN0aW9utyBvZiBhCiAgICAqIHdpbGRjYXJkIHBhcnRpY2xlLi4uIgogICAgKgogICAgKiBTUEVDICgxKSAiRXZlcnkgbWVtYmVyIG9mIHRoZSB7cGFydGljbGVzfSBvZiB0aGUgZ3JvdXAgaXMgYSC3dmFsaWQKICAgICogcmVzdHJpY3Rpb263IG9mIHRoZSB3aWxkY2FyZCBhcyBkZWZpbmVkIGJ5CiAgICAqIFBhcnRpY2xlIFZhbGlkIChSZXN0cmljdGlvbikgKKczLjkuNikuIgogICAgKi8KICAgIHBhcnQgPSAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHItPmNoaWxkcmVuLT5jaGlsZHJlbjsKICAgIGRvIHsKCWlmICh4bWxTY2hlbWFDaGVja0NPU1BhcnRpY2xlUmVzdHJpY3QoY3R4dCwgcGFydCwgYikpCgkgICAgcmV0dXJuICgxKTsKCXBhcnQgPSAoeG1sU2NoZW1hUGFydGljbGVQdHIpIHBhcnQtPm5leHQ7CiAgICB9IHdoaWxlIChwYXJ0ICE9IE5VTEwpOwogICAgLyoKICAgICogU1BFQyAoMikgIlRoZSBlZmZlY3RpdmUgdG90YWwgcmFuZ2Ugb2YgdGhlIGdyb3VwIFsuLi5dIGlzIGEKICAgICogdmFsaWQgcmVzdHJpY3Rpb24gb2YgQidzIG9jY3VycmVuY2UgcmFuZ2UgYXMgZGVmaW5lZCBieQogICAgKiBPY2N1cnJlbmNlIFJhbmdlIE9LICinMy45LjYpLiIKICAgICovCiAgICBpZiAoeG1sU2NoZW1hQ2hlY2tQYXJ0aWNsZVJhbmdlT0soCgkgICAgeG1sU2NoZW1hR2V0UGFydGljbGVUb3RhbFJhbmdlTWluKHIpLAoJICAgIHhtbFNjaGVtYUdldFBhcnRpY2xlVG90YWxSYW5nZU1heChyKSwKCSAgICBiLT5taW5PY2N1cnMsIGItPm1heE9jY3VycykgIT0gMCkKCXJldHVybiAoMSk7CiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tSQ2FzZVJlY3Vyc2U6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAcjogdGhlIDxhbGw+IG9yIDxzZXF1ZW5jZT4gbW9kZWwgZ3JvdXAgcGFydGljbGUKICogQGI6IHRoZSBiYXNlIDxhbGw+IG9yIDxzZXF1ZW5jZT4gbW9kZWwgZ3JvdXAgcGFydGljbGUKICoKICogKDMuOS42KSBDb25zdHJhaW50cyBvbiBQYXJ0aWNsZSBTY2hlbWEgQ29tcG9uZW50cwogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqIFBhcnRpY2xlIERlcml2YXRpb24gT0sgKEFsbDpBbGwsU2VxdWVuY2U6U2VxdWVuY2UgLS0KICAgICAgICAgICAgICAgICAgICAgICAgICAgUmVjdXJzZSkKICogKHJjYXNlLVJlY3Vyc2UpCiAqCiAqIFNUQVRVUzogID8KICogVE9ETzogc3Vic3QtZ3JvdXBzCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgY29uc3RyYWludHMgYXJlIHNhdGlzZmllZCwgYSBwb3NpdGl2ZQogKiBlcnJvciBjb2RlIGlmIG5vdCBhbmQgLTEgaWYgYW4gaW50ZXJuYWwgZXJyb3Igb2NjdXJlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tSQ2FzZVJlY3Vyc2UoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciByLAoJCQkgICB4bWxTY2hlbWFQYXJ0aWNsZVB0ciBiKQp7CiAgICAvKiB4bWxTY2hlbWFQYXJ0aWNsZVB0ciBwYXJ0OyAqLwogICAgLyogVE9ETzogRXJyb3IgY29kZXMgKHJjYXNlLVJlY3Vyc2UpLiAqLwogICAgaWYgKChyLT5jaGlsZHJlbiA9PSBOVUxMKSB8fCAoYi0+Y2hpbGRyZW4gPT0gTlVMTCkgfHwKCShyLT5jaGlsZHJlbi0+dHlwZSAhPSBiLT5jaGlsZHJlbi0+dHlwZSkpCglyZXR1cm4gKC0xKTsKICAgIC8qCiAgICAqIFNQRUMgIkZvciBhbiBhbGwgb3Igc2VxdWVuY2UgZ3JvdXAgcGFydGljbGUgdG8gYmUgYSC3dmFsaWQKICAgICogcmVzdHJpY3Rpb263IG9mIGFub3RoZXIgZ3JvdXAgcGFydGljbGUgd2l0aCB0aGUgc2FtZSB7Y29tcG9zaXRvcn0uLi4iCiAgICAqCiAgICAqIFNQRUMgKDEpICJSJ3Mgb2NjdXJyZW5jZSByYW5nZSBpcyBhIHZhbGlkIHJlc3RyaWN0aW9uIG9mIEIncwogICAgKiBvY2N1cnJlbmNlIHJhbmdlIGFzIGRlZmluZWQgYnkgT2NjdXJyZW5jZSBSYW5nZSBPSyAopzMuOS42KS4iCiAgICAqLwogICAgaWYgKHhtbFNjaGVtYUNoZWNrUGFydGljbGVSYW5nZU9LKHItPm1pbk9jY3Vycywgci0+bWF4T2NjdXJzLAoJICAgIGItPm1pbk9jY3VycywgYi0+bWF4T2NjdXJzKSkKCXJldHVybiAoMSk7CgoKICAgIHJldHVybiAoMCk7Cn0KCiNlbmRpZgoKI2RlZmluZSBGQUNFVF9SRVNUUl9NVVRVQUxfRVJSKGZhYzEsIGZhYzIpIFwKICAgIHhtbFNjaGVtYVBDdXN0b21FcnJFeHQocGN0eHQsICAgICAgXAoJWE1MX1NDSEVNQVBfSU5WQUxJRF9GQUNFVF9WQUxVRSwgXAoJV1hTX0JBU0lDX0NBU1QgZmFjMSwgZmFjMS0+bm9kZSwgXAoJIkl0IGlzIGFuIGVycm9yIGZvciBib3RoICclcycgYW5kICclcycgdG8gYmUgc3BlY2lmaWVkIG9uIHRoZSAiXAoJInNhbWUgdHlwZSBkZWZpbml0aW9uIiwgXAoJQkFEX0NBU1QgeG1sU2NoZW1hRmFjZXRUeXBlVG9TdHJpbmcoZmFjMS0+dHlwZSksIFwKCUJBRF9DQVNUIHhtbFNjaGVtYUZhY2V0VHlwZVRvU3RyaW5nKGZhYzItPnR5cGUpLCBOVUxMKTsKCiNkZWZpbmUgRkFDRVRfUkVTVFJfRVJSKGZhYzEsIG1zZykgXAogICAgeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwgICAgICBcCglYTUxfU0NIRU1BUF9JTlZBTElEX0ZBQ0VUX1ZBTFVFLCBcCglXWFNfQkFTSUNfQ0FTVCBmYWMxLCBmYWMxLT5ub2RlLCBcCgltc2csIE5VTEwpOwoKI2RlZmluZSBGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZmFjKSBcCiAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LCBcCglYTUxfU0NIRU1BUF9JTlZBTElEX0ZBQ0VUX1ZBTFVFLCBcCglXWFNfQkFTSUNfQ0FTVCBmYWMsIGZhYy0+bm9kZSwgXAoJIlRoZSBiYXNlIHR5cGUncyBmYWNldCBpcyAnZml4ZWQnLCB0aHVzIHRoZSB2YWx1ZSBtdXN0IG5vdCAiIFwKCSJkaWZmZXIiLCBOVUxMKTsKCnN0YXRpYyB2b2lkCnhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCXhtbFNjaGVtYUZhY2V0UHRyIGZhY2V0MSwKCQkJeG1sU2NoZW1hRmFjZXRQdHIgZmFjZXQyLAoJCQlpbnQgbGVzc0dyZWF0ZXIsCgkJCWludCBvckVxdWFsLAoJCQlpbnQgb2ZCYXNlKQp7CiAgICB4bWxDaGFyICptc2cgPSBOVUxMOwoKICAgIG1zZyA9IHhtbFN0cmR1cChCQURfQ0FTVCAiJyIpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgeG1sU2NoZW1hRmFjZXRUeXBlVG9TdHJpbmcoZmFjZXQxLT50eXBlKSk7CiAgICBtc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiJyBoYXMgdG8gYmUiKTsKICAgIGlmIChsZXNzR3JlYXRlciA9PSAwKQoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIiBlcXVhbCB0byIpOwogICAgaWYgKGxlc3NHcmVhdGVyID09IDEpCgltc2cgPSB4bWxTdHJjYXQobXNnLCBCQURfQ0FTVCAiIGdyZWF0ZXIgdGhhbiIpOwogICAgZWxzZQoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIiBsZXNzIHRoYW4iKTsKCiAgICBpZiAob3JFcXVhbCkKCW1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICIgb3IgZXF1YWwgdG8iKTsKICAgIG1zZyA9IHhtbFN0cmNhdChtc2csIEJBRF9DQVNUICIgJyIpOwogICAgbXNnID0geG1sU3RyY2F0KG1zZywgeG1sU2NoZW1hRmFjZXRUeXBlVG9TdHJpbmcoZmFjZXQyLT50eXBlKSk7CiAgICBpZiAob2ZCYXNlKQoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIicgb2YgdGhlIGJhc2UgdHlwZSIpOwogICAgZWxzZQoJbXNnID0geG1sU3RyY2F0KG1zZywgQkFEX0NBU1QgIiciKTsKCiAgICB4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJWE1MX1NDSEVNQVBfSU5WQUxJRF9GQUNFVF9WQUxVRSwKCVdYU19CQVNJQ19DQVNUIGZhY2V0MSwgTlVMTCwKCShjb25zdCBjaGFyICopIG1zZywgTlVMTCk7CgogICAgaWYgKG1zZyAhPSBOVUxMKQoJeG1sRnJlZShtc2cpOwp9CgovKgoqIHhtbFNjaGVtYURlcml2ZUFuZFZhbGlkYXRlRmFjZXRzOgoqCiogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiBTaW1wbGUgVHlwZSBSZXN0cmljdGlvbiAoRmFjZXRzKQoqIChzdC1yZXN0cmljdC1mYWNldHMpCiovCnN0YXRpYyBpbnQKeG1sU2NoZW1hRGVyaXZlQW5kVmFsaWRhdGVGYWNldHMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJCSB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHhtbFNjaGVtYVR5cGVQdHIgYmFzZSA9IHR5cGUtPmJhc2VUeXBlOwogICAgeG1sU2NoZW1hRmFjZXRMaW5rUHRyIGxpbmssIGN1ciwgbGFzdCA9IE5VTEw7CiAgICB4bWxTY2hlbWFGYWNldFB0ciBmYWNldCwgYmZhY2V0LAoJZmxlbmd0aCA9IE5VTEwsIGZ0b3RkaWcgPSBOVUxMLCBmZnJhY2RpZyA9IE5VTEwsCglmbWF4bGVuID0gTlVMTCwgZm1pbmxlbiA9IE5VTEwsIC8qIGZhY2V0cyBvZiB0aGUgY3VycmVudCB0eXBlICovCglmbWluaW5jID0gTlVMTCwgZm1heGluYyA9IE5VTEwsCglmbWluZXhjID0gTlVMTCwgZm1heGV4YyA9IE5VTEwsCgliZmxlbmd0aCA9IE5VTEwsIGJmdG90ZGlnID0gTlVMTCwgYmZmcmFjZGlnID0gTlVMTCwKCWJmbWF4bGVuID0gTlVMTCwgYmZtaW5sZW4gPSBOVUxMLCAvKiBmYWNldHMgb2YgdGhlIGJhc2UgdHlwZSAqLwoJYmZtaW5pbmMgPSBOVUxMLCBiZm1heGluYyA9IE5VTEwsCgliZm1pbmV4YyA9IE5VTEwsIGJmbWF4ZXhjID0gTlVMTDsKICAgIGludCByZXM7IC8qIGVyciA9IDAsIGZpeGVkRXJyOyAqLwoKICAgIC8qCiAgICAqIFNQRUMgc3QtcmVzdHJpY3QtZmFjZXRzIDE6CiAgICAqICJUaGUge3ZhcmlldHl9IG9mIFIgaXMgdGhlIHNhbWUgYXMgdGhhdCBvZiBCLiIgICAgCiAgICAqLwogICAgLyoKICAgICogU1BFQyBzdC1yZXN0cmljdC1mYWNldHMgMjoKICAgICogIklmIHt2YXJpZXR5fSBpcyBhdG9taWMsIHRoZSB7cHJpbWl0aXZlIHR5cGUgZGVmaW5pdGlvbn0KICAgICogb2YgUiBpcyB0aGUgc2FtZSBhcyB0aGF0IG9mIEIuIgogICAgKgogICAgKiBOT1RFOiB3ZSBsZWF2ZSAxICYgMiBvdXQgZm9yIG5vdywgc2luY2UgdGhpcyB3aWxsIGJlCiAgICAqIHNhdGlzZmllZCBieSB0aGUgZGVyaXZhdGlvbiBwcm9jZXNzLgogICAgKiBDT05TVFJVQ1RJT04gVE9ETzogTWF5YmUgbmVlZGVkIGlmIHVzaW5nIGEgY29uc3RydWN0aW9uIEFQSS4KICAgICovCiAgICAvKgogICAgKiBTUEVDIHN0LXJlc3RyaWN0LWZhY2V0cyAzOgogICAgKiAiVGhlIHtmYWNldHN9IG9mIFIgYXJlIHRoZSB1bmlvbiBvZiBTIGFuZCB0aGUge2ZhY2V0c30KICAgICogb2YgQiwgZWxpbWluYXRpbmcgZHVwbGljYXRlcy4gVG8gZWxpbWluYXRlIGR1cGxpY2F0ZXMsCiAgICAqIHdoZW4gYSBmYWNldCBvZiB0aGUgc2FtZSBraW5kIG9jY3VycyBpbiBib3RoIFMgYW5kIHRoZQogICAgKiB7ZmFjZXRzfSBvZiBCLCB0aGUgb25lIGluIHRoZSB7ZmFjZXRzfSBvZiBCIGlzIG5vdAogICAgKiBpbmNsdWRlZCwgd2l0aCB0aGUgZXhjZXB0aW9uIG9mIGVudW1lcmF0aW9uIGFuZCBwYXR0ZXJuCiAgICAqIGZhY2V0cywgZm9yIHdoaWNoIG11bHRpcGxlIG9jY3VycmVuY2VzIHdpdGggZGlzdGluY3QgdmFsdWVzCiAgICAqIGFyZSBhbGxvd2VkLiIKICAgICovCgogICAgaWYgKCh0eXBlLT5mYWNldFNldCA9PSBOVUxMKSAmJiAoYmFzZS0+ZmFjZXRTZXQgPT0gTlVMTCkpCglyZXR1cm4gKDApOwoKICAgIGxhc3QgPSB0eXBlLT5mYWNldFNldDsKICAgIGlmIChsYXN0ICE9IE5VTEwpCgl3aGlsZSAobGFzdC0+bmV4dCAhPSBOVUxMKQoJICAgIGxhc3QgPSBsYXN0LT5uZXh0OwoKICAgIGZvciAoY3VyID0gdHlwZS0+ZmFjZXRTZXQ7IGN1ciAhPSBOVUxMOyBjdXIgPSBjdXItPm5leHQpIHsKCWZhY2V0ID0gY3VyLT5mYWNldDsKCXN3aXRjaCAoZmFjZXQtPnR5cGUpIHsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTEVOR1RIOgoJCWZsZW5ndGggPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkxFTkdUSDoKCQlmbWlubGVuID0gZmFjZXQ7IGJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NSU5JTkNMVVNJVkU6CgkJZm1pbmluYyA9IGZhY2V0OyBicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlORVhDTFVTSVZFOgoJCWZtaW5leGMgPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01BWExFTkdUSDoKCQlmbWF4bGVuID0gZmFjZXQ7IGJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NQVhJTkNMVVNJVkU6CgkJZm1heGluYyA9IGZhY2V0OyBicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYRVhDTFVTSVZFOgoJCWZtYXhleGMgPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1RPVEFMRElHSVRTOgoJCWZ0b3RkaWcgPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0ZSQUNUSU9ORElHSVRTOgoJCWZmcmFjZGlnID0gZmFjZXQ7IGJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CiAgICB9CiAgICBmb3IgKGN1ciA9IGJhc2UtPmZhY2V0U2V0OyBjdXIgIT0gTlVMTDsgY3VyID0gY3VyLT5uZXh0KSB7CglmYWNldCA9IGN1ci0+ZmFjZXQ7Cglzd2l0Y2ggKGZhY2V0LT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0xFTkdUSDoKCQliZmxlbmd0aCA9IGZhY2V0OyBicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlOTEVOR1RIOgoJCWJmbWlubGVuID0gZmFjZXQ7IGJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NSU5JTkNMVVNJVkU6CgkJYmZtaW5pbmMgPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkVYQ0xVU0lWRToKCQliZm1pbmV4YyA9IGZhY2V0OyBicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIOgoJCWJmbWF4bGVuID0gZmFjZXQ7IGJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NQVhJTkNMVVNJVkU6CgkJYmZtYXhpbmMgPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01BWEVYQ0xVU0lWRToKCQliZm1heGV4YyA9IGZhY2V0OyBicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfVE9UQUxESUdJVFM6CgkJYmZ0b3RkaWcgPSBmYWNldDsgYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0ZSQUNUSU9ORElHSVRTOgoJCWJmZnJhY2RpZyA9IGZhY2V0OyBicmVhazsKCSAgICBkZWZhdWx0OgoJCWJyZWFrOwoJfQogICAgfQogICAgLyoKICAgICogbGVuZ3RoIGFuZCBtaW5MZW5ndGggb3IgbWF4TGVuZ3RoICgyLjIpICsgKDMuMikKICAgICovCiAgICBpZiAoZmxlbmd0aCAmJiAoZm1pbmxlbiB8fCBmbWF4bGVuKSkgewoJRkFDRVRfUkVTVFJfRVJSKGZsZW5ndGgsICJJdCBpcyBhbiBlcnJvciBmb3IgYm90aCAnbGVuZ3RoJyBhbmQgIgoJICAgICJlaXRoZXIgb2YgJ21pbkxlbmd0aCcgb3IgJ21heExlbmd0aCcgdG8gYmUgc3BlY2lmaWVkIG9uICIKCSAgICAidGhlIHNhbWUgdHlwZSBkZWZpbml0aW9uIikKICAgIH0KICAgIC8qCiAgICAqIE11dHVhbCBleGNsdXNpb25zIGluIHRoZSBzYW1lIGRlcml2YXRpb24gc3RlcC4KICAgICovCiAgICBpZiAoKGZtYXhpbmMpICYmIChmbWF4ZXhjKSkgewoJLyoKCSogU0NDICJtYXhJbmNsdXNpdmUgYW5kIG1heEV4Y2x1c2l2ZSIKCSovCglGQUNFVF9SRVNUUl9NVVRVQUxfRVJSKGZtYXhpbmMsIGZtYXhleGMpCiAgICB9CiAgICBpZiAoKGZtaW5pbmMpICYmIChmbWluZXhjKSkgewoJLyoKCSogU0NDICJtaW5JbmNsdXNpdmUgYW5kIG1pbkV4Y2x1c2l2ZSIKCSovCglGQUNFVF9SRVNUUl9NVVRVQUxfRVJSKGZtaW5pbmMsIGZtaW5leGMpCiAgICB9CgogICAgaWYgKGZsZW5ndGggJiYgYmZsZW5ndGgpIHsKCS8qCgkqIFNDQyAibGVuZ3RoIHZhbGlkIHJlc3RyaWN0aW9uIgoJKiBUaGUgdmFsdWVzIGhhdmUgdG8gYmUgZXF1YWwuCgkqLwoJcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbGVuZ3RoLT52YWwsIGJmbGVuZ3RoLT52YWwpOwoJaWYgKHJlcyA9PSAtMikKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJaWYgKHJlcyAhPSAwKQoJICAgIHhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbGVuZ3RoLCBiZmxlbmd0aCwgMCwgMCwgMSk7CglpZiAoKHJlcyAhPSAwKSAmJiAoYmZsZW5ndGgtPmZpeGVkKSkgewoJICAgIEZBQ0VUX1JFU1RSX0ZJWEVEX0VSUihmbGVuZ3RoKQoJfQoKICAgIH0KICAgIGlmIChmbWlubGVuICYmIGJmbWlubGVuKSB7CgkvKgoJKiBTQ0MgIm1pbkxlbmd0aCB2YWxpZCByZXN0cmljdGlvbiIKCSogbWluTGVuZ3RoID49IEJBU0UgbWluTGVuZ3RoCgkqLwoJcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWlubGVuLT52YWwsIGJmbWlubGVuLT52YWwpOwoJaWYgKHJlcyA9PSAtMikKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJaWYgKHJlcyA9PSAtMSkKCSAgICB4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1pbmxlbiwgYmZtaW5sZW4sIDEsIDEsIDEpOwoJaWYgKChyZXMgIT0gMCkgJiYgKGJmbWlubGVuLT5maXhlZCkpIHsKCSAgICBGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZm1pbmxlbikKCX0KICAgIH0KICAgIGlmIChmbWF4bGVuICYmIGJmbWF4bGVuKSB7CgkvKgoJKiBTQ0MgIm1heExlbmd0aCB2YWxpZCByZXN0cmljdGlvbiIKCSogbWF4TGVuZ3RoIDw9IEJBU0UgbWluTGVuZ3RoCgkqLwoJcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWF4bGVuLT52YWwsIGJmbWF4bGVuLT52YWwpOwoJaWYgKHJlcyA9PSAtMikKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJaWYgKHJlcyA9PSAxKQoJICAgIHhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWF4bGVuLCBiZm1heGxlbiwgLTEsIDEsIDEpOwoJaWYgKChyZXMgIT0gMCkgJiYgKGJmbWF4bGVuLT5maXhlZCkpIHsKCSAgICBGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZm1heGxlbikKCX0KICAgIH0KICAgIC8qCiAgICAqIFNDQyAibGVuZ3RoIGFuZCBtaW5MZW5ndGggb3IgbWF4TGVuZ3RoIgogICAgKi8KICAgIGlmICghIGZsZW5ndGgpCglmbGVuZ3RoID0gYmZsZW5ndGg7CiAgICBpZiAoZmxlbmd0aCkgewoJaWYgKCEgZm1pbmxlbikKCSAgICBmbGVuZ3RoID0gYmZsZW5ndGg7CglpZiAoZm1pbmxlbikgewoJICAgIC8qICgxLjEpIGxlbmd0aCA+PSBtaW5MZW5ndGggKi8KCSAgICByZXMgPSB4bWxTY2hlbWFDb21wYXJlVmFsdWVzKGZsZW5ndGgtPnZhbCwgZm1pbmxlbi0+dmFsKTsKCSAgICBpZiAocmVzID09IC0yKQoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgaWYgKHJlcyA9PSAtMSkKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZmxlbmd0aCwgZm1pbmxlbiwgMSwgMSwgMCk7Cgl9CglpZiAoISBmbWF4bGVuKQoJICAgIGZtYXhsZW4gPSBiZm1heGxlbjsKCWlmIChmbWF4bGVuKSB7CgkgICAgLyogKDIuMSkgbGVuZ3RoIDw9IG1heExlbmd0aCAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZmxlbmd0aC0+dmFsLCBmbWF4bGVuLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzID09IDEpCgkJeG1sU2NoZW1hRGVyaXZlRmFjZXRFcnIocGN0eHQsIGZsZW5ndGgsIGZtYXhsZW4sIC0xLCAxLCAwKTsKCX0KICAgIH0KICAgIGlmIChmbWF4aW5jKSB7CgkvKgoJKiAibWF4SW5jbHVzaXZlIgoJKi8KCWlmIChmbWluaW5jKSB7CgkgICAgLyogU0NDICJtYXhJbmNsdXNpdmUgPj0gbWluSW5jbHVzaXZlIiAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1heGluYy0+dmFsLCBmbWluaW5jLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzID09IC0xKSB7CgkJeG1sU2NoZW1hRGVyaXZlRmFjZXRFcnIocGN0eHQsIGZtYXhpbmMsIGZtaW5pbmMsIDEsIDEsIDApOwoJICAgIH0KCX0KCS8qCgkqIFNDQyAibWF4SW5jbHVzaXZlIHZhbGlkIHJlc3RyaWN0aW9uIgoJKi8KCWlmIChiZm1heGluYykgewoJICAgIC8qIG1heEluY2x1c2l2ZSA8PSBCQVNFIG1heEluY2x1c2l2ZSAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1heGluYy0+dmFsLCBiZm1heGluYy0+dmFsKTsKCSAgICBpZiAocmVzID09IC0yKQoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgaWYgKHJlcyA9PSAxKQoJCXhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWF4aW5jLCBiZm1heGluYywgLTEsIDEsIDEpOwoJICAgIGlmICgocmVzICE9IDApICYmIChiZm1heGluYy0+Zml4ZWQpKSB7CgkJRkFDRVRfUkVTVFJfRklYRURfRVJSKGZtYXhpbmMpCgkgICAgfQoJfQoJaWYgKGJmbWF4ZXhjKSB7CgkgICAgLyogbWF4SW5jbHVzaXZlIDwgQkFTRSBtYXhFeGNsdXNpdmUgKi8KCSAgICByZXMgPSB4bWxTY2hlbWFDb21wYXJlVmFsdWVzKGZtYXhpbmMtPnZhbCwgYmZtYXhleGMtPnZhbCk7CgkgICAgaWYgKHJlcyA9PSAtMikKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIGlmIChyZXMgIT0gLTEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1heGluYywgYmZtYXhleGMsIC0xLCAwLCAxKTsKCSAgICB9Cgl9CglpZiAoYmZtaW5pbmMpIHsKCSAgICAvKiBtYXhJbmNsdXNpdmUgPj0gQkFTRSBtaW5JbmNsdXNpdmUgKi8KCSAgICByZXMgPSB4bWxTY2hlbWFDb21wYXJlVmFsdWVzKGZtYXhpbmMtPnZhbCwgYmZtaW5pbmMtPnZhbCk7CgkgICAgaWYgKHJlcyA9PSAtMikKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIGlmIChyZXMgPT0gLTEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1heGluYywgYmZtaW5pbmMsIDEsIDEsIDEpOwoJICAgIH0KCX0KCWlmIChiZm1pbmV4YykgewoJICAgIC8qIG1heEluY2x1c2l2ZSA+IEJBU0UgbWluRXhjbHVzaXZlICovCgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWF4aW5jLT52YWwsIGJmbWluZXhjLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzICE9IDEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1heGluYywgYmZtaW5leGMsIDEsIDAsIDEpOwoJICAgIH0KCX0KICAgIH0KICAgIGlmIChmbWF4ZXhjKSB7CgkvKgoJKiAibWF4RXhjbHVzaXZlID49IG1pbkV4Y2x1c2l2ZSIKCSovCglpZiAoZm1pbmV4YykgewoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1heGV4Yy0+dmFsLCBmbWluZXhjLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzID09IC0xKSB7CgkJeG1sU2NoZW1hRGVyaXZlRmFjZXRFcnIocGN0eHQsIGZtYXhleGMsIGZtaW5leGMsIDEsIDEsIDApOwoJICAgIH0KCX0KCS8qCgkqICJtYXhFeGNsdXNpdmUgdmFsaWQgcmVzdHJpY3Rpb24iCgkqLwoJaWYgKGJmbWF4ZXhjKSB7CgkgICAgLyogbWF4RXhjbHVzaXZlIDw9IEJBU0UgbWF4RXhjbHVzaXZlICovCgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWF4ZXhjLT52YWwsIGJmbWF4ZXhjLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzID09IDEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1heGV4YywgYmZtYXhleGMsIC0xLCAxLCAxKTsKCSAgICB9CgkgICAgaWYgKChyZXMgIT0gMCkgJiYgKGJmbWF4ZXhjLT5maXhlZCkpIHsKCQlGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZm1heGV4YykKCSAgICB9Cgl9CglpZiAoYmZtYXhpbmMpIHsKCSAgICAvKiBtYXhFeGNsdXNpdmUgPD0gQkFTRSBtYXhJbmNsdXNpdmUgKi8KCSAgICByZXMgPSB4bWxTY2hlbWFDb21wYXJlVmFsdWVzKGZtYXhleGMtPnZhbCwgYmZtYXhpbmMtPnZhbCk7CgkgICAgaWYgKHJlcyA9PSAtMikKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIGlmIChyZXMgPT0gMSkgewoJCXhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWF4ZXhjLCBiZm1heGluYywgLTEsIDEsIDEpOwoJICAgIH0KCX0KCWlmIChiZm1pbmluYykgewoJICAgIC8qIG1heEV4Y2x1c2l2ZSA+IEJBU0UgbWluSW5jbHVzaXZlICovCgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWF4ZXhjLT52YWwsIGJmbWluaW5jLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzICE9IDEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1heGV4YywgYmZtaW5pbmMsIDEsIDAsIDEpOwoJICAgIH0KCX0KCWlmIChiZm1pbmV4YykgewoJICAgIC8qIG1heEV4Y2x1c2l2ZSA+IEJBU0UgbWluRXhjbHVzaXZlICovCgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWF4ZXhjLT52YWwsIGJmbWluZXhjLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzICE9IDEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1heGV4YywgYmZtaW5leGMsIDEsIDAsIDEpOwoJICAgIH0KCX0KICAgIH0KICAgIGlmIChmbWluZXhjKSB7CgkvKgoJKiAibWluRXhjbHVzaXZlIDwgbWF4SW5jbHVzaXZlIgoJKi8KCWlmIChmbWF4aW5jKSB7CgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWluZXhjLT52YWwsIGZtYXhpbmMtPnZhbCk7CgkgICAgaWYgKHJlcyA9PSAtMikKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIGlmIChyZXMgIT0gLTEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1pbmV4YywgZm1heGluYywgLTEsIDAsIDApOwoJICAgIH0KCX0KCS8qCgkqICJtaW5FeGNsdXNpdmUgdmFsaWQgcmVzdHJpY3Rpb24iCgkqLwoJaWYgKGJmbWluZXhjKSB7CgkgICAgLyogbWluRXhjbHVzaXZlID49IEJBU0UgbWluRXhjbHVzaXZlICovCgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWluZXhjLT52YWwsIGJmbWluZXhjLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzID09IC0xKSB7CgkJeG1sU2NoZW1hRGVyaXZlRmFjZXRFcnIocGN0eHQsIGZtaW5leGMsIGJmbWluZXhjLCAxLCAxLCAxKTsKCSAgICB9CgkgICAgaWYgKChyZXMgIT0gMCkgJiYgKGJmbWluZXhjLT5maXhlZCkpIHsKCQlGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZm1pbmV4YykKCSAgICB9Cgl9CglpZiAoYmZtYXhpbmMpIHsKCSAgICAvKiBtaW5FeGNsdXNpdmUgPD0gQkFTRSBtYXhJbmNsdXNpdmUgKi8KCSAgICByZXMgPSB4bWxTY2hlbWFDb21wYXJlVmFsdWVzKGZtaW5leGMtPnZhbCwgYmZtYXhpbmMtPnZhbCk7CgkgICAgaWYgKHJlcyA9PSAtMikKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIGlmIChyZXMgPT0gMSkgewoJCXhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWluZXhjLCBiZm1heGluYywgLTEsIDEsIDEpOwoJICAgIH0KCX0KCWlmIChiZm1pbmluYykgewoJICAgIC8qIG1pbkV4Y2x1c2l2ZSA+PSBCQVNFIG1pbkluY2x1c2l2ZSAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1pbmV4Yy0+dmFsLCBiZm1pbmluYy0+dmFsKTsKCSAgICBpZiAocmVzID09IC0yKQoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgaWYgKHJlcyA9PSAtMSkgewoJCXhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWluZXhjLCBiZm1pbmluYywgMSwgMSwgMSk7CgkgICAgfQoJfQoJaWYgKGJmbWF4ZXhjKSB7CgkgICAgLyogbWluRXhjbHVzaXZlIDwgQkFTRSBtYXhFeGNsdXNpdmUgKi8KCSAgICByZXMgPSB4bWxTY2hlbWFDb21wYXJlVmFsdWVzKGZtaW5leGMtPnZhbCwgYmZtYXhleGMtPnZhbCk7CgkgICAgaWYgKHJlcyA9PSAtMikKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIGlmIChyZXMgIT0gLTEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1pbmV4YywgYmZtYXhleGMsIC0xLCAwLCAxKTsKCSAgICB9Cgl9CiAgICB9CiAgICBpZiAoZm1pbmluYykgewoJLyoKCSogIm1pbkluY2x1c2l2ZSA8IG1heEV4Y2x1c2l2ZSIKCSovCglpZiAoZm1heGV4YykgewoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1pbmluYy0+dmFsLCBmbWF4ZXhjLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzICE9IC0xKSB7CgkJeG1sU2NoZW1hRGVyaXZlRmFjZXRFcnIocGN0eHQsIGZtaW5pbmMsIGZtYXhleGMsIC0xLCAwLCAwKTsKCSAgICB9Cgl9CgkvKgoJKiAibWluRXhjbHVzaXZlIHZhbGlkIHJlc3RyaWN0aW9uIgoJKi8KCWlmIChiZm1pbmluYykgewoJICAgIC8qIG1pbkluY2x1c2l2ZSA+PSBCQVNFIG1pbkluY2x1c2l2ZSAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1pbmluYy0+dmFsLCBiZm1pbmluYy0+dmFsKTsKCSAgICBpZiAocmVzID09IC0yKQoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgaWYgKHJlcyA9PSAtMSkgewoJCXhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWluaW5jLCBiZm1pbmluYywgMSwgMSwgMSk7CgkgICAgfQoJICAgIGlmICgocmVzICE9IDApICYmIChiZm1pbmluYy0+Zml4ZWQpKSB7CgkJRkFDRVRfUkVTVFJfRklYRURfRVJSKGZtaW5pbmMpCgkgICAgfQoJfQoJaWYgKGJmbWF4aW5jKSB7CgkgICAgLyogbWluSW5jbHVzaXZlIDw9IEJBU0UgbWF4SW5jbHVzaXZlICovCgkgICAgcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmbWluaW5jLT52YWwsIGJmbWF4aW5jLT52YWwpOwoJICAgIGlmIChyZXMgPT0gLTIpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZiAocmVzID09IDEpIHsKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1pbmluYywgYmZtYXhpbmMsIC0xLCAxLCAxKTsKCSAgICB9Cgl9CglpZiAoYmZtaW5leGMpIHsKCSAgICAvKiBtaW5JbmNsdXNpdmUgPiBCQVNFIG1pbkV4Y2x1c2l2ZSAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1pbmluYy0+dmFsLCBiZm1pbmV4Yy0+dmFsKTsKCSAgICBpZiAocmVzID09IC0yKQoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgaWYgKHJlcyAhPSAxKQoJCXhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmbWluaW5jLCBiZm1pbmV4YywgMSwgMCwgMSk7Cgl9CglpZiAoYmZtYXhleGMpIHsKCSAgICAvKiBtaW5JbmNsdXNpdmUgPCBCQVNFIG1heEV4Y2x1c2l2ZSAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZm1pbmluYy0+dmFsLCBiZm1heGV4Yy0+dmFsKTsKCSAgICBpZiAocmVzID09IC0yKQoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgaWYgKHJlcyAhPSAtMSkKCQl4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZm1pbmluYywgYmZtYXhleGMsIC0xLCAwLCAxKTsKCX0KICAgIH0KICAgIGlmIChmdG90ZGlnICYmIGJmdG90ZGlnKSB7CgkvKgoJKiBTQ0MgIiB0b3RhbERpZ2l0cyB2YWxpZCByZXN0cmljdGlvbiIKCSogdG90YWxEaWdpdHMgPD0gQkFTRSB0b3RhbERpZ2l0cwoJKi8KCXJlcyA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXMoZnRvdGRpZy0+dmFsLCBiZnRvdGRpZy0+dmFsKTsKCWlmIChyZXMgPT0gLTIpCgkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCWlmIChyZXMgPT0gMSkKCSAgICB4bWxTY2hlbWFEZXJpdmVGYWNldEVycihwY3R4dCwgZnRvdGRpZywgYmZ0b3RkaWcsCgkgICAgLTEsIDEsIDEpOwoJaWYgKChyZXMgIT0gMCkgJiYgKGJmdG90ZGlnLT5maXhlZCkpIHsKCSAgICBGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZnRvdGRpZykKCX0KICAgIH0KICAgIGlmIChmZnJhY2RpZyAmJiBiZmZyYWNkaWcpIHsKCS8qCgkqIFNDQyAgImZyYWN0aW9uRGlnaXRzIHZhbGlkIHJlc3RyaWN0aW9uIgoJKiBmcmFjdGlvbkRpZ2l0cyA8PSBCQVNFIGZyYWN0aW9uRGlnaXRzCgkqLwoJcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmZnJhY2RpZy0+dmFsLCBiZmZyYWNkaWctPnZhbCk7CglpZiAocmVzID09IC0yKQoJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CglpZiAocmVzID09IDEpCgkgICAgeG1sU2NoZW1hRGVyaXZlRmFjZXRFcnIocGN0eHQsIGZmcmFjZGlnLCBiZmZyYWNkaWcsCgkgICAgLTEsIDEsIDEpOwoJaWYgKChyZXMgIT0gMCkgJiYgKGJmZnJhY2RpZy0+Zml4ZWQpKSB7CgkgICAgRkFDRVRfUkVTVFJfRklYRURfRVJSKGZmcmFjZGlnKQoJfQogICAgfQogICAgLyoKICAgICogU0NDICJmcmFjdGlvbkRpZ2l0cyBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gdG90YWxEaWdpdHMiCiAgICAqLwogICAgaWYgKCEgZnRvdGRpZykKCWZ0b3RkaWcgPSBiZnRvdGRpZzsKICAgIGlmICghIGZmcmFjZGlnKQoJZmZyYWNkaWcgPSBiZmZyYWNkaWc7CiAgICBpZiAoZnRvdGRpZyAmJiBmZnJhY2RpZykgewoJcmVzID0geG1sU2NoZW1hQ29tcGFyZVZhbHVlcyhmZnJhY2RpZy0+dmFsLCBmdG90ZGlnLT52YWwpOwoJaWYgKHJlcyA9PSAtMikKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJaWYgKHJlcyA9PSAxKQoJICAgIHhtbFNjaGVtYURlcml2ZUZhY2V0RXJyKHBjdHh0LCBmZnJhY2RpZywgZnRvdGRpZywKCQktMSwgMSwgMCk7CiAgICB9CiAgICAvKgogICAgKiAqRW51bWVyYXRpb25zKiB3b24nIGJlIGFkZGVkIGhlcmUsIHNpbmNlIG9ubHkgdGhlIGZpcnN0IHNldAogICAgKiBvZiBlbnVtZXJhdGlvbnMgaW4gdGhlIGFuY2VzdG9yLW9yLXNlbGYgYXhpcyBpcyB1c2VkCiAgICAqIGZvciB2YWxpZGF0aW9uLCBwbHVzIHdlIG5lZWQgdG8gdXNlIHRoZSBiYXNlIHR5cGUgb2YgdGhvc2UKICAgICogZW51bWVyYXRpb25zIGZvciB3aGl0ZXNwYWNlLgogICAgKgogICAgKiAqUGF0dGVybnMqOiB3b24ndCBiZSBhZGQgaGVyZSwgc2luY2UgdGhleSBhcmUgT1JlZCBhdAogICAgKiB0eXBlIGxldmVsIGFuZCBBTkRlZCBhdCBhbmNlc3RvciBsZXZlbC4gVGhpcyB3aWxsCiAgICAqIGhhcHBlZCBkdXJpbmcgdmFsaWRhdGlvbiBieSB3YWxraW5nIHRoZSBiYXNlIGF4aXMKICAgICogb2YgdGhlIHR5cGUuCiAgICAqLwogICAgZm9yIChjdXIgPSBiYXNlLT5mYWNldFNldDsgY3VyICE9IE5VTEw7IGN1ciA9IGN1ci0+bmV4dCkgewoJYmZhY2V0ID0gY3VyLT5mYWNldDsKCS8qCgkqIFNwZWNpYWwgaGFuZGxpbmcgb2YgZW51bWVyYXRpb25zIGFuZCBwYXR0ZXJucy4KCSogVE9ETzogaG1tLCB0aGV5IHNob3VsZCBub3QgYXBwZWFyIGluIHRoZSBzZXQsIHNvIHJlbW92ZSB0aGlzLgoJKi8KCWlmICgoYmZhY2V0LT50eXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfUEFUVEVSTikgfHwKCSAgICAoYmZhY2V0LT50eXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfRU5VTUVSQVRJT04pKQoJICAgIGNvbnRpbnVlOwoJLyoKCSogU2VhcmNoIGZvciBhIGR1cGxpY2F0ZSBmYWNldCBpbiB0aGUgY3VycmVudCB0eXBlLgoJKi8KCWxpbmsgPSB0eXBlLT5mYWNldFNldDsKCS8qIGVyciA9IDA7ICovCgkvKiBmaXhlZEVyciA9IDA7ICovCgl3aGlsZSAobGluayAhPSBOVUxMKSB7CgkgICAgZmFjZXQgPSBsaW5rLT5mYWNldDsKCSAgICBpZiAoZmFjZXQtPnR5cGUgPT0gYmZhY2V0LT50eXBlKSB7CgkJc3dpdGNoIChmYWNldC0+dHlwZSkgewoJCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfV0hJVEVTUEFDRToKCQkJLyoKCQkJKiBUaGUgd2hpdGVzcGFjZSBtdXN0IGJlIHN0cm9uZ2VyLgoJCQkqLwoJCQlpZiAoZmFjZXQtPndoaXRlc3BhY2UgPCBiZmFjZXQtPndoaXRlc3BhY2UpIHsKCQkJICAgIEZBQ0VUX1JFU1RSX0VSUihmbGVuZ3RoLAoJCQkJIlRoZSAnd2hpdGVzcGFjZScgdmFsdWUgaGFzIHRvIGJlIGVxdWFsIHRvICIKCQkJCSJvciBzdHJvbmdlciB0aGFuIHRoZSAnd2hpdGVzcGFjZScgdmFsdWUgb2YgIgoJCQkJInRoZSBiYXNlIHR5cGUiKQoJCQl9CgkJCWlmICgoYmZhY2V0LT5maXhlZCkgJiYKCQkJICAgIChmYWNldC0+d2hpdGVzcGFjZSAhPSBiZmFjZXQtPndoaXRlc3BhY2UpKSB7CgkJCSAgICBGQUNFVF9SRVNUUl9GSVhFRF9FUlIoZmFjZXQpCgkJCX0KCQkJYnJlYWs7CgkJICAgIGRlZmF1bHQ6CgkJCWJyZWFrOwoJCX0KCQkvKiBEdXBsaWNhdGUgZm91bmQuICovCgkJYnJlYWs7CgkgICAgfQoJICAgIGxpbmsgPSBsaW5rLT5uZXh0OwoJfQoJLyoKCSogSWYgbm8gZHVwbGljYXRlIHdhcyBmb3VuZDogYWRkIHRoZSBiYXNlIHR5cGVzJ3MgZmFjZXQKCSogdG8gdGhlIHNldC4KCSovCglpZiAobGluayA9PSBOVUxMKSB7CgkgICAgbGluayA9ICh4bWxTY2hlbWFGYWNldExpbmtQdHIpCgkJeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFGYWNldExpbmspKTsKCSAgICBpZiAobGluayA9PSBOVUxMKSB7CgkJeG1sU2NoZW1hUEVyck1lbW9yeShwY3R4dCwKCQkgICAgImRlcml2aW5nIGZhY2V0cywgY3JlYXRpbmcgYSBmYWNldCBsaW5rIiwgTlVMTCk7CgkJcmV0dXJuICgtMSk7CgkgICAgfQoJICAgIGxpbmstPmZhY2V0ID0gY3VyLT5mYWNldDsKCSAgICBsaW5rLT5uZXh0ID0gTlVMTDsKCSAgICBpZiAobGFzdCA9PSBOVUxMKQoJCXR5cGUtPmZhY2V0U2V0ID0gbGluazsKCSAgICBlbHNlCgkJbGFzdC0+bmV4dCA9IGxpbms7CgkgICAgbGFzdCA9IGxpbms7Cgl9CgogICAgfQoKICAgIHJldHVybiAoMCk7CmludGVybmFsX2Vycm9yOgogICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hRGVyaXZlQW5kVmFsaWRhdGVGYWNldHMiLAoJImFuIGVycm9yIG9jY3VyZWQiKTsKICAgIHJldHVybiAoLTEpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYUZpbmlzaE1lbWJlclR5cGVEZWZpbml0aW9uc1Byb3BlcnR5KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkJICAgICB4bWxTY2hlbWFUeXBlUHRyIHR5cGUpCnsKICAgIHhtbFNjaGVtYVR5cGVMaW5rUHRyIGxpbmssIGxhc3RMaW5rLCBwcmV2TGluaywgc3ViTGluaywgbmV3TGluazsKICAgIC8qCiAgICAqIFRoZSBhY3R1YWwgdmFsdWUgaXMgdGhlbiBmb3JtZWQgYnkgcmVwbGFjaW5nIGFueSB1bmlvbiB0eXBlCiAgICAqIGRlZmluaXRpb24gaW4gdGhlILdleHBsaWNpdCBtZW1iZXJztyB3aXRoIHRoZSBtZW1iZXJzIG9mIHRoZWlyCiAgICAqIHttZW1iZXIgdHlwZSBkZWZpbml0aW9uc30sIGluIG9yZGVyLgogICAgKgogICAgKiBUT0RPOiBUaGVyZSdzIGEgYnVnIGVudHJ5IGF0CiAgICAqICJodHRwOi8vbGlzdHMudzMub3JnL0FyY2hpdmVzL1B1YmxpYy93d3cteG1sLXNjaGVtYS1jb21tZW50cy8yMDA1SnVsU2VwLzAyODcuaHRtbCIKICAgICogd2hpY2ggaW5kaWNhdGVzIHRoYXQgd2UnbGwga2VlcCB0aGUgdW5pb24gdHlwZXMgdGhlIGZ1dHVyZS4KICAgICovCiAgICBsaW5rID0gdHlwZS0+bWVtYmVyVHlwZXM7CiAgICB3aGlsZSAobGluayAhPSBOVUxMKSB7CgoJaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRChsaW5rLT50eXBlKSkKCSAgICB4bWxTY2hlbWFUeXBlRml4dXAobGluay0+dHlwZSwgQUNUWFRfQ0FTVCBwY3R4dCk7CgoJaWYgKFdYU19JU19VTklPTihsaW5rLT50eXBlKSkgewoJICAgIHN1YkxpbmsgPSB4bWxTY2hlbWFHZXRVbmlvblNpbXBsZVR5cGVNZW1iZXJUeXBlcyhsaW5rLT50eXBlKTsKCSAgICBpZiAoc3ViTGluayAhPSBOVUxMKSB7CgkJbGluay0+dHlwZSA9IHN1YkxpbmstPnR5cGU7CgkJaWYgKHN1YkxpbmstPm5leHQgIT0gTlVMTCkgewoJCSAgICBsYXN0TGluayA9IGxpbmstPm5leHQ7CgkJICAgIHN1YkxpbmsgPSBzdWJMaW5rLT5uZXh0OwoJCSAgICBwcmV2TGluayA9IGxpbms7CgkJICAgIHdoaWxlIChzdWJMaW5rICE9IE5VTEwpIHsKCQkJbmV3TGluayA9ICh4bWxTY2hlbWFUeXBlTGlua1B0cikKCQkJICAgIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hVHlwZUxpbmspKTsKCQkJaWYgKG5ld0xpbmsgPT0gTlVMTCkgewoJCQkgICAgeG1sU2NoZW1hUEVyck1lbW9yeShwY3R4dCwgImFsbG9jYXRpbmcgYSB0eXBlIGxpbmsiLAoJCQkJTlVMTCk7CgkJCSAgICByZXR1cm4gKC0xKTsKCQkJfQoJCQluZXdMaW5rLT50eXBlID0gc3ViTGluay0+dHlwZTsKCQkJcHJldkxpbmstPm5leHQgPSBuZXdMaW5rOwoJCQlwcmV2TGluayA9IG5ld0xpbms7CgkJCW5ld0xpbmstPm5leHQgPSBsYXN0TGluazsKCgkJCXN1YkxpbmsgPSBzdWJMaW5rLT5uZXh0OwoJCSAgICB9CgkJfQoJICAgIH0KCX0KCWxpbmsgPSBsaW5rLT5uZXh0OwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hVHlwZUZpeHVwT3B0aW1GYWNldHMoeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7ICAgICAgIAogICAgaW50IGhhcyA9IDAsIG5lZWRWYWwgPSAwLCBub3JtVmFsID0gMDsKCiAgICBoYXMJPSAodHlwZS0+YmFzZVR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9IQVNfRkFDRVRTKSA/IDEgOiAwOwogICAgaWYgKGhhcykgewoJbmVlZFZhbCA9ICh0eXBlLT5iYXNlVHlwZS0+ZmxhZ3MgJgoJICAgIFhNTF9TQ0hFTUFTX1RZUEVfRkFDRVRTTkVFRFZBTFVFKSA/IDEgOiAwOwoJbm9ybVZhbCA9ICh0eXBlLT5iYXNlVHlwZS0+ZmxhZ3MgJgoJICAgIFhNTF9TQ0hFTUFTX1RZUEVfTk9STVZBTFVFTkVFREVEKSA/IDEgOiAwOwogICAgfQogICAgaWYgKHR5cGUtPmZhY2V0cyAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFGYWNldFB0ciBmYWM7CgkKCWZvciAoZmFjID0gdHlwZS0+ZmFjZXRzOyBmYWMgIT0gTlVMTDsgZmFjID0gZmFjLT5uZXh0KSB7CgkgICAgc3dpdGNoIChmYWMtPnR5cGUpIHsKCQljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfV0hJVEVTUEFDRToKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk46CgkJICAgIG5vcm1WYWwgPSAxOwoJCSAgICBoYXMgPSAxOwoJCSAgICBicmVhazsKCQljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfRU5VTUVSQVRJT046CgkJICAgIG5lZWRWYWwgPSAxOwoJCSAgICBub3JtVmFsID0gMTsKCQkgICAgaGFzID0gMTsKCQkgICAgYnJlYWs7CgkJZGVmYXVsdDoKCQkgICAgaGFzID0gMTsKCQkgICAgYnJlYWs7CgkgICAgfQoJfQkKICAgIH0KICAgIGlmIChub3JtVmFsKQoJdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9OT1JNVkFMVUVORUVERUQ7CiAgICBpZiAobmVlZFZhbCkKCXR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfRkFDRVRTTkVFRFZBTFVFOwogICAgaWYgKGhhcykKCXR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfSEFTX0ZBQ0VUUzsKCiAgICBpZiAoaGFzICYmICghIG5lZWRWYWwpICYmIFdYU19JU19BVE9NSUModHlwZSkpIHsKCXhtbFNjaGVtYVR5cGVQdHIgcHJpbSA9IHhtbFNjaGVtYUdldFByaW1pdGl2ZVR5cGUodHlwZSk7CgkvKgoJKiBPUFRJTUlaRSBWQUwgVE9ETzogU29tZSBmYWNldHMgbmVlZCBhIGNvbXB1dGVkIHZhbHVlLgoJKi8KCWlmICgocHJpbS0+YnVpbHRJblR5cGUgIT0gWE1MX1NDSEVNQVNfQU5ZU0lNUExFVFlQRSkgJiYKCSAgICAocHJpbS0+YnVpbHRJblR5cGUgIT0gWE1MX1NDSEVNQVNfU1RSSU5HKSkgewoJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfRkFDRVRTTkVFRFZBTFVFOwoJfSAJCiAgICB9ICAgICAgIAp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVR5cGVGaXh1cFdoaXRlc3BhY2UoeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICAKICAgIAogICAgLyoKICAgICogRXZhbHVhdGUgdGhlIHdoaXRlc3BhY2UtZmFjZXQgdmFsdWUuCiAgICAqLyAgICAKICAgIGlmIChXWFNfSVNfTElTVCh0eXBlKSkgewoJdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9XSElURVNQQUNFX0NPTExBUFNFOwoJcmV0dXJuICgwKTsKICAgIH0gZWxzZSBpZiAoV1hTX0lTX1VOSU9OKHR5cGUpKQoJcmV0dXJuICgwKTsKICAgIAogICAgaWYgKHR5cGUtPmZhY2V0U2V0ICE9IE5VTEwpIHsKCXhtbFNjaGVtYUZhY2V0TGlua1B0ciBsaW47CgoJZm9yIChsaW4gPSB0eXBlLT5mYWNldFNldDsgbGluICE9IE5VTEw7IGxpbiA9IGxpbi0+bmV4dCkgewoJICAgIGlmIChsaW4tPmZhY2V0LT50eXBlID09IFhNTF9TQ0hFTUFfRkFDRVRfV0hJVEVTUEFDRSkgewoJCXN3aXRjaCAobGluLT5mYWNldC0+d2hpdGVzcGFjZSkgewoJCWNhc2UgWE1MX1NDSEVNQVNfRkFDRVRfUFJFU0VSVkU6CgkJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfV0hJVEVTUEFDRV9QUkVTRVJWRTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BU19GQUNFVF9SRVBMQUNFOgoJCSAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX1dISVRFU1BBQ0VfUkVQTEFDRTsKCQkgICAgYnJlYWs7CgkJY2FzZSBYTUxfU0NIRU1BU19GQUNFVF9DT0xMQVBTRToKCQkgICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9XSElURVNQQUNFX0NPTExBUFNFOwoJCSAgICBicmVhazsKCQlkZWZhdWx0OgoJCSAgICByZXR1cm4gKC0xKTsKCQl9CgkJcmV0dXJuICgwKTsKCSAgICB9Cgl9CiAgICB9CiAgICAvKgogICAgKiBGb3IgYWxsILdhdG9taWO3IGRhdGF0eXBlcyBvdGhlciB0aGFuIHN0cmluZyAoYW5kIHR5cGVzILdkZXJpdmVktyAKICAgICogYnkgt3Jlc3RyaWN0aW9utyBmcm9tIGl0KSB0aGUgdmFsdWUgb2Ygd2hpdGVTcGFjZSBpcyBmaXhlZCB0byAKICAgICogY29sbGFwc2UKICAgICovCiAgICB7Cgl4bWxTY2hlbWFUeXBlUHRyIGFuYzsKCglmb3IgKGFuYyA9IHR5cGUtPmJhc2VUeXBlOyBhbmMgIT0gTlVMTCAmJiAKCQlhbmMtPmJ1aWx0SW5UeXBlICE9IFhNTF9TQ0hFTUFTX0FOWVRZUEU7CgkJYW5jID0gYW5jLT5iYXNlVHlwZSkgewoKCSAgICBpZiAoYW5jLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgewoJCWlmIChhbmMtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX05PUk1TVFJJTkcpIHsJICAgIAoJCSAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX1dISVRFU1BBQ0VfUkVQTEFDRTsKCgkJfSBlbHNlIGlmICgoYW5jLT5idWlsdEluVHlwZSA9PSBYTUxfU0NIRU1BU19TVFJJTkcpIHx8CgkJICAgIChhbmMtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX0FOWVNJTVBMRVRZUEUpKSB7CQkgICAgCgkJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfV0hJVEVTUEFDRV9QUkVTRVJWRTsKCgkJfSBlbHNlCgkJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfV0hJVEVTUEFDRV9DT0xMQVBTRTsKCQlicmVhazsKCSAgICB9Cgl9CiAgICB9CiAgICByZXR1cm4gKDApOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYUZpeHVwU2ltcGxlVHlwZVN0YWdlT25lKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCSAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICBpZiAodHlwZS0+dHlwZSAhPSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFKQoJcmV0dXJuKDApOwogICAgaWYgKCEgV1hTX0lTX1RZUEVfTk9UX0ZJWEVEXzEodHlwZSkpCglyZXR1cm4oMCk7CiAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX0ZJWFVQXzE7CgogICAgaWYgKFdYU19JU19MSVNUKHR5cGUpKSB7CgkvKgoJKiBDb3JyZXNwb25kcyB0byA8c2ltcGxlVHlwZT48bGlzdD4uLi4KCSovCglpZiAodHlwZS0+c3VidHlwZXMgPT0gTlVMTCkgewoJICAgIC8qCgkgICAgKiBUaGlzIG9uZSBpcyByZWFsbHkgbmVlZGVkLCBzbyBnZXQgb3V0LgoJICAgICovCgkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hRml4dXBTaW1wbGVUeXBlU3RhZ2VPbmUiLAoJCSJsaXN0IHR5cGUgaGFzIG5vIGl0ZW0tdHlwZSBhc3NpZ25lZCIpOwoJICAgIHJldHVybigtMSk7Cgl9CiAgICB9IGVsc2UgaWYgKFdYU19JU19VTklPTih0eXBlKSkgewoJLyoKCSogQ29ycmVzcG9uZHMgdG8gPHNpbXBsZVR5cGU+PHVuaW9uPi4uLgoJKi8JCglpZiAodHlwZS0+bWVtYmVyVHlwZXMgPT0gTlVMTCkgewoJICAgIC8qCgkgICAgKiBUaGlzIG9uZSBpcyByZWFsbHkgbmVlZGVkLCBzbyBnZXQgb3V0LgoJICAgICovCgkgICAgUEVSUk9SX0lOVCgieG1sU2NoZW1hRml4dXBTaW1wbGVUeXBlU3RhZ2VPbmUiLAoJCSJ1bmlvbiB0eXBlIGhhcyBubyBtZW1iZXItdHlwZXMgYXNzaWduZWQiKTsKCSAgICByZXR1cm4oLTEpOwoJfQkgICAgCiAgICB9IGVsc2UgeyAgICAKCS8qCgkqIENvcnJlc3BvbmRzIHRvIDxzaW1wbGVUeXBlPjxyZXN0cmljdGlvbj4uLi4KCSovCglpZiAodHlwZS0+YmFzZVR5cGUgPT0gTlVMTCkgewoJICAgIFBFUlJPUl9JTlQoInhtbFNjaGVtYUZpeHVwU2ltcGxlVHlwZVN0YWdlT25lIiwKCQkidHlwZSBoYXMgbm8gYmFzZS10eXBlIGFzc2lnbmVkIik7CgkgICAgcmV0dXJuKC0xKTsKCX0KCWlmIChXWFNfSVNfVFlQRV9OT1RfRklYRURfMSh0eXBlLT5iYXNlVHlwZSkpCgkgICAgaWYgKHhtbFNjaGVtYUZpeHVwU2ltcGxlVHlwZVN0YWdlT25lKHBjdHh0LCB0eXBlLT5iYXNlVHlwZSkgPT0gLTEpCgkJcmV0dXJuKC0xKTsKCS8qCgkqIFZhcmlldHkKCSogSWYgdGhlIDxyZXN0cmljdGlvbj4gYWx0ZXJuYXRpdmUgaXMgY2hvc2VuLCB0aGVuIHRoZQoJKiB7dmFyaWV0eX0gb2YgdGhlIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0uCgkqLwoJaWYgKFdYU19JU19BVE9NSUModHlwZS0+YmFzZVR5cGUpKQoJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfVkFSSUVUWV9BVE9NSUM7CgllbHNlIGlmIChXWFNfSVNfTElTVCh0eXBlLT5iYXNlVHlwZSkpIHsKCSAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX1ZBUklFVFlfTElTVDsKCSAgICAvKgoJICAgICogSW5oZXJpdCB0aGUgaXRlbVR5cGUuCgkgICAgKi8KCSAgICB0eXBlLT5zdWJ0eXBlcyA9IHR5cGUtPmJhc2VUeXBlLT5zdWJ0eXBlczsKCX0gZWxzZSBpZiAoV1hTX0lTX1VOSU9OKHR5cGUtPmJhc2VUeXBlKSkgewoJICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfVkFSSUVUWV9VTklPTjsKCSAgICAvKgoJICAgICogTk9URSB0aGF0IHdlIHdvbid0IGFzc2lnbiB0aGUgbWVtYmVyVHlwZXMgb2YgdGhlIGJhc2UsCgkgICAgKiBzaW5jZSB0aGlzIHdpbGwgbWFrZSB0cm91YmxlIHdoZW4gZnJlZWluZyB0aGVtOyB3ZSB3aWxsCgkgICAgKiB1c2UgYSBsb29rdXAgZnVuY3Rpb24gdG8gYWNjZXNzIHRoZW0gaW5zdGVhZC4KCSAgICAqLwoJfQogICAgfQogICAgcmV0dXJuKDApOwp9CgojaWZkZWYgREVCVUdfVFlQRQp2b2lkCnhtbFNjaGVtYURlYnVnRml4ZWRUeXBlKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJICAgICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgaWYgKHR5cGUtPm5vZGUgIT0gTlVMTCkgewogICAgICAgIHhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LAogICAgICAgICAgICAgICAgICAgICAgICAiVHlwZSBvZiAlcyA6ICVzOiVkIDoiLCBuYW1lLAogICAgICAgICAgICAgICAgICAgICAgICB0eXBlLT5ub2RlLT5kb2MtPlVSTCwKICAgICAgICAgICAgICAgICAgICAgICAgeG1sR2V0TGluZU5vKHR5cGUtPm5vZGUpKTsKICAgIH0gZWxzZSB7CiAgICAgICAgeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsICJUeXBlIG9mICVzIDoiLCBuYW1lKTsKICAgIH0KICAgIGlmICgoV1hTX0lTX1NJTVBMRSh0eXBlKSkgfHwgKFdYU19JU19DT01QTEVYKHR5cGUpKSkgewoJc3dpdGNoICh0eXBlLT5jb250ZW50VHlwZSkgewoJICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRToKCQl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgInNpbXBsZVxuIik7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0NPTlRFTlRfRUxFTUVOVFM6CgkJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsICJlbGVtZW50c1xuIik7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0NPTlRFTlRfVU5LTk9XTjoKCQl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgInVua25vd24gISEhXG4iKTsKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWToKCQl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgImVtcHR5XG4iKTsKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfQ09OVEVOVF9NSVhFRDoKCQlpZiAoeG1sU2NoZW1hSXNQYXJ0aWNsZUVtcHRpYWJsZSgoeG1sU2NoZW1hUGFydGljbGVQdHIpCgkJICAgIHR5cGUtPnN1YnR5cGVzKSkKCQkgICAgeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsCgkJCSJtaXhlZCBhcyBlbXB0aWFibGUgcGFydGljbGVcbiIpOwoJCWVsc2UKCQkgICAgeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsICJtaXhlZFxuIik7CgkJYnJlYWs7CgkJLyogUmVtb3ZlZCwgc2luY2Ugbm90IHVzZWQuICovCgkJLyoKCQljYXNlIFhNTF9TQ0hFTUFfQ09OVEVOVF9NSVhFRF9PUl9FTEVNRU5UUzoKCQl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgIm1peGVkIG9yIGVsZW1zXG4iKTsKCQlicmVhazsKCQkqLwoJICAgIGNhc2UgWE1MX1NDSEVNQV9DT05URU5UX0JBU0lDOgoJCXhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LCAiYmFzaWNcbiIpOwoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsCgkJICAgICJub3QgcmVnaXN0ZXJlZCAhISFcbiIpOwoJCWJyZWFrOwoJfQogICAgfQp9CiNlbmRpZgoKLyoKKiAzLjE0LjYgQ29uc3RyYWludHMgb24gU2ltcGxlIFR5cGUgRGVmaW5pdGlvbiBTY2hlbWEgQ29tcG9uZW50cwoqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUZpeHVwU2ltcGxlVHlwZVN0YWdlVHdvKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICBpbnQgcmVzLCBvbGRlcnJzID0gcGN0eHQtPm5iZXJyb3JzOwoKICAgIGlmICh0eXBlLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUpCglyZXR1cm4oLTEpOwoKICAgIGlmICghIFdYU19JU19UWVBFX05PVF9GSVhFRCh0eXBlKSkKCXJldHVybigwKTsKCiAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX0lOVEVSTkFMX1JFU09MVkVEOwogICAgdHlwZS0+Y29udGVudFR5cGUgPSBYTUxfU0NIRU1BX0NPTlRFTlRfU0lNUExFOwoKICAgIGlmICh0eXBlLT5iYXNlVHlwZSA9PSBOVUxMKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFGaXh1cFNpbXBsZVR5cGVTdGFnZVR3byIsCgkgICAgIm1pc3NpbmcgYmFzZVR5cGUiKTsKCWdvdG8gZXhpdF9mYWlsdXJlOwogICAgfQogICAgaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRCh0eXBlLT5iYXNlVHlwZSkpCgl4bWxTY2hlbWFUeXBlRml4dXAodHlwZS0+YmFzZVR5cGUsIEFDVFhUX0NBU1QgcGN0eHQpOwogICAgLyogCiAgICAqIElmIGEgbWVtYmVyIHR5cGUgb2YgYSB1bmlvbiBpcyBhIHVuaW9uIGl0c2VsZiwgd2UgbmVlZCB0byBzdWJzdGl0dXRlCiAgICAqIHRoYXQgbWVtYmVyIHR5cGUgZm9yIGl0cyBtZW1iZXIgdHlwZXMuCiAgICAqIE5PVEUgdGhhdCB0aGlzIG1pZ2h0IGNoYW5nZSBpbiBXWFMgMS4xOyBpLmUuIHdlIHdpbGwga2VlcCB0aGUgdW5pb24KICAgICogdHlwZXMgaW4gV1hTIDEuMS4KICAgICovCiAgICBpZiAoKHR5cGUtPm1lbWJlclR5cGVzICE9IE5VTEwpICYmCgkoeG1sU2NoZW1hRmluaXNoTWVtYmVyVHlwZURlZmluaXRpb25zUHJvcGVydHkocGN0eHQsIHR5cGUpID09IC0xKSkKCXJldHVybigtMSk7ICAgICAgICAKICAgIC8qCiAgICAqIFNQRUMgc3JjLXNpbXBsZS10eXBlIDEgCiAgICAqICJUaGUgY29ycmVzcG9uZGluZyBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLCBpZiBhbnksIG11c3Qgc2F0aXNmeQogICAgKiB0aGUgY29uZGl0aW9ucyBzZXQgb3V0IGluIENvbnN0cmFpbnRzIG9uIFNpbXBsZSBUeXBlIERlZmluaXRpb24KICAgICogU2NoZW1hIENvbXBvbmVudHMgKKczLjE0LjYpLiIKICAgICovCiAgICAvKgogICAgKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IFNpbXBsZSBUeXBlIERlZmluaXRpb24gUHJvcGVydGllcyBDb3JyZWN0CiAgICAqIChzdC1wcm9wcy1jb3JyZWN0KQogICAgKi8KICAgIHJlcyA9IHhtbFNjaGVtYUNoZWNrU1RQcm9wc0NvcnJlY3QocGN0eHQsIHR5cGUpOwogICAgSEZBSUxVUkUgSEVSUk9SCiAgICAvKiAKICAgICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiBEZXJpdmF0aW9uIFZhbGlkIChSZXN0cmljdGlvbiwgU2ltcGxlKQogICAgKiAoY29zLXN0LXJlc3RyaWN0cykKICAgICovCiAgICByZXMgPSB4bWxTY2hlbWFDaGVja0NPU1NUUmVzdHJpY3RzKHBjdHh0LCB0eXBlKTsKICAgIEhGQUlMVVJFIEhFUlJPUgogICAgLyoKICAgICogVE9ETzogUmVtb3ZlZCB0aGUgZXJyb3IgcmVwb3J0LCBzaW5jZSBpdCBnb3QgYW5ub3lpbmcgdG8gZ2V0IGFuCiAgICAqIGV4dHJhIGVycm9yIHJlcG9ydCwgaWYgYW55dGhpbmcgZmFpbGVkIHVudGlsIG5vdy4KICAgICogRW5hYmxlIHRoaXMgaWYgbmVlZGVkLgogICAgKgogICAgKiB4bWxTY2hlbWFQRXJyKGN0eHQsIHR5cGUtPm5vZGUsCiAgICAqICAgIFhNTF9TQ0hFTUFQX1NSQ19TSU1QTEVfVFlQRV8xLAogICAgKiAgICAiU2ltcGxlIHR5cGUgJyVzJyBkb2VzIG5vdCBzYXRpc2Z5IHRoZSBjb25zdHJhaW50cyAiCiAgICAqICAgICJvbiBzaW1wbGUgdHlwZSBkZWZpbml0aW9ucy5cbiIsCiAgICAqICAgIHR5cGUtPm5hbWUsIE5VTEwpOwogICAgKi8KICAgIC8qCiAgICAqIFNjaGVtYSBDb21wb25lbnQgQ29uc3RyYWludDogU2ltcGxlIFR5cGUgUmVzdHJpY3Rpb24gKEZhY2V0cykKICAgICogKHN0LXJlc3RyaWN0LWZhY2V0cykKICAgICovCiAgICByZXMgPSB4bWxTY2hlbWFDaGVja0ZhY2V0VmFsdWVzKHR5cGUsIHBjdHh0KTsKICAgIEhGQUlMVVJFIEhFUlJPUgogICAgaWYgKCh0eXBlLT5mYWNldFNldCAhPSBOVUxMKSB8fAoJKHR5cGUtPmJhc2VUeXBlLT5mYWNldFNldCAhPSBOVUxMKSkgewoJcmVzID0geG1sU2NoZW1hRGVyaXZlQW5kVmFsaWRhdGVGYWNldHMocGN0eHQsIHR5cGUpOwoJSEZBSUxVUkUgSEVSUk9SCiAgICB9CiAgICAvKgogICAgKiBXaGl0ZXNwYWNlIHZhbHVlLgogICAgKi8KICAgIHJlcyA9IHhtbFNjaGVtYVR5cGVGaXh1cFdoaXRlc3BhY2UodHlwZSk7CiAgICBIRkFJTFVSRSBIRVJST1IKICAgIHhtbFNjaGVtYVR5cGVGaXh1cE9wdGltRmFjZXRzKHR5cGUpOyAgICAKCmV4aXRfZXJyb3I6CiNpZmRlZiBERUJVR19UWVBFCiAgICB4bWxTY2hlbWFEZWJ1Z0ZpeGVkVHlwZShwY3R4dCwgdHlwZSk7CiNlbmRpZgogICAgaWYgKG9sZGVycnMgIT0gcGN0eHQtPm5iZXJyb3JzKQoJcmV0dXJuKHBjdHh0LT5lcnIpOwogICAgcmV0dXJuKDApOwoKZXhpdF9mYWlsdXJlOgojaWZkZWYgREVCVUdfVFlQRQogICAgeG1sU2NoZW1hRGVidWdGaXhlZFR5cGUocGN0eHQsIHR5cGUpOwojZW5kaWYKICAgIHJldHVybigtMSk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hRml4dXBDb21wbGV4VHlwZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCQkgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZSkKewogICAgaW50IHJlcyA9IDAsIG9sZGVycnMgPSBwY3R4dC0+bmJlcnJvcnM7CiAgICB4bWxTY2hlbWFUeXBlUHRyIGJhc2VUeXBlID0gdHlwZS0+YmFzZVR5cGU7CgogICAgaWYgKCEgV1hTX0lTX1RZUEVfTk9UX0ZJWEVEKHR5cGUpKQoJcmV0dXJuKDApOwogICAgdHlwZS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfVFlQRV9JTlRFUk5BTF9SRVNPTFZFRDsKICAgIGlmIChiYXNlVHlwZSA9PSBOVUxMKSB7CglQRVJST1JfSU5UKCJ4bWxTY2hlbWFGaXh1cENvbXBsZXhUeXBlIiwKCSAgICAibWlzc2luZyBiYXNlVHlwZSIpOwoJZ290byBleGl0X2ZhaWx1cmU7CiAgICB9ICAgIAogICAgLyoKICAgICogRml4dXAgdGhlIGJhc2UgdHlwZS4KICAgICovCiAgICBpZiAoV1hTX0lTX1RZUEVfTk9UX0ZJWEVEKGJhc2VUeXBlKSkKCXhtbFNjaGVtYVR5cGVGaXh1cChiYXNlVHlwZSwgQUNUWFRfQ0FTVCBwY3R4dCk7CiAgICBpZiAoYmFzZVR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9JTlRFUk5BTF9JTlZBTElEKSB7CgkvKgoJKiBTa2lwIGZpeHVwIGlmIHRoZSBiYXNlIHR5cGUgaXMgaW52YWxpZC4KCSogVE9ETzogR2VuZXJhdGUgYSB3YXJuaW5nIQoJKi8KCXJldHVybigwKTsKICAgIH0JCiAgICAvKgogICAgKiBUaGlzIGJhc2ljYWxseSBjaGVja3MgaWYgdGhlIGJhc2UgdHlwZSBjYW4gYmUgZGVyaXZlZC4KICAgICovCiAgICByZXMgPSB4bWxTY2hlbWFDaGVja1NSQ0NUKHBjdHh0LCB0eXBlKTsKICAgIEhGQUlMVVJFIEhFUlJPUiAgIAogICAgLyoKICAgICogRml4dXAgdGhlIGNvbnRlbnQgdHlwZS4KICAgICovCiAgICBpZiAodHlwZS0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRSkgewoJLyoKCSogQ29ycmVzcG9uZHMgdG8gPGNvbXBsZXhUeXBlPjxzaW1wbGVDb250ZW50Pi4uLgoJKi8KCWlmICgoV1hTX0lTX0NPTVBMRVgoYmFzZVR5cGUpKSAmJgoJICAgIChiYXNlVHlwZS0+Y29udGVudFR5cGVEZWYgIT0gTlVMTCkgJiYKCSAgICAoV1hTX0lTX1JFU1RSSUNUSU9OKHR5cGUpKSkgewoJICAgIHhtbFNjaGVtYVR5cGVQdHIgY29udGVudEJhc2UsIGNvbnRlbnQ7CiNpZmRlZiBFTkFCTEVfTkFNRURfTE9DQUxTCgkgICAgY2hhciBidWZbMzBdOwoJICAgIGNvbnN0IHhtbENoYXIgKnRtcG5hbWU7CiNlbmRpZgoJICAgIC8qCgkgICAgKiBTUEVDICgxKSBJZiA8cmVzdHJpY3Rpb24+ICsgYmFzZSB0eXBlIGlzIDxjb21wbGV4VHlwZT4sCgkgICAgKiAid2hvc2Ugb3duIHtjb250ZW50IHR5cGV9IGlzIGEgc2ltcGxlIHR5cGUuLi4iCgkgICAgKi8KCSAgICBpZiAodHlwZS0+Y29udGVudFR5cGVEZWYgIT0gTlVMTCkgewoJCS8qCgkJKiBTUEVDICgxLjEpICJ0aGUgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbiBjb3JyZXNwb25kaW5nIHRvIHRoZQoJCSogPHNpbXBsZVR5cGU+IGFtb25nIHRoZSBbY2hpbGRyZW5dIG9mIDxyZXN0cmljdGlvbj4gaWYgdGhlcmUKCQkqIGlzIG9uZTsiCgkJKiBOb3RlIHRoYXQgdGhpcyAiPHNpbXBsZVR5cGU+IGFtb25nIHRoZSBbY2hpbGRyZW5dIiB3YXMgcHV0CgkJKiBpbnRvIC0+Y29udGVudFR5cGVEZWYgZHVyaW5nIHBhcnNpbmcuCgkJKi8KCQljb250ZW50QmFzZSA9IHR5cGUtPmNvbnRlbnRUeXBlRGVmOwoJCXR5cGUtPmNvbnRlbnRUeXBlRGVmID0gTlVMTDsKCSAgICB9IGVsc2UgewoJCS8qCgkJKiAoMS4yKSAiLi4ub3RoZXJ3aXNlICg8cmVzdHJpY3Rpb24+IGhhcyBubyA8c2ltcGxlVHlwZT4KCQkqIGFtb25nIGl0cyBbY2hpbGRyZW5dKSwgdGhlIHNpbXBsZSB0eXBlIGRlZmluaXRpb24gd2hpY2gKCQkqIGlzIHRoZSB7Y29udGVudCB0eXBlfSBvZiB0aGUgLi4uIGJhc2UgdHlwZS4iCgkJKi8KCQljb250ZW50QmFzZSA9IGJhc2VUeXBlLT5jb250ZW50VHlwZURlZjsKCSAgICB9CgkgICAgLyoKCSAgICAqIFNQRUMKCSAgICAqICIuLi4gYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIHdoaWNoIHJlc3RyaWN0cyB0aGUgc2ltcGxlCgkgICAgKiB0eXBlIGRlZmluaXRpb24gaWRlbnRpZmllZCBpbiBjbGF1c2UgMS4xIG9yIGNsYXVzZSAxLjIKCSAgICAqIHdpdGggYSBzZXQgb2YgZmFjZXQgY29tcG9uZW50cyIKCSAgICAqCgkgICAgKiBDcmVhdGUgdGhlIGFub255bW91cyBzaW1wbGUgdHlwZSwgd2hpY2ggd2lsbCBiZSB0aGUgY29udGVudAoJICAgICogdHlwZSBvZiB0aGUgY29tcGxleCB0eXBlLgoJICAgICovCiNpZmRlZiBFTkFCTEVfTkFNRURfTE9DQUxTCgkgICAgc25wcmludGYoYnVmLCAyOSwgIiNzY1NUJWQiLCArKyhwY3R4dC0+Y291bnRlcikpOwoJICAgIHRtcG5hbWUgPSB4bWxEaWN0TG9va3VwKHBjdHh0LT5kaWN0LCBCQURfQ0FTVCBidWYsIC0xKTsKCSAgICBjb250ZW50ID0geG1sU2NoZW1hQWRkVHlwZShwY3R4dCwgcGN0eHQtPnNjaGVtYSwKCQlYTUxfU0NIRU1BX1RZUEVfU0lNUExFLCB0bXBuYW1lLCB0eXBlLT50YXJnZXROYW1lc3BhY2UsCgkJdHlwZS0+bm9kZSwgMCk7CiNlbHNlCgkgICAgY29udGVudCA9IHhtbFNjaGVtYUFkZFR5cGUocGN0eHQsIHBjdHh0LT5zY2hlbWEsCgkJWE1MX1NDSEVNQV9UWVBFX1NJTVBMRSwgTlVMTCwgdHlwZS0+dGFyZ2V0TmFtZXNwYWNlLAoJCXR5cGUtPm5vZGUsIDApOwojZW5kaWYKCSAgICBpZiAoY29udGVudCA9PSBOVUxMKQoJCWdvdG8gZXhpdF9mYWlsdXJlOwoJICAgIC8qCgkgICAgKiBXZSB3aWxsIHVzZSB0aGUgc2FtZSBub2RlIGFzIGZvciB0aGUgPGNvbXBsZXhUeXBlPgoJICAgICogdG8gaGF2ZSBpdCBzb21laG93IGFuY2hvcmVkIGluIHRoZSBzY2hlbWEgZG9jLgoJICAgICovCgkgICAgY29udGVudC0+dHlwZSA9IFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU7CgkgICAgY29udGVudC0+YmFzZVR5cGUgPSBjb250ZW50QmFzZTsKCSAgICAvKgoJICAgICogTW92ZSB0aGUgZmFjZXRzLCBwcmV2aW91c2x5IGFuY2hvcmVkIG9uIHRoZQoJICAgICogY29tcGxleFR5cGUgZHVyaW5nIHBhcnNpbmcuCgkgICAgKi8KCSAgICBjb250ZW50LT5mYWNldHMgPSB0eXBlLT5mYWNldHM7CgkgICAgdHlwZS0+ZmFjZXRzID0gTlVMTDsKCSAgICBjb250ZW50LT5mYWNldFNldCA9IHR5cGUtPmZhY2V0U2V0OwoJICAgIHR5cGUtPmZhY2V0U2V0ID0gTlVMTDsKCSAgICAKCSAgICB0eXBlLT5jb250ZW50VHlwZURlZiA9IGNvbnRlbnQ7CgkgICAgaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRChjb250ZW50QmFzZSkpCgkJeG1sU2NoZW1hVHlwZUZpeHVwKGNvbnRlbnRCYXNlLCBBQ1RYVF9DQVNUIHBjdHh0KTsKCSAgICAvKgoJICAgICogRml4dXAgdGhlIG5ld2x5IGNyZWF0ZWQgdHlwZS4gV2UgZG9uJ3QgbmVlZCB0byBjaGVjawoJICAgICogZm9yIGNpcmN1bGFyaXR5IGhlcmUuCgkgICAgKi8KCSAgICByZXMgPSB4bWxTY2hlbWFGaXh1cFNpbXBsZVR5cGVTdGFnZU9uZShwY3R4dCwgY29udGVudCk7CgkgICAgSEZBSUxVUkUgSEVSUk9SIAoJICAgIHJlcyA9IHhtbFNjaGVtYUZpeHVwU2ltcGxlVHlwZVN0YWdlVHdvKHBjdHh0LCBjb250ZW50KTsKCSAgICBIRkFJTFVSRSBIRVJST1IgCgkJCgl9IGVsc2UgaWYgKChXWFNfSVNfQ09NUExFWChiYXNlVHlwZSkpICYmCgkgICAgKGJhc2VUeXBlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfTUlYRUQpICYmCgkgICAgKFdYU19JU19SRVNUUklDVElPTih0eXBlKSkpIHsKCSAgICAvKgoJICAgICogU1BFQyAoMikgSWYgPHJlc3RyaWN0aW9uPiArIGJhc2UgaXMgYSBtaXhlZCA8Y29tcGxleFR5cGU+IHdpdGgKCSAgICAqIGFuIGVtcHRpYWJsZSBwYXJ0aWNsZSwgdGhlbiBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24gd2hpY2gKCSAgICAqIHJlc3RyaWN0cyB0aGUgPHJlc3RyaWN0aW9uPidzIDxzaW1wbGVUeXBlPiBjaGlsZC4KCSAgICAqLwoJICAgIGlmICgodHlwZS0+Y29udGVudFR5cGVEZWYgPT0gTlVMTCkgfHwKCQkodHlwZS0+Y29udGVudFR5cGVEZWYtPmJhc2VUeXBlID09IE5VTEwpKSB7CgkJLyoKCQkqIFRPRE86IENoZWNrIGlmIHRoaXMgZXZlciBoYXBwZW5zLgoJCSovCgkJeG1sU2NoZW1hUEN1c3RvbUVycihwY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfSU5URVJOQUwsCgkJICAgIFdYU19CQVNJQ19DQVNUIHR5cGUsIE5VTEwsCgkJICAgICJJbnRlcm5hbCBlcnJvcjogeG1sU2NoZW1hVHlwZUZpeHVwLCAiCgkJICAgICJjb21wbGV4IHR5cGUgJyVzJzogdGhlIDxzaW1wbGVDb250ZW50PjxyZXN0cmljdGlvbj4gIgoJCSAgICAiaXMgbWlzc2luZyBhIDxzaW1wbGVUeXBlPiBjaGlsZCwgYnV0IHdhcyBub3QgY2F0Y2hlZCAiCgkJICAgICJieSB4bWxTY2hlbWFDaGVja1NSQ0NUKCkiLCB0eXBlLT5uYW1lKTsKCQlnb3RvIGV4aXRfZmFpbHVyZTsKCSAgICB9Cgl9IGVsc2UgaWYgKChXWFNfSVNfQ09NUExFWChiYXNlVHlwZSkpICYmIFdYU19JU19FWFRFTlNJT04odHlwZSkpIHsKCSAgICAvKgoJICAgICogU1BFQyAoMykgSWYgPGV4dGVuc2lvbj4gKyBiYXNlIGlzIDxjb21wbGV4VHlwZT4gd2l0aAoJICAgICogPHNpbXBsZVR5cGU+IGNvbnRlbnQsICIuLi50aGVuIHRoZSB7Y29udGVudCB0eXBlfSBvZiB0aGF0CgkgICAgKiBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiIKCSAgICAqLwoJICAgIGlmIChiYXNlVHlwZS0+Y29udGVudFR5cGVEZWYgPT0gTlVMTCkgewoJCS8qCgkJKiBUT0RPOiBDaGVjayBpZiB0aGlzIGV2ZXIgaGFwcGVucy4geG1sU2NoZW1hQ2hlY2tTUkNDVAoJCSogc2hvdWxkIGhhdmUgY2F0Y2hlZCB0aGlzIGFscmVhZHkuCgkJKi8KCQl4bWxTY2hlbWFQQ3VzdG9tRXJyKHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9JTlRFUk5BTCwKCQkgICAgV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkgICAgIkludGVybmFsIGVycm9yOiB4bWxTY2hlbWFUeXBlRml4dXAsICIKCQkgICAgImNvbXBsZXggdHlwZSAnJXMnOiB0aGUgPGV4dGVuc2lvbj5lZCBiYXNlIHR5cGUgaXMgIgoJCSAgICAiYSBjb21wbGV4IHR5cGUgd2l0aCBubyBzaW1wbGUgY29udGVudCB0eXBlIiwKCQkgICAgdHlwZS0+bmFtZSk7CgkJZ290byBleGl0X2ZhaWx1cmU7CgkgICAgfQoJICAgIHR5cGUtPmNvbnRlbnRUeXBlRGVmID0gYmFzZVR5cGUtPmNvbnRlbnRUeXBlRGVmOwoJfSBlbHNlIGlmICgoV1hTX0lTX1NJTVBMRShiYXNlVHlwZSkpICYmIFdYU19JU19FWFRFTlNJT04odHlwZSkpIHsKCSAgICAvKgoJICAgICogU1BFQyAoNCkgPGV4dGVuc2lvbj4gKyBiYXNlIGlzIDxzaW1wbGVUeXBlPgoJICAgICogIi4uLiB0aGVuIHRoYXQgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbiIKCSAgICAqLwoJICAgIHR5cGUtPmNvbnRlbnRUeXBlRGVmID0gYmFzZVR5cGU7Cgl9IGVsc2UgewoJICAgIC8qCgkgICAgKiBUT0RPOiBDaGVjayBpZiB0aGlzIGV2ZXIgaGFwcGVucy4KCSAgICAqLwoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJWE1MX1NDSEVNQVBfSU5URVJOQUwsCgkJV1hTX0JBU0lDX0NBU1QgdHlwZSwgTlVMTCwKCQkiSW50ZXJuYWwgZXJyb3I6IHhtbFNjaGVtYVR5cGVGaXh1cCwgIgoJCSJjb21wbGV4IHR5cGUgJyVzJyB3aXRoIDxzaW1wbGVDb250ZW50PjogdW5oYW5kbGVkICIKCQkiZGVyaXZhdGlvbiBjYXNlIiwgdHlwZS0+bmFtZSk7CgkgICAgZ290byBleGl0X2ZhaWx1cmU7Cgl9CiAgICB9IGVsc2UgewoJaW50IGR1bW15U2VxdWVuY2UgPSAwOwoJeG1sU2NoZW1hUGFydGljbGVQdHIgcGFydGljbGUgPQoJICAgICh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgdHlwZS0+c3VidHlwZXM7CgkvKgoJKiBDb3JyZXNwb25kcyB0byA8Y29tcGxleFR5cGU+PGNvbXBsZXhDb250ZW50Pi4uLgoJKgoJKiBOT1RFIHRoYXQgdGhlIGVmZmVjdGl2ZSBtaXhlZCB3YXMgYWxyZWFkeSBzZXQgZHVyaW5nIHBhcnNpbmcgb2YKCSogPGNvbXBsZXhUeXBlPiBhbmQgPGNvbXBsZXhDb250ZW50PjsgaXRzIGZsYWcgdmFsdWUgaXMKCSogWE1MX1NDSEVNQVNfVFlQRV9NSVhFRC4KCSoKCSogQ29tcHV0ZSB0aGUgImVmZmVjdGl2ZSBjb250ZW50IjoKCSogKDIuMS4xKSArICgyLjEuMikgKyAoMi4xLjMpCgkqLwoJaWYgKChwYXJ0aWNsZSA9PSBOVUxMKSB8fAoJICAgICgocGFydGljbGUtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX1BBUlRJQ0xFKSAmJgoJICAgICgocGFydGljbGUtPmNoaWxkcmVuLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTEwpIHx8CgkgICAgKHBhcnRpY2xlLT5jaGlsZHJlbi0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UpIHx8CgkgICAgKChwYXJ0aWNsZS0+Y2hpbGRyZW4tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NIT0lDRSkgJiYKCSAgICAocGFydGljbGUtPm1pbk9jY3VycyA9PSAwKSkpICYmCgkgICAgKCAoKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSBwYXJ0aWNsZS0+Y2hpbGRyZW4pLT5jaGlsZHJlbiA9PSBOVUxMKSkpIHsKCSAgICBpZiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX01JWEVEKSB7CgkJLyoKCQkqIFNQRUMgKDIuMS40KSAiSWYgdGhlILdlZmZlY3RpdmUgbWl4ZWS3IGlzIHRydWUsIHRoZW4KCQkqIGEgcGFydGljbGUgd2hvc2UgcHJvcGVydGllcyBhcmUgYXMgZm9sbG93czouLi4iCgkJKgoJCSogRW1wdHkgc2VxdWVuY2UgbW9kZWwgZ3JvdXAgd2l0aAoJCSogbWluT2NjdXJzL21heE9jY3VycyA9IDEgKGkuZS4gYSAicGFydGljbGUgZW1wdGlhYmxlIikuCgkJKiBOT1RFIHRoYXQgd2Ugc2lsbCBhc3NpZ24gaXQgdGhlIDxjb21wbGV4VHlwZT4gbm9kZSB0bwoJCSogc29tZWhvdyBhbmNob3IgaXQgaW4gdGhlIGRvYy4KCQkqLwoJCWlmICgocGFydGljbGUgPT0gTlVMTCkgfHwKCQkgICAgKHBhcnRpY2xlLT5jaGlsZHJlbi0+dHlwZSAhPSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UpKSB7CgkJICAgIC8qCgkJICAgICogQ3JlYXRlIHRoZSBwYXJ0aWNsZS4KCQkgICAgKi8KCQkgICAgcGFydGljbGUgPSB4bWxTY2hlbWFBZGRQYXJ0aWNsZShwY3R4dCwgcGN0eHQtPnNjaGVtYSwKCQkJdHlwZS0+bm9kZSwgMSwgMSk7CgkJICAgIGlmIChwYXJ0aWNsZSA9PSBOVUxMKQoJCQlnb3RvIGV4aXRfZmFpbHVyZTsKCQkgICAgLyoKCQkgICAgKiBDcmVhdGUgdGhlIG1vZGVsIGdyb3VwLgoJCSAgICAqLyAvKiBVUkdFTlQgVE9ETzogYXZvaWQgYWRkaW5nIHRvIHBlbmRpbmcgaXRlbXMuICovCgkJICAgIHBhcnRpY2xlLT5jaGlsZHJlbiA9ICh4bWxTY2hlbWFUcmVlSXRlbVB0cikKCQkJeG1sU2NoZW1hQWRkTW9kZWxHcm91cChwY3R4dCwgcGN0eHQtPnNjaGVtYSwKCQkJWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFLCB0eXBlLT5ub2RlKTsKCQkgICAgaWYgKHBhcnRpY2xlLT5jaGlsZHJlbiA9PSBOVUxMKQoJCQlnb3RvIGV4aXRfZmFpbHVyZTsKCQkgICAgCgkJICAgIHR5cGUtPnN1YnR5cGVzID0gKHhtbFNjaGVtYVR5cGVQdHIpIHBhcnRpY2xlOwoJCX0KCQlkdW1teVNlcXVlbmNlID0gMTsKCQl0eXBlLT5jb250ZW50VHlwZSA9IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTEVNRU5UUzsKCSAgICB9IGVsc2UgewoJCS8qCgkJKiBTUEVDICgyLjEuNSkgIm90aGVyd2lzZSBlbXB0eSIKCQkqLwoJCXR5cGUtPmNvbnRlbnRUeXBlID0gWE1MX1NDSEVNQV9DT05URU5UX0VNUFRZOwoJICAgIH0KCX0gZWxzZSB7CgkgICAgLyoKCSAgICAqIFNQRUMgKDIuMikgIm90aGVyd2lzZSB0aGUgcGFydGljbGUgY29ycmVzcG9uZGluZyB0byB0aGUKCSAgICAqIDxhbGw+LCA8Y2hvaWNlPiwgPGdyb3VwPiBvciA8c2VxdWVuY2U+IGFtb25nIHRoZQoJICAgICogW2NoaWxkcmVuXS4iCgkgICAgKi8KCSAgICB0eXBlLT5jb250ZW50VHlwZSA9IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTEVNRU5UUzsKCX0KCS8qCgkqIENvbXB1dGUgdGhlICJjb250ZW50IHR5cGUiLgoJKi8KCWlmIChXWFNfSVNfUkVTVFJJQ1RJT04odHlwZSkpIHsKCSAgICAvKgoJICAgICogU1BFQyAoMy4xKSAiSWYgPHJlc3RyaWN0aW9uPi4uLiIKCSAgICAqICgzLjEuMSkgKyAoMy4xLjIpICovCgkgICAgaWYgKHR5cGUtPmNvbnRlbnRUeXBlICE9IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWSkgewoJCWlmICh0eXBlLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfTUlYRUQpCgkJICAgIHR5cGUtPmNvbnRlbnRUeXBlID0gWE1MX1NDSEVNQV9DT05URU5UX01JWEVEOwoJICAgIH0KCX0gZWxzZSB7CgkgICAgLyoKCSAgICAqIFNQRUMgKDMuMikgIklmIDxleHRlbnNpb24+Li4uIgoJICAgICovCgkgICAgaWYgKHR5cGUtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWSkgewoJCS8qCgkJKiBTUEVDICgzLjIuMSkKCQkqLwoJCXR5cGUtPmNvbnRlbnRUeXBlID0gYmFzZVR5cGUtPmNvbnRlbnRUeXBlOwoJCXR5cGUtPnN1YnR5cGVzID0gYmFzZVR5cGUtPnN1YnR5cGVzOwoJCS8qCgkJKiBOT1RFIHRoYXQgdGhlIGVmZmVjdGl2ZSBtaXhlZCBpcyBpZ25vcmVkIGhlcmUuCgkJKi8KCSAgICB9IGVsc2UgaWYgKGJhc2VUeXBlLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfRU1QVFkpIHsKCQkvKgoJCSogU1BFQyAoMy4yLjIpCgkJKi8KCQlpZiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX01JWEVEKQoJCSAgICB0eXBlLT5jb250ZW50VHlwZSA9IFhNTF9TQ0hFTUFfQ09OVEVOVF9NSVhFRDsKCSAgICB9IGVsc2UgewoJCS8qCgkJKiBTUEVDICgzLjIuMykKCQkqLwoJCWlmICh0eXBlLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfTUlYRUQpCgkJICAgIHR5cGUtPmNvbnRlbnRUeXBlID0gWE1MX1NDSEVNQV9DT05URU5UX01JWEVEOwoJCSAgICAvKgoJCSAgICAqICJBIG1vZGVsIGdyb3VwIHdob3NlIHtjb21wb3NpdG9yfSBpcyBzZXF1ZW5jZSBhbmQgd2hvc2UKCQkgICAgKiB7cGFydGljbGVzfSBhcmUuLi4iCgkJICAgICovCgkJaWYgKChXWFNfVFlQRV9QQVJUSUNMRSh0eXBlKSAhPSBOVUxMKSAmJgoJCSAgICAoV1hTX1RZUEVfUEFSVElDTEVfVEVSTSh0eXBlKSAhPSBOVUxMKSAmJgoJCSAgICAoKFdYU19UWVBFX1BBUlRJQ0xFX1RFUk0odHlwZSkpLT50eXBlID09CgkJCVhNTF9TQ0hFTUFfVFlQRV9BTEwpKQoJCXsKCQkgICAgLyoKCQkgICAgKiBTUEVDIGNvcy1hbGwtbGltaXRlZCAoMSkKCQkgICAgKi8KCQkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJCS8qIFRPRE86IGVycm9yIGNvZGUgKi8KCQkJWE1MX1NDSEVNQVBfQ09TX0FMTF9MSU1JVEVELAoJCQlXWFNfSVRFTV9OT0RFKHR5cGUpLCBOVUxMLAoJCQkiVGhlIHR5cGUgaGFzIGFuICdhbGwnIG1vZGVsIGdyb3VwIGluIGl0cyAiCgkJCSJ7Y29udGVudCB0eXBlfSBhbmQgdGh1cyBjYW5ub3QgYmUgZGVyaXZlZCBmcm9tICIKCQkJImEgbm9uLWVtcHR5IHR5cGUsIHNpbmNlIHRoaXMgd291bGQgcHJvZHVjZSBhICIKCQkJIidzZXF1ZW5jZScgbW9kZWwgZ3JvdXAgY29udGFpbmluZyB0aGUgJ2FsbCcgIgoJCQkibW9kZWwgZ3JvdXA7ICdhbGwnIG1vZGVsIGdyb3VwcyBhcmUgbm90ICIKCQkJImFsbG93ZWQgdG8gYXBwZWFyIGluc2lkZSBvdGhlciBtb2RlbCBncm91cHMiLAoJCQlOVUxMLCBOVUxMKTsKCgkJfSBlbHNlIGlmICgoV1hTX1RZUEVfUEFSVElDTEUoYmFzZVR5cGUpICE9IE5VTEwpICYmCgkJICAgIChXWFNfVFlQRV9QQVJUSUNMRV9URVJNKGJhc2VUeXBlKSAhPSBOVUxMKSAmJgoJCSAgICAoKFdYU19UWVBFX1BBUlRJQ0xFX1RFUk0oYmFzZVR5cGUpKS0+dHlwZSA9PQoJCQlYTUxfU0NIRU1BX1RZUEVfQUxMKSkKCQl7CgkJICAgIC8qCgkJICAgICogU1BFQyBjb3MtYWxsLWxpbWl0ZWQgKDEpCgkJICAgICovCgkJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LAoJCQkvKiBUT0RPOiBlcnJvciBjb2RlICovCgkJCVhNTF9TQ0hFTUFQX0NPU19BTExfTElNSVRFRCwKCQkJV1hTX0lURU1fTk9ERSh0eXBlKSwgTlVMTCwKCQkJIkEgdHlwZSBjYW5ub3QgYmUgZGVyaXZlZCBieSBleHRlbnNpb24gZnJvbSBhIHR5cGUgIgoJCQkid2hpY2ggaGFzIGFuICdhbGwnIG1vZGVsIGdyb3VwIGluIGl0cyAiCgkJCSJ7Y29udGVudCB0eXBlfSwgc2luY2UgdGhpcyB3b3VsZCBwcm9kdWNlIGEgIgoJCQkiJ3NlcXVlbmNlJyBtb2RlbCBncm91cCBjb250YWluaW5nIHRoZSAnYWxsJyAiCgkJCSJtb2RlbCBncm91cDsgJ2FsbCcgbW9kZWwgZ3JvdXBzIGFyZSBub3QgIgoJCQkiYWxsb3dlZCB0byBhcHBlYXIgaW5zaWRlIG90aGVyIG1vZGVsIGdyb3VwcyIsCgkJCU5VTEwsIE5VTEwpOwoKCQl9IGVsc2UgaWYgKCEgZHVtbXlTZXF1ZW5jZSkgewoJCSAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciBlZmZlY3RpdmVDb250ZW50ID0KCQkJKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSB0eXBlLT5zdWJ0eXBlczsKCQkgICAgLyoKCQkgICAgKiBDcmVhdGUgdGhlIHBhcnRpY2xlLgoJCSAgICAqLwoJCSAgICBwYXJ0aWNsZSA9IHhtbFNjaGVtYUFkZFBhcnRpY2xlKHBjdHh0LCBwY3R4dC0+c2NoZW1hLAoJCQl0eXBlLT5ub2RlLCAxLCAxKTsKCQkgICAgaWYgKHBhcnRpY2xlID09IE5VTEwpCgkJCWdvdG8gZXhpdF9mYWlsdXJlOwoJCSAgICAvKgoJCSAgICAqIENyZWF0ZSB0aGUgInNlcXVlbmNlIiBtb2RlbCBncm91cC4KCQkgICAgKi8KCQkgICAgcGFydGljbGUtPmNoaWxkcmVuID0gKHhtbFNjaGVtYVRyZWVJdGVtUHRyKQoJCQl4bWxTY2hlbWFBZGRNb2RlbEdyb3VwKHBjdHh0LCBwY3R4dC0+c2NoZW1hLAoJCQlYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0UsIHR5cGUtPm5vZGUpOwoJCSAgICBpZiAocGFydGljbGUtPmNoaWxkcmVuID09IE5VTEwpCgkJCWdvdG8gZXhpdF9mYWlsdXJlOwoJCSAgICBXWFNfVFlQRV9DT05URU5UVFlQRSh0eXBlKSA9ICh4bWxTY2hlbWFUeXBlUHRyKSBwYXJ0aWNsZTsKCQkgICAgLyoKCQkgICAgKiBTUEVDICJ0aGUgcGFydGljbGUgb2YgdGhlIHtjb250ZW50IHR5cGV9IG9mCgkJICAgICogdGhlIC4uLiBiYXNlIC4uLiIKCQkgICAgKiBDcmVhdGUgYSBkdXBsaWNhdGUgb2YgdGhlIGJhc2UgdHlwZSdzIHBhcnRpY2xlCgkJICAgICogYW5kIGFzc2lnbiBpdHMgInRlcm0iIHRvIGl0LgoJCSAgICAqLwoJCSAgICBwYXJ0aWNsZS0+Y2hpbGRyZW4tPmNoaWxkcmVuID0KCQkJKHhtbFNjaGVtYVRyZWVJdGVtUHRyKSB4bWxTY2hlbWFBZGRQYXJ0aWNsZShwY3R4dCwKCQkJcGN0eHQtPnNjaGVtYSwgdHlwZS0+bm9kZSwKCQkJKCh4bWxTY2hlbWFQYXJ0aWNsZVB0cikgdHlwZS0+c3VidHlwZXMpLT5taW5PY2N1cnMsCgkJCSgoeG1sU2NoZW1hUGFydGljbGVQdHIpIHR5cGUtPnN1YnR5cGVzKS0+bWF4T2NjdXJzKTsKCQkgICAgaWYgKHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW4gPT0gTlVMTCkKCQkJZ290byBleGl0X2ZhaWx1cmU7CgkJICAgIHBhcnRpY2xlID0gKHhtbFNjaGVtYVBhcnRpY2xlUHRyKQoJCQlwYXJ0aWNsZS0+Y2hpbGRyZW4tPmNoaWxkcmVuOwoJCSAgICBwYXJ0aWNsZS0+Y2hpbGRyZW4gPQoJCQkoKHhtbFNjaGVtYVBhcnRpY2xlUHRyKSBiYXNlVHlwZS0+c3VidHlwZXMpLT5jaGlsZHJlbjsKCQkgICAgLyoKCQkgICAgKiBTUEVDICJmb2xsb3dlZCBieSB0aGUgt2VmZmVjdGl2ZSBjb250ZW50ty4iCgkJICAgICovCgkJICAgIHBhcnRpY2xlLT5uZXh0ID0gZWZmZWN0aXZlQ29udGVudDsKCQkgICAgLyoKCQkgICAgKiBUaGlzIGFsbCB3aWxsIHJlc3VsdCBpbjoKCQkgICAgKiBuZXctcGFydGljbGUKCQkgICAgKiAgIC0tPiBuZXctc2VxdWVuY2UoCgkJICAgICogICAgICAgICBuZXctcGFydGljbGUKCQkgICAgKiAgICAgICAgICAgLS0+IGJhc2UtbW9kZWwsCgkJICAgICogICAgICAgICB0aGlzLXBhcnRpY2xlCgkJICAgICoJICAgICAgICAtLT4gdGhpcy1tb2RlbAoJCSAgICAqCSAgICApCgkJICAgICovCgkJfSBlbHNlIHsKCQkgICAgLyoKCQkgICAgKiBUaGlzIGlzIHRoZSBjYXNlIHdoZW4gdGhlcmUgaXMgYWxyZWFkeSBhbiBlbXB0eQoJCSAgICAqIDxzZXF1ZW5jZT4gd2l0aCBtaW5PY2N1cnM9PW1heE9jY3Vycz09MS4KCQkgICAgKiBKdXN0IGFkZCB0aGUgYmFzZSB0eXBlcydzIGNvbnRlbnQgdHlwZS4KCQkgICAgKiBOT1RFIHRoYXQsIGFsdGhvdWdoIHdlIG1pc3MgdG8gYWRkIGFuIGludGVybWVkaWF0ZQoJCSAgICAqIDxzZXF1ZW5jZT4sIHRoaXMgc2hvdWxkIHByb2R1Y2Ugbm8gZGlmZmVyZW5jZSB0bwoJCSAgICAqIG5laXRoZXIgdGhlIHJlZ2V4IGNvbXBpbGF0aW9uIG9mIHRoZSBjb250ZW50IG1vZGVsLAoJCSAgICAqIG5vciB0byB0aGUgY29tcGxleCB0eXBlIGNvbnRyYWludHMuCgkJICAgICovCgkJICAgIHBhcnRpY2xlLT5jaGlsZHJlbi0+Y2hpbGRyZW4gPQoJCQkoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpIGJhc2VUeXBlLT5zdWJ0eXBlczsKCQl9CgkgICAgfQoJfQogICAgfQogICAgLyoKICAgICogTm93IGZpeHVwIGF0dHJpYnV0ZSB1c2VzOgogICAgKiAgIC0gZXhwYW5kIGF0dHIuIGdyb3VwIHJlZmVyZW5jZXMKICAgICogICAgIC0gaW50ZXJzZWN0IGF0dHJpYnV0ZSB3aWxkY2FyZHMKICAgICogICAtIGluaGVyaXQgYXR0cmlidXRlIHVzZXMgb2YgdGhlIGJhc2UgdHlwZQogICAgKiAgIC0gaW5oZXJpdCBvciB1bmlvbiBhdHRyLiB3aWxkY2FyZHMgaWYgZXh0ZW5kaW5nCiAgICAqICAgLSBhcHBseSBhdHRyLiB1c2UgcHJvaGliaXRpb25zIGlmIHJlc3RyaWN0aW5nCiAgICAqLwogICAgcmVzID0geG1sU2NoZW1hRml4dXBUeXBlQXR0cmlidXRlVXNlcyhwY3R4dCwgdHlwZSk7CiAgICBIRkFJTFVSRSBIRVJST1IKICAgIC8qCiAgICAqIEFwcGx5IHRoZSBjb21wbGV4IHR5cGUgY29tcG9uZW50IGNvbnN0cmFpbnRzOyB0aGlzIHdpbGwgbm90CiAgICAqIGNoZWNrIGF0dHJpYnV0ZXMsIHNpbmNlIHRoaXMgaXMgZG9uZSBpbgogICAgKiB4bWxTY2hlbWFGaXh1cFR5cGVBdHRyaWJ1dGVVc2VzKCkuCiAgICAqLwogICAgcmVzID0geG1sU2NoZW1hQ2hlY2tDVENvbXBvbmVudChwY3R4dCwgdHlwZSk7CiAgICBIRkFJTFVSRSBIRVJST1IKCiNpZmRlZiBERUJVR19UWVBFCiAgICB4bWxTY2hlbWFEZWJ1Z0ZpeGVkVHlwZShwY3R4dCwgdHlwZSk7CiNlbmRpZgogICAgaWYgKG9sZGVycnMgIT0gcGN0eHQtPm5iZXJyb3JzKQoJcmV0dXJuKHBjdHh0LT5lcnIpOwogICAgZWxzZQoJcmV0dXJuKDApOwoKZXhpdF9lcnJvcjoKICAgIHR5cGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfSU5URVJOQUxfSU5WQUxJRDsKI2lmZGVmIERFQlVHX1RZUEUKICAgIHhtbFNjaGVtYURlYnVnRml4ZWRUeXBlKHBjdHh0LCB0eXBlKTsKI2VuZGlmCiAgICByZXR1cm4ocGN0eHQtPmVycik7CgpleGl0X2ZhaWx1cmU6CiAgICB0eXBlLT5mbGFncyB8PSBYTUxfU0NIRU1BU19UWVBFX0lOVEVSTkFMX0lOVkFMSUQ7CiNpZmRlZiBERUJVR19UWVBFCiAgICB4bWxTY2hlbWFEZWJ1Z0ZpeGVkVHlwZShwY3R4dCwgdHlwZSk7CiNlbmRpZgogICAgcmV0dXJuKC0xKTsKfQoKCi8qKgogKiB4bWxTY2hlbWFUeXBlRml4dXA6CiAqIEB0eXBlRGVjbDogIHRoZSBzY2hlbWEgdHlwZSBkZWZpbml0aW9uCiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKgogKiBGaXhlcyB0aGUgY29udGVudCBtb2RlbCBvZiB0aGUgdHlwZS4KICogVVJHRU5UIFRPRE86IFdlIG5lZWQgYW4gaW50IHJlc3VsdCEKICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hVHlwZUZpeHVwKHhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCkKewogICAgaWYgKHR5cGUgPT0gTlVMTCkKICAgICAgICByZXR1cm4oMCk7CiAgICBpZiAoYWN0eHQtPnR5cGUgIT0gWE1MX1NDSEVNQV9DVFhUX1BBUlNFUikgewoJQUVSUk9SX0lOVCgieG1sU2NoZW1hVHlwZUZpeHVwIiwKCSAgICAidGhpcyBmdW5jdGlvbiBuZWVkcyBhIHBhcnNlciBjb250ZXh0Iik7CglyZXR1cm4oLTEpOwogICAgfQogICAgaWYgKCEgV1hTX0lTX1RZUEVfTk9UX0ZJWEVEKHR5cGUpKQoJcmV0dXJuKDApOwogICAgaWYgKHR5cGUtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVgpCglyZXR1cm4oeG1sU2NoZW1hRml4dXBDb21wbGV4VHlwZShQQ1RYVF9DQVNUIGFjdHh0LCB0eXBlKSk7CiAgICBlbHNlIGlmICh0eXBlLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUpCglyZXR1cm4oeG1sU2NoZW1hRml4dXBTaW1wbGVUeXBlU3RhZ2VUd28oUENUWFRfQ0FTVCBhY3R4dCwgdHlwZSkpOwogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tGYWNldDoKICogQGZhY2V0OiAgdGhlIGZhY2V0CiAqIEB0eXBlRGVjbDogIHRoZSBzY2hlbWEgdHlwZSBkZWZpbml0aW9uCiAqIEBwY3R4dDogIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQgb3IgTlVMTAogKiBAbmFtZTogdGhlIG9wdGlvbmFsIG5hbWUgb2YgdGhlIHR5cGUKICoKICogQ2hlY2tzIGFuZCBjb21wdXRlcyB0aGUgdmFsdWVzIG9mIGZhY2V0cy4KICoKICogUmV0dXJucyAwIGlmIHZhbGlkLCBhIHBvc2l0aXZlIGVycm9yIGNvZGUgaWYgbm90IHZhbGlkIGFuZAogKiAgICAgICAgIC0xIGluIGNhc2Ugb2YgYW4gaW50ZXJuYWwgb3IgQVBJIGVycm9yLgogKi8KaW50CnhtbFNjaGVtYUNoZWNrRmFjZXQoeG1sU2NoZW1hRmFjZXRQdHIgZmFjZXQsCiAgICAgICAgICAgICAgICAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlRGVjbCwKICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0LAoJCSAgICBjb25zdCB4bWxDaGFyICogbmFtZSBBVFRSSUJVVEVfVU5VU0VEKQp7CiAgICBpbnQgcmV0ID0gMCwgY3R4dEdpdmVuOwoKICAgIGlmICgoZmFjZXQgPT0gTlVMTCkgfHwgKHR5cGVEZWNsID09IE5VTEwpKQogICAgICAgIHJldHVybigtMSk7CiAgICAvKgogICAgKiBUT0RPOiB3aWxsIHRoZSBwYXJzZXIgY29udGV4dCBiZSBnaXZlbiBpZiB1c2VkIGZyb20KICAgICogdGhlIHJlbGF4TkcgbW9kdWxlPwogICAgKi8KICAgIGlmIChwY3R4dCA9PSBOVUxMKQoJY3R4dEdpdmVuID0gMDsKICAgIGVsc2UKCWN0eHRHaXZlbiA9IDE7CgogICAgc3dpdGNoIChmYWNldC0+dHlwZSkgewogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NSU5JTkNMVVNJVkU6CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkVYQ0xVU0lWRToKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYSU5DTFVTSVZFOgogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9NQVhFWENMVVNJVkU6CgljYXNlIFhNTF9TQ0hFTUFfRkFDRVRfRU5VTUVSQVRJT046IHsKICAgICAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAgICAgKiBPa2F5IHdlIG5lZWQgdG8gdmFsaWRhdGUgdGhlIHZhbHVlCiAgICAgICAgICAgICAgICAgKiBhdCB0aGF0IHBvaW50LgogICAgICAgICAgICAgICAgICovCgkJeG1sU2NoZW1hVHlwZVB0ciBiYXNlOwoKCQkvKiA0LjMuNS41IENvbnN0cmFpbnRzIG9uIGVudW1lcmF0aW9uIFNjaGVtYSBDb21wb25lbnRzCgkJKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IGVudW1lcmF0aW9uIHZhbGlkIHJlc3RyaWN0aW9uCgkJKiBJdCBpcyBhbiC3ZXJyb3K3IGlmIGFueSBtZW1iZXIgb2Yge3ZhbHVlfSBpcyBub3QgaW4gdGhlCgkJKiC3dmFsdWUgc3BhY2W3IG9mIHtiYXNlIHR5cGUgZGVmaW5pdGlvbn0uCgkJKgoJCSogbWluSW5jbHVzaXZlLCBtYXhJbmNsdXNpdmUsIG1pbkV4Y2x1c2l2ZSwgbWF4RXhjbHVzaXZlOgoJCSogVGhlIHZhbHVlILdtdXN0tyBiZSBpbiB0aGUKCQkqILd2YWx1ZSBzcGFjZbcgb2YgdGhlILdiYXNlIHR5cGW3LgoJCSovCgkJLyoKCQkqIFRoaXMgZnVuY3Rpb24gaXMgaW50ZW5kZWQgdG8gZGVsaXZlciBhIGNvbXBpbGVkIHZhbHVlCgkJKiBvbiB0aGUgZmFjZXQuIEluIHRoaXMgaW1wbGVtZW50YXRpb24gb2YgWE1MIFNjaGVtYXRhIHRoZQoJCSogdHlwZSBob2xkaW5nIGEgZmFjZXQsIHdvbid0IGJlIGEgYnVpbHQtaW4gdHlwZS4KCQkqIFRodXMgdG8gZW5zdXJlIHRoYXQgb3RoZXIgQVBJCgkJKiBjYWxscyAocmVsYXhuZykgZG8gd29yaywgaWYgdGhlIGdpdmVuIHR5cGUgaXMgYSBidWlsdC1pbgoJCSogdHlwZSwgd2Ugd2lsbCBhc3N1bWUgdGhhdCB0aGUgZ2l2ZW4gYnVpbHQtaW4gdHlwZSAqaXMKCQkqIGFscmVhZHkqIHRoZSBiYXNlIHR5cGUuCgkJKi8KCQlpZiAodHlwZURlY2wtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKSB7CgkJICAgIGJhc2UgPSB0eXBlRGVjbC0+YmFzZVR5cGU7CgkJICAgIGlmIChiYXNlID09IE5VTEwpIHsKCQkJUEVSUk9SX0lOVCgieG1sU2NoZW1hQ2hlY2tGYWNldCIsCgkJCSAgICAiYSB0eXBlIHVzZXIgZGVyaXZlZCB0eXBlIGhhcyBubyBiYXNlIHR5cGUiKTsKCQkJcmV0dXJuICgtMSk7CgkJICAgIH0KCQl9IGVsc2UKCQkgICAgYmFzZSA9IHR5cGVEZWNsOwoJICAgICAgICAgICAgICAgICAKCQlpZiAoISBjdHh0R2l2ZW4pIHsKCQkgICAgLyoKCQkgICAgKiBBIGNvbnRleHQgaXMgbmVlZGVkIGlmIGNhbGxlZCBmcm9tIFJlbGF4TkcuCgkJICAgICovCQkgICAgCgkJICAgIHBjdHh0ID0geG1sU2NoZW1hTmV3UGFyc2VyQ3R4dCgiKiIpOwoJCSAgICBpZiAocGN0eHQgPT0gTlVMTCkKCQkJcmV0dXJuICgtMSk7CgkJfQoJCS8qCgkJKiBOT1RFOiBUaGlzIGNhbGwgZG9lcyBub3QgY2hlY2sgdGhlIGNvbnRlbnQgbm9kZXMsCgkJKiBzaW5jZSB0aGV5IGFyZSBub3QgYXZhaWxhYmxlOgoJCSogZmFjZXQtPm5vZGUgaXMganVzdCB0aGUgbm9kZSBob2xkaW5nIHRoZSBmYWNldAoJCSogZGVmaW5pdGlvbiwgKm5vdCogdGhlIGF0dHJpYnV0ZSBob2xkaW5nIHRoZSAqdmFsdWUqCgkJKiBvZiB0aGUgZmFjZXQuCgkJKi8JCQoJCXJldCA9IHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoCgkJICAgIEFDVFhUX0NBU1QgcGN0eHQsIGZhY2V0LT5ub2RlLCBiYXNlLAoJCSAgICBmYWNldC0+dmFsdWUsICYoZmFjZXQtPnZhbCksIDEsIDEsIDApOwogICAgICAgICAgICAgICAgaWYgKHJldCAhPSAwKSB7CgkJICAgIGlmIChyZXQgPCAwKSB7CgkJCS8qIE5vIGVycm9yIG1lc3NhZ2UgZm9yIFJlbGF4TkcuICovCgkJCWlmIChjdHh0R2l2ZW4pIHsJCQkgICAgCgkJCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQkJCVhNTF9TQ0hFTUFQX0lOVEVSTkFMLCBmYWNldC0+bm9kZSwgTlVMTCwKCQkJCSJJbnRlcm5hbCBlcnJvcjogeG1sU2NoZW1hQ2hlY2tGYWNldCwgIiAKCQkJCSJmYWlsZWQgdG8gdmFsaWRhdGUgdGhlIHZhbHVlICclcycgb2YgdGhlICIKCQkJCSJmYWNldCAnJXMnIGFnYWluc3QgdGhlIGJhc2UgdHlwZSIsCgkJCQlmYWNldC0+dmFsdWUsIHhtbFNjaGVtYUZhY2V0VHlwZVRvU3RyaW5nKGZhY2V0LT50eXBlKSk7CgkJCX0KCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkgICAgfQoJCSAgICByZXQgPSBYTUxfU0NIRU1BUF9JTlZBTElEX0ZBQ0VUX1ZBTFVFOwoJCSAgICAvKiBObyBlcnJvciBtZXNzYWdlIGZvciBSZWxheE5HLiAqLwoJCSAgICBpZiAoY3R4dEdpdmVuKSB7CgkJCXhtbENoYXIgKnN0ciA9IE5VTEw7CgoJCQl4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQkJICAgIHJldCwgZmFjZXQtPm5vZGUsIFdYU19CQVNJQ19DQVNUIGZhY2V0LAoJCQkgICAgIlRoZSB2YWx1ZSAnJXMnIG9mIHRoZSBmYWNldCBkb2VzIG5vdCB2YWxpZGF0ZSAiCgkJCSAgICAiYWdhaW5zdCB0aGUgYmFzZSB0eXBlICclcyciLAoJCQkgICAgZmFjZXQtPnZhbHVlLAoJCQkgICAgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwKCQkJCWJhc2UtPnRhcmdldE5hbWVzcGFjZSwgYmFzZS0+bmFtZSkpOwoJCQlGUkVFX0FORF9OVUxMKHN0cik7CgkJICAgIH0KCQkgICAgZ290byBleGl0OwogICAgICAgICAgICAgICAgfSBlbHNlIGlmIChmYWNldC0+dmFsID09IE5VTEwpIHsKCQkgICAgaWYgKGN0eHRHaXZlbikgewoJCQlQRVJST1JfSU5UKCJ4bWxTY2hlbWFDaGVja0ZhY2V0IiwKCQkJICAgICJ2YWx1ZSB3YXMgbm90IGNvbXB1dGVkIik7CgkJICAgIH0KCQkgICAgVE9ETwoJCX0KICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk46CiAgICAgICAgICAgIGZhY2V0LT5yZWdleHAgPSB4bWxSZWdleHBDb21waWxlKGZhY2V0LT52YWx1ZSk7CiAgICAgICAgICAgIGlmIChmYWNldC0+cmVnZXhwID09IE5VTEwpIHsKCQlyZXQgPSBYTUxfU0NIRU1BUF9SRUdFWFBfSU5WQUxJRDsKCQkvKiBObyBlcnJvciBtZXNzYWdlIGZvciBSZWxheE5HLiAqLwoJCWlmIChjdHh0R2l2ZW4pIHsKCQkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJCXJldCwgZmFjZXQtPm5vZGUsIFdYU19CQVNJQ19DQVNUIHR5cGVEZWNsLAoJCQkiVGhlIHZhbHVlICclcycgb2YgdGhlIGZhY2V0ICdwYXR0ZXJuJyBpcyBub3QgYSAiCgkJCSJ2YWxpZCByZWd1bGFyIGV4cHJlc3Npb24iLAoJCQlmYWNldC0+dmFsdWUsIE5VTEwpOwoJCX0KICAgICAgICAgICAgfQogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfVE9UQUxESUdJVFM6CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0ZSQUNUSU9ORElHSVRTOgogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9MRU5HVEg6CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01BWExFTkdUSDoKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlOTEVOR1RIOgoKCSAgICBpZiAoZmFjZXQtPnR5cGUgPT0gWE1MX1NDSEVNQV9GQUNFVF9UT1RBTERJR0lUUykgewoJCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlUHJlZGVmaW5lZFR5cGUoCgkJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX1BJTlRFR0VSKSwKCQkgICAgZmFjZXQtPnZhbHVlLCAmKGZhY2V0LT52YWwpKTsKCSAgICB9IGVsc2UgewoJCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlUHJlZGVmaW5lZFR5cGUoCgkJICAgIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX05OSU5URUdFUiksCgkJICAgIGZhY2V0LT52YWx1ZSwgJihmYWNldC0+dmFsKSk7CgkgICAgfQoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPCAwKSB7CgkJICAgIC8qIE5vIGVycm9yIG1lc3NhZ2UgZm9yIFJlbGF4TkcuICovCgkJICAgIGlmIChjdHh0R2l2ZW4pIHsKCQkJUEVSUk9SX0lOVCgieG1sU2NoZW1hQ2hlY2tGYWNldCIsCgkJCSAgICAidmFsaWRhdGluZyBmYWNldCB2YWx1ZSIpOwoJCSAgICB9CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJCXJldCA9IFhNTF9TQ0hFTUFQX0lOVkFMSURfRkFDRVRfVkFMVUU7CgkJLyogTm8gZXJyb3IgbWVzc2FnZSBmb3IgUmVsYXhORy4gKi8KCQlpZiAoY3R4dEdpdmVuKSB7CgkJICAgIC8qIGVycm9yIGNvZGUgKi8KCQkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyNChBQ1RYVF9DQVNUIHBjdHh0LAoJCQlyZXQsIGZhY2V0LT5ub2RlLCBXWFNfQkFTSUNfQ0FTVCB0eXBlRGVjbCwKCQkJIlRoZSB2YWx1ZSAnJXMnIG9mIHRoZSBmYWNldCAnJXMnIGlzIG5vdCBhIHZhbGlkICclcyciLAkJCQoJCQlmYWNldC0+dmFsdWUsCgkJCXhtbFNjaGVtYUZhY2V0VHlwZVRvU3RyaW5nKGZhY2V0LT50eXBlKSwKCQkJKGZhY2V0LT50eXBlICE9IFhNTF9TQ0hFTUFfRkFDRVRfVE9UQUxESUdJVFMpID8gCgkJCSAgICBCQURfQ0FTVCAibm9uTmVnYXRpdmVJbnRlZ2VyIiA6CgkJCSAgICBCQURfQ0FTVCAicG9zaXRpdmVJbnRlZ2VyIiwKCQkJTlVMTCk7CgkJfQoJICAgIH0KCSAgICBicmVhazsKICAgICAgICAgICAgCiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1dISVRFU1BBQ0U6ewogICAgICAgICAgICAgICAgaWYgKHhtbFN0ckVxdWFsKGZhY2V0LT52YWx1ZSwgQkFEX0NBU1QgInByZXNlcnZlIikpIHsKICAgICAgICAgICAgICAgICAgICBmYWNldC0+d2hpdGVzcGFjZSA9IFhNTF9TQ0hFTUFTX0ZBQ0VUX1BSRVNFUlZFOwogICAgICAgICAgICAgICAgfSBlbHNlIGlmICh4bWxTdHJFcXVhbChmYWNldC0+dmFsdWUsIEJBRF9DQVNUICJyZXBsYWNlIikpIHsKICAgICAgICAgICAgICAgICAgICBmYWNldC0+d2hpdGVzcGFjZSA9IFhNTF9TQ0hFTUFTX0ZBQ0VUX1JFUExBQ0U7CiAgICAgICAgICAgICAgICB9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGZhY2V0LT52YWx1ZSwgQkFEX0NBU1QgImNvbGxhcHNlIikpIHsKICAgICAgICAgICAgICAgICAgICBmYWNldC0+d2hpdGVzcGFjZSA9IFhNTF9TQ0hFTUFTX0ZBQ0VUX0NPTExBUFNFOwogICAgICAgICAgICAgICAgfSBlbHNlIHsKCQkgICAgcmV0ID0gWE1MX1NDSEVNQVBfSU5WQUxJRF9GQUNFVF9WQUxVRTsKICAgICAgICAgICAgICAgICAgICAvKiBObyBlcnJvciBtZXNzYWdlIGZvciBSZWxheE5HLiAqLwoJCSAgICBpZiAoY3R4dEdpdmVuKSB7CgkJCS8qIGVycm9yIHdhcyBwcmV2aW91c2x5OiBYTUxfU0NIRU1BUF9JTlZBTElEX1dISVRFX1NQQUNFICovCgkJCXhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LAoJCQkgICAgcmV0LCBmYWNldC0+bm9kZSwgV1hTX0JBU0lDX0NBU1QgdHlwZURlY2wsCgkJCSAgICAiVGhlIHZhbHVlICclcycgb2YgdGhlIGZhY2V0ICd3aGl0ZXNwYWNlJyBpcyBub3QgIgoJCQkgICAgInZhbGlkIiwgZmFjZXQtPnZhbHVlLCBOVUxMKTsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICBicmVhazsKICAgIH0KZXhpdDoKICAgIGlmICgoISBjdHh0R2l2ZW4pICYmIChwY3R4dCAhPSBOVUxMKSkKCXhtbFNjaGVtYUZyZWVQYXJzZXJDdHh0KHBjdHh0KTsKICAgIHJldHVybiAocmV0KTsKaW50ZXJuYWxfZXJyb3I6CiAgICBpZiAoKCEgY3R4dEdpdmVuKSAmJiAocGN0eHQgIT0gTlVMTCkpCgl4bWxTY2hlbWFGcmVlUGFyc2VyQ3R4dChwY3R4dCk7CiAgICByZXR1cm4gKC0xKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrRmFjZXRWYWx1ZXM6CiAqIEB0eXBlRGVjbDogIHRoZSBzY2hlbWEgdHlwZSBkZWZpbml0aW9uCiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKgogKiBDaGVja3MgdGhlIGRlZmF1bHQgdmFsdWVzIHR5cGVzLCBlc3BlY2lhbGx5IGZvciBmYWNldHMKICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tGYWNldFZhbHVlcyh4bWxTY2hlbWFUeXBlUHRyIHR5cGVEZWNsLAoJCQkgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQpCnsKICAgIGludCByZXMsIG9sZGVycnMgPSBwY3R4dC0+bmJlcnJvcnM7CiAgICBjb25zdCB4bWxDaGFyICpuYW1lID0gdHlwZURlY2wtPm5hbWU7CiAgICAvKgogICAgKiBOT1RFOiBJdCBpcyBpbnRlbmRlZCB0byB1c2UgdGhlIGZhY2V0cyBsaXN0LCBpbnN0ZWFkCiAgICAqIG9mIGZhY2V0U2V0LgogICAgKi8KICAgIGlmICh0eXBlRGVjbC0+ZmFjZXRzICE9IE5VTEwpIHsKCXhtbFNjaGVtYUZhY2V0UHRyIGZhY2V0ID0gdHlwZURlY2wtPmZhY2V0czsKCgkvKgoJKiBUZW1wb3JhcmlseSBhc3NpZ24gdGhlICJzY2hlbWEiIHRvIHRoZSB2YWxpZGF0aW9uIGNvbnRleHQKCSogb2YgdGhlIHBhcnNlciBjb250ZXh0LiBUaGlzIGlzIG5lZWRlZCBmb3IgTk9UQVRJT04gdmFsaWRhdGlvbi4KCSovCglpZiAocGN0eHQtPnZjdHh0ID09IE5VTEwpIHsKCSAgICBpZiAoeG1sU2NoZW1hQ3JlYXRlVkN0eHRPblBDdHh0KHBjdHh0KSA9PSAtMSkKCQlyZXR1cm4oLTEpOwoJfQoJcGN0eHQtPnZjdHh0LT5zY2hlbWEgPSBwY3R4dC0+c2NoZW1hOwoJd2hpbGUgKGZhY2V0ICE9IE5VTEwpIHsKCSAgICByZXMgPSB4bWxTY2hlbWFDaGVja0ZhY2V0KGZhY2V0LCB0eXBlRGVjbCwgcGN0eHQsIG5hbWUpOwoJICAgIEhGQUlMVVJFCgkgICAgZmFjZXQgPSBmYWNldC0+bmV4dDsKCX0KCXBjdHh0LT52Y3R4dC0+c2NoZW1hID0gTlVMTDsKICAgIH0KICAgIGlmIChvbGRlcnJzICE9IHBjdHh0LT5uYmVycm9ycykKCXJldHVybihwY3R4dC0+ZXJyKTsKICAgIHJldHVybigwKTsKZXhpdF9mYWlsdXJlOgogICAgcmV0dXJuKC0xKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUdldENpcmNNb2RlbEdyRGVmUmVmOgogKiBAY3R4dE1Hcm91cDogdGhlIHNlYXJjaGVkIG1vZGVsIGdyb3VwCiAqIEBzZWxmTUdyb3VwOiB0aGUgc2Vjb25kIHNlYXJjaGVkIG1vZGVsIGdyb3VwCiAqIEBwYXJ0aWNsZTogdGhlIGZpcnN0IHBhcnRpY2xlCiAqCiAqIFRoaXMgb25lIGlzIGludGVuZGVkIHRvIGJlIHVzZWQgYnkKICogeG1sU2NoZW1hQ2hlY2tHcm91cERlZkNpcmN1bGFyIG9ubHkuCiAqCiAqIFJldHVybnMgdGhlIHBhcnRpY2xlIHdpdGggdGhlIGNpcmN1bGFyIG1vZGVsIGdyb3VwIGRlZmluaXRpb24gcmVmZXJlbmNlLAogKiBvdGhlcndpc2UgTlVMTC4KICovCnN0YXRpYyB4bWxTY2hlbWFUcmVlSXRlbVB0cgp4bWxTY2hlbWFHZXRDaXJjTW9kZWxHckRlZlJlZih4bWxTY2hlbWFNb2RlbEdyb3VwRGVmUHRyIGdyb3VwRGVmLAoJCQkgICAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciBwYXJ0aWNsZSkKewogICAgeG1sU2NoZW1hVHJlZUl0ZW1QdHIgY2lyYyA9IE5VTEw7CiAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciB0ZXJtOwogICAgeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0ciBnZGVmOwoKICAgIGZvciAoOyBwYXJ0aWNsZSAhPSBOVUxMOyBwYXJ0aWNsZSA9IHBhcnRpY2xlLT5uZXh0KSB7Cgl0ZXJtID0gcGFydGljbGUtPmNoaWxkcmVuOwoJaWYgKHRlcm0gPT0gTlVMTCkKCSAgICBjb250aW51ZTsKCXN3aXRjaCAodGVybS0+dHlwZSkgewoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOgoJCWdkZWYgPSAoeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cikgdGVybTsKCQlpZiAoZ2RlZiA9PSBncm91cERlZikKCQkgICAgcmV0dXJuIChwYXJ0aWNsZSk7CgkJLyoKCQkqIE1hcmsgdGhpcyBtb2RlbCBncm91cCBkZWZpbml0aW9uIHRvIGF2b2lkIGluZmluaXRlCgkJKiByZWN1cnNpb24gb24gY2lyY3VsYXIgcmVmZXJlbmNlcyBub3QgeWV0IGV4YW1pbmVkLgoJCSovCgkJaWYgKGdkZWYtPmZsYWdzICYgWE1MX1NDSEVNQV9NT0RFTF9HUk9VUF9ERUZfTUFSS0VEKQoJCSAgICBjb250aW51ZTsKCQlpZiAoZ2RlZi0+Y2hpbGRyZW4gIT0gTlVMTCkgewoJCSAgICBnZGVmLT5mbGFncyB8PSBYTUxfU0NIRU1BX01PREVMX0dST1VQX0RFRl9NQVJLRUQ7CgkJICAgIGNpcmMgPSB4bWxTY2hlbWFHZXRDaXJjTW9kZWxHckRlZlJlZihncm91cERlZiwKCQkJZ2RlZi0+Y2hpbGRyZW4tPmNoaWxkcmVuKTsKCQkgICAgZ2RlZi0+ZmxhZ3MgXj0gWE1MX1NDSEVNQV9NT0RFTF9HUk9VUF9ERUZfTUFSS0VEOwoJCSAgICBpZiAoY2lyYyAhPSBOVUxMKQoJCQlyZXR1cm4gKGNpcmMpOwoJCX0KCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TRVFVRU5DRToKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9DSE9JQ0U6CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQUxMOgoJCWNpcmMgPSB4bWxTY2hlbWFHZXRDaXJjTW9kZWxHckRlZlJlZihncm91cERlZiwgdGVybS0+Y2hpbGRyZW4pOwoJCWlmIChjaXJjICE9IE5VTEwpCgkJICAgIHJldHVybiAoY2lyYyk7CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlicmVhazsKCX0KICAgIH0KICAgIHJldHVybiAoTlVMTCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0dyb3VwRGVmQ2lyY3VsYXI6CiAqIEBpdGVtOiAgdGhlIG1vZGVsIGdyb3VwIGRlZmluaXRpb24KICogQGN0eHQ6ICB0aGUgcGFyc2VyIGNvbnRleHQKICogQG5hbWU6ICB0aGUgbmFtZQogKgogKiBDaGVja3MgZm9yIGNpcmN1bGFyIHJlZmVyZW5jZXMgdG8gbW9kZWwgZ3JvdXAgZGVmaW5pdGlvbnMuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDaGVja0dyb3VwRGVmQ2lyY3VsYXIoeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0ciBpdGVtLAoJCQkgICAgICAgeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0KQp7CiAgICAvKgogICAgKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6IE1vZGVsIEdyb3VwIENvcnJlY3QKICAgICogMiBDaXJjdWxhciBncm91cHMgYXJlIGRpc2FsbG93ZWQuIFRoYXQgaXMsIHdpdGhpbiB0aGUge3BhcnRpY2xlc30KICAgICogb2YgYSBncm91cCB0aGVyZSBtdXN0IG5vdCBiZSBhdCBhbnkgZGVwdGggYSBwYXJ0aWNsZSB3aG9zZSB7dGVybX0KICAgICogaXMgdGhlIGdyb3VwIGl0c2VsZi4KICAgICovCiAgICBpZiAoKGl0ZW0gPT0gTlVMTCkgfHwKCShpdGVtLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9HUk9VUCkgfHwKCShpdGVtLT5jaGlsZHJlbiA9PSBOVUxMKSkKCXJldHVybjsKICAgIHsKCXhtbFNjaGVtYVRyZWVJdGVtUHRyIGNpcmM7CgoJY2lyYyA9IHhtbFNjaGVtYUdldENpcmNNb2RlbEdyRGVmUmVmKGl0ZW0sIGl0ZW0tPmNoaWxkcmVuLT5jaGlsZHJlbik7CglpZiAoY2lyYyAhPSBOVUxMKSB7CgkgICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCSAgICAvKgoJICAgICogVE9ETzogVGhlIGVycm9yIHJlcG9ydCBpcyBub3QgYWRlcXVhdGU6IHRoaXMgY29uc3RyYWludAoJICAgICogaXMgZGVmaW5lZCBmb3IgbW9kZWwgZ3JvdXBzIGJ1dCBub3QgZGVmaW5pdGlvbnMsIGJ1dCBzaW5jZQoJICAgICogdGhlcmUgY2Fubm90IGJlIGFueSBjaXJjdWxhciBtb2RlbCBncm91cHMgd2l0aG91dCBhIG1vZGVsIGdyb3VwCgkgICAgKiBkZWZpbml0aW9uIChpZiBub3QgdXNpbmcgYSBjb25zdHJ1Y3Rpb24gQVBJKSwgd2UgY2hlY2sgdGhvc2UKCSAgICAqIGRlZmludGlvbnMgb25seS4KCSAgICAqLwoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9NR19QUk9QU19DT1JSRUNUXzIsCgkJTlVMTCwgV1hTX0lURU1fTk9ERShjaXJjKSwKCQkiQ2lyY3VsYXIgcmVmZXJlbmNlIHRvIHRoZSBtb2RlbCBncm91cCBkZWZpbml0aW9uICclcycgIgoJCSJkZWZpbmVkIiwgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwKCQkgICAgaXRlbS0+dGFyZ2V0TmFtZXNwYWNlLCBpdGVtLT5uYW1lKSk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHIpCgkgICAgLyoKCSAgICAqIE5PVEU6IFdlIHdpbGwgY3V0IHRoZSByZWZlcmVuY2UgdG8gYXZvaWQgZnVydGhlcgoJICAgICogY29uZnVzaW9uIG9mIHRoZSBwcm9jZXNzb3IuIFRoaXMgaXMgYSBmYXRhbCBlcnJvci4KCSAgICAqLwoJICAgIGNpcmMtPmNoaWxkcmVuID0gTlVMTDsKCX0KICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYU1vZGVsR3JvdXBUb01vZGVsR3JvdXBEZWZGaXh1cDoKICogQGN0eHQ6ICB0aGUgcGFyc2VyIGNvbnRleHQKICogQG1nOiAgdGhlIG1vZGVsIGdyb3VwCiAqCiAqIEFzc2lnbnMgdGhlIG1vZGVsIGdyb3VwIG9mIG1vZGVsIGdyb3VwIGRlZmluaXRpb25zIHRvIHRoZSAidGVybSIKICogb2YgdGhlIHJlZmVyZW5jaW5nIHBhcnRpY2xlLgogKiBJbiB4bWxTY2hlbWFSZXNvbHZlTW9kZWxHcm91cFBhcnRpY2xlUmVmZXJlbmNlcyB0aGUgbW9kZWwgZ3JvdXAKICogZGVmaW5pdGlvbnMgd2VyZSBhc3NpZ25lZCB0byB0aGUgInRlcm0iLCBzaW5jZSBuZWVkZWQgZm9yIHRoZQogKiBjaXJjdWxhcml0eSBjaGVjay4KICoKICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OgogKiAgICAgQWxsIEdyb3VwIExpbWl0ZWQgKGNvcy1hbGwtbGltaXRlZCkgKDEuMikKICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYU1vZGVsR3JvdXBUb01vZGVsR3JvdXBEZWZGaXh1cCgKICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCBBVFRSSUJVVEVfVU5VU0VELAogICAgeG1sU2NoZW1hTW9kZWxHcm91cFB0ciBtZykKewogICAgeG1sU2NoZW1hUGFydGljbGVQdHIgcGFydGljbGUgPSBXWFNfTU9ERUxHUk9VUF9QQVJUSUNMRShtZyk7CgogICAgd2hpbGUgKHBhcnRpY2xlICE9IE5VTEwpIHsKCWlmICgoV1hTX1BBUlRJQ0xFX1RFUk0ocGFydGljbGUpID09IE5VTEwpIHx8CgkgICAgKChXWFNfUEFSVElDTEVfVEVSTShwYXJ0aWNsZSkpLT50eXBlICE9CgkJWE1MX1NDSEVNQV9UWVBFX0dST1VQKSkKCXsKCSAgICBwYXJ0aWNsZSA9IFdYU19QVENfQ0FTVCBwYXJ0aWNsZS0+bmV4dDsKCSAgICBjb250aW51ZTsKCX0gCglpZiAoV1hTX01PREVMR1JPVVBERUZfTU9ERUwoV1hTX1BBUlRJQ0xFX1RFUk0ocGFydGljbGUpKSA9PSBOVUxMKSB7CgkgICAgLyoKCSAgICAqIFRPRE86IFJlbW92ZSB0aGUgcGFydGljbGUuCgkgICAgKi8KCSAgICBXWFNfUEFSVElDTEVfVEVSTShwYXJ0aWNsZSkgPSBOVUxMOwoJICAgIHBhcnRpY2xlID0gV1hTX1BUQ19DQVNUIHBhcnRpY2xlLT5uZXh0OwoJICAgIGNvbnRpbnVlOwoJfQoJLyoKCSogQXNzaWduIHRoZSBtb2RlbCBncm91cCB0byB0aGUge3Rlcm19IG9mIHRoZSBwYXJ0aWNsZS4KCSovCglXWFNfUEFSVElDTEVfVEVSTShwYXJ0aWNsZSkgPQoJICAgIFdYU19UUkVFX0NBU1QgV1hTX01PREVMR1JPVVBERUZfTU9ERUwoV1hTX1BBUlRJQ0xFX1RFUk0ocGFydGljbGUpKTsKCglwYXJ0aWNsZSA9IFdYU19QVENfQ0FTVCBwYXJ0aWNsZS0+bmV4dDsKICAgIH0KfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrQXR0ckdyb3VwQ2lyY3VsYXJSZWN1cjoKICogQGN0eHRHcjogdGhlIHNlYXJjaGVkIGF0dHJpYnV0ZSBncm91cAogKiBAYXR0cjogdGhlIGN1cnJlbnQgYXR0cmlidXRlIGxpc3QgdG8gYmUgcHJvY2Vzc2VkCiAqCiAqIFRoaXMgb25lIGlzIGludGVuZGVkIHRvIGJlIHVzZWQgYnkKICogeG1sU2NoZW1hQ2hlY2tBdHRyR3JvdXBDaXJjdWxhciBvbmx5LgogKgogKiBSZXR1cm5zIHRoZSBjaXJjdWxhciBhdHRyaWJ1dGUgZ3JvdSByZWZlcmVuY2UsIG90aGVyd2lzZSBOVUxMLgogKi8Kc3RhdGljIHhtbFNjaGVtYVFOYW1lUmVmUHRyCnhtbFNjaGVtYUNoZWNrQXR0ckdyb3VwQ2lyY3VsYXJSZWN1cih4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0ciBjdHh0R3IsCgkJCQkgICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGxpc3QpCnsKICAgIHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwUHRyIGdyOwogICAgeG1sU2NoZW1hUU5hbWVSZWZQdHIgcmVmLCBjaXJjOwogICAgaW50IGk7CiAgICAvKgogICAgKiBXZSB3aWxsIHNlYXJjaCBmb3IgYW4gYXR0cmlidXRlIGdyb3VwIHJlZmVyZW5jZSB3aGljaAogICAgKiByZWZlcmVuY2VzIHRoZSBjb250ZXh0IGF0dHJpYnV0ZSBncm91cC4KICAgICovCiAgICBmb3IgKGkgPSAwOyBpIDwgbGlzdC0+bmJJdGVtczsgaSsrKSB7CglyZWYgPSBsaXN0LT5pdGVtc1tpXTsKCWlmICgocmVmLT50eXBlID09IFhNTF9TQ0hFTUFfRVhUUkFfUU5BTUVSRUYpICYmCgkgICAgKHJlZi0+aXRlbVR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQKSAmJgoJICAgIChyZWYtPml0ZW0gIT0gTlVMTCkpCgl7CgkgICAgZ3IgPSBXWFNfQVRUUl9HUk9VUF9DQVNUIHJlZi0+aXRlbTsKCSAgICBpZiAoZ3IgPT0gY3R4dEdyKQoJCXJldHVybihyZWYpOwoJICAgIGlmIChnci0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSR1JPVVBfTUFSS0VEKQoJCWNvbnRpbnVlOwkgICAgCgkgICAgLyoKCSAgICAqIE1hcmsgYXMgdmlzaXRlZCB0byBhdm9pZCBpbmZpbml0ZSByZWN1cnNpb24gb24KCSAgICAqIGNpcmN1bGFyIHJlZmVyZW5jZXMgbm90IHlldCBleGFtaW5lZC4KCSAgICAqLwoJICAgIGlmICgoZ3ItPmF0dHJVc2VzKSAmJgoJCShnci0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSR1JPVVBfSEFTX1JFRlMpKQoJICAgIHsKCQlnci0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfQVRUUkdST1VQX01BUktFRDsKCQljaXJjID0geG1sU2NoZW1hQ2hlY2tBdHRyR3JvdXBDaXJjdWxhclJlY3VyKGN0eHRHciwKCQkgICAgKHhtbFNjaGVtYUl0ZW1MaXN0UHRyKSBnci0+YXR0clVzZXMpOwkJCgkJZ3ItPmZsYWdzIF49IFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9NQVJLRUQ7CgkJaWYgKGNpcmMgIT0gTlVMTCkKCQkgICAgcmV0dXJuIChjaXJjKTsKCSAgICB9CgkgICAgCgl9CiAgICB9CiAgICByZXR1cm4gKE5VTEwpOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tBdHRyR3JvdXBDaXJjdWxhcjoKICogYXR0ckdyOiAgdGhlIGF0dHJpYnV0ZSBncm91cCBkZWZpbml0aW9uCiAqIEBjdHh0OiAgdGhlIHBhcnNlciBjb250ZXh0CiAqIEBuYW1lOiAgdGhlIG5hbWUKICoKICogQ2hlY2tzIGZvciBjaXJjdWxhciByZWZlcmVuY2VzIG9mIGF0dHJpYnV0ZSBncm91cHMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQXR0ckdyb3VwQ2lyY3VsYXIoeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIgYXR0ckdyLAoJCQkJeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0KQp7CiAgICAvKgogICAgKiBTY2hlbWEgUmVwcmVzZW50YXRpb24gQ29uc3RyYWludDoKICAgICogQXR0cmlidXRlIEdyb3VwIERlZmluaXRpb24gUmVwcmVzZW50YXRpb24gT0sKICAgICogMyBDaXJjdWxhciBncm91cCByZWZlcmVuY2UgaXMgZGlzYWxsb3dlZCBvdXRzaWRlIDxyZWRlZmluZT4uCiAgICAqIFRoYXQgaXMsIHVubGVzcyB0aGlzIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSdzIHBhcmVudCBpcwogICAgKiA8cmVkZWZpbmU+LCB0aGVuIGFtb25nIHRoZSBbY2hpbGRyZW5dLCBpZiBhbnksIHRoZXJlIG11c3QKICAgICogbm90IGJlIGFuIDxhdHRyaWJ1dGVHcm91cD4gd2l0aCByZWYgW2F0dHJpYnV0ZV0gd2hpY2ggcmVzb2x2ZXMKICAgICogdG8gdGhlIGNvbXBvbmVudCBjb3JyZXNwb25kaW5nIHRvIHRoaXMgPGF0dHJpYnV0ZUdyb3VwPi4gSW5kaXJlY3QKICAgICogY2lyY3VsYXJpdHkgaXMgYWxzbyBydWxlZCBvdXQuIFRoYXQgaXMsIHdoZW4gUU5hbWUgcmVzb2x1dGlvbgogICAgKiAoU2NoZW1hIERvY3VtZW50KSAopzMuMTUuMykgaXMgYXBwbGllZCB0byBhILdRTmFtZbcgYXJpc2luZyBmcm9tCiAgICAqIGFueSA8YXR0cmlidXRlR3JvdXA+cyB3aXRoIGEgcmVmIFthdHRyaWJ1dGVdIGFtb25nIHRoZSBbY2hpbGRyZW5dLAogICAgKiBpdCBtdXN0IG5vdCBiZSB0aGUgY2FzZSB0aGF0IGEgt1FOYW1ltyBpcyBlbmNvdW50ZXJlZCBhdCBhbnkgZGVwdGgKICAgICogd2hpY2ggcmVzb2x2ZXMgdG8gdGhlIGNvbXBvbmVudCBjb3JyZXNwb25kaW5nIHRvIHRoaXMgPGF0dHJpYnV0ZUdyb3VwPi4KICAgICovCiAgICBpZiAoYXR0ckdyLT5hdHRyVXNlcyA9PSBOVUxMKQoJcmV0dXJuKDApOwogICAgZWxzZSBpZiAoKGF0dHJHci0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSR1JPVVBfSEFTX1JFRlMpID09IDApCglyZXR1cm4oMCk7CiAgICBlbHNlIHsKCXhtbFNjaGVtYVFOYW1lUmVmUHRyIGNpcmM7CgkKCWNpcmMgPSB4bWxTY2hlbWFDaGVja0F0dHJHcm91cENpcmN1bGFyUmVjdXIoYXR0ckdyLAoJICAgICh4bWxTY2hlbWFJdGVtTGlzdFB0cikgYXR0ckdyLT5hdHRyVXNlcyk7CQoJaWYgKGNpcmMgIT0gTlVMTCkgewoJICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgkgICAgLyoKCSAgICAqIFRPRE86IFJlcG9ydCB0aGUgcmVmZXJlbmNlZCBhdHRyIGdyb3VwIGFzIFFOYW1lLgoJICAgICovCgkgICAgeG1sU2NoZW1hUEN1c3RvbUVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19BVFRSSUJVVEVfR1JPVVBfMywKCQlOVUxMLCBXWFNfSVRFTV9OT0RFKFdYU19CQVNJQ19DQVNUIGNpcmMpLAoJCSJDaXJjdWxhciByZWZlcmVuY2UgdG8gdGhlIGF0dHJpYnV0ZSBncm91cCAnJXMnICIKCQkiZGVmaW5lZCIsIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHIsIGF0dHJHcikpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKTsKCSAgICAvKgoJICAgICogTk9URTogV2Ugd2lsbCBjdXQgdGhlIHJlZmVyZW5jZSB0byBhdm9pZCBmdXJ0aGVyCgkgICAgKiBjb25mdXNpb24gb2YgdGhlIHByb2Nlc3Nvci4KCSAgICAqIEJBRFNQRUMgVE9ETzogVGhlIHNwZWMgc2hvdWxkIGRlZmluZSBob3cgdG8gcHJvY2VzcyBpbiB0aGlzIGNhc2UuCgkgICAgKi8KCSAgICBjaXJjLT5pdGVtID0gTlVMTDsKCSAgICByZXR1cm4oY3R4dC0+ZXJyKTsKCX0KICAgIH0KICAgIHJldHVybigwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cEV4cGFuZFJlZnMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJCSAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIgYXR0ckdyKTsKCi8qKgogKiB4bWxTY2hlbWFFeHBhbmRBdHRyaWJ1dGVHcm91cFJlZnM6CiAqIEBwY3R4dDogdGhlIHBhcnNlciBjb250ZXh0CiAqIEBub2RlOiB0aGUgbm9kZSBvZiB0aGUgY29tcG9uZW50IGhvbGRpbmcgdGhlIGF0dHJpYnV0ZSB1c2VzCiAqIEBjb21wbGV0ZVdpbGQ6IHRoZSBpbnRlcnNlY3RlZCB3aWxkY2FyZCB0byBiZSByZXR1cm5lZCAKICogQGxpc3Q6IHRoZSBhdHRyaWJ1dGUgdXNlcwogKgogKiBTdWJzdGl0dXRlcyBjb250YWluZWQgYXR0cmlidXRlIGdyb3VwIHJlZmVyZW5jZXMKICogZm9yIHRoZWlyIGF0dHJpYnV0ZSB1c2VzLiBXaWxjYXJkcyBhcmUgaW50ZXJzZWN0ZWQuCiAqIEF0dHJpYnV0ZSB1c2UgcHJvaGliaXRpb25zIGFyZSByZW1vdmVkIGZyb20gdGhlIGxpc3QKICogYW5kIHJldHVybmVkIHZpYSB0aGUgQHByb2hpYnMgbGlzdC4KICogUG9pbnRsZXNzbmVzcyBvZiBhdHRyLiBwcm9oaWJzLCBpZiBhIG1hdGNoaW5nIGF0dHIuIGRlY2wKICogaXMgZXhpc3RlbnQgYSB3ZWxsLCBhcmUgY2hlY2tlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hRXhwYW5kQXR0cmlidXRlR3JvdXBSZWZzKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCQkgIHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBpdGVtLAoJCQkJICB4bWxTY2hlbWFXaWxkY2FyZFB0ciAqY29tcGxldGVXaWxkLAoJCQkJICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBsaXN0LAoJCQkJICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBwcm9oaWJzKQp7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0ciBncjsKICAgIHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVB0ciB1c2U7CiAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciBzdWJsaXN0OwogICAgaW50IGksIGo7CiAgICBpbnQgY3JlYXRlZCA9ICgqY29tcGxldGVXaWxkID09IE5VTEwpID8gMCA6IDE7CgogICAgaWYgKHByb2hpYnMpCglwcm9oaWJzLT5uYkl0ZW1zID0gMDsKCiAgICBmb3IgKGkgPSAwOyBpIDwgbGlzdC0+bmJJdGVtczsgaSsrKSB7Cgl1c2UgPSBsaXN0LT5pdGVtc1tpXTsKCglpZiAodXNlLT50eXBlID09IFhNTF9TQ0hFTUFfRVhUUkFfQVRUUl9VU0VfUFJPSElCKSB7CSAgICAKCSAgICBpZiAocHJvaGlicyA9PSBOVUxMKSB7CgkJUEVSUk9SX0lOVCgieG1sU2NoZW1hRXhwYW5kQXR0cmlidXRlR3JvdXBSZWZzIiwKCQkgICAgInVuZXhwZWN0ZWQgYXR0ciBwcm9oaWJpdGlvbiBmb3VuZCIpOwoJCXJldHVybigtMSk7CgkgICAgfQoJICAgIC8qCgkgICAgKiBSZW1vdmUgZnJvbSBhdHRyaWJ1dGUgdXNlcy4KCSAgICAqLwoJICAgIGlmICh4bWxTY2hlbWFJdGVtTGlzdFJlbW92ZShsaXN0LCBpKSA9PSAtMSkKCQlyZXR1cm4oLTEpOwoJICAgIGktLTsKCSAgICAvKgoJICAgICogTm90ZSB0aGF0IGR1cGxpY2F0ZSBwcm9oaWJpdGlvbnMgd2VyZSBhbHJlYWR5CgkgICAgKiBoYW5kbGVkIGF0IHBhcnNpbmcgdGltZS4KCSAgICAqLwkgICAgCgkgICAgLyoKCSAgICAqIEFkZCB0byBsaXN0IG9mIHByb2hpYml0aW9ucy4KCSAgICAqLwoJICAgIHhtbFNjaGVtYUl0ZW1MaXN0QWRkU2l6ZShwcm9oaWJzLCAyLCB1c2UpOwoJICAgIGNvbnRpbnVlOwoJfQoJaWYgKCh1c2UtPnR5cGUgPT0gWE1MX1NDSEVNQV9FWFRSQV9RTkFNRVJFRikgJiYKCSAgICAoKFdYU19RTkFNRV9DQVNUIHVzZSktPml0ZW1UeXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUCkpCgl7CgkgICAgaWYgKChXWFNfUU5BTUVfQ0FTVCB1c2UpLT5pdGVtID09IE5VTEwpCgkJcmV0dXJuKC0xKTsKCSAgICBnciA9IFdYU19BVFRSX0dST1VQX0NBU1QgKFdYU19RTkFNRV9DQVNUIHVzZSktPml0ZW07CgkgICAgLyoKCSAgICAqIEV4cGFuZCB0aGUgcmVmZXJlbmNlZCBhdHRyLiBncm91cC4KCSAgICAqIFRPRE86IHJlbW92ZSB0aGlzLCB0aGlzIGlzIGRvbmUgaW4gYSBwcmV2aW91cyBzdGVwLCBzbwoJICAgICogYWxyZWFkeSBkb25lIGhlcmUuCgkgICAgKi8KCSAgICBpZiAoKGdyLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9XSUxEQ0FSRF9CVUlMREVEKSA9PSAwKSB7CgkJaWYgKHhtbFNjaGVtYUF0dHJpYnV0ZUdyb3VwRXhwYW5kUmVmcyhwY3R4dCwgZ3IpID09IC0xKQoJCSAgICByZXR1cm4oLTEpOwoJICAgIH0KCSAgICAvKgoJICAgICogQnVpbGQgdGhlICdjb21wbGV0ZScgd2lsZGNhcmQ7IGkuZS4gaW50ZXJzZWN0IG11bHRpcGxlCgkgICAgKiB3aWxkY2FyZHMuCgkgICAgKi8KCSAgICBpZiAoZ3ItPmF0dHJpYnV0ZVdpbGRjYXJkICE9IE5VTEwpIHsKCQlpZiAoKmNvbXBsZXRlV2lsZCA9PSBOVUxMKSB7CgkJICAgICpjb21wbGV0ZVdpbGQgPSBnci0+YXR0cmlidXRlV2lsZGNhcmQ7CgkJfSBlbHNlIHsKCQkgICAgaWYgKCEgY3JlYXRlZCkgewoJCQl4bWxTY2hlbWFXaWxkY2FyZFB0ciB0bXBXaWxkOwoKCQkJIC8qCgkJCSogQ29weSB0aGUgZmlyc3QgZW5jb3VudGVyZWQgd2lsZGNhcmQgYXMgY29udGV4dCwKCQkJKiBleGNlcHQgZm9yIHRoZSBhbm5vdGF0aW9uLgoJCQkqCgkJCSogQWx0aG91Z2ggdGhlIGNvbXBsZXRlIHdpbGRjYXJkIG1pZ2h0IG5vdCBjb3JyZXNwb25kCgkJCSogdG8gYW55IG5vZGUgaW4gdGhlIHNjaGVtYSwgd2Ugd2lsbCBhbmNob3IgaXQgb24KCQkJKiB0aGUgbm9kZSBvZiB0aGUgb3duZXIgY29tcG9uZW50LgoJCQkqLwoJCQl0bXBXaWxkID0gIHhtbFNjaGVtYUFkZFdpbGRjYXJkKHBjdHh0LCBwY3R4dC0+c2NoZW1hLAoJCQkgICAgWE1MX1NDSEVNQV9UWVBFX0FOWV9BVFRSSUJVVEUsCgkJCSAgICBXWFNfSVRFTV9OT0RFKGl0ZW0pKTsKCQkJaWYgKHRtcFdpbGQgPT0gTlVMTCkKCQkJICAgIHJldHVybigtMSk7CgkJCWlmICh4bWxTY2hlbWFDbG9uZVdpbGRjYXJkTnNDb25zdHJhaW50cyhwY3R4dCwKCQkJICAgIHRtcFdpbGQsICpjb21wbGV0ZVdpbGQpID09IC0xKQoJCQkgICAgcmV0dXJuICgtMSk7CgkJCXRtcFdpbGQtPnByb2Nlc3NDb250ZW50cyA9ICgqY29tcGxldGVXaWxkKS0+cHJvY2Vzc0NvbnRlbnRzOwoJCQkqY29tcGxldGVXaWxkID0gdG1wV2lsZDsKCQkJY3JlYXRlZCA9IDE7CgkJICAgIH0KCQkgICAgCgkJICAgIGlmICh4bWxTY2hlbWFJbnRlcnNlY3RXaWxkY2FyZHMocGN0eHQsICpjb21wbGV0ZVdpbGQsCgkJCWdyLT5hdHRyaWJ1dGVXaWxkY2FyZCkgPT0gLTEpCgkJCXJldHVybigtMSk7CgkJfQoJICAgIH0KCSAgICAvKgoJICAgICogSnVzdCByZW1vdmUgdGhlIHJlZmVyZW5jZSBpZiB0aGUgcmVmZXJlbmNlZCBncm91cCBkb2VzIG5vdAoJICAgICogY29udGFpbiBhbnkgYXR0cmlidXRlIHVzZXMuCgkgICAgKi8KCSAgICBpZiAoZ3ItPmF0dHJVc2VzID09IE5VTEwpIHsKCQlpZiAoeG1sU2NoZW1hSXRlbUxpc3RSZW1vdmUobGlzdCwgaSkgPT0gLTEpCgkJICAgIHJldHVybigtMSk7CgkJaS0tOwoJCWNvbnRpbnVlOwoJICAgIH0KCSAgICAvKgoJICAgICogQWRkIHRoZSBhdHRyaWJ1dGUgdXNlcy4KCSAgICAqLwoJICAgIHN1Ymxpc3QgPSAoKHhtbFNjaGVtYUl0ZW1MaXN0UHRyKSBnci0+YXR0clVzZXMpOwoJICAgIGlmIChzdWJsaXN0LT5uYkl0ZW1zICE9IDApIHsKCQlsaXN0LT5pdGVtc1tpXSA9IHN1Ymxpc3QtPml0ZW1zWzBdOwoJCWlmIChzdWJsaXN0LT5uYkl0ZW1zICE9IDEpIHsKCQkgICAgZm9yIChqID0gMTsgaiA8IHN1Ymxpc3QtPm5iSXRlbXM7IGorKykgewoJCQlpKys7CgkJCWlmICh4bWxTY2hlbWFJdGVtTGlzdEluc2VydChsaXN0LAoJCQkJc3VibGlzdC0+aXRlbXNbal0sIGkpID09IC0xKQoJCQkgICAgcmV0dXJuKC0xKTsKCQkgICAgfQoJCX0KCSAgICB9CSAgICAgIAoJfQoKICAgIH0KICAgIC8qCiAgICAqIEhhbmRsZSBwb2ludGxlc3MgcHJvaGliaXRpb25zIG9mIGRlY2xhcmVkIGF0dHJpYnV0ZXMuCiAgICAqLwogICAgaWYgKHByb2hpYnMgJiYgKHByb2hpYnMtPm5iSXRlbXMgIT0gMCkgJiYgKGxpc3QtPm5iSXRlbXMgIT0gMCkpIHsKCXhtbFNjaGVtYUF0dHJpYnV0ZVVzZVByb2hpYlB0ciBwcm9oaWI7CgoJZm9yIChpID0gcHJvaGlicy0+bmJJdGVtcyAtMTsgaSA+PSAwOyBpLS0pIHsKCSAgICBwcm9oaWIgPSBwcm9oaWJzLT5pdGVtc1tpXTsKCSAgICBmb3IgKGogPSAwOyBqIDwgbGlzdC0+bmJJdGVtczsgaisrKSB7CgkJdXNlID0gbGlzdC0+aXRlbXNbal07CgoJCWlmICgocHJvaGliLT5uYW1lID09IFdYU19BVFRSVVNFX0RFQ0xfTkFNRSh1c2UpKSAmJgoJCSAgICAocHJvaGliLT50YXJnZXROYW1lc3BhY2UgPT0gV1hTX0FUVFJVU0VfREVDTF9UTlModXNlKSkpCgkJewoJCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoKCQkgICAgeG1sU2NoZW1hQ3VzdG9tV2FybmluZyhBQ1RYVF9DQVNUIHBjdHh0LAoJCQlYTUxfU0NIRU1BUF9XQVJOX0FUVFJfUE9JTlRMRVNTX1BST0gsCgkJCXByb2hpYi0+bm9kZSwgTlVMTCwKCQkJIlNraXBwaW5nIHBvaW50bGVzcyBhdHRyaWJ1dGUgdXNlIHByb2hpYml0aW9uICIKCQkJIiclcycsIHNpbmNlIGEgY29ycmVzcG9uZGluZyBhdHRyaWJ1dGUgdXNlICIKCQkJImV4aXN0cyBhbHJlYWR5IGluIHRoZSB0eXBlIGRlZmluaXRpb24iLAoJCQl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCQkgICAgcHJvaGliLT50YXJnZXROYW1lc3BhY2UsIHByb2hpYi0+bmFtZSksCgkJCU5VTEwsIE5VTEwpOwoJCSAgICBGUkVFX0FORF9OVUxMKHN0cik7CgkJICAgIC8qCgkJICAgICogUmVtb3ZlIHRoZSBwcm9oaWJpdGlvbi4KCQkgICAgKi8KCQkgICAgaWYgKHhtbFNjaGVtYUl0ZW1MaXN0UmVtb3ZlKHByb2hpYnMsIGkpID09IC0xKQoJCQlyZXR1cm4oLTEpOwoJCSAgICBicmVhazsKCQl9CgkgICAgfQoJfQogICAgfQogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBFeHBhbmRSZWZzOgogKiBAcGN0eHQ6ICB0aGUgcGFyc2VyIGNvbnRleHQKICogQGF0dHJHcjogIHRoZSBhdHRyaWJ1dGUgZ3JvdXAgZGVmaW5pdGlvbiAKICoKICogQ29tcHV0YXRpb24gb2Y6CiAqIHthdHRyaWJ1dGUgdXNlc30gcHJvcGVydHkKICoge2F0dHJpYnV0ZSB3aWxkY2FyZH0gcHJvcGVydHkKICoKICogU3Vic3RpdHV0ZXMgY29udGFpbmVkIGF0dHJpYnV0ZSBncm91cCByZWZlcmVuY2VzCiAqIGZvciB0aGVpciBhdHRyaWJ1dGUgdXNlcy4gV2lsY2FyZHMgYXJlIGludGVyc2VjdGVkLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cEV4cGFuZFJlZnMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJCSAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIgYXR0ckdyKQp7ICAKICAgIGlmICgoYXR0ckdyLT5hdHRyVXNlcyA9PSBOVUxMKSB8fAoJKGF0dHJHci0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSR1JPVVBfV0lMRENBUkRfQlVJTERFRCkpCglyZXR1cm4oMCk7CgogICAgYXR0ckdyLT5mbGFncyB8PSBYTUxfU0NIRU1BU19BVFRSR1JPVVBfV0lMRENBUkRfQlVJTERFRDsKICAgIGlmICh4bWxTY2hlbWFFeHBhbmRBdHRyaWJ1dGVHcm91cFJlZnMocGN0eHQsIFdYU19CQVNJQ19DQVNUIGF0dHJHciwKCSYoYXR0ckdyLT5hdHRyaWJ1dGVXaWxkY2FyZCksIGF0dHJHci0+YXR0clVzZXMsIE5VTEwpID09IC0xKQoJcmV0dXJuKC0xKTsgICAgCiAgICByZXR1cm4oMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cEV4cGFuZFJlZnM6CiAqIEBwY3R4dDogIHRoZSBwYXJzZXIgY29udGV4dAogKiBAYXR0ckdyOiAgdGhlIGF0dHJpYnV0ZSBncm91cCBkZWZpbml0aW9uIAogKgogKiBTdWJzdGl0dXRlcyBjb250YWluZWQgYXR0cmlidXRlIGdyb3VwIHJlZmVyZW5jZXMKICogZm9yIHRoZWlyIGF0dHJpYnV0ZSB1c2VzLiBXaWxjYXJkcyBhcmUgaW50ZXJzZWN0ZWQuCiAqIAogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqICAgIEF0dHJpYnV0ZSBHcm91cCBEZWZpbml0aW9uIFByb3BlcnRpZXMgQ29ycmVjdCAoYWctcHJvcHMtY29ycmVjdCkgCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQUdQcm9wc0NvcnJlY3QoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCwKCQkJCSAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIgYXR0ckdyKQp7ICAKICAgIC8qCiAgICAqIFNQRUMgYWctcHJvcHMtY29ycmVjdAogICAgKiAoMSkgIlRoZSB2YWx1ZXMgb2YgdGhlIHByb3BlcnRpZXMgb2YgYW4gYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb24KICAgICogbXVzdCBiZSBhcyBkZXNjcmliZWQgaW4gdGhlIHByb3BlcnR5IHRhYmxlYXUgaW4gVGhlIEF0dHJpYnV0ZQogICAgKiBHcm91cCBEZWZpbml0aW9uIFNjaGVtYSBDb21wb25lbnQgKKczLjYuMSksIG1vZHVsbyB0aGUgaW1wYWN0IG9mCiAgICAqIE1pc3NpbmcgU3ViLWNvbXBvbmVudHMgKKc1LjMpOyIKICAgICovCiAgICAKICAgIGlmICgoYXR0ckdyLT5hdHRyVXNlcyAhPSBOVUxMKSAmJgoJKFdYU19MSVNUX0NBU1QgYXR0ckdyLT5hdHRyVXNlcyktPm5iSXRlbXMgPiAxKQogICAgewoJeG1sU2NoZW1hSXRlbUxpc3RQdHIgdXNlcyA9IFdYU19MSVNUX0NBU1QgYXR0ckdyLT5hdHRyVXNlczsKCXhtbFNjaGVtYUF0dHJpYnV0ZVVzZVB0ciB1c2UsIHRtcDsKCWludCBpLCBqLCBoYXNJZCA9IDA7CgoJZm9yIChpID0gdXNlcy0+bmJJdGVtcyAtMTsgaSA+PSAwOyBpLS0pIHsKCSAgICB1c2UgPSB1c2VzLT5pdGVtc1tpXTsJICAgIAoJICAgIC8qCgkgICAgKiBTUEVDIGFnLXByb3BzLWNvcnJlY3QKCSAgICAqICgyKSAiVHdvIGRpc3RpbmN0IG1lbWJlcnMgb2YgdGhlIHthdHRyaWJ1dGUgdXNlc30gbXVzdCBub3QgaGF2ZQoJICAgICoge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn1zIGJvdGggb2Ygd2hvc2Uge25hbWV9cyBtYXRjaCBhbmQgd2hvc2UKCSAgICAqIHt0YXJnZXQgbmFtZXNwYWNlfXMgYXJlIGlkZW50aWNhbC4iCgkgICAgKi8KCSAgICBpZiAoaSA+IDApIHsKCQlmb3IgKGogPSBpIC0xOyBqID49IDA7IGotLSkgewoJCSAgICB0bXAgPSB1c2VzLT5pdGVtc1tqXTsKCQkgICAgaWYgKChXWFNfQVRUUlVTRV9ERUNMX05BTUUodXNlKSA9PQoJCQlXWFNfQVRUUlVTRV9ERUNMX05BTUUodG1wKSkgJiYKCQkJKFdYU19BVFRSVVNFX0RFQ0xfVE5TKHVzZSkgPT0KCQkJV1hTX0FUVFJVU0VfREVDTF9UTlModG1wKSkpCgkJICAgIHsKCQkJeG1sQ2hhciAqc3RyID0gTlVMTDsKCQkJCgkJCXhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LAoJCQkgICAgWE1MX1NDSEVNQVBfQUdfUFJPUFNfQ09SUkVDVCwKCQkJICAgIGF0dHJHci0+bm9kZSwgV1hTX0JBU0lDX0NBU1QgYXR0ckdyLAoJCQkgICAgIkR1cGxpY2F0ZSAlcyIsCgkJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyLCB1c2UpLAoJCQkgICAgTlVMTCk7CgkJCUZSRUVfQU5EX05VTEwoc3RyKTsKCQkJLyoKCQkJKiBSZW1vdmUgdGhlIGR1cGxpY2F0ZS4KCQkJKi8KCQkJaWYgKHhtbFNjaGVtYUl0ZW1MaXN0UmVtb3ZlKHVzZXMsIGkpID09IC0xKQoJCQkgICAgcmV0dXJuKC0xKTsKCQkJZ290byBuZXh0X3VzZTsKCQkgICAgfQoJCX0KCSAgICB9CgkgICAgLyoKCSAgICAqIFNQRUMgYWctcHJvcHMtY29ycmVjdAoJICAgICogKDMpICJUd28gZGlzdGluY3QgbWVtYmVycyBvZiB0aGUge2F0dHJpYnV0ZSB1c2VzfSBtdXN0IG5vdCBoYXZlCgkgICAgKiB7YXR0cmlidXRlIGRlY2xhcmF0aW9ufXMgYm90aCBvZiB3aG9zZSB7dHlwZSBkZWZpbml0aW9ufXMgYXJlIG9yCgkgICAgKiBhcmUgZGVyaXZlZCBmcm9tIElELiIKCSAgICAqIFRPRE86IERvZXMgJ2Rlcml2ZWQnIGluY2x1ZGUgbWVtYmVyLXR5cGVzIG9mIHVuaW9ucz8KCSAgICAqLwoJICAgIGlmIChXWFNfQVRUUlVTRV9UWVBFREVGKHVzZSkgIT0gTlVMTCkgewkJCgkJaWYgKHhtbFNjaGVtYUlzRGVyaXZlZEZyb21CdWlsdEluVHlwZSgKCQkgICAgV1hTX0FUVFJVU0VfVFlQRURFRih1c2UpLCBYTUxfU0NIRU1BU19JRCkpCgkJewkJCgkJICAgIGlmIChoYXNJZCkgewoJCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoJCQkKCQkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJCSAgICBYTUxfU0NIRU1BUF9BR19QUk9QU19DT1JSRUNULAoJCQkgICAgYXR0ckdyLT5ub2RlLCBXWFNfQkFTSUNfQ0FTVCBhdHRyR3IsCgkJCSAgICAiVGhlcmUgbXVzdCBub3QgZXhpc3QgbW9yZSB0aGFuIG9uZSBhdHRyaWJ1dGUgIgoJCQkgICAgImRlY2xhcmF0aW9uIG9mIHR5cGUgJ3hzOklEJyAiCgkJCSAgICAiKG9yIGRlcml2ZWQgZnJvbSAneHM6SUQnKS4gVGhlICVzIHZpb2xhdGVzIHRoaXMgIgoJCQkgICAgImNvbnN0cmFpbnQiLAoJCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50RGVzaWduYXRpb24oJnN0ciwgdXNlKSwKCQkJICAgIE5VTEwpOwoJCQlGUkVFX0FORF9OVUxMKHN0cik7CgkJCWlmICh4bWxTY2hlbWFJdGVtTGlzdFJlbW92ZSh1c2VzLCBpKSA9PSAtMSkKCQkJICAgIHJldHVybigtMSk7CgkJICAgIH0JCSAgICAKCQkgICAgaGFzSWQgPSAxOwoJCX0KCSAgICB9Cm5leHRfdXNlOiB7fQoJfQogICAgfQogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hUmVzb2x2ZUF0dHJHcm91cFJlZmVyZW5jZXM6CiAqIEBhdHRyZ3JwRGVjbDogIHRoZSBzY2hlbWEgYXR0cmlidXRlIGRlZmluaXRpb24KICogQGN0eHQ6ICB0aGUgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBuYW1lOiAgdGhlIGF0dHJpYnV0ZSBuYW1lCiAqCiAqIFJlc29sdmVzIHJlZmVyZW5jZXMgdG8gYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb25zLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFSZXNvbHZlQXR0ckdyb3VwUmVmZXJlbmNlcyh4bWxTY2hlbWFRTmFtZVJlZlB0ciByZWYsCgkJCQkgICAgeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0KQp7CiAgICB4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0ciBncm91cDsKCiAgICBpZiAocmVmLT5pdGVtICE9IE5VTEwpCiAgICAgICAgcmV0dXJuKDApOwogICAgZ3JvdXAgPSB4bWxTY2hlbWFHZXRBdHRyaWJ1dGVHcm91cChjdHh0LT5zY2hlbWEsCglyZWYtPm5hbWUsCglyZWYtPnRhcmdldE5hbWVzcGFjZSk7CiAgICBpZiAoZ3JvdXAgPT0gTlVMTCkgewoJeG1sU2NoZW1hUFJlc0NvbXBBdHRyRXJyKGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUsCgkgICAgTlVMTCwgcmVmLT5ub2RlLAoJICAgICJyZWYiLCByZWYtPm5hbWUsIHJlZi0+dGFyZ2V0TmFtZXNwYWNlLAoJICAgIHJlZi0+aXRlbVR5cGUsIE5VTEwpOwoJcmV0dXJuKGN0eHQtPmVycik7CiAgICB9CiAgICByZWYtPml0ZW0gPSBXWFNfQkFTSUNfQ0FTVCBncm91cDsKICAgIHJldHVybigwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrQXR0clByb3BzQ29ycmVjdDoKICogQGl0ZW06ICBhbiBzY2hlbWEgYXR0cmlidXRlIGRlY2xhcmF0aW9uL3VzZQogKiBAY3R4dDogIGEgc2NoZW1hIHBhcnNlciBjb250ZXh0CiAqIEBuYW1lOiAgdGhlIG5hbWUgb2YgdGhlIGF0dHJpYnV0ZQogKgogKgogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqICAgIEF0dHJpYnV0ZSBEZWNsYXJhdGlvbiBQcm9wZXJ0aWVzIENvcnJlY3QgKGEtcHJvcHMtY29ycmVjdCkKICoKICogVmFsaWRhdGVzIHRoZSB2YWx1ZSBjb25zdHJhaW50cyBvZiBhbiBhdHRyaWJ1dGUgZGVjbGFyYXRpb24vdXNlLgogKiBOT1RFIHRoYXQgdGhpcyBuZWVkcyB0aGUgc2ltbGUgdHlwZSBkZWZpbml0aW9ucyB0byBiZSBhbHJlYWR5CiAqICAgYnVpbGRlZCBhbmQgY2hlY2tlZC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tBdHRyUHJvcHNDb3JyZWN0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCSAgICAgICB4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgYXR0cikKewoKICAgIC8qCiAgICAqIFNQRUMgYS1wcm9wcy1jb3JyZWN0ICgxKQogICAgKiAiVGhlIHZhbHVlcyBvZiB0aGUgcHJvcGVydGllcyBvZiBhbiBhdHRyaWJ1dGUgZGVjbGFyYXRpb24gbXVzdAogICAgKiBiZSBhcyBkZXNjcmliZWQgaW4gdGhlIHByb3BlcnR5IHRhYmxlYXUgaW4gVGhlIEF0dHJpYnV0ZQogICAgKiBEZWNsYXJhdGlvbiBTY2hlbWEgQ29tcG9uZW50ICinMy4yLjEpLCBtb2R1bG8gdGhlIGltcGFjdCBvZgogICAgKiBNaXNzaW5nIFN1Yi1jb21wb25lbnRzICinNS4zKS4iCiAgICAqLwogICAgCiAgICBpZiAoV1hTX0FUVFJfVFlQRURFRihhdHRyKSA9PSBOVUxMKQoJcmV0dXJuKDApOwoKICAgIGlmIChhdHRyLT5kZWZWYWx1ZSAhPSBOVUxMKSB7CglpbnQgcmV0OwoKCS8qCgkqIFNQRUMgYS1wcm9wcy1jb3JyZWN0ICgzKQoJKiAiSWYgdGhlIHt0eXBlIGRlZmluaXRpb259IGlzIG9yIGlzIGRlcml2ZWQgZnJvbSBJRCB0aGVuIHRoZXJlCgkqIG11c3Qgbm90IGJlIGEge3ZhbHVlIGNvbnN0cmFpbnR9LiIKCSovCglpZiAoeG1sU2NoZW1hSXNEZXJpdmVkRnJvbUJ1aWx0SW5UeXBlKAoJICAgIFdYU19BVFRSX1RZUEVERUYoYXR0ciksIFhNTF9TQ0hFTUFTX0lEKSkKCXsKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQlYTUxfU0NIRU1BUF9BX1BST1BTX0NPUlJFQ1RfMywKCQlOVUxMLCBXWFNfQkFTSUNfQ0FTVCBhdHRyLAoJCSJWYWx1ZSBjb25zdHJhaW50cyBhcmUgbm90IGFsbG93ZWQgaWYgdGhlIHR5cGUgZGVmaW5pdGlvbiAiCgkJImlzIG9yIGlzIGRlcml2ZWQgZnJvbSB4czpJRCIsCgkJTlVMTCwgTlVMTCk7CgkgICAgcmV0dXJuKHBjdHh0LT5lcnIpOwoJfQoJLyoKCSogU1BFQyBhLXByb3BzLWNvcnJlY3QgKDIpCgkqICJpZiB0aGVyZSBpcyBhIHt2YWx1ZSBjb25zdHJhaW50fSwgdGhlIGNhbm9uaWNhbCBsZXhpY2FsCgkqIHJlcHJlc2VudGF0aW9uIG9mIGl0cyB2YWx1ZSBtdXN0IGJlILd2YWxpZLcgd2l0aCByZXNwZWN0CgkqIHRvIHRoZSB7dHlwZSBkZWZpbml0aW9ufSBhcyBkZWZpbmVkIGluIFN0cmluZyBWYWxpZCAopzMuMTQuNCkuIgoJKiBUT0RPOiBEb24ndCBjYXJlIGFib3V0IHRoZSAqY29ub25pY2FsKiBzdHVmZiBoZXJlLCB0aGlzIHJlcXVpcmVtZW50CgkqIHdpbGwgYmUgcmVtb3ZlZCBpbiBXWFMgMS4xIGFueXdheS4KCSovCglyZXQgPSB4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKEFDVFhUX0NBU1QgcGN0eHQsCgkgICAgYXR0ci0+bm9kZSwgV1hTX0FUVFJfVFlQRURFRihhdHRyKSwKCSAgICBhdHRyLT5kZWZWYWx1ZSwgJihhdHRyLT5kZWZWYWwpLAoJICAgIDEsIDEsIDApOwoJaWYgKHJldCAhPSAwKSB7CgkgICAgaWYgKHJldCA8IDApIHsKCQlQRVJST1JfSU5UKCJ4bWxTY2hlbWFDaGVja0F0dHJQcm9wc0NvcnJlY3QiLAoJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKCkiKTsKCQlyZXR1cm4oLTEpOwoJICAgIH0KCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQlYTUxfU0NIRU1BUF9BX1BST1BTX0NPUlJFQ1RfMiwKCQlOVUxMLCBXWFNfQkFTSUNfQ0FTVCBhdHRyLAoJCSJUaGUgdmFsdWUgb2YgdGhlIHZhbHVlIGNvbnN0cmFpbnQgaXMgbm90IHZhbGlkIiwKCQlOVUxMLCBOVUxMKTsKCSAgICByZXR1cm4ocGN0eHQtPmVycik7Cgl9CiAgICB9CiAgIAogICAgcmV0dXJuKDApOwp9CgpzdGF0aWMgeG1sU2NoZW1hRWxlbWVudFB0cgp4bWxTY2hlbWFDaGVja1N1YnN0R3JvdXBDaXJjdWxhcih4bWxTY2hlbWFFbGVtZW50UHRyIGVsZW1EZWNsLAoJCQkJIHhtbFNjaGVtYUVsZW1lbnRQdHIgYW5jZXN0b3IpCnsKICAgIHhtbFNjaGVtYUVsZW1lbnRQdHIgcmV0OwoKICAgIGlmIChXWFNfU1VCU1RfSEVBRChhbmNlc3RvcikgPT0gTlVMTCkKCXJldHVybiAoTlVMTCk7CiAgICBpZiAoV1hTX1NVQlNUX0hFQUQoYW5jZXN0b3IpID09IGVsZW1EZWNsKQoJcmV0dXJuIChhbmNlc3Rvcik7CgogICAgaWYgKFdYU19TVUJTVF9IRUFEKGFuY2VzdG9yKS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0NJUkNVTEFSKQoJcmV0dXJuIChOVUxMKTsKICAgIFdYU19TVUJTVF9IRUFEKGFuY2VzdG9yKS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9DSVJDVUxBUjsKICAgIHJldCA9IHhtbFNjaGVtYUNoZWNrU3Vic3RHcm91cENpcmN1bGFyKGVsZW1EZWNsLAoJV1hTX1NVQlNUX0hFQUQoYW5jZXN0b3IpKTsKICAgIFdYU19TVUJTVF9IRUFEKGFuY2VzdG9yKS0+ZmxhZ3MgXj0gWE1MX1NDSEVNQVNfRUxFTV9DSVJDVUxBUjsKCiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDaGVja0VsZW1Qcm9wc0NvcnJlY3Q6CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQGRlY2w6IHRoZSBlbGVtZW50IGRlY2xhcmF0aW9uCiAqIEBuYW1lOiAgdGhlIG5hbWUgb2YgdGhlIGF0dHJpYnV0ZQogKgogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqIEVsZW1lbnQgRGVjbGFyYXRpb24gUHJvcGVydGllcyBDb3JyZWN0IChlLXByb3BzLWNvcnJlY3QpCiAqCiAqIFNUQVRVUzoKICogICBtaXNzaW5nOiAoNikKICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tFbGVtUHJvcHNDb3JyZWN0KHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJCSAgICAgICB4bWxTY2hlbWFFbGVtZW50UHRyIGVsZW1EZWNsKQp7CiAgICBpbnQgcmV0ID0gMDsKICAgIHhtbFNjaGVtYVR5cGVQdHIgdHlwZURlZiA9IFdYU19FTEVNX1RZUEVERUYoZWxlbURlY2wpOwogICAgLyoKICAgICogU1BFQyAoMSkgIlRoZSB2YWx1ZXMgb2YgdGhlIHByb3BlcnRpZXMgb2YgYW4gZWxlbWVudCBkZWNsYXJhdGlvbgogICAgKiBtdXN0IGJlIGFzIGRlc2NyaWJlZCBpbiB0aGUgcHJvcGVydHkgdGFibGVhdSBpbiBUaGUgRWxlbWVudAogICAgKiBEZWNsYXJhdGlvbiBTY2hlbWEgQ29tcG9uZW50ICinMy4zLjEpLCBtb2R1bG8gdGhlIGltcGFjdCBvZiBNaXNzaW5nCiAgICAqIFN1Yi1jb21wb25lbnRzICinNS4zKS4iCiAgICAqLwogICAgaWYgKFdYU19TVUJTVF9IRUFEKGVsZW1EZWNsKSAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFFbGVtZW50UHRyIGhlYWQgPSBXWFNfU1VCU1RfSEVBRChlbGVtRGVjbCksIGNpcmM7CgoJeG1sU2NoZW1hQ2hlY2tFbGVtZW50RGVjbENvbXBvbmVudChoZWFkLCBwY3R4dCk7CgkvKgoJKiBTUEVDICgzKSAiSWYgdGhlcmUgaXMgYSBub24tt2Fic2VudLcge3N1YnN0aXR1dGlvbiBncm91cAoJKiBhZmZpbGlhdGlvbn0sIHRoZW4ge3Njb3BlfSBtdXN0IGJlIGdsb2JhbC4iCgkqLwoJaWYgKChlbGVtRGVjbC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0dMT0JBTCkgPT0gMCkgewoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkJWE1MX1NDSEVNQVBfRV9QUk9QU19DT1JSRUNUXzMsCgkJV1hTX0JBU0lDX0NBU1QgZWxlbURlY2wsIE5VTEwsCgkJIk9ubHkgZ2xvYmFsIGVsZW1lbnQgZGVjbGFyYXRpb25zIGNhbiBoYXZlIGEgIgoJCSJzdWJzdGl0dXRpb24gZ3JvdXAgYWZmaWxpYXRpb24iLCBOVUxMKTsKCSAgICByZXQgPSBYTUxfU0NIRU1BUF9FX1BST1BTX0NPUlJFQ1RfMzsKCX0KCS8qCgkqIFRPRE86IFNQRUMgKDYpICJDaXJjdWxhciBzdWJzdGl0dXRpb24gZ3JvdXBzIGFyZSBkaXNhbGxvd2VkLgoJKiBUaGF0IGlzLCBpdCBtdXN0IG5vdCBiZSBwb3NzaWJsZSB0byByZXR1cm4gdG8gYW4gZWxlbWVudCBkZWNsYXJhdGlvbgoJKiBieSByZXBlYXRlZGx5IGZvbGxvd2luZyB0aGUge3N1YnN0aXR1dGlvbiBncm91cCBhZmZpbGlhdGlvbn0KCSogcHJvcGVydHkuIgoJKi8KCWlmIChoZWFkID09IGVsZW1EZWNsKQoJICAgIGNpcmMgPSBoZWFkOwoJZWxzZSBpZiAoV1hTX1NVQlNUX0hFQUQoaGVhZCkgIT0gTlVMTCkKCSAgICBjaXJjID0geG1sU2NoZW1hQ2hlY2tTdWJzdEdyb3VwQ2lyY3VsYXIoaGVhZCwgaGVhZCk7CgllbHNlCgkgICAgY2lyYyA9IE5VTEw7CglpZiAoY2lyYyAhPSBOVUxMKSB7CgkgICAgeG1sQ2hhciAqc3RyQSA9IE5VTEwsICpzdHJCID0gTlVMTDsKCgkgICAgeG1sU2NoZW1hUEN1c3RvbUVyckV4dChwY3R4dCwKCQlYTUxfU0NIRU1BUF9FX1BST1BTX0NPUlJFQ1RfNiwKCQlXWFNfQkFTSUNfQ0FTVCBjaXJjLCBOVUxMLAoJCSJUaGUgZWxlbWVudCBkZWNsYXJhdGlvbiAnJXMnIGRlZmluZXMgYSBjaXJjdWxhciAiCgkJInN1YnN0aXR1dGlvbiBncm91cCB0byBlbGVtZW50IGRlY2xhcmF0aW9uICclcyciLAoJCXhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHJBLCBjaXJjKSwKCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyQiwgaGVhZCksCgkJTlVMTCk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHJBKQoJICAgIEZSRUVfQU5EX05VTEwoc3RyQikKCSAgICByZXQgPSBYTUxfU0NIRU1BUF9FX1BST1BTX0NPUlJFQ1RfNjsKCX0KCS8qCgkqIFNQRUMgKDQpICJJZiB0aGVyZSBpcyBhIHtzdWJzdGl0dXRpb24gZ3JvdXAgYWZmaWxpYXRpb259LAoJKiB0aGUge3R5cGUgZGVmaW5pdGlvbn0KCSogb2YgdGhlIGVsZW1lbnQgZGVjbGFyYXRpb24gbXVzdCBiZSB2YWxpZGx5IGRlcml2ZWQgZnJvbSB0aGUge3R5cGUKCSogZGVmaW5pdGlvbn0gb2YgdGhlIHtzdWJzdGl0dXRpb24gZ3JvdXAgYWZmaWxpYXRpb259LCBnaXZlbiB0aGUgdmFsdWUKCSogb2YgdGhlIHtzdWJzdGl0dXRpb24gZ3JvdXAgZXhjbHVzaW9uc30gb2YgdGhlIHtzdWJzdGl0dXRpb24gZ3JvdXAKCSogYWZmaWxpYXRpb259LCBhcyBkZWZpbmVkIGluIFR5cGUgRGVyaXZhdGlvbiBPSyAoQ29tcGxleCkgKKczLjQuNikKCSogKGlmIHRoZSB7dHlwZSBkZWZpbml0aW9ufSBpcyBjb21wbGV4KSBvciBhcyBkZWZpbmVkIGluCgkqIFR5cGUgRGVyaXZhdGlvbiBPSyAoU2ltcGxlKSAopzMuMTQuNikgKGlmIHRoZSB7dHlwZSBkZWZpbml0aW9ufSBpcwoJKiBzaW1wbGUpLiIKCSoKCSogTk9URToge3N1YnN0aXR1dGlvbiBncm91cCBleGNsdXNpb25zfSBtZWFucyB0aGUgdmFsdWVzIG9mIHRoZQoJKiBhdHRyaWJ1dGUgImZpbmFsIi4KCSovCgoJaWYgKHR5cGVEZWYgIT0gV1hTX0VMRU1fVFlQRURFRihXWFNfU1VCU1RfSEVBRChlbGVtRGVjbCkpKSB7CgkgICAgaW50IHNldCA9IDA7CgoJICAgIGlmIChoZWFkLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fRklOQUxfRVhURU5TSU9OKQoJCXNldCB8PSBTVUJTRVRfRVhURU5TSU9OOwoJICAgIGlmIChoZWFkLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fRklOQUxfUkVTVFJJQ1RJT04pCgkJc2V0IHw9IFNVQlNFVF9SRVNUUklDVElPTjsKCgkgICAgaWYgKHhtbFNjaGVtYUNoZWNrQ09TRGVyaXZlZE9LKEFDVFhUX0NBU1QgcGN0eHQsIHR5cGVEZWYsCgkJV1hTX0VMRU1fVFlQRURFRihoZWFkKSwgc2V0KSAhPSAwKSB7CgkJeG1sQ2hhciAqc3RyQSA9IE5VTEwsICpzdHJCID0gTlVMTCwgKnN0ckMgPSBOVUxMOwoKCQlyZXQgPSBYTUxfU0NIRU1BUF9FX1BST1BTX0NPUlJFQ1RfNDsKCQl4bWxTY2hlbWFQQ3VzdG9tRXJyRXh0KHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BUF9FX1BST1BTX0NPUlJFQ1RfNCwKCQkgICAgV1hTX0JBU0lDX0NBU1QgZWxlbURlY2wsIE5VTEwsCgkJICAgICJUaGUgdHlwZSBkZWZpbml0aW9uICclcycgd2FzICIKCQkgICAgImVpdGhlciByZWplY3RlZCBieSB0aGUgc3Vic3RpdHV0aW9uIGdyb3VwICIKCQkgICAgImFmZmlsaWF0aW9uICclcycsIG9yIG5vdCB2YWxpZGx5IGRlcml2ZWQgZnJvbSBpdHMgdHlwZSAiCgkJICAgICJkZWZpbml0aW9uICclcyciLAoJCSAgICB4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyQSwgdHlwZURlZiksCgkJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHJCLCBoZWFkKSwKCQkgICAgeG1sU2NoZW1hR2V0Q29tcG9uZW50UU5hbWUoJnN0ckMsIFdYU19FTEVNX1RZUEVERUYoaGVhZCkpKTsKCQlGUkVFX0FORF9OVUxMKHN0ckEpCgkJRlJFRV9BTkRfTlVMTChzdHJCKQoJCUZSRUVfQU5EX05VTEwoc3RyQykKCSAgICB9Cgl9CiAgICB9CiAgICAvKgogICAgKiBTUEVDICg1KSAiSWYgdGhlIHt0eXBlIGRlZmluaXRpb259IG9yIHt0eXBlIGRlZmluaXRpb259J3MKICAgICoge2NvbnRlbnQgdHlwZX0KICAgICogaXMgb3IgaXMgZGVyaXZlZCBmcm9tIElEIHRoZW4gdGhlcmUgbXVzdCBub3QgYmUgYSB7dmFsdWUgY29uc3RyYWludH0uCiAgICAqIE5vdGU6IFRoZSB1c2Ugb2YgSUQgYXMgYSB0eXBlIGRlZmluaXRpb24gZm9yIGVsZW1lbnRzIGdvZXMgYmV5b25kCiAgICAqIFhNTCAxLjAsIGFuZCBzaG91bGQgYmUgYXZvaWRlZCBpZiBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSBpcyBkZXNpcmVkIgogICAgKi8KICAgIGlmICgoZWxlbURlY2wtPnZhbHVlICE9IE5VTEwpICYmCgkoKFdYU19JU19TSU1QTEUodHlwZURlZikgJiYKCSAgeG1sU2NoZW1hSXNEZXJpdmVkRnJvbUJ1aWx0SW5UeXBlKHR5cGVEZWYsIFhNTF9TQ0hFTUFTX0lEKSkgfHwKCSAoV1hTX0lTX0NPTVBMRVgodHlwZURlZikgJiYKCSAgV1hTX0hBU19TSU1QTEVfQ09OVEVOVCh0eXBlRGVmKSAmJgoJICB4bWxTY2hlbWFJc0Rlcml2ZWRGcm9tQnVpbHRJblR5cGUodHlwZURlZi0+Y29udGVudFR5cGVEZWYsCgkgICAgWE1MX1NDSEVNQVNfSUQpKSkpIHsKCglyZXQgPSBYTUxfU0NIRU1BUF9FX1BST1BTX0NPUlJFQ1RfNTsKCXhtbFNjaGVtYVBDdXN0b21FcnIocGN0eHQsCgkgICAgWE1MX1NDSEVNQVBfRV9QUk9QU19DT1JSRUNUXzUsCgkgICAgV1hTX0JBU0lDX0NBU1QgZWxlbURlY2wsIE5VTEwsCgkgICAgIlRoZSB0eXBlIGRlZmluaXRpb24gKG9yIHR5cGUgZGVmaW5pdGlvbidzIGNvbnRlbnQgdHlwZSkgaXMgb3IgIgoJICAgICJpcyBkZXJpdmVkIGZyb20gSUQ7IHZhbHVlIGNvbnN0cmFpbnRzIGFyZSBub3QgYWxsb3dlZCBpbiAiCgkgICAgImNvbmp1bmN0aW9uIHdpdGggc3VjaCBhIHR5cGUgZGVmaW5pdGlvbiIsIE5VTEwpOwogICAgfSBlbHNlIGlmIChlbGVtRGVjbC0+dmFsdWUgIT0gTlVMTCkgewoJaW50IHZjcmV0OwoJeG1sTm9kZVB0ciBub2RlID0gTlVMTDsKCgkvKgoJKiBTUEVDICgyKSAiSWYgdGhlcmUgaXMgYSB7dmFsdWUgY29uc3RyYWludH0sIHRoZSBjYW5vbmljYWwgbGV4aWNhbAoJKiByZXByZXNlbnRhdGlvbiBvZiBpdHMgdmFsdWUgbXVzdCBiZSC3dmFsaWS3IHdpdGggcmVzcGVjdCB0byB0aGUKCSoge3R5cGUgZGVmaW5pdGlvbn0gYXMgZGVmaW5lZCBpbiBFbGVtZW50IERlZmF1bHQgVmFsaWQgKEltbWVkaWF0ZSkKCSogKKczLjMuNikuIgoJKi8KCWlmICh0eXBlRGVmID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQRXJyKHBjdHh0LCBlbGVtRGVjbC0+bm9kZSwKCQlYTUxfU0NIRU1BUF9JTlRFUk5BTCwKCQkiSW50ZXJuYWwgZXJyb3I6IHhtbFNjaGVtYUNoZWNrRWxlbVByb3BzQ29ycmVjdCwgIgoJCSJ0eXBlIGlzIG1pc3NpbmcuLi4gc2tpcHBpbmcgdmFsaWRhdGlvbiBvZiAiCgkJInRoZSB2YWx1ZSBjb25zdHJhaW50IiwgTlVMTCwgTlVMTCk7CgkgICAgcmV0dXJuICgtMSk7Cgl9CglpZiAoZWxlbURlY2wtPm5vZGUgIT0gTlVMTCkgewoJICAgIGlmIChlbGVtRGVjbC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0ZJWEVEKQoJCW5vZGUgPSAoeG1sTm9kZVB0cikgeG1sSGFzUHJvcChlbGVtRGVjbC0+bm9kZSwKCQkgICAgQkFEX0NBU1QgImZpeGVkIik7CgkgICAgZWxzZQoJCW5vZGUgPSAoeG1sTm9kZVB0cikgeG1sSGFzUHJvcChlbGVtRGVjbC0+bm9kZSwKCQkgICAgQkFEX0NBU1QgImRlZmF1bHQiKTsKCX0KCXZjcmV0ID0geG1sU2NoZW1hUGFyc2VDaGVja0NPU1ZhbGlkRGVmYXVsdChwY3R4dCwgbm9kZSwKCSAgICB0eXBlRGVmLCBlbGVtRGVjbC0+dmFsdWUsICYoZWxlbURlY2wtPmRlZlZhbCkpOwoJaWYgKHZjcmV0ICE9IDApIHsKCSAgICBpZiAodmNyZXQgPCAwKSB7CgkJUEVSUk9SX0lOVCgieG1sU2NoZW1hRWxlbUNoZWNrVmFsQ29uc3RyIiwKCQkgICAgImZhaWxlZCB0byB2YWxpZGF0ZSB0aGUgdmFsdWUgY29uc3RyYWludCBvZiBhbiAiCgkJICAgICJlbGVtZW50IGRlY2xhcmF0aW9uIik7CgkJcmV0dXJuICgtMSk7CgkgICAgfQoJICAgIHJldHVybiAodmNyZXQpOwoJfQogICAgfQoKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrRWxlbVN1YnN0R3JvdXA6CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQGRlY2w6IHRoZSBlbGVtZW50IGRlY2xhcmF0aW9uCiAqIEBuYW1lOiAgdGhlIG5hbWUgb2YgdGhlIGF0dHJpYnV0ZQogKgogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqIFN1YnN0aXR1dGlvbiBHcm91cCAoY29zLWVxdWl2LWNsYXNzKQogKgogKiBJbiBMaWJ4bWwyIHRoZSBzdWJzdC4gZ3JvdXBzIHdpbGwgYmUgcHJlY29tcHV0ZWQsIGluIHRlcm1zIG9mIHRoYXQKICogYSBsaXN0IHdpbGwgYmUgYnVpbHQgZm9yIGVhY2ggc3Vic3QuIGdyb3VwIGhlYWQsIGhvbGRpbmcgYWxsIGRpcmVjdAogKiByZWZlcmVudHMgdG8gdGhpcyBoZWFkLgogKiBOT1RFIHRoYXQgdGhpcyBmdW5jdGlvbiBuZWVkczoKICogICAxLiBjaXJjdWxhciBzdWJzdC4gZ3JvdXBzIHRvIGJlIGNoZWNrZWQgYmVmb3JlaGFuZAogKiAgIDIuIHRoZSBkZWNsYXJhdGlvbidzIHR5cGUgdG8gYmUgZGVyaXZlZCBmcm9tIHRoZSBoZWFkJ3MgdHlwZQogKgogKiBTVEFUVVM6CiAqCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDaGVja0VsZW1TdWJzdEdyb3VwKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKCQkJICAgICB4bWxTY2hlbWFFbGVtZW50UHRyIGVsZW1EZWNsKQp7CiAgICBpZiAoKFdYU19TVUJTVF9IRUFEKGVsZW1EZWNsKSA9PSBOVUxMKSB8fAoJLyogU1BFQyAoMSkgIkl0cyB7YWJzdHJhY3R9IGlzIGZhbHNlLiIgKi8KCShlbGVtRGVjbC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0FCU1RSQUNUKSkKCXJldHVybjsKICAgIHsKCXhtbFNjaGVtYUVsZW1lbnRQdHIgaGVhZDsKCXhtbFNjaGVtYVR5cGVQdHIgaGVhZFR5cGUsIHR5cGU7CglpbnQgc2V0LCBtZXRoU2V0OwoJLyoKCSogU1BFQyAoMikgIkl0IGlzIHZhbGlkbHkgc3Vic3RpdHV0YWJsZSBmb3IgSEVBRCBzdWJqZWN0IHRvIEhFQUQncwoJKiB7ZGlzYWxsb3dlZCBzdWJzdGl0dXRpb25zfSBhcyB0aGUgYmxvY2tpbmcgY29uc3RyYWludCwgYXMgZGVmaW5lZCBpbgoJKiBTdWJzdGl0dXRpb24gR3JvdXAgT0sgKFRyYW5zaXRpdmUpICinMy4zLjYpLiIKCSovCglmb3IgKGhlYWQgPSBXWFNfU1VCU1RfSEVBRChlbGVtRGVjbCk7IGhlYWQgIT0gTlVMTDsKCSAgICBoZWFkID0gV1hTX1NVQlNUX0hFQUQoaGVhZCkpIHsKCSAgICBzZXQgPSAwOwoJICAgIG1ldGhTZXQgPSAwOwoJICAgIC8qCgkgICAgKiBUaGUgYmxvY2tpbmcgY29uc3RyYWludHMuCgkgICAgKi8KCSAgICBpZiAoaGVhZC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0JMT0NLX1NVQlNUSVRVVElPTikKCQljb250aW51ZTsKCSAgICBoZWFkVHlwZSA9IGhlYWQtPnN1YnR5cGVzOwoJICAgIHR5cGUgPSBlbGVtRGVjbC0+c3VidHlwZXM7CgkgICAgaWYgKGhlYWRUeXBlID09IHR5cGUpCgkJZ290byBhZGRfbWVtYmVyOwoJICAgIGlmIChoZWFkLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfUkVTVFJJQ1RJT04pCgkJc2V0IHw9IFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfUkVTVFJJQ1RJT047CgkgICAgaWYgKGhlYWQtPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9CTE9DS19FWFRFTlNJT04pCgkJc2V0IHw9IFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfRVhURU5TSU9OOwoJICAgIC8qCgkgICAgKiBTUEVDOiBTdWJzdGl0dXRpb24gR3JvdXAgT0sgKFRyYW5zaXRpdmUpICgyLjMpCgkgICAgKiAiVGhlIHNldCBvZiBhbGwge2Rlcml2YXRpb24gbWV0aG9kfXMgaW52b2x2ZWQgaW4gdGhlCgkgICAgKiBkZXJpdmF0aW9uIG9mIEQncyB7dHlwZSBkZWZpbml0aW9ufSBmcm9tIEMncyB7dHlwZSBkZWZpbml0aW9ufQoJICAgICogZG9lcyBub3QgaW50ZXJzZWN0IHdpdGggdGhlIHVuaW9uIG9mIHRoZSBibG9ja2luZyBjb25zdHJhaW50LAoJICAgICogQydzIHtwcm9oaWJpdGVkIHN1YnN0aXR1dGlvbnN9IChpZiBDIGlzIGNvbXBsZXgsIG90aGVyd2lzZSB0aGUKCSAgICAqIGVtcHR5IHNldCkgYW5kIHRoZSB7cHJvaGliaXRlZCBzdWJzdGl0dXRpb25zfSAocmVzcGVjdGl2ZWx5IHRoZQoJICAgICogZW1wdHkgc2V0KSBvZiBhbnkgaW50ZXJtZWRpYXRlIHt0eXBlIGRlZmluaXRpb259cyBpbiB0aGUKCSAgICAqIGRlcml2YXRpb24gb2YgRCdzIHt0eXBlIGRlZmluaXRpb259IGZyb20gQydzIHt0eXBlIGRlZmluaXRpb259LiIKCSAgICAqLwoJICAgIC8qCgkgICAgKiBPUFRJTUlaRSBUT0RPOiBPcHRpbWl6ZSB0aGlzIGEgYml0LCBzaW5jZSwgaWYgdHJhdmVyc2luZyB0aGUKCSAgICAqIHN1YnN0LmhlYWQgYXhpcywgdGhlIG1ldGhTZXQgZG9lcyBub3QgbmVlZCB0byBiZSBjb21wdXRlZCBmb3IKCSAgICAqIHRoZSBmdWxsIGRlcHRoIG92ZXIgYW5kIG92ZXIuCgkgICAgKi8KCSAgICAvKgoJICAgICogVGhlIHNldCBvZiBhbGwge2Rlcml2YXRpb24gbWV0aG9kfXMgaW52b2x2ZWQgaW4gdGhlIGRlcml2YXRpb24KCSAgICAqLwoJICAgIHdoaWxlICgodHlwZSAhPSBOVUxMKSAmJiAodHlwZSAhPSBoZWFkVHlwZSkpIHsKCQlpZiAoKFdYU19JU19FWFRFTlNJT04odHlwZSkpICYmCgkJICAgICgobWV0aFNldCAmIFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfUkVTVFJJQ1RJT04pID09IDApKQoJCSAgICBtZXRoU2V0IHw9IFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfRVhURU5TSU9OOwoKCQlpZiAoV1hTX0lTX1JFU1RSSUNUSU9OKHR5cGUpICYmCgkJICAgICgobWV0aFNldCAmIFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfUkVTVFJJQ1RJT04pID09IDApKQoJCSAgICBtZXRoU2V0IHw9IFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfUkVTVFJJQ1RJT047CgoJCXR5cGUgPSB0eXBlLT5iYXNlVHlwZTsKCSAgICB9CgkgICAgLyoKCSAgICAqIFRoZSB7cHJvaGliaXRlZCBzdWJzdGl0dXRpb25zfSBvZiBhbGwgaW50ZXJtZWRpYXRlIHR5cGVzICsKCSAgICAqIHRoZSBoZWFkJ3MgdHlwZS4KCSAgICAqLwoJICAgIHR5cGUgPSBlbGVtRGVjbC0+c3VidHlwZXMtPmJhc2VUeXBlOwoJICAgIHdoaWxlICh0eXBlICE9IE5VTEwpIHsKCQlpZiAoV1hTX0lTX0NPTVBMRVgodHlwZSkpIHsKCQkgICAgaWYgKCh0eXBlLT5mbGFncyAmCgkJCSAgICBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX0VYVEVOU0lPTikgJiYKCQkJKChzZXQgJiBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX0VYVEVOU0lPTikgPT0gMCkpCgkJICAgIHNldCB8PSBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX0VYVEVOU0lPTjsKCQkgICAgaWYgKCh0eXBlLT5mbGFncyAmCgkJCSAgICBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX1JFU1RSSUNUSU9OKSAmJgoJCQkoKHNldCAmIFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfUkVTVFJJQ1RJT04pID09IDApKQoJCSAgICBzZXQgfD0gWE1MX1NDSEVNQVNfVFlQRV9CTE9DS19SRVNUUklDVElPTjsKCQl9IGVsc2UKCQkgICAgYnJlYWs7CgkJaWYgKHR5cGUgPT0gaGVhZFR5cGUpCgkJICAgIGJyZWFrOwoJCXR5cGUgPSB0eXBlLT5iYXNlVHlwZTsKCSAgICB9CgkgICAgaWYgKChzZXQgIT0gMCkgJiYKCQkoKChzZXQgJiBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX0VYVEVOU0lPTikgJiYKCQkobWV0aFNldCAmIFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfRVhURU5TSU9OKSkgfHwKCQkoKHNldCAmIFhNTF9TQ0hFTUFTX1RZUEVfQkxPQ0tfUkVTVFJJQ1RJT04pICYmCgkJKG1ldGhTZXQgJiBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX1JFU1RSSUNUSU9OKSkpKSB7CgkJY29udGludWU7CgkgICAgfQphZGRfbWVtYmVyOgoJICAgIHhtbFNjaGVtYUFkZEVsZW1lbnRTdWJzdGl0dXRpb25NZW1iZXIoY3R4dCwgaGVhZCwgZWxlbURlY2wpOwoJICAgIGlmICgoaGVhZC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX1NVQlNUX0dST1VQX0hFQUQpID09IDApCgkJaGVhZC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9TVUJTVF9HUk9VUF9IRUFEOwoJfQogICAgfQp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tFbGVtZW50RGVjbENvbXBvbmVudAogKiBAaXRlbTogIGFuIHNjaGVtYSBlbGVtZW50IGRlY2xhcmF0aW9uL3BhcnRpY2xlCiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQG5hbWU6ICB0aGUgbmFtZSBvZiB0aGUgYXR0cmlidXRlCiAqCiAqIFZhbGlkYXRlcyB0aGUgdmFsdWUgY29uc3RyYWludHMgb2YgYW4gZWxlbWVudCBkZWNsYXJhdGlvbi4KICoKICogRml4ZXMgZmluaXNoIGRvaW5nIHRoZSBjb21wdXRhdGlvbnMgb24gdGhlIGVsZW1lbnQgZGVjbGFyYXRpb25zLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hQ2hlY2tFbGVtZW50RGVjbENvbXBvbmVudCh4bWxTY2hlbWFFbGVtZW50UHRyIGVsZW1EZWNsLAoJCQkJICAgeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0KQp7CiAgICBpZiAoZWxlbURlY2wgPT0gTlVMTCkKCXJldHVybjsKICAgIGlmIChlbGVtRGVjbC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19FTEVNX0lOVEVSTkFMX0NIRUNLRUQpCglyZXR1cm47CiAgICBlbGVtRGVjbC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfRUxFTV9JTlRFUk5BTF9DSEVDS0VEOwogICAgaWYgKHhtbFNjaGVtYUNoZWNrRWxlbVByb3BzQ29ycmVjdChjdHh0LCBlbGVtRGVjbCkgPT0gMCkKCXhtbFNjaGVtYUNoZWNrRWxlbVN1YnN0R3JvdXAoY3R4dCwgZWxlbURlY2wpOwp9CgovKioKICogeG1sU2NoZW1hUmVzb2x2ZU1vZGVsR3JvdXBQYXJ0aWNsZVJlZmVyZW5jZXM6CiAqIEBwYXJ0aWNsZTogIGEgcGFydGljbGUgY29tcG9uZW50CiAqIEBjdHh0OiAgYSBwYXJzZXIgY29udGV4dAogKgogKiBSZXNvbHZlcyByZWZlcmVuY2VzIG9mIGEgbW9kZWwgZ3JvdXAncyB7cGFydGljbGVzfSB0bwogKiBtb2RlbCBncm91cCBkZWZpbml0aW9ucyBhbmQgdG8gZWxlbWVudCBkZWNsYXJhdGlvbnMuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFSZXNvbHZlTW9kZWxHcm91cFBhcnRpY2xlUmVmZXJlbmNlcygKICAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCwKICAgIHhtbFNjaGVtYU1vZGVsR3JvdXBQdHIgbWcpCnsKICAgIHhtbFNjaGVtYVBhcnRpY2xlUHRyIHBhcnRpY2xlID0gV1hTX01PREVMR1JPVVBfUEFSVElDTEUobWcpOwogICAgeG1sU2NoZW1hUU5hbWVSZWZQdHIgcmVmOwogICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIHJlZkl0ZW07CgogICAgLyoKICAgICogVVJHRU5UIFRPRE86IFRlc3QgdGhpcy4KICAgICovCiAgICB3aGlsZSAocGFydGljbGUgIT0gTlVMTCkgewoJaWYgKChXWFNfUEFSVElDTEVfVEVSTShwYXJ0aWNsZSkgPT0gTlVMTCkgfHwKCSAgICAoKFdYU19QQVJUSUNMRV9URVJNKHBhcnRpY2xlKSktPnR5cGUgIT0KCQlYTUxfU0NIRU1BX0VYVFJBX1FOQU1FUkVGKSkKCXsKCSAgICBnb3RvIG5leHRfcGFydGljbGU7Cgl9IAoJcmVmID0gV1hTX1FOQU1FX0NBU1QgV1hTX1BBUlRJQ0xFX1RFUk0ocGFydGljbGUpOwoJLyoKCSogUmVzb2x2ZSB0aGUgcmVmZXJlbmNlLgoJKiBOVUxMIHRoZSB7dGVybX0gYnkgZGVmYXVsdC4KCSovCglwYXJ0aWNsZS0+Y2hpbGRyZW4gPSBOVUxMOwoKCXJlZkl0ZW0gPSB4bWxTY2hlbWFHZXROYW1lZENvbXBvbmVudChjdHh0LT5zY2hlbWEsCgkgICAgcmVmLT5pdGVtVHlwZSwgcmVmLT5uYW1lLCByZWYtPnRhcmdldE5hbWVzcGFjZSk7CglpZiAocmVmSXRlbSA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hUFJlc0NvbXBBdHRyRXJyKGN0eHQsIFhNTF9TQ0hFTUFQX1NSQ19SRVNPTFZFLAoJCU5VTEwsIFdYU19JVEVNX05PREUocGFydGljbGUpLCAicmVmIiwgcmVmLT5uYW1lLAoJCXJlZi0+dGFyZ2V0TmFtZXNwYWNlLCByZWYtPml0ZW1UeXBlLCBOVUxMKTsKCSAgICAvKiBUT0RPOiByZW1vdmUgdGhlIHBhcnRpY2xlLiAqLwoJICAgIGdvdG8gbmV4dF9wYXJ0aWNsZTsKCX0gCglpZiAocmVmSXRlbS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfR1JPVVApIHsKCSAgICBpZiAoV1hTX01PREVMR1JPVVBERUZfTU9ERUwocmVmSXRlbSkgPT0gTlVMTCkKCQkvKiBUT0RPOiByZW1vdmUgdGhlIHBhcnRpY2xlLiAqLwoJCWdvdG8gbmV4dF9wYXJ0aWNsZTsKCSAgICAvKgoJICAgICogTk9URSB0aGF0IHdlIHdpbGwgYXNzaWduIHRoZSBtb2RlbCBncm91cCBkZWZpbml0aW9uCgkgICAgKiBpdHNlbGYgdG8gdGhlICJ0ZXJtIiBvZiB0aGUgcGFydGljbGUuIFRoaXMgd2lsbCBlYXNlCgkgICAgKiB0aGUgY2hlY2sgZm9yIGNpcmN1bGFyIG1vZGVsIGdyb3VwIGRlZmluaXRpb25zLiBBZnRlcgoJICAgICogdGhhdCB0aGUgInRlcm0iIHdpbGwgYmUgYXNzaWduZWQgdGhlIG1vZGVsIGdyb3VwIG9mIHRoZQoJICAgICogbW9kZWwgZ3JvdXAgZGVmaW5pdGlvbi4KCSAgICAqLwoJICAgIGlmICgoV1hTX01PREVMR1JPVVBERUZfTU9ERUwocmVmSXRlbSkpLT50eXBlID09CgkJICAgIFhNTF9TQ0hFTUFfVFlQRV9BTEwpIHsKCQkvKgoJCSogU1BFQyBjb3MtYWxsLWxpbWl0ZWQgKDEpCgkJKiBTUEVDIGNvcy1hbGwtbGltaXRlZCAoMS4yKQoJCSogIkl0IGFwcGVhcnMgb25seSBhcyB0aGUgdmFsdWUgb2Ygb25lIG9yIGJvdGggb2YgdGhlCgkJKiBmb2xsb3dpbmcgcHJvcGVydGllczoiCgkJKiAoMS4xKSAidGhlIHttb2RlbCBncm91cH0gcHJvcGVydHkgb2YgYSBtb2RlbCBncm91cAoJCSogICAgICAgIGRlZmluaXRpb24uIgoJCSogKDEuMikgInRoZSB7dGVybX0gcHJvcGVydHkgb2YgYSBwYXJ0aWNsZSBbLi4uIG9mXSB0aGUgIgoJCSoge2NvbnRlbnQgdHlwZX0gb2YgYSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbi4iCgkJKi8KCQl4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBjdHh0LAoJCSAgICAvKiBUT0RPOiBlcnJvciBjb2RlICovCgkJICAgIFhNTF9TQ0hFTUFQX0NPU19BTExfTElNSVRFRCwKCQkgICAgV1hTX0lURU1fTk9ERShwYXJ0aWNsZSksIE5VTEwsCgkJICAgICJBIG1vZGVsIGdyb3VwIGRlZmluaXRpb24gaXMgcmVmZXJlbmNlZCwgYnV0ICIKCQkgICAgIml0IGNvbnRhaW5zIGFuICdhbGwnIG1vZGVsIGdyb3VwLCB3aGljaCAiCgkJICAgICJjYW5ub3QgYmUgY29udGFpbmVkIGJ5IG1vZGVsIGdyb3VwcyIsCgkJICAgIE5VTEwsIE5VTEwpOwoJCS8qIFRPRE86IHJlbW92ZSB0aGUgcGFydGljbGUuICovCgkJZ290byBuZXh0X3BhcnRpY2xlOwoJICAgIH0KCSAgICBwYXJ0aWNsZS0+Y2hpbGRyZW4gPSAoeG1sU2NoZW1hVHJlZUl0ZW1QdHIpIHJlZkl0ZW07Cgl9IGVsc2UgewoJICAgIC8qCgkgICAgKiBUT0RPOiBBcmUgcmVmZXJlbmNlZCBlbGVtZW50IGRlY2xhcmF0aW9ucyB0aGUgb25seQoJICAgICogb3RoZXIgY29tcG9uZW50cyB3ZSBleHBlY3QgaGVyZT8KCSAgICAqLwoJICAgIHBhcnRpY2xlLT5jaGlsZHJlbiA9ICh4bWxTY2hlbWFUcmVlSXRlbVB0cikgcmVmSXRlbTsKCX0KbmV4dF9wYXJ0aWNsZToKCXBhcnRpY2xlID0gV1hTX1BUQ19DQVNUIHBhcnRpY2xlLT5uZXh0OwogICAgfQp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYUFyZVZhbHVlc0VxdWFsKHhtbFNjaGVtYVZhbFB0ciB4LAoJCSAgICAgICB4bWxTY2hlbWFWYWxQdHIgeSkgCnsgICAKICAgIHhtbFNjaGVtYVR5cGVQdHIgdHgsIHR5LCBwdHgsIHB0eTsgICAgCiAgICBpbnQgcmV0OwoKICAgIHdoaWxlICh4ICE9IE5VTEwpIHsKCS8qIFNhbWUgdHlwZXMuICovCgl0eCA9IHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKHhtbFNjaGVtYUdldFZhbFR5cGUoeCkpOwoJdHkgPSB4bWxTY2hlbWFHZXRCdWlsdEluVHlwZSh4bWxTY2hlbWFHZXRWYWxUeXBlKHkpKTsKCXB0eCA9IHhtbFNjaGVtYUdldFByaW1pdGl2ZVR5cGUodHgpOwoJcHR5ID0geG1sU2NoZW1hR2V0UHJpbWl0aXZlVHlwZSh0eSk7CgkvKgoJKiAoMSkgaWYgYSBkYXRhdHlwZSBUJyBpcyC3ZGVyaXZlZLcgYnkgt3Jlc3RyaWN0aW9utyBmcm9tIGFuCgkqIGF0b21pYyBkYXRhdHlwZSBUIHRoZW4gdGhlILd2YWx1ZSBzcGFjZbcgb2YgVCcgaXMgYSBzdWJzZXQgb2YKCSogdGhlILd2YWx1ZSBzcGFjZbcgb2YgVC4gKi8KCS8qCgkqICgyKSBpZiBkYXRhdHlwZXMgVCcgYW5kIFQnJyBhcmUgt2Rlcml2ZWS3IGJ5ILdyZXN0cmljdGlvbrcKCSogZnJvbSBhIGNvbW1vbiBhdG9taWMgYW5jZXN0b3IgVCB0aGVuIHRoZSC3dmFsdWUgc3BhY2W3cyBvZiBUJwoJKiBhbmQgVCcnIG1heSBvdmVybGFwLgoJKi8KCWlmIChwdHggIT0gcHR5KQoJICAgIHJldHVybigwKTsKCS8qCgkqIFdlIGFzc3VtZSBjb21wdXRlZCB2YWx1ZXMgdG8gYmUgbm9ybWFsaXplZCwgc28gZG8gYSBmYXN0CgkqIHN0cmluZyBjb21wYXJpc29uIGZvciBzdHJpbmcgYmFzZWQgdHlwZXMuCgkqLwoJaWYgKChwdHgtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX1NUUklORykgfHwKCSAgICBXWFNfSVNfQU5ZX1NJTVBMRV9UWVBFKHB0eCkpIHsKCSAgICBpZiAoISB4bWxTdHJFcXVhbCgKCQl4bWxTY2hlbWFWYWx1ZUdldEFzU3RyaW5nKHgpLAoJCXhtbFNjaGVtYVZhbHVlR2V0QXNTdHJpbmcoeSkpKQoJCXJldHVybiAoMCk7Cgl9IGVsc2UgewoJICAgIHJldCA9IHhtbFNjaGVtYUNvbXBhcmVWYWx1ZXNXaHRzcCgKCQl4LCBYTUxfU0NIRU1BX1dISVRFU1BBQ0VfUFJFU0VSVkUsCgkJeSwgWE1MX1NDSEVNQV9XSElURVNQQUNFX1BSRVNFUlZFKTsKCSAgICBpZiAocmV0ID09IC0yKQoJCXJldHVybigtMSk7CgkgICAgaWYgKHJldCAhPSAwKQoJCXJldHVybigwKTsKCX0KCS8qCgkqIExpc3RzLgoJKi8KCXggPSB4bWxTY2hlbWFWYWx1ZUdldE5leHQoeCk7CglpZiAoeCAhPSBOVUxMKSB7CgkgICAgeSA9IHhtbFNjaGVtYVZhbHVlR2V0TmV4dCh5KTsKCSAgICBpZiAoeSA9PSBOVUxMKQoJCXJldHVybiAoMCk7CSAgICAKCX0gZWxzZSBpZiAoeG1sU2NoZW1hVmFsdWVHZXROZXh0KHkpICE9IE5VTEwpCgkgICAgcmV0dXJuICgwKTsKCWVsc2UKCSAgICByZXR1cm4gKDEpOwogICAgfQogICAgcmV0dXJuICgwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYVJlc29sdmVBdHRyVXNlUmVmZXJlbmNlczoKICogQGl0ZW06ICBhbiBhdHRyaWJ1dGUgdXNlCiAqIEBjdHh0OiAgYSBwYXJzZXIgY29udGV4dAogKgogKiBSZXNvbHZlcyB0aGUgcmVmZXJlbmNlZCBhdHRyaWJ1dGUgZGVjbGFyYXRpb24uCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYVJlc29sdmVBdHRyVXNlUmVmZXJlbmNlcyh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIgYXVzZSwKCQkJCSAgeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0KQp7CiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKGF1c2UgPT0gTlVMTCkpCglyZXR1cm4oLTEpOwogICAgaWYgKChhdXNlLT5hdHRyRGVjbCA9PSBOVUxMKSB8fAoJKGF1c2UtPmF0dHJEZWNsLT50eXBlICE9IFhNTF9TQ0hFTUFfRVhUUkFfUU5BTUVSRUYpKQoJcmV0dXJuKDApOwoKICAgIHsKCXhtbFNjaGVtYVFOYW1lUmVmUHRyIHJlZiA9IFdYU19RTkFNRV9DQVNUIGF1c2UtPmF0dHJEZWNsOwoKCS8qCgkqIFRPRE86IEV2YWx1YXRlLCB3aGF0IGVycm9ycyBjb3VsZCBvY2N1ciBpZiB0aGUgZGVjbGFyYXRpb24gaXMgbm90CgkqIGZvdW5kLgoJKi8KCWF1c2UtPmF0dHJEZWNsID0geG1sU2NoZW1hR2V0QXR0cmlidXRlRGVjbChjdHh0LT5zY2hlbWEsCgkgICAgcmVmLT5uYW1lLCByZWYtPnRhcmdldE5hbWVzcGFjZSk7CiAgICAgICAgaWYgKGF1c2UtPmF0dHJEZWNsID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFQUmVzQ29tcEF0dHJFcnIoY3R4dCwKCSAgICAJWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUsCgkJV1hTX0JBU0lDX0NBU1QgYXVzZSwgYXVzZS0+bm9kZSwKCQkicmVmIiwgcmVmLT5uYW1lLCByZWYtPnRhcmdldE5hbWVzcGFjZSwKCQlYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFLCBOVUxMKTsKICAgICAgICAgICAgcmV0dXJuKGN0eHQtPmVycik7OwogICAgICAgIH0KICAgIH0KICAgIHJldHVybigwKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUNoZWNrQXR0clVzZVByb3BzQ29ycmVjdDoKICogQGN0eHQ6ICBhIHBhcnNlciBjb250ZXh0CiAqIEB1c2U6ICBhbiBhdHRyaWJ1dGUgdXNlIAogKgogKiBTY2hlbWEgQ29tcG9uZW50IENvbnN0cmFpbnQ6CiAqIEF0dHJpYnV0ZSBVc2UgQ29ycmVjdCAoYXUtcHJvcHMtY29ycmVjdCkKICogCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQXR0clVzZVByb3BzQ29ycmVjdCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCSAgICAgeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIHVzZSkKewogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8ICh1c2UgPT0gTlVMTCkpCglyZXR1cm4oLTEpOwogICAgaWYgKCh1c2UtPmRlZlZhbHVlID09IE5VTEwpIHx8IChXWFNfQVRUUlVTRV9ERUNMKHVzZSkgPT0gTlVMTCkgfHwKCSgoV1hTX0FUVFJVU0VfREVDTCh1c2UpKS0+dHlwZSAhPSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFKSkKCXJldHVybigwKTsJCgogICAgLyoKICAgICogU1BFQyBhdS1wcm9wcy1jb3JyZWN0ICgxKQogICAgKiAiVGhlIHZhbHVlcyBvZiB0aGUgcHJvcGVydGllcyBvZiBhbiBhdHRyaWJ1dGUgdXNlIG11c3QgYmUgYXMKICAgICogZGVzY3JpYmVkIGluIHRoZSBwcm9wZXJ0eSB0YWJsZWF1IGluIFRoZSBBdHRyaWJ1dGUgVXNlIFNjaGVtYQogICAgKiBDb21wb25lbnQgKKczLjUuMSksIG1vZHVsbyB0aGUgaW1wYWN0IG9mIE1pc3NpbmcKICAgICogU3ViLWNvbXBvbmVudHMgKKc1LjMpLiIKICAgICovCiAgICAKICAgIGlmICgoKFdYU19BVFRSVVNFX0RFQ0wodXNlKSktPmRlZlZhbHVlICE9IE5VTEwpICYmCgkoKFdYU19BVFRSVVNFX0RFQ0wodXNlKSktPmZsYWdzICYgWE1MX1NDSEVNQVNfQVRUUl9GSVhFRCkgJiYKICAgICAgICAoKHVzZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BX0FUVFJfVVNFX0ZJWEVEKSA9PSAwKSkKICAgIHsKCXhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9BVV9QUk9QU19DT1JSRUNUXzIsCgkgICAgV1hTX0JBU0lDX0NBU1QgdXNlLCBOVUxMLAoJICAgICJUaGUgYXR0cmlidXRlIGRlY2xhcmF0aW9uIGhhcyBhICdmaXhlZCcgdmFsdWUgY29uc3RyYWludCAiCgkgICAgIiwgdGh1cyB0aGUgYXR0cmlidXRlIHVzZSBtdXN0IGFsc28gaGF2ZSBhICdmaXhlZCcgdmFsdWUgIgoJICAgICJjb25zdHJhaW50IiwKCSAgICBOVUxMKTsKCXJldHVybihjdHh0LT5lcnIpOwogICAgfQogICAgLyoKICAgICogQ29tcHV0ZSBhbmQgY2hlY2sgdGhlIHZhbHVlIGNvbnN0cmFpbnQncyB2YWx1ZS4KICAgICovCiAgICBpZiAoKHVzZS0+ZGVmVmFsICE9IE5VTEwpICYmIChXWFNfQVRUUlVTRV9UWVBFREVGKHVzZSkgIT0gTlVMTCkpIHsKCWludCByZXQ7CgkvKgoJKiBUT0RPOiBUaGUgc3BlYyBzZWVtcyB0byBiZSBtaXNzaW5nIGEgY2hlY2sgb2YgdGhlIAoJKiB2YWx1ZSBjb25zdHJhaW50IG9mIHRoZSBhdHRyaWJ1dGUgdXNlLiBXZSB3aWxsIGRvIGl0IGhlcmUuCgkqLwoJLyoKCSogU1BFQyBhLXByb3BzLWNvcnJlY3QgKDMpCgkqLwoJaWYgKHhtbFNjaGVtYUlzRGVyaXZlZEZyb21CdWlsdEluVHlwZSgKCSAgICBXWFNfQVRUUlVTRV9UWVBFREVGKHVzZSksIFhNTF9TQ0hFTUFTX0lEKSkKCXsKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBjdHh0LAoJCVhNTF9TQ0hFTUFQX0FVX1BST1BTX0NPUlJFQ1QsCgkJTlVMTCwgV1hTX0JBU0lDX0NBU1QgdXNlLAoJCSJWYWx1ZSBjb25zdHJhaW50cyBhcmUgbm90IGFsbG93ZWQgaWYgdGhlIHR5cGUgZGVmaW5pdGlvbiAiCgkJImlzIG9yIGlzIGRlcml2ZWQgZnJvbSB4czpJRCIsCgkJTlVMTCwgTlVMTCk7CgkgICAgcmV0dXJuKGN0eHQtPmVycik7Cgl9CgkKCXJldCA9IHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoQUNUWFRfQ0FTVCBjdHh0LAoJICAgIHVzZS0+bm9kZSwgV1hTX0FUVFJVU0VfVFlQRURFRih1c2UpLAoJICAgIHVzZS0+ZGVmVmFsdWUsICYodXNlLT5kZWZWYWwpLAoJICAgIDEsIDEsIDApOwoJaWYgKHJldCAhPSAwKSB7CgkgICAgaWYgKHJldCA8IDApIHsKCQlQRVJST1JfSU5UMigieG1sU2NoZW1hQ2hlY2tBdHRyVXNlUHJvcHNDb3JyZWN0IiwKCQkgICAgImNhbGxpbmcgeG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSgpIik7CgkJcmV0dXJuKC0xKTsKCSAgICB9CgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgY3R4dCwKCQlYTUxfU0NIRU1BUF9BVV9QUk9QU19DT1JSRUNULAoJCU5VTEwsIFdYU19CQVNJQ19DQVNUIHVzZSwKCQkiVGhlIHZhbHVlIG9mIHRoZSB2YWx1ZSBjb25zdHJhaW50IGlzIG5vdCB2YWxpZCIsCgkJTlVMTCwgTlVMTCk7CgkgICAgcmV0dXJuKGN0eHQtPmVycik7Cgl9CiAgICB9CiAgICAvKgogICAgKiBTUEVDIGF1LXByb3BzLWNvcnJlY3QgKDIpCiAgICAqICJJZiB0aGUge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0gaGFzIGEgZml4ZWQKICAgICoge3ZhbHVlIGNvbnN0cmFpbnR9LCB0aGVuIGlmIHRoZSBhdHRyaWJ1dGUgdXNlIGl0c2VsZiBoYXMgYQogICAgKiB7dmFsdWUgY29uc3RyYWludH0sIGl0IG11c3QgYWxzbyBiZSBmaXhlZCBhbmQgaXRzIHZhbHVlIG11c3QgbWF0Y2gKICAgICogdGhhdCBvZiB0aGUge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0ncyB7dmFsdWUgY29uc3RyYWludH0uIgogICAgKi8KICAgIGlmICgoKFdYU19BVFRSVVNFX0RFQ0wodXNlKSktPmRlZlZhbCAhPSBOVUxMKSAmJgoJKCgoV1hTX0FUVFJVU0VfREVDTCh1c2UpKS0+ZmxhZ3MgJiBYTUxfU0NIRU1BX0FUVFJfVVNFX0ZJWEVEKSA9PSAwKSkKICAgIHsKCWlmICghIHhtbFNjaGVtYUFyZVZhbHVlc0VxdWFsKHVzZS0+ZGVmVmFsLAoJCShXWFNfQVRUUlVTRV9ERUNMKHVzZSkpLT5kZWZWYWwpKQoJewoJICAgIHhtbFNjaGVtYVBDdXN0b21FcnIoY3R4dCwKCQlYTUxfU0NIRU1BUF9BVV9QUk9QU19DT1JSRUNUXzIsCgkJV1hTX0JBU0lDX0NBU1QgdXNlLCBOVUxMLAoJCSJUaGUgJ2ZpeGVkJyB2YWx1ZSBjb25zdHJhaW50IG9mIHRoZSBhdHRyaWJ1dGUgdXNlICIKCQkibXVzdCBtYXRjaCB0aGUgYXR0cmlidXRlIGRlY2xhcmF0aW9uJ3MgdmFsdWUgIgoJCSJjb25zdHJhaW50ICclcyciLAoJCShXWFNfQVRUUlVTRV9ERUNMKHVzZSkpLT5kZWZWYWx1ZSk7Cgl9CglyZXR1cm4oY3R4dC0+ZXJyKTsKICAgIH0KICAgIHJldHVybigwKTsKfQoKCgoKLyoqCiAqIHhtbFNjaGVtYVJlc29sdmVBdHRyVHlwZVJlZmVyZW5jZXM6CiAqIEBpdGVtOiAgYW4gYXR0cmlidXRlIGRlY2xhcmF0aW9uCiAqIEBjdHh0OiAgYSBwYXJzZXIgY29udGV4dCAKICoKICogUmVzb2x2ZXMgdGhlIHJlZmVyZW5jZWQgdHlwZSBkZWZpbml0aW9uIGNvbXBvbmVudC4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUmVzb2x2ZUF0dHJUeXBlUmVmZXJlbmNlcyh4bWxTY2hlbWFBdHRyaWJ1dGVQdHIgaXRlbSwKCQkJCSAgIHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgY3R4dCkKewogICAgLyoKICAgICogVGhlIHNpbXBsZSB0eXBlIGRlZmluaXRpb24gY29ycmVzcG9uZGluZyB0byB0aGUgPHNpbXBsZVR5cGU+IGVsZW1lbnQKICAgICogaW5mb3JtYXRpb24gaXRlbSBpbiB0aGUgW2NoaWxkcmVuXSwgaWYgcHJlc2VudCwgb3RoZXJ3aXNlIHRoZSBzaW1wbGUKICAgICogdHlwZSBkZWZpbml0aW9uILdyZXNvbHZlZLcgdG8gYnkgdGhlILdhY3R1YWwgdmFsdWW3IG9mIHRoZSB0eXBlCiAgICAqIFthdHRyaWJ1dGVdLCBpZiBwcmVzZW50LCBvdGhlcndpc2UgdGhlILdzaW1wbGUgdXItdHlwZSBkZWZpbml0aW9uty4KICAgICovCiAgICBpZiAoaXRlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSX0lOVEVSTkFMX1JFU09MVkVEKQoJcmV0dXJuKDApOwogICAgaXRlbS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQVNfQVRUUl9JTlRFUk5BTF9SRVNPTFZFRDsKICAgIGlmIChpdGVtLT5zdWJ0eXBlcyAhPSBOVUxMKQogICAgICAgIHJldHVybigwKTsKICAgIGlmIChpdGVtLT50eXBlTmFtZSAhPSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlOwoKCXR5cGUgPSB4bWxTY2hlbWFHZXRUeXBlKGN0eHQtPnNjaGVtYSwgaXRlbS0+dHlwZU5hbWUsCgkgICAgaXRlbS0+dHlwZU5zKTsKCWlmICgodHlwZSA9PSBOVUxMKSB8fCAoISBXWFNfSVNfU0lNUExFKHR5cGUpKSkgewoJICAgIHhtbFNjaGVtYVBSZXNDb21wQXR0ckVycihjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19SRVNPTFZFLAoJCVdYU19CQVNJQ19DQVNUIGl0ZW0sIGl0ZW0tPm5vZGUsCgkJInR5cGUiLCBpdGVtLT50eXBlTmFtZSwgaXRlbS0+dHlwZU5zLAoJCVhNTF9TQ0hFTUFfVFlQRV9TSU1QTEUsIE5VTEwpOwoJICAgIHJldHVybihjdHh0LT5lcnIpOwoJfSBlbHNlCgkgICAgaXRlbS0+c3VidHlwZXMgPSB0eXBlOwoKICAgIH0gZWxzZSB7CgkvKgoJKiBUaGUgdHlwZSBkZWZhdWx0cyB0byB0aGUgeHM6YW55U2ltcGxlVHlwZS4KCSovCglpdGVtLT5zdWJ0eXBlcyA9IHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVNJTVBMRVRZUEUpOwogICAgfQogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hUmVzb2x2ZUlEQ0tleVJlZmVyZW5jZXM6CiAqIEBpZGM6ICB0aGUgaWRlbnRpdHktY29uc3RyYWludCBkZWZpbml0aW9uCiAqIEBjdHh0OiAgdGhlIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAbmFtZTogIHRoZSBhdHRyaWJ1dGUgbmFtZQogKgogKiBSZXNvbHZlIGtleVJlZiByZWZlcmVuY2VzIHRvIGtleS91bmlxdWUgSURDcy4KICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OgogKiAgIElkZW50aXR5LWNvbnN0cmFpbnQgRGVmaW5pdGlvbiBQcm9wZXJ0aWVzIENvcnJlY3QgKGMtcHJvcHMtY29ycmVjdCkKICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hUmVzb2x2ZUlEQ0tleVJlZmVyZW5jZXMoeG1sU2NoZW1hSURDUHRyIGlkYywKCQkJICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0KQp7CiAgICBpZiAoaWRjLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGKQogICAgICAgIHJldHVybigwKTsKICAgIGlmIChpZGMtPnJlZi0+bmFtZSAhPSBOVUxMKSB7CglpZGMtPnJlZi0+aXRlbSA9ICh4bWxTY2hlbWFCYXNpY0l0ZW1QdHIpCgkgICAgeG1sU2NoZW1hR2V0SURDKHBjdHh0LT5zY2hlbWEsIGlkYy0+cmVmLT5uYW1lLAoJCWlkYy0+cmVmLT50YXJnZXROYW1lc3BhY2UpOwogICAgICAgIGlmIChpZGMtPnJlZi0+aXRlbSA9PSBOVUxMKSB7CgkgICAgLyoKCSAgICAqIFRPRE86IEl0IGlzIGFjdHVhbGx5IG5vdCBhbiBlcnJvciB0byBmYWlsIHRvIHJlc29sdmUKCSAgICAqIGF0IHRoaXMgc3RhZ2UuIEJVVCB3ZSBuZWVkIHRvIGJlIHRoYXQgc3RyaWN0IQoJICAgICovCgkgICAgeG1sU2NoZW1hUFJlc0NvbXBBdHRyRXJyKHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1NSQ19SRVNPTFZFLAoJCVdYU19CQVNJQ19DQVNUIGlkYywgaWRjLT5ub2RlLAoJCSJyZWZlciIsIGlkYy0+cmVmLT5uYW1lLAoJCWlkYy0+cmVmLT50YXJnZXROYW1lc3BhY2UsCgkJWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVksIE5VTEwpOwogICAgICAgICAgICByZXR1cm4ocGN0eHQtPmVycik7Cgl9IGVsc2UgaWYgKGlkYy0+cmVmLT5pdGVtLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGKSB7CgkgICAgLyoKCSAgICAqIFNQRUMgYy1wcm9wcy1jb3JyZWN0ICgxKQoJICAgICovCgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJWE1MX1NDSEVNQVBfQ19QUk9QU19DT1JSRUNULAoJCU5VTEwsIFdYU19CQVNJQ19DQVNUIGlkYywKCQkiVGhlIGtleXJlZiByZWZlcmVuY2VzIGEga2V5cmVmIiwKCQlOVUxMLCBOVUxMKTsKCSAgICBpZGMtPnJlZi0+aXRlbSA9IE5VTEw7CgkgICAgcmV0dXJuKHBjdHh0LT5lcnIpOwoJfSBlbHNlIHsKCSAgICBpZiAoaWRjLT5uYkZpZWxkcyAhPQoJCSgoeG1sU2NoZW1hSURDUHRyKSBpZGMtPnJlZi0+aXRlbSktPm5iRmllbGRzKSB7CgkJeG1sQ2hhciAqc3RyID0gTlVMTDsKCQl4bWxTY2hlbWFJRENQdHIgcmVmZXI7CgkJCgkJcmVmZXIgPSAoeG1sU2NoZW1hSURDUHRyKSBpZGMtPnJlZi0+aXRlbTsKCQkvKgoJCSogU1BFQyBjLXByb3BzLWNvcnJlY3QoMikKCQkqICJJZiB0aGUge2lkZW50aXR5LWNvbnN0cmFpbnQgY2F0ZWdvcnl9IGlzIGtleXJlZiwKCQkqIHRoZSBjYXJkaW5hbGl0eSBvZiB0aGUge2ZpZWxkc30gbXVzdCBlcXVhbCB0aGF0IG9mCgkJKiB0aGUge2ZpZWxkc30gb2YgdGhlIHtyZWZlcmVuY2VkIGtleX0uCgkJKi8KCQl4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQkgICAgWE1MX1NDSEVNQVBfQ19QUk9QU19DT1JSRUNULAoJCSAgICBOVUxMLCBXWFNfQkFTSUNfQ0FTVCBpZGMsCgkJICAgICJUaGUgY2FyZGluYWxpdHkgb2YgdGhlIGtleXJlZiBkaWZmZXJzIGZyb20gdGhlICIKCQkgICAgImNhcmRpbmFsaXR5IG9mIHRoZSByZWZlcmVuY2VkIGtleS91bmlxdWUgJyVzJyIsCgkJICAgIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIHJlZmVyLT50YXJnZXROYW1lc3BhY2UsCgkJCXJlZmVyLT5uYW1lKSwKCQkgICAgTlVMTCk7CgkJRlJFRV9BTkRfTlVMTChzdHIpCgkJcmV0dXJuKHBjdHh0LT5lcnIpOwoJICAgIH0KCX0KICAgIH0KICAgIHJldHVybigwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFSZXNvbHZlQXR0clVzZVByb2hpYlJlZmVyZW5jZXMoeG1sU2NoZW1hQXR0cmlidXRlVXNlUHJvaGliUHRyIHByb2hpYiwKCQkJCSAgICAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0KQp7CiAgICBpZiAoeG1sU2NoZW1hR2V0QXR0cmlidXRlRGVjbChwY3R4dC0+c2NoZW1hLCBwcm9oaWItPm5hbWUsCglwcm9oaWItPnRhcmdldE5hbWVzcGFjZSkgPT0gTlVMTCkgewoKCXhtbFNjaGVtYVBSZXNDb21wQXR0ckVycihwY3R4dCwKCSAgICBYTUxfU0NIRU1BUF9TUkNfUkVTT0xWRSwKCSAgICBOVUxMLCBwcm9oaWItPm5vZGUsCgkgICAgInJlZiIsIHByb2hpYi0+bmFtZSwgcHJvaGliLT50YXJnZXROYW1lc3BhY2UsCgkgICAgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURSwgTlVMTCk7CglyZXR1cm4oWE1MX1NDSEVNQVBfU1JDX1JFU09MVkUpOwogICAgfQogICAgcmV0dXJuKDApOwp9CgojZGVmaW5lIFdYU19SRURFRklORURfVFlQRShjKSBcCigoKHhtbFNjaGVtYVR5cGVQdHIpIGl0ZW0pLT5mbGFncyAmIFhNTF9TQ0hFTUFTX1RZUEVfUkVERUZJTkVEKQoKI2RlZmluZSBXWFNfUkVERUZJTkVEX01PREVMX0dST1VQX0RFRihjKSBcCigoKHhtbFNjaGVtYU1vZGVsR3JvdXBEZWZQdHIpIGl0ZW0pLT5mbGFncyAmIFhNTF9TQ0hFTUFfTU9ERUxfR1JPVVBfREVGX1JFREVGSU5FRCkKCiNkZWZpbmUgV1hTX1JFREVGSU5FRF9BVFRSX0dST1VQKGMpIFwKKCgoeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBQdHIpIGl0ZW0pLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9SRURFRklORUQpCgpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrU1JDUmVkZWZpbmVGaXJzdCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0KQp7CiAgICBpbnQgZXJyID0gMDsKICAgIHhtbFNjaGVtYVJlZGVmUHRyIHJlZGVmID0gV1hTX0NPTlNUUlVDVE9SKHBjdHh0KS0+cmVkZWZzOwogICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIHByZXYsIGl0ZW07CiAgICBpbnQgd2FzUmVkZWZpbmVkOwoKICAgIGlmIChyZWRlZiA9PSBOVUxMKQoJcmV0dXJuKDApOyAgIAkKCiAgICBkbyB7CglpdGVtID0gcmVkZWYtPml0ZW07CgkvKgoJKiBGaXJzdCB0cnkgdG8gbG9jYXRlIHRoZSByZWRlZmluZWQgY29tcG9uZW50IGluIHRoZQoJKiBzY2hlbWEgZ3JhcGggc3RhcnRpbmcgd2l0aCB0aGUgcmVkZWZpbmVkIHNjaGVtYS4KCSogTk9URTogQWNjb3JkaW5nIHRvIHRoaXMgc2NoZW1hIGJ1ZyBlbnRyeToKCSogICBodHRwOi8vbGlzdHMudzMub3JnL0FyY2hpdmVzL1B1YmxpYy93d3cteG1sLXNjaGVtYS1jb21tZW50cy8yMDA1T2N0RGVjLzAwMTkuaHRtbAoJKiAgIGl0J3Mgbm90IGNsZWFyIGlmIHRoZSByZWZlcmVuY2VkIGNvbXBvbmVudCBuZWVkcyB0byBvcmlnaW5hdGUKCSogICBmcm9tIHRoZSA8cmVkZWZpbmU+ZCBzY2hlbWEgX2RvY3VtZW50XyBvciB0aGUgc2NoZW1hOyB0aGUgbGF0dGVyCgkqICAgd291bGQgaW5jbHVkZSBhbGwgaW1wb3J0ZWQgYW5kIGluY2x1ZGVkIHN1Yi1zY2hlbWFzIG9mIHRoZQoJKiAgIDxyZWRlZmluZT5kIHNjaGVtYS4gQ3VycmVubHR5IHdlIGxhdHRlciBhcHByb2FjaCBpcyB1c2VkLgoJKiAgIFNVUFBMRU1FTlQ6IEl0IHNlZW1zIHRoYXQgdGhlIFdHIG1vdmVzIHRvd2FyZHMgdGhlIGxhdHRlcgoJKiAgIGFwcHJvYWNoLCBzbyB3ZSBhcmUgZG9pbmcgaXQgcmlnaHQuCgkqICAgCgkqLwoJcHJldiA9IHhtbFNjaGVtYUZpbmRSZWRlZkNvbXBJbkdyYXBoKAoJICAgIHJlZGVmLT50YXJnZXRCdWNrZXQsIGl0ZW0tPnR5cGUsCgkgICAgcmVkZWYtPnJlZk5hbWUsIHJlZGVmLT5yZWZUYXJnZXROcyk7CglpZiAocHJldiA9PSBOVUxMKSB7CgkgICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCSAgICB4bWxOb2RlUHRyIG5vZGU7CgoJICAgIC8qCgkgICAgKiBTUEVDIHNyYy1yZWRlZmluZToKCSAgICAqICg2LjIuMSkgIlRoZSC3YWN0dWFsIHZhbHVltyBvZiBpdHMgb3duIG5hbWUgYXR0cmlidXRlIHBsdXMKCSAgICAqIHRhcmdldCBuYW1lc3BhY2UgbXVzdCBzdWNjZXNzZnVsbHkgt3Jlc29sdmW3IHRvIGEgbW9kZWwKCSAgICAqIGdyb3VwIGRlZmluaXRpb24gaW4gSS4iCgkgICAgKiAoNy4yLjEpICJUaGUgt2FjdHVhbCB2YWx1Zbcgb2YgaXRzIG93biBuYW1lIGF0dHJpYnV0ZSBwbHVzCgkgICAgKiB0YXJnZXQgbmFtZXNwYWNlIG11c3Qgc3VjY2Vzc2Z1bGx5ILdyZXNvbHZltyB0byBhbiBhdHRyaWJ1dGUKCSAgICAqIGdyb3VwIGRlZmluaXRpb24gaW4gSS4iCgoJICAgICoKCSAgICAqIE5vdGUgdGhhdCwgaWYgd2UgYXJlIHJlZGVmaW5pbmcgd2l0aCB0aGUgdXNlIG9mIHJlZmVyZW5jZXMKCSAgICAqIHRvIGNvbXBvbmVudHMsIHRoZSBzcGVjIGFzc3VtZXMgdGhlIHNyYy1yZXNvbHZlIHRvIGJlIHVzZWQ7CgkgICAgKiBidXQgdGhpcyB3b24ndCBhc3N1cmUgdGhhdCB3ZSBzZWFyY2ggb25seSAqaW5zaWRlKiB0aGUKCSAgICAqIHJlZGVmaW5lZCBzY2hlbWEuCgkgICAgKi8KCSAgICBpZiAocmVkZWYtPnJlZmVyZW5jZSkKCQlub2RlID0gV1hTX0lURU1fTk9ERShyZWRlZi0+cmVmZXJlbmNlKTsKCSAgICBlbHNlCgkJbm9kZSA9IFdYU19JVEVNX05PREUoaXRlbSk7CgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgcGN0eHQsCgkJLyoKCQkqIFRPRE86IGVycm9yIGNvZGUuCgkJKiBQcm9iYWJseSBYTUxfU0NIRU1BUF9TUkNfUkVTT0xWRSwgaWYgdGhpcyBpcyB1c2luZyB0aGUKCQkqIHJlZmVyZW5jZSBraW5kLgkJCgkJKi8KCQlYTUxfU0NIRU1BUF9TUkNfUkVERUZJTkUsIG5vZGUsIE5VTEwsCgkJIlRoZSAlcyAnJXMnIHRvIGJlIHJlZGVmaW5lZCBjb3VsZCBub3QgYmUgZm91bmQgaW4gIgoJCSJ0aGUgcmVkZWZpbmVkIHNjaGVtYSIsCgkJV1hTX0lURU1fVFlQRV9OQU1FKGl0ZW0pLAoJCXhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIHJlZGVmLT5yZWZUYXJnZXROcywKCQkgICAgcmVkZWYtPnJlZk5hbWUpKTsKCSAgICBGUkVFX0FORF9OVUxMKHN0cik7CSAgICAKCSAgICBlcnIgPSBwY3R4dC0+ZXJyOwoJICAgIHJlZGVmID0gcmVkZWYtPm5leHQ7CgkgICAgY29udGludWU7Cgl9CgkvKgoJKiBUT0RPOiBPYnRhaW5pbmcgYW5kIHNldHRpbmcgdGhlIHJlZGVmaW5pdGlvbiBzdGF0ZSBpcyByZWFsbHkKCSogY2x1bXN5LgoJKi8KCXdhc1JlZGVmaW5lZCA9IDA7Cglzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9DT01QTEVYOgoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX1NJTVBMRToKCQlpZiAoKFdYU19UWVBFX0NBU1QgcHJldiktPmZsYWdzICYKCQkgICAgWE1MX1NDSEVNQVNfVFlQRV9SRURFRklORUQpCgkJewoJCSAgICB3YXNSZWRlZmluZWQgPSAxOwoJCSAgICBicmVhazsKCQl9CgkJLyogTWFyayBpdCBhcyByZWRlZmluZWQuICovCgkJKFdYU19UWVBFX0NBU1QgcHJldiktPmZsYWdzIHw9IFhNTF9TQ0hFTUFTX1RZUEVfUkVERUZJTkVEOwoJCS8qCgkJKiBBc3NpZ24gdGhlIHJlZGVmaW5lZCB0eXBlIHRvIHRoZQoJCSogYmFzZSB0eXBlIG9mIHRoZSByZWRlZmluaW5nIHR5cGUuCgkJKiBUT0RPOiBIb3cKCQkqLwoJCSgoeG1sU2NoZW1hVHlwZVB0cikgaXRlbSktPmJhc2VUeXBlID0gCgkJICAgICh4bWxTY2hlbWFUeXBlUHRyKSBwcmV2OwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0dST1VQOgoJCWlmICgoV1hTX01PREVMX0dST1VQREVGX0NBU1QgcHJldiktPmZsYWdzICYKCQkgICAgWE1MX1NDSEVNQV9NT0RFTF9HUk9VUF9ERUZfUkVERUZJTkVEKQoJCXsKCQkgICAgd2FzUmVkZWZpbmVkID0gMTsKCQkgICAgYnJlYWs7CgkJfQoJCS8qIE1hcmsgaXQgYXMgcmVkZWZpbmVkLiAqLwoJCShXWFNfTU9ERUxfR1JPVVBERUZfQ0FTVCBwcmV2KS0+ZmxhZ3MgfD0KCQkgICAgWE1MX1NDSEVNQV9NT0RFTF9HUk9VUF9ERUZfUkVERUZJTkVEOwoJCWlmIChyZWRlZi0+cmVmZXJlbmNlICE9IE5VTEwpIHsKCQkgICAgLyoKCQkgICAgKiBPdmVyd3JpdGUgdGhlIFFOYW1lLXJlZmVyZW5jZSB3aXRoIHRoZQoJCSAgICAqIHJlZmVyZW5jZWQgbW9kZWwgZ3JvdXAgZGVmLgoJCSAgICAqLwoJCSAgICAoV1hTX1BUQ19DQVNUIHJlZGVmLT5yZWZlcmVuY2UpLT5jaGlsZHJlbiA9CgkJCVdYU19UUkVFX0NBU1QgcHJldjsKCQl9CgkJcmVkZWYtPnRhcmdldCA9IHByZXY7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVA6CgkJaWYgKChXWFNfQVRUUl9HUk9VUF9DQVNUIHByZXYpLT5mbGFncyAmCgkJICAgIFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9SRURFRklORUQpCgkJewoJCSAgICB3YXNSZWRlZmluZWQgPSAxOwoJCSAgICBicmVhazsKCQl9CgkJKFdYU19BVFRSX0dST1VQX0NBU1QgcHJldiktPmZsYWdzIHw9CgkJICAgIFhNTF9TQ0hFTUFTX0FUVFJHUk9VUF9SRURFRklORUQ7CgkJaWYgKHJlZGVmLT5yZWZlcmVuY2UgIT0gTlVMTCkgewoJCSAgICAvKgoJCSAgICAqIEFzc2lnbiB0aGUgcmVkZWZpbmVkIGF0dHJpYnV0ZSBncm91cCB0byB0aGUKCQkgICAgKiBRTmFtZS1yZWZlcmVuY2UgY29tcG9uZW50LgoJCSAgICAqIFRoaXMgaXMgdGhlIGVhc3kgY2FzZSwgc2luY2Ugd2Ugd2lsbCBqdXN0CgkJICAgICogZXhwYW5kIHRoZSByZWRlZmluZWQgZ3JvdXAuCgkJICAgICovCgkJICAgIChXWFNfUU5BTUVfQ0FTVCByZWRlZi0+cmVmZXJlbmNlKS0+aXRlbSA9IHByZXY7CgkJICAgIHJlZGVmLT50YXJnZXQgPSBOVUxMOwoJCX0gZWxzZSB7CgkJICAgIC8qCgkJICAgICogVGhpcyBpcyB0aGUgY29tcGxpY2F0ZWQgY2FzZTogd2UgbmVlZAoJCSAgICAqIHRvIGFwcGx5IHNyYy1yZWRlZmluZSAoNy4yLjIpIGF0IGEgbGF0ZXIKCQkgICAgKiBzdGFnZSwgaS5lLiB3aGVuIGF0dHJpYnV0ZSBncm91cCByZWZlcmVuY2VzCgkJICAgICogaGF2ZSBiZWVkIGV4cGFuZGVkIGFuZCBzaW1wbGUgdHlwZXMgaGF2ZQoJCSAgICAqIGJlZWQgZml4ZWQuCgkJICAgICovCgkJICAgIHJlZGVmLT50YXJnZXQgPSBwcmV2OwoJCX0KCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCVBFUlJPUl9JTlQoInhtbFNjaGVtYVJlc29sdmVSZWRlZlJlZmVyZW5jZXMiLAoJCSAgICAiVW5leHBlY3RlZCByZWRlZmluZWQgY29tcG9uZW50IHR5cGUiKTsKCQlyZXR1cm4oLTEpOwkKCX0KCWlmICh3YXNSZWRlZmluZWQpIHsKCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJICAgIHhtbE5vZGVQdHIgbm9kZTsKCgkgICAgaWYgKHJlZGVmLT5yZWZlcmVuY2UpCgkJbm9kZSA9IFdYU19JVEVNX05PREUocmVkZWYtPnJlZmVyZW5jZSk7CgkgICAgZWxzZQoJCW5vZGUgPSBXWFNfSVRFTV9OT0RFKHJlZGVmLT5pdGVtKTsKCSAgICAKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBwY3R4dCwKCQkvKiBUT0RPOiBlcnJvciBjb2RlLiAqLwoJCVhNTF9TQ0hFTUFQX1NSQ19SRURFRklORSwKCQlub2RlLCBOVUxMLAoJCSJUaGUgcmVmZXJlbmNlZCAlcyB3YXMgYWxyZWFkeSByZWRlZmluZWQuIE11bHRpcGxlICIKCQkicmVkZWZpbml0aW9uIG9mIHRoZSBzYW1lIGNvbXBvbmVudCBpcyBub3Qgc3VwcG9ydGVkIiwKCQl4bWxTY2hlbWFHZXRDb21wb25lbnREZXNpZ25hdGlvbigmc3RyLCBwcmV2KSwKCQlOVUxMKTsKCSAgICBGUkVFX0FORF9OVUxMKHN0cikJICAgIAoJICAgIGVyciA9IHBjdHh0LT5lcnI7CgkgICAgcmVkZWYgPSByZWRlZi0+bmV4dDsKCSAgICBjb250aW51ZTsKCX0KCXJlZGVmID0gcmVkZWYtPm5leHQ7CQogICAgfSB3aGlsZSAocmVkZWYgIT0gTlVMTCk7CgogICAgcmV0dXJuKGVycik7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hQ2hlY2tTUkNSZWRlZmluZVNlY29uZCh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0KQp7CiAgICBpbnQgZXJyID0gMDsKICAgIHhtbFNjaGVtYVJlZGVmUHRyIHJlZGVmID0gV1hTX0NPTlNUUlVDVE9SKHBjdHh0KS0+cmVkZWZzOwogICAgeG1sU2NoZW1hQmFzaWNJdGVtUHRyIGl0ZW07CgogICAgaWYgKHJlZGVmID09IE5VTEwpCglyZXR1cm4oMCk7ICAgCQoKICAgIGRvIHsKCWlmIChyZWRlZi0+dGFyZ2V0ID09IE5VTEwpIHsKCSAgICByZWRlZiA9IHJlZGVmLT5uZXh0OwoJICAgIGNvbnRpbnVlOwoJfQoJaXRlbSA9IHJlZGVmLT5pdGVtOwoJCQoJc3dpdGNoIChpdGVtLT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVg6CgkJLyoKCQkqIFNpbmNlIHRoZSBzcGVjIHdhbnRzIHRoZSB7bmFtZX0gb2YgdGhlIHJlZGVmaW5lZAoJCSogdHlwZSB0byBiZSAnYWJzZW50Jywgd2UnbGwgTlVMTCBpdC4KCQkqLwoJCShXWFNfVFlQRV9DQVNUIHJlZGVmLT50YXJnZXQpLT5uYW1lID0gTlVMTDsKCQkKCQkvKgoJCSogVE9ETzogU2VlbXMgbGlrZSB0aGVyZSdzIG5vdGhpbmcgbW9yZSB0byBkby4gVGhlIG5vcm1hbAoJCSogaW5oZXJpdGFuY2UgbWVjaGFuaXNtIGlzIHVzZWQuIEJ1dCBub3QgMTAwJSBzdXJlLgoJCSovCgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkJLyoKCQkqIFVSR0VOVCBUT0RPOgoJCSogU1BFQyBzcmMtcmVkZWZpbmU6CgkJKiAoNi4yLjIpICJUaGUge21vZGVsIGdyb3VwfSBvZiB0aGUgbW9kZWwgZ3JvdXAgZGVmaW5pdGlvbgoJCSogd2hpY2ggY29ycmVzcG9uZHMgdG8gaXQgcGVyIFhNTCBSZXByZXNlbnRhdGlvbiBvZiBNb2RlbAoJCSogR3JvdXAgRGVmaW5pdGlvbiBTY2hlbWEgQ29tcG9uZW50cyAopzMuNy4yKSBtdXN0IGJlIGEKCQkqILd2YWxpZCByZXN0cmljdGlvbrcgb2YgdGhlIHttb2RlbCBncm91cH0gb2YgdGhhdCBtb2RlbAoJCSogZ3JvdXAgZGVmaW5pdGlvbiBpbiBJLCBhcyBkZWZpbmVkIGluIFBhcnRpY2xlIFZhbGlkCgkJKiAoUmVzdHJpY3Rpb24pICinMy45LjYpLiIKCQkqLwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQOgoJCS8qCgkJKiBTUEVDIHNyYy1yZWRlZmluZToKCQkqICg3LjIuMikgIlRoZSB7YXR0cmlidXRlIHVzZXN9IGFuZCB7YXR0cmlidXRlIHdpbGRjYXJkfSBvZgoJCSogdGhlIGF0dHJpYnV0ZSBncm91cCBkZWZpbml0aW9uIHdoaWNoIGNvcnJlc3BvbmRzIHRvIGl0CgkJKiBwZXIgWE1MIFJlcHJlc2VudGF0aW9uIG9mIEF0dHJpYnV0ZSBHcm91cCBEZWZpbml0aW9uIFNjaGVtYQoJCSogQ29tcG9uZW50cyAopzMuNi4yKSBtdXN0IGJlILd2YWxpZCByZXN0cmljdGlvbnO3IG9mIHRoZQoJCSoge2F0dHJpYnV0ZSB1c2VzfSBhbmQge2F0dHJpYnV0ZSB3aWxkY2FyZH0gb2YgdGhhdCBhdHRyaWJ1dGUKCQkqIGdyb3VwIGRlZmluaXRpb24gaW4gSSwgYXMgZGVmaW5lZCBpbiBjbGF1c2UgMiwgY2xhdXNlIDMgYW5kCgkJKiBjbGF1c2UgNCBvZiBEZXJpdmF0aW9uIFZhbGlkIChSZXN0cmljdGlvbiwgQ29tcGxleCkKCQkqICinMy40LjYpICh3aGVyZSByZWZlcmVuY2VzIHRvIHRoZSBiYXNlIHR5cGUgZGVmaW5pdGlvbiBhcmUKCQkqIHVuZGVyc3Rvb2QgYXMgcmVmZXJlbmNlcyB0byB0aGUgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb24KCQkqIGluIEkpLiIKCQkqLwoJCWVyciA9IHhtbFNjaGVtYUNoZWNrRGVyaXZhdGlvbk9LUmVzdHJpY3Rpb24ydG80KHBjdHh0LAoJCSAgICBYTUxfU0NIRU1BX0FDVElPTl9SRURFRklORSwKCQkgICAgaXRlbSwgcmVkZWYtPnRhcmdldCwKCQkgICAgKFdYU19BVFRSX0dST1VQX0NBU1QgaXRlbSktPmF0dHJVc2VzLAoJCSAgICAoV1hTX0FUVFJfR1JPVVBfQ0FTVCByZWRlZi0+dGFyZ2V0KS0+YXR0clVzZXMsCgkJICAgIChXWFNfQVRUUl9HUk9VUF9DQVNUIGl0ZW0pLT5hdHRyaWJ1dGVXaWxkY2FyZCwKCQkgICAgKFdYU19BVFRSX0dST1VQX0NBU1QgcmVkZWYtPnRhcmdldCktPmF0dHJpYnV0ZVdpbGRjYXJkKTsKCQlpZiAoZXJyID09IC0xKQoJCSAgICByZXR1cm4oLTEpOwoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CglyZWRlZiA9IHJlZGVmLT5uZXh0OwogICAgfSB3aGlsZSAocmVkZWYgIT0gTlVMTCk7CiAgICByZXR1cm4oMCk7Cn0KCQoKc3RhdGljIGludAp4bWxTY2hlbWFBZGRDb21wb25lbnRzKHhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQsCgkJICAgICAgIHhtbFNjaGVtYUJ1Y2tldFB0ciBidWNrZXQpCnsKICAgIHhtbFNjaGVtYUJhc2ljSXRlbVB0ciBpdGVtOwogICAgaW50IGVycjsKICAgIHhtbEhhc2hUYWJsZVB0ciAqdGFibGU7CiAgICBjb25zdCB4bWxDaGFyICpuYW1lOwogICAgaW50IGk7CgojZGVmaW5lIFdYU19HRVRfR0xPQkFMX0hBU0goYywgcywgc2xvdCkgeyBcCiAgICBpZiAoV1hTX0lTX0JVQ0tFVF9JTVBNQUlOKChjKS0+dHlwZSkpIFwKCXRhYmxlID0gJihXWFNfSU1QQlVDS0VUKChjKSktPnNjaGVtYS0+c2xvdCk7IFwKICAgIGVsc2UgXAoJdGFibGUgPSAmKFdYU19JTkNCVUNLRVQoKGMpKS0+b3duZXJJbXBvcnQtPnNjaGVtYS0+c2xvdCk7IH0KCiAgICAvKgogICAgKiBBZGQgZ2xvYmFsIGNvbXBvbmVudHMgdG8gdGhlIHNjaGVtYSdzIGhhc2ggdGFibGVzLgogICAgKiBUaGlzIGlzIHRoZSBwbGFjZSB3aGVyZSBkdXBsaWNhdGUgY29tcG9uZW50cyB3aWxsIGJlCiAgICAqIGRldGVjdGVkLgogICAgKiBUT0RPOiBJIHRoaW5rIG5vcm1hbGx5IHdlIHNob3VsZCBzdXBwb3J0IGltcG9ydHMgb2YgdGhlCiAgICAqICAgc2FtZSBuYW1lc3BhY2UgZnJvbSBtdWx0aXBsZSBsb2NhdGlvbnMuIFdlIGRvbid0IGRvIGN1cnJlbnRseSwKICAgICogICBidXQgaWYgd2UgZG8gdGhlbiBhY2NvcmRpbmcgdG86CiAgICAqICAgaHR0cDovL3d3dy53My5vcmcvQnVncy9QdWJsaWMvc2hvd19idWcuY2dpP2lkPTIyMjQKICAgICogICB3ZSB3b3VsZCBuZWVkLCBpZiBpbXBvcnRlZCBkaXJlY3RseSwgdG8gaW1wb3J0IHJlZGVmaW5lZAogICAgKiAgIGNvbXBvbmVudHMgYXMgd2VsbCB0byBiZSBhYmxlIHRvIGNhdGNoIGNsYXNoaW5nIGNvbXBvbmVudHMuCiAgICAqICAgKEkgaG9wZSBJJ2xsIHN0aWxsIGtub3cgd2hhdCB0aGlzIG1lYW5zIGFmdGVyIHNvbWUgbW9udGhzIDotKCkKICAgICovCiAgICBpZiAoYnVja2V0ID09IE5VTEwpCglyZXR1cm4oLTEpOwogICAgaWYgKGJ1Y2tldC0+ZmxhZ3MgJiBYTUxfU0NIRU1BX0JVQ0tFVF9DT01QU19BRERFRCkKCXJldHVybigwKTsKICAgIGJ1Y2tldC0+ZmxhZ3MgfD0gWE1MX1NDSEVNQV9CVUNLRVRfQ09NUFNfQURERUQ7IAogICAgCiAgICBmb3IgKGkgPSAwOyBpIDwgYnVja2V0LT5nbG9iYWxzLT5uYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBidWNrZXQtPmdsb2JhbHMtPml0ZW1zW2ldOwoJdGFibGUgPSBOVUxMOwoJc3dpdGNoIChpdGVtLT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkJaWYgKFdYU19SRURFRklORURfVFlQRShpdGVtKSkKCQkgICAgY29udGludWU7CgkJbmFtZSA9IChXWFNfVFlQRV9DQVNUIGl0ZW0pLT5uYW1lOwoJCVdYU19HRVRfR0xPQkFMX0hBU0goYnVja2V0LCBzY2hlbWEsIHR5cGVEZWNsKQoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQ6CgkJbmFtZSA9IChXWFNfRUxFTV9DQVNUIGl0ZW0pLT5uYW1lOwoJCVdYU19HRVRfR0xPQkFMX0hBU0goYnVja2V0LCBzY2hlbWEsIGVsZW1EZWNsKQoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURToKCQluYW1lID0gKFdYU19BVFRSX0NBU1QgaXRlbSktPm5hbWU7CgkJV1hTX0dFVF9HTE9CQUxfSEFTSChidWNrZXQsIHNjaGVtYSwgYXR0ckRlY2wpCgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkJaWYgKFdYU19SRURFRklORURfTU9ERUxfR1JPVVBfREVGKGl0ZW0pKQoJCSAgICBjb250aW51ZTsKCQluYW1lID0gKFdYU19NT0RFTF9HUk9VUERFRl9DQVNUIGl0ZW0pLT5uYW1lOwoJCVdYU19HRVRfR0xPQkFMX0hBU0goYnVja2V0LCBzY2hlbWEsIGdyb3VwRGVjbCkKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUDoKCQlpZiAoV1hTX1JFREVGSU5FRF9BVFRSX0dST1VQKGl0ZW0pKQoJCSAgICBjb250aW51ZTsKCQluYW1lID0gKFdYU19BVFRSX0dST1VQX0NBU1QgaXRlbSktPm5hbWU7CgkJV1hTX0dFVF9HTE9CQUxfSEFTSChidWNrZXQsIHNjaGVtYSwgYXR0cmdycERlY2wpCgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWToKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfVU5JUVVFOgoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUY6CgkJbmFtZSA9IChXWFNfSURDX0NBU1QgaXRlbSktPm5hbWU7CgkJV1hTX0dFVF9HTE9CQUxfSEFTSChidWNrZXQsIHNjaGVtYSwgaWRjRGVmKQoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX05PVEFUSU9OOgoJCW5hbWUgPSAoKHhtbFNjaGVtYU5vdGF0aW9uUHRyKSBpdGVtKS0+bmFtZTsKCQlXWFNfR0VUX0dMT0JBTF9IQVNIKGJ1Y2tldCwgc2NoZW1hLCBub3RhRGVjbCkKCQlicmVhazsJICAgIAoJICAgIGRlZmF1bHQ6CgkJUEVSUk9SX0lOVCgieG1sU2NoZW1hQWRkQ29tcG9uZW50cyIsCgkJICAgICJVbmV4cGVjdGVkIGdsb2JhbCBjb21wb25lbnQgdHlwZSIpOwoJCWNvbnRpbnVlOyAgICAJCQoJfQkKCWlmICgqdGFibGUgPT0gTlVMTCkgewoJICAgICp0YWJsZSA9IHhtbEhhc2hDcmVhdGVEaWN0KDEwLCBwY3R4dC0+ZGljdCk7CgkgICAgaWYgKCp0YWJsZSA9PSBOVUxMKSB7CgkJUEVSUk9SX0lOVCgieG1sU2NoZW1hQWRkQ29tcG9uZW50cyIsCgkJICAgICJmYWlsZWQgdG8gY3JlYXRlIGEgY29tcG9uZW50IGhhc2ggdGFibGUiKTsKCQlyZXR1cm4oLTEpOwoJICAgIH0KCX0JCgllcnIgPSB4bWxIYXNoQWRkRW50cnkoKnRhYmxlLCBuYW1lLCBpdGVtKTsKCWlmIChlcnIgIT0gMCkgewkKCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJICAgIAoJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHBjdHh0LAoJCVhNTF9TQ0hFTUFQX1JFREVGSU5FRF9UWVBFLAoJCVdYU19JVEVNX05PREUoaXRlbSksCgkJV1hTX0JBU0lDX0NBU1QgaXRlbSwKCQkiQSBnbG9iYWwgJXMgJyVzJyBkb2VzIGFscmVhZHkgZXhpc3QiLAoJCVdYU19JVEVNX1RZUEVfTkFNRShpdGVtKSwKCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyLCBpdGVtKSk7CgkgICAgRlJFRV9BTkRfTlVMTChzdHIpOwkgCgl9CiAgICB9CiAgICAvKgogICAgKiBQcm9jZXNzIGltcG9ydGVkL2luY2x1ZGVkIHNjaGVtYXMuCiAgICAqLwogICAgaWYgKGJ1Y2tldC0+cmVsYXRpb25zICE9IE5VTEwpIHsKCXhtbFNjaGVtYVNjaGVtYVJlbGF0aW9uUHRyIHJlbCA9IGJ1Y2tldC0+cmVsYXRpb25zOwoJZG8gewoJICAgIGlmICgocmVsLT5idWNrZXQgIT0gTlVMTCkgJiYKCQkoKHJlbC0+YnVja2V0LT5mbGFncyAmIFhNTF9TQ0hFTUFfQlVDS0VUX0NPTVBTX0FEREVEKSA9PSAwKSkgewoJCWlmICh4bWxTY2hlbWFBZGRDb21wb25lbnRzKHBjdHh0LCByZWwtPmJ1Y2tldCkgPT0gLTEpCgkJICAgIHJldHVybigtMSk7CgkgICAgfQoJICAgIHJlbCA9IHJlbC0+bmV4dDsKCX0gd2hpbGUgKHJlbCAhPSBOVUxMKTsKICAgIH0KICAgIHJldHVybigwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFGaXh1cENvbXBvbmVudHMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBwY3R4dCkKewogICAgeG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dFB0ciBjb24gPSBwY3R4dC0+Y29uc3RydWN0b3I7CiAgICB4bWxTY2hlbWFUcmVlSXRlbVB0ciBpdGVtLCAqaXRlbXM7CiAgICBpbnQgbmJJdGVtcywgaTsKCiNkZWZpbmUgRklYSEZBSUxVUkUgaWYgKHBjdHh0LT5lcnIgPT0gWE1MX1NDSEVNQVBfSU5URVJOQUwpIGdvdG8gZXhpdF9mYWlsdXJlOwoKICAgIGlmICgoY29uLT5wZW5kaW5nID09IE5VTEwpIHx8CgkoY29uLT5wZW5kaW5nLT5uYkl0ZW1zID09IDApKQoJcmV0dXJuKDApOyAgICAKCiAgICAvKiBUT0RPOgogICAgKiBTUEVDIChzcmMtcmVkZWZpbmUpOgogICAgKiAoNi4yKSAiSWYgaXQgaGFzIG5vIHN1Y2ggc2VsZi1yZWZlcmVuY2UsIHRoZW4gYWxsIG9mIHRoZQogICAgKiBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlOiIKICAgIAogICAgKiAoNi4yLjIpIFRoZSB7bW9kZWwgZ3JvdXB9IG9mIHRoZSBtb2RlbCBncm91cCBkZWZpbml0aW9uIHdoaWNoCiAgICAqIGNvcnJlc3BvbmRzIHRvIGl0IHBlciBYTUwgUmVwcmVzZW50YXRpb24gb2YgTW9kZWwgR3JvdXAKICAgICogRGVmaW5pdGlvbiBTY2hlbWEgQ29tcG9uZW50cyAopzMuNy4yKSBtdXN0IGJlIGEgt3ZhbGlkCiAgICAqIHJlc3RyaWN0aW9utyBvZiB0aGUge21vZGVsIGdyb3VwfSBvZiB0aGF0IG1vZGVsIGdyb3VwIGRlZmluaXRpb24KICAgICogaW4gSSwgYXMgZGVmaW5lZCBpbiBQYXJ0aWNsZSBWYWxpZCAoUmVzdHJpY3Rpb24pICinMy45LjYpLiIKICAgICovCiAgICB4bWxTY2hlbWFDaGVja1NSQ1JlZGVmaW5lRmlyc3QocGN0eHQpOwoKICAgIC8qCiAgICAqIEFkZCBnbG9iYWwgY29tcG9uZW50cyB0byB0aGUgc2NoZW1hdGEncyBoYXNoIHRhYmxlcy4KICAgICovCiAgICB4bWxTY2hlbWFBZGRDb21wb25lbnRzKHBjdHh0LCBXWFNfQ09OU1RSVUNUT1IocGN0eHQpLT5tYWluQnVja2V0KTsKCiAgICBwY3R4dC0+Y3R4dFR5cGUgPSBOVUxMOwogICAgaXRlbXMgPSAoeG1sU2NoZW1hVHJlZUl0ZW1QdHIgKikgY29uLT5wZW5kaW5nLT5pdGVtczsKICAgIG5iSXRlbXMgPSBjb24tPnBlbmRpbmctPm5iSXRlbXM7CiAgICAvKgogICAgKiBOb3cgdGhhdCB3ZSBoYXZlIHBhcnNlZCAqYWxsKiB0aGUgc2NoZW1hIGRvY3VtZW50KHMpIGFuZCBjb252ZXJ0ZWQKICAgICogdGhlbSB0byBzY2hlbWEgY29tcG9uZW50cywgd2UgY2FuIHJlc29sdmUgcmVmZXJlbmNlcywgYXBwbHkgY29tcG9uZW50CiAgICAqIGNvbnN0cmFpbnRzLCBjcmVhdGUgdGhlIEZTQSBmcm9tIHRoZSBjb250ZW50IG1vZGVsLCBldGMuCiAgICAqLyAgICAKICAgIC8qCiAgICAqIFJlc29sdmUgcmVmZXJlbmNlcyBvZi4uCiAgICAqCiAgICAqIDEuIGVsZW1lbnQgZGVjbGFyYXRpb25zOgogICAgKiAgIC0gdGhlIHR5cGUgZGVmaW5pdGlvbgogICAgKiAgIC0gdGhlIHN1YnN0aXR1dGlvbiBncm91cCBhZmZpbGlhdGlvbgogICAgKiAyLiBzaW1wbGUvY29tcGxleCB0eXBlczoKICAgICogICAtIHRoZSBiYXNlIHR5cGUgZGVmaW5pdGlvbgogICAgKiAgIC0gdGhlIG1lbWJlclR5cGVzIG9mIHVuaW9uIHR5cGVzCiAgICAqICAgLSB0aGUgaXRlbVR5cGUgb2YgbGlzdCB0eXBlcwogICAgKiAzLiBhdHRyaWJ1dGVzIGRlY2xhcmF0aW9ucyBhbmQgYXR0cmlidXRlIHVzZXM6CiAgICAqICAgLSB0aGUgdHlwZSBkZWZpbml0aW9uCiAgICAqICAgLSBpZiBhbiBhdHRyaWJ1dGUgdXNlLCB0aGVuIHRoZSBhdHRyaWJ1dGUgZGVjbGFyYXRpb24KICAgICogNC4gYXR0cmlidXRlIGdyb3VwIHJlZmVyZW5jZXM6CiAgICAqICAgLSB0aGUgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb24KICAgICogNS4gcGFydGljbGVzOgogICAgKiAgIC0gdGhlIHRlcm0gb2YgdGhlIHBhcnRpY2xlIChlLmcuIGEgbW9kZWwgZ3JvdXApCiAgICAqIDYuIElEQyBrZXktcmVmZXJlbmNlczoKICAgICogICAtIHRoZSByZWZlcmVuY2VkIElEQyAna2V5JyBvciAndW5pcXVlJyBkZWZpbml0aW9uCiAgICAqIDcuIEF0dHJpYnV0ZSBwcm9oaWJpdGlvbnMgd2hpY2ggaGFkIGEgInJlZiIgYXR0cmlidXRlLgogICAgKi8gICAgICAgIAogICAgZm9yIChpID0gMDsgaSA8IG5iSXRlbXM7IGkrKykgewoJaXRlbSA9IGl0ZW1zW2ldOwoJc3dpdGNoIChpdGVtLT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfRUxFTUVOVDoKCQl4bWxTY2hlbWFSZXNvbHZlRWxlbWVudFJlZmVyZW5jZXMoCgkJICAgICh4bWxTY2hlbWFFbGVtZW50UHRyKSBpdGVtLCBwY3R4dCk7CgkJRklYSEZBSUxVUkU7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkJeG1sU2NoZW1hUmVzb2x2ZVR5cGVSZWZlcmVuY2VzKAoJCSAgICAoeG1sU2NoZW1hVHlwZVB0cikgaXRlbSwgcGN0eHQpOwoJCUZJWEhGQUlMVVJFOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURToKCQl4bWxTY2hlbWFSZXNvbHZlQXR0clR5cGVSZWZlcmVuY2VzKAoJCSAgICAoeG1sU2NoZW1hQXR0cmlidXRlUHRyKSBpdGVtLCBwY3R4dCk7CgkJRklYSEZBSUxVUkU7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFX1VTRToKCQl4bWxTY2hlbWFSZXNvbHZlQXR0clVzZVJlZmVyZW5jZXMoCgkJICAgICh4bWxTY2hlbWFBdHRyaWJ1dGVVc2VQdHIpIGl0ZW0sIHBjdHh0KTsKCQlGSVhIRkFJTFVSRTsKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRVhUUkFfUU5BTUVSRUY6CgkJaWYgKChXWFNfUU5BTUVfQ0FTVCBpdGVtKS0+aXRlbVR5cGUgPT0gCgkJICAgIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUCkKCQl7CgkJICAgIHhtbFNjaGVtYVJlc29sdmVBdHRyR3JvdXBSZWZlcmVuY2VzKAoJCQlXWFNfUU5BTUVfQ0FTVCBpdGVtLCBwY3R4dCk7CgkJfQoJCUZJWEhGQUlMVVJFOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX1NFUVVFTkNFOgoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0NIT0lDRToKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9BTEw6CgkJeG1sU2NoZW1hUmVzb2x2ZU1vZGVsR3JvdXBQYXJ0aWNsZVJlZmVyZW5jZXMocGN0eHQsCgkJICAgIFdYU19NT0RFTF9HUk9VUF9DQVNUIGl0ZW0pOwoJCUZJWEhGQUlMVVJFOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVk6CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfSURDX1VOSVFVRToKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGOgoJCXhtbFNjaGVtYVJlc29sdmVJRENLZXlSZWZlcmVuY2VzKAoJCSAgICAoeG1sU2NoZW1hSURDUHRyKSBpdGVtLCBwY3R4dCk7CgkJRklYSEZBSUxVUkU7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0VYVFJBX0FUVFJfVVNFX1BST0hJQjoKCQkvKgoJCSogSGFuZGxlIGF0dHJpYnVlIHByb2hpYml0aW9uIHdoaWNoIGhhZCBhCgkJKiAicmVmIiBhdHRyaWJ1dGUuCgkJKi8KCQl4bWxTY2hlbWFSZXNvbHZlQXR0clVzZVByb2hpYlJlZmVyZW5jZXMoCgkJICAgIFdYU19BVFRSX1BST0hJQl9DQVNUIGl0ZW0sIHBjdHh0KTsKCQlGSVhIRkFJTFVSRTsKCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCWJyZWFrOwoJfQogICAgfQogICAgaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJZ290byBleGl0X2Vycm9yOwogICAgCiAgICAvKgogICAgKiBOb3cgdGhhdCBhbGwgcmVmZXJlbmNlcyBhcmUgcmVzb2x2ZWQgd2UKICAgICogY2FuIGNoZWNrIGZvciBjaXJjdWxhcml0eSBvZi4uLgogICAgKiAxLiB0aGUgYmFzZSBheGlzIG9mIHR5cGUgZGVmaW5pdGlvbnMgCiAgICAqIDIuIG5lc3RlZCBtb2RlbCBncm91cCBkZWZpbml0aW9ucwogICAgKiAzLiBuZXN0ZWQgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb25zCiAgICAqIFRPRE86IGNoZWNrIGZvciBjaXJjdWFsIHN1YnN0aXR1dGlvbiBncm91cHMuCiAgICAqLwogICAgZm9yIChpID0gMDsgaSA8IG5iSXRlbXM7IGkrKykgewoJaXRlbSA9IGl0ZW1zW2ldOwoJLyoKCSogTGV0J3MgYmV0dGVyIHN0b3Agb24gdGhlIGZpcnN0IGVycm9yIGhlcmUuCgkqLwoJc3dpdGNoIChpdGVtLT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkJeG1sU2NoZW1hQ2hlY2tUeXBlRGVmQ2lyY3VsYXIoCgkJICAgICh4bWxTY2hlbWFUeXBlUHRyKSBpdGVtLCBwY3R4dCk7CgkJRklYSEZBSUxVUkU7CgkJaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJCSAgICBnb3RvIGV4aXRfZXJyb3I7CgkJYnJlYWs7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfR1JPVVA6CgkJeG1sU2NoZW1hQ2hlY2tHcm91cERlZkNpcmN1bGFyKAoJCSAgICAoeG1sU2NoZW1hTW9kZWxHcm91cERlZlB0cikgaXRlbSwgcGN0eHQpOwoJCUZJWEhGQUlMVVJFOwoJCWlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCQkgICAgZ290byBleGl0X2Vycm9yOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0FUVFJJQlVURUdST1VQOgoJCXhtbFNjaGVtYUNoZWNrQXR0ckdyb3VwQ2lyY3VsYXIoCgkJICAgICh4bWxTY2hlbWFBdHRyaWJ1dGVHcm91cFB0cikgaXRlbSwgcGN0eHQpOwoJCUZJWEhGQUlMVVJFOwoJCWlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCQkgICAgZ290byBleGl0X2Vycm9yOwoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CQogICAgfQogICAgaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJZ290byBleGl0X2Vycm9yOwogICAgLyoKICAgICogTW9kZWwgZ3JvdXAgZGVmaW5pdGlvbiByZWZlcmVuY2VzOgogICAgKiBTdWNoIGEgcmVmZXJlbmNlIGlzIHJlZmxlY3RlZCBieSBhIHBhcnRpY2xlIGF0IHRoZSBjb21wb25lbnQKICAgICogbGV2ZWwuIFVudGlsIG5vdyB0aGUgJ3Rlcm0nIG9mIHN1Y2ggcGFydGljbGVzIHBvaW50ZWQKICAgICogdG8gdGhlIG1vZGVsIGdyb3VwIGRlZmluaXRpb247IHRoaXMgd2FzIGRvbmUsIGluIG9yZGVyIHRvCiAgICAqIGVhc2UgY2lyY3VsYXJpdHkgY2hlY2tzLiBOb3cgd2UgbmVlZCB0byBzZXQgdGhlICd0ZXJtJyBvZgogICAgKiBzdWNoIHBhcnRpY2xlcyB0byB0aGUgbW9kZWwgZ3JvdXAgb2YgdGhlIG1vZGVsIGdyb3VwIGRlZmluaXRpb24uCiAgICAqLwogICAgZm9yIChpID0gMDsgaSA8IG5iSXRlbXM7IGkrKykgewoJaXRlbSA9IGl0ZW1zW2ldOwoJc3dpdGNoIChpdGVtLT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0VRVUVOQ0U6CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ0hPSUNFOgkKCQl4bWxTY2hlbWFNb2RlbEdyb3VwVG9Nb2RlbEdyb3VwRGVmRml4dXAocGN0eHQsCgkJICAgIFdYU19NT0RFTF9HUk9VUF9DQVNUIGl0ZW0pOwoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CiAgICB9CiAgICBpZiAocGN0eHQtPm5iZXJyb3JzICE9IDApCglnb3RvIGV4aXRfZXJyb3I7CiAgICAvKgogICAgKiBFeHBhbmQgYXR0cmlidXRlIGdyb3VwIHJlZmVyZW5jZXMgb2YgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb25zLgogICAgKi8KICAgIGZvciAoaSA9IDA7IGkgPCBuYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBpdGVtc1tpXTsKCXN3aXRjaCAoaXRlbS0+dHlwZSkgewogICAgICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVHUk9VUDoKCQlpZiAoKCEgV1hTX0FUVFJfR1JPVVBfRVhQQU5ERUQoaXRlbSkpICYmCgkJICAgIFdYU19BVFRSX0dST1VQX0hBU19SRUZTKGl0ZW0pKQoJCXsKCQkgICAgeG1sU2NoZW1hQXR0cmlidXRlR3JvdXBFeHBhbmRSZWZzKHBjdHh0LAoJCQlXWFNfQVRUUl9HUk9VUF9DQVNUIGl0ZW0pOwoJCSAgICBGSVhIRkFJTFVSRTsKCQl9CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlicmVhazsKCX0KICAgIH0KICAgIGlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdF9lcnJvcjsKICAgIC8qIAogICAgKiBGaXJzdCBjb21wdXRlIHRoZSB2YXJpZXR5IG9mIHNpbXBsZSB0eXBlcy4gVGhpcyBpcyBuZWVkZWQgYXMKICAgICogYSBzZXBlcmF0ZSBzdGVwLCBzaW5jZSBvdGhlcndpc2Ugd2Ugd29uJ3QgYmUgYWJsZSB0byBkZXRlY3QKICAgICogY2lyY3VsYXIgdW5pb24gdHlwZXMgaW4gYWxsIGNhc2VzLgogICAgKi8KICAgIGZvciAoaSA9IDA7IGkgPCBuYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBpdGVtc1tpXTsKCXN3aXRjaCAoaXRlbS0+dHlwZSkgewogICAgICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkJaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRF8xKCh4bWxTY2hlbWFUeXBlUHRyKSBpdGVtKSkgewoJCSAgICB4bWxTY2hlbWFGaXh1cFNpbXBsZVR5cGVTdGFnZU9uZShwY3R4dCwKCQkJKHhtbFNjaGVtYVR5cGVQdHIpIGl0ZW0pOwoJCSAgICBGSVhIRkFJTFVSRTsKCQl9CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlicmVhazsKCX0KICAgIH0KICAgIGlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdF9lcnJvcjsKICAgIC8qCiAgICAqIERldGVjdCBjaXJjdWxhciB1bmlvbiB0eXBlcy4gTm90ZSB0aGF0IHRoaXMgbmVlZHMgdGhlIHZhcmlldHkgdG8KICAgICogYmUgYWxyZWFkeSBjb21wdXRlZC4KICAgICovCiAgICBmb3IgKGkgPSAwOyBpIDwgbmJJdGVtczsgaSsrKSB7CglpdGVtID0gaXRlbXNbaV07Cglzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKICAgICAgICAgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfU0lNUExFOgoJCWlmICgoKHhtbFNjaGVtYVR5cGVQdHIpIGl0ZW0pLT5tZW1iZXJUeXBlcyAhPSBOVUxMKSB7CgkJICAgIHhtbFNjaGVtYUNoZWNrVW5pb25UeXBlRGVmQ2lyY3VsYXIocGN0eHQsCQoJCQkoeG1sU2NoZW1hVHlwZVB0cikgaXRlbSk7CgkJICAgIEZJWEhGQUlMVVJFOwoJCX0KCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCWJyZWFrOwoJfQogICAgfQogICAgaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJZ290byBleGl0X2Vycm9yOwogICAgCiAgICAvKgogICAgKiBEbyB0aGUgY29tcGxldGUgdHlwZSBmaXh1cCBmb3Igc2ltcGxlIHR5cGVzLgogICAgKi8KICAgIGZvciAoaSA9IDA7IGkgPCBuYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBpdGVtc1tpXTsKCXN3aXRjaCAoaXRlbS0+dHlwZSkgewogICAgICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9TSU1QTEU6CgkJaWYgKFdYU19JU19UWVBFX05PVF9GSVhFRChXWFNfVFlQRV9DQVNUIGl0ZW0pKSB7CgkJICAgIHhtbFNjaGVtYUZpeHVwU2ltcGxlVHlwZVN0YWdlVHdvKHBjdHh0LCBXWFNfVFlQRV9DQVNUIGl0ZW0pOwoJCSAgICBGSVhIRkFJTFVSRTsKCQl9CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlicmVhazsKCX0KICAgIH0KICAgIGlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdF9lcnJvcjsKICAgIC8qCiAgICAqIEF0IHRoaXMgcG9pbnQgd2UgbmVlZCBhbGwgc2ltcGxlIHR5cGVzIHRvIGJlIGJ1aWxkZWQgYW5kIGNoZWNrZWQuCiAgICAqLwogICAgLyoKICAgICogQXBwbHkgY29udHJhaW50cyBmb3IgYXR0cmlidXRlIGRlY2xhcmF0aW9ucy4KICAgICovCiAgICBmb3IgKGkgPSAwOyBpIDwgbmJJdGVtczsgaSsrKSB7CglpdGVtID0gaXRlbXNbaV07Cglzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEU6CQkKCQl4bWxTY2hlbWFDaGVja0F0dHJQcm9wc0NvcnJlY3QocGN0eHQsIFdYU19BVFRSX0NBU1QgaXRlbSk7CgkJRklYSEZBSUxVUkU7CgkJYnJlYWs7CSAgICAKCSAgICBkZWZhdWx0OgoJCWJyZWFrOwoJfQogICAgfQogICAgaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJZ290byBleGl0X2Vycm9yOwogICAgLyoKICAgICogQXBwbHkgY29uc3RyYWludHMgZm9yIGF0dHJpYnV0ZSB1c2VzLgogICAgKi8gICAgCiAgICBmb3IgKGkgPSAwOyBpIDwgbmJJdGVtczsgaSsrKSB7CglpdGVtID0gaXRlbXNbaV07Cglzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9BVFRSSUJVVEVfVVNFOgoJCWlmICgoKHhtbFNjaGVtYUF0dHJpYnV0ZVVzZVB0cilpdGVtKS0+ZGVmVmFsdWUgIT0gTlVMTCkgewoJCSAgICB4bWxTY2hlbWFDaGVja0F0dHJVc2VQcm9wc0NvcnJlY3QocGN0eHQsCgkJCVdYU19BVFRSX1VTRV9DQVNUIGl0ZW0pOwoJCSAgICBGSVhIRkFJTFVSRTsKCQl9CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlicmVhazsKCX0KICAgIH0KICAgIGlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdF9lcnJvcjsKCiAgICAvKgogICAgKiBBcHBseSBjb25zdHJhaW50cyBmb3IgYXR0cmlidXRlIGdyb3VwIGRlZmluaXRpb25zLgogICAgKi8KICAgIGZvciAoaSA9IDA7IGkgPCBuYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBpdGVtc1tpXTsKCXN3aXRjaCAoaXRlbS0+dHlwZSkgewoJY2FzZSBYTUxfU0NIRU1BX1RZUEVfQVRUUklCVVRFR1JPVVA6CgkgICAgaWYgKCggKFdYU19BVFRSX0dST1VQX0NBU1QgaXRlbSktPmF0dHJVc2VzICE9IE5VTEwpICYmCgkJKCAoV1hTX0xJU1RfQ0FTVCAoV1hTX0FUVFJfR1JPVVBfQ0FTVCBpdGVtKS0+YXR0clVzZXMpLT5uYkl0ZW1zID4gMSkpCgkgICAgewoJCXhtbFNjaGVtYUNoZWNrQUdQcm9wc0NvcnJlY3QocGN0eHQsIFdYU19BVFRSX0dST1VQX0NBU1QgaXRlbSk7CgkJRklYSEZBSUxVUkU7CgkgICAgfQoJICAgIGJyZWFrOwoJZGVmYXVsdDoKCSAgICBicmVhazsKCX0KICAgIH0KICAgIGlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdF9lcnJvcjsKCiAgICAvKgogICAgKiBBcHBseSBjb25zdHJhaW50cyBmb3IgcmVkZWZpbml0aW9ucy4KICAgICovCiAgICBpZiAoV1hTX0NPTlNUUlVDVE9SKHBjdHh0KS0+cmVkZWZzICE9IE5VTEwpCgl4bWxTY2hlbWFDaGVja1NSQ1JlZGVmaW5lU2Vjb25kKHBjdHh0KTsKICAgIGlmIChwY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdF9lcnJvcjsKCiAgICAvKgogICAgKiBGaXh1cCBjb21wbGV4IHR5cGVzLgogICAgKi8KICAgIGZvciAoaSA9IDA7IGkgPCBuYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBjb24tPnBlbmRpbmctPml0ZW1zW2ldOwoJc3dpdGNoIChpdGVtLT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1RZUEVfQ09NUExFWDoKCQlpZiAoV1hTX0lTX1RZUEVfTk9UX0ZJWEVEKFdYU19UWVBFX0NBU1QgaXRlbSkpIHsKCQkgICAgeG1sU2NoZW1hRml4dXBDb21wbGV4VHlwZShwY3R4dCwgV1hTX1RZUEVfQ0FTVCBpdGVtKTsKCQkgICAgRklYSEZBSUxVUkU7CgkJfQoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CiAgICB9CiAgICBpZiAocGN0eHQtPm5iZXJyb3JzICE9IDApCglnb3RvIGV4aXRfZXJyb3I7CgogICAgLyoKICAgICogVGhlIGxpc3QgY291bGQgaGF2ZSBjaGFuZ2VkLCBzaW5jZSB4bWxTY2hlbWFGaXh1cENvbXBsZXhUeXBlKCkKICAgICogd2lsbCBjcmVhdGUgcGFydGljbGVzIGFuZCBtb2RlbCBncm91cHMgaW4gc29tZSBjYXNlcy4KICAgICovCiAgICBpdGVtcyA9ICh4bWxTY2hlbWFUcmVlSXRlbVB0ciAqKSBjb24tPnBlbmRpbmctPml0ZW1zOwogICAgbmJJdGVtcyA9IGNvbi0+cGVuZGluZy0+bmJJdGVtczsKCiAgICAvKgogICAgKiBBdCB0aGlzIHBvaW50IGFsbCBjb21wbGV4IHR5cGVzIG5lZWQgdG8gYmUgYnVpbGRlZCBhbmQgY2hlY2tlZC4KICAgICovCiAgICAvKgogICAgKiBBcHBseSBzb21lIGNvbnN0cmFpbnRzIGZvciBlbGVtZW50IGRlY2xhcmF0aW9ucy4KICAgICovCiAgICBmb3IgKGkgPSAwOyBpIDwgbmJJdGVtczsgaSsrKSB7CglpdGVtID0gaXRlbXNbaV07Cglzd2l0Y2ggKGl0ZW0tPnR5cGUpIHsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfVFlQRV9FTEVNRU5UOgoJCQoJCWlmICgoKCh4bWxTY2hlbWFFbGVtZW50UHRyKSBpdGVtKS0+ZmxhZ3MgJiAKCQkgICAgWE1MX1NDSEVNQVNfRUxFTV9JTlRFUk5BTF9DSEVDS0VEKSA9PSAwKSB7CgkJICAgIHhtbFNjaGVtYUNoZWNrRWxlbWVudERlY2xDb21wb25lbnQoCgkJCSh4bWxTY2hlbWFFbGVtZW50UHRyKSBpdGVtLCBwY3R4dCk7CgkJICAgIEZJWEhGQUlMVVJFOwoJCX0KCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCWJyZWFrOwoJfQogICAgfQogICAgaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJZ290byBleGl0X2Vycm9yOwogICAgLyoKICAgICogRmluYWxseSB3ZSBjYW4gYnVpbGQgdGhlIGF1dG9tYXRvbiBmcm9tIHRoZSBjb250ZW50IG1vZGVsIG9mCiAgICAqIGNvbXBsZXggdHlwZXMuCiAgICAqLwoKICAgIGZvciAoaSA9IDA7IGkgPCBuYkl0ZW1zOyBpKyspIHsKCWl0ZW0gPSBpdGVtc1tpXTsKCXN3aXRjaCAoaXRlbS0+dHlwZSkgewoJICAgIGNhc2UgWE1MX1NDSEVNQV9UWVBFX0NPTVBMRVg6CgkJeG1sU2NoZW1hQnVpbGRDb250ZW50TW9kZWwoKHhtbFNjaGVtYVR5cGVQdHIpIGl0ZW0sIHBjdHh0KTsKCQkvKiBGSVhIRkFJTFVSRTsgKi8KCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCWJyZWFrOwoJfQogICAgfQogICAgaWYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKQoJZ290byBleGl0X2Vycm9yOwogICAgLyoKICAgICogVVJHRU5UIFRPRE86IGNvcy1lbGVtZW50LWNvbnNpc3RlbnQKICAgICovICAgIAogICAgY29uLT5wZW5kaW5nLT5uYkl0ZW1zID0gMDsKICAgIHJldHVybigwKTsKZXhpdF9lcnJvcjoKICAgIGNvbi0+cGVuZGluZy0+bmJJdGVtcyA9IDA7CiAgICByZXR1cm4ocGN0eHQtPmVycik7CmV4aXRfZmFpbHVyZToKICAgIGNvbi0+cGVuZGluZy0+bmJJdGVtcyA9IDA7CiAgICByZXR1cm4oLTEpOwp9Ci8qKgogKiB4bWxTY2hlbWFQYXJzZToKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICoKICogcGFyc2UgYSBzY2hlbWEgZGVmaW5pdGlvbiByZXNvdXJjZSBhbmQgYnVpbGQgYW4gaW50ZXJuYWwKICogWE1MIFNoZW1hIHN0cnV0dXJlIHdoaWNoIGNhbiBiZSB1c2VkIHRvIHZhbGlkYXRlIGluc3RhbmNlcy4KICoKICogUmV0dXJucyB0aGUgaW50ZXJuYWwgWE1MIFNjaGVtYSBzdHJ1Y3R1cmUgYnVpbHQgZnJvbSB0aGUgcmVzb3VyY2Ugb3IKICogICAgICAgICBOVUxMIGluIGNhc2Ugb2YgZXJyb3IKICovCnhtbFNjaGVtYVB0cgp4bWxTY2hlbWFQYXJzZSh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQpCnsKICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEgPSBOVUxMOwogICAgeG1sU2NoZW1hQnVja2V0UHRyIGJ1Y2tldCA9IE5VTEw7CiAgICBpbnQgcmVzOwoKICAgIC8qCiAgICAqIFRoaXMgb25lIGlzIHVzZWQgaWYgdGhlIHNjaGVtYSB0byBiZSBwYXJzZWQgd2FzIHNwZWNpZmllZCB2aWEKICAgICogdGhlIEFQSTsgaS5lLiBub3QgYXV0b21hdGljYWxseSBieSB0aGUgdmFsaWRhdGVkIGluc3RhbmNlIGRvY3VtZW50LgogICAgKi8KCiAgICB4bWxTY2hlbWFJbml0VHlwZXMoKTsKCiAgICBpZiAoY3R4dCA9PSBOVUxMKQogICAgICAgIHJldHVybiAoTlVMTCk7CgogICAgLyogVE9ETzogSW5pdCB0aGUgY29udGV4dC4gSXMgdGhpcyBhbGwgd2UgbmVlZD8qLwogICAgY3R4dC0+bmJlcnJvcnMgPSAwOwogICAgY3R4dC0+ZXJyID0gMDsKICAgIGN0eHQtPmNvdW50ZXIgPSAwOwoKICAgIC8qIENyZWF0ZSB0aGUgKm1haW4qIHNjaGVtYS4gKi8KICAgIHNjaGVtYSA9IHhtbFNjaGVtYU5ld1NjaGVtYShjdHh0KTsKICAgIGlmIChzY2hlbWEgPT0gTlVMTCkKCWdvdG8gZXhpdF9mYWlsdXJlOwogICAgLyoKICAgICogQ3JlYXRlIHRoZSBzY2hlbWEgY29uc3RydWN0b3IuCiAgICAqLwogICAgaWYgKGN0eHQtPmNvbnN0cnVjdG9yID09IE5VTEwpIHsKCWN0eHQtPmNvbnN0cnVjdG9yID0geG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dENyZWF0ZShjdHh0LT5kaWN0KTsKCWlmIChjdHh0LT5jb25zdHJ1Y3RvciA9PSBOVUxMKQoJICAgIHJldHVybihOVUxMKTsKCS8qIFRha2Ugb3duZXJzaGlwIG9mIHRoZSBjb25zdHJ1Y3RvciB0byBiZSBhYmxlIHRvIGZyZWUgaXQuICovCgljdHh0LT5vd25zQ29uc3RydWN0b3IgPSAxOwogICAgfQogICAgY3R4dC0+Y29uc3RydWN0b3ItPm1haW5TY2hlbWEgPSBzY2hlbWE7CiAgICAvKgogICAgKiBMb2NhdGUgYW5kIGFkZCB0aGUgc2NoZW1hIGRvY3VtZW50LgogICAgKi8KICAgIHJlcyA9IHhtbFNjaGVtYUFkZFNjaGVtYURvYyhjdHh0LCBYTUxfU0NIRU1BX1NDSEVNQV9NQUlOLAoJY3R4dC0+VVJMLCBjdHh0LT5kb2MsIGN0eHQtPmJ1ZmZlciwgY3R4dC0+c2l6ZSwgTlVMTCwKCU5VTEwsIE5VTEwsICZidWNrZXQpOwogICAgaWYgKHJlcyA9PSAtMSkKCWdvdG8gZXhpdF9mYWlsdXJlOwogICAgaWYgKHJlcyAhPSAwKQoJZ290byBleGl0OyAgIAoKICAgIGlmIChidWNrZXQgPT0gTlVMTCkgewoJLyogVE9ETzogRXJyb3IgY29kZSwgYWN0dWFsbHkgd2UgZmFpbGVkIHRvICpsb2NhdGUqIHRoZSBzY2hlbWEuICovCglpZiAoY3R4dC0+VVJMKSAKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCBjdHh0LCBYTUxfU0NIRU1BUF9GQUlMRURfTE9BRCwKCQlOVUxMLCBOVUxMLAoJCSJGYWlsZWQgdG8gbG9jYXRlIHRoZSBtYWluIHNjaGVtYSByZXNvdXJjZSBhdCAnJXMnIiwKCQljdHh0LT5VUkwsIE5VTEwpOwoJZWxzZQoJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIGN0eHQsIFhNTF9TQ0hFTUFQX0ZBSUxFRF9MT0FELAoJCU5VTEwsIE5VTEwsCgkJIkZhaWxlZCB0byBsb2NhdGUgdGhlIG1haW4gc2NoZW1hIHJlc291cmNlIiwKCQkgICAgTlVMTCwgTlVMTCk7Cglnb3RvIGV4aXQ7CiAgICB9CiAgICAvKiBTZXQgdGhlIG1haW4gc2NoZW1hIGJ1Y2tldC4gKi8KICAgIGN0eHQtPmNvbnN0cnVjdG9yLT5idWNrZXQgPSBidWNrZXQ7CiAgICBjdHh0LT50YXJnZXROYW1lc3BhY2UgPSBidWNrZXQtPnRhcmdldE5hbWVzcGFjZTsgICAgCiAgICBzY2hlbWEtPnRhcmdldE5hbWVzcGFjZSA9IGJ1Y2tldC0+dGFyZ2V0TmFtZXNwYWNlOwogICAgCiAgICAvKiBUaGVuIGRvIHRoZSBwYXJzaW5nIGZvciBnb29kLiAqLwogICAgaWYgKHhtbFNjaGVtYVBhcnNlTmV3RG9jV2l0aENvbnRleHQoY3R4dCwgc2NoZW1hLCBidWNrZXQpID09IC0xKQoJZ290byBleGl0X2ZhaWx1cmU7CiAgICBpZiAoY3R4dC0+bmJlcnJvcnMgIT0gMCkKCWdvdG8gZXhpdDsKCiAgICBzY2hlbWEtPmRvYyA9IGJ1Y2tldC0+ZG9jOwogICAgc2NoZW1hLT5wcmVzZXJ2ZSA9IGN0eHQtPnByZXNlcnZlOwoKICAgIGN0eHQtPnNjaGVtYSA9IHNjaGVtYTsKCiAgICBpZiAoeG1sU2NoZW1hRml4dXBDb21wb25lbnRzKGN0eHQpID09IC0xKQoJZ290byBleGl0X2ZhaWx1cmU7CgogICAgLyoKICAgICogVE9ETzogVGhpcyBpcyBub3QgbmljZSwgc2luY2Ugd2UgY2Fubm90IGRpc3Rpbmd1aXNoIGZyb20gdGhlCiAgICAqIHJlc3VsdCBpZiB0aGVyZSB3YXMgYW4gaW50ZXJuYWwgZXJyb3Igb3Igbm90LgogICAgKi8KZXhpdDogICAgICAgCiAgICBpZiAoY3R4dC0+bmJlcnJvcnMgIT0gMCkgewkKCWlmIChzY2hlbWEpIHsKCSAgICB4bWxTY2hlbWFGcmVlKHNjaGVtYSk7CgkgICAgc2NoZW1hID0gTlVMTDsKCX0KCWlmIChjdHh0LT5jb25zdHJ1Y3RvcikgewoJICAgIHhtbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHRGcmVlKGN0eHQtPmNvbnN0cnVjdG9yKTsKCSAgICBjdHh0LT5jb25zdHJ1Y3RvciA9IE5VTEw7CgkgICAgY3R4dC0+b3duc0NvbnN0cnVjdG9yID0gMDsKCX0KICAgIH0KICAgIGN0eHQtPnNjaGVtYSA9IE5VTEw7CiAgICByZXR1cm4oc2NoZW1hKTsKZXhpdF9mYWlsdXJlOgogICAgLyogCiAgICAqIFF1aXRlIHZlcmJvc2UsIGJ1dCBzaG91bGQgY2F0Y2ggaW50ZXJuYWwgZXJyb3JzLCB3aGljaCB3ZXJlCiAgICAqIG5vdCBjb21tdW5pdGF0ZWQuCiAgICAqLwogICAgaWYgKHNjaGVtYSkgewogICAgICAgIHhtbFNjaGVtYUZyZWUoc2NoZW1hKTsKCXNjaGVtYSA9IE5VTEw7CiAgICB9CiAgICBpZiAoY3R4dC0+Y29uc3RydWN0b3IpIHsKCXhtbFNjaGVtYUNvbnN0cnVjdGlvbkN0eHRGcmVlKGN0eHQtPmNvbnN0cnVjdG9yKTsKCWN0eHQtPmNvbnN0cnVjdG9yID0gTlVMTDsKCWN0eHQtPm93bnNDb25zdHJ1Y3RvciA9IDA7CiAgICB9CiAgICBQRVJST1JfSU5UMigieG1sU2NoZW1hUGFyc2UiLAoJIkFuIGludGVybmFsIGVycm9yIG9jY3VyZWQiKTsgICAgCiAgICBjdHh0LT5zY2hlbWEgPSBOVUxMOwogICAgcmV0dXJuKE5VTEwpOwp9CgovKioKICogeG1sU2NoZW1hU2V0UGFyc2VyRXJyb3JzOgogKiBAY3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAZXJyOiAgdGhlIGVycm9yIGNhbGxiYWNrCiAqIEB3YXJuOiAgdGhlIHdhcm5pbmcgY2FsbGJhY2sKICogQGN0eDogIGNvbnRleHR1YWwgZGF0YSBmb3IgdGhlIGNhbGxiYWNrcwogKgogKiBTZXQgdGhlIGNhbGxiYWNrIGZ1bmN0aW9ucyB1c2VkIHRvIGhhbmRsZSBlcnJvcnMgZm9yIGEgdmFsaWRhdGlvbiBjb250ZXh0CiAqLwp2b2lkCnhtbFNjaGVtYVNldFBhcnNlckVycm9ycyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCiAgICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFWYWxpZGl0eUVycm9yRnVuYyBlcnIsCiAgICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFWYWxpZGl0eVdhcm5pbmdGdW5jIHdhcm4sIHZvaWQgKmN0eCkKewogICAgaWYgKGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBjdHh0LT5lcnJvciA9IGVycjsKICAgIGN0eHQtPndhcm5pbmcgPSB3YXJuOwogICAgY3R4dC0+ZXJyQ3R4dCA9IGN0eDsKICAgIGlmIChjdHh0LT52Y3R4dCAhPSBOVUxMKQoJeG1sU2NoZW1hU2V0VmFsaWRFcnJvcnMoY3R4dC0+dmN0eHQsIGVyciwgd2FybiwgY3R4KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVNldFBhcnNlclN0cnVjdHVyZWRFcnJvcnM6CiAqIEBjdHh0OiAgYSBzY2hlbWEgcGFyc2VyIGNvbnRleHQKICogQHNlcnJvcjogIHRoZSBzdHJ1Y3R1cmVkIGVycm9yIGZ1bmN0aW9uCiAqIEBjdHg6IHRoZSBmdW5jdGlvbnMgY29udGV4dAogKgogKiBTZXQgdGhlIHN0cnVjdHVyZWQgZXJyb3IgY2FsbGJhY2sKICovCnZvaWQKeG1sU2NoZW1hU2V0UGFyc2VyU3RydWN0dXJlZEVycm9ycyh4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIGN0eHQsCgkJCQkgICB4bWxTdHJ1Y3R1cmVkRXJyb3JGdW5jIHNlcnJvciwKCQkJCSAgIHZvaWQgKmN0eCkKewogICAgaWYgKGN0eHQgPT0gTlVMTCkKCXJldHVybjsKICAgIGN0eHQtPnNlcnJvciA9IHNlcnJvcjsKICAgIGN0eHQtPmVyckN0eHQgPSBjdHg7CiAgICBpZiAoY3R4dC0+dmN0eHQgIT0gTlVMTCkKCXhtbFNjaGVtYVNldFZhbGlkU3RydWN0dXJlZEVycm9ycyhjdHh0LT52Y3R4dCwgc2Vycm9yLCBjdHgpOwp9CgovKioKICogeG1sU2NoZW1hR2V0UGFyc2VyRXJyb3JzOgogKiBAY3R4dDogIGEgWE1sLVNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAZXJyOiB0aGUgZXJyb3IgY2FsbGJhY2sgcmVzdWx0CiAqIEB3YXJuOiB0aGUgd2FybmluZyBjYWxsYmFjayByZXN1bHQKICogQGN0eDogY29udGV4dHVhbCBkYXRhIGZvciB0aGUgY2FsbGJhY2tzIHJlc3VsdAogKgogKiBHZXQgdGhlIGNhbGxiYWNrIGluZm9ybWF0aW9uIHVzZWQgdG8gaGFuZGxlIGVycm9ycyBmb3IgYSBwYXJzZXIgY29udGV4dAogKgogKiBSZXR1cm5zIC0xIGluIGNhc2Ugb2YgZmFpbHVyZSwgMCBvdGhlcndpc2UKICovCmludAp4bWxTY2hlbWFHZXRQYXJzZXJFcnJvcnMoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0ciBjdHh0LAoJCQkgeG1sU2NoZW1hVmFsaWRpdHlFcnJvckZ1bmMgKiBlcnIsCgkJCSB4bWxTY2hlbWFWYWxpZGl0eVdhcm5pbmdGdW5jICogd2Fybiwgdm9pZCAqKmN0eCkKewoJaWYgKGN0eHQgPT0gTlVMTCkKCQlyZXR1cm4oLTEpOwoJaWYgKGVyciAhPSBOVUxMKQoJCSplcnIgPSBjdHh0LT5lcnJvcjsKCWlmICh3YXJuICE9IE5VTEwpCgkJKndhcm4gPSBjdHh0LT53YXJuaW5nOwoJaWYgKGN0eCAhPSBOVUxMKQoJCSpjdHggPSBjdHh0LT5lcnJDdHh0OwoJcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hRmFjZXRUeXBlVG9TdHJpbmc6CiAqIEB0eXBlOiAgdGhlIGZhY2V0IHR5cGUKICoKICogQ29udmVydCB0aGUgeG1sU2NoZW1hVHlwZVR5cGUgdG8gYSBjaGFyIHN0cmluZy4KICoKICogUmV0dXJucyB0aGUgY2hhciBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIGZhY2V0IHR5cGUgaWYgdGhlCiAqICAgICB0eXBlIGlzIGEgZmFjZXQgYW5kIGFuICJJbnRlcm5hbCBFcnJvciIgc3RyaW5nIG90aGVyd2lzZS4KICovCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hRmFjZXRUeXBlVG9TdHJpbmcoeG1sU2NoZW1hVHlwZVR5cGUgdHlwZSkKewogICAgc3dpdGNoICh0eXBlKSB7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk46CiAgICAgICAgICAgIHJldHVybiAoQkFEX0NBU1QgInBhdHRlcm4iKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYRVhDTFVTSVZFOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJtYXhFeGNsdXNpdmUiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYSU5DTFVTSVZFOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJtYXhJbmNsdXNpdmUiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlORVhDTFVTSVZFOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJtaW5FeGNsdXNpdmUiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlOSU5DTFVTSVZFOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJtaW5JbmNsdXNpdmUiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfV0hJVEVTUEFDRToKICAgICAgICAgICAgcmV0dXJuIChCQURfQ0FTVCAid2hpdGVTcGFjZSIpOwogICAgICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9FTlVNRVJBVElPTjoKICAgICAgICAgICAgcmV0dXJuIChCQURfQ0FTVCAiZW51bWVyYXRpb24iKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTEVOR1RIOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJsZW5ndGgiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJtYXhMZW5ndGgiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUlOTEVOR1RIOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJtaW5MZW5ndGgiKTsKICAgICAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfVE9UQUxESUdJVFM6CiAgICAgICAgICAgIHJldHVybiAoQkFEX0NBU1QgInRvdGFsRGlnaXRzIik7CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0ZSQUNUSU9ORElHSVRTOgogICAgICAgICAgICByZXR1cm4gKEJBRF9DQVNUICJmcmFjdGlvbkRpZ2l0cyIpOwogICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgIGJyZWFrOwogICAgfQogICAgcmV0dXJuIChCQURfQ0FTVCAiSW50ZXJuYWwgRXJyb3IiKTsKfQoKc3RhdGljIHhtbFNjaGVtYVdoaXRlc3BhY2VWYWx1ZVR5cGUKeG1sU2NoZW1hR2V0V2hpdGVTcGFjZUZhY2V0VmFsdWUoeG1sU2NoZW1hVHlwZVB0ciB0eXBlKQp7CiAgICAvKgogICAgKiBUaGUgbm9ybWFsaXphdGlvbiB0eXBlIGNhbiBiZSBjaGFuZ2VkIG9ubHkgZm9yIHR5cGVzIHdoaWNoIGFyZSBkZXJpdmVkCiAgICAqIGZyb20geHNkOnN0cmluZy4KICAgICovCiAgICBpZiAodHlwZS0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpIHsKCS8qCgkqIE5vdGUgdGhhdCB3ZSBhc3N1bWUgYSB3aGl0ZXNwYWNlIG9mIHByZXNlcnZlIGZvciBhbnlTaW1wbGVUeXBlLgoJKi8KCWlmICgodHlwZS0+YnVpbHRJblR5cGUgPT0gWE1MX1NDSEVNQVNfU1RSSU5HKSB8fAoJICAgICh0eXBlLT5idWlsdEluVHlwZSA9PSBYTUxfU0NIRU1BU19BTllTSU1QTEVUWVBFKSkKCSAgICByZXR1cm4oWE1MX1NDSEVNQV9XSElURVNQQUNFX1BSRVNFUlZFKTsKCWVsc2UgaWYgKHR5cGUtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX05PUk1TVFJJTkcpCgkgICAgcmV0dXJuKFhNTF9TQ0hFTUFfV0hJVEVTUEFDRV9SRVBMQUNFKTsKCWVsc2UgewoJICAgIC8qCgkgICAgKiBGb3IgYWxsILdhdG9taWO3IGRhdGF0eXBlcyBvdGhlciB0aGFuIHN0cmluZyAoYW5kIHR5cGVzILdkZXJpdmVktwoJICAgICogYnkgt3Jlc3RyaWN0aW9utyBmcm9tIGl0KSB0aGUgdmFsdWUgb2Ygd2hpdGVTcGFjZSBpcyBmaXhlZCB0bwoJICAgICogY29sbGFwc2UKCSAgICAqIE5vdGUgdGhhdCB0aGlzIGluY2x1ZGVzIGJ1aWx0LWluIGxpc3QgZGF0YXR5cGVzLgoJICAgICovCgkgICAgcmV0dXJuKFhNTF9TQ0hFTUFfV0hJVEVTUEFDRV9DT0xMQVBTRSk7Cgl9CiAgICB9IGVsc2UgaWYgKFdYU19JU19MSVNUKHR5cGUpKSB7CgkvKgoJKiBGb3IgbGlzdCB0eXBlcyB0aGUgZmFjZXQgIndoaXRlU3BhY2UiIGlzIGZpeGVkIHRvICJjb2xsYXBzZSIuCgkqLwoJcmV0dXJuIChYTUxfU0NIRU1BX1dISVRFU1BBQ0VfQ09MTEFQU0UpOwogICAgfSBlbHNlIGlmIChXWFNfSVNfVU5JT04odHlwZSkpIHsKCXJldHVybiAoWE1MX1NDSEVNQV9XSElURVNQQUNFX1VOS05PV04pOwogICAgfSBlbHNlIGlmIChXWFNfSVNfQVRPTUlDKHR5cGUpKSB7CglpZiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX1dISVRFU1BBQ0VfUFJFU0VSVkUpCgkgICAgcmV0dXJuIChYTUxfU0NIRU1BX1dISVRFU1BBQ0VfUFJFU0VSVkUpOwoJZWxzZSBpZiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX1dISVRFU1BBQ0VfUkVQTEFDRSkKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFfV0hJVEVTUEFDRV9SRVBMQUNFKTsKCWVsc2UKCSAgICByZXR1cm4gKFhNTF9TQ0hFTUFfV0hJVEVTUEFDRV9DT0xMQVBTRSk7CiAgICB9CiAgICByZXR1cm4gKC0xKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJCVNpbXBsZSB0eXBlIHZhbGlkYXRpb24JCQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJCURPTSBWYWxpZGF0aW9uIGNvZGUJCQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgovKioKICogeG1sU2NoZW1hQXNzZW1ibGVCeUxvY2F0aW9uOgogKiBAcGN0eHQ6ICBhIHNjaGVtYSBwYXJzZXIgY29udGV4dAogKiBAdmN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNjaGVtYTogdGhlIGV4aXN0aW5nIHNjaGVtYQogKiBAbm9kZTogdGhlIG5vZGUgdGhhdCBmaXJlZCB0aGUgYXNzZW1ibGluZwogKiBAbnNOYW1lOiB0aGUgbmFtZXNwYWNlIG5hbWUgb2YgdGhlIG5ldyBzY2hlbWEKICogQGxvY2F0aW9uOiB0aGUgbG9jYXRpb24gb2YgdGhlIHNjaGVtYQogKgogKiBFeHBhbmRzIGFuIGV4aXN0aW5nIHNjaGVtYSBieSBhbiBhZGRpdGlvbmFsIHNjaGVtYS4KICoKICogUmV0dXJucyAwIGlmIHRoZSBuZXcgc2NoZW1hIGlzIGNvcnJlY3QsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiBudW1iZXIgb3RoZXJ3aXNlIGFuZCAtMSBpbiBjYXNlIG9mIGFuIGludGVybmFsIG9yIEFQSSBlcnJvci4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hQXNzZW1ibGVCeUxvY2F0aW9uKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJICAgIHhtbFNjaGVtYVB0ciBzY2hlbWEsCgkJCSAgICB4bWxOb2RlUHRyIG5vZGUsCgkJCSAgICBjb25zdCB4bWxDaGFyICpuc05hbWUsCgkJCSAgICBjb25zdCB4bWxDaGFyICpsb2NhdGlvbikKewogICAgaW50IHJldCA9IDA7CiAgICB4bWxTY2hlbWFQYXJzZXJDdHh0UHRyIHBjdHh0OwogICAgeG1sU2NoZW1hQnVja2V0UHRyIGJ1Y2tldCA9IE5VTEw7CgogICAgaWYgKCh2Y3R4dCA9PSBOVUxMKSB8fCAoc2NoZW1hID09IE5VTEwpKQoJcmV0dXJuICgtMSk7CgogICAgaWYgKHZjdHh0LT5wY3R4dCA9PSBOVUxMKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFBc3NlbWJsZUJ5TG9jYXRpb24iLAoJICAgICJubyBwYXJzZXIgY29udGV4dCBhdmFpbGFibGUiKTsKCXJldHVybigtMSk7CiAgICB9CiAgICBwY3R4dCA9IHZjdHh0LT5wY3R4dDsKICAgIGlmIChwY3R4dC0+Y29uc3RydWN0b3IgPT0gTlVMTCkgewoJUEVSUk9SX0lOVCgieG1sU2NoZW1hQXNzZW1ibGVCeUxvY2F0aW9uIiwKCSAgICAibm8gY29uc3RydWN0b3IiKTsKCXJldHVybigtMSk7CiAgICB9CiAgICAvKgogICAgKiBBY3F1aXJlIHRoZSBzY2hlbWEgZG9jdW1lbnQuCiAgICAqLwogICAgbG9jYXRpb24gPSB4bWxTY2hlbWFCdWlsZEFic29sdXRlVVJJKHBjdHh0LT5kaWN0LAoJbG9jYXRpb24sIG5vZGUpOwogICAgLyoKICAgICogTm90ZSB0aGF0IHdlIHBhc3MgWE1MX1NDSEVNQV9TQ0hFTUFfSU1QT1JUIGhlcmU7CiAgICAqIHRoZSBwcm9jZXNzIHdpbGwgYXV0b21hdGljYWxseSBjaGFuZ2UgdGhpcyB0bwogICAgKiBYTUxfU0NIRU1BX1NDSEVNQV9NQUlOIGlmIGl0IGlzIHRoZSBmaXJzdCBzY2hlbWEgZG9jdW1lbnQuCiAgICAqLwogICAgcmV0ID0geG1sU2NoZW1hQWRkU2NoZW1hRG9jKHBjdHh0LCBYTUxfU0NIRU1BX1NDSEVNQV9JTVBPUlQsCglsb2NhdGlvbiwgTlVMTCwgTlVMTCwgMCwgbm9kZSwgTlVMTCwgbnNOYW1lLCAKCSZidWNrZXQpOwogICAgaWYgKHJldCAhPSAwKQoJcmV0dXJuKHJldCk7CiAgICBpZiAoYnVja2V0ID09IE5VTEwpIHsKCVBFUlJPUl9JTlQoInhtbFNjaGVtYUFzc2VtYmxlQnlMb2NhdGlvbiIsCgkgICAgIm5vIHNjaGVtYSBidWNrZXQgYWNxdWlyZWQiKTsKCXJldHVybigtMSk7CiAgICB9IAogICAgLyoKICAgICogVGhlIGZpcnN0IGxvY2F0ZWQgc2NoZW1hIHdpbGwgYmUgaGFuZGxlZCBhcyBpZiBhbGwgb3RoZXIKICAgICogc2NoZW1hcyBpbXBvcnRlZCBieSBYU0kgd2VyZSBpbXBvcnRlZCBieSB0aGlzIGZpcnN0IHNjaGVtYS4KICAgICovCiAgICBpZiAoKGJ1Y2tldCAhPSBOVUxMKSAmJgoJKFdYU19DT05TVFJVQ1RPUihwY3R4dCktPmJ1Y2tldCA9PSBOVUxMKSkKCVdYU19DT05TVFJVQ1RPUihwY3R4dCktPmJ1Y2tldCA9IGJ1Y2tldDsKICAgIC8qCiAgICAqIFRPRE86IElzIHRoaXMgaGFuZGxlZCBsaWtlIGFuIGltcG9ydD8gSS5lLiBpcyBpdCBub3QgYW4gZXJyb3IKICAgICogaWYgdGhlIHNjaGVtYSBjYW5ub3QgYmUgbG9jYXRlZD8KICAgICovCiAgICBpZiAoKGJ1Y2tldCA9PSBOVUxMKSB8fCAoISBDQU5fUEFSU0VfU0NIRU1BKGJ1Y2tldCkpKQoJcmV0dXJuKDApOwogICAgLyoKICAgICogV2Ugd2lsbCByZXVzZSB0aGUgcGFyc2VyIGNvbnRleHQgZm9yIGV2ZXJ5IHNjaGVtYSBpbXBvcnRlZAogICAgKiBkaXJlY3RseSB2aWEgWFNJLiBTbyByZXNldCB0aGUgY29udGV4dC4KICAgICovCiAgICBwY3R4dC0+bmJlcnJvcnMgPSAwOwogICAgcGN0eHQtPmVyciA9IDA7CiAgICBwY3R4dC0+ZG9jID0gYnVja2V0LT5kb2M7CiAgICAKICAgIHJldCA9IHhtbFNjaGVtYVBhcnNlTmV3RG9jV2l0aENvbnRleHQocGN0eHQsIHNjaGVtYSwgYnVja2V0KTsgICAgICAgIAogICAgaWYgKHJldCA9PSAtMSkgewoJcGN0eHQtPmRvYyA9IE5VTEw7Cglnb3RvIGV4aXRfZmFpbHVyZTsKICAgIH0KICAgIC8qIFBhcmFub2lkIGVycm9yIGNoYW5uZWxsaW5nLiAqLwogICAgaWYgKChyZXQgPT0gMCkgJiYgKHBjdHh0LT5uYmVycm9ycyAhPSAwKSkKCXJldCA9IHBjdHh0LT5lcnI7ICAgIAogICAgaWYgKHBjdHh0LT5uYmVycm9ycyA9PSAwKSB7CgkvKiAKCSogT25seSBib3RoZXIgdG8gZml4dXAgcGVuZGluZyBjb21wb25lbnRzLCBpZiB0aGVyZSB3YXMKCSogbm8gZXJyb3IgeWV0LgoJKi8KCXhtbFNjaGVtYUZpeHVwQ29tcG9uZW50cyhwY3R4dCk7CglyZXQgPSBwY3R4dC0+ZXJyOwoJLyoKCSogTm90IG5pY2UsIGJ1dCB3ZSBuZWVkIHNvbWVob3cgdG8gY2hhbm5lbCB0aGUgc2NoZW1hIHBhcnNlcgoJKiBlcnJvciB0byB0aGUgdmFsaWRhdGlvbiBjb250ZXh0LgoJKi8KCWlmICgocmV0ICE9IDApICYmICh2Y3R4dC0+ZXJyID09IDApKQoJICAgIHZjdHh0LT5lcnIgPSByZXQ7Cgl2Y3R4dC0+bmJlcnJvcnMgKz0gcGN0eHQtPm5iZXJyb3JzOwogICAgfSBlbHNlIHsKCS8qIEFkZCB0byB2YWxpZGF0aW9uIGVycm9yIHN1bS4gKi8gCgl2Y3R4dC0+bmJlcnJvcnMgKz0gcGN0eHQtPm5iZXJyb3JzOwogICAgfQogICAgcGN0eHQtPmRvYyA9IE5VTEw7CiAgICByZXR1cm4ocmV0KTsKZXhpdF9mYWlsdXJlOgogICAgcGN0eHQtPmRvYyA9IE5VTEw7CiAgICByZXR1cm4gKC0xKTsKfQoKc3RhdGljIHhtbFNjaGVtYUF0dHJJbmZvUHRyCnhtbFNjaGVtYUdldE1ldGFBdHRySW5mbyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCQkgICAgICAKCQkJIGludCBtZXRhVHlwZSkKewogICAgaWYgKHZjdHh0LT5uYkF0dHJJbmZvcyA9PSAwKQoJcmV0dXJuIChOVUxMKTsKICAgIHsKCWludCBpOwoJeG1sU2NoZW1hQXR0ckluZm9QdHIgaWF0dHI7CgoJZm9yIChpID0gMDsgaSA8IHZjdHh0LT5uYkF0dHJJbmZvczsgaSsrKSB7CgkgICAgaWF0dHIgPSB2Y3R4dC0+YXR0ckluZm9zW2ldOwoJICAgIGlmIChpYXR0ci0+bWV0YVR5cGUgPT0gbWV0YVR5cGUpCgkJcmV0dXJuIChpYXR0cik7Cgl9CgogICAgfQogICAgcmV0dXJuIChOVUxMKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUFzc2VtYmxlQnlYU0k6CiAqIEB2Y3R4dDogIGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKgogKiBFeHBhbmRzIGFuIGV4aXN0aW5nIHNjaGVtYSBieSBhbiBhZGRpdGlvbmFsIHNjaGVtYSB1c2luZwogKiB0aGUgeHNpOnNjaGVtYUxvY2F0aW9uIG9yIHhzaTpub05hbWVzcGFjZVNjaGVtYUxvY2F0aW9uIGF0dHJpYnV0ZQogKiBvZiBhbiBpbnN0YW5jZS4gSWYgeHNpOm5vTmFtZXNwYWNlU2NoZW1hTG9jYXRpb24gaXMgdXNlZCwgQG5vTmFtZXNwYWNlCiAqIG11c3QgYmUgc2V0IHRvIDEuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgbmV3IHNjaGVtYSBpcyBjb3JyZWN0LCBhIHBvc2l0aXZlIGVycm9yIGNvZGUKICogbnVtYmVyIG90aGVyd2lzZSBhbmQgLTEgaW4gY2FzZSBvZiBhbiBpbnRlcm5hbCBvciBBUEkgZXJyb3IuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUFzc2VtYmxlQnlYU0koeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7CiAgICBjb25zdCB4bWxDaGFyICpjdXIsICplbmQ7CiAgICBjb25zdCB4bWxDaGFyICpuc25hbWUgPSBOVUxMLCAqbG9jYXRpb247CiAgICBpbnQgY291bnQgPSAwOwogICAgaW50IHJldCA9IDA7CiAgICB4bWxTY2hlbWFBdHRySW5mb1B0ciBpYXR0cjsKCiAgICAvKgogICAgKiBQYXJzZSB0aGUgdmFsdWU7IHdlIHdpbGwgYXNzdW1lIGFuIGV2ZW4gbnVtYmVyIG9mIHZhbHVlcwogICAgKiB0byBiZSBnaXZlbiAodGhpcyBpcyBob3cgWGVyY2VzIGFuZCBYU1Ygd29yaykuCiAgICAqCiAgICAqIFVSR0VOVCBUT0RPOiAhISBUaGlzIG5lZWRzIHRvIHdvcmsgZm9yIGJvdGgKICAgICogQG5vTmFtZXNwYWNlU2NoZW1hTG9jYXRpb24gQU5EIEBzY2hlbWFMb2NhdGlvbiBvbiB0aGUgc2FtZQogICAgKiBlbGVtZW50ICEhCiAgICAqLwogICAgaWF0dHIgPSB4bWxTY2hlbWFHZXRNZXRhQXR0ckluZm8odmN0eHQsCglYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hTSV9TQ0hFTUFfTE9DKTsKICAgIGlmIChpYXR0ciA9PSBOVUxMKQoJaWF0dHIgPSB4bWxTY2hlbWFHZXRNZXRhQXR0ckluZm8odmN0eHQsCglYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hTSV9OT19OU19TQ0hFTUFfTE9DKTsKICAgIGlmIChpYXR0ciA9PSBOVUxMKQoJcmV0dXJuICgwKTsKICAgIGN1ciA9IGlhdHRyLT52YWx1ZTsKICAgIGRvIHsKCWlmIChpYXR0ci0+bWV0YVR5cGUgPT0gWE1MX1NDSEVNQV9BVFRSX0lORk9fTUVUQV9YU0lfU0NIRU1BX0xPQykgewoJICAgIC8qCgkgICAgKiBHZXQgdGhlIG5hbWVzcGFjZSBuYW1lLgoJICAgICovCgkgICAgd2hpbGUgKElTX0JMQU5LX0NIKCpjdXIpKQoJCWN1cisrOwoJICAgIGVuZCA9IGN1cjsKCSAgICB3aGlsZSAoKCplbmQgIT0gMCkgJiYgKCEoSVNfQkxBTktfQ0goKmVuZCkpKSkKCQllbmQrKzsKCSAgICBpZiAoZW5kID09IGN1cikKCQlicmVhazsKCSAgICBjb3VudCsrOwoJICAgIG5zbmFtZSA9IHhtbERpY3RMb29rdXAodmN0eHQtPnNjaGVtYS0+ZGljdCwgY3VyLCBlbmQgLSBjdXIpOwoJICAgIGN1ciA9IGVuZDsKCX0KCS8qCgkqIEdldCB0aGUgVVJJLgoJKi8KCXdoaWxlIChJU19CTEFOS19DSCgqY3VyKSkKCSAgICBjdXIrKzsKCWVuZCA9IGN1cjsKCXdoaWxlICgoKmVuZCAhPSAwKSAmJiAoIShJU19CTEFOS19DSCgqZW5kKSkpKQoJICAgIGVuZCsrOwoJaWYgKGVuZCA9PSBjdXIpCgkgICAgYnJlYWs7Cgljb3VudCsrOwoJbG9jYXRpb24gPSB4bWxEaWN0TG9va3VwKHZjdHh0LT5zY2hlbWEtPmRpY3QsIGN1ciwgZW5kIC0gY3VyKTsKCWN1ciA9IGVuZDsKCXJldCA9IHhtbFNjaGVtYUFzc2VtYmxlQnlMb2NhdGlvbih2Y3R4dCwgdmN0eHQtPnNjaGVtYSwKCSAgICBpYXR0ci0+bm9kZSwgbnNuYW1lLCBsb2NhdGlvbik7CglpZiAocmV0ID09IC0xKSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hQXNzZW1ibGVCeVhTSSIsCgkJImFzc2VtYmxpbmcgc2NoZW1hdGEiKTsKCSAgICByZXR1cm4gKC0xKTsKCX0KICAgIH0gd2hpbGUgKCpjdXIgIT0gMCk7CiAgICByZXR1cm4gKHJldCk7Cn0KCnN0YXRpYyBjb25zdCB4bWxDaGFyICoKeG1sU2NoZW1hTG9va3VwTmFtZXNwYWNlKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJIGNvbnN0IHhtbENoYXIgKnByZWZpeCkKewogICAgaWYgKHZjdHh0LT5zYXggIT0gTlVMTCkgewoJaW50IGksIGo7Cgl4bWxTY2hlbWFOb2RlSW5mb1B0ciBpbm9kZTsKCQoJZm9yIChpID0gdmN0eHQtPmRlcHRoOyBpID49IDA7IGktLSkgewoJICAgIGlmICh2Y3R4dC0+ZWxlbUluZm9zW2ldLT5uYk5zQmluZGluZ3MgIT0gMCkgewoJCWlub2RlID0gdmN0eHQtPmVsZW1JbmZvc1tpXTsKCQlmb3IgKGogPSAwOyBqIDwgaW5vZGUtPm5iTnNCaW5kaW5ncyAqIDI7IGogKz0gMikgewoJCSAgICBpZiAoKChwcmVmaXggPT0gTlVMTCkgJiYKCQkJICAgIChpbm9kZS0+bnNCaW5kaW5nc1tqXSA9PSBOVUxMKSkgfHwKCQkJKChwcmVmaXggIT0gTlVMTCkgJiYgeG1sU3RyRXF1YWwocHJlZml4LAoJCQkgICAgaW5vZGUtPm5zQmluZGluZ3Nbal0pKSkgewoKCQkJLyoKCQkJKiBOb3RlIHRoYXQgdGhlIG5hbWVzcGFjZSBiaW5kaW5ncyBhcmUgYWxyZWFkeQoJCQkqIGluIGEgc3RyaW5nIGRpY3QuCgkJCSovCgkJCXJldHVybiAoaW5vZGUtPm5zQmluZGluZ3NbaisxXSk7CQkJCgkJICAgIH0KCQl9CgkgICAgfQoJfQoJcmV0dXJuIChOVUxMKTsKI2lmZGVmIExJQlhNTF9XUklURVJfRU5BQkxFRAogICAgfSBlbHNlIGlmICh2Y3R4dC0+cmVhZGVyICE9IE5VTEwpIHsKCXhtbENoYXIgKm5zTmFtZTsKCQoJbnNOYW1lID0geG1sVGV4dFJlYWRlckxvb2t1cE5hbWVzcGFjZSh2Y3R4dC0+cmVhZGVyLCBwcmVmaXgpOwoJaWYgKG5zTmFtZSAhPSBOVUxMKSB7CgkgICAgY29uc3QgeG1sQ2hhciAqcmV0OwoKCSAgICByZXQgPSB4bWxEaWN0TG9va3VwKHZjdHh0LT5kaWN0LCBuc05hbWUsIC0xKTsKCSAgICB4bWxGcmVlKG5zTmFtZSk7CgkgICAgcmV0dXJuIChyZXQpOwoJfSBlbHNlCgkgICAgcmV0dXJuIChOVUxMKTsKI2VuZGlmCiAgICB9IGVsc2UgewoJeG1sTnNQdHIgbnM7CgoJaWYgKCh2Y3R4dC0+aW5vZGUtPm5vZGUgPT0gTlVMTCkgfHwKCSAgICAodmN0eHQtPmlub2RlLT5ub2RlLT5kb2MgPT0gTlVMTCkpIHsKCSAgICBWRVJST1JfSU5UKCJ4bWxTY2hlbWFMb29rdXBOYW1lc3BhY2UiLAoJCSJubyBub2RlIG9yIG5vZGUncyBkb2MgYXZhbGlhYmxlIik7CgkgICAgcmV0dXJuIChOVUxMKTsKCX0KCW5zID0geG1sU2VhcmNoTnModmN0eHQtPmlub2RlLT5ub2RlLT5kb2MsCgkgICAgdmN0eHQtPmlub2RlLT5ub2RlLCBwcmVmaXgpOwoJaWYgKG5zICE9IE5VTEwpCgkgICAgcmV0dXJuIChucy0+aHJlZik7CglyZXR1cm4gKE5VTEwpOwogICAgfQp9CgovKgoqIFRoaXMgb25lIHdvcmtzIG9uIHRoZSBzY2hlbWEgb2YgdGhlIHZhbGlkYXRpb24gY29udGV4dC4KKi8Kc3RhdGljIGludAp4bWxTY2hlbWFWYWxpZGF0ZU5vdGF0aW9uKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwgCQkJICAKCQkJICB4bWxTY2hlbWFQdHIgc2NoZW1hLAoJCQkgIHhtbE5vZGVQdHIgbm9kZSwKCQkJICBjb25zdCB4bWxDaGFyICp2YWx1ZSwKCQkJICB4bWxTY2hlbWFWYWxQdHIgKnZhbCwKCQkJICBpbnQgdmFsTmVlZGVkKQp7CiAgICBpbnQgcmV0OwoKICAgIGlmICh2Y3R4dCAmJiAodmN0eHQtPnNjaGVtYSA9PSBOVUxMKSkgewoJVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVOb3RhdGlvbiIsCgkgICAgImEgc2NoZW1hIGlzIG5lZWRlZCBvbiB0aGUgdmFsaWRhdGlvbiBjb250ZXh0Iik7CglyZXR1cm4gKC0xKTsKICAgIH0KICAgIHJldCA9IHhtbFZhbGlkYXRlUU5hbWUodmFsdWUsIDEpOwogICAgaWYgKHJldCAhPSAwKQoJcmV0dXJuIChyZXQpOwogICAgewoJeG1sQ2hhciAqbG9jYWxOYW1lID0gTlVMTDsKCXhtbENoYXIgKnByZWZpeCA9IE5VTEw7CgoJbG9jYWxOYW1lID0geG1sU3BsaXRRTmFtZTIodmFsdWUsICZwcmVmaXgpOwoJaWYgKHByZWZpeCAhPSBOVUxMKSB7CgkgICAgY29uc3QgeG1sQ2hhciAqbnNOYW1lID0gTlVMTDsKCgkgICAgaWYgKHZjdHh0ICE9IE5VTEwpIAoJCW5zTmFtZSA9IHhtbFNjaGVtYUxvb2t1cE5hbWVzcGFjZSh2Y3R4dCwgQkFEX0NBU1QgcHJlZml4KTsKCSAgICBlbHNlIGlmIChub2RlICE9IE5VTEwpIHsKCQl4bWxOc1B0ciBucyA9IHhtbFNlYXJjaE5zKG5vZGUtPmRvYywgbm9kZSwgcHJlZml4KTsKCQlpZiAobnMgIT0gTlVMTCkKCQkgICAgbnNOYW1lID0gbnMtPmhyZWY7CgkgICAgfSBlbHNlIHsKCQl4bWxGcmVlKHByZWZpeCk7CgkJeG1sRnJlZShsb2NhbE5hbWUpOwoJCXJldHVybiAoMSk7CgkgICAgfQoJICAgIGlmIChuc05hbWUgPT0gTlVMTCkgewoJCXhtbEZyZWUocHJlZml4KTsKCQl4bWxGcmVlKGxvY2FsTmFtZSk7CgkJcmV0dXJuICgxKTsKCSAgICB9CgkgICAgaWYgKHhtbFNjaGVtYUdldE5vdGF0aW9uKHNjaGVtYSwgbG9jYWxOYW1lLCBuc05hbWUpICE9IE5VTEwpIHsKCQlpZiAodmFsTmVlZGVkICYmICh2YWwgIT0gTlVMTCkpIHsKCQkgICAgKCp2YWwpID0geG1sU2NoZW1hTmV3Tk9UQVRJT05WYWx1ZShCQURfQ0FTVCBsb2NhbE5hbWUsCgkJCUJBRF9DQVNUIHhtbFN0cmR1cChuc05hbWUpKTsKCQkgICAgaWYgKCp2YWwgPT0gTlVMTCkKCQkJcmV0ID0gLTE7CgkJfQoJICAgIH0gZWxzZQoJCXJldCA9IDE7CgkgICAgeG1sRnJlZShwcmVmaXgpOwoJICAgIHhtbEZyZWUobG9jYWxOYW1lKTsKCX0gZWxzZSB7CgkgICAgaWYgKHhtbFNjaGVtYUdldE5vdGF0aW9uKHNjaGVtYSwgdmFsdWUsIE5VTEwpICE9IE5VTEwpIHsKCQlpZiAodmFsTmVlZGVkICYmICh2YWwgIT0gTlVMTCkpIHsKCQkgICAgKCp2YWwpID0geG1sU2NoZW1hTmV3Tk9UQVRJT05WYWx1ZSgKCQkJQkFEX0NBU1QgeG1sU3RyZHVwKHZhbHVlKSwgTlVMTCk7CgkJICAgIGlmICgqdmFsID09IE5VTEwpCgkJCXJldCA9IC0xOwoJCX0KCSAgICB9IGVsc2UKCQlyZXR1cm4gKDEpOwoJfQogICAgfQogICAgcmV0dXJuIChyZXQpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVZBZGROb2RlUU5hbWUoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0LAoJCSAgICAgICBjb25zdCB4bWxDaGFyKiBsbmFtZSwKCQkgICAgICAgY29uc3QgeG1sQ2hhciogbnNuYW1lKQp7CiAgICBpbnQgaTsKCiAgICBsbmFtZSA9IHhtbERpY3RMb29rdXAodmN0eHQtPmRpY3QsIGxuYW1lLCAtMSk7CiAgICBpZiAobG5hbWUgPT0gTlVMTCkKCXJldHVybigtMSk7CiAgICBpZiAobnNuYW1lICE9IE5VTEwpIHsKCW5zbmFtZSA9IHhtbERpY3RMb29rdXAodmN0eHQtPmRpY3QsIG5zbmFtZSwgLTEpOwoJaWYgKG5zbmFtZSA9PSBOVUxMKQoJICAgIHJldHVybigtMSk7CiAgICB9CiAgICBmb3IgKGkgPSAwOyBpIDwgdmN0eHQtPm5vZGVRTmFtZXMtPm5iSXRlbXM7IGkgKz0gMikgewoJaWYgKCh2Y3R4dC0+bm9kZVFOYW1lcy0+aXRlbXMgW2ldID09IGxuYW1lKSAmJgoJICAgICh2Y3R4dC0+bm9kZVFOYW1lcy0+aXRlbXNbaSArMV0gPT0gbnNuYW1lKSkKCSAgICAvKiBBbHJlYWR5IHRoZXJlICovCgkgICAgcmV0dXJuKGkpOwogICAgfQogICAgLyogQWRkIG5ldyBlbnRyeS4gKi8KICAgIGkgPSB2Y3R4dC0+bm9kZVFOYW1lcy0+bmJJdGVtczsKICAgIHhtbFNjaGVtYUl0ZW1MaXN0QWRkKHZjdHh0LT5ub2RlUU5hbWVzLCAodm9pZCAqKSBsbmFtZSk7CiAgICB4bWxTY2hlbWFJdGVtTGlzdEFkZCh2Y3R4dC0+bm9kZVFOYW1lcywgKHZvaWQgKikgbnNuYW1lKTsKICAgIHJldHVybihpKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqICBWYWxpZGF0aW9uIG9mIGlkZW50aXR5LWNvbnN0cmFpbnRzIChJREMpICAgICAgICAgICAgICAgICAgICAgICAgICAgICoKICogCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoqCiAqIHhtbFNjaGVtYUF1Z21lbnRJREM6CiAqIEBpZGNEZWY6IHRoZSBJREMgZGVmaW5pdGlvbgogKgogKiBDcmVhdGVzIGFuIGF1Z21lbnRlZCBJREMgZGVmaW5pdGlvbiBpdGVtLgogKgogKiBSZXR1cm5zIHRoZSBpdGVtLCBvciBOVUxMIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyB2b2lkCnhtbFNjaGVtYUF1Z21lbnRJREMoeG1sU2NoZW1hSURDUHRyIGlkY0RlZiwKCQkgICAgeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7CiAgICB4bWxTY2hlbWFJRENBdWdQdHIgYWlkYzsKCiAgICBhaWRjID0gKHhtbFNjaGVtYUlEQ0F1Z1B0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFJRENBdWcpKTsKICAgIGlmIChhaWRjID09IE5VTEwpIHsKCXhtbFNjaGVtYVZFcnJNZW1vcnkodmN0eHQsCgkgICAgInhtbFNjaGVtYUF1Z21lbnRJREM6IGFsbG9jYXRpbmcgYW4gYXVnbWVudGVkIElEQyBkZWZpbml0aW9uIiwKCSAgICBOVUxMKTsKCXJldHVybjsKICAgIH0KICAgIGFpZGMtPmtleXJlZkRlcHRoID0gLTE7CiAgICBhaWRjLT5kZWYgPSBpZGNEZWY7CiAgICBhaWRjLT5uZXh0ID0gTlVMTDsKICAgIGlmICh2Y3R4dC0+YWlkY3MgPT0gTlVMTCkKCXZjdHh0LT5haWRjcyA9IGFpZGM7CiAgICBlbHNlIHsKCWFpZGMtPm5leHQgPSB2Y3R4dC0+YWlkY3M7Cgl2Y3R4dC0+YWlkY3MgPSBhaWRjOwogICAgfQogICAgLyoKICAgICogU2F2ZSBpZiB3ZSBoYXZlIGtleXJlZnMgYXQgYWxsLgogICAgKi8KICAgIGlmICgodmN0eHQtPmhhc0tleXJlZnMgPT0gMCkgJiYKCShpZGNEZWYtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUYpKQoJdmN0eHQtPmhhc0tleXJlZnMgPSAxOwp9CgovKioKICogeG1sU2NoZW1hSURDTmV3QmluZGluZzoKICogQGlkY0RlZjogdGhlIElEQyBkZWZpbml0aW9uIG9mIHRoaXMgYmluZGluZwogKgogKiBDcmVhdGVzIGEgbmV3IElEQyBiaW5kaW5nLgogKgogKiBSZXR1cm5zIHRoZSBuZXcgSURDIGJpbmRpbmcsIE5VTEwgb24gaW50ZXJuYWwgZXJyb3JzLgogKi8Kc3RhdGljIHhtbFNjaGVtYVBTVklJRENCaW5kaW5nUHRyCnhtbFNjaGVtYUlEQ05ld0JpbmRpbmcoeG1sU2NoZW1hSURDUHRyIGlkY0RlZikKewogICAgeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmdQdHIgcmV0OwoKICAgIHJldCA9ICh4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0cikgeG1sTWFsbG9jKAoJICAgIHNpemVvZih4bWxTY2hlbWFQU1ZJSURDQmluZGluZykpOwogICAgaWYgKHJldCA9PSBOVUxMKSB7Cgl4bWxTY2hlbWFWRXJyTWVtb3J5KE5VTEwsCgkgICAgImFsbG9jYXRpbmcgYSBQU1ZJIElEQyBiaW5kaW5nIGl0ZW0iLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICBtZW1zZXQocmV0LCAwLCBzaXplb2YoeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmcpKTsKICAgIHJldC0+ZGVmaW5pdGlvbiA9IGlkY0RlZjsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYUlEQ1N0b3JlTm9kZVRhYmxlSXRlbToKICogQHZjdHh0OiB0aGUgV1hTIHZhbGlkYXRpb24gY29udGV4dAogKiBAaXRlbTogdGhlIElEQyBub2RlIHRhYmxlIGl0ZW0KICoKICogVGhlIHZhbGlkYXRpb24gY29udGV4dCBpcyB1c2VkIHRvIHN0b3JlIElEQyBub2RlIHRhYmxlIGl0ZW1zLgogKiBUaGV5IGFyZSBzdG9yZWQgdG8gYXZvaWQgY29weWluZyB0aGVtIGlmIElEQyBub2RlLXRhYmxlcyBhcmUgbWVyZ2VkCiAqIHdpdGggY29ycmVzcG9uZGluZyBwYXJlbnQgSURDIG5vZGUtdGFibGVzIChidWJibGluZykuCiAqCiAqIFJldHVybnMgMCBpZiBzdWNjZWVkZWQsIC0xIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hSURDU3RvcmVOb2RlVGFibGVJdGVtKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJICAgICAgIHhtbFNjaGVtYVBTVklJRENOb2RlUHRyIGl0ZW0pCnsKICAgIC8qCiAgICAqIEFkZCB0byBnb2JhbCBsaXN0LgogICAgKi8KICAgIGlmICh2Y3R4dC0+aWRjTm9kZXMgPT0gTlVMTCkgewoJdmN0eHQtPmlkY05vZGVzID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopCgkgICAgeG1sTWFsbG9jKDIwICogc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyKSk7CglpZiAodmN0eHQtPmlkY05vZGVzID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFWRXJyTWVtb3J5KHZjdHh0LAoJCSJhbGxvY2F0aW5nIHRoZSBJREMgbm9kZSB0YWJsZSBpdGVtIGxpc3QiLCBOVUxMKTsKCSAgICByZXR1cm4gKC0xKTsKCX0KCXZjdHh0LT5zaXplSWRjTm9kZXMgPSAyMDsKICAgIH0gZWxzZSBpZiAodmN0eHQtPnNpemVJZGNOb2RlcyA8PSB2Y3R4dC0+bmJJZGNOb2RlcykgewoJdmN0eHQtPnNpemVJZGNOb2RlcyAqPSAyOwoJdmN0eHQtPmlkY05vZGVzID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopCgkgICAgeG1sUmVhbGxvYyh2Y3R4dC0+aWRjTm9kZXMsIHZjdHh0LT5zaXplSWRjTm9kZXMgKgoJICAgIHNpemVvZih4bWxTY2hlbWFQU1ZJSURDTm9kZVB0cikpOwoJaWYgKHZjdHh0LT5pZGNOb2RlcyA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hVkVyck1lbW9yeSh2Y3R4dCwKCQkicmUtYWxsb2NhdGluZyB0aGUgSURDIG5vZGUgdGFibGUgaXRlbSBsaXN0IiwgTlVMTCk7CgkgICAgcmV0dXJuICgtMSk7Cgl9CiAgICB9CiAgICB2Y3R4dC0+aWRjTm9kZXNbdmN0eHQtPm5iSWRjTm9kZXMrK10gPSBpdGVtOwoKICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFJRENTdG9yZUtleToKICogQHZjdHh0OiB0aGUgV1hTIHZhbGlkYXRpb24gY29udGV4dAogKiBAaXRlbTogdGhlIElEQyBrZXkKICoKICogVGhlIHZhbGlkYXRpb24gY29udGV4dCBpcyB1c2VkIHRvIHN0b3JlIGFuIElEQyBrZXkuCiAqCiAqIFJldHVybnMgMCBpZiBzdWNjZWVkZWQsIC0xIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hSURDU3RvcmVLZXkoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0LAoJCSAgICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciBrZXkpCnsKICAgIC8qCiAgICAqIEFkZCB0byBnb2JhbCBsaXN0LgogICAgKi8KICAgIGlmICh2Y3R4dC0+aWRjS2V5cyA9PSBOVUxMKSB7Cgl2Y3R4dC0+aWRjS2V5cyA9ICh4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICopCgkgICAgeG1sTWFsbG9jKDQwICogc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENLZXlQdHIpKTsKCWlmICh2Y3R4dC0+aWRjS2V5cyA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hVkVyck1lbW9yeSh2Y3R4dCwKCQkiYWxsb2NhdGluZyB0aGUgSURDIGtleSBzdG9yYWdlIGxpc3QiLCBOVUxMKTsKCSAgICByZXR1cm4gKC0xKTsKCX0KCXZjdHh0LT5zaXplSWRjS2V5cyA9IDQwOwogICAgfSBlbHNlIGlmICh2Y3R4dC0+c2l6ZUlkY0tleXMgPD0gdmN0eHQtPm5iSWRjS2V5cykgewoJdmN0eHQtPnNpemVJZGNLZXlzICo9IDI7Cgl2Y3R4dC0+aWRjS2V5cyA9ICh4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICopCgkgICAgeG1sUmVhbGxvYyh2Y3R4dC0+aWRjS2V5cywgdmN0eHQtPnNpemVJZGNLZXlzICoKCSAgICBzaXplb2YoeG1sU2NoZW1hUFNWSUlEQ0tleVB0cikpOwoJaWYgKHZjdHh0LT5pZGNLZXlzID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFWRXJyTWVtb3J5KHZjdHh0LAoJCSJyZS1hbGxvY2F0aW5nIHRoZSBJREMga2V5IHN0b3JhZ2UgbGlzdCIsIE5VTEwpOwoJICAgIHJldHVybiAoLTEpOwoJfQogICAgfQogICAgdmN0eHQtPmlkY0tleXNbdmN0eHQtPm5iSWRjS2V5cysrXSA9IGtleTsKCiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hSURDQXBwZW5kTm9kZVRhYmxlSXRlbToKICogQGJpbmQ6IHRoZSBJREMgYmluZGluZwogKiBAbnRJdGVtOiB0aGUgbm9kZS10YWJsZSBpdGVtCiAqCiAqIEFwcGVuZHMgdGhlIElEQyBub2RlLXRhYmxlIGl0ZW0gdG8gdGhlIGJpbmRpbmcuCiAqCiAqIFJldHVybnMgMCBvbiBzdWNjZXNzIGFuZCAtMSBvbiBpbnRlcm5hbCBlcnJvcnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUlEQ0FwcGVuZE5vZGVUYWJsZUl0ZW0oeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmdQdHIgYmluZCwKCQkJCXhtbFNjaGVtYVBTVklJRENOb2RlUHRyIG50SXRlbSkKewogICAgaWYgKGJpbmQtPm5vZGVUYWJsZSA9PSBOVUxMKSB7CgliaW5kLT5zaXplTm9kZXMgPSAxMDsKCWJpbmQtPm5vZGVUYWJsZSA9ICh4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciAqKQoJICAgIHhtbE1hbGxvYygxMCAqIHNpemVvZih4bWxTY2hlbWFQU1ZJSURDTm9kZVB0cikpOwoJaWYgKGJpbmQtPm5vZGVUYWJsZSA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hVkVyck1lbW9yeShOVUxMLAoJCSJhbGxvY2F0aW5nIGFuIGFycmF5IG9mIElEQyBub2RlLXRhYmxlIGl0ZW1zIiwgTlVMTCk7CgkgICAgcmV0dXJuKC0xKTsKCX0KICAgIH0gZWxzZSBpZiAoYmluZC0+c2l6ZU5vZGVzIDw9IGJpbmQtPm5iTm9kZXMpIHsKCWJpbmQtPnNpemVOb2RlcyAqPSAyOwoJYmluZC0+bm9kZVRhYmxlID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopCgkgICAgeG1sUmVhbGxvYyhiaW5kLT5ub2RlVGFibGUsIGJpbmQtPnNpemVOb2RlcyAqCgkJc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyKSk7CglpZiAoYmluZC0+bm9kZVRhYmxlID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFWRXJyTWVtb3J5KE5VTEwsCgkJInJlLWFsbG9jYXRpbmcgYW4gYXJyYXkgb2YgSURDIG5vZGUtdGFibGUgaXRlbXMiLCBOVUxMKTsKCSAgICByZXR1cm4oLTEpOwoJfQogICAgfQogICAgYmluZC0+bm9kZVRhYmxlW2JpbmQtPm5iTm9kZXMrK10gPSBudEl0ZW07CiAgICByZXR1cm4oMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFJRENBY3F1aXJlQmluZGluZzoKICogQHZjdHh0OiB0aGUgV1hTIHZhbGlkYXRpb24gY29udGV4dAogKiBAbWF0Y2hlcjogdGhlIElEQyBtYXRjaGVyCiAqCiAqIExvb2tzIHVwIGFuIFBTVkkgSURDIGJpbmRpbmcsIGZvciB0aGUgSURDIGRlZmluaXRpb24gYW5kCiAqIG9mIHRoZSBnaXZlbiBtYXRjaGVyLiBJZiBub25lIGZvdW5kLCBhIG5ldyBvbmUgaXMgY3JlYXRlZAogKiBhbmQgYWRkZWQgdG8gdGhlIElEQyB0YWJsZS4KICoKICogUmV0dXJucyBhbiBJREMgYmluZGluZyBvciBOVUxMIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyB4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0cgp4bWxTY2hlbWFJRENBY3F1aXJlQmluZGluZyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyKQp7CiAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBpZWxlbTsKCiAgICBpZWxlbSA9IHZjdHh0LT5lbGVtSW5mb3NbbWF0Y2hlci0+ZGVwdGhdOwoKICAgIGlmIChpZWxlbS0+aWRjVGFibGUgPT0gTlVMTCkgewoJaWVsZW0tPmlkY1RhYmxlID0geG1sU2NoZW1hSURDTmV3QmluZGluZyhtYXRjaGVyLT5haWRjLT5kZWYpOwoJaWYgKGllbGVtLT5pZGNUYWJsZSA9PSBOVUxMKQoJICAgIHJldHVybiAoTlVMTCk7CglyZXR1cm4oaWVsZW0tPmlkY1RhYmxlKTsKICAgIH0gZWxzZSB7Cgl4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0ciBiaW5kID0gTlVMTDsKCgliaW5kID0gaWVsZW0tPmlkY1RhYmxlOwoJZG8gewoJICAgIGlmIChiaW5kLT5kZWZpbml0aW9uID09IG1hdGNoZXItPmFpZGMtPmRlZikKCQlyZXR1cm4oYmluZCk7CgkgICAgaWYgKGJpbmQtPm5leHQgPT0gTlVMTCkgewoJCWJpbmQtPm5leHQgPSB4bWxTY2hlbWFJRENOZXdCaW5kaW5nKG1hdGNoZXItPmFpZGMtPmRlZik7CgkJaWYgKGJpbmQtPm5leHQgPT0gTlVMTCkKCQkgICAgcmV0dXJuIChOVUxMKTsKCQlyZXR1cm4oYmluZC0+bmV4dCk7CgkgICAgfQoJICAgIGJpbmQgPSBiaW5kLT5uZXh0OwoJfSB3aGlsZSAoYmluZCAhPSBOVUxMKTsKICAgIH0KICAgIHJldHVybiAoTlVMTCk7Cn0KCnN0YXRpYyB4bWxTY2hlbWFJdGVtTGlzdFB0cgp4bWxTY2hlbWFJRENBY3F1aXJlVGFyZ2V0TGlzdCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQgQVRUUklCVVRFX1VOVVNFRCwKCQkJICAgICB4bWxTY2hlbWFJRENNYXRjaGVyUHRyIG1hdGNoZXIpCnsKICAgIGlmIChtYXRjaGVyLT50YXJnZXRzID09IE5VTEwpCgltYXRjaGVyLT50YXJnZXRzID0geG1sU2NoZW1hSXRlbUxpc3RDcmVhdGUoKTsKICAgIHJldHVybihtYXRjaGVyLT50YXJnZXRzKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUlEQ0ZyZWVLZXk6CiAqIEBrZXk6IHRoZSBJREMga2V5CiAqCiAqIEZyZWVzIGFuIElEQyBrZXkgdG9nZXRoZXIgd2l0aCBpdHMgY29tcGlsZWQgdmFsdWUuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFJRENGcmVlS2V5KHhtbFNjaGVtYVBTVklJRENLZXlQdHIga2V5KQp7CiAgICBpZiAoa2V5LT52YWwgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVWYWx1ZShrZXktPnZhbCk7CiAgICB4bWxGcmVlKGtleSk7Cn0KCi8qKgogKiB4bWxTY2hlbWFJRENGcmVlQmluZGluZzoKICoKICogRnJlZXMgYW4gSURDIGJpbmRpbmcuIE5vdGUgdGhhdCB0aGUgbm9kZSB0YWJsZS1pdGVtcwogKiBhcmUgbm90IGZyZWVkLgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hSURDRnJlZUJpbmRpbmcoeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmdQdHIgYmluZCkKewogICAgaWYgKGJpbmQtPm5vZGVUYWJsZSAhPSBOVUxMKQoJeG1sRnJlZShiaW5kLT5ub2RlVGFibGUpOwogICAgaWYgKGJpbmQtPmR1cGxzICE9IE5VTEwpCgl4bWxTY2hlbWFJdGVtTGlzdEZyZWUoYmluZC0+ZHVwbHMpOwkKICAgIHhtbEZyZWUoYmluZCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFJRENGcmVlSURDVGFibGU6CiAqIEBiaW5kOiB0aGUgZmlyc3QgSURDIGJpbmRpbmcgaW4gdGhlIGxpc3QKICoKICogRnJlZXMgYW4gSURDIHRhYmxlLCBpLmUuIGFsbCB0aGUgSURDIGJpbmRpbmdzIGluIHRoZSBsaXN0LgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hSURDRnJlZUlEQ1RhYmxlKHhtbFNjaGVtYVBTVklJRENCaW5kaW5nUHRyIGJpbmQpCnsKICAgIHhtbFNjaGVtYVBTVklJRENCaW5kaW5nUHRyIHByZXY7CgogICAgd2hpbGUgKGJpbmQgIT0gTlVMTCkgewoJcHJldiA9IGJpbmQ7CgliaW5kID0gYmluZC0+bmV4dDsKCXhtbFNjaGVtYUlEQ0ZyZWVCaW5kaW5nKHByZXYpOwogICAgfQp9CgovKioKICogeG1sU2NoZW1hSURDRnJlZU1hdGNoZXJMaXN0OgogKiBAbWF0Y2hlcjogdGhlIGZpcnN0IElEQyBtYXRjaGVyIGluIHRoZSBsaXN0CiAqCiAqIEZyZWVzIGEgbGlzdCBvZiBJREMgbWF0Y2hlcnMuCiAqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFJRENGcmVlTWF0Y2hlckxpc3QoeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyKQp7CiAgICB4bWxTY2hlbWFJRENNYXRjaGVyUHRyIG5leHQ7CgogICAgd2hpbGUgKG1hdGNoZXIgIT0gTlVMTCkgewoJbmV4dCA9IG1hdGNoZXItPm5leHQ7CglpZiAobWF0Y2hlci0+a2V5U2VxcyAhPSBOVUxMKSB7CgkgICAgaW50IGk7CgkgICAgZm9yIChpID0gMDsgaSA8IG1hdGNoZXItPnNpemVLZXlTZXFzOyBpKyspCgkJaWYgKG1hdGNoZXItPmtleVNlcXNbaV0gIT0gTlVMTCkKCQkgICAgeG1sRnJlZShtYXRjaGVyLT5rZXlTZXFzW2ldKTsKCSAgICB4bWxGcmVlKG1hdGNoZXItPmtleVNlcXMpOwkgICAgCgl9CglpZiAobWF0Y2hlci0+dGFyZ2V0cyAhPSBOVUxMKSB7CgkgICAgaWYgKG1hdGNoZXItPmlkY1R5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUYpIHsKCQlpbnQgaTsKCQl4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciBpZGNOb2RlOwoJCS8qCgkJKiBOb2RlLXRhYmxlIGl0ZW1zIGZvciBrZXlyZWZzIGFyZSBub3Qgc3RvcmVkIGdsb2JhbGx5CgkJKiB0byB0aGUgdmFsaWRhdGlvbiBjb250ZXh0LCBzaW5jZSB0aGV5IGFyZSBub3QgYnViYmxlZC4KCQkqIFdlIG5lZWQgdG8gZnJlZSB0aGVtIGhlcmUuCgkJKi8KCQlmb3IgKGkgPSAwOyBpIDwgbWF0Y2hlci0+dGFyZ2V0cy0+bmJJdGVtczsgaSsrKSB7CgkJICAgIGlkY05vZGUgPQoJCQkoeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIpIG1hdGNoZXItPnRhcmdldHMtPml0ZW1zW2ldOwoJCSAgICB4bWxGcmVlKGlkY05vZGUtPmtleXMpOwoJCSAgICB4bWxGcmVlKGlkY05vZGUpOwoJCX0KCSAgICB9CgkgICAgeG1sU2NoZW1hSXRlbUxpc3RGcmVlKG1hdGNoZXItPnRhcmdldHMpOwoJfQoJeG1sRnJlZShtYXRjaGVyKTsKCW1hdGNoZXIgPSBuZXh0OwogICAgfQp9CgovKioKICogeG1sU2NoZW1hSURDQWRkU3RhdGVPYmplY3Q6CiAqIEB2Y3R4dDogdGhlIFdYUyB2YWxpZGF0aW9uIGNvbnRleHQKICogQG1hdGNoZXI6IHRoZSBJREMgbWF0Y2hlcgogKiBAc2VsOiB0aGUgWFBhdGggaW5mb3JtYXRpb24KICogQHBhcmVudDogdGhlIHBhcmVudCAic2VsZWN0b3IiIHN0YXRlIG9iamVjdCBpZiBhbnkKICogQHR5cGU6ICJzZWxlY3RvciIgb3IgImZpZWxkIgogKgogKiBDcmVhdGVzL3JldXNlcyBhbmQgYWN0aXZhdGVzIHN0YXRlIG9iamVjdHMgZm9yIHRoZSBnaXZlbgogKiBYUGF0aCBpbmZvcm1hdGlvbjsgaWYgdGhlIFhQYXRoIGV4cHJlc3Npb24gY29uc2lzdHMgb2YgdW5pb25zLAogKiBtdWx0aXBsZSBzdGF0ZSBvYmplY3RzIGFyZSBjcmVhdGVkIGZvciBldmVyeSB1bmlvbmVkIGV4cHJlc3Npb24uCiAqCiAqIFJldHVybnMgMCBvbiBzdWNjZXNzIGFuZCAtMSBvbiBpbnRlcm5hbCBlcnJvcnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUlEQ0FkZFN0YXRlT2JqZWN0KHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyLAoJCQl4bWxTY2hlbWFJRENTZWxlY3RQdHIgc2VsLAoJCQlpbnQgdHlwZSkKewogICAgeG1sU2NoZW1hSURDU3RhdGVPYmpQdHIgc3RvOwoKICAgIC8qCiAgICAqIFJldXNlIHRoZSBzdGF0ZSBvYmplY3RzIGZyb20gdGhlIHBvb2wuCiAgICAqLwogICAgaWYgKHZjdHh0LT54cGF0aFN0YXRlUG9vbCAhPSBOVUxMKSB7CglzdG8gPSB2Y3R4dC0+eHBhdGhTdGF0ZVBvb2w7Cgl2Y3R4dC0+eHBhdGhTdGF0ZVBvb2wgPSBzdG8tPm5leHQ7CglzdG8tPm5leHQgPSBOVUxMOwogICAgfSBlbHNlIHsJCgkvKgoJKiBDcmVhdGUgYSBuZXcgc3RhdGUgb2JqZWN0LgoJKi8KCXN0byA9ICh4bWxTY2hlbWFJRENTdGF0ZU9ialB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFJRENTdGF0ZU9iaikpOwoJaWYgKHN0byA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hVkVyck1lbW9yeShOVUxMLAoJCSJhbGxvY2F0aW5nIGFuIElEQyBzdGF0ZSBvYmplY3QiLCBOVUxMKTsKCSAgICByZXR1cm4gKC0xKTsKCX0KCW1lbXNldChzdG8sIDAsIHNpemVvZih4bWxTY2hlbWFJRENTdGF0ZU9iaikpOwogICAgfQkKICAgIC8qCiAgICAqIEFkZCB0byBnbG9iYWwgbGlzdC4gCiAgICAqLwkKICAgIGlmICh2Y3R4dC0+eHBhdGhTdGF0ZXMgIT0gTlVMTCkKCXN0by0+bmV4dCA9IHZjdHh0LT54cGF0aFN0YXRlczsKICAgIHZjdHh0LT54cGF0aFN0YXRlcyA9IHN0bzsKCiAgICAvKgogICAgKiBGcmVlIHRoZSBvbGQgeHBhdGggdmFsaWRhdGlvbiBjb250ZXh0LgogICAgKi8KICAgIGlmIChzdG8tPnhwYXRoQ3R4dCAhPSBOVUxMKQoJeG1sRnJlZVN0cmVhbUN0eHQoKHhtbFN0cmVhbUN0eHRQdHIpIHN0by0+eHBhdGhDdHh0KTsKCiAgICAvKgogICAgKiBDcmVhdGUgYSBuZXcgWFBhdGggKHBhdHRlcm4pIHZhbGlkYXRpb24gY29udGV4dC4KICAgICovCiAgICBzdG8tPnhwYXRoQ3R4dCA9ICh2b2lkICopIHhtbFBhdHRlcm5HZXRTdHJlYW1DdHh0KAoJKHhtbFBhdHRlcm5QdHIpIHNlbC0+eHBhdGhDb21wKTsKICAgIGlmIChzdG8tPnhwYXRoQ3R4dCA9PSBOVUxMKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFJRENBZGRTdGF0ZU9iamVjdCIsCgkgICAgImZhaWxlZCB0byBjcmVhdGUgYW4gWFBhdGggdmFsaWRhdGlvbiBjb250ZXh0Iik7CglyZXR1cm4gKC0xKTsKICAgIH0gICAgCiAgICBzdG8tPnR5cGUgPSB0eXBlOwogICAgc3RvLT5kZXB0aCA9IHZjdHh0LT5kZXB0aDsKICAgIHN0by0+bWF0Y2hlciA9IG1hdGNoZXI7CiAgICBzdG8tPnNlbCA9IHNlbDsKICAgIHN0by0+bmJIaXN0b3J5ID0gMDsKICAgIAojaWZkZWYgREVCVUdfSURDCiAgICB4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgIklEQzogICBTVE8gcHVzaCAnJXMnXG4iLAoJc3RvLT5zZWwtPnhwYXRoKTsKI2VuZGlmCiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hWFBhdGhFdmFsdWF0ZToKICogQHZjdHh0OiB0aGUgV1hTIHZhbGlkYXRpb24gY29udGV4dAogKiBAbm9kZVR5cGU6IHRoZSBub2RlVHlwZSBvZiB0aGUgY3VycmVudCBub2RlCiAqCiAqIEV2YWx1YXRlcyBhbGwgYWN0aXZlIFhQYXRoIHN0YXRlIG9iamVjdHMuCiAqCiAqIFJldHVybnMgdGhlIG51bWJlciBvZiBJQyAiZmllbGQiIHN0YXRlIG9iamVjdHMgd2hpY2ggcmVzb2x2ZWQgdG8KICogdGhpcyBub2RlLCAwIGlmIG5vbmUgcmVzb2x2ZWQgYW5kIC0xIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hWFBhdGhFdmFsdWF0ZSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJICAgICAgIHhtbEVsZW1lbnRUeXBlIG5vZGVUeXBlKQp7CiAgICB4bWxTY2hlbWFJRENTdGF0ZU9ialB0ciBzdG8sIGhlYWQgPSBOVUxMLCBmaXJzdDsKICAgIGludCByZXMsIHJlc29sdmVkID0gMCwgZGVwdGggPSB2Y3R4dC0+ZGVwdGg7CiAgICAgICAgCiAgICBpZiAodmN0eHQtPnhwYXRoU3RhdGVzID09IE5VTEwpCglyZXR1cm4gKDApOwoKICAgIGlmIChub2RlVHlwZSA9PSBYTUxfQVRUUklCVVRFX05PREUpCglkZXB0aCsrOwojaWZkZWYgREVCVUdfSURDCiAgICB7Cgl4bWxDaGFyICpzdHIgPSBOVUxMOwoJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsIAoJICAgICJJREM6IEVWQUwgb24gJXMsIGRlcHRoICVkLCB0eXBlICVkXG4iLAkgICAgCgkgICAgeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwgdmN0eHQtPmlub2RlLT5uc05hbWUsCgkJdmN0eHQtPmlub2RlLT5sb2NhbE5hbWUpLCBkZXB0aCwgbm9kZVR5cGUpOwoJRlJFRV9BTkRfTlVMTChzdHIpCiAgICB9CiNlbmRpZgogICAgLyoKICAgICogUHJvY2VzcyBhbGwgYWN0aXZlIFhQYXRoIHN0YXRlIG9iamVjdHMuCiAgICAqLwogICAgZmlyc3QgPSB2Y3R4dC0+eHBhdGhTdGF0ZXM7CiAgICBzdG8gPSBmaXJzdDsKICAgIHdoaWxlIChzdG8gIT0gaGVhZCkgewojaWZkZWYgREVCVUdfSURDCglpZiAoc3RvLT50eXBlID09IFhQQVRIX1NUQVRFX09CSl9UWVBFX0lEQ19TRUxFQ1RPUikKCSAgICB4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgIklEQzogICBbJyVzJ10gc2VsZWN0b3IgJyVzJ1xuIiwgCgkJc3RvLT5tYXRjaGVyLT5haWRjLT5kZWYtPm5hbWUsIHN0by0+c2VsLT54cGF0aCk7CgllbHNlCgkgICAgeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsICJJREM6ICAgWyclcyddIGZpZWxkICclcydcbiIsIAoJCXN0by0+bWF0Y2hlci0+YWlkYy0+ZGVmLT5uYW1lLCBzdG8tPnNlbC0+eHBhdGgpOwojZW5kaWYKCWlmIChub2RlVHlwZSA9PSBYTUxfRUxFTUVOVF9OT0RFKQoJICAgIHJlcyA9IHhtbFN0cmVhbVB1c2goKHhtbFN0cmVhbUN0eHRQdHIpIHN0by0+eHBhdGhDdHh0LAoJCXZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lLCB2Y3R4dC0+aW5vZGUtPm5zTmFtZSk7CgllbHNlCgkgICAgcmVzID0geG1sU3RyZWFtUHVzaEF0dHIoKHhtbFN0cmVhbUN0eHRQdHIpIHN0by0+eHBhdGhDdHh0LAoJCXZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lLCB2Y3R4dC0+aW5vZGUtPm5zTmFtZSk7CgoJaWYgKHJlcyA9PSAtMSkgewoJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVhQYXRoRXZhbHVhdGUiLAoJCSJjYWxsaW5nIHhtbFN0cmVhbVB1c2goKSIpOwoJICAgIHJldHVybiAoLTEpOwoJfQoJaWYgKHJlcyA9PSAwKQoJICAgIGdvdG8gbmV4dF9zdG87CgkvKgoJKiBGdWxsIG1hdGNoLgoJKi8KI2lmZGVmIERFQlVHX0lEQwoJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsICJJREM6ICAgICAiCgkgICAgIk1BVENIXG4iKTsKI2VuZGlmCgkvKgoJKiBSZWdpc3RlciBhIG1hdGNoIGluIHRoZSBzdGF0ZSBvYmplY3QgaGlzdG9yeS4KCSovCglpZiAoc3RvLT5oaXN0b3J5ID09IE5VTEwpIHsKCSAgICBzdG8tPmhpc3RvcnkgPSAoaW50ICopIHhtbE1hbGxvYyg1ICogc2l6ZW9mKGludCkpOwoJICAgIGlmIChzdG8tPmhpc3RvcnkgPT0gTlVMTCkgewoJCXhtbFNjaGVtYVZFcnJNZW1vcnkoTlVMTCwgCgkJICAgICJhbGxvY2F0aW5nIHRoZSBzdGF0ZSBvYmplY3QgaGlzdG9yeSIsIE5VTEwpOwoJCXJldHVybigtMSk7CgkgICAgfQoJICAgIHN0by0+c2l6ZUhpc3RvcnkgPSAxMDsKCX0gZWxzZSBpZiAoc3RvLT5zaXplSGlzdG9yeSA8PSBzdG8tPm5iSGlzdG9yeSkgewoJICAgIHN0by0+c2l6ZUhpc3RvcnkgKj0gMjsKCSAgICBzdG8tPmhpc3RvcnkgPSAoaW50ICopIHhtbFJlYWxsb2Moc3RvLT5oaXN0b3J5LAoJCXN0by0+c2l6ZUhpc3RvcnkgKiBzaXplb2YoaW50KSk7CgkgICAgaWYgKHN0by0+aGlzdG9yeSA9PSBOVUxMKSB7CgkJeG1sU2NoZW1hVkVyck1lbW9yeShOVUxMLCAKCQkgICAgInJlLWFsbG9jYXRpbmcgdGhlIHN0YXRlIG9iamVjdCBoaXN0b3J5IiwgTlVMTCk7CgkJcmV0dXJuKC0xKTsKCSAgICB9Cgl9CQkKCXN0by0+aGlzdG9yeVtzdG8tPm5iSGlzdG9yeSsrXSA9IGRlcHRoOwoKI2lmZGVmIERFQlVHX0lEQwoJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsICJJREM6ICAgICAgIHB1c2ggbWF0Y2ggJyVkJ1xuIiwKCSAgICB2Y3R4dC0+ZGVwdGgpOwojZW5kaWYKCglpZiAoc3RvLT50eXBlID09IFhQQVRIX1NUQVRFX09CSl9UWVBFX0lEQ19TRUxFQ1RPUikgewoJICAgIHhtbFNjaGVtYUlEQ1NlbGVjdFB0ciBzZWw7CgkgICAgLyoKCSAgICAqIEFjdGl2YXRlIHN0YXRlIG9iamVjdHMgZm9yIHRoZSBJREMgZmllbGRzIG9mCgkgICAgKiB0aGUgSURDIHNlbGVjdG9yLgoJICAgICovCiNpZmRlZiBERUJVR19JREMKCSAgICB4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgIklEQzogICAgICIKCQkiYWN0aXZhdGluZyBmaWVsZCBzdGF0ZXNcbiIpOwojZW5kaWYKCSAgICBzZWwgPSBzdG8tPm1hdGNoZXItPmFpZGMtPmRlZi0+ZmllbGRzOwoJICAgIHdoaWxlIChzZWwgIT0gTlVMTCkgewoJCWlmICh4bWxTY2hlbWFJRENBZGRTdGF0ZU9iamVjdCh2Y3R4dCwgc3RvLT5tYXRjaGVyLAoJCSAgICBzZWwsIFhQQVRIX1NUQVRFX09CSl9UWVBFX0lEQ19GSUVMRCkgPT0gLTEpCgkJICAgIHJldHVybiAoLTEpOwoJCXNlbCA9IHNlbC0+bmV4dDsKCSAgICB9Cgl9IGVsc2UgaWYgKHN0by0+dHlwZSA9PSBYUEFUSF9TVEFURV9PQkpfVFlQRV9JRENfRklFTEQpIHsKCSAgICAvKgoJICAgICogQW4gSURDIGtleSBub2RlIHdhcyBmb3VuZCBieSB0aGUgSURDIGZpZWxkLgoJICAgICovCiNpZmRlZiBERUJVR19JREMKCSAgICB4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwKCQkiSURDOiAgICAga2V5IGZvdW5kXG4iKTsKI2VuZGlmCgkgICAgLyoKCSAgICAqIE5vdGlmeSB0aGF0IHRoZSBjaGFyYWN0ZXIgdmFsdWUgb2YgdGhpcyBub2RlIGlzCgkgICAgKiBuZWVkZWQuCgkgICAgKi8KCSAgICBpZiAocmVzb2x2ZWQgPT0gMCkgewoJCWlmICgodmN0eHQtPmlub2RlLT5mbGFncyAmCgkJICAgIFhNTF9TQ0hFTUFfTk9ERV9JTkZPX1ZBTFVFX05FRURFRCkgPT0gMCkKCQl2Y3R4dC0+aW5vZGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfTk9ERV9JTkZPX1ZBTFVFX05FRURFRDsKCSAgICB9CgkgICAgcmVzb2x2ZWQrKzsKCX0KbmV4dF9zdG86CglpZiAoc3RvLT5uZXh0ID09IE5VTEwpIHsKCSAgICAvKgoJICAgICogRXZhbHVhdGUgZmllbGQgc3RhdGUgb2JqZWN0cyBjcmVhdGVkIG9uIHRoaXMgbm9kZSBhcyB3ZWxsLgoJICAgICovCgkgICAgaGVhZCA9IGZpcnN0OwoJICAgIHN0byA9IHZjdHh0LT54cGF0aFN0YXRlczsKCX0gZWxzZQoJICAgIHN0byA9IHN0by0+bmV4dDsKICAgIH0KICAgIHJldHVybiAocmVzb2x2ZWQpOwp9CgpzdGF0aWMgY29uc3QgeG1sQ2hhciAqCnhtbFNjaGVtYUZvcm1hdElEQ0tleVNlcXVlbmNlKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJICAgICAgeG1sQ2hhciAqKmJ1ZiwKCQkJICAgICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciAqc2VxLAoJCQkgICAgICBpbnQgY291bnQpCnsKICAgIGludCBpLCByZXM7CiAgICB4bWxDaGFyICp2YWx1ZSA9IE5VTEw7CgogICAgKmJ1ZiA9IHhtbFN0cmR1cChCQURfQ0FTVCAiWyIpOwogICAgZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKCSpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIiciKTsKCXJlcyA9IHhtbFNjaGVtYUdldENhbm9uVmFsdWVXaHRzcEV4dChzZXFbaV0tPnZhbCwgCgkgICAgeG1sU2NoZW1hR2V0V2hpdGVTcGFjZUZhY2V0VmFsdWUoc2VxW2ldLT50eXBlKSwKCSAgICAmdmFsdWUpOwoJaWYgKHJlcyA9PSAwKQoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgdmFsdWUpOwoJZWxzZSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hRm9ybWF0SURDS2V5U2VxdWVuY2UiLAoJCSJmYWlsZWQgdG8gY29tcHV0ZSBhIGNhbm9uaWNhbCB2YWx1ZSIpOwoJICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIj8/PyIpOwoJfQoJaWYgKGkgPCBjb3VudCAtMSkKCSAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICInLCAiKTsKCWVsc2UKCSAgICAqYnVmID0geG1sU3RyY2F0KCpidWYsIEJBRF9DQVNUICInIik7CglpZiAodmFsdWUgIT0gTlVMTCkgewoJICAgIHhtbEZyZWUodmFsdWUpOwoJICAgIHZhbHVlID0gTlVMTDsKCX0KICAgIH0KICAgICpidWYgPSB4bWxTdHJjYXQoKmJ1ZiwgQkFEX0NBU1QgIl0iKTsKCiAgICByZXR1cm4gKEJBRF9DQVNUICpidWYpOwp9CgovKioKICogeG1sU2NoZW1hWFBhdGhQb3A6CiAqIEB2Y3R4dDogdGhlIFdYUyB2YWxpZGF0aW9uIGNvbnRleHQKICoKICogUG9wcyBhbGwgWFBhdGggc3RhdGVzLgogKgogKiBSZXR1cm5zIDAgb24gc3VjY2VzcyBhbmQgLTEgb24gaW50ZXJuYWwgZXJyb3JzLgogKi8Kc3RhdGljIGludAp4bWxTY2hlbWFYUGF0aFBvcCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpCnsKICAgIHhtbFNjaGVtYUlEQ1N0YXRlT2JqUHRyIHN0bzsKICAgIGludCByZXM7CgogICAgaWYgKHZjdHh0LT54cGF0aFN0YXRlcyA9PSBOVUxMKQoJcmV0dXJuKDApOwogICAgc3RvID0gdmN0eHQtPnhwYXRoU3RhdGVzOwogICAgZG8gewoJcmVzID0geG1sU3RyZWFtUG9wKCh4bWxTdHJlYW1DdHh0UHRyKSBzdG8tPnhwYXRoQ3R4dCk7CglpZiAocmVzID09IC0xKQoJICAgIHJldHVybiAoLTEpOwoJc3RvID0gc3RvLT5uZXh0OwogICAgfSB3aGlsZSAoc3RvICE9IE5VTEwpOwogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hWFBhdGhQcm9jZXNzSGlzdG9yeToKICogQHZjdHh0OiB0aGUgV1hTIHZhbGlkYXRpb24gY29udGV4dAogKiBAdHlwZTogdGhlIHNpbXBsZS9jb21wbGV4IHR5cGUgb2YgdGhlIGN1cnJlbnQgbm9kZSBpZiBhbnkgYXQgYWxsCiAqIEB2YWw6IHRoZSBwcmVjb21waWxlZCB2YWx1ZQogKgogKiBQcm9jZXNzZXMgYW5kIHBvcHMgdGhlIGhpc3RvcnkgaXRlbXMgb2YgdGhlIElEQyBzdGF0ZSBvYmplY3RzLgogKiBJREMga2V5LXNlcXVlbmNlcyBhcmUgdmFsaWRhdGVkL2NyZWF0ZWQgb24gSURDIGJpbmRpbmdzLgogKiAKICogUmV0dXJucyAwIG9uIHN1Y2Nlc3MgYW5kIC0xIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hWFBhdGhQcm9jZXNzSGlzdG9yeSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgICAgaW50IGRlcHRoKQp7CiAgICB4bWxTY2hlbWFJRENTdGF0ZU9ialB0ciBzdG8sIG5leHRzdG87CiAgICBpbnQgcmVzLCBtYXRjaERlcHRoOwogICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciBrZXkgPSBOVUxMOwogICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlID0gdmN0eHQtPmlub2RlLT50eXBlRGVmLCBzaW1wbGVUeXBlID0gTlVMTDsKCiAgICBpZiAodmN0eHQtPnhwYXRoU3RhdGVzID09IE5VTEwpCglyZXR1cm4gKDApOwogICAgc3RvID0gdmN0eHQtPnhwYXRoU3RhdGVzOwoKI2lmZGVmIERFQlVHX0lEQwogICAgewoJeG1sQ2hhciAqc3RyID0gTlVMTDsKCXhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LCAKCSAgICAiSURDOiBCQUNLIG9uICVzLCBkZXB0aCAlZFxuIiwKCSAgICB4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLCB2Y3R4dC0+aW5vZGUtPm5zTmFtZSwKCQl2Y3R4dC0+aW5vZGUtPmxvY2FsTmFtZSksIHZjdHh0LT5kZXB0aCk7CglGUkVFX0FORF9OVUxMKHN0cikKICAgIH0KI2VuZGlmICAgIAogICAgLyoKICAgICogRXZhbHVhdGUgdGhlIHN0YXRlIG9iamVjdHMuCiAgICAqLwogICAgd2hpbGUgKHN0byAhPSBOVUxMKSB7CglyZXMgPSB4bWxTdHJlYW1Qb3AoKHhtbFN0cmVhbUN0eHRQdHIpIHN0by0+eHBhdGhDdHh0KTsKCWlmIChyZXMgPT0gLTEpIHsKCSAgICBWRVJST1JfSU5UKCJ4bWxTY2hlbWFYUGF0aFByb2Nlc3NIaXN0b3J5IiwKCQkiY2FsbGluZyB4bWxTdHJlYW1Qb3AoKSIpOwoJICAgIHJldHVybiAoLTEpOwoJfQojaWZkZWYgREVCVUdfSURDCgl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgIklEQzogICBzdHJlYW0gcG9wICclcydcbiIsCgkgICAgc3RvLT5zZWwtPnhwYXRoKTsKI2VuZGlmCglpZiAoc3RvLT5uYkhpc3RvcnkgPT0gMCkKCSAgICBnb3RvIGRlcmVnaXN0ZXJfY2hlY2s7CgoJbWF0Y2hEZXB0aCA9IHN0by0+aGlzdG9yeVtzdG8tPm5iSGlzdG9yeSAtMV07CgoJLyoKCSogT25seSBtYXRjaGVzIGF0IHRoZSBjdXJyZW50IGRlcHRoIGFyZSBvZiBpbnRlcmVzdC4KCSovCglpZiAobWF0Y2hEZXB0aCAhPSBkZXB0aCkgewoJICAgIHN0byA9IHN0by0+bmV4dDsKCSAgICBjb250aW51ZTsKCX0JCglpZiAoc3RvLT50eXBlID09IFhQQVRIX1NUQVRFX09CSl9UWVBFX0lEQ19GSUVMRCkgewoJICAgIC8qCgkgICAgKiBOT1RFOiBBY2NvcmRpbmcgdG8KCSAgICAqICAgaHR0cDovL3d3dy53My5vcmcvQnVncy9QdWJsaWMvc2hvd19idWcuY2dpP2lkPTIxOTgKCSAgICAqICAgLi4uIHRoZSBzaW1wbGUtY29udGVudCBvZiBjb21wbGV4IHR5cGVzIGlzIGFsc28gYWxsb3dlZC4KCSAgICAqLwoJICAgIAoJICAgIGlmIChXWFNfSVNfQ09NUExFWCh0eXBlKSkgewoJCWlmIChXWFNfSEFTX1NJTVBMRV9DT05URU5UKHR5cGUpKSB7CgkJICAgIC8qCgkJICAgICogU2FuaXR5IGNoZWNrIGZvciBjb21wbGV4IHR5cGVzIHdpdGggc2ltcGxlIGNvbnRlbnQuCgkJICAgICovCgkJICAgIHNpbXBsZVR5cGUgPSB0eXBlLT5jb250ZW50VHlwZURlZjsKCQkgICAgaWYgKHNpbXBsZVR5cGUgPT0gTlVMTCkgewoJCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFYUGF0aFByb2Nlc3NIaXN0b3J5IiwKCQkJICAgICJmaWVsZCByZXNvbHZlcyB0byBhIENUIHdpdGggc2ltcGxlIGNvbnRlbnQgIgoJCQkgICAgImJ1dCB0aGUgQ1QgaXMgbWlzc2luZyB0aGUgU1QgZGVmaW5pdGlvbiIpOwoJCQlyZXR1cm4gKC0xKTsKCQkgICAgfQoJCX0gZWxzZQoJCSAgICBzaW1wbGVUeXBlID0gTlVMTDsKCSAgICB9IGVsc2UgCgkJc2ltcGxlVHlwZSA9IHR5cGU7CgkgICAgaWYgKHNpbXBsZVR5cGUgPT0gTlVMTCkgewoJCXhtbENoYXIgKnN0ciA9IE5VTEw7CgkKCQkvKgoJCSogTm90IHF1YWxpZmllZCBpZiB0aGUgZmllbGQgcmVzb2x2ZXMgdG8gYSBub2RlIG9mIG5vbgoJCSogc2ltcGxlIHR5cGUuCgkJKi8JCgkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJICAgIFhNTF9TQ0hFTUFWX0NWQ19JREMsIE5VTEwsCQkgICAgCgkJICAgIFdYU19CQVNJQ19DQVNUIHN0by0+bWF0Y2hlci0+YWlkYy0+ZGVmLAoJCSAgICAiVGhlIFhQYXRoICclcycgb2YgYSBmaWVsZCBvZiAlcyBkb2VzIGV2YWx1YXRlIHRvIGEgbm9kZSBvZiAiCgkJICAgICJub24tc2ltcGxlIHR5cGUiLAoJCSAgICBzdG8tPnNlbC0+eHBhdGgsCgkJICAgIHhtbFNjaGVtYUdldElEQ0Rlc2lnbmF0aW9uKCZzdHIsIHN0by0+bWF0Y2hlci0+YWlkYy0+ZGVmKSk7CgkJRlJFRV9BTkRfTlVMTChzdHIpOwoJCXN0by0+bmJIaXN0b3J5LS07CgkJZ290byBkZXJlZ2lzdGVyX2NoZWNrOwoJICAgIH0KCSAgICAKCSAgICBpZiAoKGtleSA9PSBOVUxMKSAmJiAodmN0eHQtPmlub2RlLT52YWwgPT0gTlVMTCkpIHsKCQkvKgoJCSogRmFpbGVkIHRvIHByb3ZpZGUgdGhlIG5vcm1hbGl6ZWQgdmFsdWU7IG1heWJlCgkJKiB0aGUgdmFsdWUgd2FzIGludmFsaWQuCgkJKi8KCQlWRVJST1IoWE1MX1NDSEVNQVZfQ1ZDX0lEQywKCQkgICAgV1hTX0JBU0lDX0NBU1Qgc3RvLT5tYXRjaGVyLT5haWRjLT5kZWYsCgkJICAgICJXYXJuaW5nOiBObyBwcmVjb21wdXRlZCB2YWx1ZSBhdmFpbGFibGUsIHRoZSB2YWx1ZSAiCgkJICAgICJ3YXMgZWl0aGVyIGludmFsaWQgb3Igc29tZXRoaW5nIHN0cmFuZ2UgaGFwcGVuZCIpOwoJCXN0by0+bmJIaXN0b3J5LS07CgkJZ290byBkZXJlZ2lzdGVyX2NoZWNrOwoJICAgIH0gZWxzZSB7CgkJeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyID0gc3RvLT5tYXRjaGVyOwoJCXhtbFNjaGVtYVBTVklJRENLZXlQdHIgKmtleVNlcTsKCQlpbnQgcG9zLCBpZHg7CgkJCgkJLyoKCQkqIFRoZSBrZXkgd2lsbCBiZSBhbmNob3JlZCBvbiB0aGUgbWF0Y2hlcidzIGxpc3Qgb2YKCQkqIGtleS1zZXF1ZW5jZXMuIFRoZSBwb3NpdGlvbiBpbiB0aGlzIGxpc3QgaXMgZGV0ZXJtaW5lZAoJCSogYnkgdGhlIHRhcmdldCBub2RlJ3MgZGVwdGggcmVsYXRpdmUgdG8gdGhlIG1hdGNoZXIncwoJCSogZGVwdGggb2YgY3JlYXRpb24gKGkuZS4gdGhlIGRlcHRoIG9mIHRoZSBzY29wZSBlbGVtZW50KS4KCQkqIAoJCSogRWxlbWVudCAgICAgICAgRGVwdGggICAgUG9zICAgTGlzdC1lbnRyaWVzCgkJKiA8c2NvcGU+ICAgICAgICAgIDAgICAgICAgICAgICAgIE5VTEwKCQkqICAgPGJhcj4gICAgICAgICAgMSAgICAgICAgICAgICAgTlVMTAoJCSogICAgIDx0YXJnZXQvPiAgICAyICAgICAgIDIgICAgICB0YXJnZXQKCQkqICAgPGJhcj4KICAgICAgICAgICAgICAgICogPC9zY29wZT4KCQkqCgkJKiBUaGUgc2l6ZSBvZiB0aGUgbGlzdCBpcyBvbmx5IGRlcGVuZGFudCBvbiB0aGUgZGVwdGggb2YKCQkqIHRoZSB0cmVlLgoJCSogQW4gZW50cnkgd2lsbCBiZSBOVUxMZWQgaW4gc2VsZWN0b3JfbGVhdmUsIGkuZS4gd2hlbgoJCSogd2UgaGl0IHRoZSB0YXJnZXQncyAKCQkqLwkJICAgIAoJCXBvcyA9IHN0by0+ZGVwdGggLSBtYXRjaGVyLT5kZXB0aDsKCQlpZHggPSBzdG8tPnNlbC0+aW5kZXg7CgkJCgkJLyoKCQkqIENyZWF0ZS9ncm93IHRoZSBhcnJheSBvZiBrZXktc2VxdWVuY2VzLgoJCSovCgkJaWYgKG1hdGNoZXItPmtleVNlcXMgPT0gTlVMTCkgewoJCSAgICBpZiAocG9zID4gOSkgCgkJCW1hdGNoZXItPnNpemVLZXlTZXFzID0gcG9zICogMjsKCQkgICAgZWxzZQoJCQltYXRjaGVyLT5zaXplS2V5U2VxcyA9IDEwOwoJCSAgICBtYXRjaGVyLT5rZXlTZXFzID0gKHhtbFNjaGVtYVBTVklJRENLZXlQdHIgKiopIAoJCQl4bWxNYWxsb2MobWF0Y2hlci0+c2l6ZUtleVNlcXMgKgoJCQlzaXplb2YoeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciAqKSk7CQkJCgkJICAgIGlmIChtYXRjaGVyLT5rZXlTZXFzID09IE5VTEwpIHsJCQoJCQl4bWxTY2hlbWFWRXJyTWVtb3J5KE5VTEwsCgkJCSAgICAiYWxsb2NhdGluZyBhbiBhcnJheSBvZiBrZXktc2VxdWVuY2VzIiwKCQkJICAgIE5VTEwpOwoJCQlyZXR1cm4oLTEpOwoJCSAgICB9CgkJICAgIG1lbXNldChtYXRjaGVyLT5rZXlTZXFzLCAwLAoJCQltYXRjaGVyLT5zaXplS2V5U2VxcyAqCgkJCXNpemVvZih4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICopKTsKCQl9IGVsc2UgaWYgKHBvcyA+PSBtYXRjaGVyLT5zaXplS2V5U2VxcykgewkKCQkgICAgaW50IGkgPSBtYXRjaGVyLT5zaXplS2V5U2VxczsKCQkgICAgCgkJICAgIG1hdGNoZXItPnNpemVLZXlTZXFzICo9IDI7CgkJICAgIG1hdGNoZXItPmtleVNlcXMgPSAoeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciAqKikKCQkJeG1sUmVhbGxvYyhtYXRjaGVyLT5rZXlTZXFzLAoJCQltYXRjaGVyLT5zaXplS2V5U2VxcyAqCgkJCXNpemVvZih4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICopKTsKCQkgICAgaWYgKG1hdGNoZXItPmtleVNlcXMgPT0gTlVMTCkgewoJCQl4bWxTY2hlbWFWRXJyTWVtb3J5KE5VTEwsCgkJCSAgICAicmVhbGxvY2F0aW5nIGFuIGFycmF5IG9mIGtleS1zZXF1ZW5jZXMiLAoJCQkgICAgTlVMTCk7CgkJCXJldHVybiAoLTEpOwoJCSAgICB9CgkJICAgIC8qCgkJICAgICogVGhlIGFycmF5IG5lZWRzIHRvIGJlIE5VTExlZC4KCQkgICAgKiBUT0RPOiBVc2UgbWVtc2V0PwoJCSAgICAqLwoJCSAgICBmb3IgKDsgaSA8IG1hdGNoZXItPnNpemVLZXlTZXFzOyBpKyspIAoJCQltYXRjaGVyLT5rZXlTZXFzW2ldID0gTlVMTDsJCQkKCQl9CgkJCgkJLyoKCQkqIEdldC9jcmVhdGUgdGhlIGtleS1zZXF1ZW5jZS4KCQkqLwoJCWtleVNlcSA9IG1hdGNoZXItPmtleVNlcXNbcG9zXTsJCSAgICAKCQlpZiAoa2V5U2VxID09IE5VTEwpIHsJCgkJICAgIGdvdG8gY3JlYXRlX3NlcXVlbmNlOwoJCX0gZWxzZSBpZiAoa2V5U2VxW2lkeF0gIT0gTlVMTCkgewoJCSAgICB4bWxDaGFyICpzdHIgPSBOVUxMOwoJCSAgICAvKgoJCSAgICAqIGN2Yy1pZGVudGl0eS1jb25zdHJhaW50OgoJCSAgICAqIDMgRm9yIGVhY2ggbm9kZSBpbiB0aGUgt3RhcmdldCBub2RlIHNldLcgYWxsCgkJICAgICogb2YgdGhlIHtmaWVsZHN9LCB3aXRoIHRoYXQgbm9kZSBhcyB0aGUgY29udGV4dAoJCSAgICAqIG5vZGUsIGV2YWx1YXRlIHRvIGVpdGhlciBhbiBlbXB0eSBub2RlLXNldCBvcgoJCSAgICAqIGEgbm9kZS1zZXQgd2l0aCBleGFjdGx5IG9uZSBtZW1iZXIsIHdoaWNoIG11c3QKCQkgICAgKiBoYXZlIGEgc2ltcGxlIHR5cGUuCgkJICAgICogCgkJICAgICogVGhlIGtleSB3YXMgYWxyZWFkeSBzZXQ7IHJlcG9ydCBhbiBlcnJvci4KCQkgICAgKi8KCQkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsIAoJCQlYTUxfU0NIRU1BVl9DVkNfSURDLCBOVUxMLAoJCQlXWFNfQkFTSUNfQ0FTVCBtYXRjaGVyLT5haWRjLT5kZWYsCgkJCSJUaGUgWFBhdGggJyVzJyBvZiBhIGZpZWxkIG9mICVzIGV2YWx1YXRlcyB0byBhICIKCQkJIm5vZGUtc2V0IHdpdGggbW9yZSB0aGFuIG9uZSBtZW1iZXIiLAoJCQlzdG8tPnNlbC0+eHBhdGgsCgkJCXhtbFNjaGVtYUdldElEQ0Rlc2lnbmF0aW9uKCZzdHIsIG1hdGNoZXItPmFpZGMtPmRlZikpOwoJCSAgICBGUkVFX0FORF9OVUxMKHN0cik7CgkJICAgIHN0by0+bmJIaXN0b3J5LS07CgkJICAgIGdvdG8gZGVyZWdpc3Rlcl9jaGVjazsKCQl9IGVsc2UKCQkgICAgZ290byBjcmVhdGVfa2V5OwkJCgkJCmNyZWF0ZV9zZXF1ZW5jZToKCQkvKgoJCSogQ3JlYXRlIGEga2V5LXNlcXVlbmNlLgoJCSovCgkJa2V5U2VxID0gKHhtbFNjaGVtYVBTVklJRENLZXlQdHIgKikgeG1sTWFsbG9jKAoJCSAgICBtYXRjaGVyLT5haWRjLT5kZWYtPm5iRmllbGRzICogCgkJICAgIHNpemVvZih4bWxTY2hlbWFQU1ZJSURDS2V5UHRyKSk7CgkJaWYgKGtleVNlcSA9PSBOVUxMKSB7CgkJICAgIHhtbFNjaGVtYVZFcnJNZW1vcnkoTlVMTCwgCgkJCSJhbGxvY2F0aW5nIGFuIElEQyBrZXktc2VxdWVuY2UiLCBOVUxMKTsKCQkgICAgcmV0dXJuKC0xKTsJCQkKCQl9CQoJCW1lbXNldChrZXlTZXEsIDAsIG1hdGNoZXItPmFpZGMtPmRlZi0+bmJGaWVsZHMgKiAKCQkgICAgc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENLZXlQdHIpKTsKCQltYXRjaGVyLT5rZXlTZXFzW3Bvc10gPSBrZXlTZXE7CmNyZWF0ZV9rZXk6CgkJLyoKCQkqIENyZWF0ZSBhIGtleSBvbmNlIHBlciBub2RlIG9ubHkuCgkJKi8gIAoJCWlmIChrZXkgPT0gTlVMTCkgewoJCSAgICBrZXkgPSAoeG1sU2NoZW1hUFNWSUlEQ0tleVB0cikgeG1sTWFsbG9jKAoJCQlzaXplb2YoeG1sU2NoZW1hUFNWSUlEQ0tleSkpOwoJCSAgICBpZiAoa2V5ID09IE5VTEwpIHsKCQkJeG1sU2NoZW1hVkVyck1lbW9yeShOVUxMLAoJCQkgICAgImFsbG9jYXRpbmcgYSBJREMga2V5IiwgTlVMTCk7CgkJCXhtbEZyZWUoa2V5U2VxKTsKCQkJbWF0Y2hlci0+a2V5U2Vxc1twb3NdID0gTlVMTDsKCQkJcmV0dXJuKC0xKTsJCQkKCQkgICAgfQoJCSAgICAvKgoJCSAgICAqIENvbnN1bWUgdGhlIGNvbXBpbGVkIHZhbHVlLgoJCSAgICAqLwoJCSAgICBrZXktPnR5cGUgPSBzaW1wbGVUeXBlOwoJCSAgICBrZXktPnZhbCA9IHZjdHh0LT5pbm9kZS0+dmFsOwoJCSAgICB2Y3R4dC0+aW5vZGUtPnZhbCA9IE5VTEw7CgkJICAgIC8qCgkJICAgICogU3RvcmUgdGhlIGtleSBpbiBhIGdsb2JhbCBsaXN0LgoJCSAgICAqLwoJCSAgICBpZiAoeG1sU2NoZW1hSURDU3RvcmVLZXkodmN0eHQsIGtleSkgPT0gLTEpIHsKCQkJeG1sU2NoZW1hSURDRnJlZUtleShrZXkpOwoJCQlyZXR1cm4gKC0xKTsKCQkgICAgfQoJCX0KCQlrZXlTZXFbaWR4XSA9IGtleTsJCSAgICAKCSAgICB9Cgl9IGVsc2UgaWYgKHN0by0+dHlwZSA9PSBYUEFUSF9TVEFURV9PQkpfVFlQRV9JRENfU0VMRUNUT1IpIHsKCQkKCSAgICB4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICoqa2V5U2VxID0gTlVMTDsKCSAgICAvKiB4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0ciBiaW5kOyAqLwoJICAgIHhtbFNjaGVtYVBTVklJRENOb2RlUHRyIG50SXRlbTsKCSAgICB4bWxTY2hlbWFJRENNYXRjaGVyUHRyIG1hdGNoZXI7CgkgICAgeG1sU2NoZW1hSURDUHRyIGlkYzsKCSAgICB4bWxTY2hlbWFJdGVtTGlzdFB0ciB0YXJnZXRzOwoJICAgIGludCBwb3MsIGksIGosIG5iS2V5czsKCSAgICAvKgoJICAgICogSGVyZSB3ZSBoYXZlIHRoZSBmb2xsb3dpbmcgc2NlbmFyaW86CgkgICAgKiBBbiBJREMgJ3NlbGVjdG9yJyBzdGF0ZSBvYmplY3QgcmVzb2x2ZWQgdG8gYSB0YXJnZXQgbm9kZSwKCSAgICAqIGR1cmluZyB0aGUgdGltZSB0aGlzIHRhcmdldCBub2RlIHdhcyBpbiB0aGUgCgkgICAgKiBhbmNlc3Rvci1vci1zZWxmIGF4aXMsIHRoZSAnZmllbGQnIHN0YXRlIG9iamVjdChzKSBsb29rZWQgCgkgICAgKiBvdXQgZm9yIG1hdGNoaW5nIG5vZGVzIHRvIGNyZWF0ZSBhIGtleS1zZXF1ZW5jZSBmb3IgdGhpcyAKCSAgICAqIHRhcmdldCBub2RlLiBOb3cgd2UgYXJlIGJhY2sgdG8gdGhpcyB0YXJnZXQgbm9kZSBhbmQgbmVlZAoJICAgICogdG8gcHV0IHRoZSBrZXktc2VxdWVuY2UsIHRvZ2V0aGVyIHdpdGggdGhlIHRhcmdldCBub2RlIAoJICAgICogaXRzZWxmLCBpbnRvIHRoZSBub2RlLXRhYmxlIG9mIHRoZSBjb3JyZXNwb25kaW5nIElEQyAKCSAgICAqIGJpbmRpbmcuCgkgICAgKi8KCSAgICBtYXRjaGVyID0gc3RvLT5tYXRjaGVyOwoJICAgIGlkYyA9IG1hdGNoZXItPmFpZGMtPmRlZjsKCSAgICBuYktleXMgPSBpZGMtPm5iRmllbGRzOwoJICAgIHBvcyA9IGRlcHRoIC0gbWF0Y2hlci0+ZGVwdGg7CQkKCSAgICAvKgoJICAgICogQ2hlY2sgaWYgdGhlIG1hdGNoZXIgaGFzIGFueSBrZXktc2VxdWVuY2VzIGF0IGFsbCwgcGx1cwoJICAgICogaWYgaXQgaGFzIGEga2V5LXNlcXVlbmNlIGZvciB0aGUgY3VycmVudCB0YXJnZXQgbm9kZS4KCSAgICAqLwkJCgkgICAgaWYgKChtYXRjaGVyLT5rZXlTZXFzID09IE5VTEwpIHx8CgkJKG1hdGNoZXItPnNpemVLZXlTZXFzIDw9IHBvcykpIHsKCQlpZiAoaWRjLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZKQoJCSAgICBnb3RvIHNlbGVjdG9yX2tleV9lcnJvcjsKCQllbHNlCgkJICAgIGdvdG8gc2VsZWN0b3JfbGVhdmU7CgkgICAgfQoJICAgIAoJICAgIGtleVNlcSA9ICYobWF0Y2hlci0+a2V5U2Vxc1twb3NdKTsJCQoJICAgIGlmICgqa2V5U2VxID09IE5VTEwpIHsKCQlpZiAoaWRjLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZKQoJCSAgICBnb3RvIHNlbGVjdG9yX2tleV9lcnJvcjsKCQllbHNlCgkJICAgIGdvdG8gc2VsZWN0b3JfbGVhdmU7CgkgICAgfQoJICAgIAoJICAgIGZvciAoaSA9IDA7IGkgPCBuYktleXM7IGkrKykgewoJCWlmICgoKmtleVNlcSlbaV0gPT0gTlVMTCkgewoJCSAgICAvKgoJCSAgICAqIE5vdCBxdWFsaWZpZWQsIGlmIG5vdCBhbGwgZmllbGRzIGRpZCByZXNvbHZlLgoJCSAgICAqLwoJCSAgICBpZiAoaWRjLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZKSB7CgkJCS8qCgkJCSogQWxsIGZpZWxkcyBvZiBhICJrZXkiIElEQyBtdXN0IHJlc29sdmUuCgkJCSovCgkJCWdvdG8gc2VsZWN0b3Jfa2V5X2Vycm9yOwoJCSAgICB9CQkgICAgCgkJICAgIGdvdG8gc2VsZWN0b3JfbGVhdmU7CgkJfQoJICAgIH0KCSAgICAvKgoJICAgICogQWxsIGZpZWxkcyBkaWQgcmVzb2x2ZS4KCSAgICAqLwoJICAgIAoJICAgIC8qCgkgICAgKiA0LjEgSWYgdGhlIHtpZGVudGl0eS1jb25zdHJhaW50IGNhdGVnb3J5fSBpcyB1bmlxdWUoL2tleSksCgkgICAgKiB0aGVuIG5vIHR3byBtZW1iZXJzIG9mIHRoZSC3cXVhbGlmaWVkIG5vZGUgc2V0tyBoYXZlCgkgICAgKiC3a2V5LXNlcXVlbmNlc7cgd2hvc2UgbWVtYmVycyBhcmUgcGFpcndpc2UgZXF1YWwsIGFzCgkgICAgKiBkZWZpbmVkIGJ5IEVxdWFsIGluIFtYTUwgU2NoZW1hczogRGF0YXR5cGVzXS4KCSAgICAqCgkgICAgKiBHZXQgdGhlIElEQyBiaW5kaW5nIGZyb20gdGhlIG1hdGNoZXIgYW5kIGNoZWNrIGZvcgoJICAgICogZHVwbGljYXRlIGtleS1zZXF1ZW5jZXMuCgkgICAgKi8KI2lmIDAKCSAgICBiaW5kID0geG1sU2NoZW1hSURDQWNxdWlyZUJpbmRpbmcodmN0eHQsIG1hdGNoZXIpOwojZW5kaWYKCSAgICB0YXJnZXRzID0geG1sU2NoZW1hSURDQWNxdWlyZVRhcmdldExpc3QodmN0eHQsIG1hdGNoZXIpOwoJICAgIGlmICgoaWRjLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGKSAmJiAKCQkodGFyZ2V0cy0+bmJJdGVtcyAhPSAwKSkgewoJCXhtbFNjaGVtYVBTVklJRENLZXlQdHIgY2tleSwgYmtleSwgKmJrZXlTZXE7CgkJCgkJaSA9IDA7CgkJcmVzID0gMDsKCQkvKgoJCSogQ29tcGFyZSB0aGUga2V5LXNlcXVlbmNlcywga2V5IGJ5IGtleS4KCQkqLwoJCWRvIHsKCQkgICAgYmtleVNlcSA9CgkJCSgoeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIpIHRhcmdldHMtPml0ZW1zW2ldKS0+a2V5czsKCQkgICAgZm9yIChqID0gMDsgaiA8IG5iS2V5czsgaisrKSB7CgkJCWNrZXkgPSAoKmtleVNlcSlbal07CgkJCWJrZXkgPSBia2V5U2VxW2pdOwkJCQkJCQkKCQkJcmVzID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoY2tleS0+dmFsLCBia2V5LT52YWwpOwoJCQlpZiAocmVzID09IC0xKSB7CgkJCSAgICByZXR1cm4gKC0xKTsKCQkJfSBlbHNlIGlmIChyZXMgPT0gMCkgewoJCQkgICAgLyoKCQkJICAgICogT25lIG9mIHRoZSBrZXlzIGRpZmZlcnMsIHNvIHRoZSBrZXktc2VxdWVuY2UKCQkJICAgICogd29uJ3QgYmUgZXF1YWw7IGdldCBvdXQuCgkJCSAgICAqLwoJCQkgICAgYnJlYWs7CgkJCX0KCQkgICAgfQoJCSAgICBpZiAocmVzID09IDEpIHsKCQkJLyoKCQkJKiBEdXBsaWNhdGUga2V5LXNlcXVlbmNlIGZvdW5kLgoJCQkqLwoJCQlicmVhazsKCQkgICAgfQoJCSAgICBpKys7CgkJfSB3aGlsZSAoaSA8IHRhcmdldHMtPm5iSXRlbXMpOwoJCWlmIChpICE9IHRhcmdldHMtPm5iSXRlbXMpIHsKCQkgICAgeG1sQ2hhciAqc3RyID0gTlVMTCwgKnN0ckIgPSBOVUxMOwoJCSAgICAvKiAgIAoJCSAgICAqIFRPRE86IFRyeSB0byByZXBvcnQgdGhlIGtleS1zZXF1ZW5jZS4KCQkgICAgKi8KCQkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsIAoJCQlYTUxfU0NIRU1BVl9DVkNfSURDLCBOVUxMLAoJCQlXWFNfQkFTSUNfQ0FTVCBpZGMsCgkJCSJEdXBsaWNhdGUga2V5LXNlcXVlbmNlICVzIGluICVzIiwKCQkJeG1sU2NoZW1hRm9ybWF0SURDS2V5U2VxdWVuY2UodmN0eHQsICZzdHIsCgkJCSAgICAoKmtleVNlcSksIG5iS2V5cyksCgkJCXhtbFNjaGVtYUdldElEQ0Rlc2lnbmF0aW9uKCZzdHJCLCBpZGMpKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHIpOwoJCSAgICBGUkVFX0FORF9OVUxMKHN0ckIpOwoJCSAgICBnb3RvIHNlbGVjdG9yX2xlYXZlOwoJCX0KCSAgICB9CgkgICAgLyoKCSAgICAqIEFkZCBhIG5vZGUtdGFibGUgaXRlbSB0byB0aGUgSURDIGJpbmRpbmcuCgkgICAgKi8KCSAgICBudEl0ZW0gPSAoeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIpIHhtbE1hbGxvYygKCQlzaXplb2YoeG1sU2NoZW1hUFNWSUlEQ05vZGUpKTsKCSAgICBpZiAobnRJdGVtID09IE5VTEwpIHsKCQl4bWxTY2hlbWFWRXJyTWVtb3J5KE5VTEwsIAoJCSAgICAiYWxsb2NhdGluZyBhbiBJREMgbm9kZS10YWJsZSBpdGVtIiwgTlVMTCk7CgkJeG1sRnJlZSgqa2V5U2VxKTsKCQkqa2V5U2VxID0gTlVMTDsKCQlyZXR1cm4oLTEpOwoJICAgIH0JCgkgICAgbWVtc2V0KG50SXRlbSwgMCwgc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENOb2RlKSk7CgkgICAgCgkgICAgLyogCgkgICAgKiBTdG9yZSB0aGUgbm9kZS10YWJsZSBpdGVtIGluIGEgZ2xvYmFsIGxpc3QuCgkgICAgKi8KCSAgICBpZiAoaWRjLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9JRENfS0VZUkVGKSB7CgkJaWYgKHhtbFNjaGVtYUlEQ1N0b3JlTm9kZVRhYmxlSXRlbSh2Y3R4dCwgbnRJdGVtKSA9PSAtMSkgewoJCSAgICB4bWxGcmVlKG50SXRlbSk7CgkJICAgIHhtbEZyZWUoKmtleVNlcSk7CgkJICAgICprZXlTZXEgPSBOVUxMOwoJCSAgICByZXR1cm4gKC0xKTsKCQl9CgkJbnRJdGVtLT5ub2RlUU5hbWVJRCA9IC0xOwoJICAgIH0gZWxzZSB7CgkJLyoKCQkqIFNhdmUgYSBjYWNoZWQgUU5hbWUgZm9yIHRoaXMgbm9kZSBvbiB0aGUgSURDIG5vZGUsIHRvIGJlCgkJKiBhYmxlIHRvIHJlcG9ydCBpdCwgZXZlbiBpZiB0aGUgbm9kZSBpcyBub3Qgc2F2ZWQuCgkJKi8KCQludEl0ZW0tPm5vZGVRTmFtZUlEID0geG1sU2NoZW1hVkFkZE5vZGVRTmFtZSh2Y3R4dCwKCQkgICAgdmN0eHQtPmlub2RlLT5sb2NhbE5hbWUsIHZjdHh0LT5pbm9kZS0+bnNOYW1lKTsKCQlpZiAobnRJdGVtLT5ub2RlUU5hbWVJRCA9PSAtMSkgewoJCSAgICB4bWxGcmVlKG50SXRlbSk7CgkJICAgIHhtbEZyZWUoKmtleVNlcSk7CgkJICAgICprZXlTZXEgPSBOVUxMOwoJCSAgICByZXR1cm4gKC0xKTsJCSAgICAKCQl9CgkgICAgfQoJICAgIC8qCgkgICAgKiBJbml0IHRoZSBub2RlLXRhYmxlIGl0ZW06IFNhdmUgdGhlIG5vZGUsIHBvc2l0aW9uIGFuZAoJICAgICogY29uc3VtZSB0aGUga2V5LXNlcXVlbmNlLgoJICAgICovCgkgICAgbnRJdGVtLT5ub2RlID0gdmN0eHQtPm5vZGU7CgkgICAgbnRJdGVtLT5ub2RlTGluZSA9IHZjdHh0LT5pbm9kZS0+bm9kZUxpbmU7CgkgICAgbnRJdGVtLT5rZXlzID0gKmtleVNlcTsKCSAgICAqa2V5U2VxID0gTlVMTDsKI2lmIDAKCSAgICBpZiAoeG1sU2NoZW1hSURDQXBwZW5kTm9kZVRhYmxlSXRlbShiaW5kLCBudEl0ZW0pID09IC0xKSB7CiNlbmRpZgoJICAgIGlmICh4bWxTY2hlbWFJdGVtTGlzdEFkZCh0YXJnZXRzLCBudEl0ZW0pID09IC0xKSB7CgkJaWYgKGlkYy0+dHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRikgewoJCSAgICAvKiAKCQkgICAgKiBGcmVlIHRoZSBpdGVtLCBzaW5jZSBrZXlyZWYgaXRlbXMgd29uJ3QgYmUKCQkgICAgKiBwdXQgb24gYSBnbG9iYWwgbGlzdC4KCQkgICAgKi8KCQkgICAgeG1sRnJlZShudEl0ZW0tPmtleXMpOwoJCSAgICB4bWxGcmVlKG50SXRlbSk7CgkJfQoJCXJldHVybiAoLTEpOwoJICAgIH0KCSAgICAKCSAgICBnb3RvIHNlbGVjdG9yX2xlYXZlOwpzZWxlY3Rvcl9rZXlfZXJyb3I6CgkgICAgewoJCXhtbENoYXIgKnN0ciA9IE5VTEw7CgkJLyoKCQkqIDQuMi4xIChLRVkpIFRoZSC3dGFyZ2V0IG5vZGUgc2V0tyBhbmQgdGhlIAoJCSogt3F1YWxpZmllZCBub2RlIHNldLcgYXJlIGVxdWFsLCB0aGF0IGlzLCBldmVyeSAKCQkqIG1lbWJlciBvZiB0aGUgt3RhcmdldCBub2RlIHNldLcgaXMgYWxzbyBhIG1lbWJlcgoJCSogb2YgdGhlILdxdWFsaWZpZWQgbm9kZSBzZXS3IGFuZCB2aWNlIHZlcnNhLgoJCSovCgkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsIAoJCSAgICBYTUxfU0NIRU1BVl9DVkNfSURDLCBOVUxMLAoJCSAgICBXWFNfQkFTSUNfQ0FTVCBpZGMsCgkJICAgICJOb3QgYWxsIGZpZWxkcyBvZiAlcyBldmFsdWF0ZSB0byBhIG5vZGUiLAoJCSAgICB4bWxTY2hlbWFHZXRJRENEZXNpZ25hdGlvbigmc3RyLCBpZGMpLCBOVUxMKTsKCQlGUkVFX0FORF9OVUxMKHN0cik7CgkgICAgfQpzZWxlY3Rvcl9sZWF2ZToKCSAgICAvKgoJICAgICogRnJlZSB0aGUga2V5LXNlcXVlbmNlIGlmIG5vdCBhZGRlZCB0byB0aGUgSURDIHRhYmxlLgoJICAgICovCgkgICAgaWYgKChrZXlTZXEgIT0gTlVMTCkgJiYgKCprZXlTZXEgIT0gTlVMTCkpIHsKCQl4bWxGcmVlKCprZXlTZXEpOwoJCSprZXlTZXEgPSBOVUxMOwoJICAgIH0KCX0gLyogaWYgc2VsZWN0b3IgKi8KCQoJc3RvLT5uYkhpc3RvcnktLTsKCmRlcmVnaXN0ZXJfY2hlY2s6CgkvKgoJKiBEZXJlZ2lzdGVyIHN0YXRlIG9iamVjdHMgaWYgdGhleSByZWFjaCB0aGUgZGVwdGggb2YgY3JlYXRpb24uCgkqLwoJaWYgKChzdG8tPm5iSGlzdG9yeSA9PSAwKSAmJiAoc3RvLT5kZXB0aCA9PSBkZXB0aCkpIHsKI2lmZGVmIERFQlVHX0lEQwoJICAgIHhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LCAiSURDOiAgIFNUTyBwb3AgJyVzJ1xuIiwKCQlzdG8tPnNlbC0+eHBhdGgpOwojZW5kaWYKCSAgICBpZiAodmN0eHQtPnhwYXRoU3RhdGVzICE9IHN0bykgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVhQYXRoUHJvY2Vzc0hpc3RvcnkiLAoJCSAgICAiVGhlIHN0YXRlIG9iamVjdCB0byBiZSByZW1vdmVkIGlzIG5vdCB0aGUgZmlyc3QgIgoJCSAgICAiaW4gdGhlIGxpc3QiKTsKCSAgICB9CgkgICAgbmV4dHN0byA9IHN0by0+bmV4dDsKCSAgICAvKgoJICAgICogVW5saW5rIGZyb20gdGhlIGxpc3Qgb2YgYWN0aXZlIFhQYXRoIHN0YXRlIG9iamVjdHMuCgkgICAgKi8KCSAgICB2Y3R4dC0+eHBhdGhTdGF0ZXMgPSBzdG8tPm5leHQ7CgkgICAgc3RvLT5uZXh0ID0gdmN0eHQtPnhwYXRoU3RhdGVQb29sOwoJICAgIC8qCgkgICAgKiBMaW5rIGl0IHRvIHRoZSBwb29sIG9mIHJldXNhYmxlIHN0YXRlIG9iamVjdHMuCgkgICAgKi8KCSAgICB2Y3R4dC0+eHBhdGhTdGF0ZVBvb2wgPSBzdG87CSAgICAKCSAgICBzdG8gPSBuZXh0c3RvOwoJfSBlbHNlCgkgICAgc3RvID0gc3RvLT5uZXh0OwogICAgfSAvKiB3aGlsZSAoc3RvICE9IE5VTEwpICovCiAgICByZXR1cm4gKDApOwp9CgovKioKICogeG1sU2NoZW1hSURDUmVnaXN0ZXJNYXRjaGVyczoKICogQHZjdHh0OiB0aGUgV1hTIHZhbGlkYXRpb24gY29udGV4dAogKiBAZWxlbURlY2w6IHRoZSBlbGVtZW50IGRlY2xhcmF0aW9uCiAqCiAqIENyZWF0ZXMgaGVscGVyIG9iamVjdHMgdG8gZXZhbHVhdGUgSURDIHNlbGVjdG9ycy9maWVsZHMKICogc3VjY2Vzc2l2ZWx5LgogKgogKiBSZXR1cm5zIDAgaWYgT0sgYW5kIC0xIG9uIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyBpbnQKeG1sU2NoZW1hSURDUmVnaXN0ZXJNYXRjaGVycyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgICAgeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtRGVjbCkKewogICAgeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyLCBsYXN0ID0gTlVMTDsKICAgIHhtbFNjaGVtYUlEQ1B0ciBpZGMsIHJlZklkYzsKICAgIHhtbFNjaGVtYUlEQ0F1Z1B0ciBhaWRjOwogICAgICAgIAogICAgaWRjID0gKHhtbFNjaGVtYUlEQ1B0cikgZWxlbURlY2wtPmlkY3M7CiAgICBpZiAoaWRjID09IE5VTEwpCglyZXR1cm4gKDApOwogICAgCiNpZmRlZiBERUJVR19JREMKICAgIHsKCXhtbENoYXIgKnN0ciA9IE5VTEw7Cgl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgCgkgICAgIklEQzogUkVHSVNURVIgb24gJXMsIGRlcHRoICVkXG4iLAoJICAgIChjaGFyICopIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsIHZjdHh0LT5pbm9kZS0+bnNOYW1lLAoJCXZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lKSwgdmN0eHQtPmRlcHRoKTsKCUZSRUVfQU5EX05VTEwoc3RyKQogICAgfQojZW5kaWYKICAgIGlmICh2Y3R4dC0+aW5vZGUtPmlkY01hdGNoZXJzICE9IE5VTEwpIHsKCVZFUlJPUl9JTlQoInhtbFNjaGVtYUlEQ1JlZ2lzdGVyTWF0Y2hlcnMiLAoJICAgICJUaGUgY2hhaW4gb2YgSURDIG1hdGNoZXJzIGlzIGV4cGVjdGVkIHRvIGJlIGVtcHR5Iik7CglyZXR1cm4gKC0xKTsKICAgIH0KICAgIGRvIHsKCWlmIChpZGMtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUYpIHsKCSAgICAvKgoJICAgICogU2luY2UgSURDcyBidWJibGVzIGFyZSBleHBlbnNpdmUgd2UgbmVlZCB0byBrbm93IHRoZQoJICAgICogZGVwdGggYXQgd2hpY2ggdGhlIGJ1YmJsZXMgc2hvdWxkIHN0b3A7IHRoaXMgd2lsbCBiZQoJICAgICogdGhlIGRlcHRoIG9mIHRoZSB0b3AtbW9zdCBrZXlyZWYgSURDLiBJZiBubyBrZXlyZWYKCSAgICAqIHJlZmVyZW5jZXMgYSBrZXkvdW5pcXVlIElEQywgdGhlIGtleXJlZkRlcHRoIHdpbGwKCSAgICAqIGJlIC0xLCBpbmRpY2F0aW5nIHRoYXQgbm8gYnViYmxlcyBhcmUgbmVlZGVkLgoJICAgICovCgkgICAgcmVmSWRjID0gKHhtbFNjaGVtYUlEQ1B0cikgaWRjLT5yZWYtPml0ZW07CgkgICAgaWYgKHJlZklkYyAhPSBOVUxMKSB7CgkJLyoKCQkqIFJlbWVtYmVyIHRoYXQgd2UgaGF2ZSBrZXlyZWZzIG9uIHRoaXMgbm9kZS4KCQkqLwoJCXZjdHh0LT5pbm9kZS0+aGFzS2V5cmVmcyA9IDE7CgkJLyoKCQkqIExvb2t1cCB0aGUgcmVmZXJlbmNlZCBhdWdtZW50ZWQgSURDIGluZm8uCgkJKi8KCQlhaWRjID0gdmN0eHQtPmFpZGNzOwoJCXdoaWxlIChhaWRjICE9IE5VTEwpIHsKCQkgICAgaWYgKGFpZGMtPmRlZiA9PSByZWZJZGMpCgkJCWJyZWFrOwoJCSAgICBhaWRjID0gYWlkYy0+bmV4dDsKCQl9CgkJaWYgKGFpZGMgPT0gTlVMTCkgewoJCSAgICBWRVJST1JfSU5UKCJ4bWxTY2hlbWFJRENSZWdpc3Rlck1hdGNoZXJzIiwKCQkJIkNvdWxkIG5vdCBmaW5kIGFuIGF1Z21lbnRlZCBJREMgaXRlbSBmb3IgYW4gSURDICIKCQkJImRlZmluaXRpb24iKTsKCQkgICAgcmV0dXJuICgtMSk7CgkJfQkJCgkJaWYgKChhaWRjLT5rZXlyZWZEZXB0aCA9PSAtMSkgfHwKCQkgICAgKHZjdHh0LT5kZXB0aCA8IGFpZGMtPmtleXJlZkRlcHRoKSkKCQkgICAgYWlkYy0+a2V5cmVmRGVwdGggPSB2Y3R4dC0+ZGVwdGg7CgkgICAgfQoJfQoJLyoKCSogTG9va3VwIHRoZSBhdWdtZW50ZWQgSURDIGl0ZW0gZm9yIHRoZSBJREMgZGVmaW5pdGlvbi4KCSovCglhaWRjID0gdmN0eHQtPmFpZGNzOwoJd2hpbGUgKGFpZGMgIT0gTlVMTCkgewoJICAgIGlmIChhaWRjLT5kZWYgPT0gaWRjKQoJCWJyZWFrOwoJICAgIGFpZGMgPSBhaWRjLT5uZXh0OwoJfQoJaWYgKGFpZGMgPT0gTlVMTCkgewoJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYUlEQ1JlZ2lzdGVyTWF0Y2hlcnMiLAoJCSJDb3VsZCBub3QgZmluZCBhbiBhdWdtZW50ZWQgSURDIGl0ZW0gZm9yIGFuIElEQyBkZWZpbml0aW9uIik7CgkgICAgcmV0dXJuICgtMSk7Cgl9CgkvKgoJKiBDcmVhdGUgYW4gSURDIG1hdGNoZXIgZm9yIGV2ZXJ5IElEQyBkZWZpbml0aW9uLgoJKi8KCW1hdGNoZXIgPSAoeG1sU2NoZW1hSURDTWF0Y2hlclB0cikgCgkgICAgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFJRENNYXRjaGVyKSk7CglpZiAobWF0Y2hlciA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hVkVyck1lbW9yeSh2Y3R4dCwgCgkJImFsbG9jYXRpbmcgYW4gSURDIG1hdGNoZXIiLCBOVUxMKTsKCSAgICByZXR1cm4gKC0xKTsKCX0KCW1lbXNldChtYXRjaGVyLCAwLCBzaXplb2YoeG1sU2NoZW1hSURDTWF0Y2hlcikpOwoJaWYgKGxhc3QgPT0gTlVMTCkKCSAgICB2Y3R4dC0+aW5vZGUtPmlkY01hdGNoZXJzID0gbWF0Y2hlcjsKCWVsc2UKCSAgICBsYXN0LT5uZXh0ID0gbWF0Y2hlcjsKCWxhc3QgPSBtYXRjaGVyOwoKCW1hdGNoZXItPnR5cGUgPSBJRENfTUFUQ0hFUjsKCW1hdGNoZXItPmRlcHRoID0gdmN0eHQtPmRlcHRoOwkKCW1hdGNoZXItPmFpZGMgPSBhaWRjOwoJbWF0Y2hlci0+aWRjVHlwZSA9IGFpZGMtPmRlZi0+dHlwZTsKI2lmZGVmIERFQlVHX0lEQwkKCXhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LCAiSURDOiAgIHJlZ2lzdGVyIG1hdGNoZXJcbiIpOwojZW5kaWYgCgkvKgoJKiBJbml0IHRoZSBhdXRvbWF0b24gc3RhdGUgb2JqZWN0LiAKCSovCglpZiAoeG1sU2NoZW1hSURDQWRkU3RhdGVPYmplY3QodmN0eHQsIG1hdGNoZXIsIAoJICAgIGlkYy0+c2VsZWN0b3IsIFhQQVRIX1NUQVRFX09CSl9UWVBFX0lEQ19TRUxFQ1RPUikgPT0gLTEpCgkgICAgcmV0dXJuICgtMSk7CgoJaWRjID0gaWRjLT5uZXh0OwogICAgfSB3aGlsZSAoaWRjICE9IE5VTEwpOwogICAgcmV0dXJuICgwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFJRENGaWxsTm9kZVRhYmxlcyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgIHhtbFNjaGVtYU5vZGVJbmZvUHRyIGllbGVtKQp7CiAgICB4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0ciBiaW5kOwogICAgaW50IHJlcywgaSwgaiwgaywgbmJUYXJnZXRzLCBuYkZpZWxkcywgbmJEdXBscywgbmJOb2RlVGFibGU7CiAgICB4bWxTY2hlbWFQU1ZJSURDS2V5UHRyICprZXlzLCAqbnRrZXlzOwogICAgeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIgKnRhcmdldHMsICpkdXBsczsKICAgIAogICAgeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyID0gaWVsZW0tPmlkY01hdGNoZXJzOwogICAgLyogdmN0eHQtPmNyZWF0ZUlEQ05vZGVUYWJsZXMgKi8KICAgIHdoaWxlIChtYXRjaGVyICE9IE5VTEwpIHsKCS8qCgkqIFNraXAga2V5cmVmIElEQ3MgYW5kIGVtcHR5IElEQyB0YXJnZXQtbGlzdHMuCgkqLwoJaWYgKChtYXRjaGVyLT5haWRjLT5kZWYtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0lEQ19LRVlSRUYpIHx8CgkgICAgV1hTX0lMSVNUX0lTX0VNUFRZKG1hdGNoZXItPnRhcmdldHMpKQoJewoJICAgIG1hdGNoZXIgPSBtYXRjaGVyLT5uZXh0OwoJICAgIGNvbnRpbnVlOwoJfQoJLyoKCSogSWYgd2UgX3dhbnRfIHRoZSBJREMgbm9kZS10YWJsZSB0byBiZSBjcmVhdGVkIGluIGFueSBjYXNlCgkqIHRoZW4gZG8gc28uIE90aGVyd2lzZSBjcmVhdGUgdGhlbSBvbmx5IGlmIGtleXJlZnMgbmVlZCB0aGVtLgoJKi8KCWlmICgoISB2Y3R4dC0+Y3JlYXRlSURDTm9kZVRhYmxlcykgJiYKCSAgICAoKG1hdGNoZXItPmFpZGMtPmtleXJlZkRlcHRoID09IC0xKSB8fAoJICAgICAobWF0Y2hlci0+YWlkYy0+a2V5cmVmRGVwdGggPiB2Y3R4dC0+ZGVwdGgpKSkKCXsKCSAgICBtYXRjaGVyID0gbWF0Y2hlci0+bmV4dDsKCSAgICBjb250aW51ZTsKCX0KCS8qCgkqIEdldC9jcmVhdGUgdGhlIElEQyBiaW5kaW5nIG9uIHRoaXMgZWxlbWVudCBmb3IgdGhlIElEQyBkZWZpbml0aW9uLgoJKi8KCWJpbmQgPSB4bWxTY2hlbWFJRENBY3F1aXJlQmluZGluZyh2Y3R4dCwgbWF0Y2hlcik7CgoJaWYgKCEgV1hTX0lMSVNUX0lTX0VNUFRZKGJpbmQtPmR1cGxzKSkgewoJICAgIGR1cGxzID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopIGJpbmQtPmR1cGxzLT5pdGVtczsKCSAgICBuYkR1cGxzID0gYmluZC0+ZHVwbHMtPm5iSXRlbXM7Cgl9IGVsc2UgewoJICAgIGR1cGxzID0gTlVMTDsKCSAgICBuYkR1cGxzID0gMDsJICAgIAoJfQoJaWYgKGJpbmQtPm5vZGVUYWJsZSAhPSBOVUxMKSB7CgkgICAgbmJOb2RlVGFibGUgPSBiaW5kLT5uYk5vZGVzOwoJfSBlbHNlIHsKCSAgICBuYk5vZGVUYWJsZSA9IDA7Cgl9CgoJaWYgKChuYk5vZGVUYWJsZSA9PSAwKSAmJiAobmJEdXBscyA9PSAwKSkgewoJICAgIC8qCgkgICAgKiBUcmFuc2ZlciBhbGwgSURDIHRhcmdldC1ub2RlcyB0byB0aGUgSURDIG5vZGUtdGFibGUuCgkgICAgKi8KCSAgICBiaW5kLT5ub2RlVGFibGUgPQoJCSh4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciAqKSBtYXRjaGVyLT50YXJnZXRzLT5pdGVtczsJCQoJICAgIGJpbmQtPnNpemVOb2RlcyA9IG1hdGNoZXItPnRhcmdldHMtPnNpemVJdGVtczsKCSAgICBiaW5kLT5uYk5vZGVzID0gbWF0Y2hlci0+dGFyZ2V0cy0+bmJJdGVtczsKCgkgICAgbWF0Y2hlci0+dGFyZ2V0cy0+aXRlbXMgPSBOVUxMOwoJICAgIG1hdGNoZXItPnRhcmdldHMtPnNpemVJdGVtcyA9IDA7CgkgICAgbWF0Y2hlci0+dGFyZ2V0cy0+bmJJdGVtcyA9IDA7CSAgICAKCX0gZWxzZSB7CgkgICAgLyoKCSAgICAqIENvbXBhcmUgdGhlIGtleS1zZXF1ZW5jZXMgYW5kIGFkZCB0byB0aGUgSURDIG5vZGUtdGFibGUuCgkgICAgKi8KCSAgICBuYlRhcmdldHMgPSBtYXRjaGVyLT50YXJnZXRzLT5uYkl0ZW1zOwoJICAgIHRhcmdldHMgPSAoeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIgKikgbWF0Y2hlci0+dGFyZ2V0cy0+aXRlbXM7CQoJICAgIG5iRmllbGRzID0gbWF0Y2hlci0+YWlkYy0+ZGVmLT5uYkZpZWxkczsKCSAgICBpID0gMDsKCSAgICBkbyB7CgkJa2V5cyA9IHRhcmdldHNbaV0tPmtleXM7CgkJaWYgKG5iRHVwbHMpIHsJCQkKCQkgICAgLyoKCQkgICAgKiBTZWFyY2ggaW4gYWxyZWFkeSBmb3VuZCBkdXBsaWNhdGVzIGZpcnN0LgoJCSAgICAqLwoJCSAgICBqID0gMDsKCQkgICAgZG8gewkJCQkJCQoJCQlpZiAobmJGaWVsZHMgPT0gMSkgewoJCQkgICAgcmVzID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoa2V5c1swXS0+dmFsLAoJCQkJZHVwbHNbal0tPmtleXNbMF0tPnZhbCk7CgkJCSAgICBpZiAocmVzID09IC0xKQoJCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJICAgIGlmIChyZXMgPT0gMSkgewoJCQkJLyoKCQkJCSogRXF1YWwga2V5LXNlcXVlbmNlLgoJCQkJKi8KCQkJCWdvdG8gbmV4dF90YXJnZXQ7CgkJCSAgICB9CgkJCX0gZWxzZSB7CgkJCSAgICByZXMgPSAwOwoJCQkgICAgbnRrZXlzID0gZHVwbHNbal0tPmtleXM7CgkJCSAgICBmb3IgKGsgPSAwOyBrIDwgbmJGaWVsZHM7IGsrKykgewoJCQkJcmVzID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoa2V5c1trXS0+dmFsLAoJCQkJICAgIG50a2V5c1trXS0+dmFsKTsKCQkJCWlmIChyZXMgPT0gLTEpCgkJCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJCWlmIChyZXMgPT0gMCkgewoJCQkJICAgIC8qCgkJCQkgICAgKiBPbmUgb2YgdGhlIGtleXMgZGlmZmVycy4KCQkJCSAgICAqLwoJCQkJICAgIGJyZWFrOwoJCQkJfQoJCQkgICAgfQoJCQkgICAgaWYgKHJlcyA9PSAxKSB7CgkJCQkvKgoJCQkJKiBFcXVhbCBrZXktc2VxdWVuY2UgZm91bmQuCgkJCQkqLwoJCQkJZ290byBuZXh0X3RhcmdldDsKCQkJICAgIH0KCQkJfQoJCQlqKys7CgkJICAgIH0gd2hpbGUgKGogPCBuYkR1cGxzKTsJCSAgICAKCQl9CgkJaWYgKG5iTm9kZVRhYmxlKSB7CgkJICAgIGogPSAwOwoJCSAgICBkbyB7CQkJCQkJCgkJCWlmIChuYkZpZWxkcyA9PSAxKSB7CgkJCSAgICByZXMgPSB4bWxTY2hlbWFBcmVWYWx1ZXNFcXVhbChrZXlzWzBdLT52YWwsCgkJCQliaW5kLT5ub2RlVGFibGVbal0tPmtleXNbMF0tPnZhbCk7CgkJCSAgICBpZiAocmVzID09IC0xKQoJCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJICAgIGlmIChyZXMgPT0gMCkgewoJCQkJLyoKCQkJCSogVGhlIGtleS1zZXF1ZW5jZSBkaWZmZXJzLgoJCQkJKi8KCQkJCWdvdG8gbmV4dF9ub2RlX3RhYmxlX2VudHJ5OwoJCQkgICAgfQoJCQl9IGVsc2UgewoJCQkgICAgcmVzID0gMDsKCQkJICAgIG50a2V5cyA9IGJpbmQtPm5vZGVUYWJsZVtqXS0+a2V5czsKCQkJICAgIGZvciAoayA9IDA7IGsgPCBuYkZpZWxkczsgaysrKSB7CgkJCQlyZXMgPSB4bWxTY2hlbWFBcmVWYWx1ZXNFcXVhbChrZXlzW2tdLT52YWwsCgkJCQkgICAgbnRrZXlzW2tdLT52YWwpOwoJCQkJaWYgKHJlcyA9PSAtMSkKCQkJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCQkJaWYgKHJlcyA9PSAwKSB7CgkJCQkgICAgLyoKCQkJCSAgICAqIE9uZSBvZiB0aGUga2V5cyBkaWZmZXJzLgoJCQkJICAgICovCgkJCQkgICAgZ290byBuZXh0X25vZGVfdGFibGVfZW50cnk7CgkJCQl9CgkJCSAgICB9CgkJCX0JCQkKCQkJLyoKCQkJKiBBZGQgdGhlIGR1cGxpY2F0ZSB0byB0aGUgbGlzdCBvZiBkdXBsaWNhdGVzLgoJCQkqLwoJCQlpZiAoYmluZC0+ZHVwbHMgPT0gTlVMTCkgewoJCQkgICAgYmluZC0+ZHVwbHMgPSB4bWxTY2hlbWFJdGVtTGlzdENyZWF0ZSgpOwoJCQkgICAgaWYgKGJpbmQtPmR1cGxzID09IE5VTEwpCgkJCQlnb3RvIGludGVybmFsX2Vycm9yOwoJCQl9CQkgICAgCgkJCWlmICh4bWxTY2hlbWFJdGVtTGlzdEFkZChiaW5kLT5kdXBscywgYmluZC0+bm9kZVRhYmxlW2pdKSA9PSAtMSkKCQkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJCS8qCgkJCSogUmVtb3ZlIHRoZSBkdXBsaWNhdGUgZW50cnkgZnJvbSB0aGUgSURDIG5vZGUtdGFibGUuCgkJCSovCgkJCWJpbmQtPm5vZGVUYWJsZVtqXSA9IGJpbmQtPm5vZGVUYWJsZVtiaW5kLT5uYk5vZGVzIC0xXTsKCQkJYmluZC0+bmJOb2Rlcy0tOwoKCQkJZ290byBuZXh0X3RhcmdldDsKCm5leHRfbm9kZV90YWJsZV9lbnRyeToKCQkJaisrOwoJCSAgICB9IHdoaWxlIChqIDwgbmJOb2RlVGFibGUpOwoJCX0KCQkvKgoJCSogSWYgZXZlcnl0aGluZyBpcyBmaW5lLCB0aGVuIGFkZCB0aGUgSURDIHRhcmdldC1ub2RlIHRvCgkJKiB0aGUgSURDIG5vZGUtdGFibGUuCgkJKi8KCQlpZiAoeG1sU2NoZW1hSURDQXBwZW5kTm9kZVRhYmxlSXRlbShiaW5kLCB0YXJnZXRzW2ldKSA9PSAtMSkKCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCm5leHRfdGFyZ2V0OgoJCWkrKzsKCSAgICB9IHdoaWxlIChpIDwgbmJUYXJnZXRzKTsKCX0KCW1hdGNoZXIgPSBtYXRjaGVyLT5uZXh0OwogICAgfQogICAgcmV0dXJuKDApOwoKaW50ZXJuYWxfZXJyb3I6CiAgICByZXR1cm4oLTEpOwp9CgovKioKICogeG1sU2NoZW1hQnViYmxlSURDTm9kZVRhYmxlczogCiAqIEBkZXB0aDogdGhlIGN1cnJlbnQgdHJlZSBkZXB0aAogKgogKiBNZXJnZXMgSURDIGJpbmRpbmdzIG9mIGFuIGVsZW1lbnQgYXQgQGRlcHRoIGludG8gdGhlIGNvcnJlc3BvbmRpbmcgSURDIAogKiBiaW5kaW5ncyBvZiBpdHMgcGFyZW50IGVsZW1lbnQuIElmIGEgZHVwbGljYXRlIG5vdGUtdGFibGUgZW50cnkgaXMgZm91bmQsIAogKiBib3RoLCB0aGUgcGFyZW50IG5vZGUtdGFibGUgZW50cnkgYW5kIGNoaWxkIGVudHJ5IGFyZSBkaXNjYXJkZWQgZnJvbSB0aGUgCiAqIG5vZGUtdGFibGUgb2YgdGhlIHBhcmVudC4KICoKICogUmV0dXJucyAwIGlmIE9LIGFuZCAtMSBvbiBpbnRlcm5hbCBlcnJvcnMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUJ1YmJsZUlEQ05vZGVUYWJsZXMoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7CiAgICB4bWxTY2hlbWFQU1ZJSURDQmluZGluZ1B0ciBiaW5kOyAvKiBJREMgYmluZGluZ3Mgb2YgdGhlIGN1cnJlbnQgbm9kZS4gKi8KICAgIHhtbFNjaGVtYVBTVklJRENCaW5kaW5nUHRyICpwYXJUYWJsZSwgcGFyQmluZCA9IE5VTEw7IC8qIHBhcmVudCBJREMgYmluZGluZ3MuICovCiAgICB4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciBub2RlLCBwYXJOb2RlID0gTlVMTCwgKmR1cGxzLCAqcGFyTm9kZXM7IC8qIG5vZGUtdGFibGUgZW50cmllcy4gKi8KICAgIHhtbFNjaGVtYUlEQ0F1Z1B0ciBhaWRjOwogICAgaW50IGksIGosIGssIHJldCA9IDAsIG5iRmllbGRzLCBvbGROdW0sIG9sZER1cGxzOwoKICAgIGJpbmQgPSB2Y3R4dC0+aW5vZGUtPmlkY1RhYmxlOyAgICAgICAgCiAgICBpZiAoYmluZCA9PSBOVUxMKSB7CgkvKiBGaW5lLCBubyB0YWJsZSwgbm8gYnViYmxlcy4gKi8KCXJldHVybiAoMCk7CiAgICB9CiAgICAKICAgIHBhclRhYmxlID0gJih2Y3R4dC0+ZWxlbUluZm9zW3ZjdHh0LT5kZXB0aCAtMV0tPmlkY1RhYmxlKTsKICAgIC8qCiAgICAqIFdhbGsgYWxsIGJpbmRpbmdzOyBjcmVhdGUgbmV3IG9yIGFkZCB0byBleGlzdGluZyBiaW5kaW5ncy4KICAgICogUmVtb3ZlIGR1cGxpY2F0ZSBrZXktc2VxdWVuY2VzLgogICAgKi8KICAgIHdoaWxlIChiaW5kICE9IE5VTEwpIHsKCQoJaWYgKChiaW5kLT5uYk5vZGVzID09IDApICYmIFdYU19JTElTVF9JU19FTVBUWShiaW5kLT5kdXBscykpCgkgICAgZ290byBuZXh0X2JpbmRpbmc7CgkvKgoJKiBDaGVjayBpZiB0aGUga2V5L3VuaXF1ZSBJREMgdGFibGUgbmVlZHMgdG8gYmUgYnViYmxlZC4KCSovCglpZiAoISB2Y3R4dC0+Y3JlYXRlSURDTm9kZVRhYmxlcykgewoJICAgIGFpZGMgPSB2Y3R4dC0+YWlkY3M7CgkgICAgZG8gewoJCWlmIChhaWRjLT5kZWYgPT0gYmluZC0+ZGVmaW5pdGlvbikgewoJCSAgICBpZiAoKGFpZGMtPmtleXJlZkRlcHRoID09IC0xKSB8fCAKCQkJKGFpZGMtPmtleXJlZkRlcHRoID49IHZjdHh0LT5kZXB0aCkpIHsKCQkJZ290byBuZXh0X2JpbmRpbmc7CgkJICAgIH0KCQkgICAgYnJlYWs7CgkJfQoJCWFpZGMgPSBhaWRjLT5uZXh0OwoJICAgIH0gd2hpbGUgKGFpZGMgIT0gTlVMTCk7Cgl9CgoJaWYgKHBhclRhYmxlICE9IE5VTEwpCgkgICAgcGFyQmluZCA9ICpwYXJUYWJsZTsKCS8qCgkqIFNlYXJjaCBhIG1hdGNoaW5nIHBhcmVudCBiaW5kaW5nIGZvciB0aGUKCSogSURDIGRlZmluaXRpb24uCgkqLwoJd2hpbGUgKHBhckJpbmQgIT0gTlVMTCkgewkgICAgCgkgICAgaWYgKHBhckJpbmQtPmRlZmluaXRpb24gPT0gYmluZC0+ZGVmaW5pdGlvbikKCQlicmVhazsKCSAgICBwYXJCaW5kID0gcGFyQmluZC0+bmV4dDsKCX0KCglpZiAocGFyQmluZCAhPSBOVUxMKSB7CgkgICAgLyoKCSAgICAqIENvbXBhcmUgZXZlcnkgbm9kZS10YWJsZSBlbnRyeSBvZiB0aGUgY2hpbGQgbm9kZSwgCgkgICAgKiBpLmUuIHRoZSBrZXktc2VxdWVuY2Ugd2l0aGluLCAuLi4KCSAgICAqLwoJICAgIG9sZE51bSA9IHBhckJpbmQtPm5iTm9kZXM7IC8qIFNraXAgbmV3bHkgYWRkZWQgaXRlbXMuICovCgoJICAgIGlmICghIFdYU19JTElTVF9JU19FTVBUWShwYXJCaW5kLT5kdXBscykpIHsKCQlvbGREdXBscyA9IHBhckJpbmQtPmR1cGxzLT5uYkl0ZW1zOwoJCWR1cGxzID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopIHBhckJpbmQtPmR1cGxzLT5pdGVtczsKCSAgICB9IGVsc2UgewoJCWR1cGxzID0gTlVMTDsKCQlvbGREdXBscyA9IDA7CQkKCSAgICB9CgkgICAgCgkgICAgcGFyTm9kZXMgPSBwYXJCaW5kLT5ub2RlVGFibGU7CgkgICAgbmJGaWVsZHMgPSBiaW5kLT5kZWZpbml0aW9uLT5uYkZpZWxkczsKCSAgICAKCSAgICBmb3IgKGkgPSAwOyBpIDwgYmluZC0+bmJOb2RlczsgaSsrKSB7CgkJbm9kZSA9IGJpbmQtPm5vZGVUYWJsZVtpXTsKCQlpZiAobm9kZSA9PSBOVUxMKQoJCSAgICBjb250aW51ZTsKCQkvKgoJCSogLi4ud2l0aCBldmVyeSBrZXktc2VxdWVuY2Ugb2YgdGhlIHBhcmVudCBub2RlLCBhbHJlYWR5CgkJKiBldmFsdWF0ZWQgdG8gYmUgYSBkdXBsaWNhdGUga2V5LXNlcXVlbmNlLgoJCSovCgkJaWYgKG9sZER1cGxzKSB7CgkJICAgIGogPSAwOyAKCQkgICAgd2hpbGUgKGogPCBvbGREdXBscykgewoJCQlpZiAobmJGaWVsZHMgPT0gMSkgewoJCQkgICAgcmV0ID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoCgkJCQlub2RlLT5rZXlzWzBdLT52YWwsCgkJCQlkdXBsc1tqXS0+a2V5c1swXS0+dmFsKTsKCQkJICAgIGlmIChyZXQgPT0gLTEpCgkJCQlnb3RvIGludGVybmFsX2Vycm9yOwoJCQkgICAgaWYgKHJldCA9PSAwKSB7CgkJCQlqKys7CgkJCQljb250aW51ZTsKCQkJICAgIH0KCQkJfSBlbHNlIHsKCQkJICAgIHBhck5vZGUgPSBkdXBsc1tqXTsKCQkJICAgIGZvciAoayA9IDA7IGsgPCBuYkZpZWxkczsgaysrKSB7CgkJCQlyZXQgPSB4bWxTY2hlbWFBcmVWYWx1ZXNFcXVhbCgKCQkJCSAgICBub2RlLT5rZXlzW2tdLT52YWwsCgkJCQkgICAgcGFyTm9kZS0+a2V5c1trXS0+dmFsKTsKCQkJCWlmIChyZXQgPT0gLTEpCgkJCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJCWlmIChyZXQgPT0gMCkKCQkJCSAgICBicmVhazsKCQkJICAgIH0KCQkJfQoJCQlpZiAocmV0ID09IDEpCgkJCSAgICAvKiBEdXBsaWNhdGUgZm91bmQuICovCgkJCSAgICBicmVhazsKCQkJaisrOwoJCSAgICB9CgkJICAgIGlmIChqICE9IG9sZER1cGxzKSB7CgkJCS8qIER1cGxpY2F0ZSBmb3VuZC4gU2tpcCB0aGlzIGVudHJ5LiAqLwoJCQljb250aW51ZTsKCQkgICAgfQoJCX0JCSAgICAKCQkvKgoJCSogLi4uIGFuZCB3aXRoIGV2ZXJ5IGtleS1zZXF1ZW5jZSBvZiB0aGUgcGFyZW50IG5vZGUuCgkJKi8KCQlpZiAob2xkTnVtKSB7CgkJICAgIGogPSAwOyAKCQkgICAgd2hpbGUgKGogPCBvbGROdW0pIHsKCQkJcGFyTm9kZSA9IHBhck5vZGVzW2pdOwoJCQlpZiAobmJGaWVsZHMgPT0gMSkgewoJCQkgICAgcmV0ID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoCgkJCQlub2RlLT5rZXlzWzBdLT52YWwsCgkJCQlwYXJOb2RlLT5rZXlzWzBdLT52YWwpOwoJCQkgICAgaWYgKHJldCA9PSAtMSkKCQkJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJCSAgICBpZiAocmV0ID09IDApIHsKCQkJCWorKzsKCQkJCWNvbnRpbnVlOwoJCQkgICAgfQoJCQl9IGVsc2UgewkJCSAgICAKCQkJICAgIGZvciAoayA9IDA7IGsgPCBuYkZpZWxkczsgaysrKSB7CgkJCQlyZXQgPSB4bWxTY2hlbWFBcmVWYWx1ZXNFcXVhbCgKCQkJCSAgICBub2RlLT5rZXlzW2tdLT52YWwsCgkJCQkgICAgcGFyTm9kZS0+a2V5c1trXS0+dmFsKTsKCQkJCWlmIChyZXQgPT0gLTEpCgkJCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJCWlmIChyZXQgPT0gMCkKCQkJCSAgICBicmVhazsKCQkJICAgIH0KCQkJfQoJCQlpZiAocmV0ID09IDEpCgkJCSAgICAvKiBEdXBsaWNhdGUgZm91bmQuICovCgkJCSAgICBicmVhazsKCQkJaisrOwoJCSAgICB9CgkJICAgIGlmIChqICE9IG9sZE51bSkgewoJCQkvKgoJCQkqIEhhbmRsZSBkdXBsaWNhdGVzLiBNb3ZlIHRoZSBkdXBsaWNhdGUgaW4KCQkJKiB0aGUgcGFyZW50J3Mgbm9kZS10YWJsZSB0byB0aGUgbGlzdCBvZgoJCQkqIGR1cGxpY2F0ZXMuCgkJCSovCQkJCgkJCW9sZE51bS0tOwoJCQlwYXJCaW5kLT5uYk5vZGVzLS07CgkJCS8qCgkJCSogTW92ZSBsYXN0IG9sZCBpdGVtIHRvIHBvcyBvZiBkdXBsaWNhdGUuCgkJCSovCgkJCXBhck5vZGVzW2pdID0gcGFyTm9kZXNbb2xkTnVtXTsKCQkJCgkJCWlmIChwYXJCaW5kLT5uYk5vZGVzICE9IG9sZE51bSkgewoJCQkgICAgLyoKCQkJICAgICogSWYgbmV3IGl0ZW1zIGV4aXN0LCBtb3ZlIGxhc3QgbmV3IGl0ZW0gdG8gCgkJCSAgICAqIGxhc3Qgb2Ygb2xkIGl0ZW1zLgoJCQkgICAgKi8KCQkJICAgIHBhck5vZGVzW29sZE51bV0gPSAKCQkJCXBhck5vZGVzW3BhckJpbmQtPm5iTm9kZXNdOwoJCQl9CgkJCWlmIChwYXJCaW5kLT5kdXBscyA9PSBOVUxMKSB7CgkJCSAgICBwYXJCaW5kLT5kdXBscyA9IHhtbFNjaGVtYUl0ZW1MaXN0Q3JlYXRlKCk7CgkJCSAgICBpZiAocGFyQmluZC0+ZHVwbHMgPT0gTlVMTCkKCQkJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJCX0KCQkJeG1sU2NoZW1hSXRlbUxpc3RBZGQocGFyQmluZC0+ZHVwbHMsIHBhck5vZGUpOwkJCQoJCSAgICB9IGVsc2UgewoJCQkvKgoJCQkqIEFkZCB0aGUgbm9kZS10YWJsZSBlbnRyeSAobm9kZSBhbmQga2V5LXNlcXVlbmNlKSBvZiAKCQkJKiB0aGUgY2hpbGQgbm9kZSB0byB0aGUgbm9kZSB0YWJsZSBvZiB0aGUgcGFyZW50IG5vZGUuCgkJCSovCgkJCWlmIChwYXJCaW5kLT5ub2RlVGFibGUgPT0gTlVMTCkgewkJCQoJCQkgICAgcGFyQmluZC0+bm9kZVRhYmxlID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopIAoJCQkJeG1sTWFsbG9jKDEwICogc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyKSk7CgkJCSAgICBpZiAocGFyQmluZC0+bm9kZVRhYmxlID09IE5VTEwpIHsKCQkJCXhtbFNjaGVtYVZFcnJNZW1vcnkoTlVMTCwgCgkJCQkgICAgImFsbG9jYXRpbmcgSURDIGxpc3Qgb2Ygbm9kZS10YWJsZSBpdGVtcyIsIE5VTEwpOwoJCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJICAgIH0KCQkJICAgIHBhckJpbmQtPnNpemVOb2RlcyA9IDE7CgkJCX0gZWxzZSBpZiAocGFyQmluZC0+bmJOb2RlcyA+PSBwYXJCaW5kLT5zaXplTm9kZXMpIHsKCQkJICAgIHBhckJpbmQtPnNpemVOb2RlcyAqPSAyOwoJCQkgICAgcGFyQmluZC0+bm9kZVRhYmxlID0gKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyICopIAoJCQkJeG1sUmVhbGxvYyhwYXJCaW5kLT5ub2RlVGFibGUsIHBhckJpbmQtPnNpemVOb2RlcyAqIAoJCQkJc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyKSk7CgkJCSAgICBpZiAocGFyQmluZC0+bm9kZVRhYmxlID09IE5VTEwpIHsKCQkJCXhtbFNjaGVtYVZFcnJNZW1vcnkoTlVMTCwgCgkJCQkgICAgInJlLWFsbG9jYXRpbmcgSURDIGxpc3Qgb2Ygbm9kZS10YWJsZSBpdGVtcyIsIE5VTEwpOwoJCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJICAgIH0JCQkgICAgCgkJCX0KCQkJcGFyTm9kZXMgPSBwYXJCaW5kLT5ub2RlVGFibGU7CgkJCS8qCgkJCSogQXBwZW5kIHRoZSBuZXcgbm9kZS10YWJsZSBlbnRyeSB0byB0aGUgJ25ldyBub2RlLXRhYmxlCgkJCSogZW50cmllcycgc2VjdGlvbi4KCQkJKi8KCQkJcGFyTm9kZXNbcGFyQmluZC0+bmJOb2RlcysrXSA9IG5vZGU7CgkJICAgIH0KCgkJfQkKCQkKCSAgICB9CQoJfSBlbHNlIHsKCSAgICAvKgoJICAgICogTm8gYmluZGluZyBmb3IgdGhlIElEQyB3YXMgZm91bmQ6IGNyZWF0ZSBhIG5ldyBvbmUgYW5kCgkgICAgKiBjb3B5IGFsbCBub2RlLXRhYmxlcy4KCSAgICAqLwoJICAgIHBhckJpbmQgPSB4bWxTY2hlbWFJRENOZXdCaW5kaW5nKGJpbmQtPmRlZmluaXRpb24pOwoJICAgIGlmIChwYXJCaW5kID09IE5VTEwpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICAKCSAgICAvKgoJICAgICogVE9ETzogSG1tLCBob3cgdG8gb3B0aW1pemUgdGhlIGluaXRpYWwgbnVtYmVyIG9mCgkgICAgKiBhbGxvY2F0ZWQgZW50cmllcz8KCSAgICAqLwoJICAgIGlmIChiaW5kLT5uYk5vZGVzICE9IDApIHsKCQkvKgoJCSogQWRkIGFsbCBJREMgbm9kZS10YWJsZSBlbnRyaWVzLgoJCSovCgkJaWYgKCEgdmN0eHQtPnBzdmlFeHBvc2VJRENOb2RlVGFibGVzKSB7CgkJICAgIC8qCgkJICAgICogSnVzdCBtb3ZlIHRoZSBlbnRyaWVzLgoJCSAgICAqIE5PVEU6IHRoaXMgaXMgcXVpdGUgc2F2ZSBoZXJlLCBzaW5jZQoJCSAgICAqIGFsbCB0aGUga2V5cmVmIGxvb2t1cHMgaGF2ZSBhbHJlYWR5IGJlZW4KCQkgICAgKiBwZXJmb3JtZWQuCgkJICAgICovCgkJICAgIHBhckJpbmQtPm5vZGVUYWJsZSA9IGJpbmQtPm5vZGVUYWJsZTsKCQkgICAgYmluZC0+bm9kZVRhYmxlID0gTlVMTDsKCQkgICAgcGFyQmluZC0+c2l6ZU5vZGVzID0gYmluZC0+c2l6ZU5vZGVzOwoJCSAgICBiaW5kLT5zaXplTm9kZXMgPSAwOwoJCSAgICBwYXJCaW5kLT5uYk5vZGVzID0gYmluZC0+bmJOb2RlczsKCQkgICAgYmluZC0+bmJOb2RlcyA9IDA7CgkJfSBlbHNlIHsKCQkgICAgLyoKCQkgICAgKiBDb3B5IHRoZSBlbnRyaWVzLgoJCSAgICAqLwoJCSAgICBwYXJCaW5kLT5ub2RlVGFibGUgPSAoeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIgKikgCgkJCXhtbE1hbGxvYyhiaW5kLT5uYk5vZGVzICoKCQkJc2l6ZW9mKHhtbFNjaGVtYVBTVklJRENOb2RlUHRyKSk7CgkJICAgIGlmIChwYXJCaW5kLT5ub2RlVGFibGUgPT0gTlVMTCkgewoJCQl4bWxTY2hlbWFWRXJyTWVtb3J5KE5VTEwsIAoJCQkgICAgImFsbG9jYXRpbmcgYW4gYXJyYXkgb2YgSURDIG5vZGUtdGFibGUgIgoJCQkgICAgIml0ZW1zIiwgTlVMTCk7CgkJCXhtbFNjaGVtYUlEQ0ZyZWVCaW5kaW5nKHBhckJpbmQpOwoJCQlnb3RvIGludGVybmFsX2Vycm9yOwoJCSAgICB9CgkJICAgIHBhckJpbmQtPnNpemVOb2RlcyA9IGJpbmQtPm5iTm9kZXM7CgkJICAgIHBhckJpbmQtPm5iTm9kZXMgPSBiaW5kLT5uYk5vZGVzOwoJCSAgICBtZW1jcHkocGFyQmluZC0+bm9kZVRhYmxlLCBiaW5kLT5ub2RlVGFibGUsCgkJCWJpbmQtPm5iTm9kZXMgKiBzaXplb2YoeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIpKTsKCQl9CgkgICAgfQoJICAgIGlmIChiaW5kLT5kdXBscykgewoJCS8qCgkJKiBNb3ZlIHRoZSBkdXBsaWNhdGVzLgoJCSovCgkJaWYgKHBhckJpbmQtPmR1cGxzICE9IE5VTEwpCgkJICAgIHhtbFNjaGVtYUl0ZW1MaXN0RnJlZShwYXJCaW5kLT5kdXBscyk7CgkJcGFyQmluZC0+ZHVwbHMgPSBiaW5kLT5kdXBsczsKCQliaW5kLT5kdXBscyA9IE5VTEw7CQkKCSAgICB9CgkgICAgaWYgKCpwYXJUYWJsZSA9PSBOVUxMKQoJCSpwYXJUYWJsZSA9IHBhckJpbmQ7CgkgICAgZWxzZSB7CgkJcGFyQmluZC0+bmV4dCA9ICpwYXJUYWJsZTsKCQkqcGFyVGFibGUgPSBwYXJCaW5kOwoJICAgIH0JICAgCgl9CQoKbmV4dF9iaW5kaW5nOgoJYmluZCA9IGJpbmQtPm5leHQ7CiAgICB9CiAgICByZXR1cm4gKDApOwoKaW50ZXJuYWxfZXJyb3I6CiAgICByZXR1cm4oLTEpOwp9CgovKioKICogeG1sU2NoZW1hQ2hlY2tDVkNJRENLZXlSZWY6CiAqIEB2Y3R4dDogdGhlIFdYUyB2YWxpZGF0aW9uIGNvbnRleHQKICogQGVsZW1EZWNsOiB0aGUgZWxlbWVudCBkZWNsYXJhdGlvbgogKgogKiBDaGVjayB0aGUgY3ZjLWlkYy1rZXlyZWYgY29uc3RyYWludHMuCiAqLwpzdGF0aWMgaW50CnhtbFNjaGVtYUNoZWNrQ1ZDSURDS2V5UmVmKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgeG1sU2NoZW1hSURDTWF0Y2hlclB0ciBtYXRjaGVyOwogICAgeG1sU2NoZW1hUFNWSUlEQ0JpbmRpbmdQdHIgYmluZDsKICAgIAogICAgbWF0Y2hlciA9IHZjdHh0LT5pbm9kZS0+aWRjTWF0Y2hlcnM7CiAgICAvKgogICAgKiBGaW5kIGEga2V5cmVmLgogICAgKi8KICAgIHdoaWxlIChtYXRjaGVyICE9IE5VTEwpIHsKCWlmICgobWF0Y2hlci0+aWRjVHlwZSA9PSBYTUxfU0NIRU1BX1RZUEVfSURDX0tFWVJFRikgJiYKCSAgICBtYXRjaGVyLT50YXJnZXRzICYmCgkgICAgbWF0Y2hlci0+dGFyZ2V0cy0+bmJJdGVtcykKCXsKCSAgICBpbnQgaSwgaiwgaywgcmVzLCBuYkZpZWxkcywgaGFzRHVwbHM7CgkgICAgeG1sU2NoZW1hUFNWSUlEQ0tleVB0ciAqcmVmS2V5cywgKmtleXM7CgkgICAgeG1sU2NoZW1hUFNWSUlEQ05vZGVQdHIgcmVmTm9kZSA9IE5VTEw7CgoJICAgIG5iRmllbGRzID0gbWF0Y2hlci0+YWlkYy0+ZGVmLT5uYkZpZWxkczsKCgkgICAgLyoKCSAgICAqIEZpbmQgdGhlIElEQyBub2RlLXRhYmxlIGZvciB0aGUgcmVmZXJlbmNlZCBJREMga2V5L3VuaXF1ZS4KCSAgICAqLwoJICAgIGJpbmQgPSB2Y3R4dC0+aW5vZGUtPmlkY1RhYmxlOwoJICAgIHdoaWxlIChiaW5kICE9IE5VTEwpIHsKCQlpZiAoKHhtbFNjaGVtYUlEQ1B0cikgbWF0Y2hlci0+YWlkYy0+ZGVmLT5yZWYtPml0ZW0gPT0gCgkJICAgIGJpbmQtPmRlZmluaXRpb24pCgkJICAgIGJyZWFrOwoJCWJpbmQgPSBiaW5kLT5uZXh0OwoJICAgIH0KCSAgICBoYXNEdXBscyA9IChiaW5kICYmIGJpbmQtPmR1cGxzICYmIGJpbmQtPmR1cGxzLT5uYkl0ZW1zKSA/IDEgOiAwOwoJICAgIC8qCgkgICAgKiBTZWFyY2ggZm9yIGEgbWF0Y2hpbmcga2V5LXNlcXVlbmNlcy4KCSAgICAqLwoJICAgIGZvciAoaSA9IDA7IGkgPCBtYXRjaGVyLT50YXJnZXRzLT5uYkl0ZW1zOyBpKyspIHsKCQlyZXMgPSAwOwoJCXJlZk5vZGUgPSBtYXRjaGVyLT50YXJnZXRzLT5pdGVtc1tpXTsKCQlpZiAoYmluZCAhPSBOVUxMKSB7CgkJICAgIHJlZktleXMgPSByZWZOb2RlLT5rZXlzOwoJCSAgICBmb3IgKGogPSAwOyBqIDwgYmluZC0+bmJOb2RlczsgaisrKSB7CgkJCWtleXMgPSBiaW5kLT5ub2RlVGFibGVbal0tPmtleXM7CgkJCWZvciAoayA9IDA7IGsgPCBuYkZpZWxkczsgaysrKSB7CgkJCSAgICByZXMgPSB4bWxTY2hlbWFBcmVWYWx1ZXNFcXVhbChrZXlzW2tdLT52YWwsCgkJCQlyZWZLZXlzW2tdLT52YWwpOwoJCQkgICAgaWYgKHJlcyA9PSAwKQoJCQkJYnJlYWs7CgkJCSAgICBlbHNlIGlmIChyZXMgPT0gLTEpIHsKCQkJCXJldHVybiAoLTEpOwoJCQkgICAgfQoJCQl9CgkJCWlmIChyZXMgPT0gMSkgewoJCQkgICAgLyoKCQkJICAgICogTWF0Y2ggZm91bmQuCgkJCSAgICAqLwoJCQkgICAgYnJlYWs7CgkJCX0KCQkgICAgfQoJCSAgICBpZiAoKHJlcyA9PSAwKSAmJiBoYXNEdXBscykgewoJCQkvKgoJCQkqIFNlYXJjaCBpbiBkdXBsaWNhdGVzCgkJCSovCgkJCWZvciAoaiA9IDA7IGogPCBiaW5kLT5kdXBscy0+bmJJdGVtczsgaisrKSB7CgkJCSAgICBrZXlzID0gKCh4bWxTY2hlbWFQU1ZJSURDTm9kZVB0cikKCQkJCWJpbmQtPmR1cGxzLT5pdGVtc1tqXSktPmtleXM7CgkJCSAgICBmb3IgKGsgPSAwOyBrIDwgbmJGaWVsZHM7IGsrKykgewoJCQkJcmVzID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoa2V5c1trXS0+dmFsLAoJCQkJICAgIHJlZktleXNba10tPnZhbCk7CgkJCQlpZiAocmVzID09IDApCgkJCQkgICAgYnJlYWs7CgkJCQllbHNlIGlmIChyZXMgPT0gLTEpIHsKCQkJCSAgICByZXR1cm4gKC0xKTsKCQkJCX0KCQkJICAgIH0KCQkJICAgIGlmIChyZXMgPT0gMSkgewoJCQkJLyoKCQkJCSogTWF0Y2ggaW4gZHVwbGljYXRlcyBmb3VuZC4KCQkJCSovCgkJCQl4bWxDaGFyICpzdHIgPSBOVUxMLCAqc3RyQiA9IE5VTEw7CgkJCQl4bWxTY2hlbWFLZXlyZWZFcnIodmN0eHQsCgkJCQkgICAgWE1MX1NDSEVNQVZfQ1ZDX0lEQywgcmVmTm9kZSwKCQkJCSAgICAoeG1sU2NoZW1hVHlwZVB0cikgbWF0Y2hlci0+YWlkYy0+ZGVmLAoJCQkJICAgICJNb3JlIHRoYW4gb25lIG1hdGNoIGZvdW5kIGZvciAiCgkJCQkgICAgImtleS1zZXF1ZW5jZSAlcyBvZiBrZXlyZWYgJyVzJyIsCgkJCQkgICAgeG1sU2NoZW1hRm9ybWF0SURDS2V5U2VxdWVuY2UodmN0eHQsICZzdHIsCgkJCQkJcmVmTm9kZS0+a2V5cywgbmJGaWVsZHMpLAoJCQkJICAgIHhtbFNjaGVtYUdldENvbXBvbmVudFFOYW1lKCZzdHJCLAoJCQkJCW1hdGNoZXItPmFpZGMtPmRlZikpOwoJCQkJRlJFRV9BTkRfTlVMTChzdHIpOwoJCQkJRlJFRV9BTkRfTlVMTChzdHJCKTsKCQkJCWJyZWFrOwoJCQkgICAgfQoJCQl9CgkJICAgIH0KCQl9CgkJCgkJaWYgKHJlcyA9PSAwKSB7CgkJICAgIHhtbENoYXIgKnN0ciA9IE5VTEwsICpzdHJCID0gTlVMTDsKCQkgICAgeG1sU2NoZW1hS2V5cmVmRXJyKHZjdHh0LAoJCQlYTUxfU0NIRU1BVl9DVkNfSURDLCByZWZOb2RlLAoJCQkoeG1sU2NoZW1hVHlwZVB0cikgbWF0Y2hlci0+YWlkYy0+ZGVmLAoJCQkiTm8gbWF0Y2ggZm91bmQgZm9yIGtleS1zZXF1ZW5jZSAlcyBvZiBrZXlyZWYgJyVzJyIsCgkJCXhtbFNjaGVtYUZvcm1hdElEQ0tleVNlcXVlbmNlKHZjdHh0LCAmc3RyLAoJCQkgICAgcmVmTm9kZS0+a2V5cywgbmJGaWVsZHMpLAoJCQl4bWxTY2hlbWFHZXRDb21wb25lbnRRTmFtZSgmc3RyQiwgbWF0Y2hlci0+YWlkYy0+ZGVmKSk7CgkJICAgIEZSRUVfQU5EX05VTEwoc3RyKTsKCQkgICAgRlJFRV9BTkRfTlVMTChzdHJCKTsKCQl9CgkgICAgfQoJfQoJbWF0Y2hlciA9IG1hdGNoZXItPm5leHQ7CiAgICB9CiAgICAvKiBUT0RPOiBSZXR1cm4gYW4gZXJyb3IgaWYgYW55IGVycm9yIGVuY291bnRlcmVkLiAqLwogICAgcmV0dXJuICgwKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJCVhNTCBSZWFkZXIgdmFsaWRhdGlvbiBjb2RlICAgICAgICAgICAgICAgICAgICAgICoKICogCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIHhtbFNjaGVtYUF0dHJJbmZvUHRyCnhtbFNjaGVtYUdldEZyZXNoQXR0ckluZm8oeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7CiAgICB4bWxTY2hlbWFBdHRySW5mb1B0ciBpYXR0cjsKICAgIC8qCiAgICAqIEdyb3cvY3JlYXRlIGxpc3Qgb2YgYXR0cmlidXRlIGluZm9zLgogICAgKi8KICAgIGlmICh2Y3R4dC0+YXR0ckluZm9zID09IE5VTEwpIHsKCXZjdHh0LT5hdHRySW5mb3MgPSAoeG1sU2NoZW1hQXR0ckluZm9QdHIgKikKCSAgICB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYUF0dHJJbmZvUHRyKSk7Cgl2Y3R4dC0+c2l6ZUF0dHJJbmZvcyA9IDE7CglpZiAodmN0eHQtPmF0dHJJbmZvcyA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hVkVyck1lbW9yeSh2Y3R4dCwKCQkiYWxsb2NhdGluZyBhdHRyaWJ1dGUgaW5mbyBsaXN0IiwgTlVMTCk7CgkgICAgcmV0dXJuIChOVUxMKTsKCX0KICAgIH0gZWxzZSBpZiAodmN0eHQtPnNpemVBdHRySW5mb3MgPD0gdmN0eHQtPm5iQXR0ckluZm9zKSB7Cgl2Y3R4dC0+c2l6ZUF0dHJJbmZvcysrOwoJdmN0eHQtPmF0dHJJbmZvcyA9ICh4bWxTY2hlbWFBdHRySW5mb1B0ciAqKQoJICAgIHhtbFJlYWxsb2ModmN0eHQtPmF0dHJJbmZvcywKCQl2Y3R4dC0+c2l6ZUF0dHJJbmZvcyAqIHNpemVvZih4bWxTY2hlbWFBdHRySW5mb1B0cikpOwoJaWYgKHZjdHh0LT5hdHRySW5mb3MgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVZFcnJNZW1vcnkodmN0eHQsCgkJInJlLWFsbG9jYXRpbmcgYXR0cmlidXRlIGluZm8gbGlzdCIsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9CiAgICB9IGVsc2UgewoJaWF0dHIgPSB2Y3R4dC0+YXR0ckluZm9zW3ZjdHh0LT5uYkF0dHJJbmZvcysrXTsKCWlmIChpYXR0ci0+bG9jYWxOYW1lICE9IE5VTEwpIHsKCSAgICBWRVJST1JfSU5UKCJ4bWxTY2hlbWFHZXRGcmVzaEF0dHJJbmZvIiwKCQkiYXR0ciBpbmZvIG5vdCBjbGVhcmVkIik7CgkgICAgcmV0dXJuIChOVUxMKTsKCX0KCWlhdHRyLT5ub2RlVHlwZSA9IFhNTF9BVFRSSUJVVEVfTk9ERTsKCXJldHVybiAoaWF0dHIpOwogICAgfQogICAgLyoKICAgICogQ3JlYXRlIGFuIGF0dHJpYnV0ZSBpbmZvLgogICAgKi8KICAgIGlhdHRyID0gKHhtbFNjaGVtYUF0dHJJbmZvUHRyKQoJeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFBdHRySW5mbykpOwogICAgaWYgKGlhdHRyID09IE5VTEwpIHsKCXhtbFNjaGVtYVZFcnJNZW1vcnkodmN0eHQsICJjcmVhdGluZyBuZXcgYXR0cmlidXRlIGluZm8iLCBOVUxMKTsKCXJldHVybiAoTlVMTCk7CiAgICB9CiAgICBtZW1zZXQoaWF0dHIsIDAsIHNpemVvZih4bWxTY2hlbWFBdHRySW5mbykpOwogICAgaWF0dHItPm5vZGVUeXBlID0gWE1MX0FUVFJJQlVURV9OT0RFOwogICAgdmN0eHQtPmF0dHJJbmZvc1t2Y3R4dC0+bmJBdHRySW5mb3MrK10gPSBpYXR0cjsKCiAgICByZXR1cm4gKGlhdHRyKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFWYWxpZGF0b3JQdXNoQXR0cmlidXRlKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJeG1sTm9kZVB0ciBhdHRyTm9kZSwKCQkJaW50IG5vZGVMaW5lLAoJCQljb25zdCB4bWxDaGFyICpsb2NhbE5hbWUsCgkJCWNvbnN0IHhtbENoYXIgKm5zTmFtZSwJCQkKCQkJaW50IG93bmVkTmFtZXMsCgkJCXhtbENoYXIgKnZhbHVlLAoJCQlpbnQgb3duZWRWYWx1ZSkKewogICAgeG1sU2NoZW1hQXR0ckluZm9QdHIgYXR0cjsKCiAgICBhdHRyID0geG1sU2NoZW1hR2V0RnJlc2hBdHRySW5mbyh2Y3R4dCk7CiAgICBpZiAoYXR0ciA9PSBOVUxMKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFQdXNoQXR0cmlidXRlIiwKCSAgICAiY2FsbGluZyB4bWxTY2hlbWFHZXRGcmVzaEF0dHJJbmZvKCkiKTsKCXJldHVybiAoLTEpOwogICAgfQogICAgYXR0ci0+bm9kZSA9IGF0dHJOb2RlOwogICAgYXR0ci0+bm9kZUxpbmUgPSBub2RlTGluZTsKICAgIGF0dHItPnN0YXRlID0gWE1MX1NDSEVNQVNfQVRUUl9VTktOT1dOOwogICAgYXR0ci0+bG9jYWxOYW1lID0gbG9jYWxOYW1lOwogICAgYXR0ci0+bnNOYW1lID0gbnNOYW1lOwogICAgaWYgKG93bmVkTmFtZXMpCglhdHRyLT5mbGFncyB8PSBYTUxfU0NIRU1BX05PREVfSU5GT19GTEFHX09XTkVEX05BTUVTOwogICAgLyoKICAgICogRXZhbHVhdGUgaWYgaXQncyBhbiBYU0kgYXR0cmlidXRlLgogICAgKi8KICAgIGlmIChuc05hbWUgIT0gTlVMTCkgewoJaWYgKHhtbFN0ckVxdWFsKGxvY2FsTmFtZSwgQkFEX0NBU1QgIm5pbCIpKSB7CgkgICAgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zTmFtZSwgeG1sU2NoZW1hSW5zdGFuY2VOcykpIHsKCQlhdHRyLT5tZXRhVHlwZSA9IFhNTF9TQ0hFTUFfQVRUUl9JTkZPX01FVEFfWFNJX05JTDsJCQoJICAgIH0KCX0gZWxzZSBpZiAoeG1sU3RyRXF1YWwobG9jYWxOYW1lLCBCQURfQ0FTVCAidHlwZSIpKSB7CgkgICAgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zTmFtZSwgeG1sU2NoZW1hSW5zdGFuY2VOcykpIHsKCQlhdHRyLT5tZXRhVHlwZSA9IFhNTF9TQ0hFTUFfQVRUUl9JTkZPX01FVEFfWFNJX1RZUEU7CgkgICAgfQoJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChsb2NhbE5hbWUsIEJBRF9DQVNUICJzY2hlbWFMb2NhdGlvbiIpKSB7CgkgICAgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zTmFtZSwgeG1sU2NoZW1hSW5zdGFuY2VOcykpIHsKCQlhdHRyLT5tZXRhVHlwZSA9IFhNTF9TQ0hFTUFfQVRUUl9JTkZPX01FVEFfWFNJX1NDSEVNQV9MT0M7CgkgICAgfQoJfSBlbHNlIGlmICh4bWxTdHJFcXVhbChsb2NhbE5hbWUsIEJBRF9DQVNUICJub05hbWVzcGFjZVNjaGVtYUxvY2F0aW9uIikpIHsKCSAgICBpZiAoeG1sU3RyRXF1YWwoYXR0ci0+bnNOYW1lLCB4bWxTY2hlbWFJbnN0YW5jZU5zKSkgewoJCWF0dHItPm1ldGFUeXBlID0gWE1MX1NDSEVNQV9BVFRSX0lORk9fTUVUQV9YU0lfTk9fTlNfU0NIRU1BX0xPQzsKCSAgICB9Cgl9IGVsc2UgaWYgKHhtbFN0ckVxdWFsKGF0dHItPm5zTmFtZSwgeG1sTmFtZXNwYWNlTnMpKSB7CgkgICAgYXR0ci0+bWV0YVR5cGUgPSBYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hNTE5TOwoJfQogICAgfQogICAgYXR0ci0+dmFsdWUgPSB2YWx1ZTsKICAgIGlmIChvd25lZFZhbHVlKQoJYXR0ci0+ZmxhZ3MgfD0gWE1MX1NDSEVNQV9OT0RFX0lORk9fRkxBR19PV05FRF9WQUxVRVM7CiAgICBpZiAoYXR0ci0+bWV0YVR5cGUgIT0gMCkKCWF0dHItPnN0YXRlID0gWE1MX1NDSEVNQVNfQVRUUl9NRVRBOwogICAgcmV0dXJuICgwKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hQ2xlYXJFbGVtSW5mbyh4bWxTY2hlbWFOb2RlSW5mb1B0ciBpZWxlbSkKewogICAgaWVsZW0tPmhhc0tleXJlZnMgPSAwOwogICAgaWVsZW0tPmFwcGxpZWRYUGF0aCA9IDA7CiAgICBpZiAoaWVsZW0tPmZsYWdzICYgWE1MX1NDSEVNQV9OT0RFX0lORk9fRkxBR19PV05FRF9OQU1FUykgewoJRlJFRV9BTkRfTlVMTChpZWxlbS0+bG9jYWxOYW1lKTsKCUZSRUVfQU5EX05VTEwoaWVsZW0tPm5zTmFtZSk7CiAgICB9IGVsc2UgewoJaWVsZW0tPmxvY2FsTmFtZSA9IE5VTEw7CglpZWxlbS0+bnNOYW1lID0gTlVMTDsKICAgIH0KICAgIGlmIChpZWxlbS0+ZmxhZ3MgJiBYTUxfU0NIRU1BX05PREVfSU5GT19GTEFHX09XTkVEX1ZBTFVFUykgewoJRlJFRV9BTkRfTlVMTChpZWxlbS0+dmFsdWUpOwogICAgfSBlbHNlIHsKCWllbGVtLT52YWx1ZSA9IE5VTEw7CiAgICB9CiAgICBpZiAoaWVsZW0tPnZhbCAhPSBOVUxMKSB7CgkvKgoJKiBQU1ZJIFRPRE86IEJlIGNhcmVmdWwgbm90IHRvIGZyZWUgaXQgd2hlbiB0aGUgdmFsdWUgaXMKCSogZXhwb3NlZCB2aWEgUFNWSS4KCSovCgl4bWxTY2hlbWFGcmVlVmFsdWUoaWVsZW0tPnZhbCk7CglpZWxlbS0+dmFsID0gTlVMTDsKICAgIH0KICAgIGlmIChpZWxlbS0+aWRjTWF0Y2hlcnMgIT0gTlVMTCkgewoJLyoKCSogVVJHRU5UIE9QVElNSVpFIFRPRE86IFVzZSBhIHBvb2wgb2YgSURDIG1hdGNoZXJzLgoJKi8KCXhtbFNjaGVtYUlEQ0ZyZWVNYXRjaGVyTGlzdChpZWxlbS0+aWRjTWF0Y2hlcnMpOwoJaWVsZW0tPmlkY01hdGNoZXJzID0gTlVMTDsKICAgIH0KICAgIGlmIChpZWxlbS0+aWRjVGFibGUgIT0gTlVMTCkgewoJLyoKCSogT1BUSU1JWkUgVE9ETzogVXNlIGEgcG9vbCBvZiBJREMgdGFibGVzPz8uCgkqLwoJeG1sU2NoZW1hSURDRnJlZUlEQ1RhYmxlKGllbGVtLT5pZGNUYWJsZSk7CglpZWxlbS0+aWRjVGFibGUgPSBOVUxMOwogICAgfQogICAgaWYgKGllbGVtLT5yZWdleEN0eHQgIT0gTlVMTCkgewoJeG1sUmVnRnJlZUV4ZWNDdHh0KGllbGVtLT5yZWdleEN0eHQpOwoJaWVsZW0tPnJlZ2V4Q3R4dCA9IE5VTEw7CiAgICB9CiAgICBpZiAoaWVsZW0tPm5zQmluZGluZ3MgIT0gTlVMTCkgewoJeG1sRnJlZSgoeG1sQ2hhciAqKilpZWxlbS0+bnNCaW5kaW5ncyk7CglpZWxlbS0+bnNCaW5kaW5ncyA9IE5VTEw7CglpZWxlbS0+bmJOc0JpbmRpbmdzID0gMDsKCWllbGVtLT5zaXplTnNCaW5kaW5ncyA9IDA7CiAgICB9Cn0KCi8qKgogKiB4bWxTY2hlbWFHZXRGcmVzaEVsZW1JbmZvOgogKiBAdmN0eHQ6IHRoZSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqCiAqIENyZWF0ZXMvcmV1c2VzIGFuZCBpbml0aWFsaXplcyB0aGUgZWxlbWVudCBpbmZvIGl0ZW0gZm9yCiAqIHRoZSBjdXJyZWN0IHRyZWUgZGVwdGguCiAqCiAqIFJldHVybnMgdGhlIGVsZW1lbnQgaW5mbyBpdGVtIG9yIE5VTEwgb24gQVBJIG9yIGludGVybmFsIGVycm9ycy4KICovCnN0YXRpYyB4bWxTY2hlbWFOb2RlSW5mb1B0cgp4bWxTY2hlbWFHZXRGcmVzaEVsZW1JbmZvKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgeG1sU2NoZW1hTm9kZUluZm9QdHIgaW5mbyA9IE5VTEw7CgogICAgaWYgKHZjdHh0LT5kZXB0aCA+IHZjdHh0LT5zaXplRWxlbUluZm9zKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFHZXRGcmVzaEVsZW1JbmZvIiwKCSAgICAiaW5jb25zaXN0ZW50IGRlcHRoIGVuY291bnRlcmVkIik7CglyZXR1cm4gKE5VTEwpOwogICAgfQogICAgaWYgKHZjdHh0LT5lbGVtSW5mb3MgPT0gTlVMTCkgewoJdmN0eHQtPmVsZW1JbmZvcyA9ICh4bWxTY2hlbWFOb2RlSW5mb1B0ciAqKQoJICAgIHhtbE1hbGxvYygxMCAqIHNpemVvZih4bWxTY2hlbWFOb2RlSW5mb1B0cikpOwoJaWYgKHZjdHh0LT5lbGVtSW5mb3MgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVZFcnJNZW1vcnkodmN0eHQsCgkJImFsbG9jYXRpbmcgdGhlIGVsZW1lbnQgaW5mbyBhcnJheSIsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9CgltZW1zZXQodmN0eHQtPmVsZW1JbmZvcywgMCwgMTAgKiBzaXplb2YoeG1sU2NoZW1hTm9kZUluZm9QdHIpKTsKCXZjdHh0LT5zaXplRWxlbUluZm9zID0gMTA7CiAgICB9IGVsc2UgaWYgKHZjdHh0LT5zaXplRWxlbUluZm9zIDw9IHZjdHh0LT5kZXB0aCkgewoJaW50IGkgPSB2Y3R4dC0+c2l6ZUVsZW1JbmZvczsKCgl2Y3R4dC0+c2l6ZUVsZW1JbmZvcyAqPSAyOwoJdmN0eHQtPmVsZW1JbmZvcyA9ICh4bWxTY2hlbWFOb2RlSW5mb1B0ciAqKQoJICAgIHhtbFJlYWxsb2ModmN0eHQtPmVsZW1JbmZvcywgdmN0eHQtPnNpemVFbGVtSW5mb3MgKgoJICAgIHNpemVvZih4bWxTY2hlbWFOb2RlSW5mb1B0cikpOwoJaWYgKHZjdHh0LT5lbGVtSW5mb3MgPT0gTlVMTCkgewoJICAgIHhtbFNjaGVtYVZFcnJNZW1vcnkodmN0eHQsCgkJInJlLWFsbG9jYXRpbmcgdGhlIGVsZW1lbnQgaW5mbyBhcnJheSIsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9CgkvKgoJKiBXZSBuZWVkIHRoZSBuZXcgbWVtb3J5IHRvIGJlIE5VTExlZC4KCSogVE9ETzogVXNlIG1lbXNldCBpbnN0ZWFkPwoJKi8KCWZvciAoOyBpIDwgdmN0eHQtPnNpemVFbGVtSW5mb3M7IGkrKykKCSAgICB2Y3R4dC0+ZWxlbUluZm9zW2ldID0gTlVMTDsKICAgIH0gZWxzZQoJaW5mbyA9IHZjdHh0LT5lbGVtSW5mb3NbdmN0eHQtPmRlcHRoXTsKCiAgICBpZiAoaW5mbyA9PSBOVUxMKSB7CglpbmZvID0gKHhtbFNjaGVtYU5vZGVJbmZvUHRyKQoJICAgIHhtbE1hbGxvYyhzaXplb2YoeG1sU2NoZW1hTm9kZUluZm8pKTsKCWlmIChpbmZvID09IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFWRXJyTWVtb3J5KHZjdHh0LAoJCSJhbGxvY2F0aW5nIGFuIGVsZW1lbnQgaW5mbyIsIE5VTEwpOwoJICAgIHJldHVybiAoTlVMTCk7Cgl9Cgl2Y3R4dC0+ZWxlbUluZm9zW3ZjdHh0LT5kZXB0aF0gPSBpbmZvOwogICAgfSBlbHNlIHsKCWlmIChpbmZvLT5sb2NhbE5hbWUgIT0gTlVMTCkgewoJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYUdldEZyZXNoRWxlbUluZm8iLAoJCSJlbGVtIGluZm8gaGFzIG5vdCBiZWVuIGNsZWFyZWQiKTsKCSAgICByZXR1cm4gKE5VTEwpOwoJfQogICAgfQogICAgbWVtc2V0KGluZm8sIDAsIHNpemVvZih4bWxTY2hlbWFOb2RlSW5mbykpOwogICAgaW5mby0+bm9kZVR5cGUgPSBYTUxfRUxFTUVOVF9OT0RFOwogICAgaW5mby0+ZGVwdGggPSB2Y3R4dC0+ZGVwdGg7CgogICAgcmV0dXJuIChpbmZvKTsKfQoKI2RlZmluZSBBQ1RJVkFURV9BVFRSSUJVVEUoaXRlbSkgdmN0eHQtPmlub2RlID0gKHhtbFNjaGVtYU5vZGVJbmZvUHRyKSBpdGVtOwojZGVmaW5lIEFDVElWQVRFX0VMRU0gdmN0eHQtPmlub2RlID0gdmN0eHQtPmVsZW1JbmZvc1t2Y3R4dC0+ZGVwdGhdOwojZGVmaW5lIEFDVElWQVRFX1BBUkVOVF9FTEVNIHZjdHh0LT5pbm9kZSA9IHZjdHh0LT5lbGVtSW5mb3NbdmN0eHQtPmRlcHRoIC0xXTsKCnN0YXRpYyBpbnQKeG1sU2NoZW1hVmFsaWRhdGVGYWNldHMoeG1sU2NoZW1hQWJzdHJhY3RDdHh0UHRyIGFjdHh0LAoJCQl4bWxOb2RlUHRyIG5vZGUsCgkJCXhtbFNjaGVtYVR5cGVQdHIgdHlwZSwKCQkJeG1sU2NoZW1hVmFsVHlwZSB2YWxUeXBlLAoJCQljb25zdCB4bWxDaGFyICogdmFsdWUsCgkJCXhtbFNjaGVtYVZhbFB0ciB2YWwsCgkJCXVuc2lnbmVkIGxvbmcgbGVuZ3RoLAoJCQlpbnQgZmlyZUVycm9ycykKewogICAgaW50IHJldCwgZXJyb3IgPSAwOwoKICAgIHhtbFNjaGVtYVR5cGVQdHIgdG1wVHlwZTsKICAgIHhtbFNjaGVtYUZhY2V0TGlua1B0ciBmYWNldExpbms7CiAgICB4bWxTY2hlbWFGYWNldFB0ciBmYWNldDsKICAgIHVuc2lnbmVkIGxvbmcgbGVuID0gMDsKICAgIHhtbFNjaGVtYVdoaXRlc3BhY2VWYWx1ZVR5cGUgd3M7CgogICAgLyoKICAgICogSW4gTGlieG1sMiwgZGVyaXZlZCBidWlsdC1pbiB0eXBlcyBoYXZlIGN1cnJlbnRseSBubyBleHBsaWNpdCBmYWNldHMuCiAgICAqLwogICAgaWYgKHR5cGUtPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKQoJcmV0dXJuICgwKTsKCiAgICAvKgogICAgKiBOT1RFOiBEbyBub3QganVtcCBhd2F5LCBpZiB0aGUgZmFjZXRTZXQgb2YgdGhlIGdpdmVuIHR5cGUgaXMKICAgICogZW1wdHk6IHVudGlsIG5vdywgInBhdHRlcm4iIGFuZCAiZW51bWVyYXRpb24iIGZhY2V0cyBvZiB0aGUKICAgICogKmJhc2UgdHlwZXMqIG5lZWQgdG8gYmUgY2hlY2tlZCBhcyB3ZWxsLgogICAgKi8KICAgIGlmICh0eXBlLT5mYWNldFNldCA9PSBOVUxMKQoJZ290byBwYXR0ZXJuX2FuZF9lbnVtOwoKICAgIGlmICghIFdYU19JU19BVE9NSUModHlwZSkpIHsKCWlmIChXWFNfSVNfTElTVCh0eXBlKSkKCSAgICBnb3RvIFdYU19JU19MSVNUOwoJZWxzZQoJICAgIGdvdG8gcGF0dGVybl9hbmRfZW51bTsKICAgIH0KICAgIC8qCiAgICAqIFdoaXRlc3BhY2UgaGFuZGxpbmcgaXMgb25seSBvZiBpbXBvcnRhbmNlIGZvciBzdHJpbmctYmFzZWQKICAgICogdHlwZXMuCiAgICAqLwogICAgdG1wVHlwZSA9IHhtbFNjaGVtYUdldFByaW1pdGl2ZVR5cGUodHlwZSk7CiAgICBpZiAoKHRtcFR5cGUtPmJ1aWx0SW5UeXBlID09IFhNTF9TQ0hFTUFTX1NUUklORykgfHwKCVdYU19JU19BTllfU0lNUExFX1RZUEUodG1wVHlwZSkpIHsKCXdzID0geG1sU2NoZW1hR2V0V2hpdGVTcGFjZUZhY2V0VmFsdWUodHlwZSk7CiAgICB9IGVsc2UKCXdzID0gWE1MX1NDSEVNQV9XSElURVNQQUNFX0NPTExBUFNFOwogICAgLyoKICAgICogSWYgdGhlIHZhbHVlIHdhcyBub3QgY29tcHV0ZWQgKGZvciBzdHJpbmcgb3IKICAgICogYW55U2ltcGxlVHlwZSBiYXNlZCB0eXBlcyksIHRoZW4gdXNlIHRoZSBwcm92aWRlZAogICAgKiB0eXBlLgogICAgKi8KICAgIGlmICh2YWwgPT0gTlVMTCkKCXZhbFR5cGUgPSB2YWxUeXBlOwogICAgZWxzZQoJdmFsVHlwZSA9IHhtbFNjaGVtYUdldFZhbFR5cGUodmFsKTsKICAgIAogICAgcmV0ID0gMDsKICAgIGZvciAoZmFjZXRMaW5rID0gdHlwZS0+ZmFjZXRTZXQ7IGZhY2V0TGluayAhPSBOVUxMOwoJZmFjZXRMaW5rID0gZmFjZXRMaW5rLT5uZXh0KSB7CgkvKgoJKiBTa2lwIHRoZSBwYXR0ZXJuICJ3aGl0ZVNwYWNlIjogaXQgaXMgdXNlZCB0bwoJKiBmb3JtYXQgdGhlIGNoYXJhY3RlciBjb250ZW50IGJlZm9yZWhhbmQuCgkqLwoJc3dpdGNoIChmYWNldExpbmstPmZhY2V0LT50eXBlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1dISVRFU1BBQ0U6CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX1BBVFRFUk46CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX0VOVU1FUkFUSU9OOgoJCWNvbnRpbnVlOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9MRU5HVEg6CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkxFTkdUSDoKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIOgoJCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlTGVuZ3RoRmFjZXRXaHRzcChmYWNldExpbmstPmZhY2V0LAoJCSAgICB2YWxUeXBlLCB2YWx1ZSwgdmFsLCAmbGVuLCB3cyk7CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlyZXQgPSB4bWxTY2hlbWFWYWxpZGF0ZUZhY2V0V2h0c3AoZmFjZXRMaW5rLT5mYWNldCwgd3MsCgkJICAgIHZhbFR5cGUsIHZhbHVlLCB2YWwsIHdzKTsKCQlicmVhazsKCX0KCWlmIChyZXQgPCAwKSB7CgkgICAgQUVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVGYWNldHMiLAoJCSJ2YWxpZGF0aW5nIGFnYWluc3QgYSBhdG9taWMgdHlwZSBmYWNldCIpOwoJICAgIHJldHVybiAoLTEpOwoJfSBlbHNlIGlmIChyZXQgPiAwKSB7CgkgICAgaWYgKGZpcmVFcnJvcnMpCgkJeG1sU2NoZW1hRmFjZXRFcnIoYWN0eHQsIHJldCwgbm9kZSwKCQl2YWx1ZSwgbGVuLCB0eXBlLCBmYWNldExpbmstPmZhY2V0LCBOVUxMLCBOVUxMLCBOVUxMKTsKCSAgICBlbHNlCgkJcmV0dXJuIChyZXQpOwoJICAgIGlmIChlcnJvciA9PSAwKQoJCWVycm9yID0gcmV0OwoJfQoJcmV0ID0gMDsKICAgIH0KCldYU19JU19MSVNUOgogICAgaWYgKCEgV1hTX0lTX0xJU1QodHlwZSkpCglnb3RvIHBhdHRlcm5fYW5kX2VudW07CiAgICAvKgogICAgKiAibGVuZ3RoIiwgIm1pbkxlbmd0aCIgYW5kICJtYXhMZW5ndGgiIG9mIGxpc3QgdHlwZXMuCiAgICAqLwogICAgcmV0ID0gMDsKICAgIGZvciAoZmFjZXRMaW5rID0gdHlwZS0+ZmFjZXRTZXQ7IGZhY2V0TGluayAhPSBOVUxMOwoJZmFjZXRMaW5rID0gZmFjZXRMaW5rLT5uZXh0KSB7CgkKCXN3aXRjaCAoZmFjZXRMaW5rLT5mYWNldC0+dHlwZSkgewoJICAgIGNhc2UgWE1MX1NDSEVNQV9GQUNFVF9MRU5HVEg6CgkgICAgY2FzZSBYTUxfU0NIRU1BX0ZBQ0VUX01JTkxFTkdUSDoKCSAgICBjYXNlIFhNTF9TQ0hFTUFfRkFDRVRfTUFYTEVOR1RIOgkJICAgIAoJCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlTGlzdFNpbXBsZVR5cGVGYWNldChmYWNldExpbmstPmZhY2V0LAoJCSAgICB2YWx1ZSwgbGVuZ3RoLCBOVUxMKTsKCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCWNvbnRpbnVlOwoJfQoJaWYgKHJldCA8IDApIHsKCSAgICBBRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUZhY2V0cyIsCgkJInZhbGlkYXRpbmcgYWdhaW5zdCBhIGxpc3QgdHlwZSBmYWNldCIpOwoJICAgIHJldHVybiAoLTEpOwoJfSBlbHNlIGlmIChyZXQgPiAwKSB7CgkgICAgaWYgKGZpcmVFcnJvcnMpCQkKCQl4bWxTY2hlbWFGYWNldEVycihhY3R4dCwgcmV0LCBub2RlLAoJCXZhbHVlLCBsZW5ndGgsIHR5cGUsIGZhY2V0TGluay0+ZmFjZXQsIE5VTEwsIE5VTEwsIE5VTEwpOwoJICAgIGVsc2UKCQlyZXR1cm4gKHJldCk7CgkgICAgaWYgKGVycm9yID09IDApCgkJZXJyb3IgPSByZXQ7Cgl9CglyZXQgPSAwOwogICAgfQoKcGF0dGVybl9hbmRfZW51bToKICAgIGlmIChlcnJvciA+PSAwKSB7CglpbnQgZm91bmQgPSAwOwoJLyoKCSogUHJvY2VzcyBlbnVtZXJhdGlvbnMuIEZhY2V0IHZhbHVlcyBhcmUgaW4gdGhlIHZhbHVlIHNwYWNlCgkqIG9mIHRoZSBkZWZpbmluZyB0eXBlJ3MgYmFzZSB0eXBlLiBUaGlzIHNlZW1zIHRvIGJlIGEgYnVnIGluIHRoZQoJKiBYTUwgU2NoZW1hIDEuMCBzcGVjLiBVc2UgdGhlIHdoaXRlc3BhY2UgdHlwZSBvZiB0aGUgYmFzZSB0eXBlLgoJKiBPbmx5IHRoZSBmaXJzdCBzZXQgb2YgZW51bWVyYXRpb25zIGluIHRoZSBhbmNlc3Rvci1vci1zZWxmIGF4aXMKCSogaXMgdXNlZCBmb3IgdmFsaWRhdGlvbi4KCSovCglyZXQgPSAwOwoJdG1wVHlwZSA9IHR5cGU7CglkbyB7CgkgICAgZm9yIChmYWNldCA9IHRtcFR5cGUtPmZhY2V0czsgZmFjZXQgIT0gTlVMTDsgZmFjZXQgPSBmYWNldC0+bmV4dCkgewoJCWlmIChmYWNldC0+dHlwZSAhPSBYTUxfU0NIRU1BX0ZBQ0VUX0VOVU1FUkFUSU9OKQoJCSAgICBjb250aW51ZTsKCQlmb3VuZCA9IDE7CgkJcmV0ID0geG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoZmFjZXQtPnZhbCwgdmFsKTsKCQlpZiAocmV0ID09IDEpCgkJICAgIGJyZWFrOwoJCWVsc2UgaWYgKHJldCA8IDApIHsKCQkgICAgQUVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVGYWNldHMiLAoJCQkidmFsaWRhdGluZyBhZ2FpbnN0IGFuIGVudW1lcmF0aW9uIGZhY2V0Iik7CgkJICAgIHJldHVybiAoLTEpOwoJCX0KCSAgICB9CgkgICAgaWYgKHJldCAhPSAwKQoJCWJyZWFrOwoJICAgIHRtcFR5cGUgPSB0bXBUeXBlLT5iYXNlVHlwZTsKCX0gd2hpbGUgKCh0bXBUeXBlICE9IE5VTEwpICYmCgkgICAgKHRtcFR5cGUtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKSk7CglpZiAoZm91bmQgJiYgKHJldCA9PSAwKSkgewoJICAgIHJldCA9IFhNTF9TQ0hFTUFWX0NWQ19FTlVNRVJBVElPTl9WQUxJRDsKCSAgICBpZiAoZmlyZUVycm9ycykgewoJCXhtbFNjaGVtYUZhY2V0RXJyKGFjdHh0LCByZXQsIG5vZGUsCgkJICAgIHZhbHVlLCAwLCB0eXBlLCBOVUxMLCBOVUxMLCBOVUxMLCBOVUxMKTsKCSAgICB9IGVsc2UKCQlyZXR1cm4gKHJldCk7CgkgICAgaWYgKGVycm9yID09IDApCgkJZXJyb3IgPSByZXQ7Cgl9CiAgICB9CgogICAgaWYgKGVycm9yID49IDApIHsKCWludCBmb3VuZDsKCS8qCgkqIFByb2Nlc3MgcGF0dGVycy4gUGF0dGVybiBmYWNldHMgYXJlIE9SZWQgYXQgdHlwZSBsZXZlbAoJKiBhbmQgQU5EZWQgaWYgZGVyaXZlZC4gV2FsayB0aGUgYmFzZSB0eXBlIGF4aXMuCgkqLwoJdG1wVHlwZSA9IHR5cGU7CglmYWNldCA9IE5VTEw7CglkbyB7CgkgICAgZm91bmQgPSAwOwoJICAgIGZvciAoZmFjZXRMaW5rID0gdG1wVHlwZS0+ZmFjZXRTZXQ7IGZhY2V0TGluayAhPSBOVUxMOwoJCWZhY2V0TGluayA9IGZhY2V0TGluay0+bmV4dCkgewoJCWlmIChmYWNldExpbmstPmZhY2V0LT50eXBlICE9IFhNTF9TQ0hFTUFfRkFDRVRfUEFUVEVSTikKCQkgICAgY29udGludWU7CgkJZm91bmQgPSAxOwoJCS8qIAoJCSogTk9URSB0aGF0IGZvciBwYXR0ZXJucywgQHZhbHVlIG5lZWRzIHRvIGJlIHRoZQoJCSogbm9ybWFsaXplZCB2YXVsZS4KCQkqLwoJCXJldCA9IHhtbFJlZ2V4cEV4ZWMoZmFjZXRMaW5rLT5mYWNldC0+cmVnZXhwLCB2YWx1ZSk7CgkJaWYgKHJldCA9PSAxKQoJCSAgICBicmVhazsKCQllbHNlIGlmIChyZXQgPCAwKSB7CgkJICAgIEFFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRlRmFjZXRzIiwKCQkJInZhbGlkYXRpbmcgYWdhaW5zdCBhIHBhdHRlcm4gZmFjZXQiKTsKCQkgICAgcmV0dXJuICgtMSk7CgkJfSBlbHNlIHsKCQkgICAgLyogCgkJICAgICogU2F2ZSB0aGUgbGFzdCBub24tdmFsaWRhdGluZyBmYWNldC4KCQkgICAgKi8KCQkgICAgZmFjZXQgPSBmYWNldExpbmstPmZhY2V0OwoJCX0KCSAgICB9CgkgICAgaWYgKGZvdW5kICYmIChyZXQgIT0gMSkpIHsKCQlyZXQgPSBYTUxfU0NIRU1BVl9DVkNfUEFUVEVSTl9WQUxJRDsKCQlpZiAoZmlyZUVycm9ycykgewoJCSAgICB4bWxTY2hlbWFGYWNldEVycihhY3R4dCwgcmV0LCBub2RlLAoJCQl2YWx1ZSwgMCwgdHlwZSwgZmFjZXQsIE5VTEwsIE5VTEwsIE5VTEwpOwoJCX0gZWxzZQoJCSAgICByZXR1cm4gKHJldCk7CgkJaWYgKGVycm9yID09IDApCgkJICAgIGVycm9yID0gcmV0OwoJCWJyZWFrOwoJICAgIH0KCSAgICB0bXBUeXBlID0gdG1wVHlwZS0+YmFzZVR5cGU7Cgl9IHdoaWxlICgodG1wVHlwZSAhPSBOVUxMKSAmJiAodG1wVHlwZS0+dHlwZSAhPSBYTUxfU0NIRU1BX1RZUEVfQkFTSUMpKTsKICAgIH0KCiAgICByZXR1cm4gKGVycm9yKTsKfQogCnN0YXRpYyB4bWxDaGFyICoKeG1sU2NoZW1hTm9ybWFsaXplVmFsdWUoeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQljb25zdCB4bWxDaGFyICp2YWx1ZSkKewogICAgc3dpdGNoICh4bWxTY2hlbWFHZXRXaGl0ZVNwYWNlRmFjZXRWYWx1ZSh0eXBlKSkgewkKCWNhc2UgWE1MX1NDSEVNQV9XSElURVNQQUNFX0NPTExBUFNFOgoJICAgIHJldHVybiAoeG1sU2NoZW1hQ29sbGFwc2VTdHJpbmcodmFsdWUpKTsKCWNhc2UgWE1MX1NDSEVNQV9XSElURVNQQUNFX1JFUExBQ0U6CgkgICAgcmV0dXJuICh4bWxTY2hlbWFXaGl0ZVNwYWNlUmVwbGFjZSh2YWx1ZSkpOwoJZGVmYXVsdDoKCSAgICByZXR1cm4gKE5VTEwpOwogICAgfQp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVZhbGlkYXRlUU5hbWUoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0LAoJCSAgICAgICBjb25zdCB4bWxDaGFyICp2YWx1ZSwKCQkgICAgICAgeG1sU2NoZW1hVmFsUHRyICp2YWwsCgkJICAgICAgIGludCB2YWxOZWVkZWQpCnsKICAgIGludCByZXQ7CiAgICBjb25zdCB4bWxDaGFyICpuc05hbWU7CiAgICB4bWxDaGFyICpsb2NhbCwgKnByZWZpeCA9IE5VTEw7CiAgICAKICAgIHJldCA9IHhtbFZhbGlkYXRlUU5hbWUodmFsdWUsIDEpOwogICAgaWYgKHJldCAhPSAwKSB7CglpZiAocmV0ID09IC0xKSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVRTmFtZSIsCgkJImNhbGxpbmcgeG1sVmFsaWRhdGVRTmFtZSgpIik7CgkgICAgcmV0dXJuICgtMSk7Cgl9CglyZXR1cm4oIFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMSk7CiAgICB9CiAgICAvKgogICAgKiBOT1RFOiB4bWxTcGxpdFFOYW1lMiB3aWxsIGFsd2F5cyByZXR1cm4gYSBkdXBsaWNhdGVkCiAgICAqIHN0cmluZ3MuCiAgICAqLwogICAgbG9jYWwgPSB4bWxTcGxpdFFOYW1lMih2YWx1ZSwgJnByZWZpeCk7CiAgICBpZiAobG9jYWwgPT0gTlVMTCkKCWxvY2FsID0geG1sU3RyZHVwKHZhbHVlKTsKICAgIC8qCiAgICAqIE9QVElNSVpFIFRPRE86IFVzZSBmbGFncyBmb3I6CiAgICAqICAtIGlzIHRoZXJlIGFueSBuYW1lc3BhY2UgYmluZGluZz8KICAgICogIC0gaXMgdGhlcmUgYSBkZWZhdWx0IG5hbWVzcGFjZT8KICAgICovCiAgICBuc05hbWUgPSB4bWxTY2hlbWFMb29rdXBOYW1lc3BhY2UodmN0eHQsIHByZWZpeCk7CiAgICAKICAgIGlmIChwcmVmaXggIT0gTlVMTCkgewoJeG1sRnJlZShwcmVmaXgpOwoJLyoKCSogQSBuYW1lc3BhY2UgbXVzdCBiZSBmb3VuZCBpZiB0aGUgcHJlZml4IGlzCgkqIE5PVCBOVUxMLgoJKi8KCWlmIChuc05hbWUgPT0gTlVMTCkgewoJICAgIHJldCA9IFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMTsKCSAgICB4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCB2Y3R4dCwgcmV0LCBOVUxMLAoJCVdYU19CQVNJQ19DQVNUIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX1FOQU1FKSwKCQkiVGhlIFFOYW1lIHZhbHVlICclcycgaGFzIG5vICIKCQkiY29ycmVzcG9uZGluZyBuYW1lc3BhY2UgZGVjbGFyYXRpb24gaW4gIgoJCSJzY29wZSIsIHZhbHVlLCBOVUxMKTsKCSAgICBpZiAobG9jYWwgIT0gTlVMTCkKCQl4bWxGcmVlKGxvY2FsKTsKCSAgICByZXR1cm4gKHJldCk7Cgl9CiAgICB9CiAgICBpZiAodmFsTmVlZGVkICYmIHZhbCkgewoJaWYgKG5zTmFtZSAhPSBOVUxMKQoJICAgICp2YWwgPSB4bWxTY2hlbWFOZXdRTmFtZVZhbHVlKAoJCUJBRF9DQVNUIHhtbFN0cmR1cChuc05hbWUpLCBCQURfQ0FTVCBsb2NhbCk7CgllbHNlCgkgICAgKnZhbCA9IHhtbFNjaGVtYU5ld1FOYW1lVmFsdWUoTlVMTCwKCQlCQURfQ0FTVCBsb2NhbCk7CiAgICB9IGVsc2UKCXhtbEZyZWUobG9jYWwpOwogICAgcmV0dXJuICgwKTsKfQoKLyoKKiBjdmMtc2ltcGxlLXR5cGUKKi8Kc3RhdGljIGludAp4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKHhtbFNjaGVtYUFic3RyYWN0Q3R4dFB0ciBhY3R4dCwKCQkJICAgICB4bWxOb2RlUHRyIG5vZGUsCgkJCSAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQkgICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkgICAgIHhtbFNjaGVtYVZhbFB0ciAqcmV0VmFsLAoJCQkgICAgIGludCBmaXJlRXJyb3JzLAoJCQkgICAgIGludCBub3JtYWxpemUsCgkJCSAgICAgaW50IGlzTm9ybWFsaXplZCkKewogICAgaW50IHJldCA9IDAsIHZhbE5lZWRlZCA9IChyZXRWYWwpID8gMSA6IDA7CiAgICB4bWxTY2hlbWFWYWxQdHIgdmFsID0gTlVMTDsKICAgIC8qIHhtbFNjaGVtYVdoaXRlc3BhY2VWYWx1ZVR5cGUgd3M7ICovCiAgICB4bWxDaGFyICpub3JtVmFsdWUgPSBOVUxMOwoKI2RlZmluZSBOT1JNQUxJWkUoYXR5cGUpIFwKICAgIGlmICgoISBpc05vcm1hbGl6ZWQpICYmIFwKICAgIChub3JtYWxpemUgfHwgKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9OT1JNVkFMVUVORUVERUQpKSkgeyBcCglub3JtVmFsdWUgPSB4bWxTY2hlbWFOb3JtYWxpemVWYWx1ZShhdHlwZSwgdmFsdWUpOyBcCglpZiAobm9ybVZhbHVlICE9IE5VTEwpIFwKCSAgICB2YWx1ZSA9IG5vcm1WYWx1ZTsgXAoJaXNOb3JtYWxpemVkID0gMTsgXAogICAgfQogICAgCiAgICBpZiAoKHJldFZhbCAhPSBOVUxMKSAmJiAoKnJldFZhbCAhPSBOVUxMKSkgewoJeG1sU2NoZW1hRnJlZVZhbHVlKCpyZXRWYWwpOwoJKnJldFZhbCA9IE5VTEw7CiAgICB9CiAgICAvKgogICAgKiAzLjE0LjQgU2ltcGxlIFR5cGUgRGVmaW5pdGlvbiBWYWxpZGF0aW9uIFJ1bGVzCiAgICAqIFZhbGlkYXRpb24gUnVsZTogU3RyaW5nIFZhbGlkCiAgICAqLwogICAgLyoKICAgICogMSBJdCBpcyBzY2hlbWEtdmFsaWQgd2l0aCByZXNwZWN0IHRvIHRoYXQgZGVmaW5pdGlvbiBhcyBkZWZpbmVkCiAgICAqIGJ5IERhdGF0eXBlIFZhbGlkIGluIFtYTUwgU2NoZW1hczogRGF0YXR5cGVzXS4KICAgICovCiAgICAvKgogICAgKiAyLjEgSWYgVGhlIGRlZmluaXRpb24gaXMgRU5USVRZIG9yIGlzIHZhbGlkbHkgZGVyaXZlZCBmcm9tIEVOVElUWSBnaXZlbgogICAgKiB0aGUgZW1wdHkgc2V0LCBhcyBkZWZpbmVkIGluIFR5cGUgRGVyaXZhdGlvbiBPSyAoU2ltcGxlKSAopzMuMTQuNiksIHRoZW4KICAgICogdGhlIHN0cmluZyBtdXN0IGJlIGEgt2RlY2xhcmVkIGVudGl0eSBuYW1lty4KICAgICovCiAgICAvKgogICAgKiAyLjIgSWYgVGhlIGRlZmluaXRpb24gaXMgRU5USVRJRVMgb3IgaXMgdmFsaWRseSBkZXJpdmVkIGZyb20gRU5USVRJRVMKICAgICogZ2l2ZW4gdGhlIGVtcHR5IHNldCwgYXMgZGVmaW5lZCBpbiBUeXBlIERlcml2YXRpb24gT0sgKFNpbXBsZSkgKKczLjE0LjYpLAogICAgKiB0aGVuIGV2ZXJ5IHdoaXRlc3BhY2UtZGVsaW1pdGVkIHN1YnN0cmluZyBvZiB0aGUgc3RyaW5nIG11c3QgYmUgYSC3ZGVjbGFyZWQKICAgICogZW50aXR5IG5hbWW3LgogICAgKi8KICAgIC8qCiAgICAqIDIuMyBvdGhlcndpc2Ugbm8gZnVydGhlciBjb25kaXRpb24gYXBwbGllcy4KICAgICovCiAgICBpZiAoKCEgdmFsTmVlZGVkKSAmJiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0ZBQ0VUU05FRURWQUxVRSkpCgl2YWxOZWVkZWQgPSAxOwogICAgaWYgKHZhbHVlID09IE5VTEwpCgl2YWx1ZSA9IEJBRF9DQVNUICIiOwogICAgaWYgKFdYU19JU19BTllfU0lNUExFX1RZUEUodHlwZSkgfHwgV1hTX0lTX0FUT01JQyh0eXBlKSkgewoJeG1sU2NoZW1hVHlwZVB0ciBiaVR5cGU7IC8qIFRoZSBidWlsdC1pbiB0eXBlLiAqLwoJLyoKCSogU1BFQyAoMS4yLjEpICJpZiB7dmFyaWV0eX0gaXMgt2F0b21pY7cgdGhlbiB0aGUgc3RyaW5nIG11c3Qgt21hdGNotwoJKiBhIGxpdGVyYWwgaW4gdGhlILdsZXhpY2FsIHNwYWNltyBvZiB7YmFzZSB0eXBlIGRlZmluaXRpb259IgoJKi8KCS8qCgkqIFdoaXRlc3BhY2Utbm9ybWFsaXplLgoJKi8KCU5PUk1BTElaRSh0eXBlKTsKCWlmICh0eXBlLT50eXBlICE9IFhNTF9TQ0hFTUFfVFlQRV9CQVNJQykgewoJICAgIC8qCgkgICAgKiBHZXQgdGhlIGJ1aWx0LWluIHR5cGUuCgkgICAgKi8KCSAgICBiaVR5cGUgPSB0eXBlLT5iYXNlVHlwZTsKCSAgICB3aGlsZSAoKGJpVHlwZSAhPSBOVUxMKSAmJgoJCShiaVR5cGUtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0JBU0lDKSkKCQliaVR5cGUgPSBiaVR5cGUtPmJhc2VUeXBlOwoKCSAgICBpZiAoYmlUeXBlID09IE5VTEwpIHsKCQlBRVJST1JfSU5UKCJ4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlIiwKCQkgICAgImNvdWxkIG5vdCBnZXQgdGhlIGJ1aWx0LWluIHR5cGUiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCX0gZWxzZQoJICAgIGJpVHlwZSA9IHR5cGU7CgkvKgoJKiBOT1RBVElPTnMgbmVlZCB0byBiZSBwcm9jZXNzZWQgaGVyZSwgc2luY2UgdGhleSBuZWVkCgkqIHRvIGxvb2t1cCBpbiB0aGUgaGFzaHRhYmxlIG9mIE5PVEFUSU9OIGRlY2xhcmF0aW9ucyBvZiB0aGUgc2NoZW1hLgoJKi8KCWlmIChhY3R4dC0+dHlwZSA9PSBYTUxfU0NIRU1BX0NUWFRfVkFMSURBVE9SKSB7CSAgICAKCSAgICBzd2l0Y2ggKGJpVHlwZS0+YnVpbHRJblR5cGUpIHsJCQoJCWNhc2UgWE1MX1NDSEVNQVNfTk9UQVRJT046CQkgICAgCgkJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRlTm90YXRpb24oCgkJCSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIpIGFjdHh0LAoJCQkoKHhtbFNjaGVtYVZhbGlkQ3R4dFB0cikgYWN0eHQpLT5zY2hlbWEsCgkJCU5VTEwsIHZhbHVlLCAmdmFsLCB2YWxOZWVkZWQpOwoJCSAgICBicmVhazsKCQljYXNlIFhNTF9TQ0hFTUFTX1FOQU1FOgoJCSAgICByZXQgPSB4bWxTY2hlbWFWYWxpZGF0ZVFOYW1lKCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIpIGFjdHh0LAoJCQl2YWx1ZSwgJnZhbCwgdmFsTmVlZGVkKTsKCQkgICAgYnJlYWs7CgkJZGVmYXVsdDoKCQkgICAgLyogd3MgPSB4bWxTY2hlbWFHZXRXaGl0ZVNwYWNlRmFjZXRWYWx1ZSh0eXBlKTsgKi8KCQkgICAgaWYgKHZhbE5lZWRlZCkKCQkJcmV0ID0geG1sU2NoZW1hVmFsUHJlZGVmVHlwZU5vZGVOb05vcm0oYmlUeXBlLAoJCQkgICAgdmFsdWUsICZ2YWwsIE5VTEwpOwoJCSAgICBlbHNlCgkJCXJldCA9IHhtbFNjaGVtYVZhbFByZWRlZlR5cGVOb2RlTm9Ob3JtKGJpVHlwZSwKCQkJICAgIHZhbHVlLCBOVUxMLCBOVUxMKTsKCQkgICAgYnJlYWs7CgkgICAgfQoJfSBlbHNlIGlmIChhY3R4dC0+dHlwZSA9PSBYTUxfU0NIRU1BX0NUWFRfUEFSU0VSKSB7CSAgICAKCSAgICBzd2l0Y2ggKGJpVHlwZS0+YnVpbHRJblR5cGUpIHsJCSAgICAKCQljYXNlIFhNTF9TQ0hFTUFTX05PVEFUSU9OOgoJCSAgICByZXQgPSB4bWxTY2hlbWFWYWxpZGF0ZU5vdGF0aW9uKE5VTEwsCgkJCSgoeG1sU2NoZW1hUGFyc2VyQ3R4dFB0cikgYWN0eHQpLT5zY2hlbWEsIG5vZGUsCgkJCXZhbHVlLCAmdmFsLCB2YWxOZWVkZWQpOwoJCSAgICBicmVhazsKCQlkZWZhdWx0OgoJCSAgICAvKiB3cyA9IHhtbFNjaGVtYUdldFdoaXRlU3BhY2VGYWNldFZhbHVlKHR5cGUpOyAqLwoJCSAgICBpZiAodmFsTmVlZGVkKQoJCQlyZXQgPSB4bWxTY2hlbWFWYWxQcmVkZWZUeXBlTm9kZU5vTm9ybShiaVR5cGUsCgkJCSAgICB2YWx1ZSwgJnZhbCwgbm9kZSk7CgkJICAgIGVsc2UKCQkJcmV0ID0geG1sU2NoZW1hVmFsUHJlZGVmVHlwZU5vZGVOb05vcm0oYmlUeXBlLAoJCQkgICAgdmFsdWUsIE5VTEwsIG5vZGUpOwoJCSAgICBicmVhazsKCSAgICB9CSAgIAoJfSBlbHNlIHsKCSAgICAvKgoJICAgICogVmFsaWRhdGlvbiB2aWEgYSBwdWJsaWMgQVBJIGlzIG5vdCBpbXBsZW1lbnRlZCB5ZXQuCgkgICAgKi8KCSAgICBUT0RPCgkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCX0KCWlmIChyZXQgIT0gMCkgewoJICAgIGlmIChyZXQgPCAwKSB7CgkJQUVSUk9SX0lOVCgieG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSIsCgkJICAgICJ2YWxpZGF0aW5nIGFnYWluc3QgYSBidWlsdC1pbiB0eXBlIik7CgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICB9CgkgICAgaWYgKFdYU19JU19MSVNUKHR5cGUpKQoJCXJldCA9IFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMjsKCSAgICBlbHNlCgkJcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX0RBVEFUWVBFX1ZBTElEXzFfMl8xOwkgICAgCgl9CglpZiAoKHJldCA9PSAwKSAmJiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0hBU19GQUNFVFMpKSB7CgkgICAgLyoKCSAgICAqIENoZWNrIGZhY2V0cy4KCSAgICAqLwoJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRlRmFjZXRzKGFjdHh0LCBub2RlLCB0eXBlLAoJCSh4bWxTY2hlbWFWYWxUeXBlKSBiaVR5cGUtPmJ1aWx0SW5UeXBlLCB2YWx1ZSwgdmFsLAoJCTAsIGZpcmVFcnJvcnMpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPCAwKSB7CgkJICAgIEFFUlJPUl9JTlQoInhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUiLAoJCQkidmFsaWRhdGluZyBmYWNldHMgb2YgYXRvbWljIHNpbXBsZSB0eXBlIik7CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJCWlmIChXWFNfSVNfTElTVCh0eXBlKSkgCgkJICAgIHJldCA9IFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMjsKCQllbHNlCgkJICAgIHJldCA9IFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMTsJCQoJICAgIH0KCX0KCWlmIChmaXJlRXJyb3JzICYmIChyZXQgPiAwKSkKCSAgICB4bWxTY2hlbWFTaW1wbGVUeXBlRXJyKGFjdHh0LCByZXQsIG5vZGUsIHZhbHVlLCB0eXBlLCAxKTsKICAgIH0gZWxzZSBpZiAoV1hTX0lTX0xJU1QodHlwZSkpIHsKCgl4bWxTY2hlbWFUeXBlUHRyIGl0ZW1UeXBlOwoJY29uc3QgeG1sQ2hhciAqY3VyLCAqZW5kOwoJeG1sQ2hhciAqdG1wVmFsdWUgPSBOVUxMOwoJdW5zaWduZWQgbG9uZyBsZW4gPSAwOwoJeG1sU2NoZW1hVmFsUHRyIHByZXZWYWwgPSBOVUxMLCBjdXJWYWwgPSBOVUxMOwoJLyogMS4yLjIgaWYge3ZhcmlldHl9IGlzILdsaXN0tyB0aGVuIHRoZSBzdHJpbmcgbXVzdCBiZSBhIHNlcXVlbmNlCgkqIG9mIHdoaXRlIHNwYWNlIHNlcGFyYXRlZCB0b2tlbnMsIGVhY2ggb2Ygd2hpY2ggt21hdGNot2VzIGEgbGl0ZXJhbAoJKiBpbiB0aGUgt2xleGljYWwgc3BhY2W3IG9mIHtpdGVtIHR5cGUgZGVmaW5pdGlvbn0KCSovCgkvKgoJKiBOb3RlIHRoYXQgWE1MX1NDSEVNQVNfVFlQRV9OT1JNVkFMVUVORUVERUQgd2lsbCBiZSBzZXQgaWYKCSogdGhlIGxpc3QgdHlwZSBoYXMgYW4gZW51bSBvciBwYXR0ZXJuIGZhY2V0LgoJKi8KCU5PUk1BTElaRSh0eXBlKTsKCS8qCgkqIFZBTCBUT0RPOiBPcHRpbWl6ZSB2YWxpZGF0aW9uIG9mIGVtcHR5IHZhbHVlcy4KCSogVkFMIFRPRE86IFdlIGRvIG5vdCBoYXZlIGNvbXB1dGVkIHZhbHVlcyBmb3IgbGlzdHMuCgkqLwoJaXRlbVR5cGUgPSBXWFNfTElTVF9JVEVNVFlQRSh0eXBlKTsJCgljdXIgPSB2YWx1ZTsKCWRvIHsKCSAgICB3aGlsZSAoSVNfQkxBTktfQ0goKmN1cikpCgkJY3VyKys7CgkgICAgZW5kID0gY3VyOwoJICAgIHdoaWxlICgoKmVuZCAhPSAwKSAmJiAoIShJU19CTEFOS19DSCgqZW5kKSkpKQoJCWVuZCsrOwoJICAgIGlmIChlbmQgPT0gY3VyKQoJCWJyZWFrOwoJICAgIHRtcFZhbHVlID0geG1sU3RybmR1cChjdXIsIGVuZCAtIGN1cik7CgkgICAgbGVuKys7CgoJICAgIGlmICh2YWxOZWVkZWQpCgkJcmV0ID0geG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZShhY3R4dCwgbm9kZSwgaXRlbVR5cGUsCgkJICAgIHRtcFZhbHVlLCAmY3VyVmFsLCBmaXJlRXJyb3JzLCAwLCAxKTsKCSAgICBlbHNlCgkJcmV0ID0geG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZShhY3R4dCwgbm9kZSwgaXRlbVR5cGUsCgkJICAgIHRtcFZhbHVlLCBOVUxMLCBmaXJlRXJyb3JzLCAwLCAxKTsKCSAgICBGUkVFX0FORF9OVUxMKHRtcFZhbHVlKTsKCSAgICBpZiAoY3VyVmFsICE9IE5VTEwpIHsKCQkvKgoJCSogQWRkIHRvIGxpc3Qgb2YgY29tcHV0ZWQgdmFsdWVzLgoJCSovCgkJaWYgKHZhbCA9PSBOVUxMKQoJCSAgICB2YWwgPSBjdXJWYWw7CgkJZWxzZQoJCSAgICB4bWxTY2hlbWFWYWx1ZUFwcGVuZChwcmV2VmFsLCBjdXJWYWwpOwoJCXByZXZWYWwgPSBjdXJWYWw7CgkJY3VyVmFsID0gTlVMTDsKCSAgICB9CgkgICAgaWYgKHJldCAhPSAwKSB7CgkJaWYgKHJldCA8IDApIHsKCQkgICAgQUVSUk9SX0lOVCgieG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSIsCgkJCSJ2YWxpZGF0aW5nIGFuIGl0ZW0gb2YgbGlzdCBzaW1wbGUgdHlwZSIpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KCQlyZXQgPSBYTUxfU0NIRU1BVl9DVkNfREFUQVRZUEVfVkFMSURfMV8yXzI7CgkJYnJlYWs7CgkgICAgfQkgICAgCgkgICAgY3VyID0gZW5kOwoJfSB3aGlsZSAoKmN1ciAhPSAwKTsKCUZSRUVfQU5EX05VTEwodG1wVmFsdWUpOwoJaWYgKChyZXQgPT0gMCkgJiYgKHR5cGUtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9IQVNfRkFDRVRTKSkgewoJICAgIC8qCgkgICAgKiBBcHBseSBmYWNldHMgKHBhdHRlcm4sIGVudW1lcmF0aW9uKS4KCSAgICAqLwoJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRlRmFjZXRzKGFjdHh0LCBub2RlLCB0eXBlLAoJCVhNTF9TQ0hFTUFTX1VOS05PV04sIHZhbHVlLCB2YWwsCgkJbGVuLCBmaXJlRXJyb3JzKTsKCSAgICBpZiAocmV0ICE9IDApIHsKCQlpZiAocmV0IDwgMCkgewoJCSAgICBBRVJST1JfSU5UKCJ4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlIiwKCQkJInZhbGlkYXRpbmcgZmFjZXRzIG9mIGxpc3Qgc2ltcGxlIHR5cGUiKTsKCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCQl9CgkJcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX0RBVEFUWVBFX1ZBTElEXzFfMl8yOwoJICAgIH0KCX0KCWlmIChmaXJlRXJyb3JzICYmIChyZXQgPiAwKSkgewoJICAgIC8qIAoJICAgICogUmVwb3J0IHRoZSBub3JtYWxpemVkIHZhbHVlLgoJICAgICovCgkgICAgbm9ybWFsaXplID0gMTsKCSAgICBOT1JNQUxJWkUodHlwZSk7CgkgICAgeG1sU2NoZW1hU2ltcGxlVHlwZUVycihhY3R4dCwgcmV0LCBub2RlLCB2YWx1ZSwgdHlwZSwgMSk7Cgl9CiAgICB9IGVsc2UgaWYgKFdYU19JU19VTklPTih0eXBlKSkgewoJeG1sU2NoZW1hVHlwZUxpbmtQdHIgbWVtYmVyTGluazsKCS8qCgkqIFRPRE86IEZvciBhbGwgZGF0YXR5cGVzILdkZXJpdmVktyBieSC3dW5pb263ICB3aGl0ZVNwYWNlIGRvZXMKCSogbm90IGFwcGx5IGRpcmVjdGx5OyBob3dldmVyLCB0aGUgbm9ybWFsaXphdGlvbiBiZWhhdmlvciBvZiC3dW5pb263CgkqIHR5cGVzIGlzIGNvbnRyb2xsZWQgYnkgdGhlIHZhbHVlIG9mIHdoaXRlU3BhY2Ugb24gdGhhdCBvbmUgb2YgdGhlCgkqILdtZW1iZXJUeXBlc7cgYWdhaW5zdCB3aGljaCB0aGUgt3VuaW9utyBpcyBzdWNjZXNzZnVsbHkgdmFsaWRhdGVkLgoJKgoJKiBUaGlzIG1lYW5zIHRoYXQgdGhlIHZhbHVlIGlzIG5vcm1hbGl6ZWQgYnkgdGhlIGZpcnN0IHZhbGlkYXRpbmcKCSogbWVtYmVyIHR5cGUsIHRoZW4gdGhlIGZhY2V0cyBvZiB0aGUgdW5pb24gdHlwZSBhcmUgYXBwbGllZC4gVGhpcwoJKiBuZWVkcyBjaGFuZ2luZyBvZiB0aGUgdmFsdWUhCgkqLwoKCS8qCgkqIDEuMi4zIGlmIHt2YXJpZXR5fSBpcyC3dW5pb263IHRoZW4gdGhlIHN0cmluZyBtdXN0ILdtYXRjaLcgYQoJKiBsaXRlcmFsIGluIHRoZSC3bGV4aWNhbCBzcGFjZbcgb2YgYXQgbGVhc3Qgb25lIG1lbWJlciBvZgoJKiB7bWVtYmVyIHR5cGUgZGVmaW5pdGlvbnN9CgkqLwoJbWVtYmVyTGluayA9IHhtbFNjaGVtYUdldFVuaW9uU2ltcGxlVHlwZU1lbWJlclR5cGVzKHR5cGUpOwoJaWYgKG1lbWJlckxpbmsgPT0gTlVMTCkgewoJICAgIEFFUlJPUl9JTlQoInhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUiLAoJCSJ1bmlvbiBzaW1wbGUgdHlwZSBoYXMgbm8gbWVtYmVyIHR5cGVzIik7CgkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCX0JCgkvKgoJKiBBbHdheXMgbm9ybWFsaXplIHVuaW9uIHR5cGUgdmFsdWVzLCBzaW5jZSB3ZSBjdXJyZW50bHkKCSogY2Fubm90IHN0b3JlIHRoZSB3aGl0ZXNwYWNlIGluZm9ybWF0aW9uIHdpdGggdGhlIHZhbHVlCgkqIGl0c2VsZjsgb3RoZXJ3aXNlIGEgbGF0ZXIgdmFsdWUtY29tcGFyaXNvbiB3b3VsZCBiZQoJKiBub3QgcG9zc2libGUuCgkqLwoJd2hpbGUgKG1lbWJlckxpbmsgIT0gTlVMTCkgewoJICAgIGlmICh2YWxOZWVkZWQpIAoJCXJldCA9IHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoYWN0eHQsIG5vZGUsCgkJICAgIG1lbWJlckxpbmstPnR5cGUsIHZhbHVlLCAmdmFsLCAwLCAxLCAwKTsKCSAgICBlbHNlCgkJcmV0ID0geG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZShhY3R4dCwgbm9kZSwKCQkgICAgbWVtYmVyTGluay0+dHlwZSwgdmFsdWUsIE5VTEwsIDAsIDEsIDApOwoJICAgIGlmIChyZXQgPD0gMCkKCQlicmVhazsKCSAgICBtZW1iZXJMaW5rID0gbWVtYmVyTGluay0+bmV4dDsKCX0KCWlmIChyZXQgIT0gMCkgewoJICAgIGlmIChyZXQgPCAwKSB7CgkJQUVSUk9SX0lOVCgieG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSIsCgkJICAgICJ2YWxpZGF0aW5nIG1lbWJlcnMgb2YgdW5pb24gc2ltcGxlIHR5cGUiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCSAgICByZXQgPSBYTUxfU0NIRU1BVl9DVkNfREFUQVRZUEVfVkFMSURfMV8yXzM7Cgl9CgkvKgoJKiBBcHBseSBmYWNldHMgKHBhdHRlcm4sIGVudW1lcmF0aW9uKS4KCSovCglpZiAoKHJldCA9PSAwKSAmJiAodHlwZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19UWVBFX0hBU19GQUNFVFMpKSB7CgkgICAgLyoKCSAgICAqIFRoZSBub3JtYWxpemF0aW9uIGJlaGF2aW9yIG9mILd1bmlvbrcgdHlwZXMgaXMgY29udHJvbGxlZCBieQoJICAgICogdGhlIHZhbHVlIG9mIHdoaXRlU3BhY2Ugb24gdGhhdCBvbmUgb2YgdGhlILdtZW1iZXJUeXBlc7cKCSAgICAqIGFnYWluc3Qgd2hpY2ggdGhlILd1bmlvbrcgaXMgc3VjY2Vzc2Z1bGx5IHZhbGlkYXRlZC4KCSAgICAqLwoJICAgIE5PUk1BTElaRShtZW1iZXJMaW5rLT50eXBlKTsKCSAgICByZXQgPSB4bWxTY2hlbWFWYWxpZGF0ZUZhY2V0cyhhY3R4dCwgbm9kZSwgdHlwZSwKCQlYTUxfU0NIRU1BU19VTktOT1dOLCB2YWx1ZSwgdmFsLAoJCTAsIGZpcmVFcnJvcnMpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPCAwKSB7CgkJICAgIEFFUlJPUl9JTlQoInhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUiLAoJCQkidmFsaWRhdGluZyBmYWNldHMgb2YgdW5pb24gc2ltcGxlIHR5cGUiKTsKCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCQl9CgkJcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX0RBVEFUWVBFX1ZBTElEXzFfMl8zOwkJCgkgICAgfQoJfQoJaWYgKGZpcmVFcnJvcnMgJiYgKHJldCA+IDApKQoJICAgIHhtbFNjaGVtYVNpbXBsZVR5cGVFcnIoYWN0eHQsIHJldCwgbm9kZSwgdmFsdWUsIHR5cGUsIDEpOwogICAgfQoKICAgIGlmIChub3JtVmFsdWUgIT0gTlVMTCkKCXhtbEZyZWUobm9ybVZhbHVlKTsKICAgIGlmIChyZXQgPT0gMCkgewoJaWYgKHJldFZhbCAhPSBOVUxMKQoJICAgICpyZXRWYWwgPSB2YWw7CgllbHNlIGlmICh2YWwgIT0gTlVMTCkKCSAgICB4bWxTY2hlbWFGcmVlVmFsdWUodmFsKTsKICAgIH0gZWxzZSBpZiAodmFsICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlVmFsdWUodmFsKTsKICAgIHJldHVybiAocmV0KTsKaW50ZXJuYWxfZXJyb3I6CiAgICBpZiAobm9ybVZhbHVlICE9IE5VTEwpCgl4bWxGcmVlKG5vcm1WYWx1ZSk7CiAgICBpZiAodmFsICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlVmFsdWUodmFsKTsKICAgIHJldHVybiAoLTEpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVZFeHBhbmRRTmFtZSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkgICBjb25zdCB4bWxDaGFyICoqbnNOYW1lLAoJCQkgICBjb25zdCB4bWxDaGFyICoqbG9jYWxOYW1lKQp7CiAgICBpbnQgcmV0ID0gMDsKCiAgICBpZiAoKG5zTmFtZSA9PSBOVUxMKSB8fCAobG9jYWxOYW1lID09IE5VTEwpKQoJcmV0dXJuICgtMSk7CiAgICAqbnNOYW1lID0gTlVMTDsKICAgICpsb2NhbE5hbWUgPSBOVUxMOwoKICAgIHJldCA9IHhtbFZhbGlkYXRlUU5hbWUodmFsdWUsIDEpOwogICAgaWYgKHJldCA9PSAtMSkKCXJldHVybiAoLTEpOwogICAgaWYgKHJldCA+IDApIHsKCXhtbFNjaGVtYVNpbXBsZVR5cGVFcnIoQUNUWFRfQ0FTVCB2Y3R4dCwKCSAgICBYTUxfU0NIRU1BVl9DVkNfREFUQVRZUEVfVkFMSURfMV8yXzEsIE5VTEwsCgkgICAgdmFsdWUsIHhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX1FOQU1FKSwgMSk7CglyZXR1cm4gKDEpOwogICAgfQogICAgewoJeG1sQ2hhciAqbG9jYWwgPSBOVUxMOwoJeG1sQ2hhciAqcHJlZml4OwoKCS8qCgkqIE5PVEU6IHhtbFNwbGl0UU5hbWUyIHdpbGwgcmV0dXJuIGEgZHVwbGljYXRlZAoJKiBzdHJpbmcuCgkqLwoJbG9jYWwgPSB4bWxTcGxpdFFOYW1lMih2YWx1ZSwgJnByZWZpeCk7CglpZiAobG9jYWwgPT0gTlVMTCkKCSAgICAqbG9jYWxOYW1lID0geG1sRGljdExvb2t1cCh2Y3R4dC0+ZGljdCwgdmFsdWUsIC0xKTsKCWVsc2UgewoJICAgICpsb2NhbE5hbWUgPSB4bWxEaWN0TG9va3VwKHZjdHh0LT5kaWN0LCBsb2NhbCwgLTEpOwoJICAgIHhtbEZyZWUobG9jYWwpOwoJfQoKCSpuc05hbWUgPSB4bWxTY2hlbWFMb29rdXBOYW1lc3BhY2UodmN0eHQsIHByZWZpeCk7CgoJaWYgKHByZWZpeCAhPSBOVUxMKSB7CgkgICAgeG1sRnJlZShwcmVmaXgpOwoJICAgIC8qCgkgICAgKiBBIG5hbWVzcGFjZSBtdXN0IGJlIGZvdW5kIGlmIHRoZSBwcmVmaXggaXMgTk9UIE5VTEwuCgkgICAgKi8KCSAgICBpZiAoKm5zTmFtZSA9PSBOVUxMKSB7CgkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJICAgIFhNTF9TQ0hFTUFWX0NWQ19EQVRBVFlQRV9WQUxJRF8xXzJfMSwgTlVMTCwKCQkgICAgV1hTX0JBU0lDX0NBU1QgeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfUU5BTUUpLAoJCSAgICAiVGhlIFFOYW1lIHZhbHVlICclcycgaGFzIG5vICIKCQkgICAgImNvcnJlc3BvbmRpbmcgbmFtZXNwYWNlIGRlY2xhcmF0aW9uIGluIHNjb3BlIiwKCQkgICAgdmFsdWUsIE5VTEwpOwoJCXJldHVybiAoMik7CgkgICAgfQoJfQogICAgfQogICAgcmV0dXJuICgwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFQcm9jZXNzWFNJVHlwZSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCXhtbFNjaGVtYUF0dHJJbmZvUHRyIGlhdHRyLAoJCQl4bWxTY2hlbWFUeXBlUHRyICpsb2NhbFR5cGUsCgkJCXhtbFNjaGVtYUVsZW1lbnRQdHIgZWxlbURlY2wpCnsKICAgIGludCByZXQgPSAwOwogICAgLyoKICAgICogY3ZjLWVsdCAoMy4zLjQpIDogKDQpCiAgICAqIEFORAogICAgKiBTY2hlbWEtVmFsaWRpdHkgQXNzZXNzbWVudCAoRWxlbWVudCkgKGN2Yy1hc3Nlc3MtZWx0KQogICAgKiAgICgxLjIuMS4yLjEpIC0gKDEuMi4xLjIuNCkKICAgICogSGFuZGxlICd4c2k6dHlwZScuCiAgICAqLwogICAgaWYgKGxvY2FsVHlwZSA9PSBOVUxMKQoJcmV0dXJuICgtMSk7CiAgICAqbG9jYWxUeXBlID0gTlVMTDsKICAgIGlmIChpYXR0ciA9PSBOVUxMKQoJcmV0dXJuICgwKTsKICAgIGVsc2UgewoJY29uc3QgeG1sQ2hhciAqbnNOYW1lID0gTlVMTCwgKmxvY2FsID0gTlVMTDsKCS8qCgkqIFRPRE86IFdlIHNob3VsZCByZXBvcnQgYSAqd2FybmluZyogdGhhdCB0aGUgdHlwZSB3YXMgb3ZlcnJpZGVuCgkqIGJ5IHRoZSBpbnN0YW5jZS4KCSovCglBQ1RJVkFURV9BVFRSSUJVVEUoaWF0dHIpOwoJLyoKCSogKGN2Yy1lbHQpICgzLjMuNCkgOiAoNC4xKQoJKiAoY3ZjLWFzc2Vzcy1lbHQpICgxLjIuMS4yLjIpCgkqLwoJcmV0ID0geG1sU2NoZW1hVkV4cGFuZFFOYW1lKHZjdHh0LCBpYXR0ci0+dmFsdWUsCgkgICAgJm5zTmFtZSwgJmxvY2FsKTsKCWlmIChyZXQgIT0gMCkgewoJICAgIGlmIChyZXQgPCAwKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVFbGVtZW50QnlEZWNsYXJhdGlvbiIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVFOYW1lRXhwYW5kKCkgdG8gdmFsaWRhdGUgdGhlICIKCQkgICAgImF0dHJpYnV0ZSAneHNpOnR5cGUnIik7CgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICB9CgkgICAgZ290byBleGl0OwoJfQoJLyoKCSogKGN2Yy1lbHQpICgzLjMuNCkgOiAoNC4yKQoJKiAoY3ZjLWFzc2Vzcy1lbHQpICgxLjIuMS4yLjMpCgkqLwoJKmxvY2FsVHlwZSA9IHhtbFNjaGVtYUdldFR5cGUodmN0eHQtPnNjaGVtYSwgbG9jYWwsIG5zTmFtZSk7CglpZiAoKmxvY2FsVHlwZSA9PSBOVUxMKSB7CgkgICAgeG1sQ2hhciAqc3RyID0gTlVMTDsKCgkgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJWE1MX1NDSEVNQVZfQ1ZDX0VMVF80XzIsIE5VTEwsCgkJV1hTX0JBU0lDX0NBU1QgeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfUU5BTUUpLAoJCSJUaGUgUU5hbWUgdmFsdWUgJyVzJyBvZiB0aGUgeHNpOnR5cGUgYXR0cmlidXRlIGRvZXMgbm90ICIKCQkicmVzb2x2ZSB0byBhIHR5cGUgZGVmaW5pdGlvbiIsCgkJeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwgbnNOYW1lLCBsb2NhbCksIE5VTEwpOwoJICAgIEZSRUVfQU5EX05VTEwoc3RyKTsKCSAgICByZXQgPSB2Y3R4dC0+ZXJyOwoJICAgIGdvdG8gZXhpdDsKCX0KCWlmIChlbGVtRGVjbCAhPSBOVUxMKSB7CgkgICAgaW50IHNldCA9IDA7CgoJICAgIC8qCgkgICAgKiBTUEVDIGN2Yy1lbHQgKDMuMy40KSA6ICg0LjMpIChUeXBlIERlcml2YXRpb24gT0spCgkgICAgKiAiVGhlILdsb2NhbCB0eXBlIGRlZmluaXRpb263IG11c3QgYmUgdmFsaWRseQoJICAgICogZGVyaXZlZCBmcm9tIHRoZSB7dHlwZSBkZWZpbml0aW9ufSBnaXZlbiB0aGUgdW5pb24gb2YKCSAgICAqIHRoZSB7ZGlzYWxsb3dlZCBzdWJzdGl0dXRpb25zfSBhbmQgdGhlIHt0eXBlIGRlZmluaXRpb259J3MKCSAgICAqIHtwcm9oaWJpdGVkIHN1YnN0aXR1dGlvbnN9LCBhcyBkZWZpbmVkIGluCgkgICAgKiBUeXBlIERlcml2YXRpb24gT0sgKENvbXBsZXgpICinMy40LjYpCgkgICAgKiAoaWYgaXQgaXMgYSBjb21wbGV4IHR5cGUgZGVmaW5pdGlvbiksCgkgICAgKiBvciBnaXZlbiB7ZGlzYWxsb3dlZCBzdWJzdGl0dXRpb25zfSBhcyBkZWZpbmVkIGluIFR5cGUKCSAgICAqIERlcml2YXRpb24gT0sgKFNpbXBsZSkgKKczLjE0LjYpIChpZiBpdCBpcyBhIHNpbXBsZSB0eXBlCgkgICAgKiBkZWZpbml0aW9uKS4iCgkgICAgKgoJICAgICoge2Rpc2FsbG93ZWQgc3Vic3RpdHV0aW9uc306IHRoZSAiYmxvY2siIG9uIHRoZSBlbGVtZW50IGRlY2wuCgkgICAgKiB7cHJvaGliaXRlZCBzdWJzdGl0dXRpb25zfTogdGhlICJibG9jayIgb24gdGhlIHR5cGUgZGVmLgoJICAgICovCgkgICAgLyoKCSAgICAqIE9QVElNSVpFIFRPRE86IFdlIGNvdWxkIG1hcCB0eXBlcyBhbHJlYWR5IGV2YWx1YXRlZAoJICAgICogdG8gYmUgdmFsaWRseSBkZXJpdmVkIGZyb20gb3RoZXIgdHlwZXMgdG8gYXZvaWQgY2hlY2tpbmcKCSAgICAqIHRoaXMgb3ZlciBhbmQgb3ZlciBmb3IgdGhlIHNhbWUgdHlwZXMuCgkgICAgKi8KCSAgICBpZiAoKGVsZW1EZWNsLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfRVhURU5TSU9OKSB8fAoJCShlbGVtRGVjbC0+c3VidHlwZXMtPmZsYWdzICYKCQkgICAgWE1MX1NDSEVNQVNfVFlQRV9CTE9DS19FWFRFTlNJT04pKQoJCXNldCB8PSBTVUJTRVRfRVhURU5TSU9OOwoKCSAgICBpZiAoKGVsZW1EZWNsLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fQkxPQ0tfUkVTVFJJQ1RJT04pIHx8CgkJKGVsZW1EZWNsLT5zdWJ0eXBlcy0+ZmxhZ3MgJgoJCSAgICBYTUxfU0NIRU1BU19UWVBFX0JMT0NLX1JFU1RSSUNUSU9OKSkKCQlzZXQgfD0gU1VCU0VUX1JFU1RSSUNUSU9OOwoKCSAgICAvKgoJICAgICogUkVNT1ZFRCBhbmQgQ0hBTkdFRCBzaW5jZSB0aGlzIHByb2R1Y2VkIGEgcGFyc2VyIGNvbnRleHQKCSAgICAqIHdoaWNoIGFkZHMgdG8gdGhlIHN0cmluZyBkaWN0IG9mIHRoZSBzY2hlbWEuIFNvIHRoaXMgd291bGQKCSAgICAqIGNoYW5nZSB0aGUgc2NoZW1hIGFuZCB3ZSBkb24ndCB3YW50IHRoaXMuIFdlIGRvbid0IG5lZWQKCSAgICAqIHRoZSBwYXJzZXIgY29udGV4dCBhbnltb3JlLgoJICAgICoKCSAgICAqIGlmICgodmN0eHQtPnBjdHh0ID09IE5VTEwpICYmCgkgICAgKgkoeG1sU2NoZW1hQ3JlYXRlUEN0eHRPblZDdHh0KHZjdHh0KSA9PSAtMSkpCgkgICAgKgkgICAgcmV0dXJuICgtMSk7CgkgICAgKi8KCgkgICAgaWYgKHhtbFNjaGVtYUNoZWNrQ09TRGVyaXZlZE9LKEFDVFhUX0NBU1QgdmN0eHQsICpsb2NhbFR5cGUsCgkJZWxlbURlY2wtPnN1YnR5cGVzLCBzZXQpICE9IDApIHsKCQl4bWxDaGFyICpzdHIgPSBOVUxMOwoKCQl4bWxTY2hlbWFDdXN0b21FcnIoQUNUWFRfQ0FTVCB2Y3R4dCwKCQkgICAgWE1MX1NDSEVNQVZfQ1ZDX0VMVF80XzMsIE5VTEwsIE5VTEwsCgkJICAgICJUaGUgdHlwZSBkZWZpbml0aW9uICclcycsIHNwZWNpZmllZCBieSB4c2k6dHlwZSwgaXMgIgoJCSAgICAiYmxvY2tlZCBvciBub3QgdmFsaWRseSBkZXJpdmVkIGZyb20gdGhlIHR5cGUgZGVmaW5pdGlvbiAiCgkJICAgICJvZiB0aGUgZWxlbWVudCBkZWNsYXJhdGlvbiIsCgkJICAgIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkJCSgqbG9jYWxUeXBlKS0+dGFyZ2V0TmFtZXNwYWNlLAoJCQkoKmxvY2FsVHlwZSktPm5hbWUpLAoJCSAgICBOVUxMKTsKCQlGUkVFX0FORF9OVUxMKHN0cik7CgkJcmV0ID0gdmN0eHQtPmVycjsKCQkqbG9jYWxUeXBlID0gTlVMTDsKCSAgICB9Cgl9CiAgICB9CmV4aXQ6CiAgICBBQ1RJVkFURV9FTEVNOwogICAgcmV0dXJuIChyZXQpOwppbnRlcm5hbF9lcnJvcjoKICAgIEFDVElWQVRFX0VMRU07CiAgICByZXR1cm4gKC0xKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFWYWxpZGF0ZUVsZW1EZWNsKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgeG1sU2NoZW1hRWxlbWVudFB0ciBlbGVtRGVjbCA9IHZjdHh0LT5pbm9kZS0+ZGVjbDsKICAgIHhtbFNjaGVtYVR5cGVQdHIgYWN0dWFsVHlwZSA9IFdYU19FTEVNX1RZUEVERUYoZWxlbURlY2wpOwoKICAgIC8qCiAgICAqIGN2Yy1lbHQgKDMuMy40KSA6IDEKICAgICovCiAgICBpZiAoZWxlbURlY2wgPT0gTlVMTCkgewoJVkVSUk9SKFhNTF9TQ0hFTUFWX0NWQ19FTFRfMSwgTlVMTCwKCSAgICAiTm8gbWF0Y2hpbmcgZGVjbGFyYXRpb24gYXZhaWxhYmxlIik7CiAgICAgICAgcmV0dXJuICh2Y3R4dC0+ZXJyKTsKICAgIH0KICAgIC8qCiAgICAqIGN2Yy1lbHQgKDMuMy40KSA6IDIKICAgICovCiAgICBpZiAoZWxlbURlY2wtPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9BQlNUUkFDVCkgewoJVkVSUk9SKFhNTF9TQ0hFTUFWX0NWQ19FTFRfMiwgTlVMTCwKCSAgICAiVGhlIGVsZW1lbnQgZGVjbGFyYXRpb24gaXMgYWJzdHJhY3QiKTsKICAgICAgICByZXR1cm4gKHZjdHh0LT5lcnIpOwogICAgfQogICAgaWYgKGFjdHVhbFR5cGUgPT0gTlVMTCkgewogICAgCVZFUlJPUihYTUxfU0NIRU1BVl9DVkNfVFlQRV8xLCBOVUxMLAogICAgCSAgICAiVGhlIHR5cGUgZGVmaW5pdGlvbiBpcyBhYnNlbnQiKTsKICAgIAlyZXR1cm4gKFhNTF9TQ0hFTUFWX0NWQ19UWVBFXzEpOwogICAgfQogICAgaWYgKHZjdHh0LT5uYkF0dHJJbmZvcyAhPSAwKSB7CglpbnQgcmV0OwoJeG1sU2NoZW1hQXR0ckluZm9QdHIgaWF0dHI7CgkvKgoJKiBjdmMtZWx0ICgzLjMuNCkgOiAzCgkqIEhhbmRsZSAneHNpOm5pbCcuCgkqLwoJaWF0dHIgPSB4bWxTY2hlbWFHZXRNZXRhQXR0ckluZm8odmN0eHQsCgkgICAgWE1MX1NDSEVNQV9BVFRSX0lORk9fTUVUQV9YU0lfTklMKTsKCWlmIChpYXR0cikgewoJICAgIEFDVElWQVRFX0FUVFJJQlVURShpYXR0cik7CgkgICAgLyoKCSAgICAqIFZhbGlkYXRlIHRoZSB2YWx1ZS4KCSAgICAqLwoJICAgIHJldCA9IHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoCgkJQUNUWFRfQ0FTVCB2Y3R4dCwgTlVMTCwKCQl4bWxTY2hlbWFHZXRCdWlsdEluVHlwZShYTUxfU0NIRU1BU19CT09MRUFOKSwKCQlpYXR0ci0+dmFsdWUsICYoaWF0dHItPnZhbCksIDEsIDAsIDApOwoJICAgIEFDVElWQVRFX0VMRU07CgkgICAgaWYgKHJldCA8IDApIHsKCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUVsZW1EZWNsIiwKCQkgICAgImNhbGxpbmcgeG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSgpIHRvICIKCQkgICAgInZhbGlkYXRlIHRoZSBhdHRyaWJ1dGUgJ3hzaTpuaWwnIik7CgkJcmV0dXJuICgtMSk7CgkgICAgfQoJICAgIGlmIChyZXQgPT0gMCkgewoJCWlmICgoZWxlbURlY2wtPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9OSUxMQUJMRSkgPT0gMCkgewoJCSAgICAvKgoJCSAgICAqIGN2Yy1lbHQgKDMuMy40KSA6IDMuMQoJCSAgICAqLwoJCSAgICBWRVJST1IoWE1MX1NDSEVNQVZfQ1ZDX0VMVF8zXzEsIE5VTEwsCgkJCSJUaGUgZWxlbWVudCBpcyBub3QgJ25pbGxhYmxlJyIpOwoJCSAgICAvKiBEb2VzIG5vdCByZXR1cm4gYW4gZXJyb3Igb24gcHVycG9zZS4gKi8KCQl9IGVsc2UgewoJCSAgICBpZiAoeG1sU2NoZW1hVmFsdWVHZXRBc0Jvb2xlYW4oaWF0dHItPnZhbCkpIHsKCQkJLyoKCQkJKiBjdmMtZWx0ICgzLjMuNCkgOiAzLjIuMgoJCQkqLwoJCQlpZiAoKGVsZW1EZWNsLT5mbGFncyAmIFhNTF9TQ0hFTUFTX0VMRU1fRklYRUQpICYmCgkJCSAgICAoZWxlbURlY2wtPnZhbHVlICE9IE5VTEwpKSB7CgkJCSAgICBWRVJST1IoWE1MX1NDSEVNQVZfQ1ZDX0VMVF8zXzJfMiwgTlVMTCwKCQkJCSJUaGUgZWxlbWVudCBjYW5ub3QgYmUgJ25pbGxlZCcgYmVjYXVzZSAiCgkJCQkidGhlcmUgaXMgYSBmaXhlZCB2YWx1ZSBjb25zdHJhaW50IGRlZmluZWQgIgoJCQkJImZvciBpdCIpOwoJCQkgICAgIC8qIERvZXMgbm90IHJldHVybiBhbiBlcnJvciBvbiBwdXJwb3NlLiAqLwoJCQl9IGVsc2UKCQkJICAgIHZjdHh0LT5pbm9kZS0+ZmxhZ3MgfD0KCQkJCVhNTF9TQ0hFTUFfRUxFTV9JTkZPX05JTExFRDsKCQkgICAgfQoJCX0KCSAgICB9Cgl9CgkvKgoJKiBjdmMtZWx0ICgzLjMuNCkgOiA0CgkqIEhhbmRsZSAneHNpOnR5cGUnLgoJKi8KCWlhdHRyID0geG1sU2NoZW1hR2V0TWV0YUF0dHJJbmZvKHZjdHh0LAoJICAgIFhNTF9TQ0hFTUFfQVRUUl9JTkZPX01FVEFfWFNJX1RZUEUpOwoJaWYgKGlhdHRyKSB7CgkgICAgeG1sU2NoZW1hVHlwZVB0ciBsb2NhbFR5cGUgPSBOVUxMOwoKCSAgICByZXQgPSB4bWxTY2hlbWFQcm9jZXNzWFNJVHlwZSh2Y3R4dCwgaWF0dHIsICZsb2NhbFR5cGUsCgkJZWxlbURlY2wpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPT0gLTEpIHsKCQkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVFbGVtRGVjbCIsCgkJCSJjYWxsaW5nIHhtbFNjaGVtYVByb2Nlc3NYU0lUeXBlKCkgdG8gIgoJCQkicHJvY2VzcyB0aGUgYXR0cmlidXRlICd4c2k6dHlwZSciKTsKCQkgICAgcmV0dXJuICgtMSk7CgkJfQoJCS8qIERvZXMgbm90IHJldHVybiBhbiBlcnJvciBvbiBwdXJwb3NlLiAqLwoJICAgIH0KCSAgICBpZiAobG9jYWxUeXBlICE9IE5VTEwpIHsKCQl2Y3R4dC0+aW5vZGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0xPQ0FMX1RZUEU7CgkJYWN0dWFsVHlwZSA9IGxvY2FsVHlwZTsKCSAgICB9Cgl9CiAgICB9CiAgICAvKgogICAgKiBJREM6IFJlZ2lzdGVyIGlkZW50aXR5LWNvbnN0cmFpbnQgWFBhdGggbWF0Y2hlcnMuCiAgICAqLwogICAgaWYgKChlbGVtRGVjbC0+aWRjcyAhPSBOVUxMKSAmJgoJKHhtbFNjaGVtYUlEQ1JlZ2lzdGVyTWF0Y2hlcnModmN0eHQsIGVsZW1EZWNsKSA9PSAtMSkpCgkgICAgcmV0dXJuICgtMSk7CiAgICAvKgogICAgKiBObyBhY3R1YWwgdHlwZSBkZWZpbml0aW9uLgogICAgKi8KICAgIGlmIChhY3R1YWxUeXBlID09IE5VTEwpIHsKICAgIAlWRVJST1IoWE1MX1NDSEVNQVZfQ1ZDX1RZUEVfMSwgTlVMTCwKICAgIAkgICAgIlRoZSB0eXBlIGRlZmluaXRpb24gaXMgYWJzZW50Iik7CiAgICAJcmV0dXJuIChYTUxfU0NIRU1BVl9DVkNfVFlQRV8xKTsKICAgIH0KICAgIC8qCiAgICAqIFJlbWVtYmVyIHRoZSBhY3R1YWwgdHlwZSBkZWZpbml0aW9uLgogICAgKi8KICAgIHZjdHh0LT5pbm9kZS0+dHlwZURlZiA9IGFjdHVhbFR5cGU7CgogICAgcmV0dXJuICgwKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFWQXR0cmlidXRlc1NpbXBsZSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpCnsKICAgIHhtbFNjaGVtYUF0dHJJbmZvUHRyIGlhdHRyOwogICAgaW50IHJldCA9IDAsIGk7CgogICAgLyoKICAgICogU1BFQyBjdmMtdHlwZSAoMy4xLjEpCiAgICAqICJUaGUgYXR0cmlidXRlcyBvZiBtdXN0IGJlIGVtcHR5LCBleGNlcHRpbmcgdGhvc2Ugd2hvc2UgbmFtZXNwYWNlCiAgICAqIG5hbWUgaXMgaWRlbnRpY2FsIHRvIGh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIGFuZAogICAgKiB3aG9zZSBsb2NhbCBuYW1lIGlzIG9uZSBvZiB0eXBlLCBuaWwsIHNjaGVtYUxvY2F0aW9uIG9yCiAgICAqIG5vTmFtZXNwYWNlU2NoZW1hTG9jYXRpb24uIgogICAgKi8KICAgIGlmICh2Y3R4dC0+bmJBdHRySW5mb3MgPT0gMCkKCXJldHVybiAoMCk7CiAgICBmb3IgKGkgPSAwOyBpIDwgdmN0eHQtPm5iQXR0ckluZm9zOyBpKyspIHsKCWlhdHRyID0gdmN0eHQtPmF0dHJJbmZvc1tpXTsKCWlmICghIGlhdHRyLT5tZXRhVHlwZSkgewoJICAgIEFDVElWQVRFX0FUVFJJQlVURShpYXR0cikKCSAgICB4bWxTY2hlbWFJbGxlZ2FsQXR0ckVycihBQ1RYVF9DQVNUIHZjdHh0LAoJCVhNTF9TQ0hFTUFWX0NWQ19UWVBFXzNfMV8xLCBpYXR0ciwgTlVMTCk7CgkgICAgcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX1RZUEVfM18xXzE7CiAgICAgICAgfQogICAgfQogICAgQUNUSVZBVEVfRUxFTQogICAgcmV0dXJuIChyZXQpOwp9CgovKgoqIENsZWFudXAgY3VycmVudGx5IHVzZWQgYXR0cmlidXRlIGluZm9zLgoqLwpzdGF0aWMgdm9pZAp4bWxTY2hlbWFDbGVhckF0dHJJbmZvcyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpCnsKICAgIGludCBpOwogICAgeG1sU2NoZW1hQXR0ckluZm9QdHIgYXR0cjsKCiAgICBpZiAodmN0eHQtPm5iQXR0ckluZm9zID09IDApCglyZXR1cm47CiAgICBmb3IgKGkgPSAwOyBpIDwgdmN0eHQtPm5iQXR0ckluZm9zOyBpKyspIHsKCWF0dHIgPSB2Y3R4dC0+YXR0ckluZm9zW2ldOwoJaWYgKGF0dHItPmZsYWdzICYgWE1MX1NDSEVNQV9OT0RFX0lORk9fRkxBR19PV05FRF9OQU1FUykgewoJICAgIGlmIChhdHRyLT5sb2NhbE5hbWUgIT0gTlVMTCkKCQl4bWxGcmVlKCh4bWxDaGFyICopIGF0dHItPmxvY2FsTmFtZSk7CgkgICAgaWYgKGF0dHItPm5zTmFtZSAhPSBOVUxMKQoJCXhtbEZyZWUoKHhtbENoYXIgKikgYXR0ci0+bnNOYW1lKTsKCX0KCWlmIChhdHRyLT5mbGFncyAmIFhNTF9TQ0hFTUFfTk9ERV9JTkZPX0ZMQUdfT1dORURfVkFMVUVTKSB7CgkgICAgaWYgKGF0dHItPnZhbHVlICE9IE5VTEwpCgkJeG1sRnJlZSgoeG1sQ2hhciAqKSBhdHRyLT52YWx1ZSk7Cgl9CglpZiAoYXR0ci0+dmFsICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFGcmVlVmFsdWUoYXR0ci0+dmFsKTsKCSAgICBhdHRyLT52YWwgPSBOVUxMOwoJfQoJbWVtc2V0KGF0dHIsIDAsIHNpemVvZih4bWxTY2hlbWFBdHRySW5mbykpOwogICAgfQogICAgdmN0eHQtPm5iQXR0ckluZm9zID0gMDsKfQoKLyoKKiAzLjQuNCBDb21wbGV4IFR5cGUgRGVmaW5pdGlvbiBWYWxpZGF0aW9uIFJ1bGVzCiogICBFbGVtZW50IExvY2FsbHkgVmFsaWQgKENvbXBsZXggVHlwZSkgKGN2Yy1jb21wbGV4LXR5cGUpCiogMy4yLjQgQXR0cmlidXRlIERlY2xhcmF0aW9uIFZhbGlkYXRpb24gUnVsZXMKKiAgIFZhbGlkYXRpb24gUnVsZTogQXR0cmlidXRlIExvY2FsbHkgVmFsaWQgKGN2Yy1hdHRyaWJ1dGUpCiogICBBdHRyaWJ1dGUgTG9jYWxseSBWYWxpZCAoVXNlKSAoY3ZjLWF1KQoqCiogT25seSAiYXNzZXNzZWQiIGF0dHJpYnV0ZSBpbmZvcm1hdGlvbiBpdGVtcyB3aWxsIGJlIHZpc2libGUgdG8KKiBJRENzLiBJLmUuIG5vdCAibGF4IiAod2l0aG91dCBkZWNsYXJhdGlvbikgYW5kICJza2lwIiB3aWxkIGF0dHJpYnV0ZXMuCiovCnN0YXRpYyBpbnQKeG1sU2NoZW1hVkF0dHJpYnV0ZXNDb21wbGV4KHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlID0gdmN0eHQtPmlub2RlLT50eXBlRGVmOyAgICAKICAgIHhtbFNjaGVtYUl0ZW1MaXN0UHRyIGF0dHJVc2VMaXN0OwogICAgeG1sU2NoZW1hQXR0cmlidXRlVXNlUHRyIGF0dHJVc2UgPSBOVUxMOwogICAgeG1sU2NoZW1hQXR0cmlidXRlUHRyIGF0dHJEZWNsID0gTlVMTDsKICAgIHhtbFNjaGVtYUF0dHJJbmZvUHRyIGlhdHRyLCB0bXBpYXR0cjsKICAgIGludCBpLCBqLCBmb3VuZCwgbmJBdHRycywgbmJVc2VzOwogICAgaW50IHhwYXRoUmVzID0gMCwgcmVzLCB3aWxkSURzID0gMCwgZml4ZWQ7CgogICAgLyoKICAgICogU1BFQyAoY3ZjLWF0dHJpYnV0ZSkKICAgICogKDEpICJUaGUgZGVjbGFyYXRpb24gbXVzdCBub3QgYmUgt2Fic2VudLcgKHNlZSBNaXNzaW5nCiAgICAqIFN1Yi1jb21wb25lbnRzICinNS4zKSBmb3IgaG93IHRoaXMgY2FuIGZhaWwgdG8gYmUKICAgICogdGhlIGNhc2UpLiIKICAgICogKDIpICJJdHMge3R5cGUgZGVmaW5pdGlvbn0gbXVzdCBub3QgYmUgYWJzZW50LiIKICAgICoKICAgICogTk9URSAoMSkgKyAoMik6IFRoaXMgaXMgbm90IGhhbmRsZWQgaGVyZSwgc2luY2Ugd2UgY3VycmVudGx5IGRvIG5vdAogICAgKiBhbGxvdyB2YWxpZGF0aW9uIGFnYWluc3Qgc2NoZW1hcyB3aGljaCBoYXZlIG1pc3Npbmcgc3ViLWNvbXBvbmVudHMuCiAgICAqCiAgICAqIFNQRUMgKGN2Yy1jb21wbGV4LXR5cGUpCiAgICAqICgzKSAiRm9yIGVhY2ggYXR0cmlidXRlIGluZm9ybWF0aW9uIGl0ZW0gaW4gdGhlIGVsZW1lbnQgaW5mb3JtYXRpb24KICAgICogaXRlbSdzIFthdHRyaWJ1dGVzXSBleGNlcHRpbmcgdGhvc2Ugd2hvc2UgW25hbWVzcGFjZSBuYW1lXSBpcwogICAgKiBpZGVudGljYWwgdG8gaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UgYW5kIHdob3NlCiAgICAqIFtsb2NhbCBuYW1lXSBpcyBvbmUgb2YgdHlwZSwgbmlsLCBzY2hlbWFMb2NhdGlvbiBvcgogICAgKiBub05hbWVzcGFjZVNjaGVtYUxvY2F0aW9uLCB0aGUgYXBwcm9wcmlhdGUgY2FzZSBhbW9uZyB0aGUgZm9sbG93aW5nCiAgICAqIG11c3QgYmUgdHJ1ZToKICAgICoKICAgICovCiAgICBhdHRyVXNlTGlzdCA9ICh4bWxTY2hlbWFJdGVtTGlzdFB0cikgdHlwZS0+YXR0clVzZXM7CiAgICAvKgogICAgKiBAbmJBdHRycyBpcyB0aGUgbnVtYmVyIG9mIGF0dHJpYnV0ZXMgcHJlc2VudCBpbiB0aGUgaW5zdGFuY2UuCiAgICAqLwogICAgbmJBdHRycyA9IHZjdHh0LT5uYkF0dHJJbmZvczsKICAgIGlmIChhdHRyVXNlTGlzdCAhPSBOVUxMKQoJbmJVc2VzID0gYXR0clVzZUxpc3QtPm5iSXRlbXM7CiAgICBlbHNlCgluYlVzZXMgPSAwOwogICAgZm9yIChpID0gMDsgaSA8IG5iVXNlczsgaSsrKSB7CiAgICAgICAgZm91bmQgPSAwOwoJYXR0clVzZSA9IGF0dHJVc2VMaXN0LT5pdGVtc1tpXTsKCWF0dHJEZWNsID0gV1hTX0FUVFJVU0VfREVDTChhdHRyVXNlKTsKICAgICAgICBmb3IgKGogPSAwOyBqIDwgbmJBdHRyczsgaisrKSB7CgkgICAgaWF0dHIgPSB2Y3R4dC0+YXR0ckluZm9zW2pdOwoJICAgIC8qCgkgICAgKiBTUEVDIChjdmMtY29tcGxleC10eXBlKSAoMykKCSAgICAqIFNraXAgbWV0YSBhdHRyaWJ1dGVzLgoJICAgICovCgkgICAgaWYgKGlhdHRyLT5tZXRhVHlwZSkKCQljb250aW51ZTsKCSAgICBpZiAoaWF0dHItPmxvY2FsTmFtZVswXSAhPSBhdHRyRGVjbC0+bmFtZVswXSkKCQljb250aW51ZTsKCSAgICBpZiAoIXhtbFN0ckVxdWFsKGlhdHRyLT5sb2NhbE5hbWUsIGF0dHJEZWNsLT5uYW1lKSkKCQljb250aW51ZTsKCSAgICBpZiAoIXhtbFN0ckVxdWFsKGlhdHRyLT5uc05hbWUsIGF0dHJEZWNsLT50YXJnZXROYW1lc3BhY2UpKQoJCWNvbnRpbnVlOwoJICAgIGZvdW5kID0gMTsKCSAgICAvKgoJICAgICogU1BFQyAoY3ZjLWNvbXBsZXgtdHlwZSkKCSAgICAqICgzLjEpICJJZiB0aGVyZSBpcyBhbW9uZyB0aGUge2F0dHJpYnV0ZSB1c2VzfSBhbiBhdHRyaWJ1dGUKCSAgICAqIHVzZSB3aXRoIGFuIHthdHRyaWJ1dGUgZGVjbGFyYXRpb259IHdob3NlIHtuYW1lfSBtYXRjaGVzCgkgICAgKiB0aGUgYXR0cmlidXRlIGluZm9ybWF0aW9uIGl0ZW0ncyBbbG9jYWwgbmFtZV0gYW5kIHdob3NlCgkgICAgKiB7dGFyZ2V0IG5hbWVzcGFjZX0gaXMgaWRlbnRpY2FsIHRvIHRoZSBhdHRyaWJ1dGUgaW5mb3JtYXRpb24KCSAgICAqIGl0ZW0ncyBbbmFtZXNwYWNlIG5hbWVdICh3aGVyZSBhbiC3YWJzZW50tyB7dGFyZ2V0IG5hbWVzcGFjZX0KCSAgICAqIGlzIHRha2VuIHRvIGJlIGlkZW50aWNhbCB0byBhIFtuYW1lc3BhY2UgbmFtZV0gd2l0aCBubyB2YWx1ZSksCgkgICAgKiB0aGVuIHRoZSBhdHRyaWJ1dGUgaW5mb3JtYXRpb24gbXVzdCBiZSC3dmFsaWS3IHdpdGggcmVzcGVjdAoJICAgICogdG8gdGhhdCBhdHRyaWJ1dGUgdXNlIGFzIHBlciBBdHRyaWJ1dGUgTG9jYWxseSBWYWxpZCAoVXNlKQoJICAgICogKKczLjUuNCkuIEluIHRoaXMgY2FzZSB0aGUge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0gb2YgdGhhdAoJICAgICogYXR0cmlidXRlIHVzZSBpcyB0aGUgt2NvbnRleHQtZGV0ZXJtaW5lZCBkZWNsYXJhdGlvbrcgZm9yIHRoZQoJICAgICogYXR0cmlidXRlIGluZm9ybWF0aW9uIGl0ZW0gd2l0aCByZXNwZWN0IHRvIFNjaGVtYS1WYWxpZGl0eQoJICAgICogQXNzZXNzbWVudCAoQXR0cmlidXRlKSAopzMuMi40KSBhbmQKCSAgICAqIEFzc2Vzc21lbnQgT3V0Y29tZSAoQXR0cmlidXRlKSAopzMuMi41KS4KCSAgICAqLwoJICAgIGlhdHRyLT5zdGF0ZSA9IFhNTF9TQ0hFTUFTX0FUVFJfQVNTRVNTRUQ7CgkgICAgaWF0dHItPnVzZSA9IGF0dHJVc2U7CgkgICAgLyoKCSAgICAqIENvbnRleHQtZGV0ZXJtaW5lZCBkZWNsYXJhdGlvbi4KCSAgICAqLwoJICAgIGlhdHRyLT5kZWNsID0gYXR0ckRlY2w7CgkgICAgaWF0dHItPnR5cGVEZWYgPSBhdHRyRGVjbC0+c3VidHlwZXM7CgkgICAgYnJlYWs7Cgl9CgoJaWYgKGZvdW5kKQoJICAgIGNvbnRpbnVlOwoKCWlmIChhdHRyVXNlLT5vY2N1cnMgPT0gWE1MX1NDSEVNQVNfQVRUUl9VU0VfUkVRVUlSRUQpIHsKCSAgICAvKgoJICAgICogSGFuZGxlIG5vbi1leGlzdGVudCwgcmVxdWlyZWQgYXR0cmlidXRlcy4KCSAgICAqCgkgICAgKiBTUEVDIChjdmMtY29tcGxleC10eXBlKQoJICAgICogKDQpICJUaGUge2F0dHJpYnV0ZSBkZWNsYXJhdGlvbn0gb2YgZWFjaCBhdHRyaWJ1dGUgdXNlIGluCgkgICAgKiB0aGUge2F0dHJpYnV0ZSB1c2VzfSB3aG9zZSB7cmVxdWlyZWR9IGlzIHRydWUgbWF0Y2hlcyBvbmUKCSAgICAqIG9mIHRoZSBhdHRyaWJ1dGUgaW5mb3JtYXRpb24gaXRlbXMgaW4gdGhlIGVsZW1lbnQgaW5mb3JtYXRpb24KCSAgICAqIGl0ZW0ncyBbYXR0cmlidXRlc10gYXMgcGVyIGNsYXVzZSAzLjEgYWJvdmUuIgoJICAgICovCgkgICAgdG1waWF0dHIgPSB4bWxTY2hlbWFHZXRGcmVzaEF0dHJJbmZvKHZjdHh0KTsKCSAgICBpZiAodG1waWF0dHIgPT0gTlVMTCkgewoJCVZFUlJPUl9JTlQoCgkJICAgICJ4bWxTY2hlbWFWQXR0cmlidXRlc0NvbXBsZXgiLAoJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFHZXRGcmVzaEF0dHJJbmZvKCkiKTsKCQlyZXR1cm4gKC0xKTsKCSAgICB9CgkgICAgdG1waWF0dHItPnN0YXRlID0gWE1MX1NDSEVNQVNfQVRUUl9FUlJfTUlTU0lORzsKCSAgICB0bXBpYXR0ci0+dXNlID0gYXR0clVzZTsKCSAgICB0bXBpYXR0ci0+ZGVjbCA9IGF0dHJEZWNsOwkgICAgCgl9IGVsc2UgaWYgKChhdHRyVXNlLT5vY2N1cnMgPT0gWE1MX1NDSEVNQVNfQVRUUl9VU0VfT1BUSU9OQUwpICYmCgkgICAgKChhdHRyVXNlLT5kZWZWYWx1ZSAhPSBOVUxMKSB8fAoJICAgICAoYXR0ckRlY2wtPmRlZlZhbHVlICE9IE5VTEwpKSkgewoJICAgIC8qCgkgICAgKiBIYW5kbGUgbm9uLWV4aXN0ZW50LCBvcHRpb25hbCwgZGVmYXVsdC9maXhlZCBhdHRyaWJ1dGVzLgoJICAgICovCgkgICAgdG1waWF0dHIgPSB4bWxTY2hlbWFHZXRGcmVzaEF0dHJJbmZvKHZjdHh0KTsKCSAgICBpZiAodG1waWF0dHIgPT0gTlVMTCkgewoJCVZFUlJPUl9JTlQoCgkJICAgICJ4bWxTY2hlbWFWQXR0cmlidXRlc0NvbXBsZXgiLAoJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFHZXRGcmVzaEF0dHJJbmZvKCkiKTsKCQlyZXR1cm4gKC0xKTsKCSAgICB9CgkgICAgdG1waWF0dHItPnN0YXRlID0gWE1MX1NDSEVNQVNfQVRUUl9ERUZBVUxUOwoJICAgIHRtcGlhdHRyLT51c2UgPSBhdHRyVXNlOwoJICAgIHRtcGlhdHRyLT5kZWNsID0gYXR0ckRlY2w7CgkgICAgdG1waWF0dHItPnR5cGVEZWYgPSBhdHRyRGVjbC0+c3VidHlwZXM7CgkgICAgdG1waWF0dHItPmxvY2FsTmFtZSA9IGF0dHJEZWNsLT5uYW1lOwoJICAgIHRtcGlhdHRyLT5uc05hbWUgPSBhdHRyRGVjbC0+dGFyZ2V0TmFtZXNwYWNlOwoJfQogICAgfQoKICAgIGlmICh2Y3R4dC0+bmJBdHRySW5mb3MgPT0gMCkKCXJldHVybiAoMCk7CiAgICBuYlVzZXMgPSB2Y3R4dC0+bmJBdHRySW5mb3M7CiAgICAvKgogICAgKiBWYWxpZGF0ZSBhZ2FpbnN0IHRoZSB3aWxkY2FyZC4KICAgICovCiAgICBpZiAodHlwZS0+YXR0cmlidXRlV2lsZGNhcmQgIT0gTlVMTCkgewoJLyoKCSogU1BFQyAoY3ZjLWNvbXBsZXgtdHlwZSkKCSogKDMuMi4xKSAiVGhlcmUgbXVzdCBiZSBhbiB7YXR0cmlidXRlIHdpbGRjYXJkfS4iCgkqLwoJZm9yIChpID0gMDsgaSA8IG5iQXR0cnM7IGkrKykgewoJICAgIGlhdHRyID0gdmN0eHQtPmF0dHJJbmZvc1tpXTsKCSAgICAvKgoJICAgICogU1BFQyAoY3ZjLWNvbXBsZXgtdHlwZSkgKDMpCgkgICAgKiBTa2lwIG1ldGEgYXR0cmlidXRlcy4KCSAgICAqLwoJICAgIGlmIChpYXR0ci0+c3RhdGUgIT0gWE1MX1NDSEVNQVNfQVRUUl9VTktOT1dOKQoJCWNvbnRpbnVlOwoJICAgIC8qCgkgICAgKiBTUEVDIChjdmMtY29tcGxleC10eXBlKQoJICAgICogKDMuMi4yKSAiVGhlIGF0dHJpYnV0ZSBpbmZvcm1hdGlvbiBpdGVtIG11c3QgYmUgt3ZhbGlktyB3aXRoCgkgICAgKiByZXNwZWN0IHRvIGl0IGFzIGRlZmluZWQgaW4gSXRlbSBWYWxpZCAoV2lsZGNhcmQpICinMy4xMC40KS4iCgkgICAgKgoJICAgICogU1BFQyBJdGVtIFZhbGlkIChXaWxkY2FyZCkgKGN2Yy13aWxkY2FyZCkKCSAgICAqICIuLi4gaXRzIFtuYW1lc3BhY2UgbmFtZV0gbXVzdCBiZSC3dmFsaWS3IHdpdGggcmVzcGVjdCB0bwoJICAgICogdGhlIHdpbGRjYXJkIGNvbnN0cmFpbnQsIGFzIGRlZmluZWQgaW4gV2lsZGNhcmQgYWxsb3dzCgkgICAgKiBOYW1lc3BhY2UgTmFtZSAopzMuMTAuNCkuIgoJICAgICovCgkgICAgaWYgKHhtbFNjaGVtYUNoZWNrQ1ZDV2lsZGNhcmROYW1lc3BhY2UodHlwZS0+YXR0cmlidXRlV2lsZGNhcmQsCgkJICAgIGlhdHRyLT5uc05hbWUpID09IDApIHsKCQkvKgoJCSogSGFuZGxlIHByb2Nlc3NDb250ZW50cy4KCQkqCgkJKiBTUEVDIChjdmMtd2lsZGNhcmQpOgoJCSogcHJvY2Vzc0NvbnRlbnRzIHwgY29udGV4dC1kZXRlcm1pbmVkIGRlY2xhcmF0aW9uOgoJCSogInN0cmljdCIgICAgICAgICAgIm11c3RGaW5kIgoJCSogImxheCIgICAgICAgICAgICAgIm5vbmUiCgkJKiAic2tpcCIgICAgICAgICAgICAic2tpcCIKCQkqLwoJCWlmICh0eXBlLT5hdHRyaWJ1dGVXaWxkY2FyZC0+cHJvY2Vzc0NvbnRlbnRzID09CgkJICAgIFhNTF9TQ0hFTUFTX0FOWV9TS0lQKSB7CgkJICAgICAvKgoJCSAgICAqIGNvbnRleHQtZGV0ZXJtaW5lZCBkZWNsYXJhdGlvbiA9ICJza2lwIgoJCSAgICAqCgkJICAgICogU1BFQyBQU1ZJIEFzc2Vzc21lbnQgT3V0Y29tZSAoQXR0cmlidXRlKQoJCSAgICAqIFt2YWxpZGl0eV0gPSAibm90S25vd24iCgkJICAgICogW3ZhbGlkYXRpb24gYXR0ZW1wdGVkXSA9ICJub25lIgoJCSAgICAqLwoJCSAgICBpYXR0ci0+c3RhdGUgPSBYTUxfU0NIRU1BU19BVFRSX1dJTERfU0tJUDsKCQkgICAgY29udGludWU7CgkJfQoJCS8qCgkJKiBGaW5kIGFuIGF0dHJpYnV0ZSBkZWNsYXJhdGlvbi4KCQkqLwoJCWlhdHRyLT5kZWNsID0geG1sU2NoZW1hR2V0QXR0cmlidXRlRGVjbCh2Y3R4dC0+c2NoZW1hLAoJCSAgICBpYXR0ci0+bG9jYWxOYW1lLCBpYXR0ci0+bnNOYW1lKTsKCQlpZiAoaWF0dHItPmRlY2wgIT0gTlVMTCkgewoJCSAgICBpYXR0ci0+c3RhdGUgPSBYTUxfU0NIRU1BU19BVFRSX0FTU0VTU0VEOwoJCSAgICAvKgoJCSAgICAqIFNQRUMgKGN2Yy1jb21wbGV4LXR5cGUpCgkJICAgICogKDUpICJMZXQgW0RlZmluaXRpb246XSAgdGhlIHdpbGQgSURzIGJlIHRoZSBzZXQgb2YKCQkgICAgKiBhbGwgYXR0cmlidXRlIGluZm9ybWF0aW9uIGl0ZW0gdG8gd2hpY2ggY2xhdXNlIDMuMgoJCSAgICAqIGFwcGxpZWQgYW5kIHdob3NlILd2YWxpZGF0aW9utyByZXN1bHRlZCBpbiBhCgkJICAgICogt2NvbnRleHQtZGV0ZXJtaW5lZCBkZWNsYXJhdGlvbrcgb2YgbXVzdEZpbmQgb3Igbm8KCQkgICAgKiC3Y29udGV4dC1kZXRlcm1pbmVkIGRlY2xhcmF0aW9utyBhdCBhbGwsIGFuZCB3aG9zZQoJCSAgICAqIFtsb2NhbCBuYW1lXSBhbmQgW25hbWVzcGFjZSBuYW1lXSByZXNvbHZlIChhcwoJCSAgICAqIGRlZmluZWQgYnkgUU5hbWUgcmVzb2x1dGlvbiAoSW5zdGFuY2UpICinMy4xNS40KSkgdG8KCQkgICAgKiBhbiBhdHRyaWJ1dGUgZGVjbGFyYXRpb24gd2hvc2Uge3R5cGUgZGVmaW5pdGlvbn0gaXMKCQkgICAgKiBvciBpcyBkZXJpdmVkIGZyb20gSUQuIFRoZW4gYWxsIG9mIHRoZSBmb2xsb3dpbmcKCQkgICAgKiBtdXN0IGJlIHRydWU6IgoJCSAgICAqLwoJCSAgICBpYXR0ci0+dHlwZURlZiA9IFdYU19BVFRSX1RZUEVERUYoaWF0dHItPmRlY2wpOwoJCSAgICBpZiAoeG1sU2NoZW1hSXNEZXJpdmVkRnJvbUJ1aWx0SW5UeXBlKAoJCQlpYXR0ci0+dHlwZURlZiwgWE1MX1NDSEVNQVNfSUQpKSB7CgkJCS8qCgkJCSogU1BFQyAoNS4xKSAiVGhlcmUgbXVzdCBiZSBubyBtb3JlIHRoYW4gb25lCgkJCSogaXRlbSBpbiC3d2lsZCBJRHO3LiIKCQkJKi8KCQkJaWYgKHdpbGRJRHMgIT0gMCkgewoJCQkgICAgLyogVkFMIFRPRE8gKi8KCQkJICAgIGlhdHRyLT5zdGF0ZSA9IFhNTF9TQ0hFTUFTX0FUVFJfRVJSX1dJTERfRFVQTElDQVRFX0lEOwoJCQkgICAgVE9ETwoJCQkgICAgY29udGludWU7CgkJCX0KCQkJd2lsZElEcysrOwoJCQkvKgoJCQkqIFNQRUMgKGN2Yy1jb21wbGV4LXR5cGUpCgkJCSogKDUuMikgIklmILd3aWxkIElEc7cgaXMgbm9uLWVtcHR5LCB0aGVyZSBtdXN0IG5vdAoJCQkqIGJlIGFueSBhdHRyaWJ1dGUgdXNlcyBhbW9uZyB0aGUge2F0dHJpYnV0ZSB1c2VzfQoJCQkqIHdob3NlIHthdHRyaWJ1dGUgZGVjbGFyYXRpb259J3Mge3R5cGUgZGVmaW5pdGlvbn0KCQkJKiBpcyBvciBpcyBkZXJpdmVkIGZyb20gSUQuIgoJCQkqLwoJCQlmb3IgKGogPSAwOyBqIDwgYXR0clVzZUxpc3QtPm5iSXRlbXM7IGorKykgewoJCQkgICAgaWYgKHhtbFNjaGVtYUlzRGVyaXZlZEZyb21CdWlsdEluVHlwZSgKCQkJCVdYU19BVFRSVVNFX1RZUEVERUYoYXR0clVzZUxpc3QtPml0ZW1zW2pdKSwKCQkJCVhNTF9TQ0hFTUFTX0lEKSkgewoJCQkJLyogVVJHRU5UIFZBTCBUT0RPOiBpbXBsZW1lbnQgKi8KCQkJCWlhdHRyLT5zdGF0ZSA9IFhNTF9TQ0hFTUFTX0FUVFJfRVJSX1dJTERfQU5EX1VTRV9JRDsKCQkJCVRPRE8KCQkJCWJyZWFrOwoJCQkgICAgfQoJCQl9CgkJICAgIH0KCQl9IGVsc2UgaWYgKHR5cGUtPmF0dHJpYnV0ZVdpbGRjYXJkLT5wcm9jZXNzQ29udGVudHMgPT0KCQkgICAgWE1MX1NDSEVNQVNfQU5ZX0xBWCkgewoJCSAgICBpYXR0ci0+c3RhdGUgPSBYTUxfU0NIRU1BU19BVFRSX1dJTERfTEFYX05PX0RFQ0w7CgkJICAgIC8qCgkJICAgICogU1BFQyBQU1ZJIEFzc2Vzc21lbnQgT3V0Y29tZSAoQXR0cmlidXRlKQoJCSAgICAqIFt2YWxpZGl0eV0gPSAibm90S25vd24iCgkJICAgICogW3ZhbGlkYXRpb24gYXR0ZW1wdGVkXSA9ICJub25lIgoJCSAgICAqLwoJCX0gZWxzZSB7CgkJICAgIGlhdHRyLT5zdGF0ZSA9IFhNTF9TQ0hFTUFTX0FUVFJfRVJSX1dJTERfU1RSSUNUX05PX0RFQ0w7CgkJfQoJICAgIH0KCX0KICAgIH0KCiAgICBpZiAodmN0eHQtPm5iQXR0ckluZm9zID09IDApCglyZXR1cm4gKDApOwoKICAgIC8qCiAgICAqIFZhbGlkYXRlIHZhbHVlcywgY3JlYXRlIGRlZmF1bHQgYXR0cmlidXRlcywgZXZhbHVhdGUgSURDcy4KICAgICovCiAgICBmb3IgKGkgPSAwOyBpIDwgdmN0eHQtPm5iQXR0ckluZm9zOyBpKyspIHsKCWlhdHRyID0gdmN0eHQtPmF0dHJJbmZvc1tpXTsKCS8qCgkqIFZBTCBUT0RPOiBOb3RlIHRoYXQgd2Ugd29uJ3QgdHJ5IHRvIHJlc29sdmUgSURDcyB0bwoJKiAibGF4IiBhbmQgInNraXAiIHZhbGlkYXRlZCBhdHRyaWJ1dGVzLiBDaGVjayB3aGF0IHRvCgkqIGRvIGluIHRoaXMgY2FzZS4KCSovCglpZiAoKGlhdHRyLT5zdGF0ZSAhPSBYTUxfU0NIRU1BU19BVFRSX0FTU0VTU0VEKSAmJgoJICAgIChpYXR0ci0+c3RhdGUgIT0gWE1MX1NDSEVNQVNfQVRUUl9ERUZBVUxUKSkKCSAgICBjb250aW51ZTsKCS8qCgkqIFZBTCBUT0RPOiBXaGF0IHRvIGRvIGlmIHRoZSB0eXBlIGRlZmluaXRpb24gaXMgbWlzc2luZz8KCSovCglpZiAoaWF0dHItPnR5cGVEZWYgPT0gTlVMTCkgewoJICAgIGlhdHRyLT5zdGF0ZSA9IFhNTF9TQ0hFTUFTX0FUVFJfRVJSX05PX1RZUEU7CgkgICAgY29udGludWU7Cgl9CgoJQUNUSVZBVEVfQVRUUklCVVRFKGlhdHRyKTsKCWZpeGVkID0gMDsKCXhwYXRoUmVzID0gMDsKCglpZiAodmN0eHQtPnhwYXRoU3RhdGVzICE9IE5VTEwpIHsKCSAgICAvKgoJICAgICogRXZhbHVhdGUgSURDcy4KCSAgICAqLwoJICAgIHhwYXRoUmVzID0geG1sU2NoZW1hWFBhdGhFdmFsdWF0ZSh2Y3R4dCwKCQlYTUxfQVRUUklCVVRFX05PREUpOwoJICAgIGlmICh4cGF0aFJlcyA9PSAtMSkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZBdHRyaWJ1dGVzQ29tcGxleCIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVhQYXRoRXZhbHVhdGUoKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJfQoKCWlmIChpYXR0ci0+c3RhdGUgPT0gWE1MX1NDSEVNQVNfQVRUUl9ERUZBVUxUKSB7CgkgICAgLyoKCSAgICAqIERlZmF1bHQvZml4ZWQgYXR0cmlidXRlcy4KCSAgICAqLwoJICAgIGlmICh4cGF0aFJlcykgewoJCWlmIChpYXR0ci0+dXNlLT5kZWZWYWx1ZSAhPSBOVUxMKSB7CgkJICAgIGlhdHRyLT52YWx1ZSA9ICh4bWxDaGFyICopIGlhdHRyLT51c2UtPmRlZlZhbHVlOwoJCSAgICBpYXR0ci0+dmFsID0gaWF0dHItPnVzZS0+ZGVmVmFsOwoJCX0gZWxzZSB7CgkJICAgIGlhdHRyLT52YWx1ZSA9ICh4bWxDaGFyICopIGlhdHRyLT5kZWNsLT5kZWZWYWx1ZTsKCQkgICAgaWF0dHItPnZhbCA9IGlhdHRyLT5kZWNsLT5kZWZWYWw7CgkJfQoJCS8qCgkJKiBJRENzIHdpbGwgY29uc3VtZSB0aGUgcHJlY29tcHV0ZWQgZGVmYXVsdCB2YWx1ZSwKCQkqIHNvIHdlIG5lZWQgdG8gY2xvbmUgaXQuCgkJKi8KCQlpZiAoaWF0dHItPnZhbCA9PSBOVUxMKSB7CgkJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVZBdHRyaWJ1dGVzQ29tcGxleCIsCgkJCSJkZWZhdWx0L2ZpeGVkIHZhbHVlIG9uIGFuIGF0dHJpYnV0ZSB1c2Ugd2FzICIKCQkJIm5vdCBwcmVjb21wdXRlZCIpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KCQlpYXR0ci0+dmFsID0geG1sU2NoZW1hQ29weVZhbHVlKGlhdHRyLT52YWwpOwoJCWlmIChpYXR0ci0+dmFsID09IE5VTEwpIHsKCQkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVkF0dHJpYnV0ZXNDb21wbGV4IiwKCQkJImNhbGxpbmcgeG1sU2NoZW1hQ29weVZhbHVlKCkiKTsKCQkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKCQl9CgkgICAgfQoJICAgIC8qCgkgICAgKiBQU1ZJOiBBZGQgdGhlIGRlZmF1bHQgYXR0cmlidXRlIHRvIHRoZSBjdXJyZW50IGVsZW1lbnQuCgkgICAgKiBWQUwgVE9ETzogU2hvdWxkIHdlIHVzZSB0aGUgKm5vcm1hbGl6ZWQqIHZhbHVlPyBUaGlzIGN1cnJlbnRseQoJICAgICogICB1c2VzIHRoZSAqaW5pdGlhbCogdmFsdWUuCgkgICAgKi8KCSAgICBpZiAoKHZjdHh0LT5vcHRpb25zICYgWE1MX1NDSEVNQV9WQUxfVkNfSV9DUkVBVEUpICYmCgkJKGlhdHRyLT5ub2RlICE9IE5VTEwpICYmIChpYXR0ci0+bm9kZS0+ZG9jICE9IE5VTEwpKSB7CgkJeG1sQ2hhciAqbm9ybVZhbHVlOwoJCWNvbnN0IHhtbENoYXIgKnZhbHVlOwoKCQl2YWx1ZSA9IGlhdHRyLT52YWx1ZTsKCQkvKgoJCSogTm9ybWFsaXplIHRoZSB2YWx1ZS4KCQkqLwoJCW5vcm1WYWx1ZSA9IHhtbFNjaGVtYU5vcm1hbGl6ZVZhbHVlKGlhdHRyLT50eXBlRGVmLAoJCSAgICBpYXR0ci0+dmFsdWUpOwoJCWlmIChub3JtVmFsdWUgIT0gTlVMTCkKCQkgICAgdmFsdWUgPSBCQURfQ0FTVCBub3JtVmFsdWU7CgoJCWlmIChpYXR0ci0+bnNOYW1lID09IE5VTEwpIHsKCQkgICAgaWYgKHhtbE5ld1Byb3AoaWF0dHItPm5vZGUtPnBhcmVudCwKCQkJaWF0dHItPmxvY2FsTmFtZSwgdmFsdWUpID09IE5VTEwpIHsKCQkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVkF0dHJpYnV0ZXNDb21wbGV4IiwKCQkJICAgICJjYWxsbGluZyB4bWxOZXdQcm9wKCkiKTsKCQkJaWYgKG5vcm1WYWx1ZSAhPSBOVUxMKQoJCQkgICAgeG1sRnJlZShub3JtVmFsdWUpOwoJCQlnb3RvIGludGVybmFsX2Vycm9yOwoJCSAgICB9CgkJfSBlbHNlIHsKCQkgICAgeG1sTnNQdHIgbnM7CgoJCSAgICBucyA9IHhtbFNlYXJjaE5zQnlIcmVmKGlhdHRyLT5ub2RlLT5kb2MsCgkJCWlhdHRyLT5ub2RlLT5wYXJlbnQsIGlhdHRyLT5uc05hbWUpOwoJCSAgICBpZiAobnMgPT0gTlVMTCkgewoJCQl4bWxDaGFyIHByZWZpeFsxMl07CgkJCWludCBjb3VudGVyID0gMDsKCgkJCS8qCgkJCSogQ3JlYXRlIGEgbmFtZXNwYWNlIGRlY2xhcmF0aW9uIG9uIHRoZSB2YWxpZGF0aW9uCgkJCSogcm9vdCBub2RlIGlmIG5vIG5hbWVzcGFjZSBkZWNsYXJhdGlvbiBpcyBpbiBzY29wZS4KCQkJKi8KCQkJZG8gewoJCQkgICAgc25wcmludGYoKGNoYXIgKikgcHJlZml4LCAxMiwgInAlZCIsIGNvdW50ZXIrKyk7CgkJCSAgICBucyA9IHhtbFNlYXJjaE5zKGlhdHRyLT5ub2RlLT5kb2MsCgkJCQlpYXR0ci0+bm9kZS0+cGFyZW50LCBCQURfQ0FTVCBwcmVmaXgpOwoJCQkgICAgaWYgKGNvdW50ZXIgPiAxMDAwKSB7CgkJCQlWRVJST1JfSU5UKAoJCQkJICAgICJ4bWxTY2hlbWFWQXR0cmlidXRlc0NvbXBsZXgiLAoJCQkJICAgICJjb3VsZCBub3QgY29tcHV0ZSBhIG5zIHByZWZpeCBmb3IgYSAiCgkJCQkgICAgImRlZmF1bHQvZml4ZWQgYXR0cmlidXRlIik7CgkJCQlpZiAobm9ybVZhbHVlICE9IE5VTEwpCgkJCQkgICAgeG1sRnJlZShub3JtVmFsdWUpOwoJCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkJICAgIH0KCQkJfSB3aGlsZSAobnMgIT0gTlVMTCk7CgkJCW5zID0geG1sTmV3TnModmN0eHQtPnZhbGlkYXRpb25Sb290LAoJCQkgICAgaWF0dHItPm5zTmFtZSwgQkFEX0NBU1QgcHJlZml4KTsKCQkgICAgfQoJCSAgICAvKgoJCSAgICAqIFRPRE86CgkJICAgICogaHR0cDovL2xpc3RzLnczLm9yZy9BcmNoaXZlcy9QdWJsaWMvd3d3LXhtbC1zY2hlbWEtY29tbWVudHMvMjAwNUp1bFNlcC8wNDA2Lmh0bWwKCQkgICAgKiBJZiB3ZSBoYXZlIFFOYW1lczogZG8gd2UgbmVlZCB0byBlbnN1cmUgdGhlcmUncyBhCgkJICAgICogcHJlZml4IGRlZmluZWQgZm9yIHRoZSBRTmFtZT8KCQkgICAgKi8KCQkgICAgeG1sTmV3TnNQcm9wKGlhdHRyLT5ub2RlLT5wYXJlbnQsIG5zLAoJCQlpYXR0ci0+bG9jYWxOYW1lLCB2YWx1ZSk7CgkJfQoJCWlmIChub3JtVmFsdWUgIT0gTlVMTCkKCQkgICAgeG1sRnJlZShub3JtVmFsdWUpOwoJICAgIH0KCSAgICAvKgoJICAgICogR28gZGlyZWN0bHkgdG8gSURDIGV2YWx1YXRpb24uCgkgICAgKi8KCSAgICBnb3RvIGV2YWxfaWRjczsKCX0KCS8qCgkqIFZhbGlkYXRlIHRoZSB2YWx1ZS4KCSovCglpZiAodmN0eHQtPnZhbHVlICE9IE5VTEwpIHsKCSAgICAvKgoJICAgICogRnJlZSBsYXN0IGNvbXB1dGVkIHZhbHVlOyBqdXN0IGZvciBzYWZldHkgcmVhc29ucy4KCSAgICAqLwoJICAgIHhtbFNjaGVtYUZyZWVWYWx1ZSh2Y3R4dC0+dmFsdWUpOwoJICAgIHZjdHh0LT52YWx1ZSA9IE5VTEw7Cgl9CgkvKgoJKiBOb3RlIHRoYXQgdGhlIGF0dHJpYnV0ZSAqdXNlKiBjYW4gYmUgdW5hdmFpbGFibGUsIGlmCgkqIHRoZSBhdHRyaWJ1dGUgd2FzIGEgd2lsZCBhdHRyaWJ1dGUuCgkqLwoJaWYgKChpYXR0ci0+ZGVjbC0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSX0ZJWEVEKSB8fAoJICAgICgoaWF0dHItPnVzZSAhPSBOVUxMKSAmJgoJICAgICAoaWF0dHItPnVzZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BU19BVFRSX0ZJWEVEKSkpCgkgICAgZml4ZWQgPSAxOwoJZWxzZQoJICAgIGZpeGVkID0gMDsKCS8qCgkqIFNQRUMgKGN2Yy1hdHRyaWJ1dGUpCgkqICgzKSAiVGhlIGl0ZW0ncyC3bm9ybWFsaXplZCB2YWx1ZbcgbXVzdCBiZSBsb2NhbGx5ILd2YWxpZLcKCSogd2l0aCByZXNwZWN0IHRvIHRoYXQge3R5cGUgZGVmaW5pdGlvbn0gYXMgcGVyIAoJKiBTdHJpbmcgVmFsaWQgKKczLjE0LjQpLiIKCSoKCSogVkFMIFRPRE86IERvIHdlIGFscmVhZHkgaGF2ZSB0aGUKCSogIm5vcm1hbGl6ZWQgYXR0cmlidXRlIHZhbHVlIiBoZXJlPwoJKi8KCWlmICh4cGF0aFJlcyB8fCBmaXhlZCkgewoJICAgIGlhdHRyLT5mbGFncyB8PSBYTUxfU0NIRU1BX05PREVfSU5GT19WQUxVRV9ORUVERUQ7CgkgICAgLyoKCSAgICAqIFJlcXVlc3QgYSBjb21wdXRlZCB2YWx1ZS4KCSAgICAqLwoJICAgIHJlcyA9IHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoCgkJQUNUWFRfQ0FTVCB2Y3R4dCwKCQlpYXR0ci0+bm9kZSwgaWF0dHItPnR5cGVEZWYsIGlhdHRyLT52YWx1ZSwgJihpYXR0ci0+dmFsKSwKCQkxLCAxLCAwKTsKCX0gZWxzZSB7CgkgICAgcmVzID0geG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSgKCQlBQ1RYVF9DQVNUIHZjdHh0LAoJCWlhdHRyLT5ub2RlLCBpYXR0ci0+dHlwZURlZiwgaWF0dHItPnZhbHVlLCBOVUxMLAoJCTEsIDAsIDApOwoJfQoJICAgIAoJaWYgKHJlcyAhPSAwKSB7CgkgICAgaWYgKHJlcyA9PSAtMSkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZBdHRyaWJ1dGVzQ29tcGxleCIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVN0cmVhbVZhbGlkYXRlU2ltcGxlVHlwZVZhbHVlKCkiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCSAgICBpYXR0ci0+c3RhdGUgPSBYTUxfU0NIRU1BU19BVFRSX0lOVkFMSURfVkFMVUU7CgkgICAgLyoKCSAgICAqIFNQRUMgUFNWSSBBc3Nlc3NtZW50IE91dGNvbWUgKEF0dHJpYnV0ZSkKCSAgICAqIFt2YWxpZGl0eV0gPSAiaW52YWxpZCIKCSAgICAqLwoJICAgIGdvdG8gZXZhbF9pZGNzOwoJfQoKCWlmIChmaXhlZCkgewkgICAgCgkgICAgLyoKCSAgICAqIFNQRUMgQXR0cmlidXRlIExvY2FsbHkgVmFsaWQgKFVzZSkgKGN2Yy1hdSkKCSAgICAqICJGb3IgYW4gYXR0cmlidXRlIGluZm9ybWF0aW9uIGl0ZW0gdG8gYmW3dmFsaWS3CgkgICAgKiB3aXRoIHJlc3BlY3QgdG8gYW4gYXR0cmlidXRlIHVzZSBpdHMgKm5vcm1hbGl6ZWQqCgkgICAgKiB2YWx1ZbcgbXVzdCBtYXRjaCB0aGUgKmNhbm9uaWNhbCogbGV4aWNhbAoJICAgICogcmVwcmVzZW50YXRpb24gb2YgdGhlIGF0dHJpYnV0ZSB1c2UncyB7dmFsdWUKCSAgICAqIGNvbnN0cmFpbnR9dmFsdWUsIGlmIGl0IGlzIHByZXNlbnQgYW5kIGZpeGVkLiIKCSAgICAqCgkgICAgKiBWQUwgVE9ETzogVGhlIHJlcXVpcmVtZW50IGZvciB0aGUgKmNhbm9uaWNhbCogdmFsdWUKCSAgICAqIHdpbGwgYmUgcmVtb3ZlZCBpbiBYTUwgU2NoZW1hIDEuMS4KCSAgICAqLwoJICAgIC8qCgkgICAgKiBTUEVDIEF0dHJpYnV0ZSBMb2NhbGx5IFZhbGlkIChjdmMtYXR0cmlidXRlKQoJICAgICogKDQpICJUaGUgaXRlbSdzICphY3R1YWwqIHZhbHVltyBtdXN0IG1hdGNoIHRoZSAqdmFsdWUqIG9mCgkgICAgKiB0aGUge3ZhbHVlIGNvbnN0cmFpbnR9LCBpZiBpdCBpcyBwcmVzZW50IGFuZCBmaXhlZC4iCgkgICAgKi8KCSAgICBpZiAoaWF0dHItPnZhbCA9PSBOVUxMKSB7CgkJLyogVkFMIFRPRE86IEEgdmFsdWUgd2FzIG5vdCBwcmVjb21wdXRlZC4gKi8KCQlUT0RPCgkJZ290byBldmFsX2lkY3M7CgkgICAgfQoJICAgIGlmICgoaWF0dHItPnVzZSAhPSBOVUxMKSAmJgoJCShpYXR0ci0+dXNlLT5kZWZWYWx1ZSAhPSBOVUxMKSkgewoJCWlmIChpYXR0ci0+dXNlLT5kZWZWYWwgPT0gTlVMTCkgewoJCSAgICAvKiBWQUwgVE9ETzogQSBkZWZhdWx0IHZhbHVlIHdhcyBub3QgcHJlY29tcHV0ZWQuICovCgkJICAgIFRPRE8KCQkgICAgZ290byBldmFsX2lkY3M7CgkJfQoJCWlhdHRyLT52Y1ZhbHVlID0gaWF0dHItPnVzZS0+ZGVmVmFsdWU7CgkJLyoKCQlpZiAoeG1sU2NoZW1hQ29tcGFyZVZhbHVlc1dodHNwKGF0dHItPnZhbCwKCQkgICAgKHhtbFNjaGVtYVdoaXRlc3BhY2VWYWx1ZVR5cGUpIHdzLAoJCSAgICBhdHRyLT51c2UtPmRlZlZhbCwKCQkgICAgKHhtbFNjaGVtYVdoaXRlc3BhY2VWYWx1ZVR5cGUpIHdzKSAhPSAwKSB7CgkJKi8KCQlpZiAoISB4bWxTY2hlbWFBcmVWYWx1ZXNFcXVhbChpYXR0ci0+dmFsLCBpYXR0ci0+dXNlLT5kZWZWYWwpKQoJCSAgICBpYXR0ci0+c3RhdGUgPSBYTUxfU0NIRU1BU19BVFRSX0VSUl9GSVhFRF9WQUxVRTsKCSAgICB9IGVsc2UgewoJCWlmIChpYXR0ci0+ZGVjbC0+ZGVmVmFsID09IE5VTEwpIHsKCQkgICAgLyogVkFMIFRPRE86IEEgZGVmYXVsdCB2YWx1ZSB3YXMgbm90IHByZWNvbXB1dGVkLiAqLwoJCSAgICBUT0RPCgkJICAgIGdvdG8gZXZhbF9pZGNzOwoJCX0KCQlpYXR0ci0+dmNWYWx1ZSA9IGlhdHRyLT5kZWNsLT5kZWZWYWx1ZTsKCQkvKgoJCWlmICh4bWxTY2hlbWFDb21wYXJlVmFsdWVzV2h0c3AoYXR0ci0+dmFsLAoJCSAgICAoeG1sU2NoZW1hV2hpdGVzcGFjZVZhbHVlVHlwZSkgd3MsCgkJICAgIGF0dHJEZWNsLT5kZWZWYWwsCgkJICAgICh4bWxTY2hlbWFXaGl0ZXNwYWNlVmFsdWVUeXBlKSB3cykgIT0gMCkgewoJCSovCgkJaWYgKCEgeG1sU2NoZW1hQXJlVmFsdWVzRXF1YWwoaWF0dHItPnZhbCwgaWF0dHItPmRlY2wtPmRlZlZhbCkpCgkJICAgIGlhdHRyLT5zdGF0ZSA9IFhNTF9TQ0hFTUFTX0FUVFJfRVJSX0ZJWEVEX1ZBTFVFOwoJICAgIH0KCSAgICAvKgoJICAgICogW3ZhbGlkaXR5XSA9ICJ2YWxpZCIKCSAgICAqLwoJfQpldmFsX2lkY3M6CgkvKgoJKiBFdmFsdWF0ZSBJRENzLgoJKi8KCWlmICh4cGF0aFJlcykgewoJICAgIGlmICh4bWxTY2hlbWFYUGF0aFByb2Nlc3NIaXN0b3J5KHZjdHh0LAoJCXZjdHh0LT5kZXB0aCArMSkgPT0gLTEpIHsKCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWQXR0cmlidXRlc0NvbXBsZXgiLAoJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFYUGF0aEV2YWx1YXRlKCkiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCX0gZWxzZSBpZiAodmN0eHQtPnhwYXRoU3RhdGVzICE9IE5VTEwpCgkgICAgeG1sU2NoZW1hWFBhdGhQb3AodmN0eHQpOwogICAgfQoKICAgIC8qCiAgICAqIFJlcG9ydCBlcnJvcnMuCiAgICAqLwogICAgZm9yIChpID0gMDsgaSA8IHZjdHh0LT5uYkF0dHJJbmZvczsgaSsrKSB7CglpYXR0ciA9IHZjdHh0LT5hdHRySW5mb3NbaV07CglpZiAoKGlhdHRyLT5zdGF0ZSA9PSBYTUxfU0NIRU1BU19BVFRSX01FVEEpIHx8CgkgICAgKGlhdHRyLT5zdGF0ZSA9PSBYTUxfU0NIRU1BU19BVFRSX0FTU0VTU0VEKSB8fAoJICAgIChpYXR0ci0+c3RhdGUgPT0gWE1MX1NDSEVNQVNfQVRUUl9XSUxEX1NLSVApIHx8CgkgICAgKGlhdHRyLT5zdGF0ZSA9PSBYTUxfU0NIRU1BU19BVFRSX1dJTERfTEFYX05PX0RFQ0wpKQoJICAgIGNvbnRpbnVlOwoJQUNUSVZBVEVfQVRUUklCVVRFKGlhdHRyKTsKCXN3aXRjaCAoaWF0dHItPnN0YXRlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BU19BVFRSX0VSUl9NSVNTSU5HOiB7CgkJICAgIHhtbENoYXIgKnN0ciA9IE5VTEw7CgkJICAgIEFDVElWQVRFX0VMRU07CgkJICAgIHhtbFNjaGVtYUN1c3RvbUVycihBQ1RYVF9DQVNUIHZjdHh0LAoJCQlYTUxfU0NIRU1BVl9DVkNfQ09NUExFWF9UWVBFXzQsIE5VTEwsIE5VTEwsCgkJCSJUaGUgYXR0cmlidXRlICclcycgaXMgcmVxdWlyZWQgYnV0IG1pc3NpbmciLAoJCQl4bWxTY2hlbWFGb3JtYXRRTmFtZSgmc3RyLAoJCQkgICAgaWF0dHItPmRlY2wtPnRhcmdldE5hbWVzcGFjZSwKCQkJICAgIGlhdHRyLT5kZWNsLT5uYW1lKSwKCQkJTlVMTCk7CgkJICAgIEZSRUVfQU5EX05VTEwoc3RyKQoJCSAgICBicmVhazsKCQl9CgkgICAgY2FzZSBYTUxfU0NIRU1BU19BVFRSX0VSUl9OT19UWVBFOgoJCVZFUlJPUihYTUxfU0NIRU1BVl9DVkNfQVRUUklCVVRFXzIsIE5VTEwsCgkJICAgICJUaGUgdHlwZSBkZWZpbml0aW9uIGlzIGFic2VudCIpOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQVNfQVRUUl9FUlJfRklYRURfVkFMVUU6CgkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJICAgIFhNTF9TQ0hFTUFWX0NWQ19BVSwgTlVMTCwgTlVMTCwKCQkgICAgIlRoZSB2YWx1ZSAnJXMnIGRvZXMgbm90IG1hdGNoIHRoZSBmaXhlZCAiCgkJICAgICJ2YWx1ZSBjb25zdHJhaW50ICclcyciLCAKCQkgICAgaWF0dHItPnZhbHVlLCBpYXR0ci0+dmNWYWx1ZSk7CQkKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFTX0FUVFJfRVJSX1dJTERfU1RSSUNUX05PX0RFQ0w6CgkJVkVSUk9SKFhNTF9TQ0hFTUFWX0NWQ19XSUxEQ0FSRCwgTlVMTCwKCQkgICAgIk5vIG1hdGNoaW5nIGdsb2JhbCBhdHRyaWJ1dGUgZGVjbGFyYXRpb24gYXZhaWxhYmxlLCBidXQgIgoJCSAgICAiZGVtYW5kZWQgYnkgdGhlIHN0cmljdCB3aWxkY2FyZCIpOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQVNfQVRUUl9VTktOT1dOOgoJCWlmIChpYXR0ci0+bWV0YVR5cGUpCgkJICAgIGJyZWFrOwoJCS8qCgkJKiBNQVlCRSBWQUwgVE9ETzogT25lIG1pZ2h0IHJlcG9ydCBkaWZmZXJlbnQgZXJyb3IgbWVzc2FnZXMKCQkqIGZvciB0aGUgZm9sbG93aW5nIGVycm9ycy4KCQkqLwoJCWlmICh0eXBlLT5hdHRyaWJ1dGVXaWxkY2FyZCA9PSBOVUxMKSB7CgkJICAgIHhtbFNjaGVtYUlsbGVnYWxBdHRyRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJCVhNTF9TQ0hFTUFWX0NWQ19DT01QTEVYX1RZUEVfM18yXzEsIGlhdHRyLCBOVUxMKTsKCQl9IGVsc2UgewoJCSAgICB4bWxTY2hlbWFJbGxlZ2FsQXR0ckVycihBQ1RYVF9DQVNUIHZjdHh0LAoJCQlYTUxfU0NIRU1BVl9DVkNfQ09NUExFWF9UWVBFXzNfMl8yLCBpYXR0ciwgTlVMTCk7CgkJfQoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CiAgICB9CgogICAgQUNUSVZBVEVfRUxFTTsKICAgIHJldHVybiAoMCk7CmludGVybmFsX2Vycm9yOgogICAgQUNUSVZBVEVfRUxFTTsKICAgIHJldHVybiAoLTEpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVZhbGlkYXRlRWxlbVdpbGRjYXJkKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCwKCQkJICAgICAgaW50ICpza2lwKQp7CiAgICB4bWxTY2hlbWFXaWxkY2FyZFB0ciB3aWxkID0gKHhtbFNjaGVtYVdpbGRjYXJkUHRyKSB2Y3R4dC0+aW5vZGUtPmRlY2w7CiAgICAvKgogICAgKiBUaGUgbmFtZXNwYWNlIG9mIHRoZSBlbGVtZW50IHdhcyBhbHJlYWR5IGlkZW50aWZpZWQgdG8gYmUKICAgICogbWF0Y2hpbmcgdGhlIHdpbGRjYXJkLgogICAgKi8KICAgIGlmICgoc2tpcCA9PSBOVUxMKSB8fCAod2lsZCA9PSBOVUxMKSB8fAoJKHdpbGQtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0FOWSkpIHsKCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRlRWxlbVdpbGRjYXJkIiwKCSAgICAiYmFkIGFyZ3VtZW50cyIpOwoJcmV0dXJuICgtMSk7CiAgICB9CiAgICAqc2tpcCA9IDA7CiAgICBpZiAod2lsZC0+cHJvY2Vzc0NvbnRlbnRzID09IFhNTF9TQ0hFTUFTX0FOWV9TS0lQKSB7CgkvKgoJKiBVUkdFTlQgVkFMIFRPRE86IEVpdGhlciB3ZSBuZWVkIHRvIHBvc2l0aW9uIHRoZSBzdHJlYW0gdG8gdGhlCgkqIG5leHQgc2libGluZywgb3Igd2FsayB0aGUgd2hvbGUgc3VidHJlZS4KCSovCgkqc2tpcCA9IDE7CglyZXR1cm4gKDApOwogICAgfQogICAgewoJeG1sU2NoZW1hRWxlbWVudFB0ciBkZWNsID0gTlVMTDsKCglkZWNsID0geG1sU2NoZW1hR2V0RWxlbSh2Y3R4dC0+c2NoZW1hLAoJICAgIHZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lLCB2Y3R4dC0+aW5vZGUtPm5zTmFtZSk7CSAgICAKCWlmIChkZWNsICE9IE5VTEwpIHsKCSAgICB2Y3R4dC0+aW5vZGUtPmRlY2wgPSBkZWNsOwoJICAgIHJldHVybiAoMCk7Cgl9CiAgICB9CiAgICBpZiAod2lsZC0+cHJvY2Vzc0NvbnRlbnRzID09IFhNTF9TQ0hFTUFTX0FOWV9TVFJJQ1QpIHsKCS8qIFZBTCBUT0RPOiBDaGFuZ2UgdG8gcHJvcGVyIGVycm9yIGNvZGUuICovCglWRVJST1IoWE1MX1NDSEVNQVZfQ1ZDX0VMVF8xLCBOVUxMLCAvKiBXWFNfQkFTSUNfQ0FTVCB3aWxkICovCgkgICAgIk5vIG1hdGNoaW5nIGdsb2JhbCBlbGVtZW50IGRlY2xhcmF0aW9uIGF2YWlsYWJsZSwgYnV0ICIKCSAgICAiZGVtYW5kZWQgYnkgdGhlIHN0cmljdCB3aWxkY2FyZCIpOwoJcmV0dXJuICh2Y3R4dC0+ZXJyKTsKICAgIH0KICAgIGlmICh2Y3R4dC0+bmJBdHRySW5mb3MgIT0gMCkgewoJeG1sU2NoZW1hQXR0ckluZm9QdHIgaWF0dHI7CgkvKgoJKiBTUEVDIFZhbGlkYXRpb24gUnVsZTogU2NoZW1hLVZhbGlkaXR5IEFzc2Vzc21lbnQgKEVsZW1lbnQpCgkqICgxLjIuMS4yLjEpIC0gKDEuMi4xLjIuMyApCgkqCgkqIFVzZSB0aGUgeHNpOnR5cGUgYXR0cmlidXRlIGZvciB0aGUgdHlwZSBkZWZpbml0aW9uLgoJKi8KCWlhdHRyID0geG1sU2NoZW1hR2V0TWV0YUF0dHJJbmZvKHZjdHh0LAoJICAgIFhNTF9TQ0hFTUFfQVRUUl9JTkZPX01FVEFfWFNJX1RZUEUpOwoJaWYgKGlhdHRyICE9IE5VTEwpIHsKCSAgICBpZiAoeG1sU2NoZW1hUHJvY2Vzc1hTSVR5cGUodmN0eHQsIGlhdHRyLAoJCSYodmN0eHQtPmlub2RlLT50eXBlRGVmKSwgTlVMTCkgPT0gLTEpIHsKCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUVsZW1XaWxkY2FyZCIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVByb2Nlc3NYU0lUeXBlKCkgdG8gIgoJCSAgICAicHJvY2VzcyB0aGUgYXR0cmlidXRlICd4c2k6bmlsJyIpOwoJCXJldHVybiAoLTEpOwoJICAgIH0KCSAgICAvKgoJICAgICogRG9uJ3QgcmV0dXJuIGFuIGVycm9yIG9uIHB1cnBvc2UuCgkgICAgKi8KCSAgICByZXR1cm4gKDApOwoJfQogICAgfQogICAgLyoKICAgICogU1BFQyBWYWxpZGF0aW9uIFJ1bGU6IFNjaGVtYS1WYWxpZGl0eSBBc3Nlc3NtZW50IChFbGVtZW50KQogICAgKgogICAgKiBGYWxsYmFjayB0byAiYW55VHlwZSIuCiAgICAqLwogICAgdmN0eHQtPmlub2RlLT50eXBlRGVmID0KCXhtbFNjaGVtYUdldEJ1aWx0SW5UeXBlKFhNTF9TQ0hFTUFTX0FOWVRZUEUpOwogICAgcmV0dXJuICgwKTsKfQoKLyoKKiB4bWxTY2hlbWFDaGVja0NPU1ZhbGlkRGVmYXVsdDoKKgoqIFRoaXMgd2lsbCBiZSBjYWxsZWQgaWY6IG5vdCBuaWxsZWQsIG5vIGNvbnRlbnQgYW5kIGEgZGVmYXVsdC9maXhlZAoqIHZhbHVlIGlzIHByb3ZpZGVkLgoqLwoKc3RhdGljIGludAp4bWxTY2hlbWFDaGVja0NPU1ZhbGlkRGVmYXVsdCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlLAoJCQkgICAgICB4bWxTY2hlbWFWYWxQdHIgKnZhbCkKeyAgIAogICAgaW50IHJldCA9IDA7CiAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBpbm9kZSA9IHZjdHh0LT5pbm9kZTsKCiAgICAvKgogICAgKiBjb3MtdmFsaWQtZGVmYXVsdDoKICAgICogU2NoZW1hIENvbXBvbmVudCBDb25zdHJhaW50OiBFbGVtZW50IERlZmF1bHQgVmFsaWQgKEltbWVkaWF0ZSkKICAgICogRm9yIGEgc3RyaW5nIHRvIGJlIGEgdmFsaWQgZGVmYXVsdCB3aXRoIHJlc3BlY3QgdG8gYSB0eXBlIAogICAgKiBkZWZpbml0aW9uIHRoZSBhcHByb3ByaWF0ZSBjYXNlIGFtb25nIHRoZSBmb2xsb3dpbmcgbXVzdCBiZSB0cnVlOgogICAgKi8gICAgCiAgICBpZiBXWFNfSVNfQ09NUExFWChpbm9kZS0+dHlwZURlZikgewoJLyoKCSogQ29tcGxleCB0eXBlLgoJKgoJKiBTUEVDICgyLjEpICJpdHMge2NvbnRlbnQgdHlwZX0gbXVzdCBiZSBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24KCSogb3IgbWl4ZWQuIgoJKiBTUEVDICgyLjIuMikgIklmIHRoZSB7Y29udGVudCB0eXBlfSBpcyBtaXhlZCwgdGhlbiB0aGUge2NvbnRlbnQKCSogdHlwZX0ncyBwYXJ0aWNsZSBtdXN0IGJlILdlbXB0aWFibGW3IGFzIGRlZmluZWQgYnkgCgkqIFBhcnRpY2xlIEVtcHRpYWJsZSAopzMuOS42KS4iCgkqLwoJaWYgKCghIFdYU19IQVNfU0lNUExFX0NPTlRFTlQoaW5vZGUtPnR5cGVEZWYpKSAmJgoJICAgICgoISBXWFNfSEFTX01JWEVEX0NPTlRFTlQoaW5vZGUtPnR5cGVEZWYpKSB8fAoJICAgICAoISBXWFNfRU1QVElBQkxFKGlub2RlLT50eXBlRGVmKSkpKSB7CgkgICAgcmV0ID0gWE1MX1NDSEVNQVBfQ09TX1ZBTElEX0RFRkFVTFRfMl8xOwoJICAgIC8qIE5PVEUgdGhhdCB0aGlzIGNvdmVycyAoMi4yLjIpIGFzIHdlbGwuICovCgkgICAgVkVSUk9SKHJldCwgTlVMTCwKCQkiRm9yIGEgc3RyaW5nIHRvIGJlIGEgdmFsaWQgZGVmYXVsdCwgdGhlIHR5cGUgZGVmaW5pdGlvbiAiCgkJIm11c3QgYmUgYSBzaW1wbGUgdHlwZSBvciBhIGNvbXBsZXggdHlwZSB3aXRoIHNpbXBsZSBjb250ZW50ICIKCQkib3IgbWl4ZWQgY29udGVudCBhbmQgYSBwYXJ0aWNsZSBlbXB0aWFibGUiKTsKCSAgICByZXR1cm4ocmV0KTsKCX0KICAgIH0JCiAgICAvKgogICAgKiAxIElmIHRoZSB0eXBlIGRlZmluaXRpb24gaXMgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLCB0aGVuIHRoZSBzdHJpbmcgCiAgICAqIG11c3QgYmUgt3ZhbGlktyB3aXRoIHJlc3BlY3QgdG8gdGhhdCBkZWZpbml0aW9uIGFzIGRlZmluZWQgYnkgU3RyaW5nIAogICAgKiBWYWxpZCAopzMuMTQuNCkuCiAgICAqCiAgICAqIEFORAogICAgKgogICAgKiAyLjIuMSBJZiB0aGUge2NvbnRlbnQgdHlwZX0gaXMgYSBzaW1wbGUgdHlwZSBkZWZpbml0aW9uLCB0aGVuIHRoZSAKICAgICogc3RyaW5nIG11c3QgYmUgt3ZhbGlktyB3aXRoIHJlc3BlY3QgdG8gdGhhdCBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIAogICAgKiBhcyBkZWZpbmVkIGJ5IFN0cmluZyBWYWxpZCAopzMuMTQuNCkuCiAgICAqLyAgCiAgICBpZiAoV1hTX0lTX1NJTVBMRShpbm9kZS0+dHlwZURlZikpIHsKCglyZXQgPSB4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKEFDVFhUX0NBU1QgdmN0eHQsCgkgICAgTlVMTCwgaW5vZGUtPnR5cGVEZWYsIHZhbHVlLCB2YWwsIDEsIDEsIDApOwoKICAgIH0gZWxzZSBpZiAoV1hTX0hBU19TSU1QTEVfQ09OVEVOVChpbm9kZS0+dHlwZURlZikpIHsKCglyZXQgPSB4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKEFDVFhUX0NBU1QgdmN0eHQsCgkgICAgTlVMTCwgaW5vZGUtPnR5cGVEZWYtPmNvbnRlbnRUeXBlRGVmLCB2YWx1ZSwgdmFsLCAxLCAxLCAwKTsKICAgIH0KICAgIGlmIChyZXQgPCAwKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFDaGVja0NPU1ZhbGlkRGVmYXVsdCIsCgkgICAgImNhbGxpbmcgeG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSgpIik7CiAgICB9ICAgIAogICAgcmV0dXJuIChyZXQpOwp9CgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFWQ29udGVudE1vZGVsQ2FsbGJhY2soeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0IEFUVFJJQlVURV9VTlVTRUQsCgkJCSAgICAgICBjb25zdCB4bWxDaGFyICogbmFtZSBBVFRSSUJVVEVfVU5VU0VELAoJCQkgICAgICAgeG1sU2NoZW1hRWxlbWVudFB0ciBpdGVtLAoJCQkgICAgICAgeG1sU2NoZW1hTm9kZUluZm9QdHIgaW5vZGUpCnsKICAgIGlub2RlLT5kZWNsID0gaXRlbTsKI2lmZGVmIERFQlVHX0NPTlRFTlQKICAgIHsKCXhtbENoYXIgKnN0ciA9IE5VTEw7CgoJaWYgKGl0ZW0tPnR5cGUgPT0gWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQpIHsKCSAgICB4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwKCQkiQVVUT01BVE9OIGNhbGxiYWNrIGZvciAnJXMnIFtkZWNsYXJhdGlvbl1cbiIsCgkJeG1sU2NoZW1hRm9ybWF0UU5hbWUoJnN0ciwKCQlpbm9kZS0+bG9jYWxOYW1lLCBpbm9kZS0+bnNOYW1lKSk7Cgl9IGVsc2UgewoJICAgIHhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LAoJCSAgICAiQVVUT01BVE9OIGNhbGxiYWNrIGZvciAnJXMnIFt3aWxkY2FyZF1cbiIsCgkJICAgIHhtbFNjaGVtYUZvcm1hdFFOYW1lKCZzdHIsCgkJICAgIGlub2RlLT5sb2NhbE5hbWUsIGlub2RlLT5uc05hbWUpKTsKCgl9CglGUkVFX0FORF9OVUxMKHN0cikKICAgIH0KI2VuZGlmCn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hVmFsaWRhdG9yUHVzaEVsZW0oeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7ICAgIAogICAgdmN0eHQtPmlub2RlID0geG1sU2NoZW1hR2V0RnJlc2hFbGVtSW5mbyh2Y3R4dCk7CiAgICBpZiAodmN0eHQtPmlub2RlID09IE5VTEwpIHsKCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRvclB1c2hFbGVtIiwKCSAgICAiY2FsbGluZyB4bWxTY2hlbWFHZXRGcmVzaEVsZW1JbmZvKCkiKTsKCXJldHVybiAoLTEpOwogICAgfSAgIAogICAgdmN0eHQtPm5iQXR0ckluZm9zID0gMDsKICAgIHJldHVybiAoMCk7Cn0KCnN0YXRpYyBpbnQKeG1sU2NoZW1hVkNoZWNrSU5vZGVEYXRhVHlwZSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJCSAgICAgeG1sU2NoZW1hTm9kZUluZm9QdHIgaW5vZGUsCgkJCSAgICAgeG1sU2NoZW1hVHlwZVB0ciB0eXBlLAoJCQkgICAgIGNvbnN0IHhtbENoYXIgKnZhbHVlKQp7CiAgICBpZiAoaW5vZGUtPmZsYWdzICYgWE1MX1NDSEVNQV9OT0RFX0lORk9fVkFMVUVfTkVFREVEKQoJcmV0dXJuICh4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKAoJICAgIEFDVFhUX0NBU1QgdmN0eHQsIE5VTEwsCgkgICAgdHlwZSwgdmFsdWUsICYoaW5vZGUtPnZhbCksIDEsIDEsIDApKTsKICAgIGVsc2UKCXJldHVybiAoeG1sU2NoZW1hVkNoZWNrQ1ZDU2ltcGxlVHlwZSgKCSAgICBBQ1RYVF9DQVNUIHZjdHh0LCBOVUxMLAoJICAgIHR5cGUsIHZhbHVlLCBOVUxMLCAxLCAwLCAwKSk7Cn0KCgoKLyogCiogUHJvY2VzcyBFTkQgb2YgZWxlbWVudC4KKi8Kc3RhdGljIGludAp4bWxTY2hlbWFWYWxpZGF0b3JQb3BFbGVtKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgaW50IHJldCA9IDA7CiAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBpbm9kZSA9IHZjdHh0LT5pbm9kZTsKCiAgICBpZiAodmN0eHQtPm5iQXR0ckluZm9zICE9IDApCgl4bWxTY2hlbWFDbGVhckF0dHJJbmZvcyh2Y3R4dCk7CiAgICBpZiAoaW5vZGUtPmZsYWdzICYgWE1MX1NDSEVNQV9OT0RFX0lORk9fRVJSX05PVF9FWFBFQ1RFRCkgewoJLyoKCSogVGhpcyBlbGVtZW50IHdhcyBub3QgZXhwZWN0ZWQ7CgkqIHdlIHdpbGwgbm90IHZhbGlkYXRlIGNoaWxkIGVsZW1lbnRzIG9mIGJyb2tlbiBwYXJlbnRzLgoJKiBTa2lwIHZhbGlkYXRpb24gb2YgYWxsIGNvbnRlbnQgb2YgdGhlIHBhcmVudC4KCSovCgl2Y3R4dC0+c2tpcERlcHRoID0gdmN0eHQtPmRlcHRoIC0xOwoJZ290byBlbmRfZWxlbTsKICAgIH0gICAgCiAgICBpZiAoKGlub2RlLT50eXBlRGVmID09IE5VTEwpIHx8CgkoaW5vZGUtPmZsYWdzICYgWE1MX1NDSEVNQV9OT0RFX0lORk9fRVJSX0JBRF9UWVBFKSkgewoJLyoKCSogMS4gdGhlIHR5cGUgZGVmaW5pdGlvbiBtaWdodCBiZSBtaXNzaW5nIGlmIHRoZSBlbGVtZW50IHdhcwoJKiAgICBlcnJvciBwcm9uZQoJKiAyLiBpdCBtaWdodCBiZSBhYnN0cmFjdC4KCSovCglnb3RvIGVuZF9lbGVtOwogICAgfQogICAgLyoKICAgICogQ2hlY2sgdGhlIGNvbnRlbnQgbW9kZWwuCiAgICAqLwogICAgaWYgKChpbm9kZS0+dHlwZURlZi0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX01JWEVEKSB8fAoJKGlub2RlLT50eXBlRGVmLT5jb250ZW50VHlwZSA9PSBYTUxfU0NIRU1BX0NPTlRFTlRfRUxFTUVOVFMpKSB7CgoJLyoKCSogV29ya2Fyb3VuZCBmb3IgImFueVR5cGUiLgoJKi8KCWlmIChpbm9kZS0+dHlwZURlZi0+YnVpbHRJblR5cGUgPT0gWE1MX1NDSEVNQVNfQU5ZVFlQRSkKCSAgICBnb3RvIGNoYXJhY3Rlcl9jb250ZW50OwkJCQoJCglpZiAoKGlub2RlLT5mbGFncyAmIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VSUl9CQURfQ09OVEVOVCkgPT0gMCkgewoJICAgIHhtbENoYXIgKnZhbHVlc1sxMF07CgkgICAgaW50IHRlcm1pbmFsLCBuYnZhbCA9IDEwLCBuYm5lZzsKCgkgICAgaWYgKGlub2RlLT5yZWdleEN0eHQgPT0gTlVMTCkgewoJCS8qCgkJKiBDcmVhdGUgdGhlIHJlZ2V4IGNvbnRleHQuCgkJKi8KCQlpbm9kZS0+cmVnZXhDdHh0ID0KCQkgICAgeG1sUmVnTmV3RXhlY0N0eHQoaW5vZGUtPnR5cGVEZWYtPmNvbnRNb2RlbCwKCQkgICAgKHhtbFJlZ0V4ZWNDYWxsYmFja3MpIHhtbFNjaGVtYVZDb250ZW50TW9kZWxDYWxsYmFjaywKCQkgICAgdmN0eHQpOwoJCWlmIChpbm9kZS0+cmVnZXhDdHh0ID09IE5VTEwpIHsKCQkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdG9yUG9wRWxlbSIsCgkJCSJmYWlsZWQgdG8gY3JlYXRlIGEgcmVnZXggY29udGV4dCIpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KI2lmZGVmIERFQlVHX0FVVE9NQVRBCgkJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsCgkJICAgICJBVVRPTUFUT04gY3JlYXRlIG9uICclcydcbiIsIGlub2RlLT5sb2NhbE5hbWUpOwojZW5kaWYJICAgIAoJICAgIH0KCSAgICAvKgoJICAgICogR2V0IGhvbGQgb2YgdGhlIHN0aWxsIGV4cGVjdGVkIGNvbnRlbnQsIHNpbmNlIGEgZnVydGhlcgoJICAgICogY2FsbCB0byB4bWxSZWdFeGVjUHVzaFN0cmluZygpIHdpbGwgbG9vc2UgdGhpcyBpbmZvcm1hdGlvbi4KCSAgICAqLyAKCSAgICB4bWxSZWdFeGVjTmV4dFZhbHVlcyhpbm9kZS0+cmVnZXhDdHh0LAoJCSZuYnZhbCwgJm5ibmVnLCAmdmFsdWVzWzBdLCAmdGVybWluYWwpOwoJICAgIHJldCA9IHhtbFJlZ0V4ZWNQdXNoU3RyaW5nKGlub2RlLT5yZWdleEN0eHQsIE5VTEwsIE5VTEwpOwoJICAgIGlmIChyZXQgPD0gMCkgewkJCgkJLyoKCQkqIFN0aWxsIG1pc3Npbmcgc29tZXRoaW5nLgoJCSovCgkJcmV0ID0gMTsKCQlpbm9kZS0+ZmxhZ3MgfD0KCQkgICAgWE1MX1NDSEVNQV9FTEVNX0lORk9fRVJSX0JBRF9DT05URU5UOwoJCXhtbFNjaGVtYUNvbXBsZXhUeXBlRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJICAgIFhNTF9TQ0hFTUFWX0VMRU1FTlRfQ09OVEVOVCwgTlVMTCwgTlVMTCwKCQkgICAgIk1pc3NpbmcgY2hpbGQgZWxlbWVudChzKSIsCgkJICAgIG5idmFsLCBuYm5lZywgdmFsdWVzKTsKI2lmZGVmIERFQlVHX0FVVE9NQVRBCgkJeG1sR2VuZXJpY0Vycm9yKHhtbEdlbmVyaWNFcnJvckNvbnRleHQsCgkJICAgICJBVVRPTUFUT04gbWlzc2luZyBFUlJPUiBvbiAnJXMnXG4iLAoJCSAgICBpbm9kZS0+bG9jYWxOYW1lKTsKI2VuZGlmCgkgICAgfSBlbHNlIHsKCQkvKgoJCSogQ29udGVudCBtb2RlbCBpcyBzYXRpc2ZpZWQuCgkJKi8KCQlyZXQgPSAwOwojaWZkZWYgREVCVUdfQVVUT01BVEEKCQl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwKCQkgICAgIkFVVE9NQVRPTiBzdWNjZWVkZWQgb24gJyVzJ1xuIiwKCQkgICAgaW5vZGUtPmxvY2FsTmFtZSk7CiNlbmRpZgoJICAgIH0KCgl9CiAgICB9CiAgICBpZiAoaW5vZGUtPnR5cGVEZWYtPmNvbnRlbnRUeXBlID09IFhNTF9TQ0hFTUFfQ09OVEVOVF9FTEVNRU5UUykKCWdvdG8gZW5kX2VsZW07CgpjaGFyYWN0ZXJfY29udGVudDoKCiAgICBpZiAodmN0eHQtPnZhbHVlICE9IE5VTEwpIHsKCXhtbFNjaGVtYUZyZWVWYWx1ZSh2Y3R4dC0+dmFsdWUpOwoJdmN0eHQtPnZhbHVlID0gTlVMTDsKICAgIH0KICAgIC8qCiAgICAqIENoZWNrIGNoYXJhY3RlciBjb250ZW50LgogICAgKi8KICAgIGlmIChpbm9kZS0+ZGVjbCA9PSBOVUxMKSB7CgkvKgoJKiBTcGVlZHVwIGlmIG5vIGRlY2xhcmF0aW9uIGV4aXN0cy4KCSovCglpZiAoV1hTX0lTX1NJTVBMRShpbm9kZS0+dHlwZURlZikpIHsJICAgIAoJICAgIHJldCA9IHhtbFNjaGVtYVZDaGVja0lOb2RlRGF0YVR5cGUodmN0eHQsCgkJaW5vZGUsIGlub2RlLT50eXBlRGVmLCBpbm9kZS0+dmFsdWUpOwoJfSBlbHNlIGlmIChXWFNfSEFTX1NJTVBMRV9DT05URU5UKGlub2RlLT50eXBlRGVmKSkgewoJICAgIHJldCA9IHhtbFNjaGVtYVZDaGVja0lOb2RlRGF0YVR5cGUodmN0eHQsCgkJaW5vZGUsIGlub2RlLT50eXBlRGVmLT5jb250ZW50VHlwZURlZiwKCQlpbm9kZS0+dmFsdWUpOwoJfQkJCglpZiAocmV0IDwgMCkgewoJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRvclBvcEVsZW0iLAoJCSJjYWxsaW5nIHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoKSIpOwoJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7Cgl9Cglnb3RvIGVuZF9lbGVtOwogICAgfQogICAgLyoKICAgICogY3ZjLWVsdCAoMy4zLjQpIDogNSAKICAgICogVGhlIGFwcHJvcHJpYXRlIGNhc2UgYW1vbmcgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6CiAgICAqLwogICAgLyoKICAgICogY3ZjLWVsdCAoMy4zLjQpIDogNS4xIAogICAgKiBJZiB0aGUgZGVjbGFyYXRpb24gaGFzIGEge3ZhbHVlIGNvbnN0cmFpbnR9LCAKICAgICogdGhlIGl0ZW0gaGFzIG5laXRoZXIgZWxlbWVudCBub3IgY2hhcmFjdGVyIFtjaGlsZHJlbl0gYW5kIAogICAgKiBjbGF1c2UgMy4yIGhhcyBub3QgYXBwbGllZCwgdGhlbiBhbGwgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6CiAgICAqLwogICAgaWYgKChpbm9kZS0+ZGVjbC0+dmFsdWUgIT0gTlVMTCkgJiYKCShpbm9kZS0+ZmxhZ3MgJiBYTUxfU0NIRU1BX0VMRU1fSU5GT19FTVBUWSkgJiYgCgkoISBJTk9ERV9OSUxMRUQoaW5vZGUpKSkgewoJLyoKCSogY3ZjLWVsdCAoMy4zLjQpIDogNS4xLjEgCgkqIElmIHRoZSC3YWN0dWFsIHR5cGUgZGVmaW5pdGlvbrcgaXMgYSC3bG9jYWwgdHlwZSBkZWZpbml0aW9utwoJKiB0aGVuIHRoZSBjYW5vbmljYWwgbGV4aWNhbCByZXByZXNlbnRhdGlvbiBvZiB0aGUge3ZhbHVlIGNvbnN0cmFpbnR9CgkqIHZhbHVlIG11c3QgYmUgYSB2YWxpZCBkZWZhdWx0IGZvciB0aGUgt2FjdHVhbCB0eXBlIGRlZmluaXRpb263IGFzIAoJKiBkZWZpbmVkIGluIEVsZW1lbnQgRGVmYXVsdCBWYWxpZCAoSW1tZWRpYXRlKSAopzMuMy42KS4gCgkqLwoJLyogCgkqIE5PVEU6ICdsb2NhbCcgYWJvdmUgbWVhbnMgdHlwZXMgYWNxdWlyZWQgYnkgeHNpOnR5cGUuCgkqIE5PVEU6IEFsdGhvdWdoIHRoZSAqY2Fub25pY2FsKiB2YWx1ZSBpcyBzdGF0ZWQsIGl0IGlzIG5vdAoJKiByZWxldmFudCBpZiBjYW5vbmljYWwgb3Igbm90LiBBZGRpdGlvbmFsbHkgWE1MIFNjaGVtYSAxLjEKCSogd2lsbCByZW1vdmVkIHRoaXMgcmVxdWlyZW1lbnQgYXMgd2VsbC4KCSovCglpZiAoaW5vZGUtPmZsYWdzICYgWE1MX1NDSEVNQV9FTEVNX0lORk9fTE9DQUxfVFlQRSkgewoKCSAgICByZXQgPSB4bWxTY2hlbWFDaGVja0NPU1ZhbGlkRGVmYXVsdCh2Y3R4dCwKCQlpbm9kZS0+ZGVjbC0+dmFsdWUsICYoaW5vZGUtPnZhbCkpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPCAwKSB7CgkJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRvclBvcEVsZW0iLAoJCQkiY2FsbGluZyB4bWxTY2hlbWFDaGVja0NPU1ZhbGlkRGVmYXVsdCgpIik7CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJCWdvdG8gZW5kX2VsZW07CgkgICAgfQoJICAgIC8qCgkgICAgKiBTdG9wIGhlcmUsIHRvIGF2b2lkIHJlZHVuZGFudCB2YWxpZGF0aW9uIG9mIHRoZSB2YWx1ZQoJICAgICogKHNlZSBmb2xsb3dpbmcpLgoJICAgICovCgkgICAgZ290byBkZWZhdWx0X3Bzdmk7Cgl9CQoJLyoKCSogY3ZjLWVsdCAoMy4zLjQpIDogNS4xLjIgCgkqIFRoZSBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0gd2l0aCB0aGUgY2Fub25pY2FsIGxleGljYWwgCgkqIHJlcHJlc2VudGF0aW9uIG9mIHRoZSB7dmFsdWUgY29uc3RyYWludH0gdmFsdWUgdXNlZCBhcyBpdHMgCgkqILdub3JtYWxpemVkIHZhbHVltyBtdXN0IGJlILd2YWxpZLcgd2l0aCByZXNwZWN0IHRvIHRoZSAKCSogt2FjdHVhbCB0eXBlIGRlZmluaXRpb263IGFzIGRlZmluZWQgYnkgRWxlbWVudCBMb2NhbGx5IFZhbGlkIChUeXBlKQoJKiAopzMuMy40KS4KCSovCSAgICAKCWlmIChXWFNfSVNfU0lNUExFKGlub2RlLT50eXBlRGVmKSkgewoJICAgIHJldCA9IHhtbFNjaGVtYVZDaGVja0lOb2RlRGF0YVR5cGUodmN0eHQsCgkJaW5vZGUsIGlub2RlLT50eXBlRGVmLCBpbm9kZS0+ZGVjbC0+dmFsdWUpOwoJfSBlbHNlIGlmIChXWFNfSEFTX1NJTVBMRV9DT05URU5UKGlub2RlLT50eXBlRGVmKSkgewoJICAgIHJldCA9IHhtbFNjaGVtYVZDaGVja0lOb2RlRGF0YVR5cGUodmN0eHQsCgkJaW5vZGUsIGlub2RlLT50eXBlRGVmLT5jb250ZW50VHlwZURlZiwKCQlpbm9kZS0+ZGVjbC0+dmFsdWUpOwkgICAgCgl9CglpZiAocmV0ICE9IDApIHsKCSAgICBpZiAocmV0IDwgMCkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRvclBvcEVsZW0iLAoJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFWQ2hlY2tDVkNTaW1wbGVUeXBlKCkiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCSAgICBnb3RvIGVuZF9lbGVtOwoJfQoKZGVmYXVsdF9wc3ZpOgoJLyoKCSogUFNWSTogQ3JlYXRlIGEgdGV4dCBub2RlIG9uIHRoZSBpbnN0YW5jZSBlbGVtZW50LgoJKi8KCWlmICgodmN0eHQtPm9wdGlvbnMgJiBYTUxfU0NIRU1BX1ZBTF9WQ19JX0NSRUFURSkgJiYKCSAgICAoaW5vZGUtPm5vZGUgIT0gTlVMTCkpIHsKCSAgICB4bWxOb2RlUHRyIHRleHRDaGlsZDsKCSAgICB4bWxDaGFyICpub3JtVmFsdWU7CgkgICAgLyoKCSAgICAqIFZBTCBUT0RPOiBOb3JtYWxpemUgdGhlIHZhbHVlLgoJICAgICovCSAgICAKCSAgICBub3JtVmFsdWUgPSB4bWxTY2hlbWFOb3JtYWxpemVWYWx1ZShpbm9kZS0+dHlwZURlZiwKCQlpbm9kZS0+ZGVjbC0+dmFsdWUpOwoJICAgIGlmIChub3JtVmFsdWUgIT0gTlVMTCkgewoJCXRleHRDaGlsZCA9IHhtbE5ld1RleHQoQkFEX0NBU1Qgbm9ybVZhbHVlKTsKCQl4bWxGcmVlKG5vcm1WYWx1ZSk7CgkgICAgfSBlbHNlCgkJdGV4dENoaWxkID0geG1sTmV3VGV4dChpbm9kZS0+ZGVjbC0+dmFsdWUpOwoJICAgIGlmICh0ZXh0Q2hpbGQgPT0gTlVMTCkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRvclBvcEVsZW0iLAoJCSAgICAiY2FsbGluZyB4bWxOZXdUZXh0KCkiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0gZWxzZQoJCXhtbEFkZENoaWxkKGlub2RlLT5ub2RlLCB0ZXh0Q2hpbGQpOwkgICAgCgl9CgkKICAgIH0gZWxzZSBpZiAoISBJTk9ERV9OSUxMRUQoaW5vZGUpKSB7CQoJLyoKCSogNS4yLjEgVGhlIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBtdXN0IGJlILd2YWxpZLcgd2l0aCByZXNwZWN0IAoJKiB0byB0aGUgt2FjdHVhbCB0eXBlIGRlZmluaXRpb263IGFzIGRlZmluZWQgYnkgRWxlbWVudCBMb2NhbGx5IAoJKiBWYWxpZCAoVHlwZSkgKKczLjMuNCkuCgkqLwkKCWlmIChXWFNfSVNfU0lNUExFKGlub2RlLT50eXBlRGVmKSkgewoJICAgICAvKgoJICAgICogU1BFQyAoY3ZjLXR5cGUpICgzLjEpCgkgICAgKiAiSWYgdGhlIHR5cGUgZGVmaW5pdGlvbiBpcyBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24sIC4uLiIKCSAgICAqICgzLjEuMykgIklmIGNsYXVzZSAzLjIgb2YgRWxlbWVudCBMb2NhbGx5IFZhbGlkCgkgICAgKiAoRWxlbWVudCkgKKczLjMuNCkgZGlkIG5vdCBhcHBseSwgdGhlbiB0aGUgt25vcm1hbGl6ZWQgdmFsdWW3CgkgICAgKiBtdXN0IGJlILd2YWxpZLcgd2l0aCByZXNwZWN0IHRvIHRoZSB0eXBlIGRlZmluaXRpb24gYXMgZGVmaW5lZAoJICAgICogYnkgU3RyaW5nIFZhbGlkICinMy4xNC40KS4KCSAgICAqLwkgICAgCgkgICAgcmV0ID0geG1sU2NoZW1hVkNoZWNrSU5vZGVEYXRhVHlwZSh2Y3R4dCwKCQkgICAgaW5vZGUsIGlub2RlLT50eXBlRGVmLCBpbm9kZS0+dmFsdWUpOwoJfSBlbHNlIGlmIChXWFNfSEFTX1NJTVBMRV9DT05URU5UKGlub2RlLT50eXBlRGVmKSkgewoJICAgIC8qCgkgICAgKiBTUEVDIChjdmMtdHlwZSkgKDMuMikgIklmIHRoZSB0eXBlIGRlZmluaXRpb24gaXMgYSBjb21wbGV4IHR5cGUKCSAgICAqIGRlZmluaXRpb24sIHRoZW4gdGhlIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBtdXN0IGJlCgkgICAgKiC3dmFsaWS3IHdpdGggcmVzcGVjdCB0byB0aGUgdHlwZSBkZWZpbml0aW9uIGFzIHBlcgoJICAgICogRWxlbWVudCBMb2NhbGx5IFZhbGlkIChDb21wbGV4IFR5cGUpICinMy40LjQpOyIKCSAgICAqCgkgICAgKiBTUEVDIChjdmMtY29tcGxleC10eXBlKSAoMi4yKQoJICAgICogIklmIHRoZSB7Y29udGVudCB0eXBlfSBpcyBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24sIC4uLiAKCSAgICAqIHRoZSC3bm9ybWFsaXplZCB2YWx1Zbcgb2YgdGhlIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBpcwoJICAgICogt3ZhbGlktyB3aXRoIHJlc3BlY3QgdG8gdGhhdCBzaW1wbGUgdHlwZSBkZWZpbml0aW9uIGFzCgkgICAgKiBkZWZpbmVkIGJ5IFN0cmluZyBWYWxpZCAopzMuMTQuNCkuIgoJICAgICovCgkgICAgcmV0ID0geG1sU2NoZW1hVkNoZWNrSU5vZGVEYXRhVHlwZSh2Y3R4dCwKCQlpbm9kZSwgaW5vZGUtPnR5cGVEZWYtPmNvbnRlbnRUeXBlRGVmLCBpbm9kZS0+dmFsdWUpOwoJfQkKCWlmIChyZXQgIT0gMCkgewoJICAgIGlmIChyZXQgPCAwKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdG9yUG9wRWxlbSIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVZDaGVja0NWQ1NpbXBsZVR5cGUoKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJICAgIGdvdG8gZW5kX2VsZW07Cgl9CgkvKgoJKiA1LjIuMiBJZiB0aGVyZSBpcyBhIGZpeGVkIHt2YWx1ZSBjb25zdHJhaW50fSBhbmQgY2xhdXNlIDMuMiBoYXMgCgkqIG5vdCBhcHBsaWVkLCBhbGwgb2YgdGhlIGZvbGxvd2luZyBtdXN0IGJlIHRydWU6CgkqLwoJaWYgKChpbm9kZS0+ZGVjbC0+dmFsdWUgIT0gTlVMTCkgJiYKCSAgICAoaW5vZGUtPmRlY2wtPmZsYWdzICYgWE1MX1NDSEVNQVNfRUxFTV9GSVhFRCkpIHsKCgkgICAgLyoKCSAgICAqIFRPRE86IFdlIHdpbGwgbmVlZCBhIGNvbXB1dGVkIHZhbHVlLCB3aGVuIGNvbXBhcmlzb24gaXMKCSAgICAqIGRvbmUgb24gY29tcHV0ZWQgdmFsdWVzLgoJICAgICovCgkgICAgLyoKCSAgICAqIDUuMi4yLjEgVGhlIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBtdXN0IGhhdmUgbm8gZWxlbWVudCAKCSAgICAqIGluZm9ybWF0aW9uIGl0ZW0gW2NoaWxkcmVuXS4KCSAgICAqLwoJICAgIGlmIChpbm9kZS0+ZmxhZ3MgJgoJCSAgICBYTUxfU0NIRU1BX0VMRU1fSU5GT19IQVNfRUxFTV9DT05URU5UKSB7CgkJcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX0VMVF81XzJfMl8xOwoJCVZFUlJPUihyZXQsIE5VTEwsCgkJICAgICJUaGUgY29udGVudCBtdXN0IG5vdCBjb250YWludCBlbGVtZW50IG5vZGVzIHNpbmNlICIKCQkgICAgInRoZXJlIGlzIGEgZml4ZWQgdmFsdWUgY29uc3RyYWludCIpOwoJCWdvdG8gZW5kX2VsZW07CgkgICAgfSBlbHNlIHsKCQkvKgoJCSogNS4yLjIuMiBUaGUgYXBwcm9wcmlhdGUgY2FzZSBhbW9uZyB0aGUgZm9sbG93aW5nIG11c3QgCgkJKiBiZSB0cnVlOgoJCSovCQkKCQlpZiAoV1hTX0hBU19NSVhFRF9DT05URU5UKGlub2RlLT50eXBlRGVmKSkgewoJCSAgICAvKgoJCSAgICAqIDUuMi4yLjIuMSBJZiB0aGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlILdhY3R1YWwgdHlwZSAKCQkgICAgKiBkZWZpbml0aW9utyBpcyBtaXhlZCwgdGhlbiB0aGUgKmluaXRpYWwgdmFsdWUqIG9mIHRoZSAKCQkgICAgKiBpdGVtIG11c3QgbWF0Y2ggdGhlIGNhbm9uaWNhbCBsZXhpY2FsIHJlcHJlc2VudGF0aW9uIAoJCSAgICAqIG9mIHRoZSB7dmFsdWUgY29uc3RyYWludH0gdmFsdWUuCgkJICAgICoKCQkgICAgKiAuLi4gdGhlICppbml0aWFsIHZhbHVlKiBvZiBhbiBlbGVtZW50IGluZm9ybWF0aW9uIAoJCSAgICAqIGl0ZW0gaXMgdGhlIHN0cmluZyBjb21wb3NlZCBvZiwgaW4gb3JkZXIsIHRoZSAKCQkgICAgKiBbY2hhcmFjdGVyIGNvZGVdIG9mIGVhY2ggY2hhcmFjdGVyIGluZm9ybWF0aW9uIGl0ZW0gaW4gCgkJICAgICogdGhlIFtjaGlsZHJlbl0gb2YgdGhhdCBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0uCgkJICAgICovCQkgICAKCQkgICAgaWYgKCEgeG1sU3RyRXF1YWwoaW5vZGUtPnZhbHVlLCBpbm9kZS0+ZGVjbC0+dmFsdWUpKXsKCQkJLyogCgkJCSogVkFMIFRPRE86IFJlcG9ydCBpbnZhbGlkICYgZXhwZWN0ZWQgdmFsdWVzIGFzIHdlbGwuCgkJCSogVkFMIFRPRE86IEltcGxlbWVudCB0aGUgY2Fub25pY2FsIHN0dWZmLgoJCQkqLwoJCQlyZXQgPSBYTUxfU0NIRU1BVl9DVkNfRUxUXzVfMl8yXzJfMTsKCQkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsIAoJCQkgICAgcmV0LCBOVUxMLCBOVUxMLAoJCQkgICAgIlRoZSBpbml0aWFsIHZhbHVlICclcycgZG9lcyBub3QgbWF0Y2ggdGhlIGZpeGVkICIKCQkJICAgICJ2YWx1ZSBjb25zdHJhaW50ICclcyciLAoJCQkgICAgaW5vZGUtPnZhbHVlLCBpbm9kZS0+ZGVjbC0+dmFsdWUpOwoJCQlnb3RvIGVuZF9lbGVtOwoJCSAgICB9CgkJfSBlbHNlIGlmIChXWFNfSEFTX1NJTVBMRV9DT05URU5UKGlub2RlLT50eXBlRGVmKSkgewoJCSAgICAvKgoJCSAgICAqIDUuMi4yLjIuMiBJZiB0aGUge2NvbnRlbnQgdHlwZX0gb2YgdGhlILdhY3R1YWwgdHlwZSAKCQkgICAgKiBkZWZpbml0aW9utyBpcyBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24sIHRoZW4gdGhlIAoJCSAgICAqICphY3R1YWwgdmFsdWUqIG9mIHRoZSBpdGVtIG11c3QgbWF0Y2ggdGhlIGNhbm9uaWNhbCAKCQkgICAgKiBsZXhpY2FsIHJlcHJlc2VudGF0aW9uIG9mIHRoZSB7dmFsdWUgY29uc3RyYWludH0gdmFsdWUuCgkJICAgICovCgkJICAgIC8qCgkJICAgICogVkFMIFRPRE86ICphY3R1YWwgdmFsdWUqIGlzIHRoZSBub3JtYWxpemVkIHZhbHVlLCBpbXBsLgoJCSAgICAqICAgICAgICAgICB0aGlzLgoJCSAgICAqIFZBTCBUT0RPOiBSZXBvcnQgaW52YWxpZCAmIGV4cGVjdGVkIHZhbHVlcyBhcyB3ZWxsLgoJCSAgICAqIFZBTCBUT0RPOiBJbXBsZW1lbnQgYSBjb21wYXJpc29uIHdpdGggdGhlIGNvbXB1dGVkIHZhbHVlcy4KCQkgICAgKi8KCQkgICAgaWYgKCEgeG1sU3RyRXF1YWwoaW5vZGUtPnZhbHVlLAoJCQkgICAgaW5vZGUtPmRlY2wtPnZhbHVlKSkgewoJCQlyZXQgPSBYTUxfU0NIRU1BVl9DVkNfRUxUXzVfMl8yXzJfMjsKCQkJeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgdmN0eHQsCgkJCSAgICByZXQsIE5VTEwsIE5VTEwsCgkJCSAgICAiVGhlIGFjdHVhbCB2YWx1ZSAnJXMnIGRvZXMgbm90IG1hdGNoIHRoZSBmaXhlZCAiCgkJCSAgICAidmFsdWUgY29uc3RyYWludCAnJXMnIiwgCgkJCSAgICBpbm9kZS0+dmFsdWUsCgkJCSAgICBpbm9kZS0+ZGVjbC0+dmFsdWUpOwoJCQlnb3RvIGVuZF9lbGVtOwoJCSAgICB9CQkgICAgCgkJfQoJICAgIH0JICAgIAoJfQogICAgfQogICAgCmVuZF9lbGVtOgogICAgaWYgKHZjdHh0LT5kZXB0aCA8IDApIHsKCS8qIFRPRE86IHJhaXNlIGVycm9yPyAqLwoJcmV0dXJuICgwKTsKICAgIH0KICAgIGlmICh2Y3R4dC0+ZGVwdGggPT0gdmN0eHQtPnNraXBEZXB0aCkKCXZjdHh0LT5za2lwRGVwdGggPSAtMTsKICAgIC8qCiAgICAqIEV2YWx1YXRlIHRoZSBoaXN0b3J5IG9mIFhQYXRoIHN0YXRlIG9iamVjdHMuCiAgICAqLyAgICAKICAgIGlmIChpbm9kZS0+YXBwbGllZFhQYXRoICYmCgkoeG1sU2NoZW1hWFBhdGhQcm9jZXNzSGlzdG9yeSh2Y3R4dCwgdmN0eHQtPmRlcHRoKSA9PSAtMSkpCglnb3RvIGludGVybmFsX2Vycm9yOwogICAgLyoKICAgICogTUFZQkUgVE9ETzoKICAgICogU1BFQyAoNikgIlRoZSBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0gbXVzdCBiZSC3dmFsaWS3IHdpdGgKICAgICogcmVzcGVjdCB0byBlYWNoIG9mIHRoZSB7aWRlbnRpdHktY29uc3RyYWludCBkZWZpbml0aW9uc30gYXMgcGVyCiAgICAqIElkZW50aXR5LWNvbnN0cmFpbnQgU2F0aXNmaWVkICinMy4xMS40KS4iCiAgICAqLwogICAgLyoKICAgICogUFNWSSBUT0RPOiBJZiB3ZSBleHBvc2UgSURDIG5vZGUtdGFibGVzIHZpYSBQU1ZJIHRoZW4gdGhlIHRhYmxlcwogICAgKiAgIG5lZWQgdG8gYmUgYnVpbHQgaW4gYW55IGNhc2UuCiAgICAqICAgV2Ugd2lsbCBjdXJyZW50bHkgYnVpbGQgSURDIG5vZGUtdGFibGVzIGFuZCBidWJibGUgdGhlbSBvbmx5IGlmCiAgICAqICAga2V5cmVmcyBkbyBleGlzdC4KICAgICovCiAgICAKICAgIC8qCiAgICAqIEFkZCB0aGUgY3VycmVudCBJREMgdGFyZ2V0LW5vZGVzIHRvIHRoZSBJREMgbm9kZS10YWJsZXMuCiAgICAqLwogICAgaWYgKChpbm9kZS0+aWRjTWF0Y2hlcnMgIT0gTlVMTCkgJiYKCSh2Y3R4dC0+aGFzS2V5cmVmcyB8fCB2Y3R4dC0+Y3JlYXRlSURDTm9kZVRhYmxlcykpCiAgICB7CglpZiAoeG1sU2NoZW1hSURDRmlsbE5vZGVUYWJsZXModmN0eHQsIGlub2RlKSA9PSAtMSkKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwogICAgfQogICAgLyoKICAgICogVmFsaWRhdGUgSURDIGtleXJlZnMuCiAgICAqLwogICAgaWYgKHZjdHh0LT5pbm9kZS0+aGFzS2V5cmVmcykKCWlmICh4bWxTY2hlbWFDaGVja0NWQ0lEQ0tleVJlZih2Y3R4dCkgPT0gLTEpCgkgICAgZ290byBpbnRlcm5hbF9lcnJvcjsKICAgIC8qCiAgICAqIE1lcmdlL2ZyZWUgdGhlIElEQyB0YWJsZS4KICAgICovCiAgICBpZiAoaW5vZGUtPmlkY1RhYmxlICE9IE5VTEwpIHsKI2lmZGVmIERFQlVHX0lEQ19OT0RFX1RBQkxFCgl4bWxTY2hlbWFEZWJ1Z0R1bXBJRENUYWJsZShzdGRvdXQsCgkgICAgaW5vZGUtPm5zTmFtZSwKCSAgICBpbm9kZS0+bG9jYWxOYW1lLAoJICAgIGlub2RlLT5pZGNUYWJsZSk7CiNlbmRpZgoJaWYgKCh2Y3R4dC0+ZGVwdGggPiAwKSAmJgoJICAgICh2Y3R4dC0+aGFzS2V5cmVmcyB8fCB2Y3R4dC0+Y3JlYXRlSURDTm9kZVRhYmxlcykpCgl7CgkgICAgLyoKCSAgICAqIE1lcmdlIHRoZSBJREMgbm9kZSB0YWJsZSB3aXRoIHRoZSB0YWJsZSBvZiB0aGUgcGFyZW50IG5vZGUuCgkgICAgKi8KCSAgICBpZiAoeG1sU2NoZW1hQnViYmxlSURDTm9kZVRhYmxlcyh2Y3R4dCkgPT0gLTEpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCX0JCiAgICB9CiAgICAvKgogICAgKiBDbGVhciB0aGUgY3VycmVudCBpZWxlbS4KICAgICogVkFMIFRPRE86IERvbid0IGZyZWUgdGhlIFBTVkkgSURDIHRhYmxlcyBpZiB0aGV5IGFyZQogICAgKiByZXF1ZXN0ZWQgZm9yIHRoZSBQU1ZJLgogICAgKi8KICAgIHhtbFNjaGVtYUNsZWFyRWxlbUluZm8oaW5vZGUpOwogICAgLyoKICAgICogU2tpcCBmdXJ0aGVyIHByb2Nlc3NpbmcgaWYgd2UgYXJlIG9uIHRoZSB2YWxpZGF0aW9uIHJvb3QuCiAgICAqLwogICAgaWYgKHZjdHh0LT5kZXB0aCA9PSAwKSB7Cgl2Y3R4dC0+ZGVwdGgtLTsKCXZjdHh0LT5pbm9kZSA9IE5VTEw7CglyZXR1cm4gKDApOwogICAgfQogICAgLyoKICAgICogUmVzZXQgdGhlIGtleXJlZkRlcHRoIGlmIG5lZWRlZC4KICAgICovCiAgICBpZiAodmN0eHQtPmFpZGNzICE9IE5VTEwpIHsKCXhtbFNjaGVtYUlEQ0F1Z1B0ciBhaWRjID0gdmN0eHQtPmFpZGNzOwoJZG8gewoJICAgIGlmIChhaWRjLT5rZXlyZWZEZXB0aCA9PSB2Y3R4dC0+ZGVwdGgpIHsKCQkvKgoJCSogQSAna2V5cmVmRGVwdGgnIG9mIGEga2V5L3VuaXF1ZSBJREMgbWF0Y2hlcyB0aGUgY3VycmVudAoJCSogZGVwdGgsIHRoaXMgbWVhbnMgdGhhdCB3ZSBhcmUgbGVhdmluZyB0aGUgc2NvcGUgb2YgdGhlCgkJKiB0b3AtbW9zdCBrZXlyZWYgSURDIHdoaWNoIHJlZmVycyB0byB0aGlzIElEQy4KCQkqLwoJCWFpZGMtPmtleXJlZkRlcHRoID0gLTE7CgkgICAgfQoJICAgIGFpZGMgPSBhaWRjLT5uZXh0OwoJfSB3aGlsZSAoYWlkYyAhPSBOVUxMKTsKICAgIH0KICAgIHZjdHh0LT5kZXB0aC0tOyAgICAgICAgCiAgICB2Y3R4dC0+aW5vZGUgPSB2Y3R4dC0+ZWxlbUluZm9zW3ZjdHh0LT5kZXB0aF07CiAgICAvKgogICAgKiBWQUwgVE9ETzogNyBJZiB0aGUgZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtIGlzIHRoZSC3dmFsaWRhdGlvbiByb290tywgaXQgbXVzdCBiZSAKICAgICogt3ZhbGlktyBwZXIgVmFsaWRhdGlvbiBSb290IFZhbGlkIChJRC9JRFJFRikgKKczLjMuNCkuCiAgICAqLwogICAgcmV0dXJuIChyZXQpOwoKaW50ZXJuYWxfZXJyb3I6CiAgICB2Y3R4dC0+ZXJyID0gLTE7CiAgICByZXR1cm4gKC0xKTsKfQoKLyoKKiAzLjQuNCBDb21wbGV4IFR5cGUgRGVmaW5pdGlvbiBWYWxpZGF0aW9uIFJ1bGVzCiogVmFsaWRhdGlvbiBSdWxlOiBFbGVtZW50IExvY2FsbHkgVmFsaWQgKENvbXBsZXggVHlwZSkgKGN2Yy1jb21wbGV4LXR5cGUpCiovCnN0YXRpYyBpbnQKeG1sU2NoZW1hVmFsaWRhdGVDaGlsZEVsZW0oeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7CiAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBwaWVsZW07CiAgICB4bWxTY2hlbWFUeXBlUHRyIHB0eXBlOwogICAgaW50IHJldCA9IDA7CgogICAgaWYgKHZjdHh0LT5kZXB0aCA8PSAwKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUNoaWxkRWxlbSIsCgkgICAgIm5vdCBpbnRlbmRlZCBmb3IgdGhlIHZhbGlkYXRpb24gcm9vdCIpOwoJcmV0dXJuICgtMSk7CiAgICB9CiAgICBwaWVsZW0gPSB2Y3R4dC0+ZWxlbUluZm9zW3ZjdHh0LT5kZXB0aCAtMV07CiAgICBpZiAocGllbGVtLT5mbGFncyAmIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZKQoJcGllbGVtLT5mbGFncyBePSBYTUxfU0NIRU1BX0VMRU1fSU5GT19FTVBUWTsKICAgIC8qCiAgICAqIEhhbmRsZSAnbmlsbGVkJyBlbGVtZW50cy4KICAgICovCiAgICBpZiAoSU5PREVfTklMTEVEKHBpZWxlbSkpIHsKCS8qCgkqIFNQRUMgKGN2Yy1lbHQpICgzLjMuNCkgOiAoMy4yLjEpCgkqLwoJQUNUSVZBVEVfUEFSRU5UX0VMRU07CglyZXQgPSBYTUxfU0NIRU1BVl9DVkNfRUxUXzNfMl8xOwoJVkVSUk9SKHJldCwgTlVMTCwKCSAgICAiTmVpdGhlciBjaGFyYWN0ZXIgbm9yIGVsZW1lbnQgY29udGVudCBpcyBhbGxvd2VkLCAiCgkgICAgImJlY2F1c2UgdGhlIGVsZW1lbnQgd2FzICduaWxsZWQnIik7CglBQ1RJVkFURV9FTEVNOwoJZ290byB1bmV4cGVjdGVkX2VsZW07CiAgICB9CgogICAgcHR5cGUgPSBwaWVsZW0tPnR5cGVEZWY7CgogICAgaWYgKHB0eXBlLT5idWlsdEluVHlwZSA9PSBYTUxfU0NIRU1BU19BTllUWVBFKSB7CgkvKgoJKiBXb3JrYXJvdW5kIGZvciAiYW55VHlwZSI6IHdlIGhhdmUgY3VycmVudGx5IG5vIGNvbnRlbnQgbW9kZWwKCSogYXNzaWduZWQgZm9yICJhbnlUeXBlIiwgc28gaGFuZGxlIGl0IGV4cGxpY2l0ZWx5LgoJKiAiYW55VHlwZSIgaGFzIGFuIHVuYm91bmRlZCwgbGF4ICJhbnkiIHdpbGRjYXJkLgoJKi8KCXZjdHh0LT5pbm9kZS0+ZGVjbCA9IHhtbFNjaGVtYUdldEVsZW0odmN0eHQtPnNjaGVtYSwKCSAgICB2Y3R4dC0+aW5vZGUtPmxvY2FsTmFtZSwKCSAgICB2Y3R4dC0+aW5vZGUtPm5zTmFtZSk7CgoJaWYgKHZjdHh0LT5pbm9kZS0+ZGVjbCA9PSBOVUxMKSB7CgkgICAgeG1sU2NoZW1hQXR0ckluZm9QdHIgaWF0dHI7CgkgICAgLyoKCSAgICAqIFByb2Nlc3MgInhzaTp0eXBlIi4KCSAgICAqIFNQRUMgKGN2Yy1hc3Nlc3MtZWx0KSAoMS4yLjEuMi4xKSAtICgxLjIuMS4yLjMpCgkgICAgKi8KCSAgICBpYXR0ciA9IHhtbFNjaGVtYUdldE1ldGFBdHRySW5mbyh2Y3R4dCwKCQlYTUxfU0NIRU1BX0FUVFJfSU5GT19NRVRBX1hTSV9UWVBFKTsKCSAgICBpZiAoaWF0dHIgIT0gTlVMTCkgewoJCXJldCA9IHhtbFNjaGVtYVByb2Nlc3NYU0lUeXBlKHZjdHh0LCBpYXR0ciwKCQkgICAgJih2Y3R4dC0+aW5vZGUtPnR5cGVEZWYpLCBOVUxMKTsKCQlpZiAocmV0ICE9IDApIHsKCQkgICAgaWYgKHJldCA9PSAtMSkgewoJCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUNoaWxkRWxlbSIsCgkJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFQcm9jZXNzWFNJVHlwZSgpIHRvICIKCQkJICAgICJwcm9jZXNzIHRoZSBhdHRyaWJ1dGUgJ3hzaTpuaWwnIik7CgkJCXJldHVybiAoLTEpOwoJCSAgICB9CgkJICAgIHJldHVybiAocmV0KTsKCQl9CgkgICAgfSBlbHNlIHsKCQkgLyoKCQkgKiBGYWxsYmFjayB0byAiYW55VHlwZSIuCgkJICoKCQkgKiBTUEVDIChjdmMtYXNzZXNzLWVsdCkKCQkgKiAiSWYgdGhlIGl0ZW0gY2Fubm90IGJlILdzdHJpY3RseSBhc3Nlc3NlZLcsIFsuLi5dCgkJICogYW4gZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtJ3Mgc2NoZW1hIHZhbGlkaXR5IG1heSBiZSBsYXhseQoJCSAqIGFzc2Vzc2VkIGlmIGl0cyC3Y29udGV4dC1kZXRlcm1pbmVkIGRlY2xhcmF0aW9utyBpcyBub3QKCQkgKiBza2lwIGJ5ILd2YWxpZGF0aW5ntyB3aXRoIHJlc3BlY3QgdG8gdGhlILd1ci10eXBlCgkJICogZGVmaW5pdGlvbrcgYXMgcGVyIEVsZW1lbnQgTG9jYWxseSBWYWxpZCAoVHlwZSkgKKczLjMuNCkuIgoJCSovCgkJdmN0eHQtPmlub2RlLT50eXBlRGVmID0KCQkgICAgeG1sU2NoZW1hR2V0QnVpbHRJblR5cGUoWE1MX1NDSEVNQVNfQU5ZVFlQRSk7CgkgICAgfQoJfQoJcmV0dXJuICgwKTsKICAgIH0KCiAgICBzd2l0Y2ggKHB0eXBlLT5jb250ZW50VHlwZSkgewoJY2FzZSBYTUxfU0NIRU1BX0NPTlRFTlRfRU1QVFk6CgkgICAgLyoKCSAgICAqIFNQRUMgKDIuMSkgIklmIHRoZSB7Y29udGVudCB0eXBlfSBpcyBlbXB0eSwgdGhlbiB0aGUKCSAgICAqIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBoYXMgbm8gY2hhcmFjdGVyIG9yIGVsZW1lbnQKCSAgICAqIGluZm9ybWF0aW9uIGl0ZW0gW2NoaWxkcmVuXS4iCgkgICAgKi8KCSAgICBBQ1RJVkFURV9QQVJFTlRfRUxFTQoJICAgIHJldCA9IFhNTF9TQ0hFTUFWX0NWQ19DT01QTEVYX1RZUEVfMl8xOwoJICAgIFZFUlJPUihyZXQsIE5VTEwsCgkJIkVsZW1lbnQgY29udGVudCBpcyBub3QgYWxsb3dlZCwgIgoJCSJiZWNhdXNlIHRoZSBjb250ZW50IHR5cGUgaXMgZW1wdHkiKTsKCSAgICBBQ1RJVkFURV9FTEVNCgkgICAgZ290byB1bmV4cGVjdGVkX2VsZW07CgkgICAgYnJlYWs7CgoJY2FzZSBYTUxfU0NIRU1BX0NPTlRFTlRfTUlYRUQ6CiAgICAgICAgY2FzZSBYTUxfU0NIRU1BX0NPTlRFTlRfRUxFTUVOVFM6IHsKCSAgICB4bWxSZWdFeGVjQ3R4dFB0ciByZWdleEN0eHQ7CgkgICAgeG1sQ2hhciAqdmFsdWVzWzEwXTsKCSAgICBpbnQgdGVybWluYWwsIG5idmFsID0gMTAsIG5ibmVnOwoKCSAgICAvKiBWQUwgVE9ETzogT3B0aW1pemVkICJhbnlUeXBlIiB2YWxpZGF0aW9uLiovCgoJICAgIGlmIChwdHlwZS0+Y29udE1vZGVsID09IE5VTEwpIHsKCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUNoaWxkRWxlbSIsCgkJICAgICJ0eXBlIGhhcyBlbGVtIGNvbnRlbnQgYnV0IG5vIGNvbnRlbnQgbW9kZWwiKTsKCQlyZXR1cm4gKC0xKTsKCSAgICB9CgkgICAgLyoKCSAgICAqIFNhZmV0eSBiZWxmIGZvciBldmFsdWF0aW9uIGlmIHRoZSBjb250LiBtb2RlbCB3YXMgYWxyZWFkeQoJICAgICogZXhhbWluZWQgdG8gYmUgaW52YWxpZC4KCSAgICAqLwoJICAgIGlmIChwaWVsZW0tPmZsYWdzICYgWE1MX1NDSEVNQV9FTEVNX0lORk9fRVJSX0JBRF9DT05URU5UKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVDaGlsZEVsZW0iLAoJCSAgICAidmFsaWRhdGluZyBlbGVtLCBidXQgZWxlbSBjb250ZW50IGlzIGFscmVhZHkgaW52YWxpZCIpOwoJCXJldHVybiAoLTEpOwoJICAgIH0KCgkgICAgcmVnZXhDdHh0ID0gcGllbGVtLT5yZWdleEN0eHQ7CgkgICAgaWYgKHJlZ2V4Q3R4dCA9PSBOVUxMKSB7CgkJLyoKCQkqIENyZWF0ZSB0aGUgcmVnZXggY29udGV4dC4KCQkqLwoJCXJlZ2V4Q3R4dCA9IHhtbFJlZ05ld0V4ZWNDdHh0KHB0eXBlLT5jb250TW9kZWwsCgkJICAgICh4bWxSZWdFeGVjQ2FsbGJhY2tzKSB4bWxTY2hlbWFWQ29udGVudE1vZGVsQ2FsbGJhY2ssCgkJICAgIHZjdHh0KTsKCQlpZiAocmVnZXhDdHh0ID09IE5VTEwpIHsKCQkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVDaGlsZEVsZW0iLAoJCQkiZmFpbGVkIHRvIGNyZWF0ZSBhIHJlZ2V4IGNvbnRleHQiKTsKCQkgICAgcmV0dXJuICgtMSk7CgkJfQoJCXBpZWxlbS0+cmVnZXhDdHh0ID0gcmVnZXhDdHh0OwojaWZkZWYgREVCVUdfQVVUT01BVEEKCQl4bWxHZW5lcmljRXJyb3IoeG1sR2VuZXJpY0Vycm9yQ29udGV4dCwgIkFVVE9NQVRBIGNyZWF0ZSBvbiAnJXMnXG4iLAoJCSAgICBwaWVsZW0tPmxvY2FsTmFtZSk7CiNlbmRpZgoJICAgIH0KCgkgICAgLyoKCSAgICAqIFNQRUMgKDIuNCkgIklmIHRoZSB7Y29udGVudCB0eXBlfSBpcyBlbGVtZW50LW9ubHkgb3IgbWl4ZWQsCgkgICAgKiB0aGVuIHRoZSBzZXF1ZW5jZSBvZiB0aGUgZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtJ3MKCSAgICAqIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBbY2hpbGRyZW5dLCBpZiBhbnksIHRha2VuIGluCgkgICAgKiBvcmRlciwgaXMgt3ZhbGlktyB3aXRoIHJlc3BlY3QgdG8gdGhlIHtjb250ZW50IHR5cGV9J3MKCSAgICAqIHBhcnRpY2xlLCBhcyBkZWZpbmVkIGluIEVsZW1lbnQgU2VxdWVuY2UgTG9jYWxseSBWYWxpZAoJICAgICogKFBhcnRpY2xlKSAopzMuOS40KS4iCgkgICAgKi8KCSAgICByZXQgPSB4bWxSZWdFeGVjUHVzaFN0cmluZzIocmVnZXhDdHh0LAoJCXZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lLAoJCXZjdHh0LT5pbm9kZS0+bnNOYW1lLAoJCXZjdHh0LT5pbm9kZSk7CiNpZmRlZiBERUJVR19BVVRPTUFUQQoJICAgIGlmIChyZXQgPCAwKQoJCXhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LAoJCSJBVVRPTUFUT04gcHVzaCBFUlJPUiBmb3IgJyVzJyBvbiAnJXMnXG4iLAoJCXZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lLCBwaWVsZW0tPmxvY2FsTmFtZSk7CgkgICAgZWxzZQoJCXhtbEdlbmVyaWNFcnJvcih4bWxHZW5lcmljRXJyb3JDb250ZXh0LAoJCSJBVVRPTUFUT04gcHVzaCBPSyBmb3IgJyVzJyBvbiAnJXMnXG4iLAoJCXZjdHh0LT5pbm9kZS0+bG9jYWxOYW1lLCBwaWVsZW0tPmxvY2FsTmFtZSk7CiNlbmRpZgoJICAgIGlmICh2Y3R4dC0+ZXJyID09IFhNTF9TQ0hFTUFWX0lOVEVSTkFMKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVDaGlsZEVsZW0iLAoJCSAgICAiY2FsbGluZyB4bWxSZWdFeGVjUHVzaFN0cmluZzIoKSIpOwoJCXJldHVybiAoLTEpOwoJICAgIH0KCSAgICBpZiAocmV0IDwgMCkgewoJCXhtbFJlZ0V4ZWNFcnJJbmZvKHJlZ2V4Q3R4dCwgTlVMTCwgJm5idmFsLCAmbmJuZWcsCgkJICAgICZ2YWx1ZXNbMF0sICZ0ZXJtaW5hbCk7CgkJeG1sU2NoZW1hQ29tcGxleFR5cGVFcnIoQUNUWFRfQ0FTVCB2Y3R4dCwKCQkgICAgWE1MX1NDSEVNQVZfRUxFTUVOVF9DT05URU5ULCBOVUxMLE5VTEwsCgkJICAgICJUaGlzIGVsZW1lbnQgaXMgbm90IGV4cGVjdGVkIiwKCQkgICAgbmJ2YWwsIG5ibmVnLCB2YWx1ZXMpOwoJCXJldCA9IHZjdHh0LT5lcnI7CgkJZ290byB1bmV4cGVjdGVkX2VsZW07CgkgICAgfSBlbHNlCgkJcmV0ID0gMDsKCX0KCSAgICBicmVhazsKCWNhc2UgWE1MX1NDSEVNQV9DT05URU5UX1NJTVBMRToKCWNhc2UgWE1MX1NDSEVNQV9DT05URU5UX0JBU0lDOgoJICAgIEFDVElWQVRFX1BBUkVOVF9FTEVNCgkgICAgaWYgKFdYU19JU19DT01QTEVYKHB0eXBlKSkgewoJCS8qCgkJKiBTUEVDIChjdmMtY29tcGxleC10eXBlKSAoMi4yKQoJCSogIklmIHRoZSB7Y29udGVudCB0eXBlfSBpcyBhIHNpbXBsZSB0eXBlIGRlZmluaXRpb24sIHRoZW4KCQkqIHRoZSBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0gaGFzIG5vIGVsZW1lbnQgaW5mb3JtYXRpb24KCQkqIGl0ZW0gW2NoaWxkcmVuXSwgLi4uIgoJCSovCgkJcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX0NPTVBMRVhfVFlQRV8yXzI7CgkJVkVSUk9SKHJldCwgTlVMTCwgIkVsZW1lbnQgY29udGVudCBpcyBub3QgYWxsb3dlZCwgIgoJCSAgICAiYmVjYXVzZSB0aGUgY29udGVudCB0eXBlIGlzIGEgc2ltcGxlIHR5cGUgZGVmaW5pdGlvbiIpOwoJICAgIH0gZWxzZSB7CgkJLyoKCQkqIFNQRUMgKGN2Yy10eXBlKSAoMy4xLjIpICJUaGUgZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtIG11c3QKCQkqIGhhdmUgbm8gZWxlbWVudCBpbmZvcm1hdGlvbiBpdGVtIFtjaGlsZHJlbl0uIgoJCSovCgkJcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX1RZUEVfM18xXzI7CgkJVkVSUk9SKHJldCwgTlVMTCwgIkVsZW1lbnQgY29udGVudCBpcyBub3QgYWxsb3dlZCwgIgoJCSAgICAiYmVjYXVzZSB0aGUgdHlwZSBkZWZpbml0aW9uIGlzIHNpbXBsZSIpOwoJICAgIH0KCSAgICBBQ1RJVkFURV9FTEVNCgkgICAgcmV0ID0gdmN0eHQtPmVycjsKCSAgICBnb3RvIHVuZXhwZWN0ZWRfZWxlbTsKCSAgICBicmVhazsKCglkZWZhdWx0OgoJICAgIGJyZWFrOwogICAgfQogICAgcmV0dXJuIChyZXQpOwp1bmV4cGVjdGVkX2VsZW06CiAgICAvKgogICAgKiBQb3AgdGhpcyBlbGVtZW50IGFuZCBzZXQgdGhlIHNraXBEZXB0aCB0byBza2lwCiAgICAqIGFsbCBmdXJ0aGVyIGNvbnRlbnQgb2YgdGhlIHBhcmVudCBlbGVtZW50LgogICAgKi8KICAgIHZjdHh0LT5za2lwRGVwdGggPSB2Y3R4dC0+ZGVwdGg7CiAgICB2Y3R4dC0+aW5vZGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfTk9ERV9JTkZPX0VSUl9OT1RfRVhQRUNURUQ7CiAgICBwaWVsZW0tPmZsYWdzIHw9IFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VSUl9CQURfQ09OVEVOVDsKICAgIHJldHVybiAocmV0KTsKfQoKI2RlZmluZSBYTUxfU0NIRU1BX1BVU0hfVEVYVF9QRVJTSVNUIDEKI2RlZmluZSBYTUxfU0NIRU1BX1BVU0hfVEVYVF9DUkVBVEVEIDIKI2RlZmluZSBYTUxfU0NIRU1BX1BVU0hfVEVYVF9WT0xBVElMRSAzCgpzdGF0aWMgaW50CnhtbFNjaGVtYVZQdXNoVGV4dCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQsCgkJICBpbnQgbm9kZVR5cGUsIGNvbnN0IHhtbENoYXIgKnZhbHVlLCBpbnQgbGVuLAoJCSAgaW50IG1vZGUsIGludCAqY29uc3VtZWQpCnsKICAgIC8qCiAgICAqIFVuZm9ydHVuYXRlbHkgd2UgaGF2ZSB0byBkdXBsaWNhdGUgdGhlIHRleHQgc29tZXRpbWVzLgogICAgKiBPUFRJTUlaRTogTWF5YmUgd2UgY291bGQgc2tpcCBpdCwgaWY6CiAgICAqICAgMS4gY29udGVudCB0eXBlIGlzIHNpbXBsZQogICAgKiAgIDIuIHdoaXRlc3BhY2UgaXMgImNvbGxhcHNlIgogICAgKiAgIDMuIGl0IGNvbnNpc3RzIG9mIHdoaXRlc3BhY2Ugb25seQogICAgKgogICAgKiBQcm9jZXNzIGNoYXJhY3RlciBjb250ZW50LgogICAgKi8KICAgIGlmIChjb25zdW1lZCAhPSBOVUxMKQoJKmNvbnN1bWVkID0gMDsKICAgIGlmIChJTk9ERV9OSUxMRUQodmN0eHQtPmlub2RlKSkgewoJLyogCgkqIFNQRUMgY3ZjLWVsdCAoMy4zLjQgLSAzLjIuMSkKCSogIlRoZSBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0gbXVzdCBoYXZlIG5vIGNoYXJhY3RlciBvcgoJKiBlbGVtZW50IGluZm9ybWF0aW9uIGl0ZW0gW2NoaWxkcmVuXS4iCgkqLwoJVkVSUk9SKFhNTF9TQ0hFTUFWX0NWQ19FTFRfM18yXzEsIE5VTEwsCgkgICAgIk5laXRoZXIgY2hhcmFjdGVyIG5vciBlbGVtZW50IGNvbnRlbnQgaXMgYWxsb3dlZCAiCgkgICAgImJlY2F1c2UgdGhlIGVsZW1lbnQgaXMgJ25pbGxlZCciKTsKCXJldHVybiAodmN0eHQtPmVycik7CiAgICB9CiAgICAvKgogICAgKiBTUEVDICgyLjEpICJJZiB0aGUge2NvbnRlbnQgdHlwZX0gaXMgZW1wdHksIHRoZW4gdGhlCiAgICAqIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBoYXMgbm8gY2hhcmFjdGVyIG9yIGVsZW1lbnQKICAgICogaW5mb3JtYXRpb24gaXRlbSBbY2hpbGRyZW5dLiIKICAgICovCiAgICBpZiAodmN0eHQtPmlub2RlLT50eXBlRGVmLT5jb250ZW50VHlwZSA9PQoJICAgIFhNTF9TQ0hFTUFfQ09OVEVOVF9FTVBUWSkgeyAgICAKCVZFUlJPUihYTUxfU0NIRU1BVl9DVkNfQ09NUExFWF9UWVBFXzJfMSwgTlVMTCwKCSAgICAiQ2hhcmFjdGVyIGNvbnRlbnQgaXMgbm90IGFsbG93ZWQsICIKCSAgICAiYmVjYXVzZSB0aGUgY29udGVudCB0eXBlIGlzIGVtcHR5Iik7CglyZXR1cm4gKHZjdHh0LT5lcnIpOwogICAgfQoKICAgIGlmICh2Y3R4dC0+aW5vZGUtPnR5cGVEZWYtPmNvbnRlbnRUeXBlID09CgkgICAgWE1MX1NDSEVNQV9DT05URU5UX0VMRU1FTlRTKSB7CglpZiAoKG5vZGVUeXBlICE9IFhNTF9URVhUX05PREUpIHx8CgkgICAgKCEgeG1sU2NoZW1hSXNCbGFuaygoeG1sQ2hhciAqKSB2YWx1ZSwgbGVuKSkpIHsKCSAgICAvKiAKCSAgICAqIFNQRUMgY3ZjLWNvbXBsZXgtdHlwZSAoMi4zKSAKCSAgICAqICJJZiB0aGUge2NvbnRlbnQgdHlwZX0gaXMgZWxlbWVudC1vbmx5LCB0aGVuIHRoZSAKCSAgICAqIGVsZW1lbnQgaW5mb3JtYXRpb24gaXRlbSBoYXMgbm8gY2hhcmFjdGVyIGluZm9ybWF0aW9uIAoJICAgICogaXRlbSBbY2hpbGRyZW5dIG90aGVyIHRoYW4gdGhvc2Ugd2hvc2UgW2NoYXJhY3RlciAKCSAgICAqIGNvZGVdIGlzIGRlZmluZWQgYXMgYSB3aGl0ZSBzcGFjZSBpbiBbWE1MIDEuMCAoU2Vjb25kIAoJICAgICogRWRpdGlvbildLiIKCSAgICAqLwoJICAgIFZFUlJPUihYTUxfU0NIRU1BVl9DVkNfQ09NUExFWF9UWVBFXzJfMywgTlVMTCwKCQkiQ2hhcmFjdGVyIGNvbnRlbnQgb3RoZXIgdGhhbiB3aGl0ZXNwYWNlIGlzIG5vdCBhbGxvd2VkICIKCQkiYmVjYXVzZSB0aGUgY29udGVudCB0eXBlIGlzICdlbGVtZW50LW9ubHknIik7CgkgICAgcmV0dXJuICh2Y3R4dC0+ZXJyKTsKCX0KCXJldHVybiAoMCk7CiAgICB9CiAgICAKICAgIGlmICgodmFsdWUgPT0gTlVMTCkgfHwgKHZhbHVlWzBdID09IDApKQoJcmV0dXJuICgwKTsKICAgIC8qCiAgICAqIFNhdmUgdGhlIHZhbHVlLgogICAgKiBOT1RFIHRoYXQgZXZlbiBpZiB0aGUgY29udGVudCB0eXBlIGlzICptaXhlZCosIHdlIG5lZWQgdGhlCiAgICAqICppbml0aWFsIHZhbHVlKiBmb3IgZGVmYXVsdC9maXhlZCB2YWx1ZSBjb25zdHJhaW50cy4KICAgICovCiAgICBpZiAoKHZjdHh0LT5pbm9kZS0+dHlwZURlZi0+Y29udGVudFR5cGUgPT0gWE1MX1NDSEVNQV9DT05URU5UX01JWEVEKSAmJgoJKCh2Y3R4dC0+aW5vZGUtPmRlY2wgPT0gTlVMTCkgfHwKCSh2Y3R4dC0+aW5vZGUtPmRlY2wtPnZhbHVlID09IE5VTEwpKSkKCXJldHVybiAoMCk7CiAgICAKICAgIGlmICh2Y3R4dC0+aW5vZGUtPnZhbHVlID09IE5VTEwpIHsKCS8qCgkqIFNldCB0aGUgdmFsdWUuCgkqLwoJc3dpdGNoIChtb2RlKSB7CgkgICAgY2FzZSBYTUxfU0NIRU1BX1BVU0hfVEVYVF9QRVJTSVNUOgoJCS8qCgkJKiBXaGVuIHdvcmtpbmcgb24gYSB0cmVlLgoJCSovCgkJdmN0eHQtPmlub2RlLT52YWx1ZSA9IHZhbHVlOwoJCWJyZWFrOwoJICAgIGNhc2UgWE1MX1NDSEVNQV9QVVNIX1RFWFRfQ1JFQVRFRDoKCQkvKgoJCSogV2hlbiB3b3JraW5nIHdpdGggdGhlIHJlYWRlci4KCQkqIFRoZSB2YWx1ZSB3aWxsIGJlIGZyZWVkIGJ5IHRoZSBlbGVtZW50IGluZm8uCgkJKi8KCQl2Y3R4dC0+aW5vZGUtPnZhbHVlID0gdmFsdWU7CgkJaWYgKGNvbnN1bWVkICE9IE5VTEwpCgkJICAgICpjb25zdW1lZCA9IDE7CgkJdmN0eHQtPmlub2RlLT5mbGFncyB8PQoJCSAgICBYTUxfU0NIRU1BX05PREVfSU5GT19GTEFHX09XTkVEX1ZBTFVFUzsKCQlicmVhazsKCSAgICBjYXNlIFhNTF9TQ0hFTUFfUFVTSF9URVhUX1ZPTEFUSUxFOgoJCS8qCgkJKiBXaGVuIHdvcmtpbmcgd2l0aCBTQVguCgkJKiBUaGUgdmFsdWUgd2lsbCBiZSBmcmVlZCBieSB0aGUgZWxlbWVudCBpbmZvLgoJCSovCgkJaWYgKGxlbiAhPSAtMSkKCQkgICAgdmN0eHQtPmlub2RlLT52YWx1ZSA9IEJBRF9DQVNUIHhtbFN0cm5kdXAodmFsdWUsIGxlbik7CgkJZWxzZQoJCSAgICB2Y3R4dC0+aW5vZGUtPnZhbHVlID0gQkFEX0NBU1QgeG1sU3RyZHVwKHZhbHVlKTsKCQl2Y3R4dC0+aW5vZGUtPmZsYWdzIHw9CgkJICAgIFhNTF9TQ0hFTUFfTk9ERV9JTkZPX0ZMQUdfT1dORURfVkFMVUVTOwoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJYnJlYWs7Cgl9CiAgICB9IGVsc2UgewoJaWYgKGxlbiA8IDApCgkgICAgbGVuID0geG1sU3RybGVuKHZhbHVlKTsKCS8qCgkqIENvbmNhdCB0aGUgdmFsdWUuCgkqLwkKCWlmICh2Y3R4dC0+aW5vZGUtPmZsYWdzICYgWE1MX1NDSEVNQV9OT0RFX0lORk9fRkxBR19PV05FRF9WQUxVRVMpIHsKCSAgICB2Y3R4dC0+aW5vZGUtPnZhbHVlID0gQkFEX0NBU1QgeG1sU3RybmNhdCgKCQkoeG1sQ2hhciAqKSB2Y3R4dC0+aW5vZGUtPnZhbHVlLCB2YWx1ZSwgbGVuKTsKCX0gZWxzZSB7CgkgICAgdmN0eHQtPmlub2RlLT52YWx1ZSA9CgkJQkFEX0NBU1QgeG1sU3RybmNhdE5ldyh2Y3R4dC0+aW5vZGUtPnZhbHVlLCB2YWx1ZSwgbGVuKTsKCSAgICB2Y3R4dC0+aW5vZGUtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfTk9ERV9JTkZPX0ZMQUdfT1dORURfVkFMVUVTOwoJfQogICAgfQkKCiAgICByZXR1cm4gKDApOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVZhbGlkYXRlRWxlbSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpCnsKICAgIGludCByZXQgPSAwOwoKICAgIGlmICgodmN0eHQtPnNraXBEZXB0aCAhPSAtMSkgJiYKCSh2Y3R4dC0+ZGVwdGggPj0gdmN0eHQtPnNraXBEZXB0aCkpIHsKCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRlRWxlbSIsCgkgICAgImluIHNraXAtc3RhdGUiKTsKCWdvdG8gaW50ZXJuYWxfZXJyb3I7CiAgICB9CiAgICBpZiAodmN0eHQtPnhzaUFzc2VtYmxlKSB7CgkvKiAKCSogV2Ugd2lsbCBzdG9wIHZhbGlkYXRpb24gaWYgdGhlcmUgd2FzIGFuIGVycm9yIGR1cmluZwoJKiBkeW5hbWljIHNjaGVtYSBjb25zdHJ1Y3Rpb24uCgkqIE5vdGUgdGhhdCB3ZSBzaW1wbHkgc2V0IEBza2lwRGVwdGggdG8gMCwgdGhpcyBjb3VsZAoJKiBtZWFuIHRoYXQgYSBzdHJlYW1pbmcgZG9jdW1lbnQgdmlhIFNBWCB3b3VsZCBiZQoJKiBzdGlsbCByZWFkIHRvIHRoZSBlbmQgYnV0IGl0IHdvbid0IGJlIHZhbGlkYXRlZCBhbnkgbW9yZS4KCSogVE9ETzogSWYgd2UgYXJlIHN1cmUgaG93IHRvIHN0b3AgdGhlIHZhbGlkYXRpb24gYXQgb25jZQoJKiAgIGZvciBhbGwgaW5wdXQgc2NlbmFyaW9zLCB0aGVuIHRoaXMgc2hvdWxkIGJlIGNoYW5nZWQgdG8KCSogICBpbnN0YW50bHkgc3RvcCB0aGUgdmFsaWRhdGlvbi4KCSovCglyZXQgPSB4bWxTY2hlbWFBc3NlbWJsZUJ5WFNJKHZjdHh0KTsKCWlmIChyZXQgIT0gMCkgewoJICAgIGlmIChyZXQgPT0gLTEpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICB2Y3R4dC0+c2tpcERlcHRoID0gMDsKCSAgICByZXR1cm4ocmV0KTsKCX0KICAgIH0KICAgIGlmICh2Y3R4dC0+ZGVwdGggPiAwKSB7CgkvKgoJKiBWYWxpZGF0ZSB0aGlzIGVsZW1lbnQgYWdhaW5zdCB0aGUgY29udGVudCBtb2RlbAoJKiBvZiB0aGUgcGFyZW50LgoJKi8KCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlQ2hpbGRFbGVtKHZjdHh0KTsKCWlmIChyZXQgIT0gMCkgewoJICAgIGlmIChyZXQgPCAwKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVFbGVtIiwKCQkgICAgImNhbGxpbmcgeG1sU2NoZW1hU3RyZWFtVmFsaWRhdGVDaGlsZEVsZW1lbnQoKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJICAgIGdvdG8gZXhpdDsKCX0KCWlmICh2Y3R4dC0+ZGVwdGggPT0gdmN0eHQtPnNraXBEZXB0aCkKCSAgICBnb3RvIGV4aXQ7CglpZiAoKHZjdHh0LT5pbm9kZS0+ZGVjbCA9PSBOVUxMKSAmJgoJICAgICh2Y3R4dC0+aW5vZGUtPnR5cGVEZWYgPT0gTlVMTCkpIHsKCSAgICBWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUVsZW0iLAoJCSJ0aGUgY2hpbGQgZWxlbWVudCB3YXMgdmFsaWQgYnV0IG5laXRoZXIgdGhlICIKCQkiZGVjbGFyYXRpb24gbm9yIHRoZSB0eXBlIHdhcyBzZXQiKTsKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJfQogICAgfSBlbHNlIHsKCS8qCgkqIEdldCB0aGUgZGVjbGFyYXRpb24gb2YgdGhlIHZhbGlkYXRpb24gcm9vdC4KCSovCgl2Y3R4dC0+aW5vZGUtPmRlY2wgPSB4bWxTY2hlbWFHZXRFbGVtKHZjdHh0LT5zY2hlbWEsCgkgICAgdmN0eHQtPmlub2RlLT5sb2NhbE5hbWUsCgkgICAgdmN0eHQtPmlub2RlLT5uc05hbWUpOwoJaWYgKHZjdHh0LT5pbm9kZS0+ZGVjbCA9PSBOVUxMKSB7CgkgICAgcmV0ID0gWE1MX1NDSEVNQVZfQ1ZDX0VMVF8xOwoJICAgIFZFUlJPUihyZXQsIE5VTEwsCgkJIk5vIG1hdGNoaW5nIGdsb2JhbCBkZWNsYXJhdGlvbiBhdmFpbGFibGUgIgoJCSJmb3IgdGhlIHZhbGlkYXRpb24gcm9vdCIpOwoJICAgIGdvdG8gZXhpdDsKCX0KICAgIH0KCiAgICBpZiAodmN0eHQtPmlub2RlLT5kZWNsID09IE5VTEwpCglnb3RvIHR5cGVfdmFsaWRhdGlvbjsKCiAgICBpZiAodmN0eHQtPmlub2RlLT5kZWNsLT50eXBlID09IFhNTF9TQ0hFTUFfVFlQRV9BTlkpIHsKCWludCBza2lwOwoJLyoKCSogV2lsZGNhcmRzLgoJKi8KCXJldCA9IHhtbFNjaGVtYVZhbGlkYXRlRWxlbVdpbGRjYXJkKHZjdHh0LCAmc2tpcCk7CglpZiAocmV0ICE9IDApIHsKCSAgICBpZiAocmV0IDwgMCkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZhbGlkYXRlRWxlbSIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVZhbGlkYXRlRWxlbVdpbGRjYXJkKCkiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCSAgICBnb3RvIGV4aXQ7Cgl9CglpZiAoc2tpcCkgewoJICAgIHZjdHh0LT5za2lwRGVwdGggPSB2Y3R4dC0+ZGVwdGg7CgkgICAgZ290byBleGl0OwoJfQoJLyoKCSogVGhlIGRlY2xhcmF0aW9uIG1pZ2h0IGJlIHNldCBieSB0aGUgd2lsZGNhcmQgdmFsaWRhdGlvbiwKCSogd2hlbiB0aGUgcHJvY2Vzc0NvbnRlbnRzIGlzICJsYXgiIG9yICJzdHJpY3QiLgoJKi8KCWlmICh2Y3R4dC0+aW5vZGUtPmRlY2wtPnR5cGUgIT0gWE1MX1NDSEVNQV9UWVBFX0VMRU1FTlQpIHsKCSAgICAvKgoJICAgICogQ2xlYXIgdGhlICJkZWNsIiBmaWVsZCB0byBub3QgY29uZnVzZSBmdXJ0aGVyIHByb2Nlc3NpbmcuCgkgICAgKi8KCSAgICB2Y3R4dC0+aW5vZGUtPmRlY2wgPSBOVUxMOwoJICAgIGdvdG8gdHlwZV92YWxpZGF0aW9uOwoJfQogICAgfQogICAgLyoKICAgICogVmFsaWRhdGUgYWdhaW5zdCB0aGUgZGVjbGFyYXRpb24uCiAgICAqLwogICAgcmV0ID0geG1sU2NoZW1hVmFsaWRhdGVFbGVtRGVjbCh2Y3R4dCk7CiAgICBpZiAocmV0ICE9IDApIHsKCWlmIChyZXQgPCAwKSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVFbGVtIiwKCQkiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0ZUVsZW1EZWNsKCkiKTsKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJfQoJZ290byBleGl0OwogICAgfQogICAgLyoKICAgICogVmFsaWRhdGUgYWdhaW5zdCB0aGUgdHlwZSBkZWZpbml0aW9uLgogICAgKi8KdHlwZV92YWxpZGF0aW9uOgoKICAgIGlmICh2Y3R4dC0+aW5vZGUtPnR5cGVEZWYgPT0gTlVMTCkgewoJdmN0eHQtPmlub2RlLT5mbGFncyB8PSBYTUxfU0NIRU1BX05PREVfSU5GT19FUlJfQkFEX1RZUEU7CglyZXQgPSBYTUxfU0NIRU1BVl9DVkNfVFlQRV8xOwogICAgCVZFUlJPUihyZXQsIE5VTEwsCiAgICAJICAgICJUaGUgdHlwZSBkZWZpbml0aW9uIGlzIGFic2VudCIpOwoJZ290byBleGl0OwogICAgfSAgICAKICAgIGlmICh2Y3R4dC0+aW5vZGUtPnR5cGVEZWYtPmZsYWdzICYgWE1MX1NDSEVNQVNfVFlQRV9BQlNUUkFDVCkgewoJdmN0eHQtPmlub2RlLT5mbGFncyB8PSBYTUxfU0NIRU1BX05PREVfSU5GT19FUlJfQkFEX1RZUEU7CglyZXQgPSBYTUxfU0NIRU1BVl9DVkNfVFlQRV8yOwogICAgCSAgICBWRVJST1IocmV0LCBOVUxMLAogICAgCSAgICAiVGhlIHR5cGUgZGVmaW5pdGlvbiBpcyBhYnN0cmFjdCIpOwkKCWdvdG8gZXhpdDsKICAgIH0KICAgIC8qCiAgICAqIEV2YWx1YXRlIElEQ3MuIERvIGl0IGhlcmUsIHNpbmNlIG5ldyBJREMgbWF0Y2hlcnMgYXJlIHJlZ2lzdGVyZWQKICAgICogZHVyaW5nIHZhbGlkYXRpb24gYWdhaW5zdCB0aGUgZGVjbGFyYXRpb24uIFRoaXMgbXVzdCBiZSBkb25lCiAgICAqIF9iZWZvcmVfIGF0dHJpYnV0ZSB2YWxpZGF0aW9uLgogICAgKi8KICAgIGlmICh2Y3R4dC0+eHBhdGhTdGF0ZXMgIT0gTlVMTCkgewoJcmV0ID0geG1sU2NoZW1hWFBhdGhFdmFsdWF0ZSh2Y3R4dCwgWE1MX0VMRU1FTlRfTk9ERSk7Cgl2Y3R4dC0+aW5vZGUtPmFwcGxpZWRYUGF0aCA9IDE7CglpZiAocmV0ID09IC0xKSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVmFsaWRhdGVFbGVtIiwKCQkiY2FsbGluZyB4bWxTY2hlbWFYUGF0aEV2YWx1YXRlKCkiKTsKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJfQogICAgfQogICAgLyoKICAgICogVmFsaWRhdGUgYXR0cmlidXRlcy4KICAgICovCiAgICBpZiAoV1hTX0lTX0NPTVBMRVgodmN0eHQtPmlub2RlLT50eXBlRGVmKSkgewoJaWYgKCh2Y3R4dC0+bmJBdHRySW5mb3MgIT0gMCkgfHwKCSAgICAodmN0eHQtPmlub2RlLT50eXBlRGVmLT5hdHRyVXNlcyAhPSBOVUxMKSkgewoKCSAgICByZXQgPSB4bWxTY2hlbWFWQXR0cmlidXRlc0NvbXBsZXgodmN0eHQpOwoJfQogICAgfSBlbHNlIGlmICh2Y3R4dC0+bmJBdHRySW5mb3MgIT0gMCkgewoKCXJldCA9IHhtbFNjaGVtYVZBdHRyaWJ1dGVzU2ltcGxlKHZjdHh0KTsKICAgIH0KICAgIC8qCiAgICAqIENsZWFyIHJlZ2lzdGVyZWQgYXR0cmlidXRlcy4KICAgICovCiAgICBpZiAodmN0eHQtPm5iQXR0ckluZm9zICE9IDApCgl4bWxTY2hlbWFDbGVhckF0dHJJbmZvcyh2Y3R4dCk7CiAgICBpZiAocmV0ID09IC0xKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFWYWxpZGF0ZUVsZW0iLAoJICAgICJjYWxsaW5nIGF0dHJpYnV0ZXMgdmFsaWRhdGlvbiIpOwoJZ290byBpbnRlcm5hbF9lcnJvcjsKICAgIH0KICAgIC8qCiAgICAqIERvbid0IHJldHVybiBhbiBlcnJvciBpZiBhdHRyaWJ1dGVzIGFyZSBpbnZhbGlkIG9uIHB1cnBvc2UuCiAgICAqLwogICAgcmV0ID0gMDsKCmV4aXQ6CiAgICBpZiAocmV0ICE9IDApCgl2Y3R4dC0+c2tpcERlcHRoID0gdmN0eHQtPmRlcHRoOwogICAgcmV0dXJuIChyZXQpOwppbnRlcm5hbF9lcnJvcjoKICAgIHJldHVybiAoLTEpOwp9CgojaWZkZWYgWE1MX1NDSEVNQV9SRUFERVJfRU5BQkxFRApzdGF0aWMgaW50CnhtbFNjaGVtYVZSZWFkZXJXYWxrKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCkKewogICAgY29uc3QgaW50IFdIVFNQID0gMTMsIFNJR05fV0hUU1AgPSAxNCwgRU5EX0VMRU0gPSAxNTsKICAgIGludCBkZXB0aCwgbm9kZVR5cGUsIHJldCA9IDAsIGNvbnN1bWVkOwogICAgeG1sU2NoZW1hTm9kZUluZm9QdHIgaWVsZW07CgogICAgdmN0eHQtPmRlcHRoID0gLTE7CiAgICByZXQgPSB4bWxUZXh0UmVhZGVyUmVhZCh2Y3R4dC0+cmVhZGVyKTsKICAgIC8qCiAgICAqIE1vdmUgdG8gdGhlIGRvY3VtZW50IGVsZW1lbnQuCiAgICAqLwogICAgd2hpbGUgKHJldCA9PSAxKSB7Cglub2RlVHlwZSA9IHhtbFRleHRSZWFkZXJOb2RlVHlwZSh2Y3R4dC0+cmVhZGVyKTsKCWlmIChub2RlVHlwZSA9PSBYTUxfRUxFTUVOVF9OT0RFKQoJICAgIGdvdG8gcm9vdF9mb3VuZDsKCXJldCA9IHhtbFRleHRSZWFkZXJSZWFkKHZjdHh0LT5yZWFkZXIpOwogICAgfQogICAgZ290byBleGl0OwoKcm9vdF9mb3VuZDoKCiAgICBkbyB7CglkZXB0aCA9IHhtbFRleHRSZWFkZXJEZXB0aCh2Y3R4dC0+cmVhZGVyKTsKCW5vZGVUeXBlID0geG1sVGV4dFJlYWRlck5vZGVUeXBlKHZjdHh0LT5yZWFkZXIpOwoKCWlmIChub2RlVHlwZSA9PSBYTUxfRUxFTUVOVF9OT0RFKSB7CgkgICAgCgkgICAgdmN0eHQtPmRlcHRoKys7CgkgICAgaWYgKHhtbFNjaGVtYVZhbGlkYXRvclB1c2hFbGVtKHZjdHh0KSA9PSAtMSkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZSZWFkZXJXYWxrIiwKCQkgICAgImNhbGxpbmcgeG1sU2NoZW1hVmFsaWRhdG9yUHVzaEVsZW0oKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJICAgIGllbGVtID0gdmN0eHQtPmlub2RlOwoJICAgIGllbGVtLT5sb2NhbE5hbWUgPSB4bWxUZXh0UmVhZGVyTG9jYWxOYW1lKHZjdHh0LT5yZWFkZXIpOwoJICAgIGllbGVtLT5uc05hbWUgPSB4bWxUZXh0UmVhZGVyTmFtZXNwYWNlVXJpKHZjdHh0LT5yZWFkZXIpOwoJICAgIGllbGVtLT5mbGFncyB8PSBYTUxfU0NIRU1BX05PREVfSU5GT19GTEFHX09XTkVEX05BTUVTOwoJICAgIC8qCgkgICAgKiBJcyB0aGUgZWxlbWVudCBlbXB0eT8KCSAgICAqLwoJICAgIHJldCA9IHhtbFRleHRSZWFkZXJJc0VtcHR5RWxlbWVudCh2Y3R4dC0+cmVhZGVyKTsKCSAgICBpZiAocmV0ID09IC0xKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVlJlYWRlcldhbGsiLAoJCSAgICAiY2FsbGluZyB4bWxUZXh0UmVhZGVySXNFbXB0eUVsZW1lbnQoKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJICAgIGlmIChyZXQpIHsKCQlpZWxlbS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQV9FTEVNX0lORk9fRU1QVFk7CgkgICAgfQoJICAgIC8qCgkgICAgKiBSZWdpc3RlciBhdHRyaWJ1dGVzLgoJICAgICovCgkgICAgdmN0eHQtPm5iQXR0ckluZm9zID0gMDsKCSAgICByZXQgPSB4bWxUZXh0UmVhZGVyTW92ZVRvRmlyc3RBdHRyaWJ1dGUodmN0eHQtPnJlYWRlcik7CgkgICAgaWYgKHJldCA9PSAtMSkgewoJCVZFUlJPUl9JTlQoInhtbFNjaGVtYVZSZWFkZXJXYWxrIiwKCQkgICAgImNhbGxpbmcgeG1sVGV4dFJlYWRlck1vdmVUb0ZpcnN0QXR0cmlidXRlKCkiKTsKCQlnb3RvIGludGVybmFsX2Vycm9yOwoJICAgIH0KCSAgICBpZiAocmV0ID09IDEpIHsKCQlkbyB7CgkJICAgIC8qCgkJICAgICogVkFMIFRPRE86IEhvdyBkbyB3ZSBrbm93IHRoYXQgdGhlIHJlYWRlciB3b3JrcyBvbiBhCgkJICAgICogbm9kZSB0cmVlLCB0byBiZSBhYmxlIHRvIHBhc3MgYSBub2RlIGhlcmU/CgkJICAgICovCgkJICAgIGlmICh4bWxTY2hlbWFWYWxpZGF0b3JQdXNoQXR0cmlidXRlKHZjdHh0LCBOVUxMLAoJCQkoY29uc3QgeG1sQ2hhciAqKSB4bWxUZXh0UmVhZGVyTG9jYWxOYW1lKHZjdHh0LT5yZWFkZXIpLAoJCQl4bWxUZXh0UmVhZGVyTmFtZXNwYWNlVXJpKHZjdHh0LT5yZWFkZXIpLCAxLAoJCQl4bWxUZXh0UmVhZGVyVmFsdWUodmN0eHQtPnJlYWRlciksIDEpID09IC0xKSB7CgoJCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWUmVhZGVyV2FsayIsCgkJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0b3JQdXNoQXR0cmlidXRlKCkiKTsKCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkgICAgfQoJCSAgICByZXQgPSB4bWxUZXh0UmVhZGVyTW92ZVRvTmV4dEF0dHJpYnV0ZSh2Y3R4dC0+cmVhZGVyKTsKCQkgICAgaWYgKHJldCA9PSAtMSkgewoJCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWUmVhZGVyV2FsayIsCgkJCSAgICAiY2FsbGluZyB4bWxUZXh0UmVhZGVyTW92ZVRvRmlyc3RBdHRyaWJ1dGUoKSIpOwoJCQlnb3RvIGludGVybmFsX2Vycm9yOwoJCSAgICB9CgkJfSB3aGlsZSAocmV0ID09IDEpOwoJCS8qCgkJKiBCYWNrIHRvIGVsZW1lbnQgcG9zaXRpb24uCgkJKi8KCQlyZXQgPSB4bWxUZXh0UmVhZGVyTW92ZVRvRWxlbWVudCh2Y3R4dC0+cmVhZGVyKTsKCQlpZiAocmV0ID09IC0xKSB7CgkJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVZSZWFkZXJXYWxrIiwKCQkJImNhbGxpbmcgeG1sVGV4dFJlYWRlck1vdmVUb0VsZW1lbnQoKSIpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KCSAgICB9CgkgICAgLyoKCSAgICAqIFZhbGlkYXRlIHRoZSBlbGVtZW50LgoJICAgICovCgkgICAgcmV0PSB4bWxTY2hlbWFWYWxpZGF0ZUVsZW0odmN0eHQpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPT0gLTEpIHsKCQkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hVlJlYWRlcldhbGsiLAoJCQkiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0ZUVsZW0oKSIpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KCQlnb3RvIGV4aXQ7CgkgICAgfQoJICAgIGlmICh2Y3R4dC0+ZGVwdGggPT0gdmN0eHQtPnNraXBEZXB0aCkgewoJCWludCBjdXJEZXB0aDsKCQkvKgoJCSogU2tpcCBhbGwgY29udGVudC4KCQkqLwoJCWlmICgoaWVsZW0tPmZsYWdzICYgWE1MX1NDSEVNQV9FTEVNX0lORk9fRU1QVFkpID09IDApIHsKCQkgICAgcmV0ID0geG1sVGV4dFJlYWRlclJlYWQodmN0eHQtPnJlYWRlcik7CgkJICAgIGN1ckRlcHRoID0geG1sVGV4dFJlYWRlckRlcHRoKHZjdHh0LT5yZWFkZXIpOwoJCSAgICB3aGlsZSAoKHJldCA9PSAxKSAmJiAoY3VyRGVwdGggIT0gZGVwdGgpKSB7CgkJCXJldCA9IHhtbFRleHRSZWFkZXJSZWFkKHZjdHh0LT5yZWFkZXIpOwoJCQljdXJEZXB0aCA9IHhtbFRleHRSZWFkZXJEZXB0aCh2Y3R4dC0+cmVhZGVyKTsKCQkgICAgfQoJCSAgICBpZiAocmV0IDwgMCkgewoJCQkvKgoJCQkqIFZBTCBUT0RPOiBBIHJlYWRlciBlcnJvciBvY2N1cmVkOyB3aGF0IHRvIGRvIGhlcmU/CgkJCSovCgkJCXJldCA9IDE7CgkJCWdvdG8gZXhpdDsKCQkgICAgfQoJCX0KCQlnb3RvIGxlYXZlX2VsZW07CgkgICAgfQoJICAgIC8qCgkgICAgKiBSRUFERVIgVkFMIFRPRE86IElzIGFuIEVORF9FTEVNIHJlYWxseSBuZXZlciBjYWxsZWQKCSAgICAqIGlmIHRoZSBlbGVtIGlzIGVtcHR5PwoJICAgICovCgkgICAgaWYgKGllbGVtLT5mbGFncyAmIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZKQoJCWdvdG8gbGVhdmVfZWxlbTsKCX0gZWxzZSBpZiAobm9kZVR5cGUgPT0gRU5EX0VMRU0pIHsKCSAgICAvKgoJICAgICogUHJvY2VzcyBFTkQgb2YgZWxlbWVudC4KCSAgICAqLwpsZWF2ZV9lbGVtOgoJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRvclBvcEVsZW0odmN0eHQpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPCAwKSB7CgkJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVZSZWFkZXJXYWxrIiwKCQkJImNhbGxpbmcgeG1sU2NoZW1hVmFsaWRhdG9yUG9wRWxlbSgpIik7CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJCWdvdG8gZXhpdDsKCSAgICB9CgkgICAgaWYgKHZjdHh0LT5kZXB0aCA+PSAwKQoJCWllbGVtID0gdmN0eHQtPmlub2RlOwoJICAgIGVsc2UKCQlpZWxlbSA9IE5VTEw7Cgl9IGVsc2UgaWYgKChub2RlVHlwZSA9PSBYTUxfVEVYVF9OT0RFKSB8fAoJICAgIChub2RlVHlwZSA9PSBYTUxfQ0RBVEFfU0VDVElPTl9OT0RFKSB8fAoJICAgIChub2RlVHlwZSA9PSBXSFRTUCkgfHwKCSAgICAobm9kZVR5cGUgPT0gU0lHTl9XSFRTUCkpIHsKCSAgICAvKgoJICAgICogUHJvY2VzcyBjaGFyYWN0ZXIgY29udGVudC4KCSAgICAqLwoJICAgIHhtbENoYXIgKnZhbHVlOwoKCSAgICBpZiAoKG5vZGVUeXBlID09IFdIVFNQKSB8fCAobm9kZVR5cGUgPT0gU0lHTl9XSFRTUCkpCgkJbm9kZVR5cGUgPSBYTUxfVEVYVF9OT0RFOwoKCSAgICB2YWx1ZSA9IHhtbFRleHRSZWFkZXJWYWx1ZSh2Y3R4dC0+cmVhZGVyKTsKCSAgICByZXQgPSB4bWxTY2hlbWFWUHVzaFRleHQodmN0eHQsIG5vZGVUeXBlLCBCQURfQ0FTVCB2YWx1ZSwKCQktMSwgWE1MX1NDSEVNQV9QVVNIX1RFWFRfQ1JFQVRFRCwgJmNvbnN1bWVkKTsKCSAgICBpZiAoISBjb25zdW1lZCkKCQl4bWxGcmVlKHZhbHVlKTsKCSAgICBpZiAocmV0ID09IC0xKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVlJlYWRlcldhbGsiLAoJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFWUHVzaFRleHQoKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJfSBlbHNlIGlmICgobm9kZVR5cGUgPT0gWE1MX0VOVElUWV9OT0RFKSB8fAoJICAgIChub2RlVHlwZSA9PSBYTUxfRU5USVRZX1JFRl9OT0RFKSkgewoJICAgIC8qCgkgICAgKiBWQUwgVE9ETzogV2hhdCB0byBkbyB3aXRoIGVudGl0aWVzPwoJICAgICovCgkgICAgVE9ETwoJfQoJLyoKCSogUmVhZCBuZXh0IG5vZGUuCgkqLwoJcmV0ID0geG1sVGV4dFJlYWRlclJlYWQodmN0eHQtPnJlYWRlcik7CiAgICB9IHdoaWxlIChyZXQgPT0gMSk7CgpleGl0OgogICAgcmV0dXJuIChyZXQpOwppbnRlcm5hbF9lcnJvcjoKICAgIHJldHVybiAoLTEpOwp9CiNlbmRpZgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJCVNBWCB2YWxpZGF0aW9uIGhhbmRsZXJzCQkJCSoKICogCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoKKiBQcm9jZXNzIHRleHQgY29udGVudC4KKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hU0FYSGFuZGxlVGV4dCh2b2lkICpjdHgsIAoJCSAgICAgICBjb25zdCB4bWxDaGFyICogY2gsIAoJCSAgICAgICBpbnQgbGVuKQp7CiAgICB4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQgPSAoeG1sU2NoZW1hVmFsaWRDdHh0UHRyKSBjdHg7CgogICAgaWYgKHZjdHh0LT5kZXB0aCA8IDApCglyZXR1cm47CiAgICBpZiAoKHZjdHh0LT5za2lwRGVwdGggIT0gLTEpICYmICh2Y3R4dC0+ZGVwdGggPj0gdmN0eHQtPnNraXBEZXB0aCkpCglyZXR1cm47CiAgICBpZiAodmN0eHQtPmlub2RlLT5mbGFncyAmIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZKQoJdmN0eHQtPmlub2RlLT5mbGFncyBePSBYTUxfU0NIRU1BX0VMRU1fSU5GT19FTVBUWTsKICAgIGlmICh4bWxTY2hlbWFWUHVzaFRleHQodmN0eHQsIFhNTF9URVhUX05PREUsIGNoLCBsZW4sCglYTUxfU0NIRU1BX1BVU0hfVEVYVF9WT0xBVElMRSwgTlVMTCkgPT0gLTEpIHsKCVZFUlJPUl9JTlQoInhtbFNjaGVtYVNBWEhhbmRsZUNEYXRhU2VjdGlvbiIsCgkgICAgImNhbGxpbmcgeG1sU2NoZW1hVlB1c2hUZXh0KCkiKTsKCXZjdHh0LT5lcnIgPSAtMTsKCXhtbFN0b3BQYXJzZXIodmN0eHQtPnBhcnNlckN0eHQpOwogICAgfQp9CgovKgoqIFByb2Nlc3MgQ0RBVEEgY29udGVudC4KKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hU0FYSGFuZGxlQ0RhdGFTZWN0aW9uKHZvaWQgKmN0eCwgCgkJCSAgICAgY29uc3QgeG1sQ2hhciAqIGNoLCAKCQkJICAgICBpbnQgbGVuKQp7ICAgCiAgICB4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQgPSAoeG1sU2NoZW1hVmFsaWRDdHh0UHRyKSBjdHg7CgogICAgaWYgKHZjdHh0LT5kZXB0aCA8IDApCglyZXR1cm47CiAgICBpZiAoKHZjdHh0LT5za2lwRGVwdGggIT0gLTEpICYmICh2Y3R4dC0+ZGVwdGggPj0gdmN0eHQtPnNraXBEZXB0aCkpCglyZXR1cm47CiAgICBpZiAodmN0eHQtPmlub2RlLT5mbGFncyAmIFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZKQoJdmN0eHQtPmlub2RlLT5mbGFncyBePSBYTUxfU0NIRU1BX0VMRU1fSU5GT19FTVBUWTsKICAgIGlmICh4bWxTY2hlbWFWUHVzaFRleHQodmN0eHQsIFhNTF9DREFUQV9TRUNUSU9OX05PREUsIGNoLCBsZW4sCglYTUxfU0NIRU1BX1BVU0hfVEVYVF9WT0xBVElMRSwgTlVMTCkgPT0gLTEpIHsKCVZFUlJPUl9JTlQoInhtbFNjaGVtYVNBWEhhbmRsZUNEYXRhU2VjdGlvbiIsCgkgICAgImNhbGxpbmcgeG1sU2NoZW1hVlB1c2hUZXh0KCkiKTsKCXZjdHh0LT5lcnIgPSAtMTsKCXhtbFN0b3BQYXJzZXIodmN0eHQtPnBhcnNlckN0eHQpOwogICAgfQp9CgpzdGF0aWMgdm9pZAp4bWxTY2hlbWFTQVhIYW5kbGVSZWZlcmVuY2Uodm9pZCAqY3R4IEFUVFJJQlVURV9VTlVTRUQsCgkJCSAgICBjb25zdCB4bWxDaGFyICogbmFtZSBBVFRSSUJVVEVfVU5VU0VEKQp7CiAgICB4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQgPSAoeG1sU2NoZW1hVmFsaWRDdHh0UHRyKSBjdHg7CgogICAgaWYgKHZjdHh0LT5kZXB0aCA8IDApCglyZXR1cm47CiAgICBpZiAoKHZjdHh0LT5za2lwRGVwdGggIT0gLTEpICYmICh2Y3R4dC0+ZGVwdGggPj0gdmN0eHQtPnNraXBEZXB0aCkpCglyZXR1cm47CiAgICAvKiBTQVggVkFMIFRPRE86IFdoYXQgdG8gZG8gaGVyZT8gKi8KICAgIFRPRE8KfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hU0FYSGFuZGxlU3RhcnRFbGVtZW50TnModm9pZCAqY3R4LAoJCQkJIGNvbnN0IHhtbENoYXIgKiBsb2NhbG5hbWUsIAoJCQkJIGNvbnN0IHhtbENoYXIgKiBwcmVmaXggQVRUUklCVVRFX1VOVVNFRCwgCgkJCQkgY29uc3QgeG1sQ2hhciAqIFVSSSwgCgkJCQkgaW50IG5iX25hbWVzcGFjZXMsIAoJCQkJIGNvbnN0IHhtbENoYXIgKiogbmFtZXNwYWNlcywgCgkJCQkgaW50IG5iX2F0dHJpYnV0ZXMsIAoJCQkJIGludCBuYl9kZWZhdWx0ZWQgQVRUUklCVVRFX1VOVVNFRCwgCgkJCQkgY29uc3QgeG1sQ2hhciAqKiBhdHRyaWJ1dGVzKQp7ICAKICAgIHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciB2Y3R4dCA9ICh4bWxTY2hlbWFWYWxpZEN0eHRQdHIpIGN0eDsKICAgIGludCByZXQ7CiAgICB4bWxTY2hlbWFOb2RlSW5mb1B0ciBpZWxlbTsKICAgIGludCBpLCBqOwogICAgCiAgICAvKgogICAgKiBTQVggVkFMIFRPRE86IFdoYXQgdG8gZG8gd2l0aCBuYl9kZWZhdWx0ZWQ/CiAgICAqLwogICAgLyoKICAgICogU2tpcCBlbGVtZW50cyBpZiBpbnNpZGUgYSAic2tpcCIgd2lsZGNhcmQgb3IgaW52YWxpZC4KICAgICovCiAgICB2Y3R4dC0+ZGVwdGgrKzsKICAgIGlmICgodmN0eHQtPnNraXBEZXB0aCAhPSAtMSkgJiYgKHZjdHh0LT5kZXB0aCA+PSB2Y3R4dC0+c2tpcERlcHRoKSkKCXJldHVybjsKICAgIC8qCiAgICAqIFB1c2ggdGhlIGVsZW1lbnQuCiAgICAqLwogICAgaWYgKHhtbFNjaGVtYVZhbGlkYXRvclB1c2hFbGVtKHZjdHh0KSA9PSAtMSkgewoJVkVSUk9SX0lOVCgieG1sU2NoZW1hU0FYSGFuZGxlU3RhcnRFbGVtZW50TnMiLAoJICAgICJjYWxsaW5nIHhtbFNjaGVtYVZhbGlkYXRvclB1c2hFbGVtKCkiKTsKCWdvdG8gaW50ZXJuYWxfZXJyb3I7CiAgICB9CiAgICBpZWxlbSA9IHZjdHh0LT5pbm9kZTsKICAgIC8qCiAgICAqIFRPRE86IElzIHRoaXMgT0s/CiAgICAqLwogICAgaWVsZW0tPm5vZGVMaW5lID0geG1sU0FYMkdldExpbmVOdW1iZXIodmN0eHQtPnBhcnNlckN0eHQpOwogICAgaWVsZW0tPmxvY2FsTmFtZSA9IGxvY2FsbmFtZTsKICAgIGllbGVtLT5uc05hbWUgPSBVUkk7CiAgICBpZWxlbS0+ZmxhZ3MgfD0gWE1MX1NDSEVNQV9FTEVNX0lORk9fRU1QVFk7CiAgICAvKgogICAgKiBSZWdpc3RlciBuYW1lc3BhY2VzIG9uIHRoZSBlbGVtIGluZm8uCiAgICAqLyAgICAKICAgIGlmIChuYl9uYW1lc3BhY2VzICE9IDApIHsKCS8qCgkqIEFsdGhvdWdoIHRoZSBwYXJzZXIgYnVpbGRzIGl0cyBvd24gbmFtZXNwYWNlIGxpc3QsCgkqIHdlIGhhdmUgbm8gYWNjZXNzIHRvIGl0LCBzbyB3ZSdsbCB1c2UgYW4gb3duIG9uZS4KCSovCiAgICAgICAgZm9yIChpID0gMCwgaiA9IDA7IGkgPCBuYl9uYW1lc3BhY2VzOyBpKyssIGogKz0gMikgewkgICAgCgkgICAgLyoKCSAgICAqIFN0b3JlIHByZWZpeCBhbmQgbmFtZXNwYWNlIG5hbWUuCgkgICAgKi8JICAgCgkgICAgaWYgKGllbGVtLT5uc0JpbmRpbmdzID09IE5VTEwpIHsKCQlpZWxlbS0+bnNCaW5kaW5ncyA9CgkJICAgIChjb25zdCB4bWxDaGFyICoqKSB4bWxNYWxsb2MoMTAgKgoJCQlzaXplb2YoY29uc3QgeG1sQ2hhciAqKSk7CgkJaWYgKGllbGVtLT5uc0JpbmRpbmdzID09IE5VTEwpIHsKCQkgICAgeG1sU2NoZW1hVkVyck1lbW9yeSh2Y3R4dCwKCQkJImFsbG9jYXRpbmcgbmFtZXNwYWNlIGJpbmRpbmdzIGZvciBTQVggdmFsaWRhdGlvbiIsCgkJCU5VTEwpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KCQlpZWxlbS0+bmJOc0JpbmRpbmdzID0gMDsKCQlpZWxlbS0+c2l6ZU5zQmluZGluZ3MgPSA1OwoJICAgIH0gZWxzZSBpZiAoaWVsZW0tPnNpemVOc0JpbmRpbmdzIDw9IGllbGVtLT5uYk5zQmluZGluZ3MpIHsKCQlpZWxlbS0+c2l6ZU5zQmluZGluZ3MgKj0gMjsKCQlpZWxlbS0+bnNCaW5kaW5ncyA9CgkJICAgIChjb25zdCB4bWxDaGFyICoqKSB4bWxSZWFsbG9jKAoJCQkodm9pZCAqKSBpZWxlbS0+bnNCaW5kaW5ncywKCQkJaWVsZW0tPnNpemVOc0JpbmRpbmdzICogMiAqIHNpemVvZihjb25zdCB4bWxDaGFyICopKTsKCQlpZiAoaWVsZW0tPm5zQmluZGluZ3MgPT0gTlVMTCkgewoJCSAgICB4bWxTY2hlbWFWRXJyTWVtb3J5KHZjdHh0LAoJCQkicmUtYWxsb2NhdGluZyBuYW1lc3BhY2UgYmluZGluZ3MgZm9yIFNBWCB2YWxpZGF0aW9uIiwKCQkJTlVMTCk7CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJICAgIH0KCgkgICAgaWVsZW0tPm5zQmluZGluZ3NbaWVsZW0tPm5iTnNCaW5kaW5ncyAqIDJdID0gbmFtZXNwYWNlc1tqXTsKCSAgICBpZiAobmFtZXNwYWNlc1tqKzFdWzBdID09IDApIHsKCQkvKgoJCSogSGFuZGxlIHhtbG5zPSIiLgoJCSovCgkJaWVsZW0tPm5zQmluZGluZ3NbaWVsZW0tPm5iTnNCaW5kaW5ncyAqIDIgKyAxXSA9IE5VTEw7CgkgICAgfSBlbHNlCgkJaWVsZW0tPm5zQmluZGluZ3NbaWVsZW0tPm5iTnNCaW5kaW5ncyAqIDIgKyAxXSA9CgkJICAgIG5hbWVzcGFjZXNbaisxXTsKCSAgICBpZWxlbS0+bmJOc0JpbmRpbmdzKys7CSAgICAJICAgIAoJfQogICAgfQogICAgLyoKICAgICogUmVnaXN0ZXIgYXR0cmlidXRlcy4KICAgICogU0FYIFZBTCBUT0RPOiBXZSBhcmUgbm90IGFkZGluZyBuYW1lc3BhY2UgZGVjbGFyYXRpb24KICAgICogYXR0cmlidXRlcyB5ZXQuCiAgICAqLwogICAgaWYgKG5iX2F0dHJpYnV0ZXMgIT0gMCkgewoJeG1sQ2hhciAqdmFsdWU7CgogICAgICAgIGZvciAoaiA9IDAsIGkgPSAwOyBpIDwgbmJfYXR0cmlidXRlczsgaSsrLCBqICs9IDUpIHsKCSAgICAvKgoJICAgICogRHVwbGljYXRlIHRoZSB2YWx1ZS4KCSAgICAqLwkgCgkgICAgdmFsdWUgPSB4bWxTdHJuZHVwKGF0dHJpYnV0ZXNbaiszXSwKCQlhdHRyaWJ1dGVzW2orNF0gLSBhdHRyaWJ1dGVzW2orM10pOwoJICAgIC8qCgkgICAgKiBUT0RPOiBTZXQgdGhlIG5vZGUgbGluZS4KCSAgICAqLwoJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRvclB1c2hBdHRyaWJ1dGUodmN0eHQsCgkJTlVMTCwgaWVsZW0tPm5vZGVMaW5lLCBhdHRyaWJ1dGVzW2pdLCBhdHRyaWJ1dGVzW2orMl0sIDAsCgkJdmFsdWUsIDEpOwoJICAgIGlmIChyZXQgPT0gLTEpIHsKCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFTQVhIYW5kbGVTdGFydEVsZW1lbnROcyIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVZhbGlkYXRvclB1c2hBdHRyaWJ1dGUoKSIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJfQogICAgfQogICAgLyoKICAgICogVmFsaWRhdGUgdGhlIGVsZW1lbnQuCiAgICAqLwogICAgcmV0ID0geG1sU2NoZW1hVmFsaWRhdGVFbGVtKHZjdHh0KTsKICAgIGlmIChyZXQgIT0gMCkgewoJaWYgKHJldCA9PSAtMSkgewoJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVNBWEhhbmRsZVN0YXJ0RWxlbWVudE5zIiwKCQkiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0ZUVsZW0oKSIpOwoJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7Cgl9Cglnb3RvIGV4aXQ7CiAgICB9ICAgIAoKZXhpdDoKICAgIHJldHVybjsKaW50ZXJuYWxfZXJyb3I6CiAgICB2Y3R4dC0+ZXJyID0gLTE7CiAgICB4bWxTdG9wUGFyc2VyKHZjdHh0LT5wYXJzZXJDdHh0KTsKICAgIHJldHVybjsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hU0FYSGFuZGxlRW5kRWxlbWVudE5zKHZvaWQgKmN0eCwKCQkJICAgICAgIGNvbnN0IHhtbENoYXIgKiBsb2NhbG5hbWUgQVRUUklCVVRFX1VOVVNFRCwKCQkJICAgICAgIGNvbnN0IHhtbENoYXIgKiBwcmVmaXggQVRUUklCVVRFX1VOVVNFRCwKCQkJICAgICAgIGNvbnN0IHhtbENoYXIgKiBVUkkgQVRUUklCVVRFX1VOVVNFRCkKewogICAgeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0ID0gKHhtbFNjaGVtYVZhbGlkQ3R4dFB0cikgY3R4OwogICAgaW50IHJlczsKCiAgICAvKgogICAgKiBTa2lwIGVsZW1lbnRzIGlmIGluc2lkZSBhICJza2lwIiB3aWxkY2FyZCBvciBpZiBpbnZhbGlkLgogICAgKi8KICAgIGlmICh2Y3R4dC0+c2tpcERlcHRoICE9IC0xKSB7CglpZiAodmN0eHQtPmRlcHRoID4gdmN0eHQtPnNraXBEZXB0aCkgewoJICAgIHZjdHh0LT5kZXB0aC0tOwoJICAgIHJldHVybjsKCX0gZWxzZQoJICAgIHZjdHh0LT5za2lwRGVwdGggPSAtMTsKICAgIH0KICAgIC8qCiAgICAqIFNBWCBWQUwgVE9ETzogSnVzdCBhIHRlbXBvcmFyeSBjaGVjay4KICAgICovCiAgICBpZiAoKCF4bWxTdHJFcXVhbCh2Y3R4dC0+aW5vZGUtPmxvY2FsTmFtZSwgbG9jYWxuYW1lKSkgfHwKCSgheG1sU3RyRXF1YWwodmN0eHQtPmlub2RlLT5uc05hbWUsIFVSSSkpKSB7CglWRVJST1JfSU5UKCJ4bWxTY2hlbWFTQVhIYW5kbGVFbmRFbGVtZW50TnMiLAoJICAgICJlbGVtIHBvcCBtaXNtYXRjaCIpOwogICAgfQogICAgcmVzID0geG1sU2NoZW1hVmFsaWRhdG9yUG9wRWxlbSh2Y3R4dCk7CiAgICBpZiAocmVzICE9IDApIHsKCWlmIChyZXMgPCAwKSB7CgkgICAgVkVSUk9SX0lOVCgieG1sU2NoZW1hU0FYSGFuZGxlRW5kRWxlbWVudE5zIiwKCQkiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0b3JQb3BFbGVtKCkiKTsKCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJfQoJZ290byBleGl0OwogICAgfQpleGl0OgogICAgcmV0dXJuOwppbnRlcm5hbF9lcnJvcjoKICAgIHZjdHh0LT5lcnIgPSAtMTsKICAgIHhtbFN0b3BQYXJzZXIodmN0eHQtPnBhcnNlckN0eHQpOwogICAgcmV0dXJuOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQkJCQkJCSoKICogCQkJVmFsaWRhdGlvbiBpbnRlcmZhY2VzCQkJCSoKICogCQkJCQkJCQkJKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoqCiAqIHhtbFNjaGVtYU5ld1ZhbGlkQ3R4dDoKICogQHNjaGVtYTogIGEgcHJlY29tcGlsZWQgWE1MIFNjaGVtYXMKICoKICogQ3JlYXRlIGFuIFhNTCBTY2hlbWFzIHZhbGlkYXRpb24gY29udGV4dCBiYXNlZCBvbiB0aGUgZ2l2ZW4gc2NoZW1hLgogKgogKiBSZXR1cm5zIHRoZSB2YWxpZGF0aW9uIGNvbnRleHQgb3IgTlVMTCBpbiBjYXNlIG9mIGVycm9yCiAqLwp4bWxTY2hlbWFWYWxpZEN0eHRQdHIKeG1sU2NoZW1hTmV3VmFsaWRDdHh0KHhtbFNjaGVtYVB0ciBzY2hlbWEpCnsKICAgIHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciByZXQ7CgogICAgcmV0ID0gKHhtbFNjaGVtYVZhbGlkQ3R4dFB0cikgeG1sTWFsbG9jKHNpemVvZih4bWxTY2hlbWFWYWxpZEN0eHQpKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewogICAgICAgIHhtbFNjaGVtYVZFcnJNZW1vcnkoTlVMTCwgImFsbG9jYXRpbmcgdmFsaWRhdGlvbiBjb250ZXh0IiwgTlVMTCk7CiAgICAgICAgcmV0dXJuIChOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFWYWxpZEN0eHQpKTsKICAgIHJldC0+dHlwZSA9IFhNTF9TQ0hFTUFfQ1RYVF9WQUxJREFUT1I7CiAgICByZXQtPmRpY3QgPSB4bWxEaWN0Q3JlYXRlKCk7CiAgICByZXQtPm5vZGVRTmFtZXMgPSB4bWxTY2hlbWFJdGVtTGlzdENyZWF0ZSgpOwogICAgcmV0LT5zY2hlbWEgPSBzY2hlbWE7CiAgICByZXR1cm4gKHJldCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFDbGVhclZhbGlkQ3R4dDoKICogQGN0eHQ6IHRoZSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqCiAqIEZyZWUgdGhlIHJlc291cmNlcyBhc3NvY2lhdGVkIHRvIHRoZSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0OwogKiBsZWF2ZXMgc29tZSBmaWVsZHMgYWxpdmUgaW50ZW5kZWQgZm9yIHJldXNlIG9mIHRoZSBjb250ZXh0LgogKi8Kc3RhdGljIHZvaWQKeG1sU2NoZW1hQ2xlYXJWYWxpZEN0eHQoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KQp7CiAgICBpZiAodmN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CgogICAgLyoKICAgICogVE9ETzogU2hvdWxkIHdlIGNsZWFyIHRoZSBmbGFncz8KICAgICogICBNaWdodCBiZSBwcm9ibGVtYXRpYyBpZiBvbmUgcmV1c2VzIHRoZSBjb250ZXh0CiAgICAqICAgYW5kIGFzc3VtZXMgdGhhdCB0aGUgb3B0aW9ucyByZW1haW4gdGhlIHNhbWUuCiAgICAqLwogICAgdmN0eHQtPmZsYWdzID0gMDsKICAgIHZjdHh0LT52YWxpZGF0aW9uUm9vdCA9IE5VTEw7CiAgICB2Y3R4dC0+ZG9jID0gTlVMTDsKI2lmZGVmIExJQlhNTF9SRUFERVJfRU5BQkxFRAogICAgdmN0eHQtPnJlYWRlciA9IE5VTEw7CiNlbmRpZgogICAgdmN0eHQtPmhhc0tleXJlZnMgPSAwOyAgICAKCiAgICBpZiAodmN0eHQtPnZhbHVlICE9IE5VTEwpIHsKICAgICAgICB4bWxTY2hlbWFGcmVlVmFsdWUodmN0eHQtPnZhbHVlKTsKCXZjdHh0LT52YWx1ZSA9IE5VTEw7CiAgICB9CiAgICAvKgogICAgKiBBdWdtZW50ZWQgSURDIGluZm9ybWF0aW9uLgogICAgKi8KICAgIGlmICh2Y3R4dC0+YWlkY3MgIT0gTlVMTCkgewoJeG1sU2NoZW1hSURDQXVnUHRyIGN1ciA9IHZjdHh0LT5haWRjcywgbmV4dDsKCWRvIHsKCSAgICBuZXh0ID0gY3VyLT5uZXh0OwoJICAgIHhtbEZyZWUoY3VyKTsKCSAgICBjdXIgPSBuZXh0OwoJfSB3aGlsZSAoY3VyICE9IE5VTEwpOwoJdmN0eHQtPmFpZGNzID0gTlVMTDsKICAgIH0KICAgIGlmICh2Y3R4dC0+aWRjTm9kZXMgIT0gTlVMTCkgewoJaW50IGk7Cgl4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciBpdGVtOwoKCWZvciAoaSA9IDA7IGkgPCB2Y3R4dC0+bmJJZGNOb2RlczsgaSsrKSB7CgkgICAgaXRlbSA9IHZjdHh0LT5pZGNOb2Rlc1tpXTsKCSAgICB4bWxGcmVlKGl0ZW0tPmtleXMpOwoJICAgIHhtbEZyZWUoaXRlbSk7Cgl9Cgl4bWxGcmVlKHZjdHh0LT5pZGNOb2Rlcyk7Cgl2Y3R4dC0+aWRjTm9kZXMgPSBOVUxMOwogICAgfQogICAgLyoKICAgICogTm90ZSB0aGF0IHdlIHdvbid0IGRlbGV0ZSB0aGUgWFBhdGggc3RhdGUgcG9vbCBoZXJlLgogICAgKi8KICAgIGlmICh2Y3R4dC0+eHBhdGhTdGF0ZXMgIT0gTlVMTCkgewoJeG1sU2NoZW1hRnJlZUlEQ1N0YXRlT2JqTGlzdCh2Y3R4dC0+eHBhdGhTdGF0ZXMpOwoJdmN0eHQtPnhwYXRoU3RhdGVzID0gTlVMTDsKICAgIH0KICAgIC8qCiAgICAqIEF0dHJpYnV0ZSBpbmZvLgogICAgKi8KICAgIGlmICh2Y3R4dC0+bmJBdHRySW5mb3MgIT0gMCkgewoJeG1sU2NoZW1hQ2xlYXJBdHRySW5mb3ModmN0eHQpOwogICAgfQogICAgLyoKICAgICogRWxlbWVudCBpbmZvLgogICAgKi8KICAgIGlmICh2Y3R4dC0+ZWxlbUluZm9zICE9IE5VTEwpIHsKCWludCBpOwoJeG1sU2NoZW1hTm9kZUluZm9QdHIgZWk7CgoJZm9yIChpID0gMDsgaSA8IHZjdHh0LT5zaXplRWxlbUluZm9zOyBpKyspIHsKCSAgICBlaSA9IHZjdHh0LT5lbGVtSW5mb3NbaV07CgkgICAgaWYgKGVpID09IE5VTEwpCgkJYnJlYWs7CgkgICAgeG1sU2NoZW1hQ2xlYXJFbGVtSW5mbyhlaSk7Cgl9CiAgICB9ICAgIAogICAgeG1sU2NoZW1hSXRlbUxpc3RDbGVhcih2Y3R4dC0+bm9kZVFOYW1lcyk7CiAgICAvKiBSZWNyZWF0ZSB0aGUgZGljdC4gKi8KICAgIHhtbERpY3RGcmVlKHZjdHh0LT5kaWN0KTsKICAgIC8qCiAgICAqIFRPRE86IElzIGlzIHNhdmUgdG8gcmVjcmVhdGUgaXQ/IERvIHdlIGhhdmUgYSBzY2VuYXJpbwogICAgKiB3aGVyZSB0aGUgdXNlciBwcm92aWRlcyB0aGUgZGljdD8KICAgICovCiAgICB2Y3R4dC0+ZGljdCA9IHhtbERpY3RDcmVhdGUoKTsKfQoKLyoqCiAqIHhtbFNjaGVtYUZyZWVWYWxpZEN0eHQ6CiAqIEBjdHh0OiAgdGhlIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICoKICogRnJlZSB0aGUgcmVzb3VyY2VzIGFzc29jaWF0ZWQgdG8gdGhlIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICovCnZvaWQKeG1sU2NoZW1hRnJlZVZhbGlkQ3R4dCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgY3R4dCkKewogICAgaWYgKGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoY3R4dC0+dmFsdWUgIT0gTlVMTCkKICAgICAgICB4bWxTY2hlbWFGcmVlVmFsdWUoY3R4dC0+dmFsdWUpOwogICAgaWYgKGN0eHQtPnBjdHh0ICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlUGFyc2VyQ3R4dChjdHh0LT5wY3R4dCk7CiAgICBpZiAoY3R4dC0+aWRjTm9kZXMgIT0gTlVMTCkgewoJaW50IGk7Cgl4bWxTY2hlbWFQU1ZJSURDTm9kZVB0ciBpdGVtOwoKCWZvciAoaSA9IDA7IGkgPCBjdHh0LT5uYklkY05vZGVzOyBpKyspIHsKCSAgICBpdGVtID0gY3R4dC0+aWRjTm9kZXNbaV07CgkgICAgeG1sRnJlZShpdGVtLT5rZXlzKTsKCSAgICB4bWxGcmVlKGl0ZW0pOwoJfQoJeG1sRnJlZShjdHh0LT5pZGNOb2Rlcyk7CiAgICB9CiAgICBpZiAoY3R4dC0+aWRjS2V5cyAhPSBOVUxMKSB7CglpbnQgaTsKCWZvciAoaSA9IDA7IGkgPCBjdHh0LT5uYklkY0tleXM7IGkrKykKCSAgICB4bWxTY2hlbWFJRENGcmVlS2V5KGN0eHQtPmlkY0tleXNbaV0pOwoJeG1sRnJlZShjdHh0LT5pZGNLZXlzKTsKICAgIH0KCiAgICBpZiAoY3R4dC0+eHBhdGhTdGF0ZXMgIT0gTlVMTCkKCXhtbFNjaGVtYUZyZWVJRENTdGF0ZU9iakxpc3QoY3R4dC0+eHBhdGhTdGF0ZXMpOwogICAgaWYgKGN0eHQtPnhwYXRoU3RhdGVQb29sICE9IE5VTEwpCgl4bWxTY2hlbWFGcmVlSURDU3RhdGVPYmpMaXN0KGN0eHQtPnhwYXRoU3RhdGVQb29sKTsKCiAgICAvKgogICAgKiBBdWdtZW50ZWQgSURDIGluZm9ybWF0aW9uLgogICAgKi8KICAgIGlmIChjdHh0LT5haWRjcyAhPSBOVUxMKSB7Cgl4bWxTY2hlbWFJRENBdWdQdHIgY3VyID0gY3R4dC0+YWlkY3MsIG5leHQ7CglkbyB7CgkgICAgbmV4dCA9IGN1ci0+bmV4dDsKCSAgICB4bWxGcmVlKGN1cik7CgkgICAgY3VyID0gbmV4dDsKCX0gd2hpbGUgKGN1ciAhPSBOVUxMKTsKICAgIH0KICAgIGlmIChjdHh0LT5hdHRySW5mb3MgIT0gTlVMTCkgewoJaW50IGk7Cgl4bWxTY2hlbWFBdHRySW5mb1B0ciBhdHRyOwoKCS8qIEp1c3QgYSBwYXJhbm9pZCBjYWxsIHRvIHRoZSBjbGVhbnVwLiAqLwoJaWYgKGN0eHQtPm5iQXR0ckluZm9zICE9IDApCgkgICAgeG1sU2NoZW1hQ2xlYXJBdHRySW5mb3MoY3R4dCk7Cglmb3IgKGkgPSAwOyBpIDwgY3R4dC0+c2l6ZUF0dHJJbmZvczsgaSsrKSB7CgkgICAgYXR0ciA9IGN0eHQtPmF0dHJJbmZvc1tpXTsKCSAgICB4bWxGcmVlKGF0dHIpOwoJfQoJeG1sRnJlZShjdHh0LT5hdHRySW5mb3MpOwogICAgfQogICAgaWYgKGN0eHQtPmVsZW1JbmZvcyAhPSBOVUxMKSB7CglpbnQgaTsKCXhtbFNjaGVtYU5vZGVJbmZvUHRyIGVpOwoKCWZvciAoaSA9IDA7IGkgPCBjdHh0LT5zaXplRWxlbUluZm9zOyBpKyspIHsKCSAgICBlaSA9IGN0eHQtPmVsZW1JbmZvc1tpXTsKCSAgICBpZiAoZWkgPT0gTlVMTCkKCQlicmVhazsKCSAgICB4bWxTY2hlbWFDbGVhckVsZW1JbmZvKGVpKTsKCSAgICB4bWxGcmVlKGVpKTsKCX0KCXhtbEZyZWUoY3R4dC0+ZWxlbUluZm9zKTsKICAgIH0KICAgIGlmIChjdHh0LT5ub2RlUU5hbWVzICE9IE5VTEwpCgl4bWxTY2hlbWFJdGVtTGlzdEZyZWUoY3R4dC0+bm9kZVFOYW1lcyk7CiAgICBpZiAoY3R4dC0+ZGljdCAhPSBOVUxMKQoJeG1sRGljdEZyZWUoY3R4dC0+ZGljdCk7CiAgICB4bWxGcmVlKGN0eHQpOwp9CgovKioKICogeG1sU2NoZW1hSXNWYWxpZDoKICogQGN0eHQ6IHRoZSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqCiAqIENoZWNrIGlmIGFueSBlcnJvciB3YXMgZGV0ZWN0ZWQgZHVyaW5nIHZhbGlkYXRpb24uCiAqIAogKiBSZXR1cm5zIDEgaWYgdmFsaWQgc28gZmFyLCAwIGlmIGVycm9ycyB3ZXJlIGRldGVjdGVkLCBhbmQgLTEgaW4gY2FzZQogKiAgICAgICAgIG9mIGludGVybmFsIGVycm9yLgogKi8KaW50CnhtbFNjaGVtYUlzVmFsaWQoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIGN0eHQpCnsKICAgIGlmIChjdHh0ID09IE5VTEwpCiAgICAgICAgcmV0dXJuKC0xKTsKICAgIHJldHVybihjdHh0LT5lcnIgPT0gMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFTZXRWYWxpZEVycm9yczoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQGVycjogIHRoZSBlcnJvciBmdW5jdGlvbgogKiBAd2FybjogdGhlIHdhcm5pbmcgZnVuY3Rpb24KICogQGN0eDogdGhlIGZ1bmN0aW9ucyBjb250ZXh0CiAqCiAqIFNldCB0aGUgZXJyb3IgYW5kIHdhcm5pbmcgY2FsbGJhY2sgaW5mb3JtYXRpb25zCiAqLwp2b2lkCnhtbFNjaGVtYVNldFZhbGlkRXJyb3JzKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgICB4bWxTY2hlbWFWYWxpZGl0eUVycm9yRnVuYyBlcnIsCiAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNjaGVtYVZhbGlkaXR5V2FybmluZ0Z1bmMgd2Fybiwgdm9pZCAqY3R4KQp7CiAgICBpZiAoY3R4dCA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIGN0eHQtPmVycm9yID0gZXJyOwogICAgY3R4dC0+d2FybmluZyA9IHdhcm47CiAgICBjdHh0LT5lcnJDdHh0ID0gY3R4OwogICAgaWYgKGN0eHQtPnBjdHh0ICE9IE5VTEwpCgl4bWxTY2hlbWFTZXRQYXJzZXJFcnJvcnMoY3R4dC0+cGN0eHQsIGVyciwgd2FybiwgY3R4KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVNldFZhbGlkU3RydWN0dXJlZEVycm9yczoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNlcnJvcjogIHRoZSBzdHJ1Y3R1cmVkIGVycm9yIGZ1bmN0aW9uCiAqIEBjdHg6IHRoZSBmdW5jdGlvbnMgY29udGV4dAogKgogKiBTZXQgdGhlIHN0cnVjdHVyZWQgZXJyb3IgY2FsbGJhY2sKICovCnZvaWQKeG1sU2NoZW1hU2V0VmFsaWRTdHJ1Y3R1cmVkRXJyb3JzKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0LAoJCQkJICB4bWxTdHJ1Y3R1cmVkRXJyb3JGdW5jIHNlcnJvciwgdm9pZCAqY3R4KQp7CiAgICBpZiAoY3R4dCA9PSBOVUxMKQogICAgICAgIHJldHVybjsKCWN0eHQtPnNlcnJvciA9IHNlcnJvcjsKICAgIGN0eHQtPmVycm9yID0gTlVMTDsKICAgIGN0eHQtPndhcm5pbmcgPSBOVUxMOwogICAgY3R4dC0+ZXJyQ3R4dCA9IGN0eDsKICAgIGlmIChjdHh0LT5wY3R4dCAhPSBOVUxMKQoJeG1sU2NoZW1hU2V0UGFyc2VyU3RydWN0dXJlZEVycm9ycyhjdHh0LT5wY3R4dCwgc2Vycm9yLCBjdHgpOwp9CgovKioKICogeG1sU2NoZW1hR2V0VmFsaWRFcnJvcnM6CiAqIEBjdHh0OglhIFhNTC1TY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBlcnI6IHRoZSBlcnJvciBmdW5jdGlvbiByZXN1bHQKICogQHdhcm46IHRoZSB3YXJuaW5nIGZ1bmN0aW9uIHJlc3VsdAogKiBAY3R4OiB0aGUgZnVuY3Rpb25zIGNvbnRleHQgcmVzdWx0CiAqCiAqIEdldCB0aGUgZXJyb3IgYW5kIHdhcm5pbmcgY2FsbGJhY2sgaW5mb3JtYXRpb25zCiAqCiAqIFJldHVybnMgLTEgaW4gY2FzZSBvZiBlcnJvciBhbmQgMCBvdGhlcndpc2UKICovCmludAp4bWxTY2hlbWFHZXRWYWxpZEVycm9ycyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgY3R4dCwKCQkJeG1sU2NoZW1hVmFsaWRpdHlFcnJvckZ1bmMgKiBlcnIsCgkJCXhtbFNjaGVtYVZhbGlkaXR5V2FybmluZ0Z1bmMgKiB3YXJuLCB2b2lkICoqY3R4KQp7CglpZiAoY3R4dCA9PSBOVUxMKQoJCXJldHVybiAoLTEpOwoJaWYgKGVyciAhPSBOVUxMKQoJCSplcnIgPSBjdHh0LT5lcnJvcjsKCWlmICh3YXJuICE9IE5VTEwpCgkJKndhcm4gPSBjdHh0LT53YXJuaW5nOwoJaWYgKGN0eCAhPSBOVUxMKQoJCSpjdHggPSBjdHh0LT5lcnJDdHh0OwoJcmV0dXJuICgwKTsKfQoKCi8qKgogKiB4bWxTY2hlbWFTZXRWYWxpZE9wdGlvbnM6CiAqIEBjdHh0OglhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQG9wdGlvbnM6IGEgY29tYmluYXRpb24gb2YgeG1sU2NoZW1hVmFsaWRPcHRpb24KICoKICogU2V0cyB0aGUgb3B0aW9ucyB0byBiZSB1c2VkIGR1cmluZyB0aGUgdmFsaWRhdGlvbi4KICoKICogUmV0dXJucyAwIGluIGNhc2Ugb2Ygc3VjY2VzcywgLTEgaW4gY2FzZSBvZiBhbgogKiBBUEkgZXJyb3IuCiAqLwppbnQKeG1sU2NoZW1hU2V0VmFsaWRPcHRpb25zKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0LAoJCQkgaW50IG9wdGlvbnMpCgp7CiAgICBpbnQgaTsKCiAgICBpZiAoY3R4dCA9PSBOVUxMKQoJcmV0dXJuICgtMSk7CiAgICAvKgogICAgKiBXQVJOSU5HOiBDaGFuZ2UgdGhlIHN0YXJ0IHZhbHVlIGlmIGFkZGluZyB0byB0aGUKICAgICogeG1sU2NoZW1hVmFsaWRPcHRpb24uCiAgICAqIFRPRE86IElzIHRoZXJlIGFuIG90aGVyLCBtb3JlIGVhc3kgdG8gbWFpbnRhaW4sCiAgICAqIHdheT8KICAgICovCiAgICBmb3IgKGkgPSAxOyBpIDwgKGludCkgc2l6ZW9mKGludCkgKiA4OyBpKyspIHsKICAgICAgICBpZiAob3B0aW9ucyAmIDE8PGkpCgkgICAgcmV0dXJuICgtMSk7CiAgICB9CiAgICBjdHh0LT5vcHRpb25zID0gb3B0aW9uczsKICAgIHJldHVybiAoMCk7Cn0KCi8qKgogKiB4bWxTY2hlbWFWYWxpZEN0eHRHZXRPcHRpb25zOgogKiBAY3R4dDoJYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqCiAqIEdldCB0aGUgdmFsaWRhdGlvbiBjb250ZXh0IG9wdGlvbnMuCiAqCiAqIFJldHVybnMgdGhlIG9wdGlvbiBjb21iaW5hdGlvbiBvciAtMSBvbiBlcnJvci4KICovCmludAp4bWxTY2hlbWFWYWxpZEN0eHRHZXRPcHRpb25zKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0KQoKewogICAgaWYgKGN0eHQgPT0gTlVMTCkKCXJldHVybiAoLTEpOwogICAgZWxzZQoJcmV0dXJuIChjdHh0LT5vcHRpb25zKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFWRG9jV2Fsayh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpCnsKICAgIHhtbEF0dHJQdHIgYXR0cjsKICAgIGludCByZXQgPSAwOwogICAgeG1sU2NoZW1hTm9kZUluZm9QdHIgaWVsZW0gPSBOVUxMOwogICAgeG1sTm9kZVB0ciBub2RlLCB2YWxSb290OwogICAgY29uc3QgeG1sQ2hhciAqbnNOYW1lOwoKICAgIC8qIERPQyBWQUwgVE9ETzogTW92ZSB0aGlzIHRvIHRoZSBzdGFydCBmdW5jdGlvbi4gKi8KICAgIHZhbFJvb3QgPSB4bWxEb2NHZXRSb290RWxlbWVudCh2Y3R4dC0+ZG9jKTsKICAgIGlmICh2YWxSb290ID09IE5VTEwpIHsKCS8qIFZBTCBUT0RPOiBFcnJvciBjb2RlPyAqLwoJVkVSUk9SKDEsIE5VTEwsICJUaGUgZG9jdW1lbnQgaGFzIG5vIGRvY3VtZW50IGVsZW1lbnQiKTsKCXJldHVybiAoMSk7CiAgICB9CiAgICB2Y3R4dC0+ZGVwdGggPSAtMTsKICAgIHZjdHh0LT52YWxpZGF0aW9uUm9vdCA9IHZhbFJvb3Q7CiAgICBub2RlID0gdmFsUm9vdDsKICAgIHdoaWxlIChub2RlICE9IE5VTEwpIHsKCWlmICgodmN0eHQtPnNraXBEZXB0aCAhPSAtMSkgJiYgKHZjdHh0LT5kZXB0aCA+PSB2Y3R4dC0+c2tpcERlcHRoKSkKCSAgICBnb3RvIG5leHRfc2libGluZzsKCWlmIChub2RlLT50eXBlID09IFhNTF9FTEVNRU5UX05PREUpIHsKCgkgICAgLyoKCSAgICAqIEluaXQgdGhlIG5vZGUtaW5mby4KCSAgICAqLwoJICAgIHZjdHh0LT5kZXB0aCsrOwoJICAgIGlmICh4bWxTY2hlbWFWYWxpZGF0b3JQdXNoRWxlbSh2Y3R4dCkgPT0gLTEpCgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICBpZWxlbSA9IHZjdHh0LT5pbm9kZTsKCSAgICBpZWxlbS0+bm9kZSA9IG5vZGU7CgkgICAgaWVsZW0tPm5vZGVMaW5lID0gbm9kZS0+bGluZTsKCSAgICBpZWxlbS0+bG9jYWxOYW1lID0gbm9kZS0+bmFtZTsKCSAgICBpZiAobm9kZS0+bnMgIT0gTlVMTCkKCQlpZWxlbS0+bnNOYW1lID0gbm9kZS0+bnMtPmhyZWY7CgkgICAgaWVsZW0tPmZsYWdzIHw9IFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZOwoJICAgIC8qCgkgICAgKiBSZWdpc3RlciBhdHRyaWJ1dGVzLgoJICAgICogRE9DIFZBTCBUT0RPOiBXZSBkbyBub3QgcmVnaXN0ZXIgbmFtZXNwYWNlIGRlY2xhcmF0aW9uCgkgICAgKiBhdHRyaWJ1dGVzIHlldC4KCSAgICAqLwoJICAgIHZjdHh0LT5uYkF0dHJJbmZvcyA9IDA7CgkgICAgaWYgKG5vZGUtPnByb3BlcnRpZXMgIT0gTlVMTCkgewoJCWF0dHIgPSBub2RlLT5wcm9wZXJ0aWVzOwoJCWRvIHsKCQkgICAgaWYgKGF0dHItPm5zICE9IE5VTEwpCgkJCW5zTmFtZSA9IGF0dHItPm5zLT5ocmVmOwoJCSAgICBlbHNlCgkJCW5zTmFtZSA9IE5VTEw7CgkJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRvclB1c2hBdHRyaWJ1dGUodmN0eHQsCgkJCSh4bWxOb2RlUHRyKSBhdHRyLAoJCQkvKiAKCQkJKiBOb3RlIHRoYXQgd2UgZ2l2ZSBpdCB0aGUgbGluZSBudW1iZXIgb2YgdGhlCgkJCSogcGFyZW50IGVsZW1lbnQuCgkJCSovCgkJCWllbGVtLT5ub2RlTGluZSwKCQkJYXR0ci0+bmFtZSwgbnNOYW1lLCAwLAoJCQl4bWxOb2RlTGlzdEdldFN0cmluZyhhdHRyLT5kb2MsIGF0dHItPmNoaWxkcmVuLCAxKSwgMSk7CgkJICAgIGlmIChyZXQgPT0gLTEpIHsKCQkJVkVSUk9SX0lOVCgieG1sU2NoZW1hRG9jV2FsayIsCgkJCSAgICAiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0b3JQdXNoQXR0cmlidXRlKCkiKTsKCQkJZ290byBpbnRlcm5hbF9lcnJvcjsKCQkgICAgfQoJCSAgICBhdHRyID0gYXR0ci0+bmV4dDsKCQl9IHdoaWxlIChhdHRyKTsKCSAgICB9CgkgICAgLyoKCSAgICAqIFZhbGlkYXRlIHRoZSBlbGVtZW50LgoJICAgICovCgkgICAgcmV0ID0geG1sU2NoZW1hVmFsaWRhdGVFbGVtKHZjdHh0KTsKCSAgICBpZiAocmV0ICE9IDApIHsKCQlpZiAocmV0ID09IC0xKSB7CgkJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYURvY1dhbGsiLAoJCQkiY2FsbGluZyB4bWxTY2hlbWFWYWxpZGF0ZUVsZW0oKSIpOwoJCSAgICBnb3RvIGludGVybmFsX2Vycm9yOwoJCX0KCQkvKgoJCSogRG9uJ3Qgc3RvcCB2YWxpZGF0aW9uOyBqdXN0IHNraXAgdGhlIGNvbnRlbnQKCQkqIG9mIHRoaXMgZWxlbWVudC4KCQkqLwoJCWdvdG8gbGVhdmVfbm9kZTsKCSAgICB9CgkgICAgaWYgKCh2Y3R4dC0+c2tpcERlcHRoICE9IC0xKSAmJgoJCSh2Y3R4dC0+ZGVwdGggPj0gdmN0eHQtPnNraXBEZXB0aCkpCgkJZ290byBsZWF2ZV9ub2RlOwoJfSBlbHNlIGlmICgobm9kZS0+dHlwZSA9PSBYTUxfVEVYVF9OT0RFKSB8fAoJICAgIChub2RlLT50eXBlID09IFhNTF9DREFUQV9TRUNUSU9OX05PREUpKSB7CgkgICAgLyoKCSAgICAqIFByb2Nlc3MgY2hhcmFjdGVyIGNvbnRlbnQuCgkgICAgKi8KCSAgICBpZiAoaWVsZW0tPmZsYWdzICYgWE1MX1NDSEVNQV9FTEVNX0lORk9fRU1QVFkpCgkJaWVsZW0tPmZsYWdzIF49IFhNTF9TQ0hFTUFfRUxFTV9JTkZPX0VNUFRZOwoJICAgIHJldCA9IHhtbFNjaGVtYVZQdXNoVGV4dCh2Y3R4dCwgbm9kZS0+dHlwZSwgbm9kZS0+Y29udGVudCwKCQktMSwgWE1MX1NDSEVNQV9QVVNIX1RFWFRfUEVSU0lTVCwgTlVMTCk7CgkgICAgaWYgKHJldCA8IDApIHsKCQlWRVJST1JfSU5UKCJ4bWxTY2hlbWFWRG9jV2FsayIsCgkJICAgICJjYWxsaW5nIHhtbFNjaGVtYVZQdXNoVGV4dCgpIik7CgkJZ290byBpbnRlcm5hbF9lcnJvcjsKCSAgICB9CgkgICAgLyoKCSAgICAqIERPQyBWQUwgVE9ETzogU2hvdWxkIHdlIHNraXAgZnVydGhlciB2YWxpZGF0aW9uIG9mIHRoZQoJICAgICogZWxlbWVudCBjb250ZW50IGhlcmU/CgkgICAgKi8KCX0gZWxzZSBpZiAoKG5vZGUtPnR5cGUgPT0gWE1MX0VOVElUWV9OT0RFKSB8fAoJICAgIChub2RlLT50eXBlID09IFhNTF9FTlRJVFlfUkVGX05PREUpKSB7CgkgICAgLyoKCSAgICAqIERPQyBWQUwgVE9ETzogV2hhdCB0byBkbyB3aXRoIGVudGl0aWVzPwoJICAgICovCgkgICAgVE9ETwoJfSBlbHNlIHsKCSAgICBnb3RvIGxlYXZlX25vZGU7CgkgICAgLyoKCSAgICAqIERPQyBWQUwgVE9ETzogWEluY2x1ZGUgbm9kZXMsIGV0Yy4KCSAgICAqLwoJfQoJLyoKCSogV2FsayB0aGUgZG9jLgoJKi8KCWlmIChub2RlLT5jaGlsZHJlbiAhPSBOVUxMKSB7CgkgICAgbm9kZSA9IG5vZGUtPmNoaWxkcmVuOwoJICAgIGNvbnRpbnVlOwoJfQpsZWF2ZV9ub2RlOgoJaWYgKG5vZGUtPnR5cGUgPT0gWE1MX0VMRU1FTlRfTk9ERSkgewoJICAgIC8qCgkgICAgKiBMZWF2aW5nIHRoZSBzY29wZSBvZiBhbiBlbGVtZW50LgoJICAgICovCgkgICAgaWYgKG5vZGUgIT0gdmN0eHQtPmlub2RlLT5ub2RlKSB7CgkJVkVSUk9SX0lOVCgieG1sU2NoZW1hVkRvY1dhbGsiLAoJCSAgICAiZWxlbWVudCBwb3NpdGlvbiBtaXNtYXRjaCIpOwoJCWdvdG8gaW50ZXJuYWxfZXJyb3I7CgkgICAgfQoJICAgIHJldCA9IHhtbFNjaGVtYVZhbGlkYXRvclBvcEVsZW0odmN0eHQpOwoJICAgIGlmIChyZXQgIT0gMCkgewoJCWlmIChyZXQgPCAwKSB7CgkJICAgIFZFUlJPUl9JTlQoInhtbFNjaGVtYVZEb2NXYWxrIiwKCQkJImNhbGxpbmcgeG1sU2NoZW1hVmFsaWRhdG9yUG9wRWxlbSgpIik7CgkJICAgIGdvdG8gaW50ZXJuYWxfZXJyb3I7CgkJfQoJICAgIH0KCSAgICBpZiAobm9kZSA9PSB2YWxSb290KQoJCWdvdG8gZXhpdDsKCX0KbmV4dF9zaWJsaW5nOgoJaWYgKG5vZGUtPm5leHQgIT0gTlVMTCkKCSAgICBub2RlID0gbm9kZS0+bmV4dDsKCWVsc2UgewoJICAgIG5vZGUgPSBub2RlLT5wYXJlbnQ7CgkgICAgZ290byBsZWF2ZV9ub2RlOwoJfQogICAgfQoKZXhpdDoKICAgIHJldHVybiAocmV0KTsKaW50ZXJuYWxfZXJyb3I6CiAgICByZXR1cm4gKC0xKTsKfQoKc3RhdGljIGludAp4bWxTY2hlbWFQcmVSdW4oeG1sU2NoZW1hVmFsaWRDdHh0UHRyIHZjdHh0KSB7CiAgICAvKgogICAgKiBTb21lIGluaXRpYWxpemF0aW9uLgogICAgKi8gICAgCiAgICB2Y3R4dC0+ZXJyID0gMDsKICAgIHZjdHh0LT5uYmVycm9ycyA9IDA7CiAgICB2Y3R4dC0+ZGVwdGggPSAtMTsKICAgIHZjdHh0LT5za2lwRGVwdGggPSAtMTsKICAgIHZjdHh0LT54c2lBc3NlbWJsZSA9IDA7CiAgICB2Y3R4dC0+aGFzS2V5cmVmcyA9IDA7CiNpZmRlZiBFTkFCTEVfSURDX05PREVfVEFCTEVTX1RFU1QKICAgIHZjdHh0LT5jcmVhdGVJRENOb2RlVGFibGVzID0gMTsKI2Vsc2UKICAgIHZjdHh0LT5jcmVhdGVJRENOb2RlVGFibGVzID0gMDsKI2VuZGlmCiAgICAvKgogICAgKiBDcmVhdGUgYSBzY2hlbWEgKyBwYXJzZXIgaWYgbmVjZXNzYXJ5LgogICAgKi8KICAgIGlmICh2Y3R4dC0+c2NoZW1hID09IE5VTEwpIHsKCXhtbFNjaGVtYVBhcnNlckN0eHRQdHIgcGN0eHQ7CgkKCXZjdHh0LT54c2lBc3NlbWJsZSA9IDE7CgkvKiAKCSogSWYgbm90IHNjaGVtYSB3YXMgZ2l2ZW4gdGhlbiB3ZSB3aWxsIGNyZWF0ZSBhIHNjaGVtYQoJKiBkeW5hbWljYWxseSB1c2luZyBYU0kgc2NoZW1hIGxvY2F0aW9ucy4KCSoKCSogQ3JlYXRlIHRoZSBzY2hlbWEgcGFyc2VyIGNvbnRleHQuCgkqLwoJaWYgKCh2Y3R4dC0+cGN0eHQgPT0gTlVMTCkgJiYKCSAgICh4bWxTY2hlbWFDcmVhdGVQQ3R4dE9uVkN0eHQodmN0eHQpID09IC0xKSkKCSAgIHJldHVybiAoLTEpOwoJcGN0eHQgPSB2Y3R4dC0+cGN0eHQ7CglwY3R4dC0+eHNpQXNzZW1ibGUgPSAxOwoJLyoKCSogQ3JlYXRlIHRoZSBzY2hlbWEuCgkqLwoJdmN0eHQtPnNjaGVtYSA9IHhtbFNjaGVtYU5ld1NjaGVtYShwY3R4dCk7CglpZiAodmN0eHQtPnNjaGVtYSA9PSBOVUxMKQoJICAgIHJldHVybiAoLTEpOwkJCgkvKiAKCSogQ3JlYXRlIHRoZSBzY2hlbWEgY29uc3RydWN0aW9uIGNvbnRleHQuCgkqLwoJcGN0eHQtPmNvbnN0cnVjdG9yID0geG1sU2NoZW1hQ29uc3RydWN0aW9uQ3R4dENyZWF0ZShwY3R4dC0+ZGljdCk7CglpZiAocGN0eHQtPmNvbnN0cnVjdG9yID09IE5VTEwpCgkgICAgcmV0dXJuKC0xKTsKCXBjdHh0LT5jb25zdHJ1Y3Rvci0+bWFpblNjaGVtYSA9IHZjdHh0LT5zY2hlbWE7CgkvKgoJKiBUYWtlIG93bmVyc2hpcCBvZiB0aGUgY29uc3RydWN0b3IgdG8gYmUgYWJsZSB0byBmcmVlIGl0LgoJKi8KCXBjdHh0LT5vd25zQ29uc3RydWN0b3IgPSAxOwogICAgfQkKICAgIC8qCiAgICAqIEF1Z21lbnQgdGhlIElEQyBkZWZpbml0aW9ucy4KICAgICovCiAgICBpZiAodmN0eHQtPnNjaGVtYS0+aWRjRGVmICE9IE5VTEwpIHsKCXhtbEhhc2hTY2FuKHZjdHh0LT5zY2hlbWEtPmlkY0RlZiwKCSAgICAoeG1sSGFzaFNjYW5uZXIpIHhtbFNjaGVtYUF1Z21lbnRJREMsIHZjdHh0KTsKICAgIH0KICAgIHJldHVybigwKTsKfQoKc3RhdGljIHZvaWQKeG1sU2NoZW1hUG9zdFJ1bih4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpIHsKICAgIGlmICh2Y3R4dC0+eHNpQXNzZW1ibGUpIHsKCWlmICh2Y3R4dC0+c2NoZW1hICE9IE5VTEwpIHsKCSAgICB4bWxTY2hlbWFGcmVlKHZjdHh0LT5zY2hlbWEpOwoJICAgIHZjdHh0LT5zY2hlbWEgPSBOVUxMOwoJfQogICAgfQogICAgeG1sU2NoZW1hQ2xlYXJWYWxpZEN0eHQodmN0eHQpOwp9CgpzdGF0aWMgaW50CnhtbFNjaGVtYVZTdGFydCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgdmN0eHQpCnsKICAgIGludCByZXQgPSAwOwoKICAgIGlmICh4bWxTY2hlbWFQcmVSdW4odmN0eHQpIDwgMCkKICAgICAgICByZXR1cm4oLTEpOwoKICAgIGlmICh2Y3R4dC0+ZG9jICE9IE5VTEwpIHsKCS8qCgkgKiBUcmVlIHZhbGlkYXRpb24uCgkgKi8KCXJldCA9IHhtbFNjaGVtYVZEb2NXYWxrKHZjdHh0KTsKI2lmZGVmIExJQlhNTF9SRUFERVJfRU5BQkxFRAogICAgfSBlbHNlIGlmICh2Y3R4dC0+cmVhZGVyICE9IE5VTEwpIHsKCS8qCgkgKiBYTUwgUmVhZGVyIHZhbGlkYXRpb24uCgkgKi8KI2lmZGVmIFhNTF9TQ0hFTUFfUkVBREVSX0VOQUJMRUQKCXJldCA9IHhtbFNjaGVtYVZSZWFkZXJXYWxrKHZjdHh0KTsKI2VuZGlmCiNlbmRpZgogICAgfSBlbHNlIGlmICgodmN0eHQtPnNheCAhPSBOVUxMKSAmJiAodmN0eHQtPnBhcnNlckN0eHQgIT0gTlVMTCkpIHsKCS8qCgkgKiBTQVggdmFsaWRhdGlvbi4KCSAqLwoJcmV0ID0geG1sUGFyc2VEb2N1bWVudCh2Y3R4dC0+cGFyc2VyQ3R4dCk7CiAgICB9IGVsc2UgewoJVkVSUk9SX0lOVCgieG1sU2NoZW1hVlN0YXJ0IiwKCSAgICAibm8gaW5zdGFuY2UgdG8gdmFsaWRhdGUiKTsKCXJldCA9IC0xOwogICAgfQoKICAgIHhtbFNjaGVtYVBvc3RSdW4odmN0eHQpOwogICAgaWYgKHJldCA9PSAwKQoJcmV0ID0gdmN0eHQtPmVycjsKICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVZhbGlkYXRlT25lRWxlbWVudDoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQGVsZW06ICBhbiBlbGVtZW50IG5vZGUKICoKICogVmFsaWRhdGUgYSBicmFuY2ggb2YgYSB0cmVlLCBzdGFydGluZyB3aXRoIHRoZSBnaXZlbiBAZWxlbS4KICoKICogUmV0dXJucyAwIGlmIHRoZSBlbGVtZW50IGFuZCBpdHMgc3VidHJlZSBpcyB2YWxpZCwgYSBwb3NpdGl2ZSBlcnJvcgogKiBjb2RlIG51bWJlciBvdGhlcndpc2UgYW5kIC0xIGluIGNhc2Ugb2YgYW4gaW50ZXJuYWwgb3IgQVBJIGVycm9yLgogKi8KaW50CnhtbFNjaGVtYVZhbGlkYXRlT25lRWxlbWVudCh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgY3R4dCwgeG1sTm9kZVB0ciBlbGVtKQp7CiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKGVsZW0gPT0gTlVMTCkgfHwgKGVsZW0tPnR5cGUgIT0gWE1MX0VMRU1FTlRfTk9ERSkpCglyZXR1cm4gKC0xKTsKCiAgICBpZiAoY3R4dC0+c2NoZW1hID09IE5VTEwpCglyZXR1cm4gKC0xKTsKCiAgICBjdHh0LT5kb2MgPSBlbGVtLT5kb2M7CiAgICBjdHh0LT5ub2RlID0gZWxlbTsKICAgIGN0eHQtPnZhbGlkYXRpb25Sb290ID0gZWxlbTsKICAgIHJldHVybih4bWxTY2hlbWFWU3RhcnQoY3R4dCkpOwp9CgovKioKICogeG1sU2NoZW1hVmFsaWRhdGVEb2M6CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBkb2M6ICBhIHBhcnNlZCBkb2N1bWVudCB0cmVlCiAqCiAqIFZhbGlkYXRlIGEgZG9jdW1lbnQgdHJlZSBpbiBtZW1vcnkuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgZG9jdW1lbnQgaXMgc2NoZW1hcyB2YWxpZCwgYSBwb3NpdGl2ZSBlcnJvciBjb2RlCiAqICAgICBudW1iZXIgb3RoZXJ3aXNlIGFuZCAtMSBpbiBjYXNlIG9mIGludGVybmFsIG9yIEFQSSBlcnJvci4KICovCmludAp4bWxTY2hlbWFWYWxpZGF0ZURvYyh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgY3R4dCwgeG1sRG9jUHRyIGRvYykKewogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChkb2MgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuICgtMSk7CgogICAgY3R4dC0+ZG9jID0gZG9jOwogICAgY3R4dC0+bm9kZSA9IHhtbERvY0dldFJvb3RFbGVtZW50KGRvYyk7CiAgICBpZiAoY3R4dC0+bm9kZSA9PSBOVUxMKSB7CiAgICAgICAgeG1sU2NoZW1hQ3VzdG9tRXJyKEFDVFhUX0NBU1QgY3R4dCwKCSAgICBYTUxfU0NIRU1BVl9ET0NVTUVOVF9FTEVNRU5UX01JU1NJTkcsCgkgICAgKHhtbE5vZGVQdHIpIGRvYywgTlVMTCwKCSAgICAiVGhlIGRvY3VtZW50IGhhcyBubyBkb2N1bWVudCBlbGVtZW50IiwgTlVMTCwgTlVMTCk7CiAgICAgICAgcmV0dXJuIChjdHh0LT5lcnIpOwogICAgfQogICAgY3R4dC0+dmFsaWRhdGlvblJvb3QgPSBjdHh0LT5ub2RlOwogICAgcmV0dXJuICh4bWxTY2hlbWFWU3RhcnQoY3R4dCkpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJCQkJCQkqCiAqIAkJRnVuY3Rpb24gYW5kIGRhdGEgZm9yIFNBWCBzdHJlYW1pbmcgQVBJCQkJKgogKiAJCQkJCQkJCQkqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCnR5cGVkZWYgc3RydWN0IF94bWxTY2hlbWFTcGxpdFNBWERhdGEgeG1sU2NoZW1hU3BsaXRTQVhEYXRhOwp0eXBlZGVmIHhtbFNjaGVtYVNwbGl0U0FYRGF0YSAqeG1sU2NoZW1hU3BsaXRTQVhEYXRhUHRyOwoKc3RydWN0IF94bWxTY2hlbWFTcGxpdFNBWERhdGEgewogICAgeG1sU0FYSGFuZGxlclB0ciAgICAgIHVzZXJfc2F4OwogICAgdm9pZCAgICAgICAgICAgICAgICAgKnVzZXJfZGF0YTsKICAgIHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0OwogICAgeG1sU0FYSGFuZGxlclB0ciAgICAgIHNjaGVtYXNfc2F4Owp9OwoKI2RlZmluZSBYTUxfU0FYX1BMVUdfTUFHSUMgMHhkYzQzYmEyMQoKc3RydWN0IF94bWxTY2hlbWFTQVhQbHVnIHsKICAgIHVuc2lnbmVkIGludCBtYWdpYzsKCiAgICAvKiB0aGUgb3JpZ2luYWwgY2FsbGJhY2tzIGluZm9ybWF0aW9ucyAqLwogICAgeG1sU0FYSGFuZGxlclB0ciAgICAgKnVzZXJfc2F4X3B0cjsKICAgIHhtbFNBWEhhbmRsZXJQdHIgICAgICB1c2VyX3NheDsKICAgIHZvaWQgICAgICAgICAgICAgICAgKip1c2VyX2RhdGFfcHRyOwogICAgdm9pZCAgICAgICAgICAgICAgICAgKnVzZXJfZGF0YTsKCiAgICAvKiB0aGUgYmxvY2sgcGx1Z2dlZCBiYWNrIGFuZCB2YWxpZGF0aW9uIGluZm9ybWF0aW9ucyAqLwogICAgeG1sU0FYSGFuZGxlciAgICAgICAgIHNjaGVtYXNfc2F4OwogICAgeG1sU2NoZW1hVmFsaWRDdHh0UHRyIGN0eHQ7Cn07CgovKiBBbGwgdGhvc2UgZnVuY3Rpb25zIGp1c3QgYm91bmNlcyB0byB0aGUgdXNlciBwcm92aWRlZCBTQVggaGFuZGxlcnMgKi8Kc3RhdGljIHZvaWQKaW50ZXJuYWxTdWJzZXRTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKm5hbWUsCgkgICAgICAgY29uc3QgeG1sQ2hhciAqRXh0ZXJuYWxJRCwgY29uc3QgeG1sQ2hhciAqU3lzdGVtSUQpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5pbnRlcm5hbFN1YnNldCAhPSBOVUxMKSkKCWN0eHQtPnVzZXJfc2F4LT5pbnRlcm5hbFN1YnNldChjdHh0LT51c2VyX2RhdGEsIG5hbWUsIEV4dGVybmFsSUQsCgkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU3lzdGVtSUQpOwp9CgpzdGF0aWMgaW50CmlzU3RhbmRhbG9uZVNwbGl0KHZvaWQgKmN0eCkKewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPmlzU3RhbmRhbG9uZSAhPSBOVUxMKSkKCXJldHVybihjdHh0LT51c2VyX3NheC0+aXNTdGFuZGFsb25lKGN0eHQtPnVzZXJfZGF0YSkpOwogICAgcmV0dXJuKDApOwp9CgpzdGF0aWMgaW50Cmhhc0ludGVybmFsU3Vic2V0U3BsaXQodm9pZCAqY3R4KQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKChjdHh0ICE9IE5VTEwpICYmIChjdHh0LT51c2VyX3NheCAhPSBOVUxMKSAmJgogICAgICAgIChjdHh0LT51c2VyX3NheC0+aGFzSW50ZXJuYWxTdWJzZXQgIT0gTlVMTCkpCglyZXR1cm4oY3R4dC0+dXNlcl9zYXgtPmhhc0ludGVybmFsU3Vic2V0KGN0eHQtPnVzZXJfZGF0YSkpOwogICAgcmV0dXJuKDApOwp9CgpzdGF0aWMgaW50Cmhhc0V4dGVybmFsU3Vic2V0U3BsaXQodm9pZCAqY3R4KQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKChjdHh0ICE9IE5VTEwpICYmIChjdHh0LT51c2VyX3NheCAhPSBOVUxMKSAmJgogICAgICAgIChjdHh0LT51c2VyX3NheC0+aGFzRXh0ZXJuYWxTdWJzZXQgIT0gTlVMTCkpCglyZXR1cm4oY3R4dC0+dXNlcl9zYXgtPmhhc0V4dGVybmFsU3Vic2V0KGN0eHQtPnVzZXJfZGF0YSkpOwogICAgcmV0dXJuKDApOwp9CgpzdGF0aWMgdm9pZApleHRlcm5hbFN1YnNldFNwbGl0KHZvaWQgKmN0eCwgY29uc3QgeG1sQ2hhciAqbmFtZSwKCSAgICAgICBjb25zdCB4bWxDaGFyICpFeHRlcm5hbElELCBjb25zdCB4bWxDaGFyICpTeXN0ZW1JRCkKewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPmludGVybmFsU3Vic2V0ICE9IE5VTEwpKQoJY3R4dC0+dXNlcl9zYXgtPmludGVybmFsU3Vic2V0KGN0eHQtPnVzZXJfZGF0YSwgbmFtZSwgRXh0ZXJuYWxJRCwKCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTeXN0ZW1JRCk7Cn0KCnN0YXRpYyB4bWxQYXJzZXJJbnB1dFB0cgpyZXNvbHZlRW50aXR5U3BsaXQodm9pZCAqY3R4LCBjb25zdCB4bWxDaGFyICpwdWJsaWNJZCwgY29uc3QgeG1sQ2hhciAqc3lzdGVtSWQpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5yZXNvbHZlRW50aXR5ICE9IE5VTEwpKQoJcmV0dXJuKGN0eHQtPnVzZXJfc2F4LT5yZXNvbHZlRW50aXR5KGN0eHQtPnVzZXJfZGF0YSwgcHVibGljSWQsCgkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3lzdGVtSWQpKTsKICAgIHJldHVybihOVUxMKTsKfQoKc3RhdGljIHhtbEVudGl0eVB0cgpnZXRFbnRpdHlTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKm5hbWUpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5nZXRFbnRpdHkgIT0gTlVMTCkpCglyZXR1cm4oY3R4dC0+dXNlcl9zYXgtPmdldEVudGl0eShjdHh0LT51c2VyX2RhdGEsIG5hbWUpKTsKICAgIHJldHVybihOVUxMKTsKfQoKc3RhdGljIHhtbEVudGl0eVB0cgpnZXRQYXJhbWV0ZXJFbnRpdHlTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKm5hbWUpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5nZXRQYXJhbWV0ZXJFbnRpdHkgIT0gTlVMTCkpCglyZXR1cm4oY3R4dC0+dXNlcl9zYXgtPmdldFBhcmFtZXRlckVudGl0eShjdHh0LT51c2VyX2RhdGEsIG5hbWUpKTsKICAgIHJldHVybihOVUxMKTsKfQoKCnN0YXRpYyB2b2lkCmVudGl0eURlY2xTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKm5hbWUsIGludCB0eXBlLAogICAgICAgICAgY29uc3QgeG1sQ2hhciAqcHVibGljSWQsIGNvbnN0IHhtbENoYXIgKnN5c3RlbUlkLCB4bWxDaGFyICpjb250ZW50KQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKChjdHh0ICE9IE5VTEwpICYmIChjdHh0LT51c2VyX3NheCAhPSBOVUxMKSAmJgogICAgICAgIChjdHh0LT51c2VyX3NheC0+ZW50aXR5RGVjbCAhPSBOVUxMKSkKCWN0eHQtPnVzZXJfc2F4LT5lbnRpdHlEZWNsKGN0eHQtPnVzZXJfZGF0YSwgbmFtZSwgdHlwZSwgcHVibGljSWQsCgkgICAgICAgICAgICAgICAgICAgICAgICAgICBzeXN0ZW1JZCwgY29udGVudCk7Cn0KCnN0YXRpYyB2b2lkCmF0dHJpYnV0ZURlY2xTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKiBlbGVtLAogICAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhciAqIG5hbWUsIGludCB0eXBlLCBpbnQgZGVmLAogICAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhciAqIGRlZmF1bHRWYWx1ZSwgeG1sRW51bWVyYXRpb25QdHIgdHJlZSkKewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPmF0dHJpYnV0ZURlY2wgIT0gTlVMTCkpIHsKCWN0eHQtPnVzZXJfc2F4LT5hdHRyaWJ1dGVEZWNsKGN0eHQtPnVzZXJfZGF0YSwgZWxlbSwgbmFtZSwgdHlwZSwKCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlZiwgZGVmYXVsdFZhbHVlLCB0cmVlKTsKICAgIH0gZWxzZSB7Cgl4bWxGcmVlRW51bWVyYXRpb24odHJlZSk7CiAgICB9Cn0KCnN0YXRpYyB2b2lkCmVsZW1lbnREZWNsU3BsaXQodm9pZCAqY3R4LCBjb25zdCB4bWxDaGFyICpuYW1lLCBpbnQgdHlwZSwKCSAgICB4bWxFbGVtZW50Q29udGVudFB0ciBjb250ZW50KQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKChjdHh0ICE9IE5VTEwpICYmIChjdHh0LT51c2VyX3NheCAhPSBOVUxMKSAmJgogICAgICAgIChjdHh0LT51c2VyX3NheC0+ZWxlbWVudERlY2wgIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+ZWxlbWVudERlY2woY3R4dC0+dXNlcl9kYXRhLCBuYW1lLCB0eXBlLCBjb250ZW50KTsKfQoKc3RhdGljIHZvaWQKbm90YXRpb25EZWNsU3BsaXQodm9pZCAqY3R4LCBjb25zdCB4bWxDaGFyICpuYW1lLAoJICAgICBjb25zdCB4bWxDaGFyICpwdWJsaWNJZCwgY29uc3QgeG1sQ2hhciAqc3lzdGVtSWQpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5ub3RhdGlvbkRlY2wgIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+bm90YXRpb25EZWNsKGN0eHQtPnVzZXJfZGF0YSwgbmFtZSwgcHVibGljSWQsCgkgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN5c3RlbUlkKTsKfQoKc3RhdGljIHZvaWQKdW5wYXJzZWRFbnRpdHlEZWNsU3BsaXQodm9pZCAqY3R4LCBjb25zdCB4bWxDaGFyICpuYW1lLAoJCSAgIGNvbnN0IHhtbENoYXIgKnB1YmxpY0lkLCBjb25zdCB4bWxDaGFyICpzeXN0ZW1JZCwKCQkgICBjb25zdCB4bWxDaGFyICpub3RhdGlvbk5hbWUpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT51bnBhcnNlZEVudGl0eURlY2wgIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+dW5wYXJzZWRFbnRpdHlEZWNsKGN0eHQtPnVzZXJfZGF0YSwgbmFtZSwgcHVibGljSWQsCgkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN5c3RlbUlkLCBub3RhdGlvbk5hbWUpOwp9CgpzdGF0aWMgdm9pZApzZXREb2N1bWVudExvY2F0b3JTcGxpdCh2b2lkICpjdHgsIHhtbFNBWExvY2F0b3JQdHIgbG9jKQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKChjdHh0ICE9IE5VTEwpICYmIChjdHh0LT51c2VyX3NheCAhPSBOVUxMKSAmJgogICAgICAgIChjdHh0LT51c2VyX3NheC0+c2V0RG9jdW1lbnRMb2NhdG9yICE9IE5VTEwpKQoJY3R4dC0+dXNlcl9zYXgtPnNldERvY3VtZW50TG9jYXRvcihjdHh0LT51c2VyX2RhdGEsIGxvYyk7Cn0KCnN0YXRpYyB2b2lkCnN0YXJ0RG9jdW1lbnRTcGxpdCh2b2lkICpjdHgpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5zdGFydERvY3VtZW50ICE9IE5VTEwpKQoJY3R4dC0+dXNlcl9zYXgtPnN0YXJ0RG9jdW1lbnQoY3R4dC0+dXNlcl9kYXRhKTsKfQoKc3RhdGljIHZvaWQKZW5kRG9jdW1lbnRTcGxpdCh2b2lkICpjdHgpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5lbmREb2N1bWVudCAhPSBOVUxMKSkKCWN0eHQtPnVzZXJfc2F4LT5lbmREb2N1bWVudChjdHh0LT51c2VyX2RhdGEpOwp9CgpzdGF0aWMgdm9pZApwcm9jZXNzaW5nSW5zdHJ1Y3Rpb25TcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKnRhcmdldCwKICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHhtbENoYXIgKmRhdGEpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5wcm9jZXNzaW5nSW5zdHJ1Y3Rpb24gIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+cHJvY2Vzc2luZ0luc3RydWN0aW9uKGN0eHQtPnVzZXJfZGF0YSwgdGFyZ2V0LCBkYXRhKTsKfQoKc3RhdGljIHZvaWQKY29tbWVudFNwbGl0KHZvaWQgKmN0eCwgY29uc3QgeG1sQ2hhciAqdmFsdWUpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoKGN0eHQgIT0gTlVMTCkgJiYgKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5jb21tZW50ICE9IE5VTEwpKQoJY3R4dC0+dXNlcl9zYXgtPmNvbW1lbnQoY3R4dC0+dXNlcl9kYXRhLCB2YWx1ZSk7Cn0KCi8qCiAqIFZhcmFyZ3MgZXJyb3IgY2FsbGJhY2tzIHRvIHRoZSB1c2VyIGFwcGxpY2F0aW9uLCBoYXJkZXIgLi4uCiAqLwoKc3RhdGljIHZvaWQgWE1MQ0RFQ0wKd2FybmluZ1NwbGl0KHZvaWQgKmN0eCwgY29uc3QgY2hhciAqbXNnIEFUVFJJQlVURV9VTlVTRUQsIC4uLikgewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPndhcm5pbmcgIT0gTlVMTCkpIHsKCVRPRE8KICAgIH0KfQpzdGF0aWMgdm9pZCBYTUxDREVDTAplcnJvclNwbGl0KHZvaWQgKmN0eCwgY29uc3QgY2hhciAqbXNnIEFUVFJJQlVURV9VTlVTRUQsIC4uLikgewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPmVycm9yICE9IE5VTEwpKSB7CglUT0RPCiAgICB9Cn0Kc3RhdGljIHZvaWQgWE1MQ0RFQ0wKZmF0YWxFcnJvclNwbGl0KHZvaWQgKmN0eCwgY29uc3QgY2hhciAqbXNnIEFUVFJJQlVURV9VTlVTRUQsIC4uLikgewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPmZhdGFsRXJyb3IgIT0gTlVMTCkpIHsKCVRPRE8KICAgIH0KfQoKLyoKICogVGhvc2UgYXJlIGZ1bmN0aW9uIHdoZXJlIGJvdGggdGhlIHVzZXIgaGFuZGxlciBhbmQgdGhlIHNjaGVtYXMgaGFuZGxlcgogKiBuZWVkIHRvIGJlIGNhbGxlZC4KICovCnN0YXRpYyB2b2lkCmNoYXJhY3RlcnNTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKmNoLCBpbnQgbGVuKQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmIChjdHh0LT51c2VyX3NheC0+Y2hhcmFjdGVycyAhPSBOVUxMKSkKCWN0eHQtPnVzZXJfc2F4LT5jaGFyYWN0ZXJzKGN0eHQtPnVzZXJfZGF0YSwgY2gsIGxlbik7CiAgICBpZiAoY3R4dC0+Y3R4dCAhPSBOVUxMKQoJeG1sU2NoZW1hU0FYSGFuZGxlVGV4dChjdHh0LT5jdHh0LCBjaCwgbGVuKTsKfQoKc3RhdGljIHZvaWQKaWdub3JhYmxlV2hpdGVzcGFjZVNwbGl0KHZvaWQgKmN0eCwgY29uc3QgeG1sQ2hhciAqY2gsIGludCBsZW4pCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgY3R4dCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSBjdHg7CiAgICBpZiAoY3R4dCA9PSBOVUxMKQogICAgICAgIHJldHVybjsKICAgIGlmICgoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPmlnbm9yYWJsZVdoaXRlc3BhY2UgIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+aWdub3JhYmxlV2hpdGVzcGFjZShjdHh0LT51c2VyX2RhdGEsIGNoLCBsZW4pOwogICAgaWYgKGN0eHQtPmN0eHQgIT0gTlVMTCkKCXhtbFNjaGVtYVNBWEhhbmRsZVRleHQoY3R4dC0+Y3R4dCwgY2gsIGxlbik7Cn0KCnN0YXRpYyB2b2lkCmNkYXRhQmxvY2tTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKnZhbHVlLCBpbnQgbGVuKQp7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5pZ25vcmFibGVXaGl0ZXNwYWNlICE9IE5VTEwpKQoJY3R4dC0+dXNlcl9zYXgtPmlnbm9yYWJsZVdoaXRlc3BhY2UoY3R4dC0+dXNlcl9kYXRhLCB2YWx1ZSwgbGVuKTsKICAgIGlmIChjdHh0LT5jdHh0ICE9IE5VTEwpCgl4bWxTY2hlbWFTQVhIYW5kbGVDRGF0YVNlY3Rpb24oY3R4dC0+Y3R4dCwgdmFsdWUsIGxlbik7Cn0KCnN0YXRpYyB2b2lkCnJlZmVyZW5jZVNwbGl0KHZvaWQgKmN0eCwgY29uc3QgeG1sQ2hhciAqbmFtZSkKewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmICgoY3R4dCAhPSBOVUxMKSAmJiAoY3R4dC0+dXNlcl9zYXggIT0gTlVMTCkgJiYKICAgICAgICAoY3R4dC0+dXNlcl9zYXgtPnJlZmVyZW5jZSAhPSBOVUxMKSkKCWN0eHQtPnVzZXJfc2F4LT5yZWZlcmVuY2UoY3R4dC0+dXNlcl9kYXRhLCBuYW1lKTsKICAgIGlmIChjdHh0LT5jdHh0ICE9IE5VTEwpCiAgICAgICAgeG1sU2NoZW1hU0FYSGFuZGxlUmVmZXJlbmNlKGN0eHQtPnVzZXJfZGF0YSwgbmFtZSk7Cn0KCnN0YXRpYyB2b2lkCnN0YXJ0RWxlbWVudE5zU3BsaXQodm9pZCAqY3R4LCBjb25zdCB4bWxDaGFyICogbG9jYWxuYW1lLCAKCQkgICAgY29uc3QgeG1sQ2hhciAqIHByZWZpeCwgY29uc3QgeG1sQ2hhciAqIFVSSSwgCgkJICAgIGludCBuYl9uYW1lc3BhY2VzLCBjb25zdCB4bWxDaGFyICoqIG5hbWVzcGFjZXMsIAoJCSAgICBpbnQgbmJfYXR0cmlidXRlcywgaW50IG5iX2RlZmF1bHRlZCwgCgkJICAgIGNvbnN0IHhtbENoYXIgKiogYXR0cmlidXRlcykgewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciBjdHh0ID0gKHhtbFNjaGVtYVNBWFBsdWdQdHIpIGN0eDsKICAgIGlmIChjdHh0ID09IE5VTEwpCiAgICAgICAgcmV0dXJuOwogICAgaWYgKChjdHh0LT51c2VyX3NheCAhPSBOVUxMKSAmJgogICAgICAgIChjdHh0LT51c2VyX3NheC0+c3RhcnRFbGVtZW50TnMgIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+c3RhcnRFbGVtZW50TnMoY3R4dC0+dXNlcl9kYXRhLCBsb2NhbG5hbWUsIHByZWZpeCwKCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVUkksIG5iX25hbWVzcGFjZXMsIG5hbWVzcGFjZXMsCgkJCQkgICAgICAgbmJfYXR0cmlidXRlcywgbmJfZGVmYXVsdGVkLAoJCQkJICAgICAgIGF0dHJpYnV0ZXMpOwogICAgaWYgKGN0eHQtPmN0eHQgIT0gTlVMTCkKCXhtbFNjaGVtYVNBWEhhbmRsZVN0YXJ0RWxlbWVudE5zKGN0eHQtPmN0eHQsIGxvY2FsbmFtZSwgcHJlZml4LAoJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVVJJLCBuYl9uYW1lc3BhY2VzLCBuYW1lc3BhY2VzLAoJCQkJCSBuYl9hdHRyaWJ1dGVzLCBuYl9kZWZhdWx0ZWQsCgkJCQkJIGF0dHJpYnV0ZXMpOwp9CgpzdGF0aWMgdm9pZAplbmRFbGVtZW50TnNTcGxpdCh2b2lkICpjdHgsIGNvbnN0IHhtbENoYXIgKiBsb2NhbG5hbWUsIAoJCSAgICBjb25zdCB4bWxDaGFyICogcHJlZml4LCBjb25zdCB4bWxDaGFyICogVVJJKSB7CiAgICB4bWxTY2hlbWFTQVhQbHVnUHRyIGN0eHQgPSAoeG1sU2NoZW1hU0FYUGx1Z1B0cikgY3R4OwogICAgaWYgKGN0eHQgPT0gTlVMTCkKICAgICAgICByZXR1cm47CiAgICBpZiAoKGN0eHQtPnVzZXJfc2F4ICE9IE5VTEwpICYmCiAgICAgICAgKGN0eHQtPnVzZXJfc2F4LT5lbmRFbGVtZW50TnMgIT0gTlVMTCkpCgljdHh0LT51c2VyX3NheC0+ZW5kRWxlbWVudE5zKGN0eHQtPnVzZXJfZGF0YSwgbG9jYWxuYW1lLCBwcmVmaXgsIFVSSSk7CiAgICBpZiAoY3R4dC0+Y3R4dCAhPSBOVUxMKQoJeG1sU2NoZW1hU0FYSGFuZGxlRW5kRWxlbWVudE5zKGN0eHQtPmN0eHQsIGxvY2FsbmFtZSwgcHJlZml4LCBVUkkpOwp9CgovKioKICogeG1sU2NoZW1hU0FYUGx1ZzoKICogQGN0eHQ6ICBhIHNjaGVtYSB2YWxpZGF0aW9uIGNvbnRleHQKICogQHNheDogIGEgcG9pbnRlciB0byB0aGUgb3JpZ2luYWwgeG1sU0FYSGFuZGxlclB0cgogKiBAdXNlcl9kYXRhOiAgYSBwb2ludGVyIHRvIHRoZSBvcmlnaW5hbCBTQVggdXNlciBkYXRhIHBvaW50ZXIKICoKICogUGx1ZyBhIFNBWCBiYXNlZCB2YWxpZGF0aW9uIGxheWVyIGluIGEgU0FYIHBhcnNpbmcgZXZlbnQgZmxvdy4KICogVGhlIG9yaWdpbmFsIEBzYXhwdHIgYW5kIEBkYXRhcHRyIGRhdGEgYXJlIHJlcGxhY2VkIGJ5IG5ldyBwb2ludGVycwogKiBidXQgdGhlIGNhbGxzIHRvIHRoZSBvcmlnaW5hbCB3aWxsIGJlIG1haW50YWluZWQuCiAqCiAqIFJldHVybnMgYSBwb2ludGVyIHRvIGEgZGF0YSBzdHJ1Y3R1cmUgbmVlZGVkIHRvIHVucGx1ZyB0aGUgdmFsaWRhdGlvbiBsYXllcgogKiAgICAgICAgIG9yIE5VTEwgaW4gY2FzZSBvZiBlcnJvcnMuCiAqLwp4bWxTY2hlbWFTQVhQbHVnUHRyCnhtbFNjaGVtYVNBWFBsdWcoeG1sU2NoZW1hVmFsaWRDdHh0UHRyIGN0eHQsCgkJIHhtbFNBWEhhbmRsZXJQdHIgKnNheCwgdm9pZCAqKnVzZXJfZGF0YSkKewogICAgeG1sU2NoZW1hU0FYUGx1Z1B0ciByZXQ7CiAgICB4bWxTQVhIYW5kbGVyUHRyIG9sZF9zYXg7CgogICAgaWYgKChjdHh0ID09IE5VTEwpIHx8IChzYXggPT0gTlVMTCkgfHwgKHVzZXJfZGF0YSA9PSBOVUxMKSkKICAgICAgICByZXR1cm4oTlVMTCk7CgogICAgLyoKICAgICAqIFdlIG9ubHkgYWxsb3cgdG8gcGx1ZyBpbnRvIFNBWDIgZXZlbnQgc3RyZWFtcwogICAgICovCiAgICBvbGRfc2F4ID0gKnNheDsKICAgIGlmICgob2xkX3NheCAhPSBOVUxMKSAmJiAob2xkX3NheC0+aW5pdGlhbGl6ZWQgIT0gWE1MX1NBWDJfTUFHSUMpKQogICAgICAgIHJldHVybihOVUxMKTsKICAgIGlmICgob2xkX3NheCAhPSBOVUxMKSAmJiAKICAgICAgICAob2xkX3NheC0+c3RhcnRFbGVtZW50TnMgPT0gTlVMTCkgJiYgKG9sZF9zYXgtPmVuZEVsZW1lbnROcyA9PSBOVUxMKSAmJgogICAgICAgICgob2xkX3NheC0+c3RhcnRFbGVtZW50ICE9IE5VTEwpIHx8IChvbGRfc2F4LT5lbmRFbGVtZW50ICE9IE5VTEwpKSkKICAgICAgICByZXR1cm4oTlVMTCk7CgogICAgLyoKICAgICAqIGV2ZXJ5dGhpbmcgc2VlbXMgcmlnaHQgYWxsb2NhdGUgdGhlIGxvY2FsIGRhdGEgbmVlZGVkIGZvciB0aGF0IGxheWVyCiAgICAgKi8KICAgIHJldCA9ICh4bWxTY2hlbWFTQVhQbHVnUHRyKSB4bWxNYWxsb2Moc2l6ZW9mKHhtbFNjaGVtYVNBWFBsdWdTdHJ1Y3QpKTsKICAgIGlmIChyZXQgPT0gTlVMTCkgewogICAgICAgIHJldHVybihOVUxMKTsKICAgIH0KICAgIG1lbXNldChyZXQsIDAsIHNpemVvZih4bWxTY2hlbWFTQVhQbHVnU3RydWN0KSk7CiAgICByZXQtPm1hZ2ljID0gWE1MX1NBWF9QTFVHX01BR0lDOwogICAgcmV0LT5zY2hlbWFzX3NheC5pbml0aWFsaXplZCA9IFhNTF9TQVgyX01BR0lDOwogICAgcmV0LT5jdHh0ID0gY3R4dDsKICAgIHJldC0+dXNlcl9zYXhfcHRyID0gc2F4OwogICAgcmV0LT51c2VyX3NheCA9IG9sZF9zYXg7CiAgICBpZiAob2xkX3NheCA9PSBOVUxMKSB7CQogICAgICAgIC8qCgkgKiBnbyBkaXJlY3QsIG5vIG5lZWQgZm9yIHRoZSBzcGxpdCBibG9jayBhbmQgZnVuY3Rpb25zLgoJICovCglyZXQtPnNjaGVtYXNfc2F4LnN0YXJ0RWxlbWVudE5zID0geG1sU2NoZW1hU0FYSGFuZGxlU3RhcnRFbGVtZW50TnM7CglyZXQtPnNjaGVtYXNfc2F4LmVuZEVsZW1lbnROcyA9IHhtbFNjaGVtYVNBWEhhbmRsZUVuZEVsZW1lbnROczsKCS8qCgkgKiBOb3RlIHRoYXQgd2UgdXNlIHRoZSBzYW1lIHRleHQtZnVuY3Rpb24gZm9yIGJvdGgsIHRvIHByZXZlbnQKCSAqIHRoZSBwYXJzZXIgZnJvbSB0ZXN0aW5nIGZvciBpZ25vcmFibGUgd2hpdGVzcGFjZS4KCSAqLwoJcmV0LT5zY2hlbWFzX3NheC5pZ25vcmFibGVXaGl0ZXNwYWNlID0geG1sU2NoZW1hU0FYSGFuZGxlVGV4dDsKCXJldC0+c2NoZW1hc19zYXguY2hhcmFjdGVycyA9IHhtbFNjaGVtYVNBWEhhbmRsZVRleHQ7CgoJcmV0LT5zY2hlbWFzX3NheC5jZGF0YUJsb2NrID0geG1sU2NoZW1hU0FYSGFuZGxlQ0RhdGFTZWN0aW9uOwoJcmV0LT5zY2hlbWFzX3NheC5yZWZlcmVuY2UgPSB4bWxTY2hlbWFTQVhIYW5kbGVSZWZlcmVuY2U7CgoJcmV0LT51c2VyX2RhdGEgPSBjdHh0OwoJKnVzZXJfZGF0YSA9IGN0eHQ7CiAgICB9IGVsc2UgewogICAgICAgLyoKICAgICAgICAqIGZvciBlYWNoIGNhbGxiYWNrIHVudXNlZCBieSBTY2hlbWFzIGluaXRpYWxpemUgaXQgdG8gdGhlIFNwbGl0CgkqIHJvdXRpbmUgb25seSBpZiBub24gTlVMTCBpbiB0aGUgdXNlciBibG9jaywgdGhpcyBjYW4gc3BlZWQgdXAgCgkqIHRoaW5ncyBhdCB0aGUgU0FYIGxldmVsLgoJKi8KICAgICAgICBpZiAob2xkX3NheC0+aW50ZXJuYWxTdWJzZXQgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5pbnRlcm5hbFN1YnNldCA9IGludGVybmFsU3Vic2V0U3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPmlzU3RhbmRhbG9uZSAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmlzU3RhbmRhbG9uZSA9IGlzU3RhbmRhbG9uZVNwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5oYXNJbnRlcm5hbFN1YnNldCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4Lmhhc0ludGVybmFsU3Vic2V0ID0gaGFzSW50ZXJuYWxTdWJzZXRTcGxpdDsKICAgICAgICBpZiAob2xkX3NheC0+aGFzRXh0ZXJuYWxTdWJzZXQgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5oYXNFeHRlcm5hbFN1YnNldCA9IGhhc0V4dGVybmFsU3Vic2V0U3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPnJlc29sdmVFbnRpdHkgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5yZXNvbHZlRW50aXR5ID0gcmVzb2x2ZUVudGl0eVNwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5nZXRFbnRpdHkgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5nZXRFbnRpdHkgPSBnZXRFbnRpdHlTcGxpdDsKICAgICAgICBpZiAob2xkX3NheC0+ZW50aXR5RGVjbCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmVudGl0eURlY2wgPSBlbnRpdHlEZWNsU3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPm5vdGF0aW9uRGVjbCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4Lm5vdGF0aW9uRGVjbCA9IG5vdGF0aW9uRGVjbFNwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5hdHRyaWJ1dGVEZWNsICE9IE5VTEwpCiAgICAgICAgICAgIHJldC0+c2NoZW1hc19zYXguYXR0cmlidXRlRGVjbCA9IGF0dHJpYnV0ZURlY2xTcGxpdDsKICAgICAgICBpZiAob2xkX3NheC0+ZWxlbWVudERlY2wgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5lbGVtZW50RGVjbCA9IGVsZW1lbnREZWNsU3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPnVucGFyc2VkRW50aXR5RGVjbCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LnVucGFyc2VkRW50aXR5RGVjbCA9IHVucGFyc2VkRW50aXR5RGVjbFNwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5zZXREb2N1bWVudExvY2F0b3IgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5zZXREb2N1bWVudExvY2F0b3IgPSBzZXREb2N1bWVudExvY2F0b3JTcGxpdDsKICAgICAgICBpZiAob2xkX3NheC0+c3RhcnREb2N1bWVudCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LnN0YXJ0RG9jdW1lbnQgPSBzdGFydERvY3VtZW50U3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPmVuZERvY3VtZW50ICE9IE5VTEwpCiAgICAgICAgICAgIHJldC0+c2NoZW1hc19zYXguZW5kRG9jdW1lbnQgPSBlbmREb2N1bWVudFNwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5wcm9jZXNzaW5nSW5zdHJ1Y3Rpb24gIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5wcm9jZXNzaW5nSW5zdHJ1Y3Rpb24gPSBwcm9jZXNzaW5nSW5zdHJ1Y3Rpb25TcGxpdDsKICAgICAgICBpZiAob2xkX3NheC0+Y29tbWVudCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmNvbW1lbnQgPSBjb21tZW50U3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPndhcm5pbmcgIT0gTlVMTCkKICAgICAgICAgICAgcmV0LT5zY2hlbWFzX3NheC53YXJuaW5nID0gd2FybmluZ1NwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5lcnJvciAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmVycm9yID0gZXJyb3JTcGxpdDsKICAgICAgICBpZiAob2xkX3NheC0+ZmF0YWxFcnJvciAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmZhdGFsRXJyb3IgPSBmYXRhbEVycm9yU3BsaXQ7CiAgICAgICAgaWYgKG9sZF9zYXgtPmdldFBhcmFtZXRlckVudGl0eSAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmdldFBhcmFtZXRlckVudGl0eSA9IGdldFBhcmFtZXRlckVudGl0eVNwbGl0OwogICAgICAgIGlmIChvbGRfc2F4LT5leHRlcm5hbFN1YnNldCAhPSBOVUxMKQogICAgICAgICAgICByZXQtPnNjaGVtYXNfc2F4LmV4dGVybmFsU3Vic2V0ID0gZXh0ZXJuYWxTdWJzZXRTcGxpdDsKCgkvKgoJICogdGhlIDYgc2NoZW1hcyBjYWxsYmFjayBoYXZlIHRvIGdvIHRvIHRoZSBzcGxpdHRlciBmdW5jdGlvbnMKCSAqIE5vdGUgdGhhdCB3ZSB1c2UgdGhlIHNhbWUgdGV4dC1mdW5jdGlvbiBmb3IgaWdub3JhYmxlV2hpdGVzcGFjZQoJICogaWYgcG9zc2libGUsIHRvIHByZXZlbnQgdGhlIHBhcnNlciBmcm9tIHRlc3RpbmcgZm9yIGlnbm9yYWJsZQoJICogd2hpdGVzcGFjZS4KCSAqLwogICAgICAgIHJldC0+c2NoZW1hc19zYXguY2hhcmFjdGVycyA9IGNoYXJhY3RlcnNTcGxpdDsKCWlmICgob2xkX3NheC0+aWdub3JhYmxlV2hpdGVzcGFjZSAhPSBOVUxMKSAmJgoJICAgIChvbGRfc2F4LT5pZ25vcmFibGVXaGl0ZXNwYWNlICE9IG9sZF9zYXgtPmNoYXJhY3RlcnMpKQoJICAgIHJldC0+c2NoZW1hc19zYXguaWdub3JhYmxlV2hpdGVzcGFjZSA9IGlnbm9yYWJsZVdoaXRlc3BhY2VTcGxpdDsKCWVsc2UKCSAgICByZXQtPnNjaGVtYXNfc2F4Lmlnbm9yYWJsZVdoaXRlc3BhY2UgPSBjaGFyYWN0ZXJzU3BsaXQ7CiAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5jZGF0YUJsb2NrID0gY2RhdGFCbG9ja1NwbGl0OwogICAgICAgIHJldC0+c2NoZW1hc19zYXgucmVmZXJlbmNlID0gcmVmZXJlbmNlU3BsaXQ7CiAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5zdGFydEVsZW1lbnROcyA9IHN0YXJ0RWxlbWVudE5zU3BsaXQ7CiAgICAgICAgcmV0LT5zY2hlbWFzX3NheC5lbmRFbGVtZW50TnMgPSBlbmRFbGVtZW50TnNTcGxpdDsKCglyZXQtPnVzZXJfZGF0YV9wdHIgPSB1c2VyX2RhdGE7CglyZXQtPnVzZXJfZGF0YSA9ICp1c2VyX2RhdGE7CgkqdXNlcl9kYXRhID0gcmV0OwogICAgfQoKICAgIC8qCiAgICAgKiBwbHVnIHRoZSBwb2ludGVycyBiYWNrLgogICAgICovCiAgICAqc2F4ID0gJihyZXQtPnNjaGVtYXNfc2F4KTsKICAgIGN0eHQtPnNheCA9ICpzYXg7CiAgICBjdHh0LT5mbGFncyB8PSBYTUxfU0NIRU1BX1ZBTElEX0NUWFRfRkxBR19TVFJFQU07CiAgICB4bWxTY2hlbWFQcmVSdW4oY3R4dCk7CiAgICByZXR1cm4ocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVNBWFVucGx1ZzoKICogQHBsdWc6ICBhIGRhdGEgc3RydWN0dXJlIHJldHVybmVkIGJ5IHhtbFNjaGVtYVNBWFBsdWcKICoKICogVW5wbHVnIGEgU0FYIGJhc2VkIHZhbGlkYXRpb24gbGF5ZXIgaW4gYSBTQVggcGFyc2luZyBldmVudCBmbG93LgogKiBUaGUgb3JpZ2luYWwgcG9pbnRlcnMgdXNlZCBpbiB0aGUgY2FsbCBhcmUgcmVzdG9yZWQuCiAqCiAqIFJldHVybnMgMCBpbiBjYXNlIG9mIHN1Y2Nlc3MgYW5kIC0xIGluIGNhc2Ugb2YgZmFpbHVyZS4KICovCmludAp4bWxTY2hlbWFTQVhVbnBsdWcoeG1sU2NoZW1hU0FYUGx1Z1B0ciBwbHVnKQp7CiAgICB4bWxTQVhIYW5kbGVyUHRyICpzYXg7CiAgICB2b2lkICoqdXNlcl9kYXRhOwoKICAgIGlmICgocGx1ZyA9PSBOVUxMKSB8fCAocGx1Zy0+bWFnaWMgIT0gWE1MX1NBWF9QTFVHX01BR0lDKSkKICAgICAgICByZXR1cm4oLTEpOwogICAgcGx1Zy0+bWFnaWMgPSAwOwoKICAgIHhtbFNjaGVtYVBvc3RSdW4ocGx1Zy0+Y3R4dCk7CiAgICAvKiByZXN0b3JlIHRoZSBkYXRhICovCiAgICBzYXggPSBwbHVnLT51c2VyX3NheF9wdHI7CiAgICAqc2F4ID0gcGx1Zy0+dXNlcl9zYXg7CiAgICBpZiAocGx1Zy0+dXNlcl9zYXggIT0gTlVMTCkgewoJdXNlcl9kYXRhID0gcGx1Zy0+dXNlcl9kYXRhX3B0cjsKCSp1c2VyX2RhdGEgPSBwbHVnLT51c2VyX2RhdGE7CiAgICB9CgogICAgLyogZnJlZSBhbmQgcmV0dXJuICovCiAgICB4bWxGcmVlKHBsdWcpOwogICAgcmV0dXJuKDApOwp9CgovKioKICogeG1sU2NoZW1hVmFsaWRhdGVTdHJlYW06CiAqIEBjdHh0OiAgYSBzY2hlbWEgdmFsaWRhdGlvbiBjb250ZXh0CiAqIEBpbnB1dDogIHRoZSBpbnB1dCB0byB1c2UgZm9yIHJlYWRpbmcgdGhlIGRhdGEKICogQGVuYzogIGFuIG9wdGlvbmFsIGVuY29kaW5nIGluZm9ybWF0aW9uCiAqIEBzYXg6ICBhIFNBWCBoYW5kbGVyIGZvciB0aGUgcmVzdWx0aW5nIGV2ZW50cwogKiBAdXNlcl9kYXRhOiAgdGhlIGNvbnRleHQgdG8gcHJvdmlkZSB0byB0aGUgU0FYIGhhbmRsZXIuCiAqCiAqIFZhbGlkYXRlIGFuIGlucHV0IGJhc2VkIG9uIGEgZmxvdyBvZiBTQVggZXZlbnQgZnJvbSB0aGUgcGFyc2VyCiAqIGFuZCBmb3J3YXJkIHRoZSBldmVudHMgdG8gdGhlIEBzYXggaGFuZGxlciB3aXRoIHRoZSBwcm92aWRlZCBAdXNlcl9kYXRhCiAqIHRoZSB1c2VyIHByb3ZpZGVkIEBzYXggaGFuZGxlciBtdXN0IGJlIGEgU0FYMiBvbmUuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgZG9jdW1lbnQgaXMgc2NoZW1hcyB2YWxpZCwgYSBwb3NpdGl2ZSBlcnJvciBjb2RlCiAqICAgICBudW1iZXIgb3RoZXJ3aXNlIGFuZCAtMSBpbiBjYXNlIG9mIGludGVybmFsIG9yIEFQSSBlcnJvci4KICovCmludAp4bWxTY2hlbWFWYWxpZGF0ZVN0cmVhbSh4bWxTY2hlbWFWYWxpZEN0eHRQdHIgY3R4dCwKICAgICAgICAgICAgICAgICAgICAgICAgeG1sUGFyc2VySW5wdXRCdWZmZXJQdHIgaW5wdXQsIHhtbENoYXJFbmNvZGluZyBlbmMsCiAgICAgICAgICAgICAgICAgICAgICAgIHhtbFNBWEhhbmRsZXJQdHIgc2F4LCB2b2lkICp1c2VyX2RhdGEpCnsKICAgIHhtbFNjaGVtYVNBWFBsdWdQdHIgcGx1ZyA9IE5VTEw7CiAgICB4bWxTQVhIYW5kbGVyUHRyIG9sZF9zYXggPSBOVUxMOwogICAgeG1sUGFyc2VyQ3R4dFB0ciBwY3R4dCA9IE5VTEw7CiAgICB4bWxQYXJzZXJJbnB1dFB0ciBpbnB1dFN0cmVhbSA9IE5VTEw7CiAgICBpbnQgcmV0OwoKICAgIGlmICgoY3R4dCA9PSBOVUxMKSB8fCAoaW5wdXQgPT0gTlVMTCkpCiAgICAgICAgcmV0dXJuICgtMSk7CgogICAgLyoKICAgICAqIHByZXBhcmUgdGhlIHBhcnNlcgogICAgICovCiAgICBwY3R4dCA9IHhtbE5ld1BhcnNlckN0eHQoKTsKICAgIGlmIChwY3R4dCA9PSBOVUxMKQogICAgICAgIHJldHVybiAoLTEpOwogICAgb2xkX3NheCA9IHBjdHh0LT5zYXg7CiAgICBwY3R4dC0+c2F4ID0gc2F4OwogICAgcGN0eHQtPnVzZXJEYXRhID0gdXNlcl9kYXRhOwojaWYgMAogICAgaWYgKG9wdGlvbnMpCiAgICAgICAgeG1sQ3R4dFVzZU9wdGlvbnMocGN0eHQsIG9wdGlvbnMpOwojZW5kaWYKICAgIHBjdHh0LT5saW5lbnVtYmVycyA9IDE7ICAgIAoKICAgIGlucHV0U3RyZWFtID0geG1sTmV3SU9JbnB1dFN0cmVhbShwY3R4dCwgaW5wdXQsIGVuYyk7OwogICAgaWYgKGlucHV0U3RyZWFtID09IE5VTEwpIHsKICAgICAgICByZXQgPSAtMTsKCWdvdG8gZG9uZTsKICAgIH0KICAgIGlucHV0UHVzaChwY3R4dCwgaW5wdXRTdHJlYW0pOwogICAgY3R4dC0+cGFyc2VyQ3R4dCA9IHBjdHh0OwogICAgY3R4dC0+aW5wdXQgPSBpbnB1dDsKCiAgICAvKgogICAgICogUGx1ZyB0aGUgdmFsaWRhdGlvbiBhbmQgbGF1bmNoIHRoZSBwYXJzaW5nCiAgICAgKi8KICAgIHBsdWcgPSB4bWxTY2hlbWFTQVhQbHVnKGN0eHQsICYocGN0eHQtPnNheCksICYocGN0eHQtPnVzZXJEYXRhKSk7CiAgICBpZiAocGx1ZyA9PSBOVUxMKSB7CiAgICAgICAgcmV0ID0gLTE7Cglnb3RvIGRvbmU7CiAgICB9CiAgICBjdHh0LT5pbnB1dCA9IGlucHV0OwogICAgY3R4dC0+ZW5jID0gZW5jOwogICAgY3R4dC0+c2F4ID0gcGN0eHQtPnNheDsKICAgIGN0eHQtPmZsYWdzIHw9IFhNTF9TQ0hFTUFfVkFMSURfQ1RYVF9GTEFHX1NUUkVBTTsKICAgIHJldCA9IHhtbFNjaGVtYVZTdGFydChjdHh0KTsKCiAgICBpZiAoKHJldCA9PSAwKSAmJiAoISBjdHh0LT5wYXJzZXJDdHh0LT53ZWxsRm9ybWVkKSkgewoJcmV0ID0gY3R4dC0+cGFyc2VyQ3R4dC0+ZXJyTm87CglpZiAocmV0ID09IDApCgkgICAgcmV0ID0gMTsKICAgIH0gICAgCgpkb25lOgogICAgY3R4dC0+cGFyc2VyQ3R4dCA9IE5VTEw7CiAgICBjdHh0LT5zYXggPSBOVUxMOwogICAgY3R4dC0+aW5wdXQgPSBOVUxMOwogICAgaWYgKHBsdWcgIT0gTlVMTCkgewogICAgICAgIHhtbFNjaGVtYVNBWFVucGx1ZyhwbHVnKTsKICAgIH0KICAgIC8qIGNsZWFudXAgKi8KICAgIGlmIChwY3R4dCAhPSBOVUxMKSB7CglwY3R4dC0+c2F4ID0gb2xkX3NheDsKCXhtbEZyZWVQYXJzZXJDdHh0KHBjdHh0KTsKICAgIH0KICAgIHJldHVybiAocmV0KTsKfQoKLyoqCiAqIHhtbFNjaGVtYVZhbGlkYXRlRmlsZToKICogQGN0eHQ6IGEgc2NoZW1hIHZhbGlkYXRpb24gY29udGV4dAogKiBAZmlsZW5hbWU6IHRoZSBVUkkgb2YgdGhlIGluc3RhbmNlCiAqIEBvcHRpb25zOiBhIGZ1dHVyZSBzZXQgb2Ygb3B0aW9ucywgY3VycmVudGx5IHVudXNlZAogKgogKiBEbyBhIHNjaGVtYXMgdmFsaWRhdGlvbiBvZiB0aGUgZ2l2ZW4gcmVzb3VyY2UsIGl0IHdpbGwgdXNlIHRoZQogKiBTQVggc3RyZWFtYWJsZSB2YWxpZGF0aW9uIGludGVybmFsbHkuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgZG9jdW1lbnQgaXMgdmFsaWQsIGEgcG9zaXRpdmUgZXJyb3IgY29kZQogKiAgICAgbnVtYmVyIG90aGVyd2lzZSBhbmQgLTEgaW4gY2FzZSBvZiBhbiBpbnRlcm5hbCBvciBBUEkgZXJyb3IuCiAqLwppbnQKeG1sU2NoZW1hVmFsaWRhdGVGaWxlKHhtbFNjaGVtYVZhbGlkQ3R4dFB0ciBjdHh0LAogICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqIGZpbGVuYW1lLAoJCSAgICAgIGludCBvcHRpb25zIEFUVFJJQlVURV9VTlVTRUQpCnsKICAgIGludCByZXQ7CiAgICB4bWxQYXJzZXJJbnB1dEJ1ZmZlclB0ciBpbnB1dDsKCiAgICBpZiAoKGN0eHQgPT0gTlVMTCkgfHwgKGZpbGVuYW1lID09IE5VTEwpKQogICAgICAgIHJldHVybiAoLTEpOwogICAgCiAgICBpbnB1dCA9IHhtbFBhcnNlcklucHV0QnVmZmVyQ3JlYXRlRmlsZW5hbWUoZmlsZW5hbWUsCglYTUxfQ0hBUl9FTkNPRElOR19OT05FKTsKICAgIGlmIChpbnB1dCA9PSBOVUxMKQoJcmV0dXJuICgtMSk7CiAgICByZXQgPSB4bWxTY2hlbWFWYWxpZGF0ZVN0cmVhbShjdHh0LCBpbnB1dCwgWE1MX0NIQVJfRU5DT0RJTkdfTk9ORSwKCU5VTEwsIE5VTEwpOyAgICAKICAgIHJldHVybiAocmV0KTsKfQoKI2RlZmluZSBib3R0b21feG1sc2NoZW1hcwojaW5jbHVkZSAiZWxmZ2NjaGFjay5oIgojZW5kaWYgLyogTElCWE1MX1NDSEVNQVNfRU5BQkxFRCAqLwo=