LyoKICogRE9TIFZpcnR1YWwgTWFjaGluZQogKgogKiBDb3B5cmlnaHQgMTk5OCBPdmUgS+V2ZW4KICoKICogVGhpcyBjb2RlIGhhc24ndCBiZWVuIGNvbXBsZXRlbHkgY2xlYW5lZCB1cCB5ZXQuCiAqLwoKI2luY2x1ZGUgImNvbmZpZy5oIgoKI2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzdGRsaWIuaD4KI2luY2x1ZGUgPHN0cmluZy5oPgojaW5jbHVkZSA8ZXJybm8uaD4KI2luY2x1ZGUgPGZjbnRsLmg+CiNpbmNsdWRlIDxzaWduYWwuaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVkZSA8c3lzL3RpbWUuaD4KI2luY2x1ZGUgPHN5cy90eXBlcy5oPgojaW5jbHVkZSA8c3lzL3N0YXQuaD4KCiNpbmNsdWRlICJ3aW5lL3dpbmJhc2UxNi5oIgojaW5jbHVkZSAid2luZS9leGNlcHRpb24uaCIKI2luY2x1ZGUgIndpbmRlZi5oIgojaW5jbHVkZSAid2luZ2RpLmgiCiNpbmNsdWRlICJ3aW51c2VyLmgiCiNpbmNsdWRlICJ3aW5udC5oIgoKI2luY2x1ZGUgImNhbGxiYWNrLmgiCiNpbmNsdWRlICJtc2Rvcy5oIgojaW5jbHVkZSAiZmlsZS5oIgojaW5jbHVkZSAibWlzY2VtdS5oIgojaW5jbHVkZSAiZG9zZXhlLmgiCiNpbmNsdWRlICJkb3Ntb2QuaCIKI2luY2x1ZGUgInN0YWNrZnJhbWUuaCIKI2luY2x1ZGUgImRlYnVndG9vbHMuaCIKCkRFQ0xBUkVfREVCVUdfQ0hBTk5FTChpbnQpCkRFQ0xBUkVfREVCVUdfQ0hBTk5FTChtb2R1bGUpCkRFQ0xBUkVfREVCVUdfQ0hBTk5FTChyZWxheSkKCiNpZmRlZiBNWl9TVVBQT1JURUQKCiNpZmRlZiBIQVZFX1NZU19WTTg2X0gKIyBpbmNsdWRlIDxzeXMvdm04Ni5oPgojZW5kaWYKI2lmZGVmIEhBVkVfU1lTX01NQU5fSAojIGluY2x1ZGUgPHN5cy9tbWFuLmg+CiNlbmRpZgoKI2RlZmluZSBJRl9DTFIoY3R4KSBFRkxfcmVnKGN0eCkgJj0gflZJRl9NQVNLCiNkZWZpbmUgSUZfRU5BQkxFRChjdHgpIChFRkxfcmVnKGN0eCkgJiBWSUZfTUFTSykKI2RlZmluZSBTRVRfUEVORChjdHgpIEVGTF9yZWcoY3R4KSB8PSBWSVBfTUFTSwojZGVmaW5lIENMUl9QRU5EKGN0eCkgRUZMX3JlZyhjdHgpICY9IH5WSVBfTUFTSwojZGVmaW5lIElTX1BFTkQoY3R4KSAoRUZMX3JlZyhjdHgpICYgVklQX01BU0spCgojdW5kZWYgVFJZX1BJQ1JFVFVSTgoKc3RhdGljIHZvaWQgZG9fZXhjZXB0aW9uKCBpbnQgc2lnbmFsLCBDT05URVhUODYgKmNvbnRleHQgKQp7CiAgICBFWENFUFRJT05fUkVDT1JEIHJlYzsKICAgIGlmICgoc2lnbmFsID09IFNJR1RSQVApIHx8IChzaWduYWwgPT0gU0lHSFVQKSkKICAgIHsKICAgICAgICByZWMuRXhjZXB0aW9uQ29kZSAgPSBFWENFUFRJT05fQlJFQUtQT0lOVDsKICAgICAgICByZWMuRXhjZXB0aW9uRmxhZ3MgPSBFWENFUFRJT05fQ09OVElOVUFCTEU7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgcmVjLkV4Y2VwdGlvbkNvZGUgID0gRVhDRVBUSU9OX0lMTEVHQUxfSU5TVFJVQ1RJT047ICAvKiBnZW5lcmljIGVycm9yICovCiAgICAgICAgcmVjLkV4Y2VwdGlvbkZsYWdzID0gRUhfTk9OQ09OVElOVUFCTEU7CiAgICB9CiAgICByZWMuRXhjZXB0aW9uUmVjb3JkICA9IE5VTEw7CiAgICByZWMuRXhjZXB0aW9uQWRkcmVzcyA9IChMUFZPSUQpRUlQX3JlZyhjb250ZXh0KTsKICAgIHJlYy5OdW1iZXJQYXJhbWV0ZXJzID0gMDsKICAgIEVYQ19SdGxSYWlzZUV4Y2VwdGlvbiggJnJlYywgY29udGV4dCApOwp9CgpzdGF0aWMgdm9pZCBET1NWTV9EdW1wKCBMUERPU1RBU0sgbHBEb3NUYXNrLCBpbnQgZm4sIGludCBzaWcsCiAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCB2bTg2cGx1c19zdHJ1Y3QqVk04NiApCnsKIHVuc2lnbmVkIGlvZnM7CiBCWVRFKmluc3Q7CiBpbnQgeDsKCiBzd2l0Y2ggKFZNODZfVFlQRShmbikpIHsKICBjYXNlIFZNODZfU0lHTkFMOgogICBwcmludGYoIlRyYXBwZWQgc2lnbmFsICVkXG4iLHNpZyk7IGJyZWFrOwogIGNhc2UgVk04Nl9VTktOT1dOOgogICBwcmludGYoIlRyYXBwZWQgdW5oYW5kbGVkIEdQRlxuIik7IGJyZWFrOwogIGNhc2UgVk04Nl9JTlR4OgogICBwcmludGYoIlRyYXBwZWQgSU5UICUwMnhcbiIsVk04Nl9BUkcoZm4pKTsgYnJlYWs7CiAgY2FzZSBWTTg2X1NUSToKICAgcHJpbnRmKCJUcmFwcGVkIFNUSVxuIik7IGJyZWFrOwogIGNhc2UgVk04Nl9QSUNSRVRVUk46CiAgIHByaW50ZigiVHJhcHBlZCBkdWUgdG8gcGVuZGluZyBQSUMgcmVxdWVzdFxuIik7IGJyZWFrOwogIGNhc2UgVk04Nl9UUkFQOgogICBwcmludGYoIlRyYXBwZWQgZGVidWcgcmVxdWVzdFxuIik7IGJyZWFrOwogIGRlZmF1bHQ6CiAgIHByaW50ZigiVHJhcHBlZCB1bmtub3duIFZNODYgdHlwZSAlZCBhcmcgJWRcbiIsVk04Nl9UWVBFKGZuKSxWTTg2X0FSRyhmbikpOyBicmVhazsKIH0KI2RlZmluZSBSRUdTIFZNODYtPnJlZ3MKIGZwcmludGYoc3RkZXJyLCJBWD0lMDRsWCBDWD0lMDRsWCBEWD0lMDRsWCBCWD0lMDRsWFxuIixSRUdTLmVheCxSRUdTLmVjeCxSRUdTLmVkeCxSRUdTLmVieCk7CiBmcHJpbnRmKHN0ZGVyciwiU0k9JTA0bFggREk9JTA0bFggU1A9JTA0bFggQlA9JTA0bFhcbiIsUkVHUy5lc2ksUkVHUy5lZGksUkVHUy5lc3AsUkVHUy5lYnApOwogZnByaW50ZihzdGRlcnIsIkNTPSUwNFggRFM9JTA0WCBFUz0lMDRYIFNTPSUwNFhcbiIsUkVHUy5jcyxSRUdTLmRzLFJFR1MuZXMsUkVHUy5zcyk7CiBmcHJpbnRmKHN0ZGVyciwiSVA9JTA0bFggRUZMQUdTPSUwOGxYXG4iLFJFR1MuZWlwLFJFR1MuZWZsYWdzKTsKCiBpb2ZzPSgoRFdPUkQpUkVHUy5jczw8NCkrUkVHUy5laXA7CiN1bmRlZiBSRUdTCiBpbnN0PShCWVRFKilscERvc1Rhc2stPmltZytpb2ZzOwogcHJpbnRmKCJPcGNvZGVzOiIpOwogZm9yICh4PTA7IHg8ODsgeCsrKSBwcmludGYoIiAlMDJ4IixpbnN0W3hdKTsKIHByaW50ZigiXG4iKTsKfQoKc3RhdGljIGludCBET1NWTV9JbnQoIGludCB2ZWN0LCBDT05URVhUODYgKmNvbnRleHQsIExQRE9TVEFTSyBscERvc1Rhc2sgKQp7CiBleHRlcm4gVUlOVDE2IERQTUlfd3JhcF9zZWc7CgogaWYgKHZlY3Q9PTB4MzEpIHsKICBpZiAoQ1NfcmVnKGNvbnRleHQpPT1EUE1JX3dyYXBfc2VnKSB7CiAgIC8qIGV4aXQgZnJvbSByZWFsLW1vZGUgd3JhcHBlciAqLwogICByZXR1cm4gLTE7CiAgfQogIC8qIHdlIGNvdWxkIHByb2JhYmx5IG1vdmUgc29tZSBvdGhlciBkb2RneSBzdHVmZiBoZXJlIHRvbyBmcm9tIGRwbWkuYyAqLwogfQogSU5UX1JlYWxNb2RlSW50ZXJydXB0KHZlY3QsY29udGV4dCk7CiByZXR1cm4gMDsKfQoKc3RhdGljIHZvaWQgRE9TVk1fU2ltdWxhdGVJbnQoIGludCB2ZWN0LCBDT05URVhUODYgKmNvbnRleHQsIExQRE9TVEFTSyBscERvc1Rhc2sgKQp7CiAgRkFSUFJPQzE2IGhhbmRsZXI9SU5UX0dldFJNSGFuZGxlcih2ZWN0KTsKCiAgaWYgKFNFTEVDVE9ST0YoaGFuZGxlcik9PTB4ZjAwMCkgewogICAgLyogaWYgaW50ZXJuYWwgaW50ZXJydXB0LCBjYWxsIGl0IGRpcmVjdGx5ICovCiAgICBJTlRfUmVhbE1vZGVJbnRlcnJ1cHQodmVjdCxjb250ZXh0KTsKICB9IGVsc2UgewogICAgV09SRCpzdGFjaz0oV09SRCopKFY4NkJBU0UoY29udGV4dCkrKCgoRFdPUkQpU1NfcmVnKGNvbnRleHQpKTw8NCkrTE9XT1JEKEVTUF9yZWcoY29udGV4dCkpKTsKICAgIFdPUkQgZmxhZz1MT1dPUkQoRUZMX3JlZyhjb250ZXh0KSk7CgogICAgaWYgKElGX0VOQUJMRUQoY29udGV4dCkpIGZsYWd8PUlGX01BU0s7CiAgICBlbHNlIGZsYWcmPX5JRl9NQVNLOwoKICAgICooLS1zdGFjayk9ZmxhZzsKICAgICooLS1zdGFjayk9Q1NfcmVnKGNvbnRleHQpOwogICAgKigtLXN0YWNrKT1MT1dPUkQoRUlQX3JlZyhjb250ZXh0KSk7CiAgICBFU1BfcmVnKGNvbnRleHQpLT02OwogICAgQ1NfcmVnKGNvbnRleHQpPVNFTEVDVE9ST0YoaGFuZGxlcik7CiAgICBFSVBfcmVnKGNvbnRleHQpPU9GRlNFVE9GKGhhbmRsZXIpOwogICAgSUZfQ0xSKGNvbnRleHQpOwogIH0KfQoKI2RlZmluZSBTSE9VTERfUEVORCh4KSBcCiAgKHggJiYgKCghbHBEb3NUYXNrLT5jdXJyZW50KSB8fCAoeC0+cHJpb3JpdHkgPCBscERvc1Rhc2stPmN1cnJlbnQtPnByaW9yaXR5KSkpCgpzdGF0aWMgdm9pZCBET1NWTV9TZW5kUXVldWVkRXZlbnQoQ09OVEVYVDg2ICpjb250ZXh0LCBMUERPU1RBU0sgbHBEb3NUYXNrKQp7CiAgTFBET1NFVkVOVCBldmVudCA9IGxwRG9zVGFzay0+cGVuZGluZzsKCiAgaWYgKFNIT1VMRF9QRU5EKGV2ZW50KSkgewogICAgLyogcmVtb3ZlIGZyb20gInBlbmRpbmciIGxpc3QgKi8KICAgIGxwRG9zVGFzay0+cGVuZGluZyA9IGV2ZW50LT5uZXh0OwogICAgLyogcHJvY2VzcyBldmVudCAqLwogICAgaWYgKGV2ZW50LT5pcnE+PTApIHsKICAgICAgLyogaXQncyBhbiBJUlEsIG1vdmUgaXQgdG8gImN1cnJlbnQiIGxpc3QgKi8KICAgICAgZXZlbnQtPm5leHQgPSBscERvc1Rhc2stPmN1cnJlbnQ7CiAgICAgIGxwRG9zVGFzay0+Y3VycmVudCA9IGV2ZW50OwogICAgICBUUkFDRV8oaW50KSgiZGlzcGF0Y2hpbmcgSVJRICVkXG4iLGV2ZW50LT5pcnEpOwogICAgICAvKiBub3RlIHRoYXQgaWYgRE9TVk1fU2ltdWxhdGVJbnQgY2FsbHMgYW4gaW50ZXJuYWwgaW50ZXJydXB0IGRpcmVjdGx5LAogICAgICAgKiBscERvc1Rhc2stPmN1cnJlbnQgbWlnaHQgYmUgY2xlYXJlZCAoYW5kIGV2ZW50IGZyZWVkKSBpbiB0aGlzIHZlcnkgY2FsbCEgKi8KICAgICAgRE9TVk1fU2ltdWxhdGVJbnQoKGV2ZW50LT5pcnE8OCk/KGV2ZW50LT5pcnErOCk6KGV2ZW50LT5pcnEtOCsweDcwKSxjb250ZXh0LGxwRG9zVGFzayk7CiAgICB9IGVsc2UgewogICAgICAvKiBjYWxsYmFjayBldmVudCAqLwogICAgICBUUkFDRV8oaW50KSgiZGlzcGF0Y2hpbmcgY2FsbGJhY2sgZXZlbnRcbiIpOwogICAgICAoKmV2ZW50LT5yZWxheSkobHBEb3NUYXNrLGNvbnRleHQsZXZlbnQtPmRhdGEpOwogICAgICBmcmVlKGV2ZW50KTsKICAgIH0KICB9CiAgaWYgKCFTSE9VTERfUEVORChscERvc1Rhc2stPnBlbmRpbmcpKSB7CiAgICBUUkFDRV8oaW50KSgiY2xlYXJpbmcgUGVuZGluZyBmbGFnXG4iKTsKICAgIENMUl9QRU5EKGNvbnRleHQpOwogIH0KfQoKc3RhdGljIHZvaWQgRE9TVk1fU2VuZFF1ZXVlZEV2ZW50cyhDT05URVhUODYgKmNvbnRleHQsIExQRE9TVEFTSyBscERvc1Rhc2spCnsKICAvKiB3ZSB3aWxsIHNlbmQgYWxsIHF1ZXVlZCBldmVudHMgYXMgbG9uZyBhcyBpbnRlcnJ1cHRzIGFyZSBlbmFibGVkLAogICAqIGJ1dCBJUlEgZXZlbnRzIHdpbGwgZGlzYWJsZSBpbnRlcnJ1cHRzIGFnYWluICovCiAgd2hpbGUgKElTX1BFTkQoY29udGV4dCkgJiYgSUZfRU5BQkxFRChjb250ZXh0KSkKICAgIERPU1ZNX1NlbmRRdWV1ZWRFdmVudChjb250ZXh0LGxwRG9zVGFzayk7Cn0KCnZvaWQgRE9TVk1fUXVldWVFdmVudCggaW50IGlycSwgaW50IHByaW9yaXR5LCB2b2lkICgqcmVsYXkpKExQRE9TVEFTSyxDT05URVhUODYqLHZvaWQqKSwgdm9pZCAqZGF0YSkKewogIExQRE9TVEFTSyBscERvc1Rhc2sgPSBNWl9DdXJyZW50KCk7CiAgTFBET1NFVkVOVCBldmVudCwgY3VyLCBwcmV2OwoKICBpZiAobHBEb3NUYXNrKSB7CiAgICBldmVudCA9IG1hbGxvYyhzaXplb2YoRE9TRVZFTlQpKTsKICAgIGlmICghZXZlbnQpIHsKICAgICAgRVJSXyhpbnQpKCJvdXQgb2YgbWVtb3J5IGFsbG9jYXRpbmcgZXZlbnQgZW50cnlcbiIpOwogICAgICByZXR1cm47CiAgICB9CiAgICBldmVudC0+aXJxID0gaXJxOyBldmVudC0+cHJpb3JpdHkgPSBwcmlvcml0eTsKICAgIGV2ZW50LT5yZWxheSA9IHJlbGF5OyBldmVudC0+ZGF0YSA9IGRhdGE7CgogICAgLyogaW5zZXJ0IGV2ZW50IGludG8gbGlua2VkIGxpc3QsIGluIG9yZGVyICphZnRlcioKICAgICAqIGFsbCBlYXJsaWVyIGV2ZW50cyBvZiBoaWdoZXIgb3IgZXF1YWwgcHJpb3JpdHkgKi8KICAgIGN1ciA9IGxwRG9zVGFzay0+cGVuZGluZzsgcHJldiA9IE5VTEw7CiAgICB3aGlsZSAoY3VyICYmIGN1ci0+cHJpb3JpdHk8PXByaW9yaXR5KSB7CiAgICAgIHByZXYgPSBjdXI7CiAgICAgIGN1ciA9IGN1ci0+bmV4dDsKICAgIH0KICAgIGV2ZW50LT5uZXh0ID0gY3VyOwogICAgaWYgKHByZXYpIHByZXYtPm5leHQgPSBldmVudDsKICAgIGVsc2UgbHBEb3NUYXNrLT5wZW5kaW5nID0gZXZlbnQ7CiAgICAKICAgIC8qIGdldCBkb3Ntb2QncyBhdHRlbnRpb24gdG8gdGhlIG5ldyBldmVudCwgZXhjZXB0IGZvciBpcnE9PTAgd2hlcmUgd2UgYWxyZWFkeSBoYXZlIGl0ICovCiAgICBpZiAoaXJxICYmICFscERvc1Rhc2stPnNpZ19zZW50KSB7CiAgICAgIFRSQUNFXyhpbnQpKCJuZXcgZXZlbnQgcXVldWVkLCBzaWduYWxsaW5nIGRvc21vZFxuIik7CiAgICAgIGtpbGwobHBEb3NUYXNrLT50YXNrLFNJR1VTUjIpOwogICAgICBscERvc1Rhc2stPnNpZ19zZW50Kys7CiAgICB9IGVsc2UgewogICAgICBUUkFDRV8oaW50KSgibmV3IGV2ZW50IHF1ZXVlZFxuIik7CiAgICB9CiAgfQp9CgojZGVmaW5lIENWIENQKGVheCxFQVgpOyBDUChlY3gsRUNYKTsgQ1AoZWR4LEVEWCk7IENQKGVieCxFQlgpOyBcCiAgICAgICAgICAgQ1AoZXNpLEVTSSk7IENQKGVkaSxFREkpOyBDUChlc3AsRVNQKTsgQ1AoZWJwLEVCUCk7IFwKICAgICAgICAgICBDUChjcyxDUyk7IENQKGRzLERTKTsgQ1AoZXMsRVMpOyBcCiAgICAgICAgICAgQ1Aoc3MsU1MpOyBDUChmcyxGUyk7IENQKGdzLEdTKTsgXAogICAgICAgICAgIENQKGVpcCxFSVApOyBDUChlZmxhZ3MsRUZMKQoKc3RhdGljIGludCBET1NWTV9Qcm9jZXNzKCBMUERPU1RBU0sgbHBEb3NUYXNrLCBpbnQgZm4sIGludCBzaWcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHZtODZwbHVzX3N0cnVjdCpWTTg2ICkKewogQ09OVEVYVDg2IGNvbnRleHQ7CiBpbnQgcmV0PTA7CgojZGVmaW5lIENQKHgseSkgeSMjX3JlZygmY29udGV4dCkgPSBWTTg2LT5yZWdzLngKICBDVjsKI3VuZGVmIENQCiBpZiAoVk04Nl9UWVBFKGZuKT09Vk04Nl9VTktOT1dOKSB7CiAgcmV0PUlOU1RSX0VtdWxhdGVJbnN0cnVjdGlvbigmY29udGV4dCk7CiNkZWZpbmUgQ1AoeCx5KSBWTTg2LT5yZWdzLnggPSB5IyNfcmVnKCZjb250ZXh0KQogIENWOwojdW5kZWYgQ1AKICBpZiAocmV0KSByZXR1cm4gMDsKICByZXQ9MDsKIH0KI2lmZGVmIFRSWV9QSUNSRVRVUk4KIGlmIChWTTg2LT52bTg2cGx1cy5mb3JjZV9yZXR1cm5fZm9yX3BpYykgewogICBTRVRfUEVORCgmY29udGV4dCk7CiB9CiNlbHNlCiAvKiBsaW51eCBkb2Vzbid0IHByZXNlcnZlIHBlbmRpbmcgZmxhZyBvbiByZXR1cm4gKi8KIGlmIChTSE9VTERfUEVORChscERvc1Rhc2stPnBlbmRpbmcpKSB7CiAgIFNFVF9QRU5EKCZjb250ZXh0KTsKIH0KI2VuZGlmCgogc3dpdGNoIChWTTg2X1RZUEUoZm4pKSB7CiAgY2FzZSBWTTg2X1NJR05BTDoKICAgVFJBQ0VfKGludCkoIkRPUyBtb2R1bGUgY2F1Z2h0IHNpZ25hbCAlZFxuIixzaWcpOwogICBpZiAoKHNpZz09U0lHQUxSTSkgfHwgKHNpZz09U0lHVVNSMikpIHsKICAgICBpZiAoc2lnPT1TSUdBTFJNKSB7CiAgICAgICBET1NWTV9RdWV1ZUV2ZW50KDAsRE9TX1BSSU9SSVRZX1JFQUxUSU1FLE5VTEwsTlVMTCk7CiAgICAgfQogICAgIGlmIChscERvc1Rhc2stPnBlbmRpbmcpIHsKICAgICAgIFRSQUNFXyhpbnQpKCJzZXR0aW5nIFBlbmRpbmcgZmxhZywgaW50ZXJydXB0cyBhcmUgY3VycmVudGx5ICVzXG4iLAogICAgICAgICAgICAgICAgIElGX0VOQUJMRUQoJmNvbnRleHQpID8gImVuYWJsZWQiIDogImRpc2FibGVkIik7CiAgICAgICBTRVRfUEVORCgmY29udGV4dCk7CiAgICAgICBET1NWTV9TZW5kUXVldWVkRXZlbnRzKCZjb250ZXh0LGxwRG9zVGFzayk7CiAgICAgfSBlbHNlIHsKICAgICAgIFRSQUNFXyhpbnQpKCJubyBldmVudHMgYXJlIHBlbmRpbmcsIGNsZWFyaW5nIFBlbmRpbmcgZmxhZ1xuIik7CiAgICAgICBDTFJfUEVORCgmY29udGV4dCk7CiAgICAgfQogICAgIGlmIChzaWc9PVNJR1VTUjIpIGxwRG9zVGFzay0+c2lnX3NlbnQtLTsKICAgfQogICBlbHNlIGlmICgoc2lnPT1TSUdIVVApIHx8IChzaWc9PVNJR0lMTCkgfHwgKHNpZz09U0lHU0VHVikpIHsKICAgICAgIGRvX2V4Y2VwdGlvbiggc2lnLCAmY29udGV4dCApOwogICB9IGVsc2UgewogICAgRE9TVk1fRHVtcChscERvc1Rhc2ssZm4sc2lnLFZNODYpOwogICAgcmV0PS0xOwogICB9CiAgIGJyZWFrOwogIGNhc2UgVk04Nl9VTktOT1dOOiAvKiB1bmhhbmRsZWQgR1BGICovCiAgIERPU1ZNX0R1bXAobHBEb3NUYXNrLGZuLHNpZyxWTTg2KTsKICAgZG9fZXhjZXB0aW9uKCBTSUdTRUdWLCAmY29udGV4dCApOwogICBicmVhazsKICBjYXNlIFZNODZfSU5UeDoKICAgaWYgKFRSQUNFX09OKHJlbGF5KSkKICAgIERQUklOVEYoIkNhbGwgRE9TIGludCAweCUwMnggKEVBWD0lMDhseCkgcmV0PSUwNGx4OiUwNGx4XG4iLFZNODZfQVJHKGZuKSxjb250ZXh0LkVheCxjb250ZXh0LlNlZ0NzLGNvbnRleHQuRWlwKTsKICAgcmV0PURPU1ZNX0ludChWTTg2X0FSRyhmbiksJmNvbnRleHQsbHBEb3NUYXNrKTsKICAgaWYgKFRSQUNFX09OKHJlbGF5KSkKICAgIERQUklOVEYoIlJldCAgRE9TIGludCAweCUwMnggKEVBWD0lMDhseCkgcmV0PSUwNGx4OiUwNGx4XG4iLFZNODZfQVJHKGZuKSxjb250ZXh0LkVheCxjb250ZXh0LlNlZ0NzLGNvbnRleHQuRWlwKTsKICAgYnJlYWs7CiAgY2FzZSBWTTg2X1NUSToKICBjYXNlIFZNODZfUElDUkVUVVJOOgogICAgVFJBQ0VfKGludCkoIkRPUyB0YXNrIGVuYWJsZWQgaW50ZXJydXB0cyB3aXRoIGV2ZW50cyBwZW5kaW5nLCBzZW5kaW5nIGV2ZW50c1xuIik7CiAgICBET1NWTV9TZW5kUXVldWVkRXZlbnRzKCZjb250ZXh0LGxwRG9zVGFzayk7CiAgICBicmVhazsKICBjYXNlIFZNODZfVFJBUDoKICAgZG9fZXhjZXB0aW9uKCBTSUdUUkFQLCAmY29udGV4dCApOwogICBicmVhazsKICBkZWZhdWx0OgogICBET1NWTV9EdW1wKGxwRG9zVGFzayxmbixzaWcsVk04Nik7CiAgIHJldD0tMTsKIH0KCiNkZWZpbmUgQ1AoeCx5KSBWTTg2LT5yZWdzLnggPSB5IyNfcmVnKCZjb250ZXh0KQogQ1Y7CiN1bmRlZiBDUAojaWZkZWYgVFJZX1BJQ1JFVFVSTgogVk04Ni0+dm04NnBsdXMuZm9yY2VfcmV0dXJuX2Zvcl9waWMgPSBJU19QRU5EKCZjb250ZXh0KSA/IDEgOiAwOwogQ0xSX1BFTkQoJmNvbnRleHQpOwojZW5kaWYKIHJldHVybiByZXQ7Cn0KCnZvaWQgRE9TVk1fUHJvY2Vzc01lc3NhZ2UoTFBET1NUQVNLIGxwRG9zVGFzayxNU0cgKm1zZykKewogIEJZVEUgc2NhbiA9IDA7CgogIGZwcmludGYoc3RkZXJyLCJnb3QgbWVzc2FnZSAlMDR4LCB3cGFyYW09JTA4eCwgbHBhcmFtPSUwOGx4XG4iLG1zZy0+bWVzc2FnZSxtc2ctPndQYXJhbSxtc2ctPmxQYXJhbSk7CiAgaWYgKChtc2ctPm1lc3NhZ2U+PVdNX01PVVNFRklSU1QpJiYKICAgICAgKG1zZy0+bWVzc2FnZTw9V01fTU9VU0VMQVNUKSkgewogICAgSU5UX0ludDMzTWVzc2FnZShtc2ctPm1lc3NhZ2UsbXNnLT53UGFyYW0sbXNnLT5sUGFyYW0pOwogIH0gZWxzZSB7CiAgICBzd2l0Y2ggKG1zZy0+bWVzc2FnZSkgewogICAgY2FzZSBXTV9LRVlVUDoKICAgICAgc2NhbiA9IDB4ODA7CiAgICBjYXNlIFdNX0tFWURPV046CiAgICAgIHNjYW4gfD0gKG1zZy0+bFBhcmFtID4+IDE2KSAmIDB4N2Y7CgogICAgICAvKiBjaGVjayB3aGV0aGVyIGV4dGVuZGVkIGJpdCBpcyBzZXQsCiAgICAgICAqIGFuZCBpZiBzbywgcXVldWUgdGhlIGV4dGVuc2lvbiBwcmVmaXggKi8KICAgICAgaWYgKG1zZy0+bFBhcmFtICYgMHgxMDAwMDAwKSB7CgkvKiBGSVhNRTogc29tZSBrZXlzIChmdW5jdGlvbiBrZXlzKSBoYXZlCgkgKiBleHRlbmRlZCBiaXQgc2V0IGV2ZW4gd2hlbiB0aGV5IHNob3VsZG4ndCwKCSAqIHNob3VsZCBjaGVjayBmb3IgdGhlbSAqLwoJSU5UX0ludDA5U2VuZFNjYW4oMHhFMCwwKTsKICAgICAgfQogICAgICBJTlRfSW50MDlTZW5kU2NhbihzY2FuLDApOwogICAgICBicmVhazsKICAgIH0KICB9Cn0KCnZvaWQgRE9TVk1fV2FpdCggaW50IHJlYWRfcGlwZSwgSEFORExFIGhPYmplY3QgKQp7CiAgTFBET1NUQVNLIGxwRG9zVGFzayA9IE1aX0N1cnJlbnQoKTsKICBNU0cgbXNnOwogIERXT1JEIHdhaXRyZXQ7CiAgQk9PTCBnb3RfbXNnID0gRkFMU0U7CgogIGRvIHsKICAgIC8qIGNoZWNrIGZvciBtZXNzYWdlcyAod2FzdGUgdGltZSBiZWZvcmUgdGhlIHJlc3BvbnNlIGNoZWNrIGJlbG93KSAqLwogICAgd2hpbGUgKENhbGxvdXQuUGVla01lc3NhZ2VBKCZtc2csMCwwLDAsUE1fUkVNT1ZFfFBNX05PWUlFTEQpKSB7CiAgICAgIC8qIGdvdCBhIG1lc3NhZ2UgKi8KICAgICAgRE9TVk1fUHJvY2Vzc01lc3NhZ2UobHBEb3NUYXNrLCZtc2cpOwogICAgICAvKiB3ZSBkb24ndCBuZWVkIGEgVHJhbnNsYXRlTWVzc2FnZSBoZXJlICovCiAgICAgIENhbGxvdXQuRGlzcGF0Y2hNZXNzYWdlQSgmbXNnKTsKICAgICAgZ290X21zZyA9IFRSVUU7CiAgICB9CiAgICBpZiAocmVhZF9waXBlID09IC0xKSB7CiAgICAgIGlmIChnb3RfbXNnKSBicmVhazsKICAgIH0gZWxzZSB7CiAgICAgIGZkX3NldCByZWFkZmRzOwogICAgICBzdHJ1Y3QgdGltZXZhbCB0aW1lb3V0PXswLDB9OwogICAgICAvKiBxdWljayBjaGVjayBmb3IgcmVzcG9uc2UgZnJvbSBkb3Ntb2QKICAgICAgICogKGZhc3RlciB0aGFuIGRvaW5nIHRoZSBmdWxsIGJsb2NraW5nIHdhaXQsIGlmIGRhdGEgYWxyZWFkeSBhdmFpbGFibGUpICovCiAgICAgIEZEX1pFUk8oJnJlYWRmZHMpOyBGRF9TRVQocmVhZF9waXBlLCZyZWFkZmRzKTsKICAgICAgaWYgKHNlbGVjdChyZWFkX3BpcGUrMSwmcmVhZGZkcyxOVUxMLE5VTEwsJnRpbWVvdXQpPjApCglicmVhazsKICAgIH0KICAgIC8qIGNoZWNrIGZvciBkYXRhIGZyb20gd2luMzIgY29uc29sZSBkZXZpY2UgKi8KCiAgICAvKiBub3RoaW5nIHlldCwgYmxvY2sgd2hpbGUgd2FpdGluZyBmb3Igc29tZXRoaW5nIHRvIGRvICovCiAgICB3YWl0cmV0PU1zZ1dhaXRGb3JNdWx0aXBsZU9iamVjdHMoMSwmaE9iamVjdCxGQUxTRSxJTkZJTklURSxRU19BTExJTlBVVCk7CiAgICBpZiAod2FpdHJldD09KERXT1JEKS0xKSB7CiAgICAgIEVSUl8obW9kdWxlKSgiZG9zdm0gd2FpdCBlcnJvcj0lbGRcbiIsR2V0TGFzdEVycm9yKCkpOwogICAgfQogICAgaWYgKHJlYWRfcGlwZSAhPSAtMSkgewogICAgICBpZiAod2FpdHJldD09V0FJVF9PQkpFQ1RfMCkgYnJlYWs7CiAgICB9CiAgfSB3aGlsZSAoVFJVRSk7Cn0KCmludCBET1NWTV9FbnRlciggQ09OVEVYVDg2ICpjb250ZXh0ICkKewogTFBET1NUQVNLIGxwRG9zVGFzayA9IE1aX0N1cnJlbnQoKTsKIHN0cnVjdCB2bTg2cGx1c19zdHJ1Y3QgVk04NjsKIGludCBzdGF0LGxlbixzaWc7CgogaWYgKCFscERvc1Rhc2spIHsKICAvKiBNWl9DcmVhdGVQcm9jZXNzIG9yIE1aX0FsbG9jRFBNSVRhc2sgc2hvdWxkIGhhdmUgYmVlbiBjYWxsZWQgZmlyc3QgKi8KICBFUlJfKG1vZHVsZSkoImRvc21vZCBoYXMgbm90IGJlZW4gaW5pdGlhbGl6ZWQhIik7CiAgcmV0dXJuIC0xOwogfQoKIGlmIChjb250ZXh0KSB7CiNkZWZpbmUgQ1AoeCx5KSBWTTg2LnJlZ3MueCA9IHkjI19yZWcoY29udGV4dCkKICBDVjsKI3VuZGVmIENQCiAgaWYgKFZNODYucmVncy5lZmxhZ3MgJiBJRl9NQVNLKQogICAgVk04Ni5yZWdzLmVmbGFncyB8PSBWSUZfTUFTSzsKIH0gZWxzZSB7Ci8qIGluaXRpYWwgc2V0dXAgKi8KICAvKiBhbGxvY2F0ZSBzdGFuZGFyZCBET1MgaGFuZGxlcyAqLwogIEZJTEVfSW5pdFByb2Nlc3NEb3NIYW5kbGVzKCk7IAogIC8qIHJlZ2lzdGVycyAqLwogIG1lbXNldCgmVk04NiwwLHNpemVvZihWTTg2KSk7CiAgVk04Ni5yZWdzLmNzPWxwRG9zVGFzay0+aW5pdF9jczsKICBWTTg2LnJlZ3MuZWlwPWxwRG9zVGFzay0+aW5pdF9pcDsKICBWTTg2LnJlZ3Muc3M9bHBEb3NUYXNrLT5pbml0X3NzOwogIFZNODYucmVncy5lc3A9bHBEb3NUYXNrLT5pbml0X3NwOwogIFZNODYucmVncy5kcz1scERvc1Rhc2stPnBzcF9zZWc7CiAgVk04Ni5yZWdzLmVzPWxwRG9zVGFzay0+cHNwX3NlZzsKICBWTTg2LnJlZ3MuZWZsYWdzPVZJRl9NQVNLOwogIC8qIGhtbSwgd2hhdCBlbHNlIGRvIHdlIG5lZWQ/ICovCiB9CgogLyogbWFpbiBleGNoYW5nZSBsb29wICovCiBkbyB7CiAgc3RhdCA9IFZNODZfRU5URVI7CiAgZXJybm8gPSAwOwogIC8qIHRyYW5zbWl0IFZNODYgc3RydWN0dXJlIHRvIGRvc21vZCB0YXNrICovCiAgaWYgKHdyaXRlKGxwRG9zVGFzay0+d3JpdGVfcGlwZSwmc3RhdCxzaXplb2Yoc3RhdCkpIT1zaXplb2Yoc3RhdCkpIHsKICAgRVJSXyhtb2R1bGUpKCJkb3Ntb2Qgc3luYyBsb3N0LCBlcnJubz0lZCwgZmQ9JWQsIHBpZD0lZFxuIixlcnJubyxscERvc1Rhc2stPndyaXRlX3BpcGUsZ2V0cGlkKCkpOwogICByZXR1cm4gLTE7CiAgfQogIGlmICh3cml0ZShscERvc1Rhc2stPndyaXRlX3BpcGUsJlZNODYsc2l6ZW9mKFZNODYpKSE9c2l6ZW9mKFZNODYpKSB7CiAgIEVSUl8obW9kdWxlKSgiZG9zbW9kIHN5bmMgbG9zdCwgZXJybm89JWRcbiIsZXJybm8pOwogICByZXR1cm4gLTE7CiAgfQogIC8qIHdhaXQgZm9yIHJlc3BvbnNlLCBkb2luZyBvdGhlciB0aGluZ3MgaW4gdGhlIG1lYW50aW1lICovCiAgRE9TVk1fV2FpdChscERvc1Rhc2stPnJlYWRfcGlwZSwgbHBEb3NUYXNrLT5oUmVhZFBpcGUpOwogIC8qIHJlYWQgcmVzcG9uc2UgKi8KICB3aGlsZSAoMSkgewogICAgaWYgKChsZW49cmVhZChscERvc1Rhc2stPnJlYWRfcGlwZSwmc3RhdCxzaXplb2Yoc3RhdCkpKT09c2l6ZW9mKHN0YXQpKSBicmVhazsKICAgIGlmICgoKGVycm5vPT1FSU5UUil8fChlcnJubz09RUFHQUlOKSkmJihsZW48PTApKSB7CiAgICAgV0FSTl8obW9kdWxlKSgicmVyZWFkaW5nIGRvc21vZCByZXR1cm4gY29kZSBkdWUgdG8gZXJybm89JWQsIHJlc3VsdD0lZFxuIixlcnJubyxsZW4pOwogICAgIGNvbnRpbnVlOwogICAgfQogICAgRVJSXyhtb2R1bGUpKCJkb3Ntb2Qgc3luYyBsb3N0IHJlYWRpbmcgcmV0dXJuIGNvZGUsIGVycm5vPSVkLCByZXN1bHQ9JWRcbiIsZXJybm8sbGVuKTsKICAgIHJldHVybiAtMTsKICB9CiAgVFJBQ0VfKG1vZHVsZSkoImRvc21vZCByZXR1cm4gY29kZT0lZFxuIixzdGF0KTsKICB3aGlsZSAoMSkgewogICAgaWYgKChsZW49cmVhZChscERvc1Rhc2stPnJlYWRfcGlwZSwmVk04NixzaXplb2YoVk04NikpKT09c2l6ZW9mKFZNODYpKSBicmVhazsKICAgIGlmICgoKGVycm5vPT1FSU5UUil8fChlcnJubz09RUFHQUlOKSkmJihsZW48PTApKSB7CiAgICAgV0FSTl8obW9kdWxlKSgicmVyZWFkaW5nIGRvc21vZCBWTTg2IHN0cnVjdHVyZSBkdWUgdG8gZXJybm89JWQsIHJlc3VsdD0lZFxuIixlcnJubyxsZW4pOwogICAgIGNvbnRpbnVlOwogICAgfQogICAgRVJSXyhtb2R1bGUpKCJkb3Ntb2Qgc3luYyBsb3N0IHJlYWRpbmcgVk04NiBzdHJ1Y3R1cmUsIGVycm5vPSVkLCByZXN1bHQ9JWRcbiIsZXJybm8sbGVuKTsKICAgIHJldHVybiAtMTsKICB9CiAgaWYgKChzdGF0JjB4ZmYpPT1ET1NNT0RfU0lHTkFMKSB7CiAgICB3aGlsZSAoMSkgewogICAgICBpZiAoKGxlbj1yZWFkKGxwRG9zVGFzay0+cmVhZF9waXBlLCZzaWcsc2l6ZW9mKHNpZykpKT09c2l6ZW9mKHNpZykpIGJyZWFrOwogICAgICBpZiAoKChlcnJubz09RUlOVFIpfHwoZXJybm89PUVBR0FJTikpJiYobGVuPD0wKSkgewoJV0FSTl8obW9kdWxlKSgicmVyZWFkaW5nIGRvc21vZCBzaWduYWwgZHVlIHRvIGVycm5vPSVkLCByZXN1bHQ9JWRcbiIsZXJybm8sbGVuKTsKCWNvbnRpbnVlOwogICAgICB9CiAgICAgIEVSUl8obW9kdWxlKSgiZG9zbW9kIHN5bmMgbG9zdCByZWFkaW5nIHNpZ25hbCwgZXJybm89JWQsIHJlc3VsdD0lZFxuIixlcnJubyxsZW4pOwogICAgICByZXR1cm4gLTE7CiAgICB9IHdoaWxlICgwKTsKICB9IGVsc2Ugc2lnPTA7CiAgLyogZ290IHJlc3BvbnNlICovCiB9IHdoaWxlIChET1NWTV9Qcm9jZXNzKGxwRG9zVGFzayxzdGF0LHNpZywmVk04Nik+PTApOwoKIGlmIChjb250ZXh0KSB7CiNkZWZpbmUgQ1AoeCx5KSB5IyNfcmVnKGNvbnRleHQpID0gVk04Ni5yZWdzLngKICBDVjsKI3VuZGVmIENQCiB9CiByZXR1cm4gMDsKfQoKdm9pZCBET1NWTV9QSUNfaW9wb3J0X291dCggV09SRCBwb3J0LCBCWVRFIHZhbCkKewogIExQRE9TVEFTSyBscERvc1Rhc2sgPSBNWl9DdXJyZW50KCk7CiAgTFBET1NFVkVOVCBldmVudDsKCiAgaWYgKGxwRG9zVGFzaykgewogICAgaWYgKChwb3J0PT0weDIwKSAmJiAodmFsPT0weDIwKSkgewogICAgICBpZiAobHBEb3NUYXNrLT5jdXJyZW50KSB7CgkvKiBFT0kgKEVuZCBPZiBJbnRlcnJ1cHQpICovCglUUkFDRV8oaW50KSgicmVjZWl2ZWQgRU9JIGZvciBjdXJyZW50IElSUSwgY2xlYXJpbmdcbiIpOwoJZXZlbnQgPSBscERvc1Rhc2stPmN1cnJlbnQ7CglscERvc1Rhc2stPmN1cnJlbnQgPSBldmVudC0+bmV4dDsKCWlmIChldmVudC0+cmVsYXkpCgkoKmV2ZW50LT5yZWxheSkobHBEb3NUYXNrLE5VTEwsZXZlbnQtPmRhdGEpOwoJZnJlZShldmVudCk7CgoJaWYgKGxwRG9zVGFzay0+cGVuZGluZyAmJgoJICAgICFscERvc1Rhc2stPnNpZ19zZW50KSB7CgkgIC8qIGFub3RoZXIgZXZlbnQgaXMgcGVuZGluZywgd2hpY2ggd2Ugc2hvdWxkIHByb2JhYmx5CgkgICAqIGJlIGFibGUgdG8gcHJvY2VzcyBub3csIHNvIHRlbGwgZG9zbW9kIGFib3V0IGl0ICovCgkgIFRSQUNFXyhpbnQpKCJhbm90aGVyIGV2ZW50IHBlbmRpbmcsIHNpZ25hbGxpbmcgZG9zbW9kXG4iKTsKCSAga2lsbChscERvc1Rhc2stPnRhc2ssU0lHVVNSMik7CgkgIGxwRG9zVGFzay0+c2lnX3NlbnQrKzsKCX0KICAgICAgfSBlbHNlIHsKCVdBUk5fKGludCkoIkVPSSB3aXRob3V0IGFjdGl2ZSBJUlFcbiIpOwogICAgICB9CiAgICB9IGVsc2UgewogICAgICBGSVhNRV8oaW50KSgidW5yZWNvZ25pemVkIFBJQyBjb21tYW5kICUwMnhcbiIsdmFsKTsKICAgIH0KICB9Cn0KCnZvaWQgRE9TVk1fU2V0VGltZXIoIHVuc2lnbmVkIHRpY2tzICkKewogIExQRE9TVEFTSyBscERvc1Rhc2sgPSBNWl9DdXJyZW50KCk7CiAgaW50IHN0YXQ9RE9TTU9EX1NFVF9USU1FUjsKICBzdHJ1Y3QgdGltZXZhbCB0aW07CgogIGlmIChscERvc1Rhc2spIHsKICAgIC8qIHRoZSBQQyBjbG9ja3MgdGlja3MgYXQgMTE5MzE4MCBIeiAqLwogICAgdGltLnR2X3NlYz0wOwogICAgdGltLnR2X3VzZWM9KCh1bnNpZ25lZCBsb25nIGxvbmcpdGlja3MqMTAwMDAwMCkvMTE5MzE4MDsKICAgIC8qIHNhbml0eSBjaGVjayAqLwogICAgaWYgKCF0aW0udHZfdXNlYykgdGltLnR2X3VzZWM9MTsKCiAgICBpZiAod3JpdGUobHBEb3NUYXNrLT53cml0ZV9waXBlLCZzdGF0LHNpemVvZihzdGF0KSkhPXNpemVvZihzdGF0KSkgewogICAgICBFUlJfKG1vZHVsZSkoImRvc21vZCBzeW5jIGxvc3QsIGVycm5vPSVkXG4iLGVycm5vKTsKICAgICAgcmV0dXJuOwogICAgfQogICAgaWYgKHdyaXRlKGxwRG9zVGFzay0+d3JpdGVfcGlwZSwmdGltLHNpemVvZih0aW0pKSE9c2l6ZW9mKHRpbSkpIHsKICAgICAgRVJSXyhtb2R1bGUpKCJkb3Ntb2Qgc3luYyBsb3N0LCBlcnJubz0lZFxuIixlcnJubyk7CiAgICAgIHJldHVybjsKICAgIH0KICAgIC8qIHRoZXJlJ3Mgbm8gcmV0dXJuICovCiAgfQp9Cgp1bnNpZ25lZCBET1NWTV9HZXRUaW1lciggdm9pZCApCnsKICBMUERPU1RBU0sgbHBEb3NUYXNrID0gTVpfQ3VycmVudCgpOwogIGludCBzdGF0PURPU01PRF9HRVRfVElNRVI7CiAgc3RydWN0IHRpbWV2YWwgdGltOwoKICBpZiAobHBEb3NUYXNrKSB7CiAgICBpZiAod3JpdGUobHBEb3NUYXNrLT53cml0ZV9waXBlLCZzdGF0LHNpemVvZihzdGF0KSkhPXNpemVvZihzdGF0KSkgewogICAgICBFUlJfKG1vZHVsZSkoImRvc21vZCBzeW5jIGxvc3QsIGVycm5vPSVkXG4iLGVycm5vKTsKICAgICAgcmV0dXJuIDA7CiAgICB9CiAgICAvKiByZWFkIHJlc3BvbnNlICovCiAgICB3aGlsZSAoMSkgewogICAgICBpZiAocmVhZChscERvc1Rhc2stPnJlYWRfcGlwZSwmdGltLHNpemVvZih0aW0pKT09c2l6ZW9mKHRpbSkpIGJyZWFrOwogICAgICBpZiAoKGVycm5vPT1FSU5UUil8fChlcnJubz09RUFHQUlOKSkgY29udGludWU7CiAgICAgIEVSUl8obW9kdWxlKSgiZG9zbW9kIHN5bmMgbG9zdCwgZXJybm89JWRcbiIsZXJybm8pOwogICAgICByZXR1cm4gMDsKICAgIH0KICAgIHJldHVybiAoKHVuc2lnbmVkIGxvbmcgbG9uZyl0aW0udHZfdXNlYyoxMTkzMTgwKS8xMDAwMDAwOwogIH0KICByZXR1cm4gMDsKfQoKdm9pZCBET1NWTV9TZXRTeXN0ZW1EYXRhKCBpbnQgaWQsIHZvaWQgKmRhdGEgKQp7CiAgTFBET1NUQVNLIGxwRG9zVGFzayA9IE1aX0N1cnJlbnQoKTsKICBET1NTWVNURU0gKnN5cywgKnByZXY7CgogIGlmIChscERvc1Rhc2spIHsKICAgIHN5cyA9IGxwRG9zVGFzay0+c3lzOwogICAgcHJldiA9IE5VTEw7CiAgICB3aGlsZSAoc3lzICYmIChzeXMtPmlkICE9IGlkKSkgewogICAgICBwcmV2ID0gc3lzOwogICAgICBzeXMgPSBzeXMtPm5leHQ7CiAgICB9CiAgICBpZiAoc3lzKSB7CiAgICAgIGZyZWUoc3lzLT5kYXRhKTsKICAgICAgc3lzLT5kYXRhID0gZGF0YTsKICAgIH0gZWxzZSB7CiAgICAgIHN5cyA9IG1hbGxvYyhzaXplb2YoRE9TU1lTVEVNKSk7CiAgICAgIHN5cy0+aWQgPSBpZDsKICAgICAgc3lzLT5kYXRhID0gZGF0YTsKICAgICAgc3lzLT5uZXh0ID0gTlVMTDsKICAgICAgaWYgKHByZXYpIHByZXYtPm5leHQgPSBzeXM7CiAgICAgIGVsc2UgbHBEb3NUYXNrLT5zeXMgPSBzeXM7CiAgICB9CiAgfSBlbHNlIGZyZWUoZGF0YSk7Cn0KCnZvaWQqIERPU1ZNX0dldFN5c3RlbURhdGEoIGludCBpZCApCnsKICBMUERPU1RBU0sgbHBEb3NUYXNrID0gTVpfQ3VycmVudCgpOwogIERPU1NZU1RFTSAqc3lzOwoKICBpZiAobHBEb3NUYXNrKSB7CiAgICBzeXMgPSBscERvc1Rhc2stPnN5czsKICAgIHdoaWxlIChzeXMgJiYgKHN5cy0+aWQgIT0gaWQpKQogICAgICBzeXMgPSBzeXMtPm5leHQ7CiAgICBpZiAoc3lzKQogICAgICByZXR1cm4gc3lzLT5kYXRhOwogIH0KICByZXR1cm4gTlVMTDsKfQoKI2Vsc2UgLyogIU1aX1NVUFBPUlRFRCAqLwoKaW50IERPU1ZNX0VudGVyKCBDT05URVhUODYgKmNvbnRleHQgKQp7CiBFUlJfKG1vZHVsZSkoIkRPUyByZWFsbW9kZSBub3Qgc3VwcG9ydGVkIG9uIHRoaXMgYXJjaGl0ZWN0dXJlIVxuIik7CiByZXR1cm4gLTE7Cn0KCnZvaWQgRE9TVk1fV2FpdCggaW50IHJlYWRfcGlwZSwgSEFORExFIGhPYmplY3QpIHt9CnZvaWQgRE9TVk1fUElDX2lvcG9ydF9vdXQoIFdPUkQgcG9ydCwgQllURSB2YWwpIHt9CnZvaWQgRE9TVk1fU2V0VGltZXIoIHVuc2lnbmVkIHRpY2tzICkge30KdW5zaWduZWQgRE9TVk1fR2V0VGltZXIoIHZvaWQgKSB7IHJldHVybiAwOyB9CnZvaWQgRE9TVk1fU2V0U3lzdGVtRGF0YSggaW50IGlkLCB2b2lkICpkYXRhICkgeyBmcmVlKGRhdGEpOyB9CnZvaWQqIERPU1ZNX0dldFN5c3RlbURhdGEoIGludCBpZCApIHsgcmV0dXJuIE5VTEw7IH0Kdm9pZCBET1NWTV9RdWV1ZUV2ZW50KCBpbnQgaXJxLCBpbnQgcHJpb3JpdHksIHZvaWQgKCpyZWxheSkoTFBET1NUQVNLLENPTlRFWFQ4Niosdm9pZCopLCB2b2lkICpkYXRhKSB7fQoKI2VuZGlmCg==