ZGlmZiAtLWdpdCBhL0NIQU5HRUxPRyBiL0NIQU5HRUxPRwppbmRleCBmNzc0MTcxLi43OTNjOTM2IDEwMDY0NAotLS0gYS9DSEFOR0VMT0cKKysrIGIvQ0hBTkdFTE9HCkBAIC0yLDEyICsyLDQyIEBACiBDaGFuZ2VzIHNpbmNlIFUtQm9vdCAwLjIuMjoKID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KIAorKiBQYXRjaCBieSBBcnVuIERoYXJhbmthciwgNCBBcHIgMjAwMzoKKyAgQWRkIElETUEgZXhhbXBsZSBjb2RlICh0ZXN0ZWQgb24gODI2MCBvbmx5KQorCisqIEFkZCBzdXBwb3J0IGZvciBQdXJwbGUgQm9hcmQgKE1JUFM2NCA1S2MpCisKKyogQWRkIHN1cHBvcnQgZm9yIE1JUFM2NCA1S2MgQ1BVcworCisqIEZpeCBtaXNzaW5nIHNldHRpbmcgb2YgImxvYWRhZGRyIiBhbmQgImJvb3RmaWxlIiBvbiBBUk0gYW5kIE1JUFMKKworKiBQYXRjaCBieSBEZW5pcyBQZXRlciwgMDQgQXByIDIwMDM6CisgIC0gdXBkYXRlIE1JUDQwNS00IGJvYXJkCisKICogUGF0Y2ggYnkgU3RlZmFuIFJvZXNlLCA0IEFwciAyMDAzOgogICAtIFUtQm9vdCB2ZXJzaW9uIGVudmlyb25tZW50IHZhcmlhYmxlICJ2ZXIiIGFkZGVkCiAgICAgKENPTkZJR19WRVJTSU9OX1ZBUklBQkxFKS4KICAgLSBDaGFuZ2VkIFBQQzQwNUdQciB2ZXJzaW9uIGZyb20gQSB0byBCLgogICAtIENoYW5nZWQgQ1BDSTQwNSB0byB1c2UgQ1RTIGluc3RlYWQgb2YgRFNSIG9uIFBQQzQwNSBVQVJUMS4KIAorKiBQYXRjaGVzIGJ5IERlbmlzIFBldGVyLCAwMyBBcHJpbCAyMDAzOgorICAtIGZpeCBQQ0kgSVJRcyBvbiBNUEwgYm9hcmRzCisgIC0gZml4IHR3byBtb3JlIHVuLXJlbG9jYXRlZCBwb2ludGVyIHByb2JsZW1zCisKKyogRml4IGJlaGF2aW91ciBvZiAicnVuIiBjb21tYW5kOgorICAtIHByaW50IGVycm9yIG1lc3NhZ2UgaXYgdmFyaWFibGUgZG9lcyBub3QgZXhpc3QKKyAgLSB0ZXJtaW5hdGUgcHJvY2Vzc2luZyBvZiBhcmd1bWVudHMgaW4gY2FzZSBvZiBlcnJvcgorCisqIFBhdGNoZXMgYnkgUGV0ZXIgRmlndWxpLCAxMCBNYXIgMjAwMworICAtIEFkZCBzdXBwb3J0IGZvciBCVFVBUlQgb24gUFhBIHBsYXRmb3JtCisgIC0gQWRkIHN1cHBvcnQgZm9yIFdFUCBFUDI1MCAoUFhBKSBib2FyZAorCisqIEZpeCBmbGFzaCBwcm9ibGVtcyBvbiBJTkNBLUlQOyBhZGQgdG9vbCB0byBhbGxvdyBicnVuaW5nIGltYWdlcyAgdG8KKyAgZmxhc2ggdXNpbmcgYSBCREkyMDAwCisKKyogSW1wbGVtZW50IGZpeCBmb3IgSTJDIEVkZ2UgQ29uZGl0aW9ucyBwcm9ibGVtIGZvciBhbGwgYm9hcmRzIHRoYXQKKyAgdXNlIHRoZSBiaXQtYmFuZ2luZyBkcml2ZXIgKGNvbW1vbi9zb2Z0X2kyYy5jKQorCiAqIFBhdGNoIGJ5IE1hcnRpbiBXaW5pc3RvZXJmZXIsIDIzIE1hciAyMDAzCiAgIC0gQWRkIHBvcnQgdG8gTVBDNTU1LzU1NiBtaWNyb2NvbnRyb2xsZXJzCiAgIC0gQWRkIHN1cHBvcnQgZm9yIGNtaSBjdXN0b21lciBib2FyZCB3aXRoCkBAIC0yMiw2ICs1MiwxMSBAQAogKiBBZGQgcGF0Y2hlcyBieSBSb2JlcnQgU2Nod2ViZWwsIDMxIE1hciAyMDAzOgogICAtIGFkZCBjdHJsLWMgc3VwcG9ydCBmb3Iga2VybWl0IGRvd25sb2FkCiAgIC0gYWxpZ24gYmRpbmZvIG91dHB1dCBvbiBBUk0KKyAgLSBjc2IyMjYgYm9hcmQ6IGJyaW5nIGluIHN5bmMgd2l0aCBpbm5va29tL21lbXNldHVwLlMKKyAgLSBjc2IyMjYgYm9hcmQ6IGZpeCBNRFJFRlIgaGFuZGxpbmcKKyAgLSBtaXNjIGRvYyBmaXhlcyAvIGV4dGVuc2lvbnMKKyAgLSBpbm5va29tIGJvYXJkOiBjbGVhbnVwLCBNRFJFRlIgZml4IGluIG1lbXNldHVwLlMsIGNvbmZpZyB1cGRhdGUKKyAgLSBhZGQgQk9PVF9QUk9HUkVTUyB0byBhcm1saW51eC5jCiAKICogQWRkIENQVSBJRCwgdmVyc2lvbiwgYW5kIGNsb2NrIHNwZWVkIGZvciBJTkNBLUlQCiAKZGlmZiAtLWdpdCBhL0NSRURJVFMgYi9DUkVESVRTCmluZGV4IGU3YWUzNzcuLjg5NTlmZjVmIDEwMDY0NAotLS0gYS9DUkVESVRTCisrKyBiL0NSRURJVFMKQEAgLTEwNCw2ICsxMDQsMTAgQEAKIEQ6IFN1cHBvcnQgZm9yIEludGVycGhhc2UgNDUzOSBUMS9FMS9KMSBQTUMsIFBONjIsIENDTSwgU0NNIGJvYXJkcwogVzogd3d3LmRlbnguZGUKIAorTjogUGV0ZXIgRmlndWxpCitFOiBwZXBvc2hAZXRjLnNrCitEOiBTdXBwb3J0IGZvciBXRVAgRVAyNTAgKFBYQSkgYm9hcmQKKwogTjogVGhvbWFzIEZyaWVkZW4KIEU6IFRob21hc0ZAaHlwZXJpb24tZW50ZXJ0YWlubWVudC5jb20KIEQ6IFN1cHBvcnQgZm9yIEFtaWdhT25lCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDU2ZjI5NmQuLjMzMmU0MTMgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC0yNDEsNiArMjQxLDEwIEBACiAjCUJvYXJkCQkJQ1BVCQkJCQkjCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAKK1BldGVyIEZpZ3VsaSA8cGVwb3NoQGV0Yy5zaz4KKworCXdlcGVwMjUwCQl4c2NhbGUKKwogTWFyaXVzIEdy9mdlciA8bWFnQHN5c2dvLmRlPgogCiAJaW1wYTcJCQlBUk03MjBUIChFUDcyMTEpCkBAIC0yOTYsNiArMzAwLDcgQEAKIFdvbGZnYW5nIERlbmsgPHdkQGRlbnguZGU+CiAKIAlpbmNhaXAJCQlNSVBTMzIgNEtjCisJcHVycGxlCQkJTUlQUzY0IDVLYwogCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIEVuZCBvZiBNQUlOVEFJTkVSUyBsaXN0CQkJCQkJIwpkaWZmIC0tZ2l0IGEvTUFLRUFMTCBiL01BS0VBTEwKaW5kZXggODMwZjlhYy4uMzM4YTFlOCAxMDA2NDQKLS0tIGEvTUFLRUFMTAorKysgYi9NQUtFQUxMCkBAIC0xMTIsNyArMTEyLDcgQEAKICMjIFhzY2FsZSBTeXN0ZW1zCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAKLUxJU1RfeHNjYWxlPSJjcmFkbGUgY3NiMjI2IGlubm9rb20gbHViYm9jayIKK0xJU1RfeHNjYWxlPSJjcmFkbGUgY3NiMjI2IGlubm9rb20gbHViYm9jayB3ZXBlcDI1MCIKIAogCiBMSVNUX2FybT0iJHtMSVNUX1NBfSAke0xJU1RfQVJNN30gJHtMSVNUX0FSTTl9ICR7TElTVF94c2NhbGV9IgpAQCAtMTIzLDcgKzEyMyw5IEBACiAKIExJU1RfbWlwczRrYz0iaW5jYWlwIgogCi1MSVNUX21pcHM9IiR7TElTVF9taXBzNGtjfSIKK0xJU1RfbWlwczVrYz0icHVycGxlIgorCitMSVNUX21pcHM9IiR7TElTVF9taXBzNGtjfSAke0xJU1RfbWlwczVrY30iCiAKIAogIy0tLS0tIGZvciBub3csIGp1c3QgcnVuIFBQQyBieSBkZWZhdWx0IC0tLS0tCmRpZmYgLS1naXQgYS9NYWtlZmlsZSBiL01ha2VmaWxlCmluZGV4IDFmYWU2NDUuLmMwNzc1MjUgMTAwNjQ0Ci0tLSBhL01ha2VmaWxlCisrKyBiL01ha2VmaWxlCkBAIC02MjksNyArNjI5LDYgQEAKIEVMUFBDX2NvbmZpZzogdW5jb25maWcKIAlALi9ta2NvbmZpZyAkKEA6X2NvbmZpZz0pIHBwYyA3NHh4Xzd4eCBlbHBwYyBlbHRlYwogCi0KICM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICMgQVJNCiAjPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CkBAIC02OTksNiArNjk4LDkgQEAKIGx1YmJvY2tfY29uZmlnCToJdW5jb25maWcKIAlALi9ta2NvbmZpZyAkKEA6X2NvbmZpZz0pIGFybSB4c2NhbGUgbHViYm9jawogCit3ZXBlcDI1MF9jb25maWcJOgl1bmNvbmZpZworCUAuL21rY29uZmlnICQoQDpfY29uZmlnPSkgYXJtIHhzY2FsZSB3ZXBlcDI1MAorCiAjPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAjIGkzODYKICM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KQEAgLTcxOCw3ICs3MjAsMTEgQEAKIGluY2FpcF9jb25maWcgOgkJdW5jb25maWcKIAlALi9ta2NvbmZpZyAkKEA6X2NvbmZpZz0pIG1pcHMgbWlwcyBpbmNhaXAKIAorcHVycGxlX2NvbmZpZyA6CQl1bmNvbmZpZworCUAuL21rY29uZmlnICQoQDpfY29uZmlnPSkgbWlwcyBtaXBzIHB1cnBsZQogCisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAKIGNsZWFuOgogCWZpbmQgLiAtdHlwZSBmIFwKQEAgLTcyNiw3ICs3MzIsOCBAQAogCQktbyAtbmFtZSAnKi5vJyAgLW8gLW5hbWUgJyouYScgIFwpIC1wcmludCBcCiAJCXwgeGFyZ3Mgcm0gLWYKIAlybSAtZiBleGFtcGxlcy9oZWxsb193b3JsZCBleGFtcGxlcy90aW1lciBcCi0JICAgICAgZXhhbXBsZXMvZWVwcm8xMDBfZWVwcm9tIGV4YW1wbGVzL3NjaGVkCisJICAgICAgZXhhbXBsZXMvZWVwcm8xMDBfZWVwcm9tIGV4YW1wbGVzL3NjaGVkIFwKKwkgICAgICBleGFtcGxlcy9tZW1fdG9fbWVtX2lkbWEyaW50cgogCXJtIC1mIHRvb2xzL2ltZzJzcmVjIHRvb2xzL21raW1hZ2UgdG9vbHMvZW52Y3JjIHRvb2xzL2dlbl9ldGhfYWRkcgogCXJtIC1mIHRvb2xzL2Vhc3lsb2dvL2Vhc3lsb2dvIHRvb2xzL2JtcF9sb2dvCiAJcm0gLWYgdG9vbHMvZ2RiL2FzdGVzdCB0b29scy9nZGIvZ2RiY29udCB0b29scy9nZGIvZ2Ric2VuZApAQCAtNzQxLDcgKzc0OCw3IEBACiAJcm0gLWZyICouKn4KIAlybSAtZiB1LWJvb3QgdS1ib290LmJpbiB1LWJvb3QuZWxmIHUtYm9vdC5zcmVjIHUtYm9vdC5tYXAgU3lzdGVtLm1hcAogCXJtIC1mIHRvb2xzL2NyYzMyLmMgdG9vbHMvZW52aXJvbm1lbnQuYyB0b29scy9lbnYvY3JjMzIuYwotCXJtIC1mIGNwdS9tcGM4MjR4L2JlZGJ1Z182MDNlLmMKKwlybSAtZiB0b29scy9pbmNhLXN3YXAtYnl0ZXMgY3B1L21wYzgyNHgvYmVkYnVnXzYwM2UuYwogCXJtIC1mIGluY2x1ZGUvYXNtL2FyY2ggaW5jbHVkZS9hc20KIAogbXJwcm9wZXIgXApkaWZmIC0tZ2l0IGEvUkVBRE1FIGIvUkVBRE1FCmluZGV4IDE3Njg3NzkuLjQ1YjFjNTcgMTAwNjQ0Ci0tLSBhL1JFQURNRQorKysgYi9SRUFETUUKQEAgLTE0NjIsNyArMTQ2Miw3IEBACiAKIAkgICBUaGVzZSBzZXR0aW5ncyBkZXNjcmliZSBhIHNlY29uZCBzdG9yYWdlIGFyZWEgdXNlZCB0byBob2xkCiAJICAgYSByZWR1bmRhbmQgY29weSBvZiB0aGUgZW52aXJvbm1lbnQgZGF0YSwgc28gdGhhdCB0aGVyZSBpcwotCSAgIGEgdmFsaWQgYmFja3VwIGNvcHkgaW4gY2FzZSB0aGVyZSBpcyBhIHBvd2VyIGZhaWx1ciBkdXJpbmcKKwkgICBhIHZhbGlkIGJhY2t1cCBjb3B5IGluIGNhc2UgdGhlcmUgaXMgYSBwb3dlciBmYWlsdXJlIGR1cmluZwogCSAgIGEgInNhdmVlbnYiIG9wZXJhdGlvbi4KIAogQkUgQ0FSRUZVTCEgQW55IGNoYW5nZXMgdG8gdGhlIGZsYXNoIGxheW91dCwgYW5kIHNvbWUgY2hhbmdlcyB0byB0aGUKZGlmZiAtLWdpdCBhL2JvYXJkL2NzYjIyNi9tZW1zZXR1cC5TIGIvYm9hcmQvY3NiMjI2L21lbXNldHVwLlMKaW5kZXggNjU2NzE4NC4uNjBmOWQ1MCAxMDA2NDQKLS0tIGEvYm9hcmQvY3NiMjI2L21lbXNldHVwLlMKKysrIGIvYm9hcmQvY3NiMjI2L21lbXNldHVwLlMKQEAgLTM4LDYgKzM4LDkgQEAKICAgIHN1YiAgcGMscGMsIzQKICAgIC5lbmRtCiAKK19URVhUX0JBU0U6CisJLndvcmQJVEVYVF9CQVNFCisKIAogLyoKICAqIAlNZW1vcnkgc2V0dXAKQEAgLTIyMiwyMyArMjI1LDI4IEBACiAgICAgICAgIC8qIFN0ZXAgMmM6IFdyaXRlIEZMWUNORkcgIEZJWE1FOiB3aGF0J3MgdGhhdD8/PyAgICAgICAgICAgICAgICAgICAgKi8KICAgICAgICAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogCisgICAgICAgIC8qIHRlc3QgaWYgd2UgcnVuIGZyb20gZmxhc2ggb3IgUkFNIC0gUkFNL0JESTogZG9uJ3Qgc2V0dXAgUkFNICAgICAgKi8KKwlhZHIJcjMsIG1lbV9pbml0CQkvKiByMCA8LSBjdXJyZW50IHBvc2l0aW9uIG9mIGNvZGUgICAqLworCWxkcglyMiwgPW1lbV9pbml0CisJY21wCXIzLCByMgkJCS8qIHNraXAgaW5pdCBpZiBpbiBwbGFjZSAgICAgICAgICAgICovCisJYmVxCWluaXRpcnFzCisKIAogCS8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICAgICAgICAgLyogU3RlcCAyZDogSW5pdGlhbGl6ZSBUaW1pbmcgZm9yIFN5bmMgTWVtb3J5IChTRENMSzApICAgICAgICAgICAgICAqLwogICAgICAgICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKIAkvKiBCZWZvcmUgYWNjZXNzaW5nIE1EUkVGUiB3ZSBuZWVkIGEgdmFsaWQgRFJJIGZpZWxkLCBzbyB3ZSBzZXQgICAgICovCi0JLyogdGhpcyB0byBwb3dlciBvbiBkZWZhdWx0cyArIERJUiBmaWVsZC4gICAgICAgICAgICAgICAgICAgICAgICAgICAqLworCS8qIHRoaXMgdG8gcG93ZXIgb24gZGVmYXVsdHMgKyBEUkkgZmllbGQuICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KIAotCWxkcglyNCwJPTB4MDNjYTRmZmYKLQlzdHIJcjQsCVtyMSwgI01EUkVGUl9PRkZTRVRdCS8qIHdyaXRlIGJhY2sgTURSRUZSICAgICAgICAqLwotICAgICAgICBsZHIgICAgIHI0LAlbcjEsICNNRFJFRlJfT0ZGU0VUXQorCWxkciAJcjMsIAk9Q0ZHX01EUkVGUl9WQUwKKwlsZHIJcjIsCT0weEZGRgorCWFuZAlyMywJcjMsIHIyCisJbGRyCXI0LAk9MHgwM2NhNDAwMAorCW9ycglyNCwJcjQsICByMwogCi0JbGRyCXI0LAk9MHgwM2NhNDAzMAogCXN0cglyNCwJW3IxLCAjTURSRUZSX09GRlNFVF0JLyogd3JpdGUgYmFjayBNRFJFRlIgICAgICAgICovCi0JbGRyCXI0LAlbcjEsICNNRFJFRlJfT0ZGU0VUXQotCi0gICAgICAgIC8qIE5vdGU6IHByZXNlcnZlIHRoZSBtZHJlZnIgdmFsdWUgaW4gcjQgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICAgICAgbGRyICAgICByNCwJW3IxLCAjTURSRUZSX09GRlNFVF0KIAogCiAJLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtMjU4LDE4ICsyNjYsMTYgQEAKICAgICAgICAgLyogU3RlcCA0OiBJbml0aWFsaXplIFNEUkFNICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwogICAgICAgICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKLQkvKiBTdGVwIDRhOiBhc3NlcnQgTURSRUZSOksxUlVOIGFuZCBNRFJFRlI6SzJSVU4gYW5kIGNvbmZpZ3VyZSAgICAgICovCisJLyogU3RlcCA0YTogYXNzZXJ0IE1EUkVGUjpLP1JVTiBhbmQgY29uZmlndXJlICAgICAgICAgICAgICAgICAgICAgICAqLwogCS8qICAgICAgICAgIE1EUkVGUjpLMURCMiBhbmQgTURSRUZSOksyREIyIGFzIGRlc2lyZWQuICAgICAgICAgICAgICAgKi8KIAotCW9ycglyNCwJcjQsCSMoTURSRUZSX0sxUlVOfE1EUkVGUl9LMFJVTikKLQotCXN0ciAgICAgcjQsICAgICBbcjEsICNNRFJFRlJfT0ZGU0VUXSAgICAvKiB3cml0ZSBiYWNrIE1EUkVGUiAgICAgICAgKi8KLQlsZHIgICAgIHI0LCAgICAgW3IxLCAjTURSRUZSX09GRlNFVF0KLQorCWxkcglyNCwJPUNGR19NRFJFRlJfVkFMCisJc3RyCXI0LAlbcjEsICNNRFJFRlJfT0ZGU0VUXQkvKiB3cml0ZSBiYWNrIE1EUkVGUiAgICAgICAgKi8KKwlsZHIJcjQsCVtyMSwgI01EUkVGUl9PRkZTRVRdCiAKIAkvKiBTdGVwIDRiOiBkZS1hc3NlcnQgTURSRUZSOlNMRlJTSC4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCiAKLQliaWMJcjQsCXI0LAkjKE1EUkVGUl9TTEZSU0gpCisJYmljCXI0LAlyNCwgIyhNRFJFRlJfU0xGUlNIKQogCiAgICAgICAgIHN0ciAgICAgcjQsICAgICBbcjEsICNNRFJFRlJfT0ZGU0VUXSAgICAvKiB3cml0ZSBiYWNrIE1EUkVGUiAgICAgICAgKi8KICAgICAgICAgbGRyICAgICByNCwgICAgIFtyMSwgI01EUkVGUl9PRkZTRVRdCmRpZmYgLS1naXQgYS9ib2FyZC9pbm5va29tL2ZsYXNoLmMgYi9ib2FyZC9pbm5va29tL2ZsYXNoLmMKaW5kZXggMzJjNTdkOC4uYjdjMjA3MiAxMDA2NDQKLS0tIGEvYm9hcmQvaW5ub2tvbS9mbGFzaC5jCisrKyBiL2JvYXJkL2lubm9rb20vZmxhc2guYwpAQCAtMTAsNyArMTAsOCBAQAogICogUm9iZXJ0IFNjaHdlYmVsLCBQZW5ndXRyb25peCwgPHIuc2Nod2ViZWxAcGVuZ3V0cm9uaXguZGU+CiAgKgogICogKEMpIENvcHlyaWdodCAyMDAyCi0gKiBLYWktVXdlIEJsb2VtLCBHRFMsIDxrYWktdXdlLmJsb2VtQGF1ZXJzd2FsZC5kZT4KKyAqIEF1ZXJzd2FsZCBHbWJIICYgQ28gS0csIEdlcm1hbnkgCisgKiBLYWktVXdlIEJsb2VtIDxrYWktdXdlLmJsb2VtQGF1ZXJzd2FsZC5kZT4KICAqCiAgKiBTZWUgZmlsZSBDUkVESVRTIGZvciBsaXN0IG9mIHBlb3BsZSB3aG8gY29udHJpYnV0ZWQgdG8gdGhpcwogICogcHJvamVjdC4KZGlmZiAtLWdpdCBhL2JvYXJkL2lubm9rb20vaW5ub2tvbS5jIGIvYm9hcmQvaW5ub2tvbS9pbm5va29tLmMKaW5kZXggNWVlNTExNy4uZGEyMzhkYSAxMDA2NDQKLS0tIGEvYm9hcmQvaW5ub2tvbS9pbm5va29tLmMKKysrIGIvYm9hcmQvaW5ub2tvbS9pbm5va29tLmMKQEAgLTQ4LDcgKzQ4LDcgQEAKIAlpY3IgPSBJQ1I7IElDUiAmPSB+KElDUl9TQ0xFIHwgSUNSX0lVRSk7CiAJCiAJLyogc2V0IGdwaW8gcGluIGxvdyBfYmVmb3JlXyB3ZSBjaGFuZ2UgZGlyZWN0aW9uIHRvIG91dHB1dCAgICAgICAgICAqLwotCQlHUENSKDcwKSA9IEdQSU9fYml0KDcwKTsKKwlHUENSKDcwKSA9IEdQSU9fYml0KDcwKTsKIAkKIAkvKiBub3cgdG9nZ2xlIGJldHdlZW4gb3V0cHV0PWxvdyBhbmQgaGlnaC1pbXBlZGFuY2UgICAgICAgICAgICAgICAgICovCiAJZm9yIChpID0gMDsgaSA8IDIwOyBpKyspIHsKQEAgLTEwMCwxMyArMTAwLDggQEAKIAkvKiBtZW1vcnkgYW5kIGNwdS1zcGVlZCBhcmUgc2V0dXAgYmVmb3JlIHJlbG9jYXRpb24gKi8KIAkvKiBzbyB3ZSBkbyBfbm90aGluZ18gaGVyZSAqLwogCi0JLyogYXJjaCBudW1iZXIgb2YgSW5ub2tvbSBib2FyZCAqLwogCWdkLT5iZC0+YmlfYXJjaF9udW1iZXIgPSBNQUNIX1RZUEVfSU5OT0tPTTsKLQotCS8qIGFkcmVzcyBvZiBib290IHBhcmFtZXRlcnMgKi8KIAlnZC0+YmQtPmJpX2Jvb3RfcGFyYW1zID0gMHhhMDAwMDEwMDsKLQotCS8qIGJhdWQgcmF0ZSAqLwogCWdkLT5iZC0+YmlfYmF1ZHJhdGUgPSBDT05GSUdfQkFVRFJBVEU7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2JvYXJkL2lubm9rb20vbWVtc2V0dXAuUyBiL2JvYXJkL2lubm9rb20vbWVtc2V0dXAuUwppbmRleCBhMmJjOTlkLi42MGY5ZDUwIDEwMDY0NAotLS0gYS9ib2FyZC9pbm5va29tL21lbXNldHVwLlMKKysrIGIvYm9hcmQvaW5ub2tvbS9tZW1zZXR1cC5TCkBAIC0yMzcsMTcgKzIzNywxNiBAQAogICAgICAgICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKIAkvKiBCZWZvcmUgYWNjZXNzaW5nIE1EUkVGUiB3ZSBuZWVkIGEgdmFsaWQgRFJJIGZpZWxkLCBzbyB3ZSBzZXQgICAgICovCi0JLyogdGhpcyB0byBwb3dlciBvbiBkZWZhdWx0cyArIERJUiBmaWVsZC4gICAgICAgICAgICAgICAgICAgICAgICAgICAqLworCS8qIHRoaXMgdG8gcG93ZXIgb24gZGVmYXVsdHMgKyBEUkkgZmllbGQuICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KIAotCWxkcglyNCwJPTB4MDNjYTRmZmYKLQlzdHIJcjQsCVtyMSwgI01EUkVGUl9PRkZTRVRdCS8qIHdyaXRlIGJhY2sgTURSRUZSICAgICAgICAqLwotICAgICAgICBsZHIgICAgIHI0LAlbcjEsICNNRFJFRlJfT0ZGU0VUXQorCWxkciAJcjMsIAk9Q0ZHX01EUkVGUl9WQUwKKwlsZHIJcjIsCT0weEZGRgorCWFuZAlyMywJcjMsIHIyCisJbGRyCXI0LAk9MHgwM2NhNDAwMAorCW9ycglyNCwJcjQsICByMwogCi0JbGRyCXI0LAk9MHgwM2NhNDAzMAogCXN0cglyNCwJW3IxLCAjTURSRUZSX09GRlNFVF0JLyogd3JpdGUgYmFjayBNRFJFRlIgICAgICAgICovCi0JbGRyCXI0LAlbcjEsICNNRFJFRlJfT0ZGU0VUXQotCi0gICAgICAgIC8qIE5vdGU6IHByZXNlcnZlIHRoZSBtZHJlZnIgdmFsdWUgaW4gcjQgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICAgICAgbGRyICAgICByNCwJW3IxLCAjTURSRUZSX09GRlNFVF0KIAogCiAJLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtMjY3LDE4ICsyNjYsMTYgQEAKICAgICAgICAgLyogU3RlcCA0OiBJbml0aWFsaXplIFNEUkFNICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwogICAgICAgICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKLQkvKiBTdGVwIDRhOiBhc3NlcnQgTURSRUZSOksxUlVOIGFuZCBNRFJFRlI6SzJSVU4gYW5kIGNvbmZpZ3VyZSAgICAgICovCisJLyogU3RlcCA0YTogYXNzZXJ0IE1EUkVGUjpLP1JVTiBhbmQgY29uZmlndXJlICAgICAgICAgICAgICAgICAgICAgICAqLwogCS8qICAgICAgICAgIE1EUkVGUjpLMURCMiBhbmQgTURSRUZSOksyREIyIGFzIGRlc2lyZWQuICAgICAgICAgICAgICAgKi8KIAotCW9ycglyNCwJcjQsCSMoTURSRUZSX0sxUlVOfE1EUkVGUl9LMFJVTikKLQotCXN0ciAgICAgcjQsICAgICBbcjEsICNNRFJFRlJfT0ZGU0VUXSAgICAvKiB3cml0ZSBiYWNrIE1EUkVGUiAgICAgICAgKi8KLQlsZHIgICAgIHI0LCAgICAgW3IxLCAjTURSRUZSX09GRlNFVF0KLQorCWxkcglyNCwJPUNGR19NRFJFRlJfVkFMCisJc3RyCXI0LAlbcjEsICNNRFJFRlJfT0ZGU0VUXQkvKiB3cml0ZSBiYWNrIE1EUkVGUiAgICAgICAgKi8KKwlsZHIJcjQsCVtyMSwgI01EUkVGUl9PRkZTRVRdCiAKIAkvKiBTdGVwIDRiOiBkZS1hc3NlcnQgTURSRUZSOlNMRlJTSC4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCiAKLQliaWMJcjQsCXI0LAkjKE1EUkVGUl9TTEZSU0gpCisJYmljCXI0LAlyNCwgIyhNRFJFRlJfU0xGUlNIKQogCiAgICAgICAgIHN0ciAgICAgcjQsICAgICBbcjEsICNNRFJFRlJfT0ZGU0VUXSAgICAvKiB3cml0ZSBiYWNrIE1EUkVGUiAgICAgICAgKi8KICAgICAgICAgbGRyICAgICByNCwgICAgIFtyMSwgI01EUkVGUl9PRkZTRVRdCmRpZmYgLS1naXQgYS9ib2FyZC9tcGwvY29tbW9uL3BjaS5jIGIvYm9hcmQvbXBsL2NvbW1vbi9wY2kuYwppbmRleCBhMjZmNTQyLi42OTI5MzBiIDEwMDY0NAotLS0gYS9ib2FyZC9tcGwvY29tbW9uL3BjaS5jCisrKyBiL2JvYXJkL21wbC9jb21tb24vcGNpLmMKQEAgLTY1LDIxICs2NSwyMiBAQAogc3RhdGljIHZvaWQgcGNpX3BpcDQwNV9maXh1cF9pcnEoc3RydWN0IHBjaV9jb250cm9sbGVyICpob3NlLCBwY2lfZGV2X3QgZGV2KQogewogCXVuc2lnbmVkIGNoYXIgaW50X2xpbmUgPSAweGZmOworCXVuc2lnbmVkIGNoYXIgcGluOwogCS8qCiAJICogV3JpdGUgcGNpIGludGVycnVwdCBsaW5lIHJlZ2lzdGVyCiAJICovCiAJaWYoUENJX0RFVihkZXYpPT0wKSAvKiBEZXZpY2UwID0gUFBDNDA1IC0+IHNraXAgKi8KIAkJcmV0dXJuOwotCWlmKFBDSV9GVU5DKGRldik9PTApCi0JewotCQkvKiBhc3N1bWluZyBhbGwgZnVuY3Rpb24gMCBhcmUgdXNpbmcgdGhlaXIgSU5UQSMgUGluKi8KLQkJaW50X2xpbmU9UENJX0lSUV9WRUNUT1IoZGV2KTsKLQkJcGNpX2hvc2Vfd3JpdGVfY29uZmlnX2J5dGUoaG9zZSwgZGV2LCBQQ0lfSU5URVJSVVBUX0xJTkUsIGludF9saW5lKTsKKwlwY2lfaG9zZV9yZWFkX2NvbmZpZ19ieXRlKGhvc2UsIGRldiwgUENJX0lOVEVSUlVQVF9QSU4sICZwaW4pOworCWlmICgocGluID09IDApIHx8IChwaW4gPiA0KSkKKwkgICAgcmV0dXJuOworCisJaW50X2xpbmUgPSAoKFBDSV9ERVYoZGV2KSArIChwaW4tMSkgKyAxMCkgJSA0KSArIDI4OworCXBjaV9ob3NlX3dyaXRlX2NvbmZpZ19ieXRlKGhvc2UsIGRldiwgUENJX0lOVEVSUlVQVF9MSU5FLCBpbnRfbGluZSk7CiAjaWZkZWYgREVCVUcKLQkJcHJpbnRmKCJGaXh1cCBJUlE6IGRldiAlZCAoJXgpIGludCBsaW5lICVkIDB4JXhcbiIsCi0JCSAgICAgICBQQ0lfREVWKGRldiksZGV2LGludF9saW5lLGludF9saW5lKTsKKwlwcmludGYoIkZpeHVwIElSUTogZGV2ICVkICgleCkgaW50IGxpbmUgJWQgMHgleFxuIiwKKwkgICAgICAgUENJX0RFVihkZXYpLGRldixpbnRfbGluZSxpbnRfbGluZSk7CiAjZW5kaWYKLQl9CiB9CiAKIGV4dGVybiB2b2lkIHBjaV80MDVncF9pbml0KHN0cnVjdCBwY2lfY29udHJvbGxlciAqaG9zZSk7CkBAIC05MCwxMSArOTEsMzQgQEAKICAgZml4dXBfaXJxOiBwY2lfcGlwNDA1X2ZpeHVwX2lycSwKIH07CiAKKworc3RhdGljIHZvaWQgcmVsb2NfcGNpX2NmZ190YWJsZShzdHJ1Y3QgcGNpX2NvbmZpZ190YWJsZSAqdGFibGUpCit7CisJREVDTEFSRV9HTE9CQUxfREFUQV9QVFI7CisJdW5zaWduZWQgbG9uZyBhZGRyOworCisJZm9yICg7IHRhYmxlICYmIHRhYmxlLT52ZW5kb3I7IHRhYmxlKyspIHsKKyAJCWFkZHIgPSAodWxvbmcpICh0YWJsZS0+Y29uZmlnX2RldmljZSkgKyBnZC0+cmVsb2Nfb2ZmOworI2lmZGVmIERFQlVHCisJCXByaW50ZiAoImRldmljZSBcIiVkXCI6IDB4JTA4bHggPT4gMHglMDhseFxuIiwKKwkJCQl0YWJsZS0+ZGV2aWNlLCAodWxvbmcpICh0YWJsZS0+Y29uZmlnX2RldmljZSksIGFkZHIpOworI2VuZGlmCisJCXRhYmxlLT5jb25maWdfZGV2aWNlID0KKwkJCSh2b2lkICgqKShzdHJ1Y3QgcGNpX2NvbnRyb2xsZXIqIGhvc2UsIHBjaV9kZXZfdCBkZXYsCisJCQkgICAgICBzdHJ1Y3QgcGNpX2NvbmZpZ190YWJsZSAqKSlhZGRyOworCQl0YWJsZS0+cHJpdlswXSs9Z2QtPnJlbG9jX29mZjsKKwl9Cit9CisKIHZvaWQgcGNpX2luaXRfYm9hcmQodm9pZCkKIHsKIAkvKndlIHdhbnQgdGhlIHB0cnMgdG8gUkFNIG5vdCBmbGFzaCAoaWUgZG9uJ3QgdXNlIGluaXQgbGlzdCkqLwogCWhvc2UuZml4dXBfaXJxICAgID0gcGNpX3BpcDQwNV9maXh1cF9pcnE7CiAJaG9zZS5jb25maWdfdGFibGUgPSBwY2lfcGlwNDA1X2NvbmZpZ190YWJsZTsKKwlyZWxvY19wY2lfY2ZnX3RhYmxlKGhvc2UuY29uZmlnX3RhYmxlKTsKKyNpZmRlZiBERUJVRworCXByaW50ZigiSW5pdCBQQ0k6IGZpeHVwX2lycT0lcCBjb25maWdfdGFibGU9JXAgaG9zZT0lcFxuIixwY2lfcGlwNDA1X2ZpeHVwX2lycSxwY2lfcGlwNDA1X2NvbmZpZ190YWJsZSxob3NlKTsKKyNlbmRpZgogCXBjaV80MDVncF9pbml0KCZob3NlKTsKIH0KIApkaWZmIC0tZ2l0IGEvYm9hcmQvbXBsL21pcDQwNS9taXA0MDUuYyBiL2JvYXJkL21wbC9taXA0MDUvbWlwNDA1LmMKaW5kZXggOGJhYjQ3Yy4uOTVhZDk3YyAxMDA2NDQKLS0tIGEvYm9hcmQvbXBsL21pcDQwNS9taXA0MDUuYworKysgYi9ib2FyZC9tcGwvbWlwNDA1L21pcDQwNS5jCkBAIC0xMjgsNiArMTI4LDE1IEBACiAgIAkJMiwJLyogQWRkcmVzcyBNb2RlID0gMiAqLwogCQk0LAkvKiBzaXplIHZhbHVlICovCiAJCTF9LAkvKiBFQ0MgZW5hYmxlZCAqLworCXsgMHgwMywJLyogUmV2IEEsIDEyOE1CeXRlIC00IEJvYXJkICovCisJCTMsCS8qIENhc2UgTGF0ZW50eSA9IDMgKi8KKwkJMywJLyogdHJwIDIwbnMgLyA3LjUgbnMgZGF0YWluWzI3XSAqLworICAJCTMsIAkvKiB0cmNkIDIwbnMgLzcuNSBucyAoZGF0YWluWzI5XSkgKi8KKyAgCQk2LCAgLyogdHJhcyA0NG5zIC83LjUgbnMgIChkYXRhaW5bMzBdKSAqLworCQk0LAkvKiB0Y3B0IDQ0IC0gMjBucyA9IDI0bnMgKi8KKyAgCQkzLAkvKiBBZGRyZXNzIE1vZGUgPSAzICovCisJCTUsCS8qIHNpemUgdmFsdWUgKi8KKwkJMX0sCS8qIEVDQyBlbmFibGVkICovCiAJeyAweGZmLCAvKiB0ZXJtaW5hdG9yICovCiAJICAweGZmLAogCSAgMHhmZiwKQEAgLTYxNiw5ICs2MjUsMTUgQEAKIAogaW50IGxhc3Rfc3RhZ2VfaW5pdCAodm9pZCkKIHsKKwkvKiB3cml0ZSBjb3JyZWN0IExFRCBjb25maWd1cmF0aW9uICovCiAJaWYgKG1paXBoeV93cml0ZSAoMHgxLCAweDE0LCAweDI0MDIpICE9IDApIHsKIAkJcHJpbnRmICgiRXJyb3Igd3JpdGluZyB0byB0aGUgUEhZXG4iKTsKIAl9CisJLyogc2luY2UgTEVEL0NGRzIgaXMgbm90IGNvbm5lY3RlZCBvbiB0aGUgLTIsCisJICogd3JpdGUgdG8gY29ycmVjdCBjYXBhYmlsaXR5IGluZm9ybWF0aW9uICovCisJaWYgKG1paXBoeV93cml0ZSAoMHgxLCAweDQsIDB4MDFFMSkgIT0gMCkgeworCQlwcmludGYgKCJFcnJvciB3cml0aW5nIHRvIHRoZSBQSFlcbiIpOworCX0KIAlwcmludF9taXA0MDVfcmV2ICgpOwogCXNob3dfc3RkaW9fZGV2ICgpOwogCWNoZWNrX2VudiAoKTsKZGlmZiAtLWdpdCBhL2JvYXJkL3N2bV9zYzh4eC9wcGNib290LmxkcyBiL2JvYXJkL3N2bV9zYzh4eC9wcGNib290LmxkcwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNWY1ZTJlNC4uMDAwMDAwMAotLS0gYS9ib2FyZC9zdm1fc2M4eHgvcHBjYm9vdC5sZHMKKysrIC9kZXYvbnVsbApAQCAtMSwxMzMgKzAsMCBAQAotLyoKLSAqIChDKSBDb3B5cmlnaHQgMjAwMAotICogV29sZmdhbmcgRGVuaywgREVOWCBTb2Z0d2FyZSBFbmdpbmVlcmluZywgd2RAZGVueC5kZS4KLSAqCi0gKiBTZWUgZmlsZSBDUkVESVRTIGZvciBsaXN0IG9mIHBlb3BsZSB3aG8gY29udHJpYnV0ZWQgdG8gdGhpcwotICogcHJvamVjdC4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCi0gKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YKLSAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCi0gKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLAotICogTUEgMDIxMTEtMTMwNyBVU0EKLSAqLwotCi1PVVRQVVRfQVJDSChwb3dlcnBjKQotU0VBUkNIX0RJUigvbGliKTsgU0VBUkNIX0RJUigvdXNyL2xpYik7IFNFQVJDSF9ESVIoL3Vzci9sb2NhbC9saWIpOyBTRUFSQ0hfRElSKC91c3IvbG9jYWwvcG93ZXJwYy1hbnktZWxmL2xpYik7Ci0vKiBEbyB3ZSBuZWVkIGFueSBvZiB0aGVzZSBmb3IgZWxmPwotICAgX19EWU5BTUlDID0gMDsgICAgKi8KLVNFQ1RJT05TCi17Ci0gIC8qIFJlYWQtb25seSBzZWN0aW9ucywgbWVyZ2VkIGludG8gdGV4dCBzZWdtZW50OiAqLwotICAuID0gKyBTSVpFT0ZfSEVBREVSUzsKLSAgLmludGVycCA6IHsgKiguaW50ZXJwKSB9Ci0gIC5oYXNoICAgICAgICAgIDogeyAqKC5oYXNoKQkJfQotICAuZHluc3ltICAgICAgICA6IHsgKiguZHluc3ltKQkJfQotICAuZHluc3RyICAgICAgICA6IHsgKiguZHluc3RyKQkJfQotICAucmVsLnRleHQgICAgICA6IHsgKigucmVsLnRleHQpCQl9Ci0gIC5yZWxhLnRleHQgICAgIDogeyAqKC5yZWxhLnRleHQpIAl9Ci0gIC5yZWwuZGF0YSAgICAgIDogeyAqKC5yZWwuZGF0YSkJCX0KLSAgLnJlbGEuZGF0YSAgICAgOiB7ICooLnJlbGEuZGF0YSkgCX0KLSAgLnJlbC5yb2RhdGEgICAgOiB7ICooLnJlbC5yb2RhdGEpIAl9Ci0gIC5yZWxhLnJvZGF0YSAgIDogeyAqKC5yZWxhLnJvZGF0YSkgCX0KLSAgLnJlbC5nb3QgICAgICAgOiB7ICooLnJlbC5nb3QpCQl9Ci0gIC5yZWxhLmdvdCAgICAgIDogeyAqKC5yZWxhLmdvdCkJCX0KLSAgLnJlbC5jdG9ycyAgICAgOiB7ICooLnJlbC5jdG9ycykJfQotICAucmVsYS5jdG9ycyAgICA6IHsgKigucmVsYS5jdG9ycykJfQotICAucmVsLmR0b3JzICAgICA6IHsgKigucmVsLmR0b3JzKQl9Ci0gIC5yZWxhLmR0b3JzICAgIDogeyAqKC5yZWxhLmR0b3JzKQl9Ci0gIC5yZWwuYnNzICAgICAgIDogeyAqKC5yZWwuYnNzKQkJfQotICAucmVsYS5ic3MgICAgICA6IHsgKigucmVsYS5ic3MpCQl9Ci0gIC5yZWwucGx0ICAgICAgIDogeyAqKC5yZWwucGx0KQkJfQotICAucmVsYS5wbHQgICAgICA6IHsgKigucmVsYS5wbHQpCQl9Ci0gIC5pbml0ICAgICAgICAgIDogeyAqKC5pbml0KQl9Ci0gIC5wbHQgOiB7ICooLnBsdCkgfQotICAudGV4dCAgICAgIDoKLSAgewotICAgIC8qIFdBUk5JTkcgLSB0aGUgZm9sbG93aW5nIGlzIGhhbmQtb3B0aW1pemVkIHRvIGZpdCB3aXRoaW4JKi8KLSAgICAvKiB0aGUgc2VjdG9yIGxheW91dCBvZiBvdXIgZmxhc2ggY2hpcHMhCVhYWCBGSVhNRSBYWFgJKi8KLQotICAgIGNwdS9tcGM4eHgvc3RhcnQubwkoLnRleHQpCi0gICAgY29tbW9uL2RsbWFsbG9jLm8JKC50ZXh0KQotICAgIHBwYy9wcGNzdHJpbmcubwkoLnRleHQpCi0gICAgcHBjL3ZzcHJpbnRmLm8JKC50ZXh0KQotICAgIHBwYy9jcmMzMi5vCQkoLnRleHQpCi0gICAgcHBjL3psaWIubwkJKC50ZXh0KQotCi0gICAgLiA9IGVudl9vZmZzZXQ7Ci0gICAgY29tbW9uL2Vudmlyb25tZW50Lm8oLnRleHQpCi0KLSAgICAqKC50ZXh0KQotICAgICooLmZpeHVwKQotICAgICooLmdvdDEpCi0gIH0KLSAgX2V0ZXh0ID0gLjsKLSAgUFJPVklERSAoZXRleHQgPSAuKTsKLSAgLnJvZGF0YSAgICA6Ci0gIHsKLSAgICAqKC5yb2RhdGEpCi0gICAgKigucm9kYXRhMSkKLSAgfQotICAuZmluaSAgICAgIDogeyAqKC5maW5pKSAgICB9ID0wCi0gIC5jdG9ycyAgICAgOiB7ICooLmN0b3JzKSAgIH0KLSAgLmR0b3JzICAgICA6IHsgKiguZHRvcnMpICAgfQotCi0gIC8qIFJlYWQtd3JpdGUgc2VjdGlvbiwgbWVyZ2VkIGludG8gZGF0YSBzZWdtZW50OiAqLwotICAuID0gKC4gKyAweDAwRkYpICYgMHhGRkZGRkYwMDsKLSAgX2Vyb3RleHQgPSAuOwotICBQUk9WSURFIChlcm90ZXh0ID0gLik7Ci0gIC5yZWxvYyAgIDoKLSAgewotICAgICooLmdvdCkKLSAgICBfR09UMl9UQUJMRV8gPSAuOwotICAgICooLmdvdDIpCi0gICAgX0ZJWFVQX1RBQkxFXyA9IC47Ci0gICAgKiguZml4dXApCi0gIH0KLSAgX19nb3QyX2VudHJpZXMgPSAoX0ZJWFVQX1RBQkxFXyAtIF9HT1QyX1RBQkxFXykgPj4yOwotICBfX2ZpeHVwX2VudHJpZXMgPSAoLiAtIF9GSVhVUF9UQUJMRV8pPj4yOwotCi0gIC5kYXRhICAgIDoKLSAgewotICAgICooLmRhdGEpCi0gICAgKiguZGF0YTEpCi0gICAgKiguc2RhdGEpCi0gICAgKiguc2RhdGEyKQotICAgICooLmR5bmFtaWMpCi0gICAgQ09OU1RSVUNUT1JTCi0gIH0KLSAgX2VkYXRhICA9ICAuOwotICBQUk9WSURFIChlZGF0YSA9IC4pOwotCi0gIF9fc3RhcnRfX19leF90YWJsZSA9IC47Ci0gIF9fZXhfdGFibGUgOiB7ICooX19leF90YWJsZSkgfQotICBfX3N0b3BfX19leF90YWJsZSA9IC47Ci0KLSAgLiA9IEFMSUdOKDI1Nik7Ci0gIF9faW5pdF9iZWdpbiA9IC47Ci0gIC50ZXh0LmluaXQgOiB7ICooLnRleHQuaW5pdCkgfQotICAuZGF0YS5pbml0IDogeyAqKC5kYXRhLmluaXQpIH0KLSAgLiA9IEFMSUdOKDI1Nik7Ci0gIF9faW5pdF9lbmQgPSAuOwotCi0gIF9fYnNzX3N0YXJ0ID0gLjsKLSAgLmJzcyAgICAgICA6Ci0gIHsKLSAgICooLnNic3MpICooLnNjb21tb24pCi0gICAqKC5keW5ic3MpCi0gICAqKC5ic3MpCi0gICAqKENPTU1PTikKLSAgfQotICBfZW5kID0gLiA7Ci0gIFBST1ZJREUgKGVuZCA9IC4pOwotfQotCmRpZmYgLS1naXQgYS9ib2FyZC9zdm1fc2M4eHgvcHBjYm9vdC5sZHMuZGVidWcgYi9ib2FyZC9zdm1fc2M4eHgvcHBjYm9vdC5sZHMuZGVidWcKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYyMzBhNmIuLjAwMDAwMDAKLS0tIGEvYm9hcmQvc3ZtX3NjOHh4L3BwY2Jvb3QubGRzLmRlYnVnCisrKyAvZGV2L251bGwKQEAgLTEsMTMxICswLDAgQEAKLS8qCi0gKiAoQykgQ29weXJpZ2h0IDIwMDAKLSAqIFdvbGZnYW5nIERlbmssIERFTlggU29mdHdhcmUgRW5naW5lZXJpbmcsIHdkQGRlbnguZGUuCi0gKgotICogU2VlIGZpbGUgQ1JFRElUUyBmb3IgbGlzdCBvZiBwZW9wbGUgd2hvIGNvbnRyaWJ1dGVkIHRvIHRoaXMKLSAqIHByb2plY3QuCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgotICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mCi0gKiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQotICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwKLSAqIE1BIDAyMTExLTEzMDcgVVNBCi0gKi8KLQotT1VUUFVUX0FSQ0gocG93ZXJwYykKLVNFQVJDSF9ESVIoL2xpYik7IFNFQVJDSF9ESVIoL3Vzci9saWIpOyBTRUFSQ0hfRElSKC91c3IvbG9jYWwvbGliKTsgU0VBUkNIX0RJUigvdXNyL2xvY2FsL3Bvd2VycGMtYW55LWVsZi9saWIpOwotLyogRG8gd2UgbmVlZCBhbnkgb2YgdGhlc2UgZm9yIGVsZj8KLSAgIF9fRFlOQU1JQyA9IDA7ICAgICovCi1TRUNUSU9OUwotewotICAvKiBSZWFkLW9ubHkgc2VjdGlvbnMsIG1lcmdlZCBpbnRvIHRleHQgc2VnbWVudDogKi8KLSAgLiA9ICsgU0laRU9GX0hFQURFUlM7Ci0gIC5pbnRlcnAgOiB7ICooLmludGVycCkgfQotICAuaGFzaCAgICAgICAgICA6IHsgKiguaGFzaCkJCX0KLSAgLmR5bnN5bSAgICAgICAgOiB7ICooLmR5bnN5bSkJCX0KLSAgLmR5bnN0ciAgICAgICAgOiB7ICooLmR5bnN0cikJCX0KLSAgLnJlbC50ZXh0ICAgICAgOiB7ICooLnJlbC50ZXh0KQkJfQotICAucmVsYS50ZXh0ICAgICA6IHsgKigucmVsYS50ZXh0KSAJfQotICAucmVsLmRhdGEgICAgICA6IHsgKigucmVsLmRhdGEpCQl9Ci0gIC5yZWxhLmRhdGEgICAgIDogeyAqKC5yZWxhLmRhdGEpIAl9Ci0gIC5yZWwucm9kYXRhICAgIDogeyAqKC5yZWwucm9kYXRhKSAJfQotICAucmVsYS5yb2RhdGEgICA6IHsgKigucmVsYS5yb2RhdGEpIAl9Ci0gIC5yZWwuZ290ICAgICAgIDogeyAqKC5yZWwuZ290KQkJfQotICAucmVsYS5nb3QgICAgICA6IHsgKigucmVsYS5nb3QpCQl9Ci0gIC5yZWwuY3RvcnMgICAgIDogeyAqKC5yZWwuY3RvcnMpCX0KLSAgLnJlbGEuY3RvcnMgICAgOiB7ICooLnJlbGEuY3RvcnMpCX0KLSAgLnJlbC5kdG9ycyAgICAgOiB7ICooLnJlbC5kdG9ycykJfQotICAucmVsYS5kdG9ycyAgICA6IHsgKigucmVsYS5kdG9ycykJfQotICAucmVsLmJzcyAgICAgICA6IHsgKigucmVsLmJzcykJCX0KLSAgLnJlbGEuYnNzICAgICAgOiB7ICooLnJlbGEuYnNzKQkJfQotICAucmVsLnBsdCAgICAgICA6IHsgKigucmVsLnBsdCkJCX0KLSAgLnJlbGEucGx0ICAgICAgOiB7ICooLnJlbGEucGx0KQkJfQotICAuaW5pdCAgICAgICAgICA6IHsgKiguaW5pdCkJfQotICAucGx0IDogeyAqKC5wbHQpIH0KLSAgLnRleHQgICAgICA6Ci0gIHsKLSAgICAvKiBXQVJOSU5HIC0gdGhlIGZvbGxvd2luZyBpcyBoYW5kLW9wdGltaXplZCB0byBmaXQgd2l0aGluCSovCi0gICAgLyogdGhlIHNlY3RvciBsYXlvdXQgb2Ygb3VyIGZsYXNoIGNoaXBzIQlYWFggRklYTUUgWFhYCSovCi0KLSAgICBjcHUvbXBjOHh4L3N0YXJ0Lm8JKC50ZXh0KQotICAgIGNvbW1vbi9kbG1hbGxvYy5vCSgudGV4dCkKLSAgICBwcGMvdnNwcmludGYubwkoLnRleHQpCi0gICAgcHBjL2NyYzMyLm8JCSgudGV4dCkKLQotICAgIC4gPSBlbnZfb2Zmc2V0OwotICAgIGNvbW1vbi9lbnZpcm9ubWVudC5vKC50ZXh0KQotCi0gICAgKigudGV4dCkKLSAgICAqKC5maXh1cCkKLSAgICAqKC5nb3QxKQotICB9Ci0gIF9ldGV4dCA9IC47Ci0gIFBST1ZJREUgKGV0ZXh0ID0gLik7Ci0gIC5yb2RhdGEgICAgOgotICB7Ci0gICAgKigucm9kYXRhKQotICAgICooLnJvZGF0YTEpCi0gIH0KLSAgLmZpbmkgICAgICA6IHsgKiguZmluaSkgICAgfSA9MAotICAuY3RvcnMgICAgIDogeyAqKC5jdG9ycykgICB9Ci0gIC5kdG9ycyAgICAgOiB7ICooLmR0b3JzKSAgIH0KLQotICAvKiBSZWFkLXdyaXRlIHNlY3Rpb24sIG1lcmdlZCBpbnRvIGRhdGEgc2VnbWVudDogKi8KLSAgLiA9ICguICsgMHgwRkZGKSAmIDB4RkZGRkYwMDA7Ci0gIF9lcm90ZXh0ID0gLjsKLSAgUFJPVklERSAoZXJvdGV4dCA9IC4pOwotICAucmVsb2MgICA6Ci0gIHsKLSAgICAqKC5nb3QpCi0gICAgX0dPVDJfVEFCTEVfID0gLjsKLSAgICAqKC5nb3QyKQotICAgIF9GSVhVUF9UQUJMRV8gPSAuOwotICAgICooLmZpeHVwKQotICB9Ci0gIF9fZ290Ml9lbnRyaWVzID0gKF9GSVhVUF9UQUJMRV8gLSBfR09UMl9UQUJMRV8pID4+MjsKLSAgX19maXh1cF9lbnRyaWVzID0gKC4gLSBfRklYVVBfVEFCTEVfKT4+MjsKLQotICAuZGF0YSAgICA6Ci0gIHsKLSAgICAqKC5kYXRhKQotICAgICooLmRhdGExKQotICAgICooLnNkYXRhKQotICAgICooLnNkYXRhMikKLSAgICAqKC5keW5hbWljKQotICAgIENPTlNUUlVDVE9SUwotICB9Ci0gIF9lZGF0YSAgPSAgLjsKLSAgUFJPVklERSAoZWRhdGEgPSAuKTsKLQotICBfX3N0YXJ0X19fZXhfdGFibGUgPSAuOwotICBfX2V4X3RhYmxlIDogeyAqKF9fZXhfdGFibGUpIH0KLSAgX19zdG9wX19fZXhfdGFibGUgPSAuOwotCi0gIC4gPSBBTElHTig0MDk2KTsKLSAgX19pbml0X2JlZ2luID0gLjsKLSAgLnRleHQuaW5pdCA6IHsgKigudGV4dC5pbml0KSB9Ci0gIC5kYXRhLmluaXQgOiB7ICooLmRhdGEuaW5pdCkgfQotICAuID0gQUxJR04oNDA5Nik7Ci0gIF9faW5pdF9lbmQgPSAuOwotCi0gIF9fYnNzX3N0YXJ0ID0gLjsKLSAgLmJzcyAgICAgICA6Ci0gIHsKLSAgICooLnNic3MpICooLnNjb21tb24pCi0gICAqKC5keW5ic3MpCi0gICAqKC5ic3MpCi0gICAqKENPTU1PTikKLSAgfQotICBfZW5kID0gLiA7Ci0gIFBST1ZJREUgKGVuZCA9IC4pOwotfQotCmRpZmYgLS1naXQgYS9ib2FyZC93ZXBlcDI1MC9NYWtlZmlsZSBiL2JvYXJkL3dlcGVwMjUwL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ0MzE0ZDcKLS0tIC9kZXYvbnVsbAorKysgYi9ib2FyZC93ZXBlcDI1MC9NYWtlZmlsZQpAQCAtMCwwICsxLDQ3IEBACisjCisjIChDKSBDb3B5cmlnaHQgMjAwMCwgMjAwMgorIyBXb2xmZ2FuZyBEZW5rLCBERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nLCB3ZEBkZW54LmRlLgorIworIyBTZWUgZmlsZSBDUkVESVRTIGZvciBsaXN0IG9mIHBlb3BsZSB3aG8gY29udHJpYnV0ZWQgdG8gdGhpcworIyBwcm9qZWN0LgorIworIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisjIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzCisjIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mCisjIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIworIyBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyMgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorIyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIworIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorIyBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLAorIyBNQSAwMjExMS0xMzA3IFVTQQorIworCitpbmNsdWRlICQoVE9QRElSKS9jb25maWcubWsKKworTElCCT0gbGliJChCT0FSRCkuYQorCitPQkpTCTo9IHdlcGVwMjUwLm8gZmxhc2gubworU09CSlMJOj0gbWVtc2V0dXAubworCiskKExJQik6CSQoT0JKUykgJChTT0JKUykKKwkkKEFSKSBjcnYgJEAgJF4KKworY2xlYW46CisJcm0gLWYgJChTT0JKUykgJChPQkpTKQorCitkaXN0Y2xlYW46CWNsZWFuCisJcm0gLWYgJChMSUIpIGNvcmUgKi5iYWsgLmRlcGVuZAorCisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCisKKy5kZXBlbmQ6CU1ha2VmaWxlICQoU09CSlM6Lm89LlMpICQoT0JKUzoubz0uYykKKwkJJChDQykgLU0gJChDUFBGTEFHUykgJChTT0JKUzoubz0uUykgJChPQkpTOi5vPS5jKSA+ICRACisKKy1pbmNsdWRlIC5kZXBlbmQKKworIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvYm9hcmQvd2VwZXAyNTAvY29uZmlnLm1rIGIvYm9hcmQvd2VwZXAyNTAvY29uZmlnLm1rCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc5MmYwZWUKLS0tIC9kZXYvbnVsbAorKysgYi9ib2FyZC93ZXBlcDI1MC9jb25maWcubWsKQEAgLTAsMCArMSwxMSBAQAorIworIyBUaGlzIGlzIGNvbmZpZyB1c2VkIGZvciBjb21waWxhdGlvbiBvZiBXRVAgRVAyNTAgc291cmNlcworIworIyBZb3UgbWlnaHQgY2hhbmdlIGxvY2F0aW9uIG9mIFUtQm9vdCBpbiBtZW1vcnkgYnkgc2V0dGluZyByaWdodCBURVhUX0JBU0UuCisjIFRoaXMgYWxsb3dzIGZvciBleGFtcGxlIGhhdmluZyBvbmUgY29weSBsb2NhdGVkIGF0IHRoZSBlbmQgb2YgcmFtIGFuZCBzdG9yZWQKKyMgaW4gZmxhc2ggZGV2aWNlIGFuZCBsYXRlciBvbiB3aGlsZSBkZXZlbG9waW5nIHVzZSBvdGhlciBsb2NhdGlvbiB0byB0ZXN0CisjIHRoZSBjb2RlIGluIFJBTSBkZXZpY2Ugb25seS4KKyMKKworVEVYVF9CQVNFID0gMHhhMWZlMDAwMAorI1RFWFRfQkFTRSA9IDB4YTEwMDEwMDAKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9ib2FyZC93ZXBlcDI1MC9mbGFzaC5jIGIvYm9hcmQvd2VwZXAyNTAvZmxhc2guYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMTlkZGRjCi0tLSAvZGV2L251bGwKKysrIGIvYm9hcmQvd2VwZXAyNTAvZmxhc2guYwpAQCAtMCwwICsxLDMyMSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwMyBFVEMgcy5yLm8uCisgKgorICogVGhpcyBjb2RlIHdhcyBpbnNwaXJlZCBieSBNYXJpdXMgR3JvZWdlciBhbmQgS3lsZSBIYXJyaXMgY29kZQorICogYXZhaWxhYmxlIGluIG90aGVyIGJvYXJkIHBvcnRzIGZvciBVLUJvb3QKKyAqCisgKiBTZWUgZmlsZSBDUkVESVRTIGZvciBsaXN0IG9mIHBlb3BsZSB3aG8gY29udHJpYnV0ZWQgdG8gdGhpcworICogcHJvamVjdC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YKKyAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLAorICogTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKiBXcml0dGVuIGJ5IFBldGVyIEZpZ3VsaSA8cGVwb3NoQGV0Yy5zaz4sIDIwMDMuCisgKgorICovCisKKyNpbmNsdWRlIDxjb21tb24uaD4KKyNpbmNsdWRlICJpbnRlbC5oIgorCisKKy8qCisgKiBUaGlzIGNvZGUgc2hvdWxkIGhhbmRsZSBDRkkgRkxBU0ggbWVtb3J5IGRldmljZS4gVGhpcyBjb2RlIGlzIHZlcnkKKyAqIG1pbmltYWxpc3RpYyBhcHByb2FjaCB3aXRob3V0IG1hbnkgZXNzZW50aWFsIGVycm9yIGhhbmRsaW5nIGNvZGUgYXMgd2VsbC4KKyAqIEJlY2F1c2UgVS1Cb290IGFjdHVhbGx5IGlzIG1pc3Npbmcgc21hcnQgaGFuZGxpbmcgb2YgRkxBU0ggZGV2aWNlLAorICogd2UganVzdCBzZXQgZmxhc2hfaWQgdG8gYW55dGhpbmcgZWxzZSB0byBGTEFTSF9VTktOT1csIHNvIGNvbW1vbiBjb2RlCisgKiBjYW4gY2FsbCB1cyB3aXRob3V0IGFueSByZXN0cmljdGlvbnMuCisgKiBUT0RPOiBBZGQgQ0ZJIFF1ZXJ5LCB0byBiZSBhYmxlIHRvIGRldGVybWluZSBGTEFTSCBkZXZpY2UuCisgKiBUT0RPOiBBZGQgZXJyb3IgaGFuZGxpbmcgY29kZQorICogTk9URTogVGhpcyBjb2RlIHdhcyB0ZXN0ZWQgd2l0aCBCVVNfV0lEVEggNCBhbmQgSVRFUkxFQVZFIDIgb25seSwgYnV0CisgKiAgICAgICBob3BlZnVsbHkgbWF5IHdvcmsgd2l0aCBvdGhlciBjb25maWd1cmF0aW9ucy4KKyAqLworCisjaWYgKCBXRVBfRkxBU0hfQlVTX1dJRFRIID09IDEgKQorIyAgZGVmaW5lIEZMQVNIX0JVUyB2dV9jaGFyCisjICBpZiAoIFdFUF9GTEFTSF9JTlRFUkxFQVZFID09IDEgKQorIyAgICBkZWZpbmUgRkxBU0hfQ01EKCB4ICkgeAorIyAgZWxzZQorIyAgICBlcnJvciAiV2l0aCA4Yml0IGJ1cyBvbmx5IG9uZSBjaGlwIGlzIGFsbG93ZWQiCisjICBlbmRpZgorCisKKyNlbGlmICggV0VQX0ZMQVNIX0JVU19XSURUSCA9PSAyICkKKyMgIGRlZmluZSBGTEFTSF9CVVMgdnVfc2hvcnQKKyMgIGlmICggV0VQX0ZMQVNIX0lOVEVSTEVBVkUgPT0gMSApCisjICAgIGRlZmluZSBGTEFTSF9DTUQoIHggKSB4CisjICBlbGlmICggV0VQX0ZMQVNIX0lOVEVSTEVBVkUgPT0gMiApCisjICAgIGRlZmluZSBGTEFTSF9DTUQoIHggKSAoKCB4IDw8IDggKXwgeCApCisjICBlbHNlCisjICAgIGVycm9yICJXaXRoIDE2Yml0IGJ1cyBvbmx5IDEgb3IgMiBjaGlwKHMpIGFyZSBhbGxvd2VkIgorIyAgZW5kaWYKKworCisjZWxpZiAoIFdFUF9GTEFTSF9CVVNfV0lEVEggPT0gNCApCisjICBkZWZpbmUgRkxBU0hfQlVTIHZ1X2xvbmcKKyMgIGlmICggV0VQX0ZMQVNIX0lOVEVSTEVBVkUgPT0gMSApCisjICAgIGRlZmluZSBGTEFTSF9DTUQoIHggKSB4CisjICBlbGlmICggV0VQX0ZMQVNIX0lOVEVSTEVBVkUgPT0gMiApCisjICAgIGRlZmluZSBGTEFTSF9DTUQoIHggKSAoKCB4IDw8IDE2ICl8IHggKQorIyAgZWxpZiAoIFdFUF9GTEFTSF9JTlRFUkxFQVZFID09IDQgKQorIyAgICBkZWZpbmUgRkxBU0hfQ01EKCB4ICkgKCggeCA8PCAyNCApfCggeCA8PCAxNiApICggeCA8PCA4ICl8IHggKQorIyAgZWxzZQorIyAgICBlcnJvciAiV2l0aCAzMmJpdCBidXMgb25seSAxLDIgb3IgNCBjaGlwKHMpIGFyZSBhbGxvd2VkIgorIyAgZW5kaWYKKworI2Vsc2UKKyMgIGVycm9yICJGbGFzaCBidXMgd2lkdGggbWlnaHQgYmUgMSwyLDQgZm9yIDgsMTYsMzIgYml0IGNvbmZpZ3VyYXRpb24iCisjZW5kaWYKKworCitmbGFzaF9pbmZvX3QgZmxhc2hfaW5mb1tDRkdfTUFYX0ZMQVNIX0JBTktTXTsKKworc3RhdGljIEZMQVNIX0JVUyBmbGFzaF9zdGF0dXNfcmVnICh2b2lkKQoreworCisJRkxBU0hfQlVTICphZGRyID0gKEZMQVNIX0JVUyAqKSAwOworCisJKmFkZHIgPSBGTEFTSF9DTUQgKENGSV9JTlRFTF9DTURfUkVBRF9TVEFUVVNfUkVHSVNURVIpOworCisJcmV0dXJuICphZGRyOworfQorCitzdGF0aWMgaW50IGZsYXNoX3JlYWR5ICh1bG9uZyB0aW1lb3V0KQoreworCWludCBvayA9IDE7CisKKwlyZXNldF90aW1lcl9tYXNrZWQgKCk7CisJd2hpbGUgKChmbGFzaF9zdGF0dXNfcmVnICgpICYgRkxBU0hfQ01EIChDRklfSU5URUxfU1JfUkVBRFkpKSAhPQorCQkgICBGTEFTSF9DTUQgKENGSV9JTlRFTF9TUl9SRUFEWSkpIHsKKwkJaWYgKGdldF90aW1lcl9tYXNrZWQgKCkgPiB0aW1lb3V0ICYmIHRpbWVvdXQgIT0gMCkgeworCQkJb2sgPSAwOworCQkJYnJlYWs7CisJCX0KKwl9CisJcmV0dXJuIG9rOworfQorCisjaWYgKCBDRkdfTUFYX0ZMQVNIX0JBTktTICE9IDEgKQorIyAgZXJyb3IgIldFUCBwbGF0Zm9ybSBoYXMgb25seSBvbmUgZmxhc2ggYmFuayEiCisjZW5kaWYKKworCit1bG9uZyBmbGFzaF9pbml0ICh2b2lkKQoreworCWludCBpOworCUZMQVNIX0JVUyBhZGRyZXNzID0gV0VQX0ZMQVNIX0JBU0U7CisKKwlmbGFzaF9pbmZvWzBdLnNpemUgPSBXRVBfRkxBU0hfQkFOS19TSVpFOworCWZsYXNoX2luZm9bMF0uc2VjdG9yX2NvdW50ID0gQ0ZHX01BWF9GTEFTSF9TRUNUOworCWZsYXNoX2luZm9bMF0uZmxhc2hfaWQgPSBJTlRFTF9NQU5VRkFDVDsKKwltZW1zZXQgKGZsYXNoX2luZm9bMF0ucHJvdGVjdCwgMCwgQ0ZHX01BWF9GTEFTSF9TRUNUKTsKKworCWZvciAoaSA9IDA7IGkgPCBDRkdfTUFYX0ZMQVNIX1NFQ1Q7IGkrKykgeworCQlmbGFzaF9pbmZvWzBdLnN0YXJ0W2ldID0gYWRkcmVzczsKKyNpZmRlZiBXRVBfRkxBU0hfVU5MT0NLCisJCS8qIFNvbWUgZGV2aWNlcyBhcmUgaHcgbG9ja2VkIGFmdGVyIHN0YXJ0LiAqLworCQkqKChGTEFTSF9CVVMgKikgYWRkcmVzcykgPSBGTEFTSF9DTUQgKENGSV9JTlRFTF9DTURfTE9DS19TRVRVUCk7CisJCSooKEZMQVNIX0JVUyAqKSBhZGRyZXNzKSA9IEZMQVNIX0NNRCAoQ0ZJX0lOVEVMX0NNRF9VTkxPQ0tfQkxPQ0spOworCQlmbGFzaF9yZWFkeSAoMCk7CisJCSooKEZMQVNIX0JVUyAqKSBhZGRyZXNzKSA9IEZMQVNIX0NNRCAoQ0ZJX0lOVEVMX0NNRF9SRUFEX0FSUkFZKTsKKyNlbmRpZgorCQlhZGRyZXNzICs9IFdFUF9GTEFTSF9TRUNUX1NJWkU7CisJfQorCisJZmxhc2hfcHJvdGVjdCAoRkxBR19QUk9URUNUX1NFVCwKKwkJCQkgICBDRkdfRkxBU0hfQkFTRSwKKwkJCQkgICBDRkdfRkxBU0hfQkFTRSArIF9hcm1ib290X2VuZF9kYXRhIC0gX2FybWJvb3Rfc3RhcnQsCisJCQkJICAgJmZsYXNoX2luZm9bMF0pOworCisJZmxhc2hfcHJvdGVjdCAoRkxBR19QUk9URUNUX1NFVCwKKwkJCQkgICBDRkdfRU5WX0FERFIsCisJCQkJICAgQ0ZHX0VOVl9BRERSICsgQ0ZHX0VOVl9TSVpFIC0gMSwgJmZsYXNoX2luZm9bMF0pOworCisJcmV0dXJuIFdFUF9GTEFTSF9CQU5LX1NJWkU7Cit9CisKK3ZvaWQgZmxhc2hfcHJpbnRfaW5mbyAoZmxhc2hfaW5mb190ICogaW5mbykKK3sKKwlpbnQgaTsKKworCXByaW50ZiAoIiBJbnRlbCB2ZW5kb3JcbiIpOworCXByaW50ZiAoIiAgU2l6ZTogJWxkIE1CIGluICVkIFNlY3RvcnNcbiIsCisJCQlpbmZvLT5zaXplID4+IDIwLCBpbmZvLT5zZWN0b3JfY291bnQpOworCisJcHJpbnRmICgiICBTZWN0b3IgU3RhcnQgQWRkcmVzc2VzOiIpOworCWZvciAoaSA9IDA7IGkgPCBpbmZvLT5zZWN0b3JfY291bnQ7IGkrKykgeworCQlpZiAoIShpICUgNSkpIHsKKwkJCXByaW50ZiAoIlxuIik7CisJCX0KKworCQlwcmludGYgKCIgJTA4bFglcyIsIGluZm8tPnN0YXJ0W2ldLAorCQkJCWluZm8tPnByb3RlY3RbaV0gPyAiIChSTykiIDogIiAgICAgIik7CisJfQorCXByaW50ZiAoIlxuIik7Cit9CisKKworaW50IGZsYXNoX2VyYXNlIChmbGFzaF9pbmZvX3QgKiBpbmZvLCBpbnQgc19maXJzdCwgaW50IHNfbGFzdCkKK3sKKwlpbnQgZmxhZywgbm9uX3Byb3RlY3RlZCA9IDAsIHNlY3RvcjsKKwlpbnQgcmMgPSBFUlJfT0s7CisKKwlGTEFTSF9CVVMgKmFkZHJlc3M7CisKKwlmb3IgKHNlY3RvciA9IHNfZmlyc3Q7IHNlY3RvciA8PSBzX2xhc3Q7IHNlY3RvcisrKSB7CisJCWlmICghaW5mby0+cHJvdGVjdFtzZWN0b3JdKSB7CisJCQlub25fcHJvdGVjdGVkKys7CisJCX0KKwl9CisKKwlpZiAoIW5vbl9wcm90ZWN0ZWQpIHsKKwkJcmV0dXJuIEVSUl9QUk9URUNURUQ7CisJfQorCisJLyoKKwkgKiBEaXNhYmxlIGludGVycnVwdHMgd2hpY2ggbWlnaHQgY2F1c2UgYSB0aW1lb3V0CisJICogaGVyZS4gUmVtZW1iZXIgdGhhdCBvdXIgZXhjZXB0aW9uIHZlY3RvcnMgYXJlCisJICogYXQgYWRkcmVzcyAwIGluIHRoZSBmbGFzaCwgYW5kIHdlIGRvbid0IHdhbnQgYQorCSAqICh0aWNrZXIpIGV4Y2VwdGlvbiB0byBoYXBwZW4gd2hpbGUgdGhlIGZsYXNoCisJICogY2hpcCBpcyBpbiBwcm9ncmFtbWluZyBtb2RlLgorCSAqLworCWZsYWcgPSBkaXNhYmxlX2ludGVycnVwdHMgKCk7CisKKworCS8qIFN0YXJ0IGVyYXNlIG9uIHVucHJvdGVjdGVkIHNlY3RvcnMgKi8KKwlmb3IgKHNlY3RvciA9IHNfZmlyc3Q7IHNlY3RvciA8PSBzX2xhc3QgJiYgIWN0cmxjICgpOyBzZWN0b3IrKykgeworCQlpZiAoaW5mby0+cHJvdGVjdFtzZWN0b3JdKSB7CisJCQlwcmludGYgKCJQcm90ZWN0ZWQgc2VjdG9yICUyZCBza2lwcGluZy4uLlxuIiwgc2VjdG9yKTsKKwkJCWNvbnRpbnVlOworCQl9IGVsc2UgeworCQkJcHJpbnRmICgiRXJhc2luZyBzZWN0b3IgJTJkIC4uLiAiLCBzZWN0b3IpOworCQl9CisJCisJCWFkZHJlc3MgPSAoRkxBU0hfQlVTICopIChpbmZvLT5zdGFydFtzZWN0b3JdKTsKKworCQkqYWRkcmVzcyA9IEZMQVNIX0NNRCAoQ0ZJX0lOVEVMX0NNRF9CTE9DS19FUkFTRSk7CisJCSphZGRyZXNzID0gRkxBU0hfQ01EIChDRklfSU5URUxfQ01EX0NPTkZJUk0pOworCQlpZiAoZmxhc2hfcmVhZHkgKENGR19GTEFTSF9FUkFTRV9UT1VUKSkgeworCQkJKmFkZHJlc3MgPSBGTEFTSF9DTUQgKENGSV9JTlRFTF9DTURfQ0xFQVJfU1RBVFVTX1JFR0lTVEVSKTsKKwkJCXByaW50ZiAoIm9rLlxuIik7CisJCX0gZWxzZSB7CisJCQkqYWRkcmVzcyA9IEZMQVNIX0NNRCAoQ0ZJX0lOVEVMX0NNRF9TVVNQRU5EKTsKKwkJCXJjID0gRVJSX1RJTU9VVDsKKwkJCXByaW50ZiAoInRpbWVvdXQhIEFib3J0aW5nLi4uXG4iKTsKKwkJCWJyZWFrOworCQl9CisJCSphZGRyZXNzID0gRkxBU0hfQ01EIChDRklfSU5URUxfQ01EX1JFQURfQVJSQVkpOworCX0KKwlpZiAoY3RybGMgKCkpCisJCXByaW50ZiAoIlVzZXIgSW50ZXJydXB0IVxuIik7CisKKwkvKiBhbGxvdyBmbGFzaCB0byBzZXR0bGUgLSB3YWl0IDEwIG1zICovCisJdWRlbGF5X21hc2tlZCAoMTAwMDApOworCWlmIChmbGFnKSB7CisJCWVuYWJsZV9pbnRlcnJ1cHRzICgpOworCX0KKworCXJldHVybiByYzsKK30KKworc3RhdGljIGludCB3cml0ZV9kYXRhIChmbGFzaF9pbmZvX3QgKiBpbmZvLCB1bG9uZyBkZXN0LCBGTEFTSF9CVVMgZGF0YSkKK3sKKwlGTEFTSF9CVVMgKmFkZHJlc3MgPSAoRkxBU0hfQlVTICopIGRlc3Q7CisJaW50IHJjID0gRVJSX09LOworCWludCBmbGFnOworCisJLyogQ2hlY2sgaWYgRmxhc2ggaXMgKHN1ZmZpY2llbnRseSkgZXJhc2VkICovCisJaWYgKCgqYWRkcmVzcyAmIGRhdGEpICE9IGRhdGEpIHsKKwkJcmV0dXJuIEVSUl9OT1RfRVJBU0VEOworCX0KKworCS8qCisJICogRGlzYWJsZSBpbnRlcnJ1cHRzIHdoaWNoIG1pZ2h0IGNhdXNlIGEgdGltZW91dAorCSAqIGhlcmUuIFJlbWVtYmVyIHRoYXQgb3VyIGV4Y2VwdGlvbiB2ZWN0b3JzIGFyZQorCSAqIGF0IGFkZHJlc3MgMCBpbiB0aGUgZmxhc2gsIGFuZCB3ZSBkb24ndCB3YW50IGEKKwkgKiAodGlja2VyKSBleGNlcHRpb24gdG8gaGFwcGVuIHdoaWxlIHRoZSBmbGFzaAorCSAqIGNoaXAgaXMgaW4gcHJvZ3JhbW1pbmcgbW9kZS4KKwkgKi8KKworCWZsYWcgPSBkaXNhYmxlX2ludGVycnVwdHMgKCk7CisKKwkqYWRkcmVzcyA9IEZMQVNIX0NNRCAoQ0ZJX0lOVEVMX0NNRF9DTEVBUl9TVEFUVVNfUkVHSVNURVIpOworCSphZGRyZXNzID0gRkxBU0hfQ01EIChDRklfSU5URUxfQ01EX1BST0dSQU0xKTsKKwkqYWRkcmVzcyA9IGRhdGE7CisKKwlpZiAoIWZsYXNoX3JlYWR5IChDRkdfRkxBU0hfV1JJVEVfVE9VVCkpIHsKKwkJKmFkZHJlc3MgPSBGTEFTSF9DTUQgKENGSV9JTlRFTF9DTURfU1VTUEVORCk7CisJCXJjID0gRVJSX1RJTU9VVDsKKwkJcHJpbnRmICgidGltZW91dCEgQWJvcnRpbmcuLi5cbiIpOworCX0KKworCSphZGRyZXNzID0gRkxBU0hfQ01EIChDRklfSU5URUxfQ01EX1JFQURfQVJSQVkpOworCWlmIChmbGFnKSB7CisJCWVuYWJsZV9pbnRlcnJ1cHRzICgpOworCX0KKworCXJldHVybiByYzsKK30KKworaW50IHdyaXRlX2J1ZmYgKGZsYXNoX2luZm9fdCAqIGluZm8sIHVjaGFyICogc3JjLCB1bG9uZyBhZGRyLCB1bG9uZyBjbnQpCit7CisJdWxvbmcgcmVhZF9hZGRyLCB3cml0ZV9hZGRyOworCUZMQVNIX0JVUyBkYXRhOworCWludCBpLCByZXN1bHQgPSBFUlJfT0s7CisKKworCXJlYWRfYWRkciA9IGFkZHIgJiB+KHNpemVvZiAoRkxBU0hfQlVTKSAtIDEpOworCXdyaXRlX2FkZHIgPSByZWFkX2FkZHI7CisJaWYgKHJlYWRfYWRkciAhPSBhZGRyKSB7CisJCWRhdGEgPSAwOworCQlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mIChGTEFTSF9CVVMpOyBpKyspIHsKKwkJCWlmIChyZWFkX2FkZHIgPCBhZGRyIHx8IGNudCA9PSAwKSB7CisJCQkJZGF0YSB8PSAqKCh1Y2hhciAqKSByZWFkX2FkZHIpIDw8IGkgKiA4OworCQkJfSBlbHNlIHsKKwkJCQlkYXRhIHw9ICgqc3JjKyspIDw8IGkgKiA4OworCQkJCWNudC0tOworCQkJfQorCQkJcmVhZF9hZGRyKys7CisJCX0KKwkJaWYgKChyZXN1bHQgPSB3cml0ZV9kYXRhIChpbmZvLCB3cml0ZV9hZGRyLCBkYXRhKSkgIT0gRVJSX09LKSB7CisJCQlyZXR1cm4gcmVzdWx0OworCQl9CisJCXdyaXRlX2FkZHIgKz0gc2l6ZW9mIChGTEFTSF9CVVMpOworCX0KKwlmb3IgKDsgY250ID49IHNpemVvZiAoRkxBU0hfQlVTKTsgY250IC09IHNpemVvZiAoRkxBU0hfQlVTKSkgeworCQlpZiAoKHJlc3VsdCA9IHdyaXRlX2RhdGEgKGluZm8sIHdyaXRlX2FkZHIsCisJCQkJCQkJCSAgKigoRkxBU0hfQlVTICopIHNyYykpKSAhPSBFUlJfT0spIHsKKwkJCXJldHVybiByZXN1bHQ7CisJCX0KKwkJd3JpdGVfYWRkciArPSBzaXplb2YgKEZMQVNIX0JVUyk7CisJCXNyYyArPSBzaXplb2YgKEZMQVNIX0JVUyk7CisJfQorCWlmIChjbnQgPiAwKSB7CisJCXJlYWRfYWRkciA9IHdyaXRlX2FkZHI7CisJCWRhdGEgPSAwOworCQlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mIChGTEFTSF9CVVMpOyBpKyspIHsKKwkJCWlmIChjbnQgPiAwKSB7CisJCQkJZGF0YSB8PSAoKnNyYysrKSA8PCBpICogODsKKwkJCQljbnQtLTsKKwkJCX0gZWxzZSB7CisJCQkJZGF0YSB8PSAqKCh1Y2hhciAqKSByZWFkX2FkZHIpIDw8IGkgKiA4OworCQkJfQorCQkJcmVhZF9hZGRyKys7CisJCX0KKwkJaWYgKChyZXN1bHQgPSB3cml0ZV9kYXRhIChpbmZvLCB3cml0ZV9hZGRyLCBkYXRhKSkgIT0gMCkgeworCQkJcmV0dXJuIHJlc3VsdDsKKwkJfQorCX0KKwlyZXR1cm4gRVJSX09LOworfQpkaWZmIC0tZ2l0IGEvYm9hcmQvd2VwZXAyNTAvaW50ZWwuaCBiL2JvYXJkL3dlcGVwMjUwL2ludGVsLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjYyMjU5MAotLS0gL2Rldi9udWxsCisrKyBiL2JvYXJkL3dlcGVwMjUwL2ludGVsLmgKQEAgLTAsMCArMSwxMDAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDIgRVRDIHMuci5vLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWUgb2YgdGhlIEVUQyBzLnIuby4gbm9yIHRoZSBuYW1lcyBvZiBpdHMgY29udHJpYnV0b3JzCisgKiAgICBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMgc29mdHdhcmUKKyAqICAgIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMgIkFTIElTIgorICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UKKyAqIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUKKyAqIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisgKiBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUgorICogU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIKKyAqIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisgKiBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqCisgKiBXcml0dGVuIGJ5IE1hcmNlbCBUZWxrYSA8bWFyY2VsQHRlbGthLnNrPiwgMjAwMi4KKyAqCisgKiBEb2N1bWVudGF0aW9uOgorICogWzFdIEludGVsIENvcnBvcmF0aW9uLCAiMyBWb2x0IEludGVsIFN0cmF0YSBGbGFzaCBNZW1vcnkgMjhGMTI4SjNBLCAyOEY2NDBKM0EsCisgKiAgICAgMjhGMzIwSjNBICh4OC94MTYpIiwgQXByaWwgMjAwMiwgT3JkZXIgTnVtYmVyOiAyOTA2NjctMDExCisgKiBbMl0gSW50ZWwgQ29ycG9yYXRpb24sICIzIFZvbHQgU3luY2hyb25vdXMgSW50ZWwgU3RyYXRhIEZsYXNoIE1lbW9yeSAyOEY2NDBLMywgMjhGNjQwSzE4LAorICogICAgIDI4RjEyOEszLCAyOEYxMjhLMTgsIDI4RjI1NkszLCAyOEYyNTZLMTggKHgxNikiLCBKdW5lIDIwMDIsIE9yZGVyIE51bWJlcjogMjkwNzM3LTAwNQorICoKKyAqIFRoaXMgZmlsZSBpcyB0YWtlbiBmcm9tIE9wZW5XaW5DRSBwcm9qZWN0IGhvc3RlZCBieSBTb3VyY2VGb3JnZS5uZXQKKyAqCisgKi8KKworI2lmbmRlZglGTEFTSF9JTlRFTF9ICisjZGVmaW5lCUZMQVNIX0lOVEVMX0gKKworI2luY2x1ZGUgPGNvbW1vbi5oPgorCisvKiBJbnRlbCBDRkkgY29tbWFuZHMgLSBzZWUgVGFibGUgNC4gaW4gWzFdIGFuZCBUYWJsZSAzLiBpbiBbMl0gKi8KKworI2RlZmluZQlDRklfSU5URUxfQ01EX1JFQURfQVJSQVkJCTB4RkYJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9DTURfUkVBRF9JREVOVElGSUVSCQkweDkwCS8qIDI4Rnh4eEozQSwgMjhGeHh4SzMsIDI4Rnh4eEsxOCAqLworI2RlZmluZQlDRklfSU5URUxfQ01EX1JFQURfUVVFUlkJCTB4OTgJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9DTURfUkVBRF9TVEFUVVNfUkVHSVNURVIJMHg3MAkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9DTEVBUl9TVEFUVVNfUkVHSVNURVIJMHg1MAkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9QUk9HUkFNMQkJCTB4NDAJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9DTURfUFJPR1JBTTIJCQkweDEwCS8qIDI4Rnh4eEozQSwgMjhGeHh4SzMsIDI4Rnh4eEsxOCAqLworI2RlZmluZQlDRklfSU5URUxfQ01EX1dSSVRFX1RPX0JVRkZFUgkJMHhFOAkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9DT05GSVJNCQkJMHhEMAkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9CTE9DS19FUkFTRQkJMHgyMAkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9TVVNQRU5ECQkJMHhCMAkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9SRVNVTUUJCQkweEQwCS8qIDI4Rnh4eEozQSwgMjhGeHh4SzMsIDI4Rnh4eEsxOCAqLworI2RlZmluZQlDRklfSU5URUxfQ01EX0xPQ0tfU0VUVVAJCTB4NjAJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9DTURfTE9DS19CTE9DSwkJMHgwMQkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX0NNRF9VTkxPQ0tfQkxPQ0sJCTB4RDAJLyogMjhGeHh4SjNBIC0gdW5sb2NrcyBhbGwgYmxvY2tzLCAyOEZGeHh4SzMsIDI4Rnh4eEsxOCAqLworI2RlZmluZQlDRklfSU5URUxfQ01EX0xPQ0tfRE9XTl9CTE9DSwkJMHgyRgkvKiAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisKKy8qIEludGVsIENGSSBTdGF0dXMgUmVnaXN0ZXIgYml0cyAtIHNlZSBUYWJsZSA2LiBpbiBbMV0gYW5kIFRhYmxlIDcuIGluIFsyXSAqLworCisjZGVmaW5lCUNGSV9JTlRFTF9TUl9SRUFEWQkJCTEgPDwgNwkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX1NSX0VSQVNFX1NVU1BFTkQJCTEgPDwgNgkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX1NSX0VSQVNFX0VSUk9SCQkxIDw8IDUJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9TUl9QUk9HUkFNX0VSUk9SCQkxIDw8IDQJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9TUl9WUEVOX0VSUk9SCQkJMSA8PCAzCS8qIDI4Rnh4eEozQSwgMjhGeHh4SzMsIDI4Rnh4eEsxOCAqLworI2RlZmluZQlDRklfSU5URUxfU1JfUFJPR1JBTV9TVVNQRU5ECQkxIDw8IDIJLyogMjhGeHh4SjNBLCAyOEZ4eHhLMywgMjhGeHh4SzE4ICovCisjZGVmaW5lCUNGSV9JTlRFTF9TUl9CTE9DS19MT0NLRUQJCTEgPDwgMQkvKiAyOEZ4eHhKM0EsIDI4Rnh4eEszLCAyOEZ4eHhLMTggKi8KKyNkZWZpbmUJQ0ZJX0lOVEVMX1NSX0JFRlAJCQkxIDw8IDAJLyogMjhGeHh4SzMsIDI4Rnh4eEsxOCAqLworCisvKiBJbnRlbCBmbGFzaCBkZXZpY2UgSUQgY29kZXMgZm9yIDI4Rnh4eEozQSAtIHNlZSBUYWJsZSA1LiBpbiBbMV0gKi8KKworI2RlZmluZQlDRklfQ0hJUF9JTlRFTF8yOEYzMjBKM0EJCTB4MDAxNgorI2RlZmluZQlDRklfQ0hJUE5fSU5URUxfMjhGMzIwSjNBCQkiMjhGMzIwSjNBIgorI2RlZmluZQlDRklfQ0hJUF9JTlRFTF8yOEY2NDBKM0EJCTB4MDAxNworI2RlZmluZQlDRklfQ0hJUE5fSU5URUxfMjhGNjQwSjNBCQkiMjhGNjQwSjNBIgorI2RlZmluZQlDRklfQ0hJUF9JTlRFTF8yOEYxMjhKM0EJCTB4MDAxOAorI2RlZmluZQlDRklfQ0hJUE5fSU5URUxfMjhGMTI4SjNBCQkiMjhGMTI4SjNBIgorCisvKiBJbnRlbCBmbGFzaCBkZXZpY2UgSUQgY29kZXMgZm9yIDI4Rnh4eEszIGFuZCAyOEZ4eHhLMTggLSBzZWUgVGFibGUgOC4gaW4gWzJdICovCisKKyNkZWZpbmUJQ0ZJX0NISVBfSU5URUxfMjhGNjQwSzMJCQkweDg4MDEKKyNkZWZpbmUJQ0ZJX0NISVBOX0lOVEVMXzI4RjY0MEszCQkiMjhGNjQwSzMiCisjZGVmaW5lCUNGSV9DSElQX0lOVEVMXzI4RjEyOEszCQkJMHg4ODAyCisjZGVmaW5lCUNGSV9DSElQTl9JTlRFTF8yOEYxMjhLMwkJIjI4RjEyOEszIgorI2RlZmluZQlDRklfQ0hJUF9JTlRFTF8yOEYyNTZLMwkJCTB4ODgwMworI2RlZmluZQlDRklfQ0hJUE5fSU5URUxfMjhGMjU2SzMJCSIyOEYyNTZLMyIKKyNkZWZpbmUJQ0ZJX0NISVBfSU5URUxfMjhGNjQwSzE4CQkweDg4MDUKKyNkZWZpbmUJQ0ZJX0NISVBOX0lOVEVMXzI4RjY0MEsxOAkJIjI4RjY0MEsxOCIKKyNkZWZpbmUJQ0ZJX0NISVBfSU5URUxfMjhGMTI4SzE4CQkweDg4MDYKKyNkZWZpbmUJQ0ZJX0NISVBOX0lOVEVMXzI4RjEyOEsxOAkJIjI4RjEyOEsxOCIKKyNkZWZpbmUJQ0ZJX0NISVBfSU5URUxfMjhGMjU2SzE4CQkweDg4MDcKKyNkZWZpbmUJQ0ZJX0NISVBOX0lOVEVMXzI4RjI1NksxOAkJIjI4RjI1NksxOCIKKworI2VuZGlmIC8qIEZMQVNIX0lOVEVMX0ggKi8KKwpkaWZmIC0tZ2l0IGEvYm9hcmQvd2VwZXAyNTAvbWVtc2V0dXAuUyBiL2JvYXJkL3dlcGVwMjUwL21lbXNldHVwLlMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGE1ZDQyZgotLS0gL2Rldi9udWxsCisrKyBiL2JvYXJkL3dlcGVwMjUwL21lbXNldHVwLlMKQEAgLTAsMCArMSwxNDcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDEsIDIwMDIgRVRDIHMuci5vLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMgorICogb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKiAKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKiAKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BCisgKiAwMjExMS0xMzA3LCBVU0EuCisgKiAKKyAqIFdyaXR0ZW4gYnkgTWFyY2VsIFRlbGthIDxtYXJjZWxAdGVsa2Euc2s+LCAyMDAxLCAyMDAyLgorICogQ2hhbmdlcyBmb3IgVS1Cb290IFBldGVyIEZpZ3VsaSA8cGVwb3NoQGV0Yy5zaz4sIDIwMDMuCisgKgorICogVGhpcyBmaWxlIGlzIHRha2VuIGZyb20gT3BlbldpbkNFIHByb2plY3QgaG9zdGVkIGJ5IFNvdXJjZUZvcmdlLm5ldAorICoKKyAqIERvY3VtZW50YXRpb246CisgKiBbMV0gSW50ZWwgQ29ycG9yYXRpb24sICJJbnRlbCBQWEEyNTAgYW5kIFBYQTIxMCBBcHBsaWNhdGlvbiBQcm9jZXNzb3JzCisgKiAgICAgRGV2ZWxvcGVyJ3MgTWFudWFsIiwgRmVicnVhcnkgMjAwMiwgT3JkZXIgTnVtYmVyOiAyNzg1MjItMDAxCisgKiBbMl0gU2Ftc3VuZyBFbGVjdHJvbmljcywgIjhNeDE2IFNEUkFNIDU0Q1NQIEs0UzI4MTYzM0QtUkwvTi9QIiwKKyAqICAgICBSZXZpc2lvbiAxLjAsIEZlYnJ1YXJ5IDIwMDIKKyAqIFszXSBTYW1zdW5nIEVsZWN0cm9uaWNzLCAiMTZNeDE2IFNEUkFNIDU0Q1NQIEs0UzU2MTYzM0MtUkwoTikiLAorICogICAgIFJldmlzaW9uIDEuMCwgRmVicnVhcnkgMjAwMgorICogCisqLworCisjaW5jbHVkZSA8Y29uZmlnLmg+CisjaW5jbHVkZSA8dmVyc2lvbi5oPgorI2luY2x1ZGUgPGFzbS9hcmNoL3B4YS1yZWdzLmg+CisKKy5nbG9ibCBtZW1zZXR1cAorbWVtc2V0dXA6CisKKwltb3YJcjEwLCBscgorCisvKglzZXR1cCBtZW1vcnkgLSBzZWUgNi4xMiBpbiBbMV0KKyAqCVN0ZXAgMSAJLSB3YWl0IDIwMCB1cworICovCisJbW92CXIwLCMweDI3MDAgICAgICAJCS8qIHdhaXQgMjAwIHVzIEAgOTkuNSBNSHogKi8KKzE6CXN1YnMJcjAsIHIwLCAjMQorCWJuZQkxYgorLyoJVE9ETzogY29tcGxldGUgc3RlcCAxIGZvciBTeW5jaHJvbm91cyBTdGF0aWMgbWVtb3J5Ki8KKworCWxkcglyMCwgPTB4NDgwMDAwMDAJCQkvKiBNQ19CQVNFICovCisKKworCisvKiAJc3RlcCAxLmEgLSBzZXR1cCBNU0N4CisgKi8KKwlsZHIJcjEsID0weDAwMDAxMkIzCQkJLyogTVNDMF9SUlIwKDEpIHwgTVNDMF9SRE4wKDIpIHwgTVNDMF9SREYwKDExKSB8IE1TQzBfUlQwKDMpICovCisJc3RyCXIxLCBbcjAsICMweDhdCQkJLyogTVNDMF9PRkZTRVQgKi8KKworLyoJc3RlcCAxLmMgLSBjbGVhciBNRFJFRlI6SzFGUkVFLCBzZXQgTURSRUZSOkRSSQorICoJc2VlIEFVVE8gUkVGUkVTSCBjaGFwdGVyIGluIHNlY3Rpb24gRC4gaW4gWzJdIGFuZCBpbiBbM10KKyAqCURSSSA9ICg2NG1zIC8gNDA5NikgKiA5OS41M01IeiAvIDMyID0gNDggZm9yIEs0UzI4MTYzMworICoJRFJJID0gKDY0bXMgLyA4MTkyKSAqIDk5LjUyTUh6IC8gMzIgPSAyNCBmb3IgSzRTNTYxNjMzCisgKglUT0RPOiBjb21wbGV0ZSBmb3IgU3luY2hyb25vdXMgU3RhdGljIG1lbW9yeQorICovCisJbGRyCXIxLCBbcjAsICM0XQkJCS8qIE1EUkVGUl9PRkZTRVQgKi8KKwlsZHIJcjIsID0weDAxMDAwRkZGCQkJLyogTURSRUZSX0sxRlJFRSB8IE1EUkVGUl9EUklfTUFTSyAqLworCWJpYwlyMSwgcjEsIHIyCisjaWYgZGVmaW5lZCggV0VQX1NEUkFNX0s0UzI4MTYzMyApCisJb3JyCXIxLCByMSwgIzQ4CQkJLyogTURSRUZSX0RSSSg0OCkgKi8KKyNlbGlmIGRlZmluZWQoIFdFUF9TRFJBTV9LNFM1NjE2MzMgKQorCW9ycglyMSwgcjEsICMyNAkJCS8qIE1EUkVGUl9EUkkoMjQpICovCisjZWxzZQorI2Vycm9yIFNEUkFNIGNoaXAgaXMgbm90IGRlZmluZWQKKyNlbmRpZgorCisJc3RyCXIxLCBbcjAsICM0XQkJCS8qIE1EUkVGUl9PRkZTRVQgKi8KKworLyoJU3RlcCAyIC0gb25seSBmb3IgU3luY2hyb25vdXMgU3RhdGljIG1lbW9yeSAoVE9ETykKKyAqCisgKglTdGVwIDMgLSBzYW1lIGFzIHN0ZXAgNAorICoKKyAqCVN0ZXAgNAorICoKKyAqCVN0ZXAgNC5hIC0gc2V0IE1EUkVGUjpLMVJVTiwgY2xlYXIgTURSRUZSOksxREIyCisgKi8KKwlvcnIJcjEsIHIxLCAjMHgwMDAxMDAwMAkJLyogTURSRUZSX0sxUlVOICovCisJYmljCXIxLCByMSwgIzB4MDAwMjAwMDAJCS8qIE1EUkVGUl9LMURCMiAqLworCXN0cglyMSwgW3IwLCAjNF0JCQkvKiBNRFJFRlJfT0ZGU0VUICovCisKKy8qCVN0ZXAgNC5iIC0gY2xlYXIgTURSRUZSOlNMRlJTSCAqLworCWJpYwlyMSwgcjEsICMweDAwNDAwMDAwCQkvKiBNRFJFRlJfU0xGUlNIICovCisJc3RyCXIxLCBbcjAsICM0XQkJCS8qIE1EUkVGUl9PRkZTRVQgKi8KKworLyoJU3RlcCA0LmMgLSBzZXQgTURSRUZSOkUxUElOICovCisJb3JyCXIxLCByMSwgIzB4MDAwMDgwMDAJCS8qIE1EUkVGUl9FMVBJTiAqLworCXN0cglyMSwgW3IwLCAjNF0JCQkvKiBNRFJFRlJfT0ZGU0VUICovCisKKy8qCVN0ZXAgNC5kIC0gYXV0b21hdGljYWxseSBkb25lCisgKgorICoJU3RlcHMgNC5lIGFuZCA0LmYgLSBjb25maWd1cmUgU0RSQU0KKyAqLworI2lmIGRlZmluZWQoIFdFUF9TRFJBTV9LNFMyODE2MzMgKQorCWxkcglyMSwgPTB4MDAwMDBBQTgJCQkvKiBNRENORkdfRFRDMCgyKSB8IE1EQ05GR19ETEFUQ0gwIHwgTURDTkZHX0RDQUMwKDEpIHwgTURDTkZHX0RSQUMwKDEpIHwgTURDTkZHX0ROQjAgKi8KKyNlbGlmIGRlZmluZWQoIFdFUF9TRFJBTV9LNFM1NjE2MzMgKQorCWxkcglyMSwgPTB4MDAwMDBBQzgJCQkvKiBNRENORkdfRFRDMCgyKSB8IE1EQ05GR19ETEFUQ0gwIHwgTURDTkZHX0RDQUMwKDEpIHwgTURDTkZHX0RSQUMwKDIpIHwgTURDTkZHX0ROQjAgKi8KKyNlbHNlCisjZXJyb3IgU0RSQU0gY2hpcCBpcyBub3QgZGVmaW5lZAorI2VuZGlmCisJc3RyCXIxLCBbcjAsICMwXQkJCS8qIE1EQ05GR19PRkZTRVQgKi8KKworLyoJU3RlcCA1IC0gd2FpdCBhdCBsZWFzdCAyMDAgdXMgZm9yIFNEUkFNCisgKglzZWUgc2VjdGlvbiBCLiBpbiBbMl0KKyAqLworCW1vdglyMiwjMHgyNzAwICAgICAgCQkvKiB3YWl0IDIwMCB1cyBAIDk5LjUgTUh6ICovCisxOglzdWJzCXIyLCByMiwgIzEKKwlibmUJMWIKKworLyoJU3RlcCA2IC0gYWZ0ZXIgcmVzZXQgZGNhY2hlIGlzIGRpc2FibGVkLCBzbyBhdXRvbWF0aWNhbGx5IGRvbmUKKyAqCisgKglTdGVwIDcgLSBlaWdodCByZWZyZXNoIGN5Y2xlcworICovCisJbW92CXIyLCAjMHhBMDAwMDAwMAorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCWxkcglyMywgW3IyXQorCisvKglTdGVwIDggLSB3ZSBkb24ndCBuZWVkIGRjYWNoZSBub3cKKyAqCisgKglTdGVwIDkgLSBlbmFibGUgU0RSQU0gcGFydGl0aW9uIDAKKyAqLworCW9ycglyMSwgcjEsICMxCQkJLyogTURDTkZHX0RFMCAqLworCXN0cglyMSwgW3IwLCAjMF0JCQkvKiBNRENORkdfT0ZGU0VUICovCisKKy8qCVN0ZXAgMTAgLSB3cml0ZSBNRE1SUyAqLworCW1vdglyMSwgIzAKKwlzdHIJcjEsIFtyMCwgIzB4NDBdCQkJLyogTURNUlNfT0ZGU0VUICovCisKKy8qCVN0ZXAgMTEgLSBvcHRpb25hbCAoVE9ETykgKi8KKworCW1vdglwYyxyMTAKKwpkaWZmIC0tZ2l0IGEvYm9hcmQvd2VwZXAyNTAvdS1ib290LmxkcyBiL2JvYXJkL3dlcGVwMjUwL3UtYm9vdC5sZHMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjgwZmM0OAotLS0gL2Rldi9udWxsCisrKyBiL2JvYXJkL3dlcGVwMjUwL3UtYm9vdC5sZHMKQEAgLTAsMCArMSw1NSBAQAorLyoKKyAqIChDKSBDb3B5cmlnaHQgMjAwMAorICogV29sZmdhbmcgRGVuaywgREVOWCBTb2Z0d2FyZSBFbmdpbmVlcmluZywgd2RAZGVueC5kZS4KKyAqCisgKiBTZWUgZmlsZSBDUkVESVRTIGZvciBsaXN0IG9mIHBlb3BsZSB3aG8gY29udHJpYnV0ZWQgdG8gdGhpcworICogcHJvamVjdC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YKKyAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLAorICogTUEgMDIxMTEtMTMwNyBVU0EKKyAqLworCitPVVRQVVRfRk9STUFUKCJlbGYzMi1saXR0bGVhcm0iLCAiZWxmMzItbGl0dGxlYXJtIiwgImVsZjMyLWxpdHRsZWFybSIpCitPVVRQVVRfQVJDSChhcm0pCitFTlRSWShfc3RhcnQpCitTRUNUSU9OUworeworICAgICAgICAuID0gMHgwMDAwMDAwMDsKKworICAgICAgICAuID0gQUxJR04oNCk7CisJLnRleHQgICAgICA6CisJeworCSAgY3B1L3hzY2FsZS9zdGFydC5vCSgudGV4dCkKKwkgICooLnRleHQpCisJfQorCisgICAgICAgIC4gPSBBTElHTig0KTsKKyAgICAgICAgLnJvZGF0YSA6IHsgKigucm9kYXRhKSB9CisKKyAgICAgICAgLiA9IEFMSUdOKDQpOworICAgICAgICAuZGF0YSA6IHsgKiguZGF0YSkgfQorCisgICAgICAgIC4gPSBBTElHTig0KTsKKyAgICAgICAgLmdvdCA6IHsgKiguZ290KSB9CisKKwlhcm1ib290X2VuZF9kYXRhID0gLjsKKworICAgICAgICAuID0gQUxJR04oNCk7CisJYnNzX3N0YXJ0ID0gLjsKKyAgICAgICAgLmJzcyA6IHsgKiguYnNzKSB9CisJYnNzX2VuZCA9IC47CisKKwlhcm1ib290X2VuZCA9IC47Cit9CmRpZmYgLS1naXQgYS9ib2FyZC93ZXBlcDI1MC93ZXBlcDI1MC5jIGIvYm9hcmQvd2VwZXAyNTAvd2VwZXAyNTAuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYmY3NWQ3Ci0tLSAvZGV2L251bGwKKysrIGIvYm9hcmQvd2VwZXAyNTAvd2VwZXAyNTAuYwpAQCAtMCwwICsxLDc3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDAzIEVUQyBzLnIuby4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YKKyAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLAorICogTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKiBXcml0dGVuIGJ5IFBldGVyIEZpZ3VsaSA8cGVwb3NoQGV0Yy5zaz4sIDIwMDMuCisgKgorICovCisKKyNpbmNsdWRlIDxjb21tb24uaD4KKyNpbmNsdWRlIDxhc20vYXJjaC9weGEtcmVncy5oPgorCitpbnQgYm9hcmRfaW5pdCggdm9pZCApeworICBERUNMQVJFX0dMT0JBTF9EQVRBX1BUUjsKKworICBnZC0+YmQtPmJpX2FyY2hfbnVtYmVyID0gMjg4OwkKKyAgZ2QtPmJkLT5iaV9ib290X3BhcmFtcyA9IDB4YTAwMDAwMDA7CisvKgorICogU2V0dXAgR1BJTyBzdHVmZiB0byBnZXQgc2VyaWFsIHdvcmtpbmcKKyAqLworI2lmIGRlZmluZWQoIENPTkZJR19GRlVBUlQgKQorICBHUERSMSAgID0gMHg4MDsKKyAgR0FGUjFfTCA9IDB4ODAxMDsKKyNlbGlmIGRlZmluZWQoIENPTkZJR19CVFVBUlQgKQorICBHUERSMSAgID0gMHg4MDA7CisgIEdBRlIxX0wgPSAweDkwMDAwMDsKKyNlbmRpZgorICBQU1NSICAgID0gMHgyMDsKKworLyoKKyAqIEZvbGxvd2luZyBjb2RlIGlzIGp1c3QgYnVnIHdvcmthcm91bmQsIHJlbW92ZSBpdCBpZiBub3QgbmVjY2Vzc2FyeQorICovCisKKyAgLyogY3B1L3hzY2FsZS9jcHUuYyBkbyBub3Qgc2V0IGFybWJvb3RfcmVhbF9lbmQgdGhhdCBpcyB1c2VkIGZvcgorICAgICBtYWxsb2MgcG9vbC4qLworICBpZiggX2FybWJvb3RfcmVhbF9lbmQgPT0gMHhiYWRjMGRlICl7CisgICAgX2FybWJvb3RfcmVhbF9lbmQgPSBfYXJtYm9vdF9lbmQ7CisgIH0KKyAgcmV0dXJuIDA7Cit9CisKK2ludCBkcmFtX2luaXQoIHZvaWQgKXsKKyAgREVDTEFSRV9HTE9CQUxfREFUQV9QVFI7CisKKyNpZiAoIENPTkZJR19OUl9EUkFNX0JBTktTID4gMCApCisgIGdkLT5iZC0+YmlfZHJhbVswXS5zdGFydCA9IFdFUF9TRFJBTV8xOworICBnZC0+YmQtPmJpX2RyYW1bMF0uc2l6ZSAgPSBXRVBfU0RSQU1fMV9TSVpFOworI2VuZGlmCisjaWYgKCBDT05GSUdfTlJfRFJBTV9CQU5LUyA+IDEgKSAgCisgIGdkLT5iZC0+YmlfZHJhbVsxXS5zdGFydCA9IFdFUF9TRFJBTV8yOworICBnZC0+YmQtPmJpX2RyYW1bMV0uc2l6ZSAgPSBXRVBfU0RSQU1fMl9TSVpFOworI2VuZGlmCisjaWYgKCBDT05GSUdfTlJfRFJBTV9CQU5LUyA+IDIgKSAgCisgIGdkLT5iZC0+YmlfZHJhbVsyXS5zdGFydCA9IFdFUF9TRFJBTV8zOworICBnZC0+YmQtPmJpX2RyYW1bMl0uc2l6ZSAgPSBXRVBfU0RSQU1fM19TSVpFOworI2VuZGlmCisjaWYgKCBDT05GSUdfTlJfRFJBTV9CQU5LUyA+IDMgKQorICBnZC0+YmQtPmJpX2RyYW1bM10uc3RhcnQgPSBXRVBfU0RSQU1fNDsKKyAgZ2QtPmJkLT5iaV9kcmFtWzNdLnNpemUgID0gV0VQX1NEUkFNXzRfU0laRTsKKyNlbmRpZgorCQorICByZXR1cm4gMDsKK30KKwpkaWZmIC0tZ2l0IGEvY29tbW9uL2NtZF9kYXRlLmMgYi9jb21tb24vY21kX2RhdGUuYwppbmRleCAxNDcyZTNmLi4yMTM5Y2ViIDEwMDY0NAotLS0gYS9jb21tb24vY21kX2RhdGUuYworKysgYi9jb21tb24vY21kX2RhdGUuYwpAQCAtMzQsMTAgKzM0LDEzIEBACiAJIlN1biIsICJNb24iLCAiVHVlcyIsICJXZWRuZXMiLCAiVGh1cnMiLCAiRnJpIiwgIlNhdHVyIiwKIH07CiAKKyNkZWZpbmUgUkVMT0MoYSkJKCh0eXBlb2YoYSkpKCh1bnNpZ25lZCBsb25nKShhKSArIGdkLT5yZWxvY19vZmYpKQorCiBpbnQgbWtfZGF0ZSAoY2hhciAqLCBzdHJ1Y3QgcnRjX3RpbWUgKik7CiAKIGludCBkb19kYXRlIChjbWRfdGJsX3QgKmNtZHRwLCBpbnQgZmxhZywgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIHsKKwlERUNMQVJFX0dMT0JBTF9EQVRBX1BUUjsKIAlzdHJ1Y3QgcnRjX3RpbWUgdG07CiAJaW50IHJjb2RlID0gMDsKIApAQCAtNjQsNyArNjcsNyBAQAogCQlwcmludGYgKCJEYXRlOiAlNGQtJTAyZC0lMDJkICglc2RheSkgICAgVGltZTogJTJkOiUwMmQ6JTAyZFxuIiwKIAkJCXRtLnRtX3llYXIsIHRtLnRtX21vbiwgdG0udG1fbWRheSwKIAkJCSh0bS50bV93ZGF5PDAgfHwgdG0udG1fd2RheT42KSA/Ci0JCQkJInVua25vd24gIiA6IHdlZWtkYXlzW3RtLnRtX3dkYXldLAorCQkJCSJ1bmtub3duICIgOiBSRUxPQyh3ZWVrZGF5c1t0bS50bV93ZGF5XSksCiAJCQl0bS50bV9ob3VyLCB0bS50bV9taW4sIHRtLnRtX3NlYyk7CiAKIAkJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9jb21tb24vaHVzaC5jIGIvY29tbW9uL2h1c2guYwppbmRleCBmY2MzNTU5Li4xOTkzMzk4IDEwMDY0NAotLS0gYS9jb21tb24vaHVzaC5jCisrKyBiL2NvbW1vbi9odXNoLmMKQEAgLTIzNTcsMzQgKzIzNTcsMzUgQEAKICAqIHNob3VsZCBoYW5kbGUgaWYsIHRoZW4sIGVsaWYsIGVsc2UsIGZpLCBmb3IsIHdoaWxlLCB1bnRpbCwgZG8sIGRvbmUuCiAgKiBjYXNlLCBmdW5jdGlvbiwgYW5kIHNlbGVjdCBhcmUgb2Jub3hpb3VzLCBzYXZlIHRob3NlIGZvciBsYXRlci4KICAqLworc3RydWN0IHJlc2VydmVkX2NvbWJvIHsKKwljaGFyICpsaXRlcmFsOworCWludCBjb2RlOworCWxvbmcgZmxhZzsKK307CisvKiBNb3N0bHkgYSBsaXN0IG9mIGFjY2VwdGVkIGZvbGxvdy11cCByZXNlcnZlZCB3b3Jkcy4KKyAqIEZMQUdfRU5EIG1lYW5zIHdlIGFyZSBkb25lIHdpdGggdGhlIHNlcXVlbmNlLCBhbmQgYXJlIHJlYWR5CisgKiB0byB0dXJuIHRoZSBjb21wb3VuZCBsaXN0IGludG8gYSBjb21tYW5kLgorICogRkxBR19TVEFSVCBtZWFucyB0aGUgd29yZCBtdXN0IHN0YXJ0IGEgbmV3IGNvbXBvdW5kIGxpc3QuCisgKi8KK3N0YXRpYyBzdHJ1Y3QgcmVzZXJ2ZWRfY29tYm8gcmVzZXJ2ZWRfbGlzdFtdID0geworCXsgImlmIiwgICAgUkVTX0lGLCAgICBGTEFHX1RIRU4gfCBGTEFHX1NUQVJUIH0sCisJeyAidGhlbiIsICBSRVNfVEhFTiwgIEZMQUdfRUxJRiB8IEZMQUdfRUxTRSB8IEZMQUdfRkkgfSwKKwl7ICJlbGlmIiwgIFJFU19FTElGLCAgRkxBR19USEVOIH0sCisJeyAiZWxzZSIsICBSRVNfRUxTRSwgIEZMQUdfRkkgICB9LAorCXsgImZpIiwgICAgUkVTX0ZJLCAgICBGTEFHX0VORCAgfSwKKwl7ICJmb3IiLCAgIFJFU19GT1IsICAgRkxBR19JTiAgIHwgRkxBR19TVEFSVCB9LAorCXsgIndoaWxlIiwgUkVTX1dISUxFLCBGTEFHX0RPICAgfCBGTEFHX1NUQVJUIH0sCisJeyAidW50aWwiLCBSRVNfVU5USUwsIEZMQUdfRE8gICB8IEZMQUdfU1RBUlQgfSwKKwl7ICJpbiIsICAgIFJFU19JTiwgICAgRkxBR19ETyAgIH0sCisJeyAiZG8iLCAgICBSRVNfRE8sICAgIEZMQUdfRE9ORSB9LAorCXsgImRvbmUiLCAgUkVTX0RPTkUsICBGTEFHX0VORCAgfQorfTsKKyNkZWZpbmUgTlJFUyAoc2l6ZW9mKHJlc2VydmVkX2xpc3QpL3NpemVvZihzdHJ1Y3QgcmVzZXJ2ZWRfY29tYm8pKQorCiBpbnQgcmVzZXJ2ZWRfd29yZChvX3N0cmluZyAqZGVzdCwgc3RydWN0IHBfY29udGV4dCAqY3R4KQogewotCXN0cnVjdCByZXNlcnZlZF9jb21ibyB7Ci0JCWNoYXIgKmxpdGVyYWw7Ci0JCWludCBjb2RlOwotCQlsb25nIGZsYWc7Ci0JfTsKLQkvKiBNb3N0bHkgYSBsaXN0IG9mIGFjY2VwdGVkIGZvbGxvdy11cCByZXNlcnZlZCB3b3Jkcy4KLQkgKiBGTEFHX0VORCBtZWFucyB3ZSBhcmUgZG9uZSB3aXRoIHRoZSBzZXF1ZW5jZSwgYW5kIGFyZSByZWFkeQotCSAqIHRvIHR1cm4gdGhlIGNvbXBvdW5kIGxpc3QgaW50byBhIGNvbW1hbmQuCi0JICogRkxBR19TVEFSVCBtZWFucyB0aGUgd29yZCBtdXN0IHN0YXJ0IGEgbmV3IGNvbXBvdW5kIGxpc3QuCi0JICovCi0Jc3RhdGljIHN0cnVjdCByZXNlcnZlZF9jb21ibyByZXNlcnZlZF9saXN0W10gPSB7Ci0JCXsgImlmIiwgICAgUkVTX0lGLCAgICBGTEFHX1RIRU4gfCBGTEFHX1NUQVJUIH0sCi0JCXsgInRoZW4iLCAgUkVTX1RIRU4sICBGTEFHX0VMSUYgfCBGTEFHX0VMU0UgfCBGTEFHX0ZJIH0sCi0JCXsgImVsaWYiLCAgUkVTX0VMSUYsICBGTEFHX1RIRU4gfSwKLQkJeyAiZWxzZSIsICBSRVNfRUxTRSwgIEZMQUdfRkkgICB9LAotCQl7ICJmaSIsICAgIFJFU19GSSwgICAgRkxBR19FTkQgIH0sCi0JCXsgImZvciIsICAgUkVTX0ZPUiwgICBGTEFHX0lOICAgfCBGTEFHX1NUQVJUIH0sCi0JCXsgIndoaWxlIiwgUkVTX1dISUxFLCBGTEFHX0RPICAgfCBGTEFHX1NUQVJUIH0sCi0JCXsgInVudGlsIiwgUkVTX1VOVElMLCBGTEFHX0RPICAgfCBGTEFHX1NUQVJUIH0sCi0JCXsgImluIiwgICAgUkVTX0lOLCAgICBGTEFHX0RPICAgfSwKLQkJeyAiZG8iLCAgICBSRVNfRE8sICAgIEZMQUdfRE9ORSB9LAotCQl7ICJkb25lIiwgIFJFU19ET05FLCAgRkxBR19FTkQgIH0KLQl9OwogCXN0cnVjdCByZXNlcnZlZF9jb21ibyAqcjsKIAlmb3IgKHI9cmVzZXJ2ZWRfbGlzdDsKLSNkZWZpbmUgTlJFUyBzaXplb2YocmVzZXJ2ZWRfbGlzdCkvc2l6ZW9mKHN0cnVjdCByZXNlcnZlZF9jb21ibykKIAkJcjxyZXNlcnZlZF9saXN0K05SRVM7IHIrKykgewogCQlpZiAoc3RyY21wKGRlc3QtPmRhdGEsIHItPmxpdGVyYWwpID09IDApIHsKIAkJCWRlYnVnX3ByaW50ZigiZm91bmQgcmVzZXJ2ZWQgd29yZCAlcywgY29kZSAlZFxuIixyLT5saXRlcmFsLHItPmNvZGUpOwpAQCAtMzE2OSw2ICszMTcwLDE4IEBACiB9CiAKICNpZmRlZiBfX1VfQk9PVF9fCitzdGF0aWMgdm9pZCB1X2Jvb3RfaHVzaF9yZWxvYyh2b2lkKQoreworCURFQ0xBUkVfR0xPQkFMX0RBVEFfUFRSOworCXVuc2lnbmVkIGxvbmcgYWRkcjsKKwlzdHJ1Y3QgcmVzZXJ2ZWRfY29tYm8gKnI7CisKKwlmb3IgKHI9cmVzZXJ2ZWRfbGlzdDsgcjxyZXNlcnZlZF9saXN0K05SRVM7IHIrKykgeworCQlhZGRyID0gKHVsb25nKSAoci0+bGl0ZXJhbCkgKyBnZC0+cmVsb2Nfb2ZmOworCQlyLT5saXRlcmFsID0gKGNoYXIgKilhZGRyOworCX0KK30KKwogaW50IHVfYm9vdF9odXNoX3N0YXJ0KHZvaWQpCiB7CiAJdG9wX3ZhcnMgPSBtYWxsb2Moc2l6ZW9mKHN0cnVjdCB2YXJpYWJsZXMpKTsKQEAgLTMxNzcsNiArMzE5MCw3IEBACiAJdG9wX3ZhcnMtPm5leHQgPSAwOwogCXRvcF92YXJzLT5mbGdfZXhwb3J0ID0gMDsKIAl0b3BfdmFycy0+ZmxnX3JlYWRfb25seSA9IDE7CisJdV9ib290X2h1c2hfcmVsb2MoKTsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvY29tbW9uL21haW4uYyBiL2NvbW1vbi9tYWluLmMKaW5kZXggZTMyODQ1ZS4uMzNkODcxNyAxMDA2NDQKLS0tIGEvY29tbW9uL21haW4uYworKysgYi9jb21tb24vbWFpbi5jCkBAIC04NjIsNyArODYyLDYgQEAKIGludCBkb19ydW4gKGNtZF90YmxfdCAqIGNtZHRwLCBpbnQgZmxhZywgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKIHsKIAlpbnQgaTsKLQlpbnQgcmNvZGUgPSAxOwogCiAJaWYgKGFyZ2MgPCAyKSB7CiAJCXByaW50ZiAoIlVzYWdlOlxuJXNcbiIsIGNtZHRwLT51c2FnZSk7CkBAIC04NzAsMTMgKzg2OSwyMSBAQAogCX0KIAogCWZvciAoaT0xOyBpPGFyZ2M7ICsraSkgeworCQljaGFyICphcmc7CisKKwkJaWYgKChhcmcgPSBnZXRlbnYgKGFyZ3ZbaV0pKSA9PSBOVUxMKSB7CisJCQlwcmludGYgKCIjIyBFcnJvcjogXCIlc1wiIG5vdCBkZWZpbmVkXG4iLCBhcmd2W2ldKTsKKwkJCXJldHVybiAxOworCQl9CiAjaWZuZGVmIENGR19IVVNIX1BBUlNFUgotCSAgICBpZiAocnVuX2NvbW1hbmQgKGdldGVudiAoYXJndltpXSksIGZsYWcpICE9IC0xKSArK3Jjb2RlOworCQlpZiAocnVuX2NvbW1hbmQgKGFyZywgZmxhZykgPT0gLTEpCisJCQlyZXR1cm4gMTsKICNlbHNlCi0gICAJICAgIGlmIChwYXJzZV9zdHJpbmdfb3V0ZXIoZ2V0ZW52IChhcmd2W2ldKSwKLQkJICAgIEZMQUdfUEFSU0VfU0VNSUNPTE9OIHwgRkxBR19FWElUX0ZST01fTE9PUCkgPT0gMCkgKytyY29kZTsKKwkJaWYgKHBhcnNlX3N0cmluZ19vdXRlcihhcmcsCisJCSAgICBGTEFHX1BBUlNFX1NFTUlDT0xPTiB8IEZMQUdfRVhJVF9GUk9NX0xPT1ApID09IDApCisJCQlyZXR1cm4gMTsKICNlbmRpZgogCX0KLQlyZXR1cm4gKChyY29kZSA9PSBpKSA/IDAgOiAxKTsKKwlyZXR1cm4gMDsKIH0KLSNlbmRpZgorI2VuZGlmCS8qIENGR19DTURfUlVOICovCmRpZmYgLS1naXQgYS9jcHUvbWlwcy9jYWNoZS5TIGIvY3B1L21pcHMvY2FjaGUuUwppbmRleCBhZWIwNGIzLi4yNzE1YjliIDEwMDY0NAotLS0gYS9jcHUvbWlwcy9jYWNoZS5TCisrKyBiL2NwdS9taXBzL2NhY2hlLlMKQEAgLTI1Myw5ICsyNTMsOSBAQAogCS5nbG9ibAltaXBzX2NhY2hlX2xvY2sKIAkuZW50CW1pcHNfY2FjaGVfbG9jawogbWlwc19jYWNoZV9sb2NrOgotCWxpCWExLCBLMEJBU0UgLSBDRkdfRENBQ0hFX1NJWkUKKwlsaQlhMSwgSzBCQVNFIC0gQ0ZHX0RDQUNIRV9TSVpFLzIKIAlhZGR1CWEwLCBhMQotCWxpCWEyLCBDRkdfRENBQ0hFX1NJWkUKKwlsaQlhMiwgQ0ZHX0RDQUNIRV9TSVpFLzIKIAlsaQlhMywgQ0ZHX0NBQ0hFTElORV9TSVpFCiAJbW92ZQlhMSwgYTIKIAlpY2FjaGVvcChhMCxhMSxhMixhMywweDFkKQpkaWZmIC0tZ2l0IGEvY3B1L21pcHMvY3B1LmMgYi9jcHUvbWlwcy9jcHUuYwppbmRleCAzZmMzOTE2Li5lOTY3NmMxIDEwMDY0NAotLS0gYS9jcHUvbWlwcy9jcHUuYworKysgYi9jcHUvbWlwcy9jcHUuYwpAQCAtMjcsOCArMjcsMTIgQEAKIAogaW50IGRvX3Jlc2V0KGNtZF90YmxfdCAqY21kdHAsIGludCBmbGFnLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQogewotI2lmZGVmIENPTkZJR19JTkNBX0lQCisjaWYgZGVmaW5lZChDT05GSUdfSU5DQV9JUCkKIAkqSU5DQV9JUF9XRFRfUlNUX1JFUSA9IDB4M2Y7CisjZWxpZiBkZWZpbmVkKENPTkZJR19QVVJQTEUpCisJdm9pZCAoKmYpKHZvaWQpID0gKHZvaWQgKikgMHhiZmMwMDAwMDsKKworCWYoKTsKICNlbmRpZgogCWZwcmludGYoc3RkZXJyLCAiKioqIHJlc2V0IGZhaWxlZCAqKipcbiIpOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvY3B1L21pcHMvc2VyaWFsLmMgYi9jcHUvbWlwcy9zZXJpYWwuYwppbmRleCBlYmRhNTA5Li5iMjZmNDFkIDEwMDY0NAotLS0gYS9jcHUvbWlwcy9zZXJpYWwuYworKysgYi9jcHUvbWlwcy9zZXJpYWwuYwpAQCAtMiwxMCArMiw0OSBAQAogICogKElOQ0EpIEFTQyBVQVJUIHN1cHBvcnQKICAqLwogCisjaW5jbHVkZSA8Y29uZmlnLmg+CisKKyNpZmRlZiBDT05GSUdfUFVSUExFCisjZGVmaW5lCXNlcmlhbF9pbml0CWFzY19zZXJpYWxfaW5pdAorI2RlZmluZQlzZXJpYWxfcHV0Ywlhc2Nfc2VyaWFsX3B1dGMKKyNkZWZpbmUJc2VyaWFsX3B1dHMJYXNjX3NlcmlhbF9wdXRzCisjZGVmaW5lCXNlcmlhbF9nZXRjCWFzY19zZXJpYWxfZ2V0YworI2RlZmluZQlzZXJpYWxfdHN0Ywlhc2Nfc2VyaWFsX3RzdGMKKyNkZWZpbmUJc2VyaWFsX3NldGJyZwlhc2Nfc2VyaWFsX3NldGJyZworI2VuZGlmCisKICNpbmNsdWRlIDxjb21tb24uaD4KICNpbmNsdWRlIDxhc20vaW5jYS1pcC5oPgogI2luY2x1ZGUgInNlcmlhbC5oIgogCisjaWZkZWYgQ09ORklHX1BVUlBMRQorCisjdW5kZWYgQVNDX0ZJRk9fUFJFU0VOVAorI2RlZmluZSBUT1VUX0xPT1AJMTAwMDAwCisKKy8qIFNldCBiYXNlIGFkZHJlc3MgZm9yIHNlY29uZCBGUEkgaW50ZXJydXB0IGNvbnRyb2wgcmVnaXN0ZXIgYmFuayAqLworI2RlZmluZSBTRlBJX0lOVENPTl9CQVNFQUREUgkweEJGMEYwMDAwIAorCisvKiBSZWdpc3RlciBvZmZzZXQgZnJvbSBiYXNlIGFkZHJlc3MgKi8KKyNkZWZpbmUgRkJTX0lTUgkJMHgwMDAwMDAwMAkvKiBJbnRlcnJ1cHQgc3RhdHVzIHJlZ2lzdGVyICovCisjZGVmaW5lIEZCU19JTVIJCTB4MDAwMDAwMDgJLyogSW50ZXJydXB0IG1hc2sgcmVnaXN0ZXIgKi8KKyNkZWZpbmUgRkJTX0lESVMJMHgwMDAwMDAxMAkvKiBJbnRlcnJ1cHQgZGlzYWJsZSByZWdpc3RlciAqLworCisvKiBJbnRlcnJ1cHQgc3RhdHVzIHJlZ2lzdGVyIGJpdHMgKi8KKyNkZWZpbmUgRkJTX0lTUl9BVAkweDAwMDAwMDQwCS8qIEFTQyB0cmFuc21pdCBpbnRlcnJ1cHQgKi8KKyNkZWZpbmUgRkJTX0lTUl9BUiAJMHgwMDAwMDAyMAkvKiBBU0MgcmVjZWl2ZSBpbnRlcnJ1cHQgKi8KKyNkZWZpbmUgRkJTX0lTUl9BRQkweDAwMDAwMDEwCS8qIEFTQyBlcnJvciBpbnRlcnJ1cHQgKi8KKyNkZWZpbmUgRkJTX0lTUl9BQgkweDAwMDAwMDA4CS8qIEFTQyB0cmFuc21pdCBidWZmZXIgaW50ZXJydXB0ICovCisjZGVmaW5lIEZCU19JU1JfQVMgICAgICAweDAwMDAwMDA0IAkvKiBBU0Mgc3RhcnQgb2YgYXV0b2JhdWQgZGV0ZWN0aW9uIGludGVycnVwdCAqLworI2RlZmluZSBGQlNfSVNSX0FGCTB4MDAwMDAwMDIJLyogQVNDIGVuZCBvZiBhdXRvYmF1ZCBkZXRlY3Rpb24gaW50ZXJydXB0ICovCisKKyNlbHNlCisKKyNkZWZpbmUgQVNDX0ZJRk9fUFJFU0VOVAorCisjZW5kaWYKKworCiAjZGVmaW5lIFNFVF9CSVQocmVnLCBtYXNrKSAgICAgICAgICAgICAgICAgIHJlZyB8PSAobWFzaykKICNkZWZpbmUgQ0xFQVJfQklUKHJlZywgbWFzaykgICAgICAgICAgICAgICAgcmVnICY9ICh+bWFzaykKICNkZWZpbmUgQ0xFQVJfQklUUyhyZWcsIG1hc2spICAgICAgICAgICAgICAgQ0xFQVJfQklUKHJlZywgbWFzaykKQEAgLTMyLDggKzcxLDEwIEBACiAKIGludCBzZXJpYWxfaW5pdCAodm9pZCkKIHsKKyNpZmRlZiBDT05GSUdfSU5DQV9JUAogICAgIC8qIHdlIGhhdmUgdG8gc2V0IFBNVS5FTjEzIGJpdCB0byBlbmFibGUgYW4gQVNDIGRldmljZSovCiAgICAgSU5DQUFTQ19QTVVfRU5BQkxFKDEzKTsKKyNlbmRpZgogICAgIAogICAgIC8qIGFuZCB3ZSBoYXZlIHRvIHNldCBDTEMgcmVnaXN0ZXIqLwogICAgIENMRUFSX0JJVChwQXNjLT5hc2NfY2xjLCBBU0NDTENfRElTUyk7CkBAIC00NSw2ICs4Niw3IEBACiAgICAgLyogc2VsZWN0IGlucHV0IHBvcnQgKi8KICAgICBwQXNjLT5hc2NfcGlzZWwgPSAoQ09OU09MRV9UVFkgJiAweDEpOwogCisjaWZkZWYgQVNDX0ZJRk9fUFJFU0VOVAogICAgIC8qIFRYRklGTydzIGZpbGxpbmcgbGV2ZWwgKi8KICAgICBTRVRfQklURklFTEQocEFzYy0+YXNjX3R4ZmNvbiwgQVNDVFhGQ09OX1RYRklUTE1BU0ssCiAgICAgICAgICAgICAgICAgICAgIEFTQ1RYRkNPTl9UWEZJVExPRkYsIElOQ0FBU0NfVFhGSUZPX0ZMKTsKQEAgLTU2LDIwICs5OCwyNSBAQAogICAgICAgICAgICAgICAgICAgICBBU0NSWEZDT05fUlhGSVRMT0ZGLCBJTkNBQVNDX1JYRklGT19GTCk7CiAgICAgLyogZW5hYmxlIFJYRklGTyAqLwogICAgIFNFVF9CSVQocEFzYy0+YXNjX3J4ZmNvbiwgQVNDUlhGQ09OX1JYRkVOKTsKKyNlbmRpZgogCiAgICAgLyogZW5hYmxlIGVycm9yIHNpZ25hbHMgKi8KICAgICBTRVRfQklUKHBBc2MtPmFzY19jb24sIEFTQ0NPTl9GRU4pOwogICAgIFNFVF9CSVQocEFzYy0+YXNjX2NvbiwgQVNDQ09OX09FTik7CiAKKyNpZmRlZiBDT05GSUdfSU5DQV9JUAogICAgIC8qIGFja25vd2xlZGdlIEFTQyBpbnRlcnJ1cHRzICovCiAgICAgQVNDX0lOVEVSUlVQVFNfQ0xFQVIoSU5DQUFTQ19JUlFfTElORV9BTEwpOwogCiAgICAgLyogZGlzYWJsZSBBU0MgaW50ZXJydXB0cyAqLwogICAgIEFTQ19JTlRFUlJVUFRTX0RJU0FCTEUoSU5DQUFTQ19JUlFfTElORV9BTEwpOworI2VuZGlmCiAKKyNpZmRlZiBBU0NfRklGT19QUkVTRU5UCiAgICAgLyogc2V0IEZJRk9zIGludG8gdGhlIHRyYW5zcGFyZW50IG1vZGUgKi8KICAgICBTRVRfQklUKHBBc2MtPmFzY190eGZjb24sIEFTQ1RYRkNPTl9UWFRNRU4pOwogICAgIFNFVF9CSVQocEFzYy0+YXNjX3J4ZmNvbiwgQVNDUlhGQ09OX1JYVE1FTik7CisjZW5kaWYKIAogICAgIC8qIHNldCBiYXVkIHJhdGUgKi8KICAgICBzZXJpYWxfc2V0YnJnKCk7CkBAIC04NSw3ICsxMzIsMTEgQEAKICAgICB1bG9uZyAgICAgIHVpUmVsb2FkVmFsdWUsIGZkdjsKICAgICB1bG9uZyAgICAgIGZfQVNDOwogCisjaWZkZWYgQ09ORklHX0lOQ0FfSVAKICAgICBmX0FTQyA9IGluY2FpcF9nZXRfZnBpY2xrKCk7CisjZWxzZQorICAgIGZfQVNDID0gQVNDX0NMT0NLX1JBVEU7CisjZW5kaWYKIAogI2lmbmRlZiBJTkNBQVNDX1VTRV9GRFYKICAgICBmZHYgPSAyOwpAQCAtMjEwLDEwICsyNjEsMTUgQEAKIAogdm9pZCBzZXJpYWxfcHV0YyAoY29uc3QgY2hhciBjKQogeworI2lmZGVmIEFTQ19GSUZPX1BSRVNFTlQKICAgICB1aW50IHR4RmwgPSAwOworI2Vsc2UKKyAgICB1aW50IHRpbWVvdXQgPSAwOworI2VuZGlmCiAKICAgICBpZiAoYyA9PSAnXG4nKSBzZXJpYWxfcHV0YyAoJ1xyJyk7CiAKKyNpZmRlZiBBU0NfRklGT19QUkVTRU5UCiAgICAgLyogY2hlY2sgZG8gd2UgaGF2ZSBhIGZyZWUgc3BhY2UgaW4gdGhlIFRYIEZJRk8gKi8KICAgICAvKiBnZXQgY3VycmVudCBmaWxsaW5nIGxldmVsICovCiAgICAgZG8KQEAgLTIyMSw4ICsyNzcsMjUgQEAKIAl0eEZsID0gKCBwQXNjLT5hc2NfZnN0YXQgJiBBU0NGU1RBVF9UWEZGTE1BU0sgKSA+PiBBU0NGU1RBVF9UWEZGTE9GRjsKICAgICB9CiAgICAgd2hpbGUgKCB0eEZsID09IElOQ0FBU0NfVFhGSUZPX0ZVTEwgKTsKKyNlbHNlCisKKyAgICB3aGlsZSghKCoodm9sYXRpbGUgdW5zaWduZWQgbG9uZyopKFNGUElfSU5UQ09OX0JBU0VBRERSICsgRkJTX0lTUikgJgorCQkJICAgRkJTX0lTUl9BQikpCisgICAgeworCSAgICBpZiAodGltZW91dCsrID4gVE9VVF9MT09QKQorCSAgICB7CisJCSAgICBicmVhazsKKwkgICAgfQorICAgIH0KKyNlbmRpZgogCiAgICAgcEFzYy0+YXNjX3RidWYgPSBjOyAvKiB3cml0ZSBjaGFyIHRvIFRyYW5zbWl0IEJ1ZmZlciBSZWdpc3RlciAqLworCisjaWZuZGVmIEFTQ19GSUZPX1BSRVNFTlQKKyAgICAqKHZvbGF0aWxlIHVuc2lnbmVkIGxvbmcqKShTRlBJX0lOVENPTl9CQVNFQUREUiArIEZCU19JU1IpID0gRkJTX0lTUl9BQiB8CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEZCU19JU1JfQVQ7CisjZW5kaWYKKyAgICAKICAgICAvKiBjaGVjayBmb3IgZXJyb3JzICovCiAgICAgaWYgKCBwQXNjLT5hc2NfY29uICYgQVNDQ09OX09FICkKICAgICB7CkBAIC0yNTEsNiArMzI0LDEwIEBACiAgICAgCiAgICAgYyA9IChjaGFyKShwQXNjLT5hc2NfcmJ1ZiAmIHN5bWJvbF9tYXNrKTsKIAorI2lmbmRlZiBBU0NfRklGT19QUkVTRU5UCisgICAgKih2b2xhdGlsZSB1bnNpZ25lZCBsb25nKikoU0ZQSV9JTlRDT05fQkFTRUFERFIgKyBGQlNfSVNSKSA9IEZCU19JU1JfQVI7CisjZW5kaWYKKwogICAgIHJldHVybiBjOwogfQogCkBAIC0yNTgsMTAgKzMzNSwxOSBAQAogewogICAgIGludCByZXMgPSAxOwogCisjaWZkZWYgQVNDX0ZJRk9fUFJFU0VOVAogICAgIGlmICggKHBBc2MtPmFzY19mc3RhdCAmIEFTQ0ZTVEFUX1JYRkZMTUFTSykgPT0gMCApCiAgICAgewogICAgICAgICByZXMgPSAwOwogICAgIH0KKyNlbHNlCisgICAgaWYgKCEoKih2b2xhdGlsZSB1bnNpZ25lZCBsb25nKikoU0ZQSV9JTlRDT05fQkFTRUFERFIgKyBGQlNfSVNSKSAmCisJCQkgICAgCQkJCQlGQlNfSVNSX0FSKSkKKyAgICAKKyAgICB7CisgICAgICAgIHJlcyA9IDA7CisgICAgfQorI2VuZGlmCiAgICAgZWxzZSBpZiAoIHBBc2MtPmFzY19jb24gJiBBU0NDT05fRkUgKQogICAgIHsKICAgICAgICAgU0VUX0JJVChwQXNjLT5hc2Nfd2hiY29uLCBBU0NXSEJDT05fQ0xSRkUpOwpkaWZmIC0tZ2l0IGEvY3B1L21pcHMvc3RhcnQuUyBiL2NwdS9taXBzL3N0YXJ0LlMKaW5kZXggYmYxMTY1NS4uODZhODQwNyAxMDA2NDQKLS0tIGEvY3B1L21pcHMvc3RhcnQuUworKysgYi9jcHUvbWlwcy9zdGFydC5TCkBAIC00Miw5ICs0MiwxMiBAQAogX3N0YXJ0OgogCVJWRUNFTlQocmVzZXQsMCkJLyogVS1ib290IGVudHJ5IHBvaW50ICovCiAJUlZFQ0VOVChyZXNldCwxKQkvKiBzb2Z0d2FyZSByZWJvb3QgKi8KLSNpZmRlZiBDT05GSUdfSU5DQV9JUAotCS53b3JkIDB4MDAwMDIwQzQJLyogRUJVIGluaXQgY29kZSwgZmV0Y2hlZCBkdXJpbmcgYm9vdGluZyAqLwotCS53b3JkIDB4MDAwMDAwMDAgICAgICAgIC8qIHBoYXNlIG9mIHRoZSBmbGFzaCAgICAgICAgICAgICAgICAgICAgKi8KKyNpZiBkZWZpbmVkKENPTkZJR19JTkNBX0lQKQorCS53b3JkIElORklORU9OX0VCVV9CT09UQ0ZHIC8qIEVCVSBpbml0IGNvZGUsIGZldGNoZWQgZHVyaW5nIGJvb3RpbmcgKi8KKwkud29yZCAweDAwMDAwMDAwICAgICAgICAgICAvKiBwaGFzZSBvZiB0aGUgZmxhc2ggICAgICAgICAgICAgICAgICAgICovCisjZWxpZiBkZWZpbmVkKENPTkZJR19QVVJQTEUpCisJLndvcmQgSU5GSU5FT05fRUJVX0JPT1RDRkcgLyogRUJVIGluaXQgY29kZSwgZmV0Y2hlZCBkdXJpbmcgYm9vdGluZyAqLworCS53b3JkIElORklORU9OX0VCVV9CT09UQ0ZHIC8qIEVCVSBpbml0IGNvZGUsIGZldGNoZWQgZHVyaW5nIGJvb3RpbmcgKi8KICNlbHNlCiAJUlZFQ0VOVChyb21SZXNlcnZlZCwyKQogI2VuZGlmCkBAIC0xNzgsNiArMTgxLDMwIEBACiAJICogMTI4ICogOCA9PSAxMDI0ID09IDB4NDAwCiAJICogc28gdGhpcyBpcyBhZGRyZXNzIFJfVkVDKzB4NDAwID09IDB4YmZjMDA0MDAKIAkgKi8KKyNpZmRlZiBDT05GSUdfUFVSUExFCisvKiAweGJmYzAwNDAwICovCisJLndvcmQJMHhkYzg3MDAwMAorCS53b3JkCTB4ZmNhNzAwMDAKKwkud29yZAkweDIwODQwMDA4CisJLndvcmQJMHgyMGE1MDAwOAorCS53b3JkCTB4MjBjNmZmZmYKKwkud29yZAkweDE0YzBmZmZhCisJLndvcmQJMHgwMDAwMDAwMAorCS53b3JkCTB4MDNlMDAwMDgKKwkud29yZAkweDAwMDAwMDAwCisJLndvcmQgICAweDAwMDAwMDAwCisvKiAweGJmYzAwNDI4ICovCisJLndvcmQJMHhkYzg3MDAwMAorCS53b3JkCTB4ZmNhNzAwMDAKKwkud29yZAkweDIwODQwMDA4CisJLndvcmQJMHgyMGE1MDAwOAorCS53b3JkCTB4MjBjNmZmZmYKKwkud29yZAkweDE0YzBmZmZhCisJLndvcmQJMHgwMDAwMDAwMAorCS53b3JkCTB4MDNlMDAwMDgKKwkud29yZAkweDAwMDAwMDAwCisJLndvcmQgICAweDAwMDAwMDAwCisjZW5kaWYgLyogQ09ORklHX1BVUlBMRSAqLwogCS5hbGlnbiA0CiByZXNldDoKIApAQCAtMjgzLDEyICszMTAsMTcgQEAKIAkgKiB0MSA9IHRhcmdldCBhZGRyZXNzCiAJICogdDIgPSBzb3VyY2UgZW5kIGFkZHJlc3MKIAkgKi8KKwkvKiBPbiB0aGUgcHVycGxlIGJvYXJkIHdlIGNvcHkgdGhlIGNvZGUgZWFybGllciBpbiBhIHNwZWNpYWwgd2F5CisJICogaW4gb3JkZXIgdG8gc29sdmUgZmxhc2ggcHJvYmxlbXMKKwkgKi8KKyNpZm5kZWYgQ09ORklHX1BVUlBMRQogMToKIAlsdwl0MywgMCh0MCkKIAlzdwl0MywgMCh0MSkKIAlhZGR1CXQwLCA0CiAJYmxlCXQwLCB0MiwgMWIKIAlhZGR1CXQxLCA0CQkJLyogZGVsYXkgc2xvdAkJCSovCisjZW5kaWYKIAogCS8qIElmIGNhY2hlcyB3ZXJlIGVuYWJsZWQsIHdlIHdvdWxkIGhhdmUgdG8gZmx1c2ggdGhlbSBoZXJlLgogCSAqLwpkaWZmIC0tZ2l0IGEvY3B1L3hzY2FsZS9zZXJpYWwuYyBiL2NwdS94c2NhbGUvc2VyaWFsLmMKaW5kZXggMzUzMDJhNy4uYzlkNWY3MCAxMDA2NDQKLS0tIGEvY3B1L3hzY2FsZS9zZXJpYWwuYworKysgYi9jcHUveHNjYWxlL3NlcmlhbC5jCkBAIC02Nyw3ICs2NywyMSBAQAogCiAJRkZJRVIgPSBJRVJfVVVFOwkJCS8qIEVuYWJsZSBGRlVBUlQgKi8KIAotI2VsaWYgQ09ORklHX1NUVUFSVAorI2VsaWYgZGVmaW5lZChDT05GSUdfQlRVQVJUKQorCUNLRU4gfD0gQ0tFTjdfQlRVQVJUOworCisJQlRJRVIgPSAwOworCUJURkNSID0gMDsKKworCS8qIHNldCBiYXVkIHJhdGUgKi8KKwlCVExDUiA9IExDUl9ETEFCOworCUJURExMID0gcXVvdCAmIDB4ZmY7CisJQlRETEggPSBxdW90ID4+IDg7CisJQlRMQ1IgPSBMQ1JfV0xTMCB8IExDUl9XTFMxOworCisJQlRJRVIgPSBJRVJfVVVFOwkJCS8qIEVuYWJsZSBCRlVBUlQgKi8KKworI2VsaWYgZGVmaW5lZChDT05GSUdfU1RVQVJUKQogI2Vycm9yICJCYWQ6IG5vdCBpbXBsZW1lbnRlZCB5ZXQhIgogI2Vsc2UKICNlcnJvciAiQmFkOiB5b3UgZGlkbid0IGNvbmZpZ3VyZWQgc2VyaWFsIC4uLiIKQEAgLTk4LDcgKzExMiwxMCBAQAogCXdoaWxlICgoRkZMU1IgJiBMU1JfVEVNVCkgPT0gMCk7CiAKIAlGRlRIUiA9IGM7Ci0jZWxpZiBDT05GSUdfU1RVQVJUCisjZWxpZiBkZWZpbmVkKENPTkZJR19CVFVBUlQpCisJd2hpbGUgKChCVExTUiAmIExTUl9URU1UICkgPT0gMCApOworCUJUVEhSID0gYzsKKyNlbGlmIGRlZmluZWQoQ09ORklHX1NUVUFSVCkKICNlbmRpZgogCiAJLyogSWYgXG4sIGFsc28gZG8gXHIgKi8KQEAgLTExNSw3ICsxMzIsOSBAQAogewogI2lmZGVmIENPTkZJR19GRlVBUlQKIAlyZXR1cm4gRkZMU1IgJiBMU1JfRFI7Ci0jZWxpZiBDT05GSUdfU1RVQVJUCisjZWxpZiBkZWZpbmVkKENPTkZJR19CVFVBUlQpCisJcmV0dXJuIEJUTFNSICYgTFNSX0RSOworI2VsaWYgZGVmaW5lZChDT05GSUdfU1RVQVJUKQogI2VuZGlmCiB9CiAKQEAgLTEzMCw3ICsxNDksMTEgQEAKIAl3aGlsZSAoIShGRkxTUiAmIExTUl9EUikpOwogCiAJcmV0dXJuIChjaGFyKSBGRlJCUiAmIDB4ZmY7Ci0jZWxpZiBDT05GSUdfU1RVQVJUCisjZWxpZiBkZWZpbmVkKENPTkZJR19CVFVBUlQpCisJd2hpbGUgKCEoQlRMU1IgJiBMU1JfRFIpKTsKKworCXJldHVybiAoY2hhcikgQlRSQlIgJiAweGZmOworI2VsaWYgZGVmaW5lZChDT05GSUdfU1RVQVJUKQogI2VuZGlmCiB9CiAKZGlmZiAtLWdpdCBhL2RvYy9JMkNfRWRnZV9Db25kaXRpb25zIGIvZG9jL0kyQ19FZGdlX0NvbmRpdGlvbnMKaW5kZXggOTE1NTdhMy4uYmU3ZjFiZSAxMDA2NDQKLS0tIGEvZG9jL0kyQ19FZGdlX0NvbmRpdGlvbnMKKysrIGIvZG9jL0kyQ19FZGdlX0NvbmRpdGlvbnMKQEAgLTMxLDggKzMxLDEzIEBACiAhISFUSElTIElTIEFOIFVORE9DVU1FTlRFRCBJMkMgQlVTIEJVRywgTk9UIEEgSUJNIDR4eCBCVUchISEKIAogVGhpcyByZXNldCBlZGdlIGNvbmRpdGlvbiBjb3VsZCBwb3NzaWJseSBiZSBwcmVzZW50IGluIGV2ZXJ5IEkyQwotY29udHJvbGxlciBhbmQgZGV2aWNlIGF2YWlsYWJsZS4gV2Ugc2hvdWxkIHByb2JhYmx5IGhhdmUgYSBidXMgcmVzZXQKLWZ1bmN0aW9uIGZvciBhbGwgb3VyIHRhcmdldCBDUFVzLgorY29udHJvbGxlciBhbmQgZGV2aWNlIGF2YWlsYWJsZS4gRm9yIGJvYXJkcyB3aGVyZSBhIEkyQyBidXMgcmVzZXQKK2Z1bmN0aW9uIGNhbiBiZSBpbXBsZW1lbnRlZCBhIGkyY19pbml0X2JvYXJkKCkgZnVuY3Rpb24gc2hvdWxkIGJlCitwcm92aWRlZCBhbmQgZW5hYmxlZCBieSAjZGVmaW5lJ2luZyBDRkdfSTJDX0lOSVRfQk9BUkQgaW4geW91cgorYm9hcmQncyBjb25maWcgZmlsZS4gTm90ZSB0aGF0IHRoaXMgaXMgTk9UIG5lY2Vzc2FyeSB3aGVuIHVzaW5nIHRoZQorYml0LWJhbmdpbmcgSTJDIGRyaXZlciAoY29tbW9uL3NvZnRfaTJjLmMpIGFzIHRoaXMgYWxyZWFkeSBpbmNsdWRlcwordGhlIEkyQyBidXMgcmVzZXQgc2VxdWVuY2UuCisKIAogTWFueSB0aGFua3MgdG8gQmlsbCBIdW50ZXIgZm9yIGZpbmRpbmcgdGhpcyBzZXJpb3VzIEJVRy4KIGVtYWlsIHRvOiA8d2lsbGlhbWh1bnRlckBhdHRiaS5jb20+CmRpZmYgLS1naXQgYS9kb2MvUkVBRE1FLklOQ0EtSVAgYi9kb2MvUkVBRE1FLklOQ0EtSVAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTE3ZWVjMAotLS0gL2Rldi9udWxsCisrKyBiL2RvYy9SRUFETUUuSU5DQS1JUApAQCAtMCwwICsxLDQ0IEBACisKK0ZsYXNoIHByb2dyYW1taW5nIG9uIHRoZSBJTkNBLUlQIGJvYXJkIGlzIGNvbXBsaWNhdGVkIGJlY2F1c2Ugb2YgdGhlCitFQlUgc3dhcHBpbmcgdW5pdC4gQSBCREkyMDAwIGNhbiBiZSB1c2VkIGZvciBmbGFzaCBwcm9ncmFtbWluZyBvbmx5CitpZiB0aGUgRUJVIHN3YXBwaW5nIHVuaXQgaXMgZW5hYmxlZDsgb3RoZXJ3aXNlIGl0IHdpbGwgbm90IGRldGVjdCB0aGUKK2ZsYXNoIG1lbW9yeS4gQnV0IHRoZSBFQlUgc3dhcHBpbmcgdW5pdCBpcyBkaXNhZGJsZWQgYWZ0ZXIgcmVzZXQsIHNvCitpZiB5b3UgcHJvZ3JhbSBzb21lIGNvZGUgdG8gZmxhc2ggd2l0aCB0aGUgc3dhcHBpbmcgdW5pdCBvbiwgaXQgd2lsbAorbm90IGJlIHJ1bm5hYmxlIHdpdGggdGhlIHN3YXBwaW5nIHVuaXQgb2ZmLgorCitUaGUgY29uc2VxdWVuY2UgaXMgdGhhdCB5b3UgaGF2ZSB0byB3cml0ZSBhIHByZS1zd2FwcGVkIGltYWdlIHRvCitmbGFzaCB1c2luZyB0aGUgQkRJMjAwMC4gQSBzaW1wbGUgaG9zdC1zaWRlIHRvb2wgImluY2Etc3dhcC1ieXRlcyIgaXMKK3Byb3ZpZGVkIGluIHRoZSAidG9vbHMvIiBkaXJlY3RvcnkuIFVzZSBpdCBhcyBmb2xsb3dzOgorCisJYmFzaCQgLi9pbmNhLXN3YXAtYnl0ZXMgPHUtYm9vdC5iaW4gPnUtYm9vdC5iaW4uc3dwCisKK05vdGUgdGhhdCB0aGUgY3VycmVudCBCREkgY29uZmlnIGZpbGUgX2Rpc2FibGVzXyB0aGUgRUJVIHN3YXBwaW5nCit1bml0IGZvciB0aGUgZmxhc2ggYmFuayAwLiBUbyBlbmFibGUgaXQsICh0aGlzIGlzIHJlcXVpcmVkIGZvciB0aGUKK0JESSBmbGFzaCBjb21tYW5kcyB0byB3b3JrKSB1bmNvbW1lbnQgdGhlIGZvbGxvd2luZyBsaW5lIGluIHRoZQorY29uZmlnIGZpbGU6CisKKwk7V00zMiAgIDB4YjgwMDAyNjAgICAgICAweDQwNDE2MWZmIDsgU3dhcHBpbmcgdW5pdCBlbmFibGVkCisKK2FuZCBjb21tZW50IG91dAorCisJV00zMiAgICAweGI4MDAwMjYwICAgICAgMHgwMDQxNjFmZiA7IFN3YXBwaW5nIHVuaXQgZGlzYWJsZWQKKworQWx0ZXJuYXRpdmVseSwgeW91IGNhbiB1c2UgIm1tIDB4YjgwMDAyNjAgPHZhbHVlPiIgY29tbWFuZHMgdG8KK2VuYWJsZS9kaXNhYmxlIHRoZSBzd2FwcGluZyB1bml0IG1hbnVhbGx5LgorCitKdXN0IGZvciByZWZlcmVuY2UsIGhlcmUgaXMgdGhlIGNvbXBsZXRlIHNlcXVlbmNlIG9mIGFjdGlvbnMgd2UgdG9vawordG8gaW5zdGFsbCBhIFUtQm9vdCBpbWFnZSBpbnRvIGZsYXNoLgorCisgICAgMS4gLi9pbmNhLXN3YXAtYnl0ZXMgPHUtYm9vdC5iaW4gPnUtYm9vdC5iaW4uc3dwCisKKyAgICAyLiBGcm9tIEJESToKKworCW1tIDB4YjgwMDAyNjAgIDB4NDA0MTYxZmYKKwllcmFzZSAweGIwMDAwMDAwCisJZXJhc2UgMHhiMDAxMDAwMAorCXByb2cgMHhiMDAwMDAwMCAvdGZ0cGJvb3QvSU5DQS91LWJvb3QuYmluLnN3cCBiaW4KKwltbSAweGI4MDAwMjYwIDB4MDA0MTYxZmYKKwlnbyAweGIwMDAwMDAwCisKKworKEMpIDIwMDMgV29sZmdhbmcgRGVuawpkaWZmIC0tZ2l0IGEvZG9jL1JFQURNRS5pZG1hMmludHIgYi9kb2MvUkVBRE1FLmlkbWEyaW50cgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xODI4YjUxCi0tLSAvZGV2L251bGwKKysrIGIvZG9jL1JFQURNRS5pZG1hMmludHIKQEAgLTAsMCArMSwxMCBAQAorKEMpIDIwMDMgQXJ1biBEaGFyYW5rYXIgPEFEaGFyYW5rYXJAQVRUQkkuQ29tPgorCitBdHRhY2hlZCBpcyBhbiBJRE1BIGV4YW1wbGUgY29kZSBmb3IgTVBDODI2MC9QUENCb290LiBJIGhhZCB0cmllZCB0bworc2VhcmNoIGFyb3VuZCBhbmQgY291bGQgbm90IGZpbmQgYW55IGZvciBpbXBsZW1lbnRpbmcgSURNQSwgc28KK2ltcGxlbWVudGVkIG9uZS4gSXRzIG5vdCBjb2RlZCBpbiB0aGUgYmVzdCB3YXksIGJ1dCB3b3Jrcy4KKworQWxzbywgSSB3YXMgYWJsZSB0byB0ZXN0IHRoZSBJRE1BIHNwZWNpZmljIGNvZGUgdW5kZXIgTGludXggYWxzbworKHdpdGggbW9kaWZpY2F0aW9ucykuIE15IHJlcXVpcmVtZW50IHdhcyB0byBpbXBsZW1lbnQgaXQgZm9yCitDb21wYWN0Rmxhc2ggaW1wbGVtZW50ZWQgaW4gbWVtb3J5IG1vZGUsIGFuZCBpdCB3b3JrcyBmb3IgaXQgdW5kZXIKK1BQQ0Jvb3QgYW5kIExpbnV4LgpkaWZmIC0tZ2l0IGEvZG9jL1JFQURNRS5zY2hlZCBiL2RvYy9SRUFETUUuc2NoZWQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2FhODllNgotLS0gL2Rldi9udWxsCisrKyBiL2RvYy9SRUFETUUuc2NoZWQKQEAgLTAsMCArMSw1MyBAQAorTm90ZXMgb24gdGhlIHNjaGVkdWxlciBpbiBzY2hlZC5jOgorfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorCisgICdzY2hlZC5jJyBwcm92aWRlcyBhbiB2ZXJ5IHNpbXBsaXN0aWMgbXVsdGktdGhyZWFkaW5nIHNjaGVkdWxlci4KKyAgIFNlZSB0aGUgZXhhbXBsZSwgZnVuY3Rpb24gJ3NjaGVkKC4uLiknLCBpbiB0aGUgc2FtZSBmaWxlIGZvciBpdHMKKyAgIEFQSSB1c2FnZS4KKworICAgVW50aWwgYW4gZXhoYXVzdGl2ZSB0ZXN0aW5nIGNhbiBiZSBkb25lLCB0aGUgaW1wbGVtZW50YXRpb24gY2Fubm90CisgICBxdWFsaWZ5IGFzIHRoYXQgb2YgcHJvZHVjdGlvbiBxdWFsaXR5LiBJdCB3b3JrcyB3aXRoIHRoZSBleGFtcGxlCisgICBpbiAnc2NoZWQuYycsIGl0IG1heSBvciBtYXkgbm90IHdvcmsgaW4gb3RoZXIgY2FzZXMuCisKKworTGltaXRhdGlvbnM6Cit+fn5+fn5+fn5+fn4KKworICAtIFRoZXJlIGFyZSBOTyBwcmltaXRpdmVzIGZvciB0aHJlYWQgc3luY2hyb25pemF0aW9uIChsb2NraW5nLAorICAgIG5vdGlmeSBldGMpLgorCisgIC0gT25seSB0aGUgR1BScyBhbmQgRlBScyBjb250ZXh0IGlzIHNhdmVkIGR1cmluZyBhIHRocmVhZCBjb250ZXh0CisgICAgc3dpdGNoLiBPdGhlciByZWdpc3RlcnMgb24gdGhlIFBvd2VyUEMgcHJvY2Vzc29yICg2MHgsIDd4eCwgN3h4eAorICAgIGV0YykgYXJlIE5PVCBzYXZlZC4KKworICAtIFRoZSBzY2hlZHVsZXIgaXMgTk9UIHRyYW5zcGFyZW50IHRvIHRoZSB1c2VyLiBUaGUgdXNlcgorICAgIGFwcGxpY2F0aW9ucyBtdXN0IGludm9rZSB0aHJlYWRfeWllbGQoKSB0byBhbGxvdyBvdGhlciB0aHJlYWRzIHRvCisgICAgc2NoZWR1bGVyLgorCisgIC0gVGhlcmUgYXJlIE5PIHByaW9yaXRpZXMsIGFuZCB0aGUgc2NoZWR1bGluZyBwb2xpY3kgaXMgcm91bmQtcm9iaW4KKyAgICBiYXNlZC4KKworICAtIFRoZXJlIGFyZSBOTyBjYXBhYmlsaXRpZXMgdG8gY29sbGVjdCB0aHJlYWQgQ1BVIHVzYWdlLCBzY2hlZHVsZXIKKyAgICBzdGF0cywgdGhyZWFkIHN0YXR1cyBldGMuCisKKyAgLSBUaGUgc2VtYW50aWNzIGFyZSBzb21ld2hhdCBiYXNlZCBvbiB0aG9zZSBvZiBwdGhyZWFkcywgYnV0IE5PVAorICAgIHRoZSBzYW1lLgorCisgIC0gT25seSBzZXZlbiB0aHJlYWRzIGFyZSBhbGxvd2VkLiBUaGVzZSBjYW4gYmUgZWFzaWx5IGluY3JlYXNlZCBieQorICAgIGNoYW5naW5nICIjZGVmaW5lIE1BWF9USFJFQURTIiBkZXBlbmRpbmcgb24gdGhlIGF2YWlsYWJsZSBtZW1vcnkuCisKKyAgLSBUaGUgc3RhY2sgc2l6ZSBvZiBlYWNoIHRocmVhZCBpcyA4S0J5dGVzLiBUaGlzIGNhbiBiZSBlYXNpbHkKKyAgICBpbmNyZWFzZWQgZGVwZW5kaW5nIG9uIHRoZSByZXF1aXJlbWVudCBhbmQgdGhlIGF2YWlsYWJsZSBtZW1vcnksCisgICAgYnkgaW5jcmVhc2luZyAiI2RlZmluZSBTVEtfU0laRSIuCisKKyAgLSBPbmx5IG9uZSBtYXN0ZXIvcGFyZW50IHRocmVhZCBpcyBhbGxvd2VkLCBhbmQgaXQgY2Fubm90IGJlCisgICAgc3RvcHBlZCBvciBkZWxldGVkLiBBbnkgZ2l2ZW4gdGhyZWFkIGlzIE5PVCBhbGxvd2VkIHRvIHN0b3Agb3IKKyAgICBkZWxldGUgaXRzZWxmLgorCisgIC0gVGhlcmUgTk9UIGVub3VnaCBzYWZldHkgY2hlY2tzIGFzIGFyZSBwcm9iYWJseSBpbiB0aGUgb3RoZXIKKyAgICB0aHJlYWRzIGltcGxlbWVudGF0aW9ucy4KKworICAtIFRoZXJlIGlzIG5vIHBhcmVudC1jaGlsZCByZWxhdGlvbnNoaXAgYmV0d2VlbiB0aHJlYWRzLiBPbmx5IG9uZQorICAgIHRocmVhZCBtYXkgdGhyZWFkX2pvaW4sIHByZWZlcmFibHkgdGhlIG1hc3Rlci9wYXJlbnQgdGhyZWFkLgorCisoQykgMjAwMyBBcnVuIERoYXJhbmthciA8QURoYXJhbmthckBBVFRCSS5Db20+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2N0NjkwMDAuYyBiL2RyaXZlcnMvY3Q2OTAwMC5jCmluZGV4IDc5NjJmNzQuLjU2MzU1NjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3Q2OTAwMC5jCisrKyBiL2RyaXZlcnMvY3Q2OTAwMC5jCkBAIC04MzAsNiArODMwLDcgQEAKIAl1bnNpZ25lZCBpbnQgbSwgbiwgdmxkLCBwZCwgUEQsIGZyZWYsIHhyX2NiOwogCXVuc2lnbmVkIGludCBmdmNvbWluLCBmdmNvbWF4LCBwY2xja21pbiwgcGNsY2ttYXgsIHBjbGs7CiAJdW5zaWduZWQgaW50IHBmcmVxLCBmdmNvLCBuZXdfcGl4Y2xvY2s7CisJdW5zaWduZWQgaW50IEQsbmJhY2ssbWJhY2s7CiAKIAlmcmVmID0gVklERU9fRlJFRjsKIAlwZCA9IDE7CkBAIC04NTAsMTAgKzg1MSwxOSBAQAogCQlQRCsrOwogCX0KIAkvKiBmdmNvIGlzIGV4YWN0bHkgcGQgKiBwaXhlbGNsb2NrIGFuZCBoaWdoZXIgdGhhbiB0aGUgbmlubWFsIFZDTyBmcmVxdWVuY3kgKi8KLQl2bGQgPSAocGFyYW0tPnZsZF9zZXQgPiBwYXJhbS0+dmxkX25vdF9zZXQpID8KLQkgICAgcGFyYW0tPnZsZF9ub3Rfc2V0IDogcGFyYW0tPnZsZF9zZXQ7Ci0JLyogc3RhcnQgd2l0aCBsb3dlciBWTEQgKGhpZ2hlciBWTEQgaXMgTk9UIHlldCBpbXBsZW1lbnRlZCAqLwotCUZpbmRCZXN0UFFGaXR0aW5nTU4gKGZ2Y28gLyB2bGQsIGZyZWYsIHBhcmFtLT5tbl9taW4sIHBhcmFtLT5tbl9tYXgsICZtLCAmbik7CS8qIHJkcyA9IDEgKi8KKwkvKiBmaXJzdCB0cnkgKi8KKwl2bGQgPSBwYXJhbS0+dmxkX3NldDsKKwlEPUZpbmRCZXN0UFFGaXR0aW5nTU4gKGZ2Y28gLyB2bGQsIGZyZWYsIHBhcmFtLT5tbl9taW4sIHBhcmFtLT5tbl9tYXgsICZtLCAmbik7IC8qIHJkcyA9IDEgKi8KKwltYmFjaz1tOworCW5iYWNrPW47CisJLyogc2Vjb25kIHRyeSAqLworCXZsZCA9IHBhcmFtLT52bGRfbm90X3NldDsKKwlpZihEPEZpbmRCZXN0UFFGaXR0aW5nTU4gKGZ2Y28gLyB2bGQsIGZyZWYsIHBhcmFtLT5tbl9taW4sIHBhcmFtLT5tbl9tYXgsICZtLCAmbikpIHsgICAgLyogcmRzID0gMSAqLworCQkvKiBmaXJzdCB0cnkgd2FzIGJldHRlciAqLworCQltPW1iYWNrOworCQluPW5iYWNrOworCQl2bGQgPSBwYXJhbS0+dmxkX3NldDsKKwl9CiAJbSArPSBwYXJhbS0+bW5fZGlmZjsKIAluICs9IHBhcmFtLT5tbl9kaWZmOwogCVBSSU5URiAoIlZDTyAlZCwgcGQgJWQsIG0gJWQgbiAlZCB2bGQgJWQgXG4iLCBmdmNvLCBwZCwgbSwgbiwgdmxkKTsKZGlmZiAtLWdpdCBhL2V4YW1wbGVzL01ha2VmaWxlIGIvZXhhbXBsZXMvTWFrZWZpbGUKaW5kZXggMTYzYjQwNC4uYjY5MGZhMCAxMDA2NDQKLS0tIGEvZXhhbXBsZXMvTWFrZWZpbGUKKysrIGIvZXhhbXBsZXMvTWFrZWZpbGUKQEAgLTMzLDcgKzMzLDcgQEAKIEJJTiAgICArPSBzY2hlZC5iaW4KIGVuZGlmCiAKLWlmZXEgKCQoQ1BVKSxtaXBzKQoraWZlcSAoJChBUkNIKSxtaXBzKQogU1JFQyA9CiBCSU4gPQogZW5kaWYKQEAgLTQ0LDYgKzQ0LDEyIEBACiBCSU4gICAgKz0gdGltZXIuYmluCiBlbmRpZgogCisjIFRoZSBmb2xsb3dpbmcgZXhhbXBsZSBpcyA4MjYwIHNwZWNpZmljLi4uCitpZmVxICgkKENQVSksbXBjODI2MCkKK1NSRUMgICArPSBtZW1fdG9fbWVtX2lkbWEyaW50ci5zcmVjCitCSU4gICAgKz0gbWVtX3RvX21lbV9pZG1hMmludHIuYmluCitlbmRpZgorCiAjIFV0aWxpdHkgZm9yIHJlc2V0dGluZyBpODI1NTkgRUVQUk9NCiBpZmVxICgkKEJPQVJEKSxveGMpCiBTUkVDICAgKz0gZWVwcm8xMDBfZWVwcm9tLnNyZWMKZGlmZiAtLWdpdCBhL2V4YW1wbGVzL21lbV90b19tZW1faWRtYTJpbnRyLmMgYi9leGFtcGxlcy9tZW1fdG9fbWVtX2lkbWEyaW50ci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjkzYzZmNzcKLS0tIC9kZXYvbnVsbAorKysgYi9leGFtcGxlcy9tZW1fdG9fbWVtX2lkbWEyaW50ci5jCkBAIC0wLDAgKzEsMzkxIEBACisvKiBUaGUgZHBhbGxvYyBmdW5jdGlvbiB1c2VkIGFuZCBpbXBsZW1lbnRlZCBpbiB0aGlzIGZpbGUgd2FzIGRlcmlldmVkCisgKiBmcm9tIFBQQ0Jvb3QvVS1Cb290IGZpbGUgImNwdS9tcGM4MjYwL2NvbW1wcm9jLmMiLgorICovCisKKy8qIEF1dGhvcjogQXJ1biBEaGFyYW5rYXIgPEFEaGFyYW5rYXJAQVRUQkkuQ29tPgorICogVGhpcyBleGFtcGxlIGlzIG1lYW50IHRvIG9ubHkgZGVtb25zdHJhdGUgaG93IHRoZSBJRE1BIGNvdWxkIGJlIHVzZWQuCisgKi8KKworLyoKKyAqIFRoaXMgZmlsZSBpcyBiYXNlZCBvbiAiYXJjaC9wcGMvODI2MF9pby9jb21tcHJvYy5jIiAtIGhlcmUgaXMgaXQncworICogY29weXJpZ2h0IG5vdGljZToKKyAqCisgKiBHZW5lcmFsIFB1cnBvc2UgZnVuY3Rpb25zIGZvciB0aGUgZ2xvYmFsIG1hbmFnZW1lbnQgb2YgdGhlCisgKiA4MjYwIENvbW11bmljYXRpb24gUHJvY2Vzc29yIE1vZHVsZS4KKyAqIENvcHlyaWdodCAoYykgMTk5OSBEYW4gTWFsZWsgKGRtYWxla0BqbGMubmV0KQorICogQ29weXJpZ2h0IChjKSAyMDAwIE1vbnRhVmlzdGEgU29mdHdhcmUsIEluYyAoc291cmNlQG12aXN0YS5jb20pCisgKiAgMi4zLjk5IFVwZGF0ZXMKKyAqCisgKiBJbiBhZGRpdGlvbiB0byB0aGUgaW5kaXZpZHVhbCBjb250cm9sIG9mIHRoZSBjb21tdW5pY2F0aW9uCisgKiBjaGFubmVscywgdGhlcmUgYXJlIGEgZmV3IGZ1bmN0aW9ucyB0aGF0IGdsb2JhbGx5IGFmZmVjdCB0aGUKKyAqIGNvbW11bmljYXRpb24gcHJvY2Vzc29yLgorICoKKyAqIEJ1ZmZlciBkZXNjcmlwdG9ycyBtdXN0IGJlIGFsbG9jYXRlZCBmcm9tIHRoZSBkdWFsIHBvcnRlZCBtZW1vcnkKKyAqIHNwYWNlLiAgVGhlIGFsbG9jYXRvciBmb3IgdGhhdCBpcyBoZXJlLiAgV2hlbiB0aGUgY29tbXVuaWNhdGlvbgorICogcHJvY2VzcyBpcyByZXNldCwgd2UgcmVjbGFpbSB0aGUgbWVtb3J5IGF2YWlsYWJsZS4gIFRoZXJlIGlzCisgKiBjdXJyZW50bHkgbm8gZGVhbGxvY2F0b3IgZm9yIHRoaXMgbWVtb3J5LgorICovCisKKworCisjaW5jbHVkZSA8Y29tbW9uLmg+CisjaW5jbHVkZSA8c3lzY2FsbC5oPgorCisjZGVmaW5lIFNUQU5EQUxPTkUKKworI2lmbmRlZiBTVEFOREFMT05FCQkJLyogTGlua2VkIGludG8vUGFydCBvZiAgUFBDQm9vdCAqLworI2luY2x1ZGUgPGNvbW1hbmQuaD4KKyNpbmNsdWRlIDx3YXRjaGRvZy5oPgorI2Vsc2UJCQkJCS8qIFN0YW5kYWxvbmUgYXBwIG9mIFBQQ0Jvb3QgKi8KKyNpbmNsdWRlIDxzeXNjYWxsLmg+CisjZGVmaW5lIHByaW50Zgltb25fcHJpbnRmCisjZGVmaW5lIHRzdGMJbW9uX3RzdGMKKyNkZWZpbmUgZ2V0Ywltb25fZ2V0YworI2RlZmluZSBwdXRjCW1vbl9wdXRjCisjZGVmaW5lIHVkZWxheQltb25fdWRlbGF5CisjZGVmaW5lIG1hbGxvYwltb25fbWFsbG9jCisjZGVmaW5lIFdBVENIRE9HX1JFU0VUKCkgewkJCQkJCVwKKwkJCSoodXNob3J0ICopKENGR19JTU1SICsgMHgxMDAwRSkgPSAweDU1NmM7CVwKKwkJCSoodXNob3J0ICopKENGR19JTU1SICsgMHgxMDAwRSkgPSAweGFhMzk7CVwKKwkJfQorI2VuZGlmCS8qIFNUQU5EQUxPTkUgKi8KKworc3RhdGljIGludCBkZWJ1ZyA9IDE7CisKKyNkZWZpbmUgREVCVUcoZm10LCBhcmdzLi4uKQkgewkJCQkJXAorCWlmKGRlYnVnICE9IDApIHsJCQkJCQlcCisJCXByaW50ZigiWyVzICVkICVzXTogIixfX0ZJTEVfXyxfX0xJTkVfXyxfX0ZVTkNUSU9OX18pOwlcCisJCXByaW50ZihmbXQsICMjYXJncyk7CQkJCQlcCisJfQkJCQkJCQkJXAorfQorCisjZGVmaW5lIENQTV9DUl9JRE1BMV9TQkxPQ0sgICgweDE0KQorI2RlZmluZSBDUE1fQ1JfSURNQTJfU0JMT0NLICAoMHgxNSkKKyNkZWZpbmUgQ1BNX0NSX0lETUEzX1NCTE9DSyAgKDB4MTYpCisjZGVmaW5lIENQTV9DUl9JRE1BNF9TQkxPQ0sgICgweDE3KQorI2RlZmluZSBDUE1fQ1JfSURNQTFfUEFHRSAgICAoMHgwNykKKyNkZWZpbmUgQ1BNX0NSX0lETUEyX1BBR0UgICAgKDB4MDgpCisjZGVmaW5lIENQTV9DUl9JRE1BM19QQUdFICAgICgweDA5KQorI2RlZmluZSBDUE1fQ1JfSURNQTRfUEFHRSAgICAoMHgwYSkKKyNkZWZpbmUgUFJPRkZfSURNQTFfQkFTRSAgICAgKCh1aW50KTB4ODdmZSkKKyNkZWZpbmUgUFJPRkZfSURNQTJfQkFTRSAgICAgKCh1aW50KTB4ODhmZSkKKyNkZWZpbmUgUFJPRkZfSURNQTNfQkFTRSAgICAgKCh1aW50KTB4ODlmZSkKKyNkZWZpbmUgUFJPRkZfSURNQTRfQkFTRSAgICAgKCh1aW50KTB4OGFmZSkKKworI2RlZmluZSBDUE1fQ1JfSU5JVF9UUlggICAgICgodXNob3J0KTB4MDAwMCkKKyNkZWZpbmUgQ1BNX0NSX0ZMRyAgKCh1c2hvcnQpMHgwMDAxKQorCisjZGVmaW5lIG1rX2NyX2NtZChQRywgU0JDLCBNQ04sIE9QKSBcCisgICAgKChQRyA8PCAyNikgfCAoU0JDIDw8IDIxKSB8IChNQ04gPDwgNikgfCBPUCkKKworCisjcHJhZ21hIHBhY2soMSkKK3R5cGVkZWYgc3RydWN0IGliZGJpdHMgeworCXVuc2lnbmVkIGJfdmFsaWQ6MTsKKwl1bnNpZ25lZCBiX3Jlc3YxOjE7CisJdW5zaWduZWQgYl93cmFwOjE7CisJdW5zaWduZWQgYl9pbnRlcnJ1cHQ6MTsKKwl1bnNpZ25lZCBiX2xhc3Q6MTsKKwl1bnNpZ25lZCBiX3Jlc3YyOjE7CisJdW5zaWduZWQgYl9jbToxOworCXVuc2lnbmVkIGJfcmVzdjM6MjsKKwl1bnNpZ25lZCBiX3NkbjoxOworCXVuc2lnbmVkIGJfZGRuOjE7CisJdW5zaWduZWQgYl9kZ2JsOjE7CisJdW5zaWduZWQgYl9kYm86MjsKKwl1bnNpZ25lZCBiX3Jlc3Y0OjE7CisJdW5zaWduZWQgYl9kZHRiOjE7CisJdW5zaWduZWQgYl9yZXN2NToyOworCXVuc2lnbmVkIGJfc2dibDoxOworCXVuc2lnbmVkIGJfc2JvOjI7CisJdW5zaWduZWQgYl9yZXN2NjoxOworCXVuc2lnbmVkIGJfc2R0YjoxOworCXVuc2lnbmVkIGJfcmVzdjc6OTsKK30gaWJkYml0c190OworCisjcHJhZ21hIHBhY2soMSkKK3R5cGVkZWYgdW5pb24gaWJkYml0c3UgeworCWliZGJpdHNfdCBiOworCXVpbnQgaTsKK30gaWJkYml0c3VfdDsKKworI3ByYWdtYSBwYWNrKDEpCit0eXBlZGVmIHN0cnVjdCBpZG1hX2J1Zl9kZXNjIHsKKwlpYmRiaXRzdV90IGliZF9iaXRzOwkJLyogU3RhdHVzIGFuZCBDb250cm9sICovCisJdWludCBpYmRfZGF0bGVuOwkJLyogRGF0YSBsZW5ndGggaW4gYnVmZmVyICovCisJdWludCBpYmRfc2J1ZjsJCQkvKiBTb3VyY2UgYnVmZmVyIGFkZHIgaW4gaG9zdCBtZW0gKi8KKwl1aW50IGliZF9kYnVmOwkJCS8qIERlc3RpbmF0aW9uIGJ1ZmZlciBhZGRyIGluIGhvc3QgbWVtICovCit9IGliZF90OworCisKKyNwcmFnbWEgcGFjaygxKQordHlwZWRlZiBzdHJ1Y3QgZGNtYml0cyB7CisJdW5zaWduZWQgYl9mYjoxOworCXVuc2lnbmVkIGJfbHA6MTsKKwl1bnNpZ25lZCBiX3Jlc3YxOjM7CisJdW5zaWduZWQgYl90YzI6MTsKKwl1bnNpZ25lZCBiX3Jlc3YyOjE7CisJdW5zaWduZWQgYl93cmFwOjM7CisJdW5zaWduZWQgYl9zaW5jOjE7CisJdW5zaWduZWQgYl9kaW5jOjE7CisJdW5zaWduZWQgYl9lcm06MTsKKwl1bnNpZ25lZCBiX2R0OjE7CisJdW5zaWduZWQgYl9zZDoyOworfSBkY21iaXRzX3Q7CisKKyNwcmFnbWEgcGFjaygxKQordHlwZWRlZiB1bmlvbiBkY21iaXRzdSB7CisJZGNtYml0c190IGI7CisJdXNob3J0IGk7Cit9IGRjbWJpdHN1X3Q7CisKKyNwcmFnbWEgcGFjaygxKQordHlwZWRlZiBzdHJ1Y3QgcHJhbV9pZG1hIHsKKwl1c2hvcnQgcGlfaWJhc2U7CisJZGNtYml0c3VfdCBwaV9kY21iaXRzOworCXVzaG9ydCBwaV9pYmRwdHI7CisJdXNob3J0IHBpX2RwcmJ1ZjsKKwl1c2hvcnQgcGlfYnVmaW52OwkJLyogaW50ZXJuYWwgdG8gQ1BNICovCisJdXNob3J0IHBpX3NzbWF4OworCXVzaG9ydCBwaV9kcHJpbnB0cjsJCS8qIGludGVybmFsIHRvIENQTSAqLworCXVzaG9ydCBwaV9zdHM7CisJdXNob3J0IHBpX2Rwcm91dHB0cjsJCS8qIGludGVybmFsIHRvIENQTSAqLworCXVzaG9ydCBwaV9zZW9iOworCXVzaG9ydCBwaV9kZW9iOworCXVzaG9ydCBwaV9kdHM7CisJdXNob3J0IHBpX3JldGFkZDsKKwl1c2hvcnQgcGlfcmVzdjE7CQkvKiBpbnRlcm5hbCB0byBDUE0gKi8KKwl1aW50IHBpX2JkY250OworCXVpbnQgcGlfc3B0cjsKKwl1aW50IHBpX2RwdHI7CisJdWludCBwaV9pc3RhdGU7Cit9IHByYW1faWRtYV90OworCisKK3ZvbGF0aWxlIGltbWFwX3QgKmltbWFwID0gKGltbWFwX3QgKikgQ0ZHX0lNTVI7Cit2b2xhdGlsZSBpYmRfdCAqYmRmOwordm9sYXRpbGUgcHJhbV9pZG1hX3QgKnBpcHRyOworCit2b2xhdGlsZSBpbnQgZG1hZG9uZTsKK3ZvbGF0aWxlIGludCAqZG1hZG9uZXAgPSAmZG1hZG9uZTsKK3ZvaWQgZG1hZG9uZV9oYW5kbGVyICh2b2lkICopOworCitpbnQgaWRtYV9pbml0ICh2b2lkKTsKK3ZvaWQgaWRtYV9zdGFydCAoaW50LCBpbnQsIGludCwgdWludCwgdWludCwgaW50KTsKK3VpbnQgZHBhbGxvYyAodWludCwgdWludCk7CisKKwordWludCBkcGluaXRfZG9uZSA9IDA7CisKKworI2lmZGVmIFNUQU5EQUxPTkUKK2ludCBjdHJsYyAodm9pZCkKK3sKKwlpZiAobW9uX3RzdGMoKSkgeworCQlzd2l0Y2ggKG1vbl9nZXRjICgpKSB7CisJCWNhc2UgMHgwMzoJCS8qIF5DIC0gQ29udHJvbCBDICovCisJCQlyZXR1cm4gMTsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJfQorCXJldHVybiAwOworfQordm9pZCAqIG1lbXNldCh2b2lkICogcyxpbnQgYyxzaXplX3QgY291bnQpCit7CisJY2hhciAqeHMgPSAoY2hhciAqKSBzOworCXdoaWxlIChjb3VudC0tKQorCQkqeHMrKyA9IGM7CisJcmV0dXJuIHM7Cit9CitpbnQgbWVtY21wKGNvbnN0IHZvaWQgKiBjcyxjb25zdCB2b2lkICogY3Qsc2l6ZV90IGNvdW50KQoreworCWNvbnN0IHVuc2lnbmVkIGNoYXIgKnN1MSwgKnN1MjsKKwlpbnQgcmVzID0gMDsKKwlmb3IoIHN1MSA9IGNzLCBzdTIgPSBjdDsgMCA8IGNvdW50OyArK3N1MSwgKytzdTIsIGNvdW50LS0pCisJCWlmICgocmVzID0gKnN1MSAtICpzdTIpICE9IDApCisJCQlicmVhazsKKwlyZXR1cm4gcmVzOworfQorI2VuZGlmCS8qIFNUQU5EQUxPTkUgKi8KKworI2lmZGVmIFNUQU5EQUxPTkUKK2ludCBtZW1fdG9fbWVtX2lkbWEyaW50ciAoYmRfdCAqIGJkLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQorI2Vsc2UKK2ludCBkb19pZG1hIChiZF90ICogYmQsIGludCBhcmdjLCBjaGFyICphcmd2W10pCisjZW5kaWYJLyogU1RBTkRBTE9ORSAqLworeworCWludCBpOworCisJZHBpbml0X2RvbmUgPSAwOworCisJaWRtYV9pbml0ICgpOworCisJREVCVUcgKCJJbnN0YWxsaW5nIGRtYSBoYW5kbGVyXG4iKTsKKwltb25faW5zdGFsbF9oZGxyICg3LCBkbWFkb25lX2hhbmRsZXIsICh2b2lkICopIGJkZik7CisKKwltZW1zZXQgKCh2b2lkICopIDB4MTAwMDAwLCAnYScsIDUxMik7CisJbWVtc2V0ICgodm9pZCAqKSAweDIwMDAwMCwgJ2InLCA1MTIpOworCisJZm9yIChpID0gMDsgaSA8IDMyOyBpKyspIHsKKwkJcHJpbnRmICgiU3RhcnRpbiBJRE1BLCBpdGVyYXRpb249JWRcbiIsIGkpOworCQlpZG1hX3N0YXJ0ICgxLCAxLCA1MTIsIDB4MTAwMDAwLCAweDIwMDAwMCwgMyk7CisJfQorCisJREVCVUcgKCJVbmluc3RhbGxpbmcgZG1hIGhhbmRsZXJcbiIpOworCW1vbl9mcmVlX2hkbHIgKDcpOworCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQKK2lkbWFfc3RhcnQgKGludCBzaW5jLCBpbnQgZGluYywgaW50IHN6LCB1aW50IHNidWYsIHVpbnQgZGJ1ZiwgaW50IHR0eXBlKQoreworCS8qIHR0eXBlIGlzIGZvciBNLU0sIE0tUCwgUC1NIG9yIFAtUDogbm90IHVzZWQgZm9yIG5vdyAqLworCisJcGlwdHItPnBpX2lzdGF0ZSA9IDA7CS8qIG1hbnVhbCBzYXlzOiBjbGVhciBpdCBiZWZvcmUgZXZlcnkgU1RBUlRfSURNQSAqLworCXBpcHRyLT5waV9kY21iaXRzLmIuYl9yZXN2MSA9IDA7CisKKwlpZiAoc2luYyA9PSAxKQorCQlwaXB0ci0+cGlfZGNtYml0cy5iLmJfc2luYyA9IDE7CisJZWxzZQorCQlwaXB0ci0+cGlfZGNtYml0cy5iLmJfc2luYyA9IDA7CisKKwlpZiAoZGluYyA9PSAxKQorCQlwaXB0ci0+cGlfZGNtYml0cy5iLmJfZGluYyA9IDE7CisJZWxzZQorCQlwaXB0ci0+cGlfZGNtYml0cy5iLmJfZGluYyA9IDA7CisKKwlwaXB0ci0+cGlfZGNtYml0cy5iLmJfZXJtID0gMDsKKwlwaXB0ci0+cGlfZGNtYml0cy5iLmJfc2QgPSAweDAwOwkvKiBNLU0gKi8KKworCWJkZi0+aWJkX3NidWYgPSBzYnVmOworCWJkZi0+aWJkX2RidWYgPSBkYnVmOworCWJkZi0+aWJkX2JpdHMuYi5iX2NtID0gMDsKKwliZGYtPmliZF9iaXRzLmIuYl9pbnRlcnJ1cHQgPSAxOworCWJkZi0+aWJkX2JpdHMuYi5iX3dyYXAgPSAxOworCWJkZi0+aWJkX2JpdHMuYi5iX2xhc3QgPSAxOworCWJkZi0+aWJkX2JpdHMuYi5iX3NkbiA9IDA7CisJYmRmLT5pYmRfYml0cy5iLmJfZGRuID0gMDsKKwliZGYtPmliZF9iaXRzLmIuYl9kZ2JsID0gMDsKKwliZGYtPmliZF9iaXRzLmIuYl9kZHRiID0gMDsKKwliZGYtPmliZF9iaXRzLmIuYl9zZ2JsID0gMDsKKwliZGYtPmliZF9iaXRzLmIuYl9zZHRiID0gMDsKKwliZGYtPmliZF9iaXRzLmIuYl9kYm8gPSAxOworCWJkZi0+aWJkX2JpdHMuYi5iX3NibyA9IDE7CisJYmRmLT5pYmRfYml0cy5iLmJfdmFsaWQgPSAxOworCWJkZi0+aWJkX2RhdGxlbiA9IDUxMjsKKworCSpkbWFkb25lcCA9IDA7CisKKwlpbW1hcC0+aW1fc2RtYS5zZG1hX2lkbXIyID0gKHVjaGFyKSAweGY7CisKKwlpbW1hcC0+aW1fY3BtLmNwX2NwY3IgPSBta19jcl9jbWQgKENQTV9DUl9JRE1BMl9QQUdFLAorCQkJCQkgICBDUE1fQ1JfSURNQTJfU0JMT0NLLCAweDAsCisJCQkJCSAgIDB4OSkgfCAweDAwMDEwMDAwOworCisJd2hpbGUgKCpkbWFkb25lcCAhPSAxKSB7CisJCWlmIChjdHJsYyAoKSkgeworCQkJREVCVUcgKCJcbkludGVycnVwdGVkIHdhaXRpbmcgZm9yIERNQSBpbnRlcnJ1cHQuXG4iKTsKKwkJCWdvdG8gZG9uZTsKKwkJfQorCQlwcmludGYgKCJXYWl0aW5nIGZvciBETUEgaW50ZXJydXB0IChkbWFkb25lPSVkIGJfdmFsaWQgPSAlZCkuLi5cbiIsCisJCQlkbWFkb25lLCBiZGYtPmliZF9iaXRzLmIuYl92YWxpZCk7CisJCXVkZWxheSAoMTAwMDAwMCk7CisJfQorCXByaW50ZiAoIkRNQSBjb21wbGV0ZSBub3RpZmljYXRpb24gcmVjZWl2ZWQhXG4iKTsKKworICBkb25lOgorCURFQlVHICgibWVtY21wKDB4JTA4eCwgMHglMDh4LCA1MTIpID0gJWRcbiIsCisJCXNidWYsIGRidWYsIG1lbWNtcCAoKHZvaWQgKikgc2J1ZiwgKHZvaWQgKikgZGJ1ZiwgNTEyKSk7CisKKwlyZXR1cm47Cit9CisKKyNkZWZpbmUgTUFYX0lOVF9CVUZTWgk2NAorI2RlZmluZSBEQ01fV1JBUAkgMAkvKiBNVVNUIGJlIGNvbnNpc3RhbnQgd2l0aCBNQVhfSU5UX0JVRlNaICovCisKK2ludCBpZG1hX2luaXQgKHZvaWQpCit7CisJdWludCBtZW1hZGRyOworCisJaW1tYXAtPmltX2NwbS5jcF9yY2NyICY9IH4weDAwRjNGRkZGOworCWltbWFwLT5pbV9jcG0uY3BfcmNjciB8PSAweDAwQTAwQTAwOworCisJbWVtYWRkciA9IGRwYWxsb2MgKHNpemVvZiAocHJhbV9pZG1hX3QpLCA2NCk7CisKKwkqKHZvbGF0aWxlIHVzaG9ydCAqKSAmaW1tYXAtPmltX2RwcmFtYmFzZVtQUk9GRl9JRE1BMl9CQVNFXSA9IG1lbWFkZHI7CisJcGlwdHIgPSAodm9sYXRpbGUgcHJhbV9pZG1hX3QgKikgKCh1aW50KSAoaW1tYXApICsgbWVtYWRkcik7CisKKwlwaXB0ci0+cGlfcmVzdjEgPSAwOwkJLyogbWFudWFsIHNheXM6IGNsZWFyIGl0ICovCisJcGlwdHItPnBpX2RjbWJpdHMuYi5iX2ZiID0gMDsKKwlwaXB0ci0+cGlfZGNtYml0cy5iLmJfbHAgPSAxOworCXBpcHRyLT5waV9kY21iaXRzLmIuYl9lcm0gPSAwOworCXBpcHRyLT5waV9kY21iaXRzLmIuYl9kdCA9IDA7CisKKwltZW1hZGRyID0gKHVpbnQpIGRwYWxsb2MgKHNpemVvZiAoaWJkX3QpLCA2NCk7CisJcGlwdHItPnBpX2liYXNlID0gcGlwdHItPnBpX2liZHB0ciA9ICh2b2xhdGlsZSBzaG9ydCkgbWVtYWRkcjsKKwliZGYgPSAodm9sYXRpbGUgaWJkX3QgKikgKCh1aW50KSAoaW1tYXApICsgbWVtYWRkcik7CisJYmRmLT5pYmRfYml0cy5iLmJfdmFsaWQgPSAwOworCisJbWVtYWRkciA9ICh1aW50KSBkcGFsbG9jICg2NCwgNjQpOworCXBpcHRyLT5waV9kcHJidWYgPSAodm9sYXRpbGUgdXNob3J0KSBtZW1hZGRyOworCXBpcHRyLT5waV9kY21iaXRzLmIuYl93cmFwID0gNDsKKwlwaXB0ci0+cGlfc3NtYXggPSAzMjsKKworCXBpcHRyLT5waV9zdHMgPSBwaXB0ci0+cGlfc3NtYXg7CisJcGlwdHItPnBpX2R0cyA9IHBpcHRyLT5waV9zc21heDsKKworCXJldHVybiAxOworfQorCit2b2lkIGRtYWRvbmVfaGFuZGxlciAodm9pZCAqYXJnKQoreworCWltbWFwLT5pbV9zZG1hLnNkbWFfaWRtcjIgPSAodWNoYXIpIDB4MDsKKworCSpkbWFkb25lcCA9IDE7CisKKwlyZXR1cm47Cit9CisKKworc3RhdGljIHVpbnQgZHBiYXNlID0gMDsKKwordWludCBkcGFsbG9jICh1aW50IHNpemUsIHVpbnQgYWxpZ24pCit7CisJREVDTEFSRV9HTE9CQUxfREFUQV9QVFI7CisKKwl2b2xhdGlsZSBpbW1hcF90ICppbW1yID0gKGltbWFwX3QgKikgQ0ZHX0lNTVI7CisJdWludCByZXRsb2M7CisJdWludCBhbGlnbl9tYXNrLCBvZmY7CisJdWludCBzYXZlYmFzZTsKKworCS8qIFBvaW50ZXIgdG8gaW5pdGlhbCBnbG9iYWwgZGF0YSBhcmVhICovCisKKwlpZiAoZHBpbml0X2RvbmUgPT0gMCkgeworCQlkcGJhc2UgPSBnZC0+ZHBfYWxsb2NfYmFzZTsKKwkJZHBpbml0X2RvbmUgPSAxOworCX0KKworCWFsaWduX21hc2sgPSBhbGlnbiAtIDE7CisJc2F2ZWJhc2UgPSBkcGJhc2U7CisKKwlpZiAoKG9mZiA9IChkcGJhc2UgJiBhbGlnbl9tYXNrKSkgIT0gMCkKKwkJZHBiYXNlICs9IChhbGlnbiAtIG9mZik7CisKKwlpZiAoKG9mZiA9IHNpemUgJiBhbGlnbl9tYXNrKSAhPSAwKQorCQlzaXplICs9IGFsaWduIC0gb2ZmOworCisJaWYgKChkcGJhc2UgKyBzaXplKSA+PSBnZC0+ZHBfYWxsb2NfdG9wKSB7CisJCWRwYmFzZSA9IHNhdmViYXNlOworCQlwcmludGYgKCJkcGFsbG9jOiByYW4gb3V0IG9mIGR1YWwgcG9ydCByYW0hIik7CisJCXJldHVybiAwOworCX0KKworCXJldGxvYyA9IGRwYmFzZTsKKwlkcGJhc2UgKz0gc2l6ZTsKKworCW1lbXNldCAoKHZvaWQgKikgJmltbXItPmltX2RwcmFtYmFzZVtyZXRsb2NdLCAwLCBzaXplKTsKKworCXJldHVybiAocmV0bG9jKTsKK30KZGlmZiAtLWdpdCBhL2V4YW1wbGVzL3BwY19sb25nam1wLlMgYi9leGFtcGxlcy9wcGNfbG9uZ2ptcC5TCmluZGV4IGFkODI4NWEuLjVjYTZmNmYgMTAwNjQ0Ci0tLSBhL2V4YW1wbGVzL3BwY19sb25nam1wLlMKKysrIGIvZXhhbXBsZXMvcHBjX2xvbmdqbXAuUwpAQCAtMzAsOSArMzAsOSBAQAogI2RlZmluZSBGUCh4Li4uKSB4CiAjZGVmaW5lIEZQKHguLi4pIHgKIAotLmdsb2JsICAgICAgbG9uZ2ptcDsKKy5nbG9ibCAgICAgIHBwY19sb25nam1wOwogCi1sb25nam1wOgorcHBjX2xvbmdqbXA6CiAJbHd6IHIxLChKQl9HUFIxKjQpKHIzKQogCWx3eiByMiwoSkJfR1BSMio0KShyMykKIAlsd3ogcjAsKEpCX0xSKjQpKHIzKQpkaWZmIC0tZ2l0IGEvZXhhbXBsZXMvcHBjX3NldGptcC5TIGIvZXhhbXBsZXMvcHBjX3NldGptcC5TCmluZGV4IGI3MTgxMTMuLjQyMWFiZmQgMTAwNjQ0Ci0tLSBhL2V4YW1wbGVzL3BwY19zZXRqbXAuUworKysgYi9leGFtcGxlcy9wcGNfc2V0am1wLlMKQEAgLTM0LDggKzM0LDggQEAKIAltciAgcjEsIHIzCiAJYmxyCiAKLS5nbG9ibCAgICAgIF9zZXRqbXA7Ci1fc2V0am1wOgorLmdsb2JsICAgICAgcHBjX3NldGptcDsKK3BwY19zZXRqbXA6CiAJc3R3ICByMSwoSkJfR1BSMSo0KSgzKQogCW1mbHIgcjAKIAlzdHcgIHIyLChKQl9HUFIyKjQpKDMpCmRpZmYgLS1naXQgYS9leGFtcGxlcy9zY2hlZC5jIGIvZXhhbXBsZXMvc2NoZWQuYwppbmRleCA0ZjZmOThlLi5jZWI1YzFmIDEwMDY0NAotLS0gYS9leGFtcGxlcy9zY2hlZC5jCisrKyBiL2V4YW1wbGVzL3NjaGVkLmMKQEAgLTMsMTIgKzMsMTIgQEAKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzCiAgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZgogICogdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKiAKKyAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiAgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICogCisgKgogICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLApAQCAtMTcsNyArMTcsNiBAQAogCiAjaW5jbHVkZSA8Y29tbW9uLmg+CiAjaW5jbHVkZSA8c3lzY2FsbC5oPgotI2luY2x1ZGUgPHNldGptcC5oPgogCiAvKgogICogQXV0aG9yOiBBcnVuIERoYXJhbmthciA8QURoYXJhbmthckBBVFRCSS5Db20+CkBAIC01NCw2ICs1MywxMyBAQAogI2RlZmluZSBSQ19GQUlMVVJFCSgtMSkKICNkZWZpbmUJUkNfU1VDQ0VTUwkoMCkKIAordHlwZWRlZgl2dV9jaGFyICpqbXBfY3R4OwordW5zaWduZWQgbG9uZyBzZXRjdHhzcCAodnVfY2hhciAqc3ApOworaW50IHBwY19zZXRqbXAoam1wX2N0eCBlbnYpOwordm9pZCBwcGNfbG9uZ2ptcChqbXBfY3R4IGVudiwgaW50IHZhbCk7CisjZGVmaW5lIHNldGptcAlwcGNfc2V0am1wCisjZGVmaW5lIGxvbmdqbXAJcHBjX2xvbmdqbXAKKwogc3RydWN0IGx0aHJlYWQgewogCWludCBzdGF0ZTsKIAlpbnQgcmV0dmFsOwpAQCAtNjgsMTMgKzc0LDEzIEBACiAKIHN0YXRpYyB1Y2hhciBkYmcgPSAwOwogCi0jZGVmaW5lIERFQlVHKGZtdCwgYXJncy4uLikJIHsJCQkJCQkJCQkJCQlcCi0JCWlmKGRiZyAhPSAwKSB7CQkJCQkJCQkJCQkJCQlcCi0JCQltb25fcHJpbnRmKCJbJXMgJWQgJXNdOiAiLCBfX0ZJTEVfXywgX19MSU5FX18sIF9fRlVOQ1RJT05fXyk7CVwKLQkJCW1vbl9wcmludGYoZm10LCAjI2FyZ3MpOwkJCQkJCQkJCQlcCi0JCQltb25fcHJpbnRmKCJcbiIpOwkJCQkJCQkJCQkJCVwKLQkJfQkJCQkJCQkJCQkJCQkJCQkJXAotCX0KKyNkZWZpbmUgUERFQlVHKGZtdCwgYXJncy4uLikJIHsJCQkJCVwKKwlpZihkYmcgIT0gMCkgewkJCQkJCQlcCisJCW1vbl9wcmludGYoIlslcyAlZCAlc106ICIsX19GSUxFX18sX19MSU5FX18sX19GVU5DVElPTl9fKTtcCisJCW1vbl9wcmludGYoZm10LCAjI2FyZ3MpOwkJCQlcCisJCW1vbl9wcmludGYoIlxuIik7CQkJCQlcCisJfQkJCQkJCQkJXAorfQogCiBzdGF0aWMgaW50IHRlc3R0aHJlYWQgKHZvaWQgKik7CiBzdGF0aWMgdm9pZCBzY2hlZF9pbml0ICh2b2lkKTsKQEAgLTgzLDE0ICs4OSwxNSBAQAogc3RhdGljIHZvaWQgdGhyZWFkX3lpZWxkICh2b2lkKTsKIHN0YXRpYyBpbnQgdGhyZWFkX2RlbGV0ZSAoaW50IGlkKTsKIHN0YXRpYyBpbnQgdGhyZWFkX2pvaW4gKGludCAqcmV0KTsKLSNpZiAwIC8qIG5vdCB1c2VkIHlldCAqLworCisjaWYgMAkJCQkJCQkvKiBub3QgdXNlZCB5ZXQgKi8KIHN0YXRpYyBpbnQgdGhyZWFkX3N0b3AgKGludCBpZCk7Ci0jZW5kaWYgLyogbm90IHVzZWQgeWV0ICovCisjZW5kaWYJCQkJCQkJLyogbm90IHVzZWQgeWV0ICovCiAKIC8qIEFuIGV4YW1wbGUgb2Ygc2NoZWR1bGFyIHRlc3QgKi8KIAogI2RlZmluZSBOVU1USFJFQURTIDcKLWludCBzY2hlZCAoYmRfdCAqYmQsIGludCBhYywgY2hhciAqYXZbXSkKK2ludCBzY2hlZCAoYmRfdCAqIGJkLCBpbnQgYWMsIGNoYXIgKmF2W10pCiB7CiAJaW50IGksIGo7CiAJaW50IHRpZFtOVU1USFJFQURTXTsKQEAgLTEwMiwxMSArMTA5LDEwIEBACiAJCW5hbWVzW2ldID0gaTsKIAkJaiA9IHRocmVhZF9jcmVhdGUgKHRlc3R0aHJlYWQsICh2b2lkICopICZuYW1lc1tpXSk7CiAJCWlmIChqID09IFJDX0ZBSUxVUkUpCi0JCQltb25fcHJpbnRmICgic2NoZWR0ZXN0OiBGYWlsZWQgdG8gY3JlYXRlIHRocmVhZCAlZFxuIiwKLQkJCWkpOworCQkJbW9uX3ByaW50ZiAoInNjaGVkdGVzdDogRmFpbGVkIHRvIGNyZWF0ZSB0aHJlYWQgJWRcbiIsIGkpOwogCQlpZiAoaiA+IDApIHsKIAkJCW1vbl9wcmludGYgKCJzY2hlZHRlc3Q6IENyZWF0ZWQgdGhyZWFkIHdpdGggaWQgJWQsIG5hbWUgJWRcbiIsCi0JCQkJaiwgaSk7CisJCQkJCQlqLCBpKTsKIAkJCXRpZFtpXSA9IGo7CiAJCX0KIAl9CkBAIC0xMjUsOCArMTMxLDcgQEAKIAkJaWYgKG1vbl90c3RjICgpICYmIG1vbl9nZXRjICgpID09IDB4MykgewogCQkJbW9uX3ByaW50ZiAoInNjaGVkdGVzdDogQWJvcnRpbmcgdGhyZWFkcy4uLlxuIik7CiAJCQlmb3IgKGkgPSAwOyBpIDwgTlVNVEhSRUFEUzsgaSsrKSB7Ci0JCQkJbW9uX3ByaW50ZiAoInNjaGVkdGVzdDogRGVsZXRpbmcgdGhyZWFkICVkXG4iLAotCQkJCQl0aWRbaV0pOworCQkJCW1vbl9wcmludGYgKCJzY2hlZHRlc3Q6IERlbGV0aW5nIHRocmVhZCAlZFxuIiwgdGlkW2ldKTsKIAkJCQl0aHJlYWRfZGVsZXRlICh0aWRbaV0pOwogCQkJfQogCQkJcmV0dXJuIFJDX1NVQ0NFU1M7CkBAIC0xMzUsMTEgKzE0MCwxMCBAQAogCQlpID0gdGhyZWFkX2pvaW4gKCZqKTsKIAkJaWYgKGkgPT0gUkNfRkFJTFVSRSkgewogCQkJbW9uX3ByaW50ZiAoInNjaGVkdGVzdDogTm8gdGhyZWFkcyBwZW5kaW5nLCAiCi0JCQkJImV4aXRpbmcgc2NoZWR1bGFyIHRlc3RcbiIpOworCQkJCQkJImV4aXRpbmcgc2NoZWR1bGFyIHRlc3RcbiIpOwogCQkJcmV0dXJuIFJDX1NVQ0NFU1M7CiAJCX0KLQkJbW9uX3ByaW50ZiAoInNjaGVkdGVzdDogdGhyZWFkIGlzICVkIHJldHVybmVkICVkXG4iLCBpLAotCQkJCQlqKTsKKwkJbW9uX3ByaW50ZiAoInNjaGVkdGVzdDogdGhyZWFkIGlzICVkIHJldHVybmVkICVkXG4iLCBpLCBqKTsKIAkJdGhyZWFkX3lpZWxkICgpOwogCX0KIApAQCAtMTUxLDE0ICsxNTUsMTQgQEAKIAlpbnQgaTsKIAogCW1vbl9wcmludGYgKCJ0ZXN0dGhyZWFkOiBCZWdpbiBleGVjdXRpbmcgdGhyZWFkLCBteW5hbWUgJWQsICZpPTB4JTA4eFxuIiwKLQkJICooaW50ICopIG5hbWUsICZpKTsKKwkJCSAqKGludCAqKSBuYW1lLCAmaSk7CiAKIAltb25fcHJpbnRmICgiVGhyZWFkICUwMmQsIGk9JWRcbiIsICooaW50ICopIG5hbWUpOwogCiAJZm9yIChpID0gMDsgaSA8IDB4ZmZmZiAqICgqKGludCAqKSBuYW1lICsgMSk7IGkrKykgewogCQlpZiAobW9uX3RzdGMgKCkgJiYgbW9uX2dldGMgKCkgPT0gMHgzKSB7CiAJCQltb25fcHJpbnRmICgidGVzdHRocmVhZDogbXluYW1lICVkIHRlcm1pbmF0aW5nLlxuIiwKLQkJCQkqKGludCAqKSBuYW1lKTsKKwkJCQkJCSooaW50ICopIG5hbWUpOwogCQkJcmV0dXJuICooaW50ICopIG5hbWUgKyAxOwogCQl9CiAKQEAgLTE2Nyw3ICsxNzEsNyBAQAogCX0KIAogCW1vbl9wcmludGYgKCJ0ZXN0dGhyZWFkOiByZXR1cm5pbmcgJWQsIGk9MHgleFxuIiwKLQkJKihpbnQgKikgbmFtZSArIDEsIGkpOworCQkJCSooaW50ICopIG5hbWUgKyAxLCBpKTsKIAogCXJldHVybiAqKGludCAqKSBuYW1lICsgMTsKIH0KQEAgLTE4Miw4ICsxODYsOCBAQAogCiAJY3VycmVudF90aWQgPSBNQVNURVJfVEhSRUFEOwogCWx0aHJlYWRzW2N1cnJlbnRfdGlkXS5zdGF0ZSA9IFNUQVRFX1JVTk5BQkxFOwotCURFQlVHICgic2NoZWRfaW5pdDogbWFzdGVyIGNvbnRleHQgPSAweCUwOHgiLAotCQlsdGhyZWFkc1tjdXJyZW50X3RpZF0uY29udGV4dCk7CisJUERFQlVHICgic2NoZWRfaW5pdDogbWFzdGVyIGNvbnRleHQgPSAweCUwOHgiLAorCQkgICBsdGhyZWFkc1tjdXJyZW50X3RpZF0uY29udGV4dCk7CiAJcmV0dXJuOwogfQogCkBAIC0xOTEsMTkgKzE5NSwxOSBAQAogewogCXN0YXRpYyBpbnQgaTsKIAotCURFQlVHICgidGhyZWFkX3lpZWxkOiBjdXJyZW50IHRpZD0lZCIsIGN1cnJlbnRfdGlkKTsKKwlQREVCVUcgKCJ0aHJlYWRfeWllbGQ6IGN1cnJlbnQgdGlkPSVkIiwgY3VycmVudF90aWQpOwogCiAjZGVmaW5lIFNXSVRDSChuZXcpIAkJCQkJCQlcCiAJaWYobHRocmVhZHNbbmV3XS5zdGF0ZSA9PSBTVEFURV9SVU5OQUJMRSkgewkJCVwKLQkJREVCVUcoInRocmVhZF95aWVsZDogJWQgbWF0Y2gsIGN0eD0weCUwOHgiLAkJXAorCQlQREVCVUcoInRocmVhZF95aWVsZDogJWQgbWF0Y2gsIGN0eD0weCUwOHgiLAkJXAogCQkJbmV3LCBsdGhyZWFkc1tjdXJyZW50X3RpZF0uY29udGV4dCk7IAkJXAogCQlpZihzZXRqbXAobHRocmVhZHNbY3VycmVudF90aWRdLmNvbnRleHQpID09IDApIHsJXAogCQkJY3VycmVudF90aWQgPSBuZXc7CQkJCVwKLQkJCURFQlVHKCJ0aHJlYWRfeWllbGQ6IHRpZCAlZCByZXR1cm5zIDAiLAkJXAorCQkJUERFQlVHKCJ0aHJlYWRfeWllbGQ6IHRpZCAlZCByZXR1cm5zIDAiLAlcCiAJCQkJbmV3KTsgCQkJCQlcCiAJCQlsb25nam1wKGx0aHJlYWRzW25ld10uY29udGV4dCwgMSk7CQlcCiAJCX0gZWxzZSB7CQkJCQkJXAotCQkJREVCVUcoInRocmVhZF95aWVsZDogdGlkICVkIHJldHVybnMgMSIsCQlcCisJCQlQREVCVUcoInRocmVhZF95aWVsZDogdGlkICVkIHJldHVybnMgMSIsCVwKIAkJCQluZXcpOyAJCQkJCVwKIAkJCXJldHVybjsJCQkJCQlcCiAJCX0JCQkJCQkJXApAQCAtMjE5LDcgKzIyMyw3IEBACiAJCX0KIAl9CiAKLQlERUJVRyAoInRocmVhZF95aWVsZDogcmV0dXJuaW5nIGZyb20gdGhyZWFkX3lpZWxkIik7CisJUERFQlVHICgidGhyZWFkX3lpZWxkOiByZXR1cm5pbmcgZnJvbSB0aHJlYWRfeWllbGQiKTsKIAlyZXR1cm47CiB9CiAKQEAgLTIzMiwxMiArMjM2LDEyIEBACiAJCQlsdGhyZWFkc1tpXS5zdGF0ZSA9IFNUQVRFX1NUT1BQRUQ7CiAJCQlsdGhyZWFkc1tpXS5mdW5jID0gZnVuYzsKIAkJCWx0aHJlYWRzW2ldLmFyZyA9IGFyZzsKLQkJCURFQlVHICgidGhyZWFkX2NyZWF0ZTogcmV0dXJucyBuZXcgdGlkICVkIiwgaSk7CisJCQlQREVCVUcgKCJ0aHJlYWRfY3JlYXRlOiByZXR1cm5zIG5ldyB0aWQgJWQiLCBpKTsKIAkJCXJldHVybiBpOwogCQl9CiAJfQogCi0JREVCVUcgKCJ0aHJlYWRfY3JlYXRlOiByZXR1cm5zIGZhaWx1cmUiKTsKKwlQREVCVUcgKCJ0aHJlYWRfY3JlYXRlOiByZXR1cm5zIGZhaWx1cmUiKTsKIAlyZXR1cm4gUkNfRkFJTFVSRTsKIH0KIApAQCAtMjU1LDEzICsyNTksMTMgQEAKIAogc3RhdGljIHZvaWQgdGhyZWFkX2xhdW5jaGVyICh2b2lkKQogewotCURFQlVHICgidGhyZWFkX2xhdW5jaGVyOiBpbnZva2luZyBmdW5jPTB4JTA4eCIsCisJUERFQlVHICgidGhyZWFkX2xhdW5jaGVyOiBpbnZva2luZyBmdW5jPTB4JTA4eCIsCiAJCSAgIGx0aHJlYWRzW2N1cnJlbnRfdGlkXS5mdW5jKTsKIAogCWx0aHJlYWRzW2N1cnJlbnRfdGlkXS5yZXR2YWwgPQotCQkJbHRocmVhZHNbY3VycmVudF90aWRdLmZ1bmMobHRocmVhZHNbY3VycmVudF90aWRdLmFyZyk7CisJCQlsdGhyZWFkc1tjdXJyZW50X3RpZF0uZnVuYyAobHRocmVhZHNbY3VycmVudF90aWRdLmFyZyk7CiAKLQlERUJVRyAoInRocmVhZF9sYXVuY2hlcjogdGlkICVkIHRlcm1pbmF0ZWQiLCBjdXJyZW50X3RpZCk7CisJUERFQlVHICgidGhyZWFkX2xhdW5jaGVyOiB0aWQgJWQgdGVybWluYXRlZCIsIGN1cnJlbnRfdGlkKTsKIAogCWx0aHJlYWRzW2N1cnJlbnRfdGlkXS5zdGF0ZSA9IFNUQVRFX1RFUk1JTkFURUQ7CiAJdGhyZWFkX3lpZWxkICgpOwpAQCAtMjcyLDcgKzI3Niw3IEBACiAKIHN0YXRpYyBpbnQgdGhyZWFkX3N0YXJ0IChpbnQgaWQpCiB7Ci0JREVCVUcgKCJ0aHJlYWRfc3RhcnQ6IGlkPSVkIiwgaWQpOworCVBERUJVRyAoInRocmVhZF9zdGFydDogaWQ9JWQiLCBpZCk7CiAJaWYgKGlkIDw9IE1BU1RFUl9USFJFQUQgfHwgaWQgPiBNQVhfVEhSRUFEUykgewogCQlyZXR1cm4gUkNfRkFJTFVSRTsKIAl9CkBAIC0yODMsMTcgKzI4NywxNyBAQAogCWlmIChzZXRqbXAgKGx0aHJlYWRzW2N1cnJlbnRfdGlkXS5jb250ZXh0KSA9PSAwKSB7CiAJCWx0aHJlYWRzW2lkXS5zdGF0ZSA9IFNUQVRFX1JVTk5BQkxFOwogCQljdXJyZW50X3RpZCA9IGlkOwotCQlERUJVRyAoInRocmVhZF9zdGFydDogdG8gYmUgc3RhY2s9MCUwOHgiLCBsdGhyZWFkc1tpZF0uc3RhY2spOworCQlQREVCVUcgKCJ0aHJlYWRfc3RhcnQ6IHRvIGJlIHN0YWNrPTAlMDh4IiwgbHRocmVhZHNbaWRdLnN0YWNrKTsKIAkJc2V0Y3R4c3AgKCZsdGhyZWFkc1tpZF0uc3RhY2tbU1RLX1NJWkVdKTsKIAkJdGhyZWFkX2xhdW5jaGVyICgpOwogCX0KIAotCURFQlVHICgidGhyZWFkX3N0YXJ0OiBUaHJlYWQgaWQ9JWQgc3RhcnRlZCwgcGFyZW50IHJldHVybnMiLCBpZCk7CisJUERFQlVHICgidGhyZWFkX3N0YXJ0OiBUaHJlYWQgaWQ9JWQgc3RhcnRlZCwgcGFyZW50IHJldHVybnMiLCBpZCk7CiAKIAlyZXR1cm4gUkNfU1VDQ0VTUzsKIH0KIAotI2lmIDAJLyogbm90IHVzZWQgc28gZmFyICovCisjaWYgMAkJCQkJCQkvKiBub3QgdXNlZCBzbyBmYXIgKi8KIHN0YXRpYyBpbnQgdGhyZWFkX3N0b3AgKGludCBpZCkKIHsKIAlpZiAoaWQgPD0gTUFTVEVSX1RIUkVBRCB8fCBpZCA+PSBNQVhfVEhSRUFEUykKQEAgLTMwNSw0NiArMzA5LDQ2IEBACiAJbHRocmVhZHNbaWRdLnN0YXRlID0gU1RBVEVfU1RPUFBFRDsKIAlyZXR1cm4gUkNfU1VDQ0VTUzsKIH0KLSNlbmRpZiAvKiBub3QgdXNlZCBzbyBmYXIgKi8KKyNlbmRpZgkJCQkJCQkvKiBub3QgdXNlZCBzbyBmYXIgKi8KIAogc3RhdGljIGludCB0aHJlYWRfam9pbiAoaW50ICpyZXQpCiB7CiAJaW50IGksIGogPSAwOwogCi0JREVCVUcgKCJ0aHJlYWRfam9pbjogKnJldCA9ICVkIiwgKnJldCk7CisJUERFQlVHICgidGhyZWFkX2pvaW46ICpyZXQgPSAlZCIsICpyZXQpOwogCiAJaWYgKCEoKnJldCA9PSAtMSB8fCAqcmV0ID4gTUFTVEVSX1RIUkVBRCB8fCAqcmV0IDwgTUFYX1RIUkVBRFMpKSB7Ci0JCURFQlVHICgidGhyZWFkX2pvaW46IGludmFsaWQgdGlkICVkIiwgKnJldCk7CisJCVBERUJVRyAoInRocmVhZF9qb2luOiBpbnZhbGlkIHRpZCAlZCIsICpyZXQpOwogCQlyZXR1cm4gUkNfRkFJTFVSRTsKIAl9CiAKIAlpZiAoKnJldCA9PSAtMSkgewotCQlERUJVRyAoIkNoZWNraW5nIGZvciB0aWQgPSAtMSIpOworCQlQREVCVUcgKCJDaGVja2luZyBmb3IgdGlkID0gLTEiKTsKIAkJd2hpbGUgKDEpIHsKLQkJCS8qIERFQlVHKCJ0aHJlYWRfam9pbjogc3RhcnQgd2hpbGUtbG9vcG4iKTsgKi8KKwkJCS8qIFBERUJVRygidGhyZWFkX2pvaW46IHN0YXJ0IHdoaWxlLWxvb3BuIik7ICovCiAJCQlqID0gMDsKIAkJCWZvciAoaSA9IE1BU1RFUl9USFJFQUQgKyAxOyBpIDwgTUFYX1RIUkVBRFM7IGkrKykgewogCQkJCWlmIChsdGhyZWFkc1tpXS5zdGF0ZSA9PSBTVEFURV9URVJNSU5BVEVEKSB7CiAJCQkJCSpyZXQgPSBsdGhyZWFkc1tpXS5yZXR2YWw7CiAJCQkJCWx0aHJlYWRzW2ldLnN0YXRlID0gU1RBVEVfRU1QVFk7Ci0JCQkJCS8qIERFQlVHKCJ0aHJlYWRfam9pbjogcmV0dXJuaW5nIHJldHZhbCAlZCBvZiB0aWQgJWQiLAotCQkJCQkJcmV0LCBpKTsgKi8KKwkJCQkJLyogUERFQlVHKCJ0aHJlYWRfam9pbjogcmV0dXJuaW5nIHJldHZhbCAlZCBvZiB0aWQgJWQiLAorCQkJCQkgICByZXQsIGkpOyAqLwogCQkJCQlyZXR1cm4gUkNfU1VDQ0VTUzsKIAkJCQl9CiAKIAkJCQlpZiAobHRocmVhZHNbaV0uc3RhdGUgIT0gU1RBVEVfRU1QVFkpIHsKLQkJCQkJREVCVUcgKCJ0aHJlYWRfam9pbjogJWQgdXNlZCBzbG90cyB0aWQgJWQgc3RhdGU9JWQiLAotCQkJCQkJaiwgaSwgbHRocmVhZHNbaV0uc3RhdGUpOworCQkJCQlQREVCVUcgKCJ0aHJlYWRfam9pbjogJWQgdXNlZCBzbG90cyB0aWQgJWQgc3RhdGU9JWQiLAorCQkJCQkJICAgaiwgaSwgbHRocmVhZHNbaV0uc3RhdGUpOwogCQkJCQlqKys7CiAJCQkJfQogCQkJfQogCQkJaWYgKGogPT0gMCkgewotCQkJCURFQlVHICgidGhyZWFkX2pvaW46IGFsbCBzbG90cyBlbXB0eSEiKTsKKwkJCQlQREVCVUcgKCJ0aHJlYWRfam9pbjogYWxsIHNsb3RzIGVtcHR5ISIpOwogCQkJCXJldHVybiBSQ19GQUlMVVJFOwogCQkJfQotCQkJLyogIERFQlVHKCJ0aHJlYWRfam9pbjogeWllbGRpbmciKTsgKi8KKwkJCS8qICBQREVCVUcoInRocmVhZF9qb2luOiB5aWVsZGluZyIpOyAqLwogCQkJdGhyZWFkX3lpZWxkICgpOwotCQkJLyogIERFQlVHKCJ0aHJlYWRfam9pbjogYmFjayBmcm9tIHlpZWxkIik7ICovCisJCQkvKiAgUERFQlVHKCJ0aHJlYWRfam9pbjogYmFjayBmcm9tIHlpZWxkIik7ICovCiAJCX0KIAl9CiAKQEAgLTM1MiwxMCArMzU2LDEwIEBACiAJCWkgPSAqcmV0OwogCQkqcmV0ID0gbHRocmVhZHNbKnJldF0ucmV0dmFsOwogCQlsdGhyZWFkc1sqcmV0XS5zdGF0ZSA9IFNUQVRFX0VNUFRZOwotCQlERUJVRyAoInRocmVhZF9qb2luOiByZXR1cmluZyAlZCBmb3IgdGlkICVkIiwgKnJldCwgaSk7CisJCVBERUJVRyAoInRocmVhZF9qb2luOiByZXR1cmluZyAlZCBmb3IgdGlkICVkIiwgKnJldCwgaSk7CiAJCXJldHVybiBSQ19TVUNDRVNTOwogCX0KIAotCURFQlVHICgidGhyZWFkX2pvaW46IHRocmVhZCAlZCBpcyBub3QgdGVybWluYXRlZCEiLCAqcmV0KTsKKwlQREVCVUcgKCJ0aHJlYWRfam9pbjogdGhyZWFkICVkIGlzIG5vdCB0ZXJtaW5hdGVkISIsICpyZXQpOwogCXJldHVybiBSQ19GQUlMVVJFOwogfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hc20tbWlwcy9pbmNhLWlwLmggYi9pbmNsdWRlL2FzbS1taXBzL2luY2EtaXAuaAppbmRleCBkYmFjYjMzLi4wYzVmMWQ3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FzbS1taXBzL2luY2EtaXAuaAorKysgYi9pbmNsdWRlL2FzbS1taXBzL2luY2EtaXAuaApAQCAtODk0LDcgKzg5NCwxMiBAQAogLyogIE1vZHVsZSAgICAgIDogIEVCVSByZWdpc3RlciBhZGRyZXNzIGFuZCBiaXRzICAgICAgICAgICAgICAgICAgICAgICAqLwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogICAgICAgICAgCisjaWYgZGVmaW5lZChDT05GSUdfSU5DQV9JUCkKICNkZWZpbmUgSU5DQV9JUF9FQlUgICAgICAgICAgICAgICAgICAgICAgICAgICgweEI4MDAwMjAwKQorI2VsaWYgZGVmaW5lZChDT05GSUdfUFVSUExFKQorI2RlZmluZSBJTkNBX0lQX0VCVSAgICAgICAgICAgICAgICAgICAgICAgICAgKDB4QjgwMEQ4MDApCisjZW5kaWYKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLyAgIAogCiAgICAgICAKQEAgLTE0OTAsNyArMTQ5NSwxMiBAQAogLyogIE1vZHVsZSAgICAgIDogIEFTQyByZWdpc3RlciBhZGRyZXNzIGFuZCBiaXRzICAgICAgICAgICAgICAgICAgICAgICAqLwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogICAgICAgICAgCisjaWYgZGVmaW5lZChDT05GSUdfSU5DQV9JUCkKICNkZWZpbmUgSU5DQV9JUF9BU0MgICAgICAgICAgICAgICAgICAgICAgICAgICgweEI4MDAwNDAwKQorI2VsaWYgZGVmaW5lZChDT05GSUdfUFVSUExFKQorI2RlZmluZSBJTkNBX0lQX0FTQyAgICAgICAgICAgICAgICAgICAgICAgICAgKDB4QkU1MDAwMDApCisjZW5kaWYKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLyAgIAogCiAgICAgICAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvY21kX25ldC5oIGIvaW5jbHVkZS9jbWRfbmV0LmgKaW5kZXggMmZhODQ4Yi4uZTljYTVjNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9jbWRfbmV0LmgKKysrIGIvaW5jbHVkZS9jbWRfbmV0LmgKQEAgLTU2LDcgKzU2LDcgQEAKICNkZWZpbmUJQ01EX1RCTF9ESENQCU1LX0NNRF9UQkxfRU5UUlkoCQkJCQlcCiAJImRoY3AiLAkJNCwJMywJMSwJZG9fZGhjcCwJCQlcCiAJImRoY3AgICAgLSBpbnZva2UgREhDUCBjbGllbnQgdG8gb2J0YWluIElQL2Jvb3QgcGFyYW1zXG4iLAkJXAotCSJcbiIgCQkJCQkJIAkJCVwKKwkiW2xvYWRBZGRyZXNzXSBbYm9vdGZpbGVuYW1lXVxuIiAJCSAJCQlcCiApLAogCiBpbnQgZG9fZGhjcCAoY21kX3RibF90ICpjbWR0cCwgaW50IGZsYWcsIGludCBhcmdjLCBjaGFyICphcmd2W10pOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9jb25maWdzL01JUDQwNS5oIGIvaW5jbHVkZS9jb25maWdzL01JUDQwNS5oCmluZGV4IDFkZDdmM2EuLjQ3N2JlNTIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvY29uZmlncy9NSVA0MDUuaAorKysgYi9pbmNsdWRlL2NvbmZpZ3MvTUlQNDA1LmgKQEAgLTEwOSw3ICsxMDksNyBAQAogI2RlZmluZSBDT05GSUdfQk9PVF9SRVRSWV9USU1FCS0xMAkvKiBmZWF0dXJlIGlzIGF2YWlhYmxlIGJ1dCBub3QgZW5hYmxlZCAqLwogI2RlZmluZSBDT05GSUdfWkVST19CT09UREVMQVlfQ0hFQ0sgIAkvKiBjaGVjayBjb25zb2xlIGV2ZW4gaWYgYm9vdGRlbGF5ID0gMCAqLwogCi0jZGVmaW5lIENPTkZJR19CT09UQ09NTUFORAkiZGlza2Jvb3QgMjAwMDAwIDA6MTsgYm9vdG0iIC8qIGF1dG9ib290IGNvbW1hbmQJCSovCisjZGVmaW5lIENPTkZJR19CT09UQ09NTUFORAkiZGlza2Jvb3QgNDAwMDAwIDA6MTsgYm9vdG0iIC8qIGF1dG9ib290IGNvbW1hbmQJCSovCiAjZGVmaW5lIENPTkZJR19CT09UQVJHUwkJImNvbnNvbGU9dHR5UzAsOTYwMCByb290PS9kZXYvaGRhNSIgLyogYm9vdCBhcmd1bWVudHMgKi8KIAogI2RlZmluZSBDT05GSUdfSVBBRERSCQkxMC4wLjAuMTAwCkBAIC0xNjIsNyArMTYyLDcgQEAKIAl7IDMwMCwgNjAwLCAxMjAwLCAyNDAwLCA0ODAwLCA5NjAwLCAxOTIwMCwgMzg0MDAsICAgICBcCiAJIDU3NjAwLCAxMTUyMDAsIDIzMDQwMCwgNDYwODAwLCA5MjE2MDAgfQogCi0jZGVmaW5lIENGR19MT0FEX0FERFIJMHgyMDAwMDAJLyogZGVmYXVsdCBsb2FkIGFkZHJlc3MgKi8KKyNkZWZpbmUgQ0ZHX0xPQURfQUREUgkweDQwMDAwMAkvKiBkZWZhdWx0IGxvYWQgYWRkcmVzcyAqLwogI2RlZmluZSBDRkdfRVhUQkRJTkZPCTEJCS8qIFRvIHVzZSBleHRlbmRlZCBib2FyZF9pbnRvIChiZF90KSAqLwogCiAjZGVmaW5lIENGR19IWgkJMTAwMAkJLyogZGVjcmVtZW50ZXIgZnJlcTogMSBtcyB0aWNrcyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9jb25maWdzL1BJUDQwNS5oIGIvaW5jbHVkZS9jb25maWdzL1BJUDQwNS5oCmluZGV4IGE1ZmM4ZDkuLjVlY2I1MzcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvY29uZmlncy9QSVA0MDUuaAorKysgYi9pbmNsdWRlL2NvbmZpZ3MvUElQNDA1LmgKQEAgLTExMyw3ICsxMTMsNyBAQAogI2RlZmluZSBDT05GSUdfWkVST19CT09UREVMQVlfQ0hFQ0sgIAkvKiBjaGVjayBjb25zb2xlIGV2ZW4gaWYgYm9vdGRlbGF5ID0gMCAqLwogCiAKLSNkZWZpbmUgQ09ORklHX0JPT1RDT01NQU5ECSJkaXNrYm9vdCAyMDAwMDAgMDoxOyBib290bSIgLyogYXV0b2Jvb3QgY29tbWFuZAkJKi8KKyNkZWZpbmUgQ09ORklHX0JPT1RDT01NQU5ECSJkaXNrYm9vdCA0MDAwMDAgMDoxOyBib290bSIgLyogYXV0b2Jvb3QgY29tbWFuZAkJKi8KICNkZWZpbmUgQ09ORklHX0JPT1RBUkdTCQkiY29uc29sZT10dHlTMCw5NjAwIHJvb3Q9L2Rldi9oZGE1IiAvKiBib290IGFyZ3VtZW50cyAqLwogCiAjZGVmaW5lIENPTkZJR19JUEFERFIJCTEwLjAuMC4xMDAKQEAgLTE2Niw3ICsxNjYsNyBAQAogCXsgMzAwLCA2MDAsIDEyMDAsIDI0MDAsIDQ4MDAsIDk2MDAsIDE5MjAwLCAzODQwMCwgICAgIFwKIAkgNTc2MDAsIDExNTIwMCwgMjMwNDAwLCA0NjA4MDAsIDkyMTYwMCB9CiAKLSNkZWZpbmUgQ0ZHX0xPQURfQUREUgkJMHgyMDAwMDAJLyogZGVmYXVsdCBsb2FkIGFkZHJlc3MgKi8KKyNkZWZpbmUgQ0ZHX0xPQURfQUREUgkJMHg0MDAwMDAJLyogZGVmYXVsdCBsb2FkIGFkZHJlc3MgKi8KICNkZWZpbmUgQ0ZHX0VYVEJESU5GTwkJMQkvKiBUbyB1c2UgZXh0ZW5kZWQgYm9hcmRfaW50byAoYmRfdCkgKi8KIAogI2RlZmluZSBDRkdfSFoJCTEwMDAJCS8qIGRlY3JlbWVudGVyIGZyZXE6IDEgbXMgdGlja3MgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvY29uZmlncy9pbmNhaXAuaCBiL2luY2x1ZGUvY29uZmlncy9pbmNhaXAuaAppbmRleCBiYzBkYjg0Li4zYjY0OGMxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2NvbmZpZ3MvaW5jYWlwLmgKKysrIGIvaW5jbHVkZS9jb25maWdzL2luY2FpcC5oCkBAIC0zNCwxOCArMzQsNjAgQEAKIC8qIGFsbG93ZWQgdmFsdWVzOiAxMDAwMDAwMDAgYW5kIDE1MDAwMDAwMCAqLwogI2RlZmluZSBDUFVfQ0xPQ0tfUkFURQkxNTAwMDAwMDAgICAvKiAxNTAgTUh6IGNsb2NrIGZvciB0aGUgTUlQUyBjb3JlICovCiAKLSNkZWZpbmUgQ09ORklHX0JBVURSQVRFCQkxMTUyMDAKKyNpZiBDUFVfQ0xPQ0tfUkFURSA9PSAxMDAwMDAwMDAKKyNkZWZpbmUgSU5GSU5FT05fRUJVX0JPT1RDRkcJMHgyMEM0CS8qIENNVUxUID0gNCBmb3IgMTAwIE1IeiAqLworI2Vsc2UKKyNkZWZpbmUgSU5GSU5FT05fRUJVX0JPT1RDRkcJMHg0MEM0CS8qIENNVUxUID0gOCBmb3IgMTUwIE1IeiAqLworI2VuZGlmCiAKLSNkZWZpbmUgQ0ZHX1NEUkFNX0JBU0UJCTB4ODAwMDAwMDAKIAotI2RlZmluZSBDRkdfTUFMTE9DX0xFTgkJMTI4KjEwMjQKKyNkZWZpbmUgQ09ORklHX0JPT1RERUxBWQk1CS8qIGF1dG9ib290IGFmdGVyIDUgc2Vjb25kcwkqLwogCi0jZGVmaW5lIENGR19CT09UUEFSQU1TX0xFTgkxMjgqMTAyNAorI2RlZmluZSBDT05GSUdfQkFVRFJBVEUJCTExNTIwMAogCiAvKiB2YWxpZCBiYXVkcmF0ZXMgKi8KICNkZWZpbmUgQ0ZHX0JBVURSQVRFX1RBQkxFCXsgOTYwMCwgMTkyMDAsIDM4NDAwLCA1NzYwMCwgMTE1MjAwIH0KIAorI2RlZmluZQlDT05GSUdfVElNRVNUQU1QCQkvKiBQcmludCBpbWFnZSBpbmZvIHdpdGggdGltZXN0YW1wICovCisKKyNkZWZpbmUgQ09ORklHX1BSRUJPT1QJImVjaG87IglcCisJImVjaG8gVHlwZSBcInJ1biBmbGFzaF9uZnNcIiB0byBtb3VudCByb290IGZpbGVzeXN0ZW0gb3ZlciBORlM7IiBcCisJImVjaG8iCisKKyN1bmRlZglDT05GSUdfQk9PVEFSR1MKKworI2RlZmluZQlDT05GSUdfRVhUUkFfRU5WX1NFVFRJTkdTCQkJCQlcCisJIm5mc2FyZ3M9c2V0ZW52IGJvb3RhcmdzIHJvb3Q9L2Rldi9uZnMgcncgIgkJCVwKKwkJIm5mc3Jvb3Q9JChzZXJ2ZXJpcCk6JChyb290cGF0aClcMCIJCQlcCisJInJhbWFyZ3M9c2V0ZW52IGJvb3RhcmdzIHJvb3Q9L2Rldi9yYW0gcndcMCIJCQlcCisJImFkZGlwPXNldGVudiBib290YXJncyAkKGJvb3RhcmdzKSAiCQkJCVwKKwkJImlwPSQoaXBhZGRyKTokKHNlcnZlcmlwKTokKGdhdGV3YXlpcCk6JChuZXRtYXNrKSIJXAorCQkiOiQoaG9zdG5hbWUpOiQobmV0ZGV2KTpvZmZcMCIJCQkJXAorCSJhZGRtaXNjPXNldGVudiBib290YXJncyAkKGJvb3RhcmdzKSAiCQkJCVwKKwkJImNvbnNvbGU9dHR5UzAsJChiYXVkcmF0ZSkgIgkJCQlcCisJCSJldGhhZGRyPSQoZXRoYWRkcikgIgkJCQkJXAorCQkicGFuaWM9MVwwIgkJCQkJCVwKKwkiZmxhc2hfbmZzPXJ1biBuZnNhcmdzIGFkZGlwIGFkZG1pc2M7IgkJCQlcCisJCSJib290bSAkKGtlcm5lbF9hZGRyKVwwIgkJCQlcCisJImZsYXNoX3NlbGY9cnVuIHJhbWFyZ3MgYWRkaXAgYWRkbWlzYzsiCQkJCVwKKwkJImJvb3RtICQoa2VybmVsX2FkZHIpICQocmFtZGlza19hZGRyKVwwIgkJXAorCSJuZXRfbmZzPXRmdHAgODA1MDAwMDAgJChib290ZmlsZSk7IgkJCQlcCisJCSJydW4gbmZzYXJncyBhZGRpcCBhZGRtaXNjO2Jvb3RtXDAiCQkJXAorCSJyb290cGF0aD0vb3B0L2VsZGsvbWlwc180S0NcMCIJCQkJCVwKKwkiYm9vdGZpbGU9L3RmdHBib290L0lOQ0EvdUltYWdlXDAiCQkJCVwKKwkia2VybmVsX2FkZHI9QjAwNDAwMDBcMCIJCQkJCVwKKwkicmFtZGlza19hZGRyPUIwMTAwMDAwXDAiCQkJCQlcCisJInUtYm9vdD0vdGZ0cGJvb3QvSU5DQS91LWJvb3QuYmluXDAiCQkJCVwKKwkibG9hZD10ZnRwIDgwNTAwMDAwICQodS1ib290KVwwIgkJCQlcCisJInVwZGF0ZT1wcm90ZWN0IG9mZiAxOjAtMjtlcmEgMTowLTI7IgkJCQlcCisJCSJjcC5iIDgwNTAwMDAwIEIwMDAwMDAwICQoZmlsZXNpemUpXDAiCQkJXAorCSIiCisjZGVmaW5lIENPTkZJR19CT09UQ09NTUFORAkicnVuIGZsYXNoX3NlbGYiCisKLSNkZWZpbmUgQ09ORklHX0NPTU1BTkRTCQkoQ09ORklHX0NNRF9ERkwgfCBDRkdfQ01EX0VMRikKKyNkZWZpbmUgQ09ORklHX0NPTU1BTkRTCQkoQ09ORklHX0NNRF9ERkwgfCBcCisJCQkJIENGR19DTURfQVNLRU5WCXwgXAorCQkJCSBDRkdfQ01EX0RIQ1AJfCBcCisJCQkJIENGR19DTURfRUxGCSkKICNpbmNsdWRlIDxjbWRfY29uZmRlZnMuaD4KIAogLyoKQEAgLTU1LDEyICs5NywxOSBAQAogI2RlZmluZQlDRkdfUFJPTVBUCQkiSU5DQS1JUCAjICIJLyogTW9uaXRvciBDb21tYW5kIFByb21wdCAgICAqLwogI2RlZmluZQlDRkdfQ0JTSVpFCQkyNTYJCS8qIENvbnNvbGUgSS9PIEJ1ZmZlciBTaXplICAgKi8KICNkZWZpbmUJQ0ZHX1BCU0laRSAoQ0ZHX0NCU0laRStzaXplb2YoQ0ZHX1BST01QVCkrMTYpICAvKiBQcmludCBCdWZmZXIgU2l6ZSAqLwotI2RlZmluZSBDRkdfSFoJCQkoQ1BVX0NMT0NLX1JBVEUvMikKICNkZWZpbmUJQ0ZHX01BWEFSR1MJCTE2CQkvKiBtYXggbnVtYmVyIG9mIGNvbW1hbmQgYXJncyovCiAKKyNkZWZpbmUgQ0ZHX01BTExPQ19MRU4JCTEyOCoxMDI0CisKKyNkZWZpbmUgQ0ZHX0JPT1RQQVJBTVNfTEVOCTEyOCoxMDI0CisKKyNkZWZpbmUgQ0ZHX0haCQkJKENQVV9DTE9DS19SQVRFLzIpCisKKyNkZWZpbmUgQ0ZHX1NEUkFNX0JBU0UJCTB4ODAwMDAwMDAKKwogI2RlZmluZQlDRkdfTE9BRF9BRERSCQkweDgwMTAwMDAwCS8qIGRlZmF1bHQgbG9hZCBhZGRyZXNzCSovCiAKLSNkZWZpbmUgQ0ZHX01FTVRFU1RfU1RBUlQJMHg4MDIwMDAwMAorI2RlZmluZSBDRkdfTUVNVEVTVF9TVEFSVAkweDgwMTAwMDAwCiAjZGVmaW5lIENGR19NRU1URVNUX0VORAkJMHg4MDgwMDAwMAogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS9pbmNsdWRlL2NvbmZpZ3MvaW5ub2tvbS5oIGIvaW5jbHVkZS9jb25maWdzL2lubm9rb20uaAppbmRleCBjMjI2N2JkLi4zMTJjODU0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2NvbmZpZ3MvaW5ub2tvbS5oCisrKyBiL2luY2x1ZGUvY29uZmlncy9pbm5va29tLmgKQEAgLTYyLDcgKzYyLDggQEAKICNkZWZpbmUgQ09ORklHX0JBVURSQVRFCQkxOTIwMAogI2RlZmluZSBDT05GSUdfTUlTQ19JTklUX1IJMQkvKiB3ZSBoYXZlIGEgbWlzY19pbml0X3IoKSBmdW5jdGlvbiAqLwogCi0jZGVmaW5lIENPTkZJR19DT01NQU5EUyAoQ09ORklHX0NNRF9ERkx8Q0ZHX0NNRF9JMkN8Q0ZHX0NNRF9FRVBST018Q0ZHX0NNRF9ORVR8Q0ZHX0NNRF9KRkZTMnxDRkdfQ01EX0RIQ1ApCisjZGVmaW5lIENPTkZJR19DT01NQU5EUyAoQ0ZHX0NNRF9CREl8Q0ZHX0NNRF9MT0FEQnxDRkdfQ01EX0lNSXxDRkdfQ01EX0ZMQVNIfENGR19DTURfTUVNT1JZfENGR19DTURfTkVUfENGR19DTURfRU5WfENGR19DTURfUlVOfENGR19DTURfQVNLRU5WfENGR19DTURfRUNIT3xDRkdfQ01EX0kyQ3xDRkdfQ01EX0RIQ1ApCisvKiBDT05GSUdfQ01EX0RGTHxDRkdfQ01EX0kyQ3xDRkdfQ01EX0VFUFJPTXxDRkdfQ01EX05FVHxDRkdfQ01EX0pGRlMyfENGR19DTURfREhDUCkgKi8KIC8qIHRoaXMgbXVzdCBiZSBpbmNsdWRlZCBBRlRFUiB0aGUgZGVmaW5pdGlvbiBvZiBDT05GSUdfQ09NTUFORFMgKGlmIGFueSkgICAqLwogI2luY2x1ZGUgPGNtZF9jb25mZGVmcy5oPgogCkBAIC03OCwxMSArNzksNiBAQAogCiAjZGVmaW5lIENPTkZJR19DTURMSU5FX1RBRwkxCiAKLSNpZiAoQ09ORklHX0NPTU1BTkRTICYgQ0ZHX0NNRF9LR0RCKQotI2RlZmluZSBDT05GSUdfS0dEQl9CQVVEUkFURQkxOTIwMAkJLyogc3BlZWQgdG8gcnVuIGtnZGIgc2VyaWFsIHBvcnQgKi8KLSNkZWZpbmUgQ09ORklHX0tHREJfU0VSX0lOREVYCTIJCS8qIHdoaWNoIHNlcmlhbCBwb3J0IHRvIHVzZSAqLwotI2VuZGlmCi0KIC8qCiAgKiBNaXNjZWxsYW5lb3VzIGNvbmZpZ3VyYWJsZSBvcHRpb25zCiAgKi8KQEAgLTE4Niw3ICsxODIsNyBAQAogCiAKIC8qCi0gKiBHUElPIHNldHRpbmdzOyBzZWUgQkRJMjAwMCBjb25maWcgZmlsZSBmb3IgZGV0YWlscworICogR1BJTyBzZXR0aW5ncwogICoKICAqIEdQMTUgPT0gbkNTMSAgICAgIGlzIDEKICAqIEdQMjQgPT0gU0ZSTSAgICAgIGlzIDEKQEAgLTM5MSw3ICszODcsNyBAQAogICogWzMyOjI2XSAwICAgICAtIHJlc2VydmVkCiAgKiBbMjVdICAgIDAgICAgIC0gSzJGUkVFOiBub3QgZnJlZSBydW5uaW5nCiAgKiBbMjRdICAgIDAgICAgIC0gSzFGUkVFOiBub3QgZnJlZSBydW5uaW5nCi0gKiBbMjNdICAgIDAgICAgIC0gSzBGUkVFOiBub3QgZnJlZSBydW5uaW5nCisgKiBbMjNdICAgIDEgICAgIC0gSzBGUkVFOiBub3QgZnJlZSBydW5uaW5nCiAgKiBbMjJdICAgIDAgICAgIC0gU0xGUlNIOiBzZWxmIHJlZnJlc2ggZGlzYWJsZWQKICAqIFsyMV0gICAgMCAgICAgLSByZXNlcnZlZAogICogWzIwXSAgICAwICAgICAtIEFQRDogbm8gYXV0byBwb3dlciBkb3duCkBAIC00MDEsMTEgKzM5NywxMSBAQAogICogWzE2XSAgICAxICAgICAtIEsxUlVOOiBlbmFibGUgU0RDTEsxCiAgKiBbMTVdICAgIDEgICAgIC0gRTFQSU46IFNEUkFNIGNsb2NrIGVuYWJsZQogICogWzE0XSAgICAxICAgICAtIEswREIyOiBTRENMSzAgaXMgTWVtQ2xrCi0gKiBbMTNdICAgIDEgICAgIC0gSzBSVU46IGRpc2FibGUgU0RDTEswCisgKiBbMTNdICAgIDAgICAgIC0gSzBSVU46IGRpc2FibGUgU0RDTEswCiAgKiBbMTJdICAgIDEgICAgIC0gRTBQSU46IGRpc2FibGUgU0RDS0UwCiAgKiBbMTE6MDBdIDAwMDAwMDAxMTAwMCAtICg2NG1zLzgxOTIpKk1lbUNsa0ZyZXEvMzIgPSAyNAogICovCi0jZGVmaW5lIENGR19NRFJFRlJfVkFMCQkweDAwMDFGMDE4CisjZGVmaW5lIENGR19NRFJFRlJfVkFMCQkweDAwODFEMDE4CiAKIC8qIE1ETVJTOiBNb2RlIFJlZ2lzdGVyIFNldCBDb25maWd1cmF0aW9uIFJlZ2lzdGVyCiAgKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9jb25maWdzL3dlcGVwMjUwLmggYi9pbmNsdWRlL2NvbmZpZ3Mvd2VwZXAyNTAuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jODhjNGFiCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9jb25maWdzL3dlcGVwMjUwLmgKQEAgLTAsMCArMSwxODggQEAKKy8qIAorICogQ29weXJpZ2h0IChDKSAyMDAzIEVUQyBzLnIuby4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YKKyAqIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLAorICogTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKiBXcml0dGVuIGJ5IFBldGVyIEZpZ3VsaSA8cGVwb3NoQGV0Yy5zaz4sIDIwMDMuCisgKgorICovCisKKyNpZm5kZWYgX19DT05GSUdfSAorI2RlZmluZSBfX0NPTkZJR19ICisKKyNkZWZpbmUgQ09ORklHX1BYQTI1MCAgICAgICAgICAxICAgICAgICAvKiB0aGlzIGlzIGFuIFBYQTI1MCBDUFUgICAgICovCisjZGVmaW5lIENPTkZJR19XRVBFUDI1MCAgICAgICAgMSAgICAgICAgLyogY29uZmlnIGZvciB3ZXBlcDI1MCBib2FyZCAqLworI3VuZGVmICBDT05GSUdfVVNFX0lSUSAgICAgICAgICAgICAgICAgIC8qIGRvbid0IG5lZWQgdXNlIElSUS9GSVEgICAgKi8KKworCisvKgorICogU2VsZWN0IHNlcmlhbCBjb25zb2xlIGNvbmZpZ3VyYXRpb24KKyAqLworI2RlZmluZSBDT05GSUdfQlRVQVJUICAgICAgICAgIDEgICAgICAgLyogQlRVQVJUIGlzIGRlZmF1bHQgb24gV0VQIGRldiBib2FyZCAqLworI2RlZmluZSBDT05GSUdfQkFVRFJBVEUgICAxMTUyMDAKKworCisvKgorICogRGVmaW5pdGlvbiBvZiB1LWJvb3QgYnVpbGQgaW4gY29tbWFuZHMuIENoZWNrIG91dCBDT05GSUdfQ01EX0RGTCBpZgorICogbmVjY2Vzc2FyeSBpbiBpbmNsdWRlL2NtZF9jb25mZGVmcy5oIGZpbGUuIChVbiljb21tZW50IGZvciBnZXR0aW5nCisgKiBmdW5jdGlvbmFsaXR5IG9yIHNpemUgb2YgdS1ib290IGNvZGUuCisgKi8KKyNkZWZpbmUgQ09ORklHX0NPTU1BTkRTICAgICAgICAgKENPTkZJR19DTURfREZMCQlcCisJCQkJJiB+Q0ZHX0NNRF9ORVQgCQlcCisJCQkJJiB+Q0ZHX0NNRF9MT0FEUwlcCisJCQkJJiB+Q0ZHX0NNRF9DT05TT0xFCVwKKwkJCQkmIH5DRkdfQ01EX0FVVE9TQ1JJUFQJXAorLyoJCQkJfCBDRkdfQ01EX0pGRlMyICovCVwKKwkJCQkpCisjaW5jbHVkZSA8Y21kX2NvbmZkZWZzLmg+CisKKy8qCisgKiBCb290IG9wdGlvbnMuIFNldHRpbmcgZGVsYXkgdG8gLTEgc3RvcHMgYXV0b3N0YXJ0IGNvdW50IGRvd24uCisgKiBOT1RFOiBTZW5kaW5nIHBhcmFtZXRlcnMgdG8ga2VybmVsIGRlcGVuZHMgb24ga2VybmVsIHZlcnNpb24gYW5kCisgKiAyLjQuMTktcm1rNi1weGExIHBhdGNoIHVzZWQgd2hpbGUgbXkgdS1ib290IGNvZGluZyBkaWRuJ3QgYWNjZXB0IAorICogcGFyYW1ldGVycyBhdCBhbGwhIERvIG5vdCBnZXQgY29uZnVzZWQgYnkgdGhlbSBzby4KKyAqLworI2RlZmluZSBDT05GSUdfQk9PVERFTEFZICAgLTEKKyNkZWZpbmUgQ09ORklHX0JPT1RBUkdTICAgICJyb290PS9kZXYvbXRkYmxvY2syIG1lbT0zMm0gY29uc29sZT10dHlTMDEsMTE1MjAwbjgiCisjZGVmaW5lIENPTkZJR19CT09UQ09NTUFORCAiYm9vdG0gNDAwMDAiCisKKworLyoKKyAqIEdlbmVyYWwgb3B0aW9ucyBmb3IgdS1ib290LiBNb2RpZnkgdG8gc2F2ZSBtZW1vcnkgZm9vdCBwcmludAorICovCisjZGVmaW5lIENGR19MT05HSEVMUCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB1bmRlZiBzYXZlcyBtZW1vcnkgICovCisjZGVmaW5lIENGR19QUk9NUFQgICAgICAgICAgICAgICJXRVA+ICIgICAgICAgICAgICAgICAvKiBwcm9tcHQgc3RyaW5nICAgICAgICovCisjZGVmaW5lIENGR19DQlNJWkUgICAgICAgICAgICAgIDI1NiAgICAgICAgICAgICAgICAgICAvKiBjb25zb2xlIEkvTyBidWZmZXIgICovCisjZGVmaW5lIENGR19QQlNJWkUgKENGR19DQlNJWkUrc2l6ZW9mKENGR19QUk9NUFQpKzE2KSAvKiBwcmludCBidWZmZXIgc2l6ZSAgICovCisjZGVmaW5lIENGR19NQVhBUkdTICAgICAgICAgICAgIDE2ICAgICAgICAgICAgICAgICAgICAvKiBtYXggY29tbWFuZCBhcmdzICAgICovCisjZGVmaW5lIENGR19CQVJHU0laRSAgICAgICAgICAgIENGR19DQlNJWkUgICAgICAgICAgICAvKiBib290IGFyZ3MgYnVmIHNpemUgICovCisKKyNkZWZpbmUgQ0ZHX01FTVRFU1RfU1RBUlQgICAgICAgMHhhMDQwMDAwMCAgICAgICAgICAgIC8qIG1lbXRlc3QgdGVzdCBhcmVhICAgKi8KKyNkZWZpbmUgQ0ZHX01FTVRFU1RfRU5EICAgICAgICAgMHhhMDgwMDAwMCAgICAgIAorCisjdW5kZWYgIENGR19DTEtTX0lOX0haICAgICAgICAgICAgICAgICAgICAgICAvKiB1c2UgSFogZm9yIGZyZXEuIGRpc3BsYXkgICAgICovCisKKyNkZWZpbmUgQ0ZHX0haICAgICAgICAgICAgICAgICAgMzY4NjQwMCAgICAgIC8qIGluY3JlbWVudGVyIGZyZXE6IDMuNjg2NCBNSHogKi8KKyNkZWZpbmUgQ0ZHX0NQVVNQRUVEICAgICAgICAgICAgMHgxNDEgICAgICAgIC8qIGNvcmUgY2xvY2sgLSByZWdpc3RlciB2YWx1ZSAgKi8KKworI2RlZmluZSBDRkdfQkFVRFJBVEVfVEFCTEUgICAgICB7IDk2MDAsIDE5MjAwLCAzODQwMCwgNTc2MDAsIDExNTIwMCB9CisKKy8qCisgKiBEZWZpbml0aW9ucyByZWxhdGVkIHRvIHBhc3NpbmcgYXJndW1lbnRzIHRvIGtlcm5lbC4KKyAqLworI2RlZmluZSBDT05GSUdfQ01ETElORV9UQUcgICAgICAgICAgIDEgICAvKiBzZW5kIGNvbW1hbmRsaW5lIHRvIEtlcm5lbCAgICAgICAqLworI2RlZmluZSBDT05GSUdfU0VUVVBfTUVNT1JZX1RBR1MgICAgIDEgICAvKiBzZW5kIG1lbW9yeSBkZWZpbml0aW9uIHRvIGtlcm5lbCAqLworI3VuZGVmICBDT05GSUdfSU5JVFJEX1RBRyAgICAgICAgICAgICAgICAvKiBkbyBub3Qgc2VuZCBpbml0cmQgcGFyYW1zICAgICAgICAqLworI3VuZGVmICBDT05GSUdfVkZEICAgICAgICAgICAgICAgICAgICAgICAvKiBkbyBub3Qgc2VuZCBmcmFtZWJ1ZmZlciBzZXR1cCAgICAqLworCisKKy8qCisgKiBNYWxsb2MgcG9vbCBuZWVkIHRvIGhvc3QgZW52ICsgMTI4IEtiIHJlc2VydmUgZm9yIG90aGVyIGFsbG9jYXRpb25zLgorICovCisjZGVmaW5lIENGR19NQUxMT0NfTEVOCSAgKENGR19FTlZfU0laRSArICgxMjg8PDEwKSApCisKKyNkZWZpbmUgQ09ORklHX1NUQUNLU0laRSAgICAgICAgKDEyMDw8MTApICAgICAgLyogc3RhY2sgc2l6ZSAqLworCisjaWZkZWYgQ09ORklHX1VTRV9JUlEKKyNkZWZpbmUgQ09ORklHX1NUQUNLU0laRV9JUlEgICAgKDQ8PDEwKSAgICAgICAgLyogSVJRIHN0YWNrICAqLworI2RlZmluZSBDT05GSUdfU1RBQ0tTSVpFX0ZJUSAgICAoNDw8MTApICAgICAgICAvKiBGSVEgc3RhY2sgICovCisjZW5kaWYKKworLyoKKyAqIFNEUkFNIE1lbW9yeSBNYXAKKyAqLworI2RlZmluZSBDT05GSUdfTlJfRFJBTV9CQU5LUyAgICAxICAgICAgICAgICAgICAgIC8qIHdlIGhhdmUgMSBiYW5rIG9mIFNEUkFNICovCisjZGVmaW5lIFdFUF9TRFJBTV8xICAgICAgICAgICAgMHhhMDAwMDAwMCAgICAgICAgLyogU0RSQU0gYmFuayAjMSAgICAgICAgICAgKi8KKyNkZWZpbmUgV0VQX1NEUkFNXzFfU0laRSAgICAgICAweDAyMDAwMDAwICAgICAgICAvKiAzMiBNQiAoIDIgY2hpcCApICAgICAgICAqLworI2RlZmluZSBXRVBfU0RSQU1fMiAgICAgICAgICAgIDB4YTIwMDAwMDAgICAgICAgIC8qIFNEUkFNIGJhbmsgIzIgICAgICAgICAgICovCisjZGVmaW5lIFdFUF9TRFJBTV8yX1NJWkUgICAgICAgMHgwMDAwMDAwMCAgICAgICAgLyogMCBNQiAgICAgICAgICAgICAgICAgICAgKi8KKyNkZWZpbmUgV0VQX1NEUkFNXzMgICAgICAgICAgICAweGE4MDAwMDAwICAgICAgICAvKiBTRFJBTSBiYW5rICMzICAgICAgICAgICAqLworI2RlZmluZSBXRVBfU0RSQU1fM19TSVpFICAgICAgIDB4MDAwMDAwMDAgICAgICAgIC8qIDAgTUIgICAgICAgICAgICAgICAgICAgICovCisjZGVmaW5lIFdFUF9TRFJBTV80ICAgICAgICAgICAgMHhhYzAwMDAwMCAgICAgICAgLyogU0RSQU0gYmFuayAjNCAgICAgICAgICAgKi8KKyNkZWZpbmUgV0VQX1NEUkFNXzRfU0laRSAgICAgICAweDAwMDAwMDAwICAgICAgICAvKiAwIE1CICAgICAgICAgICAgICAgICAgICAqLworCisjZGVmaW5lIENGR19EUkFNX0JBU0UgICAgICAgICAgIDB4YTAwMDAwMDAKKyNkZWZpbmUgQ0ZHX0RSQU1fU0laRSAgICAgICAgICAgMHgwMjAwMDAwMAorCisvKiBVbmNvbW1lbnQgdXNlZCBTRFJBTSBjaGlwICovCisjZGVmaW5lIFdFUF9TRFJBTV9LNFMyODE2MzMKKy8qI2RlZmluZSBXRVBfU0RSQU1fSzRTNTYxNjMzKi8KKworCisvKgorICogQ29uZmlndXJhdGlvbiBmb3IgRkxBU0ggbWVtb3J5CisgKi8KKyNkZWZpbmUgQ0ZHX01BWF9GTEFTSF9CQU5LUyAgICAJMSAgCS8qIEZMQVNIIGJhbmtzIGNvdW50IChub3QgY2hpcCBjb3VudCkqLworI2RlZmluZSBDRkdfTUFYX0ZMQVNIX1NFQ1QgICAgIAkxMjgJLyogbnVtYmVyIG9mIHNlY3RvciBpbiBGTEFTSCBiYW5rICAgICovCisjZGVmaW5lIFdFUF9GTEFTSF9CVVNfV0lEVEggCTQJLyogd2UgdXNlIDMyIGJpdCBGTEFTSCBtZW1vcnkuLi4gICAgICovCisjZGVmaW5lIFdFUF9GTEFTSF9JTlRFUkxFQVZFCTIJLyogLi4uIG1hZGUgb2YgMiBjaGlwcyAqLyAKKyNkZWZpbmUgV0VQX0ZMQVNIX0JBTktfU0laRSAgMHgyMDAwMDAwICAvKiBzaXplIG9mIG9uZSBmbGFzaCBiYW5rKi8KKyNkZWZpbmUgV0VQX0ZMQVNIX1NFQ1RfU0laRSAgMHgwMDQwMDAwICAvKiBzaXplIG9mIGVyYXNlIHNlY3RvciAqLworI2RlZmluZSBXRVBfRkxBU0hfQkFTRSAgICAgICAweDAwMDAwMDAgIC8qIGxvY2F0aW9uIG9mIGZsYXNoIG1lbW9yeSAqLworI2RlZmluZSBXRVBfRkxBU0hfVU5MT0NLICAgICAgICAxICAgICAgIC8qIHBlcmZvcm0gaHcgdW5sb2NrIGZpcnN0ICovCisKKworLyogVGhpcyBzaG91bGQgYmUgZGVmaW5lZCBpZiBDRkkgRkxBU0ggZGV2aWNlIGlzIHByZXNlbnQuIEFjdHVhbGx5IGJlbmVmaXQKKyAgIGlzIG5vdCBzbyBjbGVhciB0byBtZS4gSW4gb3RoZXIgd29yZHMgd2UgY2FuIHByb3ZpZGUgbW9yZSBpbmZvcm1hdGlvbnMKKyAgIHRvIHVzZXIsIGJ1dCB0aGlzIGV4cGVjdHMgbW9yZSBjb21wbGV4IGZsYXNoIGhhbmRsaW5nIHdlIGRvIG5vdCBwcm92aWRlIAorICAgbm93LiovCisjdW5kZWYgIENGR19GTEFTSF9DRkkJCisKKyNkZWZpbmUgQ0ZHX0ZMQVNIX0VSQVNFX1RPVVQgICAgKDIqQ0ZHX0haKSAgICAvKiB0aW1lb3V0IGZvciBFcmFzZSBvcGVyYXRpb24gKi8KKyNkZWZpbmUgQ0ZHX0ZMQVNIX1dSSVRFX1RPVVQgICAgKDIqQ0ZHX0haKSAgICAvKiB0aW1lb3V0IGZvciBXcml0ZSBvcGVyYXRpb24gKi8KKworI2RlZmluZSBDRkdfRkxBU0hfQkFTRSAgICAgICAgICBXRVBfRkxBU0hfQkFTRQorCisvKgorICogVGhpcyBpcyBzZXR0aW5nIGZvciBKRkZTMiBzdXBwb3J0IGluIHUtYm9vdC4KKyAqIFJpZ2h0IG5vdyB0aGVyZSBpcyBubyBnYWluIGZvciB1c2VyLCBidXQgbGF0ZXIgb24gYm9vdGluZyBrZXJuZWwgbWlnaHQgYmUKKyAqIHBvc3NpYmxlLiBDb25zaWRlciB1c2luZyBYSVAga2VybmVsIHJ1bm5pbmcgZnJvbSBmbGFzaCB0byBzYXZlIFJBTQorICogZm9vdHByaW50LgorICogTk9URTogRW5hYmxlIENGR19DTURfSkZGUzIgZm9yIEpGRlMyIHN1cHBvcnQuCisgKi8KKyNkZWZpbmUgQ0ZHX0pGRlMyX0ZJUlNUX0JBTksJCTAKKyNkZWZpbmUgQ0ZHX0pGRlMyX0ZJUlNUX1NFQ1RPUgkJNQorI2RlZmluZSBDRkdfSkZGUzJfTlVNX0JBTktTCQkxCisKKy8qCisgKiBFbnZpcm9ubWVudCBzZXR1cC4gRGVmaW5pdGlvbnMgb2YgbW9uaXRvciBsb2NhdGlvbiBhbmQgc2l6ZSB3aXRoCisgKiBkZWZpbml0aW9uIG9mIGVudmlyb25tZW50IHNldHVwIGVuZHMgdXAgaW4gMiBwb3NzaWJpbGl0aWVzLgorICogMS4gRW1iZWRlZCBlbnZpcm9ubWVudCAtIGluIHUtYm9vdCBjb2RlIGlzIHNwYWNlIGZvciBlbnZpcm9ubWVudAorICogMi4gRW52aXJvbm1lbnQgaXMgcmVhZCBmcm9tIHByZWRlZmluZWQgc2VjdG9yIG9mIGZsYXNoCisgKiBSaWdodCBub3cgd2Ugc3VwcG9ydCAyLiBwb3NzaWJsaXR5LCBidXQgZXhwZWN0aW5nIG5vIGVudiBwbGFjZWQKKyAqIG9uIG1lbnRpb25lZCBhZGRyZXNzIHJpZ2h0IG5vdy4gVGhpcyBhbHNvIG5lZWRzIHRvIHByb3ZpZGUgd2hvbGUKKyAqIHNlY3RvciBmb3IgaXQgLSBmb3IgdXMgMjU2S2IgaXMgcmVhbGx5IHdhc3RlIG9mIG1lbW9yeS4gVS1ib290IHVzZXMKKyAqIGRlZmF1bHQgZW52LiBhbmQgdW50aWwga2VybmVsIHBhcmFtZXRlcnMgY291bGQgYmUgc2VudCB0byBrZXJuZWwKKyAqIGVudi4gaGFzIG5vIHNlbnNlIHRvIHVzLgorICovCisKKyNkZWZpbmUgQ0ZHX01PTklUT1JfQkFTRQlQSFlTX0ZMQVNIXzEKKyNkZWZpbmUgQ0ZHX01PTklUT1JfTEVOCQkweDIwMDAwCQkvKiAxMjhrYiAoIDEgZmxhc2ggc2VjdG9yICkgICovCisjZGVmaW5lIENGR19FTlZfSVNfSU5fRkxBU0gJMQorI2RlZmluZSBDRkdfRU5WX0FERFIJCTB4MjAwMDAJICAgICAgICAvKiBhYnNvbHV0ZSBhZGRyZXNzIGZvciBub3cgICovCisjZGVmaW5lIENGR19FTlZfU0laRQkJMHgyMDAwCSAgICAgICAgCisKKyN1bmRlZiAgQ09ORklHX0VOVl9PVkVSV1JJVEUgICAgICAgICAgICAgICAgICAgIC8qIGVudiBpcyBub3Qgd3JpdGFibGUgbm93ICAgKi8KKworLyoKKyAqIFdlbGwgdGhpcyBoYXMgdG8gYmUgZGVmaW5lZCwgYnV0IG9uIHRoZSBvdGhlciBoYW5kIGl0IGlzIHVzZWQgZGlmZmVyZW50bHkKKyAqIG9uZSBtYXkgZXhwZWN0LiBGb3IgaW5zdGFuY2UgbG9hZGIgY29tbWFuZCBkbyBub3QgY2FyZXMgOi0pCisgKiBTbyBhZHZpY2UgaXMgLSBkbyBub3QgcmVsYXkgb24gdGhpcy4uLgorICovCisjZGVmaW5lIENGR19MT0FEX0FERFIgICAgICAgIDB4NDAwMDAKKworI2VuZGlmICAvKiBfX0NPTkZJR19IICovCisKZGlmZiAtLWdpdCBhL2xpYl9hcm0vYm9hcmQuYyBiL2xpYl9hcm0vYm9hcmQuYwppbmRleCA4MjhjMmYyLi5hNzI1YzI0IDEwMDY0NAotLS0gYS9saWJfYXJtL2JvYXJkLmMKKysrIGIvbGliX2FybS9ib2FyZC5jCkBAIC0xOTAsNiArMTkwLDcgQEAKIAlnZF90IGdkX2RhdGE7CiAJYmRfdCBiZF9kYXRhOwogCWluaXRfZm5jX3QgKippbml0X2ZuY19wdHI7CisJY2hhciAqczsKICNpZiBkZWZpbmVkKENPTkZJR19WRkQpCiAJdW5zaWduZWQgbG9uZyBhZGRyOwogI2VuZGlmCkBAIC0yNzQsNiArMjc1LDE2IEBACiAJY3M4OTAwX2dldF9lbmV0YWRkciAoZ2QtPmJkLT5iaV9lbmV0YWRkcik7CiAjZW5kaWYKIAorCS8qIEluaXRpYWxpemUgZnJvbSBlbnZpcm9ubWVudCAqLworCWlmICgocyA9IGdldGVudiAoImxvYWRhZGRyIikpICE9IE5VTEwpIHsKKwkJbG9hZF9hZGRyID0gc2ltcGxlX3N0cnRvdWwgKHMsIE5VTEwsIDE2KTsKKwl9CisjaWYgKENPTkZJR19DT01NQU5EUyAmIENGR19DTURfTkVUKQorCWlmICgocyA9IGdldGVudiAoImJvb3RmaWxlIikpICE9IE5VTEwpIHsKKwkJY29weV9maWxlbmFtZSAoQm9vdEZpbGUsIHMsIHNpemVvZiAoQm9vdEZpbGUpKTsKKwl9CisjZW5kaWYJLyogQ0ZHX0NNRF9ORVQgKi8KKwogI2lmZGVmIEJPQVJEX1BPU1RfSU5JVAogCWJvYXJkX3Bvc3RfaW5pdCAoKTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvbGliX21pcHMvYm9hcmQuYyBiL2xpYl9taXBzL2JvYXJkLmMKaW5kZXggYTA3Y2IzZi4uNGJhYjNjNSAxMDA2NDQKLS0tIGEvbGliX21pcHMvYm9hcmQuYworKysgYi9saWJfbWlwcy9ib2FyZC5jCkBAIC0xNzcsNiArMTc3LDkgQEAKIAliZF90ICpiZDsKIAlpbml0X2ZuY190ICoqaW5pdF9mbmNfcHRyOwogCXVsb25nIGFkZHIsIGFkZHJfc3AsIGxlbiAgID0gQ0ZHX01PTklUT1JfTEVOOworI2lmZGVmIENPTkZJR19QVVJQTEUKKwl2b2lkIGNvcHlfY29kZSAodWxvbmcpOworI2VuZGlmCiAKIAkJLyogUG9pbnRlciBpcyB3cml0YWJsZSBzaW5jZSB3ZSBhbGxvY2F0ZWQgYSByZWdpc3RlciBmb3IgaXQuCiAJCSAqLwpAQCAtMjcxLDYgKzI3NCwxNCBAQAogCWJkLT5iaV9iYXVkcmF0ZQk9IGdkLT5iYXVkcmF0ZTsJCS8qIENvbnNvbGUgQmF1ZHJhdGUgKi8KIAogCW1lbWNweSAoaWQsIGdkLCBzaXplb2YgKGdkX3QpKTsKKworCS8qIE9uIHRoZSBwdXJwbGUgYm9hcmQgd2UgY29weSB0aGUgY29kZSBpbiBhIHNwZWNpYWwgd2F5CisJICogaW4gb3JkZXIgdG8gc29sdmUgZmxhc2ggcHJvYmxlbXMKKwkgKi8KKyNpZmRlZiBDT05GSUdfUFVSUExFCisJY29weV9jb2RlKGFkZHIpOworI2VuZGlmCisKIAlyZWxvY2F0ZV9jb2RlIChhZGRyX3NwLCBpZCwgYWRkcik7CiAKIAkvKiBOT1RSRUFDSEVEIC0gcmVsb2NhdGVfY29kZSgpIGRvZXMgbm90IHJldHVybiAqLwpAQCAtMzgzLDYgKzM5NCwyMSBAQAogCWNvbnNvbGVfaW5pdF9yICgpOwogLyoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqICoqLwogCisJLyogSW5pdGlhbGl6ZSBmcm9tIGVudmlyb25tZW50ICovCisJaWYgKChzID0gZ2V0ZW52ICgibG9hZGFkZHIiKSkgIT0gTlVMTCkgeworCQlsb2FkX2FkZHIgPSBzaW1wbGVfc3RydG91bCAocywgTlVMTCwgMTYpOworCX0KKyNpZiAoQ09ORklHX0NPTU1BTkRTICYgQ0ZHX0NNRF9ORVQpCisJaWYgKChzID0gZ2V0ZW52ICgiYm9vdGZpbGUiKSkgIT0gTlVMTCkgeworCQljb3B5X2ZpbGVuYW1lIChCb290RmlsZSwgcywgc2l6ZW9mIChCb290RmlsZSkpOworCX0KKyNlbmRpZgkvKiBDRkdfQ01EX05FVCAqLworCisjaWYgZGVmaW5lZChDT05GSUdfTUlTQ19JTklUX1IpCisJLyogbWlzY2VsbGFuZW91cyBwbGF0Zm9ybSBkZXBlbmRlbnQgaW5pdGlhbGlzYXRpb25zICovCisJbWlzY19pbml0X3IgKCk7CisjZW5kaWYKKwogI2lmIChDT05GSUdfQ09NTUFORFMgJiBDRkdfQ01EX05FVCkgJiYgZGVmaW5lZChDT05GSUdfTkVUX01VTFRJKQogCXB1dHMgKCJOZXQ6ICAgIik7CiAJZXRoX2luaXRpYWxpemUoZ2QtPmJkKTsKZGlmZiAtLWdpdCBhL25ldC9ib290cC5jIGIvbmV0L2Jvb3RwLmMKaW5kZXggZWY4Y2Q2MC4uZWU5NjU2YyAxMDA2NDQKLS0tIGEvbmV0L2Jvb3RwLmMKKysrIGIvbmV0L2Jvb3RwLmMKQEAgLTU5LDcgKzU5LDggQEAKIHN0YXRpYyB2b2lkIERoY3BIYW5kbGVyKHVjaGFyICogcGt0LCB1bnNpZ25lZCBkZXN0LCB1bnNpZ25lZCBzcmMsIHVuc2lnbmVkIGxlbik7CiAKIC8qIEZvciBEZWJ1ZyAqLwotY2hhciAqZGhjcG1zZzJzdHIoaW50IHR5cGUpCisjaWYgMAorc3RhdGljIGNoYXIgKmRoY3Btc2cyc3RyKGludCB0eXBlKQogewogCXN3aXRjaCAodHlwZSkgewogCWNhc2UgMTogIHJldHVybiAiREhDUERJU0NPVkVSIjsJYnJlYWs7CkBAIC03Miw2ICs3Myw3IEBACiAJZGVmYXVsdDogcmV0dXJuICJVTktOT1dOL0lOVkFMSUQgTVNHIFRZUEUiOyBicmVhazsKIAl9CiB9CisjZW5kaWYKIAogI2lmIChDT05GSUdfQk9PVFBfTUFTSyAmIENPTkZJR19CT09UUF9WRU5ET1JFWCkKIGV4dGVybiB1OCAqZGhjcF92ZW5kb3JleF9wcmVwICh1OCAqZSk7IC8qcnRuIG5ldyBlIGFmdGVyIGFkZCBvd24gb3B0cy4gKi8KQEAgLTExMiw3ICsxMTQsNyBAQAogLyoKICAqIENvcHkgcGFyYW1ldGVycyBvZiBpbnRlcmVzdCBmcm9tIEJPT1RQX1JFUExZL0RIQ1BfT0ZGRVIgcGFja2V0CiAgKi8KLXZvaWQgQm9vdHBDb3B5TmV0UGFyYW1zKEJvb3RwX3QgKmJwKQorc3RhdGljIHZvaWQgQm9vdHBDb3B5TmV0UGFyYW1zKEJvb3RwX3QgKmJwKQogewogCU5ldENvcHlJUCgmTmV0T3VySVAsICZicC0+YnBfeWlhZGRyKTsKIAlOZXRDb3B5SVAoJk5ldFNlcnZlcklQLCAmYnAtPmJwX3NpYWRkcik7CkBAIC02NzUsOSArNjc3LDkgQEAKIH0KIAogI2lmIChDT05GSUdfQ09NTUFORFMgJiBDRkdfQ01EX0RIQ1ApCi12b2lkIERoY3BPcHRpb25zUHJvY2VzcyhjaGFyICpwb3B0KQorc3RhdGljIHZvaWQgRGhjcE9wdGlvbnNQcm9jZXNzKHVjaGFyICpwb3B0KQogewotCWNoYXIgKmVuZCA9IHBvcHQgKyBCT09UUF9IRFJfU0laRTsKKwl1Y2hhciAqZW5kID0gcG9wdCArIEJPT1RQX0hEUl9TSVpFOwogCWludCBvcGxlbiwgc2l6ZTsKIAogCXdoaWxlICggcG9wdCA8IGVuZCAmJiAqcG9wdCAhPSAweGZmICkgewpAQCAtNzQ3LDcgKzc0OSw3IEBACiAJcmV0dXJuIC0xOwogfQogCi12b2lkIERoY3BTZW5kUmVxdWVzdFBrdChCb290cF90ICpicF9vZmZlcikKK3N0YXRpYyB2b2lkIERoY3BTZW5kUmVxdWVzdFBrdChCb290cF90ICpicF9vZmZlcikKIHsKIAl2b2xhdGlsZSB1Y2hhciAqcGt0LCAqaXBoZHI7CiAJQm9vdHBfdCAqYnA7CmRpZmYgLS1naXQgYS9uZXQvZXRoLmMgYi9uZXQvZXRoLmMKaW5kZXggODc0MmMxZS4uZTJkNjk5ZSAxMDA2NDQKLS0tIGEvbmV0L2V0aC5jCisrKyBiL25ldC9ldGguYwpAQCAtNDAsNiArNDAsNyBAQAogZXh0ZXJuIGludCBmZWNfaW5pdGlhbGl6ZShiZF90Kik7CiBleHRlcm4gaW50IHNjY19pbml0aWFsaXplKGJkX3QqKTsKIGV4dGVybiBpbnQgaW5jYV9zd2l0Y2hfaW5pdGlhbGl6ZShiZF90Kik7CitleHRlcm4gaW50IHBsYjI4MDBfZXRoX2luaXRpYWxpemUoYmRfdCopOwogCiBzdGF0aWMgc3RydWN0IGV0aF9kZXZpY2UgKmV0aF9kZXZpY2VzLCAqZXRoX2N1cnJlbnQ7CiAKQEAgLTk5LDYgKzEwMCw5IEBACiAjaWZkZWYgQ09ORklHX0lOQ0FfSVBfU1dJVENICiAJaW5jYV9zd2l0Y2hfaW5pdGlhbGl6ZShiaXMpOwogI2VuZGlmCisjaWZkZWYgQ09ORklHX1BMQjI4MDBfRVRIRVIKKwlwbGIyODAwX2V0aF9pbml0aWFsaXplKGJpcyk7CisjZW5kaWYKICNpZmRlZiBDT05GSUdfRUVQUk8xMDAKIAllZXBybzEwMF9pbml0aWFsaXplKGJpcyk7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL3Rvb2xzL01ha2VmaWxlIGIvdG9vbHMvTWFrZWZpbGUKaW5kZXggNDFiY2M1OS4uMzVjNjBiNiAxMDA2NDQKLS0tIGEvdG9vbHMvTWFrZWZpbGUKKysrIGIvdG9vbHMvTWFrZWZpbGUKQEAgLTI1LDYgKzI1LDExIEBACiAKIE9CSlMJPSBlbnZpcm9ubWVudC5vIGltZzJzcmVjLm8gbWtpbWFnZS5vIGNyYzMyLm8gZW52Y3JjLm8gZ2VuX2V0aF9hZGRyLm8gYm1wX2xvZ28ubwogCitpZmVxICgkKEFSQ0gpLG1pcHMpCitCSU5TICAgKz0gaW5jYS1zd2FwLWJ5dGVzJChTRlgpCitPQkpTICAgKz0gaW5jYS1zd2FwLWJ5dGVzLm8KK2VuZGlmCisKIExPR09fSAk9ICQoVE9QRElSKS9pbmNsdWRlL2JtcF9sb2dvLmgKIAogaWZlcSAoJChMT0dPX0JNUCksKQpAQCAtMTMzLDYgKzEzOCwxMCBAQAogCQkkKENDKSAkKENGTEFHUykgJChIT1NUX0xERkxBR1MpIC1vICRAICReCiAJCSQoU1RSSVApICRACiAKK2luY2Etc3dhcC1ieXRlcyQoU0ZYKToJaW5jYS1zd2FwLWJ5dGVzLm8KKwkJJChDQykgJChDRkxBR1MpICQoSE9TVF9MREZMQUdTKSAtbyAkQCAkXgorCQkkKFNUUklQKSAkQAorCiBlbnZjcmMubzoJZW52Y3JjLmMKIAkJJChDQykgLWcgJChDRkxBR1MpIC1jICQ8CiAKQEAgLTE0NSw2ICsxNTQsOSBAQAogZ2VuX2V0aF9hZGRyLm86CWdlbl9ldGhfYWRkci5jCiAJCSQoQ0MpIC1nICQoQ0ZMQUdTKSAtYyAkPAogCitpbmNhLXN3YXAtYnl0ZXMubzoJaW5jYS1zd2FwLWJ5dGVzLmMKKwkJJChDQykgLWcgJChDRkxBR1MpIC1jICQ8CisKIHN1YmRpcnM6CiAJCUBmb3IgZGlyIGluICQoVE9PTFNVQkRJUlMpIDsgZG8gXAogCQkgICAgJChNQUtFKSBcCmRpZmYgLS1naXQgYS90b29scy9pbmNhLXN3YXAtYnl0ZXMuYyBiL3Rvb2xzL2luY2Etc3dhcC1ieXRlcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNhNmQ4MmQKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9pbmNhLXN3YXAtYnl0ZXMuYwpAQCAtMCwwICsxLDM4IEBACisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKworI2lmbmRlZiBCVUZTSVoKKyMgZGVmaW5lIEJVRlNJWiA0MDk2CisjZW5kaWYKKworI3VuZGVmIEJVRlNJWgorIyBkZWZpbmUgQlVGU0laIDY0CitpbnQgbWFpbiAodm9pZCkKK3sKKwlzaG9ydCBpYnVmZltCVUZTSVpdLCBvYnVmZltCVUZTSVpdOworCWludCByYywgaSwgbGVuOworCisJd2hpbGUgKChyYyA9IHJlYWQgKDAsIGlidWZmLCBzaXplb2YgKGlidWZmKSkpID4gMCkgeworCQltZW1zZXQgKG9idWZmLCAwLCBzaXplb2YgKG9idWZmKSk7CisJCWZvciAoaSA9IDA7IGkgPCAocmMgKyAxKSAvIDI7IGkrKykgeworCQkJb2J1ZmZbaV0gPSBpYnVmZltpIF4gMV07CisJCX0KKworCQlsZW4gPSAocmMgKyAxKSAmIH4xOworCisJCWlmICh3cml0ZSAoMSwgb2J1ZmYsIGxlbikgIT0gbGVuKSB7CisJCQlwZXJyb3IgKCJyZWFkIGVycm9yIik7CisJCQlyZXR1cm4gKEVYSVRfRkFJTFVSRSk7CisJCX0KKworCQltZW1zZXQgKGlidWZmLCAwLCBzaXplb2YgKGlidWZmKSk7CisJfQorCisJaWYgKHJjIDwgMCkgeworCQlwZXJyb3IgKCJyZWFkIGVycm9yIik7CisJCXJldHVybiAoRVhJVF9GQUlMVVJFKTsKKwl9CisJcmV0dXJuIChFWElUX1NVQ0NFU1MpOworfQo=