ZGlmZiAtLWdpdCBhL0FOTk9VTkNFIGIvQU5OT1VOQ0UKaW5kZXggNWExMGY4Yi4uZTE5ZWY3MiAxMDA2NDQKLS0tIGEvQU5OT1VOQ0UKKysrIGIvQU5OT1VOQ0UKQEAgLTEsMTUgKzEsMTQgQEAKLVRoaXMgaXMgcmVsZWFzZSA5NTEwMDMgb2YgV2luZSB0aGUgTVMgV2luZG93cyBlbXVsYXRvci4gIFRoaXMgaXMgc3RpbGwgYQorVGhpcyBpcyByZWxlYXNlIDk1MTEwNSBvZiBXaW5lIHRoZSBNUyBXaW5kb3dzIGVtdWxhdG9yLiAgVGhpcyBpcyBzdGlsbCBhCiBkZXZlbG9wZXIncyBvbmx5IHJlbGVhc2UuICBUaGVyZSBhcmUgbWFueSBidWdzIGFuZCBtYW55IHVuaW1wbGVtZW50ZWQgQVBJCiBmZWF0dXJlcy4gIE1vc3QgYXBwbGljYXRpb25zIHN0aWxsIGRvIG5vdCB3b3JrLgogCiBQYXRjaGVzIHNob3VsZCBiZSBzdWJtaXR0ZWQgdG8gIndpbmUtbmV3QGFtc2NvbnMuY29tIi4gIFBsZWFzZSBkb24ndCBmb3JnZXQKIHRvIGluY2x1ZGUgYSBDaGFuZ2VMb2cgZW50cnkuICBJJ2xsIG1ha2UgYSBuZXcgcmVsZWFzZSBldmVyeSBvdGhlciB3ZWVrLgogCi1XSEFUJ1MgTkVXIHdpdGggV2luZS05NTEwMDM6IChzZWUgQ2hhbmdlTG9nIGZvciBkZXRhaWxzKQotCS0gTmV3IGN1cnNvciBoYW5kbGluZy4KLQktIEZyZW5jaCwgRGFuaXNoIGFuZCBGaW5uaXNoIGxhbmd1YWdlIHN1cHBvcnQuCi0JLSBMb3RzIG9mIFdpbmVsaWIgaW1wcm92ZW1lbnRzLgotCS0gUHJlbGltaW5hcnkgVnhEIHN1cHBvcnQuCitXSEFUJ1MgTkVXIHdpdGggV2luZS05NTExMDU6IChzZWUgQ2hhbmdlTG9nIGZvciBkZXRhaWxzKQorCS0gQSBsb3Qgb2YgZml4ZXMgZm9yIFdpbmVsaWIuCisJLSBCdWlsdC1pbiBkZWJ1Z2dlciBpbXByb3ZlbWVudHMuCisJLSBHZXQvU2V0TWV0YWZpbGVCaXRzIGltcGxlbWVudGVkLgogCS0gTG90cyBvZiBidWcgZml4ZXMuCiAKIFNlZSB0aGUgUkVBRE1FIGZpbGUgaW4gdGhlIGRpc3RyaWJ1dGlvbiBmb3IgaW5zdGFsbGF0aW9uIGluc3RydWN0aW9ucy4KQEAgLTE4LDExICsxNywxMSBAQAogdGhlIHJlbGVhc2UgaXMgYXZhaWxhYmxlIGF0IHRoZSBmdHAgc2l0ZXMuICBUaGUgc291cmNlcyB3aWxsIGJlIGF2YWlsYWJsZQogZnJvbSB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczoKIAotICAgIHN1bnNpdGUudW5jLmVkdTovcHViL0xpbnV4L0FMUEhBL3dpbmUvV2luZS05NTEwMDMudGFyLmd6Ci0gICAgdHN4LTExLm1pdC5lZHU6L3B1Yi9saW51eC9BTFBIQS9XaW5lL2RldmVsb3BtZW50L1dpbmUtOTUxMDAzLnRhci5negotICAgIGZ0cC5pbmZvbWFnaWMuY29tOi9wdWIvbWlycm9ycy9saW51eC93aW5lL2RldmVsb3BtZW50L1dpbmUtOTUxMDAzLnRhci5negotICAgIGZ0cC5mdW5ldC5maTovcHViL09TL0xpbnV4L0FMUEhBL1dpbmUvV2luZS05NTEwMDMudGFyLmd6Ci0gICAgYXJpcy5jb206L3B1Yi9saW51eC9BTFBIQS9XaW5lL2RldmVsb3BtZW50L1dpbmUtOTUxMDAzLnRhci5negorICAgIHN1bnNpdGUudW5jLmVkdTovcHViL0xpbnV4L0FMUEhBL3dpbmUvV2luZS05NTExMDUudGFyLmd6CisgICAgdHN4LTExLm1pdC5lZHU6L3B1Yi9saW51eC9BTFBIQS9XaW5lL2RldmVsb3BtZW50L1dpbmUtOTUxMTA1LnRhci5negorICAgIGZ0cC5pbmZvbWFnaWMuY29tOi9wdWIvbWlycm9ycy9saW51eC93aW5lL2RldmVsb3BtZW50L1dpbmUtOTUxMTA1LnRhci5negorICAgIGZ0cC5mdW5ldC5maTovcHViL09TL0xpbnV4L0FMUEhBL1dpbmUvV2luZS05NTExMDUudGFyLmd6CisgICAgYXJpcy5jb206L3B1Yi9saW51eC9BTFBIQS9XaW5lL2RldmVsb3BtZW50L1dpbmUtOTUxMTA1LnRhci5negogCiBJdCBzaG91bGQgYWxzbyBiZSBhdmFpbGFibGUgZnJvbSBhbnkgc2l0ZSB0aGF0IG1pcnJvcnMgdHN4LTExIG9yIHN1bnNpdGUuCiAKZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCAzZGRkYThlLi45ODhkOWE2IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDQgKzEsMTgwIEBACiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitGcmkgTm92ICAzIDIwOjA4OjE3IDE5OTUgIEFsZXhhbmRyZSBKdWxsaWFyZCAgPGp1bGxpYXJkQHN1bnNpdGUudW5jLmVkdT4KKworCSogW2NvbmZpZ3VyZS5pbl0KKwlBdHRlbXB0IHRvIGNoZWNrIGZvciAtbGkzODYgb24gTmV0QlNELiBQbGVhc2UgdGVzdCB0aGlzLgorCitNb24gT2N0IDMwIDEyOjQwOjMyIEVTVCAxOTk1ICBKaW0gUGV0ZXJzb24gPGpzcGV0ZXJAYmlyY2guZWUudnQuZWR1PgorCisJKiBbKi8qXQorCUVsaW1pbmF0ZWQgdmFyaW91cyB3YXJuaW5ncyB3aXRoIGVpdGhlciBleHBsaWNpdCBjYXN0cyBvciBtb3JlCisJYWNjdXJhdGUgdmFyaWFibGUvcGFyYW1ldGVyIGRlY2xhcmF0aW9ucyAoZS5nLiBJTlQgaW5zdGVhZCBvZiBzaG9ydAorCW9yIFdPUkQpLgorCUNoYW5nZWQgbWFjcm9zICdtaW4nIGFuZCAnbWF4JyB0byAnTUlOJyBhbmQgJ01BWCcsIHNpbmNlIHRoZXkncmUKKwltYWNyb3MuCisKKwkqIFtjb250cm9scy9lZGl0LmNdIFt3aW5kb3dzL2RlZmRsZy5jXQorCUFkZGVkICcjaWZkZWYgU1VQRVJGTFVPVVNfRlVOQ1RJT05TJyB3cmFwcGVycyBhcm91bmQgZnVuY3Rpb24KKwlkZWZpbml0aW9uIG9mIEVESVRfS2V5VlNjcm9sbERvYywgRURJVF9UZXh0TGluZU51bWJlciwgYW5kCisJREVGRExHX0ZpbmREZWZCdXR0b24gdG8gYXZvaWQgd2FybmluZ3MuCisKKwkqIFtjb250cm9scy9idXR0b24uY10gW2NvbnRyb2xzL3Njcm9sbC5jXSBbd2luZG93cy9kZWZ3bmQuY10KKwkgIFt3aW5kb3dzL21lc3NhZ2UuY10gW3dpbmRvd3Mvbm9uY2xpZW50LmNdCisJQ29udmVydGVkIE1BS0VQT0lOVCBtYWNybyBjYWxsIHRvIG1hbnVhbCBjb252ZXJzaW9uLgorCisJKiBbaW5jbHVkZS93aW5kb3dzLmhdCisJRm9yIFdJTkVMSUIzMiwgc3RydWN0dXJlcyBQT0lOVCwgU0laRSwgYW5kIFJFQ1QgaGF2ZSBMT05HIG1lbWJlcnMKKwlpbnN0ZWFkIG9mIElOVC4gIFRoaXMgYWxzbyBpbnZhbGlkYXRlcyB0aGUgbWFjcm8gTUFLRVBPSU5UKCksIHdoaWNoCisJaXMgbm90IHN1cHBvcnRlZCBpbiBXaW4zMi4gIEFsc28gZGVmaW5lZCB0aGUgUE9JTlRTIHN0cnVjdHVyZSAoU0hPUlQKKwltZW1iZXJzKSBhbmQgdGhlIE1BS0VQT0lOVFMgbWFjcm8uCisKKwkqIFttaXNjL2NvbW1kbGcuY10KKwlDaGFuZ2VkIGEgbG90IG9mICdzdHJjcHknIGNhbGxzIHRvICdzdHJuY3B5JyBjYWxscy4gIEknbSBkZXNwZXJhdGUgdG8KKwlmaW5kIHRoaXMgbWVtb3J5IGJ1ZywgYW5kIHRoaXMgc2hvdWxkIGJlIGRvbmUgYW55d2F5LgorCisJKiBbY29udHJvbHMvZWRpdC5jXQorCVdlbGwsIHRoZSBhbHRlcmF0aW9uIG1lbnRpb25lZCBhYm92ZSBkaWRuJ3QgZG8gaXQsIGJ1dCAjaWZkZWYnaW5nIG91dAorCWEgZmV3IGxpbmVzIGluIEVESVRfQ2xlYXJUZXh0IGRpZC4gIFRoaXMgbGVhZHMgdG8gYnVncywgYnV0IGZvciBub3csCisJaXQncyBiZXR0ZXIgdGhhbiBiaXp6YXJlIG1lbW9yeSB0cm91Ymxlcy4KKworCSogW3Rvb2xraXQvbWlzY3N0dWJzLmNdCisJUmVtb3ZlZCB3YXJuaW5nIG1lc3NhZ2VzIGluIEdMT0JBTF9DcmVhdGVCbG9jaygpLCBHTE9CQUxfRnJlZUJsb2NrKCksCisJYW5kIFJFTEFZMzJfR2V0RW50cnlQb2ludCgpLiAgVGhlc2UgYXJlIHRoZSBtb3N0IHBvcHVsYXIgd2FybmluZ3MsIGFuZAorCXRoZWlyIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gc2VlbXMgZmluZS4KKworU2F0IE9jdCAyOCAwOTozOToxOCAxOTk1ICBKb2NoZW4gS2FycmVyIDxjaXAzMDdAd3BheDAxLlBoeXNpay5VbmktV3VlcnpidXJnLkRFPgorCisJKiBbb2JqZWN0cy9jdXJzb3JpY29uLmNdCisJRml4IGZvciAiYnJva2VuIiBYIHNlcnZlcnMgdGhhdCBpbnZlcnQgbWFza2VkIGN1cnNvciBjb2xvcnMuCisKK0ZyaSBPY3QgMjcgMTk6Mjc6MjEgMTk5NSAgQWxleCBLb3JvYmthICA8YWxleEBwaG02LnBoYXJtLnN1bnlzYi5lZHU+CisKKwkqIFt3aW5kb3dzL2RpYWxvZy5jXSBbd2luZG93cy9ub25jbGllbnQuY10KKwlSZW1vdmUgdW5uZWNlc3NhcnkgaXRlbXMgZnJvbSB0aGUgc3lzdGVtIG1lbnUuCisKK1RodSBPY3QgMjYgMDU6MDM6MDMgTUVUIDE5OTUgIFBoaWxpcHBlIERlIE11eXRlciA8cGhkbUBpbmZvLnVjbC5hYy5iZT4KKworCSogW29iamVjdHMvY29sb3IuY10gW29iamVjdHMvcGFsZXR0ZS5jXQorCU1ha2UgR2V0TmVhcmVzdENvbG9yIHJldHVybiBhIFJHQiB2YWx1ZSBpbnN0ZWFkIG9mIGEgcGl4ZWwgdmFsdWUuCisKK1dlZCBPY3QgMjUgMjM6MzM6MzkgMTk5NSAgICBNYXJ0aW4gdm9uIExvZXdpcyA8bG9ld2lzQGluZm9ybWF0aWsuaHUtYmVybGluLmRlPgorCisJKiBbY29udHJvbHMvZGVza3RvcC5jXVtjb250cm9scy9tZW51LmNdW2luY2x1ZGUvbWVudS5oXQorCUNoYW5nZWQgV09SRCBwYXJhbWV0ZXJzIHRvIFVJTlQgcGFyYW1ldGVycy4KKworCSogW2luY2x1ZGUvd2ludHlwZXMuaF0KKwlNYWRlIFVJTlQgMzJiaXQgZm9yIFdJTkVMSUIuCisKKwkqIFtsb2FkZXIvbWFpbi5jXQorCURpc2FibGVkIFJFTEFZMzJfSW5pdCBhbmQgTU9EVUxFX0luaXQgZm9yIFdJTkVMSUIuCisKKwkqIFttaXNjL21haW4uY10KKwlBc3N1bWUgQ1BVMzg2IGZvciBXSU5FTElCLgorCisJKiBbcmMvd2luZXJjXQorCWFkZF9wb3B1cDogc2V0IE1GX1BPUFVQIGZsYWcgb24gbWVudSBpdGVtLgorCisJKiBbdG9vbGtpdC9NYWtlZmlsZS5pbl1bdG9vbGtpdC9oZWxsbzMuY11bdG9vbGtpdC9oZWxsbzNyZXMuY10KKwlBZGQgcmVzb3VyY2UgZGVtbyBoZWxsbzMgZm9yIFdJTkVMSUIuCisJTmV3IGZpbGUgUkVBRE1FLnJlc291cmNlcy4KKworCSogW3Rvb2xraXQvbWlzY3N0dWJzLmNdCisJQWRkIGEgY2FzZSBmb3IgMTcuCisKK1R1ZSBPY3QgMTcgMTU6MTM6MTAgSVNUIDE5OTUgIEl0YWkgTmFoc2hvbiA8bmFoc2hvbkB2bmV0LmlibS5jb20+CisKKwkqIFtsb2FkZXIvbW9kdWxlLmNdCisJRG8gbm90IGFwcGVuZCAuZXhlIGlmIHRoZSBmaWxlIG5hbWUgYWxyZWFkeSBoYXMgYW4gZXh0ZW5zaW9uLgorCisJKiBbbWlzYy9wcm9maWxlLmNdCisJQXZvaWQgY3JlYXRpbmcgYSBmaWxlIHdpdGggYSBqdW5rIG5hbWUgaWYgYSAuaW5pIGZpbGUgZG9lcyBub3QKKwlleGlzdC4KKworCSogW2lmMTYzMi9nZGkuc3BlY10gW2lmMTYzMi91c2VyLnNwZWNdIFtpZjE2MzIvZHVtbXkuY10KKwlBZGRlZCBhIGxvdCBvZiBkdW1teSBzdHVicyBmb3IgV2luZG93cyBIZWJyZXcgdmVyc2lvbi4KKworVHVlIE9jdCAxNyAwMTowMzoyNCAxOTk1IFdpbGxpYW0gTWFncm8gPHdtYWdyb0B0Yy5jb3JuZWxsLmVkdT4KKworCSogW2NvbnRyb2xzL2J1dHRvbi5jXQorCUZpeCBmb3IgYnV0dG9ucyB3aXRoIG5vIGxhYmVsLgorCisJKiBbY29udHJvbHMvY29tYm8uY11bY29udHJvbHMvbGlzdGJveC5jXQorCUZpeGVzIGZvciBzY3JvbGxiYXIgcG9zaXRpb25pbmcuICBOb3cgZGlzYXBwZWFycyBjb3JyZWN0bHkKKwlmb3Igc2hvcnQgbGlzdHMuCisKKwkqIFtjb250cm9scy9lZGl0LmNdCisJSGFuZGxlIG1lbW9yeSBhbGxvY2F0aW9uIGRpZmZlcmVudGx5IHdoZW4gYnVpbGRpbmcgYXMgbGlicmFyeS4KKworCSogW2NvbnRyb2xzL3N0YXRpY10KKwlEb24ndCBkZXN0cm95IG9sZCBpY29uIGJlZm9yZSBkcmF3aW5nIG5ldyBpY29uLiAoRml4ZXMgbGFuZHNjYXBlLworCXBvcnRyYWl0IHRvZ2dsZSBpY29uIGluIHByaW50IGRpYWxvZy4pCisKKwkqIFtpZjE2MzIvZ2RpLnNwZWNdCisJTmV3IGZ1bmN0aW9ucyBTZXRNZXRhRmlsZUJpdHMgYW5kIEdldE1ldGFGaWxlQml0cworCisJKiBbaW5jbHVkZS9zeXNtZXRyaWNzLmhdIFt3aW5kb3dzL3N5c21ldHJpY3MuY10KKwlBZGQgc3VwcG9ydCBmb3IgR2V0U3lzdGVtTWV0cmljcyhTTV9DTUVUUklDUykgPT0gU01fQ01FVFJJQ1MKKworCSogW2luY2x1ZGUvd2luZG93cy5oXQorCU1FVEFfRVhUVEVYVE9VVCwgbm90IE1FVEFfU0VUVEVYVE9VVAorCWRlZmluZSBHZXRDdXJyZW50VGltZSBhcyBHZXRUaWNrQ291bnQgKGZvciB3aW5lIGxpYnJhcnkpCisKKwkqIFtsb2FkZXIvbWFpbi5jXQorCURvbid0IGluaXRpYWxpemUgYnVpbHQtaW4gbW9kdWxlcyBpbiB3aW5lIGxpYnJhcnkKKworCSogW21lbW9yeS9sb2NhbC5jXQorCUxvY2FsUmVBbGxvYyB3YXMgZGVmaW5lZCBpbmNvcnJlY3RseS4gU3dhcCBmbGFncyBhbmQgc2l6ZSBhcmd1bWVudHMuCisKKwkqIFttaXNjL21haW4uY10KKwlBbHdheXMgcmVwb3J0IENQVVRZUEU9NCB0byB3aW5lIGxpYnJhcnkuCisKKwkqIFtvYmplY3RzL2RpYi5jXQorCVJMRTggaW1hZ2VzIHdlcmUgbWlzc2luZyB0b3AgbGluZSB3aGVuIGRlY29tcHJlc3NlZC4KKworCSogW29iamVjdHMvbWV0YWZpbGUuY10KKwlTZXRNZXRhRmlsZUJpdHMgYW5kIEdldE1ldGFGaWxlQml0cyBpbXBsZW1lbnRlZC4gIFdvcmtzIHdoZW4gY2FsbGVkCisJZnJvbSB3aW5oZWxwLiAgTW9yZSB0ZXN0aW5nIG5lZWRlZC4gIFZhcmlvdXMgbWVtb3J5IGxlYWtzIHBsdWdnZWQuCisJVmFyaW91cyBvdGhlciBidWcgZml4ZXMuICBOZXcgbWV0YWZpbGUgb3BlcmF0aW9ucyBhZGRlZCBpbgorCVBsYXlNZXRhRmlsZVJlY29yZDogQ3JlYXRlUGFsZXR0ZSwgU2V0VGV4dEFsaWduLCBTZWxlY3RQYWxldHRlLAorCVNldE1hcHBlckZsYWdzLCBSZWFsaXplUGFsZXR0ZSwgRXh0VGV4dE91dCwgRXNjYXBlLiAgVGVzdGluZyBuZWVkZWQuCisKKwkqIFt0b29sa2l0L2hlYXAuY10KKwlMb2NhbFVuTG9jayBjaGFuZ2VkIHRvIExvY2FsVW5sb2NrCisKK1N1biBPY3QgMTUgMjE6NTU6MzMgMTk5NSAgQW5hbmQgS3VtcmlhIDxha3VtcmlhQG96ZW1haWwuY29tLmF1PgorCQorCSogW21pc2Mvd2luc29jay5jXSAKKwlSZXR1cm4gdGhlIGNvcnJlY3QgZXJyb3IgbnVtYmVyLCBmb3IgaG9zdCBsb29rdXAgb3BlcmF0aW9ucy4KKwlBbHNvLCBjb3JyZWN0IHRoZSBwcm9ibGVtIHdpdGggc2VuZF9tZXNzYWdlLgorCitGcmkgT2N0IDEzIDE5OjA0OjM1IDE5OTUgIE1vcnRlbiBXZWxpbmRlciAgPHRlcnJhQGRpa3UuZGs+CisKKwkqIFtNYWtlZmlsZS5pbl0KKwlVc2luZyBubSdzIGJ1aWx0LWluIHNvcnRpbmcuCisKKwkqIFsqLyouY10KKwlVc2UgeG1hbGxvYyBmb3IgbWFsbG9jIGFuZCB4cmVhbGxvYyBmb3IgcmVhbGxvYyBpbiBhbGwgdW5nYXJkZWQKKwljYXNlcy4KKworCSogW2RlYnVnZ2VyL2RiZy55XQorCUhhbmRsZSBDLWxpa2UgZXhwcmVzc2lvbnMuICBDbGVhbi11cC4KKworCSogW2RlYnVnZ2VyL2RlYnVnLmxdCisJTG90cyBvZiBuZXcgdG9rZW5zIGZvciBleHByZXNzaW9ucy4KKworCSogW2RlYnVnZ2VyL2luZm8uY10KKwlJbXBsZW1lbnQgImxpc3QiIGNvbW1hbmQgZm9yIGRpc2Fzc2VtYmxpbmcuCisKKwkqIFttaXNjL29sZTJubHMuY10KKwlJbXBsZW1lbnQgbW9yZSBEYW5pc2ggc3R1ZmYuCisKK0ZyaSBPY3QgIDYgMTA6Mzk6MzkgMTk5NSBSYW0nb24gR2FyYydpYSA8cmFtb25AaWUzLmNsdWJzLmV0c2l0LnVwbS5lcz4KKworCSogW2xvYWRlci9tb2R1bGUuY10KKwlVcGRhdGVkIHNlbGYtbG9hZGluZyBtb2R1bGVzIHRvIHN1cHBvcnQgZm9yIG5ldyAzMiBiaXQgCisJc3RhY2sgZnJhbWVzLgorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBTdW4gT2N0ICAxIDE1OjQ4OjM0IDE5OTUgIEFsZXhhbmRyZSBKdWxsaWFyZCAgPGp1bGxpYXJkQHN1bnNpdGUudW5jPgogCiAJKiBbY29udHJvbHMvbWVudS5jXQpkaWZmIC0tZ2l0IGEvTWFrZS5ydWxlcy5pbiBiL01ha2UucnVsZXMuaW4KaW5kZXggNzg5NGQyYi4uNGRkOTcxZCAxMDA2NDQKLS0tIGEvTWFrZS5ydWxlcy5pbgorKysgYi9NYWtlLnJ1bGVzLmluCkBAIC0zMiw3ICszMiw3IEBACiAJbXYgdG1wX21ha2UgTWFrZWZpbGUKIAogY2xlYW46OgotCSQoUk0pICoubyBcIypcIyAqfiAqLmJhayB0bXBfbWFrZQorCSQoUk0pICoubyBcIypcIyAqfiAqLmJhayAqLmZsYyB0bXBfbWFrZQogCiBkaXN0Y2xlYW46OiBjbGVhbgogCSQoUk0pIE1ha2VmaWxlCmRpZmYgLS1naXQgYS9NYWtlZmlsZS5pbiBiL01ha2VmaWxlLmluCmluZGV4IDEzMGYxMmYuLjE5ZjhhMTIgMTAwNjQ0Ci0tLSBhL01ha2VmaWxlLmluCisrKyBiL01ha2VmaWxlLmluCkBAIC02LDYgKzYsNyBAQAogIyBsYW5nY2xlYW46CQlyZW1vdmUgYWxsIGZpbGVzIHdoaWNoIGhhdmUgdG8gYmUgcmVtYWRlIGlmCiAjCQkJYSBkaWZmZXJlbnQgTEFOR3VhZ2UgaXMgc2VsZWN0ZWQKICMgZGVwZW5kOgkJY3JlYXRlIHRoZSBkZXBlbmRlbmNpZXMKKyMgZXRhZ3M6CQlDcmVhdGUgYSBUQUdTIGZpbGUgZm9yIEVtYWNzLgogIwogIyBBdXRob3I6IE1pY2hhZWwgUGF0cmEgICA8bWlja3lAbWFyaWUucGh5c2lrLnR1LWJlcmxpbi5kZT4KICMgICAgICAgICAgICAgICAgICAgICAgICAgPHBhdHJhQGl0cDEucGh5c2lrLnR1LWJlcmxpbi5kZT4KQEAgLTIwLDcgKzIxLDcgQEAKIERJVklOQ0wgICA9IC1JJChUT1BTUkMpL2luY2x1ZGUKIFhQTV9MSUIJICA9IC1sWHBtCiBYTElCCSAgPSBAWF9QUkVfTElCU0AgLWxYZXh0IC1sWDExIEBYX0VYVFJBX0xJQlNACi1MRExJQlMJICA9IC1sbQorTERMSUJTCSAgPSBATERMSUJTQAogQVIgICAgICAgID0gYXIgcmMKIFJBTkxJQiAgICA9IEBSQU5MSUJACiBSTSAgICAgICAgPSBybSAtZgpAQCAtNTksOSArNjAsOSBAQAogCiBhbGw6ICQoTUFJTl9UQVJHRVQpCiAKLXdpbmU6ICQoQ09NTU9OU1VCRElSUykgJChFTVVTVUJESVJTKSBkdW1teQord2luZSB3aW5lLnN5bTogJChDT01NT05TVUJESVJTKSAkKEVNVVNVQkRJUlMpIGR1bW15CiAJJChDQykgLW8gd2luZSAkKENPTU1PTk9CSlMpICQoRU1VT0JKUykgJChMRE9QVElPTlMpICQoWF9MSUJTKSAkKFhQTV9MSUIpICQoWExJQikgJChMRExJQlMpCi0Jbm0gd2luZSB8IGdyZXAgLXYgX2NvbXBpbGVkIHwgc29ydCA+d2luZS5zeW0KKwlubSAtbiB3aW5lIHwgZ3JlcCAtdiBfY29tcGlsZWQgPndpbmUuc3ltCiAKIHdpbmVsaWIuYTogJChDT01NT05TVUJESVJTKSAkKExJQlNVQkRJUlMpIGR1bW15CiAJJChSTSkgJEAKQEAgLTc5LDcgKzgwLDcgQEAKIAogY2xlYW46CiAJZm9yIGkgaW4gJChBTExTVUJESVJTKTsgZG8gKGNkICQkaTsgJChNQUtFKSBjbGVhbik7IGRvbmUKLQkkKFJNKSAqLm8gXCMqXCMgKn4gKi5iYWsgd2luZSB3aW5lLnN5bSB3aW5lbGliLmEgVEFHUworCSQoUk0pICoubyBcIypcIyAqfiAqLmJhayAqLmZsYyB3aW5lIHdpbmUuc3ltIHdpbmVsaWIuYSBUQUdTCiAKIGRpc3RjbGVhbjoKIAlmb3IgaSBpbiAkKEFMTFNVQkRJUlMpOyBkbyAoY2QgJCRpOyAkKE1BS0UpIGRpc3RjbGVhbik7IGRvbmUKZGlmZiAtLWdpdCBhL2NvbmZpZ3VyZSBiL2NvbmZpZ3VyZQppbmRleCA3Mzk0NGJjLi5jMGRmODRkIDEwMDc1NQotLS0gYS9jb25maWd1cmUKKysrIGIvY29uZmlndXJlCkBAIC00MTMsNiArNDEzLDcgQEAKICMgV2Ugd2FudCB0aGVzZSBiZWZvcmUgdGhlIGNoZWNrcywgc28gdGhlIGNoZWNrcyBjYW4gbW9kaWZ5IHRoZWlyIHZhbHVlcy4KIHRlc3QgLXogIiRDRkxBR1MiICYmIENGTEFHUz0iLWcgLU8yIC1XYWxsIiAKIHRlc3QgLXogIiRMREZMQUdTIiAmJiBMREZMQUdTPS1nIAordGVzdCAteiAiJExETElCUyIgJiYgTERMSUJTPS1sbSAKIAogCiAjIENoZWNrIHdoZXRoZXIgLS13aXRoLWxpYnJhcnkgb3IgLS13aXRob3V0LWxpYnJhcnkgd2FzIGdpdmVuLgpAQCAtNTczLDcgKzU3NCw3IEBACiAgICMgT24gdGhlIE5lWFQsIGNjIC1FIHJ1bnMgdGhlIGNvZGUgdGhyb3VnaCB0aGUgY29tcGlsZXIncyBwYXJzZXIsCiAgICMgbm90IGp1c3QgdGhyb3VnaCBjcHAuCiAgIGNhdCA+IGNvbmZ0ZXN0LiRhY19leHQgPDxFT0YKLSNsaW5lIDU3NyAiY29uZmlndXJlIgorI2xpbmUgNTc4ICJjb25maWd1cmUiCiAjaW5jbHVkZSAiY29uZmRlZnMuaCIKICNpbmNsdWRlIDxhc3NlcnQuaD4KIFN5bnRheCBFcnJvcgpAQCAtNTg3LDcgKzU4OCw3IEBACiAgIHJtIC1yZiBjb25mdGVzdCoKICAgQ1BQPSIke0NDLWNjfSAtRSAtdHJhZGl0aW9uYWwtY3BwIgogICBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSA1OTEgImNvbmZpZ3VyZSIKKyNsaW5lIDU5MiAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAjaW5jbHVkZSA8YXNzZXJ0Lmg+CiBTeW50YXggRXJyb3IKQEAgLTY5Myw3ICs2OTQsNyBAQAogdGVzdCAteiAiJHhfZGlyZWN0X3Rlc3RfZnVuY3Rpb24iICYmIHhfZGlyZWN0X3Rlc3RfZnVuY3Rpb249WHRNYWxsb2MKIHRlc3QgLXogIiR4X2RpcmVjdF90ZXN0X2luY2x1ZGUiICYmIHhfZGlyZWN0X3Rlc3RfaW5jbHVkZT1YMTEvSW50cmluc2ljLmgKIGNhdCA+IGNvbmZ0ZXN0LiRhY19leHQgPDxFT0YKLSNsaW5lIDY5NyAiY29uZmlndXJlIgorI2xpbmUgNjk4ICJjb25maWd1cmUiCiAjaW5jbHVkZSAiY29uZmRlZnMuaCIKICNpbmNsdWRlIDwkeF9kaXJlY3RfdGVzdF9pbmNsdWRlPgogRU9GCkBAIC03NTYsNyArNzU3LDcgQEAKIGFjX3NhdmVfTElCUz0iJExJQlMiCiBMSUJTPSItbCR4X2RpcmVjdF90ZXN0X2xpYnJhcnkgJExJQlMiCiBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSA3NjAgImNvbmZpZ3VyZSIKKyNsaW5lIDc2MSAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAKIGludCBtYWluKCkgeyByZXR1cm4gMDsgfQpAQCAtODc0LDcgKzg3NSw3IEBACiAgIGFjX3NhdmVfTElCUz0iJExJQlMiCiBMSUJTPSItbElDRSAgJExJQlMiCiBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSA4NzggImNvbmZpZ3VyZSIKKyNsaW5lIDg3OSAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAKIGludCBtYWluKCkgeyByZXR1cm4gMDsgfQpAQCAtOTE3LDcgKzkxOCw3IEBACiAgIGFjX3NhdmVfTElCUz0iJExJQlMiCiBMSUJTPSItbGRuZXQgICRMSUJTIgogY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgOTIxICJjb25maWd1cmUiCisjbGluZSA5MjIgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogCiBpbnQgbWFpbigpIHsgcmV0dXJuIDA7IH0KQEAgLTk1MSw3ICs5NTIsNyBAQAogICBhY19zYXZlX0xJQlM9IiRMSUJTIgogTElCUz0iLWxkbmV0X3N0dWIgICRMSUJTIgogY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgOTU1ICJjb25maWd1cmUiCisjbGluZSA5NTYgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogCiBpbnQgbWFpbigpIHsgcmV0dXJuIDA7IH0KQEAgLTk5MCw3ICs5OTEsNyBAQAogICBhY19zYXZlX0xJQlM9IiRMSUJTIgogTElCUz0iLWxuc2wgICRMSUJTIgogY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgOTk0ICJjb25maWd1cmUiCisjbGluZSA5OTUgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogCiBpbnQgbWFpbigpIHsgcmV0dXJuIDA7IH0KQEAgLTEwMjgsNyArMTAyOSw3IEBACiAgIGFjX3NhdmVfTElCUz0iJExJQlMiCiBMSUJTPSItbHNvY2tldCAgJExJQlMiCiBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSAxMDMyICJjb25maWd1cmUiCisjbGluZSAxMDMzICJjb25maWd1cmUiCiAjaW5jbHVkZSAiY29uZmRlZnMuaCIKIAogaW50IG1haW4oKSB7IHJldHVybiAwOyB9CkBAIC0xMTMyLDcgKzExMzMsNyBAQAogICBhY19zYXZlX0xJQlM9IiRMSUJTIgogTElCUz0iLWwkYWNfbGliICAkTElCUyIKIGNhdCA+IGNvbmZ0ZXN0LiRhY19leHQgPDxFT0YKLSNsaW5lIDExMzYgImNvbmZpZ3VyZSIKKyNsaW5lIDExMzcgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogCiBpbnQgbWFpbigpIHsgcmV0dXJuIDA7IH0KQEAgLTExODgsNiArMTE4OSw0MCBAQAogICBlY2hvICIkYWNfdCIibm8iIDE+JjYKIGZpCiAKK2VjaG8gJGFjX24gImNoZWNraW5nIGZvciAtbGkzODYiIi4uLiAkYWNfYyIgMT4mNgoraWYgZXZhbCAidGVzdCBcImBlY2hvICckJyd7J2FjX2N2X2xpYl9pMzg2JytzZXR9J2BcIiA9IHNldCI7IHRoZW4KKyAgZWNobyAkYWNfbiAiKGNhY2hlZCkgJGFjX2MiIDE+JjYKK2Vsc2UKKyAgYWNfc2F2ZV9MSUJTPSIkTElCUyIKK0xJQlM9Ii1saTM4NiAgJExJQlMiCitjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCisjbGluZSAxMjAwICJjb25maWd1cmUiCisjaW5jbHVkZSAiY29uZmRlZnMuaCIKKworaW50IG1haW4oKSB7IHJldHVybiAwOyB9CitpbnQgdCgpIHsKK2kzODZfc2V0X2xkdCgpCis7IHJldHVybiAwOyB9CitFT0YKK2lmIGV2YWwgJGFjX2xpbms7IHRoZW4KKyAgcm0gLXJmIGNvbmZ0ZXN0KgorICBldmFsICJhY19jdl9saWJfaTM4Nj15ZXMiCitlbHNlCisgIHJtIC1yZiBjb25mdGVzdCoKKyAgZXZhbCAiYWNfY3ZfbGliX2kzODY9bm8iCitmaQorcm0gLWYgY29uZnRlc3QqCitMSUJTPSIkYWNfc2F2ZV9MSUJTIgorCitmaQoraWYgZXZhbCAidGVzdCBcImBlY2hvICckYWNfY3ZfbGliXydpMzg2YFwiID0geWVzIjsgdGhlbgorICBlY2hvICIkYWNfdCIieWVzIiAxPiY2CisgIExETElCUz0iJExETElCUyAtbGkzODYiCitlbHNlCisgIGVjaG8gIiRhY190IiJubyIgMT4mNgorZmkKKworCiAKIGZvciBhY19mdW5jIGluIHRjZ2V0YXR0cgogZG8KQEAgLTExOTYsNyArMTIzMSw3IEBACiAgIGVjaG8gJGFjX24gIihjYWNoZWQpICRhY19jIiAxPiY2CiBlbHNlCiAgIGNhdCA+IGNvbmZ0ZXN0LiRhY19leHQgPDxFT0YKLSNsaW5lIDEyMDAgImNvbmZpZ3VyZSIKKyNsaW5lIDEyMzUgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogLyogU3lzdGVtIGhlYWRlciB0byBkZWZpbmUgX19zdHViIG1hY3JvcyBhbmQgaG9wZWZ1bGx5IGZldyBwcm90b3R5cGVzLAogICAgIHdoaWNoIGNhbiBjb25mbGljdCB3aXRoIGNoYXIgJGFjX2Z1bmMoKTsgYmVsb3cuICAqLwpAQCAtMTI0OCw3ICsxMjgzLDcgQEAKICAgZWNobyAkYWNfbiAiKGNhY2hlZCkgJGFjX2MiIDE+JjYKIGVsc2UKICAgY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgMTI1MiAiY29uZmlndXJlIgorI2xpbmUgMTI4NyAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAjaW5jbHVkZSA8JGFjX2hkcj4KIEVPRgpAQCAtMTI4MSw3ICsxMzE2LDcgQEAKICAgZWNobyAkYWNfbiAiKGNhY2hlZCkgJGFjX2MiIDE+JjYKIGVsc2UKICAgY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgMTI4NSAiY29uZmlndXJlIgorI2xpbmUgMTMyMCAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAjaW5jbHVkZSA8c3lzL3R5cGVzLmg+CiAjaW5jbHVkZSA8c3lzL3N0YXQuaD4KQEAgLTEzMzUsNyArMTM3MCw3IEBACiAgIGVjaG8gJGFjX24gIihjYWNoZWQpICRhY19jIiAxPiY2CiBlbHNlCiAgIGNhdCA+IGNvbmZ0ZXN0LiRhY19leHQgPDxFT0YKLSNsaW5lIDEzMzkgImNvbmZpZ3VyZSIKKyNsaW5lIDEzNzQgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogCiBpbnQgbWFpbigpIHsgcmV0dXJuIDA7IH0KQEAgLTE0MTIsNyArMTQ0Nyw3IEBACiAgIGFjX2N2X2NfY3Jvc3M9eWVzCiBlbHNlCiBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSAxNDE2ICJjb25maWd1cmUiCisjbGluZSAxNDUxICJjb25maWd1cmUiCiAjaW5jbHVkZSAiY29uZmRlZnMuaCIKIG1haW4oKXtyZXR1cm4oMCk7fQogRU9GCkBAIC0xNDMzLDcgKzE0NjgsNyBAQAogICBlY2hvICRhY19uICIoY2FjaGVkKSAkYWNfYyIgMT4mNgogZWxzZQogICBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSAxNDM3ICJjb25maWd1cmUiCisjbGluZSAxNDcyICJjb25maWd1cmUiCiAjaW5jbHVkZSAiY29uZmRlZnMuaCIKICNpbmNsdWRlIDxzdGRsaWIuaD4KICNpbmNsdWRlIDxzdGRhcmcuaD4KQEAgLTE0NTUsNyArMTQ5MCw3IEBACiBpZiB0ZXN0ICRhY19jdl9oZWFkZXJfc3RkYyA9IHllczsgdGhlbgogICAjIFN1bk9TIDQueCBzdHJpbmcuaCBkb2VzIG5vdCBkZWNsYXJlIG1lbSosIGNvbnRyYXJ5IHRvIEFOU0kuCiBjYXQgPiBjb25mdGVzdC4kYWNfZXh0IDw8RU9GCi0jbGluZSAxNDU5ICJjb25maWd1cmUiCisjbGluZSAxNDk0ICJjb25maWd1cmUiCiAjaW5jbHVkZSAiY29uZmRlZnMuaCIKICNpbmNsdWRlIDxzdHJpbmcuaD4KIEVPRgpAQCAtMTQ3Myw3ICsxNTA4LDcgQEAKIGlmIHRlc3QgJGFjX2N2X2hlYWRlcl9zdGRjID0geWVzOyB0aGVuCiAgICMgSVNDIDIuMC4yIHN0ZGxpYi5oIGRvZXMgbm90IGRlY2xhcmUgZnJlZSwgY29udHJhcnkgdG8gQU5TSS4KIGNhdCA+IGNvbmZ0ZXN0LiRhY19leHQgPDxFT0YKLSNsaW5lIDE0NzcgImNvbmZpZ3VyZSIKKyNsaW5lIDE1MTIgImNvbmZpZ3VyZSIKICNpbmNsdWRlICJjb25mZGVmcy5oIgogI2luY2x1ZGUgPHN0ZGxpYi5oPgogRU9GCkBAIC0xNDk0LDcgKzE1MjksNyBAQAogICBhY19jdl9oZWFkZXJfc3RkYz1ubwogZWxzZQogY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgMTQ5OCAiY29uZmlndXJlIgorI2xpbmUgMTUzMyAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAjaW5jbHVkZSA8Y3R5cGUuaD4KICNkZWZpbmUgSVNMT1dFUihjKSAoJ2EnIDw9IChjKSAmJiAoYykgPD0gJ3onKQpAQCAtMTUyOCw3ICsxNTYzLDcgQEAKICAgZWNobyAkYWNfbiAiKGNhY2hlZCkgJGFjX2MiIDE+JjYKIGVsc2UKICAgY2F0ID4gY29uZnRlc3QuJGFjX2V4dCA8PEVPRgotI2xpbmUgMTUzMiAiY29uZmlndXJlIgorI2xpbmUgMTU2NyAiY29uZmlndXJlIgogI2luY2x1ZGUgImNvbmZkZWZzLmgiCiAjaW5jbHVkZSA8c3lzL3R5cGVzLmg+CiAjaWYgU1REQ19IRUFERVJTCkBAIC0xNzA1LDYgKzE3NDAsNyBAQAogcyVAZXhlY19wcmVmaXhAJSRleGVjX3ByZWZpeCVnCiBzJUBwcmVmaXhAJSRwcmVmaXglZwogcyVAcHJvZ3JhbV90cmFuc2Zvcm1fbmFtZUAlJHByb2dyYW1fdHJhbnNmb3JtX25hbWUlZworcyVATERMSUJTQCUkTERMSUJTJWcKIHMlQE1BSU5fVEFSR0VUQCUkTUFJTl9UQVJHRVQlZwogcyVATEFOR0AlJExBTkclZwogcyVAU0VUX01BS0VAJSRTRVRfTUFLRSVnCmRpZmYgLS1naXQgYS9jb25maWd1cmUuaW4gYi9jb25maWd1cmUuaW4KaW5kZXggODQ2MGQxZC4uNGJiZjNmZSAxMDA2NDQKLS0tIGEvY29uZmlndXJlLmluCisrKyBiL2NvbmZpZ3VyZS5pbgpAQCAtNyw2ICs3LDcgQEAKICMgV2Ugd2FudCB0aGVzZSBiZWZvcmUgdGhlIGNoZWNrcywgc28gdGhlIGNoZWNrcyBjYW4gbW9kaWZ5IHRoZWlyIHZhbHVlcy4KIHRlc3QgLXogIiRDRkxBR1MiICYmIENGTEFHUz0iLWcgLU8yIC1XYWxsIiBBQ19TVUJTVChDRkxBR1MpCiB0ZXN0IC16ICIkTERGTEFHUyIgJiYgTERGTEFHUz0tZyBBQ19TVUJTVChMREZMQUdTKQordGVzdCAteiAiJExETElCUyIgJiYgTERMSUJTPS1sbSBBQ19TVUJTVChMRExJQlMpCiAKIGRubCAqKioqIENvbW1hbmQtbGluZSBhcmd1bWVudHMgKioqKgogCkBAIC0yOSw3ICszMCw3IEBACiBbICAtLXdpdGgtbWFsbG9jLWRlYnVnICAgICBlbmFibGUgbWFsbG9jKCkgZGVidWdnaW5nXSwKIFtBQ19ERUZJTkUoTUFMTE9DX0RFQlVHR0lORyldKQogCi1kbmwgKioqKiBDaGVjayBmb3Igc29tZSBwcm9ncmFtcyAqKioqCitkbmwgKioqKiBDaGVjayBmb3Igc29tZSBwcm9ncmFtcyBhbmQgbGlicmFyaWVzICoqKioKIAogQUNfUFJPR19NQUtFX1NFVAogQUNfUFJPR19DQwpAQCAtMzcsNiArMzgsMTAgQEAKIEFDX1BST0dfWUFDQwogQUNfUFJPR19MRVgKIEFDX1BST0dfUkFOTElCCitkbmwgQ2hlY2sgZm9yIC1saTM4NiBmb3IgTmV0QlNECitBQ19DSEVDS19MSUIoaTM4NixpMzg2X3NldF9sZHQsTERMSUJTPSIkTERMSUJTIC1saTM4NiIpCisKK2RubCAqKioqIENoZWNrIGZvciBmdW5jdGlvbnMgYW5kIGhlYWRlciBmaWxlcyAqKioqCiAKIEFDX0NIRUNLX0ZVTkNTKHRjZ2V0YXR0cikKIEFDX0NIRUNLX0hFQURFUlMoc3RkbGliLmgpCmRpZmYgLS1naXQgYS9jb250cm9scy9idXR0b24uYyBiL2NvbnRyb2xzL2J1dHRvbi5jCmluZGV4IDA4N2E3ZDcuLjkzMTA2NDMgMTAwNjQ0Ci0tLSBhL2NvbnRyb2xzL2J1dHRvbi5jCisrKyBiL2NvbnRyb2xzL2J1dHRvbi5jCkBAIC03MSw2ICs3MSw3IEBACiBMUkVTVUxUIEJ1dHRvblduZFByb2MoSFdORCBoV25kLCBVSU5UIHVNc2csIFdQQVJBTSB3UGFyYW0sIExQQVJBTSBsUGFyYW0pCiB7CiAgICAgICAgIFJFQ1QgcmVjdDsKKyAgICAgICAgUE9JTlQgcHQ7CiAJTE9ORyBsUmVzdWx0ID0gMDsKIAlXTkQgKnduZFB0ciA9IFdJTl9GaW5kV25kUHRyKGhXbmQpOwogCUxPTkcgc3R5bGUgPSB3bmRQdHItPmR3U3R5bGUgJiAweDAwMDAwMDBGOwpAQCAtMTM5LDcgKzE0MCw5IEBACiAJICAgICAgICBpZiAoIShpbmZvUHRyLT5zdGF0ZSAmIEJVVFRPTl9ISUdITElHSFRFRCkpIGJyZWFrOwogICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlKCBoV25kLCBCTV9TRVRTVEFURSwgRkFMU0UsIDAgKTsKICAgICAgICAgICAgICAgICBHZXRDbGllbnRSZWN0KCBoV25kLCAmcmVjdCApOwotICAgICAgICAgICAgICAgIGlmIChQdEluUmVjdCggJnJlY3QsIE1BS0VQT0lOVChsUGFyYW0pICkpCisgICAgICAgICAgICAgICAgcHQueCA9IExPV09SRChsUGFyYW0pOworICAgICAgICAgICAgICAgIHB0LnkgPSBISVdPUkQobFBhcmFtKTsKKyAgICAgICAgICAgICAgICBpZiAoUHRJblJlY3QoICZyZWN0LCBwdCApKQogICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgc3dpdGNoKHN0eWxlKQogICAgICAgICAgICAgICAgICAgICB7CkBAIC0xNzEsNyArMTc0LDkgQEAKICAgICAgICAgICAgICAgICBpZiAoR2V0Q2FwdHVyZSgpID09IGhXbmQpCiAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICBHZXRDbGllbnRSZWN0KCBoV25kLCAmcmVjdCApOwotICAgICAgICAgICAgICAgICAgICBpZiAoUHRJblJlY3QoICZyZWN0LCBNQUtFUE9JTlQobFBhcmFtKSkgKQorICAgICAgICAgICAgICAgICAgICBwdC54ID0gTE9XT1JEKGxQYXJhbSk7CisgICAgICAgICAgICAgICAgICAgIHB0LnkgPSBISVdPUkQobFBhcmFtKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKFB0SW5SZWN0KCAmcmVjdCwgcHQpICkKICAgICAgICAgICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2UoIGhXbmQsIEJNX1NFVFNUQVRFLCBUUlVFLCAwICk7CiAgICAgICAgICAgICAgICAgICAgIGVsc2UgU2VuZE1lc3NhZ2UoIGhXbmQsIEJNX1NFVFNUQVRFLCBGQUxTRSwgMCApOwogICAgICAgICAgICAgICAgIH0KQEAgLTMxNCw3ICszMTksNyBAQAogICAgIAogICAgIC8qIGRyYXcgYnV0dG9uIGxhYmVsLCBpZiBhbnk6ICovCiAgICAgdGV4dCA9IChjaGFyKikgVVNFUl9IRUFQX0xJTl9BRERSKCB3bmRQdHItPmhUZXh0ICk7Ci0gICAgaWYgKHRleHRbMF0pCisgICAgaWYgKHRleHQgJiYgdGV4dFswXSkKICAgICB7CiAgICAgICAgIFNldFRleHRDb2xvciggaERDLCAod25kUHRyLT5kd1N0eWxlICYgV1NfRElTQUJMRUQpID8KICAgICAgICAgICAgICAgICAgICAgIEdldFN5c0NvbG9yKENPTE9SX0dSQVlURVhUKSA6IEdldFN5c0NvbG9yKENPTE9SX0JUTlRFWFQpKTsKQEAgLTM2OSw4ICszNzQsNiBAQAogCiAgICAgR2V0VGV4dE1ldHJpY3MoaERDLCAmdG0pOwogICAgIGRlbHRhID0gKHJjLmJvdHRvbSAtIHJjLnRvcCAtIHRtLnRtSGVpZ2h0KSA+PiAxOwotICAgIHRleHQgPSAoY2hhciopIFVTRVJfSEVBUF9MSU5fQUREUiggd25kUHRyLT5oVGV4dCApOwotICAgIHRleHRsZW4gPSBzdHJsZW4oIHRleHQgKTsKIAogICAgICAgLyogRHJhdyB0aGUgY2hlY2stYm94IGJpdG1hcCAqLwogICAgIHggPSB5ID0gMDsKQEAgLTM4Myw2ICszODYsOSBAQAogICAgICAgICAgICAgICAgICAgICAgIHgsIHksIGNoZWNrQm94V2lkdGgsIGNoZWNrQm94SGVpZ2h0ICk7CiAgICAgcmMubGVmdCArPSBjaGVja0JveFdpZHRoICsgdG0udG1BdmVDaGFyV2lkdGggLyAyOwogCisgICAgaWYgKCEodGV4dCA9IChjaGFyKikgVVNFUl9IRUFQX0xJTl9BRERSKCB3bmRQdHItPmhUZXh0ICkpKSByZXR1cm47CisgICAgdGV4dGxlbiA9IHN0cmxlbiggdGV4dCApOworCiAgICAgaWYgKGFjdGlvbiA9PSBPREFfRFJBV0VOVElSRSkKICAgICB7CiAgICAgICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19ESVNBQkxFRCkKQEAgLTQwMCw3ICs0MDYsNyBAQAogICAgICAgICAgICAgcmMuYm90dG9tIC09IGRlbHRhICsgMTsKICAgICAgICAgfQogICAgICAgICByYy5sZWZ0LS07Ci0gICAgICAgIHJjLnJpZ2h0ID0gbWluKCByYy5sZWZ0ICsgc2l6ZS5jeCArIDIsIHJjLnJpZ2h0ICk7CisgICAgICAgIHJjLnJpZ2h0ID0gTUlOKCByYy5sZWZ0ICsgc2l6ZS5jeCArIDIsIHJjLnJpZ2h0ICk7CiAgICAgICAgIERyYXdGb2N1c1JlY3QoaERDLCAmcmMpOwogICAgIH0KIH0KQEAgLTQ1Myw3ICs0NTksNyBAQAogICAgIExpbmVUbyggaERDLCByYy5sZWZ0LCByYy5ib3R0b20tMSApOwogICAgIExpbmVUbyggaERDLCByYy5sZWZ0LCByYy50b3ArMiApOwogCi0gICAgdGV4dCA9IChjaGFyKikgVVNFUl9IRUFQX0xJTl9BRERSKCB3bmRQdHItPmhUZXh0ICk7CisgICAgaWYgKCEodGV4dCA9IChjaGFyKikgVVNFUl9IRUFQX0xJTl9BRERSKCB3bmRQdHItPmhUZXh0ICkpKSByZXR1cm47CiAgICAgR2V0VGV4dEV4dGVudFBvaW50KGhEQywgdGV4dCwgc3RybGVuKHRleHQpLCAmc2l6ZSk7CiAgICAgcmMubGVmdCAgKz0gMTA7CiAgICAgcmMucmlnaHQgID0gcmMubGVmdCArIHNpemUuY3ggKyAxOwpkaWZmIC0tZ2l0IGEvY29udHJvbHMvY29tYm8uYyBiL2NvbnRyb2xzL2NvbWJvLmMKaW5kZXggYWFiOTdmNS4uODI4NGQ1MSAxMDA2NDQKLS0tIGEvY29udHJvbHMvY29tYm8uYworKysgYi9jb250cm9scy9jb21iby5jCkBAIC0yMiw2ICsyMiw3IEBACiAjaW5jbHVkZSAiZG9zX2ZzLmgiCiAjaW5jbHVkZSAic3RkZGVidWcuaCIKICNpbmNsdWRlICJkZWJ1Zy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogIC8qCiAgICogTm90ZTogQ29tYm9zIGFyZSBwcm9iYWJseSBpbXBsZW1lbnRlZCBpbiBhIGRpZmZlcmVudCB3YXkgYnkgV2luZG93cy4KQEAgLTU5LDcgKzYwLDcgQEAKIHsKICAgTFBIRUFEQ09NQk8gbHBoYzsKIAotICBscGhjID0gKExQSEVBRENPTUJPKW1hbGxvYyhzaXplb2YoSEVBRENPTUJPKSk7CisgIGxwaGMgPSAoTFBIRUFEQ09NQk8peG1hbGxvYyhzaXplb2YoSEVBRENPTUJPKSk7CiAgIFNldFdpbmRvd0xvbmcoaHduZCw0LChMT05HKWxwaGMpOwogICBscGhjLT5oV25kRWRpdCA9IDA7CiAgIGxwaGMtPmhXbmRMQm94ID0gMDsKQEAgLTY1Miw3ICs2NTMsMTEgQEAKIHN0YXRpYyBMT05HIENCTENyZWF0ZSggSFdORCBod25kLCBXT1JEIHdQYXJhbSwgTE9ORyBsUGFyYW0gKQogewogICBDUkVBVEVTVFJVQ1QgKmNyZWF0ZVN0cnVjdCA9IChDUkVBVEVTVFJVQ1QgKilQVFJfU0VHX1RPX0xJTihsUGFyYW0pOworI2lmZGVmIFdJTkVMSUIzMgorICBTZXRXaW5kb3dMb25nKGh3bmQsMCwoTE9ORyljcmVhdGVTdHJ1Y3QtPmxwQ3JlYXRlUGFyYW1zKTsKKyNlbHNlCiAgIFNldFdpbmRvd1dvcmQoaHduZCwwLExPV09SRChjcmVhdGVTdHJ1Y3QtPmxwQ3JlYXRlUGFyYW1zKSk7CisjZW5kaWYKICAgcmV0dXJuIDA7CiB9CiAKQEAgLTc3Miw3ICs3NzcsNyBAQAogICAgICAgbHBscy0+aXRlbVJlY3QubGVmdCAgID0gcmVjdC5sZWZ0OwogICAgICAgbHBscy0+aXRlbVJlY3QucmlnaHQgID0gcmVjdC5yaWdodDsKIAotICAgICAgZHByaW50Zl9saXN0Ym94KHN0ZGRlYiwiZHJhd2luZyBpdGVtOiAlZCAlZCAlZCAlZCAlZFxuIixyZWN0LmxlZnQsdG9wLHJlY3QucmlnaHQsdG9wK2hlaWdodCxscGxzLT5pdGVtU3RhdGUpOworICAgICAgZHByaW50Zl9saXN0Ym94KHN0ZGRlYiwiZHJhd2luZyBpdGVtOiAlbGQgJWQgJWxkICVkICVkXG4iLChMT05HKXJlY3QubGVmdCx0b3AsKExPTkcpcmVjdC5yaWdodCx0b3AraGVpZ2h0LGxwbHMtPml0ZW1TdGF0ZSk7CiAgICAgICBpZiAobHBobC0+T3duZXJEcmF3bikgewogCUxpc3RCb3hEcmF3SXRlbSAoY29tYm9od25kLCBscGhsLCBoZGMsIGxwbHMsICZscGxzLT5pdGVtUmVjdCwgT0RBX0RSQVdFTlRJUkUsIDApOwogCWlmIChscGxzLT5pdGVtU3RhdGUpCkBAIC03OTAsNiArNzk1LDcgQEAKIAogICAgIGxwbHMgPSBscGxzLT5scE5leHQ7CiAgIH0KKyAgU2V0U2Nyb2xsUmFuZ2UoaHduZCwgU0JfVkVSVCwgMCwgTGlzdE1heEZpcnN0VmlzaWJsZShscGhsKSwgVFJVRSk7CiAgIFNlbGVjdE9iamVjdChoZGMsaE9sZEZvbnQpOwogICBFbmRQYWludCggaHduZCwgJnBzICk7CiAgIHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvY29udHJvbHMvZGVza3RvcC5jIGIvY29udHJvbHMvZGVza3RvcC5jCmluZGV4IGVmOTM3N2IuLmIzNzk2ZjQgMTAwNjQ0Ci0tLSBhL2NvbnRyb2xzL2Rlc2t0b3AuYworKysgYi9jb250cm9scy9kZXNrdG9wLmMKQEAgLTExOCw3ICsxMTgsNyBAQAogICoKICAqIFdpbmRvdyBwcm9jZWR1cmUgZm9yIHRoZSBkZXNrdG9wIHdpbmRvdy4KICAqLwotTFJFU1VMVCBEZXNrdG9wV25kUHJvYyAoIEhXTkQgaHduZCwgV09SRCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtICkKK0xSRVNVTFQgRGVza3RvcFduZFByb2MgKCBIV05EIGh3bmQsIFVJTlQgbWVzc2FnZSwgV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSApCiB7CiAgICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwogICAgIERFU0tUT1BJTkZPICppbmZvUHRyID0gKERFU0tUT1BJTkZPICopd25kUHRyLT53RXh0cmE7CmRpZmYgLS1naXQgYS9jb250cm9scy9lZGl0LmMgYi9jb250cm9scy9lZGl0LmMKaW5kZXggOTU3Yzg3MC4uMzE1MzRkNiAxMDA2NDQKLS0tIGEvY29udHJvbHMvZWRpdC5jCisrKyBiL2NvbnRyb2xzL2VkaXQuYwpAQCAtMTgsNiArMTgsNyBAQAogI2luY2x1ZGUgInVzZXIuaCIKICNpbmNsdWRlICJzdGRkZWJ1Zy5oIgogI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiAKICNpZmRlZiBXSU5FTElCMzIKQEAgLTQ2LDcgKzQ3LDcgQEAKICAgICBSRUNUIGZtdHJjOyAgICAgICAgICAgICAgLyogcmVjdGFuZ2xlIGluIHdoaWNoIHRvIGZvcm1hdCB0ZXh0ICovCiAgICAgaW50IHR4dGh0OyAgICAgICAgICAgICAgIC8qIGhlaWdodCBvZiB0ZXh0IGxpbmUgaW4gcGl4ZWxzICovCiAgICAgSEFORExFIGhUZXh0OyAgICAgICAgICAgIC8qIGhhbmRsZSB0byB0ZXh0IGJ1ZmZlciAqLwotICAgIHNob3J0ICpDaGFyV2lkdGhzOyAgICAgICAvKiB3aWR0aHMgb2YgY2hhcnMgaW4gZm9udCAqLworICAgIElOVCAqQ2hhcldpZHRoczsgICAgICAgICAvKiB3aWR0aHMgb2YgY2hhcnMgaW4gZm9udCAqLwogICAgIHVuc2lnbmVkIGludCAqdGV4dHB0cnM7ICAvKiBsaXN0IG9mIGxpbmUgb2Zmc2V0cyAqLwogICAgIGNoYXIgKkJsYW5rTGluZTsgICAgICAgICAvKiB0byBmaWxsIGJsYW5rIGxpbmVzIHF1aWNrbHkgKi8KICAgICBpbnQgQ3VyckNvbDsgICAgICAgICAgICAgLyogY3VycmVudCBjb2x1bW4gKi8KQEAgLTEwNiw3ICsxMDcsMTIgQEAKIHsKICAgICBITE9DQUwgcmV0OwogCisjaWYgZGVmaW5lZChXSU5FTElCKQorICAgIC8qIHRlbXBvcmFyeSBmaXgsIHVudGlsIExvY2FsIG1lbW9yeSBpcyBjb3JyZWN0bHkgaW1wbGVtZW50ZWQgaW4gV0lORUxJQiAqLworICAgIHJldCA9IExvY2FsQWxsb2MoIGZsYWdzLCBieXRlcyApOworI2Vsc2UKICAgICByZXQgPSBMT0NBTF9BbGxvYyggV0lOX0dldFdpbmRvd0luc3RhbmNlKGh3bmQpLCBmbGFncywgYnl0ZXMgKTsKKyNlbmRpZgogICAgIGlmICghcmV0KQogICAgICAgICBwcmludGYoIkVESVRfSGVhcEFsbG9jOiBPdXQgb2YgaGVhcC1tZW1vcnlcbiIpOwogICAgIHJldHVybiByZXQ7CkBAIC0xMjIsOSArMTI4LDEzIEBACiAgICAgSElOU1RBTkNFIGhpbnN0YW5jZSA9IFdJTl9HZXRXaW5kb3dJbnN0YW5jZSggaHduZCApOwogICAgIEhBTkRMRSBvZmZzOwogICAgIAorI2lmIGRlZmluZWQoV0lORUxJQikKKyAgICByZXR1cm4gaGFuZGxlOworI2Vsc2UKICAgICBpZiAoaGFuZGxlID09IDApIHJldHVybiAwOwogICAgIG9mZnMgPSBMT0NBTF9Mb2NrKCBoaW5zdGFuY2UsIGhhbmRsZSApOwogICAgIHJldHVybiBQVFJfU0VHX09GRl9UT19MSU4oIGhpbnN0YW5jZSwgb2ZmcyApOworI2VuZGlmCiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTEzMiw4ICsxNDIsMTIgQEAKICAqLwogc3RhdGljIHZvaWQgRURJVF9IZWFwVW5sb2NrKEhXTkQgaHduZCwgSEFORExFIGhhbmRsZSkKIHsKKyNpZiBkZWZpbmVkKFdJTkVMSUIpCisgICAgcmV0dXJuIDA7CisjZWxzZQogICAgIGlmIChoYW5kbGUgPT0gMCkgcmV0dXJuOwogICAgIExPQ0FMX1VubG9jayggV0lOX0dldFdpbmRvd0luc3RhbmNlKCBod25kICksIGhhbmRsZSApOworI2VuZGlmCiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTE0Myw4ICsxNTcsMTIgQEAKICAqLwogc3RhdGljIEhMT0NBTCBFRElUX0hlYXBSZUFsbG9jKEhXTkQgaHduZCwgSEFORExFIGhhbmRsZSwgaW50IGJ5dGVzKQogeworI2lmIGRlZmluZWQoV0lORUxJQikKKyAgICByZXR1cm4gTG9jYWxSZUFsbG9jKCBoYW5kbGUsIGJ5dGVzLCBMTUVNX0ZJWEVEICk7CisjZWxzZQogICAgIHJldHVybiBMT0NBTF9SZUFsbG9jKCBXSU5fR2V0V2luZG93SW5zdGFuY2UoaHduZCksIGhhbmRsZSwgYnl0ZXMsIAogCQkJICBMTUVNX0ZJWEVEICk7CisjZW5kaWYKIH0KIAogCkBAIC0xNTUsNyArMTczLDExIEBACiAgKi8KIHN0YXRpYyB2b2lkIEVESVRfSGVhcEZyZWUoSFdORCBod25kLCBIQU5ETEUgaGFuZGxlKQogeworI2lmIGRlZmluZWQoV0lORUxJQikKKyAgICBMb2NhbEZyZWUoIGhhbmRsZSApOworI2Vsc2UKICAgICBMT0NBTF9GcmVlKCBXSU5fR2V0V2luZG93SW5zdGFuY2UoaHduZCksIGhhbmRsZSApOworI2VuZGlmCiB9CiAKIApAQCAtMTY2LDcgKzE4OCwxMSBAQAogICovCiBzdGF0aWMgdW5zaWduZWQgaW50IEVESVRfSGVhcFNpemUoSFdORCBod25kLCBIQU5ETEUgaGFuZGxlKQogeworI2lmIGRlZmluZWQoV0lORUxJQikKKyAgICByZXR1cm4gTG9jYWxTaXplKCBoYW5kbGUgKTsKKyNlbHNlCiAgICAgcmV0dXJuIExPQ0FMX1NpemUoIFdJTl9HZXRXaW5kb3dJbnN0YW5jZShod25kKSwgaGFuZGxlICk7CisjZW5kaWYKIH0KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCkBAIC0yMzksNyArMjY1LDcgQEAKICAgICBFRElUU1RBVEUgKmVzID0gRURJVF9HZXRFZGl0U3RhdGUoaHduZCk7CiAgICAgCiAgICAgZHByaW50Zl9lZGl0KCBzdGRkZWIsICJFRElUX0NsZXJUZXh0UG9pbnRlcnNcbiIgKTsKLSAgICBlcy0+dGV4dHB0cnMgPSByZWFsbG9jKGVzLT50ZXh0cHRycywgc2l6ZW9mKGludCkpOworICAgIGVzLT50ZXh0cHRycyA9IHhyZWFsbG9jKGVzLT50ZXh0cHRycywgc2l6ZW9mKGludCkpOwogICAgIGVzLT50ZXh0cHRyc1swXSA9IDA7CiB9CiAKQEAgLTI2Nyw3ICsyOTMsNyBAQAogICAgIH0gZWxzZSBlcy0+d2xpbmVzID0gMTsKICAgICAKICAgICBkcHJpbnRmX2VkaXQoIHN0ZGRlYiwgIkVESVRfQnVpbGRUZXh0UG9pbnRlcnM6IHJlYWxsb2NcbiIgKTsKLSAgICBlcy0+dGV4dHB0cnMgPSByZWFsbG9jKGVzLT50ZXh0cHRycywgKGVzLT53bGluZXMgKyAyKSAqIHNpemVvZihpbnQpKTsKKyAgICBlcy0+dGV4dHB0cnMgPSB4cmVhbGxvYyhlcy0+dGV4dHB0cnMsIChlcy0+d2xpbmVzICsgMikgKiBzaXplb2YoaW50KSk7CiAgICAgCiAgICAgY3AgPSB0ZXh0OwogICAgIGRwcmludGZfZWRpdChzdGRkZWIsIkJ1aWxkVGV4dFBvaW50ZXJzOiAlZCBsaW5lcywgcG9pbnRlciAlcFxuIiwgCkBAIC0yOTAsNyArMzE2LDcgQEAKIAkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogd2lkdGggb2YgbGluZSBpbiBwaXhlbHMgKi8KIAkgICAgY3ArKzsKIAl9Ci0JZXMtPnRleHR3aWR0aCA9IG1heChlcy0+dGV4dHdpZHRoLCBsZW4pOworCWVzLT50ZXh0d2lkdGggPSBNQVgoZXMtPnRleHR3aWR0aCwgbGVuKTsKIAlpZiAoKmNwKQogCSAgICBjcCsrOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBza2lwICdcbicgKi8KICAgICB9CkBAIC0zNDUsNyArMzcxLDcgQEAKICAgICBlbHNlIGxlbiA9IGNwIC0gY3AxOwogICAgIAogICAgIC8qIHN0b3JlIHNlbGVjdGVkIGxpbmUgYW5kIHJldHVybiBoYW5kbGUgKi8KLSAgICBjcCA9IG1hbGxvYyggbGVuICsgMSApOworICAgIGNwID0geG1hbGxvYyggbGVuICsgMSApOwogICAgIHN0cm5jcHkoIGNwLCBjcDEsIGxlbik7CiAgICAgY3BbbGVuXSA9IDA7CiAgICAgcmV0dXJuIGNwOwpAQCAtNDk3LDggKzUyMyw4IEBACiAgICAgaWYgKHN0cmxlbihlcy0+QmxhbmtMaW5lKSA8IChlcy0+Q2xpZW50V2lkdGggLyBlcy0+Q2hhcldpZHRoc1szMl0pICsgMikKICAgICB7CiAJZHByaW50Zl9lZGl0KCBzdGRkZWIsICJFRElUX1dyaXRlVGV4dDogcmVhbGxvY1xuIiApOwotICAgICAgICBlcy0+QmxhbmtMaW5lID0gcmVhbGxvYyhlcy0+QmxhbmtMaW5lLCAKLQkJCQkoZXMtPkNsaWVudFdpZHRoIC8gZXMtPkNoYXJXaWR0aHNbMzJdKSArIDIpOworICAgICAgICBlcy0+QmxhbmtMaW5lID0geHJlYWxsb2MoZXMtPkJsYW5rTGluZSwgCisJCQkJIChlcy0+Q2xpZW50V2lkdGggLyBlcy0+Q2hhcldpZHRoc1szMl0pICsgMik7CiAgICAgICAgIG1lbXNldChlcy0+QmxhbmtMaW5lLCAnICcsIChlcy0+Q2xpZW50V2lkdGggLyBlcy0+Q2hhcldpZHRoc1szMl0pICsgMik7CiAJZXMtPkJsYW5rTGluZVsoZXMtPkNsaWVudFdpZHRoIC8gZXMtPkNoYXJXaWR0aHNbMzJdKSArIDFdID0gMDsKICAgICB9CkBAIC01ODUsMTQgKzYxMSwxNCBAQAogICAgIC8qIG1ha2Ugc3VyZSByZWN0YW5nbGUgaXMgd2l0aGluIHdpbmRvdyAqLwogICAgIGlmIChyYy5sZWZ0ID49IGVzLT5DbGllbnRXaWR0aCAtIDEpCiAgICAgewotCWRwcmludGZfZWRpdChzdGRkZWIsIkVESVRfV3JpdGVUZXh0TGluZTogcmMubGVmdCAoJWQpIGlzIGdyZWF0ZXIgdGhhbiByaWdodCBlZGdlXG4iLAotCSAgICAgICByYy5sZWZ0KTsKKwlkcHJpbnRmX2VkaXQoc3RkZGViLCJFRElUX1dyaXRlVGV4dExpbmU6IHJjLmxlZnQgKCVsZCkgaXMgZ3JlYXRlciB0aGFuIHJpZ2h0IGVkZ2VcbiIsCisJICAgICAgIChMT05HKXJjLmxlZnQpOwogCXJldHVybjsKICAgICB9CiAgICAgaWYgKHJjLnJpZ2h0IDw9IDApCiAgICAgewotCWRwcmludGZfZWRpdChzdGRkZWIsIkVESVRfV3JpdGVUZXh0TGluZTogcmMucmlnaHQgKCVkKSBpcyBsZXNzIHRoYW4gbGVmdCBlZGdlXG4iLAotCSAgICAgICByYy5yaWdodCk7CisJZHByaW50Zl9lZGl0KHN0ZGRlYiwiRURJVF9Xcml0ZVRleHRMaW5lOiByYy5yaWdodCAoJWxkKSBpcyBsZXNzIHRoYW4gbGVmdCBlZGdlXG4iLAorCSAgICAgICAoTE9ORylyYy5yaWdodCk7CiAJcmV0dXJuOwogICAgIH0KICAgICBpZiAoeSAtIGVzLT53dG9wIDwgKHJjLnRvcCAvIGVzLT50eHRodCkgfHwgCkBAIC02MjYsNyArNjUyLDcgQEAKIAlvZmYgKz0gcmMubGVmdDsKIAlsbmxlbiA9IGxubGVuMSAtIG9mZjsKICAgICB9Ci0gICAgbGVuID0gbWluKGxubGVuLCByYy5yaWdodCAtIHJjLmxlZnQpOworICAgIGxlbiA9IE1JTihsbmxlbiwgcmMucmlnaHQgLSByYy5sZWZ0KTsKIAogICAgIGlmIChTZWxNYXJrZWQoZXMpKQogICAgIHsKQEAgLTY1NSw3ICs2ODEsNyBAQAogCSAgICBjb2wgPSBFRElUX1N0cldpZHRoKGh3bmQsIGxwLCBzYmMsIDApOwogCSAgICBpZiAoY29sID4gKGVzLT53bGVmdCArIHJjLmxlZnQpKQogCSAgICB7Ci0JCWxlbiA9IG1pbihjb2wgLSBvZmYsIHJjLnJpZ2h0IC0gb2ZmKTsKKwkJbGVuID0gTUlOKGNvbCAtIG9mZiwgcmMucmlnaHQgLSBvZmYpOwogCQlFRElUX1dyaXRlVGV4dChod25kLCBscCwgb2ZmLCBsZW4sIHkgLSBlcy0+d3RvcCwgCiAJCQkgICAgICAgcmMubGVmdCwgJnJjLCBGQUxTRSwgRkFMU0UpOwogCQlvZmYgPSBjb2w7CkBAIC02NjUsMjQgKzY5MSwyNCBAQAogCQljb2wgPSBFRElUX1N0cldpZHRoKGh3bmQsIGxwLCBzZWMsIDApOwogCQlpZiAoY29sIDwgKGVzLT53bGVmdCArIHJjLnJpZ2h0KSkKIAkJewotCQkgICAgbGVuID0gbWluKGNvbCAtIG9mZiwgcmMucmlnaHQgLSBvZmYpOworCQkgICAgbGVuID0gTUlOKGNvbCAtIG9mZiwgcmMucmlnaHQgLSBvZmYpOwogCQkgICAgRURJVF9Xcml0ZVRleHQoaHduZCwgbHAsIG9mZiwgbGVuLCB5IC0gZXMtPnd0b3AsCiAJCQkJICAgb2ZmIC0gZXMtPndsZWZ0LCAmcmMsIEZBTFNFLCBUUlVFKTsKIAkJICAgIG9mZiA9IGNvbDsKLQkJICAgIGxlbiA9IG1pbihsbmxlbiAtIG9mZiwgcmMucmlnaHQgLSBvZmYpOworCQkgICAgbGVuID0gTUlOKGxubGVuIC0gb2ZmLCByYy5yaWdodCAtIG9mZik7CiAJCSAgICBFRElUX1dyaXRlVGV4dChod25kLCBscCwgb2ZmLCBsZW4sIHkgLSBlcy0+d3RvcCwKIAkJCQkgICBvZmYgLSBlcy0+d2xlZnQsICZyYywgVFJVRSwgRkFMU0UpOwogCQl9CiAJCWVsc2UKIAkJewotCQkgICAgbGVuID0gbWluKGxubGVuIC0gb2ZmLCByYy5yaWdodCAtIG9mZik7CisJCSAgICBsZW4gPSBNSU4obG5sZW4gLSBvZmYsIHJjLnJpZ2h0IC0gb2ZmKTsKIAkJICAgIEVESVRfV3JpdGVUZXh0KGh3bmQsIGxwLCBvZmYsIGxlbiwgeSAtIGVzLT53dG9wLAogCQkJCSAgIG9mZiAtIGVzLT53bGVmdCwgJnJjLCBUUlVFLCBUUlVFKTsKIAkJfQogCSAgICB9CiAJICAgIGVsc2UKIAkgICAgewotCQlsZW4gPSBtaW4obG5sZW4gLSBvZmYsIHJjLnJpZ2h0IC0gb2ZmKTsKKwkJbGVuID0gTUlOKGxubGVuIC0gb2ZmLCByYy5yaWdodCAtIG9mZik7CiAJCWlmIChjb2wgPCAoZXMtPndsZWZ0ICsgcmMucmlnaHQpKQogCQkgICAgRURJVF9Xcml0ZVRleHQoaHduZCwgbHAsIG9mZiwgbGVuLCB5IC0gZXMtPnd0b3AsCiAJCQkJICAgb2ZmIC0gZXMtPndsZWZ0LCAmcmMsIFRSVUUsIFRSVUUpOwpAQCAtNjkzLDExICs3MTksMTEgQEAKIAkgICAgY29sID0gRURJVF9TdHJXaWR0aChod25kLCBscCwgc2VjLCAwKTsKIAkgICAgaWYgKGNvbCA8IChlcy0+d2xlZnQgKyByYy5yaWdodCkpCiAJICAgIHsKLQkJbGVuID0gbWluKGNvbCAtIG9mZiwgcmMucmlnaHQgLSBvZmYpOworCQlsZW4gPSBNSU4oY29sIC0gb2ZmLCByYy5yaWdodCAtIG9mZik7CiAJCUVESVRfV3JpdGVUZXh0KGh3bmQsIGxwLCBvZmYsIGxlbiwgeSAtIGVzLT53dG9wLAogCQkJICAgICAgIG9mZiAtIGVzLT53bGVmdCwgJnJjLCBGQUxTRSwgVFJVRSk7CiAJCW9mZiA9IGNvbDsKLQkJbGVuID0gbWluKGxubGVuIC0gb2ZmLCByYy5yaWdodCAtIG9mZik7CisJCWxlbiA9IE1JTihsbmxlbiAtIG9mZiwgcmMucmlnaHQgLSBvZmYpOwogCQlFRElUX1dyaXRlVGV4dChod25kLCBscCwgb2ZmLCBsZW4sIHkgLSBlcy0+d3RvcCwKIAkJCSAgICAgICBvZmYgLSBlcy0+d2xlZnQsICZyYywgVFJVRSwgRkFMU0UpOwogCSAgICB9CkBAIC03MTksNyArNzQ1LDcgQEAKIHN0YXRpYyBpbnQgRURJVF9Db21wdXRlVlNjcm9sbFBvcyhIV05EIGh3bmQpCiB7CiAgICAgaW50IHZzY3JvbGxwb3M7Ci0gICAgc2hvcnQgbWlucG9zLCBtYXhwb3M7CisgICAgSU5UIG1pbnBvcywgbWF4cG9zOwogICAgIEVESVRTVEFURSAqZXMgPSBFRElUX0dldEVkaXRTdGF0ZShod25kKTsKIAogICAgIEdldFNjcm9sbFJhbmdlKGh3bmQsIFNCX1ZFUlQsICZtaW5wb3MsICZtYXhwb3MpOwpAQCAtNzQyLDcgKzc2OCw3IEBACiBzdGF0aWMgaW50IEVESVRfQ29tcHV0ZUhTY3JvbGxQb3MoSFdORCBod25kKQogewogICAgIGludCBoc2Nyb2xscG9zOwotICAgIHNob3J0IG1pbnBvcywgbWF4cG9zOworICAgIElOVCBtaW5wb3MsIG1heHBvczsKICAgICBFRElUU1RBVEUgKmVzID0gRURJVF9HZXRFZGl0U3RhdGUoaHduZCk7CiAKICAgICBHZXRTY3JvbGxSYW5nZShod25kLCBTQl9IT1JaLCAmbWlucG9zLCAmbWF4cG9zKTsKQEAgLTkxMywxMyArOTM5LDEzIEBACiAgICAgY2hhciAqY3AgPSBFRElUX1RleHRMaW5lKGh3bmQsIGVzLT5DdXJyTGluZSk7CiAgICAgaW50IGN1cnJwZWw7CiAKLSAgICBlcy0+Q3VyckNvbCA9IG1pbihsZW4sIGVzLT5DdXJyQ29sKTsKLSAgICBlcy0+V25kQ29sID0gbWluKEVESVRfU3RyV2lkdGgoaHduZCwgY3AsIGxlbiwgMCkgLSBlcy0+d2xlZnQsIGVzLT5XbmRDb2wpOworICAgIGVzLT5DdXJyQ29sID0gTUlOKGxlbiwgZXMtPkN1cnJDb2wpOworICAgIGVzLT5XbmRDb2wgPSBNSU4oRURJVF9TdHJXaWR0aChod25kLCBjcCwgbGVuLCAwKSAtIGVzLT53bGVmdCwgZXMtPlduZENvbCk7CiAgICAgY3VycnBlbCA9IEVESVRfU3RyV2lkdGgoaHduZCwgY3AsIGVzLT5DdXJyQ29sLCAwKTsKIAogICAgIGlmIChlcy0+d2xlZnQgPiBjdXJycGVsKQogICAgIHsKLQllcy0+d2xlZnQgPSBtYXgoMCwgY3VycnBlbCAtIDIwKTsKKwllcy0+d2xlZnQgPSBNQVgoMCwgY3VycnBlbCAtIDIwKTsKIAllcy0+V25kQ29sID0gY3VycnBlbCAtIGVzLT53bGVmdDsKIAlVcGRhdGVXaW5kb3coaHduZCk7CiAgICAgfQpAQCAtMTA4MCw2ICsxMTA2LDcgQEAKICAgICB9CiB9CiAKKyNpZmRlZiBTVVBFUkZMVU9VU19GVU5DVElPTlMKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICBFRElUX0tleVZTY3JvbGxEb2MKICAqCkBAIC0xMTE0LDYgKzExNDEsNyBAQAogCVNldFNjcm9sbFBvcyhod25kLCBTQl9WRVJULCB2c2Nyb2xscG9zLCBUUlVFKTsKICAgICB9CiB9CisjZW5kaWYKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogIEVESVRfRGVsS2V5CkBAIC0xMjg3LDkgKzEzMTUsMTEgQEAKICAgICBjaGFyICp0ZXh0OwogCiAgICAgZHByaW50Zl9lZGl0KHN0ZGRlYiwiRURJVF9DbGVhclRleHQgJWRcbiIsYmxlbik7CisjaWZuZGVmIFdJTkVMSUIKICAgICBlcy0+aFRleHQgPSBFRElUX0hlYXBSZUFsbG9jKGh3bmQsIGVzLT5oVGV4dCwgYmxlbik7CiAgICAgdGV4dCA9IEVESVRfSGVhcExvY2soaHduZCwgZXMtPmhUZXh0KTsKICAgICBtZW1zZXQodGV4dCwgMCwgYmxlbik7CisjZW5kaWYKICAgICBlcy0+dGV4dGxlbiA9IDA7CiAgICAgZXMtPndsaW5lcyA9IDA7CiAgICAgZXMtPkN1cnJMaW5lID0gZXMtPkN1cnJDb2wgPSAwOwpAQCAtMTI5Nyw3ICsxMzI3LDkgQEAKICAgICBlcy0+d2xlZnQgPSBlcy0+d3RvcCA9IDA7CiAgICAgZXMtPnRleHR3aWR0aCA9IDA7CiAgICAgZXMtPlRleHRDaGFuZ2VkID0gRkFMU0U7CisjaWZuZGVmIFdJTkVMSUIKICAgICBFRElUX0NsZWFyVGV4dFBvaW50ZXJzKGh3bmQpOworI2VuZGlmCiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTE0MjEsNiArMTQ1Myw3IEBACiAgICAgfQogfQogCisjaWZkZWYgU1VQRVJGTFVPVVNfRlVOQ1RJT05TCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgRURJVF9UZXh0TGluZU51bWJlcgogICoKQEAgLTE0NDQsNiArMTQ3Nyw3IEBACiAgICAgfQogICAgIHJldHVybiBsaW5lbm8gLSAxOwogfQorI2VuZGlmCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICBFRElUX1NldEFuY2hvcgpAQCAtMTUyOSw3ICsxNTYzLDcgQEAKIAogICAgIGJibCA9IGVzLT5TZWxFbmRMaW5lOwogICAgIGJiYyA9IGVzLT5TZWxFbmRDb2w7Ci0gICAgeSA9IG1heCh5LDApOworICAgIHkgPSBNQVgoeSwwKTsKICAgICBpZiAoSXNNdWx0aUxpbmUoaHduZCkpCiAgICAgewogICAgICAgICBpZiAoKGxpbmUgPSBlcy0+d3RvcCArIHkgLyBlcy0+dHh0aHQpID49IGVzLT53bGluZXMpCkBAIC0xNTQ5LDcgKzE1ODMsNyBAQAogICAgIGVzLT5DdXJyTGluZSA9IGVzLT53dG9wICsgZXMtPlduZFJvdzsKICAgICBlcy0+U2VsRW5kTGluZSA9IGVzLT5DdXJyTGluZTsKIAotICAgIGVzLT5XbmRDb2wgPSBlcy0+d2xlZnQgKyBtYXgoeCwwKTsKKyAgICBlcy0+V25kQ29sID0gZXMtPndsZWZ0ICsgTUFYKHgsMCk7CiAgICAgaWYgKGVzLT5XbmRDb2wgPiBFRElUX1N0cldpZHRoKGh3bmQsIGNwLCBsZW4sIDApKQogCWVzLT5XbmRDb2wgPSBFRElUX1N0cldpZHRoKGh3bmQsIGNwLCBsZW4sIDApOwogICAgIGVzLT5DdXJyQ29sID0gRURJVF9QaXhlbFRvQ2hhcihod25kLCBlcy0+Q3VyckxpbmUsICYoZXMtPlduZENvbCkpOwpAQCAtMTc2NCwxMiArMTc5OCwxMiBAQAogICAgIEhpZGVDYXJldChod25kKTsKICAgICBpZiAoSXNNdWx0aUxpbmUoaHduZCkgJiYgZXMtPndsaW5lcyA+IDEpCiAgICAgewotCWVzLT50ZXh0d2lkdGggPSBtYXgoZXMtPnRleHR3aWR0aCwKKwllcy0+dGV4dHdpZHRoID0gTUFYKGVzLT50ZXh0d2lkdGgsCiAJCSAgICBFRElUX1N0cldpZHRoKGh3bmQsIEVESVRfVGV4dExpbmUoaHduZCwgZXMtPkN1cnJMaW5lKSwKIAkJICAgIChpbnQpKEVESVRfVGV4dExpbmUoaHduZCwgZXMtPkN1cnJMaW5lICsgMSkgLQogCQkJICBFRElUX1RleHRMaW5lKGh3bmQsIGVzLT5DdXJyTGluZSkpLCAwKSk7CiAgICAgfSBlbHNlIHsKLSAgICAgIGVzLT50ZXh0d2lkdGggPSBtYXgoZXMtPnRleHR3aWR0aCwKKyAgICAgIGVzLT50ZXh0d2lkdGggPSBNQVgoZXMtPnRleHR3aWR0aCwKIAkJCSAgRURJVF9TdHJXaWR0aChod25kLCB0ZXh0LCBzdHJsZW4odGV4dCksIDApKTsKICAgICB9CiAKQEAgLTE4ODcsMTUgKzE5MjEsMTUgQEAKICAgICBkcHJpbnRmX2VkaXQoIHN0ZGRlYiwgIkVESVRfU2V0VGFiU3RvcHNcbiIgKTsKICAgICBlcy0+TnVtVGFiU3RvcHMgPSB3UGFyYW07CiAgICAgaWYgKHdQYXJhbSA9PSAwKQotCWVzLT5UYWJTdG9wcyA9IHJlYWxsb2MoZXMtPlRhYlN0b3BzLCAyKTsKKwllcy0+VGFiU3RvcHMgPSB4cmVhbGxvYyhlcy0+VGFiU3RvcHMsIDIpOwogICAgIGVsc2UgaWYgKHdQYXJhbSA9PSAxKQogICAgIHsKLQllcy0+VGFiU3RvcHMgPSByZWFsbG9jKGVzLT5UYWJTdG9wcywgMik7CisJZXMtPlRhYlN0b3BzID0geHJlYWxsb2MoZXMtPlRhYlN0b3BzLCAyKTsKIAllcy0+VGFiU3RvcHNbMF0gPSBMT1dPUkQobFBhcmFtKTsKICAgICB9CiAgICAgZWxzZQogICAgIHsKLQllcy0+VGFiU3RvcHMgPSByZWFsbG9jKGVzLT5UYWJTdG9wcywgd1BhcmFtICogc2l6ZW9mKCplcy0+VGFiU3RvcHMpKTsKKwllcy0+VGFiU3RvcHMgPSB4cmVhbGxvYyhlcy0+VGFiU3RvcHMsIHdQYXJhbSAqIHNpemVvZigqZXMtPlRhYlN0b3BzKSk7CiAJbWVtY3B5KGVzLT5UYWJTdG9wcywgKHVuc2lnbmVkIHNob3J0ICopUFRSX1NFR19UT19MSU4obFBhcmFtKSwgd1BhcmFtKTsKICAgICB9CiAgICAgcmV0dXJuIDA7CkBAIC0xOTEyLDcgKzE5NDYsNyBAQAogCiAgICAgY3AgPSBFRElUX1RleHRMaW5lKGh3bmQsIHdQYXJhbSk7CiAgICAgY3AxID0gRURJVF9UZXh0TGluZShod25kLCB3UGFyYW0gKyAxKTsKLSAgICBsZW4gPSBtaW4oKGludCkoY3AxIC0gY3ApLCAoV09SRCkoKmJ1ZmZlcikpOworICAgIGxlbiA9IE1JTigoaW50KShjcDEgLSBjcCksIChXT1JEKSgqYnVmZmVyKSk7CiAgICAgZHByaW50Zl9lZGl0KCBzdGRkZWIsICJFRElUX0dldExpbmVNc2c6ICVkICVkLCBsZW4gJWRcbiIsIChpbnQpKFdPUkQpKCpidWZmZXIpLCAoaW50KShXT1JEKSgqKGNoYXIgKilidWZmZXIpLCBsZW4pOwogICAgIHN0cm5jcHkoYnVmZmVyLCBjcCwgbGVuKTsKIApAQCAtMjE4MSw4ICsyMjE1LDggQEAKICAgICBoZGMgPSBCZWdpblBhaW50KGh3bmQsICZwcyk7CiAgICAgcmMgPSBwcy5yY1BhaW50OwogCi0gICAgZHByaW50Zl9lZGl0KHN0ZGRlYiwiV01fUEFJTlQ6IHJjPSglZCwlZCksICglZCwlZClcbiIsIHJjLmxlZnQsIHJjLnRvcCwgCi0JICAgcmMucmlnaHQsIHJjLmJvdHRvbSk7CisgICAgZHByaW50Zl9lZGl0KHN0ZGRlYiwiV01fUEFJTlQ6IHJjPSglbGQsJWxkKSwgKCVsZCwlbGQpXG4iLCAoTE9ORylyYy5sZWZ0LCAKKyAgICAgICAgICAgKExPTkcpcmMudG9wLCAoTE9ORylyYy5yaWdodCwgKExPTkcpcmMuYm90dG9tKTsKIAogICAgIGlmIChlcy0+UGFpbnRCa2dkKQogCUZpbGxXaW5kb3coR2V0UGFyZW50KGh3bmQpLCBod25kLCBoZGMsIChIQlJVU0gpQ1RMQ09MT1JfRURJVCk7CkBAIC0yMjEwLDEwICsyMjQ0LDEwIEBACiAgICAgLyogRURJVFNUQVRFIHN0cnVjdHVyZSBpdHNlbGYgY2FuIGJlIHN0b3JlZCBvbiBsb2NhbCBoZWFwICAqLwogCiAgICAgLyogYWxsb2NhdGUgc3BhY2UgZm9yIHN0YXRlIHZhcmlhYmxlIHN0cnVjdHVyZSAqLwotICAgIGVzID0gbWFsbG9jKCBzaXplb2YoRURJVFNUQVRFKSApOworICAgIGVzID0geG1hbGxvYyggc2l6ZW9mKEVESVRTVEFURSkgKTsKICAgICBTZXRXaW5kb3dMb25nKCBod25kLCAwLCAoTE9ORyllcyApOwotICAgIGVzLT50ZXh0cHRycyA9IG1hbGxvYyhzaXplb2YoaW50KSk7Ci0gICAgZXMtPkNoYXJXaWR0aHMgPSBtYWxsb2MoMjU2ICogc2l6ZW9mKHNob3J0KSk7CisgICAgZXMtPnRleHRwdHJzID0geG1hbGxvYyhzaXplb2YoaW50KSk7CisgICAgZXMtPkNoYXJXaWR0aHMgPSB4bWFsbG9jKDI1NiAqIHNpemVvZihJTlQpKTsKICAgICBlcy0+Q2xpZW50V2lkdGggPSBlcy0+Q2xpZW50SGVpZ2h0ID0gMTsKICAgICAvKiAtLS0gdGV4dCBidWZmZXIgKi8KICAgICBlcy0+TWF4VGV4dExlbiA9IE1BWFRFWFRMRU4gKyAxOwpAQCAtMjI4OSw3ICsyMzIzLDcgQEAKICAgICAvKiAtLS0gY2hhciB3aWR0aCBhcnJheSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwogICAgIC8qICAgICBvbmx5IGluaXRpYWxpc2UgY2hhcnMgPD0gMzIgYXMgWCByZXR1cm5zIHN0cmFuZ2Ugd2lkdGhzICovCiAgICAgLyogICAgIGZvciBvdGhlciBjaGFycyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KLSAgICBtZW1zZXQoZXMtPkNoYXJXaWR0aHMsIDAsIDI1NiAqIHNpemVvZihzaG9ydCkpOworICAgIG1lbXNldChlcy0+Q2hhcldpZHRocywgMCwgMjU2ICogc2l6ZW9mKElOVCkpOwogICAgIEdldENoYXJXaWR0aChoZGMsIDMyLCAyNTQsICZlcy0+Q2hhcldpZHRoc1szMl0pOwogCiAgICAgLyogLS0tIG90aGVyIHN0cnVjdHVyZSB2YXJpYWJsZXMgKi8KQEAgLTIzMDYsMTEgKzIzNDAsMTEgQEAKICAgICBlcy0+aERlbGV0ZWRUZXh0ID0gMDsKICAgICBlcy0+RGVsZXRlZExlbmd0aCA9IDA7CiAgICAgZXMtPk51bVRhYlN0b3BzID0gMDsKLSAgICBlcy0+VGFiU3RvcHMgPSBtYWxsb2MoIHNpemVvZihzaG9ydCkgKTsKKyAgICBlcy0+VGFiU3RvcHMgPSB4bWFsbG9jKCBzaXplb2Yoc2hvcnQpICk7CiAKICAgICAvKiBhbGxvY2F0ZSBzcGFjZSBmb3IgYSBsaW5lIGZ1bGwgb2YgYmxhbmtzIHRvIHNwZWVkIHVwICovCiAgICAgLyogbGluZSBmaWxsaW5nICovCi0gICAgZXMtPkJsYW5rTGluZSA9IG1hbGxvYyggKGVzLT5DbGllbnRXaWR0aCAvIGVzLT5DaGFyV2lkdGhzWzMyXSkgKyAyKTsKKyAgICBlcy0+QmxhbmtMaW5lID0geG1hbGxvYyggKGVzLT5DbGllbnRXaWR0aCAvIGVzLT5DaGFyV2lkdGhzWzMyXSkgKyAyKTsKICAgICBtZW1zZXQoZXMtPkJsYW5rTGluZSwgJyAnLCAoZXMtPkNsaWVudFdpZHRoIC8gZXMtPkNoYXJXaWR0aHNbMzJdKSArIDIpOwogICAgIGVzLT5CbGFua0xpbmVbKGVzLT5DbGllbnRXaWR0aCAvIGVzLT5DaGFyV2lkdGhzWzMyXSkgKyAxXSA9IDA7CiAKZGlmZiAtLWdpdCBhL2NvbnRyb2xzL2xpc3Rib3guYyBiL2NvbnRyb2xzL2xpc3Rib3guYwppbmRleCAzOTNmNDk3Li5kMDY3NjBkIDEwMDY0NAotLS0gYS9jb250cm9scy9saXN0Ym94LmMKKysrIGIvY29udHJvbHMvbGlzdGJveC5jCkBAIC0yNCw2ICsyNCw3IEBACiAjaW5jbHVkZSAiZG9zX2ZzLmgiCiAjaW5jbHVkZSAic3RkZGVidWcuaCIKICNpbmNsdWRlICJkZWJ1Zy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogI2lmIDAKICNkZWZpbmUgTElTVF9IRUFQX0FMTE9DKGxwaGwsZixzaXplKSAoKGludClIRUFQX0FsbG9jKCZscGhsLT5IZWFwLGYsc2l6ZSkgJiAweGZmZmYpCkBAIC01NiwxMyArNTcsOCBAQAogewogICBMUEhFQURMSVNUIGxwaGw7CiAKLSAgbHBobCA9IChMUEhFQURMSVNUKW1hbGxvYyhzaXplb2YoSEVBRExJU1QpKTsKKyAgbHBobCA9IChMUEhFQURMSVNUKXhtYWxsb2Moc2l6ZW9mKEhFQURMSVNUKSk7CiAgIFNldFdpbmRvd0xvbmcoaHduZCwgMCwgKExPTkcpbHBobCk7Ci0gIGlmIChscGhsID09IE5VTEwpIHsKLSAgICBmcHJpbnRmKHN0ZGVyciwibWFsbG9jIGZhaWxlZCBpbiBDcmVhdGVMaXN0Qm94U3RydWN0KClcbiIpOwotICAgIGV4aXQoMSk7IC8qIFRoaW5ncyB3b24ndCBnZXQgYmV0dGVyICovCi0gIH0KLQogICBMaXN0Qm94SW5pdGlhbGl6ZShscGhsKTsKICAgbHBobC0+RHJhd0N0bFR5cGUgICAgPSBDdGxUeXBlOwogICBscGhsLT5DdGxJRCAgICAgICAgICA9IEdldFdpbmRvd1dvcmQoaHduZCxHV1dfSUQpOwpAQCAtMTE0Nyw3ICsxMTQzLDcgQEAKIAogICAgICAgaWYgKHRvcCA+IHJlY3QuYm90dG9tKSB7CiAJaWYgKGxwaGwtPmR3U3R5bGUgJiBMQlNfTVVMVElDT0xVTU4pIHsKLQkgIGxwaGwtPkl0ZW1zUGVyQ29sdW1uID0gbWF4KGxwaGwtPkl0ZW1zUGVyQ29sdW1uLCBpcGMpOworCSAgbHBobC0+SXRlbXNQZXJDb2x1bW4gPSBNQVgobHBobC0+SXRlbXNQZXJDb2x1bW4sIGlwYyk7CiAJICBpcGMgPSAwOwogCSAgdG9wID0gMDsKIAkgIHJlY3QubGVmdCArPSBscGhsLT5Db2x1bW5zV2lkdGg7CkBAIC0xMTgyLDYgKzExNzgsNyBAQAogCiAgICAgbHBscyA9IGxwbHMtPmxwTmV4dDsKICAgfQorICBMaXN0Qm94VXBkYXRlV2luZG93KGh3bmQsbHBobCxGQUxTRSk7CiAgIFNlbGVjdE9iamVjdChoZGMsaE9sZEZvbnQpOwogICBFbmRQYWludCggaHduZCwgJnBzICk7CiAgIHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvY29udHJvbHMvbWVudS5jIGIvY29udHJvbHMvbWVudS5jCmluZGV4IDkwZGI5OWMuLmIxNGQxYWIgMTAwNjQ0Ci0tLSBhL2NvbnRyb2xzL21lbnUuYworKysgYi9jb250cm9scy9tZW51LmMKQEAgLTEzNSw3ICsxMzUsNyBAQAogICogRmluZCBhIG1lbnUgaXRlbS4gUmV0dXJuIGEgcG9pbnRlciBvbiB0aGUgaXRlbSwgYW5kIG1vZGlmaWVzICpobWVudQogICogaW4gY2FzZSB0aGUgaXRlbSB3YXMgaW4gYSBzdWItbWVudS4KICAqLwotc3RhdGljIE1FTlVJVEVNICpNRU5VX0ZpbmRJdGVtKCBITUVOVSAqaG1lbnUsIFdPUkQgKm5Qb3MsIFdPUkQgd0ZsYWdzICkKK3N0YXRpYyBNRU5VSVRFTSAqTUVOVV9GaW5kSXRlbSggSE1FTlUgKmhtZW51LCBVSU5UICpuUG9zLCBVSU5UIHdGbGFncyApCiB7CiAgICAgUE9QVVBNRU5VICptZW51OwogICAgIE1FTlVJVEVNICppdGVtOwpAQCAtMTc4LDcgKzE3OCw3IEBACiAgKgogICogRmluZCB0aGUgaXRlbSBhdCB0aGUgc3BlY2lmaWVkIGNvb3JkaW5hdGVzIChzY3JlZW4gY29vcmRzKS4KICAqLwotc3RhdGljIE1FTlVJVEVNICpNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIFBPUFVQTUVOVSAqbWVudSwgaW50IHgsIGludCB5LCBXT1JEICpwb3MgKQorc3RhdGljIE1FTlVJVEVNICpNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIFBPUFVQTUVOVSAqbWVudSwgaW50IHgsIGludCB5LCBVSU5UICpwb3MgKQogewogICAgIE1FTlVJVEVNICppdGVtOwogICAgIFdORCAqd25kUHRyOwpAQCAtMjA3LDcgKzIwNyw3IEBACiAgKiBGaW5kIHRoZSBtZW51IGl0ZW0gc2VsZWN0ZWQgYnkgYSBrZXkgcHJlc3MuCiAgKiBSZXR1cm4gaXRlbSBpZCwgLTEgaWYgbm9uZSwgLTIgaWYgd2Ugc2hvdWxkIGNsb3NlIHRoZSBtZW51LgogICovCi1zdGF0aWMgV09SRCBNRU5VX0ZpbmRJdGVtQnlLZXkoIEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwgV09SRCBrZXkgKQorc3RhdGljIFVJTlQgTUVOVV9GaW5kSXRlbUJ5S2V5KCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsIFVJTlQga2V5ICkKIHsKICAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICAgTFBNRU5VSVRFTSBscGl0ZW07CkBAIC0yOTksNyArMjk5LDcgQEAKIAogICAgIGR3U2l6ZSA9IChscGl0ZW0tPml0ZW1fdGV4dCA9PSBOVUxMKSA/IDAgOiBHZXRUZXh0RXh0ZW50KCBoZGMsIGxwaXRlbS0+aXRlbV90ZXh0LCBzdHJsZW4obHBpdGVtLT5pdGVtX3RleHQpKTsKICAgICBscGl0ZW0tPnJlY3QucmlnaHQgICs9IExPV09SRChkd1NpemUpOwotICAgIGxwaXRlbS0+cmVjdC5ib3R0b20gKz0gbWF4KCBISVdPUkQoZHdTaXplKSwgU1lTTUVUUklDU19DWU1FTlUgKTsKKyAgICBscGl0ZW0tPnJlY3QuYm90dG9tICs9IE1BWCggSElXT1JEKGR3U2l6ZSksIFNZU01FVFJJQ1NfQ1lNRU5VICk7CiAKICAgICBpZiAobWVudUJhcikgbHBpdGVtLT5yZWN0LnJpZ2h0ICs9IE1FTlVfQkFSX0lURU1TX1NQQUNFOwogICAgIGVsc2UgaWYgKChwID0gc3RyY2hyKCBscGl0ZW0tPml0ZW1fdGV4dCwgJ1x0JyApKSAhPSBOVUxMKQpAQCAtMzUxLDIzICszNTEsMjMgQEAKIAkJKGxwaXRlbS0+aXRlbV9mbGFncyAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKSkgYnJlYWs7CiAJICAgIE1FTlVfQ2FsY0l0ZW1TaXplKCBoZGMsIGxwaXRlbSwgaHduZE93bmVyLCBvcmdYLCBvcmdZLCBGQUxTRSApOwogICAgICAgICAgICAgaWYgKGxwaXRlbS0+aXRlbV9mbGFncyAmIE1GX01FTlVCQVJCUkVBSykgb3JnWCsrOwotCSAgICBtYXhYID0gbWF4KCBtYXhYLCBscGl0ZW0tPnJlY3QucmlnaHQgKTsKKwkgICAgbWF4WCA9IE1BWCggbWF4WCwgbHBpdGVtLT5yZWN0LnJpZ2h0ICk7CiAJICAgIG9yZ1kgPSBscGl0ZW0tPnJlY3QuYm90dG9tOwogCSAgICBpZiAobHBpdGVtLT54VGFiKQogCSAgICB7Ci0JCW1heFRhYiA9IG1heCggbWF4VGFiLCBscGl0ZW0tPnhUYWIgKTsKLQkJbWF4VGFiV2lkdGggPSBtYXgobWF4VGFiV2lkdGgsbHBpdGVtLT5yZWN0LnJpZ2h0LWxwaXRlbS0+eFRhYik7CisJCW1heFRhYiA9IE1BWCggbWF4VGFiLCBscGl0ZW0tPnhUYWIgKTsKKwkJbWF4VGFiV2lkdGggPSBNQVgobWF4VGFiV2lkdGgsbHBpdGVtLT5yZWN0LnJpZ2h0LWxwaXRlbS0+eFRhYik7CiAJICAgIH0KIAl9CiAKIAkgIC8qIEZpbmlzaCB0aGUgY29sdW1uIChzZXQgYWxsIGl0ZW1zIHRvIHRoZSBsYXJnZXN0IHdpZHRoIGZvdW5kKSAqLwotCW1heFggPSBtYXgoIG1heFgsIG1heFRhYiArIG1heFRhYldpZHRoICk7CisJbWF4WCA9IE1BWCggbWF4WCwgbWF4VGFiICsgbWF4VGFiV2lkdGggKTsKIAlmb3IgKGxwaXRlbSA9ICZpdGVtc1tzdGFydF07IHN0YXJ0IDwgaTsgc3RhcnQrKywgbHBpdGVtKyspCiAJewogCSAgICBscGl0ZW0tPnJlY3QucmlnaHQgPSBtYXhYOwogCSAgICBpZiAobHBpdGVtLT54VGFiKSBscGl0ZW0tPnhUYWIgPSBtYXhUYWI7CiAJfQotCWxwcG9wLT5IZWlnaHQgPSBtYXgoIGxwcG9wLT5IZWlnaHQsIG9yZ1kgKTsKKwlscHBvcC0+SGVpZ2h0ID0gTUFYKCBscHBvcC0+SGVpZ2h0LCBvcmdZICk7CiAgICAgfQogCiAgICAgbHBwb3AtPldpZHRoICA9IG1heFg7CkBAIC0zODgsOCArMzg4LDggQEAKIAogICAgIGlmICgobHByZWN0ID09IE5VTEwpIHx8IChscHBvcCA9PSBOVUxMKSkgcmV0dXJuOwogICAgIGlmIChscHBvcC0+bkl0ZW1zID09IDApIHJldHVybjsKLQlkcHJpbnRmX21lbnVjYWxjKHN0ZGRlYiwiTWVudUJhckNhbGNTaXplIGxlZnQ9JWQgdG9wPSVkIHJpZ2h0PSVkIGJvdHRvbT0lZCAhXG4iLCAKLQkJbHByZWN0LT5sZWZ0LCBscHJlY3QtPnRvcCwgbHByZWN0LT5yaWdodCwgbHByZWN0LT5ib3R0b20pOworCWRwcmludGZfbWVudWNhbGMoc3RkZGViLCJNZW51QmFyQ2FsY1NpemUgbGVmdD0lbGQgdG9wPSVsZCByaWdodD0lbGQgYm90dG9tPSVsZCAhXG4iLCAKKwkJKExPTkcpbHByZWN0LT5sZWZ0LCAoTE9ORylscHJlY3QtPnRvcCwgKExPTkcpbHByZWN0LT5yaWdodCwgKExPTkcpbHByZWN0LT5ib3R0b20pOwogICAgIGl0ZW1zID0gKE1FTlVJVEVNICopVVNFUl9IRUFQX0xJTl9BRERSKCBscHBvcC0+aEl0ZW1zICk7CiAgICAgbHBwb3AtPldpZHRoICA9IGxwcmVjdC0+cmlnaHQgLSBscHJlY3QtPmxlZnQ7CiAgICAgbHBwb3AtPkhlaWdodCA9IDA7CkBAIC00MTQsNyArNDE0LDcgQEAKIAkJaWYgKGkgIT0gc3RhcnQpIGJyZWFrOwogCQllbHNlIGxwaXRlbS0+cmVjdC5yaWdodCA9IGxwcmVjdC0+cmlnaHQ7CiAJICAgIH0KLQkgICAgbWF4WSA9IG1heCggbWF4WSwgbHBpdGVtLT5yZWN0LmJvdHRvbSApOworCSAgICBtYXhZID0gTUFYKCBtYXhZLCBscGl0ZW0tPnJlY3QuYm90dG9tICk7CiAJICAgIG9yZ1ggPSBscGl0ZW0tPnJlY3QucmlnaHQ7CiAJfQogCkBAIC00NTAsNyArNDUwLDcgQEAKICAqIERyYXcgYSBzaW5nbGUgbWVudSBpdGVtLgogICovCiBzdGF0aWMgdm9pZCBNRU5VX0RyYXdNZW51SXRlbSggSFdORCBod25kLCBIREMgaGRjLCBMUE1FTlVJVEVNIGxwaXRlbSwKLQkJCSAgICAgICBXT1JEIGhlaWdodCwgQk9PTCBtZW51QmFyICkKKwkJCSAgICAgICBVSU5UIGhlaWdodCwgQk9PTCBtZW51QmFyICkKIHsKICAgICBSRUNUIHJlY3Q7CiAKQEAgLTYyNiw3ICs2MjYsNyBAQAogICoKICAqIFBhaW50IGEgbWVudSBiYXIuIFJldHVybnMgdGhlIGhlaWdodCBvZiB0aGUgbWVudSBiYXIuCiAgKi8KLVdPUkQgTUVOVV9EcmF3TWVudUJhcihIREMgaERDLCBMUFJFQ1QgbHByZWN0LCBIV05EIGh3bmQsIEJPT0wgc3VwcHJlc3NfZHJhdykKK1VJTlQgTUVOVV9EcmF3TWVudUJhcihIREMgaERDLCBMUFJFQ1QgbHByZWN0LCBIV05EIGh3bmQsIEJPT0wgc3VwcHJlc3NfZHJhdykKIHsKICAgICBMUFBPUFVQTUVOVSBscHBvcDsKICAgICBMUE1FTlVJVEVNIGxwaXRlbTsKQEAgLTY2MSw3ICs2NjEsNyBAQAogICoKICAqIERpc3BsYXkgYSBwb3B1cCBtZW51LgogICovCi1zdGF0aWMgQk9PTCBNRU5VX1Nob3dQb3B1cChIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsIFdPUkQgaWQsIGludCB4LCBpbnQgeSkKK3N0YXRpYyBCT09MIE1FTlVfU2hvd1BvcHVwKEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwgVUlOVCBpZCwgaW50IHgsIGludCB5KQogewogICAgIFBPUFVQTUVOVSAqbWVudTsKIApAQCAtNzAzLDcgKzcwMyw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICBNRU5VX1NlbGVjdEl0ZW0KICAqLwotc3RhdGljIHZvaWQgTUVOVV9TZWxlY3RJdGVtKCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsIFdPUkQgd0luZGV4ICkKK3N0YXRpYyB2b2lkIE1FTlVfU2VsZWN0SXRlbSggSFdORCBod25kT3duZXIsIEhNRU5VIGhtZW51LCBVSU5UIHdJbmRleCApCiB7CiAgICAgTUVOVUlURU0gKml0ZW1zOwogICAgIExQUE9QVVBNRU5VIGxwcG9wOwpAQCAtNzQxLDggKzc0MSw5IEBACiAgICAgICAgIHsKIAkgICAgTkNfRHJhd1N5c0J1dHRvbiggbHBwb3AtPmhXbmQsIGhkYywgVFJVRSApOwogI2lmZGVmIFdJTkVMSUIzMgorLyogRklYOiBMb3N0SW5mbyAqLwogICAgICAgICAgICAgU2VuZE1lc3NhZ2UoIGh3bmRPd25lciwgV01fTUVOVVNFTEVDVCwKLSAgICAgICAgICAgICAgICAgICAgICAgICBNQUtFV1BBUkFNKCBHZXRTeXN0ZW1NZW51KCBscHBvcC0+aFduZCwgRkFMU0UgKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICBNQUtFV1BBUkFNKCAoRFdPUkQpR2V0U3lzdGVtTWVudSggbHBwb3AtPmhXbmQsIEZBTFNFICksCiAJCQkJICAgICBscHBvcC0+d0ZsYWdzIHwgTUZfTU9VU0VTRUxFQ1QgKSwKIAkJCSAoTFBBUkFNKWhtZW51ICk7CiAjZWxzZQpAQCAtNzcwLDggKzc3MSw5IEBACiAJfQogICAgIH0KICNpZmRlZiBXSU5FTElCMzIKKy8qIEZJWDogTG9zdCBJbmZvICovCiAgICAgZWxzZSBTZW5kTWVzc2FnZSggaHduZE93bmVyLCBXTV9NRU5VU0VMRUNULCAKLQkJICAgICAgTUFLRVdQQVJBTSggaG1lbnUsIGxwcG9wLT53RmxhZ3MgfCBNRl9NT1VTRVNFTEVDVCksCisJCSAgICAgIE1BS0VXUEFSQU0oIChEV09SRClobWVudSwgbHBwb3AtPndGbGFncyB8IE1GX01PVVNFU0VMRUNUKSwKIAkJICAgICAgKExQQVJBTSlobWVudSApOwogI2Vsc2UKICAgICBlbHNlIFNlbmRNZXNzYWdlKCBod25kT3duZXIsIFdNX01FTlVTRUxFQ1QsIGhtZW51LApAQCAtMTA0NCw3ICsxMDQ2LDcgQEAKIHsKICAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICAgTUVOVUlURU0gKml0ZW07Ci0gICAgV09SRCBpZDsKKyAgICBVSU5UIGlkOwogCiAgICAgaWYgKCFobWVudSkgcmV0dXJuIEZBTFNFOyAgLyogT3V0c2lkZSBhbGwgbWVudXMgKi8KICAgICBtZW51ID0gKFBPUFVQTUVOVSAqKSBVU0VSX0hFQVBfTElOX0FERFIoIGhtZW51ICk7CkBAIC0xMDk1LDcgKzEwOTcsNyBAQAogICAgIFBPUFVQTUVOVSAqbWVudTsKICAgICBNRU5VSVRFTSAqaXRlbTsKICAgICBITUVOVSBoc3VibWVudSA9IDA7Ci0gICAgV09SRCBpZDsKKyAgICBVSU5UIGlkOwogCiAgICAgaWYgKCFobWVudSkgcmV0dXJuIEZBTFNFOyAgLyogT3V0c2lkZSBhbGwgbWVudXMgKi8KICAgICBtZW51ID0gKFBPUFVQTUVOVSAqKSBVU0VSX0hFQVBfTElOX0FERFIoIGhtZW51ICk7CkBAIC0xMTM2LDcgKzExMzgsNyBAQAogewogICAgIE1FTlVJVEVNICppdGVtOwogICAgIFBPUFVQTUVOVSAqbWVudSA9IChQT1BVUE1FTlUgKikgVVNFUl9IRUFQX0xJTl9BRERSKCBobWVudSApOwotICAgIFdPUkQgaWQgPSBOT19TRUxFQ1RFRF9JVEVNOworICAgIFVJTlQgaWQgPSBOT19TRUxFQ1RFRF9JVEVNOwogCiAgICAgaWYgKGhtZW51KQogICAgIHsKQEAgLTEyNTMsNyArMTI1NSw3IEBACiAgKiBJZiAneCcgYW5kICd5JyBhcmUgbm90IDAsIHdlIHNpbXVsYXRlIGEgYnV0dG9uLWRvd24gZXZlbnQgYXQgKHgseSkKICAqIGJlZm9yZSBiZWdpbm5pbmcgdHJhY2tpbmcuIFRoaXMgaXMgdG8gaGVscCBtZW51LWJhciB0cmFja2luZy4KICAqLwotc3RhdGljIEJPT0wgTUVOVV9UcmFja01lbnUoIEhNRU5VIGhtZW51LCBXT1JEIHdGbGFncywgaW50IHgsIGludCB5LAorc3RhdGljIEJPT0wgTUVOVV9UcmFja01lbnUoIEhNRU5VIGhtZW51LCBVSU5UIHdGbGFncywgaW50IHgsIGludCB5LAogCQkJICAgIEhXTkQgaHduZCwgTFBSRUNUIGxwcmVjdCApCiB7CiAgICAgTVNHICptc2c7CkBAIC0xMjYxLDcgKzEyNjMsNyBAQAogICAgIFBPUFVQTUVOVSAqbWVudTsKICAgICBITUVOVSBobWVudUN1cnJlbnQgPSBobWVudTsKICAgICBCT09MIGZDbG9zZWQgPSBGQUxTRSwgZlJlbW92ZTsKLSAgICBXT1JEIHBvczsKKyAgICBVSU5UIHBvczsKIAogICAgIGZFbmRNZW51Q2FsbGVkID0gRkFMU0U7CiAgICAgaWYgKCEobWVudSA9IChQT1BVUE1FTlUgKikgVVNFUl9IRUFQX0xJTl9BRERSKCBobWVudSApKSkgcmV0dXJuIEZBTFNFOwpAQCAtMTI3NSw3ICsxMjc3LDcgQEAKICAgICBtc2cgPSAoTVNHICopVVNFUl9IRUFQX0xJTl9BRERSKCBoTXNnICk7CiAgICAgd2hpbGUgKCFmQ2xvc2VkKQogICAgIHsKLQlpZiAoIU1TR19JbnRlcm5hbEdldE1lc3NhZ2UoIFVTRVJfSEVBUF9TRUdfQUREUihoTXNnKSwgMCwKKwlpZiAoIU1TR19JbnRlcm5hbEdldE1lc3NhZ2UoIChTRUdQVFIpVVNFUl9IRUFQX1NFR19BRERSKGhNc2cpLCAwLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGh3bmQsIE1TR0ZfTUVOVSwgMCwgVFJVRSApKQogCSAgICBicmVhazsKIApAQCAtMTM5MCw4ICsxMzkyLDggQEAKIAkJICAgICAgLyogV2Ugd2lsbCBmaW5kIGEgYmV0dGVyIHdheSByZWFsIHNvb24uLi4gKi8KIAkJICAgIGlmICgobXNnLT53UGFyYW0gPD0gMzIpIHx8IChtc2ctPndQYXJhbSA+PSAxMjcpKSBicmVhazsKIAkJICAgIHBvcyA9IE1FTlVfRmluZEl0ZW1CeUtleSggaHduZCwgaG1lbnVDdXJyZW50LCBtc2ctPndQYXJhbSApOwotCQkgICAgaWYgKHBvcyA9PSAoV09SRCktMikgZkNsb3NlZCA9IFRSVUU7Ci0JCSAgICBlbHNlIGlmIChwb3MgPT0gKFdPUkQpLTEpIE1lc3NhZ2VCZWVwKDApOworCQkgICAgaWYgKHBvcyA9PSAoVUlOVCktMikgZkNsb3NlZCA9IFRSVUU7CisJCSAgICBlbHNlIGlmIChwb3MgPT0gKFVJTlQpLTEpIE1lc3NhZ2VCZWVwKDApOwogCQkgICAgZWxzZQogCQkgICAgewogCQkJTUVOVV9TZWxlY3RJdGVtKCBod25kLCBobWVudUN1cnJlbnQsIHBvcyApOwpAQCAtMTQ0NSw3ICsxNDQ3LDcgQEAKICAqCiAgKiBNZW51LWJhciB0cmFja2luZyB1cG9uIGEga2V5Ym9hcmQgZXZlbnQuIENhbGxlZCBmcm9tIE5DX0hhbmRsZVN5c0NvbW1hbmQoKS4KICAqLwotdm9pZCBNRU5VX1RyYWNrS2JkTWVudUJhciggSFdORCBod25kLCBXT1JEIHdQYXJhbSApCit2b2lkIE1FTlVfVHJhY2tLYmRNZW51QmFyKCBIV05EIGh3bmQsIFVJTlQgd1BhcmFtICkKIHsKICAgICBXTkQgKnduZFB0ciA9IFdJTl9GaW5kV25kUHRyKCBod25kICk7CiAgICAgaWYgKCF3bmRQdHItPndJRG1lbnUpIHJldHVybjsKQEAgLTE0NjMsNyArMTQ2NSw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIFRyYWNrUG9wdXBNZW51ICAgKFVTRVIuNDE2KQogICovCi1CT09MIFRyYWNrUG9wdXBNZW51KCBITUVOVSBoTWVudSwgV09SRCB3RmxhZ3MsIHNob3J0IHgsIHNob3J0IHksCitCT09MIFRyYWNrUG9wdXBNZW51KCBITUVOVSBoTWVudSwgVUlOVCB3RmxhZ3MsIHNob3J0IHgsIHNob3J0IHksCiAJCSAgICAgc2hvcnQgblJlc2VydmVkLCBIV05EIGhXbmQsIExQUkVDVCBscFJlY3QgKQogewogICAgIGlmICghTUVOVV9TaG93UG9wdXAoIGhXbmQsIGhNZW51LCAwLCB4LCB5ICkpIHJldHVybiBGQUxTRTsKQEAgLTE0ODMsNyArMTQ4NSw3IEBACiAJICAgIENSRUFURVNUUlVDVCAqY3JlYXRlU3RydWN0ID0gKENSRUFURVNUUlVDVCopUFRSX1NFR19UT19MSU4obFBhcmFtKTsKICNpZmRlZiBXSU5FTElCMzIKIAkgICAgSE1FTlUgaG1lbnUgPSAoSE1FTlUpIChjcmVhdGVTdHJ1Y3QtPmxwQ3JlYXRlUGFyYW1zKTsKLQkgICAgU2V0V2luZG93TG9uZyggaHduZCwgMCwgaG1lbnUgKTsKKwkgICAgU2V0V2luZG93TG9uZyggaHduZCwgMCwgKExPTkcpaG1lbnUgKTsKICNlbHNlCiAJICAgIEhNRU5VIGhtZW51ID0gKEhNRU5VKSAoKGludCljcmVhdGVTdHJ1Y3QtPmxwQ3JlYXRlUGFyYW1zICYgMHhmZmZmKTsKIAkgICAgU2V0V2luZG93V29yZCggaHduZCwgMCwgaG1lbnUgKTsKQEAgLTE1MjEsNyArMTUyMyw3IEBACiAgKgogICogQ29tcHV0ZSB0aGUgc2l6ZSBvZiB0aGUgbWVudSBiYXIgaGVpZ2h0LiBVc2VkIGJ5IE5DX0hhbmRsZU5DQ2FsY1NpemUoKS4KICAqLwotV09SRCBNRU5VX0dldE1lbnVCYXJIZWlnaHQoIEhXTkQgaHduZCwgV09SRCBtZW51YmFyV2lkdGgsIGludCBvcmdYLCBpbnQgb3JnWSApCitVSU5UIE1FTlVfR2V0TWVudUJhckhlaWdodCggSFdORCBod25kLCBVSU5UIG1lbnViYXJXaWR0aCwgaW50IG9yZ1gsIGludCBvcmdZICkKIHsKICAgICBIREMgaGRjOwogICAgIFJFQ1QgcmVjdEJhcjsKQEAgLTE1MjksNyArMTUzMSw4IEBACiAgICAgTFBQT1BVUE1FTlUgbHBwb3A7CiAKICAgICBpZiAoISh3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApKSkgcmV0dXJuIDA7Ci0gICAgaWYgKCEobHBwb3AgPSAoTFBQT1BVUE1FTlUpVVNFUl9IRUFQX0xJTl9BRERSKHduZFB0ci0+d0lEbWVudSkpKSByZXR1cm4gMDsKKyAgICBpZiAoIShscHBvcCA9IChMUFBPUFVQTUVOVSlVU0VSX0hFQVBfTElOX0FERFIoKEhNRU5VKXduZFB0ci0+d0lEbWVudSkpKQorICAgICAgcmV0dXJuIDA7CiAgICAgaGRjID0gR2V0REMoIGh3bmQgKTsKICAgICBTZXRSZWN0KCAmcmVjdEJhciwgb3JnWCwgb3JnWSwgb3JnWCttZW51YmFyV2lkdGgsIG9yZ1krU1lTTUVUUklDU19DWU1FTlUgKTsKICAgICBNRU5VX01lbnVCYXJDYWxjU2l6ZSggaGRjLCAmcmVjdEJhciwgbHBwb3AsIGh3bmQgKTsKQEAgLTE1NDEsOCArMTU0NCw4IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoJCQlDaGFuZ2VNZW51CQlbVVNFUi4xNTNdCiAgKi8KLUJPT0wgQ2hhbmdlTWVudShITUVOVSBoTWVudSwgV09SRCBuUG9zLCBMUFNUUiBscE5ld0l0ZW0sIAotCQkJV09SRCB3SXRlbUlELCBXT1JEIHdGbGFncykKK0JPT0wgQ2hhbmdlTWVudShITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBMUFNUUiBscE5ld0l0ZW0sIAorCQkJVUlOVCB3SXRlbUlELCBVSU5UIHdGbGFncykKIHsKICAgZHByaW50Zl9tZW51KHN0ZGRlYiwiQ2hhbmdlTWVudTogbWVudT0iTlBGTVQiIHBvcz0lZCBwdHI9JXAgaXRlbT0lMDR4IGZsYWdzPSUwNHhcbiIsCiAJICAgICAgIGhNZW51LCBuUG9zLCBscE5ld0l0ZW0sIHdJdGVtSUQsIHdGbGFncyk7CkBAIC0xNTY4LDcgKzE1NzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCQkJQ2hlY2tNZW51SXRlbQkJW1VTRVIuMTU0XQogICovCi1CT09MIENoZWNrTWVudUl0ZW0oSE1FTlUgaE1lbnUsIFdPUkQgd0l0ZW1JRCwgV09SRCB3RmxhZ3MpCitCT09MIENoZWNrTWVudUl0ZW0oSE1FTlUgaE1lbnUsIFVJTlQgd0l0ZW1JRCwgVUlOVCB3RmxhZ3MpCiB7CiAJTFBNRU5VSVRFTSAJbHBpdGVtOwogCWRwcmludGZfbWVudShzdGRkZWIsIkNoZWNrTWVudUl0ZW0gKCJOUEZNVCIsICUwNFgsICUwNFgpICFcbiIsIApAQCAtMTU4Myw3ICsxNTg2LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCUVuYWJsZU1lbnVJdGVtCQlbVVNFUi4xNTVdCiAgKi8KLUJPT0wgRW5hYmxlTWVudUl0ZW0oSE1FTlUgaE1lbnUsIFdPUkQgd0l0ZW1JRCwgV09SRCB3RmxhZ3MpCitCT09MIEVuYWJsZU1lbnVJdGVtKEhNRU5VIGhNZW51LCBVSU5UIHdJdGVtSUQsIFVJTlQgd0ZsYWdzKQogewogICAgIExQTUVOVUlURU0gCWxwaXRlbTsKICAgICBkcHJpbnRmX21lbnUoc3RkZGViLCJFbmFibGVNZW51SXRlbSAoIk5QRk1UIiwgJTA0WCwgJTA0WCkgIVxuIiwgCkBAIC0xNjEwLDggKzE2MTMsOCBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgR2V0TWVudVN0cmluZyAgICAoVVNFUi4xNjEpCiAgKi8KLWludCBHZXRNZW51U3RyaW5nKCBITUVOVSBoTWVudSwgV09SRCB3SXRlbUlELAotICAgICAgICAgICAgICAgICAgIExQU1RSIHN0ciwgc2hvcnQgbk1heFNpeiwgV09SRCB3RmxhZ3MgKQoraW50IEdldE1lbnVTdHJpbmcoIEhNRU5VIGhNZW51LCBVSU5UIHdJdGVtSUQsCisgICAgICAgICAgICAgICAgICAgTFBTVFIgc3RyLCBzaG9ydCBuTWF4U2l6LCBVSU5UIHdGbGFncyApCiB7CiAgICAgTFBNRU5VSVRFTSBscGl0ZW07CiAKQEAgLTE2MjEsNyArMTYyNCw3IEBACiAgICAgc3RyWzBdID0gJ1wwJzsKICAgICBpZiAoIShscGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZ3SXRlbUlELCB3RmxhZ3MgKSkpIHJldHVybiAwOwogICAgIGlmICghbHBpdGVtLT5pdGVtX3RleHQgfHwgIUlTX1NUUklOR19JVEVNKGxwaXRlbS0+aXRlbV9mbGFncykpIHJldHVybiAwOwotICAgIG5NYXhTaXogPSBtaW4oIG5NYXhTaXotMSwgc3RybGVuKGxwaXRlbS0+aXRlbV90ZXh0KSApOworICAgIG5NYXhTaXogPSBNSU4oIG5NYXhTaXotMSwgc3RybGVuKGxwaXRlbS0+aXRlbV90ZXh0KSApOwogICAgIHN0cm5jcHkoIHN0ciwgbHBpdGVtLT5pdGVtX3RleHQsIG5NYXhTaXogKTsKICAgICBzdHJbbk1heFNpel0gPSAnXDAnOwogICAgIGRwcmludGZfbWVudSggc3RkZGViLCAiR2V0TWVudVN0cmluZzogcmV0dXJuaW5nICclcydcbiIsIHN0ciApOwpAQCAtMTYzMiw3ICsxNjM1LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCUhpbGl0ZU1lbnVJdGVtCQlbVVNFUi4xNjJdCiAgKi8KLUJPT0wgSGlsaXRlTWVudUl0ZW0oSFdORCBoV25kLCBITUVOVSBoTWVudSwgV09SRCB3SXRlbUlELCBXT1JEIHdIaWxpdGUpCitCT09MIEhpbGl0ZU1lbnVJdGVtKEhXTkQgaFduZCwgSE1FTlUgaE1lbnUsIFVJTlQgd0l0ZW1JRCwgVUlOVCB3SGlsaXRlKQogewogICAgIExQUE9QVVBNRU5VIG1lbnU7CiAgICAgTFBNRU5VSVRFTSAgbHBpdGVtOwpAQCAtMTY1MCw3ICsxNjUzLDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCUdldE1lbnVTdGF0ZQkJW1VTRVIuMjUwXQogICovCi1XT1JEIEdldE1lbnVTdGF0ZShITUVOVSBoTWVudSwgV09SRCB3SXRlbUlELCBXT1JEIHdGbGFncykKK1VJTlQgR2V0TWVudVN0YXRlKEhNRU5VIGhNZW51LCBVSU5UIHdJdGVtSUQsIFVJTlQgd0ZsYWdzKQogewogICAgIExQTUVOVUlURU0gbHBpdGVtOwogICAgIGRwcmludGZfbWVudShzdGRkZWIsIkdldE1lbnVTdGF0ZSgiTlBGTVQiLCAlMDRYLCAlMDRYKTtcbiIsIApAQCAtMTY1OCw3ICsxNjYxLDcgQEAKICAgICBpZiAoIShscGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZ3SXRlbUlELCB3RmxhZ3MgKSkpIHJldHVybiAtMTsKICAgICBpZiAobHBpdGVtLT5pdGVtX2ZsYWdzICYgTUZfUE9QVVApCiAgICAgewotCVBPUFVQTUVOVSAqbWVudSA9IChQT1BVUE1FTlUgKikgVVNFUl9IRUFQX0xJTl9BRERSKCBscGl0ZW0tPml0ZW1faWQgKTsKKwlQT1BVUE1FTlUgKm1lbnUgPSAoUE9QVVBNRU5VICopIFVTRVJfSEVBUF9MSU5fQUREUiggKEhNRU5VKWxwaXRlbS0+aXRlbV9pZCApOwogCWlmICghbWVudSkgcmV0dXJuIC0xOwogCWVsc2UgcmV0dXJuIChtZW51LT5uSXRlbXMgPDwgOCkgfCAobWVudS0+d0ZsYWdzICYgMHhmZik7CiAgICAgfQpAQCAtMTY3NCw3ICsxNjc3LDcgQEAKIAlMUFBPUFVQTUVOVQltZW51OwogCWRwcmludGZfbWVudShzdGRkZWIsIkdldE1lbnVJdGVtQ291bnQoIk5QRk1UIik7XG4iLCBoTWVudSk7CiAJbWVudSA9IChMUFBPUFVQTUVOVSkgVVNFUl9IRUFQX0xJTl9BRERSKGhNZW51KTsKLQlpZiAobWVudSA9PSBOVUxMKSByZXR1cm4gKFdPUkQpLTE7CisJaWYgKG1lbnUgPT0gTlVMTCkgcmV0dXJuIChVSU5UKS0xOwogCWRwcmludGZfbWVudShzdGRkZWIsIkdldE1lbnVJdGVtQ291bnQoIk5QRk1UIikgcmV0dXJuICVkIFxuIiwgCiAJCSAgICAgaE1lbnUsIG1lbnUtPm5JdGVtcyk7CiAJcmV0dXJuIG1lbnUtPm5JdGVtczsKQEAgLTE2ODQsNyArMTY4Nyw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoJCQlHZXRNZW51SXRlbUlECQkJW1VTRVIuMjY0XQogICovCi1XT1JEIEdldE1lbnVJdGVtSUQoSE1FTlUgaE1lbnUsIGludCBuUG9zKQorVUlOVCBHZXRNZW51SXRlbUlEKEhNRU5VIGhNZW51LCBpbnQgblBvcykKIHsKICAgICBMUFBPUFVQTUVOVQltZW51OwogICAgIE1FTlVJVEVNICppdGVtOwpAQCAtMTcwMSw3ICsxNzA0LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCUluc2VydE1lbnUJCVtVU0VSLjQxMF0KICAqLwotQk9PTCBJbnNlcnRNZW51KEhNRU5VIGhNZW51LCBXT1JEIG5Qb3MsIFdPUkQgd0ZsYWdzLCBXT1JEIHdJdGVtSUQsIExQU1RSIGxwTmV3SXRlbSkKK0JPT0wgSW5zZXJ0TWVudShITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncywgVUlOVCB3SXRlbUlELCBMUFNUUiBscE5ld0l0ZW0pCiB7CiAgICAgSEFORExFIGhOZXdJdGVtczsKICAgICBNRU5VSVRFTSAqbHBpdGVtLCAqbmV3SXRlbXM7CkBAIC0xNzIxLDcgKzE3MjQsNyBAQAogICAgICAgLyogRmluZCB3aGVyZSB0byBpbnNlcnQgbmV3IGl0ZW0gKi8KIAogICAgIGlmICgod0ZsYWdzICYgTUZfQllQT1NJVElPTikgJiYgCi0gICAgICAgICgoblBvcyA9PSAoV09SRCktMSkgfHwgKG5Qb3MgPT0gR2V0TWVudUl0ZW1Db3VudChoTWVudSkpKSkKKyAgICAgICAgKChuUG9zID09IChVSU5UKS0xKSB8fCAoblBvcyA9PSBHZXRNZW51SXRlbUNvdW50KGhNZW51KSkpKQogICAgIHsKICAgICAgICAgICAvKiBTcGVjaWFsIGNhc2U6IGFwcGVuZCB0byBtZW51IAogICAgICAgICAgICAgIFNvbWUgcHJvZ3JhbXMgc3BlY2lmeSB0aGUgbWVudSBsZW5ndGggdG8gZG8gdGhhdCAqLwpAQCAtMTc4NiwxMSArMTc4OSwxNSBAQAogCWxwaXRlbS0+aXRlbV90ZXh0ID0gKGNoYXIgKilVU0VSX0hFQVBfTElOX0FERFIoIGxwaXRlbS0+aFRleHQgKTsKIAlzdHJjcHkoIGxwaXRlbS0+aXRlbV90ZXh0LCBscE5ld0l0ZW0gKTsKICAgICB9CisjaWZkZWYgV0lORUxJQjMyCisgICAgZWxzZSBpZiAod0ZsYWdzICYgTUZfQklUTUFQKSBscGl0ZW0tPmhUZXh0ID0gKEhBTkRMRSlscE5ld0l0ZW07CisjZWxzZQogICAgIGVsc2UgaWYgKHdGbGFncyAmIE1GX0JJVE1BUCkgbHBpdGVtLT5oVGV4dCA9IExPV09SRCgoRFdPUkQpbHBOZXdJdGVtKTsKKyNlbmRpZgogICAgIGVsc2UgbHBpdGVtLT5pdGVtX3RleHQgPSBscE5ld0l0ZW07CiAKICAgICBpZiAod0ZsYWdzICYgTUZfUE9QVVApICAvKiBTZXQgdGhlIE1GX1BPUFVQIGZsYWcgb24gdGhlIHBvcHVwLW1lbnUgKi8KLQkoKFBPUFVQTUVOVSAqKVVTRVJfSEVBUF9MSU5fQUREUih3SXRlbUlEKSktPndGbGFncyB8PSBNRl9QT1BVUDsKKwkoKFBPUFVQTUVOVSAqKVVTRVJfSEVBUF9MSU5fQUREUigoSE1FTlUpd0l0ZW1JRCkpLT53RmxhZ3MgfD0gTUZfUE9QVVA7CiAKICAgICBTZXRSZWN0RW1wdHkoICZscGl0ZW0tPnJlY3QgKTsKICAgICBscGl0ZW0tPmhDaGVja0JpdCAgID0gaFN0ZENoZWNrOwpAQCAtMTgwMiw3ICsxODA5LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCUFwcGVuZE1lbnUJCVtVU0VSLjQxMV0KICAqLwotQk9PTCBBcHBlbmRNZW51KEhNRU5VIGhNZW51LCBXT1JEIHdGbGFncywgV09SRCB3SXRlbUlELCBMUFNUUiBscE5ld0l0ZW0pCitCT09MIEFwcGVuZE1lbnUoSE1FTlUgaE1lbnUsIFVJTlQgd0ZsYWdzLCBVSU5UIHdJdGVtSUQsIExQU1RSIGxwTmV3SXRlbSkKIHsKICAgICByZXR1cm4gSW5zZXJ0TWVudSggaE1lbnUsIC0xLCB3RmxhZ3MgfCBNRl9CWVBPU0lUSU9OLCB3SXRlbUlELCBscE5ld0l0ZW0gKTsKIH0KQEAgLTE4MTEsNyArMTgxOCw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoJCQlSZW1vdmVNZW51CQlbVVNFUi40MTJdCiAgKi8KLUJPT0wgUmVtb3ZlTWVudShITUVOVSBoTWVudSwgV09SRCBuUG9zLCBXT1JEIHdGbGFncykKK0JPT0wgUmVtb3ZlTWVudShITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncykKIHsKICAgICBMUFBPUFVQTUVOVQltZW51OwogICAgIExQTUVOVUlURU0gCWxwaXRlbTsKQEAgLTE4NDYsNyArMTg1Myw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoJCQlEZWxldGVNZW51CQlbVVNFUi40MTNdCiAgKi8KLUJPT0wgRGVsZXRlTWVudShITUVOVSBoTWVudSwgV09SRCBuUG9zLCBXT1JEIHdGbGFncykKK0JPT0wgRGVsZXRlTWVudShITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncykKIHsKICAgICBNRU5VSVRFTSAqaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJm5Qb3MsIHdGbGFncyApOwogICAgIGlmICghaXRlbSkgcmV0dXJuIEZBTFNFOwpAQCAtMTg2MCw3ICsxODY3LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCU1vZGlmeU1lbnUJCVtVU0VSLjQxNF0KICAqLwotQk9PTCBNb2RpZnlNZW51KEhNRU5VIGhNZW51LCBXT1JEIG5Qb3MsIFdPUkQgd0ZsYWdzLCBXT1JEIHdJdGVtSUQsIExQU1RSIGxwTmV3SXRlbSkKK0JPT0wgTW9kaWZ5TWVudShITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncywgVUlOVCB3SXRlbUlELCBMUFNUUiBscE5ld0l0ZW0pCiB7CiAgICAgTFBNRU5VSVRFTSAJbHBpdGVtOwogICAgIGlmIChJU19TVFJJTkdfSVRFTSh3RmxhZ3MpKQpAQCAtMTg4NCw3ICsxODkxLDExIEBACiAJbHBpdGVtLT5pdGVtX3RleHQgPSAoY2hhciAqKVVTRVJfSEVBUF9MSU5fQUREUiggbHBpdGVtLT5oVGV4dCApOwogCXN0cmNweSggbHBpdGVtLT5pdGVtX3RleHQsIGxwTmV3SXRlbSApOwogICAgIH0KKyNpZmRlZiBXSU5FTElCMzIKKyAgICBlbHNlIGlmICh3RmxhZ3MgJiBNRl9CSVRNQVApIGxwaXRlbS0+aFRleHQgPSAoSEFORExFKWxwTmV3SXRlbTsKKyNlbHNlCiAgICAgZWxzZSBpZiAod0ZsYWdzICYgTUZfQklUTUFQKSBscGl0ZW0tPmhUZXh0ID0gTE9XT1JEKChEV09SRClscE5ld0l0ZW0pOworI2VuZGlmCiAgICAgZWxzZSBscGl0ZW0tPml0ZW1fdGV4dCA9IGxwTmV3SXRlbTsKICAgICBTZXRSZWN0RW1wdHkoICZscGl0ZW0tPnJlY3QgKTsKICAgICByZXR1cm4gVFJVRTsKQEAgLTE5MTgsNyArMTkyOSw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoJCQlTZXRNZW51SXRlbUJpdG1hcHMJW1VTRVIuNDE4XQogICovCi1CT09MIFNldE1lbnVJdGVtQml0bWFwcyhITUVOVSBoTWVudSwgV09SRCBuUG9zLCBXT1JEIHdGbGFncywKK0JPT0wgU2V0TWVudUl0ZW1CaXRtYXBzKEhNRU5VIGhNZW51LCBVSU5UIG5Qb3MsIFVJTlQgd0ZsYWdzLAogCQlIQklUTUFQIGhOZXdDaGVjaywgSEJJVE1BUCBoTmV3VW5DaGVjaykKIHsKICAgICBMUE1FTlVJVEVNIGxwaXRlbTsKQEAgLTE5OTAsNyArMjAwMSw3IEBACiAgICAgICAgIGZvciAoaSA9IGxwcG9wLT5uSXRlbXM7IGkgPiAwOyBpLS0sIGl0ZW0rKykKICAgICAgICAgewogICAgICAgICAgICAgaWYgKGl0ZW0tPml0ZW1fZmxhZ3MgJiBNRl9QT1BVUCkKLSAgICAgICAgICAgICAgICBEZXN0cm95TWVudSggaXRlbS0+aXRlbV9pZCApOworICAgICAgICAgICAgICAgIERlc3Ryb3lNZW51KCAoSE1FTlUpaXRlbS0+aXRlbV9pZCApOwogICAgICAgICB9CiAgICAgICAgIFVTRVJfSEVBUF9GUkVFKCBscHBvcC0+aEl0ZW1zICk7CiAgICAgfQpAQCAtMjAzMiw3ICsyMDQzLDcgQEAKIHsgCiAJV05EICogd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoaFduZCk7CiAJaWYgKHduZFB0ciA9PSBOVUxMKSByZXR1cm4gMDsKLQlyZXR1cm4gd25kUHRyLT53SURtZW51OworCXJldHVybiAoSE1FTlUpd25kUHRyLT53SURtZW51OwogfQogCiAKQEAgLTIwNTAsNyArMjA2MSw3IEBACiAJCX0KIAlkcHJpbnRmX21lbnUoc3RkZGViLCJTZXRNZW51KCJOUEZNVCIsICJOUEZNVCIpO1xuIiwgaFduZCwgaE1lbnUpOwogCWlmIChHZXRDYXB0dXJlKCkgPT0gaFduZCkgUmVsZWFzZUNhcHR1cmUoKTsKLQl3bmRQdHItPndJRG1lbnUgPSBoTWVudTsKKwl3bmRQdHItPndJRG1lbnUgPSAoVUlOVCloTWVudTsKIAlpZiAoaE1lbnUgIT0gMCkKIAl7CiAJICAgIGxwbWVudSA9IChMUFBPUFVQTUVOVSkgVVNFUl9IRUFQX0xJTl9BRERSKGhNZW51KTsKQEAgLTIwNzksNyArMjA5MCw3IEBACiAgICAgTFBNRU5VSVRFTSAJbHBpdGVtOwogICAgIGRwcmludGZfbWVudShzdGRkZWIsIkdldFN1Yk1lbnUgKCJOUEZNVCIsICUwNFgpICFcbiIsIGhNZW51LCBuUG9zKTsKICAgICBpZiAoIShscHBvcCA9IChMUFBPUFVQTUVOVSkgVVNFUl9IRUFQX0xJTl9BRERSKGhNZW51KSkpIHJldHVybiAwOwotICAgIGlmICgoV09SRCluUG9zID49IGxwcG9wLT5uSXRlbXMpIHJldHVybiAwOworICAgIGlmICgoVUlOVCluUG9zID49IGxwcG9wLT5uSXRlbXMpIHJldHVybiAwOwogICAgIGxwaXRlbSA9IChNRU5VSVRFTSAqKSBVU0VSX0hFQVBfTElOX0FERFIoIGxwcG9wLT5oSXRlbXMgKTsKICAgICBpZiAoIShscGl0ZW1bblBvc10uaXRlbV9mbGFncyAmIE1GX1BPUFVQKSkgcmV0dXJuIDA7CiAgICAgcmV0dXJuIGxwaXRlbVtuUG9zXS5pdGVtX2lkOwpAQCAtMjA5OSw3ICsyMTEwLDcgQEAKIAkJd25kUHRyLT53SURtZW51ICE9IDApIHsKIAkJZHByaW50Zl9tZW51KHN0ZGRlYiwiRHJhd01lbnVCYXIgd0lEbWVudT0lMDRYIFxuIiwgCiAJCQkgICAgIHduZFB0ci0+d0lEbWVudSk7Ci0JCWxwcG9wID0gKExQUE9QVVBNRU5VKSBVU0VSX0hFQVBfTElOX0FERFIod25kUHRyLT53SURtZW51KTsKKwkJbHBwb3AgPSAoTFBQT1BVUE1FTlUpIFVTRVJfSEVBUF9MSU5fQUREUigoSE1FTlUpd25kUHRyLT53SURtZW51KTsKIAkJaWYgKGxwcG9wID09IE5VTEwpIHJldHVybjsKIAogCQlscHBvcC0+SGVpZ2h0ID0gMDsgLyogTWFrZSBzdXJlIHdlIGNhbGwgTUVOVV9NZW51QmFyQ2FsY1NpemUgKi8KQEAgLTIyMTcsNyArMjIyOCw3IEBACiAJICAgIGhTdWJNZW51ID0gQ3JlYXRlUG9wdXBNZW51KCk7CiAJICAgIG5leHRfaXRlbSA9IFBhcnNlTWVudVJlc291cmNlKG5leHRfaXRlbSwgbGV2ZWwsIGhTdWJNZW51KTsKIAkgICAgQXBwZW5kTWVudShoTWVudSwgcG9wdXBfaXRlbS0+aXRlbV9mbGFncywgCi0JICAgIAloU3ViTWVudSwgcG9wdXBfaXRlbS0+aXRlbV90ZXh0KTsKKwkgICAgCShVSU5UKWhTdWJNZW51LCBwb3B1cF9pdGVtLT5pdGVtX3RleHQpOwogCSAgICB9CiAJZWxzZSB7CiAJCU1FTlVJVEVNVEVNUExBVEUgKm5vcm1hbF9pdGVtID0gKE1FTlVJVEVNVEVNUExBVEUgKikgaXRlbTsKZGlmZiAtLWdpdCBhL2NvbnRyb2xzL3Njcm9sbC5jIGIvY29udHJvbHMvc2Nyb2xsLmMKaW5kZXggNTA3Yzg5Ny4uM2Q3YTY3ZSAxMDA2NDQKLS0tIGEvY29udHJvbHMvc2Nyb2xsLmMKKysrIGIvY29udHJvbHMvc2Nyb2xsLmMKQEAgLTIwOSw3ICsyMDksNyBAQAogewogICAgIGludCBwaXhlbHMgPSB2ZXJ0aWNhbCA/IHJlY3QtPmJvdHRvbS1yZWN0LT50b3AgOiByZWN0LT5yaWdodC1yZWN0LT5sZWZ0OwogICAgIGlmICgocGl4ZWxzIC09IDMqU1lTTUVUUklDU19DWFZTQ1JPTEwrMSkgPD0gMCkgcmV0dXJuIGluZm9QdHItPk1pblZhbDsKLSAgICBwb3MgPSBtYXgoIDAsIHBvcyAtIFNZU01FVFJJQ1NfQ1hWU0NST0xMICk7CisgICAgcG9zID0gTUFYKCAwLCBwb3MgLSBTWVNNRVRSSUNTX0NYVlNDUk9MTCApOwogICAgIGlmIChwb3MgPiBwaXhlbHMpIHBvcyA9IHBpeGVsczsKICAgICBkcHJpbnRmX3Njcm9sbChzdGRkZWIsIkdldFRodW1iVmFsOiBwb3M9JWQgcmV0PSVkXG4iLCBwb3MsCiAgICAgICAgICAgICAgICAgICAgKGluZm9QdHItPk1pblZhbApAQCAtNTkyLDggKzU5Miw4IEBACiAgICAgICAgICAgcmV0dXJuOyAgLyogU2hvdWxkIG5ldmVyIGhhcHBlbiAqLwogICAgIH0KIAotICAgIGRwcmludGZfc2Nyb2xsKCBzdGRkZWIsICJTY3JvbGxCYXIgRXZlbnQ6IGh3bmQ9Ik5QRk1UIiBiYXI9JWQgbXNnPSV4IHB0PSVkLCVkIGhpdD0lZFxuIiwKLSAgICAgICAgICAgICAgICAgICAgaHduZCwgbkJhciwgbXNnLCBwdC54LCBwdC55LCBoaXR0ZXN0ICk7CisgICAgZHByaW50Zl9zY3JvbGwoIHN0ZGRlYiwgIlNjcm9sbEJhciBFdmVudDogaHduZD0iTlBGTVQiIGJhcj0lZCBtc2c9JXggcHQ9JWxkLCVsZCBoaXQ9JWRcbiIsCisgICAgICAgICAgICAgICAgICAgIGh3bmQsIG5CYXIsIG1zZywgKExPTkcpcHQueCwgKExPTkcpcHQueSwgaGl0dGVzdCApOwogCiAgICAgc3dpdGNoKHRyYWNrSGl0VGVzdCkKICAgICB7CkBAIC03NTcsNyArNzU3LDExIEBACiAgKiAgICAgICAgICAgU2Nyb2xsQmFyV25kUHJvYwogICovCiBMT05HIFNjcm9sbEJhclduZFByb2MoIEhXTkQgaHduZCwgV09SRCBtZXNzYWdlLCBXT1JEIHdQYXJhbSwgTE9ORyBsUGFyYW0gKQoteyAgICAKK3sKKyAgICBQT0lOVCBQdDsKKyAgICBQdC54ID0gTE9XT1JEKGxQYXJhbSk7IFB0LnkgPSBISVdPUkQobFBhcmFtKTsKKyAgICAvKiBeIENhbid0IHVzZSBNQUtFUE9JTlQgbWFjcm8gaW4gV0lORUxJQjMyICovCisKICAgICBzd2l0Y2gobWVzc2FnZSkKICAgICB7CiAgICAgY2FzZSBXTV9DUkVBVEU6CkBAIC04MDAsNyArODA0LDcgQEAKICAgICBjYXNlIFdNX0xCVVRUT05VUDoKICAgICBjYXNlIFdNX01PVVNFTU9WRToKICAgICBjYXNlIFdNX1NZU1RJTUVSOgotICAgICAgICBTQ1JPTExfSGFuZGxlU2Nyb2xsRXZlbnQoIGh3bmQsIFNCX0NUTCwgbWVzc2FnZSwgTUFLRVBPSU5UKGxQYXJhbSkgKTsKKyAgICAgICAgU0NST0xMX0hhbmRsZVNjcm9sbEV2ZW50KCBod25kLCBTQl9DVEwsIG1lc3NhZ2UsIFB0ICk7CiAgICAgICAgIGJyZWFrOwogCiAgICAgY2FzZSBXTV9LRVlET1dOOgpkaWZmIC0tZ2l0IGEvY29udHJvbHMvc3RhdGljLmMgYi9jb250cm9scy9zdGF0aWMuYwppbmRleCBiODhkZDJmLi5jZTgxMjUyIDEwMDY0NAotLS0gYS9jb250cm9scy9zdGF0aWMuYworKysgYi9jb250cm9scy9zdGF0aWMuYwpAQCAtNTUsNyArNTUsOCBAQAogICAgIFNUQVRJQ0lORk8gKmluZm9QdHIgPSAoU1RBVElDSU5GTyAqKXduZFB0ci0+d0V4dHJhOwogCiAgICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiAweDBmKSAhPSBTU19JQ09OKSByZXR1cm47Ci0gICAgaWYgKGluZm9QdHItPmhJY29uKSBEZXN0cm95SWNvbiggaW5mb1B0ci0+aEljb24gKTsKKy8qICBGSVhNRTogaXMgdGhpcyBPSz8KKyAgICBpZiAoaW5mb1B0ci0+aEljb24pIERlc3Ryb3lJY29uKCBpbmZvUHRyLT5oSWNvbiApOyAqLwogICAgIGluZm9QdHItPmhJY29uID0gaGljb247CiAgICAgaWYgKGhpY29uKQogICAgIHsKZGlmZiAtLWdpdCBhL2RlYnVnZ2VyL2RiZy55IGIvZGVidWdnZXIvZGJnLnkKaW5kZXggN2ViNWE1OC4uY2QzYjljZiAxMDA2NDQKLS0tIGEvZGVidWdnZXIvZGJnLnkKKysrIGIvZGVidWdnZXIvZGJnLnkKQEAgLTEsOSArMSw5IEBACi0KICV7CiAvKgogICogUGFyc2VyIGZvciBjb21tYW5kIGxpbmVzIGluIHRoZSBXaW5lIGRlYnVnZ2VyCiAgKgogICogQ29weXJpZ2h0IDE5OTMgRXJpYyBZb3VuZ2RhbGUKKyAqIENvcHlyaWdodCAxOTk1IE1vcnRlbiBXZWxpbmRlcgogICovCiAKICNpbmNsdWRlIDxzdGRpby5oPgpAQCAtMzMsNyArMzMsNyBAQAogICAgIGludCAgICAgICAgICAgICAgaW50ZWdlcjsKIH0KIAotJXRva2VuIENPTlQgU1RFUCBORVhUIFFVSVQgSEVMUCBCQUNLVFJBQ0UgSU5GTyBTVEFDSyBTRUdNRU5UUyBSRUdTCisldG9rZW4gQ09OVCBTVEVQIExJU1QgTkVYVCBRVUlUIEhFTFAgQkFDS1RSQUNFIElORk8gU1RBQ0sgU0VHTUVOVFMgUkVHUwogJXRva2VuIEVOQUJMRSBESVNBQkxFIEJSRUFLIERFTEVURSBTRVQgTU9ERSBQUklOVCBFWEFNIERFRklORSBBQk9SVAogJXRva2VuIE5PX1NZTUJPTAogJXRva2VuIFNZTUJPTEZJTEUKQEAgLTQyLDgyICs0MiwxNDQgQEAKICV0b2tlbiA8aW50ZWdlcj4gTlVNIEZPUk1BVAogJXRva2VuIDxyZWc+IFJFRwogCisvKiAlbGVmdCAnLCcgKi8KKy8qICVsZWZ0ICc9JyBPUF9PUl9FUVVBTCBPUF9YT1JfRVFVQUwgT1BfQU5EX0VRVUFMIE9QX1NITF9FUVVBTCBcCisgICAgICAgICBPUF9TSFJfRVFVQUwgT1BfUExVU19FUVVBTCBPUF9NSU5VU19FUVVBTCBcCisgICAgICAgICBPUF9USU1FU19FUVVBTCBPUF9ESVZJREVfRVFVQUwgT1BfTU9EVUxPX0VRVUFMICovCisvKiAlbGVmdCBPUF9DT05EICovIC8qIC4uLiA/IC4uLiA6IC4uLiAqLworJWxlZnQgT1BfTE9SCislbGVmdCBPUF9MQU5ECislbGVmdCAnfCcKKyVsZWZ0ICdeJworJWxlZnQgJyYnCislbGVmdCBPUF9FUSBPUF9ORQorJWxlZnQgJzwnICc+JyBPUF9MRSBPUF9HRQorJWxlZnQgT1BfU0hMIE9QX1NIUgorJWxlZnQgJysnICctJworJWxlZnQgJyonICcvJyAnJScKKyVsZWZ0IE9QX1NJR04gJyEnICd+JyBPUF9ERVJFRiAvKiBPUF9JTkMgT1BfREVDIE9QX0FERFIgKi8KKyVub25hc3NvYyAnOicKKwogJXR5cGUgPGludGVnZXI+IGV4cHIKLSV0eXBlIDxhZGRyZXNzPiBhZGRyIHN5bWJvbAorJXR5cGUgPGFkZHJlc3M+IGFkZHIgc2VnYWRkciBzeW1ib2wKIAogJSUKIAotIGlucHV0OiAgLyogZW1wdHkgKi8KLQl8IGlucHV0IGxpbmUgIHsgaXNzdWVfcHJvbXB0KCk7IH0KKyBpbnB1dDogICBsaW5lCQkJeyBpc3N1ZV9wcm9tcHQoKTsgfQorCXwgaW5wdXQgbGluZQkJeyBpc3N1ZV9wcm9tcHQoKTsgfQogCi0gbGluZToJCSdcbicKLQl8IGVycm9yICdcbicgICAgICAgeyB5eWVycm9rOyB9Ci0JfCBRVUlUICAnXG4nICAgICAgIHsgZXhpdCgwKTsgfQotCXwgSEVMUCAgJ1xuJyAgICAgICB7IERFQlVHX0hlbHAoKTsgfQotCXwgQ09OVCAnXG4nICAgICAgICB7IGRiZ19leGVjX21vZGUgPSBFWEVDX0NPTlQ7IHJldHVybiAwOyB9Ci0JfCBTVEVQICdcbicgICAgICAgIHsgZGJnX2V4ZWNfbW9kZSA9IEVYRUNfU1RFUF9JTlNUUjsgcmV0dXJuIDA7IH0KLQl8IE5FWFQgJ1xuJyAgICAgICAgeyBkYmdfZXhlY19tb2RlID0gRVhFQ19TVEVQX09WRVI7IHJldHVybiAwOyB9Ci0JfCBBQk9SVCAnXG4nICAgICAgIHsga2lsbChnZXRwaWQoKSwgU0lHQUJSVCk7IH0KLSAJfCBTWU1CT0xGSUxFIElERU5USUZJRVIgJ1xuJyAgeyBERUJVR19SZWFkU3ltYm9sVGFibGUoICQyICk7IH0KLQl8IERFRklORSBJREVOVElGSUVSIGFkZHIgJ1xuJyB7IERFQlVHX0FkZFN5bWJvbCggJDIsICYkMyApOyB9Ci0JfCBNT0RFIE5VTSAnXG4nICAgICAgICAgeyBtb2RlX2NvbW1hbmQoJDIpOyB9Ci0JfCBFTkFCTEUgTlVNICdcbicgICAgICAgeyBERUJVR19FbmFibGVCcmVha3BvaW50KCAkMiwgVFJVRSApOyB9Ci0JfCBESVNBQkxFIE5VTSAnXG4nICAgICAgeyBERUJVR19FbmFibGVCcmVha3BvaW50KCAkMiwgRkFMU0UgKTsgfQotCXwgQlJFQUsgJyonIGFkZHIgJ1xuJyAgIHsgREVCVUdfQWRkQnJlYWtwb2ludCggJiQzICk7IH0KLSAgICAgICAgfCBCUkVBSyBzeW1ib2wgJ1xuJyAgICAgeyBERUJVR19BZGRCcmVha3BvaW50KCAmJDIgKTsgfQotICAgICAgICB8IEJSRUFLICdcbicgICAgICAgICAgICB7IERCR19BRERSIGFkZHIgPSB7IENTX3JlZyhERUJVR19jb250ZXh0KSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFSVBfcmVnKERFQlVHX2NvbnRleHQpIH07Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgREVCVUdfQWRkQnJlYWtwb2ludCggJmFkZHIgKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfQotICAgICAgICB8IERFTEVURSBCUkVBSyBOVU0gJ1xuJyB7IERFQlVHX0RlbEJyZWFrcG9pbnQoICQzICk7IH0KLQl8IEJBQ0tUUkFDRSAnXG4nICAgICAgICB7IERFQlVHX0JhY2tUcmFjZSgpOyB9CisgbGluZTogIGNvbW1hbmQgJ1xuJworCXwgJ1xuJworCXwgZXJyb3IJJ1xuJwkgICAgICAgeyB5eWVycm9rOyB9CisKKyBjb21tYW5kOiBRVUlUCSAgICAgICAgICAgICAgIHsgZXhpdCgwKTsgfQorCXwgSEVMUAkgICAgICAgICAgICAgICB7IERFQlVHX0hlbHAoKTsgfQorCXwgQ09OVAkgICAgICAgICAgICAgICB7IGRiZ19leGVjX21vZGUgPSBFWEVDX0NPTlQ7IHJldHVybiAwOyB9CisJfCBTVEVQCSAgICAgICAgICAgICAgIHsgZGJnX2V4ZWNfbW9kZSA9IEVYRUNfU1RFUF9JTlNUUjsgcmV0dXJuIDA7IH0KKwl8IE5FWFQJICAgICAgICAgICAgICAgeyBkYmdfZXhlY19tb2RlID0gRVhFQ19TVEVQX09WRVI7IHJldHVybiAwOyB9CisJfCBMSVNUCQkgICAgICAgeyBERUJVR19MaXN0KCBOVUxMLCAxNSApOyB9CisJfCBMSVNUIGFkZHIJICAgICAgIHsgREVCVUdfTGlzdCggJiQyLCAxNSApOyB9CisJfCBBQk9SVAkgICAgICAgICAgICAgICB7IGtpbGwoZ2V0cGlkKCksIFNJR0FCUlQpOyB9CisJfCBTWU1CT0xGSUxFIElERU5USUZJRVIgeyBERUJVR19SZWFkU3ltYm9sVGFibGUoICQyICk7IH0KKwl8IERFRklORSBJREVOVElGSUVSIGFkZHIgeyBERUJVR19BZGRTeW1ib2woICQyLCAmJDMgKTsgfQorCXwgTU9ERSBOVU0JICAgICAgIHsgbW9kZV9jb21tYW5kKCQyKTsgfQorCXwgRU5BQkxFIE5VTQkgICAgICAgeyBERUJVR19FbmFibGVCcmVha3BvaW50KCAkMiwgVFJVRSApOyB9CisJfCBESVNBQkxFIE5VTQkgICAgICAgeyBERUJVR19FbmFibGVCcmVha3BvaW50KCAkMiwgRkFMU0UgKTsgfQorCXwgQlJFQUsgJyonIGFkZHIgICAgICAgeyBERUJVR19BZGRCcmVha3BvaW50KCAmJDMgKTsgfQorCXwgQlJFQUsgc3ltYm9sCSAgICAgICB7IERFQlVHX0FkZEJyZWFrcG9pbnQoICYkMiApOyB9CisJfCBCUkVBSwkJICAgICAgIHsgREJHX0FERFIgYWRkciA9IHsgQ1NfcmVnKERFQlVHX2NvbnRleHQpLAorCQkJCQkJICAgICBFSVBfcmVnKERFQlVHX2NvbnRleHQpIH07CisJCQkJIERFQlVHX0FkZEJyZWFrcG9pbnQoICZhZGRyICk7CisJCQkgICAgICAgfQorCXwgREVMRVRFIEJSRUFLIE5VTSAgICAgeyBERUJVR19EZWxCcmVha3BvaW50KCAkMyApOyB9CisJfCBCQUNLVFJBQ0UJICAgICAgIHsgREVCVUdfQmFja1RyYWNlKCk7IH0KIAl8IGluZm9jbWQKIAl8IHhfY29tbWFuZAogCXwgcHJpbnRfY29tbWFuZAogCXwgZGVwb3NpdF9jb21tYW5kCiAKIGRlcG9zaXRfY29tbWFuZDoKLQlTRVQgUkVHICc9JyBleHByICdcbicgICAgICAgICAgeyBERUJVR19TZXRSZWdpc3RlciggJDIsICQ0ICk7IH0KLQl8IFNFVCAnKicgYWRkciAnPScgZXhwciAnXG4nICAgeyBERUJVR19Xcml0ZU1lbW9yeSggJiQzLCAkNSApOyB9Ci0JfCBTRVQgSURFTlRJRklFUiAnPScgYWRkciAnXG4nIHsgaWYgKCFERUJVR19TZXRTeW1ib2xWYWx1ZSggJDIsICYkNCApKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZnByaW50Ziggc3RkZXJyLCAiU3ltYm9sICVzIG5vdCBmb3VuZFxuIiwgJDIgKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBZWUVSUk9SOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CisJU0VUIFJFRyAnPScgZXhwcgkgICB7IERFQlVHX1NldFJlZ2lzdGVyKCAkMiwgJDQgKTsgfQorCXwgU0VUICcqJyBhZGRyICc9JyBleHByCSAgIHsgREVCVUdfV3JpdGVNZW1vcnkoICYkMywgJDUgKTsgfQorCXwgU0VUIElERU5USUZJRVIgJz0nIGFkZHIgIHsgaWYgKCFERUJVR19TZXRTeW1ib2xWYWx1ZSggJDIsICYkNCApKQorCQkJCSAgICAgICB7CisJCQkJCSBmcHJpbnRmKCBzdGRlcnIsCisJCQkJCQkgIlN5bWJvbCAlcyBub3QgZm91bmRcbiIsICQyICk7CisJCQkJCSBZWUVSUk9SOworCQkJCSAgICAgICB9CisJCQkJICAgfQogCiAKIHhfY29tbWFuZDoKLQkgIEVYQU0gYWRkciAnXG4nIHsgREVCVUdfRXhhbWluZU1lbW9yeSggJiQyLCAxLCAneCcpOyB9Ci0JfCBFWEFNIEZPUk1BVCBhZGRyICdcbicgeyBERUJVR19FeGFtaW5lTWVtb3J5KCAmJDMsICQyPj44LCAkMiYweGZmICk7IH0KKwkgIEVYQU0gYWRkciAgeyBERUJVR19FeGFtaW5lTWVtb3J5KCAmJDIsIDEsICd4Jyk7IH0KKwl8IEVYQU0gRk9STUFUIGFkZHIgIHsgREVCVUdfRXhhbWluZU1lbW9yeSggJiQzLCAkMj4+OCwgJDImMHhmZiApOyB9CiAKICBwcmludF9jb21tYW5kOgotCSAgUFJJTlQgYWRkciAnXG4nICAgICAgICB7IERFQlVHX1ByaW50KCAmJDIsIDEsICd4JyApOyB9Ci0JfCBQUklOVCBGT1JNQVQgYWRkciAnXG4nIHsgREVCVUdfUHJpbnQoICYkMywgJDIgPj4gOCwgJDIgJiAweGZmICk7IH0KKwkgIFBSSU5UIGFkZHIJICAgICB7IERFQlVHX1ByaW50KCAmJDIsIDEsICd4JyApOyB9CisJfCBQUklOVCBGT1JNQVQgYWRkciAgeyBERUJVR19QcmludCggJiQzLCAkMiA+PiA4LCAkMiAmIDB4ZmYgKTsgfQogCiAgc3ltYm9sOiBJREVOVElGSUVSICAgeyBpZiAoIURFQlVHX0dldFN5bWJvbFZhbHVlKCAkMSwgJiQkICkpCi0gICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICBmcHJpbnRmKCBzdGRlcnIsICJTeW1ib2wgJXMgbm90IGZvdW5kXG4iLCAkMSApOwotICAgICAgICAgICAgICAgICAgICAgICAgICAgWVlFUlJPUjsKLSAgICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICAgICAgICB9IAorCQkJeworCQkJICAgZnByaW50Ziggc3RkZXJyLCAiU3ltYm9sICVzIG5vdCBmb3VuZFxuIiwgJDEgKTsKKwkJCSAgIFlZRVJST1I7CisJCQl9CisJCSAgICAgIH0gCiAKLSBhZGRyOiBleHByICAgICAgICAgICAgICAgICAgICAgeyAkJC5zZWcgPSAweGZmZmZmZmZmOyAkJC5vZmYgPSAkMTsgfQotICAgICAgIHwgZXhwciAnOicgZXhwciAgICAgICAgICB7ICQkLnNlZyA9ICQxOyAkJC5vZmYgPSAkMzsgfQotICAgICAgIHwgc3ltYm9sICAgCQl7ICQkID0gJDE7IH0KKyBhZGRyOiBleHByCQkJCXsgJCQuc2VnID0gMHhmZmZmZmZmZjsgJCQub2ZmID0gJDE7IH0KKyAgICAgICB8IHNlZ2FkZHIJCQl7ICQkID0gJDE7IH0KIAotIGV4cHI6ICBOVU0JCQl7ICQkID0gJDE7CX0KLQl8IFJFRwkJCXsgJCQgPSBERUJVR19HZXRSZWdpc3RlcigkMSk7IH0KLQl8IGV4cHIgJysnIE5VTQkJeyAkJCA9ICQxICsgJDM7IH0KLQl8IGV4cHIgJy0nIE5VTQkJeyAkJCA9ICQxIC0gJDM7IH0KLQl8ICcoJyBleHByICcpJwkJeyAkJCA9ICQyOyB9Ci0JfCAnKicgYWRkcgkJeyAkJCA9IERFQlVHX1JlYWRNZW1vcnkoICYkMiApOyB9Cisgc2VnYWRkcjogZXhwciAnOicgZXhwcgkJCXsgJCQuc2VnID0gJDE7ICQkLm9mZiA9ICQzOyB9CisgICAgICAgfCBzeW1ib2wJCQkJeyAkJCA9ICQxOyB9CisKKyBleHByOglOVU0JCQkJeyAkJCA9ICQxOwl9CisJfCBSRUcJCQkJeyAkJCA9IERFQlVHX0dldFJlZ2lzdGVyKCQxKTsgfQorCXwgZXhwciBPUF9MT1IgZXhwcgkJeyAkJCA9ICQxIHx8ICQzOyB9CisJfCBleHByIE9QX0xBTkQgZXhwcgkJeyAkJCA9ICQxICYmICQzOyB9CisJfCBleHByICd8JyBleHByCQkJeyAkJCA9ICQxIHwgJDM7IH0KKwl8IGV4cHIgJyYnIGV4cHIJCQl7ICQkID0gJDEgJiAkMzsgfQorCXwgZXhwciAnXicgZXhwcgkJCXsgJCQgPSAkMSBeICQzOyB9CisJfCBleHByIE9QX0VRIGV4cHIJCXsgJCQgPSAkMSA9PSAkMzsgfQorCXwgZXhwciAnPicgZXhwcgkJCXsgJCQgPSAkMSA+ICQzOyB9CisJfCBleHByICc8JyBleHByCQkJeyAkJCA9ICQxIDwgJDM7IH0KKwl8IGV4cHIgT1BfR0UgZXhwcgkJeyAkJCA9ICQxID49ICQzOyB9CisJfCBleHByIE9QX0xFIGV4cHIJCXsgJCQgPSAkMSA8PSAkMzsgfQorCXwgZXhwciBPUF9ORSBleHByCQl7ICQkID0gJDEgIT0gJDM7IH0KKwl8IGV4cHIgT1BfU0hMIGV4cHIJCXsgJCQgPSAodW5zaWduZWQpJDEgPDwgJDM7IH0KKwl8IGV4cHIgT1BfU0hSIGV4cHIJCXsgJCQgPSAodW5zaWduZWQpJDEgPj4gJDM7IH0KKwl8IGV4cHIgJysnIGV4cHIJCQl7ICQkID0gJDEgKyAkMzsgfQorCXwgZXhwciAnLScgZXhwcgkJCXsgJCQgPSAkMSAtICQzOyB9CisJfCBleHByICcqJyBleHByCQkJeyAkJCA9ICQxICogJDM7IH0KKwl8IGV4cHIgJy8nIGV4cHIKKwkgIHsgaWYgKCQzKSAKKwkgICAgICBpZiAoJDMgPT0gLTEgJiYgJDEgPT0gMHg4MDAwMDAwMGwpCisJCXl5ZXJyb3IgKCJEaXZpc2lvbiBvdmVyZmxvdyIpOworCSAgICAgIGVsc2UKKwkJJCQgPSAkMSAvICQzOworCSAgICBlbHNlCisJICAgICAgeXllcnJvciAoIkRpdmlzaW9uIGJ5IHplcm8iKTsgfQorCXwgZXhwciAnJScgZXhwcgorCSAgeyBpZiAoJDMpIAorCSAgICAgIGlmICgkMyA9PSAtMSAmJiAkMSA9PSAweDgwMDAwMDAwbCkKKwkJJCQgPSAwOyAvKiBBIHNlbnNpYmxlIHJlc3VsdCBpbiB0aGlzIGNhc2UuICAqLworCSAgICAgIGVsc2UKKwkJJCQgPSAkMSAlICQzOworCSAgICBlbHNlCisJICAgICAgeXllcnJvciAoIkRpdmlzaW9uIGJ5IHplcm8iKTsgfQorCXwgJy0nIGV4cHIgJXByZWMgT1BfU0lHTgl7ICQkID0gLSQyOyB9CisJfCAnKycgZXhwciAlcHJlYyBPUF9TSUdOCXsgJCQgPSAkMjsgfQorCXwgJyEnIGV4cHIJCQl7ICQkID0gISQyOyB9CisJfCAnficgZXhwcgkJCXsgJCQgPSB+JDI7IH0KKwl8ICcoJyBleHByICcpJwkJCXsgJCQgPSAkMjsgfQorLyogRm9yIHBhcnNlciB0ZWNobmljYWwgcmVhc29ucyB3ZSBjYW4ndCB1c2UgImFkZHIiIGhlcmUuICAqLworCXwgJyonIGV4cHIgJXByZWMgT1BfREVSRUYJeyBEQkdfQUREUiBhZGRyID0geyAweGZmZmZmZmZmLCAkMiB9OworCQkJCQkgICQkID0gREVCVUdfUmVhZE1lbW9yeSggJmFkZHIgKTsgfQorCXwgJyonIHNlZ2FkZHIgJXByZWMgT1BfREVSRUYJeyAkJCA9IERFQlVHX1JlYWRNZW1vcnkoICYkMiApOyB9CiAJCi0gaW5mb2NtZDogSU5GTyBSRUdTICdcbicgICAgICAgICAgeyBERUJVR19JbmZvUmVnaXN0ZXJzKCk7IH0KLQl8IElORk8gU1RBQ0sgJ1xuJyAgICAgICAgIHsgREVCVUdfSW5mb1N0YWNrKCk7IH0KLQl8IElORk8gQlJFQUsgJ1xuJyAgICAgICAgIHsgREVCVUdfSW5mb0JyZWFrcG9pbnRzKCk7IH0KLQl8IElORk8gU0VHTUVOVFMgJ1xuJyAgICAgIHsgTERUX1ByaW50KCAwLCAtMSApOyB9Ci0gICAgICAgIHwgSU5GTyBTRUdNRU5UUyBleHByICdcbicgeyBMRFRfUHJpbnQoIFNFTEVDVE9SX1RPX0VOVFJZKCQzKSwgMSApOyB9CisgaW5mb2NtZDogSU5GTyBSRUdTCSAgICAgIHsgREVCVUdfSW5mb1JlZ2lzdGVycygpOyB9CisJfCBJTkZPIFNUQUNLCSAgICAgIHsgREVCVUdfSW5mb1N0YWNrKCk7IH0KKwl8IElORk8gQlJFQUsJICAgICAgeyBERUJVR19JbmZvQnJlYWtwb2ludHMoKTsgfQorCXwgSU5GTyBTRUdNRU5UUwkgICAgICB7IExEVF9QcmludCggMCwgLTEgKTsgfQorCXwgSU5GTyBTRUdNRU5UUyBleHByICB7IExEVF9QcmludCggU0VMRUNUT1JfVE9fRU5UUlkoJDMpLCAxICk7IH0KIAogCiAlJQpkaWZmIC0tZ2l0IGEvZGVidWdnZXIvZGVidWcubCBiL2RlYnVnZ2VyL2RlYnVnLmwKaW5kZXggZWYxNDJlZC4uYzQ2ZWIxMCAxMDA2NDQKLS0tIGEvZGVidWdnZXIvZGVidWcubAorKysgYi9kZWJ1Z2dlci9kZWJ1Zy5sCkBAIC0zNCw5ICszNCwxNyBAQAogCiAlJQogCi1cbgkJeyBzeW50YXhfZXJyb3IgPSAwOyByZXR1cm4gJ1xuJzsgfSAvKkluZGljYXRlIGVuZCBvZiBjb21tYW5kKi8KK1xuCQl7IHN5bnRheF9lcnJvciA9IDA7IHJldHVybiAnXG4nOyB9IC8qSW5kaWNhdGVzIGVuZCBvZiBjb21tYW5kKi8KIAotWy0rPSgpKjpdICAgICAgIHsgcmV0dXJuICp5eXRleHQ7IH0KKyJ8fCIJCXsgcmV0dXJuIE9QX0xPUjsgfQorIiYmIgkJeyByZXR1cm4gT1BfTEFORDsgfQorIj09IgkJeyByZXR1cm4gT1BfRVE7IH0KKyIhPSIJCXsgcmV0dXJuIE9QX05FOyB9CisiPD0iCQl7IHJldHVybiBPUF9MRTsgfQorIj49IgkJeyByZXR1cm4gT1BfR0U7IH0KKyI8PCIJCXsgcmV0dXJuIE9QX1NITDsgfQorIj4+IgkJeyByZXR1cm4gT1BfU0hSOyB9CitbLSs8PT58Jl4oKSovJTohfl0JeyByZXR1cm4gKnl5dGV4dDsgfQogCiAiMHgie0hFWERJR0lUfSsgICAgICB7IHNzY2FuZih5eXRleHQsICIleCIsICZ5eWx2YWwuaW50ZWdlcik7IHJldHVybiBOVU07IH0KIHtESUdJVH0rICAgICAgICAgICAgIHsgc3NjYW5mKHl5dGV4dCwgIiVkIiwgJnl5bHZhbC5pbnRlZ2VyKTsgcmV0dXJuIE5VTTsgfQpAQCAtNzIsMjUgKzgwLDI2IEBACiAkY3MgICAgIHsgeXlsdmFsLnJlZyA9IFJFR19DUzsgIHJldHVybiBSRUc7IH0KICRzcyAgICAgeyB5eWx2YWwucmVnID0gUkVHX1NTOyAgcmV0dXJuIFJFRzsgfQogCi1pbmZvfGluZnxpbgkJICAgICAgeyByZXR1cm4gSU5GTzsgfQotc2VnbWVudHN8c2VnbWVudHxzZWdtfHNlZ3xzZSAgeyByZXR1cm4gU0VHTUVOVFM7IH0KLWJyZWFrfGJyZWF8YnJlfGJyfGIgICAgICAgICAgIHsgcmV0dXJuIEJSRUFLOyB9Ci1lbmFibGV8ZW5hYmx8ZW5hYnxlbmEgICAgICAgICB7IHJldHVybiBFTkFCTEU7fQotZGlzYWJsZXxkaXNhYmx8ZGlzYWJ8ZGlzYXxkaXMgeyByZXR1cm4gRElTQUJMRTsgfQotZGVsZXRlfGRlbGV0fGRlbGV8ZGVsICAgICAgICAgeyByZXR1cm4gREVMRVRFOyB9Ci1xdWl0fHF1aXxxdXxxICAgICAgICAgICAgICAgICB7IHJldHVybiBRVUlUOyB9Ci14ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7IHJldHVybiBFWEFNOyB9CitpbmZvfGluZnxpbgkJCXsgcmV0dXJuIElORk87IH0KK3Nob3d8c2hvfHNoCQkJeyByZXR1cm4gSU5GTzsgfQorbGlzdHxsCQkJCXsgcmV0dXJuIExJU1Q7IH0KK3NlZ21lbnRzfHNlZ21lbnR8c2VnbXxzZWd8c2UJeyByZXR1cm4gU0VHTUVOVFM7IH0KK2JyZWFrfGJyZWF8YnJlfGJyfGIJCXsgcmV0dXJuIEJSRUFLOyB9CitlbmFibGV8ZW5hYmx8ZW5hYnxlbmEJCXsgcmV0dXJuIEVOQUJMRTt9CitkaXNhYmxlfGRpc2FibHxkaXNhYnxkaXNhfGRpcwl7IHJldHVybiBESVNBQkxFOyB9CitkZWxldGV8ZGVsZXR8ZGVsZXxkZWwJCXsgcmV0dXJuIERFTEVURTsgfQorcXVpdHxxdWl8cXV8cQkJCXsgcmV0dXJuIFFVSVQ7IH0KK3gJCQkJeyByZXR1cm4gRVhBTTsgfQogCi1oZWxwfGhlbHxoZQl7IHJldHVybiBIRUxQOyB9Ci0iPyIJCXsgcmV0dXJuIEhFTFA7IH0KK2hlbHB8aGVsfGhlfCI/IgkJCXsgcmV0dXJuIEhFTFA7IH0KIAotc2V0fHNlCQl7IHJldHVybiBTRVQ7IH0KK3NldHxzZQkJCQl7IHJldHVybiBTRVQ7IH0KIAotYnQJCXsgcmV0dXJuIEJBQ0tUUkFDRTsgfQorYnQJCQkJeyByZXR1cm4gQkFDS1RSQUNFOyB9CiAKLWNvbnR8Y29ufGNvfGMgICB7IHJldHVybiBDT05UOyB9Ci1zdGVwfHN0ZXxzdHxzICAgeyByZXR1cm4gU1RFUDsgfQotbmV4dHxuZXh8bmV8biAgIHsgcmV0dXJuIE5FWFQ7IH0KK2NvbnR8Y29ufGNvfGMgICAJCXsgcmV0dXJuIENPTlQ7IH0KK3N0ZXB8c3RlfHN0fHMgICAJCXsgcmV0dXJuIFNURVA7IH0KK25leHR8bmV4fG5lfG4gICAJCXsgcmV0dXJuIE5FWFQ7IH0KIAogc3ltYm9sZmlsZXxzeW1ib2xmaWx8c3ltYm9sZml8c3ltYm9sZnxzeW1ib2x8c3ltYm98c3ltYiB7IHJldHVybiBTWU1CT0xGSUxFOyB9CiAKQEAgLTEwMCw5ICsxMDksOSBAQAogCiBtb2RlCQkJCXsgcmV0dXJuIE1PREU7IH0KIAotcmVnaXN0ZXJzfHJlZ3N8cmVnfHJlCXsgcmV0dXJuIFJFR1M7IH0KK3JlZ2lzdGVyc3xyZWdzfHJlZ3xyZQkJeyByZXR1cm4gUkVHUzsgfQogCi1zdGFja3xzdGFjfHN0YXxzdCAgICAgCXsgcmV0dXJuIFNUQUNLOyB9CitzdGFja3xzdGFjfHN0YXxzdCAgICAgCQl7IHJldHVybiBTVEFDSzsgfQogCiB7SURFTlRJRklFUn0JeyB5eWx2YWwuc3RyaW5nID0gbWFrZV9zeW1ib2woeXl0ZXh0KTsgcmV0dXJuIElERU5USUZJRVI7IH0KIApkaWZmIC0tZ2l0IGEvZGVidWdnZXIvaGFzaC5jIGIvZGVidWdnZXIvaGFzaC5jCmluZGV4IGY2NTY5YzguLjhhMzI1YzcgMTAwNjQ0Ci0tLSBhL2RlYnVnZ2VyL2hhc2guYworKysgYi9kZWJ1Z2dlci9oYXNoLmMKQEAgLTE0LDYgKzE0LDcgQEAKICNpbmNsdWRlICJzZWxlY3RvcnMuaCIKICNpbmNsdWRlICJkZWJ1Z2dlci5oIgogI2luY2x1ZGUgInRvb2xoZWxwLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiBzdHJ1Y3QgbmFtZV9oYXNoCiB7CkBAIC00OCw3ICs0OSw3IEBACiAgICAgc3RydWN0IG5hbWVfaGFzaCAgKiBuZXc7CiAgICAgaW50IGhhc2g7CiAKLSAgICBuZXcgPSAoc3RydWN0IG5hbWVfaGFzaCAqKSBtYWxsb2Moc2l6ZW9mKHN0cnVjdCBuYW1lX2hhc2gpKTsKKyAgICBuZXcgPSAoc3RydWN0IG5hbWVfaGFzaCAqKSB4bWFsbG9jKHNpemVvZihzdHJ1Y3QgbmFtZV9oYXNoKSk7CiAgICAgbmV3LT5hZGRyID0gKmFkZHI7CiAgICAgbmV3LT5uYW1lID0gc3RyZHVwKG5hbWUpOwogICAgIG5ldy0+bmV4dCA9IE5VTEw7CmRpZmYgLS1naXQgYS9kZWJ1Z2dlci9pbmZvLmMgYi9kZWJ1Z2dlci9pbmZvLmMKaW5kZXggNDkxNGExNS4uNTRkNTE0MCAxMDA2NDQKLS0tIGEvZGVidWdnZXIvaW5mby5jCisrKyBiL2RlYnVnZ2VyL2luZm8uYwpAQCAtMTI1LDMgKzEyNSwyNyBAQAogCiAgICAgd2hpbGUoaGVscHRleHRbaV0pIGZwcmludGYoc3RkZXJyLCIlc1xuIiwgaGVscHRleHRbaSsrXSk7CiB9CisKKworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqICAgICAgICAgICBERUJVR19MaXN0CisgKgorICogSW1wbGVtZW50YXRpb24gb2YgdGhlICdsaXN0JyBjb21tYW5kLgorICovCit2b2lkIERFQlVHX0xpc3QoIERCR19BRERSICphZGRyLCBpbnQgY291bnQgKQoreworICAgIHN0YXRpYyBEQkdfQUREUiBsYXN0dGltZSA9IHsgMHhmZmZmZmZmZiwgMCB9OworCisgICAgaWYgKGFkZHIgPT0gTlVMTCkgYWRkciA9ICZsYXN0dGltZTsKKyAgICBEQkdfRklYX0FERFJfU0VHKCBhZGRyLCBDU19yZWcoREVCVUdfY29udGV4dCkgKTsKKyAgICB3aGlsZSAoY291bnQtLSA+IDApCisgICAgeworICAgICAgICBERUJVR19QcmludEFkZHJlc3MoIGFkZHIsIGRiZ19tb2RlICk7CisgICAgICAgIGZwcmludGYoIHN0ZGVyciwgIjogICIgKTsKKyAgICAgICAgaWYgKCFEQkdfQ0hFQ0tfUkVBRF9QVFIoIGFkZHIsIDEgKSkgYnJlYWs7CisgICAgICAgIERFQlVHX0Rpc2FzbSggYWRkciApOworICAgICAgICBmcHJpbnRmIChzdGRlcnIsICJcbiIpOworICAgIH0KKyAgICBsYXN0dGltZSA9ICphZGRyOworfQpkaWZmIC0tZ2l0IGEvaWYxNjMyL01ha2VmaWxlLmluIGIvaWYxNjMyL01ha2VmaWxlLmluCmluZGV4IDUyZTBhMTguLjYwYWM5MDcgMTAwNjQ0Ci0tLSBhL2lmMTYzMi9NYWtlZmlsZS5pbgorKysgYi9pZjE2MzIvTWFrZWZpbGUuaW4KQEAgLTE3LDYgKzE3LDcgQEAKIENfU1JDUyA9IFwKIAkkKFNQRUMzMl9GSUxFUykgXAogCWNhbGxiYWNrLmMgXAorCWR1bW15LmMgXAogCXJlbGF5LmMgXAogCXJlbGF5MzIuYwogCmRpZmYgLS1naXQgYS9pZjE2MzIvZHVtbXkuYyBiL2lmMTYzMi9kdW1teS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA4YzBmYzYKLS0tIC9kZXYvbnVsbAorKysgYi9pZjE2MzIvZHVtbXkuYwpAQCAtMCwwICsxLDQyIEBACisjaW5jbHVkZSA8c3RkaW8uaD4KK2xvbmcgc3R1Yl9HRElfNTMwKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTMwOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0dESV81MzEodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEdESV81MzE6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfR0RJXzUzMih2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogR0RJXzUzMjogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9HRElfNTM2KHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTM2OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0dESV81Mzgodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEdESV81Mzg6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfR0RJXzU0MCh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogR0RJXzU0MDogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9HRElfNTQzKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTQzOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0dESV81NTUodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEdESV81NTU6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfR0RJXzU2MCh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogR0RJXzU2MDogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9HRElfNTYxKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTYxOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0dESV81NjQodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEdESV81NjQ6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfR0RJXzU2NSh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogR0RJXzU2NTogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9HRElfNTY2KHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTY2OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0dESV81NzEodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEdESV81NzE6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfR0RJXzU3Mih2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogR0RJXzU3MjogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9HRElfNTczKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTczOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0dESV81NTYodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEdESV81NTY6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfR0RJXzU1OCh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogR0RJXzU1ODogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9HRElfNTY5KHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBHRElfNTY5OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX0tFUk5FTF80NTAodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IEtFUk5FTF80NTA6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl80ODkodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfNDg5OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfNDkwKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzQ5MDogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzQ5Mih2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl80OTI6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl80OTYodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfNDk2OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfOTAyKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzkwMjogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzkwNSh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl85MDU6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl85MDYodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfOTA2OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfOTA3KHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzkwNzogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzkwOSh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl85MDk6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl85MTAodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfOTEwOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfOTExKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzkxMTogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzkxMih2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl85MTI6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl85MTModm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfOTEzOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfOTE0KHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzkxNDogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzkxNSh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl85MTU6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl85MTYodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfOTE2OiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfOTE4KHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzkxODogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzkxOSh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl85MTk6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9Citsb25nIHN0dWJfVVNFUl85MjAodm9pZCkgeyBmcHJpbnRmKHN0ZGVyciwgIldhcm5pbmc6IFVTRVJfOTIwOiB1bmltcGxlbWVudGVkIHN0dWJcbiIpOyByZXR1cm4gMDsgfQorbG9uZyBzdHViX1VTRVJfOTIyKHZvaWQpIHsgZnByaW50ZihzdGRlcnIsICJXYXJuaW5nOiBVU0VSXzkyMjogdW5pbXBsZW1lbnRlZCBzdHViXG4iKTsgcmV0dXJuIDA7IH0KK2xvbmcgc3R1Yl9VU0VSXzkyMyh2b2lkKSB7IGZwcmludGYoc3RkZXJyLCAiV2FybmluZzogVVNFUl85MjM6IHVuaW1wbGVtZW50ZWQgc3R1YlxuIik7IHJldHVybiAwOyB9CmRpZmYgLS1naXQgYS9pZjE2MzIvZ2RpLnNwZWMgYi9pZjE2MzIvZ2RpLnNwZWMKaW5kZXggZjk2MDAwNy4uNWRkNTU5MyAxMDA2NDQKLS0tIGEvaWYxNjMyL2dkaS5zcGVjCisrKyBiL2lmMTYzMi9nZGkuc3BlYwpAQCAtMTQwLDggKzE0MCw4IEBACiAxNTQgcGFzY2FsIEdldE5lYXJlc3RDb2xvcih3b3JkIGxvbmcpIEdldE5lYXJlc3RDb2xvcgogMTU1IHN0dWIgUXVlcnlBYm9ydAogMTU2IHBhc2NhbDE2IENyZWF0ZURpc2NhcmRhYmxlQml0bWFwKHdvcmQgd29yZCB3b3JkKSBDcmVhdGVEaXNjYXJkYWJsZUJpdG1hcAotMTU5IHN0dWIgR2V0TWV0YUZpbGVCaXRzCi0xNjAgc3R1YiBTZXRNZXRhRmlsZUJpdHMKKzE1OSBwYXNjYWwxNiBHZXRNZXRhRmlsZUJpdHMod29yZCkgR2V0TWV0YUZpbGVCaXRzCisxNjAgcGFzY2FsMTYgU2V0TWV0YUZpbGVCaXRzKHdvcmQpIFNldE1ldGFGaWxlQml0cwogMTYxIHBhc2NhbDE2IFB0SW5SZWdpb24od29yZCBzX3dvcmQgc193b3JkKSBQdEluUmVnaW9uCiAxNjIgcGFzY2FsIEdldEJpdG1hcERpbWVuc2lvbih3b3JkKSBHZXRCaXRtYXBEaW1lbnNpb24KIDE2MyBwYXNjYWwgU2V0Qml0bWFwRGltZW5zaW9uKHdvcmQgc193b3JkIHNfd29yZCkgU2V0Qml0bWFwRGltZW5zaW9uCkBAIC0zNzUsMyArMzc1LDIzIEBACiA4MjIgc3R1YiBJQ01UcmFuc2xhdGVSR0IKIDgyMyBzdHViIElDTVRyYW5zbGF0ZVJHQnMKIDgyNCBzdHViIElDTUNoZWNrQ09sb3JzSW5HYW11dAorIyBTdHVicyBmb3IgSGVicmV3IHZlcnNpb24KKzUzMCBwYXNjYWwxNiBHRElfNTMwKCkgc3R1Yl9HRElfNTMwCis1MzEgcGFzY2FsMTYgR0RJXzUzMSgpIHN0dWJfR0RJXzUzMQorNTMyIHBhc2NhbDE2IEdESV81MzIoKSBzdHViX0dESV81MzIKKzUzNiBwYXNjYWwxNiBHRElfNTM2KCkgc3R1Yl9HRElfNTM2Cis1MzggcGFzY2FsMTYgR0RJXzUzOCgpIHN0dWJfR0RJXzUzOAorNTQwIHBhc2NhbDE2IEdESV81NDAoKSBzdHViX0dESV81NDAKKzU0MyBwYXNjYWwxNiBHRElfNTQzKCkgc3R1Yl9HRElfNTQzCis1NTUgcGFzY2FsMTYgR0RJXzU1NSgpIHN0dWJfR0RJXzU1NQorNTYwIHBhc2NhbDE2IEdESV81NjAoKSBzdHViX0dESV81NjAKKzU2MSBwYXNjYWwxNiBHRElfNTYxKCkgc3R1Yl9HRElfNTYxCis1NjQgcGFzY2FsMTYgR0RJXzU2NCgpIHN0dWJfR0RJXzU2NAorNTY1IHBhc2NhbDE2IEdESV81NjUoKSBzdHViX0dESV81NjUKKzU2NiBwYXNjYWwxNiBHRElfNTY2KCkgc3R1Yl9HRElfNTY2Cis1NzEgcGFzY2FsMTYgR0RJXzU3MSgpIHN0dWJfR0RJXzU3MQorNTcyIHBhc2NhbDE2IEdESV81NzIoKSBzdHViX0dESV81NzIKKzU3MyBwYXNjYWwxNiBHRElfNTczKCkgc3R1Yl9HRElfNTczCis1NTYgcGFzY2FsMTYgR0RJXzU1NigpIHN0dWJfR0RJXzU1NgorNTU4IHBhc2NhbDE2IEdESV81NTgoKSBzdHViX0dESV81NTgKKzU2OSBwYXNjYWwxNiBHRElfNTY5KCkgc3R1Yl9HRElfNTY5CmRpZmYgLS1naXQgYS9pZjE2MzIva2VybmVsLnNwZWMgYi9pZjE2MzIva2VybmVsLnNwZWMKaW5kZXggNGNmODQyNC4uOWE1YjE1ZiAxMDA2NDQKLS0tIGEvaWYxNjMyL2tlcm5lbC5zcGVjCisrKyBiL2lmMTYzMi9rZXJuZWwuc3BlYwpAQCAtMjgzLDYgKzI4Myw3IEBACiA0MjEgc3R1YiBTZXRGaWxlQXR0cmlidXRlcwogNDIyIHN0dWIgR2V0RGlza0ZyZWVTcGFjZQogNDMyIHN0dWIgRmlsZVRpbWVUb0xvY2FsRmlsZVRpbWUKKzQ1MCBwYXNjYWwxNiBLRVJORUxfNDUwKCkgc3R1Yl9LRVJORUxfNDUwCiA0OTEgc3R1YiBSZWdpc3RlclNlcnZpY2VQcm9jZXNzCiA1MTMgc3R1YiBMb2FkTGlicmFyeUV4MzJXCiA1MTQgc3R1YiBGcmVlTGlicmFyeTMyVwpkaWZmIC0tZ2l0IGEvaWYxNjMyL3VzZXIuc3BlYyBiL2lmMTYzMi91c2VyLnNwZWMKaW5kZXggNjNiN2E5ZC4uNDY5YmJjNSAxMDA2NDQKLS0tIGEvaWYxNjMyL3VzZXIuc3BlYworKysgYi9pZjE2MzIvdXNlci5zcGVjCkBAIC0yOTcsNyArMjk3LDcgQEAKIDI5MiBwYXNjYWwxNiBVbmhvb2tXaW5kb3dzSG9va0V4KHNlZ3B0cikgVW5ob29rV2luZG93c0hvb2tFeAogMjkzIHBhc2NhbCAgIENhbGxOZXh0SG9va0V4KHNlZ3B0ciBzX3dvcmQgd29yZCBsb25nKSBDYWxsTmV4dEhvb2tFeAogMjk0IHN0dWIgTG9ja1dpbmRvd1VwZGF0ZQotIzI5OSBNT1VTRV9FVkVOVAorMjk5IHJlZ2lzdGVyIE1vdXNlX0V2ZW50KCkgTW91c2VfRXZlbnQKIDMwMCBzdHViIFVubG9hZEluc3RhbGxlZERyaXZlcnMKICMzMDEgQk9aT1NMSVZFSEVSRSA6LSkpCiAjMzA2IEJFQVIzMDYKQEAgLTMxOSw3ICszMTksNyBAQAogMzM0IHBhc2NhbCAgIEdldFF1ZXVlU3RhdHVzKHdvcmQpIEdldFF1ZXVlU3RhdHVzCiAzMzUgcGFzY2FsMTYgR2V0SW5wdXRTdGF0ZSgpIEdldElucHV0U3RhdGUKIDMzNiBzdHViIExvYWRDdXJzb3JJY29uSGFuZGxlcgotMzM3IHN0dWIgR2V0TW91c2VFdmVudFByb2MKKzMzNyBwYXNjYWwgICBHZXRNb3VzZUV2ZW50UHJvYygpIEdldE1vdXNlRXZlbnRQcm9jCiAjMzQxIF9GRkZFX0ZBUkZSQU1FCiAzNDMgc3R1YiBHZXRGaWxlUG9ydE5hbWUKIDM1NiBzdHViIExvYWRESUJDdXJzb3JIYW5kbGVyCkBAIC01MTQsMyArNTE0LDI1IEBACiA4NTUgc3R1YiBVc3IzMlRoa0Nvbm5lY3Rpb25EYXRhU0wKIDg5MCBzdHViIEluc3RhbGxJTVQKIDg5MSBzdHViIFVuaW5zdGFsbElNVAorIyBTdHVicyBmb3IgSGVicmV3IHZlcnNpb24KKzQ4OSBwYXNjYWwxNiBVU0VSXzQ4OSgpIHN0dWJfVVNFUl80ODkKKzQ5MCBwYXNjYWwxNiBVU0VSXzQ5MCgpIHN0dWJfVVNFUl80OTAKKzQ5MiBwYXNjYWwxNiBVU0VSXzQ5MigpIHN0dWJfVVNFUl80OTIKKzQ5NiBwYXNjYWwxNiBVU0VSXzQ5NigpIHN0dWJfVVNFUl80OTYKKzkwMiBwYXNjYWwxNiBVU0VSXzkwMigpIHN0dWJfVVNFUl85MDIKKzkwNSBwYXNjYWwxNiBVU0VSXzkwNSgpIHN0dWJfVVNFUl85MDUKKzkwNiBwYXNjYWwxNiBVU0VSXzkwNigpIHN0dWJfVVNFUl85MDYKKzkwNyBwYXNjYWwxNiBVU0VSXzkwNygpIHN0dWJfVVNFUl85MDcKKzkwOSBwYXNjYWwxNiBVU0VSXzkwOSgpIHN0dWJfVVNFUl85MDkKKzkxMCBwYXNjYWwxNiBVU0VSXzkxMCgpIHN0dWJfVVNFUl85MTAKKzkxMSBwYXNjYWwxNiBVU0VSXzkxMSgpIHN0dWJfVVNFUl85MTEKKzkxMiBwYXNjYWwxNiBVU0VSXzkxMigpIHN0dWJfVVNFUl85MTIKKzkxMyBwYXNjYWwxNiBVU0VSXzkxMygpIHN0dWJfVVNFUl85MTMKKzkxNCBwYXNjYWwxNiBVU0VSXzkxNCgpIHN0dWJfVVNFUl85MTQKKzkxNSBwYXNjYWwxNiBVU0VSXzkxNSgpIHN0dWJfVVNFUl85MTUKKzkxNiBwYXNjYWwxNiBVU0VSXzkxNigpIHN0dWJfVVNFUl85MTYKKzkxOCBwYXNjYWwxNiBVU0VSXzkxOCgpIHN0dWJfVVNFUl85MTgKKzkxOSBwYXNjYWwxNiBVU0VSXzkxOSgpIHN0dWJfVVNFUl85MTkKKzkyMCBwYXNjYWwxNiBVU0VSXzkyMCgpIHN0dWJfVVNFUl85MjAKKzkyMiBwYXNjYWwxNiBVU0VSXzkyMigpIHN0dWJfVVNFUl85MjIKKzkyMyBwYXNjYWwxNiBVU0VSXzkyMygpIHN0dWJfVVNFUl85MjMKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNjZWwuaCBiL2luY2x1ZGUvYWNjZWwuaAppbmRleCA1OWZkYmQ4Li5iOGU1NjkwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjY2VsLmgKKysrIGIvaW5jbHVkZS9hY2NlbC5oCkBAIC01LDYgKzUsOCBAQAogICoKICAqLwogCisjaW5jbHVkZSAid2luZG93cy5oIgorCiB0eXBlZGVmIHN0cnVjdCB7CiAJV09SRAkJd0V2ZW50OwogCVdPUkQJCXdJRHZhbDsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYml0bWFwLmggYi9pbmNsdWRlL2JpdG1hcC5oCmluZGV4IGMyMzZjZGMuLmZjMDc3NjIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYml0bWFwLmgKKysrIGIvaW5jbHVkZS9iaXRtYXAuaApAQCAtMjgsNyArMjgsNyBAQAogeyBcCiAgICAgaW50IHdpZHRoX2J5dGVzID0gRElCX0dldEltYWdlV2lkdGhCeXRlcyggKHdpZHRoKSwgKGJwcCkgKTsgXAogICAgIChpbWFnZSkgPSBYQ3JlYXRlSW1hZ2UoZGlzcGxheSwgRGVmYXVsdFZpc3VhbE9mU2NyZWVuKHNjcmVlbiksIFwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgIChicHApLCBaUGl4bWFwLCAwLCBtYWxsb2MoIChoZWlnaHQpKndpZHRoX2J5dGVzICksIFwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIChicHApLCBaUGl4bWFwLCAwLCB4bWFsbG9jKCAoaGVpZ2h0KSp3aWR0aF9ieXRlcyApLFwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICh3aWR0aCksIChoZWlnaHQpLCAzMiwgd2lkdGhfYnl0ZXMgKTsgXAogfQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RlYnVnZ2VyLmggYi9pbmNsdWRlL2RlYnVnZ2VyLmgKaW5kZXggOTE5MGZmMS4uZGViOTJmYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kZWJ1Z2dlci5oCisrKyBiL2luY2x1ZGUvZGVidWdnZXIuaApAQCAtODYsNiArODYsNyBAQAogZXh0ZXJuIHZvaWQgREVCVUdfUHJpbnQoIGNvbnN0IERCR19BRERSICphZGRyLCBpbnQgY291bnQsIGNoYXIgZm9ybWF0ICk7CiBleHRlcm4gdm9pZCBERUJVR19QcmludEFkZHJlc3MoIGNvbnN0IERCR19BRERSICphZGRyLCBpbnQgYWRkcmxlbiApOwogZXh0ZXJuIHZvaWQgREVCVUdfSGVscCh2b2lkKTsKK2V4dGVybiB2b2lkIERFQlVHX0xpc3QoIERCR19BRERSICphZGRyLCBpbnQgY291bnQgKTsKIAogICAvKiBkZWJ1Z2dlci9tZW1vcnkuYyAqLwogZXh0ZXJuIEJPT0wgREVCVUdfSXNCYWRSZWFkUHRyKCBjb25zdCBEQkdfQUREUiAqYWRkcmVzcywgaW50IHNpemUgKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbWVudS5oIGIvaW5jbHVkZS9tZW51LmgKaW5kZXggZDJmYWU3Yy4uNTlmMjkyZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZW51LmgKKysrIGIvaW5jbHVkZS9tZW51LmgKQEAgLTksMTEgKzksMTEgQEAKICNkZWZpbmUgTUVOVV9NQUdJQyAgIDB4NTU0ZCAgLyogJ01VJyAqLwogCiBleHRlcm4gQk9PTCBNRU5VX0luaXQodm9pZCk7Ci1leHRlcm4gV09SRCBNRU5VX0dldE1lbnVCYXJIZWlnaHQoIEhXTkQgaHduZCwgV09SRCBtZW51YmFyV2lkdGgsCitleHRlcm4gVUlOVCBNRU5VX0dldE1lbnVCYXJIZWlnaHQoIEhXTkQgaHduZCwgVUlOVCBtZW51YmFyV2lkdGgsCiAJCQkJICAgaW50IG9yZ1gsIGludCBvcmdZICk7ICAgICAgICAgLyogbWVudS5jICovCiBleHRlcm4gdm9pZCBNRU5VX1RyYWNrTW91c2VNZW51QmFyKCBIV05EIGh3bmQsIFBPSU5UIHB0ICk7ICAgICAgIC8qIG1lbnUuYyAqLwotZXh0ZXJuIHZvaWQgTUVOVV9UcmFja0tiZE1lbnVCYXIoIEhXTkQgaHduZCwgV09SRCB3UGFyYW0gKTsgICAgICAvKiBtZW51LmMgKi8KLWV4dGVybiBXT1JEIE1FTlVfRHJhd01lbnVCYXIoIEhEQyBoREMsIExQUkVDVCBscHJlY3QsCitleHRlcm4gdm9pZCBNRU5VX1RyYWNrS2JkTWVudUJhciggSFdORCBod25kLCBVSU5UIHdQYXJhbSApOyAgICAgIC8qIG1lbnUuYyAqLworZXh0ZXJuIFVJTlQgTUVOVV9EcmF3TWVudUJhciggSERDIGhEQywgTFBSRUNUIGxwcmVjdCwKIAkJCSAgICAgIEhXTkQgaHduZCwgQk9PTCBzdXBwcmVzc19kcmF3ICk7ICAgLyogbWVudS5jICovCiBleHRlcm4gSE1FTlUgQ29weVN5c01lbnUoKTsgLyogbWVudS5jICovCiAKQEAgLTIyLDcgKzIyLDcgQEAKIHR5cGVkZWYgc3RydWN0IHRhZ01FTlVJVEVNCiB7CiAgICAgV09SRAlpdGVtX2ZsYWdzOyAgICAvKiBJdGVtIGZsYWdzICovCi0gICAgV09SRAlpdGVtX2lkOyAgICAgICAvKiBJdGVtIG9yIHBvcHVwIGlkICovCisgICAgVUlOVAlpdGVtX2lkOyAgICAgICAvKiBJdGVtIG9yIHBvcHVwIGlkICovCiAgICAgUkVDVAlyZWN0OyAgICAgICAgICAvKiBJdGVtIGFyZWEgKHJlbGF0aXZlIHRvIG1lbnUgd2luZG93KSAqLwogICAgIFdPUkQgICAgICAgIHhUYWI7ICAgICAgICAgIC8qIFggcG9zaXRpb24gb2YgdGV4dCBhZnRlciBUYWIgKi8KICAgICBIQklUTUFQCWhDaGVja0JpdDsgICAgIC8qIEJpdG1hcCBmb3IgY2hlY2tlZCBpdGVtICovCkBAIC00Myw3ICs0Myw3IEBACiAgICAgV09SRAluSXRlbXM7ICAgICAgIC8qIE51bWJlciBvZiBpdGVtcyBpbiB0aGUgbWVudSAqLwogICAgIEhXTkQJaFduZDsJICAgICAgLyogV2luZG93IGNvbnRhaW5pbmcgdGhlIG1lbnUgKi8KICAgICBIQU5ETEUgICAgICBoSXRlbXM7ICAgICAgIC8qIEhhbmRsZSB0byB0aGUgaXRlbXMgYXJyYXkgKi8KLSAgICBXT1JECUZvY3VzZWRJdGVtOyAgLyogQ3VycmVudGx5IGZvY3VzZWQgaXRlbSAqLworICAgIFVJTlQJRm9jdXNlZEl0ZW07ICAvKiBDdXJyZW50bHkgZm9jdXNlZCBpdGVtICovCiB9IFBPUFVQTUVOVSwgKkxQUE9QVVBNRU5VOwogCiB0eXBlZGVmIHN0cnVjdApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zeXNtZXRyaWNzLmggYi9pbmNsdWRlL3N5c21ldHJpY3MuaAppbmRleCAxMWUwOGI0Li41MmZmYTZjIDEwMDY0NAotLS0gYS9pbmNsdWRlL3N5c21ldHJpY3MuaAorKysgYi9pbmNsdWRlL3N5c21ldHJpY3MuaApAQCAtNzUsNiArNzUsNiBAQAogI2RlZmluZSBTWVNNRVRSSUNTX01FTlVEUk9QQUxJR05NRU5UICAgc3lzTWV0cmljc1tTTV9NRU5VRFJPUEFMSUdOTUVOVF0KIAogZXh0ZXJuIHZvaWQgU1lTTUVUUklDU19Jbml0KHZvaWQpOwotZXh0ZXJuIHNob3J0IHN5c01ldHJpY3NbU01fQ01FVFJJQ1NdOworZXh0ZXJuIHNob3J0IHN5c01ldHJpY3NbU01fQ01FVFJJQ1MrMV07CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS93aW4uaCBiL2luY2x1ZGUvd2luLmgKaW5kZXggZjQwOTM3ZC4uNDk0OTFhMiAxMDA2NDQKLS0tIGEvaW5jbHVkZS93aW4uaAorKysgYi9pbmNsdWRlL3dpbi5oCkBAIC01MSw3ICs1MSw3IEBACiAgICAgSEFORExFICAgICAgIGhkY2U7ICAgICAgICAgICAvKiBXaW5kb3cgRENFIChpZiBDU19PV05EQyBvciBDU19DTEFTU0RDKSAqLwogICAgIEhBTkRMRSAgICAgICBoVlNjcm9sbDsgICAgICAgLyogVmVydGljYWwgc2Nyb2xsLWJhciBpbmZvICovCiAgICAgSEFORExFICAgICAgIGhIU2Nyb2xsOyAgICAgICAvKiBIb3Jpem9udGFsIHNjcm9sbC1iYXIgaW5mbyAqLwotICAgIFdPUkQgICAgICAgICB3SURtZW51OyAgICAgICAgLyogSUQgb3IgaG1lbnUgKGZyb20gQ3JlYXRlV2luZG93KSAqLworICAgIFVJTlQgICAgICAgICB3SURtZW51OyAgICAgICAgLyogSUQgb3IgaG1lbnUgKGZyb20gQ3JlYXRlV2luZG93KSAqLwogICAgIEhBTkRMRSAgICAgICBoVGV4dDsgICAgICAgICAgLyogSGFuZGxlIG9mIHdpbmRvdyB0ZXh0ICovCiAgICAgV09SRCAgICAgICAgIGZsYWdzOyAgICAgICAgICAvKiBNaXNjLiBmbGFncyAoc2VlIGJlbG93KSAqLwogICAgIFdpbmRvdyAgICAgICB3aW5kb3c7ICAgICAgICAgLyogWCB3aW5kb3cgKG9ubHkgZm9yIHRvcC1sZXZlbCB3aW5kb3dzKSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS93aW5kb3dzLmggYi9pbmNsdWRlL3dpbmRvd3MuaAppbmRleCBlMTUxZWJmLi4wNjQ0MzRkIDEwMDY0NAotLS0gYS9pbmNsdWRlL3dpbmRvd3MuaAorKysgYi9pbmNsdWRlL3dpbmRvd3MuaApAQCAtOSwyMSArOSwyNCBAQAogI3ByYWdtYSBwYWNrKDEpCiAjZW5kaWYKIAotdHlwZWRlZiBzdHJ1Y3QgeyAKLQlJTlQgeDsKLQlJTlQgeTsgCi19IFBPSU5UOworI2lmZGVmIFdJTkVMSUIzMgordHlwZWRlZiBzdHJ1Y3QgeyBMT05HIHgseTsgfSBQT0lOVDsKK3R5cGVkZWYgc3RydWN0IHsgU0hPUlQgeCx5OyB9IFBPSU5UUzsKK3R5cGVkZWYgc3RydWN0IHsgTE9ORyBjeCxjeTsgfSBTSVpFLCAqTFBTSVpFOwordHlwZWRlZiBzdHJ1Y3QgeyBMT05HIGxlZnQsIHRvcCwgcmlnaHQsIGJvdHRvbTsgfSBSRUNUOworI2RlZmluZSBNQUtFUE9JTlRTKGwpICgqKChQT0lOVFMgKikmKGwpKSkKKyNlbHNlCit0eXBlZGVmIHN0cnVjdCB7IElOVCB4LHk7IH0gUE9JTlQ7Cit0eXBlZGVmIHN0cnVjdCB7IElOVCBjeCxjeTsgfSBTSVpFLCAqTFBTSVpFOwordHlwZWRlZiBzdHJ1Y3QgeyBJTlQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOyB9IFJFQ1Q7CisjZGVmaW5lIE1BS0VQT0lOVChsKSAoKigoUE9JTlQgKikmKGwpKSkKKyNlbmRpZgogdHlwZWRlZiBQT0lOVCAqUFBPSU5UOwogdHlwZWRlZiBQT0lOVCAqTlBQT0lOVDsKIHR5cGVkZWYgUE9JTlQgKkxQUE9JTlQ7Ci0KLXR5cGVkZWYgc3RydWN0IAotewotICAgIElOVCBjeDsKLSAgICBJTlQgY3k7Ci19IFNJWkUsICpMUFNJWkU7Ci0KLSNkZWZpbmUgTUFLRVBPSU5UKGwpICgqKChQT0lOVCAqKSYobCkpKQordHlwZWRlZiBSRUNUICpMUFJFQ1Q7Cit0eXBlZGVmIFJFQ1QgKk5QUkVDVDsKK3R5cGVkZWYgUkVDVCAqUFJFQ1Q7CiAKICNpZmRlZiBXSU5FTElCMzIKICNkZWZpbmUgTUFLRVdQQVJBTShsb3csIGhpZ2gpICgoTE9ORykoKChXT1JEKShsb3cpKSB8IFwKQEAgLTMzLDExICszNiw2IEBACiAjZGVmaW5lIE1BS0VMUEFSQU0obG93LCBoaWdoKSAoKExPTkcpKCgoV09SRCkobG93KSkgfCBcCiAJCQkgICAgICAoKChEV09SRCkoKFdPUkQpKGhpZ2gpKSkgPDwgMTYpKSkKIAotdHlwZWRlZiBzdHJ1Y3QgeyBJTlQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOyB9IFJFQ1Q7Ci10eXBlZGVmIFJFQ1QgKkxQUkVDVDsKLXR5cGVkZWYgUkVDVCAqTlBSRUNUOwotdHlwZWRlZiBSRUNUICpQUkVDVDsKLQogdHlwZWRlZiBzdHJ1Y3QgewogCUhEQyBoZGM7CiAJQk9PTAlmRXJhc2U7CkBAIC00MjUsOSArNDIzLDkgQEAKIHR5cGVkZWYgc3RydWN0IHRhZ01TRwogewogICBIV05EICAgIGh3bmQ7Ci0gIFdPUkQgICAgbWVzc2FnZTsKLSAgV09SRCAgICB3UGFyYW07Ci0gIERXT1JEICAgbFBhcmFtIFdJTkVfUEFDS0VEOworICBVSU5UICAgIG1lc3NhZ2U7CisgIFdQQVJBTSAgd1BhcmFtOworICBMUEFSQU0gIGxQYXJhbSBXSU5FX1BBQ0tFRDsKICAgRFdPUkQgICB0aW1lIFdJTkVfUEFDS0VEOwogICBQT0lOVAkgIHB0IFdJTkVfUEFDS0VEOwogfSBNU0csICpMUE1TRzsKQEAgLTE1NjksNiArMTU2NywxMyBAQAogI2RlZmluZSBNS19DT05UUk9MCSAgICAweDAwMDgKICNkZWZpbmUgTUtfTUJVVFRPTgkgICAgMHgwMDEwCiAKKyAgLyogTW91c2VfRXZlbnQgZmxhZ3MgKi8KKyNkZWZpbmUgTUVfTU9WRSAgICAgICAgICAgICAweDAxCisjZGVmaW5lIE1FX0xET1dOICAgICAgICAgICAgMHgwMgorI2RlZmluZSBNRV9MVVAgICAgICAgICAgICAgIDB4MDQKKyNkZWZpbmUgTUVfUkRPV04gICAgICAgICAgICAweDA4CisjZGVmaW5lIE1FX1JVUCAgICAgICAgICAgICAgMHgxMAorCiAgIC8qIFF1ZXVlIHN0YXR1cyBmbGFncyAqLwogI2RlZmluZSBRU19LRVkJCTB4MDAwMQogI2RlZmluZSBRU19NT1VTRU1PVkUJMHgwMDAyCkBAIC0yMzY2LDcgKzIzNzEsNyBAQAogI2RlZmluZSBNRVRBX0RSQVdURVhUICAgICAgICAgICAgICAgIDB4MDYyRgogI2RlZmluZSBNRVRBX0NIT1JEICAgICAgICAgICAgICAgICAgIDB4MDgzMAogI2RlZmluZSBNRVRBX1NFVE1BUFBFUkZMQUdTICAgICAgICAgIDB4MDIzMQotI2RlZmluZSBNRVRBX1NFVFRFWFRPVVQgICAgICAgICAgICAgIDB4MEEzMgorI2RlZmluZSBNRVRBX0VYVFRFWFRPVVQgICAgICAgICAgICAgIDB4MEEzMgogI2RlZmluZSBNRVRBX1NFVERJQlRPREVWICAgICAgICAgICAgIDB4MEQzMwogI2RlZmluZSBNRVRBX1NFTEVDVFBBTEVUVEUgICAgICAgICAgIDB4MDIzNAogI2RlZmluZSBNRVRBX1JFQUxJWkVQQUxFVFRFICAgICAgICAgIDB4MDAzNQpAQCAtMjQ1OCwxOSArMjQ2MywxOSBAQAogQVRPTSBHbG9iYWxGaW5kQXRvbShTRUdQVFIpOwogQVRPTSBSZWdpc3RlckNsYXNzKExQV05EQ0xBU1MpOwogQk9PTCBBbnlQb3B1cCh2b2lkKTsKLUJPT0wgQXBwZW5kTWVudShITUVOVSxXT1JELFdPUkQsTFBTVFIpOworQk9PTCBBcHBlbmRNZW51KEhNRU5VLFVJTlQsVUlOVCxMUFNUUik7CiBCT09MIEFyYyhIREMsaW50LGludCxpbnQsaW50LGludCxpbnQsaW50LGludCk7CiBCT09MIEJpdEJsdChIREMsc2hvcnQsc2hvcnQsc2hvcnQsc2hvcnQsSERDLHNob3J0LHNob3J0LERXT1JEKTsKIEJPT0wgQnJpbmdXaW5kb3dUb1RvcChIV05EKTsKIEJPT0wgQ2FsbE1zZ0ZpbHRlcihTRUdQVFIsc2hvcnQpOwogQk9PTCBDaGFuZ2VDbGlwYm9hcmRDaGFpbihIV05ELEhXTkQpOwotQk9PTCBDaGFuZ2VNZW51KEhNRU5VLFdPUkQsTFBTVFIsV09SRCxXT1JEKTsKLUJPT0wgQ2hlY2tNZW51SXRlbShITUVOVSxXT1JELFdPUkQpOworQk9PTCBDaGFuZ2VNZW51KEhNRU5VLFVJTlQsTFBTVFIsVUlOVCxVSU5UKTsKK0JPT0wgQ2hlY2tNZW51SXRlbShITUVOVSxVSU5ULFVJTlQpOwogQk9PTCBDaG9yZChIREMsaW50LGludCxpbnQsaW50LGludCxpbnQsaW50LGludCk7CiBCT09MIENsb3NlQ2xpcGJvYXJkKHZvaWQpOwogQk9PTCBEUHRvTFAoSERDLExQUE9JTlQsaW50KTsKIEJPT0wgRGVsZXRlREMoSERDKTsKLUJPT0wgRGVsZXRlTWVudShITUVOVSxXT1JELFdPUkQpOworQk9PTCBEZWxldGVNZW51KEhNRU5VLFVJTlQsVUlOVCk7CiBCT09MIERlbGV0ZU1ldGFGaWxlKEhNRVRBRklMRSk7CiBCT09MIERlbGV0ZU9iamVjdChIQU5ETEUpOwogQk9PTCBEZXN0cm95Q3Vyc29yKEhDVVJTT1IpOwpAQCAtMjQ4Myw3ICsyNDg4LDcgQEAKIEJPT0wgRWxsaXBzZShIREMsaW50LGludCxpbnQsaW50KTsKIEJPT0wgRW1wdHlDbGlwYm9hcmQodm9pZCk7CiBCT09MIEVuYWJsZUhhcmR3YXJlSW5wdXQoQk9PTCk7Ci1CT09MIEVuYWJsZU1lbnVJdGVtKEhNRU5VLFdPUkQsV09SRCk7CitCT09MIEVuYWJsZU1lbnVJdGVtKEhNRU5VLFVJTlQsVUlOVCk7CiBCT09MIEVuYWJsZVNjcm9sbEJhcihIV05ELElOVCxVSU5UKTsKIEJPT0wgRW5hYmxlV2luZG93KEhXTkQsQk9PTCk7CiBCT09MIEVuZERlZmVyV2luZG93UG9zKEhEV1ApOwpAQCAtMjUyMSw5ICsyNTI2LDkgQEAKIEJPT0wgR2xvYmFsVW5XaXJlKEhHTE9CQUwpOwogQk9PTCBHbG9iYWxVbmxvY2soSEdMT0JBTCk7CiBCT09MIEdyYXlTdHJpbmcoSERDLEhCUlVTSCxGQVJQUk9DLExQQVJBTSxJTlQsSU5ULElOVCxJTlQsSU5UKTsKLUJPT0wgSGlsaXRlTWVudUl0ZW0oSFdORCxITUVOVSxXT1JELFdPUkQpOworQk9PTCBIaWxpdGVNZW51SXRlbShIV05ELEhNRU5VLFVJTlQsVUlOVCk7CiBCT09MIEluU2VuZE1lc3NhZ2Uodm9pZCk7Ci1CT09MIEluc2VydE1lbnUoSE1FTlUsV09SRCxXT1JELFdPUkQsTFBTVFIpOworQk9PTCBJbnNlcnRNZW51KEhNRU5VLFVJTlQsVUlOVCxVSU5ULExQU1RSKTsKIEJPT0wgSW50ZXJzZWN0UmVjdChMUFJFQ1QsTFBSRUNULExQUkVDVCk7CiBCT09MIEludmVydFJnbihIREMsSFJHTik7CiBCT09MIElzQmFkQ29kZVB0cihTRUdQVFIpOwpAQCAtMjU1Miw3ICsyNTU3LDcgQEAKIEJPT0wgTGluZVRvKEhEQyxzaG9ydCxzaG9ydCk7CiBCT09MIExvY2FsSW5pdChIQU5ETEUsV09SRCxXT1JEKTsKIEJPT0wgTG9jYWxVbmxvY2soSEFORExFKTsKLUJPT0wgTW9kaWZ5TWVudShITUVOVSxXT1JELFdPUkQsV09SRCxMUFNUUik7CitCT09MIE1vZGlmeU1lbnUoSE1FTlUsVUlOVCxVSU5ULFVJTlQsTFBTVFIpOwogQk9PTCBNb3ZlVG9FeChIREMsc2hvcnQsc2hvcnQsTFBQT0lOVCk7CiBCT09MIE1vdmVXaW5kb3coSFdORCxzaG9ydCxzaG9ydCxzaG9ydCxzaG9ydCxCT09MKTsKIEJPT0wgT2VtVG9BbnNpKExQU1RSLExQU1RSKTsKQEAgLTI1NzgsOCArMjU4Myw4IEBACiBCT09MIFJlY3RhbmdsZShIREMsaW50LGludCxpbnQsaW50KTsKIEJPT0wgUmVkcmF3V2luZG93KEhXTkQsTFBSRUNULEhSR04sVUlOVCk7CiBCT09MIFJlbW92ZUZvbnRSZXNvdXJjZShMUFNUUik7Ci1CT09MIFJlbW92ZU1lbnUoSE1FTlUsV09SRCxXT1JEKTsKLUJPT0wgUmVzaXplUGFsZXR0ZShIUEFMRVRURSxXT1JEKTsKK0JPT0wgUmVtb3ZlTWVudShITUVOVSxVSU5ULFVJTlQpOworQk9PTCBSZXNpemVQYWxldHRlKEhQQUxFVFRFLFVJTlQpOwogQk9PTCBSZXN0b3JlREMoSERDLHNob3J0KTsKIEJPT0wgUm91bmRSZWN0KEhEQyxzaG9ydCxzaG9ydCxzaG9ydCxzaG9ydCxzaG9ydCxzaG9ydCk7CiBCT09MIFNjYWxlVmlld3BvcnRFeHRFeChIREMsc2hvcnQsc2hvcnQsc2hvcnQsc2hvcnQsTFBTSVpFKTsKQEAgLTI1OTEsNyArMjU5Niw3IEBACiBCT09MIFNldERlc2tXYWxsUGFwZXIoTFBTVFIpOwogQk9PTCBTZXRFcnJvck1vZGUoV09SRCk7CiBCT09MIFNldE1lbnUoSFdORCxITUVOVSk7Ci1CT09MIFNldE1lbnVJdGVtQml0bWFwcyhITUVOVSxXT1JELFdPUkQsSEJJVE1BUCxIQklUTUFQKTsKK0JPT0wgU2V0TWVudUl0ZW1CaXRtYXBzKEhNRU5VLFVJTlQsVUlOVCxIQklUTUFQLEhCSVRNQVApOwogQk9PTCBTZXRNZXNzYWdlUXVldWUoaW50KTsKIEJPT0wgU2V0UHJvcChIV05ELFNFR1BUUixIQU5ETEUpOwogQk9PTCBTZXRWaWV3cG9ydEV4dEV4KEhEQyxzaG9ydCxzaG9ydCxMUFNJWkUpOwpAQCAtMjYwNiw3ICsyNjExLDcgQEAKIEJPT0wgU3VidHJhY3RSZWN0KExQUkVDVCxMUFJFQ1QsTFBSRUNUKTsKIEJPT0wgU3dhcE1vdXNlQnV0dG9uKEJPT0wpOwogQk9PTCBUZXh0T3V0KEhEQyxzaG9ydCxzaG9ydCxMUFNUUixzaG9ydCk7Ci1CT09MIFRyYWNrUG9wdXBNZW51KEhNRU5VLFdPUkQsc2hvcnQsc2hvcnQsc2hvcnQsSFdORCxMUFJFQ1QpOworQk9PTCBUcmFja1BvcHVwTWVudShITUVOVSxVSU5ULHNob3J0LHNob3J0LHNob3J0LEhXTkQsTFBSRUNUKTsKIEJPT0wgVHJhbnNsYXRlTURJU3lzQWNjZWwoSFdORCxMUE1TRyk7CiBCT09MIFRyYW5zbGF0ZU1lc3NhZ2UoTFBNU0cpOwogQk9PTCBVbmhvb2tXaW5kb3dzSG9vayhzaG9ydCxGQVJQUk9DKTsKQEAgLTI2MjgsNyArMjYzMyw4IEBACiBEV09SRCBHZXRCaXRtYXBEaW1lbnNpb24oSEJJVE1BUCk7CiBEV09SRCBHZXRCcnVzaE9yZyhIREMpOwogRFdPUkQgR2V0Q3VycmVudFBvc2l0aW9uKEhEQyk7Ci1EV09SRCBHZXRDdXJyZW50VGltZSh2b2lkKTsKKy8qRFdPUkQgR2V0Q3VycmVudFRpbWUodm9pZCk7Ki8KKyNkZWZpbmUgR2V0Q3VycmVudFRpbWUgR2V0VGlja0NvdW50CiBEV09SRCBHZXREQ09yZyhIREMpOwogRFdPUkQgR2V0RGlhbG9nQmFzZVVuaXRzKHZvaWQpOwogRFdPUkQgR2V0RnJlZVNwYWNlKFdPUkQpOwpAQCAtMjY0OCw3ICsyNjU0LDExIEBACiBEV09SRCBHZXRXaW5kb3dPcmcoSERDKTsKIERXT1JEIEdsb2JhbENvbXBhY3QoRFdPUkQpOwogRFdPUkQgR2xvYmFsRE9TQWxsb2MoRFdPUkQpOwotRFdPUkQgR2xvYmFsSGFuZGxlKFdPUkQpOworI2lmZGVmIFdJTkVMSUIzMgorSEdMT0JBTCBHbG9iYWxIYW5kbGUoTFBDVk9JRCk7CisjZWxzZQorRFdPUkQgR2xvYmFsSGFuZGxlKFVJTlQpOworI2VuZGlmCiBEV09SRCBHbG9iYWxTaXplKEhHTE9CQUwpOwogRFdPUkQgTW92ZVRvKEhEQyxzaG9ydCxzaG9ydCk7CiBEV09SRCBPZW1LZXlTY2FuKFdPUkQpOwpAQCAtMjY2Niw2ICsyNjc2LDcgQEAKIERXT1JEIFNldFdpbmRvd0V4dChIREMsc2hvcnQsc2hvcnQpOwogRFdPUkQgU2V0V2luZG93T3JnKEhEQyxzaG9ydCxzaG9ydCk7CiBEV09SRCBTaXplb2ZSZXNvdXJjZShIQU5ETEUsSFJTUkMpOworRkFSUFJPQyBHZXRNb3VzZUV2ZW50UHJvYyh2b2lkKTsKIEZBUlBST0MgR2V0UHJvY0FkZHJlc3MoSEFORExFLFNFR1BUUik7CiBGQVJQUk9DIExvY2FsTm90aWZ5KEZBUlBST0MpOwogRkFSUFJPQyBNYWtlUHJvY0luc3RhbmNlKEZBUlBST0MsSEFORExFKTsKQEAgLTI3NTgsOCArMjc2OSw4IEBACiBIUEVOIENyZWF0ZVBlbkluZGlyZWN0KExPR1BFTiopOwogSFJHTiBDcmVhdGVFbGxpcHRpY1JnbihzaG9ydCxzaG9ydCxzaG9ydCxzaG9ydCk7CiBIUkdOIENyZWF0ZUVsbGlwdGljUmduSW5kaXJlY3QoTFBSRUNUKTsKLUhSR04gQ3JlYXRlUG9seVBvbHlnb25SZ24oTFBQT0lOVCxMUElOVCxzaG9ydCxzaG9ydCk7Ci1IUkdOIENyZWF0ZVBvbHlnb25SZ24oTFBQT0lOVCxzaG9ydCxzaG9ydCk7CitIUkdOIENyZWF0ZVBvbHlQb2x5Z29uUmduKExQUE9JTlQsTFBJTlQsSU5ULElOVCk7CitIUkdOIENyZWF0ZVBvbHlnb25SZ24oTFBQT0lOVCxJTlQsSU5UKTsKIEhSR04gQ3JlYXRlUmVjdFJnbihzaG9ydCxzaG9ydCxzaG9ydCxzaG9ydCk7CiBIUkdOIENyZWF0ZVJlY3RSZ25JbmRpcmVjdChMUFJFQ1QpOwogSFJHTiBDcmVhdGVSb3VuZFJlY3RSZ24oc2hvcnQsc2hvcnQsc2hvcnQsc2hvcnQsc2hvcnQsc2hvcnQpOwpAQCAtMjg2OSwxNSArMjg4MCwxNSBAQAogV09SRCBHZXRCa01vZGUoSERDKTsKIFdPUkQgR2V0Q2FyZXRCbGlua1RpbWUodm9pZCk7CiBXT1JEIEdldENsYXNzV29yZChIV05ELHNob3J0KTsKLVdPUkQgR2V0Q29tbUV2ZW50TWFzayhpbnQsaW50KTsKK1VJTlQgR2V0Q29tbUV2ZW50TWFzayhpbnQsaW50KTsKIFdPUkQgR2V0RGxnSXRlbUludChIV05ELFdPUkQsQk9PTCosQk9PTCk7CiBXT1JEIEdldERvdWJsZUNsaWNrVGltZSh2b2lkKTsKIFdPUkQgR2V0RHJpdmVUeXBlKElOVCk7CiBXT1JEIEdldEludGVybmFsV2luZG93UG9zKEhXTkQsTFBSRUNULExQUE9JTlQpOwogV09SRCBHZXRNYXBNb2RlKEhEQyk7CiBXT1JEIEdldE1lbnVJdGVtQ291bnQoSE1FTlUpOwotV09SRCBHZXRNZW51SXRlbUlEKEhNRU5VLGludCk7Ci1XT1JEIEdldE1lbnVTdGF0ZShITUVOVSxXT1JELFdPUkQpOworVUlOVCBHZXRNZW51SXRlbUlEKEhNRU5VLGludCk7CitVSU5UIEdldE1lbnVTdGF0ZShITUVOVSxVSU5ULFVJTlQpOwogV09SRCBHZXROZWFyZXN0UGFsZXR0ZUluZGV4KEhQQUxFVFRFLERXT1JEKTsKIFdPUkQgR2V0TnVtVGFza3Modm9pZCk7CiBXT1JEIEdldFBhbGV0dGVFbnRyaWVzKEhQQUxFVFRFLFdPUkQsV09SRCxMUFBBTEVUVEVFTlRSWSk7CkBAIC0yODg3LDEyICsyODk4LDEyIEBACiBXT1JEIEdldFJPUDIoSERDKTsKIFdPUkQgR2V0UmVsQWJzKEhEQyk7CiBXT1JEIEdldFN0cmV0Y2hCbHRNb2RlKEhEQyk7Ci1XT1JEIEdldFN5c3RlbURpcmVjdG9yeShMUFNUUixXT1JEKTsKK1VJTlQgR2V0U3lzdGVtRGlyZWN0b3J5KExQU1RSLFVJTlQpOwogV09SRCBHZXRTeXN0ZW1QYWxldHRlRW50cmllcyhIREMsV09SRCxXT1JELExQUEFMRVRURUVOVFJZKTsKIFdPUkQgR2V0U3lzdGVtUGFsZXR0ZVVzZShIREMpOwogV09SRCBHZXRUZXh0QWxpZ24oSERDKTsKIFdPUkQgR2V0V2luZG93V29yZChIV05ELHNob3J0KTsKLVdPUkQgR2V0V2luZG93c0RpcmVjdG9yeShMUFNUUixXT1JEKTsKK1VJTlQgR2V0V2luZG93c0RpcmVjdG9yeShMUFNUUixVSU5UKTsKIFdPUkQgR2xvYmFsRE9TRnJlZShXT1JEKTsKIFdPUkQgR2xvYmFsRmxhZ3MoSEdMT0JBTCk7CiBXT1JEIEdsb2JhbEdldEF0b21OYW1lKEFUT00sTFBTVFIsc2hvcnQpOwpAQCAtMjkyNyw3ICsyOTM4LDcgQEAKIFdPUkQgU2V0VGltZXIoSFdORCxXT1JELFdPUkQsRkFSUFJPQyk7CiBXT1JEIFNldFdpbmRvd1dvcmQoSFdORCxzaG9ydCxXT1JEKTsKIFdPUkQgVmtLZXlTY2FuKFdPUkQpOwotV09SRCogU2V0Q29tbUV2ZW50TWFzayhpbnQsV09SRCk7CitVSU5UKiBTZXRDb21tRXZlbnRNYXNrKGludCxVSU5UKTsKIGludCBCdWlsZENvbW1EQ0IoTFBTVFIsRENCKik7CiBpbnQgQ2F0Y2goTFBDQVRDSEJVRik7CiBpbnQgQ2xlYXJDb21tQnJlYWsoaW50KTsKQEAgLTI5NjksNyArMjk4MCw3IEBACiBpbnQgR2V0S2V5TmFtZVRleHQoTE9ORyxMUFNUUixpbnQpOwogaW50IEdldEtleVN0YXRlKGludCk7CiBpbnQgR2V0S2V5Ym9hcmRUeXBlKGludCk7Ci1pbnQgR2V0TWVudVN0cmluZyhITUVOVSxXT1JELExQU1RSLHNob3J0LFdPUkQpOworaW50IEdldE1lbnVTdHJpbmcoSE1FTlUsVUlOVCxMUFNUUixzaG9ydCxVSU5UKTsKIGludCBHZXRNb2R1bGVGaWxlTmFtZShIQU5ETEUsTFBTVFIsc2hvcnQpOwogaW50IEdldE1vZHVsZVVzYWdlKEhBTkRMRSk7CiBpbnQgR2V0T2JqZWN0KEhBTkRMRSxpbnQsTFBTVFIpOwpAQCAtMjk4OSw3ICszMDAwLDcgQEAKIGludCBNdWxEaXYoaW50LGludCxpbnQpOwogaW50IE9mZnNldENsaXBSZ24oSERDLHNob3J0LHNob3J0KTsKIGludCBPZmZzZXRSZ24oSFJHTixzaG9ydCxzaG9ydCk7Ci1pbnQgT3BlbkNvbW0oTFBTVFIsV09SRCxXT1JEKTsKK2ludCBPcGVuQ29tbShMUFNUUixVSU5ULFVJTlQpOwogaW50IE9wZW5Tb3VuZCh2b2lkKTsKIGludCBQcm9mSW5zQ2hrKHZvaWQpOwogaW50IFJlYWRDb21tKGludCxMUFNUUixpbnQpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS93aW50eXBlcy5oIGIvaW5jbHVkZS93aW50eXBlcy5oCmluZGV4IDM0OGFmMzYuLmZmNzg1ZDEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvd2ludHlwZXMuaAorKysgYi9pbmNsdWRlL3dpbnR5cGVzLmgKQEAgLTksMzIgKzksNDEgQEAKICMgICBkZWZpbmUgV0lORUxJQjMyCiAjICBlbmRpZgogIyBlbmRpZgorI2Vsc2UKKyMgaWZkZWYgV0lORUxJQjMyCisjICB1bmRlZiBXSU5FTElCMTYKKyMgIGRlZmluZSBXSU5FTElCCisjIGVuZGlmCisjIGlmZGVmIFdJTkVMSUIxNgorIyAgZGVmaW5lIFdJTkVMSUIKKyMgZW5kaWYKICNlbmRpZgogCi10eXBlZGVmIHNob3J0CUlOVDsKLXR5cGVkZWYgdW5zaWduZWQgc2hvcnQgVUlOVDsKLSNkZWZpbmUgVUlGTVQgIiVodSIKIHR5cGVkZWYgdW5zaWduZWQgc2hvcnQgV09SRDsKIHR5cGVkZWYgdW5zaWduZWQgbG9uZyBEV09SRDsKIHR5cGVkZWYgdW5zaWduZWQgc2hvcnQgQk9PTDsKIHR5cGVkZWYgdW5zaWduZWQgY2hhciBCWVRFOwogdHlwZWRlZiBsb25nIExPTkc7CiAjaWZkZWYgV0lORUxJQjMyCit0eXBlZGVmIGludCBJTlQ7Cit0eXBlZGVmIHVuc2lnbmVkIGludCBVSU5UOwordHlwZWRlZiBzaG9ydCBTSE9SVDsKIHR5cGVkZWYgTE9ORyBXUEFSQU07Cit0eXBlZGVmIHZvaWQqIEhBTkRMRTsKK3R5cGVkZWYgdm9pZCogTlBWT0lEOworI2RlZmluZSBVSUZNVCAiJXUiCisjZGVmaW5lIE5QRk1UICIlcCIKICNlbHNlCit0eXBlZGVmIHNob3J0IElOVDsKK3R5cGVkZWYgdW5zaWduZWQgc2hvcnQgVUlOVDsKIHR5cGVkZWYgVUlOVCBXUEFSQU07Cit0eXBlZGVmIFdPUkQgSEFORExFOwordHlwZWRlZiBXT1JEIE5QVk9JRDsKKyNkZWZpbmUgVUlGTVQgIiVodSIKKyNkZWZpbmUgTlBGTVQgIiUwNFgiCiAjZW5kaWYKIHR5cGVkZWYgTE9ORyBMUEFSQU07CiB0eXBlZGVmIExPTkcgTFJFU1VMVDsKLSNpZmRlZiBXSU5FTElCMzIKLXR5cGVkZWYgdm9pZCogSEFORExFOwotdHlwZWRlZiB2b2lkKiBOUFZPSUQ7Ci0jZGVmaW5lIE5QRk1UICIlcCIKLSNlbHNlCi10eXBlZGVmIFdPUkQgSEFORExFOwotdHlwZWRlZiBXT1JEIE5QVk9JRDsKLSNkZWZpbmUgTlBGTVQgIiUwNFgiCi0jZW5kaWYKIHR5cGVkZWYgRFdPUkQgSEhPT0s7CiB0eXBlZGVmIERXT1JEIFNFR1BUUjsKIHR5cGVkZWYgY2hhciAqTFBTVFI7CkBAIC00Niw2ICs1NSw3IEBACiB0eXBlZGVmIERXT1JEICpMUERXT1JEOwogdHlwZWRlZiBMT05HICpMUExPTkc7CiB0eXBlZGVmIHZvaWQgKkxQVk9JRDsKK3R5cGVkZWYgY29uc3Qgdm9pZCAqTFBDVk9JRDsKIHR5cGVkZWYgV09SRCBDQVRDSEJVRls5XTsKIHR5cGVkZWYgV09SRCAqTFBDQVRDSEJVRjsKIApAQCAtMTE5LDEyICsxMjksMTIgQEAKICNkZWZpbmUgU0VMRUNUT1JPRihwdHIpICAgICAoSElXT1JEKHB0cikpCiAjZGVmaW5lIE9GRlNFVE9GKHB0cikgICAgICAgKExPV09SRChwdHIpKQogCi0jaWZuZGVmIG1heAotI2RlZmluZSBtYXgoYSxiKSAoKChhKSA+IChiKSkgPyAoYSkgOiAoYikpCisjaWZuZGVmIE1BWAorI2RlZmluZSBNQVgoYSxiKSAoKChhKSA+IChiKSkgPyAoYSkgOiAoYikpCiAjZW5kaWYKIAotI2lmbmRlZiBtaW4KLSNkZWZpbmUgbWluKGEsYikgKCgoYSkgPCAoYikpID8gKGEpIDogKGIpKQorI2lmbmRlZiBNSU4KKyNkZWZpbmUgTUlOKGEsYikgKCgoYSkgPCAoYikpID8gKGEpIDogKGIpKQogI2VuZGlmCiAKICNlbmRpZiAvKiBfX1dJTkVfV0lOVFlQRVNfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94bWFsbG9jLmggYi9pbmNsdWRlL3htYWxsb2MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lOGIxODNkCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS94bWFsbG9jLmgKQEAgLTAsMCArMSw4IEBACisjaWZkZWYgSEFWRV9TVERMSUJfSAorI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2Vsc2UKKyNkZWZpbmUgc2l6ZV90IHVuc2lnbmVkIGludAorI2VuZGlmCisKK3ZvaWQgKnhtYWxsb2MgKHNpemVfdCk7Cit2b2lkICp4cmVhbGxvYyAodm9pZCAqLCBzaXplX3QpOwpkaWZmIC0tZ2l0IGEvaXBjL2RkZV9wcm9jLmMgYi9pcGMvZGRlX3Byb2MuYwppbmRleCBkZjZlNmE4Li5jNzJmMzcxIDEwMDY0NAotLS0gYS9pcGMvZGRlX3Byb2MuYworKysgYi9pcGMvZGRlX3Byb2MuYwpAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgImRkZS5oIgogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIGludCBjdXJyX3Byb2NfaWR4PSAtMTsKIApAQCAtNzMsNyArNzQsNyBAQAogewogICBmaWZvX2VsZW1lbnQgKmNyZWF0ZWQ7CiAKLSAgY3JlYXRlZD0gKGZpZm9fZWxlbWVudCopIG1hbGxvYyggc2l6ZW9mKGZpZm9fZWxlbWVudCkgKTsKKyAgY3JlYXRlZD0gKGZpZm9fZWxlbWVudCopIHhtYWxsb2MoIHNpemVvZihmaWZvX2VsZW1lbnQpICk7CiAgIGNyZWF0ZWQtPnZhbHVlID0gdmFsOwogICBjcmVhdGVkLT5uZXh0ID0gTlVMTDsKICAgCmRpZmYgLS1naXQgYS9pcGMvc2htX2Jsb2NrLmMgYi9pcGMvc2htX2Jsb2NrLmMKaW5kZXggMjU5Mzc4Zi4uNmE1MTA2YiAxMDA2NDQKLS0tIGEvaXBjL3NobV9ibG9jay5jCisrKyBiL2lwYy9zaG1fYmxvY2suYwpAQCAtMjQsNiArMjQsNyBAQAogI2luY2x1ZGUgInNobV9ibG9jay5oIgogI2luY2x1ZGUgInNobV9zZW1hcGguaCIKICNpbmNsdWRlICJkZGVfcHJvYy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogLyogSG93IGVhY2ggc2htaWQgaXMgbWFwZWQgdG8gbG9jYWwgcG9pbnRlciAqLwogLyogT25seSBhdHRhY2hlZCBzaG0gYmxvY2tzIGFyZSBpbiB0aGlzIGNvbnN0cnVjdCAqLwpAQCAtNzksNyArODAsNyBAQAogICBibG9jaz0oc3RydWN0IHNobV9ibG9jayopc2htYXQoc2htX2lkLCBOVUxMLCAwKTsKICAgaWYgKGJsb2NrPT1OVUxMIHx8IGJsb2NrID09IChzdHJ1Y3Qgc2htX2Jsb2NrKikgLTEpIHJldHVybiBOVUxMOwogCi0gIHRoaXM9KHN0cnVjdCBsb2NhbF9zaG1fbWFwICopbWFsbG9jKHNpemVvZigqdGhpcykpOworICB0aGlzPShzdHJ1Y3QgbG9jYWxfc2htX21hcCAqKXhtYWxsb2Moc2l6ZW9mKCp0aGlzKSk7CiAgIHRoaXMtPm5leHQ9IHNobV9tYXA7CiAgIHNobV9tYXAgICA9IHRoaXM7CiAgIHRoaXMtPnNobV9pZD0gc2htX2lkOwpkaWZmIC0tZ2l0IGEvaXBjL3NobV9mcmFnbWVudF90ZXN0LmMgYi9pcGMvc2htX2ZyYWdtZW50X3Rlc3QuYwppbmRleCA4OTY0NzE1Li43MDhkYWQ0IDEwMDY0NAotLS0gYS9pcGMvc2htX2ZyYWdtZW50X3Rlc3QuYworKysgYi9pcGMvc2htX2ZyYWdtZW50X3Rlc3QuYwpAQCAtMTYsNiArMTYsNyBAQAogI2luY2x1ZGUgPHN0cmluZy5oPgogI2luY2x1ZGUgInNobV9ibG9jay5oIgogI2luY2x1ZGUgInNobV9mcmFnbWVudC5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogI2RlZmluZSBET19GUkVFKGlkKSAoLWlkKQogI2RlZmluZSBMSVNUX0xFTkdUSCAyMApAQCAtNjAsOCArNjEsNyBAQAogICAKICAgc3RhdGljIGNoYXIgKnB0cltMSVNUX0xFTkdUSF07CiAgIAotICBibG9jaz1tYWxsb2MoU0hNX01JTkJMT0NLKTsKLSAgYXNzZXJ0KGJsb2NrKTsKKyAgYmxvY2s9eG1hbGxvYyhTSE1fTUlOQkxPQ0spOwogCiAgIC8qIHNldHVwIGZpcnN0IGl0ZW0gaW4gdGhlIGZyZWUgbGlzdCAqLwogICBzaG1fRnJhZ21lbnRJbml0KGJsb2NrLCBzaXplb2YoKmJsb2NrKSwgU0hNX01JTkJMT0NLKTsKZGlmZiAtLWdpdCBhL2xvYWRlci9tYWluLmMgYi9sb2FkZXIvbWFpbi5jCmluZGV4IGRlN2RmMWUuLjA4YWQ3Y2QgMTAwNjQ0Ci0tLSBhL2xvYWRlci9tYWluLmMKKysrIGIvbG9hZGVyL21haW4uYwpAQCAtNTgsMTAgKzU4LDEwIEBACiAKICAgICAgIC8qIEluaXRpYWxpemUgV2luMzIgcmVsYXkgY29kZSAqLwogICAgIGlmICghUkVMQVkzMl9Jbml0KCkpIHJldHVybiAwOwotI2VuZGlmCiAKICAgICAgIC8qIENyZWF0ZSBidWlsdC1pbiBtb2R1bGVzICovCiAgICAgaWYgKCFNT0RVTEVfSW5pdCgpKSByZXR1cm4gMDsKKyNlbmRpZgogCiAgICAgICAvKiBJbml0aWFsaXplIHRoZSBET1MgZmlsZSBzeXN0ZW0gKi8KICAgICBET1NfSW5pdEZTKCk7CmRpZmYgLS1naXQgYS9sb2FkZXIvbW9kdWxlLmMgYi9sb2FkZXIvbW9kdWxlLmMKaW5kZXggZTQ4ZWQwMy4uNzE4NmM5MyAxMDA2NDQKLS0tIGEvbG9hZGVyL21vZHVsZS5jCisrKyBiL2xvYWRlci9tb2R1bGUuYwpAQCAtMjQsMjAgKzI0LDIyIEBACiAjaW5jbHVkZSAiZGVidWcuaCIKIAogI2luY2x1ZGUgImNhbGxiYWNrLmgiCisjaW5jbHVkZSAid2luZS5oIgogCiBzdGF0aWMgSE1PRFVMRSBoRmlyc3RNb2R1bGUgPSAwOwogc3RhdGljIEhNT0RVTEUgaENhY2hlZE1vZHVsZSA9IDA7ICAvKiBNb2R1bGUgY2FjaGVkIGJ5IE1PRFVMRV9PcGVuRmlsZSAqLwogCiAKK3N0YXRpYyBIQU5ETEUgaEluaXRpYWxTdGFjazMyID0gMDsKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIE1PRFVMRV9Mb2FkQnVpbHRpbgogICoKICAqIExvYWQgYSBidWlsdC1pbiBtb2R1bGUuIElmIHRoZSAnZm9yY2UnIHBhcmFtZXRlciBpcyBGQUxTRSwgd2Ugb25seQogICogbG9hZCB0aGUgbW9kdWxlIGlmIGl0IGhhcyBub3QgYmVlbiBkaXNhYmxlZCB2aWEgdGhlIC1kbGwgb3B0aW9uLgogICovCisjaWZuZGVmIFdJTkVMSUIgLyogSkJQOiBOb3QgcmVhbGx5IGFsbG93ZWQgaW4gbGlid2luZS5hIChGSVhNRTo/KSAqLwogc3RhdGljIEhNT0RVTEUgTU9EVUxFX0xvYWRCdWlsdGluKCBMUENTVFIgbmFtZSwgQk9PTCBmb3JjZSApCiB7Ci0jaWZuZGVmIFdJTkVMSUIgLyogSkJQOiBOb3QgcmVhbGx5IGFsbG93ZWQgaW4gbGlid2luZS5hIChGSVhNRTo/KSAqLwogICAgIEhNT0RVTEUgaE1vZHVsZTsKICAgICBORV9NT0RVTEUgKnBNb2R1bGU7CiAgICAgU0VHVEFCTEVFTlRSWSAqcFNlZ1RhYmxlOwpAQCAtOTEsNyArOTMsNyBAQAogICAgIGhGaXJzdE1vZHVsZSA9IGhNb2R1bGU7CiAgICAgcmV0dXJuIGhNb2R1bGU7CiB9Ci0KKyNlbmRpZgogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICBNT0RVTEVfSW5pdApAQCAtMTAyLDYgKzEwNCw3IEBACiB7CiAgICAgLyogRm9yIHRoZXNlLCBidWlsdC1pbiBtb2R1bGVzIGFyZSBhbHdheXMgdXNlZCAqLwogCisjaWZuZGVmIFdJTkVMSUIzMgogICAgIGlmICghTU9EVUxFX0xvYWRCdWlsdGluKCAiS0VSTkVMIiwgVFJVRSApIHx8CiAgICAgICAgICFNT0RVTEVfTG9hZEJ1aWx0aW4oICJHREkiLCBUUlVFICkgfHwKICAgICAgICAgIU1PRFVMRV9Mb2FkQnVpbHRpbiggIlVTRVIiLCBUUlVFICkgfHwKQEAgLTMxNyw2ICszMjAsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgICAgICAgICAgTU9EVUxFX0NyZWF0ZVNlZ21lbnRzCiAgKi8KKyNpZm5kZWYgV0lORUxJQjMyCiBzdGF0aWMgQk9PTCBNT0RVTEVfQ3JlYXRlU2VnbWVudHMoIEhNT0RVTEUgaE1vZHVsZSApCiB7CiAgICAgU0VHVEFCTEVFTlRSWSAqcFNlZ21lbnQ7CkBAIC0zNDMsMTEgKzM0NywxMyBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIChwTW9kdWxlLT5kZ3JvdXAgLSAxKSAqIHNpemVvZihTRUdUQUJMRUVOVFJZKSA6IDA7CiAgICAgcmV0dXJuIFRSVUU7CiB9CisjZW5kaWYKIAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICBNT0RVTEVfR2V0SW5zdGFuY2UKICAqLworI2lmbmRlZiBXSU5FTElCMzIKIHN0YXRpYyBISU5TVEFOQ0UgTU9EVUxFX0dldEluc3RhbmNlKCBITU9EVUxFIGhNb2R1bGUgKQogewogICAgIFNFR1RBQkxFRU5UUlkgKnBTZWdtZW50OwpAQCAtMzYwLDYgKzM2Niw3IEBACiAgICAgCiAgICAgcmV0dXJuIHBTZWdtZW50LT5zZWxlY3RvcjsKIH0KKyNlbmRpZgogCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgpAQCAtNzk1LDcgKzgwMiw3IEBACiAKICAgICBpZiAoIShwTW9kdWxlID0gKE5FX01PRFVMRSAqKUdsb2JhbExvY2soIGhNb2R1bGUgKSkpIHJldHVybiBOVUxMOwogICAgIHAgPSAoQllURSAqKXBNb2R1bGUgKyBwTW9kdWxlLT5uYW1lX3RhYmxlOwotICAgIGxlbiA9IG1pbiggKnAsIDggKTsKKyAgICBsZW4gPSBNSU4oICpwLCA4ICk7CiAgICAgbWVtY3B5KCBidWZmZXIsIHAgKyAxLCBsZW4gKTsKICAgICBidWZmZXJbbGVuXSA9ICdcMCc7CiAgICAgcmV0dXJuIGJ1ZmZlcjsKQEAgLTEwMjMsNiArMTAzMCwzMyBAQAogCQlvbGRzcCA9IElGMTYzMl9TYXZlZDE2X3NwOwogCQlJRjE2MzJfU2F2ZWQxNl9zcyA9IHBNb2R1bGUtPnNlbGZfbG9hZGluZ19zZWw7CiAJCUlGMTYzMl9TYXZlZDE2X3NwID0gMHhGRjAwOworCQlpZiAoIUlGMTYzMl9TdGFjazMyX2Jhc2UpIHsKKwkJICBTVEFDSzMyRlJBTUUqIGZyYW1lMzI7CisJCSAgY2hhciAqc3RhY2szMlRvcDsKKwkJICAvKiBTZXR1cCBhbiBpbml0aWFsIDMyIGJpdCBzdGFjayBmcmFtZSAqLworCQkgIGhJbml0aWFsU3RhY2szMiA9ICBHTE9CQUxfQWxsb2MoIEdNRU1fRklYRUQsIDB4MTAwMDAsCisJCQkJCQkgIGhNb2R1bGUsIEZBTFNFLCBGQUxTRSwgCisJCQkJCQkgIEZBTFNFICk7CisKKwkJICAvKiBDcmVhdGUgdGhlIDMyLWJpdCBzdGFjayBmcmFtZSAqLworCQkgIAorCQkgICooRFdPUkQgKilHbG9iYWxMb2NrKGhJbml0aWFsU3RhY2szMikgPSAweERFQURCRUVGOworCQkgIHN0YWNrMzJUb3AgPSAoY2hhciopR2xvYmFsTG9jayhoSW5pdGlhbFN0YWNrMzIpICsgCisJCSAgICAweDEwMDAwOworCQkgIGZyYW1lMzIgPSAoU1RBQ0szMkZSQU1FICopc3RhY2szMlRvcCAtIDE7CisJCSAgZnJhbWUzMi0+c2F2ZWRfZXNwID0gKERXT1JEKXN0YWNrMzJUb3A7CisJCSAgZnJhbWUzMi0+ZWRpID0gMDsKKwkJICBmcmFtZTMyLT5lc2kgPSAwOworCQkgIGZyYW1lMzItPmVkeCA9IDA7CisJCSAgZnJhbWUzMi0+ZWN4ID0gMDsKKwkJICBmcmFtZTMyLT5lYnggPSAwOworCQkgIGZyYW1lMzItPmVicCA9IDA7CisJCSAgZnJhbWUzMi0+cmV0YWRkciA9IDA7CisJCSAgZnJhbWUzMi0+Y29kZXNlbGVjdG9yID0gV0lORV9DT0RFX1NFTEVDVE9SOworCQkgIC8qIHBUYXNrLT5lc3AgPSAoRFdPUkQpZnJhbWUzMjsgKi8KKwkJICBJRjE2MzJfU3RhY2szMl9iYXNlID0gV0lOMTZfR2xvYmFsTG9jayhoSW5pdGlhbFN0YWNrMzIpOworCisJCX0KIAkJQ2FsbFRvMTZfd29yZF93dyAoc2VsZmxvYWRoZWFkZXItPkJvb3RBcHAsCiAJCQlwTW9kdWxlLT5zZWxmX2xvYWRpbmdfc2VsLCBoTW9kdWxlLCBmZCk7CiAJCS8qIHNvbWUgQm9vdEFwcCBwcm9jcyBvdmVyd3JpdGUgdGhlIHNlbGVjdG9yIG9mIGRncm91cCAqLwpAQCAtMTAzMCw2ICsxMDY0LDExIEBACiAJCUlGMTYzMl9TYXZlZDE2X3NzID0gb2xkc3M7CiAJCUlGMTYzMl9TYXZlZDE2X3NwID0gb2xkc3A7CiAJCWZvciAoaSA9IDI7IGkgPD0gcE1vZHVsZS0+c2VnX2NvdW50OyBpKyspIE5FX0xvYWRTZWdtZW50KCBoTW9kdWxlLCBpICk7CisJCWlmIChoSW5pdGlhbFN0YWNrMzIpeworCQkgIEdsb2JhbFVubG9jayAoaEluaXRpYWxTdGFjazMyKTsKKwkJICBHbG9iYWxGcmVlIChoSW5pdGlhbFN0YWNrMzIpOworCQkgIElGMTYzMl9TdGFjazMyX2Jhc2UgPSBoSW5pdGlhbFN0YWNrMzIgPSAwOworCQl9CiAJfSAKIAllbHNlCiAgICAgICAgIHsKQEAgLTEyMjksMTMgKzEyNjgsMjggQEAKICAgICBoYW5kbGUgPSBMb2FkTW9kdWxlKCBmaWxlbmFtZSwgJnBhcmFtcyApOwogICAgIGlmIChoYW5kbGUgPT0gKEhBTkRMRSkyKSAgLyogZmlsZSBub3QgZm91bmQgKi8KICAgICB7CisJLyogQ2hlY2sgdGhhdCB0aGUgb3JpZ2luYWwgZmlsZSBuYW1lIGRpZCBub3QgaGF2ZSBhIHN1ZmZpeCAqLworCXAgPSBzdHJyY2hyKGZpbGVuYW1lLCAnLicpOworICAgICAgICBpZiAocCAmJiAhKHN0cmNocihwLCAnLycpIHx8IHN0cmNocihwLCAnXFwnKSkpCisgICAgICAgICAgICByZXR1cm4gaGFuZGxlOyAgLyogZmlsZW5hbWUgYWxyZWFkeSBpbmNsdWRlcyBhIHN1ZmZpeCEgKi8KICAgICAgICAgc3RyY2F0KCBmaWxlbmFtZSwgIi5leGUiICk7CiAgICAgICAgIGhhbmRsZSA9IExvYWRNb2R1bGUoIGZpbGVuYW1lLCAmcGFyYW1zICk7CiAgICAgfQogCiAgICAgR2xvYmFsRnJlZSggY21kU2hvd0hhbmRsZSApOwogICAgIEdsb2JhbEZyZWUoIGNtZExpbmVIYW5kbGUgKTsKLSAgICBZaWVsZCgpOwkvKiBwcm9ncmFtIGlzIGV4ZWN1dGVkIGltbWVkaWF0bHkgLi4uLm5lZWRlZCBmb3Igd29yZCAqLworCisjaWYgMAorICAgIGlmIChoYW5kbGUgPCAoSEFORExFKTMyKQkvKiBFcnJvcj8gKi8KKwlyZXR1cm4gaGFuZGxlOworICAgIAorLyogRklYTUU6IFlpZWxkIG5ldmVyIHJldHVybnMhIAorICAgV2UgbWF5IHdhbnQgdG8gcnVuIG1vcmUgYXBwbGljYXRpb25zIG9yIHN0YXJ0IHRoZSBkZWJ1Z2dlcgorICAgYmVmb3JlIGNhbGxpbmcgWWllbGQuIElmIHdlIGRvbid0IFlpZWxkIHdpbGwgYmUgY2FsbGVkIGltbWRpYXRlbHkKKyAgIGFmdGVyIHJldHVybmluZy4gIFdoeSBpcyBpdCBuZWVkZWQgZm9yIFdvcmQgYW55d2F5PyAqLworICAgIFlpZWxkKCk7CS8qIHByb2dyYW0gaXMgZXhlY3V0ZWQgaW1tZWRpYXRlbHkgLi4uLm5lZWRlZCBmb3Igd29yZCAqLworCisjZW5kaWYKICAgICByZXR1cm4gaGFuZGxlOwogfQogCmRpZmYgLS1naXQgYS9sb2FkZXIvbmVfaW1hZ2UuYyBiL2xvYWRlci9uZV9pbWFnZS5jCmluZGV4IDkxNjdhOTkuLjk3NzQ4MTcgMTAwNjQ0Ci0tLSBhL2xvYWRlci9uZV9pbWFnZS5jCisrKyBiL2xvYWRlci9uZV9pbWFnZS5jCkBAIC0yNCw2ICsyNCw3IEBACiAjaW5jbHVkZSAic3RhY2tmcmFtZS5oIgogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCkBAIC0xMDcsNyArMTA4LDcgQEAKIAkgYnV0IG1heSBiZSBtaXNzaW5nIHNvbWV0aGluZy4gSWYgeW91IGhhdmUgYW55IGRvY28gcGxlYXNlIGVpdGhlciBzZW5kCiAJIGl0IHRvIG1lIG9yIGZpeCB0aGUgY29kZSB5b3Vyc2VsZi4gZ2ZtQHdlcnBsZS5taXJhLm5ldC5hdQogICAgICAgKi8KLSAgICAgIGNoYXIqIGJ1ZmYgPSBtYWxsb2Moc2l6ZSk7CisgICAgICBjaGFyKiBidWZmID0geG1hbGxvYyhzaXplKTsKICAgICAgIGNoYXIqIGN1cnIgPSBidWZmOwogICAgICAgcmVhZChmZCwgYnVmZiwgc2l6ZSk7CiAgICAgICB3aGlsZShjdXJyIDwgYnVmZiArIHNpemUpIHsKQEAgLTEzNyw3ICsxMzgsNyBAQAogICAgICAgICAgICAgICAgICAgIChjaGFyICopcE1vZHVsZSArIHBNb2R1bGUtPm5hbWVfdGFibGUgKyAxLAogICAgICAgICAgICAgICAgICAgIHNlZ251bSwgcFNlZy0+c2VsZWN0b3IgKTsKIAotICAgIHJlbG9jX2VudHJpZXMgPSAoc3RydWN0IHJlbG9jYXRpb25fZW50cnlfcyAqKW1hbGxvYyhjb3VudCAqIHNpemVvZihzdHJ1Y3QgcmVsb2NhdGlvbl9lbnRyeV9zKSk7CisgICAgcmVsb2NfZW50cmllcyA9IChzdHJ1Y3QgcmVsb2NhdGlvbl9lbnRyeV9zICopeG1hbGxvYyhjb3VudCAqIHNpemVvZihzdHJ1Y3QgcmVsb2NhdGlvbl9lbnRyeV9zKSk7CiAgICAgaWYgKHJlYWQoIGZkLCByZWxvY19lbnRyaWVzLCBjb3VudCAqIHNpemVvZihzdHJ1Y3QgcmVsb2NhdGlvbl9lbnRyeV9zKSkgIT0KICAgICAgICAgICAgIGNvdW50ICogc2l6ZW9mKHN0cnVjdCByZWxvY2F0aW9uX2VudHJ5X3MpKQogICAgIHsKZGlmZiAtLWdpdCBhL2xvYWRlci9wZV9pbWFnZS5jIGIvbG9hZGVyL3BlX2ltYWdlLmMKaW5kZXggMTgxMTdjZC4uNDdjOWQ4NyAxMDA2NDQKLS0tIGEvbG9hZGVyL3BlX2ltYWdlLmMKKysrIGIvbG9hZGVyL3BlX2ltYWdlLmMKQEAgLTI4LDYgKzI4LDcgQEAKICNpbmNsdWRlICJzZWxlY3RvcnMuaCIKICNpbmNsdWRlICJzdGRkZWJ1Zy5oIgogI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiAjZGVmaW5lIE1BUF9BTk9OWU1PVVMJMHgyMAogCkBAIC0xODQsMTcgKzE4NSwxNyBAQAogewogCWludCBpLCByZXN1bHQ7CiAKLQl3cG50LT5wZSA9IG1hbGxvYyhzaXplb2Yoc3RydWN0IHBlX2RhdGEpKTsKKwl3cG50LT5wZSA9IHhtYWxsb2Moc2l6ZW9mKHN0cnVjdCBwZV9kYXRhKSk7CiAJbWVtc2V0KHdwbnQtPnBlLDAsc2l6ZW9mKHN0cnVjdCBwZV9kYXRhKSk7Ci0Jd3BudC0+cGUtPnBlX2hlYWRlciA9IG1hbGxvYyhzaXplb2Yoc3RydWN0IHBlX2hlYWRlcl9zKSk7CisJd3BudC0+cGUtPnBlX2hlYWRlciA9IHhtYWxsb2Moc2l6ZW9mKHN0cnVjdCBwZV9oZWFkZXJfcykpOwogCiAJLyogcmVhZCBQRSBoZWFkZXIgKi8KIAlsc2Vlayh3cG50LT5mZCwgd3BudC0+bXpfaGVhZGVyLT5uZV9vZmZzZXQsIFNFRUtfU0VUKTsKIAlyZWFkKHdwbnQtPmZkLCB3cG50LT5wZS0+cGVfaGVhZGVyLCBzaXplb2Yoc3RydWN0IHBlX2hlYWRlcl9zKSk7CiAKIAkvKiByZWFkIHNlY3Rpb25zICovCi0Jd3BudC0+cGUtPnBlX3NlZyA9IG1hbGxvYyhzaXplb2Yoc3RydWN0IHBlX3NlZ21lbnRfdGFibGUpICogCi0JCQkJd3BudC0+cGUtPnBlX2hlYWRlci0+Y29mZi5OdW1iZXJPZlNlY3Rpb25zKTsKKwl3cG50LT5wZS0+cGVfc2VnID0geG1hbGxvYyhzaXplb2Yoc3RydWN0IHBlX3NlZ21lbnRfdGFibGUpICogCisJCQkJICAgd3BudC0+cGUtPnBlX2hlYWRlci0+Y29mZi5OdW1iZXJPZlNlY3Rpb25zKTsKIAlyZWFkKHdwbnQtPmZkLCB3cG50LT5wZS0+cGVfc2VnLCBzaXplb2Yoc3RydWN0IHBlX3NlZ21lbnRfdGFibGUpICogCiAJCQl3cG50LT5wZS0+cGVfaGVhZGVyLT5jb2ZmLk51bWJlck9mU2VjdGlvbnMpOwogCkBAIC0yNjEsNyArMjYyLDcgQEAKIAogCUFMSUFTX1VzZUFsaWFzZXM9MTsKIAotCXdwbnQ9bWFsbG9jKHNpemVvZihzdHJ1Y3Qgd19maWxlcykpOworCXdwbnQ9eG1hbGxvYyhzaXplb2Yoc3RydWN0IHdfZmlsZXMpKTsKIAl3cG50LT5uZXh0PXdpbmVfZmlsZXM7CiAJd2luZV9maWxlcz13cG50OwogCXdwbnQtPm9mcz0qb2ZzOwpAQCAtMjcxLDcgKzI3Miw3IEBACiAJd3BudC0+aE1vZHVsZT0wOwogCXdwbnQtPmluaXRpYWxpc2VkPTA7CiAJbHNlZWsoZmQsMCxTRUVLX1NFVCk7Ci0Jd3BudC0+bXpfaGVhZGVyPW1hbGxvYyhzaXplb2Yoc3RydWN0IG16X2hlYWRlcl9zKSk7CisJd3BudC0+bXpfaGVhZGVyPXhtYWxsb2Moc2l6ZW9mKHN0cnVjdCBtel9oZWFkZXJfcykpOwogCXJlYWQoZmQsd3BudC0+bXpfaGVhZGVyLHNpemVvZihzdHJ1Y3QgbXpfaGVhZGVyX3MpKTsKIAogCXNpemU9c2l6ZW9mKE5FX01PRFVMRSkgKwpkaWZmIC0tZ2l0IGEvbG9hZGVyL3Jlc291cmNlLmMgYi9sb2FkZXIvcmVzb3VyY2UuYwppbmRleCA3YTViNGIxLi40MzdkOGUyIDEwMDY0NAotLS0gYS9sb2FkZXIvcmVzb3VyY2UuYworKysgYi9sb2FkZXIvcmVzb3VyY2UuYwpAQCAtMzYyLDcgKzM2Miw3IEBACiAgICAgCiAgICAgZHByaW50Zl9yZXNvdXJjZSggc3RkZGViLCAic3RybGVuID0gJWRcbiIsIChpbnQpKnAgKTsKICAgICAKLSAgICBpID0gbWluKGJ1ZmxlbiAtIDEsICpwKTsKKyAgICBpID0gTUlOKGJ1ZmxlbiAtIDEsICpwKTsKICAgICBpZiAoYnVmZmVyID09IE5VTEwpCiAJcmV0dXJuIGk7CiAgICAgaWYgKGkgPiAwKSB7CmRpZmYgLS1naXQgYS9sb2FkZXIvc2lnbmFsLmMgYi9sb2FkZXIvc2lnbmFsLmMKaW5kZXggM2E1NjBjNS4uOGEzMWI4ZCAxMDA2NDQKLS0tIGEvbG9hZGVyL3NpZ25hbC5jCisrKyBiL2xvYWRlci9zaWduYWwuYwpAQCAtMTgsNiArMTgsNyBAQAogI2luY2x1ZGUgIm1pc2NlbXUuaCIKICNpbmNsdWRlICJyZWdpc3RlcnMuaCIKICNpbmNsdWRlICJ3aW4uaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKICNpZiAhZGVmaW5lZChCU0Q0XzQpIHx8IGRlZmluZWQobGludXgpIHx8IGRlZmluZWQoX19GcmVlQlNEX18pCiBjaGFyICogY3N0YWNrWzQwOTZdOwpAQCAtNTcsOCArNTgsOCBAQAogICAgIHsKICAgICAgICAgaWYgKENTX3JlZyhjb250ZXh0KSA9PSBXSU5FX0NPREVfU0VMRUNUT1IpCiAgICAgICAgIHsKLSAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiU2VnbWVudGF0aW9uIGZhdWx0IGluIFdpbmUgcHJvZ3JhbSAoJXg6JWx4KS4iCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIiAgUGxlYXNlIGRlYnVnXG4iLAorICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJTZWdtZW50YXRpb24gZmF1bHQgaW4gV2luZSBwcm9ncmFtICglMDR4OiUwOGx4KS4iCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiAgUGxlYXNlIGRlYnVnLlxuIiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDU19yZWcoY29udGV4dCksIEVJUF9yZWcoY29udGV4dCkgKTsKICAgICAgICAgfQogICAgICAgICBlbHNlIGlmIChJTlNUUl9FbXVsYXRlSW5zdHJ1Y3Rpb24oIGNvbnRleHQgKSkgcmV0dXJuOwpAQCAtMTAwLDE0ICsxMDEsMTAgQEAKICAgICAgICAgc3RydWN0IHNpZ2FsdHN0YWNrIHNzOwogICAgICAgICAKICNpZiAhZGVmaW5lZCAoX19GcmVlQlNEX18pCi0gICAgICAgIGlmICgoc3Muc3NfYmFzZSA9IG1hbGxvYyhNSU5TSUdTVEtTWikpID09IE5VTEwpIHsKKyAgICAgICAgc3Muc3NfYmFzZSA9IHhtYWxsb2MgKE1JTlNJR1NUS1NaKTsKICNlbHNlCi0gICAgICAgIGlmICgoc3Muc3Nfc3AgPSBtYWxsb2MoTUlOU0lHU1RLU1opKSA9PSBOVUxMKSB7CisgICAgICAgIHNzLnNzX3NwID0geG1hbGxvYyAoTUlOU0lHU1RLU1opOwogI2VuZGlmCi0JICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlVuYWJsZSB0byBhbGxvY2F0ZSBzaWduYWwgc3RhY2sgKCVkIGJ5dGVzKVxuIiwKLQkJICAgICAgICBNSU5TSUdTVEtTWik7Ci0JCWV4aXQoMSk7Ci0JfQogCXNzLnNzX3NpemUgPSBNSU5TSUdTVEtTWjsKICAgICAgICAgc3Muc3NfZmxhZ3MgPSAwOwogICAgICAgICBpZiAoc2lnYWx0c3RhY2soJnNzLCBOVUxMKSA8IDApIHsKZGlmZiAtLWdpdCBhL21lbW9yeS9sb2NhbC5jIGIvbWVtb3J5L2xvY2FsLmMKaW5kZXggOWYyMTVhZi4uZTIwYmQ5YyAxMDA2NDQKLS0tIGEvbWVtb3J5L2xvY2FsLmMKKysrIGIvbWVtb3J5L2xvY2FsLmMKQEAgLTMyOCw3ICszMjgsNyBAQAogICAgIH0KICAgICBwdHIgPSBQVFJfU0VHX09GRl9UT19MSU4oIHNlbGVjdG9yLCAwICk7CiAKLSAgICBzdGFydCA9IExBTElHTiggbWF4KCBzdGFydCwgc2l6ZW9mKElOU1RBTkNFREFUQSkgKSApOworICAgIHN0YXJ0ID0gTEFMSUdOKCBNQVgoIHN0YXJ0LCBzaXplb2YoSU5TVEFOQ0VEQVRBKSApICk7CiAgICAgaGVhcEluZm9BcmVuYSA9IExBTElHTihzdGFydCArIHNpemVvZihMT0NBTEFSRU5BKSApOwogICAgIGZyZWVBcmVuYSA9IExBTElHTiggaGVhcEluZm9BcmVuYSArIEFSRU5BX0hFQURFUl9TSVpFCiAgICAgICAgICAgICAgICAgICAgICAgICArIHNpemVvZihMT0NBTEhFQVBJTkZPKSApOwpAQCAtNTIxLDcgKzUyMSw3IEBACiAgICAgfQogICAgIAogICAgIHNpemUgKz0gQVJFTkFfSEVBREVSX1NJWkU7Ci0gICAgc2l6ZSA9IExBTElHTiggbWF4KCBzaXplLCBzaXplb2YoTE9DQUxBUkVOQSkgKSApOworICAgIHNpemUgPSBMQUxJR04oIE1BWCggc2l6ZSwgc2l6ZW9mKExPQ0FMQVJFTkEpICkgKTsKIAogICAgICAgLyogRmluZCBhIHN1aXRhYmxlIGZyZWUgYmxvY2sgKi8KICAgICBhcmVuYSA9IExPQ0FMX0ZpbmRGcmVlQmxvY2soIGRzLCBzaXplICk7CkBAIC03NDAsNiArNzQwLDggQEAKICAgICBXT1JEIGFyZW5hLCBuZXdoYW5kbGUsIGJsb2NraGFuZGxlOwogICAgIExPTkcgbmV4dGFyZW5hOwogCisgICAgaWYgKCFoYW5kbGUpIHJldHVybiBMT0NBTF9BbGxvYyggZHMsIHNpemUsIGZsYWdzICk7CisKICAgICBkcHJpbnRmX2xvY2FsKCBzdGRkZWIsICJMb2NhbFJlQWxsb2M6ICUwNHggJWQgJTA0eCBkcz0lMDR4XG4iLAogICAgICAgICAgICAgICAgICAgIGhhbmRsZSwgc2l6ZSwgZmxhZ3MsIGRzICk7CiAgICAgaWYgKCEocEluZm8gPSBMT0NBTF9HZXRIZWFwKCBkcyApKSkgcmV0dXJuIDA7CkBAIC05MDQsOSArOTA2LDkgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIExvY2FsUmVBbGxvYyAgIChLRVJORUwuNikKICAqLwotSExPQ0FMIExvY2FsUmVBbGxvYyggSExPQ0FMIGhhbmRsZSwgV09SRCBmbGFncywgV09SRCBzaXplICkKK0hMT0NBTCBMb2NhbFJlQWxsb2MoIEhMT0NBTCBoYW5kbGUsIFdPUkQgc2l6ZSwgV09SRCBmbGFncyApCiB7Ci0gICAgcmV0dXJuIExPQ0FMX1JlQWxsb2MoIENVUlJFTlRfRFMsIGhhbmRsZSwgZmxhZ3MsIHNpemUgKTsKKyAgICByZXR1cm4gTE9DQUxfUmVBbGxvYyggQ1VSUkVOVF9EUywgaGFuZGxlLCBzaXplLCBmbGFncyApOwogfQogCiAKZGlmZiAtLWdpdCBhL21pc2MvTWFrZWZpbGUuaW4gYi9taXNjL01ha2VmaWxlLmluCmluZGV4IDc3OGUzMzEuLjI2YWMwMmQgMTAwNjQ0Ci0tLSBhL21pc2MvTWFrZWZpbGUuaW4KKysrIGIvbWlzYy9NYWtlZmlsZS5pbgpAQCAtMjgsNyArMjgsOCBAQAogCXN0cmVzcy5jIFwKIAl1c2VyLmMgXAogCXVzZXIzMi5jIFwKLQl3aW5zb2NrZXQuYworCXdpbnNvY2tldC5jIFwKKwl4bWFsbG9jLmMKIAogYWxsOiBjaGVja3JjICQoTU9EVUxFKS5vCiAKZGlmZiAtLWdpdCBhL21pc2MvY2xpcGJvYXJkLmMgYi9taXNjL2NsaXBib2FyZC5jCmluZGV4IGQzZGY1OWQuLjY4ZjVmZTcgMTAwNjQ0Ci0tLSBhL21pc2MvY2xpcGJvYXJkLmMKKysrIGIvbWlzYy9jbGlwYm9hcmQuYwpAQCAtMjY1LDcgKzI2NSw3IEBACiAgICAgaWYgKGxwRm9ybWF0LT5OYW1lID09IE5VTEwpIHJldHVybiAwOwogICAgIGRwcmludGZfY2xpcGJvYXJkKHN0ZGRlYiwKIAkJIkdldENsaXBib2FyZEZvcm1hdCAvLyBOYW1lPSclcycgIVxuIiwgbHBGb3JtYXQtPk5hbWUpOwotICAgIG1heGxlbiA9IG1pbihtYXhsZW4gLSAxLCBzdHJsZW4obHBGb3JtYXQtPk5hbWUpKTsKKyAgICBtYXhsZW4gPSBNSU4obWF4bGVuIC0gMSwgc3RybGVuKGxwRm9ybWF0LT5OYW1lKSk7CiAgICAgZHByaW50Zl9jbGlwYm9hcmQoc3RkZGViLCJHZXRDbGlwYm9hcmRGb3JtYXQgLy8gbWF4bGVuPSVkICFcbiIsIG1heGxlbik7CiAgICAgbWVtY3B5KHJldFN0ciwgbHBGb3JtYXQtPk5hbWUsIG1heGxlbik7CiAgICAgcmV0U3RyW21heGxlbl0gPSAwOwpkaWZmIC0tZ2l0IGEvbWlzYy9jb21tZGxnLmMgYi9taXNjL2NvbW1kbGcuYwppbmRleCBmODU2MjRmLi41Yjg2YWQzIDEwMDY0NAotLS0gYS9taXNjL2NvbW1kbGcuYworKysgYi9taXNjL2NvbW1kbGcuYwpAQCAtMTcxLDkgKzE3MSw5IEBACiB7CiAgIGNoYXIgc3RyWzUxMl0sc3RyMls1MTJdOwogCi0gIHN0cmNweShzdHIsbmV3UGF0aCk7CisgIHN0cm5jcHkoc3RyLG5ld1BhdGgsNTExKTsgc3RyWzUxMV09MDsKICAgU2VuZERsZ0l0ZW1NZXNzYWdlKGhXbmQsIGVkdDEsIFdNX0dFVFRFWFQsIDUxMSwgTUFLRV9TRUdQVFIoc3RyMikpOwotICBzdHJjYXQoc3RyLCBzdHIyKTsKKyAgc3RybmNhdChzdHIsc3RyMiw1MTEtc3RybGVuKHN0cikpOyBzdHJbNTExXT0wOwogICBpZiAoIURsZ0Rpckxpc3QoaFduZCwgc3RyLCBsc3QxLCAwLCAweDAwMDApKSByZXR1cm4gRkFMU0U7CiAgIERsZ0Rpckxpc3QoaFduZCwgIiouKiIsIGxzdDIsIHN0YzEsIDB4ODAxMCk7CiAgIApAQCAtMjEwLDcgKzIxMCw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRklMRURMR19XTURyYXdJdGVtICAgICAgICAgICAgICBbaW50ZXJuYWxdCiAgKi8KLXN0YXRpYyBMT05HIEZJTEVETEdfV01EcmF3SXRlbShIV05EIGhXbmQsIFdPUkQgd1BhcmFtLCBMT05HIGxQYXJhbSkKK3N0YXRpYyBMT05HIEZJTEVETEdfV01EcmF3SXRlbShIV05EIGhXbmQsIFdQQVJBTSB3UGFyYW0sIExQQVJBTSBsUGFyYW0pCiB7CiAgICAgTFBEUkFXSVRFTVNUUlVDVCBscGRpcyA9IChMUERSQVdJVEVNU1RSVUNUKVBUUl9TRUdfVE9fTElOKGxQYXJhbSk7CiAgICAgY2hhciBzdHJbNTEyXTsKQEAgLTIxOSw3ICsyMTksNyBAQAogICAgIEJJVE1BUCBibTsKICAgICBIREMgaE1lbURDOwogCi0gICAgc3RyY3B5KHN0ciwgIiIpOworICAgIHN0clswXT0wOwogICAgIGlmIChscGRpcy0+Q3RsVHlwZSA9PSBPRFRfTElTVEJPWCAmJiBscGRpcy0+Q3RsSUQgPT0gbHN0MSkgewogCWhCcnVzaCA9IFNlbGVjdE9iamVjdChscGRpcy0+aERDLCBHZXRTdG9ja09iamVjdChMVEdSQVlfQlJVU0gpKTsKIAlTZWxlY3RPYmplY3QobHBkaXMtPmhEQywgaEJydXNoKTsKQEAgLTI5MCw3ICsyOTAsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEZJTEVETEdfV01NZWFzdXJlSXRlbSAgICAgICAgICAgW2ludGVybmFsXQogICovCi1zdGF0aWMgTE9ORyBGSUxFRExHX1dNTWVhc3VyZUl0ZW0oSFdORCBoV25kLCBXT1JEIHdQYXJhbSwgTE9ORyBsUGFyYW0pIAorc3RhdGljIExPTkcgRklMRURMR19XTU1lYXN1cmVJdGVtKEhXTkQgaFduZCwgV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSkgCiB7CiAgICAgQklUTUFQIGJtOwogICAgIExQTUVBU1VSRUlURU1TVFJVQ1QgbHBtZWFzdXJlOwpAQCAtMzA1LDcgKzMwNSw3IEBACiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEZJTEVETEdfV01Jbml0RGlhbG9nICAgICAgICAgICAgW2ludGVybmFsXQogICovCiAKLXN0YXRpYyBMT05HIEZJTEVETEdfV01Jbml0RGlhbG9nKEhXTkQgaFduZCwgV09SRCB3UGFyYW0sIExPTkcgbFBhcmFtKSAKK3N0YXRpYyBMT05HIEZJTEVETEdfV01Jbml0RGlhbG9nKEhXTkQgaFduZCwgV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSkgCiB7CiAgIGludCBuOwogICBMUE9QRU5GSUxFTkFNRSBscG9mbjsKQEAgLTMyMSw3ICszMjEsNyBAQAogICAgICAgd2hpbGUoKnBzdHIpCiAJewogCSAgbiA9IHN0cmxlbihwc3RyKTsKLQkgIHN0cmNweSh0bXBzdHIsIHBzdHIpOworCSAgc3RybmNweSh0bXBzdHIsIHBzdHIsIDUxMSk7IHRtcHN0cls1MTFdPTA7CiAJICBwcmludGYoImxwc3RyQ3VzdG9tRmlsdGVyIC8vIGFkZCB0bXBzdHI9JyVzJyAiLCB0bXBzdHIpOwogCSAgU2VuZERsZ0l0ZW1NZXNzYWdlKGhXbmQsIGNtYjEsIENCX0FERFNUUklORywgMCwgTUFLRV9TRUdQVFIodG1wc3RyKSk7CiAJICBwc3RyICs9IG4gKyAxOwpAQCAtMzM1LDcgKzMzNSw3IEBACiAgIHdoaWxlKCpwc3RyKQogICAgIHsKICAgICAgIG4gPSBzdHJsZW4ocHN0cik7Ci0gICAgICBzdHJjcHkodG1wc3RyLCBwc3RyKTsKKyAgICAgIHN0cm5jcHkodG1wc3RyLCBwc3RyLCA1MTEpOyB0bXBzdHJbNTExXT0wOwogICAgICAgcHJpbnRmKCJscHN0ckZpbHRlciAvLyBhZGQgdG1wc3RyPSclcycgIiwgdG1wc3RyKTsKICAgICAgIFNlbmREbGdJdGVtTWVzc2FnZShoV25kLCBjbWIxLCBDQl9BRERTVFJJTkcsIDAsIE1BS0VfU0VHUFRSKHRtcHN0cikpOwogICAgICAgcHN0ciArPSBuICsgMTsKQEAgLTM0Nyw4ICszNDcsOSBAQAogICBpZiAobHBvZm4tPm5GaWx0ZXJJbmRleCA9PSAwICYmIGxwb2ZuLT5scHN0ckN1c3RvbUZpbHRlciA9PSAoU0VHUFRSKU5VTEwpCiAgIAlscG9mbi0+bkZpbHRlckluZGV4ID0gMTsKICAgU2VuZERsZ0l0ZW1NZXNzYWdlKGhXbmQsIGNtYjEsIENCX1NFVENVUlNFTCwgbHBvZm4tPm5GaWx0ZXJJbmRleCAtIDEsIDApOyAgICAKLSAgc3RyY3B5KHRtcHN0ciwgRklMRURMR19HZXRGaWxlVHlwZShQVFJfU0VHX1RPX0xJTihscG9mbi0+bHBzdHJDdXN0b21GaWx0ZXIpLAotCSAgICAgUFRSX1NFR19UT19MSU4obHBvZm4tPmxwc3RyRmlsdGVyKSwgbHBvZm4tPm5GaWx0ZXJJbmRleCAtIDEpKTsKKyAgc3RybmNweSh0bXBzdHIsIEZJTEVETEdfR2V0RmlsZVR5cGUoUFRSX1NFR19UT19MSU4obHBvZm4tPmxwc3RyQ3VzdG9tRmlsdGVyKSwKKwkgICAgIFBUUl9TRUdfVE9fTElOKGxwb2ZuLT5scHN0ckZpbHRlciksIGxwb2ZuLT5uRmlsdGVySW5kZXggLSAxKSw1MTEpOworICB0bXBzdHJbNTExXT0wOwogICBwcmludGYoIm5GaWx0ZXJJbmRleCA9ICVsZCAvLyBTZXRUZXh0IG9mIGVkdDEgdG8gJyVzJ1xuIiwgCiAgIAkJCWxwb2ZuLT5uRmlsdGVySW5kZXgsIHRtcHN0cik7CiAgIFNlbmREbGdJdGVtTWVzc2FnZShoV25kLCBlZHQxLCBXTV9TRVRURVhULCAwLCBNQUtFX1NFR1BUUih0bXBzdHIpKTsKQEAgLTM1OCw3ICszNTksOCBAQAogICAvKiByZWFkIGluaXRpYWwgZGlyZWN0b3J5ICovCiAgIGlmIChQVFJfU0VHX1RPX0xJTihscG9mbi0+bHBzdHJJbml0aWFsRGlyKSAhPSBOVUxMKSAKICAgICB7Ci0gICAgICBzdHJjcHkodG1wc3RyLCBQVFJfU0VHX1RPX0xJTihscG9mbi0+bHBzdHJJbml0aWFsRGlyKSk7CisgICAgICBzdHJuY3B5KHRtcHN0ciwgUFRSX1NFR19UT19MSU4obHBvZm4tPmxwc3RySW5pdGlhbERpciksIDUxMCk7CisgICAgICB0bXBzdHJbNTEwXT0wOwogICAgICAgaWYgKHN0cmxlbih0bXBzdHIpID4gMCAmJiB0bXBzdHJbc3RybGVuKHRtcHN0ciktMV0gIT0gJ1xcJyAKIAkgICYmIHRtcHN0cltzdHJsZW4odG1wc3RyKS0xXSAhPSAnOicpCiAJc3RyY2F0KHRtcHN0ciwiXFwiKTsKQEAgLTM4MCw3ICszODIsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEZJTEVETEdfV01Db21tYW5kICAgICAgICAgICAgICAgW2ludGVybmFsXQogICovCi1zdGF0aWMgTE9ORyBGSUxFRExHX1dNQ29tbWFuZChIV05EIGhXbmQsIFdPUkQgd1BhcmFtLCBMT05HIGxQYXJhbSkgCitzdGF0aWMgTFJFU1VMVCBGSUxFRExHX1dNQ29tbWFuZChIV05EIGhXbmQsIFdQQVJBTSB3UGFyYW0sIExQQVJBTSBsUGFyYW0pIAogewogICBMT05HIGxSZXQ7CiAgIExQT1BFTkZJTEVOQU1FIGxwb2ZuOwpAQCAtNDM3LDcgKzQzOSw3IEBACiAgICAgICBwc3RyID0gRklMRURMR19HZXRGaWxlVHlwZShQVFJfU0VHX1RPX0xJTihscG9mbi0+bHBzdHJDdXN0b21GaWx0ZXIpLAogCQkJCSBQVFJfU0VHX1RPX0xJTihscG9mbi0+bHBzdHJGaWx0ZXIpLAogCQkJCSBsUmV0KTsKLSAgICAgIHN0cmNweSh0bXBzdHIyLCBwc3RyKTsgCisgICAgICBzdHJuY3B5KHRtcHN0cjIsIHBzdHIsIDUxMSk7IHRtcHN0cjJbNTExXT0wOwogICAgICAgU2VuZERsZ0l0ZW1NZXNzYWdlKGhXbmQsIGVkdDEsIFdNX1NFVFRFWFQsIDAsIE1BS0VfU0VHUFRSKHRtcHN0cjIpKTsKICAgICAgIEZJTEVETEdfU2NhbkRpcihoV25kLCB0bXBzdHIpOwogICAgICAgcmV0dXJuIFRSVUU7CkBAIC00NTYsMTMgKzQ1OCwxMyBAQAogCSAgLyogZWRpdCBjb250cm9sIGNvbnRhaW5zIHdpbGRjYXJkcyAqLwogCSAgaWYgKHBzdHIgIT0gTlVMTCkKIAkgICAgewotCSAgICAgIHN0cmNweSh0bXBzdHIyLCBwc3RyKzEpOworCSAgICAgIHN0cm5jcHkodG1wc3RyMiwgcHN0cisxLCA1MTEpOyB0bXBzdHIyWzUxMV09MDsKIAkgICAgICAqKHBzdHIrMSkgPSAwOwogCSAgICB9CiAJICBlbHNlCiAJICAgIHsKIAkgICAgICBzdHJjcHkodG1wc3RyMiwgdG1wc3RyKTsKLQkgICAgICBzdHJjcHkodG1wc3RyLCAiIik7CisJICAgICAgKnRtcHN0cj0wOwogCSAgICB9CiAJICBwcmludGYoImNvbW1kbGc6ICVzLCAlc1xuIiwgdG1wc3RyLCB0bXBzdHIyKTsKIAkgIFNlbmREbGdJdGVtTWVzc2FnZShoV25kLCBlZHQxLCBXTV9TRVRURVhULCAwLCBNQUtFX1NFR1BUUih0bXBzdHIyKSk7CkBAIC00NzgsMTAgKzQ4MCwxMSBAQAogICAgICAgaWYgKGxSZXQgPT0gTEJfRVJSKSByZXR1cm4gVFJVRTsKICAgICAgIGxwb2ZuLT5uRmlsdGVySW5kZXggPSBsUmV0ICsgMTsKICAgICAgIHByaW50ZigiY29tbWRsZzogbHBvZm4tPm5GaWx0ZXJJbmRleD0lbGRcbiIsIGxwb2ZuLT5uRmlsdGVySW5kZXgpOwotICAgICAgc3RyY3B5KHRtcHN0cjIsIAorICAgICAgc3RybmNweSh0bXBzdHIyLCAKIAkgICAgIEZJTEVETEdfR2V0RmlsZVR5cGUoUFRSX1NFR19UT19MSU4obHBvZm4tPmxwc3RyQ3VzdG9tRmlsdGVyKSwKIAkJCQkgUFRSX1NFR19UT19MSU4obHBvZm4tPmxwc3RyRmlsdGVyKSwKLQkJCQkgbFJldCkpOworCQkJCSBsUmV0KSwgNTExKTsKKyAgICAgIHRtcHN0cjJbNTExXT0wOwogICAgICAgU2VuZERsZ0l0ZW1NZXNzYWdlKGhXbmQsIGVkdDEsIFdNX1NFVFRFWFQsIDAsIE1BS0VfU0VHUFRSKHRtcHN0cjIpKTsKICAgICAgIC8qIGlmIFNjYW5EaXIgc3VjY2VlZHMsIHdlIGhhdmUgY2hhbmdlZCB0aGUgZGlyZWN0b3J5ICovCiAgICAgICBpZiAoRklMRURMR19TY2FuRGlyKGhXbmQsIHRtcHN0cikpIHJldHVybiBUUlVFOwpAQCAtNDkxLDcgKzQ5NCw3IEBACiAJewogCSAgLyogc3RyaXAgb2ZmIHRoZSBwYXRobmFtZSAqLwogCSAgKnBzdHIgPSAwOwotCSAgc3RyY3B5KHRtcHN0cjIsIHBzdHIrMSk7CisJICBzdHJuY3B5KHRtcHN0cjIsIHBzdHIrMSwgNTExKTsgdG1wc3RyMls1MTFdPTA7CiAJICBTZW5kRGxnSXRlbU1lc3NhZ2UoaFduZCwgZWR0MSwgV01fU0VUVEVYVCwgMCwgTUFLRV9TRUdQVFIodG1wc3RyMikpOwogCSAgLyogU2hvdWxkIHdlIE1lc3NhZ2VCb3goKSBpZiB0aGlzIGZhaWxzPyAqLwogCSAgaWYgKCFGSUxFRExHX1NjYW5EaXIoaFduZCwgdG1wc3RyKSkgcmV0dXJuIFRSVUU7CkBAIC01MDYsMTAgKzUwOSwxMSBAQAogCXRtcHN0cjJbMF0gPSAnQScrIGRyaXZlOwogCXRtcHN0cjJbMV0gPSAnOic7CiAJdG1wc3RyMlsyXSA9ICdcXCc7Ci0Jc3RyY3B5KHRtcHN0cjIgKyAzLCBET1NfR2V0Q3VycmVudERpcihkcml2ZSkpOworCXN0cm5jcHkodG1wc3RyMiArIDMsIERPU19HZXRDdXJyZW50RGlyKGRyaXZlKSwgNTEwKTsgdG1wc3RyMls1MTBdPTA7CiAJaWYgKHN0cmxlbih0bXBzdHIyKSA+IDMpCiAJICBzdHJjYXQodG1wc3RyMiwgIlxcIik7Ci0Jc3RyY2F0KHRtcHN0cjIsIHRtcHN0cik7CisJc3RybmNhdCh0bXBzdHIyLCB0bXBzdHIsIDUxMS1zdHJsZW4odG1wc3RyMikpOyB0bXBzdHIyWzUxMV09MDsKKwlwcmludGYoInN0cmNweSdpbmcgJyVzJ1xuIix0bXBzdHIyKTsgZmZsdXNoKHN0ZG91dCk7CiAJc3RyY3B5KFBUUl9TRUdfVE9fTElOKGxwb2ZuLT5scHN0ckZpbGUpLCB0bXBzdHIyKTsKICAgICAgIH0KICAgICAgIGxwb2ZuLT5uRmlsZU9mZnNldCA9IDA7CkBAIC01MjUsNiArNTI5LDcgQEAKIAkgIGxSZXQgPSBTZW5kRGxnSXRlbU1lc3NhZ2UoaFduZCwgbHN0MSwgTEJfR0VUQ1VSU0VMLCAwLCAwKTsKIAkgIFNlbmREbGdJdGVtTWVzc2FnZShoV25kLCBsc3QxLCBMQl9HRVRURVhULCBsUmV0LAogCQkJICAgICBNQUtFX1NFR1BUUih0bXBzdHIpKTsKKyAgICAgICAgICBwcmludGYoInN0cmNweSdpbmcgJyVzJ1xuIix0bXBzdHIpOyBmZmx1c2goc3Rkb3V0KTsKIAkgIHN0cmNweShQVFJfU0VHX1RPX0xJTihscG9mbi0+bHBzdHJGaWxlVGl0bGUpLCB0bXBzdHIpOwogCX0KICAgICAgIEVuZERpYWxvZyhoV25kLCBUUlVFKTsKQEAgLTg3Myw3ICs4NzgsNyBAQAogCWJyZWFrOwogICAgICAgfQogICBwcmludGYoIlxuLS0tPiAnJXMnICIsICZscEZpbGVbaV0pOwotICBsZW4gPSBtaW4oY2JCdWYsIHN0cmxlbigmbHBGaWxlW2ldKSArIDEpOworICBsZW4gPSBNSU4oY2JCdWYsIHN0cmxlbigmbHBGaWxlW2ldKSArIDEpOwogICBzdHJuY3B5KGxwVGl0bGUsICZscEZpbGVbaV0sIGxlbiArIDEpOwogICBpZiAobGVuICE9IGNiQnVmKQogICAgIHJldHVybiBsZW47CmRpZmYgLS1naXQgYS9taXNjL2Rvc19mcy5jIGIvbWlzYy9kb3NfZnMuYwppbmRleCA2NjY3MDU4Li4xM2Y1MmJmIDEwMDY0NAotLS0gYS9taXNjL2Rvc19mcy5jCisrKyBiL21pc2MvZG9zX2ZzLmMKQEAgLTgsNiArOCw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGN0eXBlLmg+CisjaW5jbHVkZSA8ZXJybm8uaD4KICNpbmNsdWRlIDxzdGRpby5oPgogI2luY2x1ZGUgPHN0ZGxpYi5oPgogI2luY2x1ZGUgPHN0cmluZy5oPgpAQCAtMzUsNiArMzYsNyBAQAogI2luY2x1ZGUgInRhc2suaCIKICNpbmNsdWRlICJzdGRkZWJ1Zy5oIgogI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiAjaWZuZGVmIFdJTkVfSU5JX0dMT0JBTAogLyogR2V0IHRoZSBXSU5FX0lOSV9HTE9CQUwgZGVmaW5pdGlvbiBmcm9tIGF1dG9jb25mLmggKi8KQEAgLTc2NSwxMyArNzY3LDEzIEBACiAJaWYgKG5hbWUpCiAJCXJldHVybiBuYW1lOwogCQkKLQluYW1lID0gbWFsbG9jKDEwMjQpOworCW5hbWUgPSB4bWFsbG9jKDEwMjQpOwogCiAJc3RyY3B5KG5hbWUsIERPU19HZXRVbml4RmlsZU5hbWUoV2luZG93c0RpcmVjdG9yeSkpOwogCXN0cmNhdChuYW1lLCAiLyIpOwogCXN0cmNhdChuYW1lLCAid2luLmluaSIpOwogCi0JbmFtZSA9IHJlYWxsb2MobmFtZSwgc3RybGVuKG5hbWUpICsgMSk7CisJbmFtZSA9IHhyZWFsbG9jKG5hbWUsIHN0cmxlbihuYW1lKSArIDEpOwogCQogCXJldHVybiBuYW1lOwogfQpAQCAtODU4LDkgKzg2MCw5IEBACiAgICAgZm9yICh4PTA7IHggPD0gbWF4X29wZW5fZGlyczsgeCsrKSB7CiAJaWYgKHggPT0gbWF4X29wZW5fZGlycykgewogCSAgICBpZiAoRG9zRGlycykgewotCQlEb3NEaXJzPShzdHJ1Y3QgZG9zZGlyZW50KilyZWFsbG9jKERvc0RpcnMsKCsrbWF4X29wZW5fZGlycykqc2l6ZW9mKERvc0RpcnNbMF0pKTsKKwkJRG9zRGlycz0oc3RydWN0IGRvc2RpcmVudCopeHJlYWxsb2MoRG9zRGlycywoKyttYXhfb3Blbl9kaXJzKSpzaXplb2YoRG9zRGlyc1swXSkpOwogCSAgICB9IGVsc2UgewotCQlEb3NEaXJzPShzdHJ1Y3QgZG9zZGlyZW50KiltYWxsb2Moc2l6ZW9mKERvc0RpcnNbMF0pKTsKKwkJRG9zRGlycz0oc3RydWN0IGRvc2RpcmVudCopeG1hbGxvYyhzaXplb2YoRG9zRGlyc1swXSkpOwogCQltYXhfb3Blbl9kaXJzPTE7CiAJICAgIH0KIAkgICAgYnJlYWs7IC8qIHRoaXMgb25lIGlzIGRlZmluaXRlbHkgbm90IGluIHVzZSAqLwpkaWZmIC0tZ2l0IGEvbWlzYy9maWxlLmMgYi9taXNjL2ZpbGUuYwppbmRleCBiOWJjYzA2Li4xZDE4ZTgzIDEwMDY0NAotLS0gYS9taXNjL2ZpbGUuYworKysgYi9taXNjL2ZpbGUuYwpAQCAtMzUwLDcgKzM1MCw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgR2V0RHJpdmVUeXBlCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotVUlOVCBHZXREcml2ZVR5cGUoSU5UIGRyaXZlKQorV09SRCBHZXREcml2ZVR5cGUoSU5UIGRyaXZlKQogewogCiAgICAgCWRwcmludGZfZmlsZShzdGRkZWIsIkdldERyaXZlVHlwZSAlYzpcbiIsJ0EnK2RyaXZlKTsKZGlmZiAtLWdpdCBhL21pc2MvbWFpbi5jIGIvbWlzYy9tYWluLmMKaW5kZXggZDg4NzZhMS4uOWRlMmZlNyAxMDA2NDQKLS0tIGEvbWlzYy9tYWluLmMKKysrIGIvbWlzYy9tYWluLmMKQEAgLTI3LDYgKzI3LDcgQEAKICNkZWZpbmUgREVCVUdfREVGSU5FX1ZBUklBQkxFUwogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIGNvbnN0IGNoYXIgcGVvcGxlW10gPSAiV2luZSBpcyBhdmFpbGFibGUgdGhhbmtzIHRvIHRoZSB3b3JrIG9mICIKICJCb2IgQW1zdGFkdCwgRGFnIEFzaGVpbSwgTWFydGluIEF5b3R0ZSwgUm9zcyBCaXJvLCBFcmlrIEJvcywgIgpAQCAtMTI1LDExICsxMjYsMTMgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIE1BSU5fVXNhZ2UKICAqLworI2lmbmRlZiBXSU5FTElCMzIKIHN0YXRpYyB2b2lkIE1BSU5fVXNhZ2UoIGNoYXIgKm5hbWUgKQogewogICAgIGZwcmludGYoIHN0ZGVyciwgVVNBR0UsIG5hbWUgKTsKICAgICBleGl0KDEpOwogfQorI2VuZGlmCiAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCkBAIC0xNjUsOCArMTY4LDggQEAKICAgICBjaGFyICpkdW1teTsKICAgICBpbnQgcmV0dmFsOwogCi0gICAgYnVmZl9pbnN0YW5jZSA9IChjaGFyICopbWFsbG9jKHN0cmxlbihPcHRpb25zLnByb2dyYW1OYW1lKStzdHJsZW4obmFtZSkrMSk7Ci0gICAgYnVmZl9jbGFzcyAgICA9IChjaGFyICopbWFsbG9jKCBzdHJsZW4oV0lORV9DTEFTUykgKyBzdHJsZW4obmFtZSkgKyAxICk7CisgICAgYnVmZl9pbnN0YW5jZSA9IChjaGFyICopeG1hbGxvYyhzdHJsZW4oT3B0aW9ucy5wcm9ncmFtTmFtZSkrc3RybGVuKG5hbWUpKzEpOworICAgIGJ1ZmZfY2xhc3MgICAgPSAoY2hhciAqKXhtYWxsb2MoIHN0cmxlbihXSU5FX0NMQVNTKSArIHN0cmxlbihuYW1lKSArIDEgKTsKIAogICAgIHN0cmNweSggYnVmZl9pbnN0YW5jZSwgT3B0aW9ucy5wcm9ncmFtTmFtZSApOwogICAgIHN0cmNhdCggYnVmZl9pbnN0YW5jZSwgbmFtZSApOwpAQCAtMjk5LDcgKzMwMiw3IEBACiAgICAgaWYgKCEoZGlzcGxheSA9IFhPcGVuRGlzcGxheSggZGlzcGxheV9uYW1lICkpKQogICAgIHsKIAlmcHJpbnRmKCBzdGRlcnIsICIlczogQ2FuJ3Qgb3BlbiBkaXNwbGF5OiAlc1xuIiwKLQkJIGFyZ3ZbMF0sIGRpc3BsYXlfbmFtZSA/IGRpc3BsYXlfbmFtZSA6ICIiICk7CisJCSBhcmd2WzBdLCBkaXNwbGF5X25hbWUgPyBkaXNwbGF5X25hbWUgOiAiKG5vbmUgc3BlY2lmaWVkKSIgKTsKIAlleGl0KDEpOwogICAgIH0KIApAQCAtNTg4LDcgKzU5MSwxMSBAQAogICAgIHsgV0ZfQ1BVMDg2LCBXRl9DUFUxODYsIFdGX0NQVTI4NiwgV0ZfQ1BVMzg2LCBXRl9DUFU0ODYgfTsKIAogICAvKiBUaGVyZSBkb2Vzbid0IHNlZW0gdG8gYmUgYW55IFBlbnRpdW0gZmxhZy4gICovCi0gIGxvbmcgY3B1ZmxhZyA9IGNwdWZsYWdzW21pbiAocnVudGltZV9jcHUgKCksIDQpXTsKKyNpZm5kZWYgV0lORUxJQgorICBsb25nIGNwdWZsYWcgPSBjcHVmbGFnc1tNSU4gKHJ1bnRpbWVfY3B1ICgpLCA0KV07CisjZWxzZQorICBsb25nIGNwdWZsYWcgPSBjcHVmbGFnc1s0XTsKKyNlbmRpZgogCiAgIGlmIChPcHRpb25zLmVuaGFuY2VkKQogICAgIHJldHVybiAoV0ZfRU5IQU5DRUQgfCBjcHVmbGFnIHwgV0ZfUE1PREUgfCBXRl84MHg4NyB8IFdGX1BBR0lORyk7CkBAIC02ODUsNyArNjkyLDcgQEAKIAkJCQkJbHBQb3J0TmFtZSwgbHBFbnZpcm9uLCBuTWF4U2l6KTsKIAl3aGlsZSAobHBFbnYgIT0gTlVMTCkgewogCQlpZiAobHBFbnYtPk5hbWUgIT0gTlVMTCAmJiBzdHJjbXAobHBFbnYtPk5hbWUsIGxwUG9ydE5hbWUpID09IDApIHsKLQkJCW5Db3VudCA9IG1pbihuTWF4U2l6LCBscEVudi0+d1NpemUpOworCQkJbkNvdW50ID0gTUlOKG5NYXhTaXosIGxwRW52LT53U2l6ZSk7CiAJCQltZW1jcHkobHBFbnZpcm9uLCBscEVudi0+VmFsdWUsIG5Db3VudCk7CiAJCQlwcmludGYoIkdldEVudmlyb25uZW1lbnQoKSAvLyBmb3VuZCAnJXMnICFcbiIsIGxwRW52aXJvbik7CiAJCQlyZXR1cm4gbkNvdW50OwpkaWZmIC0tZ2l0IGEvbWlzYy9vbGUybmxzLmMgYi9taXNjL29sZTJubHMuYwppbmRleCA1OTE1Y2U4Li5mMGRjNTJmIDEwMDY0NAotLS0gYS9taXNjL29sZTJubHMuYworKysgYi9taXNjL29sZTJubHMuYwpAQCAtMzE3LDYgKzMxNywxMDggQEAKICovCiAjZW5kaWYgLyogTEFORyhEZSkgKi8KIAorI2lmICNMQU5HKERhKQorLyogTE9DVkFMKExPQ0FMRV9JTEFOR1VBR0UsIjkiKSAqLworTE9DVkFMKExPQ0FMRV9TTEFOR1VBR0UsIkRhbnNrIikKK0xPQ1ZBTChMT0NBTEVfU0VOR0xBTkdVQUdFLCJEYW5pc2giKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWTEFOR05BTUUsImRhbiIpCitMT0NWQUwoTE9DQUxFX1NOQVRJVkVMQU5HTkFNRSwiRGFuc2siKQorTE9DVkFMKExPQ0FMRV9JQ09VTlRSWSwiNDUiKQorTE9DVkFMKExPQ0FMRV9TQ09VTlRSWSwiRGFubWFyayIpCitMT0NWQUwoTE9DQUxFX1NFTkdDT1VOVFJZLCJEZW5tYXJrIikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVkNUUllOQU1FLCJEYSIpCitMT0NWQUwoTE9DQUxFX1NOQVRJVkVDVFJZTkFNRSwiRGFubWFyayIpCisvKiBMT0NWQUwoTE9DQUxFX0lERUZBVUxUTEFOR1VBR0UsIjkiKSAqLworTE9DVkFMKExPQ0FMRV9JREVGQVVMVENPVU5UUlksIjQ1IikKKy8qIExPQ1ZBTChMT0NBTEVfSURFRkFVTFRDT0RFUEFHRSkgKi8KKy8qIExPQ1ZBTChMT0NBTEVfSURFRkFVTFRBTlNJQ09ERVBBR0UpICovCitMT0NWQUwoTE9DQUxFX1NMSVNULCI7IikKK0xPQ1ZBTChMT0NBTEVfSU1FQVNVUkUsIjAiKQorTE9DVkFMKExPQ0FMRV9TREVDSU1BTCwiLCIpCitMT0NWQUwoTE9DQUxFX1NUSE9VU0FORCwiLiIpCisvKiBMT0NWQUwoTE9DQUxFX1NHUk9VUElORykgKi8KK0xPQ1ZBTChMT0NBTEVfSURJR0lUUywiMiIpCitMT0NWQUwoTE9DQUxFX0lMWkVSTywiMSIpCisvKiBMT0NWQUwoTE9DQUxFX0lORUdOVU1CRVIpICovCisvKiBMT0NWQUwoTE9DQUxFX1NOQVRJVkVESUdJVFMpICovCitMT0NWQUwoTE9DQUxFX1NDVVJSRU5DWSwia3IiKQorLyogTE9DVkFMKExPQ0FMRV9TSU5UTFNZTUJPTCkgKi8KK0xPQ1ZBTChMT0NBTEVfU01PTkRFQ0lNQUxTRVAsIiwiKQorTE9DVkFMKExPQ0FMRV9TTU9OVEhPVVNBTkRTRVAsIi4iKQorLyogTE9DVkFMKExPQ0FMRV9TTU9OR1JPVVBJTkcpICovCitMT0NWQUwoTE9DQUxFX0lDVVJSRElHSVRTLCIyIikKKy8qIExPQ1ZBTChMT0NBTEVfSUlOVExDVVJSRElHSVRTKSAqLworTE9DVkFMKExPQ0FMRV9JQ1VSUkVOQ1ksIjMiKQorTE9DVkFMKExPQ0FMRV9JTkVHQ1VSUiwiOCIpCitMT0NWQUwoTE9DQUxFX1NEQVRFLCIuIikKK0xPQ1ZBTChMT0NBTEVfU1RJTUUsIjoiKQorTE9DVkFMKExPQ0FMRV9TU0hPUlREQVRFLCJkZC9NTS15eXl5IikKK0xPQ1ZBTChMT0NBTEVfU0xPTkdEQVRFLCJkZGQsIGQuIE1NTU0geXl5eSIpCisvKiBMT0NWQUwoTE9DQUxFX1NUSU1FRk9STUFUKSAqLworTE9DVkFMKExPQ0FMRV9JREFURSwiMSIpCisvKiBMT0NWQUwoTE9DQUxFX0lMREFURSkgKi8KK0xPQ1ZBTChMT0NBTEVfSVRJTUUsIjEiKQorLyogTE9DVkFMKExPQ0FMRV9JVElNRU1BUktQT1NOKSAqLworLyogTE9DVkFMKExPQ0FMRV9JQ0VOVFVSWSkgKi8KK0xPQ1ZBTChMT0NBTEVfSVRMWkVSTywiMSIpCisvKiBMT0NWQUwoTE9DQUxFX0lEQVlMWkVSTykgKi8KKy8qIExPQ1ZBTChMT0NBTEVfSU1PTkxaRVJPKSAqLworLyogTE9DVkFMKExPQ0FMRV9TMTE1OSkgKi8KKy8qIExPQ1ZBTChMT0NBTEVfUzIzNTkpICovCisvKiBMT0NWQUwoTE9DQUxFX0lDQUxFTkRBUlRZUEUpICovCisvKiBMT0NWQUwoTE9DQUxFX0lPUFRJT05BTENBTEVOREFSKSAqLworLyogTE9DVkFMKExPQ0FMRV9JRklSU1REQVlPRldFRUspICovCisvKiBMT0NWQUwoTE9DQUxFX0lGSVJTVFdFRUtPRllFQVIpICovCitMT0NWQUwoTE9DQUxFX1NEQVlOQU1FMSwiTWFuZGFnIikKK0xPQ1ZBTChMT0NBTEVfU0RBWU5BTUUyLCJUaXJzZGFnIikKK0xPQ1ZBTChMT0NBTEVfU0RBWU5BTUUzLCJPbnNkYWciKQorTE9DVkFMKExPQ0FMRV9TREFZTkFNRTQsIlRvcnNkYWciKQorTE9DVkFMKExPQ0FMRV9TREFZTkFNRTUsIkZyZWRhZyIpCitMT0NWQUwoTE9DQUxFX1NEQVlOQU1FNiwiTPhyZGFnIikKK0xPQ1ZBTChMT0NBTEVfU0RBWU5BTUU3LCJT+G5kYWciKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWREFZTkFNRTEsIk1hIikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVkRBWU5BTUUyLCJUaSIpCitMT0NWQUwoTE9DQUxFX1NBQkJSRVZEQVlOQU1FMywiT24iKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWREFZTkFNRTQsIlRvIikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVkRBWU5BTUU1LCJGciIpCitMT0NWQUwoTE9DQUxFX1NBQkJSRVZEQVlOQU1FNiwiTPgiKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWREFZTkFNRTcsIlP4IikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTEsIkphbnVhciIpCitMT0NWQUwoTE9DQUxFX1NNT05USE5BTUUyLCJGZWJydWFyIikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTMsIk1hcnRzIikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTQsIkFwcmlsIikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTUsIk1haiIpCitMT0NWQUwoTE9DQUxFX1NNT05USE5BTUU2LCJKdW5pIikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTcsIkp1bGkiKQorTE9DVkFMKExPQ0FMRV9TTU9OVEhOQU1FOCwiQXVndXN0IikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTksIlNlcHRlbWJlciIpCitMT0NWQUwoTE9DQUxFX1NNT05USE5BTUUxMCwiT2t0b2JlciIpCitMT0NWQUwoTE9DQUxFX1NNT05USE5BTUUxMSwiTm92ZW1iZXIiKQorTE9DVkFMKExPQ0FMRV9TTU9OVEhOQU1FMTIsIkRlY2VtYmVyIikKK0xPQ1ZBTChMT0NBTEVfU01PTlRITkFNRTEzLCIiKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWTU9OVEhOQU1FMSwiSmFuIikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVk1PTlRITkFNRTIsIkZlYiIpCitMT0NWQUwoTE9DQUxFX1NBQkJSRVZNT05USE5BTUUzLCJNYXIiKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWTU9OVEhOQU1FNCwiQXByIikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVk1PTlRITkFNRTUsIk1haiIpCitMT0NWQUwoTE9DQUxFX1NBQkJSRVZNT05USE5BTUU2LCJKdW4iKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWTU9OVEhOQU1FNywiSnVsIikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVk1PTlRITkFNRTgsIkF1ZyIpCitMT0NWQUwoTE9DQUxFX1NBQkJSRVZNT05USE5BTUU5LCJTZXAiKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWTU9OVEhOQU1FMTAsIk9rdCIpCitMT0NWQUwoTE9DQUxFX1NBQkJSRVZNT05USE5BTUUxMSwiTm92IikKK0xPQ1ZBTChMT0NBTEVfU0FCQlJFVk1PTlRITkFNRTEyLCJEZWMiKQorTE9DVkFMKExPQ0FMRV9TQUJCUkVWTU9OVEhOQU1FMTMsIiIpCisvKiBMT0NWQUwoTE9DQUxFX1NQT1NJVElWRVNJR04pICovCisvKiBMT0NWQUwoTE9DQUxFX1NORUdBVElWRVNJR04pICovCisvKiBMT0NWQUwoTE9DQUxFX0lQT1NTSUdOUE9TTikgKi8KKy8qIExPQ1ZBTChMT0NBTEVfSU5FR1NJR05QT1NOKSAqLworLyogTE9DVkFMKExPQ0FMRV9JUE9TU1lNUFJFQ0VERVMpICovCisvKiBMT0NWQUwoTE9DQUxFX0lQT1NTRVBCWVNQQUNFKSAqLworLyogTE9DVkFMKExPQ0FMRV9JTkVHU1lNUFJFQ0VERVMpICovCisvKiBMT0NWQUwoTE9DQUxFX0lORUdTRVBCWVNQQUNFKSAqLworI2VuZGlmIC8qIExBTkcoRGEpICovCisKIC8qSW5zZXJ0IG90aGVyIGxhbmd1YWdlcyBoZXJlKi8KIAogCmRpZmYgLS1naXQgYS9taXNjL3Byb2ZpbGUuYyBiL21pc2MvcHJvZmlsZS5jCmluZGV4IGQ5MDY3YjEuLjdkY2U1MTIgMTAwNjQ0Ci0tLSBhL21pc2MvcHJvZmlsZS5jCisrKyBiL21pc2MvcHJvZmlsZS5jCkBAIC0yOSw5ICsyOSw5IEBACiAjaW5jbHVkZSAic3RkZGVidWcuaCIKIC8qICNkZWZpbmUgREVCVUdfUFJPRklMRSAqLwogI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiAjZGVmaW5lIFNUUlNJWkUgMjU1Ci0jZGVmaW5lIHhtYWxsb2MoeCkgbWFsbG9jKHgpCiAjZGVmaW5lIG92ZXJmbG93IChuZXh0ID09ICZDaGFyQnVmZmVyIFtTVFJTSVpFLTFdKQogCiBlbnVtIHsgRmlyc3RCcmFjZSwgT25TZWNIZWFkZXIsIElnbm9yZVRvRU9MLCBLZXlEZWYsIEtleVZhbHVlIH07CkBAIC0xMDEsNiArMTAxLDggQEAKICAgICBjaGFyIGM7CiAgICAgY2hhciBwYXRoW01BWF9QQVRIKzFdOwogCisgICAgKnBmdWxsbmFtZSA9IE5VTEw7CisKICAgICAvKiBUcnkgdGhlIFdpbmRvd3MgZGlyZWN0b3J5ICovCiAKICAgICBHZXRXaW5kb3dzRGlyZWN0b3J5KHBhdGgsIHNpemVvZihwYXRoKSk7CkBAIC0xMjYsNiArMTI4LDcgQEAKICAgICB9CiAgICAgaWYgKGYgPT0gTlVMTCkgewogCWZwcmludGYoc3RkZXJyLCAicHJvZmlsZS5jOiBsb2FkKCkgY2FuJ3QgZmluZCBmaWxlICVzXG4iLCBmaWxlbmFtZSk7CisgICAgICAgIC8qIEZJWE1FOiB3ZSBvdWdodCB0byBjcmVhdGUgaXQgbm93IChpbiB3aGljaCBkaXJlY3Rvcnk/KSAqLwogCXJldHVybiBOVUxMOwogICAgIH0KICAgICAKQEAgLTI3Niw3ICsyNzksNyBAQAogCQkJZHByaW50Zl9wcm9maWxlKHN0ZGRlYiwiR2V0U2V0UHJvZmlsZSAvLyBObyBtb3JlIHN0b3JhZ2UgZm9yIGVudW0gIVxuIik7CiAJCQlyZXR1cm4gKFNpemUgLSAyKTsKIAkJfQotCQlzbGVuID0gbWluKHN0cmxlbihrZXktPktleU5hbWUpICsgMSwgbGVmdCk7CisJCXNsZW4gPSBNSU4oc3RybGVuKGtleS0+S2V5TmFtZSkgKyAxLCBsZWZ0KTsKIAkJZHByaW50Zl9wcm9maWxlKHN0ZGRlYiwiR2V0U2V0UHJvZmlsZSAvLyBzdHJuY3B5KCVwLCAlcCwgJWQpO1xuIiwgCiAJCQkJUmV0dXJuZWRTdHJpbmcsIGtleS0+VmFsdWUsIHNsZW4pOwogCQlzdHJuY3B5IChwLCBrZXktPktleU5hbWUsIHNsZW4pOwpAQCAtMjk4LDcgKzMwMSw3IEBACiAJCUN1cnJlbnQtPmNoYW5nZWQ9VFJVRTsKIAkJcmV0dXJuIDE7CiAJICAgIH0KLQkgICAgc2xlbiA9IG1pbihzdHJsZW4oa2V5LT5WYWx1ZSksIFNpemUgLSAxKTsKKwkgICAgc2xlbiA9IE1JTihzdHJsZW4oa2V5LT5WYWx1ZSksIFNpemUgLSAxKTsKIAkgICAgUmV0dXJuZWRTdHJpbmdbc2xlbl0gPSAwOwogCSAgICBzdHJuY3B5IChSZXR1cm5lZFN0cmluZywga2V5LT5WYWx1ZSwgc2xlbik7CiAJICAgIGRwcmludGZfcHJvZmlsZShzdGRkZWIsIkdldFNldFByb2ZpbGUgLy8gUmV0dXJuIGBgJXMnJ1xuIiwgUmV0dXJuZWRTdHJpbmcpOwpAQCAtMzEwLDcgKzMxMyw3IEBACiAJaWYgKHNldCkgewogCSAgICBuZXdfa2V5IChzZWN0aW9uLCBLZXlOYW1lLCBEZWZhdWx0KTsKICAgICAgICAgfSBlbHNlIHsKLQkgICAgaW50IHNsZW4gPSBtaW4oc3RybGVuKERlZmF1bHQpLCBTaXplIC0gMSk7CisJICAgIGludCBzbGVuID0gTUlOKHN0cmxlbihEZWZhdWx0KSwgU2l6ZSAtIDEpOwogICAgICAgICAgICAgUmV0dXJuZWRTdHJpbmdbc2xlbl0gPSAwOwogICAgICAgICAgICAgc3RybmNweShSZXR1cm5lZFN0cmluZywgRGVmYXVsdCwgc2xlbik7CiAJICAgIGRwcmludGZfcHJvZmlsZShzdGRkZWIsIkdldFNldFByb2ZpbGUgLy8gS2V5IG5vdCBmb3VuZFxuIik7CkBAIC0zMjcsNyArMzMwLDcgQEAKIAlDdXJyZW50LT5TZWN0aW9uID0gc2VjdGlvbjsKIAlDdXJyZW50LT5jaGFuZ2VkID0gVFJVRTsKICAgICB9IGVsc2UgewotCWludCBzbGVuID0gbWluKHN0cmxlbihEZWZhdWx0KSwgU2l6ZSAtIDEpOworCWludCBzbGVuID0gTUlOKHN0cmxlbihEZWZhdWx0KSwgU2l6ZSAtIDEpOwogCVJldHVybmVkU3RyaW5nW3NsZW5dID0gMDsKIAlzdHJuY3B5KFJldHVybmVkU3RyaW5nLCBEZWZhdWx0LCBzbGVuKTsKIAlkcHJpbnRmX3Byb2ZpbGUoc3RkZGViLCJHZXRTZXRQcm9maWxlIC8vIFNlY3Rpb24gbm90IGZvdW5kXG4iKTsKQEAgLTQxOCw3ICs0MjEsNyBAQAogICAgIGR1bXBfcHJvZmlsZSAocC0+bGluayk7CiAgICAgaWYoIXAtPmNoYW5nZWQpCiAJcmV0dXJuOwotICAgIGlmICgocHJvZmlsZSA9IGZvcGVuIChwLT5GdWxsTmFtZSwgInciKSkgIT0gTlVMTCl7CisgICAgaWYgKHAtPkZ1bGxOYW1lICYmIChwcm9maWxlID0gZm9wZW4gKHAtPkZ1bGxOYW1lLCAidyIpKSAhPSBOVUxMKXsKIAlkdW1wX3NlY3Rpb25zIChwcm9maWxlLCBwLT5TZWN0aW9uKTsKIAlmY2xvc2UgKHByb2ZpbGUpOwogICAgIH0KZGlmZiAtLWdpdCBhL21pc2MvcmVjdC5jIGIvbWlzYy9yZWN0LmMKaW5kZXggMGI1MTMzYi4uYzVkNzk4NSAxMDA2NDQKLS0tIGEvbWlzYy9yZWN0LmMKKysrIGIvbWlzYy9yZWN0LmMKQEAgLTgsOSArOCw2IEBACiAKICNpbmNsdWRlICJ3aW5kb3dzLmgiCiAKLSNkZWZpbmUgTUlOKGEsYikgKChhKSA8IChiKSA/IChhKSA6IChiKSkKLSNkZWZpbmUgTUFYKGEsYikgKChhKSA+IChiKSA/IChhKSA6IChiKSkKLQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICBTZXRSZWN0ICAgIChVU0VSLjcyKQpkaWZmIC0tZ2l0IGEvbWlzYy9zaGVsbC5jIGIvbWlzYy9zaGVsbC5jCmluZGV4IDEyODIyZjEuLjg2ZDYwZWUgMTAwNjQ0Ci0tLSBhL21pc2Mvc2hlbGwuYworKysgYi9taXNjL3NoZWxsLmMKQEAgLTE4LDYgKzE4LDcgQEAKICNpbmNsdWRlICJ3aW4uaCIKICNpbmNsdWRlICJzdGRkZWJ1Zy5oIgogI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiBMUEtFWVNUUlVDVAlscGhSb290S2V5ID0gTlVMTCxscGhUb3BLZXkgPSBOVUxMOwogCkBAIC0xMTEsNyArMTEyLDcgQEAKIAkgKiAoSEtFWV9MT0NBTF9NQUNISU5FLEhLRVlfQ1VSUkVOVF9VU0VSIG9yIHdoYXRldmVyKQogCSAqIC1jaG9vc2UgYmV0dGVyIGZpbGVuYW1lKHMpCiAJICovCi0JX1NhdmVLZXkoSEtFWV9DTEFTU0VTX1JPT1QsIi90bXAvd2luZXJlZyIpOworCV9TYXZlS2V5KChIS0VZKUhLRVlfQ0xBU1NFU19ST09ULCIvdG1wL3dpbmVyZWciKTsKIH0KIAogI2RlZmluZSBCVUZTSVpFCTI1NgpAQCAtMTM5LDEwICsxNDAsMTAgQEAKIAkJCWxwTmV3S2V5PWxwS2V5LT5scFN1Ykx2bD0oTFBLRVlTVFJVQ1QpR2xvYmFsTG9jayhoTmV3S2V5KTsKIAkJCWxwTmV3S2V5LT5oS2V5CQk9IGhOZXdLZXk7CiAJCQlscE5ld0tleS0+ZHdUeXBlCT0gMDsKLQkJCWxwTmV3S2V5LT5scFN1YktleQk9Ci0JCQlscE5ld0tleS0+bHBWYWx1ZQk9Ci0JCQlscE5ld0tleS0+bHBTdWJMdmwJPQotCQkJbHBOZXdLZXktPmxwTmV4dEtleQk9CisJCQlscE5ld0tleS0+bHBTdWJLZXkJPSBOVUxMOworCQkJbHBOZXdLZXktPmxwVmFsdWUJPSBOVUxMOworCQkJbHBOZXdLZXktPmxwU3ViTHZsCT0gTlVMTDsKKwkJCWxwTmV3S2V5LT5scE5leHRLZXkJPSBOVUxMOwogCQkJbHBOZXdLZXktPmxwUHJldktleQk9IE5VTEw7CiAJCQlpZiAoTlVMTCE9KHQ9c3RyY2hyKHMsJz0nKSkpIHsKIAkJCQkqdD0nXDAnO3QrKzsKQEAgLTE2NSw5ICsxNjYsOSBAQAogCQlscE5ld0tleS0+bHBQcmV2S2V5CT0gbHBLZXk7CiAJCWxwTmV3S2V5LT5oS2V5CQk9IGhOZXdLZXk7CiAJCWxwTmV3S2V5LT5kd1R5cGUJPSAwOwotCQlscE5ld0tleS0+bHBTdWJLZXkJPQotCQlscE5ld0tleS0+bHBWYWx1ZQk9Ci0JCWxwTmV3S2V5LT5scFN1Ykx2bAk9CisJCWxwTmV3S2V5LT5scFN1YktleQk9IE5VTEw7CisJCWxwTmV3S2V5LT5scFZhbHVlCT0gTlVMTDsKKwkJbHBOZXdLZXktPmxwU3ViTHZsCT0gTlVMTDsKIAkJbHBOZXdLZXktPmxwTmV4dEtleQk9IE5VTEw7CiAJCWlmIChOVUxMIT0odD1zdHJjaHIocywnPScpKSkgewogCQkJKnQ9J1wwJzt0Kys7CkBAIC0yMDksNyArMjEwLDcgQEAKIAlkd1JldD1TSEVMTF9SZWdDaGVja0ZvclJvb3QoKTsKIAlpZiAoZHdSZXQhPUVSUk9SX1NVQ0NFU1MpIAogCQlyZXR1cm47Lyp2ZXJ5IGJhZCBtYWdpYywgaWYgd2UgY2FuJ3QgZXZlbiBhbGxvY2F0ZSB0aGUgcm9vdGtleXMqLwotCV9Mb2FkS2V5KEhLRVlfQ0xBU1NFU19ST09ULCIvdG1wL3dpbmVyZWciKTsKKwlfTG9hZEtleSgoSEtFWSlIS0VZX0NMQVNTRVNfUk9PVCwiL3RtcC93aW5lcmVnIik7CiB9CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCkBAIC0zODYsNyArMzg3LDcgQEAKICAgICBscEtleSA9IChMUEtFWVNUUlVDVClHbG9iYWxMb2NrKGhSZXRLZXkpOwogICAgIGlmIChscEtleSA9PSBOVUxMKSByZXR1cm4gRVJST1JfQkFES0VZOwogICAgIGlmIChscEtleS0+bHBWYWx1ZSAhPSBOVUxMKSBmcmVlKGxwS2V5LT5scFZhbHVlKTsKLSAgICBscEtleS0+bHBWYWx1ZSA9IG1hbGxvYyhzdHJsZW4obHBWYWwpICsgMSk7CisgICAgbHBLZXktPmxwVmFsdWUgPSB4bWFsbG9jKHN0cmxlbihscFZhbCkgKyAxKTsKICAgICBzdHJjcHkobHBLZXktPmxwVmFsdWUsIGxwVmFsKTsKICAgICBkcHJpbnRmX3JlZyhzdGRkZWIsIlJlZ1NldFZhbHVlIC8vIHN1Y2Nlc3NmdWwga2V5PSclcycgdmFsPSclcycgIVxuIiwgbHBTdWJLZXksIGxwS2V5LT5scFZhbHVlKTsKICAgICByZXR1cm4gRVJST1JfU1VDQ0VTUzsKQEAgLTQ1OCw3ICs0NTksNyBAQAogICAgICAgICBscEtleSA9IGxwS2V5LT5scFN1Ykx2bDsKICAgICAgICAgd2hpbGUobHBLZXkgIT0gTlVMTCl7CiAgICAgICAgICAgaWYgKCFkd1N1YktleSl7Ci0gICAgICAgICAgICBsZW4gPSBtaW4oZHdTaXplLTEsc3RybGVuKGxwS2V5LT5scFN1YktleSkpOworICAgICAgICAgICAgbGVuID0gTUlOKGR3U2l6ZS0xLHN0cmxlbihscEtleS0+bHBTdWJLZXkpKTsKIAkgICAgc3RybmNweShscEJ1ZixscEtleS0+bHBTdWJLZXksbGVuKTsKIAkgICAgbHBCdWZbbGVuXSA9IDA7CiAgICAgICAgICAgICBkcHJpbnRmX3JlZyhzdGRkZWIsICJSZWdFbnVtS2V5OiBmb3VuZCAlc1xuIixscEJ1Zik7CkBAIC00NzksNyArNDgwLDcgQEAKIHsKICAvKiBmbGlwcyBXU19FWF9BQ0NFUFRGSUxFUyBiaXQgYWNjb3JkaW5nIHRvIHRoZSB2YWx1ZSBvZiBiIChUUlVFIG9yIEZBTFNFKSAqLwogCi0gZHByaW50Zl9yZWcoc3RkZGViLCJEcmFnQWNjZXB0RmlsZXMoJTA0eCwgJXUpIG9sZCBleFN0eWxlICUwOGx4XG4iLGhXbmQsYixHZXRXaW5kb3dMb25nKGhXbmQsR1dMX0VYU1RZTEUpKTsKKyBkcHJpbnRmX3JlZyhzdGRkZWIsIkRyYWdBY2NlcHRGaWxlcygiTlBGTVQiLCAldSkgb2xkIGV4U3R5bGUgJTA4bHhcbiIsaFduZCxiLEdldFdpbmRvd0xvbmcoaFduZCxHV0xfRVhTVFlMRSkpOwogCiAgU2V0V2luZG93TG9uZyhoV25kLEdXTF9FWFNUWUxFLEdldFdpbmRvd0xvbmcoaFduZCxHV0xfRVhTVFlMRSkgfCBiKihMT05HKVdTX0VYX0FDQ0VQVEZJTEVTKTsgCiB9CkBAIC00OTgsNyArNDk5LDcgQEAKICBMUFNUUgkJICBscEN1cnJlbnQ7CiAgV09SRAkJICBpOwogCi0gZHByaW50Zl9yZWcoc3RkZGViLCJEcmFnUXVlcnlGaWxlKCUwNHgsICVpLCAlcCwgJXUpXG4iLAorIGRwcmludGZfcmVnKHN0ZGRlYiwiRHJhZ1F1ZXJ5RmlsZSgiTlBGTVQiLCAlaSwgJXAsICV1KVxuIiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIGhEcm9wLHdGaWxlLGxwc3pGaWxlLHdMZW5ndGgpOwogCiAgbHBEcm9wRmlsZVN0cnVjdCA9IChMUERST1BGSUxFU1RSVUNUKSBHbG9iYWxMb2NrKGhEcm9wKTsgCkBAIC02MTAsNyArNjExLDcgQEAKIAkgICAgc3RyY2F0KGNtZCxscEZpbGUpOwogCSAgfSBlbHNlIHsKIAkgICAgY2hhciAqczsKLQkgICAgcz1tYWxsb2MobGVuK3N0cmxlbihscEZpbGUpKzEwKTsKKwkgICAgcz14bWFsbG9jKGxlbitzdHJsZW4obHBGaWxlKSsxMCk7CiAJICAgIHN0cm5jcHkocyxjbWQsdC1jbWQpOwogCSAgICBzW3QtY21kXT0nXDAnOwogCSAgICBzdHJjYXQocyxscEZpbGUpOwpkaWZmIC0tZ2l0IGEvbWlzYy9zcHkuYyBiL21pc2Mvc3B5LmMKaW5kZXggZWJhMTRmZS4uMmQ0YzQzMCAxMDA2NDQKLS0tIGEvbWlzYy9zcHkuYworKysgYi9taXNjL3NweS5jCkBAIC00MDgsMTQgKzQwOCwxNCBAQAogCQkgICAgaWYobXNnIDw9IFdNX1VTRVIpCiAJCSAgICAgIHsKIAkJICAgICAgIGlmKE1lc3NhZ2VUeXBlTmFtZXNbbXNnXSkKLQkJICAgICAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsIiglMDR4KSBtZXNzYWdlIFslMDR4XSAlcyBkaXNwYXRjaGVkICB3cD0lMDR4IGxwPSUwOGx4XG4iLAorCQkgICAgICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwiKCJOUEZNVCIpIG1lc3NhZ2UgWyUwNHhdICVzIGRpc3BhdGNoZWQgIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAJCSAgICAgICAgICAgICAgICAgICAgICAgICAgaFduZCwgbXNnLCBNZXNzYWdlVHlwZU5hbWVzW21zZ10sIHdQYXJhbSwgbFBhcmFtKTsKIAkJICAgICAgIGVsc2UKLQkJICAgICAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsIiglMDR4KSBtZXNzYWdlIFslMDR4XSBkaXNwYXRjaGVkICB3cD0lMDR4IGxwPSUwOGx4XG4iLAorCQkgICAgICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwiKCJOUEZNVCIpIG1lc3NhZ2UgWyUwNHhdIGRpc3BhdGNoZWQgIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAJCSAgICAgICAgICAgICAgICAgICAgICAgICAgaFduZCwgbXNnLCB3UGFyYW0sIGxQYXJhbSk7CiAJCSAgICAgIH0KIAkJICAgIGVsc2UKLQkJICAgICAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsIiglMDR4KSBtZXNzYWdlIFslMDR4XSBXTV9VU0VSKyUwNGQgZGlzcGF0Y2hlZCAgd3A9JTA0eCBscD0lMDhseFxuIiwKKwkJICAgICAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsIigiTlBGTVQiKSBtZXNzYWdlIFslMDR4XSBXTV9VU0VSKyUwNGQgZGlzcGF0Y2hlZCAgd3A9JTA0eCBscD0lMDhseFxuIiwKIAkJICAgICAgICAgICAgICAgICAgICAgICAgICBoV25kLCBtc2csIG1zZy1XTV9VU0VSICx3UGFyYW0gLGxQYXJhbSk7CiAJCSAgICBicmVhazsKIAljYXNlIFNQWV9TRU5ETUVTU0FHRToKQEAgLTQyNSwyNyArNDI1LDI3IEBACiAgIAkJICAgICAgCSAgIGxwc3RyU3B5TWVzc2FnZUZyb20gPSBscHN0clNweU1lc3NhZ2VGcm9tV2luZTsKICAgCQkgICAgCSBlbHNlCiAgIAkJCQl7Ci0gIAkJCQkgICBzcHJpbnRmKGxwc3RyU3B5TWVzc2FnZUZyb21UYXNrLCAidGFzayAlMDR4IiwgaFRhc2spOwkKKyAgCQkJCSAgIHNwcmludGYobHBzdHJTcHlNZXNzYWdlRnJvbVRhc2ssICJ0YXNrICJOUEZNVCwgaFRhc2spOwkKICAgCQkJCSAgIGxwc3RyU3B5TWVzc2FnZUZyb20gPSBscHN0clNweU1lc3NhZ2VGcm9tVGFzazsKICAgCQkJCX0KIAkJICAgICAKIAkgICAgICAgICAgICBpZihtc2cgPD0gV01fVVNFUikKIAkgICAgICAgICAgICAgICAgewogCSAgICAgICAgICAgICAgICAgIGlmKE1lc3NhZ2VUeXBlTmFtZXNbbXNnXSkKLQkJCSAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsIiVzKCUwNHgpIG1lc3NhZ2UgWyUwNHhdICVzIHNlbnQgZnJvbSAlcyB3cD0lMDR4IGxwPSUwOGx4XG4iLAorCQkJICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwiJXMoIk5QRk1UIikgbWVzc2FnZSBbJTA0eF0gJXMgc2VudCBmcm9tICVzIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkgICAgICBscHN0clNweU1lc3NhZ2VJbmRlbnQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkgICAgICBoV25kLCBtc2csIE1lc3NhZ2VUeXBlTmFtZXNbbXNnXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCSAgICAgIGxwc3RyU3B5TWVzc2FnZUZyb20sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkgICAgICB3UGFyYW0sIGxQYXJhbSk7CiAJICAgICAgICAgICAgICAgICAgZWxzZQotCSAgICAgICAgICAgICAgICAgICAgICBkcHJpbnRmX21lc3NhZ2Uoc3RkZGViLCIlcyglMDR4KSBtZXNzYWdlIFslMDR4XSBzZW50IGZyb20gJXMgd3A9JTA0eCBscD0lMDhseFxuIiwKKwkgICAgICAgICAgICAgICAgICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwiJXMoIk5QRk1UIikgbWVzc2FnZSBbJTA0eF0gc2VudCBmcm9tICVzIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkgICAgICBscHN0clNweU1lc3NhZ2VJbmRlbnQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkgICAgICBoV25kLCBtc2csCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkgICAgICBscHN0clNweU1lc3NhZ2VGcm9tLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJICAgICAgd1BhcmFtLCBsUGFyYW0pOwogICAgICAgICAgIAkJfQogICAgICAgICAJICAgIGVsc2UKLSAgICAgICAgICAgICAJCSAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwiJXMoJTA0eCkgbWVzc2FnZSBbJTA0eF0gV01fVVNFUislMDR4IHNlbnQgZnJvbSAlcyB3cD0lMDR4IGxwPSUwOGx4XG4iLAorICAgICAgICAgICAgIAkJICBkcHJpbnRmX21lc3NhZ2Uoc3RkZGViLCIlcygiTlBGTVQiKSBtZXNzYWdlIFslMDR4XSBXTV9VU0VSKyUwNHggc2VudCBmcm9tICVzIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCQkgIGxwc3RyU3B5TWVzc2FnZUluZGVudCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJCSAgaFduZCwgbXNnLCBtc2ctV01fVVNFUiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJCSAgbHBzdHJTcHlNZXNzYWdlRnJvbSwKQEAgLTQ2MSwxNSArNDYxLDE1IEBACiAJY2FzZSBTUFlfREVGV05EUFJPQzoKIAkJICAgIGlmKG1zZyA8PSBXTV9VU0VSKQogCQkgICAgICAgIGlmKE1lc3NhZ2VUeXBlTmFtZXNbbXNnXSkKLQkJICAgICAgICAgICBkcHJpbnRmX21lc3NhZ2Uoc3RkZGViLCAiJXMoJTA0eCkgRGVmV2luZG93UHJvYzogJXMgWyUwNHhdICB3cD0lMDR4IGxwPSUwOGx4XG4iLAorCQkgICAgICAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsICIlcygiTlBGTVQiKSBEZWZXaW5kb3dQcm9jOiAlcyBbJTA0eF0gIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAJCSAgICAgICAgICAgICAgICAgICAgICAgICAgIGxwc3RyU3B5TWVzc2FnZUluZGVudCwKIAkJICAgICAgICAgICAgICAgICAgICAgICAgICAgaFduZCwgTWVzc2FnZVR5cGVOYW1lc1ttc2ddLCBtc2csIHdQYXJhbSwgbFBhcmFtICk7CiAJCSAgICAgICAgZWxzZQotCQkgICAgICAgICAgIGRwcmludGZfbWVzc2FnZShzdGRkZWIsICIlcyglMDR4KSBEZWZXaW5kb3dQcm9jOiBbJTA0eF0gIHdwPSUwNHggbHA9JTA4bHhcbiIsCisJCSAgICAgICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwgIiVzKCJOUEZNVCIpIERlZldpbmRvd1Byb2M6IFslMDR4XSAgd3A9JTA0eCBscD0lMDhseFxuIiwKIAkJICAgICAgICAgICAgICAgICAgICAgICAgICAgbHBzdHJTcHlNZXNzYWdlSW5kZW50LAogCQkgICAgICAgICAgICAgICAgICAgICAgICAgICBoV25kLCBtc2csIHdQYXJhbSwgbFBhcmFtICk7CiAJCSAgICBlbHNlCi0JCSAgICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwgIiVzKCUwNHgpIERlZldpbmRvd1Byb2M6IFdNX1VTRVIrJWQgWyUwNHhdIHdwPSUwNHggbHA9JTA4bHhcbiIsCisJCSAgICAgICAgZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwgIiVzKCJOUEZNVCIpIERlZldpbmRvd1Byb2M6IFdNX1VTRVIrJWQgWyUwNHhdIHdwPSUwNHggbHA9JTA4bHhcbiIsCiAJCSAgICAgICAgICAgICAgICAgICAgICAgIGxwc3RyU3B5TWVzc2FnZUluZGVudCwKIAkJICAgICAgICAgICAgICAgICAgICAgICAgaFduZCwgbXNnIC0gV01fVVNFUiwgbXNnLCB3UGFyYW0sIGxQYXJhbSApOwogCQkgICAgYnJlYWs7CkBAIC00OTMsMTEgKzQ5MywxMSBAQAogICBzd2l0Y2goaUZsYWcpCiAgICAgewogCWNhc2UgU1BZX1JFU1VMVF9JTlZBTElESFdORDogCi0JCWRwcmludGZfbWVzc2FnZShzdGRkZWIsIiVzKCUwNHgpIG1lc3NhZ2UgWyUwNHhdIEhBUyBJTlZBTElEIEhXTkRcbiIsCisJCWRwcmludGZfbWVzc2FnZShzdGRkZWIsIiVzKCJOUEZNVCIpIG1lc3NhZ2UgWyUwNHhdIEhBUyBJTlZBTElEIEhXTkRcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxwc3RyU3B5TWVzc2FnZUluZGVudCwgaFduZCwgbXNnKTsKIAkgICAgICAgIGJyZWFrOwogCWNhc2UgU1BZX1JFU1VMVF9PSzoKLQkJZHByaW50Zl9tZXNzYWdlKHN0ZGRlYiwiJXMoJTA0eCkgbWVzc2FnZSBbJTA0eF0gcmV0dXJuZWQgJTA4bHhcbiIsCisJCWRwcmludGZfbWVzc2FnZShzdGRkZWIsIiVzKCJOUEZNVCIpIG1lc3NhZ2UgWyUwNHhdIHJldHVybmVkICUwOGx4XG4iLAogCSAgICAgICAgICAgICAgICAgICAgICAgIGxwc3RyU3B5TWVzc2FnZUluZGVudCwgaFduZCwgbXNnLCBsUmV0dXJuKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKZGlmZiAtLWdpdCBhL21pc2MvdXNlcjMyLmMgYi9taXNjL3VzZXIzMi5jCmluZGV4IDVhNGMwMmYuLmI5MWI3NDkgMTAwNjQ0Ci0tLSBhL21pc2MvdXNlcjMyLmMKKysrIGIvbWlzYy91c2VyMzIuYwpAQCAtMTE1LDcgKzExNSw3IEBACiBCT09MIFVTRVIzMl9FbmRQYWludChEV09SRCBod25kLHN0cnVjdCBXSU4zMl9QQUlOVFNUUlVDVCAqbHBwcykKIHsKIAlQQUlOVFNUUlVDVCBwczsKLQlwcy5oZGM9bHBwcy0+aGRjOworCXBzLmhkYz0oSERDKWxwcHMtPmhkYzsKIAlwcy5mRXJhc2U9bHBwcy0+ZkVyYXNlOwogCXBzLnJjUGFpbnQudG9wPWxwcHMtPnJjUGFpbnQudG9wOwogCXBzLnJjUGFpbnQubGVmdD1scHBzLT5yY1BhaW50LmxlZnQ7CmRpZmYgLS1naXQgYS9taXNjL3dpbnNvY2tldC5jIGIvbWlzYy93aW5zb2NrZXQuYwppbmRleCAyMzY3NWExLi41MmJhZjc4IDEwMDY0NAotLS0gYS9taXNjL3dpbnNvY2tldC5jCisrKyBiL21pc2Mvd2luc29ja2V0LmMKQEAgLTkxLDcgKzkxLDkgQEAKIH07CiBzdGF0aWMgc3RydWN0IFdpblNvY2tIZWFwICpIZWFwOwogc3RhdGljIEhBTkRMRSBIZWFwSGFuZGxlOworI2lmbmRlZiBXSU5FTElCMzIKIHN0YXRpYyBpbnQgU2NyYXRjaFB0cjsKKyNlbmRpZgogCiAjaWZuZGVmIFdJTkVMSUIKICNkZWZpbmUgR0VUX1NFR19QVFIoeCkJTUFLRUxPTkcoKGludCkoKGNoYXIqKSh4KS0oY2hhciopSGVhcCksCVwKQEAgLTExMCw2ICsxMTIsNyBAQAogCQkJaW5ldF9udG9hKCgoc3RydWN0IHNvY2thZGRyX2luICopYSktPnNpbl9hZGRyKSwgXAogCQkJbnRvaHMoKChzdHJ1Y3Qgc29ja2FkZHJfaW4gKilhKS0+c2luX3BvcnQpKQogCisjaWZuZGVmIFdJTkVMSUIzMgogc3RhdGljIHZvaWQgUmVzZXRTY3JhdGNoKCkKIHsKIAlTY3JhdGNoUHRyPTA7CkBAIC0xMzEsNiArMTM0LDcgQEAKIAlzdHJjcHkocmV0LHMpOwogCXJldHVybiBHRVRfU0VHX1BUUihyZXQpOwogfQorI2VuZGlmCiAKIHN0YXRpYyBXT1JEIHdzYWVycm5vKHZvaWQpCiB7CkBAIC0xNDEsNyArMTQ1LDcgQEAKICAgICAgICAgICAgICAgICAJCQllcnJubywgc3lzX2Vycmxpc3RbZXJybm9dKTsKICNlbHNlCiAgICAgICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJ3aW5zb2NrOiBlcnJubyAlZCwgKCVzKS5cbiIsIAotICAgICAgICAgICAgICAgIAkJCWVycm5vLCBzdHJlcnJvcihlcnJubykpOworCQkJCQllcnJubywgc3RyZXJyb3IoZXJybm8pKTsKICNlbmRpZgogI2Vsc2UKICAgICAgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIndpbnNvY2s6IGVycm5vICVkXG4iLCBlcnJubyk7CkBAIC0xNTEsNiArMTU1LDcgQEAKICAgICAgICAgc3dpdGNoKGVycm5vKQogICAgICAgICB7CiAJY2FzZSBFSU5UUjoJCXJldHVybiBXU0FFSU5UUjsKKwljYXNlIEVCQURGOgkJcmV0dXJuIFdTQUVCQURGOwogCWNhc2UgRUFDQ0VTOgkJcmV0dXJuIFdTQUVBQ0NFUzsKIAljYXNlIEVGQVVMVDoJCXJldHVybiBXU0FFRkFVTFQ7CiAJY2FzZSBFSU5WQUw6CQlyZXR1cm4gV1NBRUlOVkFMOwpAQCAtMTU4LDcgKzE2Myw2IEBACiAJY2FzZSBFV09VTERCTE9DSzoJcmV0dXJuIFdTQUVXT1VMREJMT0NLOwogCWNhc2UgRUlOUFJPR1JFU1M6CXJldHVybiBXU0FFSU5QUk9HUkVTUzsKIAljYXNlIEVBTFJFQURZOgkJcmV0dXJuIFdTQUVBTFJFQURZOwotCWNhc2UgRUJBREY6CiAJY2FzZSBFTk9UU09DSzoJCXJldHVybiBXU0FFTk9UU09DSzsKIAljYXNlIEVERVNUQUREUlJFUToJcmV0dXJuIFdTQUVERVNUQUREUlJFUTsKIAljYXNlIEVNU0dTSVpFOgkJcmV0dXJuIFdTQUVNU0dTSVpFOwpAQCAtMTk1LDYgKzE5OSw4IEBACiAJY2FzZSBFRFFVT1Q6CQlyZXR1cm4gV1NBRURRVU9UOwogCWNhc2UgRVNUQUxFOgkJcmV0dXJuIFdTQUVTVEFMRTsKIAljYXNlIEVSRU1PVEU6CQlyZXR1cm4gV1NBRVJFTU9URTsKKy8qIGp1c3QgaW4gY2FzZSB3ZSBldmVyIGdldCBoZXJlIGFuZCB0aGVyZSBhcmUgbm8gcHJvYmxlbXMgKi8KKwljYXNlIDA6CQkJcmV0dXJuIDA7CiAKICNpZmRlZiBFRFFVT1QKICAgICAgICAgZGVmYXVsdDoKQEAgLTIwOSw5ICsyMTUsNTAgQEAKIAl3c2FfZXJybm8gPSB3c2FlcnJubygpOwogfQogCisKK3N0YXRpYyBXT1JEIHdzYWhlcnJubyh2b2lkKQoreworI2lmIERFQlVHX1dJTlNPQ0sKKyNpZm5kZWYgc3VuCisjaWYgZGVmaW5lZChfX0ZyZWVCU0RfXykKKyAgICAgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIndpbnNvY2s6IGhfZXJybm8gJWQsICglcykuXG4iLCAKKyAgICAgICAgICAgICAgICAJCQloX2Vycm5vLCBzeXNfZXJybGlzdFtoX2Vycm5vXSk7CisjZWxzZQorICAgICAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAid2luc29jazogaF9lcnJubyAlZC5cbiIsIGhfZXJybm8pOworCQloZXJyb3IoIndpbmU6IHdpbnNvY2s6IHdzYWhlcnJubyIpOworI2VuZGlmCisjZWxzZQorICAgICAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAid2luc29jazogaF9lcnJubyAlZFxuIiwgaF9lcnJubyk7CisjZW5kaWYKKyNlbmRpZgorCisgICAgICAgIHN3aXRjaChoX2Vycm5vKQorICAgICAgICB7CisJY2FzZSBUUllfQUdBSU46CQlyZXR1cm4gV1NBVFJZX0FHQUlOOworCWNhc2UgSE9TVF9OT1RfRk9VTkQ6CXJldHVybiBXU0FIT1NUX05PVF9GT1VORDsKKwljYXNlIE5PX1JFQ09WRVJZOglyZXR1cm4gV1NBTk9fUkVDT1ZFUlk7CisJY2FzZSBOT19EQVRBOgkJcmV0dXJuIFdTQU5PX0RBVEE7IAorLyoganVzdCBpbiBjYXNlIHdlIGV2ZXIgZ2V0IGhlcmUgYW5kIHRoZXJlIGFyZSBubyBwcm9ibGVtcyAqLworCWNhc2UgMDoJCQlyZXR1cm4gMDsKKworI2lmZGVmIEVEUVVPVAorICAgICAgICBkZWZhdWx0OgorI2VuZGlmCisJCWZwcmludGYoc3RkZXJyLCAid2luc29jazogdW5rbm93biBoX2Vycm9ybm8gJWQhXG4iLCBoX2Vycm5vKTsKKwkJcmV0dXJuIFdTQUVPUE5PVFNVUFA7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIGhlcnJub190b193c2FlcnJubyh2b2lkKQoreworCXdzYV9lcnJubyA9IHdzYWhlcnJubygpOworfQorCisKIHN0YXRpYyB2b2lkIGNvbnZlcnRfc29ja29wdChJTlQgKmxldmVsLCBJTlQgKm9wdG5hbWUpCiB7Ci0vKiAkJSMlIUAhIHdoeSBjb3VsZG4ndCB0aGV5IHVzZSB0aGUgc2FtZSB2YWx1ZXMgZm9yIGJvdGggd2luc29jayBhbmQgdW5peCA/ICovCisvKiAkJSMlISMhIHdoeSBjb3VsZG4ndCB0aGV5IHVzZSB0aGUgc2FtZSB2YWx1ZXMgZm9yIGJvdGggd2luc29jayBhbmQgdW5peCA/ICovCiAKIAlzd2l0Y2ggKCpsZXZlbCkgewogCQljYXNlIC0xOiAKQEAgLTM3Niw3ICs0MjMsMTEgQEAKIAlkdW1wX3NvY2thZGRyKG5hbWUpOwogCiAJaWYgKGdldHBlZXJuYW1lKHMsIG5hbWUsIChpbnQgKikgbmFtZWxlbikgPCAwKSB7Ci0gICAgICAgIAllcnJub190b193c2FlcnJubygpOworCQlpZiAoaF9lcnJubyA8IDApIHsKKyAgICAgICAgCQllcnJub190b193c2FlcnJubygpOworCQl9IGVsc2UgeworCQkJaGVycm5vX3RvX3dzYWVycm5vKCk7CisJCX0KICAgICAgICAgCXJldHVybiBTT0NLRVRfRVJST1I7CiAJfQogCXJldHVybiAwOwpAQCAtMzg2LDcgKzQzNywxMSBAQAogewogCWRwcmludGZfd2luc29jayhzdGRkZWIsICJXU0FfZ2V0c29ja25hbWU6IHNvY2tldDogJWQsIHB0ciAlOHgsIHB0ciAlOHhcbiIsIHMsIChpbnQpIG5hbWUsIChpbnQpICpuYW1lbGVuKTsKIAlpZiAoZ2V0c29ja25hbWUocywgbmFtZSwgKGludCAqKSBuYW1lbGVuKSA8IDApIHsKLSAgICAgICAgCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCX0gZWxzZSB7CisJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfQogICAgICAgICAJcmV0dXJuIFNPQ0tFVF9FUlJPUjsKIAl9CiAJcmV0dXJuIDA7CkBAIC01OTYsNiArNjUxLDEwIEBACiAgICAgfQogICAgIAogICAgIGlmIChzb2NrID4gMHhmZmZmKSB7CisJLyogd2Ugc2V0IHRoZSB2YWx1ZSBvZiB3c2FfZXJybm8gZGlyZWN0bHksIGJlY2F1c2UgCisJICogb25seSBzdXBwb3J0IHNvY2tldCBudW1iZXJzIHVwIHRvIDB4ZmZmZi4gVGhlCisJICogdmFsdWUgcmV0dXJuIGluZGljYXRlcyB0aGVyZSBhcmUgbm8gZGVzY3JpcHRvcnMgYXZhaWxhYmxlCisJICovCiAJd3NhX2Vycm5vID0gV1NBRU1GSUxFOwogCXJldHVybiBJTlZBTElEX1NPQ0tFVDsKICAgICB9CkBAIC02MTYsNyArNjc1LDExIEBACiAJZHByaW50Zl93aW5zb2NrKHN0ZGRlYiwgIldTQV9nZXRob3N0YnlhZGRyOiBwdHIgJTh4LCBsZW4gJWQsIHR5cGUgJWRcbiIsIChpbnQpIGFkZHIsIGxlbiwgdHlwZSk7CiAKIAlpZiAoKGhvc3QgPSBnZXRob3N0YnlhZGRyKGFkZHIsIGxlbiwgdHlwZSkpID09IE5VTEwpIHsKLSAgICAgICAgCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCX0gZWxzZSB7CisJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfQogICAgICAgICAJcmV0dXJuIE5VTEw7CiAJfQogCUNPTlZFUlRfSE9TVEVOVCgmSGVhcC0+aG9zdGVudF9hZGRyLCBob3N0KTsKQEAgLTYzNCw3ICs2OTcsMTEgQEAKIAlkcHJpbnRmX3dpbnNvY2soc3RkZGViLCAiV1NBX2dldGhvc3RieW5hbWU6ICVzXG4iLCBuYW1lKTsKIAogCWlmICgoaG9zdCA9IGdldGhvc3RieW5hbWUobmFtZSkpID09IE5VTEwpIHsKLSAgICAgICAgCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCX0gZWxzZSB7CisJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfQogICAgICAgICAJcmV0dXJuIE5VTEw7CiAJfQogCUNPTlZFUlRfSE9TVEVOVCgmSGVhcC0+aG9zdGVudF9uYW1lLCBob3N0KTsKQEAgLTY0Nyw3ICs3MTQsMTEgQEAKIAlkcHJpbnRmX3dpbnNvY2soc3RkZGViLCAiV1NBX2dldGhvc3RuYW1lOiBuYW1lICVzLCBsZW4gJWRcbiIsIG5hbWUsIG5hbWVsZW4pOwogCiAJaWYgKGdldGhvc3RuYW1lKG5hbWUsIG5hbWVsZW4pIDwgMCkgewotICAgICAgICAJZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJaWYgKGhfZXJybm8gPCAwKSB7CisgICAgICAgIAkJZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfSBlbHNlIHsKKwkJCWhlcnJub190b193c2FlcnJubygpOworCQl9CiAgICAgICAgIAlyZXR1cm4gU09DS0VUX0VSUk9SOwogCX0KIAlyZXR1cm4gMDsKQEAgLTY2Myw3ICs3MzQsMTEgQEAKIAlkcHJpbnRmX3dpbnNvY2soc3RkZGViLCAiV1NBX2dldHByb3RvYnluYW1lOiBuYW1lICVzXG4iLCBuYW1lKTsKIAogCWlmICgocHJvdG8gPSBnZXRwcm90b2J5bmFtZShuYW1lKSkgPT0gTlVMTCkgewotICAgICAgICAJZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJaWYgKGhfZXJybm8gPCAwKSB7CisgICAgICAgIAkJZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfSBlbHNlIHsKKwkJCWhlcnJub190b193c2FlcnJubygpOworCQl9CiAgICAgICAgIAlyZXR1cm4gTlVMTDsKIAl9CiAJQ09OVkVSVF9QUk9UT0VOVCgmSGVhcC0+cHJvdG9lbnRfbmFtZSwgcHJvdG8pOwpAQCAtNjgxLDcgKzc1NiwxMSBAQAogCWRwcmludGZfd2luc29jayhzdGRkZWIsICJXU0FfZ2V0cHJvdG9ieW51bWJlcjogbnVtICVkXG4iLCBudW1iZXIpOwogCiAJaWYgKChwcm90byA9IGdldHByb3RvYnludW1iZXIobnVtYmVyKSkgPT0gTlVMTCkgewotICAgICAgICAJZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJaWYgKGhfZXJybm8gPCAwKSB7CisgICAgICAgIAkJZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfSBlbHNlIHsKKwkJCWhlcnJub190b193c2FlcnJubygpOworCQl9CiAgICAgICAgIAlyZXR1cm4gTlVMTDsKIAl9CiAJQ09OVkVSVF9QUk9UT0VOVCgmSGVhcC0+cHJvdG9lbnRfbnVtYmVyLCBwcm90byk7CkBAIC03MDIsNyArNzgxLDExIEBACiAJZHByaW50Zl93aW5zb2NrKHN0ZGRlYiwgIldTQV9nZXRzZXJ2YnluYW1lOiBuYW1lICVzLCBwcm90byAlc1xuIiwgbmFtZSwgcHJvdG8pOwogCiAJaWYgKChzZXJ2aWNlID0gZ2V0c2VydmJ5bmFtZShuYW1lLCBwcm90bykpID09IE5VTEwpIHsKLSAgICAgICAgCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCX0gZWxzZSB7CisJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJfQogICAgICAgICAJcmV0dXJuIE5VTEw7CiAJfQogCUNPTlZFUlRfU0VSVkVOVCgmSGVhcC0+c2VydmVudF9uYW1lLCBzZXJ2aWNlKTsKQEAgLTcyMCw3ICs4MDMsMTEgQEAKIAlkcHJpbnRmX3dpbnNvY2soc3RkZGViLCAiV1NBX2dldHNlcnZieXBvcnQ6IHBvcnQgJWQsIG5hbWUgJXNcbiIsIHBvcnQsIHByb3RvKTsKIAogCWlmICgoc2VydmljZSA9IGdldHNlcnZieXBvcnQocG9ydCwgcHJvdG8pKSA9PSBOVUxMKSB7Ci0gICAgICAgIAllcnJub190b193c2FlcnJubygpOworCQlpZiAoaF9lcnJubyA8IDApIHsKKyAgICAgICAgCQllcnJub190b193c2FlcnJubygpOworCQl9IGVsc2UgeworCQkJaGVycm5vX3RvX3dzYWVycm5vKCk7CisJCX0KICAgICAgICAgCXJldHVybiBOVUxMOwogCX0KIAlDT05WRVJUX1NFUlZFTlQoJkhlYXAtPnNlcnZlbnRfcG9ydCwgc2VydmljZSk7CkBAIC03NDIsNyArODI5LDggQEAKIHsKIAlzdHJ1Y3QgaXBjX3BhY2tldCBtZXNzYWdlOwogCi0JaWYgKG1zZ3Jjdih3aW5lX2tleSwgKHN0cnVjdCBtc2didWYqKSZtZXNzYWdlLCAKKy8qIEZJWE1FOiBzb21ldGhpbmcgYWJvdXQgbm8gbWVzc2FnZSBvZiBkZXNpcmVkIHR5cGUgKi8KKwlpZiAobXNncmN2KHdpbmVfa2V5LCAoc3RydWN0IG1zZ2J1ZiopJihtZXNzYWdlKSwgCiAJCSAgIElQQ19QQUNLRVRfU0laRSwgTVRZUEUsIElQQ19OT1dBSVQpID09IC0xKQogCQlwZXJyb3IoIndpbmU6IG1zZ3JjdiIpOwogCkBAIC03NTksNyArODQ3LDcgQEAKIH0KIAogCi1zdGF0aWMgdm9pZCBzZW5kX21lc3NhZ2UoSEFORExFIGhhbmRsZSwgSFdORCBoV25kLCB1X2ludCB3TXNnLCBsb25nIGxQYXJhbSkKK3N0YXRpYyB2b2lkIHNlbmRfbWVzc2FnZSggSFdORCBoV25kLCB1X2ludCB3TXNnLCBIQU5ETEUgaGFuZGxlLCBsb25nIGxQYXJhbSkKIHsKIAlzdHJ1Y3QgaXBjX3BhY2tldCBtZXNzYWdlOwogCQpAQCAtNzczLDcgKzg2MSw4IEBACiAJCSJXU0E6IHNlbmQgKGh3bmQgIk5QRk1UIiwgd01zZyAlZCwgaGFuZGxlICJOUEZNVCIsIGxQYXJhbSAlbGQpXG4iLAogCQloV25kLCB3TXNnLCBoYW5kbGUsIGxQYXJhbSk7CiAJCi0JaWYgKG1zZ3NuZCh3aW5lX2tleSwgKHN0cnVjdCBtc2didWYqKSZtZXNzYWdlLCAgCisvKiBGSVhNRTogc29tZXRoaW5nIGFib3V0IGludmFsaWQgYXJndW1lbnQgKi8KKwlpZiAobXNnc25kKHdpbmVfa2V5LCAoc3RydWN0IG1zZ2J1ZiopJihtZXNzYWdlKSwgIAogCQkgICBJUENfUEFDS0VUX1NJWkUsIElQQ19OT1dBSVQpID09IC0xKQogCQlwZXJyb3IoIndpbmU6IG1zZ3NuZCIpOwogCQkKQEAgLTc5Myw2ICs4ODIsMTEgQEAKIAkJcmV0dXJuIGhhbmRsZTsKIAl9IGVsc2UgewogCQlpZiAoKGhvc3QgPSBnZXRob3N0YnlhZGRyKGFkZHIsIGxlbiwgdHlwZSkpID09IE5VTEwpIHsKKwkJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCQllcnJub190b193c2FlcnJubygpOworCQkJfSBlbHNlIHsKKwkJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJCX0KIAkJCXNlbmRfbWVzc2FnZShoV25kLCB3TXNnLCBoYW5kbGUsIHdzYWVycm5vKCkgPDwgMTYpOwogCQkJZXhpdCgwKTsKIAkJfQpAQCAtODE1LDYgKzkwOSwxMSBAQAogCQlyZXR1cm4gaGFuZGxlOwogCX0gZWxzZSB7CiAJCWlmICgoaG9zdCA9IGdldGhvc3RieW5hbWUobmFtZSkpID09IE5VTEwpIHsKKwkJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCQllcnJub190b193c2FlcnJubygpOworCQkJfSBlbHNlIHsKKwkJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJCX0KIAkJCXNlbmRfbWVzc2FnZShoV25kLCB3TXNnLCBoYW5kbGUsIHdzYWVycm5vKCkgPDwgMTYpOwogCQkJZXhpdCgwKTsKIAkJfQpAQCAtODM3LDYgKzkzNiwxMSBAQAogCQlyZXR1cm4gaGFuZGxlOwogCX0gZWxzZSB7CiAJCWlmICgocHJvdG8gPSBnZXRwcm90b2J5bmFtZShuYW1lKSkgPT0gTlVMTCkgeworCQkJaWYgKGhfZXJybm8gPCAwKSB7CisgICAgICAgIAkJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCQl9IGVsc2UgeworCQkJCWhlcnJub190b193c2FlcnJubygpOworCQkJfQogCQkJc2VuZF9tZXNzYWdlKGhXbmQsIHdNc2csIGhhbmRsZSwgd3NhZXJybm8oKSA8PCAxNik7CiAJCQlleGl0KDApOwogCQl9CkBAIC04NTksNiArOTYzLDExIEBACiAJCXJldHVybiBoYW5kbGU7CiAJfSBlbHNlIHsKIAkJaWYgKChwcm90byA9IGdldHByb3RvYnludW1iZXIobnVtYmVyKSkgPT0gTlVMTCkgeworCQkJaWYgKGhfZXJybm8gPCAwKSB7CisgICAgICAgIAkJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCQl9IGVsc2UgeworCQkJCWhlcnJub190b193c2FlcnJubygpOworCQkJfQogCQkJc2VuZF9tZXNzYWdlKGhXbmQsIHdNc2csIGhhbmRsZSwgd3NhZXJybm8oKSA8PCAxNik7CiAJCQlleGl0KDApOwogCQl9CkBAIC04ODEsNiArOTkwLDExIEBACiAJCXJldHVybiBoYW5kbGU7CiAJfSBlbHNlIHsKIAkJaWYgKChzZXJ2aWNlID0gZ2V0c2VydmJ5bmFtZShuYW1lLCBwcm90bykpID09IE5VTEwpIHsKKwkJCWlmIChoX2Vycm5vIDwgMCkgeworICAgICAgICAJCQllcnJub190b193c2FlcnJubygpOworCQkJfSBlbHNlIHsKKwkJCQloZXJybm9fdG9fd3NhZXJybm8oKTsKKwkJCX0KIAkJCXNlbmRfbWVzc2FnZShoV25kLCB3TXNnLCBoYW5kbGUsIHdzYWVycm5vKCkgPDwgMTYpOwogCQkJZXhpdCgwKTsKIAkJfQpAQCAtOTAzLDYgKzEwMTcsMTEgQEAKIAkJcmV0dXJuIGhhbmRsZTsKIAl9IGVsc2UgewogCQlpZiAoKHNlcnZpY2UgPSBnZXRzZXJ2Ynlwb3J0KHBvcnQsIHByb3RvKSkgPT0gTlVMTCkgeworCQkJaWYgKGhfZXJybm8gPCAwKSB7CisgICAgICAgIAkJCWVycm5vX3RvX3dzYWVycm5vKCk7CisJCQl9IGVsc2UgeworCQkJCWhlcnJub190b193c2FlcnJubygpOworCQkJfQogCQkJc2VuZF9tZXNzYWdlKGhXbmQsIHdNc2csIGhhbmRsZSwgd3NhZXJybm8oKSA8PCAxNik7CiAJCQlleGl0KDApOwogCQl9CkBAIC05NDYsOCArMTA2NSw4IEBACiAJCQkJZXZlbnQgfD0gRkRfUkVBRDsKIAkJCWlmIChGRF9JU1NFVChzLCAmd3JpdGVfZmRzKSkKIAkJCQlldmVudCB8PSBGRF9XUklURTsKLQotCQkJc2VuZF9tZXNzYWdlKGhXbmQsIHdNc2csIHMsICh3c2FlcnJubygpIDw8IDE2KSB8IGV2ZW50KTsKKwkvKiBGSVhNRTogdGhlIGZpcnN0IHRpbWUgdGhyb3VnaCB3ZSBnZXQgYSB3aW5zb2NrIGVycm9yIG9mIDIsIHdoeT8gKi8KKwkJCXNlbmRfbWVzc2FnZShoV25kLCB3TXNnLCAoSEFORExFKXMsICh3c2FlcnJubygpIDw8IDE2KSB8IGV2ZW50KTsKIAkJfQogCX0KIH0KQEAgLTEwNDksNyArMTE2OCw3IEBACiAgICAgLyogaXBjIHN0dWZmICovCiAKICAgICBpZiAoKHdpbmVfa2V5ID0gbXNnZ2V0KElQQ19QUklWQVRFLCAwNjAwKSkgPT0gLTEpCi0JcGVycm9yKCJ3aW5lOiBtc2dnZXQiKTsKKwlwZXJyb3IoIndpbmU6IG1zZ2dldCIpOyAKIAogICAgIHNpZ25hbChTSUdVU1IxLCByZWN2X21lc3NhZ2UpOwogCmRpZmYgLS1naXQgYS9taXNjL3htYWxsb2MuYyBiL21pc2MveG1hbGxvYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI0ZGNlZjUKLS0tIC9kZXYvbnVsbAorKysgYi9taXNjL3htYWxsb2MuYwpAQCAtMCwwICsxLDQ0IEBACisvKgorICAgeG1hbGxvYyAtIGEgc2FmZSBtYWxsb2MKKworICAgVXNlIHRoaXMgZnVuY3Rpb24gaW5zdGVhZCBvZiBtYWxsb2Mgd2hlbmV2ZXIgeW91IGRvbid0IGludGVuZCB0byBjaGVjaworICAgdGhlIHJldHVybiB2YWx1ZSB5b3Vyc2VsZiwgZm9yIGluc3RhbmNlIGJlY2F1c2UgeW91IGRvbid0IGhhdmUgYSBnb29kCisgICB3YXkgdG8gaGFuZGxlIGEgemVybyByZXR1cm4gdmFsdWUuCisKKyAgIFR5cGljYWxseSwgV2luZSdzIG93biBtZW1vcnkgcmVxdWVzdHMgc2hvdWxkIGJlIGhhbmRsZXMgYnkgdGhpcyBmdW5jdGlvbiwKKyAgIHdoaWxlIHRoZSBjbGllbnQncyBzaG91bGQgdXNlIG1hbGxvYyBkaXJlY3RseSAoYW5kIFdpbmUgc2hvdWxkIHJldHVybiBhbgorICAgZXJyb3IgdG8gdGhlIGNsaWVudCBpZiBhbGxvY2F0aW9uIGZhaWxzKS4KKworICAgQ29weXJpZ2h0IDE5OTUgYnkgTW9ydGVuIFdlbGluZGVyLgorCisqLworCisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlICJ4bWFsbG9jLmgiCisKK3ZvaWQgKgoreG1hbGxvYyAoc2l6ZV90IHNpemUpCit7CisgICAgdm9pZCAqcmVzOworCisgICAgcmVzID0gbWFsbG9jIChzaXplID8gc2l6ZSA6IDEpOworICAgIGlmIChyZXMgPT0gTlVMTCkKKyAgICB7CisgICAgICAgIGZwcmludGYgKHN0ZGVyciwgIlZpcnR1YWwgbWVtb3J5IGV4aGF1c3RlZC5cbiIpOworICAgICAgICBleGl0ICgxKTsKKyAgICB9CisgICAgcmV0dXJuIHJlczsKK30KKworCit2b2lkICoKK3hyZWFsbG9jICh2b2lkICpwdHIsIHNpemVfdCBzaXplKQoreworICAgIHZvaWQgKnJlcyA9IHJlYWxsb2MgKHB0ciwgc2l6ZSk7CisgICAgaWYgKHJlcyA9PSBOVUxMKQorICAgIHsKKyAgICAgICAgZnByaW50ZiAoc3RkZXJyLCAiVmlydHVhbCBtZW1vcnkgZXhoYXVzdGVkLlxuIik7CisgICAgICAgIGV4aXQgKDEpOworICAgIH0KKyAgICByZXR1cm4gcmVzOworfQpkaWZmIC0tZ2l0IGEvbWlzY2VtdS9kb3NtZW0uYyBiL21pc2NlbXUvZG9zbWVtLmMKaW5kZXggZmQ2NzNlZS4uNDU2OGViOCAxMDA2NDQKLS0tIGEvbWlzY2VtdS9kb3NtZW0uYworKysgYi9taXNjZW11L2Rvc21lbS5jCkBAIC0xMyw2ICsxMyw3IEBACiAjaW5jbHVkZSAibGR0LmgiCiAjaW5jbHVkZSAibWlzY2VtdS5oIgogI2luY2x1ZGUgIm1vZHVsZS5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogCiBIQU5ETEUgRE9TTUVNX0Jpb3NTZWc7ICAvKiBCSU9TIGRhdGEgc2VnbWVudCBhdCAweDQwOjAgKi8KQEAgLTkwLDcgKzkxLDcgQEAKIAogICAgIC8qIEFsbG9jYXRlIDcgNjRrIHNlZ21lbnRzIGZvciAwMDAwLCBBMDAwLCBCMDAwLCBDMDAwLCBEMDAwLCBFMDAwLCBGMDAwLiAqLwogCi0gICAgZG9zbWVtID0gbWFsbG9jKCAweDcwMDAwICk7CisgICAgZG9zbWVtID0geG1hbGxvYyggMHg3MDAwMCApOwogCiAgICAgTU9EVUxFX1NldEVudHJ5UG9pbnQoIGhNb2R1bGUsIDE4MywgIC8qIEtFUk5FTC4xODM6IF9fMDAwMEggKi8KICAgICAgICAgICAgICAgICAgICAgICAgICAgR0xPQkFMX0NyZWF0ZUJsb2NrKCBHTUVNX0ZJWEVELCBkb3NtZW0sCmRpZmYgLS1naXQgYS9taXNjZW11L2luc3RyLmMgYi9taXNjZW11L2luc3RyLmMKaW5kZXggODNmN2NlZi4uMDlkYWY0MyAxMDA2NDQKLS0tIGEvbWlzY2VtdS9pbnN0ci5jCisrKyBiL21pc2NlbXUvaW5zdHIuYwpAQCAtNDI5LDEwICs0MjksMTAgQEAKIAogCSAgICAgIGlmIChvdXRwKQogCQkvKiBGSVhNRTogQ2hlY2sgc2VnbWVudCByZWFkYWJsZS4gICovCi0JCTsKKwkJKHZvaWQpMDsKIAkgICAgICBlbHNlCiAJCS8qIEZJWE1FOiBDaGVjayBzZWdtZW50IHdyaXRlYWJsZS4gICovCi0JCTsKKwkJKHZvaWQpMDsKIAogCSAgICAgIGlmIChyZXBYKQogCQlpZiAobG9uZ19hZGRyKQpkaWZmIC0tZ2l0IGEvbWlzY2VtdS9pbnQyMS5jIGIvbWlzY2VtdS9pbnQyMS5jCmluZGV4IDMwODYyYTYuLjAyMjg2MDIgMTAwNjQ0Ci0tLSBhL21pc2NlbXUvaW50MjEuYworKysgYi9taXNjZW11L2ludDIxLmMKQEAgLTc5OSw4ICs3OTksMTAgQEAKIHsKIAljaGFyIHRlbXBbMjU2XTsKIAlpbnQgaGFuZGxlOwotCQotCXNwcmludGYodGVtcCwiJXNcXHdpbiVkLnRtcCIsVGVtcERpcmVjdG9yeSwoaW50KSBnZXRwaWQoKSk7CisJc3RhdGljIGludCBjb3VudGVyID0gMDsKKworCXNwcmludGYodGVtcCwiJXNcXHdpbiVkLiUwM2QiLFRlbXBEaXJlY3RvcnksKGludCkgZ2V0cGlkKCksIGNvdW50ZXIpOworICAgICAgICBjb3VudGVyID0gKGNvdW50ZXIgKyAxKSAlIDEwMDA7CiAKIAlkcHJpbnRmX2ludChzdGRkZWIsIkNyZWF0ZVRlbXBGaWxlICVzXG4iLHRlbXApOwogCmRpZmYgLS1naXQgYS9tdWx0aW1lZGlhL21jaXN0cmluZy5jIGIvbXVsdGltZWRpYS9tY2lzdHJpbmcuYwppbmRleCA3OWZlNjY5Li4zZWEyMDhmIDEwMDY0NAotLS0gYS9tdWx0aW1lZGlhL21jaXN0cmluZy5jCisrKyBiL211bHRpbWVkaWEvbWNpc3RyaW5nLmMKQEAgLTIyLDYgKzIyLDcgQEAKICNpbmNsdWRlICJtbXN5c3RlbS5oIgogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIGV4dGVybiBNQ0lfT1BFTl9EUklWRVJfUEFSTVMJbWNpRHJ2W01BWE1DSURSSVZFUlNdOwogCkBAIC0xMzkzLDcgKzEzOTQsNyBAQAogCQlsZW4rPXN0cmxlbihrZXl3b3Jkc1tpXSkrMTsKIAkJaSsrOwogCX0KLQlzPShjaGFyKiltYWxsb2MobGVuKTsKKwlzPShjaGFyKil4bWFsbG9jKGxlbik7CiAJKnM9J1wwJzsKIAl3aGlsZSAoaTxucm9ma2V5d29yZHMpIHsKIAkJc3RyY2F0KHMsa2V5d29yZHNbaV0pOwpAQCAtMTQ0NSw3ICsxNDQ2LDcgQEAKIAkJbGVuKz1zdHJsZW4oa2V5d29yZHNbaV0pKzE7CiAJCWkrKzsKIAl9Ci0Jcz0oY2hhciopbWFsbG9jKGxlbik7CisJcz0oY2hhciopeG1hbGxvYyhsZW4pOwogCSpzPSdcMCc7CiAJd2hpbGUgKGk8bnJvZmtleXdvcmRzKSB7CiAJCXN0cmNhdChzLGtleXdvcmRzW2ldKTsKQEAgLTE1NjksNyArMTU3MCw3IEBACiAJCWxlbis9c3RybGVuKGtleXdvcmRzW2ldKSsxOwogCQlpKys7CiAJfQotCXM9KGNoYXIqKW1hbGxvYyhsZW4pOworCXM9KGNoYXIqKXhtYWxsb2MobGVuKTsKIAkqcz0nXDAnOwogCXdoaWxlIChpPG5yb2ZrZXl3b3JkcykgewogCQlzdHJjYXQocyxrZXl3b3Jkc1tpXSk7CkBAIC0xOTQxLDcgKzE5NDIsNyBAQAogCQkJCQkJYnJlYWs7CiAJCQkJCWorKzsKIAkJCQl9Ci0JCQkJcz0oY2hhciopbWFsbG9jKGxlbik7CisJCQkJcz0oY2hhciopeG1hbGxvYyhsZW4pOwogCQkJCXN0cmNweShzLGtleXdvcmRzW2krMV0rMSk7CiAJCQkJaz1qO2o9aSsyOwogCQkJCXdoaWxlIChqPD1rKSB7CkBAIC0yMDEwLDcgKzIwMTEsNyBAQAogCQkJCQkJYnJlYWs7CiAJCQkJCWorKzsKIAkJCQl9Ci0JCQkJcz0oY2hhciopbWFsbG9jKGxlbik7CisJCQkJcz0oY2hhciopeG1hbGxvYyhsZW4pOwogCQkJCXN0cmNweShzLGtleXdvcmRzW2krMV0rMSk7CiAJCQkJaz1qO2o9aSsyOwogCQkJCXdoaWxlIChqPD1rKSB7CkBAIC0yMTA1LDcgKzIxMDYsNyBAQAogCQlpPTE7LyogbnJvZmtleXdvcmRzID0gbnJvZnNwYWNlcysxICovCiAJCXM9YXJnczsKIAkJd2hpbGUgKChzPXN0cmNocihzLCcgJykpIT1OVUxMKSBpKysscysrOwotCQlrZXl3b3Jkcz0oY2hhcioqKW1hbGxvYyhzaXplb2YoY2hhciopKihpKzIpKTsKKwkJa2V5d29yZHM9KGNoYXIqKil4bWFsbG9jKHNpemVvZihjaGFyKikqKGkrMikpOwogCQlucm9ma2V5d29yZHM9aTsKIAkJcz1hcmdzO2k9MDsKIAkJd2hpbGUgKHMgJiYgaTxucm9ma2V5d29yZHMpIHsKQEAgLTIxMTYsNyArMjExNyw3IEBACiAJCWtleXdvcmRzW2ldPU5VTEw7CiAJfSBlbHNlIHsKIAkJbnJvZmtleXdvcmRzPTA7Ci0JCWtleXdvcmRzPShjaGFyKiopbWFsbG9jKHNpemVvZihjaGFyKikpOworCQlrZXl3b3Jkcz0oY2hhcioqKXhtYWxsb2Moc2l6ZW9mKGNoYXIqKSk7CiAJfQogCWR3RmxhZ3MgPSAwOyAvKiBkZWZhdWx0IGZsYWdzICovCiAJZm9yIChpPTA7aTxucm9ma2V5d29yZHM7KSB7CmRpZmYgLS1naXQgYS9tdWx0aW1lZGlhL21pZGkuYyBiL211bHRpbWVkaWEvbWlkaS5jCmluZGV4IGZhYTYxYjUuLmI3MzRlY2QgMTAwNjQ0Ci0tLSBhL211bHRpbWVkaWEvbWlkaS5jCisrKyBiL211bHRpbWVkaWEvbWlkaS5jCkBAIC0xOSw2ICsxOSw3IEBACiAjaW5jbHVkZSAibGR0LmgiCiAjaW5jbHVkZSAiZHJpdmVyLmgiCiAjaW5jbHVkZSAibW1zeXN0ZW0uaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKICNpbmNsdWRlICJzdGRkZWJ1Zy5oIgogI2luY2x1ZGUgImRlYnVnLmgiCkBAIC01MjAsNyArNTIxLDcgQEAKIAkJZHByaW50Zl9taWRpKHN0ZGRlYiwgIk1JRElfbWNpUmVjb3JkIC8vIE1DSV9UTz0lZCBcbiIsIGVuZCk7CiAJCX0KIAlscE1pZGlIZHIgPSAmTUNJTWlkaURldlt3RGV2SURdLk1pZGlIZHI7Ci0JbHBNaWRpSGRyLT5scERhdGEgPSAoTFBTVFIpIG1hbGxvYygxMjAwKTsKKwlscE1pZGlIZHItPmxwRGF0YSA9IChMUFNUUikgeG1hbGxvYygxMjAwKTsKIAlscE1pZGlIZHItPmR3QnVmZmVyTGVuZ3RoID0gMTAyNDsKIAlscE1pZGlIZHItPmR3VXNlciA9IDBMOwogCWxwTWlkaUhkci0+ZHdGbGFncyA9IDBMOwpkaWZmIC0tZ2l0IGEvbXVsdGltZWRpYS9tbXN5c3RlbS5jIGIvbXVsdGltZWRpYS9tbXN5c3RlbS5jCmluZGV4IGRiM2U3MDcuLjgxZjFjMWIgMTAwNjQ0Ci0tLSBhL211bHRpbWVkaWEvbW1zeXN0ZW0uYworKysgYi9tdWx0aW1lZGlhL21tc3lzdGVtLmMKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlICJtbXN5c3RlbS5oIgogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIHN0YXRpYyBpbnQJSW5zdGFsbGVkQ291bnQ7CiBzdGF0aWMgaW50CUluc3RhbGxlZExpc3RMZW47CkBAIC01MzMsNyArNTM0LDcgQEAKIAkJCW1zZ3B0ciA9ICJVbmtub3duIE1DSSBFcnJvciAhXG4iOwogCQkJYnJlYWs7CiAJCX0KLQltYXhidWYgPSBtaW4odUxlbmd0aCAtIDEsIHN0cmxlbihtc2dwdHIpKTsKKwltYXhidWYgPSBNSU4odUxlbmd0aCAtIDEsIHN0cmxlbihtc2dwdHIpKTsKIAlpZiAobWF4YnVmID4gMCkgc3RybmNweShscHN0ckJ1ZmZlciwgbXNncHRyLCBtYXhidWYpOwogCWxwc3RyQnVmZmVyW21heGJ1ZiArIDFdID0gJ1wwJzsKIAlyZXR1cm4oVFJVRSk7CkBAIC02OTksNyArNzAwLDcgQEAKIAkJCWlmIChscEluc3RhbGxOYW1lcyA9PSBOVUxMKSB7CiAJCQkJSW5zdGFsbGVkQ291bnQgPSAwOwogCQkJCUluc3RhbGxlZExpc3RMZW4gPSAwOwotCQkJCXB0ciA9IGxwSW5zdGFsbE5hbWVzID0gbWFsbG9jKDIwNDgpOworCQkJCXB0ciA9IGxwSW5zdGFsbE5hbWVzID0geG1hbGxvYygyMDQ4KTsKIAkJCQlHZXRQcml2YXRlUHJvZmlsZVN0cmluZygibWNpIiwgTlVMTCwgIiIsIGxwSW5zdGFsbE5hbWVzLCAyMDAwLCBTeXNGaWxlKTsKIAkJCQl3aGlsZShzdHJsZW4ocHRyKSA+IDApIHsKIAkJCQkJZHByaW50Zl9tY2koc3RkZGViLCAiLS0tPiAnJXMnIFxuIiwgcHRyKTsKQEAgLTkwMCw3ICs5MDEsNyBAQAogCQkJbXNncHRyID0gIlVua25vd24gTUlESSBFcnJvciAhXG4iOwogCQkJYnJlYWs7CiAJCX0KLQltYXhidWYgPSBtaW4odVNpemUgLSAxLCBzdHJsZW4obXNncHRyKSk7CisJbWF4YnVmID0gTUlOKHVTaXplIC0gMSwgc3RybGVuKG1zZ3B0cikpOwogCWlmIChtYXhidWYgPiAwKSBzdHJuY3B5KGxwVGV4dCwgbXNncHRyLCBtYXhidWYpOwogCWxwVGV4dFttYXhidWYgKyAxXSA9ICdcMCc7CiAJcmV0dXJuKFRSVUUpOwpAQCAtMTM1Niw3ICsxMzU3LDcgQEAKIAkJCW1zZ3B0ciA9ICJVbmtub3duIE1NU1lTVEVNIEVycm9yICFcbiI7CiAJCQlicmVhazsKIAkJfQotCW1heGJ1ZiA9IG1pbih1U2l6ZSAtIDEsIHN0cmxlbihtc2dwdHIpKTsKKwltYXhidWYgPSBNSU4odVNpemUgLSAxLCBzdHJsZW4obXNncHRyKSk7CiAJaWYgKG1heGJ1ZiA+IDApIHN0cm5jcHkobHBUZXh0LCBtc2dwdHIsIG1heGJ1Zik7CiAJbHBUZXh0W21heGJ1ZiArIDFdID0gJ1wwJzsKIAlyZXR1cm4oVFJVRSk7CmRpZmYgLS1naXQgYS9tdWx0aW1lZGlhL3RpbWUuYyBiL211bHRpbWVkaWEvdGltZS5jCmluZGV4IDUxOTNhYmQuLmM5ZTdmMjIgMTAwNjQ0Ci0tLSBhL211bHRpbWVkaWEvdGltZS5jCisrKyBiL211bHRpbWVkaWEvdGltZS5jCkBAIC0xMzUsNyArMTM1LDcgQEAKICAgICBpZiAobHBOZXdUaW1lciA9PSBOVUxMKQogCXJldHVybiAwOwogICAgIHdoaWxlIChscFRpbWVyICE9IE5VTEwpIHsKLQl3TmV3SUQgPSBtYXgod05ld0lELCBscFRpbWVyLT53VGltZXJJRCk7CisJd05ld0lEID0gTUFYKHdOZXdJRCwgbHBUaW1lci0+d1RpbWVySUQpOwogCWlmIChscFRpbWVyLT5OZXh0ID09IE5VTEwpCiAJICAgIGJyZWFrOwogCWxwVGltZXIgPSBscFRpbWVyLT5OZXh0OwpkaWZmIC0tZ2l0IGEvb2JqZWN0cy9iaXRibHQuYyBiL29iamVjdHMvYml0Ymx0LmMKaW5kZXggYWU3ZGQzMC4uODlhZTQwNCAxMDA2NDQKLS0tIGEvb2JqZWN0cy9iaXRibHQuYworKysgYi9vYmplY3RzL2JpdGJsdC5jCkBAIC0xNyw2ICsxNyw3IEBACiAjaW5jbHVkZSAic3RkZGVidWcuaCIKIC8qICNkZWZpbmUgREVCVUdfQklUQkxUICovCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIAogI2RlZmluZSBEU1QgMCAgIC8qIERlc3RpbmF0aW9uIGRyYXdhYmxlICovCkBAIC0xMDYzLDExICsxMDY0LDExIEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRjU3JjLCB4U3JjLCB5U3JjLCB3aWR0aFNyYywgaGVpZ2h0U3JjLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmdmlzUmVjdFNyYywgJnZpc1JlY3REc3QgKSkKICAgICAgICAgICAgIHJldHVybiBUUlVFOwotICAgICAgICBkcHJpbnRmX2JpdGJsdCggc3RkZGViLCAiICAgIHZpc3NyYz0lZCwlZC0lZCwlZCB2aXNkc3Q9JWQsJWQtJWQsJWRcbiIsCi0gICAgICAgICAgICAgICAgICAgICAgICB2aXNSZWN0U3JjLmxlZnQsIHZpc1JlY3RTcmMudG9wLAotICAgICAgICAgICAgICAgICAgICAgICAgdmlzUmVjdFNyYy5yaWdodCwgdmlzUmVjdFNyYy5ib3R0b20sCi0gICAgICAgICAgICAgICAgICAgICAgICB2aXNSZWN0RHN0LmxlZnQsIHZpc1JlY3REc3QudG9wLAotICAgICAgICAgICAgICAgICAgICAgICAgdmlzUmVjdERzdC5yaWdodCwgdmlzUmVjdERzdC5ib3R0b20gKTsKKyAgICAgICAgZHByaW50Zl9iaXRibHQoIHN0ZGRlYiwgIiAgICB2aXNzcmM9JWxkLCVsZC0lbGQsJWxkIHZpc2RzdD0lbGQsJWxkLSVsZCwlbGRcbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAoTE9ORyl2aXNSZWN0U3JjLmxlZnQsIChMT05HKXZpc1JlY3RTcmMudG9wLAorICAgICAgICAgICAgICAgICAgICAgICAgKExPTkcpdmlzUmVjdFNyYy5yaWdodCwgKExPTkcpdmlzUmVjdFNyYy5ib3R0b20sCisgICAgICAgICAgICAgICAgICAgICAgICAoTE9ORyl2aXNSZWN0RHN0LmxlZnQsIChMT05HKXZpc1JlY3REc3QudG9wLAorICAgICAgICAgICAgICAgICAgICAgICAgKExPTkcpdmlzUmVjdERzdC5yaWdodCwgKExPTkcpdmlzUmVjdERzdC5ib3R0b20gKTsKICAgICB9CiAgICAgZWxzZQogICAgIHsKQEAgLTEwNzUsOSArMTA3Niw5IEBACiAgICAgICAgIGlmICghQklUQkxUX0dldFZpc1JlY3RhbmdsZXMoIGRjRHN0LCB4RHN0LCB5RHN0LCB3aWR0aERzdCwgaGVpZ2h0RHN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMLCAwLCAwLCAwLCAwLCBOVUxMLCAmdmlzUmVjdERzdCApKQogICAgICAgICAgICAgcmV0dXJuIFRSVUU7Ci0gICAgICAgIGRwcmludGZfYml0Ymx0KCBzdGRkZWIsICIgICAgdmlzc3JjPW5vbmUgdmlzZHN0PSVkLCVkLSVkLCVkXG4iLAotICAgICAgICAgICAgICAgICAgICAgICAgdmlzUmVjdERzdC5sZWZ0LCB2aXNSZWN0RHN0LnRvcCwKLSAgICAgICAgICAgICAgICAgICAgICAgIHZpc1JlY3REc3QucmlnaHQsIHZpc1JlY3REc3QuYm90dG9tICk7CisgICAgICAgIGRwcmludGZfYml0Ymx0KCBzdGRkZWIsICIgICAgdmlzc3JjPW5vbmUgdmlzZHN0PSVsZCwlbGQtJWxkLCVsZFxuIiwKKyAgICAgICAgICAgICAgICAgICAgICAgIChMT05HKXZpc1JlY3REc3QubGVmdCwgKExPTkcpdmlzUmVjdERzdC50b3AsCisgICAgICAgICAgICAgICAgICAgICAgICAoTE9ORyl2aXNSZWN0RHN0LnJpZ2h0LCAoTE9ORyl2aXNSZWN0RHN0LmJvdHRvbSApOwogICAgIH0KIAogICAgIHdpZHRoICA9IHZpc1JlY3REc3QucmlnaHQgLSB2aXNSZWN0RHN0LmxlZnQ7CmRpZmYgLS1naXQgYS9vYmplY3RzL2JydXNoLmMgYi9vYmplY3RzL2JydXNoLmMKaW5kZXggOTgyOTIwYS4uMTAzNGM0MCAxMDA2NDQKLS0tIGEvb2JqZWN0cy9icnVzaC5jCisrKyBiL29iamVjdHMvYnJ1c2guYwpAQCAtMTEsNiArMTEsNyBAQAogI2luY2x1ZGUgImNvbG9yLmgiCiAjaW5jbHVkZSAic3RkZGVidWcuaCIKICNpbmNsdWRlICJkZWJ1Zy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogI2RlZmluZSBOQl9IQVRDSF9TVFlMRVMgIDYKIApkaWZmIC0tZ2l0IGEvb2JqZWN0cy9jbGlwcGluZy5jIGIvb2JqZWN0cy9jbGlwcGluZy5jCmluZGV4IGU2YTMzMzUuLjA4ZTY1ZDcgMTAwNjQ0Ci0tLSBhL29iamVjdHMvY2xpcHBpbmcuYworKysgYi9vYmplY3RzL2NsaXBwaW5nLmMKQEAgLTMxMSw4ICszMTEsOSBAQAogICAgIFJFQ1QgdG1wUmVjdDsKICAgICBEQyAqIGRjID0gKERDICopIEdESV9HZXRPYmpQdHIoIGhkYywgRENfTUFHSUMgKTsKICAgICBpZiAoIWRjKSByZXR1cm4gRkFMU0U7Ci0gICAgZHByaW50Zl9jbGlwcGluZyhzdGRkZWIsIlJlY3RWaXNpYmxlOiAiTlBGTVQiICVkLCVkeCVkLCVkXG4iLAotICAgICAgICAgICAgICAgICAgICAgaGRjLCByZWN0LT5sZWZ0LCByZWN0LT50b3AsIHJlY3QtPnJpZ2h0LCByZWN0LT5ib3R0b20gKTsKKyAgICBkcHJpbnRmX2NsaXBwaW5nKHN0ZGRlYiwiUmVjdFZpc2libGU6ICJOUEZNVCIgJWxkLCVsZHglbGQsJWxkXG4iLAorICAgICAgICAgICAgICAgICAgICAgaGRjLCAoTE9ORylyZWN0LT5sZWZ0LCAoTE9ORylyZWN0LT50b3AsIChMT05HKXJlY3QtPnJpZ2h0LAorCQkgICAgIChMT05HKXJlY3QtPmJvdHRvbSApOwogICAgIGlmICghZGMtPncuaEdDQ2xpcFJnbikgcmV0dXJuIEZBTFNFOwogICAgIC8qIGNvcHkgcmVjdGFuZ2xlIHRvIGF2b2lkIG92ZXJ3cml0aW5nIGJ5IExQdG9EUCAqLwogICAgIHRtcFJlY3QgPSAqcmVjdDsKZGlmZiAtLWdpdCBhL29iamVjdHMvY29sb3IuYyBiL29iamVjdHMvY29sb3IuYwppbmRleCA1OTQxMzQwLi40MWUyMjJjIDEwMDY0NAotLS0gYS9vYmplY3RzL2NvbG9yLmMKKysrIGIvb2JqZWN0cy9jb2xvci5jCkBAIC0xMiw2ICsxMiw3IEBACiAjaW5jbHVkZSAiZ2RpLmgiCiAjaW5jbHVkZSAiY29sb3IuaCIKICNpbmNsdWRlICJwYWxldHRlLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiBDb2xvcm1hcCBDT0xPUl9XaW5Db2xvcm1hcCA9IDA7CiBpbnQgQ09MT1JfRml4ZWRNYXAgPSAwOwpAQCAtMTI2LDggKzEyNyw4IEBACiAKICAgICBpZiAoKENPTE9SX1dpbkNvbG9ybWFwID09IERlZmF1bHRDb2xvcm1hcE9mU2NyZWVuKHNjcmVlbikpICYmIChzY3JlZW5EZXB0aCA8PSA4KSkKICAgICB7Ci0gICAgICAgIENPTE9SX1BhbGV0dGVUb1BpeGVsID0gKGludCAqKW1hbGxvYyggc2l6ZW9mKGludCkgKiBzaXplICk7Ci0gICAgICAgIENPTE9SX1BpeGVsVG9QYWxldHRlID0gKGludCAqKW1hbGxvYyggc2l6ZW9mKGludCkgKiBzaXplICk7CisgICAgICAgIENPTE9SX1BhbGV0dGVUb1BpeGVsID0gKGludCAqKXhtYWxsb2MoIHNpemVvZihpbnQpICogc2l6ZSApOworICAgICAgICBDT0xPUl9QaXhlbFRvUGFsZXR0ZSA9IChpbnQgKil4bWFsbG9jKCBzaXplb2YoaW50KSAqIHNpemUgKTsKICAgICAgICAgZm9yIChpID0gMDsgaSA8IHNpemU7IGkrKykgIC8qIFNldCB0aGUgZGVmYXVsdCBtYXBwaW5nICovCiAgICAgICAgICAgICBDT0xPUl9QYWxldHRlVG9QaXhlbFtpXSA9IENPTE9SX1BpeGVsVG9QYWxldHRlW2ldID0gaTsKICAgICB9CkBAIC0zMzQsNiArMzM1LDcgQEAKICAgICAgICAgICAgIGlkeCA9IGNvbG9yICYgMHhmZmZmOwogICAgICAgICAgICAgaWYgKGlkeCA+PSBwYWxQdHItPmxvZ3BhbGV0dGUucGFsTnVtRW50cmllcykKICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkNPTE9SX1RvUGh5c2ljYWwoJWx4KSA6IGlkeCAlZCBpcyBvdXQgb2YgYm91bmRzLCBhc3N1bWluZyBibGFja1xuIiwgY29sb3IsIGlkeCk7CiAgICAgICAgICAgICAgICAgLyogb3V0IG9mIGJvdW5kcyAqLwogICAgICAgICAgICAgICAgIHJlZCA9IGdyZWVuID0gYmx1ZSA9IDA7CiAgICAgICAgICAgICB9CkBAIC0zNzUsMTIgKzM3NywyMCBAQAogICAgIH0KICAgICBpZiAoZGMmJmRjLT51LngucGFsLm1hcHBpbmdTaXplKQogICAgIHsKLSAgICAgICAgaWYgKGluZGV4ID49IGRjLT51LngucGFsLm1hcHBpbmdTaXplKSByZXR1cm4gMDsKKyAgICAgICAgaWYgKGluZGV4ID49IGRjLT51LngucGFsLm1hcHBpbmdTaXplKQorICAgICAgICB7CisgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIkNPTE9SX1RvUGh5c2ljYWwoJWx4KSA6IGlkeCAlZCBpcyA+PSBkYy0+dS54LnBhbC5tYXBwaW5nU2l6ZSwgYXNzdW1pbmcgcGl4ZWwgMFxuIiwgY29sb3IsIGluZGV4KTsKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICB9CiAgICAgICAgIG1hcHBpbmcgPSAoV09SRCAqKSBHRElfSEVBUF9MSU5fQUREUiggZGMtPnUueC5wYWwuaE1hcHBpbmcgKTsKICAgICB9CiAgICAgZWxzZQogICAgIHsKLSAgICAgICAgaWYgKGluZGV4ID49IE5CX1JFU0VSVkVEX0NPTE9SUykgcmV0dXJuIDA7CisgICAgICAgIGlmIChpbmRleCA+PSBOQl9SRVNFUlZFRF9DT0xPUlMpCisgICAgICAgIHsKKyAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiQ09MT1JfVG9QaHlzaWNhbCglbHgpIDogaWR4ICVkIGlzID49IE5CX1JFU0VSVkVEX0NPTE9SUywgYXNzdW1pbmcgcGl4ZWwgMFxuIiwgY29sb3IsIGluZGV4KTsKKwkgICAgcmV0dXJuIDA7CisgICAgICAgIH0KICAgICAgICAgbWFwcGluZyA9IChXT1JEICopIEdESV9IRUFQX0xJTl9BRERSKCBoU3lzQ29sb3JUcmFuc2xhdGlvbiApOwogICAgIH0KICAgICBpZiAobWFwcGluZykgcmV0dXJuIG1hcHBpbmdbaW5kZXhdOwpAQCAtNDI1LDIwICs0MzUsNiBAQAogCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogICAgICAgICAgIEdldE5lYXJlc3RDb2xvciAgICAoR0RJLjE1NCkKLSAqLwotQ09MT1JSRUYgR2V0TmVhcmVzdENvbG9yKCBIREMgaGRjLCBDT0xPUlJFRiBjb2xvciApCi17Ci0gICAgV09SRCBpbmRleDsKLSAgICBEQyAqZGMgPSAoREMgKikgR0RJX0dldE9ialB0ciggaGRjLCBEQ19NQUdJQyApOwotICAgIGlmICghZGMpIHJldHVybiAwOwotICAgIGlmIChzY3JlZW5EZXB0aCA+IDgpIHJldHVybiBjb2xvcjsgLyogRklYTUUgKi8KLSAgICBpbmRleCA9IChXT1JEKShDT0xPUl9Ub1BoeXNpY2FsKCBkYywgY29sb3IgJiAweGZmZmZmZiApICYgMHhmZmZmKTsKLSAgICByZXR1cm4gUEFMRVRURUlOREVYKCBpbmRleCApOwotfQotCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIFJlYWxpemVEZWZhdWx0UGFsZXR0ZSAgICAoR0RJLjM2NSkKICAqLwogV09SRCBSZWFsaXplRGVmYXVsdFBhbGV0dGUoIEhEQyBoZGMgKQpkaWZmIC0tZ2l0IGEvb2JqZWN0cy9jdXJzb3JpY29uLmMgYi9vYmplY3RzL2N1cnNvcmljb24uYwppbmRleCA2Y2MzZjJhLi5mY2I1NTNlIDEwMDY0NAotLS0gYS9vYmplY3RzL2N1cnNvcmljb24uYworKysgYi9vYmplY3RzL2N1cnNvcmljb24uYwpAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIndpbi5oIgogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIAogQ3Vyc29yIENVUlNPUklDT05fWEN1cnNvciA9IE5vbmU7ICAvKiBDdXJyZW50IFggY3Vyc29yICovCkBAIC0yNzgsOCArMjc5LDggQEAKIAogICAgIHNpemUgPSBESUJfQml0bWFwSW5mb1NpemUoIGJtaSwgRElCX1JHQl9DT0xPUlMgKTsKICAgICAvKiBNYWtlIHN1cmUgd2UgaGF2ZSByb29tIGZvciB0aGUgbW9ub2Nocm9tZSBiaXRtYXAgbGF0ZXIgb24gKi8KLSAgICBzaXplID0gbWF4KCBzaXplLCBzaXplb2YoQklUTUFQSU5GT0hFQURFUikgKyAyKnNpemVvZihSR0JRVUFEKSApOwotICAgIHBJbmZvID0gKEJJVE1BUElORk8gKiltYWxsb2MoIHNpemUgKTsKKyAgICBzaXplID0gTUFYKCBzaXplLCBzaXplb2YoQklUTUFQSU5GT0hFQURFUikgKyAyKnNpemVvZihSR0JRVUFEKSApOworICAgIHBJbmZvID0gKEJJVE1BUElORk8gKil4bWFsbG9jKCBzaXplICk7CiAgICAgbWVtY3B5KCBwSW5mbywgYm1pLCBzaXplICk7CiAKICAgICBpZiAocEluZm8tPmJtaUhlYWRlci5iaVNpemUgPT0gc2l6ZW9mKEJJVE1BUElORk9IRUFERVIpKQpAQCAtNDQyLDcgKzQ0Myw3IEBACiAKICAgICByZXR1cm4gQ1VSU09SSUNPTl9Mb2FkKCBoSW5zdGFuY2UsIG5hbWUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU1lTTUVUUklDU19DWElDT04sIFNZU01FVFJJQ1NfQ1lJQ09OLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1pbiggMTYsIDEgPDwgc2NyZWVuRGVwdGggKSwgRkFMU0UgKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBNSU4oIDE2LCAxIDw8IHNjcmVlbkRlcHRoICksIEZBTFNFICk7CiB9CiAKIApAQCAtNTA2LDcgKzUwNyw3IEBACiAgKi8KIEhJQ09OIENvcHlJY29uKCBIQU5ETEUgaEluc3RhbmNlLCBISUNPTiBoSWNvbiApCiB7Ci0gICAgZHByaW50Zl9pY29uKCBzdGRkZWIsICJDb3B5SWNvbjogJTA0eCAlMDR4XG4iLCBoSW5zdGFuY2UsIGhJY29uICk7CisgICAgZHByaW50Zl9pY29uKCBzdGRkZWIsICJDb3B5SWNvbjogIk5QRk1UIiAiTlBGTVQiXG4iLCBoSW5zdGFuY2UsIGhJY29uICk7CiAgICAgcmV0dXJuIENVUlNPUklDT05fQ29weSggaEluc3RhbmNlLCBoSWNvbiApOwogfQogCkBAIC01MTYsNyArNTE3LDcgQEAKICAqLwogSENVUlNPUiBDb3B5Q3Vyc29yKCBIQU5ETEUgaEluc3RhbmNlLCBIQ1VSU09SIGhDdXJzb3IgKQogewotICAgIGRwcmludGZfY3Vyc29yKCBzdGRkZWIsICJDb3B5Q3Vyc29yOiAlMDR4ICUwNHhcbiIsIGhJbnN0YW5jZSwgaEN1cnNvciApOworICAgIGRwcmludGZfY3Vyc29yKCBzdGRkZWIsICJDb3B5Q3Vyc29yOiAiTlBGTVQiICJOUEZNVCJcbiIsIGhJbnN0YW5jZSwgaEN1cnNvciApOwogICAgIHJldHVybiBDVVJTT1JJQ09OX0NvcHkoIGhJbnN0YW5jZSwgaEN1cnNvciApOwogfQogCkBAIC01MjYsOCArNTI3LDkgQEAKICAqLwogQk9PTCBEZXN0cm95SWNvbiggSElDT04gaEljb24gKQogewotICAgIGRwcmludGZfaWNvbiggc3RkZGViLCAiRGVzdHJveUljb246ICUwNHhcbiIsIGhJY29uICk7Ci0gICAgcmV0dXJuIEdsb2JhbEZyZWUoIGhJY29uICk7CisgICAgZHByaW50Zl9pY29uKCBzdGRkZWIsICJEZXN0cm95SWNvbjogIk5QRk1UIlxuIiwgaEljb24gKTsKKyAgICAvKiBGSVhNRTogc2hvdWxkIGNoZWNrIGZvciBPRU0gaWNvbiBoZXJlICovCisgICAgcmV0dXJuIChHbG9iYWxGcmVlKCBoSWNvbiApICE9IDApOwogfQogCiAKQEAgLTUzNiw4ICs1MzgsOSBAQAogICovCiBCT09MIERlc3Ryb3lDdXJzb3IoIEhDVVJTT1IgaEN1cnNvciApCiB7Ci0gICAgZHByaW50Zl9jdXJzb3IoIHN0ZGRlYiwgIkRlc3Ryb3lDdXJzb3I6ICUwNHhcbiIsIGhDdXJzb3IgKTsKLSAgICByZXR1cm4gR2xvYmFsRnJlZSggaEN1cnNvciApOworICAgIGRwcmludGZfY3Vyc29yKCBzdGRkZWIsICJEZXN0cm95Q3Vyc29yOiAiTlBGTVQiXG4iLCBoQ3Vyc29yICk7CisgICAgLyogRklYTUU6IHNob3VsZCBjaGVjayBmb3IgT0VNIGN1cnNvciBoZXJlICovCisgICAgcmV0dXJuIChHbG9iYWxGcmVlKCBoQ3Vyc29yICkgIT0gMCk7CiB9CiAKIApAQCAtNjI4LDcgKzYzMSw3IEBACiAgICAgICAgIGlmICghKHB0ciA9IChDVVJTT1JJQ09OSU5GTyopR2xvYmFsTG9jayggaEN1cnNvciApKSkgcmV0dXJuIEZBTFNFOwogICAgICAgICBpZiAocHRyLT5iUGxhbmVzICogcHRyLT5iQml0c1BlclBpeGVsICE9IDEpCiAgICAgICAgIHsKLSAgICAgICAgICAgIGZwcmludGYoIHN0ZGVyciwgIkN1cnNvciAlMDR4IGhhcyBtb3JlIHRoYW4gMSBicHAhXG4iLCBoQ3Vyc29yICk7CisgICAgICAgICAgICBmcHJpbnRmKCBzdGRlcnIsICJDdXJzb3IgIk5QRk1UIiBoYXMgbW9yZSB0aGFuIDEgYnBwIVxuIiwgaEN1cnNvciApOwogICAgICAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgICAgICB9CiAKQEAgLTY3MiwyMiArNjc1LDI2IEBACiAgICAgICAgICAgICAgKiBiaXRzIG9uIHRoZSBzY3JlZW4pIHRvIGJsYWNrLiBUaGlzIHJlcXVpcmUgc29tZSBib29sZWFuCiAgICAgICAgICAgICAgKiBhcml0aG1ldGljOgogICAgICAgICAgICAgICoKLSAgICAgICAgICAgICAqICAgV2luZG93cyAgICAgICAgICAgICAgICAgICAgICAgIFgxMQotICAgICAgICAgICAgICogWG9yICAgIEFuZCAgICAgIFJlc3VsdCAgICAgIEJpdHMgICAgIE1hc2sKLSAgICAgICAgICAgICAqICAwICAgICAgMCAgICAgYmxhY2sgICAgICAgICAgMCAgICAgICAgMQotICAgICAgICAgICAgICogIDAgICAgICAxICAgICBubyBjaGFuZ2UgICAgICBYICAgICAgICAwCi0gICAgICAgICAgICAgKiAgMSAgICAgIDAgICAgIHdoaXRlICAgICAgICAgIDEgICAgICAgIDEKLSAgICAgICAgICAgICAqICAxICAgICAgMSAgICAgaW52ZXJ0ZWQgICAgICAgMCAgICAgICAgMSAgKD1ibGFjaykKKyAgICAgICAgICAgICAqICAgICAgICAgV2luZG93cyAgICAgICAgICB8ICAgICAgICAgIFgxMQorICAgICAgICAgICAgICogWG9yICAgIEFuZCAgICAgIFJlc3VsdCAgIHwgICBCaXRzICAgICBNYXNrICAgICBSZXN1bHQKKyAgICAgICAgICAgICAqICAwICAgICAgMCAgICAgYmxhY2sgICAgICB8ICAgIDAgICAgICAgIDEgICAgIGJhY2tncm91bmQKKyAgICAgICAgICAgICAqICAwICAgICAgMSAgICAgbm8gY2hhbmdlICB8ICAgIFggICAgICAgIDAgICAgIG5vIGNoYW5nZQorICAgICAgICAgICAgICogIDEgICAgICAwICAgICB3aGl0ZSAgICAgIHwgICAgMSAgICAgICAgMSAgICAgZm9yZWdyb3VuZAorICAgICAgICAgICAgICogIDEgICAgICAxICAgICBpbnZlcnRlZCAgIHwgICAgMCAgICAgICAgMSAgICAgYmFja2dyb3VuZAogICAgICAgICAgICAgICoKICAgICAgICAgICAgICAqIHdoaWNoIGdpdmVzOgotICAgICAgICAgICAgICogIEJpdHMgPSAnWG9yJyB4b3IgJ0FuZCcKKyAgICAgICAgICAgICAqICBCaXRzID0gJ1hvcicgYW5kIG5vdCAnQW5kJwogICAgICAgICAgICAgICogIE1hc2sgPSAnWG9yJyBvciBub3QgJ0FuZCcKKyAgICAgICAgICAgICAqCisgICAgICAgICAgICAgKiBGSVhNRTogYXBwYXJlbnRseSBzb21lIHNlcnZlcnMgZG8gc3VwcG9ydCAnaW52ZXJ0ZWQnIGNvbG9yLgorICAgICAgICAgICAgICogSSBkb24ndCBrbm93IGlmIGl0J3MgY29ycmVjdCBwZXIgdGhlIFggc3BlYywgYnV0IG1heWJlCisgICAgICAgICAgICAgKiB3ZSBvdWdodCB0byB0YWtlIGFkdmFudGFnZSBvZiBpdC4gIC0tIEFKCiAgICAgICAgICAgICAgKi8KICAgICAgICAgICAgIFhDb3B5QXJlYSggZGlzcGxheSwgcGl4bWFwQWxsLCBwaXhtYXBCaXRzLCBCSVRNQVBfbW9ub0dDLAogICAgICAgICAgICAgICAgICAgICAgICAwLCAwLCBwdHItPm5XaWR0aCwgcHRyLT5uSGVpZ2h0LCAwLCAwICk7CiAgICAgICAgICAgICBYQ29weUFyZWEoIGRpc3BsYXksIHBpeG1hcEFsbCwgcGl4bWFwTWFzaywgQklUTUFQX21vbm9HQywKICAgICAgICAgICAgICAgICAgICAgICAgMCwgMCwgcHRyLT5uV2lkdGgsIHB0ci0+bkhlaWdodCwgMCwgMCApOwotICAgICAgICAgICAgWFNldEZ1bmN0aW9uKCBkaXNwbGF5LCBCSVRNQVBfbW9ub0dDLCBHWHhvciApOworICAgICAgICAgICAgWFNldEZ1bmN0aW9uKCBkaXNwbGF5LCBCSVRNQVBfbW9ub0dDLCBHWGFuZFJldmVyc2UgKTsKICAgICAgICAgICAgIFhDb3B5QXJlYSggZGlzcGxheSwgcGl4bWFwQWxsLCBwaXhtYXBCaXRzLCBCSVRNQVBfbW9ub0dDLAogICAgICAgICAgICAgICAgICAgICAgICAwLCBwdHItPm5IZWlnaHQsIHB0ci0+bldpZHRoLCBwdHItPm5IZWlnaHQsIDAsIDAgKTsKICAgICAgICAgICAgIFhTZXRGdW5jdGlvbiggZGlzcGxheSwgQklUTUFQX21vbm9HQywgR1hvclJldmVyc2UgKTsKQEAgLTc0MCw3ICs3NDcsNyBAQAogICAgIEhDVVJTT1IgaE9sZEN1cnNvcjsKIAogICAgIGlmIChoQ3Vyc29yID09IGhBY3RpdmVDdXJzb3IpIHJldHVybiBoQWN0aXZlQ3Vyc29yOyAgLyogTm8gY2hhbmdlICovCi0gICAgZHByaW50Zl9jdXJzb3IoIHN0ZGRlYiwgIlNldEN1cnNvcjogJTA0eFxuIiwgaEN1cnNvciApOworICAgIGRwcmludGZfY3Vyc29yKCBzdGRkZWIsICJTZXRDdXJzb3I6ICJOUEZNVCJcbiIsIGhDdXJzb3IgKTsKICAgICBoT2xkQ3Vyc29yID0gaEFjdGl2ZUN1cnNvcjsKICAgICBoQWN0aXZlQ3Vyc29yID0gaEN1cnNvcjsKICAgICAvKiBDaGFuZ2UgdGhlIGN1cnNvciBzaGFwZSBvbmx5IGlmIGl0IGlzIHZpc2libGUgKi8KQEAgLTc1NSw3ICs3NjIsNyBAQAogdm9pZCBTZXRDdXJzb3JQb3MoIHNob3J0IHgsIHNob3J0IHkgKQogewogICAgIGRwcmludGZfY3Vyc29yKCBzdGRkZWIsICJTZXRDdXJzb3JQb3M6IHg9JWQgeT0lZFxuIiwgeCwgeSApOwotICAgIFhXYXJwUG9pbnRlciggZGlzcGxheSwgTm9uZSwgcm9vdFdpbmRvdywgMCwgMCwgMCwgMCwgeCwgeSApOworICAgIFhXYXJwUG9pbnRlciggZGlzcGxheSwgcm9vdFdpbmRvdywgcm9vdFdpbmRvdywgMCwgMCwgMCwgMCwgeCwgeSApOwogfQogCiAKQEAgLTgxOCw3ICs4MjUsOCBAQAogCXB0LT54ID0gcm9vdFggKyBkZXNrdG9wWDsKIAlwdC0+eSA9IHJvb3RZICsgZGVza3RvcFk7CiAgICAgfQotICAgIGRwcmludGZfY3Vyc29yKHN0ZGRlYiwgIkdldEN1cnNvclBvczogcmV0PSVkLCVkXG4iLCBwdC0+eCwgcHQtPnkgKTsKKyAgICBkcHJpbnRmX2N1cnNvcihzdGRkZWIsICJHZXRDdXJzb3JQb3M6IHJldD0lbGQsJWxkXG4iLCAoTE9ORylwdC0+eCwgCisJCSAgIChMT05HKXB0LT55ICk7CiB9CiAKIApAQCAtODM2LDcgKzg0NCw3IEBACiAgKi8KIFdPUkQgR2V0SWNvbklEKCBIQU5ETEUgaFJlc291cmNlLCBEV09SRCByZXNUeXBlICkKIHsKLSAgICBmcHJpbnRmKCBzdGRlcnIsICJHZXRJY29uSWQoJTA0eCwlbGQpOiBlbXB0eSBzdHViIVxuIiwKKyAgICBmcHJpbnRmKCBzdGRlcnIsICJHZXRJY29uSWQoIk5QRk1UIiwlbGQpOiBlbXB0eSBzdHViIVxuIiwKICAgICAgICAgICAgICBoUmVzb3VyY2UsIHJlc1R5cGUgKTsKICAgICByZXR1cm4gMDsKIH0KQEAgLTg0Nyw3ICs4NTUsNyBAQAogICovCiBISUNPTiBMb2FkSWNvbkhhbmRsZXIoIEhBTkRMRSBoUmVzb3VyY2UsIEJPT0wgYk5ldyApCiB7Ci0gICAgZnByaW50Ziggc3RkZXJyLCAiTG9hZEljb25IYW5kbGUoJTA0eCwlZCk6IGVtcHR5IHN0dWIhXG4iLAorICAgIGZwcmludGYoIHN0ZGVyciwgIkxvYWRJY29uSGFuZGxlKCJOUEZNVCIsJWQpOiBlbXB0eSBzdHViIVxuIiwKICAgICAgICAgICAgICBoUmVzb3VyY2UsIGJOZXcgKTsKICAgICByZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL29iamVjdHMvZGMuYyBiL29iamVjdHMvZGMuYwppbmRleCA3ZGJkNjhlLi40MWM5ODFhIDEwMDY0NAotLS0gYS9vYmplY3RzL2RjLmMKKysrIGIvb2JqZWN0cy9kYy5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSAiY29sb3IuaCIKICNpbmNsdWRlICJkZWJ1Zy5oIgogI2luY2x1ZGUgImZvbnQuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIHN0YXRpYyBEZXZpY2VDYXBzICogZGlzcGxheURldkNhcHMgPSBOVUxMOwogCkBAIC00NjMsNyArNDY0LDcgQEAKIAogICAgIGlmICghZGlzcGxheURldkNhcHMpCiAgICAgewotCWRpc3BsYXlEZXZDYXBzID0gKERldmljZUNhcHMgKikgbWFsbG9jKCBzaXplb2YoRGV2aWNlQ2FwcykgKTsKKwlkaXNwbGF5RGV2Q2FwcyA9IChEZXZpY2VDYXBzICopIHhtYWxsb2MoIHNpemVvZihEZXZpY2VDYXBzKSApOwogCURDX0ZpbGxEZXZDYXBzKCBkaXNwbGF5RGV2Q2FwcyApOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvb2JqZWN0cy9kaWIuYyBiL29iamVjdHMvZGliLmMKaW5kZXggMTA4MmI3NC4uM2MwMjA0NiAxMDA2NDQKLS0tIGEvb2JqZWN0cy9kaWIuYworKysgYi9vYmplY3RzL2RpYi5jCkBAIC0xNiw2ICsxNiw3IEBACiAjaW5jbHVkZSAic3RkZGVidWcuaCIKICNpbmNsdWRlICJjb2xvci5oIgogI2luY2x1ZGUgImRlYnVnLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgpAQCAtMjgwLDcgKzI4MSw3IEBACiAJQllURSAqYmVnaW4gPSBiaXRzOwogCiAgICAgICAgIGxpbmVzLS07Ci0Jd2hpbGUgKChJTlQpbGluZXMgPj0gMCkKKwl3aGlsZSAoKHNob3J0KWxpbmVzID49IDApCiAgICAgICAgIHsKIAkJbGVuZ3RoID0gKmJpdHMrKzsKIAkJaWYgKGxlbmd0aCkgewkvKiBlbmNvZGVkICovCkBAIC00NTEsNyArNDUyLDcgQEAKIAkJCSAgICogd2hhdCBjYXVzZWQgdGhlIHByZXZpb3VzIGltcGxlbWVudGF0aW9uIHRvIAogCQkJICAgKiBmYWlsLgkJCVtKQVldCiAJCQkgICAqLwotCQkJICBsaW5lPTA7IC8qIENhdXNlIGV4aXQgZnJvbSBkbyBsb29wLiAqLworCQkJICBsaW5lPS0xOyAvKiBDYXVzZSBleGl0IGZyb20gZG8gbG9vcC4gKi8KIAkJCSAgYnJlYWs7CiAJCSAgICAgIH0KIAkJICAgICAgCkBAIC01MTEsNyArNTEyLDcgQEAKIAkgICAgfSAgLyogcHJvY2VzcyBlaXRoZXIgYW4gZW5jb2RlZCBzZXF1ZW5jZSBvciBhbiBlc2NhcGUgc2VxdWVuY2UgKi8KIAkgIAogCSAgLyogV2UgZXhwZWN0IHRvIGNvbWUgaGVyZSBtb3JlIHRoYW4gb25jZSBwZXIgbGluZS4gKi8KLSAgICAgIH0gd2hpbGUgKGxpbmUgPiAwKTsgIC8qIERvIHRoaXMgdW50aWwgdGhlIGJpdG1hcCBpcyBmaWxsZWQgKi8KKyAgICAgIH0gd2hpbGUgKGxpbmUgPj0gMCk7ICAvKiBEbyB0aGlzIHVudGlsIHRoZSBiaXRtYXAgaXMgZmlsbGVkICovCiAgICAgCiAgICAgLyoKICAgICAgKiBFdmVyeWJvZHkgY29tZXMgaGVyZSBhdCB0aGUgZW5kLgpkaWZmIC0tZ2l0IGEvb2JqZWN0cy9mb250LmMgYi9vYmplY3RzL2ZvbnQuYwppbmRleCBiMWE4OWE4Li5iZTdhYzc2IDEwMDY0NAotLS0gYS9vYmplY3RzL2ZvbnQuYworKysgYi9vYmplY3RzL2ZvbnQuYwpAQCAtNTE4LDggKzUxOCw5IEBACiAgICAgc2l6ZS0+Y3kgPSBhYnMoKGRjLT51LnguZm9udC5mc3RydWN0LT5hc2NlbnQrZGMtPnUueC5mb250LmZzdHJ1Y3QtPmRlc2NlbnQpCiAJCSAgICAqIGRjLT53LlduZEV4dFkgLyBkYy0+dy5WcG9ydEV4dFkpOwogCi0gICAgZHByaW50Zl9mb250KHN0ZGRlYiwiR2V0VGV4dEV4dGVudFBvaW50KCJOUEZNVCIgJyUqLipzJyAlZCAlcCk6IHJldHVybmluZyAlZCwlZFxuIiwKLQkgICAgaGRjLCBjb3VudCwgY291bnQsIHN0ciwgY291bnQsIHNpemUsIHNpemUtPmN4LCBzaXplLT5jeSApOworICAgIGRwcmludGZfZm9udChzdGRkZWIsIkdldFRleHRFeHRlbnRQb2ludCgiTlBGTVQiICclKi4qcycgJWQgJXApOiByZXR1cm5pbmcgJWxkLCVsZFxuIiwKKwkJIGhkYywgY291bnQsIGNvdW50LCBzdHIsIGNvdW50LCBzaXplLCAoTE9ORylzaXplLT5jeCwgCisJCSAoTE9ORylzaXplLT5jeSApOwogICAgIHJldHVybiBUUlVFOwogfQogCmRpZmYgLS1naXQgYS9vYmplY3RzL2dkaW9iai5jIGIvb2JqZWN0cy9nZGlvYmouYwppbmRleCBiMjQzNDEyNS4uN2YwZTZhMyAxMDA2NDQKLS0tIGEvb2JqZWN0cy9nZGlvYmouYworKysgYi9vYmplY3RzL2dkaW9iai5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSAic3RkZGVidWcuaCIKIC8qICNkZWZpbmUgREVCVUdfR0RJICovCiAjaW5jbHVkZSAiZGVidWcuaCIKKyNpbmNsdWRlICJ4bWFsbG9jLmgiCiAKIExQU1RSIEdESV9IZWFwID0gTlVMTDsKIFdPUkQgR0RJX0hlYXBTZWwgPSAwOwpAQCAtMjAwLDcgKzIwMSw3IEBACiAJaW50CSAgICAgICAJaSA9IDE7CiAJaWYgKGhOZXdPYmogPT0gMCkgcmV0dXJuIEZBTFNFOwogCWlmIChscFBlbkJydXNoTGlzdCA9PSBOVUxMKSB7Ci0JCWxwUGVuQnJ1c2hMaXN0ID0gbWFsbG9jKE1BWF9PQkogKiBzaXplb2YoSEFORExFKSk7CisJCWxwUGVuQnJ1c2hMaXN0ID0geG1hbGxvYyhNQVhfT0JKICogc2l6ZW9mKEhBTkRMRSkpOwogCQlscFBlbkJydXNoTGlzdFswXSA9IDA7CiAJCWRwcmludGZfZ2RpKHN0ZGRlYiwiR0RJX0FwcGVuZFRvUGVuQnJ1c2hMaXN0KCkgbHBQZW5CcnVzaExpc3QgYWxsb2NhdGVkICFcbiIpOwogCX0KQEAgLTQ5NSw3ICs0OTYsNyBAQAogICAgICAgaWYgKGhlYWRlci0+d01hZ2ljID09IFBFTl9NQUdJQykgewogCVBFTl9HZXRPYmplY3QoIChQRU5PQkogKiloZWFkZXIsIHNpemVvZihMT0dQRU4pLCBscExvZyk7CiAJZHByaW50Zl9nZGkoc3RkZGViLCJFbnVtT2JqZWN0cyAvLyBEQ19QZW4gbG9wblN0eWxlPSUwNFhcbiIsICgoTFBMT0dQRU4pbHBMb2cpLT5sb3BuU3R5bGUpOwotCWRwcmludGZfZ2RpKHN0ZGRlYiwiRW51bU9iamVjdHMgLy8gRENfUGVuIGxvcG5XaWR0aD0lZFxuIiwgKChMUExPR1BFTilscExvZyktPmxvcG5XaWR0aC54KTsKKwlkcHJpbnRmX2dkaShzdGRkZWIsIkVudW1PYmplY3RzIC8vIERDX1BlbiBsb3BuV2lkdGg9JWxkXG4iLCAoTE9ORykoKExQTE9HUEVOKWxwTG9nKS0+bG9wbldpZHRoLngpOwogCWRwcmludGZfZ2RpKHN0ZGRlYiwiRW51bU9iamVjdHMgLy8gRENfUGVuIGxvcG5Db2xvcj0lMDhsWFxuIiwgKChMUExPR1BFTilscExvZyktPmxvcG5Db2xvcik7CiAgICAgICB9CiAgICAgICBuUmV0ID0gQ2FsbEVudW1PYmplY3RzUHJvYyhscEVudW1GdW5jLCBHRElfSEVBUF9TRUdfQUREUihoTG9nKSwKZGlmZiAtLWdpdCBhL29iamVjdHMvbWV0YWZpbGUuYyBiL29iamVjdHMvbWV0YWZpbGUuYwppbmRleCA5NjI4ZTk5Li5lMWQxNzZlIDEwMDY0NAotLS0gYS9vYmplY3RzL21ldGFmaWxlLmMKKysrIGIvb2JqZWN0cy9tZXRhZmlsZS5jCkBAIC01MCw2ICs1MCw3IEBACiAgIHN0cmNweShtZi0+RmlsZW5hbWUsIGxwRmlsZW5hbWUpOwogICBtZi0+d01hZ2ljID0gTUVUQUZJTEVfTUFHSUM7CiAgIGlmICgobWYtPmhGaWxlID0gX2xvcGVuKGxwRmlsZW5hbWUsIE9GX1JFQUQpKSA9PSBIRklMRV9FUlJPUikgeworICAgIEdsb2JhbEZyZWUobWYtPmhNZXRhSGRyKTsKICAgICBHbG9iYWxGcmVlKGhtZik7CiAgICAgcmV0dXJuIDA7CiAgIH0KQEAgLTYwLDEzICs2MSwxNiBAQAogICB9CiAgIF9sY2xvc2UobWYtPmhGaWxlKTsKIAorICBpZiAobWgtPm10VHlwZSAhPSAxKSB7CisgICAgR2xvYmFsRnJlZShtZi0+aE1ldGFIZHIpOworICAgIEdsb2JhbEZyZWUoaG1mKTsKKyAgICByZXR1cm4gMDsKKyAgfQogCiAgIEdsb2JhbFVubG9jayhtZi0+aE1ldGFIZHIpOwogICBHbG9iYWxVbmxvY2soaG1mKTsKLSAgaWYgKG1oLT5tdFR5cGUgIT0gMSkKLSAgICByZXR1cm4gMDsKLSAgZWxzZQotICAgIHJldHVybiBobWY7CisgIHJldHVybiBobWY7CisKIH0KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgpAQCAtODYsMTEgKzkwLDE0IEBACiAgICAgaWYgKCFoYW5kbGUpIHJldHVybiAwOwogICAgIGRjID0gKERDICopR0RJX0hFQVBfTElOX0FERFIoaGFuZGxlKTsKIAotICAgIGlmICghKGRjLT53LmhNZXRhRmlsZSA9IEdsb2JhbEFsbG9jKEdNRU1fTU9WRUFCTEUsIHNpemVvZihNRVRBRklMRSkpKSkKKyAgICBpZiAoIShkYy0+dy5oTWV0YUZpbGUgPSBHbG9iYWxBbGxvYyhHTUVNX01PVkVBQkxFLCBzaXplb2YoTUVUQUZJTEUpKSkpIHsKKyAgICAgICAgR0RJX0ZyZWVPYmplY3QoaGFuZGxlKTsKIAlyZXR1cm4gMDsKKyAgICB9CiAgICAgbWYgPSAoTUVUQUZJTEUgKilHbG9iYWxMb2NrKGRjLT53LmhNZXRhRmlsZSk7CiAgICAgaWYgKCEobWYtPmhNZXRhSGRyID0gR2xvYmFsQWxsb2MoR01FTV9NT1ZFQUJMRSwgc2l6ZW9mKE1FVEFIRUFERVIpKSkpCiAgICAgeworICAgICAgICBHRElfRnJlZU9iamVjdChoYW5kbGUpOwogCUdsb2JhbEZyZWUoZGMtPncuaE1ldGFGaWxlKTsKIAlyZXR1cm4gMDsKICAgICB9CkBAIC0xMDgsNyArMTE1LDEyIEBACiAgICAgewogCW1oLT5tdFR5cGUgPSAxOwogCXN0cmNweShtZi0+RmlsZW5hbWUsIGxwRmlsZW5hbWUpOworI2lmbmRlZiBXSU5FTElCCiAJbWYtPmhGaWxlID0gX2xjcmVhdChscEZpbGVuYW1lLCAwKTsKKyNlbHNlCisgICAgICAgIC8qIHRlbXBvcmFyeSBmaXggdW50aWwgX2xjcmVhdGUgd29ya3MgdW5kZXIgV0lORUxJQiAqLworCW1mLT5oRmlsZSA9IGNyZWF0KGxwRmlsZW5hbWUsIDA2NjYpOworI2VuZGlmCiAJaWYgKF9sd3JpdGUobWYtPmhGaWxlLCAoY2hhciAqKW1oLCBNRkhFQURFUlNJWkUpID09IC0xKQogCXsKIAkgICAgR2xvYmFsRnJlZShtZi0+aE1ldGFIZHIpOwpAQCAtMTk0LDcgKzIwNiw3IEBACiB7CiAgICAgTUVUQUZJTEUgKm1mID0gKE1FVEFGSUxFICopR2xvYmFsTG9jayhobWYpOwogCi0gICAgaWYgKG1mLT53TWFnaWMgIT0gTUVUQUZJTEVfTUFHSUMpCisgICAgaWYgKCFtZiB8fCBtZi0+d01hZ2ljICE9IE1FVEFGSUxFX01BR0lDKQogCXJldHVybiBGQUxTRTsKIAogICAgIEdsb2JhbEZyZWUobWYtPmhNZXRhSGRyKTsKQEAgLTQzNyw3ICs0NDksNyBAQAogCiAgICAgY2FzZSBNRVRBX1BPTFlQT0xZR09OOgogICAgICAgUG9seVBvbHlnb24oaGRjLCAoTFBQT0lOVCkobXItPnJkUGFyYW0gKyAqKG1yLT5yZFBhcmFtKSArIDEpLAotCQkgIChtci0+cmRQYXJhbSArIDEpLCAqKG1yLT5yZFBhcmFtKSk7IAorCQkgIChMUElOVCkobXItPnJkUGFyYW0gKyAxKSwgKihtci0+cmRQYXJhbSkpOyAKICAgICAgIGJyZWFrOwogCiAgICAgY2FzZSBNRVRBX1BPTFlMSU5FOgpAQCAtNDk5LDEyICs1MTEsMTMwIEBACiAJCSAgICAgQ3JlYXRlQnJ1c2hJbmRpcmVjdCgoTE9HQlJVU0ggKikoJihtci0+cmRQYXJhbSkpKSk7CiAJYnJlYWs7CiAKKyAgICAvKiBXLiBNYWdybzogU29tZSBuZXcgbWV0YWZpbGUgb3BlcmF0aW9ucy4gIE5vdCBhbGwgZGVidWdnZWQuICovCisgICAgY2FzZSBNRVRBX0NSRUFURVBBTEVUVEU6CisJTUZfQWRkSGFuZGxlKGh0LCBuSGFuZGxlcywgCisJCSAgICAgQ3JlYXRlUGFsZXR0ZSgoTFBMT0dQQUxFVFRFKW1yLT5yZFBhcmFtKSk7CisJYnJlYWs7CisKKyAgICBjYXNlIE1FVEFfU0VUVEVYVEFMSUdOOgorICAgICAgICBmcHJpbnRmKHN0ZGVyciwiUGxheU1ldGFGaWxlUmVjb3JkOiBTRVRURVhUQUxJR046ICVoZFxuIixtci0+cmRQYXJhbVswXSk7CisJU2V0VGV4dEFsaWduKGhkYywgKihtci0+cmRQYXJhbSkpOworCWJyZWFrOworCisgICAgY2FzZSBNRVRBX1NFTEVDVFBBTEVUVEU6CisJU2VsZWN0UGFsZXR0ZShoZGMsICooaHQtPm9iamVjdEhhbmRsZSArICoobXItPnJkUGFyYW0rMSkpLCoobXItPnJkUGFyYW0pKTsKKwlicmVhazsKKworICAgIGNhc2UgTUVUQV9TRVRNQVBQRVJGTEFHUzoKKwlTZXRNYXBwZXJGbGFncyhoZGMsICoobXItPnJkUGFyYW0pKTsKKwlicmVhazsKKworICAgIGNhc2UgTUVUQV9SRUFMSVpFUEFMRVRURToKKwlSZWFsaXplUGFsZXR0ZShoZGMpOworCWJyZWFrOworCisgICAgY2FzZSBNRVRBX0VTQ0FQRToKKwlkcHJpbnRmX21ldGFmaWxlKHN0ZGRlYiwiUGxheU1ldGFGaWxlUmVjb3JkOiBNRVRBX0VTQ0FQRSB1bmltcGxlbWVudGVkLlxuIik7CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBNRVRBX0VYVFRFWFRPVVQ6IC8qIEZJWE1FOiBkb24ndCBrbm93IHRoZSBleGFjdCBwYXJhbWV0ZXJzIGhlcmUgKi8KKyAgICAgICAgeworICAgICAgICBzaG9ydCB4LHksb3B0aW9ucyx4NSx4Nix4Nyx4ODsKKyAgICAgICAgeT1tci0+cmRQYXJhbVswXTsgIC8qIFggcG9zaXRpb24gKi8KKyAgICAgICAgeD1tci0+cmRQYXJhbVsxXTsgIC8qIFkgcG9zaXRpb24gKi8KKyAgICAgICAgczE9bXItPnJkUGFyYW1bMl07IC8qIFN0cmluZyBsZW5ndGggKi8KKyAgICAgICAgb3B0aW9ucz1tci0+cmRQYXJhbVszXTsKKyAgICAgICAgeDU9bXItPnJkUGFyYW1bKHMxKzEpLzIrNF07IC8qIHVua25vd24gbWVhbmluZyAqLworICAgICAgICB4Nj1tci0+cmRQYXJhbVsoczErMSkvMis1XTsgLyogdW5rbm93biBtZWFuaW5nICovCisgICAgICAgIHg3PW1yLT5yZFBhcmFtWyhzMSsxKS8yKzZdOyAvKiB1bmtub3duIG1lYW5pbmcgKi8KKyAgICAgICAgeDg9bXItPnJkUGFyYW1bKHMxKzEpLzIrN107IC8qIHVua25vd24gbWVhbmluZyAqLworCUV4dFRleHRPdXQoaGRjLCB4LCB5LCBvcHRpb25zLCAoTFBSRUNUKSAmbXItPnJkUGFyYW1bKHMxKzEpLzIrNF0sIChjaGFyICopKG1yLT5yZFBhcmFtICsgNCksIHMxLCBOVUxMKTsKKwkvKiBmcHJpbnRmKHN0ZGVyciwiRVhUVEVYVE9VVCAobGVuOiAlZCkgJWhkIDogJWhkICVoZCAlaGQgJWhkIFslc10uXG4iLAorICAgICAgICAgICAgKG1yLT5yZFNpemUtczEpLG9wdGlvbnMseDUseDYseDcseDgsKGNoYXIqKSAmKG1yLT5yZFBhcmFtWzRdKSApOyovCisgICAgICAgIH0KKyAgICAgICAgYnJlYWs7CisgICAgICAgIC8qIEVuZCBuZXcgbWV0YWZpbGUgb3BlcmF0aW9ucy4gKi8KKwogICAgIGRlZmF1bHQ6Ci0JZnByaW50ZihzdGRlcnIsIlBsYXlNZXRhRmlsZVJlY29yZDogVW5rbm93biByZWNvcmQgdHlwZSAleFxuIiwKKwlmcHJpbnRmKHN0ZGRlYiwiUGxheU1ldGFGaWxlUmVjb3JkOiBVbmtub3duIHJlY29yZCB0eXBlICV4XG4iLAogCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXItPnJkRnVuY3Rpb24pOwogICAgIH0KIH0KIAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogICAgICAgICBHZXRNZXRhRmlsZUJpdHMJCWJ5IFdpbGxpYW0gTWFncm8sIDE5IFNlcCAxOTk1CisgKgorICogVHJhZGUgaW4gYSBtZXRhIGZpbGUgb2JqZWN0IGhhbmRsZSBmb3IgYSBoYW5kbGUgdG8gdGhlIG1ldGEgZmlsZSBtZW1vcnkKKyAqLworSEFORExFIEdldE1ldGFGaWxlQml0cyhITUVUQUZJTEUgaG1mKQoreworCisgICAgLyogc2F2ZSBhd2F5IHRoZSBtZXRhIGZpbGUgYml0cyBoYW5kbGUgKi8KKyAgICBNRVRBRklMRSAqbWYgPSAoTUVUQUZJTEUgKilHbG9iYWxMb2NrKGhtZik7CisgICAgSEFORExFIGhNZW0gPSBtZi0+aE1ldGFIZHI7CisgICAgTUVUQUhFQURFUiAqbWggPSAoTUVUQUhFQURFUiAqKUdsb2JhbExvY2soaE1lbSk7CisKKyAgICBkcHJpbnRmX21ldGFmaWxlKHN0ZGRlYiwiR2V0TWV0YUZpbGVCaXRzOiBobWYgaW46ICV4XG4iLCBobWYpOworCisgICAgLyogY2FuJ3QgZ2V0IGJpdHMgb2YgZGlzayBiYXNlZCBtZXRhZmlsZSAqLworICAgIC8qIEZJWE1FOiBzaG91bGQgdGhlIGRpc2sgZmlsZSBiZSBsb2FkZWQgaW4gdGhpcyBjYXNlPyAqLworICAgIGlmKG1oLT5tdFR5cGUgPT0gMSkgeworICAgICAgICBmcHJpbnRmKHN0ZGVyciwKKyAgICAgICAgICAgICJHZXRNZXRhRmlsZUJpdHM6IGFwcGxpY2F0aW9uIHJlcXVlc3RlZCBiaXRzIG9mIGRpc2sgbWV0YSBmaWxlLlxuIik7CisgICAgICAgIEdsb2JhbFVubG9jayhoTWVtKTsKKyAgICAgICAgR2xvYmFsVW5sb2NrKGhtZik7CisgICAgICAgIHJldHVybiBGQUxTRTsKKyAgICB9CisgICAgCisgICAgLyogdW5sb2NrIHRoZSBtZW1vcnkgYW5kIGludmFsaWRhdGUgdGhlIG1ldGFmaWxlIGhhbmRsZSAqLworICAgIEdsb2JhbFVubG9jayhoTWVtKTsKKyAgICBHbG9iYWxGcmVlKGhtZik7CisKKyAgICBkcHJpbnRmX21ldGFmaWxlKHN0ZGRlYiwiR2V0TWV0YUZpbGVCaXRzOiBoTWVtIG91dDogJXhcbiIsIGhNZW0pOworCisgICAgcmV0dXJuIGhNZW07Cit9CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqICAgICAgICAgU2V0TWV0YUZpbGVCaXRzCQlieSBXaWxsaWFtIE1hZ3JvLCAxOSBTZXAgMTk5NQorICoKKyAqIFRyYWRlIGluIGEgbWV0YSBmaWxlIG1lbW9yeSBoYW5kbGUgZm9yIGEgaGFuZGxlIHRvIGEgbWV0YSBmaWxlIG9iamVjdAorICovCitITUVUQUZJTEUgU2V0TWV0YUZpbGVCaXRzKEhBTkRMRSBoTWVtKQoreworICAgIEhNRVRBRklMRSBobWY7CisgICAgTUVUQUZJTEUgKm1mOworICAgIE1FVEFIRUFERVIgKm1oID0gKE1FVEFIRUFERVIgKilHbG9iYWxMb2NrKGhNZW0pOworCisgICAgZHByaW50Zl9tZXRhZmlsZShzdGRkZWIsIlNldE1ldGFGaWxlQml0czogaE1lbSBpbjogJXhcbiIsIGhNZW0pOworCisgICAgaWYgKCFtaCkgcmV0dXJuIEZBTFNFOworCisgICAgLyogbm93IGl0IGlzIGEgbWVtb3J5IG1ldGEgZmlsZSAqLworICAgIG1oLT5tdFR5cGUgPSAwOworCisgICAgaG1mID0gR2xvYmFsQWxsb2MoR01FTV9NT1ZFQUJMRSwgc2l6ZW9mKE1FVEFGSUxFKSk7CisgICAgbWYgPSAoTUVUQUZJTEUgKilHbG9iYWxMb2NrKGhtZik7CisgICAgaWYgKCFtZikgeworICAgICAgR2xvYmFsVW5sb2NrKGhNZW0pOworICAgICAgR2xvYmFsRnJlZShobWYpOworICAgICAgcmV0dXJuIEZBTFNFOworICAgIH0KKworICAgIC8qIHVzZSB0aGUgc3VwcGxpZWQgbWVtb3J5IGhhbmRsZSAqLworICAgIG1mLT5oTWV0YUhkciA9IGhNZW07CisgICAgbWYtPndNYWdpYyA9IE1FVEFGSUxFX01BR0lDOworICAgIG1mLT5NZXRhT2Zmc2V0ID0gbWgtPm10SGVhZGVyU2l6ZSAqIDI7CisgICAgbWYtPmhGaWxlID0gbWYtPmhCdWZmZXIgPSAoSEFORExFKSBOVUxMOworCisgICAgR2xvYmFsVW5sb2NrKGhNZW0pOworICAgIEdsb2JhbFVubG9jayhobWYpOworCisgICAgZHByaW50Zl9tZXRhZmlsZShzdGRkZWIsIlNldE1ldGFGaWxlQml0czogaG1mIG91dDogJXhcbiIsIGhtZik7CisKKyAgICByZXR1cm4gaG1mOworfQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgICAgICAgIE1GX1dyaXRlUmVjb3JkCkBAIC01MzgsNyArNjY4LDcgQEAKICAgICB9CiAKICAgICBtaC0+bXRTaXplICs9IHJsZW4gLyAyOwotICAgIG1oLT5tdE1heFJlY29yZCA9IG1heChtaC0+bXRNYXhSZWNvcmQsIHJsZW4gLyAyKTsKKyAgICBtaC0+bXRNYXhSZWNvcmQgPSBNQVgobWgtPm10TWF4UmVjb3JkLCBybGVuIC8gMik7CiAgICAgR2xvYmFsVW5sb2NrKG1mLT5oTWV0YUhkcik7CiAgICAgcmV0dXJuIFRSVUU7CiB9CmRpZmYgLS1naXQgYS9vYmplY3RzL3BhbGV0dGUuYyBiL29iamVjdHMvcGFsZXR0ZS5jCmluZGV4IDdmYTJjZmUuLmNjZDBiNDIgMTAwNjQ0Ci0tLSBhL29iamVjdHMvcGFsZXR0ZS5jCisrKyBiL29iamVjdHMvcGFsZXR0ZS5jCkBAIC0yMyw2ICsyMyw1NiBAQAogCiBzdGF0aWMgV09SRCBTeXN0ZW1QYWxldHRlVXNlID0gU1lTUEFMX1NUQVRJQzsJLyogY3VycmVudGx5IG5vdCBjb25zaWRlcmVkICovCiAKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiAgICAgICAgICAgUEFMRVRURV9HZXROZWFyZXN0SW5kZXhBbmRDb2xvcgorICovCitzdGF0aWMgV09SRCBQQUxFVFRFX0dldE5lYXJlc3RJbmRleEFuZENvbG9yKEhQQUxFVFRFIGhwYWxldHRlLCBDT0xPUlJFRiAqY29sb3IpCit7CisgICAgaW50IGksIG1pbkRpc3QsIGRpc3Q7CisgICAgV09SRCBpbmRleCA9IDA7CisgICAgQllURSByLCBnLCBiOworICAgIFBBTEVUVEVFTlRSWSAqIGVudHJ5OworICAgIFBBTEVUVEVPQkogKiBwYWxQdHI7CisgICAgCisgICAgcGFsUHRyID0gKFBBTEVUVEVPQkogKikgR0RJX0dldE9ialB0ciggaHBhbGV0dGUsIFBBTEVUVEVfTUFHSUMgKTsKKyAgICBpZiAoIXBhbFB0cikgcmV0dXJuIDA7CisKKyAgICBpZiAoKENPTE9SX1dpbkNvbG9ybWFwICE9IERlZmF1bHRDb2xvcm1hcE9mU2NyZWVuKHNjcmVlbikpICYmCisJKGhwYWxldHRlID09IFNUT0NLX0RFRkFVTFRfUEFMRVRURSkpCisgICAgeworCWlmICgoKmNvbG9yICYgMHhmZmZmZmYpID09IDApIHJldHVybiAwOyAgLyogRW50cnkgMCBpcyBibGFjayAqLworCWlmICgoKmNvbG9yICYgMHhmZmZmZmYpID09IDB4ZmZmZmZmKSAgICAgLyogTWF4IGVudHJ5IGlzIHdoaXRlICovCisJICAgIHJldHVybiBwYWxQdHItPmxvZ3BhbGV0dGUucGFsTnVtRW50cmllcyAtIDE7CisgICAgfQorICAgIAorICAgIHIgPSBHZXRSVmFsdWUoKmNvbG9yKTsKKyAgICBnID0gR2V0R1ZhbHVlKCpjb2xvcik7CisgICAgYiA9IEdldEJWYWx1ZSgqY29sb3IpOworCisgICAgZW50cnkgPSBwYWxQdHItPmxvZ3BhbGV0dGUucGFsUGFsRW50cnk7CisgICAgZm9yIChpID0gMCwgbWluRGlzdCA9IE1BWElOVDsgbWluRGlzdCAhPTAgJiYKKyAgICAgICAgIGkgPCBwYWxQdHItPmxvZ3BhbGV0dGUucGFsTnVtRW50cmllcyA7IGkrKykKKyAgICB7CisJaWYgKGVudHJ5LT5wZUZsYWdzICE9IDB4ZmYpCisJeworCSAgICBkaXN0ID0gKHIgLSBlbnRyeS0+cGVSZWQpICogKHIgLSBlbnRyeS0+cGVSZWQpICsKKwkJICAgKGcgLSBlbnRyeS0+cGVHcmVlbikgKiAoZyAtIGVudHJ5LT5wZUdyZWVuKSArCisJCSAgIChiIC0gZW50cnktPnBlQmx1ZSkgKiAoYiAtIGVudHJ5LT5wZUJsdWUpOwkKKwkgICAgaWYgKGRpc3QgPCBtaW5EaXN0KQorCSAgICB7CisJCW1pbkRpc3QgPSBkaXN0OworCQlpbmRleCA9IGk7CisJICAgIH0KKwl9CisJZW50cnkrKzsKKyAgICB9CisgICAgZW50cnkgPSAmcGFsUHRyLT5sb2dwYWxldHRlLnBhbFBhbEVudHJ5W2luZGV4XTsKKyAgICAqY29sb3IgPSBSR0IoIGVudHJ5LT5wZVJlZCwgZW50cnktPnBlR3JlZW4sIGVudHJ5LT5wZUJsdWUgKTsKKyAgICByZXR1cm4gaW5kZXg7Cit9CisKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgICAgICAgICAgQ3JlYXRlUGFsZXR0ZSAgICAoR0RJLjM2MCkKICAqLwpAQCAtMTQ1LDUxICsxOTUsMzAgQEAKICAqLwogV09SRCBHZXROZWFyZXN0UGFsZXR0ZUluZGV4KCBIUEFMRVRURSBocGFsZXR0ZSwgQ09MT1JSRUYgY29sb3IgKQogewotICAgIGludCBpLCBtaW5EaXN0LCBkaXN0OwotICAgIFdPUkQgaW5kZXggPSAwOwotICAgIEJZVEUgciwgZywgYjsKLSAgICBQQUxFVFRFRU5UUlkgKiBlbnRyeTsKLSAgICBQQUxFVFRFT0JKICogcGFsUHRyOwotICAgIAotICAgIHBhbFB0ciA9IChQQUxFVFRFT0JKICopIEdESV9HZXRPYmpQdHIoIGhwYWxldHRlLCBQQUxFVFRFX01BR0lDICk7Ci0gICAgaWYgKCFwYWxQdHIpIHJldHVybiAwOwotCi0gICAgaWYgKChDT0xPUl9XaW5Db2xvcm1hcCAhPSBEZWZhdWx0Q29sb3JtYXBPZlNjcmVlbihzY3JlZW4pKSAmJgotCShocGFsZXR0ZSA9PSBTVE9DS19ERUZBVUxUX1BBTEVUVEUpKQotICAgIHsKLQlpZiAoKGNvbG9yICYgMHhmZmZmZmYpID09IDApIHJldHVybiAwOyAgLyogRW50cnkgMCBpcyBibGFjayAqLwotCWlmICgoY29sb3IgJiAweGZmZmZmZikgPT0gMHhmZmZmZmYpICAgICAvKiBNYXggZW50cnkgaXMgd2hpdGUgKi8KLQkgICAgcmV0dXJuIHBhbFB0ci0+bG9ncGFsZXR0ZS5wYWxOdW1FbnRyaWVzIC0gMTsKLSAgICB9Ci0gICAgCi0gICAgciA9IEdldFJWYWx1ZShjb2xvcik7Ci0gICAgZyA9IEdldEdWYWx1ZShjb2xvcik7Ci0gICAgYiA9IEdldEJWYWx1ZShjb2xvcik7Ci0KLSAgICBlbnRyeSA9IHBhbFB0ci0+bG9ncGFsZXR0ZS5wYWxQYWxFbnRyeTsKLSAgICBmb3IgKGkgPSAwLCBtaW5EaXN0ID0gTUFYSU5UOyBtaW5EaXN0ICE9MCAmJgotICAgICAgICAgaSA8IHBhbFB0ci0+bG9ncGFsZXR0ZS5wYWxOdW1FbnRyaWVzIDsgaSsrKQotICAgIHsKLQlpZiAoZW50cnktPnBlRmxhZ3MgIT0gMHhmZikKLQl7Ci0JICAgIGRpc3QgPSAociAtIGVudHJ5LT5wZVJlZCkgKiAociAtIGVudHJ5LT5wZVJlZCkgKwotCQkgICAoZyAtIGVudHJ5LT5wZUdyZWVuKSAqIChnIC0gZW50cnktPnBlR3JlZW4pICsKLQkJICAgKGIgLSBlbnRyeS0+cGVCbHVlKSAqIChiIC0gZW50cnktPnBlQmx1ZSk7CQotCSAgICBpZiAoZGlzdCA8IG1pbkRpc3QpCi0JICAgIHsKLQkJbWluRGlzdCA9IGRpc3Q7Ci0JCWluZGV4ID0gaTsKLQkgICAgfQotCX0KLQllbnRyeSsrOwotICAgIH0KKyAgICBXT1JEIGluZGV4ID0gUEFMRVRURV9HZXROZWFyZXN0SW5kZXhBbmRDb2xvciggaHBhbGV0dGUsICZjb2xvciApOwogICAgIGRwcmludGZfcGFsZXR0ZShzdGRkZWIsIkdldE5lYXJlc3RQYWxldHRlSW5kZXgoIk5QRk1UIiwlMDZseCk6IHJldHVybmluZyAlZFxuIiwgCi0JICAgICBocGFsZXR0ZSwgY29sb3IsIGluZGV4ICk7CisgICAgICAgICAgICAgICAgICAgIGhwYWxldHRlLCBjb2xvciwgaW5kZXggKTsKICAgICByZXR1cm4gaW5kZXg7CiB9CiAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiAgICAgICAgICAgR2V0TmVhcmVzdENvbG9yICAgIChHREkuMTU0KQorICovCitDT0xPUlJFRiBHZXROZWFyZXN0Q29sb3IoIEhEQyBoZGMsIENPTE9SUkVGIGNvbG9yICkKK3sKKyAgICBDT0xPUlJFRiBuZWFyZXN0ID0gY29sb3I7CisgICAgREMgKmRjOworCisgICAgaWYgKCEoZGMgPSAoREMgKikgR0RJX0dldE9ialB0ciggaGRjLCBEQ19NQUdJQyApKSkgcmV0dXJuIDA7CisgICAgUEFMRVRURV9HZXROZWFyZXN0SW5kZXhBbmRDb2xvciggZGMtPncuaFBhbGV0dGUsICZuZWFyZXN0ICk7CisgICAgZHByaW50Zl9wYWxldHRlKHN0ZGRlYiwiR2V0TmVhcmVzdENvbG9yKCUwNmx4KTogcmV0dXJuaW5nICUwNmx4XG4iLCAKKyAgICAgICAgICAgICAgICAgICAgY29sb3IsIG5lYXJlc3QgKTsKKyAgICByZXR1cm4gbmVhcmVzdDsKK30KKworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICBQQUxFVFRFX0dldE9iamVjdAogICovCiBpbnQgUEFMRVRURV9HZXRPYmplY3QoIFBBTEVUVEVPQkogKiBwYWxldHRlLCBpbnQgY291bnQsIExQU1RSIGJ1ZmZlciApCmRpZmYgLS1naXQgYS9vYmplY3RzL3JlZ2lvbi5jIGIvb2JqZWN0cy9yZWdpb24uYwppbmRleCA1YmUyM2ZmLi43M2FkYzUxIDEwMDY0NAotLS0gYS9vYmplY3RzL3JlZ2lvbi5jCisrKyBiL29iamVjdHMvcmVnaW9uLmMKQEAgLTI0MCw3ICsyNDAsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAgICAgICAgICAgQ3JlYXRlUG9seWdvblJnbiAgICAoR0RJLjYzKQogICovCi1IUkdOIENyZWF0ZVBvbHlnb25SZ24oIFBPSU5UICogcG9pbnRzLCBzaG9ydCBjb3VudCwgc2hvcnQgbW9kZSApCitIUkdOIENyZWF0ZVBvbHlnb25SZ24oIFBPSU5UICogcG9pbnRzLCBJTlQgY291bnQsIElOVCBtb2RlICkKIHsKICAgICByZXR1cm4gQ3JlYXRlUG9seVBvbHlnb25SZ24oIHBvaW50cywgJmNvdW50LCAxLCBtb2RlICk7CiB9CkBAIC0yNDksOCArMjQ5LDggQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIENyZWF0ZVBvbHlQb2x5Z29uUmduICAgIChHREkuNDUxKQogICovCi1IUkdOIENyZWF0ZVBvbHlQb2x5Z29uUmduKCBQT0lOVCAqIHBvaW50cywgc2hvcnQgKiBjb3VudCwKLQkJCSAgIHNob3J0IG5icG9seWdvbnMsIHNob3J0IG1vZGUgKQorSFJHTiBDcmVhdGVQb2x5UG9seWdvblJnbiggUE9JTlQgKiBwb2ludHMsIElOVCAqIGNvdW50LAorCQkJICAgSU5UIG5icG9seWdvbnMsIElOVCBtb2RlICkKIHsKICAgICBSR05PQkogKiBvYmo7CiAgICAgSFJHTiBocmduOwpkaWZmIC0tZ2l0IGEvb2JqZWN0cy90ZXh0LmMgYi9vYmplY3RzL3RleHQuYwppbmRleCBmZDk0YjEwLi4zYjZlYzIyIDEwMDY0NAotLS0gYS9vYmplY3RzL3RleHQuYworKysgYi9vYmplY3RzL3RleHQuYwpAQCAtMTUsNiArMTUsNyBAQAogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAvKiAjZGVmaW5lIERFQlVHX1RFWFQgKi8KICNpbmNsdWRlICJkZWJ1Zy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogI2RlZmluZSBUQUIgICAgIDkKICNkZWZpbmUgTEYgICAgIDEwCkBAIC0xOTYsOCArMTk3LDkgQEAKICAgICBpbnQgd2lkdGggPSByZWN0LT5yaWdodCAtIHJlY3QtPmxlZnQ7CiAgICAgaW50IG1heF93aWR0aCA9IDA7CiAKLSAgICBkcHJpbnRmX3RleHQoc3RkZGViLCJEcmF3VGV4dDogJyVzJywgJWQgLCBbKCVkLCVkKSwoJWQsJWQpXVxuIiwgc3RyLCBjb3VudCwKLQkgICByZWN0LT5sZWZ0LCByZWN0LT50b3AsIHJlY3QtPnJpZ2h0LCByZWN0LT5ib3R0b20pOworICAgIGRwcmludGZfdGV4dChzdGRkZWIsIkRyYXdUZXh0OiAnJXMnLCAlZCAsIFsoJWxkLCVsZCksKCVsZCwlbGQpXVxuIiwgc3RyLAorCQkgY291bnQsIChMT05HKXJlY3QtPmxlZnQsIChMT05HKXJlY3QtPnRvcCwgKExPTkcpcmVjdC0+cmlnaHQsIAorCQkgKExPTkcpcmVjdC0+Ym90dG9tKTsKICAgICAKICAgICBpZiAoY291bnQgPT0gLTEpIGNvdW50ID0gc3RybGVuKHN0cik7CiAgICAgc3RyUHRyID0gc3RyOwpAQCAtMzA3LDggKzMwOSw5IEBACiAgICAgZHByaW50Zl90ZXh0KHN0ZGRlYiwiRXh0VGV4dE91dDogJWQsJWQgJyUqLipzJywgJWQgIGZsYWdzPSVkXG4iLAogICAgICAgICAgICAgeCwgeSwgY291bnQsIGNvdW50LCBzdHIsIGNvdW50LCBmbGFncyk7CiAgICAgaWYgKGxwcmVjdCAhPSBOVUxMKSB7Ci0gICAgICBkcHJpbnRmX3RleHQoc3RkZGViLCAicmVjdCAlZCAlZCAlZCAlZFxuIiwKLQkJICAgbHByZWN0LT5sZWZ0LCBscHJlY3QtPnRvcCwgbHByZWN0LT5yaWdodCwgbHByZWN0LT5ib3R0b20gKTsKKyAgICAgIGRwcmludGZfdGV4dChzdGRkZWIsICJyZWN0ICVsZCAlbGQgJWxkICVsZFxuIiwgKExPTkcpbHByZWN0LT5sZWZ0LAorCQkgICAoTE9ORylscHJlY3QtPnRvcCwgKExPTkcpbHByZWN0LT5yaWdodCwKKwkJICAgKExPTkcpbHByZWN0LT5ib3R0b20gKTsKICAgICB9CiAKICAgICAgIC8qIFNldHVwIGNvb3JkaW5hdGVzICovCkBAIC00MTgsNyArNDIxLDcgQEAKICAgICB7CiAgICAgICAgIFhUZXh0SXRlbSAqaXRlbXMsICpwaXRlbTsKIAotICAgICAgICBpdGVtcyA9IG1hbGxvYyggY291bnQgKiBzaXplb2YoWFRleHRJdGVtKSApOworICAgICAgICBpdGVtcyA9IHhtYWxsb2MoIGNvdW50ICogc2l6ZW9mKFhUZXh0SXRlbSkgKTsKICAgICAgICAgZm9yIChpID0gMCwgcGl0ZW0gPSBpdGVtczsgaSA8IGNvdW50OyBpKyssIHBpdGVtKyspCiAgICAgICAgIHsKICAgICAgICAgICAgIHBpdGVtLT5jaGFycyAgPSBzdHIgKyBpOwpkaWZmIC0tZ2l0IGEvcmMvd2luZXJjLmMgYi9yYy93aW5lcmMuYwppbmRleCBhZmRkODllLi4wNmY4Mzk2IDEwMDY0NAotLS0gYS9yYy93aW5lcmMuYworKysgYi9yYy93aW5lcmMuYwpAQCAtMzQsNiArMzQsMjAgQEAKIGludCB0cmFuc2Zvcm1fYmluYXJ5X2ZpbGUodm9pZCk7CiBpbnQgeXlwYXJzZSh2b2lkKTsKIAorc3RhdGljIHZvaWQgKnhtYWxsb2MgKHNpemVfdCBzaXplKQoreworICAgIHZvaWQgKnJlczsKKworICAgIHJlcyA9IG1hbGxvYyAoc2l6ZSA/IHNpemUgOiAxKTsKKyAgICBpZiAocmVzID09IE5VTEwpCisgICAgeworICAgICAgICBmcHJpbnRmIChzdGRlcnIsICJWaXJ0dWFsIG1lbW9yeSBleGhhdXN0ZWQuXG4iKTsKKyAgICAgICAgZXhpdCAoMSk7CisgICAgfQorICAgIHJldHVybiByZXM7Cit9CisKKwogaW50IG1haW4oaW50IGFyZ2MsY2hhciAqYXJndltdKQogeyAgCiAJZXh0ZXJuIGludCB5eWRlYnVnOwpAQCAtMTMwLDEwICsxNDQsOCBAQAogCiAvKmNyZWF0ZSBhIG5ldyBnZW5fcmVzLCBpbml0aWFsIHNpemUgMTAwKi8KIGdlbl9yZXMgKm5ld19yZXMoKQotewlnZW5fcmVzKiByZXQ9bWFsbG9jKHNpemVvZihnZW5fcmVzKSsxMDApOworewlnZW5fcmVzKiByZXQ9eG1hbGxvYyhzaXplb2YoZ2VuX3JlcykrMTAwKTsKIAlpbnQgaTsKLQlpZighcmV0KQotCQlmcHJpbnRmKHN0ZGVyciwiT3V0IG9mIG1lbW9yeVxuIiksZXhpdCgxKTsKIAlmb3IoaT0wO2k8c2l6ZW9mKGdlbl9yZXMpKzEwMDtpKyspKigoY2hhciopcmV0K2kpPSdcMCc7CiAJcmV0LT5nX25leHQ9Z19zdGFydDsKIAlyZXQtPmdfcHJldj0wOwpAQCAtMTg4LDcgKzIwMCw3IEBACiAvKmNyZWF0ZSBhIG5ldyBzdHlsZSovCiByY19zdHlsZSAqbmV3X3N0eWxlKCkKIHsKLQlyY19zdHlsZSAqcmV0PW1hbGxvYyhzaXplb2YocmNfc3R5bGUpKTsKKwlyY19zdHlsZSAqcmV0PXhtYWxsb2Moc2l6ZW9mKHJjX3N0eWxlKSk7CiAJLyppbml0aWFsbHksIG5vIGJpdHMgaGF2ZSB0byBiZSByZXNldCovCiAJcmV0LT5hbmQ9LTE7CiAJLyppbml0aWFsbHksIG5vIGJpdHMgYXJlIHNldCovCkBAIC00NjQsNiArNDc2LDcgQEAKIGdlbl9yZXMgKmFkZF9wb3B1cChjaGFyICpuYW1lLHNob3J0IGZsYWdzLCBnZW5fcmVzKiBib2R5LCBnZW5fcmVzKnJlcykKIHsKIAljaGFyIGNfZmxhZ3NbMl07CisJZmxhZ3N8PU1GX1BPUFVQOwogCWlmKHJlcy0+bnVtX2VudHJpZXM9PTApZmxhZ3N8PU1GX0VORDsKIAlwdXRfV09SRChjX2ZsYWdzLGZsYWdzKTsKIAlyZXM9aW5zZXJ0X2F0X2JlZ2lubmluZyhyZXMsYm9keS0+cmVzLGJvZHktPnNpemUpOwpAQCAtNjE3LDcgKzYzMCw3IEBACiAvKiB0cmFuc2xhdGUgIkhlbGxvLFxcdHdvcmxkIVxcMTAiIHRvICJIZWxsbyxcdHdvcmxkIVxuIiAqLwogY2hhciAqcGFyc2VfY19zdHJpbmcoY2hhciAqaW4pCiB7Ci0JY2hhciAqb3V0PW1hbGxvYyhzdHJsZW4oaW4pLTEpOworCWNoYXIgKm91dD14bWFsbG9jKHN0cmxlbihpbiktMSk7CiAJY2hhciAqaXQ7CiAJY2hhciB0bXBbNV0sKnRlbmQ7CiAJZm9yKGl0PW91dCxpbisrOyppbjtpbisrKQpkaWZmIC0tZ2l0IGEvdG9vbGtpdC9NYWtlZmlsZS5pbiBiL3Rvb2xraXQvTWFrZWZpbGUuaW4KaW5kZXggNzNmODc0Ni4uNTU3NDVkZCAxMDA2NDQKLS0tIGEvdG9vbGtpdC9NYWtlZmlsZS5pbgorKysgYi90b29sa2l0L01ha2VmaWxlLmluCkBAIC0xOSw5ICsxOSwyMSBAQAogaGVsbG8yOiBoZWxsbzIubyAuLi93aW5lbGliLmEKIAlnY2MgLWcgLW8gaGVsbG8yIGhlbGxvMi5vIC4uL3dpbmVsaWIuYSAtbG0gJChYX0xJQlMpIC1sWHBtICQoWExJQikKIAoraGVsbG8zOiBoZWxsbzNyZXMubyBoZWxsbzMubworCWdjYyAtZyAtbyBoZWxsbzMgaGVsbG8zLm8gaGVsbG8zcmVzLm8gLi4vd2luZWxpYi5hIC1sbSAkKFhfTElCUykgLWxYcG0gJChYTElCKQorCitoZWxsbzMubzogICBoZWxsbzNyZXMubworCitoZWxsbzNyZXMubzogICAgaGVsbG8zcmVzLnJjCisJZWNobyAiI2luY2x1ZGUgXCJ3aW5kb3dzLmhcIiIgPmhlbGxvM3Jlcy5yY3QKKwllY2hvIFdJTkRPV1NfSF9FTkRTX0hFUkUgPj5oZWxsbzNyZXMucmN0CisJY2F0IGhlbGxvM3Jlcy5yYyAgPj5oZWxsbzNyZXMucmN0CisJJChDQykgJChBTExDRkxBR1MpIC1FIC14IGMgLVAgaGVsbG8zcmVzLnJjdCB8IHNlZCAtZSAnMSwvXldJTkRPV1NfSF9FTkRTX0hFUkUvZCcgfCAuLi9yYy93aW5lcmMgLW8gaGVsbG8zcmVzIC12IC1wIGhlbGxvMworCWdjYyAtYyBoZWxsbzNyZXMuYworCiBATUFLRV9SVUxFU0AKIAogY2xlYW46OgotCSQoUk0pIGhlbGxvIGhlbGxvMgorCSQoUk0pIGhlbGxvIGhlbGxvMiBoZWxsbzMKIAogIyMjIERlcGVuZGVuY2llczoKZGlmZiAtLWdpdCBhL3Rvb2xraXQvUkVBRE1FLnJlc291cmNlcyBiL3Rvb2xraXQvUkVBRE1FLnJlc291cmNlcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yY2ViNWE3Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbGtpdC9SRUFETUUucmVzb3VyY2VzCkBAIC0wLDAgKzEsOTEgQEAKK1RoaXMgaXMgYSBzaG9ydCBkaXNjdXNzaW9uIG9mIHJlc291cmNlcyBpbiBXaW5lTGliLgorCitJbnRyb2R1Y3Rpb24KK1Jlc291cmNlcyBhcmUgdXNlZCB0byBzdG9yZSBkaWFsb2dzLCBtZW51cywgYml0bWFwcywgaWNvbnMsIAordmVyc2lvbiBpbmZvcm1hdGlvbiwgc3RyaW5ncywgZm9udHMsIGFuZCBhY2NlbGVyYXRvcnMuCitJbiBhIFdpbjMuMSBwcm9ncmFtbWluZyBlbnZpcm9ubWVudCwgdGhlcmUgYXJlIHRocmVlIGZpbGUgZm9ybWF0cyBmb3IgCityZXNvdXJjZXM6CistIHRoZSBSQyBzY3JpcHQsIHdoaWNoIGlzIGh1bWFuLXJlYWRhYmxlIGFuZCBjYW4gYmUgcHJvY2Vzc2VkIGJ5IGEgcmVzb3VyY2UKK2NvbXBpbGVyCistIHRoZSAuUkVTIGZpbGUsIHdoaWNoIGlzIHRoZSBvdXRwdXQgb2YgdGhlIHJlc291cmNlIGNvbXBpbGVyCistIHRoZSAuRVhFIGFuZCAuRExMIGZpbGVzLCB3aGljaCBzdG9yZSByZXNvdXJjZXMgYXMgYSBwYXJ0IG9mIHRoZSBORQorZmlsZSBmb3JtYXQKK0ZvciBXaW5lTGliLCBvbmx5IGEgcGFydCBvZiB0aGlzIGlzIHN1cHBvcnRlZC4gSW4gcGFydGljdWxhciwgdGhlcmUgaXMgbm8KKy5SRVMgZmlsZSwgdGhlIGV4ZWN1dGFibGUgaXMgbm90IGEgTkUgZmlsZSAoYXMgaXQgaXMgYSBuYXRpdmUgVW5peCBleGVjdXRhYmxlKSwKK2FuZCBzb21lIHJlc291cmNlIHR5cGVzIGFyZSBub3QgaW1wbGVtZW50ZWQ6IGljb25zLCB2ZXJzaW9uIGluZm9ybWF0aW9uLAorc3RyaW5ncywgYW5kIGZvbnRzLgorCitCdWlsZGluZyBhIFdpbmVMaWIgYXBwbGljYXRpb24KK1RoZSBidWlsZCBwcm9jZXNzIGFzc3VtZXMgdGhhdCB0aGUgQyBzb3VyY2UgZmlsZXMgYW5kIHRoZSByZXNvdXJjZSBzY3JpcHQKK2lzIGF2YWlsYWJsZS4gQXQgdGhlIG1vbWVudCwgYSBzaW5nbGUgcmVzb3VyY2Ugc2NyaXB0IGlzIHJlY29tbWVuZGVkLgorVGhpcyBzY3JpcHQgaXMgcHJvY2Vzc2VkIGJ5IHdpbmVyYzoKKzEpIHRoZSBwcmVwcm9jZXNzb3IgaXMgdXNlZCB0byByZXNvbHZlIHN5bWJvbGljIHN0eWxlIG5hbWUgKExCU19TVEFOREFSRCwgLi4uKQoraW50byBudW1iZXJzLiBUaGlzIGludm9sdmVzIHByb2Nlc3Npbmcgd2luZG93cy5oCisyKSB0aGUgdW51c2VkIHBhcnRzIG9mIHdpbmRvd3MuaCAodHlwZSBkZWZpbml0aW9ucykgYXJlIHJlbW92ZWQuIFRoaXMgd291bGQKK25vdCBiZSBuZWNlc3NhcnkgaWYgV2luZSdzIHdpbmRvd3MuaCB3b3VsZCB1c2UgdGhlIFJDX0lOVk9LRUQgbWFjcm8uCiszKSB3aW5lcmMgaXMgaW52b2tlZCB0byBjcmVhdGUgYSBiaW5hcnkgcmVwcmVzZW50YXRpb24gb2YgdGhlIHJlc291cmNlcy4KK1RoaXMgcmVwcmVzZW50YXRpb24gaXMgc3RvcmVkIGFzIEMgc291cmNlIGNvZGUgKGFycmF5cykuCis0KSBnY2MgaXMgdXNlZCB0byBjb21waWxlIHRoZSBnZW5lcmF0ZWQgQyBjb2RlLgorTm93LCBlYWNoIHJlc291cmNlIGlzIGF2YWlsYWJsZSBhcyBhIEMgYXJyYXkgdG8gdGhlIGFwcGxpY2F0aW9uLiBBcyB0aGUgCitleGVjdXRhYmxlIGlzIG5vdCBpbiB0aGUgTkUgZm9ybWF0LCBpdCBpcyBub3QgcG9zc2libGUgdG8gcmV0cmlldmUgcmVzb3VyY2UKK2xvY2F0aW9ucyBpbiB0aGUgZXhlY3V0YWJsZSB2aWEgbmFtZS4gSW5zdGVhZCwgdGhlIHJlc291cmNlcyBoYXZlIHRvIGJlCityZWZlcmVuY2VkIHdpdGggdGhlaXIgZ2VuZXJhdGVkIEMgYXJyYXkgbmFtZXMuIFRoZSBsaW5rZXIgdGhlbiByZXNvbHZlcwordGhlc2UgbmFtZXMgaW4gdGhlIGNvbXBpbGVkIHJlc291cmNlIGZpbGUuCis1KSBUaGUgcHJvZ3JhbSBzb3VyY2VzIGFyZSBjb21waWxlZCBhbmQgbGlua2VkIHdpdGggdGhlIG91dHB1dCBvZiBzdGVwIDQuCitBIHNhbXBsZSBidWlsZCBwcm9jZXNzIGlzIGluIHRvb2xraXQvTWFrZWZpbGU6aGVsbG8zLgorCitSZXF1aXJlZCBjaGFuZ2VzIHRvIHRoZSBwcm9ncmFtIHNvdXJjZXMKK0JlY2F1c2UgbG9hZGluZyB0aGUgcmVzb3VyY2VzIGZyb20gYW4gaW5zdGFuY2UgaGFuZGxlIGlzIG5vdCBwb3NzaWJsZSwKK3RoZSAqSW5kaXJlY3QgZnVuY3Rpb25zIGhhdmUgdG8gYmUgdXNlZCB0byBsb2FkIGEgcmVzb3VyY2UuIFRoZSBDIGFycmF5cworY2FuIGJlIGRpcmVjdGx5IHBhc3NlZCB0byB0aGUgKkluZGlyZWN0IGZ1bmN0aW9ucy4gU28sIGluc3RlYWQgb2Ygd3JpdGluZworCisJaE1lbnU9TG9hZE1lbnUoaEluc3RhbmNlLCJNQUlOIik7CisKK3dyaXRlCisKKwloTWVudT1Mb2FkTWVudUluZGlyZWN0KGhlbGxvM19NRU5VX01BSU4uYnl0ZXMpOworCitGb3J0dW5hdGVseSwgdGhlIFdpbmRvd3MgQVBJIGhhcyB0aGUgZm9sbG93aW5nIGZ1bmN0aW9ucyBhdmFpbGFibGU6CitEaWFsb2dCb3hJbmRpcmVjdAorQ3JlYXRlRGlhbG9nSW5kaXJlY3QKK0RpYWxvZ0JveEluZGlyZWN0UGFyYW0KK0NyZWF0ZURpYWxvZ0luZGlyZWN0UGFyYW0KKworTG9hZE1lbnVJbmRpcmVjdAorU2V0RElCaXRzVG9EZXZpY2UKKworU2FtcGxlIGNvZGUgaXMgYXZhaWxhYmxlIGluIGhlbGxvMy5jLiBoZWxsbzNyZXMuYyBjb250YWlucyB0aGUgY29ycmVzcG9uZGluZworcmVzb3VyY2VzLgorCitLZWVwaW5nIGEgY29tbW9uIHNvdXJjZQorQ2xlYXJseSwgY2hhbmdpbmcgdGhlIHNvdXJjZXMgaXMgbm90IHZlcnkgZGVzaXJhYmxlLCBhbmQgc3VnZ2VzdGlvbnMgaG93Cit0byByZWR1Y2UgdGhlIGFtb3VudCBvZiB3b3JrIGFyZSB3ZWxjb21lLiBJbiB0aGUgbWVhbnRpbWUsIHR3byBhcHByb2FjaGVzCithbGxvdyBhdCBsZWFzdCB0byByZW1haW4gYSBjb21tb24gc291cmNlIGJldHdlZW4gdGhlIFdpbjMuMSBjb2RlIGFuZCB0aGUKK1dpbmVMaWIgY29kZToKKzEpIGNvbmRpdGlvbmFsIGNvbXBpbGVzOgorV2hlbiBjb21waWxpbmcgYSBXaW5lTGliIGFwcGxpY2F0aW9uLCBXSU5FTElCIGlzIGRlZmluZWQuIFRoaXMgY2FuIGJlIHVzZWQKK3RvIHNlbGVjdCBXaW5lLXNwZWNpZmljIGNvZGUuCisyKSB1c2FnZSBvZiB3aW5lcmMgZm9yIFdpbmRvd3M6IFRoZSAqSW5kaXJlY3QgZnVuY3Rpb25zIGFyZSBhdmFpbGFibGUgb24KK3BsYWluIFdpbjMuMSwgYW5kIHRoZSByZXNvdXJjZSBmb3JtYXQgaXMgZnVsbHkgY29tcGF0aWJsZS4gVGh1cywgcmVjb21waWxpbmcKK3NvdXJjZXMgbW9kaWZpZWQgZm9yIFdpbmVMaWIgb24gV2luMy4xIGlzIHBvc3NpYmxlIGFuZCBrbm93biB0byB3b3JrLgorCitPcGVuIHByb2JsZW1zCisxKSBJY29ucyBhbmQgY3Vyc29yczogRm9yIHRoZXNlIHJlc291cmNlcywgdGhlcmUgaXMgbm8gKkluZGlyZWN0IGZ1bmN0aW9uCitkb2N1bWVudGVkLiBJbiBhZGRpdGlvbiwgYm90aCBhcmUgaW1wbGVtZW50ZWQgYnkgYSBzZXQgb2YgdHdvIHJlc291cmNlcy4KK1RoaXMgaXMgdGhlIHJlYXNvbiB3aHkgdGhleSBhcmUgbm90IHN1cHBvcnRlZCBieSB3aW5lcmMuCisyKSBBY2NlbGVyYXRvcnM6IEFsdGhvdWdoIHdpbmVyYyBzdXBwb3J0cyBhY2NlbGVyYXRvcnMsIHRoZXJlIGlzIG5vIAorTG9hZEFjY2VsZXJhdG9ySW5kaXJlY3QgZnVuY3Rpb24uIEEgd29yay1hcm91bmQgd291bGQgYmUgdG8gZGVmaW5lIG9uZS4KKzMpIEZvbnRzOiBGb250IHJlc291cmNlcyBhcmUgbm90IHN1cHBvcnRlZCBieSBXaW5lIGF0IGFsbC4KKzQpIFN0cmluZyB0YWJsZXM6IEFsdGhvdWdoIHN0cmluZyB0YWJsZXMgYXJlIG5vdCBzdXBwb3J0ZWQgYnkgd2luZXJjLCB0aGVyZQoraXMgbm8gcmVhc29uIG5vdCB0byBhZGQgc3VjaCBzdXBwb3J0LiBBZ2Fpbiwgc29tZSBpbmRpcmVjdCBsb2FkaW5nIHdvdWxkCitiZSBuZWNlc3NhcnkuCis1KSBBUEkgcmVxdWlyZXMgbG9hZGluZyBieSBuYW1lOiBBdCBzb21lIHBsYWNlcywgdGhlIG5hbWUgb2YgYSByZXNvdXJjZQoraXMgcGFzc2VkIGluc3RlYWQgb2YgYSBoYW5kbGUuIFRoZSBXTkRDTEFTUyBzdHJ1Y3R1cmUgY29udGFpbnMgdGhlIG5hbWUKK29mIGEgbWVudSByZXNvdXJjZSwgYW5kIHRoZSBpY29uIGluIGEgZGlhbG9nIGJveCBpcyByZWZlcmVuY2VkIGJ5IGl0cyBuYW1lLgorKEFyZSB0aGVyZSBzb21lIG1vcmUgcGxhY2VzPykKK0NsZWFybHksIGxvYWRpbmcgdGhlIHJlc291cmNlIGJ5IG5hbWUgd291bGQgYmUgaGlnaGx5IGRlc2lyYWJsZS4gVGhlCityZXNvdXJjZSBjb21waWxlciBjdXJyZW50bHkgY3JlYXRlcyBhIHN0cnVjdHVyZSBjb250YWluaW5nIGFsbCByZXNvdXJjZXMKK2RlZmluZWQgaW4gYW4gUkMgZmlsZS4gSG93ZXZlciwgaXQgaXMgbm90IGNsZWFyIGhvdyBXSU5FTElCIGNvdWxkIGZpbmQgdGhlCitsb2NhdGlvbiBvZiB0aGlzIHN0cnVjdHVyZSwgZXNwZWNpYWxseSwgd2hlbiB0aGVyZSBpcyBtb3JlIHRoYW4gb25lIFJDIGZpbGUuCisKKwpkaWZmIC0tZ2l0IGEvdG9vbGtpdC9hdG9tLmMgYi90b29sa2l0L2F0b20uYwppbmRleCAyNmFlNDQ1Li40OGZiZmJlIDEwMDY0NAotLS0gYS90b29sa2l0L2F0b20uYworKysgYi90b29sa2l0L2F0b20uYwpAQCAtMTAsNiArMTAsNyBAQAogI2luY2x1ZGUgPGN0eXBlLmg+CiAKICNpbmNsdWRlICJ3aW5kb3dzLmgiCisjaW5jbHVkZSAieG1hbGxvYy5oIgogCiAjaWZkZWYgQ09ORklHX0lQQwogI2luY2x1ZGUgImRkZV9hdG9tLmgiCkBAIC05MCw3ICs5MSw3IEBACiAgICAgfQogICAgIGlmKCFGaXJzdFVudXNlZCkKICAgICB7Ci0gICAgICAqdGFibGVwdHIgPSBtYWxsb2Moc2l6ZW9mKEFUT010b0hBTkRMRXRhYmxlKSk7CisgICAgICAqdGFibGVwdHIgPSB4bWFsbG9jKHNpemVvZihBVE9NdG9IQU5ETEV0YWJsZSkpOwogICAgICAgKCp0YWJsZXB0ciktPm5leHQgPSBOVUxMOwogICAgICAgZm9yKGk9MDsgaTwxNjsgaSsrKQogICAgICAgewpkaWZmIC0tZ2l0IGEvdG9vbGtpdC9oZWFwLmMgYi90b29sa2l0L2hlYXAuYwppbmRleCAzNzBmN2M2Li43NWZhZWZjIDEwMDY0NAotLS0gYS90b29sa2l0L2hlYXAuYworKysgYi90b29sa2l0L2hlYXAuYwpAQCAtOCw5ICs4LDExIEBACiAKIC8qICNpZm5kZWYgX19TVERDX18gKi8KICNpbmNsdWRlIDxtYWxsb2MuaD4KKyNpbmNsdWRlIDxzdGRpby5oPgogI2luY2x1ZGUgPHN0cmluZy5oPgogLyogI2VuZGlmICovCiAjaW5jbHVkZSAid2luZG93cy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogI2lmZGVmIFdJTkVMSUIxNgogCkBAIC0zOSw3ICs0MSw3IEBACiAgICAgfQogCiAgICAgLyogTm8gZnJlZSBzbG90cyAqLwotICAgIGxhc3QtPm5leHQgPSBtYWxsb2MgKHNpemVvZiAoaGFuZGxlX3RhYmxlX3QpKTsKKyAgICBsYXN0LT5uZXh0ID0geG1hbGxvYyAoc2l6ZW9mIChoYW5kbGVfdGFibGVfdCkpOwogICAgIHRhYmxlID0gbGFzdC0+bmV4dDsKICAgICBtZW1zZXQgKHRhYmxlLCAwLCBzaXplb2YgKGhhbmRsZV90YWJsZV90KSk7CiAgICAgaSA9IDA7CkBAIC0xMzEsNyArMTMzLDcgQEAKIHsKICAgICB2b2lkICoqbSA9IEhFQVBfRmluZFNsb3QgKGhNZW0pOwogCi0gICAgcmVhbGxvYyAoKm0sIGJ5dGVzKTsKKyAgICB4cmVhbGxvYyAoKm0sIGJ5dGVzKTsKIH0KIAogV09SRCBMb2NhbFNpemUgKEhBTkRMRSBoTWVtKQpAQCAtMTQwLDcgKzE0Miw3IEBACiB9CiAKIAotQk9PTCBMb2NhbFVuTG9jayAoSEFORExFIGhNZW0pCitCT09MIExvY2FsVW5sb2NrIChIQU5ETEUgaE1lbSkKIHsKICAgICByZXR1cm4gMDsKIH0KQEAgLTE2Miw3ICsxNjQsNyBAQAogCiBCT09MIEdsb2JhbFVubG9jayAoSEFORExFIGhNZW0pCiB7Ci0gICAgcmV0dXJuIExvY2FsVW5Mb2NrIChoTWVtKTsKKyAgICByZXR1cm4gTG9jYWxVbmxvY2sgKGhNZW0pOwogfQogCiBXT1JEIEdsb2JhbEZsYWdzIChIQU5ETEUgaE1lbSkKQEAgLTIwOCw5ICsyMTAsNDcgQEAKICNlbmRpZgogCiAjZWxzZSAvKiBXSU5FTElCMTYgKi8KKworI2lmZGVmIERFQlVHX0hFQVAKK3N0YXRpYyB2b2lkKiBMYXN0VHdlbnR5WzIwXT17IDAsMCwwLDAsMCwgMCwwLDAsMCwwLCAwLDAsMCwwLDAsIDAsMCwwLDAsMCAgfTsKKwordm9pZCBDaGVja01lbSh2b2lkKiBmKQoreworICBpbnQgaTsKKworICBmb3IoaT0wOyBpPDIwOyBpKyspCisgIHsKKyAgICBpZihMYXN0VHdlbnR5W2ldPT1mKQorICAgICAgTGFzdFR3ZW50eVtpXT1OVUxMOworICAgIGVsc2UgaWYoTGFzdFR3ZW50eVtpXSkKKyAgICAgIGlmKCAqKChpbnQqKUxhc3RUd2VudHlbaV0pICE9IDB4MTIzNDU2NzggIHx8CisJICAqKCgoaW50KilMYXN0VHdlbnR5W2ldKSsxKSAhPSAweDBmZWRjYmE5ICkKKwlmcHJpbnRmKHN0ZGVyciwibWVtb3J5IGNvcnJ1cHRlZCBhdCAlcFxuIixMYXN0VHdlbnR5W2ldKTsKKyAgfQorICBmZmx1c2goc3RkZXJyKTsKK30KKwordm9pZCBOZXdNZW0odm9pZCogbikKK3sKKyAgaW50IGk7CisgIGZvcihpPTA7IGk8MjA7IGkrKykKKyAgICBpZighTGFzdFR3ZW50eVtpXSkKKyAgICB7CisgICAgICBMYXN0VHdlbnR5W2ldPW47CisgICAgICByZXR1cm47CisgICAgfQorICBmb3IoaT0wOyBpPDIwOyBpKyspCisgICAgTGFzdFR3ZW50eVtpXT1MYXN0VHdlbnR5W2krMV07CisgIExhc3RUd2VudHlbNF09bjsKK30KKyNlbmRpZgorCiBIQU5ETEUgTG9jYWxBbGxvYyAoV09SRCBmbGFncywgV09SRCBieXRlcykKIHsKICAgICBIQU5ETEUgbTsKKyNpZmRlZiBERUJVR19IRUFQCisgICAgYnl0ZXMrPTIqc2l6ZW9mKGludCk7CisjZW5kaWYKIAogICAgIGlmIChmbGFncyAmIExNRU1fV0lORV9BTElHTikKIAltID0gbWVtYWxpZ24gKDQsIGJ5dGVzKTsKQEAgLTIyMCw2ICsyNjAsMTQgQEAKIAlpZiAoZmxhZ3MgJiBMTUVNX1pFUk9JTklUKQogCSAgICBiemVybyAobSwgYnl0ZXMpOwogICAgIH0KKyNpZmRlZiBERUJVR19IRUFQCisgICAgQ2hlY2tNZW0oTlVMTCk7CisgICAgKigoaW50KikgbSk9MHgxMjM0NTY3ODsKKyAgICAqKCgoaW50KikgbSkrMSk9MHgwZmVkY2JhOTsKKyAgICBmcHJpbnRmKHN0ZGVyciwiJXAgbWFsbG9jJ2RcbiIsbSk7IGZmbHVzaChzdGRlcnIpOworICAgIE5ld01lbShtKTsKKyAgICByZXR1cm4gKEhBTkRMRSkgKCgoaW50KiltKSsyKTsKKyNlbmRpZgogICAgIHJldHVybiBtOwogfQogCkBAIC0yMzUsNyArMjgzLDI0IEBACiAKIEhBTkRMRSBMb2NhbEZyZWUgKEhBTkRMRSBoTWVtKQogeworI2lmZGVmIERFQlVHX0hFQVAKKyAgICBoTWVtPShIQU5ETEUpICgoKGludCopaE1lbSktMik7CisgICAgQ2hlY2tNZW0oaE1lbSk7CisgICAgZnByaW50ZihzdGRlcnIsIiVwIGZyZWUtaW5nLi4uIixoTWVtKTsKKyAgICBpZiggKigoaW50KiloTWVtKSAhPSAweDEyMzQ1Njc4ICB8fAorICAgICAgICAqKCgoaW50KiloTWVtKSsxKSAhPSAweDBmZWRjYmE5ICkKKyAgICAgIGZwcmludGYoc3RkZXJyLCJtZW1vcnkgY29ycnVwdGVkLi4uIik7CisgICAgZWxzZQorICAgIHsgCisgICAgICAqKChpbnQqKWhNZW0pID0gMHg5YWJjZGVmMDsKKyAgICAgICooKChpbnQqKWhNZW0pKzEpID0gMHg4NzY1NDMyMTsKKyAgICB9CisgICAgZmZsdXNoKHN0ZGVycik7CisjZW5kaWYKICAgICBmcmVlKGhNZW0pOworI2lmZGVmIERFQlVHX0hFQVAKKyAgICBmcHJpbnRmKHN0ZGVyciwiZnJlZSdkXG4iKTsgZmZsdXNoKHN0ZGVycik7CisjZW5kaWYKICAgICByZXR1cm4gMDsKIH0KIApAQCAtMjUxLDggKzMxNiwxMSBAQAogCiBIQU5ETEUgTG9jYWxSZUFsbG9jIChIQU5ETEUgaE1lbSwgV09SRCBmbGFncywgV09SRCBieXRlcykKIHsKLSAgICByZWFsbG9jKGhNZW0sIGJ5dGVzKTsKLSAgICByZXR1cm4gaE1lbTsKKyNpZmRlZiBERUJVR19IRUFQCisgICAgTG9jYWxGcmVlKGhNZW0pOworICAgIHJldHVybiBMb2NhbEFsbG9jKGZsYWdzLGJ5dGVzKTsgCisjZW5kaWYKKyAgICByZXR1cm4gcmVhbGxvYyhoTWVtLCBieXRlcyk7CiB9CiAKIFdPUkQgTG9jYWxTaXplIChIQU5ETEUgaE1lbSkKQEAgLTI2Miw3ICszMzAsNyBAQAogfQogCiAKLUJPT0wgTG9jYWxVbkxvY2sgKEhBTkRMRSBoTWVtKQorQk9PTCBMb2NhbFVubG9jayAoSEFORExFIGhNZW0pCiB7CiAgICAgcmV0dXJuIDA7CiB9CkBAIC0yODQsNyArMzUyLDcgQEAKIAogQk9PTCBHbG9iYWxVbmxvY2sgKEhBTkRMRSBoTWVtKQogewotICAgIHJldHVybiBMb2NhbFVuTG9jayAoaE1lbSk7CisgICAgcmV0dXJuIExvY2FsVW5sb2NrIChoTWVtKTsKIH0KIAogV09SRCBHbG9iYWxGbGFncyAoSEFORExFIGhNZW0pCmRpZmYgLS1naXQgYS90b29sa2l0L2hlbGxvMy5jIGIvdG9vbGtpdC9oZWxsbzMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNjg4Y2VjCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbGtpdC9oZWxsbzMuYwpAQCAtMCwwICsxLDg1IEBACisjaW5jbHVkZSA8d2luZG93cy5oPgorI2luY2x1ZGUgImhlbGxvM3Jlcy5oIgorCitCT09MIENBTExCQUNLIERsZ1Byb2MoSFdORCBoV25kLFVJTlQgbXNnLFdQQVJBTSB3UGFyYW0sTFBBUkFNIGxQYXJhbSkKK3sKKwlzd2l0Y2gobXNnKQorCXsKKwkJY2FzZSBXTV9JTklURElBTE9HOgorCQkJcmV0dXJuIDE7CisJCWNhc2UgV01fQ09NTUFORDoKKwkJaWYod1BhcmFtPT0xMDApCisJCQlEZXN0cm95V2luZG93KGhXbmQpOworCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDA7Cit9CisKK0xSRVNVTFQgV25kUHJvYyAoSFdORCB3bmQsIFVJTlQgbXNnLCBXUEFSQU0gdywgTFBBUkFNIGwpCit7CisgICAgc3dpdGNoIChtc2cpeworCisJY2FzZSBXTV9DT01NQU5EOgorCXN3aXRjaCh3KXsKKwkJY2FzZSAxMDA6CisJCQlDcmVhdGVEaWFsb2dJbmRpcmVjdCgwLGhlbGxvM19ESUFMT0dfRElBREVNTy5ieXRlcyx3bmQsKFdORFBST0MpRGxnUHJvYyk7CisJCQlyZXR1cm4gMDsKKwkJY2FzZSAxMDE6CisJCXsKKwkJCUJJVE1BUElORk8gKmJtPWhlbGxvM19CSVRNQVBfQklUREVNTy5ieXRlczsKKwkJCWNoYXIgKmJpdHM9Ym07CisJCQlIREMgaGRjPUdldERDKHduZCk7CisJCQliaXRzKz1ibS0+Ym1pSGVhZGVyLmJpU2l6ZTsKKwkJCWJpdHMrPSgxPDxibS0+Ym1pSGVhZGVyLmJpQml0Q291bnQpKnNpemVvZihSR0JRVUFEKTsKKwkJCVNldERJQml0c1RvRGV2aWNlKGhkYywwLDAsYm0tPmJtaUhlYWRlci5iaVdpZHRoLAorCQkJCWJtLT5ibWlIZWFkZXIuYmlIZWlnaHQsMCwwLDAsYm0tPmJtaUhlYWRlci5iaUhlaWdodCwKKwkJCQliaXRzLGJtLERJQl9SR0JfQ09MT1JTKTsKKwkJCVJlbGVhc2VEQyh3bmQsaGRjKTsKKwkJCXJldHVybiAwOworCQl9CisJCWRlZmF1bHQ6CisJCQlyZXR1cm4gRGVmV2luZG93UHJvYyAod25kLCBtc2csIHcsIGwpOworCX0KKyAgICBjYXNlIFdNX0RFU1RST1k6CisJUG9zdFF1aXRNZXNzYWdlICgwKTsKKwlicmVhazsKKworICAgIGRlZmF1bHQ6CisJcmV0dXJuIERlZldpbmRvd1Byb2MgKHduZCwgbXNnLCB3LCBsKTsKKyAgICB9CisgICAgcmV0dXJuIDBsOworfQorCitpbnQgUEFTQ0FMIFdpbk1haW4gKEhBTkRMRSBpbnN0LCBIQU5ETEUgcHJldiwgTFBTVFIgY21kbGluZSwgaW50IHNob3cpCit7CisgICAgSFdORCAgICAgd25kOworICAgIE1TRyAgICAgIG1zZzsKKyAgICBXTkRDTEFTUyBjbGFzczsKKworICAgIGlmICghcHJldil7CisJY2xhc3Muc3R5bGUgPSBDU19IUkVEUkFXIHwgQ1NfVlJFRFJBVzsKKwljbGFzcy5scGZuV25kUHJvYyA9IFduZFByb2M7CisJY2xhc3MuY2JDbHNFeHRyYSA9IDA7CisJY2xhc3MuY2JXbmRFeHRyYSA9IDA7CisJY2xhc3MuaEluc3RhbmNlICA9IGluc3Q7CisJY2xhc3MuaEljb24gICAgICA9IExvYWRJY29uICgwLCBJRElfQVBQTElDQVRJT04pOworCWNsYXNzLmhDdXJzb3IgICAgPSBMb2FkQ3Vyc29yICgwLCBJRENfQVJST1cpOworCWNsYXNzLmhickJhY2tncm91bmQgPSBHZXRTdG9ja09iamVjdCAoV0hJVEVfQlJVU0gpOworCWNsYXNzLmxwc3pNZW51TmFtZSA9IDA7CisJY2xhc3MubHBzekNsYXNzTmFtZSA9IChTRUdQVFIpImNsYXNzIjsKKyAgICB9CisgICAgaWYgKCFSZWdpc3RlckNsYXNzICgmY2xhc3MpKQorCXJldHVybiBGQUxTRTsKKworICAgIHduZCA9IENyZWF0ZVdpbmRvdyAoImNsYXNzIiwgIlRlc3QgYXBwIiwgV1NfT1ZFUkxBUFBFRFdJTkRPVywKKwkJCUNXX1VTRURFRkFVTFQsIDAsIENXX1VTRURFRkFVTFQsIDAsIDAsIAorCQkJTG9hZE1lbnVJbmRpcmVjdChoZWxsbzNfTUVOVV9NQUlOLmJ5dGVzKSwgaW5zdCwgMCk7CisgICAgU2hvd1dpbmRvdyAod25kLCBzaG93KTsKKyAgICBVcGRhdGVXaW5kb3cgKHduZCk7CisKKyAgICB3aGlsZSAoR2V0TWVzc2FnZSAoJm1zZywgMCwgMCwgMCkpeworCVRyYW5zbGF0ZU1lc3NhZ2UgKCZtc2cpOworCURpc3BhdGNoTWVzc2FnZSAoJm1zZyk7CisgICAgfQorICAgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvdG9vbGtpdC9oZWxsbzNyZXMucmMgYi90b29sa2l0L2hlbGxvM3Jlcy5yYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yM2YyOWM1Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbGtpdC9oZWxsbzNyZXMucmMKQEAgLTAsMCArMSwzMiBAQAorTUFJTiBNRU5VIAoreworIFBPUFVQICJNZW51IGRlbW8iIHsKKyAgIE1FTlVJVEVNICJEaWFsb2cgRGVtbyIsIDEwMAorICAgTUVOVUlURU0gIkJpdG1hcCBEZW1vIiwgMTAxCisgfQorfQorCitESUFERU1PIERJQUxPRyAyMCwgMjAsIDE3OSwgMTE4CitTVFlMRSBEU19NT0RBTEZSQU1FIHwgV1NfQ0FQVElPTiB8IFdTX1BPUFVQIHwgV1NfVklTSUJMRSB8IFdTX1NZU01FTlUKK0NBUFRJT04gIkRpYWxvZyBkZW1vIgorRk9OVCA4LCAiSGVsdiIKK0JFR0lOCisJQ09OVFJPTCAiUHVzaGJ1dHRvbiIsIDEwMCwgIkJVVFRPTiIsIEJTX1BVU0hCVVRUT04gfCBXU19DSElMRCB8IFdTX1ZJU0lCTEUgfCBXU19UQUJTVE9QLCAxNCwgOTIsIDUyLCAxMworCUNPTlRST0wgIkNoZWNrYm94IiwgMTAxLCAiQlVUVE9OIiwgQlNfQVVUT0NIRUNLQk9YIHwgV1NfQ0hJTEQgfCBXU19WSVNJQkxFIHwgV1NfVEFCU1RPUCwgMTksIDc2LCA0NywgMTIKKwlDT05UUk9MICJTdGF0aWMgdGV4dCIsIDEwMiwgIlNUQVRJQyIsIFNTX0xFRlQgfCBXU19DSElMRCB8IFdTX1ZJU0lCTEUsIDE3LCA2MCwgMzksIDEwCisjaWYgMAorCS8qIEVkaXQgY29udHJvbHMgZG9uJ3Qgd29yaywgeWV0ICovCisJQ09OVFJPTCAiRWRpdCBjb250cm9sIiwgMTAzLCAiRURJVCIsIEVTX0xFRlQgfCBXU19DSElMRCB8IFdTX1ZJU0lCTEUgfCBXU19CT1JERVIgfCBXU19UQUJTVE9QLCAxOCwgNDEsIDQ0LCAxMworI2VuZGlmCisJQ09OVFJPTCAiUmFkaW8gYnV0dG9uIiwgMTA0LCAiQlVUVE9OIiwgQlNfQVVUT1JBRElPQlVUVE9OIHwgV1NfQ0hJTEQgfCBXU19WSVNJQkxFLCAxNywgMjMsIDU4LCAxMgorCUNPTlRST0wgIkNoZWNrYm94IiwgMTAxLCAiQlVUVE9OIiwgQlNfQVVUT0NIRUNLQk9YIHwgV1NfQ0hJTEQgfCBXU19WSVNJQkxFIHwgV1NfVEFCU1RPUCwgMTksIDc2LCA0NywgMTIKKyNpZiAwCisJQ09OVFJPTCAiIiwgMTA2LCAiQ09NQk9CT1giLCBDQlNfRFJPUERPV04gfCBXU19DSElMRCB8IFdTX1ZJU0lCTEUgfCBXU19UQUJTVE9QLCA4NiwgMjMsIDg2LCA4NQorI2Vsc2UKKwlDT05UUk9MICIiLCAxMDYsICJMSVNUQk9YIiwgTEJTX1NUQU5EQVJEIHwgTEJTX0RJU0FCTEVOT1NDUk9MTCB8IFdTX0NISUxEIHwgV1NfVklTSUJMRSB8IFdTX1RBQlNUT1AsIDg2LCAyMywgODYsIDg1CisjZW5kaWYKK0VORAorCisKK0JJVERFTU8gQklUTUFQICIuLi9yYy93aW5lbG9nby5ibXAiCisKZGlmZiAtLWdpdCBhL3Rvb2xraXQvbWlzY3N0dWJzLmMgYi90b29sa2l0L21pc2NzdHVicy5jCmluZGV4IDVkYjkwMTYuLmRkZWViNDkgMTAwNjQ0Ci0tLSBhL3Rvb2xraXQvbWlzY3N0dWJzLmMKKysrIGIvdG9vbGtpdC9taXNjc3R1YnMuYwpAQCAtMTEsNiArMTEsNyBAQAogI2luY2x1ZGUgIndpbmRvd3MuaCIKICNpbmNsdWRlICJnbG9iYWwuaCIKICNpbmNsdWRlICJkZWJ1Zy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogaW50IENhbGxUbzMyX0xhcmdlU3RhY2soIGludCAoKmZ1bmMpKCksIGludCBuYmFyZ3MsIC4uLikKIHsKQEAgLTMyLDYgKzMzLDggQEAKICAgICAgICAgICAgICAgICBhWzddLGFbOF0sYVs5XSxhWzEwXSk7CiAgIGNhc2UgMTQ6IHJldHVybiBmdW5jKGFbMF0sYVsxXSxhWzJdLGFbM10sYVs0XSxhWzVdLGFbNl0sCiAgICAgICAgICAgICAgICAgYVs3XSxhWzhdLGFbOV0sYVsxMF0sYVsxMV0sYVsxMl0sYVsxM10pOworICBjYXNlIDE3OiByZXR1cm4gZnVuYyhhWzBdLGFbMV0sYVsyXSxhWzNdLGFbNF0sYVs1XSxhWzZdLAorICAgICAgICAgICAgICAgIGFbN10sYVs4XSxhWzldLGFbMTBdLGFbMTFdLGFbMTJdLGFbMTNdLGFbMTRdLGFbMTVdLGFbMTZdKTsKICAgZGVmYXVsdDogZnByaW50ZihzdGRlcnIsIkpCUDogQ2FsbFRvMzJfTGFyZ2VTdGFjayBjYWxsZWQgd2l0aCB1bnN1cHBvcnRlZCAiCiAgICAgICAgICAgICAgICAgICAgICAgICAgICJudW1iZXIgb2YgYXJndW1lbnRzICglZCkuICBJZ25vcmVkLlxuIixuYmFyZ3MpOwogICAgICAgICAgICByZXR1cm4gMDsKQEAgLTQwLDI1ICs0Myw2IEBACiAKIFdPUkQgQ2FsbFRvMTZfd29yZF8gKCBGQVJQUk9DIGZ1bmMsIFdPUkQgYXJnICkgeyByZXR1cm4gZnVuYyhhcmcpOyB9CiAKLS8qIHR5cGVkZWYgdm9pZCogQVRPTTsgKi8KLS8qIEFUT00gR2xvYmFsQWRkQXRvbShjaGFyICpuKSAqLwotLyogeyAqLwotLyogICByZXR1cm4gc3RyZHVwKG4pOyAqLwotLyogfSAqLwotLyogR2xvYmFsRGVsZXRlQXRvbShBVE9NIG4pICovCi0vKiB7ICovCi0vKiAgIGZyZWUobik7ICovCi0vKiB9ICovCi0vKiBHbG9iYWxGaW5kQXRvbShjaGFyKm4pICovCi0vKiB7ICovCi0vKiAgIGZwcmludGYoc3RkZXJyLCJKQlA6IEdsb2JhbEZpbmRBdG9tKCkgaWdub3JlZC5cbiIpOyAqLwotLyogICByZXR1cm4gMDsgKi8KLS8qIH0gKi8KLS8qIGNoYXIgKkdsb2JhbEdldEF0b21OYW1lKEFUT00gYSkgKi8KLS8qIHsgKi8KLS8qICAgcmV0dXJuIGE7ICovCi0vKiB9ICovCi0KIHZvaWQgR2xvYmFsRnJlZUFsbChIQU5ETEUgb3duZXIpCiB7CiAgIGZwcmludGYoc3RkZXJyLCJKQlA6IEdsb2JhbEZyZWVBbGwoKSBpZ25vcmVkLlxuIik7CkBAIC03MCwxMjMgKzU0LDM2IEBACiB9CiAKIAotCi0jaWYgMAotdHlwZWRlZiBXT1JEKiBITE9DQUw7Ci0KLWludCBJc1ZhbGlkSExPQ0FMKEhMT0NBTCBoYW5kbGUpCi17Ci0gIHJldHVybiAqKGhhbmRsZS0xKSArICooaGFuZGxlLTIpID09IDA7IC8qIFZhbGlkIEhMT0NBTCdzIHN1bSB0byAwICovCi19Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogICAgICAgICAgIExPQ0FMX0ZyZWUKLSAqCi0gKi8KIEhMT0NBTCBMT0NBTF9GcmVlKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlICkKIHsKLSAgaWYgKCFJc1ZhbGlkSExPQ0FMKGhhbmRsZSkpIHJldHVybiBoYW5kbGU7IC8qIGNvdWxkbid0IGZyZWUgaXQgKi8KLSAgZnJlZShoYW5kbGUtMik7Ci0gIHJldHVybiAwOwotfQotCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogICAgICAgICAgIExPQ0FMX0FsbG9jCi0gKgotICovCi1ITE9DQUwgTE9DQUxfQWxsb2MoIFdPUkQgZHMsIFdPUkQgZmxhZ3MsIFdPUkQgc2l6ZSApCi17Ci0gIEhMT0NBTCBoYW5kbGU7Ci0gICAgCi0gIGhhbmRsZSA9IG1hbGxvYyhzaXplICsgMipzaXplb2YoV09SRCkpOwotICBoYW5kbGUgKz0gMjsKLSAgKihoYW5kbGUtMikgPSBzaXplOwotICAqKGhhbmRsZS0xKSA9IC1zaXplOwotICByZXR1cm4gaGFuZGxlOwotfQotCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogICAgICAgICAgIExPQ0FMX1JlQWxsb2MKLSAqCi0gKi8KLUhMT0NBTCBMT0NBTF9SZUFsbG9jKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlLCBXT1JEIHNpemUsIFdPUkQgZmxhZ3MgKQotewotICBITE9DQUwgbmV3aGFuZGxlOwotCi0gIGlmKCFJc1ZhbGlkSExPQ0FMKGhhbmRsZSkpcmV0dXJuIDA7Ci0gIG5ld2hhbmRsZSA9IHJlYWxsb2MoaGFuZGxlLTIsIHNpemUrMipzaXplb2YoV09SRCkpOwotICBuZXdoYW5kbGUgKz0gMjsKLSAgKihuZXdoYW5kbGUtMikgPSBzaXplOwotICAqKG5ld2hhbmRsZS0xKSA9IC1zaXplOwotICByZXR1cm4gbmV3aGFuZGxlOwotfQotCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogICAgICAgICAgIExPQ0FMX0xvY2sKLSAqLwotV09SRCBMT0NBTF9Mb2NrKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlICkKLXsKLSAgaWYoIUlzVmFsaWRITE9DQUwoaGFuZGxlKSlyZXR1cm4gMDsKLSAgcmV0dXJuIGhhbmRsZTsKLX0KLQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICAgICAgICAgICBMT0NBTF9VbmxvY2sKLSAqLwotQk9PTCBMT0NBTF9VbmxvY2soIFdPUkQgZHMsIEhMT0NBTCBoYW5kbGUgKQotewotICByZXR1cm4gVFJVRTsKLX0KLQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqICAgICAgICAgICBMT0NBTF9TaXplCi0gKgotICovCi1XT1JEIExPQ0FMX1NpemUoIFdPUkQgZHMsIEhMT0NBTCBoYW5kbGUgKQotewotICByZXR1cm4gKihoYW5kbGUtMik7Ci19Ci0jZW5kaWYKLQotSExPQ0FMIExPQ0FMX0ZyZWUoIFdPUkQgZHMsIEhMT0NBTCBoYW5kbGUgKQotewotICBmcHJpbnRmKHN0ZGVyciwiSkJQOiBMT0NBTF8qKCkgaWdub3JlZC5cbiIpOwotICByZXR1cm4gMDsKKyAgICByZXR1cm4gTG9jYWxGcmVlKGhhbmRsZSk7CiB9CiAKIEhMT0NBTCBMT0NBTF9BbGxvYyggV09SRCBkcywgV09SRCBmbGFncywgV09SRCBzaXplICkKIHsKLSAgZnByaW50ZihzdGRlcnIsIkpCUDogTE9DQUxfKigpIGlnbm9yZWQuXG4iKTsKLSAgcmV0dXJuIDA7CisgICAgcmV0dXJuIExvY2FsQWxsb2MoZmxhZ3Msc2l6ZSk7CiB9CiAKIEhMT0NBTCBMT0NBTF9SZUFsbG9jKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlLCBXT1JEIHNpemUsIFdPUkQgZmxhZ3MgKQogewotICBmcHJpbnRmKHN0ZGVyciwiSkJQOiBMT0NBTF8qKCkgaWdub3JlZC5cbiIpOwotICByZXR1cm4gMDsKKyAgICByZXR1cm4gTG9jYWxSZUFsbG9jKGhhbmRsZSxzaXplLGZsYWdzKTsKIH0KIAotV09SRCBMT0NBTF9Mb2NrKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlICkKK05QVk9JRCBMT0NBTF9Mb2NrKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlICkKIHsKLSAgZnByaW50ZihzdGRlcnIsIkpCUDogTE9DQUxfKigpIGlnbm9yZWQuXG4iKTsKLSAgcmV0dXJuIDA7CisgICAgcmV0dXJuIExvY2FsTG9jayhoYW5kbGUpOwogfQogCiBCT09MIExPQ0FMX1VubG9jayggV09SRCBkcywgSExPQ0FMIGhhbmRsZSApCiB7Ci0gIGZwcmludGYoc3RkZXJyLCJKQlA6IExPQ0FMXyooKSBpZ25vcmVkLlxuIik7Ci0gIHJldHVybiAxOworICAgIGZwcmludGYoc3RkZXJyLCJKQlA6IExPQ0FMX1VubG9jaygpIGlnbm9yZWQuXG4iKTsKKyAgICByZXR1cm4gMTsKIH0KIAogV09SRCBMT0NBTF9TaXplKCBXT1JEIGRzLCBITE9DQUwgaGFuZGxlICkKIHsKLSAgZnByaW50ZihzdGRlcnIsIkpCUDogTE9DQUxfKigpIGlnbm9yZWQuXG4iKTsKLSAgcmV0dXJuIDA7CisgICAgZnByaW50ZihzdGRlcnIsIkpCUDogTE9DQUxfU2l6ZSgpIGlnbm9yZWQuXG4iKTsKKyAgICByZXR1cm4gMDsKIH0KIAogdm9pZCBGYXJTZXRPd25lcihIQU5ETEUgYSwgV09SRCBiKQpAQCAtMjQwLDE3ICsxMzcsMTcgQEAKIAkJCSAgICBCT09MIGlzMzJCaXQsIEJPT0wgaXNSZWFkT25seSwKIAkJCSAgICBTSE1EQVRBICpzaG1kYXRhKQogewotICBmcHJpbnRmKHN0ZGVyciwiSkJQOiBHTE9CQUxfQ3JlYXRlQmxvY2soKSBmYWtlZC5cbiIpOworLyogIGZwcmludGYoc3RkZXJyLCJKQlA6IEdMT0JBTF9DcmVhdGVCbG9jaygpIGZha2VkLlxuIik7Ki8KICAgcmV0dXJuIHB0cjsKIH0KIAogQk9PTCBHTE9CQUxfRnJlZUJsb2NrKCBIR0xPQkFMIGhhbmRsZSApCiB7Ci0gIGZwcmludGYoc3RkZXJyLCJKQlA6IEdMT0JBTF9GcmVlQmxvY2soKSBpZ25vcmVkLlxuIik7CisvKiAgZnByaW50ZihzdGRlcnIsIkpCUDogR0xPQkFMX0ZyZWVCbG9jaygpIGlnbm9yZWQuXG4iKTsqLwogICByZXR1cm4gMTsKIH0KIAotRFdPUkQgR2xvYmFsSGFuZGxlKFdPUkQgYSkKK0hHTE9CQUwgR2xvYmFsSGFuZGxlKExQQ1ZPSUQgYSkKIHsKICAgZnByaW50ZihzdGRlcnIsIkpCUDogR2xvYmFsSGFuZGxlKCkgaWdub3JlZC5cbiIpOwogICByZXR1cm4gMDsKQEAgLTI1OCw3ICsxNTUsNyBAQAogCiB2b2lkICpSRUxBWTMyX0dldEVudHJ5UG9pbnQoY2hhciAqZGxsX25hbWUsIGNoYXIgKml0ZW0sIGludCBoaW50KQogewotICBmcHJpbnRmKHN0ZGVyciwiSkJQOiBSRUxBWTMyX0dldEVudHJ5UG9pbnQoKSBpZ25vcmVkLlxuIik7CisvKiAgZnByaW50ZihzdGRlcnIsIkpCUDogUkVMQVkzMl9HZXRFbnRyeVBvaW50KCkgaWdub3JlZC5cbiIpOyovCiAgIHJldHVybiBOVUxMOwogfQogCmRpZmYgLS1naXQgYS90b29sa2l0L3dpbm1haW4uYyBiL3Rvb2xraXQvd2lubWFpbi5jCmluZGV4IDE5ODJmNmIuLmYxMzI3MjUgMTAwNjQ0Ci0tLSBhL3Rvb2xraXQvd2lubWFpbi5jCisrKyBiL3Rvb2xraXQvd2lubWFpbi5jCkBAIC0xMSwxMCArMTEsMTMgQEAKIGV4dGVybiB2b2lkIFRBU0tfUmVzY2hlZHVsZSh2b2lkKTsKIGV4dGVybiBpbnQgVVNFUl9Jbml0QXBwKEhJTlNUQU5DRSk7CiAKK2NoYXIqIHByb2duYW1lPU5VTEw7CisKIGludCBfV2luTWFpbiAoaW50IGFyZ2MsIGNoYXIgKmFyZ3YgW10pCiB7CiAgIEhJTlNUQU5DRSBoSW5zdGFuY2U7CiAKKyAgcHJvZ25hbWU9KmFyZ3Y7CiAgIGlmKCFNQUlOX0luaXQoKSkgcmV0dXJuIDA7IC8qIEpCUDogTmVlZGVkIGZvciBEb3NEcml2ZXNbXSBzdHJ1Y3R1cmUsIGV0Yy4gKi8KICAgaEluc3RhbmNlID0gV2luRXhlYyggKmFyZ3YsIFNXX1NIT1dOT1JNQUwgKTsKICAgVEFTS19SZXNjaGVkdWxlKCk7CmRpZmYgLS1naXQgYS90b29scy9idWlsZC5jIGIvdG9vbHMvYnVpbGQuYwppbmRleCA1OTU4ODc1Li43MGZmNDNmIDEwMDY0NAotLS0gYS90b29scy9idWlsZC5jCisrKyBiL3Rvb2xzL2J1aWxkLmMKQEAgLTg0LDYgKzg0LDMyIEBACiAgICAoKGludCkmKCgoc3RydWN0IHNpZ2NvbnRleHRfc3RydWN0ICopMSktPnJlZykgLSAxIFwKICAgICAtIHNpemVvZihzdHJ1Y3Qgc2lnY29udGV4dF9zdHJ1Y3QpKQogCitzdGF0aWMgdm9pZCAqeG1hbGxvYyAoc2l6ZV90IHNpemUpCit7CisgICAgdm9pZCAqcmVzOworCisgICAgcmVzID0gbWFsbG9jIChzaXplID8gc2l6ZSA6IDEpOworICAgIGlmIChyZXMgPT0gTlVMTCkKKyAgICB7CisgICAgICAgIGZwcmludGYgKHN0ZGVyciwgIlZpcnR1YWwgbWVtb3J5IGV4aGF1c3RlZC5cbiIpOworICAgICAgICBleGl0ICgxKTsKKyAgICB9CisgICAgcmV0dXJuIHJlczsKK30KKworCitzdGF0aWMgdm9pZCAqeHJlYWxsb2MgKHZvaWQgKnB0ciwgc2l6ZV90IHNpemUpCit7CisgICAgdm9pZCAqcmVzID0gcmVhbGxvYyAocHRyLCBzaXplKTsKKyAgICBpZiAocmVzID09IE5VTEwpCisgICAgeworICAgICAgICBmcHJpbnRmIChzdGRlcnIsICJWaXJ0dWFsIG1lbW9yeSBleGhhdXN0ZWQuXG4iKTsKKyAgICAgICAgZXhpdCAoMSk7CisgICAgfQorICAgIHJldHVybiByZXM7Cit9CisKKwogc3RhdGljIGludCBJc051bWJlclN0cmluZyhjaGFyICpzKQogewogICAgIHdoaWxlICgqcyAhPSAnXDAnKQpAQCAtMTU1LDcgKzE4MSw3IEBACiAKICAgICBpZiAoUGFyc2VCdWZmZXIgPT0gTlVMTCkKICAgICB7Ci0JUGFyc2VCdWZmZXIgPSBtYWxsb2MoNTEyKTsKKwlQYXJzZUJ1ZmZlciA9IHhtYWxsb2MoNTEyKTsKIAlQYXJzZU5leHQgPSBQYXJzZUJ1ZmZlcjsKIAlMaW5lKys7CiAJd2hpbGUgKDEpCkBAIC0yMDUsNyArMjMxLDcgQEAKIAogICAgIG5fdmFsdWVzID0gMDsKICAgICB2YWx1ZV9hcnJheV9zaXplID0gMjU7Ci0gICAgdmFsdWVfYXJyYXkgPSBtYWxsb2Moc2l6ZW9mKCp2YWx1ZV9hcnJheSkgKiB2YWx1ZV9hcnJheV9zaXplKTsKKyAgICB2YWx1ZV9hcnJheSA9IHhtYWxsb2Moc2l6ZW9mKCp2YWx1ZV9hcnJheSkgKiB2YWx1ZV9hcnJheV9zaXplKTsKICAgICAKICAgICB3aGlsZSAoKHRva2VuID0gR2V0VG9rZW4oKSkgIT0gTlVMTCkKICAgICB7CkBAIC0yMTYsOCArMjQyLDggQEAKIAlpZiAobl92YWx1ZXMgPT0gdmFsdWVfYXJyYXlfc2l6ZSkKIAl7CiAJICAgIHZhbHVlX2FycmF5X3NpemUgKz0gMjU7Ci0JICAgIHZhbHVlX2FycmF5ID0gcmVhbGxvYyh2YWx1ZV9hcnJheSwgCi0JCQkJICBzaXplb2YoKnZhbHVlX2FycmF5KSAqIHZhbHVlX2FycmF5X3NpemUpOworCSAgICB2YWx1ZV9hcnJheSA9IHhyZWFsbG9jKHZhbHVlX2FycmF5LCAKKwkJCQkgICBzaXplb2YoKnZhbHVlX2FycmF5KSAqIHZhbHVlX2FycmF5X3NpemUpOwogCX0KIAkKIAlpZiAoZW5kcHRyID09IE5VTEwgfHwgKmVuZHB0ciAhPSAnXDAnKQpAQCAtMjQ0LDExICsyNzAsMTEgQEAKICAgICBvZHAtPnR5cGUgPSB0eXBlOwogICAgIHN0cmNweShvZHAtPmV4cG9ydF9uYW1lLCBleHBvcnRfbmFtZSk7CiAKLSAgICB2ZHAgPSBtYWxsb2Moc2l6ZW9mKCp2ZHApKTsKKyAgICB2ZHAgPSB4bWFsbG9jKHNpemVvZigqdmRwKSk7CiAgICAgb2RwLT5hZGRpdGlvbmFsX2RhdGEgPSB2ZHA7CiAgICAgCiAgICAgdmRwLT5uX3ZhbHVlcyA9IG5fdmFsdWVzOwotICAgIHZkcC0+dmFsdWVzID0gcmVhbGxvYyh2YWx1ZV9hcnJheSwgc2l6ZW9mKCp2YWx1ZV9hcnJheSkgKiBuX3ZhbHVlcyk7CisgICAgdmRwLT52YWx1ZXMgPSB4cmVhbGxvYyh2YWx1ZV9hcnJheSwgc2l6ZW9mKCp2YWx1ZV9hcnJheSkgKiBuX3ZhbHVlcyk7CiAKICAgICByZXR1cm4gMDsKIH0KQEAgLTI2Myw3ICsyODksNyBAQAogICAgIG9kcCA9ICZPcmRpbmFsRGVmaW5pdGlvbnNbb3JkaW5hbF07CiAgICAgc3RyY3B5KG9kcC0+ZXhwb3J0X25hbWUsIEdldFRva2VuKCkpOwogICAgIG9kcC0+dHlwZSA9IHR5cGU7Ci0gICAgZmRwID0gbWFsbG9jKHNpemVvZigqZmRwKSk7CisgICAgZmRwID0geG1hbGxvYyhzaXplb2YoKmZkcCkpOwogICAgIG9kcC0+YWRkaXRpb25hbF9kYXRhID0gZmRwOwogCiAgICAgdG9rZW4gPSBHZXRUb2tlbigpOwpAQCAtMzMxLDcgKzM1Nyw3IEBACiAgICAgY2hhciAqdG9rZW47CiAgICAgY2hhciAqZW5kcHRyOwogICAgIAotICAgIHJkcCA9IG1hbGxvYyhzaXplb2YoKnJkcCkpOworICAgIHJkcCA9IHhtYWxsb2Moc2l6ZW9mKCpyZHApKTsKICAgICAKICAgICBvZHAgPSAmT3JkaW5hbERlZmluaXRpb25zW29yZGluYWxdOwogICAgIHN0cmNweShvZHAtPmV4cG9ydF9uYW1lLCBHZXRUb2tlbigpKTsKQEAgLTM2OCw3ICszOTQsNyBAQAogICAgIG9kcCA9ICZPcmRpbmFsRGVmaW5pdGlvbnNbb3JkaW5hbF07CiAgICAgc3RyY3B5KCBvZHAtPmV4cG9ydF9uYW1lLCBHZXRUb2tlbigpICk7CiAgICAgb2RwLT50eXBlID0gVFlQRV9TVFVCOwotICAgIGZkcCA9IG1hbGxvYyhzaXplb2YoKmZkcCkpOworICAgIGZkcCA9IHhtYWxsb2Moc2l6ZW9mKCpmZHApKTsKICAgICBvZHAtPmFkZGl0aW9uYWxfZGF0YSA9IGZkcDsKICAgICBmZHAtPmFyZ190eXBlc1swXSA9ICdcMCc7CiAgICAgc3RyY3B5KCBmZHAtPmludGVybmFsX25hbWUsIFNUVUJfQ0FMTEJBQ0sgKTsKQEAgLTUzMyw3ICs1NTksNyBAQAogICAgICAqIEJZVEVbbl0gICAgICAgICBFbnRyeSB0YWJsZQogICAgICAqLwogCi0gICAgYnVmZmVyID0gbWFsbG9jKCAweDEwMDAwICk7CisgICAgYnVmZmVyID0geG1hbGxvYyggMHgxMDAwMCApOwogCiAgICAgcE1vZHVsZSA9IChORV9NT0RVTEUgKilidWZmZXI7CiAgICAgcE1vZHVsZS0+bWFnaWMgPSBORV9TSUdOQVRVUkU7CkBAIC0xNjI1LDcgKzE2NTEsNyBAQAogICAgIHsKICAgICAgICAgLyogRmlsZSBoZWFkZXIgKi8KIAotICAgICAgICBwcmludGYoICIvKiBGaWxlIGdlbmVyYXRlZCBhdXRvbWF0aWNhbGx5LiBEbyBubyBlZGl0ISAqL1xuXG4iICk7CisgICAgICAgIHByaW50ZiggIi8qIEZpbGUgZ2VuZXJhdGVkIGF1dG9tYXRpY2FsbHkuIERvIG5vdCBlZGl0ISAqL1xuXG4iICk7CiAgICAgICAgIHByaW50ZiggIlx0LnRleHRcbiIgKTsKIAogICAgICAgICAvKiBCdWlsZCB0aGUgMzItYml0IGxhcmdlIHN0YWNrIGNhbGxiYWNrICovCkBAIC0xNjUyLDcgKzE2NzgsNyBAQAogICAgIHsKICAgICAgICAgLyogRmlsZSBoZWFkZXIgKi8KIAotICAgICAgICBwcmludGYoICIvKiBGaWxlIGdlbmVyYXRlZCBhdXRvbWF0aWNhbGx5LiBEbyBubyBlZGl0ISAqL1xuXG4iICk7CisgICAgICAgIHByaW50ZiggIi8qIEZpbGUgZ2VuZXJhdGVkIGF1dG9tYXRpY2FsbHkuIERvIG5vdCBlZGl0ISAqL1xuXG4iICk7CiAgICAgICAgIHByaW50ZiggIlx0LnRleHRcbiIgKTsKICAgICAgICAgcHJpbnRmKCAiXHQuZ2xvYmwgIiBQUkVGSVggIkNBTEwxNl9TdGFydFxuIiApOwogICAgICAgICBwcmludGYoIFBSRUZJWCAiQ0FMTDE2X1N0YXJ0OlxuIiApOwpkaWZmIC0tZ2l0IGEvd2luMzIvZmlsZS5jIGIvd2luMzIvZmlsZS5jCmluZGV4IDYxYjRhMDkuLjE2MGZjNDAgMTAwNjQ0Ci0tLSBhL3dpbjMyL2ZpbGUuYworKysgYi93aW4zMi9maWxlLmMKQEAgLTIxLDcgKzIxLDcgQEAKIHsKICAgICBEV09SRCBmaWxlX3R5cGU7CiAKLSAgICBpZihoRmlsZSA8IDMpCisgICAgaWYoKERXT1JEKWhGaWxlIDwgMykKICAgICB7CiAgICAgICAgIGZpbGVfdHlwZSA9IDI7ICAgICAgICAvKiBGSUxFX1RZUEVfQ0hBUiAqLwogICAgIH0KQEAgLTY3LDcgKzY3LDcgQEAKICAgICAgICAgfQogICAgIH0KIAotICAgIHJjID0gbHNlZWsoaEZpbGUsIGRpc3RhbmNlLCBtZXRob2QpOworICAgIHJjID0gbHNlZWsoKERXT1JEKWhGaWxlLCBkaXN0YW5jZSwgbWV0aG9kKTsKICAgICBpZihyYyA9PSAtMSkKICAgICAgICAgU2V0TGFzdEVycm9yKEVycm5vVG9MYXN0RXJyb3IoZXJybm8pKTsKICAgICByZXR1cm4gcmM7CkBAIC04NCw5ICs4NCw5IEBACiB7CiAgICAgaW50IHdyaXR0ZW47CiAKLSAgICBpZihoRmlsZSA8IDMpCisgICAgaWYoKERXT1JEKWhGaWxlIDwgMykKICAgICB7Ci0gICAgICAgIHdyaXR0ZW4gPSB3cml0ZShoRmlsZSwgbHBCdWZmZXIsIG51bWJlck9mQnl0ZXNUb1dyaXRlKTsKKyAgICAgICAgd3JpdHRlbiA9IHdyaXRlKChEV09SRCloRmlsZSwgbHBCdWZmZXIsIG51bWJlck9mQnl0ZXNUb1dyaXRlKTsKICAgICAgICAgaWYobnVtYmVyT2ZCeXRlc1dyaXR0ZW4pCiAgICAgICAgICAgICAqbnVtYmVyT2ZCeXRlc1dyaXR0ZW4gPSB3cml0dGVuOwogICAgIH0KZGlmZiAtLWdpdCBhL3dpbjMyL2luaXQuYyBiL3dpbjMyL2luaXQuYwppbmRleCA4MDAwZWRjLi4wNTU0YTJmIDEwMDY0NAotLS0gYS93aW4zMi9pbml0LmMKKysrIGIvd2luMzIvaW5pdC5jCkBAIC0zMyw5ICszMyw5IEBACiAgICAgbHBTdGFydHVwSW5mby0+bHBUaXRsZSA9ICJUaXRsZSI7CiAKICAgICBscFN0YXJ0dXBJbmZvLT5scFJlc2VydmVkMiA9IE5VTEw7IC8qIG11c3QgYmUgTlVMTCBmb3IgVkMgcnVudGltZSAqLwotICAgIGxwU3RhcnR1cEluZm8tPmhTdGRJbnB1dCA9IDA7Ci0gICAgbHBTdGFydHVwSW5mby0+aFN0ZE91dHB1dCA9IDE7Ci0gICAgbHBTdGFydHVwSW5mby0+aFN0ZEVycm9yID0gMjsKKyAgICBscFN0YXJ0dXBJbmZvLT5oU3RkSW5wdXQgID0gKEhBTkRMRSkwOworICAgIGxwU3RhcnR1cEluZm8tPmhTdGRPdXRwdXQgPSAoSEFORExFKTE7CisgICAgbHBTdGFydHVwSW5mby0+aFN0ZEVycm9yICA9IChIQU5ETEUpMjsKIH0KIAogaW50IEtFUk4zMl9Jbml0KHZvaWQpCmRpZmYgLS1naXQgYS93aW5kb3dzL2RlZmRsZy5jIGIvd2luZG93cy9kZWZkbGcuYwppbmRleCA5ZjMwYWYxLi40ZjE1MmZiIDEwMDY0NAotLS0gYS93aW5kb3dzL2RlZmRsZy5jCisrKyBiL3dpbmRvd3MvZGVmZGxnLmMKQEAgLTYyLDYgKzYyLDcgQEAKIH0KIAogCisjaWZkZWYgU1VQRVJGTFVPVVNfRlVOQ1RJT05TCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICBERUZETEdfRmluZERlZkJ1dHRvbgogICoKQEAgLTc4LDYgKzc5LDcgQEAKICAgICB9CiAgICAgcmV0dXJuIGh3bmRDaGlsZDsKIH0KKyNlbmRpZgogCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgpkaWZmIC0tZ2l0IGEvd2luZG93cy9kZWZ3bmQuYyBiL3dpbmRvd3MvZGVmd25kLmMKaW5kZXggMTQ3OWI2OC4uZWRhNGZlMiAxMDA2NDQKLS0tIGEvd2luZG93cy9kZWZ3bmQuYworKysgYi93aW5kb3dzL2RlZnduZC5jCkBAIC03MSw3ICs3MSwxMCBAQAogCXJldHVybiBOQ19IYW5kbGVOQ1BhaW50KCBod25kICk7CiAKICAgICBjYXNlIFdNX05DSElUVEVTVDoKLQlyZXR1cm4gTkNfSGFuZGxlTkNIaXRUZXN0KCBod25kLCBNQUtFUE9JTlQobFBhcmFtKSApOworICAgICAgICB7CisgICAgICAgICAgICBQT0lOVCBwdCA9IHsgTE9XT1JEKGxQYXJhbSksIEhJV09SRChsUGFyYW0pIH07CisgICAgICAgICAgICByZXR1cm4gTkNfSGFuZGxlTkNIaXRUZXN0KCBod25kLCBwdCApOworICAgICAgICB9CiAKICAgICBjYXNlIFdNX05DTEJVVFRPTkRPV046CiAJcmV0dXJuIE5DX0hhbmRsZU5DTEJ1dHRvbkRvd24oIGh3bmQsIHdQYXJhbSwgbFBhcmFtICk7CkBAIC0yMzYsNyArMjM5LDEwIEBACiAJcmV0dXJuIE5DX0hhbmRsZVNldEN1cnNvciggaHduZCwgd1BhcmFtLCBsUGFyYW0gKTsKIAogICAgIGNhc2UgV01fU1lTQ09NTUFORDoKLQlyZXR1cm4gTkNfSGFuZGxlU3lzQ29tbWFuZCggaHduZCwgd1BhcmFtLCBNQUtFUE9JTlQobFBhcmFtKSApOworICAgICAgICB7CisgICAgICAgICAgICBQT0lOVCBwdCA9IHsgTE9XT1JEKGxQYXJhbSksIEhJV09SRChsUGFyYW0pIH07CisgICAgICAgICAgICByZXR1cm4gTkNfSGFuZGxlU3lzQ29tbWFuZCggaHduZCwgd1BhcmFtLCBwdCApOworICAgICAgICB9CiAKICAgICBjYXNlIFdNX1NZU0tFWURPV046CiAJaWYgKHdQYXJhbSA9PSBWS19NRU5VKQpkaWZmIC0tZ2l0IGEvd2luZG93cy9kaWFsb2cuYyBiL3dpbmRvd3MvZGlhbG9nLmMKaW5kZXggOGRjMjljNC4uNmExNjgwNSAxMDA2NDQKLS0tIGEvd2luZG93cy9kaWFsb2cuYworKysgYi93aW5kb3dzL2RpYWxvZy5jCkBAIC0zMjgsMTIgKzMyOCwyOSBAQAogCWlmIChoTWVudSkgRGVzdHJveU1lbnUoIGhNZW51ICk7CiAJcmV0dXJuIDA7CiAgICAgfQorICAgIHduZFB0ciA9IFdJTl9GaW5kV25kUHRyKCBod25kICk7CisKKyAgICAgIC8qIFB1cmdlIGp1bmsgZnJvbSBzeXN0ZW0gbWVudSAqLworICAgICAgLyogRklYTUU6IHRoaXMgZG9lc24ndCBiZWxvbmcgaGVyZSAqLworCisgICAgRGVsZXRlTWVudSh3bmRQdHItPmhTeXNNZW51LFNDX1NJWkUsTUZfQllDT01NQU5EKTsKKyAgICBpZiAoISh3bmRQdHItPmR3U3R5bGUgJiBXU19NQVhJTUlaRUJPWCkgKQorICAgIHsKKyAgICAgICAgRGVsZXRlTWVudSh3bmRQdHItPmhTeXNNZW51LFNDX01BWElNSVpFLE1GX0JZQ09NTUFORCk7CisgICAgICAgIGlmKCAhKHduZFB0ci0+ZHdTdHlsZSAmIFdTX01JTklNSVpFQk9YKSApCisgICAgICAgIHsKKyAgICAgICAgICAgIERlbGV0ZU1lbnUod25kUHRyLT5oU3lzTWVudSxTQ19NSU5JTUlaRSxNRl9CWUNPTU1BTkQpOworICAgICAgICAgICAgRGVsZXRlTWVudSh3bmRQdHItPmhTeXNNZW51LFNDX1JFU1RPUkUsTUZfQllDT01NQU5EKTsKKyAgICAgICAgfQorICAgIH0KKyAgICBlbHNlCisgICAgICAgIGlmICghKHduZFB0ci0+ZHdTdHlsZSAmIFdTX01JTklNSVpFQk9YKSApCisgICAgICAgICAgICBEZWxldGVNZW51KHduZFB0ci0+aFN5c01lbnUsU0NfTUlOSU1JWkUsTUZfQllDT01NQU5EKTsKIAogICAgICAgLyogQ3JlYXRlIGNvbnRyb2wgd2luZG93cyAqLwogCiAgICAgZHByaW50Zl9kaWFsb2coc3RkZGViLCAiIEJFR0lOXG4iICk7CiAKLSAgICB3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwogICAgIGRsZ0luZm8gPSAoRElBTE9HSU5GTyAqKXduZFB0ci0+d0V4dHJhOwogICAgIGRsZ0luZm8tPm1zZ1Jlc3VsdCA9IDA7ICAvKiBUaGlzIGlzIHVzZWQgdG8gc3RvcmUgdGhlIGRlZmF1bHQgYnV0dG9uIGlkICovCiAgICAgZGxnSW5mby0+aERpYWxvZ0hlYXAgPSAwOwpAQCAtNDY5LDcgKzQ4Niw3IEBACiAgICAgRW5hYmxlV2luZG93KCBvd25lciwgRkFMU0UgKTsKICAgICBTaG93V2luZG93KCBod25kLCBTV19TSE9XICk7CiAKLSAgICB3aGlsZSAoTVNHX0ludGVybmFsR2V0TWVzc2FnZSggVVNFUl9IRUFQX1NFR19BRERSKG1zZ0hhbmRsZSksIGh3bmQsIG93bmVyLAorICAgIHdoaWxlIChNU0dfSW50ZXJuYWxHZXRNZXNzYWdlKCAoU0VHUFRSKVVTRVJfSEVBUF9TRUdfQUREUihtc2dIYW5kbGUpLCBod25kLCBvd25lciwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTVNHRl9ESUFMT0dCT1gsIFBNX1JFTU9WRSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgISh3bmRQdHItPmR3U3R5bGUgJiBEU19OT0lETEVNU0cpICkpCiAgICAgewpkaWZmIC0tZ2l0IGEvd2luZG93cy9ldmVudC5jIGIvd2luZG93cy9ldmVudC5jCmluZGV4IGE5MWQyNDguLjI4ZjIxZTEgMTAwNjQ0Ci0tLSBhL3dpbmRvd3MvZXZlbnQuYworKysgYi93aW5kb3dzL2V2ZW50LmMKQEAgLTE5LDYgKzE5LDggQEAKICNpbmNsdWRlICJtZXNzYWdlLmgiCiAjaW5jbHVkZSAiY2xpcGJvYXJkLmgiCiAjaW5jbHVkZSAid2lucG9zLmgiCisjaW5jbHVkZSAicmVnaXN0ZXJzLmgiCisjaW5jbHVkZSAic3RhY2tmcmFtZS5oIgogI2luY2x1ZGUgInN0ZGRlYnVnLmgiCiAvKiAjZGVmaW5lIERFQlVHX0VWRU5UICovCiAvKiAjZGVmaW5lIERFQlVHX0tFWSAgICovCkBAIC01ODYsNiArNTg4LDU4IEBACiB9CiAKIAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiAgICAgICAgICAgR2V0TW91c2VFdmVudFByb2MgICAoVVNFUi4zMzcpCisgKi8KK0ZBUlBST0MgR2V0TW91c2VFdmVudFByb2Modm9pZCkKK3sKKyAgICBjaGFyIG5hbWVbXSA9ICJNb3VzZV9FdmVudCI7CisgICAgcmV0dXJuIEdldFByb2NBZGRyZXNzKCBHZXRNb2R1bGVIYW5kbGUoIlVTRVIiKSwgTUFLRV9TRUdQVFIobmFtZSkgKTsKK30KKworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqICAgICAgICAgICBNb3VzZV9FdmVudCAgIChVU0VSLjI5OSkKKyAqLworI2lmbmRlZiBXSU5FTElCCit2b2lkIE1vdXNlX0V2ZW50KCBzdHJ1Y3Qgc2lnY29udGV4dF9zdHJ1Y3QgY29udGV4dCApCit7CisgICAgLyogUmVnaXN0ZXIgdmFsdWVzOgorICAgICAqIEFYID0gbW91c2UgZXZlbnQKKyAgICAgKiBCWCA9IGhvcml6b250YWwgZGlzcGxhY2VtZW50IGlmIEFYICYgTUVfTU9WRQorICAgICAqIENYID0gdmVydGljYWwgZGlzcGxhY2VtZW50IGlmIEFYICYgTUVfTU9WRQorICAgICAqIERYID0gYnV0dG9uIHN0YXRlICg/KQorICAgICAqIFNJID0gbW91c2UgZXZlbnQgZmxhZ3MgKD8pCisgICAgICovCisgICAgV2luZG93IHJvb3QsIGNoaWxkOworICAgIGludCByb290WCwgcm9vdFksIGNoaWxkWCwgY2hpbGRZOworICAgIHVuc2lnbmVkIGludCBzdGF0ZTsKKworICAgIGlmIChBWF9yZWcoJmNvbnRleHQpICYgTUVfTU9WRSkKKyAgICB7CisgICAgICAgIC8qIFdlIGhhdmUgdG8gYWN0dWFsbHkgbW92ZSB0aGUgY3Vyc29yICovCisgICAgICAgIFhXYXJwUG9pbnRlciggZGlzcGxheSwgcm9vdFdpbmRvdywgTm9uZSwgMCwgMCwgMCwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAoc2hvcnQpQlhfcmVnKCZjb250ZXh0KSwgKHNob3J0KUNYX3JlZygmY29udGV4dCkgKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBpZiAoIVhRdWVyeVBvaW50ZXIoIGRpc3BsYXksIHJvb3RXaW5kb3csICZyb290LCAmY2hpbGQsCisgICAgICAgICAgICAgICAgICAgICAgICAmcm9vdFgsICZyb290WSwgJmNoaWxkWCwgJmNoaWxkWSwgJnN0YXRlICkpIHJldHVybjsKKyAgICBpZiAoQVhfcmVnKCZjb250ZXh0KSAmIE1FX0xET1dOKQorICAgICAgICBoYXJkd2FyZV9ldmVudCggV01fTEJVVFRPTkRPV04sIEVWRU5UX1hTdGF0ZVRvS2V5U3RhdGUoIHN0YXRlICksIDBMLAorICAgICAgICAgICAgICAgICAgICAgICAgcm9vdFggLSBkZXNrdG9wWCwgcm9vdFkgLSBkZXNrdG9wWSwgR2V0VGlja0NvdW50KCksIDApOworICAgIGlmIChBWF9yZWcoJmNvbnRleHQpICYgTUVfTFVQKQorICAgICAgICBoYXJkd2FyZV9ldmVudCggV01fTEJVVFRPTlVQLCBFVkVOVF9YU3RhdGVUb0tleVN0YXRlKCBzdGF0ZSApLCAwTCwKKyAgICAgICAgICAgICAgICAgICAgICAgIHJvb3RYIC0gZGVza3RvcFgsIHJvb3RZIC0gZGVza3RvcFksIEdldFRpY2tDb3VudCgpLCAwKTsKKyAgICBpZiAoQVhfcmVnKCZjb250ZXh0KSAmIE1FX1JET1dOKQorICAgICAgICBoYXJkd2FyZV9ldmVudCggV01fUkJVVFRPTkRPV04sIEVWRU5UX1hTdGF0ZVRvS2V5U3RhdGUoIHN0YXRlICksIDBMLAorICAgICAgICAgICAgICAgICAgICAgICAgcm9vdFggLSBkZXNrdG9wWCwgcm9vdFkgLSBkZXNrdG9wWSwgR2V0VGlja0NvdW50KCksIDApOworICAgIGlmIChBWF9yZWcoJmNvbnRleHQpICYgTUVfUlVQKQorICAgICAgICBoYXJkd2FyZV9ldmVudCggV01fUkJVVFRPTlVQLCBFVkVOVF9YU3RhdGVUb0tleVN0YXRlKCBzdGF0ZSApLCAwTCwKKyAgICAgICAgICAgICAgICAgICAgICAgIHJvb3RYIC0gZGVza3RvcFgsIHJvb3RZIC0gZGVza3RvcFksIEdldFRpY2tDb3VudCgpLCAwKTsKK30KKyNlbmRpZgorCisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgkJCUVuYWJsZUhhcmR3YXJlSW5wdXQgCQlbVVNFUi4zMzFdCiAgKi8KZGlmZiAtLWdpdCBhL3dpbmRvd3MvZ3JhcGhpY3MuYyBiL3dpbmRvd3MvZ3JhcGhpY3MuYwppbmRleCA2MDhmYmVhLi5kNDQ3NWJhIDEwMDY0NAotLS0gYS93aW5kb3dzL2dyYXBoaWNzLmMKKysrIGIvd2luZG93cy9ncmFwaGljcy5jCkBAIC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSAiY29sb3IuaCIKICNpbmNsdWRlICJyZWdpb24uaCIKICNpbmNsdWRlICJkZWJ1Zy5oIgorI2luY2x1ZGUgInhtYWxsb2MuaCIKIAogc3RhdGljIF9faW5saW5lX18gdm9pZCBzd2FwX2ludChpbnQgKmEsIGludCAqYikKIHsKQEAgLTc4Niw3ICs3ODcsNyBAQAogewogICAgIHJlZ2lzdGVyIGludCBpOwogICAgIERDICogZGMgPSAoREMgKikgR0RJX0dldE9ialB0ciggaGRjLCBEQ19NQUdJQyApOwotICAgIFhQb2ludCAqcG9pbnRzID0gKFhQb2ludCAqKSBtYWxsb2MgKHNpemVvZiAoWFBvaW50KSAqIChjb3VudCsxKSk7CisgICAgWFBvaW50ICpwb2ludHMgPSAoWFBvaW50ICopIHhtYWxsb2MgKHNpemVvZiAoWFBvaW50KSAqIChjb3VudCsxKSk7CiAKICAgICBpZiAoIWRjKSAKICAgICB7CkBAIC04NDcsNyArODQ4LDcgQEAKIAlYUG9pbnQgKnBvaW50czsKIAogCWZvciAoaSA9IDA7IGkgPCBwb2x5Z29uczsgaSsrKSBpZiAoY291bnRzW2ldID4gbWF4KSBtYXggPSBjb3VudHNbaV07Ci0JcG9pbnRzID0gKFhQb2ludCAqKSBtYWxsb2MoIHNpemVvZihYUG9pbnQpICogKG1heCsxKSApOworCXBvaW50cyA9IChYUG9pbnQgKikgeG1hbGxvYyggc2l6ZW9mKFhQb2ludCkgKiAobWF4KzEpICk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcG9seWdvbnM7IGkrKykKIAl7CmRpZmYgLS1naXQgYS93aW5kb3dzL2hvb2suYyBiL3dpbmRvd3MvaG9vay5jCmluZGV4IDA4NDcyYWYuLmQ1NmM5M2YgMTAwNjQ0Ci0tLSBhL3dpbmRvd3MvaG9vay5jCisrKyBiL3dpbmRvd3MvaG9vay5jCkBAIC0xMDksNyArMTA5LDcgQEAKIAogICAgIGlmICgoaWQgPCBGSVJTVF9IT09LKSB8fCAoaWQgPiBMQVNUX0hPT0spKSByZXR1cm4gMDsKICAgICBpZiAoaWQgIT0gV0hfR0VUTUVTU0FHRSAmJiBpZCAhPSBXSF9DQUxMV05EUFJPQykgewotCWZwcmludGYoIHN0ZG5pbXAsICJVbmltcGxlbWVudGVkIGhvb2sgc2V0OiAoJWQsJTA4bHgsJTA0eCwlMDR4KSFcbiIsCisJZnByaW50Ziggc3RkbmltcCwgIlVuaW1wbGVtZW50ZWQgaG9vayBzZXQ6ICglZCwlMDhseCwiTlBGTVQiLCJOUEZNVCIpIVxuIiwKICAgICAgICAgICAgICAgICAgaWQsIChEV09SRClwcm9jLCBoaW5zdCwgaHRhc2sgKTsKICAgICB9CiAgICAgaWYgKGh0YXNrKSAgLyogVGFzay1zcGVjaWZpYyBob29rICovCmRpZmYgLS1naXQgYS93aW5kb3dzL21kaS5jIGIvd2luZG93cy9tZGkuYwppbmRleCA3NmY2ZDg3Li5lMWEzZGRmIDEwMDY0NAotLS0gYS93aW5kb3dzL21kaS5jCisrKyBiL3dpbmRvd3MvbWRpLmMKQEAgLTQxNCw4ICs0MTQsOSBAQAogICAgIHhzaXplICAgPSByZWN0LnJpZ2h0ICAtIDggKiBzcGFjaW5nOwogICAgIAogICAgIGRwcmludGZfbWRpKHN0ZGRlYiwgCi0JICAgICJNRElDYXNjYWRlOiBDbGllbnQgd25kIGF0ICglZCwlZCkgLSAoJWQsJWQpLCBzcGFjaW5nICVkXG4iLCAKLQkgICAgcmVjdC5sZWZ0LCByZWN0LnRvcCwgcmVjdC5yaWdodCwgcmVjdC5ib3R0b20sIHNwYWNpbmcpOworICAgICAgIk1ESUNhc2NhZGU6IENsaWVudCB3bmQgYXQgKCVsZCwlbGQpIC0gKCVsZCwlbGQpLCBzcGFjaW5nICVkXG4iLCAKKyAgICAgIChMT05HKXJlY3QubGVmdCwgKExPTkcpcmVjdC50b3AsIChMT05HKXJlY3QucmlnaHQsIChMT05HKXJlY3QuYm90dG9tLAorICAgICAgc3BhY2luZyk7CiAgICAgZHByaW50Zl9tZGkoc3RkZGViLCAiTURJQ2FzY2FkZTogc2VhcmNoaW5nIGZvciBsYXN0IGNoaWxkXG4iKTsKICAgICBoaW5mbyA9IGNpLT5pbmZvQWN0aXZlQ2hpbGRyZW47CiAgICAgd2hpbGUoMSkgewpkaWZmIC0tZ2l0IGEvd2luZG93cy9tZXNzYWdlLmMgYi93aW5kb3dzL21lc3NhZ2UuYwppbmRleCBhZGVmYjE0Li5hMzA5MzU2IDEwMDY0NAotLS0gYS93aW5kb3dzL21lc3NhZ2UuYworKysgYi93aW5kb3dzL21lc3NhZ2UuYwpAQCAtMjkxLDYgKzI5MSw3IEBACiAgICAgc3RhdGljIERXT1JEIGxhc3RDbGlja1RpbWUgPSAwOwogICAgIHN0YXRpYyBXT1JEICBsYXN0Q2xpY2tNc2cgPSAwOwogICAgIHN0YXRpYyBQT0lOVCBsYXN0Q2xpY2tQb3MgPSB7IDAsIDAgfTsKKyAgICBQT0lOVCBwdCA9IG1zZy0+cHQ7CiAKICAgICBCT09MIG1vdXNlQ2xpY2sgPSAoKG1zZy0+bWVzc2FnZSA9PSBXTV9MQlVUVE9ORE9XTikgfHwKIAkJICAgICAgIChtc2ctPm1lc3NhZ2UgPT0gV01fUkJVVFRPTkRPV04pIHx8CkBAIC0zMDEsOCArMzAyLDggQEAKICAgICBpZiAoR2V0Q2FwdHVyZSgpKQogICAgIHsKIAltc2ctPmh3bmQgPSBHZXRDYXB0dXJlKCk7Ci0JbXNnLT5sUGFyYW0gPSBNQUtFTE9ORyggbXNnLT5wdC54LCBtc2ctPnB0LnkgKTsKLQlTY3JlZW5Ub0NsaWVudCggbXNnLT5od25kLCAoTFBQT0lOVCkmbXNnLT5sUGFyYW0gKTsKKwlTY3JlZW5Ub0NsaWVudCggbXNnLT5od25kLCAmcHQgKTsKKwltc2ctPmxQYXJhbSA9IE1BS0VMT05HKCBwdC54LCBwdC55ICk7CiAJcmV0dXJuIFRSVUU7ICAvKiBObyBuZWVkIHRvIGZ1cnRoZXIgcHJvY2VzcyB0aGUgbWVzc2FnZSAqLwogICAgIH0KICAgIApAQCAtMzc5LDE2ICszODAsMTQgQEAKIAogICAgICAgLyogQnVpbGQgdGhlIHRyYW5zbGF0ZWQgbWVzc2FnZSAqLwogCi0gICAgbXNnLT5sUGFyYW0gPSBNQUtFTE9ORyggbXNnLT5wdC54LCBtc2ctPnB0LnkgKTsKICAgICBpZiAoaGl0dGVzdCA9PSBIVENMSUVOVCkKLSAgICB7Ci0JU2NyZWVuVG9DbGllbnQoIG1zZy0+aHduZCwgKExQUE9JTlQpJm1zZy0+bFBhcmFtICk7Ci0gICAgfQorICAgICAgICBTY3JlZW5Ub0NsaWVudCggbXNnLT5od25kLCAmcHQgKTsKICAgICBlbHNlCiAgICAgewogCW1zZy0+d1BhcmFtID0gaGl0dGVzdDsKIAltc2ctPm1lc3NhZ2UgKz0gV01fTkNMQlVUVE9ORE9XTiAtIFdNX0xCVVRUT05ET1dOOwogICAgIH0KKyAgICBtc2ctPmxQYXJhbSA9IE1BS0VMT05HKCBwdC54LCBwdC55ICk7CiAgICAgCiAgICAgcmV0dXJuIFRSVUU7CiB9CkBAIC05NTIsNyArOTUxLDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIEdldE1lc3NhZ2UgICAoVVNFUi4xMDgpCiAgKi8KLUJPT0wgR2V0TWVzc2FnZSggU0VHUFRSIG1zZywgSFdORCBod25kLCBXT1JEIGZpcnN0LCBXT1JEIGxhc3QgKSAKK0JPT0wgR2V0TWVzc2FnZSggU0VHUFRSIG1zZywgSFdORCBod25kLCBVSU5UIGZpcnN0LCBVSU5UIGxhc3QgKSAKIHsKICAgICBNU0dfUGVla01lc3NhZ2UoIChNU0cgKilQVFJfU0VHX1RPX0xJTihtc2cpLAogICAgICAgICAgICAgICAgICAgICAgaHduZCwgZmlyc3QsIGxhc3QsIFBNX1JFTU9WRSwgRkFMU0UgKTsKZGlmZiAtLWdpdCBhL3dpbmRvd3MvbXNnYm94LmMgYi93aW5kb3dzL21zZ2JveC5jCmluZGV4IGUwY2Q0NmMuLmRkYjk2OTAgMTAwNjQ0Ci0tLSBhL3dpbmRvd3MvbXNnYm94LmMKKysrIGIvd2luZG93cy9tc2dib3guYwpAQCAtMTIxLDcgKzEyMSw3IEBACiAgICAgbFJldCA9IERyYXdUZXh0KGhkYywgbHBtYi0+dGV4dCwgLTEsICZyZWN0LAogCQkgICAgRFRfTEVGVCB8IERUX0VYUEFORFRBQlMgfCBEVF9XT1JEQlJFQUsgfCBEVF9DQUxDUkVDVCk7CiAgICAgdGhlaWdodCA9IHJlY3QuYm90dG9tICAtIHJlY3QudG9wOwotICAgIHRpaGVpZ2h0ID0gMTYgKyBtYXgoaWhlaWdodCwgdGhlaWdodCk7CisgICAgdGloZWlnaHQgPSAxNiArIE1BWChpaGVpZ2h0LCB0aGVpZ2h0KTsKICAgICBSZWxlYXNlREMoaEl0ZW0sIGhkYyk7CiAgICAgCiAgICAgLyogUG9zaXRpb24gdGhlIHRleHQgKi8KZGlmZiAtLWdpdCBhL3dpbmRvd3Mvbm9uY2xpZW50LmMgYi93aW5kb3dzL25vbmNsaWVudC5jCmluZGV4IGFhNzdiZWYuLjA4NmRjMTggMTAwNjQ0Ci0tLSBhL3dpbmRvd3Mvbm9uY2xpZW50LmMKKysrIGIvd2luZG93cy9ub25jbGllbnQuYwpAQCAtMTAyLDggKzEwMiw5IEBACiAJc3R5bGUgfD0gV1NfQ0FQVElPTjsKICAgICBpZiAoZXhTdHlsZSAmIFdTX0VYX0RMR01PREFMRlJBTUUpIHN0eWxlICY9IH5XU19USElDS0ZSQU1FOwogCi0gICAgZHByaW50Zl9ub25jbGllbnQoc3RkZGViLCAiQWRqdXN0V2luZG93UmVjdEV4OiAoJWQsJWQpLSglZCwlZCkgJTA4bHggJWQgJTA4bHhcbiIsCi0gICAgICByZWN0LT5sZWZ0LCByZWN0LT50b3AsIHJlY3QtPnJpZ2h0LCByZWN0LT5ib3R0b20sIHN0eWxlLCBtZW51LCBleFN0eWxlICk7CisgICAgZHByaW50Zl9ub25jbGllbnQoc3RkZGViLCAiQWRqdXN0V2luZG93UmVjdEV4OiAoJWxkLCVsZCktKCVsZCwlbGQpICUwOGx4ICVkICUwOGx4XG4iLAorICAgICAgKExPTkcpcmVjdC0+bGVmdCwgKExPTkcpcmVjdC0+dG9wLCAoTE9ORylyZWN0LT5yaWdodCwgKExPTkcpcmVjdC0+Ym90dG9tLAorICAgICAgc3R5bGUsIG1lbnUsIGV4U3R5bGUgKTsKIAogICAgIE5DX0FkanVzdFJlY3QoIHJlY3QsIHN0eWxlLCBtZW51LCBleFN0eWxlICk7CiB9CkBAIC0xNzYsOSArMTc3LDkgQEAKIAogICAgICAgLyogU29tZSBzYW5pdHkgY2hlY2tzICovCiAKLSAgICBwTWluTWF4LT5wdE1heFRyYWNrU2l6ZS54ID0gbWF4KCBwTWluTWF4LT5wdE1heFRyYWNrU2l6ZS54LAorICAgIHBNaW5NYXgtPnB0TWF4VHJhY2tTaXplLnggPSBNQVgoIHBNaW5NYXgtPnB0TWF4VHJhY2tTaXplLngsCiAJCQkJICAgICBwTWluTWF4LT5wdE1pblRyYWNrU2l6ZS54ICk7Ci0gICAgcE1pbk1heC0+cHRNYXhUcmFja1NpemUueSA9IG1heCggcE1pbk1heC0+cHRNYXhUcmFja1NpemUueSwKKyAgICBwTWluTWF4LT5wdE1heFRyYWNrU2l6ZS55ID0gTUFYKCBwTWluTWF4LT5wdE1heFRyYWNrU2l6ZS55LAogCQkJCSAgICAgcE1pbk1heC0+cHRNaW5UcmFja1NpemUueSApOwogICAgIAogICAgIGlmIChtYXhTaXplKSAqbWF4U2l6ZSA9IHBNaW5NYXgtPnB0TWF4U2l6ZTsKQEAgLTI2MCw4ICsyNjEsOCBAQAogICAgIFdORCAqd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKICAgICBpZiAoIXduZFB0cikgcmV0dXJuIEhURVJST1I7CiAKLSAgICBkcHJpbnRmX25vbmNsaWVudChzdGRkZWIsICJOQ19IYW5kbGVOQ0hpdFRlc3Q6IGh3bmQ9Ik5QRk1UIiBwdD0lZCwlZFxuIiwKLQkJICAgICAgaHduZCwgcHQueCwgcHQueSApOworICAgIGRwcmludGZfbm9uY2xpZW50KHN0ZGRlYiwgIk5DX0hhbmRsZU5DSGl0VGVzdDogaHduZD0iTlBGTVQiIHB0PSVsZCwlbGRcbiIsCisJCSAgICAgIGh3bmQsIChMT05HKXB0LngsIChMT05HKXB0LnkgKTsKIAogICAgIEdldFdpbmRvd1JlY3QoIGh3bmQsICZyZWN0ICk7CiAgICAgaWYgKCFQdEluUmVjdCggJnJlY3QsIHB0ICkpIHJldHVybiBIVE5PV0hFUkU7CkBAIC05MjcsMjMgKzkyOCwyMyBAQAogICAgIGVsc2UgU2V0UmVjdCggJm1vdXNlUmVjdCwgMCwgMCwgU1lTTUVUUklDU19DWFNDUkVFTiwgU1lTTUVUUklDU19DWVNDUkVFTiApOwogICAgIGlmIChPTl9MRUZUX0JPUkRFUihoaXR0ZXN0KSkKICAgICB7Ci0JbW91c2VSZWN0LmxlZnQgID0gbWF4KCBtb3VzZVJlY3QubGVmdCwgc2l6aW5nUmVjdC5yaWdodC1tYXhUcmFjay54ICk7Ci0JbW91c2VSZWN0LnJpZ2h0ID0gbWluKCBtb3VzZVJlY3QucmlnaHQsIHNpemluZ1JlY3QucmlnaHQtbWluVHJhY2sueCApOworCW1vdXNlUmVjdC5sZWZ0ICA9IE1BWCggbW91c2VSZWN0LmxlZnQsIHNpemluZ1JlY3QucmlnaHQtbWF4VHJhY2sueCApOworCW1vdXNlUmVjdC5yaWdodCA9IE1JTiggbW91c2VSZWN0LnJpZ2h0LCBzaXppbmdSZWN0LnJpZ2h0LW1pblRyYWNrLnggKTsKICAgICB9CiAgICAgZWxzZSBpZiAoT05fUklHSFRfQk9SREVSKGhpdHRlc3QpKQogICAgIHsKLQltb3VzZVJlY3QubGVmdCAgPSBtYXgoIG1vdXNlUmVjdC5sZWZ0LCBzaXppbmdSZWN0LmxlZnQrbWluVHJhY2sueCApOwotCW1vdXNlUmVjdC5yaWdodCA9IG1pbiggbW91c2VSZWN0LnJpZ2h0LCBzaXppbmdSZWN0LmxlZnQrbWF4VHJhY2sueCApOworCW1vdXNlUmVjdC5sZWZ0ICA9IE1BWCggbW91c2VSZWN0LmxlZnQsIHNpemluZ1JlY3QubGVmdCttaW5UcmFjay54ICk7CisJbW91c2VSZWN0LnJpZ2h0ID0gTUlOKCBtb3VzZVJlY3QucmlnaHQsIHNpemluZ1JlY3QubGVmdCttYXhUcmFjay54ICk7CiAgICAgfQogICAgIGlmIChPTl9UT1BfQk9SREVSKGhpdHRlc3QpKQogICAgIHsKLQltb3VzZVJlY3QudG9wICAgID0gbWF4KCBtb3VzZVJlY3QudG9wLCBzaXppbmdSZWN0LmJvdHRvbS1tYXhUcmFjay55ICk7Ci0JbW91c2VSZWN0LmJvdHRvbSA9IG1pbiggbW91c2VSZWN0LmJvdHRvbSxzaXppbmdSZWN0LmJvdHRvbS1taW5UcmFjay55KTsKKwltb3VzZVJlY3QudG9wICAgID0gTUFYKCBtb3VzZVJlY3QudG9wLCBzaXppbmdSZWN0LmJvdHRvbS1tYXhUcmFjay55ICk7CisJbW91c2VSZWN0LmJvdHRvbSA9IE1JTiggbW91c2VSZWN0LmJvdHRvbSxzaXppbmdSZWN0LmJvdHRvbS1taW5UcmFjay55KTsKICAgICB9CiAgICAgZWxzZSBpZiAoT05fQk9UVE9NX0JPUkRFUihoaXR0ZXN0KSkKICAgICB7Ci0JbW91c2VSZWN0LnRvcCAgICA9IG1heCggbW91c2VSZWN0LnRvcCwgc2l6aW5nUmVjdC50b3ArbWluVHJhY2sueSApOwotCW1vdXNlUmVjdC5ib3R0b20gPSBtaW4oIG1vdXNlUmVjdC5ib3R0b20sIHNpemluZ1JlY3QudG9wK21heFRyYWNrLnkgKTsKKwltb3VzZVJlY3QudG9wICAgID0gTUFYKCBtb3VzZVJlY3QudG9wLCBzaXppbmdSZWN0LnRvcCttaW5UcmFjay55ICk7CisJbW91c2VSZWN0LmJvdHRvbSA9IE1JTiggbW91c2VSZWN0LmJvdHRvbSwgc2l6aW5nUmVjdC50b3ArbWF4VHJhY2sueSApOwogICAgIH0KICAgICBTZW5kTWVzc2FnZSggaHduZCwgV01fRU5URVJTSVpFTU9WRSwgMCwgMCApOwogCkBAIC05ODgsMTAgKzk4OSwxMCBAQAogCSAgICBjYXNlIFZLX1JJR0hUOiBwdC54ICs9IDg7IGJyZWFrOwkJCiAJfQogCi0JcHQueCA9IG1heCggcHQueCwgbW91c2VSZWN0LmxlZnQgKTsKLQlwdC54ID0gbWluKCBwdC54LCBtb3VzZVJlY3QucmlnaHQgKTsKLQlwdC55ID0gbWF4KCBwdC55LCBtb3VzZVJlY3QudG9wICk7Ci0JcHQueSA9IG1pbiggcHQueSwgbW91c2VSZWN0LmJvdHRvbSApOworCXB0LnggPSBNQVgoIHB0LngsIG1vdXNlUmVjdC5sZWZ0ICk7CisJcHQueCA9IE1JTiggcHQueCwgbW91c2VSZWN0LnJpZ2h0ICk7CisJcHQueSA9IE1BWCggcHQueSwgbW91c2VSZWN0LnRvcCApOworCXB0LnkgPSBNSU4oIHB0LnksIG1vdXNlUmVjdC5ib3R0b20gKTsKIAogCWR4ID0gcHQueCAtIGNhcHR1cmVQb2ludC54OwogCWR5ID0gcHQueSAtIGNhcHR1cmVQb2ludC55OwpAQCAtMTEyMCw5ICsxMTIxLDEwIEBACiAJY2FzZSBXTV9MQlVUVE9OVVA6CiAJY2FzZSBXTV9NT1VTRU1PVkU6CiAgICAgICAgIGNhc2UgV01fU1lTVElNRVI6Ci0gICAgICAgICAgICBwdCA9IE1BS0VQT0lOVChtc2ctPmxQYXJhbSk7Ci0gICAgICAgICAgICBwdC54ICs9IHduZFB0ci0+cmVjdENsaWVudC5sZWZ0IC0gd25kUHRyLT5yZWN0V2luZG93LmxlZnQ7Ci0gICAgICAgICAgICBwdC55ICs9IHduZFB0ci0+cmVjdENsaWVudC50b3AgLSB3bmRQdHItPnJlY3RXaW5kb3cudG9wOworICAgICAgICAgICAgcHQueCA9IExPV09SRChtc2ctPmxQYXJhbSkgKyB3bmRQdHItPnJlY3RDbGllbnQubGVmdCAtIAorCSAgICAgIHduZFB0ci0+cmVjdFdpbmRvdy5sZWZ0OworICAgICAgICAgICAgcHQueSA9IEhJV09SRChtc2ctPmxQYXJhbSkgKyB3bmRQdHItPnJlY3RDbGllbnQudG9wIC0gCisJICAgICAgd25kUHRyLT5yZWN0V2luZG93LnRvcDsKICAgICAgICAgICAgIFNDUk9MTF9IYW5kbGVTY3JvbGxFdmVudCggaHduZCwgc2Nyb2xsYmFyLCBtc2ctPm1lc3NhZ2UsIHB0ICk7CiAJICAgIGJyZWFrOwogICAgICAgICBkZWZhdWx0OgpAQCAtMTE3Nyw2ICsxMTc5LDcgQEAKIExPTkcgTkNfSGFuZGxlTkNMQnV0dG9uRG93biggSFdORCBod25kLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtICkKIHsKICAgICBIREMgaGRjID0gR2V0V2luZG93REMoIGh3bmQgKTsKKyAgICBQT0lOVCBwdCA9IHsgTE9XT1JEKGxQYXJhbSksIEhJV09SRChsUGFyYW0pIH07CiAKICAgICBzd2l0Y2god1BhcmFtKSAgLyogSGl0IHRlc3QgKi8KICAgICB7CkBAIC0xMTg1LDcgKzExODgsNyBAQAogCWJyZWFrOwogCiAgICAgY2FzZSBIVFNZU01FTlU6Ci0JTkNfVHJhY2tTeXNNZW51KCBod25kLCBoZGMsIE1BS0VQT0lOVChsUGFyYW0pICk7CisJTkNfVHJhY2tTeXNNZW51KCBod25kLCBoZGMsIHB0ICk7CiAJYnJlYWs7CiAKICAgICBjYXNlIEhUTUVOVToKQEAgLTEyNDUsOCArMTI0OCwxMSBAQAogICAgIHN3aXRjaCh3UGFyYW0pICAvKiBIaXQgdGVzdCAqLwogICAgIHsKICAgICBjYXNlIEhUQ0FQVElPTjoKLSAgICAgICAgU2VuZE1lc3NhZ2UoIGh3bmQsIFdNX1NZU0NPTU1BTkQsCi0gICAgICAgICAgICAgICAgICAgICBJc1pvb21lZChod25kKSA/IFNDX1JFU1RPUkUgOiBTQ19NQVhJTUlaRSwgbFBhcmFtICk7CisgICAgICAgIC8qIHN0b3AgcHJvY2Vzc2luZyBpZiBXU19NQVhJTUlaRUJPWCBpcyBtaXNzaW5nICovCisKKyAgICAgICAgaWYoIEdldFdpbmRvd0xvbmcoIGh3bmQgLCBHV0xfU1RZTEUpICYgV1NfTUFYSU1JWkVCT1ggKQorICAgICAgICAgICAgU2VuZE1lc3NhZ2UoIGh3bmQsIFdNX1NZU0NPTU1BTkQsCisgICAgICAgICAgICAgICAgICAgICAgICAgSXNab29tZWQoaHduZCkgPyBTQ19SRVNUT1JFIDogU0NfTUFYSU1JWkUsIGxQYXJhbSApOwogCWJyZWFrOwogCiAgICAgY2FzZSBIVFNZU01FTlU6CkBAIC0xMjY2LDggKzEyNzIsOCBAQAogewogICAgIFdORCAqd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKIAotICAgIGRwcmludGZfbm9uY2xpZW50KHN0ZGRlYiwgIkhhbmRsaW5nIFdNX1NZU0NPTU1BTkQgJWx4ICVkLCVkXG4iLCAKLQkJICAgICAgKERXT1JEKXdQYXJhbSwgcHQueCwgcHQueSApOworICAgIGRwcmludGZfbm9uY2xpZW50KHN0ZGRlYiwgIkhhbmRsaW5nIFdNX1NZU0NPTU1BTkQgJWx4ICVsZCwlbGRcbiIsIAorCQkgICAgICAoRFdPUkQpd1BhcmFtLCAoTE9ORylwdC54LCAoTE9ORylwdC55ICk7CiAKICAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfQ0hJTEQpIFNjcmVlblRvQ2xpZW50KCB3bmRQdHItPmh3bmRQYXJlbnQsICZwdCApOwogCmRpZmYgLS1naXQgYS93aW5kb3dzL3BhaW50aW5nLmMgYi93aW5kb3dzL3BhaW50aW5nLmMKaW5kZXggN2UxNjYzMi4uMDE0NDI2ZCAxMDA2NDQKLS0tIGEvd2luZG93cy9wYWludGluZy5jCisrKyBiL3dpbmRvd3MvcGFpbnRpbmcuYwpAQCAtMTQwLDkgKzE0MCw5IEBACiAKICAgICBpZiAocmVjdFVwZGF0ZSkKICAgICB7Ci0gICAgICAgIGRwcmludGZfd2luKCBzdGRkZWIsICJSZWRyYXdXaW5kb3c6ICJOUEZNVCIgJWQsJWQtJWQsJWQgIk5QRk1UIiBmbGFncz0lMDR4XG4iLAotICAgICAgICAgICAgICAgICAgICAgaHduZCwgcmVjdFVwZGF0ZS0+bGVmdCwgcmVjdFVwZGF0ZS0+dG9wLAotICAgICAgICAgICAgICAgICAgICAgcmVjdFVwZGF0ZS0+cmlnaHQsIHJlY3RVcGRhdGUtPmJvdHRvbSwgaHJnblVwZGF0ZSwgZmxhZ3MpOworICAgICAgICBkcHJpbnRmX3dpbiggc3RkZGViLCAiUmVkcmF3V2luZG93OiAiTlBGTVQiICVsZCwlbGQtJWxkLCVsZCAiTlBGTVQiIGZsYWdzPSUwNHhcbiIsCisgICAgICAgICAgICAgICAgICAgICBod25kLCAoTE9ORylyZWN0VXBkYXRlLT5sZWZ0LCAoTE9ORylyZWN0VXBkYXRlLT50b3AsCisgICAgICAgICAgICAgICAgICAgICAoTE9ORylyZWN0VXBkYXRlLT5yaWdodCwgKExPTkcpcmVjdFVwZGF0ZS0+Ym90dG9tLCBocmduVXBkYXRlLCBmbGFncyk7CiAgICAgfQogICAgIGVsc2UKICAgICB7CmRpZmYgLS1naXQgYS93aW5kb3dzL3Njcm9sbC5jIGIvd2luZG93cy9zY3JvbGwuYwppbmRleCBkNjYyOTgzLi5iMjRmY2JmIDEwMDY0NAotLS0gYS93aW5kb3dzL3Njcm9sbC5jCisrKyBiL3dpbmRvd3Mvc2Nyb2xsLmMKQEAgLTI3LDggKzI3LDggQEAKICAgICBIUkdOIGhyZ25VcGRhdGU7CiAgICAgUkVDVCByYywgY2xpcHJjOwogCi0gICAgZHByaW50Zl9zY3JvbGwoc3RkZGViLCJTY3JvbGxXaW5kb3c6IGR4PSVkLCBkeT0lZCwgcmVjdD0lZCwlZCwlZCwlZFxuIiwgCi0JICAgZHgsIGR5LCByZWN0LT5sZWZ0LCByZWN0LT50b3AsIHJlY3QtPnJpZ2h0LCByZWN0LT5ib3R0b20pOworICAgIGRwcmludGZfc2Nyb2xsKHN0ZGRlYiwiU2Nyb2xsV2luZG93OiBkeD0lZCwgZHk9JWQsIHJlY3Q9JWxkLCVsZCwlbGQsJWxkXG4iLCAKKwkgICBkeCwgZHksIChMT05HKXJlY3QtPmxlZnQsIChMT05HKXJlY3QtPnRvcCwgKExPTkcpcmVjdC0+cmlnaHQsIChMT05HKXJlY3QtPmJvdHRvbSk7CiAKICAgICBoZGMgPSBHZXREQyhod25kKTsKIApAQCAtNjAsOCArNjAsOCBAQAogICAgIHNob3J0IHdpZHRoLCBoZWlnaHQ7CiAgICAgREMgKmRjID0gKERDICopR0RJX0dldE9ialB0cihoZGMsIERDX01BR0lDKTsKIAotICAgIGRwcmludGZfc2Nyb2xsKHN0ZGRlYiwgIlNjcm9sbERDOiBkeD0lZCwgZHk9JWQsIHJjPSVkLCVkLCVkLCVkXG4iLCBkeCwgZHksCi0JICAgcmMtPmxlZnQsIHJjLT50b3AsIHJjLT5yaWdodCwgcmMtPmJvdHRvbSk7CisgICAgZHByaW50Zl9zY3JvbGwoc3RkZGViLCAiU2Nyb2xsREM6IGR4PSVkLCBkeT0lZCwgcmM9JWxkLCVsZCwlbGQsJWxkXG4iLCBkeCwgZHksCisJICAgKExPTkcpcmMtPmxlZnQsIChMT05HKXJjLT50b3AsIChMT05HKXJjLT5yaWdodCwgKExPTkcpcmMtPmJvdHRvbSk7CiAKICAgICBpZiAocmMgPT0gTlVMTCkKIAlyZXR1cm4gRkFMU0U7CkBAIC0xMzYsOCArMTM2LDkgQEAKICAgICBIREMgaGRjOwogICAgIFJFQ1QgcmMsIGNsaXByYzsKIAotICAgIGRwcmludGZfc2Nyb2xsKHN0ZGRlYiwiU2Nyb2xsV2luZG93RXg6IGR4PSVkLCBkeT0lZCwgcmVjdD0lZCwlZCwlZCwlZFxuIiwgCi0JICAgZHgsIGR5LCByZWN0LT5sZWZ0LCByZWN0LT50b3AsIHJlY3QtPnJpZ2h0LCByZWN0LT5ib3R0b20pOworICAgIGRwcmludGZfc2Nyb2xsKHN0ZGRlYiwiU2Nyb2xsV2luZG93RXg6IGR4PSVkLCBkeT0lZCwgcmVjdD0lbGQsJWxkLCVsZCwlbGRcbiIsIAorCSAgIGR4LCBkeSwgKExPTkcpcmVjdC0+bGVmdCwgKExPTkcpcmVjdC0+dG9wLCAoTE9ORylyZWN0LT5yaWdodCwKKyAgICAgICAgICAgKExPTkcpcmVjdC0+Ym90dG9tKTsKIAogICAgIGhkYyA9IEdldERDKGh3bmQpOwogCmRpZmYgLS1naXQgYS93aW5kb3dzL3N5c21ldHJpY3MuYyBiL3dpbmRvd3Mvc3lzbWV0cmljcy5jCmluZGV4IDNhYTliYjMuLjY0YjgwZGMgMTAwNjQ0Ci0tLSBhL3dpbmRvd3Mvc3lzbWV0cmljcy5jCisrKyBiL3dpbmRvd3Mvc3lzbWV0cmljcy5jCkBAIC0xMCw3ICsxMCw3IEBACiAjaW5jbHVkZSAiZ2RpLmgiCiAjaW5jbHVkZSAic3lzbWV0cmljcy5oIgogCi1zaG9ydCBzeXNNZXRyaWNzW1NNX0NNRVRSSUNTXTsKK3Nob3J0IHN5c01ldHJpY3NbU01fQ01FVFJJQ1MrMV07CiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICogICAgICAgICAgIFNZU01FVFJJQ1NfSW5pdApAQCAtNjIsNiArNjIsNyBAQAogICAgIHN5c01ldHJpY3NbU01fTUVOVURST1BBTElHTk1FTlRdID0gR2V0UHJvZmlsZUludCggIndpbmRvd3MiLCJNZW51RHJvcEFsaWdubWVudCIsIDAgKTsKICAgICBzeXNNZXRyaWNzW1NNX1BFTldJTkRPV1NdID0gMDsKICAgICBzeXNNZXRyaWNzW1NNX0RCQ1NFTkFCTEVEXSA9IDA7CisgICAgc3lzTWV0cmljc1tTTV9DTUVUUklDU10gPSBTTV9DTUVUUklDUzsKIH0KIAogCkBAIC03MCw2ICs3MSw2IEBACiAgKi8KIGludCBHZXRTeXN0ZW1NZXRyaWNzKCBXT1JEIGluZGV4ICkKIHsKLSAgICBpZiAoaW5kZXggPj0gU01fQ01FVFJJQ1MpIHJldHVybiAwOworICAgIGlmIChpbmRleCA+IFNNX0NNRVRSSUNTKSByZXR1cm4gMDsKICAgICBlbHNlIHJldHVybiBzeXNNZXRyaWNzW2luZGV4XTsgICAgCiB9CmRpZmYgLS1naXQgYS93aW5kb3dzL3dpbi5jIGIvd2luZG93cy93aW4uYwppbmRleCAxNjRiNTYzLi4xZTBkMjA5IDEwMDY0NAotLS0gYS93aW5kb3dzL3dpbi5jCisrKyBiL3dpbmRvd3Mvd2luLmMKQEAgLTIwOSw3ICsyMDksNyBAQAogICAgIH0KICAgICBpZiAoISh3bmRQdHItPmR3U3R5bGUgJiBXU19DSElMRCkpCiAgICAgewotICAgICAgICBpZiAod25kUHRyLT53SURtZW51KSBEZXN0cm95TWVudSggd25kUHRyLT53SURtZW51ICk7CisgICAgICAgIGlmICh3bmRQdHItPndJRG1lbnUpIERlc3Ryb3lNZW51KCAoSE1FTlUpd25kUHRyLT53SURtZW51ICk7CiAgICAgfQogICAgIGlmICh3bmRQdHItPmhTeXNNZW51KSBEZXN0cm95TWVudSggd25kUHRyLT5oU3lzTWVudSApOwogICAgIGlmICh3bmRQdHItPndpbmRvdykgWERlc3Ryb3lXaW5kb3coIGRpc3BsYXksIHduZFB0ci0+d2luZG93ICk7CkBAIC0yODUsNyArMjg1LDcgQEAKICAqICAgICAgICAgICBDcmVhdGVXaW5kb3cgICAoVVNFUi40MSkKICAqLwogSFdORCBDcmVhdGVXaW5kb3coIFNFR1BUUiBjbGFzc05hbWUsIFNFR1BUUiB3aW5kb3dOYW1lLAotCQkgICBEV09SRCBzdHlsZSwgc2hvcnQgeCwgc2hvcnQgeSwgc2hvcnQgd2lkdGgsIHNob3J0IGhlaWdodCwKKwkJICAgRFdPUkQgc3R5bGUsIElOVCB4LCBJTlQgeSwgSU5UIHdpZHRoLCBJTlQgaGVpZ2h0LAogCQkgICBIV05EIHBhcmVudCwgSE1FTlUgbWVudSwgSEFORExFIGluc3RhbmNlLCBTRUdQVFIgZGF0YSApIAogewogICAgIHJldHVybiBDcmVhdGVXaW5kb3dFeCggMCwgY2xhc3NOYW1lLCB3aW5kb3dOYW1lLCBzdHlsZSwKQEAgLTI5Nyw3ICsyOTcsNyBAQAogICogICAgICAgICAgIENyZWF0ZVdpbmRvd0V4ICAgKFVTRVIuNDUyKQogICovCiBIV05EIENyZWF0ZVdpbmRvd0V4KCBEV09SRCBleFN0eWxlLCBTRUdQVFIgY2xhc3NOYW1lLCBTRUdQVFIgd2luZG93TmFtZSwKLQkJICAgICBEV09SRCBzdHlsZSwgc2hvcnQgeCwgc2hvcnQgeSwgc2hvcnQgd2lkdGgsIHNob3J0IGhlaWdodCwKKwkJICAgICBEV09SRCBzdHlsZSwgSU5UIHgsIElOVCB5LCBJTlQgd2lkdGgsIElOVCBoZWlnaHQsCiAJCSAgICAgSFdORCBwYXJlbnQsIEhNRU5VIG1lbnUsIEhBTkRMRSBpbnN0YW5jZSwgU0VHUFRSIGRhdGEgKSAKIHsKICAgICBIQU5ETEUgY2xhc3MsIGh3bmQ7CkBAIC00NjUsNyArNDY1LDcgQEAKICAgICAgICAgZWxzZSBpZiAoY2xhc3NQdHItPndjLmxwc3pNZW51TmFtZSkKICAgICAgICAgICAgIFNldE1lbnUoIGh3bmQsIExvYWRNZW51KCBpbnN0YW5jZSwgY2xhc3NQdHItPndjLmxwc3pNZW51TmFtZSApICk7CiAgICAgfQotICAgIGVsc2Ugd25kUHRyLT53SURtZW51ID0gbWVudTsKKyAgICBlbHNlIHduZFB0ci0+d0lEbWVudSA9IChVSU5UKW1lbnU7CiAKICAgICAgIC8qIFNlbmQgdGhlIFdNX0NSRUFURSBtZXNzYWdlICovCiAKQEAgLTc0NCwxMiArNzQ0LDEzIEBACiAgICAgaWYgKG9mZnNldCA+PSAwKSBwdHIgPSAoV09SRCAqKSgoKGNoYXIgKil3bmRQdHItPndFeHRyYSkgKyBvZmZzZXQpOwogICAgIGVsc2Ugc3dpdGNoKG9mZnNldCkKICAgICB7Ci0JY2FzZSBHV1dfSUQ6ICAgICAgICBwdHIgPSAmd25kUHRyLT53SURtZW51OyAgIGJyZWFrOwogI2lmZGVmIFdJTkVMSUIzMgorCWNhc2UgR1dXX0lEOgogCWNhc2UgR1dXX0hJTlNUQU5DRToKICAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCJTZXRXaW5kb3dXb3JkIGNhbGxlZCB3aXRoIG9mZnNldCAlZC5cbiIsb2Zmc2V0KTsKICAgICAgICAgICAgIHJldHVybiAwOwogI2Vsc2UKKwljYXNlIEdXV19JRDogICAgICAgIHB0ciA9ICZ3bmRQdHItPndJRG1lbnU7ICAgYnJlYWs7CiAJY2FzZSBHV1dfSElOU1RBTkNFOiBwdHIgPSAoV09SRCopJnduZFB0ci0+aEluc3RhbmNlOyBicmVhazsKICNlbmRpZgogCWRlZmF1bHQ6IHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvd2luZG93cy93aW5wb3MuYyBiL3dpbmRvd3Mvd2lucG9zLmMKaW5kZXggMzJjYTIxYzYuLjExOWIyNjUgMTAwNjQ0Ci0tLSBhL3dpbmRvd3Mvd2lucG9zLmMKKysrIGIvd2luZG93cy93aW5wb3MuYwpAQCAtNjE5LDggKzYxOSw4IEBACiAJKHduZFB0ci0+ZHdTdHlsZSAmIChXU19QT1BVUCB8IFdTX0NISUxEKSA9PSAwKSkKICAgICB7CiAJTkNfR2V0TWluTWF4SW5mbyggd2lucG9zLT5od25kLCAmbWF4U2l6ZSwgTlVMTCwgTlVMTCwgTlVMTCApOwotCXdpbnBvcy0+Y3ggPSBtaW4oIHdpbnBvcy0+Y3gsIG1heFNpemUueCApOwotCXdpbnBvcy0+Y3kgPSBtaW4oIHdpbnBvcy0+Y3ksIG1heFNpemUueSApOworCXdpbnBvcy0+Y3ggPSBNSU4oIHdpbnBvcy0+Y3gsIG1heFNpemUueCApOworCXdpbnBvcy0+Y3kgPSBNSU4oIHdpbnBvcy0+Y3ksIG1heFNpemUueSApOwogICAgIH0KICAgICByZXR1cm4gMDsKIH0KQEAgLTcwMiw3ICs3MDIsNyBAQAogCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICogICAgICAgICAgIFdJTlBPU19TZXRYV2luZG9zUG9zCisgKiAgICAgICAgICAgV0lOUE9TX1NldFhXaW5kb3dQb3MKICAqCiAgKiBTZXRXaW5kb3dQb3MoKSBmb3IgYW4gWCB3aW5kb3cuIFVzZWQgYnkgdGhlIHJlYWwgU2V0V2luZG93UG9zKCkuCiAgKi8K