ZGlmZiAtLWdpdCBhL3NyYy9NYWtlZmlsZSBiL3NyYy9NYWtlZmlsZQppbmRleCAwMjc0MjE0Li41YWM0Y2VlIDEwMDY0NAotLS0gYS9zcmMvTWFrZWZpbGUKKysrIGIvc3JjL01ha2VmaWxlCkBAIC0zNTQsMTAgKzM1NCwxNCBAQAogIyBEQVJXSU4gLSBkZXRlY3RpbmcgTWFjIE9TIFgKICMgVW5jb21tZW50IHRoaXMgbGluZSB3aGVuIHlvdSB3YW50IHRvIGNvbXBpbGUgYSBVbml4IHZlcnNpb24gb2YgVmltIG9uCiAjIERhcndpbi4gIE5vbmUgb2YgdGhlIE1hYyBzcGVjaWZpYyBvcHRpb25zIG9yIGZpbGVzIHdpbGwgYmUgdXNlZC4KLSMgWW91IGNhbiBhbHNvIGNoYW5nZSB0aGUgYXJjaGl0ZWN0dXJlIHN1cHBvcnRlZCwgZGVmYXVsdCBpcyB0byB0ZXN0IGZvciBib3RoLgogI0NPTkZfT1BUX0RBUldJTiA9IC0tZGlzYWJsZS1kYXJ3aW4KKworIyBTZWxlY3QgdGhlIGFyY2hpdGVjdHVyZSBzdXBwb3J0ZWQuICBEZWZhdWx0IGlzIHRvIGJ1aWxkIGZvciB0aGUgY3VycmVudAorIyBwbGF0Zm9ybS4gIFVzZSAiYm90aCIgZm9yIGEgdW5pdmVyc2FsIGJpbmFyeS4gIFRoYXQgcHJvYmFibHkgZG9lc24ndCB3b3JrCisjIHdoZW4gaW5jbHVkaW5nIFBlcmwsIFB5dGhvbiwgZXRjLgogI0NPTkZfT1BUX0RBUldJTiA9IC0td2l0aC1tYWMtYXJjaD1pMzg2CiAjQ09ORl9PUFRfREFSV0lOID0gLS13aXRoLW1hYy1hcmNoPXBwYworI0NPTkZfT1BUX0RBUldJTiA9IC0td2l0aC1tYWMtYXJjaD1ib3RoCiAKICMgUEVSTAogIyBVbmNvbW1lbnQgdGhpcyB3aGVuIHlvdSB3YW50IHRvIGluY2x1ZGUgdGhlIFBlcmwgaW50ZXJmYWNlLgpAQCAtMTMxOCw2ICsxMzIyLDggQEAKIERFU1RfTUFOX0lUID0gJChERVNUX01BTl9UT1ApL2l0JChNQU4xRElSKQogREVTVF9NQU5fSVRfSSA9ICQoREVTVF9NQU5fVE9QKS9pdC5JU084ODU5LTEkKE1BTjFESVIpCiBERVNUX01BTl9JVF9VID0gJChERVNUX01BTl9UT1ApL2l0LlVURi04JChNQU4xRElSKQorREVTVF9NQU5fUEwgPSAkKERFU1RfTUFOX1RPUCkvcGwuSVNPODg1OS0yJChNQU4xRElSKQorREVTVF9NQU5fUExfVSA9ICQoREVTVF9NQU5fVE9QKS9wbC5VVEYtOCQoTUFOMURJUikKIERFU1RfTUFOX1JVID0gJChERVNUX01BTl9UT1ApL3J1LktPSTgtUiQoTUFOMURJUikKIERFU1RfTUFOX1JVX1UgPSAkKERFU1RfTUFOX1RPUCkvcnUuVVRGLTgkKE1BTjFESVIpCiAKQEAgLTE4OTcsNiArMTkwMyw4IEBACiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9JVCkgIi1pdCIgJChJTlNUQUxMTUFOQVJHUykKIAktJChTSEVMTCkgLi9pbnN0YWxsbWFuLnNoIHh4ZCAkKERFU1RfTUFOX0lUX0kpICItaXQiICQoSU5TVEFMTE1BTkFSR1MpCiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9JVF9VKSAiLWl0LlVURi04IiAkKElOU1RBTExNQU5BUkdTKQorCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggeHhkICQoREVTVF9NQU5fUEwpICItcGwiICQoSU5TVEFMTE1BTkFSR1MpCisJLSQoU0hFTEwpIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9QTF9VKSAiLXBsLlVURi04IiAkKElOU1RBTExNQU5BUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggeHhkICQoREVTVF9NQU5fUlUpICItcnUiICQoSU5TVEFMTE1BTkFSR1MpCiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9SVV9VKSAiLXJ1LlVURi04IiAkKElOU1RBTExNQU5BUkdTKQogCkBAIC0xOTA4LDYgKzE5MTYsOCBAQAogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX0lUKSAiLWl0IiAkKElOU1RBTExNQU5BUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX0lUX0kpICItaXQiICQoSU5TVEFMTE1BTkFSR1MpCiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1hbi5zaCBpbnN0YWxsICQoREVTVF9NQU5fSVRfVSkgIi1pdC5VVEYtOCIgJChJTlNUQUxMTUFOQVJHUykKKwktJChTSEVMTCkgLi9pbnN0YWxsbWFuLnNoIGluc3RhbGwgJChERVNUX01BTl9QTCkgIi1wbCIgJChJTlNUQUxMTUFOQVJHUykKKwktJChTSEVMTCkgLi9pbnN0YWxsbWFuLnNoIGluc3RhbGwgJChERVNUX01BTl9QTF9VKSAiLXBsLlVURi04IiAkKElOU1RBTExNQU5BUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX1JVKSAiLXJ1IiAkKElOU1RBTExNQU5BUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX1JVX1UpICItcnUuVVRGLTgiICQoSU5TVEFMTE1BTkFSR1MpCiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1sLnNoIGluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXApAQCAtMTkyMyw2ICsxOTMzLDEwIEBACiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1sLnNoIGluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXAogCQkkKERFU1RfTUFOX0lUX1UpICQoSU5TVEFMTE1MQVJHUykKIAktJChTSEVMTCkgLi9pbnN0YWxsbWwuc2ggaW5zdGFsbCAiJChHVUlfTUFOX1RBUkdFVFMpIiBcCisJCSQoREVTVF9NQU5fUEwpICQoSU5TVEFMTE1MQVJHUykKKwktJChTSEVMTCkgLi9pbnN0YWxsbWwuc2ggaW5zdGFsbCAiJChHVUlfTUFOX1RBUkdFVFMpIiBcCisJCSQoREVTVF9NQU5fUExfVSkgJChJTlNUQUxMTUxBUkdTKQorCS0kKFNIRUxMKSAuL2luc3RhbGxtbC5zaCBpbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKIAkJJChERVNUX01BTl9SVSkgJChJTlNUQUxMTUxBUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtbC5zaCBpbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKIAkJJChERVNUX01BTl9SVV9VKSAkKElOU1RBTExNTEFSR1MpCkBAIC0yMDYxLDYgKzIwNzUsOCBAQAogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fSVQpICIiICQoSU5TVEFMTE1BTkFSR1MpCiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1hbi5zaCB1bmluc3RhbGwgJChERVNUX01BTl9JVF9JKSAiIiAkKElOU1RBTExNQU5BUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fSVRfVSkgIiIgJChJTlNUQUxMTUFOQVJHUykKKwktJChTSEVMTCkgLi9pbnN0YWxsbWFuLnNoIHVuaW5zdGFsbCAkKERFU1RfTUFOX1BMKSAiIiAkKElOU1RBTExNQU5BUkdTKQorCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fUExfVSkgIiIgJChJTlNUQUxMTUFOQVJHUykKIAktJChTSEVMTCkgLi9pbnN0YWxsbWFuLnNoIHVuaW5zdGFsbCAkKERFU1RfTUFOX1JVKSAiIiAkKElOU1RBTExNQU5BUkdTKQogCS0kKFNIRUxMKSAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fUlVfVSkgIiIgJChJTlNUQUxMTUFOQVJHUykKIAktJChTSEVMTCkgLi9pbnN0YWxsbWwuc2ggdW5pbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKQEAgLTIwNzgsMTIgKzIwOTQsMTcgQEAKIAktJChTSEVMTCkgLi9pbnN0YWxsbWwuc2ggdW5pbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKIAkJJChERVNUX01BTl9JVF9VKSAkKElOU1RBTExNTEFSR1MpCiAJLSQoU0hFTEwpIC4vaW5zdGFsbG1sLnNoIHVuaW5zdGFsbCAiJChHVUlfTUFOX1RBUkdFVFMpIiBcCisJCSQoREVTVF9NQU5fUEwpICQoSU5TVEFMTE1MQVJHUykKKwktJChTSEVMTCkgLi9pbnN0YWxsbWwuc2ggdW5pbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKKwkJJChERVNUX01BTl9QTF9VKSAkKElOU1RBTExNTEFSR1MpCisJLSQoU0hFTEwpIC4vaW5zdGFsbG1sLnNoIHVuaW5zdGFsbCAiJChHVUlfTUFOX1RBUkdFVFMpIiBcCiAJCSQoREVTVF9NQU5fUlUpICQoSU5TVEFMTE1MQVJHUykKIAktJChTSEVMTCkgLi9pbnN0YWxsbWwuc2ggdW5pbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKIAkJJChERVNUX01BTl9SVV9VKSAkKElOU1RBTExNTEFSR1MpCiAJLXJtIC1mICQoREVTVF9NQU4pL3h4ZC4xCiAJLXJtIC1mICQoREVTVF9NQU5fRlIpL3h4ZC4xICQoREVTVF9NQU5fRlJfSSkveHhkLjEgJChERVNUX01BTl9GUl9VKS94eGQuMQogCS1ybSAtZiAkKERFU1RfTUFOX0lUKS94eGQuMSAkKERFU1RfTUFOX0lUX0kpL3h4ZC4xICQoREVTVF9NQU5fSVRfVSkveHhkLjEKKwktcm0gLWYgJChERVNUX01BTl9QTCkveHhkLjEgJChERVNUX01BTl9QTF9VKS94eGQuMQogCS1ybSAtZiAkKERFU1RfTUFOX1JVKS94eGQuMSAkKERFU1RfTUFOX1JVX1UpL3h4ZC4xCiAJLXJtIC1mICQoREVTVF9IRUxQKS8qLnR4dCAkKERFU1RfSEVMUCkvdGFncyAkKERFU1RfSEVMUCkvKi5wbAogCS1ybSAtZiAkKERFU1RfSEVMUCkvKi4/P3ggJChERVNUX0hFTFApL3RhZ3MtPz8KZGlmZiAtLWdpdCBhL3NyYy9hdXRvL2NvbmZpZ3VyZSBiL3NyYy9hdXRvL2NvbmZpZ3VyZQppbmRleCAyMmY3MjRlLi5mMTE3OGY4IDEwMDc1NQotLS0gYS9zcmMvYXV0by9jb25maWd1cmUKKysrIGIvc3JjL2F1dG8vY29uZmlndXJlCkBAIC04NzYsNyArODc2LDcgQEAKIE9wdGlvbmFsIFBhY2thZ2VzOgogICAtLXdpdGgtUEFDS0FHRVs9QVJHXSAgICB1c2UgUEFDS0FHRSBbQVJHPXllc10KICAgLS13aXRob3V0LVBBQ0tBR0UgICAgICAgZG8gbm90IHVzZSBQQUNLQUdFIChzYW1lIGFzIC0td2l0aC1QQUNLQUdFPW5vKQotICAtLXdpdGgtbWFjLWFyY2g9QVJDSCAgICBpbnRlbCwgcHBjIG9yIGJvdGgKKyAgLS13aXRoLW1hYy1hcmNoPUFSQ0ggICAgY3VycmVudCwgaW50ZWwsIHBwYyBvciBib3RoCiAgIC0td2l0aC12aW0tbmFtZT1OQU1FICAgIHdoYXQgdG8gY2FsbCB0aGUgVmltIGV4ZWN1dGFibGUKICAgLS13aXRoLWV4LW5hbWU9TkFNRSAgICAgd2hhdCB0byBjYWxsIHRoZSBFeCBleGVjdXRhYmxlCiAgIC0td2l0aC12aWV3LW5hbWU9TkFNRSAgIHdoYXQgdG8gY2FsbCB0aGUgVmlldyBleGVjdXRhYmxlCkBAIC0yODc0LDcgKzI4NzQsNyBAQAogICBNQUNBUkNIPSIkd2l0aHZhbCI7IGVjaG8gIiRhc19tZTokTElORU5POiByZXN1bHQ6ICRNQUNBUkNIIiA+JjUKIGVjaG8gIiR7RUNIT19UfSRNQUNBUkNIIiA+JjYKIGVsc2UKLSAgTUFDQVJDSD0iYm90aCI7IGVjaG8gIiRhc19tZTokTElORU5POiByZXN1bHQ6IGRlZmF1bHRpbmcgdG8gJE1BQ0FSQ0giID4mNQorICBNQUNBUkNIPSJjdXJyZW50IjsgZWNobyAiJGFzX21lOiRMSU5FTk86IHJlc3VsdDogZGVmYXVsdGluZyB0byAkTUFDQVJDSCIgPiY1CiBlY2hvICIke0VDSE9fVH1kZWZhdWx0aW5nIHRvICRNQUNBUkNIIiA+JjYKIGZpOwogCmRpZmYgLS1naXQgYS9zcmMvYnVmZmVyLmMgYi9zcmMvYnVmZmVyLmMKaW5kZXggMzcyMzg2My4uNDM5YjVmMiAxMDA2NDQKLS0tIGEvc3JjL2J1ZmZlci5jCisrKyBiL3NyYy9idWZmZXIuYwpAQCAtMzcwNyw3ICszNzA3LDcgQEAKIAkgICAgaXRlbWlzZmxhZyA9IFRSVUU7CiAJICAgIGlmICh3cC0+d19idWZmZXItPmJfaGVscCkKIAkJc3RyID0gKGNoYXJfdSAqKSgob3B0ID09IFNUTF9IRUxQRkxBR19BTFQpID8gIixITFAiCi0JCQkJCQkJICAgICAgIDogXygiW2hlbHBdIikpOworCQkJCQkJCSAgICAgICA6IF8oIltIZWxwXSIpKTsKIAkgICAgYnJlYWs7CiAKICNpZmRlZiBGRUFUX0FVVE9DTUQKQEAgLTQ5NzUsNyArNDk3NSw3IEBACiAJaWYgKHdpbiAhPSBOVUxMICYmIHdpbi0+d19sbGlzdF9yZWYgIT0gTlVMTCkKIAkgICAgcmV0dXJuIF8oIltMb2NhdGlvbiBMaXN0XSIpOwogCWVsc2UKLQkgICAgcmV0dXJuIF8oIltFcnJvciBMaXN0XSIpOworCSAgICByZXR1cm4gXygiW1F1aWNrZml4IExpc3RdIik7CiAgICAgfQogI2VuZGlmCiAjaWZkZWYgRkVBVF9RVUlDS0ZJWApkaWZmIC0tZ2l0IGEvc3JjL2NvbmZpZ3VyZS5pbiBiL3NyYy9jb25maWd1cmUuaW4KaW5kZXggZjc2NDhhOC4uMjU2OGZjMyAxMDA2NDQKLS0tIGEvc3JjL2NvbmZpZ3VyZS5pbgorKysgYi9zcmMvY29uZmlndXJlLmluCkBAIC0xMDMsOSArMTAzLDkgQEAKICAgZmkKIAogICBBQ19NU0dfQ0hFQ0tJTkcoLS13aXRoLW1hYy1hcmNoIGFyZ3VtZW50KQotICBBQ19BUkdfV0lUSChtYWMtYXJjaCwgWyAgLS13aXRoLW1hYy1hcmNoPUFSQ0ggICAgaW50ZWwsIHBwYyBvciBib3RoXSwKKyAgQUNfQVJHX1dJVEgobWFjLWFyY2gsIFsgIC0td2l0aC1tYWMtYXJjaD1BUkNIICAgIGN1cnJlbnQsIGludGVsLCBwcGMgb3IgYm90aF0sCiAJTUFDQVJDSD0iJHdpdGh2YWwiOyBBQ19NU0dfUkVTVUxUKCRNQUNBUkNIKSwKLQlNQUNBUkNIPSJib3RoIjsgQUNfTVNHX1JFU1VMVChkZWZhdWx0aW5nIHRvICRNQUNBUkNIKSkKKwlNQUNBUkNIPSJjdXJyZW50IjsgQUNfTVNHX1JFU1VMVChkZWZhdWx0aW5nIHRvICRNQUNBUkNIKSkKIAogICBpZiB0ZXN0ICJ4JE1BQ0FSQ0giID0gInhib3RoIjsgdGhlbgogICAgIEFDX01TR19DSEVDS0lORyhmb3IgMTAuNCB1bml2ZXJzYWwgU0RLKQpkaWZmIC0tZ2l0IGEvc3JjL2V2YWwuYyBiL3NyYy9ldmFsLmMKaW5kZXggZTgwNDA3ZS4uNjNhYmNiYSAxMDA2NDQKLS0tIGEvc3JjL2V2YWwuYworKysgYi9zcmMvZXZhbC5jCkBAIC04OTY0LDQyICs4OTY0LDU0IEBACiAgICAgY2hhcl91CXBhdGhidWZbTlVNQlVGTEVOXTsKICAgICBpbnQJCWNvdW50ID0gMTsKICAgICBpbnQJCWZpcnN0ID0gVFJVRTsKKyAgICBpbnQJCWVycm9yID0gRkFMU0U7CisjZW5kaWYKIAorICAgIHJldHR2LT52dmFsLnZfc3RyaW5nID0gTlVMTDsKKyAgICByZXR0di0+dl90eXBlID0gVkFSX1NUUklORzsKKworI2lmZGVmIEZFQVRfU0VBUkNIUEFUSAogICAgIGZuYW1lID0gZ2V0X3R2X3N0cmluZygmYXJndmFyc1swXSk7CiAKICAgICBpZiAoYXJndmFyc1sxXS52X3R5cGUgIT0gVkFSX1VOS05PV04pCiAgICAgewogCXAgPSBnZXRfdHZfc3RyaW5nX2J1Zl9jaGsoJmFyZ3ZhcnNbMV0sIHBhdGhidWYpOwogCWlmIChwID09IE5VTEwpCi0JICAgIGNvdW50ID0gLTE7CSAgICAvKiBlcnJvciAqLworCSAgICBlcnJvciA9IFRSVUU7CiAJZWxzZQogCXsKIAkgICAgaWYgKCpwICE9IE5VTCkKIAkJcGF0aCA9IHA7CiAKIAkgICAgaWYgKGFyZ3ZhcnNbMl0udl90eXBlICE9IFZBUl9VTktOT1dOKQotCQljb3VudCA9IGdldF90dl9udW1iZXJfY2hrKCZhcmd2YXJzWzJdLCBOVUxMKTsgLyogLTE6IGVycm9yICovCisJCWNvdW50ID0gZ2V0X3R2X251bWJlcl9jaGsoJmFyZ3ZhcnNbMl0sICZlcnJvcik7CiAJfQogICAgIH0KIAotICAgIGlmICgqZm5hbWUgIT0gTlVMICYmIGNvdW50ID49IDApCisgICAgaWYgKGNvdW50IDwgMCAmJiByZXR0dl9saXN0X2FsbG9jKHJldHR2KSA9PSBGQUlMKQorCWVycm9yID0gVFJVRTsKKworICAgIGlmICgqZm5hbWUgIT0gTlVMICYmICFlcnJvcikKICAgICB7CiAJZG8KIAl7Ci0JICAgIHZpbV9mcmVlKGZyZXN1bHQpOworCSAgICBpZiAocmV0dHYtPnZfdHlwZSA9PSBWQVJfU1RSSU5HKQorCQl2aW1fZnJlZShmcmVzdWx0KTsKIAkgICAgZnJlc3VsdCA9IGZpbmRfZmlsZV9pbl9wYXRoX29wdGlvbihmaXJzdCA/IGZuYW1lIDogTlVMTCwKIAkJCQkJICAgICAgIGZpcnN0ID8gKGludClTVFJMRU4oZm5hbWUpIDogMCwKIAkJCQkJMCwgZmlyc3QsIHBhdGgsIGRpciwgTlVMTCwKIAkJCQkJZGlyID8gKGNoYXJfdSAqKSIiIDogY3VyYnVmLT5iX3Bfc3VhKTsKIAkgICAgZmlyc3QgPSBGQUxTRTsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCAmJiBmcmVzdWx0ICE9IE5VTEwpOworCisJICAgIGlmIChmcmVzdWx0ICE9IE5VTEwgJiYgcmV0dHYtPnZfdHlwZSA9PSBWQVJfTElTVCkKKwkJbGlzdF9hcHBlbmRfc3RyaW5nKHJldHR2LT52dmFsLnZfbGlzdCwgZnJlc3VsdCwgLTEpOworCisJfSB3aGlsZSAoKHJldHR2LT52X3R5cGUgPT0gVkFSX0xJU1QgfHwgLS1jb3VudCA+IDApICYmIGZyZXN1bHQgIT0gTlVMTCk7CiAgICAgfQogCi0gICAgcmV0dHYtPnZ2YWwudl9zdHJpbmcgPSBmcmVzdWx0OwotI2Vsc2UKLSAgICByZXR0di0+dnZhbC52X3N0cmluZyA9IE5VTEw7CisgICAgaWYgKHJldHR2LT52X3R5cGUgPT0gVkFSX1NUUklORykKKwlyZXR0di0+dnZhbC52X3N0cmluZyA9IGZyZXN1bHQ7CiAjZW5kaWYKLSAgICByZXR0di0+dl90eXBlID0gVkFSX1NUUklORzsKIH0KIAogc3RhdGljIHZvaWQgZmlsdGVyX21hcCBfX0FSR1MoKHR5cHZhbF9UICphcmd2YXJzLCB0eXB2YWxfVCAqcmV0dHYsIGludCBtYXApKTsKQEAgLTE4NjczLDggKzE4Njg1LDkgQEAKICAgICBlbHNlIGlmIChsZWFkID4gMCkKICAgICB7CiAJbGVhZCA9IDM7Ci0JaWYgKGV2YWxfZm5hbWVfc2lkKCpwcCkpCS8qIElmIGl0J3MgIjxTSUQ+IiAqLworCWlmIChldmFsX2ZuYW1lX3NpZChsdi5sbF9leHBfbmFtZSAhPSBOVUxMID8gbHYubGxfZXhwX25hbWUgOiAqcHApKQogCXsKKwkgICAgLyogSXQncyAiczoiIG9yICI8U0lEPiIgKi8KIAkgICAgaWYgKGN1cnJlbnRfU0lEIDw9IDApCiAJICAgIHsKIAkJRU1TRyhfKGVfdXNpbmdzaWQpKTsKZGlmZiAtLWdpdCBhL3NyYy9tYWluLmFhcCBiL3NyYy9tYWluLmFhcAppbmRleCBmYTc5MTdiLi5hNGRlNjMxIDEwMDY0NAotLS0gYS9zcmMvbWFpbi5hYXAKKysrIGIvc3JjL21haW4uYWFwCkBAIC02NTgsNiArNjU4LDggQEAKIERFU1RfTUFOX0lUID0gJChERVNUX01BTl9UT1ApL2l0JChNQU4xRElSKQogREVTVF9NQU5fSVRfSSA9ICQoREVTVF9NQU5fVE9QKS9pdC5JU084ODU5LTEkKE1BTjFESVIpCiBERVNUX01BTl9JVF9VID0gJChERVNUX01BTl9UT1ApL2l0LlVURi04JChNQU4xRElSKQorREVTVF9NQU5fUEwgPSAkKERFU1RfTUFOX1RPUCkvcGwuSVNPODg1OS0yJChNQU4xRElSKQorREVTVF9NQU5fUExfVSA9ICQoREVTVF9NQU5fVE9QKS9wbC5VVEYtOCQoTUFOMURJUikKIERFU1RfTUFOX1JVID0gJChERVNUX01BTl9UT1ApL3J1LktPSTgtUiQoTUFOMURJUikKIERFU1RfTUFOX1JVX1UgPSAkKERFU1RfTUFOX1RPUCkvcnUuVVRGLTgkKE1BTjFESVIpCiAKQEAgLTY2Nyw3ICs2NjksOSBAQAogICAgICAgICAgICAgICAgICRERVNUX0NPTVAgJERFU1RfS01BUCAkREVTVF9NQUNSTyAkREVTVF9UT09MUyAkREVTVF9UVVRPUgogICAgICAgICAgICAgICAgICRERVNUX1NDUklQVCAkREVTVF9QUklOVCAkREVTVF9NQU4gJERFU1RfU1BFTEwKICAgICAgICAgICAgICAgICAkREVTVF9NQU5fRlIgJERFU1RfTUFOX0ZSX0kgJERFU1RfTUFOX0ZSX1UgJERFU1RfTUFOX0lUCi0gICAgICAgICAgICAgICAgJERFU1RfTUFOX0lUX0kgJERFU1RfTUFOX0lUX1UgJERFU1RfTUFOX1JVICRERVNUX01BTl9SVV9VCisgICAgICAgICAgICAgICAgJERFU1RfTUFOX0lUX0kgJERFU1RfTUFOX0lUX1UKKyAgICAgICAgICAgICAgICAkREVTVF9NQU5fUEwgJERFU1RfTUFOX1BMX1UKKyAgICAgICAgICAgICAgICAkREVTVF9NQU5fUlUgJERFU1RfTUFOX1JVX1UKIAogIwogIyBJIE4gUyBUIEEgTCBMCkBAIC04OTMsNiArODk3LDggQEAKIAk6c3lzIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9JVCkgIi1pdCIgJChJTlNUQUxMTUFOQVJHUykKIAk6c3lzIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9JVF9JKSAiLWl0IiAkKElOU1RBTExNQU5BUkdTKQogCTpzeXMgLi9pbnN0YWxsbWFuLnNoIHh4ZCAkKERFU1RfTUFOX0lUX1UpICItaXQuVVRGLTgiICQoSU5TVEFMTE1BTkFSR1MpCisJOnN5cyAuL2luc3RhbGxtYW4uc2ggeHhkICQoREVTVF9NQU5fUEwpICItcGwiICQoSU5TVEFMTE1BTkFSR1MpCisJOnN5cyAuL2luc3RhbGxtYW4uc2ggeHhkICQoREVTVF9NQU5fUExfVSkgIi1wbC5VVEYtOCIgJChJTlNUQUxMTUFOQVJHUykKIAk6c3lzIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9SVSkgIi1ydSIgJChJTlNUQUxMTUFOQVJHUykKIAk6c3lzIC4vaW5zdGFsbG1hbi5zaCB4eGQgJChERVNUX01BTl9SVV9VKSAiLXJ1LlVURi04IiAkKElOU1RBTExNQU5BUkdTKQogCkBAIC05MDQsNiArOTEwLDggQEAKIAk6c3lzIC4vaW5zdGFsbG1hbi5zaCBpbnN0YWxsICQoREVTVF9NQU5fSVQpICItaXQiICQoSU5TVEFMTE1BTkFSR1MpCiAJOnN5cyAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX0lUX0kpICItaXQiICQoSU5TVEFMTE1BTkFSR1MpCiAJOnN5cyAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX0lUX1UpICItaXQuVVRGLTgiICQoSU5TVEFMTE1BTkFSR1MpCisJOnN5cyAuL2luc3RhbGxtYW4uc2ggaW5zdGFsbCAkKERFU1RfTUFOX1BMKSAiLXBsIiAkKElOU1RBTExNQU5BUkdTKQorCTpzeXMgLi9pbnN0YWxsbWFuLnNoIGluc3RhbGwgJChERVNUX01BTl9QTF9VKSAiLXBsLlVURi04IiAkKElOU1RBTExNQU5BUkdTKQogCTpzeXMgLi9pbnN0YWxsbWFuLnNoIGluc3RhbGwgJChERVNUX01BTl9SVSkgIi1ydSIgJChJTlNUQUxMTUFOQVJHUykKIAk6c3lzIC4vaW5zdGFsbG1hbi5zaCBpbnN0YWxsICQoREVTVF9NQU5fUlVfVSkgIi1ydS5VVEYtOCIgJChJTlNUQUxMTUFOQVJHUykKIAk6c3lzIC4vaW5zdGFsbG1sLnNoIGluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXApAQCAtOTE5LDYgKzkyNywxMCBAQAogICAgICAgICA6c3lzIC4vaW5zdGFsbG1sLnNoIGluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXAogCQkkKERFU1RfTUFOX0lUX1UpICQoSU5TVEFMTE1MQVJHUykKICAgICAgICAgOnN5cyAuL2luc3RhbGxtbC5zaCBpbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKKwkJJChERVNUX01BTl9QTCkgJChJTlNUQUxMTUxBUkdTKQorICAgICAgICA6c3lzIC4vaW5zdGFsbG1sLnNoIGluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXAorCQkkKERFU1RfTUFOX1BMX1UpICQoSU5TVEFMTE1MQVJHUykKKyAgICAgICAgOnN5cyAuL2luc3RhbGxtbC5zaCBpbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKIAkJJChERVNUX01BTl9SVSkgJChJTlNUQUxMTUxBUkdTKQogICAgICAgICA6c3lzIC4vaW5zdGFsbG1sLnNoIGluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXAogCQkkKERFU1RfTUFOX1JVX1UpICQoSU5TVEFMTE1MQVJHUykKQEAgLTEwNDksNiArMTA2MSw4IEBACiAgICAgOnN5cyAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fSVQpICIiICQoSU5TVEFMTE1BTkFSR1MpCiAgICAgOnN5cyAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fSVRfSSkgIiIgJChJTlNUQUxMTUFOQVJHUykKICAgICA6c3lzIC4vaW5zdGFsbG1hbi5zaCB1bmluc3RhbGwgJChERVNUX01BTl9JVF9VKSAiIiAkKElOU1RBTExNQU5BUkdTKQorICAgIDpzeXMgLi9pbnN0YWxsbWFuLnNoIHVuaW5zdGFsbCAkKERFU1RfTUFOX1BMKSAiIiAkKElOU1RBTExNQU5BUkdTKQorICAgIDpzeXMgLi9pbnN0YWxsbWFuLnNoIHVuaW5zdGFsbCAkKERFU1RfTUFOX1BMX1UpICIiICQoSU5TVEFMTE1BTkFSR1MpCiAgICAgOnN5cyAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fUlUpICIiICQoSU5TVEFMTE1BTkFSR1MpCiAgICAgOnN5cyAuL2luc3RhbGxtYW4uc2ggdW5pbnN0YWxsICQoREVTVF9NQU5fUlVfVSkgIiIgJChJTlNUQUxMTUFOQVJHUykKICAgICA6c3lzIC4vaW5zdGFsbG1sLnNoIHVuaW5zdGFsbCAiJChHVUlfTUFOX1RBUkdFVFMpIiBcCkBAIC0xMDY2LDEyICsxMDgwLDE3IEBACiAgICAgOnN5cyAuL2luc3RhbGxtbC5zaCB1bmluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXAogICAgICAgICAgICAgJChERVNUX01BTl9JVF9VKSAkKElOU1RBTExNTEFSR1MpCiAgICAgOnN5cyAuL2luc3RhbGxtbC5zaCB1bmluc3RhbGwgIiQoR1VJX01BTl9UQVJHRVRTKSIgXAorICAgICAgICAgICAgJChERVNUX01BTl9QTCkgJChJTlNUQUxMTUxBUkdTKQorICAgIDpzeXMgLi9pbnN0YWxsbWwuc2ggdW5pbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKKyAgICAgICAgICAgICQoREVTVF9NQU5fUExfVSkgJChJTlNUQUxMTUxBUkdTKQorICAgIDpzeXMgLi9pbnN0YWxsbWwuc2ggdW5pbnN0YWxsICIkKEdVSV9NQU5fVEFSR0VUUykiIFwKICAgICAgICAgICAgICQoREVTVF9NQU5fUlUpICQoSU5TVEFMTE1MQVJHUykKICAgICA6c3lzIC4vaW5zdGFsbG1sLnNoIHVuaW5zdGFsbCAiJChHVUlfTUFOX1RBUkdFVFMpIiBcCiAgICAgICAgICAgICAkKERFU1RfTUFOX1JVX1UpICQoSU5TVEFMTE1MQVJHUykKICAgICA6ZGVsIHtmb3JjZX0gJERFU1RfTUFOL3h4ZC4xCiAgICAgOmRlbCB7Zm9yY2V9ICQoREVTVF9NQU5fRlIpL3h4ZC4xICQoREVTVF9NQU5fRlJfSSkveHhkLjEgJChERVNUX01BTl9GUl9VKS94eGQuMQogICAgIDpkZWwge2ZvcmNlfSAkKERFU1RfTUFOX0lUKS94eGQuMSAkKERFU1RfTUFOX0lUX0kpL3h4ZC4xICQoREVTVF9NQU5fSVRfVSkveHhkLjEKKyAgICA6ZGVsIHtmb3JjZX0gJChERVNUX01BTl9QTCkveHhkLjEgJChERVNUX01BTl9QTF9VKS94eGQuMQogICAgIDpkZWwge2ZvcmNlfSAkKERFU1RfTUFOX1JVKS94eGQuMSAkKERFU1RfTUFOX1JVX1UpL3h4ZC4xCiAKICAgICA6ZGVsIHtmb3JjZX0gJERFU1RfSEVMUC8qLnR4dCAkREVTVF9IRUxQL3RhZ3MgJERFU1RfSEVMUC8qLnBsCmRpZmYgLS1naXQgYS9zcmMvc2NyZWVuLmMgYi9zcmMvc2NyZWVuLmMKaW5kZXggMGU4Yjg2Ny4uNjBmZmU5OSAxMDA2NDQKLS0tIGEvc3JjL3NjcmVlbi5jCisrKyBiL3NyYy9zY3JlZW4uYwpAQCAtNTUyOCw3ICs1NTI4LDcgQEAKIAkgICAgKihwICsgbGVuKyspID0gJyAnOwogCWlmICh3cC0+d19idWZmZXItPmJfaGVscCkKIAl7Ci0JICAgIFNUUkNQWShwICsgbGVuLCBfKCJbaGVscF0iKSk7CisJICAgIFNUUkNQWShwICsgbGVuLCBfKCJbSGVscF0iKSk7CiAJICAgIGxlbiArPSAoaW50KVNUUkxFTihwICsgbGVuKTsKIAl9CiAjaWZkZWYgRkVBVF9RVUlDS0ZJWApkaWZmIC0tZ2l0IGEvc3JjL3NwZWxsLmMgYi9zcmMvc3BlbGwuYwppbmRleCA0YTY1YWVlLi5jMmJmNThkIDEwMDY0NAotLS0gYS9zcmMvc3BlbGwuYworKysgYi9zcmMvc3BlbGwuYwpAQCAtMTg1LDE0ICsxODUsMjEgQEAKICAqIDxtYXBzdHI+CSBOIGJ5dGVzICAgIFN0cmluZyB3aXRoIHNlcXVlbmNlcyBvZiBzaW1pbGFyIGNoYXJhY3RlcnMsCiAgKgkJCSAgICBzZXBhcmF0ZWQgYnkgc2xhc2hlcy4KICAqCi0gKiBzZWN0aW9uSUQgPT0gU05fQ09NUE9VTkQ6IDxjb21wbWF4PiA8Y29tcG1pbmxlbj4gPGNvbXBzeWxtYXg+IDxjb21wZmxhZ3M+CisgKiBzZWN0aW9uSUQgPT0gU05fQ09NUE9VTkQ6IDxjb21wbWF4PiA8Y29tcG1pbmxlbj4gPGNvbXBzeWxtYXg+IDxjb21wb3B0aW9ucz4KKyAqCQkJCTxjb21wcGF0Y291bnQ+IDxjb21wcGF0dGVybj4gLi4uIDxjb21wZmxhZ3M+CiAgKiA8Y29tcG1heD4gICAgIDEgYnl0ZQkgICAgTWF4aW11bSBuciBvZiB3b3JkcyBpbiBjb21wb3VuZCB3b3JkLgogICogPGNvbXBtaW5sZW4+ICAxIGJ5dGUJICAgIE1pbmltYWwgd29yZCBsZW5ndGggZm9yIGNvbXBvdW5kaW5nLgogICogPGNvbXBzeWxtYXg+ICAxIGJ5dGUJICAgIE1heGltdW0gbnIgb2Ygc3lsbGFibGVzIGluIGNvbXBvdW5kIHdvcmQuCisgKiA8Y29tcG9wdGlvbnM+IDIgYnl0ZXMgICAgQ09NUF8gZmxhZ3MuCisgKiA8Y29tcHBhdGNvdW50PiAyIGJ5dGVzICAgbnVtYmVyIG9mIDxjb21wcGF0dGVybj4gZm9sbG93aW5nCiAgKiA8Y29tcGZsYWdzPiAgIE4gYnl0ZXMgICAgRmxhZ3MgZnJvbSBDT01QT1VORFJVTEUgaXRlbXMsIHNlcGFyYXRlZCBieQogICoJCQkgICAgc2xhc2hlcy4KICAqCi0gKiBzZWN0aW9uSUQgPT0gU05fTk9CUkVBSzogKGVtcHR5LCBpdHMgcHJlc2VuY2UgaXMgZW5vdWdoKQorICogPGNvbXBwYXR0ZXJuPjogPGNvbXBwYXRsZW4+IDxjb21wcGF0dGV4dD4KKyAqIDxjb21wcGF0bGVuPgkgMSBieXRlCSAgICBsZW5ndGggb2YgPGNvbXBwYXR0ZXh0PgorICogPGNvbXBwYXR0ZXh0PiBOIGJ5dGVzICAgIGVuZCBvciBiZWdpbiBjaGFycyBmcm9tIENIRUNLQ09NUE9VTkRQQVRURVJOCisgKgorICogc2VjdGlvbklEID09IFNOX05PQlJFQUs6IChlbXB0eSwgaXRzIHByZXNlbmNlIGlzIHdoYXQgbWF0dGVycykKICAqCiAgKiBzZWN0aW9uSUQgPT0gU05fU1lMTEFCTEU6IDxzeWxsYWJsZT4KICAqIDxzeWxsYWJsZT4gICAgTiBieXRlcyAgICBTdHJpbmcgZnJvbSBTWUxMQUJMRSBpdGVtLgpAQCAtMjQ4LDYgKzI1NSw3IEBACiAgKgkJCSAgICBXRl9IQVNfQUZGID4+IDggICB3b3JkIGluY2x1ZGVzIGFmZml4CiAgKgkJCSAgICBXRl9ORUVEQ09NUCA+PiA4ICB3b3JkIG9ubHkgdmFsaWQgaW4gY29tcG91bmQKICAqCQkJICAgIFdGX05PU1VHR0VTVCA+PiA4ICB3b3JkIG5vdCB1c2VkIGZvciBzdWdnZXN0aW9ucworICoJCQkgICAgV0ZfQ09NUFJPT1QgPj4gOCAgd29yZCBhbHJlYWR5IGEgY29tcG91bmQKICAqCiAgKiA8cGZsYWdzPgkxIGJ5dGUJICAgIGJpdG1hc2sgb2Y6CiAgKgkJCSAgICBXRlBfUkFSRQlyYXJlIHByZWZpeApAQCAtMzM2LDYgKzM0NCw3IEBACiAjZGVmaW5lIFdGX0hBU19BRkYgIDB4MDEwMAkvKiB3b3JkIGluY2x1ZGVzIGFmZml4ICovCiAjZGVmaW5lIFdGX05FRURDT01QIDB4MDIwMAkvKiB3b3JkIG9ubHkgdmFsaWQgaW4gY29tcG91bmQgKi8KICNkZWZpbmUgV0ZfTk9TVUdHRVNUIDB4MDQwMAkvKiB3b3JkIG5vdCB0byBiZSBzdWdnZXN0ZWQgKi8KKyNkZWZpbmUgV0ZfQ09NUFJPT1QgMHgwODAwCS8qIGFscmVhZHkgY29tcG91bmRlZCB3b3JkLCBDT01QT1VORFJPT1QgKi8KIAogLyogb25seSB1c2VkIGZvciBzdV9iYWRmbGFncyAqLwogI2RlZmluZSBXRl9NSVhDQVAgICAweDIwCS8qIG1peCBvZiB1cHBlciBhbmQgbG93ZXIgY2FzZTogbWFjYVJPTkkgKi8KQEAgLTM1Niw2ICszNjUsMTIgQEAKICNkZWZpbmUgV0ZfUEZYX1VQICAgKFdGUF9VUCA8PCAyNCkJLyogaW4gc2xfcGlkeHM6IGZsYWcgZm9yIHRvLXVwcGVyCiAJCQkJCSAqIHBvc3Rwb25lZCBwcmVmaXggKi8KIAorLyogZmxhZ3MgZm9yIDxjb21wb3B0aW9ucz4gKi8KKyNkZWZpbmUgQ09NUF9DSEVDS0RVUAkJMQkvKiBDSEVDS0NPTVBPVU5ERFVQICovCisjZGVmaW5lIENPTVBfQ0hFQ0tSRVAJCTIJLyogQ0hFQ0tDT01QT1VORFJFUCAqLworI2RlZmluZSBDT01QX0NIRUNLQ0FTRQkJNAkvKiBDSEVDS0NPTVBPVU5EQ0FTRSAqLworI2RlZmluZSBDT01QX0NIRUNLVFJJUExFCTgJLyogQ0hFQ0tDT01QT1VORFRSSVBMRSAqLworCiAvKiBTcGVjaWFsIGJ5dGUgdmFsdWVzIGZvciA8Ynl0ZT4uICBTb21lIGFyZSBvbmx5IHVzZWQgaW4gdGhlIHRyZWUgZm9yCiAgKiBwb3N0cG9uZWQgcHJlZml4ZXMsIHNvbWUgb25seSBpbiB0aGUgb3RoZXIgdHJlZXMuICBUaGlzIGlzIGEgYml0IG1lc3N5Li4uICovCiAjZGVmaW5lIEJZX05PRkxBR1MJMAkvKiBlbmQgb2Ygd29yZCB3aXRob3V0IGZsYWdzIG9yIHJlZ2lvbjsgZm9yCkBAIC00NDMsOSArNDU4LDExIEBACiAKICAgICBoYXNodGFiX1QJc2xfd29yZGNvdW50OwkvKiBoYXNodGFibGUgd2l0aCB3b3JkIGNvdW50LCB3b3JkY291bnRfVCAqLwogCi0gICAgaW50CQlzbF9jb21wbWF4OwkvKiBDT01QT1VORE1BWCAoZGVmYXVsdDogTUFYV0xFTikgKi8KKyAgICBpbnQJCXNsX2NvbXBtYXg7CS8qIENPTVBPVU5EV09SRE1BWCAoZGVmYXVsdDogTUFYV0xFTikgKi8KICAgICBpbnQJCXNsX2NvbXBtaW5sZW47CS8qIENPTVBPVU5ETUlOIChkZWZhdWx0OiAwKSAqLwogICAgIGludAkJc2xfY29tcHN5bG1heDsJLyogQ09NUE9VTkRTWUxNQVggKGRlZmF1bHQ6IE1BWFdMRU4pICovCisgICAgaW50CQlzbF9jb21wb3B0aW9uczsJLyogQ09NUF8qIGZsYWdzICovCisgICAgZ2FycmF5X1QJc2xfY29tcHBhdDsJLyogQ0hFQ0tDT01QT1VORFBBVFRFUk4gaXRlbXMgKi8KICAgICByZWdwcm9nX1QJKnNsX2NvbXBwcm9nOwkvKiBDT01QT1VORFJVTEUgdHVybmVkIGludG8gYSByZWdleHAgcHJvZ3JtCiAJCQkJICogKE5VTEwgd2hlbiBubyBjb21wb3VuZGluZykgKi8KICAgICBjaGFyX3UJKnNsX2NvbXBzdGFydGZsYWdzOyAvKiBmbGFncyBmb3IgZmlyc3QgY29tcG91bmQgd29yZCAqLwpAQCAtNjkzLDYgKzcxMCw3IEBACiAgICAgaW50CQltaV9jb21wb2ZmOwkJLyogc3RhcnQgb2YgZm9sbG93aW5nIHdvcmQgb2Zmc2V0ICovCiAgICAgY2hhcl91CW1pX2NvbXBmbGFnc1tNQVhXTEVOXTsJLyogZmxhZ3MgZm9yIGNvbXBvdW5kIHdvcmRzIHVzZWQgKi8KICAgICBpbnQJCW1pX2NvbXBsZW47CQkvKiBuciBvZiBjb21wb3VuZCB3b3JkcyB1c2VkICovCisgICAgaW50CQltaV9jb21wZXh0cmE7CQkvKiBuciBvZiBDT01QT1VORFJPT1Qgd29yZHMgKi8KIAogICAgIC8qIG90aGVycyAqLwogICAgIGludAkJbWlfcmVzdWx0OwkJLyogcmVzdWx0IHNvIGZhcjogU1BfQkFELCBTUF9PSywgZXRjLiAqLwpAQCAtMTQ3NSw5ICsxNDkzLDEwIEBACiAJCQljb250aW51ZTsKICNlbmRpZgogCi0JCS8qIExpbWl0IHRoZSBudW1iZXIgb2YgY29tcG91bmQgd29yZHMgdG8gQ09NUE9VTkRNQVggaWYgbm8KKwkJLyogTGltaXQgdGhlIG51bWJlciBvZiBjb21wb3VuZCB3b3JkcyB0byBDT01QT1VORFdPUkRNQVggaWYgbm8KIAkJICogbWF4aW11bSBmb3Igc3lsbGFibGVzIGlzIHNwZWNpZmllZC4gKi8KLQkJaWYgKCF3b3JkX2VuZHMgJiYgbWlwLT5taV9jb21wbGVuICsgMiA+IHNsYW5nLT5zbF9jb21wbWF4CisJCWlmICghd29yZF9lbmRzICYmIG1pcC0+bWlfY29tcGxlbiArIG1pcC0+bWlfY29tcGV4dHJhICsgMgorCQkJCQkJCSAgID4gc2xhbmctPnNsX2NvbXBtYXgKIAkJCQkJICAgJiYgc2xhbmctPnNsX2NvbXBzeWxtYXggPT0gTUFYV0xFTikKIAkJICAgIGNvbnRpbnVlOwogCkBAIC0xNTg5LDYgKzE2MDgsOCBAQAogI2VuZGlmCiAJCWMgPSBtaXAtPm1pX2NvbXBvZmY7CiAJCSsrbWlwLT5taV9jb21wbGVuOworCQlpZiAoZmxhZ3MgJiBXRl9DT01QUk9PVCkKKwkJICAgICsrbWlwLT5taV9jb21wZXh0cmE7CiAKIAkJLyogRm9yIE5PQlJFQUsgd2UgbmVlZCB0byB0cnkgYWxsIE5PQlJFQUsgbGFuZ3VhZ2VzLCBhdCBsZWFzdAogCQkgKiB0byBmaW5kIHRoZSAiLmFkZCIgZmlsZShzKS4gKi8KQEAgLTE2MjUsNiArMTY0Niw4IEBACiAJCQlicmVhazsKIAkJfQogCQktLW1pcC0+bWlfY29tcGxlbjsKKwkJaWYgKGZsYWdzICYgV0ZfQ09NUFJPT1QpCisJCSAgICAtLW1pcC0+bWlfY29tcGV4dHJhOwogCQltaXAtPm1pX2xwID0gc2F2ZV9scDsKIAogCQlpZiAoc2xhbmctPnNsX25vYnJlYWspCkBAIC0xNzI2LDcgKzE3NDksNyBAQAogCiAgICAgLyogQ291bnQgdGhlIG51bWJlciBvZiBzeWxsYWJsZXMuICBUaGlzIG1heSBiZSBzbG93LCBkbyBpdCBsYXN0LiAgSWYgdGhlcmUKICAgICAgKiBhcmUgdG9vIG1hbnkgc3lsbGFibGVzIEFORCB0aGUgbnVtYmVyIG9mIGNvbXBvdW5kIHdvcmRzIGlzIGFib3ZlCi0gICAgICogQ09NUE9VTkRNQVggdGhlbiBjb21wb3VuZGluZyBpcyBub3QgYWxsb3dlZC4gKi8KKyAgICAgKiBDT01QT1VORFdPUkRNQVggdGhlbiBjb21wb3VuZGluZyBpcyBub3QgYWxsb3dlZC4gKi8KICAgICBpZiAoc2xhbmctPnNsX2NvbXBzeWxtYXggPCBNQVhXTEVOCiAJCSAgICAgICAmJiBjb3VudF9zeWxsYWJsZXMoc2xhbmcsIHdvcmQpID4gc2xhbmctPnNsX2NvbXBzeWxtYXgpCiAJcmV0dXJuIChpbnQpU1RSTEVOKGZsYWdzKSA8IHNsYW5nLT5zbF9jb21wbWF4OwpAQCAtMjQ2NSw2ICsyNDg4LDggQEAKICAgICBscC0+c2xfc3lsbGFibGUgPSBOVUxMOwogICAgIGdhX2NsZWFyKCZscC0+c2xfc3lsX2l0ZW1zKTsKIAorICAgIGdhX2NsZWFyX3N0cmluZ3MoJmxwLT5zbF9jb21wcGF0KTsKKwogICAgIGhhc2hfY2xlYXJfYWxsKCZscC0+c2xfd29yZGNvdW50LCBXQ19LRVlfT0ZGKTsKICAgICBoYXNoX2luaXQoJmxwLT5zbF93b3JkY291bnQpOwogCkBAIC0zMzcxLDcgKzMzOTYsNyBAQAogCiAvKgogICogUmVhZCB0aGUgY29tcG91bmQgc2VjdGlvbiBmcm9tIHRoZSAuc3BsIGZpbGU6Ci0gKgk8Y29tcG1heD4gPGNvbXBtaW5sZW4+IDxjb21wc3lsbWF4PiA8Y29tcGZsYWdzPgorICoJPGNvbXBtYXg+IDxjb21wbWlubGVuPiA8Y29tcHN5bG1heD4gPGNvbXBvcHRpb25zPiA8Y29tcGZsYWdzPgogICogUmV0dXJucyBTUF8qRVJST1IgZmxhZ3MuCiAgKi8KICAgICBzdGF0aWMgaW50CkBAIC0zMzg3LDYgKzM0MTIsOCBAQAogICAgIGNoYXJfdQkqcHA7CiAgICAgY2hhcl91CSpjcDsKICAgICBjaGFyX3UJKmFwOworICAgIGludAkJY250OworICAgIGdhcnJheV9UCSpnYXA7CiAKICAgICBpZiAodG9kbyA8IDIpCiAJcmV0dXJuIFNQX0ZPUk1FUlJPUjsJLyogbmVlZCBhdCBsZWFzdCB0d28gYnl0ZXMgKi8KQEAgLTM0MDksNiArMzQzNiwzMiBAQAogCWMgPSBNQVhXTEVOOwogICAgIHNsYW5nLT5zbF9jb21wc3lsbWF4ID0gYzsKIAorICAgIGMgPSBnZXRjKGZkKTsJCQkJCS8qIDxjb21wb3B0aW9ucz4gKi8KKyAgICBpZiAoYyAhPSAwKQorCXVuZ2V0YyhjLCBmZCk7CSAgICAvKiBiZSBiYWNrd2FyZHMgY29tcGF0aWJsZSB3aXRoIFZpbSA3LjBiICovCisgICAgZWxzZQorICAgIHsKKwktLXRvZG87CisJYyA9IGdldGMoZmQpOwkgICAgLyogb25seSB1c2UgdGhlIGxvd2VyIGJ5dGUgZm9yIG5vdyAqLworCS0tdG9kbzsKKwlzbGFuZy0+c2xfY29tcG9wdGlvbnMgPSBjOworCisJZ2FwID0gJnNsYW5nLT5zbF9jb21wcGF0OworCWMgPSBnZXQyYyhmZCk7CQkJCQkvKiA8Y29tcHBhdGNvdW50PiAqLworCXRvZG8gLT0gMjsKKwlnYV9pbml0MihnYXAsIHNpemVvZihjaGFyX3UgKiksIGMpOworCWlmIChnYV9ncm93KGdhcCwgYykgPT0gT0spCisJICAgIHdoaWxlICgtLWMgPj0gMCkKKwkgICAgeworCQkoKGNoYXJfdSAqKikoZ2FwLT5nYV9kYXRhKSlbZ2FwLT5nYV9sZW4rK10gPQorCQkJCQkJIHJlYWRfY250X3N0cmluZyhmZCwgMSwgJmNudCk7CisJCQkJCSAgICAvKiA8Y29tcHBhdGxlbj4gPGNvbXBwYXR0ZXh0PiAqLworCQlpZiAoY250IDwgMCkKKwkJICAgIHJldHVybiBjbnQ7CisJCXRvZG8gLT0gY250ICsgMjsKKwkgICAgfQorICAgIH0KKwogICAgIC8qIFR1cm4gdGhlIENPTVBPVU5EUlVMRSBpdGVtcyBpbnRvIGEgcmVnZXhwIHBhdHRlcm46CiAgICAgICogImFbYmNdL2EqYisiIC0+ICJeXChhW2JjXVx8YSpiXCtcKSQiLgogICAgICAqIEluc2VydGluZyBiYWNrc2xhc2hlcyBtYXkgZG91YmxlIHRoZSBsZW5ndGgsICJeXChcKSQ8TnVsPiIgaXMgNyBieXRlcy4KQEAgLTQ1ODgsOCArNDY0MSwxMiBAQAogICAgIHVuc2lnbmVkCWFmX2JhZDsJCS8qIEJBRCBJRCBmb3IgYmFubmVkIHdvcmQgKi8KICAgICB1bnNpZ25lZAlhZl9uZWVkYWZmaXg7CS8qIE5FRURBRkZJWCBJRCAqLwogICAgIHVuc2lnbmVkCWFmX25lZWRjb21wOwkvKiBORUVEQ09NUE9VTkQgSUQgKi8KKyAgICB1bnNpZ25lZAlhZl9jb21wcm9vdDsJLyogQ09NUE9VTkRST09UIElEICovCisgICAgdW5zaWduZWQJYWZfY29tcGZvcmJpZDsJLyogQ09NUE9VTkRGT1JCSURGTEFHIElEICovCisgICAgdW5zaWduZWQJYWZfY29tcHBlcm1pdDsJLyogQ09NUE9VTkRQRVJNSVRGTEFHIElEICovCiAgICAgdW5zaWduZWQJYWZfbm9zdWdnZXN0OwkvKiBOT1NVR0dFU1QgSUQgKi8KLSAgICBpbnQJCWFmX3BmeHBvc3Rwb25lOwkvKiBwb3N0cG9uZSBwcmVmaXhlcyB3aXRob3V0IGNob3Agc3RyaW5nICovCisgICAgaW50CQlhZl9wZnhwb3N0cG9uZTsJLyogcG9zdHBvbmUgcHJlZml4ZXMgd2l0aG91dCBjaG9wIHN0cmluZyBhbmQKKwkJCQkgICB3aXRob3V0IGZsYWdzICovCiAgICAgaGFzaHRhYl9UCWFmX3ByZWY7CS8qIGhhc2h0YWJsZSBmb3IgcHJlZml4ZXMsIGFmZmhlYWRlcl9UICovCiAgICAgaGFzaHRhYl9UCWFmX3N1ZmY7CS8qIGhhc2h0YWJsZSBmb3Igc3VmZml4ZXMsIGFmZmhlYWRlcl9UICovCiAgICAgaGFzaHRhYl9UCWFmX2NvbXA7CS8qIGhhc2h0YWJsZSBmb3IgY29tcG91bmQgZmxhZ3MsIGNvbXBpdGVtX1QgKi8KQEAgLTQ2MDcsOSArNDY2NCw5IEBACiAgICAgYWZmZW50cnlfVAkqYWVfbmV4dDsJLyogbmV4dCBhZmZpeCB3aXRoIHNhbWUgbmFtZS9udW1iZXIgKi8KICAgICBjaGFyX3UJKmFlX2Nob3A7CS8qIHRleHQgdG8gY2hvcCBvZmYgYmFzaWMgd29yZCAoY2FuIGJlIE5VTEwpICovCiAgICAgY2hhcl91CSphZV9hZGQ7CS8qIHRleHQgdG8gYWRkIHRvIGJhc2ljIHdvcmQgKGNhbiBiZSBOVUxMKSAqLworICAgIGNoYXJfdQkqYWVfZmxhZ3M7CS8qIGZsYWdzIG9uIHRoZSBhZmZpeCAoY2FuIGJlIE5VTEwpICovCiAgICAgY2hhcl91CSphZV9jb25kOwkvKiBjb25kaXRpb24gKE5VTEwgZm9yICIuIikgKi8KICAgICByZWdwcm9nX1QJKmFlX3Byb2c7CS8qIHJlZ2V4cCBwcm9ncmFtIGZvciBhZV9jb25kIG9yIE5VTEwgKi8KLSAgICBjaGFyX3UJYWVfcmFyZTsJLyogcmFyZSBhZmZpeCAqLwogICAgIGNoYXJfdQlhZV9ub2NvbXA7CS8qIHdvcmQgd2l0aCBhZmZpeCBub3QgY29tcG91bmRhYmxlICovCiB9OwogCkBAIC00NzU3LDYgKzQ4MTQsOSBAQAogICAgIGludAkJc2lfY29tcG1heDsJLyogbWF4IG5yIG9mIHdvcmRzIGZvciBjb21wb3VuZGluZyAqLwogICAgIGludAkJc2lfY29tcG1pbmxlbjsJLyogbWluaW1hbCBsZW5ndGggZm9yIGNvbXBvdW5kaW5nICovCiAgICAgaW50CQlzaV9jb21wc3lsbWF4OwkvKiBtYXggbnIgb2Ygc3lsbGFibGVzIGZvciBjb21wb3VuZGluZyAqLworICAgIGludAkJc2lfY29tcG9wdGlvbnM7CS8qIENPTVBfIGZsYWdzICovCisgICAgZ2FycmF5X1QJc2lfY29tcHBhdDsJLyogQ0hFQ0tDT01QT1VORFBBVFRFUk4gaXRlbXMsIGVhY2ggc3RvcmVkIGFzCisJCQkJICAgYSBzdHJpbmcgKi8KICAgICBjaGFyX3UJKnNpX2NvbXBmbGFnczsJLyogZmxhZ3MgdXNlZCBmb3IgY29tcG91bmRpbmcgKi8KICAgICBjaGFyX3UJc2lfbm9icmVhazsJLyogTk9CUkVBSyAqLwogICAgIGNoYXJfdQkqc2lfc3lsbGFibGU7CS8qIHN5bGxhYmxlIHN0cmluZyAqLwpAQCAtNDk2MCw3ICs1MDIwLDggQEAKICAgICBpbnQJCWw7CiAgICAgaW50CQljb21wbWlubGVuID0gMDsJCS8qIENPTVBPVU5ETUlOIHZhbHVlICovCiAgICAgaW50CQljb21wc3lsbWF4ID0gMDsJCS8qIENPTVBPVU5EU1lMTUFYIHZhbHVlICovCi0gICAgaW50CQljb21wbWF4ID0gMDsJCS8qIENPTVBPVU5ETUFYIHZhbHVlICovCisgICAgaW50CQljb21wb3B0aW9ucyA9IDA7CS8qIENPTVBfIGZsYWdzICovCisgICAgaW50CQljb21wbWF4ID0gMDsJCS8qIENPTVBPVU5EV09SRE1BWCB2YWx1ZSAqLwogICAgIGNoYXJfdQkqY29tcGZsYWdzID0gTlVMTDsJLyogQ09NUE9VTkRGTEFHIGFuZCBDT01QT1VORFJVTEUKIAkJCQkJICAgY29uY2F0ZW5hdGVkICovCiAgICAgY2hhcl91CSptaWR3b3JkID0gTlVMTDsJLyogTUlEV09SRCB2YWx1ZSAqLwpAQCAtNTA5Niw2ICs1MTU3LDcgQEAKIAkJCXx8IGFmZi0+YWZfYmFkICE9IDAKIAkJCXx8IGFmZi0+YWZfbmVlZGFmZml4ICE9IDAKIAkJCXx8IGFmZi0+YWZfbmVlZGNvbXAgIT0gMAorCQkJfHwgYWZmLT5hZl9jb21wcm9vdCAhPSAwCiAJCQl8fCBhZmYtPmFmX25vc3VnZ2VzdCAhPSAwCiAJCQl8fCBjb21wZmxhZ3MgIT0gTlVMTAogCQkJfHwgYWZmLT5hZl9zdWZmLmh0X3VzZWQgPiAwCkBAIC01MTcxLDYgKzUyMzMsMjQgQEAKIAkJYWZmLT5hZl9uZWVkY29tcCA9IGFmZml0ZW0yZmxhZyhhZmYtPmFmX2ZsYWd0eXBlLCBpdGVtc1sxXSwKIAkJCQkJCQkJIGZuYW1lLCBsbnVtKTsKIAkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VORFJPT1QiKSA9PSAwICYmIGl0ZW1jbnQgPT0gMgorCQkJCQkJICAgICAmJiBhZmYtPmFmX2NvbXByb290ID09IDApCisJICAgIHsKKwkJYWZmLT5hZl9jb21wcm9vdCA9IGFmZml0ZW0yZmxhZyhhZmYtPmFmX2ZsYWd0eXBlLCBpdGVtc1sxXSwKKwkJCQkJCQkJIGZuYW1lLCBsbnVtKTsKKwkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VOREZPUkJJREZMQUciKSA9PSAwCisJCQkJICAgJiYgaXRlbWNudCA9PSAyICYmIGFmZi0+YWZfY29tcGZvcmJpZCA9PSAwKQorCSAgICB7CisJCWFmZi0+YWZfY29tcGZvcmJpZCA9IGFmZml0ZW0yZmxhZyhhZmYtPmFmX2ZsYWd0eXBlLCBpdGVtc1sxXSwKKwkJCQkJCQkJIGZuYW1lLCBsbnVtKTsKKwkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VORFBFUk1JVEZMQUciKSA9PSAwCisJCQkJICAgJiYgaXRlbWNudCA9PSAyICYmIGFmZi0+YWZfY29tcHBlcm1pdCA9PSAwKQorCSAgICB7CisJCWFmZi0+YWZfY29tcHBlcm1pdCA9IGFmZml0ZW0yZmxhZyhhZmYtPmFmX2ZsYWd0eXBlLCBpdGVtc1sxXSwKKwkJCQkJCQkJIGZuYW1lLCBsbnVtKTsKKwkgICAgfQogCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VOREZMQUciKSA9PSAwICYmIGl0ZW1jbnQgPT0gMgogCQkJCQkJCSAmJiBjb21wZmxhZ3MgPT0gTlVMTCkKIAkgICAgewpAQCAtNTIwMywxMiArNTI4MywxMiBAQAogCQkgICAgY29tcGZsYWdzID0gcDsKIAkJfQogCSAgICB9Ci0JICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIkNPTVBPVU5ETUFYIikgPT0gMCAmJiBpdGVtY250ID09IDIKKwkgICAgZWxzZSBpZiAoU1RSQ01QKGl0ZW1zWzBdLCAiQ09NUE9VTkRXT1JETUFYIikgPT0gMCAmJiBpdGVtY250ID09IDIKIAkJCQkJCQkgICAgICAmJiBjb21wbWF4ID09IDApCiAJICAgIHsKIAkJY29tcG1heCA9IGF0b2koKGNoYXIgKilpdGVtc1sxXSk7CiAJCWlmIChjb21wbWF4ID09IDApCi0JCSAgICBzbXNnKChjaGFyX3UgKilfKCJXcm9uZyBDT01QT1VORE1BWCB2YWx1ZSBpbiAlcyBsaW5lICVkOiAlcyIpLAorCQkgICAgc21zZygoY2hhcl91ICopXygiV3JvbmcgQ09NUE9VTkRXT1JETUFYIHZhbHVlIGluICVzIGxpbmUgJWQ6ICVzIiksCiAJCQkJCQkgICAgICAgZm5hbWUsIGxudW0sIGl0ZW1zWzFdKTsKIAkgICAgfQogCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDT01QT1VORE1JTiIpID09IDAgJiYgaXRlbWNudCA9PSAyCkBAIC01MjI3LDYgKzUzMDcsNTAgQEAKIAkJICAgIHNtc2coKGNoYXJfdSAqKV8oIldyb25nIENPTVBPVU5EU1lMTUFYIHZhbHVlIGluICVzIGxpbmUgJWQ6ICVzIiksCiAJCQkJCQkgICAgICAgZm5hbWUsIGxudW0sIGl0ZW1zWzFdKTsKIAkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDSEVDS0NPTVBPVU5ERFVQIikgPT0gMCAmJiBpdGVtY250ID09IDEpCisJICAgIHsKKwkJY29tcG9wdGlvbnMgfD0gQ09NUF9DSEVDS0RVUDsKKwkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDSEVDS0NPTVBPVU5EUkVQIikgPT0gMCAmJiBpdGVtY250ID09IDEpCisJICAgIHsKKwkJY29tcG9wdGlvbnMgfD0gQ09NUF9DSEVDS1JFUDsKKwkgICAgfQorCSAgICBlbHNlIGlmIChTVFJDTVAoaXRlbXNbMF0sICJDSEVDS0NPTVBPVU5EQ0FTRSIpID09IDAgJiYgaXRlbWNudCA9PSAxKQorCSAgICB7CisJCWNvbXBvcHRpb25zIHw9IENPTVBfQ0hFQ0tDQVNFOworCSAgICB9CisJICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIkNIRUNLQ09NUE9VTkRUUklQTEUiKSA9PSAwCisJCQkJCQkJICAgICAgJiYgaXRlbWNudCA9PSAxKQorCSAgICB7CisJCWNvbXBvcHRpb25zIHw9IENPTVBfQ0hFQ0tUUklQTEU7CisJICAgIH0KKwkgICAgZWxzZSBpZiAoU1RSQ01QKGl0ZW1zWzBdLCAiQ0hFQ0tDT01QT1VORFBBVFRFUk4iKSA9PSAwCisJCQkJCQkJICAgICAgJiYgaXRlbWNudCA9PSAyKQorCSAgICB7CisJCWlmIChhdG9pKChjaGFyICopaXRlbXNbMV0pID09IDApCisJCSAgICBzbXNnKChjaGFyX3UgKilfKCJXcm9uZyBDSEVDS0NPTVBPVU5EUEFUVEVSTiB2YWx1ZSBpbiAlcyBsaW5lICVkOiAlcyIpLAorCQkJCQkJICAgICAgIGZuYW1lLCBsbnVtLCBpdGVtc1sxXSk7CisJICAgIH0KKwkgICAgZWxzZSBpZiAoU1RSQ01QKGl0ZW1zWzBdLCAiQ0hFQ0tDT01QT1VORFBBVFRFUk4iKSA9PSAwCisJCQkJCQkJICAgICAgJiYgaXRlbWNudCA9PSAzKQorCSAgICB7CisJCWdhcnJheV9UICAgICpnYXAgPSAmc3Bpbi0+c2lfY29tcHBhdDsKKwkJaW50CSAgICBpOworCisJCS8qIE9ubHkgYWRkIHRoZSBjb3VwbGUgaWYgaXQgaXNuJ3QgYWxyZWFkeSB0aGVyZS4gKi8KKwkJZm9yIChpID0gMDsgaSA8IGdhcC0+Z2FfbGVuIC0gMTsgaSArPSAyKQorCQkgICAgaWYgKFNUUkNNUCgoKGNoYXJfdSAqKikoZ2FwLT5nYV9kYXRhKSlbaV0sIGl0ZW1zWzFdKSA9PSAwCisJCQkgICAgJiYgU1RSQ01QKCgoY2hhcl91ICoqKShnYXAtPmdhX2RhdGEpKVtpICsgMV0sCisJCQkJCQkJICAgICAgIGl0ZW1zWzJdKSA9PSAwKQorCQkJYnJlYWs7CisJCWlmIChpID49IGdhcC0+Z2FfbGVuICYmIGdhX2dyb3coZ2FwLCAyKSA9PSBPSykKKwkJeworCQkgICAgKChjaGFyX3UgKiopKGdhcC0+Z2FfZGF0YSkpW2dhcC0+Z2FfbGVuKytdCisJCQkJCSAgICAgICA9IGdldHJvb21fc2F2ZShzcGluLCBpdGVtc1sxXSk7CisJCSAgICAoKGNoYXJfdSAqKikoZ2FwLT5nYV9kYXRhKSlbZ2FwLT5nYV9sZW4rK10KKwkJCQkJICAgICAgID0gZ2V0cm9vbV9zYXZlKHNwaW4sIGl0ZW1zWzJdKTsKKwkJfQorCSAgICB9CiAJICAgIGVsc2UgaWYgKFNUUkNNUChpdGVtc1swXSwgIlNZTExBQkxFIikgPT0gMCAmJiBpdGVtY250ID09IDIKIAkJCQkJCQkgICYmIHN5bGxhYmxlID09IE5VTEwpCiAJICAgIHsKQEAgLTUyOTMsNyArNTQxNyw4IEBACiAJCQkgICAgfHwgY3VyX2FmZi0+YWhfZmxhZyA9PSBhZmYtPmFmX2tlZXBjYXNlCiAJCQkgICAgfHwgY3VyX2FmZi0+YWhfZmxhZyA9PSBhZmYtPmFmX25lZWRhZmZpeAogCQkJICAgIHx8IGN1cl9hZmYtPmFoX2ZsYWcgPT0gYWZmLT5hZl9ub3N1Z2dlc3QKLQkJCSAgICB8fCBjdXJfYWZmLT5haF9mbGFnID09IGFmZi0+YWZfbmVlZGNvbXApCisJCQkgICAgfHwgY3VyX2FmZi0+YWhfZmxhZyA9PSBhZmYtPmFmX25lZWRjb21wCisJCQkgICAgfHwgY3VyX2FmZi0+YWhfZmxhZyA9PSBhZmYtPmFmX2NvbXByb290KQogCQkJc21zZygoY2hhcl91ICopXygiQWZmaXggYWxzbyB1c2VkIGZvciBCQUQvUkFSRS9LRUVQQ0FTRS9ORUVEQUZGSVgvTkVFRENPTVBPVU5EL05PU1VHR0VTVCBpbiAlcyBsaW5lICVkOiAlcyIpLAogCQkJCQkJICAgICAgIGZuYW1lLCBsbnVtLCBpdGVtc1sxXSk7CiAJCSAgICBTVFJDUFkoY3VyX2FmZi0+YWhfa2V5LCBpdGVtc1sxXSk7CkBAIC01MzE1LDggKzU0NDAsNyBAQAogCQkvKiBNeXNwZWxsIGFsbG93cyBleHRyYSB0ZXh0IGFmdGVyIHRoZSBpdGVtLCBidXQgdGhhdCBtaWdodAogCQkgKiBtZWFuIG1pc3Rha2VzIGdvIHVubm90aWNlZC4gIFJlcXVpcmUgYSBjb21tZW50LXN0YXJ0ZXIuICovCiAJCWlmIChpdGVtY250ID4gbGFzdGkgJiYgKml0ZW1zW2xhc3RpXSAhPSAnIycpCi0JCSAgICBzbXNnKChjaGFyX3UgKilfKCJUcmFpbGluZyB0ZXh0IGluICVzIGxpbmUgJWQ6ICVzIiksCi0JCQkJCQkgICAgICAgZm5hbWUsIGxudW0sIGl0ZW1zWzRdKTsKKwkJICAgIHNtc2coKGNoYXJfdSAqKV8oZV9hZmZ0cmFpbGluZyksIGZuYW1lLCBsbnVtLCBpdGVtc1tsYXN0aV0pOwogCiAJCWlmIChTVFJDTVAoaXRlbXNbMl0sICJZIikgIT0gMCAmJiBTVFJDTVAoaXRlbXNbMl0sICJOIikgIT0gMCkKIAkJICAgIHNtc2coKGNoYXJfdSAqKV8oIkV4cGVjdGVkIFkgb3IgTiBpbiAlcyBsaW5lICVkOiAlcyIpLApAQCAtNTM1MCwzMSArNTQ3NCwxNiBAQAogCQkgICAgJiYgaXRlbWNudCA+PSA1KQogCSAgICB7CiAJCWFmZmVudHJ5X1QJKmFmZl9lbnRyeTsKLQkJaW50CQlyYXJlID0gRkFMU0U7CiAJCWludAkJbm9jb21wID0gRkFMU0U7CiAJCWludAkJdXBwZXIgPSBGQUxTRTsKIAkJaW50CQlsYXN0aSA9IDU7CiAKLQkJLyogQ2hlY2sgZm9yICJyYXJlIiBhbmQgIm5vY29tcCIgYWZ0ZXIgdGhlIG90aGVyIGluZm8uICovCi0JCXdoaWxlIChpdGVtY250ID4gbGFzdGkpCi0JCXsKLQkJICAgIGlmICghcmFyZSAmJiBTVFJJQ01QKGl0ZW1zW2xhc3RpXSwgInJhcmUiKSA9PSAwKQotCQkgICAgewotCQkJcmFyZSA9IFRSVUU7Ci0JCQkrK2xhc3RpOwotCQkgICAgfQotCQkgICAgZWxzZSBpZiAoIW5vY29tcCAmJiBTVFJJQ01QKGl0ZW1zW2xhc3RpXSwgIm5vY29tcCIpID09IDApCi0JCSAgICB7Ci0JCQlub2NvbXAgPSBUUlVFOwotCQkJKytsYXN0aTsKLQkJICAgIH0KLQkJICAgIGVsc2UKLQkJCWJyZWFrOwotCQl9Ci0KIAkJLyogTXlzcGVsbCBhbGxvd3MgZXh0cmEgdGV4dCBhZnRlciB0aGUgaXRlbSwgYnV0IHRoYXQgbWlnaHQKLQkJICogbWVhbiBtaXN0YWtlcyBnbyB1bm5vdGljZWQuICBSZXF1aXJlIGEgY29tbWVudC1zdGFydGVyLiAqLwotCQlpZiAoaXRlbWNudCA+IGxhc3RpICYmICppdGVtc1tsYXN0aV0gIT0gJyMnKQorCQkgKiBtZWFuIG1pc3Rha2VzIGdvIHVubm90aWNlZC4gIFJlcXVpcmUgYSBjb21tZW50LXN0YXJ0ZXIuCisJCSAqIEh1bnNwZWxsIHVzZXMgYSAiLSIgaXRlbS4gKi8KKwkJaWYgKGl0ZW1jbnQgPiBsYXN0aSAmJiAqaXRlbXNbbGFzdGldICE9ICcjJworCQkJJiYgKFNUUkNNUChpdGVtc1tsYXN0aV0sICItIikgIT0gMAorCQkJCQkJICAgICB8fCBpdGVtY250ICE9IGxhc3RpICsgMSkpCiAJCSAgICBzbXNnKChjaGFyX3UgKilfKGVfYWZmdHJhaWxpbmcpLCBmbmFtZSwgbG51bSwgaXRlbXNbbGFzdGldKTsKIAogCQkvKiBOZXcgaXRlbSBmb3IgYW4gYWZmaXggbGV0dGVyLiAqLwpAQCAtNTM4MywxNCArNTQ5MiwyMCBAQAogCQkJCQkJICAgIHNpemVvZihhZmZlbnRyeV9UKSwgVFJVRSk7CiAJCWlmIChhZmZfZW50cnkgPT0gTlVMTCkKIAkJICAgIGJyZWFrOwotCQlhZmZfZW50cnktPmFlX3JhcmUgPSByYXJlOwogCQlhZmZfZW50cnktPmFlX25vY29tcCA9IG5vY29tcDsKIAogCQlpZiAoU1RSQ01QKGl0ZW1zWzJdLCAiMCIpICE9IDApCiAJCSAgICBhZmZfZW50cnktPmFlX2Nob3AgPSBnZXRyb29tX3NhdmUoc3BpbiwgaXRlbXNbMl0pOwogCQlpZiAoU1RSQ01QKGl0ZW1zWzNdLCAiMCIpICE9IDApCisJCXsKIAkJICAgIGFmZl9lbnRyeS0+YWVfYWRkID0gZ2V0cm9vbV9zYXZlKHNwaW4sIGl0ZW1zWzNdKTsKIAorCQkgICAgLyogUmVjb2duaXplIGZsYWdzIG9uIHRoZSBhZmZpeDogYWJjZC8xMjM0ICovCisJCSAgICBhZmZfZW50cnktPmFlX2ZsYWdzID0gdmltX3N0cmNocihhZmZfZW50cnktPmFlX2FkZCwgJy8nKTsKKwkJICAgIGlmIChhZmZfZW50cnktPmFlX2ZsYWdzICE9IE5VTEwpCisJCQkqYWZmX2VudHJ5LT5hZV9mbGFncysrID0gTlVMOworCQl9CisKIAkJLyogRG9uJ3QgdXNlIGFuIGFmZml4IGVudHJ5IHdpdGggbm9uLUFTQ0lJIGNoYXJhY3RlcnMgd2hlbgogCQkgKiAic3Bpbi0+c2lfYXNjaWkiIGlzIFRSVUUuICovCiAJCWlmICghc3Bpbi0+c2lfYXNjaWkgfHwgIShoYXNfbm9uX2FzY2lpKGFmZl9lbnRyeS0+YWVfY2hvcCkKQEAgLTU0MTYsOCArNTUzMSwxMCBAQAogCQkgICAgfQogCiAJCSAgICAvKiBGb3IgcG9zdHBvbmVkIHByZWZpeGVzIHdlIG5lZWQgYW4gZW50cnkgaW4gc2lfcHJlZmNvbmQKLQkJICAgICAqIGZvciB0aGUgY29uZGl0aW9uLiAgVXNlIGFuIGV4aXN0aW5nIG9uZSBpZiBwb3NzaWJsZS4gKi8KLQkJICAgIGlmICgqaXRlbXNbMF0gPT0gJ1AnICYmIGFmZi0+YWZfcGZ4cG9zdHBvbmUpCisJCSAgICAgKiBmb3IgdGhlIGNvbmRpdGlvbi4gIFVzZSBhbiBleGlzdGluZyBvbmUgaWYgcG9zc2libGUuCisJCSAgICAgKiBDYW4ndCBiZSBkb25lIGZvciBhbiBhZmZpeCB3aXRoIGZsYWdzLiAqLworCQkgICAgaWYgKCppdGVtc1swXSA9PSAnUCcgJiYgYWZmLT5hZl9wZnhwb3N0cG9uZQorCQkJCQkgICAgICAgJiYgYWZmX2VudHJ5LT5hZV9mbGFncyA9PSBOVUxMKQogCQkgICAgewogCQkJLyogV2hlbiB0aGUgY2hvcCBzdHJpbmcgaXMgb25lIGxvd2VyLWNhc2UgbGV0dGVyIGFuZAogCQkJICogdGhlIGFkZCBzdHJpbmcgZW5kcyBpbiB0aGUgdXBwZXItY2FzZSBsZXR0ZXIgd2Ugc2V0CkBAIC01NDgwLDcgKzU1OTcsOCBAQAogCQkJICAgIH0KIAkJCX0KIAotCQkJaWYgKGFmZl9lbnRyeS0+YWVfY2hvcCA9PSBOVUxMKQorCQkJaWYgKGFmZl9lbnRyeS0+YWVfY2hvcCA9PSBOVUxMCisJCQkJCSAgICAgICAmJiBhZmZfZW50cnktPmFlX2ZsYWdzID09IE5VTEwpCiAJCQl7CiAJCQkgICAgaW50CQlpZHg7CiAJCQkgICAgY2hhcl91CSoqcHA7CkBAIC01NTA3LDE2ICs1NjI1LDE5IEBACiAJCQkJCQkJICBhZmZfZW50cnktPmFlX2NvbmQpOwogCQkJICAgIH0KIAorCQkJICAgIGlmIChhZmZfZW50cnktPmFlX2ZsYWdzICE9IE5VTEwpCisJCQkJc21zZygoY2hhcl91ICopXygiQWZmaXggZmxhZ3MgaWdub3JlZCB3aGVuIFBGWFBPU1RQT05FIHVzZWQgaW4gJXMgbGluZSAlZDogJXMiKSwKKwkJCQkJCSAgICAgICBmbmFtZSwgbG51bSwgaXRlbXNbNF0pOworCiAJCQkgICAgLyogQWRkIHRoZSBwcmVmaXggdG8gdGhlIHByZWZpeCB0cmVlLiAqLwogCQkJICAgIGlmIChhZmZfZW50cnktPmFlX2FkZCA9PSBOVUxMKQogCQkJCXAgPSAoY2hhcl91ICopIiI7CiAJCQkgICAgZWxzZQogCQkJCXAgPSBhZmZfZW50cnktPmFlX2FkZDsKKwogCQkJICAgIC8qIFBGWF9GTEFHUyBpcyBhIG5lZ2F0aXZlIG51bWJlciwgc28gdGhhdAogCQkJICAgICAqIHRyZWVfYWRkX3dvcmQoKSBrbm93cyB0aGlzIGlzIHRoZSBwcmVmaXggdHJlZS4gKi8KIAkJCSAgICBuID0gUEZYX0ZMQUdTOwotCQkJICAgIGlmIChyYXJlKQotCQkJCW4gfD0gV0ZQX1JBUkU7CiAJCQkgICAgaWYgKCFjdXJfYWZmLT5haF9jb21iaW5lKQogCQkJCW4gfD0gV0ZQX05DOwogCQkJICAgIGlmICh1cHBlcikKQEAgLTU3MDksNyArNTgzMCw3IEBACiAgICAgLyogVXNlIGNvbXBvdW5kIHNwZWNpZmljYXRpb25zIG9mIHRoZSAuYWZmIGZpbGUgZm9yIHRoZSBzcGVsbCBpbmZvLiAqLwogICAgIGlmIChjb21wbWF4ICE9IDApCiAgICAgewotCWFmZl9jaGVja19udW1iZXIoc3Bpbi0+c2lfY29tcG1heCwgY29tcG1heCwgIkNPTVBPVU5ETUFYIik7CisJYWZmX2NoZWNrX251bWJlcihzcGluLT5zaV9jb21wbWF4LCBjb21wbWF4LCAiQ09NUE9VTkRXT1JETUFYIik7CiAJc3Bpbi0+c2lfY29tcG1heCA9IGNvbXBtYXg7CiAgICAgfQogCkBAIC01NzI3LDYgKzU4NDgsMTIgQEAKIAlzcGluLT5zaV9jb21wc3lsbWF4ID0gY29tcHN5bG1heDsKICAgICB9CiAKKyAgICBpZiAoY29tcG9wdGlvbnMgIT0gMCkKKyAgICB7CisJYWZmX2NoZWNrX251bWJlcihzcGluLT5zaV9jb21wb3B0aW9ucywgY29tcG9wdGlvbnMsICJDT01QT1VORCBvcHRpb25zIik7CisJc3Bpbi0+c2lfY29tcG9wdGlvbnMgfD0gY29tcG9wdGlvbnM7CisgICAgfQorCiAgICAgaWYgKGNvbXBmbGFncyAhPSBOVUxMKQogCXByb2Nlc3NfY29tcGZsYWdzKHNwaW4sIGFmZiwgY29tcGZsYWdzKTsKIApAQCAtNjMyNyw2ICs2NDU0LDkgQEAKIAkgICAgaWYgKGFmZmlsZS0+YWZfbmVlZGNvbXAgIT0gMCAmJiBmbGFnX2luX2FmZmxpc3QoCiAJCQkgICBhZmZpbGUtPmFmX2ZsYWd0eXBlLCBhZmZsaXN0LCBhZmZpbGUtPmFmX25lZWRjb21wKSkKIAkJZmxhZ3MgfD0gV0ZfTkVFRENPTVA7CisJICAgIGlmIChhZmZpbGUtPmFmX2NvbXByb290ICE9IDAgJiYgZmxhZ19pbl9hZmZsaXN0KAorCQkJICAgYWZmaWxlLT5hZl9mbGFndHlwZSwgYWZmbGlzdCwgYWZmaWxlLT5hZl9jb21wcm9vdCkpCisJCWZsYWdzIHw9IFdGX0NPTVBST09UOwogCSAgICBpZiAoYWZmaWxlLT5hZl9ub3N1Z2dlc3QgIT0gMCAmJiBmbGFnX2luX2FmZmxpc3QoCiAJCQkgICBhZmZpbGUtPmFmX2ZsYWd0eXBlLCBhZmZsaXN0LCBhZmZpbGUtPmFmX25vc3VnZ2VzdCkpCiAJCWZsYWdzIHw9IFdGX05PU1VHR0VTVDsKQEAgLTY1MTIsMTEgKzY2NDIsMTIgQEAKIAkJICAgICAqIEFub3RoZXIgcmVxdWlyZW1lbnQgZnJvbSBNeXNwZWxsIGlzIHRoYXQgdGhlIGNob3AKIAkJICAgICAqIHN0cmluZyBpcyBzaG9ydGVyIHRoYW4gdGhlIHdvcmQgaXRzZWxmLgogCQkgICAgICogRm9yIHByZWZpeGVzLCB3aGVuICJQRlhQT1NUUE9ORSIgd2FzIHVzZWQsIG9ubHkgZG8KLQkJICAgICAqIHByZWZpeGVzIHdpdGggYSBjaG9wIHN0cmluZy4gKi8KKwkJICAgICAqIHByZWZpeGVzIHdpdGggYSBjaG9wIHN0cmluZyBhbmQvb3IgZmxhZ3MuICovCiAJCSAgICByZWdtYXRjaC5yZWdwcm9nID0gYWUtPmFlX3Byb2c7CiAJCSAgICByZWdtYXRjaC5ybV9pYyA9IEZBTFNFOwogCQkgICAgaWYgKCh4aHQgIT0gTlVMTCB8fCAhYWZmaWxlLT5hZl9wZnhwb3N0cG9uZQotCQkJCXx8IGFlLT5hZV9jaG9wICE9IE5VTEwpCisJCQkJfHwgYWUtPmFlX2Nob3AgIT0gTlVMTAorCQkJCXx8IGFlLT5hZV9mbGFncyAhPSBOVUxMKQogCQkJICAgICYmIChhZS0+YWVfY2hvcCA9PSBOVUxMCiAJCQkJfHwgU1RSTEVOKGFlLT5hZV9jaG9wKSA8IHdvcmRsZW4pCiAJCQkgICAgJiYgKGFlLT5hZV9wcm9nID09IE5VTEwKQEAgLTY1NjUsMTUgKzY2OTYsMjQgQEAKIAkJCX0KIAogCQkJLyogT2JleSB0aGUgInJhcmUiIGZsYWcgb2YgdGhlIGFmZml4LiAqLwotCQkJaWYgKGFlLT5hZV9yYXJlKQorCQkJaWYgKGFmZmlsZS0+YWZfcmFyZSAhPSAwCisJCQkJJiYgYWUtPmFlX2ZsYWdzICE9IE5VTEwKKwkJCQkmJiBmbGFnX2luX2FmZmxpc3QoCisJCQkJICAgIGFmZmlsZS0+YWZfZmxhZ3R5cGUsIGFlLT5hZV9mbGFncywKKwkJCQkJCQkgICAgIGFmZmlsZS0+YWZfcmFyZSkpCiAJCQkgICAgdXNlX2ZsYWdzID0gZmxhZ3MgfCBXRl9SQVJFOwogCQkJZWxzZQogCQkJICAgIHVzZV9mbGFncyA9IGZsYWdzOwogCi0JCQkvKiBPYmV5IHRoZSAibm9jb21wIiBmbGFnIG9mIHRoZSBhZmZpeDogZG9uJ3QgdXNlIHRoZQotCQkJICogY29tcG91bmQgZmxhZ3MuICovCisJCQkvKiBPYmV5IGEgIkNPTVBPVU5ERk9SQklEIiBmbGFnIG9mIHRoZSBhZmZpeDogZG9uJ3QKKwkJCSAqIHVzZSB0aGUgY29tcG91bmQgZmxhZ3MuICovCiAJCQl1c2VfcGZ4bGlzdCA9IHBmeGxpc3Q7Ci0JCQlpZiAoYWUtPmFlX25vY29tcCAmJiBwZnhsaXN0ICE9IE5VTEwpCisJCQlpZiAocGZ4bGlzdCAhPSBOVUxMCisJCQkJJiYgYWZmaWxlLT5hZl9jb21wZm9yYmlkICE9IDAKKwkJCQkmJiBhZS0+YWVfZmxhZ3MgIT0gTlVMTAorCQkJCSYmIGZsYWdfaW5fYWZmbGlzdCgKKwkJCQkgICAgYWZmaWxlLT5hZl9mbGFndHlwZSwgYWUtPmFlX2ZsYWdzLAorCQkJCQkJICAgICAgIGFmZmlsZS0+YWZfY29tcGZvcmJpZCkpCiAJCQl7CiAJCQkgICAgdmltX3N0cm5jcHkocGZ4X3BmeGxpc3QsIHBmeGxpc3QsIHBmeGxlbik7CiAJCQkgICAgdXNlX3BmeGxpc3QgPSBwZnhfcGZ4bGlzdDsKQEAgLTc4MDMsMTIgKzc5NDMsMjYgQEAKIAlwdXRjKDAsIGZkKTsJCQkJCS8qIDxzZWN0aW9uZmxhZ3M+ICovCiAKIAlsID0gU1RSTEVOKHNwaW4tPnNpX2NvbXBmbGFncyk7Ci0JcHV0X2J5dGVzKGZkLCAobG9uZ191KShsICsgMyksIDQpOwkJLyogPHNlY3Rpb25sZW4+ICovCisJZm9yIChpID0gMDsgaSA8IHNwaW4tPnNpX2NvbXBwYXQuZ2FfbGVuOyArK2kpCisJICAgIGwgKz0gU1RSTEVOKCgoY2hhcl91ICoqKShzcGluLT5zaV9jb21wcGF0LmdhX2RhdGEpKVtpXSkgKyAxOworCXB1dF9ieXRlcyhmZCwgKGxvbmdfdSkobCArIDcpLCA0KTsJCS8qIDxzZWN0aW9ubGVuPiAqLworCiAJcHV0YyhzcGluLT5zaV9jb21wbWF4LCBmZCk7CQkJLyogPGNvbXBtYXg+ICovCiAJcHV0YyhzcGluLT5zaV9jb21wbWlubGVuLCBmZCk7CQkJLyogPGNvbXBtaW5sZW4+ICovCiAJcHV0YyhzcGluLT5zaV9jb21wc3lsbWF4LCBmZCk7CQkJLyogPGNvbXBzeWxtYXg+ICovCisJcHV0YygwLCBmZCk7CQkvKiBmb3IgVmltIDcuMGIgY29tcGF0aWJpbGl0eSAqLworCXB1dGMoc3Bpbi0+c2lfY29tcG9wdGlvbnMsIGZkKTsJCQkvKiA8Y29tcG9wdGlvbnM+ICovCisJcHV0X2J5dGVzKGZkLCAobG9uZ191KXNwaW4tPnNpX2NvbXBwYXQuZ2FfbGVuLCAyKTsKKwkJCQkJCQkvKiA8Y29tcHBhdGNvdW50PiAqLworCWZvciAoaSA9IDA7IGkgPCBzcGluLT5zaV9jb21wcGF0LmdhX2xlbjsgKytpKQorCXsKKwkgICAgcCA9ICgoY2hhcl91ICoqKShzcGluLT5zaV9jb21wcGF0LmdhX2RhdGEpKVtpXTsKKwkgICAgcHV0YyhTVFJMRU4ocCksIGZkKTsJCQkvKiA8Y29tcHBhdGxlbj4gKi8KKwkgICAgZndyaXRlKHAsIChzaXplX3QpU1RSTEVOKHApLCAoc2l6ZV90KTEsIGZkKTsvKiA8Y29tcHBhdHRleHQ+ICovCisJfQogCQkJCQkJCS8qIDxjb21wZmxhZ3M+ICovCi0JZndyaXRlKHNwaW4tPnNpX2NvbXBmbGFncywgKHNpemVfdClsLCAoc2l6ZV90KTEsIGZkKTsKKwlmd3JpdGUoc3Bpbi0+c2lfY29tcGZsYWdzLCAoc2l6ZV90KVNUUkxFTihzcGluLT5zaV9jb21wZmxhZ3MpLAorCQkJCQkJCSAgICAgICAoc2l6ZV90KTEsIGZkKTsKICAgICB9CiAKICAgICAvKiBTTl9OT0JSRUFLOiBOT0JSRUFLIGZsYWcgKi8KQEAgLTg2MTEsNiArODc2NSw3IEBACiAgICAgZ2FfaW5pdDIoJnNwaW4uc2lfcmVwc2FsLCAoaW50KXNpemVvZihmcm9tdG9fVCksIDIwKTsKICAgICBnYV9pbml0Migmc3Bpbi5zaV9zYWwsIChpbnQpc2l6ZW9mKGZyb210b19UKSwgMjApOwogICAgIGdhX2luaXQyKCZzcGluLnNpX21hcCwgKGludClzaXplb2YoY2hhcl91KSwgMTAwKTsKKyAgICBnYV9pbml0Migmc3Bpbi5zaV9jb21wcGF0LCAoaW50KXNpemVvZihjaGFyX3UgKiksIDIwKTsKICAgICBnYV9pbml0Migmc3Bpbi5zaV9wcmVmY29uZCwgKGludClzaXplb2YoY2hhcl91ICopLCA1MCk7CiAgICAgaGFzaF9pbml0KCZzcGluLnNpX2NvbW1vbndvcmRzKTsKICAgICBzcGluLnNpX25ld2NvbXBJRCA9IDEyNzsJLyogc3RhcnQgY29tcG91bmQgSUQgYXQgZmlyc3QgbWF4aW11bSAqLwpAQCAtODgwNCw2ICs4OTU5LDcgQEAKIAlnYV9jbGVhcigmc3Bpbi5zaV9yZXBzYWwpOwogCWdhX2NsZWFyKCZzcGluLnNpX3NhbCk7CiAJZ2FfY2xlYXIoJnNwaW4uc2lfbWFwKTsKKwlnYV9jbGVhcigmc3Bpbi5zaV9jb21wcGF0KTsKIAlnYV9jbGVhcigmc3Bpbi5zaV9wcmVmY29uZCk7CiAJaGFzaF9jbGVhcl9hbGwoJnNwaW4uc2lfY29tbW9ud29yZHMsIDApOwogCmRpZmYgLS1naXQgYS9zcmMvc3ludGF4LmMgYi9zcmMvc3ludGF4LmMKaW5kZXggNzc3NmMwOS4uZjY2ZjYzOSAxMDA2NDQKLS0tIGEvc3JjL3N5bnRheC5jCisrKyBiL3NyYy9zeW50YXguYwpAQCAtNjA2NiwyMDMgKzYwNjYsMjA4IEBACiAgKiBUaGUgI2lmZGVmcyBhcmUgbmVlZGVkIHRvIHJlZHVjZSB0aGUgYW1vdW50IG9mIHN0YXRpYyBkYXRhLiAgSGVscHMgdG8gbWFrZQogICogdGhlIDE2IGJpdCBET1MgKG11c2V1bSkgdmVyc2lvbiBjb21waWxlLgogICovCisjaWZkZWYgRkVBVF9HVUkKKyMgZGVmaW5lIENFTlQoYSwgYikgYgorI2Vsc2UKKyMgZGVmaW5lIENFTlQoYSwgYikgYQorI2VuZGlmCiBzdGF0aWMgY2hhciAqKGhpZ2hsaWdodF9pbml0X2JvdGhbXSkgPQogICAgIHsKLQkiRXJyb3JNc2cgdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtSZWQgY3Rlcm1mZz1XaGl0ZSIsCi0JIkluY1NlYXJjaCB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSIsCi0JIk1vZGVNc2cgdGVybT1ib2xkIGN0ZXJtPWJvbGQiLAotCSJOb25UZXh0IHRlcm09Ym9sZCBjdGVybWZnPUJsdWUiLAotCSJTdGF0dXNMaW5lIHRlcm09cmV2ZXJzZSxib2xkIGN0ZXJtPXJldmVyc2UsYm9sZCIsCi0JIlN0YXR1c0xpbmVOQyB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSIsCisJQ0VOVCgiRXJyb3JNc2cgdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtSZWQgY3Rlcm1mZz1XaGl0ZSIsCisJICAgICAiRXJyb3JNc2cgdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtSZWQgY3Rlcm1mZz1XaGl0ZSBndWliZz1SZWQgZ3VpZmc9V2hpdGUiKSwKKwlDRU5UKCJJbmNTZWFyY2ggdGVybT1yZXZlcnNlIGN0ZXJtPXJldmVyc2UiLAorCSAgICAgIkluY1NlYXJjaCB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSBndWk9cmV2ZXJzZSIpLAorCUNFTlQoIk1vZGVNc2cgdGVybT1ib2xkIGN0ZXJtPWJvbGQiLAorCSAgICAgIk1vZGVNc2cgdGVybT1ib2xkIGN0ZXJtPWJvbGQgZ3VpPWJvbGQiKSwKKwlDRU5UKCJOb25UZXh0IHRlcm09Ym9sZCBjdGVybWZnPUJsdWUiLAorCSAgICAgIk5vblRleHQgdGVybT1ib2xkIGN0ZXJtZmc9Qmx1ZSBndWk9Ym9sZCBndWlmZz1CbHVlIiksCisJQ0VOVCgiU3RhdHVzTGluZSB0ZXJtPXJldmVyc2UsYm9sZCBjdGVybT1yZXZlcnNlLGJvbGQiLAorCSAgICAgIlN0YXR1c0xpbmUgdGVybT1yZXZlcnNlLGJvbGQgY3Rlcm09cmV2ZXJzZSxib2xkIGd1aT1yZXZlcnNlLGJvbGQiKSwKKwlDRU5UKCJTdGF0dXNMaW5lTkMgdGVybT1yZXZlcnNlIGN0ZXJtPXJldmVyc2UiLAorCSAgICAgIlN0YXR1c0xpbmVOQyB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSBndWk9cmV2ZXJzZSIpLAogI2lmZGVmIEZFQVRfVkVSVFNQTElUCi0JIlZlcnRTcGxpdCB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSIsCisJQ0VOVCgiVmVydFNwbGl0IHRlcm09cmV2ZXJzZSBjdGVybT1yZXZlcnNlIiwKKwkgICAgICJWZXJ0U3BsaXQgdGVybT1yZXZlcnNlIGN0ZXJtPXJldmVyc2UgZ3VpPXJldmVyc2UiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfQ0xJUEJPQVJECi0JIlZpc3VhbE5PUyB0ZXJtPXVuZGVybGluZSxib2xkIGN0ZXJtPXVuZGVybGluZSxib2xkIiwKKwlDRU5UKCJWaXN1YWxOT1MgdGVybT11bmRlcmxpbmUsYm9sZCBjdGVybT11bmRlcmxpbmUsYm9sZCIsCisJICAgICAiVmlzdWFsTk9TIHRlcm09dW5kZXJsaW5lLGJvbGQgY3Rlcm09dW5kZXJsaW5lLGJvbGQgZ3VpPXVuZGVybGluZSxib2xkIiksCiAjZW5kaWYKICNpZmRlZiBGRUFUX0RJRkYKLQkiRGlmZlRleHQgdGVybT1yZXZlcnNlIGN0ZXJtPWJvbGQgY3Rlcm1iZz1SZWQiLAorCUNFTlQoIkRpZmZUZXh0IHRlcm09cmV2ZXJzZSBjdGVybT1ib2xkIGN0ZXJtYmc9UmVkIiwKKwkgICAgICJEaWZmVGV4dCB0ZXJtPXJldmVyc2UgY3Rlcm09Ym9sZCBjdGVybWJnPVJlZCBndWk9Ym9sZCBndWliZz1SZWQiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfSU5TX0VYUEFORAotCSJQbWVudVRodW1iIGN0ZXJtPXJldmVyc2UiLAotCSJQbWVudVNiYXIgY3Rlcm1iZz1HcmV5IiwKKwlDRU5UKCJQbWVudVRodW1iIGN0ZXJtPXJldmVyc2UiLAorCSAgICAgIlBtZW51VGh1bWIgY3Rlcm09cmV2ZXJzZSBndWk9cmV2ZXJzZSIpLAorCUNFTlQoIlBtZW51U2JhciBjdGVybWJnPUdyZXkiLAorCSAgICAgIlBtZW51U2JhciBjdGVybWJnPUdyZXkgZ3VpYmc9R3JleSIpLAogI2VuZGlmCiAjaWZkZWYgRkVBVF9XSU5ET1dTCi0JIlRhYkxpbmVTZWwgdGVybT1ib2xkIGN0ZXJtPWJvbGQiLAotCSJUYWJMaW5lRmlsbCB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSIsCisJQ0VOVCgiVGFiTGluZVNlbCB0ZXJtPWJvbGQgY3Rlcm09Ym9sZCIsCisJICAgICAiVGFiTGluZVNlbCB0ZXJtPWJvbGQgY3Rlcm09Ym9sZCBndWk9Ym9sZCIpLAorCUNFTlQoIlRhYkxpbmVGaWxsIHRlcm09cmV2ZXJzZSBjdGVybT1yZXZlcnNlIiwKKwkgICAgICJUYWJMaW5lRmlsbCB0ZXJtPXJldmVyc2UgY3Rlcm09cmV2ZXJzZSBndWk9cmV2ZXJzZSIpLAogI2VuZGlmCiAjaWZkZWYgRkVBVF9BVVRPQ01ECi0JIk1hdGNoUGFyZW4gdGVybT1yZXZlcnNlIGN0ZXJtYmc9Q3lhbiIsCisJQ0VOVCgiTWF0Y2hQYXJlbiB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1DeWFuIiwKKwkgICAgICJNYXRjaFBhcmVuIHRlcm09cmV2ZXJzZSBjdGVybWJnPUN5YW4gZ3VpYmc9Q3lhbiIpLAogI2VuZGlmCiAjaWZkZWYgRkVBVF9HVUkKLQkiRXJyb3JNc2cgZ3VpYmc9UmVkIGd1aWZnPVdoaXRlIiwKLQkiSW5jU2VhcmNoIGd1aT1yZXZlcnNlIiwKLQkiTW9kZU1zZyBndWk9Ym9sZCIsCi0JIk5vblRleHQgZ3VpPWJvbGQgZ3VpZmc9Qmx1ZSIsCi0JIlN0YXR1c0xpbmUgZ3VpPXJldmVyc2UsYm9sZCIsCi0JIlN0YXR1c0xpbmVOQyBndWk9cmV2ZXJzZSIsCi0JIlZlcnRTcGxpdCBndWk9cmV2ZXJzZSIsCi0JIlZpc3VhbE5PUyBndWk9dW5kZXJsaW5lLGJvbGQiLAotCSJEaWZmVGV4dCBndWk9Ym9sZCBndWliZz1SZWQiLAotCSJQbWVudVRodW1iIGd1aT1yZXZlcnNlIiwKLQkiUG1lbnVTYmFyIGd1aWJnPUdyZXkiLAotCSJUYWJMaW5lU2VsIGd1aT1ib2xkIiwKLQkiVGFiTGluZUZpbGwgZ3VpPXJldmVyc2UiLAotCSJNYXRjaFBhcmVuIGd1aWJnPUN5YW4iLAogCSJDdXJzb3IgZ3VpYmc9ZmcgZ3VpZmc9YmciLAotCSJsQ3Vyc29yIGd1aWJnPWZnIGd1aWZnPWJnIiwJLyogc2hvdWxkIGJlIGRpZmZlcmVudCwgYnV0IHdoYXQ/ICovCisJImxDdXJzb3IgZ3VpYmc9ZmcgZ3VpZmc9YmciLCAvKiBzaG91bGQgYmUgZGlmZmVyZW50LCBidXQgd2hhdD8gKi8KICNlbmRpZgogCU5VTEwKICAgICB9OwogCiBzdGF0aWMgY2hhciAqKGhpZ2hsaWdodF9pbml0X2xpZ2h0W10pID0KICAgICB7Ci0JIkRpcmVjdG9yeSB0ZXJtPWJvbGQgY3Rlcm1mZz1EYXJrQmx1ZSIsCi0JIkxpbmVOciB0ZXJtPXVuZGVybGluZSBjdGVybWZnPUJyb3duIiwKLQkiTW9yZU1zZyB0ZXJtPWJvbGQgY3Rlcm1mZz1EYXJrR3JlZW4iLAotCSJRdWVzdGlvbiB0ZXJtPXN0YW5kb3V0IGN0ZXJtZmc9RGFya0dyZWVuIiwKLQkiU2VhcmNoIHRlcm09cmV2ZXJzZSBjdGVybWJnPVllbGxvdyBjdGVybWZnPU5PTkUiLAorCUNFTlQoIkRpcmVjdG9yeSB0ZXJtPWJvbGQgY3Rlcm1mZz1EYXJrQmx1ZSIsCisJICAgICAiRGlyZWN0b3J5IHRlcm09Ym9sZCBjdGVybWZnPURhcmtCbHVlIGd1aWZnPUJsdWUiKSwKKwlDRU5UKCJMaW5lTnIgdGVybT11bmRlcmxpbmUgY3Rlcm1mZz1Ccm93biIsCisJICAgICAiTGluZU5yIHRlcm09dW5kZXJsaW5lIGN0ZXJtZmc9QnJvd24gZ3VpZmc9QnJvd24iKSwKKwlDRU5UKCJNb3JlTXNnIHRlcm09Ym9sZCBjdGVybWZnPURhcmtHcmVlbiIsCisJICAgICAiTW9yZU1zZyB0ZXJtPWJvbGQgY3Rlcm1mZz1EYXJrR3JlZW4gZ3VpPWJvbGQgZ3VpZmc9U2VhR3JlZW4iKSwKKwlDRU5UKCJRdWVzdGlvbiB0ZXJtPXN0YW5kb3V0IGN0ZXJtZmc9RGFya0dyZWVuIiwKKwkgICAgICJRdWVzdGlvbiB0ZXJtPXN0YW5kb3V0IGN0ZXJtZmc9RGFya0dyZWVuIGd1aT1ib2xkIGd1aWZnPVNlYUdyZWVuIiksCisJQ0VOVCgiU2VhcmNoIHRlcm09cmV2ZXJzZSBjdGVybWJnPVllbGxvdyBjdGVybWZnPU5PTkUiLAorCSAgICAgIlNlYXJjaCB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1ZZWxsb3cgY3Rlcm1mZz1OT05FIGd1aWJnPVllbGxvdyBndWlmZz1OT05FIiksCiAjaWZkZWYgRkVBVF9TUEVMTAotCSJTcGVsbEJhZCB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1MaWdodFJlZCIsCi0JIlNwZWxsQ2FwIHRlcm09cmV2ZXJzZSBjdGVybWJnPUxpZ2h0Qmx1ZSIsCi0JIlNwZWxsUmFyZSB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1MaWdodE1hZ2VudGEiLAotCSJTcGVsbExvY2FsIHRlcm09dW5kZXJsaW5lIGN0ZXJtYmc9Q3lhbiIsCisJQ0VOVCgiU3BlbGxCYWQgdGVybT1yZXZlcnNlIGN0ZXJtYmc9TGlnaHRSZWQiLAorCSAgICAgIlNwZWxsQmFkIHRlcm09cmV2ZXJzZSBjdGVybWJnPUxpZ2h0UmVkIGd1aXNwPVJlZCBndWk9dW5kZXJjdXJsIiksCisJQ0VOVCgiU3BlbGxDYXAgdGVybT1yZXZlcnNlIGN0ZXJtYmc9TGlnaHRCbHVlIiwKKwkgICAgICJTcGVsbENhcCB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1MaWdodEJsdWUgZ3Vpc3A9Qmx1ZSBndWk9dW5kZXJjdXJsIiksCisJQ0VOVCgiU3BlbGxSYXJlIHRlcm09cmV2ZXJzZSBjdGVybWJnPUxpZ2h0TWFnZW50YSIsCisJICAgICAiU3BlbGxSYXJlIHRlcm09cmV2ZXJzZSBjdGVybWJnPUxpZ2h0TWFnZW50YSBndWlzcD1NYWdlbnRhIGd1aT11bmRlcmN1cmwiKSwKKwlDRU5UKCJTcGVsbExvY2FsIHRlcm09dW5kZXJsaW5lIGN0ZXJtYmc9Q3lhbiIsCisJICAgICAiU3BlbGxMb2NhbCB0ZXJtPXVuZGVybGluZSBjdGVybWJnPUN5YW4gZ3Vpc3A9RGFya0N5YW4gZ3VpPXVuZGVyY3VybCIpLAogI2VuZGlmCiAjaWZkZWYgRkVBVF9JTlNfRVhQQU5ECi0JIlBtZW51IGN0ZXJtYmc9TGlnaHRNYWdlbnRhIiwKLQkiUG1lbnVTZWwgY3Rlcm1iZz1MaWdodEdyZXkiLAorCUNFTlQoIlBtZW51IGN0ZXJtYmc9TGlnaHRNYWdlbnRhIiwKKwkgICAgICJQbWVudSBjdGVybWJnPUxpZ2h0TWFnZW50YSBndWliZz1MaWdodE1hZ2VudGEiKSwKKwlDRU5UKCJQbWVudVNlbCBjdGVybWJnPUxpZ2h0R3JleSIsCisJICAgICAiUG1lbnVTZWwgY3Rlcm1iZz1MaWdodEdyZXkgZ3VpYmc9R3JleSIpLAogI2VuZGlmCi0JIlNwZWNpYWxLZXkgdGVybT1ib2xkIGN0ZXJtZmc9RGFya0JsdWUiLAotCSJUaXRsZSB0ZXJtPWJvbGQgY3Rlcm1mZz1EYXJrTWFnZW50YSIsCi0JIldhcm5pbmdNc2cgdGVybT1zdGFuZG91dCBjdGVybWZnPURhcmtSZWQiLAorCUNFTlQoIlNwZWNpYWxLZXkgdGVybT1ib2xkIGN0ZXJtZmc9RGFya0JsdWUiLAorCSAgICAgIlNwZWNpYWxLZXkgdGVybT1ib2xkIGN0ZXJtZmc9RGFya0JsdWUgZ3VpZmc9Qmx1ZSIpLAorCUNFTlQoIlRpdGxlIHRlcm09Ym9sZCBjdGVybWZnPURhcmtNYWdlbnRhIiwKKwkgICAgICJUaXRsZSB0ZXJtPWJvbGQgY3Rlcm1mZz1EYXJrTWFnZW50YSBndWk9Ym9sZCBndWlmZz1NYWdlbnRhIiksCisJQ0VOVCgiV2FybmluZ01zZyB0ZXJtPXN0YW5kb3V0IGN0ZXJtZmc9RGFya1JlZCIsCisJICAgICAiV2FybmluZ01zZyB0ZXJtPXN0YW5kb3V0IGN0ZXJtZmc9RGFya1JlZCBndWlmZz1SZWQiKSwKICNpZmRlZiBGRUFUX1dJTERNRU5VCi0JIldpbGRNZW51IHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1ZZWxsb3cgY3Rlcm1mZz1CbGFjayIsCisJQ0VOVCgiV2lsZE1lbnUgdGVybT1zdGFuZG91dCBjdGVybWJnPVllbGxvdyBjdGVybWZnPUJsYWNrIiwKKwkgICAgICJXaWxkTWVudSB0ZXJtPXN0YW5kb3V0IGN0ZXJtYmc9WWVsbG93IGN0ZXJtZmc9QmxhY2sgZ3VpYmc9WWVsbG93IGd1aWZnPUJsYWNrIiksCiAjZW5kaWYKICNpZmRlZiBGRUFUX0ZPTERJTkcKLQkiRm9sZGVkIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1HcmV5IGN0ZXJtZmc9RGFya0JsdWUiLAotCSJGb2xkQ29sdW1uIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1HcmV5IGN0ZXJtZmc9RGFya0JsdWUiLAorCUNFTlQoIkZvbGRlZCB0ZXJtPXN0YW5kb3V0IGN0ZXJtYmc9R3JleSBjdGVybWZnPURhcmtCbHVlIiwKKwkgICAgICJGb2xkZWQgdGVybT1zdGFuZG91dCBjdGVybWJnPUdyZXkgY3Rlcm1mZz1EYXJrQmx1ZSBndWliZz1MaWdodEdyZXkgZ3VpZmc9RGFya0JsdWUiKSwKKwlDRU5UKCJGb2xkQ29sdW1uIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1HcmV5IGN0ZXJtZmc9RGFya0JsdWUiLAorCSAgICAgIkZvbGRDb2x1bW4gdGVybT1zdGFuZG91dCBjdGVybWJnPUdyZXkgY3Rlcm1mZz1EYXJrQmx1ZSBndWliZz1HcmV5IGd1aWZnPURhcmtCbHVlIiksCiAjZW5kaWYKICNpZmRlZiBGRUFUX1NJR05TCi0JIlNpZ25Db2x1bW4gdGVybT1zdGFuZG91dCBjdGVybWJnPUdyZXkgY3Rlcm1mZz1EYXJrQmx1ZSIsCisJQ0VOVCgiU2lnbkNvbHVtbiB0ZXJtPXN0YW5kb3V0IGN0ZXJtYmc9R3JleSBjdGVybWZnPURhcmtCbHVlIiwKKwkgICAgICJTaWduQ29sdW1uIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1HcmV5IGN0ZXJtZmc9RGFya0JsdWUgZ3VpYmc9R3JleSBndWlmZz1EYXJrQmx1ZSIpLAogI2VuZGlmCiAjaWZkZWYgRkVBVF9WSVNVQUwKLQkiVmlzdWFsIHRlcm09cmV2ZXJzZSBjdGVybWJnPU1hZ2VudGEiLAorCUNFTlQoIlZpc3VhbCB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1NYWdlbnRhIiwKKwkgICAgICJWaXN1YWwgdGVybT1yZXZlcnNlIGN0ZXJtYmc9TWFnZW50YSBndWliZz1MaWdodEdyZXkiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfRElGRgotCSJEaWZmQWRkIHRlcm09Ym9sZCBjdGVybWJnPUxpZ2h0Qmx1ZSIsCi0JIkRpZmZDaGFuZ2UgdGVybT1ib2xkIGN0ZXJtYmc9TGlnaHRNYWdlbnRhIiwKLQkiRGlmZkRlbGV0ZSB0ZXJtPWJvbGQgY3Rlcm1mZz1CbHVlIGN0ZXJtYmc9TGlnaHRDeWFuIiwKKwlDRU5UKCJEaWZmQWRkIHRlcm09Ym9sZCBjdGVybWJnPUxpZ2h0Qmx1ZSIsCisJICAgICAiRGlmZkFkZCB0ZXJtPWJvbGQgY3Rlcm1iZz1MaWdodEJsdWUgZ3VpYmc9TGlnaHRCbHVlIiksCisJQ0VOVCgiRGlmZkNoYW5nZSB0ZXJtPWJvbGQgY3Rlcm1iZz1MaWdodE1hZ2VudGEiLAorCSAgICAgIkRpZmZDaGFuZ2UgdGVybT1ib2xkIGN0ZXJtYmc9TGlnaHRNYWdlbnRhIGd1aWJnPUxpZ2h0TWFnZW50YSIpLAorCUNFTlQoIkRpZmZEZWxldGUgdGVybT1ib2xkIGN0ZXJtZmc9Qmx1ZSBjdGVybWJnPUxpZ2h0Q3lhbiIsCisJICAgICAiRGlmZkRlbGV0ZSB0ZXJtPWJvbGQgY3Rlcm1mZz1CbHVlIGN0ZXJtYmc9TGlnaHRDeWFuIGd1aT1ib2xkIGd1aWZnPUJsdWUgZ3VpYmc9TGlnaHRDeWFuIiksCiAjZW5kaWYKICNpZmRlZiBGRUFUX1dJTkRPV1MKLQkiVGFiTGluZSB0ZXJtPXVuZGVybGluZSBjdGVybT11bmRlcmxpbmUgY3Rlcm1mZz1ibGFjayBjdGVybWJnPUxpZ2h0R3JleSIsCisJQ0VOVCgiVGFiTGluZSB0ZXJtPXVuZGVybGluZSBjdGVybT11bmRlcmxpbmUgY3Rlcm1mZz1ibGFjayBjdGVybWJnPUxpZ2h0R3JleSIsCisJICAgICAiVGFiTGluZSB0ZXJtPXVuZGVybGluZSBjdGVybT11bmRlcmxpbmUgY3Rlcm1mZz1ibGFjayBjdGVybWJnPUxpZ2h0R3JleSBndWk9dW5kZXJsaW5lIGd1aWJnPUxpZ2h0R3JleSIpLAogI2VuZGlmCiAjaWZkZWYgRkVBVF9TWU5fSEwKLQkiQ3Vyc29yQ29sdW1uIHRlcm09cmV2ZXJzZSBjdGVybWJnPUxpZ2h0R3JleSIsCi0JIkN1cnNvckxpbmUgdGVybT11bmRlcmxpbmUgY3Rlcm09dW5kZXJsaW5lIiwKKwlDRU5UKCJDdXJzb3JDb2x1bW4gdGVybT1yZXZlcnNlIGN0ZXJtYmc9TGlnaHRHcmV5IiwKKwkgICAgICJDdXJzb3JDb2x1bW4gdGVybT1yZXZlcnNlIGN0ZXJtYmc9TGlnaHRHcmV5IGd1aWJnPUxpZ2h0R3JleSIpLAorCUNFTlQoIkN1cnNvckxpbmUgdGVybT11bmRlcmxpbmUgY3Rlcm09dW5kZXJsaW5lIiwKKwkgICAgICJDdXJzb3JMaW5lIHRlcm09dW5kZXJsaW5lIGN0ZXJtPXVuZGVybGluZSBndWliZz1MaWdodEdyZXkiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfR1VJCi0JIkRpcmVjdG9yeSBndWlmZz1CbHVlIiwKLQkiTGluZU5yIGd1aWZnPUJyb3duIiwKLQkiTW9yZU1zZyBndWk9Ym9sZCBndWlmZz1TZWFHcmVlbiIsCiAJIk5vcm1hbCBndWk9Tk9ORSIsCi0JIlF1ZXN0aW9uIGd1aT1ib2xkIGd1aWZnPVNlYUdyZWVuIiwKLQkiU2VhcmNoIGd1aWJnPVllbGxvdyBndWlmZz1OT05FIiwKLQkiU3BlbGxCYWQgZ3Vpc3A9UmVkIGd1aT11bmRlcmN1cmwiLAotCSJTcGVsbENhcCBndWlzcD1CbHVlIGd1aT11bmRlcmN1cmwiLAotCSJTcGVsbFJhcmUgZ3Vpc3A9TWFnZW50YSBndWk9dW5kZXJjdXJsIiwKLQkiU3BlbGxMb2NhbCBndWlzcD1EYXJrQ3lhbiBndWk9dW5kZXJjdXJsIiwKLQkiUG1lbnUgZ3VpYmc9TGlnaHRNYWdlbnRhIiwKLQkiUG1lbnVTZWwgZ3VpYmc9R3JleSIsCi0JIlNwZWNpYWxLZXkgZ3VpZmc9Qmx1ZSIsCi0JIlRpdGxlIGd1aT1ib2xkIGd1aWZnPU1hZ2VudGEiLAotCSJXYXJuaW5nTXNnIGd1aWZnPVJlZCIsCi0JIldpbGRNZW51IGd1aWJnPVllbGxvdyBndWlmZz1CbGFjayIsCi0JIkZvbGRlZCBndWliZz1MaWdodEdyZXkgZ3VpZmc9RGFya0JsdWUiLAotCSJGb2xkQ29sdW1uIGd1aWJnPUdyZXkgZ3VpZmc9RGFya0JsdWUiLAotCSJTaWduQ29sdW1uIGd1aWJnPUdyZXkgZ3VpZmc9RGFya0JsdWUiLAotCSJWaXN1YWwgZ3VpYmc9TGlnaHRHcmV5IiwKLQkiRGlmZkFkZCBndWliZz1MaWdodEJsdWUiLAotCSJEaWZmQ2hhbmdlIGd1aWJnPUxpZ2h0TWFnZW50YSIsCi0JIkRpZmZEZWxldGUgZ3VpPWJvbGQgZ3VpZmc9Qmx1ZSBndWliZz1MaWdodEN5YW4iLAotCSJUYWJMaW5lIGd1aT11bmRlcmxpbmUgZ3VpYmc9TGlnaHRHcmV5IiwKLQkiQ3Vyc29yQ29sdW1uIGd1aWJnPUxpZ2h0R3JleSIsCi0JIkN1cnNvckxpbmUgZ3VpYmc9TGlnaHRHcmV5IiwKICNlbmRpZgogCU5VTEwKICAgICB9OwogCiBzdGF0aWMgY2hhciAqKGhpZ2hsaWdodF9pbml0X2RhcmtbXSkgPQogICAgIHsKLQkiRGlyZWN0b3J5IHRlcm09Ym9sZCBjdGVybWZnPUxpZ2h0Q3lhbiIsCi0JIkxpbmVOciB0ZXJtPXVuZGVybGluZSBjdGVybWZnPVllbGxvdyIsCi0JIk1vcmVNc2cgdGVybT1ib2xkIGN0ZXJtZmc9TGlnaHRHcmVlbiIsCi0JIlF1ZXN0aW9uIHRlcm09c3RhbmRvdXQgY3Rlcm1mZz1MaWdodEdyZWVuIiwKLQkiU2VhcmNoIHRlcm09cmV2ZXJzZSBjdGVybWJnPVllbGxvdyBjdGVybWZnPUJsYWNrIiwKLQkiU3BlY2lhbEtleSB0ZXJtPWJvbGQgY3Rlcm1mZz1MaWdodEJsdWUiLAorCUNFTlQoIkRpcmVjdG9yeSB0ZXJtPWJvbGQgY3Rlcm1mZz1MaWdodEN5YW4iLAorCSAgICAgIkRpcmVjdG9yeSB0ZXJtPWJvbGQgY3Rlcm1mZz1MaWdodEN5YW4gZ3VpZmc9Q3lhbiIpLAorCUNFTlQoIkxpbmVOciB0ZXJtPXVuZGVybGluZSBjdGVybWZnPVllbGxvdyIsCisJICAgICAiTGluZU5yIHRlcm09dW5kZXJsaW5lIGN0ZXJtZmc9WWVsbG93IGd1aWZnPVllbGxvdyIpLAorCUNFTlQoIk1vcmVNc2cgdGVybT1ib2xkIGN0ZXJtZmc9TGlnaHRHcmVlbiIsCisJICAgICAiTW9yZU1zZyB0ZXJtPWJvbGQgY3Rlcm1mZz1MaWdodEdyZWVuIGd1aT1ib2xkIGd1aWZnPVNlYUdyZWVuIiksCisJQ0VOVCgiUXVlc3Rpb24gdGVybT1zdGFuZG91dCBjdGVybWZnPUxpZ2h0R3JlZW4iLAorCSAgICAgIlF1ZXN0aW9uIHRlcm09c3RhbmRvdXQgY3Rlcm1mZz1MaWdodEdyZWVuIGd1aT1ib2xkIGd1aWZnPUdyZWVuIiksCisJQ0VOVCgiU2VhcmNoIHRlcm09cmV2ZXJzZSBjdGVybWJnPVllbGxvdyBjdGVybWZnPUJsYWNrIiwKKwkgICAgICJTZWFyY2ggdGVybT1yZXZlcnNlIGN0ZXJtYmc9WWVsbG93IGN0ZXJtZmc9QmxhY2sgZ3VpYmc9WWVsbG93IGd1aWZnPUJsYWNrIiksCisJQ0VOVCgiU3BlY2lhbEtleSB0ZXJtPWJvbGQgY3Rlcm1mZz1MaWdodEJsdWUiLAorCSAgICAgIlNwZWNpYWxLZXkgdGVybT1ib2xkIGN0ZXJtZmc9TGlnaHRCbHVlIGd1aWZnPUN5YW4iKSwKICNpZmRlZiBGRUFUX1NQRUxMCi0JIlNwZWxsQmFkIHRlcm09cmV2ZXJzZSBjdGVybWJnPVJlZCIsCi0JIlNwZWxsQ2FwIHRlcm09cmV2ZXJzZSBjdGVybWJnPUJsdWUiLAotCSJTcGVsbFJhcmUgdGVybT1yZXZlcnNlIGN0ZXJtYmc9TWFnZW50YSIsCi0JIlNwZWxsTG9jYWwgdGVybT11bmRlcmxpbmUgY3Rlcm1iZz1DeWFuIiwKKwlDRU5UKCJTcGVsbEJhZCB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1SZWQiLAorCSAgICAgIlNwZWxsQmFkIHRlcm09cmV2ZXJzZSBjdGVybWJnPVJlZCBndWlzcD1SZWQgZ3VpPXVuZGVyY3VybCIpLAorCUNFTlQoIlNwZWxsQ2FwIHRlcm09cmV2ZXJzZSBjdGVybWJnPUJsdWUiLAorCSAgICAgIlNwZWxsQ2FwIHRlcm09cmV2ZXJzZSBjdGVybWJnPUJsdWUgZ3Vpc3A9Qmx1ZSBndWk9dW5kZXJjdXJsIiksCisJQ0VOVCgiU3BlbGxSYXJlIHRlcm09cmV2ZXJzZSBjdGVybWJnPU1hZ2VudGEiLAorCSAgICAgIlNwZWxsUmFyZSB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1NYWdlbnRhIGd1aXNwPU1hZ2VudGEgZ3VpPXVuZGVyY3VybCIpLAorCUNFTlQoIlNwZWxsTG9jYWwgdGVybT11bmRlcmxpbmUgY3Rlcm1iZz1DeWFuIiwKKwkgICAgICJTcGVsbExvY2FsIHRlcm09dW5kZXJsaW5lIGN0ZXJtYmc9Q3lhbiBndWlzcD1DeWFuIGd1aT11bmRlcmN1cmwiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfSU5TX0VYUEFORAotCSJQbWVudSBjdGVybWJnPU1hZ2VudGEiLAotCSJQbWVudVNlbCBjdGVybWJnPURhcmtHcmV5IiwKKwlDRU5UKCJQbWVudSBjdGVybWJnPU1hZ2VudGEiLAorCSAgICAgIlBtZW51IGN0ZXJtYmc9TWFnZW50YSBndWliZz1NYWdlbnRhIiksCisJQ0VOVCgiUG1lbnVTZWwgY3Rlcm1iZz1EYXJrR3JleSIsCisJICAgICAiUG1lbnVTZWwgY3Rlcm1iZz1EYXJrR3JleSBndWliZz1EYXJrR3JleSIpLAogI2VuZGlmCi0JIlRpdGxlIHRlcm09Ym9sZCBjdGVybWZnPUxpZ2h0TWFnZW50YSIsCi0JIldhcm5pbmdNc2cgdGVybT1zdGFuZG91dCBjdGVybWZnPUxpZ2h0UmVkIiwKKwlDRU5UKCJUaXRsZSB0ZXJtPWJvbGQgY3Rlcm1mZz1MaWdodE1hZ2VudGEiLAorCSAgICAgIlRpdGxlIHRlcm09Ym9sZCBjdGVybWZnPUxpZ2h0TWFnZW50YSBndWk9Ym9sZCBndWlmZz1NYWdlbnRhIiksCisJQ0VOVCgiV2FybmluZ01zZyB0ZXJtPXN0YW5kb3V0IGN0ZXJtZmc9TGlnaHRSZWQiLAorCSAgICAgIldhcm5pbmdNc2cgdGVybT1zdGFuZG91dCBjdGVybWZnPUxpZ2h0UmVkIGd1aWZnPVJlZCIpLAogI2lmZGVmIEZFQVRfV0lMRE1FTlUKLQkiV2lsZE1lbnUgdGVybT1zdGFuZG91dCBjdGVybWJnPVllbGxvdyBjdGVybWZnPUJsYWNrIiwKKwlDRU5UKCJXaWxkTWVudSB0ZXJtPXN0YW5kb3V0IGN0ZXJtYmc9WWVsbG93IGN0ZXJtZmc9QmxhY2siLAorCSAgICAgIldpbGRNZW51IHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1ZZWxsb3cgY3Rlcm1mZz1CbGFjayBndWliZz1ZZWxsb3cgZ3VpZmc9QmxhY2siKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfRk9MRElORwotCSJGb2xkZWQgdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtHcmV5IGN0ZXJtZmc9Q3lhbiIsCi0JIkZvbGRDb2x1bW4gdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtHcmV5IGN0ZXJtZmc9Q3lhbiIsCisJQ0VOVCgiRm9sZGVkIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1EYXJrR3JleSBjdGVybWZnPUN5YW4iLAorCSAgICAgIkZvbGRlZCB0ZXJtPXN0YW5kb3V0IGN0ZXJtYmc9RGFya0dyZXkgY3Rlcm1mZz1DeWFuIGd1aWJnPURhcmtHcmV5IGd1aWZnPUN5YW4iKSwKKwlDRU5UKCJGb2xkQ29sdW1uIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1EYXJrR3JleSBjdGVybWZnPUN5YW4iLAorCSAgICAgIkZvbGRDb2x1bW4gdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtHcmV5IGN0ZXJtZmc9Q3lhbiBndWliZz1HcmV5IGd1aWZnPUN5YW4iKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfU0lHTlMKLQkiU2lnbkNvbHVtbiB0ZXJtPXN0YW5kb3V0IGN0ZXJtYmc9RGFya0dyZXkgY3Rlcm1mZz1DeWFuIiwKKwlDRU5UKCJTaWduQ29sdW1uIHRlcm09c3RhbmRvdXQgY3Rlcm1iZz1EYXJrR3JleSBjdGVybWZnPUN5YW4iLAorCSAgICAgIlNpZ25Db2x1bW4gdGVybT1zdGFuZG91dCBjdGVybWJnPURhcmtHcmV5IGN0ZXJtZmc9Q3lhbiBndWliZz1HcmV5IGd1aWZnPUN5YW4iKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfVklTVUFMCi0JIlZpc3VhbCB0ZXJtPXJldmVyc2UgY3Rlcm1iZz1NYWdlbnRhIiwKKwlDRU5UKCJWaXN1YWwgdGVybT1yZXZlcnNlIGN0ZXJtYmc9TWFnZW50YSIsCisJICAgICAiVmlzdWFsIHRlcm09cmV2ZXJzZSBjdGVybWJnPU1hZ2VudGEgZ3VpYmc9RGFya0dyZXkiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfRElGRgotCSJEaWZmQWRkIHRlcm09Ym9sZCBjdGVybWJnPURhcmtCbHVlIiwKLQkiRGlmZkNoYW5nZSB0ZXJtPWJvbGQgY3Rlcm1iZz1EYXJrTWFnZW50YSIsCi0JIkRpZmZEZWxldGUgdGVybT1ib2xkIGN0ZXJtZmc9Qmx1ZSBjdGVybWJnPURhcmtDeWFuIiwKKwlDRU5UKCJEaWZmQWRkIHRlcm09Ym9sZCBjdGVybWJnPURhcmtCbHVlIiwKKwkgICAgICJEaWZmQWRkIHRlcm09Ym9sZCBjdGVybWJnPURhcmtCbHVlIGd1aWJnPURhcmtCbHVlIiksCisJQ0VOVCgiRGlmZkNoYW5nZSB0ZXJtPWJvbGQgY3Rlcm1iZz1EYXJrTWFnZW50YSIsCisJICAgICAiRGlmZkNoYW5nZSB0ZXJtPWJvbGQgY3Rlcm1iZz1EYXJrTWFnZW50YSBndWliZz1EYXJrTWFnZW50YSIpLAorCUNFTlQoIkRpZmZEZWxldGUgdGVybT1ib2xkIGN0ZXJtZmc9Qmx1ZSBjdGVybWJnPURhcmtDeWFuIiwKKwkgICAgICJEaWZmRGVsZXRlIHRlcm09Ym9sZCBjdGVybWZnPUJsdWUgY3Rlcm1iZz1EYXJrQ3lhbiBndWk9Ym9sZCBndWlmZz1CbHVlIGd1aWJnPURhcmtDeWFuIiksCiAjZW5kaWYKICNpZmRlZiBGRUFUX1dJTkRPV1MKLQkiVGFiTGluZSB0ZXJtPXVuZGVybGluZSBjdGVybT11bmRlcmxpbmUgY3Rlcm1mZz13aGl0ZSBjdGVybWJnPURhcmtHcmV5IiwKKwlDRU5UKCJUYWJMaW5lIHRlcm09dW5kZXJsaW5lIGN0ZXJtPXVuZGVybGluZSBjdGVybWZnPXdoaXRlIGN0ZXJtYmc9RGFya0dyZXkiLAorCSAgICAgIlRhYkxpbmUgdGVybT11bmRlcmxpbmUgY3Rlcm09dW5kZXJsaW5lIGN0ZXJtZmc9d2hpdGUgY3Rlcm1iZz1EYXJrR3JleSBndWk9dW5kZXJsaW5lIGd1aWJnPURhcmtHcmV5IiksCiAjZW5kaWYKICNpZmRlZiBGRUFUX1NZTl9ITAotCSJDdXJzb3JDb2x1bW4gdGVybT1yZXZlcnNlIGN0ZXJtYmc9RGFya0dyZXkiLAotCSJDdXJzb3JMaW5lIHRlcm09dW5kZXJsaW5lIGN0ZXJtPXVuZGVybGluZSIsCisJQ0VOVCgiQ3Vyc29yQ29sdW1uIHRlcm09cmV2ZXJzZSBjdGVybWJnPURhcmtHcmV5IiwKKwkgICAgICJDdXJzb3JDb2x1bW4gdGVybT1yZXZlcnNlIGN0ZXJtYmc9RGFya0dyZXkgZ3VpYmc9RGFya0dyZXkiKSwKKwlDRU5UKCJDdXJzb3JMaW5lIHRlcm09dW5kZXJsaW5lIGN0ZXJtPXVuZGVybGluZSIsCisJICAgICAiQ3Vyc29yTGluZSB0ZXJtPXVuZGVybGluZSBjdGVybT11bmRlcmxpbmUgZ3VpYmc9RGFya0dyZXkiKSwKICNlbmRpZgogI2lmZGVmIEZFQVRfR1VJCi0JIkRpcmVjdG9yeSBndWlmZz1DeWFuIiwKLQkiTGluZU5yIGd1aWZnPVllbGxvdyIsCi0JIk1vcmVNc2cgZ3VpPWJvbGQgZ3VpZmc9U2VhR3JlZW4iLAogCSJOb3JtYWwgZ3VpPU5PTkUiLAotCSJRdWVzdGlvbiBndWk9Ym9sZCBndWlmZz1HcmVlbiIsCi0JIlNlYXJjaCBndWliZz1ZZWxsb3cgZ3VpZmc9QmxhY2siLAotCSJTcGVjaWFsS2V5IGd1aWZnPUN5YW4iLAotCSJTcGVsbEJhZCBndWlzcD1SZWQgZ3VpPXVuZGVyY3VybCIsCi0JIlNwZWxsQ2FwIGd1aXNwPUJsdWUgZ3VpPXVuZGVyY3VybCIsCi0JIlNwZWxsUmFyZSBndWlzcD1NYWdlbnRhIGd1aT11bmRlcmN1cmwiLAotCSJTcGVsbExvY2FsIGd1aXNwPUN5YW4gZ3VpPXVuZGVyY3VybCIsCi0JIlBtZW51IGd1aWJnPU1hZ2VudGEiLAotCSJQbWVudVNlbCBndWliZz1EYXJrR3JleSIsCi0JIlRpdGxlIGd1aT1ib2xkIGd1aWZnPU1hZ2VudGEiLAotCSJXYXJuaW5nTXNnIGd1aWZnPVJlZCIsCi0JIldpbGRNZW51IGd1aWJnPVllbGxvdyBndWlmZz1CbGFjayIsCi0JIkZvbGRlZCBndWliZz1EYXJrR3JleSBndWlmZz1DeWFuIiwKLQkiRm9sZENvbHVtbiBndWliZz1HcmV5IGd1aWZnPUN5YW4iLAotCSJTaWduQ29sdW1uIGd1aWJnPUdyZXkgZ3VpZmc9Q3lhbiIsCi0JIlZpc3VhbCBndWliZz1EYXJrR3JleSIsCi0JIkRpZmZBZGQgZ3VpYmc9RGFya0JsdWUiLAotCSJEaWZmQ2hhbmdlIGd1aWJnPURhcmtNYWdlbnRhIiwKLQkiRGlmZkRlbGV0ZSBndWk9Ym9sZCBndWlmZz1CbHVlIGd1aWJnPURhcmtDeWFuIiwKLQkiVGFiTGluZSBndWk9dW5kZXJsaW5lIGd1aWJnPURhcmtHcmV5IiwKLQkiQ3Vyc29yQ29sdW1uIGd1aWJnPURhcmtHcmV5IiwKLQkiQ3Vyc29yTGluZSBndWliZz1EYXJrR3JleSIsCiAjZW5kaWYKIAlOVUxMCiAgICAgfTsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0ZGlyL3Rlc3Q1OC5pbiBiL3NyYy90ZXN0ZGlyL3Rlc3Q1OC5pbgppbmRleCA3ZGI2YTllLi4wY2Q4NGVlIDEwMDY0NAotLS0gYS9zcmMvdGVzdGRpci90ZXN0NTguaW4KKysrIGIvc3JjL3Rlc3RkaXIvdGVzdDU4LmluCkBAIC00MjAsNyArNDIwLDggQEAKIENPTVBPVU5EUlVMRSBzbSplCiBDT01QT1VORFJVTEUgc20rCiBDT01QT1VORE1JTiAzCi1DT01QT1VORE1BWCAzCitDT01QT1VORFdPUkRNQVggMworQ09NUE9VTkRGT1JCSURGTEFHIHQKIAogQ09NUE9VTkRTWUxNQVggNQogU1lMTEFCTEUgYeFl6Wntb/P29XX6/Pt5L2FhL2F1L2VhL2VlL2VpL2llL29hL29lL29vL291L3V1L3VpCkBAIC00NDcsNyArNDQ4LDcgQEAKIAogU0ZYIGEgWSAyCiBTRlggYSAwIHMgLgotU0ZYIGEgMCBpemUgLiBub2NvbXAKK1NGWCBhIDAgaXplL3QgLgogCiBQRlggcCBOIDEKIFBGWCBwIDAgcHJlIC4KZGlmZiAtLWdpdCBhL3NyYy90ZXN0ZGlyL3Rlc3Q1OS5pbiBiL3NyYy90ZXN0ZGlyL3Rlc3Q1OS5pbgppbmRleCBkOGUwYTk3Li5jZjljYjQ5IDEwMDY0NAotLS0gYS9zcmMvdGVzdGRpci90ZXN0NTkuaW4KKysrIGIvc3JjL3Rlc3RkaXIvdGVzdDU5LmluCkBAIC00MjQsNyArNDI0LDggQEAKIENPTVBPVU5EUlVMRSBzbSplCiBDT01QT1VORFJVTEUgc20rCiBDT01QT1VORE1JTiAzCi1DT01QT1VORE1BWCAzCitDT01QT1VORFdPUkRNQVggMworQ09NUE9VTkRGT1JCSURGTEFHIHQKIAogQ09NUE9VTkRTWUxNQVggNQogU1lMTEFCTEUgYeFl6Wntb/P29XX6/Pt5L2FhL2F1L2VhL2VlL2VpL2llL29hL29lL29vL291L3V1L3VpCkBAIC00NTEsNyArNDUyLDcgQEAKIAogU0ZYIGEgWSAyCiBTRlggYSAwIHMgLgotU0ZYIGEgMCBpemUgLiBub2NvbXAKK1NGWCBhIDAgaXplL3QgLgogCiBQRlggcCBOIDEKIFBGWCBwIDAgcHJlIC4KZGlmZiAtLWdpdCBhL3NyYy92ZXJzaW9uLmggYi9zcmMvdmVyc2lvbi5oCmluZGV4IGQ4Y2RlNjcuLjk2NWVlODMgMTAwNjQ0Ci0tLSBhL3NyYy92ZXJzaW9uLmgKKysrIGIvc3JjL3ZlcnNpb24uaApAQCAtMzYsNSArMzYsNSBAQAogI2RlZmluZSBWSU1fVkVSU0lPTl9OT0RPVAkidmltNzBiIgogI2RlZmluZSBWSU1fVkVSU0lPTl9TSE9SVAkiNy4wYiIKICNkZWZpbmUgVklNX1ZFUlNJT05fTUVESVVNCSI3LjBiIEJFVEEiCi0jZGVmaW5lIFZJTV9WRVJTSU9OX0xPTkcJIlZJTSAtIFZpIElNcHJvdmVkIDcuMGIgQkVUQSAoMjAwNiBNYXIgMjUpIgotI2RlZmluZSBWSU1fVkVSU0lPTl9MT05HX0RBVEUJIlZJTSAtIFZpIElNcHJvdmVkIDcuMGIgQkVUQSAoMjAwNiBNYXIgMjUsIGNvbXBpbGVkICIKKyNkZWZpbmUgVklNX1ZFUlNJT05fTE9ORwkiVklNIC0gVmkgSU1wcm92ZWQgNy4wYiBCRVRBICgyMDA2IE1hciAyNikiCisjZGVmaW5lIFZJTV9WRVJTSU9OX0xPTkdfREFURQkiVklNIC0gVmkgSU1wcm92ZWQgNy4wYiBCRVRBICgyMDA2IE1hciAyNiwgY29tcGlsZWQgIgpkaWZmIC0tZ2l0IGEvc3JjL3h4ZC94eGQuYyBiL3NyYy94eGQveHhkLmMKaW5kZXggMmIzZWU5Yy4uZjU3ZDc4NiAxMDA2NDQKLS0tIGEvc3JjL3h4ZC94eGQuYworKysgYi9zcmMveHhkL3h4ZC5jCkBAIC0yNzUsNiArMjc1LDkgQEAKICAgICAgIGlmIChjID09ICdccicpCS8qIERvemUgc3R5bGUgaW5wdXQgZmlsZT8gKi8KIAljb250aW51ZTsKIAorICAgICAgaWYgKGMgPT0gJyAnIHx8IGMgPT0gJ1xuJyB8fCBjID09ICdcdCcpICAvKiBhbGxvdyBtdWx0aXBsZSBzcGFjZXMgKi8KKyAgICAgICAgY29udGludWU7CisKICAgICAgIG4zID0gbjI7CiAgICAgICBuMiA9IG4xOwogCkBAIC0zMzQsNyArMzM3LDcgQEAKIAkgIG4xID0gLTE7CiAJICBpZiAoKCsrcCA+PSBjb2xzKSAmJiAhaGV4dHlwZSkKIAkgICAgewotCSAgICAgIC8qIHNraXAgcmVzdCBvZiBsaW5lIGFzIGdhcmJhZ2EgKi8KKwkgICAgICAvKiBza2lwIHJlc3Qgb2YgbGluZSBhcyBnYXJiYWdlICovCiAJICAgICAgd2FudF9vZmYgPSAwOwogCSAgICAgIHdoaWxlICgoYyA9IGdldGMoZnBpKSkgIT0gJ1xuJyAmJiBjICE9IEVPRikKIAkJOwo=