ZGlmZiAtLWdpdCBhL3N0ZC90aGluZy9jb21tYW5kcy5jIGIvc3RkL3RoaW5nL2NvbW1hbmRzLmMKaW5kZXggODEzNGY0Yi4uYTFhYTA3OSAxMDA2NDQKLS0tIGEvc3RkL3RoaW5nL2NvbW1hbmRzLmMKKysrIGIvc3RkL3RoaW5nL2NvbW1hbmRzLmMKQEAgLTExLDIyICsxMSwyOSBAQAogLy8KIC8vIEFkZENtZCh2ZXJiLGZ1bjEsMSk7CiAvLyBBZGRDbWQodmVyYitzeW4xYXxzeW4xYiZzeW4yYXxzeW4yYnxzeW4yYyxmdW4yLAotLy8JICAgZXJyb3IxX25vdGlmeXxlcnJvcjJfbm90aWZ5XmVycm9yMl93cml0ZSk7CisvLyAgICAgICAgZXJyb3IxX25vdGlmeXxlcnJvcjJfbm90aWZ5XmVycm9yMl93cml0ZSk7CiAvLyAtLT4KLS8vIChbdmVyYjooe2Z1bjEsZnVuMn0pOwkJCQkJLy8gZnVucwotLy8JICAoezEsKHtlcnJvcjFfbm90aWZ5LCBlcnJvcjJfd3JpdGVeZXJyb3IyX3NheSwgMX0pfSk7ICAvLyBmbGFncwotLy8gICAgICAgICh7MCwoeyh7c3luMWEsc3luMWJ9KSwoe3N5bjJhLHN5bjJiLHN5bjJjfSl9KX0pOwkvLyBydWxlcwotLy8gICAgICAgIDBdKQkJCQkJCQkvLyBJRHMKKy8vIChbdmVyYjoKKy8vICAgICh7ZnVuMSxmdW4yfSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8vIGZ1bnMKKy8vICAgICh7MSwoe2Vycm9yMV9ub3RpZnksIGVycm9yMl93cml0ZV5lcnJvcjJfc2F5LCAxfSl9KTsgIC8vIGZsYWdzCisvLyAgICAoezAsKHsoe3N5bjFhLHN5bjFifSksKHtzeW4yYSxzeW4yYixzeW4yY30pfSl9KTsgICAgICAvLyBydWxlcworLy8gICAgMDsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gSURzCisvLyAgICAoe2Nsb3N1cmUgYXVmIGZ1bjEsIGNsb3N1cmUgYXVmIGZ1bjJ9KSBdKSAgICAgICAgICAgICAvLyBDYWNoZQogLy8KKy8vIEZ1bnM6ICAoezxmdW4xPiAsLi4uCisvLyAgICAgICAgICAnZnVuJyBrYW5uIHNlaW46IENsb3N1cmUKKy8vICAgICAgICAgICAgICAgICAgICAgICAgICAgU3RyaW5nOiBNZXRob2Rlbm5hbWUgLSB3aXJkIGV0d2FzIGdlcHJ1ZWZ0CisvLyAgICAgICAgICAgICAgICAgICAgICAgICAgIE9iamVrdDogd2VubiBrZWluZSBNZXRob2RlLCB0aGlzX29iamVjdCgpIGZ1ZXIKKy8vICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnRlcm4sIHByZXZpb3VzX29iamVjdCgpIGZ1ZXIgZXh0ZXJuCisvLyAgICAgICAgICAgICAgICAgICAgICAgICAgIDAgKGVybG9zY2hlbmVzIGV4dGVybmVzIE9iamVrdCkKIC8vIFJ1bGVzOiAoezxSZWdlbHNhdHogZnVlciBmdW4xPiwgKHs8MS4gU3lub255bWdydXBwZT4sCi0vLwkJCQkgICAgIDwyLiBTeW5vbnltZ3J1cHBlLCAuLi59KSwgLi4ufSkKKy8vICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Mi4gU3lub255bWdydXBwZSwgLi4ufSksIC4uLn0pCiAvLyBGbGFnczogKHs8RmxhZyBmdWVyIGZ1bjE+LCAoezxGZWhsZXJtZWxkdW5nIDEuIFN5bm9ueW1ncnVwcGU+LCAuLi4gLAotLy8JCQkJWywgSW5kZXggZnVlciB3cml0ZSBhbnN0YXR0IG5vdGlmeV9mYWlsXX0pLAotLy8JICAgIC4uLiB9KQorLy8gICAgICAgICAgICAgICAgICAgICAgICAgICAgICBbLCBJbmRleCBmdWVyIHdyaXRlIGFuc3RhdHQgbm90aWZ5X2ZhaWxdfSksCisvLyAgICAgICAgICAgIC4uLiB9KQogLy8gSURzOiAgIDAgb2RlciAoezxJRCBmdWVyIGZ1bjE+fSkgb2RlciAoezAsIDxJRCBmdWVyIGZ1bjI+fSkgLi4uCi0vLwotLy8gSURFQTogc2F2ZSBubyAwcyBpbiBydWxlcy9mbGFncyBpZiBwb3NzaWJsZSAoYXMgaW4gSURzKQotLy8gICAgICAgKGFkcmVzc2luZyBlc3BlY2lhbGx5IG9sZC1zdHlsZS1BZGRDbWQtTVVEcykKKy8vIENhY2hlOiAoezxjbG9zdXJlIGZ1ZXIgZnVuMT4sIC4uLgorLy8gICAgICAgIENhY2hlLUNsb3N1cmVzIHNpbmQgYmVpIEV4cG9ydCAoUXVlcnlQcm9wKSBpbW1lciBnZW51bGx0CiAjcHJhZ21hIHN0cmljdF90eXBlcwogI3ByYWdtYSBzYXZlX3R5cGVzCiAjcHJhZ21hIHJhbmdlX2NoZWNrCkBAIC0zOCw2ICs0NSw3IEBACiAjaW5jbHVkZSA8ZXhwbG9yYXRpb24uaD4KICNpbmNsdWRlIDxkZWZpbmVzLmg+CiAjaW5jbHVkZSA8bGl2aW5nL2NvbW0uaD4KKyNpbmNsdWRlIDxmdW5jdGlvbmxpc3QuaD4KIAogI2RlZmluZSBORUVEX1BST1RPVFlQRVMKICNpbmNsdWRlIDx0aGluZy9wcm9wZXJ0aWVzLmg+CkBAIC00NSw2ICs1MywxNCBAQAogI2luY2x1ZGUgPHRoaW5nL2NvbW1hbmRzLmg+CiAjdW5kZWYgTkVFRF9QUk9UT1RZUEVTCiAKKyNkZWZpbmUgQ01EU19XSURUSCA1CisvLyBNYXBwaW5nLUluZGl6ZXMKKyNkZWZpbmUgQ01ESURYX0ZVTiAgIDAKKyNkZWZpbmUgQ01ESURYX0ZMQUcgIDEKKyNkZWZpbmUgQ01ESURYX1JVTEUgIDIKKyNkZWZpbmUgQ01ESURYX0lEICAgIDMKKyNkZWZpbmUgQ01ESURYX0NBQ0hFIDQKKwogI2lmZGVmIERCRwogI3VuZGVmIERCRwogI2VuZGlmCkBAIC0xMjksOSArMTQ1LDM5IEBACiAgIHNldF9uZXh0X3Jlc2V0KC0xKTsKIH0KIAorcHJpdmF0ZSBjbG9zdXJlIF9jaGVja19zdHJpbmdtZXRob2QobWl4ZWQgZnVuYywgaW50IGV4LCBzdHJpbmcgcmVzcCkgeworICBjbG9zdXJlIGNsOworICBpZighZnVuY3Rpb25fZXhpc3RzKGZ1bmMpKQorICAgIHJhaXNlX2Vycm9yKHNwcmludGYoCisgICAgICByZXNwKyJzdHJpbmctTWV0aG9kZSAnJXMnIGZlaGx0IG9kZXIgaXN0IHByaXZhdGUuXG4iLCBmdW5jKSk7CisKKyAgLy8gZXh0ZXJuIGVyc3RlbGx0ZSBhdWYgU2ljaHRiYXJrZWl0IHBydWVmZW4gdW5kIGFiYnJlY2hlbi9kYXZvciB3YXJuZW4KKyAgaWYoZXgpIHsKKyAgICBtaXhlZCAqZmwgPSBmdW5jdGlvbmxpc3QodGhpc19vYmplY3QoKSwgUkVUVVJOX0ZVTkNUSU9OX05BTUV8CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJFVFVSTl9GVU5DVElPTl9GTEFHUyk7CisgICAgaW50IGluZGV4ID0gbWVtYmVyKGZsLCBmdW5jKSsxOworICAgIGlmKGluZGV4PD0wIHx8IHNpemVvZihmbCk8PWluZGV4KQorICAgICAgcmFpc2VfZXJyb3Ioc3ByaW50ZigKKyAgICAgICAgcmVzcCsic3RyaW5nLU1ldGhvZGUgJyVzJyBuaWNodCBpbiBmdW5jdGlvbmxpc3QuXG4iLCBmdW5jKSk7CisgICAgZWxzZSBpZihmbFtpbmRleF0mVFlQRV9NT0RfUFJPVEVDVEVEIHx8IGZsW2luZGV4XSZUWVBFX01PRF9TVEFUSUMpCisgICAgICByYWlzZV9lcnJvcihzcHJpbnRmKAorICAgICAgICByZXNwKyJzdHJpbmctTWV0aG9kZSAnJXMnIGlzdCBwcm90ZWN0ZWQvc3RhdGljLiBFeHRlcm4gIgorICAgICAgICAiZGVmaW5pZXJ0ZXMgS29tbWFuZG8gZGFyZiBzbyBlaW5lIE1ldGhvZGUgbmljaHQgYXVmcnVmZW4hXG4iLAorICAgICAgICBmdW5jKSk7CisgIH0KKworICAvLyBhbnNvbnN0ZW4gTWV0aG9kZSBlcnN0bWFsIGNhY2hlbgorICBjbCA9IHN5bWJvbF9mdW5jdGlvbihmdW5jLCB0aGlzX29iamVjdCgpKTsKKyAgaWYoIWNsKQorICAgIHJhaXNlX2Vycm9yKHNwcmludGYoCisgICAgICByZXNwKyJzdHJpbmctTWV0aG9kZSAnJXMnIG5pY2h0IGluIENsb3N1cmUgd2FuZGVsYmFyP1xuIiwgZnVuYykpOworCisgIHJldHVybiBjbDsKK30KKwogdmFyYXJncyB2b2lkIEFkZENtZChtaXhlZCBjbWQsIG1peGVkIGZ1bmMsIG1peGVkIGZsYWcsIG1peGVkIGNtZGlkKSB7CiAgaW50IGksajsKLSBjbG9zdXJlIGNsOworIGNsb3N1cmUgY2FjaGVkY2w7CiAgbWl4ZWQgKnJ1bGU7CiAKICAvLyBwb3RlbnRpZWxsZSBBZGRDbWQgbWl0IFJlZ2VsPwpAQCAtMTk2LDM3ICsyNDIsNDEgQEAKICBpZighcG9pbnRlcnAoY21kKSkKICAgIHJhaXNlX2Vycm9yKCJBZGRDbWQ6IG1pc3Npbmcgc3RyaW5nL3BvaW50ZXItcGFyYW1ldGVyIGZvciBjb21tYW5kLlxuIik7CiAKLSAvLyBDbG9zdXJlIGF1cyBlaW5lbSBTdHJpbmcgZXJ6ZXVnZW4sIHdlbm4gbW9lZ2xpY2ggdW5kIHNpY2hlcgotIC8vIChmdW5jdGlvbl9leGlzdHMoKSBmaWx0ZXJ0IHVubm9ldGlnZXJ3ZWlzZSBhdWNoIHJlaW5lICJzdGF0aWMiIGZ1bnMsCi0gLy8gIGRpZSBnZW5hdWUgUHJ1ZWZ1bmcgdWViZXIgZnVuY3Rpb25saXN0KCkga29zdGV0IGplZG9jaCB6dXZpZWwpCi0gaWYoc3RyaW5ncChmdW5jKSAmJgotICAgICghZXh0ZXJuX2NhbGwoKSB8fCBmdW5jdGlvbl9leGlzdHMoZnVuYyx0aGlzX29iamVjdCgpKSkgJiYKLSAgICBjbG9zdXJlcChjbD1zeW1ib2xfZnVuY3Rpb24oZnVuYyx0aGlzX29iamVjdCgpKSkpCi0gIGZ1bmM9Y2w7CisgIC8vIFN0cmluZy1NZXRob2RlIGF1ZiBTaWNodGJhcmtlaXQgcHJ1ZWZlbiwgQ2FjaGUgZ2xlaWNoIGFucGFzc2VuCisgIHN3aXRjaCh0eXBlb2YoZnVuYykpIHsKKyAgICBjYXNlIFRfU1RSSU5HOgorICAgICAgY2FjaGVkY2w9X2NoZWNrX3N0cmluZ21ldGhvZChmdW5jLCBleHRlcm5fY2FsbCgpLCAiQWRkQ21kOiAiKTsKKyAgICAgIGJyZWFrOworICAgIGNhc2UgVF9DTE9TVVJFOgorICAgICAgY2FjaGVkY2w9ZnVuYzsKKyAgICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICBpZihleHRlcm5fY2FsbCgpKSBmdW5jPXByZXZpb3VzX29iamVjdCgpOworICAgICAgZWxzZSBmdW5jPXRoaXNfb2JqZWN0KCk7CisgICAgICBicmVhazsKKyAgfQogCi0gLy8gamVkZXMgZWluemVsbmUgVmVyYiBtaXQgc2VpbmVuIFJlZ2VsbiB1bmQgRnVua3Rpb25lbiBlaW50cmFnZW4KKyAgLy8gamVkZXMgZWluemVsbmUgVmVyYiBtaXQgc2VpbmVuIFJlZ2VsbiB1bmQgRnVua3Rpb25lbiBlaW50cmFnZW4KICBpPXNpemVvZihjbWQpOwotIGlmKCFhZGRlZF9jbWRzKSBhZGRlZF9jbWRzPW1fYWxsb2NhdGUoaSw0KTsKKyBpZighYWRkZWRfY21kcykgYWRkZWRfY21kcz1tX2FsbG9jYXRlKGksIENNRFNfV0lEVEgpOwogIHdoaWxlKGktLSkgewogICBzdHJpbmcgc3RyOwogICBzdHI9Y21kW2ldOwotICBpZighZnVuYykKLSAgIGlmKGV4dGVybl9jYWxsKCkpIGZ1bmM9cHJldmlvdXNfb2JqZWN0KCk7Ci0gICBlbHNlIGZ1bmM9dGhpc19vYmplY3QoKTsKICAgaWYoIW1lbWJlcihhZGRlZF9jbWRzLHN0cikpCi0gICBhZGRlZF9jbWRzKz0oW3N0cjphbGxvY2F0ZSgwKTthbGxvY2F0ZSgwKTthbGxvY2F0ZSgwKTswXSk7CisgICBhZGRlZF9jbWRzKz0oW3N0cjphbGxvY2F0ZSgwKTthbGxvY2F0ZSgwKTthbGxvY2F0ZSgwKTswO2FsbG9jYXRlKDApXSk7CiAgIC8vIGV4aXN0aWVyZW5kZXMgVmVyYiBlcmdhZW56ZW4KLSAgYWRkZWRfY21kc1tzdHIsMF0rPSh7ZnVuY30pOwotICBhZGRlZF9jbWRzW3N0ciwxXSs9KHtmbGFnfSk7Ci0gIGFkZGVkX2NtZHNbc3RyLDJdKz0oe3J1bGV9KTsKKyAgYWRkZWRfY21kc1tzdHIsIENNRElEWF9GVU5dKz0oe2Z1bmN9KTsKKyAgYWRkZWRfY21kc1tzdHIsIENNRElEWF9GTEFHXSs9KHtmbGFnfSk7CisgIGFkZGVkX2NtZHNbc3RyLCBDTURJRFhfUlVMRV0rPSh7cnVsZX0pOworICBhZGRlZF9jbWRzW3N0ciwgQ01ESURYX0NBQ0hFXSs9KHtjYWNoZWRjbH0pOwogICAvLyBnZ2YuIGlkIGluIGRhcyBJRC1NYXBwaW5nIGVpbnRyYWdlbgogICBpZihjbWRpZCkgewogICAgbWl4ZWQgKnRtcDsKLSAgIGo9c2l6ZW9mKChzdHJpbmcqKWFkZGVkX2NtZHNbc3RyLDBdKTsKLSAgIHRtcD1hZGRlZF9jbWRzW3N0ciwzXXx8YWxsb2NhdGUoaik7CisgICBqPXNpemVvZigoc3RyaW5nKilhZGRlZF9jbWRzW3N0ciwgQ01ESURYX0ZVTl0pOworICAgdG1wPWFkZGVkX2NtZHNbc3RyLCBDTURJRFhfSURdfHxhbGxvY2F0ZShqKTsKICAgIGlmKHNpemVvZih0bXApPGopIHRtcCs9YWxsb2NhdGUoai1zaXplb2YodG1wKSk7CiAgICB0bXBbPDFdPWNtZGlkOwotICAgYWRkZWRfY21kc1tzdHIsM109dG1wOworICAgYWRkZWRfY21kc1tzdHIsIENNRElEWF9JRF09dG1wOwogICB9CiAgfQogfQpAQCAtMjU0LDcgKzMwNCw3IEBACiAgIGFkZGVkX2NtZHM9KG1hcHBpbmcpMDsgCiAgZWxzZSB7CiAgIGludCBpLCBqOwotICBtaXhlZCAqcnVsZSwgKmZsYWcsICpmdW4sICpkZWxydWxlLCAqaWRzOworICBtaXhlZCAqcnVsZSwgKmZsYWcsICpmdW4sICpkZWxydWxlLCAqaWRzLCAqY2FjaGVjbDsKIAogICBpZihzdHJpbmdwKGNtZCkpIHsKICAgIC8vIFJlZ2VsbiBlbnRkZWNrdCAtIFplcmxlZ2VuICh3aWUgQWRkQ21kKQpAQCAtMjc1LDcgKzMyNSw3IEBACiAgIHdoaWxlKGktLSkgewogICAgLy8ga2VpbmUgUmVnZWxuIGRhIHVuZCBSZWdlbG4gbG9lc2NoZW4gZXJsYXVidDogYWxsZXMgbG9lc2NoZW4KICAgIGlmKCFkZWxydWxlICYmICFkZWxfbm9ydWxlICYmICFvbmx5aWQpIG1fZGVsZXRlKGFkZGVkX2NtZHMsY21kW2ldKTsKLSAgIGVsc2UgaWYobV9jb250YWlucygmZnVuLCAmZmxhZywgJnJ1bGUsICZpZHMsIGFkZGVkX2NtZHMsIGNtZFtpXSkpIHsKKyAgIGVsc2UgaWYobV9jb250YWlucygmZnVuLCAmZmxhZywgJnJ1bGUsICZpZHMsICZjYWNoZWNsLCBhZGRlZF9jbWRzLCBjbWRbaV0pKSB7CiAgICAgaj1zaXplb2YoZnVuKTsKICAgICB3aGlsZShqLS0pIHsKICAgICAgaW50IGs7CkBAIC0yOTQsOSArMzQ0LDEwIEBACiAgICAgICB9CiAgICAgICAvLyBhbGxlcyBrb3JyZWt0OiBM9nNjaGVuIQogICAgICAgLy8gKEFycmF5YmVyZWljaCBkdXJjaCBsZWVyZXMgQXJyYXkgbG9lc2NoZW4pCi0gICAgICBmbGFnW2ouLmpdICA9IGFsbG9jYXRlKDApOwotICAgICAgZnVuW2ouLmpdICAgPSBhbGxvY2F0ZSgwKTsKLSAgICAgIHJ1bGVbai4ual0gID0gYWxsb2NhdGUoMCk7CisgICAgICBmbGFnW2ouLmpdICAgID0gYWxsb2NhdGUoMCk7CisgICAgICBmdW5bai4ual0gICAgID0gYWxsb2NhdGUoMCk7CisgICAgICBydWxlW2ouLmpdICAgID0gYWxsb2NhdGUoMCk7CisgICAgICBjYWNoZWNsW2ouLmpdID0gYWxsb2NhdGUoMCk7CiAgICAgICBpZihpZHMpIHsKICAgICAgICBpZHNbai4ual0gPSBhbGxvY2F0ZSgwKTsKICAgICAgICBpZighc2l6ZW9mKGlkcy1hbGxvY2F0ZSgxKSkpIGlkcz0obWl4ZWQqKTA7CkBAIC0zMDcsMTAgKzM1OCwxMSBAQAogICAgfQogICAgLy8gRnVua3Rpb25zL1JlZ2VsbGlzdGUgdXBkYXRlIG9kZXIgZ2dmLiBLb21tYW5kbyB2b2VsbGlnIGxvZXNjaGVuCiAgICBpZihzaXplb2YocnVsZSkpIHsKLSAgICBhZGRlZF9jbWRzW2NtZFtpXSwwXT1mdW47Ci0gICAgYWRkZWRfY21kc1tjbWRbaV0sMV09ZmxhZzsKLSAgICBhZGRlZF9jbWRzW2NtZFtpXSwyXT1ydWxlOwotICAgIGFkZGVkX2NtZHNbY21kW2ldLDNdPWlkczsKKyAgICBhZGRlZF9jbWRzW2NtZFtpXSwgQ01ESURYX0ZVTl09ZnVuOworICAgIGFkZGVkX2NtZHNbY21kW2ldLCBDTURJRFhfRkxBR109ZmxhZzsKKyAgICBhZGRlZF9jbWRzW2NtZFtpXSwgQ01ESURYX1JVTEVdPXJ1bGU7CisgICAgYWRkZWRfY21kc1tjbWRbaV0sIENNRElEWF9JRF09aWRzOworICAgIGFkZGVkX2NtZHNbY21kW2ldLCBDTURJRFhfQ0FDSEVdPWNhY2hlY2w7CiAgICB9IGVsc2UgbV9kZWxldGUoYWRkZWRfY21kcyxjbWRbaV0pOwogICB9CiAgIGlmKCFzaXplb2YoYWRkZWRfY21kcykpIGFkZGVkX2NtZHM9KG1hcHBpbmcpMDsKQEAgLTMyMCwxMSArMzcyLDIwIEBACiAKIC8vIEF1c2Z1ZWhyZW4gc2FtdCBnZXBhcnN0ZW0gSW5wdXRzdHJpbmcgdW5kIGdldHJpZ2dlcnRlbiBQYXJzZXJlcmdlYm5pc3Nlbgogc3RhdGljIGludCBfZXhlY3V0ZShtaXhlZCBmdW4sIHN0cmluZyBzdHIsIG1peGVkICpwYXJzZWQpIHsKLSBpZihjbG9zdXJlcChmdW4pKQotICByZXR1cm4gKChpbnQpZnVuY2FsbChmdW4sc3RyLCZwYXJzZWQpKTsKLSBpZihzdHJpbmdwKGZ1bikpCi0gIHJldHVybiAoKGludCljYWxsX290aGVyKHRoaXNfb2JqZWN0KCksZnVuLHN0ciwmcGFyc2VkKSk7Ci0gcmV0dXJuIDA7CisgIHN3aXRjaCh0eXBlb2YoZnVuKSkgeworICAgIGNhc2UgVF9DTE9TVVJFOgorICAgICAgcmV0dXJuICgoaW50KWZ1bmNhbGwoZnVuLHN0ciwmcGFyc2VkKSk7CisgICAgY2FzZSBUX1NUUklORzoKKyAgICAgIGludCByZXQ7CisgICAgICBpZighY2FsbF9yZXNvbHZlZCgmcmV0LCB0aGlzX29iamVjdCgpLCBmdW4sIHN0ciwgJnBhcnNlZCkpCisgICAgICAgIHJhaXNlX2Vycm9yKHNwcmludGYoCisgICAgICAgICAgIkFkZENtZDogU3RyaW5nLU1ldGhvZGUgJyVzJyBpbiBLb21tYW5kbyAlI08gc2NoZWludCB6dSBmZWhsZW4gIgorICAgICAgICAgICJvZGVyIG5pY2h0IHp1Z3JlaWZiYXIgenUgc2Vpbi5cbiIsIGZ1biwgcGFyc2VkKSk7CisgICAgICByZXR1cm4gcmV0OworICAgIGRlZmF1bHQ6CisgICAgICBicmVhazsKKyAgfQorICByZXR1cm4gMDsKIH0KIAogI2RlZmluZSBDSEVDS19QUkVTRU5UICAgICAxCkBAIC0zMzksOCArNDAwLDggQEAKIAogLy8gUmVnZWxuIGZ1ZXIgZWluIChudW4gdW53aWNodGlnZXMpIFZlcmIgdHJpZ2dlcm4KIHN0YXRpYyBpbnQgX3Byb2Nlc3NfY29tbWFuZChzdHJpbmcgc3RyLCBzdHJpbmcgKm5vcGFyc2VzdHIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgbWl4ZWQgZnVuLCBtaXhlZCBmbGFnLCBtaXhlZCBydWxlLCBtaXhlZCBpZCkKLXsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBtaXhlZCBmdW4sIG1peGVkIGZsYWcsIG1peGVkIHJ1bGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWl4ZWQgaWQsIG1peGVkIGNhY2hlZGNsKSB7CiAgbWl4ZWQgKnBhcnNlZCwgKm9iam1hdGNoZXM7CiAKICAvLyBlaW5lIFJlZ2VsIC4uLiBhdXN3ZXJ0ZW4gLi4uCkBAIC01MDUsNyArNTY2LDcgQEAKICAgIHBhcnNlZFtvYmptYXRjaGVzW29ianNpemVdXT1vYmptYXRjaGVzW29ianNpemUrMV07CiAKICAvLyBlcmZvbGdyZWljaCBNZXRob2RlIGdlZnVuZGVuL2VpbmUgUmVnZWwgYmlzIHp1bSBFbmRlIGR1cmNoZ2VwYXJzdDoKLSByZXR1cm4oX2V4ZWN1dGUoJmZ1biwmc3RyLCZwYXJzZWQpKTsKKyByZXR1cm4oX2V4ZWN1dGUoY2FjaGVkY2x8fGZ1biwgc3RyLCAmcGFyc2VkKSk7CiB9CiAKIC8vIEF1c3dlcnR1bmcgLSBhZGRfYWN0aW9uLUZ1biAKQEAgLTUxNSwxMCArNTc2LDEwIEBACiAgbWl4ZWQgKmZsYWc7CiAgLy8gVmVyYiBleGlzdGllcnQsIEtvbW1hbmRvcyBhdWNoLCBFaW50cmFnIGZ1ZXIgVmVyYiBnZWZ1bmRlbgogIGlmKG1hcHBpbmdwKGFkZGVkX2NtZHMpICYmIHF1ZXJ5X3ZlcmIoKSkgewotICBtaXhlZCAqZnVuLCAqcnVsZSwgKmlkczsKKyAgbWl4ZWQgKmZ1biwgKnJ1bGUsICppZHMsICpjYWNoZWNsOwogCiAgIC8vIGlzdCBkYXMgVmVyYiBlaW4gS2V5IGltIEtvbW1hbmRvbWFwcGluZz8KLSAgaWYobV9jb250YWlucygmZnVuLCAmZmxhZywgJnJ1bGUsICZpZHMsIGFkZGVkX2NtZHMsIHF1ZXJ5X3ZlcmIoKSkpIHsKKyAgaWYobV9jb250YWlucygmZnVuLCAmZmxhZywgJnJ1bGUsICZpZHMsICZjYWNoZWNsLCBhZGRlZF9jbWRzLCBxdWVyeV92ZXJiKCkpKSB7CiAgICBzdHJpbmcgKm5vcGFyc2VzdHI7CiAgICBuaW5kZXg9c2l6ZW9mKGZ1bik7CiAgICBub3BhcnNlc3RyPWV4cGxvZGUoKHN0cnx8IiIpLCIgIiktKHsiIn0pOwpAQCAtNTI4LDggKzU4OSw3IEBACiAgICB7CiAgICAgbWl4ZWQgY21kX2lkID0gKHBvaW50ZXJwKGlkcykgJiYgc2l6ZW9mKGlkcyk+bmluZGV4KSA/IGlkc1tuaW5kZXhdIDogMDsKICAgICBpZihfcHJvY2Vzc19jb21tYW5kKCZzdHIsIG5vcGFyc2VzdHIsIGZ1bltuaW5kZXhdLCBmbGFnW25pbmRleF0sCi0gICAgICAgICAgICAgICAgICAgICAgICBydWxlW25pbmRleF0sIGNtZF9pZCkpCi0gICAgeworICAgICAgICAgICAgICAgICAgICAgICAgcnVsZVtuaW5kZXhdLCBjbWRfaWQsIGNhY2hlY2xbbmluZGV4XSkpIHsKICAgICAgIEdpdmVFUChFUF9DTUQsIHF1ZXJ5X3ZlcmIoKSk7CiAgICAgICByZXR1cm4gMTsKICAgICB9CkBAIC01NDIsMjAgKzYwMiwyMSBAQAogICBuaW5kZXg9c2l6ZW9mKGtleXMpOwogICB3aGlsZShuaW5kZXgtLSkKICAgIGlmKCFzdHJzdHIocXVlcnlfdmVyYigpLGtleXNbbmluZGV4XSkgJiYKLSAgICAgIG1lbWJlcigoZmxhZz1hZGRlZF9jbWRzW2tleXNbbmluZGV4XSwxXSksMSk+PTApIHsKKyAgICAgIG1lbWJlcigoZmxhZz1hZGRlZF9jbWRzW2tleXNbbmluZGV4XSwgQ01ESURYX0ZMQUddKSwxKT49MCkgewogICAgIGludCBpLHJldDsKICAgICBpPXNpemVvZihmbGFnKTsKICAgICAvLyBSZWloZW5mb2xnZSBuaWNodCBhZW5kZXJuICEKICAgICB3aGlsZShpLS0pCiAgICAgICBpZihmbGFnW2ldPT0xKSB7Ci0gICAgICAgIG1peGVkICpleGVjID0gYWRkZWRfY21kc1trZXlzW25pbmRleF0sMF07Ci0gICAgICAgIGlmKCFwb2ludGVycChleGVjKSB8fCBzaXplb2YoZXhlYyk8PWkpCisgICAgICAgIG1peGVkICpmdXp6eWZ1bnMgICA9IGFkZGVkX2NtZHNba2V5c1tuaW5kZXhdLCBDTURJRFhfRlVOXTsKKyAgICAgICAgbWl4ZWQgKmZ1enp5Y2FjaGUgID0gYWRkZWRfY21kc1trZXlzW25pbmRleF0sIENNRElEWF9DQUNIRV07CisgICAgICAgIGlmKCFwb2ludGVycChmdXp6eWZ1bnMpIHx8IHNpemVvZihmdXp6eWZ1bnMpPD1pKQogICAgICAgICAgIGNhdGNoKHJhaXNlX2Vycm9yKAogICAgICAgICAgICAgIkFkZENtZC1BdXN3ZXJ0dW5nOiBDYXRjaEFsbC1Lb21tYW5kbyBcIiIra2V5c1tuaW5kZXhdKyJcIiIKICAgICAgICAgICAgICIgd3VyZGUgd2FlaHJlbmQgZGVyIEF1c2Z1ZWhydW5nIHZlcmFlbmRlcnQgb2RlciBnZWxvZXNjaHQuICIKICAgICAgICAgICAgICJLbGFydGV4dDogRGFzIGlzdCBzY2hsZWNodC4gU3VjaHQgZWluIFJlbW92ZUNtZD8gIik7CiAgICAgICAgICAgICBwdWJsaXNoKTsKLSAgICAgICAgZWxzZSBpZihfZXhlY3V0ZShleGVjW2ldLHN0ciwwKSkgeworICAgICAgICBlbHNlIGlmKF9leGVjdXRlKGZ1enp5Y2FjaGVbaV18fGZ1enp5ZnVuc1tpXSwgc3RyLCAwKSkgewogICAgICAgICAgIEdpdmVFUChFUF9DTUQsIHF1ZXJ5X3ZlcmIoKSk7CiAgICAgICAgICAgcmV0dXJuIDE7CiAgICAgICAgIH0KQEAgLTU3MCwzOSArNjMxLDUxIEBACiB9CiAKIAotc3RhdGljIHZvaWQgX2NoZWNrX2NvcHlfY29tbWFuZHMoc3RyaW5nIGluZCwgbWl4ZWQgKmZ1biwKLQkJCQkgIG1peGVkICpmbGFnLCBtaXhlZCAqcnVsZSkgewotIGlmKHBvaW50ZXJwKGZ1bikpIGFkZGVkX2NtZHNbaW5kLDBdPWZ1bithbGxvY2F0ZSgwKTsKLSBlbHNlIGFkZGVkX2NtZHNbaW5kLDBdPSh7ZnVufSk7Ci0gaWYocG9pbnRlcnAoZmxhZykpIGFkZGVkX2NtZHNbaW5kLDFdPWZsYWcrYWxsb2NhdGUoMCk7Ci0gZWxzZSBpZihmbGFnKSBhZGRlZF9jbWRzW2luZCwxXT0oe2ZsYWd9KTsKLSBlbHNlIGFkZGVkX2NtZHNbaW5kLDFdPWFsbG9jYXRlKHNpemVvZihhZGRlZF9jbWRzW2luZF0pKTsKLSBpZihwb2ludGVycChydWxlKSkgYWRkZWRfY21kc1tpbmQsMl09cnVsZSthbGxvY2F0ZSgwKTsKLSBlbHNlIGFkZGVkX2NtZHNbaW5kLDJdPWFsbG9jYXRlKHNpemVvZihhZGRlZF9jbWRzW2luZF0pKTsKLQotIGlmKHNpemVvZihhZGRlZF9jbWRzW2luZF0pIT1zaXplb2YoYWRkZWRfY21kc1tpbmQsMV0pIHx8Ci0gICAgc2l6ZW9mKGFkZGVkX2NtZHNbaW5kXSkhPXNpemVvZihhZGRlZF9jbWRzW2luZCwyXSkpIHsKLSAgYWRkZWRfY21kcz0obWFwcGluZykwOwotICByYWlzZV9lcnJvcigiU2V0UHJvcChQX0NPTU1BTkRTKTogY29ycnVwdCBjb21tYW5kcy1tYXBwaW5nLlxuIik7Ci0gfQorcHJpdmF0ZSB2b2lkIF9jaGVja19pbXBvcnRlbnRyeShzdHJpbmcgaW5kLCBtaXhlZCAqZnVuLCBtaXhlZCAqZmxhZywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWl4ZWQgKnJ1bGUsIGludHxtaXhlZCBpZCwgbWl4ZWQgKmNhY2hlZGNsKSB7CisgIC8vIENoZWNrIGRlciBTdHJpbmdtZXRob2RlbgorICBjYWNoZWRjbCA9IG1hcChmdW4sIGZ1bmN0aW9uIGludHxjbG9zdXJlKHN0cmluZyBjbGZ1bikgeworICAgICAgICAgICAgICAgICAgICAgICAgY2xvc3VyZSByZXQ7CisgICAgICAgICAgICAgICAgICAgICAgICBjYXRjaChyZXQ9X2NoZWNrX3N0cmluZ21ldGhvZCgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNsZnVuLCAxLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIldhcm51bmcgU2V0UHJvcChQX0NPTU1BTkRTKTogIik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwdWJsaXNoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiByZXQ7CisgICAgICAgICAgICAgICAgICAgICAgfSk7CisgIGlmKHNpemVvZihmdW4pIT1zaXplb2YoZmxhZykgfHwgc2l6ZW9mKGZ1bikhPXNpemVvZihydWxlKSkKKyAgICByYWlzZV9lcnJvcigiU2V0UHJvcChQX0NPTU1BTkRTKTogY29ycnVwdCBjb21tYW5kcy1tYXBwaW5nLlxuIik7CiB9CiAKLXN0YXRpYyBtYXBwaW5nIF9zZXRfY29tbWFuZHMobWFwcGluZyBjb21tYW5kcykgewotIGlmKCFjb21tYW5kcykgYWRkZWRfY21kcz0obWFwcGluZykwOwotIGVsc2UgaWYobWFwcGluZ3AoY29tbWFuZHMpKSB7Ci0gIGFkZGVkX2NtZHM9bV9hbGxvY2F0ZShzaXplb2YoY29tbWFuZHMpLDQpOwotICB3YWxrX21hcHBpbmcoY29tbWFuZHMsIydfY2hlY2tfY29weV9jb21tYW5kcyk7Ci0gfQotIGlmIChtYXBwaW5ncChhZGRlZF9jbWRzKSkKLSAgIHJldHVybihkZWVwX2NvcHkoYWRkZWRfY21kcykpOwotIGVsc2UKLSAgIHJldHVybiAobWFwcGluZykwOworcHJpdmF0ZSB2b2lkIF9jbGVhbnVwX2V4cG9ydGNsKHN0cmluZyBpbmQsIG1peGVkICpmdW4sIG1peGVkICpmbGFnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1peGVkICpydWxlLCBpbnR8bWl4ZWQgaWQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWl4ZWQgKmNhY2hlZGNsLCBtaXhlZCAqZmwpIHsKKyAgY2FjaGVkY2wgPSBhbGxvY2F0ZShzaXplb2YoZnVuKSk7CisgIGZvcmVhY2goc3RyaW5nIGZ1bmM6IGZpbHRlcihmdW4sICMnc3RyaW5ncCkpCisgICAgY2F0Y2goX2NoZWNrX3N0cmluZ21ldGhvZChmdW5jLCAxLCAiV2FybnVuZyBRdWVyeVByb3AoUF9DT01NQU5EUyk6ICIpOworICAgICAgICAgIHB1Ymxpc2gpOwogfQogCiBzdGF0aWMgbWFwcGluZyBfcXVlcnlfY29tbWFuZHMoKSB7Ci0gaWYgKG1hcHBpbmdwKGFkZGVkX2NtZHMpKQotICAgcmV0dXJuKGRlZXBfY29weShhZGRlZF9jbWRzKSk7Ci0gZWxzZQotICAgcmV0dXJuIChtYXBwaW5nKTA7CisgIG1hcHBpbmcgcmV0OworICBpZihtYXBwaW5ncChhZGRlZF9jbWRzKSkgeworICAgIHJldCA9IGRlZXBfY29weShhZGRlZF9jbWRzKTsKKyAgICAvLyBIaWVyIGthbm4gbWFuIG5pY2h0IG1laHIgaGVyYXVzZmluZGVuLCBvYiBlcyBlaW4gZXh0ZXJuX2NhbGwoKSBpc3Q6CisgICAgLy8gQ2xvc3VyZXMgaW0gQ2FjaGUgd2VyZGVuIGltbWVyIGdlbG9lc2NodC4KKyAgICB3YWxrX21hcHBpbmcocmV0LCAjJ19jbGVhbnVwX2V4cG9ydGNsLAorICAgICAgICAgICAgICAgICBmdW5jdGlvbmxpc3QodGhpc19vYmplY3QoKSwgUkVUVVJOX0ZVTkNUSU9OX05BTUV8CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSRVRVUk5fRlVOQ1RJT05fRkxBR1MpKTsKKyAgfQorICByZXR1cm4gcmV0OwogfQogCitzdGF0aWMgbWFwcGluZyBfc2V0X2NvbW1hbmRzKG1hcHBpbmcgY29tbWFuZHMpIHsKKyAgaWYoIWNvbW1hbmRzKSBhZGRlZF9jbWRzPShtYXBwaW5nKTA7CisgIGVsc2UgaWYobWFwcGluZ3AoY29tbWFuZHMpKSB7CisgICAgaWYod2lkdGhvZihjb21tYW5kcykgIT0gQ01EU19XSURUSCkKKyAgICAgIHJhaXNlX2Vycm9yKCJTZXRQcm9wKFBfQ09NTUFORFMpOiBjb3JydXB0IGNvbW1hbmRzLW1hcHBpbmcuXG4iKTsKKyAgICBtYXBwaW5nIHRtcCA9IGRlZXBfY29weShjb21tYW5kcyk7CisgICAgd2Fsa19tYXBwaW5nKHRtcCwgIydfY2hlY2tfaW1wb3J0ZW50cnkpOworICAgIGNvbW1hbmRzID0gdG1wOworICB9CisgIHJldHVybiBfcXVlcnlfY29tbWFuZHMoKTsKK30K