ZGlmZiAtLWdpdCBhL2hvc3RhcGQvQ2hhbmdlTG9nIGIvaG9zdGFwZC9DaGFuZ2VMb2cKaW5kZXggNDdmMjQyMy4uOWZjMDVmNyAxMDA2NDQKLS0tIGEvaG9zdGFwZC9DaGFuZ2VMb2cKKysrIGIvaG9zdGFwZC9DaGFuZ2VMb2cKQEAgLTEsNSArMSwxMTIgQEAKIENoYW5nZUxvZyBmb3IgaG9zdGFwZAogCisyMDEyLTA1LTEwIC0gdjEuMAorCSogQWRkIGNoYW5uZWwgc2VsZWN0aW9uIHN1cHBvcnQgaW4gaG9zdGFwZC4gU2VlIGhvc3RhcGQuY29uZi4KKwkqIEFkZCBzdXBwb3J0IGZvciBJRUVFIDgwMi4xMXYgVGltZSBBZHZlcnRpc2VtZW50IG1lY2hhbmlzbSB3aXRoIFVUQworCSAgVFNGIG9mZnNldC4gU2VlIGhvc3RhcGQuY29uZiBmb3IgY29uZmlnIGluZm8uCisJKiBEZWxheSBTVEEgZW50cnkgcmVtb3ZhbCB1bnRpbCBEZWF1dGgvRGlzYXNzb2MgVFggc3RhdHVzIGluIEFQIG1vZGUuCisJICBUaGlzIGFsbG93cyB0aGUgZHJpdmVyIHRvIHVzZSBQUyBidWZmZXJpbmcgb2YgRGVhdXRoZW50aWNhdGlvbiBhbmQKKwkgIERpc2Fzc29jaWF0aW9uIGZyYW1lcyB3aGVuIHRoZSBTVEEgaXMgaW4gcG93ZXIgc2F2ZSBzbGVlcC4gT25seQorCSAgYXZhaWxhYmxlIHdpdGggZHJpdmVycyB0aGF0IHByb3ZpZGUgVFggc3RhdHVzIGV2ZW50cyBmb3IgRGVhdXRoLworCSAgRGlzYXNzb2MgZnJhbWVzIChubDgwMjExKS4KKwkqIEFsbG93IFBNS1NBIGNhY2hpbmcgdG8gYmUgZGlzYWJsZWQgb24gdGhlIEF1dGhlbnRpY2F0b3IuIFNlZQorCSAgaG9zdGFwLmNvbmYgY29uZmlnIHBhcmFtZXRlciBkaXNhYmxlX3Bta3NhX2NhY2hpbmcuCisJKiBhdGhlcm9zOiBBZGQgc3VwcG9ydCBmb3IgSUVFRSA4MDIuMTF3IGNvbmZpZ3VyYXRpb24uCisJKiBic2Q6IEFkZCBzdXBwb3J0IGZvciBzZXR0aW5nIEhUIHZhbHVlcyBpbiBJRk1fTU1BU0suCisJKiBBbGxvdyBjbGllbnQgaXNvbGF0aW9uIHRvIGJlIGNvbmZpZ3VyZWQgd2l0aCBhcF9pc29sYXRlLiBDbGllbnQKKwkgIGlzb2xhdGlvbiBjYW4gYmUgdXNlZCB0byBwcmV2ZW50IGxvdy1sZXZlbCBicmlkZ2luZyBvZiBmcmFtZXMKKwkgIGJldHdlZW4gYXNzb2NpYXRlZCBzdGF0aW9ucyBpbiB0aGUgQlNTLiBCeSBkZWZhdWx0LCB0aGlzIGJyaWRnaW5nCisJICBpcyBhbGxvd2VkLgorCSogQWxsb3cgY29leGlzdGFuY2Ugb2YgSFQgQlNTZXMgd2l0aCBXRVAvVEtJUCBCU1Nlcy4KKwkqIEFkZCByZXF1aXJlX2h0IGNvbmZpZyBwYXJhbWV0ZXIsIHdoaWNoIGNhbiBiZSB1c2VkIHRvIGNvbmZpZ3VyZQorCSAgaG9zdGFwZCB0byByZWplY3QgYXNzb2NpYXRpb24gd2l0aCBhbnkgc3RhdGlvbiB0aGF0IGRvZXMgbm90IHN1cHBvcnQKKwkgIEhUIFBIWS4KKwkqIEFkZCBzdXBwb3J0IGZvciB3cml0aW5nIGRlYnVnIGxvZyB0byBhIGZpbGUgdXNpbmcgIi1mIiBvcHRpb24uIEFsc28KKwkgIGFkZCByZWxvZyBDTEkgY29tbWFuZCB0byByZS1vcGVuIHRoZSBsb2cgZmlsZS4KKwkqIEFkZCBicmlkZ2UgaGFuZGxpbmcgZm9yIFdEUyBTVEEgaW50ZXJmYWNlcy4gQnkgZGVmYXVsdCB0aGV5IGFyZQorCSAgYWRkZWQgdG8gdGhlIGNvbmZpZ3VyZWQgYnJpZGdlIG9mIHRoZSBBUCBpbnRlcmZhY2UgKGlmIHByZXNlbnQpLAorCSAgYnV0IHRoZSB1c2VyIGNhbiBhbHNvIHNwZWNpZnkgYSBzZXBhcmF0ZSBicmlkZ2UgdXNpbmcgY2xpIGNvbW1hbmQKKwkgIHdkc19icmlkZ2UuCisJKiBob3N0YXBkX2NsaToKKwkgIC0gQWRkIHdkc19icmlkZ2UgY29tbWFuZCBmb3Igc3BlY2lmeWluZyBicmlkZ2UgZm9yIFdEUyBTVEEKKwkgICAgaW50ZXJmYWNlcy4KKwkgIC0gQWRkIHJlbG9nIGNvbW1hbmQgZm9yIHJlb3BlbmluZyBsb2cgZmlsZS4KKwkgIC0gU2VuZCBBUC1TVEEtRElTQ09OTkVDVEVEIGV2ZW50IHdoZW4gYW4gQVAgZGlzY29ubmVjdHMgYSBzdGF0aW9uCisJICAgIGR1ZSB0byBpbmFjdGl2aXR5LgorCSAgLSBBZGQgd3BzX2NvbmZpZyBjdHJsX2ludGVyZmFjZSBjb21tYW5kIGZvciBjb25maWd1cmluZyBBUC4gVGhpcworCSAgICBjb21tYW5kIGNhbiBiZSB1c2VkIHRvIGNvbmZpZ3VyZSB0aGUgQVAgdXNpbmcgdGhlIGludGVybmFsIFdQUworCSAgICByZWdpc3RyYXIuIEl0IHdvcmtzIGluIHRoZSBzYW1lIHdheSBhcyBuZXcgQVAgc2V0dGluZ3MgcmVjZWl2ZWQKKwkgICAgZnJvbSBhbiBFUi4KKwkgIC0gTWFueSBXUFMvV1BTIEVSIGNvbW1hbmRzIC0gc2VlIFdQUy9XUFMgRVIgc2VjdGlvbnMgZm9yIGRldGFpbHMuCisJICAtIEFkZCBjb21tYW5kIGdldCB2ZXJzaW9uLCB0aGF0IHJldHVybnMgaG9zdGFwZCB2ZXJzaW9uIHN0cmluZy4KKwkqIFdOTTogQWRkIEJTUyBUcmFuc2l0aW9uIE1hbmFnZW1lbnQgUmVxdWVzdCBmb3IgRVNTIERpc2Fzc29jIEltbWluZW50LgorCSAgVXNlIGhvc3RhcGRfY2xpIGVzc19kaXNhc3NvYyAoU1RBIGFkZHIpIChVUkwpIHRvIHNlbmQgdGhlCisJICBub3RpZmljYXRpb24gdG8gdGhlIFNUQS4KKwkqIEFsbG93IEFQIG1vZGUgdG8gZGlzY29ubmVjdCBTVEFzIGJhc2VkIG9uIGxvdyBBQ0sgY29uZGl0aW9uICh3aGVuCisJICB0aGUgZGF0YSBjb25uZWN0aW9uIGlzIG5vdCB3b3JraW5nIHByb3Blcmx5LCBlLmcuLCBkdWUgdG8gdGhlIFNUQQorCSAgZ29pbmcgb3V0c2lkZSB0aGUgcmFuZ2Ugb2YgdGhlIEFQKS4gRGlzYWJsZWQgYnkgZGVmYXVsdCwgZW5hYmxlIGJ5CisJICBjb25maWcgb3B0aW9uIGRpc2Fzc29jX2xvd19hY2suCisJKiBBZGQgV1BBX0lHTk9SRV9DT05GSUdfRVJST1JTIGJ1aWxkIG9wdGlvbiB0byBjb250aW51ZSBpbiBjYXNlIG9mIGJhZAorCSAgY29uZmlnIGZpbGUuCisJKiBXUFM6CisJICAtIFNlbmQgQVAgU2V0dGluZ3MgYXMgYSB3cmFwcGVkIENyZWRlbnRpYWwgYXR0cmlidXRlIHRvIGN0cmxfaWZhY2UKKwkgICAgaW4gV1BTLU5FVy1BUC1TRVRUSU5HUy4KKwkgIC0gRGlzcGF0Y2ggbW9yZSBXUFMgZXZlbnRzIHRocm91Z2ggaG9zdGFwZCBjdHJsX2lmYWNlLgorCSAgLSBBZGQgbWVjaGFuaXNtIGZvciBpbmRpY2F0aW5nIG5vbi1zdGFuZGFyZCBXUFMgZXJyb3JzLgorCSAgLSBDaGFuZ2UgY29uY3VycmVudCByYWRpbyBBUCB0byB1c2Ugb25seSBvbmUgV1BTIFVQblAgaW5zdGFuY2UuCisJICAtIEFkZCB3cHNfY2hlY2tfcGluIGNvbW1hbmQgZm9yIHByb2Nlc3NpbmcgUElOIGZyb20gdXNlciBpbnB1dC4KKwkgICAgVUlzIGNhbiB1c2UgdGhpcyBjb21tYW5kIHRvIHByb2Nlc3MgYSBQSU4gZW50ZXJlZCBieSBhIHVzZXIgYW5kIHRvCisJICAgIHZhbGlkYXRlIHRoZSBjaGVja3N1bSBkaWdpdCAoaWYgcHJlc2VudCkuCisJICAtIEFkZCBob3N0YXBfY2xpIGdldF9jb25maWcgY29tbWFuZCB0byBkaXNwbGF5IGN1cnJlbnQgQVAgY29uZmlnLgorCSAgLSBBZGQgbmV3IGhvc3RhcGRfY2xpIGNvbW1hbmQsIHdwc19hcF9waW4sIHRvIG1hbmFnZSBBUCBQSU4gYXQKKwkgICAgcnVudGltZSBhbmQgc3VwcG9ydCBkeW5hbWljIEFQIFBJTiBtYW5hZ2VtZW50LgorCSAgLSBEaXNhYmxlIEFQIFBJTiBhZnRlciAxMCBjb25zZWN1dGl2ZSBmYWlsdXJlcy4gU2xvdyBkb3duIGF0dGFja3MKKwkgICAgb24gZmFpbHVyZXMgdXAgdG8gMTAuCisJICAtIEFsbG93IEFQIHRvIHN0YXJ0IGluIEVucm9sbGVlIG1vZGUgd2l0aG91dCBBUCBQSU4gZm9yIHByb2JpbmcsCisJICAgIHRvIGJlIGNvbXBhdGlibGUgd2l0aCBXaW5kb3dzIDcuCisJICAtIEFkZCBDb25maWcgRXJyb3IgaW50byBXUFMtRkFJTCBldmVudHMgdG8gcHJvdmlkZSBtb3JlIGluZm8KKwkgICAgdG8gdGhlIHVzZXIgb24gaG93IHRvIHJlc29sdmUgdGhlIGlzc3VlLgorCSAgLSBXaGVuIGNvbnRyb2xsaW5nIG11bHRpcGxlIGludGVyZmFjZXM6CisJICAgICAtIGFwcGx5IFdQUyBjb21tYW5kcyB0byBhbGwgaW50ZXJmYWNlcyBjb25maWd1cmVkIHRvIHVzZSBXUFMKKwkgICAgIC0gYXBwbHkgV1BTIGNvbmZpZyBjaGFuZ2VzIHRvIGFsbCBpbnRlcmZhY2VzIHRoYXQgdXNlIFdQUworCSAgICAgLSB3aGVuIGFuIGF0dGFjayBpcyBkZXRlY3RlZCBvbiBhbnkgaW50ZXJmYWNlLCBkaXNhYmxlIEFQIFBJTiBvbgorCSAgICAgICBhbGwgaW50ZXJmYWNlcworCSogV1BTIEVSOgorCSAgLSBTaG93IFNldFNlbGVjdGVkUmVnaXN0cmFyIGV2ZW50cyBhcyBjdHJsX2lmYWNlIGV2ZW50cy4KKwkgIC0gQWRkIHNwZWNpYWwgQVAgU2V0dXAgTG9ja2VkIG1vZGUgdG8gYWxsb3cgcmVhZCBvbmx5IEVSLgorCSAgICBhcF9zZXR1cF9sb2NrZWQ9MiBjYW4gbm93IGJlIHVzZWQgdG8gZW5hYmxlIGEgc3BlY2lhbCBtb2RlIHdoZXJlCisJICAgIFdQUyBFUiBjYW4gbGVhcm4gdGhlIGN1cnJlbnQgQVAgc2V0dGluZ3MsIGJ1dCBjYW5ub3QgY2hhbmdlIHRoZW0uCisJKiBXUFMgMi4wOiBBZGQgc3VwcG9ydCBmb3IgV1BTIDIuMCAoQ09ORklHX1dQUzIpCisJICAtIEFkZCBidWlsZCBvcHRpb24gQ09ORklHX1dQU19FWFRFTlNJQklMSVRZX1RFU1RJTkcgdG8gZW5hYmxlIHRvb2wKKwkgICAgZm9yIHRlc3RpbmcgcHJvdG9jb2wgZXh0ZW5zaWJpbGl0eS4KKwkgIC0gQWRkIGJ1aWxkIG9wdGlvbiBDT05GSUdfV1BTX1NUUklDVCB0byBhbGxvdyBkaXNhYmxpbmcgb2YgV1BTCisJICAgIHdvcmthcm91bmRzLgorCSAgLSBBZGQgc3VwcG9ydCBmb3IgQXV0aG9yaXplZE1BQ3MgYXR0cmlidXRlLgorCSogVERMUzoKKwkgIC0gQWxsb3cgVERMUyB1c2Ugb3IgVERMUyBjaGFubmVsIHN3aXRjaGluZyBpbiB0aGUgQlNTIHRvIGJlCisJICAgIHByb2hpYml0ZWQgaW4gdGhlIEJTUywgdXNpbmcgY29uZmlnIHBhcmFtcyB0ZGxzX3Byb2hpYml0IGFuZAorCSAgICB0ZGxzX3Byb2hpYml0X2NoYW5fc3dpdGNoLgorCSogRUFQIHNlcnZlcjogQWRkIHN1cHBvcnQgZm9yIGNvbmZpZ3VyaW5nIGZyYWdtZW50IHNpemUgKHNlZQorCSAgZnJhZ21lbnRfc2l6ZSBpbiBob3N0YXBkLmNvbmYpLgorCSogd2xhbnRlc3Q6IEFkZCBhIHRvb2wgd2xhbnRlc3QgZm9yIElFRUU4MDIuMTEgcHJvdG9jb2wgdGVzdGluZy4KKwkgIHdsYW50ZXN0IGNhbiBiZSB1c2VkIHRvIGNhcHR1cmUgZnJhbWVzIGZyb20gYSBtb25pdG9yIGludGVyZmFjZQorCSAgZm9yIHJlYWx0aW1lIGNhcHR1cmluZyBvciBmcm9tIHBjYXAgZmlsZXMgZm9yIG9mZmxpbmUgYW5hbHlzaXMuCisJKiBJbnRlcndvcmtpbmc6IFN1cHBvcnQgYWRkZWQgZm9yIDgwMi4xMXUuIEVuYWJsZSBpbiAuY29uZmlnIHdpdGgKKwkgIENPTkZJR19JTlRFUldPUktJTkcuIFNlZSBob3N0YXBkLmNvbmYgZm9yIGNvbmZpZyBwYXJhbWV0ZXJzIGZvcgorCSAgaW50ZXJ3b3JraW5nLgorCSogQW5kcm9pZDogQWRkIGJ1aWxkIGFuZCBydW50aW1lIHN1cHBvcnQgZm9yIEFuZHJvaWQgaG9zdGFwZC4KKwkqIEFkZCBhIG5ldyBkZWJ1ZyBtZXNzYWdlIGxldmVsIGZvciBleGNlc3NpdmUgaW5mb3JtYXRpb24uIFVzZQorCSAgLWRkZCB0byBlbmFibGUuCisJKiBUTFM6IEFkZCBzdXBwb3J0IGZvciB0bHNfZGlzYWJsZV90aW1lX2NoZWNrcz0xIGluIGNsaWVudCBtb2RlLgorCSogSW50ZXJuYWwgVExTOgorCSAgLSBBZGQgc3VwcG9ydCBmb3IgVExTIHYxLjEgKFJGQyA0MzQ2KS4gRW5hYmxlIHdpdGggYnVpbGQgcGFyYW1ldGVyCisJICAgIENPTkZJR19UTFNWMTEuCisJICAtIEFkZCBkb21haW5Db21wb25lbnQgcGFyc2VyIGZvciBYLjUwOSBuYW1lcworCSogUmVvcmRlciBzb21lIElFcyB0byBnZXQgY2xvc2VyIHRvIElFRUUgODAyLjExIHN0YW5kYXJkLiBNb3ZlCisJICBXTU0gaW50byBlbmQgb2YgQmVhY29uLCBQcm9iZSBSZXNwIGFuZCAoUmUpQXNzb2MgUmVzcCBmcmFtZXMuCisJICBNb3ZlIEhUIElFcyB0byBiZSBsYXRlciBpbiAoUmUpQXNzb2MgUmVzcC4KKwkqIE1hbnkgYnVnZml4ZXMuCisKIDIwMTAtMDQtMTggLSB2MC43LjIKIAkqIGZpeCBXUFMgaW50ZXJuYWwgUmVnaXN0cmFyIHVzZSB3aGVuIGFuIGV4dGVybmFsIFJlZ2lzdHJhciBpcyBhbHNvCiAJICBhY3RpdmUKZGlmZiAtLWdpdCBhL2hvc3RhcGQvTWFrZWZpbGUgYi9ob3N0YXBkL01ha2VmaWxlCmluZGV4IDIyYzA5YzEuLmI0M2FhNzUgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvTWFrZWZpbGUKKysrIGIvaG9zdGFwZC9NYWtlZmlsZQpAQCAtMTEwLDYgKzExMCw3IEBACiBlbHNlCiBPQkpTICs9IC4uL3NyYy9yYWRpdXMvcmFkaXVzLm8KIE9CSlMgKz0gLi4vc3JjL3JhZGl1cy9yYWRpdXNfY2xpZW50Lm8KK09CSlMgKz0gLi4vc3JjL3JhZGl1cy9yYWRpdXNfZGFzLm8KIGVuZGlmCiAKIGlmZGVmIENPTkZJR19OT19BQ0NPVU5USU5HCkBAIC0xNjgsNiArMTY5LDE0IEBACiBDRkxBR1MgKz0gLURDT05GSUdfSUVFRTgwMjExTgogZW5kaWYKIAoraWZkZWYgQ09ORklHX1dOTQorQ0ZMQUdTICs9IC1EQ09ORklHX1dOTQorZW5kaWYKKworaWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCitDRkxBR1MgKz0gLURDT05GSUdfSUVFRTgwMjExQUMKK2VuZGlmCisKIGluY2x1ZGUgLi4vc3JjL2RyaXZlcnMvZHJpdmVycy5tYWsKIE9CSlMgKz0gJChEUlZfQVBfT0JKUykKIENGTEFHUyArPSAkKERSVl9BUF9DRkxBR1MpCkBAIC03NTIsNiArNzYxLDEwIEBACiBPQkpTICs9IC4uL3NyYy9hcC9pZWVlODAyXzExX2h0Lm8KIGVuZGlmCiAKK2lmZGVmIENPTkZJR19JRUVFODAyMTFBQworT0JKUyArPSAuLi9zcmMvYXAvaWVlZTgwMl8xMV92aHQubworZW5kaWYKKwogaWZkZWYgQ09ORklHX1AyUF9NQU5BR0VSCiBDRkxBR1MgKz0gLURDT05GSUdfUDJQX01BTkFHRVIKIE9CSlMgKz0gLi4vc3JjL2FwL3AycF9ob3N0YXBkLm8KQEAgLTc1OSw2ICs3NzIsOCBAQAogCiBpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCiBDRkxBR1MgKz0gLURDT05GSUdfSU5URVJXT1JLSU5HCitPQkpTICs9IC4uL3NyYy9jb21tb24vZ2FzLm8KK09CSlMgKz0gLi4vc3JjL2FwL2dhc19zZXJ2Lm8KIGVuZGlmCiAKIE9CSlMgKz0gLi4vc3JjL2RyaXZlcnMvZHJpdmVyX2NvbW1vbi5vCmRpZmYgLS1naXQgYS9ob3N0YXBkL1JFQURNRS1XUFMgYi9ob3N0YXBkL1JFQURNRS1XUFMKaW5kZXggMTc5ODhkNC4uODdhNmY5MSAxMDA2NDQKLS0tIGEvaG9zdGFwZC9SRUFETUUtV1BTCisrKyBiL2hvc3RhcGQvUkVBRE1FLVdQUwpAQCAtNjYsNiArNjYsMTAgQEAKIENPTkZJR19XUFMyPXkKIENPTkZJR19XUFNfVVBOUD15CiAKK0ZvbGxvd2luZyBwYXJhbWV0ZXIgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIHN1cHBvcnQgZm9yIE5GQyBjb25maWcgbWV0aG9kOgorCitDT05GSUdfV1BTX05GQz15CisKIAogRm9sbG93aW5nIHNlY3Rpb24gc2hvd3MgYW4gZXhhbXBsZSBydW50aW1lIGNvbmZpZ3VyYXRpb24KIChob3N0YXBkLmNvbmYpIHRoYXQgZW5hYmxlcyBXUFM6CkBAIC0yODksMyArMjkzLDQ4IEBACiAKIFRoaXMgY2FuIGJlIHVzZWQgdG8gdXBkYXRlIHRoZSBleHRlcm5hbGx5IHN0b3JlZCBBUCBjb25maWd1cmF0aW9uIGFuZAogdGhlbiB1cGRhdGUgaG9zdGFwZCBjb25maWd1cmF0aW9uIChmb2xsb3dlZCBieSByZXN0YXJ0aW5nIG9mIGhvc3RhcGQpLgorCisKK1dQUyB3aXRoIE5GQworLS0tLS0tLS0tLS0tCisKK1dQUyBjYW4gYmUgdXNlZCB3aXRoIE5GQy1iYXNlZCBjb25maWd1cmF0aW9uIG1ldGhvZC4gQW4gTkZDIHRhZworY29udGFpbmluZyBhIHBhc3N3b3JkIHRva2VuIGZyb20gdGhlIEVucm9sbGVlIGNhbiBiZSB1c2VkIHRvCithdXRoZW50aWNhdGUgdGhlIGNvbm5lY3Rpb24gaW5zdGVhZCBvZiB0aGUgUElOLiBJbiBhZGRpdGlvbiwgYW4gTkZDIHRhZword2l0aCBhIGNvbmZpZ3VyYXRpb24gdG9rZW4gY2FuIGJlIHVzZWQgdG8gdHJhbnNmZXIgQVAgc2V0dGluZ3Mgd2l0aG91dAorZ29pbmcgdGhyb3VnaCB0aGUgV1BTIHByb3RvY29sLgorCitXaGVuIHRoZSBBUCBhY3RzIGFzIGFuIEVucm9sbGVlLCBhIGxvY2FsIE5GQyB0YWcgd2l0aCBhIHBhc3N3b3JkIHRva2VuCitjYW4gYmUgdXNlZCBieSB0b3VjaGluZyB0aGUgTkZDIGludGVyZmFjZSBvZiBhbiBleHRlcm5hbCBSZWdpc3RyYXIuIFRoZQord3BzX25mY190b2tlbiBjb21tYW5kIGlzIHVzZWQgdG8gbWFuYWdlIHVzZSBvZiB0aGUgTkZDIHBhc3N3b3JkIHRva2VuCitmcm9tIHRoZSBBUC4gIndwc19uZmNfdG9rZW4gZW5hYmxlIiBlbmFibGVzIHRoZSB1c2Ugb2YgdGhlIEFQJ3MgTkZDCitwYXNzd29yZCB0b2tlbiAoaW4gcGxhY2Ugb2YgQVAgUElOKSBhbmQgIndwc19uZmNfdG9rZW4gZGlzYWJsZSIgZGlzYWJsZXMKK3RoZSBORkMgcGFzc3dvcmQgdG9rZW4uCisKK1RoZSBORkMgcGFzc3dvcmQgdG9rZW4gdGhhdCBpcyBlaXRoZXIgcHJlLWNvbmZpZ3VyZWQgaW4gdGhlCitjb25maWd1cmF0aW9uIGZpbGUgKHdwc19uZmNfZGV2X3B3X2lkLCB3cHNfbmZjX2RoX3B1YmtleSwKK3dwc19uZmNfZGhfcHJpdmtleSwgd3BzX25mY19kZXZfcHcpIG9yIGdlbmVyYXRlZCBkeW5hbWljYWxseSB3aXRoCisid3BzX25mY190b2tlbiA8V1BTfE5ERUY+IiBjb21tYW5kLiBUaGUgbmZjX3B3X3Rva2VuIHRvb2wgZnJvbQord3BhX3N1cHBsaWNhbnQgY2FuIGJlIHVzZWQgdG8gZ2VuZXJhdGUgTkZDIHBhc3N3b3JkIHRva2VucyBkdXJpbmcKK21hbnVmYWN0dXJpbmcgKGVhY2ggQVAgbmVlZHMgdG8gaGF2ZSBpdHMgb3duIHJhbmRvbSBrZXlzKS4KKworVGhlICJ3cHNfbmZjX2NvbmZpZ190b2tlbiA8V1BTL05ERUY+IiBjb21tYW5kIGNhbiBiZSB1c2VkIHRvIGJ1aWxkIGFuCitORkMgY29uZmlndXJhdGlvbiB0b2tlbi4gVGhlIG91dHB1dCB2YWx1ZSBmcm9tIHRoaXMgY29tbWFuZCBpcyBhIGhleGR1bXAKK29mIHRoZSBjdXJyZW50IEFQIGNvbmZpZ3VyYXRpb24gKFdQUyBwYXJhbWV0ZXIgcmVxdWVzdHMgdGhpcyB0byBpbmNsdWRlCitvbmx5IHRoZSBXUFMgYXR0cmlidXRlczsgTkRFRiBwYXJhbWV0ZXIgcmVxdWVzdHMgYWRkaXRpb25hbCBOREVGCitlbmNhcHN1bGF0aW9uIHRvIGJlIGluY2x1ZGVkKS4gVGhpcyBkYXRhIG5lZWRzIHRvIGJlIHdyaXR0ZW4gdG8gYW4gTkZDCit0YWcgd2l0aCBhbiBleHRlcm5hbCBwcm9ncmFtLiBPbmNlIHdyaXR0ZW4sIHRoZSBORkMgY29uZmlndXJhdGlvbiB0b2tlbgorY2FuIGJlIHVzZWQgdG8gdG91Y2ggYW4gTkZDIGludGVyZmFjZSBvbiBhIHN0YXRpb24gdG8gcHJvdmlzaW9uIHRoZQorY3JlZGVudGlhbHMgbmVlZGVkIHRvIGFjY2VzcyB0aGUgbmV0d29yay4KKworV2hlbiB0aGUgTkZDIGRldmljZSBvbiB0aGUgQVAgcmVhZHMgYW4gTkZDIHRhZyB3aXRoIGEgTUlNRSBtZWRpYSB0eXBlCisiYXBwbGljYXRpb24vdm5kLndmYS53c2MiLCB0aGUgTkRFRiBtZXNzYWdlIHBheWxvYWQgKHdpdGggb3Igd2l0aG91dAorTkRFRiBlbmNhcHN1bGF0aW9uKSBjYW4gYmUgZGVsaXZlcmVkIHRvIGhvc3RhcGQgdXNpbmcgdGhlCitmb2xsb3dpbmcgaG9zdGFwZF9jbGkgY29tbWFuZDoKKword3BzX25mY190YWdfcmVhZCA8aGV4ZHVtcCBvZiBwYXlsb2FkPgorCitJZiB0aGUgTkZDIHRhZyBjb250YWlucyBhIHBhc3N3b3JkIHRva2VuLCB0aGUgdG9rZW4gaXMgYWRkZWQgdG8gdGhlCitpbnRlcm5hbCBSZWdpc3RyYXIuIFRoaXMgYWxsb3dzIHN0YXRpb24gRW5yb2xsZWUgZnJvbSB3aGljaCB0aGUgcGFzc3dvcmQKK3Rva2VuIHdhcyByZWNlaXZlZCB0byBydW4gdGhyb3VnaCBXUFMgcHJvdG9jb2wgdG8gcHJvdmlzaW9uIHRoZQorY3JlZGVudGlhbC4KZGlmZiAtLWdpdCBhL2hvc3RhcGQvY29uZmlnX2ZpbGUuYyBiL2hvc3RhcGQvY29uZmlnX2ZpbGUuYwppbmRleCA3OGYxZTNkLi5lZWJiYWE2IDEwMDY0NAotLS0gYS9ob3N0YXBkL2NvbmZpZ19maWxlLmMKKysrIGIvaG9zdGFwZC9jb25maWdfZmlsZS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIGhvc3RhcGQgLyBDb25maWd1cmF0aW9uIGZpbGUgcGFyc2VyCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwMy0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC00OTEsNiArNDkxLDEwNCBAQAogCiAJcmV0dXJuIHJldDsKIH0KKworCitzdGF0aWMgc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKgoraG9zdGFwZF9wYXJzZV9yYWRpdXNfYXR0cihjb25zdCBjaGFyICp2YWx1ZSkKK3sKKwljb25zdCBjaGFyICpwb3M7CisJY2hhciBzeW50YXg7CisJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHI7CisJc2l6ZV90IGxlbjsKKworCWF0dHIgPSBvc196YWxsb2Moc2l6ZW9mKCphdHRyKSk7CisJaWYgKGF0dHIgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlhdHRyLT50eXBlID0gYXRvaSh2YWx1ZSk7CisKKwlwb3MgPSBvc19zdHJjaHIodmFsdWUsICc6Jyk7CisJaWYgKHBvcyA9PSBOVUxMKSB7CisJCWF0dHItPnZhbCA9IHdwYWJ1Zl9hbGxvYygxKTsKKwkJaWYgKGF0dHItPnZhbCA9PSBOVUxMKSB7CisJCQlvc19mcmVlKGF0dHIpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwkJd3BhYnVmX3B1dF91OChhdHRyLT52YWwsIDApOworCQlyZXR1cm4gYXR0cjsKKwl9CisKKwlwb3MrKzsKKwlpZiAocG9zWzBdID09ICdcMCcgfHwgcG9zWzFdICE9ICc6JykgeworCQlvc19mcmVlKGF0dHIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJc3ludGF4ID0gKnBvcysrOworCXBvcysrOworCisJc3dpdGNoIChzeW50YXgpIHsKKwljYXNlICdzJzoKKwkJYXR0ci0+dmFsID0gd3BhYnVmX2FsbG9jX2NvcHkocG9zLCBvc19zdHJsZW4ocG9zKSk7CisJCWJyZWFrOworCWNhc2UgJ3gnOgorCQlsZW4gPSBvc19zdHJsZW4ocG9zKTsKKwkJaWYgKGxlbiAmIDEpCisJCQlicmVhazsKKwkJbGVuIC89IDI7CisJCWF0dHItPnZhbCA9IHdwYWJ1Zl9hbGxvYyhsZW4pOworCQlpZiAoYXR0ci0+dmFsID09IE5VTEwpCisJCQlicmVhazsKKwkJaWYgKGhleHN0cjJiaW4ocG9zLCB3cGFidWZfcHV0KGF0dHItPnZhbCwgbGVuKSwgbGVuKSA8IDApIHsKKwkJCXdwYWJ1Zl9mcmVlKGF0dHItPnZhbCk7CisJCQlvc19mcmVlKGF0dHIpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwkJYnJlYWs7CisJY2FzZSAnZCc6CisJCWF0dHItPnZhbCA9IHdwYWJ1Zl9hbGxvYyg0KTsKKwkJaWYgKGF0dHItPnZhbCkKKwkJCXdwYWJ1Zl9wdXRfYmUzMihhdHRyLT52YWwsIGF0b2kocG9zKSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCW9zX2ZyZWUoYXR0cik7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmIChhdHRyLT52YWwgPT0gTlVMTCkgeworCQlvc19mcmVlKGF0dHIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gYXR0cjsKK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfcGFyc2VfZGFzX2NsaWVudChzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsCisJCQkJICAgIGNvbnN0IGNoYXIgKnZhbCkKK3sKKwljaGFyICpzZWNyZXQ7CisJc2l6ZV90IGxlbjsKKworCXNlY3JldCA9IG9zX3N0cmNocih2YWwsICcgJyk7CisJaWYgKHNlY3JldCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlzZWNyZXQrKzsKKwlsZW4gPSBvc19zdHJsZW4oc2VjcmV0KTsKKworCWlmIChob3N0YXBkX3BhcnNlX2lwX2FkZHIodmFsLCAmYnNzLT5yYWRpdXNfZGFzX2NsaWVudF9hZGRyKSkKKwkJcmV0dXJuIC0xOworCisJb3NfZnJlZShic3MtPnJhZGl1c19kYXNfc2hhcmVkX3NlY3JldCk7CisJYnNzLT5yYWRpdXNfZGFzX3NoYXJlZF9zZWNyZXQgPSBvc19tYWxsb2MobGVuKTsKKwlpZiAoYnNzLT5yYWRpdXNfZGFzX3NoYXJlZF9zZWNyZXQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJb3NfbWVtY3B5KGJzcy0+cmFkaXVzX2Rhc19zaGFyZWRfc2VjcmV0LCBzZWNyZXQsIGxlbik7CisJYnNzLT5yYWRpdXNfZGFzX3NoYXJlZF9zZWNyZXRfbGVuID0gbGVuOworCisJcmV0dXJuIDA7Cit9CiAjZW5kaWYgLyogQ09ORklHX05PX1JBRElVUyAqLwogCiAKQEAgLTEwMzQsNiArMTEzMiw3MSBAQAogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCiAKIAorI2lmZGVmIENPTkZJR19JRUVFODAyMTFBQworc3RhdGljIGludCBob3N0YXBkX2NvbmZpZ192aHRfY2FwYWIoc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mLAorCQkJCSAgICBjb25zdCBjaGFyICpjYXBhYikKK3sKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW01BWC1NUERVLTc5OTFdIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX01BWF9NUERVX0xFTkdUSF83OTkxOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbTUFYLU1QRFUtMTE0NTRdIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX01BWF9NUERVX0xFTkdUSF8xMTQ1NDsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1ZIVDE2MF0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2ME1IWjsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1ZIVDE2MC04MFBMVVM4MF0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2MF84MFBMVVM4ME1IWjsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1ZIVDE2MC04MFBMVVM4MF0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfU1VQUF9DSEFOX1dJRFRIXzE2MF84MFBMVVM4ME1IWjsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1JYTERQQ10iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfUlhMRFBDOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbU0hPUlQtR0ktODBdIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1NIT1JUX0dJXzgwOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbU0hPUlQtR0ktMTYwXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9TSE9SVF9HSV8xNjA7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltUWC1TVEJDLTJCWTFdIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1RYU1RCQzsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1JYLVNUQkMtMV0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfUlhTVEJDXzE7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltSWC1TVEJDLTEyXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9SWFNUQkNfMjsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1JYLVNUQkMtMTIzXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9SWFNUQkNfMzsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1JYLVNUQkMtMTIzNF0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfUlhTVEJDXzQ7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltTVS1CRUFNRk9STUVSXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NVV9CRUFNRk9STUVSX0NBUEFCTEU7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltTVS1CRUFNRk9STUVFXSIpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9NVV9CRUFNRk9STUVFX0NBUEFCTEU7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltCRi1BTlRFTk5BLTJdIikgJiYKKwkgICAgKGNvbmYtPnZodF9jYXBhYiAmIFZIVF9DQVBfTVVfQkVBTUZPUk1FUl9DQVBBQkxFKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfQkVBTUZPUk1FUl9BTlRFTk5BU19NQVg7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltTT1VORElORy1ESU1FTlNJT04tMl0iKSAmJgorCSAgICAoY29uZi0+dmh0X2NhcGFiICYgVkhUX0NBUF9NVV9CRUFNRk9STUVSX0NBUEFCTEUpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9TT1VORElOR19ESU1FTlRJT05fTUFYOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbTVUtQkVBTUZPUk1FUl0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfTVVfQkVBTUZPUk1FUl9DQVBBQkxFOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbTVUtQkVBTUZPUk1FRV0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfTVVfQkVBTUZPUk1FRV9DQVBBQkxFOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbVkhULVRYT1AtUFNdIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1ZIVF9UWE9QX1BTOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbSFRDLVZIVF0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfSFRDX1ZIVDsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW01BWC1BLU1QRFUtTEVOLUVYUDBdIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX01BWF9BX01QRFVfTEVOR1RIX0VYUE9ORU5UOworCWlmIChvc19zdHJzdHIoY2FwYWIsICJbVkhULUxJTkstQURBUFQyXSIpICYmCisJICAgIChjb25mLT52aHRfY2FwYWIgJiBWSFRfQ0FQX0hUQ19WSFQpKQorCQljb25mLT52aHRfY2FwYWIgfD0gVkhUX0NBUF9WSFRfTElOS19BREFQVEFUSU9OX1ZIVF9VTlNPTF9NRkI7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltWSFQtTElOSy1BREFQVDNdIikgJiYKKwkgICAgKGNvbmYtPnZodF9jYXBhYiAmIFZIVF9DQVBfSFRDX1ZIVCkpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1ZIVF9MSU5LX0FEQVBUQVRJT05fVkhUX01SUV9NRkI7CisJaWYgKG9zX3N0cnN0cihjYXBhYiwgIltSWC1BTlRFTk5BLVBBVFRFUk5dIikpCisJCWNvbmYtPnZodF9jYXBhYiB8PSBWSFRfQ0FQX1JYX0FOVEVOTkFfUEFUVEVSTjsKKwlpZiAob3Nfc3Ryc3RyKGNhcGFiLCAiW1RYLUFOVEVOTkEtUEFUVEVSTl0iKSkKKwkJY29uZi0+dmh0X2NhcGFiIHw9IFZIVF9DQVBfVFhfQU5URU5OQV9QQVRURVJOOworCXJldHVybiAwOworfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFBQyAqLworCisKIHN0YXRpYyBpbnQgaG9zdGFwZF9jb25maWdfY2hlY2tfYnNzKHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywKIAkJCQkgICAgc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mKQogewpAQCAtMTA5MCw2ICsxMjUzLDEyIEBACiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KIAogI2lmZGVmIENPTkZJR19JRUVFODAyMTFOCisJaWYgKGNvbmYtPmllZWU4MDIxMW4gJiYgY29uZi0+aHdfbW9kZSA9PSBIT1NUQVBEX01PREVfSUVFRTgwMjExQikgeworCQlic3MtPmRpc2FibGVfMTFuID0gMTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJIVCAoSUVFRSA4MDIuMTFuKSBpbiAxMWIgbW9kZSBpcyBub3QgIgorCQkJICAgImFsbG93ZWQsIGRpc2FibGluZyBIVCBjYXBhYmlsaXRlcyIpOworCX0KKwogCWlmIChjb25mLT5pZWVlODAyMTFuICYmCiAJICAgIGJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPT0gU0VDVVJJVFlfU1RBVElDX1dFUCkgewogCQlic3MtPmRpc2FibGVfMTFuID0gMTsKQEAgLTExNzUsNzYgKzEzNDQsODQgQEAKIAogCXJldHVybiAwOwogfQorCisKK3N0YXRpYyBpbnQgcGFyc2VfdmVudWVfbmFtZShzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsIGNoYXIgKnBvcywKKwkJCSAgICBpbnQgbGluZSkKK3sKKwljaGFyICpzZXA7CisJc2l6ZV90IGNsZW4sIG5sZW47CisJc3RydWN0IGhvc3RhcGRfdmVudWVfbmFtZSAqdm47CisKKwlzZXAgPSBvc19zdHJjaHIocG9zLCAnOicpOworCWlmIChzZXAgPT0gTlVMTCkKKwkJZ290byBmYWlsOworCSpzZXArKyA9ICdcMCc7CisKKwljbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJaWYgKGNsZW4gPCAyKQorCQlnb3RvIGZhaWw7CisJbmxlbiA9IG9zX3N0cmxlbihzZXApOworCWlmIChubGVuID4gMjUyKQorCQlnb3RvIGZhaWw7CisKKwl2biA9IG9zX3JlYWxsb2MoYnNzLT52ZW51ZV9uYW1lLAorCQkJc2l6ZW9mKHN0cnVjdCBob3N0YXBkX3ZlbnVlX25hbWUpICoKKwkJCShic3MtPnZlbnVlX25hbWVfY291bnQgKyAxKSk7CisJaWYgKHZuID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWJzcy0+dmVudWVfbmFtZSA9IHZuOworCXZuID0gJmJzcy0+dmVudWVfbmFtZVtic3MtPnZlbnVlX25hbWVfY291bnRdOworCWJzcy0+dmVudWVfbmFtZV9jb3VudCsrOworCisJb3NfbWVtc2V0KHZuLT5sYW5nLCAwLCBzaXplb2Yodm4tPmxhbmcpKTsKKwlvc19tZW1jcHkodm4tPmxhbmcsIHBvcywgY2xlbik7CisJdm4tPm5hbWVfbGVuID0gbmxlbjsKKwlvc19tZW1jcHkodm4tPm5hbWUsIHNlcCwgbmxlbik7CisKKwlyZXR1cm4gMDsKKworZmFpbDoKKwl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgdmVudWVfbmFtZSAnJXMnIiwKKwkJICAgbGluZSwgcG9zKTsKKwlyZXR1cm4gLTE7Cit9CiAjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogCiAKLS8qKgotICogaG9zdGFwZF9jb25maWdfcmVhZCAtIFJlYWQgYW5kIHBhcnNlIGEgY29uZmlndXJhdGlvbiBmaWxlCi0gKiBAZm5hbWU6IENvbmZpZ3VyYXRpb24gZmlsZSBuYW1lIChpbmNsdWRpbmcgcGF0aCwgaWYgbmVlZGVkKQotICogUmV0dXJuczogQWxsb2NhdGVkIGNvbmZpZ3VyYXRpb24gZGF0YSBzdHJ1Y3R1cmUKLSAqLwotc3RydWN0IGhvc3RhcGRfY29uZmlnICogaG9zdGFwZF9jb25maWdfcmVhZChjb25zdCBjaGFyICpmbmFtZSkKKyNpZmRlZiBDT05GSUdfV1BTX05GQworc3RhdGljIHN0cnVjdCB3cGFidWYgKiBob3N0YXBkX3BhcnNlX2Jpbihjb25zdCBjaGFyICpidWYpCiB7Ci0Jc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mOwotCXN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzczsKLQlGSUxFICpmOwotCWNoYXIgYnVmWzI1Nl0sICpwb3M7Ci0JaW50IGxpbmUgPSAwOworCXNpemVfdCBsZW47CisJc3RydWN0IHdwYWJ1ZiAqcmV0OworCisJbGVuID0gb3Nfc3RybGVuKGJ1Zik7CisJaWYgKGxlbiAmIDB4MDEpCisJCXJldHVybiBOVUxMOworCWxlbiAvPSAyOworCisJcmV0ID0gd3BhYnVmX2FsbG9jKGxlbik7CisJaWYgKHJldCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChoZXhzdHIyYmluKGJ1Ziwgd3BhYnVmX3B1dChyZXQsIGxlbiksIGxlbikpIHsKKwkJd3BhYnVmX2ZyZWUocmV0KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0dXJuIHJldDsKK30KKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jb25maWdfZmlsbChzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmYsCisJCQkgICAgICAgc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzLAorCQkJICAgICAgIGNoYXIgKmJ1ZiwgY2hhciAqcG9zLCBpbnQgbGluZSkKK3sKIAlpbnQgZXJyb3JzID0gMDsKLQlpbnQgcGFpcndpc2U7Ci0Jc2l6ZV90IGk7CiAKLQlmID0gZm9wZW4oZm5hbWUsICJyIik7Ci0JaWYgKGYgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBvcGVuIGNvbmZpZ3VyYXRpb24gZmlsZSAnJXMnICIKLQkJCSAgICJmb3IgcmVhZGluZy4iLCBmbmFtZSk7Ci0JCXJldHVybiBOVUxMOwotCX0KLQotCWNvbmYgPSBob3N0YXBkX2NvbmZpZ19kZWZhdWx0cygpOwotCWlmIChjb25mID09IE5VTEwpIHsKLQkJZmNsb3NlKGYpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0KLQkvKiBzZXQgZGVmYXVsdCBkcml2ZXIgYmFzZWQgb24gY29uZmlndXJhdGlvbiAqLwotCWNvbmYtPmRyaXZlciA9IHdwYV9kcml2ZXJzWzBdOwotCWlmIChjb25mLT5kcml2ZXIgPT0gTlVMTCkgewotCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIk5vIGRyaXZlciB3cmFwcGVycyByZWdpc3RlcmVkISIpOwotCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOwotCQlmY2xvc2UoZik7Ci0JCXJldHVybiBOVUxMOwotCX0KLQotCWJzcyA9IGNvbmYtPmxhc3RfYnNzID0gY29uZi0+YnNzOwotCi0Jd2hpbGUgKGZnZXRzKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGYpKSB7Ci0JCWJzcyA9IGNvbmYtPmxhc3RfYnNzOwotCQlsaW5lKys7Ci0KLQkJaWYgKGJ1ZlswXSA9PSAnIycpCi0JCQljb250aW51ZTsKLQkJcG9zID0gYnVmOwotCQl3aGlsZSAoKnBvcyAhPSAnXDAnKSB7Ci0JCQlpZiAoKnBvcyA9PSAnXG4nKSB7Ci0JCQkJKnBvcyA9ICdcMCc7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQlwb3MrKzsKLQkJfQotCQlpZiAoYnVmWzBdID09ICdcMCcpCi0JCQljb250aW51ZTsKLQotCQlwb3MgPSBvc19zdHJjaHIoYnVmLCAnPScpOwotCQlpZiAocG9zID09IE5VTEwpIHsKLQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBsaW5lICclcyciLAotCQkJCSAgIGxpbmUsIGJ1Zik7Ci0JCQllcnJvcnMrKzsKLQkJCWNvbnRpbnVlOwotCQl9Ci0JCSpwb3MgPSAnXDAnOwotCQlwb3MrKzsKLQorCXsKIAkJaWYgKG9zX3N0cmNtcChidWYsICJpbnRlcmZhY2UiKSA9PSAwKSB7CiAJCQlvc19zdHJsY3B5KGNvbmYtPmJzc1swXS5pZmFjZSwgcG9zLAogCQkJCSAgIHNpemVvZihjb25mLT5ic3NbMF0uaWZhY2UpKTsKQEAgLTE0NDYsNyArMTYyMyw3IEBACiAJCQkJCSAgICJhbGxvY2F0ZSBtZW1vcnkgZm9yICIKIAkJCQkJICAgImVhcF9yZXFfaWRfdGV4dCIsIGxpbmUpOwogCQkJCWVycm9ycysrOwotCQkJCWNvbnRpbnVlOworCQkJCXJldHVybiBlcnJvcnM7CiAJCQl9CiAJCQlic3MtPmVhcF9yZXFfaWRfdGV4dF9sZW4gPQogCQkJCW9zX3N0cmxlbihic3MtPmVhcF9yZXFfaWRfdGV4dCk7CkBAIC0xNTY2LDYgKzE3NDMsNTEgQEAKIAkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2FjY3RfaW50ZXJpbV9pbnRlcnZhbCIpID09IDApCiAJCXsKIAkJCWJzcy0+YWNjdF9pbnRlcmltX2ludGVydmFsID0gYXRvaShwb3MpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfcmVxdWVzdF9jdWkiKSA9PSAwKSB7CisJCQlic3MtPnJhZGl1c19yZXF1ZXN0X2N1aSA9IGF0b2kocG9zKTsKKwkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicmFkaXVzX2F1dGhfcmVxX2F0dHIiKSA9PSAwKSB7CisJCQlzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfYXR0ciAqYXR0ciwgKmE7CisJCQlhdHRyID0gaG9zdGFwZF9wYXJzZV9yYWRpdXNfYXR0cihwb3MpOworCQkJaWYgKGF0dHIgPT0gTlVMTCkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCisJCQkJCSAgICJyYWRpdXNfYXV0aF9yZXFfYXR0ciIsIGxpbmUpOworCQkJCWVycm9ycysrOworCQkJfSBlbHNlIGlmIChic3MtPnJhZGl1c19hdXRoX3JlcV9hdHRyID09IE5VTEwpIHsKKwkJCQlic3MtPnJhZGl1c19hdXRoX3JlcV9hdHRyID0gYXR0cjsKKwkJCX0gZWxzZSB7CisJCQkJYSA9IGJzcy0+cmFkaXVzX2F1dGhfcmVxX2F0dHI7CisJCQkJd2hpbGUgKGEtPm5leHQpCisJCQkJCWEgPSBhLT5uZXh0OworCQkJCWEtPm5leHQgPSBhdHRyOworCQkJfQorCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfYWNjdF9yZXFfYXR0ciIpID09IDApIHsKKwkJCXN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICphdHRyLCAqYTsKKwkJCWF0dHIgPSBob3N0YXBkX3BhcnNlX3JhZGl1c19hdHRyKHBvcyk7CisJCQlpZiAoYXR0ciA9PSBOVUxMKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKKwkJCQkJICAgInJhZGl1c19hY2N0X3JlcV9hdHRyIiwgbGluZSk7CisJCQkJZXJyb3JzKys7CisJCQl9IGVsc2UgaWYgKGJzcy0+cmFkaXVzX2FjY3RfcmVxX2F0dHIgPT0gTlVMTCkgeworCQkJCWJzcy0+cmFkaXVzX2FjY3RfcmVxX2F0dHIgPSBhdHRyOworCQkJfSBlbHNlIHsKKwkJCQlhID0gYnNzLT5yYWRpdXNfYWNjdF9yZXFfYXR0cjsKKwkJCQl3aGlsZSAoYS0+bmV4dCkKKwkJCQkJYSA9IGEtPm5leHQ7CisJCQkJYS0+bmV4dCA9IGF0dHI7CisJCQl9CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19kYXNfcG9ydCIpID09IDApIHsKKwkJCWJzcy0+cmFkaXVzX2Rhc19wb3J0ID0gYXRvaShwb3MpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJyYWRpdXNfZGFzX2NsaWVudCIpID09IDApIHsKKwkJCWlmIChob3N0YXBkX3BhcnNlX2Rhc19jbGllbnQoYnNzLCBwb3MpIDwgMCkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCAiCisJCQkJCSAgICJEQVMgY2xpZW50IiwgbGluZSk7CisJCQkJZXJyb3JzKys7CisJCQl9CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19kYXNfdGltZV93aW5kb3ciKSA9PSAwKSB7CisJCQlic3MtPnJhZGl1c19kYXNfdGltZV93aW5kb3cgPSBhdG9pKHBvcyk7CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJhZGl1c19kYXNfcmVxdWlyZV9ldmVudF90aW1lc3RhbXAiKQorCQkJICAgPT0gMCkgeworCQkJYnNzLT5yYWRpdXNfZGFzX3JlcXVpcmVfZXZlbnRfdGltZXN0YW1wID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KIAkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiYXV0aF9hbGdzIikgPT0gMCkgewogCQkJYnNzLT5hdXRoX2FsZ3MgPSBhdG9pKHBvcyk7CkBAIC0xNjA1LDYgKzE4MjcsOCBAQAogCQkJfSBlbHNlIHsKIAkJCQlvc19mcmVlKGJzcy0+c3NpZC53cGFfcGFzc3BocmFzZSk7CiAJCQkJYnNzLT5zc2lkLndwYV9wYXNzcGhyYXNlID0gb3Nfc3RyZHVwKHBvcyk7CisJCQkJb3NfZnJlZShic3MtPnNzaWQud3BhX3Bzayk7CisJCQkJYnNzLT5zc2lkLndwYV9wc2sgPSBOVUxMOwogCQkJfQogCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfcHNrIikgPT0gMCkgewogCQkJb3NfZnJlZShic3MtPnNzaWQud3BhX3Bzayk7CkBAIC0xNjIwLDYgKzE4NDQsOCBAQAogCQkJCWVycm9ycysrOwogCQkJfSBlbHNlIHsKIAkJCQlic3MtPnNzaWQud3BhX3Bzay0+Z3JvdXAgPSAxOworCQkJCW9zX2ZyZWUoYnNzLT5zc2lkLndwYV9wYXNzcGhyYXNlKTsKKwkJCQlic3MtPnNzaWQud3BhX3Bhc3NwaHJhc2UgPSBOVUxMOwogCQkJfQogCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cGFfcHNrX2ZpbGUiKSA9PSAwKSB7CiAJCQlvc19mcmVlKGJzcy0+c3NpZC53cGFfcHNrX2ZpbGUpOwpAQCAtMTY5MCw3ICsxOTE2LDcgQEAKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkxpbmUgJWQ6IEludmFsaWQgIgogCQkJCQkgICAibW9iaWxpdHlfZG9tYWluICclcyciLCBsaW5lLCBwb3MpOwogCQkJCWVycm9ycysrOwotCQkJCWNvbnRpbnVlOworCQkJCXJldHVybiBlcnJvcnM7CiAJCQl9CiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInIxX2tleV9ob2xkZXIiKSA9PSAwKSB7CiAJCQlpZiAob3Nfc3RybGVuKHBvcykgIT0gMiAqIEZUX1IxS0hfSURfTEVOIHx8CkBAIC0xNjk5LDcgKzE5MjUsNyBAQAogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCAiCiAJCQkJCSAgICJyMV9rZXlfaG9sZGVyICclcyciLCBsaW5lLCBwb3MpOwogCQkJCWVycm9ycysrOwotCQkJCWNvbnRpbnVlOworCQkJCXJldHVybiBlcnJvcnM7CiAJCQl9CiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInIwX2tleV9saWZldGltZSIpID09IDApIHsKIAkJCWJzcy0+cjBfa2V5X2xpZmV0aW1lID0gYXRvaShwb3MpOwpAQCAtMTcxMCwxNCArMTkzNiwxNCBAQAogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCAiCiAJCQkJCSAgICJyMGtoICclcyciLCBsaW5lLCBwb3MpOwogCQkJCWVycm9ycysrOwotCQkJCWNvbnRpbnVlOworCQkJCXJldHVybiBlcnJvcnM7CiAJCQl9CiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInIxa2giKSA9PSAwKSB7CiAJCQlpZiAoYWRkX3Ixa2goYnNzLCBwb3MpIDwgMCkgewogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiTGluZSAlZDogSW52YWxpZCAiCiAJCQkJCSAgICJyMWtoICclcyciLCBsaW5lLCBwb3MpOwogCQkJCWVycm9ycysrOwotCQkJCWNvbnRpbnVlOworCQkJCXJldHVybiBlcnJvcnM7CiAJCQl9CiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBta19yMV9wdXNoIikgPT0gMCkgewogCQkJYnNzLT5wbWtfcjFfcHVzaCA9IGF0b2kocG9zKTsKQEAgLTE3NDEsNyArMTk2Nyw3IEBACiAJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJjdHJsX2ludGVyZmFjZV9ncm91cD0lZCIKIAkJCQkJICAgIiAoZnJvbSBncm91cCBuYW1lICclcycpIiwKIAkJCQkJICAgYnNzLT5jdHJsX2ludGVyZmFjZV9naWQsIGdyb3VwKTsKLQkJCQljb250aW51ZTsKKwkJCQlyZXR1cm4gZXJyb3JzOwogCQkJfQogCiAJCQkvKiBHcm91cCBuYW1lIG5vdCBmb3VuZCAtIHRyeSB0byBwYXJzZSB0aGlzIGFzIGdpZCAqLwpAQCAtMTc1MCw3ICsxOTc2LDcgQEAKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkxpbmUgJWQ6IEludmFsaWQgZ3JvdXAgIgogCQkJCQkgICAiJyVzJyIsIGxpbmUsIGdyb3VwKTsKIAkJCQllcnJvcnMrKzsKLQkJCQljb250aW51ZTsKKwkJCQlyZXR1cm4gZXJyb3JzOwogCQkJfQogCQkJYnNzLT5jdHJsX2ludGVyZmFjZV9naWRfc2V0ID0gMTsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiY3RybF9pbnRlcmZhY2VfZ3JvdXA9JWQiLApAQCAtMTk2NSw2ICsyMTkxLDE4IEBACiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInJlcXVpcmVfaHQiKSA9PSAwKSB7CiAJCQljb25mLT5yZXF1aXJlX2h0ID0gYXRvaShwb3MpOwogI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFOICovCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImllZWU4MDIxMWFjIikgPT0gMCkgeworCQkJY29uZi0+aWVlZTgwMjExYWMgPSBhdG9pKHBvcyk7CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZodF9jYXBhYiIpID09IDApIHsKKwkJCWlmIChob3N0YXBkX2NvbmZpZ192aHRfY2FwYWIoY29uZiwgcG9zKSA8IDApIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgIgorCQkJCQkgICAidmh0X2NhcGFiIiwgbGluZSk7CisJCQkJZXJyb3JzKys7CisJCQl9CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInZodF9vcGVyX2Nod2lkdGgiKSA9PSAwKSB7CisJCSAgICBjb25mLT52aHRfb3Blcl9jaHdpZHRoID0gYXRvaShwb3MpOworI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFBQyAqLwogCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJtYXhfbGlzdGVuX2ludGVydmFsIikgPT0gMCkgewogCQkJYnNzLT5tYXhfbGlzdGVuX2ludGVydmFsID0gYXRvaShwb3MpOwogCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJkaXNhYmxlX3Bta3NhX2NhY2hpbmciKSA9PSAwKSB7CkBAIC0yMDg4LDYgKzIzMjYsMjUgQEAKIAkJCWJzcy0+dXBjID0gb3Nfc3RyZHVwKHBvcyk7CiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgInBiY19pbl9tMSIpID09IDApIHsKIAkJCWJzcy0+cGJjX2luX20xID0gYXRvaShwb3MpOworI2lmZGVmIENPTkZJR19XUFNfTkZDCisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwc19uZmNfZGV2X3B3X2lkIikgPT0gMCkgeworCQkJYnNzLT53cHNfbmZjX2Rldl9wd19pZCA9IGF0b2kocG9zKTsKKwkJCWlmIChic3MtPndwc19uZmNfZGV2X3B3X2lkIDwgMHgxMCB8fAorCQkJICAgIGJzcy0+d3BzX25mY19kZXZfcHdfaWQgPiAweGZmZmYpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgIgorCQkJCQkgICAid3BzX25mY19kZXZfcHdfaWQgdmFsdWUiLCBsaW5lKTsKKwkJCQllcnJvcnMrKzsKKwkJCX0KKwkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAid3BzX25mY19kaF9wdWJrZXkiKSA9PSAwKSB7CisJCQl3cGFidWZfZnJlZShic3MtPndwc19uZmNfZGhfcHVia2V5KTsKKwkJCWJzcy0+d3BzX25mY19kaF9wdWJrZXkgPSBob3N0YXBkX3BhcnNlX2Jpbihwb3MpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ3cHNfbmZjX2RoX3ByaXZrZXkiKSA9PSAwKSB7CisJCQl3cGFidWZfZnJlZShic3MtPndwc19uZmNfZGhfcHJpdmtleSk7CisJCQlic3MtPndwc19uZmNfZGhfcHJpdmtleSA9IGhvc3RhcGRfcGFyc2VfYmluKHBvcyk7CisJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIndwc19uZmNfZGV2X3B3IikgPT0gMCkgeworCQkJd3BhYnVmX2ZyZWUoYnNzLT53cHNfbmZjX2Rldl9wdyk7CisJCQlic3MtPndwc19uZmNfZGV2X3B3ID0gaG9zdGFwZF9wYXJzZV9iaW4ocG9zKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KICNpZmRlZiBDT05GSUdfUDJQX01BTkFHRVIKIAkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAibWFuYWdlX3AycCIpID09IDApIHsKQEAgLTIxMjksNyArMjM4Niw3IEBACiAJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJMaW5lICVkOiBpbnZhbGlkICIKIAkJCQkJICAgInRpbWVfem9uZSIsIGxpbmUpOwogCQkJCWVycm9ycysrOwotCQkJCWNvbnRpbnVlOworCQkJCXJldHVybiBlcnJvcnM7CiAJCQl9CiAJCQlvc19mcmVlKGJzcy0+dGltZV96b25lKTsKIAkJCWJzcy0+dGltZV96b25lID0gb3Nfc3RyZHVwKHBvcyk7CkBAIC0yMTY5LDYgKzI0MjYsMTMgQEAKIAkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAicm9hbWluZ19jb25zb3J0aXVtIikgPT0gMCkgewogCQkJaWYgKHBhcnNlX3JvYW1pbmdfY29uc29ydGl1bShic3MsIHBvcywgbGluZSkgPCAwKQogCQkJCWVycm9ycysrOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJ2ZW51ZV9uYW1lIikgPT0gMCkgeworCQkJaWYgKHBhcnNlX3ZlbnVlX25hbWUoYnNzLCBwb3MsIGxpbmUpIDwgMCkKKwkJCQllcnJvcnMrKzsKKwkJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiZ2FzX2ZyYWdfbGltaXQiKSA9PSAwKSB7CisJCQlic3MtPmdhc19mcmFnX2xpbWl0ID0gYXRvaShwb3MpOworCQl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJnYXNfY29tZWJhY2tfZGVsYXkiKSA9PSAwKSB7CisJCQlic3MtPmdhc19jb21lYmFja19kZWxheSA9IGF0b2kocG9zKTsKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAjaWZkZWYgQ09ORklHX1JBRElVU19URVNUCiAJCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgImR1bXBfbXNrX2ZpbGUiKSA9PSAwKSB7CkBAIC0yMTgyLDY0ICsyNDQ2LDE0MSBAQAogCQl9CiAJfQogCisJcmV0dXJuIGVycm9yczsKK30KKworCitzdGF0aWMgdm9pZCBob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzKQoreworCWludCBwYWlyd2lzZTsKKworCWlmIChic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPT0gMCkgeworCQkvKiBpbmRpdmlkdWFsIGtleXMgYXJlIG5vdCB1c2U7IGNhbiB1c2Uga2V5IGlkeDAgZm9yCisJCSAqIGJyb2FkY2FzdCBrZXlzICovCisJCWJzcy0+YnJvYWRjYXN0X2tleV9pZHhfbWluID0gMDsKKwl9CisKKwkvKiBTZWxlY3QgZ3JvdXAgY2lwaGVyIGJhc2VkIG9uIHRoZSBlbmFibGVkIHBhaXJ3aXNlIGNpcGhlcgorCSAqIHN1aXRlcyAqLworCXBhaXJ3aXNlID0gMDsKKwlpZiAoYnNzLT53cGEgJiAxKQorCQlwYWlyd2lzZSB8PSBic3MtPndwYV9wYWlyd2lzZTsKKwlpZiAoYnNzLT53cGEgJiAyKSB7CisJCWlmIChic3MtPnJzbl9wYWlyd2lzZSA9PSAwKQorCQkJYnNzLT5yc25fcGFpcndpc2UgPSBic3MtPndwYV9wYWlyd2lzZTsKKwkJcGFpcndpc2UgfD0gYnNzLT5yc25fcGFpcndpc2U7CisJfQorCWlmIChwYWlyd2lzZSAmIFdQQV9DSVBIRVJfVEtJUCkKKwkJYnNzLT53cGFfZ3JvdXAgPSBXUEFfQ0lQSEVSX1RLSVA7CisJZWxzZQorCQlic3MtPndwYV9ncm91cCA9IFdQQV9DSVBIRVJfQ0NNUDsKKworCWJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlciA9IGJzcy0+cmFkaXVzLT5hdXRoX3NlcnZlcnM7CisJYnNzLT5yYWRpdXMtPmFjY3Rfc2VydmVyID0gYnNzLT5yYWRpdXMtPmFjY3Rfc2VydmVyczsKKworCWlmIChic3MtPndwYSAmJiBic3MtPmllZWU4MDJfMXgpIHsKKwkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1dQQTsKKwl9IGVsc2UgaWYgKGJzcy0+d3BhKSB7CisJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9XUEFfUFNLOworCX0gZWxzZSBpZiAoYnNzLT5pZWVlODAyXzF4KSB7CisJCWludCBjaXBoZXIgPSBXUEFfQ0lQSEVSX05PTkU7CisJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9JRUVFXzgwMl8xWDsKKwkJYnNzLT5zc2lkLndlcC5kZWZhdWx0X2xlbiA9IGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbjsKKwkJaWYgKGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbikKKwkJCWNpcGhlciA9IGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiA+PSAxMyA/CisJCQkJV1BBX0NJUEhFUl9XRVAxMDQgOiBXUEFfQ0lQSEVSX1dFUDQwOworCQlic3MtPndwYV9ncm91cCA9IGNpcGhlcjsKKwkJYnNzLT53cGFfcGFpcndpc2UgPSBjaXBoZXI7CisJCWJzcy0+cnNuX3BhaXJ3aXNlID0gY2lwaGVyOworCX0gZWxzZSBpZiAoYnNzLT5zc2lkLndlcC5rZXlzX3NldCkgeworCQlpbnQgY2lwaGVyID0gV1BBX0NJUEhFUl9XRVA0MDsKKwkJaWYgKGJzcy0+c3NpZC53ZXAubGVuWzBdID49IDEzKQorCQkJY2lwaGVyID0gV1BBX0NJUEhFUl9XRVAxMDQ7CisJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9TVEFUSUNfV0VQOworCQlic3MtPndwYV9ncm91cCA9IGNpcGhlcjsKKwkJYnNzLT53cGFfcGFpcndpc2UgPSBjaXBoZXI7CisJCWJzcy0+cnNuX3BhaXJ3aXNlID0gY2lwaGVyOworCX0gZWxzZSB7CisJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9QTEFJTlRFWFQ7CisJCWJzcy0+d3BhX2dyb3VwID0gV1BBX0NJUEhFUl9OT05FOworCQlic3MtPndwYV9wYWlyd2lzZSA9IFdQQV9DSVBIRVJfTk9ORTsKKwkJYnNzLT5yc25fcGFpcndpc2UgPSBXUEFfQ0lQSEVSX05PTkU7CisJfQorfQorCisKKy8qKgorICogaG9zdGFwZF9jb25maWdfcmVhZCAtIFJlYWQgYW5kIHBhcnNlIGEgY29uZmlndXJhdGlvbiBmaWxlCisgKiBAZm5hbWU6IENvbmZpZ3VyYXRpb24gZmlsZSBuYW1lIChpbmNsdWRpbmcgcGF0aCwgaWYgbmVlZGVkKQorICogUmV0dXJuczogQWxsb2NhdGVkIGNvbmZpZ3VyYXRpb24gZGF0YSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGhvc3RhcGRfY29uZmlnICogaG9zdGFwZF9jb25maWdfcmVhZChjb25zdCBjaGFyICpmbmFtZSkKK3sKKwlzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmY7CisJc3RydWN0IGhvc3RhcGRfYnNzX2NvbmZpZyAqYnNzOworCUZJTEUgKmY7CisJY2hhciBidWZbNTEyXSwgKnBvczsKKwlpbnQgbGluZSA9IDA7CisJaW50IGVycm9ycyA9IDA7CisJc2l6ZV90IGk7CisKKwlmID0gZm9wZW4oZm5hbWUsICJyIik7CisJaWYgKGYgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBvcGVuIGNvbmZpZ3VyYXRpb24gZmlsZSAnJXMnICIKKwkJCSAgICJmb3IgcmVhZGluZy4iLCBmbmFtZSk7CisJCXJldHVybiBOVUxMOworCX0KKworCWNvbmYgPSBob3N0YXBkX2NvbmZpZ19kZWZhdWx0cygpOworCWlmIChjb25mID09IE5VTEwpIHsKKwkJZmNsb3NlKGYpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwkvKiBzZXQgZGVmYXVsdCBkcml2ZXIgYmFzZWQgb24gY29uZmlndXJhdGlvbiAqLworCWNvbmYtPmRyaXZlciA9IHdwYV9kcml2ZXJzWzBdOworCWlmIChjb25mLT5kcml2ZXIgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIk5vIGRyaXZlciB3cmFwcGVycyByZWdpc3RlcmVkISIpOworCQlob3N0YXBkX2NvbmZpZ19mcmVlKGNvbmYpOworCQlmY2xvc2UoZik7CisJCXJldHVybiBOVUxMOworCX0KKworCWJzcyA9IGNvbmYtPmxhc3RfYnNzID0gY29uZi0+YnNzOworCisJd2hpbGUgKGZnZXRzKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGYpKSB7CisJCWJzcyA9IGNvbmYtPmxhc3RfYnNzOworCQlsaW5lKys7CisKKwkJaWYgKGJ1ZlswXSA9PSAnIycpCisJCQljb250aW51ZTsKKwkJcG9zID0gYnVmOworCQl3aGlsZSAoKnBvcyAhPSAnXDAnKSB7CisJCQlpZiAoKnBvcyA9PSAnXG4nKSB7CisJCQkJKnBvcyA9ICdcMCc7CisJCQkJYnJlYWs7CisJCQl9CisJCQlwb3MrKzsKKwkJfQorCQlpZiAoYnVmWzBdID09ICdcMCcpCisJCQljb250aW51ZTsKKworCQlwb3MgPSBvc19zdHJjaHIoYnVmLCAnPScpOworCQlpZiAocG9zID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogaW52YWxpZCBsaW5lICclcyciLAorCQkJCSAgIGxpbmUsIGJ1Zik7CisJCQllcnJvcnMrKzsKKwkJCWNvbnRpbnVlOworCQl9CisJCSpwb3MgPSAnXDAnOworCQlwb3MrKzsKKwkJZXJyb3JzICs9IGhvc3RhcGRfY29uZmlnX2ZpbGwoY29uZiwgYnNzLCBidWYsIHBvcywgbGluZSk7CisJfQorCiAJZmNsb3NlKGYpOwogCi0JZm9yIChpID0gMDsgaSA8IGNvbmYtPm51bV9ic3M7IGkrKykgewotCQlic3MgPSAmY29uZi0+YnNzW2ldOwotCi0JCWlmIChic3MtPmluZGl2aWR1YWxfd2VwX2tleV9sZW4gPT0gMCkgewotCQkJLyogaW5kaXZpZHVhbCBrZXlzIGFyZSBub3QgdXNlOyBjYW4gdXNlIGtleSBpZHgwIGZvcgotCQkJICogYnJvYWRjYXN0IGtleXMgKi8KLQkJCWJzcy0+YnJvYWRjYXN0X2tleV9pZHhfbWluID0gMDsKLQkJfQotCi0JCS8qIFNlbGVjdCBncm91cCBjaXBoZXIgYmFzZWQgb24gdGhlIGVuYWJsZWQgcGFpcndpc2UgY2lwaGVyCi0JCSAqIHN1aXRlcyAqLwotCQlwYWlyd2lzZSA9IDA7Ci0JCWlmIChic3MtPndwYSAmIDEpCi0JCQlwYWlyd2lzZSB8PSBic3MtPndwYV9wYWlyd2lzZTsKLQkJaWYgKGJzcy0+d3BhICYgMikgewotCQkJaWYgKGJzcy0+cnNuX3BhaXJ3aXNlID09IDApCi0JCQkJYnNzLT5yc25fcGFpcndpc2UgPSBic3MtPndwYV9wYWlyd2lzZTsKLQkJCXBhaXJ3aXNlIHw9IGJzcy0+cnNuX3BhaXJ3aXNlOwotCQl9Ci0JCWlmIChwYWlyd2lzZSAmIFdQQV9DSVBIRVJfVEtJUCkKLQkJCWJzcy0+d3BhX2dyb3VwID0gV1BBX0NJUEhFUl9US0lQOwotCQllbHNlCi0JCQlic3MtPndwYV9ncm91cCA9IFdQQV9DSVBIRVJfQ0NNUDsKLQotCQlic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXIgPSBic3MtPnJhZGl1cy0+YXV0aF9zZXJ2ZXJzOwotCQlic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXIgPSBic3MtPnJhZGl1cy0+YWNjdF9zZXJ2ZXJzOwotCi0JCWlmIChic3MtPndwYSAmJiBic3MtPmllZWU4MDJfMXgpIHsKLQkJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9XUEE7Ci0JCX0gZWxzZSBpZiAoYnNzLT53cGEpIHsKLQkJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9XUEFfUFNLOwotCQl9IGVsc2UgaWYgKGJzcy0+aWVlZTgwMl8xeCkgewotCQkJaW50IGNpcGhlciA9IFdQQV9DSVBIRVJfTk9ORTsKLQkJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9JRUVFXzgwMl8xWDsKLQkJCWJzcy0+c3NpZC53ZXAuZGVmYXVsdF9sZW4gPSBic3MtPmRlZmF1bHRfd2VwX2tleV9sZW47Ci0JCQlpZiAoYnNzLT5kZWZhdWx0X3dlcF9rZXlfbGVuKQotCQkJCWNpcGhlciA9IGJzcy0+ZGVmYXVsdF93ZXBfa2V5X2xlbiA+PSAxMyA/Ci0JCQkJCVdQQV9DSVBIRVJfV0VQMTA0IDogV1BBX0NJUEhFUl9XRVA0MDsKLQkJCWJzcy0+d3BhX2dyb3VwID0gY2lwaGVyOwotCQkJYnNzLT53cGFfcGFpcndpc2UgPSBjaXBoZXI7Ci0JCQlic3MtPnJzbl9wYWlyd2lzZSA9IGNpcGhlcjsKLQkJfSBlbHNlIGlmIChic3MtPnNzaWQud2VwLmtleXNfc2V0KSB7Ci0JCQlpbnQgY2lwaGVyID0gV1BBX0NJUEhFUl9XRVA0MDsKLQkJCWlmIChic3MtPnNzaWQud2VwLmxlblswXSA+PSAxMykKLQkJCQljaXBoZXIgPSBXUEFfQ0lQSEVSX1dFUDEwNDsKLQkJCWJzcy0+c3NpZC5zZWN1cml0eV9wb2xpY3kgPSBTRUNVUklUWV9TVEFUSUNfV0VQOwotCQkJYnNzLT53cGFfZ3JvdXAgPSBjaXBoZXI7Ci0JCQlic3MtPndwYV9wYWlyd2lzZSA9IGNpcGhlcjsKLQkJCWJzcy0+cnNuX3BhaXJ3aXNlID0gY2lwaGVyOwotCQl9IGVsc2UgewotCQkJYnNzLT5zc2lkLnNlY3VyaXR5X3BvbGljeSA9IFNFQ1VSSVRZX1BMQUlOVEVYVDsKLQkJCWJzcy0+d3BhX2dyb3VwID0gV1BBX0NJUEhFUl9OT05FOwotCQkJYnNzLT53cGFfcGFpcndpc2UgPSBXUEFfQ0lQSEVSX05PTkU7Ci0JCQlic3MtPnJzbl9wYWlyd2lzZSA9IFdQQV9DSVBIRVJfTk9ORTsKLQkJfQotCX0KKwlmb3IgKGkgPSAwOyBpIDwgY29uZi0+bnVtX2JzczsgaSsrKQorCQlob3N0YXBkX3NldF9zZWN1cml0eV9wYXJhbXMoJmNvbmYtPmJzc1tpXSk7CiAKIAlpZiAoaG9zdGFwZF9jb25maWdfY2hlY2soY29uZikpCiAJCWVycm9ycysrOwpAQCAtMjI1NSwzICsyNTk2LDI4IEBACiAKIAlyZXR1cm4gY29uZjsKIH0KKworCitpbnQgaG9zdGFwZF9zZXRfaWZhY2Uoc3RydWN0IGhvc3RhcGRfY29uZmlnICpjb25mLAorCQkgICAgICBzdHJ1Y3QgaG9zdGFwZF9ic3NfY29uZmlnICpic3MsIGNoYXIgKmZpZWxkLCBjaGFyICp2YWx1ZSkKK3sKKwlpbnQgZXJyb3JzOworCXNpemVfdCBpOworCisJZXJyb3JzID0gaG9zdGFwZF9jb25maWdfZmlsbChjb25mLCBic3MsIGZpZWxkLCB2YWx1ZSwgMCk7CisJaWYgKGVycm9ycykgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRmFpbGVkIHRvIHNldCBjb25maWd1cmF0aW9uIGZpZWxkICclcycgIgorCQkJICAgInRvIHZhbHVlICclcyciLCBmaWVsZCwgdmFsdWUpOworCQlyZXR1cm4gLTE7CisJfQorCisJZm9yIChpID0gMDsgaSA8IGNvbmYtPm51bV9ic3M7IGkrKykKKwkJaG9zdGFwZF9zZXRfc2VjdXJpdHlfcGFyYW1zKCZjb25mLT5ic3NbaV0pOworCisJaWYgKGhvc3RhcGRfY29uZmlnX2NoZWNrKGNvbmYpKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ29uZmlndXJhdGlvbiBjaGVjayBmYWlsZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvaG9zdGFwZC9jb25maWdfZmlsZS5oIGIvaG9zdGFwZC9jb25maWdfZmlsZS5oCmluZGV4IDgwZDE4MmUuLmZiYTU3YjggMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvY29uZmlnX2ZpbGUuaAorKysgYi9ob3N0YXBkL2NvbmZpZ19maWxlLmgKQEAgLTEwLDUgKzEwLDggQEAKICNkZWZpbmUgQ09ORklHX0ZJTEVfSAogCiBzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKiBob3N0YXBkX2NvbmZpZ19yZWFkKGNvbnN0IGNoYXIgKmZuYW1lKTsKK2ludCBob3N0YXBkX3NldF9pZmFjZShzdHJ1Y3QgaG9zdGFwZF9jb25maWcgKmNvbmYsCisJCSAgICAgIHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmJzcywgY2hhciAqZmllbGQsCisJCSAgICAgIGNoYXIgKnZhbHVlKTsKIAogI2VuZGlmIC8qIENPTkZJR19GSUxFX0ggKi8KZGlmZiAtLWdpdCBhL2hvc3RhcGQvY3RybF9pZmFjZS5jIGIvaG9zdGFwZC9jdHJsX2lmYWNlLmMKaW5kZXggOWQ1YTY3ZS4uNzU4N2UwMyAxMDA2NDQKLS0tIGEvaG9zdGFwZC9jdHJsX2lmYWNlLmMKKysrIGIvaG9zdGFwZC9jdHJsX2lmYWNlLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIFVOSVggZG9tYWluIHNvY2tldCAtYmFzZWQgY29udHJvbCBpbnRlcmZhY2UKLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEwLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJhcC9hcF9kcnZfb3BzLmgiCiAjaW5jbHVkZSAid3BzL3dwc19kZWZzLmgiCiAjaW5jbHVkZSAid3BzL3dwcy5oIgorI2luY2x1ZGUgImNvbmZpZ19maWxlLmgiCiAjaW5jbHVkZSAiY3RybF9pZmFjZS5oIgogCiAKQEAgLTE1MiwxNzMgKzE1Myw2IEBACiB9CiAKIAotI2lmZGVmIENPTkZJR19QMlBfTUFOQUdFUgotc3RhdGljIGludCBwMnBfbWFuYWdlcl9kaXNjb25uZWN0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHUxNiBzdHlwZSwKLQkJCQkgIHU4IG1pbm9yX3JlYXNvbl9jb2RlLCBjb25zdCB1OCAqYWRkcikKLXsKLQlzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7Ci0JaW50IHJldDsKLQl1OCAqcG9zOwotCi0JaWYgKGhhcGQtPmRyaXZlci0+c2VuZF9mcmFtZSA9PSBOVUxMKQotCQlyZXR1cm4gLTE7Ci0KLQltZ210ID0gb3NfemFsbG9jKHNpemVvZigqbWdtdCkgKyAxMDApOwotCWlmIChtZ210ID09IE5VTEwpCi0JCXJldHVybiAtMTsKLQotCXdwYV9kYmcoaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiUDJQOiBEaXNjb25uZWN0IFNUQSAiIE1BQ1NUUgotCQkiIHdpdGggbWlub3IgcmVhc29uIGNvZGUgJXUgKHN0eXBlPSV1KSIsCi0JCU1BQzJTVFIoYWRkciksIG1pbm9yX3JlYXNvbl9jb2RlLCBzdHlwZSk7Ci0KLQltZ210LT5mcmFtZV9jb250cm9sID0gSUVFRTgwMjExX0ZDKFdMQU5fRkNfVFlQRV9NR01ULCBzdHlwZSk7Ci0Jb3NfbWVtY3B5KG1nbXQtPmRhLCBhZGRyLCBFVEhfQUxFTik7Ci0Jb3NfbWVtY3B5KG1nbXQtPnNhLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwotCW9zX21lbWNweShtZ210LT5ic3NpZCwgaGFwZC0+b3duX2FkZHIsIEVUSF9BTEVOKTsKLQlpZiAoc3R5cGUgPT0gV0xBTl9GQ19TVFlQRV9ERUFVVEgpIHsKLQkJbWdtdC0+dS5kZWF1dGgucmVhc29uX2NvZGUgPQotCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCQlwb3MgPSAodTggKikgKCZtZ210LT51LmRlYXV0aC5yZWFzb25fY29kZSArIDEpOwotCX0gZWxzZSB7Ci0JCW1nbXQtPnUuZGlzYXNzb2MucmVhc29uX2NvZGUgPQotCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCQlwb3MgPSAodTggKikgKCZtZ210LT51LmRpc2Fzc29jLnJlYXNvbl9jb2RlICsgMSk7Ci0JfQotCi0JKnBvcysrID0gV0xBTl9FSURfVkVORE9SX1NQRUNJRklDOwotCSpwb3MrKyA9IDQgKyAzICsgMTsKLQlXUEFfUFVUX0JFMjQocG9zLCBPVUlfV0ZBKTsKLQlwb3MgKz0gMzsKLQkqcG9zKysgPSBQMlBfT1VJX1RZUEU7Ci0KLQkqcG9zKysgPSBQMlBfQVRUUl9NSU5PUl9SRUFTT05fQ09ERTsKLQlXUEFfUFVUX0xFMTYocG9zLCAxKTsKLQlwb3MgKz0gMjsKLQkqcG9zKysgPSBtaW5vcl9yZWFzb25fY29kZTsKLQotCXJldCA9IGhhcGQtPmRyaXZlci0+c2VuZF9mcmFtZShoYXBkLT5kcnZfcHJpdiwgKHU4ICopIG1nbXQsCi0JCQkJICAgICAgIHBvcyAtICh1OCAqKSBtZ210LCAxKTsKLQlvc19mcmVlKG1nbXQpOwotCi0JcmV0dXJuIHJldCA8IDAgPyAtMSA6IDA7Ci19Ci0jZW5kaWYgLyogQ09ORklHX1AyUF9NQU5BR0VSICovCi0KLQotc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2VfZGVhdXRoZW50aWNhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKLQkJCQkJICAgICBjb25zdCBjaGFyICp0eHRhZGRyKQotewotCXU4IGFkZHJbRVRIX0FMRU5dOwotCXN0cnVjdCBzdGFfaW5mbyAqc3RhOwotCWNvbnN0IGNoYXIgKnBvczsKLQotCXdwYV9kYmcoaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBERUFVVEhFTlRJQ0FURSAlcyIsCi0JCXR4dGFkZHIpOwotCi0JaWYgKGh3YWRkcl9hdG9uKHR4dGFkZHIsIGFkZHIpKQotCQlyZXR1cm4gLTE7Ci0KLQlwb3MgPSBvc19zdHJzdHIodHh0YWRkciwgIiB0ZXN0PSIpOwotCWlmIChwb3MpIHsKLQkJc3RydWN0IGllZWU4MDIxMV9tZ210IG1nbXQ7Ci0JCWludCBlbmNyeXB0OwotCQlpZiAoaGFwZC0+ZHJpdmVyLT5zZW5kX2ZyYW1lID09IE5VTEwpCi0JCQlyZXR1cm4gLTE7Ci0JCXBvcyArPSA2OwotCQllbmNyeXB0ID0gYXRvaShwb3MpOwotCQlvc19tZW1zZXQoJm1nbXQsIDAsIHNpemVvZihtZ210KSk7Ci0JCW1nbXQuZnJhbWVfY29udHJvbCA9IElFRUU4MDIxMV9GQyhXTEFOX0ZDX1RZUEVfTUdNVCwKLQkJCQkJCSAgV0xBTl9GQ19TVFlQRV9ERUFVVEgpOwotCQlvc19tZW1jcHkobWdtdC5kYSwgYWRkciwgRVRIX0FMRU4pOwotCQlvc19tZW1jcHkobWdtdC5zYSwgaGFwZC0+b3duX2FkZHIsIEVUSF9BTEVOKTsKLQkJb3NfbWVtY3B5KG1nbXQuYnNzaWQsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7Ci0JCW1nbXQudS5kZWF1dGgucmVhc29uX2NvZGUgPQotCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCQlpZiAoaGFwZC0+ZHJpdmVyLT5zZW5kX2ZyYW1lKGhhcGQtPmRydl9wcml2LCAodTggKikgJm1nbXQsCi0JCQkJCSAgICAgSUVFRTgwMjExX0hEUkxFTiArCi0JCQkJCSAgICAgc2l6ZW9mKG1nbXQudS5kZWF1dGgpLAotCQkJCQkgICAgIGVuY3J5cHQpIDwgMCkKLQkJCXJldHVybiAtMTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0jaWZkZWYgQ09ORklHX1AyUF9NQU5BR0VSCi0JcG9zID0gb3Nfc3Ryc3RyKHR4dGFkZHIsICIgcDJwPSIpOwotCWlmIChwb3MpIHsKLQkJcmV0dXJuIHAycF9tYW5hZ2VyX2Rpc2Nvbm5lY3QoaGFwZCwgV0xBTl9GQ19TVFlQRV9ERUFVVEgsCi0JCQkJCSAgICAgIGF0b2kocG9zICsgNSksIGFkZHIpOwotCX0KLSNlbmRpZiAvKiBDT05GSUdfUDJQX01BTkFHRVIgKi8KLQotCWhvc3RhcGRfZHJ2X3N0YV9kZWF1dGgoaGFwZCwgYWRkciwgV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7Ci0Jc3RhID0gYXBfZ2V0X3N0YShoYXBkLCBhZGRyKTsKLQlpZiAoc3RhKQotCQlhcF9zdGFfZGVhdXRoZW50aWNhdGUoaGFwZCwgc3RhLAotCQkJCSAgICAgIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCWVsc2UgaWYgKGFkZHJbMF0gPT0gMHhmZikKLQkJaG9zdGFwZF9mcmVlX3N0YXMoaGFwZCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV9kaXNhc3NvY2lhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKLQkJCQkJICAgY29uc3QgY2hhciAqdHh0YWRkcikKLXsKLQl1OCBhZGRyW0VUSF9BTEVOXTsKLQlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKLQljb25zdCBjaGFyICpwb3M7Ci0KLQl3cGFfZGJnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgRElTQVNTT0NJQVRFICVzIiwKLQkJdHh0YWRkcik7Ci0KLQlpZiAoaHdhZGRyX2F0b24odHh0YWRkciwgYWRkcikpCi0JCXJldHVybiAtMTsKLQotCXBvcyA9IG9zX3N0cnN0cih0eHRhZGRyLCAiIHRlc3Q9Iik7Ci0JaWYgKHBvcykgewotCQlzdHJ1Y3QgaWVlZTgwMjExX21nbXQgbWdtdDsKLQkJaW50IGVuY3J5cHQ7Ci0JCWlmIChoYXBkLT5kcml2ZXItPnNlbmRfZnJhbWUgPT0gTlVMTCkKLQkJCXJldHVybiAtMTsKLQkJcG9zICs9IDY7Ci0JCWVuY3J5cHQgPSBhdG9pKHBvcyk7Ci0JCW9zX21lbXNldCgmbWdtdCwgMCwgc2l6ZW9mKG1nbXQpKTsKLQkJbWdtdC5mcmFtZV9jb250cm9sID0gSUVFRTgwMjExX0ZDKFdMQU5fRkNfVFlQRV9NR01ULAotCQkJCQkJICBXTEFOX0ZDX1NUWVBFX0RJU0FTU09DKTsKLQkJb3NfbWVtY3B5KG1nbXQuZGEsIGFkZHIsIEVUSF9BTEVOKTsKLQkJb3NfbWVtY3B5KG1nbXQuc2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7Ci0JCW9zX21lbWNweShtZ210LmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOwotCQltZ210LnUuZGlzYXNzb2MucmVhc29uX2NvZGUgPQotCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCQlpZiAoaGFwZC0+ZHJpdmVyLT5zZW5kX2ZyYW1lKGhhcGQtPmRydl9wcml2LCAodTggKikgJm1nbXQsCi0JCQkJCSAgICAgSUVFRTgwMjExX0hEUkxFTiArCi0JCQkJCSAgICAgc2l6ZW9mKG1nbXQudS5kZWF1dGgpLAotCQkJCQkgICAgIGVuY3J5cHQpIDwgMCkKLQkJCXJldHVybiAtMTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0jaWZkZWYgQ09ORklHX1AyUF9NQU5BR0VSCi0JcG9zID0gb3Nfc3Ryc3RyKHR4dGFkZHIsICIgcDJwPSIpOwotCWlmIChwb3MpIHsKLQkJcmV0dXJuIHAycF9tYW5hZ2VyX2Rpc2Nvbm5lY3QoaGFwZCwgV0xBTl9GQ19TVFlQRV9ESVNBU1NPQywKLQkJCQkJICAgICAgYXRvaShwb3MgKyA1KSwgYWRkcik7Ci0JfQotI2VuZGlmIC8qIENPTkZJR19QMlBfTUFOQUdFUiAqLwotCi0JaG9zdGFwZF9kcnZfc3RhX2Rpc2Fzc29jKGhhcGQsIGFkZHIsIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgYWRkcik7Ci0JaWYgKHN0YSkKLQkJYXBfc3RhX2Rpc2Fzc29jaWF0ZShoYXBkLCBzdGEsCi0JCQkJICAgIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOwotCWVsc2UgaWYgKGFkZHJbMF0gPT0gMHhmZikKLQkJaG9zdGFwZF9mcmVlX3N0YXMoaGFwZCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCiAjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVcKICNpZmRlZiBORUVEX0FQX01MTUUKIHN0YXRpYyBpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX3NhX3F1ZXJ5KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCkBAIC00NDAsNiArMjc0LDExMSBAQAogI2VuZGlmIC8qIENPTkZJR19XUFNfT09CICovCiAKIAorI2lmZGVmIENPTkZJR19XUFNfTkZDCitzdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV93cHNfbmZjX3RhZ19yZWFkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgICAgICBjaGFyICpwb3MpCit7CisJc2l6ZV90IGxlbjsKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJldDsKKworCWxlbiA9IG9zX3N0cmxlbihwb3MpOworCWlmIChsZW4gJiAweDAxKQorCQlyZXR1cm4gLTE7CisJbGVuIC89IDI7CisKKwlidWYgPSB3cGFidWZfYWxsb2MobGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlpZiAoaGV4c3RyMmJpbihwb3MsIHdwYWJ1Zl9wdXQoYnVmLCBsZW4pLCBsZW4pIDwgMCkgeworCQl3cGFidWZfZnJlZShidWYpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0ID0gaG9zdGFwZF93cHNfbmZjX3RhZ19yZWFkKGhhcGQsIGJ1Zik7CisJd3BhYnVmX2ZyZWUoYnVmKTsKKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2Vfd3BzX25mY19jb25maWdfdG9rZW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJCSAgIGNoYXIgKmNtZCwgY2hhciAqcmVwbHksCisJCQkJCQkgICBzaXplX3QgbWF4X2xlbikKK3sKKwlpbnQgbmRlZjsKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJlczsKKworCWlmIChvc19zdHJjbXAoY21kLCAiV1BTIikgPT0gMCkKKwkJbmRlZiA9IDA7CisJZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIk5ERUYiKSA9PSAwKQorCQluZGVmID0gMTsKKwllbHNlCisJCXJldHVybiAtMTsKKworCWJ1ZiA9IGhvc3RhcGRfd3BzX25mY19jb25maWdfdG9rZW4oaGFwZCwgbmRlZik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlyZXMgPSB3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShyZXBseSwgbWF4X2xlbiwgd3BhYnVmX2hlYWQoYnVmKSwKKwkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CisJcmVwbHlbcmVzKytdID0gJ1xuJzsKKwlyZXBseVtyZXNdID0gJ1wwJzsKKworCXdwYWJ1Zl9mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmVzOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX3dwc19uZmNfdG9rZW5fZ2VuKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCQljaGFyICpyZXBseSwgc2l6ZV90IG1heF9sZW4sCisJCQkJCQlpbnQgbmRlZikKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJlczsKKworCWJ1ZiA9IGhvc3RhcGRfd3BzX25mY190b2tlbl9nZW4oaGFwZCwgbmRlZik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlyZXMgPSB3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShyZXBseSwgbWF4X2xlbiwgd3BhYnVmX2hlYWQoYnVmKSwKKwkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CisJcmVwbHlbcmVzKytdID0gJ1xuJzsKKwlyZXBseVtyZXNdID0gJ1wwJzsKKworCXdwYWJ1Zl9mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmVzOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX3dwc19uZmNfdG9rZW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJICAgIGNoYXIgKmNtZCwgY2hhciAqcmVwbHksCisJCQkJCSAgICBzaXplX3QgbWF4X2xlbikKK3sKKwlpZiAob3Nfc3RyY21wKGNtZCwgIldQUyIpID09IDApCisJCXJldHVybiBob3N0YXBkX2N0cmxfaWZhY2Vfd3BzX25mY190b2tlbl9nZW4oaGFwZCwgcmVwbHksCisJCQkJCQkJICAgIG1heF9sZW4sIDApOworCisJaWYgKG9zX3N0cmNtcChjbWQsICJOREVGIikgPT0gMCkKKwkJcmV0dXJuIGhvc3RhcGRfY3RybF9pZmFjZV93cHNfbmZjX3Rva2VuX2dlbihoYXBkLCByZXBseSwKKwkJCQkJCQkgICAgbWF4X2xlbiwgMSk7CisKKwlpZiAob3Nfc3RyY21wKGNtZCwgImVuYWJsZSIpID09IDApCisJCXJldHVybiBob3N0YXBkX3dwc19uZmNfdG9rZW5fZW5hYmxlKGhhcGQpOworCisJaWYgKG9zX3N0cmNtcChjbWQsICJkaXNhYmxlIikgPT0gMCkgeworCQlob3N0YXBkX3dwc19uZmNfdG9rZW5fZGlzYWJsZShoYXBkKTsKKwkJcmV0dXJuIDA7CisJfQorCisJcmV0dXJuIC0xOworfQorI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCisKKwogc3RhdGljIGludCBob3N0YXBkX2N0cmxfaWZhY2Vfd3BzX2FwX3BpbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjaGFyICp0eHQsCiAJCQkJCSBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCiB7CkBAIC03NzMsOCArNzEyLDE2IEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBUZXN0aW5nIC0gZHVtbXlfY3JlZD0lZCIsCiAJCQkgICB3cHNfdGVzdGluZ19kdW1teV9jcmVkKTsKICNlbmRpZiAvKiBDT05GSUdfV1BTX1RFU1RJTkcgKi8KKyNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCisJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImdhc19mcmFnX2xpbWl0IikgPT0gMCkgeworCQlpbnQgdmFsID0gYXRvaSh2YWx1ZSk7CisJCWlmICh2YWwgPD0gMCkKKwkJCXJldCA9IC0xOworCQllbHNlCisJCQloYXBkLT5nYXNfZnJhZ19saW1pdCA9IHZhbDsKKyNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCiAJfSBlbHNlIHsKLQkJcmV0ID0gLTE7CisJCXJldCA9IGhvc3RhcGRfc2V0X2lmYWNlKGhhcGQtPmljb25mLCBoYXBkLT5jb25mLCBjbWQsIHZhbHVlKTsKIAl9CiAKIAlyZXR1cm4gcmV0OwpAQCAtOTEzLDYgKzg2MCw5IEBACiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiV1BTX1BCQyIpID09IDApIHsKIAkJaWYgKGhvc3RhcGRfd3BzX2J1dHRvbl9wdXNoZWQoaGFwZCwgTlVMTCkpCiAJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJXUFNfQ0FOQ0VMIikgPT0gMCkgeworCQlpZiAoaG9zdGFwZF93cHNfY2FuY2VsKGhhcGQpKQorCQkJcmVwbHlfbGVuID0gLTE7CiAjaWZkZWYgQ09ORklHX1dQU19PT0IKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX09PQiAiLCA4KSA9PSAwKSB7CiAJCWlmIChob3N0YXBkX2N0cmxfaWZhY2Vfd3BzX29vYihoYXBkLCBidWYgKyA4KSkKQEAgLTkyNCw2ICs4NzQsMTcgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX0NPTkZJRyAiLCAxMSkgPT0gMCkgewogCQlpZiAoaG9zdGFwZF9jdHJsX2lmYWNlX3dwc19jb25maWcoaGFwZCwgYnVmICsgMTEpIDwgMCkKIAkJCXJlcGx5X2xlbiA9IC0xOworI2lmZGVmIENPTkZJR19XUFNfTkZDCisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19ORkNfVEFHX1JFQUQgIiwgMTcpID09IDApIHsKKwkJaWYgKGhvc3RhcGRfY3RybF9pZmFjZV93cHNfbmZjX3RhZ19yZWFkKGhhcGQsIGJ1ZiArIDE3KSkKKwkJCXJlcGx5X2xlbiA9IC0xOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX0NPTkZJR19UT0tFTiAiLCAyMSkgPT0gMCkgeworCQlyZXBseV9sZW4gPSBob3N0YXBkX2N0cmxfaWZhY2Vfd3BzX25mY19jb25maWdfdG9rZW4oCisJCQloYXBkLCBidWYgKyAyMSwgcmVwbHksIHJlcGx5X3NpemUpOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX1RPS0VOICIsIDE0KSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IGhvc3RhcGRfY3RybF9pZmFjZV93cHNfbmZjX3Rva2VuKAorCQkJaGFwZCwgYnVmICsgMTQsIHJlcGx5LCByZXBseV9zaXplKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiRVNTX0RJU0FTU09DICIsIDEzKSA9PSAwKSB7CiAJCWlmIChob3N0YXBkX2N0cmxfaWZhY2VfZXNzX2Rpc2Fzc29jKGhhcGQsIGJ1ZiArIDEzKSkKQEAgLTk4OCw3ICs5NDksMTAgQEAKIAlpbnQgcyA9IC0xOwogCWNoYXIgKmZuYW1lID0gTlVMTDsKIAotCWhhcGQtPmN0cmxfc29jayA9IC0xOworCWlmIChoYXBkLT5jdHJsX3NvY2sgPiAtMSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN0cmxfaWZhY2UgYWxyZWFkeSBleGlzdHMhIik7CisJCXJldHVybiAwOworCX0KIAogCWlmIChoYXBkLT5jb25mLT5jdHJsX2ludGVyZmFjZSA9PSBOVUxMKQogCQlyZXR1cm4gMDsKQEAgLTEwNDUsNyArMTAwOSw3IEBACiAJCQl9CiAJCQlpZiAoYmluZChzLCAoc3RydWN0IHNvY2thZGRyICopICZhZGRyLCBzaXplb2YoYWRkcikpIDwKIAkJCSAgICAwKSB7Ci0JCQkJcGVycm9yKCJiaW5kKFBGX1VOSVgpIik7CisJCQkJcGVycm9yKCJob3N0YXBkLWN0cmwtaWZhY2U6IGJpbmQoUEZfVU5JWCkiKTsKIAkJCQlnb3RvIGZhaWw7CiAJCQl9CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN1Y2Nlc3NmdWxseSByZXBsYWNlZCBsZWZ0b3ZlciAiCmRpZmYgLS1naXQgYS9ob3N0YXBkL2RlZmNvbmZpZyBiL2hvc3RhcGQvZGVmY29uZmlnCmluZGV4IDNjZjBkMTMuLjljNWIxM2EgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvZGVmY29uZmlnCisrKyBiL2hvc3RhcGQvZGVmY29uZmlnCkBAIC0xMDgsNiArMTA4LDggQEAKICNDT05GSUdfV1BTMj15CiAjIEVuYWJsZSBVUG5QIHN1cHBvcnQgZm9yIGV4dGVybmFsIFdQUyBSZWdpc3RyYXJzCiAjQ09ORklHX1dQU19VUE5QPXkKKyMgRW5hYmxlIFdQUyBzdXBwb3J0IHdpdGggTkZDIGNvbmZpZyBtZXRob2QKKyNDT05GSUdfV1BTX05GQz15CiAKICMgRUFQLUlLRXYyCiAjQ09ORklHX0VBUF9JS0VWMj15CkBAIC0xMzYsNiArMTM4LDEzIEBACiAjIElFRUUgODAyLjExbiAoSGlnaCBUaHJvdWdocHV0KSBzdXBwb3J0CiAjQ09ORklHX0lFRUU4MDIxMU49eQogCisjIFdpcmVsZXNzIE5ldHdvcmsgTWFuYWdlbWVudCAoSUVFRSBTdGQgODAyLjExdi0yMDExKQorIyBOb3RlOiBUaGlzIGlzIGV4cGVyaW1lbnRhbCBhbmQgbm90IGNvbXBsZXRlIGltcGxlbWVudGF0aW9uLgorI0NPTkZJR19XTk09eQorCisjIElFRUUgODAyLjExYWMgKFZlcnkgSGlnaCBUaHJvdWdocHV0KSBzdXBwb3J0CisjQ09ORklHX0lFRUU4MDIxMUFDPXkKKwogIyBSZW1vdmUgZGVidWdnaW5nIGNvZGUgdGhhdCBpcyBwcmludGluZyBvdXQgZGVidWcgbWVzc2FnZXMgdG8gc3Rkb3V0LgogIyBUaGlzIGNhbiBiZSB1c2VkIHRvIHJlZHVjZSB0aGUgc2l6ZSBvZiB0aGUgaG9zdGFwZCBjb25zaWRlcmFibHkgaWYgZGVidWdnaW5nCiAjIGNvZGUgaXMgbm90IG5lZWRlZC4KZGlmZiAtLWdpdCBhL2hvc3RhcGQvaGxyX2F1Y19ndy5jIGIvaG9zdGFwZC9obHJfYXVjX2d3LmMKaW5kZXggYjU5ZWExYi4uNTE2ZDg1OSAxMDA2NDQKLS0tIGEvaG9zdGFwZC9obHJfYXVjX2d3LmMKKysrIGIvaG9zdGFwZC9obHJfYXVjX2d3LmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogSExSL0F1QyB0ZXN0aW5nIGdhdGV3YXkgZm9yIGhvc3RhcGQgRUFQLVNJTS9BS0EgZGF0YWJhc2UvYXV0aGVudGljYXRvcgotICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDcsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNywgMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMzQsNyArMzQsMTEgQEAKICAqIHRleHQgZmlsZSBpbiBJTVNJOktjOlNSRVM6UkFORCBmb3JtYXQsIElNU0kgaW4gQVNDSUksIG90aGVyIGZpZWxkcyBhcyBoZXgKICAqIHN0cmluZ3MuIFRoaXMgaXMgdXNlZCB0byBzaW11bGF0ZSBhbiBITFIvQXVDLiBBcyBzdWNoLCBpdCBpcyBub3QgdmVyeSB1c2VmdWwKICAqIGZvciByZWFsIGxpZmUgYXV0aGVudGljYXRpb24sIGJ1dCBpdCBpcyB1c2VmdWwgYm90aCBhcyBhbiBleGFtcGxlCi0gKiBpbXBsZW1lbnRhdGlvbiBhbmQgZm9yIEVBUC1TSU0gdGVzdGluZy4KKyAqIGltcGxlbWVudGF0aW9uIGFuZCBmb3IgRUFQLVNJTS9BS0EvQUtBJyB0ZXN0aW5nLgorICoKKyAqIFNRTiBnZW5lcmF0aW9uIGZvbGxvd3MgdGhlIG5vdCB0aW1lLWJhc2VkIFByb2ZpbGUgMiBkZXNjcmliZWQgaW4KKyAqIDNHUFAgVFMgMzMuMTAyIEFubmV4IEMuMy4yLiBUaGUgbGVuZ3RoIG9mIElORCBpcyA1IGJpdHMgYnkgZGVmYXVsdCwgYnV0IHRoaXMKKyAqIGNhbiBiZSBjaGFuZ2VkIHdpdGggYSBjb21tYW5kIGxpbmUgb3B0aW9ucyBpZiBuZWVkZWQuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC00Nyw2ICs1MSwxMCBAQAogc3RhdGljIGNvbnN0IGNoYXIgKmRlZmF1bHRfc29ja2V0X3BhdGggPSAiL3RtcC9obHJfYXVjX2d3LnNvY2siOwogc3RhdGljIGNvbnN0IGNoYXIgKnNvY2tldF9wYXRoOwogc3RhdGljIGludCBzZXJ2X3NvY2sgPSAtMTsKK3N0YXRpYyBjaGFyICptaWxlbmFnZV9maWxlID0gTlVMTDsKK3N0YXRpYyBpbnQgdXBkYXRlX21pbGVuYWdlID0gMDsKK3N0YXRpYyBpbnQgc3FuX2NoYW5nZXMgPSAwOworc3RhdGljIGludCBpbmRfbGVuID0gNTsKIAogLyogR1NNIHRyaXBsZXRzICovCiBzdHJ1Y3QgZ3NtX3RyaXBsZXQgewpAQCAtOTYsNyArMTA0LDcgQEAKIAlhZGRyLnN1bl9mYW1pbHkgPSBBRl9VTklYOwogCW9zX3N0cmxjcHkoYWRkci5zdW5fcGF0aCwgcGF0aCwgc2l6ZW9mKGFkZHIuc3VuX3BhdGgpKTsKIAlpZiAoYmluZChzLCAoc3RydWN0IHNvY2thZGRyICopICZhZGRyLCBzaXplb2YoYWRkcikpIDwgMCkgewotCQlwZXJyb3IoImJpbmQoUEZfVU5JWCkiKTsKKwkJcGVycm9yKCJobHItYXVjLWd3OiBiaW5kKFBGX1VOSVgpIik7CiAJCWNsb3NlKHMpOwogCQlyZXR1cm4gLTE7CiAJfQpAQCAtMjEwLDcgKzIxOCw3IEBACiAJCWdzbV9kYiA9IGc7CiAJCWcgPSBOVUxMOwogCX0KLQlmcmVlKGcpOworCW9zX2ZyZWUoZyk7CiAKIAlmY2xvc2UoZik7CiAKQEAgLTM2MCw3ICszNjgsNyBAQAogCQltaWxlbmFnZV9kYiA9IG07CiAJCW0gPSBOVUxMOwogCX0KLQlmcmVlKG0pOworCW9zX2ZyZWUobSk7CiAKIAlmY2xvc2UoZik7CiAKQEAgLTM2OCw2ICszNzYsODAgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB1cGRhdGVfbWlsZW5hZ2VfZmlsZShjb25zdCBjaGFyICpmbmFtZSkKK3sKKwlGSUxFICpmLCAqZjI7CisJY2hhciBidWZbNTAwXSwgKnBvczsKKwljaGFyICplbmQgPSBidWYgKyBzaXplb2YoYnVmKTsKKwlzdHJ1Y3QgbWlsZW5hZ2VfcGFyYW1ldGVycyAqbTsKKwlzaXplX3QgaW1zaV9sZW47CisKKwlmID0gZm9wZW4oZm5hbWUsICJyIik7CisJaWYgKGYgPT0gTlVMTCkgeworCQlwcmludGYoIkNvdWxkIG5vdCBvcGVuIE1pbGVuYWdlIGRhdGEgZmlsZSAnJXMnXG4iLCBmbmFtZSk7CisJCXJldHVybjsKKwl9CisKKwlzbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiJXMubmV3IiwgZm5hbWUpOworCWYyID0gZm9wZW4oYnVmLCAidyIpOworCWlmIChmMiA9PSBOVUxMKSB7CisJCXByaW50ZigiQ291bGQgbm90IHdyaXRlIE1pbGVuYWdlIGRhdGEgZmlsZSAnJXMnXG4iLCBidWYpOworCQlmY2xvc2UoZik7CisJCXJldHVybjsKKwl9CisKKwl3aGlsZSAoZmdldHMoYnVmLCBzaXplb2YoYnVmKSwgZikpIHsKKwkJLyogSU1TSSBLaSBPUGMgQU1GIFNRTiAqLworCQlidWZbc2l6ZW9mKGJ1ZikgLSAxXSA9ICdcMCc7CisKKwkJcG9zID0gc3RyY2hyKGJ1ZiwgJyAnKTsKKwkJaWYgKGJ1ZlswXSA9PSAnIycgfHwgcG9zID09IE5VTEwgfHwgcG9zIC0gYnVmID49IDIwKQorCQkJZ290byBub191cGRhdGU7CisKKwkJaW1zaV9sZW4gPSBwb3MgLSBidWY7CisKKwkJZm9yIChtID0gbWlsZW5hZ2VfZGI7IG07IG0gPSBtLT5uZXh0KSB7CisJCQlpZiAoc3RybmNtcChidWYsIG0tPmltc2ksIGltc2lfbGVuKSA9PSAwICYmCisJCQkgICAgbS0+aW1zaVtpbXNpX2xlbl0gPT0gJ1wwJykKKwkJCQlicmVhazsKKwkJfQorCisJCWlmICghbSkKKwkJCWdvdG8gbm9fdXBkYXRlOworCisJCXBvcyA9IGJ1ZjsKKwkJcG9zICs9IHNucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXMgIiwgbS0+aW1zaSk7CisJCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCBtLT5raSwgMTYpOworCQkqcG9zKysgPSAnICc7CisJCXBvcyArPSB3cGFfc25wcmludGZfaGV4KHBvcywgZW5kIC0gcG9zLCBtLT5vcGMsIDE2KTsKKwkJKnBvcysrID0gJyAnOworCQlwb3MgKz0gd3BhX3NucHJpbnRmX2hleChwb3MsIGVuZCAtIHBvcywgbS0+YW1mLCAyKTsKKwkJKnBvcysrID0gJyAnOworCQlwb3MgKz0gd3BhX3NucHJpbnRmX2hleChwb3MsIGVuZCAtIHBvcywgbS0+c3FuLCA2KTsKKwkJKnBvcysrID0gJ1xuJzsKKworCW5vX3VwZGF0ZToKKwkJZnByaW50ZihmMiwgIiVzIiwgYnVmKTsKKwl9CisKKwlmY2xvc2UoZjIpOworCWZjbG9zZShmKTsKKworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlcy5iYWsiLCBmbmFtZSk7CisJaWYgKHJlbmFtZShmbmFtZSwgYnVmKSA8IDApIHsKKwkJcGVycm9yKCJyZW5hbWUiKTsKKwkJcmV0dXJuOworCX0KKworCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlcy5uZXciLCBmbmFtZSk7CisJaWYgKHJlbmFtZShidWYsIGZuYW1lKSA8IDApIHsKKwkJcGVycm9yKCJyZW5hbWUiKTsKKwkJcmV0dXJuOworCX0KKworfQorCisKIHN0YXRpYyBzdHJ1Y3QgbWlsZW5hZ2VfcGFyYW1ldGVycyAqIGdldF9taWxlbmFnZShjb25zdCBjaGFyICppbXNpKQogewogCXN0cnVjdCBtaWxlbmFnZV9wYXJhbWV0ZXJzICptID0gbWlsZW5hZ2VfZGI7CkBAIC00NjAsNiArNTQyLDI4IEBACiB9CiAKIAorc3RhdGljIHZvaWQgaW5jX3Nxbih1OCAqc3FuKQoreworCXU2NCB2YWwsIHNlcSwgaW5kOworCisJLyoKKwkgKiBTUU4gPSBTRVEgfCBJTkQgPSBTRVExIHwgU0VRMiB8IElORAorCSAqCisJICogVGhlIG1lY2hhbmlzbSB1c2VkIGhlcmUgaXMgbm90IHRpbWUtYmFzZWQsIHNvIFNFUTIgaXMgdm9pZCBhbmQKKwkgKiBTUU4gPSBTRVExIHwgSU5ELiBUaGUgbGVuZ3RoIG9mIElORCBpcyBpbmRfbGVuIGJpdHMgYW5kIHRoZSBsZW5ndGgKKwkgKiBvZiBTRVExIGlzIDQ4IC0gaW5kX2xlbiBiaXRzLgorCSAqLworCisJLyogSW5jcmVtZW50IGJvdGggU0VRIGFuZCBJTkQgYnkgb25lICovCisJdmFsID0gKCh1NjQpIFdQQV9HRVRfQkUzMihzcW4pIDw8IDE2KSB8ICgodTY0KSBXUEFfR0VUX0JFMTYoc3FuICsgNCkpOworCXNlcSA9ICh2YWwgPj4gaW5kX2xlbikgKyAxOworCWluZCA9ICh2YWwgKyAxKSAmICgoMSA8PCBpbmRfbGVuKSAtIDEpOworCXZhbCA9IChzZXEgPDwgaW5kX2xlbikgfCBpbmQ7CisJV1BBX1BVVF9CRTMyKHNxbiwgdmFsID4+IDE2KTsKKwlXUEFfUFVUX0JFMTYoc3FuICsgNCwgdmFsICYgMHhmZmZmKTsKK30KKworCiBzdGF0aWMgdm9pZCBha2FfcmVxX2F1dGgoaW50IHMsIHN0cnVjdCBzb2NrYWRkcl91biAqZnJvbSwgc29ja2xlbl90IGZyb21sZW4sCiAJCQkgY2hhciAqaW1zaSkKIHsKQEAgLTQ3OSw3ICs1ODMsOCBAQAogCQlpZiAocmFuZG9tX2dldF9ieXRlcyhfcmFuZCwgRUFQX0FLQV9SQU5EX0xFTikgPCAwKQogCQkJcmV0dXJuOwogCQlyZXNfbGVuID0gRUFQX0FLQV9SRVNfTUFYX0xFTjsKLQkJaW5jX2J5dGVfYXJyYXkobS0+c3FuLCA2KTsKKwkJaW5jX3NxbihtLT5zcW4pOworCQlzcW5fY2hhbmdlcyA9IDE7CiAJCXByaW50ZigiQUtBOiBNaWxlbmFnZSB3aXRoIFNRTj0lMDJ4JTAyeCUwMnglMDJ4JTAyeCUwMnhcbiIsCiAJCSAgICAgICBtLT5zcW5bMF0sIG0tPnNxblsxXSwgbS0+c3FuWzJdLAogCQkgICAgICAgbS0+c3FuWzNdLCBtLT5zcW5bNF0sIG0tPnNxbls1XSk7CkBAIC01NjMsNiArNjY4LDcgQEAKIAkJcHJpbnRmKCJBS0EtQVVUUzogUmUtc3luY2hyb25pemVkOiAiCiAJCSAgICAgICAiU1FOPSUwMnglMDJ4JTAyeCUwMnglMDJ4JTAyeFxuIiwKIAkJICAgICAgIHNxblswXSwgc3FuWzFdLCBzcW5bMl0sIHNxblszXSwgc3FuWzRdLCBzcW5bNV0pOworCQlzcW5fY2hhbmdlcyA9IDE7CiAJfQogfQogCkBAIC02MDksMTggKzcxNSwyMSBAQAogCXN0cnVjdCBnc21fdHJpcGxldCAqZywgKmdwcmV2OwogCXN0cnVjdCBtaWxlbmFnZV9wYXJhbWV0ZXJzICptLCAqcHJldjsKIAorCWlmICh1cGRhdGVfbWlsZW5hZ2UgJiYgbWlsZW5hZ2VfZmlsZSAmJiBzcW5fY2hhbmdlcykKKwkJdXBkYXRlX21pbGVuYWdlX2ZpbGUobWlsZW5hZ2VfZmlsZSk7CisKIAlnID0gZ3NtX2RiOwogCXdoaWxlIChnKSB7CiAJCWdwcmV2ID0gZzsKIAkJZyA9IGctPm5leHQ7Ci0JCWZyZWUoZ3ByZXYpOworCQlvc19mcmVlKGdwcmV2KTsKIAl9CiAKIAltID0gbWlsZW5hZ2VfZGI7CiAJd2hpbGUgKG0pIHsKIAkJcHJldiA9IG07CiAJCW0gPSBtLT5uZXh0OwotCQlmcmVlKHByZXYpOworCQlvc19mcmVlKHByZXYpOwogCX0KIAogCWNsb3NlKHNlcnZfc29jayk7CkBAIC02MzksMTggKzc0OCwyMSBAQAogewogCXByaW50ZigiSExSL0F1QyB0ZXN0aW5nIGdhdGV3YXkgZm9yIGhvc3RhcGQgRUFQLVNJTS9BS0EgIgogCSAgICAgICAiZGF0YWJhc2UvYXV0aGVudGljYXRvclxuIgotCSAgICAgICAiQ29weXJpZ2h0IChjKSAyMDA1LTIwMDcsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+XG4iCisJICAgICAgICJDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNywgMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT5cbiIKIAkgICAgICAgIlxuIgogCSAgICAgICAidXNhZ2U6XG4iCi0JICAgICAgICJobHJfYXVjX2d3IFstaF0gWy1zPHNvY2tldCBwYXRoPl0gWy1nPHRyaXBsZXQgZmlsZT5dICIKLQkgICAgICAgIlstbTxtaWxlbmFnZSBmaWxlPl1cbiIKKwkgICAgICAgImhscl9hdWNfZ3cgWy1odV0gWy1zPHNvY2tldCBwYXRoPl0gWy1nPHRyaXBsZXQgZmlsZT5dICIKKwkgICAgICAgIlstbTxtaWxlbmFnZSBmaWxlPl0gXFxcbiIKKwkgICAgICAgIiAgICAgICAgWy1pPElORCBsZW4gaW4gYml0cz5dXG4iCiAJICAgICAgICJcbiIKIAkgICAgICAgIm9wdGlvbnM6XG4iCiAJICAgICAgICIgIC1oID0gc2hvdyB0aGlzIHVzYWdlIGhlbHBcbiIKKwkgICAgICAgIiAgLXUgPSB1cGRhdGUgU1FOIGluIE1pbGVuYWdlIGZpbGUgb24gZXhpdFxuIgogCSAgICAgICAiICAtczxzb2NrZXQgcGF0aD4gPSBwYXRoIGZvciBVTklYIGRvbWFpbiBzb2NrZXRcbiIKIAkgICAgICAgIiAgICAgICAgICAgICAgICAgICAgKGRlZmF1bHQ6ICVzKVxuIgogCSAgICAgICAiICAtZzx0cmlwbGV0IGZpbGU+ID0gcGF0aCBmb3IgR1NNIGF1dGhlbnRpY2F0aW9uIHRyaXBsZXRzXG4iCi0JICAgICAgICIgIC1tPG1pbGVuYWdlIGZpbGU+ID0gcGF0aCBmb3IgTWlsZW5hZ2Uga2V5c1xuIiwKKwkgICAgICAgIiAgLW08bWlsZW5hZ2UgZmlsZT4gPSBwYXRoIGZvciBNaWxlbmFnZSBrZXlzXG4iCisJICAgICAgICIgIC1pPElORCBsZW4gaW4gYml0cz4gPSBJTkQgbGVuZ3RoIGZvciBTUU4gKGRlZmF1bHQ6IDUpXG4iLAogCSAgICAgICBkZWZhdWx0X3NvY2tldF9wYXRoKTsKIH0KIApAQCAtNjU4LDEzICs3NzAsMTUgQEAKIGludCBtYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pCiB7CiAJaW50IGM7Ci0JY2hhciAqbWlsZW5hZ2VfZmlsZSA9IE5VTEw7CiAJY2hhciAqZ3NtX3RyaXBsZXRfZmlsZSA9IE5VTEw7CiAKKwlpZiAob3NfcHJvZ3JhbV9pbml0KCkpCisJCXJldHVybiAtMTsKKwogCXNvY2tldF9wYXRoID0gZGVmYXVsdF9zb2NrZXRfcGF0aDsKIAogCWZvciAoOzspIHsKLQkJYyA9IGdldG9wdChhcmdjLCBhcmd2LCAiZzpobTpzOiIpOworCQljID0gZ2V0b3B0KGFyZ2MsIGFyZ3YsICJnOmhpOm06czp1Iik7CiAJCWlmIChjIDwgMCkKIAkJCWJyZWFrOwogCQlzd2l0Y2ggKGMpIHsKQEAgLTY3NCwxMiArNzg4LDIyIEBACiAJCWNhc2UgJ2gnOgogCQkJdXNhZ2UoKTsKIAkJCXJldHVybiAwOworCQljYXNlICdpJzoKKwkJCWluZF9sZW4gPSBhdG9pKG9wdGFyZyk7CisJCQlpZiAoaW5kX2xlbiA8IDAgfHwgaW5kX2xlbiA+IDMyKSB7CisJCQkJcHJpbnRmKCJJbnZhbGlkIElORCBsZW5ndGhcbiIpOworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJCWJyZWFrOwogCQljYXNlICdtJzoKIAkJCW1pbGVuYWdlX2ZpbGUgPSBvcHRhcmc7CiAJCQlicmVhazsKIAkJY2FzZSAncyc6CiAJCQlzb2NrZXRfcGF0aCA9IG9wdGFyZzsKIAkJCWJyZWFrOworCQljYXNlICd1JzoKKwkJCXVwZGF0ZV9taWxlbmFnZSA9IDE7CisJCQlicmVhazsKIAkJZGVmYXVsdDoKIAkJCXVzYWdlKCk7CiAJCQlyZXR1cm4gLTE7CkBAIC03MDUsNSArODI5LDcgQEAKIAlmb3IgKDs7KQogCQlwcm9jZXNzKHNlcnZfc29jayk7CiAKKwlvc19wcm9ncmFtX2RlaW5pdCgpOworCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9ob3N0YXBkL2hvc3RhcGQuY29uZiBiL2hvc3RhcGQvaG9zdGFwZC5jb25mCmluZGV4IDRlNjIwMmIuLmRhYTAzZDIgMTAwNjQ0Ci0tLSBhL2hvc3RhcGQvaG9zdGFwZC5jb25mCisrKyBiL2hvc3RhcGQvaG9zdGFwZC5jb25mCkBAIC00MTYsNiArNDE2LDEzNyBAQAogIyBSZXF1aXJlIHN0YXRpb25zIHRvIHN1cHBvcnQgSFQgUEhZIChyZWplY3QgYXNzb2NpYXRpb24gaWYgdGhleSBkbyBub3QpCiAjcmVxdWlyZV9odD0xCiAKKyMjIyMjIElFRUUgODAyLjExYWMgcmVsYXRlZCBjb25maWd1cmF0aW9uICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKworIyBpZWVlODAyMTFhYzogV2hldGhlciBJRUVFIDgwMi4xMWFjIChWSFQpIGlzIGVuYWJsZWQKKyMgMCA9IGRpc2FibGVkIChkZWZhdWx0KQorIyAxID0gZW5hYmxlZAorIyBOb3RlOiBZb3Ugd2lsbCBhbHNvIG5lZWQgdG8gZW5hYmxlIFdNTSBmb3IgZnVsbCBWSFQgZnVuY3Rpb25hbGl0eS4KKyNpZWVlODAyMTFhYz0xCisKKyMgdmh0X2NhcGFiOiBWSFQgY2FwYWJpbGl0aWVzIChsaXN0IG9mIGZsYWdzKQorIworIyB2aHRfbWF4X21wZHVfbGVuOiBbTUFYLU1QRFUtNzk5MV0gW01BWC1NUERVLTExNDU0XQorIyBJbmRpY2F0ZXMgbWF4aW11bSBNUERVIGxlbmd0aAorIyAwID0gMzg5NSBvY3RldHMgKGRlZmF1bHQpCisjIDEgPSA3OTkxIG9jdGV0cworIyAyID0gMTE0NTQgb2N0ZXRzCisjIDMgPSByZXNlcnZlZAorIworIyBzdXBwb3J0ZWRfY2hhbl93aWR0aDogW1ZIVDE2MF0gW1ZIVDE2MC04MFBMVVM4MF0KKyMgSW5kaWNhdGVzIHN1cHBvcnRlZCBDaGFubmVsIHdpZHRocworIyAwID0gMTYwIE1IeiAmIDgwKzgwIGNoYW5uZWwgd2lkdGhzIGFyZSBub3Qgc3VwcG9ydGVkIChkZWZhdWx0KQorIyAxID0gMTYwIE1IeiBjaGFubmVsIHdpZHRoIGlzIHN1cHBvcnRlZAorIyAyID0gMTYwIE1IeiAmIDgwKzgwIGNoYW5uZWwgd2lkdGhzIGFyZSBzdXBwb3J0ZWQKKyMgMyA9IHJlc2VydmVkCisjCisjIFJ4IExEUEMgY29kaW5nIGNhcGFiaWxpdHk6IFtSWExEUENdCisjIEluZGljYXRlcyBzdXBwb3J0IGZvciByZWNlaXZpbmcgTERQQyBjb2RlZCBwa3RzCisjIDAgPSBOb3Qgc3VwcG9ydGVkIChkZWZhdWx0KQorIyAxID0gU3VwcG9ydGVkCisjCisjIFNob3J0IEdJIGZvciA4MCBNSHo6IFtTSE9SVC1HSS04MF0KKyMgSW5kaWNhdGVzIHNob3J0IEdJIHN1cHBvcnQgZm9yIHJlY2VwdGlvbiBvZiBwYWNrZXRzIHRyYW5zbWl0dGVkIHdpdGggVFhWRUNUT1IKKyMgcGFyYW1zIGZvcm1hdCBlcXVhbCB0byBWSFQgYW5kIENCVyA9IDgwTWh6CisjIDAgPSBOb3Qgc3VwcG9ydGVkIChkZWZhdWx0KQorIyAxID0gU3VwcG9ydGVkCisjCisjIFNob3J0IEdJIGZvciAxNjAgTUh6OiBbU0hPUlQtR0ktMTYwXQorIyBJbmRpY2F0ZXMgc2hvcnQgR0kgc3VwcG9ydCBmb3IgcmVjZXB0aW9uIG9mIHBhY2tldHMgdHJhbnNtaXR0ZWQgd2l0aCBUWFZFQ1RPUgorIyBwYXJhbXMgZm9ybWF0IGVxdWFsIHRvIFZIVCBhbmQgQ0JXID0gMTYwTWh6CisjIDAgPSBOb3Qgc3VwcG9ydGVkIChkZWZhdWx0KQorIyAxID0gU3VwcG9ydGVkCisjCisjIFR4IFNUQkM6IFtUWC1TVEJDLTJCWTFdCisjIEluZGljYXRlcyBzdXBwb3J0IGZvciB0aGUgdHJhbnNtaXNzaW9uIG9mIGF0IGxlYXN0IDJ4MSBTVEJDCisjIDAgPSBOb3Qgc3VwcG9ydGVkIChkZWZhdWx0KQorIyAxID0gU3VwcG9ydGVkCisjCisjIFJ4IFNUQkM6IFtSWC1TVEJDLTFdIFtSWC1TVEJDLTEyXSBbUlgtU1RCQy0xMjNdIFtSWC1TVEJDLTEyMzRdCisjIEluZGljYXRlcyBzdXBwb3J0IGZvciB0aGUgcmVjZXB0aW9uIG9mIFBQRFVzIHVzaW5nIFNUQkMKKyMgMCA9IE5vdCBzdXBwb3J0ZWQgKGRlZmF1bHQpCisjIDEgPSBzdXBwb3J0IG9mIG9uZSBzcGF0aWFsIHN0cmVhbQorIyAyID0gc3VwcG9ydCBvZiBvbmUgYW5kIHR3byBzcGF0aWFsIHN0cmVhbXMKKyMgMyA9IHN1cHBvcnQgb2Ygb25lLCB0d28gYW5kIHRocmVlIHNwYXRpYWwgc3RyZWFtcworIyA0ID0gc3VwcG9ydCBvZiBvbmUsIHR3bywgdGhyZWUgYW5kIGZvdXIgc3BhdGlhbCBzdHJlYW1zCisjIDUsNiw3ID0gcmVzZXJ2ZWQKKyMKKyMgU1UgQmVhbWZvcm1lciBDYXBhYmxlOiBbU1UtQkVBTUZPUk1FUl0KKyMgSW5kaWNhdGVzIHN1cHBvcnQgZm9yIG9wZXJhdGlvbiBhcyBhIHNpbmdsZSB1c2VyIGJlYW1mb3JtZXIKKyMgMCA9IE5vdCBzdXBwb3J0ZWQgKGRlZmF1bHQpCisjIDEgPSBTdXBwb3J0ZWQKKyMKKyMgU1UgQmVhbWZvcm1lZSBDYXBhYmxlOiBbU1UtQkVBTUZPUk1FRV0KKyMgSW5kaWNhdGVzIHN1cHBvcnQgZm9yIG9wZXJhdGlvbiBhcyBhIHNpbmdsZSB1c2VyIGJlYW1mb3JtZWUKKyMgMCA9IE5vdCBzdXBwb3J0ZWQgKGRlZmF1bHQpCisjIDEgPSBTdXBwb3J0ZWQKKyMKKyMgQ29tcHJlc3NlZCBTdGVlcmluZyBOdW1iZXIgb2YgQmVhbWZvcm1lciBBbnRlbm5hcyBTdXBwb3J0ZWQ6IFtCRi1BTlRFTk5BLTJdCisjICAgQmVhbWZvcm1lZSdzIGNhcGFiaWxpdHkgaW5kaWNhdGluZyB0aGUgbWF4aW11bSBudW1iZXIgb2YgYmVhbWZvcm1lcgorIyAgIGFudGVubmFzIHRoZSBiZWFtZm9ybWVlIGNhbiBzdXBwb3J0IHdoZW4gc2VuZGluZyBjb21wcmVzc2VkIGJlYW1mb3JtaW5nCisjICAgZmVlZGJhY2sKKyMgSWYgU1UgYmVhbWZvcm1lciBjYXBhYmxlLCBzZXQgdG8gbWF4aW11bSB2YWx1ZSBtaW51cyAxCisjIGVsc2UgcmVzZXJ2ZWQgKGRlZmF1bHQpCisjCisjIE51bWJlciBvZiBTb3VuZGluZyBEaW1lbnNpb25zOiBbU09VTkRJTkctRElNRU5TSU9OLTJdCisjIEJlYW1mb3JtZXKScyBjYXBhYmlsaXR5IGluZGljYXRpbmcgdGhlIG1heGltdW0gdmFsdWUgb2YgdGhlIE5VTV9TVFMgcGFyYW1ldGVyCisjIGluIHRoZSBUWFZFQ1RPUiBvZiBhIFZIVCBORFAKKyMgSWYgU1UgYmVhbWZvcm1lciBjYXBhYmxlLCBzZXQgdG8gbWF4aW11bSB2YWx1ZSBtaW51cyAxCisjIGVsc2UgcmVzZXJ2ZWQgKGRlZmF1bHQpCisjCisjIE1VIEJlYW1mb3JtZXIgQ2FwYWJsZTogW01VLUJFQU1GT1JNRVJdCisjIEluZGljYXRlcyBzdXBwb3J0IGZvciBvcGVyYXRpb24gYXMgYW4gTVUgYmVhbWZvcm1lcgorIyAwID0gTm90IHN1cHBvcnRlZCBvciBzZW50IGJ5IE5vbi1BUCBTVEEgKGRlZmF1bHQpCisjIDEgPSBTdXBwb3J0ZWQKKyMKKyMgTVUgQmVhbWZvcm1lZSBDYXBhYmxlOiBbTVUtQkVBTUZPUk1FRV0KKyMgSW5kaWNhdGVzIHN1cHBvcnQgZm9yIG9wZXJhdGlvbiBhcyBhbiBNVSBiZWFtZm9ybWVlCisjIDAgPSBOb3Qgc3VwcG9ydGVkIG9yIHNlbnQgYnkgQVAgKGRlZmF1bHQpCisjIDEgPSBTdXBwb3J0ZWQKKyMKKyMgVkhUIFRYT1AgUFM6IFtWSFQtVFhPUC1QU10KKyMgSW5kaWNhdGVzIHdoZXRoZXIgb3Igbm90IHRoZSBBUCBzdXBwb3J0cyBWSFQgVFhPUCBQb3dlciBTYXZlIE1vZGUKKyMgIG9yIHdoZXRoZXIgb3Igbm90IHRoZSBTVEEgaXMgaW4gVkhUIFRYT1AgUG93ZXIgU2F2ZSBtb2RlCisjIDAgPSBWSFQgQVAgZG9lc250IHN1cHBvcnQgVkhUIFRYT1AgUFMgbW9kZSAoT1IpIFZIVCBTdGEgbm90IGluIFZIVCBUWE9QIFBTCisjICBtb2RlCisjIDEgPSBWSFQgQVAgc3VwcG9ydHMgVkhUIFRYT1AgUFMgbW9kZSAoT1IpIFZIVCBTdGEgaXMgaW4gVkhUIFRYT1AgcG93ZXIgc2F2ZQorIyAgbW9kZQorIworIyArSFRDLVZIVCBDYXBhYmxlOiBbSFRDLVZIVF0KKyMgSW5kaWNhdGVzIHdoZXRoZXIgb3Igbm90IHRoZSBTVEEgc3VwcG9ydHMgcmVjZWl2aW5nIGEgVkhUIHZhcmlhbnQgSFQgQ29udHJvbAorIyBmaWVsZC4KKyMgMCA9IE5vdCBzdXBwb3J0ZWQgKGRlZmF1bHQpCisjIDEgPSBzdXBwb3J0ZWQKKyMKKyMgTWF4aW11bSBBLU1QRFUgTGVuZ3RoIEV4cG9uZW50OiBbTUFYLUEtTVBEVS1MRU4tRVhQMF0uLltNQVgtQS1NUERVLUxFTi1FWFA3XQorIyBJbmRpY2F0ZXMgdGhlIG1heGltdW0gbGVuZ3RoIG9mIEEtTVBEVSBwcmUtRU9GIHBhZGRpbmcgdGhhdCB0aGUgU1RBIGNhbiByZWN2CisjIFRoaXMgZmllbGQgaXMgYW4gaW50ZWdlciBpbiB0aGUgcmFuZ2Ugb2YgMCB0byA3LgorIyBUaGUgbGVuZ3RoIGRlZmluZWQgYnkgdGhpcyBmaWVsZCBpcyBlcXVhbCB0bworIyAyIHBvdygxMyArIE1heGltdW0gQS1NUERVIExlbmd0aCBFeHBvbmVudCkgljEgb2N0ZXRzCisjCisjIFZIVCBMaW5rIEFkYXB0YXRpb24gQ2FwYWJsZTogW1ZIVC1MSU5LLUFEQVBUMl0gW1ZIVC1MSU5LLUFEQVBUM10KKyMgSW5kaWNhdGVzIHdoZXRoZXIgb3Igbm90IHRoZSBTVEEgc3VwcG9ydHMgbGluayBhZGFwdGF0aW9uIHVzaW5nIFZIVCB2YXJpYW50CisjIEhUIENvbnRyb2wgZmllbGQKKyMgSWYgK0hUQy1WSFRjYXBhYmxlIGlzIDEKKyMgIDAgPSAobm8gZmVlZGJhY2spIGlmIHRoZSBTVEEgZG9lcyBub3QgcHJvdmlkZSBWSFQgTUZCIChkZWZhdWx0KQorIyAgMSA9IHJlc2VydmVkCisjICAyID0gKFVuc29saWNpdGVkKSBpZiB0aGUgU1RBIHByb3ZpZGVzIG9ubHkgdW5zb2xpY2l0ZWQgVkhUIE1GQgorIyAgMyA9IChCb3RoKSBpZiB0aGUgU1RBIGNhbiBwcm92aWRlIFZIVCBNRkIgaW4gcmVzcG9uc2UgdG8gVkhUIE1SUSBhbmQgaWYgdGhlCisjICAgICAgU1RBIHByb3ZpZGVzIHVuc29saWNpdGVkIFZIVCBNRkIKKyMgUmVzZXJ2ZWQgaWYgK0hUQy1WSFRjYXBhYmxlIGlzIDAKKyMKKyMgUnggQW50ZW5uYSBQYXR0ZXJuIENvbnNpc3RlbmN5OiBbUlgtQU5URU5OQS1QQVRURVJOXQorIyBJbmRpY2F0ZXMgdGhlIHBvc3NpYmlsaXR5IG9mIFJ4IGFudGVubmEgcGF0dGVybiBjaGFuZ2UKKyMgMCA9IFJ4IGFudGVubmEgcGF0dGVybiBtaWdodCBjaGFuZ2UgZHVyaW5nIHRoZSBsaWZldGltZSBvZiBhbiBhc3NvY2lhdGlvbgorIyAxID0gUnggYW50ZW5uYSBwYXR0ZXJuIGRvZXMgbm90IGNoYW5nZSBkdXJpbmcgdGhlIGxpZmV0aW1lIG9mIGFuIGFzc29jaWF0aW9uCisjCisjIFR4IEFudGVubmEgUGF0dGVybiBDb25zaXN0ZW5jeTogW1RYLUFOVEVOTkEtUEFUVEVSTl0KKyMgSW5kaWNhdGVzIHRoZSBwb3NzaWJpbGl0eSBvZiBUeCBhbnRlbm5hIHBhdHRlcm4gY2hhbmdlCisjIDAgPSBUeCBhbnRlbm5hIHBhdHRlcm4gbWlnaHQgY2hhbmdlIGR1cmluZyB0aGUgbGlmZXRpbWUgb2YgYW4gYXNzb2NpYXRpb24KKyMgMSA9IFR4IGFudGVubmEgcGF0dGVybiBkb2VzIG5vdCBjaGFuZ2UgZHVyaW5nIHRoZSBsaWZldGltZSBvZiBhbiBhc3NvY2lhdGlvbgorI3ZodF9jYXBhYj1bU0hPUlQtR0ktODBdW0hUQy1WSFRdCisjdmh0X29wZXJfY2h3aWR0aD0xCisKICMjIyMjIElFRUUgODAyLjFYLTIwMDQgcmVsYXRlZCBjb25maWd1cmF0aW9uICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKIAogIyBSZXF1aXJlIElFRUUgODAyLjFYIGF1dGhvcml6YXRpb24KQEAgLTYzMiw2ICs3NjMsMTIgQEAKICMgNjAgKDEgbWludXRlKS4KICNyYWRpdXNfYWNjdF9pbnRlcmltX2ludGVydmFsPTYwMAogCisjIFJlcXVlc3QgQ2hhcmdlYWJsZS1Vc2VyLUlkZW50aXR5IChSRkMgNDM3MikKKyMgVGhpcyBwYXJhbWV0ZXIgY2FuIGJlIHVzZWQgdG8gY29uZmlndXJlIGhvc3RhcGQgdG8gcmVxdWVzdCBDVUkgZnJvbSB0aGUKKyMgUkFESVVTIHNlcnZlciBieSBpbmNsdWRpbmcgQ2hhcmdlYWJsZS1Vc2VyLUlkZW50aXR5IGF0dHJpYnV0ZSBpbnRvCisjIEFjY2Vzcy1SZXF1ZXN0IHBhY2tldHMuCisjcmFkaXVzX3JlcXVlc3RfY3VpPTEKKwogIyBEeW5hbWljIFZMQU4gbW9kZTsgYWxsb3cgUkFESVVTIGF1dGhlbnRpY2F0aW9uIHNlcnZlciB0byBkZWNpZGUgd2hpY2ggVkxBTgogIyBpcyB1c2VkIGZvciB0aGUgc3RhdGlvbnMuIFRoaXMgaW5mb3JtYXRpb24gaXMgcGFyc2VkIGZyb20gZm9sbG93aW5nIFJBRElVUwogIyBhdHRyaWJ1dGVzIGJhc2VkIG9uIFJGQyAzNTgwIGFuZCBSRkMgMjg2ODogVHVubmVsLVR5cGUgKHZhbHVlIDEzID0gVkxBTiksCkBAIC02NTksNiArNzk2LDU1IEBACiAjIHRvIHRoZSBicmlkZ2UuCiAjdmxhbl90YWdnZWRfaW50ZXJmYWNlPWV0aDAKIAorIyBBcmJpdHJhcnkgUkFESVVTIGF0dHJpYnV0ZXMgY2FuIGJlIGFkZGVkIGludG8gQWNjZXNzLVJlcXVlc3QgYW5kCisjIEFjY291bnRpbmctUmVxdWVzdCBwYWNrZXRzIGJ5IHNwZWNpZnlpbmcgdGhlIGNvbnRlbnRzIG9mIHRoZSBhdHRyaWJ1dGVzIHdpdGgKKyMgdGhlIGZvbGxvd2luZyBjb25maWd1cmF0aW9uIHBhcmFtZXRlcnMuIFRoZXJlIGNhbiBiZSBtdWx0aXBsZSBvZiB0aGVzZSB0bworIyBhZGQgbXVsdGlwbGUgYXR0cmlidXRlcy4gVGhlc2UgcGFyYW1ldGVycyBjYW4gYWxzbyBiZSB1c2VkIHRvIG92ZXJyaWRlIHNvbWUKKyMgb2YgdGhlIGF0dHJpYnV0ZXMgYWRkZWQgYXV0b21hdGljYWxseSBieSBob3N0YXBkLgorIyBGb3JtYXQ6IDxhdHRyX2lkPls6PHN5bnRheDp2YWx1ZT5dCisjIGF0dHJfaWQ6IFJBRElVUyBhdHRyaWJ1dGUgdHlwZSAoZS5nLiwgMjYgPSBWZW5kb3ItU3BlY2lmaWMpCisjIHN5bnRheDogcyA9IHN0cmluZyAoVVRGLTgpLCBkID0gaW50ZWdlciwgeCA9IG9jdGV0IHN0cmluZworIyB2YWx1ZTogYXR0cmlidXRlIHZhbHVlIGluIGZvcm1hdCBpbmRpY2F0ZWQgYnkgdGhlIHN5bnRheAorIyBJZiBzeW50YXggYW5kIHZhbHVlIHBhcnRzIGFyZSBvbWl0dGVkLCBhIG51bGwgdmFsdWUgKHNpbmdsZSAweDAwIG9jdGV0KSBpcworIyB1c2VkLgorIworIyBBZGRpdGlvbmFsIEFjY2Vzcy1SZXF1ZXN0IGF0dHJpYnV0ZXMKKyMgcmFkaXVzX2F1dGhfcmVxX2F0dHI9PGF0dHJfaWQ+Wzo8c3ludGF4OnZhbHVlPl0KKyMgRXhhbXBsZXM6CisjIE9wZXJhdG9yLU5hbWUgPSAiT3BlcmF0b3IiCisjcmFkaXVzX2F1dGhfcmVxX2F0dHI9MTI2OnM6T3BlcmF0b3IKKyMgU2VydmljZS1UeXBlID0gRnJhbWVkICgyKQorI3JhZGl1c19hdXRoX3JlcV9hdHRyPTY6ZDoyCisjIENvbm5lY3QtSW5mbyA9ICJ0ZXN0aW5nIiAodGhpcyBvdmVycmlkZXMgdGhlIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIHZhbHVlKQorI3JhZGl1c19hdXRoX3JlcV9hdHRyPTc3OnM6dGVzdGluZworIyBTYW1lIENvbm5lY3QtSW5mbyB2YWx1ZSBzZXQgYXMgYSBoZXhkdW1wCisjcmFkaXVzX2F1dGhfcmVxX2F0dHI9Nzc6eDo3NDY1NzM3NDY5NmU2NworCisjCisjIEFkZGl0aW9uYWwgQWNjb3VudGluZy1SZXF1ZXN0IGF0dHJpYnV0ZXMKKyMgcmFkaXVzX2FjY3RfcmVxX2F0dHI9PGF0dHJfaWQ+Wzo8c3ludGF4OnZhbHVlPl0KKyMgRXhhbXBsZXM6CisjIE9wZXJhdG9yLU5hbWUgPSAiT3BlcmF0b3IiCisjcmFkaXVzX2FjY3RfcmVxX2F0dHI9MTI2OnM6T3BlcmF0b3IKKworIyBEeW5hbWljIEF1dGhvcml6YXRpb24gRXh0ZW5zaW9ucyAoUkZDIDUxNzYpCisjIFRoaXMgbWVjaGFuaXNtIGNhbiBiZSB1c2VkIHRvIGFsbG93IGR5bmFtaWMgY2hhbmdlcyB0byB1c2VyIHNlc3Npb24gYmFzZWQgb24KKyMgY29tbWFuZHMgZnJvbSBhIFJBRElVUyBzZXJ2ZXIgKG9yIHNvbWUgb3RoZXIgZGlzY29ubmVjdCBjbGllbnQgdGhhdCBoYXMgdGhlCisjIG5lZWRlZCBzZXNzaW9uIGluZm9ybWF0aW9uKS4gRm9yIGV4YW1wbGUsIERpc2Nvbm5lY3QgbWVzc2FnZSBjYW4gYmUgdXNlZCB0bworIyByZXF1ZXN0IGFuIGFzc29jaWF0ZWQgc3RhdGlvbiB0byBiZSBkaXNjb25uZWN0ZWQuCisjCisjIFRoaXMgaXMgZGlzYWJsZWQgYnkgZGVmYXVsdC4gU2V0IHJhZGl1c19kYXNfcG9ydCB0byBub24temVybyBVRFAgcG9ydAorIyBudW1iZXIgdG8gZW5hYmxlLgorI3JhZGl1c19kYXNfcG9ydD0zNzk5CisjCisjIERBUyBjbGllbnQgKHRoZSBob3N0IHRoYXQgY2FuIHNlbmQgRGlzY29ubmVjdC9Db0EgcmVxdWVzdHMpIGFuZCBzaGFyZWQgc2VjcmV0CisjcmFkaXVzX2Rhc19jbGllbnQ9MTkyLjE2OC4xLjEyMyBzaGFyZWQgc2VjcmV0IGhlcmUKKyMKKyMgREFTIEV2ZW50LVRpbWVzdGFtcCB0aW1lIHdpbmRvdyBpbiBzZWNvbmRzCisjcmFkaXVzX2Rhc190aW1lX3dpbmRvdz0zMDAKKyMKKyMgREFTIHJlcXVpcmUgRXZlbnQtVGltZXN0YW1wCisjcmFkaXVzX2Rhc19yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcD0xCiAKICMjIyMjIFJBRElVUyBhdXRoZW50aWNhdGlvbiBzZXJ2ZXIgY29uZmlndXJhdGlvbiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKIApAQCAtMTAzMyw2ICsxMjE5LDE4IEBACiAjIHNldCB0byBhZyB0byBhbGxvdyBib3RoIFJGIGJhbmRzIHRvIGJlIGFkdmVydGl6ZWQuCiAjd3BzX3JmX2JhbmRzPWFnCiAKKyMgTkZDIHBhc3N3b3JkIHRva2VuIGZvciBXUFMKKyMgVGhlc2UgcGFyYW1ldGVycyBjYW4gYmUgdXNlZCB0byBjb25maWd1cmUgYSBmaXhlZCBORkMgcGFzc3dvcmQgdG9rZW4gZm9yIHRoZQorIyBBUC4gVGhpcyBjYW4gYmUgZ2VuZXJhdGVkLCBlLmcuLCB3aXRoIG5mY19wd190b2tlbiBmcm9tIHdwYV9zdXBwbGljYW50LiBXaGVuCisjIHRoZXNlIHBhcmFtZXRlcnMgYXJlIHVzZWQsIHRoZSBBUCBpcyBhc3N1bWVkIHRvIGJlIGRlcGxveWVkIHdpdGggYSBORkMgdGFnCisjIHRoYXQgaW5jbHVkZXMgdGhlIG1hdGNoaW5nIE5GQyBwYXNzd29yZCB0b2tlbiAoZS5nLiwgd3JpdHRlbiBiYXNlZCBvbiB0aGUKKyMgTkRFRiByZWNvcmQgZnJvbSBuZmNfcHdfdG9rZW4pLgorIworI3dwc19uZmNfZGV2X3B3X2lkOiBEZXZpY2UgUGFzc3dvcmQgSUQgKDE2Li42NTUzNSkKKyN3cHNfbmZjX2RoX3B1YmtleTogSGV4ZHVtcCBvZiBESCBQdWJsaWMgS2V5Cisjd3BzX25mY19kaF9wcml2a2V5OiBIZXhkdW1wIG9mIERIIFByaXZhdGUgS2V5Cisjd3BzX25mY19kZXZfcHc6IEhleGR1bXAgb2YgRGV2aWNlIFBhc3N3b3JkCisKICMjIyMjIFdpLUZpIERpcmVjdCAoUDJQKSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKIAogIyBFbmFibGUgUDJQIERldmljZSBtYW5hZ2VtZW50CkBAIC0xMTE4LDYgKzEzMTYsMTUgQEAKICNyb2FtaW5nX2NvbnNvcnRpdW09MDIxMTIyCiAjcm9hbWluZ19jb25zb3J0aXVtPTIyMzM0NDU1NjYKIAorIyBWZW51ZSBOYW1lIGluZm9ybWF0aW9uCisjIFRoaXMgcGFyYW1ldGVyIGNhbiBiZSB1c2VkIHRvIGNvbmZpZ3VyZSBvbmUgb3IgbW9yZSBWZW51ZSBOYW1lIER1cGxlcyBmb3IKKyMgVmVudWUgTmFtZSBBTlFQIGluZm9ybWF0aW9uLiBFYWNoIGVudHJ5IGhhcyBhIHR3byBvciB0aHJlZSBjaGFyYWN0ZXIgbGFuZ3VhZ2UKKyMgY29kZSAoSVNPLTYzOSkgc2VwYXJhdGVkIGJ5IGNvbG9uIGZyb20gdGhlIHZlbnVlIG5hbWUgc3RyaW5nLgorIyBOb3RlIHRoYXQgdmVudWVfZ3JvdXAgYW5kIHZlbnVlX3R5cGUgaGF2ZSB0byBiZSBzZXQgZm9yIFZlbnVlIE5hbWUKKyMgaW5mb3JtYXRpb24gdG8gYmUgY29tcGxldGUuCisjdmVudWVfbmFtZT1lbmc6RXhhbXBsZSB2ZW51ZQorI3ZlbnVlX25hbWU9ZmluOkVzaW1lcmtraXBhaWtrYQorCiAjIyMjIyBNdWx0aXBsZSBCU1NJRCBzdXBwb3J0ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjCiAjIEFib3ZlIGNvbmZpZ3VyYXRpb24gaXMgdXNpbmcgdGhlIGRlZmF1bHQgaW50ZXJmYWNlICh3bGFuIywgb3IgbXVsdGktU1NJRCBWTEFOCmRpZmYgLS1naXQgYS9ob3N0YXBkL2hvc3RhcGQuZWFwX3VzZXIgYi9ob3N0YXBkL2hvc3RhcGQuZWFwX3VzZXIKaW5kZXggYWM5YTVkOC4uMTJhMmM2MSAxMDA2NDQKLS0tIGEvaG9zdGFwZC9ob3N0YXBkLmVhcF91c2VyCisrKyBiL2hvc3RhcGQvaG9zdGFwZC5lYXBfdXNlcgpAQCAtNjksNiArNjksOSBAQAogIjMiKgkJU0lNLFRUTFMsVExTLFBFQVAsQUtBCiAiNCIqCQlBS0EsVFRMUyxUTFMsUEVBUCxTSU0KICI1IioJCVNJTSxUVExTLFRMUyxQRUFQLEFLQQorIjYiKgkJQUtBJworIjciKgkJQUtBJworIjgiKgkJQUtBJwogCiAjIFdpbGRjYXJkIGZvciBhbGwgb3RoZXIgaWRlbnRpdGllcwogKgkJUEVBUCxUVExTLFRMUyxTSU0sQUtBCkBAIC04OSwzICs5Miw2IEBACiAiMyIqCQlTSU0JWzJdCiAiNCIqCQlBS0EJWzJdCiAiNSIqCQlTSU0JWzJdCisiNiIqCQlBS0EnCVsyXQorIjciKgkJQUtBJwlbMl0KKyI4IioJCUFLQScJWzJdCmRpZmYgLS1naXQgYS9ob3N0YXBkL2hvc3RhcGRfY2xpLmMgYi9ob3N0YXBkL2hvc3RhcGRfY2xpLmMKaW5kZXggODkxMjVmZC4uMGMzM2Q1YiAxMDA2NDQKLS0tIGEvaG9zdGFwZC9ob3N0YXBkX2NsaS5jCisrKyBiL2hvc3RhcGQvaG9zdGFwZF9jbGkuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC0gY29tbWFuZCBsaW5lIGludGVyZmFjZSBmb3IgaG9zdGFwZCBkYWVtb24KLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDExLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTc0LDYgKzc0LDExIEBACiAjaWZkZWYgQ09ORklHX1dQU19PT0IKICIgICB3cHNfb29iIDx0eXBlPiA8cGF0aD4gPG1ldGhvZD4gIHVzZSBXUFMgd2l0aCBvdXQtb2YtYmFuZCAoVUZEKVxuIgogI2VuZGlmIC8qIENPTkZJR19XUFNfT09CICovCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKyIgICB3cHNfbmZjX3RhZ19yZWFkIDxoZXhkdW1wPiAgcmVwb3J0IHJlYWQgTkZDIHRhZyB3aXRoIFdQUyBkYXRhXG4iCisiICAgd3BzX25mY19jb25maWdfdG9rZW4gPFdQUy9OREVGPiAgYnVpbGQgTkZDIGNvbmZpZ3VyYXRpb24gdG9rZW5cbiIKKyIgICB3cHNfbmZjX3Rva2VuIDxXUFMvTkRFRi9lbmFibGUvZGlzYWJsZT4gIG1hbmFnZXIgTkZDIHBhc3N3b3JkIHRva2VuXG4iCisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KICIgICB3cHNfYXBfcGluIDxjbWQ+IFtwYXJhbXMuLl0gIGVuYWJsZS9kaXNhYmxlIEFQIFBJTlxuIgogIiAgIHdwc19jb25maWcgPFNTSUQ+IDxhdXRoPiA8ZW5jcj4gPGtleT4gIGNvbmZpZ3VyZSBBUFxuIgogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KQEAgLTM5Miw2ICszOTcsMTMgQEAKIH0KIAogCitzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF93cHNfY2FuY2VsKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJICAgICAgY2hhciAqYXJndltdKQoreworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJXUFNfQ0FOQ0VMIik7Cit9CisKKwogI2lmZGVmIENPTkZJR19XUFNfT09CCiBzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF93cHNfb29iKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCiAJCQkJICAgY2hhciAqYXJndltdKQpAQCAtNDI2LDYgKzQzOCw3NyBAQAogI2VuZGlmIC8qIENPTkZJR19XUFNfT09CICovCiAKIAorI2lmZGVmIENPTkZJR19XUFNfTkZDCitzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF93cHNfbmZjX3RhZ19yZWFkKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJCSAgICBjaGFyICphcmd2W10pCit7CisJaW50IHJldDsKKwljaGFyICpidWY7CisJc2l6ZV90IGJ1ZmxlbjsKKworCWlmIChhcmdjICE9IDEpIHsKKwkJcHJpbnRmKCJJbnZhbGlkICd3cHNfbmZjX3RhZ19yZWFkJyBjb21tYW5kIC0gb25lIGFyZ3VtZW50ICIKKwkJICAgICAgICJpcyByZXF1aXJlZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJYnVmbGVuID0gMTggKyBvc19zdHJsZW4oYXJndlswXSk7CisJYnVmID0gb3NfbWFsbG9jKGJ1Zmxlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJXUFNfTkZDX1RBR19SRUFEICVzIiwgYXJndlswXSk7CisKKwlyZXQgPSB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGJ1Zik7CisJb3NfZnJlZShidWYpOworCisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IGhvc3RhcGRfY2xpX2NtZF93cHNfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsCisJCQkJCQlpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCWNoYXIgY21kWzY0XTsKKwlpbnQgcmVzOworCisJaWYgKGFyZ2MgIT0gMSkgeworCQlwcmludGYoIkludmFsaWQgJ3dwc19uZmNfY29uZmlnX3Rva2VuJyBjb21tYW5kIC0gb25lIGFyZ3VtZW50ICIKKwkJICAgICAgICJpcyByZXF1aXJlZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIldQU19ORkNfQ09ORklHX1RPS0VOICVzIiwKKwkJCSAgYXJndlswXSk7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIFdQU19ORkNfQ09ORklHX1RPS0VOIGNvbW1hbmQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBjbWQpOworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9jbGlfY21kX3dwc19uZmNfdG9rZW4oc3RydWN0IHdwYV9jdHJsICpjdHJsLAorCQkJCQkgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGNtZFs2NF07CisJaW50IHJlczsKKworCWlmIChhcmdjICE9IDEpIHsKKwkJcHJpbnRmKCJJbnZhbGlkICd3cHNfbmZjX3Rva2VuJyBjb21tYW5kIC0gb25lIGFyZ3VtZW50IGlzICIKKwkJICAgICAgICJyZXF1aXJlZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIldQU19ORkNfVE9LRU4gJXMiLCBhcmd2WzBdKTsKKwlpZiAocmVzIDwgMCB8fCAoc2l6ZV90KSByZXMgPj0gc2l6ZW9mKGNtZCkgLSAxKSB7CisJCXByaW50ZigiVG9vIGxvbmcgV1BTX05GQ19UT0tFTiBjb21tYW5kLlxuIik7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKK30KKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCisKIHN0YXRpYyBpbnQgaG9zdGFwZF9jbGlfY21kX3dwc19hcF9waW4oc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKIAkJCQkgICAgICBjaGFyICphcmd2W10pCiB7CkBAIC03MTksOSArODAyLDE1IEBACiAJeyAid3BzX3BpbiIsIGhvc3RhcGRfY2xpX2NtZF93cHNfcGluIH0sCiAJeyAid3BzX2NoZWNrX3BpbiIsIGhvc3RhcGRfY2xpX2NtZF93cHNfY2hlY2tfcGluIH0sCiAJeyAid3BzX3BiYyIsIGhvc3RhcGRfY2xpX2NtZF93cHNfcGJjIH0sCisJeyAid3BzX2NhbmNlbCIsIGhvc3RhcGRfY2xpX2NtZF93cHNfY2FuY2VsIH0sCiAjaWZkZWYgQ09ORklHX1dQU19PT0IKIAl7ICJ3cHNfb29iIiwgaG9zdGFwZF9jbGlfY21kX3dwc19vb2IgfSwKICNlbmRpZiAvKiBDT05GSUdfV1BTX09PQiAqLworI2lmZGVmIENPTkZJR19XUFNfTkZDCisJeyAid3BzX25mY190YWdfcmVhZCIsIGhvc3RhcGRfY2xpX2NtZF93cHNfbmZjX3RhZ19yZWFkIH0sCisJeyAid3BzX25mY19jb25maWdfdG9rZW4iLCBob3N0YXBkX2NsaV9jbWRfd3BzX25mY19jb25maWdfdG9rZW4gfSwKKwl7ICJ3cHNfbmZjX3Rva2VuIiwgaG9zdGFwZF9jbGlfY21kX3dwc19uZmNfdG9rZW4gfSwKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogCXsgIndwc19hcF9waW4iLCBob3N0YXBkX2NsaV9jbWRfd3BzX2FwX3BpbiB9LAogCXsgIndwc19jb25maWciLCBob3N0YXBkX2NsaV9jbWRfd3BzX2NvbmZpZyB9LAogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KZGlmZiAtLWdpdCBhL2hvc3RhcGQvbWFpbi5jIGIvaG9zdGFwZC9tYWluLmMKaW5kZXggMzkxODczNy4uZDhjMjc3NiAxMDA2NDQKLS0tIGEvaG9zdGFwZC9tYWluLmMKKysrIGIvaG9zdGFwZC9tYWluLmMKQEAgLTIxLDYgKzIxLDcgQEAKICNpbmNsdWRlICJlYXBfc2VydmVyL3RuY3MuaCIKICNpbmNsdWRlICJhcC9ob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXAvYXBfY29uZmlnLmgiCisjaW5jbHVkZSAiYXAvYXBfZHJ2X29wcy5oIgogI2luY2x1ZGUgImNvbmZpZ19maWxlLmgiCiAjaW5jbHVkZSAiZWFwX3JlZ2lzdGVyLmgiCiAjaW5jbHVkZSAiZHVtcF9zdGF0ZS5oIgpAQCAtNDIsMjkgKzQzLDYgQEAKIHN0YXRpYyBzdHJ1Y3QgaGFwZF9nbG9iYWwgZ2xvYmFsOwogCiAKLXN0cnVjdCBoYXBkX2ludGVyZmFjZXMgewotCXNpemVfdCBjb3VudDsKLQlzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqKmlmYWNlOwotfTsKLQotCi1zdGF0aWMgaW50IGhvc3RhcGRfZm9yX2VhY2hfaW50ZXJmYWNlKHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgKmludGVyZmFjZXMsCi0JCQkJICAgICAgaW50ICgqY2IpKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwKLQkJCQkJCXZvaWQgKmN0eCksIHZvaWQgKmN0eCkKLXsKLQlzaXplX3QgaTsKLQlpbnQgcmV0OwotCi0JZm9yIChpID0gMDsgaSA8IGludGVyZmFjZXMtPmNvdW50OyBpKyspIHsKLQkJcmV0ID0gY2IoaW50ZXJmYWNlcy0+aWZhY2VbaV0sIGN0eCk7Ci0JCWlmIChyZXQpCi0JCQlyZXR1cm4gcmV0OwotCX0KLQotCXJldHVybiAwOwotfQotCi0KICNpZm5kZWYgQ09ORklHX05PX0hPU1RBUERfTE9HR0VSCiBzdGF0aWMgdm9pZCBob3N0YXBkX2xvZ2dlcl9jYih2b2lkICpjdHgsIGNvbnN0IHU4ICphZGRyLCB1bnNpZ25lZCBpbnQgbW9kdWxlLAogCQkJICAgICAgaW50IGxldmVsLCBjb25zdCBjaGFyICp0eHQsIHNpemVfdCBsZW4pCkBAIC0zMTUsNyArMjkzLDcgQEAKIAlkcml2ZXIgPSBpZmFjZS0+YnNzWzBdLT5kcml2ZXI7CiAJZHJ2X3ByaXYgPSBpZmFjZS0+YnNzWzBdLT5kcnZfcHJpdjsKIAlob3N0YXBkX2ludGVyZmFjZV9kZWluaXQoaWZhY2UpOwotCWlmIChkcml2ZXIgJiYgZHJpdmVyLT5oYXBkX2RlaW5pdCkKKwlpZiAoZHJpdmVyICYmIGRyaXZlci0+aGFwZF9kZWluaXQgJiYgZHJ2X3ByaXYpCiAJCWRyaXZlci0+aGFwZF9kZWluaXQoZHJ2X3ByaXYpOwogCWhvc3RhcGRfaW50ZXJmYWNlX2ZyZWUoaWZhY2UpOwogfQpAQCAtMzM5LDEwICszMTcsMTMgQEAKIAkJCWlmYWNlLT5ic3NbMF0tPmNvbmYtPmxvZ2dlcl9zdGRvdXRfbGV2ZWwtLTsKIAl9CiAKLQlpZiAoaG9zdGFwZF9kcml2ZXJfaW5pdChpZmFjZSkgfHwKLQkgICAgaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UoaWZhY2UpKSB7Ci0JCWhvc3RhcGRfaW50ZXJmYWNlX2RlaW5pdF9mcmVlKGlmYWNlKTsKLQkJcmV0dXJuIE5VTEw7CisJaWYgKGlmYWNlLT5jb25mLT5ic3NbMF0uaWZhY2VbMF0gIT0gMCB8fAorCSAgICBob3N0YXBkX2Rydl9ub25lKGlmYWNlLT5ic3NbMF0pKSB7CisJCWlmIChob3N0YXBkX2RyaXZlcl9pbml0KGlmYWNlKSB8fAorCQkJaG9zdGFwZF9zZXR1cF9pbnRlcmZhY2UoaWZhY2UpKSB7CisJCQlob3N0YXBkX2ludGVyZmFjZV9kZWluaXRfZnJlZShpZmFjZSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQogCX0KIAogCXJldHVybiBpZmFjZTsKZGlmZiAtLWdpdCBhL3NyYy9hcC9hY2NvdW50aW5nLmMgYi9zcmMvYXAvYWNjb3VudGluZy5jCmluZGV4IDJhMDQ1NjAuLjJjM2E2ZDkgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9hY2NvdW50aW5nLmMKKysrIGIvc3JjL2FwL2FjY291bnRpbmcuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC8gUkFESVVTIEFjY291bnRpbmcKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTM5LDYgKzM5LDggQEAKIAl1OCAqdmFsOwogCXNpemVfdCBsZW47CiAJaW50IGk7CisJc3RydWN0IHdwYWJ1ZiAqYjsKKwlzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfYXR0ciAqYXR0cjsKIAogCW1zZyA9IHJhZGl1c19tc2dfbmV3KFJBRElVU19DT0RFX0FDQ09VTlRJTkdfUkVRVUVTVCwKIAkJCSAgICAgcmFkaXVzX2NsaWVudF9nZXRfaWQoaGFwZC0+cmFkaXVzKSk7CkBAIC02Nyw3ICs2OSw5IEBACiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9BQ0NUX0FVVEhFTlRJQywKKwlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihoYXBkLT5jb25mLT5yYWRpdXNfYWNjdF9yZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX0FDQ1RfQVVUSEVOVElDKSAmJgorCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihtc2csIFJBRElVU19BVFRSX0FDQ1RfQVVUSEVOVElDLAogCQkJCSAgICAgICBoYXBkLT5jb25mLT5pZWVlODAyXzF4ID8KIAkJCQkgICAgICAgUkFESVVTX0FDQ1RfQVVUSEVOVElDX1JBRElVUyA6CiAJCQkJICAgICAgIFJBRElVU19BQ0NUX0FVVEhFTlRJQ19MT0NBTCkpIHsKQEAgLTkxLDcgKzk1LDkgQEAKIAkJfQogCX0KIAotCWlmIChoYXBkLT5jb25mLT5vd25faXBfYWRkci5hZiA9PSBBRl9JTkVUICYmCisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2FjY3RfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfSVBfQUREUkVTUykgJiYKKwkgICAgaGFwZC0+Y29uZi0+b3duX2lwX2FkZHIuYWYgPT0gQUZfSU5FVCAmJgogCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX05BU19JUF9BRERSRVNTLAogCQkJCSAodTggKikgJmhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLnUudjQsIDQpKSB7CiAJCXByaW50ZigiQ291bGQgbm90IGFkZCBOQVMtSVAtQWRkcmVzc1xuIik7CkBAIC05OSw3ICsxMDUsOSBAQAogCX0KIAogI2lmZGVmIENPTkZJR19JUFY2Ci0JaWYgKGhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLmFmID09IEFGX0lORVQ2ICYmCisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2FjY3RfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfSVBWNl9BRERSRVNTKSAmJgorCSAgICBoYXBkLT5jb25mLT5vd25faXBfYWRkci5hZiA9PSBBRl9JTkVUNiAmJgogCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX05BU19JUFY2X0FERFJFU1MsCiAJCQkJICh1OCAqKSAmaGFwZC0+Y29uZi0+b3duX2lwX2FkZHIudS52NiwgMTYpKSB7CiAJCXByaW50ZigiQ291bGQgbm90IGFkZCBOQVMtSVB2Ni1BZGRyZXNzXG4iKTsKQEAgLTEwNyw3ICsxMTUsOSBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLwogCi0JaWYgKGhhcGQtPmNvbmYtPm5hc19pZGVudGlmaWVyICYmCisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2FjY3RfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfSURFTlRJRklFUikgJiYKKwkgICAgaGFwZC0+Y29uZi0+bmFzX2lkZW50aWZpZXIgJiYKIAkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9OQVNfSURFTlRJRklFUiwKIAkJCQkgKHU4ICopIGhhcGQtPmNvbmYtPm5hc19pZGVudGlmaWVyLAogCQkJCSBvc19zdHJsZW4oaGFwZC0+Y29uZi0+bmFzX2lkZW50aWZpZXIpKSkgewpAQCAtMTE1LDcgKzEyNSw5IEBACiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoc3RhICYmCisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2FjY3RfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfUE9SVCkgJiYKKwkgICAgc3RhICYmCiAJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyX2ludDMyKG1zZywgUkFESVVTX0FUVFJfTkFTX1BPUlQsIHN0YS0+YWlkKSkgewogCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgTkFTLVBvcnRcbiIpOwogCQlnb3RvIGZhaWw7CkBAIC0xMjMsNyArMTM1LDkgQEAKIAogCW9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksIFJBRElVU184MDJfMVhfQUREUl9GT1JNQVQgIjolcyIsCiAJCSAgICBNQUMyU1RSKGhhcGQtPm93bl9hZGRyKSwgaGFwZC0+Y29uZi0+c3NpZC5zc2lkKTsKLQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9DQUxMRURfU1RBVElPTl9JRCwKKwlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihoYXBkLT5jb25mLT5yYWRpdXNfYWNjdF9yZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX0NBTExFRF9TVEFUSU9OX0lEKSAmJgorCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX0NBTExFRF9TVEFUSU9OX0lELAogCQkJCSAodTggKikgYnVmLCBvc19zdHJsZW4oYnVmKSkpIHsKIAkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIENhbGxlZC1TdGF0aW9uLUlkXG4iKTsKIAkJZ290byBmYWlsOwpAQCAtMTM4LDcgKzE1MiwxMCBAQAogCQkJZ290byBmYWlsOwogCQl9CiAKLQkJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyX2ludDMyKAorCQlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cigKKwkJCSAgICBoYXBkLT5jb25mLT5yYWRpdXNfYWNjdF9yZXFfYXR0ciwKKwkJCSAgICBSQURJVVNfQVRUUl9OQVNfUE9SVF9UWVBFKSAmJgorCQkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIoCiAJCQkgICAgbXNnLCBSQURJVVNfQVRUUl9OQVNfUE9SVF9UWVBFLAogCQkJICAgIFJBRElVU19OQVNfUE9SVF9UWVBFX0lFRUVfODAyXzExKSkgewogCQkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIE5BUy1Qb3J0LVR5cGVcbiIpOwpAQCAtMTQ5LDcgKzE2NiwxMCBAQAogCQkJICAgIHJhZGl1c19zdGFfcmF0ZShoYXBkLCBzdGEpIC8gMiwKIAkJCSAgICAocmFkaXVzX3N0YV9yYXRlKGhhcGQsIHN0YSkgJiAxKSA/ICIuNSIgOiAiIiwKIAkJCSAgICByYWRpdXNfbW9kZV90eHQoaGFwZCkpOwotCQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9DT05ORUNUX0lORk8sCisJCWlmICghaG9zdGFwZF9jb25maWdfZ2V0X3JhZGl1c19hdHRyKAorCQkJICAgIGhhcGQtPmNvbmYtPnJhZGl1c19hY2N0X3JlcV9hdHRyLAorCQkJICAgIFJBRElVU19BVFRSX0NPTk5FQ1RfSU5GTykgJiYKKwkJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfQ09OTkVDVF9JTkZPLAogCQkJCQkgKHU4ICopIGJ1Ziwgb3Nfc3RybGVuKGJ1ZikpKSB7CiAJCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgQ29ubmVjdC1JbmZvXG4iKTsKIAkJCWdvdG8gZmFpbDsKQEAgLTE2Nyw2ICsxODcsMjYgQEAKIAkJCQlnb3RvIGZhaWw7CiAJCQl9CiAJCX0KKworCQliID0gaWVlZTgwMl8xeF9nZXRfcmFkaXVzX2N1aShzdGEtPmVhcG9sX3NtKTsKKwkJaWYgKGIgJiYKKwkJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywKKwkJCQkJIFJBRElVU19BVFRSX0NIQVJHRUFCTEVfVVNFUl9JREVOVElUWSwKKwkJCQkJIHdwYWJ1Zl9oZWFkKGIpLCB3cGFidWZfbGVuKGIpKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIENVSSIpOworCQkJZ290byBmYWlsOworCQl9CisJfQorCisJZm9yIChhdHRyID0gaGFwZC0+Y29uZi0+cmFkaXVzX2FjY3RfcmVxX2F0dHI7IGF0dHI7IGF0dHIgPSBhdHRyLT5uZXh0KQorCXsKKwkJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgYXR0ci0+dHlwZSwKKwkJCQkJIHdwYWJ1Zl9oZWFkKGF0dHItPnZhbCksCisJCQkJCSB3cGFidWZfbGVuKGF0dHItPnZhbCkpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkNvdWxkIG5vdCBhZGQgUkFESVVTICIKKwkJCQkgICAiYXR0cmlidXRlIik7CisJCQlnb3RvIGZhaWw7CisJCX0KIAl9CiAKIAlyZXR1cm4gbXNnOwpAQCAtMjU5LDggKzI5OSw5IEBACiAJCQkgICAgICAgaGFwZCwgc3RhKTsKIAogCW1zZyA9IGFjY291bnRpbmdfbXNnKGhhcGQsIHN0YSwgUkFESVVTX0FDQ1RfU1RBVFVTX1RZUEVfU1RBUlQpOwotCWlmIChtc2cpCi0JCXJhZGl1c19jbGllbnRfc2VuZChoYXBkLT5yYWRpdXMsIG1zZywgUkFESVVTX0FDQ1QsIHN0YS0+YWRkcik7CisJaWYgKG1zZyAmJgorCSAgICByYWRpdXNfY2xpZW50X3NlbmQoaGFwZC0+cmFkaXVzLCBtc2csIFJBRElVU19BQ0NULCBzdGEtPmFkZHIpIDwgMCkKKwkJcmFkaXVzX21zZ19mcmVlKG1zZyk7CiAKIAlzdGEtPmFjY3Rfc2Vzc2lvbl9zdGFydGVkID0gMTsKIH0KQEAgLTM1OCw5ICszOTksMTAgQEAKIAkJZ290byBmYWlsOwogCX0KIAotCXJhZGl1c19jbGllbnRfc2VuZChoYXBkLT5yYWRpdXMsIG1zZywKLQkJCSAgIHN0b3AgPyBSQURJVVNfQUNDVCA6IFJBRElVU19BQ0NUX0lOVEVSSU0sCi0JCQkgICBzdGEtPmFkZHIpOworCWlmIChyYWRpdXNfY2xpZW50X3NlbmQoaGFwZC0+cmFkaXVzLCBtc2csCisJCQkgICAgICAgc3RvcCA/IFJBRElVU19BQ0NUIDogUkFESVVTX0FDQ1RfSU5URVJJTSwKKwkJCSAgICAgICBzdGEtPmFkZHIpIDwgMCkKKwkJZ290byBmYWlsOwogCXJldHVybjsKIAogIGZhaWw6CkBAIC00NjMsNyArNTA1LDggQEAKIAkJcmV0dXJuOwogCX0KIAotCXJhZGl1c19jbGllbnRfc2VuZChoYXBkLT5yYWRpdXMsIG1zZywgUkFESVVTX0FDQ1QsIE5VTEwpOworCWlmIChyYWRpdXNfY2xpZW50X3NlbmQoaGFwZC0+cmFkaXVzLCBtc2csIFJBRElVU19BQ0NULCBOVUxMKSA8IDApCisJCXJhZGl1c19tc2dfZnJlZShtc2cpOwogfQogCiAKZGlmZiAtLWdpdCBhL3NyYy9hcC9hcF9jb25maWcuYyBiL3NyYy9hcC9hcF9jb25maWcuYwppbmRleCBiOWY1OTk0Li44MTFmZmMxIDEwMDY0NAotLS0gYS9zcmMvYXAvYXBfY29uZmlnLmMKKysrIGIvc3JjL2FwL2FwX2NvbmZpZy5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIGhvc3RhcGQgLyBDb25maWd1cmF0aW9uIGhlbHBlciBmdW5jdGlvbnMKLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTg3LDYgKzg3LDggQEAKICNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgogCWJzcy0+ZnRfb3Zlcl9kcyA9IDE7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KKworCWJzcy0+cmFkaXVzX2Rhc190aW1lX3dpbmRvdyA9IDMwMDsKIH0KIAogCkBAIC0zMzYsNiArMzM4LDMwIEBACiB9CiAKIAorc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKgoraG9zdGFwZF9jb25maWdfZ2V0X3JhZGl1c19hdHRyKHN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICphdHRyLCB1OCB0eXBlKQoreworCWZvciAoOyBhdHRyOyBhdHRyID0gYXR0ci0+bmV4dCkgeworCQlpZiAoYXR0ci0+dHlwZSA9PSB0eXBlKQorCQkJcmV0dXJuIGF0dHI7CisJfQorCXJldHVybiBOVUxMOworfQorCisKK3N0YXRpYyB2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWVfcmFkaXVzX2F0dHIoc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKmF0dHIpCit7CisJc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgKnByZXY7CisKKwl3aGlsZSAoYXR0cikgeworCQlwcmV2ID0gYXR0cjsKKwkJYXR0ciA9IGF0dHItPm5leHQ7CisJCXdwYWJ1Zl9mcmVlKHByZXYtPnZhbCk7CisJCW9zX2ZyZWUocHJldik7CisJfQorfQorCisKIHN0YXRpYyB2b2lkIGhvc3RhcGRfY29uZmlnX2ZyZWVfZWFwX3VzZXIoc3RydWN0IGhvc3RhcGRfZWFwX3VzZXIgKnVzZXIpCiB7CiAJb3NfZnJlZSh1c2VyLT5pZGVudGl0eSk7CkBAIC0zOTIsNiArNDE4LDggQEAKIAkJCQkgICBjb25mLT5yYWRpdXMtPm51bV9hdXRoX3NlcnZlcnMpOwogCWhvc3RhcGRfY29uZmlnX2ZyZWVfcmFkaXVzKGNvbmYtPnJhZGl1cy0+YWNjdF9zZXJ2ZXJzLAogCQkJCSAgIGNvbmYtPnJhZGl1cy0+bnVtX2FjY3Rfc2VydmVycyk7CisJaG9zdGFwZF9jb25maWdfZnJlZV9yYWRpdXNfYXR0cihjb25mLT5yYWRpdXNfYXV0aF9yZXFfYXR0cik7CisJaG9zdGFwZF9jb25maWdfZnJlZV9yYWRpdXNfYXR0cihjb25mLT5yYWRpdXNfYWNjdF9yZXFfYXR0cik7CiAJb3NfZnJlZShjb25mLT5yc25fcHJlYXV0aF9pbnRlcmZhY2VzKTsKIAlvc19mcmVlKGNvbmYtPmN0cmxfaW50ZXJmYWNlKTsKIAlvc19mcmVlKGNvbmYtPmNhX2NlcnQpOwpAQCAtNDA2LDYgKzQzNCw3IEBACiAJb3NfZnJlZShjb25mLT5yYWRpdXNfc2VydmVyX2NsaWVudHMpOwogCW9zX2ZyZWUoY29uZi0+dGVzdF9zb2NrZXQpOwogCW9zX2ZyZWUoY29uZi0+cmFkaXVzKTsKKwlvc19mcmVlKGNvbmYtPnJhZGl1c19kYXNfc2hhcmVkX3NlY3JldCk7CiAJaG9zdGFwZF9jb25maWdfZnJlZV92bGFuKGNvbmYpOwogCWlmIChjb25mLT5zc2lkLmR5bl92bGFuX2tleXMpIHsKIAkJc3RydWN0IGhvc3RhcGRfc3NpZCAqc3NpZCA9ICZjb25mLT5zc2lkOwpAQCAtNDY1LDkgKzQ5NCwxMyBAQAogCW9zX2ZyZWUoY29uZi0+bW9kZWxfZGVzY3JpcHRpb24pOwogCW9zX2ZyZWUoY29uZi0+bW9kZWxfdXJsKTsKIAlvc19mcmVlKGNvbmYtPnVwYyk7CisJd3BhYnVmX2ZyZWUoY29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCXdwYWJ1Zl9mcmVlKGNvbmYtPndwc19uZmNfZGhfcHJpdmtleSk7CisJd3BhYnVmX2ZyZWUoY29uZi0+d3BzX25mY19kZXZfcHcpOwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAogCW9zX2ZyZWUoY29uZi0+cm9hbWluZ19jb25zb3J0aXVtKTsKKwlvc19mcmVlKGNvbmYtPnZlbnVlX25hbWUpOwogCiAjaWZkZWYgQ09ORklHX1JBRElVU19URVNUCiAJb3NfZnJlZShjb25mLT5kdW1wX21za19maWxlKTsKZGlmZiAtLWdpdCBhL3NyYy9hcC9hcF9jb25maWcuaCBiL3NyYy9hcC9hcF9jb25maWcuaAppbmRleCAyZWMyNWFkLi4xM2Q1NTQ5IDEwMDY0NAotLS0gYS9zcmMvYXAvYXBfY29uZmlnLmgKKysrIGIvc3JjL2FwL2FwX2NvbmZpZy5oCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIGhvc3RhcGQgLyBDb25maWd1cmF0aW9uIGRlZmluaXRpb25zIGFuZCBoZWxwZXJzIGZ1bmN0aW9ucwotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTE2LDYgKzExNiwxMiBAQAogCWludCB0dGxzX2F1dGg7IC8qIEVBUF9UVExTX0FVVEhfKiBiaXRmaWVsZCAqLwogfTsKIAorc3RydWN0IGhvc3RhcGRfcmFkaXVzX2F0dHIgeworCXU4IHR5cGU7CisJc3RydWN0IHdwYWJ1ZiAqdmFsOworCXN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICpuZXh0OworfTsKKwogCiAjZGVmaW5lIE5VTV9UWF9RVUVVRVMgNAogCkBAIC0xNDIsNiArMTQ4LDEyIEBACiAJdTggb2lbTUFYX1JPQU1JTkdfQ09OU09SVElVTV9MRU5dOwogfTsKIAorc3RydWN0IGhvc3RhcGRfdmVudWVfbmFtZSB7CisJdTggbGFuZ1szXTsKKwl1OCBuYW1lX2xlbjsKKwl1OCBuYW1lWzI1Ml07Cit9OworCiAvKioKICAqIHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgLSBQZXItQlNTIGNvbmZpZ3VyYXRpb24KICAqLwpAQCAtMTcxLDYgKzE4MywxNSBAQAogCWNoYXIgKm5hc19pZGVudGlmaWVyOwogCXN0cnVjdCBob3N0YXBkX3JhZGl1c19zZXJ2ZXJzICpyYWRpdXM7CiAJaW50IGFjY3RfaW50ZXJpbV9pbnRlcnZhbDsKKwlpbnQgcmFkaXVzX3JlcXVlc3RfY3VpOworCXN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICpyYWRpdXNfYXV0aF9yZXFfYXR0cjsKKwlzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfYXR0ciAqcmFkaXVzX2FjY3RfcmVxX2F0dHI7CisJaW50IHJhZGl1c19kYXNfcG9ydDsKKwl1bnNpZ25lZCBpbnQgcmFkaXVzX2Rhc190aW1lX3dpbmRvdzsKKwlpbnQgcmFkaXVzX2Rhc19yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcDsKKwlzdHJ1Y3QgaG9zdGFwZF9pcF9hZGRyIHJhZGl1c19kYXNfY2xpZW50X2FkZHI7CisJdTggKnJhZGl1c19kYXNfc2hhcmVkX3NlY3JldDsKKwlzaXplX3QgcmFkaXVzX2Rhc19zaGFyZWRfc2VjcmV0X2xlbjsKIAogCXN0cnVjdCBob3N0YXBkX3NzaWQgc3NpZDsKIApAQCAtMzI2LDYgKzM0NywxMCBAQAogCWNoYXIgKm1vZGVsX3VybDsKIAljaGFyICp1cGM7CiAJc3RydWN0IHdwYWJ1ZiAqd3BzX3ZlbmRvcl9leHRbTUFYX1dQU19WRU5ET1JfRVhURU5TSU9OU107CisJaW50IHdwc19uZmNfZGV2X3B3X2lkOworCXN0cnVjdCB3cGFidWYgKndwc19uZmNfZGhfcHVia2V5OworCXN0cnVjdCB3cGFidWYgKndwc19uZmNfZGhfcHJpdmtleTsKKwlzdHJ1Y3Qgd3BhYnVmICp3cHNfbmZjX2Rldl9wdzsKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAJaW50IHBiY19pbl9tMTsKIApAQCAtMzQzLDYgKzM2OCw3IEBACiAjZGVmaW5lIFRETFNfUFJPSElCSVRfQ0hBTl9TV0lUQ0ggQklUKDEpCiAJaW50IHRkbHM7CiAJaW50IGRpc2FibGVfMTFuOworCWludCBkaXNhYmxlXzExYWM7CiAKIAkvKiBJRUVFIDgwMi4xMXYgKi8KIAlpbnQgdGltZV9hZHZlcnRpc2VtZW50OwpAQCAtMzY0LDYgKzM5MCwxMyBAQAogCXVuc2lnbmVkIGludCByb2FtaW5nX2NvbnNvcnRpdW1fY291bnQ7CiAJc3RydWN0IGhvc3RhcGRfcm9hbWluZ19jb25zb3J0aXVtICpyb2FtaW5nX2NvbnNvcnRpdW07CiAKKwkvKiBJRUVFIDgwMi4xMXUgLSBWZW51ZSBOYW1lIGR1cGxlcyAqLworCXVuc2lnbmVkIGludCB2ZW51ZV9uYW1lX2NvdW50OworCXN0cnVjdCBob3N0YXBkX3ZlbnVlX25hbWUgKnZlbnVlX25hbWU7CisKKwl1MTYgZ2FzX2NvbWViYWNrX2RlbGF5OworCWludCBnYXNfZnJhZ19saW1pdDsKKwogCXU4IHdwc19yZl9iYW5kczsgLyogUkYgYmFuZHMgZm9yIFdQUyAoV1BTX1JGXyopICovCiAKICNpZmRlZiBDT05GSUdfUkFESVVTX1RFU1QKQEAgLTQyMyw2ICs0NTYsOSBAQAogCWludCBpZWVlODAyMTFuOwogCWludCBzZWNvbmRhcnlfY2hhbm5lbDsKIAlpbnQgcmVxdWlyZV9odDsKKwl1MzIgdmh0X2NhcGFiOworCWludCBpZWVlODAyMTFhYzsKKwl1OCB2aHRfb3Blcl9jaHdpZHRoOwogfTsKIAogCkBAIC00NDQsNSArNDgwLDcgQEAKIGNvbnN0IHN0cnVjdCBob3N0YXBkX2VhcF91c2VyICoKIGhvc3RhcGRfZ2V0X2VhcF91c2VyKGNvbnN0IHN0cnVjdCBob3N0YXBkX2Jzc19jb25maWcgKmNvbmYsIGNvbnN0IHU4ICppZGVudGl0eSwKIAkJICAgICBzaXplX3QgaWRlbnRpdHlfbGVuLCBpbnQgcGhhc2UyKTsKK3N0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICoKK2hvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihzdHJ1Y3QgaG9zdGFwZF9yYWRpdXNfYXR0ciAqYXR0ciwgdTggdHlwZSk7CiAKICNlbmRpZiAvKiBIT1NUQVBEX0NPTkZJR19IICovCmRpZmYgLS1naXQgYS9zcmMvYXAvYXBfZHJ2X29wcy5jIGIvc3JjL2FwL2FwX2Rydl9vcHMuYwppbmRleCBkMDdjYzZiLi44NTliNTI5IDEwMDY0NAotLS0gYS9zcmMvYXAvYXBfZHJ2X29wcy5jCisrKyBiL3NyYy9hcC9hcF9kcnZfb3BzLmMKQEAgLTU4NCwzICs1ODQsMTUgQEAKIAlyZXR1cm4gaGFwZC0+ZHJpdmVyLT5zdGFfZGlzYXNzb2MoaGFwZC0+ZHJ2X3ByaXYsIGhhcGQtPm93bl9hZGRyLCBhZGRyLAogCQkJCQkgIHJlYXNvbik7CiB9CisKKworaW50IGhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHVuc2lnbmVkIGludCBmcmVxLAorCQkJICAgIHVuc2lnbmVkIGludCB3YWl0LCBjb25zdCB1OCAqZHN0LCBjb25zdCB1OCAqZGF0YSwKKwkJCSAgICBzaXplX3QgbGVuKQoreworCWlmIChoYXBkLT5kcml2ZXIgPT0gTlVMTCB8fCBoYXBkLT5kcml2ZXItPnNlbmRfYWN0aW9uID09IE5VTEwpCisJCXJldHVybiAwOworCXJldHVybiBoYXBkLT5kcml2ZXItPnNlbmRfYWN0aW9uKGhhcGQtPmRydl9wcml2LCBmcmVxLCB3YWl0LCBkc3QsCisJCQkJCSBoYXBkLT5vd25fYWRkciwgaGFwZC0+b3duX2FkZHIsIGRhdGEsCisJCQkJCSBsZW4sIDApOworfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2Rydl9vcHMuaCBiL3NyYy9hcC9hcF9kcnZfb3BzLmgKaW5kZXggODAzOGZhMi4uMTY5YzkxYiAxMDA2NDQKLS0tIGEvc3JjL2FwL2FwX2Rydl9vcHMuaAorKysgYi9zcmMvYXAvYXBfZHJ2X29wcy5oCkBAIC04Niw2ICs4Niw5IEBACiAJCQkgICBjb25zdCB1OCAqYWRkciwgaW50IHJlYXNvbik7CiBpbnQgaG9zdGFwZF9kcnZfc3RhX2Rpc2Fzc29jKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkgICAgIGNvbnN0IHU4ICphZGRyLCBpbnQgcmVhc29uKTsKK2ludCBob3N0YXBkX2Rydl9zZW5kX2FjdGlvbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1bnNpZ25lZCBpbnQgZnJlcSwKKwkJCSAgICB1bnNpZ25lZCBpbnQgd2FpdCwgY29uc3QgdTggKmRzdCwgY29uc3QgdTggKmRhdGEsCisJCQkgICAgc2l6ZV90IGxlbik7CiBpbnQgaG9zdGFwZF9hZGRfc3RhX25vZGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsCiAJCQkgdTE2IGF1dGhfYWxnKTsKIGludCBob3N0YXBkX3N0YV9hdXRoKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICphZGRyLApkaWZmIC0tZ2l0IGEvc3JjL2FwL2FwX2xpc3QuYyBiL3NyYy9hcC9hcF9saXN0LmMKaW5kZXggYjQyNTJjZi4uOTMzYjE1OCAxMDA2NDQKLS0tIGEvc3JjL2FwL2FwX2xpc3QuYworKysgYi9zcmMvYXAvYXBfbGlzdC5jCkBAIC0yODksMTAgKzI4OSw4IEBACiAJYXAtPm51bV9iZWFjb25zKys7CiAJb3NfZ2V0X3RpbWUoJm5vdyk7CiAJYXAtPmxhc3RfYmVhY29uID0gbm93LnNlYzsKLQlpZiAoZmkpIHsKLQkJYXAtPnNzaV9zaWduYWwgPSBmaS0+c3NpX3NpZ25hbDsKKwlpZiAoZmkpCiAJCWFwLT5kYXRhcmF0ZSA9IGZpLT5kYXRhcmF0ZTsKLQl9CiAKIAlpZiAoIW5ld19hcCAmJiBhcCAhPSBpZmFjZS0+YXBfbGlzdCkgewogCQkvKiBtb3ZlIEFQIGVudHJ5IGludG8gdGhlIGJlZ2lubmluZyBvZiB0aGUgbGlzdCBzbyB0aGF0IHRoZQpAQCAtMzIwLDcgKzMxOCw3IEBACiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMU4gKi8KIAogCWlmIChzZXRfYmVhY29uKQotCQlpZWVlODAyXzExX3NldF9iZWFjb25zKGlmYWNlKTsKKwkJaWVlZTgwMl8xMV91cGRhdGVfYmVhY29ucyhpZmFjZSk7CiB9CiAKIApAQCAtMzc1LDcgKzM3Myw3IEBACiAJfQogCiAJaWYgKHNldF9iZWFjb24pCi0JCWllZWU4MDJfMTFfc2V0X2JlYWNvbnMoaWZhY2UpOworCQlpZWVlODAyXzExX3VwZGF0ZV9iZWFjb25zKGlmYWNlKTsKIH0KIAogCmRpZmYgLS1naXQgYS9zcmMvYXAvYXBfbGlzdC5oIGIvc3JjL2FwL2FwX2xpc3QuaAppbmRleCAyMDFmNmVjLi5mMGI0MTI1IDEwMDY0NAotLS0gYS9zcmMvYXAvYXBfbGlzdC5oCisrKyBiL3NyYy9hcC9hcF9saXN0LmgKQEAgLTM0LDcgKzM0LDYgQEAKIAogCWludCBjaGFubmVsOwogCWludCBkYXRhcmF0ZTsgLyogaW4gMTAwIGticHMgKi8KLQlpbnQgc3NpX3NpZ25hbDsKIAogCWludCBodF9zdXBwb3J0OwogCmRpZmYgLS1naXQgYS9zcmMvYXAvYmVhY29uLmMgYi9zcmMvYXAvYmVhY29uLmMKaW5kZXggNGVhODY4NC4uMGYyOWNjZCAxMDA2NDQKLS0tIGEvc3JjL2FwL2JlYWNvbi5jCisrKyBiL3NyYy9hcC9iZWFjb24uYwpAQCAtMjYyLDYgKzI2MiwxMSBAQAogCXBvcyA9IGhvc3RhcGRfZWlkX2Fkdl9wcm90byhoYXBkLCBwb3MpOwogCXBvcyA9IGhvc3RhcGRfZWlkX3JvYW1pbmdfY29uc29ydGl1bShoYXBkLCBwb3MpOwogCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCisJcG9zID0gaG9zdGFwZF9laWRfdmh0X2NhcGFiaWxpdGllcyhoYXBkLCBwb3MpOworCXBvcyA9IGhvc3RhcGRfZWlkX3ZodF9vcGVyYXRpb24oaGFwZCwgcG9zKTsKKyNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExQUMgKi8KKwogCS8qIFdpLUZpIEFsbGlhbmNlIFdNTSAqLwogCXBvcyA9IGhvc3RhcGRfZWlkX3dtbShoYXBkLCBwb3MpOwogCkBAIC0yOTMsNyArMjk4LDggQEAKIAogCiB2b2lkIGhhbmRsZV9wcm9iZV9yZXEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKLQkJICAgICAgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LCBzaXplX3QgbGVuKQorCQkgICAgICBjb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQsIHNpemVfdCBsZW4sCisJCSAgICAgIGludCBzc2lfc2lnbmFsKQogewogCXU4ICpyZXNwOwogCXN0cnVjdCBpZWVlODAyXzExX2VsZW1zIGVsZW1zOwpAQCAtMzExLDcgKzMxNyw3IEBACiAJZm9yIChpID0gMDsgaGFwZC0+cHJvYmVyZXFfY2IgJiYgaSA8IGhhcGQtPm51bV9wcm9iZXJlcV9jYjsgaSsrKQogCQlpZiAoaGFwZC0+cHJvYmVyZXFfY2JbaV0uY2IoaGFwZC0+cHJvYmVyZXFfY2JbaV0uY3R4LAogCQkJCQkgICAgbWdtdC0+c2EsIG1nbXQtPmRhLCBtZ210LT5ic3NpZCwKLQkJCQkJICAgIGllLCBpZV9sZW4pID4gMCkKKwkJCQkJICAgIGllLCBpZV9sZW4sIHNzaV9zaWduYWwpID4gMCkKIAkJCXJldHVybjsKIAogCWlmICghaGFwZC0+aWNvbmYtPnNlbmRfcHJvYmVfcmVzcG9uc2UpCkBAIC01OTQsNiArNjAwLDExIEBACiAJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX2Fkdl9wcm90byhoYXBkLCB0YWlscG9zKTsKIAl0YWlscG9zID0gaG9zdGFwZF9laWRfcm9hbWluZ19jb25zb3J0aXVtKGhhcGQsIHRhaWxwb3MpOwogCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMUFDCisJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX3ZodF9jYXBhYmlsaXRpZXMoaGFwZCwgdGFpbHBvcyk7CisJdGFpbHBvcyA9IGhvc3RhcGRfZWlkX3ZodF9vcGVyYXRpb24oaGFwZCwgdGFpbHBvcyk7CisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMUFDICovCisKIAkvKiBXaS1GaSBBbGxpYW5jZSBXTU0gKi8KIAl0YWlscG9zID0gaG9zdGFwZF9laWRfd21tKGhhcGQsIHRhaWxwb3MpOwogCkBAIC02ODIsNiArNjkzLDcgQEAKIAkgICAgIWlzX3plcm9fZXRoZXJfYWRkcihoYXBkLT5jb25mLT5oZXNzaWQpKQogCQlwYXJhbXMuaGVzc2lkID0gaGFwZC0+Y29uZi0+aGVzc2lkOwogCXBhcmFtcy5hY2Nlc3NfbmV0d29ya190eXBlID0gaGFwZC0+Y29uZi0+YWNjZXNzX25ldHdvcmtfdHlwZTsKKwlwYXJhbXMuYXBfbWF4X2luYWN0aXZpdHkgPSBoYXBkLT5jb25mLT5hcF9tYXhfaW5hY3Rpdml0eTsKIAlpZiAoaG9zdGFwZF9kcnZfc2V0X2FwKGhhcGQsICZwYXJhbXMpKQogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBzZXQgYmVhY29uIHBhcmFtZXRlcnMiKTsKIAlob3N0YXBkX2ZyZWVfYXBfZXh0cmFfaWVzKGhhcGQsIGJlYWNvbiwgcHJvYmVyZXNwLCBhc3NvY3Jlc3ApOwpAQCAtNjk5LDQgKzcxMSwxNCBAQAogCQlpZWVlODAyXzExX3NldF9iZWFjb24oaWZhY2UtPmJzc1tpXSk7CiB9CiAKKworLyogb25seSB1cGRhdGUgYmVhY29ucyBpZiBzdGFydGVkICovCit2b2lkIGllZWU4MDJfMTFfdXBkYXRlX2JlYWNvbnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQoreworCXNpemVfdCBpOworCWZvciAoaSA9IDA7IGkgPCBpZmFjZS0+bnVtX2JzczsgaSsrKQorCQlpZiAoaWZhY2UtPmJzc1tpXS0+YmVhY29uX3NldF9kb25lKQorCQkJaWVlZTgwMl8xMV9zZXRfYmVhY29uKGlmYWNlLT5ic3NbaV0pOworfQorCiAjZW5kaWYgLyogQ09ORklHX05BVElWRV9XSU5ET1dTICovCmRpZmYgLS1naXQgYS9zcmMvYXAvYmVhY29uLmggYi9zcmMvYXAvYmVhY29uLmgKaW5kZXggYTk0NGY1Zi4uMzdmMTBkMiAxMDA2NDQKLS0tIGEvc3JjL2FwL2JlYWNvbi5oCisrKyBiL3NyYy9hcC9iZWFjb24uaApAQCAtMTksOCArMTksMTAgQEAKIHN0cnVjdCBpZWVlODAyMTFfbWdtdDsKIAogdm9pZCBoYW5kbGVfcHJvYmVfcmVxKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCi0JCSAgICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdCwgc2l6ZV90IGxlbik7CisJCSAgICAgIGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdCwgc2l6ZV90IGxlbiwKKwkJICAgICAgaW50IHNzaV9zaWduYWwpOwogdm9pZCBpZWVlODAyXzExX3NldF9iZWFjb24oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CiB2b2lkIGllZWU4MDJfMTFfc2V0X2JlYWNvbnMoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKK3ZvaWQgaWVlZTgwMl8xMV91cGRhdGVfYmVhY29ucyhzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpOwogCiAjZW5kaWYgLyogQkVBQ09OX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmMgYi9zcmMvYXAvY3RybF9pZmFjZV9hcC5jCmluZGV4IGQ3NmIzODEuLmFiOWM4M2UgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmMKKysrIGIvc3JjL2FwL2N0cmxfaWZhY2VfYXAuYwpAQCAtOSw2ICs5LDcgQEAKICNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgogCiAjaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCisjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImhvc3RhcGQuaCIKICNpbmNsdWRlICJpZWVlODAyXzF4LmgiCiAjaW5jbHVkZSAid3BhX2F1dGguaCIKQEAgLTE3LDYgKzE4LDcgQEAKICNpbmNsdWRlICJ3cHNfaG9zdGFwZC5oIgogI2luY2x1ZGUgInAycF9ob3N0YXBkLmgiCiAjaW5jbHVkZSAiY3RybF9pZmFjZV9hcC5oIgorI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKIAogCiBzdGF0aWMgaW50IGhvc3RhcGRfY3RybF9pZmFjZV9zdGFfbWliKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCkBAIC0xMDAsMyArMTAyLDE3MCBAQAogCX0JCQogCXJldHVybiBob3N0YXBkX2N0cmxfaWZhY2Vfc3RhX21pYihoYXBkLCBzdGEtPm5leHQsIGJ1ZiwgYnVmbGVuKTsKIH0KKworCisjaWZkZWYgQ09ORklHX1AyUF9NQU5BR0VSCitzdGF0aWMgaW50IHAycF9tYW5hZ2VyX2Rpc2Nvbm5lY3Qoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTE2IHN0eXBlLAorCQkJCSAgdTggbWlub3JfcmVhc29uX2NvZGUsIGNvbnN0IHU4ICphZGRyKQoreworCXN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKKwlpbnQgcmV0OworCXU4ICpwb3M7CisKKwlpZiAoaGFwZC0+ZHJpdmVyLT5zZW5kX2ZyYW1lID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCW1nbXQgPSBvc196YWxsb2Moc2l6ZW9mKCptZ210KSArIDEwMCk7CisJaWYgKG1nbXQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJd3BhX2RiZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IERpc2Nvbm5lY3QgU1RBICIgTUFDU1RSCisJCSIgd2l0aCBtaW5vciByZWFzb24gY29kZSAldSAoc3R5cGU9JXUpIiwKKwkJTUFDMlNUUihhZGRyKSwgbWlub3JfcmVhc29uX2NvZGUsIHN0eXBlKTsKKworCW1nbXQtPmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsIHN0eXBlKTsKKwlvc19tZW1jcHkobWdtdC0+ZGEsIGFkZHIsIEVUSF9BTEVOKTsKKwlvc19tZW1jcHkobWdtdC0+c2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CisJb3NfbWVtY3B5KG1nbXQtPmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOworCWlmIChzdHlwZSA9PSBXTEFOX0ZDX1NUWVBFX0RFQVVUSCkgeworCQltZ210LT51LmRlYXV0aC5yZWFzb25fY29kZSA9CisJCQlob3N0X3RvX2xlMTYoV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7CisJCXBvcyA9ICh1OCAqKSAoJm1nbXQtPnUuZGVhdXRoLnJlYXNvbl9jb2RlICsgMSk7CisJfSBlbHNlIHsKKwkJbWdtdC0+dS5kaXNhc3NvYy5yZWFzb25fY29kZSA9CisJCQlob3N0X3RvX2xlMTYoV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7CisJCXBvcyA9ICh1OCAqKSAoJm1nbXQtPnUuZGlzYXNzb2MucmVhc29uX2NvZGUgKyAxKTsKKwl9CisKKwkqcG9zKysgPSBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUM7CisJKnBvcysrID0gNCArIDMgKyAxOworCVdQQV9QVVRfQkUyNChwb3MsIE9VSV9XRkEpOworCXBvcyArPSAzOworCSpwb3MrKyA9IFAyUF9PVUlfVFlQRTsKKworCSpwb3MrKyA9IFAyUF9BVFRSX01JTk9SX1JFQVNPTl9DT0RFOworCVdQQV9QVVRfTEUxNihwb3MsIDEpOworCXBvcyArPSAyOworCSpwb3MrKyA9IG1pbm9yX3JlYXNvbl9jb2RlOworCisJcmV0ID0gaGFwZC0+ZHJpdmVyLT5zZW5kX2ZyYW1lKGhhcGQtPmRydl9wcml2LCAodTggKikgbWdtdCwKKwkJCQkgICAgICAgcG9zIC0gKHU4ICopIG1nbXQsIDEpOworCW9zX2ZyZWUobWdtdCk7CisKKwlyZXR1cm4gcmV0IDwgMCA/IC0xIDogMDsKK30KKyNlbmRpZiAvKiBDT05GSUdfUDJQX01BTkFHRVIgKi8KKworCitpbnQgaG9zdGFwZF9jdHJsX2lmYWNlX2RlYXV0aGVudGljYXRlKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJICAgICAgY29uc3QgY2hhciAqdHh0YWRkcikKK3sKKwl1OCBhZGRyW0VUSF9BTEVOXTsKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKKwljb25zdCBjaGFyICpwb3M7CisKKwl3cGFfZGJnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgREVBVVRIRU5USUNBVEUgJXMiLAorCQl0eHRhZGRyKTsKKworCWlmIChod2FkZHJfYXRvbih0eHRhZGRyLCBhZGRyKSkKKwkJcmV0dXJuIC0xOworCisJcG9zID0gb3Nfc3Ryc3RyKHR4dGFkZHIsICIgdGVzdD0iKTsKKwlpZiAocG9zKSB7CisJCXN0cnVjdCBpZWVlODAyMTFfbWdtdCBtZ210OworCQlpbnQgZW5jcnlwdDsKKwkJaWYgKGhhcGQtPmRyaXZlci0+c2VuZF9mcmFtZSA9PSBOVUxMKQorCQkJcmV0dXJuIC0xOworCQlwb3MgKz0gNjsKKwkJZW5jcnlwdCA9IGF0b2kocG9zKTsKKwkJb3NfbWVtc2V0KCZtZ210LCAwLCBzaXplb2YobWdtdCkpOworCQltZ210LmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCisJCQkJCQkgIFdMQU5fRkNfU1RZUEVfREVBVVRIKTsKKwkJb3NfbWVtY3B5KG1nbXQuZGEsIGFkZHIsIEVUSF9BTEVOKTsKKwkJb3NfbWVtY3B5KG1nbXQuc2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CisJCW9zX21lbWNweShtZ210LmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOworCQltZ210LnUuZGVhdXRoLnJlYXNvbl9jb2RlID0KKwkJCWhvc3RfdG9fbGUxNihXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKKwkJaWYgKGhhcGQtPmRyaXZlci0+c2VuZF9mcmFtZShoYXBkLT5kcnZfcHJpdiwgKHU4ICopICZtZ210LAorCQkJCQkgICAgIElFRUU4MDIxMV9IRFJMRU4gKworCQkJCQkgICAgIHNpemVvZihtZ210LnUuZGVhdXRoKSwKKwkJCQkJICAgICBlbmNyeXB0KSA8IDApCisJCQlyZXR1cm4gLTE7CisJCXJldHVybiAwOworCX0KKworI2lmZGVmIENPTkZJR19QMlBfTUFOQUdFUgorCXBvcyA9IG9zX3N0cnN0cih0eHRhZGRyLCAiIHAycD0iKTsKKwlpZiAocG9zKSB7CisJCXJldHVybiBwMnBfbWFuYWdlcl9kaXNjb25uZWN0KGhhcGQsIFdMQU5fRkNfU1RZUEVfREVBVVRILAorCQkJCQkgICAgICBhdG9pKHBvcyArIDUpLCBhZGRyKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1AyUF9NQU5BR0VSICovCisKKwlob3N0YXBkX2Rydl9zdGFfZGVhdXRoKGhhcGQsIGFkZHIsIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgYWRkcik7CisJaWYgKHN0YSkKKwkJYXBfc3RhX2RlYXV0aGVudGljYXRlKGhhcGQsIHN0YSwKKwkJCQkgICAgICBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKKwllbHNlIGlmIChhZGRyWzBdID09IDB4ZmYpCisJCWhvc3RhcGRfZnJlZV9zdGFzKGhhcGQpOworCisJcmV0dXJuIDA7Cit9CisKKworaW50IGhvc3RhcGRfY3RybF9pZmFjZV9kaXNhc3NvY2lhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgY29uc3QgY2hhciAqdHh0YWRkcikKK3sKKwl1OCBhZGRyW0VUSF9BTEVOXTsKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKKwljb25zdCBjaGFyICpwb3M7CisKKwl3cGFfZGJnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgRElTQVNTT0NJQVRFICVzIiwKKwkJdHh0YWRkcik7CisKKwlpZiAoaHdhZGRyX2F0b24odHh0YWRkciwgYWRkcikpCisJCXJldHVybiAtMTsKKworCXBvcyA9IG9zX3N0cnN0cih0eHRhZGRyLCAiIHRlc3Q9Iik7CisJaWYgKHBvcykgeworCQlzdHJ1Y3QgaWVlZTgwMjExX21nbXQgbWdtdDsKKwkJaW50IGVuY3J5cHQ7CisJCWlmIChoYXBkLT5kcml2ZXItPnNlbmRfZnJhbWUgPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKKwkJcG9zICs9IDY7CisJCWVuY3J5cHQgPSBhdG9pKHBvcyk7CisJCW9zX21lbXNldCgmbWdtdCwgMCwgc2l6ZW9mKG1nbXQpKTsKKwkJbWdtdC5mcmFtZV9jb250cm9sID0gSUVFRTgwMjExX0ZDKFdMQU5fRkNfVFlQRV9NR01ULAorCQkJCQkJICBXTEFOX0ZDX1NUWVBFX0RJU0FTU09DKTsKKwkJb3NfbWVtY3B5KG1nbXQuZGEsIGFkZHIsIEVUSF9BTEVOKTsKKwkJb3NfbWVtY3B5KG1nbXQuc2EsIGhhcGQtPm93bl9hZGRyLCBFVEhfQUxFTik7CisJCW9zX21lbWNweShtZ210LmJzc2lkLCBoYXBkLT5vd25fYWRkciwgRVRIX0FMRU4pOworCQltZ210LnUuZGlzYXNzb2MucmVhc29uX2NvZGUgPQorCQkJaG9zdF90b19sZTE2KFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCQlpZiAoaGFwZC0+ZHJpdmVyLT5zZW5kX2ZyYW1lKGhhcGQtPmRydl9wcml2LCAodTggKikgJm1nbXQsCisJCQkJCSAgICAgSUVFRTgwMjExX0hEUkxFTiArCisJCQkJCSAgICAgc2l6ZW9mKG1nbXQudS5kZWF1dGgpLAorCQkJCQkgICAgIGVuY3J5cHQpIDwgMCkKKwkJCXJldHVybiAtMTsKKwkJcmV0dXJuIDA7CisJfQorCisjaWZkZWYgQ09ORklHX1AyUF9NQU5BR0VSCisJcG9zID0gb3Nfc3Ryc3RyKHR4dGFkZHIsICIgcDJwPSIpOworCWlmIChwb3MpIHsKKwkJcmV0dXJuIHAycF9tYW5hZ2VyX2Rpc2Nvbm5lY3QoaGFwZCwgV0xBTl9GQ19TVFlQRV9ESVNBU1NPQywKKwkJCQkJICAgICAgYXRvaShwb3MgKyA1KSwgYWRkcik7CisJfQorI2VuZGlmIC8qIENPTkZJR19QMlBfTUFOQUdFUiAqLworCisJaG9zdGFwZF9kcnZfc3RhX2Rpc2Fzc29jKGhhcGQsIGFkZHIsIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgYWRkcik7CisJaWYgKHN0YSkKKwkJYXBfc3RhX2Rpc2Fzc29jaWF0ZShoYXBkLCBzdGEsCisJCQkJICAgIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCWVsc2UgaWYgKGFkZHJbMF0gPT0gMHhmZikKKwkJaG9zdGFwZF9mcmVlX3N0YXMoaGFwZCk7CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmggYi9zcmMvYXAvY3RybF9pZmFjZV9hcC5oCmluZGV4IDBlNDI4NmQuLmU4M2Y4OTQgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9jdHJsX2lmYWNlX2FwLmgKKysrIGIvc3JjL2FwL2N0cmxfaWZhY2VfYXAuaApAQCAtMTUsNSArMTUsOSBAQAogCQkJICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKTsKIGludCBob3N0YXBkX2N0cmxfaWZhY2Vfc3RhX25leHQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgY2hhciAqdHh0YWRkciwKIAkJCQljaGFyICpidWYsIHNpemVfdCBidWZsZW4pOworaW50IGhvc3RhcGRfY3RybF9pZmFjZV9kZWF1dGhlbnRpY2F0ZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICAgIGNvbnN0IGNoYXIgKnR4dGFkZHIpOworaW50IGhvc3RhcGRfY3RybF9pZmFjZV9kaXNhc3NvY2lhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgY29uc3QgY2hhciAqdHh0YWRkcik7CiAKICNlbmRpZiAvKiBDVFJMX0lGQUNFX0FQX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9kcnZfY2FsbGJhY2tzLmMgYi9zcmMvYXAvZHJ2X2NhbGxiYWNrcy5jCmluZGV4IDgyMGE5MDMuLmNmMDZhNGYgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9kcnZfY2FsbGJhY2tzLmMKKysrIGIvc3JjL2FwL2Rydl9jYWxsYmFja3MuYwpAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgIndwc19ob3N0YXBkLmgiCiAjaW5jbHVkZSAiYXBfZHJ2X29wcy5oIgogI2luY2x1ZGUgImFwX2NvbmZpZy5oIgorI2luY2x1ZGUgImh3X2ZlYXR1cmVzLmgiCiAKIAogaW50IGhvc3RhcGRfbm90aWZfYXNzb2Moc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsCkBAIC03OCwxMCArNzksMTkgQEAKIAlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIGFkZHIpOwogCWlmIChzdGEpIHsKIAkJYWNjb3VudGluZ19zdGFfc3RvcChoYXBkLCBzdGEpOworCisJCS8qCisJCSAqIE1ha2Ugc3VyZSB0aGF0IHRoZSBwcmV2aW91c2x5IHJlZ2lzdGVyZWQgaW5hY3Rpdml0eSB0aW1lcgorCQkgKiB3aWxsIG5vdCByZW1vdmUgdGhlIFNUQSBpbW1lZGlhdGVseS4KKwkJICovCisJCXN0YS0+dGltZW91dF9uZXh0ID0gU1RBX05VTExGVU5DOwogCX0gZWxzZSB7CiAJCXN0YSA9IGFwX3N0YV9hZGQoaGFwZCwgYWRkcik7Ci0JCWlmIChzdGEgPT0gTlVMTCkKKwkJaWYgKHN0YSA9PSBOVUxMKSB7CisJCQlob3N0YXBkX2Rydl9zdGFfZGlzYXNzb2MoaGFwZCwgYWRkciwKKwkJCQkJCSBXTEFOX1JFQVNPTl9ESVNBU1NPQ19BUF9CVVNZKTsKIAkJCXJldHVybiAtMTsKKwkJfQogCX0KIAlzdGEtPmZsYWdzICY9IH4oV0xBTl9TVEFfV1BTIHwgV0xBTl9TVEFfTUFZQkVfV1BTIHwgV0xBTl9TVEFfV1BTMik7CiAKQEAgLTI2NCw4ICsyNzQsMzYgQEAKIH0KIAogCit2b2lkIGhvc3RhcGRfZXZlbnRfY2hfc3dpdGNoKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGludCBmcmVxLCBpbnQgaHQsCisJCQkgICAgIGludCBvZmZzZXQpCit7CisjaWZkZWYgTkVFRF9BUF9NTE1FCisJaW50IGNoYW5uZWw7CisKKwlob3N0YXBkX2xvZ2dlcihoYXBkLCBOVUxMLCBIT1NUQVBEX01PRFVMRV9JRUVFODAyMTEsCisJCSAgICAgICBIT1NUQVBEX0xFVkVMX0lORk8sICJkcml2ZXIgaGFkIGNoYW5uZWwgc3dpdGNoOiAiCisJCSAgICAgICAiZnJlcT0lZCwgaHQ9JWQsIG9mZnNldD0lZCIsIGZyZXEsIGh0LCBvZmZzZXQpOworCisJaGFwZC0+aWZhY2UtPmZyZXEgPSBmcmVxOworCisJY2hhbm5lbCA9IGhvc3RhcGRfaHdfZ2V0X2NoYW5uZWwoaGFwZCwgZnJlcSk7CisJaWYgKCFjaGFubmVsKSB7CisJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIE5VTEwsIEhPU1RBUERfTU9EVUxFX0lFRUU4MDIxMSwKKwkJCSAgICAgICBIT1NUQVBEX0xFVkVMX1dBUk5JTkcsICJkcml2ZXIgc3dpdGNoZWQgdG8gIgorCQkJICAgICAgICJiYWQgY2hhbm5lbCEiKTsKKwkJcmV0dXJuOworCX0KKworCWhhcGQtPmljb25mLT5jaGFubmVsID0gY2hhbm5lbDsKKwloYXBkLT5pY29uZi0+aWVlZTgwMjExbiA9IGh0OworCWhhcGQtPmljb25mLT5zZWNvbmRhcnlfY2hhbm5lbCA9IG9mZnNldDsKKyNlbmRpZiAvKiBORUVEX0FQX01MTUUgKi8KK30KKworCiBpbnQgaG9zdGFwZF9wcm9iZV9yZXFfcngoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKnNhLCBjb25zdCB1OCAqZGEsCi0JCQkgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pCisJCQkgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkgaW50IHNzaV9zaWduYWwpCiB7CiAJc2l6ZV90IGk7CiAJaW50IHJldCA9IDA7CkBAIC0yNzYsNyArMzE0LDggQEAKIAlyYW5kb21fYWRkX3JhbmRvbW5lc3Moc2EsIEVUSF9BTEVOKTsKIAlmb3IgKGkgPSAwOyBoYXBkLT5wcm9iZXJlcV9jYiAmJiBpIDwgaGFwZC0+bnVtX3Byb2JlcmVxX2NiOyBpKyspIHsKIAkJaWYgKGhhcGQtPnByb2JlcmVxX2NiW2ldLmNiKGhhcGQtPnByb2JlcmVxX2NiW2ldLmN0eCwKLQkJCQkJICAgIHNhLCBkYSwgYnNzaWQsIGllLCBpZV9sZW4pID4gMCkgeworCQkJCQkgICAgc2EsIGRhLCBic3NpZCwgaWUsIGllX2xlbiwKKwkJCQkJICAgIHNzaV9zaWduYWwpID4gMCkgewogCQkJcmV0ID0gMTsKIAkJCWJyZWFrOwogCQl9CkBAIC01NDEsNyArNTgwLDggQEAKIAkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5kYSwKIAkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5ic3NpZCwKIAkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZSwKLQkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZV9sZW4pOworCQkJCSAgICAgZGF0YS0+cnhfcHJvYmVfcmVxLmllX2xlbiwKKwkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5zc2lfc2lnbmFsKTsKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9ORVdfU1RBOgogCQlob3N0YXBkX2V2ZW50X25ld19zdGEoaGFwZCwgZGF0YS0+bmV3X3N0YS5hZGRyKTsKQEAgLTU3OCw2ICs2MTgsMTMgQEAKIAkJaG9zdGFwZF9yeF9hY3Rpb24oaGFwZCwgJmRhdGEtPnJ4X2FjdGlvbik7CiAJCWJyZWFrOwogI2VuZGlmIC8qIE5FRURfQVBfTUxNRSAqLworCWNhc2UgRVZFTlRfQ0hfU1dJVENIOgorCQlpZiAoIWRhdGEpCisJCQlicmVhazsKKwkJaG9zdGFwZF9ldmVudF9jaF9zd2l0Y2goaGFwZCwgZGF0YS0+Y2hfc3dpdGNoLmZyZXEsCisJCQkJCWRhdGEtPmNoX3N3aXRjaC5odF9lbmFibGVkLAorCQkJCQlkYXRhLT5jaF9zd2l0Y2guY2hfb2Zmc2V0KTsKKwkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbmtub3duIGV2ZW50ICVkIiwgZXZlbnQpOwogCQlicmVhazsKZGlmZiAtLWdpdCBhL3NyYy9hcC9nYXNfc2Vydi5jIGIvc3JjL2FwL2dhc19zZXJ2LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjE3N2IwMgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9hcC9nYXNfc2Vydi5jCkBAIC0wLDAgKzEsNjczIEBACisvKgorICogR2VuZXJpYyBhZHZlcnRpc2VtZW50IHNlcnZpY2UgKEdBUykgc2VydmVyCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMiwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9kZWZzLmgiCisjaW5jbHVkZSAiY29tbW9uL2dhcy5oIgorI2luY2x1ZGUgInV0aWxzL2Vsb29wLmgiCisjaW5jbHVkZSAiaG9zdGFwZC5oIgorI2luY2x1ZGUgImFwX2NvbmZpZy5oIgorI2luY2x1ZGUgImFwX2Rydl9vcHMuaCIKKyNpbmNsdWRlICJzdGFfaW5mby5oIgorI2luY2x1ZGUgImdhc19zZXJ2LmgiCisKKworc3RhdGljIHN0cnVjdCBnYXNfZGlhbG9nX2luZm8gKgorZ2FzX2RpYWxvZ19jcmVhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmFkZHIsIHU4IGRpYWxvZ190b2tlbikKK3sKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKKwlzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICpkaWEgPSBOVUxMOworCWludCBpLCBqOworCisJc3RhID0gYXBfZ2V0X3N0YShoYXBkLCBhZGRyKTsKKwlpZiAoIXN0YSkgeworCQkvKgorCQkgKiBXZSBuZWVkIGEgU1RBIGVudHJ5IHRvIGJlIGFibGUgdG8gbWFpbnRhaW4gc3RhdGUgZm9yCisJCSAqIHRoZSBHQVMgcXVlcnkuCisJCSAqLworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IEFkZCBhIHRlbXBvcmFyeSBTVEEgZW50cnkgZm9yICIKKwkJCSAgICJHQVMgcXVlcnkiKTsKKwkJc3RhID0gYXBfc3RhX2FkZChoYXBkLCBhZGRyKTsKKwkJaWYgKCFzdGEpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRmFpbGVkIHRvIGFkZCBTVEEgIiBNQUNTVFIKKwkJCQkgICAiIGZvciBHQVMgcXVlcnkiLCBNQUMyU1RSKGFkZHIpKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCXN0YS0+ZmxhZ3MgfD0gV0xBTl9TVEFfR0FTOworCQkvKgorCQkgKiBUaGUgZGVmYXVsdCBpbmFjdGl2aXR5IGlzIDMwMCBzZWNvbmRzLiBXZSBkb24ndCBuZWVkCisJCSAqIGl0IHRvIGJlIHRoYXQgbG9uZy4KKwkJICovCisJCWFwX3N0YV9zZXNzaW9uX3RpbWVvdXQoaGFwZCwgc3RhLCA1KTsKKwl9CisKKwlpZiAoc3RhLT5nYXNfZGlhbG9nID09IE5VTEwpIHsKKwkJc3RhLT5nYXNfZGlhbG9nID0gb3NfemFsbG9jKEdBU19ESUFMT0dfTUFYICoKKwkJCQkJICAgIHNpemVvZihzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvKSk7CisJCWlmIChzdGEtPmdhc19kaWFsb2cgPT0gTlVMTCkKKwkJCXJldHVybiBOVUxMOworCX0KKworCWZvciAoaSA9IHN0YS0+Z2FzX2RpYWxvZ19uZXh0LCBqID0gMDsgaiA8IEdBU19ESUFMT0dfTUFYOyBpKyssIGorKykgeworCQlpZiAoaSA9PSBHQVNfRElBTE9HX01BWCkKKwkJCWkgPSAwOworCQlpZiAoc3RhLT5nYXNfZGlhbG9nW2ldLnZhbGlkKQorCQkJY29udGludWU7CisJCWRpYSA9ICZzdGEtPmdhc19kaWFsb2dbaV07CisJCWRpYS0+dmFsaWQgPSAxOworCQlkaWEtPmluZGV4ID0gaTsKKwkJZGlhLT5kaWFsb2dfdG9rZW4gPSBkaWFsb2dfdG9rZW47CisJCXN0YS0+Z2FzX2RpYWxvZ19uZXh0ID0gKCsraSA9PSBHQVNfRElBTE9HX01BWCkgPyAwIDogaTsKKwkJcmV0dXJuIGRpYTsKKwl9CisKKwl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19FUlJPUiwgIkFOUVA6IENvdWxkIG5vdCBjcmVhdGUgZGlhbG9nIGZvciAiCisJCU1BQ1NUUiAiIGRpYWxvZ190b2tlbiAldS4gQ29uc2lkZXIgaW5jcmVhc2luZyAiCisJCSJHQVNfRElBTE9HX01BWC4iLCBNQUMyU1RSKGFkZHIpLCBkaWFsb2dfdG9rZW4pOworCisJcmV0dXJuIE5VTEw7Cit9CisKKworc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqCitnYXNfc2Vydl9kaWFsb2dfZmluZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkciwKKwkJICAgICB1OCBkaWFsb2dfdG9rZW4pCit7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CisJaW50IGk7CisKKwlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIGFkZHIpOworCWlmICghc3RhKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogY291bGQgbm90IGZpbmQgU1RBICIgTUFDU1RSLAorCQkJICAgTUFDMlNUUihhZGRyKSk7CisJCXJldHVybiBOVUxMOworCX0KKwlmb3IgKGkgPSAwOyBzdGEtPmdhc19kaWFsb2cgJiYgaSA8IEdBU19ESUFMT0dfTUFYOyBpKyspIHsKKwkJaWYgKHN0YS0+Z2FzX2RpYWxvZ1tpXS5kaWFsb2dfdG9rZW4gIT0gZGlhbG9nX3Rva2VuIHx8CisJCSAgICAhc3RhLT5nYXNfZGlhbG9nW2ldLnZhbGlkKQorCQkJY29udGludWU7CisJCXJldHVybiAmc3RhLT5nYXNfZGlhbG9nW2ldOworCX0KKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IENvdWxkIG5vdCBmaW5kIGRpYWxvZyBmb3IgIgorCQkgICBNQUNTVFIgIiBkaWFsb2dfdG9rZW4gJXUiLCBNQUMyU1RSKGFkZHIpLCBkaWFsb2dfdG9rZW4pOworCXJldHVybiBOVUxMOworfQorCisKK3ZvaWQgZ2FzX3NlcnZfZGlhbG9nX2NsZWFyKHN0cnVjdCBnYXNfZGlhbG9nX2luZm8gKmRpYSkKK3sKKwl3cGFidWZfZnJlZShkaWEtPnNkX3Jlc3ApOworCW9zX21lbXNldChkaWEsIDAsIHNpemVvZigqZGlhKSk7Cit9CisKKworc3RhdGljIHZvaWQgZ2FzX3NlcnZfZnJlZV9kaWFsb2dzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJICBjb25zdCB1OCAqc3RhX2FkZHIpCit7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CisJaW50IGk7CisKKwlzdGEgPSBhcF9nZXRfc3RhKGhhcGQsIHN0YV9hZGRyKTsKKwlpZiAoc3RhID09IE5VTEwgfHwgc3RhLT5nYXNfZGlhbG9nID09IE5VTEwpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCBHQVNfRElBTE9HX01BWDsgaSsrKSB7CisJCWlmIChzdGEtPmdhc19kaWFsb2dbaV0udmFsaWQpCisJCQlyZXR1cm47CisJfQorCisJb3NfZnJlZShzdGEtPmdhc19kaWFsb2cpOworCXN0YS0+Z2FzX2RpYWxvZyA9IE5VTEw7Cit9CisKKworc3RhdGljIHZvaWQgYW5xcF9hZGRfY2FwYWJfbGlzdChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCXN0cnVjdCB3cGFidWYgKmJ1ZikKK3sKKwl1OCAqbGVuOworCisJbGVuID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX0NBUEFCSUxJVFlfTElTVCk7CisJd3BhYnVmX3B1dF9sZTE2KGJ1ZiwgQU5RUF9DQVBBQklMSVRZX0xJU1QpOworCWlmIChoYXBkLT5jb25mLT52ZW51ZV9uYW1lKQorCQl3cGFidWZfcHV0X2xlMTYoYnVmLCBBTlFQX1ZFTlVFX05BTUUpOworCWlmIChoYXBkLT5jb25mLT5yb2FtaW5nX2NvbnNvcnRpdW0pCisJCXdwYWJ1Zl9wdXRfbGUxNihidWYsIEFOUVBfUk9BTUlOR19DT05TT1JUSVVNKTsKKwlnYXNfYW5xcF9zZXRfZWxlbWVudF9sZW4oYnVmLCBsZW4pOworfQorCisKK3N0YXRpYyB2b2lkIGFucXBfYWRkX3ZlbnVlX25hbWUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCWlmIChoYXBkLT5jb25mLT52ZW51ZV9uYW1lKSB7CisJCXU4ICpsZW47CisJCXVuc2lnbmVkIGludCBpOworCQlsZW4gPSBnYXNfYW5xcF9hZGRfZWxlbWVudChidWYsIEFOUVBfVkVOVUVfTkFNRSk7CisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBoYXBkLT5jb25mLT52ZW51ZV9ncm91cCk7CisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBoYXBkLT5jb25mLT52ZW51ZV90eXBlKTsKKwkJZm9yIChpID0gMDsgaSA8IGhhcGQtPmNvbmYtPnZlbnVlX25hbWVfY291bnQ7IGkrKykgeworCQkJc3RydWN0IGhvc3RhcGRfdmVudWVfbmFtZSAqdm47CisJCQl2biA9ICZoYXBkLT5jb25mLT52ZW51ZV9uYW1lW2ldOworCQkJd3BhYnVmX3B1dF91OChidWYsIDMgKyB2bi0+bmFtZV9sZW4pOworCQkJd3BhYnVmX3B1dF9kYXRhKGJ1Ziwgdm4tPmxhbmcsIDMpOworCQkJd3BhYnVmX3B1dF9kYXRhKGJ1Ziwgdm4tPm5hbWUsIHZuLT5uYW1lX2xlbik7CisJCX0KKwkJZ2FzX2FucXBfc2V0X2VsZW1lbnRfbGVuKGJ1ZiwgbGVuKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgYW5xcF9hZGRfcm9hbWluZ19jb25zb3J0aXVtKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCXN0cnVjdCB3cGFidWYgKmJ1ZikKK3sKKwl1bnNpZ25lZCBpbnQgaTsKKwl1OCAqbGVuOworCisJbGVuID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX1JPQU1JTkdfQ09OU09SVElVTSk7CisJZm9yIChpID0gMDsgaSA8IGhhcGQtPmNvbmYtPnJvYW1pbmdfY29uc29ydGl1bV9jb3VudDsgaSsrKSB7CisJCXN0cnVjdCBob3N0YXBkX3JvYW1pbmdfY29uc29ydGl1bSAqcmM7CisJCXJjID0gJmhhcGQtPmNvbmYtPnJvYW1pbmdfY29uc29ydGl1bVtpXTsKKwkJd3BhYnVmX3B1dF91OChidWYsIHJjLT5sZW4pOworCQl3cGFidWZfcHV0X2RhdGEoYnVmLCByYy0+b2ksIHJjLT5sZW4pOworCX0KKwlnYXNfYW5xcF9zZXRfZWxlbWVudF9sZW4oYnVmLCBsZW4pOworfQorCisKK3N0YXRpYyBzdHJ1Y3Qgd3BhYnVmICoKK2dhc19zZXJ2X2J1aWxkX2dhc19yZXNwX3BheWxvYWQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQl1bnNpZ25lZCBpbnQgcmVxdWVzdCwKKwkJCQlzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICpkaSkKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisKKwlidWYgPSB3cGFidWZfYWxsb2MoMTQwMCk7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChyZXF1ZXN0ICYgQU5RUF9SRVFfQ0FQQUJJTElUWV9MSVNUKQorCQlhbnFwX2FkZF9jYXBhYl9saXN0KGhhcGQsIGJ1Zik7CisJaWYgKHJlcXVlc3QgJiBBTlFQX1JFUV9WRU5VRV9OQU1FKQorCQlhbnFwX2FkZF92ZW51ZV9uYW1lKGhhcGQsIGJ1Zik7CisJaWYgKHJlcXVlc3QgJiBBTlFQX1JFUV9ST0FNSU5HX0NPTlNPUlRJVU0pCisJCWFucXBfYWRkX3JvYW1pbmdfY29uc29ydGl1bShoYXBkLCBidWYpOworCisJcmV0dXJuIGJ1ZjsKK30KKworCitzdGF0aWMgdm9pZCBnYXNfc2Vydl9jbGVhcl9jYWNoZWRfaWVzKHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfY3R4KQoreworCXN0cnVjdCBnYXNfZGlhbG9nX2luZm8gKmRpYSA9IGVsb29wX2RhdGE7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogVGltZW91dCB0cmlnZ2VyZWQsIGNsZWFyaW5nIGRpYWxvZyBmb3IgIgorCQkgICAiZGlhbG9nIHRva2VuICVkIiwgZGlhLT5kaWFsb2dfdG9rZW4pOworCisJZ2FzX3NlcnZfZGlhbG9nX2NsZWFyKGRpYSk7Cit9CisKKworc3RydWN0IGFucXBfcXVlcnlfaW5mbyB7CisJdW5zaWduZWQgaW50IHJlcXVlc3Q7CisJdW5zaWduZWQgaW50IHJlbW90ZV9yZXF1ZXN0OworCWNvbnN0IHZvaWQgKnBhcmFtOworCXUzMiBwYXJhbV9hcmc7CisJdTE2IHJlbW90ZV9kZWxheTsKK307CisKKworc3RhdGljIHZvaWQgc2V0X2FucXBfcmVxKHVuc2lnbmVkIGludCBiaXQsIGNvbnN0IGNoYXIgKm5hbWUsIGludCBsb2NhbCwKKwkJCSB1bnNpZ25lZCBpbnQgcmVtb3RlLCB1MTYgcmVtb3RlX2RlbGF5LAorCQkJIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gKnFpKQoreworCXFpLT5yZXF1ZXN0IHw9IGJpdDsKKwlpZiAobG9jYWwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiAlcyAobG9jYWwpIiwgbmFtZSk7CisJfSBlbHNlIGlmIChiaXQgJiByZW1vdGUpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiAlcyAocmVtb3RlKSIsIG5hbWUpOworCQlxaS0+cmVtb3RlX3JlcXVlc3QgfD0gYml0OworCQlpZiAocmVtb3RlX2RlbGF5ID4gcWktPnJlbW90ZV9kZWxheSkKKwkJCXFpLT5yZW1vdGVfZGVsYXkgPSByZW1vdGVfZGVsYXk7CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiAlcyBub3QgYXZhaWxhYmxlIiwgbmFtZSk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHJ4X2FucXBfcXVlcnlfbGlzdF9pZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1MTYgaW5mb19pZCwKKwkJCQkgIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gKnFpKQoreworCXN3aXRjaCAoaW5mb19pZCkgeworCWNhc2UgQU5RUF9DQVBBQklMSVRZX0xJU1Q6CisJCXNldF9hbnFwX3JlcShBTlFQX1JFUV9DQVBBQklMSVRZX0xJU1QsICJDYXBhYmlsaXR5IExpc3QiLCAxLCAwLAorCQkJICAgICAwLCBxaSk7CisJCWJyZWFrOworCWNhc2UgQU5RUF9WRU5VRV9OQU1FOgorCQlzZXRfYW5xcF9yZXEoQU5RUF9SRVFfVkVOVUVfTkFNRSwgIlZlbnVlIE5hbWUiLAorCQkJICAgICBoYXBkLT5jb25mLT52ZW51ZV9uYW1lICE9IE5VTEwsIDAsIDAsIHFpKTsKKwkJYnJlYWs7CisJY2FzZSBBTlFQX1JPQU1JTkdfQ09OU09SVElVTToKKwkJc2V0X2FucXBfcmVxKEFOUVBfUkVRX1JPQU1JTkdfQ09OU09SVElVTSwgIlJvYW1pbmcgQ29uc29ydGl1bSIsCisJCQkgICAgIGhhcGQtPmNvbmYtPnJvYW1pbmdfY29uc29ydGl1bSAhPSBOVUxMLCAwLCAwLCBxaSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogVW5zdXBwb3J0ZWQgSW5mbyBJZCAldSIsCisJCQkgICBpbmZvX2lkKTsKKwkJYnJlYWs7CisJfQorfQorCisKK3N0YXRpYyB2b2lkIHJ4X2FucXBfcXVlcnlfbGlzdChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJICAgICAgIGNvbnN0IHU4ICpwb3MsIGNvbnN0IHU4ICplbmQsCisJCQkgICAgICAgc3RydWN0IGFucXBfcXVlcnlfaW5mbyAqcWkpCit7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiAldSBJbmZvIElEcyByZXF1ZXN0ZWQgaW4gUXVlcnkgbGlzdCIsCisJCSAgICh1bnNpZ25lZCBpbnQpIChlbmQgLSBwb3MpIC8gMik7CisKKwl3aGlsZSAocG9zICsgMiA8PSBlbmQpIHsKKwkJcnhfYW5xcF9xdWVyeV9saXN0X2lkKGhhcGQsIFdQQV9HRVRfTEUxNihwb3MpLCBxaSk7CisJCXBvcyArPSAyOworCX0KK30KKworCitzdGF0aWMgdm9pZCBnYXNfc2Vydl9yZXFfbG9jYWxfcHJvY2Vzc2luZyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgIGNvbnN0IHU4ICpzYSwgdTggZGlhbG9nX3Rva2VuLAorCQkJCQkgIHN0cnVjdCBhbnFwX3F1ZXJ5X2luZm8gKnFpKQoreworCXN0cnVjdCB3cGFidWYgKmJ1ZiwgKnR4X2J1ZjsKKworCWJ1ZiA9IGdhc19zZXJ2X2J1aWxkX2dhc19yZXNwX3BheWxvYWQoaGFwZCwgcWktPnJlcXVlc3QsIE5VTEwpOworCXdwYV9oZXhkdW1wX2J1ZihNU0dfTVNHRFVNUCwgIkFOUVA6IExvY2FsbHkgZ2VuZXJhdGVkIEFOUVAgcmVzcG9uc2VzIiwKKwkJCWJ1Zik7CisJaWYgKCFidWYpCisJCXJldHVybjsKKworCWlmICh3cGFidWZfbGVuKGJ1ZikgPiBoYXBkLT5nYXNfZnJhZ19saW1pdCB8fAorCSAgICBoYXBkLT5jb25mLT5nYXNfY29tZWJhY2tfZGVsYXkpIHsKKwkJc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqZGk7CisJCXUxNiBjb21lYmFja19kZWxheSA9IDE7CisKKwkJaWYgKGhhcGQtPmNvbmYtPmdhc19jb21lYmFja19kZWxheSkgeworCQkJLyogVGVzdGluZyAtIGFsbG93IG92ZXJyaWRpbmcgb2YgdGhlIGRlbGF5IHZhbHVlICovCisJCQljb21lYmFja19kZWxheSA9IGhhcGQtPmNvbmYtPmdhc19jb21lYmFja19kZWxheTsKKwkJfQorCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogVG9vIGxvbmcgcmVzcG9uc2UgdG8gZml0IGluICIKKwkJCSAgICJpbml0aWFsIHJlc3BvbnNlIC0gdXNlIEdBUyBjb21lYmFjayIpOworCQlkaSA9IGdhc19kaWFsb2dfY3JlYXRlKGhhcGQsIHNhLCBkaWFsb2dfdG9rZW4pOworCQlpZiAoIWRpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiQU5RUDogQ291bGQgbm90IGNyZWF0ZSBkaWFsb2cgIgorCQkJCSAgICJmb3IgIiBNQUNTVFIgIiAoZGlhbG9nIHRva2VuICV1KSIsCisJCQkJICAgTUFDMlNUUihzYSksIGRpYWxvZ190b2tlbik7CisJCQl3cGFidWZfZnJlZShidWYpOworCQkJcmV0dXJuOworCQl9CisJCWRpLT5zZF9yZXNwID0gYnVmOworCQlkaS0+c2RfcmVzcF9wb3MgPSAwOworCQl0eF9idWYgPSBnYXNfYW5xcF9idWlsZF9pbml0aWFsX3Jlc3BfYnVmKAorCQkJZGlhbG9nX3Rva2VuLCBXTEFOX1NUQVRVU19TVUNDRVNTLCBjb21lYmFja19kZWxheSwKKwkJCU5VTEwpOworCX0gZWxzZSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogSW5pdGlhbCByZXNwb25zZSAobm8gY29tZWJhY2spIik7CisJCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2luaXRpYWxfcmVzcF9idWYoCisJCQlkaWFsb2dfdG9rZW4sIFdMQU5fU1RBVFVTX1NVQ0NFU1MsIDAsIGJ1Zik7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJfQorCWlmICghdHhfYnVmKQorCQlyZXR1cm47CisKKwlob3N0YXBkX2Rydl9zZW5kX2FjdGlvbihoYXBkLCBoYXBkLT5pZmFjZS0+ZnJlcSwgMCwgc2EsCisJCQkJd3BhYnVmX2hlYWQodHhfYnVmKSwgd3BhYnVmX2xlbih0eF9idWYpKTsKKwl3cGFidWZfZnJlZSh0eF9idWYpOworfQorCisKK3N0YXRpYyB2b2lkIGdhc19zZXJ2X3J4X2dhc19pbml0aWFsX3JlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQljb25zdCB1OCAqc2EsCisJCQkJCWNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuKQoreworCWNvbnN0IHU4ICpwb3MgPSBkYXRhOworCWNvbnN0IHU4ICplbmQgPSBkYXRhICsgbGVuOworCWNvbnN0IHU4ICpuZXh0OworCXU4IGRpYWxvZ190b2tlbjsKKwl1MTYgc2xlbjsKKwlzdHJ1Y3QgYW5xcF9xdWVyeV9pbmZvIHFpOworCWNvbnN0IHU4ICphZHZfcHJvdG87CisKKwlpZiAobGVuIDwgMSArIDIpCisJCXJldHVybjsKKworCW9zX21lbXNldCgmcWksIDAsIHNpemVvZihxaSkpOworCisJZGlhbG9nX3Rva2VuID0gKnBvcysrOworCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLAorCQkiR0FTOiBHQVMgSW5pdGlhbCBSZXF1ZXN0IGZyb20gIiBNQUNTVFIgIiAoZGlhbG9nIHRva2VuICV1KSAiLAorCQlNQUMyU1RSKHNhKSwgZGlhbG9nX3Rva2VuKTsKKworCWlmICgqcG9zICE9IFdMQU5fRUlEX0FEVl9QUk9UTykgeworCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywKKwkJCSJHQVM6IFVuZXhwZWN0ZWQgSUUgaW4gR0FTIEluaXRpYWwgUmVxdWVzdDogJXUiLCAqcG9zKTsKKwkJcmV0dXJuOworCX0KKwlhZHZfcHJvdG8gPSBwb3MrKzsKKworCXNsZW4gPSAqcG9zKys7CisJbmV4dCA9IHBvcyArIHNsZW47CisJaWYgKG5leHQgPiBlbmQgfHwgc2xlbiA8IDIpIHsKKwkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsCisJCQkiR0FTOiBJbnZhbGlkIElFIGluIEdBUyBJbml0aWFsIFJlcXVlc3QiKTsKKwkJcmV0dXJuOworCX0KKwlwb3MrKzsgLyogc2tpcCBRdWVyeVJlc3BMZW5MaW1pdCBhbmQgUEFNRS1CSSAqLworCisJaWYgKCpwb3MgIT0gQUNDRVNTX05FVFdPUktfUVVFUllfUFJPVE9DT0wpIHsKKwkJc3RydWN0IHdwYWJ1ZiAqYnVmOworCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywKKwkJCSJHQVM6IFVuc3VwcG9ydGVkIEdBUyBhZHZlcnRpc2VtZW50IHByb3RvY29sIGlkICV1IiwKKwkJCSpwb3MpOworCQlpZiAoc2FbMF0gJiAweDAxKQorCQkJcmV0dXJuOyAvKiBJbnZhbGlkIHNvdXJjZSBhZGRyZXNzIC0gZHJvcCBzaWxlbnRseSAqLworCQlidWYgPSBnYXNfYnVpbGRfaW5pdGlhbF9yZXNwKAorCQkJZGlhbG9nX3Rva2VuLCBXTEFOX1NUQVRVU19HQVNfQURWX1BST1RPX05PVF9TVVBQT1JURUQsCisJCQkwLCAyICsgc2xlbiArIDIpOworCQlpZiAoYnVmID09IE5VTEwpCisJCQlyZXR1cm47CisJCXdwYWJ1Zl9wdXRfZGF0YShidWYsIGFkdl9wcm90bywgMiArIHNsZW4pOworCQl3cGFidWZfcHV0X2xlMTYoYnVmLCAwKTsgLyogUXVlcnkgUmVzcG9uc2UgTGVuZ3RoICovCisJCWhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLCBzYSwKKwkJCQkJd3BhYnVmX2hlYWQoYnVmKSwgd3BhYnVmX2xlbihidWYpKTsKKwkJd3BhYnVmX2ZyZWUoYnVmKTsKKwkJcmV0dXJuOworCX0KKworCXBvcyA9IG5leHQ7CisJLyogUXVlcnkgUmVxdWVzdCAqLworCWlmIChwb3MgKyAyID4gZW5kKQorCQlyZXR1cm47CisJc2xlbiA9IFdQQV9HRVRfTEUxNihwb3MpOworCXBvcyArPSAyOworCWlmIChwb3MgKyBzbGVuID4gZW5kKQorCQlyZXR1cm47CisJZW5kID0gcG9zICsgc2xlbjsKKworCS8qIEFOUVAgUXVlcnkgUmVxdWVzdCAqLworCXdoaWxlIChwb3MgPCBlbmQpIHsKKwkJdTE2IGluZm9faWQsIGVsZW47CisKKwkJaWYgKHBvcyArIDQgPiBlbmQpCisJCQlyZXR1cm47CisKKwkJaW5mb19pZCA9IFdQQV9HRVRfTEUxNihwb3MpOworCQlwb3MgKz0gMjsKKwkJZWxlbiA9IFdQQV9HRVRfTEUxNihwb3MpOworCQlwb3MgKz0gMjsKKworCQlpZiAocG9zICsgZWxlbiA+IGVuZCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJBTlFQOiBJbnZhbGlkIFF1ZXJ5IFJlcXVlc3QiKTsKKwkJCXJldHVybjsKKwkJfQorCisJCXN3aXRjaCAoaW5mb19pZCkgeworCQljYXNlIEFOUVBfUVVFUllfTElTVDoKKwkJCXJ4X2FucXBfcXVlcnlfbGlzdChoYXBkLCBwb3MsIHBvcyArIGVsZW4sICZxaSk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogVW5zdXBwb3J0ZWQgUXVlcnkgIgorCQkJCSAgICJSZXF1ZXN0IGVsZW1lbnQgJXUiLCBpbmZvX2lkKTsKKwkJCWJyZWFrOworCQl9CisKKwkJcG9zICs9IGVsZW47CisJfQorCisJZ2FzX3NlcnZfcmVxX2xvY2FsX3Byb2Nlc3NpbmcoaGFwZCwgc2EsIGRpYWxvZ190b2tlbiwgJnFpKTsKK30KKworCit2b2lkIGdhc19zZXJ2X3R4X2dhc19yZXNwb25zZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqZHN0LAorCQkJICAgICAgc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqZGlhbG9nKQoreworCXN0cnVjdCB3cGFidWYgKmJ1ZiwgKnR4X2J1ZjsKKwl1OCBkaWFsb2dfdG9rZW4gPSBkaWFsb2ctPmRpYWxvZ190b2tlbjsKKwlzaXplX3QgZnJhZ19sZW47CisKKwlpZiAoZGlhbG9nLT5zZF9yZXNwID09IE5VTEwpIHsKKwkJYnVmID0gZ2FzX3NlcnZfYnVpbGRfZ2FzX3Jlc3BfcGF5bG9hZChoYXBkLAorCQkJCQkJICAgICAgZGlhbG9nLT5hbGxfcmVxdWVzdGVkLAorCQkJCQkJICAgICAgZGlhbG9nKTsKKwkJd3BhX2hleGR1bXBfYnVmKE1TR19NU0dEVU1QLCAiQU5RUDogR2VuZXJhdGVkIEFOUVAgcmVzcG9uc2VzIiwKKwkJCWJ1Zik7CisJCWlmICghYnVmKQorCQkJZ290byB0eF9nYXNfcmVzcG9uc2VfZG9uZTsKKwkJZGlhbG9nLT5zZF9yZXNwID0gYnVmOworCQlkaWFsb2ctPnNkX3Jlc3BfcG9zID0gMDsKKwl9CisJZnJhZ19sZW4gPSB3cGFidWZfbGVuKGRpYWxvZy0+c2RfcmVzcCkgLSBkaWFsb2ctPnNkX3Jlc3BfcG9zOworCWlmIChmcmFnX2xlbiA+IGhhcGQtPmdhc19mcmFnX2xpbWl0IHx8IGRpYWxvZy0+Y29tZWJhY2tfZGVsYXkgfHwKKwkgICAgaGFwZC0+Y29uZi0+Z2FzX2NvbWViYWNrX2RlbGF5KSB7CisJCXUxNiBjb21lYmFja19kZWxheV90dXMgPSBkaWFsb2ctPmNvbWViYWNrX2RlbGF5ICsKKwkJCUdBU19TRVJWX0NPTUVCQUNLX0RFTEFZX0ZVREdFOworCQl1MzIgY29tZWJhY2tfZGVsYXlfc2VjcywgY29tZWJhY2tfZGVsYXlfdXNlY3M7CisKKwkJaWYgKGhhcGQtPmNvbmYtPmdhc19jb21lYmFja19kZWxheSkgeworCQkJLyogVGVzdGluZyAtIGFsbG93IG92ZXJyaWRpbmcgb2YgdGhlIGRlbGF5IHZhbHVlICovCisJCQljb21lYmFja19kZWxheV90dXMgPSBoYXBkLT5jb25mLT5nYXNfY29tZWJhY2tfZGVsYXk7CisJCX0KKworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogUmVzcG9uc2UgZnJhZ19sZW4gJXUgKGZyYWcgbGltaXQgIgorCQkJICAgIiV1KSBhbmQgY29tZWJhY2sgZGVsYXkgJXUsICIKKwkJCSAgICJyZXF1ZXN0aW5nIGNvbWViYWNrcyIsICh1bnNpZ25lZCBpbnQpIGZyYWdfbGVuLAorCQkJICAgKHVuc2lnbmVkIGludCkgaGFwZC0+Z2FzX2ZyYWdfbGltaXQsCisJCQkgICBkaWFsb2ctPmNvbWViYWNrX2RlbGF5KTsKKwkJdHhfYnVmID0gZ2FzX2FucXBfYnVpbGRfaW5pdGlhbF9yZXNwX2J1ZihkaWFsb2dfdG9rZW4sCisJCQkJCQkJIFdMQU5fU1RBVFVTX1NVQ0NFU1MsCisJCQkJCQkJIGNvbWViYWNrX2RlbGF5X3R1cywKKwkJCQkJCQkgTlVMTCk7CisJCWlmICh0eF9idWYpIHsKKwkJCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLAorCQkJCSJHQVM6IFR4IEdBUyBJbml0aWFsIFJlc3AgKGNvbWViYWNrID0gMTBUVSkiKTsKKwkJCWhvc3RhcGRfZHJ2X3NlbmRfYWN0aW9uKGhhcGQsIGhhcGQtPmlmYWNlLT5mcmVxLCAwLAorCQkJCQkJZHN0LAorCQkJCQkJd3BhYnVmX2hlYWQodHhfYnVmKSwKKwkJCQkJCXdwYWJ1Zl9sZW4odHhfYnVmKSk7CisJCX0KKwkJd3BhYnVmX2ZyZWUodHhfYnVmKTsKKworCQkvKiBzdGFydCBhIHRpbWVyIG9mIDEuNSAqIGNvbWViYWNrLWRlbGF5ICovCisJCWNvbWViYWNrX2RlbGF5X3R1cyA9IGNvbWViYWNrX2RlbGF5X3R1cyArCisJCQkoY29tZWJhY2tfZGVsYXlfdHVzIC8gMik7CisJCWNvbWViYWNrX2RlbGF5X3NlY3MgPSAoY29tZWJhY2tfZGVsYXlfdHVzICogMTAyNCkgLyAxMDAwMDAwOworCQljb21lYmFja19kZWxheV91c2VjcyA9IChjb21lYmFja19kZWxheV90dXMgKiAxMDI0KSAtCisJCQkoY29tZWJhY2tfZGVsYXlfc2VjcyAqIDEwMDAwMDApOworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGNvbWViYWNrX2RlbGF5X3NlY3MsCisJCQkJICAgICAgIGNvbWViYWNrX2RlbGF5X3VzZWNzLAorCQkJCSAgICAgICBnYXNfc2Vydl9jbGVhcl9jYWNoZWRfaWVzLCBkaWFsb2csCisJCQkJICAgICAgIE5VTEwpOworCQlnb3RvIHR4X2dhc19yZXNwb25zZV9kb25lOworCX0KKworCWJ1ZiA9IHdwYWJ1Zl9hbGxvY19jb3B5KHdwYWJ1Zl9oZWFkX3U4KGRpYWxvZy0+c2RfcmVzcCkgKworCQkJCWRpYWxvZy0+c2RfcmVzcF9wb3MsIGZyYWdfbGVuKTsKKwlpZiAoYnVmID09IE5VTEwpIHsKKwkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJHQVM6IEJ1ZmZlciBhbGxvY2F0aW9uICIKKwkJCSJmYWlsZWQiKTsKKwkJZ290byB0eF9nYXNfcmVzcG9uc2VfZG9uZTsKKwl9CisJdHhfYnVmID0gZ2FzX2FucXBfYnVpbGRfaW5pdGlhbF9yZXNwX2J1ZihkaWFsb2dfdG9rZW4sCisJCQkJCQkgV0xBTl9TVEFUVVNfU1VDQ0VTUywgMCwgYnVmKTsKKwl3cGFidWZfZnJlZShidWYpOworCWlmICh0eF9idWYgPT0gTlVMTCkKKwkJZ290byB0eF9nYXNfcmVzcG9uc2VfZG9uZTsKKwl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkdBUzogVHggR0FTIEluaXRpYWwgIgorCQkiUmVzcG9uc2UgKGZyYWdfaWQgJWQgZnJhZ19sZW4gJWQpIiwKKwkJZGlhbG9nLT5zZF9mcmFnX2lkLCAoaW50KSBmcmFnX2xlbik7CisJZGlhbG9nLT5zZF9mcmFnX2lkKys7CisKKwlob3N0YXBkX2Rydl9zZW5kX2FjdGlvbihoYXBkLCBoYXBkLT5pZmFjZS0+ZnJlcSwgMCwgZHN0LAorCQkJCXdwYWJ1Zl9oZWFkKHR4X2J1ZiksIHdwYWJ1Zl9sZW4odHhfYnVmKSk7CisJd3BhYnVmX2ZyZWUodHhfYnVmKTsKK3R4X2dhc19yZXNwb25zZV9kb25lOgorCWdhc19zZXJ2X2NsZWFyX2NhY2hlZF9pZXMoZGlhbG9nLCBOVUxMKTsKK30KKworCitzdGF0aWMgdm9pZCBnYXNfc2Vydl9yeF9nYXNfY29tZWJhY2tfcmVxKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSBjb25zdCB1OCAqc2EsCisJCQkJCSBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbikKK3sKKwlzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICpkaWFsb2c7CisJc3RydWN0IHdwYWJ1ZiAqYnVmLCAqdHhfYnVmOworCXU4IGRpYWxvZ190b2tlbjsKKwlzaXplX3QgZnJhZ19sZW47CisJaW50IG1vcmUgPSAwOworCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiR0FTOiBSWCBHQVMgQ29tZWJhY2sgUmVxdWVzdCIsIGRhdGEsIGxlbik7CisJaWYgKGxlbiA8IDEpCisJCXJldHVybjsKKwlkaWFsb2dfdG9rZW4gPSAqZGF0YTsKKwl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkdBUzogRGlhbG9nIFRva2VuOiAldSIsCisJCWRpYWxvZ190b2tlbik7CisKKwlkaWFsb2cgPSBnYXNfc2Vydl9kaWFsb2dfZmluZChoYXBkLCBzYSwgZGlhbG9nX3Rva2VuKTsKKwlpZiAoIWRpYWxvZykgeworCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkdBUzogTm8gcGVuZGluZyBTRCAiCisJCQkicmVzcG9uc2UgZnJhZ21lbnQgZm9yICIgTUFDU1RSICIgZGlhbG9nIHRva2VuICV1IiwKKwkJCU1BQzJTVFIoc2EpLCBkaWFsb2dfdG9rZW4pOworCisJCWlmIChzYVswXSAmIDB4MDEpCisJCQlyZXR1cm47IC8qIEludmFsaWQgc291cmNlIGFkZHJlc3MgLSBkcm9wIHNpbGVudGx5ICovCisJCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2NvbWViYWNrX3Jlc3BfYnVmKAorCQkJZGlhbG9nX3Rva2VuLCBXTEFOX1NUQVRVU19OT19PVVRTVEFORElOR19HQVNfUkVRLCAwLCAwLAorCQkJMCwgTlVMTCk7CisJCWlmICh0eF9idWYgPT0gTlVMTCkKKwkJCXJldHVybjsKKwkJZ290byBzZW5kX3Jlc3A7CisJfQorCisJaWYgKGRpYWxvZy0+c2RfcmVzcCA9PSBOVUxMKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiR0FTOiBSZW1vdGUgcmVxdWVzdCAweCV4IHJlY2VpdmVkIDB4JXgiLAorCQkJICAgZGlhbG9nLT5yZXF1ZXN0ZWQsIGRpYWxvZy0+cmVjZWl2ZWQpOworCQlpZiAoKGRpYWxvZy0+cmVxdWVzdGVkICYgZGlhbG9nLT5yZWNlaXZlZCkgIT0KKwkJICAgIGRpYWxvZy0+cmVxdWVzdGVkKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdBUzogRGlkIG5vdCByZWNlaXZlIHJlc3BvbnNlICIKKwkJCQkgICAiZnJvbSByZW1vdGUgcHJvY2Vzc2luZyIpOworCQkJZ2FzX3NlcnZfZGlhbG9nX2NsZWFyKGRpYWxvZyk7CisJCQl0eF9idWYgPSBnYXNfYW5xcF9idWlsZF9jb21lYmFja19yZXNwX2J1ZigKKwkJCQlkaWFsb2dfdG9rZW4sCisJCQkJV0xBTl9TVEFUVVNfR0FTX1JFU1BfTk9UX1JFQ0VJVkVELCAwLCAwLCAwLAorCQkJCU5VTEwpOworCQkJaWYgKHR4X2J1ZiA9PSBOVUxMKQorCQkJCXJldHVybjsKKwkJCWdvdG8gc2VuZF9yZXNwOworCQl9CisKKwkJYnVmID0gZ2FzX3NlcnZfYnVpbGRfZ2FzX3Jlc3BfcGF5bG9hZChoYXBkLAorCQkJCQkJICAgICAgZGlhbG9nLT5hbGxfcmVxdWVzdGVkLAorCQkJCQkJICAgICAgZGlhbG9nKTsKKwkJd3BhX2hleGR1bXBfYnVmKE1TR19NU0dEVU1QLCAiQU5RUDogR2VuZXJhdGVkIEFOUVAgcmVzcG9uc2VzIiwKKwkJCWJ1Zik7CisJCWlmICghYnVmKQorCQkJZ290byByeF9nYXNfY29tZWJhY2tfcmVxX2RvbmU7CisJCWRpYWxvZy0+c2RfcmVzcCA9IGJ1ZjsKKwkJZGlhbG9nLT5zZF9yZXNwX3BvcyA9IDA7CisJfQorCWZyYWdfbGVuID0gd3BhYnVmX2xlbihkaWFsb2ctPnNkX3Jlc3ApIC0gZGlhbG9nLT5zZF9yZXNwX3BvczsKKwlpZiAoZnJhZ19sZW4gPiBoYXBkLT5nYXNfZnJhZ19saW1pdCkgeworCQlmcmFnX2xlbiA9IGhhcGQtPmdhc19mcmFnX2xpbWl0OworCQltb3JlID0gMTsKKwl9CisJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJHQVM6IHJlc3AgZnJhZ19sZW4gJXUiLAorCQkodW5zaWduZWQgaW50KSBmcmFnX2xlbik7CisJYnVmID0gd3BhYnVmX2FsbG9jX2NvcHkod3BhYnVmX2hlYWRfdTgoZGlhbG9nLT5zZF9yZXNwKSArCisJCQkJZGlhbG9nLT5zZF9yZXNwX3BvcywgZnJhZ19sZW4pOworCWlmIChidWYgPT0gTlVMTCkgeworCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkdBUzogRmFpbGVkIHRvIGFsbG9jYXRlICIKKwkJCSJidWZmZXIiKTsKKwkJZ290byByeF9nYXNfY29tZWJhY2tfcmVxX2RvbmU7CisJfQorCXR4X2J1ZiA9IGdhc19hbnFwX2J1aWxkX2NvbWViYWNrX3Jlc3BfYnVmKGRpYWxvZ190b2tlbiwKKwkJCQkJCSAgV0xBTl9TVEFUVVNfU1VDQ0VTUywKKwkJCQkJCSAgZGlhbG9nLT5zZF9mcmFnX2lkLAorCQkJCQkJICBtb3JlLCAwLCBidWYpOworCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJaWYgKHR4X2J1ZiA9PSBOVUxMKQorCQlnb3RvIHJ4X2dhc19jb21lYmFja19yZXFfZG9uZTsKKwl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywgIkdBUzogVHggR0FTIENvbWViYWNrIFJlc3BvbnNlICIKKwkJIihmcmFnX2lkICVkIG1vcmU9JWQgZnJhZ19sZW49JWQpIiwKKwkJZGlhbG9nLT5zZF9mcmFnX2lkLCBtb3JlLCAoaW50KSBmcmFnX2xlbik7CisJZGlhbG9nLT5zZF9mcmFnX2lkKys7CisJZGlhbG9nLT5zZF9yZXNwX3BvcyArPSBmcmFnX2xlbjsKKworCWlmIChtb3JlKSB7CisJCXdwYV9tc2coaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiR0FTOiAlZCBtb3JlIGJ5dGVzIHJlbWFpbiAiCisJCQkidG8gYmUgc2VudCIsCisJCQkoaW50KSAod3BhYnVmX2xlbihkaWFsb2ctPnNkX3Jlc3ApIC0KKwkJCSAgICAgICBkaWFsb2ctPnNkX3Jlc3BfcG9zKSk7CisJfSBlbHNlIHsKKwkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsICJHQVM6IEFsbCBmcmFnbWVudHMgb2YgIgorCQkJIlNEIHJlc3BvbnNlIHNlbnQiKTsKKwkJZ2FzX3NlcnZfZGlhbG9nX2NsZWFyKGRpYWxvZyk7CisJCWdhc19zZXJ2X2ZyZWVfZGlhbG9ncyhoYXBkLCBzYSk7CisJfQorCitzZW5kX3Jlc3A6CisJaG9zdGFwZF9kcnZfc2VuZF9hY3Rpb24oaGFwZCwgaGFwZC0+aWZhY2UtPmZyZXEsIDAsIHNhLAorCQkJCXdwYWJ1Zl9oZWFkKHR4X2J1ZiksIHdwYWJ1Zl9sZW4odHhfYnVmKSk7CisJd3BhYnVmX2ZyZWUodHhfYnVmKTsKKwlyZXR1cm47CisKK3J4X2dhc19jb21lYmFja19yZXFfZG9uZToKKwlnYXNfc2Vydl9jbGVhcl9jYWNoZWRfaWVzKGRpYWxvZywgTlVMTCk7Cit9CisKKworc3RhdGljIHZvaWQgZ2FzX3NlcnZfcnhfcHVibGljX2FjdGlvbih2b2lkICpjdHgsIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4sCisJCQkJICAgICAgaW50IGZyZXEpCit7CisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGN0eDsKKwljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7CisJc2l6ZV90IGhkcl9sZW47CisJY29uc3QgdTggKnNhLCAqZGF0YTsKKworCW1nbXQgPSAoY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGJ1ZjsKKwloZHJfbGVuID0gKGNvbnN0IHU4ICopICZtZ210LT51LmFjdGlvbi51LnZzX3B1YmxpY19hY3Rpb24uYWN0aW9uIC0gYnVmOworCWlmIChoZHJfbGVuID4gbGVuKQorCQlyZXR1cm47CisJaWYgKG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5ICE9IFdMQU5fQUNUSU9OX1BVQkxJQykKKwkJcmV0dXJuOworCXNhID0gbWdtdC0+c2E7CisJbGVuIC09IGhkcl9sZW47CisJZGF0YSA9ICZtZ210LT51LmFjdGlvbi51LnB1YmxpY19hY3Rpb24uYWN0aW9uOworCXN3aXRjaCAoZGF0YVswXSkgeworCWNhc2UgV0xBTl9QQV9HQVNfSU5JVElBTF9SRVE6CisJCWdhc19zZXJ2X3J4X2dhc19pbml0aWFsX3JlcShoYXBkLCBzYSwgZGF0YSArIDEsIGxlbiAtIDEpOworCQlicmVhazsKKwljYXNlIFdMQU5fUEFfR0FTX0NPTUVCQUNLX1JFUToKKwkJZ2FzX3NlcnZfcnhfZ2FzX2NvbWViYWNrX3JlcShoYXBkLCBzYSwgZGF0YSArIDEsIGxlbiAtIDEpOworCQlicmVhazsKKwl9Cit9CisKKworaW50IGdhc19zZXJ2X2luaXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKKwloYXBkLT5wdWJsaWNfYWN0aW9uX2NiID0gZ2FzX3NlcnZfcnhfcHVibGljX2FjdGlvbjsKKwloYXBkLT5wdWJsaWNfYWN0aW9uX2NiX2N0eCA9IGhhcGQ7CisJaGFwZC0+Z2FzX2ZyYWdfbGltaXQgPSAxNDAwOworCWlmIChoYXBkLT5jb25mLT5nYXNfZnJhZ19saW1pdCA+IDApCisJCWhhcGQtPmdhc19mcmFnX2xpbWl0ID0gaGFwZC0+Y29uZi0+Z2FzX2ZyYWdfbGltaXQ7CisJcmV0dXJuIDA7Cit9CisKKwordm9pZCBnYXNfc2Vydl9kZWluaXQoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKK30KZGlmZiAtLWdpdCBhL3NyYy9hcC9nYXNfc2Vydi5oIGIvc3JjL2FwL2dhc19zZXJ2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGUyZWFmNgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9hcC9nYXNfc2Vydi5oCkBAIC0wLDAgKzEsNDkgQEAKKy8qCisgKiBHZW5lcmljIGFkdmVydGlzZW1lbnQgc2VydmljZSAoR0FTKSBzZXJ2ZXIKKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIEdBU19TRVJWX0gKKyNkZWZpbmUgR0FTX1NFUlZfSAorCisjZGVmaW5lIEFOUVBfUkVRX0NBUEFCSUxJVFlfTElTVCBcCisJKDEgPDwgKEFOUVBfQ0FQQUJJTElUWV9MSVNUIC0gQU5RUF9RVUVSWV9MSVNUKSkKKyNkZWZpbmUgQU5RUF9SRVFfVkVOVUVfTkFNRSBcCisJKDEgPDwgKEFOUVBfVkVOVUVfTkFNRSAtIEFOUVBfUVVFUllfTElTVCkpCisjZGVmaW5lIEFOUVBfUkVRX1JPQU1JTkdfQ09OU09SVElVTSBcCisJKDEgPDwgKEFOUVBfUk9BTUlOR19DT05TT1JUSVVNIC0gQU5RUF9RVUVSWV9MSVNUKSkKKworLyogVG8gYWNjb3VudCBmb3IgbGF0ZW5jaWVzIGJldHdlZW4gaG9zdGFwZCBhbmQgZXh0ZXJuYWwgQU5RUCBwcm9jZXNzb3IgKi8KKyNkZWZpbmUgR0FTX1NFUlZfQ09NRUJBQ0tfREVMQVlfRlVER0UgMTAKKyNkZWZpbmUgR0FTX1NFUlZfTUlOX0NPTUVCQUNLX0RFTEFZIDEwMCAvKiBpbiBUVSAqLworCitzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvIHsKKwl1OCB2YWxpZDsKKwl1OCBpbmRleDsKKwlzdHJ1Y3Qgd3BhYnVmICpzZF9yZXNwOyAvKiBGcmFnbWVudGVkIHJlc3BvbnNlICovCisJdTggZGlhbG9nX3Rva2VuOworCXNpemVfdCBzZF9yZXNwX3BvczsgLyogT2Zmc2V0IGluIHNkX3Jlc3AgKi8KKwl1OCBzZF9mcmFnX2lkOworCXUxNiBjb21lYmFja19kZWxheTsKKworCXVuc2lnbmVkIGludCByZXF1ZXN0ZWQ7CisJdW5zaWduZWQgaW50IHJlY2VpdmVkOworCXVuc2lnbmVkIGludCBhbGxfcmVxdWVzdGVkOworfTsKKworc3RydWN0IGhvc3RhcGRfZGF0YTsKKwordm9pZCBnYXNfc2Vydl90eF9nYXNfcmVzcG9uc2Uoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKmRzdCwKKwkJCSAgICAgIHN0cnVjdCBnYXNfZGlhbG9nX2luZm8gKmRpYWxvZyk7CitzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICoKK2dhc19zZXJ2X2RpYWxvZ19maW5kKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICphZGRyLAorCQkgICAgIHU4IGRpYWxvZ190b2tlbik7Cit2b2lkIGdhc19zZXJ2X2RpYWxvZ19jbGVhcihzdHJ1Y3QgZ2FzX2RpYWxvZ19pbmZvICpkaWFsb2cpOworCitpbnQgZ2FzX3NlcnZfaW5pdChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKTsKK3ZvaWQgZ2FzX3NlcnZfZGVpbml0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOworCisjZW5kaWYgLyogR0FTX1NFUlZfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2hvc3RhcGQuYyBiL3NyYy9hcC9ob3N0YXBkLmMKaW5kZXggYzVjYmRmNy4uMjJjNWU2NSAxMDA2NDQKLS0tIGEvc3JjL2FwL2hvc3RhcGQuYworKysgYi9zcmMvYXAvaG9zdGFwZC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIGhvc3RhcGQgLyBJbml0aWFsaXphdGlvbiBhbmQgY29uZmlndXJhdGlvbgotICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgInV0aWxzL2Vsb29wLmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgInJhZGl1cy9yYWRpdXNfY2xpZW50LmgiCisjaW5jbHVkZSAicmFkaXVzL3JhZGl1c19kYXMuaCIKICNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgogI2luY2x1ZGUgImhvc3RhcGQuaCIKICNpbmNsdWRlICJhdXRoc3J2LmgiCkBAIC0zMCwxNSArMzEsMzMgQEAKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCiAjaW5jbHVkZSAiYXBfY29uZmlnLmgiCiAjaW5jbHVkZSAicDJwX2hvc3RhcGQuaCIKKyNpbmNsdWRlICJnYXNfc2Vydi5oIgogCiAKLXN0YXRpYyBpbnQgaG9zdGFwZF9mbHVzaF9vbGRfc3RhdGlvbnMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CitzdGF0aWMgaW50IGhvc3RhcGRfZmx1c2hfb2xkX3N0YXRpb25zKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHUxNiByZWFzb24pOwogc3RhdGljIGludCBob3N0YXBkX3NldHVwX2VuY3J5cHRpb24oY2hhciAqaWZhY2UsIHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwogc3RhdGljIGludCBob3N0YXBkX2Jyb2FkY2FzdF93ZXBfY2xlYXIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CiAKIGV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwogCiAKK2ludCBob3N0YXBkX2Zvcl9lYWNoX2ludGVyZmFjZShzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzICppbnRlcmZhY2VzLAorCQkJICAgICAgIGludCAoKmNiKShzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UsCisJCQkJCSB2b2lkICpjdHgpLCB2b2lkICpjdHgpCit7CisJc2l6ZV90IGk7CisJaW50IHJldDsKKworCWZvciAoaSA9IDA7IGkgPCBpbnRlcmZhY2VzLT5jb3VudDsgaSsrKSB7CisJCXJldCA9IGNiKGludGVyZmFjZXMtPmlmYWNlW2ldLCBjdHgpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCiBzdGF0aWMgdm9pZCBob3N0YXBkX3JlbG9hZF9ic3Moc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKIHsKICNpZm5kZWYgQ09ORklHX05PX1JBRElVUwpAQCAtMTA1LDcgKzEyNCw4IEBACiAJICogYWxsb3cgdGhlbSB0byB1c2UgdGhlIEJTUyBhbnltb3JlLgogCSAqLwogCWZvciAoaiA9IDA7IGogPCBpZmFjZS0+bnVtX2JzczsgaisrKSB7Ci0JCWhvc3RhcGRfZmx1c2hfb2xkX3N0YXRpb25zKGlmYWNlLT5ic3Nbal0pOworCQlob3N0YXBkX2ZsdXNoX29sZF9zdGF0aW9ucyhpZmFjZS0+YnNzW2pdLAorCQkJCQkgICBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKIAkJaG9zdGFwZF9icm9hZGNhc3Rfd2VwX2NsZWFyKGlmYWNlLT5ic3Nbal0pOwogCiAjaWZuZGVmIENPTkZJR19OT19SQURJVVMKQEAgLTIxMCwyMSArMjMwLDkgQEAKIAlyZXR1cm4gZXJyb3JzOwogfQogCi0vKioKLSAqIGhvc3RhcGRfY2xlYW51cCAtIFBlci1CU1MgY2xlYW51cCAoZGVpbml0aWFsaXphdGlvbikKLSAqIEBoYXBkOiBQb2ludGVyIHRvIEJTUyBkYXRhCi0gKgotICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIGZyZWUgYWxsIHBlci1CU1MgZGF0YSBzdHJ1Y3R1cmVzIGFuZCByZXNvdXJjZXMuCi0gKiBUaGlzIGdldHMgY2FsbGVkIGluIGEgbG9vcCBmb3IgZWFjaCBCU1MgYmV0d2VlbiBjYWxscyB0bwotICogaG9zdGFwZF9jbGVhbnVwX2lmYWNlX3ByZSgpIGFuZCBob3N0YXBkX2NsZWFudXBfaWZhY2UoKSB3aGVuIGFuIGludGVyZmFjZQotICogaXMgZGVpbml0aWFsaXplZC4gTW9zdCBvZiB0aGUgbW9kdWxlcyB0aGF0IGFyZSBpbml0aWFsaXplZCBpbgotICogaG9zdGFwZF9zZXR1cF9ic3MoKSBhcmUgZGVpbml0aWFsaXplZCBoZXJlLgotICovCi1zdGF0aWMgdm9pZCBob3N0YXBkX2NsZWFudXAoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKLXsKLQlpZiAoaGFwZC0+aWZhY2UtPmN0cmxfaWZhY2VfZGVpbml0KQotCQloYXBkLT5pZmFjZS0+Y3RybF9pZmFjZV9kZWluaXQoaGFwZCk7CiAKK3N0YXRpYyB2b2lkIGhvc3RhcGRfZnJlZV9oYXBkX2RhdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKIAlpYXBwX2RlaW5pdChoYXBkLT5pYXBwKTsKIAloYXBkLT5pYXBwID0gTlVMTDsKIAlhY2NvdW50aW5nX2RlaW5pdChoYXBkKTsKQEAgLTIzNCw2ICsyNDIsOCBAQAogI2lmbmRlZiBDT05GSUdfTk9fUkFESVVTCiAJcmFkaXVzX2NsaWVudF9kZWluaXQoaGFwZC0+cmFkaXVzKTsKIAloYXBkLT5yYWRpdXMgPSBOVUxMOworCXJhZGl1c19kYXNfZGVpbml0KGhhcGQtPnJhZGl1c19kYXMpOworCWhhcGQtPnJhZGl1c19kYXMgPSBOVUxMOwogI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KIAogCWhvc3RhcGRfZGVpbml0X3dwcyhoYXBkKTsKQEAgLTI1Nyw2ICsyNjcsMjggQEAKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKIAl3cGFidWZfZnJlZShoYXBkLT50aW1lX2Fkdik7CisKKyNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCisJZ2FzX3NlcnZfZGVpbml0KGhhcGQpOworI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KK30KKworCisvKioKKyAqIGhvc3RhcGRfY2xlYW51cCAtIFBlci1CU1MgY2xlYW51cCAoZGVpbml0aWFsaXphdGlvbikKKyAqIEBoYXBkOiBQb2ludGVyIHRvIEJTUyBkYXRhCisgKgorICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIGZyZWUgYWxsIHBlci1CU1MgZGF0YSBzdHJ1Y3R1cmVzIGFuZCByZXNvdXJjZXMuCisgKiBUaGlzIGdldHMgY2FsbGVkIGluIGEgbG9vcCBmb3IgZWFjaCBCU1MgYmV0d2VlbiBjYWxscyB0bworICogaG9zdGFwZF9jbGVhbnVwX2lmYWNlX3ByZSgpIGFuZCBob3N0YXBkX2NsZWFudXBfaWZhY2UoKSB3aGVuIGFuIGludGVyZmFjZQorICogaXMgZGVpbml0aWFsaXplZC4gTW9zdCBvZiB0aGUgbW9kdWxlcyB0aGF0IGFyZSBpbml0aWFsaXplZCBpbgorICogaG9zdGFwZF9zZXR1cF9ic3MoKSBhcmUgZGVpbml0aWFsaXplZCBoZXJlLgorICovCitzdGF0aWMgdm9pZCBob3N0YXBkX2NsZWFudXAoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCkKK3sKKwlpZiAoaGFwZC0+aWZhY2UtPmN0cmxfaWZhY2VfZGVpbml0KQorCQloYXBkLT5pZmFjZS0+Y3RybF9pZmFjZV9kZWluaXQoaGFwZCk7CisJaG9zdGFwZF9mcmVlX2hhcGRfZGF0YShoYXBkKTsKIH0KIAogCkBAIC0yNzIsNiArMzA0LDE4IEBACiB9CiAKIAorc3RhdGljIHZvaWQgaG9zdGFwZF9jbGVhbnVwX2lmYWNlX3BhcnRpYWwoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQoreworCWhvc3RhcGRfZnJlZV9od19mZWF0dXJlcyhpZmFjZS0+aHdfZmVhdHVyZXMsIGlmYWNlLT5udW1faHdfZmVhdHVyZXMpOworCWlmYWNlLT5od19mZWF0dXJlcyA9IE5VTEw7CisJb3NfZnJlZShpZmFjZS0+Y3VycmVudF9yYXRlcyk7CisJaWZhY2UtPmN1cnJlbnRfcmF0ZXMgPSBOVUxMOworCW9zX2ZyZWUoaWZhY2UtPmJhc2ljX3JhdGVzKTsKKwlpZmFjZS0+YmFzaWNfcmF0ZXMgPSBOVUxMOworCWFwX2xpc3RfZGVpbml0KGlmYWNlKTsKK30KKworCiAvKioKICAqIGhvc3RhcGRfY2xlYW51cF9pZmFjZSAtIENvbXBsZXRlIHBlci1pbnRlcmZhY2UgY2xlYW51cAogICogQGlmYWNlOiBQb2ludGVyIHRvIGludGVyZmFjZSBkYXRhCkBAIC0yODEsMTMgKzMyNSw3IEBACiAgKi8KIHN0YXRpYyB2b2lkIGhvc3RhcGRfY2xlYW51cF9pZmFjZShzdHJ1Y3QgaG9zdGFwZF9pZmFjZSAqaWZhY2UpCiB7Ci0JaG9zdGFwZF9mcmVlX2h3X2ZlYXR1cmVzKGlmYWNlLT5od19mZWF0dXJlcywgaWZhY2UtPm51bV9od19mZWF0dXJlcyk7Ci0JaWZhY2UtPmh3X2ZlYXR1cmVzID0gTlVMTDsKLQlvc19mcmVlKGlmYWNlLT5jdXJyZW50X3JhdGVzKTsKLQlpZmFjZS0+Y3VycmVudF9yYXRlcyA9IE5VTEw7Ci0Jb3NfZnJlZShpZmFjZS0+YmFzaWNfcmF0ZXMpOwotCWlmYWNlLT5iYXNpY19yYXRlcyA9IE5VTEw7Ci0JYXBfbGlzdF9kZWluaXQoaWZhY2UpOworCWhvc3RhcGRfY2xlYW51cF9pZmFjZV9wYXJ0aWFsKGlmYWNlKTsKIAlob3N0YXBkX2NvbmZpZ19mcmVlKGlmYWNlLT5jb25mKTsKIAlpZmFjZS0+Y29uZiA9IE5VTEw7CiAKQEAgLTI5Nyw2ICszMzUsMTUgQEAKIH0KIAogCitzdGF0aWMgdm9pZCBob3N0YXBkX2NsZWFyX3dlcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQoreworCWlmIChoYXBkLT5kcnZfcHJpdikgeworCQlob3N0YXBkX3NldF9wcml2YWN5KGhhcGQsIDApOworCQlob3N0YXBkX2Jyb2FkY2FzdF93ZXBfY2xlYXIoaGFwZCk7CisJfQorfQorCisKIHN0YXRpYyBpbnQgaG9zdGFwZF9zZXR1cF9lbmNyeXB0aW9uKGNoYXIgKmlmYWNlLCBzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQogewogCWludCBpOwpAQCAtMzMzLDcgKzM4MCw3IEBACiB9CiAKIAotc3RhdGljIGludCBob3N0YXBkX2ZsdXNoX29sZF9zdGF0aW9ucyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQorc3RhdGljIGludCBob3N0YXBkX2ZsdXNoX29sZF9zdGF0aW9ucyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1MTYgcmVhc29uKQogewogCWludCByZXQgPSAwOwogCXU4IGFkZHJbRVRIX0FMRU5dOwpAQCAtMzQ5LDcgKzM5Niw3IEBACiAJfQogCXdwYV9kYmcoaGFwZC0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiRGVhdXRoZW50aWNhdGUgYWxsIHN0YXRpb25zIik7CiAJb3NfbWVtc2V0KGFkZHIsIDB4ZmYsIEVUSF9BTEVOKTsKLQlob3N0YXBkX2Rydl9zdGFfZGVhdXRoKGhhcGQsIGFkZHIsIFdMQU5fUkVBU09OX1BSRVZfQVVUSF9OT1RfVkFMSUQpOworCWhvc3RhcGRfZHJ2X3N0YV9kZWF1dGgoaGFwZCwgYWRkciwgcmVhc29uKTsKIAlob3N0YXBkX2ZyZWVfc3RhcyhoYXBkKTsKIAogCXJldHVybiByZXQ7CkBAIC00NjQsNiArNTExLDg2IEBACiB9CiAKIAorI2lmbmRlZiBDT05GSUdfTk9fUkFESVVTCisKK3N0YXRpYyBpbnQgaG9zdGFwZF9kYXNfbmFzX21pc21hdGNoKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJICAgIHN0cnVjdCByYWRpdXNfZGFzX2F0dHJzICphdHRyKQoreworCS8qIFRPRE8gKi8KKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgc3RydWN0IHN0YV9pbmZvICogaG9zdGFwZF9kYXNfZmluZF9zdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkJICAgICAgc3RydWN0IHJhZGl1c19kYXNfYXR0cnMgKmF0dHIpCit7CisJc3RydWN0IHN0YV9pbmZvICpzdGEgPSBOVUxMOworCWNoYXIgYnVmWzEyOF07CisKKwlpZiAoYXR0ci0+c3RhX2FkZHIpCisJCXN0YSA9IGFwX2dldF9zdGEoaGFwZCwgYXR0ci0+c3RhX2FkZHIpOworCisJaWYgKHN0YSA9PSBOVUxMICYmIGF0dHItPmFjY3Rfc2Vzc2lvbl9pZCAmJgorCSAgICBhdHRyLT5hY2N0X3Nlc3Npb25faWRfbGVuID09IDE3KSB7CisJCWZvciAoc3RhID0gaGFwZC0+c3RhX2xpc3Q7IHN0YTsgc3RhID0gc3RhLT5uZXh0KSB7CisJCQlvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiJTA4WC0lMDhYIiwKKwkJCQkgICAgc3RhLT5hY2N0X3Nlc3Npb25faWRfaGksCisJCQkJICAgIHN0YS0+YWNjdF9zZXNzaW9uX2lkX2xvKTsKKwkJCWlmIChvc19tZW1jbXAoYXR0ci0+YWNjdF9zZXNzaW9uX2lkLCBidWYsIDE3KSA9PSAwKQorCQkJCWJyZWFrOworCQl9CisJfQorCisJaWYgKHN0YSA9PSBOVUxMICYmIGF0dHItPmN1aSkgeworCQlmb3IgKHN0YSA9IGhhcGQtPnN0YV9saXN0OyBzdGE7IHN0YSA9IHN0YS0+bmV4dCkgeworCQkJc3RydWN0IHdwYWJ1ZiAqY3VpOworCQkJY3VpID0gaWVlZTgwMl8xeF9nZXRfcmFkaXVzX2N1aShzdGEtPmVhcG9sX3NtKTsKKwkJCWlmIChjdWkgJiYgd3BhYnVmX2xlbihjdWkpID09IGF0dHItPmN1aV9sZW4gJiYKKwkJCSAgICBvc19tZW1jbXAod3BhYnVmX2hlYWQoY3VpKSwgYXR0ci0+Y3VpLAorCQkJCSAgICAgIGF0dHItPmN1aV9sZW4pID09IDApCisJCQkJYnJlYWs7CisJCX0KKwl9CisKKwlpZiAoc3RhID09IE5VTEwgJiYgYXR0ci0+dXNlcl9uYW1lKSB7CisJCWZvciAoc3RhID0gaGFwZC0+c3RhX2xpc3Q7IHN0YTsgc3RhID0gc3RhLT5uZXh0KSB7CisJCQl1OCAqaWRlbnRpdHk7CisJCQlzaXplX3QgaWRlbnRpdHlfbGVuOworCQkJaWRlbnRpdHkgPSBpZWVlODAyXzF4X2dldF9pZGVudGl0eShzdGEtPmVhcG9sX3NtLAorCQkJCQkJCSAgICZpZGVudGl0eV9sZW4pOworCQkJaWYgKGlkZW50aXR5ICYmCisJCQkgICAgaWRlbnRpdHlfbGVuID09IGF0dHItPnVzZXJfbmFtZV9sZW4gJiYKKwkJCSAgICBvc19tZW1jbXAoaWRlbnRpdHksIGF0dHItPnVzZXJfbmFtZSwgaWRlbnRpdHlfbGVuKQorCQkJICAgID09IDApCisJCQkJYnJlYWs7CisJCX0KKwl9CisKKwlyZXR1cm4gc3RhOworfQorCisKK3N0YXRpYyBlbnVtIHJhZGl1c19kYXNfcmVzCitob3N0YXBkX2Rhc19kaXNjb25uZWN0KHZvaWQgKmN0eCwgc3RydWN0IHJhZGl1c19kYXNfYXR0cnMgKmF0dHIpCit7CisJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGN0eDsKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKKworCWlmIChob3N0YXBkX2Rhc19uYXNfbWlzbWF0Y2goaGFwZCwgYXR0cikpCisJCXJldHVybiBSQURJVVNfREFTX05BU19NSVNNQVRDSDsKKworCXN0YSA9IGhvc3RhcGRfZGFzX2ZpbmRfc3RhKGhhcGQsIGF0dHIpOworCWlmIChzdGEgPT0gTlVMTCkKKwkJcmV0dXJuIFJBRElVU19EQVNfU0VTU0lPTl9OT1RfRk9VTkQ7CisKKwlob3N0YXBkX2Rydl9zdGFfZGVhdXRoKGhhcGQsIHN0YS0+YWRkciwKKwkJCSAgICAgICBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKKwlhcF9zdGFfZGVhdXRoZW50aWNhdGUoaGFwZCwgc3RhLCBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKKworCXJldHVybiBSQURJVVNfREFTX1NVQ0NFU1M7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfTk9fUkFESVVTICovCiAKIAogLyoqCkBAIC01MTksNyArNjQ2LDcgQEAKIAlpZiAoY29uZi0+d21tX2VuYWJsZWQgPCAwKQogCQljb25mLT53bW1fZW5hYmxlZCA9IGhhcGQtPmljb25mLT5pZWVlODAyMTFuOwogCi0JaG9zdGFwZF9mbHVzaF9vbGRfc3RhdGlvbnMoaGFwZCk7CisJaG9zdGFwZF9mbHVzaF9vbGRfc3RhdGlvbnMoaGFwZCwgV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7CiAJaG9zdGFwZF9zZXRfcHJpdmFjeShoYXBkLCAwKTsKIAogCWhvc3RhcGRfYnJvYWRjYXN0X3dlcF9jbGVhcihoYXBkKTsKQEAgLTU4Myw2ICs3MTAsMjcgQEAKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJSQURJVVMgY2xpZW50IGluaXRpYWxpemF0aW9uIGZhaWxlZC4iKTsKIAkJcmV0dXJuIC0xOwogCX0KKworCWlmIChoYXBkLT5jb25mLT5yYWRpdXNfZGFzX3BvcnQpIHsKKwkJc3RydWN0IHJhZGl1c19kYXNfY29uZiBkYXNfY29uZjsKKwkJb3NfbWVtc2V0KCZkYXNfY29uZiwgMCwgc2l6ZW9mKGRhc19jb25mKSk7CisJCWRhc19jb25mLnBvcnQgPSBoYXBkLT5jb25mLT5yYWRpdXNfZGFzX3BvcnQ7CisJCWRhc19jb25mLnNoYXJlZF9zZWNyZXQgPSBoYXBkLT5jb25mLT5yYWRpdXNfZGFzX3NoYXJlZF9zZWNyZXQ7CisJCWRhc19jb25mLnNoYXJlZF9zZWNyZXRfbGVuID0KKwkJCWhhcGQtPmNvbmYtPnJhZGl1c19kYXNfc2hhcmVkX3NlY3JldF9sZW47CisJCWRhc19jb25mLmNsaWVudF9hZGRyID0gJmhhcGQtPmNvbmYtPnJhZGl1c19kYXNfY2xpZW50X2FkZHI7CisJCWRhc19jb25mLnRpbWVfd2luZG93ID0gaGFwZC0+Y29uZi0+cmFkaXVzX2Rhc190aW1lX3dpbmRvdzsKKwkJZGFzX2NvbmYucmVxdWlyZV9ldmVudF90aW1lc3RhbXAgPQorCQkJaGFwZC0+Y29uZi0+cmFkaXVzX2Rhc19yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcDsKKwkJZGFzX2NvbmYuY3R4ID0gaGFwZDsKKwkJZGFzX2NvbmYuZGlzY29ubmVjdCA9IGhvc3RhcGRfZGFzX2Rpc2Nvbm5lY3Q7CisJCWhhcGQtPnJhZGl1c19kYXMgPSByYWRpdXNfZGFzX2luaXQoJmRhc19jb25mKTsKKwkJaWYgKGhhcGQtPnJhZGl1c19kYXMgPT0gTlVMTCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJSQURJVVMgREFTIGluaXRpYWxpemF0aW9uICIKKwkJCQkgICAiZmFpbGVkLiIpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQogI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KIAogCWlmIChob3N0YXBkX2FjbF9pbml0KGhhcGQpKSB7CkBAIC02MTUsNiArNzYzLDEzIEBACiAJCXJldHVybiAtMTsKIAl9CiAKKyNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCisJaWYgKGdhc19zZXJ2X2luaXQoaGFwZCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJHQVMgc2VydmVyIGluaXRpYWxpemF0aW9uIGZhaWxlZCIpOworCQlyZXR1cm4gLTE7CisJfQorI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KKwogCWlmIChoYXBkLT5pZmFjZS0+Y3RybF9pZmFjZV9pbml0ICYmCiAJICAgIGhhcGQtPmlmYWNlLT5jdHJsX2lmYWNlX2luaXQoaGFwZCkpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gc2V0dXAgY29udHJvbCBpbnRlcmZhY2UiKTsKQEAgLTg1Nyw2ICsxMDEyLDcgQEAKIAloYXBkLT5jb25mID0gYnNzOwogCWhhcGQtPmlmYWNlID0gaGFwZF9pZmFjZTsKIAloYXBkLT5kcml2ZXIgPSBoYXBkLT5pY29uZi0+ZHJpdmVyOworCWhhcGQtPmN0cmxfc29jayA9IC0xOwogCiAJcmV0dXJuIGhhcGQ7CiB9CkBAIC04NzMsNyArMTAyOSw4IEBACiAJZm9yIChqID0gMDsgaiA8IGlmYWNlLT5udW1fYnNzOyBqKyspIHsKIAkJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGlmYWNlLT5ic3Nbal07CiAJCWhvc3RhcGRfZnJlZV9zdGFzKGhhcGQpOwotCQlob3N0YXBkX2ZsdXNoX29sZF9zdGF0aW9ucyhoYXBkKTsKKwkJaG9zdGFwZF9mbHVzaF9vbGRfc3RhdGlvbnMoaGFwZCwgV0xBTl9SRUFTT05fREVBVVRIX0xFQVZJTkcpOworCQlob3N0YXBkX2NsZWFyX3dlcChoYXBkKTsKIAkJaG9zdGFwZF9jbGVhbnVwKGhhcGQpOwogCX0KIH0KQEAgLTkzNyw0ICsxMDk0LDEyIEBACiAJCQl3cGFfYXV0aF9zbV9ldmVudChzdGEtPndwYV9zbSwgV1BBX1JFQVVUSCk7CiAJfSBlbHNlCiAJCXdwYV9hdXRoX3N0YV9hc3NvY2lhdGVkKGhhcGQtPndwYV9hdXRoLCBzdGEtPndwYV9zbSk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiByZXNjaGVkdWxlIGFwX2hhbmRsZV90aW1lciB0aW1lb3V0ICIKKwkJICAgImZvciAiIE1BQ1NUUiAiICglZCBzZWNvbmRzIC0gYXBfbWF4X2luYWN0aXZpdHkpIiwKKwkJICAgX19mdW5jX18sIE1BQzJTVFIoc3RhLT5hZGRyKSwKKwkJICAgaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHkpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKKwllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5LCAwLAorCQkJICAgICAgIGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKIH0KZGlmZiAtLWdpdCBhL3NyYy9hcC9ob3N0YXBkLmggYi9zcmMvYXAvaG9zdGFwZC5oCmluZGV4IGJjMjg4MDUuLmY3ZWQzMTEgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9ob3N0YXBkLmgKKysrIGIvc3JjL2FwL2hvc3RhcGQuaApAQCAtMTUsNyArMTUsNiBAQAogc3RydWN0IHdwYV9jdHJsX2RzdDsKIHN0cnVjdCByYWRpdXNfc2VydmVyX2RhdGE7CiBzdHJ1Y3QgdXBucF93cHNfZGV2aWNlX3NtOwotc3RydWN0IGhhcGRfaW50ZXJmYWNlczsKIHN0cnVjdCBob3N0YXBkX2RhdGE7CiBzdHJ1Y3Qgc3RhX2luZm87CiBzdHJ1Y3QgaG9zdGFwX3N0YV9kcml2ZXJfZGF0YTsKQEAgLTI0LDkgKzIzLDE1IEBACiBlbnVtIHdwc19ldmVudDsKIHVuaW9uIHdwc19ldmVudF9kYXRhOwogCitzdHJ1Y3QgaGFwZF9pbnRlcmZhY2VzIHsKKwlzaXplX3QgY291bnQ7CisJc3RydWN0IGhvc3RhcGRfaWZhY2UgKippZmFjZTsKK307CisKKwogc3RydWN0IGhvc3RhcGRfcHJvYmVyZXFfY2IgewogCWludCAoKmNiKSh2b2lkICpjdHgsIGNvbnN0IHU4ICpzYSwgY29uc3QgdTggKmRhLCBjb25zdCB1OCAqYnNzaWQsCi0JCSAgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuKTsKKwkJICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sIGludCBzc2lfc2lnbmFsKTsKIAl2b2lkICpjdHg7CiB9OwogCkBAIC00MCw3ICs0NSw3IEBACiBzdHJ1Y3QgaG9zdGFwZF9mcmFtZV9pbmZvIHsKIAl1MzIgY2hhbm5lbDsKIAl1MzIgZGF0YXJhdGU7Ci0JdTMyIHNzaV9zaWduYWw7CisJaW50IHNzaV9zaWduYWw7IC8qIGRCbSAqLwogfTsKIAogCkBAIC04MCw2ICs4NSw3IEBACiAKIAlzdHJ1Y3QgcmFkaXVzX2NsaWVudF9kYXRhICpyYWRpdXM7CiAJdTMyIGFjY3Rfc2Vzc2lvbl9pZF9oaSwgYWNjdF9zZXNzaW9uX2lkX2xvOworCXN0cnVjdCByYWRpdXNfZGFzX2RhdGEgKnJhZGl1c19kYXM7CiAKIAlzdHJ1Y3QgaWFwcF9kYXRhICppYXBwOwogCkBAIC0xNjQsNiArMTcwLDkgQEAKIAlpbnQgbm9hX3N0YXJ0OwogCWludCBub2FfZHVyYXRpb247CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLworI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKwlzaXplX3QgZ2FzX2ZyYWdfbGltaXQ7CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogfTsKIAogCkBAIC0yNDIsNiArMjUxLDkgQEAKIH07CiAKIC8qIGhvc3RhcGQuYyAqLworaW50IGhvc3RhcGRfZm9yX2VhY2hfaW50ZXJmYWNlKHN0cnVjdCBoYXBkX2ludGVyZmFjZXMgKmludGVyZmFjZXMsCisJCQkgICAgICAgaW50ICgqY2IpKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwKKwkJCQkJIHZvaWQgKmN0eCksIHZvaWQgKmN0eCk7CiBpbnQgaG9zdGFwZF9yZWxvYWRfY29uZmlnKHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSk7CiBzdHJ1Y3QgaG9zdGFwZF9kYXRhICoKIGhvc3RhcGRfYWxsb2NfYnNzX2RhdGEoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmhhcGRfaWZhY2UsCkBAIC0yNTgsNyArMjcwLDggQEAKIGludCBob3N0YXBkX3JlZ2lzdGVyX3Byb2JlcmVxX2NiKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkJIGludCAoKmNiKSh2b2lkICpjdHgsIGNvbnN0IHU4ICpzYSwKIAkJCQkJICAgY29uc3QgdTggKmRhLCBjb25zdCB1OCAqYnNzaWQsCi0JCQkJCSAgIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiksCisJCQkJCSAgIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwKKwkJCQkJICAgaW50IHNzaV9zaWduYWwpLAogCQkJCSB2b2lkICpjdHgpOwogdm9pZCBob3N0YXBkX3BydW5lX2Fzc29jaWF0aW9ucyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkcik7CiAKQEAgLTI2OCw2ICsyODEsOSBAQAogdm9pZCBob3N0YXBkX25vdGlmX2Rpc2Fzc29jKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICphZGRyKTsKIHZvaWQgaG9zdGFwZF9ldmVudF9zdGFfbG93X2FjayhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkcik7CiBpbnQgaG9zdGFwZF9wcm9iZV9yZXFfcngoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKnNhLCBjb25zdCB1OCAqZGEsCi0JCQkgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pOworCQkJIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuLAorCQkJIGludCBzc2lfc2lnbmFsKTsKK3ZvaWQgaG9zdGFwZF9ldmVudF9jaF9zd2l0Y2goc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IGZyZXEsIGludCBodCwKKwkJCSAgICAgaW50IG9mZnNldCk7CiAKICNlbmRpZiAvKiBIT1NUQVBEX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9od19mZWF0dXJlcy5jIGIvc3JjL2FwL2h3X2ZlYXR1cmVzLmMKaW5kZXggOGM2ZmVmMi4uNzZjNDIxMSAxMDA2NDQKLS0tIGEvc3JjL2FwL2h3X2ZlYXR1cmVzLmMKKysrIGIvc3JjL2FwL2h3X2ZlYXR1cmVzLmMKQEAgLTIsNyArMiw3IEBACiAgKiBob3N0YXBkIC8gSGFyZHdhcmUgZmVhdHVyZSBxdWVyeSBhbmQgZGlmZmVyZW50IG1vZGVzCiAgKiBDb3B5cmlnaHQgMjAwMi0yMDAzLCBJbnN0YW50ODAyIE5ldHdvcmtzLCBJbmMuCiAgKiBDb3B5cmlnaHQgMjAwNS0yMDA2LCBEZXZpY2VzY2FwZSBTb2Z0d2FyZSwgSW5jLgotICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMTEsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKQEAgLTQxNiw3ICs0MTYsNyBAQAogCWludCByZXM7CiAKIAkvKiBDaGVjayBsaXN0IG9mIG5laWdoYm9yaW5nIEJTU2VzIChmcm9tIHNjYW4pIHRvIHNlZSB3aGV0aGVyIDQwIE1IeiBpcwotCSAqIGFsbG93ZWQgcGVyIElFRUUgODAyLjExbi9ENy4wLCAxMS4xNC4zLjIgKi8KKwkgKiBhbGxvd2VkIHBlciBJRUVFIFN0ZCA4MDIuMTEtMjAxMiwgMTAuMTUuMy4yICovCiAKIAlpZmFjZS0+c2Nhbl9jYiA9IE5VTEw7CiAKQEAgLTQ0Nyw2ICs0NDcsNDYgQEAKIH0KIAogCitzdGF0aWMgdm9pZCBpZWVlODAyMTFuX3NjYW5fY2hhbm5lbHNfMmc0KHN0cnVjdCBob3N0YXBkX2lmYWNlICppZmFjZSwKKwkJCQkJIHN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpwYXJhbXMpCit7CisJLyogU2NhbiBvbmx5IHRoZSBhZmZlY3RlZCBmcmVxdWVuY3kgcmFuZ2UgKi8KKwlpbnQgcHJpX2ZyZXEsIHNlY19mcmVxOworCWludCBhZmZlY3RlZF9zdGFydCwgYWZmZWN0ZWRfZW5kOworCWludCBpLCBwb3M7CisJc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGU7CisKKwlpZiAoaWZhY2UtPmN1cnJlbnRfbW9kZSA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlwcmlfZnJlcSA9IGhvc3RhcGRfaHdfZ2V0X2ZyZXEoaWZhY2UtPmJzc1swXSwgaWZhY2UtPmNvbmYtPmNoYW5uZWwpOworCWlmIChpZmFjZS0+Y29uZi0+c2Vjb25kYXJ5X2NoYW5uZWwgPiAwKQorCQlzZWNfZnJlcSA9IHByaV9mcmVxICsgMjA7CisJZWxzZQorCQlzZWNfZnJlcSA9IHByaV9mcmVxIC0gMjA7CisJYWZmZWN0ZWRfc3RhcnQgPSAocHJpX2ZyZXEgKyBzZWNfZnJlcSkgLyAyIC0gMjU7CisJYWZmZWN0ZWRfZW5kID0gKHByaV9mcmVxICsgc2VjX2ZyZXEpIC8gMiArIDI1OworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiNDAgTUh6IGFmZmVjdGVkIGNoYW5uZWwgcmFuZ2U6IFslZCwlZF0gTUh6IiwKKwkJICAgYWZmZWN0ZWRfc3RhcnQsIGFmZmVjdGVkX2VuZCk7CisKKwltb2RlID0gaWZhY2UtPmN1cnJlbnRfbW9kZTsKKwlwYXJhbXMtPmZyZXFzID0gb3NfemFsbG9jKChtb2RlLT5udW1fY2hhbm5lbHMgKyAxKSAqIHNpemVvZihpbnQpKTsKKwlpZiAocGFyYW1zLT5mcmVxcyA9PSBOVUxMKQorCQlyZXR1cm47CisJcG9zID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBtb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgeworCQlzdHJ1Y3QgaG9zdGFwZF9jaGFubmVsX2RhdGEgKmNoYW4gPSAmbW9kZS0+Y2hhbm5lbHNbaV07CisJCWlmIChjaGFuLT5mbGFnICYgSE9TVEFQRF9DSEFOX0RJU0FCTEVEKQorCQkJY29udGludWU7CisJCWlmIChjaGFuLT5mcmVxIDwgYWZmZWN0ZWRfc3RhcnQgfHwKKwkJICAgIGNoYW4tPmZyZXEgPiBhZmZlY3RlZF9lbmQpCisJCQljb250aW51ZTsKKwkJcGFyYW1zLT5mcmVxc1twb3MrK10gPSBjaGFuLT5mcmVxOworCX0KK30KKworCiBzdGF0aWMgaW50IGllZWU4MDIxMW5fY2hlY2tfNDBtaHooc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKQogewogCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zIHBhcmFtczsKQEAgLTQ1NywxMiArNDk3LDE1IEBACiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTY2FuIGZvciBuZWlnaGJvcmluZyBCU1NlcyBwcmlvciB0byBlbmFibGluZyAiCiAJCSAgICI0MCBNSHogY2hhbm5lbCIpOwogCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7Ci0JLyogVE9ETzogc2NhbiBvbmx5IHRoZSBuZWVkZWQgZnJlcXVlbmN5ICovCisJaWYgKGlmYWNlLT5jdXJyZW50X21vZGUtPm1vZGUgPT0gSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcpCisJCWllZWU4MDIxMW5fc2Nhbl9jaGFubmVsc18yZzQoaWZhY2UsICZwYXJhbXMpOwogCWlmIChob3N0YXBkX2RyaXZlcl9zY2FuKGlmYWNlLT5ic3NbMF0sICZwYXJhbXMpIDwgMCkgewogCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byByZXF1ZXN0IGEgc2NhbiBvZiAiCiAJCQkgICAibmVpZ2hib3JpbmcgQlNTZXMiKTsKKwkJb3NfZnJlZShwYXJhbXMuZnJlcXMpOwogCQlyZXR1cm4gLTE7CiAJfQorCW9zX2ZyZWUocGFyYW1zLmZyZXFzKTsKIAogCWlmYWNlLT5zY2FuX2NiID0gaWVlZTgwMjExbl9jaGVja19zY2FuOwogCXJldHVybiAxOwpkaWZmIC0tZ2l0IGEvc3JjL2FwL2llZWU4MDJfMTEuYyBiL3NyYy9hcC9pZWVlODAyXzExLmMKaW5kZXggOWM5MzFjYS4uMzk5NmM5MCAxMDA2NDQKLS0tIGEvc3JjL2FwL2llZWU4MDJfMTEuYworKysgYi9zcmMvYXAvaWVlZTgwMl8xMS5jCkBAIC04NzYsNiArODc2LDcgQEAKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExTiAqLwogCiAJcCA9IGhvc3RhcGRfZWlkX2V4dF9jYXBhYihoYXBkLCBwKTsKKwlwID0gaG9zdGFwZF9laWRfYnNzX21heF9pZGxlX3BlcmlvZChoYXBkLCBwKTsKIAogCWlmIChzdGEtPmZsYWdzICYgV0xBTl9TVEFfV01NKQogCQlwID0gaG9zdGFwZF9laWRfd21tKGhhcGQsIHApOwpAQCAtMTM5Miw3ICsxMzkzLDcgQEAKIAogCiAJaWYgKHN0eXBlID09IFdMQU5fRkNfU1RZUEVfUFJPQkVfUkVRKSB7Ci0JCWhhbmRsZV9wcm9iZV9yZXEoaGFwZCwgbWdtdCwgbGVuKTsKKwkJaGFuZGxlX3Byb2JlX3JlcShoYXBkLCBtZ210LCBsZW4sIGZpLT5zc2lfc2lnbmFsKTsKIAkJcmV0dXJuOwogCX0KIApkaWZmIC0tZ2l0IGEvc3JjL2FwL2llZWU4MDJfMTEuaCBiL3NyYy9hcC9pZWVlODAyXzExLmgKaW5kZXggZDMwZTkwZi4uOTk5M2JlZSAxMDA2NDQKLS0tIGEvc3JjL2FwL2llZWU4MDJfMTEuaAorKysgYi9zcmMvYXAvaWVlZTgwMl8xMS5oCkBAIC00NSw2ICs0NSw4IEBACiB1OCAqIGhvc3RhcGRfZWlkX2V4dF9zdXBwX3JhdGVzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpOwogdTggKiBob3N0YXBkX2VpZF9odF9jYXBhYmlsaXRpZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7CiB1OCAqIGhvc3RhcGRfZWlkX2h0X29wZXJhdGlvbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKTsKK3U4ICogaG9zdGFwZF9laWRfdmh0X2NhcGFiaWxpdGllcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKTsKK3U4ICogaG9zdGFwZF9laWRfdmh0X29wZXJhdGlvbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKTsKIGludCBob3N0YXBkX2h0X29wZXJhdGlvbl91cGRhdGUoc3RydWN0IGhvc3RhcGRfaWZhY2UgKmlmYWNlKTsKIHZvaWQgaWVlZTgwMl8xMV9zZW5kX3NhX3F1ZXJ5X3JlcShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCSAgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICp0cmFuc19pZCk7CkBAIC03Miw1ICs3NCw2IEBACiB1OCAqIGhvc3RhcGRfZWlkX3RpbWVfem9uZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKTsKIGludCBob3N0YXBkX3VwZGF0ZV90aW1lX2FkdihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKTsKIHZvaWQgaG9zdGFwZF9jbGllbnRfcG9sbF9vayhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCB1OCAqYWRkcik7Cit1OCAqIGhvc3RhcGRfZWlkX2Jzc19tYXhfaWRsZV9wZXJpb2Qoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCk7CiAKICNlbmRpZiAvKiBJRUVFODAyXzExX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9pZWVlODAyXzExX2F1dGguYyBiL3NyYy9hcC9pZWVlODAyXzExX2F1dGguYwppbmRleCAxMDljNGJjLi4wYzRjNWYzIDEwMDY0NAotLS0gYS9zcmMvYXAvaWVlZTgwMl8xMV9hdXRoLmMKKysrIGIvc3JjL2FwL2llZWU4MDJfMTFfYXV0aC5jCkBAIC0xOTMsNyArMTkzLDggQEAKIAkJZ290byBmYWlsOwogCX0KIAotCXJhZGl1c19jbGllbnRfc2VuZChoYXBkLT5yYWRpdXMsIG1zZywgUkFESVVTX0FVVEgsIGFkZHIpOworCWlmIChyYWRpdXNfY2xpZW50X3NlbmQoaGFwZC0+cmFkaXVzLCBtc2csIFJBRElVU19BVVRILCBhZGRyKSA8IDApCisJCWdvdG8gZmFpbDsKIAlyZXR1cm4gMDsKIAogIGZhaWw6CkBAIC00OTIsNyArNDkzLDcgQEAKIAkJfQogCiAJCWlmIChoYXBkLT5jb25mLT53cGFfcHNrX3JhZGl1cyA9PSBQU0tfUkFESVVTX1JFUVVJUkVEICYmCi0JCSAgICBjYWNoZS0+cHNrID09IE5VTEwpCisJCSAgICAhY2FjaGUtPmhhc19wc2spCiAJCQljYWNoZS0+YWNjZXB0ZWQgPSBIT1NUQVBEX0FDTF9SRUpFQ1Q7CiAJfSBlbHNlCiAJCWNhY2hlLT5hY2NlcHRlZCA9IEhPU1RBUERfQUNMX1JFSkVDVDsKZGlmZiAtLWdpdCBhL3NyYy9hcC9pZWVlODAyXzExX3NoYXJlZC5jIGIvc3JjL2FwL2llZWU4MDJfMTFfc2hhcmVkLmMKaW5kZXggMDkzNWNkNS4uYjNmZGYzZCAxMDA2NDQKLS0tIGEvc3JjL2FwL2llZWU4MDJfMTFfc2hhcmVkLmMKKysrIGIvc3JjL2FwL2llZWU4MDJfMTFfc2hhcmVkLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIElFRUUgODAyLjExIE1hbmFnZW1lbnQKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDEwLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTM5NywzICszOTcsMzEgQEAKIAogCXJldHVybiAwOwogfQorCisKK3U4ICogaG9zdGFwZF9laWRfYnNzX21heF9pZGxlX3BlcmlvZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB1OCAqZWlkKQoreworCXU4ICpwb3MgPSBlaWQ7CisKKyNpZmRlZiBDT05GSUdfV05NCisJaWYgKGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5ID4gMCkgeworCQl1bnNpZ25lZCBpbnQgdmFsOworCQkqcG9zKysgPSBXTEFOX0VJRF9CU1NfTUFYX0lETEVfUEVSSU9EOworCQkqcG9zKysgPSAzOworCQl2YWwgPSBoYXBkLT5jb25mLT5hcF9tYXhfaW5hY3Rpdml0eTsKKwkJaWYgKHZhbCA+IDY4MDAwKQorCQkJdmFsID0gNjgwMDA7CisJCXZhbCAqPSAxMDAwOworCQl2YWwgLz0gMTAyNDsKKwkJaWYgKHZhbCA9PSAwKQorCQkJdmFsID0gMTsKKwkJaWYgKHZhbCA+IDY1NTM1KQorCQkJdmFsID0gNjU1MzU7CisJCVdQQV9QVVRfTEUxNihwb3MsIHZhbCk7CisJCXBvcyArPSAyOworCQkqcG9zKysgPSAweDAwOyAvKiBUT0RPOiBQcm90ZWN0ZWQgS2VlcC1BbGl2ZSBSZXF1aXJlZCAqLworCX0KKyNlbmRpZiAvKiBDT05GSUdfV05NICovCisKKwlyZXR1cm4gcG9zOworfQpkaWZmIC0tZ2l0IGEvc3JjL2FwL2llZWU4MDJfMTFfdmh0LmMgYi9zcmMvYXAvaWVlZTgwMl8xMV92aHQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zYWQzM2M4Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL2FwL2llZWU4MDJfMTFfdmh0LmMKQEAgLTAsMCArMSw3MiBAQAorLyoKKyAqIGhvc3RhcGQgLyBJRUVFIDgwMi4xMWFjIFZIVAorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QgbGljZW5zZQorICoKKyAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgInV0aWxzL2NvbW1vbi5oIgorI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKKyNpbmNsdWRlICJkcml2ZXJzL2RyaXZlci5oIgorI2luY2x1ZGUgImhvc3RhcGQuaCIKKyNpbmNsdWRlICJhcF9jb25maWcuaCIKKyNpbmNsdWRlICJzdGFfaW5mby5oIgorI2luY2x1ZGUgImJlYWNvbi5oIgorI2luY2x1ZGUgImllZWU4MDJfMTEuaCIKKworCit1OCAqIGhvc3RhcGRfZWlkX3ZodF9jYXBhYmlsaXRpZXMoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdTggKmVpZCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExX3ZodF9jYXBhYmlsaXRpZXMgKmNhcDsKKwl1OCAqcG9zID0gZWlkOworCisJaWYgKCFoYXBkLT5pY29uZi0+aWVlZTgwMjExYWMgfHwgIWhhcGQtPmlmYWNlLT5jdXJyZW50X21vZGUgfHwKKwkgICAgaGFwZC0+Y29uZi0+ZGlzYWJsZV8xMWFjKQorCQlyZXR1cm4gZWlkOworCisJKnBvcysrID0gV0xBTl9FSURfVkhUX0NBUDsKKwkqcG9zKysgPSBzaXplb2YoKmNhcCk7CisKKwljYXAgPSAoc3RydWN0IGllZWU4MDIxMV92aHRfY2FwYWJpbGl0aWVzICopIHBvczsKKwlvc19tZW1zZXQoY2FwLCAwLCBzaXplb2YoKmNhcCkpOworCWNhcC0+dmh0X2NhcGFiaWxpdGllc19pbmZvID0gaG9zdF90b19sZTMyKAorCQloYXBkLT5pZmFjZS0+Y3VycmVudF9tb2RlLT52aHRfY2FwYWIpOworCisJLyogU3VwcG9ydGVkIE1DUyBzZXQgY29tZXMgZnJvbSBodyAqLworCW9zX21lbWNweShjYXAtPnZodF9zdXBwb3J0ZWRfbWNzX3NldCwKKwkgICAgICAgICAgaGFwZC0+aWZhY2UtPmN1cnJlbnRfbW9kZS0+dmh0X21jc19zZXQsIDgpOworCisJcG9zICs9IHNpemVvZigqY2FwKTsKKworCXJldHVybiBwb3M7Cit9CisKKwordTggKiBob3N0YXBkX2VpZF92aHRfb3BlcmF0aW9uKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHU4ICplaWQpCit7CisJc3RydWN0IGllZWU4MDIxMV92aHRfb3BlcmF0aW9uICpvcGVyOworCXU4ICpwb3MgPSBlaWQ7CisKKwlpZiAoIWhhcGQtPmljb25mLT5pZWVlODAyMTFhYyB8fCBoYXBkLT5jb25mLT5kaXNhYmxlXzExYWMpCisJCXJldHVybiBlaWQ7CisKKwkqcG9zKysgPSBXTEFOX0VJRF9WSFRfT1BFUkFUSU9OOworCSpwb3MrKyA9IHNpemVvZigqb3Blcik7CisKKwlvcGVyID0gKHN0cnVjdCBpZWVlODAyMTFfdmh0X29wZXJhdGlvbiAqKSBwb3M7CisJb3NfbWVtc2V0KG9wZXIsIDAsIHNpemVvZigqb3BlcikpOworCisJb3Blci0+dmh0X29wX2luZm9fY2h3aWR0aCA9IGhhcGQtPmljb25mLT52aHRfb3Blcl9jaHdpZHRoOworCisJLyogVkhUIEJhc2ljIE1DUyBzZXQgY29tZXMgZnJvbSBodyAqLworCS8qIEhhcmQgY29kZSAxIHN0cmVhbSwgTUNTMC03IGlzIGEgbWluIEJhc2ljIFZIVCBNQ1MgcmF0ZXMgKi8KKwlvcGVyLT52aHRfYmFzaWNfbWNzX3NldCA9IDB4ZmZmYzsKKwlwb3MgKz0gc2l6ZW9mKCpvcGVyKTsKKworCXJldHVybiBwb3M7Cit9CmRpZmYgLS1naXQgYS9zcmMvYXAvaWVlZTgwMl8xeC5jIGIvc3JjL2FwL2llZWU4MDJfMXguYwppbmRleCBhMzI5Nzc3Li5kZDBkZjFkIDEwMDY0NAotLS0gYS9zcmMvYXAvaWVlZTgwMl8xeC5jCisrKyBiL3NyYy9hcC9pZWVlODAyXzF4LmMKQEAgLTQxNiw2ICs0MTYsNyBAQAogCXN0cnVjdCByYWRpdXNfbXNnICptc2c7CiAJY2hhciBidWZbMTI4XTsKIAlzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc20gPSBzdGEtPmVhcG9sX3NtOworCXN0cnVjdCBob3N0YXBkX3JhZGl1c19hdHRyICphdHRyOwogCiAJaWYgKHNtID09IE5VTEwpCiAJCXJldHVybjsKQEAgLTQ0Miw3ICs0NDMsOSBAQAogCQlnb3RvIGZhaWw7CiAJfQogCi0JaWYgKGhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLmFmID09IEFGX0lORVQgJiYKKwlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihoYXBkLT5jb25mLT5yYWRpdXNfYXV0aF9yZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX05BU19JUF9BRERSRVNTKSAmJgorCSAgICBoYXBkLT5jb25mLT5vd25faXBfYWRkci5hZiA9PSBBRl9JTkVUICYmCiAJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfTkFTX0lQX0FERFJFU1MsCiAJCQkJICh1OCAqKSAmaGFwZC0+Y29uZi0+b3duX2lwX2FkZHIudS52NCwgNCkpIHsKIAkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIE5BUy1JUC1BZGRyZXNzXG4iKTsKQEAgLTQ1MCw3ICs0NTMsOSBAQAogCX0KIAogI2lmZGVmIENPTkZJR19JUFY2Ci0JaWYgKGhhcGQtPmNvbmYtPm93bl9pcF9hZGRyLmFmID09IEFGX0lORVQ2ICYmCisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2F1dGhfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfSVBWNl9BRERSRVNTKSAmJgorCSAgICBoYXBkLT5jb25mLT5vd25faXBfYWRkci5hZiA9PSBBRl9JTkVUNiAmJgogCSAgICAhcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX05BU19JUFY2X0FERFJFU1MsCiAJCQkJICh1OCAqKSAmaGFwZC0+Y29uZi0+b3duX2lwX2FkZHIudS52NiwgMTYpKSB7CiAJCXByaW50ZigiQ291bGQgbm90IGFkZCBOQVMtSVB2Ni1BZGRyZXNzXG4iKTsKQEAgLTQ1OCw3ICs0NjMsOSBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLwogCi0JaWYgKGhhcGQtPmNvbmYtPm5hc19pZGVudGlmaWVyICYmCisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2F1dGhfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfSURFTlRJRklFUikgJiYKKwkgICAgaGFwZC0+Y29uZi0+bmFzX2lkZW50aWZpZXIgJiYKIAkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9OQVNfSURFTlRJRklFUiwKIAkJCQkgKHU4ICopIGhhcGQtPmNvbmYtPm5hc19pZGVudGlmaWVyLAogCQkJCSBvc19zdHJsZW4oaGFwZC0+Y29uZi0+bmFzX2lkZW50aWZpZXIpKSkgewpAQCAtNDY2LDcgKzQ3Myw5IEBACiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9OQVNfUE9SVCwgc3RhLT5haWQpKSB7CisJaWYgKCFob3N0YXBkX2NvbmZpZ19nZXRfcmFkaXVzX2F0dHIoaGFwZC0+Y29uZi0+cmFkaXVzX2F1dGhfcmVxX2F0dHIsCisJCQkJCSAgICBSQURJVVNfQVRUUl9OQVNfUE9SVCkgJiYKKwkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9OQVNfUE9SVCwgc3RhLT5haWQpKSB7CiAJCXByaW50ZigiQ291bGQgbm90IGFkZCBOQVMtUG9ydFxuIik7CiAJCWdvdG8gZmFpbDsKIAl9CkBAIC00NzQsNyArNDgzLDkgQEAKIAlvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCBSQURJVVNfODAyXzFYX0FERFJfRk9STUFUICI6JXMiLAogCQkgICAgTUFDMlNUUihoYXBkLT5vd25fYWRkciksIGhhcGQtPmNvbmYtPnNzaWQuc3NpZCk7CiAJYnVmW3NpemVvZihidWYpIC0gMV0gPSAnXDAnOwotCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX0NBTExFRF9TVEFUSU9OX0lELAorCWlmICghaG9zdGFwZF9jb25maWdfZ2V0X3JhZGl1c19hdHRyKGhhcGQtPmNvbmYtPnJhZGl1c19hdXRoX3JlcV9hdHRyLAorCQkJCQkgICAgUkFESVVTX0FUVFJfQ0FMTEVEX1NUQVRJT05fSUQpICYmCisJICAgICFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywgUkFESVVTX0FUVFJfQ0FMTEVEX1NUQVRJT05fSUQsCiAJCQkJICh1OCAqKSBidWYsIG9zX3N0cmxlbihidWYpKSkgewogCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgQ2FsbGVkLVN0YXRpb24tSWRcbiIpOwogCQlnb3RvIGZhaWw7CkBAIC00OTIsMTIgKzUwMywxNiBAQAogCS8qIFRPRE86IHNob3VsZCBwcm9iYWJseSBjaGVjayBNVFUgZnJvbSBkcml2ZXIgY29uZmlnOyAyMzA0IGlzIG1heCBmb3IKIAkgKiBJRUVFIDgwMi4xMSwgYnV0IHVzZSAxNDAwIHRvIGF2b2lkIHByb2JsZW1zIHdpdGggdG9vIGxhcmdlIHBhY2tldHMKIAkgKi8KLQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9GUkFNRURfTVRVLCAxNDAwKSkgeworCWlmICghaG9zdGFwZF9jb25maWdfZ2V0X3JhZGl1c19hdHRyKGhhcGQtPmNvbmYtPnJhZGl1c19hdXRoX3JlcV9hdHRyLAorCQkJCQkgICAgUkFESVVTX0FUVFJfRlJBTUVEX01UVSkgJiYKKwkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9GUkFNRURfTVRVLCAxNDAwKSkgewogCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgRnJhbWVkLU1UVVxuIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAoIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9OQVNfUE9SVF9UWVBFLAorCWlmICghaG9zdGFwZF9jb25maWdfZ2V0X3JhZGl1c19hdHRyKGhhcGQtPmNvbmYtPnJhZGl1c19hdXRoX3JlcV9hdHRyLAorCQkJCQkgICAgUkFESVVTX0FUVFJfTkFTX1BPUlRfVFlQRSkgJiYKKwkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIobXNnLCBSQURJVVNfQVRUUl9OQVNfUE9SVF9UWVBFLAogCQkJCSAgICAgICBSQURJVVNfTkFTX1BPUlRfVFlQRV9JRUVFXzgwMl8xMSkpIHsKIAkJcHJpbnRmKCJDb3VsZCBub3QgYWRkIE5BUy1Qb3J0LVR5cGVcbiIpOwogCQlnb3RvIGZhaWw7CkBAIC01MTMsNyArNTI4LDkgQEAKIAkJCSAgICByYWRpdXNfbW9kZV90eHQoaGFwZCkpOwogCQlidWZbc2l6ZW9mKGJ1ZikgLSAxXSA9ICdcMCc7CiAJfQotCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIFJBRElVU19BVFRSX0NPTk5FQ1RfSU5GTywKKwlpZiAoIWhvc3RhcGRfY29uZmlnX2dldF9yYWRpdXNfYXR0cihoYXBkLT5jb25mLT5yYWRpdXNfYXV0aF9yZXFfYXR0ciwKKwkJCQkJICAgIFJBRElVU19BVFRSX0NPTk5FQ1RfSU5GTykgJiYKKwkgICAgIXJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9DT05ORUNUX0lORk8sCiAJCQkJICh1OCAqKSBidWYsIG9zX3N0cmxlbihidWYpKSkgewogCQlwcmludGYoIkNvdWxkIG5vdCBhZGQgQ29ubmVjdC1JbmZvXG4iKTsKIAkJZ290byBmYWlsOwpAQCAtNTQxLDYgKzU1OCwzNiBAQAogCQl9CiAJfQogCisJaWYgKGhhcGQtPmNvbmYtPnJhZGl1c19yZXF1ZXN0X2N1aSkgeworCQljb25zdCB1OCAqY3VpOworCQlzaXplX3QgY3VpX2xlbjsKKwkJLyogQWRkIHByZXZpb3VzbHkgbGVhcm5lZCBDVUkgb3IgbnVsIENVSSB0byByZXF1ZXN0IENVSSAqLworCQlpZiAoc20tPnJhZGl1c19jdWkpIHsKKwkJCWN1aSA9IHdwYWJ1Zl9oZWFkKHNtLT5yYWRpdXNfY3VpKTsKKwkJCWN1aV9sZW4gPSB3cGFidWZfbGVuKHNtLT5yYWRpdXNfY3VpKTsKKwkJfSBlbHNlIHsKKwkJCWN1aSA9IChjb25zdCB1OCAqKSAiXDAiOworCQkJY3VpX2xlbiA9IDE7CisJCX0KKwkJaWYgKCFyYWRpdXNfbXNnX2FkZF9hdHRyKG1zZywKKwkJCQkJIFJBRElVU19BVFRSX0NIQVJHRUFCTEVfVVNFUl9JREVOVElUWSwKKwkJCQkJIGN1aSwgY3VpX2xlbikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiQ291bGQgbm90IGFkZCBDVUkiKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCX0KKworCWZvciAoYXR0ciA9IGhhcGQtPmNvbmYtPnJhZGl1c19hdXRoX3JlcV9hdHRyOyBhdHRyOyBhdHRyID0gYXR0ci0+bmV4dCkKKwl7CisJCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cihtc2csIGF0dHItPnR5cGUsCisJCQkJCSB3cGFidWZfaGVhZChhdHRyLT52YWwpLAorCQkJCQkgd3BhYnVmX2xlbihhdHRyLT52YWwpKSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDb3VsZCBub3QgYWRkIFJBRElVUyAiCisJCQkJICAgImF0dHJpYnV0ZSIpOworCQkJZ290byBmYWlsOworCQl9CisJfQorCiAJaWYgKHJhZGl1c19jbGllbnRfc2VuZChoYXBkLT5yYWRpdXMsIG1zZywgUkFESVVTX0FVVEgsIHN0YS0+YWRkcikgPCAwKQogCQlnb3RvIGZhaWw7CiAKQEAgLTg2MSwxMiArOTA4LDIyIEBACiAJaWYgKCFmb3JjZV8xeCAmJiAhaGFwZC0+Y29uZi0+aWVlZTgwMl8xeCkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIklFRUUgODAyLjFYOiBJZ25vcmUgU1RBIC0gIgogCQkJICAgIjgwMi4xWCBub3QgZW5hYmxlZCBvciBmb3JjZWQgZm9yIFdQUyIpOworCQkvKgorCQkgKiBDbGVhciBhbnkgcG9zc2libGUgRUFQT0wgYXV0aGVudGljYXRvciBzdGF0ZSB0byBzdXBwb3J0CisJCSAqIHJlYXNzb2NpYXRpb24gY2hhbmdlIGZyb20gV1BTIHRvIFBTSy4KKwkJICovCisJCWllZWU4MDJfMXhfZnJlZV9zdGF0aW9uKHN0YSk7CiAJCXJldHVybjsKIAl9CiAKIAlrZXlfbWdtdCA9IHdwYV9hdXRoX3N0YV9rZXlfbWdtdChzdGEtPndwYV9zbSk7CiAJaWYgKGtleV9tZ210ICE9IC0xICYmIHdwYV9rZXlfbWdtdF93cGFfcHNrKGtleV9tZ210KSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIklFRUUgODAyLjFYOiBJZ25vcmUgU1RBIC0gdXNpbmcgUFNLIik7CisJCS8qCisJCSAqIENsZWFyIGFueSBwb3NzaWJsZSBFQVBPTCBhdXRoZW50aWNhdG9yIHN0YXRlIHRvIHN1cHBvcnQKKwkJICogcmVhc3NvY2lhdGlvbiBjaGFuZ2UgZnJvbSBXUEEtRUFQIHRvIFBTSy4KKwkJICovCisJCWllZWU4MDJfMXhfZnJlZV9zdGF0aW9uKHN0YSk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTk2OCw2ICsxMDI1LDcgQEAKICNpZm5kZWYgQ09ORklHX05PX1JBRElVUwogCXJhZGl1c19tc2dfZnJlZShzbS0+bGFzdF9yZWN2X3JhZGl1cyk7CiAJcmFkaXVzX2ZyZWVfY2xhc3MoJnNtLT5yYWRpdXNfY2xhc3MpOworCXdwYWJ1Zl9mcmVlKHNtLT5yYWRpdXNfY3VpKTsKICNlbmRpZiAvKiBDT05GSUdfTk9fUkFESVVTICovCiAKIAlvc19mcmVlKHNtLT5pZGVudGl0eSk7CkBAIC0xMTg5LDYgKzEyNDcsMzIgQEAKIH0KIAogCisvKiBVcGRhdGUgQ1VJIGJhc2VkIG9uIENoYXJnZWFibGUtVXNlci1JZGVudGl0eSBhdHRyaWJ1dGUgaW4gQWNjZXNzLUFjY2VwdCAqLworc3RhdGljIHZvaWQgaWVlZTgwMl8xeF91cGRhdGVfc3RhX2N1aShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCSAgICAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLAorCQkJCSAgICAgIHN0cnVjdCByYWRpdXNfbXNnICptc2cpCit7CisJc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtID0gc3RhLT5lYXBvbF9zbTsKKwlzdHJ1Y3Qgd3BhYnVmICpjdWk7CisJdTggKmJ1ZjsKKwlzaXplX3QgbGVuOworCisJaWYgKHNtID09IE5VTEwpCisJCXJldHVybjsKKworCWlmIChyYWRpdXNfbXNnX2dldF9hdHRyX3B0cihtc2csIFJBRElVU19BVFRSX0NIQVJHRUFCTEVfVVNFUl9JREVOVElUWSwKKwkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPCAwKQorCQlyZXR1cm47CisKKwljdWkgPSB3cGFidWZfYWxsb2NfY29weShidWYsIGxlbik7CisJaWYgKGN1aSA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3cGFidWZfZnJlZShzbS0+cmFkaXVzX2N1aSk7CisJc20tPnJhZGl1c19jdWkgPSBjdWk7Cit9CisKKwogc3RydWN0IHN0YV9pZF9zZWFyY2ggewogCXU4IGlkZW50aWZpZXI7CiAJc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtOwpAQCAtMTM0OCw2ICsxNDMyLDcgQEAKIAkJCQkgICAgc2hhcmVkX3NlY3JldF9sZW4pOwogCQlpZWVlODAyXzF4X3N0b3JlX3JhZGl1c19jbGFzcyhoYXBkLCBzdGEsIG1zZyk7CiAJCWllZWU4MDJfMXhfdXBkYXRlX3N0YV9pZGVudGl0eShoYXBkLCBzdGEsIG1zZyk7CisJCWllZWU4MDJfMXhfdXBkYXRlX3N0YV9jdWkoaGFwZCwgc3RhLCBtc2cpOwogCQlpZiAoc20tPmVhcF9pZi0+ZWFwS2V5QXZhaWxhYmxlICYmCiAJCSAgICB3cGFfYXV0aF9wbWtzYV9hZGQoc3RhLT53cGFfc20sIHNtLT5lYXBvbF9rZXlfY3J5cHQsCiAJCQkJICAgICAgIHNlc3Npb25fdGltZW91dF9zZXQgPwpAQCAtMTg2NSw2ICsxOTUwLDE0IEBACiB9CiAKIAorc3RydWN0IHdwYWJ1ZiAqIGllZWU4MDJfMXhfZ2V0X3JhZGl1c19jdWkoc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtKQoreworCWlmIChzbSA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gc20tPnJhZGl1c19jdWk7Cit9CisKKwogY29uc3QgdTggKiBpZWVlODAyXzF4X2dldF9rZXkoc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtLCBzaXplX3QgKmxlbikKIHsKIAkqbGVuID0gMDsKZGlmZiAtLWdpdCBhL3NyYy9hcC9pZWVlODAyXzF4LmggYi9zcmMvYXAvaWVlZTgwMl8xeC5oCmluZGV4IDU4ZjYwODQuLmY5YjA1Y2EgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9pZWVlODAyXzF4LmgKKysrIGIvc3JjL2FwL2llZWU4MDJfMXguaApAQCAtNjcsNiArNjcsNyBAQAogdTggKiBpZWVlODAyXzF4X2dldF9pZGVudGl0eShzdHJ1Y3QgZWFwb2xfc3RhdGVfbWFjaGluZSAqc20sIHNpemVfdCAqbGVuKTsKIHU4ICogaWVlZTgwMl8xeF9nZXRfcmFkaXVzX2NsYXNzKHN0cnVjdCBlYXBvbF9zdGF0ZV9tYWNoaW5lICpzbSwgc2l6ZV90ICpsZW4sCiAJCQkJIGludCBpZHgpOworc3RydWN0IHdwYWJ1ZiAqIGllZWU4MDJfMXhfZ2V0X3JhZGl1c19jdWkoc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtKTsKIGNvbnN0IHU4ICogaWVlZTgwMl8xeF9nZXRfa2V5KHN0cnVjdCBlYXBvbF9zdGF0ZV9tYWNoaW5lICpzbSwgc2l6ZV90ICpsZW4pOwogdm9pZCBpZWVlODAyXzF4X25vdGlmeV9wb3J0X2VuYWJsZWQoc3RydWN0IGVhcG9sX3N0YXRlX21hY2hpbmUgKnNtLAogCQkJCSAgICBpbnQgZW5hYmxlZCk7CmRpZmYgLS1naXQgYS9zcmMvYXAvcG1rc2FfY2FjaGVfYXV0aC5jIGIvc3JjL2FwL3Bta3NhX2NhY2hlX2F1dGguYwppbmRleCA5ZWI0ODQwLi5iYTJjMDMzIDEwMDY0NAotLS0gYS9zcmMvYXAvcG1rc2FfY2FjaGVfYXV0aC5jCisrKyBiL3NyYy9hcC9wbWtzYV9jYWNoZV9hdXRoLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAtIFBNS1NBIGNhY2hlIGZvciBJRUVFIDgwMi4xMWkgUlNOCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAwOCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA4LCAyMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC00MCw2ICs0MCw3IEBACiAJaWYgKGVudHJ5ID09IE5VTEwpCiAJCXJldHVybjsKIAlvc19mcmVlKGVudHJ5LT5pZGVudGl0eSk7CisJd3BhYnVmX2ZyZWUoZW50cnktPmN1aSk7CiAjaWZuZGVmIENPTkZJR19OT19SQURJVVMKIAlyYWRpdXNfZnJlZV9jbGFzcygmZW50cnktPnJhZGl1c19jbGFzcyk7CiAjZW5kaWYgLyogQ09ORklHX05PX1JBRElVUyAqLwpAQCAtMTM2LDYgKzEzNyw5IEBACiAJCX0KIAl9CiAKKwlpZiAoZWFwb2wtPnJhZGl1c19jdWkpCisJCWVudHJ5LT5jdWkgPSB3cGFidWZfZHVwKGVhcG9sLT5yYWRpdXNfY3VpKTsKKwogI2lmbmRlZiBDT05GSUdfTk9fUkFESVVTCiAJcmFkaXVzX2NvcHlfY2xhc3MoJmVudHJ5LT5yYWRpdXNfY2xhc3MsICZlYXBvbC0+cmFkaXVzX2NsYXNzKTsKICNlbmRpZiAvKiBDT05GSUdfTk9fUkFESVVTICovCkBAIC0xNjMsNiArMTY3LDExIEBACiAJCQkJICBlYXBvbC0+aWRlbnRpdHksIGVhcG9sLT5pZGVudGl0eV9sZW4pOwogCX0KIAorCWlmIChlbnRyeS0+Y3VpKSB7CisJCXdwYWJ1Zl9mcmVlKGVhcG9sLT5yYWRpdXNfY3VpKTsKKwkJZWFwb2wtPnJhZGl1c19jdWkgPSB3cGFidWZfZHVwKGVudHJ5LT5jdWkpOworCX0KKwogI2lmbmRlZiBDT05GSUdfTk9fUkFESVVTCiAJcmFkaXVzX2ZyZWVfY2xhc3MoJmVhcG9sLT5yYWRpdXNfY2xhc3MpOwogCXJhZGl1c19jb3B5X2NsYXNzKCZlYXBvbC0+cmFkaXVzX2NsYXNzLCAmZW50cnktPnJhZGl1c19jbGFzcyk7CkBAIC0yOTksNiArMzA4LDggQEAKIAkJCQkgIG9sZF9lbnRyeS0+aWRlbnRpdHlfbGVuKTsKIAkJfQogCX0KKwlpZiAob2xkX2VudHJ5LT5jdWkpCisJCWVudHJ5LT5jdWkgPSB3cGFidWZfZHVwKG9sZF9lbnRyeS0+Y3VpKTsKICNpZm5kZWYgQ09ORklHX05PX1JBRElVUwogCXJhZGl1c19jb3B5X2NsYXNzKCZlbnRyeS0+cmFkaXVzX2NsYXNzLCAmb2xkX2VudHJ5LT5yYWRpdXNfY2xhc3MpOwogI2VuZGlmIC8qIENPTkZJR19OT19SQURJVVMgKi8KZGlmZiAtLWdpdCBhL3NyYy9hcC9wbWtzYV9jYWNoZV9hdXRoLmggYi9zcmMvYXAvcG1rc2FfY2FjaGVfYXV0aC5oCmluZGV4IDc0YjczYzQuLmQ0NzNmM2YgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9wbWtzYV9jYWNoZV9hdXRoLmgKKysrIGIvc3JjL2FwL3Bta3NhX2NhY2hlX2F1dGguaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC0gUE1LU0EgY2FjaGUgZm9yIElFRUUgODAyLjExaSBSU04KLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA4LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDgsIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTI1LDYgKzI1LDcgQEAKIAogCXU4ICppZGVudGl0eTsKIAlzaXplX3QgaWRlbnRpdHlfbGVuOworCXN0cnVjdCB3cGFidWYgKmN1aTsKIAlzdHJ1Y3QgcmFkaXVzX2NsYXNzX2RhdGEgcmFkaXVzX2NsYXNzOwogCXU4IGVhcF90eXBlX2F1dGhzcnY7CiAJaW50IHZsYW5faWQ7CmRpZmYgLS1naXQgYS9zcmMvYXAvc3RhX2luZm8uYyBiL3NyYy9hcC9zdGFfaW5mby5jCmluZGV4IGFmYWJkYWEuLjk1YjcwMWMgMTAwNjQ0Ci0tLSBhL3NyYy9hcC9zdGFfaW5mby5jCisrKyBiL3NyYy9hcC9zdGFfaW5mby5jCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5jbHVkZSAidmxhbl9pbml0LmgiCiAjaW5jbHVkZSAicDJwX2hvc3RhcGQuaCIKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCisjaW5jbHVkZSAiZ2FzX3NlcnYuaCIKICNpbmNsdWRlICJzdGFfaW5mby5oIgogCiBzdGF0aWMgdm9pZCBhcF9zdGFfcmVtb3ZlX2luX290aGVyX2JzcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLApAQCAtMTk0LDYgKzE5NSw4IEBACiAJaWYgKHNldF9iZWFjb24pCiAJCWllZWU4MDJfMTFfc2V0X2JlYWNvbnMoaGFwZC0+aWZhY2UpOwogCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogY2FuY2VsIGFwX2hhbmRsZV90aW1lciBmb3IgIiBNQUNTVFIsCisJCSAgIF9fZnVuY19fLCBNQUMyU1RSKHN0YS0+YWRkcikpOwogCWVsb29wX2NhbmNlbF90aW1lb3V0KGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dChhcF9oYW5kbGVfc2Vzc2lvbl90aW1lciwgaGFwZCwgc3RhKTsKIAllbG9vcF9jYW5jZWxfdGltZW91dChhcF9zdGFfZGVhdXRoX2NiX3RpbWVvdXQsIGhhcGQsIHN0YSk7CkBAIC0yMTgsNiArMjIxLDE1IEBACiAJcDJwX2dyb3VwX25vdGlmX2Rpc2Fzc29jKGhhcGQtPnAycF9ncm91cCwgc3RhLT5hZGRyKTsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKKyNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCisJaWYgKHN0YS0+Z2FzX2RpYWxvZykgeworCQlpbnQgaTsKKwkJZm9yIChpID0gMDsgaSA8IEdBU19ESUFMT0dfTUFYOyBpKyspCisJCQlnYXNfc2Vydl9kaWFsb2dfY2xlYXIoJnN0YS0+Z2FzX2RpYWxvZ1tpXSk7CisJCW9zX2ZyZWUoc3RhLT5nYXNfZGlhbG9nKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworCiAJd3BhYnVmX2ZyZWUoc3RhLT53cHNfaWUpOwogCXdwYWJ1Zl9mcmVlKHN0YS0+cDJwX2llKTsKIApAQCAtMjYyLDYgKzI3NCw5IEBACiAJc3RydWN0IHN0YV9pbmZvICpzdGEgPSB0aW1lb3V0X2N0eDsKIAl1bnNpZ25lZCBsb25nIG5leHRfdGltZSA9IDA7CiAKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiAiIE1BQ1NUUiAiIGZsYWdzPTB4JXggdGltZW91dF9uZXh0PSVkIiwKKwkJICAgX19mdW5jX18sIE1BQzJTVFIoc3RhLT5hZGRyKSwgc3RhLT5mbGFncywKKwkJICAgc3RhLT50aW1lb3V0X25leHQpOwogCWlmIChzdGEtPnRpbWVvdXRfbmV4dCA9PSBTVEFfUkVNT1ZFKSB7CiAJCWhvc3RhcGRfbG9nZ2VyKGhhcGQsIHN0YS0+YWRkciwgSE9TVEFQRF9NT0RVTEVfSUVFRTgwMjExLAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfSU5GTywgImRlYXV0aGVudGljYXRlZCBkdWUgdG8gIgpAQCAtMjc0LDYgKzI4OSwxMiBAQAogCSAgICAoc3RhLT50aW1lb3V0X25leHQgPT0gU1RBX05VTExGVU5DIHx8CiAJICAgICBzdGEtPnRpbWVvdXRfbmV4dCA9PSBTVEFfRElTQVNTT0MpKSB7CiAJCWludCBpbmFjdGl2ZV9zZWM7CisJCS8qCisJCSAqIEFkZCByYW5kb20gdmFsdWUgdG8gdGltZW91dCBzbyB0aGF0IHdlIGRvbid0IGVuZCB1cCBib3VuY2luZworCQkgKiBhbGwgc3RhdGlvbnMgYXQgdGhlIHNhbWUgdGltZSBpZiB3ZSBoYXZlIGxvdHMgb2YgYXNzb2NpYXRlZAorCQkgKiBzdGF0aW9ucyB0aGF0IGFyZSBpZGxlIChidXQga2VlcCByZS1hc3NvY2lhdGluZykuCisJCSAqLworCQlpbnQgZnV6eiA9IG9zX3JhbmRvbSgpICUgMjA7CiAJCWluYWN0aXZlX3NlYyA9IGhvc3RhcGRfZHJ2X2dldF9pbmFjdF9zZWMoaGFwZCwgc3RhLT5hZGRyKTsKIAkJaWYgKGluYWN0aXZlX3NlYyA9PSAtMSkgewogCQkJd3BhX21zZyhoYXBkLT5tc2dfY3R4LCBNU0dfREVCVUcsCkBAIC0yODUsNyArMzA2LDcgQEAKIAkJCSAqIEFueXdheSwgdHJ5IGFnYWluIGFmdGVyIHRoZSBuZXh0IGluYWN0aXZpdHkgdGltZW91dCwKIAkJCSAqIGJ1dCBkbyBub3QgZGlzY29ubmVjdCB0aGUgc3RhdGlvbiBub3cuCiAJCQkgKi8KLQkJCW5leHRfdGltZSA9IGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5OworCQkJbmV4dF90aW1lID0gaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHkgKyBmdXp6OwogCQl9IGVsc2UgaWYgKGluYWN0aXZlX3NlYyA8IGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5ICYmCiAJCQkgICBzdGEtPmZsYWdzICYgV0xBTl9TVEFfQVNTT0MpIHsKIAkJCS8qIHN0YXRpb24gYWN0aXZpdHkgZGV0ZWN0ZWQ7IHJlc2V0IHRpbWVvdXQgc3RhdGUgKi8KQEAgLTI5Myw3ICszMTQsNyBAQAogCQkJCSJTdGF0aW9uICIgTUFDU1RSICIgaGFzIGJlZW4gYWN0aXZlICVpcyBhZ28iLAogCQkJCU1BQzJTVFIoc3RhLT5hZGRyKSwgaW5hY3RpdmVfc2VjKTsKIAkJCXN0YS0+dGltZW91dF9uZXh0ID0gU1RBX05VTExGVU5DOwotCQkJbmV4dF90aW1lID0gaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHkgLQorCQkJbmV4dF90aW1lID0gaGFwZC0+Y29uZi0+YXBfbWF4X2luYWN0aXZpdHkgKyBmdXp6IC0KIAkJCQlpbmFjdGl2ZV9zZWM7CiAJCX0gZWxzZSB7CiAJCQl3cGFfbXNnKGhhcGQtPm1zZ19jdHgsIE1TR19ERUJVRywKQEAgLTMyMCw2ICszNDEsOSBAQAogCX0KIAogCWlmIChuZXh0X3RpbWUpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogcmVnaXN0ZXIgYXBfaGFuZGxlX3RpbWVyIHRpbWVvdXQgIgorCQkJICAgImZvciAiIE1BQ1NUUiAiICglbHUgc2Vjb25kcykiLAorCQkJICAgX19mdW5jX18sIE1BQzJTVFIoc3RhLT5hZGRyKSwgbmV4dF90aW1lKTsKIAkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChuZXh0X3RpbWUsIDAsIGFwX2hhbmRsZV90aW1lciwgaGFwZCwKIAkJCQkgICAgICAgc3RhKTsKIAkJcmV0dXJuOwpAQCAtMzUzLDYgKzM3Nyw5IEBACiAJc3dpdGNoIChzdGEtPnRpbWVvdXRfbmV4dCkgewogCWNhc2UgU1RBX05VTExGVU5DOgogCQlzdGEtPnRpbWVvdXRfbmV4dCA9IFNUQV9ESVNBU1NPQzsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogcmVnaXN0ZXIgYXBfaGFuZGxlX3RpbWVyIHRpbWVvdXQgIgorCQkJICAgImZvciAiIE1BQ1NUUiAiICglZCBzZWNvbmRzIC0gQVBfRElTQVNTT0NfREVMQVkpIiwKKwkJCSAgIF9fZnVuY19fLCBNQUMyU1RSKHN0YS0+YWRkciksIEFQX0RJU0FTU09DX0RFTEFZKTsKIAkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChBUF9ESVNBU1NPQ19ERUxBWSwgMCwgYXBfaGFuZGxlX3RpbWVyLAogCQkJCSAgICAgICBoYXBkLCBzdGEpOwogCQlicmVhazsKQEAgLTM2OSw2ICszOTYsOSBAQAogCQkJICAgICAgIEhPU1RBUERfTEVWRUxfSU5GTywgImRpc2Fzc29jaWF0ZWQgZHVlIHRvICIKIAkJCSAgICAgICAiaW5hY3Rpdml0eSIpOwogCQlzdGEtPnRpbWVvdXRfbmV4dCA9IFNUQV9ERUFVVEg7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IHJlZ2lzdGVyIGFwX2hhbmRsZV90aW1lciB0aW1lb3V0ICIKKwkJCSAgICJmb3IgIiBNQUNTVFIgIiAoJWQgc2Vjb25kcyAtIEFQX0RFQVVUSF9ERUxBWSkiLAorCQkJICAgX19mdW5jX18sIE1BQzJTVFIoc3RhLT5hZGRyKSwgQVBfREVBVVRIX0RFTEFZKTsKIAkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChBUF9ERUFVVEhfREVMQVksIDAsIGFwX2hhbmRsZV90aW1lciwKIAkJCQkgICAgICAgaGFwZCwgc3RhKTsKIAkJbWxtZV9kaXNhc3NvY2lhdGVfaW5kaWNhdGlvbigKQEAgLTM5Nyw4ICs0MjcsMTQgQEAKIAlzdHJ1Y3Qgc3RhX2luZm8gKnN0YSA9IHRpbWVvdXRfY3R4OwogCXU4IGFkZHJbRVRIX0FMRU5dOwogCi0JaWYgKCEoc3RhLT5mbGFncyAmIFdMQU5fU1RBX0FVVEgpKQorCWlmICghKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9BVVRIKSkgeworCQlpZiAoc3RhLT5mbGFncyAmIFdMQU5fU1RBX0dBUykgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJHQVM6IFJlbW92ZSB0ZW1wb3JhcnkgU1RBICIKKwkJCQkgICAiZW50cnkgIiBNQUNTVFIsIE1BQzJTVFIoc3RhLT5hZGRyKSk7CisJCQlhcF9mcmVlX3N0YShoYXBkLCBzdGEpOworCQl9CiAJCXJldHVybjsKKwl9CiAKIAltbG1lX2RlYXV0aGVudGljYXRlX2luZGljYXRpb24oaGFwZCwgc3RhLAogCQkJCSAgICAgICBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKQEAgLTQ1NSw2ICs0OTEsMTAgQEAKIAlzdGEtPmFjY3RfaW50ZXJpbV9pbnRlcnZhbCA9IGhhcGQtPmNvbmYtPmFjY3RfaW50ZXJpbV9pbnRlcnZhbDsKIAogCS8qIGluaXRpYWxpemUgU1RBIGluZm8gZGF0YSAqLworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IHJlZ2lzdGVyIGFwX2hhbmRsZV90aW1lciB0aW1lb3V0ICIKKwkJICAgImZvciAiIE1BQ1NUUiAiICglZCBzZWNvbmRzIC0gYXBfbWF4X2luYWN0aXZpdHkpIiwKKwkJICAgX19mdW5jX18sIE1BQzJTVFIoYWRkciksCisJCSAgIGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5KTsKIAllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KGhhcGQtPmNvbmYtPmFwX21heF9pbmFjdGl2aXR5LCAwLAogCQkJICAgICAgIGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKIAlvc19tZW1jcHkoc3RhLT5hZGRyLCBhZGRyLCBFVEhfQUxFTik7CkBAIC01MjgsNiArNTY4LDExIEBACiAJc3RhLT5mbGFncyAmPSB+V0xBTl9TVEFfQVNTT0M7CiAJYXBfc3RhX3NldF9hdXRob3JpemVkKGhhcGQsIHN0YSwgMCk7CiAJc3RhLT50aW1lb3V0X25leHQgPSBTVEFfREVBVVRIOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IHJlc2NoZWR1bGUgYXBfaGFuZGxlX3RpbWVyIHRpbWVvdXQgIgorCQkgICAiZm9yICIgTUFDU1RSICIgKCVkIHNlY29uZHMgLSAiCisJCSAgICJBUF9NQVhfSU5BQ1RJVklUWV9BRlRFUl9ESVNBU1NPQykiLAorCQkgICBfX2Z1bmNfXywgTUFDMlNUUihzdGEtPmFkZHIpLAorCQkgICBBUF9NQVhfSU5BQ1RJVklUWV9BRlRFUl9ESVNBU1NPQyk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoQVBfTUFYX0lOQUNUSVZJVFlfQUZURVJfRElTQVNTT0MsIDAsCiAJCQkgICAgICAgYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOwpAQCAtNTYxLDYgKzYwNiwxMSBAQAogCXN0YS0+ZmxhZ3MgJj0gfihXTEFOX1NUQV9BVVRIIHwgV0xBTl9TVEFfQVNTT0MpOwogCWFwX3N0YV9zZXRfYXV0aG9yaXplZChoYXBkLCBzdGEsIDApOwogCXN0YS0+dGltZW91dF9uZXh0ID0gU1RBX1JFTU9WRTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiByZXNjaGVkdWxlIGFwX2hhbmRsZV90aW1lciB0aW1lb3V0ICIKKwkJICAgImZvciAiIE1BQ1NUUiAiICglZCBzZWNvbmRzIC0gIgorCQkgICAiQVBfTUFYX0lOQUNUSVZJVFlfQUZURVJfREVBVVRIKSIsCisJCSAgIF9fZnVuY19fLCBNQUMyU1RSKHN0YS0+YWRkciksCisJCSAgIEFQX01BWF9JTkFDVElWSVRZX0FGVEVSX0RFQVVUSCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoQVBfTUFYX0lOQUNUSVZJVFlfQUZURVJfREVBVVRILCAwLAogCQkJICAgICAgIGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKQEAgLTU3Niw2ICs2MjYsMjMgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX1dQUworaW50IGFwX3N0YV93cHNfY2FuY2VsKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCSAgICAgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLCB2b2lkICpjdHgpCit7CisJaWYgKHN0YSAmJiAoc3RhLT5mbGFncyAmIFdMQU5fU1RBX1dQUykpIHsKKwkJYXBfc3RhX2RlYXV0aGVudGljYXRlKGhhcGQsIHN0YSwKKwkJCQkgICAgICBXTEFOX1JFQVNPTl9QUkVWX0FVVEhfTk9UX1ZBTElEKTsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6ICVzOiBEZWF1dGggc3RhPSIgTUFDU1RSLAorCQkJICAgX19mdW5jX18sIE1BQzJTVFIoc3RhLT5hZGRyKSk7CisJCXJldHVybiAxOworCX0KKworCXJldHVybiAwOworfQorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKworCiBpbnQgYXBfc3RhX2JpbmRfdmxhbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJICAgICBpbnQgb2xkX3ZsYW5pZCkKIHsKQEAgLTc3OCwxMSArODQ1LDIwIEBACiAJCQkgICBpbnQgYXV0aG9yaXplZCkKIHsKIAljb25zdCB1OCAqZGV2X2FkZHIgPSBOVUxMOworI2lmZGVmIENPTkZJR19QMlAKKwl1OCBhZGRyW0VUSF9BTEVOXTsKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAlpZiAoISFhdXRob3JpemVkID09ICEhKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9BVVRIT1JJWkVEKSkKIAkJcmV0dXJuOwogCiAjaWZkZWYgQ09ORklHX1AyUAotCWRldl9hZGRyID0gcDJwX2dyb3VwX2dldF9kZXZfYWRkcihoYXBkLT5wMnBfZ3JvdXAsIHN0YS0+YWRkcik7CisJaWYgKGhhcGQtPnAycF9ncm91cCA9PSBOVUxMKSB7CisJCWlmIChzdGEtPnAycF9pZSAhPSBOVUxMICYmCisJCSAgICBwMnBfcGFyc2VfZGV2X2FkZHJfaW5fcDJwX2llKHN0YS0+cDJwX2llLCBhZGRyKSA9PSAwKQorCQkJZGV2X2FkZHIgPSBhZGRyOworCX0gZWxzZQorCQlkZXZfYWRkciA9IHAycF9ncm91cF9nZXRfZGV2X2FkZHIoaGFwZC0+cDJwX2dyb3VwLCBzdGEtPmFkZHIpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAogCWlmIChhdXRob3JpemVkKSB7CkBAIC04NDgsNiArOTI0LDExIEBACiAJd3BhX2F1dGhfc21fZXZlbnQoc3RhLT53cGFfc20sIFdQQV9ERUFVVEgpOwogCWllZWU4MDJfMXhfbm90aWZ5X3BvcnRfZW5hYmxlZChzdGEtPmVhcG9sX3NtLCAwKTsKIAlzdGEtPmZsYWdzICY9IH4oV0xBTl9TVEFfQVVUSCB8IFdMQU5fU1RBX0FTU09DKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiByZXNjaGVkdWxlIGFwX2hhbmRsZV90aW1lciB0aW1lb3V0ICIKKwkJICAgImZvciAiIE1BQ1NUUiAiICglZCBzZWNvbmRzIC0gIgorCQkgICAiQVBfTUFYX0lOQUNUSVZJVFlfQUZURVJfREVBVVRIKSIsCisJCSAgIF9fZnVuY19fLCBNQUMyU1RSKHN0YS0+YWRkciksCisJCSAgIEFQX01BWF9JTkFDVElWSVRZX0FGVEVSX0RFQVVUSCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoYXBfaGFuZGxlX3RpbWVyLCBoYXBkLCBzdGEpOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoQVBfTUFYX0lOQUNUSVZJVFlfQUZURVJfREVBVVRILCAwLAogCQkJICAgICAgIGFwX2hhbmRsZV90aW1lciwgaGFwZCwgc3RhKTsKZGlmZiAtLWdpdCBhL3NyYy9hcC9zdGFfaW5mby5oIGIvc3JjL2FwL3N0YV9pbmZvLmgKaW5kZXggNjBiM2E3Yi4uY2VmNDI4ZCAxMDA2NDQKLS0tIGEvc3JjL2FwL3N0YV9pbmZvLmgKKysrIGIvc3JjL2FwL3N0YV9pbmZvLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNkZWZpbmUgV0xBTl9TVEFfV0RTIEJJVCgxNCkKICNkZWZpbmUgV0xBTl9TVEFfQVNTT0NfUkVRX09LIEJJVCgxNSkKICNkZWZpbmUgV0xBTl9TVEFfV1BTMiBCSVQoMTYpCisjZGVmaW5lIFdMQU5fU1RBX0dBUyBCSVQoMTcpCiAjZGVmaW5lIFdMQU5fU1RBX1BFTkRJTkdfRElTQVNTT0NfQ0IgQklUKDI5KQogI2RlZmluZSBXTEFOX1NUQV9QRU5ESU5HX0RFQVVUSF9DQiBCSVQoMzApCiAjZGVmaW5lIFdMQU5fU1RBX05PTkVSUCBCSVQoMzEpCkBAIC0xMDcsNiArMTA4LDEyIEBACiAJc3RydWN0IG9zX3RpbWUgc2FfcXVlcnlfc3RhcnQ7CiAjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVcgKi8KIAorI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKKyNkZWZpbmUgR0FTX0RJQUxPR19NQVggOCAvKiBNYXggY29uY3VycmVudCBkaWFsb2cgbnVtYmVyICovCisJc3RydWN0IGdhc19kaWFsb2dfaW5mbyAqZ2FzX2RpYWxvZzsKKwl1OCBnYXNfZGlhbG9nX25leHQ7CisjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworCiAJc3RydWN0IHdwYWJ1ZiAqd3BzX2llOyAvKiBXUFMgSUUgZnJvbSAoUmUpQXNzb2NpYXRpb24gUmVxdWVzdCAqLwogCXN0cnVjdCB3cGFidWYgKnAycF9pZTsgLyogUDJQIElFIGZyb20gKFJlKUFzc29jaWF0aW9uIFJlcXVlc3QgKi8KIH07CkBAIC0xMzcsNyArMTQ0LDYgQEAKIHN0cnVjdCBzdGFfaW5mbyAqIGFwX2dldF9zdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY29uc3QgdTggKnN0YSk7CiB2b2lkIGFwX3N0YV9oYXNoX2FkZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSk7CiB2b2lkIGFwX2ZyZWVfc3RhKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhKTsKLXZvaWQgYXBfZnJlZV9zdGEoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEpOwogdm9pZCBob3N0YXBkX2ZyZWVfc3RhcyhzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKTsKIHZvaWQgYXBfaGFuZGxlX3RpbWVyKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogdm9pZCBhcF9zdGFfc2Vzc2lvbl90aW1lb3V0KHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHN0cnVjdCBzdGFfaW5mbyAqc3RhLApAQCAtMTQ5LDYgKzE1NSwxMCBAQAogCQkJIHUxNiByZWFzb24pOwogdm9pZCBhcF9zdGFfZGVhdXRoZW50aWNhdGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCiAJCQkgICB1MTYgcmVhc29uKTsKKyNpZmRlZiBDT05GSUdfV1BTCitpbnQgYXBfc3RhX3dwc19jYW5jZWwoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJICAgICAgc3RydWN0IHN0YV9pbmZvICpzdGEsIHZvaWQgKmN0eCk7CisjZW5kaWYgLyogQ09ORklHX1dQUyAqLwogaW50IGFwX3N0YV9iaW5kX3ZsYW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEsCiAJCSAgICAgaW50IG9sZF92bGFuaWQpOwogdm9pZCBhcF9zdGFfc3RhcnRfc2FfcXVlcnkoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgc3RydWN0IHN0YV9pbmZvICpzdGEpOwpkaWZmIC0tZ2l0IGEvc3JjL2FwL3RraXBfY291bnRlcm1lYXN1cmVzLmMgYi9zcmMvYXAvdGtpcF9jb3VudGVybWVhc3VyZXMuYwppbmRleCA2MDA4OGVlLi5kZDVhYTY4IDEwMDY0NAotLS0gYS9zcmMvYXAvdGtpcF9jb3VudGVybWVhc3VyZXMuYworKysgYi9zcmMvYXAvdGtpcF9jb3VudGVybWVhc3VyZXMuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC8gVEtJUCBjb3VudGVybWVhc3VyZXMKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDExLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTExLDYgKzExLDcgQEAKICNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKICNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKKyNpbmNsdWRlICJyYWRpdXMvcmFkaXVzLmgiCiAjaW5jbHVkZSAiaG9zdGFwZC5oIgogI2luY2x1ZGUgInN0YV9pbmZvLmgiCiAjaW5jbHVkZSAiYXBfbWxtZS5oIgpAQCAtNDQsMTIgKzQ1LDE3IEBACiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaWVlZTgwMjExX3RraXBfY291bnRlcm1lYXN1cmVzX3N0b3AsIGhhcGQsIE5VTEwpOwogCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoNjAsIDAsIGllZWU4MDIxMV90a2lwX2NvdW50ZXJtZWFzdXJlc19zdG9wLAogCQkJICAgICAgIGhhcGQsIE5VTEwpOwotCWZvciAoc3RhID0gaGFwZC0+c3RhX2xpc3Q7IHN0YSAhPSBOVUxMOyBzdGEgPSBzdGEtPm5leHQpIHsKKwl3aGlsZSAoKHN0YSA9IGhhcGQtPnN0YV9saXN0KSkgeworCQlzdGEtPmFjY3RfdGVybWluYXRlX2NhdXNlID0KKwkJCVJBRElVU19BQ0NUX1RFUk1JTkFURV9DQVVTRV9BRE1JTl9SRVNFVDsKKwkJaWYgKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9BVVRIKSB7CisJCQltbG1lX2RlYXV0aGVudGljYXRlX2luZGljYXRpb24oCisJCQkJaGFwZCwgc3RhLAorCQkJCVdMQU5fUkVBU09OX01JQ0hBRUxfTUlDX0ZBSUxVUkUpOworCQl9CiAJCWhvc3RhcGRfZHJ2X3N0YV9kZWF1dGgoaGFwZCwgc3RhLT5hZGRyLAogCQkJCSAgICAgICBXTEFOX1JFQVNPTl9NSUNIQUVMX01JQ19GQUlMVVJFKTsKLQkJYXBfc3RhX3NldF9hdXRob3JpemVkKGhhcGQsIHN0YSwgMCk7Ci0JCXN0YS0+ZmxhZ3MgJj0gfihXTEFOX1NUQV9BVVRIIHwgV0xBTl9TVEFfQVNTT0MpOwotCQlob3N0YXBkX2Rydl9zdGFfcmVtb3ZlKGhhcGQsIHN0YS0+YWRkcik7CisJCWFwX2ZyZWVfc3RhKGhhcGQsIHN0YSk7CiAJfQogfQogCmRpZmYgLS1naXQgYS9zcmMvYXAvdXRpbHMuYyBiL3NyYy9hcC91dGlscy5jCmluZGV4IDM2YzExODIuLjNlOWZjMDggMTAwNjQ0Ci0tLSBhL3NyYy9hcC91dGlscy5jCisrKyBiL3NyYy9hcC91dGlscy5jCkBAIC0xNyw3ICsxNyw4IEBACiBpbnQgaG9zdGFwZF9yZWdpc3Rlcl9wcm9iZXJlcV9jYihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAogCQkJCSBpbnQgKCpjYikodm9pZCAqY3R4LCBjb25zdCB1OCAqc2EsCiAJCQkJCSAgIGNvbnN0IHU4ICpkYSwgY29uc3QgdTggKmJzc2lkLAotCQkJCQkgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pLAorCQkJCQkgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkJCSAgIGludCBzc2lfc2lnbmFsKSwKIAkJCQkgdm9pZCAqY3R4KQogewogCXN0cnVjdCBob3N0YXBkX3Byb2JlcmVxX2NiICpuOwpkaWZmIC0tZ2l0IGEvc3JjL2FwL3dwYV9hdXRoLmMgYi9zcmMvYXAvd3BhX2F1dGguYwppbmRleCBkMWI5YjRkLi4xZDk0MmE0IDEwMDY0NAotLS0gYS9zcmMvYXAvd3BhX2F1dGguYworKysgYi9zcmMvYXAvd3BhX2F1dGguYwpAQCAtMTY0MSwxMCArMTY0MSwyMyBAQAogCiAJd3BhX2dyb3VwX2Vuc3VyZV9pbml0KHNtLT53cGFfYXV0aCwgc20tPmdyb3VwKTsKIAotCW9zX21lbWNweShzbS0+QU5vbmNlLCBzbS0+Z3JvdXAtPkNvdW50ZXIsIFdQQV9OT05DRV9MRU4pOworCS8qCisJICogRGVmaW5pdGlvbiBvZiBBTm9uY2Ugc2VsZWN0aW9uIGluIElFRUUgU3RkIDgwMi4xMWktMjAwNCBpcyBzb21ld2hhdAorCSAqIGFtYmlndW91cy4gVGhlIEF1dGhlbnRpY2F0b3Igc3RhdGUgbWFjaGluZSB1c2VzIGEgY291bnRlciB0aGF0IGlzCisJICogaW5jcmVtZW50ZWQgYnkgb25lIGZvciBlYWNoIDQtd2F5IGhhbmRzaGFrZS4gSG93ZXZlciwgdGhlIHNlY3VyaXR5CisJICogYW5hbHlzaXMgb2YgNC13YXkgaGFuZHNoYWtlIHBvaW50cyBvdXQgdGhhdCB1bnByZWRpY3RhYmxlIG5vbmNlcworCSAqIGhlbHAgaW4gcHJldmVudGluZyBwcmVjb21wdXRhdGlvbiBhdHRhY2tzLiBJbnN0ZWFkIG9mIHRoZSBzdGF0ZQorCSAqIG1hY2hpbmUgZGVmaW5pdGlvbiwgdXNlIGFuIHVucHJlZGljdGFibGUgbm9uY2UgdmFsdWUgaGVyZSB0byBwcm92aWRlCisJICogc3Ryb25nZXIgcHJvdGVjdGlvbiBhZ2FpbnN0IHBvdGVudGlhbCBwcmVjb21wdXRhdGlvbiBhdHRhY2tzLgorCSAqLworCWlmIChyYW5kb21fZ2V0X2J5dGVzKHNtLT5BTm9uY2UsIFdQQV9OT05DRV9MRU4pKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV1BBOiBGYWlsZWQgdG8gZ2V0IHJhbmRvbSBkYXRhIGZvciAiCisJCQkgICAiQU5vbmNlLiIpOworCQl3cGFfc3RhX2Rpc2Nvbm5lY3Qoc20tPndwYV9hdXRoLCBzbS0+YWRkcik7CisJCXJldHVybjsKKwl9CiAJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BBOiBBc3NpZ24gQU5vbmNlIiwgc20tPkFOb25jZSwKIAkJICAgIFdQQV9OT05DRV9MRU4pOwotCWluY19ieXRlX2FycmF5KHNtLT5ncm91cC0+Q291bnRlciwgV1BBX05PTkNFX0xFTik7CiAJc20tPlJlQXV0aGVudGljYXRpb25SZXF1ZXN0ID0gRkFMU0U7CiAJLyogSUVFRSA4MDIuMTFpIGRvZXMgbm90IGNsZWFyIFRpbWVvdXRDdHIgaGVyZSwgYnV0IHRoaXMgaXMgbW9yZQogCSAqIGxvZ2ljYWwgcGxhY2UgdGhhbiBJTklUSUFMSVpFIHNpbmNlIEFVVEhFTlRJQ0FUSU9OMiBjYW4gYmUKZGlmZiAtLWdpdCBhL3NyYy9hcC93cHNfaG9zdGFwZC5jIGIvc3JjL2FwL3dwc19ob3N0YXBkLmMKaW5kZXggODk5OTIxNy4uMDdjZTA2YyAxMDA2NDQKLS0tIGEvc3JjL2FwL3dwc19ob3N0YXBkLmMKKysrIGIvc3JjL2FwL3dwc19ob3N0YXBkLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogaG9zdGFwZCAvIFdQUyBpbnRlZ3JhdGlvbgotICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMTAsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTIsNiArMTIsOCBAQAogI2luY2x1ZGUgInV0aWxzL2Vsb29wLmgiCiAjaW5jbHVkZSAidXRpbHMvdXVpZC5oIgogI2luY2x1ZGUgImNyeXB0by9kaF9ncm91cHMuaCIKKyNpbmNsdWRlICJjcnlwdG8vZGhfZ3JvdXA1LmgiCisjaW5jbHVkZSAiY3J5cHRvL3JhbmRvbS5oIgogI2luY2x1ZGUgImNvbW1vbi93cGFfY3RybC5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJjb21tb24vaWVlZTgwMl8xMV9jb21tb24uaCIKQEAgLTIwLDYgKzIyLDcgQEAKICNpbmNsdWRlICJ3cHMvd3BzLmgiCiAjaW5jbHVkZSAid3BzL3dwc19kZWZzLmgiCiAjaW5jbHVkZSAid3BzL3dwc19kZXZfYXR0ci5oIgorI2luY2x1ZGUgIndwcy93cHNfYXR0cl9wYXJzZS5oIgogI2luY2x1ZGUgImhvc3RhcGQuaCIKICNpbmNsdWRlICJhcF9jb25maWcuaCIKICNpbmNsdWRlICJhcF9kcnZfb3BzLmgiCkBAIC0zNyw3ICs0MCw4IEBACiAKIHN0YXRpYyBpbnQgaG9zdGFwZF93cHNfcHJvYmVfcmVxX3J4KHZvaWQgKmN0eCwgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkYSwKIAkJCQkgICAgY29uc3QgdTggKmJzc2lkLAotCQkJCSAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pOworCQkJCSAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkJICAgIGludCBzc2lfc2lnbmFsKTsKIHN0YXRpYyB2b2lkIGhvc3RhcGRfd3BzX2FwX3Bpbl90aW1lb3V0KHZvaWQgKmVsb29wX2RhdGEsIHZvaWQgKnVzZXJfY3R4KTsKIAogCkBAIC0xODMsMTkgKzE4NywyMyBAQAogc3RydWN0IHdwc19zdG9wX3JlZ19kYXRhIHsKIAlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpjdXJyZW50X2hhcGQ7CiAJY29uc3QgdTggKnV1aWRfZTsKKwljb25zdCB1OCAqZGV2X3B3OworCXNpemVfdCBkZXZfcHdfbGVuOwogfTsKIAogc3RhdGljIGludCB3cHNfc3RvcF9yZWdpc3RyYXIoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgdm9pZCAqY3R4KQogewogCXN0cnVjdCB3cHNfc3RvcF9yZWdfZGF0YSAqZGF0YSA9IGN0eDsKIAlpZiAoaGFwZCAhPSBkYXRhLT5jdXJyZW50X2hhcGQgJiYgaGFwZC0+d3BzICE9IE5VTEwpCi0JCXdwc19yZWdpc3RyYXJfY29tcGxldGUoaGFwZC0+d3BzLT5yZWdpc3RyYXIsIGRhdGEtPnV1aWRfZSk7CisJCXdwc19yZWdpc3RyYXJfY29tcGxldGUoaGFwZC0+d3BzLT5yZWdpc3RyYXIsIGRhdGEtPnV1aWRfZSwKKwkJCQkgICAgICAgZGF0YS0+ZGV2X3B3LCBkYXRhLT5kZXZfcHdfbGVuKTsKIAlyZXR1cm4gMDsKIH0KIAogCiBzdGF0aWMgdm9pZCBob3N0YXBkX3dwc19yZWdfc3VjY2Vzc19jYih2b2lkICpjdHgsIGNvbnN0IHU4ICptYWNfYWRkciwKLQkJCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSkKKwkJCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSwgY29uc3QgdTggKmRldl9wdywKKwkJCQkgICAgICAgc2l6ZV90IGRldl9wd19sZW4pCiB7CiAJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGN0eDsKIAljaGFyIHV1aWRbNDBdOwpAQCAtMjA5LDYgKzIxNyw4IEBACiAJCQkJCSBtYWNfYWRkciwgdXVpZF9lKTsKIAlkYXRhLmN1cnJlbnRfaGFwZCA9IGhhcGQ7CiAJZGF0YS51dWlkX2UgPSB1dWlkX2U7CisJZGF0YS5kZXZfcHcgPSBkZXZfcHc7CisJZGF0YS5kZXZfcHdfbGVuID0gZGV2X3B3X2xlbjsKIAlob3N0YXBkX3dwc19mb3JfZWFjaChoYXBkLCB3cHNfc3RvcF9yZWdpc3RyYXIsICZkYXRhKTsKIH0KIApAQCAtOTg0LDYgKzk5NCwyMCBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGhvc3RhcGRfd3BzX25mY19jbGVhcihzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcykKK3sKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCXdwcy0+YXBfbmZjX2Rldl9wd19pZCA9IDA7CisJd3BhYnVmX2ZyZWUod3BzLT5hcF9uZmNfZGhfcHVia2V5KTsKKwl3cHMtPmFwX25mY19kaF9wdWJrZXkgPSBOVUxMOworCXdwYWJ1Zl9mcmVlKHdwcy0+YXBfbmZjX2RoX3ByaXZrZXkpOworCXdwcy0+YXBfbmZjX2RoX3ByaXZrZXkgPSBOVUxMOworCXdwYWJ1Zl9mcmVlKHdwcy0+YXBfbmZjX2Rldl9wdyk7CisJd3BzLT5hcF9uZmNfZGV2X3B3ID0gTlVMTDsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworfQorCisKIHZvaWQgaG9zdGFwZF9kZWluaXRfd3BzKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCiB7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoaG9zdGFwZF93cHNfcmVlbmFibGVfYXBfcGluLCBoYXBkLCBOVUxMKTsKQEAgLTEwMDEsNiArMTAyNSw3IEBACiAJd3BhYnVmX2ZyZWUoaGFwZC0+d3BzLT5vb2JfY29uZi5wdWJrZXlfaGFzaCk7CiAJd3BhYnVmX2ZyZWUoaGFwZC0+d3BzLT5vb2JfY29uZi5kZXZfcGFzc3dvcmQpOwogCXdwc19mcmVlX3BlbmRpbmdfbXNncyhoYXBkLT53cHMtPnVwbnBfbXNncyk7CisJaG9zdGFwZF93cHNfbmZjX2NsZWFyKGhhcGQtPndwcyk7CiAJb3NfZnJlZShoYXBkLT53cHMpOwogCWhhcGQtPndwcyA9IE5VTEw7CiAJaG9zdGFwZF93cHNfY2xlYXJfaWVzKGhhcGQpOwpAQCAtMTA5OCw2ICsxMTIzLDI0IEBACiB9CiAKIAorc3RhdGljIGludCB3cHNfY2FuY2VsKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIHZvaWQgKmN0eCkKK3sKKwlpZiAoaGFwZC0+d3BzID09IE5VTEwpCisJCXJldHVybiAwOworCisJd3BzX3JlZ2lzdHJhcl93cHNfY2FuY2VsKGhhcGQtPndwcy0+cmVnaXN0cmFyKTsKKwlhcF9mb3JfZWFjaF9zdGEoaGFwZCwgYXBfc3RhX3dwc19jYW5jZWwsIE5VTEwpOworCisJcmV0dXJuIDA7Cit9CisKKworaW50IGhvc3RhcGRfd3BzX2NhbmNlbChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQoreworCXJldHVybiBob3N0YXBkX3dwc19mb3JfZWFjaChoYXBkLCB3cHNfY2FuY2VsLCBOVUxMKTsKK30KKworCiAjaWZkZWYgQ09ORklHX1dQU19PT0IKIGludCBob3N0YXBkX3dwc19zdGFydF9vb2Ioc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgY2hhciAqZGV2aWNlX3R5cGUsCiAJCQkgIGNoYXIgKnBhdGgsIGNoYXIgKm1ldGhvZCwgY2hhciAqbmFtZSkKQEAgLTExNTQsNyArMTE5Nyw4IEBACiAKIHN0YXRpYyBpbnQgaG9zdGFwZF93cHNfcHJvYmVfcmVxX3J4KHZvaWQgKmN0eCwgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkYSwKIAkJCQkgICAgY29uc3QgdTggKmJzc2lkLAotCQkJCSAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pCisJCQkJICAgIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwKKwkJCQkgICAgaW50IHNzaV9zaWduYWwpCiB7CiAJc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCA9IGN0eDsKIAlzdHJ1Y3Qgd3BhYnVmICp3cHNfaWU7CkBAIC0xNDcxLDMgKzE1MTUsMTU2IEBACiAKIAlyZXR1cm4gd3BzX3JlZ2lzdHJhcl9jb25maWdfYXAoaGFwZC0+d3BzLT5yZWdpc3RyYXIsICZjcmVkKTsKIH0KKworCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKworc3RydWN0IHdwc19uZmNfcGFzc3dvcmRfdG9rZW5fZGF0YSB7CisJY29uc3QgdTggKm9vYl9kZXZfcHc7CisJc2l6ZV90IG9vYl9kZXZfcHdfbGVuOworCWludCBhZGRlZDsKK307CisKKworc3RhdGljIGludCB3cHNfYWRkX25mY19wYXNzd29yZF90b2tlbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCB2b2lkICpjdHgpCit7CisJc3RydWN0IHdwc19uZmNfcGFzc3dvcmRfdG9rZW5fZGF0YSAqZGF0YSA9IGN0eDsKKwlpbnQgcmV0OworCisJaWYgKGhhcGQtPndwcyA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKwlyZXQgPSB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcGFzc3dvcmRfdG9rZW4oaGFwZC0+d3BzLT5yZWdpc3RyYXIsCisJCQkJCQkgICBkYXRhLT5vb2JfZGV2X3B3LAorCQkJCQkJICAgZGF0YS0+b29iX2Rldl9wd19sZW4pOworCWlmIChyZXQgPT0gMCkKKwkJZGF0YS0+YWRkZWQrKzsKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgaG9zdGFwZF93cHNfYWRkX25mY19wYXNzd29yZF90b2tlbihzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJCQkgICAgICBzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgKmF0dHIpCit7CisJc3RydWN0IHdwc19uZmNfcGFzc3dvcmRfdG9rZW5fZGF0YSBkYXRhOworCisJZGF0YS5vb2JfZGV2X3B3ID0gYXR0ci0+b29iX2Rldl9wYXNzd29yZDsKKwlkYXRhLm9vYl9kZXZfcHdfbGVuID0gYXR0ci0+b29iX2Rldl9wYXNzd29yZF9sZW47CisJZGF0YS5hZGRlZCA9IDA7CisJaWYgKGhvc3RhcGRfd3BzX2Zvcl9lYWNoKGhhcGQsIHdwc19hZGRfbmZjX3Bhc3N3b3JkX3Rva2VuLCAmZGF0YSkgPCAwKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIGRhdGEuYWRkZWQgPyAwIDogLTE7Cit9CisKKworc3RhdGljIGludCBob3N0YXBkX3dwc19uZmNfdGFnX3Byb2Nlc3Moc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwKKwkJCQkgICAgICAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqd3BzKQoreworCXN0cnVjdCB3cHNfcGFyc2VfYXR0ciBhdHRyOworCisJd3BhX2hleGR1bXBfYnVmKE1TR19ERUJVRywgIldQUzogUmVjZWl2ZWQgTkZDIHRhZyBwYXlsb2FkIiwgd3BzKTsKKworCWlmICh3cHNfcGFyc2VfbXNnKHdwcywgJmF0dHIpKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBJZ25vcmUgaW52YWxpZCBkYXRhIGZyb20gTkZDIHRhZyIpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGF0dHIub29iX2Rldl9wYXNzd29yZCkKKwkJcmV0dXJuIGhvc3RhcGRfd3BzX2FkZF9uZmNfcGFzc3dvcmRfdG9rZW4oaGFwZCwgJmF0dHIpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IElnbm9yZSB1bnJlY29nbml6ZWQgTkZDIHRhZyIpOworCXJldHVybiAtMTsKK30KKworCitpbnQgaG9zdGFwZF93cHNfbmZjX3RhZ19yZWFkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRhdGEpCit7CisJY29uc3Qgc3RydWN0IHdwYWJ1ZiAqd3BzID0gZGF0YTsKKwlzdHJ1Y3Qgd3BhYnVmICp0bXAgPSBOVUxMOworCWludCByZXQ7CisKKwlpZiAod3BhYnVmX2xlbihkYXRhKSA8IDQpCisJCXJldHVybiAtMTsKKworCWlmICgqd3BhYnVmX2hlYWRfdTgoZGF0YSkgIT0gMHgxMCkgeworCQkvKiBBc3N1bWUgdGhpcyBjb250YWlucyBmdWxsIE5ERUYgcmVjb3JkICovCisJCXRtcCA9IG5kZWZfcGFyc2Vfd2lmaShkYXRhKTsKKwkJaWYgKHRtcCA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQ291bGQgbm90IHBhcnNlIE5ERUYiKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQl3cHMgPSB0bXA7CisJfQorCisJcmV0ID0gaG9zdGFwZF93cHNfbmZjX3RhZ19wcm9jZXNzKGhhcGQsIHdwcyk7CisJd3BhYnVmX2ZyZWUodG1wKTsKKwlyZXR1cm4gcmV0OworfQorCisKK3N0cnVjdCB3cGFidWYgKiBob3N0YXBkX3dwc19uZmNfY29uZmlnX3Rva2VuKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgICAgaW50IG5kZWYpCit7CisJc3RydWN0IHdwYWJ1ZiAqcmV0OworCisJaWYgKGhhcGQtPndwcyA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCXJldCA9IHdwc19nZXRfb29iX2NyZWQoaGFwZC0+d3BzKTsKKwlpZiAobmRlZiAmJiByZXQpIHsKKwkJc3RydWN0IHdwYWJ1ZiAqdG1wOworCQl0bXAgPSBuZGVmX2J1aWxkX3dpZmkocmV0KTsKKwkJd3BhYnVmX2ZyZWUocmV0KTsKKwkJaWYgKHRtcCA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisJCXJldCA9IHRtcDsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0cnVjdCB3cGFidWYgKiBob3N0YXBkX3dwc19uZmNfdG9rZW5fZ2VuKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGludCBuZGVmKQoreworCXJldHVybiB3cHNfbmZjX3Rva2VuX2dlbihuZGVmLCAmaGFwZC0+Y29uZi0+d3BzX25mY19kZXZfcHdfaWQsCisJCQkJICZoYXBkLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSwKKwkJCQkgJmhhcGQtPmNvbmYtPndwc19uZmNfZGhfcHJpdmtleSwKKwkJCQkgJmhhcGQtPmNvbmYtPndwc19uZmNfZGV2X3B3KTsKK30KKworCitpbnQgaG9zdGFwZF93cHNfbmZjX3Rva2VuX2VuYWJsZShzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQoreworCXN0cnVjdCB3cHNfY29udGV4dCAqd3BzID0gaGFwZC0+d3BzOworCisJaWYgKHdwcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAoIWhhcGQtPmNvbmYtPndwc19uZmNfZGhfcHVia2V5IHx8CisJICAgICFoYXBkLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkgfHwKKwkgICAgIWhhcGQtPmNvbmYtPndwc19uZmNfZGV2X3B3IHx8CisJICAgICFoYXBkLT5jb25mLT53cHNfbmZjX2Rldl9wd19pZCkKKwkJcmV0dXJuIC0xOworCisJaG9zdGFwZF93cHNfbmZjX2NsZWFyKHdwcyk7CisJd3BzLT5hcF9uZmNfZGV2X3B3X2lkID0gaGFwZC0+Y29uZi0+d3BzX25mY19kZXZfcHdfaWQ7CisJd3BzLT5hcF9uZmNfZGhfcHVia2V5ID0gd3BhYnVmX2R1cChoYXBkLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSk7CisJd3BzLT5hcF9uZmNfZGhfcHJpdmtleSA9IHdwYWJ1Zl9kdXAoaGFwZC0+Y29uZi0+d3BzX25mY19kaF9wcml2a2V5KTsKKwl3cHMtPmFwX25mY19kZXZfcHcgPSB3cGFidWZfZHVwKGhhcGQtPmNvbmYtPndwc19uZmNfZGV2X3B3KTsKKworCWlmICghd3BzLT5hcF9uZmNfZGhfcHVia2V5IHx8ICF3cHMtPmFwX25mY19kaF9wcml2a2V5IHx8CisJICAgICF3cHMtPmFwX25mY19kZXZfcHcpIHsKKwkJaG9zdGFwZF93cHNfbmZjX2NsZWFyKHdwcyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworCit2b2lkIGhvc3RhcGRfd3BzX25mY190b2tlbl9kaXNhYmxlKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpCit7CisJaG9zdGFwZF93cHNfbmZjX2NsZWFyKGhhcGQtPndwcyk7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwpkaWZmIC0tZ2l0IGEvc3JjL2FwL3dwc19ob3N0YXBkLmggYi9zcmMvYXAvd3BzX2hvc3RhcGQuaAppbmRleCA5MTk0MjI1Li5mOTY4ZTE1IDEwMDY0NAotLS0gYS9zcmMvYXAvd3BzX2hvc3RhcGQuaAorKysgYi9zcmMvYXAvd3BzX2hvc3RhcGQuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC8gV1BTIGludGVncmF0aW9uCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yMCw2ICsyMCw3IEBACiAJCQljb25zdCBjaGFyICp1dWlkLCBjb25zdCBjaGFyICpwaW4sIGludCB0aW1lb3V0KTsKIGludCBob3N0YXBkX3dwc19idXR0b25fcHVzaGVkKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCiAJCQkgICAgICBjb25zdCB1OCAqcDJwX2Rldl9hZGRyKTsKK2ludCBob3N0YXBkX3dwc19jYW5jZWwoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7CiBpbnQgaG9zdGFwZF93cHNfc3RhcnRfb29iKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNoYXIgKmRldmljZV90eXBlLAogCQkJICBjaGFyICpwYXRoLCBjaGFyICptZXRob2QsIGNoYXIgKm5hbWUpOwogaW50IGhvc3RhcGRfd3BzX2dldF9taWJfc3RhKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsIGNvbnN0IHU4ICphZGRyLApAQCAtMzIsNiArMzMsMTMgQEAKIHZvaWQgaG9zdGFwZF93cHNfdXBkYXRlX2llKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwogaW50IGhvc3RhcGRfd3BzX2NvbmZpZ19hcChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLCBjb25zdCBjaGFyICpzc2lkLAogCQkJICBjb25zdCBjaGFyICphdXRoLCBjb25zdCBjaGFyICplbmNyLCBjb25zdCBjaGFyICprZXkpOworaW50IGhvc3RhcGRfd3BzX25mY190YWdfcmVhZChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkLAorCQkJICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkYXRhKTsKK3N0cnVjdCB3cGFidWYgKiBob3N0YXBkX3dwc19uZmNfY29uZmlnX3Rva2VuKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCisJCQkJCSAgICAgaW50IG5kZWYpOworc3RydWN0IHdwYWJ1ZiAqIGhvc3RhcGRfd3BzX25mY190b2tlbl9nZW4oc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCwgaW50IG5kZWYpOworaW50IGhvc3RhcGRfd3BzX25mY190b2tlbl9lbmFibGUoc3RydWN0IGhvc3RhcGRfZGF0YSAqaGFwZCk7Cit2b2lkIGhvc3RhcGRfd3BzX25mY190b2tlbl9kaXNhYmxlKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQpOwogCiAjZWxzZSAvKiBDT05GSUdfV1BTICovCiAKQEAgLTY3LDYgKzc1LDExIEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50IGhvc3RhcGRfd3BzX2NhbmNlbChzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkKQoreworCXJldHVybiAwOworfQorCiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLwogCiAjZW5kaWYgLyogV1BTX0hPU1RBUERfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5jIGIvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5jCmluZGV4IGIwZDMxMGQuLmQ2NTY3NWMgMTAwNjQ0Ci0tLSBhL3NyYy9jb21tb24vaWVlZTgwMl8xMV9jb21tb24uYworKysgYi9zcmMvY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogSUVFRSA4MDIuMTEgQ29tbW9uIHJvdXRpbmVzCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwMi0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC05Nyw2ICs5NywxMSBAQAogCQkJZWxlbXMtPnAycCA9IHBvczsKIAkJCWVsZW1zLT5wMnBfbGVuID0gZWxlbjsKIAkJCWJyZWFrOworCQljYXNlIEhTMjBfSU5ESUNBVElPTl9PVUlfVFlQRToKKwkJCS8qIEhvdHNwb3QgMi4wICovCisJCQllbGVtcy0+aHMyMCA9IHBvczsKKwkJCWVsZW1zLT5oczIwX2xlbiA9IGVsZW47CisJCQlicmVhazsKIAkJZGVmYXVsdDoKIAkJCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJVbmtub3duIFdGQSAiCiAJCQkJICAgImluZm9ybWF0aW9uIGVsZW1lbnQgaWdub3JlZCAiCkBAIC0yNTcsNiArMjYyLDE1IEBACiAJCQllbGVtcy0+aW50ZXJ3b3JraW5nID0gcG9zOwogCQkJZWxlbXMtPmludGVyd29ya2luZ19sZW4gPSBlbGVuOwogCQkJYnJlYWs7CisJCWNhc2UgV0xBTl9FSURfRVhUX0NBUEFCOgorCQkJZWxlbXMtPmV4dF9jYXBhYiA9IHBvczsKKwkJCWVsZW1zLT5leHRfY2FwYWJfbGVuID0gZWxlbjsKKwkJCWJyZWFrOworCQljYXNlIFdMQU5fRUlEX0JTU19NQVhfSURMRV9QRVJJT0Q6CisJCQlpZiAoZWxlbiA8IDMpCisJCQkJYnJlYWs7CisJCQllbGVtcy0+YnNzX21heF9pZGxlX3BlcmlvZCA9IHBvczsKKwkJCWJyZWFrOwogCQlkZWZhdWx0OgogCQkJdW5rbm93bisrOwogCQkJaWYgKCFzaG93X2Vycm9ycykKZGlmZiAtLWdpdCBhL3NyYy9jb21tb24vaWVlZTgwMl8xMV9jb21tb24uaCBiL3NyYy9jb21tb24vaWVlZTgwMl8xMV9jb21tb24uaAppbmRleCBiZmFjODhjLi5kOWIyYjZjIDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmgKKysrIGIvc3JjL2NvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oCkBAIC0zNyw2ICszNyw5IEBACiAJY29uc3QgdTggKnAycDsKIAljb25zdCB1OCAqbGlua19pZDsKIAljb25zdCB1OCAqaW50ZXJ3b3JraW5nOworCWNvbnN0IHU4ICpoczIwOworCWNvbnN0IHU4ICpleHRfY2FwYWI7CisJY29uc3QgdTggKmJzc19tYXhfaWRsZV9wZXJpb2Q7CiAKIAl1OCBzc2lkX2xlbjsKIAl1OCBzdXBwX3JhdGVzX2xlbjsKQEAgLTYzLDYgKzY2LDggQEAKIAl1OCB2ZW5kb3JfaHRfY2FwX2xlbjsKIAl1OCBwMnBfbGVuOwogCXU4IGludGVyd29ya2luZ19sZW47CisJdTggaHMyMF9sZW47CisJdTggZXh0X2NhcGFiX2xlbjsKIH07CiAKIHR5cGVkZWYgZW51bSB7IFBhcnNlT0sgPSAwLCBQYXJzZVVua25vd24gPSAxLCBQYXJzZUZhaWxlZCA9IC0xIH0gUGFyc2VSZXM7CmRpZmYgLS1naXQgYS9zcmMvY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIGIvc3JjL2NvbW1vbi9pZWVlODAyXzExX2RlZnMuaAppbmRleCAzYmVmMDA2Li5iNGY5Mjc1IDEwMDY0NAotLS0gYS9zcmMvY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oCisrKyBiL3NyYy9jb21tb24vaWVlZTgwMl8xMV9kZWZzLmgKQEAgLTIyOCwxMiArMjI4LDI1IEBACiAjZGVmaW5lIFdMQU5fRUlEXzIwXzQwX0JTU19JTlRPTEVSQU5UIDczCiAjZGVmaW5lIFdMQU5fRUlEX09WRVJMQVBQSU5HX0JTU19TQ0FOX1BBUkFNUyA3NAogI2RlZmluZSBXTEFOX0VJRF9NTUlFIDc2CisjZGVmaW5lIFdMQU5fRUlEX0JTU19NQVhfSURMRV9QRVJJT0QgOTAKKyNkZWZpbmUgV0xBTl9FSURfVEZTX1JFUSA5MQorI2RlZmluZSBXTEFOX0VJRF9URlNfUkVTUCA5MgorI2RlZmluZSBXTEFOX0VJRF9XTk1TTEVFUCA5MwogI2RlZmluZSBXTEFOX0VJRF9USU1FX1pPTkUgOTgKICNkZWZpbmUgV0xBTl9FSURfTElOS19JRCAxMDEKICNkZWZpbmUgV0xBTl9FSURfSU5URVJXT1JLSU5HIDEwNwogI2RlZmluZSBXTEFOX0VJRF9BRFZfUFJPVE8gMTA4CiAjZGVmaW5lIFdMQU5fRUlEX1JPQU1JTkdfQ09OU09SVElVTSAxMTEKICNkZWZpbmUgV0xBTl9FSURfRVhUX0NBUEFCIDEyNworI2RlZmluZSBXTEFOX0VJRF9WSFRfQ0FQIDE5MQorI2RlZmluZSBXTEFOX0VJRF9WSFRfT1BFUkFUSU9OIDE5MgorI2RlZmluZSBXTEFOX0VJRF9WSFRfRVhURU5ERURfQlNTX0xPQUQgMTkzCisjZGVmaW5lIFdMQU5fRUlEX1ZIVF9XSURFX0JXX0NIU1dJVENIICAxOTQKKyNkZWZpbmUgV0xBTl9FSURfVkhUX1RSQU5TTUlUX1BPV0VSX0VOVkVMT1BFIDE5NQorI2RlZmluZSBXTEFOX0VJRF9WSFRfQ0hBTk5FTF9TV0lUQ0hfV1JBUFBFUiAxOTYKKyNkZWZpbmUgV0xBTl9FSURfVkhUX0FJRCAxOTcKKyNkZWZpbmUgV0xBTl9FSURfVkhUX1FVSUVUX0NIQU5ORUwgMTk4CisjZGVmaW5lIFdMQU5fRUlEX1ZIVF9PUEVSQVRJTkdfTU9ERV9OT1RJRklDQVRJT04gMTk5CiAjZGVmaW5lIFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQyAyMjEKIAogCkBAIC0yNTQsNiArMjY3LDcgQEAKICNkZWZpbmUgV0xBTl9BQ1RJT05fVkVORE9SX1NQRUNJRklDIDEyNwogCiAvKiBQdWJsaWMgYWN0aW9uIGNvZGVzICovCisjZGVmaW5lIFdMQU5fUEFfMjBfNDBfQlNTX0NPRVggMAogI2RlZmluZSBXTEFOX1BBX1ZFTkRPUl9TUEVDSUZJQyA5CiAjZGVmaW5lIFdMQU5fUEFfR0FTX0lOSVRJQUxfUkVRIDEwCiAjZGVmaW5lIFdMQU5fUEFfR0FTX0lOSVRJQUxfUkVTUCAxMQpAQCAtNDg3LDYgKzUwMSwxNyBAQAogCQkJCX0gU1RSVUNUX1BBQ0tFRCBzYV9xdWVyeV9yZXNwOwogCQkJCXN0cnVjdCB7CiAJCQkJCXU4IGFjdGlvbjsKKwkJCQkJdTggZGlhbG9ndG9rZW47CisJCQkJCXU4IHZhcmlhYmxlWzBdOworCQkJCX0gU1RSVUNUX1BBQ0tFRCB3bm1fc2xlZXBfcmVxOworCQkJCXN0cnVjdCB7CisJCQkJCXU4IGFjdGlvbjsKKwkJCQkJdTggZGlhbG9ndG9rZW47CisJCQkJCWxlMTYga2V5ZGF0YV9sZW47CisJCQkJCXU4IHZhcmlhYmxlWzBdOworCQkJCX0gU1RSVUNUX1BBQ0tFRCB3bm1fc2xlZXBfcmVzcDsKKwkJCQlzdHJ1Y3QgeworCQkJCQl1OCBhY3Rpb247CiAJCQkJCXU4IHZhcmlhYmxlWzBdOwogCQkJCX0gU1RSVUNUX1BBQ0tFRCBwdWJsaWNfYWN0aW9uOwogCQkJCXN0cnVjdCB7CkBAIC01MzQsNiArNTU5LDE5IEBACiAJdTggYmFzaWNfc2V0WzE2XTsKIH0gU1RSVUNUX1BBQ0tFRDsKIAorCitzdHJ1Y3QgaWVlZTgwMjExX3ZodF9jYXBhYmlsaXRpZXMgeworCWxlMzIgdmh0X2NhcGFiaWxpdGllc19pbmZvOworCXU4IHZodF9zdXBwb3J0ZWRfbWNzX3NldFs4XTsKK30gU1RSVUNUX1BBQ0tFRDsKKworc3RydWN0IGllZWU4MDIxMV92aHRfb3BlcmF0aW9uIHsKKwl1OCB2aHRfb3BfaW5mb19jaHdpZHRoOworCXU4IHZodF9vcF9pbmZvX2NoYW5fY2VudGVyX2ZyZXFfc2VnMF9pZHg7CisJdTggdmh0X29wX2luZm9fY2hhbl9jZW50ZXJfZnJlcV9zZWcxX2lkeDsKKwlsZTE2IHZodF9iYXNpY19tY3Nfc2V0OworfSBTVFJVQ1RfUEFDS0VEOworCiAjaWZkZWYgX01TQ19WRVIKICNwcmFnbWEgcGFjayhwb3ApCiAjZW5kaWYgLyogX01TQ19WRVIgKi8KQEAgLTYzMCwxMiArNjY4LDQwIEBACiAKICNkZWZpbmUgQlNTX01FTUJFUlNISVBfU0VMRUNUT1JfSFRfUEhZIDEyNwogCisvKiBWSFQgRGVmaW5lcyAqLworI2RlZmluZSBWSFRfQ0FQX01BWF9NUERVX0xFTkdUSF83OTkxICAgICAgICAgICAgICAgICgodTMyKSBCSVQoMCkpCisjZGVmaW5lIFZIVF9DQVBfTUFYX01QRFVfTEVOR1RIXzExNDU0ICAgICAgICAgICAgICAgKCh1MzIpIEJJVCgxKSkKKyNkZWZpbmUgVkhUX0NBUF9TVVBQX0NIQU5fV0lEVEhfMTYwTUhaICAgICAgICAgICAgICAoKHUzMikgQklUKDIpKQorI2RlZmluZSBWSFRfQ0FQX1NVUFBfQ0hBTl9XSURUSF8xNjBfODBQTFVTODBNSFogICAgICgodTMyKSBCSVQoMykpCisjZGVmaW5lIFZIVF9DQVBfUlhMRFBDICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCg0KSkKKyNkZWZpbmUgVkhUX0NBUF9TSE9SVF9HSV84MCAgICAgICAgICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDUpKQorI2RlZmluZSBWSFRfQ0FQX1NIT1JUX0dJXzE2MCAgICAgICAgICAgICAgICAgICAgICAgICgodTMyKSBCSVQoNikpCisjZGVmaW5lIFZIVF9DQVBfVFhTVEJDICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCg3KSkKKyNkZWZpbmUgVkhUX0NBUF9SWFNUQkNfMSAgICAgICAgICAgICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDgpKQorI2RlZmluZSBWSFRfQ0FQX1JYU1RCQ18yICAgICAgICAgICAgICAgICAgICAgICAgICAgICgodTMyKSBCSVQoOSkpCisjZGVmaW5lIFZIVF9DQVBfUlhTVEJDXzMgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCh1MzIpIEJJVCg4KSB8IEJJVCg5KSkKKyNkZWZpbmUgVkhUX0NBUF9SWFNUQkNfNCAgICAgICAgICAgICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDEwKSkKKyNkZWZpbmUgVkhUX0NBUF9TVV9CRUFNRk9STUVSX0NBUEFCTEUgICAgICAgICAgICAgICAoKHUzMikgQklUKDExKSkKKyNkZWZpbmUgVkhUX0NBUF9TVV9CRUFNRk9STUVFX0NBUEFCTEUgICAgICAgICAgICAgICAoKHUzMikgQklUKDEyKSkKKyNkZWZpbmUgVkhUX0NBUF9CRUFNRk9STUVSX0FOVEVOTkFTX01BWCAgICAgICAgICAgICAoKHUzMikgQklUKDEzKSB8IEJJVCgxNCkpCisjZGVmaW5lIFZIVF9DQVBfU09VTkRJTkdfRElNRU5USU9OX01BWCAgICAgICAgICAgICAgKCh1MzIpIEJJVCgxNikgfCBCSVQoMTcpKQorI2RlZmluZSBWSFRfQ0FQX01VX0JFQU1GT1JNRVJfQ0FQQUJMRSAgICAgICAgICAgICAgICgodTMyKSBCSVQoMTkpKQorI2RlZmluZSBWSFRfQ0FQX01VX0JFQU1GT1JNRUVfQ0FQQUJMRSAgICAgICAgICAgICAgICgodTMyKSBCSVQoMjApKQorI2RlZmluZSBWSFRfQ0FQX1ZIVF9UWE9QX1BTICAgICAgICAgICAgICAgICAgICAgICAgICgodTMyKSBCSVQoMjEpKQorI2RlZmluZSBWSFRfQ0FQX0hUQ19WSFQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICgodTMyKSBCSVQoMjIpKQorI2RlZmluZSBWSFRfQ0FQX01BWF9BX01QRFVfTEVOR1RIX0VYUE9ORU5UICAgICAgICAgICgodTMyKSBCSVQoMjMpKQorI2RlZmluZSBWSFRfQ0FQX1ZIVF9MSU5LX0FEQVBUQVRJT05fVkhUX1VOU09MX01GQiAgICgodTMyKSBCSVQoMjcpKQorI2RlZmluZSBWSFRfQ0FQX1ZIVF9MSU5LX0FEQVBUQVRJT05fVkhUX01SUV9NRkIgICAgICgodTMyKSBCSVQoMjYpIHwgQklUKDI3KSkKKyNkZWZpbmUgVkhUX0NBUF9SWF9BTlRFTk5BX1BBVFRFUk4gICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDI4KSkKKyNkZWZpbmUgVkhUX0NBUF9UWF9BTlRFTk5BX1BBVFRFUk4gICAgICAgICAgICAgICAgICAoKHUzMikgQklUKDI5KSkKKwogI2RlZmluZSBPVUlfTUlDUk9TT0ZUIDB4MDA1MGYyIC8qIE1pY3Jvc29mdCAoYWxzbyB1c2VkIGluIFdpLUZpIHNwZWNzKQogCQkJCSogMDA6NTA6RjIgKi8KICNkZWZpbmUgV1BBX0lFX1ZFTkRPUl9UWVBFIDB4MDA1MGYyMDEKICNkZWZpbmUgV1BTX0lFX1ZFTkRPUl9UWVBFIDB4MDA1MGYyMDQKICNkZWZpbmUgT1VJX1dGQSAweDUwNmY5YQogI2RlZmluZSBQMlBfSUVfVkVORE9SX1RZUEUgMHg1MDZmOWEwOQorI2RlZmluZSBIUzIwX0lFX1ZFTkRPUl9UWVBFIDB4NTA2ZjlhMTAKIAogI2RlZmluZSBXTU1fT1VJX1RZUEUgMgogI2RlZmluZSBXTU1fT1VJX1NVQlRZUEVfSU5GT1JNQVRJT05fRUxFTUVOVCAwCkBAIC03NDksNiArODE1LDE2IEBACiB9OwogCiAKKyNkZWZpbmUgSFMyMF9JTkRJQ0FUSU9OX09VSV9UWVBFIDE2CisjZGVmaW5lIEhTMjBfQU5RUF9PVUlfVFlQRSAxNworI2RlZmluZSBIUzIwX1NUWVBFX1FVRVJZX0xJU1QgMQorI2RlZmluZSBIUzIwX1NUWVBFX0NBUEFCSUxJVFlfTElTVCAyCisjZGVmaW5lIEhTMjBfU1RZUEVfT1BFUkFUT1JfRlJJRU5ETFlfTkFNRSAzCisjZGVmaW5lIEhTMjBfU1RZUEVfV0FOX01FVFJJQ1MgNAorI2RlZmluZSBIUzIwX1NUWVBFX0NPTk5FQ1RJT05fQ0FQQUJJTElUWSA1CisjZGVmaW5lIEhTMjBfU1RZUEVfTkFJX0hPTUVfUkVBTE1fUVVFUlkgNgorI2RlZmluZSBIUzIwX1NUWVBFX09QRVJBVElOR19DTEFTUyA3CisKIC8qIFdpLUZpIERpcmVjdCAoUDJQKSAqLwogCiAjZGVmaW5lIFAyUF9PVUlfVFlQRSA5CkBAIC05MTUsNCArOTkxLDQ4IEBACiAjZGVmaW5lIFdOTV9CU1NfVE1fUkVRX0JTU19URVJNSU5BVElPTl9JTkNMVURFRCBCSVQoMykKICNkZWZpbmUgV05NX0JTU19UTV9SRVFfRVNTX0RJU0FTU09DX0lNTUlORU5UIEJJVCg0KQogCisvKiBJRUVFIFN0ZCA4MDIuMTEtMjAxMiwgOC40LjIuNjIgMjAvNDAgQlNTIENvZXhpc3RlbmNlIGVsZW1lbnQgKi8KKyNkZWZpbmUgV0xBTl8yMF80MF9CU1NfQ09FWF9JTkZPX1JFUSAgICAgICAgICAgIEJJVCgwKQorI2RlZmluZSBXTEFOXzIwXzQwX0JTU19DT0VYXzQwTUhaX0lOVE9MICAgICAgICAgQklUKDEpCisjZGVmaW5lIFdMQU5fMjBfNDBfQlNTX0NPRVhfMjBNSFpfV0lEVEhfUkVRICAgICBCSVQoMikKKyNkZWZpbmUgV0xBTl8yMF80MF9CU1NfQ09FWF9PQlNTX0VYRU1QVF9SRVEgICAgIEJJVCgzKQorI2RlZmluZSBXTEFOXzIwXzQwX0JTU19DT0VYX09CU1NfRVhFTVBUX0dSTlQgICAgQklUKDQpCisKK3N0cnVjdCBpZWVlODAyMTFfMjA0MF9ic3NfY29leF9pZSB7CisJdTggZWxlbWVudF9pZDsKKwl1OCBsZW5ndGg7CisJdTggY29leF9wYXJhbTsKK30gU1RSVUNUX1BBQ0tFRDsKKworc3RydWN0IGllZWU4MDIxMV8yMDQwX2ludG9sX2NoYW5fcmVwb3J0IHsKKwl1OCBlbGVtZW50X2lkOworCXU4IGxlbmd0aDsKKwl1OCBvcF9jbGFzczsKKwl1OCB2YXJpYWJsZVswXTsJLyogQ2hhbm5lbCBMaXN0ICovCit9IFNUUlVDVF9QQUNLRUQ7CisKKy8qIElFRUUgODAyLjExdiAtIFdOTS1TbGVlcCBNb2RlIGVsZW1lbnQgKi8KK3N0cnVjdCB3bm1fc2xlZXBfZWxlbWVudCB7CisJdTggZWlkOyAgICAgLyogV0xBTl9FSURfV05NU0xFRVAgKi8KKwl1OCBsZW47CisJdTggYWN0aW9uX3R5cGU7IC8qIFdMQU5fV05NX1NMRUVQX0VOVEVSL0VYSVQgKi8KKwl1OCBzdGF0dXM7CisJbGUxNiBpbnR2YWw7Cit9IFNUUlVDVF9QQUNLRUQ7CisKK2VudW0gd25tX3NsZWVwX21vZGVfcmVzcG9uc2Vfc3RhdHVzIHsKKwlXTk1fU1RBVFVTX1NMRUVQX0FDQ0VQVCA9IDAsCisJV05NX1NUQVRVU19TTEVFUF9FWElUX0FDQ0VQVF9HVEtfVVBEQVRFID0gMSwKKwlXTk1fU1RBVFVTX0RFTklFRF9BQ1RJT04gPSAyLAorCVdOTV9TVEFUVVNfREVOSUVEX1RNUCA9IDMsCisJV05NX1NUQVRVU19ERU5JRURfS0VZID0gNCwKKwlXTk1fU1RBVFVTX0RFTklFRF9PVEhFUl9XTk1fU0VSVklDRSA9IDUKK307CisKKy8qIFdOTS1TbGVlcCBNb2RlIHN1YmVsZW1lbnQgSURzICovCitlbnVtIHdubV9zbGVlcF9tb2RlX3N1YmVsZW1lbnRfaWQgeworCVdOTV9TTEVFUF9TVUJFTEVNX0dUSyA9IDAsCisJV05NX1NMRUVQX1NVQkVMRU1fSUdUSyA9IDEKK307CisKICNlbmRpZiAvKiBJRUVFODAyXzExX0RFRlNfSCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2NvbW1vbi93cGFfY3RybC5oIGIvc3JjL2NvbW1vbi93cGFfY3RybC5oCmluZGV4IDU3NjhmZGQuLmE0NDBiNjkgMTAwNjQ0Ci0tLSBhL3NyYy9jb21tb24vd3BhX2N0cmwuaAorKysgYi9zcmMvY29tbW9uL3dwYV9jdHJsLmgKQEAgLTEyMCw2ICsxMjAsOCBAQAogI2RlZmluZSBQMlBfRVZFTlRfUFJPVl9ESVNDX1BCQ19SRVEgIlAyUC1QUk9WLURJU0MtUEJDLVJFUSAiCiAvKiBwYXJhbWV0ZXJzOiA8cGVlciBhZGRyZXNzPiAqLwogI2RlZmluZSBQMlBfRVZFTlRfUFJPVl9ESVNDX1BCQ19SRVNQICJQMlAtUFJPVi1ESVNDLVBCQy1SRVNQICIKKy8qIHBhcmFtZXRlcnM6IDxwZWVyIGFkZHJlc3M+IDxzdGF0dXM+ICovCisjZGVmaW5lIFAyUF9FVkVOVF9QUk9WX0RJU0NfRkFJTFVSRSAiUDJQLVBST1YtRElTQy1GQUlMVVJFIgogLyogcGFyYW1ldGVyczogPGZyZXE+IDxzcmMgYWRkcj4gPGRpYWxvZyB0b2tlbj4gPHVwZGF0ZSBpbmRpY2F0b3I+IDxUTFZzPiAqLwogI2RlZmluZSBQMlBfRVZFTlRfU0VSVl9ESVNDX1JFUSAiUDJQLVNFUlYtRElTQy1SRVEgIgogLyogcGFyYW1ldGVyczogPHNyYyBhZGRyPiA8dXBkYXRlIGluZGljYXRvcj4gPFRMVnM+ICovCkBAIC0xNDMsNiArMTQ1LDI3IEBACiAjZGVmaW5lIEFQX1NUQV9ESVNDT05ORUNURUQgIkFQLVNUQS1ESVNDT05ORUNURUQgIgogCiAKKy8qIEJTUyBjb21tYW5kIGluZm9ybWF0aW9uIG1hc2tzICovCisKKyNkZWZpbmUgV1BBX0JTU19NQVNLX0FMTAkJMHhGRkZGRkZGRgorI2RlZmluZSBXUEFfQlNTX01BU0tfSUQJCQlCSVQoMCkKKyNkZWZpbmUgV1BBX0JTU19NQVNLX0JTU0lECQlCSVQoMSkKKyNkZWZpbmUgV1BBX0JTU19NQVNLX0ZSRVEJCUJJVCgyKQorI2RlZmluZSBXUEFfQlNTX01BU0tfQkVBQ09OX0lOVAkJQklUKDMpCisjZGVmaW5lIFdQQV9CU1NfTUFTS19DQVBBQklMSVRJRVMJQklUKDQpCisjZGVmaW5lIFdQQV9CU1NfTUFTS19RVUFMCQlCSVQoNSkKKyNkZWZpbmUgV1BBX0JTU19NQVNLX05PSVNFCQlCSVQoNikKKyNkZWZpbmUgV1BBX0JTU19NQVNLX0xFVkVMCQlCSVQoNykKKyNkZWZpbmUgV1BBX0JTU19NQVNLX1RTRgkJQklUKDgpCisjZGVmaW5lIFdQQV9CU1NfTUFTS19BR0UJCUJJVCg5KQorI2RlZmluZSBXUEFfQlNTX01BU0tfSUUJCQlCSVQoMTApCisjZGVmaW5lIFdQQV9CU1NfTUFTS19GTEFHUwkJQklUKDExKQorI2RlZmluZSBXUEFfQlNTX01BU0tfU1NJRAkJQklUKDEyKQorI2RlZmluZSBXUEFfQlNTX01BU0tfV1BTX1NDQU4JCUJJVCgxMykKKyNkZWZpbmUgV1BBX0JTU19NQVNLX1AyUF9TQ0FOCQlCSVQoMTQpCisjZGVmaW5lIFdQQV9CU1NfTUFTS19JTlRFUk5FVFcJCUJJVCgxNSkKKworCiAvKiB3cGFfc3VwcGxpY2FudC9ob3N0YXBkIGNvbnRyb2wgaW50ZXJmYWNlIGFjY2VzcyAqLwogCiAvKioKZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vY3J5cHRvX29wZW5zc2wuYyBiL3NyYy9jcnlwdG8vY3J5cHRvX29wZW5zc2wuYwppbmRleCAxMTcxZjI5Li44NTA2ZmZmIDEwMDY0NAotLS0gYS9zcmMvY3J5cHRvL2NyeXB0b19vcGVuc3NsLmMKKysrIGIvc3JjL2NyeXB0by9jcnlwdG9fb3BlbnNzbC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC8gd3JhcHBlciBmdW5jdGlvbnMgZm9yIGxpYmNyeXB0bwotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTQsNiArMTQsNyBAQAogI2luY2x1ZGUgPG9wZW5zc2wvYm4uaD4KICNpbmNsdWRlIDxvcGVuc3NsL2V2cC5oPgogI2luY2x1ZGUgPG9wZW5zc2wvZGguaD4KKyNpbmNsdWRlIDxvcGVuc3NsL2htYWMuaD4KIAogI2luY2x1ZGUgImNvbW1vbi5oIgogI2luY2x1ZGUgIndwYWJ1Zi5oIgpAQCAtNDUyLDYgKzQ1Myw0MSBAQAogfQogCiAKK3ZvaWQgKiBkaDVfaW5pdF9maXhlZChjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwcml2LCBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwdWJsKQoreworCURIICpkaDsKKworCWRoID0gREhfbmV3KCk7CisJaWYgKGRoID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJZGgtPmcgPSBCTl9uZXcoKTsKKwlpZiAoZGgtPmcgPT0gTlVMTCB8fCBCTl9zZXRfd29yZChkaC0+ZywgMikgIT0gMSkKKwkJZ290byBlcnI7CisKKwlkaC0+cCA9IGdldF9ncm91cDVfcHJpbWUoKTsKKwlpZiAoZGgtPnAgPT0gTlVMTCkKKwkJZ290byBlcnI7CisKKwlkaC0+cHJpdl9rZXkgPSBCTl9iaW4yYm4od3BhYnVmX2hlYWQocHJpdiksIHdwYWJ1Zl9sZW4ocHJpdiksIE5VTEwpOworCWlmIChkaC0+cHJpdl9rZXkgPT0gTlVMTCkKKwkJZ290byBlcnI7CisKKwlkaC0+cHViX2tleSA9IEJOX2JpbjJibih3cGFidWZfaGVhZChwdWJsKSwgd3BhYnVmX2xlbihwdWJsKSwgTlVMTCk7CisJaWYgKGRoLT5wdWJfa2V5ID09IE5VTEwpCisJCWdvdG8gZXJyOworCisJaWYgKERIX2dlbmVyYXRlX2tleShkaCkgIT0gMSkKKwkJZ290byBlcnI7CisKKwlyZXR1cm4gZGg7CisKK2VycjoKKwlESF9mcmVlKGRoKTsKKwlyZXR1cm4gTlVMTDsKK30KKworCiBzdHJ1Y3Qgd3BhYnVmICogZGg1X2Rlcml2ZV9zaGFyZWQodm9pZCAqY3R4LCBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwZWVyX3B1YmxpYywKIAkJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKm93bl9wcml2YXRlKQogewpAQCAtNDk3LDMgKzUzMyw5MyBAQAogCWRoID0gY3R4OwogCURIX2ZyZWUoZGgpOwogfQorCisKK3N0cnVjdCBjcnlwdG9faGFzaCB7CisJSE1BQ19DVFggY3R4OworfTsKKworCitzdHJ1Y3QgY3J5cHRvX2hhc2ggKiBjcnlwdG9faGFzaF9pbml0KGVudW0gY3J5cHRvX2hhc2hfYWxnIGFsZywgY29uc3QgdTggKmtleSwKKwkJCQkgICAgICBzaXplX3Qga2V5X2xlbikKK3sKKwlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmN0eDsKKwljb25zdCBFVlBfTUQgKm1kOworCisJc3dpdGNoIChhbGcpIHsKKyNpZm5kZWYgT1BFTlNTTF9OT19NRDUKKwljYXNlIENSWVBUT19IQVNIX0FMR19ITUFDX01ENToKKwkJbWQgPSBFVlBfbWQ1KCk7CisJCWJyZWFrOworI2VuZGlmIC8qIE9QRU5TU0xfTk9fTUQ1ICovCisjaWZuZGVmIE9QRU5TU0xfTk9fU0hBCisJY2FzZSBDUllQVE9fSEFTSF9BTEdfSE1BQ19TSEExOgorCQltZCA9IEVWUF9zaGExKCk7CisJCWJyZWFrOworI2VuZGlmIC8qIE9QRU5TU0xfTk9fU0hBICovCisjaWZuZGVmIE9QRU5TU0xfTk9fU0hBMjU2CisjaWZkZWYgQ09ORklHX1NIQTI1NgorCWNhc2UgQ1JZUFRPX0hBU0hfQUxHX0hNQUNfU0hBMjU2OgorCQltZCA9IEVWUF9zaGEyNTYoKTsKKwkJYnJlYWs7CisjZW5kaWYgLyogQ09ORklHX1NIQTI1NiAqLworI2VuZGlmIC8qIE9QRU5TU0xfTk9fU0hBMjU2ICovCisJZGVmYXVsdDoKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJY3R4ID0gb3NfemFsbG9jKHNpemVvZigqY3R4KSk7CisJaWYgKGN0eCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworI2lmIE9QRU5TU0xfVkVSU0lPTl9OVU1CRVIgPCAweDAwOTA5MDAwCisJSE1BQ19Jbml0X2V4KCZjdHgtPmN0eCwga2V5LCBrZXlfbGVuLCBtZCwgTlVMTCk7CisjZWxzZSAvKiBvcGVuc3NsIDwgMC45LjkgKi8KKwlpZiAoSE1BQ19Jbml0X2V4KCZjdHgtPmN0eCwga2V5LCBrZXlfbGVuLCBtZCwgTlVMTCkgIT0gMSkgeworCQlvc19mcmVlKGN0eCk7CisJCXJldHVybiBOVUxMOworCX0KKyNlbmRpZiAvKiBvcGVuc3NsIDwgMC45LjkgKi8KKworCXJldHVybiBjdHg7Cit9CisKKwordm9pZCBjcnlwdG9faGFzaF91cGRhdGUoc3RydWN0IGNyeXB0b19oYXNoICpjdHgsIGNvbnN0IHU4ICpkYXRhLCBzaXplX3QgbGVuKQoreworCWlmIChjdHggPT0gTlVMTCkKKwkJcmV0dXJuOworCUhNQUNfVXBkYXRlKCZjdHgtPmN0eCwgZGF0YSwgbGVuKTsKK30KKworCitpbnQgY3J5cHRvX2hhc2hfZmluaXNoKHN0cnVjdCBjcnlwdG9faGFzaCAqY3R4LCB1OCAqbWFjLCBzaXplX3QgKmxlbikKK3sKKwl1bnNpZ25lZCBpbnQgbWRsZW47CisJaW50IHJlczsKKworCWlmIChjdHggPT0gTlVMTCkKKwkJcmV0dXJuIC0yOworCisJaWYgKG1hYyA9PSBOVUxMIHx8IGxlbiA9PSBOVUxMKSB7CisJCW9zX2ZyZWUoY3R4KTsKKwkJcmV0dXJuIDA7CisJfQorCisJbWRsZW4gPSAqbGVuOworI2lmIE9QRU5TU0xfVkVSU0lPTl9OVU1CRVIgPCAweDAwOTA5MDAwCisJSE1BQ19GaW5hbCgmY3R4LT5jdHgsIG1hYywgJm1kbGVuKTsKKwlyZXMgPSAxOworI2Vsc2UgLyogb3BlbnNzbCA8IDAuOS45ICovCisJcmVzID0gSE1BQ19GaW5hbCgmY3R4LT5jdHgsIG1hYywgJm1kbGVuKTsKKyNlbmRpZiAvKiBvcGVuc3NsIDwgMC45LjkgKi8KKwlITUFDX0NUWF9jbGVhbnVwKCZjdHgtPmN0eCk7CisJb3NfZnJlZShjdHgpOworCisJaWYgKHJlcyA9PSAxKSB7CisJCSpsZW4gPSBtZGxlbjsKKwkJcmV0dXJuIDA7CisJfQorCisJcmV0dXJuIC0xOworfQpkaWZmIC0tZ2l0IGEvc3JjL2NyeXB0by9kaF9ncm91cDUuYyBiL3NyYy9jcnlwdG8vZGhfZ3JvdXA1LmMKaW5kZXggOWE5NGNhNS4uY2NkYmZjOCAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by9kaF9ncm91cDUuYworKysgYi9zcmMvY3J5cHRvL2RoX2dyb3VwNS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIERpZmZpZS1IZWxsbWFuIGdyb3VwIDUgb3BlcmF0aW9ucwotICogQ29weXJpZ2h0IChjKSAyMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA5LCAyMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yMiw2ICsyMiwxMiBAQAogfQogCiAKK3ZvaWQgKiBkaDVfaW5pdF9maXhlZChjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwcml2LCBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwdWJsKQoreworCXJldHVybiAodm9pZCAqKSAxOworfQorCisKIHN0cnVjdCB3cGFidWYgKiBkaDVfZGVyaXZlX3NoYXJlZCh2b2lkICpjdHgsIGNvbnN0IHN0cnVjdCB3cGFidWYgKnBlZXJfcHVibGljLAogCQkJCSAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqb3duX3ByaXZhdGUpCiB7CmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL2RoX2dyb3VwNS5oIGIvc3JjL2NyeXB0by9kaF9ncm91cDUuaAppbmRleCA4ODEzNDI3Li5hYmVlOGVhIDEwMDY0NAotLS0gYS9zcmMvY3J5cHRvL2RoX2dyb3VwNS5oCisrKyBiL3NyYy9jcnlwdG8vZGhfZ3JvdXA1LmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogRGlmZmllLUhlbGxtYW4gZ3JvdXAgNSBvcGVyYXRpb25zCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDksIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTEwLDYgKzEwLDcgQEAKICNkZWZpbmUgREhfR1JPVVA1X0gKIAogdm9pZCAqIGRoNV9pbml0KHN0cnVjdCB3cGFidWYgKipwcml2LCBzdHJ1Y3Qgd3BhYnVmICoqcHVibCk7Cit2b2lkICogZGg1X2luaXRfZml4ZWQoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcHJpdiwgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcHVibCk7CiBzdHJ1Y3Qgd3BhYnVmICogZGg1X2Rlcml2ZV9zaGFyZWQodm9pZCAqY3R4LCBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwZWVyX3B1YmxpYywKIAkJCQkgIGNvbnN0IHN0cnVjdCB3cGFidWYgKm93bl9wcml2YXRlKTsKIHZvaWQgZGg1X2ZyZWUodm9pZCAqY3R4KTsKZGlmZiAtLWdpdCBhL3NyYy9jcnlwdG8vcmFuZG9tLmMgYi9zcmMvY3J5cHRvL3JhbmRvbS5jCmluZGV4IDU1ZTkzOTEuLmQ4NWMzZTYgMTAwNjQ0Ci0tLSBhL3NyYy9jcnlwdG8vcmFuZG9tLmMKKysrIGIvc3JjL2NyeXB0by9yYW5kb20uYwpAQCAtMTI4LDggKzEyOCw2IEBACiAJc3RhdGljIHVuc2lnbmVkIGludCBjb3VudCA9IDA7CiAKIAljb3VudCsrOwotCXdwYV9wcmludGYoTVNHX01TR0RVTVAsICJBZGQgcmFuZG9tbmVzczogY291bnQ9JXUgZW50cm9weT0ldSIsCi0JCSAgIGNvdW50LCBlbnRyb3B5KTsKIAlpZiAoZW50cm9weSA+IE1JTl9DT0xMRUNUX0VOVFJPUFkgJiYgKGNvdW50ICYgMHgzZmYpICE9IDApIHsKIAkJLyoKIAkJICogTm8gbmVlZCB0byBhZGQgbW9yZSBlbnRyb3B5IGF0IHRoaXMgcG9pbnQsIHNvIHNhdmUgQ1BVIGFuZApAQCAtMTM3LDYgKzEzNSw4IEBACiAJCSAqLwogCQlyZXR1cm47CiAJfQorCXdwYV9wcmludGYoTVNHX0VYQ0VTU0lWRSwgIkFkZCByYW5kb21uZXNzOiBjb3VudD0ldSBlbnRyb3B5PSV1IiwKKwkJICAgY291bnQsIGVudHJvcHkpOwogCiAJb3NfZ2V0X3RpbWUoJnQpOwogCXdwYV9oZXhkdW1wX2tleShNU0dfRVhDRVNTSVZFLCAicmFuZG9tIHBvb2wiLApkaWZmIC0tZ2l0IGEvc3JjL2NyeXB0by90bHMuaCBiL3NyYy9jcnlwdG8vdGxzLmgKaW5kZXggMmJkM2JiYi4uOTkwZjZlNiAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by90bHMuaAorKysgYi9zcmMvY3J5cHRvL3Rscy5oCkBAIC0yMSw4ICsyMSwxMCBAQAogfTsKIAogZW51bSB0bHNfZXZlbnQgeworCVRMU19DRVJUX0NIQUlOX1NVQ0NFU1MsCiAJVExTX0NFUlRfQ0hBSU5fRkFJTFVSRSwKLQlUTFNfUEVFUl9DRVJUSUZJQ0FURQorCVRMU19QRUVSX0NFUlRJRklDQVRFLAorCVRMU19BTEVSVAogfTsKIAogLyoKQEAgLTU3LDYgKzU5LDEyIEBACiAJCWNvbnN0IHU4ICpoYXNoOwogCQlzaXplX3QgaGFzaF9sZW47CiAJfSBwZWVyX2NlcnQ7CisKKwlzdHJ1Y3QgeworCQlpbnQgaXNfbG9jYWw7CisJCWNvbnN0IGNoYXIgKnR5cGU7CisJCWNvbnN0IGNoYXIgKmRlc2NyaXB0aW9uOworCX0gYWxlcnQ7CiB9OwogCiBzdHJ1Y3QgdGxzX2NvbmZpZyB7CmRpZmYgLS1naXQgYS9zcmMvY3J5cHRvL3Rsc19vcGVuc3NsLmMgYi9zcmMvY3J5cHRvL3Rsc19vcGVuc3NsLmMKaW5kZXggYWFhOTIwYi4uMDliMDJlNCAxMDA2NDQKLS0tIGEvc3JjL2NyeXB0by90bHNfb3BlbnNzbC5jCisrKyBiL3NyYy9jcnlwdG8vdGxzX29wZW5zc2wuYwpAQCAtNTI3LDYgKzUyNywxNSBAQAogCQkJZWxzZQogCQkJCWNvbm4tPndyaXRlX2FsZXJ0cysrOwogCQl9CisJCWlmICh0bHNfZ2xvYmFsLT5ldmVudF9jYiAhPSBOVUxMKSB7CisJCQl1bmlvbiB0bHNfZXZlbnRfZGF0YSBldjsKKwkJCW9zX21lbXNldCgmZXYsIDAsIHNpemVvZihldikpOworCQkJZXYuYWxlcnQuaXNfbG9jYWwgPSAhKHdoZXJlICYgU1NMX0NCX1JFQUQpOworCQkJZXYuYWxlcnQudHlwZSA9IFNTTF9hbGVydF90eXBlX3N0cmluZ19sb25nKHJldCk7CisJCQlldi5hbGVydC5kZXNjcmlwdGlvbiA9IFNTTF9hbGVydF9kZXNjX3N0cmluZ19sb25nKHJldCk7CisJCQl0bHNfZ2xvYmFsLT5ldmVudF9jYih0bHNfZ2xvYmFsLT5jYl9jdHgsIFRMU19BTEVSVCwKKwkJCQkJICAgICAmZXYpOworCQl9CiAJfSBlbHNlIGlmICh3aGVyZSAmIFNTTF9DQl9FWElUICYmIHJldCA8PSAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU1NMOiAlczolcyBpbiAlcyIsCiAJCQkgICBzdHIsIHJldCA9PSAwID8gImZhaWxlZCIgOiAiZXJyb3IiLApAQCAtMTI3NCw2ICsxMjgzLDEwIEBACiAJCQkJICAgICAgIFRMU19GQUlMX1NFUlZFUl9DSEFJTl9QUk9CRSk7CiAJfQogCisJaWYgKHByZXZlcmlmeV9vayAmJiB0bHNfZ2xvYmFsLT5ldmVudF9jYiAhPSBOVUxMKQorCQl0bHNfZ2xvYmFsLT5ldmVudF9jYih0bHNfZ2xvYmFsLT5jYl9jdHgsCisJCQkJICAgICBUTFNfQ0VSVF9DSEFJTl9TVUNDRVNTLCBOVUxMKTsKKwogCXJldHVybiBwcmV2ZXJpZnlfb2s7CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlci5oIGIvc3JjL2RyaXZlcnMvZHJpdmVyLmgKaW5kZXggZjFkNGExNC4uMGFhYjYxZSAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyLmgKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyLmgKQEAgLTEwMCw2ICsxMDAsMTYgQEAKIAkgKi8KIAl1OCBhX21wZHVfcGFyYW1zOwogCisJLyoqCisJICogdmh0X2NhcGFiIC0gVkhUIChJRUVFIDgwMi4xMWFjKSBjYXBhYmlsaXRpZXMKKwkgKi8KKwl1MzIgdmh0X2NhcGFiOworCisJLyoqCisJICogdmh0X21jc19zZXQgLSBWSFQgTUNTIChJRUVFIDgwMi4xMWFjKSByYXRlIHBhcmFtZXRlcnMKKwkgKi8KKwl1OCB2aHRfbWNzX3NldFs4XTsKKwogCXVuc2lnbmVkIGludCBmbGFnczsgLyogSE9TVEFQRF9NT0RFX0ZMQUdfKiAqLwogfTsKIApAQCAtMzMzLDYgKzM0MywxMyBAQAogCWludCBmcmVxOwogCiAJLyoqCisJICogYmdfc2Nhbl9wZXJpb2QgLSBCYWNrZ3JvdW5kIHNjYW4gcGVyaW9kIGluIHNlY29uZHMsIDAgdG8gZGlzYWJsZQorCSAqIGJhY2tncm91bmQgc2Nhbiwgb3IgLTEgdG8gaW5kaWNhdGUgbm8gY2hhbmdlIHRvIGRlZmF1bHQgZHJpdmVyCisJICogY29uZmlndXJhdGlvbgorCSAqLworCWludCBiZ19zY2FuX3BlcmlvZDsKKworCS8qKgogCSAqIHdwYV9pZSAtIFdQQSBpbmZvcm1hdGlvbiBlbGVtZW50IGZvciAoUmUpQXNzb2NpYXRpb24gUmVxdWVzdAogCSAqIFdQQSBpbmZvcm1hdGlvbiBlbGVtZW50IHRvIGJlIGluY2x1ZGVkIGluIChSZSlBc3NvY2lhdGlvbgogCSAqIFJlcXVlc3QgKGluY2x1ZGluZyBpbmZvcm1hdGlvbiBlbGVtZW50IGlkIGFuZCBsZW5ndGgpLiBVc2UKQEAgLTcwNyw2ICs3MjQsMTMgQEAKIAkgKiBlbmFibGVkLgogCSAqLwogCXU4IGFjY2Vzc19uZXR3b3JrX3R5cGU7CisKKwkvKioKKwkgKiBhcF9tYXhfaW5hY3Rpdml0eSAtIFRpbWVvdXQgaW4gc2Vjb25kcyB0byBkZXRlY3QgU1RBJ3MgaW5hY3Rpdml0eQorCSAqCisJICogVGhpcyBpcyB1c2VkIGJ5IGRyaXZlciB3aGljaCBhZHZlcnRpc2VzIHRoaXMgY2FwYWJpbGl0eS4KKwkgKi8KKwlpbnQgYXBfbWF4X2luYWN0aXZpdHk7CiB9OwogCiAvKioKQEAgLTcyNiw2ICs3NTAsNyBAQAogI2RlZmluZSBXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDEwNAkweDAwMDAwMDAyCiAjZGVmaW5lIFdQQV9EUklWRVJfQ0FQQV9FTkNfVEtJUAkweDAwMDAwMDA0CiAjZGVmaW5lIFdQQV9EUklWRVJfQ0FQQV9FTkNfQ0NNUAkweDAwMDAwMDA4CisjZGVmaW5lIFdQQV9EUklWRVJfQ0FQQV9FTkNfV0VQMTI4CTB4MDAwMDAwMTAKIAl1bnNpZ25lZCBpbnQgZW5jOwogCiAjZGVmaW5lIFdQQV9EUklWRVJfQVVUSF9PUEVOCQkweDAwMDAwMDAxCkBAIC03OTAsNiArODE1LDggQEAKICNkZWZpbmUgV1BBX0RSSVZFUl9GTEFHU19QUk9CRV9SRVNQX09GRkxPQUQJCTB4MDAyMDAwMDAKIC8qIERyaXZlciBzdXBwb3J0cyBVLUFQU0QgaW4gQVAgbW9kZSAqLwogI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX0FQX1VBUFNECQkJMHgwMDQwMDAwMAorLyogRHJpdmVyIHN1cHBvcnRzIGluYWN0aXZpdHkgdGltZXIgaW4gQVAgbW9kZSAqLworI2RlZmluZSBXUEFfRFJJVkVSX0ZMQUdTX0lOQUNUSVZJVFlfVElNRVIJCTB4MDA4MDAwMDAKIAl1bnNpZ25lZCBpbnQgZmxhZ3M7CiAKIAlpbnQgbWF4X3NjYW5fc3NpZHM7CkBAIC0yMDAzLDYgKzIwMzAsMTYgQEAKIAlpbnQgKCpkZWluaXRfYXApKHZvaWQgKnByaXYpOwogCiAJLyoqCisJICogZGVpbml0X3AycF9jbGkgLSBEZWluaXRpYWxpemUgUDJQIGNsaWVudCBtb2RlCisJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlIChvciBpZiBub3Qgc3VwcG9ydGVkKQorCSAqCisJICogVGhpcyBvcHRpb25hbCBmdW5jdGlvbiBjYW4gYmUgdXNlZCB0byBkaXNhYmxlIFAyUCBjbGllbnQgbW9kZS4gSXQKKwkgKiBjYW4gYmUgdXNlZCB0byBjaGFuZ2UgdGhlIGludGVyZmFjZSB0eXBlIGJhY2sgdG8gc3RhdGlvbiBtb2RlLgorCSAqLworCWludCAoKmRlaW5pdF9wMnBfY2xpKSh2b2lkICpwcml2KTsKKworCS8qKgogCSAqIHN1c3BlbmQgLSBOb3RpZmljYXRpb24gb24gc3lzdGVtIHN1c3BlbmQvaGliZXJuYXRlIGV2ZW50CiAJICogQHByaXY6IFByaXZhdGUgZHJpdmVyIGludGVyZmFjZSBkYXRhCiAJICovCkBAIC0yNTA4LDE5ICsyNTQ1LDMwIEBACiAJICovCiAJdm9pZCAoKnBvbGxfY2xpZW50KSh2b2lkICpwcml2LCBjb25zdCB1OCAqb3duX2FkZHIsCiAJCQkgICAgY29uc3QgdTggKmFkZHIsIGludCBxb3MpOwotI2lmZGVmIEFORFJPSURfUDJQCisKIAkvKioKLQkgKiBzd2l0Y2hfY2hhbm5lbCAtIEFubm91bmNlIGNoYW5uZWwgc3dpdGNoIGFuZCBtaWdyYXRlIHRoZSBHTyB0byBhCi0JICogZ2l2ZW4gZnJlcXVlbmN5LgorCSAqIHJhZGlvX2Rpc2FibGUgLSBEaXNhYmxlL2VuYWJsZSByYWRpbwogCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQotCSAqIEBmcmVxOiBmcmVxdWVuY3kgaW4gTUh6CisJICogQGRpc2FibGVkOiAxPWRpc2FibGUgMD1lbmFibGUgcmFkaW8KIAkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKIAkgKgotCSAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byBtb3ZlIHRoZSBHTyB0byB0aGUgbGVnYWN5IFNUQSBjaGFubmVsIHRvIGF2b2lkCi0JICogZnJlcXVlbmN5IGNvbmZsaWN0IGluIHNpbmdsZSBjaGFubmVsIGNvbmN1cnJlbmN5LgorCSAqIFRoaXMgb3B0aW9uYWwgY29tbWFuZCBpcyBmb3IgdGVzdGluZyBwdXJwb3Nlcy4gSXQgY2FuIGJlIHVzZWQgdG8KKwkgKiBkaXNhYmxlIHRoZSByYWRpbyBvbiBhIHRlc3RiZWQgZGV2aWNlIHRvIHNpbXVsYXRlIG91dC1vZi1yYWRpby1yYW5nZQorCSAqIGNvbmRpdGlvbnMuCisJICovCisJaW50ICgqcmFkaW9fZGlzYWJsZSkodm9pZCAqcHJpdiwgaW50IGRpc2FibGVkKTsKKworCS8qKgorCSAqIHN3aXRjaF9jaGFubmVsIC0gQW5ub3VuY2UgY2hhbm5lbCBzd2l0Y2ggYW5kIG1pZ3JhdGUgdGhlIEdPIHRvIHRoZQorCSAqIGdpdmVuIGZyZXF1ZW5jeQorCSAqIEBwcml2OiBQcml2YXRlIGRyaXZlciBpbnRlcmZhY2UgZGF0YQorCSAqIEBmcmVxOiBGcmVxdWVuY3kgaW4gTUh6CisJICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCisJICoKKwkgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gbW92ZSB0aGUgR08gdG8gdGhlIGxlZ2FjeSBTVEEgY2hhbm5lbCB0bworCSAqIGF2b2lkIGZyZXF1ZW5jeSBjb25mbGljdCBpbiBzaW5nbGUgY2hhbm5lbCBjb25jdXJyZW5jeS4KIAkgKi8KIAlpbnQgKCpzd2l0Y2hfY2hhbm5lbCkodm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IGZyZXEpOwotI2VuZGlmCiB9OwogCiAKQEAgLTI5NTEsNyArMjk5OSwxNCBAQAogCS8qKgogCSAqIEVWRU5UX0VBUE9MX1RYX1NUQVRVUyAtIG5vdGlmeSBvZiBFQVBPTCBUWCBzdGF0dXMKIAkgKi8KLQlFVkVOVF9FQVBPTF9UWF9TVEFUVVMKKwlFVkVOVF9FQVBPTF9UWF9TVEFUVVMsCisKKwkvKioKKwkgKiBFVkVOVF9DSF9TV0lUQ0ggLSBBUCBvciBHTyBkZWNpZGVkIHRvIHN3aXRjaCBjaGFubmVscworCSAqCisJICogRGVzY3JpYmVkIGluIHdwYV9ldmVudF9kYXRhLmNoX3N3aXRjaAorCSAqICovCisJRVZFTlRfQ0hfU1dJVENICiB9OwogCiAKQEAgLTMyNjcsNyArMzMyMiw3IEBACiAJCWNvbnN0IHU4ICpmcmFtZTsKIAkJc2l6ZV90IGZyYW1lX2xlbjsKIAkJdTMyIGRhdGFyYXRlOwotCQl1MzIgc3NpX3NpZ25hbDsKKwkJaW50IHNzaV9zaWduYWw7IC8qIGRCbSAqLwogCX0gcnhfbWdtdDsKIAogCS8qKgpAQCAtMzM4NSw2ICszNDQwLDExIEBACiAJCSAqIGllX2xlbiAtIExlbmd0aCBvZiBpZSBidWZmZXIgaW4gb2N0ZXRzCiAJCSAqLwogCQlzaXplX3QgaWVfbGVuOworCisJCS8qKgorCQkgKiBzaWduYWwgLSBzaWduYWwgc3RyZW5ndGggaW4gZEJtIChvciAwIGlmIG5vdCBhdmFpbGFibGUpCisJCSAqLworCQlpbnQgc3NpX3NpZ25hbDsKIAl9IHJ4X3Byb2JlX3JlcTsKIAogCS8qKgpAQCAtMzU0MSw2ICszNjAxLDE4IEBACiAJCWludCBkYXRhX2xlbjsKIAkJaW50IGFjazsKIAl9IGVhcG9sX3R4X3N0YXR1czsKKworCS8qKgorCSAqIHN0cnVjdCBjaF9zd2l0Y2gKKwkgKiBAZnJlcTogRnJlcXVlbmN5IG9mIG5ldyBjaGFubmVsIGluIE1IegorCSAqIEBodF9lbmFibGVkOiBXaGV0aGVyIHRoaXMgaXMgYW4gSFQgY2hhbm5lbAorCSAqIEBjaF9vZmZzZXQ6IFNlY29uZGFyeSBjaGFubmVsIG9mZnNldAorCSAqLworCXN0cnVjdCBjaF9zd2l0Y2ggeworCQlpbnQgZnJlcTsKKwkJaW50IGh0X2VuYWJsZWQ7CisJCWludCBjaF9vZmZzZXQ7CisJfSBjaF9zd2l0Y2g7CiB9OwogCiAvKioKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlcl9hdGhlcm9zLmMgYi9zcmMvZHJpdmVycy9kcml2ZXJfYXRoZXJvcy5jCmluZGV4IGIxN2QxYTYuLjczODk4ZDMgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9hdGhlcm9zLmMKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX2F0aGVyb3MuYwpAQCAtNSwxNCArNSw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNywgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqIENvcHlyaWdodCAoYykgMjAwOSwgQXRoZXJvcyBDb21tdW5pY2F0aW9ucwogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpAQCAtMzksMTEgKzMzLDExIEBACiAKICNpZmRlZiBDT05GSUdfV1BTCiAjaW5jbHVkZSA8bmV0cGFja2V0L3BhY2tldC5oPgorI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAogI2lmbmRlZiBFVEhfUF84MDIxMV9SQVcKICNkZWZpbmUgRVRIX1BfODAyMTFfUkFXIDB4MDAxOQogI2VuZGlmCi0jZW5kaWYgLyogQ09ORklHX1dQUyAqLwogCiAjaW5jbHVkZSAibGludXhfd2V4dC5oIgogCkBAIC03Myw2ICs2Nyw3IEBACiAJc3RydWN0IHdwYWJ1ZiAqd3BhX2llOwogCXN0cnVjdCB3cGFidWYgKndwc19iZWFjb25faWU7CiAJc3RydWN0IHdwYWJ1ZiAqd3BzX3Byb2JlX3Jlc3BfaWU7CisJdTgJb3duX2FkZHJbRVRIX0FMRU5dOwogfTsKIAogc3RhdGljIGludCBhdGhlcm9zX3N0YV9kZWF1dGgodm9pZCAqcHJpdiwgY29uc3QgdTggKm93bl9hZGRyLCBjb25zdCB1OCAqYWRkciwKQEAgLTczMiw4ICs3MjcsOCBAQAogfQogCiAjaWZkZWYgQ09ORklHX1dQUwotc3RhdGljIHZvaWQgYXRoZXJvc19yYXdfcmVjZWl2ZSh2b2lkICpjdHgsIGNvbnN0IHU4ICpzcmNfYWRkciwgY29uc3QgdTggKmJ1ZiwKLQkJCQlzaXplX3QgbGVuKQorc3RhdGljIHZvaWQgYXRoZXJvc19yYXdfcmVjdl93cHModm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjX2FkZHIsIGNvbnN0IHU4ICpidWYsCisJCQkJIHNpemVfdCBsZW4pCiB7CiAJc3RydWN0IGF0aGVyb3NfZHJpdmVyX2RhdGEgKmRydiA9IGN0eDsKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7CkBAIC03NjIsMjggKzc1NywxMzkgQEAKIH0KICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKLXN0YXRpYyBpbnQgYXRoZXJvc19yZWNlaXZlX3Byb2JlX3JlcShzdHJ1Y3QgYXRoZXJvc19kcml2ZXJfZGF0YSAqZHJ2KQorI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCitzdGF0aWMgdm9pZCBhdGhlcm9zX3Jhd19yZWN2XzExcih2b2lkICpjdHgsIGNvbnN0IHU4ICpzcmNfYWRkciwgY29uc3QgdTggKmJ1ZiwKKwkJCQkgc2l6ZV90IGxlbikKK3sKKwlzdHJ1Y3QgYXRoZXJvc19kcml2ZXJfZGF0YSAqZHJ2ID0gY3R4OworCXVuaW9uIHdwYV9ldmVudF9kYXRhIGV2ZW50OworCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKKwl1MTYgZmM7CisJdTE2IHN0eXBlOworCWludCBpZWxlbjsKKwljb25zdCB1OCAqaWVidWY7CisKKwkvKiBEbyAxMVIgcHJvY2Vzc2luZyBmb3IgQVNTT0MvQVVUSC9GVCBBQ1RJT04gZnJhbWVzICovCisJaWYgKGxlbiA8IElFRUU4MDIxMV9IRFJMRU4pCisJCXJldHVybjsKKwltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBidWY7CisKKwlmYyA9IGxlX3RvX2hvc3QxNihtZ210LT5mcmFtZV9jb250cm9sKTsKKworCWlmIChXTEFOX0ZDX0dFVF9UWVBFKGZjKSAhPSBXTEFOX0ZDX1RZUEVfTUdNVCkKKwkJcmV0dXJuOworCXN0eXBlID0gV0xBTl9GQ19HRVRfU1RZUEUoZmMpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogc3VidHlwZSAweCV4IGxlbiAlZCIsIF9fZnVuY19fLCBzdHlwZSwKKwkJICAgKGludCkgbGVuKTsKKworCWlmIChvc19tZW1jbXAoZHJ2LT5vd25fYWRkciwgbWdtdC0+YnNzaWQsIEVUSF9BTEVOKSAhPSAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IEJTU0lEIGRvZXMgbm90IG1hdGNoIC0gaWdub3JlIiwKKwkJCSAgIF9fZnVuY19fKTsKKwkJcmV0dXJuOworCX0KKwlzd2l0Y2ggKHN0eXBlKSB7CisJY2FzZSBXTEFOX0ZDX1NUWVBFX0FTU09DX1JFUToKKwkJaWYgKGxlbiAtIElFRUU4MDIxMV9IRFJMRU4gPCBzaXplb2YobWdtdC0+dS5hc3NvY19yZXEpKQorCQkJYnJlYWs7CisJCWllbGVuID0gbGVuIC0gKElFRUU4MDIxMV9IRFJMRU4gKyBzaXplb2YobWdtdC0+dS5hc3NvY19yZXEpKTsKKwkJaWVidWYgPSBtZ210LT51LmFzc29jX3JlcS52YXJpYWJsZTsKKwkJZHJ2X2V2ZW50X2Fzc29jKGRydi0+aGFwZCwgbWdtdC0+c2EsIGllYnVmLCBpZWxlbiwgMCk7CisJCWJyZWFrOworCWNhc2UgV0xBTl9GQ19TVFlQRV9SRUFTU09DX1JFUToKKwkJaWYgKGxlbiAtIElFRUU4MDIxMV9IRFJMRU4gPCBzaXplb2YobWdtdC0+dS5yZWFzc29jX3JlcSkpCisJCQlicmVhazsKKwkJaWVsZW4gPSBsZW4gLSAoSUVFRTgwMjExX0hEUkxFTiArIHNpemVvZihtZ210LT51LnJlYXNzb2NfcmVxKSk7CisJCWllYnVmID0gbWdtdC0+dS5yZWFzc29jX3JlcS52YXJpYWJsZTsKKwkJZHJ2X2V2ZW50X2Fzc29jKGRydi0+aGFwZCwgbWdtdC0+c2EsIGllYnVmLCBpZWxlbiwgMSk7CisJCWJyZWFrOworCWNhc2UgV0xBTl9GQ19TVFlQRV9BQ1RJT046CisJCWlmICgmbWdtdC0+dS5hY3Rpb24uY2F0ZWdvcnkgPiBidWYgKyBsZW4pCisJCQlicmVhazsKKwkJb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7CisJCWV2ZW50LnJ4X2FjdGlvbi5kYSA9IG1nbXQtPmRhOworCQlldmVudC5yeF9hY3Rpb24uc2EgPSBtZ210LT5zYTsKKwkJZXZlbnQucnhfYWN0aW9uLmJzc2lkID0gbWdtdC0+YnNzaWQ7CisJCWV2ZW50LnJ4X2FjdGlvbi5jYXRlZ29yeSA9IG1nbXQtPnUuYWN0aW9uLmNhdGVnb3J5OworCQlldmVudC5yeF9hY3Rpb24uZGF0YSA9ICZtZ210LT51LmFjdGlvbi5jYXRlZ29yeTsKKwkJZXZlbnQucnhfYWN0aW9uLmxlbiA9IGJ1ZiArIGxlbiAtIGV2ZW50LnJ4X2FjdGlvbi5kYXRhOworCQl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmhhcGQsIEVWRU5UX1JYX0FDVElPTiwgJmV2ZW50KTsKKwkJYnJlYWs7CisJY2FzZSBXTEFOX0ZDX1NUWVBFX0FVVEg6CisJCWlmIChsZW4gLSBJRUVFODAyMTFfSERSTEVOIDwgc2l6ZW9mKG1nbXQtPnUuYXV0aCkpCisJCQlicmVhazsKKwkJb3NfbWVtc2V0KCZldmVudCwgMCwgc2l6ZW9mKGV2ZW50KSk7CisJCW9zX21lbWNweShldmVudC5hdXRoLnBlZXIsIG1nbXQtPnNhLCBFVEhfQUxFTik7CisJCW9zX21lbWNweShldmVudC5hdXRoLmJzc2lkLCBtZ210LT5ic3NpZCwgRVRIX0FMRU4pOworCQlldmVudC5hdXRoLmF1dGhfdHlwZSA9IGxlX3RvX2hvc3QxNihtZ210LT51LmF1dGguYXV0aF9hbGcpOworCQlldmVudC5hdXRoLnN0YXR1c19jb2RlID0KKwkJCWxlX3RvX2hvc3QxNihtZ210LT51LmF1dGguc3RhdHVzX2NvZGUpOworCQlldmVudC5hdXRoLmF1dGhfdHJhbnNhY3Rpb24gPQorCQkJbGVfdG9faG9zdDE2KG1nbXQtPnUuYXV0aC5hdXRoX3RyYW5zYWN0aW9uKTsKKwkJZXZlbnQuYXV0aC5pZXMgPSBtZ210LT51LmF1dGgudmFyaWFibGU7CisJCWV2ZW50LmF1dGguaWVzX2xlbiA9IGxlbiAtIElFRUU4MDIxMV9IRFJMRU4gLQorCQkJc2l6ZW9mKG1nbXQtPnUuYXV0aCk7CisJCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+aGFwZCwgRVZFTlRfQVVUSCwgJmV2ZW50KTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorfQorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCisKKyNpZiBkZWZpbmVkKENPTkZJR19XUFMpIHx8IGRlZmluZWQoQ09ORklHX0lFRUU4MDIxMVIpCitzdGF0aWMgdm9pZCBhdGhlcm9zX3Jhd19yZWNlaXZlKHZvaWQgKmN0eCwgY29uc3QgdTggKnNyY19hZGRyLCBjb25zdCB1OCAqYnVmLAorCQkJCXNpemVfdCBsZW4pCit7CisjaWZkZWYgQ09ORklHX1dQUworCWF0aGVyb3NfcmF3X3JlY3Zfd3BzKGN0eCwgc3JjX2FkZHIsIGJ1ZiwgbGVuKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTICovCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKKwlhdGhlcm9zX3Jhd19yZWN2XzExcihjdHgsIHNyY19hZGRyLCBidWYsIGxlbik7CisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KK30KKyNlbmRpZiAvKiBDT05GSUdfV1BTIHx8IENPTkZJR19JRUVFODAyMTFSICovCisKK3N0YXRpYyBpbnQgYXRoZXJvc19yZWNlaXZlX3BrdChzdHJ1Y3QgYXRoZXJvc19kcml2ZXJfZGF0YSAqZHJ2KQogewogCWludCByZXQgPSAwOwotI2lmZGVmIENPTkZJR19XUFMKIAlzdHJ1Y3QgaWVlZTgwMjExcmVxX3NldF9maWx0ZXIgZmlsdDsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMgRW50ZXIiLCBfX2Z1bmNfXyk7Ci0JZmlsdC5hcHBfZmlsdGVyeXBlID0gSUVFRTgwMjExX0ZJTFRFUl9UWVBFX1BST0JFX1JFUTsKKwlmaWx0LmFwcF9maWx0ZXJ5cGUgPSAwOworI2lmZGVmIENPTkZJR19XUFMKKwlmaWx0LmFwcF9maWx0ZXJ5cGUgfD0gSUVFRTgwMjExX0ZJTFRFUl9UWVBFX1BST0JFX1JFUTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTICovCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKKwlmaWx0LmFwcF9maWx0ZXJ5cGUgfD0gKElFRUU4MDIxMV9GSUxURVJfVFlQRV9BU1NPQ19SRVEgfAorCQkJICAgICAgIElFRUU4MDIxMV9GSUxURVJfVFlQRV9BVVRIKTsKKyNlbmRpZgorCWlmIChmaWx0LmFwcF9maWx0ZXJ5cGUpIHsKKwkJcmV0ID0gc2V0ODAyMTFwcml2KGRydiwgSUVFRTgwMjExX0lPQ1RMX0ZJTFRFUkZSQU1FLCAmZmlsdCwKKwkJCQkgICBzaXplb2Yoc3RydWN0IGllZWU4MDIxMXJlcV9zZXRfZmlsdGVyKSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCX0KIAotCXJldCA9IHNldDgwMjExcHJpdihkcnYsIElFRUU4MDIxMV9JT0NUTF9GSUxURVJGUkFNRSwgJmZpbHQsCi0JCQkgICBzaXplb2Yoc3RydWN0IGllZWU4MDIxMXJlcV9zZXRfZmlsdGVyKSk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKLQorI2lmIGRlZmluZWQoQ09ORklHX1dQUykgfHwgZGVmaW5lZChDT05GSUdfSUVFRTgwMjExUikKIAlkcnYtPnNvY2tfcmF3ID0gbDJfcGFja2V0X2luaXQoZHJ2LT5pZmFjZSwgTlVMTCwgRVRIX1BfODAyMTFfUkFXLAogCQkJCSAgICAgICBhdGhlcm9zX3Jhd19yZWNlaXZlLCBkcnYsIDEpOwogCWlmIChkcnYtPnNvY2tfcmF3ID09IE5VTEwpCiAJCXJldHVybiAtMTsKLSNlbmRpZiAvKiBDT05GSUdfV1BTICovCisjZW5kaWYgLyogQ09ORklHX1dQUyB8fCBDT05GSUdfSUVFRTgwMjExUiAqLworCWlmIChsMl9wYWNrZXRfZ2V0X293bl9hZGRyKGRydi0+c29ja194bWl0LCBkcnYtPm93bl9hZGRyKSkKKwkJcmV0dXJuIC0xOwogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBpbnQgYXRoZXJvc19yZXNldF9hcHBmaWx0ZXIoc3RydWN0IGF0aGVyb3NfZHJpdmVyX2RhdGEgKmRydikKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExcmVxX3NldF9maWx0ZXIgZmlsdDsKKwlmaWx0LmFwcF9maWx0ZXJ5cGUgPSAwOworCXJldHVybiBzZXQ4MDIxMXByaXYoZHJ2LCBJRUVFODAyMTFfSU9DVExfRklMVEVSRlJBTUUsICZmaWx0LAorCQkJICAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExcmVxX3NldF9maWx0ZXIpKTsKK30KKwogI2lmZGVmIENPTkZJR19XUFMKIHN0YXRpYyBpbnQKIGF0aGVyb3Nfc2V0X3dwc19pZSh2b2lkICpwcml2LCBjb25zdCB1OCAqaWUsIHNpemVfdCBsZW4sIHUzMiBmcmFtZXR5cGUpCkBAIC04NTIsNiArOTU4LDg0IEBACiAjZGVmaW5lIGF0aGVyb3Nfc2V0X2FwX3dwc19pZSBOVUxMCiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLwogCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKK3N0YXRpYyBpbnQKK2F0aGVyb3Nfc3RhX2F1dGgodm9pZCAqcHJpdiwgY29uc3QgdTggKm93bl9hZGRyLCBjb25zdCB1OCAqYWRkciwgdTE2IHNlcSwKKwkJIHUxNiBzdGF0dXNfY29kZSwgY29uc3QgdTggKmllLCBzaXplX3QgbGVuKQoreworCXN0cnVjdCBhdGhlcm9zX2RyaXZlcl9kYXRhICpkcnYgPSBwcml2OworCXN0cnVjdCBpZWVlODAyMTFyZXFfbWxtZSBtbG1lOworCWludCByZXQ7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBhZGRyPSVzIHN0YXR1c19jb2RlPSVkIiwKKwkJICAgX19mdW5jX18sIGV0aGVyX3NwcmludGYoYWRkciksIHN0YXR1c19jb2RlKTsKKworCW1sbWUuaW1fb3AgPSBJRUVFODAyMTFfTUxNRV9BVVRIOworCW1sbWUuaW1fcmVhc29uID0gc3RhdHVzX2NvZGU7CisJbWxtZS5pbV9zZXEgPSBzZXE7CisJb3NfbWVtY3B5KG1sbWUuaW1fbWFjYWRkciwgYWRkciwgSUVFRTgwMjExX0FERFJfTEVOKTsKKwltbG1lLmltX29wdGllX2xlbiA9IGxlbjsKKwlpZiAobGVuKSB7CisJCWlmIChsZW4gPCBJRUVFODAyMTFfTUFYX09QVF9JRSkgeworCQkJb3NfbWVtY3B5KG1sbWUuaW1fb3B0aWUsIGllLCBsZW4pOworCQl9IGVsc2UgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogTm90IGVub3VnaCBzcGFjZSB0byBjb3B5ICIKKwkJCQkgICAib3B0X2llIFNUQSAoYWRkciAiIE1BQ1NUUiAiIHJlYXNvbiAlZCwgIgorCQkJCSAgICJpZV9sZW4gJWQpIiwKKwkJCQkgICBfX2Z1bmNfXywgTUFDMlNUUihhZGRyKSwgc3RhdHVzX2NvZGUsCisJCQkJICAgKGludCkgbGVuKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKwlyZXQgPSBzZXQ4MDIxMXByaXYoZHJ2LCBJRUVFODAyMTFfSU9DVExfU0VUTUxNRSwgJm1sbWUsIHNpemVvZihtbG1lKSk7CisJaWYgKHJldCA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlczogRmFpbGVkIHRvIGF1dGggU1RBIChhZGRyICIgTUFDU1RSCisJCQkgICAiIHJlYXNvbiAlZCkiLAorCQkJICAgX19mdW5jX18sIE1BQzJTVFIoYWRkciksIHN0YXR1c19jb2RlKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludAorYXRoZXJvc19zdGFfYXNzb2Modm9pZCAqcHJpdiwgY29uc3QgdTggKm93bl9hZGRyLCBjb25zdCB1OCAqYWRkciwKKwkJICBpbnQgcmVhc3NvYywgdTE2IHN0YXR1c19jb2RlLCBjb25zdCB1OCAqaWUsIHNpemVfdCBsZW4pCit7CisJc3RydWN0IGF0aGVyb3NfZHJpdmVyX2RhdGEgKmRydiA9IHByaXY7CisJc3RydWN0IGllZWU4MDIxMXJlcV9tbG1lIG1sbWU7CisJaW50IHJldDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXM6IGFkZHI9JXMgc3RhdHVzX2NvZGU9JWQgcmVhc3NvYyAlZCIsCisJCSAgIF9fZnVuY19fLCBldGhlcl9zcHJpbnRmKGFkZHIpLCBzdGF0dXNfY29kZSwgcmVhc3NvYyk7CisKKwlpZiAocmVhc3NvYykKKwkJbWxtZS5pbV9vcCA9IElFRUU4MDIxMV9NTE1FX1JFQVNTT0M7CisJZWxzZQorCQltbG1lLmltX29wID0gSUVFRTgwMjExX01MTUVfQVNTT0M7CisJbWxtZS5pbV9yZWFzb24gPSBzdGF0dXNfY29kZTsKKwlvc19tZW1jcHkobWxtZS5pbV9tYWNhZGRyLCBhZGRyLCBJRUVFODAyMTFfQUREUl9MRU4pOworCW1sbWUuaW1fb3B0aWVfbGVuID0gbGVuOworCWlmIChsZW4pIHsKKwkJaWYgKGxlbiA8IElFRUU4MDIxMV9NQVhfT1BUX0lFKSB7CisJCQlvc19tZW1jcHkobWxtZS5pbV9vcHRpZSwgaWUsIGxlbik7CisJCX0gZWxzZSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBOb3QgZW5vdWdoIHNwYWNlIHRvIGNvcHkgIgorCQkJCSAgICJvcHRfaWUgU1RBIChhZGRyICIgTUFDU1RSICIgcmVhc29uICVkLCAiCisJCQkJICAgImllX2xlbiAlZCkiLAorCQkJCSAgIF9fZnVuY19fLCBNQUMyU1RSKGFkZHIpLCBzdGF0dXNfY29kZSwKKwkJCQkgICAoaW50KSBsZW4pOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCXJldCA9IHNldDgwMjExcHJpdihkcnYsIElFRUU4MDIxMV9JT0NUTF9TRVRNTE1FLCAmbWxtZSwgc2l6ZW9mKG1sbWUpKTsKKwlpZiAocmV0IDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzOiBGYWlsZWQgdG8gYXNzb2MgU1RBIChhZGRyICIgTUFDU1RSCisJCQkgICAiIHJlYXNvbiAlZCkiLAorCQkJICAgX19mdW5jX18sIE1BQzJTVFIoYWRkciksIHN0YXR1c19jb2RlKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKyNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExUiAqLworCiBzdGF0aWMgdm9pZAogYXRoZXJvc19uZXdfc3RhKHN0cnVjdCBhdGhlcm9zX2RyaXZlcl9kYXRhICpkcnYsIHU4IGFkZHJbSUVFRTgwMjExX0FERFJfTEVOXSkKIHsKQEAgLTk4MCw2ICsxMTY0LDkgQEAKIAkJICogc28gYWxsIGFyZSBlbmFibGVkIGZvciBXUFMuLi4gdWdoLgogCQkgKi8KIAkJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5oYXBkLCBFVkVOVF9XUFNfQlVUVE9OX1BVU0hFRCwgTlVMTCk7CisjZW5kaWYgLyogQ09ORklHX1dQUyAqLworI2lmIGRlZmluZWQoQ09ORklHX1dQUykgfHwgZGVmaW5lZChDT05GSUdfSUVFRTgwMjExUikKKyNkZWZpbmUgV1BTX0ZSQU1fVEFHX1NJWkUgMzAgLyogaGFyZGNvZGVkIGluIGRyaXZlciAqLwogCX0gZWxzZSBpZiAoc3RybmNtcChjdXN0b20sICJNYW5hZ2UucHJvYl9yZXEgIiwgMTYpID09IDApIHsKIAkJLyoKIAkJICogQXRoZXJvcyBkcml2ZXIgdXNlcyBhIGhhY2sgdG8gcGFzcyBQcm9iZSBSZXF1ZXN0IGZyYW1lcyBhcyBhCkBAIC05ODcsNyArMTE3NCw2IEBACiAJCSAqIHBhY2tldCBzbmlmZmluZykgZGlkbid0IHdvcmsgd2hlbiBicmlkZ2luZy4KIAkJICogRm9ybWF0OiAiTWFuYWdlLnByb2JfcmVxIDxmcmFtZSBsZW4+IiB8IHplcm8gcGFkZGluZyB8IGZyYW1lCiAJCSAqLwotI2RlZmluZSBXUFNfRlJBTV9UQUdfU0laRSAzMCAvKiBoYXJkY29kZWQgaW4gZHJpdmVyICovCiAJCWludCBsZW4gPSBhdG9pKGN1c3RvbSArIDE2KTsKIAkJaWYgKGxlbiA8IDAgfHwgY3VzdG9tICsgV1BTX0ZSQU1fVEFHX1NJWkUgKyBsZW4gPiBlbmQpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW52YWxpZCBNYW5hZ2UucHJvYl9yZXEgZXZlbnQgIgpAQCAtOTk2LDcgKzExODIsNDAgQEAKIAkJfQogCQlhdGhlcm9zX3Jhd19yZWNlaXZlKGRydiwgTlVMTCwKIAkJCQkgICAgKHU4ICopIGN1c3RvbSArIFdQU19GUkFNX1RBR19TSVpFLCBsZW4pOwotI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KKwl9IGVsc2UgaWYgKHN0cm5jbXAoY3VzdG9tLCAiTWFuYWdlLmFzc29jX3JlcSAiLCAxNykgPT0gMCkgeworCQkvKiBGb3JtYXQ6ICJNYW5hZ2UuYXNzb2NfcmVxIDxmcmFtZSBsZW4+IiB8IHplcm8gcGFkZGluZyB8CisJCSAqIGZyYW1lICovCisJCWludCBsZW4gPSBhdG9pKGN1c3RvbSArIDE3KTsKKwkJaWYgKGxlbiA8IDAgfHwgY3VzdG9tICsgV1BTX0ZSQU1fVEFHX1NJWkUgKyBsZW4gPiBlbmQpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW52YWxpZCBNYW5hZ2UucHJvYl9yZXEvIgorCQkJCSAgICJhc3NvY19yZXEvYXV0aCBldmVudCBsZW5ndGggJWQiLCBsZW4pOworCQkJcmV0dXJuOworCQl9CisJCWF0aGVyb3NfcmF3X3JlY2VpdmUoZHJ2LCBOVUxMLAorCQkJCSAgICAodTggKikgY3VzdG9tICsgV1BTX0ZSQU1fVEFHX1NJWkUsIGxlbik7CisJfSBlbHNlIGlmIChzdHJuY21wKGN1c3RvbSwgIk1hbmFnZS5hY3Rpb24gIiwgMTQpID09IDApIHsKKwkJLyogRm9ybWF0OiAiTWFuYWdlLmFzc29jX3JlcSA8ZnJhbWUgbGVuPiIgfCB6ZXJvIHBhZGRpbmcgfAorCQkgKiBmcmFtZSAqLworCQlpbnQgbGVuID0gYXRvaShjdXN0b20gKyAxNCk7CisJCWlmIChsZW4gPCAwIHx8IGN1c3RvbSArIFdQU19GUkFNX1RBR19TSVpFICsgbGVuID4gZW5kKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludmFsaWQgTWFuYWdlLnByb2JfcmVxLyIKKwkJCQkgICAiYXNzb2NfcmVxL2F1dGggZXZlbnQgbGVuZ3RoICVkIiwgbGVuKTsKKwkJCXJldHVybjsKKwkJfQorCQlhdGhlcm9zX3Jhd19yZWNlaXZlKGRydiwgTlVMTCwKKwkJCQkgICAgKHU4ICopIGN1c3RvbSArIFdQU19GUkFNX1RBR19TSVpFLCBsZW4pOworCX0gZWxzZSBpZiAoc3RybmNtcChjdXN0b20sICJNYW5hZ2UuYXV0aCAiLCAxMikgPT0gMCkgeworCQkvKiBGb3JtYXQ6ICJNYW5hZ2UuYXV0aCA8ZnJhbWUgbGVuPiIgfCB6ZXJvIHBhZGRpbmcgfCBmcmFtZQorCQkgKi8KKwkJaW50IGxlbiA9IGF0b2koY3VzdG9tICsgMTIpOworCQlpZiAobGVuIDwgMCB8fCBjdXN0b20gKyBXUFNfRlJBTV9UQUdfU0laRSArIGxlbiA+IGVuZCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnZhbGlkIE1hbmFnZS5wcm9iX3JlcS8iCisJCQkJICAgImFzc29jX3JlcS9hdXRoIGV2ZW50IGxlbmd0aCAlZCIsIGxlbik7CisJCQlyZXR1cm47CisJCX0KKwkJYXRoZXJvc19yYXdfcmVjZWl2ZShkcnYsIE5VTEwsCisJCQkJICAgICh1OCAqKSBjdXN0b20gKyBXUFNfRlJBTV9UQUdfU0laRSwgbGVuKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTIG9yIENPTkZJR19JRUVFODAyMTFSICovCiAJfQogfQogCkBAIC0xMjc4LDcgKzE0OTcsNyBAQAogCWxpbnV4X3NldF9pZmFjZV9mbGFncyhkcnYtPmlvY3RsX3NvY2ssIGRydi0+aWZhY2UsIDApOwogCWF0aGVyb3Nfc2V0X3ByaXZhY3koZHJ2LCAwKTsgLyogZGVmYXVsdCB0byBubyBwcml2YWN5ICovCiAKLQlhdGhlcm9zX3JlY2VpdmVfcHJvYmVfcmVxKGRydik7CisJYXRoZXJvc19yZWNlaXZlX3BrdChkcnYpOwogCiAJaWYgKGF0aGVyb3Nfd2lyZWxlc3NfZXZlbnRfaW5pdChkcnYpKQogCQlnb3RvIGJhZDsKQEAgLTEzMDIsNiArMTUyMSw3IEBACiB7CiAJc3RydWN0IGF0aGVyb3NfZHJpdmVyX2RhdGEgKmRydiA9IHByaXY7CiAKKwlhdGhlcm9zX3Jlc2V0X2FwcGZpbHRlcihkcnYpOwogCW5ldGxpbmtfZGVpbml0KGRydi0+bmV0bGluayk7CiAJKHZvaWQpIGxpbnV4X3NldF9pZmFjZV9mbGFncyhkcnYtPmlvY3RsX3NvY2ssIGRydi0+aWZhY2UsIDApOwogCWlmIChkcnYtPmlvY3RsX3NvY2sgPj0gMCkKQEAgLTEzNDgsNyArMTU2OCw2IEBACiAJbWVtc2V0KCZpd3IsIDAsIHNpemVvZihpd3IpKTsKIAlvc19zdHJsY3B5KGl3ci5pZnJfbmFtZSwgZHJ2LT5pZmFjZSwgSUZOQU1TSVopOwogCWl3ci51LmVzc2lkLnBvaW50ZXIgPSAoY2FkZHJfdCkgYnVmOwotCWl3ci51LmVzc2lkLmxlbmd0aCA9IGxlbjsKIAlpd3IudS5lc3NpZC5sZW5ndGggPSAobGVuID4gSVdfRVNTSURfTUFYX1NJWkUpID8KIAkJSVdfRVNTSURfTUFYX1NJWkUgOiBsZW47CiAKQEAgLTE0MjEsNiArMTY0MCw3NSBAQAogCXJldHVybiAwOwogfQogCisKKyNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgorCitzdGF0aWMgaW50IGF0aGVyb3Nfc2VuZF9tZ210KHZvaWQgKnByaXYsIGNvbnN0IHU4ICpmcm0sIHNpemVfdCBkYXRhX2xlbiwKKwkJCSAgICAgaW50IG5vYWNrKQoreworCXN0cnVjdCBhdGhlcm9zX2RyaXZlcl9kYXRhICpkcnYgPSBwcml2OworCXU4IGJ1ZlsxNTEwXTsKKwljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7CisJc3RydWN0IGllZWU4MDIxMXJlcV9tZ210YnVmICptZ210X2ZybTsKKworCW1nbXQgPSAoY29uc3Qgc3RydWN0IGllZWU4MDIxMV9tZ210ICopIGZybTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIGZybWxlbiA9ICVsdSAiIE1BQ1NUUiwgX19mdW5jX18sCisJCSAgICh1bnNpZ25lZCBsb25nKSBkYXRhX2xlbiwgTUFDMlNUUihtZ210LT5kYSkpOworCW1nbXRfZnJtID0gKHN0cnVjdCBpZWVlODAyMTFyZXFfbWdtdGJ1ZiAqKSBidWY7CisJbWVtY3B5KG1nbXRfZnJtLT5tYWNhZGRyLCAodTggKiltZ210LT5kYSwgSUVFRTgwMjExX0FERFJfTEVOKTsKKwltZ210X2ZybS0+YnVmbGVuID0gZGF0YV9sZW47CisJaWYgKCZtZ210X2ZybS0+YnVmWzBdICsgZGF0YV9sZW4gPiBidWYgKyBzaXplb2YoYnVmKSkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiYXRoZXJvczogVG9vIGxvbmcgZnJhbWUgZm9yICIKKwkJCSAgICJhdGhlcm9zX3NlbmRfbWdtdCAoJXUpIiwgKHVuc2lnbmVkIGludCkgZGF0YV9sZW4pOworCQlyZXR1cm4gLTE7CisJfQorCW9zX21lbWNweSgmbWdtdF9mcm0tPmJ1ZlswXSwgZnJtLCBkYXRhX2xlbik7CisJcmV0dXJuIHNldDgwMjExcHJpdihkcnYsIElFRUU4MDIxMV9JT0NUTF9TRU5EX01HTVQsIG1nbXRfZnJtLAorCQkJICAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExcmVxX21nbXRidWYpICsgZGF0YV9sZW4pOworfQorCisKK3N0YXRpYyBpbnQgYXRoZXJvc19hZGRfdHNwZWModm9pZCAqcHJpdiwgY29uc3QgdTggKmFkZHIsIHU4ICp0c3BlY19pZSwKKwkJCSAgICAgc2l6ZV90IHRzcGVjX2llbGVuKQoreworCXN0cnVjdCBhdGhlcm9zX2RyaXZlcl9kYXRhICpkcnYgPSBwcml2OworCWludCByZXR2OworCXN0cnVjdCBpZWVlODAyMTFyZXFfcmVzIHJlcTsKKwlzdHJ1Y3QgaWVlZTgwMjExcmVxX3Jlc19hZGR0cyAqYWRkdHMgPSAmcmVxLnUuYWRkdHM7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiVzIiwgX19mdW5jX18pOworCXJlcS50eXBlID0gSUVFRTgwMjExX1JFU1JFUV9BRERUUzsKKwlvc19tZW1jcHkoJnJlcS5tYWNhZGRyWzBdLCBhZGRyLCBJRUVFODAyMTFfQUREUl9MRU4pOworCW9zX21lbWNweShhZGR0cy0+dHNwZWNpZSwgdHNwZWNfaWUsIHRzcGVjX2llbGVuKTsKKwlyZXR2ID0gc2V0ODAyMTFwcml2KGRydiwgSUVFRTgwMjExX0lPQ1RMX1JFU19SRVEsICZyZXEsCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBpZWVlODAyMTFyZXFfcmVzKSk7CisJaWYgKHJldHYgPCAwKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiJXMgSUVFRTgwMjExX0lPQ1RMX1JFU19SRVEgRkFJTEVEICIKKwkJCSAgICJyZXR2ID0gJWQiLCBfX2Z1bmNfXywgcmV0dik7CisJCXJldHVybiAtMTsKKwl9CisJb3NfbWVtY3B5KHRzcGVjX2llLCBhZGR0cy0+dHNwZWNpZSwgdHNwZWNfaWVsZW4pOworCXJldHVybiBhZGR0cy0+c3RhdHVzOworfQorCisKK3N0YXRpYyBpbnQgYXRoZXJvc19hZGRfc3RhX25vZGUodm9pZCAqcHJpdiwgY29uc3QgdTggKmFkZHIsIHUxNiBhdXRoX2FsZykKK3sKKwlzdHJ1Y3QgYXRoZXJvc19kcml2ZXJfZGF0YSAqZHJ2ID0gcHJpdjsKKwlzdHJ1Y3QgaWVlZTgwMjExcmVxX3JlcyByZXE7CisJc3RydWN0IGllZWU4MDIxMXJlcV9yZXNfYWRkbm9kZSAqYWRkbm9kZSA9ICZyZXEudS5hZGRub2RlOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyIsIF9fZnVuY19fKTsKKwlyZXEudHlwZSA9IElFRUU4MDIxMV9SRVNSRVFfQURETk9ERTsKKwlvc19tZW1jcHkoJnJlcS5tYWNhZGRyWzBdLCBhZGRyLCBJRUVFODAyMTFfQUREUl9MRU4pOworCWFkZG5vZGUtPmF1dGhfYWxnID0gYXV0aF9hbGc7CisJcmV0dXJuIHNldDgwMjExcHJpdihkcnYsIElFRUU4MDIxMV9JT0NUTF9SRVNfUkVRLCAmcmVxLAorCQkJICAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExcmVxX3JlcykpOworfQorCisjZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KKworCiBjb25zdCBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgd3BhX2RyaXZlcl9hdGhlcm9zX29wcyA9IHsKIAkubmFtZQkJCT0gImF0aGVyb3MiLAogCS5oYXBkX2luaXQJCT0gYXRoZXJvc19pbml0LApAQCAtMTQ0NCw0ICsxNzMyLDExIEBACiAJLnNldF9hcF93cHNfaWUJCT0gYXRoZXJvc19zZXRfYXBfd3BzX2llLAogCS5zZXRfYXV0aG1vZGUJCT0gYXRoZXJvc19zZXRfYXV0aG1vZGUsCiAJLnNldF9hcAkJCT0gYXRoZXJvc19zZXRfYXAsCisjaWZkZWYgQ09ORklHX0lFRUU4MDIxMVIKKwkuc3RhX2Fzc29jICAgICAgICAgICAgICA9IGF0aGVyb3Nfc3RhX2Fzc29jLAorCS5zdGFfYXV0aCAgICAgICAgICAgICAgID0gYXRoZXJvc19zdGFfYXV0aCwKKwkuc2VuZF9tbG1lICAgICAgIAk9IGF0aGVyb3Nfc2VuZF9tZ210LAorCS5hZGRfdHNwZWMgICAgICAJPSBhdGhlcm9zX2FkZF90c3BlYywKKwkuYWRkX3N0YV9ub2RlICAgIAk9IGF0aGVyb3NfYWRkX3N0YV9ub2RlLAorI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCiB9OwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX2JzZC5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX2JzZC5jCmluZGV4IDQ1OTZhNTEuLjY3YWJiNjcgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9ic2QuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfYnNkLmMKQEAgLTMsMTQgKzMsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA0LCBTYW0gTGVmZmxlciA8c2FtQGVycm5vLmNvbT4KICAqIENvcHlyaWdodCAoYykgMjAwNCwgMldpcmUsIEluYwogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX2NvbW1vbi5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX2NvbW1vbi5jCmluZGV4IDM0NWU4NTEuLjgxODU2YWEgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9jb21tb24uYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfY29tbW9uLmMKQEAgLTc3LDYgKzc3LDcgQEAKIAlFMlMoU0NIRURfU0NBTl9TVE9QUEVEKTsKIAlFMlMoRFJJVkVSX0NMSUVOVF9QT0xMX09LKTsKIAlFMlMoRUFQT0xfVFhfU1RBVFVTKTsKKwlFMlMoQ0hfU1dJVENIKTsKIAl9CiAKIAlyZXR1cm4gIlVOS05PV04iOwpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX21hZHdpZmkuYyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9tYWR3aWZpLmMKaW5kZXggZWRiMDg2Zi4uYmI0ODAxMSAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX21hZHdpZmkuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfbWFkd2lmaS5jCkBAIC00LDE0ICs0LDggQEAKICAqIENvcHlyaWdodCAoYykgMjAwNCwgVmlkZW81NCBUZWNobm9sb2dpZXMKICAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA3LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICoKICAqIFdoaWxlIHRoaXMgZHJpdmVyIHdyYXBwZXIgc3VwcG9ydHMgYm90aCBBUCAoaG9zdGFwZCkgYW5kIHN0YXRpb24KICAqICh3cGFfc3VwcGxpY2FudCkgb3BlcmF0aW9ucywgdGhlIHN0YXRpb24gc2lkZSBpcyBkZXByZWNhdGVkIGFuZApkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX25sODAyMTEuYyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9ubDgwMjExLmMKaW5kZXggODc5NTEwNC4uZDU0ZDBmNSAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX25sODAyMTEuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfbmw4MDIxMS5jCkBAIC0xODksNiArMTg5LDcgQEAKIAl1bnNpZ25lZCBpbnQgYmVhY29uX3NldDoxOwogCXVuc2lnbmVkIGludCBhZGRlZF9pZl9pbnRvX2JyaWRnZToxOwogCXVuc2lnbmVkIGludCBhZGRlZF9icmlkZ2U6MTsKKwl1bnNpZ25lZCBpbnQgaW5fZGVpbml0OjE7CiAKIAl1OCBhZGRyW0VUSF9BTEVOXTsKIApAQCAtNDU2LDYgKzQ1Nyw3IEBACiAJCQkgICAgIHZhbGlkX2RhdGEpOwogfQogCisKIGludCBzZW5kX2FuZF9yZWN2X21zZ3Moc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCiAJCQkgICAgICBzdHJ1Y3QgbmxfbXNnICptc2csCiAJCQkgICAgICBpbnQgKCp2YWxpZF9oYW5kbGVyKShzdHJ1Y3QgbmxfbXNnICosIHZvaWQgKiksCkBAIC03OTcsMTAgKzc5OSwyOCBAQAogCQkgICBkZWwgPyAicmVtb3ZlZCIgOiAiYWRkZWQiKTsKIAogCWlmIChvc19zdHJjbXAoZHJ2LT5maXJzdF9ic3MuaWZuYW1lLCBldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkgPT0gMCkgewotCQlpZiAoZGVsKQorCQlpZiAoZGVsKSB7CisJCQlpZiAoZHJ2LT5pZl9yZW1vdmVkKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBpZl9yZW1vdmVkICIKKwkJCQkJICAgImFscmVhZHkgc2V0IC0gaWdub3JlIGV2ZW50Iik7CisJCQkJcmV0dXJuOworCQkJfQogCQkJZHJ2LT5pZl9yZW1vdmVkID0gMTsKLQkJZWxzZQorCQl9IGVsc2UgeworCQkJaWYgKGlmX25hbWV0b2luZGV4KGRydi0+Zmlyc3RfYnNzLmlmbmFtZSkgPT0gMCkgeworCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogSW50ZXJmYWNlICVzICIKKwkJCQkJICAgImRvZXMgbm90IGV4aXN0IC0gaWdub3JlICIKKwkJCQkJICAgIlJUTV9ORVdMSU5LIiwKKwkJCQkJICAgZHJ2LT5maXJzdF9ic3MuaWZuYW1lKTsKKwkJCQlyZXR1cm47CisJCQl9CisJCQlpZiAoIWRydi0+aWZfcmVtb3ZlZCkgeworCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogaWZfcmVtb3ZlZCAiCisJCQkJCSAgICJhbHJlYWR5IGNsZWFyZWQgLSBpZ25vcmUgZXZlbnQiKTsKKwkJCQlyZXR1cm47CisJCQl9CiAJCQlkcnYtPmlmX3JlbW92ZWQgPSAwOworCQl9CiAJfQogCiAJd3BhX3N1cHBsaWNhbnRfZXZlbnQoZHJ2LT5jdHgsIEVWRU5UX0lOVEVSRkFDRV9TVEFUVVMsICZldmVudCk7CkBAIC05MTcsNiArOTM3LDE0IEBACiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSBpbnRlcmZhY2UgdXAgIgogCQkJCSAgICJldmVudCBzaW5jZSBpbnRlcmZhY2UgJXMgaXMgZG93biIsCiAJCQkJICAgbmFtZWJ1Zik7CisJCX0gZWxzZSBpZiAoaWZfbmFtZXRvaW5kZXgoZHJ2LT5maXJzdF9ic3MuaWZuYW1lKSA9PSAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSBpbnRlcmZhY2UgdXAgIgorCQkJCSAgICJldmVudCBzaW5jZSBpbnRlcmZhY2UgJXMgZG9lcyBub3QgZXhpc3QiLAorCQkJCSAgIGRydi0+Zmlyc3RfYnNzLmlmbmFtZSk7CisJCX0gZWxzZSBpZiAoZHJ2LT5pZl9yZW1vdmVkKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IElnbm9yZSBpbnRlcmZhY2UgdXAgIgorCQkJCSAgICJldmVudCBzaW5jZSBpbnRlcmZhY2UgJXMgaXMgbWFya2VkICIKKwkJCQkgICAicmVtb3ZlZCIsIGRydi0+Zmlyc3RfYnNzLmlmbmFtZSk7CiAJCX0gZWxzZSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IEludGVyZmFjZSB1cCIpOwogCQkJZHJ2LT5pZl9kaXNhYmxlZCA9IDA7CkBAIC0xMTAzLDYgKzExMzEsNyBAQAogCX0KIAogCWV2ZW50LmFzc29jX2luZm8uZnJlcSA9IGRydi0+YXNzb2NfZnJlcTsKKwogCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9BU1NPQywgJmV2ZW50KTsKIH0KIApAQCAtMTE3Niw5ICsxMjA1LDQzIEBACiAJZHJ2LT5hc3NvY2lhdGVkID0gMDsKIAlvc19tZW1zZXQoJmRhdGEsIDAsIHNpemVvZihkYXRhKSk7CiAJaWYgKHJlYXNvbikKLQkJZGF0YS5kaXNhc3NvY19pbmZvLnJlYXNvbl9jb2RlID0gbmxhX2dldF91MTYocmVhc29uKTsKLQlkYXRhLmRpc2Fzc29jX2luZm8ubG9jYWxseV9nZW5lcmF0ZWQgPSBieV9hcCA9PSBOVUxMOwotCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9ESVNBU1NPQywgJmRhdGEpOworCQlkYXRhLmRlYXV0aF9pbmZvLnJlYXNvbl9jb2RlID0gbmxhX2dldF91MTYocmVhc29uKTsKKwlkYXRhLmRlYXV0aF9pbmZvLmxvY2FsbHlfZ2VuZXJhdGVkID0gYnlfYXAgPT0gTlVMTDsKKwl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfREVBVVRILCAmZGF0YSk7Cit9CisKKworc3RhdGljIHZvaWQgbWxtZV9ldmVudF9jaF9zd2l0Y2goc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsCisJCQkJIHN0cnVjdCBubGF0dHIgKmZyZXEsIHN0cnVjdCBubGF0dHIgKnR5cGUpCit7CisJdW5pb24gd3BhX2V2ZW50X2RhdGEgZGF0YTsKKwlpbnQgaHRfZW5hYmxlZCA9IDE7CisJaW50IGNoYW5fb2Zmc2V0ID0gMDsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogQ2hhbm5lbCBzd2l0Y2ggZXZlbnQiKTsKKworCWlmICghZnJlcSB8fCAhdHlwZSkKKwkJcmV0dXJuOworCisJc3dpdGNoIChubGFfZ2V0X3UzMih0eXBlKSkgeworCWNhc2UgTkw4MDIxMV9DSEFOX05PX0hUOgorCQlodF9lbmFibGVkID0gMDsKKwkJYnJlYWs7CisJY2FzZSBOTDgwMjExX0NIQU5fSFQyMDoKKwkJYnJlYWs7CisJY2FzZSBOTDgwMjExX0NIQU5fSFQ0MFBMVVM6CisJCWNoYW5fb2Zmc2V0ID0gMTsKKwkJYnJlYWs7CisJY2FzZSBOTDgwMjExX0NIQU5fSFQ0ME1JTlVTOgorCQljaGFuX29mZnNldCA9IC0xOworCQlicmVhazsKKwl9CisKKwlkYXRhLmNoX3N3aXRjaC5mcmVxID0gbmxhX2dldF91MzIoZnJlcSk7CisJZGF0YS5jaF9zd2l0Y2guaHRfZW5hYmxlZCA9IGh0X2VuYWJsZWQ7CisJZGF0YS5jaF9zd2l0Y2guY2hfb2Zmc2V0ID0gY2hhbl9vZmZzZXQ7CisKKwl3cGFfc3VwcGxpY2FudF9ldmVudChkcnYtPmN0eCwgRVZFTlRfQ0hfU1dJVENILCAmZGF0YSk7CiB9CiAKIApAQCAtMTIwOCwxMSArMTI3MSwxMyBAQAogCiAKIHN0YXRpYyB2b2lkIG1sbWVfZXZlbnRfbWdtdChzdHJ1Y3Qgd3BhX2RyaXZlcl9ubDgwMjExX2RhdGEgKmRydiwKLQkJCSAgICBzdHJ1Y3QgbmxhdHRyICpmcmVxLCBjb25zdCB1OCAqZnJhbWUsIHNpemVfdCBsZW4pCisJCQkgICAgc3RydWN0IG5sYXR0ciAqZnJlcSwgc3RydWN0IG5sYXR0ciAqc2lnLAorCQkJICAgIGNvbnN0IHU4ICpmcmFtZSwgc2l6ZV90IGxlbikKIHsKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7CiAJdW5pb24gd3BhX2V2ZW50X2RhdGEgZXZlbnQ7CiAJdTE2IGZjLCBzdHlwZTsKKwlpbnQgc3NpX3NpZ25hbCA9IDA7CiAKIAltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKSBmcmFtZTsKIAlpZiAobGVuIDwgMjQpIHsKQEAgLTEyMjMsNiArMTI4OCw5IEBACiAJZmMgPSBsZV90b19ob3N0MTYobWdtdC0+ZnJhbWVfY29udHJvbCk7CiAJc3R5cGUgPSBXTEFOX0ZDX0dFVF9TVFlQRShmYyk7CiAKKwlpZiAoc2lnKQorCQlzc2lfc2lnbmFsID0gKHMzMikgbmxhX2dldF91MzIoc2lnKTsKKwogCW9zX21lbXNldCgmZXZlbnQsIDAsIHNpemVvZihldmVudCkpOwogCWlmIChmcmVxKSB7CiAJCWV2ZW50LnJ4X2FjdGlvbi5mcmVxID0gbmxhX2dldF91MzIoZnJlcSk7CkBAIC0xMjM5LDYgKzEzMDcsNyBAQAogCX0gZWxzZSB7CiAJCWV2ZW50LnJ4X21nbXQuZnJhbWUgPSBmcmFtZTsKIAkJZXZlbnQucnhfbWdtdC5mcmFtZV9sZW4gPSBsZW47CisJCWV2ZW50LnJ4X21nbXQuc3NpX3NpZ25hbCA9IHNzaV9zaWduYWw7CiAJCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9SWF9NR01ULCAmZXZlbnQpOwogCX0KIH0KQEAgLTEzNzksNyArMTQ0OCw3IEBACiAJCSAgICAgICBlbnVtIG5sODAyMTFfY29tbWFuZHMgY21kLCBzdHJ1Y3QgbmxhdHRyICpmcmFtZSwKIAkJICAgICAgIHN0cnVjdCBubGF0dHIgKmFkZHIsIHN0cnVjdCBubGF0dHIgKnRpbWVkX291dCwKIAkJICAgICAgIHN0cnVjdCBubGF0dHIgKmZyZXEsIHN0cnVjdCBubGF0dHIgKmFjaywKLQkJICAgICAgIHN0cnVjdCBubGF0dHIgKmNvb2tpZSkKKwkJICAgICAgIHN0cnVjdCBubGF0dHIgKmNvb2tpZSwgc3RydWN0IG5sYXR0ciAqc2lnKQogewogCWlmICh0aW1lZF9vdXQgJiYgYWRkcikgewogCQltbG1lX3RpbWVvdXRfZXZlbnQoZHJ2LCBjbWQsIGFkZHIpOwpAQCAtMTQxMiw3ICsxNDgxLDggQEAKIAkJCQkJICAgbmxhX2RhdGEoZnJhbWUpLCBubGFfbGVuKGZyYW1lKSk7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfRlJBTUU6Ci0JCW1sbWVfZXZlbnRfbWdtdChkcnYsIGZyZXEsIG5sYV9kYXRhKGZyYW1lKSwgbmxhX2xlbihmcmFtZSkpOworCQltbG1lX2V2ZW50X21nbXQoZHJ2LCBmcmVxLCBzaWcsIG5sYV9kYXRhKGZyYW1lKSwKKwkJCQlubGFfbGVuKGZyYW1lKSk7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfRlJBTUVfVFhfU1RBVFVTOgogCQltbG1lX2V2ZW50X21nbXRfdHhfc3RhdHVzKGRydiwgY29va2llLCBubGFfZGF0YShmcmFtZSksCkBAIC0yMDg0LDcgKzIxNTQsOCBAQAogCQltbG1lX2V2ZW50KGRydiwgY21kLCB0YltOTDgwMjExX0FUVFJfRlJBTUVdLAogCQkJICAgdGJbTkw4MDIxMV9BVFRSX01BQ10sIHRiW05MODAyMTFfQVRUUl9USU1FRF9PVVRdLAogCQkJICAgdGJbTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVFdLCB0YltOTDgwMjExX0FUVFJfQUNLXSwKLQkJCSAgIHRiW05MODAyMTFfQVRUUl9DT09LSUVdKTsKKwkJCSAgIHRiW05MODAyMTFfQVRUUl9DT09LSUVdLAorCQkJICAgdGJbTkw4MDIxMV9BVFRSX1JYX1NJR05BTF9EQk1dKTsKIAkJYnJlYWs7CiAJY2FzZSBOTDgwMjExX0NNRF9DT05ORUNUOgogCWNhc2UgTkw4MDIxMV9DTURfUk9BTToKQEAgLTIwOTQsNiArMjE2NSwxMCBAQAogCQkJCSAgIHRiW05MODAyMTFfQVRUUl9SRVFfSUVdLAogCQkJCSAgIHRiW05MODAyMTFfQVRUUl9SRVNQX0lFXSk7CiAJCWJyZWFrOworCWNhc2UgTkw4MDIxMV9DTURfQ0hfU1dJVENIX05PVElGWToKKwkJbWxtZV9ldmVudF9jaF9zd2l0Y2goZHJ2LCB0YltOTDgwMjExX0FUVFJfV0lQSFlfRlJFUV0sCisJCQkJICAgICB0YltOTDgwMjExX0FUVFJfV0lQSFlfQ0hBTk5FTF9UWVBFXSk7CisJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DTURfRElTQ09OTkVDVDoKIAkJbWxtZV9ldmVudF9kaXNjb25uZWN0KGRydiwgdGJbTkw4MDIxMV9BVFRSX1JFQVNPTl9DT0RFXSwKIAkJCQkgICAgICB0YltOTDgwMjExX0FUVFJfTUFDXSwKQEAgLTIxNzYsNyArMjI1MSw3IEBACiAJc3RydWN0IG5sODAyMTFfZ2xvYmFsICpnbG9iYWwgPSBhcmc7CiAJc3RydWN0IGdlbmxtc2doZHIgKmdubGggPSBubG1zZ19kYXRhKG5sbXNnX2hkcihtc2cpKTsKIAlzdHJ1Y3QgbmxhdHRyICp0YltOTDgwMjExX0FUVFJfTUFYICsgMV07Ci0Jc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnY7CisJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYsICp0bXA7CiAJaW50IGlmaWR4ID0gLTE7CiAKIAlubGFfcGFyc2UodGIsIE5MODAyMTFfQVRUUl9NQVgsIGdlbmxtc2dfYXR0cmRhdGEoZ25saCwgMCksCkBAIC0yMTg1LDE1ICsyMjYwLDExIEBACiAJaWYgKHRiW05MODAyMTFfQVRUUl9JRklOREVYXSkKIAkJaWZpZHggPSBubGFfZ2V0X3UzMih0YltOTDgwMjExX0FUVFJfSUZJTkRFWF0pOwogCi0JZGxfbGlzdF9mb3JfZWFjaChkcnYsICZnbG9iYWwtPmludGVyZmFjZXMsCi0JCQkgc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhLCBsaXN0KSB7CisJZGxfbGlzdF9mb3JfZWFjaF9zYWZlKGRydiwgdG1wLCAmZ2xvYmFsLT5pbnRlcmZhY2VzLAorCQkJICAgICAgc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhLCBsaXN0KSB7CiAJCWlmIChpZmlkeCA9PSAtMSB8fCBpZmlkeCA9PSBkcnYtPmlmaW5kZXggfHwKLQkJICAgIGhhdmVfaWZpZHgoZHJ2LCBpZmlkeCkpIHsKKwkJICAgIGhhdmVfaWZpZHgoZHJ2LCBpZmlkeCkpCiAJCQlkb19wcm9jZXNzX2Rydl9ldmVudChkcnYsIGdubGgtPmNtZCwgdGIpOwotI2lmZGVmIEFORFJPSURfUDJQCi0JCQlicmVhazsKLSNlbmRpZgotCQl9CiAJfQogCiAJcmV0dXJuIE5MX1NLSVA7CkBAIC0yMjE1LDcgKzIyODYsOCBAQAogCQltbG1lX2V2ZW50KGJzcy0+ZHJ2LCBnbmxoLT5jbWQsIHRiW05MODAyMTFfQVRUUl9GUkFNRV0sCiAJCQkgICB0YltOTDgwMjExX0FUVFJfTUFDXSwgdGJbTkw4MDIxMV9BVFRSX1RJTUVEX09VVF0sCiAJCQkgICB0YltOTDgwMjExX0FUVFJfV0lQSFlfRlJFUV0sIHRiW05MODAyMTFfQVRUUl9BQ0tdLAotCQkJICAgdGJbTkw4MDIxMV9BVFRSX0NPT0tJRV0pOworCQkJICAgdGJbTkw4MDIxMV9BVFRSX0NPT0tJRV0sCisJCQkgICB0YltOTDgwMjExX0FUVFJfUlhfU0lHTkFMX0RCTV0pOwogCQlicmVhazsKIAljYXNlIE5MODAyMTFfQ01EX1VORVhQRUNURURfRlJBTUU6CiAJCW5sODAyMTFfc3B1cmlvdXNfZnJhbWUoYnNzLCB0YiwgMCk7CkBAIC0yNTA0LDYgKzI1NzYsOSBAQAogCiAJCWlmIChmbGFncyAmIE5MODAyMTFfRkVBVFVSRV9TS19UWF9TVEFUVVMpCiAJCQlpbmZvLT5kYXRhX3R4X3N0YXR1cyA9IDE7CisKKwkJaWYgKGZsYWdzICYgTkw4MDIxMV9GRUFUVVJFX0lOQUNUSVZJVFlfVElNRVIpCisJCQljYXBhLT5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX0lOQUNUSVZJVFlfVElNRVI7CiAJfQogCiAJaWYgKHRiW05MODAyMTFfQVRUUl9QUk9CRV9SRVNQX09GRkxPQURdKSB7CkBAIC0yNTcxLDE3ICsyNjQ2LDI5IEBACiAJZHJ2LT5jYXBhLmZsYWdzIHw9IFdQQV9EUklWRVJfRkxBR1NfU0FORV9FUlJPUl9DT0RFUzsKIAlkcnYtPmNhcGEuZmxhZ3MgfD0gV1BBX0RSSVZFUl9GTEFHU19TRVRfS0VZU19BRlRFUl9BU1NPQ19ET05FOwogCWRydi0+Y2FwYS5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX0VBUE9MX1RYX1NUQVRVUzsKLQlkcnYtPmNhcGEuZmxhZ3MgfD0gV1BBX0RSSVZFUl9GTEFHU19ERUFVVEhfVFhfU1RBVFVTOworI2lmbmRlZiBBTkRST0lEX1AyUAorCWlmICghaW5mby5kZXZpY2VfYXBfc21lKQorI2VuZGlmCisJCWRydi0+Y2FwYS5mbGFncyB8PSBXUEFfRFJJVkVSX0ZMQUdTX0RFQVVUSF9UWF9TVEFUVVM7CiAKIAlkcnYtPmRldmljZV9hcF9zbWUgPSBpbmZvLmRldmljZV9hcF9zbWU7CiAJZHJ2LT5wb2xsX2NvbW1hbmRfc3VwcG9ydGVkID0gaW5mby5wb2xsX2NvbW1hbmRfc3VwcG9ydGVkOwogCWRydi0+ZGF0YV90eF9zdGF0dXMgPSBpbmZvLmRhdGFfdHhfc3RhdHVzOwogCisjaWZkZWYgQU5EUk9JRF9QMlAKKwlpZihkcnYtPmNhcGEuZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX09GRkNIQU5ORUxfVFgpIHsKKwkJLyogRHJpdmVyIGlzIG5ldyBlbm91Z2ggdG8gc3VwcG9ydCBtb25pdG9ybGVzcyBtb2RlKi8KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBEcml2ZXIgaXMgbmV3ICIKKwkJCSAgImVub3VnaCB0byBzdXBwb3J0IG1vbml0b3ItbGVzcyBtb2RlIik7CisJCWRydi0+dXNlX21vbml0b3IgPSAwOworCX0KKyNlbHNlCiAJLyoKIAkgKiBJZiBwb2xsIGNvbW1hbmQgaXMgc3VwcG9ydGVkIG1hYzgwMjExIGlzIG5ldyBlbm91Z2ggdG8KIAkgKiBoYXZlIGV2ZXJ5dGhpbmcgd2UgbmVlZCB0byBub3QgbmVlZCBtb25pdG9yIGludGVyZmFjZXMuCiAJICovCiAJZHJ2LT51c2VfbW9uaXRvciA9ICFpbmZvLnBvbGxfY29tbWFuZF9zdXBwb3J0ZWQ7CisjZW5kaWYKIAogCWlmIChkcnYtPmRldmljZV9hcF9zbWUgJiYgZHJ2LT51c2VfbW9uaXRvcikgewogCQkvKgpAQCAtMjgwMywxMCArMjg5MCw3IEBACiAJdTggZGF0YVsyMDQ4XTsKIAlzdHJ1Y3QgbXNnaGRyIG1zZzsKIAlzdHJ1Y3QgaW92ZWMgZW50cnk7Ci0Jc3RydWN0IHsKLQkJc3RydWN0IGNtc2doZHIgY207Ci0JCWNoYXIgY29udHJvbFs1MTJdOwotCX0gY29udHJvbDsKKwl1OCBjb250cm9sWzUxMl07CiAJc3RydWN0IGNtc2doZHIgKmNtc2c7CiAJaW50IHJlcywgZm91bmRfZWUgPSAwLCBmb3VuZF93aWZpID0gMCwgYWNrZWQgPSAwOwogCXVuaW9uIHdwYV9ldmVudF9kYXRhIGV2ZW50OwpAQCAtMzMwOSw2ICszMzkzLDcgQEAKIAlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CiAJc3RydWN0IHdwYV9kcml2ZXJfbmw4MDIxMV9kYXRhICpkcnYgPSBic3MtPmRydjsKIAorCWJzcy0+aW5fZGVpbml0ID0gMTsKIAlpZiAoZHJ2LT5kYXRhX3R4X3N0YXR1cykKIAkJZWxvb3BfdW5yZWdpc3Rlcl9yZWFkX3NvY2soZHJ2LT5lYXBvbF90eF9zb2NrKTsKIAlpZiAoZHJ2LT5lYXBvbF90eF9zb2NrID49IDApCkBAIC0zNDY3LDYgKzM1NTIsOCBAQAogCX0KIAogCWlmIChwYXJhbXMtPnAycF9wcm9iZSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFAyUCBwcm9iZSAtIG1hc2sgU3VwcFJhdGVzIik7CisKIAkJLyoKIAkJICogUmVtb3ZlIDIuNCBHSHogcmF0ZXMgMSwgMiwgNS41LCAxMSBNYnBzIGZyb20gc3VwcG9ydGVkIHJhdGVzCiAJCSAqIGJ5IG1hc2tpbmcgb3V0IGV2ZXJ5dGhpbmcgZWxzZSBhcGFydCBmcm9tIHRoZSBPRkRNIHJhdGVzIDYsCkBAIC00NzMxLDYgKzQ4MTgsMTggQEAKIAkJCW9zX21lbWNweShtb2RlLT5tY3Nfc2V0LCBtY3MsIDE2KTsKIAkJfQogCisJCWlmICh0Yl9iYW5kW05MODAyMTFfQkFORF9BVFRSX1ZIVF9DQVBBXSkgeworCQkJbW9kZS0+dmh0X2NhcGFiID0gbmxhX2dldF91MzIoCisJCQkJdGJfYmFuZFtOTDgwMjExX0JBTkRfQVRUUl9WSFRfQ0FQQV0pOworCQl9CisKKwkJaWYgKHRiX2JhbmRbTkw4MDIxMV9CQU5EX0FUVFJfVkhUX01DU19TRVRdICYmCisJCSAgICBubGFfbGVuKHRiX2JhbmRbTkw4MDIxMV9CQU5EX0FUVFJfVkhUX01DU19TRVRdKSkgeworCQkJdTggKm1jczsKKwkJCW1jcyA9IG5sYV9kYXRhKHRiX2JhbmRbTkw4MDIxMV9CQU5EX0FUVFJfVkhUX01DU19TRVRdKTsKKwkJCW9zX21lbWNweShtb2RlLT52aHRfbWNzX3NldCwgbWNzLCA4KTsKKwkJfQorCiAJCW5sYV9mb3JfZWFjaF9uZXN0ZWQobmxfZnJlcSwgdGJfYmFuZFtOTDgwMjExX0JBTkRfQVRUUl9GUkVRU10sIHJlbV9mcmVxKSB7CiAJCQlubGFfcGFyc2UodGJfZnJlcSwgTkw4MDIxMV9GUkVRVUVOQ1lfQVRUUl9NQVgsIG5sYV9kYXRhKG5sX2ZyZXEpLAogCQkJCSAgbmxhX2xlbihubF9mcmVxKSwgZnJlcV9wb2xpY3kpOwpAQCAtNTE5MSw3ICs1MjkwLDkgQEAKIAlpZiAoZHJ2LT5kZXZpY2VfYXBfc21lICYmIGlzX2FwX2ludGVyZmFjZShkcnYtPm5sbW9kZSkpIHsKIAkJaWYgKGZyZXEgPT0gMCkKIAkJCWZyZXEgPSBic3MtPmZyZXE7Ci0JCXJldHVybiBubDgwMjExX3NlbmRfZnJhbWVfY21kKGJzcywgZnJlcSwgMCwKKwkJcmV0dXJuIG5sODAyMTFfc2VuZF9mcmFtZV9jbWQoYnNzLCBmcmVxLAorCQkJCQkgICAgICAoaW50KSBmcmVxID09IGJzcy0+ZnJlcSA/IDAgOgorCQkJCQkgICAgICB3YWl0X3RpbWUsCiAJCQkJCSAgICAgIGRhdGEsIGRhdGFfbGVuLAogCQkJCQkgICAgICAmZHJ2LT5zZW5kX2FjdGlvbl9jb29raWUsCiAJCQkJCSAgICAgIG5vX2Njaywgbm9hY2ssIG9mZmNoYW5vayk7CkBAIC01NDAzLDYgKzU1MDQsMTEgQEAKIAkJCXdwYWJ1Zl9oZWFkKHBhcmFtcy0+YXNzb2NyZXNwX2llcykpOwogCX0KIAorCWlmIChkcnYtPmNhcGEuZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX0lOQUNUSVZJVFlfVElNRVIpICB7CisJCU5MQV9QVVRfVTE2KG1zZywgTkw4MDIxMV9BVFRSX0lOQUNUSVZJVFlfVElNRU9VVCwKKwkJCSAgICBwYXJhbXMtPmFwX21heF9pbmFjdGl2aXR5KTsKKwl9CisKIAlyZXQgPSBzZW5kX2FuZF9yZWN2X21zZ3MoZHJ2LCBtc2csIE5VTEwsIE5VTEwpOwogCWlmIChyZXQpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJubDgwMjExOiBCZWFjb24gc2V0IGZhaWxlZDogJWQgKCVzKSIsCkBAIC01NDEzLDcgKzU1MTksNiBAQAogCQkJCXBhcmFtcy0+c2hvcnRfc2xvdF90aW1lLCBwYXJhbXMtPmh0X29wbW9kZSwKIAkJCQlwYXJhbXMtPmlzb2xhdGUsIHBhcmFtcy0+YmFzaWNfcmF0ZXMpOwogCX0KLQogCXJldHVybiByZXQ7CiAgbmxhX3B1dF9mYWlsdXJlOgogCW5sbXNnX2ZyZWUobXNnKTsKQEAgLTU4NTEsOCArNTk1Niw4IEBACiAJCWNhc2UgSUVFRTgwMjExX1JBRElPVEFQX1JBVEU6CiAJCQlkYXRhcmF0ZSA9ICppdGVyLnRoaXNfYXJnICogNTsKIAkJCWJyZWFrOwotCQljYXNlIElFRUU4MDIxMV9SQURJT1RBUF9EQl9BTlRTSUdOQUw6Ci0JCQlzc2lfc2lnbmFsID0gKml0ZXIudGhpc19hcmc7CisJCWNhc2UgSUVFRTgwMjExX1JBRElPVEFQX0RCTV9BTlRTSUdOQUw6CisJCQlzc2lfc2lnbmFsID0gKHM4KSAqaXRlci50aGlzX2FyZzsKIAkJCWJyZWFrOwogCQl9CiAJfQpAQCAtNjE0OSw3ICs2MjU0LDYgQEAKIAkJaWYgKG5sODAyMTFfbWdtdF9zdWJzY3JpYmVfYXAoYnNzKSkKIAkJCXJldHVybiAtMTsKIAotI2lmbmRlZiBBTkRST0lEX1AyUAogCWlmIChkcnYtPmRldmljZV9hcF9zbWUgJiYgIWRydi0+dXNlX21vbml0b3IpCiAJCWlmIChubDgwMjExX21nbXRfc3Vic2NyaWJlX2FwX2Rldl9zbWUoYnNzKSkKIAkJCXJldHVybiAtMTsKQEAgLTYxNTcsMTUgKzYyNjEsMTcgQEAKIAlpZiAoIWRydi0+ZGV2aWNlX2FwX3NtZSAmJiBkcnYtPnVzZV9tb25pdG9yICYmCiAJICAgIG5sODAyMTFfY3JlYXRlX21vbml0b3JfaW50ZXJmYWNlKGRydikgJiYKIAkgICAgIWRydi0+ZGV2aWNlX2FwX3NtZSkKLSNlbHNlCi0JaWYgKGRydi0+ZGV2aWNlX2FwX3NtZSkKKwkJcmV0dXJuIC0xOworCisjaWZkZWYgQU5EUk9JRF9QMlAKKwlpZiAoZHJ2LT5kZXZpY2VfYXBfc21lICYmIGRydi0+dXNlX21vbml0b3IpCiAJCWlmIChubDgwMjExX21nbXRfc3Vic2NyaWJlX2FwX2Rldl9zbWUoYnNzKSkKIAkJCXJldHVybiAtMTsKIAogCWlmIChkcnYtPnVzZV9tb25pdG9yICYmCiAJICAgIG5sODAyMTFfY3JlYXRlX21vbml0b3JfaW50ZXJmYWNlKGRydikpCi0jZW5kaWYKIAkJcmV0dXJuIC0xOworI2VuZGlmCiAKIAlpZiAoZHJ2LT5kZXZpY2VfYXBfc21lICYmCiAJICAgIHdwYV9kcml2ZXJfbmw4MDIxMV9wcm9iZV9yZXFfcmVwb3J0KGJzcywgMSkgPCAwKSB7CkBAIC02NTY4LDYgKzY2NzQsMTIgQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogZnJlcT0lZCIsIHBhcmFtcy0+ZnJlcSk7CiAJCU5MQV9QVVRfVTMyKG1zZywgTkw4MDIxMV9BVFRSX1dJUEhZX0ZSRVEsIHBhcmFtcy0+ZnJlcSk7CiAJfQorCWlmIChwYXJhbXMtPmJnX3NjYW5fcGVyaW9kID49IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogYmcgc2NhbiBwZXJpb2Q9JWQiLAorCQkJICAgcGFyYW1zLT5iZ19zY2FuX3BlcmlvZCk7CisJCU5MQV9QVVRfVTE2KG1zZywgTkw4MDIxMV9BVFRSX0JHX1NDQU5fUEVSSU9ELAorCQkJICAgIHBhcmFtcy0+Ymdfc2Nhbl9wZXJpb2QpOworCX0KIAlpZiAocGFyYW1zLT5zc2lkKSB7CiAJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIiAgKiBTU0lEIiwKIAkJCQkgIHBhcmFtcy0+c3NpZCwgcGFyYW1zLT5zc2lkX2xlbik7CkBAIC02NzY1LDYgKzY4NzcsMTIgQEAKIAkJZHJ2LT5hc3NvY19mcmVxID0gcGFyYW1zLT5mcmVxOwogCX0gZWxzZQogCQlkcnYtPmFzc29jX2ZyZXEgPSAwOworCWlmIChwYXJhbXMtPmJnX3NjYW5fcGVyaW9kID49IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICogYmcgc2NhbiBwZXJpb2Q9JWQiLAorCQkJICAgcGFyYW1zLT5iZ19zY2FuX3BlcmlvZCk7CisJCU5MQV9QVVRfVTE2KG1zZywgTkw4MDIxMV9BVFRSX0JHX1NDQU5fUEVSSU9ELAorCQkJICAgIHBhcmFtcy0+Ymdfc2Nhbl9wZXJpb2QpOworCX0KIAlpZiAocGFyYW1zLT5zc2lkKSB7CiAJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIiAgKiBTU0lEIiwKIAkJCQkgIHBhcmFtcy0+c3NpZCwgcGFyYW1zLT5zc2lkX2xlbik7CkBAIC02OTgwLDcgKzcwOTgsNyBAQAogCQlubDgwMjExX21nbXRfdW5zdWJzY3JpYmUoYnNzLCAibW9kZSBjaGFuZ2UiKTsKIAl9CiAKLQlpZiAoIWlzX2FwX2ludGVyZmFjZShubG1vZGUpICYmCisJaWYgKCFic3MtPmluX2RlaW5pdCAmJiAhaXNfYXBfaW50ZXJmYWNlKG5sbW9kZSkgJiYKIAkgICAgbmw4MDIxMV9tZ210X3N1YnNjcmliZV9ub25fYXAoYnNzKSA8IDApCiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAibmw4MDIxMTogRmFpbGVkIHRvIHJlZ2lzdGVyIEFjdGlvbiAiCiAJCQkgICAiZnJhbWUgcHJvY2Vzc2luZyAtIGlnbm9yZSBmb3Igbm93Iik7CkBAIC03NDAyLDggKzc1MjAsMTIgQEAKIAkJCSAgIGludCByZWFzb24pCiB7CiAJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OworCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJc3RydWN0IGllZWU4MDIxMV9tZ210IG1nbXQ7CiAKKwlpZiAoZHJ2LT5kZXZpY2VfYXBfc21lKQorCQlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3N0YV9yZW1vdmUoYnNzLCBhZGRyKTsKKwogCW1lbXNldCgmbWdtdCwgMCwgc2l6ZW9mKG1nbXQpKTsKIAltZ210LmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCiAJCQkJCSAgV0xBTl9GQ19TVFlQRV9ERUFVVEgpOwpAQCAtNzQyMSw4ICs3NTQzLDEyIEBACiAJCQkgICAgIGludCByZWFzb24pCiB7CiAJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OworCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CiAJc3RydWN0IGllZWU4MDIxMV9tZ210IG1nbXQ7CiAKKwlpZiAoZHJ2LT5kZXZpY2VfYXBfc21lKQorCQlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3N0YV9yZW1vdmUoYnNzLCBhZGRyKTsKKwogCW1lbXNldCgmbWdtdCwgMCwgc2l6ZW9mKG1nbXQpKTsKIAltZ210LmZyYW1lX2NvbnRyb2wgPSBJRUVFODAyMTFfRkMoV0xBTl9GQ19UWVBFX01HTVQsCiAJCQkJCSAgV0xBTl9GQ19TVFlQRV9ESVNBU1NPQyk7CkBAIC03OTY3LDYgKzgwOTMsOSBAQAogCWlmICghbXNnKQogCQlyZXR1cm4gLTE7CiAKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IENNRF9GUkFNRSBmcmVxPSV1IHdhaXQ9JXUgbm9fY2NrPSVkICIKKwkJICAgIm5vX2Fjaz0lZCBvZmZjaGFub2s9JWQiLAorCQkgICBmcmVxLCB3YWl0LCBub19jY2ssIG5vX2Fjaywgb2ZmY2hhbm9rKTsKIAlubDgwMjExX2NtZChkcnYsIG1zZywgMCwgTkw4MDIxMV9DTURfRlJBTUUpOwogCiAJTkxBX1BVVF9VMzIobXNnLCBOTDgwMjExX0FUVFJfSUZJTkRFWCwgYnNzLT5pZmluZGV4KTsKQEAgLTgyNjksNiArODM5OCwxNiBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX2RyaXZlcl9ubDgwMjExX2RlaW5pdF9wMnBfY2xpKHZvaWQgKnByaXYpCit7CisJc3RydWN0IGk4MDJfYnNzICpic3MgPSBwcml2OworCXN0cnVjdCB3cGFfZHJpdmVyX25sODAyMTFfZGF0YSAqZHJ2ID0gYnNzLT5kcnY7CisJaWYgKGRydi0+bmxtb2RlICE9IE5MODAyMTFfSUZUWVBFX1AyUF9DTElFTlQpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX2RyaXZlcl9ubDgwMjExX3NldF9tb2RlKHByaXYsIE5MODAyMTFfSUZUWVBFX1NUQVRJT04pOworfQorCisKIHN0YXRpYyB2b2lkIHdwYV9kcml2ZXJfbmw4MDIxMV9yZXN1bWUodm9pZCAqcHJpdikKIHsKIAlzdHJ1Y3QgaTgwMl9ic3MgKmJzcyA9IHByaXY7CkBAIC04NDA3LDExICs4NTQ2LDkgQEAKIAkJCSAgIE1BQ1NUUiwKIAkJCSAgIGRyaXZlci0+cGh5bmFtZSwgZHJpdmVyLT5maXJzdF9ic3MuaWZuYW1lLAogCQkJICAgTUFDMlNUUihkcml2ZXItPmZpcnN0X2Jzcy5hZGRyKSk7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQkJaWYoaXNfYXBfaW50ZXJmYWNlKGRyaXZlci0+bmxtb2RlKSkKKwkJaWYgKGlzX2FwX2ludGVyZmFjZShkcml2ZXItPm5sbW9kZSkpCiAJCQlmcmVxID0gZHJpdmVyLT5maXJzdF9ic3MuZnJlcTsKIAkJZWxzZQotI2VuZGlmCiAJCQlmcmVxID0gbmw4MDIxMV9nZXRfYXNzb2NfZnJlcShkcml2ZXIpOwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIm5sODAyMTE6IFNoYXJlZCBmcmVxIGZvciBQSFkgJXM6ICVkIiwKIAkJCSAgIGRydi0+cGh5bmFtZSwgZnJlcSk7CkBAIC05MDE2LDYgKzkxNTMsNyBAQAogCXdwYV9kcml2ZXJfbmw4MDIxMV9jYW5jZWxfcmVtYWluX29uX2NoYW5uZWwsCiAJLnByb2JlX3JlcV9yZXBvcnQgPSB3cGFfZHJpdmVyX25sODAyMTFfcHJvYmVfcmVxX3JlcG9ydCwKIAkuZGVpbml0X2FwID0gd3BhX2RyaXZlcl9ubDgwMjExX2RlaW5pdF9hcCwKKwkuZGVpbml0X3AycF9jbGkgPSB3cGFfZHJpdmVyX25sODAyMTFfZGVpbml0X3AycF9jbGksCiAJLnJlc3VtZSA9IHdwYV9kcml2ZXJfbmw4MDIxMV9yZXN1bWUsCiAJLnNlbmRfZnRfYWN0aW9uID0gbmw4MDIxMV9zZW5kX2Z0X2FjdGlvbiwKIAkuc2lnbmFsX21vbml0b3IgPSBubDgwMjExX3NpZ25hbF9tb25pdG9yLApkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvZHJpdmVyX3ByaXZzZXAuYyBiL3NyYy9kcml2ZXJzL2RyaXZlcl9wcml2c2VwLmMKaW5kZXggODFhMzI4YS4uYzg5MTZmMCAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX3ByaXZzZXAuYworKysgYi9zcmMvZHJpdmVycy9kcml2ZXJfcHJpdnNlcC5jCkBAIC02NTEsNyArNjUxLDcgQEAKIAlvc19zdHJsY3B5KGFkZHIuc3VuX3BhdGgsIGRydi0+b3duX3NvY2tldF9wYXRoLCBzaXplb2YoYWRkci5zdW5fcGF0aCkpOwogCWlmIChiaW5kKGRydi0+cHJpdl9zb2NrZXQsIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmFkZHIsIHNpemVvZihhZGRyKSkgPAogCSAgICAwKSB7Ci0JCXBlcnJvcigiYmluZChQRl9VTklYKSIpOworCQlwZXJyb3IoInByaXZzZXAtc2V0LXBhcmFtcyBwcml2LXNvY2s6IGJpbmQoUEZfVU5JWCkiKTsKIAkJY2xvc2UoZHJ2LT5wcml2X3NvY2tldCk7CiAJCWRydi0+cHJpdl9zb2NrZXQgPSAtMTsKIAkJdW5saW5rKGRydi0+b3duX3NvY2tldF9wYXRoKTsKQEAgLTY3Niw3ICs2NzYsNyBAQAogCW9zX3N0cmxjcHkoYWRkci5zdW5fcGF0aCwgZHJ2LT5vd25fY21kX3BhdGgsIHNpemVvZihhZGRyLnN1bl9wYXRoKSk7CiAJaWYgKGJpbmQoZHJ2LT5jbWRfc29ja2V0LCAoc3RydWN0IHNvY2thZGRyICopICZhZGRyLCBzaXplb2YoYWRkcikpIDwgMCkKIAl7Ci0JCXBlcnJvcigiYmluZChQRl9VTklYKSIpOworCQlwZXJyb3IoInByaXZzZXAtc2V0LXBhcmFtcyBjbWQtc29jazogYmluZChQRl9VTklYKSIpOwogCQljbG9zZShkcnYtPmNtZF9zb2NrZXQpOwogCQlkcnYtPmNtZF9zb2NrZXQgPSAtMTsKIAkJdW5saW5rKGRydi0+b3duX2NtZF9wYXRoKTsKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlcl9yb2Jvc3dpdGNoLmMgYi9zcmMvZHJpdmVycy9kcml2ZXJfcm9ib3N3aXRjaC5jCmluZGV4IDYxYjc1YjEuLjBhOTA3OGEgMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl9yb2Jvc3dpdGNoLmMKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3JvYm9zd2l0Y2guYwpAQCAtMiwxNCArMiw4IEBACiAgKiBXUEEgU3VwcGxpY2FudCAtIHJvYm9zd2l0Y2ggZHJpdmVyIGludGVyZmFjZQogICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMDkgSm91a2UgV2l0dGV2ZWVuCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCmRpZmYgLS1naXQgYS9zcmMvZHJpdmVycy9kcml2ZXJfdGVzdC5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3Rlc3QuYwppbmRleCA0M2IzMGU5Li5mMDExNjUxIDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9kcml2ZXJfdGVzdC5jCisrKyBiL3NyYy9kcml2ZXJzL2RyaXZlcl90ZXN0LmMKQEAgLTEyNzUsNyArMTI3NSw3IEBACiAJCQlhbGVuID0gc2l6ZW9mKGFkZHJfdW4pOwogCQl9CiAJCWlmIChiaW5kKGRydi0+dGVzdF9zb2NrZXQsIGFkZHIsIGFsZW4pIDwgMCkgewotCQkJcGVycm9yKCJiaW5kKFBGX1VOSVgpIik7CisJCQlwZXJyb3IoInRlc3QtZHJpdmVyLWluaXQ6IGJpbmQoUEZfVU5JWCkiKTsKIAkJCWNsb3NlKGRydi0+dGVzdF9zb2NrZXQpOwogCQkJaWYgKGRydi0+b3duX3NvY2tldF9wYXRoKQogCQkJCXVubGluayhkcnYtPm93bl9zb2NrZXRfcGF0aCk7CkBAIC0yMjUyLDcgKzIyNTIsNyBAQAogCW9zX3N0cmxjcHkoYWRkci5zdW5fcGF0aCwgZHJ2LT5vd25fc29ja2V0X3BhdGgsIHNpemVvZihhZGRyLnN1bl9wYXRoKSk7CiAJaWYgKGJpbmQoZHJ2LT50ZXN0X3NvY2tldCwgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwKIAkJIHNpemVvZihhZGRyKSkgPCAwKSB7Ci0JCXBlcnJvcigiYmluZChQRl9VTklYKSIpOworCQlwZXJyb3IoInRlc3QtZHJpdmVyLWF0dGFjaDogYmluZChQRl9VTklYKSIpOwogCQljbG9zZShkcnYtPnRlc3Rfc29ja2V0KTsKIAkJdW5saW5rKGRydi0+b3duX3NvY2tldF9wYXRoKTsKIAkJb3NfZnJlZShkcnYtPm93bl9zb2NrZXRfcGF0aCk7CkBAIC0yODY3LDcgKzI4NjcsOCBAQAogCWlmICghZHJ2LT5wMnApCiAJCXJldHVybiAtMTsKIAlyZXR1cm4gcDJwX2Nvbm5lY3QoZHJ2LT5wMnAsIHBlZXJfYWRkciwgd3BzX21ldGhvZCwgZ29faW50ZW50LAotCQkJICAgb3duX2ludGVyZmFjZV9hZGRyLCBmb3JjZV9mcmVxLCBwZXJzaXN0ZW50X2dyb3VwKTsKKwkJCSAgIG93bl9pbnRlcmZhY2VfYWRkciwgZm9yY2VfZnJlcSwgcGVyc2lzdGVudF9ncm91cCwKKwkJCSAgIE5VTEwsIDAsIDApOwogfQogCiAKQEAgLTI5MTIsNyArMjkxMyw3IEBACiAKIHN0YXRpYyBpbnQgdGVzdF9wMnBfc2Nhbih2b2lkICpjdHgsIGVudW0gcDJwX3NjYW5fdHlwZSB0eXBlLCBpbnQgZnJlcSwKIAkJCSB1bnNpZ25lZCBpbnQgbnVtX3JlcV9kZXZfdHlwZXMsCi0JCQkgY29uc3QgdTggKnJlcV9kZXZfdHlwZXMsIGNvbnN0IHU4ICpkZXZfaWQpCisJCQkgY29uc3QgdTggKnJlcV9kZXZfdHlwZXMsIGNvbnN0IHU4ICpkZXZfaWQsIHUxNiBwd19pZCkKIHsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl90ZXN0X2RhdGEgKmRydiA9IGN0eDsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CkBAIC0yOTMzLDggKzI5MzQsOCBAQAogCiAjaWYgMCAvKiBUT0RPOiBXUFMgSUUgKi8KIAl3cGFfcy0+d3BzLT5kZXYucDJwID0gMTsKLQl3cHNfaWUgPSB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKDAsICZ3cGFfcy0+d3BzLT5kZXYsIHdwYV9zLT53cHMtPnV1aWQsCi0JCQkJCVdQU19SRVFfRU5ST0xMRUUpOworCXdwc19pZSA9IHdwc19idWlsZF9wcm9iZV9yZXFfaWUocHdfaWQsICZ3cGFfcy0+d3BzLT5kZXYsCisJCQkJCXdwYV9zLT53cHMtPnV1aWQsIFdQU19SRVFfRU5ST0xMRUUpOwogI2Vsc2UKIAl3cHNfaWUgPSB3cGFidWZfYWxsb2MoMSk7CiAjZW5kaWYKQEAgLTI5NjEsMTEgKzI5NjIsNiBAQAogCQlicmVhazsKIAljYXNlIFAyUF9TQ0FOX0ZVTEw6CiAJCWJyZWFrOwotCWNhc2UgUDJQX1NDQU5fU1BFQ0lGSUM6Ci0JCXNvY2lhbF9jaGFubmVsc1swXSA9IGZyZXE7Ci0JCXNvY2lhbF9jaGFubmVsc1sxXSA9IDA7Ci0JCXBhcmFtcy5mcmVxcyA9IHNvY2lhbF9jaGFubmVsczsKLQkJYnJlYWs7CiAJY2FzZSBQMlBfU0NBTl9TT0NJQUxfUExVU19PTkU6CiAJCXNvY2lhbF9jaGFubmVsc1szXSA9IGZyZXE7CiAJCXBhcmFtcy5mcmVxcyA9IHNvY2lhbF9jaGFubmVsczsKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlcl93ZXh0LmMgYi9zcmMvZHJpdmVycy9kcml2ZXJfd2V4dC5jCmluZGV4IDIwNGRlMzQuLmZkOTA0MzggMTAwNjQ0Ci0tLSBhL3NyYy9kcml2ZXJzL2RyaXZlcl93ZXh0LmMKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3dleHQuYwpAQCAtNTg0LDEwICs1ODQsMjggQEAKIAkJICAgZGVsID8gInJlbW92ZWQiIDogImFkZGVkIik7CiAKIAlpZiAob3Nfc3RyY21wKGRydi0+aWZuYW1lLCBldmVudC5pbnRlcmZhY2Vfc3RhdHVzLmlmbmFtZSkgPT0gMCkgewotCQlpZiAoZGVsKQorCQlpZiAoZGVsKSB7CisJCQlpZiAoZHJ2LT5pZl9yZW1vdmVkKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXRVhUOiBpZl9yZW1vdmVkICIKKwkJCQkJICAgImFscmVhZHkgc2V0IC0gaWdub3JlIGV2ZW50Iik7CisJCQkJcmV0dXJuOworCQkJfQogCQkJZHJ2LT5pZl9yZW1vdmVkID0gMTsKLQkJZWxzZQorCQl9IGVsc2UgeworCQkJaWYgKGlmX25hbWV0b2luZGV4KGRydi0+aWZuYW1lKSA9PSAwKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXRVhUOiBJbnRlcmZhY2UgJXMgIgorCQkJCQkgICAiZG9lcyBub3QgZXhpc3QgLSBpZ25vcmUgIgorCQkJCQkgICAiUlRNX05FV0xJTksiLAorCQkJCQkgICBkcnYtPmlmbmFtZSk7CisJCQkJcmV0dXJuOworCQkJfQorCQkJaWYgKCFkcnYtPmlmX3JlbW92ZWQpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldFWFQ6IGlmX3JlbW92ZWQgIgorCQkJCQkgICAiYWxyZWFkeSBjbGVhcmVkIC0gaWdub3JlIGV2ZW50Iik7CisJCQkJcmV0dXJuOworCQkJfQogCQkJZHJ2LT5pZl9yZW1vdmVkID0gMDsKKwkJfQogCX0KIAogCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9JTlRFUkZBQ0VfU1RBVFVTLCAmZXZlbnQpOwpAQCAtNjQzLDYgKzY2MSw3IEBACiAJc3RydWN0IHdwYV9kcml2ZXJfd2V4dF9kYXRhICpkcnYgPSBjdHg7CiAJaW50IGF0dHJsZW4sIHJ0YV9sZW47CiAJc3RydWN0IHJ0YXR0ciAqYXR0cjsKKwljaGFyIG5hbWVidWZbSUZOQU1TSVpdOwogCiAJaWYgKCF3cGFfZHJpdmVyX3dleHRfb3duX2lmaW5kZXgoZHJ2LCBpZmktPmlmaV9pbmRleCwgYnVmLCBsZW4pKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSWdub3JlIGV2ZW50IGZvciBmb3JlaWduIGlmaW5kZXggJWQiLApAQCAtNjY1LDkgKzY4NCwyNSBAQAogCX0KIAogCWlmIChkcnYtPmlmX2Rpc2FibGVkICYmIChpZmktPmlmaV9mbGFncyAmIElGRl9VUCkpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXRVhUOiBJbnRlcmZhY2UgdXAiKTsKLQkJZHJ2LT5pZl9kaXNhYmxlZCA9IDA7Ci0JCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9JTlRFUkZBQ0VfRU5BQkxFRCwgTlVMTCk7CisJCWlmIChpZl9pbmRleHRvbmFtZShpZmktPmlmaV9pbmRleCwgbmFtZWJ1ZikgJiYKKwkJICAgIGxpbnV4X2lmYWNlX3VwKGRydi0+aW9jdGxfc29jaywgZHJ2LT5pZm5hbWUpID09IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV0VYVDogSWdub3JlIGludGVyZmFjZSB1cCAiCisJCQkJICAgImV2ZW50IHNpbmNlIGludGVyZmFjZSAlcyBpcyBkb3duIiwKKwkJCQkgICBuYW1lYnVmKTsKKwkJfSBlbHNlIGlmIChpZl9uYW1ldG9pbmRleChkcnYtPmlmbmFtZSkgPT0gMCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXRVhUOiBJZ25vcmUgaW50ZXJmYWNlIHVwICIKKwkJCQkgICAiZXZlbnQgc2luY2UgaW50ZXJmYWNlICVzIGRvZXMgbm90IGV4aXN0IiwKKwkJCQkgICBkcnYtPmlmbmFtZSk7CisJCX0gZWxzZSBpZiAoZHJ2LT5pZl9yZW1vdmVkKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldFWFQ6IElnbm9yZSBpbnRlcmZhY2UgdXAgIgorCQkJCSAgICJldmVudCBzaW5jZSBpbnRlcmZhY2UgJXMgaXMgbWFya2VkICIKKwkJCQkgICAicmVtb3ZlZCIsIGRydi0+aWZuYW1lKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV0VYVDogSW50ZXJmYWNlIHVwIik7CisJCQlkcnYtPmlmX2Rpc2FibGVkID0gMDsKKwkJCXdwYV9zdXBwbGljYW50X2V2ZW50KGRydi0+Y3R4LCBFVkVOVF9JTlRFUkZBQ0VfRU5BQkxFRCwKKwkJCQkJICAgICBOVUxMKTsKKwkJfQogCX0KIAogCS8qCkBAIC0xNTY2LDYgKzE2MDEsNyBAQAogCQl9CiAJCWRydi0+Y2FwYS5lbmMgfD0gV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVA0MCB8CiAJCQlXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDEwNDsKKwkJZHJ2LT5jYXBhLmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDEyODsKIAkJaWYgKHJhbmdlLT5lbmNfY2FwYSAmIElXX0VOQ19DQVBBX0NJUEhFUl9US0lQKQogCQkJZHJ2LT5jYXBhLmVuYyB8PSBXUEFfRFJJVkVSX0NBUEFfRU5DX1RLSVA7CiAJCWlmIChyYW5nZS0+ZW5jX2NhcGEgJiBJV19FTkNfQ0FQQV9DSVBIRVJfQ0NNUCkKZGlmZiAtLWdpdCBhL3NyYy9kcml2ZXJzL2RyaXZlcl93aXJlZC5jIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3dpcmVkLmMKaW5kZXggNjE4ZGIyNi4uZTBmMGYyMiAxMDA2NDQKLS0tIGEvc3JjL2RyaXZlcnMvZHJpdmVyX3dpcmVkLmMKKysrIGIvc3JjL2RyaXZlcnMvZHJpdmVyX3dpcmVkLmMKQEAgLTMsMTQgKzMsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDQsIEd1bnRlciBCdXJjaGFyZHQgPHRpcmFAaXN4LmRlPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvc3JjL2RyaXZlcnMvbmw4MDIxMV9jb3B5LmggYi9zcmMvZHJpdmVycy9ubDgwMjExX2NvcHkuaAppbmRleCA0Zjk4ZmFlLi43NGNjNTVjIDEwMDY0NAotLS0gYS9zcmMvZHJpdmVycy9ubDgwMjExX2NvcHkuaAorKysgYi9zcmMvZHJpdmVycy9ubDgwMjExX2NvcHkuaApAQCAtMTU2LDIxICsxNTYsMjUgQEAKICAqIEBOTDgwMjExX0NNRF9ERUxfS0VZOiBkZWxldGUgYSBrZXkgaWRlbnRpZmllZCBieSAlTkw4MDIxMV9BVFRSX0tFWV9JRFgKICAqCW9yICVOTDgwMjExX0FUVFJfTUFDLgogICoKLSAqIEBOTDgwMjExX0NNRF9HRVRfQkVBQ09OOiByZXRyaWV2ZSBiZWFjb24gaW5mb3JtYXRpb24gKHJldHVybmVkIGluIGEKLSAqCSVOTDgwMjIyX0NNRF9ORVdfQkVBQ09OIG1lc3NhZ2UpCi0gKiBATkw4MDIxMV9DTURfU0VUX0JFQUNPTjogc2V0IHRoZSBiZWFjb24gb24gYW4gYWNjZXNzIHBvaW50IGludGVyZmFjZQotICoJdXNpbmcgdGhlICVOTDgwMjExX0FUVFJfQkVBQ09OX0lOVEVSVkFMLCAlTkw4MDIxMV9BVFRSX0RUSU1fUEVSSU9ELAotICoJJU5MODAyMTFfQVRUUl9CRUFDT05fSEVBRCBhbmQgJU5MODAyMTFfQVRUUl9CRUFDT05fVEFJTCBhdHRyaWJ1dGVzLgotICoJRm9sbG93aW5nIGF0dHJpYnV0ZXMgYXJlIHByb3ZpZGVkIGZvciBkcml2ZXJzIHRoYXQgZ2VuZXJhdGUgZnVsbCBCZWFjb24KLSAqCWFuZCBQcm9iZSBSZXNwb25zZSBmcmFtZXMgaW50ZXJuYWxseTogJU5MODAyMTFfQVRUUl9TU0lELAorICogQE5MODAyMTFfQ01EX0dFVF9CRUFDT046IChub3QgdXNlZCkKKyAqIEBOTDgwMjExX0NNRF9TRVRfQkVBQ09OOiBjaGFuZ2UgdGhlIGJlYWNvbiBvbiBhbiBhY2Nlc3MgcG9pbnQgaW50ZXJmYWNlCisgKgl1c2luZyB0aGUgJU5MODAyMTFfQVRUUl9CRUFDT05fSEVBRCBhbmQgJU5MODAyMTFfQVRUUl9CRUFDT05fVEFJTAorICoJYXR0cmlidXRlcy4gRm9yIGRyaXZlcnMgdGhhdCBnZW5lcmF0ZSB0aGUgYmVhY29uIGFuZCBwcm9iZSByZXNwb25zZXMKKyAqCWludGVybmFsbHksIHRoZSBmb2xsb3dpbmcgYXR0cmlidXRlcyBtdXN0IGJlIHByb3ZpZGVkOiAlTkw4MDIxMV9BVFRSX0lFLAorICoJJU5MODAyMTFfQVRUUl9JRV9QUk9CRV9SRVNQIGFuZCAlTkw4MDIxMV9BVFRSX0lFX0FTU09DX1JFU1AuCisgKiBATkw4MDIxMV9DTURfU1RBUlRfQVA6IFN0YXJ0IEFQIG9wZXJhdGlvbiBvbiBhbiBBUCBpbnRlcmZhY2UsIHBhcmFtZXRlcnMKKyAqCWFyZSBsaWtlIGZvciAlTkw4MDIxMV9DTURfU0VUX0JFQUNPTiwgYW5kIGFkZGl0aW9uYWxseSBwYXJhbWV0ZXJzIHRoYXQKKyAqCWRvIG5vdCBjaGFuZ2UgYXJlIHVzZWQsIHRoZXNlIGluY2x1ZGUgJU5MODAyMTFfQVRUUl9CRUFDT05fSU5URVJWQUwsCisgKgklTkw4MDIxMV9BVFRSX0RUSU1fUEVSSU9ELCAlTkw4MDIxMV9BVFRSX1NTSUQsCiAgKgklTkw4MDIxMV9BVFRSX0hJRERFTl9TU0lELCAlTkw4MDIxMV9BVFRSX0NJUEhFUlNfUEFJUldJU0UsCiAgKgklTkw4MDIxMV9BVFRSX0NJUEhFUl9HUk9VUCwgJU5MODAyMTFfQVRUUl9XUEFfVkVSU0lPTlMsCiAgKgklTkw4MDIxMV9BVFRSX0FLTV9TVUlURVMsICVOTDgwMjExX0FUVFJfUFJJVkFDWSwKLSAqCSVOTDgwMjExX0FUVFJfQVVUSF9UWVBFLCAlTkw4MDIxMV9BVFRSX0lFLCAlTkw4MDIxMV9BVFRSX0lFX1BST0JFX1JFU1AsCi0gKgklTkw4MDIxMV9BVFRSX0lFX0FTU09DX1JFU1AuCi0gKiBATkw4MDIxMV9DTURfTkVXX0JFQUNPTjogYWRkIGEgbmV3IGJlYWNvbiB0byBhbiBhY2Nlc3MgcG9pbnQgaW50ZXJmYWNlLAotICoJcGFyYW1ldGVycyBhcmUgbGlrZSBmb3IgJU5MODAyMTFfQ01EX1NFVF9CRUFDT04uCi0gKiBATkw4MDIxMV9DTURfREVMX0JFQUNPTjogcmVtb3ZlIHRoZSBiZWFjb24sIHN0b3Agc2VuZGluZyBpdAorICoJJU5MODAyMTFfQVRUUl9BVVRIX1RZUEUgYW5kICVOTDgwMjExX0FUVFJfSU5BQ1RJVklUWV9USU1FT1VULgorICoJVGhlIGNoYW5uZWwgdG8gdXNlIGNhbiBiZSBzZXQgb24gdGhlIGludGVyZmFjZSBvciBiZSBnaXZlbiB1c2luZyB0aGUKKyAqCSVOTDgwMjExX0FUVFJfV0lQSFlfRlJFUSBhbmQgJU5MODAyMTFfQVRUUl9XSVBIWV9DSEFOTkVMX1RZUEUgYXR0cnMuCisgKiBATkw4MDIxMV9DTURfTkVXX0JFQUNPTjogb2xkIGFsaWFzIGZvciAlTkw4MDIxMV9DTURfU1RBUlRfQVAKKyAqIEBOTDgwMjExX0NNRF9TVE9QX0FQOiBTdG9wIEFQIG9wZXJhdGlvbiBvbiB0aGUgZ2l2ZW4gaW50ZXJmYWNlCisgKiBATkw4MDIxMV9DTURfREVMX0JFQUNPTjogb2xkIGFsaWFzIGZvciAlTkw4MDIxMV9DTURfU1RPUF9BUAogICoKICAqIEBOTDgwMjExX0NNRF9HRVRfU1RBVElPTjogR2V0IHN0YXRpb24gYXR0cmlidXRlcyBmb3Igc3RhdGlvbiBpZGVudGlmaWVkIGJ5CiAgKgklTkw4MDIxMV9BVFRSX01BQyBvbiB0aGUgaW50ZXJmYWNlIGlkZW50aWZpZWQgYnkgJU5MODAyMTFfQVRUUl9JRklOREVYLgpAQCAtMjczLDYgKzI3NywxMiBAQAogICogQE5MODAyMTFfQ01EX05FV19TVVJWRVlfUkVTVUxUUzogc3VydmV5IGRhdGEgbm90aWZpY2F0aW9uIChhcyBhIHJlcGx5IHRvCiAgKglOTDgwMjExX0NNRF9HRVRfU1VSVkVZIGFuZCBvbiB0aGUgInNjYW4iIG11bHRpY2FzdCBncm91cCkKICAqCisgKiBATkw4MDIxMV9DTURfU0VUX1BNS1NBOiBBZGQgYSBQTUtTQSBjYWNoZSBlbnRyeSwgdXNpbmcgJU5MODAyMTFfQVRUUl9NQUMKKyAqCShmb3IgdGhlIEJTU0lEKSBhbmQgJU5MODAyMTFfQVRUUl9QTUtJRC4KKyAqIEBOTDgwMjExX0NNRF9ERUxfUE1LU0E6IERlbGV0ZSBhIFBNS1NBIGNhY2hlIGVudHJ5LCB1c2luZyAlTkw4MDIxMV9BVFRSX01BQworICoJKGZvciB0aGUgQlNTSUQpIGFuZCAlTkw4MDIxMV9BVFRSX1BNS0lELgorICogQE5MODAyMTFfQ01EX0ZMVVNIX1BNS1NBOiBGbHVzaCBhbGwgUE1LU0EgY2FjaGUgZW50cmllcy4KKyAqCiAgKiBATkw4MDIxMV9DTURfUkVHX0NIQU5HRTogaW5kaWNhdGVzIHRvIHVzZXJzcGFjZSB0aGUgcmVndWxhdG9yeSBkb21haW4KICAqIAloYXMgYmVlbiBjaGFuZ2VkIGFuZCBwcm92aWRlcyBkZXRhaWxzIG9mIHRoZSByZXF1ZXN0IGluZm9ybWF0aW9uCiAgKiAJdGhhdCBjYXVzZWQgdGhlIGNoYW5nZSBzdWNoIGFzIHdobyBpbml0aWF0ZWQgdGhlIHJlZ3VsYXRvcnkgcmVxdWVzdApAQCAtMzY3LDYgKzM3NywxMSBAQAogICoJJU5MODAyMTFfQVRUUl9XSVBIWV9GUkVRLCAlTkw4MDIxMV9BVFRSX0NPTlRST0xfUE9SVCwKICAqCSVOTDgwMjExX0FUVFJfQ09OVFJPTF9QT1JUX0VUSEVSVFlQRSBhbmQKICAqCSVOTDgwMjExX0FUVFJfQ09OVFJPTF9QT1JUX05PX0VOQ1JZUFQuCisgKglCYWNrZ3JvdW5kIHNjYW4gcGVyaW9kIGNhbiBvcHRpb25hbGx5IGJlCisgKglzcGVjaWZpZWQgaW4gJU5MODAyMTFfQVRUUl9CR19TQ0FOX1BFUklPRCwKKyAqCWlmIG5vdCBzcGVjaWZpZWQgZGVmYXVsdCBiYWNrZ3JvdW5kIHNjYW4gY29uZmlndXJhdGlvbgorICoJaW4gZHJpdmVyIGlzIHVzZWQgYW5kIGlmIHBlcmlvZCB2YWx1ZSBpcyAwLCBiZyBzY2FuIHdpbGwgYmUgZGlzYWJsZWQuCisgKglUaGlzIGF0dHJpYnV0ZSBpcyBpZ25vcmVkIGlmIGRyaXZlciBkb2VzIG5vdCBzdXBwb3J0IHJvYW0gc2Nhbi4KICAqCUl0IGlzIGFsc28gc2VudCBhcyBhbiBldmVudCwgd2l0aCB0aGUgQlNTSUQgYW5kIHJlc3BvbnNlIElFcyB3aGVuIHRoZQogICoJY29ubmVjdGlvbiBpcyBlc3RhYmxpc2hlZCBvciBmYWlsZWQgdG8gYmUgZXN0YWJsaXNoZWQuIFRoaXMgY2FuIGJlCiAgKglkZXRlcm1pbmVkIGJ5IHRoZSBTVEFUVVNfQ09ERSBhdHRyaWJ1dGUuCkBAIC00NDcsNiArNDYyLDEwIEBACiAgKgl0aGUgZnJhbWUuCiAgKiBATkw4MDIxMV9DTURfQUNUSU9OX1RYX1NUQVRVUzogQWxpYXMgZm9yIEBOTDgwMjExX0NNRF9GUkFNRV9UWF9TVEFUVVMgZm9yCiAgKgliYWNrd2FyZCBjb21wYXRpYmlsaXR5LgorICoKKyAqIEBOTDgwMjExX0NNRF9TRVRfUE9XRVJfU0FWRTogU2V0IHBvd2Vyc2F2ZSwgdXNpbmcgJU5MODAyMTFfQVRUUl9QU19TVEFURQorICogQE5MODAyMTFfQ01EX0dFVF9QT1dFUl9TQVZFOiBHZXQgcG93ZXJzYXZlIHN0YXR1cyBpbiAlTkw4MDIxMV9BVFRSX1BTX1NUQVRFCisgKgogICogQE5MODAyMTFfQ01EX1NFVF9DUU06IENvbm5lY3Rpb24gcXVhbGl0eSBtb25pdG9yIGNvbmZpZ3VyYXRpb24uIFRoaXMgY29tbWFuZAogICoJaXMgdXNlZCB0byBjb25maWd1cmUgY29ubmVjdGlvbiBxdWFsaXR5IG1vbml0b3Jpbmcgbm90aWZpY2F0aW9uIHRyaWdnZXIKICAqCWxldmVscy4KQEAgLTU0MSw2ICs1NjAsMTEgQEAKICAqIEBOTDgwMjExX0NNRF9TRVRfTk9BQ0tfTUFQOiBzZXRzIGEgYml0bWFwIGZvciB0aGUgaW5kaXZpZHVhbCBUSURzIHdoZXRoZXIKICAqICAgICAgTm8gQWNrbm93bGVkZ2VtZW50IFBvbGljeSBzaG91bGQgYmUgYXBwbGllZC4KICAqCisgKiBATkw4MDIxMV9DTURfQ0hfU1dJVENIX05PVElGWTogQW4gQVAgb3IgR08gbWF5IGRlY2lkZSB0byBzd2l0Y2ggY2hhbm5lbHMKKyAqCWluZGVwZW5kZW50bHkgb2YgdGhlIHVzZXJzcGFjZSBTTUUsIHNlbmQgdGhpcyBldmVudCBpbmRpY2F0aW5nCisgKgklTkw4MDIxMV9BVFRSX0lGSU5ERVggaXMgbm93IG9uICVOTDgwMjExX0FUVFJfV0lQSFlfRlJFUSB3aXRoCisgKgklTkw4MDIxMV9BVFRSX1dJUEhZX0NIQU5ORUxfVFlQRS4KKyAqCiAgKiBATkw4MDIxMV9DTURfTUFYOiBoaWdoZXN0IHVzZWQgY29tbWFuZCBudW1iZXIKICAqIEBfX05MODAyMTFfQ01EX0FGVEVSX0xBU1Q6IGludGVybmFsIHVzZQogICovCkBAIC01NjUsOCArNTg5LDEwIEBACiAKIAlOTDgwMjExX0NNRF9HRVRfQkVBQ09OLAogCU5MODAyMTFfQ01EX1NFVF9CRUFDT04sCi0JTkw4MDIxMV9DTURfTkVXX0JFQUNPTiwKLQlOTDgwMjExX0NNRF9ERUxfQkVBQ09OLAorCU5MODAyMTFfQ01EX1NUQVJUX0FQLAorCU5MODAyMTFfQ01EX05FV19CRUFDT04gPSBOTDgwMjExX0NNRF9TVEFSVF9BUCwKKwlOTDgwMjExX0NNRF9TVE9QX0FQLAorCU5MODAyMTFfQ01EX0RFTF9CRUFDT04gPSBOTDgwMjExX0NNRF9TVE9QX0FQLAogCiAJTkw4MDIxMV9DTURfR0VUX1NUQVRJT04sCiAJTkw4MDIxMV9DTURfU0VUX1NUQVRJT04sCkBAIC02ODAsNiArNzA2LDggQEAKIAogCU5MODAyMTFfQ01EX1NFVF9OT0FDS19NQVAsCiAKKwlOTDgwMjExX0NNRF9DSF9TV0lUQ0hfTk9USUZZLAorCiAJLyogYWRkIG5ldyBjb21tYW5kcyBhYm92ZSBoZXJlICovCiAKIAkvKiB1c2VkIHRvIGRlZmluZSBOTDgwMjExX0NNRF9NQVggYmVsb3cgKi8KQEAgLTc1Myw2ICs3ODEsMTMgQEAKICAqCXNlY3Rpb24gNy4zLjIuMjUuMSwgZS5nLiAweDAwMEZBQzA0KQogICogQE5MODAyMTFfQVRUUl9LRVlfU0VROiB0cmFuc21pdCBrZXkgc2VxdWVuY2UgbnVtYmVyIChJVi9QTikgZm9yIFRLSVAgYW5kCiAgKglDQ01QIGtleXMsIGVhY2ggc2l4IGJ5dGVzIGluIGxpdHRsZSBlbmRpYW4KKyAqIEBOTDgwMjExX0FUVFJfS0VZX0RFRkFVTFQ6IEZsYWcgYXR0cmlidXRlIGluZGljYXRpbmcgdGhlIGtleSBpcyBkZWZhdWx0IGtleQorICogQE5MODAyMTFfQVRUUl9LRVlfREVGQVVMVF9NR01UOiBGbGFnIGF0dHJpYnV0ZSBpbmRpY2F0aW5nIHRoZSBrZXkgaXMgdGhlCisgKglkZWZhdWx0IG1hbmFnZW1lbnQga2V5CisgKiBATkw4MDIxMV9BVFRSX0NJUEhFUl9TVUlURVNfUEFJUldJU0U6IEZvciBjcnlwdG8gc2V0dGluZ3MgZm9yIGNvbm5lY3Qgb3IKKyAqCW90aGVyIGNvbW1hbmRzLCBpbmRpY2F0ZXMgd2hpY2ggcGFpcndpc2UgY2lwaGVyIHN1aXRlcyBhcmUgdXNlZAorICogQE5MODAyMTFfQVRUUl9DSVBIRVJfU1VJVEVfR1JPVVA6IEZvciBjcnlwdG8gc2V0dGluZ3MgZm9yIGNvbm5lY3Qgb3IKKyAqCW90aGVyIGNvbW1hbmRzLCBpbmRpY2F0ZXMgd2hpY2ggZ3JvdXAgY2lwaGVyIHN1aXRlIGlzIHVzZWQKICAqCiAgKiBATkw4MDIxMV9BVFRSX0JFQUNPTl9JTlRFUlZBTDogYmVhY29uIGludGVydmFsIGluIFRVCiAgKiBATkw4MDIxMV9BVFRSX0RUSU1fUEVSSU9EOiBEVElNIHBlcmlvZCBmb3IgYmVhY29uaW5nCkBAIC05ODgsNiArMTAyMyw4IEBACiAgKiBATkw4MDIxMV9BVFRSX0FDSzogRmxhZyBhdHRyaWJ1dGUgaW5kaWNhdGluZyB0aGF0IHRoZSBmcmFtZSB3YXMKICAqCWFja25vd2xlZGdlZCBieSB0aGUgcmVjaXBpZW50LgogICoKKyAqIEBOTDgwMjExX0FUVFJfUFNfU1RBVEU6IHBvd2Vyc2F2ZSBzdGF0ZSwgdXNpbmcgJmVudW0gbmw4MDIxMV9wc19zdGF0ZSB2YWx1ZXMuCisgKgogICogQE5MODAyMTFfQVRUUl9DUU06IGNvbm5lY3Rpb24gcXVhbGl0eSBtb25pdG9yIGNvbmZpZ3VyYXRpb24gaW4gYQogICoJbmVzdGVkIGF0dHJpYnV0ZSB3aXRoICVOTDgwMjExX0FUVFJfQ1FNXyogc3ViLWF0dHJpYnV0ZXMuCiAgKgpAQCAtMTA0NSw3ICsxMDgyLDcgQEAKICAqCWZsYWcgaXNuJ3Qgc2V0LCB0aGUgZnJhbWUgd2lsbCBiZSByZWplY3RlZC4gVGhpcyBpcyBhbHNvIHVzZWQgYXMgYW4KICAqCW5sODAyMTEgY2FwYWJpbGl0eSBmbGFnLgogICoKLSAqIEBOTDgwMjExX0FUVFJfQlNTX0hUT1BNT0RFOiBIVCBvcGVyYXRpb24gbW9kZSAodTE2KQorICogQE5MODAyMTFfQVRUUl9CU1NfSFRfT1BNT0RFOiBIVCBvcGVyYXRpb24gbW9kZSAodTE2KQogICoKICAqIEBOTDgwMjExX0FUVFJfS0VZX0RFRkFVTFRfVFlQRVM6IEEgbmVzdGVkIGF0dHJpYnV0ZSBjb250YWluaW5nIGZsYWdzCiAgKglhdHRyaWJ1dGVzLCBzcGVjaWZ5aW5nIHdoYXQgYSBrZXkgc2hvdWxkIGJlIHNldCBhcyBkZWZhdWx0IGFzLgpAQCAtMTA2OSwxMCArMTEwNiwxMCBAQAogICoJaW5kaWNhdGUgd2hpY2ggV29XIHRyaWdnZXJzIHNob3VsZCBiZSBlbmFibGVkLiBUaGlzIGlzIGFsc28KICAqCXVzZWQgYnkgJU5MODAyMTFfQ01EX0dFVF9XT1dMQU4gdG8gZ2V0IHRoZSBjdXJyZW50bHkgZW5hYmxlZCBXb1dMQU4KICAqCXRyaWdnZXJzLgotCisgKgogICogQE5MODAyMTFfQVRUUl9TQ0hFRF9TQ0FOX0lOVEVSVkFMOiBJbnRlcnZhbCBiZXR3ZWVuIHNjaGVkdWxlZCBzY2FuCiAgKgljeWNsZXMsIGluIG1zZWNzLgotCisgKgogICogQE5MODAyMTFfQVRUUl9TQ0hFRF9TQ0FOX01BVENIOiBOZXN0ZWQgYXR0cmlidXRlIHdpdGggb25lIG9yIG1vcmUKICAqCXNldHMgb2YgYXR0cmlidXRlcyB0byBtYXRjaCBkdXJpbmcgc2NoZWR1bGVkIHNjYW5zLiAgT25seSBCU1NzCiAgKgl0aGF0IG1hdGNoIGFueSBvZiB0aGUgc2V0cyB3aWxsIGJlIHJlcG9ydGVkLiAgVGhlc2UgYXJlCkBAIC0xMDk5LDcgKzExMzYsNyBAQAogICoJYXJlIG1hbmFnZWQgaW4gc29mdHdhcmU6IGludGVyZmFjZXMgb2YgdGhlc2UgdHlwZXMgYXJlbid0IHN1YmplY3QgdG8KICAqCWFueSByZXN0cmljdGlvbnMgaW4gdGhlaXIgbnVtYmVyIG9yIGNvbWJpbmF0aW9ucy4KICAqCi0gKiBAJU5MODAyMTFfQVRUUl9SRUtFWV9EQVRBOiBuZXN0ZWQgYXR0cmlidXRlIGNvbnRhaW5pbmcgdGhlIGluZm9ybWF0aW9uCisgKiBATkw4MDIxMV9BVFRSX1JFS0VZX0RBVEE6IG5lc3RlZCBhdHRyaWJ1dGUgY29udGFpbmluZyB0aGUgaW5mb3JtYXRpb24KICAqCW5lY2Vzc2FyeSBmb3IgR1RLIHJla2V5aW5nIGluIHRoZSBkZXZpY2UsIHNlZSAmZW51bSBubDgwMjExX3Jla2V5X2RhdGEuCiAgKgogICogQE5MODAyMTFfQVRUUl9TQ0FOX1NVUFBfUkFURVM6IHJhdGVzIHBlciB0byBiZSBhZHZlcnRpc2VkIGFzIHN1cHBvcnRlZCBpbiBzY2FuLApAQCAtMTE2Niw3ICsxMjAzLDYgQEAKICAqIEBOTDgwMjExX0FUVFJfRkVBVFVSRV9GTEFHUzogVGhpcyB1MzIgYXR0cmlidXRlIGNvbnRhaW5zIGZsYWdzIGZyb20KICAqCSZlbnVtIG5sODAyMTFfZmVhdHVyZV9mbGFncyBhbmQgaXMgYWR2ZXJ0aXNlZCBpbiB3aXBoeSBpbmZvcm1hdGlvbi4KICAqIEBOTDgwMjExX0FUVFJfUFJPQkVfUkVTUF9PRkZMT0FEOiBJbmRpY2F0ZXMgdGhhdCB0aGUgSFcgcmVzcG9uZHMgdG8gcHJvYmUKLSAqCiAgKglyZXF1ZXN0cyB3aGlsZSBvcGVyYXRpbmcgaW4gQVAtbW9kZS4KICAqCVRoaXMgYXR0cmlidXRlIGhvbGRzIGEgYml0bWFwIG9mIHRoZSBzdXBwb3J0ZWQgcHJvdG9jb2xzIGZvcgogICoJb2ZmbG9hZGluZyAoc2VlICZlbnVtIG5sODAyMTFfcHJvYmVfcmVzcF9vZmZsb2FkX3N1cHBvcnRfYXR0cikuCkBAIC0xMTkzLDYgKzEyMjksMTkgQEAKICAqIEBOTDgwMjExX0FUVFJfTk9BQ0tfTUFQOiBUaGlzIHUxNiBiaXRtYXAgY29udGFpbnMgdGhlIE5vIEFjayBQb2xpY3kgb2YKICAqICAgICAgdXAgdG8gMTYgVElEcy4KICAqCisgKiBATkw4MDIxMV9BVFRSX0lOQUNUSVZJVFlfVElNRU9VVDogdGltZW91dCB2YWx1ZSBpbiBzZWNvbmRzLCB0aGlzIGNhbiBiZQorICoJdXNlZCBieSB0aGUgZHJpdmVycyB3aGljaCBoYXMgTUxNRSBpbiBmaXJtd2FyZSBhbmQgZG9lcyBub3QgaGF2ZSBzdXBwb3J0CisgKgl0byByZXBvcnQgcGVyIHN0YXRpb24gdHgvcnggYWN0aXZpdHkgdG8gZnJlZSB1cCB0aGUgc3RhaW9uIGVudHJ5IGZyb20KKyAqCXRoZSBsaXN0LiBUaGlzIG5lZWRzIHRvIGJlIHVzZWQgd2hlbiB0aGUgZHJpdmVyIGFkdmVydGlzZXMgdGhlCisgKgljYXBhYmlsaXR5IHRvIHRpbWVvdXQgdGhlIHN0YXRpb25zLgorICoKKyAqIEBOTDgwMjExX0FUVFJfUlhfU0lHTkFMX0RCTTogc2lnbmFsIHN0cmVuZ3RoIGluIGRCbSAoYXMgYSAzMi1iaXQgaW50KTsKKyAqCXRoaXMgYXR0cmlidXRlIGlzIChkZXBlbmRpbmcgb24gdGhlIGRyaXZlciBjYXBhYmlsaXRpZXMpIGFkZGVkIHRvCisgKglyZWNlaXZlZCBmcmFtZXMgaW5kaWNhdGVkIHdpdGggJU5MODAyMTFfQ01EX0ZSQU1FLgorICoKKyAqIEBOTDgwMjExX0FUVFJfQkdfU0NBTl9QRVJJT0Q6IEJhY2tncm91bmQgc2NhbiBwZXJpb2QgaW4gc2Vjb25kcworICogICAgICBvciAwIHRvIGRpc2FibGUgYmFja2dyb3VuZCBzY2FuLgorICoKICAqIEBOTDgwMjExX0FUVFJfTUFYOiBoaWdoZXN0IGF0dHJpYnV0ZSBudW1iZXIgY3VycmVudGx5IGRlZmluZWQKICAqIEBfX05MODAyMTFfQVRUUl9BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKICAqLwpAQCAtMTQzOCw2ICsxNDg3LDEyIEBACiAKIAlOTDgwMjExX0FUVFJfTk9BQ0tfTUFQLAogCisJTkw4MDIxMV9BVFRSX0lOQUNUSVZJVFlfVElNRU9VVCwKKworCU5MODAyMTFfQVRUUl9SWF9TSUdOQUxfREJNLAorCisJTkw4MDIxMV9BVFRSX0JHX1NDQU5fUEVSSU9ELAorCiAJLyogYWRkIGF0dHJpYnV0ZXMgaGVyZSwgdXBkYXRlIHRoZSBwb2xpY3kgaW4gbmw4MDIxMS5jICovCiAKIAlfX05MODAyMTFfQVRUUl9BRlRFUl9MQVNULApAQCAtMTQ3NSw2ICsxNTMwLDcgQEAKICNkZWZpbmUgTkw4MDIxMV9BVFRSX0ZFQVRVUkVfRkxBR1MgTkw4MDIxMV9BVFRSX0ZFQVRVUkVfRkxBR1MKIAogI2RlZmluZSBOTDgwMjExX01BWF9TVVBQX1JBVEVTCQkJMzIKKyNkZWZpbmUgTkw4MDIxMV9NQVhfU1VQUF9IVF9SQVRFUwkJNzcKICNkZWZpbmUgTkw4MDIxMV9NQVhfU1VQUF9SRUdfUlVMRVMJCTMyCiAjZGVmaW5lIE5MODAyMTFfVEtJUF9EQVRBX09GRlNFVF9FTkNSX0tFWQkwCiAjZGVmaW5lIE5MODAyMTFfVEtJUF9EQVRBX09GRlNFVF9UWF9NSUNfS0VZCTE2CkBAIC0xNDg0LDYgKzE1NDAsMTEgQEAKICNkZWZpbmUgTkw4MDIxMV9NQVhfTlJfQ0lQSEVSX1NVSVRFUwkJNQogI2RlZmluZSBOTDgwMjExX01BWF9OUl9BS01fU1VJVEVTCQkyCiAKKyNkZWZpbmUgTkw4MDIxMV9NSU5fUkVNQUlOX09OX0NIQU5ORUxfVElNRQkxMAorCisvKiBkZWZhdWx0IFJTU0kgdGhyZXNob2xkIGZvciBzY2FuIHJlc3VsdHMgaWYgbm9uZSBzcGVjaWZpZWQuICovCisjZGVmaW5lIE5MODAyMTFfU0NBTl9SU1NJX1RIT0xEX09GRgkJLTMwMAorCiAvKioKICAqIGVudW0gbmw4MDIxMV9pZnR5cGUgLSAodmlydHVhbCkgaW50ZXJmYWNlIHR5cGVzCiAgKgpAQCAtMTU1OCw2ICsxNjE5LDggQEAKIAlOTDgwMjExX1NUQV9GTEFHX01BWCA9IF9fTkw4MDIxMV9TVEFfRkxBR19BRlRFUl9MQVNUIC0gMQogfTsKIAorI2RlZmluZSBOTDgwMjExX1NUQV9GTEFHX01BWF9PTERfQVBJCU5MODAyMTFfU1RBX0ZMQUdfVERMU19QRUVSCisKIC8qKgogICogc3RydWN0IG5sODAyMTFfc3RhX2ZsYWdfdXBkYXRlIC0gc3RhdGlvbiBmbGFncyBtYXNrL3NldAogICogQG1hc2s6IG1hc2sgb2Ygc3RhdGlvbiBmbGFncyB0byBzZXQKQEAgLTE2NTYsNiArMTcxOSw3IEBACiAgKiBATkw4MDIxMV9TVEFfSU5GT19DT05ORUNURURfVElNRTogdGltZSBzaW5jZSB0aGUgc3RhdGlvbiBpcyBsYXN0IGNvbm5lY3RlZAogICogQE5MODAyMTFfU1RBX0lORk9fU1RBX0ZMQUdTOiBDb250YWlucyBhIHN0cnVjdCBubDgwMjExX3N0YV9mbGFnX3VwZGF0ZS4KICAqIEBOTDgwMjExX1NUQV9JTkZPX0JFQUNPTl9MT1NTOiBjb3VudCBvZiB0aW1lcyBiZWFjb24gbG9zcyB3YXMgZGV0ZWN0ZWQgKHUzMikKKyAqIEBOTDgwMjExX1NUQV9JTkZPX1RfT0ZGU0VUOiB0aW1pbmcgb2Zmc2V0IHdpdGggcmVzcGVjdCB0byB0aGlzIFNUQSAoczY0KQogICogQF9fTkw4MDIxMV9TVEFfSU5GT19BRlRFUl9MQVNUOiBpbnRlcm5hbAogICogQE5MODAyMTFfU1RBX0lORk9fTUFYOiBoaWdoZXN0IHBvc3NpYmxlIHN0YXRpb24gaW5mbyBhdHRyaWJ1dGUKICAqLwpAQCAtMTY3OSw2ICsxNzQzLDcgQEAKIAlOTDgwMjExX1NUQV9JTkZPX0NPTk5FQ1RFRF9USU1FLAogCU5MODAyMTFfU1RBX0lORk9fU1RBX0ZMQUdTLAogCU5MODAyMTFfU1RBX0lORk9fQkVBQ09OX0xPU1MsCisJTkw4MDIxMV9TVEFfSU5GT19UX09GRlNFVCwKIAogCS8qIGtlZXAgbGFzdCAqLwogCV9fTkw4MDIxMV9TVEFfSU5GT19BRlRFUl9MQVNULApAQCAtMTc0OCw2ICsxODEzLDkgQEAKICAqIEBOTDgwMjExX0JBTkRfQVRUUl9IVF9DQVBBOiBIVCBjYXBhYmlsaXRpZXMsIGFzIGluIHRoZSBIVCBpbmZvcm1hdGlvbiBJRQogICogQE5MODAyMTFfQkFORF9BVFRSX0hUX0FNUERVX0ZBQ1RPUjogQS1NUERVIGZhY3RvciwgYXMgaW4gMTFuCiAgKiBATkw4MDIxMV9CQU5EX0FUVFJfSFRfQU1QRFVfREVOU0lUWTogQS1NUERVIGRlbnNpdHksIGFzIGluIDExbgorICogQE5MODAyMTFfQkFORF9BVFRSX1ZIVF9NQ1NfU0VUOiAzMi1ieXRlIGF0dHJpYnV0ZSBjb250YWluaW5nIHRoZSBNQ1Mgc2V0IGFzCisgKglkZWZpbmVkIGluIDgwMi4xMWFjCisgKiBATkw4MDIxMV9CQU5EX0FUVFJfVkhUX0NBUEE6IFZIVCBjYXBhYmlsaXRpZXMsIGFzIGluIHRoZSBIVCBpbmZvcm1hdGlvbiBJRQogICogQE5MODAyMTFfQkFORF9BVFRSX01BWDogaGlnaGVzdCBiYW5kIGF0dHJpYnV0ZSBjdXJyZW50bHkgZGVmaW5lZAogICogQF9fTkw4MDIxMV9CQU5EX0FUVFJfQUZURVJfTEFTVDogaW50ZXJuYWwgdXNlCiAgKi8KQEAgLTE3NjEsNiArMTgyOSw5IEBACiAJTkw4MDIxMV9CQU5EX0FUVFJfSFRfQU1QRFVfRkFDVE9SLAogCU5MODAyMTFfQkFORF9BVFRSX0hUX0FNUERVX0RFTlNJVFksCiAKKwlOTDgwMjExX0JBTkRfQVRUUl9WSFRfTUNTX1NFVCwKKwlOTDgwMjExX0JBTkRfQVRUUl9WSFRfQ0FQQSwKKwogCS8qIGtlZXAgbGFzdCAqLwogCV9fTkw4MDIxMV9CQU5EX0FUVFJfQUZURVJfTEFTVCwKIAlOTDgwMjExX0JBTkRfQVRUUl9NQVggPSBfX05MODAyMTFfQkFORF9BVFRSX0FGVEVSX0xBU1QgLSAxCkBAIC0xOTEyLDYgKzE5ODMsOCBAQAogICogQF9fTkw4MDIxMV9TQ0hFRF9TQ0FOX01BVENIX0FUVFJfSU5WQUxJRDogYXR0cmlidXRlIG51bWJlciAwIGlzIHJlc2VydmVkCiAgKiBATkw4MDIxMV9TQ0hFRF9TQ0FOX01BVENIX0FUVFJfU1NJRDogU1NJRCB0byBiZSB1c2VkIGZvciBtYXRjaGluZywKICAqIG9ubHkgcmVwb3J0IEJTUyB3aXRoIG1hdGNoaW5nIFNTSUQuCisgKiBATkw4MDIxMV9TQ0hFRF9TQ0FOX01BVENIX0FUVFJfUlNTSTogUlNTSSB0aHJlc2hvbGQgKGluIGRCbSkgZm9yIHJlcG9ydGluZyBhCisgKglCU1MgaW4gc2NhbiByZXN1bHRzLiBGaWx0ZXJpbmcgaXMgdHVybmVkIG9mZiBpZiBub3Qgc3BlY2lmaWVkLgogICogQE5MODAyMTFfU0NIRURfU0NBTl9NQVRDSF9BVFRSX01BWDogaGlnaGVzdCBzY2hlZHVsZWQgc2NhbiBmaWx0ZXIKICAqCWF0dHJpYnV0ZSBudW1iZXIgY3VycmVudGx5IGRlZmluZWQKICAqIEBfX05MODAyMTFfU0NIRURfU0NBTl9NQVRDSF9BVFRSX0FGVEVSX0xBU1Q6IGludGVybmFsIHVzZQpAQCAtMTkxOSw3ICsxOTkyLDggQEAKIGVudW0gbmw4MDIxMV9zY2hlZF9zY2FuX21hdGNoX2F0dHIgewogCV9fTkw4MDIxMV9TQ0hFRF9TQ0FOX01BVENIX0FUVFJfSU5WQUxJRCwKIAotCU5MODAyMTFfQVRUUl9TQ0hFRF9TQ0FOX01BVENIX1NTSUQsCisJTkw4MDIxMV9TQ0hFRF9TQ0FOX01BVENIX0FUVFJfU1NJRCwKKwlOTDgwMjExX1NDSEVEX1NDQU5fTUFUQ0hfQVRUUl9SU1NJLAogCiAJLyoga2VlcCBsYXN0ICovCiAJX19OTDgwMjExX1NDSEVEX1NDQU5fTUFUQ0hfQVRUUl9BRlRFUl9MQVNULApAQCAtMTkyNyw2ICsyMDAxLDkgQEAKIAkJX19OTDgwMjExX1NDSEVEX1NDQU5fTUFUQ0hfQVRUUl9BRlRFUl9MQVNUIC0gMQogfTsKIAorLyogb25seSBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSAqLworI2RlZmluZSBOTDgwMjExX0FUVFJfU0NIRURfU0NBTl9NQVRDSF9TU0lEIE5MODAyMTFfU0NIRURfU0NBTl9NQVRDSF9BVFRSX1NTSUQKKwogLyoqCiAgKiBlbnVtIG5sODAyMTFfcmVnX3J1bGVfZmxhZ3MgLSByZWd1bGF0b3J5IHJ1bGUgZmxhZ3MKICAqCkBAIC0xOTU2LDkgKzIwMzMsOSBAQAogICogZW51bSBubDgwMjExX2Rmc19yZWdpb25zIC0gcmVndWxhdG9yeSBERlMgcmVnaW9ucwogICoKICAqIEBOTDgwMjExX0RGU19VTlNFVDogQ291bnRyeSBoYXMgbm8gREZTIG1hc3RlciByZWdpb24gc3BlY2lmaWVkCi0gKiBATkw4MDIxMV9ERlNfRkNDXzogQ291bnRyeSBmb2xsb3dzIERGUyBtYXN0ZXIgcnVsZXMgZnJvbSBGQ0MKLSAqIEBOTDgwMjExX0RGU19GQ0NfOiBDb3VudHJ5IGZvbGxvd3MgREZTIG1hc3RlciBydWxlcyBmcm9tIEVUU0kKLSAqIEBOTDgwMjExX0RGU19KUF86IENvdW50cnkgZm9sbG93cyBERlMgbWFzdGVyIHJ1bGVzIGZyb20gSlAvTUtLL1RlbGVjCisgKiBATkw4MDIxMV9ERlNfRkNDOiBDb3VudHJ5IGZvbGxvd3MgREZTIG1hc3RlciBydWxlcyBmcm9tIEZDQworICogQE5MODAyMTFfREZTX0VUU0k6IENvdW50cnkgZm9sbG93cyBERlMgbWFzdGVyIHJ1bGVzIGZyb20gRVRTSQorICogQE5MODAyMTFfREZTX0pQOiBDb3VudHJ5IGZvbGxvd3MgREZTIG1hc3RlciBydWxlcyBmcm9tIEpQL01LSy9UZWxlYwogICovCiBlbnVtIG5sODAyMTFfZGZzX3JlZ2lvbnMgewogCU5MODAyMTFfREZTX1VOU0VUCT0gMCwKQEAgLTIwNDYsNjkgKzIxMjMsOTEgQEAKICAqIEBfX05MODAyMTFfTUVTSENPTkZfSU5WQUxJRDogaW50ZXJuYWwgdXNlCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfUkVUUllfVElNRU9VVDogc3BlY2lmaWVzIHRoZSBpbml0aWFsIHJldHJ5IHRpbWVvdXQgaW4KLSAqIG1pbGxpc2Vjb25kIHVuaXRzLCB1c2VkIGJ5IHRoZSBQZWVyIExpbmsgT3BlbiBtZXNzYWdlCisgKgltaWxsaXNlY29uZCB1bml0cywgdXNlZCBieSB0aGUgUGVlciBMaW5rIE9wZW4gbWVzc2FnZQogICoKICAqIEBOTDgwMjExX01FU0hDT05GX0NPTkZJUk1fVElNRU9VVDogc3BlY2lmaWVzIHRoZSBpbml0aWFsIGNvbmZpcm0gdGltZW91dCwgaW4KLSAqIG1pbGxpc2Vjb25kIHVuaXRzLCB1c2VkIGJ5IHRoZSBwZWVyIGxpbmsgbWFuYWdlbWVudCB0byBjbG9zZSBhIHBlZXIgbGluaworICoJbWlsbGlzZWNvbmQgdW5pdHMsIHVzZWQgYnkgdGhlIHBlZXIgbGluayBtYW5hZ2VtZW50IHRvIGNsb3NlIGEgcGVlciBsaW5rCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfSE9MRElOR19USU1FT1VUOiBzcGVjaWZpZXMgdGhlIGhvbGRpbmcgdGltZW91dCwgaW4KLSAqIG1pbGxpc2Vjb25kIHVuaXRzCisgKgltaWxsaXNlY29uZCB1bml0cwogICoKICAqIEBOTDgwMjExX01FU0hDT05GX01BWF9QRUVSX0xJTktTOiBtYXhpbXVtIG51bWJlciBvZiBwZWVyIGxpbmtzIGFsbG93ZWQKLSAqIG9uIHRoaXMgbWVzaCBpbnRlcmZhY2UKKyAqCW9uIHRoaXMgbWVzaCBpbnRlcmZhY2UKICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9NQVhfUkVUUklFUzogc3BlY2lmaWVzIHRoZSBtYXhpbXVtIG51bWJlciBvZiBwZWVyIGxpbmsKLSAqIG9wZW4gcmV0cmllcyB0aGF0IGNhbiBiZSBzZW50IHRvIGVzdGFibGlzaCBhIG5ldyBwZWVyIGxpbmsgaW5zdGFuY2UgaW4gYQotICogbWVzaAorICoJb3BlbiByZXRyaWVzIHRoYXQgY2FuIGJlIHNlbnQgdG8gZXN0YWJsaXNoIGEgbmV3IHBlZXIgbGluayBpbnN0YW5jZSBpbiBhCisgKgltZXNoCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfVFRMOiBzcGVjaWZpZXMgdGhlIHZhbHVlIG9mIFRUTCBmaWVsZCBzZXQgYXQgYSBzb3VyY2UgbWVzaAotICogcG9pbnQuCisgKglwb2ludC4KICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9BVVRPX09QRU5fUExJTktTOiB3aGV0aGVyIHdlIHNob3VsZCBhdXRvbWF0aWNhbGx5Ci0gKiBvcGVuIHBlZXIgbGlua3Mgd2hlbiB3ZSBkZXRlY3QgY29tcGF0aWJsZSBtZXNoIHBlZXJzLgorICoJb3BlbiBwZWVyIGxpbmtzIHdoZW4gd2UgZGV0ZWN0IGNvbXBhdGlibGUgbWVzaCBwZWVycy4KICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9IV01QX01BWF9QUkVRX1JFVFJJRVM6IHRoZSBudW1iZXIgb2YgYWN0aW9uIGZyYW1lcwotICogY29udGFpbmluZyBhIFBSRVEgdGhhdCBhbiBNUCBjYW4gc2VuZCB0byBhIHBhcnRpY3VsYXIgZGVzdGluYXRpb24gKHBhdGgKLSAqIHRhcmdldCkKKyAqCWNvbnRhaW5pbmcgYSBQUkVRIHRoYXQgYW4gTVAgY2FuIHNlbmQgdG8gYSBwYXJ0aWN1bGFyIGRlc3RpbmF0aW9uIChwYXRoCisgKgl0YXJnZXQpCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfUEFUSF9SRUZSRVNIX1RJTUU6IGhvdyBmcmVxdWVudGx5IHRvIHJlZnJlc2ggbWVzaCBwYXRocwotICogKGluIG1pbGxpc2Vjb25kcykKKyAqCShpbiBtaWxsaXNlY29uZHMpCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfTUlOX0RJU0NPVkVSWV9USU1FT1VUOiBtaW5pbXVtIGxlbmd0aCBvZiB0aW1lIHRvIHdhaXQKLSAqIHVudGlsIGdpdmluZyB1cCBvbiBhIHBhdGggZGlzY292ZXJ5IChpbiBtaWxsaXNlY29uZHMpCisgKgl1bnRpbCBnaXZpbmcgdXAgb24gYSBwYXRoIGRpc2NvdmVyeSAoaW4gbWlsbGlzZWNvbmRzKQogICoKICAqIEBOTDgwMjExX01FU0hDT05GX0hXTVBfQUNUSVZFX1BBVEhfVElNRU9VVDogVGhlIHRpbWUgKGluIFRVcykgZm9yIHdoaWNoIG1lc2gKLSAqIHBvaW50cyByZWNlaXZpbmcgYSBQUkVRIHNoYWxsIGNvbnNpZGVyIHRoZSBmb3J3YXJkaW5nIGluZm9ybWF0aW9uIGZyb20gdGhlCi0gKiByb290IHRvIGJlIHZhbGlkLiAoVFUgPSB0aW1lIHVuaXQpCisgKglwb2ludHMgcmVjZWl2aW5nIGEgUFJFUSBzaGFsbCBjb25zaWRlciB0aGUgZm9yd2FyZGluZyBpbmZvcm1hdGlvbiBmcm9tCisgKgl0aGUgcm9vdCB0byBiZSB2YWxpZC4gKFRVID0gdGltZSB1bml0KQogICoKICAqIEBOTDgwMjExX01FU0hDT05GX0hXTVBfUFJFUV9NSU5fSU5URVJWQUw6IFRoZSBtaW5pbXVtIGludGVydmFsIG9mIHRpbWUgKGluCi0gKiBUVXMpIGR1cmluZyB3aGljaCBhbiBNUCBjYW4gc2VuZCBvbmx5IG9uZSBhY3Rpb24gZnJhbWUgY29udGFpbmluZyBhIFBSRVEKLSAqIHJlZmVyZW5jZSBlbGVtZW50CisgKglUVXMpIGR1cmluZyB3aGljaCBhbiBNUCBjYW4gc2VuZCBvbmx5IG9uZSBhY3Rpb24gZnJhbWUgY29udGFpbmluZyBhIFBSRVEKKyAqCXJlZmVyZW5jZSBlbGVtZW50CiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfSFdNUF9ORVRfRElBTV9UUlZTX1RJTUU6IFRoZSBpbnRlcnZhbCBvZiB0aW1lIChpbiBUVXMpCi0gKiB0aGF0IGl0IHRha2VzIGZvciBhbiBIV01QIGluZm9ybWF0aW9uIGVsZW1lbnQgdG8gcHJvcGFnYXRlIGFjcm9zcyB0aGUgbWVzaAorICoJdGhhdCBpdCB0YWtlcyBmb3IgYW4gSFdNUCBpbmZvcm1hdGlvbiBlbGVtZW50IHRvIHByb3BhZ2F0ZSBhY3Jvc3MgdGhlCisgKgltZXNoCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfSFdNUF9ST09UTU9ERTogd2hldGhlciByb290IG1vZGUgaXMgZW5hYmxlZCBvciBub3QKICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9FTEVNRU5UX1RUTDogc3BlY2lmaWVzIHRoZSB2YWx1ZSBvZiBUVEwgZmllbGQgc2V0IGF0IGEKLSAqIHNvdXJjZSBtZXNoIHBvaW50IGZvciBwYXRoIHNlbGVjdGlvbiBlbGVtZW50cy4KKyAqCXNvdXJjZSBtZXNoIHBvaW50IGZvciBwYXRoIHNlbGVjdGlvbiBlbGVtZW50cy4KICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9IV01QX1JBTk5fSU5URVJWQUw6ICBUaGUgaW50ZXJ2YWwgb2YgdGltZSAoaW4gVFVzKSBiZXR3ZWVuCi0gKiByb290IGFubm91bmNlbWVudHMgYXJlIHRyYW5zbWl0dGVkLgorICoJcm9vdCBhbm5vdW5jZW1lbnRzIGFyZSB0cmFuc21pdHRlZC4KICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9HQVRFX0FOTk9VTkNFTUVOVFM6IEFkdmVydGlzZSB0aGF0IHRoaXMgbWVzaCBzdGF0aW9uIGhhcwotICogYWNjZXNzIHRvIGEgYnJvYWRlciBuZXR3b3JrIGJleW9uZCB0aGUgTUJTUy4gIFRoaXMgaXMgZG9uZSB2aWEgUm9vdAotICogQW5ub3VuY2VtZW50IGZyYW1lcy4KKyAqCWFjY2VzcyB0byBhIGJyb2FkZXIgbmV0d29yayBiZXlvbmQgdGhlIE1CU1MuICBUaGlzIGlzIGRvbmUgdmlhIFJvb3QKKyAqCUFubm91bmNlbWVudCBmcmFtZXMuCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfSFdNUF9QRVJSX01JTl9JTlRFUlZBTDogVGhlIG1pbmltdW0gaW50ZXJ2YWwgb2YgdGltZSAoaW4KLSAqIFRVcykgZHVyaW5nIHdoaWNoIGEgbWVzaCBTVEEgY2FuIHNlbmQgb25seSBvbmUgQWN0aW9uIGZyYW1lIGNvbnRhaW5pbmcgYQotICogUEVSUiBlbGVtZW50LgorICoJVFVzKSBkdXJpbmcgd2hpY2ggYSBtZXNoIFNUQSBjYW4gc2VuZCBvbmx5IG9uZSBBY3Rpb24gZnJhbWUgY29udGFpbmluZyBhCisgKglQRVJSIGVsZW1lbnQuCiAgKgogICogQE5MODAyMTFfTUVTSENPTkZfRk9SV0FSRElORzogc2V0IE1lc2ggU1RBIGFzIGZvcndhcmRpbmcgb3Igbm9uLWZvcndhcmRpbmcKLSAqIG9yIGZvcndhcmRpbmcgZW50aXR5IChkZWZhdWx0IGlzIFRSVUUgLSBmb3J3YXJkaW5nIGVudGl0eSkKKyAqCW9yIGZvcndhcmRpbmcgZW50aXR5IChkZWZhdWx0IGlzIFRSVUUgLSBmb3J3YXJkaW5nIGVudGl0eSkKKyAqCisgKiBATkw4MDIxMV9NRVNIQ09ORl9SU1NJX1RIUkVTSE9MRDogUlNTSSB0aHJlc2hvbGQgaW4gZEJtLiBUaGlzIHNwZWNpZmllcyB0aGUKKyAqCXRocmVzaG9sZCBmb3IgYXZlcmFnZSBzaWduYWwgc3RyZW5ndGggb2YgY2FuZGlkYXRlIHN0YXRpb24gdG8gZXN0YWJsaXNoCisgKglhIHBlZXIgbGluay4KKyAqCisgKiBATkw4MDIxMV9NRVNIQ09ORl9TWU5DX09GRlNFVF9NQVhfTkVJR0hCT1I6IG1heGltdW0gbnVtYmVyIG9mIG5laWdoYm9ycworICoJdG8gc3luY2hyb25pemUgdG8gZm9yIDExcyBkZWZhdWx0IHN5bmNocm9uaXphdGlvbiBtZXRob2QKKyAqCShzZWUgMTFDLjEyLjIuMikKKyAqCisgKiBATkw4MDIxMV9NRVNIQ09ORl9IVF9PUE1PREU6IHNldCBtZXNoIEhUIHByb3RlY3Rpb24gbW9kZS4KICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9BVFRSX01BWDogaGlnaGVzdCBwb3NzaWJsZSBtZXNoIGNvbmZpZ3VyYXRpb24gYXR0cmlidXRlCiAgKgorICogQE5MODAyMTFfTUVTSENPTkZfSFdNUF9QQVRIX1RPX1JPT1RfVElNRU9VVDogVGhlIHRpbWUgKGluIFRVcykgZm9yCisgKgl3aGljaCBtZXNoIFNUQXMgcmVjZWl2aW5nIGEgcHJvYWN0aXZlIFBSRVEgc2hhbGwgY29uc2lkZXIgdGhlIGZvcndhcmRpbmcKKyAqCWluZm9ybWF0aW9uIHRvIHRoZSByb290IG1lc2ggU1RBIHRvIGJlIHZhbGlkLgorICoKKyAqIEBOTDgwMjExX01FU0hDT05GX0hXTVBfUk9PVF9JTlRFUlZBTDogVGhlIGludGVydmFsIG9mIHRpbWUgKGluIFRVcykgYmV0d2VlbgorICoJcHJvYWN0aXZlIFBSRVFzIGFyZSB0cmFuc21pdHRlZC4KKyAqCisgKiBATkw4MDIxMV9NRVNIQ09ORl9IV01QX0NPTkZJUk1BVElPTl9JTlRFUlZBTDogVGhlIG1pbmltdW0gaW50ZXJ2YWwgb2YgdGltZQorICoJKGluIFRVcykgZHVyaW5nIHdoaWNoIGEgbWVzaCBTVEEgY2FuIHNlbmQgb25seSBvbmUgQWN0aW9uIGZyYW1lCisgKgljb250YWluaW5nIGEgUFJFUSBlbGVtZW50IGZvciByb290IHBhdGggY29uZmlybWF0aW9uLgorICoKICAqIEBfX05MODAyMTFfTUVTSENPTkZfQVRUUl9BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKICAqLwogZW51bSBubDgwMjExX21lc2hjb25mX3BhcmFtcyB7CkBAIC0yMTMyLDYgKzIyMzEsMTIgQEAKIAlOTDgwMjExX01FU0hDT05GX0dBVEVfQU5OT1VOQ0VNRU5UUywKIAlOTDgwMjExX01FU0hDT05GX0hXTVBfUEVSUl9NSU5fSU5URVJWQUwsCiAJTkw4MDIxMV9NRVNIQ09ORl9GT1JXQVJESU5HLAorCU5MODAyMTFfTUVTSENPTkZfUlNTSV9USFJFU0hPTEQsCisJTkw4MDIxMV9NRVNIQ09ORl9TWU5DX09GRlNFVF9NQVhfTkVJR0hCT1IsCisJTkw4MDIxMV9NRVNIQ09ORl9IVF9PUE1PREUsCisJTkw4MDIxMV9NRVNIQ09ORl9IV01QX1BBVEhfVE9fUk9PVF9USU1FT1VULAorCU5MODAyMTFfTUVTSENPTkZfSFdNUF9ST09UX0lOVEVSVkFMLAorCU5MODAyMTFfTUVTSENPTkZfSFdNUF9DT05GSVJNQVRJT05fSU5URVJWQUwsCiAKIAkvKiBrZWVwIGxhc3QgKi8KIAlfX05MODAyMTFfTUVTSENPTkZfQVRUUl9BRlRFUl9MQVNULApAQCAtMjE0NywzMCArMjI1MiwzNyBAQAogICogQF9fTkw4MDIxMV9NRVNIX1NFVFVQX0lOVkFMSUQ6IEludGVybmFsIHVzZQogICoKICAqIEBOTDgwMjExX01FU0hfU0VUVVBfRU5BQkxFX1ZFTkRPUl9QQVRIX1NFTDogRW5hYmxlIHRoaXMgb3B0aW9uIHRvIHVzZSBhCi0gKiB2ZW5kb3Igc3BlY2lmaWMgcGF0aCBzZWxlY3Rpb24gYWxnb3JpdGhtIG9yIGRpc2FibGUgaXQgdG8gdXNlIHRoZSBkZWZhdWx0Ci0gKiBIV01QLgorICoJdmVuZG9yIHNwZWNpZmljIHBhdGggc2VsZWN0aW9uIGFsZ29yaXRobSBvciBkaXNhYmxlIGl0IHRvIHVzZSB0aGUKKyAqCWRlZmF1bHQgSFdNUC4KICAqCiAgKiBATkw4MDIxMV9NRVNIX1NFVFVQX0VOQUJMRV9WRU5ET1JfTUVUUklDOiBFbmFibGUgdGhpcyBvcHRpb24gdG8gdXNlIGEKLSAqIHZlbmRvciBzcGVjaWZpYyBwYXRoIG1ldHJpYyBvciBkaXNhYmxlIGl0IHRvIHVzZSB0aGUgZGVmYXVsdCBBaXJ0aW1lCi0gKiBtZXRyaWMuCisgKgl2ZW5kb3Igc3BlY2lmaWMgcGF0aCBtZXRyaWMgb3IgZGlzYWJsZSBpdCB0byB1c2UgdGhlIGRlZmF1bHQgQWlydGltZQorICoJbWV0cmljLgogICoKICAqIEBOTDgwMjExX01FU0hfU0VUVVBfSUU6IEluZm9ybWF0aW9uIGVsZW1lbnRzIGZvciB0aGlzIG1lc2gsIGZvciBpbnN0YW5jZSwgYQotICogcm9idXN0IHNlY3VyaXR5IG5ldHdvcmsgaWUsIG9yIGEgdmVuZG9yIHNwZWNpZmljIGluZm9ybWF0aW9uIGVsZW1lbnQgdGhhdAotICogdmVuZG9ycyB3aWxsIHVzZSB0byBpZGVudGlmeSB0aGUgcGF0aCBzZWxlY3Rpb24gbWV0aG9kcyBhbmQgbWV0cmljcyBpbiB1c2UuCisgKglyb2J1c3Qgc2VjdXJpdHkgbmV0d29yayBpZSwgb3IgYSB2ZW5kb3Igc3BlY2lmaWMgaW5mb3JtYXRpb24gZWxlbWVudAorICoJdGhhdCB2ZW5kb3JzIHdpbGwgdXNlIHRvIGlkZW50aWZ5IHRoZSBwYXRoIHNlbGVjdGlvbiBtZXRob2RzIGFuZAorICoJbWV0cmljcyBpbiB1c2UuCiAgKgogICogQE5MODAyMTFfTUVTSF9TRVRVUF9VU0VSU1BBQ0VfQVVUSDogRW5hYmxlIHRoaXMgb3B0aW9uIGlmIGFuIGF1dGhlbnRpY2F0aW9uCi0gKiBkYWVtb24gd2lsbCBiZSBhdXRoZW50aWNhdGluZyBtZXNoIGNhbmRpZGF0ZXMuCisgKglkYWVtb24gd2lsbCBiZSBhdXRoZW50aWNhdGluZyBtZXNoIGNhbmRpZGF0ZXMuCiAgKgogICogQE5MODAyMTFfTUVTSF9TRVRVUF9VU0VSU1BBQ0VfQU1QRTogRW5hYmxlIHRoaXMgb3B0aW9uIGlmIGFuIGF1dGhlbnRpY2F0aW9uCi0gKiBkYWVtb24gd2lsbCBiZSBzZWN1cmluZyBwZWVyIGxpbmsgZnJhbWVzLiAgQU1QRSBpcyBhIHNlY3VyZWQgdmVyc2lvbiBvZiBNZXNoCi0gKiBQZWVyaW5nIE1hbmFnZW1lbnQgKE1QTSkgYW5kIGlzIGltcGxlbWVudGVkIHdpdGggdGhlIGFzc2lzdGFuY2Ugb2YgYQotICogdXNlcnNwYWNlIGRhZW1vbi4gIFdoZW4gdGhpcyBmbGFnIGlzIHNldCwgdGhlIGtlcm5lbCB3aWxsIHNlbmQgcGVlcgotICogbWFuYWdlbWVudCBmcmFtZXMgdG8gYSB1c2Vyc3BhY2UgZGFlbW9uIHRoYXQgd2lsbCBpbXBsZW1lbnQgQU1QRQotICogZnVuY3Rpb25hbGl0eSAoc2VjdXJpdHkgY2FwYWJpbGl0aWVzIHNlbGVjdGlvbiwga2V5IGNvbmZpcm1hdGlvbiwgYW5kIGtleQotICogbWFuYWdlbWVudCkuICBXaGVuIHRoZSBmbGFnIGlzIHVuc2V0IChkZWZhdWx0KSwgdGhlIGtlcm5lbCBjYW4gYXV0b25vbW91c2x5Ci0gKiBjb21wbGV0ZSAodW5zZWN1cmVkKSBtZXNoIHBlZXJpbmcgd2l0aG91dCB0aGUgbmVlZCBvZiBhIHVzZXJzcGFjZSBkYWVtb24uCisgKglkYWVtb24gd2lsbCBiZSBzZWN1cmluZyBwZWVyIGxpbmsgZnJhbWVzLiAgQU1QRSBpcyBhIHNlY3VyZWQgdmVyc2lvbiBvZgorICoJTWVzaCBQZWVyaW5nIE1hbmFnZW1lbnQgKE1QTSkgYW5kIGlzIGltcGxlbWVudGVkIHdpdGggdGhlIGFzc2lzdGFuY2Ugb2YKKyAqCWEgdXNlcnNwYWNlIGRhZW1vbi4gIFdoZW4gdGhpcyBmbGFnIGlzIHNldCwgdGhlIGtlcm5lbCB3aWxsIHNlbmQgcGVlcgorICoJbWFuYWdlbWVudCBmcmFtZXMgdG8gYSB1c2Vyc3BhY2UgZGFlbW9uIHRoYXQgd2lsbCBpbXBsZW1lbnQgQU1QRQorICoJZnVuY3Rpb25hbGl0eSAoc2VjdXJpdHkgY2FwYWJpbGl0aWVzIHNlbGVjdGlvbiwga2V5IGNvbmZpcm1hdGlvbiwgYW5kCisgKglrZXkgbWFuYWdlbWVudCkuICBXaGVuIHRoZSBmbGFnIGlzIHVuc2V0IChkZWZhdWx0KSwgdGhlIGtlcm5lbCBjYW4KKyAqCWF1dG9ub21vdXNseSBjb21wbGV0ZSAodW5zZWN1cmVkKSBtZXNoIHBlZXJpbmcgd2l0aG91dCB0aGUgbmVlZCBvZiBhCisgKgl1c2Vyc3BhY2UgZGFlbW9uLgorICoKKyAqIEBOTDgwMjExX01FU0hfU0VUVVBfRU5BQkxFX1ZFTkRPUl9TWU5DOiBFbmFibGUgdGhpcyBvcHRpb24gdG8gdXNlIGEKKyAqCXZlbmRvciBzcGVjaWZpYyBzeW5jaHJvbml6YXRpb24gbWV0aG9kIG9yIGRpc2FibGUgaXQgdG8gdXNlIHRoZSBkZWZhdWx0CisgKgluZWlnaGJvciBvZmZzZXQgc3luY2hyb25pemF0aW9uCiAgKgogICogQE5MODAyMTFfTUVTSF9TRVRVUF9BVFRSX01BWDogaGlnaGVzdCBwb3NzaWJsZSBtZXNoIHNldHVwIGF0dHJpYnV0ZSBudW1iZXIKKyAqCiAgKiBAX19OTDgwMjExX01FU0hfU0VUVVBfQVRUUl9BRlRFUl9MQVNUOiBJbnRlcm5hbCB1c2UKICAqLwogZW51bSBubDgwMjExX21lc2hfc2V0dXBfcGFyYW1zIHsKQEAgLTIxODAsNiArMjI5Miw3IEBACiAJTkw4MDIxMV9NRVNIX1NFVFVQX0lFLAogCU5MODAyMTFfTUVTSF9TRVRVUF9VU0VSU1BBQ0VfQVVUSCwKIAlOTDgwMjExX01FU0hfU0VUVVBfVVNFUlNQQUNFX0FNUEUsCisJTkw4MDIxMV9NRVNIX1NFVFVQX0VOQUJMRV9WRU5ET1JfU1lOQywKIAogCS8qIGtlZXAgbGFzdCAqLwogCV9fTkw4MDIxMV9NRVNIX1NFVFVQX0FUVFJfQUZURVJfTEFTVCwKQEAgLTIxODksNyArMjMwMiw3IEBACiAvKioKICAqIGVudW0gbmw4MDIxMV90eHFfYXR0ciAtIFRYIHF1ZXVlIHBhcmFtZXRlciBhdHRyaWJ1dGVzCiAgKiBAX19OTDgwMjExX1RYUV9BVFRSX0lOVkFMSUQ6IEF0dHJpYnV0ZSBudW1iZXIgMCBpcyByZXNlcnZlZAotICogQE5MODAyMTFfVFhRX0FUVFJfUVVFVUU6IFRYIHF1ZXVlIGlkZW50aWZpZXIgKE5MODAyMTFfVFhRX1FfKikKKyAqIEBOTDgwMjExX1RYUV9BVFRSX0FDOiBBQyBpZGVudGlmaWVyIChOTDgwMjExX0FDXyopCiAgKiBATkw4MDIxMV9UWFFfQVRUUl9UWE9QOiBNYXhpbXVtIGJ1cnN0IHRpbWUgaW4gdW5pdHMgb2YgMzIgdXNlY3MsIDAgbWVhbmluZwogICoJZGlzYWJsZWQKICAqIEBOTDgwMjExX1RYUV9BVFRSX0NXTUlOOiBNaW5pbXVtIGNvbnRlbnRpb24gd2luZG93IFthIHZhbHVlIG9mIHRoZSBmb3JtCkBAIC0yMjAyLDcgKzIzMTUsNyBAQAogICovCiBlbnVtIG5sODAyMTFfdHhxX2F0dHIgewogCV9fTkw4MDIxMV9UWFFfQVRUUl9JTlZBTElELAotCU5MODAyMTFfVFhRX0FUVFJfUVVFVUUsCisJTkw4MDIxMV9UWFFfQVRUUl9BQywKIAlOTDgwMjExX1RYUV9BVFRSX1RYT1AsCiAJTkw4MDIxMV9UWFFfQVRUUl9DV01JTiwKIAlOTDgwMjExX1RYUV9BVFRSX0NXTUFYLApAQCAtMjIxMywxMyArMjMyNiwyMSBAQAogCU5MODAyMTFfVFhRX0FUVFJfTUFYID0gX19OTDgwMjExX1RYUV9BVFRSX0FGVEVSX0xBU1QgLSAxCiB9OwogCi1lbnVtIG5sODAyMTFfdHhxX3EgewotCU5MODAyMTFfVFhRX1FfVk8sCi0JTkw4MDIxMV9UWFFfUV9WSSwKLQlOTDgwMjExX1RYUV9RX0JFLAotCU5MODAyMTFfVFhRX1FfQksKK2VudW0gbmw4MDIxMV9hYyB7CisJTkw4MDIxMV9BQ19WTywKKwlOTDgwMjExX0FDX1ZJLAorCU5MODAyMTFfQUNfQkUsCisJTkw4MDIxMV9BQ19CSywKKwlOTDgwMjExX05VTV9BQ1MKIH07CiAKKy8qIGJhY2t3YXJkIGNvbXBhdCAqLworI2RlZmluZSBOTDgwMjExX1RYUV9BVFRSX1FVRVVFCU5MODAyMTFfVFhRX0FUVFJfQUMKKyNkZWZpbmUgTkw4MDIxMV9UWFFfUV9WTwlOTDgwMjExX0FDX1ZPCisjZGVmaW5lIE5MODAyMTFfVFhRX1FfVkkJTkw4MDIxMV9BQ19WSQorI2RlZmluZSBOTDgwMjExX1RYUV9RX0JFCU5MODAyMTFfQUNfQkUKKyNkZWZpbmUgTkw4MDIxMV9UWFFfUV9CSwlOTDgwMjExX0FDX0JLCisKIGVudW0gbmw4MDIxMV9jaGFubmVsX3R5cGUgewogCU5MODAyMTFfQ0hBTl9OT19IVCwKIAlOTDgwMjExX0NIQU5fSFQyMCwKQEAgLTI0MDUsMTIgKzI1MjYsMTUgQEAKICAqCWluIGFuIGFycmF5IG9mIHJhdGVzIGFzIGRlZmluZWQgaW4gSUVFRSA4MDIuMTEgNy4zLjIuMiAodTggdmFsdWVzIHdpdGgKICAqCTEgPSA1MDAga2JwcykgYnV0IHdpdGhvdXQgdGhlIElFIGxlbmd0aCByZXN0cmljdGlvbiAoYXQgbW9zdAogICoJJU5MODAyMTFfTUFYX1NVUFBfUkFURVMgaW4gYSBzaW5nbGUgYXJyYXkpLgorICogQE5MODAyMTFfVFhSQVRFX01DUzogSFQgKE1DUykgcmF0ZXMgYWxsb3dlZCBmb3IgVFggcmF0ZSBzZWxlY3Rpb24KKyAqCWluIGFuIGFycmF5IG9mIE1DUyBudW1iZXJzLgogICogQF9fTkw4MDIxMV9UWFJBVEVfQUZURVJfTEFTVDogaW50ZXJuYWwKICAqIEBOTDgwMjExX1RYUkFURV9NQVg6IGhpZ2hlc3QgVFggcmF0ZSBhdHRyaWJ1dGUKICAqLwogZW51bSBubDgwMjExX3R4X3JhdGVfYXR0cmlidXRlcyB7CiAJX19OTDgwMjExX1RYUkFURV9JTlZBTElELAogCU5MODAyMTFfVFhSQVRFX0xFR0FDWSwKKwlOTDgwMjExX1RYUkFURV9NQ1MsCiAKIAkvKiBrZWVwIGxhc3QgKi8KIAlfX05MODAyMTFfVFhSQVRFX0FGVEVSX0xBU1QsCkBAIC0yNDIxLDEyICsyNTQ1LDE5IEBACiAgKiBlbnVtIG5sODAyMTFfYmFuZCAtIEZyZXF1ZW5jeSBiYW5kCiAgKiBATkw4MDIxMV9CQU5EXzJHSFo6IDIuNCBHSHogSVNNIGJhbmQKICAqIEBOTDgwMjExX0JBTkRfNUdIWjogYXJvdW5kIDUgR0h6IGJhbmQgKDQuOSAtIDUuNyBHSHopCisgKiBATkw4MDIxMV9CQU5EXzYwR0haOiBhcm91bmQgNjAgR0h6IGJhbmQgKDU4LjMyIC0gNjQuODAgR0h6KQogICovCiBlbnVtIG5sODAyMTFfYmFuZCB7CiAJTkw4MDIxMV9CQU5EXzJHSFosCiAJTkw4MDIxMV9CQU5EXzVHSFosCisJTkw4MDIxMV9CQU5EXzYwR0haLAogfTsKIAorLyoqCisgKiBlbnVtIG5sODAyMTFfcHNfc3RhdGUgLSBwb3dlcnNhdmUgc3RhdGUKKyAqIEBOTDgwMjExX1BTX0RJU0FCTEVEOiBwb3dlcnNhdmUgaXMgZGlzYWJsZWQKKyAqIEBOTDgwMjExX1BTX0VOQUJMRUQ6IHBvd2Vyc2F2ZSBpcyBlbmFibGVkCisgKi8KIGVudW0gbmw4MDIxMV9wc19zdGF0ZSB7CiAJTkw4MDIxMV9QU19ESVNBQkxFRCwKIAlOTDgwMjExX1BTX0VOQUJMRUQsCkBAIC0yNDY1LDEwICsyNTk2LDE0IEBACiAgKiAgICAgIGNvbmZpZ3VyZWQgdGhyZXNob2xkCiAgKiBATkw4MDIxMV9DUU1fUlNTSV9USFJFU0hPTERfRVZFTlRfSElHSDogVGhlIFJTU0kgaXMgaGlnaGVyIHRoYW4gdGhlCiAgKiAgICAgIGNvbmZpZ3VyZWQgdGhyZXNob2xkCisgKiBATkw4MDIxMV9DUU1fUlNTSV9CRUFDT05fTE9TU19FVkVOVDogVGhlIGRldmljZSBleHBlcmllbmNlZCBiZWFjb24gbG9zcy4KKyAqCShOb3RlIHRoYXQgZGVhdXRoL2Rpc2Fzc29jIHdpbGwgc3RpbGwgZm9sbG93IGlmIHRoZSBBUCBpcyBub3QKKyAqCWF2YWlsYWJsZS4gVGhpcyBldmVudCBtaWdodCBnZXQgdXNlZCBhcyByb2FtaW5nIGV2ZW50LCBldGMuKQogICovCiBlbnVtIG5sODAyMTFfY3FtX3Jzc2lfdGhyZXNob2xkX2V2ZW50IHsKIAlOTDgwMjExX0NRTV9SU1NJX1RIUkVTSE9MRF9FVkVOVF9MT1csCiAJTkw4MDIxMV9DUU1fUlNTSV9USFJFU0hPTERfRVZFTlRfSElHSCwKKwlOTDgwMjExX0NRTV9SU1NJX0JFQUNPTl9MT1NTX0VWRU5ULAogfTsKIAogCkBAIC0yNzk2LDEwICsyOTMxLDEzIEBACiAgKglUWCBzdGF0dXMgdG8gdGhlIHNvY2tldCBlcnJvciBxdWV1ZSB3aGVuIHJlcXVlc3RlZCB3aXRoIHRoZQogICoJc29ja2V0IG9wdGlvbi4KICAqIEBOTDgwMjExX0ZFQVRVUkVfSFRfSUJTUzogVGhpcyBkcml2ZXIgc3VwcG9ydHMgSUJTUyB3aXRoIEhUIGRhdGFyYXRlcy4KKyAqIEBOTDgwMjExX0ZFQVRVUkVfSU5BQ1RJVklUWV9USU1FUjogVGhpcyBkcml2ZXIgdGFrZXMgY2FyZSBvZiBmcmVlaW5nIHVwCisgKgl0aGUgY29ubmVjdGVkIGluYWN0aXZlIHN0YXRpb25zIGluIEFQIG1vZGUuCiAgKi8KIGVudW0gbmw4MDIxMV9mZWF0dXJlX2ZsYWdzIHsKIAlOTDgwMjExX0ZFQVRVUkVfU0tfVFhfU1RBVFVTCT0gMSA8PCAwLAogCU5MODAyMTFfRkVBVFVSRV9IVF9JQlNTCQk9IDEgPDwgMSwKKwlOTDgwMjExX0ZFQVRVUkVfSU5BQ1RJVklUWV9USU1FUiA9IDEgPDwgMiwKIH07CiAKIC8qKgpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX2RlZnMuaCBiL3NyYy9lYXBfY29tbW9uL2VhcF9kZWZzLmgKaW5kZXggYWYwYTI5YS4uMzYwMTkzYSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX2RlZnMuaAorKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfZGVmcy5oCkBAIC02MCw3ICs2MCw3IEBACiAJRUFQX1RZUEVfUFNLID0gNDcgLyogUkZDIDQ3NjQgKi8sCiAJRUFQX1RZUEVfU0FLRSA9IDQ4IC8qIFJGQyA0NzYzICovLAogCUVBUF9UWVBFX0lLRVYyID0gNDkgLyogUkZDIDUxMDYgKi8sCi0JRUFQX1RZUEVfQUtBX1BSSU1FID0gNTAgLyogZHJhZnQtYXJra28tZWFwLWFrYS1rZGYtMTAudHh0ICovLAorCUVBUF9UWVBFX0FLQV9QUklNRSA9IDUwIC8qIFJGQyA1NDQ4ICovLAogCUVBUF9UWVBFX0dQU0sgPSA1MSAvKiBSRkMgNTQzMyAqLywKIAlFQVBfVFlQRV9QV0QgPSA1MiAvKiBSRkMgNTkzMSAqLywKIAlFQVBfVFlQRV9FWFBBTkRFRCA9IDI1NCAvKiBSRkMgMzc0OCAqLwpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uYyBiL3NyYy9lYXBfY29tbW9uL2VhcF9wd2RfY29tbW9uLmMKaW5kZXggNWI2YmYzYy4uN2Q2ZTZiOCAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uYworKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfcHdkX2NvbW1vbi5jCkBAIC04LDcwICs4LDc2IEBACiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgogI2luY2x1ZGUgImNvbW1vbi5oIgorI2luY2x1ZGUgImNyeXB0by9zaGEyNTYuaCIKKyNpbmNsdWRlICJjcnlwdG8vY3J5cHRvLmgiCiAjaW5jbHVkZSAiZWFwX2RlZnMuaCIKICNpbmNsdWRlICJlYXBfcHdkX2NvbW1vbi5oIgogCiAvKiBUaGUgcmFuZG9tIGZ1bmN0aW9uIEgoeCkgPSBITUFDLVNIQTI1NigwXjMyLCB4KSAqLwotdm9pZCBIX0luaXQoSE1BQ19DVFggKmN0eCkKK3N0cnVjdCBjcnlwdG9faGFzaCAqIGVhcF9wd2RfaF9pbml0KHZvaWQpCiB7Ci0JdTggYWxsemVyb1tTSEEyNTZfRElHRVNUX0xFTkdUSF07Ci0KLQlvc19tZW1zZXQoYWxsemVybywgMCwgU0hBMjU2X0RJR0VTVF9MRU5HVEgpOwotCUhNQUNfSW5pdChjdHgsIGFsbHplcm8sIFNIQTI1Nl9ESUdFU1RfTEVOR1RILCBFVlBfc2hhMjU2KCkpOworCXU4IGFsbHplcm9bU0hBMjU2X01BQ19MRU5dOworCW9zX21lbXNldChhbGx6ZXJvLCAwLCBTSEEyNTZfTUFDX0xFTik7CisJcmV0dXJuIGNyeXB0b19oYXNoX2luaXQoQ1JZUFRPX0hBU0hfQUxHX0hNQUNfU0hBMjU2LCBhbGx6ZXJvLAorCQkJCVNIQTI1Nl9NQUNfTEVOKTsKIH0KIAogCi12b2lkIEhfVXBkYXRlKEhNQUNfQ1RYICpjdHgsIGNvbnN0IHU4ICpkYXRhLCBpbnQgbGVuKQordm9pZCBlYXBfcHdkX2hfdXBkYXRlKHN0cnVjdCBjcnlwdG9faGFzaCAqaGFzaCwgY29uc3QgdTggKmRhdGEsIHNpemVfdCBsZW4pCiB7Ci0JSE1BQ19VcGRhdGUoY3R4LCBkYXRhLCBsZW4pOworCWNyeXB0b19oYXNoX3VwZGF0ZShoYXNoLCBkYXRhLCBsZW4pOwogfQogCiAKLXZvaWQgSF9GaW5hbChITUFDX0NUWCAqY3R4LCB1OCAqZGlnZXN0KQordm9pZCBlYXBfcHdkX2hfZmluYWwoc3RydWN0IGNyeXB0b19oYXNoICpoYXNoLCB1OCAqZGlnZXN0KQogewotCXVuc2lnbmVkIGludCBtZGxlbiA9IFNIQTI1Nl9ESUdFU1RfTEVOR1RIOwotCi0JSE1BQ19GaW5hbChjdHgsIGRpZ2VzdCwgJm1kbGVuKTsKLQlITUFDX0NUWF9jbGVhbnVwKGN0eCk7CisJc2l6ZV90IGxlbiA9IFNIQTI1Nl9NQUNfTEVOOworCWNyeXB0b19oYXNoX2ZpbmlzaChoYXNoLCBkaWdlc3QsICZsZW4pOwogfQogCiAKIC8qIGEgY291bnRlci1iYXNlZCBLREYgYmFzZWQgb24gTklTVCBTUDgwMC0xMDggKi8KLXZvaWQgZWFwX3B3ZF9rZGYodTggKmtleSwgaW50IGtleWxlbiwgdTggKmxhYmVsLCBpbnQgbGFiZWxsZW4sCi0JCSB1OCAqcmVzdWx0LCBpbnQgcmVzdWx0Yml0bGVuKQorc3RhdGljIGludCBlYXBfcHdkX2tkZihjb25zdCB1OCAqa2V5LCBzaXplX3Qga2V5bGVuLCBjb25zdCB1OCAqbGFiZWwsCisJCSAgICAgICBzaXplX3QgbGFiZWxsZW4sIHU4ICpyZXN1bHQsIHNpemVfdCByZXN1bHRiaXRsZW4pCiB7Ci0JSE1BQ19DVFggaGN0eDsKLQl1bnNpZ25lZCBjaGFyIGRpZ2VzdFtTSEEyNTZfRElHRVNUX0xFTkdUSF07CisJc3RydWN0IGNyeXB0b19oYXNoICpoYXNoOworCXU4IGRpZ2VzdFtTSEEyNTZfTUFDX0xFTl07CiAJdTE2IGksIGN0ciwgTDsKLQlpbnQgcmVzdWx0Ynl0ZWxlbiwgbGVuID0gMDsKLQl1bnNpZ25lZCBpbnQgbWRsZW4gPSBTSEEyNTZfRElHRVNUX0xFTkdUSDsKLQl1bnNpZ25lZCBjaGFyIG1hc2sgPSAweGZmOworCXNpemVfdCByZXN1bHRieXRlbGVuLCBsZW4gPSAwLCBtZGxlbjsKIAotCXJlc3VsdGJ5dGVsZW4gPSAocmVzdWx0Yml0bGVuICsgNykvODsKKwlyZXN1bHRieXRlbGVuID0gKHJlc3VsdGJpdGxlbiArIDcpIC8gODsKIAljdHIgPSAwOwogCUwgPSBodG9ucyhyZXN1bHRiaXRsZW4pOwogCXdoaWxlIChsZW4gPCByZXN1bHRieXRlbGVuKSB7Ci0JCWN0cisrOyBpID0gaHRvbnMoY3RyKTsKLQkJSE1BQ19Jbml0KCZoY3R4LCBrZXksIGtleWxlbiwgRVZQX3NoYTI1NigpKTsKKwkJY3RyKys7CisJCWkgPSBodG9ucyhjdHIpOworCQloYXNoID0gY3J5cHRvX2hhc2hfaW5pdChDUllQVE9fSEFTSF9BTEdfSE1BQ19TSEEyNTYsCisJCQkJCWtleSwga2V5bGVuKTsKKwkJaWYgKGhhc2ggPT0gTlVMTCkKKwkJCXJldHVybiAtMTsKIAkJaWYgKGN0ciA+IDEpCi0JCQlITUFDX1VwZGF0ZSgmaGN0eCwgZGlnZXN0LCBtZGxlbik7Ci0JCUhNQUNfVXBkYXRlKCZoY3R4LCAodTggKikgJmksIHNpemVvZih1MTYpKTsKLQkJSE1BQ19VcGRhdGUoJmhjdHgsIGxhYmVsLCBsYWJlbGxlbik7Ci0JCUhNQUNfVXBkYXRlKCZoY3R4LCAodTggKikgJkwsIHNpemVvZih1MTYpKTsKLQkJSE1BQ19GaW5hbCgmaGN0eCwgZGlnZXN0LCAmbWRsZW4pOwotCQlpZiAoKGxlbiArIChpbnQpIG1kbGVuKSA+IHJlc3VsdGJ5dGVsZW4pCisJCQljcnlwdG9faGFzaF91cGRhdGUoaGFzaCwgZGlnZXN0LCBTSEEyNTZfTUFDX0xFTik7CisJCWNyeXB0b19oYXNoX3VwZGF0ZShoYXNoLCAodTggKikgJmksIHNpemVvZih1MTYpKTsKKwkJY3J5cHRvX2hhc2hfdXBkYXRlKGhhc2gsIGxhYmVsLCBsYWJlbGxlbik7CisJCWNyeXB0b19oYXNoX3VwZGF0ZShoYXNoLCAodTggKikgJkwsIHNpemVvZih1MTYpKTsKKwkJbWRsZW4gPSBTSEEyNTZfTUFDX0xFTjsKKwkJaWYgKGNyeXB0b19oYXNoX2ZpbmlzaChoYXNoLCBkaWdlc3QsICZtZGxlbikgPCAwKQorCQkJcmV0dXJuIC0xOworCQlpZiAoKGxlbiArIG1kbGVuKSA+IHJlc3VsdGJ5dGVsZW4pCiAJCQlvc19tZW1jcHkocmVzdWx0ICsgbGVuLCBkaWdlc3QsIHJlc3VsdGJ5dGVsZW4gLSBsZW4pOwogCQllbHNlCiAJCQlvc19tZW1jcHkocmVzdWx0ICsgbGVuLCBkaWdlc3QsIG1kbGVuKTsKIAkJbGVuICs9IG1kbGVuOwotCQlITUFDX0NUWF9jbGVhbnVwKCZoY3R4KTsKIAl9CiAKIAkvKiBzaW5jZSB3ZSdyZSBleHBhbmRpbmcgdG8gYSBiaXQgbGVuZ3RoLCBtYXNrIG9mZiB0aGUgZXhjZXNzICovCiAJaWYgKHJlc3VsdGJpdGxlbiAlIDgpIHsKKwkJdTggbWFzayA9IDB4ZmY7CiAJCW1hc2sgPDw9ICg4IC0gKHJlc3VsdGJpdGxlbiAlIDgpKTsKIAkJcmVzdWx0W3Jlc3VsdGJ5dGVsZW4gLSAxXSAmPSBtYXNrOwogCX0KKworCXJldHVybiAwOwogfQogCiAKQEAgLTg1LDkgKzkxLDEwIEBACiAJCQkgICAgIHU4ICppZF9wZWVyLCBpbnQgaWRfcGVlcl9sZW4sIHU4ICp0b2tlbikKIHsKIAlCSUdOVU0gKnhfY2FuZGlkYXRlID0gTlVMTCwgKnJuZCA9IE5VTEwsICpjb2ZhY3RvciA9IE5VTEw7Ci0JSE1BQ19DVFggY3R4OwotCXVuc2lnbmVkIGNoYXIgcHdlX2RpZ2VzdFtTSEEyNTZfRElHRVNUX0xFTkdUSF0sICpwcmZidWYgPSBOVUxMLCBjdHI7Ci0JaW50IG5pZCwgaXNfb2RkLCBwcmltZWJpdGxlbiwgcHJpbWVieXRlbGVuLCByZXQgPSAwOworCXN0cnVjdCBjcnlwdG9faGFzaCAqaGFzaDsKKwl1bnNpZ25lZCBjaGFyIHB3ZV9kaWdlc3RbU0hBMjU2X01BQ19MRU5dLCAqcHJmYnVmID0gTlVMTCwgY3RyOworCWludCBuaWQsIGlzX29kZCwgcmV0ID0gMDsKKwlzaXplX3QgcHJpbWVieXRlbGVuLCBwcmltZWJpdGxlbjsKIAogCXN3aXRjaCAobnVtKSB7IC8qIGZyb20gSUFOQSByZWdpc3RyeSBmb3IgSUtFIEQtSCBncm91cHMgKi8KICAgICAgICAgY2FzZSAxOToKQEAgLTE1NCw3ICsxNjEsNyBAQAogCW9zX21lbXNldChwcmZidWYsIDAsIHByaW1lYnl0ZWxlbik7CiAJY3RyID0gMDsKIAl3aGlsZSAoMSkgewotCQlpZiAoY3RyID4gMTApIHsKKwkJaWYgKGN0ciA+IDMwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLXB3ZDogdW5hYmxlIHRvIGZpbmQgcmFuZG9tICIKIAkJCQkgICAicG9pbnQgb24gY3VydmUgZm9yIGdyb3VwICVkLCBzb21ldGhpbmcncyAiCiAJCQkJICAgImZpc2h5IiwgbnVtKTsKQEAgLTE2NywyMCArMTc0LDIzIEBACiAJCSAqICAgIHB3ZC1zZWVkID0gSCh0b2tlbiB8IHBlZXItaWQgfCBzZXJ2ZXItaWQgfCBwYXNzd29yZCB8CiAJCSAqCQkgICBjb3VudGVyKQogCQkgKi8KLQkJSF9Jbml0KCZjdHgpOwotCQlIX1VwZGF0ZSgmY3R4LCB0b2tlbiwgc2l6ZW9mKHUzMikpOwotCQlIX1VwZGF0ZSgmY3R4LCBpZF9wZWVyLCBpZF9wZWVyX2xlbik7Ci0JCUhfVXBkYXRlKCZjdHgsIGlkX3NlcnZlciwgaWRfc2VydmVyX2xlbik7Ci0JCUhfVXBkYXRlKCZjdHgsIHBhc3N3b3JkLCBwYXNzd29yZF9sZW4pOwotCQlIX1VwZGF0ZSgmY3R4LCAmY3RyLCBzaXplb2YoY3RyKSk7Ci0JCUhfRmluYWwoJmN0eCwgcHdlX2RpZ2VzdCk7CisJCWhhc2ggPSBlYXBfcHdkX2hfaW5pdCgpOworCQlpZiAoaGFzaCA9PSBOVUxMKQorCQkJZ290byBmYWlsOworCQllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIHRva2VuLCBzaXplb2YodTMyKSk7CisJCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgaWRfcGVlciwgaWRfcGVlcl9sZW4pOworCQllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGlkX3NlcnZlciwgaWRfc2VydmVyX2xlbik7CisJCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgcGFzc3dvcmQsIHBhc3N3b3JkX2xlbik7CisJCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgJmN0ciwgc2l6ZW9mKGN0cikpOworCQllYXBfcHdkX2hfZmluYWwoaGFzaCwgcHdlX2RpZ2VzdCk7CiAKLQkJQk5fYmluMmJuKHB3ZV9kaWdlc3QsIFNIQTI1Nl9ESUdFU1RfTEVOR1RILCBybmQpOworCQlCTl9iaW4yYm4ocHdlX2RpZ2VzdCwgU0hBMjU2X01BQ19MRU4sIHJuZCk7CiAKLQkJZWFwX3B3ZF9rZGYocHdlX2RpZ2VzdCwgU0hBMjU2X0RJR0VTVF9MRU5HVEgsCi0JCQkgICAgKHVuc2lnbmVkIGNoYXIgKikgIkVBUC1wd2QgSHVudGluZyBBbmQgUGVja2luZyIsCi0JCQkgICAgb3Nfc3RybGVuKCJFQVAtcHdkIEh1bnRpbmcgQW5kIFBlY2tpbmciKSwKLQkJCSAgICBwcmZidWYsIHByaW1lYml0bGVuKTsKKwkJaWYgKGVhcF9wd2Rfa2RmKHB3ZV9kaWdlc3QsIFNIQTI1Nl9NQUNfTEVOLAorCQkJCSh1OCAqKSAiRUFQLXB3ZCBIdW50aW5nIEFuZCBQZWNraW5nIiwKKwkJCQlvc19zdHJsZW4oIkVBUC1wd2QgSHVudGluZyBBbmQgUGVja2luZyIpLAorCQkJCXByZmJ1ZiwgcHJpbWViaXRsZW4pIDwgMCkKKwkJCWdvdG8gZmFpbDsKIAogCQlCTl9iaW4yYm4ocHJmYnVmLCBwcmltZWJ5dGVsZW4sIHhfY2FuZGlkYXRlKTsKIApAQCAtMjUyLDExICsyNjIsMTMgQEAKIAlpZiAoMCkgewogIGZhaWw6CiAJCUVDX0dST1VQX2ZyZWUoZ3JwLT5ncm91cCk7CisJCWdycC0+Z3JvdXAgPSBOVUxMOwogCQlFQ19QT0lOVF9mcmVlKGdycC0+cHdlKTsKKwkJZ3JwLT5wd2UgPSBOVUxMOwogCQlCTl9mcmVlKGdycC0+b3JkZXIpOworCQlncnAtPm9yZGVyID0gTlVMTDsKIAkJQk5fZnJlZShncnAtPnByaW1lKTsKLQkJb3NfZnJlZShncnApOwotCQlncnAgPSBOVUxMOworCQlncnAtPnByaW1lID0gTlVMTDsKIAkJcmV0ID0gMTsKIAl9CiAJLyogY2xlYW5saW5lc3MgYW5kIG9yZGVyLi4uLiAqLwpAQCAtMjc0LDkgKzI4Niw5IEBACiAJCSB1OCAqY29uZmlybV9wZWVyLCB1OCAqY29uZmlybV9zZXJ2ZXIsCiAJCSB1MzIgKmNpcGhlcnN1aXRlLCB1OCAqbXNrLCB1OCAqZW1zaykKIHsKLQlITUFDX0NUWCBjdHg7Ci0JdTggbWtbU0hBMjU2X0RJR0VTVF9MRU5HVEhdLCAqY3J1ZnQ7Ci0JdTggc2Vzc2lvbl9pZFtTSEEyNTZfRElHRVNUX0xFTkdUSCArIDFdOworCXN0cnVjdCBjcnlwdG9faGFzaCAqaGFzaDsKKwl1OCBta1tTSEEyNTZfTUFDX0xFTl0sICpjcnVmdDsKKwl1OCBzZXNzaW9uX2lkW1NIQTI1Nl9NQUNfTEVOICsgMV07CiAJdTggbXNrX2Vtc2tbRUFQX01TS19MRU4gKyBFQVBfRU1TS19MRU5dOwogCWludCBvZmZzZXQ7CiAKQEAgLTI4OCwzNyArMzAwLDQ2IEBACiAJICoJc2NhbF9zKQogCSAqLwogCXNlc3Npb25faWRbMF0gPSBFQVBfVFlQRV9QV0Q7Ci0JSF9Jbml0KCZjdHgpOwotCUhfVXBkYXRlKCZjdHgsICh1OCAqKWNpcGhlcnN1aXRlLCBzaXplb2YodTMyKSk7CisJaGFzaCA9IGVhcF9wd2RfaF9pbml0KCk7CisJaWYgKGhhc2ggPT0gTlVMTCkgeworCQlvc19mcmVlKGNydWZ0KTsKKwkJcmV0dXJuIC0xOworCX0KKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsICh1OCAqKSBjaXBoZXJzdWl0ZSwgc2l6ZW9mKHUzMikpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhncnAtPm9yZGVyKSAtIEJOX251bV9ieXRlcyhwZWVyX3NjYWxhcik7CiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZ3JwLT5wcmltZSkpOwogCUJOX2JuMmJpbihwZWVyX3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZ3JwLT5vcmRlcikpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhncnAtPm9yZGVyKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGdycC0+b3JkZXIpIC0gQk5fbnVtX2J5dGVzKHNlcnZlcl9zY2FsYXIpOwogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGdycC0+cHJpbWUpKTsKIAlCTl9ibjJiaW4oc2VydmVyX3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZ3JwLT5vcmRlcikpOwotCUhfRmluYWwoJmN0eCwgJnNlc3Npb25faWRbMV0pOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhncnAtPm9yZGVyKSk7CisJZWFwX3B3ZF9oX2ZpbmFsKGhhc2gsICZzZXNzaW9uX2lkWzFdKTsKIAogCS8qIHRoZW4gY29tcHV0ZSBNSyA9IEgoayB8IGNvbmZpcm0tcGVlciB8IGNvbmZpcm0tc2VydmVyKSAqLwotCUhfSW5pdCgmY3R4KTsKKwloYXNoID0gZWFwX3B3ZF9oX2luaXQoKTsKKwlpZiAoaGFzaCA9PSBOVUxMKSB7CisJCW9zX2ZyZWUoY3J1ZnQpOworCQlyZXR1cm4gLTE7CisJfQogCW9mZnNldCA9IEJOX251bV9ieXRlcyhncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyhrKTsKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhncnAtPnByaW1lKSk7CiAJQk5fYm4yYmluKGssIGNydWZ0ICsgb2Zmc2V0KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgQk5fbnVtX2J5dGVzKGdycC0+cHJpbWUpKTsKLQlIX1VwZGF0ZSgmY3R4LCBjb25maXJtX3BlZXIsIFNIQTI1Nl9ESUdFU1RfTEVOR1RIKTsKLQlIX1VwZGF0ZSgmY3R4LCBjb25maXJtX3NlcnZlciwgU0hBMjU2X0RJR0VTVF9MRU5HVEgpOwotCUhfRmluYWwoJmN0eCwgbWspOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhncnAtPnByaW1lKSk7CisJb3NfZnJlZShjcnVmdCk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjb25maXJtX3BlZXIsIFNIQTI1Nl9NQUNfTEVOKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNvbmZpcm1fc2VydmVyLCBTSEEyNTZfTUFDX0xFTik7CisJZWFwX3B3ZF9oX2ZpbmFsKGhhc2gsIG1rKTsKIAogCS8qIHN0cmV0Y2ggdGhlIG1rIHdpdGggdGhlIHNlc3Npb24taWQgdG8gZ2V0IE1TSyB8IEVNU0sgKi8KLQllYXBfcHdkX2tkZihtaywgU0hBMjU2X0RJR0VTVF9MRU5HVEgsCi0JCSAgICBzZXNzaW9uX2lkLCBTSEEyNTZfRElHRVNUX0xFTkdUSCsxLAotCQkgICAgbXNrX2Vtc2ssIChFQVBfTVNLX0xFTiArIEVBUF9FTVNLX0xFTikgKiA4KTsKKwlpZiAoZWFwX3B3ZF9rZGYobWssIFNIQTI1Nl9NQUNfTEVOLAorCQkJc2Vzc2lvbl9pZCwgU0hBMjU2X01BQ19MRU4gKyAxLAorCQkJbXNrX2Vtc2ssIChFQVBfTVNLX0xFTiArIEVBUF9FTVNLX0xFTikgKiA4KSA8IDApIHsKKwkJcmV0dXJuIC0xOworCX0KIAogCW9zX21lbWNweShtc2ssIG1za19lbXNrLCBFQVBfTVNLX0xFTik7CiAJb3NfbWVtY3B5KGVtc2ssIG1za19lbXNrICsgRUFQX01TS19MRU4sIEVBUF9FTVNLX0xFTik7CiAKLQlvc19mcmVlKGNydWZ0KTsKLQogCXJldHVybiAxOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uaCBiL3NyYy9lYXBfY29tbW9uL2VhcF9wd2RfY29tbW9uLmgKaW5kZXggMzU4ZDAwOC4uODE2ZTU4YyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uaAorKysgYi9zcmMvZWFwX2NvbW1vbi9lYXBfcHdkX2NvbW1vbi5oCkBAIC0xMCwxMCArMTAsOCBAQAogI2RlZmluZSBFQVBfUFdEX0NPTU1PTl9ICiAKICNpbmNsdWRlIDxvcGVuc3NsL2JuLmg+Ci0jaW5jbHVkZSA8b3BlbnNzbC9zaGEuaD4KICNpbmNsdWRlIDxvcGVuc3NsL2VjLmg+CiAjaW5jbHVkZSA8b3BlbnNzbC9ldnAuaD4KLSNpbmNsdWRlIDxvcGVuc3NsL2htYWMuaD4KIAogLyoKICAqIGRlZmluaXRpb24gb2YgYSBmaW5pdGUgY3ljbGljIGdyb3VwCkBAIC02Miw4ICs2MCw4IEBACiAJCQkgICAgIGludCwgdTggKik7CiBpbnQgY29tcHV0ZV9rZXlzKEVBUF9QV0RfZ3JvdXAgKiwgQk5fQ1RYICosIEJJR05VTSAqLCBCSUdOVU0gKiwgQklHTlVNICosCiAJCSB1OCAqLCB1OCAqLCB1MzIgKiwgdTggKiwgdTggKik7Ci12b2lkIEhfSW5pdChITUFDX0NUWCAqKTsKLXZvaWQgSF9VcGRhdGUoSE1BQ19DVFggKiwgY29uc3QgdTggKiwgaW50KTsKLXZvaWQgSF9GaW5hbChITUFDX0NUWCAqLCB1OCAqKTsKK3N0cnVjdCBjcnlwdG9faGFzaCAqIGVhcF9wd2RfaF9pbml0KHZvaWQpOwordm9pZCBlYXBfcHdkX2hfdXBkYXRlKHN0cnVjdCBjcnlwdG9faGFzaCAqaGFzaCwgY29uc3QgdTggKmRhdGEsIHNpemVfdCBsZW4pOwordm9pZCBlYXBfcHdkX2hfZmluYWwoc3RydWN0IGNyeXB0b19oYXNoICpoYXNoLCB1OCAqZGlnZXN0KTsKIAogI2VuZGlmICAvKiBFQVBfUFdEX0NPTU1PTl9IICovCmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwLmMgYi9zcmMvZWFwX3BlZXIvZWFwLmMKaW5kZXggNmE4ODU4OS4uOGI0M2JlNCAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcC5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXAuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBFQVAgcGVlciBzdGF0ZSBtYWNoaW5lcyAoUkZDIDQxMzcpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC04MSw2ICs4MSwxNiBAQAogfQogCiAKK3N0YXRpYyB2b2lkIGVhcF9ub3RpZnlfc3RhdHVzKHN0cnVjdCBlYXBfc20gKnNtLCBjb25zdCBjaGFyICpzdGF0dXMsCisJCQkJICAgICAgY29uc3QgY2hhciAqcGFyYW1ldGVyKQoreworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQOiBTdGF0dXMgbm90aWZpY2F0aW9uOiAlcyAocGFyYW09JXMpIiwKKwkJICAgc3RhdHVzLCBwYXJhbWV0ZXIpOworCWlmIChzbS0+ZWFwb2xfY2ItPm5vdGlmeV9zdGF0dXMpCisJCXNtLT5lYXBvbF9jYi0+bm90aWZ5X3N0YXR1cyhzbS0+ZWFwb2xfY3R4LCBzdGF0dXMsIHBhcmFtZXRlcik7Cit9CisKKwogc3RhdGljIHZvaWQgZWFwX2RlaW5pdF9wcmV2X21ldGhvZChzdHJ1Y3QgZWFwX3NtICpzbSwgY29uc3QgY2hhciAqdHh0KQogewogCWlmIChzbS0+bSA9PSBOVUxMIHx8IHNtLT5lYXBfbWV0aG9kX3ByaXYgPT0gTlVMTCkKQEAgLTIxMyw2ICsyMjMsNyBAQAogewogCWludCByZWluaXQ7CiAJRWFwVHlwZSBtZXRob2Q7CisJY29uc3Qgc3RydWN0IGVhcF9tZXRob2QgKmVhcF9tZXRob2Q7CiAKIAlTTV9FTlRSWShFQVAsIEdFVF9NRVRIT0QpOwogCkBAIC0yMjEsMTggKzIzMiwyNCBAQAogCWVsc2UKIAkJbWV0aG9kID0gc20tPnJlcU1ldGhvZDsKIAorCWVhcF9tZXRob2QgPSBlYXBfcGVlcl9nZXRfZWFwX21ldGhvZChzbS0+cmVxVmVuZG9yLCBtZXRob2QpOworCiAJaWYgKCFlYXBfc21fYWxsb3dNZXRob2Qoc20sIHNtLT5yZXFWZW5kb3IsIG1ldGhvZCkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVA6IHZlbmRvciAldSBtZXRob2QgJXUgbm90IGFsbG93ZWQiLAogCQkJICAgc20tPnJlcVZlbmRvciwgbWV0aG9kKTsKIAkJd3BhX21zZyhzbS0+bXNnX2N0eCwgTVNHX0lORk8sIFdQQV9FVkVOVF9FQVBfUFJPUE9TRURfTUVUSE9ECiAJCQkidmVuZG9yPSV1IG1ldGhvZD0ldSAtPiBOQUsiLAogCQkJc20tPnJlcVZlbmRvciwgbWV0aG9kKTsKKwkJZWFwX25vdGlmeV9zdGF0dXMoc20sICJyZWZ1c2UgcHJvcG9zZWQgbWV0aG9kIiwKKwkJCQkgIGVhcF9tZXRob2QgPyAgZWFwX21ldGhvZC0+bmFtZSA6ICJ1bmtub3duIik7CiAJCWdvdG8gbmFrOwogCX0KIAogCXdwYV9tc2coc20tPm1zZ19jdHgsIE1TR19JTkZPLCBXUEFfRVZFTlRfRUFQX1BST1BPU0VEX01FVEhPRAogCQkidmVuZG9yPSV1IG1ldGhvZD0ldSIsIHNtLT5yZXFWZW5kb3IsIG1ldGhvZCk7CiAKKwllYXBfbm90aWZ5X3N0YXR1cyhzbSwgImFjY2VwdCBwcm9wb3NlZCBtZXRob2QiLAorCQkJICBlYXBfbWV0aG9kID8gIGVhcF9tZXRob2QtPm5hbWUgOiAidW5rbm93biIpOwogCS8qCiAJICogUkZDIDQxMzcgZG9lcyBub3QgZGVmaW5lIHNwZWNpZmljIG9wZXJhdGlvbiBmb3IgZmFzdAogCSAqIHJlLWF1dGhlbnRpY2F0aW9uIChzZXNzaW9uIHJlc3VtcHRpb24pLiBUaGUgZGVzaWduIGhlcmUgaXMgdG8gYWxsb3cKQEAgLTI1Niw3ICsyNzMsNyBAQAogCiAJc20tPnNlbGVjdGVkTWV0aG9kID0gc20tPnJlcU1ldGhvZDsKIAlpZiAoc20tPm0gPT0gTlVMTCkKLQkJc20tPm0gPSBlYXBfcGVlcl9nZXRfZWFwX21ldGhvZChzbS0+cmVxVmVuZG9yLCBtZXRob2QpOworCQlzbS0+bSA9IGVhcF9tZXRob2Q7CiAJaWYgKCFzbS0+bSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUDogQ291bGQgbm90IGZpbmQgc2VsZWN0ZWQgbWV0aG9kOiAiCiAJCQkgICAidmVuZG9yICVkIG1ldGhvZCAlZCIsCkBAIC05MzgsNyArOTU1LDcgQEAKIHN0YXRpYyBpbnQgZWFwX3NtX2ltc2lfaWRlbnRpdHkoc3RydWN0IGVhcF9zbSAqc20sCiAJCQkJc3RydWN0IGVhcF9wZWVyX2NvbmZpZyAqY29uZikKIHsKLQlpbnQgYWthID0gMDsKKwllbnVtIHsgRUFQX1NNX1NJTSwgRUFQX1NNX0FLQSwgRUFQX1NNX0FLQV9QUklNRSB9IG1ldGhvZCA9IEVBUF9TTV9TSU07CiAJY2hhciBpbXNpWzEwMF07CiAJc2l6ZV90IGltc2lfbGVuOwogCXN0cnVjdCBlYXBfbWV0aG9kX3R5cGUgKm0gPSBjb25mLT5lYXBfbWV0aG9kczsKQEAgLTk2Niw4ICs5ODMsMTQgQEAKIAlmb3IgKGkgPSAwOyBtICYmIChtW2ldLnZlbmRvciAhPSBFQVBfVkVORE9SX0lFVEYgfHwKIAkJCSAgbVtpXS5tZXRob2QgIT0gRUFQX1RZUEVfTk9ORSk7IGkrKykgewogCQlpZiAobVtpXS52ZW5kb3IgPT0gRUFQX1ZFTkRPUl9JRVRGICYmCisJCSAgICBtW2ldLm1ldGhvZCA9PSBFQVBfVFlQRV9BS0FfUFJJTUUpIHsKKwkJCW1ldGhvZCA9IEVBUF9TTV9BS0FfUFJJTUU7CisJCQlicmVhazsKKwkJfQorCisJCWlmIChtW2ldLnZlbmRvciA9PSBFQVBfVkVORE9SX0lFVEYgJiYKIAkJICAgIG1baV0ubWV0aG9kID09IEVBUF9UWVBFX0FLQSkgewotCQkJYWthID0gMTsKKwkJCW1ldGhvZCA9IEVBUF9TTV9BS0E7CiAJCQlicmVhazsKIAkJfQogCX0KQEAgLTk4MCw3ICsxMDAzLDE3IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQljb25mLT5pZGVudGl0eVswXSA9IGFrYSA/ICcwJyA6ICcxJzsKKwlzd2l0Y2ggKG1ldGhvZCkgeworCWNhc2UgRUFQX1NNX1NJTToKKwkJY29uZi0+aWRlbnRpdHlbMF0gPSAnMSc7CisJCWJyZWFrOworCWNhc2UgRUFQX1NNX0FLQToKKwkJY29uZi0+aWRlbnRpdHlbMF0gPSAnMCc7CisJCWJyZWFrOworCWNhc2UgRUFQX1NNX0FLQV9QUklNRToKKwkJY29uZi0+aWRlbnRpdHlbMF0gPSAnNic7CisJCWJyZWFrOworCX0KIAlvc19tZW1jcHkoY29uZi0+aWRlbnRpdHkgKyAxLCBpbXNpLCBpbXNpX2xlbik7CiAJY29uZi0+aWRlbnRpdHlfbGVuID0gMSArIGltc2lfbGVuOwogCkBAIC0xMjE5LDEwICsxMjUyLDEyIEBACiAJCWJyZWFrOwogCWNhc2UgRUFQX0NPREVfU1VDQ0VTUzoKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVA6IFJlY2VpdmVkIEVBUC1TdWNjZXNzIik7CisJCWVhcF9ub3RpZnlfc3RhdHVzKHNtLCAiY29tcGxldGlvbiIsICJzdWNjZXNzIik7CiAJCXNtLT5yeFN1Y2Nlc3MgPSBUUlVFOwogCQlicmVhazsKIAljYXNlIEVBUF9DT0RFX0ZBSUxVUkU6CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQOiBSZWNlaXZlZCBFQVAtRmFpbHVyZSIpOworCQllYXBfbm90aWZ5X3N0YXR1cyhzbSwgImNvbXBsZXRpb24iLCAiZmFpbHVyZSIpOwogCQlzbS0+cnhGYWlsdXJlID0gVFJVRTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKQEAgLTEyNDAsNiArMTI3NSwxMCBAQAogCWNoYXIgKmhhc2hfaGV4ID0gTlVMTDsKIAogCXN3aXRjaCAoZXYpIHsKKwljYXNlIFRMU19DRVJUX0NIQUlOX1NVQ0NFU1M6CisJCWVhcF9ub3RpZnlfc3RhdHVzKHNtLCAicmVtb3RlIGNlcnRpZmljYXRlIHZlcmlmaWNhdGlvbiIsCisJCQkJICAic3VjY2VzcyIpOworCQlicmVhazsKIAljYXNlIFRMU19DRVJUX0NIQUlOX0ZBSUxVUkU6CiAJCXdwYV9tc2coc20tPm1zZ19jdHgsIE1TR19JTkZPLCBXUEFfRVZFTlRfRUFQX1RMU19DRVJUX0VSUk9SCiAJCQkicmVhc29uPSVkIGRlcHRoPSVkIHN1YmplY3Q9JyVzJyBlcnI9JyVzJyIsCkBAIC0xMjQ3LDYgKzEyODYsOCBAQAogCQkJZGF0YS0+Y2VydF9mYWlsLmRlcHRoLAogCQkJZGF0YS0+Y2VydF9mYWlsLnN1YmplY3QsCiAJCQlkYXRhLT5jZXJ0X2ZhaWwucmVhc29uX3R4dCk7CisJCWVhcF9ub3RpZnlfc3RhdHVzKHNtLCAicmVtb3RlIGNlcnRpZmljYXRlIHZlcmlmaWNhdGlvbiIsCisJCQkJICBkYXRhLT5jZXJ0X2ZhaWwucmVhc29uX3R4dCk7CiAJCWJyZWFrOwogCWNhc2UgVExTX1BFRVJfQ0VSVElGSUNBVEU6CiAJCWlmICghc20tPmVhcG9sX2NiLT5ub3RpZnlfY2VydCkKQEAgLTEyNjcsNiArMTMwOCwxNCBAQAogCQkJCQkgIGRhdGEtPnBlZXJfY2VydC5zdWJqZWN0LAogCQkJCQkgIGhhc2hfaGV4LCBkYXRhLT5wZWVyX2NlcnQuY2VydCk7CiAJCWJyZWFrOworCWNhc2UgVExTX0FMRVJUOgorCQlpZiAoZGF0YS0+YWxlcnQuaXNfbG9jYWwpCisJCQllYXBfbm90aWZ5X3N0YXR1cyhzbSwgImxvY2FsIFRMUyBhbGVydCIsCisJCQkJCSAgZGF0YS0+YWxlcnQuZGVzY3JpcHRpb24pOworCQllbHNlCisJCQllYXBfbm90aWZ5X3N0YXR1cyhzbSwgInJlbW90ZSBUTFMgYWxlcnQiLAorCQkJCQkgIGRhdGEtPmFsZXJ0LmRlc2NyaXB0aW9uKTsKKwkJYnJlYWs7CiAJfQogCiAJb3NfZnJlZShoYXNoX2hleCk7CkBAIC0xMzIxLDYgKzEzNzAsMTMgQEAKIAkJcmV0dXJuIE5VTEw7CiAJfQogCisJc20tPnNzbF9jdHgyID0gdGxzX2luaXQoJnRsc2NvbmYpOworCWlmIChzbS0+c3NsX2N0eDIgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU1NMOiBGYWlsZWQgdG8gaW5pdGlhbGl6ZSBUTFMgIgorCQkJICAgImNvbnRleHQgKDIpLiIpOworCQkvKiBSdW4gd2l0aG91dCBzZXBhcmF0ZSBUTFMgY29udGV4dCB3aXRoaW4gVExTIHR1bm5lbCAqLworCX0KKwogCXJldHVybiBzbTsKIH0KIApAQCAtMTMzOCw2ICsxMzk0LDggQEAKIAkJcmV0dXJuOwogCWVhcF9kZWluaXRfcHJldl9tZXRob2Qoc20sICJFQVAgZGVpbml0Iik7CiAJZWFwX3NtX2Fib3J0KHNtKTsKKwlpZiAoc20tPnNzbF9jdHgyKQorCQl0bHNfZGVpbml0KHNtLT5zc2xfY3R4Mik7CiAJdGxzX2RlaW5pdChzbS0+c3NsX2N0eCk7CiAJb3NfZnJlZShzbSk7CiB9CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwLmggYi9zcmMvZWFwX3BlZXIvZWFwLmgKaW5kZXggYjk1YTI4NS4uNmU4NzQ3NSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcC5oCisrKyBiL3NyYy9lYXBfcGVlci9lYXAuaApAQCAtMjI2LDYgKzIyNiwxNSBAQAogCSAqLwogCXZvaWQgKCpub3RpZnlfY2VydCkodm9pZCAqY3R4LCBpbnQgZGVwdGgsIGNvbnN0IGNoYXIgKnN1YmplY3QsCiAJCQkgICAgY29uc3QgY2hhciAqY2VydF9oYXNoLCBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpjZXJ0KTsKKworCS8qKgorCSAqIG5vdGlmeV9zdGF0dXMgLSBOb3RpZmljYXRpb24gb2YgdGhlIGN1cnJlbnQgRUFQIHN0YXRlCisJICogQGN0eDogZWFwb2xfY3R4IGZyb20gZWFwX3BlZXJfc21faW5pdCgpIGNhbGwKKwkgKiBAc3RhdHVzOiBTdGVwIGluIHRoZSBwcm9jZXNzIG9mIEVBUCBhdXRoZW50aWNhdGlvbgorCSAqIEBwYXJhbWV0ZXI6IFN0ZXAtc3BlY2lmaWMgcGFyYW1ldGVyLCBlLmcuLCBFQVAgbWV0aG9kIG5hbWUKKwkgKi8KKwl2b2lkICgqbm90aWZ5X3N0YXR1cykodm9pZCAqY3R4LCBjb25zdCBjaGFyICpzdGF0dXMsCisJCQkgICAgICBjb25zdCBjaGFyICpwYXJhbWV0ZXIpOwogfTsKIAogLyoqCmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX2FrYS5jIGIvc3JjL2VhcF9wZWVyL2VhcF9ha2EuYwppbmRleCA3ZTM3ZTQ0Li4xY2VjNGQ4IDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX2FrYS5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfYWthLmMKQEAgLTEsNiArMSw2IEBACiAvKgotICogRUFQIHBlZXIgbWV0aG9kOiBFQVAtQUtBIChSRkMgNDE4NykgYW5kIEVBUC1BS0EnIChkcmFmdC1hcmtrby1lYXAtYWthLWtkZikKLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA4LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogRUFQIHBlZXIgbWV0aG9kOiBFQVAtQUtBIChSRkMgNDE4NykgYW5kIEVBUC1BS0EnIChSRkMgNTQ0OCkKKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yMjksMTkgKzIyOSwxOSBAQAogCiBzdGF0aWMgdm9pZCBlYXBfYWthX2NsZWFyX2lkZW50aXRpZXMoc3RydWN0IGVhcF9ha2FfZGF0YSAqZGF0YSwgaW50IGlkKQogewotCWlmIChpZCAmIENMRUFSX1BTRVVET05ZTSkgeworCWlmICgoaWQgJiBDTEVBUl9QU0VVRE9OWU0pICYmIGRhdGEtPnBzZXVkb255bSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1BS0E6IGZvcmdldHRpbmcgb2xkIHBzZXVkb255bSIpOwogCQlvc19mcmVlKGRhdGEtPnBzZXVkb255bSk7CiAJCWRhdGEtPnBzZXVkb255bSA9IE5VTEw7CiAJCWRhdGEtPnBzZXVkb255bV9sZW4gPSAwOwogCX0KLQlpZiAoaWQgJiBDTEVBUl9SRUFVVEhfSUQpIHsKKwlpZiAoKGlkICYgQ0xFQVJfUkVBVVRIX0lEKSAmJiBkYXRhLT5yZWF1dGhfaWQpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtQUtBOiBmb3JnZXR0aW5nIG9sZCByZWF1dGhfaWQiKTsKIAkJb3NfZnJlZShkYXRhLT5yZWF1dGhfaWQpOwogCQlkYXRhLT5yZWF1dGhfaWQgPSBOVUxMOwogCQlkYXRhLT5yZWF1dGhfaWRfbGVuID0gMDsKIAl9Ci0JaWYgKGlkICYgQ0xFQVJfRUFQX0lEKSB7CisJaWYgKChpZCAmIENMRUFSX0VBUF9JRCkgJiYgZGF0YS0+bGFzdF9lYXBfaWRlbnRpdHkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtQUtBOiBmb3JnZXR0aW5nIG9sZCBlYXBfaWQiKTsKIAkJb3NfZnJlZShkYXRhLT5sYXN0X2VhcF9pZGVudGl0eSk7CiAJCWRhdGEtPmxhc3RfZWFwX2lkZW50aXR5ID0gTlVMTDsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfaS5oIGIvc3JjL2VhcF9wZWVyL2VhcF9pLmgKaW5kZXggMDZkNmRiNi4uMzMxOGI4MSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9pLmgKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF9pLmgKQEAgLTMxNyw2ICszMTcsNyBAQAogCXZvaWQgKm1zZ19jdHg7CiAJdm9pZCAqc2NhcmRfY3R4OwogCXZvaWQgKnNzbF9jdHg7CisJdm9pZCAqc3NsX2N0eDI7CiAKIAl1bnNpZ25lZCBpbnQgd29ya2Fyb3VuZDsKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF9wd2QuYyBiL3NyYy9lYXBfcGVlci9lYXBfcHdkLmMKaW5kZXggMzdlOTIzNC4uMjY3ZDBhNSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF9wd2QuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX3B3ZC5jCkBAIC05LDYgKzksNyBAQAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCiAKICNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJjcnlwdG8vc2hhMjU2LmgiCiAjaW5jbHVkZSAiZWFwX3BlZXIvZWFwX2kuaCIKICNpbmNsdWRlICJlYXBfY29tbW9uL2VhcF9wd2RfY29tbW9uLmgiCiAKQEAgLTQ1OSwxMCArNDYwLDEwIEBACiAJCQkJIGNvbnN0IHU4ICpwYXlsb2FkLCBzaXplX3QgcGF5bG9hZF9sZW4pCiB7CiAJQklHTlVNICp4ID0gTlVMTCwgKnkgPSBOVUxMOwotCUhNQUNfQ1RYIGN0eDsKKwlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmhhc2g7CiAJdTMyIGNzOwogCXUxNiBncnA7Ci0JdTggY29uZltTSEEyNTZfRElHRVNUX0xFTkdUSF0sICpjcnVmdCA9IE5VTEwsICpwdHI7CisJdTggY29uZltTSEEyNTZfTUFDX0xFTl0sICpjcnVmdCA9IE5VTEwsICpwdHI7CiAJaW50IG9mZnNldDsKIAogCS8qCkBAIC00ODksNyArNDkwLDkgQEAKIAkgKiBzZXJ2ZXIncyBjb21taXQgaXMgSChrIHwgc2VydmVyX2VsZW1lbnQgfCBzZXJ2ZXJfc2NhbGFyIHwKIAkgKgkJCXBlZXJfZWxlbWVudCB8IHBlZXJfc2NhbGFyIHwgY2lwaGVyc3VpdGUpCiAJICovCi0JSF9Jbml0KCZjdHgpOworCWhhc2ggPSBlYXBfcHdkX2hfaW5pdCgpOworCWlmIChoYXNoID09IE5VTEwpCisJCWdvdG8gZmluOwogCiAJLyoKIAkgKiB6ZXJvIHRoZSBtZW1vcnkgZWFjaCB0aW1lIGJlY2F1c2UgdGhpcyBpcyBtb2QgcHJpbWUgbWF0aCBhbmQgc29tZQpAQCAtNDk4LDcgKzUwMSw3IEBACiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyhkYXRhLT5rKTsKIAlCTl9ibjJiaW4oZGF0YS0+aywgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAKIAkvKiBzZXJ2ZXIgZWxlbWVudDogeCwgeSAqLwogCWlmICghRUNfUE9JTlRfZ2V0X2FmZmluZV9jb29yZGluYXRlc19HRnAoZGF0YS0+Z3JwLT5ncm91cCwKQEAgLTUxMSwxOCArNTE0LDE4IEBACiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyh4KTsKIAlCTl9ibjJiaW4oeCwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyh5KTsKIAlCTl9ibjJiaW4oeSwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAKIAkvKiBzZXJ2ZXIgc2NhbGFyICovCiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSAtCiAJCUJOX251bV9ieXRlcyhkYXRhLT5zZXJ2ZXJfc2NhbGFyKTsKIAlCTl9ibjJiaW4oZGF0YS0+c2VydmVyX3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CiAKIAkvKiBteSBlbGVtZW50OiB4LCB5ICovCiAJaWYgKCFFQ19QT0lOVF9nZXRfYWZmaW5lX2Nvb3JkaW5hdGVzX0dGcChkYXRhLT5ncnAtPmdyb3VwLApAQCAtNTM2LDI3ICs1MzksMjcgQEAKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHgpOwogCUJOX2JuMmJpbih4LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHkpOwogCUJOX2JuMmJpbih5LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAogCS8qIG15IHNjYWxhciAqLwogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvZmZzZXQgPSBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikgLQogCQlCTl9udW1fYnl0ZXMoZGF0YS0+bXlfc2NhbGFyKTsKIAlCTl9ibjJiaW4oZGF0YS0+bXlfc2NhbGFyLCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpKTsKIAogCS8qIHRoZSBjaXBoZXJzdWl0ZSAqLwotCUhfVXBkYXRlKCZjdHgsICh1OCAqKSAmY3MsIHNpemVvZih1MzIpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsICh1OCAqKSAmY3MsIHNpemVvZih1MzIpKTsKIAogCS8qIHJhbmRvbSBmdW5jdGlvbiBmaW4gKi8KLQlIX0ZpbmFsKCZjdHgsIGNvbmYpOworCWVhcF9wd2RfaF9maW5hbChoYXNoLCBjb25mKTsKIAogCXB0ciA9ICh1OCAqKSBwYXlsb2FkOwotCWlmIChvc19tZW1jbXAoY29uZiwgcHRyLCBTSEEyNTZfRElHRVNUX0xFTkdUSCkpIHsKKwlpZiAob3NfbWVtY21wKGNvbmYsIHB0ciwgU0hBMjU2X01BQ19MRU4pKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtUFdEIChwZWVyKTogY29uZmlybSBkaWQgbm90IHZlcmlmeSIpOwogCQlnb3RvIGZpbjsKIAl9CkBAIC01NjgsMTMgKzU3MSwxNSBAQAogCSAqICBIKGsgfCBwZWVyX2VsZW1lbnQgfCBwZWVyX3NjYWxhciB8IHNlcnZlcl9lbGVtZW50IHwgc2VydmVyX3NjYWxhciB8CiAJICogICAgY2lwaGVyc3VpdGUpCiAJICovCi0JSF9Jbml0KCZjdHgpOworCWhhc2ggPSBlYXBfcHdkX2hfaW5pdCgpOworCWlmIChoYXNoID09IE5VTEwpCisJCWdvdG8gZmluOwogCiAJLyogayAqLwogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvZmZzZXQgPSBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkgLSBCTl9udW1fYnl0ZXMoZGF0YS0+ayk7CiAJQk5fYm4yYmluKGRhdGEtPmssIGNydWZ0ICsgb2Zmc2V0KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCiAJLyogbXkgZWxlbWVudCAqLwogCWlmICghRUNfUE9JTlRfZ2V0X2FmZmluZV9jb29yZGluYXRlc19HRnAoZGF0YS0+Z3JwLT5ncm91cCwKQEAgLTU4NywxOCArNTkyLDE4IEBACiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyh4KTsKIAlCTl9ibjJiaW4oeCwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyh5KTsKIAlCTl9ibjJiaW4oeSwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAKIAkvKiBteSBzY2FsYXIgKi8KIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpIC0KIAkJQk5fbnVtX2J5dGVzKGRhdGEtPm15X3NjYWxhcik7CiAJQk5fYm4yYmluKGRhdGEtPm15X3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CiAKIAkvKiBzZXJ2ZXIgZWxlbWVudDogeCwgeSAqLwogCWlmICghRUNfUE9JTlRfZ2V0X2FmZmluZV9jb29yZGluYXRlc19HRnAoZGF0YS0+Z3JwLT5ncm91cCwKQEAgLTYxMSwyNCArNjE2LDI0IEBACiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyh4KTsKIAlCTl9ibjJiaW4oeCwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSAtIEJOX251bV9ieXRlcyh5KTsKIAlCTl9ibjJiaW4oeSwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAKIAkvKiBzZXJ2ZXIgc2NhbGFyICovCiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSAtCiAJCUJOX251bV9ieXRlcyhkYXRhLT5zZXJ2ZXJfc2NhbGFyKTsKIAlCTl9ibjJiaW4oZGF0YS0+c2VydmVyX3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CiAKIAkvKiB0aGUgY2lwaGVyc3VpdGUgKi8KLQlIX1VwZGF0ZSgmY3R4LCAodTggKikgJmNzLCBzaXplb2YodTMyKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCAodTggKikgJmNzLCBzaXplb2YodTMyKSk7CiAKIAkvKiBhbGwgZG9uZSAqLwotCUhfRmluYWwoJmN0eCwgY29uZik7CisJZWFwX3B3ZF9oX2ZpbmFsKGhhc2gsIGNvbmYpOwogCiAJaWYgKGNvbXB1dGVfa2V5cyhkYXRhLT5ncnAsIGRhdGEtPmJuY3R4LCBkYXRhLT5rLAogCQkJIGRhdGEtPm15X3NjYWxhciwgZGF0YS0+c2VydmVyX3NjYWxhciwgY29uZiwgcHRyLApAQCAtNjM4LDExICs2NDMsMTEgQEAKIAkJZ290byBmaW47CiAJfQogCi0JZGF0YS0+b3V0YnVmID0gd3BhYnVmX2FsbG9jKFNIQTI1Nl9ESUdFU1RfTEVOR1RIKTsKKwlkYXRhLT5vdXRidWYgPSB3cGFidWZfYWxsb2MoU0hBMjU2X01BQ19MRU4pOwogCWlmIChkYXRhLT5vdXRidWYgPT0gTlVMTCkKIAkJZ290byBmaW47CiAKLQl3cGFidWZfcHV0X2RhdGEoZGF0YS0+b3V0YnVmLCBjb25mLCBTSEEyNTZfRElHRVNUX0xFTkdUSCk7CisJd3BhYnVmX3B1dF9kYXRhKGRhdGEtPm91dGJ1ZiwgY29uZiwgU0hBMjU2X01BQ19MRU4pOwogCiBmaW46CiAJb3NfZnJlZShjcnVmdCk7CkBAIC03MjUsNiArNzMwLDcgQEAKIAkJICovCiAJCWlmIChkYXRhLT5vdXRfZnJhZ19wb3MgPj0gd3BhYnVmX2xlbihkYXRhLT5vdXRidWYpKSB7CiAJCQl3cGFidWZfZnJlZShkYXRhLT5vdXRidWYpOworCQkJZGF0YS0+b3V0YnVmID0gTlVMTDsKIAkJCWRhdGEtPm91dF9mcmFnX3BvcyA9IDA7CiAJCX0KIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJFQVAtcHdkOiBTZW5kICVzIGZyYWdtZW50IG9mICVkIGJ5dGVzIiwKQEAgLTg1Niw4ICs4NjIsMTEgQEAKIAkvKgogCSAqIGlmIHdlJ3JlIG5vdCBmcmFnbWVudGluZyB0aGVuIHRoZXJlJ3Mgbm8gbmVlZCB0byBjYXJyeSB0aGlzIGFyb3VuZAogCSAqLwotCWlmIChkYXRhLT5vdXRfZnJhZ19wb3MgPT0gMCkKKwlpZiAoZGF0YS0+b3V0X2ZyYWdfcG9zID09IDApIHsKIAkJd3BhYnVmX2ZyZWUoZGF0YS0+b3V0YnVmKTsKKwkJZGF0YS0+b3V0YnVmID0gTlVMTDsKKwkJZGF0YS0+b3V0X2ZyYWdfcG9zID0gMDsKKwl9CiAKIAlyZXR1cm4gcmVzcDsKIH0KZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfdGxzLmMgYi9zcmMvZWFwX3BlZXIvZWFwX3Rscy5jCmluZGV4IGEzMDY3ZmEuLmVkNTJmYjYgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfcGVlci9lYXBfdGxzLmMKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF90bHMuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBFQVAgcGVlciBtZXRob2Q6IEVBUC1UTFMgKFJGQyAyNzE2KQotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDgsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAwOCwgMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMjEsNiArMjEsNyBAQAogc3RydWN0IGVhcF90bHNfZGF0YSB7CiAJc3RydWN0IGVhcF9zc2xfZGF0YSBzc2w7CiAJdTggKmtleV9kYXRhOworCXZvaWQgKnNzbF9jdHg7CiB9OwogCiAKQEAgLTQwLDYgKzQxLDkgQEAKIAlpZiAoZGF0YSA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKIAorCWRhdGEtPnNzbF9jdHggPSBzbS0+aW5pdF9waGFzZTIgJiYgc20tPnNzbF9jdHgyID8gc20tPnNzbF9jdHgyIDoKKwkJc20tPnNzbF9jdHg7CisKIAlpZiAoZWFwX3BlZXJfdGxzX3NzbF9pbml0KHNtLCAmZGF0YS0+c3NsLCBjb25maWcpKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtVExTOiBGYWlsZWQgdG8gaW5pdGlhbGl6ZSBTU0wuIik7CiAJCWVhcF90bHNfZGVpbml0KHNtLCBkYXRhKTsKQEAgLTE2NSw3ICsxNjksNyBAQAogCQlyZXR1cm4gZWFwX3Rsc19mYWlsdXJlKHNtLCBkYXRhLCByZXQsIHJlcywgcmVzcCwgaWQpOwogCX0KIAotCWlmICh0bHNfY29ubmVjdGlvbl9lc3RhYmxpc2hlZChzbS0+c3NsX2N0eCwgZGF0YS0+c3NsLmNvbm4pKQorCWlmICh0bHNfY29ubmVjdGlvbl9lc3RhYmxpc2hlZChkYXRhLT5zc2xfY3R4LCBkYXRhLT5zc2wuY29ubikpCiAJCWVhcF90bHNfc3VjY2VzcyhzbSwgZGF0YSwgcmV0KTsKIAogCWlmIChyZXMgPT0gMSkgewpAQCAtMTgwLDcgKzE4NCw3IEBACiBzdGF0aWMgQm9vbGVhbiBlYXBfdGxzX2hhc19yZWF1dGhfZGF0YShzdHJ1Y3QgZWFwX3NtICpzbSwgdm9pZCAqcHJpdikKIHsKIAlzdHJ1Y3QgZWFwX3Rsc19kYXRhICpkYXRhID0gcHJpdjsKLQlyZXR1cm4gdGxzX2Nvbm5lY3Rpb25fZXN0YWJsaXNoZWQoc20tPnNzbF9jdHgsIGRhdGEtPnNzbC5jb25uKTsKKwlyZXR1cm4gdGxzX2Nvbm5lY3Rpb25fZXN0YWJsaXNoZWQoZGF0YS0+c3NsX2N0eCwgZGF0YS0+c3NsLmNvbm4pOwogfQogCiAKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfdGxzX2NvbW1vbi5jIGIvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmMKaW5kZXggNTI1NDlmNC4uNjllODNkOSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmMKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogRUFQIHBlZXI6IEVBUC1UTFMvUEVBUC9UVExTL0ZBU1QgY29tbW9uIGZ1bmN0aW9ucwotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTM2LDE0ICsxMzYsMTQgQEAKIHsKIAlpbnQgcmVzOwogCi0JZGF0YS0+Y29ubiA9IHRsc19jb25uZWN0aW9uX2luaXQoc20tPnNzbF9jdHgpOworCWRhdGEtPmNvbm4gPSB0bHNfY29ubmVjdGlvbl9pbml0KGRhdGEtPnNzbF9jdHgpOwogCWlmIChkYXRhLT5jb25uID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNTTDogRmFpbGVkIHRvIGluaXRpYWxpemUgbmV3IFRMUyAiCiAJCQkgICAiY29ubmVjdGlvbiIpOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JcmVzID0gdGxzX2Nvbm5lY3Rpb25fc2V0X3BhcmFtcyhzbS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwgcGFyYW1zKTsKKwlyZXMgPSB0bHNfY29ubmVjdGlvbl9zZXRfcGFyYW1zKGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4sIHBhcmFtcyk7CiAJaWYgKHJlcyA9PSBUTFNfU0VUX1BBUkFNU19FTkdJTkVfUFJWX0lOSVRfRkFJTEVEKSB7CiAJCS8qCiAJCSAqIEF0IHRoaXMgcG9pbnQgd2l0aCB0aGUgcGtjczExIGVuZ2luZSB0aGUgUElOIG1pZ2h0IGJlIHdyb25nLgpAQCAtMTYyLDEzICsxNjIsMTMgQEAKIAkJY29uZmlnLT5waW4gPSBOVUxMOwogCQllYXBfc21fcmVxdWVzdF9waW4oc20pOwogCQlzbS0+aWdub3JlID0gVFJVRTsKLQkJdGxzX2Nvbm5lY3Rpb25fZGVpbml0KHNtLT5zc2xfY3R4LCBkYXRhLT5jb25uKTsKKwkJdGxzX2Nvbm5lY3Rpb25fZGVpbml0KGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4pOwogCQlkYXRhLT5jb25uID0gTlVMTDsKIAkJcmV0dXJuIC0xOwogCX0gZWxzZSBpZiAocmVzKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJUTFM6IEZhaWxlZCB0byBzZXQgVExTIGNvbm5lY3Rpb24gIgogCQkJICAgInBhcmFtZXRlcnMiKTsKLQkJdGxzX2Nvbm5lY3Rpb25fZGVpbml0KHNtLT5zc2xfY3R4LCBkYXRhLT5jb25uKTsKKwkJdGxzX2Nvbm5lY3Rpb25fZGVpbml0KGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4pOwogCQlkYXRhLT5jb25uID0gTlVMTDsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTE5Nyw2ICsxOTcsOCBAQAogCiAJZGF0YS0+ZWFwID0gc207CiAJZGF0YS0+cGhhc2UyID0gc20tPmluaXRfcGhhc2UyOworCWRhdGEtPnNzbF9jdHggPSBzbS0+aW5pdF9waGFzZTIgJiYgc20tPnNzbF9jdHgyID8gc20tPnNzbF9jdHgyIDoKKwkJc20tPnNzbF9jdHg7CiAJaWYgKGVhcF90bHNfcGFyYW1zX2Zyb21fY29uZihzbSwgZGF0YSwgJnBhcmFtcywgY29uZmlnLCBkYXRhLT5waGFzZTIpIDwKIAkgICAgMCkKIAkJcmV0dXJuIC0xOwpAQCAtMjM0LDcgKzIzNiw3IEBACiAgKi8KIHZvaWQgZWFwX3BlZXJfdGxzX3NzbF9kZWluaXQoc3RydWN0IGVhcF9zbSAqc20sIHN0cnVjdCBlYXBfc3NsX2RhdGEgKmRhdGEpCiB7Ci0JdGxzX2Nvbm5lY3Rpb25fZGVpbml0KHNtLT5zc2xfY3R4LCBkYXRhLT5jb25uKTsKKwl0bHNfY29ubmVjdGlvbl9kZWluaXQoZGF0YS0+c3NsX2N0eCwgZGF0YS0+Y29ubik7CiAJZWFwX3BlZXJfdGxzX3Jlc2V0X2lucHV0KGRhdGEpOwogCWVhcF9wZWVyX3Rsc19yZXNldF9vdXRwdXQoZGF0YSk7CiB9CkBAIC0yNjUsOCArMjY3LDggQEAKIAkJcmV0dXJuIE5VTEw7CiAKIAkvKiBGaXJzdCwgdHJ5IHRvIHVzZSBUTFMgbGlicmFyeSBmdW5jdGlvbiBmb3IgUFJGLCBpZiBhdmFpbGFibGUuICovCi0JaWYgKHRsc19jb25uZWN0aW9uX3ByZihzbS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwgbGFiZWwsIDAsIG91dCwgbGVuKSA9PQotCSAgICAwKQorCWlmICh0bHNfY29ubmVjdGlvbl9wcmYoZGF0YS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwgbGFiZWwsIDAsIG91dCwgbGVuKQorCSAgICA9PSAwKQogCQlyZXR1cm4gb3V0OwogCiAJLyoKQEAgLTI3NCw3ICsyNzYsNyBAQAogCSAqIHNlc3Npb24gcGFyYW1ldGVycyBhbmQgdXNlIGFuIGludGVybmFsIGltcGxlbWVudGF0aW9uIG9mIFRMUyBQUkYgdG8KIAkgKiBkZXJpdmUgdGhlIGtleS4KIAkgKi8KLQlpZiAodGxzX2Nvbm5lY3Rpb25fZ2V0X2tleXMoc20tPnNzbF9jdHgsIGRhdGEtPmNvbm4sICZrZXlzKSkKKwlpZiAodGxzX2Nvbm5lY3Rpb25fZ2V0X2tleXMoZGF0YS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwgJmtleXMpKQogCQlnb3RvIGZhaWw7CiAKIAlpZiAoa2V5cy5jbGllbnRfcmFuZG9tID09IE5VTEwgfHwga2V5cy5zZXJ2ZXJfcmFuZG9tID09IE5VTEwgfHwKQEAgLTQ0MSwxNCArNDQzLDE0IEBACiAJCVdQQV9BU1NFUlQoZGF0YS0+dGxzX291dCA9PSBOVUxMKTsKIAl9CiAJYXBwbF9kYXRhID0gTlVMTDsKLQlkYXRhLT50bHNfb3V0ID0gdGxzX2Nvbm5lY3Rpb25faGFuZHNoYWtlKHNtLT5zc2xfY3R4LCBkYXRhLT5jb25uLAorCWRhdGEtPnRsc19vdXQgPSB0bHNfY29ubmVjdGlvbl9oYW5kc2hha2UoZGF0YS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwKIAkJCQkJCSBtc2csICZhcHBsX2RhdGEpOwogCiAJZWFwX3BlZXJfdGxzX3Jlc2V0X2lucHV0KGRhdGEpOwogCiAJaWYgKGFwcGxfZGF0YSAmJgotCSAgICB0bHNfY29ubmVjdGlvbl9lc3RhYmxpc2hlZChzbS0+c3NsX2N0eCwgZGF0YS0+Y29ubikgJiYKLQkgICAgIXRsc19jb25uZWN0aW9uX2dldF9mYWlsZWQoc20tPnNzbF9jdHgsIGRhdGEtPmNvbm4pKSB7CisJICAgIHRsc19jb25uZWN0aW9uX2VzdGFibGlzaGVkKGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4pICYmCisJICAgICF0bHNfY29ubmVjdGlvbl9nZXRfZmFpbGVkKGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4pKSB7CiAJCXdwYV9oZXhkdW1wX2J1Zl9rZXkoTVNHX01TR0RVTVAsICJTU0w6IEFwcGxpY2F0aW9uIGRhdGEiLAogCQkJCSAgICBhcHBsX2RhdGEpOwogCQkqb3V0X2RhdGEgPSBhcHBsX2RhdGE7CkBAIC02MTYsNyArNjE4LDcgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmICh0bHNfY29ubmVjdGlvbl9nZXRfZmFpbGVkKHNtLT5zc2xfY3R4LCBkYXRhLT5jb25uKSkgeworCWlmICh0bHNfY29ubmVjdGlvbl9nZXRfZmFpbGVkKGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4pKSB7CiAJCS8qIFRMUyBwcm9jZXNzaW5nIGhhcyBmYWlsZWQgLSByZXR1cm4gZXJyb3IgKi8KIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTU0w6IEZhaWxlZCAtIHRsc19vdXQgYXZhaWxhYmxlIHRvICIKIAkJCSAgICJyZXBvcnQgZXJyb3IiKTsKQEAgLTY3NSw3ICs2NzcsNyBAQAogewogCWVhcF9wZWVyX3Rsc19yZXNldF9pbnB1dChkYXRhKTsKIAllYXBfcGVlcl90bHNfcmVzZXRfb3V0cHV0KGRhdGEpOwotCXJldHVybiB0bHNfY29ubmVjdGlvbl9zaHV0ZG93bihzbS0+c3NsX2N0eCwgZGF0YS0+Y29ubik7CisJcmV0dXJuIHRsc19jb25uZWN0aW9uX3NodXRkb3duKGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4pOwogfQogCiAKQEAgLTY5NCw3ICs2OTYsOCBAQAogCWNoYXIgbmFtZVsxMjhdOwogCWludCBsZW4gPSAwLCByZXQ7CiAKLQlpZiAodGxzX2dldF9jaXBoZXIoc20tPnNzbF9jdHgsIGRhdGEtPmNvbm4sIG5hbWUsIHNpemVvZihuYW1lKSkgPT0gMCkgeworCWlmICh0bHNfZ2V0X2NpcGhlcihkYXRhLT5zc2xfY3R4LCBkYXRhLT5jb25uLCBuYW1lLCBzaXplb2YobmFtZSkpID09IDApCisJewogCQlyZXQgPSBvc19zbnByaW50ZihidWYgKyBsZW4sIGJ1ZmxlbiAtIGxlbiwKIAkJCQkgICJFQVAgVExTIGNpcGhlcj0lc1xuIiwgbmFtZSk7CiAJCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4gLSBsZW4pCkBAIC03NDEsNyArNzQ0LDcgQEAKIAlzaXplX3QgbGVmdDsKIAl1bnNpZ25lZCBpbnQgdGxzX21zZ19sZW47CiAKLQlpZiAodGxzX2dldF9lcnJvcnMoc20tPnNzbF9jdHgpKSB7CisJaWYgKHRsc19nZXRfZXJyb3JzKGRhdGEtPnNzbF9jdHgpKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJTU0w6IFRMUyBlcnJvcnMgZGV0ZWN0ZWQiKTsKIAkJcmV0LT5pZ25vcmUgPSBUUlVFOwogCQlyZXR1cm4gTlVMTDsKQEAgLTg0OSw3ICs4NTIsNyBAQAogCWlmIChtc2cgPT0gTlVMTCkKIAkJcmV0dXJuIG5lZWRfbW9yZV9pbnB1dCA/IDEgOiAtMTsKIAotCSppbl9kZWNyeXB0ZWQgPSB0bHNfY29ubmVjdGlvbl9kZWNyeXB0KHNtLT5zc2xfY3R4LCBkYXRhLT5jb25uLCBtc2cpOworCSppbl9kZWNyeXB0ZWQgPSB0bHNfY29ubmVjdGlvbl9kZWNyeXB0KGRhdGEtPnNzbF9jdHgsIGRhdGEtPmNvbm4sIG1zZyk7CiAJZWFwX3BlZXJfdGxzX3Jlc2V0X2lucHV0KGRhdGEpOwogCWlmICgqaW5fZGVjcnlwdGVkID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNTTDogRmFpbGVkIHRvIGRlY3J5cHQgUGhhc2UgMiBkYXRhIik7CkBAIC04NzcsOCArODgwLDggQEAKIHsKIAlpZiAoaW5fZGF0YSkgewogCQllYXBfcGVlcl90bHNfcmVzZXRfb3V0cHV0KGRhdGEpOwotCQlkYXRhLT50bHNfb3V0ID0gdGxzX2Nvbm5lY3Rpb25fZW5jcnlwdChzbS0+c3NsX2N0eCwgZGF0YS0+Y29ubiwKLQkJCQkJCSAgICAgICBpbl9kYXRhKTsKKwkJZGF0YS0+dGxzX291dCA9IHRsc19jb25uZWN0aW9uX2VuY3J5cHQoZGF0YS0+c3NsX2N0eCwKKwkJCQkJCSAgICAgICBkYXRhLT5jb25uLCBpbl9kYXRhKTsKIAkJaWYgKGRhdGEtPnRsc19vdXQgPT0gTlVMTCkgewogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIlNTTDogRmFpbGVkIHRvIGVuY3J5cHQgUGhhc2UgMiAiCiAJCQkJICAgImRhdGEgKGluX2xlbj0lbHUpIiwKZGlmZiAtLWdpdCBhL3NyYy9lYXBfcGVlci9lYXBfdGxzX2NvbW1vbi5oIGIvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmgKaW5kZXggNzQyNjQ2Ny4uNzcxMzg1YiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmgKKysrIGIvc3JjL2VhcF9wZWVyL2VhcF90bHNfY29tbW9uLmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogRUFQIHBlZXI6IEVBUC1UTFMvUEVBUC9UVExTL0ZBU1QgY29tbW9uIGZ1bmN0aW9ucwotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAwOSwgMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNjMsNiArNjMsMTEgQEAKIAkgKiBlYXAgLSBFQVAgc3RhdGUgbWFjaGluZSBhbGxvY2F0ZWQgd2l0aCBlYXBfcGVlcl9zbV9pbml0KCkKIAkgKi8KIAlzdHJ1Y3QgZWFwX3NtICplYXA7CisKKwkvKioKKwkgKiBzc2xfY3R4IC0gVExTIGxpYnJhcnkgY29udGV4dCB0byB1c2UgZm9yIHRoZSBjb25uZWN0aW9uCisJICovCisJdm9pZCAqc3NsX2N0eDsKIH07CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcF9wZWVyL2VhcF90dGxzLmMgYi9zcmMvZWFwX3BlZXIvZWFwX3R0bHMuYwppbmRleCAwMjA0YmEyLi5lMDlmNWU1IDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3R0bHMuYworKysgYi9zcmMvZWFwX3BlZXIvZWFwX3R0bHMuYwpAQCAtNDM1LDcgKzQzNSw2IEBACiAJCQkgICAiaW1wbGljaXQgY2hhbGxlbmdlIik7CiAJCXJldHVybiAtMTsKIAl9Ci0JcGVlcl9jaGFsbGVuZ2UgPSBjaGFsbGVuZ2UgKyAxICsgRUFQX1RUTFNfTVNDSEFQVjJfQ0hBTExFTkdFX0xFTjsKIAogCXBvcyA9IGVhcF90dGxzX2F2cF9hZGQoYnVmLCBwb3MsIFJBRElVU19BVFRSX01TX0NIQVBfQ0hBTExFTkdFLAogCQkJICAgICAgIFJBRElVU19WRU5ET1JfSURfTUlDUk9TT0ZULCAxLApAQCAtNDQ4LDcgKzQ0NywxNCBAQAogCWRhdGEtPmlkZW50ID0gY2hhbGxlbmdlW0VBUF9UVExTX01TQ0hBUFYyX0NIQUxMRU5HRV9MRU5dOwogCSpwb3MrKyA9IGRhdGEtPmlkZW50OwogCSpwb3MrKyA9IDA7IC8qIEZsYWdzICovCi0Jb3NfbWVtY3B5KHBvcywgcGVlcl9jaGFsbGVuZ2UsIEVBUF9UVExTX01TQ0hBUFYyX0NIQUxMRU5HRV9MRU4pOworCWlmIChvc19nZXRfcmFuZG9tKHBvcywgRUFQX1RUTFNfTVNDSEFQVjJfQ0hBTExFTkdFX0xFTikgPCAwKSB7CisJCW9zX2ZyZWUoY2hhbGxlbmdlKTsKKwkJd3BhYnVmX2ZyZWUobXNnKTsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJFQVAtVFRMUy9NU0NIQVBWMjogRmFpbGVkIHRvIGdldCAiCisJCQkgICAicmFuZG9tIGRhdGEgZm9yIHBlZXIgY2hhbGxlbmdlIik7CisJCXJldHVybiAtMTsKKwl9CisJcGVlcl9jaGFsbGVuZ2UgPSBwb3M7CiAJcG9zICs9IEVBUF9UVExTX01TQ0hBUFYyX0NIQUxMRU5HRV9MRU47CiAJb3NfbWVtc2V0KHBvcywgMCwgOCk7IC8qIFJlc2VydmVkLCBtdXN0IGJlIHplcm8gKi8KIAlwb3MgKz0gODsKQEAgLTQ1Niw2ICs0NjIsNyBAQAogCQkJCSAgICAgcGFzc3dvcmRfbGVuLCBwd2hhc2gsIGNoYWxsZW5nZSwKIAkJCQkgICAgIHBlZXJfY2hhbGxlbmdlLCBwb3MsIGRhdGEtPmF1dGhfcmVzcG9uc2UsCiAJCQkJICAgICBkYXRhLT5tYXN0ZXJfa2V5KSkgeworCQlvc19mcmVlKGNoYWxsZW5nZSk7CiAJCXdwYWJ1Zl9mcmVlKG1zZyk7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiRUFQLVRUTFMvTVNDSEFQVjI6IEZhaWxlZCB0byBkZXJpdmUgIgogCQkJICAgInJlc3BvbnNlIik7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3BlZXIvZWFwX3dzYy5jIGIvc3JjL2VhcF9wZWVyL2VhcF93c2MuYwppbmRleCA0NDczYjkwLi5kMDA3YTU3IDEwMDY0NAotLS0gYS9zcmMvZWFwX3BlZXIvZWFwX3dzYy5jCisrKyBiL3NyYy9lYXBfcGVlci9lYXBfd3NjLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogRUFQLVdTQyBwZWVyIGZvciBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAKLSAqIENvcHlyaWdodCAoYykgMjAwNy0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA3LTIwMDksIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTEzNyw2ICsxMzcsOCBAQAogCXN0cnVjdCB3cHNfY29udGV4dCAqd3BzOwogCXN0cnVjdCB3cHNfY3JlZGVudGlhbCBuZXdfYXBfc2V0dGluZ3M7CiAJaW50IHJlczsKKwl1OCBkZXZfcHdbV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOXTsKKwlpbnQgbmZjID0gMDsKIAogCXdwcyA9IHNtLT53cHM7CiAJaWYgKHdwcyA9PSBOVUxMKSB7CkBAIC0xODQsMTMgKzE4NiwyNiBAQAogCQl3aGlsZSAoKnBvcyAhPSAnXDAnICYmICpwb3MgIT0gJyAnKQogCQkJcG9zKys7CiAJCWNmZy5waW5fbGVuID0gcG9zIC0gKGNvbnN0IGNoYXIgKikgY2ZnLnBpbjsKKwkJaWYgKGNmZy5waW5fbGVuID49IFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX01JTl9MRU4gKiAyICYmCisJCSAgICBjZmcucGluX2xlbiA8PSBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4gKiAyICYmCisJCSAgICBoZXhzdHIyYmluKChjb25zdCBjaGFyICopIGNmZy5waW4sIGRldl9wdywKKwkJCSAgICAgICBjZmcucGluX2xlbiAvIDIpID09IDApIHsKKwkJCS8qIENvbnZlcnQgT09CIERldmljZSBQYXNzd29yZCB0byBiaW5hcnkgKi8KKwkJCWNmZy5waW4gPSBkZXZfcHc7CisJCQljZmcucGluX2xlbiAvPSAyOworCQl9CisJCWlmIChjZmcucGluX2xlbiA9PSA2ICYmIG9zX3N0cm5jbXAocG9zLCAibmZjLXB3IiwgNikgPT0gMCkgeworCQkJY2ZnLnBpbiA9IE5VTEw7CisJCQljZmcucGluX2xlbiA9IDA7CisJCQluZmMgPSAxOworCQl9CiAJfSBlbHNlIHsKIAkJcG9zID0gb3Nfc3Ryc3RyKHBoYXNlMSwgInBiYz0xIik7CiAJCWlmIChwb3MpCiAJCQljZmcucGJjID0gMTsKIAl9CiAKLQlpZiAoY2ZnLnBpbiA9PSBOVUxMICYmICFjZmcucGJjKSB7CisJaWYgKGNmZy5waW4gPT0gTlVMTCAmJiAhY2ZnLnBiYyAmJiAhbmZjKSB7CiAJCXdwYV9wcmludGYoTVNHX0lORk8sICJFQVAtV1NDOiBQSU4gb3IgUEJDIG5vdCBzZXQgaW4gcGhhc2UxICIKIAkJCSAgICJjb25maWd1cmF0aW9uIGRhdGEiKTsKIAkJb3NfZnJlZShkYXRhKTsKZGlmZiAtLWdpdCBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfYWthLmMgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX2FrYS5jCmluZGV4IDEzNWMwMmIuLjljZDU1MDkgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfYWthLmMKKysrIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9ha2EuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCi0gKiBob3N0YXBkIC8gRUFQLUFLQSAoUkZDIDQxODcpIGFuZCBFQVAtQUtBJyAoZHJhZnQtYXJra28tZWFwLWFrYS1rZGYpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIGhvc3RhcGQgLyBFQVAtQUtBIChSRkMgNDE4NykgYW5kIEVBUC1BS0EnIChSRkMgNTQ0OCkKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yNjYsOCArMjY2LDE4IEBACiAJCQkgICAgICAgRUFQX0FLQV9TVUJUWVBFX0lERU5USVRZKTsKIAlpZiAoZWFwX3NpbV9kYl9pZGVudGl0eV9rbm93bihzbS0+ZWFwX3NpbV9kYl9wcml2LCBzbS0+aWRlbnRpdHksCiAJCQkJICAgICAgc20tPmlkZW50aXR5X2xlbikpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9QRVJNQU5FTlRfSURfUkVRIik7Ci0JCWVhcF9zaW1fbXNnX2FkZChtc2csIEVBUF9TSU1fQVRfUEVSTUFORU5UX0lEX1JFUSwgMCwgTlVMTCwgMCk7CisJCWlmIChzbS0+aWRlbnRpdHlfbGVuID4gMCAmJgorCQkgICAgKHNtLT5pZGVudGl0eVswXSA9PSBFQVBfQUtBX1JFQVVUSF9JRF9QUkVGSVggfHwKKwkJICAgICBzbS0+aWRlbnRpdHlbMF0gPT0gRUFQX0FLQV9QUklNRV9SRUFVVEhfSURfUFJFRklYKSkgeworCQkJLyogUmVhdXRoIGlkIG1heSBoYXZlIGV4cGlyZWQgLSB0cnkgZnVsbGF1dGggKi8KKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAgQVRfRlVMTEFVVEhfSURfUkVRIik7CisJCQllYXBfc2ltX21zZ19hZGQobXNnLCBFQVBfU0lNX0FUX0ZVTExBVVRIX0lEX1JFUSwgMCwKKwkJCQkJTlVMTCwgMCk7CisJCX0gZWxzZSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX1BFUk1BTkVOVF9JRF9SRVEiKTsKKwkJCWVhcF9zaW1fbXNnX2FkZChtc2csIEVBUF9TSU1fQVRfUEVSTUFORU5UX0lEX1JFUSwgMCwKKwkJCQkJTlVMTCwgMCk7CisJCX0KIAl9IGVsc2UgewogCQkvKgogCQkgKiBSRkMgNDE4NywgQ2hhcC4gNC4xLjQgcmVjb21tZW5kcyB0aGF0IGlkZW50aXR5IGZyb20gRUFQIGlzCkBAIC0yOTIsMTIgKzMwMiwyMyBAQAogCQkJICAgICAgY29uc3QgdTggKm5vbmNlX3MpCiB7CiAJb3NfZnJlZShkYXRhLT5uZXh0X3BzZXVkb255bSk7Ci0JZGF0YS0+bmV4dF9wc2V1ZG9ueW0gPQotCQllYXBfc2ltX2RiX2dldF9uZXh0X3BzZXVkb255bShzbS0+ZWFwX3NpbV9kYl9wcml2LCAxKTsKKwlpZiAobm9uY2VfcyA9PSBOVUxMKSB7CisJCWRhdGEtPm5leHRfcHNldWRvbnltID0KKwkJCWVhcF9zaW1fZGJfZ2V0X25leHRfcHNldWRvbnltKAorCQkJCXNtLT5lYXBfc2ltX2RiX3ByaXYsCisJCQkJZGF0YS0+ZWFwX21ldGhvZCA9PSBFQVBfVFlQRV9BS0FfUFJJTUUgPworCQkJCUVBUF9TSU1fREJfQUtBX1BSSU1FIDogRUFQX1NJTV9EQl9BS0EpOworCX0gZWxzZSB7CisJCS8qIERvIG5vdCB1cGRhdGUgcHNldWRvbnltIGR1cmluZyByZS1hdXRoZW50aWNhdGlvbiAqLworCQlkYXRhLT5uZXh0X3BzZXVkb255bSA9IE5VTEw7CisJfQogCW9zX2ZyZWUoZGF0YS0+bmV4dF9yZWF1dGhfaWQpOwogCWlmIChkYXRhLT5jb3VudGVyIDw9IEVBUF9BS0FfTUFYX0ZBU1RfUkVBVVRIUykgewogCQlkYXRhLT5uZXh0X3JlYXV0aF9pZCA9Ci0JCQllYXBfc2ltX2RiX2dldF9uZXh0X3JlYXV0aF9pZChzbS0+ZWFwX3NpbV9kYl9wcml2LCAxKTsKKwkJCWVhcF9zaW1fZGJfZ2V0X25leHRfcmVhdXRoX2lkKAorCQkJCXNtLT5lYXBfc2ltX2RiX3ByaXYsCisJCQkJZGF0YS0+ZWFwX21ldGhvZCA9PSBFQVBfVFlQRV9BS0FfUFJJTUUgPworCQkJCUVBUF9TSU1fREJfQUtBX1BSSU1FIDogRUFQX1NJTV9EQl9BS0EpOwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLUFLQTogTWF4IGZhc3QgcmUtYXV0aGVudGljYXRpb24gIgogCQkJICAgImNvdW50IGV4Y2VlZGVkIC0gZm9yY2UgZnVsbCBhdXRoZW50aWNhdGlvbiIpOwpAQCAtNjE1LDcgKzYzNiw4IEBACiAJCWlkZW50aXR5ID0gZGF0YS0+cmVhdXRoLT5pZGVudGl0eTsKIAkJaWRlbnRpdHlfbGVuID0gZGF0YS0+cmVhdXRoLT5pZGVudGl0eV9sZW47CiAJfSBlbHNlIGlmIChzbS0+aWRlbnRpdHkgJiYgc20tPmlkZW50aXR5X2xlbiA+IDAgJiYKLQkJICAgc20tPmlkZW50aXR5WzBdID09IEVBUF9BS0FfUEVSTUFORU5UX1BSRUZJWCkgeworCQkgICAoc20tPmlkZW50aXR5WzBdID09IEVBUF9BS0FfUEVSTUFORU5UX1BSRUZJWCB8fAorCQkgICAgc20tPmlkZW50aXR5WzBdID09IEVBUF9BS0FfUFJJTUVfUEVSTUFORU5UX1BSRUZJWCkpIHsKIAkJaWRlbnRpdHkgPSBzbS0+aWRlbnRpdHk7CiAJCWlkZW50aXR5X2xlbiA9IHNtLT5pZGVudGl0eV9sZW47CiAJfSBlbHNlIHsKQEAgLTczMSw3ICs3NTMsNyBAQAogCQkJICBzbS0+aWRlbnRpdHksIGlkZW50aXR5X2xlbik7CiAKIAlpZiAoZGF0YS0+ZWFwX21ldGhvZCA9PSBFQVBfVFlQRV9BS0FfUFJJTUUpIHsKLQkJZWFwX2FrYV9wcmltZV9kZXJpdmVfa2V5cyhpZGVudGl0eSwgaWRlbnRpdHlfbGVuLCBkYXRhLT5paywKKwkJZWFwX2FrYV9wcmltZV9kZXJpdmVfa2V5cyhzbS0+aWRlbnRpdHksIGlkZW50aXR5X2xlbiwgZGF0YS0+aWssCiAJCQkJCSAgZGF0YS0+Y2ssIGRhdGEtPmtfZW5jciwgZGF0YS0+a19hdXQsCiAJCQkJCSAgZGF0YS0+a19yZSwgZGF0YS0+bXNrLCBkYXRhLT5lbXNrKTsKIAl9IGVsc2UgewpAQCAtMTAxNywxMSArMTAzOSw2IEBACiAJCWlkZW50aXR5X2xlbiA9IGlkMl9sZW47CiAJfQogCi0JaWYgKGRhdGEtPm5leHRfcHNldWRvbnltKSB7Ci0JCWVhcF9zaW1fZGJfYWRkX3BzZXVkb255bShzbS0+ZWFwX3NpbV9kYl9wcml2LCBpZGVudGl0eSwKLQkJCQkJIGlkZW50aXR5X2xlbiwgZGF0YS0+bmV4dF9wc2V1ZG9ueW0pOwotCQlkYXRhLT5uZXh0X3BzZXVkb255bSA9IE5VTEw7Ci0JfQogCWlmIChkYXRhLT5uZXh0X3JlYXV0aF9pZCkgewogCQlpZiAoZGF0YS0+ZWFwX21ldGhvZCA9PSBFQVBfVFlQRV9BS0FfUFJJTUUpIHsKICNpZmRlZiBFQVBfU0VSVkVSX0FLQV9QUklNRQpkaWZmIC0tZ2l0IGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wd2QuYyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfcHdkLmMKaW5kZXggNmM0N2RlZS4uYjYxMDYxYiAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9wd2QuYworKysgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3B3ZC5jCkBAIC05LDYgKzksNyBAQAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCiAKICNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJjcnlwdG8vc2hhMjU2LmgiCiAjaW5jbHVkZSAiZWFwX3NlcnZlci9lYXBfaS5oIgogI2luY2x1ZGUgImVhcF9jb21tb24vZWFwX3B3ZF9jb21tb24uaCIKIApAQCAtNDAsNyArNDEsNyBAQAogCUVDX1BPSU5UICpteV9lbGVtZW50OwogCUVDX1BPSU5UICpwZWVyX2VsZW1lbnQ7CiAKLQl1OCBteV9jb25maXJtW1NIQTI1Nl9ESUdFU1RfTEVOR1RIXTsKKwl1OCBteV9jb25maXJtW1NIQTI1Nl9NQUNfTEVOXTsKIAogCXU4IG1za1tFQVBfTVNLX0xFTl07CiAJdTggZW1za1tFQVBfRU1TS19MRU5dOwpAQCAtMjg4LDggKzI4OSw4IEBACiAJCQkJICAgICAgc3RydWN0IGVhcF9wd2RfZGF0YSAqZGF0YSwgdTggaWQpCiB7CiAJQklHTlVNICp4ID0gTlVMTCwgKnkgPSBOVUxMOwotCUhNQUNfQ1RYIGN0eDsKLQl1OCBjb25mW1NIQTI1Nl9ESUdFU1RfTEVOR1RIXSwgKmNydWZ0ID0gTlVMTCwgKnB0cjsKKwlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmhhc2g7CisJdTggY29uZltTSEEyNTZfTUFDX0xFTl0sICpjcnVmdCA9IE5VTEwsICpwdHI7CiAJdTE2IGdycDsKIAlpbnQgb2Zmc2V0OwogCkBAIC0zMTMsNyArMzE0LDkgQEAKIAkgKiBjb21taXQgaXMgSChrIHwgc2VydmVyX2VsZW1lbnQgfCBzZXJ2ZXJfc2NhbGFyIHwgcGVlcl9lbGVtZW50IHwKIAkgKgkgICAgICAgcGVlcl9zY2FsYXIgfCBjaXBoZXJzdWl0ZSkKIAkgKi8KLQlIX0luaXQoJmN0eCk7CisJaGFzaCA9IGVhcF9wd2RfaF9pbml0KCk7CisJaWYgKGhhc2ggPT0gTlVMTCkKKwkJZ290byBmaW47CiAKIAkvKgogCSAqIFplcm8gdGhlIG1lbW9yeSBlYWNoIHRpbWUgYmVjYXVzZSB0aGlzIGlzIG1vZCBwcmltZSBtYXRoIGFuZCBzb21lCkBAIC0zMjQsNyArMzI3LDcgQEAKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKGRhdGEtPmspOwogCUJOX2JuMmJpbihkYXRhLT5rLCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAogCS8qIHNlcnZlciBlbGVtZW50OiB4LCB5ICovCiAJaWYgKCFFQ19QT0lOVF9nZXRfYWZmaW5lX2Nvb3JkaW5hdGVzX0dGcChkYXRhLT5ncnAtPmdyb3VwLApAQCAtMzM4LDE4ICszNDEsMTggQEAKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHgpOwogCUJOX2JuMmJpbih4LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHkpOwogCUJOX2JuMmJpbih5LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAogCS8qIHNlcnZlciBzY2FsYXIgKi8KIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpIC0KIAkJQk5fbnVtX2J5dGVzKGRhdGEtPm15X3NjYWxhcik7CiAJQk5fYm4yYmluKGRhdGEtPm15X3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CiAKIAkvKiBwZWVyIGVsZW1lbnQ6IHgsIHkgKi8KIAlpZiAoIUVDX1BPSU5UX2dldF9hZmZpbmVfY29vcmRpbmF0ZXNfR0ZwKGRhdGEtPmdycC0+Z3JvdXAsCkBAIC0zNjMsMTggKzM2NiwxOCBAQAogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvZmZzZXQgPSBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkgLSBCTl9udW1fYnl0ZXMoeCk7CiAJQk5fYm4yYmluKHgsIGNydWZ0ICsgb2Zmc2V0KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvZmZzZXQgPSBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkgLSBCTl9udW1fYnl0ZXMoeSk7CiAJQk5fYm4yYmluKHksIGNydWZ0ICsgb2Zmc2V0KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCiAJLyogcGVlciBzY2FsYXIgKi8KIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpIC0KIAkJQk5fbnVtX2J5dGVzKGRhdGEtPnBlZXJfc2NhbGFyKTsKIAlCTl9ibjJiaW4oZGF0YS0+cGVlcl9zY2FsYXIsIGNydWZ0ICsgb2Zmc2V0KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikpOwogCiAJLyogY2lwaGVyc3VpdGUgKi8KIAlncnAgPSBodG9ucyhkYXRhLT5ncm91cF9udW0pOwpAQCAtMzg2LDE3ICszODksMTcgQEAKIAlwdHIgKz0gc2l6ZW9mKHU4KTsKIAkqcHRyID0gRUFQX1BXRF9ERUZBVUxUX1BSRjsKIAlwdHIgKz0gc2l6ZW9mKHU4KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgcHRyLWNydWZ0KTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNydWZ0LCBwdHIgLSBjcnVmdCk7CiAKIAkvKiBhbGwgZG9uZSB3aXRoIHRoZSByYW5kb20gZnVuY3Rpb24gKi8KLQlIX0ZpbmFsKCZjdHgsIGNvbmYpOwotCW9zX21lbWNweShkYXRhLT5teV9jb25maXJtLCBjb25mLCBTSEEyNTZfRElHRVNUX0xFTkdUSCk7CisJZWFwX3B3ZF9oX2ZpbmFsKGhhc2gsIGNvbmYpOworCW9zX21lbWNweShkYXRhLT5teV9jb25maXJtLCBjb25mLCBTSEEyNTZfTUFDX0xFTik7CiAKLQlkYXRhLT5vdXRidWYgPSB3cGFidWZfYWxsb2MoU0hBMjU2X0RJR0VTVF9MRU5HVEgpOworCWRhdGEtPm91dGJ1ZiA9IHdwYWJ1Zl9hbGxvYyhTSEEyNTZfTUFDX0xFTik7CiAJaWYgKGRhdGEtPm91dGJ1ZiA9PSBOVUxMKQogCQlnb3RvIGZpbjsKIAotCXdwYWJ1Zl9wdXRfZGF0YShkYXRhLT5vdXRidWYsIGNvbmYsIFNIQTI1Nl9ESUdFU1RfTEVOR1RIKTsKKwl3cGFidWZfcHV0X2RhdGEoZGF0YS0+b3V0YnVmLCBjb25mLCBTSEEyNTZfTUFDX0xFTik7CiAKIGZpbjoKIAlvc19mcmVlKGNydWZ0KTsKQEAgLTQwNCw4ICs0MDcsNiBAQAogCUJOX2ZyZWUoeSk7CiAJaWYgKGRhdGEtPm91dGJ1ZiA9PSBOVUxMKQogCQllYXBfcHdkX3N0YXRlKGRhdGEsIEZBSUxVUkUpOwotCi0JcmV0dXJuOwogfQogCiAKQEAgLTczNSwxMCArNzM2LDEwIEBACiAJCQkgICAgIGNvbnN0IHU4ICpwYXlsb2FkLCBzaXplX3QgcGF5bG9hZF9sZW4pCiB7CiAJQklHTlVNICp4ID0gTlVMTCwgKnkgPSBOVUxMOwotCUhNQUNfQ1RYIGN0eDsKKwlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmhhc2g7CiAJdTMyIGNzOwogCXUxNiBncnA7Ci0JdTggY29uZltTSEEyNTZfRElHRVNUX0xFTkdUSF0sICpjcnVmdCA9IE5VTEwsICpwdHI7CisJdTggY29uZltTSEEyNTZfTUFDX0xFTl0sICpjcnVmdCA9IE5VTEwsICpwdHI7CiAJaW50IG9mZnNldDsKIAogCS8qIGJ1aWxkIHVwIHRoZSBjaXBoZXJzdWl0ZTogZ3JvdXAgfCByYW5kb21fZnVuY3Rpb24gfCBwcmYgKi8KQEAgLTc2MSwxMyArNzYyLDE1IEBACiAJICogY29tbWl0IGlzIEgoayB8IHBlZXJfZWxlbWVudCB8IHBlZXJfc2NhbGFyIHwgc2VydmVyX2VsZW1lbnQgfAogCSAqCSAgICAgICBzZXJ2ZXJfc2NhbGFyIHwgY2lwaGVyc3VpdGUpCiAJICovCi0JSF9Jbml0KCZjdHgpOworCWhhc2ggPSBlYXBfcHdkX2hfaW5pdCgpOworCWlmIChoYXNoID09IE5VTEwpCisJCWdvdG8gZmluOwogCiAJLyogayAqLwogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvZmZzZXQgPSBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkgLSBCTl9udW1fYnl0ZXMoZGF0YS0+ayk7CiAJQk5fYm4yYmluKGRhdGEtPmssIGNydWZ0ICsgb2Zmc2V0KTsKLQlIX1VwZGF0ZSgmY3R4LCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCiAJLyogcGVlciBlbGVtZW50OiB4LCB5ICovCiAJaWYgKCFFQ19QT0lOVF9nZXRfYWZmaW5lX2Nvb3JkaW5hdGVzX0dGcChkYXRhLT5ncnAtPmdyb3VwLApAQCAtNzgwLDE4ICs3ODMsMTggQEAKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHgpOwogCUJOX2JuMmJpbih4LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHkpOwogCUJOX2JuMmJpbih5LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAogCS8qIHBlZXIgc2NhbGFyICovCiAJb3NfbWVtc2V0KGNydWZ0LCAwLCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5wcmltZSkpOwogCW9mZnNldCA9IEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSAtCiAJCUJOX251bV9ieXRlcyhkYXRhLT5wZWVyX3NjYWxhcik7CiAJQk5fYm4yYmluKGRhdGEtPnBlZXJfc2NhbGFyLCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpKTsKIAogCS8qIHNlcnZlciBlbGVtZW50OiB4LCB5ICovCiAJaWYgKCFFQ19QT0lOVF9nZXRfYWZmaW5lX2Nvb3JkaW5hdGVzX0dGcChkYXRhLT5ncnAtPmdyb3VwLApAQCAtODA1LDI4ICs4MDgsMjggQEAKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHgpOwogCUJOX2JuMmJpbih4LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpIC0gQk5fbnVtX2J5dGVzKHkpOwogCUJOX2JuMmJpbih5LCBjcnVmdCArIG9mZnNldCk7Ci0JSF9VcGRhdGUoJmN0eCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CisJZWFwX3B3ZF9oX3VwZGF0ZShoYXNoLCBjcnVmdCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKIAogCS8qIHNlcnZlciBzY2FsYXIgKi8KIAlvc19tZW1zZXQoY3J1ZnQsIDAsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPnByaW1lKSk7CiAJb2Zmc2V0ID0gQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+b3JkZXIpIC0KIAkJQk5fbnVtX2J5dGVzKGRhdGEtPm15X3NjYWxhcik7CiAJQk5fYm4yYmluKGRhdGEtPm15X3NjYWxhciwgY3J1ZnQgKyBvZmZzZXQpOwotCUhfVXBkYXRlKCZjdHgsIGNydWZ0LCBCTl9udW1fYnl0ZXMoZGF0YS0+Z3JwLT5vcmRlcikpOworCWVhcF9wd2RfaF91cGRhdGUoaGFzaCwgY3J1ZnQsIEJOX251bV9ieXRlcyhkYXRhLT5ncnAtPm9yZGVyKSk7CiAKIAkvKiBjaXBoZXJzdWl0ZSAqLwogCW9zX21lbXNldChjcnVmdCwgMCwgQk5fbnVtX2J5dGVzKGRhdGEtPmdycC0+cHJpbWUpKTsKLQlIX1VwZGF0ZSgmY3R4LCAodTggKikmY3MsIHNpemVvZih1MzIpKTsKKwllYXBfcHdkX2hfdXBkYXRlKGhhc2gsICh1OCAqKSAmY3MsIHNpemVvZih1MzIpKTsKIAogCS8qIGFsbCBkb25lICovCi0JSF9GaW5hbCgmY3R4LCBjb25mKTsKKwllYXBfcHdkX2hfZmluYWwoaGFzaCwgY29uZik7CiAKIAlwdHIgPSAodTggKikgcGF5bG9hZDsKLQlpZiAob3NfbWVtY21wKGNvbmYsIHB0ciwgU0hBMjU2X0RJR0VTVF9MRU5HVEgpKSB7CisJaWYgKG9zX21lbWNtcChjb25mLCBwdHIsIFNIQTI1Nl9NQUNfTEVOKSkgewogCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiRUFQLVBXRCAoc2VydmVyKTogY29uZmlybSBkaWQgbm90ICIKIAkJCSAgICJ2ZXJpZnkiKTsKIAkJZ290byBmaW47CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3NpbS5jIGIvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NlcnZlcl9zaW0uYwppbmRleCBmNDlmNzBlLi42NjU4ZDljIDEwMDY0NAotLS0gYS9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3NpbS5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zZXJ2ZXJfc2ltLmMKQEAgLTEwNyw4ICsxMDcsMTcgQEAKIAkJCSAgICAgICBFQVBfU0lNX1NVQlRZUEVfU1RBUlQpOwogCWlmIChlYXBfc2ltX2RiX2lkZW50aXR5X2tub3duKHNtLT5lYXBfc2ltX2RiX3ByaXYsIHNtLT5pZGVudGl0eSwKIAkJCQkgICAgICBzbS0+aWRlbnRpdHlfbGVuKSkgewotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIiAgIEFUX1BFUk1BTkVOVF9JRF9SRVEiKTsKLQkJZWFwX3NpbV9tc2dfYWRkKG1zZywgRUFQX1NJTV9BVF9QRVJNQU5FTlRfSURfUkVRLCAwLCBOVUxMLCAwKTsKKwkJaWYgKHNtLT5pZGVudGl0eV9sZW4gPiAwICYmCisJCSAgICBzbS0+aWRlbnRpdHlbMF0gPT0gRUFQX1NJTV9SRUFVVEhfSURfUFJFRklYKSB7CisJCQkvKiBSZWF1dGggaWQgbWF5IGhhdmUgZXhwaXJlZCAtIHRyeSBmdWxsYXV0aCAqLworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICIgICBBVF9GVUxMQVVUSF9JRF9SRVEiKTsKKwkJCWVhcF9zaW1fbXNnX2FkZChtc2csIEVBUF9TSU1fQVRfRlVMTEFVVEhfSURfUkVRLCAwLAorCQkJCQlOVUxMLCAwKTsKKwkJfSBlbHNlIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiICAgQVRfUEVSTUFORU5UX0lEX1JFUSIpOworCQkJZWFwX3NpbV9tc2dfYWRkKG1zZywgRUFQX1NJTV9BVF9QRVJNQU5FTlRfSURfUkVRLCAwLAorCQkJCQlOVUxMLCAwKTsKKwkJfQogCX0gZWxzZSB7CiAJCS8qCiAJCSAqIFJGQyA0MTg2LCBDaGFwLiA0LjIuNCByZWNvbW1lbmRzIHRoYXQgaWRlbnRpdHkgZnJvbSBFQVAgaXMKQEAgLTEzMSwxMiArMTQwLDE5IEBACiAJCQkgICAgICBjb25zdCB1OCAqbm9uY2VfcykKIHsKIAlvc19mcmVlKGRhdGEtPm5leHRfcHNldWRvbnltKTsKLQlkYXRhLT5uZXh0X3BzZXVkb255bSA9Ci0JCWVhcF9zaW1fZGJfZ2V0X25leHRfcHNldWRvbnltKHNtLT5lYXBfc2ltX2RiX3ByaXYsIDApOworCWlmIChub25jZV9zID09IE5VTEwpIHsKKwkJZGF0YS0+bmV4dF9wc2V1ZG9ueW0gPQorCQkJZWFwX3NpbV9kYl9nZXRfbmV4dF9wc2V1ZG9ueW0oc20tPmVhcF9zaW1fZGJfcHJpdiwKKwkJCQkJCSAgICAgIEVBUF9TSU1fREJfU0lNKTsKKwl9IGVsc2UgeworCQkvKiBEbyBub3QgdXBkYXRlIHBzZXVkb255bSBkdXJpbmcgcmUtYXV0aGVudGljYXRpb24gKi8KKwkJZGF0YS0+bmV4dF9wc2V1ZG9ueW0gPSBOVUxMOworCX0KIAlvc19mcmVlKGRhdGEtPm5leHRfcmVhdXRoX2lkKTsKIAlpZiAoZGF0YS0+Y291bnRlciA8PSBFQVBfU0lNX01BWF9GQVNUX1JFQVVUSFMpIHsKIAkJZGF0YS0+bmV4dF9yZWF1dGhfaWQgPQotCQkJZWFwX3NpbV9kYl9nZXRfbmV4dF9yZWF1dGhfaWQoc20tPmVhcF9zaW1fZGJfcHJpdiwgMCk7CisJCQllYXBfc2ltX2RiX2dldF9uZXh0X3JlYXV0aF9pZChzbS0+ZWFwX3NpbV9kYl9wcml2LAorCQkJCQkJICAgICAgRUFQX1NJTV9EQl9TSU0pOwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiRUFQLVNJTTogTWF4IGZhc3QgcmUtYXV0aGVudGljYXRpb24gIgogCQkJICAgImNvdW50IGV4Y2VlZGVkIC0gZm9yY2UgZnVsbCBhdXRoZW50aWNhdGlvbiIpOwpAQCAtNjE2LDExICs2MzIsNiBAQAogCQlpZGVudGl0eV9sZW4gPSBpZDJfbGVuOwogCX0KIAotCWlmIChkYXRhLT5uZXh0X3BzZXVkb255bSkgewotCQllYXBfc2ltX2RiX2FkZF9wc2V1ZG9ueW0oc20tPmVhcF9zaW1fZGJfcHJpdiwgaWRlbnRpdHksCi0JCQkJCSBpZGVudGl0eV9sZW4sIGRhdGEtPm5leHRfcHNldWRvbnltKTsKLQkJZGF0YS0+bmV4dF9wc2V1ZG9ueW0gPSBOVUxMOwotCX0KIAlpZiAoZGF0YS0+bmV4dF9yZWF1dGhfaWQpIHsKIAkJZWFwX3NpbV9kYl9hZGRfcmVhdXRoKHNtLT5lYXBfc2ltX2RiX3ByaXYsIGlkZW50aXR5LAogCQkJCSAgICAgIGlkZW50aXR5X2xlbiwgZGF0YS0+bmV4dF9yZWF1dGhfaWQsCmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2ltX2RiLmMgYi9zcmMvZWFwX3NlcnZlci9lYXBfc2ltX2RiLmMKaW5kZXggOWRiMjZkYy4uY2UzMjM4YyAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NpbV9kYi5jCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zaW1fZGIuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC8gRUFQLVNJTSBkYXRhYmFzZS9hdXRoZW50aWNhdG9yIGdhdGV3YXkKLSAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA3LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMTAsIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTY0Nyw3ICs2NDcsOCBAQAogCiAJaWYgKGlkZW50aXR5X2xlbiA9PSAwIHx8CiAJICAgIChpZGVudGl0eVswXSAhPSBFQVBfU0lNX1BTRVVET05ZTV9QUkVGSVggJiYKLQkgICAgIGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUFNFVURPTllNX1BSRUZJWCkpCisJICAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1BTRVVET05ZTV9QUkVGSVggJiYKKwkgICAgIGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUFJJTUVfUFNFVURPTllNX1BSRUZJWCkpCiAJCXJldHVybiBOVUxMOwogCiAJLyogUmVtb3ZlIHBvc3NpYmxlIHJlYWxtIGZyb20gaWRlbnRpdHkgKi8KQEAgLTY4NSw3ICs2ODYsOCBAQAogCiAJaWYgKGlkZW50aXR5X2xlbiA9PSAwIHx8CiAJICAgIChpZGVudGl0eVswXSAhPSBFQVBfU0lNX1BFUk1BTkVOVF9QUkVGSVggJiYKLQkgICAgIGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUEVSTUFORU5UX1BSRUZJWCkpCisJICAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1BFUk1BTkVOVF9QUkVGSVggJiYKKwkgICAgIGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUFJJTUVfUEVSTUFORU5UX1BSRUZJWCkpCiAJCXJldHVybiBOVUxMOwogCiAJcCA9IGRhdGEtPnBzZXVkb255bXM7CkBAIC03MTAsNyArNzEyLDggQEAKIAogCWlmIChpZGVudGl0eV9sZW4gPT0gMCB8fAogCSAgICAoaWRlbnRpdHlbMF0gIT0gRUFQX1NJTV9SRUFVVEhfSURfUFJFRklYICYmCi0JICAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1JFQVVUSF9JRF9QUkVGSVgpKQorCSAgICAgaWRlbnRpdHlbMF0gIT0gRUFQX0FLQV9SRUFVVEhfSURfUFJFRklYICYmCisJICAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1BSSU1FX1JFQVVUSF9JRF9QUkVGSVgpKQogCQlyZXR1cm4gTlVMTDsKIAogCS8qIFJlbW92ZSBwb3NzaWJsZSByZWFsbSBmcm9tIGlkZW50aXR5ICovCkBAIC03NzcsOCArNzgwLDkgQEAKICAqIEBpZGVudGl0eV9sZW46IExlbmd0aCBvZiBpZGVudGl0eSBpbiBieXRlcyAKICAqIFJldHVybnM6IDAgaWYgdGhlIHVzZXIgaXMgZm91bmQgb3IgLTEgb24gZmFpbHVyZQogICoKLSAqIEluIG1vc3QgY2FzZXMsIHRoZSB1c2VyIG5hbWUgaXMgWycwJywnMSddIHwgSU1TSSwgaS5lLiwgMSBmb2xsb3dlZCBieSB0aGUKLSAqIElNU0kgaW4gQVNDSUkgZm9ybWF0LCBbJzInLCczJ10gfCBwc2V1ZG9ueW0sIG9yIFsnNCcsJzUnXSB8IHJlYXV0aF9pZC4KKyAqIEluIG1vc3QgY2FzZXMsIHRoZSB1c2VyIG5hbWUgaXMgWycwJywnMScsJzYnXSB8IElNU0ksIGkuZS4sIDEgZm9sbG93ZWQgYnkKKyAqIHRoZSBJTVNJIGluIEFTQ0lJIGZvcm1hdCBmb3IgRUFQLVNJTSwgWycyJywnMycsJzcnXSB8IHBzZXVkb255bSwgb3IKKyAqIFsnNCcsJzUnLCc3J10gfCByZWF1dGhfaWQuCiAgKi8KIGludCBlYXBfc2ltX2RiX2lkZW50aXR5X2tub3duKHZvaWQgKnByaXYsIGNvbnN0IHU4ICppZGVudGl0eSwKIAkJCSAgICAgIHNpemVfdCBpZGVudGl0eV9sZW4pCkBAIC03ODksMjEgKzc5MywyNCBAQAogCQlyZXR1cm4gLTE7CiAKIAlpZiAoaWRlbnRpdHlbMF0gPT0gRUFQX1NJTV9QU0VVRE9OWU1fUFJFRklYIHx8Ci0JICAgIGlkZW50aXR5WzBdID09IEVBUF9BS0FfUFNFVURPTllNX1BSRUZJWCkgeworCSAgICBpZGVudGl0eVswXSA9PSBFQVBfQUtBX1BTRVVET05ZTV9QUkVGSVggfHwKKwkgICAgaWRlbnRpdHlbMF0gPT0gRUFQX0FLQV9QUklNRV9QU0VVRE9OWU1fUFJFRklYKSB7CiAJCXN0cnVjdCBlYXBfc2ltX3BzZXVkb255bSAqcCA9CiAJCQllYXBfc2ltX2RiX2dldF9wc2V1ZG9ueW0oZGF0YSwgaWRlbnRpdHksIGlkZW50aXR5X2xlbik7CiAJCXJldHVybiBwID8gMCA6IC0xOwogCX0KIAogCWlmIChpZGVudGl0eVswXSA9PSBFQVBfU0lNX1JFQVVUSF9JRF9QUkVGSVggfHwKLQkgICAgaWRlbnRpdHlbMF0gPT0gRUFQX0FLQV9SRUFVVEhfSURfUFJFRklYKSB7CisJICAgIGlkZW50aXR5WzBdID09IEVBUF9BS0FfUkVBVVRIX0lEX1BSRUZJWCB8fAorCSAgICBpZGVudGl0eVswXSA9PSBFQVBfQUtBX1BSSU1FX1JFQVVUSF9JRF9QUkVGSVgpIHsKIAkJc3RydWN0IGVhcF9zaW1fcmVhdXRoICpyID0KIAkJCWVhcF9zaW1fZGJfZ2V0X3JlYXV0aChkYXRhLCBpZGVudGl0eSwgaWRlbnRpdHlfbGVuKTsKIAkJcmV0dXJuIHIgPyAwIDogLTE7CiAJfQogCiAJaWYgKGlkZW50aXR5WzBdICE9IEVBUF9TSU1fUEVSTUFORU5UX1BSRUZJWCAmJgotCSAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1BFUk1BTkVOVF9QUkVGSVgpIHsKKwkgICAgaWRlbnRpdHlbMF0gIT0gRUFQX0FLQV9QRVJNQU5FTlRfUFJFRklYICYmCisJICAgIGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUFJJTUVfUEVSTUFORU5UX1BSRUZJWCkgewogCQkvKiBVbmtub3duIGlkZW50aXR5IHByZWZpeCAqLwogCQlyZXR1cm4gLTE7CiAJfQpAQCAtODQzLDcgKzg1MCw3IEBACiAvKioKICAqIGVhcF9zaW1fZGJfZ2V0X25leHRfcHNldWRvbnltIC0gRUFQLVNJTSBEQjogR2V0IG5leHQgcHNldWRvbnltCiAgKiBAcHJpdjogUHJpdmF0ZSBkYXRhIHBvaW50ZXIgZnJvbSBlYXBfc2ltX2RiX2luaXQoKQotICogQGFrYTogVXNpbmcgRUFQLUFLQSBpbnN0ZWFkIG9mIEVBUC1TSU0KKyAqIEBtZXRob2Q6IEVBUCBtZXRob2QgKFNJTS9BS0EvQUtBJykKICAqIFJldHVybnM6IE5leHQgcHNldWRvbnltIChhbGxvY2F0ZWQgc3RyaW5nKSBvciAlTlVMTCBvbiBmYWlsdXJlCiAgKgogICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRvIGdlbmVyYXRlIGEgcHNldWRvbnltIGZvciBFQVAtU0lNLiBUaGUgcmV0dXJuZWQKQEAgLTg1MSwxOCArODU4LDMxIEBACiAgKiB3aXRoIGVhcF9zaW1fZGJfYWRkX3BzZXVkb255bSgpIG9uY2UgdGhlIGF1dGhlbnRpY2F0aW9uIGhhcyBiZWVuIGNvbXBsZXRlZAogICogc3VjY2Vzc2Z1bGx5LiBDYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yIGZyZWVpbmcgdGhlIHJldHVybmVkIGJ1ZmZlci4KICAqLwotY2hhciAqIGVhcF9zaW1fZGJfZ2V0X25leHRfcHNldWRvbnltKHZvaWQgKnByaXYsIGludCBha2EpCitjaGFyICogZWFwX3NpbV9kYl9nZXRfbmV4dF9wc2V1ZG9ueW0odm9pZCAqcHJpdiwgZW51bSBlYXBfc2ltX2RiX21ldGhvZCBtZXRob2QpCiB7CiAJc3RydWN0IGVhcF9zaW1fZGJfZGF0YSAqZGF0YSA9IHByaXY7Ci0JcmV0dXJuIGVhcF9zaW1fZGJfZ2V0X25leHQoZGF0YSwgYWthID8gRUFQX0FLQV9QU0VVRE9OWU1fUFJFRklYIDoKLQkJCQkgICBFQVBfU0lNX1BTRVVET05ZTV9QUkVGSVgpOworCWNoYXIgcHJlZml4ID0gRUFQX1NJTV9SRUFVVEhfSURfUFJFRklYOworCisJc3dpdGNoIChtZXRob2QpIHsKKwljYXNlIEVBUF9TSU1fREJfU0lNOgorCQlwcmVmaXggPSBFQVBfU0lNX1BTRVVET05ZTV9QUkVGSVg7CisJCWJyZWFrOworCWNhc2UgRUFQX1NJTV9EQl9BS0E6CisJCXByZWZpeCA9IEVBUF9BS0FfUFNFVURPTllNX1BSRUZJWDsKKwkJYnJlYWs7CisJY2FzZSBFQVBfU0lNX0RCX0FLQV9QUklNRToKKwkJcHJlZml4ID0gRUFQX0FLQV9QUklNRV9QU0VVRE9OWU1fUFJFRklYOworCQlicmVhazsKKwl9CisKKwlyZXR1cm4gZWFwX3NpbV9kYl9nZXRfbmV4dChkYXRhLCBwcmVmaXgpOwogfQogCiAKIC8qKgogICogZWFwX3NpbV9kYl9nZXRfbmV4dF9yZWF1dGhfaWQgLSBFQVAtU0lNIERCOiBHZXQgbmV4dCByZWF1dGhfaWQKICAqIEBwcml2OiBQcml2YXRlIGRhdGEgcG9pbnRlciBmcm9tIGVhcF9zaW1fZGJfaW5pdCgpCi0gKiBAYWthOiBVc2luZyBFQVAtQUtBIGluc3RlYWQgb2YgRUFQLVNJTQorICogQG1ldGhvZDogRUFQIG1ldGhvZCAoU0lNL0FLQS9BS0EnKQogICogUmV0dXJuczogTmV4dCByZWF1dGhfaWQgKGFsbG9jYXRlZCBzdHJpbmcpIG9yICVOVUxMIG9uIGZhaWx1cmUKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gZ2VuZXJhdGUgYSBmYXN0IHJlLWF1dGhlbnRpY2F0aW9uIGlkZW50aXR5IGZvcgpAQCAtODcxLDExICs4OTEsMjQgQEAKICAqIGhhcyBiZWVuIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkuIENhbGxlciBpcyByZXNwb25zaWJsZSBmb3IgZnJlZWluZyB0aGUKICAqIHJldHVybmVkIGJ1ZmZlci4KICAqLwotY2hhciAqIGVhcF9zaW1fZGJfZ2V0X25leHRfcmVhdXRoX2lkKHZvaWQgKnByaXYsIGludCBha2EpCitjaGFyICogZWFwX3NpbV9kYl9nZXRfbmV4dF9yZWF1dGhfaWQodm9pZCAqcHJpdiwgZW51bSBlYXBfc2ltX2RiX21ldGhvZCBtZXRob2QpCiB7CiAJc3RydWN0IGVhcF9zaW1fZGJfZGF0YSAqZGF0YSA9IHByaXY7Ci0JcmV0dXJuIGVhcF9zaW1fZGJfZ2V0X25leHQoZGF0YSwgYWthID8gRUFQX0FLQV9SRUFVVEhfSURfUFJFRklYIDoKLQkJCQkgICBFQVBfU0lNX1JFQVVUSF9JRF9QUkVGSVgpOworCWNoYXIgcHJlZml4ID0gRUFQX1NJTV9SRUFVVEhfSURfUFJFRklYOworCisJc3dpdGNoIChtZXRob2QpIHsKKwljYXNlIEVBUF9TSU1fREJfU0lNOgorCQlwcmVmaXggPSBFQVBfU0lNX1JFQVVUSF9JRF9QUkVGSVg7CisJCWJyZWFrOworCWNhc2UgRUFQX1NJTV9EQl9BS0E6CisJCXByZWZpeCA9IEVBUF9BS0FfUkVBVVRIX0lEX1BSRUZJWDsKKwkJYnJlYWs7CisJY2FzZSBFQVBfU0lNX0RCX0FLQV9QUklNRToKKwkJcHJlZml4ID0gRUFQX0FLQV9QUklNRV9SRUFVVEhfSURfUFJFRklYOworCQlicmVhazsKKwl9CisKKwlyZXR1cm4gZWFwX3NpbV9kYl9nZXRfbmV4dChkYXRhLCBwcmVmaXgpOwogfQogCiAKQEAgLTExNTYsNyArMTE4OSw3IEBACiAgKiBjYWxsZWQgb25jZSB0aGUgcmVzdWx0cyBiZWNvbWUgYXZhaWxhYmxlLgogICoKICAqIEluIG1vc3QgY2FzZXMsIHRoZSB1c2VyIG5hbWUgaXMgJzAnIHwgSU1TSSwgaS5lLiwgMCBmb2xsb3dlZCBieSB0aGUgSU1TSSBpbgotICogQVNDSUkgZm9ybWF0LgorICogQVNDSUkgZm9ybWF0IGZvciBFQVAtQUtBIGFuZCAnNicgfCBJTVNJIGZvciBFQVAtQUtBJy4KICAqCiAgKiBXaGVuIHVzaW5nIGFuIGV4dGVybmFsIHNlcnZlciBmb3IgQUtBIGF1dGhlbnRpY2F0aW9uLCB0aGlzIGZ1bmN0aW9uIGNhbgogICogYWx3YXlzIHN0YXJ0IGEgcmVxdWVzdCBhbmQgcmV0dXJuIEVBUF9TSU1fREJfUEVORElORyBpbW1lZGlhdGVseSBpZgpAQCAtMTE3OCw3ICsxMjExLDggQEAKIAljaGFyIG1zZ1s0MF07CiAKIAlpZiAoaWRlbnRpdHlfbGVuIDwgMiB8fCBpZGVudGl0eSA9PSBOVUxMIHx8Ci0JICAgIGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUEVSTUFORU5UX1BSRUZJWCkgeworCSAgICAoaWRlbnRpdHlbMF0gIT0gRUFQX0FLQV9QRVJNQU5FTlRfUFJFRklYICYmCisJICAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1BSSU1FX1BFUk1BTkVOVF9QUkVGSVgpKSB7CiAJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIkVBUC1TSU0gREI6IHVuZXhwZWN0ZWQgaWRlbnRpdHkiLAogCQkJCSAgaWRlbnRpdHksIGlkZW50aXR5X2xlbik7CiAJCXJldHVybiBFQVBfU0lNX0RCX0ZBSUxVUkU7CkBAIC0xMjgxLDcgKzEzMTUsOCBAQAogCXNpemVfdCBpOwogCiAJaWYgKGlkZW50aXR5X2xlbiA8IDIgfHwgaWRlbnRpdHkgPT0gTlVMTCB8fAotCSAgICBpZGVudGl0eVswXSAhPSBFQVBfQUtBX1BFUk1BTkVOVF9QUkVGSVgpIHsKKwkgICAgKGlkZW50aXR5WzBdICE9IEVBUF9BS0FfUEVSTUFORU5UX1BSRUZJWCAmJgorCSAgICAgaWRlbnRpdHlbMF0gIT0gRUFQX0FLQV9QUklNRV9QRVJNQU5FTlRfUFJFRklYKSkgewogCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJFQVAtU0lNIERCOiB1bmV4cGVjdGVkIGlkZW50aXR5IiwKIAkJCQkgIGlkZW50aXR5LCBpZGVudGl0eV9sZW4pOwogCQlyZXR1cm4gLTE7CmRpZmYgLS1naXQgYS9zcmMvZWFwX3NlcnZlci9lYXBfc2ltX2RiLmggYi9zcmMvZWFwX3NlcnZlci9lYXBfc2ltX2RiLmgKaW5kZXggYWJlMTg1ZS4uMWY2Mzc1YSAxMDA2NDQKLS0tIGEvc3JjL2VhcF9zZXJ2ZXIvZWFwX3NpbV9kYi5oCisrKyBiL3NyYy9lYXBfc2VydmVyL2VhcF9zaW1fZGIuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBob3N0YXBkIC8gRUFQLVNJTSBkYXRhYmFzZS9hdXRoZW50aWNhdG9yIGdhdGV3YXkKLSAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA3LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDgsIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTE4LDYgKzE4LDE1IEBACiAjZGVmaW5lIEVBUF9BS0FfUEVSTUFORU5UX1BSRUZJWCAnMCcKICNkZWZpbmUgRUFQX0FLQV9QU0VVRE9OWU1fUFJFRklYICcyJwogI2RlZmluZSBFQVBfQUtBX1JFQVVUSF9JRF9QUkVGSVggJzQnCisjZGVmaW5lIEVBUF9BS0FfUFJJTUVfUEVSTUFORU5UX1BSRUZJWCAnNicKKyNkZWZpbmUgRUFQX0FLQV9QUklNRV9QU0VVRE9OWU1fUFJFRklYICc3JworI2RlZmluZSBFQVBfQUtBX1BSSU1FX1JFQVVUSF9JRF9QUkVGSVggJzgnCisKK2VudW0gZWFwX3NpbV9kYl9tZXRob2QgeworCUVBUF9TSU1fREJfU0lNLAorCUVBUF9TSU1fREJfQUtBLAorCUVBUF9TSU1fREJfQUtBX1BSSU1FCit9OwogCiB2b2lkICogZWFwX3NpbV9kYl9pbml0KGNvbnN0IGNoYXIgKmNvbmZpZywKIAkJICAgICAgIHZvaWQgKCpnZXRfY29tcGxldGVfY2IpKHZvaWQgKmN0eCwgdm9pZCAqc2Vzc2lvbl9jdHgpLApAQCAtMzYsOSArNDUsMTEgQEAKIGludCBlYXBfc2ltX2RiX2lkZW50aXR5X2tub3duKHZvaWQgKnByaXYsIGNvbnN0IHU4ICppZGVudGl0eSwKIAkJCSAgICAgIHNpemVfdCBpZGVudGl0eV9sZW4pOwogCi1jaGFyICogZWFwX3NpbV9kYl9nZXRfbmV4dF9wc2V1ZG9ueW0odm9pZCAqcHJpdiwgaW50IGFrYSk7CitjaGFyICogZWFwX3NpbV9kYl9nZXRfbmV4dF9wc2V1ZG9ueW0odm9pZCAqcHJpdiwKKwkJCQkgICAgIGVudW0gZWFwX3NpbV9kYl9tZXRob2QgbWV0aG9kKTsKIAotY2hhciAqIGVhcF9zaW1fZGJfZ2V0X25leHRfcmVhdXRoX2lkKHZvaWQgKnByaXYsIGludCBha2EpOworY2hhciAqIGVhcF9zaW1fZGJfZ2V0X25leHRfcmVhdXRoX2lkKHZvaWQgKnByaXYsCisJCQkJICAgICBlbnVtIGVhcF9zaW1fZGJfbWV0aG9kIG1ldGhvZCk7CiAKIGludCBlYXBfc2ltX2RiX2FkZF9wc2V1ZG9ueW0odm9pZCAqcHJpdiwgY29uc3QgdTggKmlkZW50aXR5LAogCQkJICAgICBzaXplX3QgaWRlbnRpdHlfbGVuLCBjaGFyICpwc2V1ZG9ueW0pOwpkaWZmIC0tZ2l0IGEvc3JjL2VhcG9sX2F1dGgvZWFwb2xfYXV0aF9zbV9pLmggYi9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtX2kuaAppbmRleCBkMGI3NjQxLi5kN2Y4OTNhIDEwMDY0NAotLS0gYS9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtX2kuaAorKysgYi9zcmMvZWFwb2xfYXV0aC9lYXBvbF9hdXRoX3NtX2kuaApAQCAtMTU3LDYgKzE1Nyw3IEBACiAJCQkgICAgICAqIEF1dGhlbnRpY2F0aW9uIHNlcnZlciAqLwogCXU4IGVhcF90eXBlX3N1cHA7IC8qIEVBUCB0eXBlIG9mIHRoZSBsYXN0IEVBUCBwYWNrZXQgZnJvbSBTdXBwbGljYW50ICovCiAJc3RydWN0IHJhZGl1c19jbGFzc19kYXRhIHJhZGl1c19jbGFzczsKKwlzdHJ1Y3Qgd3BhYnVmICpyYWRpdXNfY3VpOyAvKiBDaGFyZ2VhYmxlLVVzZXItSWRlbnRpdHkgKi8KIAogCS8qIEtleXMgZm9yIGVuY3J5cHRpbmcgYW5kIHNpZ25pbmcgRUFQT0wtS2V5IGZyYW1lcyAqLwogCXU4ICplYXBvbF9rZXlfc2lnbjsKZGlmZiAtLWdpdCBhL3NyYy9lYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uYyBiL3NyYy9lYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uYwppbmRleCBjODM3MDlmLi5mMGNhZTcwIDEwMDY0NAotLS0gYS9zcmMvZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmMKKysrIGIvc3JjL2VhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5jCkBAIC0xODQ3LDYgKzE4NDcsMTcgQEAKIAkJCQkgY2VydF9oYXNoLCBjZXJ0KTsKIH0KIAorCitzdGF0aWMgdm9pZCBlYXBvbF9zbV9ub3RpZnlfc3RhdHVzKHZvaWQgKmN0eCwgY29uc3QgY2hhciAqc3RhdHVzLAorCQkJCSAgIGNvbnN0IGNoYXIgKnBhcmFtZXRlcikKK3sKKwlzdHJ1Y3QgZWFwb2xfc20gKnNtID0gY3R4OworCisJaWYgKHNtLT5jdHgtPnN0YXR1c19jYikKKwkJc20tPmN0eC0+c3RhdHVzX2NiKHNtLT5jdHgtPmN0eCwgc3RhdHVzLCBwYXJhbWV0ZXIpOworfQorCisKIHN0YXRpYyBzdHJ1Y3QgZWFwb2xfY2FsbGJhY2tzIGVhcG9sX2NiID0KIHsKIAllYXBvbF9zbV9nZXRfY29uZmlnLApAQCAtMTg1OSw3ICsxODcwLDggQEAKIAllYXBvbF9zbV9nZXRfY29uZmlnX2Jsb2IsCiAJZWFwb2xfc21fbm90aWZ5X3BlbmRpbmcsCiAJZWFwb2xfc21fZWFwX3BhcmFtX25lZWRlZCwKLQllYXBvbF9zbV9ub3RpZnlfY2VydAorCWVhcG9sX3NtX25vdGlmeV9jZXJ0LAorCWVhcG9sX3NtX25vdGlmeV9zdGF0dXMKIH07CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2VhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5oIGIvc3JjL2VhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5oCmluZGV4IDMyNjBjNjEuLjFhMjBlNGIgMTAwNjQ0Ci0tLSBhL3NyYy9lYXBvbF9zdXBwL2VhcG9sX3N1cHBfc20uaAorKysgYi9zcmMvZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmgKQEAgLTIzMCw2ICsyMzAsMTUgQEAKIAkgKiBjZXJ0X2luX2NiIC0gSW5jbHVkZSBzZXJ2ZXIgY2VydGlmaWNhdGVzIGluIGNhbGxiYWNrCiAJICovCiAJaW50IGNlcnRfaW5fY2I7CisKKwkvKioKKwkgKiBzdGF0dXNfY2IgLSBOb3RpZmljYXRpb24gb2YgYSBjaGFuZ2UgaW4gRUFQIHN0YXR1cworCSAqIEBjdHg6IENhbGxiYWNrIGNvbnRleHQgKGN0eCkKKwkgKiBAc3RhdHVzOiBTdGVwIGluIHRoZSBwcm9jZXNzIG9mIEVBUCBhdXRoZW50aWNhdGlvbgorCSAqIEBwYXJhbWV0ZXI6IFN0ZXAtc3BlY2lmaWMgcGFyYW1ldGVyLCBlLmcuLCBFQVAgbWV0aG9kIG5hbWUKKwkgKi8KKwl2b2lkICgqc3RhdHVzX2NiKSh2b2lkICpjdHgsIGNvbnN0IGNoYXIgKnN0YXR1cywKKwkJCSAgY29uc3QgY2hhciAqcGFyYW1ldGVyKTsKIH07CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2wyX3BhY2tldC9sMl9wYWNrZXRfZnJlZWJzZC5jIGIvc3JjL2wyX3BhY2tldC9sMl9wYWNrZXRfZnJlZWJzZC5jCmluZGV4IGUyNDI3N2MuLjJlOWEwNGMgMTAwNjQ0Ci0tLSBhL3NyYy9sMl9wYWNrZXQvbDJfcGFja2V0X2ZyZWVic2QuYworKysgYi9zcmMvbDJfcGFja2V0L2wyX3BhY2tldF9mcmVlYnNkLmMKQEAgLTMsMTQgKzMsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMDUsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDUsIFNhbSBMZWZmbGVyIDxzYW1AZXJybm8uY29tPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvc3JjL2wyX3BhY2tldC9sMl9wYWNrZXRfcHJpdnNlcC5jIGIvc3JjL2wyX3BhY2tldC9sMl9wYWNrZXRfcHJpdnNlcC5jCmluZGV4IGFhY2Q3NmIuLjZiMTE3Y2EgMTAwNjQ0Ci0tLSBhL3NyYy9sMl9wYWNrZXQvbDJfcGFja2V0X3ByaXZzZXAuYworKysgYi9zcmMvbDJfcGFja2V0L2wyX3BhY2tldF9wcml2c2VwLmMKQEAgLTE3Myw3ICsxNzMsNyBAQAogCWFkZHIuc3VuX2ZhbWlseSA9IEFGX1VOSVg7CiAJb3Nfc3RybGNweShhZGRyLnN1bl9wYXRoLCBsMi0+b3duX3NvY2tldF9wYXRoLCBzaXplb2YoYWRkci5zdW5fcGF0aCkpOwogCWlmIChiaW5kKGwyLT5mZCwgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKLQkJcGVycm9yKCJiaW5kKFBGX1VOSVgpIik7CisJCXBlcnJvcigibDItcGt0LXByaXZzZXA6IGJpbmQoUEZfVU5JWCkiKTsKIAkJZ290byBmYWlsOwogCX0KIApkaWZmIC0tZ2l0IGEvc3JjL3AycC9wMnAuYyBiL3NyYy9wMnAvcDJwLmMKaW5kZXggYWVlYWNjYi4uNThhZGEzYiAxMDA2NDQKLS0tIGEvc3JjL3AycC9wMnAuYworKysgYi9zcmMvcDJwL3AycC5jCkBAIC0xMTksNyArMTE5LDcgQEAKIAkJCWNvbnRpbnVlOwogI2VuZGlmCiAKLQkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0VSUk9SLCAiUDJQOiBFeHBpcmluZyBvbGQgcGVlciAiCisJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywgIlAyUDogRXhwaXJpbmcgb2xkIHBlZXIgIgogCQkJImVudHJ5ICIgTUFDU1RSLCBNQUMyU1RSKGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIpKTsKICNpZmRlZiBBTkRST0lEX1AyUAogCQkvKiBTRF9GQUlSX1BPTElDWTogVXBkYXRlIHRoZSBjdXJyZW50IHNkX2Rldl9saXN0IHBvaW50ZXIgdG8gbmV4dCBkZXZpY2UgKi8KQEAgLTE5MywxNCArMTkzLDE0IEBACiB9CiAKIAotdm9pZCBwMnBfY2xlYXJfcHJvdmlzaW9uaW5nX2luZm8oc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICppZmFjZV9hZGRyKQordm9pZCBwMnBfY2xlYXJfcHJvdmlzaW9uaW5nX2luZm8oc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyKQogewogCXN0cnVjdCBwMnBfZGV2aWNlICpkZXYgPSBOVUxMOwogCi0JaWYgKCFpZmFjZV9hZGRyIHx8ICFwMnApCisJaWYgKCFhZGRyIHx8ICFwMnApCiAJCXJldHVybjsKIAotCWRldiA9IHAycF9nZXRfZGV2aWNlX2ludGVyZmFjZShwMnAsIGlmYWNlX2FkZHIpOworCWRldiA9IHAycF9nZXRfZGV2aWNlKHAycCwgYWRkcik7CiAJaWYgKGRldikKIAkJZGV2LT53cHNfcHJvdl9pbmZvID0gMDsKIH0KQEAgLTMxNSw3ICszMTUsNyBAQAogCXAycC0+cGVuZGluZ19saXN0ZW5fdXNlYyA9ICh0aW1lb3V0ICUgMTAwMCkgKiAxMDAwOwogCiAJaWYgKHAycC0+cDJwX3NjYW5fcnVubmluZykgewotCQlpZiAocDJwLT5zdGFydF9hZnRlcl9zY2FuID09IFAyUF9BRlRFUl9TQ0FOX05PVEhJTkcpIHsKKwkJaWYgKHAycC0+c3RhcnRfYWZ0ZXJfc2NhbiA9PSBQMlBfQUZURVJfU0NBTl9DT05ORUNUKSB7CiAJCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCiAJCQkJIlAyUDogcDJwX3NjYW4gcnVubmluZyAtIGNvbm5lY3QgaXMgYWxyZWFkeSAiCiAJCQkJInBlbmRpbmcgLSBza2lwIGxpc3RlbiIpOwpAQCAtNDg0LDEzICs0ODQsMjUgQEAKIAkJCWNvbnRpbnVlOyAvKiBpZ25vcmUgb3VyIG93biBlbnRyeSAqLwogCQlkZXYgPSBwMnBfZ2V0X2RldmljZShwMnAsIGNsaS0+cDJwX2RldmljZV9hZGRyKTsKIAkJaWYgKGRldikgewotCQkJLyoKLQkJCSAqIFVwZGF0ZSBpbmZvcm1hdGlvbiBvbmx5IGlmIHdlIGhhdmUgbm90IHJlY2VpdmVkIHRoaXMKLQkJCSAqIGRpcmVjdGx5IGZyb20gdGhlIGNsaWVudC4KLQkJCSAqLwogCQkJaWYgKGRldi0+ZmxhZ3MgJiAoUDJQX0RFVl9HUk9VUF9DTElFTlRfT05MWSB8Ci0JCQkJCSAgUDJQX0RFVl9QUk9CRV9SRVFfT05MWSkpCisJCQkJCSAgUDJQX0RFVl9QUk9CRV9SRVFfT05MWSkpIHsKKwkJCQkvKgorCQkJCSAqIFVwZGF0ZSBpbmZvcm1hdGlvbiBzaW5jZSB3ZSBoYXZlIG5vdAorCQkJCSAqIHJlY2VpdmVkIHRoaXMgZGlyZWN0bHkgZnJvbSB0aGUgY2xpZW50LgorCQkJCSAqLwogCQkJCXAycF9jb3B5X2NsaWVudF9pbmZvKGRldiwgY2xpKTsKKwkJCX0gZWxzZSB7CisJCQkJLyoKKwkJCQkgKiBOZWVkIHRvIHVwZGF0ZSBQMlAgQ2xpZW50IERpc2NvdmVyYWJpbGl0eQorCQkJCSAqIGZsYWcgc2luY2UgaXQgaXMgdmFsaWQgb25seSBpbiBQMlAgR3JvdXAKKwkJCQkgKiBJbmZvIGF0dHJpYnV0ZS4KKwkJCQkgKi8KKwkJCQlkZXYtPmluZm8uZGV2X2NhcGFiICY9CisJCQkJCX5QMlBfREVWX0NBUEFCX0NMSUVOVF9ESVNDT1ZFUkFCSUxJVFk7CisJCQkJZGV2LT5pbmZvLmRldl9jYXBhYiB8PQorCQkJCQljbGktPmRldl9jYXBhYiAmCisJCQkJCVAyUF9ERVZfQ0FQQUJfQ0xJRU5UX0RJU0NPVkVSQUJJTElUWTsKKwkJCX0KIAkJCWlmIChkZXYtPmZsYWdzICYgUDJQX0RFVl9QUk9CRV9SRVFfT05MWSkgewogCQkJCWRldi0+ZmxhZ3MgJj0gflAyUF9ERVZfUFJPQkVfUkVRX09OTFk7CiAJCQl9CkBAIC01NzMsNyArNTg1LDEzIEBACiAJfQogCiAJaWYgKG1zZy0+Y2FwYWJpbGl0eSkgewotCQlkZXYtPmluZm8uZGV2X2NhcGFiID0gbXNnLT5jYXBhYmlsaXR5WzBdOworCQkvKgorCQkgKiBQMlAgQ2xpZW50IERpc2NvdmVyYWJpbGl0eSBiaXQgaXMgcmVzZXJ2ZWQgaW4gYWxsIGZyYW1lcworCQkgKiB0aGF0IHVzZSB0aGlzIGZ1bmN0aW9uLCBzbyBkbyBub3QgY2hhbmdlIGl0cyB2YWx1ZSBoZXJlLgorCQkgKi8KKwkJZGV2LT5pbmZvLmRldl9jYXBhYiAmPSBQMlBfREVWX0NBUEFCX0NMSUVOVF9ESVNDT1ZFUkFCSUxJVFk7CisJCWRldi0+aW5mby5kZXZfY2FwYWIgfD0gbXNnLT5jYXBhYmlsaXR5WzBdICYKKwkJCX5QMlBfREVWX0NBUEFCX0NMSUVOVF9ESVNDT1ZFUkFCSUxJVFk7CiAJCWRldi0+aW5mby5ncm91cF9jYXBhYiA9IG1zZy0+Y2FwYWJpbGl0eVsxXTsKIAl9CiAKQEAgLTU4Miw2ICs2MDAsNyBAQAogCQlkZXYtPmV4dF9saXN0ZW5faW50ZXJ2YWwgPQogCQkJV1BBX0dFVF9MRTE2KG1zZy0+ZXh0X2xpc3Rlbl90aW1pbmcgKyAyKTsKIAl9CisKIAlpZiAoIXByb2JlX3JlcSkgewogCQlkZXYtPmluZm8uY29uZmlnX21ldGhvZHMgPSBtc2ctPmNvbmZpZ19tZXRob2RzID8KIAkJCW1zZy0+Y29uZmlnX21ldGhvZHMgOiBtc2ctPndwc19jb25maWdfbWV0aG9kczsKQEAgLTU5MCw3ICs2MDksNyBAQAogCiAKIC8qKgotICogcDJwX2FkZF9kZXZpY2UgLSBBZGQgcGVlciBlbnRyaWVzIGJhc2VkIG9uIHNjYW4gcmVzdWx0cworICogcDJwX2FkZF9kZXZpY2UgLSBBZGQgcGVlciBlbnRyaWVzIGJhc2VkIG9uIHNjYW4gcmVzdWx0cyBvciBQMlAgZnJhbWVzCiAgKiBAcDJwOiBQMlAgbW9kdWxlIGNvbnRleHQgZnJvbSBwMnBfaW5pdCgpCiAgKiBAYWRkcjogU291cmNlIGFkZHJlc3Mgb2YgQmVhY29uIG9yIFByb2JlIFJlc3BvbnNlIGZyYW1lIChtYXkgYmUgZWl0aGVyCiAgKglQMlAgRGV2aWNlIEFkZHJlc3Mgb3IgUDJQIEludGVyZmFjZSBBZGRyZXNzKQpAQCAtNTk4LDYgKzYxNyw3IEBACiAgKiBAZnJlcTogRnJlcXVlbmN5IG9uIHdoaWNoIHRoZSBCZWFjb24gb3IgUHJvYmUgUmVzcG9uc2UgZnJhbWUgd2FzIHJlY2VpdmVkCiAgKiBAaWVzOiBJRXMgZnJvbSB0aGUgQmVhY29uIG9yIFByb2JlIFJlc3BvbnNlIGZyYW1lCiAgKiBAaWVzX2xlbjogTGVuZ3RoIG9mIGllcyBidWZmZXIgaW4gb2N0ZXRzCisgKiBAc2Nhbl9yZXM6IFdoZXRoZXIgdGhpcyB3YXMgYmFzZWQgb24gc2NhbiByZXN1bHRzCiAgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKICAqCiAgKiBJZiB0aGUgc2NhbiByZXN1bHQgaXMgZm9yIGEgR08sIHRoZSBjbGllbnRzIGluIHRoZSBncm91cCB3aWxsIGFsc28gYmUgYWRkZWQKQEAgLTYwNiw3ICs2MjYsNyBAQAogICogSW5mbyBhdHRyaWJ1dGVzLgogICovCiBpbnQgcDJwX2FkZF9kZXZpY2Uoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLCBpbnQgZnJlcSwgaW50IGxldmVsLAotCQkgICBjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbikKKwkJICAgY29uc3QgdTggKmllcywgc2l6ZV90IGllc19sZW4sIGludCBzY2FuX3JlcykKIHsKIAlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OwogCXN0cnVjdCBwMnBfbWVzc2FnZSBtc2c7CkBAIC02NzUsMTYgKzY5NSwxOCBAQAogCQl9CiAJfQogCi0JaWYgKGRldi0+bGlzdGVuX2ZyZXEgJiYgZGV2LT5saXN0ZW5fZnJlcSAhPSBmcmVxKSB7CisJaWYgKGRldi0+bGlzdGVuX2ZyZXEgJiYgZGV2LT5saXN0ZW5fZnJlcSAhPSBmcmVxICYmIHNjYW5fcmVzKSB7CiAJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKIAkJCSJQMlA6IFVwZGF0ZSBMaXN0ZW4gZnJlcXVlbmN5IGJhc2VkIG9uIHNjYW4gIgogCQkJInJlc3VsdHMgKCIgTUFDU1RSICIgJWQgLT4gJWQgTUh6IChEUyBwYXJhbSAlZCkiLAogCQkJTUFDMlNUUihkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyKSwgZGV2LT5saXN0ZW5fZnJlcSwKIAkJCWZyZXEsIG1zZy5kc19wYXJhbXMgPyAqbXNnLmRzX3BhcmFtcyA6IC0xKTsKIAl9Ci0JZGV2LT5saXN0ZW5fZnJlcSA9IGZyZXE7Ci0JaWYgKG1zZy5ncm91cF9pbmZvKQotCQlkZXYtPm9wZXJfZnJlcSA9IGZyZXE7CisJaWYgKHNjYW5fcmVzKSB7CisJCWRldi0+bGlzdGVuX2ZyZXEgPSBmcmVxOworCQlpZiAobXNnLmdyb3VwX2luZm8pCisJCQlkZXYtPm9wZXJfZnJlcSA9IGZyZXE7CisJfQogCWRldi0+aW5mby5sZXZlbCA9IGxldmVsOwogCiAJcDJwX2NvcHlfd3BzX2luZm8oZGV2LCAwLCAmbXNnKTsKQEAgLTcwMyw4ICs3MjUsMTAgQEAKIAkJCWJyZWFrOwogCX0KIAotCXAycF9hZGRfZ3JvdXBfY2xpZW50cyhwMnAsIHAycF9kZXZfYWRkciwgYWRkciwgZnJlcSwgbXNnLmdyb3VwX2luZm8sCi0JCQkgICAgICBtc2cuZ3JvdXBfaW5mb19sZW4pOworCWlmIChzY2FuX3JlcykgeworCQlwMnBfYWRkX2dyb3VwX2NsaWVudHMocDJwLCBwMnBfZGV2X2FkZHIsIGFkZHIsIGZyZXEsCisJCQkJICAgICAgbXNnLmdyb3VwX2luZm8sIG1zZy5ncm91cF9pbmZvX2xlbik7CisJfQogCiAJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7CiAKQEAgLTgyMSw2ICs4NDUsNyBAQAogewogCWludCBmcmVxID0gMDsKIAllbnVtIHAycF9zY2FuX3R5cGUgdHlwZTsKKwl1MTYgcHdfaWQgPSBERVZfUFdfREVGQVVMVDsKIAogCWlmIChwMnAtPmRydl9pbl9saXN0ZW4pIHsKIAkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiUDJQOiBEcml2ZXIgaXMgc3RpbGwgIgpAQCAtODMwLDMwICs4NTUsOCBAQAogCX0KIAlwMnAtPmNmZy0+c3RvcF9saXN0ZW4ocDJwLT5jZmctPmNiX2N0eCk7CiAKLQlpZiAocDJwLT5nb19uZWdfcGVlcikgewotCQkvKgotCQkgKiBPbmx5IHNjYW4gdGhlIGtub3duIGxpc3RlbiBmcmVxdWVuY3kgb2YgdGhlIHBlZXIKLQkJICogZHVyaW5nIEdPIE5lZ290aWF0aW9uIHN0YXJ0LgotCQkgKi8KLQkJZnJlcSA9IHAycC0+Z29fbmVnX3BlZXItPmxpc3Rlbl9mcmVxOwotCQlpZiAoZnJlcSA8PSAwKQotCQkJZnJlcSA9IHAycC0+Z29fbmVnX3BlZXItPm9wZXJfZnJlcTsKLQkJdHlwZSA9IFAyUF9TQ0FOX1NQRUNJRklDOwotCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IFN0YXJ0aW5nIHNlYXJjaCAiCi0JCQkiZm9yIGZyZXEgJXUgKEdPIE5lZykiLCBmcmVxKTsKLQl9IGVsc2UgaWYgKHAycC0+aW52aXRlX3BlZXIpIHsKLQkJLyoKLQkJICogT25seSBzY2FuIHRoZSBrbm93biBsaXN0ZW4gZnJlcXVlbmN5IG9mIHRoZSBwZWVyCi0JCSAqIGR1cmluZyBJbnZpdGUgc3RhcnQuCi0JCSAqLwotCQlmcmVxID0gcDJwLT5pbnZpdGVfcGVlci0+bGlzdGVuX2ZyZXE7Ci0JCWlmIChmcmVxIDw9IDApCi0JCQlmcmVxID0gcDJwLT5pbnZpdGVfcGVlci0+b3Blcl9mcmVxOwotCQl0eXBlID0gUDJQX1NDQU5fU1BFQ0lGSUM7Ci0JCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywgIlAyUDogU3RhcnRpbmcgc2VhcmNoICIKLQkJCSJmb3IgZnJlcSAldSAoSW52aXRlKSIsIGZyZXEpOwotCX0gZWxzZSBpZiAocDJwLT5maW5kX3R5cGUgPT0gUDJQX0ZJTkRfUFJPR1JFU1NJVkUgJiYKLQkJICAgKGZyZXEgPSBwMnBfZ2V0X25leHRfcHJvZ19mcmVxKHAycCkpID4gMCkgeworCWlmIChwMnAtPmZpbmRfdHlwZSA9PSBQMlBfRklORF9QUk9HUkVTU0lWRSAmJgorCSAgICAoZnJlcSA9IHAycF9nZXRfbmV4dF9wcm9nX2ZyZXEocDJwKSkgPiAwKSB7CiAJCXR5cGUgPSBQMlBfU0NBTl9TT0NJQUxfUExVU19PTkU7CiAJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywgIlAyUDogU3RhcnRpbmcgc2VhcmNoICIKIAkJCSIoKyBmcmVxICV1KSIsIGZyZXEpOwpAQCAtODY0LDcgKzg2Nyw3IEBACiAKIAlpZiAocDJwLT5jZmctPnAycF9zY2FuKHAycC0+Y2ZnLT5jYl9jdHgsIHR5cGUsIGZyZXEsCiAJCQkgICAgICAgcDJwLT5udW1fcmVxX2Rldl90eXBlcywgcDJwLT5yZXFfZGV2X3R5cGVzLAotCQkJICAgICAgIHAycC0+ZmluZF9kZXZfaWQpKSB7CisJCQkgICAgICAgcDJwLT5maW5kX2Rldl9pZCwgcHdfaWQpKSB7CiAJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKIAkJCSJQMlA6IFNjYW4gcmVxdWVzdCBmYWlsZWQiKTsKIAkJcDJwX2NvbnRpbnVlX2ZpbmQocDJwKTsKQEAgLTEwMTYsMTIgKzEwMTksMTQgQEAKIAljYXNlIFAyUF9GSU5EX1BST0dSRVNTSVZFOgogCQlyZXMgPSBwMnAtPmNmZy0+cDJwX3NjYW4ocDJwLT5jZmctPmNiX2N0eCwgUDJQX1NDQU5fRlVMTCwgMCwKIAkJCQkJIHAycC0+bnVtX3JlcV9kZXZfdHlwZXMsCi0JCQkJCSBwMnAtPnJlcV9kZXZfdHlwZXMsIGRldl9pZCk7CisJCQkJCSBwMnAtPnJlcV9kZXZfdHlwZXMsIGRldl9pZCwKKwkJCQkJIERFVl9QV19ERUZBVUxUKTsKIAkJYnJlYWs7CiAJY2FzZSBQMlBfRklORF9PTkxZX1NPQ0lBTDoKIAkJcmVzID0gcDJwLT5jZmctPnAycF9zY2FuKHAycC0+Y2ZnLT5jYl9jdHgsIFAyUF9TQ0FOX1NPQ0lBTCwgMCwKIAkJCQkJIHAycC0+bnVtX3JlcV9kZXZfdHlwZXMsCi0JCQkJCSBwMnAtPnJlcV9kZXZfdHlwZXMsIGRldl9pZCk7CisJCQkJCSBwMnAtPnJlcV9kZXZfdHlwZXMsIGRldl9pZCwKKwkJCQkJIERFVl9QV19ERUZBVUxUKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJcmV0dXJuIC0xOwpAQCAtMTA5MCwxMSArMTA5NSwyMSBAQAogCXAycC0+Z29fbmVnX3BlZXIgPSBOVUxMOwogCXAycC0+c2RfcGVlciA9IE5VTEw7CiAJcDJwLT5pbnZpdGVfcGVlciA9IE5VTEw7CisJcDJwX3N0b3BfbGlzdGVuX2Zvcl9mcmVxKHAycCwgZnJlcSk7Cit9CisKKwordm9pZCBwMnBfc3RvcF9saXN0ZW5fZm9yX2ZyZXEoc3RydWN0IHAycF9kYXRhICpwMnAsIGludCBmcmVxKQorewogCWlmIChmcmVxID4gMCAmJiBwMnAtPmRydl9pbl9saXN0ZW4gPT0gZnJlcSAmJiBwMnAtPmluX2xpc3RlbikgewogCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IFNraXAgc3RvcF9saXN0ZW4gIgogCQkJInNpbmNlIHdlIGFyZSBvbiBjb3JyZWN0IGNoYW5uZWwgZm9yIHJlc3BvbnNlIik7CiAJCXJldHVybjsKIAl9CisJaWYgKHAycC0+aW5fbGlzdGVuKSB7CisJCXAycC0+aW5fbGlzdGVuID0gMDsKKwkJcDJwX2NsZWFyX3RpbWVvdXQocDJwKTsKKwl9CiAJaWYgKHAycC0+ZHJ2X2luX2xpc3RlbikgewogCQkvKgogCQkgKiBUaGUgZHJpdmVyIG1heSBub3QgZGVsaXZlciBjYWxsYmFjayB0byBwMnBfbGlzdGVuX2VuZCgpCkBAIC0xMjE3LDIxICsxMjMyLDIyIEBACiBpbnQgcDJwX2Nvbm5lY3Qoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICpwZWVyX2FkZHIsCiAJCWVudW0gcDJwX3dwc19tZXRob2Qgd3BzX21ldGhvZCwKIAkJaW50IGdvX2ludGVudCwgY29uc3QgdTggKm93bl9pbnRlcmZhY2VfYWRkciwKLQkJdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwKQorCQl1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgaW50IHBlcnNpc3RlbnRfZ3JvdXAsCisJCWNvbnN0IHU4ICpmb3JjZV9zc2lkLCBzaXplX3QgZm9yY2Vfc3NpZF9sZW4sCisJCWludCBwZF9iZWZvcmVfZ29fbmVnKQogewogCXN0cnVjdCBwMnBfZGV2aWNlICpkZXY7CiAKIAl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCiAJCSJQMlA6IFJlcXVlc3QgdG8gc3RhcnQgZ3JvdXAgbmVnb3RpYXRpb24gLSBwZWVyPSIgTUFDU1RSCiAJCSIgIEdPIEludGVudD0lZCAgSW50ZW5kZWQgSW50ZXJmYWNlIEFkZHJlc3M9IiBNQUNTVFIKLQkJIiB3cHNfbWV0aG9kPSVkIHBlcnNpc3RlbnRfZ3JvdXA9JWQiLAorCQkiIHdwc19tZXRob2Q9JWQgcGVyc2lzdGVudF9ncm91cD0lZCBwZF9iZWZvcmVfZ29fbmVnPSVkIiwKIAkJTUFDMlNUUihwZWVyX2FkZHIpLCBnb19pbnRlbnQsIE1BQzJTVFIob3duX2ludGVyZmFjZV9hZGRyKSwKLQkJd3BzX21ldGhvZCwgcGVyc2lzdGVudF9ncm91cCk7CisJCXdwc19tZXRob2QsIHBlcnNpc3RlbnRfZ3JvdXAsIHBkX2JlZm9yZV9nb19uZWcpOwogCiAJaWYgKHAycF9wcmVwYXJlX2NoYW5uZWwocDJwLCBmb3JjZV9mcmVxKSA8IDApCiAJCXJldHVybiAtMTsKIAotCXAycC0+c3NpZF9zZXQgPSAwOwogCWRldiA9IHAycF9nZXRfZGV2aWNlKHAycCwgcGVlcl9hZGRyKTsKIAlpZiAoZGV2ID09IE5VTEwgfHwgKGRldi0+ZmxhZ3MgJiBQMlBfREVWX1BST0JFX1JFUV9PTkxZKSkgewogCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCkBAIC0xMjY0LDEwICsxMjgwLDIzIEBACiAJCSAqLwogCX0KIAorCXAycC0+c3NpZF9zZXQgPSAwOworCWlmIChmb3JjZV9zc2lkKSB7CisJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIlAyUDogRm9yY2VkIFNTSUQiLAorCQkJCSAgZm9yY2Vfc3NpZCwgZm9yY2Vfc3NpZF9sZW4pOworCQlvc19tZW1jcHkocDJwLT5zc2lkLCBmb3JjZV9zc2lkLCBmb3JjZV9zc2lkX2xlbik7CisJCXAycC0+c3NpZF9sZW4gPSBmb3JjZV9zc2lkX2xlbjsKKwkJcDJwLT5zc2lkX3NldCA9IDE7CisJfQorCiAJZGV2LT5mbGFncyAmPSB+UDJQX0RFVl9OT1RfWUVUX1JFQURZOwogCWRldi0+ZmxhZ3MgJj0gflAyUF9ERVZfVVNFUl9SRUpFQ1RFRDsKIAlkZXYtPmZsYWdzICY9IH5QMlBfREVWX1dBSVRfR09fTkVHX1JFU1BPTlNFOwogCWRldi0+ZmxhZ3MgJj0gflAyUF9ERVZfV0FJVF9HT19ORUdfQ09ORklSTTsKKwlpZiAocGRfYmVmb3JlX2dvX25lZykKKwkJZGV2LT5mbGFncyB8PSBQMlBfREVWX1BEX0JFRk9SRV9HT19ORUc7CisJZWxzZQorCQlkZXYtPmZsYWdzICY9IH5QMlBfREVWX1BEX0JFRk9SRV9HT19ORUc7CiAJZGV2LT5jb25uZWN0X3JlcXMgPSAwOwogCWRldi0+Z29fbmVnX3JlcV9zZW50ID0gMDsKIAlkZXYtPmdvX3N0YXRlID0gVU5LTk9XTl9HTzsKQEAgLTEzMTUsNyArMTM0NCw4IEBACiBpbnQgcDJwX2F1dGhvcml6ZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKnBlZXJfYWRkciwKIAkJICBlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCiAJCSAgaW50IGdvX2ludGVudCwgY29uc3QgdTggKm93bl9pbnRlcmZhY2VfYWRkciwKLQkJICB1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgaW50IHBlcnNpc3RlbnRfZ3JvdXApCisJCSAgdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwLAorCQkgIGNvbnN0IHU4ICpmb3JjZV9zc2lkLCBzaXplX3QgZm9yY2Vfc3NpZF9sZW4pCiB7CiAJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKIApAQCAtMTMzNyw2ICsxMzY3LDE1IEBACiAJCXJldHVybiAtMTsKIAl9CiAKKwlwMnAtPnNzaWRfc2V0ID0gMDsKKwlpZiAoZm9yY2Vfc3NpZCkgeworCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJQMlA6IEZvcmNlZCBTU0lEIiwKKwkJCQkgIGZvcmNlX3NzaWQsIGZvcmNlX3NzaWRfbGVuKTsKKwkJb3NfbWVtY3B5KHAycC0+c3NpZCwgZm9yY2Vfc3NpZCwgZm9yY2Vfc3NpZF9sZW4pOworCQlwMnAtPnNzaWRfbGVuID0gZm9yY2Vfc3NpZF9sZW47CisJCXAycC0+c3NpZF9zZXQgPSAxOworCX0KKwogCWRldi0+ZmxhZ3MgJj0gflAyUF9ERVZfTk9UX1lFVF9SRUFEWTsKIAlkZXYtPmZsYWdzICY9IH5QMlBfREVWX1VTRVJfUkVKRUNURUQ7CiAJZGV2LT5nb19uZWdfcmVxX3NlbnQgPSAwOwpAQCAtMTgyMSwxNiArMTg2MCwyMyBAQAogewogCXN0cnVjdCB3cGFidWYgKmJ1ZjsKIAl1OCAqbGVuOworCWludCBwd19pZCA9IC0xOwogCiAJYnVmID0gd3BhYnVmX2FsbG9jKDEwMDApOwogCWlmIChidWYgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAKLQlwMnBfYnVpbGRfd3BzX2llKHAycCwgYnVmLCBERVZfUFdfREVGQVVMVCwgMSk7CisJaWYgKHAycC0+Z29fbmVnX3BlZXIpIHsKKwkJLyogQWR2ZXJ0aXNlIGltbWVkaWF0ZSBhdmFpbGFiaWxpdHkgb2YgV1BTIGNyZWRlbnRpYWwgKi8KKwkJcHdfaWQgPSBwMnBfd3BzX21ldGhvZF9wd19pZChwMnAtPmdvX25lZ19wZWVyLT53cHNfbWV0aG9kKTsKKwl9CisKKwlwMnBfYnVpbGRfd3BzX2llKHAycCwgYnVmLCBwd19pZCwgMSk7CiAKIAkvKiBQMlAgSUUgKi8KIAlsZW4gPSBwMnBfYnVmX2FkZF9pZV9oZHIoYnVmKTsKLQlwMnBfYnVmX2FkZF9jYXBhYmlsaXR5KGJ1ZiwgcDJwLT5kZXZfY2FwYWIsIDApOworCXAycF9idWZfYWRkX2NhcGFiaWxpdHkoYnVmLCBwMnAtPmRldl9jYXBhYiAmCisJCQkgICAgICAgflAyUF9ERVZfQ0FQQUJfQ0xJRU5UX0RJU0NPVkVSQUJJTElUWSwgMCk7CiAJaWYgKHAycC0+ZXh0X2xpc3Rlbl9pbnRlcnZhbCkKIAkJcDJwX2J1Zl9hZGRfZXh0X2xpc3Rlbl90aW1pbmcoYnVmLCBwMnAtPmV4dF9saXN0ZW5fcGVyaW9kLAogCQkJCQkgICAgICBwMnAtPmV4dF9saXN0ZW5faW50ZXJ2YWwpOwpAQCAtMTg3NCw5ICsxOTIwLDkgQEAKIH0KIAogCi1zdGF0aWMgdm9pZCBwMnBfcmVwbHlfcHJvYmUoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLAotCQkJICAgIGNvbnN0IHU4ICpkc3QsIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmllLAotCQkJICAgIHNpemVfdCBpZV9sZW4pCitzdGF0aWMgZW51bSBwMnBfcHJvYmVfcmVxX3N0YXR1cworcDJwX3JlcGx5X3Byb2JlKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqYWRkciwgY29uc3QgdTggKmRzdCwKKwkJY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pCiB7CiAJc3RydWN0IGllZWU4MDJfMTFfZWxlbXMgZWxlbXM7CiAJc3RydWN0IHdwYWJ1ZiAqYnVmOwpAQCAtMTg4Niw1NSArMTkzMiw1NSBAQAogCiAJaWYgKCFwMnAtPmluX2xpc3RlbiB8fCAhcDJwLT5kcnZfaW5fbGlzdGVuKSB7CiAJCS8qIG5vdCBpbiBMaXN0ZW4gc3RhdGUgLSBpZ25vcmUgUHJvYmUgUmVxdWVzdCAqLwotCQlyZXR1cm47CisJCXJldHVybiBQMlBfUFJFUV9OT1RfTElTVEVOOwogCX0KIAogCWlmIChpZWVlODAyXzExX3BhcnNlX2VsZW1zKCh1OCAqKSBpZSwgaWVfbGVuLCAmZWxlbXMsIDApID09CiAJICAgIFBhcnNlRmFpbGVkKSB7CiAJCS8qIElnbm9yZSBpbnZhbGlkIFByb2JlIFJlcXVlc3QgZnJhbWVzICovCi0JCXJldHVybjsKKwkJcmV0dXJuIFAyUF9QUkVRX01BTEZPUk1FRDsKIAl9CiAKIAlpZiAoZWxlbXMucDJwID09IE5VTEwpIHsKIAkJLyogbm90IGEgUDJQIHByb2JlIC0gaWdub3JlIGl0ICovCi0JCXJldHVybjsKKwkJcmV0dXJuIFAyUF9QUkVRX05PVF9QMlA7CiAJfQogCiAJaWYgKGRzdCAmJiAhaXNfYnJvYWRjYXN0X2V0aGVyX2FkZHIoZHN0KSAmJgogCSAgICBvc19tZW1jbXAoZHN0LCBwMnAtPmNmZy0+ZGV2X2FkZHIsIEVUSF9BTEVOKSAhPSAwKSB7CiAJCS8qIE5vdCBzZW50IHRvIHRoZSBicm9hZGNhc3QgYWRkcmVzcyBvciBvdXIgUDJQIERldmljZSBBZGRyZXNzCiAJCSAqLwotCQlyZXR1cm47CisJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIAogCWlmIChic3NpZCAmJiAhaXNfYnJvYWRjYXN0X2V0aGVyX2FkZHIoYnNzaWQpKSB7CiAJCS8qIE5vdCBzZW50IHRvIHRoZSBXaWxkY2FyZCBCU1NJRCAqLwotCQlyZXR1cm47CisJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIAogCWlmIChlbGVtcy5zc2lkID09IE5VTEwgfHwgZWxlbXMuc3NpZF9sZW4gIT0gUDJQX1dJTERDQVJEX1NTSURfTEVOIHx8CiAJICAgIG9zX21lbWNtcChlbGVtcy5zc2lkLCBQMlBfV0lMRENBUkRfU1NJRCwgUDJQX1dJTERDQVJEX1NTSURfTEVOKSAhPQogCSAgICAwKSB7CiAJCS8qIG5vdCB1c2luZyBQMlAgV2lsZGNhcmQgU1NJRCAtIGlnbm9yZSAqLwotCQlyZXR1cm47CisJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIAogCWlmIChzdXBwX3JhdGVzXzExYl9vbmx5KCZlbGVtcykpIHsKIAkJLyogSW5kaWNhdGVzIHN1cHBvcnQgZm9yIDExYiByYXRlcyBvbmx5ICovCi0JCXJldHVybjsKKwkJcmV0dXJuIFAyUF9QUkVRX05PVF9QMlA7CiAJfQogCiAJb3NfbWVtc2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKIAlpZiAocDJwX3BhcnNlX2llcyhpZSwgaWVfbGVuLCAmbXNnKSA8IDApIHsKIAkJLyogQ291bGQgbm90IHBhcnNlIFAyUCBhdHRyaWJ1dGVzICovCi0JCXJldHVybjsKKwkJcmV0dXJuIFAyUF9QUkVRX05PVF9QMlA7CiAJfQogCiAJaWYgKG1zZy5kZXZpY2VfaWQgJiYKLQkgICAgb3NfbWVtY21wKG1zZy5kZXZpY2VfaWQsIHAycC0+Y2ZnLT5kZXZfYWRkciwgRVRIX0FMRU4gIT0gMCkpIHsKKwkgICAgb3NfbWVtY21wKG1zZy5kZXZpY2VfaWQsIHAycC0+Y2ZnLT5kZXZfYWRkciwgRVRIX0FMRU4pICE9IDApIHsKIAkJLyogRGV2aWNlIElEIGRpZCBub3QgbWF0Y2ggKi8KIAkJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7Ci0JCXJldHVybjsKKwkJcmV0dXJuIFAyUF9QUkVRX05PVF9QUk9DRVNTRUQ7CiAJfQogCiAJLyogQ2hlY2sgUmVxdWVzdGVkIERldmljZSBUeXBlIG1hdGNoICovCkBAIC0xOTQyLDEyICsxOTg4LDE0IEBACiAJICAgICFwMnBfbWF0Y2hfZGV2X3R5cGUocDJwLCBtc2cud3BzX2F0dHJpYnV0ZXMpKSB7CiAJCS8qIE5vIG1hdGNoIHdpdGggUmVxdWVzdGVkIERldmljZSBUeXBlICovCiAJCXAycF9wYXJzZV9mcmVlKCZtc2cpOwotCQlyZXR1cm47CisJCXJldHVybiBQMlBfUFJFUV9OT1RfUFJPQ0VTU0VEOwogCX0KIAlwMnBfcGFyc2VfZnJlZSgmbXNnKTsKIAotCWlmICghcDJwLT5jZmctPnNlbmRfcHJvYmVfcmVzcCkKLQkJcmV0dXJuOyAvKiBSZXNwb25zZSBnZW5lcmF0ZWQgZWxzZXdoZXJlICovCisJaWYgKCFwMnAtPmNmZy0+c2VuZF9wcm9iZV9yZXNwKSB7CisJCS8qIFJlc3BvbnNlIGdlbmVyYXRlZCBlbHNld2hlcmUgKi8KKwkJcmV0dXJuIFAyUF9QUkVRX05PVF9QUk9DRVNTRUQ7CisJfQogCiAJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0RFQlVHLAogCQkiUDJQOiBSZXBseSB0byBQMlAgUHJvYmUgUmVxdWVzdCBpbiBMaXN0ZW4gc3RhdGUiKTsKQEAgLTE5NjAsMTIgKzIwMDgsMTIgQEAKIAkgKi8KIAlpZXMgPSBwMnBfYnVpbGRfcHJvYmVfcmVzcF9pZXMocDJwKTsKIAlpZiAoaWVzID09IE5VTEwpCi0JCXJldHVybjsKKwkJcmV0dXJuIFAyUF9QUkVRX05PVF9QUk9DRVNTRUQ7CiAKIAlidWYgPSB3cGFidWZfYWxsb2MoMjAwICsgd3BhYnVmX2xlbihpZXMpKTsKIAlpZiAoYnVmID09IE5VTEwpIHsKIAkJd3BhYnVmX2ZyZWUoaWVzKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gUDJQX1BSRVFfTk9UX1BST0NFU1NFRDsKIAl9CiAKIAlyZXNwID0gTlVMTDsKQEAgLTIwMDgsMTUgKzIwNTYsMjAgQEAKIAlwMnAtPmNmZy0+c2VuZF9wcm9iZV9yZXNwKHAycC0+Y2ZnLT5jYl9jdHgsIGJ1Zik7CiAKIAl3cGFidWZfZnJlZShidWYpOworCisJcmV0dXJuIFAyUF9QUkVRX05PVF9QUk9DRVNTRUQ7CiB9CiAKIAotaW50IHAycF9wcm9iZV9yZXFfcngoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLCBjb25zdCB1OCAqZHN0LAotCQkgICAgIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuKQorZW51bSBwMnBfcHJvYmVfcmVxX3N0YXR1cworcDJwX3Byb2JlX3JlcV9yeChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkc3QsCisJCSBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbikKIHsKKwllbnVtIHAycF9wcm9iZV9yZXFfc3RhdHVzIHJlczsKKwogCXAycF9hZGRfZGV2X2Zyb21fcHJvYmVfcmVxKHAycCwgYWRkciwgaWUsIGllX2xlbik7CiAKLQlwMnBfcmVwbHlfcHJvYmUocDJwLCBhZGRyLCBkc3QsIGJzc2lkLCBpZSwgaWVfbGVuKTsKKwlyZXMgPSBwMnBfcmVwbHlfcHJvYmUocDJwLCBhZGRyLCBkc3QsIGJzc2lkLCBpZSwgaWVfbGVuKTsKIAogCWlmICgocDJwLT5zdGF0ZSA9PSBQMlBfQ09OTkVDVCB8fCBwMnAtPnN0YXRlID09IFAyUF9DT05ORUNUX0xJU1RFTikgJiYKIAkgICAgcDJwLT5nb19uZWdfcGVlciAmJgpAQCAtMjAyNyw3ICsyMDgwLDcgQEAKIAkJCSJQMlA6IEZvdW5kIEdPIE5lZ290aWF0aW9uIHBlZXIgLSB0cnkgdG8gc3RhcnQgR08gIgogCQkJIm5lZ290aWF0aW9uIGZyb20gdGltZW91dCIpOwogCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDAsIHAycF9nb19uZWdfc3RhcnQsIHAycCwgTlVMTCk7Ci0JCXJldHVybiAxOworCQlyZXR1cm4gUDJQX1BSRVFfUFJPQ0VTU0VEOwogCX0KIAogCWlmICgocDJwLT5zdGF0ZSA9PSBQMlBfSU5WSVRFIHx8IHAycC0+c3RhdGUgPT0gUDJQX0lOVklURV9MSVNURU4pICYmCkBAIC0yMDM5LDEwICsyMDkyLDEwIEBACiAJCQkiUDJQOiBGb3VuZCBJbnZpdGUgcGVlciAtIHRyeSB0byBzdGFydCBJbnZpdGUgZnJvbSAiCiAJCQkidGltZW91dCIpOwogCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KDAsIDAsIHAycF9pbnZpdGVfc3RhcnQsIHAycCwgTlVMTCk7Ci0JCXJldHVybiAxOworCQlyZXR1cm4gUDJQX1BSRVFfUFJPQ0VTU0VEOwogCX0KIAotCXJldHVybiAwOworCXJldHVybiByZXM7CiB9CiAKIApAQCAtMjE1NiwyOSArMjIwOSwzNyBAQAogfQogCiAKK2ludCBwMnBfcGFyc2VfZGV2X2FkZHJfaW5fcDJwX2llKHN0cnVjdCB3cGFidWYgKnAycF9pZSwgdTggKmRldl9hZGRyKQoreworCXN0cnVjdCBwMnBfbWVzc2FnZSBtc2c7CisKKwlvc19tZW1zZXQoJm1zZywgMCwgc2l6ZW9mKG1zZykpOworCWlmIChwMnBfcGFyc2VfcDJwX2llKHAycF9pZSwgJm1zZykpCisJCXJldHVybiAtMTsKKworCWlmIChtc2cucDJwX2RldmljZV9hZGRyKSB7CisJCW9zX21lbWNweShkZXZfYWRkciwgbXNnLnAycF9kZXZpY2VfYWRkciwgRVRIX0FMRU4pOworCQlyZXR1cm4gMDsKKwl9IGVsc2UgaWYgKG1zZy5kZXZpY2VfaWQpIHsKKwkJb3NfbWVtY3B5KGRldl9hZGRyLCBtc2cuZGV2aWNlX2lkLCBFVEhfQUxFTik7CisJCXJldHVybiAwOworCX0KKwlyZXR1cm4gLTE7Cit9CisKKwogaW50IHAycF9wYXJzZV9kZXZfYWRkcihjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbiwgdTggKmRldl9hZGRyKQogewogCXN0cnVjdCB3cGFidWYgKnAycF9pZTsKLQlzdHJ1Y3QgcDJwX21lc3NhZ2UgbXNnOworCWludCByZXQ7CiAKIAlwMnBfaWUgPSBpZWVlODAyXzExX3ZlbmRvcl9pZV9jb25jYXQoaWVzLCBpZXNfbGVuLAogCQkJCQkgICAgIFAyUF9JRV9WRU5ET1JfVFlQRSk7CiAJaWYgKHAycF9pZSA9PSBOVUxMKQogCQlyZXR1cm4gLTE7Ci0Jb3NfbWVtc2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKLQlpZiAocDJwX3BhcnNlX3AycF9pZShwMnBfaWUsICZtc2cpKSB7Ci0JCXdwYWJ1Zl9mcmVlKHAycF9pZSk7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlpZiAobXNnLnAycF9kZXZpY2VfYWRkciA9PSBOVUxMKSB7Ci0JCXdwYWJ1Zl9mcmVlKHAycF9pZSk7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlvc19tZW1jcHkoZGV2X2FkZHIsIG1zZy5wMnBfZGV2aWNlX2FkZHIsIEVUSF9BTEVOKTsKKwlyZXQgPSBwMnBfcGFyc2VfZGV2X2FkZHJfaW5fcDJwX2llKHAycF9pZSwgZGV2X2FkZHIpOwogCXdwYWJ1Zl9mcmVlKHAycF9pZSk7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHJldDsKIH0KIAogCkBAIC0yMjU2LDYgKzIzMTcsMTcgQEAKIAkJcDJwLT5jZmctPm1vZGVsX251bWJlciA9IG9zX3N0cmR1cChjZmctPm1vZGVsX251bWJlcik7CiAJaWYgKGNmZy0+c2VyaWFsX251bWJlcikKIAkJcDJwLT5jZmctPnNlcmlhbF9udW1iZXIgPSBvc19zdHJkdXAoY2ZnLT5zZXJpYWxfbnVtYmVyKTsKKwlpZiAoY2ZnLT5wcmVmX2NoYW4pIHsKKwkJcDJwLT5jZmctPnByZWZfY2hhbiA9IG9zX21hbGxvYyhjZmctPm51bV9wcmVmX2NoYW4gKgorCQkJCQkJc2l6ZW9mKHN0cnVjdCBwMnBfY2hhbm5lbCkpOworCQlpZiAocDJwLT5jZmctPnByZWZfY2hhbikgeworCQkJb3NfbWVtY3B5KHAycC0+Y2ZnLT5wcmVmX2NoYW4sIGNmZy0+cHJlZl9jaGFuLAorCQkJCSAgY2ZnLT5udW1fcHJlZl9jaGFuICoKKwkJCQkgIHNpemVvZihzdHJ1Y3QgcDJwX2NoYW5uZWwpKTsKKwkJfSBlbHNlCisJCQlwMnAtPmNmZy0+bnVtX3ByZWZfY2hhbiA9IDA7CisJfQorCiAjaWZkZWYgQU5EUk9JRF9QMlAKIAkvKiAxMDBtcyBsaXN0ZW4gdGltZSBpcyB0b28gbGVzcyB0byByZWNlaXZlIHRoZSByZXNwb25zZSBmcmFtZXMgaW4gc29tZSBzY2VuYXJpb3MKIAkgKiBpbmNyZWFzaW5nIG1pbiBsaXN0ZW4gdGltZSB0byAyMDBtcy4KQEAgLTIyOTgsNiArMjM3MCw3IEBACiAJb3NfZnJlZShwMnAtPmNmZy0+bW9kZWxfbmFtZSk7CiAJb3NfZnJlZShwMnAtPmNmZy0+bW9kZWxfbnVtYmVyKTsKIAlvc19mcmVlKHAycC0+Y2ZnLT5zZXJpYWxfbnVtYmVyKTsKKwlvc19mcmVlKHAycC0+Y2ZnLT5wcmVmX2NoYW4pOwogCW9zX2ZyZWUocDJwLT5ncm91cHMpOwogCXdwYWJ1Zl9mcmVlKHAycC0+c2RfcmVzcCk7CiAJb3NfZnJlZShwMnAtPmFmdGVyX3NjYW5fdHgpOwpAQCAtMjMwOSwxNiArMjM4Miw3IEBACiB2b2lkIHAycF9mbHVzaChzdHJ1Y3QgcDJwX2RhdGEgKnAycCkKIHsKIAlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2LCAqcHJldjsKLQlwMnBfY2xlYXJfdGltZW91dChwMnApOwotI2lmZGVmIEFORFJPSURfUDJQCi0JaWYgKHAycC0+c3RhdGUgPT0gUDJQX1NFQVJDSCkKLQkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0lORk8sCi0JCQkJCQlQMlBfRVZFTlRfRklORF9TVE9QUEVEKTsKLSNlbmRpZgotCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfSURMRSk7Ci0JcDJwLT5zdGFydF9hZnRlcl9zY2FuID0gUDJQX0FGVEVSX1NDQU5fTk9USElORzsKLQlwMnAtPmdvX25lZ19wZWVyID0gTlVMTDsKLQllbG9vcF9jYW5jZWxfdGltZW91dChwMnBfZmluZF90aW1lb3V0LCBwMnAsIE5VTEwpOworCXAycF9zdG9wX2ZpbmQocDJwKTsKIAlkbF9saXN0X2Zvcl9lYWNoX3NhZmUoZGV2LCBwcmV2LCAmcDJwLT5kZXZpY2VzLCBzdHJ1Y3QgcDJwX2RldmljZSwKIAkJCSAgICAgIGxpc3QpIHsKIAkJZGxfbGlzdF9kZWwoJmRldi0+bGlzdCk7CkBAIC0yNjcxLDE3ICsyNzM1LDcgQEAKIGludCBwMnBfc2Nhbl9yZXNfaGFuZGxlcihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmJzc2lkLCBpbnQgZnJlcSwKIAkJCSBpbnQgbGV2ZWwsIGNvbnN0IHU4ICppZXMsIHNpemVfdCBpZXNfbGVuKQogewotCXAycF9hZGRfZGV2aWNlKHAycCwgYnNzaWQsIGZyZXEsIGxldmVsLCBpZXMsIGllc19sZW4pOwotCi0JaWYgKHAycC0+Z29fbmVnX3BlZXIgJiYgcDJwLT5zdGF0ZSA9PSBQMlBfU0VBUkNIICYmCi0JICAgIG9zX21lbWNtcChwMnAtPmdvX25lZ19wZWVyLT5pbmZvLnAycF9kZXZpY2VfYWRkciwgYnNzaWQsIEVUSF9BTEVOKQotCSAgICA9PSAwKSB7Ci0JCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKLQkJCSJQMlA6IEZvdW5kIEdPIE5lZ290aWF0aW9uIHBlZXIgLSB0cnkgdG8gc3RhcnQgR08gIgotCQkJIm5lZ290aWF0aW9uIik7Ci0JCXAycF9jb25uZWN0X3NlbmQocDJwLCBwMnAtPmdvX25lZ19wZWVyKTsKLQkJcmV0dXJuIDE7Ci0JfQorCXAycF9hZGRfZGV2aWNlKHAycCwgYnNzaWQsIGZyZXEsIGxldmVsLCBpZXMsIGllc19sZW4sIDEpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0yNzA2LDcgKzI3NjAsOCBAQAogdm9pZCBwMnBfc2Nhbl9pZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqaWVzLCBjb25zdCB1OCAqZGV2X2lkKQogewogCXU4ICpsZW4gPSBwMnBfYnVmX2FkZF9pZV9oZHIoaWVzKTsKLQlwMnBfYnVmX2FkZF9jYXBhYmlsaXR5KGllcywgcDJwLT5kZXZfY2FwYWIsIDApOworCXAycF9idWZfYWRkX2NhcGFiaWxpdHkoaWVzLCBwMnAtPmRldl9jYXBhYiAmCisJCQkgICAgICAgflAyUF9ERVZfQ0FQQUJfQ0xJRU5UX0RJU0NPVkVSQUJJTElUWSwgMCk7CiAJaWYgKGRldl9pZCkKIAkJcDJwX2J1Zl9hZGRfZGV2aWNlX2lkKGllcywgZGV2X2lkKTsKIAlpZiAocDJwLT5jZmctPnJlZ19jbGFzcyAmJiBwMnAtPmNmZy0+Y2hhbm5lbCkKQEAgLTI3NDgsMTkgKzI4MDMsMTQgQEAKIAl9CiAKIAlpZiAoc3VjY2VzcykgewotI2lmbmRlZiBBTkRST0lEX1AyUAotCQlkZXYtPmdvX25lZ19yZXFfc2VudCsrOwotI2VuZGlmCiAJCWlmIChkZXYtPmZsYWdzICYgUDJQX0RFVl9VU0VSX1JFSkVDVEVEKSB7CiAJCQlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX0lETEUpOwogCQkJcmV0dXJuOwogCQl9Ci0JfQotI2lmZGVmIEFORFJPSURfUDJQCi0JZWxzZSB7CisJfSBlbHNlIGlmIChkZXYtPmdvX25lZ19yZXFfc2VudCkgeworCQkvKiBDYW5jZWwgdGhlIGluY3JlbWVudCBmcm9tIHAycF9jb25uZWN0X3NlbmQoKSBvbiBmYWlsdXJlICovCiAJCWRldi0+Z29fbmVnX3JlcV9zZW50LS07CiAJfQotI2VuZGlmCiAKIAlpZiAoIXN1Y2Nlc3MgJiYKIAkgICAgKGRldi0+aW5mby5kZXZfY2FwYWIgJiBQMlBfREVWX0NBUEFCX0NMSUVOVF9ESVNDT1ZFUkFCSUxJVFkpICYmCkBAIC0yOTc4LDYgKzMwMjgsMTggQEAKIAkJCQkibmV3IG9uZSIpOwogCQkJcmV0dXJuIDE7CiAJCX0KKwkJaWYgKHAycC0+cGVuZGluZ19saXN0ZW5fZnJlcSkgeworCQkJLyoKKwkJCSAqIEJldHRlciB3YWl0IGEgYml0IGlmIHRoZSBkcml2ZXIgaXMgdW5hYmxlIHRvIHN0YXJ0CisJCQkgKiBvZmZjaGFubmVsIG9wZXJhdGlvbiBmb3Igc29tZSByZWFzb24uIHAycF9zZWFyY2goKQorCQkJICogd2lsbCBiZSBzdGFydGVkIGZyb20gaW50ZXJuYWwgdGltZW91dC4KKwkJCSAqLworCQkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0RFQlVHLCAiUDJQOiBMaXN0ZW4gIgorCQkJCSJvcGVyYXRpb24gZGlkIG5vdCBzZWVtIHRvIHN0YXJ0IC0gZGVsYXkgIgorCQkJCSJzZWFyY2ggcGhhc2UgdG8gYXZvaWQgYnVzeSBsb29wIik7CisJCQlwMnBfc2V0X3RpbWVvdXQocDJwLCAwLCAxMDAwMDApOworCQkJcmV0dXJuIDE7CisJCX0KIAkJcDJwX3NlYXJjaChwMnApOwogCQlyZXR1cm4gMTsKIAl9CkBAIC0yOTg5LDYgKzMwNTEsMTQgQEAKIHN0YXRpYyB2b2lkIHAycF90aW1lb3V0X2Nvbm5lY3Qoc3RydWN0IHAycF9kYXRhICpwMnApCiB7CiAJcDJwLT5jZmctPnNlbmRfYWN0aW9uX2RvbmUocDJwLT5jZmctPmNiX2N0eCk7CisJaWYgKHAycC0+Z29fbmVnX3BlZXIgJiYKKwkgICAgKHAycC0+Z29fbmVnX3BlZXItPmZsYWdzICYgUDJQX0RFVl9XQUlUX0dPX05FR19DT05GSVJNKSkgeworCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IFdhaXQgZm9yIEdPICIKKwkJCSJOZWdvdGlhdGlvbiBDb25maXJtIHRpbWVkIG91dCAtIGFzc3VtZSBHTyAiCisJCQkiTmVnb3RpYXRpb24gZmFpbGVkIik7CisJCXAycF9nb19uZWdfZmFpbGVkKHAycCwgcDJwLT5nb19uZWdfcGVlciwgLTEpOworCQlyZXR1cm47CisJfQogCXAycF9zZXRfc3RhdGUocDJwLCBQMlBfQ09OTkVDVF9MSVNURU4pOwogCXAycF9saXN0ZW5faW5fZmluZChwMnApOwogfQpAQCAtMzgwMiw2ICszODcyLDI4IEBACiB9CiAKIAoraW50IHAycF9zZXRfcHJlZl9jaGFuKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1bnNpZ25lZCBpbnQgbnVtX3ByZWZfY2hhbiwKKwkJICAgICAgY29uc3Qgc3RydWN0IHAycF9jaGFubmVsICpwcmVmX2NoYW4pCit7CisJc3RydWN0IHAycF9jaGFubmVsICpuOworCisJaWYgKHByZWZfY2hhbikgeworCQluID0gb3NfbWFsbG9jKG51bV9wcmVmX2NoYW4gKiBzaXplb2Yoc3RydWN0IHAycF9jaGFubmVsKSk7CisJCWlmIChuID09IE5VTEwpCisJCQlyZXR1cm4gLTE7CisJCW9zX21lbWNweShuLCBwcmVmX2NoYW4sCisJCQkgIG51bV9wcmVmX2NoYW4gKiBzaXplb2Yoc3RydWN0IHAycF9jaGFubmVsKSk7CisJfSBlbHNlCisJCW4gPSBOVUxMOworCisJb3NfZnJlZShwMnAtPmNmZy0+cHJlZl9jaGFuKTsKKwlwMnAtPmNmZy0+cHJlZl9jaGFuID0gbjsKKwlwMnAtPmNmZy0+bnVtX3ByZWZfY2hhbiA9IG51bV9wcmVmX2NoYW47CisKKwlyZXR1cm4gMDsKK30KKworCiBpbnQgcDJwX2dldF9pbnRlcmZhY2VfYWRkcihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmRldl9hZGRyLAogCQkJICAgdTggKmlmYWNlX2FkZHIpCiB7CmRpZmYgLS1naXQgYS9zcmMvcDJwL3AycC5oIGIvc3JjL3AycC9wMnAuaAppbmRleCBmZTk4ZjVlLi43MDA2NzA3IDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycC5oCisrKyBiL3NyYy9wMnAvcDJwLmgKQEAgLTEzMSw3ICsxMzEsNiBAQAogZW51bSBwMnBfc2Nhbl90eXBlIHsKIAlQMlBfU0NBTl9TT0NJQUwsCiAJUDJQX1NDQU5fRlVMTCwKLQlQMlBfU0NBTl9TUEVDSUZJQywKIAlQMlBfU0NBTl9TT0NJQUxfUExVU19PTkUKIH07CiAKQEAgLTIxOCw2ICsyMTcsMTEgQEAKIAlQMlBfUFJPVl9ESVNDX1JFSkVDVEVELAogfTsKIAorc3RydWN0IHAycF9jaGFubmVsIHsKKwl1OCBvcF9jbGFzczsKKwl1OCBjaGFuOworfTsKKwogLyoqCiAgKiBzdHJ1Y3QgcDJwX2NvbmZpZyAtIFAyUCBjb25maWd1cmF0aW9uCiAgKgpAQCAtMjY1LDYgKzI2OSwxNiBAQAogCXN0cnVjdCBwMnBfY2hhbm5lbHMgY2hhbm5lbHM7CiAKIAkvKioKKwkgKiBudW1fcHJlZl9jaGFuIC0gTnVtYmVyIG9mIHByZWZfY2hhbiBlbnRyaWVzCisJICovCisJdW5zaWduZWQgaW50IG51bV9wcmVmX2NoYW47CisKKwkvKioKKwkgKiBwcmVmX2NoYW4gLSBQcmVmZXJyZWQgY2hhbm5lbHMgZm9yIEdPIE5lZ290aWF0aW9uCisJICovCisJc3RydWN0IHAycF9jaGFubmVsICpwcmVmX2NoYW47CisKKwkvKioKIAkgKiBwcmlfZGV2X3R5cGUgLSBQcmltYXJ5IERldmljZSBUeXBlIChzZWUgV1BTKQogCSAqLwogCXU4IHByaV9kZXZfdHlwZVs4XTsKQEAgLTM1NCwxNCArMzY4LDE0IEBACiAJICogQG51bV9yZXFfZGV2X3R5cGVzOiBOdW1iZXIgb2YgcmVxdWVzdGVkIGRldmljZSB0eXBlcwogCSAqIEByZXFfZGV2X3R5cGVzOiBBcnJheSBjb250YWluaW5nIHJlcXVlc3RlZCBkZXZpY2UgdHlwZXMKIAkgKiBAZGV2X2lkOiBEZXZpY2UgSUQgdG8gc2VhcmNoIGZvciBvciAlTlVMTCB0byBmaW5kIGFsbCBkZXZpY2VzCisJICogQHB3X2lkOiBEZXZpY2UgUGFzc3dvcmQgSUQKIAkgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKIAkgKgogCSAqIFRoaXMgY2FsbGJhY2sgZnVuY3Rpb24gaXMgdXNlZCB0byByZXF1ZXN0IGEgUDJQIHNjYW4gb3Igc2VhcmNoCiAJICogb3BlcmF0aW9uIHRvIGJlIGNvbXBsZXRlZC4gVHlwZSB0eXBlIGFyZ3VtZW50IHNwZWNpZmllcyB3aGljaCB0eXBlCiAJICogb2Ygc2NhbiBpcyB0byBiZSBkb25lLiBAUDJQX1NDQU5fU09DSUFMIGluZGljYXRlcyB0aGF0IG9ubHkgdGhlCiAJICogc29jaWFsIGNoYW5uZWxzICgxLCA2LCAxMSkgc2hvdWxkIGJlIHNjYW5uZWQuIEBQMlBfU0NBTl9GVUxMCi0JICogaW5kaWNhdGVzIHRoYXQgYWxsIGNoYW5uZWxzIGFyZSB0byBiZSBzY2FubmVkLiBAUDJQX1NDQU5fU1BFQ0lGSUMKLQkgKiByZXF1ZXN0IGEgc2NhbiBvZiBhIHNpbmdsZSBjaGFubmVsIHNwZWNpZmllZCBieSBmcmVxLgorCSAqIGluZGljYXRlcyB0aGF0IGFsbCBjaGFubmVscyBhcmUgdG8gYmUgc2Nhbm5lZC4KIAkgKiBAUDJQX1NDQU5fU09DSUFMX1BMVVNfT05FIHJlcXVlc3Qgc2NhbiBvZiBhbGwgdGhlIHNvY2lhbCBjaGFubmVscwogCSAqIHBsdXMgb25lIGV4dHJhIGNoYW5uZWwgc3BlY2lmaWVkIGJ5IGZyZXEuCiAJICoKQEAgLTM3Nyw3ICszOTEsNyBAQAogCSAqLwogCWludCAoKnAycF9zY2FuKSh2b2lkICpjdHgsIGVudW0gcDJwX3NjYW5fdHlwZSB0eXBlLCBpbnQgZnJlcSwKIAkJCXVuc2lnbmVkIGludCBudW1fcmVxX2Rldl90eXBlcywKLQkJCWNvbnN0IHU4ICpyZXFfZGV2X3R5cGVzLCBjb25zdCB1OCAqZGV2X2lkKTsKKwkJCWNvbnN0IHU4ICpyZXFfZGV2X3R5cGVzLCBjb25zdCB1OCAqZGV2X2lkLCB1MTYgcHdfaWQpOwogCiAJLyoqCiAJICogc2VuZF9wcm9iZV9yZXNwIC0gVHJhbnNtaXQgYSBQcm9iZSBSZXNwb25zZSBmcmFtZQpAQCAtODYxLDEyICs4NzUsMjAgQEAKICAqIEBwZXJzaXN0ZW50X2dyb3VwOiBXaGV0aGVyIHRvIGNyZWF0ZSBhIHBlcnNpc3RlbnQgZ3JvdXAgKDAgPSBubywgMSA9CiAgKiBwZXJzaXN0ZW50IGdyb3VwIHdpdGhvdXQgcGVyc2lzdGVudCByZWNvbm5lY3QsIDIgPSBwZXJzaXN0ZW50IGdyb3VwIHdpdGgKICAqIHBlcnNpc3RlbnQgcmVjb25uZWN0KQorICogQGZvcmNlX3NzaWQ6IEZvcmNlZCBTU0lEIGZvciB0aGUgZ3JvdXAgaWYgd2UgYmVjb21lIEdPIG9yICVOVUxMIHRvIGdlbmVyYXRlCisgKglhIG5ldyBTU0lECisgKiBAZm9yY2Vfc3NpZF9sZW46IExlbmd0aCBvZiAkZm9yY2Vfc3NpZCBidWZmZXIKKyAqIEBwZF9iZWZvcmVfZ29fbmVnOiBXaGV0aGVyIHRvIHNlbmQgUHJvdmlzaW9uIERpc2NvdmVyeSBwcmlvciB0byBHTworICoJTmVnb3RpYXRpb24gYXMgYW4gaW50ZXJvcGVyYWJpbGl0eSB3b3JrYXJvdW5kIHdoZW4gaW5pdGlhdGluZyBncm91cAorICoJZm9ybWF0aW9uCiAgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUKICAqLwogaW50IHAycF9jb25uZWN0KHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqcGVlcl9hZGRyLAogCQllbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCiAJCWludCBnb19pbnRlbnQsIGNvbnN0IHU4ICpvd25faW50ZXJmYWNlX2FkZHIsCi0JCXVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBpbnQgcGVyc2lzdGVudF9ncm91cCk7CisJCXVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBpbnQgcGVyc2lzdGVudF9ncm91cCwKKwkJY29uc3QgdTggKmZvcmNlX3NzaWQsIHNpemVfdCBmb3JjZV9zc2lkX2xlbiwKKwkJaW50IHBkX2JlZm9yZV9nb19uZWcpOwogCiAvKioKICAqIHAycF9hdXRob3JpemUgLSBBdXRob3JpemUgUDJQIGdyb3VwIGZvcm1hdGlvbiAoR08gbmVnb3RpYXRpb24pCkBAIC04NzksNiArOTAxLDkgQEAKICAqIEBwZXJzaXN0ZW50X2dyb3VwOiBXaGV0aGVyIHRvIGNyZWF0ZSBhIHBlcnNpc3RlbnQgZ3JvdXAgKDAgPSBubywgMSA9CiAgKiBwZXJzaXN0ZW50IGdyb3VwIHdpdGhvdXQgcGVyc2lzdGVudCByZWNvbm5lY3QsIDIgPSBwZXJzaXN0ZW50IGdyb3VwIHdpdGgKICAqIHBlcnNpc3RlbnQgcmVjb25uZWN0KQorICogQGZvcmNlX3NzaWQ6IEZvcmNlZCBTU0lEIGZvciB0aGUgZ3JvdXAgaWYgd2UgYmVjb21lIEdPIG9yICVOVUxMIHRvIGdlbmVyYXRlCisgKglhIG5ldyBTU0lECisgKiBAZm9yY2Vfc3NpZF9sZW46IExlbmd0aCBvZiAkZm9yY2Vfc3NpZCBidWZmZXIKICAqIFJldHVybnM6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZQogICoKICAqIFRoaXMgaXMgbGlrZSBwMnBfY29ubmVjdCgpLCBidXQgdGhlIGFjdHVhbCBncm91cCBuZWdvdGlhdGlvbiBpcyBub3QKQEAgLTg4Nyw3ICs5MTIsOCBAQAogaW50IHAycF9hdXRob3JpemUoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICpwZWVyX2FkZHIsCiAJCSAgZW51bSBwMnBfd3BzX21ldGhvZCB3cHNfbWV0aG9kLAogCQkgIGludCBnb19pbnRlbnQsIGNvbnN0IHU4ICpvd25faW50ZXJmYWNlX2FkZHIsCi0JCSAgdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwKTsKKwkJICB1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgaW50IHBlcnNpc3RlbnRfZ3JvdXAsCisJCSAgY29uc3QgdTggKmZvcmNlX3NzaWQsIHNpemVfdCBmb3JjZV9zc2lkX2xlbik7CiAKIC8qKgogICogcDJwX3JlamVjdCAtIFJlamVjdCBwZWVyIGRldmljZSAoZXhwbGljaXRseSBibG9jayBjb25uZWN0aW9uIGF0dGVtcHRzKQpAQCAtMTA2MCwxNyArMTA4NiwzNCBAQAogLyoqCiAgKiBwMnBfY2xlYXJfcHJvdmlzaW9uaW5nX2luZm8gLSBDbGVhciBhbnkgc3RvcmVkIHByb3Zpc2lvbmluZyBpbmZvCiAgKiBAcDJwOiBQMlAgbW9kdWxlIGNvbnRleHQgZnJvbSBwMnBfaW5pdCgpCi0gKiBAaWZhY2VfYWRkcjogUGVlciBQMlAgSW50ZXJmYWNlIEFkZHJlc3MKKyAqIEBpZmFjZV9hZGRyOiBQZWVyIFAyUCBEZXZpY2UgQWRkcmVzcwogICoKICAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byBjbGVhciBzdG9yZWQgV1BTIHByb3Zpc2lvbmluZyBpbmZvIGZvciB0aGUgZ2l2ZW4KICAqIHBlZXIuCiAgKi8KLXZvaWQgcDJwX2NsZWFyX3Byb3Zpc2lvbmluZ19pbmZvKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBjb25zdCB1OCAqaWZhY2VfYWRkcik7Cit2b2lkIHAycF9jbGVhcl9wcm92aXNpb25pbmdfaW5mbyhzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmFkZHIpOwogCiAKIC8qIEV2ZW50IG5vdGlmaWNhdGlvbnMgZnJvbSBsb3dlciBsYXllciBkcml2ZXIgb3BlcmF0aW9ucyAqLwogCiAvKioKKyAqIGVudW0gcDJwX3Byb2JlX3JlcV9zdGF0dXMKKyAqCisgKiBAUDJQX1BSRVFfTUFMRk9STUVEOiBmcmFtZSB3YXMgbm90IHdlbGwtZm9ybWVkCisgKiBAUDJQX1BSRVFfTk9UX0xJU1RFTjogZGV2aWNlIGlzbid0IGluIGxpc3RlbiBzdGF0ZSwgZnJhbWUgaWdub3JlZAorICogQFAyUF9QUkVRX05PVF9QMlA6IGZyYW1lIHdhcyBub3QgYSBQMlAgcHJvYmUgcmVxdWVzdAorICogQFAyUF9QUkVRX1AyUF9OT1RfUFJPQ0VTU0VEOiBmcmFtZSB3YXMgUDJQIGJ1dCB3YXNuJ3QgcHJvY2Vzc2VkCisgKiBAUDJQX1BSRVFfUDJQX1BST0NFU1NFRDogZnJhbWUgaGFzIGJlZW4gcHJvY2Vzc2VkIGJ5IFAyUAorICovCitlbnVtIHAycF9wcm9iZV9yZXFfc3RhdHVzIHsKKwlQMlBfUFJFUV9NQUxGT1JNRUQsCisJUDJQX1BSRVFfTk9UX0xJU1RFTiwKKwlQMlBfUFJFUV9OT1RfUDJQLAorCVAyUF9QUkVRX05PVF9QUk9DRVNTRUQsCisJUDJQX1BSRVFfUFJPQ0VTU0VECit9OworCisvKioKICAqIHAycF9wcm9iZV9yZXFfcnggLSBSZXBvcnQgcmVjZXB0aW9uIG9mIGEgUHJvYmUgUmVxdWVzdCBmcmFtZQogICogQHAycDogUDJQIG1vZHVsZSBjb250ZXh0IGZyb20gcDJwX2luaXQoKQogICogQGFkZHI6IFNvdXJjZSBNQUMgYWRkcmVzcwpAQCAtMTA3OCwxMCArMTEyMSwxMSBAQAogICogQGJzc2lkOiBCU1NJRCBpZiBhdmFpbGFibGUgb3IgJU5VTEwKICAqIEBpZTogSW5mb3JtYXRpb24gZWxlbWVudHMgZnJvbSB0aGUgUHJvYmUgUmVxdWVzdCBmcmFtZSBib2R5CiAgKiBAaWVfbGVuOiBMZW5ndGggb2YgaWUgYnVmZmVyIGluIG9jdGV0cwotICogUmV0dXJuczogMCB0byBpbmRpY2F0ZSB0aGUgZnJhbWUgd2FzIG5vdCBwcm9jZXNzZWQgb3IgMSBpZiBpdCB3YXMKKyAqIFJldHVybnM6IHZhbHVlIGluZGljYXRpbmcgdGhlIHR5cGUgYW5kIHN0YXR1cyBvZiB0aGUgcHJvYmUgcmVxdWVzdAogICovCi1pbnQgcDJwX3Byb2JlX3JlcV9yeChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkc3QsCi0JCSAgICAgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pOworZW51bSBwMnBfcHJvYmVfcmVxX3N0YXR1cworcDJwX3Byb2JlX3JlcV9yeChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkc3QsCisJCSBjb25zdCB1OCAqYnNzaWQsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbik7CiAKIC8qKgogICogcDJwX3J4X2FjdGlvbiAtIFJlcG9ydCByZWNlaXZlZCBBY3Rpb24gZnJhbWUKQEAgLTEyMjAsNiArMTI2NCwxNiBAQAogCXVuc2lnbmVkIGludCBtYXhfY2xpZW50czsKIAogCS8qKgorCSAqIHNzaWQgLSBHcm91cCBTU0lECisJICovCisJdTggc3NpZFszMl07CisKKwkvKioKKwkgKiBzc2lkX2xlbiAtIExlbmd0aCBvZiBTU0lECisJICovCisJc2l6ZV90IHNzaWRfbGVuOworCisJLyoqCiAJICogY2JfY3R4IC0gQ29udGV4dCB0byB1c2Ugd2l0aCBjYWxsYmFjayBmdW5jdGlvbnMKIAkgKi8KIAl2b2lkICpjYl9jdHg7CkBAIC0xMzcxLDYgKzE0MjUsMTUgQEAKIGludCBwMnBfc2Nhbl9yZXN1bHRfdGV4dChjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbiwgY2hhciAqYnVmLCBjaGFyICplbmQpOwogCiAvKioKKyAqIHAycF9wYXJzZV9kZXZfYWRkcl9pbl9wMnBfaWUgLSBQYXJzZSBQMlAgRGV2aWNlIEFkZHJlc3MgZnJvbSBhIGNvbmNhdGVuYXRlZAorICogUDJQIElFCisgKiBAcDJwX2llOiBQMlAgSUUKKyAqIEBkZXZfYWRkcjogQnVmZmVyIGZvciByZXR1cm5pbmcgUDJQIERldmljZSBBZGRyZXNzCisgKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3Mgb3IgLTEgaWYgUDJQIERldmljZSBBZGRyZXNzIGNvdWxkIG5vdCBiZSBwYXJzZWQKKyAqLworaW50IHAycF9wYXJzZV9kZXZfYWRkcl9pbl9wMnBfaWUoc3RydWN0IHdwYWJ1ZiAqcDJwX2llLCB1OCAqZGV2X2FkZHIpOworCisvKioKICAqIHAycF9wYXJzZV9kZXZfYWRkciAtIFBhcnNlIFAyUCBEZXZpY2UgQWRkcmVzcyBmcm9tIFAyUCBJRShzKQogICogQGllczogSW5mb3JtYXRpb24gZWxlbWVudHMgZnJvbSBzY2FuIHJlc3VsdHMKICAqIEBpZXNfbGVuOiBpZXMgYnVmZmVyIGxlbmd0aCBpbiBvY3RldHMKQEAgLTE2MDgsNiArMTY3MSwxNiBAQAogCQkJIGludCBjZmdfb3BfY2hhbm5lbCk7CiAKIC8qKgorICogcDJwX3NldF9wcmVmX2NoYW4gLSBTZXQgUDJQIHByZWZlcnJlZCBjaGFubmVsIGxpc3QKKyAqIEBwMnA6IFAyUCBtb2R1bGUgY29udGV4dCBmcm9tIHAycF9pbml0KCkKKyAqIEBudW1fcHJlZl9jaGFuOiBOdW1iZXIgb2YgZW50cmllcyBpbiBwcmVmX2NoYW4gbGlzdAorICogQHByZWZfY2hhbjogUHJlZmVycmVkIGNoYW5uZWxzIG9yICVOVUxMIHRvIHJlbW92ZSBwcmVmZXJlbmNlcworICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlCisgKi8KK2ludCBwMnBfc2V0X3ByZWZfY2hhbihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgdW5zaWduZWQgaW50IG51bV9wcmVmX2NoYW4sCisJCSAgICAgIGNvbnN0IHN0cnVjdCBwMnBfY2hhbm5lbCAqcHJlZl9jaGFuKTsKKworLyoqCiAgKiBwMnBfaW5fcHJvZ3Jlc3MgLSBDaGVjayB3aGV0aGVyIGEgUDJQIG9wZXJhdGlvbiBpcyBwcm9ncmVzcwogICogQHAycDogUDJQIG1vZHVsZSBjb250ZXh0IGZyb20gcDJwX2luaXQoKQogICogUmV0dXJuczogMCBpZiBQMlAgbW9kdWxlIGlzIGlkbGUgb3IgMSBpZiBhbiBvcGVyYXRpb24gaXMgaW4gcHJvZ3Jlc3MKZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX2J1aWxkLmMgYi9zcmMvcDJwL3AycF9idWlsZC5jCmluZGV4IDIxMDY5NjQuLmRlZjQyMmQgMTAwNjQ0Ci0tLSBhL3NyYy9wMnAvcDJwX2J1aWxkLmMKKysrIGIvc3JjL3AycC9wMnBfYnVpbGQuYwpAQCAtMzUxLDcgKzM1MSw3IEBACiB9CiAKIAotdm9pZCBwMnBfYnVpbGRfd3BzX2llKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBzdHJ1Y3Qgd3BhYnVmICpidWYsIHUxNiBwd19pZCwKK3ZvaWQgcDJwX2J1aWxkX3dwc19pZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHdwYWJ1ZiAqYnVmLCBpbnQgcHdfaWQsCiAJCSAgICAgIGludCBhbGxfYXR0cikKIHsKIAl1OCAqbGVuOwpAQCAtMzY5LDExICszNjksMTQgQEAKIAkJd3BhYnVmX3B1dF91OChidWYsIFdQU19TVEFURV9OT1RfQ09ORklHVVJFRCk7CiAJfQogCi0JLyogRGV2aWNlIFBhc3N3b3JkIElEICovCi0Jd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgQVRUUl9ERVZfUEFTU1dPUkRfSUQpOwotCXdwYWJ1Zl9wdXRfYmUxNihidWYsIDIpOwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBXUFMgSUUgRGV2aWNlIFBhc3N3b3JkIElEOiAlZCIsIHB3X2lkKTsKLQl3cGFidWZfcHV0X2JlMTYoYnVmLCBwd19pZCk7CisJaWYgKHB3X2lkID49IDApIHsKKwkJLyogRGV2aWNlIFBhc3N3b3JkIElEICovCisJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIEFUVFJfREVWX1BBU1NXT1JEX0lEKTsKKwkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgMik7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBXUFMgSUUgRGV2aWNlIFBhc3N3b3JkIElEOiAlZCIsCisJCQkgICBwd19pZCk7CisJCXdwYWJ1Zl9wdXRfYmUxNihidWYsIHB3X2lkKTsKKwl9CiAKIAlpZiAoYWxsX2F0dHIpIHsKIAkJd3BhYnVmX3B1dF9iZTE2KGJ1ZiwgQVRUUl9SRVNQT05TRV9UWVBFKTsKZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX2dvX25lZy5jIGIvc3JjL3AycC9wMnBfZ29fbmVnLmMKaW5kZXggNmU4MThjMi4uMjQ4YjJhMCAxMDA2NDQKLS0tIGEvc3JjL3AycC9wMnBfZ29fbmVnLmMKKysrIGIvc3JjL3AycC9wMnBfZ29fbmVnLmMKQEAgLTk4LDcgKzk4LDcgQEAKIH0KIAogCi1zdGF0aWMgdTE2IHAycF93cHNfbWV0aG9kX3B3X2lkKGVudW0gcDJwX3dwc19tZXRob2Qgd3BzX21ldGhvZCkKK3UxNiBwMnBfd3BzX21ldGhvZF9wd19pZChlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QpCiB7CiAJc3dpdGNoICh3cHNfbWV0aG9kKSB7CiAJY2FzZSBXUFNfUElOX0RJU1BMQVk6CkBAIC0xNTUsNyArMTU1LDkgQEAKIAkJZ3JvdXBfY2FwYWIgfD0gUDJQX0dST1VQX0NBUEFCX0NST1NTX0NPTk47CiAJaWYgKHAycC0+Y2ZnLT5wMnBfaW50cmFfYnNzKQogCQlncm91cF9jYXBhYiB8PSBQMlBfR1JPVVBfQ0FQQUJfSU5UUkFfQlNTX0RJU1Q7Ci0JcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiLCBncm91cF9jYXBhYik7CisJcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiICYKKwkJCSAgICAgICB+UDJQX0RFVl9DQVBBQl9DTElFTlRfRElTQ09WRVJBQklMSVRZLAorCQkJICAgICAgIGdyb3VwX2NhcGFiKTsKIAlwMnBfYnVmX2FkZF9nb19pbnRlbnQoYnVmLCAocDJwLT5nb19pbnRlbnQgPDwgMSkgfAogCQkJICAgICAgcDJwLT5uZXh0X3RpZV9icmVha2VyKTsKIAlwMnAtPm5leHRfdGllX2JyZWFrZXIgPSAhcDJwLT5uZXh0X3RpZV9icmVha2VyOwpAQCAtMTg0LDYgKzE4NiwyMyBAQAogCXN0cnVjdCB3cGFidWYgKnJlcTsKIAlpbnQgZnJlcTsKIAorCWlmIChkZXYtPmZsYWdzICYgUDJQX0RFVl9QRF9CRUZPUkVfR09fTkVHKSB7CisJCXUxNiBjb25maWdfbWV0aG9kOworCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCisJCQkiUDJQOiBVc2UgUEQtYmVmb3JlLUdPLU5lZyB3b3JrYXJvdW5kIGZvciAiIE1BQ1NUUiwKKwkJCU1BQzJTVFIoZGV2LT5pbmZvLnAycF9kZXZpY2VfYWRkcikpOworCQlpZiAoZGV2LT53cHNfbWV0aG9kID09IFdQU19QSU5fRElTUExBWSkKKwkJCWNvbmZpZ19tZXRob2QgPSBXUFNfQ09ORklHX0tFWVBBRDsKKwkJZWxzZSBpZiAoZGV2LT53cHNfbWV0aG9kID09IFdQU19QSU5fS0VZUEFEKQorCQkJY29uZmlnX21ldGhvZCA9IFdQU19DT05GSUdfRElTUExBWTsKKwkJZWxzZSBpZiAoZGV2LT53cHNfbWV0aG9kID09IFdQU19QQkMpCisJCQljb25maWdfbWV0aG9kID0gV1BTX0NPTkZJR19QVVNIQlVUVE9OOworCQllbHNlCisJCQlyZXR1cm4gLTE7CisJCXJldHVybiBwMnBfcHJvdl9kaXNjX3JlcShwMnAsIGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCisJCQkJCSBjb25maWdfbWV0aG9kLCAwLCAwKTsKKwl9CisKIAlmcmVxID0gZGV2LT5saXN0ZW5fZnJlcSA+IDAgPyBkZXYtPmxpc3Rlbl9mcmVxIDogZGV2LT5vcGVyX2ZyZXE7CiAJaWYgKGZyZXEgPD0gMCkgewogCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCkBAIC0yMDMsOSArMjIyLDYgQEAKIAlwMnAtPmdvX25lZ19wZWVyID0gZGV2OwogCWRldi0+ZmxhZ3MgfD0gUDJQX0RFVl9XQUlUX0dPX05FR19SRVNQT05TRTsKIAlkZXYtPmNvbm5lY3RfcmVxcysrOwotI2lmZGVmIEFORFJPSURfUDJQCi0JZGV2LT5nb19uZWdfcmVxX3NlbnQrKzsKLSNlbmRpZgogCWlmIChwMnBfc2VuZF9hY3Rpb24ocDJwLCBmcmVxLCBkZXYtPmluZm8ucDJwX2RldmljZV9hZGRyLAogCQkJICAgIHAycC0+Y2ZnLT5kZXZfYWRkciwgZGV2LT5pbmZvLnAycF9kZXZpY2VfYWRkciwKIAkJCSAgICB3cGFidWZfaGVhZChyZXEpLCB3cGFidWZfbGVuKHJlcSksIDIwMCkgPCAwKSB7CkBAIC0yMTMsNyArMjI5LDggQEAKIAkJCSJQMlA6IEZhaWxlZCB0byBzZW5kIEFjdGlvbiBmcmFtZSIpOwogCQkvKiBVc2UgUDJQIGZpbmQgdG8gcmVjb3ZlciBhbmQgcmV0cnkgKi8KIAkJcDJwX3NldF90aW1lb3V0KHAycCwgMCwgMCk7Ci0JfQorCX0gZWxzZQorCQlkZXYtPmdvX25lZ19yZXFfc2VudCsrOwogCiAJd3BhYnVmX2ZyZWUocmVxKTsKIApAQCAtMjUzLDcgKzI3MCw5IEBACiAJCWlmIChwMnAtPmNmZy0+cDJwX2ludHJhX2JzcykKIAkJCWdyb3VwX2NhcGFiIHw9IFAyUF9HUk9VUF9DQVBBQl9JTlRSQV9CU1NfRElTVDsKIAl9Ci0JcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiLCBncm91cF9jYXBhYik7CisJcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiICYKKwkJCSAgICAgICB+UDJQX0RFVl9DQVBBQl9DTElFTlRfRElTQ09WRVJBQklMSVRZLAorCQkJICAgICAgIGdyb3VwX2NhcGFiKTsKIAlwMnBfYnVmX2FkZF9nb19pbnRlbnQoYnVmLCAocDJwLT5nb19pbnRlbnQgPDwgMSkgfCB0aWVfYnJlYWtlcik7CiAJcDJwX2J1Zl9hZGRfY29uZmlnX3RpbWVvdXQoYnVmLCAxMDAsIDIwKTsKIAlpZiAocGVlciAmJiBwZWVyLT5nb19zdGF0ZSA9PSBSRU1PVEVfR08pIHsKQEAgLTI5OSw2ICszMTgsNyBAQAogCXN0cnVjdCBwMnBfcmVnX2NsYXNzICpjbDsKIAlpbnQgZnJlcTsKIAl1OCBvcF9yZWdfY2xhc3MsIG9wX2NoYW5uZWw7CisJdW5zaWduZWQgaW50IGk7CiAKIAl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IFNlbGVjdGVkIG9wZXJhdGluZyAiCiAJCSJjaGFubmVsIChyZWdfY2xhc3MgJXUgY2hhbm5lbCAldSkgbm90IGFjY2VwdGFibGUgdG8gdGhlICIKQEAgLTMzMSw2ICszNTEsMjEgQEAKIAkJcmV0dXJuOwogCX0KIAorCS8qIFNlbGVjdCBjaGFubmVsIHdpdGggaGlnaGVzdCBwcmVmZXJlbmNlIGlmIHRoZSBwZWVyIHN1cHBvcnRzIGl0ICovCisJZm9yIChpID0gMDsgcDJwLT5jZmctPnByZWZfY2hhbiAmJiBpIDwgcDJwLT5jZmctPm51bV9wcmVmX2NoYW47IGkrKykgeworCQlpZiAocDJwX2NoYW5uZWxzX2luY2x1ZGVzKGludGVyc2VjdGlvbiwKKwkJCQkJICBwMnAtPmNmZy0+cHJlZl9jaGFuW2ldLm9wX2NsYXNzLAorCQkJCQkgIHAycC0+Y2ZnLT5wcmVmX2NoYW5baV0uY2hhbikpIHsKKwkJCXAycC0+b3BfcmVnX2NsYXNzID0gcDJwLT5jZmctPnByZWZfY2hhbltpXS5vcF9jbGFzczsKKwkJCXAycC0+b3BfY2hhbm5lbCA9IHAycC0+Y2ZnLT5wcmVmX2NoYW5baV0uY2hhbjsKKwkJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywgIlAyUDogUGljayAiCisJCQkJImhpZ2hlc3QgcHJlZmVycmVkIGNobm5lbCAob3BfY2xhc3MgJXUgIgorCQkJCSJjaGFubmVsICV1KSBmcm9tIGludGVyc2VjdGlvbiIsCisJCQkJcDJwLT5vcF9yZWdfY2xhc3MsIHAycC0+b3BfY2hhbm5lbCk7CisJCQlyZXR1cm47CisJCX0KKwl9CisKIAkvKgogCSAqIEZhbGwgYmFjayB0byB3aGF0ZXZlciBpcyBpbmNsdWRlZCBpbiB0aGUgY2hhbm5lbCBpbnRlcnNlY3Rpb24gc2luY2UKIAkgKiBubyBiZXR0ZXIgb3B0aW9ucyBzZWVtcyB0byBiZSBhdmFpbGFibGUuCkBAIC02NDEsNiArNjc2LDE3IEBACiAJaWYgKHN0YXR1cyA9PSBQMlBfU0NfU1VDQ0VTUykgewogCQlwMnAtPnBlbmRpbmdfYWN0aW9uX3N0YXRlID0gUDJQX1BFTkRJTkdfR09fTkVHX1JFU1BPTlNFOwogCQlkZXYtPmZsYWdzIHw9IFAyUF9ERVZfV0FJVF9HT19ORUdfQ09ORklSTTsKKwkJaWYgKG9zX21lbWNtcChzYSwgcDJwLT5jZmctPmRldl9hZGRyLCBFVEhfQUxFTikgPCAwKSB7CisJCQkvKgorCQkJICogUGVlciBoYXMgc21hbGxlciBhZGRyZXNzLCBzbyB0aGUgR08gTmVnb3RpYXRpb24KKwkJCSAqIFJlc3BvbnNlIGZyb20gdXMgaXMgZXhwZWN0ZWQgdG8gY29tcGxldGUKKwkJCSAqIG5lZ290aWF0aW9uLiBJZ25vcmUgYSBHTyBOZWdvdGlhdGlvbiBSZXNwb25zZSBmcm9tCisJCQkgKiB0aGUgcGVlciBpZiBpdCBoYXBwZW5zIHRvIGJlIHJlY2VpdmVkIGFmdGVyIHRoaXMKKwkJCSAqIHBvaW50IGR1ZSB0byBhIHJhY2UgY29uZGl0aW9uIGluIEdPIE5lZ290aWF0aW9uCisJCQkgKiBSZXF1ZXN0IHRyYW5zbWlzc2lvbiBhbmQgcHJvY2Vzc2luZy4KKwkJCSAqLworCQkJZGV2LT5mbGFncyAmPSB+UDJQX0RFVl9XQUlUX0dPX05FR19SRVNQT05TRTsKKwkJfQogCX0gZWxzZQogCQlwMnAtPnBlbmRpbmdfYWN0aW9uX3N0YXRlID0KIAkJCVAyUF9QRU5ESU5HX0dPX05FR19SRVNQT05TRV9GQUlMVVJFOwpAQCAtNjg4LDcgKzczNCw5IEBACiAJCWlmIChwMnAtPmNmZy0+cDJwX2ludHJhX2JzcykKIAkJCWdyb3VwX2NhcGFiIHw9IFAyUF9HUk9VUF9DQVBBQl9JTlRSQV9CU1NfRElTVDsKIAl9Ci0JcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiLCBncm91cF9jYXBhYik7CisJcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiICYKKwkJCSAgICAgICB+UDJQX0RFVl9DQVBBQl9DTElFTlRfRElTQ09WRVJBQklMSVRZLAorCQkJICAgICAgIGdyb3VwX2NhcGFiKTsKIAlpZiAoZ28gfHwgcmVzcF9jaGFuID09IE5VTEwpCiAJCXAycF9idWZfYWRkX29wZXJhdGluZ19jaGFubmVsKGJ1ZiwgcDJwLT5jZmctPmNvdW50cnksCiAJCQkJCSAgICAgIHAycC0+b3BfcmVnX2NsYXNzLApAQCAtOTkyLDcgKzEwNDAsNyBAQAogCWVsc2UKIAkJZnJlcSA9IGRldi0+bGlzdGVuX2ZyZXE7CiAJaWYgKHAycF9zZW5kX2FjdGlvbihwMnAsIGZyZXEsIHNhLCBwMnAtPmNmZy0+ZGV2X2FkZHIsIHNhLAotCQkJICAgIHdwYWJ1Zl9oZWFkKGNvbmYpLCB3cGFidWZfbGVuKGNvbmYpLCAyMDApIDwgMCkgeworCQkJICAgIHdwYWJ1Zl9oZWFkKGNvbmYpLCB3cGFidWZfbGVuKGNvbmYpLCAwKSA8IDApIHsKIAkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0RFQlVHLAogCQkJIlAyUDogRmFpbGVkIHRvIHNlbmQgQWN0aW9uIGZyYW1lIik7CiAJCXAycF9nb19uZWdfZmFpbGVkKHAycCwgZGV2LCAtMSk7CmRpZmYgLS1naXQgYS9zcmMvcDJwL3AycF9ncm91cC5jIGIvc3JjL3AycC9wMnBfZ3JvdXAuYwppbmRleCBmYWZkMTM1Li44ZDRhM2NiIDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9ncm91cC5jCisrKyBiL3NyYy9wMnAvcDJwX2dyb3VwLmMKQEAgLTEzNSwxMSArMTM1LDEwIEBACiBzdGF0aWMgdm9pZCBwMnBfZ3JvdXBfYWRkX2NvbW1vbl9pZXMoc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsCiAJCQkJICAgICBzdHJ1Y3Qgd3BhYnVmICppZSkKIHsKLQl1OCBkZXZfY2FwYWIgPSAwLCBncm91cF9jYXBhYiA9IDA7CisJdTggZGV2X2NhcGFiID0gZ3JvdXAtPnAycC0+ZGV2X2NhcGFiLCBncm91cF9jYXBhYiA9IDA7CiAKIAkvKiBQMlAgQ2FwYWJpbGl0eSAqLwotCWRldl9jYXBhYiB8PSBQMlBfREVWX0NBUEFCX1NFUlZJQ0VfRElTQ09WRVJZOwotCWRldl9jYXBhYiB8PSBQMlBfREVWX0NBUEFCX0lOVklUQVRJT05fUFJPQ0VEVVJFOworCWRldl9jYXBhYiAmPSB+UDJQX0RFVl9DQVBBQl9DTElFTlRfRElTQ09WRVJBQklMSVRZOwogCWdyb3VwX2NhcGFiIHw9IFAyUF9HUk9VUF9DQVBBQl9HUk9VUF9PV05FUjsKIAlpZiAoZ3JvdXAtPmNmZy0+cGVyc2lzdGVudF9ncm91cCkgewogCQlncm91cF9jYXBhYiB8PSBQMlBfR1JPVVBfQ0FQQUJfUEVSU0lTVEVOVF9HUk9VUDsKQEAgLTczMSwzICs3MzAsMTUgQEAKIAogCXJldHVybiAwOwogfQorCisKK2ludCBwMnBfZ3JvdXBfaXNfZ3JvdXBfaWRfbWF0Y2goc3RydWN0IHAycF9ncm91cCAqZ3JvdXAsIGNvbnN0IHU4ICpncm91cF9pZCwKKwkJCQlzaXplX3QgZ3JvdXBfaWRfbGVuKQoreworCWlmIChncm91cF9pZF9sZW4gIT0gRVRIX0FMRU4gKyBncm91cC0+Y2ZnLT5zc2lkX2xlbikKKwkJcmV0dXJuIDA7CisJaWYgKG9zX21lbWNtcChncm91cF9pZCwgZ3JvdXAtPnAycC0+Y2ZnLT5kZXZfYWRkciwgRVRIX0FMRU4pICE9IDApCisJCXJldHVybiAwOworCXJldHVybiBvc19tZW1jbXAoZ3JvdXBfaWQgKyBFVEhfQUxFTiwgZ3JvdXAtPmNmZy0+c3NpZCwKKwkJCSBncm91cC0+Y2ZnLT5zc2lkX2xlbikgPT0gMDsKK30KZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX2kuaCBiL3NyYy9wMnAvcDJwX2kuaAppbmRleCA0Y2NkMzhkLi41ZTIxMjQ5IDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9pLmgKKysrIGIvc3JjL3AycC9wMnBfaS5oCkBAIC05MCw2ICs5MCw3IEBACiAjZGVmaW5lIFAyUF9ERVZfUERfRk9SX0pPSU4gQklUKDE0KQogI2RlZmluZSBQMlBfREVWX1JFUE9SVEVEX09OQ0UgQklUKDE1KQogI2RlZmluZSBQMlBfREVWX1BSRUZFUl9QRVJTSVNURU5UX1JFQ09OTiBCSVQoMTYpCisjZGVmaW5lIFAyUF9ERVZfUERfQkVGT1JFX0dPX05FRyBCSVQoMTcpCiAJdW5zaWduZWQgaW50IGZsYWdzOwogCiAJaW50IHN0YXR1czsgLyogZW51bSBwMnBfc3RhdHVzX2NvZGUgKi8KQEAgLTU1Nyw2ICs1NTgsOCBAQAogdTggcDJwX2dyb3VwX3ByZXNlbmNlX3JlcShzdHJ1Y3QgcDJwX2dyb3VwICpncm91cCwKIAkJCSAgY29uc3QgdTggKmNsaWVudF9pbnRlcmZhY2VfYWRkciwKIAkJCSAgY29uc3QgdTggKm5vYSwgc2l6ZV90IG5vYV9sZW4pOworaW50IHAycF9ncm91cF9pc19ncm91cF9pZF9tYXRjaChzdHJ1Y3QgcDJwX2dyb3VwICpncm91cCwgY29uc3QgdTggKmdyb3VwX2lkLAorCQkJCXNpemVfdCBncm91cF9pZF9sZW4pOwogCiAKIHZvaWQgcDJwX2J1Zl9hZGRfYWN0aW9uX2hkcihzdHJ1Y3Qgd3BhYnVmICpidWYsIHU4IHN1YnR5cGUsIHU4IGRpYWxvZ190b2tlbik7CkBAIC01ODgsNyArNTkxLDcgQEAKIHZvaWQgcDJwX2J1Zl9hZGRfZXh0X2xpc3Rlbl90aW1pbmcoc3RydWN0IHdwYWJ1ZiAqYnVmLCB1MTYgcGVyaW9kLAogCQkJCSAgIHUxNiBpbnRlcnZhbCk7CiB2b2lkIHAycF9idWZfYWRkX3AycF9pbnRlcmZhY2Uoc3RydWN0IHdwYWJ1ZiAqYnVmLCBzdHJ1Y3QgcDJwX2RhdGEgKnAycCk7Ci12b2lkIHAycF9idWlsZF93cHNfaWUoc3RydWN0IHAycF9kYXRhICpwMnAsIHN0cnVjdCB3cGFidWYgKmJ1ZiwgdTE2IHB3X2lkLAordm9pZCBwMnBfYnVpbGRfd3BzX2llKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCBzdHJ1Y3Qgd3BhYnVmICpidWYsIGludCBwd19pZCwKIAkJICAgICAgaW50IGFsbF9hdHRyKTsKIAogLyogcDJwX3NkLmMgKi8KQEAgLTYxNiw2ICs2MTksNyBAQAogdm9pZCBwMnBfcHJvY2Vzc19nb19uZWdfY29uZihzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKnNhLAogCQkJICAgICBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbik7CiBpbnQgcDJwX2Nvbm5lY3Rfc2VuZChzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgc3RydWN0IHAycF9kZXZpY2UgKmRldik7Cit1MTYgcDJwX3dwc19tZXRob2RfcHdfaWQoZW51bSBwMnBfd3BzX21ldGhvZCB3cHNfbWV0aG9kKTsKIAogLyogcDJwX3BkLmMgKi8KIHZvaWQgcDJwX3Byb2Nlc3NfcHJvdl9kaXNjX3JlcShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKnNhLApAQCAtNjYwLDcgKzY2NCw3IEBACiB2b2lkIHAycF9hZGRfZGV2X2luZm8oc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLAogCQkgICAgICBzdHJ1Y3QgcDJwX2RldmljZSAqZGV2LCBzdHJ1Y3QgcDJwX21lc3NhZ2UgKm1zZyk7CiBpbnQgcDJwX2FkZF9kZXZpY2Uoc3RydWN0IHAycF9kYXRhICpwMnAsIGNvbnN0IHU4ICphZGRyLCBpbnQgZnJlcSwgaW50IGxldmVsLAotCQkgICBjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbik7CisJCSAgIGNvbnN0IHU4ICppZXMsIHNpemVfdCBpZXNfbGVuLCBpbnQgc2Nhbl9yZXMpOwogc3RydWN0IHAycF9kZXZpY2UgKiBwMnBfZ2V0X2RldmljZShzdHJ1Y3QgcDJwX2RhdGEgKnAycCwgY29uc3QgdTggKmFkZHIpOwogc3RydWN0IHAycF9kZXZpY2UgKiBwMnBfZ2V0X2RldmljZV9pbnRlcmZhY2Uoc3RydWN0IHAycF9kYXRhICpwMnAsCiAJCQkJCSAgICAgY29uc3QgdTggKmFkZHIpOwpAQCAtNjc1LDUgKzY3OSw2IEBACiBpbnQgcDJwX3NlbmRfYWN0aW9uKHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB1bnNpZ25lZCBpbnQgZnJlcSwgY29uc3QgdTggKmRzdCwKIAkJICAgIGNvbnN0IHU4ICpzcmMsIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmJ1ZiwKIAkJICAgIHNpemVfdCBsZW4sIHVuc2lnbmVkIGludCB3YWl0X3RpbWUpOwordm9pZCBwMnBfc3RvcF9saXN0ZW5fZm9yX2ZyZXEoc3RydWN0IHAycF9kYXRhICpwMnAsIGludCBmcmVxKTsKIAogI2VuZGlmIC8qIFAyUF9JX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9wMnAvcDJwX2ludml0YXRpb24uYyBiL3NyYy9wMnAvcDJwX2ludml0YXRpb24uYwppbmRleCA0MTdmMWU3Li41OTI1NTQ5IDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9pbnZpdGF0aW9uLmMKKysrIGIvc3JjL3AycC9wMnBfaW52aXRhdGlvbi5jCkBAIC0xMjEsNyArMTIxLDggQEAKIAkJCSJQMlA6IEludml0YXRpb24gUmVxdWVzdCBmcm9tIHVua25vd24gcGVlciAiCiAJCQlNQUNTVFIsIE1BQzJTVFIoc2EpKTsKIAotCQlpZiAocDJwX2FkZF9kZXZpY2UocDJwLCBzYSwgcnhfZnJlcSwgMCwgZGF0YSArIDEsIGxlbiAtIDEpKSB7CisJCWlmIChwMnBfYWRkX2RldmljZShwMnAsIHNhLCByeF9mcmVxLCAwLCBkYXRhICsgMSwgbGVuIC0gMSwgMCkpCisJCXsKIAkJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKIAkJCQkiUDJQOiBJbnZpdGF0aW9uIFJlcXVlc3QgYWRkIGRldmljZSBmYWlsZWQgIgogCQkJCU1BQ1NUUiwgTUFDMlNUUihzYSkpOwpAQCAtMzQ0LDYgKzM0NSw4IEBACiAJcmVxID0gcDJwX2J1aWxkX2ludml0YXRpb25fcmVxKHAycCwgZGV2LCBnb19kZXZfYWRkcik7CiAJaWYgKHJlcSA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CisJaWYgKHAycC0+c3RhdGUgIT0gUDJQX0lETEUpCisJCXAycF9zdG9wX2xpc3Rlbl9mb3JfZnJlcShwMnAsIGZyZXEpOwogCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKIAkJIlAyUDogU2VuZGluZyBJbnZpdGF0aW9uIFJlcXVlc3QiKTsKIAlwMnBfc2V0X3N0YXRlKHAycCwgUDJQX0lOVklURSk7CmRpZmYgLS1naXQgYS9zcmMvcDJwL3AycF9wZC5jIGIvc3JjL3AycC9wMnBfcGQuYwppbmRleCA1NWEzYjkwLi4zOGE5ZGQ4IDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9wZC5jCisrKyBiL3NyYy9wMnAvcDJwX3BkLmMKQEAgLTU0LDcgKzU0LDggQEAKIAlwMnBfYnVmX2FkZF9wdWJsaWNfYWN0aW9uX2hkcihidWYsIFAyUF9QUk9WX0RJU0NfUkVRLCBkaWFsb2dfdG9rZW4pOwogCiAJbGVuID0gcDJwX2J1Zl9hZGRfaWVfaGRyKGJ1Zik7Ci0JcDJwX2J1Zl9hZGRfY2FwYWJpbGl0eShidWYsIHAycC0+ZGV2X2NhcGFiLCAwKTsKKwlwMnBfYnVmX2FkZF9jYXBhYmlsaXR5KGJ1ZiwgcDJwLT5kZXZfY2FwYWIgJgorCQkJICAgICAgIH5QMlBfREVWX0NBUEFCX0NMSUVOVF9ESVNDT1ZFUkFCSUxJVFksIDApOwogCXAycF9idWZfYWRkX2RldmljZV9pbmZvKGJ1ZiwgcDJwLCBOVUxMKTsKIAlpZiAoZ28pIHsKIAkJcDJwX2J1Zl9hZGRfZ3JvdXBfaWQoYnVmLCBnby0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCkBAIC0xMTAsNyArMTExLDggQEAKIAkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0RFQlVHLAogCQkJIlAyUDogUHJvdmlzaW9uIERpc2NvdmVyeSBSZXF1ZXN0IGZyb20gIgogCQkJInVua25vd24gcGVlciAiIE1BQ1NUUiwgTUFDMlNUUihzYSkpOwotCQlpZiAocDJwX2FkZF9kZXZpY2UocDJwLCBzYSwgcnhfZnJlcSwgMCwgZGF0YSArIDEsIGxlbiAtIDEpKSB7CisJCWlmIChwMnBfYWRkX2RldmljZShwMnAsIHNhLCByeF9mcmVxLCAwLCBkYXRhICsgMSwgbGVuIC0gMSwgMCkpCisJCXsKIAkJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKIAkJCSAgICAgICAgIlAyUDogUHJvdmlzaW9uIERpc2NvdmVyeSBSZXF1ZXN0IGFkZCBkZXZpY2UgIgogCQkJCSJmYWlsZWQgIiBNQUNTVFIsIE1BQzJTVFIoc2EpKTsKQEAgLTEyNSw2ICsxMjcsMjEgQEAKIAkJZ290byBvdXQ7CiAJfQogCisJaWYgKG1zZy5ncm91cF9pZCkgeworCQlzaXplX3QgaTsKKwkJZm9yIChpID0gMDsgaSA8IHAycC0+bnVtX2dyb3VwczsgaSsrKSB7CisJCQlpZiAocDJwX2dyb3VwX2lzX2dyb3VwX2lkX21hdGNoKHAycC0+Z3JvdXBzW2ldLAorCQkJCQkJCW1zZy5ncm91cF9pZCwKKwkJCQkJCQltc2cuZ3JvdXBfaWRfbGVuKSkKKwkJCQlicmVhazsKKwkJfQorCQlpZiAoaSA9PSBwMnAtPm51bV9ncm91cHMpIHsKKwkJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywgIlAyUDogUEQgIgorCQkJCSJyZXF1ZXN0IGZvciB1bmtub3duIFAyUCBHcm91cCBJRCAtIHJlamVjdCIpOworCQkJZ290byBvdXQ7CisJCX0KKwl9CisKIAlpZiAoZGV2KQogCQlkZXYtPmZsYWdzICY9IH4oUDJQX0RFVl9QRF9QRUVSX0RJU1BMQVkgfAogCQkJCVAyUF9ERVZfUERfUEVFUl9LRVlQQUQpOwpAQCAtMTk4LDYgKzIxNSw3IEBACiAJc3RydWN0IHAycF9tZXNzYWdlIG1zZzsKIAlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OwogCXUxNiByZXBvcnRfY29uZmlnX21ldGhvZHMgPSAwOworCWludCBzdWNjZXNzID0gMDsKIAogCWlmIChwMnBfcGFyc2UoZGF0YSwgbGVuLCAmbXNnKSkKIAkJcmV0dXJuOwpAQCAtMjY2LDExICsyODQsMjEgQEAKIAlkZXYtPndwc19wcm92X2luZm8gPSBtc2cud3BzX2NvbmZpZ19tZXRob2RzOwogCiAJcDJwX3BhcnNlX2ZyZWUoJm1zZyk7CisJc3VjY2VzcyA9IDE7CiAKIG91dDoKIAlkZXYtPnJlcV9jb25maWdfbWV0aG9kcyA9IDA7CiAJcDJwLT5jZmctPnNlbmRfYWN0aW9uX2RvbmUocDJwLT5jZmctPmNiX2N0eCk7Ci0JaWYgKHAycC0+Y2ZnLT5wcm92X2Rpc2NfcmVzcCkKKwlpZiAoZGV2LT5mbGFncyAmIFAyUF9ERVZfUERfQkVGT1JFX0dPX05FRykgeworCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCisJCQkiUDJQOiBTdGFydCBHTyBOZWcgYWZ0ZXIgdGhlIFBELWJlZm9yZS1HTy1OZWcgIgorCQkJIndvcmthcm91bmQgd2l0aCAiIE1BQ1NUUiwKKwkJCU1BQzJTVFIoZGV2LT5pbmZvLnAycF9kZXZpY2VfYWRkcikpOworCQlkZXYtPmZsYWdzICY9IH5QMlBfREVWX1BEX0JFRk9SRV9HT19ORUc7CisJCXAycF9jb25uZWN0X3NlbmQocDJwLCBkZXYpOworCQlyZXR1cm47CisJfQorCWlmIChzdWNjZXNzICYmIHAycC0+Y2ZnLT5wcm92X2Rpc2NfcmVzcCkKIAkJcDJwLT5jZmctPnByb3ZfZGlzY19yZXNwKHAycC0+Y2ZnLT5jYl9jdHgsIHNhLAogCQkJCQkgcmVwb3J0X2NvbmZpZ19tZXRob2RzKTsKIH0KQEAgLTMxNiw2ICszNDQsOCBAQAogCWlmIChyZXEgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCisJaWYgKHAycC0+c3RhdGUgIT0gUDJQX0lETEUpCisJCXAycF9zdG9wX2xpc3Rlbl9mb3JfZnJlcShwMnAsIGZyZXEpOwogCXAycC0+cGVuZGluZ19hY3Rpb25fc3RhdGUgPSBQMlBfUEVORElOR19QRDsKIAlpZiAocDJwX3NlbmRfYWN0aW9uKHAycCwgZnJlcSwgZGV2LT5pbmZvLnAycF9kZXZpY2VfYWRkciwKIAkJCSAgICBwMnAtPmNmZy0+ZGV2X2FkZHIsIGRldi0+aW5mby5wMnBfZGV2aWNlX2FkZHIsCmRpZmYgLS1naXQgYS9zcmMvcDJwL3AycF9zZC5jIGIvc3JjL3AycC9wMnBfc2QuYwppbmRleCAzN2IzZjdiLi4wNTA5NzY3IDEwMDY0NAotLS0gYS9zcmMvcDJwL3AycF9zZC5jCisrKyBiL3NyYy9wMnAvcDJwX3NkLmMKQEAgLTM2NCw5ICszNjQsMTQgQEAKIAkJCQkicHJldmlvdXMgU0QgcmVzcG9uc2UiKTsKIAkJCXdwYWJ1Zl9mcmVlKHAycC0+c2RfcmVzcCk7CiAJCX0KKwkJcDJwLT5zZF9yZXNwID0gd3BhYnVmX2R1cChyZXNwX3RsdnMpOworCQlpZiAocDJwLT5zZF9yZXNwID09IE5VTEwpIHsKKwkJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19FUlJPUiwgIlAyUDogRmFpbGVkIHRvICIKKwkJCQkiYWxsb2NhdGUgU0QgcmVzcG9uc2UgZnJhZ21lbnRhdGlvbiBhcmVhIik7CisJCQlyZXR1cm47CisJCX0KIAkJb3NfbWVtY3B5KHAycC0+c2RfcmVzcF9hZGRyLCBkc3QsIEVUSF9BTEVOKTsKIAkJcDJwLT5zZF9yZXNwX2RpYWxvZ190b2tlbiA9IGRpYWxvZ190b2tlbjsKLQkJcDJwLT5zZF9yZXNwID0gd3BhYnVmX2R1cChyZXNwX3RsdnMpOwogCQlwMnAtPnNkX3Jlc3BfcG9zID0gMDsKIAkJcDJwLT5zZF9mcmFnX2lkID0gMDsKIAkJcmVzcCA9IHAycF9idWlsZF9zZF9yZXNwb25zZShkaWFsb2dfdG9rZW4sIFdMQU5fU1RBVFVTX1NVQ0NFU1MsCkBAIC00MDQsOSArNDA5LDE4IEBACiAJdTE2IHNsZW47CiAJdTE2IHVwZGF0ZV9pbmRpYzsKIAorI2lmZGVmIEFORFJPSURfUDJQCisJaWYgKHAycC0+c3RhdGUgIT0gUDJQX1NEX0RVUklOR19GSU5EKSB7CisJCXdwYV9tc2cocDJwLT5jZmctPm1zZ19jdHgsIE1TR19ERUJVRywKKwkJCSJQMlA6ICMjIyMgTm90IGlnbm9yaW5nIHVuZXhwZWN0ZWQgR0FTIEluaXRpYWwgUmVzcG9uc2UgZnJvbSAiCisJCQlNQUNTVFIgIiBzdGF0ZSAlZCIsIE1BQzJTVFIoc2EpLCBwMnAtPnN0YXRlKTsKKwl9CisJaWYgKHAycC0+c2RfcGVlciA9PSBOVUxMIHx8CisjZWxzZQogCWlmIChwMnAtPnN0YXRlICE9IFAyUF9TRF9EVVJJTkdfRklORCB8fCBwMnAtPnNkX3BlZXIgPT0gTlVMTCB8fAorI2VuZGlmCiAJICAgIG9zX21lbWNtcChzYSwgcDJwLT5zZF9wZWVyLT5pbmZvLnAycF9kZXZpY2VfYWRkciwgRVRIX0FMRU4pICE9IDApIHsKLQkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0VSUk9SLAorCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfSU5GTywKIAkJCSJQMlA6IElnbm9yZSB1bmV4cGVjdGVkIEdBUyBJbml0aWFsIFJlc3BvbnNlIGZyb20gIgogCQkJTUFDU1RSLCBNQUMyU1RSKHNhKSk7CiAJCXJldHVybjsKQEAgLTY0NSw5ICs2NTksMTggQEAKIAogCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlAyUDogUlggR0FTIENvbWViYWNrIFJlc3BvbnNlIiwgZGF0YSwgbGVuKTsKIAotCWlmIChwMnAtPnN0YXRlICE9IFAyUF9TRF9EVVJJTkdfRklORCB8fCBwMnAtPnNkX3BlZXIgPT0gTlVMTCB8fAotCSAgICBvc19tZW1jbXAoc2EsIHAycC0+c2RfcGVlci0+aW5mby5wMnBfZGV2aWNlX2FkZHIsIEVUSF9BTEVOKSAhPSAwKSB7CisjaWZkZWYgQU5EUk9JRF9QMlAKKwlpZiAocDJwLT5zdGF0ZSAhPSBQMlBfU0RfRFVSSU5HX0ZJTkQpIHsKIAkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0RFQlVHLAorCQkJIlAyUDogIyMjIyBOb3QgaWdub3JpbmcgdW5leHBlY3RlZCBHQVMgQ29tZWJhY2sgUmVzcG9uc2UgZnJvbSAiCisJCQlNQUNTVFIgIiBzdGF0ZSAlZCIsIE1BQzJTVFIoc2EpLCBwMnAtPnN0YXRlKTsKKwl9CisJaWYgKHAycC0+c2RfcGVlciA9PSBOVUxMIHx8CisjZWxzZQorCWlmIChwMnAtPnN0YXRlICE9IFAyUF9TRF9EVVJJTkdfRklORCB8fCBwMnAtPnNkX3BlZXIgPT0gTlVMTCB8fAorI2VuZGlmCisJICAgIG9zX21lbWNtcChzYSwgcDJwLT5zZF9wZWVyLT5pbmZvLnAycF9kZXZpY2VfYWRkciwgRVRIX0FMRU4pICE9IDApIHsKKwkJd3BhX21zZyhwMnAtPmNmZy0+bXNnX2N0eCwgTVNHX0lORk8sCiAJCQkiUDJQOiBJZ25vcmUgdW5leHBlY3RlZCBHQVMgQ29tZWJhY2sgUmVzcG9uc2UgZnJvbSAiCiAJCQlNQUNTVFIsIE1BQzJTVFIoc2EpKTsKIAkJcmV0dXJuOwpAQCAtODQyLDcgKzg2NSw3IEBACiB7CiAJc3RydWN0IHAycF9zZF9xdWVyeSAqcTsKICNpZmRlZiBBTkRST0lEX1AyUAotCS8qIEN1cnJlbnRseSwgc3VwcGxpY2FudCBkb2Vzbid0IHN1cHBvcnQgbW9yZSB0aGFuIG9uZSBwZW5kaW5nIGJyb2FkY2FzdCBTRCByZXF1ZXN0LiAKKwkvKiBDdXJyZW50bHksIHN1cHBsaWNhbnQgZG9lc24ndCBzdXBwb3J0IG1vcmUgdGhhbiBvbmUgcGVuZGluZyBicm9hZGNhc3QgU0QgcmVxdWVzdC4KIAkgKiBTbyByZWplY3QgaWYgYXBwbGljYXRpb24gaXMgcmVnaXN0ZXJpbmcgYW5vdGhlciBvbmUgYmVmb3JlIGNhbmNlbGxpbmcgdGhlIGV4aXN0aW5nIG9uZS4KIAkgKi8KIAlmb3IgKHEgPSBwMnAtPnNkX3F1ZXJpZXM7IHE7IHEgPSBxLT5uZXh0KSB7CkBAIC04NzIsNyArODk1LDcgQEAKIAogCXEtPm5leHQgPSBwMnAtPnNkX3F1ZXJpZXM7CiAJcDJwLT5zZF9xdWVyaWVzID0gcTsKLQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IEFkZGVkIFNEIFF1ZXJ5ICVwIGZvcl9hbGxfcGVlcnMgJWQiLCBxLCBxLT5mb3JfYWxsX3BlZXJzKTsKKwl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsICJQMlA6IEFkZGVkIFNEIFF1ZXJ5ICVwIiwgcSk7CiAKIAlpZiAoZHN0ID09IE5VTEwpIHsKIAkJc3RydWN0IHAycF9kZXZpY2UgKmRldjsKQEAgLTg5MywyNCArOTE2LDEwIEBACiBpbnQgcDJwX3NkX2NhbmNlbF9yZXF1ZXN0KHN0cnVjdCBwMnBfZGF0YSAqcDJwLCB2b2lkICpyZXEpCiB7CiAJaWYgKHAycF91bmxpbmtfc2RfcXVlcnkocDJwLCByZXEpKSB7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQlzdHJ1Y3QgcDJwX2RldmljZSAqZGV2OwotCXN0cnVjdCBwMnBfc2RfcXVlcnkgKnEgPSAoc3RydWN0IHAycF9zZF9xdWVyeSAqKXJlcTsKLSNlbmRpZgogCQl3cGFfbXNnKHAycC0+Y2ZnLT5tc2dfY3R4LCBNU0dfREVCVUcsCiAJCQkiUDJQOiBDYW5jZWwgcGVuZGluZyBTRCBxdWVyeSAlcCIsIHJlcSk7CiAjaWZkZWYgQU5EUk9JRF9QMlAKLQkJLyogSWYgdGhlIHJlcXVlc3QgaXMgYSBiY2FzdCBxdWVyeSwgdGhlbiBjbGVhciB0aGUKLQkJICogUDJQX0RFVl9TRF9JTkZPIGZsYWcgc28gdGhhdCB3aGVuIG5ldyBzZCBxdWVyeSBpcyByZWdpc3RlcmVkLAotCQkgKiB3ZSB3aWxsIHNlbmQgdGhlIFNEIHJlcXVlc3QgZnJhbWVzIHRvIHBlZXIgZGV2aWNlcy4KLQkJICovCi0JCWlmKHEtPmZvcl9hbGxfcGVlcnMpIHsKLQkJCXAycC0+c2RfZGV2X2xpc3QgPSBOVUxMOwotCQkJZGxfbGlzdF9mb3JfZWFjaChkZXYsICZwMnAtPmRldmljZXMsCi0JCQkJCQkJc3RydWN0IHAycF9kZXZpY2UsIGxpc3QpIHsKLQkJCQlkZXYtPmZsYWdzICY9IH5QMlBfREVWX1NEX0lORk87Ci0JCQl9Ci0JCX0KKwkJcDJwLT5zZF9kZXZfbGlzdCA9IE5VTEw7CiAjZW5kaWYKIAkJcDJwX2ZyZWVfc2RfcXVlcnkocmVxKTsKIAkJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9zcmMvcmFkaXVzL3JhZGl1cy5jIGIvc3JjL3JhZGl1cy9yYWRpdXMuYwppbmRleCAwZGQ2YjEyLi4yYjljYmNhIDEwMDY0NAotLS0gYS9zcmMvcmFkaXVzL3JhZGl1cy5jCisrKyBiL3NyYy9yYWRpdXMvcmFkaXVzLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogUkFESVVTIG1lc3NhZ2UgcHJvY2Vzc2luZwotICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDItMjAwOSwgMjAxMS0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xNDcsNiArMTQ3LDEyIEBACiAJY2FzZSBSQURJVVNfQ09ERV9TVEFUVVNfU0VSVkVSOiByZXR1cm4gIlN0YXR1cy1TZXJ2ZXIiOwogCWNhc2UgUkFESVVTX0NPREVfU1RBVFVTX0NMSUVOVDogcmV0dXJuICJTdGF0dXMtQ2xpZW50IjsKIAljYXNlIFJBRElVU19DT0RFX1JFU0VSVkVEOiByZXR1cm4gIlJlc2VydmVkIjsKKwljYXNlIFJBRElVU19DT0RFX0RJU0NPTk5FQ1RfUkVRVUVTVDogcmV0dXJuICJEaXNjb25uZWN0LVJlcXVlc3QiOworCWNhc2UgUkFESVVTX0NPREVfRElTQ09OTkVDVF9BQ0s6IHJldHVybiAiRGlzY29ubmVjdC1BQ0siOworCWNhc2UgUkFESVVTX0NPREVfRElTQ09OTkVDVF9OQUs6IHJldHVybiAiRGlzY29ubmVjdC1OQUsiOworCWNhc2UgUkFESVVTX0NPREVfQ09BX1JFUVVFU1Q6IHJldHVybiAiQ29BLVJlcXVlc3QiOworCWNhc2UgUkFESVVTX0NPREVfQ09BX0FDSzogcmV0dXJuICJDb0EtQUNLIjsKKwljYXNlIFJBRElVU19DT0RFX0NPQV9OQUs6IHJldHVybiAiQ29BLU5BSyI7CiAJZGVmYXVsdDogcmV0dXJuICI/VW5rbm93bj8iOwogCX0KIH0KQEAgLTIyMiw5ICsyMjgsMTAgQEAKIAkgIFJBRElVU19BVFRSX0hFWERVTVAgfSwKIAl7IFJBRElVU19BVFRSX0FDQ1RfSU5URVJJTV9JTlRFUlZBTCwgIkFjY3QtSW50ZXJpbS1JbnRlcnZhbCIsCiAJICBSQURJVVNfQVRUUl9JTlQzMiB9LAotCXsgUkFESVVTX0FUVFJfQ0hBUkdFQUJMRV9VU0VSX0lERU5USVRZLCAiQ2hhcmdhYmxlLVVzZXItSWRlbnRpdHkiLAorCXsgUkFESVVTX0FUVFJfQ0hBUkdFQUJMRV9VU0VSX0lERU5USVRZLCAiQ2hhcmdlYWJsZS1Vc2VyLUlkZW50aXR5IiwKIAkgIFJBRElVU19BVFRSX1RFWFQgfSwKIAl7IFJBRElVU19BVFRSX05BU19JUFY2X0FERFJFU1MsICJOQVMtSVB2Ni1BZGRyZXNzIiwgUkFESVVTX0FUVFJfSVBWNiB9LAorCXsgUkFESVVTX0FUVFJfRVJST1JfQ0FVU0UsICJFcnJvci1DYXVzZSIsIFJBRElVU19BVFRSX0lOVDMyIH0KIH07CiAjZGVmaW5lIFJBRElVU19BVFRSUyAoc2l6ZW9mKHJhZGl1c19hdHRycykgLyBzaXplb2YocmFkaXVzX2F0dHJzWzBdKSkKIApAQCAtNDA2LDYgKzQxMyw0NSBAQAogfQogCiAKK2ludCByYWRpdXNfbXNnX2ZpbmlzaF9kYXNfcmVzcChzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAorCQkJICAgICAgIHNpemVfdCBzZWNyZXRfbGVuLAorCQkJICAgICAgIGNvbnN0IHN0cnVjdCByYWRpdXNfaGRyICpyZXFfaGRyKQoreworCWNvbnN0IHU4ICphZGRyWzJdOworCXNpemVfdCBsZW5bMl07CisJdTggYXV0aFtNRDVfTUFDX0xFTl07CisJc3RydWN0IHJhZGl1c19hdHRyX2hkciAqYXR0cjsKKworCW9zX21lbXNldChhdXRoLCAwLCBNRDVfTUFDX0xFTik7CisJYXR0ciA9IHJhZGl1c19tc2dfYWRkX2F0dHIobXNnLCBSQURJVVNfQVRUUl9NRVNTQUdFX0FVVEhFTlRJQ0FUT1IsCisJCQkJICAgYXV0aCwgTUQ1X01BQ19MRU4pOworCWlmIChhdHRyID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIkNvdWxkIG5vdCBhZGQgTWVzc2FnZS1BdXRoZW50aWNhdG9yIik7CisJCXJldHVybiAtMTsKKwl9CisKKwltc2ctPmhkci0+bGVuZ3RoID0gaHRvbnMod3BhYnVmX2xlbihtc2ctPmJ1ZikpOworCW9zX21lbWNweShtc2ctPmhkci0+YXV0aGVudGljYXRvciwgcmVxX2hkci0+YXV0aGVudGljYXRvciwgMTYpOworCWhtYWNfbWQ1KHNlY3JldCwgc2VjcmV0X2xlbiwgd3BhYnVmX2hlYWQobXNnLT5idWYpLAorCQkgd3BhYnVmX2xlbihtc2ctPmJ1ZiksICh1OCAqKSAoYXR0ciArIDEpKTsKKworCS8qIFJlc3BvbnNlQXV0aCA9IE1ENShDb2RlK0lEK0xlbmd0aCtSZXF1ZXN0QXV0aCtBdHRyaWJ1dGVzK1NlY3JldCkgKi8KKwlhZGRyWzBdID0gd3BhYnVmX2hlYWRfdTgobXNnLT5idWYpOworCWxlblswXSA9IHdwYWJ1Zl9sZW4obXNnLT5idWYpOworCWFkZHJbMV0gPSBzZWNyZXQ7CisJbGVuWzFdID0gc2VjcmV0X2xlbjsKKwlpZiAobWQ1X3ZlY3RvcigyLCBhZGRyLCBsZW4sIG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yKSA8IDApCisJCXJldHVybiAtMTsKKworCWlmICh3cGFidWZfbGVuKG1zZy0+YnVmKSA+IDB4ZmZmZikgeworCQl3cGFfcHJpbnRmKE1TR19XQVJOSU5HLCAiUkFESVVTOiBUb28gbG9uZyBtZXNzYWdlICglbHUpIiwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSB3cGFidWZfbGVuKG1zZy0+YnVmKSk7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKKwogdm9pZCByYWRpdXNfbXNnX2ZpbmlzaF9hY2N0KHN0cnVjdCByYWRpdXNfbXNnICptc2csIGNvbnN0IHU4ICpzZWNyZXQsCiAJCQkgICAgc2l6ZV90IHNlY3JldF9sZW4pCiB7CkBAIC00MjcsNiArNDczLDg4IEBACiB9CiAKIAoraW50IHJhZGl1c19tc2dfdmVyaWZ5X2FjY3RfcmVxKHN0cnVjdCByYWRpdXNfbXNnICptc2csIGNvbnN0IHU4ICpzZWNyZXQsCisJCQkgICAgICAgc2l6ZV90IHNlY3JldF9sZW4pCit7CisJY29uc3QgdTggKmFkZHJbNF07CisJc2l6ZV90IGxlbls0XTsKKwl1OCB6ZXJvW01ENV9NQUNfTEVOXTsKKwl1OCBoYXNoW01ENV9NQUNfTEVOXTsKKworCW9zX21lbXNldCh6ZXJvLCAwLCBzaXplb2YoemVybykpOworCWFkZHJbMF0gPSAodTggKikgbXNnLT5oZHI7CisJbGVuWzBdID0gc2l6ZW9mKHN0cnVjdCByYWRpdXNfaGRyKSAtIE1ENV9NQUNfTEVOOworCWFkZHJbMV0gPSB6ZXJvOworCWxlblsxXSA9IE1ENV9NQUNfTEVOOworCWFkZHJbMl0gPSAodTggKikgKG1zZy0+aGRyICsgMSk7CisJbGVuWzJdID0gd3BhYnVmX2xlbihtc2ctPmJ1ZikgLSBzaXplb2Yoc3RydWN0IHJhZGl1c19oZHIpOworCWFkZHJbM10gPSBzZWNyZXQ7CisJbGVuWzNdID0gc2VjcmV0X2xlbjsKKwltZDVfdmVjdG9yKDQsIGFkZHIsIGxlbiwgaGFzaCk7CisJcmV0dXJuIG9zX21lbWNtcChtc2ctPmhkci0+YXV0aGVudGljYXRvciwgaGFzaCwgTUQ1X01BQ19MRU4pICE9IDA7Cit9CisKKworaW50IHJhZGl1c19tc2dfdmVyaWZ5X2Rhc19yZXEoc3RydWN0IHJhZGl1c19tc2cgKm1zZywgY29uc3QgdTggKnNlY3JldCwKKwkJCSAgICAgIHNpemVfdCBzZWNyZXRfbGVuKQoreworCWNvbnN0IHU4ICphZGRyWzRdOworCXNpemVfdCBsZW5bNF07CisJdTggemVyb1tNRDVfTUFDX0xFTl07CisJdTggaGFzaFtNRDVfTUFDX0xFTl07CisJdTggYXV0aFtNRDVfTUFDX0xFTl0sIG9yaWdbTUQ1X01BQ19MRU5dOworCXU4IG9yaWdfYXV0aGVudGljYXRvclsxNl07CisKKwlzdHJ1Y3QgcmFkaXVzX2F0dHJfaGRyICphdHRyID0gTlVMTCwgKnRtcDsKKwlzaXplX3QgaTsKKworCW9zX21lbXNldCh6ZXJvLCAwLCBzaXplb2YoemVybykpOworCWFkZHJbMF0gPSAodTggKikgbXNnLT5oZHI7CisJbGVuWzBdID0gc2l6ZW9mKHN0cnVjdCByYWRpdXNfaGRyKSAtIE1ENV9NQUNfTEVOOworCWFkZHJbMV0gPSB6ZXJvOworCWxlblsxXSA9IE1ENV9NQUNfTEVOOworCWFkZHJbMl0gPSAodTggKikgKG1zZy0+aGRyICsgMSk7CisJbGVuWzJdID0gd3BhYnVmX2xlbihtc2ctPmJ1ZikgLSBzaXplb2Yoc3RydWN0IHJhZGl1c19oZHIpOworCWFkZHJbM10gPSBzZWNyZXQ7CisJbGVuWzNdID0gc2VjcmV0X2xlbjsKKwltZDVfdmVjdG9yKDQsIGFkZHIsIGxlbiwgaGFzaCk7CisJaWYgKG9zX21lbWNtcChtc2ctPmhkci0+YXV0aGVudGljYXRvciwgaGFzaCwgTUQ1X01BQ19MRU4pICE9IDApCisJCXJldHVybiAxOworCisJZm9yIChpID0gMDsgaSA8IG1zZy0+YXR0cl91c2VkOyBpKyspIHsKKwkJdG1wID0gcmFkaXVzX2dldF9hdHRyX2hkcihtc2csIGkpOworCQlpZiAodG1wLT50eXBlID09IFJBRElVU19BVFRSX01FU1NBR0VfQVVUSEVOVElDQVRPUikgeworCQkJaWYgKGF0dHIgIT0gTlVMTCkgeworCQkJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJNdWx0aXBsZSAiCisJCQkJCSAgICJNZXNzYWdlLUF1dGhlbnRpY2F0b3IgYXR0cmlidXRlcyAiCisJCQkJCSAgICJpbiBSQURJVVMgbWVzc2FnZSIpOworCQkJCXJldHVybiAxOworCQkJfQorCQkJYXR0ciA9IHRtcDsKKwkJfQorCX0KKworCWlmIChhdHRyID09IE5VTEwpIHsKKwkJLyogTWVzc2FnZS1BdXRoZW50aWNhdG9yIGlzIE1BWTsgbm90IHJlcXVpcmVkICovCisJCXJldHVybiAwOworCX0KKworCW9zX21lbWNweShvcmlnLCBhdHRyICsgMSwgTUQ1X01BQ19MRU4pOworCW9zX21lbXNldChhdHRyICsgMSwgMCwgTUQ1X01BQ19MRU4pOworCW9zX21lbWNweShvcmlnX2F1dGhlbnRpY2F0b3IsIG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yLAorCQkgIHNpemVvZihvcmlnX2F1dGhlbnRpY2F0b3IpKTsKKwlvc19tZW1zZXQobXNnLT5oZHItPmF1dGhlbnRpY2F0b3IsIDAsCisJCSAgc2l6ZW9mKG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yKSk7CisJaG1hY19tZDUoc2VjcmV0LCBzZWNyZXRfbGVuLCB3cGFidWZfaGVhZChtc2ctPmJ1ZiksCisJCSB3cGFidWZfbGVuKG1zZy0+YnVmKSwgYXV0aCk7CisJb3NfbWVtY3B5KGF0dHIgKyAxLCBvcmlnLCBNRDVfTUFDX0xFTik7CisJb3NfbWVtY3B5KG1zZy0+aGRyLT5hdXRoZW50aWNhdG9yLCBvcmlnX2F1dGhlbnRpY2F0b3IsCisJCSAgc2l6ZW9mKG9yaWdfYXV0aGVudGljYXRvcikpOworCisJcmV0dXJuIG9zX21lbWNtcChvcmlnLCBhdXRoLCBNRDVfTUFDX0xFTikgIT0gMDsKK30KKworCiBzdGF0aWMgaW50IHJhZGl1c19tc2dfYWRkX2F0dHJfdG9fYXJyYXkoc3RydWN0IHJhZGl1c19tc2cgKm1zZywKIAkJCQkJc3RydWN0IHJhZGl1c19hdHRyX2hkciAqYXR0cikKIHsKQEAgLTE0MjQsMyArMTU1MiwyNCBAQAogCiAJcmV0dXJuIDA7CiB9CisKKwordTggcmFkaXVzX21zZ19maW5kX3VubGlzdGVkX2F0dHIoc3RydWN0IHJhZGl1c19tc2cgKm1zZywgdTggKmF0dHJzKQoreworCXNpemVfdCBpLCBqOworCXN0cnVjdCByYWRpdXNfYXR0cl9oZHIgKmF0dHI7CisKKwlmb3IgKGkgPSAwOyBpIDwgbXNnLT5hdHRyX3VzZWQ7IGkrKykgeworCQlhdHRyID0gcmFkaXVzX2dldF9hdHRyX2hkcihtc2csIGkpOworCisJCWZvciAoaiA9IDA7IGF0dHJzW2pdOyBqKyspIHsKKwkJCWlmIChhdHRyLT50eXBlID09IGF0dHJzW2pdKQorCQkJCWJyZWFrOworCQl9CisKKwkJaWYgKGF0dHJzW2pdID09IDApCisJCQlyZXR1cm4gYXR0ci0+dHlwZTsgLyogdW5saXN0ZWQgYXR0ciAqLworCX0KKworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvc3JjL3JhZGl1cy9yYWRpdXMuaCBiL3NyYy9yYWRpdXMvcmFkaXVzLmgKaW5kZXggNDQxMjNiZC4uMmQwNTlkZiAxMDA2NDQKLS0tIGEvc3JjL3JhZGl1cy9yYWRpdXMuaAorKysgYi9zcmMvcmFkaXVzL3JhZGl1cy5oCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFJBRElVUyBtZXNzYWdlIHByb2Nlc3NpbmcKLSAqIENvcHlyaWdodCAoYykgMjAwMi0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAyLTIwMDksIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTMxLDYgKzMxLDEyIEBACiAgICAgICAgUkFESVVTX0NPREVfQUNDRVNTX0NIQUxMRU5HRSA9IDExLAogICAgICAgIFJBRElVU19DT0RFX1NUQVRVU19TRVJWRVIgPSAxMiwKICAgICAgICBSQURJVVNfQ09ERV9TVEFUVVNfQ0xJRU5UID0gMTMsCisgICAgICAgUkFESVVTX0NPREVfRElTQ09OTkVDVF9SRVFVRVNUID0gNDAsCisgICAgICAgUkFESVVTX0NPREVfRElTQ09OTkVDVF9BQ0sgPSA0MSwKKyAgICAgICBSQURJVVNfQ09ERV9ESVNDT05ORUNUX05BSyA9IDQyLAorICAgICAgIFJBRElVU19DT0RFX0NPQV9SRVFVRVNUID0gNDMsCisgICAgICAgUkFESVVTX0NPREVfQ09BX0FDSyA9IDQ0LAorICAgICAgIFJBRElVU19DT0RFX0NPQV9OQUsgPSA0NSwKICAgICAgICBSQURJVVNfQ09ERV9SRVNFUlZFRCA9IDI1NQogfTsKIApAQCAtODMsNyArODksOCBAQAogICAgICAgIFJBRElVU19BVFRSX1RVTk5FTF9QUklWQVRFX0dST1VQX0lEID0gODEsCiAgICAgICAgUkFESVVTX0FUVFJfQUNDVF9JTlRFUklNX0lOVEVSVkFMID0gODUsCiAgICAgICAgUkFESVVTX0FUVFJfQ0hBUkdFQUJMRV9VU0VSX0lERU5USVRZID0gODksCi0gICAgICAgUkFESVVTX0FUVFJfTkFTX0lQVjZfQUREUkVTUyA9IDk1CisgICAgICAgUkFESVVTX0FUVFJfTkFTX0lQVjZfQUREUkVTUyA9IDk1LAorICAgICAgIFJBRElVU19BVFRSX0VSUk9SX0NBVVNFID0gMTAxCiB9OwogCiAKQEAgLTE5Miw4ICsxOTksMTUgQEAKIAkJICAgICAgc2l6ZV90IHNlY3JldF9sZW4pOwogaW50IHJhZGl1c19tc2dfZmluaXNoX3NydihzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAogCQkJICBzaXplX3Qgc2VjcmV0X2xlbiwgY29uc3QgdTggKnJlcV9hdXRoZW50aWNhdG9yKTsKK2ludCByYWRpdXNfbXNnX2ZpbmlzaF9kYXNfcmVzcChzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAorCQkJICAgICAgIHNpemVfdCBzZWNyZXRfbGVuLAorCQkJICAgICAgIGNvbnN0IHN0cnVjdCByYWRpdXNfaGRyICpyZXFfaGRyKTsKIHZvaWQgcmFkaXVzX21zZ19maW5pc2hfYWNjdChzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAogCQkJICAgIHNpemVfdCBzZWNyZXRfbGVuKTsKK2ludCByYWRpdXNfbXNnX3ZlcmlmeV9hY2N0X3JlcShzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCBjb25zdCB1OCAqc2VjcmV0LAorCQkJICAgICAgIHNpemVfdCBzZWNyZXRfbGVuKTsKK2ludCByYWRpdXNfbXNnX3ZlcmlmeV9kYXNfcmVxKHN0cnVjdCByYWRpdXNfbXNnICptc2csIGNvbnN0IHU4ICpzZWNyZXQsCisJCQkgICAgICAgc2l6ZV90IHNlY3JldF9sZW4pOwogc3RydWN0IHJhZGl1c19hdHRyX2hkciAqIHJhZGl1c19tc2dfYWRkX2F0dHIoc3RydWN0IHJhZGl1c19tc2cgKm1zZywgdTggdHlwZSwKIAkJCQkJICAgICBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGRhdGFfbGVuKTsKIHN0cnVjdCByYWRpdXNfbXNnICogcmFkaXVzX21zZ19wYXJzZShjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbik7CkBAIC0yNjgsNCArMjgyLDYgQEAKIGludCByYWRpdXNfY29weV9jbGFzcyhzdHJ1Y3QgcmFkaXVzX2NsYXNzX2RhdGEgKmRzdCwKIAkJICAgICAgY29uc3Qgc3RydWN0IHJhZGl1c19jbGFzc19kYXRhICpzcmMpOwogCit1OCByYWRpdXNfbXNnX2ZpbmRfdW5saXN0ZWRfYXR0cihzdHJ1Y3QgcmFkaXVzX21zZyAqbXNnLCB1OCAqYXR0cnMpOworCiAjZW5kaWYgLyogUkFESVVTX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9yYWRpdXMvcmFkaXVzX2NsaWVudC5jIGIvc3JjL3JhZGl1cy9yYWRpdXNfY2xpZW50LmMKaW5kZXggYmNkNDcxYi4uMWVlNzEzMSAxMDA2NDQKLS0tIGEvc3JjL3JhZGl1cy9yYWRpdXNfY2xpZW50LmMKKysrIGIvc3JjL3JhZGl1cy9yYWRpdXNfY2xpZW50LmMKQEAgLTUwNSw3ICs1MDUsNyBAQAogCQkJICAgICAgIE5VTEwpOwogCWhvc3RhcGRfbG9nZ2VyKHJhZGl1cy0+Y3R4LCBOVUxMLCBIT1NUQVBEX01PRFVMRV9SQURJVVMsCiAJCSAgICAgICBIT1NUQVBEX0xFVkVMX0RFQlVHLCAiTmV4dCBSQURJVVMgY2xpZW50IHJldHJhbnNtaXQgaW4iCi0JCSAgICAgICAiICVsZCBzZWNvbmRzXG4iLCAobG9uZyBpbnQpIChmaXJzdCAtIG5vdy5zZWMpKTsKKwkJICAgICAgICIgJWxkIHNlY29uZHMiLCAobG9uZyBpbnQpIChmaXJzdCAtIG5vdy5zZWMpKTsKIH0KIAogCkBAIC02NzgsNyArNjc4LDcgQEAKIAlyYWRpdXNfY2xpZW50X2xpc3RfYWRkKHJhZGl1cywgbXNnLCBtc2dfdHlwZSwgc2hhcmVkX3NlY3JldCwKIAkJCSAgICAgICBzaGFyZWRfc2VjcmV0X2xlbiwgYWRkcik7CiAKLQlyZXR1cm4gcmVzOworCXJldHVybiAwOwogfQogCiAKZGlmZiAtLWdpdCBhL3NyYy9yYWRpdXMvcmFkaXVzX2Rhcy5jIGIvc3JjL3JhZGl1cy9yYWRpdXNfZGFzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGVjZmZmYwotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9yYWRpdXMvcmFkaXVzX2Rhcy5jCkBAIC0wLDAgKzEsMzU2IEBACisvKgorICogUkFESVVTIER5bmFtaWMgQXV0aG9yaXphdGlvbiBTZXJ2ZXIgKERBUykgKFJGQyA1MTc2KQorICogQ29weXJpZ2h0IChjKSAyMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisjaW5jbHVkZSA8bmV0L2lmLmg+CisKKyNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKKyNpbmNsdWRlICJ1dGlscy9lbG9vcC5oIgorI2luY2x1ZGUgInV0aWxzL2lwX2FkZHIuaCIKKyNpbmNsdWRlICJyYWRpdXMuaCIKKyNpbmNsdWRlICJyYWRpdXNfZGFzLmgiCisKKworZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7CisKKworc3RydWN0IHJhZGl1c19kYXNfZGF0YSB7CisJaW50IHNvY2s7CisJdTggKnNoYXJlZF9zZWNyZXQ7CisJc2l6ZV90IHNoYXJlZF9zZWNyZXRfbGVuOworCXN0cnVjdCBob3N0YXBkX2lwX2FkZHIgY2xpZW50X2FkZHI7CisJdW5zaWduZWQgaW50IHRpbWVfd2luZG93OworCWludCByZXF1aXJlX2V2ZW50X3RpbWVzdGFtcDsKKwl2b2lkICpjdHg7CisJZW51bSByYWRpdXNfZGFzX3JlcyAoKmRpc2Nvbm5lY3QpKHZvaWQgKmN0eCwKKwkJCQkJICBzdHJ1Y3QgcmFkaXVzX2Rhc19hdHRycyAqYXR0cik7Cit9OworCisKK3N0YXRpYyBzdHJ1Y3QgcmFkaXVzX21zZyAqIHJhZGl1c19kYXNfZGlzY29ubmVjdChzdHJ1Y3QgcmFkaXVzX2Rhc19kYXRhICpkYXMsCisJCQkJCQkgc3RydWN0IHJhZGl1c19tc2cgKm1zZywKKwkJCQkJCSBjb25zdCBjaGFyICphYnVmLAorCQkJCQkJIGludCBmcm9tX3BvcnQpCit7CisJc3RydWN0IHJhZGl1c19oZHIgKmhkcjsKKwlzdHJ1Y3QgcmFkaXVzX21zZyAqcmVwbHk7CisJdTggYWxsb3dlZFtdID0geworCQlSQURJVVNfQVRUUl9VU0VSX05BTUUsCisJCVJBRElVU19BVFRSX0NBTExJTkdfU1RBVElPTl9JRCwKKwkJUkFESVVTX0FUVFJfQUNDVF9TRVNTSU9OX0lELAorCQlSQURJVVNfQVRUUl9FVkVOVF9USU1FU1RBTVAsCisJCVJBRElVU19BVFRSX01FU1NBR0VfQVVUSEVOVElDQVRPUiwKKwkJUkFESVVTX0FUVFJfQ0hBUkdFQUJMRV9VU0VSX0lERU5USVRZLAorCQkwCisJfTsKKwlpbnQgZXJyb3IgPSA0MDU7CisJdTggYXR0cjsKKwllbnVtIHJhZGl1c19kYXNfcmVzIHJlczsKKwlzdHJ1Y3QgcmFkaXVzX2Rhc19hdHRycyBhdHRyczsKKwl1OCAqYnVmOworCXNpemVfdCBsZW47CisJY2hhciB0bXBbMTAwXTsKKwl1OCBzdGFfYWRkcltFVEhfQUxFTl07CisKKwloZHIgPSByYWRpdXNfbXNnX2dldF9oZHIobXNnKTsKKworCWF0dHIgPSByYWRpdXNfbXNnX2ZpbmRfdW5saXN0ZWRfYXR0cihtc2csIGFsbG93ZWQpOworCWlmIChhdHRyKSB7CisJCXdwYV9wcmludGYoTVNHX0lORk8sICJEQVM6IFVuc3VwcG9ydGVkIGF0dHJpYnV0ZSAldSBpbiAiCisJCQkgICAiRGlzY29ubmVjdC1SZXF1ZXN0IGZyb20gJXM6JWQiLCBhdHRyLAorCQkJICAgYWJ1ZiwgZnJvbV9wb3J0KTsKKwkJZXJyb3IgPSA0MDE7CisJCWdvdG8gZmFpbDsKKwl9CisKKwlvc19tZW1zZXQoJmF0dHJzLCAwLCBzaXplb2YoYXR0cnMpKTsKKworCWlmIChyYWRpdXNfbXNnX2dldF9hdHRyX3B0cihtc2csIFJBRElVU19BVFRSX0NBTExJTkdfU1RBVElPTl9JRCwKKwkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPT0gMCkgeworCQlpZiAobGVuID49IHNpemVvZih0bXApKQorCQkJbGVuID0gc2l6ZW9mKHRtcCkgLSAxOworCQlvc19tZW1jcHkodG1wLCBidWYsIGxlbik7CisJCXRtcFtsZW5dID0gJ1wwJzsKKwkJaWYgKGh3YWRkcl9hdG9uMih0bXAsIHN0YV9hZGRyKSA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0lORk8sICJEQVM6IEludmFsaWQgQ2FsbGluZy1TdGF0aW9uLUlkICIKKwkJCQkgICAiJyVzJyBmcm9tICVzOiVkIiwgdG1wLCBhYnVmLCBmcm9tX3BvcnQpOworCQkJZXJyb3IgPSA0MDc7CisJCQlnb3RvIGZhaWw7CisJCX0KKwkJYXR0cnMuc3RhX2FkZHIgPSBzdGFfYWRkcjsKKwl9CisKKwlpZiAocmFkaXVzX21zZ19nZXRfYXR0cl9wdHIobXNnLCBSQURJVVNfQVRUUl9VU0VSX05BTUUsCisJCQkJICAgICZidWYsICZsZW4sIE5VTEwpID09IDApIHsKKwkJYXR0cnMudXNlcl9uYW1lID0gYnVmOworCQlhdHRycy51c2VyX25hbWVfbGVuID0gbGVuOworCX0KKworCWlmIChyYWRpdXNfbXNnX2dldF9hdHRyX3B0cihtc2csIFJBRElVU19BVFRSX0FDQ1RfU0VTU0lPTl9JRCwKKwkJCQkgICAgJmJ1ZiwgJmxlbiwgTlVMTCkgPT0gMCkgeworCQlhdHRycy5hY2N0X3Nlc3Npb25faWQgPSBidWY7CisJCWF0dHJzLmFjY3Rfc2Vzc2lvbl9pZF9sZW4gPSBsZW47CisJfQorCisJaWYgKHJhZGl1c19tc2dfZ2V0X2F0dHJfcHRyKG1zZywgUkFESVVTX0FUVFJfQ0hBUkdFQUJMRV9VU0VSX0lERU5USVRZLAorCQkJCSAgICAmYnVmLCAmbGVuLCBOVUxMKSA9PSAwKSB7CisJCWF0dHJzLmN1aSA9IGJ1ZjsKKwkJYXR0cnMuY3VpX2xlbiA9IGxlbjsKKwl9CisKKwlyZXMgPSBkYXMtPmRpc2Nvbm5lY3QoZGFzLT5jdHgsICZhdHRycyk7CisJc3dpdGNoIChyZXMpIHsKKwljYXNlIFJBRElVU19EQVNfTkFTX01JU01BVENIOgorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiREFTOiBOQVMgbWlzbWF0Y2ggZnJvbSAlczolZCIsCisJCQkgICBhYnVmLCBmcm9tX3BvcnQpOworCQllcnJvciA9IDQwMzsKKwkJYnJlYWs7CisJY2FzZSBSQURJVVNfREFTX1NFU1NJT05fTk9UX0ZPVU5EOgorCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiREFTOiBTZXNzaW9uIG5vdCBmb3VuZCBmb3IgcmVxdWVzdCBmcm9tICIKKwkJCSAgICIlczolZCIsIGFidWYsIGZyb21fcG9ydCk7CisJCWVycm9yID0gNTAzOworCQlicmVhazsKKwljYXNlIFJBRElVU19EQVNfU1VDQ0VTUzoKKwkJZXJyb3IgPSAwOworCQlicmVhazsKKwl9CisKK2ZhaWw6CisJcmVwbHkgPSByYWRpdXNfbXNnX25ldyhlcnJvciA/IFJBRElVU19DT0RFX0RJU0NPTk5FQ1RfTkFLIDoKKwkJCSAgICAgICBSQURJVVNfQ09ERV9ESVNDT05ORUNUX0FDSywgaGRyLT5pZGVudGlmaWVyKTsKKwlpZiAocmVwbHkgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoZXJyb3IpIHsKKwkJcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihyZXBseSwgUkFESVVTX0FUVFJfRVJST1JfQ0FVU0UsCisJCQkJCSAgZXJyb3IpOworCX0KKworCXJldHVybiByZXBseTsKK30KKworCitzdGF0aWMgdm9pZCByYWRpdXNfZGFzX3JlY2VpdmUoaW50IHNvY2ssIHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqc29ja19jdHgpCit7CisJc3RydWN0IHJhZGl1c19kYXNfZGF0YSAqZGFzID0gZWxvb3BfY3R4OworCXU4IGJ1ZlsxNTAwXTsKKwl1bmlvbiB7CisJCXN0cnVjdCBzb2NrYWRkcl9zdG9yYWdlIHNzOworCQlzdHJ1Y3Qgc29ja2FkZHJfaW4gc2luOworI2lmZGVmIENPTkZJR19JUFY2CisJCXN0cnVjdCBzb2NrYWRkcl9pbjYgc2luNjsKKyNlbmRpZiAvKiBDT05GSUdfSVBWNiAqLworCX0gZnJvbTsKKwljaGFyIGFidWZbNTBdOworCWludCBmcm9tX3BvcnQgPSAwOworCXNvY2tsZW5fdCBmcm9tbGVuOworCWludCBsZW47CisJc3RydWN0IHJhZGl1c19tc2cgKm1zZywgKnJlcGx5ID0gTlVMTDsKKwlzdHJ1Y3QgcmFkaXVzX2hkciAqaGRyOworCXN0cnVjdCB3cGFidWYgKnJidWY7CisJdTMyIHZhbDsKKwlpbnQgcmVzOworCXN0cnVjdCBvc190aW1lIG5vdzsKKworCWZyb21sZW4gPSBzaXplb2YoZnJvbSk7CisJbGVuID0gcmVjdmZyb20oc29jaywgYnVmLCBzaXplb2YoYnVmKSwgMCwKKwkJICAgICAgIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmZyb20uc3MsICZmcm9tbGVuKTsKKwlpZiAobGVuIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkRBUzogcmVjdmZyb206ICVzIiwgc3RyZXJyb3IoZXJybm8pKTsKKwkJcmV0dXJuOworCX0KKworCW9zX3N0cmxjcHkoYWJ1ZiwgaW5ldF9udG9hKGZyb20uc2luLnNpbl9hZGRyKSwgc2l6ZW9mKGFidWYpKTsKKwlmcm9tX3BvcnQgPSBudG9ocyhmcm9tLnNpbi5zaW5fcG9ydCk7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRBUzogUmVjZWl2ZWQgJWQgYnl0ZXMgZnJvbSAlczolZCIsCisJCSAgIGxlbiwgYWJ1ZiwgZnJvbV9wb3J0KTsKKwlpZiAoZGFzLT5jbGllbnRfYWRkci51LnY0LnNfYWRkciAhPSBmcm9tLnNpbi5zaW5fYWRkci5zX2FkZHIpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEQVM6IERyb3AgbWVzc2FnZSBmcm9tIHVua25vd24gY2xpZW50Iik7CisJCXJldHVybjsKKwl9CisKKwltc2cgPSByYWRpdXNfbXNnX3BhcnNlKGJ1ZiwgbGVuKTsKKwlpZiAobXNnID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEQVM6IFBhcnNpbmcgaW5jb21pbmcgUkFESVVTIHBhY2tldCAiCisJCQkgICAiZnJvbSAlczolZCBmYWlsZWQiLCBhYnVmLCBmcm9tX3BvcnQpOworCQlyZXR1cm47CisJfQorCisJaWYgKHdwYV9kZWJ1Z19sZXZlbCA8PSBNU0dfTVNHRFVNUCkKKwkJcmFkaXVzX21zZ19kdW1wKG1zZyk7CisKKwlpZiAocmFkaXVzX21zZ192ZXJpZnlfZGFzX3JlcShtc2csIGRhcy0+c2hhcmVkX3NlY3JldCwKKwkJCQkgICAgICAgZGFzLT5zaGFyZWRfc2VjcmV0X2xlbikpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEQVM6IEludmFsaWQgYXV0aGVudGljYXRvciBpbiBwYWNrZXQgIgorCQkJICAgImZyb20gJXM6JWQgLSBkcm9wIiwgYWJ1ZiwgZnJvbV9wb3J0KTsKKwkJZ290byBmYWlsOworCX0KKworCW9zX2dldF90aW1lKCZub3cpOworCXJlcyA9IHJhZGl1c19tc2dfZ2V0X2F0dHIobXNnLCBSQURJVVNfQVRUUl9FVkVOVF9USU1FU1RBTVAsCisJCQkJICAodTggKikgJnZhbCwgNCk7CisJaWYgKHJlcyA9PSA0KSB7CisJCXUzMiB0aW1lc3RhbXAgPSBudG9obCh2YWwpOworCQlpZiAoYWJzKG5vdy5zZWMgLSB0aW1lc3RhbXApID4gZGFzLT50aW1lX3dpbmRvdykgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEQVM6IFVuYWNjZXB0YWJsZSAiCisJCQkJICAgIkV2ZW50LVRpbWVzdGFtcCAoJXU7IGxvY2FsIHRpbWUgJXUpIGluICIKKwkJCQkgICAicGFja2V0IGZyb20gJXM6JWQgLSBkcm9wIiwKKwkJCQkgICB0aW1lc3RhbXAsICh1bnNpZ25lZCBpbnQpIG5vdy5zZWMsCisJCQkJICAgYWJ1ZiwgZnJvbV9wb3J0KTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCX0gZWxzZSBpZiAoZGFzLT5yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRBUzogTWlzc2luZyBFdmVudC1UaW1lc3RhbXAgaW4gcGFja2V0ICIKKwkJCSAgICJmcm9tICVzOiVkIC0gZHJvcCIsIGFidWYsIGZyb21fcG9ydCk7CisJCWdvdG8gZmFpbDsKKwl9CisKKwloZHIgPSByYWRpdXNfbXNnX2dldF9oZHIobXNnKTsKKworCXN3aXRjaCAoaGRyLT5jb2RlKSB7CisJY2FzZSBSQURJVVNfQ09ERV9ESVNDT05ORUNUX1JFUVVFU1Q6CisJCXJlcGx5ID0gcmFkaXVzX2Rhc19kaXNjb25uZWN0KGRhcywgbXNnLCBhYnVmLCBmcm9tX3BvcnQpOworCQlicmVhazsKKwljYXNlIFJBRElVU19DT0RFX0NPQV9SRVFVRVNUOgorCQkvKiBUT0RPICovCisJCXJlcGx5ID0gcmFkaXVzX21zZ19uZXcoUkFESVVTX0NPREVfQ09BX05BSywKKwkJCQkgICAgICAgaGRyLT5pZGVudGlmaWVyKTsKKwkJaWYgKHJlcGx5ID09IE5VTEwpCisJCQlicmVhazsKKworCQkvKiBVbnN1cHBvcnRlZCBTZXJ2aWNlICovCisJCXJhZGl1c19tc2dfYWRkX2F0dHJfaW50MzIocmVwbHksIFJBRElVU19BVFRSX0VSUk9SX0NBVVNFLCA0MDUpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRBUzogVW5leHBlY3RlZCBSQURJVVMgY29kZSAldSBpbiAiCisJCQkgICAicGFja2V0IGZyb20gJXM6JWQiLAorCQkJICAgaGRyLT5jb2RlLCBhYnVmLCBmcm9tX3BvcnQpOworCX0KKworCWlmIChyZXBseSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRBUzogUmVwbHkgdG8gJXM6JWQiLCBhYnVmLCBmcm9tX3BvcnQpOworCisJCWlmICghcmFkaXVzX21zZ19hZGRfYXR0cl9pbnQzMihyZXBseSwKKwkJCQkJICAgICAgIFJBRElVU19BVFRSX0VWRU5UX1RJTUVTVEFNUCwKKwkJCQkJICAgICAgIG5vdy5zZWMpKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRBUzogRmFpbGVkIHRvIGFkZCAiCisJCQkJICAgIkV2ZW50LVRpbWVzdGFtcCBhdHRyaWJ1dGUiKTsKKwkJfQorCisJCWlmIChyYWRpdXNfbXNnX2ZpbmlzaF9kYXNfcmVzcChyZXBseSwgZGFzLT5zaGFyZWRfc2VjcmV0LAorCQkJCQkgICAgICAgZGFzLT5zaGFyZWRfc2VjcmV0X2xlbiwgaGRyKSA8CisJCSAgICAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRBUzogRmFpbGVkIHRvIGFkZCAiCisJCQkJICAgIk1lc3NhZ2UtQXV0aGVudGljYXRvciBhdHRyaWJ1dGUiKTsKKwkJfQorCisJCWlmICh3cGFfZGVidWdfbGV2ZWwgPD0gTVNHX01TR0RVTVApCisJCQlyYWRpdXNfbXNnX2R1bXAocmVwbHkpOworCisJCXJidWYgPSByYWRpdXNfbXNnX2dldF9idWYocmVwbHkpOworCQlyZXMgPSBzZW5kdG8oZGFzLT5zb2NrLCB3cGFidWZfaGVhZChyYnVmKSwKKwkJCSAgICAgd3BhYnVmX2xlbihyYnVmKSwgMCwKKwkJCSAgICAgKHN0cnVjdCBzb2NrYWRkciAqKSAmZnJvbS5zcywgZnJvbWxlbik7CisJCWlmIChyZXMgPCAwKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkRBUzogc2VuZHRvKHRvICVzOiVkKTogJXMiLAorCQkJCSAgIGFidWYsIGZyb21fcG9ydCwgc3RyZXJyb3IoZXJybm8pKTsKKwkJfQorCX0KKworZmFpbDoKKwlyYWRpdXNfbXNnX2ZyZWUobXNnKTsKKwlyYWRpdXNfbXNnX2ZyZWUocmVwbHkpOworfQorCisKK3N0YXRpYyBpbnQgcmFkaXVzX2Rhc19vcGVuX3NvY2tldChpbnQgcG9ydCkKK3sKKwlpbnQgczsKKwlzdHJ1Y3Qgc29ja2FkZHJfaW4gYWRkcjsKKworCXMgPSBzb2NrZXQoUEZfSU5FVCwgU09DS19ER1JBTSwgMCk7CisJaWYgKHMgPCAwKSB7CisJCXBlcnJvcigic29ja2V0Iik7CisJCXJldHVybiAtMTsKKwl9CisKKwlvc19tZW1zZXQoJmFkZHIsIDAsIHNpemVvZihhZGRyKSk7CisJYWRkci5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKKwlhZGRyLnNpbl9wb3J0ID0gaHRvbnMocG9ydCk7CisJaWYgKGJpbmQocywgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwgc2l6ZW9mKGFkZHIpKSA8IDApIHsKKwkJcGVycm9yKCJiaW5kIik7CisJCWNsb3NlKHMpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIHM7Cit9CisKKworc3RydWN0IHJhZGl1c19kYXNfZGF0YSAqCityYWRpdXNfZGFzX2luaXQoc3RydWN0IHJhZGl1c19kYXNfY29uZiAqY29uZikKK3sKKwlzdHJ1Y3QgcmFkaXVzX2Rhc19kYXRhICpkYXM7CisKKwlpZiAoY29uZi0+cG9ydCA9PSAwIHx8IGNvbmYtPnNoYXJlZF9zZWNyZXQgPT0gTlVMTCB8fAorCSAgICBjb25mLT5jbGllbnRfYWRkciA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWRhcyA9IG9zX3phbGxvYyhzaXplb2YoKmRhcykpOworCWlmIChkYXMgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlkYXMtPnRpbWVfd2luZG93ID0gY29uZi0+dGltZV93aW5kb3c7CisJZGFzLT5yZXF1aXJlX2V2ZW50X3RpbWVzdGFtcCA9IGNvbmYtPnJlcXVpcmVfZXZlbnRfdGltZXN0YW1wOworCWRhcy0+Y3R4ID0gY29uZi0+Y3R4OworCWRhcy0+ZGlzY29ubmVjdCA9IGNvbmYtPmRpc2Nvbm5lY3Q7CisKKwlvc19tZW1jcHkoJmRhcy0+Y2xpZW50X2FkZHIsIGNvbmYtPmNsaWVudF9hZGRyLAorCQkgIHNpemVvZihkYXMtPmNsaWVudF9hZGRyKSk7CisKKwlkYXMtPnNoYXJlZF9zZWNyZXQgPSBvc19tYWxsb2MoY29uZi0+c2hhcmVkX3NlY3JldF9sZW4pOworCWlmIChkYXMtPnNoYXJlZF9zZWNyZXQgPT0gTlVMTCkgeworCQlyYWRpdXNfZGFzX2RlaW5pdChkYXMpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJb3NfbWVtY3B5KGRhcy0+c2hhcmVkX3NlY3JldCwgY29uZi0+c2hhcmVkX3NlY3JldCwKKwkJICBjb25mLT5zaGFyZWRfc2VjcmV0X2xlbik7CisJZGFzLT5zaGFyZWRfc2VjcmV0X2xlbiA9IGNvbmYtPnNoYXJlZF9zZWNyZXRfbGVuOworCisJZGFzLT5zb2NrID0gcmFkaXVzX2Rhc19vcGVuX3NvY2tldChjb25mLT5wb3J0KTsKKwlpZiAoZGFzLT5zb2NrIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkZhaWxlZCB0byBvcGVuIFVEUCBzb2NrZXQgZm9yIFJBRElVUyAiCisJCQkgICAiREFTIik7CisJCXJhZGl1c19kYXNfZGVpbml0KGRhcyk7CisJCXJldHVybiBOVUxMOworCX0KKworCWlmIChlbG9vcF9yZWdpc3Rlcl9yZWFkX3NvY2soZGFzLT5zb2NrLCByYWRpdXNfZGFzX3JlY2VpdmUsIGRhcywgTlVMTCkpCisJeworCQlyYWRpdXNfZGFzX2RlaW5pdChkYXMpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlyZXR1cm4gZGFzOworfQorCisKK3ZvaWQgcmFkaXVzX2Rhc19kZWluaXQoc3RydWN0IHJhZGl1c19kYXNfZGF0YSAqZGFzKQoreworCWlmIChkYXMgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKGRhcy0+c29jayA+PSAwKSB7CisJCWVsb29wX3VucmVnaXN0ZXJfcmVhZF9zb2NrKGRhcy0+c29jayk7CisJCWNsb3NlKGRhcy0+c29jayk7CisJfQorCisJb3NfZnJlZShkYXMtPnNoYXJlZF9zZWNyZXQpOworCW9zX2ZyZWUoZGFzKTsKK30KZGlmZiAtLWdpdCBhL3NyYy9yYWRpdXMvcmFkaXVzX2Rhcy5oIGIvc3JjL3JhZGl1cy9yYWRpdXNfZGFzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzM4YjE4YgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy9yYWRpdXMvcmFkaXVzX2Rhcy5oCkBAIC0wLDAgKzEsNDcgQEAKKy8qCisgKiBSQURJVVMgRHluYW1pYyBBdXRob3JpemF0aW9uIFNlcnZlciAoREFTKQorICogQ29weXJpZ2h0IChjKSAyMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBSQURJVVNfREFTX0gKKyNkZWZpbmUgUkFESVVTX0RBU19ICisKK3N0cnVjdCByYWRpdXNfZGFzX2RhdGE7CisKK2VudW0gcmFkaXVzX2Rhc19yZXMgeworCVJBRElVU19EQVNfU1VDQ0VTUywKKwlSQURJVVNfREFTX05BU19NSVNNQVRDSCwKKwlSQURJVVNfREFTX1NFU1NJT05fTk9UX0ZPVU5ECit9OworCitzdHJ1Y3QgcmFkaXVzX2Rhc19hdHRycyB7CisJY29uc3QgdTggKnN0YV9hZGRyOworCWNvbnN0IHU4ICp1c2VyX25hbWU7CisJc2l6ZV90IHVzZXJfbmFtZV9sZW47CisJY29uc3QgdTggKmFjY3Rfc2Vzc2lvbl9pZDsKKwlzaXplX3QgYWNjdF9zZXNzaW9uX2lkX2xlbjsKKwljb25zdCB1OCAqY3VpOworCXNpemVfdCBjdWlfbGVuOworfTsKKworc3RydWN0IHJhZGl1c19kYXNfY29uZiB7CisJaW50IHBvcnQ7CisJY29uc3QgdTggKnNoYXJlZF9zZWNyZXQ7CisJc2l6ZV90IHNoYXJlZF9zZWNyZXRfbGVuOworCWNvbnN0IHN0cnVjdCBob3N0YXBkX2lwX2FkZHIgKmNsaWVudF9hZGRyOworCXVuc2lnbmVkIGludCB0aW1lX3dpbmRvdzsKKwlpbnQgcmVxdWlyZV9ldmVudF90aW1lc3RhbXA7CisJdm9pZCAqY3R4OworCWVudW0gcmFkaXVzX2Rhc19yZXMgKCpkaXNjb25uZWN0KSh2b2lkICpjdHgsCisJCQkJCSAgc3RydWN0IHJhZGl1c19kYXNfYXR0cnMgKmF0dHIpOworfTsKKworc3RydWN0IHJhZGl1c19kYXNfZGF0YSAqCityYWRpdXNfZGFzX2luaXQoc3RydWN0IHJhZGl1c19kYXNfY29uZiAqY29uZik7CisKK3ZvaWQgcmFkaXVzX2Rhc19kZWluaXQoc3RydWN0IHJhZGl1c19kYXNfZGF0YSAqZGF0YSk7CisKKyNlbmRpZiAvKiBSQURJVVNfREFTX0ggKi8KZGlmZiAtLWdpdCBhL3NyYy9yc25fc3VwcC90ZGxzLmMgYi9zcmMvcnNuX3N1cHAvdGRscy5jCmluZGV4IDZlYmMzN2EuLjc2NDZjYTggMTAwNjQ0Ci0tLSBhL3NyYy9yc25fc3VwcC90ZGxzLmMKKysrIGIvc3JjL3Jzbl9zdXBwL3RkbHMuYwpAQCAtMjIwMiw3ICsyMjAyLDkgQEAKIAlpZiAoc20gPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCi0Jc20tPmwyX3RkbHMgPSBsMl9wYWNrZXRfaW5pdChzbS0+aWZuYW1lLCBzbS0+b3duX2FkZHIsCisJc20tPmwyX3RkbHMgPSBsMl9wYWNrZXRfaW5pdChzbS0+YnJpZGdlX2lmbmFtZSA/IHNtLT5icmlkZ2VfaWZuYW1lIDoKKwkJCQkgICAgIHNtLT5pZm5hbWUsCisJCQkJICAgICBzbS0+b3duX2FkZHIsCiAJCQkJICAgICBFVEhfUF84MDIxMV9FTkNBUCwgd3BhX3N1cHBsaWNhbnRfcnhfdGRscywKIAkJCQkgICAgIHNtLCAwKTsKIAlpZiAoc20tPmwyX3RkbHMgPT0gTlVMTCkgewpkaWZmIC0tZ2l0IGEvc3JjL3Rscy9saWJ0b21tYXRoLmMgYi9zcmMvdGxzL2xpYnRvbW1hdGguYwppbmRleCA3Yzk4NTdmLi43NDFiNDQyIDEwMDY0NAotLS0gYS9zcmMvdGxzL2xpYnRvbW1hdGguYworKysgYi9zcmMvdGxzL2xpYnRvbW1hdGguYwpAQCAtNjYsMTEgKzY2LDE5IEBACiAKICNkZWZpbmUgIE9QVF9DQVNUKHgpCiAKKyNpZmRlZiBfX3g4Nl82NF9fCit0eXBlZGVmIHVuc2lnbmVkIGxvbmcgbXBfZGlnaXQ7Cit0eXBlZGVmIHVuc2lnbmVkIGxvbmcgbXBfd29yZCBfX2F0dHJpYnV0ZV9fKChtb2RlKFRJKSkpOworCisjZGVmaW5lIERJR0lUX0JJVCA2MAorI2RlZmluZSBNUF82NEJJVAorI2Vsc2UKIHR5cGVkZWYgdW5zaWduZWQgbG9uZyBtcF9kaWdpdDsKIHR5cGVkZWYgdTY0IG1wX3dvcmQ7CiAKICNkZWZpbmUgRElHSVRfQklUICAgICAgICAgIDI4CiAjZGVmaW5lIE1QXzI4QklUCisjZW5kaWYKIAogCiAjZGVmaW5lIFhNQUxMT0MgIG9zX21hbGxvYwpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2J1aWxkX2NvbmZpZy5oIGIvc3JjL3V0aWxzL2J1aWxkX2NvbmZpZy5oCmluZGV4IDA0YjhkOTguLmY5NDczODggMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9idWlsZF9jb25maWcuaAorKysgYi9zcmMvdXRpbHMvYnVpbGRfY29uZmlnLmgKQEAgLTQ3LDI4ICs0Nyw2IEBACiAjZW5kaWYgLyogVVNFX0lOVEVSTkFMX0NSWVBUTyAqLwogI2VuZGlmIC8qIENPTkZJR19XSU4zMl9ERUZBVUxUUyAqLwogCi0jaWZkZWYgX19TWU1CSUFOMzJfXwotI2RlZmluZSBPU19OT19DX0xJQl9ERUZJTkVTCi0jZGVmaW5lIENPTkZJR19BTlNJX0NfRVhUUkEKLSNkZWZpbmUgQ09ORklHX05PX1dQQV9NU0cKLSNkZWZpbmUgQ09ORklHX05PX0hPU1RBUERfTE9HR0VSCi0jZGVmaW5lIENPTkZJR19OT19TVERPVVRfREVCVUcKLSNkZWZpbmUgQ09ORklHX0JBQ0tFTkRfRklMRQotI2RlZmluZSBDT05GSUdfSU5URVJOQUxfTElCVE9NTUFUSAotI2RlZmluZSBDT05GSUdfQ1JZUFRPX0lOVEVSTkFMCi0jZGVmaW5lIElFRUU4MDIxWF9FQVBPTAotI2RlZmluZSBQS0NTMTJfRlVOQ1MKLSNkZWZpbmUgRUFQX01ENQotI2RlZmluZSBFQVBfVExTCi0jZGVmaW5lIEVBUF9NU0NIQVB2MgotI2RlZmluZSBFQVBfUEVBUAotI2RlZmluZSBFQVBfVFRMUwotI2RlZmluZSBFQVBfR1RDCi0jZGVmaW5lIEVBUF9PVFAKLSNkZWZpbmUgRUFQX0xFQVAKLSNkZWZpbmUgRUFQX0ZBU1QKLSNlbmRpZiAvKiBfX1NZTUJJQU4zMl9fICovCi0KICNpZmRlZiBDT05GSUdfWENPREVfREVGQVVMVFMKICNkZWZpbmUgQ09ORklHX0RSSVZFUl9PU1gKICNkZWZpbmUgQ09ORklHX0JBQ0tFTkRfRklMRQpkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL2NvbW1vbi5oIGIvc3JjL3V0aWxzL2NvbW1vbi5oCmluZGV4IDQzY2ViNTQuLjdmMTE1ZWYgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9jb21tb24uaAorKysgYi9zcmMvdXRpbHMvY29tbW9uLmgKQEAgLTYzLDEyICs2Myw2IEBACiAjZW5kaWYKICNlbmRpZiAvKiBDT05GSUdfVElfQ09NUElMRVIgKi8KIAotI2lmZGVmIF9fU1lNQklBTjMyX18KLSNkZWZpbmUgX19CSUdfRU5ESUFOIDQzMjEKLSNkZWZpbmUgX19MSVRUTEVfRU5ESUFOIDEyMzQKLSNkZWZpbmUgX19CWVRFX09SREVSIF9fTElUVExFX0VORElBTgotI2VuZGlmIC8qIF9fU1lNQklBTjMyX18gKi8KLQogI2lmZGVmIENPTkZJR19OQVRJVkVfV0lORE9XUwogI2luY2x1ZGUgPHdpbnNvY2suaD4KIApAQCAtMTMyLDE2ICsxMjYsNiBAQAogI2RlZmluZSBXUEFfVFlQRVNfREVGSU5FRAogI2VuZGlmIC8qIENPTkZJR19USV9DT01QSUxFUiAqLwogCi0jaWZkZWYgX19TWU1CSUFOMzJfXwotI2RlZmluZSBfX1JFTU9WRV9QTEFUU0VDX0RJQUdOT1NUSUNTX18KLSNpbmNsdWRlIDxlMzJkZWYuaD4KLXR5cGVkZWYgVFVpbnQ2NCB1NjQ7Ci10eXBlZGVmIFRVaW50MzIgdTMyOwotdHlwZWRlZiBUVWludDE2IHUxNjsKLXR5cGVkZWYgVFVpbnQ4IHU4OwotI2RlZmluZSBXUEFfVFlQRVNfREVGSU5FRAotI2VuZGlmIC8qIF9fU1lNQklBTjMyX18gKi8KLQogI2lmbmRlZiBXUEFfVFlQRVNfREVGSU5FRAogI2lmZGVmIENPTkZJR19VU0VfSU5UVFlQRVNfSAogI2luY2x1ZGUgPGludHR5cGVzLmg+CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvZWxvb3AuYyBiL3NyYy91dGlscy9lbG9vcC5jCmluZGV4IDU2OTFmMTUuLmJiMzI0MDEgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9lbG9vcC5jCisrKyBiL3NyYy91dGlscy9lbG9vcC5jCkBAIC0yNzgsNyArMjc4LDcgQEAKIAkJCQlwb2xsZmRzX21hcFtmZF0gPSBwZmQ7CiAJCQkJbnh0Kys7CiAJCQl9Ci0JCQlwZmQtPmV2ZW50cyB8PSBQT0xMSU47CisJCQlwZmQtPmV2ZW50cyB8PSBQT0xMT1VUOwogCQl9CiAJfQogCkBAIC0zNTAsNyArMzUwLDggQEAKIAkJCQkgICAgICBpbnQgbWF4X3BvbGxmZF9tYXApCiB7CiAJaWYgKGVsb29wX3NvY2tfdGFibGVfZGlzcGF0Y2hfdGFibGUocmVhZGVycywgcG9sbGZkc19tYXAsCi0JCQkJCSAgICBtYXhfcG9sbGZkX21hcCwgUE9MTElOKSkKKwkJCQkJICAgIG1heF9wb2xsZmRfbWFwLCBQT0xMSU4gfCBQT0xMRVJSIHwKKwkJCQkJICAgIFBPTExIVVApKQogCQlyZXR1cm47IC8qIHBvbGxmZHMgbWF5IGJlIGludmFsaWQgYXQgdGhpcyBwb2ludCAqLwogCiAJaWYgKGVsb29wX3NvY2tfdGFibGVfZGlzcGF0Y2hfdGFibGUod3JpdGVycywgcG9sbGZkc19tYXAsCmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvaW5jbHVkZXMuaCBiL3NyYy91dGlscy9pbmNsdWRlcy5oCmluZGV4IDc4N2JlMTguLjZjNmVjODcgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9pbmNsdWRlcy5oCisrKyBiL3NyYy91dGlscy9pbmNsdWRlcy5oCkBAIC00MSw5ICs0MSw3IEBACiAjaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgogI2luY2x1ZGUgPGFycGEvaW5ldC5oPgogI2lmbmRlZiBfX3Z4d29ya3MKLSNpZm5kZWYgX19TWU1CSUFOMzJfXwogI2luY2x1ZGUgPHN5cy91aW8uaD4KLSNlbmRpZiAvKiBfX1NZTUJJQU4zMl9fICovCiAjaW5jbHVkZSA8c3lzL3RpbWUuaD4KICNlbmRpZiAvKiBfX3Z4d29ya3MgKi8KICNlbmRpZiAvKiBDT05GSUdfVElfQ09NUElMRVIgKi8KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9wY3NjX2Z1bmNzLmMgYi9zcmMvdXRpbHMvcGNzY19mdW5jcy5jCmluZGV4IGE5N2Y5ZmEuLjA4NTEwZDAgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9wY3NjX2Z1bmNzLmMKKysrIGIvc3JjL3V0aWxzL3Bjc2NfZnVuY3MuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXUEEgU3VwcGxpY2FudCAvIFBDL1NDIHNtYXJ0Y2FyZCBpbnRlcmZhY2UgZm9yIFVTSU0sIEdTTSBTSU0KLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA3LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDcsIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTcwLDYgKzcwLDkgQEAKICNkZWZpbmUgVVNJTV9UTFZfVE9UQUxfRklMRV9TSVpFCTB4ODEKICNkZWZpbmUgVVNJTV9UTFZfUElOX1NUQVRVU19URU1QTEFURQkweEM2CiAjZGVmaW5lIFVTSU1fVExWX1NIT1JUX0ZJTEVfSUQJCTB4ODgKKyNkZWZpbmUgVVNJTV9UTFZfU0VDVVJJVFlfQVRUUl84QgkweDhCCisjZGVmaW5lIFVTSU1fVExWX1NFQ1VSSVRZX0FUVFJfOEMJMHg4QworI2RlZmluZSBVU0lNX1RMVl9TRUNVUklUWV9BVFRSX0FCCTB4QUIKIAogI2RlZmluZSBVU0lNX1BTX0RPX1RBRwkJCTB4OTAKIApAQCAtODEsNiArODQsMjcgQEAKICNkZWZpbmUgQ0tfTEVOIDE2CiAKIAorLyogR1NNIGZpbGVzCisgKiBGaWxlIHR5cGUgaW4gZmlyc3Qgb2N0ZXQ6CisgKiAzRiA9IE1hc3RlciBGaWxlCisgKiA3RiA9IERlZGljYXRlZCBGaWxlCisgKiAyRiA9IEVsZW1lbnRhcnkgRmlsZSB1bmRlciB0aGUgTWFzdGVyIEZpbGUKKyAqIDZGID0gRWxlbWVudGFyeSBGaWxlIHVuZGVyIGEgRGVkaWNhdGVkIEZpbGUKKyAqLworI2RlZmluZSBTQ0FSRF9GSUxFX01GCQkweDNGMDAKKyNkZWZpbmUgU0NBUkRfRklMRV9HU01fREYJMHg3RjIwCisjZGVmaW5lIFNDQVJEX0ZJTEVfVU1UU19ERgkweDdGNTAKKyNkZWZpbmUgU0NBUkRfRklMRV9HU01fRUZfSU1TSQkweDZGMDcKKyNkZWZpbmUgU0NBUkRfRklMRV9HU01fRUZfQUQJMHg2RkFECisjZGVmaW5lIFNDQVJEX0ZJTEVfRUZfRElSCTB4MkYwMAorI2RlZmluZSBTQ0FSRF9GSUxFX0VGX0lDQ0lECTB4MkZFMgorI2RlZmluZSBTQ0FSRF9GSUxFX0VGX0NLCTB4NkZFMQorI2RlZmluZSBTQ0FSRF9GSUxFX0VGX0lLCTB4NkZFMgorCisjZGVmaW5lIFNDQVJEX0NIVjFfT0ZGU0VUCTEzCisjZGVmaW5lIFNDQVJEX0NIVjFfRkxBRwkJMHg4MAorCisKIHR5cGVkZWYgZW51bSB7IFNDQVJEX0dTTV9TSU0sIFNDQVJEX1VTSU0gfSBzaW1fdHlwZXM7CiAKIHN0cnVjdCBzY2FyZF9kYXRhIHsKQEAgLTIzNCwzNyArMjU4LDYwIEBACiBzdGF0aWMgaW50IHNjYXJkX3BhcnNlX2ZzcF90ZW1wbCh1bnNpZ25lZCBjaGFyICpidWYsIHNpemVfdCBidWZfbGVuLAogCQkJCSBpbnQgKnBzX2RvLCBpbnQgKmZpbGVfbGVuKQogewotCQl1bnNpZ25lZCBjaGFyICpwb3MsICplbmQ7CisJdW5zaWduZWQgY2hhciAqcG9zLCAqZW5kOwogCi0JCWlmIChwc19kbykKLQkJCSpwc19kbyA9IC0xOwotCQlpZiAoZmlsZV9sZW4pCi0JCQkqZmlsZV9sZW4gPSAtMTsKKwlpZiAocHNfZG8pCisJCSpwc19kbyA9IC0xOworCWlmIChmaWxlX2xlbikKKwkJKmZpbGVfbGVuID0gLTE7CiAKLQkJcG9zID0gYnVmOwotCQllbmQgPSBwb3MgKyBidWZfbGVuOwotCQlpZiAoKnBvcyAhPSBVU0lNX0ZTUF9URU1QTF9UQUcpIHsKLQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0NBUkQ6IGZpbGUgaGVhZGVyIGRpZCBub3QgIgotCQkJCSAgICJzdGFydCB3aXRoIEZTUCB0ZW1wbGF0ZSB0YWciKTsKLQkJCXJldHVybiAtMTsKLQkJfQotCQlwb3MrKzsKLQkJaWYgKHBvcyA+PSBlbmQpCi0JCQlyZXR1cm4gLTE7Ci0JCWlmICgocG9zICsgcG9zWzBdKSA8IGVuZCkKLQkJCWVuZCA9IHBvcyArIDEgKyBwb3NbMF07Ci0JCXBvcysrOwotCQl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJTQ0FSRDogZmlsZSBoZWFkZXIgRlNQIHRlbXBsYXRlIiwKLQkJCSAgICBwb3MsIGVuZCAtIHBvcyk7CisJcG9zID0gYnVmOworCWVuZCA9IHBvcyArIGJ1Zl9sZW47CisJaWYgKCpwb3MgIT0gVVNJTV9GU1BfVEVNUExfVEFHKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0NBUkQ6IGZpbGUgaGVhZGVyIGRpZCBub3QgIgorCQkJICAgInN0YXJ0IHdpdGggRlNQIHRlbXBsYXRlIHRhZyIpOworCQlyZXR1cm4gLTE7CisJfQorCXBvcysrOworCWlmIChwb3MgPj0gZW5kKQorCQlyZXR1cm4gLTE7CisJaWYgKChwb3MgKyBwb3NbMF0pIDwgZW5kKQorCQllbmQgPSBwb3MgKyAxICsgcG9zWzBdOworCXBvcysrOworCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIlNDQVJEOiBmaWxlIGhlYWRlciBGU1AgdGVtcGxhdGUiLAorCQkgICAgcG9zLCBlbmQgLSBwb3MpOwogCi0JCXdoaWxlIChwb3MgKyAxIDwgZW5kKSB7Ci0JCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiU0NBUkQ6IGZpbGUgaGVhZGVyIFRMViAiCi0JCQkJICAgIjB4JTAyeCBsZW49JWQiLCBwb3NbMF0sIHBvc1sxXSk7Ci0JCQlpZiAocG9zICsgMiArIHBvc1sxXSA+IGVuZCkKLQkJCQlicmVhazsKKwl3aGlsZSAocG9zICsgMSA8IGVuZCkgeworCQl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiU0NBUkQ6IGZpbGUgaGVhZGVyIFRMViAweCUwMnggbGVuPSVkIiwKKwkJCSAgIHBvc1swXSwgcG9zWzFdKTsKKwkJaWYgKHBvcyArIDIgKyBwb3NbMV0gPiBlbmQpCisJCQlicmVhazsKIAotCQkJaWYgKHBvc1swXSA9PSBVU0lNX1RMVl9GSUxFX1NJWkUgJiYKLQkJCSAgICAocG9zWzFdID09IDEgfHwgcG9zWzFdID09IDIpICYmIGZpbGVfbGVuKSB7CisJCXN3aXRjaCAocG9zWzBdKSB7CisJCWNhc2UgVVNJTV9UTFZfRklMRV9ERVNDOgorCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJTQ0FSRDogRmlsZSBEZXNjcmlwdG9yIFRMViIsCisJCQkJICAgIHBvcyArIDIsIHBvc1sxXSk7CisJCQlicmVhazsKKwkJY2FzZSBVU0lNX1RMVl9GSUxFX0lEOgorCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJTQ0FSRDogRmlsZSBJZGVudGlmaWVyIFRMViIsCisJCQkJICAgIHBvcyArIDIsIHBvc1sxXSk7CisJCQlicmVhazsKKwkJY2FzZSBVU0lNX1RMVl9ERl9OQU1FOgorCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJTQ0FSRDogREYgbmFtZSAoQUlEKSBUTFYiLAorCQkJCSAgICBwb3MgKyAyLCBwb3NbMV0pOworCQkJYnJlYWs7CisJCWNhc2UgVVNJTV9UTFZfUFJPUFJfSU5GTzoKKwkJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiU0NBUkQ6IFByb3ByaWV0YXJ5ICIKKwkJCQkgICAgImluZm9ybWF0aW9uIFRMViIsIHBvcyArIDIsIHBvc1sxXSk7CisJCQlicmVhazsKKwkJY2FzZSBVU0lNX1RMVl9MSUZFX0NZQ0xFX1NUQVRVUzoKKwkJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiU0NBUkQ6IExpZmUgQ3ljbGUgU3RhdHVzICIKKwkJCQkgICAgIkludGVnZXIgVExWIiwgcG9zICsgMiwgcG9zWzFdKTsKKwkJCWJyZWFrOworCQljYXNlIFVTSU1fVExWX0ZJTEVfU0laRToKKwkJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiU0NBUkQ6IEZpbGUgc2l6ZSBUTFYiLAorCQkJCSAgICBwb3MgKyAyLCBwb3NbMV0pOworCQkJaWYgKChwb3NbMV0gPT0gMSB8fCBwb3NbMV0gPT0gMikgJiYgZmlsZV9sZW4pIHsKIAkJCQlpZiAocG9zWzFdID09IDEpCiAJCQkJCSpmaWxlX2xlbiA9IChpbnQpIHBvc1syXTsKIAkJCQllbHNlCkBAIC0yNzMsMjEgKzMyMCw0MyBAQAogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0NBUkQ6IGZpbGVfc2l6ZT0lZCIsCiAJCQkJCSAgICpmaWxlX2xlbik7CiAJCQl9Ci0KLQkJCWlmIChwb3NbMF0gPT0gVVNJTV9UTFZfUElOX1NUQVRVU19URU1QTEFURSAmJgotCQkJICAgIHBvc1sxXSA+PSAyICYmIHBvc1syXSA9PSBVU0lNX1BTX0RPX1RBRyAmJgorCQkJYnJlYWs7CisJCWNhc2UgVVNJTV9UTFZfVE9UQUxfRklMRV9TSVpFOgorCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJTQ0FSRDogVG90YWwgZmlsZSBzaXplIFRMViIsCisJCQkJICAgIHBvcyArIDIsIHBvc1sxXSk7CisJCQlicmVhazsKKwkJY2FzZSBVU0lNX1RMVl9QSU5fU1RBVFVTX1RFTVBMQVRFOgorCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJTQ0FSRDogUElOIFN0YXR1cyBUZW1wbGF0ZSAiCisJCQkJICAgICJETyBUTFYiLCBwb3MgKyAyLCBwb3NbMV0pOworCQkJaWYgKHBvc1sxXSA+PSAyICYmIHBvc1syXSA9PSBVU0lNX1BTX0RPX1RBRyAmJgogCQkJICAgIHBvc1szXSA+PSAxICYmIHBzX2RvKSB7CiAJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogUFNfRE89MHglMDJ4IiwKIAkJCQkJICAgcG9zWzRdKTsKIAkJCQkqcHNfZG8gPSAoaW50KSBwb3NbNF07CiAJCQl9Ci0KLQkJCXBvcyArPSAyICsgcG9zWzFdOwotCi0JCQlpZiAocG9zID09IGVuZCkKLQkJCQlyZXR1cm4gMDsKKwkJCWJyZWFrOworCQljYXNlIFVTSU1fVExWX1NIT1JUX0ZJTEVfSUQ6CisJCQl3cGFfaGV4ZHVtcChNU0dfTVNHRFVNUCwgIlNDQVJEOiBTaG9ydCBGaWxlICIKKwkJCQkgICAgIklkZW50aWZpZXIgKFNGSSkgVExWIiwgcG9zICsgMiwgcG9zWzFdKTsKKwkJCWJyZWFrOworCQljYXNlIFVTSU1fVExWX1NFQ1VSSVRZX0FUVFJfOEI6CisJCWNhc2UgVVNJTV9UTFZfU0VDVVJJVFlfQVRUUl84QzoKKwkJY2FzZSBVU0lNX1RMVl9TRUNVUklUWV9BVFRSX0FCOgorCQkJd3BhX2hleGR1bXAoTVNHX01TR0RVTVAsICJTQ0FSRDogU2VjdXJpdHkgYXR0cmlidXRlICIKKwkJCQkgICAgIlRMViIsIHBvcyArIDIsIHBvc1sxXSk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiU0NBUkQ6IFVucmVjb2duaXplZCBUTFYiLAorCQkJCSAgICBwb3MsIDIgKyBwb3NbMV0pOworCQkJYnJlYWs7CiAJCX0KLQkJcmV0dXJuIC0xOworCisJCXBvcyArPSAyICsgcG9zWzFdOworCisJCWlmIChwb3MgPT0gZW5kKQorCQkJcmV0dXJuIDA7CisJfQorCXJldHVybiAtMTsKIH0KIAogCkBAIC0zMjgsNyArMzk3LDcgQEAKIAkJdW5zaWduZWQgY2hhciByaWRbNV07CiAJCXVuc2lnbmVkIGNoYXIgYXBwbF9jb2RlWzJdOyAvKiAweDEwMDIgZm9yIDNHIFVTSU0gKi8KIAl9ICplZmRpcjsKLQl1bnNpZ25lZCBjaGFyIGJ1ZlsxMDBdOworCXVuc2lnbmVkIGNoYXIgYnVmWzEyN107CiAJc2l6ZV90IGJsZW47CiAKIAllZmRpciA9IChzdHJ1Y3QgZWZkaXIgKikgYnVmOwpAQCAtNDE3LDYgKzQ4Niw3IEBACiAvKioKICAqIHNjYXJkX2luaXQgLSBJbml0aWFsaXplIFNJTS9VU0lNIGNvbm5lY3Rpb24gdXNpbmcgUEMvU0MKICAqIEBzaW1fdHlwZTogQWxsb3dlZCBTSU0gdHlwZXMgKFNJTSwgVVNJTSwgb3IgYm90aCkKKyAqIEByZWFkZXI6IFJlYWRlciBuYW1lIHByZWZpeCB0byBzZWFyY2ggZm9yCiAgKiBSZXR1cm5zOiBQb2ludGVyIHRvIHByaXZhdGUgZGF0YSBzdHJ1Y3R1cmUsIG9yICVOVUxMIG9uIGZhaWx1cmUKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gaW5pdGlhbGl6ZSBTSU0vVVNJTSBjb25uZWN0aW9uLiBQQy9TQyBpcyB1c2VkIHRvCkBAIC00MjUsMTAgKzQ5NSwxMCBAQAogICogYWNjZXNzIHNvbWUgb2YgdGhlIGNhcmQgZnVuY3Rpb25zLiBPbmNlIHRoZSBjb25uZWN0aW9uIGlzIG5vdCBuZWVkZWQKICAqIGFueW1vcmUsIHNjYXJkX2RlaW5pdCgpIGNhbiBiZSB1c2VkIHRvIGNsb3NlIGl0LgogICovCi1zdHJ1Y3Qgc2NhcmRfZGF0YSAqIHNjYXJkX2luaXQoc2NhcmRfc2ltX3R5cGUgc2ltX3R5cGUpCitzdHJ1Y3Qgc2NhcmRfZGF0YSAqIHNjYXJkX2luaXQoc2NhcmRfc2ltX3R5cGUgc2ltX3R5cGUsIGNvbnN0IGNoYXIgKnJlYWRlcikKIHsKIAlsb25nIHJldDsKLQl1bnNpZ25lZCBsb25nIGxlbjsKKwl1bnNpZ25lZCBsb25nIGxlbiwgcG9zOwogCXN0cnVjdCBzY2FyZF9kYXRhICpzY2FyZDsKICNpZmRlZiBDT05GSUdfTkFUSVZFX1dJTkRPV1MKIAlUQ0hBUiAqcmVhZGVycyA9IE5VTEw7CkBAIC00ODIsMTggKzU1Miw0MSBAQAogCQkJICAgImF2YWlsYWJsZS4iKTsKIAkJZ290byBmYWlsZWQ7CiAJfQotCS8qIHJlYWRlcnMgaXMgYSBsaXN0IG9mIGF2YWlsYWJsZSByZWFkZXIuIExhc3QgZW50cnkgaXMgdGVybWluYXRlZCB3aXRoCi0JICogZG91YmxlIE5VTC4KLQkgKiBUT0RPOiBhZGQgc3VwcG9ydCBmb3Igc2VsZWN0aW5nIHRoZSByZWFkZXI7IG5vdyBqdXN0IHVzZSB0aGUgZmlyc3QKLQkgKiBvbmUuLiAqLworCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIlNDQVJEOiBSZWFkZXJzIiwgKHU4ICopIHJlYWRlcnMsIGxlbik7CisJLyoKKwkgKiByZWFkZXJzIGlzIGEgbGlzdCBvZiBhdmFpbGFibGUgcmVhZGVycy4gVGhlIGxhc3QgZW50cnkgaXMgdGVybWluYXRlZAorCSAqIHdpdGggZG91YmxlIG51bGwuCisJICovCisJcG9zID0gMDsKICNpZmRlZiBVTklDT0RFCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogU2VsZWN0ZWQgcmVhZGVyPSclUyciLCByZWFkZXJzKTsKKwkvKiBUT0RPICovCiAjZWxzZSAvKiBVTklDT0RFICovCi0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogU2VsZWN0ZWQgcmVhZGVyPSclcyciLCByZWFkZXJzKTsKKwl3aGlsZSAocG9zIDwgbGVuKSB7CisJCWlmIChyZWFkZXIgPT0gTlVMTCB8fAorCQkgICAgb3Nfc3RybmNtcCgmcmVhZGVyc1twb3NdLCByZWFkZXIsIG9zX3N0cmxlbihyZWFkZXIpKSA9PSAwKQorCQkJYnJlYWs7CisJCXdoaWxlIChwb3MgPCBsZW4gJiYgcmVhZGVyc1twb3NdKQorCQkJcG9zKys7CisJCXBvcysrOyAvKiBza2lwIHNlcGFyYXRpbmcgbnVsbCAqLworCQlpZiAocG9zIDwgbGVuICYmIHJlYWRlcnNbcG9zXSA9PSAnXDAnKQorCQkJcG9zID0gbGVuOyAvKiBkb3VibGUgbnVsbCB0ZXJtaW5hdGVzIGxpc3QgKi8KKwl9CisjZW5kaWYgLyogVU5JQ09ERSAqLworCWlmIChwb3MgPj0gbGVuKSB7CisJCXdwYV9wcmludGYoTVNHX1dBUk5JTkcsICJTQ0FSRDogTm8gcmVhZGVyIHdpdGggcHJlZml4ICclcycgIgorCQkJICAgImZvdW5kIiwgcmVhZGVyKTsKKwkJZ290byBmYWlsZWQ7CisJfQorCisjaWZkZWYgVU5JQ09ERQorCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU0NBUkQ6IFNlbGVjdGVkIHJlYWRlcj0nJVMnIiwgJnJlYWRlcnNbcG9zXSk7CisjZWxzZSAvKiBVTklDT0RFICovCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogU2VsZWN0ZWQgcmVhZGVyPSclcyciLCAmcmVhZGVyc1twb3NdKTsKICNlbmRpZiAvKiBVTklDT0RFICovCiAKLQlyZXQgPSBTQ2FyZENvbm5lY3Qoc2NhcmQtPmN0eCwgcmVhZGVycywgU0NBUkRfU0hBUkVfU0hBUkVELAotCQkJICAgU0NBUkRfUFJPVE9DT0xfVDAsICZzY2FyZC0+Y2FyZCwgJnNjYXJkLT5wcm90b2NvbCk7CisJcmV0ID0gU0NhcmRDb25uZWN0KHNjYXJkLT5jdHgsICZyZWFkZXJzW3Bvc10sIFNDQVJEX1NIQVJFX1NIQVJFRCwKKwkJCSAgIFNDQVJEX1BST1RPQ09MX1QwIHwgU0NBUkRfUFJPVE9DT0xfVDEsCisJCQkgICAmc2NhcmQtPmNhcmQsICZzY2FyZC0+cHJvdG9jb2wpOwogCWlmIChyZXQgIT0gU0NBUkRfU19TVUNDRVNTKSB7CiAJCWlmIChyZXQgPT0gKGxvbmcpIFNDQVJEX0VfTk9fU01BUlRDQVJEKQogCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIk5vIHNtYXJ0IGNhcmQgaW5zZXJ0ZWQuIik7CkBAIC01ODIsNyArNjc1LDggQEAKIAl9CiAJaWYgKHBpbl9uZWVkZWQpIHsKIAkJc2NhcmQtPnBpbjFfcmVxdWlyZWQgPSAxOwotCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlBJTjEgbmVlZGVkIGZvciBTSU0gYWNjZXNzIik7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUElOMSBuZWVkZWQgZm9yIFNJTSBhY2Nlc3MgKHJldHJ5ICIKKwkJCSAgICJjb3VudGVyPSVkKSIsIHNjYXJkX2dldF9waW5fcmV0cnlfY291bnRlcihzY2FyZCkpOwogCX0KIAogCXJldCA9IFNDYXJkRW5kVHJhbnNhY3Rpb24oc2NhcmQtPmNhcmQsIFNDQVJEX0xFQVZFX0NBUkQpOwpAQCAtOTM5LDYgKzEwMzMsNDYgQEAKIH0KIAogCitpbnQgc2NhcmRfZ2V0X3Bpbl9yZXRyeV9jb3VudGVyKHN0cnVjdCBzY2FyZF9kYXRhICpzY2FyZCkKK3sKKwlsb25nIHJldDsKKwl1bnNpZ25lZCBjaGFyIHJlc3BbM107CisJdW5zaWduZWQgY2hhciBjbWRbNV0gPSB7IFNJTV9DTURfVkVSSUZZX0NIVjEgfTsKKwlzaXplX3QgbGVuOworCXUxNiB2YWw7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNDQVJEOiBmZXRjaGluZyBQSU4gcmV0cnkgY291bnRlciIpOworCisJaWYgKHNjYXJkLT5zaW1fdHlwZSA9PSBTQ0FSRF9VU0lNKQorCQljbWRbMF0gPSBVU0lNX0NMQTsKKwljbWRbNF0gPSAwOyAvKiBFbXB0eSBkYXRhICovCisKKwlsZW4gPSBzaXplb2YocmVzcCk7CisJcmV0ID0gc2NhcmRfdHJhbnNtaXQoc2NhcmQsIGNtZCwgc2l6ZW9mKGNtZCksIHJlc3AsICZsZW4pOworCWlmIChyZXQgIT0gU0NBUkRfU19TVUNDRVNTKQorCQlyZXR1cm4gLTI7CisKKwlpZiAobGVuICE9IDIpIHsKKwkJd3BhX3ByaW50ZihNU0dfV0FSTklORywgIlNDQVJEOiBmYWlsZWQgdG8gZmV0Y2ggUElOIHJldHJ5ICIKKwkJCSAgICJjb3VudGVyIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl2YWwgPSBXUEFfR0VUX0JFMTYocmVzcCk7CisJaWYgKHZhbCA9PSAweDYzYzAgfHwgdmFsID09IDB4Njk4MykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNDQVJEOiBQSU4gaGFzIGJlZW4gYmxvY2tlZCIpOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAodmFsID49IDB4NjNjMCAmJiB2YWwgPD0gMHg2M2NmKQorCQlyZXR1cm4gdmFsICYgMHgwMDBmOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogVW5leHBlY3RlZCBQSU4gcmV0cnkgY291bnRlciByZXNwb25zZSAiCisJCSAgICJ2YWx1ZSAweCV4IiwgdmFsKTsKKwlyZXR1cm4gMDsKK30KKworCiAvKioKICAqIHNjYXJkX2dldF9pbXNpIC0gUmVhZCBJTVNJIGZyb20gU0lNL1VTSU0gY2FyZAogICogQHNjYXJkOiBQb2ludGVyIHRvIHByaXZhdGUgZGF0YSBmcm9tIHNjYXJkX2luaXQoKQpAQCAtMTI4NSwzICsxNDE5LDkgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNDQVJEOiBVbnJlY29nbml6ZWQgcmVzcG9uc2UiKTsKIAlyZXR1cm4gLTE7CiB9CisKKworaW50IHNjYXJkX3N1cHBvcnRzX3VtdHMoc3RydWN0IHNjYXJkX2RhdGEgKnNjYXJkKQoreworCXJldHVybiBzY2FyZC0+c2ltX3R5cGUgPT0gU0NBUkRfVVNJTTsKK30KZGlmZiAtLWdpdCBhL3NyYy91dGlscy9wY3NjX2Z1bmNzLmggYi9zcmMvdXRpbHMvcGNzY19mdW5jcy5oCmluZGV4IDJmZDM2MTAuLmI0ZWJjOTkgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy9wY3NjX2Z1bmNzLmgKKysrIGIvc3JjL3V0aWxzL3Bjc2NfZnVuY3MuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXUEEgU3VwcGxpY2FudCAvIFBDL1NDIHNtYXJ0Y2FyZCBpbnRlcmZhY2UgZm9yIFVTSU0sIEdTTSBTSU0KLSAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA2LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMDYsIDIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTksMjYgKzksNiBAQAogI2lmbmRlZiBQQ1NDX0ZVTkNTX0gKICNkZWZpbmUgUENTQ19GVU5DU19ICiAKLS8qIEdTTSBmaWxlcwotICogRmlsZSB0eXBlIGluIGZpcnN0IG9jdGV0OgotICogM0YgPSBNYXN0ZXIgRmlsZQotICogN0YgPSBEZWRpY2F0ZWQgRmlsZQotICogMkYgPSBFbGVtZW50YXJ5IEZpbGUgdW5kZXIgdGhlIE1hc3RlciBGaWxlCi0gKiA2RiA9IEVsZW1lbnRhcnkgRmlsZSB1bmRlciBhIERlZGljYXRlZCBGaWxlCi0gKi8KLSNkZWZpbmUgU0NBUkRfRklMRV9NRgkJMHgzRjAwCi0jZGVmaW5lIFNDQVJEX0ZJTEVfR1NNX0RGCTB4N0YyMAotI2RlZmluZSBTQ0FSRF9GSUxFX1VNVFNfREYJMHg3RjUwCi0jZGVmaW5lIFNDQVJEX0ZJTEVfR1NNX0VGX0lNU0kJMHg2RjA3Ci0jZGVmaW5lIFNDQVJEX0ZJTEVfR1NNX0VGX0FECTB4NkZBRAotI2RlZmluZSBTQ0FSRF9GSUxFX0VGX0RJUgkweDJGMDAKLSNkZWZpbmUgU0NBUkRfRklMRV9FRl9JQ0NJRAkweDJGRTIKLSNkZWZpbmUgU0NBUkRfRklMRV9FRl9DSwkweDZGRTEKLSNkZWZpbmUgU0NBUkRfRklMRV9FRl9JSwkweDZGRTIKLQotI2RlZmluZSBTQ0FSRF9DSFYxX09GRlNFVAkxMwotI2RlZmluZSBTQ0FSRF9DSFYxX0ZMQUcJCTB4ODAKLQogdHlwZWRlZiBlbnVtIHsKIAlTQ0FSRF9HU01fU0lNX09OTFksCiAJU0NBUkRfVVNJTV9PTkxZLApAQCAtMzcsNyArMTcsNyBAQAogCiAKICNpZmRlZiBQQ1NDX0ZVTkNTCi1zdHJ1Y3Qgc2NhcmRfZGF0YSAqIHNjYXJkX2luaXQoc2NhcmRfc2ltX3R5cGUgc2ltX3R5cGUpOworc3RydWN0IHNjYXJkX2RhdGEgKiBzY2FyZF9pbml0KHNjYXJkX3NpbV90eXBlIHNpbV90eXBlLCBjb25zdCBjaGFyICpyZWFkZXIpOwogdm9pZCBzY2FyZF9kZWluaXQoc3RydWN0IHNjYXJkX2RhdGEgKnNjYXJkKTsKIAogaW50IHNjYXJkX3NldF9waW4oc3RydWN0IHNjYXJkX2RhdGEgKnNjYXJkLCBjb25zdCBjaGFyICpwaW4pOwpAQCAtNDksMTUgKzI5LDIwIEBACiAJCSAgICBjb25zdCB1bnNpZ25lZCBjaGFyICphdXRuLAogCQkgICAgdW5zaWduZWQgY2hhciAqcmVzLCBzaXplX3QgKnJlc19sZW4sCiAJCSAgICB1bnNpZ25lZCBjaGFyICppaywgdW5zaWduZWQgY2hhciAqY2ssIHVuc2lnbmVkIGNoYXIgKmF1dHMpOworaW50IHNjYXJkX2dldF9waW5fcmV0cnlfY291bnRlcihzdHJ1Y3Qgc2NhcmRfZGF0YSAqc2NhcmQpOworaW50IHNjYXJkX3N1cHBvcnRzX3VtdHMoc3RydWN0IHNjYXJkX2RhdGEgKnNjYXJkKTsKIAogI2Vsc2UgLyogUENTQ19GVU5DUyAqLwogCi0jZGVmaW5lIHNjYXJkX2luaXQocykgTlVMTAorI2RlZmluZSBzY2FyZF9pbml0KHMsIHIpIE5VTEwKICNkZWZpbmUgc2NhcmRfZGVpbml0KHMpIGRvIHsgfSB3aGlsZSAoMCkKICNkZWZpbmUgc2NhcmRfc2V0X3BpbihzLCBwKSAtMQogI2RlZmluZSBzY2FyZF9nZXRfaW1zaShzLCBpLCBsKSAtMQorI2RlZmluZSBzY2FyZF9nZXRfbW5jX2xlbihzKSAtMQogI2RlZmluZSBzY2FyZF9nc21fYXV0aChzLCByLCBzMiwgaykgLTEKICNkZWZpbmUgc2NhcmRfdW10c19hdXRoKHMsIHIsIGEsIHIyLCBybCwgaSwgYywgYTIpIC0xCisjZGVmaW5lIHNjYXJkX2dldF9waW5fcmV0cnlfY291bnRlcihzKSAtMQorI2RlZmluZSBzY2FyZF9zdXBwb3J0c191bXRzKHMpIDAKIAogI2VuZGlmIC8qIFBDU0NfRlVOQ1MgKi8KIApkaWZmIC0tZ2l0IGEvc3JjL3V0aWxzL3dwYV9kZWJ1Zy5jIGIvc3JjL3V0aWxzL3dwYV9kZWJ1Zy5jCmluZGV4IGE4YjkxMDYuLjU1MTFlZjEgMTAwNjQ0Ci0tLSBhL3NyYy91dGlscy93cGFfZGVidWcuYworKysgYi9zcmMvdXRpbHMvd3BhX2RlYnVnLmMKQEAgLTE2LDYgKzE2LDE4IEBACiBzdGF0aWMgaW50IHdwYV9kZWJ1Z19zeXNsb2cgPSAwOwogI2VuZGlmIC8qIENPTkZJR19ERUJVR19TWVNMT0cgKi8KIAorI2lmZGVmIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HCisjaW5jbHVkZSA8c3lzL3R5cGVzLmg+CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4KKyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUgPHN0cmluZy5oPgorI2luY2x1ZGUgPHN0ZGlvLmg+CisKK3N0YXRpYyBGSUxFICp3cGFfZGVidWdfdHJhY2luZ19maWxlID0gTlVMTDsKKworI2RlZmluZSBXUEFTX1RSQUNFX1BGWCAid3BhcyA8JWQ+OiAiCisjZW5kaWYgLyogQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcgKi8KKwogCiBpbnQgd3BhX2RlYnVnX2xldmVsID0gTVNHX0lORk87CiBpbnQgd3BhX2RlYnVnX3Nob3dfa2V5cyA9IDA7CkBAIC0zMCwyNSArNDIsMTggQEAKICNkZWZpbmUgQU5EUk9JRF9MT0dfTkFNRQkid3BhX3N1cHBsaWNhbnQiCiAjZW5kaWYgLyogQU5EUk9JRF9MT0dfTkFNRSAqLwogCi12b2lkIGFuZHJvaWRfcHJpbnRmKGludCBsZXZlbCwgY2hhciAqZm9ybWF0LCAuLi4pCitzdGF0aWMgaW50IHdwYV90b19hbmRyb2lkX2xldmVsKGludCBsZXZlbCkKIHsKLQlpZiAobGV2ZWwgPj0gd3BhX2RlYnVnX2xldmVsKSB7Ci0JCXZhX2xpc3QgYXA7Ci0JCWlmIChsZXZlbCA9PSBNU0dfRVJST1IpCi0JCQlsZXZlbCA9IEFORFJPSURfTE9HX0VSUk9SOwotCQllbHNlIGlmIChsZXZlbCA9PSBNU0dfV0FSTklORykKLQkJCWxldmVsID0gQU5EUk9JRF9MT0dfV0FSTjsKLQkJZWxzZSBpZiAobGV2ZWwgPT0gTVNHX0lORk8pCi0JCQlsZXZlbCA9IEFORFJPSURfTE9HX0lORk87Ci0JCWVsc2UKLQkJCWxldmVsID0gQU5EUk9JRF9MT0dfREVCVUc7Ci0JCXZhX3N0YXJ0KGFwLCBmb3JtYXQpOwotCQlfX2FuZHJvaWRfbG9nX3ZwcmludChsZXZlbCwgQU5EUk9JRF9MT0dfTkFNRSwgZm9ybWF0LCBhcCk7Ci0JCXZhX2VuZChhcCk7Ci0JfQorCWlmIChsZXZlbCA9PSBNU0dfRVJST1IpCisJCXJldHVybiBBTkRST0lEX0xPR19FUlJPUjsKKwlpZiAobGV2ZWwgPT0gTVNHX1dBUk5JTkcpCisJCXJldHVybiBBTkRST0lEX0xPR19XQVJOOworCWlmIChsZXZlbCA9PSBNU0dfSU5GTykKKwkJcmV0dXJuIEFORFJPSURfTE9HX0lORk87CisJcmV0dXJuIEFORFJPSURfTE9HX0RFQlVHOwogfQogCi0jZWxzZSAvKiBDT05GSUdfQU5EUk9JRF9MT0cgKi8KKyNlbmRpZiAvKiBDT05GSUdfQU5EUk9JRF9MT0cgKi8KIAogI2lmbmRlZiBDT05GSUdfTk9fU1RET1VUX0RFQlVHCiAKQEAgLTU5LDYgKzY0LDcgQEAKIAogdm9pZCB3cGFfZGVidWdfcHJpbnRfdGltZXN0YW1wKHZvaWQpCiB7CisjaWZuZGVmIENPTkZJR19BTkRST0lEX0xPRwogCXN0cnVjdCBvc190aW1lIHR2OwogCiAJaWYgKCF3cGFfZGVidWdfdGltZXN0YW1wKQpAQCAtNzIsNiArNzgsNyBAQAogCX0gZWxzZQogI2VuZGlmIC8qIENPTkZJR19ERUJVR19GSUxFICovCiAJcHJpbnRmKCIlbGQuJTA2dTogIiwgKGxvbmcpIHR2LnNlYywgKHVuc2lnbmVkIGludCkgdHYudXNlYyk7CisjZW5kaWYgLyogQ09ORklHX0FORFJPSURfTE9HICovCiB9CiAKIApAQCAtMTEyLDYgKzExOSw3NyBAQAogI2VuZGlmIC8qIENPTkZJR19ERUJVR19TWVNMT0cgKi8KIAogCisjaWZkZWYgQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcKKworaW50IHdwYV9kZWJ1Z19vcGVuX2xpbnV4X3RyYWNpbmcodm9pZCkKK3sKKwlpbnQgbW91bnRzLCB0cmFjZV9mZDsKKwljaGFyIGJ1Zls0MDk2XSA9IHt9OworCXNzaXplX3QgYnVmbGVuOworCWNoYXIgKmxpbmUsICp0bXAxLCAqcGF0aCA9IE5VTEw7CisKKwltb3VudHMgPSBvcGVuKCIvcHJvYy9tb3VudHMiLCBPX1JET05MWSk7CisJaWYgKG1vdW50cyA8IDApIHsKKwkJcHJpbnRmKCJubyAvcHJvYy9tb3VudHNcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJYnVmbGVuID0gcmVhZChtb3VudHMsIGJ1Ziwgc2l6ZW9mKGJ1ZikgLSAxKTsKKwljbG9zZShtb3VudHMpOworCWlmIChidWZsZW4gPCAwKSB7CisJCXByaW50ZigiZmFpbGVkIHRvIHJlYWQgL3Byb2MvbW91bnRzXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWxpbmUgPSBzdHJ0b2tfcihidWYsICJcbiIsICZ0bXAxKTsKKwl3aGlsZSAobGluZSkgeworCQljaGFyICp0bXAyLCAqdG1wX3BhdGgsICpmc3R5cGU7CisJCS8qICI8ZGV2PiA8bW91bnRwb2ludD4gPGZzIHR5cGU+IC4uLiIgKi8KKwkJc3RydG9rX3IobGluZSwgIiAiLCAmdG1wMik7CisJCXRtcF9wYXRoID0gc3RydG9rX3IoTlVMTCwgIiAiLCAmdG1wMik7CisJCWZzdHlwZSA9IHN0cnRva19yKE5VTEwsICIgIiwgJnRtcDIpOworCQlpZiAoc3RyY21wKGZzdHlwZSwgImRlYnVnZnMiKSA9PSAwKSB7CisJCQlwYXRoID0gdG1wX3BhdGg7CisJCQlicmVhazsKKwkJfQorCisJCWxpbmUgPSBzdHJ0b2tfcihOVUxMLCAiXG4iLCAmdG1wMSk7CisJfQorCisJaWYgKHBhdGggPT0gTlVMTCkgeworCQlwcmludGYoImRlYnVnZnMgbW91bnRwb2ludCBub3QgZm91bmRcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSAtIDEsICIlcy90cmFjaW5nL3RyYWNlX21hcmtlciIsIHBhdGgpOworCisJdHJhY2VfZmQgPSBvcGVuKGJ1ZiwgT19XUk9OTFkpOworCWlmICh0cmFjZV9mZCA8IDApIHsKKwkJcHJpbnRmKCJmYWlsZWQgdG8gb3BlbiB0cmFjZV9tYXJrZXIgZmlsZVxuIik7CisJCXJldHVybiAtMTsKKwl9CisJd3BhX2RlYnVnX3RyYWNpbmdfZmlsZSA9IGZkb3Blbih0cmFjZV9mZCwgInciKTsKKwlpZiAod3BhX2RlYnVnX3RyYWNpbmdfZmlsZSA9PSBOVUxMKSB7CisJCWNsb3NlKHRyYWNlX2ZkKTsKKwkJcHJpbnRmKCJmYWlsZWQgdG8gZmRvcGVuKClcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKwordm9pZCB3cGFfZGVidWdfY2xvc2VfbGludXhfdHJhY2luZyh2b2lkKQoreworCWlmICh3cGFfZGVidWdfdHJhY2luZ19maWxlID09IE5VTEwpCisJCXJldHVybjsKKwlmY2xvc2Uod3BhX2RlYnVnX3RyYWNpbmdfZmlsZSk7CisJd3BhX2RlYnVnX3RyYWNpbmdfZmlsZSA9IE5VTEw7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORyAqLworCisKIC8qKgogICogd3BhX3ByaW50ZiAtIGNvbmRpdGlvbmFsIHByaW50ZgogICogQGxldmVsOiBwcmlvcml0eSBsZXZlbCAoTVNHXyopIG9mIHRoZSBtZXNzYWdlCkBAIC0xMjksNiArMjA3LDEwIEBACiAKIAl2YV9zdGFydChhcCwgZm10KTsKIAlpZiAobGV2ZWwgPj0gd3BhX2RlYnVnX2xldmVsKSB7CisjaWZkZWYgQ09ORklHX0FORFJPSURfTE9HCisJCV9fYW5kcm9pZF9sb2dfdnByaW50KHdwYV90b19hbmRyb2lkX2xldmVsKGxldmVsKSwKKwkJCQkgICAgIEFORFJPSURfTE9HX05BTUUsIGZtdCwgYXApOworI2Vsc2UgLyogQ09ORklHX0FORFJPSURfTE9HICovCiAjaWZkZWYgQ09ORklHX0RFQlVHX1NZU0xPRwogCQlpZiAod3BhX2RlYnVnX3N5c2xvZykgewogCQkJdnN5c2xvZyhzeXNsb2dfcHJpb3JpdHkobGV2ZWwpLCBmbXQsIGFwKTsKQEAgLTE0OSw4ICsyMzEsMjAgQEAKICNpZmRlZiBDT05GSUdfREVCVUdfU1lTTE9HCiAJCX0KICNlbmRpZiAvKiBDT05GSUdfREVCVUdfU1lTTE9HICovCisjZW5kaWYgLyogQ09ORklHX0FORFJPSURfTE9HICovCiAJfQogCXZhX2VuZChhcCk7CisKKyNpZmRlZiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworCWlmICh3cGFfZGVidWdfdHJhY2luZ19maWxlICE9IE5VTEwpIHsKKwkJdmFfc3RhcnQoYXAsIGZtdCk7CisJCWZwcmludGYod3BhX2RlYnVnX3RyYWNpbmdfZmlsZSwgV1BBU19UUkFDRV9QRlgsIGxldmVsKTsKKwkJdmZwcmludGYod3BhX2RlYnVnX3RyYWNpbmdfZmlsZSwgZm10LCBhcCk7CisJCWZwcmludGYod3BhX2RlYnVnX3RyYWNpbmdfZmlsZSwgIlxuIik7CisJCWZmbHVzaCh3cGFfZGVidWdfdHJhY2luZ19maWxlKTsKKwkJdmFfZW5kKGFwKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcgKi8KIH0KIAogCkBAIC0xNTgsOCArMjUyLDY1IEBACiAJCQkgc2l6ZV90IGxlbiwgaW50IHNob3cpCiB7CiAJc2l6ZV90IGk7CisKKyNpZmRlZiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworCWlmICh3cGFfZGVidWdfdHJhY2luZ19maWxlICE9IE5VTEwpIHsKKwkJZnByaW50Zih3cGFfZGVidWdfdHJhY2luZ19maWxlLAorCQkJV1BBU19UUkFDRV9QRlggIiVzIC0gaGV4ZHVtcChsZW49JWx1KToiLAorCQkJbGV2ZWwsIHRpdGxlLCAodW5zaWduZWQgbG9uZykgbGVuKTsKKwkJaWYgKGJ1ZiA9PSBOVUxMKSB7CisJCQlmcHJpbnRmKHdwYV9kZWJ1Z190cmFjaW5nX2ZpbGUsICIgW05VTExdXG4iKTsKKwkJfSBlbHNlIGlmICghc2hvdykgeworCQkJZnByaW50Zih3cGFfZGVidWdfdHJhY2luZ19maWxlLCAiIFtSRU1PVkVEXVxuIik7CisJCX0gZWxzZSB7CisJCQlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspCisJCQkJZnByaW50Zih3cGFfZGVidWdfdHJhY2luZ19maWxlLAorCQkJCQkiICUwMngiLCBidWZbaV0pOworCQl9CisJCWZmbHVzaCh3cGFfZGVidWdfdHJhY2luZ19maWxlKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcgKi8KKwogCWlmIChsZXZlbCA8IHdwYV9kZWJ1Z19sZXZlbCkKIAkJcmV0dXJuOworI2lmZGVmIENPTkZJR19BTkRST0lEX0xPRworCXsKKwkJY29uc3QgY2hhciAqZGlzcGxheTsKKwkJY2hhciAqc3RyYnVmID0gTlVMTDsKKwkJc2l6ZV90IHNsZW4gPSBsZW47CisJCWlmIChidWYgPT0gTlVMTCkgeworCQkJZGlzcGxheSA9ICIgW05VTExdIjsKKwkJfSBlbHNlIGlmIChsZW4gPT0gMCkgeworCQkJZGlzcGxheSA9ICIiOworCQl9IGVsc2UgaWYgKHNob3cgJiYgbGVuKSB7CisJCQkvKiBMaW1pdCBkZWJ1ZyBtZXNzYWdlIGxlbmd0aCBmb3IgQW5kcm9pZCBsb2cgKi8KKwkJCWlmIChzbGVuID4gMzIpCisJCQkJc2xlbiA9IDMyOworCQkJc3RyYnVmID0gb3NfbWFsbG9jKDEgKyAzICogc2xlbik7CisJCQlpZiAoc3RyYnVmID09IE5VTEwpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIndwYV9oZXhkdW1wOiBGYWlsZWQgdG8gIgorCQkJCQkgICAiYWxsb2NhdGUgbWVzc2FnZSBidWZmZXIiKTsKKwkJCQlyZXR1cm47CisJCQl9CisKKwkJCWZvciAoaSA9IDA7IGkgPCBzbGVuOyBpKyspCisJCQkJb3Nfc25wcmludGYoJnN0cmJ1ZltpICogM10sIDQsICIgJTAyeCIsCisJCQkJCSAgICBidWZbaV0pOworCisJCQlkaXNwbGF5ID0gc3RyYnVmOworCQl9IGVsc2UgeworCQkJZGlzcGxheSA9ICIgW1JFTU9WRURdIjsKKwkJfQorCisJCV9fYW5kcm9pZF9sb2dfcHJpbnQod3BhX3RvX2FuZHJvaWRfbGV2ZWwobGV2ZWwpLAorCQkJCSAgICBBTkRST0lEX0xPR19OQU1FLAorCQkJCSAgICAiJXMgLSBoZXhkdW1wKGxlbj0lbHUpOiVzJXMiLAorCQkJCSAgICB0aXRsZSwgKGxvbmcgdW5zaWduZWQgaW50KSBsZW4sIGRpc3BsYXksCisJCQkJICAgIGxlbiA+IHNsZW4gPyAiIC4uLiIgOiAiIik7CisJCW9zX2ZyZWUoc3RyYnVmKTsKKwkJcmV0dXJuOworCX0KKyNlbHNlIC8qIENPTkZJR19BTkRST0lEX0xPRyAqLwogI2lmZGVmIENPTkZJR19ERUJVR19TWVNMT0cKIAlpZiAod3BhX2RlYnVnX3N5c2xvZykgewogCQljb25zdCBjaGFyICpkaXNwbGF5OwpAQCAtMTg3LDcgKzMzOCw3IEBACiAJCX0KIAogCQlzeXNsb2coc3lzbG9nX3ByaW9yaXR5KGxldmVsKSwgIiVzIC0gaGV4ZHVtcChsZW49JWx1KTolcyIsCi0JCSAgICAgICB0aXRsZSwgbGVuLCBkaXNwbGF5KTsKKwkJICAgICAgIHRpdGxlLCAodW5zaWduZWQgbG9uZykgbGVuLCBkaXNwbGF5KTsKIAkJb3NfZnJlZShzdHJidWYpOwogCQlyZXR1cm47CiAJfQpAQCAtMjIxLDYgKzM3Miw3IEBACiAjaWZkZWYgQ09ORklHX0RFQlVHX0ZJTEUKIAl9CiAjZW5kaWYgLyogQ09ORklHX0RFQlVHX0ZJTEUgKi8KKyNlbmRpZiAvKiBDT05GSUdfQU5EUk9JRF9MT0cgKi8KIH0KIAogdm9pZCB3cGFfaGV4ZHVtcChpbnQgbGV2ZWwsIGNvbnN0IGNoYXIgKnRpdGxlLCBjb25zdCB1OCAqYnVmLCBzaXplX3QgbGVuKQpAQCAtMjQyLDggKzM5NCwzMCBAQAogCWNvbnN0IHU4ICpwb3MgPSBidWY7CiAJY29uc3Qgc2l6ZV90IGxpbmVfbGVuID0gMTY7CiAKKyNpZmRlZiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworCWlmICh3cGFfZGVidWdfdHJhY2luZ19maWxlICE9IE5VTEwpIHsKKwkJZnByaW50Zih3cGFfZGVidWdfdHJhY2luZ19maWxlLAorCQkJV1BBU19UUkFDRV9QRlggIiVzIC0gaGV4ZHVtcF9hc2NpaShsZW49JWx1KToiLAorCQkJbGV2ZWwsIHRpdGxlLCAodW5zaWduZWQgbG9uZykgbGVuKTsKKwkJaWYgKGJ1ZiA9PSBOVUxMKSB7CisJCQlmcHJpbnRmKHdwYV9kZWJ1Z190cmFjaW5nX2ZpbGUsICIgW05VTExdXG4iKTsKKwkJfSBlbHNlIGlmICghc2hvdykgeworCQkJZnByaW50Zih3cGFfZGVidWdfdHJhY2luZ19maWxlLCAiIFtSRU1PVkVEXVxuIik7CisJCX0gZWxzZSB7CisJCQkvKiBjYW4gZG8gYXNjaWkgcHJvY2Vzc2luZyBpbiB1c2Vyc3BhY2UgKi8KKwkJCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykKKwkJCQlmcHJpbnRmKHdwYV9kZWJ1Z190cmFjaW5nX2ZpbGUsCisJCQkJCSIgJTAyeCIsIGJ1ZltpXSk7CisJCX0KKwkJZmZsdXNoKHdwYV9kZWJ1Z190cmFjaW5nX2ZpbGUpOworCX0KKyNlbmRpZiAvKiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORyAqLworCiAJaWYgKGxldmVsIDwgd3BhX2RlYnVnX2xldmVsKQogCQlyZXR1cm47CisjaWZkZWYgQ09ORklHX0FORFJPSURfTE9HCisJX3dwYV9oZXhkdW1wKGxldmVsLCB0aXRsZSwgYnVmLCBsZW4sIHNob3cpOworI2Vsc2UgLyogQ09ORklHX0FORFJPSURfTE9HICovCiAJd3BhX2RlYnVnX3ByaW50X3RpbWVzdGFtcCgpOwogI2lmZGVmIENPTkZJR19ERUJVR19GSUxFCiAJaWYgKG91dF9maWxlKSB7CkBAIC0zMTcsNiArNDkxLDcgQEAKICNpZmRlZiBDT05GSUdfREVCVUdfRklMRQogCX0KICNlbmRpZiAvKiBDT05GSUdfREVCVUdfRklMRSAqLworI2VuZGlmIC8qIENPTkZJR19BTkRST0lEX0xPRyAqLwogfQogCiAKQEAgLTM5OCw3ICs1NzMsNiBAQAogCiAjZW5kaWYgLyogQ09ORklHX05PX1NURE9VVF9ERUJVRyAqLwogCi0jZW5kaWYgLyogQ09ORklHX0FORFJPSURfTE9HICovCiAKICNpZm5kZWYgQ09ORklHX05PX1dQQV9NU0cKIHN0YXRpYyB3cGFfbXNnX2NiX2Z1bmMgd3BhX21zZ19jYiA9IE5VTEw7CmRpZmYgLS1naXQgYS9zcmMvdXRpbHMvd3BhX2RlYnVnLmggYi9zcmMvdXRpbHMvd3BhX2RlYnVnLmgKaW5kZXggYmJlZjQ5Yi4uMzM5Yzc0OSAxMDA2NDQKLS0tIGEvc3JjL3V0aWxzL3dwYV9kZWJ1Zy5oCisrKyBiL3NyYy91dGlscy93cGFfZGVidWcuaApAQCAtMTgsMzIgKzE4LDYgQEAKIAlNU0dfRVhDRVNTSVZFLCBNU0dfTVNHRFVNUCwgTVNHX0RFQlVHLCBNU0dfSU5GTywgTVNHX1dBUk5JTkcsIE1TR19FUlJPUgogfTsKIAotI2lmZGVmIENPTkZJR19BTkRST0lEX0xPRwotCi0jZGVmaW5lIHdwYV9kZWJ1Z19wcmludF90aW1lc3RhbXAoKSBkbyB7fSB3aGlsZSAoMCkKLSNkZWZpbmUgd3BhX2hleGR1bXAoLi4uKSAgICAgICAgICAgIGRvIHt9IHdoaWxlICgwKQotI2RlZmluZSB3cGFfaGV4ZHVtcF9rZXkoLi4uKSAgICAgICAgZG8ge30gd2hpbGUgKDApCi0jZGVmaW5lIHdwYV9oZXhkdW1wX2J1ZihsLHQsYikgICAgICBkbyB7fSB3aGlsZSAoMCkKLSNkZWZpbmUgd3BhX2hleGR1bXBfYnVmX2tleShsLHQsYikgIGRvIHt9IHdoaWxlICgwKQotI2RlZmluZSB3cGFfaGV4ZHVtcF9hc2NpaSguLi4pICAgICAgZG8ge30gd2hpbGUgKDApCi0jZGVmaW5lIHdwYV9oZXhkdW1wX2FzY2lpX2tleSguLi4pICBkbyB7fSB3aGlsZSAoMCkKLSNkZWZpbmUgd3BhX2RlYnVnX29wZW5fZmlsZSguLi4pICAgIGRvIHt9IHdoaWxlICgwKQotI2RlZmluZSB3cGFfZGVidWdfY2xvc2VfZmlsZSgpICAgICAgZG8ge30gd2hpbGUgKDApCi0jZGVmaW5lIHdwYV9kYmcoLi4uKSAgICAgICAgICAgICAgICBkbyB7fSB3aGlsZSAoMCkKLQotc3RhdGljIGlubGluZSBpbnQgd3BhX2RlYnVnX3Jlb3Blbl9maWxlKHZvaWQpCi17Ci0JcmV0dXJuIDA7Ci19Ci0KLQotdm9pZCBhbmRyb2lkX3ByaW50ZihpbnQgbGV2ZWwsIGNoYXIgKmZvcm1hdCwgLi4uKQotUFJJTlRGX0ZPUk1BVCgyLCAzKTsKLQotI2RlZmluZSB3cGFfcHJpbnRmIGFuZHJvaWRfcHJpbnRmCi0KLSNlbHNlIC8qIENPTkZJR19BTkRST0lEX0xPRyAqLwotCiAjaWZkZWYgQ09ORklHX05PX1NURE9VVF9ERUJVRwogCiAjZGVmaW5lIHdwYV9kZWJ1Z19wcmludF90aW1lc3RhbXAoKSBkbyB7IH0gd2hpbGUgKDApCkBAIC0xNzcsOCArMTUxLDYgQEAKIAogI2VuZGlmIC8qIENPTkZJR19OT19TVERPVVRfREVCVUcgKi8KIAotI2VuZGlmIC8qIENPTkZJR19BTkRST0lEX0xPRyAqLwotCiAKICNpZmRlZiBDT05GSUdfTk9fV1BBX01TRwogI2RlZmluZSB3cGFfbXNnKGFyZ3MuLi4pIGRvIHsgfSB3aGlsZSAoMCkKQEAgLTI4Myw2ICsyNTUsMjQgQEAKIAogI2VuZGlmIC8qIENPTkZJR19ERUJVR19TWVNMT0cgKi8KIAorI2lmZGVmIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HCisKK2ludCB3cGFfZGVidWdfb3Blbl9saW51eF90cmFjaW5nKHZvaWQpOwordm9pZCB3cGFfZGVidWdfY2xvc2VfbGludXhfdHJhY2luZyh2b2lkKTsKKworI2Vsc2UgLyogQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcgKi8KKworc3RhdGljIGlubGluZSBpbnQgd3BhX2RlYnVnX29wZW5fbGludXhfdHJhY2luZyh2b2lkKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgd3BhX2RlYnVnX2Nsb3NlX2xpbnV4X3RyYWNpbmcodm9pZCkKK3sKK30KKworI2VuZGlmIC8qIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HICovCisKIAogI2lmZGVmIEVBUE9MX1RFU1QKICNkZWZpbmUgV1BBX0FTU0VSVChhKQkJCQkJCSAgICAgICBcCmRpZmYgLS1naXQgYS9zcmMvd3BzL25kZWYuYyBiL3NyYy93cHMvbmRlZi5jCmluZGV4IDliYWVjN2YuLjc2MzBlY2IgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvbmRlZi5jCisrKyBiL3NyYy93cHMvbmRlZi5jCkBAIC0xLDE2ICsxLDEwIEBACiAvKgogICogTkRFRihORkMgRGF0YSBFeGNoYW5nZSBGb3JtYXQpIHJvdXRpbmVzIGZvciBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAKICAqICAgUmVmZXJlbmNlIGlzICJORkNGb3J1bS1UUy1OREVGXzEuMCAyMDA2LTA3LTI0Ii4KLSAqIENvcHlyaWdodCAoYykgMjAwOSwgTWFzYXNoaSBIb25tYSA8aG9ubWFAaWN0ZWMuY28uanA+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDktMjAxMiwgTWFzYXNoaSBIb25tYSA8bWFzYXNoaS5ob25tYUBnbWFpbC5jb20+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC0yNiw5ICsyMCw5IEBACiAjZGVmaW5lIEZMQUdfVE5GX1JGQzIwNDYgKDB4MDIpCiAKIHN0cnVjdCBuZGVmX3JlY29yZCB7Ci0JdTggKnR5cGU7Ci0JdTggKmlkOwotCXU4ICpwYXlsb2FkOworCWNvbnN0IHU4ICp0eXBlOworCWNvbnN0IHU4ICppZDsKKwljb25zdCB1OCAqcGF5bG9hZDsKIAl1OCB0eXBlX2xlbmd0aDsKIAl1OCBpZF9sZW5ndGg7CiAJdTMyIHBheWxvYWRfbGVuZ3RoOwpAQCAtMzcsOSArMzEsMTAgQEAKIAogc3RhdGljIGNoYXIgd2lmaV9oYW5kb3Zlcl90eXBlW10gPSAiYXBwbGljYXRpb24vdm5kLndmYS53c2MiOwogCi1zdGF0aWMgaW50IG5kZWZfcGFyc2VfcmVjb3JkKHU4ICpkYXRhLCB1MzIgc2l6ZSwgc3RydWN0IG5kZWZfcmVjb3JkICpyZWNvcmQpCitzdGF0aWMgaW50IG5kZWZfcGFyc2VfcmVjb3JkKGNvbnN0IHU4ICpkYXRhLCB1MzIgc2l6ZSwKKwkJCSAgICAgc3RydWN0IG5kZWZfcmVjb3JkICpyZWNvcmQpCiB7Ci0JdTggKnBvcyA9IGRhdGEgKyAxOworCWNvbnN0IHU4ICpwb3MgPSBkYXRhICsgMTsKIAogCWlmIChzaXplIDwgMikKIAkJcmV0dXJuIC0xOwpAQCAtNzgsMTIgKzczLDEyIEBACiB9CiAKIAotc3RhdGljIHN0cnVjdCB3cGFidWYgKiBuZGVmX3BhcnNlX3JlY29yZHMoc3RydWN0IHdwYWJ1ZiAqYnVmLAorc3RhdGljIHN0cnVjdCB3cGFidWYgKiBuZGVmX3BhcnNlX3JlY29yZHMoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmLAogCQkJCQkgIGludCAoKmZpbHRlcikoc3RydWN0IG5kZWZfcmVjb3JkICopKQogewogCXN0cnVjdCBuZGVmX3JlY29yZCByZWNvcmQ7CiAJaW50IGxlbiA9IHdwYWJ1Zl9sZW4oYnVmKTsKLQl1OCAqZGF0YSA9IHdwYWJ1Zl9taGVhZChidWYpOworCWNvbnN0IHU4ICpkYXRhID0gd3BhYnVmX2hlYWQoYnVmKTsKIAogCXdoaWxlIChsZW4gPiAwKSB7CiAJCWlmIChuZGVmX3BhcnNlX3JlY29yZChkYXRhLCBsZW4sICZyZWNvcmQpIDwgMCkgewpAQCAtMTAzLDEzICs5OCwxNCBAQAogCiBzdGF0aWMgc3RydWN0IHdwYWJ1ZiAqIG5kZWZfYnVpbGRfcmVjb3JkKHU4IGZsYWdzLCB2b2lkICp0eXBlLAogCQkJCQkgdTggdHlwZV9sZW5ndGgsIHZvaWQgKmlkLAotCQkJCQkgdTggaWRfbGVuZ3RoLCB2b2lkICpwYXlsb2FkLAotCQkJCQkgdTMyIHBheWxvYWRfbGVuZ3RoKQorCQkJCQkgdTggaWRfbGVuZ3RoLAorCQkJCQkgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqcGF5bG9hZCkKIHsKIAlzdHJ1Y3Qgd3BhYnVmICpyZWNvcmQ7CiAJc2l6ZV90IHRvdGFsX2xlbjsKIAlpbnQgc2hvcnRfcmVjb3JkOwogCXU4IGxvY2FsX2ZsYWc7CisJc2l6ZV90IHBheWxvYWRfbGVuZ3RoID0gd3BhYnVmX2xlbihwYXlsb2FkKTsKIAogCXNob3J0X3JlY29yZCA9IHBheWxvYWRfbGVuZ3RoIDwgMjU2ID8gMSA6IDA7CiAKQEAgLTE0NCw3ICsxNDAsNyBAQAogCQl3cGFidWZfcHV0X3U4KHJlY29yZCwgaWRfbGVuZ3RoKTsKIAl3cGFidWZfcHV0X2RhdGEocmVjb3JkLCB0eXBlLCB0eXBlX2xlbmd0aCk7CiAJd3BhYnVmX3B1dF9kYXRhKHJlY29yZCwgaWQsIGlkX2xlbmd0aCk7Ci0Jd3BhYnVmX3B1dF9kYXRhKHJlY29yZCwgcGF5bG9hZCwgcGF5bG9hZF9sZW5ndGgpOworCXdwYWJ1Zl9wdXRfYnVmKHJlY29yZCwgcGF5bG9hZCk7CiAJcmV0dXJuIHJlY29yZDsKIH0KIApAQCAtMTYwLDE2ICsxNTYsMTUgQEAKIH0KIAogCi1zdHJ1Y3Qgd3BhYnVmICogbmRlZl9wYXJzZV93aWZpKHN0cnVjdCB3cGFidWYgKmJ1ZikKK3N0cnVjdCB3cGFidWYgKiBuZGVmX3BhcnNlX3dpZmkoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmKQogewogCXJldHVybiBuZGVmX3BhcnNlX3JlY29yZHMoYnVmLCB3aWZpX2ZpbHRlcik7CiB9CiAKIAotc3RydWN0IHdwYWJ1ZiAqIG5kZWZfYnVpbGRfd2lmaShzdHJ1Y3Qgd3BhYnVmICpidWYpCitzdHJ1Y3Qgd3BhYnVmICogbmRlZl9idWlsZF93aWZpKGNvbnN0IHN0cnVjdCB3cGFidWYgKmJ1ZikKIHsKIAlyZXR1cm4gbmRlZl9idWlsZF9yZWNvcmQoRkxBR19NRVNTQUdFX0JFR0lOIHwgRkxBR19NRVNTQUdFX0VORCB8CiAJCQkJIEZMQUdfVE5GX1JGQzIwNDYsIHdpZmlfaGFuZG92ZXJfdHlwZSwKLQkJCQkgb3Nfc3RybGVuKHdpZmlfaGFuZG92ZXJfdHlwZSksIE5VTEwsIDAsCi0JCQkJIHdwYWJ1Zl9taGVhZChidWYpLCB3cGFidWZfbGVuKGJ1ZikpOworCQkJCSBvc19zdHJsZW4od2lmaV9oYW5kb3Zlcl90eXBlKSwgTlVMTCwgMCwgYnVmKTsKIH0KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzLmMgYi9zcmMvd3BzL3dwcy5jCmluZGV4IDk0MjJjNzEuLjU0NTM5NjIgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzLmMKKysrIGIvc3JjL3dwcy93cHMuYwpAQCAtNTYsNiArNTYsMjMgQEAKIAkJZGF0YS0+ZGV2X3Bhc3N3b3JkX2xlbiA9IGNmZy0+cGluX2xlbjsKIAl9CiAKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCWlmIChjZmctPndwcy0+YXAgJiYgIWNmZy0+cmVnaXN0cmFyICYmIGNmZy0+d3BzLT5hcF9uZmNfZGV2X3B3X2lkKSB7CisJCWRhdGEtPmRldl9wd19pZCA9IGNmZy0+d3BzLT5hcF9uZmNfZGV2X3B3X2lkOworCQlvc19mcmVlKGRhdGEtPmRldl9wYXNzd29yZCk7CisJCWRhdGEtPmRldl9wYXNzd29yZCA9CisJCQlvc19tYWxsb2Mod3BhYnVmX2xlbihjZmctPndwcy0+YXBfbmZjX2Rldl9wdykpOworCQlpZiAoZGF0YS0+ZGV2X3Bhc3N3b3JkID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUoZGF0YSk7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlvc19tZW1jcHkoZGF0YS0+ZGV2X3Bhc3N3b3JkLAorCQkJICB3cGFidWZfaGVhZChjZmctPndwcy0+YXBfbmZjX2Rldl9wdyksCisJCQkgIHdwYWJ1Zl9sZW4oY2ZnLT53cHMtPmFwX25mY19kZXZfcHcpKTsKKwkJZGF0YS0+ZGV2X3Bhc3N3b3JkX2xlbiA9IHdwYWJ1Zl9sZW4oY2ZnLT53cHMtPmFwX25mY19kZXZfcHcpOworCX0KKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCiAJZGF0YS0+cGJjID0gY2ZnLT5wYmM7CiAJaWYgKGNmZy0+cGJjKSB7CiAJCS8qIFVzZSBzcGVjaWFsIFBJTiAnMDAwMDAwMDAnIGZvciBQQkMgKi8KQEAgLTExOCw2ICsxMzUsMTIgQEAKICAqLwogdm9pZCB3cHNfZGVpbml0KHN0cnVjdCB3cHNfZGF0YSAqZGF0YSkKIHsKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCWlmIChkYXRhLT5yZWdpc3RyYXIgJiYgZGF0YS0+bmZjX3B3X3Rva2VuKQorCQl3cHNfcmVnaXN0cmFyX3JlbW92ZV9uZmNfcHdfdG9rZW4oZGF0YS0+d3BzLT5yZWdpc3RyYXIsCisJCQkJCQkgIGRhdGEtPm5mY19wd190b2tlbik7CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKwogCWlmIChkYXRhLT53cHNfcGluX3JldmVhbGVkKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBGdWxsIFBJTiBpbmZvcm1hdGlvbiByZXZlYWxlZCBhbmQgIgogCQkJICAgIm5lZ290aWF0aW9uIGZhaWxlZCIpOwpAQCAtMTM2LDYgKzE1OSw3IEBACiAJd3BzX2RldmljZV9kYXRhX2ZyZWUoJmRhdGEtPnBlZXJfZGV2KTsKIAlvc19mcmVlKGRhdGEtPm5ld19hcF9zZXR0aW5ncyk7CiAJZGg1X2ZyZWUoZGF0YS0+ZGhfY3R4KTsKKwlvc19mcmVlKGRhdGEtPm5mY19wd190b2tlbik7CiAJb3NfZnJlZShkYXRhKTsKIH0KIApAQCAtNDMxLDcgKzQ1NSw4IEBACiAKIC8qKgogICogd3BzX2J1aWxkX3Byb2JlX3JlcV9pZSAtIEJ1aWxkIFdQUyBJRSBmb3IgUHJvYmUgUmVxdWVzdAotICogQHBiYzogV2hldGhlciBzZWFyY2hpbmcgZm9yIFBCQyBtb2RlIEFQcworICogQHB3X2lkOiBQYXNzd29yZCBJRCAoREVWX1BXX1BVU0hCVVRUT04gZm9yIGFjdGl2ZSBQQkMgYW5kIERFVl9QV19ERUZBVUxUIGZvcgorICogbW9zdCBvdGhlciB1c2UgY2FzZXMpCiAgKiBAZGV2OiBEZXZpY2UgYXR0cmlidXRlcwogICogQHV1aWQ6IE93biBVVUlECiAgKiBAcmVxX3R5cGU6IFZhbHVlIGZvciBSZXF1ZXN0IFR5cGUgYXR0cmlidXRlCkBAIC00NDIsNyArNDY3LDcgQEAKICAqCiAgKiBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmxlIGZvciBmcmVlaW5nIHRoZSBidWZmZXIuCiAgKi8KLXN0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKGludCBwYmMsIHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldiwKK3N0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKHUxNiBwd19pZCwgc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LAogCQkJCSAgICAgICBjb25zdCB1OCAqdXVpZCwKIAkJCQkgICAgICAgZW51bSB3cHNfcmVxdWVzdF90eXBlIHJlcV90eXBlLAogCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgbnVtX3JlcV9kZXZfdHlwZXMsCkBAIC00NjQsOCArNDg5LDcgQEAKIAkgICAgd3BzX2J1aWxkX3JmX2JhbmRzKGRldiwgaWUpIHx8CiAJICAgIHdwc19idWlsZF9hc3NvY19zdGF0ZShOVUxMLCBpZSkgfHwKIAkgICAgd3BzX2J1aWxkX2NvbmZpZ19lcnJvcihpZSwgV1BTX0NGR19OT19FUlJPUikgfHwKLQkgICAgd3BzX2J1aWxkX2Rldl9wYXNzd29yZF9pZChpZSwgcGJjID8gREVWX1BXX1BVU0hCVVRUT04gOgotCQkJCSAgICAgIERFVl9QV19ERUZBVUxUKSB8fAorCSAgICB3cHNfYnVpbGRfZGV2X3Bhc3N3b3JkX2lkKGllLCBwd19pZCkgfHwKICNpZmRlZiBDT05GSUdfV1BTMgogCSAgICB3cHNfYnVpbGRfbWFudWZhY3R1cmVyKGRldiwgaWUpIHx8CiAJICAgIHdwc19idWlsZF9tb2RlbF9uYW1lKGRldiwgaWUpIHx8CmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwcy5oIGIvc3JjL3dwcy93cHMuaAppbmRleCAyMmUwMjlmLi5jNDViNjhjIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwcy5oCisrKyBiL3NyYy93cHMvd3BzLmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogV2ktRmkgUHJvdGVjdGVkIFNldHVwCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNy0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yNyw2ICsyNyw3IEBACiBzdHJ1Y3Qgd3BzX3JlZ2lzdHJhcjsKIHN0cnVjdCB1cG5wX3dwc19kZXZpY2Vfc207CiBzdHJ1Y3Qgd3BzX2VyOworc3RydWN0IHdwc19wYXJzZV9hdHRyOwogCiAvKioKICAqIHN0cnVjdCB3cHNfY3JlZGVudGlhbCAtIFdQUyBDcmVkZW50aWFsCkBAIC05NCw2ICs5NSw3IEBACiAJdTMyIG9zX3ZlcnNpb247CiAJdTggcmZfYmFuZHM7CiAJdTE2IGNvbmZpZ19tZXRob2RzOworCXN0cnVjdCB3cGFidWYgKnZlbmRvcl9leHRfbTE7CiAJc3RydWN0IHdwYWJ1ZiAqdmVuZG9yX2V4dFtNQVhfV1BTX1ZFTkRPUl9FWFRFTlNJT05TXTsKIAogCWludCBwMnA7CkBAIC0yMzgsNyArMjQwLDcgQEAKIAogc3RydWN0IHdwYWJ1ZiAqIHdwc19idWlsZF9hc3NvY19yZXFfaWUoZW51bSB3cHNfcmVxdWVzdF90eXBlIHJlcV90eXBlKTsKIHN0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfYXNzb2NfcmVzcF9pZSh2b2lkKTsKLXN0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKGludCBwYmMsIHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldiwKK3N0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKHUxNiBwd19pZCwgc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LAogCQkJCSAgICAgICBjb25zdCB1OCAqdXVpZCwKIAkJCQkgICAgICAgZW51bSB3cHNfcmVxdWVzdF90eXBlIHJlcV90eXBlLAogCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgbnVtX3JlcV9kZXZfdHlwZXMsCkBAIC0yOTQsMTIgKzI5NiwxNSBAQAogCSAqIEBjdHg6IEhpZ2hlciBsYXllciBjb250ZXh0IGRhdGEgKGNiX2N0eCkKIAkgKiBAbWFjX2FkZHI6IE1BQyBhZGRyZXNzIG9mIHRoZSBFbnJvbGxlZQogCSAqIEB1dWlkX2U6IFVVSUQtRSBvZiB0aGUgRW5yb2xsZWUKKwkgKiBAZGV2X3B3OiBEZXZpY2UgUGFzc3dvcmQgKFBJTikgdXNlZCBkdXJpbmcgcmVnaXN0cmF0aW9uCisJICogQGRldl9wd19sZW46IExlbmd0aCBvZiBkZXZfcHcgaW4gb2N0ZXRzCiAJICoKIAkgKiBUaGlzIGNhbGxiYWNrIGlzIGNhbGxlZCB3aGVuZXZlciBhbiBFbnJvbGxlZSBjb21wbGV0ZXMgcmVnaXN0cmF0aW9uCiAJICogc3VjY2Vzc2Z1bGx5LgogCSAqLwogCXZvaWQgKCpyZWdfc3VjY2Vzc19jYikodm9pZCAqY3R4LCBjb25zdCB1OCAqbWFjX2FkZHIsCi0JCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSk7CisJCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSwgY29uc3QgdTggKmRldl9wdywKKwkJCSAgICAgICBzaXplX3QgZGV2X3B3X2xlbik7CiAKIAkvKioKIAkgKiBzZXRfc2VsX3JlZ19jYiAtIENhbGxiYWNrIGZvciByZXBvcnRpbmcgc2VsZWN0ZWQgcmVnaXN0cmFyIGNoYW5nZXMKQEAgLTc1Miw2ICs3NTcsMTEgQEAKIAogCS8qIFBlbmRpbmcgbWVzc2FnZXMgZnJvbSBVUG5QIFB1dFdMQU5SZXNwb25zZSAqLwogCXN0cnVjdCB1cG5wX3BlbmRpbmdfbWVzc2FnZSAqdXBucF9tc2dzOworCisJdTE2IGFwX25mY19kZXZfcHdfaWQ7CisJc3RydWN0IHdwYWJ1ZiAqYXBfbmZjX2RoX3B1YmtleTsKKwlzdHJ1Y3Qgd3BhYnVmICphcF9uZmNfZGhfcHJpdmtleTsKKwlzdHJ1Y3Qgd3BhYnVmICphcF9uZmNfZGV2X3B3OwogfTsKIAogc3RydWN0IG9vYl9kZXZpY2VfZGF0YSB7CkBAIC03ODMsNyArNzkzLDggQEAKIGludCB3cHNfcmVnaXN0cmFyX3VubG9ja19waW4oc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywgY29uc3QgdTggKnV1aWQpOwogaW50IHdwc19yZWdpc3RyYXJfYnV0dG9uX3B1c2hlZChzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLAogCQkJCWNvbnN0IHU4ICpwMnBfZGV2X2FkZHIpOwotdm9pZCB3cHNfcmVnaXN0cmFyX2NvbXBsZXRlKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWdpc3RyYXIsIGNvbnN0IHU4ICp1dWlkX2UpOwordm9pZCB3cHNfcmVnaXN0cmFyX2NvbXBsZXRlKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWdpc3RyYXIsIGNvbnN0IHU4ICp1dWlkX2UsCisJCQkgICAgY29uc3QgdTggKmRldl9wdywgc2l6ZV90IGRldl9wd19sZW4pOwogdm9pZCB3cHNfcmVnaXN0cmFyX3Byb2JlX3JlcV9yeChzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLCBjb25zdCB1OCAqYWRkciwKIAkJCQljb25zdCBzdHJ1Y3Qgd3BhYnVmICp3cHNfZGF0YSwKIAkJCQlpbnQgcDJwX3dpbGRjYXJkKTsKQEAgLTc5Miw2ICs4MDMsMTIgQEAKIAkJCSAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1Zmxlbik7CiBpbnQgd3BzX3JlZ2lzdHJhcl9jb25maWdfYXAoc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywKIAkJCSAgICBzdHJ1Y3Qgd3BzX2NyZWRlbnRpYWwgKmNyZWQpOworaW50IHdwc19yZWdpc3RyYXJfYWRkX25mY19wd190b2tlbihzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLAorCQkJCSAgIGNvbnN0IHU4ICpwdWJrZXlfaGFzaCwgdTE2IHB3X2lkLAorCQkJCSAgIGNvbnN0IHU4ICpkZXZfcHcsIHNpemVfdCBkZXZfcHdfbGVuKTsKK2ludCB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcGFzc3dvcmRfdG9rZW4oc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywKKwkJCQkJIGNvbnN0IHU4ICpvb2JfZGV2X3B3LAorCQkJCQkgc2l6ZV90IG9vYl9kZXZfcHdfbGVuKTsKIAogaW50IHdwc19idWlsZF9jcmVkZW50aWFsX3dyYXAoc3RydWN0IHdwYWJ1ZiAqbXNnLAogCQkJICAgICAgY29uc3Qgc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkKTsKQEAgLTc5OSw2ICs4MTYsNyBAQAogdW5zaWduZWQgaW50IHdwc19waW5fY2hlY2tzdW0odW5zaWduZWQgaW50IHBpbik7CiB1bnNpZ25lZCBpbnQgd3BzX3Bpbl92YWxpZCh1bnNpZ25lZCBpbnQgcGluKTsKIHVuc2lnbmVkIGludCB3cHNfZ2VuZXJhdGVfcGluKHZvaWQpOworaW50IHdwc19waW5fc3RyX3ZhbGlkKGNvbnN0IGNoYXIgKnBpbik7CiB2b2lkIHdwc19mcmVlX3BlbmRpbmdfbXNncyhzdHJ1Y3QgdXBucF9wZW5kaW5nX21lc3NhZ2UgKm1zZ3MpOwogCiBzdHJ1Y3Qgb29iX2RldmljZV9kYXRhICogd3BzX2dldF9vb2JfZGV2aWNlKGNoYXIgKmRldmljZV90eXBlKTsKQEAgLTgwNiw2ICs4MjQsOCBAQAogaW50IHdwc19nZXRfb29iX21ldGhvZChjaGFyICptZXRob2QpOwogaW50IHdwc19wcm9jZXNzX29vYihzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgc3RydWN0IG9vYl9kZXZpY2VfZGF0YSAqb29iX2RldiwKIAkJICAgIGludCByZWdpc3RyYXIpOworc3RydWN0IHdwYWJ1ZiAqIHdwc19nZXRfb29iX2NyZWQoc3RydWN0IHdwc19jb250ZXh0ICp3cHMpOworaW50IHdwc19vb2JfdXNlX2NyZWQoc3RydWN0IHdwc19jb250ZXh0ICp3cHMsIHN0cnVjdCB3cHNfcGFyc2VfYXR0ciAqYXR0cik7CiBpbnQgd3BzX2F0dHJfdGV4dChzdHJ1Y3Qgd3BhYnVmICpkYXRhLCBjaGFyICpidWYsIGNoYXIgKmVuZCk7CiAKIHN0cnVjdCB3cHNfZXIgKiB3cHNfZXJfaW5pdChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgY29uc3QgY2hhciAqaWZuYW1lLApAQCAtODIxLDEyICs4NDEsMjMgQEAKIAkJICAgICAgY29uc3Qgc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkKTsKIGludCB3cHNfZXJfY29uZmlnKHN0cnVjdCB3cHNfZXIgKmVyLCBjb25zdCB1OCAqdXVpZCwgY29uc3QgdTggKnBpbiwKIAkJICBzaXplX3QgcGluX2xlbiwgY29uc3Qgc3RydWN0IHdwc19jcmVkZW50aWFsICpjcmVkKTsKK3N0cnVjdCB3cGFidWYgKiB3cHNfZXJfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3Qgd3BzX2VyICplciwgY29uc3QgdTggKnV1aWQpOwogCiBpbnQgd3BzX2Rldl90eXBlX3N0cjJiaW4oY29uc3QgY2hhciAqc3RyLCB1OCBkZXZfdHlwZVtXUFNfREVWX1RZUEVfTEVOXSk7CiBjaGFyICogd3BzX2Rldl90eXBlX2JpbjJzdHIoY29uc3QgdTggZGV2X3R5cGVbV1BTX0RFVl9UWVBFX0xFTl0sIGNoYXIgKmJ1ZiwKIAkJCSAgICBzaXplX3QgYnVmX2xlbik7CiB2b2lkIHV1aWRfZ2VuX21hY19hZGRyKGNvbnN0IHU4ICptYWNfYWRkciwgdTggKnV1aWQpOwogdTE2IHdwc19jb25maWdfbWV0aG9kc19zdHIyYmluKGNvbnN0IGNoYXIgKnN0cik7CitzdHJ1Y3Qgd3BhYnVmICogd3BzX2J1aWxkX25mY19wd190b2tlbih1MTYgZGV2X3B3X2lkLAorCQkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwdWJrZXksCisJCQkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRldl9wdyk7CitzdHJ1Y3Qgd3BhYnVmICogd3BzX25mY190b2tlbl9nZW4oaW50IG5kZWYsIGludCAqaWQsIHN0cnVjdCB3cGFidWYgKipwdWJrZXksCisJCQkJICBzdHJ1Y3Qgd3BhYnVmICoqcHJpdmtleSwKKwkJCQkgIHN0cnVjdCB3cGFidWYgKipkZXZfcHcpOworCisvKiBuZGVmLmMgKi8KK3N0cnVjdCB3cGFidWYgKiBuZGVmX3BhcnNlX3dpZmkoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmKTsKK3N0cnVjdCB3cGFidWYgKiBuZGVmX2J1aWxkX3dpZmkoY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmKTsKIAogI2lmZGVmIENPTkZJR19XUFNfU1RSSUNUCiBpbnQgd3BzX3ZhbGlkYXRlX2JlYWNvbihjb25zdCBzdHJ1Y3Qgd3BhYnVmICp3cHNfaWUpOwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfYXR0cl9idWlsZC5jIGIvc3JjL3dwcy93cHNfYXR0cl9idWlsZC5jCmluZGV4IDc1MzA4M2QuLjliZTMwYjkgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2F0dHJfYnVpbGQuYworKysgYi9zcmMvd3BzL3dwc19hdHRyX2J1aWxkLmMKQEAgLTMwLDYgKzMwLDE0IEBACiAJCXdwcy0+ZGhfY3R4ID0gd3BzLT53cHMtPmRoX2N0eDsKIAkJd3BzLT53cHMtPmRoX2N0eCA9IE5VTEw7CiAJCXB1YmtleSA9IHdwYWJ1Zl9kdXAod3BzLT53cHMtPmRoX3B1YmtleSk7CisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwl9IGVsc2UgaWYgKHdwcy0+ZGV2X3B3X2lkID49IDB4MTAgJiYgd3BzLT53cHMtPmFwICYmCisJCSAgIHdwcy0+ZGV2X3B3X2lkID09IHdwcy0+d3BzLT5hcF9uZmNfZGV2X3B3X2lkKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVc2luZyBORkMgcGFzc3dvcmQgdG9rZW4gREgga2V5cyIpOworCQl3cHMtPmRoX3ByaXZrZXkgPSB3cGFidWZfZHVwKHdwcy0+d3BzLT5hcF9uZmNfZGhfcHJpdmtleSk7CisJCXB1YmtleSA9IHdwYWJ1Zl9kdXAod3BzLT53cHMtPmFwX25mY19kaF9wdWJrZXkpOworCQl3cHMtPmRoX2N0eCA9IGRoNV9pbml0X2ZpeGVkKHdwcy0+ZGhfcHJpdmtleSwgcHVia2V5KTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogCX0gZWxzZSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBHZW5lcmF0ZSBuZXcgREgga2V5cyIpOwogCQl3cHMtPmRoX3ByaXZrZXkgPSBOVUxMOwpAQCAtMzQwLDE5ICszNDgsMzQgQEAKIAogCiAjaWZkZWYgQ09ORklHX1dQU19PT0IKLWludCB3cHNfYnVpbGRfb29iX2Rldl9wYXNzd29yZChzdHJ1Y3Qgd3BhYnVmICptc2csIHN0cnVjdCB3cHNfY29udGV4dCAqd3BzKQoraW50IHdwc19idWlsZF9vb2JfZGV2X3B3KHN0cnVjdCB3cGFidWYgKm1zZywgdTE2IGRldl9wd19pZCwKKwkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwdWJrZXksIGNvbnN0IHU4ICpkZXZfcHcsCisJCQkgc2l6ZV90IGRldl9wd19sZW4pCiB7CiAJc2l6ZV90IGhhc2hfbGVuOwogCWNvbnN0IHU4ICphZGRyWzFdOwogCXU4IHB1YmtleV9oYXNoW1dQU19IQVNIX0xFTl07CisKKwlhZGRyWzBdID0gd3BhYnVmX2hlYWQocHVia2V5KTsKKwloYXNoX2xlbiA9IHdwYWJ1Zl9sZW4ocHVia2V5KTsKKwlzaGEyNTZfdmVjdG9yKDEsIGFkZHIsICZoYXNoX2xlbiwgcHVia2V5X2hhc2gpOworCisJd3BhYnVmX3B1dF9iZTE2KG1zZywgQVRUUl9PT0JfREVWSUNFX1BBU1NXT1JEKTsKKwl3cGFidWZfcHV0X2JlMTYobXNnLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIgKyBkZXZfcHdfbGVuKTsKKwl3cGFidWZfcHV0X2RhdGEobXNnLCBwdWJrZXlfaGFzaCwgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCXdwYWJ1Zl9wdXRfYmUxNihtc2csIGRldl9wd19pZCk7CisJd3BhYnVmX3B1dF9kYXRhKG1zZywgZGV2X3B3LCBkZXZfcHdfbGVuKTsKKworCXJldHVybiAwOworfQorCisKK2ludCB3cHNfYnVpbGRfb29iX2Rldl9wYXNzd29yZChzdHJ1Y3Qgd3BhYnVmICptc2csIHN0cnVjdCB3cHNfY29udGV4dCAqd3BzKQorewogCXU4IGRldl9wYXNzd29yZF9iaW5bV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOXTsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAgKiBPT0IgRGV2aWNlIFBhc3N3b3JkIik7CiAKLQlhZGRyWzBdID0gd3BhYnVmX2hlYWQod3BzLT5kaF9wdWJrZXkpOwotCWhhc2hfbGVuID0gd3BhYnVmX2xlbih3cHMtPmRoX3B1YmtleSk7Ci0Jc2hhMjU2X3ZlY3RvcigxLCBhZGRyLCAmaGFzaF9sZW4sIHB1YmtleV9oYXNoKTsKLQogCWlmIChvc19nZXRfcmFuZG9tKCh1OCAqKSAmd3BzLT5vb2JfZGV2X3B3X2lkLCBzaXplb2YodTE2KSkgPCAwKSB7CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV1BTOiBkZXZpY2UgcGFzc3dvcmQgaWQgIgogCQkJICAgImdlbmVyYXRpb24gZXJyb3IiKTsKQEAgLTM2NywxOSArMzkwLDE1IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQl3cGFidWZfcHV0X2JlMTYobXNnLCBBVFRSX09PQl9ERVZJQ0VfUEFTU1dPUkQpOwotCXdwYWJ1Zl9wdXRfYmUxNihtc2csIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0FUVFJfTEVOKTsKLQl3cGFidWZfcHV0X2RhdGEobXNnLCBwdWJrZXlfaGFzaCwgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOwotCXdwYWJ1Zl9wdXRfYmUxNihtc2csIHdwcy0+b29iX2Rldl9wd19pZCk7Ci0Jd3BhYnVmX3B1dF9kYXRhKG1zZywgZGV2X3Bhc3N3b3JkX2JpbiwgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOKTsKLQogCXdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKAogCQl3cGFidWZfcHV0KHdwcy0+b29iX2NvbmYuZGV2X3Bhc3N3b3JkLAogCQkJICAgd3BhYnVmX3NpemUod3BzLT5vb2JfY29uZi5kZXZfcGFzc3dvcmQpKSwKIAkJd3BhYnVmX3NpemUod3BzLT5vb2JfY29uZi5kZXZfcGFzc3dvcmQpLAogCQlkZXZfcGFzc3dvcmRfYmluLCBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4pOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHdwc19idWlsZF9vb2JfZGV2X3B3KG1zZywgd3BzLT5vb2JfZGV2X3B3X2lkLCB3cHMtPmRoX3B1YmtleSwKKwkJCQkgICAgZGV2X3Bhc3N3b3JkX2JpbiwKKwkJCQkgICAgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOKTsKIH0KICNlbmRpZiAvKiBDT05GSUdfV1BTX09PQiAqLwogCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19hdHRyX3BhcnNlLmMgYi9zcmMvd3BzL3dwc19hdHRyX3BhcnNlLmMKaW5kZXggZjVhZDQwMy4uNWFhOWIwMCAxMDA2NDQKLS0tIGEvc3JjL3dwcy93cHNfYXR0cl9wYXJzZS5jCisrKyBiL3NyYy93cHMvd3BzX2F0dHJfcGFyc2UuYwpAQCAtOSw3ICs5LDggQEAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgogCiAjaW5jbHVkZSAiY29tbW9uLmgiCi0jaW5jbHVkZSAid3BzX2kuaCIKKyNpbmNsdWRlICJ3cHNfZGVmcy5oIgorI2luY2x1ZGUgIndwc19hdHRyX3BhcnNlLmgiCiAKICNpZm5kZWYgQ09ORklHX1dQU19TVFJJQ1QKICNkZWZpbmUgV1BTX1dPUktBUk9VTkRTCkBAIC0yNjIsMTIgKzI2MywxNiBAQAogCQlhdHRyLT5kZXZfcGFzc3dvcmRfaWQgPSBwb3M7CiAJCWJyZWFrOwogCWNhc2UgQVRUUl9PT0JfREVWSUNFX1BBU1NXT1JEOgotCQlpZiAobGVuICE9IFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0FUVFJfTEVOKSB7CisJCWlmIChsZW4gPCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIgKworCQkgICAgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTUlOX0xFTiB8fAorCQkgICAgbGVuID4gV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAyICsKKwkJICAgIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0xFTikgewogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEludmFsaWQgT09CIERldmljZSAiCiAJCQkJICAgIlBhc3N3b3JkIGxlbmd0aCAldSIsIGxlbik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAkJYXR0ci0+b29iX2Rldl9wYXNzd29yZCA9IHBvczsKKwkJYXR0ci0+b29iX2Rldl9wYXNzd29yZF9sZW4gPSBsZW47CiAJCWJyZWFrOwogCWNhc2UgQVRUUl9PU19WRVJTSU9OOgogCQlpZiAobGVuICE9IDQpIHsKZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX2F0dHJfcGFyc2UuaCBiL3NyYy93cHMvd3BzX2F0dHJfcGFyc2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMzJlOTY2Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3dwcy93cHNfYXR0cl9wYXJzZS5oCkBAIC0wLDAgKzEsMTA3IEBACisvKgorICogV2ktRmkgUHJvdGVjdGVkIFNldHVwIC0gYXR0cmlidXRlIHBhcnNpbmcKKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBXUFNfQVRUUl9QQVJTRV9ICisjZGVmaW5lIFdQU19BVFRSX1BBUlNFX0gKKworI2luY2x1ZGUgIndwcy5oIgorCitzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgeworCS8qIGZpeGVkIGxlbmd0aCBmaWVsZHMgKi8KKwljb25zdCB1OCAqdmVyc2lvbjsgLyogMSBvY3RldCAqLworCWNvbnN0IHU4ICp2ZXJzaW9uMjsgLyogMSBvY3RldCAqLworCWNvbnN0IHU4ICptc2dfdHlwZTsgLyogMSBvY3RldCAqLworCWNvbnN0IHU4ICplbnJvbGxlZV9ub25jZTsgLyogV1BTX05PTkNFX0xFTiAoMTYpIG9jdGV0cyAqLworCWNvbnN0IHU4ICpyZWdpc3RyYXJfbm9uY2U7IC8qIFdQU19OT05DRV9MRU4gKDE2KSBvY3RldHMgKi8KKwljb25zdCB1OCAqdXVpZF9yOyAvKiBXUFNfVVVJRF9MRU4gKDE2KSBvY3RldHMgKi8KKwljb25zdCB1OCAqdXVpZF9lOyAvKiBXUFNfVVVJRF9MRU4gKDE2KSBvY3RldHMgKi8KKwljb25zdCB1OCAqYXV0aF90eXBlX2ZsYWdzOyAvKiAyIG9jdGV0cyAqLworCWNvbnN0IHU4ICplbmNyX3R5cGVfZmxhZ3M7IC8qIDIgb2N0ZXRzICovCisJY29uc3QgdTggKmNvbm5fdHlwZV9mbGFnczsgLyogMSBvY3RldCAqLworCWNvbnN0IHU4ICpjb25maWdfbWV0aG9kczsgLyogMiBvY3RldHMgKi8KKwljb25zdCB1OCAqc2VsX3JlZ19jb25maWdfbWV0aG9kczsgLyogMiBvY3RldHMgKi8KKwljb25zdCB1OCAqcHJpbWFyeV9kZXZfdHlwZTsgLyogOCBvY3RldHMgKi8KKwljb25zdCB1OCAqcmZfYmFuZHM7IC8qIDEgb2N0ZXQgKi8KKwljb25zdCB1OCAqYXNzb2Nfc3RhdGU7IC8qIDIgb2N0ZXRzICovCisJY29uc3QgdTggKmNvbmZpZ19lcnJvcjsgLyogMiBvY3RldHMgKi8KKwljb25zdCB1OCAqZGV2X3Bhc3N3b3JkX2lkOyAvKiAyIG9jdGV0cyAqLworCWNvbnN0IHU4ICpvc192ZXJzaW9uOyAvKiA0IG9jdGV0cyAqLworCWNvbnN0IHU4ICp3cHNfc3RhdGU7IC8qIDEgb2N0ZXQgKi8KKwljb25zdCB1OCAqYXV0aGVudGljYXRvcjsgLyogV1BTX0FVVEhFTlRJQ0FUT1JfTEVOICg4KSBvY3RldHMgKi8KKwljb25zdCB1OCAqcl9oYXNoMTsgLyogV1BTX0hBU0hfTEVOICgzMikgb2N0ZXRzICovCisJY29uc3QgdTggKnJfaGFzaDI7IC8qIFdQU19IQVNIX0xFTiAoMzIpIG9jdGV0cyAqLworCWNvbnN0IHU4ICplX2hhc2gxOyAvKiBXUFNfSEFTSF9MRU4gKDMyKSBvY3RldHMgKi8KKwljb25zdCB1OCAqZV9oYXNoMjsgLyogV1BTX0hBU0hfTEVOICgzMikgb2N0ZXRzICovCisJY29uc3QgdTggKnJfc25vbmNlMTsgLyogV1BTX1NFQ1JFVF9OT05DRV9MRU4gKDE2KSBvY3RldHMgKi8KKwljb25zdCB1OCAqcl9zbm9uY2UyOyAvKiBXUFNfU0VDUkVUX05PTkNFX0xFTiAoMTYpIG9jdGV0cyAqLworCWNvbnN0IHU4ICplX3Nub25jZTE7IC8qIFdQU19TRUNSRVRfTk9OQ0VfTEVOICgxNikgb2N0ZXRzICovCisJY29uc3QgdTggKmVfc25vbmNlMjsgLyogV1BTX1NFQ1JFVF9OT05DRV9MRU4gKDE2KSBvY3RldHMgKi8KKwljb25zdCB1OCAqa2V5X3dyYXBfYXV0aDsgLyogV1BTX0tXQV9MRU4gKDgpIG9jdGV0cyAqLworCWNvbnN0IHU4ICphdXRoX3R5cGU7IC8qIDIgb2N0ZXRzICovCisJY29uc3QgdTggKmVuY3JfdHlwZTsgLyogMiBvY3RldHMgKi8KKwljb25zdCB1OCAqbmV0d29ya19pZHg7IC8qIDEgb2N0ZXQgKi8KKwljb25zdCB1OCAqbmV0d29ya19rZXlfaWR4OyAvKiAxIG9jdGV0ICovCisJY29uc3QgdTggKm1hY19hZGRyOyAvKiBFVEhfQUxFTiAoNikgb2N0ZXRzICovCisJY29uc3QgdTggKmtleV9wcm92X2F1dG87IC8qIDEgb2N0ZXQgKEJvb2wpICovCisJY29uc3QgdTggKmRvdDF4X2VuYWJsZWQ7IC8qIDEgb2N0ZXQgKEJvb2wpICovCisJY29uc3QgdTggKnNlbGVjdGVkX3JlZ2lzdHJhcjsgLyogMSBvY3RldCAoQm9vbCkgKi8KKwljb25zdCB1OCAqcmVxdWVzdF90eXBlOyAvKiAxIG9jdGV0ICovCisJY29uc3QgdTggKnJlc3BvbnNlX3R5cGU7IC8qIDEgb2N0ZXQgKi8KKwljb25zdCB1OCAqYXBfc2V0dXBfbG9ja2VkOyAvKiAxIG9jdGV0ICovCisJY29uc3QgdTggKnNldHRpbmdzX2RlbGF5X3RpbWU7IC8qIDEgb2N0ZXQgKi8KKwljb25zdCB1OCAqbmV0d29ya19rZXlfc2hhcmVhYmxlOyAvKiAxIG9jdGV0IChCb29sKSAqLworCWNvbnN0IHU4ICpyZXF1ZXN0X3RvX2Vucm9sbDsgLyogMSBvY3RldCAoQm9vbCkgKi8KKworCS8qIHZhcmlhYmxlIGxlbmd0aCBmaWVsZHMgKi8KKwljb25zdCB1OCAqbWFudWZhY3R1cmVyOworCXNpemVfdCBtYW51ZmFjdHVyZXJfbGVuOworCWNvbnN0IHU4ICptb2RlbF9uYW1lOworCXNpemVfdCBtb2RlbF9uYW1lX2xlbjsKKwljb25zdCB1OCAqbW9kZWxfbnVtYmVyOworCXNpemVfdCBtb2RlbF9udW1iZXJfbGVuOworCWNvbnN0IHU4ICpzZXJpYWxfbnVtYmVyOworCXNpemVfdCBzZXJpYWxfbnVtYmVyX2xlbjsKKwljb25zdCB1OCAqZGV2X25hbWU7CisJc2l6ZV90IGRldl9uYW1lX2xlbjsKKwljb25zdCB1OCAqcHVibGljX2tleTsKKwlzaXplX3QgcHVibGljX2tleV9sZW47CisJY29uc3QgdTggKmVuY3Jfc2V0dGluZ3M7CisJc2l6ZV90IGVuY3Jfc2V0dGluZ3NfbGVuOworCWNvbnN0IHU4ICpzc2lkOyAvKiA8PSAzMiBvY3RldHMgKi8KKwlzaXplX3Qgc3NpZF9sZW47CisJY29uc3QgdTggKm5ldHdvcmtfa2V5OyAvKiA8PSA2NCBvY3RldHMgKi8KKwlzaXplX3QgbmV0d29ya19rZXlfbGVuOworCWNvbnN0IHU4ICplYXBfdHlwZTsgLyogPD0gOCBvY3RldHMgKi8KKwlzaXplX3QgZWFwX3R5cGVfbGVuOworCWNvbnN0IHU4ICplYXBfaWRlbnRpdHk7IC8qIDw9IDY0IG9jdGV0cyAqLworCXNpemVfdCBlYXBfaWRlbnRpdHlfbGVuOworCWNvbnN0IHU4ICphdXRob3JpemVkX21hY3M7IC8qIDw9IDMwIG9jdGV0cyAqLworCXNpemVfdCBhdXRob3JpemVkX21hY3NfbGVuOworCWNvbnN0IHU4ICpzZWNfZGV2X3R5cGVfbGlzdDsgLyogPD0gMTI4IG9jdGV0cyAqLworCXNpemVfdCBzZWNfZGV2X3R5cGVfbGlzdF9sZW47CisJY29uc3QgdTggKm9vYl9kZXZfcGFzc3dvcmQ7IC8qIDM4Li41NCBvY3RldHMgKi8KKwlzaXplX3Qgb29iX2Rldl9wYXNzd29yZF9sZW47CisKKwkvKiBhdHRyaWJ1dGVzIHRoYXQgY2FuIG9jY3VyIG11bHRpcGxlIHRpbWVzICovCisjZGVmaW5lIE1BWF9DUkVEX0NPVU5UIDEwCisJY29uc3QgdTggKmNyZWRbTUFYX0NSRURfQ09VTlRdOworCXNpemVfdCBjcmVkX2xlbltNQVhfQ1JFRF9DT1VOVF07CisJc2l6ZV90IG51bV9jcmVkOworCisjZGVmaW5lIE1BWF9SRVFfREVWX1RZUEVfQ09VTlQgMTAKKwljb25zdCB1OCAqcmVxX2Rldl90eXBlW01BWF9SRVFfREVWX1RZUEVfQ09VTlRdOworCXNpemVfdCBudW1fcmVxX2Rldl90eXBlOworCisJY29uc3QgdTggKnZlbmRvcl9leHRbTUFYX1dQU19QQVJTRV9WRU5ET1JfRVhUXTsKKwlzaXplX3QgdmVuZG9yX2V4dF9sZW5bTUFYX1dQU19QQVJTRV9WRU5ET1JfRVhUXTsKKwlzaXplX3QgbnVtX3ZlbmRvcl9leHQ7Cit9OworCitpbnQgd3BzX3BhcnNlX21zZyhjb25zdCBzdHJ1Y3Qgd3BhYnVmICptc2csIHN0cnVjdCB3cHNfcGFyc2VfYXR0ciAqYXR0cik7CisKKyNlbmRpZiAvKiBXUFNfQVRUUl9QQVJTRV9IICovCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19jb21tb24uYyBiL3NyYy93cHMvd3BzX2NvbW1vbi5jCmluZGV4IDJkZmY0YjIuLjVhODgxN2YgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2NvbW1vbi5jCisrKyBiL3NyYy93cHMvd3BzX2NvbW1vbi5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdpLUZpIFByb3RlY3RlZCBTZXR1cCAtIGNvbW1vbiBmdW5jdGlvbmFsaXR5Ci0gKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yNDksNiArMjQ5LDIyIEBACiB9CiAKIAoraW50IHdwc19waW5fc3RyX3ZhbGlkKGNvbnN0IGNoYXIgKnBpbikKK3sKKwljb25zdCBjaGFyICpwOworCXNpemVfdCBsZW47CisKKwlwID0gcGluOworCXdoaWxlICgqcCA+PSAnMCcgJiYgKnAgPD0gJzknKQorCQlwKys7CisJaWYgKCpwICE9ICdcMCcpCisJCXJldHVybiAwOworCisJbGVuID0gcCAtIHBpbjsKKwlyZXR1cm4gbGVuID09IDQgfHwgbGVuID09IDg7Cit9CisKKwogdm9pZCB3cHNfZmFpbF9ldmVudChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgZW51bSB3cHNfbXNnX3R5cGUgbXNnLAogCQkgICAgdTE2IGNvbmZpZ19lcnJvciwgdTE2IGVycm9yX2luZGljYXRpb24pCiB7CkBAIC0zMDgsNyArMzI0LDcgQEAKIAogI2lmZGVmIENPTkZJR19XUFNfT09CCiAKLXN0YXRpYyBzdHJ1Y3Qgd3BhYnVmICogd3BzX2dldF9vb2JfY3JlZChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcykKK3N0cnVjdCB3cGFidWYgKiB3cHNfZ2V0X29vYl9jcmVkKHN0cnVjdCB3cHNfY29udGV4dCAqd3BzKQogewogCXN0cnVjdCB3cHNfZGF0YSBkYXRhOwogCXN0cnVjdCB3cGFidWYgKnBsYWluOwpAQCAtMzM1LDExICszNTEsMzUgQEAKIH0KIAogCitzdHJ1Y3Qgd3BhYnVmICogd3BzX2J1aWxkX25mY19wd190b2tlbih1MTYgZGV2X3B3X2lkLAorCQkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwdWJrZXksCisJCQkJICAgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKmRldl9wdykKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpkYXRhOworCisJZGF0YSA9IHdwYWJ1Zl9hbGxvYygyMDApOworCWlmIChkYXRhID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJaWYgKHdwc19idWlsZF92ZXJzaW9uKGRhdGEpIHx8CisJICAgIHdwc19idWlsZF9vb2JfZGV2X3B3KGRhdGEsIGRldl9wd19pZCwgcHVia2V5LAorCQkJCSB3cGFidWZfaGVhZChkZXZfcHcpLCB3cGFidWZfbGVuKGRldl9wdykpIHx8CisJICAgIHdwc19idWlsZF93ZmFfZXh0KGRhdGEsIDAsIE5VTEwsIDApKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV1BTOiBGYWlsZWQgdG8gYnVpbGQgTkZDIHBhc3N3b3JkICIKKwkJCSAgICJ0b2tlbiIpOworCQl3cGFidWZfZnJlZShkYXRhKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0dXJuIGRhdGE7Cit9CisKKwogc3RhdGljIHN0cnVjdCB3cGFidWYgKiB3cHNfZ2V0X29vYl9kZXZfcHdkKHN0cnVjdCB3cHNfY29udGV4dCAqd3BzKQogewogCXN0cnVjdCB3cGFidWYgKmRhdGE7CiAKLQlkYXRhID0gd3BhYnVmX2FsbG9jKDkgKyBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9BVFRSX0xFTik7CisJZGF0YSA9IHdwYWJ1Zl9hbGxvYygyMDApOwogCWlmIChkYXRhID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIE9PQiAiCiAJCQkgICAiZGV2aWNlIHBhc3N3b3JkIGF0dHJpYnV0ZSIpOwpAQCAtMzc1LDYgKzQxNSw3IEBACiAJc3RydWN0IG9vYl9jb25mX2RhdGEgKm9vYl9jb25mID0gJndwcy0+b29iX2NvbmY7CiAJc3RydWN0IHdwc19wYXJzZV9hdHRyIGF0dHI7CiAJY29uc3QgdTggKnBvczsKKwlzaXplX3QgcHdfbGVuOwogCiAJaWYgKHdwc19wYXJzZV9tc2coZGF0YSwgJmF0dHIpIDwgMCB8fAogCSAgICBhdHRyLm9vYl9kZXZfcGFzc3dvcmQgPT0gTlVMTCkgewpAQCAtMzg0LDYgKzQyNSw3IEBACiAKIAlwb3MgPSBhdHRyLm9vYl9kZXZfcGFzc3dvcmQ7CiAKKwl3cGFidWZfZnJlZShvb2JfY29uZi0+cHVia2V5X2hhc2gpOwogCW9vYl9jb25mLT5wdWJrZXlfaGFzaCA9CiAJCXdwYWJ1Zl9hbGxvY19jb3B5KHBvcywgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOwogCWlmIChvb2JfY29uZi0+cHVia2V5X2hhc2ggPT0gTlVMTCkgewpAQCAtMzk2LDM5ICs0MzgsMzIgQEAKIAl3cHMtPm9vYl9kZXZfcHdfaWQgPSBXUEFfR0VUX0JFMTYocG9zKTsKIAlwb3MgKz0gc2l6ZW9mKHdwcy0+b29iX2Rldl9wd19pZCk7CiAKLQlvb2JfY29uZi0+ZGV2X3Bhc3N3b3JkID0KLQkJd3BhYnVmX2FsbG9jKFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0xFTiAqIDIgKyAxKTsKKwlwd19sZW4gPSBhdHRyLm9vYl9kZXZfcGFzc3dvcmRfbGVuIC0gV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gLSAyOworCW9vYl9jb25mLT5kZXZfcGFzc3dvcmQgPSB3cGFidWZfYWxsb2MocHdfbGVuICogMiArIDEpOwogCWlmIChvb2JfY29uZi0+ZGV2X3Bhc3N3b3JkID09IE5VTEwpIHsKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IEZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIE9PQiAiCiAJCQkgICAiZGV2aWNlIHBhc3N3b3JkIik7CiAJCXJldHVybiAtMTsKIAl9CiAJd3BhX3NucHJpbnRmX2hleF91cHBlcmNhc2Uod3BhYnVmX3B1dChvb2JfY29uZi0+ZGV2X3Bhc3N3b3JkLAotCQkJCSAgIHdwYWJ1Zl9zaXplKG9vYl9jb25mLT5kZXZfcGFzc3dvcmQpKSwKLQkJCQkgICB3cGFidWZfc2l6ZShvb2JfY29uZi0+ZGV2X3Bhc3N3b3JkKSwgcG9zLAotCQkJCSAgIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0xFTik7CisJCQkJCSAgICAgIHB3X2xlbiAqIDIgKyAxKSwKKwkJCQkgICBwd19sZW4gKiAyICsgMSwgcG9zLCBwd19sZW4pOwogCiAJcmV0dXJuIDA7CiB9CiAKIAotc3RhdGljIGludCB3cHNfcGFyc2Vfb29iX2NyZWQoc3RydWN0IHdwc19jb250ZXh0ICp3cHMsIHN0cnVjdCB3cGFidWYgKmRhdGEpCitpbnQgd3BzX29vYl91c2VfY3JlZChzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgc3RydWN0IHdwc19wYXJzZV9hdHRyICphdHRyKQogewogCXN0cnVjdCB3cGFidWYgbXNnOwotCXN0cnVjdCB3cHNfcGFyc2VfYXR0ciBhdHRyOwogCXNpemVfdCBpOwogCi0JaWYgKHdwc19wYXJzZV9tc2coZGF0YSwgJmF0dHIpIDwgMCB8fCBhdHRyLm51bV9jcmVkIDw9IDApIHsKLQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IE9PQiBjcmVkZW50aWFsIG5vdCBmb3VuZCIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCi0JZm9yIChpID0gMDsgaSA8IGF0dHIubnVtX2NyZWQ7IGkrKykgeworCWZvciAoaSA9IDA7IGkgPCBhdHRyLT5udW1fY3JlZDsgaSsrKSB7CiAJCXN0cnVjdCB3cHNfY3JlZGVudGlhbCBsb2NhbF9jcmVkOwogCQlzdHJ1Y3Qgd3BzX3BhcnNlX2F0dHIgY2F0dHI7CiAKIAkJb3NfbWVtc2V0KCZsb2NhbF9jcmVkLCAwLCBzaXplb2YobG9jYWxfY3JlZCkpOwotCQl3cGFidWZfc2V0KCZtc2csIGF0dHIuY3JlZFtpXSwgYXR0ci5jcmVkX2xlbltpXSk7CisJCXdwYWJ1Zl9zZXQoJm1zZywgYXR0ci0+Y3JlZFtpXSwgYXR0ci0+Y3JlZF9sZW5baV0pOwogCQlpZiAod3BzX3BhcnNlX21zZygmbXNnLCAmY2F0dHIpIDwgMCB8fAogCQkgICAgd3BzX3Byb2Nlc3NfY3JlZCgmY2F0dHIsICZsb2NhbF9jcmVkKSkgewogCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IEZhaWxlZCB0byBwYXJzZSBPT0IgIgpAQCAtNDQyLDYgKzQ3NywxOSBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BzX3BhcnNlX29vYl9jcmVkKHN0cnVjdCB3cHNfY29udGV4dCAqd3BzLCBzdHJ1Y3Qgd3BhYnVmICpkYXRhKQoreworCXN0cnVjdCB3cHNfcGFyc2VfYXR0ciBhdHRyOworCisJaWYgKHdwc19wYXJzZV9tc2coZGF0YSwgJmF0dHIpIDwgMCB8fCBhdHRyLm51bV9jcmVkIDw9IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IE9PQiBjcmVkZW50aWFsIG5vdCBmb3VuZCIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIHdwc19vb2JfdXNlX2NyZWQod3BzLCAmYXR0cik7Cit9CisKKwogaW50IHdwc19wcm9jZXNzX29vYihzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcywgc3RydWN0IG9vYl9kZXZpY2VfZGF0YSAqb29iX2RldiwKIAkJICAgIGludCByZWdpc3RyYXIpCiB7CkBAIC02OTUsMyArNzQzLDUzIEBACiAKIAlyZXR1cm4gbXNnOwogfQorCisKKyNpZmRlZiBDT05GSUdfV1BTX05GQworc3RydWN0IHdwYWJ1ZiAqIHdwc19uZmNfdG9rZW5fZ2VuKGludCBuZGVmLCBpbnQgKmlkLCBzdHJ1Y3Qgd3BhYnVmICoqcHVia2V5LAorCQkJCSAgc3RydWN0IHdwYWJ1ZiAqKnByaXZrZXksCisJCQkJICBzdHJ1Y3Qgd3BhYnVmICoqZGV2X3B3KQoreworCXN0cnVjdCB3cGFidWYgKnByaXYgPSBOVUxMLCAqcHViID0gTlVMTCwgKnB3LCAqcmV0OworCXZvaWQgKmRoX2N0eDsKKwl1MTYgdmFsOworCisJcHcgPSB3cGFidWZfYWxsb2MoV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOKTsKKwlpZiAocHcgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAocmFuZG9tX2dldF9ieXRlcyh3cGFidWZfcHV0KHB3LCBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4pLAorCQkJICAgICBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4pIHx8CisJICAgIHJhbmRvbV9nZXRfYnl0ZXMoKHU4ICopICZ2YWwsIHNpemVvZih2YWwpKSkgeworCQl3cGFidWZfZnJlZShwdyk7CisJCXJldHVybiBOVUxMOworCX0KKworCWRoX2N0eCA9IGRoNV9pbml0KCZwcml2LCAmcHViKTsKKwlpZiAoZGhfY3R4ID09IE5VTEwpIHsKKwkJd3BhYnVmX2ZyZWUocHcpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJZGg1X2ZyZWUoZGhfY3R4KTsKKworCSppZCA9IDB4MTAgKyB2YWwgJSAweGZmZjA7CisJd3BhYnVmX2ZyZWUoKnB1YmtleSk7CisJKnB1YmtleSA9IHB1YjsKKwl3cGFidWZfZnJlZSgqcHJpdmtleSk7CisJKnByaXZrZXkgPSBwcml2OworCXdwYWJ1Zl9mcmVlKCpkZXZfcHcpOworCSpkZXZfcHcgPSBwdzsKKworCXJldCA9IHdwc19idWlsZF9uZmNfcHdfdG9rZW4oKmlkLCAqcHVia2V5LCAqZGV2X3B3KTsKKwlpZiAobmRlZiAmJiByZXQpIHsKKwkJc3RydWN0IHdwYWJ1ZiAqdG1wOworCQl0bXAgPSBuZGVmX2J1aWxkX3dpZmkocmV0KTsKKwkJd3BhYnVmX2ZyZWUocmV0KTsKKwkJaWYgKHRtcCA9PSBOVUxMKQorCQkJcmV0dXJuIE5VTEw7CisJCXJldCA9IHRtcDsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19kZWZzLmggYi9zcmMvd3BzL3dwc19kZWZzLmgKaW5kZXggZTEyOGExOS4uMmY0MjYwMyAxMDA2NDQKLS0tIGEvc3JjL3dwcy93cHNfZGVmcy5oCisrKyBiL3NyYy93cHMvd3BzX2RlZnMuaApAQCAtNDEsNyArNDEsNyBAQAogI2RlZmluZSBXUFNfTUdNVEFVVEhLRVlfTEVOIDMyCiAjZGVmaW5lIFdQU19NR01URU5DS0VZX0xFTiAxNgogI2RlZmluZSBXUFNfTUdNVF9LRVlfSURfTEVOIDE2Ci0jZGVmaW5lIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0FUVFJfTEVOIDU0CisjZGVmaW5lIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX01JTl9MRU4gMTYKICNkZWZpbmUgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOIDMyCiAjZGVmaW5lIFdQU19PT0JfUFVCS0VZX0hBU0hfTEVOIDIwCiAKZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX2Rldl9hdHRyLmMgYi9zcmMvd3BzL3dwc19kZXZfYXR0ci5jCmluZGV4IDU1OTU4MmQuLjNjOTRhNDMgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX2Rldl9hdHRyLmMKKysrIGIvc3JjL3dwcy93cHNfZGV2X2F0dHIuYwpAQCAtMjAzLDYgKzIwMywyMCBAQAogfQogCiAKK2ludCB3cHNfYnVpbGRfdmVuZG9yX2V4dF9tMShzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZykKK3sKKwlpZiAoZGV2LT52ZW5kb3JfZXh0X20xICE9IE5VTEwpIHsKKwkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiAgKiBWZW5kb3IgRXh0ZW5zaW9uIE0xIiwKKwkJCSAgICB3cGFidWZfaGVhZF91OChkZXYtPnZlbmRvcl9leHRfbTEpLAorCQkJICAgIHdwYWJ1Zl9sZW4oZGV2LT52ZW5kb3JfZXh0X20xKSk7CisJCXdwYWJ1Zl9wdXRfYmUxNihtc2csIEFUVFJfVkVORE9SX0VYVCk7CisJCXdwYWJ1Zl9wdXRfYmUxNihtc2csIHdwYWJ1Zl9sZW4oZGV2LT52ZW5kb3JfZXh0X20xKSk7CisJCXdwYWJ1Zl9wdXRfYnVmKG1zZywgZGV2LT52ZW5kb3JfZXh0X20xKTsKKwl9CisJcmV0dXJuIDA7Cit9CisKKwogaW50IHdwc19idWlsZF9yZl9iYW5kcyhzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZykKIHsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogICogUkYgQmFuZHMgKCV4KSIsIGRldi0+cmZfYmFuZHMpOwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfZGV2X2F0dHIuaCBiL3NyYy93cHMvd3BzX2Rldl9hdHRyLmgKaW5kZXggN2NhODFhZC4uMjAwYzljNCAxMDA2NDQKLS0tIGEvc3JjL3dwcy93cHNfZGV2X2F0dHIuaAorKysgYi9zcmMvd3BzL3dwc19kZXZfYXR0ci5oCkBAIC0xNyw2ICsxNyw3IEBACiBpbnQgd3BzX2J1aWxkX2Rldl9uYW1lKHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldiwgc3RydWN0IHdwYWJ1ZiAqbXNnKTsKIGludCB3cHNfYnVpbGRfZGV2aWNlX2F0dHJzKHN0cnVjdCB3cHNfZGV2aWNlX2RhdGEgKmRldiwgc3RydWN0IHdwYWJ1ZiAqbXNnKTsKIGludCB3cHNfYnVpbGRfb3NfdmVyc2lvbihzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZyk7CitpbnQgd3BzX2J1aWxkX3ZlbmRvcl9leHRfbTEoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LCBzdHJ1Y3Qgd3BhYnVmICptc2cpOwogaW50IHdwc19idWlsZF9yZl9iYW5kcyhzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYsIHN0cnVjdCB3cGFidWYgKm1zZyk7CiBpbnQgd3BzX2J1aWxkX3ByaW1hcnlfZGV2X3R5cGUoc3RydWN0IHdwc19kZXZpY2VfZGF0YSAqZGV2LAogCQkJICAgICAgIHN0cnVjdCB3cGFidWYgKm1zZyk7CmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19lbnJvbGxlZS5jIGIvc3JjL3dwcy93cHNfZW5yb2xsZWUuYwppbmRleCA4NWQyZTk1Li5kYTBjMTAxIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19lbnJvbGxlZS5jCisrKyBiL3NyYy93cHMvd3BzX2Vucm9sbGVlLmMKQEAgLTE2Myw3ICsxNjMsOCBAQAogCSAgICB3cHNfYnVpbGRfZGV2X3Bhc3N3b3JkX2lkKG1zZywgd3BzLT5kZXZfcHdfaWQpIHx8CiAJICAgIHdwc19idWlsZF9jb25maWdfZXJyb3IobXNnLCBXUFNfQ0ZHX05PX0VSUk9SKSB8fAogCSAgICB3cHNfYnVpbGRfb3NfdmVyc2lvbigmd3BzLT53cHMtPmRldiwgbXNnKSB8fAotCSAgICB3cHNfYnVpbGRfd2ZhX2V4dChtc2csIDAsIE5VTEwsIDApKSB7CisJICAgIHdwc19idWlsZF93ZmFfZXh0KG1zZywgMCwgTlVMTCwgMCkgfHwKKwkgICAgd3BzX2J1aWxkX3ZlbmRvcl9leHRfbTEoJndwcy0+d3BzLT5kZXYsIG1zZykpIHsKIAkJd3BhYnVmX2ZyZWUobXNnKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfZXIuYyBiL3NyYy93cHMvd3BzX2VyLmMKaW5kZXggMDY1NWEzYS4uOTVhMGRlYyAxMDA2NDQKLS0tIGEvc3JjL3dwcy93cHNfZXIuYworKysgYi9zcmMvd3BzL3dwc19lci5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdpLUZpIFByb3RlY3RlZCBTZXR1cCAtIEV4dGVybmFsIFJlZ2lzdHJhcgotICogQ29weXJpZ2h0IChjKSAyMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA5LTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTE5OTYsMyArMTk5Niw0MSBAQAogCiAJcmV0dXJuIDA7CiB9CisKKworI2lmZGVmIENPTkZJR19XUFNfTkZDCitzdHJ1Y3Qgd3BhYnVmICogd3BzX2VyX25mY19jb25maWdfdG9rZW4oc3RydWN0IHdwc19lciAqZXIsIGNvbnN0IHU4ICp1dWlkKQoreworCXN0cnVjdCB3cHNfZXJfYXAgKmFwOworCXN0cnVjdCB3cGFidWYgKnJldDsKKwlzdHJ1Y3Qgd3BzX2RhdGEgZGF0YTsKKworCWlmIChlciA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWFwID0gd3BzX2VyX2FwX2dldChlciwgTlVMTCwgdXVpZCk7CisJaWYgKGFwID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCWlmIChhcC0+YXBfc2V0dGluZ3MgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBFUjogTm8gc2V0dGluZ3Mga25vd24gZm9yIHRoZSAiCisJCQkgICAic2VsZWN0ZWQgQVAiKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0ID0gd3BhYnVmX2FsbG9jKDUwMCk7CisJaWYgKHJldCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCW9zX21lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKKwlkYXRhLndwcyA9IGVyLT53cHM7CisJZGF0YS51c2VfY3JlZCA9IGFwLT5hcF9zZXR0aW5nczsKKwlpZiAod3BzX2J1aWxkX3ZlcnNpb24ocmV0KSB8fAorCSAgICB3cHNfYnVpbGRfY3JlZCgmZGF0YSwgcmV0KSB8fAorCSAgICB3cHNfYnVpbGRfd2ZhX2V4dChyZXQsIDAsIE5VTEwsIDApKSB7CisJCXdwYWJ1Zl9mcmVlKHJldCk7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiByZXQ7Cit9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX2kuaCBiL3NyYy93cHMvd3BzX2kuaAppbmRleCAxMjk3ZjY1Li44NmFkMjQ4IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19pLmgKKysrIGIvc3JjL3dwcy93cHNfaS5oCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdpLUZpIFByb3RlY3RlZCBTZXR1cCAtIGludGVybmFsIGRlZmluaXRpb25zCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAwOSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMCw2ICsxMCw5IEBACiAjZGVmaW5lIFdQU19JX0gKIAogI2luY2x1ZGUgIndwcy5oIgorI2luY2x1ZGUgIndwc19hdHRyX3BhcnNlLmgiCisKK3N0cnVjdCB3cHNfbmZjX3B3X3Rva2VuOwogCiAvKioKICAqIHN0cnVjdCB3cHNfZGF0YSAtIFdQUyByZWdpc3RyYXRpb24gcHJvdG9jb2wgZGF0YQpAQCAtMTE0LDEwMCArMTE3LDExIEBACiAJdTggcDJwX2Rldl9hZGRyW0VUSF9BTEVOXTsgLyogUDJQIERldmljZSBBZGRyZXNzIG9mIHRoZSBjbGllbnQgb3IKIAkJCQkgICAgKiAwMDowMDowMDowMDowMDowMCBpZiBub3QgYSBQMnAgY2xpZW50ICovCiAJaW50IHBiY19pbl9tMTsKKworCXN0cnVjdCB3cHNfbmZjX3B3X3Rva2VuICpuZmNfcHdfdG9rZW47CiB9OwogCiAKLXN0cnVjdCB3cHNfcGFyc2VfYXR0ciB7Ci0JLyogZml4ZWQgbGVuZ3RoIGZpZWxkcyAqLwotCWNvbnN0IHU4ICp2ZXJzaW9uOyAvKiAxIG9jdGV0ICovCi0JY29uc3QgdTggKnZlcnNpb24yOyAvKiAxIG9jdGV0ICovCi0JY29uc3QgdTggKm1zZ190eXBlOyAvKiAxIG9jdGV0ICovCi0JY29uc3QgdTggKmVucm9sbGVlX25vbmNlOyAvKiBXUFNfTk9OQ0VfTEVOICgxNikgb2N0ZXRzICovCi0JY29uc3QgdTggKnJlZ2lzdHJhcl9ub25jZTsgLyogV1BTX05PTkNFX0xFTiAoMTYpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICp1dWlkX3I7IC8qIFdQU19VVUlEX0xFTiAoMTYpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICp1dWlkX2U7IC8qIFdQU19VVUlEX0xFTiAoMTYpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICphdXRoX3R5cGVfZmxhZ3M7IC8qIDIgb2N0ZXRzICovCi0JY29uc3QgdTggKmVuY3JfdHlwZV9mbGFnczsgLyogMiBvY3RldHMgKi8KLQljb25zdCB1OCAqY29ubl90eXBlX2ZsYWdzOyAvKiAxIG9jdGV0ICovCi0JY29uc3QgdTggKmNvbmZpZ19tZXRob2RzOyAvKiAyIG9jdGV0cyAqLwotCWNvbnN0IHU4ICpzZWxfcmVnX2NvbmZpZ19tZXRob2RzOyAvKiAyIG9jdGV0cyAqLwotCWNvbnN0IHU4ICpwcmltYXJ5X2Rldl90eXBlOyAvKiA4IG9jdGV0cyAqLwotCWNvbnN0IHU4ICpyZl9iYW5kczsgLyogMSBvY3RldCAqLwotCWNvbnN0IHU4ICphc3NvY19zdGF0ZTsgLyogMiBvY3RldHMgKi8KLQljb25zdCB1OCAqY29uZmlnX2Vycm9yOyAvKiAyIG9jdGV0cyAqLwotCWNvbnN0IHU4ICpkZXZfcGFzc3dvcmRfaWQ7IC8qIDIgb2N0ZXRzICovCi0JY29uc3QgdTggKm9vYl9kZXZfcGFzc3dvcmQ7IC8qIFdQU19PT0JfREVWSUNFX1BBU1NXT1JEX0FUVFJfTEVOICg1NCkKLQkJCQkgICAgICogb2N0ZXRzICovCi0JY29uc3QgdTggKm9zX3ZlcnNpb247IC8qIDQgb2N0ZXRzICovCi0JY29uc3QgdTggKndwc19zdGF0ZTsgLyogMSBvY3RldCAqLwotCWNvbnN0IHU4ICphdXRoZW50aWNhdG9yOyAvKiBXUFNfQVVUSEVOVElDQVRPUl9MRU4gKDgpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICpyX2hhc2gxOyAvKiBXUFNfSEFTSF9MRU4gKDMyKSBvY3RldHMgKi8KLQljb25zdCB1OCAqcl9oYXNoMjsgLyogV1BTX0hBU0hfTEVOICgzMikgb2N0ZXRzICovCi0JY29uc3QgdTggKmVfaGFzaDE7IC8qIFdQU19IQVNIX0xFTiAoMzIpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICplX2hhc2gyOyAvKiBXUFNfSEFTSF9MRU4gKDMyKSBvY3RldHMgKi8KLQljb25zdCB1OCAqcl9zbm9uY2UxOyAvKiBXUFNfU0VDUkVUX05PTkNFX0xFTiAoMTYpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICpyX3Nub25jZTI7IC8qIFdQU19TRUNSRVRfTk9OQ0VfTEVOICgxNikgb2N0ZXRzICovCi0JY29uc3QgdTggKmVfc25vbmNlMTsgLyogV1BTX1NFQ1JFVF9OT05DRV9MRU4gKDE2KSBvY3RldHMgKi8KLQljb25zdCB1OCAqZV9zbm9uY2UyOyAvKiBXUFNfU0VDUkVUX05PTkNFX0xFTiAoMTYpIG9jdGV0cyAqLwotCWNvbnN0IHU4ICprZXlfd3JhcF9hdXRoOyAvKiBXUFNfS1dBX0xFTiAoOCkgb2N0ZXRzICovCi0JY29uc3QgdTggKmF1dGhfdHlwZTsgLyogMiBvY3RldHMgKi8KLQljb25zdCB1OCAqZW5jcl90eXBlOyAvKiAyIG9jdGV0cyAqLwotCWNvbnN0IHU4ICpuZXR3b3JrX2lkeDsgLyogMSBvY3RldCAqLwotCWNvbnN0IHU4ICpuZXR3b3JrX2tleV9pZHg7IC8qIDEgb2N0ZXQgKi8KLQljb25zdCB1OCAqbWFjX2FkZHI7IC8qIEVUSF9BTEVOICg2KSBvY3RldHMgKi8KLQljb25zdCB1OCAqa2V5X3Byb3ZfYXV0bzsgLyogMSBvY3RldCAoQm9vbCkgKi8KLQljb25zdCB1OCAqZG90MXhfZW5hYmxlZDsgLyogMSBvY3RldCAoQm9vbCkgKi8KLQljb25zdCB1OCAqc2VsZWN0ZWRfcmVnaXN0cmFyOyAvKiAxIG9jdGV0IChCb29sKSAqLwotCWNvbnN0IHU4ICpyZXF1ZXN0X3R5cGU7IC8qIDEgb2N0ZXQgKi8KLQljb25zdCB1OCAqcmVzcG9uc2VfdHlwZTsgLyogMSBvY3RldCAqLwotCWNvbnN0IHU4ICphcF9zZXR1cF9sb2NrZWQ7IC8qIDEgb2N0ZXQgKi8KLQljb25zdCB1OCAqc2V0dGluZ3NfZGVsYXlfdGltZTsgLyogMSBvY3RldCAqLwotCWNvbnN0IHU4ICpuZXR3b3JrX2tleV9zaGFyZWFibGU7IC8qIDEgb2N0ZXQgKEJvb2wpICovCi0JY29uc3QgdTggKnJlcXVlc3RfdG9fZW5yb2xsOyAvKiAxIG9jdGV0IChCb29sKSAqLwotCi0JLyogdmFyaWFibGUgbGVuZ3RoIGZpZWxkcyAqLwotCWNvbnN0IHU4ICptYW51ZmFjdHVyZXI7Ci0Jc2l6ZV90IG1hbnVmYWN0dXJlcl9sZW47Ci0JY29uc3QgdTggKm1vZGVsX25hbWU7Ci0Jc2l6ZV90IG1vZGVsX25hbWVfbGVuOwotCWNvbnN0IHU4ICptb2RlbF9udW1iZXI7Ci0Jc2l6ZV90IG1vZGVsX251bWJlcl9sZW47Ci0JY29uc3QgdTggKnNlcmlhbF9udW1iZXI7Ci0Jc2l6ZV90IHNlcmlhbF9udW1iZXJfbGVuOwotCWNvbnN0IHU4ICpkZXZfbmFtZTsKLQlzaXplX3QgZGV2X25hbWVfbGVuOwotCWNvbnN0IHU4ICpwdWJsaWNfa2V5OwotCXNpemVfdCBwdWJsaWNfa2V5X2xlbjsKLQljb25zdCB1OCAqZW5jcl9zZXR0aW5nczsKLQlzaXplX3QgZW5jcl9zZXR0aW5nc19sZW47Ci0JY29uc3QgdTggKnNzaWQ7IC8qIDw9IDMyIG9jdGV0cyAqLwotCXNpemVfdCBzc2lkX2xlbjsKLQljb25zdCB1OCAqbmV0d29ya19rZXk7IC8qIDw9IDY0IG9jdGV0cyAqLwotCXNpemVfdCBuZXR3b3JrX2tleV9sZW47Ci0JY29uc3QgdTggKmVhcF90eXBlOyAvKiA8PSA4IG9jdGV0cyAqLwotCXNpemVfdCBlYXBfdHlwZV9sZW47Ci0JY29uc3QgdTggKmVhcF9pZGVudGl0eTsgLyogPD0gNjQgb2N0ZXRzICovCi0Jc2l6ZV90IGVhcF9pZGVudGl0eV9sZW47Ci0JY29uc3QgdTggKmF1dGhvcml6ZWRfbWFjczsgLyogPD0gMzAgb2N0ZXRzICovCi0Jc2l6ZV90IGF1dGhvcml6ZWRfbWFjc19sZW47Ci0JY29uc3QgdTggKnNlY19kZXZfdHlwZV9saXN0OyAvKiA8PSAxMjggb2N0ZXRzICovCi0Jc2l6ZV90IHNlY19kZXZfdHlwZV9saXN0X2xlbjsKLQotCS8qIGF0dHJpYnV0ZXMgdGhhdCBjYW4gb2NjdXIgbXVsdGlwbGUgdGltZXMgKi8KLSNkZWZpbmUgTUFYX0NSRURfQ09VTlQgMTAKLQljb25zdCB1OCAqY3JlZFtNQVhfQ1JFRF9DT1VOVF07Ci0Jc2l6ZV90IGNyZWRfbGVuW01BWF9DUkVEX0NPVU5UXTsKLQlzaXplX3QgbnVtX2NyZWQ7Ci0KLSNkZWZpbmUgTUFYX1JFUV9ERVZfVFlQRV9DT1VOVCAxMAotCWNvbnN0IHU4ICpyZXFfZGV2X3R5cGVbTUFYX1JFUV9ERVZfVFlQRV9DT1VOVF07Ci0Jc2l6ZV90IG51bV9yZXFfZGV2X3R5cGU7Ci0KLQljb25zdCB1OCAqdmVuZG9yX2V4dFtNQVhfV1BTX1BBUlNFX1ZFTkRPUl9FWFRdOwotCXNpemVfdCB2ZW5kb3JfZXh0X2xlbltNQVhfV1BTX1BBUlNFX1ZFTkRPUl9FWFRdOwotCXNpemVfdCBudW1fdmVuZG9yX2V4dDsKLX07Ci0KIC8qIHdwc19jb21tb24uYyAqLwogdm9pZCB3cHNfa2RmKGNvbnN0IHU4ICprZXksIGNvbnN0IHU4ICpsYWJlbF9wcmVmaXgsIHNpemVfdCBsYWJlbF9wcmVmaXhfbGVuLAogCSAgICAgY29uc3QgY2hhciAqbGFiZWwsIHU4ICpyZXMsIHNpemVfdCByZXNfbGVuKTsKQEAgLTIzMCw5ICsxNDQsNiBAQAogc3RydWN0IHdwYWJ1ZiAqIHdwc19idWlsZF93c2NfYWNrKHN0cnVjdCB3cHNfZGF0YSAqd3BzKTsKIHN0cnVjdCB3cGFidWYgKiB3cHNfYnVpbGRfd3NjX25hY2soc3RydWN0IHdwc19kYXRhICp3cHMpOwogCi0vKiB3cHNfYXR0cl9wYXJzZS5jICovCi1pbnQgd3BzX3BhcnNlX21zZyhjb25zdCBzdHJ1Y3Qgd3BhYnVmICptc2csIHN0cnVjdCB3cHNfcGFyc2VfYXR0ciAqYXR0cik7Ci0KIC8qIHdwc19hdHRyX2J1aWxkLmMgKi8KIGludCB3cHNfYnVpbGRfcHVibGljX2tleShzdHJ1Y3Qgd3BzX2RhdGEgKndwcywgc3RydWN0IHdwYWJ1ZiAqbXNnKTsKIGludCB3cHNfYnVpbGRfcmVxX3R5cGUoc3RydWN0IHdwYWJ1ZiAqbXNnLCBlbnVtIHdwc19yZXF1ZXN0X3R5cGUgdHlwZSk7CkBAIC0yNTUsNiArMTY2LDkgQEAKIGludCB3cHNfYnVpbGRfZW5jcl90eXBlX2ZsYWdzKHN0cnVjdCB3cHNfZGF0YSAqd3BzLCBzdHJ1Y3Qgd3BhYnVmICptc2cpOwogaW50IHdwc19idWlsZF9jb25uX3R5cGVfZmxhZ3Moc3RydWN0IHdwc19kYXRhICp3cHMsIHN0cnVjdCB3cGFidWYgKm1zZyk7CiBpbnQgd3BzX2J1aWxkX2Fzc29jX3N0YXRlKHN0cnVjdCB3cHNfZGF0YSAqd3BzLCBzdHJ1Y3Qgd3BhYnVmICptc2cpOworaW50IHdwc19idWlsZF9vb2JfZGV2X3B3KHN0cnVjdCB3cGFidWYgKm1zZywgdTE2IGRldl9wd19pZCwKKwkJCSBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpwdWJrZXksIGNvbnN0IHU4ICpkZXZfcHcsCisJCQkgc2l6ZV90IGRldl9wd19sZW4pOwogaW50IHdwc19idWlsZF9vb2JfZGV2X3Bhc3N3b3JkKHN0cnVjdCB3cGFidWYgKm1zZywgc3RydWN0IHdwc19jb250ZXh0ICp3cHMpOwogc3RydWN0IHdwYWJ1ZiAqIHdwc19pZV9lbmNhcHN1bGF0ZShzdHJ1Y3Qgd3BhYnVmICpkYXRhKTsKIApAQCAtMjg4LDkgKzIwMiw3IEBACiBjb25zdCB1OCAqIHdwc19hdXRob3JpemVkX21hY3Moc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywgc2l6ZV90ICpjb3VudCk7CiBpbnQgd3BzX3JlZ2lzdHJhcl9wYmNfb3ZlcmxhcChzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLAogCQkJICAgICAgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICp1dWlkX2UpOwotCi0vKiBuZGVmLmMgKi8KLXN0cnVjdCB3cGFidWYgKiBuZGVmX3BhcnNlX3dpZmkoc3RydWN0IHdwYWJ1ZiAqYnVmKTsKLXN0cnVjdCB3cGFidWYgKiBuZGVmX2J1aWxkX3dpZmkoc3RydWN0IHdwYWJ1ZiAqYnVmKTsKK3ZvaWQgd3BzX3JlZ2lzdHJhcl9yZW1vdmVfbmZjX3B3X3Rva2VuKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWcsCisJCQkJICAgICAgIHN0cnVjdCB3cHNfbmZjX3B3X3Rva2VuICp0b2tlbik7CiAKICNlbmRpZiAvKiBXUFNfSV9IICovCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc19uZmMuYyBiL3NyYy93cHMvd3BzX25mYy5jCmluZGV4IGZmMTIwMDAuLjY4MDQzNTAgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX25mYy5jCisrKyBiL3NyYy93cHMvd3BzX25mYy5jCkBAIC0xLDE1ICsxLDkgQEAKIC8qCiAgKiBORkMgcm91dGluZXMgZm9yIFdpLUZpIFByb3RlY3RlZCBTZXR1cAotICogQ29weXJpZ2h0IChjKSAyMDA5LCBNYXNhc2hpIEhvbm1hIDxob25tYUBpY3RlYy5jby5qcD4KKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEyLCBNYXNhc2hpIEhvbm1hIDxtYXNhc2hpLmhvbm1hQGdtYWlsLmNvbT4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaW5jbHVkZSAiaW5jbHVkZXMuaCIKZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX25mY19wbjUzMS5jIGIvc3JjL3dwcy93cHNfbmZjX3BuNTMxLmMKaW5kZXggN2UwNWU0ZC4uYzJiZjQ1NyAxMDA2NDQKLS0tIGEvc3JjL3dwcy93cHNfbmZjX3BuNTMxLmMKKysrIGIvc3JjL3dwcy93cHNfbmZjX3BuNTMxLmMKQEAgLTEsMTUgKzEsOSBAQAogLyoKICAqIE5GQyBQTjUzMSByb3V0aW5lcyBmb3IgV2ktRmkgUHJvdGVjdGVkIFNldHVwCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDksIE1hc2FzaGkgSG9ubWEgPGhvbm1hQGljdGVjLmNvLmpwPgorICogQ29weXJpZ2h0IChjKSAyMDA5LTIwMTIsIE1hc2FzaGkgSG9ubWEgPG1hc2FzaGkuaG9ubWFAZ21haWwuY29tPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfcmVnaXN0cmFyLmMgYi9zcmMvd3BzL3dwc19yZWdpc3RyYXIuYwppbmRleCA1ZWQ3ZWE0Li40NGJiMDA2IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc19yZWdpc3RyYXIuYworKysgYi9zcmMvd3BzL3dwc19yZWdpc3RyYXIuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAgLSBSZWdpc3RyYXIKLSAqIENvcHlyaWdodCAoYykgMjAwOC0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTI2LDYgKzI2LDUzIEBACiAjZGVmaW5lIFdQU19XT1JLQVJPVU5EUwogI2VuZGlmIC8qIENPTkZJR19XUFNfU1RSSUNUICovCiAKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCitzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiB7CisJc3RydWN0IGRsX2xpc3QgbGlzdDsKKwl1OCBwdWJrZXlfaGFzaFtXUFNfT09CX1BVQktFWV9IQVNIX0xFTl07CisJdTE2IHB3X2lkOworCXU4IGRldl9wd1tXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU5dOworCXNpemVfdCBkZXZfcHdfbGVuOworfTsKKworCitzdGF0aWMgdm9pZCB3cHNfcmVtb3ZlX25mY19wd190b2tlbihzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiAqdG9rZW4pCit7CisJZGxfbGlzdF9kZWwoJnRva2VuLT5saXN0KTsKKwlvc19mcmVlKHRva2VuKTsKK30KKworCitzdGF0aWMgdm9pZCB3cHNfZnJlZV9uZmNfcHdfdG9rZW5zKHN0cnVjdCBkbF9saXN0ICp0b2tlbnMsIHUxNiBwd19pZCkKK3sKKwlzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiAqdG9rZW4sICpwcmV2OworCWRsX2xpc3RfZm9yX2VhY2hfc2FmZSh0b2tlbiwgcHJldiwgdG9rZW5zLCBzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiwKKwkJCSAgICAgIGxpc3QpIHsKKwkJaWYgKHB3X2lkID09IDAgfHwgcHdfaWQgPT0gdG9rZW4tPnB3X2lkKQorCQkJd3BzX3JlbW92ZV9uZmNfcHdfdG9rZW4odG9rZW4pOworCX0KK30KKworCitzdGF0aWMgc3RydWN0IHdwc19uZmNfcHdfdG9rZW4gKiB3cHNfZ2V0X25mY19wd190b2tlbihzdHJ1Y3QgZGxfbGlzdCAqdG9rZW5zLAorCQkJCQkJICAgICAgdTE2IHB3X2lkKQoreworCXN0cnVjdCB3cHNfbmZjX3B3X3Rva2VuICp0b2tlbjsKKwlkbF9saXN0X2Zvcl9lYWNoKHRva2VuLCB0b2tlbnMsIHN0cnVjdCB3cHNfbmZjX3B3X3Rva2VuLCBsaXN0KSB7CisJCWlmIChwd19pZCA9PSB0b2tlbi0+cHdfaWQpCisJCQlyZXR1cm4gdG9rZW47CisJfQorCXJldHVybiBOVUxMOworfQorCisjZWxzZSAvKiBDT05GSUdfV1BTX05GQyAqLworCisjZGVmaW5lIHdwc19mcmVlX25mY19wd190b2tlbnModCwgcCkgZG8geyB9IHdoaWxlICgwKQorCisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKworCiBzdHJ1Y3Qgd3BzX3V1aWRfcGluIHsKIAlzdHJ1Y3QgZGxfbGlzdCBsaXN0OwogCXU4IHV1aWRbV1BTX1VVSURfTEVOXTsKQEAgLTEwMiw3ICsxNDksOCBAQAogCXZvaWQgKCpwaW5fbmVlZGVkX2NiKSh2b2lkICpjdHgsIGNvbnN0IHU4ICp1dWlkX2UsCiAJCQkgICAgICBjb25zdCBzdHJ1Y3Qgd3BzX2RldmljZV9kYXRhICpkZXYpOwogCXZvaWQgKCpyZWdfc3VjY2Vzc19jYikodm9pZCAqY3R4LCBjb25zdCB1OCAqbWFjX2FkZHIsCi0JCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSk7CisJCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSwgY29uc3QgdTggKmRldl9wdywKKwkJCSAgICAgICBzaXplX3QgZGV2X3B3X2xlbik7CiAJdm9pZCAoKnNldF9zZWxfcmVnX2NiKSh2b2lkICpjdHgsIGludCBzZWxfcmVnLCB1MTYgZGV2X3Bhc3N3ZF9pZCwKIAkJCSAgICAgICB1MTYgc2VsX3JlZ19jb25maWdfbWV0aG9kcyk7CiAJdm9pZCAoKmVucm9sbGVlX3NlZW5fY2IpKHZvaWQgKmN0eCwgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICp1dWlkX2UsCkBAIC0xMTIsNiArMTYwLDcgQEAKIAl2b2lkICpjYl9jdHg7CiAKIAlzdHJ1Y3QgZGxfbGlzdCBwaW5zOworCXN0cnVjdCBkbF9saXN0IG5mY19wd190b2tlbnM7CiAJc3RydWN0IHdwc19wYmNfc2Vzc2lvbiAqcGJjX3Nlc3Npb25zOwogCiAJaW50IHNraXBfY3JlZF9idWlsZDsKQEAgLTQ4NCwxMiArNTMzLDE2IEBACiB7CiAJKm1ldGhvZHMgfD0gV1BTX0NPTkZJR19QVVNIQlVUVE9OOwogI2lmZGVmIENPTkZJR19XUFMyCi0JaWYgKGNvbmZfbWV0aG9kcyAmIFdQU19DT05GSUdfVklSVF9QVVNIQlVUVE9OKQorCWlmICgoY29uZl9tZXRob2RzICYgV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT04pID09CisJICAgIFdQU19DT05GSUdfVklSVF9QVVNIQlVUVE9OKQogCQkqbWV0aG9kcyB8PSBXUFNfQ09ORklHX1ZJUlRfUFVTSEJVVFRPTjsKLQlpZiAoY29uZl9tZXRob2RzICYgV1BTX0NPTkZJR19QSFlfUFVTSEJVVFRPTikKKwlpZiAoKGNvbmZfbWV0aG9kcyAmIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04pID09CisJICAgIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04pCiAJCSptZXRob2RzIHw9IFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT047Ci0JaWYgKCEoKm1ldGhvZHMgJiAoV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT04gfAotCQkJICBXUFNfQ09ORklHX1BIWV9QVVNIQlVUVE9OKSkpIHsKKwlpZiAoKCptZXRob2RzICYgV1BTX0NPTkZJR19WSVJUX1BVU0hCVVRUT04pICE9CisJICAgIFdQU19DT05GSUdfVklSVF9QVVNIQlVUVE9OICYmCisJICAgICgqbWV0aG9kcyAmIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04pICE9CisJICAgIFdQU19DT05GSUdfUEhZX1BVU0hCVVRUT04pIHsKIAkJLyoKIAkJICogUmVxdWlyZWQgdG8gaW5jbHVkZSB2aXJ0dWFsL3BoeXNpY2FsIGZsYWcsIGJ1dCB3ZSB3ZXJlIG5vdAogCQkgKiBjb25maWd1cmVkIHdpdGggcHVzaCBidXR0b24gdHlwZSwgc28gaGF2ZSB0byBkZWZhdWx0IHRvIG9uZQpAQCAtNTkxLDYgKzY0NCw3IEBACiAJCXJldHVybiBOVUxMOwogCiAJZGxfbGlzdF9pbml0KCZyZWctPnBpbnMpOworCWRsX2xpc3RfaW5pdCgmcmVnLT5uZmNfcHdfdG9rZW5zKTsKIAlyZWctPndwcyA9IHdwczsKIAlyZWctPm5ld19wc2tfY2IgPSBjZmctPm5ld19wc2tfY2I7CiAJcmVnLT5zZXRfaWVfY2IgPSBjZmctPnNldF9pZV9jYjsKQEAgLTYzNCw2ICs2ODgsNyBAQAogCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwc19yZWdpc3RyYXJfcGJjX3RpbWVvdXQsIHJlZywgTlVMTCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3BzX3JlZ2lzdHJhcl9zZXRfc2VsZWN0ZWRfdGltZW91dCwgcmVnLCBOVUxMKTsKIAl3cHNfZnJlZV9waW5zKCZyZWctPnBpbnMpOworCXdwc19mcmVlX25mY19wd190b2tlbnMoJnJlZy0+bmZjX3B3X3Rva2VucywgMCk7CiAJd3BzX2ZyZWVfcGJjX3Nlc3Npb25zKHJlZy0+cGJjX3Nlc3Npb25zKTsKIAl3cGFidWZfZnJlZShyZWctPmV4dHJhX2NyZWQpOwogCXdwc19mcmVlX2RldmljZXMocmVnLT5kZXZpY2VzKTsKQEAgLTc0MCwxNCArNzk1LDIyIEBACiAvKioKICAqIHdwc19yZWdpc3RyYXJfaW52YWxpZGF0ZV93aWxkY2FyZF9waW4gLSBJbnZhbGlkYXRlIGEgd2lsZGNhcmQgUElOCiAgKiBAcmVnOiBSZWdpc3RyYXIgZGF0YSBmcm9tIHdwc19yZWdpc3RyYXJfaW5pdCgpCisgKiBAZGV2X3B3OiBQSU4gdG8gc2VhcmNoIGZvciBvciAlTlVMTCB0byBtYXRjaCBhbnkKKyAqIEBkZXZfcHdfbGVuOiBMZW5ndGggb2YgZGV2X3B3IGluIG9jdGV0cwogICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtMSBpZiBub3Qgd2lsZGNhcmQgUElOIGlzIGVuYWJsZWQKICAqLwotc3RhdGljIGludCB3cHNfcmVnaXN0cmFyX2ludmFsaWRhdGVfd2lsZGNhcmRfcGluKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWcpCitzdGF0aWMgaW50IHdwc19yZWdpc3RyYXJfaW52YWxpZGF0ZV93aWxkY2FyZF9waW4oc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZywKKwkJCQkJCSBjb25zdCB1OCAqZGV2X3B3LAorCQkJCQkJIHNpemVfdCBkZXZfcHdfbGVuKQogewogCXN0cnVjdCB3cHNfdXVpZF9waW4gKnBpbiwgKnByZXY7CiAKIAlkbF9saXN0X2Zvcl9lYWNoX3NhZmUocGluLCBwcmV2LCAmcmVnLT5waW5zLCBzdHJ1Y3Qgd3BzX3V1aWRfcGluLCBsaXN0KQogCXsKKwkJaWYgKGRldl9wdyAmJiBwaW4tPnBpbiAmJgorCQkgICAgKGRldl9wd19sZW4gIT0gcGluLT5waW5fbGVuIHx8CisJCSAgICAgb3NfbWVtY21wKGRldl9wdywgcGluLT5waW4sIGRldl9wd19sZW4pICE9IDApKQorCQkJY29udGludWU7IC8qIGRpZmZlcmVudCBQSU4gKi8KIAkJaWYgKHBpbi0+d2lsZGNhcmRfdXVpZCkgewogCQkJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiV1BTOiBJbnZhbGlkYXRlZCBQSU4gZm9yIFVVSUQiLAogCQkJCSAgICBwaW4tPnV1aWQsIFdQU19VVUlEX0xFTik7CkBAIC05NDUsNyArMTAwOCw4IEBACiB9CiAKIAotdm9pZCB3cHNfcmVnaXN0cmFyX2NvbXBsZXRlKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWdpc3RyYXIsIGNvbnN0IHU4ICp1dWlkX2UpCit2b2lkIHdwc19yZWdpc3RyYXJfY29tcGxldGUoc3RydWN0IHdwc19yZWdpc3RyYXIgKnJlZ2lzdHJhciwgY29uc3QgdTggKnV1aWRfZSwKKwkJCSAgICBjb25zdCB1OCAqZGV2X3B3LCBzaXplX3QgZGV2X3B3X2xlbikKIHsKIAlpZiAocmVnaXN0cmFyLT5wYmMpIHsKIAkJd3BzX3JlZ2lzdHJhcl9yZW1vdmVfcGJjX3Nlc3Npb24ocmVnaXN0cmFyLApAQCAtOTU0LDYgKzEwMTgsMTMgQEAKIAl9IGVsc2UgewogCQl3cHNfcmVnaXN0cmFyX3Bpbl9jb21wbGV0ZWQocmVnaXN0cmFyKTsKIAl9CisKKwlpZiAoZGV2X3B3ICYmCisJICAgIHdwc19yZWdpc3RyYXJfaW52YWxpZGF0ZV93aWxkY2FyZF9waW4ocmVnaXN0cmFyLCBkZXZfcHcsCisJCQkJCQkgIGRldl9wd19sZW4pID09IDApIHsKKwkJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIldQUzogSW52YWxpZGF0ZWQgd2lsZGNhcmQgUElOIiwKKwkJCQlkZXZfcHcsIGRldl9wd19sZW4pOworCX0KIH0KIAogCkBAIC05NjgsNyArMTAzOSw3IEBACiAJCS8qIFBJTiBNZXRob2QgKi8KIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFBJTiBpcyBzZXQgLSBjYW5jZWxsaW5nIGl0Iik7CiAJCXdwc19yZWdpc3RyYXJfcGluX2NvbXBsZXRlZChyZWcpOwotCQl3cHNfcmVnaXN0cmFyX2ludmFsaWRhdGVfd2lsZGNhcmRfcGluKHJlZyk7CisJCXdwc19yZWdpc3RyYXJfaW52YWxpZGF0ZV93aWxkY2FyZF9waW4ocmVnLCBOVUxMLCAwKTsKIAkJcmV0dXJuIDE7CiAJfQogCXJldHVybiAwOwpAQCAtMTA3MSwxMiArMTE0MiwxMyBAQAogCiAKIHN0YXRpYyB2b2lkIHdwc19jYl9yZWdfc3VjY2VzcyhzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLCBjb25zdCB1OCAqbWFjX2FkZHIsCi0JCQkgICAgICAgY29uc3QgdTggKnV1aWRfZSkKKwkJCSAgICAgICBjb25zdCB1OCAqdXVpZF9lLCBjb25zdCB1OCAqZGV2X3B3LAorCQkJICAgICAgIHNpemVfdCBkZXZfcHdfbGVuKQogewogCWlmIChyZWctPnJlZ19zdWNjZXNzX2NiID09IE5VTEwpCiAJCXJldHVybjsKIAotCXJlZy0+cmVnX3N1Y2Nlc3NfY2IocmVnLT5jYl9jdHgsIG1hY19hZGRyLCB1dWlkX2UpOworCXJlZy0+cmVnX3N1Y2Nlc3NfY2IocmVnLT5jYl9jdHgsIG1hY19hZGRyLCB1dWlkX2UsIGRldl9wdywgZGV2X3B3X2xlbik7CiB9CiAKIApAQCAtMTIzOCw2ICsxMzEwLDEzIEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVc2UgZGVmYXVsdCBQSU4gZm9yIFBCQyIpOwogCQlwaW4gPSAoY29uc3QgdTggKikgIjAwMDAwMDAwIjsKIAkJcGluX2xlbiA9IDg7CisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwl9IGVsc2UgaWYgKHdwcy0+bmZjX3B3X3Rva2VuKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBVc2UgT09CIERldmljZSBQYXNzd29yZCBmcm9tIE5GQyAiCisJCQkgICAiUGFzc3dvcmQgVG9rZW4iKTsKKwkJcGluID0gd3BzLT5uZmNfcHdfdG9rZW4tPmRldl9wdzsKKwkJcGluX2xlbiA9IHdwcy0+bmZjX3B3X3Rva2VuLT5kZXZfcHdfbGVuOworI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCiAJfSBlbHNlIHsKIAkJcGluID0gd3BzX3JlZ2lzdHJhcl9nZXRfcGluKHdwcy0+d3BzLT5yZWdpc3RyYXIsIHdwcy0+dXVpZF9lLAogCQkJCQkgICAgJnBpbl9sZW4pOwpAQCAtMjQyNCw4ICsyNTAzLDM0IEBACiAJCXJldHVybiBXUFNfQ09OVElOVUU7CiAJfQogCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwlpZiAod3BzLT5kZXZfcHdfaWQgPj0gMHgxMCkgeworCQlzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiAqdG9rZW47CisJCWNvbnN0IHU4ICphZGRyWzFdOworCQl1OCBoYXNoW1dQU19IQVNIX0xFTl07CisKKwkJdG9rZW4gPSB3cHNfZ2V0X25mY19wd190b2tlbigKKwkJCSZ3cHMtPndwcy0+cmVnaXN0cmFyLT5uZmNfcHdfdG9rZW5zLCB3cHMtPmRldl9wd19pZCk7CisJCWlmICh0b2tlbikgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IEZvdW5kIG1hdGNoaW5nIE5GQyAiCisJCQkJICAgIlBhc3N3b3JkIFRva2VuIik7CisJCQlkbF9saXN0X2RlbCgmdG9rZW4tPmxpc3QpOworCQkJd3BzLT5uZmNfcHdfdG9rZW4gPSB0b2tlbjsKKworCQkJYWRkclswXSA9IGF0dHItPnB1YmxpY19rZXk7CisJCQlzaGEyNTZfdmVjdG9yKDEsIGFkZHIsICZhdHRyLT5wdWJsaWNfa2V5X2xlbiwgaGFzaCk7CisJCQlpZiAob3NfbWVtY21wKGhhc2gsIHdwcy0+bmZjX3B3X3Rva2VuLT5wdWJrZXlfaGFzaCwKKwkJCQkgICAgICBXUFNfT09CX1BVQktFWV9IQVNIX0xFTikgIT0gMCkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiV1BTOiBQdWJsaWMgS2V5IGhhc2ggIgorCQkJCQkgICAibWlzbWF0Y2giKTsKKwkJCQlyZXR1cm4gV1BTX0ZBSUxVUkU7CisJCQl9CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKwogI2lmZGVmIENPTkZJR19XUFNfT09CCi0JaWYgKHdwcy0+ZGV2X3B3X2lkID49IDB4MTAgJiYKKwlpZiAod3BzLT5kZXZfcHdfaWQgPj0gMHgxMCAmJiB3cHMtPm5mY19wd190b2tlbiA9PSBOVUxMICYmCiAJICAgIHdwcy0+ZGV2X3B3X2lkICE9IHdwcy0+d3BzLT5vb2JfZGV2X3B3X2lkKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBPT0IgRGV2aWNlIFBhc3N3b3JkIElEICIKIAkJCSAgICIlZCBtaXNtYXRjaCIsIHdwcy0+ZGV2X3B3X2lkKTsKQEAgLTMwNTUsNyArMzE2MCw4IEBACiAJCXdwcy0+bmV3X3BzayA9IE5VTEw7CiAJfQogCi0Jd3BzX2NiX3JlZ19zdWNjZXNzKHdwcy0+d3BzLT5yZWdpc3RyYXIsIHdwcy0+bWFjX2FkZHJfZSwgd3BzLT51dWlkX2UpOworCXdwc19jYl9yZWdfc3VjY2Vzcyh3cHMtPndwcy0+cmVnaXN0cmFyLCB3cHMtPm1hY19hZGRyX2UsIHdwcy0+dXVpZF9lLAorCQkJICAgd3BzLT5kZXZfcGFzc3dvcmQsIHdwcy0+ZGV2X3Bhc3N3b3JkX2xlbik7CiAKIAlpZiAod3BzLT5wYmMpIHsKIAkJd3BzX3JlZ2lzdHJhcl9yZW1vdmVfcGJjX3Nlc3Npb24od3BzLT53cHMtPnJlZ2lzdHJhciwKQEAgLTMzNDgsMyArMzQ1NCw4NCBAQAogCiAJcmV0dXJuIC0xOwogfQorCisKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCitpbnQgd3BzX3JlZ2lzdHJhcl9hZGRfbmZjX3B3X3Rva2VuKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWcsCisJCQkJICAgY29uc3QgdTggKnB1YmtleV9oYXNoLCB1MTYgcHdfaWQsCisJCQkJICAgY29uc3QgdTggKmRldl9wdywgc2l6ZV90IGRldl9wd19sZW4pCit7CisJc3RydWN0IHdwc19uZmNfcHdfdG9rZW4gKnRva2VuOworCisJaWYgKGRldl9wd19sZW4gPiBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9MRU4pCisJCXJldHVybiAtMTsKKworCXdwc19mcmVlX25mY19wd190b2tlbnMoJnJlZy0+bmZjX3B3X3Rva2VucywgcHdfaWQpOworCisJdG9rZW4gPSBvc196YWxsb2Moc2l6ZW9mKCp0b2tlbikpOworCWlmICh0b2tlbiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlvc19tZW1jcHkodG9rZW4tPnB1YmtleV9oYXNoLCBwdWJrZXlfaGFzaCwgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4pOworCXRva2VuLT5wd19pZCA9IHB3X2lkOworCW9zX21lbWNweSh0b2tlbi0+ZGV2X3B3LCBkZXZfcHcsIGRldl9wd19sZW4pOworCXRva2VuLT5kZXZfcHdfbGVuID0gZGV2X3B3X2xlbjsKKworCWRsX2xpc3RfYWRkKCZyZWctPm5mY19wd190b2tlbnMsICZ0b2tlbi0+bGlzdCk7CisKKwlyZWctPnNlbGVjdGVkX3JlZ2lzdHJhciA9IDE7CisJcmVnLT5wYmMgPSAwOworCXdwc19yZWdpc3RyYXJfYWRkX2F1dGhvcml6ZWRfbWFjKHJlZywKKwkJCQkJICh1OCAqKSAiXHhmZlx4ZmZceGZmXHhmZlx4ZmZceGZmIik7CisJd3BzX3JlZ2lzdHJhcl9zZWxlY3RlZF9yZWdpc3RyYXJfY2hhbmdlZChyZWcpOworCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwc19yZWdpc3RyYXJfc2V0X3NlbGVjdGVkX3RpbWVvdXQsIHJlZywgTlVMTCk7CisJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChXUFNfUEJDX1dBTEtfVElNRSwgMCwKKwkJCSAgICAgICB3cHNfcmVnaXN0cmFyX3NldF9zZWxlY3RlZF90aW1lb3V0LAorCQkJICAgICAgIHJlZywgTlVMTCk7CisKKwlyZXR1cm4gMDsKK30KKworCitpbnQgd3BzX3JlZ2lzdHJhcl9hZGRfbmZjX3Bhc3N3b3JkX3Rva2VuKHN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWcsCisJCQkJCSBjb25zdCB1OCAqb29iX2Rldl9wdywKKwkJCQkJIHNpemVfdCBvb2JfZGV2X3B3X2xlbikKK3sKKwljb25zdCB1OCAqcG9zLCAqaGFzaCwgKmRldl9wdzsKKwl1MTYgaWQ7CisJc2l6ZV90IGRldl9wd19sZW47CisKKwlpZiAob29iX2Rldl9wd19sZW4gPCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTiArIDIgKworCSAgICBXUFNfT09CX0RFVklDRV9QQVNTV09SRF9NSU5fTEVOIHx8CisJICAgIG9vYl9kZXZfcHdfbGVuID4gV1BTX09PQl9QVUJLRVlfSEFTSF9MRU4gKyAyICsKKwkgICAgV1BTX09PQl9ERVZJQ0VfUEFTU1dPUkRfTEVOKQorCQlyZXR1cm4gLTE7CisKKwloYXNoID0gb29iX2Rldl9wdzsKKwlwb3MgPSBvb2JfZGV2X3B3ICsgV1BTX09PQl9QVUJLRVlfSEFTSF9MRU47CisJaWQgPSBXUEFfR0VUX0JFMTYocG9zKTsKKwlkZXZfcHcgPSBwb3MgKyAyOworCWRldl9wd19sZW4gPSBvb2JfZGV2X3B3ICsgb29iX2Rldl9wd19sZW4gLSBkZXZfcHc7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQWRkIE5GQyBQYXNzd29yZCBUb2tlbiBmb3IgUGFzc3dvcmQgSUQgJXUiLAorCQkgICBpZCk7CisKKwl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJXUFM6IFB1YmxpYyBLZXkgSGFzaCIsCisJCSAgICBoYXNoLCBXUFNfT09CX1BVQktFWV9IQVNIX0xFTik7CisJd3BhX2hleGR1bXBfa2V5KE1TR19ERUJVRywgIldQUzogRGV2aWNlIFBhc3N3b3JkIiwgZGV2X3B3LCBkZXZfcHdfbGVuKTsKKworCXJldHVybiB3cHNfcmVnaXN0cmFyX2FkZF9uZmNfcHdfdG9rZW4ocmVnLCBoYXNoLCBpZCwgZGV2X3B3LAorCQkJCQkgICAgICBkZXZfcHdfbGVuKTsKK30KKworCit2b2lkIHdwc19yZWdpc3RyYXJfcmVtb3ZlX25mY19wd190b2tlbihzdHJ1Y3Qgd3BzX3JlZ2lzdHJhciAqcmVnLAorCQkJCSAgICAgICBzdHJ1Y3Qgd3BzX25mY19wd190b2tlbiAqdG9rZW4pCit7CisJd3BzX3JlZ2lzdHJhcl9yZW1vdmVfYXV0aG9yaXplZF9tYWMocmVnLAorCQkJCQkgICAgKHU4ICopICJceGZmXHhmZlx4ZmZceGZmXHhmZlx4ZmYiKTsKKwl3cHNfcmVnaXN0cmFyX3NlbGVjdGVkX3JlZ2lzdHJhcl9jaGFuZ2VkKHJlZyk7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwpkaWZmIC0tZ2l0IGEvc3JjL3dwcy93cHNfdWZkLmMgYi9zcmMvd3BzL3dwc191ZmQuYwppbmRleCA2MWY2NTUzLi5mODNiZGY0IDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc191ZmQuYworKysgYi9zcmMvd3BzL3dwc191ZmQuYwpAQCAtMSwxNSArMSw5IEBACiAvKgogICogVUZEIHJvdXRpbmVzIGZvciBXaS1GaSBQcm90ZWN0ZWQgU2V0dXAKLSAqIENvcHlyaWdodCAoYykgMjAwOSwgTWFzYXNoaSBIb25tYSA8aG9ubWFAaWN0ZWMuY28uanA+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDktMjAxMiwgTWFzYXNoaSBIb25tYSA8bWFzYXNoaS5ob25tYUBnbWFpbC5jb20+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC0xNjUsOCArMTU5LDEwIEBACiAJfQogCiAJZGF0YSA9IG9zX3phbGxvYyhzaXplb2YoKmRhdGEpKTsKLQlpZiAoZGF0YSA9PSBOVUxMKQorCWlmIChkYXRhID09IE5VTEwpIHsKKwkJY2xvc2UodWZkX2ZkKTsKIAkJcmV0dXJuIE5VTEw7CisJfQogCWRhdGEtPnVmZF9mZCA9IHVmZF9mZDsKIAlyZXR1cm4gZGF0YTsKIH0KZGlmZiAtLWdpdCBhL3NyYy93cHMvd3BzX3VwbnAuYyBiL3NyYy93cHMvd3BzX3VwbnAuYwppbmRleCA3NjZjYWM0Li4wOWE0NmEyIDEwMDY0NAotLS0gYS9zcmMvd3BzL3dwc191cG5wLmMKKysrIGIvc3JjL3dwcy93cHNfdXBucC5jCkBAIC0zMDUsMTUgKzMwNSwxNSBAQAogCWludCBhbGxvY19sZW47CiAJY2hhciAqc2NyYXRjaF9tZW0gPSBOVUxMOwogCWNoYXIgKm1lbTsKLQljaGFyICpkb21haW5fYW5kX3BvcnQ7CisJY2hhciAqaG9zdDsKIAljaGFyICpkZWxpbTsKIAljaGFyICpwYXRoOwotCWNoYXIgKmRvbWFpbjsKIAlpbnQgcG9ydCA9IDgwOyAgLyogcG9ydCB0byBzZW5kIHRvIChkZWZhdWx0IGlzIHBvcnQgODApICovCiAJc3RydWN0IGFkZHJpbmZvIGhpbnRzOwogCXN0cnVjdCBhZGRyaW5mbyAqcmVzdWx0ID0gTlVMTDsKIAlzdHJ1Y3QgYWRkcmluZm8gKnJwOwogCWludCByZXJyOworCXNpemVfdCBob3N0X2xlbiwgcGF0aF9sZW47CiAKIAkvKiB1cmwgTVVTVCBiZWdpbiB3aXRoIGh0dHA6ICovCiAJaWYgKHVybF9sZW4gPCA3IHx8IG9zX3N0cm5jYXNlY21wKHVybCwgImh0dHA6Ly8iLCA3KSkKQEAgLTMyMSwzMCArMzIxLDI0IEBACiAJdXJsICs9IDc7CiAJdXJsX2xlbiAtPSA3OwogCi0JLyogYWxsb2NhdGUgbWVtb3J5IGZvciB0aGUgZXh0cmEgc3R1ZmYgd2UgbmVlZCAqLwotCWFsbG9jX2xlbiA9IDIgKiAodXJsX2xlbiArIDEpOwotCXNjcmF0Y2hfbWVtID0gb3NfemFsbG9jKGFsbG9jX2xlbik7CisJLyogTWFrZSBhIGNvcHkgb2YgdGhlIHN0cmluZyB0byBhbGxvdyBtb2RpZmljYXRpb24gZHVyaW5nIHBhcnNpbmcgKi8KKwlzY3JhdGNoX21lbSA9IG9zX21hbGxvYyh1cmxfbGVuICsgMSk7CiAJaWYgKHNjcmF0Y2hfbWVtID09IE5VTEwpCiAJCWdvdG8gZmFpbDsKLQltZW0gPSBzY3JhdGNoX21lbTsKLQlvc19zdHJuY3B5KG1lbSwgdXJsLCB1cmxfbGVuKTsKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUyBVUG5QOiBBZGRpbmcgVVJMICclcyciLCBtZW0pOwotCWRvbWFpbl9hbmRfcG9ydCA9IG1lbTsKLQltZW0gKz0gMSArIG9zX3N0cmxlbihtZW0pOwotCWRlbGltID0gb3Nfc3RyY2hyKGRvbWFpbl9hbmRfcG9ydCwgJy8nKTsKKwlvc19tZW1jcHkoc2NyYXRjaF9tZW0sIHVybCwgdXJsX2xlbik7CisJc2NyYXRjaF9tZW1bdXJsX2xlbl0gPSAnXDAnOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTIFVQblA6IEFkZGluZyBVUkwgJyVzJyIsIHNjcmF0Y2hfbWVtKTsKKwlob3N0ID0gc2NyYXRjaF9tZW07CisJcGF0aCA9IG9zX3N0cmNocihob3N0LCAnLycpOworCWlmIChwYXRoKQorCQkqcGF0aCsrID0gJ1wwJzsgLyogbnVsbCB0ZXJtaW5hdGUgaG9zdCAqLworCisJLyogUHJvY2VzcyBhbmQgcmVtb3ZlIG9wdGlvbmFsIHBvcnQgY29tcG9uZW50ICovCisJZGVsaW0gPSBvc19zdHJjaHIoaG9zdCwgJzonKTsKIAlpZiAoZGVsaW0pIHsKLQkJKmRlbGltKysgPSAwOyAgIC8qIG51bGwgdGVybWluYXRlIGRvbWFpbiBhbmQgcG9ydCAqLwotCQlwYXRoID0gZGVsaW07Ci0JfSBlbHNlIHsKLQkJcGF0aCA9IGRvbWFpbl9hbmRfcG9ydCArIG9zX3N0cmxlbihkb21haW5fYW5kX3BvcnQpOwotCX0KLQlkb21haW4gPSBtZW07Ci0Jc3RyY3B5KGRvbWFpbiwgZG9tYWluX2FuZF9wb3J0KTsKLQlkZWxpbSA9IG9zX3N0cmNocihkb21haW4sICc6Jyk7Ci0JaWYgKGRlbGltKSB7Ci0JCSpkZWxpbSsrID0gMDsgICAvKiBudWxsIHRlcm1pbmF0ZSBkb21haW4gKi8KLQkJaWYgKGlzZGlnaXQoKmRlbGltKSkKLQkJCXBvcnQgPSBhdG9sKGRlbGltKTsKKwkJKmRlbGltID0gJ1wwJzsgLyogbnVsbCB0ZXJtaW5hdGUgaG9zdCBuYW1lIGZvciBub3cgKi8KKwkJaWYgKGlzZGlnaXQoZGVsaW1bMV0pKQorCQkJcG9ydCA9IGF0b2woZGVsaW0gKyAxKTsKIAl9CiAKIAkvKgpAQCAtMzY3LDEzICszNjEsMjEgQEAKIAloaW50cy5haV9mbGFncyA9IDA7CiAjZW5kaWYKIAloaW50cy5haV9wcm90b2NvbCA9IDA7ICAgICAgICAgIC8qIEFueSBwcm90b2NvbD8gKi8KLQlyZXJyID0gZ2V0YWRkcmluZm8oZG9tYWluLCBOVUxMIC8qIGZpbGwgaW4gcG9ydCBvdXJzZWx2ZXMgKi8sCisJcmVyciA9IGdldGFkZHJpbmZvKGhvc3QsIE5VTEwgLyogZmlsbCBpbiBwb3J0IG91cnNlbHZlcyAqLywKIAkJCSAgICZoaW50cywgJnJlc3VsdCk7CiAJaWYgKHJlcnIpIHsKIAkJd3BhX3ByaW50ZihNU0dfSU5GTywgIldQUyBVUG5QOiBSZXNvbHZlIGVycm9yICVkICglcykgb246ICVzIiwKLQkJCSAgIHJlcnIsIGdhaV9zdHJlcnJvcihyZXJyKSwgZG9tYWluKTsKKwkJCSAgIHJlcnIsIGdhaV9zdHJlcnJvcihyZXJyKSwgaG9zdCk7CiAJCWdvdG8gZmFpbDsKIAl9CisKKwlpZiAoZGVsaW0pCisJCSpkZWxpbSA9ICc6JzsgLyogUmVzdG9yZSBwb3J0ICovCisKKwlob3N0X2xlbiA9IG9zX3N0cmxlbihob3N0KTsKKwlwYXRoX2xlbiA9IHBhdGggPyBvc19zdHJsZW4ocGF0aCkgOiAwOworCWFsbG9jX2xlbiA9IGhvc3RfbGVuICsgMSArIDEgKyBwYXRoX2xlbiArIDE7CisKIAlmb3IgKHJwID0gcmVzdWx0OyBycDsgcnAgPSBycC0+YWlfbmV4dCkgewogCQlzdHJ1Y3Qgc3Vic2NyX2FkZHIgKmE7CiAKQEAgLTM4NiwxNiArMzg4LDE2IEBACiAKIAkJYSA9IG9zX3phbGxvYyhzaXplb2YoKmEpICsgYWxsb2NfbGVuKTsKIAkJaWYgKGEgPT0gTlVMTCkKLQkJCWNvbnRpbnVlOwotCQltZW0gPSAodm9pZCAqKSAoYSArIDEpOworCQkJYnJlYWs7CisJCW1lbSA9IChjaGFyICopIChhICsgMSk7CiAJCWEtPmRvbWFpbl9hbmRfcG9ydCA9IG1lbTsKLQkJc3RyY3B5KG1lbSwgZG9tYWluX2FuZF9wb3J0KTsKLQkJbWVtICs9IDEgKyBzdHJsZW4obWVtKTsKKwkJb3NfbWVtY3B5KG1lbSwgaG9zdCwgaG9zdF9sZW4pOworCQltZW0gKz0gaG9zdF9sZW4gKyAxOwogCQlhLT5wYXRoID0gbWVtOwotCQlpZiAocGF0aFswXSAhPSAnLycpCisJCWlmIChwYXRoID09IE5VTEwgfHwgcGF0aFswXSAhPSAnLycpCiAJCQkqbWVtKysgPSAnLyc7Ci0JCXN0cmNweShtZW0sIHBhdGgpOwotCQltZW0gKz0gMSArIG9zX3N0cmxlbihtZW0pOworCQlpZiAocGF0aCkKKwkJCW9zX21lbWNweShtZW0sIHBhdGgsIHBhdGhfbGVuKTsKIAkJb3NfbWVtY3B5KCZhLT5zYWRkciwgcnAtPmFpX2FkZHIsIHNpemVvZihhLT5zYWRkcikpOwogCQlhLT5zYWRkci5zaW5fcG9ydCA9IGh0b25zKHBvcnQpOwogCmRpZmYgLS1naXQgYS9zcmMvd3BzL3dwc191cG5wX3NzZHAuYyBiL3NyYy93cHMvd3BzX3VwbnBfc3NkcC5jCmluZGV4IDRjNGFlYmYuLjE3YTgyMDcgMTAwNjQ0Ci0tLSBhL3NyYy93cHMvd3BzX3VwbnBfc3NkcC5jCisrKyBiL3NyYy93cHMvd3BzX3VwbnBfc3NkcC5jCkBAIC04NjYsMjAgKzg2NiwyNCBAQAogCQlyZXR1cm4gLTE7CiAKICNpZiAwICAgLyogbWF5YmUgb2sgaWYgd2Ugc29tZXRpbWVzIGJsb2NrIG9uIHdyaXRlcyAqLwotCWlmIChmY250bChzZCwgRl9TRVRGTCwgT19OT05CTE9DSykgIT0gMCkKKwlpZiAoZmNudGwoc2QsIEZfU0VURkwsIE9fTk9OQkxPQ0spICE9IDApIHsKKwkJY2xvc2Uoc2QpOwogCQlyZXR1cm4gLTE7CisJfQogI2VuZGlmCiAKIAlpZiAoc2V0c29ja29wdChzZCwgSVBQUk9UT19JUCwgSVBfTVVMVElDQVNUX0lGLAogCQkgICAgICAgJmlwX2FkZHIsIHNpemVvZihpcF9hZGRyKSkpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IHNldHNvY2tvcHQoSVBfTVVMVElDQVNUX0lGKSAleDogIgogCQkJICAgIiVkICglcykiLCBpcF9hZGRyLCBlcnJubywgc3RyZXJyb3IoZXJybm8pKTsKKwkJY2xvc2Uoc2QpOwogCQlyZXR1cm4gLTE7CiAJfQogCWlmIChzZXRzb2Nrb3B0KHNkLCBJUFBST1RPX0lQLCBJUF9NVUxUSUNBU1RfVFRMLAogCQkgICAgICAgJnR0bCwgc2l6ZW9mKHR0bCkpKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBzZXRzb2Nrb3B0KElQX01VTFRJQ0FTVF9UVEwpOiAiCiAJCQkgICAiJWQgKCVzKSIsIGVycm5vLCBzdHJlcnJvcihlcnJubykpOworCQljbG9zZShzZCk7CiAJCXJldHVybiAtMTsKIAl9CiAKQEAgLTg5OCw2ICs5MDIsNyBAQAogCQkJCSAgICJXUFMgVVBuUDogc2V0c29ja29wdCAiCiAJCQkJICAgIklQX0FERF9NRU1CRVJTSElQIGVycm5vICVkICglcykiLAogCQkJCSAgIGVycm5vLCBzdHJlcnJvcihlcnJubykpOworCQkJY2xvc2Uoc2QpOwogCQkJcmV0dXJuIC0xOwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvQW5kcm9pZC5tayBiL3dwYV9zdXBwbGljYW50L0FuZHJvaWQubWsKaW5kZXggYzZjZjgwYi4uMjMxY2Q1NyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvQW5kcm9pZC5taworKysgYi93cGFfc3VwcGxpY2FudC9BbmRyb2lkLm1rCkBAIC0xMzEwLDYgKzEzMTAsMjMgQEAKIE9CSlMgKz0gYmdzY2FuLmMKIGVuZGlmCiAKK2lmZGVmIENPTkZJR19BVVRPU0NBTl9FWFBPTkVOVElBTAorTF9DRkxBR1MgKz0gLURDT05GSUdfQVVUT1NDQU5fRVhQT05FTlRJQUwKK09CSlMgKz0gYXV0b3NjYW5fZXhwb25lbnRpYWwuYworTkVFRF9BVVRPU0NBTj15CitlbmRpZgorCitpZmRlZiBDT05GSUdfQVVUT1NDQU5fUEVSSU9ESUMKK0NGTEFHUyArPSAtRENPTkZJR19BVVRPU0NBTl9QRVJJT0RJQworT0JKUyArPSBhdXRvc2Nhbl9wZXJpb2RpYy5jCitORUVEX0FVVE9TQ0FOPXkKK2VuZGlmCisKK2lmZGVmIE5FRURfQVVUT1NDQU4KK0xfQ0ZMQUdTICs9IC1EQ09ORklHX0FVVE9TQ0FOCitPQkpTICs9IGF1dG9zY2FuLmMKK2VuZGlmCisKIGlmZGVmIE5FRURfR0FTCiBPQkpTICs9IC4uL3NyYy9jb21tb24vZ2FzLmMKIE9CSlMgKz0gZ2FzX3F1ZXJ5LmMKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L0NoYW5nZUxvZyBiL3dwYV9zdXBwbGljYW50L0NoYW5nZUxvZwppbmRleCAwNjExOWM2Li42NTBiOGEwIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9DaGFuZ2VMb2cKKysrIGIvd3BhX3N1cHBsaWNhbnQvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTc5IEBACiBDaGFuZ2VMb2cgZm9yIHdwYV9zdXBwbGljYW50CiAKKzIwMTItMDUtMTAgLSB2MS4wCisJKiBic2Q6IEFkZCBzdXBwb3J0IGZvciBzZXR0aW5nIEhUIHZhbHVlcyBpbiBJRk1fTU1BU0suCisJKiBEZWxheSBTVEEgZW50cnkgcmVtb3ZhbCB1bnRpbCBEZWF1dGgvRGlzYXNzb2MgVFggc3RhdHVzIGluIEFQIG1vZGUuCisJICBUaGlzIGFsbG93cyB0aGUgZHJpdmVyIHRvIHVzZSBQUyBidWZmZXJpbmcgb2YgRGVhdXRoZW50aWNhdGlvbiBhbmQKKwkgIERpc2Fzc29jaWF0aW9uIGZyYW1lcyB3aGVuIHRoZSBTVEEgaXMgaW4gcG93ZXIgc2F2ZSBzbGVlcC4gT25seQorCSAgYXZhaWxhYmxlIHdpdGggZHJpdmVycyB0aGF0IHByb3ZpZGUgVFggc3RhdHVzIGV2ZW50cyBmb3IgRGVhdXRoLworCSAgRGlzYXNzb2MgZnJhbWVzIChubDgwMjExKS4KKwkqIERyb3Agb2xkZXN0IHVua25vd24gQlNTIHRhYmxlIGVudHJpZXMgZmlyc3QuIFRoaXMgbWFrZXMgaXQgbGVzcworCSAgbGlrZWx5IHRvIGhpdCBjb25uZWN0aW9uIGlzc3VlcyBpbiBlbnZpcm9ubWVudHMgd2l0aCBodWdlIG51bWJlcgorCSAgb2YgdmlzaWJsZSBBUHMuCisJKiBBZGQgc3lzdGVtZCBzdXBwb3J0LgorCSogQWRkIHN1cHBvcnQgZm9yIHNldHRpbmcgdGhlIHN5c2xvZyBmYWNpbGl0eSBmcm9tIHRoZSBjb25maWcgZmlsZQorCSAgYXQgYnVpbGQgdGltZS4KKwkqIGF0aGVyb3M6IEFkZCBzdXBwb3J0IGZvciBJRUVFIDgwMi4xMXcgY29uZmlndXJhdGlvbi4KKwkqIEFQIG1vZGU6IEFsbG93IGVuYWJsZSBIVDIwIGlmIGRyaXZlciBzdXBwb3J0cyBpdCwgYnkgc2V0dGluZyB0aGUKKwkgIGNvbmZpZyBwYXJhbWV0ZXIgaWVlZTgwMjExbi4KKwkqIEFsbG93IEFQIG1vZGUgdG8gZGlzY29ubmVjdCBTVEFzIGJhc2VkIG9uIGxvdyBBQ0sgY29uZGl0aW9uICh3aGVuCisJICB0aGUgZGF0YSBjb25uZWN0aW9uIGlzIG5vdCB3b3JraW5nIHByb3Blcmx5LCBlLmcuLCBkdWUgdG8gdGhlIFNUQQorCSAgZ29pbmcgb3V0c2lkZSB0aGUgcmFuZ2Ugb2YgdGhlIEFQKS4gRGlzYWJsZWQgYnkgZGVmYXVsdCwgZW5hYmxlIGJ5CisJICBjb25maWcgb3B0aW9uIGRpc2Fzc29jX2xvd19hY2suCisJKiBubDgwMjExOgorCSAgLSBTdXBwb3J0IEdUSyByZWtleSBvZmZsb2FkLgorCSAgLSBTdXBwb3J0IFBNS1NBIGNhbmRpZGF0ZSBldmVudHMuIFRoaXMgYWRkcyBzdXBwb3J0IGZvciBSU04KKwkgICAgcHJlLWF1dGhlbnRpY2F0aW9uIHdpdGggbmw4MDIxMSBpbnRlcmZhY2UgYW5kIGRyaXZlcnMgdGhhdCBoYW5kbGUKKwkgICAgcm9hbWluZyBpbnRlcm5hbGx5LgorCSogZGJ1czoKKwkgIC0gQWRkIGEgREJ1cyBzaWduYWwgZm9yIEVBUCBTTSByZXF1ZXN0cywgZW1pdHRlZCBvbiB0aGUgSW50ZXJmYWNlCisJICAgIG9iamVjdC4KKwkgIC0gRXhwb3J0IG1heCBzY2FuIHNzaWRzIHN1cHBvcnRlZCBieSB0aGUgZHJpdmVyIGFzIE1heFNjYW5TU0lELgorCSAgLSBBZGQgc2lnbmFsIENlcnRpZmljYXRpb24gZm9yIGluZm9ybWF0aW9uIGFib3V0IHNlcnZlciBjZXJ0aWZpY2F0aW9uLgorCSAgLSBBZGQgQlNTRXhwaXJlQWdlIGFuZCBCU1NFeHBpcmVDb3VudCBpbnRlcmZhY2UgcHJvcGVydGllcyBhbmQKKwkgICAgc3VwcG9ydCBzZXQvZ2V0LCB3aGljaCBhbGxvd3MgZm9yIHNldHRpbmcgQlNTIGNhY2hlIGV4cGlyYXRpb24gYWdlCisJICAgIGFuZCBleHBpcmF0aW9uIHNjYW4gY291bnQuCisJICAtIEFkZCBDb25maWdGaWxlIHRvIEFkZEludGVyZmFjZSBwcm9wZXJ0aWVzLgorCSAgLSBBZGQgSW50ZXJmYWNlLkNvdW50cnkgcHJvcGVydHkgYW5kIHN1cHBvcnQgdG8gZ2V0L3NldCB0aGUgdmFsdWUuCisJICAtIEFkZCBEQnVzIHByb3BlcnR5IEN1cnJlbnRBdXRoTW9kZS4KKwkgIC0gUDJQIERCdXMgQVBJIGFkZGVkLgorCSAgLSBFbWl0IHByb3BlcnR5IGNoYW5nZWQgZXZlbnRzIChmb3IgcHJvcGVydHkgQlNTcykgd2hlbiBhZGRpbmcvCisJICAgIHJlbW92aW5nIEJTU3MuCisJICAtIFRyZWF0ICcnIGluIFNTSURzIG9mIEludGVyZmFjZS5TY2FuIGFzIGEgcmVxdWVzdCBmb3IgYnJvYWRjYXN0CisJICAgIHNjYW4sIGluc3RlYWQgb2YgaWdub3JpbmcgaXQuCisJICAtIEFkZCBEQnVzIGdldHRlci9zZXR0ZXIgZm9yIEZhc3RSZWF1dGguCisJICAtIFJhaXNlIFByb3BlcnRpZXNDaGFuZ2VkIG9uIG9yZy5mcmVlZGVza3RvcC5EQnVzLlByb3BlcnRpZXMuCisJKiB3cGFfY2xpOgorCSAgLSBTZW5kIEFQLVNUQS1ESVNDT05ORUNURUQgZXZlbnQgd2hlbiBhbiBBUCBkaXNjb25uZWN0cyBhIHN0YXRpb24KKwkgICAgZHVlIHRvIGluYWN0aXZpdHkuCisJICAtIE1ha2Ugc2Vjb25kIGFyZ3VtZW50IHRvIHNldCBjb21tYW5kIG9wdGlvbmFsLiBUaGlzIGNhbiBiZSB1c2VkIHRvCisJICAgIGluZGljYXRlIGEgemVybyBsZW5ndGggdmFsdWUuCisJICAtIEFkZCBzaWduYWxfcG9sbCBjb21tYW5kLgorCSAgLSBBZGQgYnNzX2V4cGlyZV9hZ2UgYW5kIGJzc19leHBpcmVfY291bnQgY29tbWFuZHMgdG8gc2V0L2dldCBCU1MKKwkgICAgY2FjaGUgZXhwaXJhdGlvbiBhZ2UgYW5kIGV4cGlyYXRpb24gc2NhbiBjb3VudC4KKwkgIC0gQWRkIGFiaWxpdHkgdG8gc2V0IHNjYW4gaW50ZXJ2YWwgKHRoZSB0aW1lIGluIHNlY29uZHMgd3BhX3Mgd2FpdHMKKwkgICAgYmVmb3JlIHJlcXVlc3RpbmcgYSBuZXcgc2NhbiBhZnRlciBmYWlsaW5nIHRvIGZpbmQgYSBzdWl0YWJsZQorCSAgICBuZXR3b3JrIGluIHNjYW4gcmVzdWx0cykgdXNpbmcgc2Nhbl9pbnRlcnZhbCBjb21tYW5kLgorCSAgLSBBZGQgZXZlbnQgQ1RSTC1FVkVOVC1BU1NPQy1SRUpFQ1QgZm9yIGFzc29jaWF0aW9uIHJlamVjdGVkLgorCSAgLSBBZGQgY29tbWFuZCBnZXQgdmVyc2lvbiwgdGhhdCByZXR1cm5zIHdwYV9zdXBwbGljYW50IHZlcnNpb24gc3RyaW5nLgorCSAgLSBBZGQgY29tbWFuZCBzdGFfYXV0b2Nvbm5lY3QgZm9yIGRpc2FibGluZyBhdXRvbWF0aWMgcmVjb25uZWN0aW9uCisJICAgIG9uIHJlY2VpdmluZyBkaXNjb25uZWN0aW9uIGV2ZW50LgorCSAgLSBTZXR0aW5nIGJzc2lkIHBhcmFtZXRlciB0byBhbiBlbXB0eSBzdHJpbmcgIiIgb3IgYW55IGNhbiBub3cgYmUKKwkgICAgdXNlZCB0byBjbGVhciB0aGUgYnNzaWRfc2V0IGZsYWcgaW4gYSBuZXR3b3JrIGJsb2NrLCBpLmUuLCB0byByZW1vdmUKKwkgICAgYnNzaWQgZmlsdGVyaW5nLgorCSAgLSBBZGQgdGRsc190ZXN0aW5nIGNvbW1hbmQgdG8gYWRkIGEgc3BlY2lhbCB0ZXN0aW5nIGZlYXR1cmUgZm9yCisJICAgIGNoYW5naW5nIFRETFMgYmVoYXZpb3IuIEJ1aWxkIHBhcmFtIENPTkZJR19URExTX1RFU1RJTkcgbXVzdCBiZQorCSAgICBlbmFibGVkIGFzIHdlbGwuCisJICAtIEZvciBpbnRlcndvcmtpbmcsIGFkZCB3cGFfY2xpIGNvbW1hbmRzIGludGVyd29ya2luZ19zZWxlY3QsCisJICAgIGludGVyd29ya2luZ19jb25uZWN0LCBhbnFwX2dldCwgZmV0Y2hfYW5xcCwgYW5kIHN0b3BfZmV0Y2hfYW5xcC4KKwkgIC0gTWFueSBQMlAgY29tbWFuZHMgd2VyZSBhZGRlZC4gU2VlIFJFQURNRS1QMlAuCisJICAtIE1hbnkgV1BTL1dQUyBFUiBjb21tYW5kcyAtIHNlZSBXUFMvV1BTIEVSIHNlY3Rpb25zIGZvciBkZXRhaWxzLgorCSAgLSBBbGxvdyBzZXQgY29tbWFuZCB0byBjaGFuZ2UgZ2xvYmFsIGNvbmZpZyBwYXJhbWV0ZXJzLgorCSAgLSBBZGQgbG9nX2xldmVsIGNvbW1hbmQsIHdoaWNoIGNhbiBiZSB1c2VkIHRvIGRpc3BsYXkgdGhlIGN1cnJlbnQKKwkgICAgZGVidWdnaW5nIGxldmVsIGFuZCB0byBjaGFuZ2UgdGhlIGxvZyBsZXZlbCBkdXJpbmcgcnVuIHRpbWUuCisJICAtIEFkZCBub3RlIGNvbW1hbmQsIHdoaWNoIGNhbiBiZSB1c2VkIHRvIGluc2VydCBub3RlcyB0byB0aGUgZGVidWcKKwkgICAgbG9nLgorCSAgLSBBZGQgaW50ZXJuYWwgbGluZSBlZGl0IGltcGxlbWVudGF0aW9uLiBDT05GSUdfV1BBX0NMSV9FRElUPXkKKwkgICAgY2FuIG5vdyBiZSB1c2VkIHRvIGJ1aWxkIHdwYV9jbGkgd2l0aCBpbnRlcm5hbCBpbXBsZW1lbnRhdGlvbiBvZgorCSAgICBsaW5lIGVkaXRpbmcgYW5kIGhpc3Rvcnkgc3VwcG9ydC4gVGhpcyBjYW4gYmUgdXNlZCBhcyBhIHJlcGxhY2VtZW50CisJICAgIGZvciBDT05GSUdfUkVBRExJTkU9eS4KKwkqIEFQIG1vZGU6IEFkZCBtYXhfbnVtX3N0YSBjb25maWcgb3B0aW9uLCB3aGljaCBjYW4gYmUgdXNlZCB0byBsaW1pdAorCSAgdGhlIG51bWJlciBvZiBzdGF0aW9ucyBhbGxvd2VkIHRvIGNvbm5lY3QgdG8gdGhlIEFQLgorCSogQWRkIFdQQV9JR05PUkVfQ09ORklHX0VSUk9SUyBidWlsZCBvcHRpb24gdG8gY29udGludWUgaW4gY2FzZSBvZiBiYWQKKwkgIGNvbmZpZyBmaWxlLgorCSogd2V4dDogSW5jcmVhc2Ugc2NhbiB0aW1lb3V0IGZyb20gNSB0byAxMCBzZWNvbmRzLgorCSogQWRkIGJsYWNrbGlzdCBjb21tYW5kLCBhbGxvd2luZyBhbiBleHRlcm5hbCBwcm9ncmFtIHRvCisJICBtYW5hZ2UgdGhlIEJTUyBibGFja2xpc3QgYW5kIGRpc3BsYXkgaXRzIGN1cnJlbnQgY29udGVudHMuCisJKiBXUFM6CisJICAtIEFkZCB3cGFfY2xpIHdwc19waW4gZ2V0IGNvbW1hbmQgZm9yIGdlbmVyYXRpbmcgcmFuZG9tIFBJTnMuIFRoaXMgY2FuCisJICAgIGJlIHVzZWQgaW4gYSBVSSB0byBnZW5lcmF0ZSBhIFBJTiB3aXRob3V0IHN0YXJ0aW5nIFdQUyAob3IgUDJQKQorCSAgICBvcGVyYXRpb24uCisJICAtIFNldCBSRiBiYW5kcyBiYXNlZCBvbiBkcml2ZXIgY2FwYWJpbGl0aWVzLCBpbnN0ZWFkIG9mIGhhcmRjb2RpbmcKKwkgICAgdGhlbS4KKwkgIC0gQWRkIG1lY2hhbmlzbSBmb3IgaW5kaWNhdGluZyBub24tc3RhbmRhcmQgV1BTIGVycm9ycy4KKwkgIC0gQWRkIENPTkZJR19XUFNfUkVHX0RJU0FCTEVfT1BFTj15IG9wdGlvbiB0byBkaXNhYmxlIG9wZW4gbmV0d29ya3MKKwkgICAgYnkgZGVmYXVsdC4KKwkgIC0gQWRkIHdwc19hcF9waW4gY2xpIGNvbW1hbmQgZm9yIHdwYV9zdXBwbGljYW50IEFQIG1vZGUuCisJICAtIEFkZCB3cHNfY2hlY2tfcGluIGNsaSBjb21tYW5kIGZvciBwcm9jZXNzaW5nIFBJTiBmcm9tIHVzZXIgaW5wdXQuCisJICAgIFVJcyBjYW4gdXNlIHRoaXMgY29tbWFuZCB0byBwcm9jZXNzIGEgUElOIGVudGVyZWQgYnkgYSB1c2VyIGFuZCB0bworCSAgICB2YWxpZGF0ZSB0aGUgY2hlY2tzdW0gZGlnaXQgKGlmIHByZXNlbnQpLgorCSAgLSBDYW5jZWwgV1BTIG9wZXJhdGlvbiBvbiBQQkMgc2Vzc2lvbiBvdmVybGFwIGRldGVjdGlvbi4KKwkgIC0gTmV3IHdwc19jYW5jZWwgY29tbWFuZCBpbiB3cGFfY2xpIHdpbGwgY2FuY2VsIGEgcGVuZGluZyBXUFMKKwkgICAgb3BlcmF0aW9uLgorCSAgLSB3cGFfY2xpIGFjdGlvbjogQWRkIFdQU19FVkVOVF9TVUNDRVNTIGFuZCBXUFNfRVZFTlRfRkFJTCBoYW5kbGVycy4KKwkgIC0gVHJpZ2dlciBXUFMgY29uZmlnIHVwZGF0ZSBvbiBNYW51ZmFjdHVyZXIsIE1vZGVsIE5hbWUsIE1vZGVsCisJICAgIE51bWJlciwgYW5kIFNlcmlhbCBOdW1iZXIgY2hhbmdlcy4KKwkgIC0gRnJhZ21lbnQgc2l6ZSBpcyBub3cgY29uZmlndXJhYmxlIGZvciBFQVAtV1NDIHBlZXIuIFVzZQorCSAgICB3cGFfY2xpIHNldCB3cHNfZnJhZ21lbnRfc2l6ZSA8dmFsPi4KKwkgIC0gRGlzYWJsZSBBUCBQSU4gYWZ0ZXIgMTAgY29uc2VjdXRpdmUgZmFpbHVyZXMuIFNsb3cgZG93biBhdHRhY2tzIG9uCisJICAgIGZhaWx1cmVzIHVwIHRvIDEwLgorCSAgLSBBbGxvdyBBUCB0byBzdGFydCBpbiBFbnJvbGxlZSBtb2RlIHdpdGhvdXQgQVAgUElOIGZvciBwcm9iaW5nLCB0bworCSAgICBiZSBjb21wYXRpYmxlIHdpdGggV2luZG93cyA3LgorCSAgLSBBZGQgQ29uZmlnIEVycm9yIGludG8gV1BTLUZBSUwgZXZlbnRzIHRvIHByb3ZpZGUgbW9yZSBpbmZvIHRvIHRoZQorCSAgICB1c2VyIG9uIGhvdyB0byByZXNvbHZlIHRoZSBpc3N1ZS4KKwkgIC0gTGFiZWwgYW5kIERpc3BsYXkgY29uZmlnIG1ldGhvZHMgYXJlIG5vdCBhbGxvd2VkIHRvIGJlIGVuYWJsZWQKKwkgICAgYXQgdGhlIHNhbWUgdGltZSwgc2luY2UgaXQgaXMgdW5jbGVhciB3aGljaCBQSU4gdG8gdXNlIGlmIGJvdGgKKwkgICAgbWV0aG9kcyBhcmUgYWR2ZXJ0aXNlZC4KKwkgIC0gV2hlbiBjb250cm9sbGluZyBtdWx0aXBsZSBpbnRlcmZhY2VzOgorCSAgICAgLSBhcHBseSBXUFMgY29tbWFuZHMgdG8gYWxsIGludGVyZmFjZXMgY29uZmlndXJlZCB0byB1c2UgV1BTCisJICAgICAtIGFwcGx5IFdQUyBjb25maWcgY2hhbmdlcyB0byBhbGwgaW50ZXJmYWNlcyB0aGF0IHVzZSBXUFMKKwkgICAgIC0gd2hlbiBhbiBhdHRhY2sgaXMgZGV0ZWN0ZWQgb24gYW55IGludGVyZmFjZSwgZGlzYWJsZSBBUCBQSU4gb24KKwkgICAgICAgYWxsIGludGVyZmFjZXMKKwkqIFdQUyBFUjoKKwkgIC0gQWRkIHNwZWNpYWwgQVAgU2V0dXAgTG9ja2VkIG1vZGUgdG8gYWxsb3cgcmVhZCBvbmx5IEVSLgorCSAgICBhcF9zZXR1cF9sb2NrZWQ9MiBjYW4gbm93IGJlIHVzZWQgdG8gZW5hYmxlIGEgc3BlY2lhbCBtb2RlIHdoZXJlCisJICAgIFdQUyBFUiBjYW4gbGVhcm4gdGhlIGN1cnJlbnQgQVAgc2V0dGluZ3MsIGJ1dCBjYW5ub3QgY2hhbmdlIHRoZW0uCisJICAtIFNob3cgU2V0U2VsZWN0ZWRSZWdpc3RyYXIgZXZlbnRzIGFzIGN0cmxfaWZhY2UgZXZlbnRzCisJICAtIEFkZCB3cHNfZXJfc2V0X2NvbmZpZyB0byBlbnJvbGwgYSBuZXR3b3JrIGJhc2VkIG9uIGEgbG9jYWwKKwkgICAgbmV0d29yayBjb25maWd1cmF0aW9uIGJsb2NrIGluc3RlYWQgb2YgaGF2aW5nIHRvIChyZS0pbGVhcm4gdGhlCisJICAgIGN1cnJlbnQgQVAgc2V0dGluZ3Mgd2l0aCB3cHNfZXJfbGVhcm4uCisJICAtIEFsbG93IEFQIGZpbHRlcmluZyBiYXNlZCBvbiBJUCBhZGRyZXNzLCBhZGQgY3RybF9pZmFjZSBldmVudCBmb3IKKwkgICAgbGVhcm5lZCBBUCBzZXR0aW5ncywgYWRkIHdwc19lcl9jb25maWcgY29tbWFuZCB0byBjb25maWd1cmUgYW4gQVAuCisJKiBXUFMgMi4wOiBBZGQgc3VwcG9ydCBmb3IgV1BTIDIuMCAoQ09ORklHX1dQUzIpCisJICAtIEFkZCBidWlsZCBvcHRpb24gQ09ORklHX1dQU19FWFRFTlNJQklMSVRZX1RFU1RJTkcgdG8gZW5hYmxlIHRvb2wKKwkgICAgZm9yIHRlc3RpbmcgcHJvdG9jb2wgZXh0ZW5zaWJpbGl0eS4KKwkgIC0gQWRkIGJ1aWxkIG9wdGlvbiBDT05GSUdfV1BTX1NUUklDVCB0byBhbGxvdyBkaXNhYmxpbmcgb2YgV1BTCisJICAgIHdvcmthcm91bmRzLgorCSAgLSBBZGQgc3VwcG9ydCBmb3IgQXV0aG9yaXplZE1BQ3MgYXR0cmlidXRlLgorCSogVERMUzoKKwkgIC0gUHJvcG9nYXRlIFRETFMgcmVsYXRlZCBubDgwMjExIGNhcGFiaWxpdHkgZmxhZ3MgZnJvbSBrZXJuZWwgYW5kCisJICAgIGFkZCB0aGVtIGFzIGRyaXZlciBjYXBhYmlsaXR5IGZsYWdzLiBJZiB0aGUgZHJpdmVyIGRvZXNuJ3Qgc3VwcG9ydAorCSAgICBjYXBhYmlsaXRpZXMsIGFzc3VtZSBURExTIGlzIHN1cHBvcnRlZCBpbnRlcm5hbGx5LiBXaGVuIFRETFMgaXMKKwkgICAgZXhwbGljaXRseSBub3Qgc3VwcG9ydGVkLCBkaXNhYmxlIGFsbCB1c2VyIGZhY2luZyBURExTIG9wZXJhdGlvbnMuCisJICAtIEFsbG93IFRETFMgdG8gYmUgZGlzYWJsZWQgYXQgcnVudGltZSAobW9zdGx5IGZvciB0ZXN0aW5nKS4KKwkgICAgVXNlIHNldCB0ZGxzX2Rpc2FibGVkLgorCSAgLSBIb25vciBBUCBURExTIHNldHRpbmdzIHRoYXQgcHJvaGliaXQvYWxsb3cgVERMUy4KKwkgIC0gQWRkIGEgc3BlY2lhbCB0ZXN0aW5nIGZlYXR1cmUgZm9yIGNoYW5naW5nIFRETFMgYmVoYXZpb3IuIFVzZQorCSAgICBDT05GSUdfVERMU19URVNUSU5HIGJ1aWxkIHBhcmFtIHRvIGVuYWJsZS4gQ29uZmlndXJlIGF0IHJ1bnRpbWUKKwkgICAgd2l0aCB0ZGxzX3Rlc3RpbmcgY2xpIGNvbW1hbmQuCisJICAtIEFkZCBzdXBwb3J0IGZvciBURExTIDgwMi4xMXouCisJKiB3bGFudGVzdDogQWRkIGEgdG9vbCB3bGFudGVzdCBmb3IgSUVFRTgwMi4xMSBwcm90b2NvbCB0ZXN0aW5nLgorCSAgd2xhbnRlc3QgY2FuIGJlIHVzZWQgdG8gY2FwdHVyZSBmcmFtZXMgZnJvbSBhIG1vbml0b3IgaW50ZXJmYWNlCisJICBmb3IgcmVhbHRpbWUgY2FwdHVyaW5nIG9yIGZyb20gcGNhcCBmaWxlcyBmb3Igb2ZmbGluZSBhbmFseXNpcy4KKwkqIEludGVyd29ya2luZzogU3VwcG9ydCBhZGRlZCBmb3IgODAyLjExdS4gRW5hYmxlIGluIC5jb25maWcgd2l0aAorCSAgQ09ORklHX0lOVEVSV09SS0lORy4gU2VlIHdwYV9zdXBwbGljYW50LmNvbmYgZm9yIGNvbmZpZyBwYXJhbWV0ZXJzCisJICBmb3IgaW50ZXJ3b3JraW5nLiB3cGFfY2xpIGNvbW1hbmRzIGFkZGVkIHRvIHN1cHBvcnQgdGhpcyBhcmUKKwkgIGludGVyd29ya2luZ19zZWxlY3QsIGludGVyd29ya2luZ19jb25uZWN0LCBhbnFwX2dldCwgZmV0Y2hfYW5xcCwKKwkgIGFuZCBzdG9wX2ZldGNoX2FucXAuCisJKiBBbmRyb2lkOiBBZGQgYnVpbGQgYW5kIHJ1bnRpbWUgc3VwcG9ydCBmb3IgQW5kcm9pZCB3cGFfc3VwcGxpY2FudC4KKwkqIGJnc2NhbiBsZWFybjogQWRkIG5ldyBiZ3NjYW4gdGhhdCBsZWFybnMgQlNTIGluZm9ybWF0aW9uIGJhc2VkIG9uCisJICBwcmV2aW91cyBzY2FucywgYW5kIHVzZXMgdGhhdCBpbmZvcm1hdGlvbiB0byBkeW5hbWljYWxseSBnZW5lcmF0ZQorCSAgdGhlIGxpc3Qgb2YgY2hhbm5lbHMgZm9yIGJhY2tncm91bmQgc2NhbnMuCisJKiBBZGQgYSBuZXcgZGVidWcgbWVzc2FnZSBsZXZlbCBmb3IgZXhjZXNzaXZlIGluZm9ybWF0aW9uLiBVc2UKKwkgIC1kZGQgdG8gZW5hYmxlLgorCSogVExTOiBBZGQgc3VwcG9ydCBmb3IgdGxzX2Rpc2FibGVfdGltZV9jaGVja3M9MSBpbiBjbGllbnQgbW9kZS4KKwkqIEludGVybmFsIFRMUzoKKwkgIC0gQWRkIHN1cHBvcnQgZm9yIFRMUyB2MS4xIChSRkMgNDM0NikuIEVuYWJsZSB3aXRoIGJ1aWxkIHBhcmFtZXRlcgorCSAgICBDT05GSUdfVExTVjExLgorCSAgLSBBZGQgZG9tYWluQ29tcG9uZW50IHBhcnNlciBmb3IgWC41MDkgbmFtZXMuCisJKiBMaW51eDogQWRkIFJGS2lsbCBzdXBwb3J0IGJ5IGFkZGluZyBhbiBpbnRlcmZhY2Ugc3RhdGUgImRpc2FibGVkIi4KKwkqIFJlb3JkZXIgc29tZSBJRXMgdG8gZ2V0IGNsb3NlciB0byBJRUVFIDgwMi4xMSBzdGFuZGFyZC4gTW92ZQorCSAgV01NIGludG8gZW5kIG9mIEJlYWNvbiwgUHJvYmUgUmVzcCBhbmQgKFJlKUFzc29jIFJlc3AgZnJhbWVzLgorCSAgTW92ZSBIVCBJRXMgdG8gYmUgbGF0ZXIgaW4gKFJlKUFzc29jIFJlc3AuCisJKiBTb2xhcmlzOiBBZGQgc3VwcG9ydCBmb3Igd2lyZWQgODAyLjFYIGNsaWVudC4KKwkqIFdpLUZpIERpcmVjdCBzdXBwb3J0LiBTZWUgUkVBRE1FLVAyUCBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KKwkqIE1hbnkgYnVnZml4ZXMuCisKIDIwMTAtMDQtMTggLSB2MC43LjIKIAkqIG5sODAyMTE6IGZpeGVkIG51bWJlciBvZiBpc3N1ZXMgd2l0aCByb2FtaW5nCiAJKiBhdm9pZCB1bm5lY2Vzc2FyeSByb2FtaW5nIGlmIG11bHRpcGxlIEFQcyB3aXRoIHNpbWlsYXIgc2lnbmFsCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9NYWtlZmlsZSBiL3dwYV9zdXBwbGljYW50L01ha2VmaWxlCmluZGV4IDAzMjQxYzUuLjY3NTZlNTQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L01ha2VmaWxlCisrKyBiL3dwYV9zdXBwbGljYW50L01ha2VmaWxlCkBAIC0yMjcsNiArMjI3LDEyIEBACiBlbmRpZgogZW5kaWYKIAoraWZkZWYgQ09ORklHX0hTMjAKK09CSlMgKz0gaHMyMF9zdXBwbGljYW50Lm8KK0NGTEFHUyArPSAtRENPTkZJR19IUzIwCitDT05GSUdfSU5URVJXT1JLSU5HPXkKK2VuZGlmCisKIGlmZGVmIENPTkZJR19JTlRFUldPUktJTkcKIE9CSlMgKz0gaW50ZXJ3b3JraW5nLm8KIENGTEFHUyArPSAtRENPTkZJR19JTlRFUldPUktJTkcKQEAgLTcxNiw2ICs3MjIsMTAgQEAKIENGTEFHUyArPSAtRENPTkZJR19JRUVFODAyMTFOCiBlbmRpZgogCitpZmRlZiBDT05GSUdfV05NCitDRkxBR1MgKz0gLURDT05GSUdfV05NCitlbmRpZgorCiBpZmRlZiBORUVEX0FQX01MTUUKIE9CSlMgKz0gLi4vc3JjL2FwL3dtbS5vCiBPQkpTICs9IC4uL3NyYy9hcC9hcF9saXN0Lm8KQEAgLTcyOCw2ICs3MzgsOSBAQAogT0JKUyArPSAuLi9zcmMvYXAvd3BzX2hvc3RhcGQubwogT0JKUyArPSAuLi9zcmMvZWFwX3NlcnZlci9lYXBfc2VydmVyX3dzYy5vCiBlbmRpZgoraWZkZWYgQ09ORklHX0lOVEVSV09SS0lORworT0JKUyArPSAuLi9zcmMvYXAvZ2FzX3NlcnYubworZW5kaWYKIGVuZGlmCiAKIGlmZGVmIE5FRURfUlNOX0FVVEhFTlRJQ0FUT1IKQEAgLTEyNzAsNiArMTI4MywxMCBAQAogZW5kaWYKIGVuZGlmCiAKK2lmZGVmIENPTkZJR19ERUJVR19MSU5VWF9UUkFDSU5HCitDRkxBR1MgKz0gLURDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworZW5kaWYKKwogaWZkZWYgQ09ORklHX0RFQlVHX0ZJTEUKIENGTEFHUyArPSAtRENPTkZJR19ERUJVR19GSUxFCiBlbmRpZgpAQCAtMTMwNCw2ICsxMzIxLDIzIEBACiBPQkpTICs9IGJnc2Nhbi5vCiBlbmRpZgogCitpZmRlZiBDT05GSUdfQVVUT1NDQU5fRVhQT05FTlRJQUwKK0NGTEFHUyArPSAtRENPTkZJR19BVVRPU0NBTl9FWFBPTkVOVElBTAorT0JKUyArPSBhdXRvc2Nhbl9leHBvbmVudGlhbC5vCitORUVEX0FVVE9TQ0FOPXkKK2VuZGlmCisKK2lmZGVmIENPTkZJR19BVVRPU0NBTl9QRVJJT0RJQworQ0ZMQUdTICs9IC1EQ09ORklHX0FVVE9TQ0FOX1BFUklPRElDCitPQkpTICs9IGF1dG9zY2FuX3BlcmlvZGljLm8KK05FRURfQVVUT1NDQU49eQorZW5kaWYKKworaWZkZWYgTkVFRF9BVVRPU0NBTgorQ0ZMQUdTICs9IC1EQ09ORklHX0FVVE9TQ0FOCitPQkpTICs9IGF1dG9zY2FuLm8KK2VuZGlmCisKIGlmZGVmIE5FRURfR0FTCiBPQkpTICs9IC4uL3NyYy9jb21tb24vZ2FzLm8KIE9CSlMgKz0gZ2FzX3F1ZXJ5Lm8KQEAgLTEzMzIsNiArMTM2NiwxMCBAQAogT0JKU190ICs9IC4uL3NyYy91dGlscy9pcF9hZGRyLm8KIGVuZGlmCiBPQkpTX3QyIDo9ICQoT0JKUykgJChPQkpTX2wyKSBwcmVhdXRoX3Rlc3QubworCitPQkpTX25mYyA6PSAkKE9CSlMpICQoT0JKU19sMikgbmZjX3B3X3Rva2VuLm8KK09CSlNfbmZjICs9ICQoT0JKU19kKSAuLi9zcmMvZHJpdmVycy9kcml2ZXJzLm8KKwogT0JKUyArPSAkKENPTkZJR19NQUlOKS5vCiAKIGlmZGVmIENPTkZJR19QUklWU0VQCkBAIC0xNDQwLDYgKzE0NzgsMTAgQEAKIAkkKFEpJChMRE8pICQoTERGTEFHUykgLW8gdGVzdF93cGEgJChPQkpTX3dwYSkgJChMSUJTKQogCUAkKEUpICIgIExEICIgJEAKIAorbmZjX3B3X3Rva2VuOiAkKE9CSlNfbmZjKQorCSQoUSkkKExETykgJChMREZMQUdTKSAtbyBuZmNfcHdfdG9rZW4gJChPQkpTX25mYykgJChMSUJTKQorCUAkKEUpICIgIExEICIgJEAKKwogd2luX2lmX2xpc3Q6IHdpbl9pZl9saXN0LmMKIAkkKFEpJChMRE8pICQoTERGTEFHUykgLW8gJEAgd2luX2lmX2xpc3QuYyAkKENGTEFHUykgJChMSUJTX3cpCiAJQCQoRSkgIiAgTEQgIiAkQApAQCAtMTUyMiw1ICsxNTY0LDYgQEAKIAkkKE1BS0UpIC1DIGRidXMgY2xlYW4KIAlybSAtZiBjb3JlICp+ICoubyAqLmQgZWFwXyouc28gJChBTEwpICQoV0lOQUxMKSBlYXBvbF90ZXN0IHByZWF1dGhfdGVzdAogCXJtIC1mIHdwYV9wcml2CisJcm0gLWYgbmZjX3B3X3Rva2VuCiAKIC1pbmNsdWRlICQoT0JKUzolLm89JS5kKQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FIGIvd3BhX3N1cHBsaWNhbnQvUkVBRE1FCmluZGV4IDllZTgyYTIuLmEwNmU1YzEgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L1JFQURNRQorKysgYi93cGFfc3VwcGxpY2FudC9SRUFETUUKQEAgLTQyNSw3ICs0MjUsNyBAQAogICAtSyA9IGluY2x1ZGUga2V5cyAocGFzc3dvcmRzLCBldGMuKSBpbiBkZWJ1ZyBvdXRwdXQKICAgLXQgPSBpbmNsdWRlIHRpbWVzdGFtcCBpbiBkZWJ1ZyBtZXNzYWdlcwogICAtaCA9IHNob3cgdGhpcyBoZWxwIHRleHQKLSAgLUwgPSBzaG93IGxpY2Vuc2UgKEdQTCBhbmQgQlNEKQorICAtTCA9IHNob3cgbGljZW5zZSAoQlNEKQogICAtcCA9IGRyaXZlciBwYXJhbWV0ZXJzCiAgIC1QID0gUElEIGZpbGUKICAgLXEgPSBkZWNyZWFzZSBkZWJ1Z2dpbmcgdmVyYm9zaXR5ICgtcXEgZXZlbiBsZXNzKQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVAyUCBiL3dwYV9zdXBwbGljYW50L1JFQURNRS1QMlAKaW5kZXggZGI2ZTRhZS4uYmI0YzJhZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVAyUAorKysgYi93cGFfc3VwcGxpY2FudC9SRUFETUUtUDJQCkBAIC0xMDEsNyArMTAxLDcgQEAKIAogR3JvdXAgRm9ybWF0aW9uCiAKLXAycF9wcm92X2Rpc2MgPHBlZXIgZGV2aWNlIGFkZHJlc3M+IDxkaXNwbGF5fGtleXBhZHxwYmM+IFtqb2luXQorcDJwX3Byb3ZfZGlzYyA8cGVlciBkZXZpY2UgYWRkcmVzcz4gPGRpc3BsYXl8a2V5cGFkfHBiYz4gW2pvaW58YXV0b10KIAogU2VuZCBQMlAgcHJvdmlzaW9uIGRpc2NvdmVyeSByZXF1ZXN0IHRvIHRoZSBzcGVjaWZpZWQgcGVlci4gVGhlCiBwYXJhbWV0ZXJzIGZvciB0aGlzIGNvbW1hbmQgYXJlIHRoZSBQMlAgZGV2aWNlIGFkZHJlc3Mgb2YgdGhlIHBlZXIgYW5kCkBAIC0xMTIsMTAgKzExMiwxNCBAQAogCiBUaGUgb3B0aW9uYWwgImpvaW4iIHBhcmFtZXRlciBjYW4gYmUgdXNlZCB0byBpbmRpY2F0ZSB0aGF0IHRoaXMgY29tbWFuZAogaXMgcmVxdWVzdGluZyBhbiBhbHJlYWR5IHJ1bm5pbmcgR08gdG8gcHJlcGFyZSBmb3IgYSBuZXcgY2xpZW50LiBUaGlzIGlzCi1tYWlubHkgdXNlZCB3aXRoICJkaXNwbGF5IiB0byByZXF1ZXN0IGl0IHRvIGRpc3BsYXkgYSBQSU4uCittYWlubHkgdXNlZCB3aXRoICJkaXNwbGF5IiB0byByZXF1ZXN0IGl0IHRvIGRpc3BsYXkgYSBQSU4uIFRoZSAiYXV0byIKK3BhcmFtZXRlciBjYW4gYmUgdXNlZCB0byByZXF1ZXN0IHdwYV9zdXBwbGljYW50IHRvIGF1dG9tYXRpY2FsbHkgZmlndXJlCitvdXQgd2hldGhlciB0aGUgcGVlciBkZXZpY2UgaXMgb3BlcmF0aW5nIGFzIGEgR08gYW5kIGlmIHNvLCB1c2UKK2pvaW4tYS1ncm91cCBzdHlsZSBQRCBpbnN0ZWFkIG9mIEdPIE5lZ290aWF0aW9uIHN0eWxlIFBELgogCiBwMnBfY29ubmVjdCA8cGVlciBkZXZpY2UgYWRkcmVzcz4gPHBiY3xwaW58UElOIz4gW2Rpc3BsYXl8a2V5cGFkXQotCVtwZXJzaXN0ZW50XSBbam9pbnxhdXRoXSBbZ29faW50ZW50PTwwLi4xNT5dIFtmcmVxPTxpbiBNSHo+XQorCVtwZXJzaXN0ZW50fHBlcnNpc3RlbnQ9PG5ldHdvcmsgaWQ+XSBbam9pbnxhdXRoXQorCVtnb19pbnRlbnQ9PDAuLjE1Pl0gW2ZyZXE9PGluIE1Iej5dIFtwcm92ZGlzY10KIAogU3RhcnQgUDJQIGdyb3VwIGZvcm1hdGlvbiB3aXRoIGEgZGlzY292ZXJlZCBQMlAgcGVlci4gVGhpcyBpbmNsdWRlcwogb3B0aW9uYWwgZ3JvdXAgb3duZXIgbmVnb3RpYXRpb24sIGdyb3VwIGludGVyZmFjZSBzZXR1cCwgcHJvdmlzaW9uaW5nLApAQCAtMTI4LDcgKzEzMiwxMiBAQAogdXNlZCAoZS5nLiwgMTIzNDU2NzApLiBbZGlzcGxheXxrZXlwYWRdIGlzIHVzZWQgd2l0aCBQSU4gbWV0aG9kCiB0byBzcGVjaWZ5IHdoaWNoIFBJTiBpcyB1c2VkIChkaXNwbGF5PWR5bmFtaWNhbGx5IGdlbmVyYXRlZCByYW5kb20gUElOCiBmcm9tIGxvY2FsIGRpc3BsYXksIGtleXBhZD1QSU4gZW50ZXJlZCBmcm9tIHBlZXIgZGlzcGxheSkuICJwZXJzaXN0ZW50IgotcGFyYW1ldGVyIGNhbiBiZSB1c2VkIHRvIHJlcXVlc3QgYSBwZXJzaXN0ZW50IGdyb3VwIHRvIGJlIGZvcm1lZC4KK3BhcmFtZXRlciBjYW4gYmUgdXNlZCB0byByZXF1ZXN0IGEgcGVyc2lzdGVudCBncm91cCB0byBiZSBmb3JtZWQuIFRoZQorInBlcnNpc3RlbnQ9PG5ldHdvcmsgaWQ+IiBhbHRlcm5hdGl2ZSBjYW4gYmUgdXNlZCB0byBwcmUtcG9wdWxhdGUKK1NTSUQvcGFzc3BocmFzZSBjb25maWd1cmF0aW9uIGJhc2VkIG9uIGEgcHJldmlvdXNseSB1c2VkIHBlcnNpc3RlbnQKK2dyb3VwIHdoZXJlIHRoaXMgZGV2aWNlIHdhcyB0aGUgR08uIFRoZSBwcmV2aW91c2x5IHVzZWQgcGFyYW1ldGVycyB3aWxsCit0aGVuIGJlIHVzZWQgaWYgdGhlIGxvY2FsIGVuZCBiZWNvbWVzIHRoZSBHTyBpbiBHTyBOZWdvdGlhdGlvbiAod2hpY2gKK2NhbiBiZSBmb3JjZWQgd2l0aCBnb19pbnRlbnQ9MTUpLgogCiAiam9pbiIgaW5kaWNhdGVzIHRoYXQgdGhpcyBpcyBhIGNvbW1hbmQgdG8gam9pbiBhbiBleGlzdGluZyBncm91cCBhcyBhCiBjbGllbnQuIEl0IHNraXBzIHRoZSBHTyBOZWdvdGlhdGlvbiBwYXJ0LiBUaGlzIHdpbGwgc2VuZCBhIFByb3Zpc2lvbgpAQCAtMTQ2LDYgKzE1NSwxMSBAQAogImZyZXEiIGNhbiBiZSB1c2VkIHRvIHNldCBhIGZvcmNlZCBvcGVyYXRpbmcgY2hhbm5lbCAoZS5nLiwgZnJlcT0yNDEyCiB0byBzZWxlY3QgMi40IEdIeiBjaGFubmVsIDEpLgogCisicHJvdmRpc2MiIGNhbiBiZSB1c2VkIHRvIHJlcXVlc3QgYSBQcm92aXNpb24gRGlzY292ZXJ5IGV4Y2hhbmdlIHRvIGJlCit1c2VkIHByaW9yIHRvIHN0YXJ0aW5nIEdPIE5lZ290aWF0aW9uIGFzIGEgd29ya2Fyb3VuZCB3aXRoIHNvbWUgZGVwbG95ZWQKK1AyUCBpbXBsZW1lbnRhdGlvbnMgdGhhdCByZXF1aXJlIHRoaXMgdG8gYWxsb3cgdGhlIHVzZXIgdG8gYWNjZXB0IHRoZQorY29ubmVjdGlvbi4KKwogcDJwX2dyb3VwX2FkZCBbcGVyc2lzdGVudHxwZXJzaXN0ZW50PTxuZXR3b3JrIGlkPl0gW2ZyZXE9PGZyZXEgaW4gTUh6Pl0KIAogU2V0IHVwIGEgUDJQIGdyb3VwIG93bmVyIG1hbnVhbGx5IChpLmUuLCB3aXRob3V0IGdyb3VwIG93bmVyCkBAIC0zMjIsNyArMzM2LDcgQEAKIAogSW52aXRlIGEgcGVlciB0byBqb2luIGEgZ3JvdXAgKGUuZy4sIGdyb3VwPXdsYW4xKSBvciB0byByZWludm9rZSBhCiBwZXJzaXN0ZW50IGdyb3VwIChlLmcuLCBwZXJzaXN0ZW50PTQpLiBJZiB0aGUgcGVlciBkZXZpY2UgaXMgdGhlIEdPIG9mCi10aGUgcGVyc2lzdGVuIGdyb3VwLCB0aGUgcGVlciBwYXJhbWV0ZXIgaXMgbm90IG5lZWRlZC4gT3RoZXJ3aXNlIGl0IGlzCit0aGUgcGVyc2lzdGVudCBncm91cCwgdGhlIHBlZXIgcGFyYW1ldGVyIGlzIG5vdCBuZWVkZWQuIE90aGVyd2lzZSBpdCBpcwogdXNlZCB0byBzcGVjaWZ5IHdoaWNoIGRldmljZSB0byBpbnZpdGUuIGdvX2Rldl9hZGRyIHBhcmFtZXRlciBjYW4gYmUKIHVzZWQgdG8gb3ZlcnJpZGUgdGhlIEdPIGRldmljZSBhZGRyZXNzIGZvciBJbnZpdGF0aW9uIFJlcXVlc3Qgc2hvdWxkCiBpdCBiZSBub3Qga25vd24gZm9yIHNvbWUgcmVhc29uICh0aGlzIHNob3VsZCBub3QgYmUgbmVlZGVkIGluIG1vc3QKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L1JFQURNRS1XUFMgYi93cGFfc3VwcGxpY2FudC9SRUFETUUtV1BTCmluZGV4IGJmNzVjYjQuLjY5MmQ1ZjUgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L1JFQURNRS1XUFMKKysrIGIvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVdQUwpAQCAtNjcsNiArNjcsMTAgQEAKIAogQ09ORklHX1dQU19FUj15CiAKK0ZvbGxvd2luZyBwYXJhbWV0ZXIgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIHN1cHBvcnQgZm9yIE5GQyBjb25maWcgbWV0aG9kOgorCitDT05GSUdfV1BTX05GQz15CisKIAogV1BTIG5lZWRzIHRoZSBVbml2ZXJzYWxseSBVbmlxdWUgSURlbnRpZmllciAoVVVJRDsgc2VlIFJGQyA0MTIyKSBmb3IKIHRoZSBkZXZpY2UuIFRoaXMgaXMgY29uZmlndXJlZCBpbiB0aGUgcnVudGltZSBjb25maWd1cmF0aW9uIGZvcgpAQCAtMzAzLDMgKzMwNyw0MSBAQAogLSBXUFMgRVIgbGVhcm5lZCBBUCBzZXR0aW5ncwogCiBXUFMtRVItQVAtU0VUVElOR1MgdXVpZD1mZDkxYjRlYy1lM2ZhLTU4OTEtYTU3ZC04YzU5ZWZlZWQxZDIgc3NpZD10ZXN0LXdwcyBhdXRoX3R5cGU9MHgwMDIwIGVuY3JfdHlwZT0weDAwMDgga2V5PTEyMzQ1Njc4CisKKworV1BTIHdpdGggTkZDCistLS0tLS0tLS0tLS0KKworV1BTIGNhbiBiZSB1c2VkIHdpdGggTkZDLWJhc2VkIGNvbmZpZ3VyYXRpb24gbWV0aG9kLiBBbiBORkMgdGFnCitjb250YWluaW5nIGEgcGFzc3dvcmQgdG9rZW4gZnJvbSB0aGUgRW5yb2xsZWUgY2FuIGJlIHVzZWQgdG8KK2F1dGhlbnRpY2F0ZSB0aGUgY29ubmVjdGlvbiBpbnN0ZWFkIG9mIHRoZSBQSU4uIEluIGFkZGl0aW9uLCBhbiBORkMgdGFnCit3aXRoIGEgY29uZmlndXJhdGlvbiB0b2tlbiBjYW4gYmUgdXNlZCB0byB0cmFuc2ZlciBBUCBzZXR0aW5ncyB3aXRob3V0Citnb2luZyB0aHJvdWdoIHRoZSBXUFMgcHJvdG9jb2wuCisKK1doZW4gdGhlIHN0YXRpb24gYWN0cyBhcyBhbiBFbnJvbGxlZSwgYSBsb2NhbCBORkMgdGFnIHdpdGggYSBwYXNzd29yZAordG9rZW4gY2FuIGJlIHVzZWQgYnkgdG91Y2hpbmcgdGhlIE5GQyBpbnRlcmZhY2Ugb2YgYSBSZWdpc3RyYXIuCisKKyJ3cHNfbmZjIFtCU1NJRF0iIGNvbW1hbmQgc3RhcnRzIFdQUyBwcm90b2NvbCBydW4gd2l0aCB0aGUgbG9jYWwgZW5kIGFzCit0aGUgRW5yb2xsZWUgdXNpbmcgdGhlIE5GQyBwYXNzd29yZCB0b2tlbiB0aGF0IGlzIGVpdGhlciBwcmUtY29uZmlndXJlZAoraW4gdGhlIGNvbmZpZ3VyYXRpb24gZmlsZSAod3BzX25mY19kZXZfcHdfaWQsIHdwc19uZmNfZGhfcHVia2V5LAord3BzX25mY19kaF9wcml2a2V5LCB3cHNfbmZjX2Rldl9wdykgb3IgZ2VuZXJhdGVkIGR5bmFtaWNhbGx5IHdpdGgKKyJ3cHNfbmZjX3Rva2VuIDxXUFN8TkRFRj4iIGNvbW1hbmQuIFRoZSBpbmNsdWRlZCBuZmNfcHdfdG9rZW4gdG9vbAorKGJ1aWxkIHdpdGggIm1ha2UgbmZjX3B3X3Rva2VuIikgY2FuIGJlIHVzZWQgdG8gZ2VuZXJhdGUgTkZDIHBhc3N3b3JkCit0b2tlbnMgZHVyaW5nIG1hbnVmYWN0dXJpbmcgKGVhY2ggc3RhdGlvbiBuZWVkcyB0byBoYXZlIGl0cyBvd24gcmFuZG9tCitrZXlzKS4KKworSWYgdGhlIHN0YXRpb24gaW5jbHVkZXMgTkZDIGludGVyZmFjZSBhbmQgcmVhZHMgYW4gTkZDIHRhZyB3aXRoIGEgTUlNRQorbWVkaWEgdHlwZSAiYXBwbGljYXRpb24vdm5kLndmYS53c2MiLCB0aGUgTkRFRiBtZXNzYWdlIHBheWxvYWQgKHdpdGggb3IKK3dpdGhvdXQgTkRFRiBlbmNhcHN1bGF0aW9uKSBjYW4gYmUgZGVsaXZlcmVkIHRvIHdwYV9zdXBwbGljYW50IHVzaW5nIHRoZQorZm9sbG93aW5nIHdwYV9jbGkgY29tbWFuZDoKKword3BzX25mY190YWdfcmVhZCA8aGV4ZHVtcCBvZiBwYXlsb2FkPgorCitJZiB0aGUgTkZDIHRhZyBjb250YWlucyBhIGNvbmZpZ3VyYXRpb24gdG9rZW4sIHRoZSBuZXR3b3JrIGlzIGFkZGVkIHRvCit3cGFfc3VwcGxpY2FudCBjb25maWd1cmF0aW9uLiBJZiB0aGUgTkZDIHRhZyBjb250YWlucyBhIHBhc3N3b3JkIHRva2VuLAordGhlIHRva2VuIGlzIGFkZGVkIHRvIHRoZSBXUFMgUmVnaXN0cmFyIGNvbXBvbmVudC4gVGhpcyBpbmZvcm1hdGlvbiBjYW4KK3RoZW4gYmUgdXNlZCB3aXRoIHdwc19yZWcgY29tbWFuZCAod2hlbiB0aGUgTkZDIHBhc3N3b3JkIHRva2VuIHdhcyBmcm9tCithbiBBUCkgdXNpbmcgYSBzcGVjaWFsIHZhbHVlICJuZmMtcHciIGluIHBsYWNlIG9mIHRoZSBQSU4gcGFyYW1ldGVyLiBJZgordGhlIEVSIGZ1bmN0aW9uYWxpdHkgaGFzIGJlZW4gc3RhcnRlZCAod3BzX2VyX3N0YXJ0KSwgdGhlIE5GQyBwYXNzd29yZAordG9rZW4gaXMgdXNlZCB0byBlbmFibGUgZW5yb2xsbWVudCBvZiBhIG5ldyBzdGF0aW9uICh0aGF0IHdhcyB0aGUgc291cmNlCitvZiB0aGUgTkZDIHBhc3N3b3JkIHRva2VuKS4KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L1JFQURNRS1XaW5kb3dzLnR4dCBiL3dwYV9zdXBwbGljYW50L1JFQURNRS1XaW5kb3dzLnR4dAppbmRleCAyOTIyMjNkLi43Mjg4YWJkIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9SRUFETUUtV2luZG93cy50eHQKKysrIGIvd3BhX3N1cHBsaWNhbnQvUkVBRE1FLVdpbmRvd3MudHh0CkBAIC00LDEzICs0LDggQEAKIENvcHlyaWdodCAoYykgMjAwMy0yMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPiBhbmQgY29udHJpYnV0b3JzCiBBbGwgUmlnaHRzIFJlc2VydmVkLgogCi1UaGlzIHByb2dyYW0gaXMgZHVhbC1saWNlbnNlZCB1bmRlciBib3RoIHRoZSBHUEwgdmVyc2lvbiAyIGFuZCBCU0QKLWxpY2Vuc2UuIEVpdGhlciBsaWNlbnNlIG1heSBiZSB1c2VkIGF0IHlvdXIgb3B0aW9uLgotCi1UaGlzIHByb2R1Y3QgaW5jbHVkZXMgc29mdHdhcmUgZGV2ZWxvcGVkIGJ5IHRoZSBPcGVuU1NMIFByb2plY3QKLWZvciB1c2UgaW4gdGhlIE9wZW5TU0wgVG9vbGtpdCAoaHR0cDovL3d3dy5vcGVuc3NsLm9yZy8pLiBUaGlzCi1wcm9kdWN0IGluY2x1ZGVzIGNyeXB0b2dyYXBoaWMgc29mdHdhcmUgd3JpdHRlbiBieSBFcmljIFlvdW5nCi0oZWF5QGNyeXB0c29mdC5jb20pLgorVGhpcyBwcm9ncmFtIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBCU0QgbGljZW5zZSAodGhlIG9uZSB3aXRoCithZHZlcnRpc2VtZW50IGNsYXVzZSByZW1vdmVkKS4KIAogCiB3cGFfc3VwcGxpY2FudCBoYXMgc3VwcG9ydCBmb3IgYmVpbmcgdXNlZCBhcyBhIFdQQS9XUEEyL0lFRUUgODAyLjFYCkBAIC0zNSwyMCArMzAsNiBAQAogLSBXUEEyLUVBUCwgVEtJUCwgQ0NNUCwgVEtJUCtDQ01QCiAKIAotQmluYXJ5IHZlcnNpb24KLS0tLS0tLS0tLS0tLS0tCi0KLUNvbXBpbGVkIGJpbmFyeSB2ZXJzaW9uIG9mIHRoZSB3cGFfc3VwcGxpY2FudCBhbmQgYWRkaXRpb25hbCB0b29scyBpcwotYXZhaWxhYmxlIGZyb20gaHR0cDovL3cxLmZpL3dwYV9zdXBwbGljYW50Ly4gVGhlc2UgYmluYXJpZXMgY2FuIGJlCi11c2VkIGFmdGVyIGluc3RhbGxpbmcgV2luUGNhcC4KLQotd3BhX2d1aSB1c2VzIFF0IDQgZnJhbWV3b3JrIGFuZCBtYXkgbmVlZCBhZGRpdGlvbmFsIGR5bmFtaWMgbGlicmFyaWVzCi0oRExMcykuIFRoZXNlIGxpYnJhcmllcyBhcmUgYXZhaWxhYmxlIGZyb20KLWh0dHA6Ly93MS5maS93cGFfc3VwcGxpY2FudC9xdDQvd3BhX2d1aS1xdDQzMy13aW5kb3dzLWRsbC56aXAKLVlvdSBjYW4gY29weSB0aGUgRExMIGZpbGVzIGZyb20gdGhpcyBaSVAgcGFja2FnZSBpbnRvIHRoZSBzYW1lIGRpcmVjdG9yeQotd2l0aCB3cGFfZ3VpLmV4ZSB0byBhbGxvdyB3cGFfZ3VpIHRvIGJlIHN0YXJ0ZWQuCi0KLQogQnVpbGRpbmcgd3BhX3N1cHBsaWNhbnQgd2l0aCBtaW5ndwogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCkBAIC0zMTYsMTM1ICsyOTcsMyBAQAogU2VlIHdpbl9leGFtcGxlLnJlZyBmb3IgYW4gZXhhbXBsZSBvbiBob3cgdG8gc2V0dXAgd3Bhc3ZjLmV4ZQogcGFyYW1ldGVycyBpbiByZWdpc3RyeS4gSXQgY2FuIGFsc28gYmUgaW1wb3J0ZWQgdG8gcmVnaXN0cnkgYXMgYQogc3RhcnRpbmcgcG9pbnQgZm9yIHRoZSBjb25maWd1cmF0aW9uLgotCi0KLQotTGljZW5zZSBpbmZvcm1hdGlvbiBmb3IgdGhpcmQgcGFydHkgc29mdHdhcmUgdXNlZCBpbiB0aGlzIHByb2R1Y3Q6Ci0KLSAgT3BlblNTTCBMaWNlbnNlCi0gIC0tLS0tLS0tLS0tLS0tLQotCi0vKiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotICogQ29weXJpZ2h0IChjKSAxOTk4LTIwMDQgVGhlIE9wZW5TU0wgUHJvamVjdC4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4gCi0gKgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbgotICogICAgdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQotICogICAgZGlzdHJpYnV0aW9uLgotICoKLSAqIDMuIEFsbCBhZHZlcnRpc2luZyBtYXRlcmlhbHMgbWVudGlvbmluZyBmZWF0dXJlcyBvciB1c2Ugb2YgdGhpcwotICogICAgc29mdHdhcmUgbXVzdCBkaXNwbGF5IHRoZSBmb2xsb3dpbmcgYWNrbm93bGVkZ21lbnQ6Ci0gKiAgICAiVGhpcyBwcm9kdWN0IGluY2x1ZGVzIHNvZnR3YXJlIGRldmVsb3BlZCBieSB0aGUgT3BlblNTTCBQcm9qZWN0Ci0gKiAgICBmb3IgdXNlIGluIHRoZSBPcGVuU1NMIFRvb2xraXQuIChodHRwOi8vd3d3Lm9wZW5zc2wub3JnLykiCi0gKgotICogNC4gVGhlIG5hbWVzICJPcGVuU1NMIFRvb2xraXQiIGFuZCAiT3BlblNTTCBQcm9qZWN0IiBtdXN0IG5vdCBiZSB1c2VkIHRvCi0gKiAgICBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tIHRoaXMgc29mdHdhcmUgd2l0aG91dAotICogICAgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLiBGb3Igd3JpdHRlbiBwZXJtaXNzaW9uLCBwbGVhc2UgY29udGFjdAotICogICAgb3BlbnNzbC1jb3JlQG9wZW5zc2wub3JnLgotICoKLSAqIDUuIFByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzIHNvZnR3YXJlIG1heSBub3QgYmUgY2FsbGVkICJPcGVuU1NMIgotICogICAgbm9yIG1heSAiT3BlblNTTCIgYXBwZWFyIGluIHRoZWlyIG5hbWVzIHdpdGhvdXQgcHJpb3Igd3JpdHRlbgotICogICAgcGVybWlzc2lvbiBvZiB0aGUgT3BlblNTTCBQcm9qZWN0LgotICoKLSAqIDYuIFJlZGlzdHJpYnV0aW9ucyBvZiBhbnkgZm9ybSB3aGF0c29ldmVyIG11c3QgcmV0YWluIHRoZSBmb2xsb3dpbmcKLSAqICAgIGFja25vd2xlZGdtZW50OgotICogICAgIlRoaXMgcHJvZHVjdCBpbmNsdWRlcyBzb2Z0d2FyZSBkZXZlbG9wZWQgYnkgdGhlIE9wZW5TU0wgUHJvamVjdAotICogICAgZm9yIHVzZSBpbiB0aGUgT3BlblNTTCBUb29sa2l0IChodHRwOi8vd3d3Lm9wZW5zc2wub3JnLykiCi0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgT3BlblNTTCBQUk9KRUNUIGBgQVMgSVMnJyBBTkQgQU5ZCi0gKiBFWFBSRVNTRUQgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCi0gKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKLSAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgT3BlblNTTCBQUk9KRUNUIE9SCi0gKiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCi0gKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQKLSAqIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOwotICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikKLSAqIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwKLSAqIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKLSAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQKLSAqIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0gKgotICogVGhpcyBwcm9kdWN0IGluY2x1ZGVzIGNyeXB0b2dyYXBoaWMgc29mdHdhcmUgd3JpdHRlbiBieSBFcmljIFlvdW5nCi0gKiAoZWF5QGNyeXB0c29mdC5jb20pLiAgVGhpcyBwcm9kdWN0IGluY2x1ZGVzIHNvZnR3YXJlIHdyaXR0ZW4gYnkgVGltCi0gKiBIdWRzb24gKHRqaEBjcnlwdHNvZnQuY29tKS4KLSAqCi0gKi8KLQotIE9yaWdpbmFsIFNTTGVheSBMaWNlbnNlCi0gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQotLyogQ29weXJpZ2h0IChDKSAxOTk1LTE5OTggRXJpYyBZb3VuZyAoZWF5QGNyeXB0c29mdC5jb20pCi0gKiBBbGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFRoaXMgcGFja2FnZSBpcyBhbiBTU0wgaW1wbGVtZW50YXRpb24gd3JpdHRlbgotICogYnkgRXJpYyBZb3VuZyAoZWF5QGNyeXB0c29mdC5jb20pLgotICogVGhlIGltcGxlbWVudGF0aW9uIHdhcyB3cml0dGVuIHNvIGFzIHRvIGNvbmZvcm0gd2l0aCBOZXRzY2FwZXMgU1NMLgotICogCi0gKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBmb3IgY29tbWVyY2lhbCBhbmQgbm9uLWNvbW1lcmNpYWwgdXNlIGFzIGxvbmcgYXMKLSAqIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUgYWhlYXJlZCB0by4gIFRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwotICogYXBwbHkgdG8gYWxsIGNvZGUgZm91bmQgaW4gdGhpcyBkaXN0cmlidXRpb24sIGJlIGl0IHRoZSBSQzQsIFJTQSwKLSAqIGxoYXNoLCBERVMsIGV0Yy4sIGNvZGU7IG5vdCBqdXN0IHRoZSBTU0wgY29kZS4gIFRoZSBTU0wgZG9jdW1lbnRhdGlvbgotICogaW5jbHVkZWQgd2l0aCB0aGlzIGRpc3RyaWJ1dGlvbiBpcyBjb3ZlcmVkIGJ5IHRoZSBzYW1lIGNvcHlyaWdodCB0ZXJtcwotICogZXhjZXB0IHRoYXQgdGhlIGhvbGRlciBpcyBUaW0gSHVkc29uICh0amhAY3J5cHRzb2Z0LmNvbSkuCi0gKiAKLSAqIENvcHlyaWdodCByZW1haW5zIEVyaWMgWW91bmcncywgYW5kIGFzIHN1Y2ggYW55IENvcHlyaWdodCBub3RpY2VzIGluCi0gKiB0aGUgY29kZSBhcmUgbm90IHRvIGJlIHJlbW92ZWQuCi0gKiBJZiB0aGlzIHBhY2thZ2UgaXMgdXNlZCBpbiBhIHByb2R1Y3QsIEVyaWMgWW91bmcgc2hvdWxkIGJlIGdpdmVuIGF0dHJpYnV0aW9uCi0gKiBhcyB0aGUgYXV0aG9yIG9mIHRoZSBwYXJ0cyBvZiB0aGUgbGlicmFyeSB1c2VkLgotICogVGhpcyBjYW4gYmUgaW4gdGhlIGZvcm0gb2YgYSB0ZXh0dWFsIG1lc3NhZ2UgYXQgcHJvZ3JhbSBzdGFydHVwIG9yCi0gKiBpbiBkb2N1bWVudGF0aW9uIChvbmxpbmUgb3IgdGV4dHVhbCkgcHJvdmlkZWQgd2l0aCB0aGUgcGFja2FnZS4KLSAqIAotICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKiAzLiBBbGwgYWR2ZXJ0aXNpbmcgbWF0ZXJpYWxzIG1lbnRpb25pbmcgZmVhdHVyZXMgb3IgdXNlIG9mIHRoaXMgc29mdHdhcmUKLSAqICAgIG11c3QgZGlzcGxheSB0aGUgZm9sbG93aW5nIGFja25vd2xlZGdlbWVudDoKLSAqICAgICJUaGlzIHByb2R1Y3QgaW5jbHVkZXMgY3J5cHRvZ3JhcGhpYyBzb2Z0d2FyZSB3cml0dGVuIGJ5Ci0gKiAgICAgRXJpYyBZb3VuZyAoZWF5QGNyeXB0c29mdC5jb20pIgotICogICAgVGhlIHdvcmQgJ2NyeXB0b2dyYXBoaWMnIGNhbiBiZSBsZWZ0IG91dCBpZiB0aGUgcm91aW5lcyBmcm9tIHRoZSBsaWJyYXJ5Ci0gKiAgICBiZWluZyB1c2VkIGFyZSBub3QgY3J5cHRvZ3JhcGhpYyByZWxhdGVkIDotKS4KLSAqIDQuIElmIHlvdSBpbmNsdWRlIGFueSBXaW5kb3dzIHNwZWNpZmljIGNvZGUgKG9yIGEgZGVyaXZhdGl2ZSB0aGVyZW9mKSBmcm9tIAotICogICAgdGhlIGFwcHMgZGlyZWN0b3J5IChhcHBsaWNhdGlvbiBjb2RlKSB5b3UgbXVzdCBpbmNsdWRlIGFuIGFja25vd2xlZGdlbWVudDoKLSAqICAgICJUaGlzIHByb2R1Y3QgaW5jbHVkZXMgc29mdHdhcmUgd3JpdHRlbiBieSBUaW0gSHVkc29uICh0amhAY3J5cHRzb2Z0LmNvbSkiCi0gKiAKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgRVJJQyBZT1VORyBgYEFTIElTJycgQU5ECi0gKiBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFCi0gKiBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBBVVRIT1IgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRQotICogRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwKLSAqIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTCi0gKiBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikKLSAqIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUCi0gKiBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZCi0gKiBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GCi0gKiBTVUNIIERBTUFHRS4KLSAqIAotICogVGhlIGxpY2VuY2UgYW5kIGRpc3RyaWJ1dGlvbiB0ZXJtcyBmb3IgYW55IHB1YmxpY2FsbHkgYXZhaWxhYmxlIHZlcnNpb24gb3IKLSAqIGRlcml2YXRpdmUgb2YgdGhpcyBjb2RlIGNhbm5vdCBiZSBjaGFuZ2VkLiAgaS5lLiB0aGlzIGNvZGUgY2Fubm90IHNpbXBseSBiZQotICogY29waWVkIGFuZCBwdXQgdW5kZXIgYW5vdGhlciBkaXN0cmlidXRpb24gbGljZW5jZQotICogW2luY2x1ZGluZyB0aGUgR05VIFB1YmxpYyBMaWNlbmNlLl0KLSAqLwotCi0KLQotICAgUXQgT3BlbiBTb3VyY2UgRWRpdGlvbgotICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCi1UaGUgUXQgR1VJIFRvb2xraXQgaXMgQ29weXJpZ2h0IChDKSAxOTk0LTIwMDcgVHJvbGx0ZWNoIEFTQS4KLVF0IE9wZW4gU291cmNlIEVkaXRpb24gaXMgbGljZW5zZWQgdW5kZXIgR1BMIHZlcnNpb24gMi4KLQotU291cmNlIGNvZGUgZm9yIHRoZSBsaWJyYXJ5IGlzIGF2YWlsYWJsZSBhdAotaHR0cDovL3cxLmZpL3dwYV9zdXBwbGljYW50L3F0NC9xdC13aW4tb3BlbnNvdXJjZS1zcmMtNC4zLjMuemlwCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9hbmRyb2lkLmNvbmZpZyBiL3dwYV9zdXBwbGljYW50L2FuZHJvaWQuY29uZmlnCmluZGV4IDVhYTRmY2MuLmZjMDYxNGQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2FuZHJvaWQuY29uZmlnCisrKyBiL3dwYV9zdXBwbGljYW50L2FuZHJvaWQuY29uZmlnCkBAIC01NSwxMSArNTUsNiBAQAogIyBTZXQgaW5jbHVkZSBkaXJlY3RvcnkgdG8gdGhlIG1hZHdpZmkgc291cmNlIHRyZWUKICNDRkxBR1MgKz0gLUkuLi8uLi9tYWR3aWZpCiAKLSMgRHJpdmVyIGludGVyZmFjZSBmb3IgUHJpc201NCBkcml2ZXIKLSMgKE5vdGU6IFByaXNtNTQgaXMgbm90IHlldCBzdXBwb3J0ZWQsIGkuZS4sIHRoaXMgd2lsbCBub3Qgd29yayBhcy1pcyBhbmQgaXMKLSMgZm9yIGRldmVsb3BlcnMgb25seSkKLSNDT05GSUdfRFJJVkVSX1BSSVNNNTQ9eQotCiAjIERyaXZlciBpbnRlcmZhY2UgZm9yIG5kaXN3cmFwcGVyCiAjIERlcHJlY2F0ZWQ7IHVzZSBDT05GSUdfRFJJVkVSX1dFWFQ9eSBpbnN0ZWFkLgogI0NPTkZJR19EUklWRVJfTkRJU1dSQVBQRVI9eQpAQCAtODMsNiArNzgsMTEgQEAKICNDT05GSUdfRFJJVkVSX1JBTElOSz15CiAKICMgRHJpdmVyIGludGVyZmFjZSBmb3IgZ2VuZXJpYyBMaW51eCB3aXJlbGVzcyBleHRlbnNpb25zCisjIE5vdGU6IFdFWFQgaXMgZGVwcmVjYXRlZCBpbiB0aGUgY3VycmVudCBMaW51eCBrZXJuZWwgdmVyc2lvbiBhbmQgbm8gbmV3CisjIGZ1bmN0aW9uYWxpdHkgaXMgYWRkZWQgdG8gaXQuIG5sODAyMTEtYmFzZWQgaW50ZXJmYWNlIGlzIHRoZSBuZXcKKyMgcmVwbGFjZW1lbnQgZm9yIFdFWFQgYW5kIGl0cyB1c2UgYWxsb3dzIHdwYV9zdXBwbGljYW50IHRvIHByb3Blcmx5IGNvbnRyb2wKKyMgdGhlIGRyaXZlciB0byBpbXByb3ZlIGV4aXN0aW5nIGZ1bmN0aW9uYWxpdHkgbGlrZSByb2FtaW5nIGFuZCB0byBzdXBwb3J0IG5ldworIyBmdW5jdGlvbmFsaXR5LgogI0NPTkZJR19EUklWRVJfV0VYVD15CiAKICMgRHJpdmVyIGludGVyZmFjZSBmb3IgTGludXggZHJpdmVycyB1c2luZyB0aGUgbmw4MDIxMSBrZXJuZWwgaW50ZXJmYWNlCkBAIC05Myw2ICs5Myw4IEBACiAjQ09ORklHX0RSSVZFUl9CU0Q9eQogI0NGTEFHUyArPSAtSS91c3IvbG9jYWwvaW5jbHVkZQogI0xJQlMgKz0gLUwvdXNyL2xvY2FsL2xpYgorI0xJQlNfcCArPSAtTC91c3IvbG9jYWwvbGliCisjTElCU19jICs9IC1ML3Vzci9sb2NhbC9saWIKIAogIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBXaW5kb3dzIE5ESVMKICNDT05GSUdfRFJJVkVSX05ESVM9eQpAQCAtMTEzLDExICsxMTUsNiBAQAogIyBEcml2ZXIgaW50ZXJmYWNlIGZvciBkZXZlbG9wbWVudCB0ZXN0aW5nCiAjQ09ORklHX0RSSVZFUl9URVNUPXkKIAotIyBJbmNsdWRlIGNsaWVudCBNTE1FIChtYW5hZ2VtZW50IGZyYW1lIHByb2Nlc3NpbmcpIGZvciB0ZXN0IGRyaXZlcgotIyBUaGlzIGNhbiBiZSB1c2VkIHRvIHRlc3QgTUxNRSBvcGVyYXRpb25zIGluIGhvc3RhcGQgd2l0aCB0aGUgdGVzdCBpbnRlcmZhY2UuCi0jIHNwYWNlLgotI0NPTkZJR19DTElFTlRfTUxNRT15Ci0KICMgRHJpdmVyIGludGVyZmFjZSBmb3Igd2lyZWQgRXRoZXJuZXQgZHJpdmVycwogI0NPTkZJR19EUklWRVJfV0lSRUQ9eQogCkBAIC0xMjcsNiArMTI0LDEwIEBACiAjIERyaXZlciBpbnRlcmZhY2UgZm9yIG5vIGRyaXZlciAoZS5nLiwgV1BTIEVSIG9ubHkpCiAjQ09ORklHX0RSSVZFUl9OT05FPXkKIAorIyBTb2xhcmlzIGxpYnJhcmllcworI0xJQlMgKz0gLWxzb2NrZXQgLWxkbHBpIC1sbnNsCisjTElCU19jICs9IC1sc29ja2V0CisKICMgRW5hYmxlIElFRUUgODAyLjFYIFN1cHBsaWNhbnQgKGF1dG9tYXRpY2FsbHkgaW5jbHVkZWQgaWYgYW55IEVBUCBtZXRob2QgaXMKICMgaW5jbHVkZWQpCiBDT05GSUdfSUVFRTgwMjFYX0VBUE9MPXkKQEAgLTE2NSw2ICsxNjYsOSBAQAogIyBFQVAtUFNLIChleHBlcmltZW50YWw7IHRoaXMgaXMgX25vdF8gbmVlZGVkIGZvciBXUEEtUFNLKQogI0NPTkZJR19FQVBfUFNLPXkKIAorIyBFQVAtcHdkIChzZWN1cmUgYXV0aGVudGljYXRpb24gdXNpbmcgb25seSBhIHBhc3N3b3JkKQorQ09ORklHX0VBUF9QV0Q9eQorCiAjIEVBUC1QQVgKICNDT05GSUdfRUFQX1BBWD15CiAKQEAgLTE5NiwxMyArMjAwLDE1IEBACiBDT05GSUdfV1BTPXkKICMgRW5hYmxlIFdTQyAyLjAgc3VwcG9ydAogQ09ORklHX1dQUzI9eQorIyBFbmFibGUgV1BTIGV4dGVybmFsIHJlZ2lzdHJhciBmdW5jdGlvbmFsaXR5CisjQ09ORklHX1dQU19FUj15CisjIERpc2FibGUgY3JlZGVudGlhbHMgZm9yIGFuIG9wZW4gbmV0d29yayBieSBkZWZhdWx0IHdoZW4gYWN0aW5nIGFzIGEgV1BTCisjIHJlZ2lzdHJhci4KKyNDT05GSUdfV1BTX1JFR19ESVNBQkxFX09QRU49eQogCiAjIEVBUC1JS0V2MgogI0NPTkZJR19FQVBfSUtFVjI9eQogCi0jIEVBUC1QV0QKLUNPTkZJR19FQVBfUFdEPXkKLQogIyBQS0NTIzEyIChQRlgpIHN1cHBvcnQgKHVzZWQgdG8gcmVhZCBwcml2YXRlIGtleSBhbmQgY2VydGlmaWNhdGUgZmlsZSBmcm9tCiAjIGEgZmlsZSB0aGF0IHVzdWFsbHkgaGFzIGV4dGVuc2lvbiAucDEyIG9yIC5wZngpCiBDT05GSUdfUEtDUzEyPXkKQEAgLTIxNSw2ICsyMjEsOSBAQAogIyBFbmFibGUgdGhpcyBpZiBFQVAtU0lNIG9yIEVBUC1BS0EgaXMgaW5jbHVkZWQKICNDT05GSUdfUENTQz15CiAKKyMgU3VwcG9ydCBIVCBvdmVycmlkZXMgKGRpc2FibGUgSFQvSFQ0MCwgbWFzayBNQ1MgcmF0ZXMsIGV0Yy4pCisjQ09ORklHX0hUX09WRVJSSURFUz15CisKICMgRGV2ZWxvcG1lbnQgdGVzdGluZwogI0NPTkZJR19FQVBPTF9URVNUPXkKIApAQCAtMjMzLDYgKzI0MiwxMCBAQAogIyB0aGUgcmVzdWx0aW5nIGJpbmFyeS4KICNDT05GSUdfUkVBRExJTkU9eQogCisjIEluY2x1ZGUgaW50ZXJuYWwgbGluZSBlZGl0IG1vZGUgaW4gd3BhX2NsaS4gVGhpcyBjYW4gYmUgdXNlZCBhcyBhIHJlcGxhY2VtZW50CisjIGZvciBHTlUgUmVhZGxpbmUgdG8gcHJvdmlkZSBsaW1pdGVkIGNvbW1hbmQgbGluZSBlZGl0aW5nIGFuZCBoaXN0b3J5IHN1cHBvcnQuCitDT05GSUdfV1BBX0NMSV9FRElUPXkKKwogIyBSZW1vdmUgZGVidWdnaW5nIGNvZGUgdGhhdCBpcyBwcmludGluZyBvdXQgZGVidWcgbWVzc2FnZSB0byBzdGRvdXQuCiAjIFRoaXMgY2FuIGJlIHVzZWQgdG8gcmVkdWNlIHRoZSBzaXplIG9mIHRoZSB3cGFfc3VwcGxpY2FudCBjb25zaWRlcmFibHkKICMgaWYgZGVidWdnaW5nIGNvZGUgaXMgbm90IG5lZWRlZC4gVGhlIHNpemUgcmVkdWN0aW9uIGNhbiBiZSBhcm91bmQgMzUlCkBAIC0yOTQsNiArMzA3LDkgQEAKICMgZWxvb3Bfbm9uZSA9IEVtcHR5IHRlbXBsYXRlCiBDT05GSUdfRUxPT1A9ZWxvb3AKIAorIyBTaG91bGQgd2UgdXNlIHBvbGwgaW5zdGVhZCBvZiBzZWxlY3Q/IFNlbGVjdCBpcyB1c2VkIGJ5IGRlZmF1bHQuCisjQ09ORklHX0VMT09QX1BPTEw9eQorCiAjIFNlbGVjdCBsYXllciAyIHBhY2tldCBpbXBsZW1lbnRhdGlvbgogIyBsaW51eCA9IExpbnV4IHBhY2tldCBzb2NrZXQgKGRlZmF1bHQpCiAjIHBjYXAgPSBsaWJwY2FwL2xpYmRuZXQvV2luUGNhcApAQCAtMzE0LDE4ICszMzAsMjQgQEAKIAogIyBTZWxlY3QgVExTIGltcGxlbWVudGF0aW9uCiAjIG9wZW5zc2wgPSBPcGVuU1NMIChkZWZhdWx0KQotIyBnbnV0bHMgPSBHbnVUTFMgKG5lZWRlZCBmb3IgVExTL0lBLCBzZWUgYWxzbyBDT05GSUdfR05VVExTX0VYVFJBKQorIyBnbnV0bHMgPSBHbnVUTFMKICMgaW50ZXJuYWwgPSBJbnRlcm5hbCBUTFN2MSBpbXBsZW1lbnRhdGlvbiAoZXhwZXJpbWVudGFsKQogIyBub25lID0gRW1wdHkgdGVtcGxhdGUKICNDT05GSUdfVExTPW9wZW5zc2wKIAotIyBXaGV0aGVyIHRvIGVuYWJsZSBUTFMvSUEgc3VwcG9ydCwgd2hpY2ggaXMgcmVxdWlyZWQgZm9yIEVBUC1UVExTdjEuCi0jIFlvdSBuZWVkIENPTkZJR19UTFM9Z251dGxzIGZvciB0aGlzIHRvIGhhdmUgYW55IGVmZmVjdC4gUGxlYXNlIG5vdGUgdGhhdAotIyBldmVuIHRob3VnaCB0aGUgY29yZSBHbnVUTFMgbGlicmFyeSBpcyByZWxlYXNlZCB1bmRlciBMR1BMLCB0aGlzIGV4dHJhCi0jIGxpYnJhcnkgdXNlcyBHUEwgYW5kIGFzIHN1Y2gsIHRoZSB0ZXJtcyBvZiBHUEwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uCi0jIG9mIHdwYV9zdXBwbGljYW50IGFuZCBHbnVUTFMgaWYgdGhpcyBvcHRpb24gaXMgZW5hYmxlZC4gQlNEIGxpY2Vuc2UgbWF5IG5vdAotIyBhcHBseSBmb3IgZGlzdHJpYnV0aW9uIG9mIHRoZSByZXN1bHRpbmcgYmluYXJ5LgotI0NPTkZJR19HTlVUTFNfRVhUUkE9eQorIyBUTFMtYmFzZWQgRUFQIG1ldGhvZHMgcmVxdWlyZSBhdCBsZWFzdCBUTFMgdjEuMC4gTmV3ZXIgdmVyc2lvbiBvZiBUTFMgKHYxLjEpCisjIGNhbiBiZSBlbmFibGVkIHRvIGdldCBhIHN0cm9uZ2VyIGNvbnN0cnVjdGlvbiBvZiBtZXNzYWdlcyB3aGVuIGJsb2NrIGNpcGhlcnMKKyMgYXJlIHVzZWQuIEl0IHNob3VsZCBiZSBub3RlZCB0aGF0IHNvbWUgZXhpc3RpbmcgVExTIHYxLjAgLWJhc2VkCisjIGltcGxlbWVudGF0aW9uIG1heSBub3QgYmUgY29tcGF0aWJsZSB3aXRoIFRMUyB2MS4xIG1lc3NhZ2UgKENsaWVudEhlbGxvIGlzCisjIHNlbnQgcHJpb3IgdG8gbmVnb3RpYXRpbmcgd2hpY2ggdmVyc2lvbiB3aWxsIGJlIHVzZWQpCisjQ09ORklHX1RMU1YxMT15CisKKyMgVExTLWJhc2VkIEVBUCBtZXRob2RzIHJlcXVpcmUgYXQgbGVhc3QgVExTIHYxLjAuIE5ld2VyIHZlcnNpb24gb2YgVExTICh2MS4yKQorIyBjYW4gYmUgZW5hYmxlZCB0byBlbmFibGUgdXNlIG9mIHN0cm9uZ2VyIGNyeXB0byBhbGdvcml0aG1zLiBJdCBzaG91bGQgYmUKKyMgbm90ZWQgdGhhdCBzb21lIGV4aXN0aW5nIFRMUyB2MS4wIC1iYXNlZCBpbXBsZW1lbnRhdGlvbiBtYXkgbm90IGJlIGNvbXBhdGlibGUKKyMgd2l0aCBUTFMgdjEuMiBtZXNzYWdlIChDbGllbnRIZWxsbyBpcyBzZW50IHByaW9yIHRvIG5lZ290aWF0aW5nIHdoaWNoIHZlcnNpb24KKyMgd2lsbCBiZSB1c2VkKQorI0NPTkZJR19UTFNWMTI9eQogCiAjIElmIENPTkZJR19UTFM9aW50ZXJuYWwgaXMgdXNlZCwgYWRkaXRpb25hbCBsaWJyYXJ5IGFuZCBpbmNsdWRlIHBhdGhzIGFyZQogIyBuZWVkZWQgZm9yIExpYlRvbU1hdGguIEFsdGVybmF0aXZlbHksIGFuIGludGVncmF0ZWQsIG1pbmltYWwgdmVyc2lvbiBvZgpAQCAtMzU3LDcgKzM3OSw3IEBACiAjIChmaS53MS5ob3N0YXAud3BhX3N1cHBsaWNhbnQxKQogI0NPTkZJR19DVFJMX0lGQUNFX0RCVVNfTkVXPXkKIAotIyBBZGQgaW50cm9zcGVjdGlvbiBzdXBwb3J0IGZvciBuZXcgREJ1cyBjb250cm9sIGludGVyZmFjZSAocmVxdWlyZXMgbGlieG1sMikKKyMgQWRkIGludHJvc3BlY3Rpb24gc3VwcG9ydCBmb3IgbmV3IERCdXMgY29udHJvbCBpbnRlcmZhY2UKICNDT05GSUdfQ1RSTF9JRkFDRV9EQlVTX0lOVFJPPXkKIAogIyBBZGQgc3VwcG9ydCBmb3IgbG9hZGluZyBFQVAgbWV0aG9kcyBkeW5hbWljYWxseSBhcyBzaGFyZWQgbGlicmFyaWVzLgpAQCAtMzg3LDcgKzQwOSwxOSBAQAogIyBBZGQgc3VwcG9ydCBmb3Igd3JpdGluZyBkZWJ1ZyBsb2cgdG8gYSBmaWxlICgvdG1wL3dwYV9zdXBwbGljYW50LWxvZy0jLnR4dCkKICNDT05GSUdfREVCVUdfRklMRT15CiAKLSMgQWRkIHN1cHBvcnQgZm9yIHdyaXRpbmcgZGVidWcgbG9nIHRvIEFuZHJvaWQgbG9nY2F0IGluc3RlYWQgb2Ygc3RhbmRhcmQgb3V0cHV0CisjIFNlbmQgZGVidWcgbWVzc2FnZXMgdG8gc3lzbG9nIGluc3RlYWQgb2Ygc3Rkb3V0CisjQ09ORklHX0RFQlVHX1NZU0xPRz15CisjIFNldCBzeXNsb2cgZmFjaWxpdHkgZm9yIGRlYnVnIG1lc3NhZ2VzCisjQ09ORklHX0RFQlVHX1NZU0xPR19GQUNJTElUWT1MT0dfREFFTU9OCisKKyMgQWRkIHN1cHBvcnQgZm9yIHNlbmRpbmcgYWxsIGRlYnVnIG1lc3NhZ2VzIChyZWdhcmRsZXNzIG9mIGRlYnVnIHZlcmJvc2l0eSkKKyMgdG8gdGhlIExpbnV4IGtlcm5lbCB0cmFjaW5nIGZhY2lsaXR5LiBUaGlzIGhlbHBzIGRlYnVnIHRoZSBlbnRpcmUgc3RhY2sgYnkKKyMgbWFraW5nIGl0IGVhc3kgdG8gcmVjb3JkIGV2ZXJ5dGhpbmcgaGFwcGVuaW5nIGZyb20gdGhlIGRyaXZlciB1cCBpbnRvIHRoZQorIyBzYW1lIGZpbGUsIGUuZy4sIHVzaW5nIHRyYWNlLWNtZC4KKyNDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORz15CisKKyMgQWRkIHN1cHBvcnQgZm9yIHdyaXRpbmcgZGVidWcgbG9nIHRvIEFuZHJvaWQgbG9nY2F0IGluc3RlYWQgb2Ygc3RhbmRhcmQKKyMgb3V0cHV0CiBDT05GSUdfQU5EUk9JRF9MT0c9eQogCiAjIEVuYWJsZSBwcml2aWxlZ2Ugc2VwYXJhdGlvbiAoc2VlIFJFQURNRSAnUHJpdmlsZWdlIHNlcGFyYXRpb24nIGZvciBkZXRhaWxzKQpAQCAtMzk3LDExICs0MzEsNjcgQEAKICMgTUlDIGVycm9yIHJlcG9ydHMgYnkgYSByYW5kb20gYW1vdW50IG9mIHRpbWUgYmV0d2VlbiAwIGFuZCA2MCBzZWNvbmRzCiAjQ09ORklHX0RFTEFZRURfTUlDX0VSUk9SX1JFUE9SVD15CiAKKyMgRW5hYmxlIHRyYWNpbmcgY29kZSBmb3IgZGV2ZWxvcGVyIGRlYnVnZ2luZworIyBUaGlzIHRyYWNrcyB1c2Ugb2YgbWVtb3J5IGFsbG9jYXRpb25zIGFuZCBvdGhlciByZWdpc3RyYXRpb25zIGFuZCByZXBvcnRzCisjIGluY29ycmVjdCB1c2Ugd2l0aCBhIGJhY2t0cmFjZSBvZiBjYWxsIChvciBhbGxvY2F0aW9uKSBsb2NhdGlvbi4KKyNDT05GSUdfV1BBX1RSQUNFPXkKKyMgRm9yIEJTRCwgdW5jb21tZW50IHRoZXNlLgorI0xJQlMgKz0gLWxleGVjaW5mbworI0xJQlNfcCArPSAtbGV4ZWNpbmZvCisjTElCU19jICs9IC1sZXhlY2luZm8KKworIyBVc2UgbGliYmZkIHRvIGdldCBtb3JlIGRldGFpbHMgZm9yIGRldmVsb3BlciBkZWJ1Z2dpbmcKKyMgVGhpcyBlbmFibGVzIHVzZSBvZiBsaWJiZmQgdG8gZ2V0IG1vcmUgZGV0YWlsZWQgc3ltYm9scyBmb3IgdGhlIGJhY2t0cmFjZXMKKyMgZ2VuZXJhdGVkIGJ5IENPTkZJR19XUEFfVFJBQ0U9eS4KKyNDT05GSUdfV1BBX1RSQUNFX0JGRD15CisjIEZvciBCU0QsIHVuY29tbWVudCB0aGVzZS4KKyNMSUJTICs9IC1sYmZkIC1saWJlcnR5IC1segorI0xJQlNfcCArPSAtbGJmZCAtbGliZXJ0eSAtbHoKKyNMSUJTX2MgKz0gLWxiZmQgLWxpYmVydHkgLWx6CisKKyMgd3BhX3N1cHBsaWNhbnQgZGVwZW5kcyBvbiBzdHJvbmcgcmFuZG9tIG51bWJlciBnZW5lcmF0aW9uIGJlaW5nIGF2YWlsYWJsZQorIyBmcm9tIHRoZSBvcGVyYXRpbmcgc3lzdGVtLiBvc19nZXRfcmFuZG9tKCkgZnVuY3Rpb24gaXMgdXNlZCB0byBmZXRjaCByYW5kb20KKyMgZGF0YSB3aGVuIG5lZWRlZCwgZS5nLiwgZm9yIGtleSBnZW5lcmF0aW9uLiBPbiBMaW51eCBhbmQgQlNEIHN5c3RlbXMsIHRoaXMKKyMgd29ya3MgYnkgcmVhZGluZyAvZGV2L3VyYW5kb20uIEl0IHNob3VsZCBiZSBub3RlZCB0aGF0IHRoZSBPUyBlbnRyb3B5IHBvb2wKKyMgbmVlZHMgdG8gYmUgcHJvcGVybHkgaW5pdGlhbGl6ZWQgYmVmb3JlIHdwYV9zdXBwbGljYW50IGlzIHN0YXJ0ZWQuIFRoaXMgaXMKKyMgaW1wb3J0YW50IGVzcGVjaWFsbHkgb24gZW1iZWRkZWQgZGV2aWNlcyB0aGF0IGRvIG5vdCBoYXZlIGEgaGFyZHdhcmUgcmFuZG9tCisjIG51bWJlciBnZW5lcmF0b3IgYW5kIG1heSBieSBkZWZhdWx0IHN0YXJ0IHVwIHdpdGggbWluaW1hbCBlbnRyb3B5IGF2YWlsYWJsZQorIyBmb3IgcmFuZG9tIG51bWJlciBnZW5lcmF0aW9uLgorIworIyBBcyBhIHNhZmV0eSBuZXQsIHdwYV9zdXBwbGljYW50IGlzIGJ5IGRlZmF1bHQgdHJ5aW5nIHRvIGludGVybmFsbHkgY29sbGVjdAorIyBhZGRpdGlvbmFsIGVudHJvcHkgZm9yIGdlbmVyYXRpbmcgcmFuZG9tIGRhdGEgdG8gbWl4IGluIHdpdGggdGhlIGRhdGEgZmV0Y2hlZAorIyBmcm9tIHRoZSBPUy4gVGhpcyBieSBpdHNlbGYgaXMgbm90IGNvbnNpZGVyZWQgdG8gYmUgdmVyeSBzdHJvbmcsIGJ1dCBpdCBtYXkKKyMgaGVscCBpbiBjYXNlcyB3aGVyZSB0aGUgc3lzdGVtIHBvb2wgaXMgbm90IGluaXRpYWxpemVkIHByb3Blcmx5LiBIb3dldmVyLCBpdAorIyBpcyB2ZXJ5IHN0cm9uZ2x5IHJlY29tbWVuZGVkIHRoYXQgdGhlIHN5c3RlbSBwb29sIGlzIGluaXRpYWxpemVkIHdpdGggZW5vdWdoCisjIGVudHJvcHkgZWl0aGVyIGJ5IHVzaW5nIGhhcmR3YXJlIGFzc2lzdGVkIHJhbmRvbSBudW1iZXIgZ2VuZXJhdG9yIG9yIGJ5CisjIHN0b3Jpbmcgc3RhdGUgb3ZlciBkZXZpY2UgcmVib290cy4KKyMKKyMgd3BhX3N1cHBsaWNhbnQgY2FuIGJlIGNvbmZpZ3VyZWQgdG8gbWFpbnRhaW4gaXRzIG93biBlbnRyb3B5IHN0b3JlIG92ZXIKKyMgcmVzdGFydHMgdG8gZW5oYW5jZSByYW5kb20gbnVtYmVyIGdlbmVyYXRpb24uIFRoaXMgaXMgbm90IHBlcmZlY3QsIGJ1dCBpdCBpcworIyBtdWNoIG1vcmUgc2VjdXJlIHRoYW4gdXNpbmcgdGhlIHNhbWUgc2VxdWVuY2Ugb2YgcmFuZG9tIG51bWJlcnMgYWZ0ZXIgZXZlcnkKKyMgcmVib290LiBUaGlzIGNhbiBiZSBlbmFibGVkIHdpdGggLWU8ZW50cm9weSBmaWxlPiBjb21tYW5kIGxpbmUgb3B0aW9uLiBUaGUKKyMgc3BlY2lmaWVkIGZpbGUgbmVlZHMgdG8gYmUgcmVhZGFibGUgYW5kIHdyaXRhYmxlIGJ5IHdwYV9zdXBwbGljYW50LgorIworIyBJZiB0aGUgb3NfZ2V0X3JhbmRvbSgpIGlzIGtub3duIHRvIHByb3ZpZGUgc3Ryb25nIHJhbmRvbSBkYXRhIChlLmcuLCBvbgorIyBMaW51eC9CU0QsIHRoZSBib2FyZCBpbiBxdWVzdGlvbiBpcyBrbm93biB0byBoYXZlIHJlbGlhYmxlIHNvdXJjZSBvZiByYW5kb20KKyMgZGF0YSBmcm9tIC9kZXYvdXJhbmRvbSksIHRoZSBpbnRlcm5hbCB3cGFfc3VwcGxpY2FudCByYW5kb20gcG9vbCBjYW4gYmUKKyMgZGlzYWJsZWQuIFRoaXMgd2lsbCBzYXZlIHNvbWUgaW4gYmluYXJ5IHNpemUgYW5kIENQVSB1c2UuIEhvd2V2ZXIsIHRoaXMKKyMgc2hvdWxkIG9ubHkgYmUgY29uc2lkZXJlZCBmb3IgYnVpbGRzIHRoYXQgYXJlIGtub3duIHRvIGJlIHVzZWQgb24gZGV2aWNlcworIyB0aGF0IG1lZXQgdGhlIHJlcXVpcmVtZW50cyBkZXNjcmliZWQgYWJvdmUuCisjQ09ORklHX05PX1JBTkRPTV9QT09MPXkKKworIyBJRUVFIDgwMi4xMW4gKEhpZ2ggVGhyb3VnaHB1dCkgc3VwcG9ydCAobWFpbmx5IGZvciBBUCBtb2RlKQorQ09ORklHX0lFRUU4MDIxMU49eQorCisjIEludGVyd29ya2luZyAoSUVFRSA4MDIuMTF1KQorIyBUaGlzIGNhbiBiZSB1c2VkIHRvIGVuYWJsZSBmdW5jdGlvbmFsaXR5IHRvIGltcHJvdmUgaW50ZXJ3b3JraW5nIHdpdGgKKyMgZXh0ZXJuYWwgbmV0d29ya3MgKEdBUy9BTlFQIHRvIGxlYXJuIG1vcmUgYWJvdXQgdGhlIG5ldHdvcmtzIGFuZCBuZXR3b3JrCisjIHNlbGVjdGlvbiBiYXNlZCBvbiBhdmFpbGFibGUgY3JlZGVudGlhbHMpLgorI0NPTkZJR19JTlRFUldPUktJTkc9eQorCiAjIERpc2FibGUgcm9hbWluZyBpbiB3cGFfc3VwcGxpY2FudAogQ09ORklHX05PX1JPQU1JTkc9eQogCiAjIEVuYWJsZSBQMlAKLSMgSUVFRSA4MDIuMTFuIChIaWdoIFRocm91Z2hwdXQpIHN1cHBvcnQgKG1haW5seSBmb3IgQVAgbW9kZSkKLUNPTkZJR19JRUVFODAyMTFOPXkKIENPTkZJR19QMlA9eQogQ09ORklHX0FQPXkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2FwLmMgYi93cGFfc3VwcGxpY2FudC9hcC5jCmluZGV4IDYwNDYyNDkuLmY5ZTAwNDUgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2FwLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvYXAuYwpAQCAtODEsMTQgKzgxLDIzIEBACiAJICovCiAJaWYgKHdwYV9zLT5ody5tb2RlcykgewogCQlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSA9IE5VTEw7Ci0JCWludCBpOworCQlpbnQgaSwgbm9faHQgPSAwOwogCQlmb3IgKGkgPSAwOyBpIDwgd3BhX3MtPmh3Lm51bV9tb2RlczsgaSsrKSB7CiAJCQlpZiAod3BhX3MtPmh3Lm1vZGVzW2ldLm1vZGUgPT0gY29uZi0+aHdfbW9kZSkgewogCQkJCW1vZGUgPSAmd3BhX3MtPmh3Lm1vZGVzW2ldOwogCQkJCWJyZWFrOwogCQkJfQogCQl9Ci0JCWlmIChtb2RlICYmIG1vZGUtPmh0X2NhcGFiKSB7CisKKyNpZmRlZiBDT05GSUdfSFRfT1ZFUlJJREVTCisJCWlmIChzc2lkLT5kaXNhYmxlX2h0KSB7CisJCQljb25mLT5pZWVlODAyMTFuID0gMDsKKwkJCWNvbmYtPmh0X2NhcGFiID0gMDsKKwkJCW5vX2h0ID0gMTsKKwkJfQorI2VuZGlmIC8qIENPTkZJR19IVF9PVkVSUklERVMgKi8KKworCQlpZiAoIW5vX2h0ICYmIG1vZGUgJiYgbW9kZS0+aHRfY2FwYWIpIHsKIAkJCWNvbmYtPmllZWU4MDIxMW4gPSAxOwogCiAJCQkvKgpAQCAtMTQ1LDYgKzE1NCw4IEBACiAJYnNzLT5zc2lkLnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CiAJYnNzLT5zc2lkLnNzaWRfc2V0ID0gMTsKIAorCWJzcy0+aWdub3JlX2Jyb2FkY2FzdF9zc2lkID0gc3NpZC0+aWdub3JlX2Jyb2FkY2FzdF9zc2lkOworCiAJaWYgKHNzaWQtPmF1dGhfYWxnKQogCQlic3MtPmF1dGhfYWxncyA9IHNzaWQtPmF1dGhfYWxnOwogCkBAIC0xNzksNiArMTkwLDEyIEBACiAJCXdlcC0+a2V5c19zZXQgPSAxOwogCX0KIAorCWlmIChzc2lkLT5hcF9tYXhfaW5hY3Rpdml0eSkKKwkJYnNzLT5hcF9tYXhfaW5hY3Rpdml0eSA9IHNzaWQtPmFwX21heF9pbmFjdGl2aXR5OworCisJaWYgKHNzaWQtPmR0aW1fcGVyaW9kKQorCQlic3MtPmR0aW1fcGVyaW9kID0gc3NpZC0+ZHRpbV9wZXJpb2Q7CisKIAkvKiBTZWxlY3QgZ3JvdXAgY2lwaGVyIGJhc2VkIG9uIHRoZSBlbmFibGVkIHBhaXJ3aXNlIGNpcGhlciBzdWl0ZXMgKi8KIAlwYWlyd2lzZSA9IDA7CiAJaWYgKGJzcy0+d3BhICYgMSkKQEAgLTIzOCw3ICsyNTUsMTAgQEAKIAkJCSAgICAgICogY29uZmlndXJhdGlvbiAqLwogI2VuZGlmIC8qIENPTkZJR19XUFMyICovCiAJYnNzLT5lYXBfc2VydmVyID0gMTsKLQlic3MtPndwc19zdGF0ZSA9IDI7CisKKwlpZiAoIXNzaWQtPmlnbm9yZV9icm9hZGNhc3Rfc3NpZCkKKwkJYnNzLT53cHNfc3RhdGUgPSAyOworCiAJYnNzLT5hcF9zZXR1cF9sb2NrZWQgPSAyOwogCWlmICh3cGFfcy0+Y29uZi0+Y29uZmlnX21ldGhvZHMpCiAJCWJzcy0+Y29uZmlnX21ldGhvZHMgPSBvc19zdHJkdXAod3BhX3MtPmNvbmYtPmNvbmZpZ19tZXRob2RzKTsKQEAgLTI2MSw2ICsyODEsNyBAQAogCWVsc2UKIAkJb3NfbWVtY3B5KGJzcy0+dXVpZCwgd3BhX3MtPmNvbmYtPnV1aWQsIFdQU19VVUlEX0xFTik7CiAJb3NfbWVtY3B5KGJzcy0+b3NfdmVyc2lvbiwgd3BhX3MtPmNvbmYtPm9zX3ZlcnNpb24sIDQpOworCWJzcy0+cGJjX2luX20xID0gd3BhX3MtPmNvbmYtPnBiY19pbl9tMTsKIG5vX3dwczoKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKQEAgLTM0OSwxMSArMzcwLDEzIEBACiAKIAogc3RhdGljIGludCBhcF9wcm9iZV9yZXFfcngodm9pZCAqY3R4LCBjb25zdCB1OCAqc2EsIGNvbnN0IHU4ICpkYSwKLQkJCSAgIGNvbnN0IHU4ICpic3NpZCwgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuKQorCQkJICAgY29uc3QgdTggKmJzc2lkLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkgICBpbnQgc3NpX3NpZ25hbCkKIHsKICNpZmRlZiBDT05GSUdfUDJQCiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKLQlyZXR1cm4gd3Bhc19wMnBfcHJvYmVfcmVxX3J4KHdwYV9zLCBzYSwgZGEsIGJzc2lkLCBpZSwgaWVfbGVuKTsKKwlyZXR1cm4gd3Bhc19wMnBfcHJvYmVfcmVxX3J4KHdwYV9zLCBzYSwgZGEsIGJzc2lkLCBpZSwgaWVfbGVuLAorCQkJCSAgICAgc3NpX3NpZ25hbCk7CiAjZWxzZSAvKiBDT05GSUdfUDJQICovCiAJcmV0dXJuIDA7CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwpAQCAtNTIwLDkgKzU0Myw4IEBACiAJCWhhcGRfaWZhY2UtPmJzc1tpXS0+c3RhX2F1dGhvcml6ZWRfY2JfY3R4ID0gd3BhX3M7CiAjaWZkZWYgQ09ORklHX1AyUAogCQloYXBkX2lmYWNlLT5ic3NbaV0tPnAycCA9IHdwYV9zLT5nbG9iYWwtPnAycDsKLQkJaGFwZF9pZmFjZS0+YnNzW2ldLT5wMnBfZ3JvdXAgPSB3cGFzX3AycF9ncm91cF9pbml0KAotCQkJd3BhX3MsIHNzaWQtPnAycF9wZXJzaXN0ZW50X2dyb3VwLAotCQkJc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTik7CisJCWhhcGRfaWZhY2UtPmJzc1tpXS0+cDJwX2dyb3VwID0gd3Bhc19wMnBfZ3JvdXBfaW5pdCh3cGFfcywKKwkJCQkJCQkJICAgIHNzaWQpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJaGFwZF9pZmFjZS0+YnNzW2ldLT5zZXR1cF9jb21wbGV0ZV9jYiA9IHdwYXNfYXBfY29uZmlndXJlZF9jYjsKIAkJaGFwZF9pZmFjZS0+YnNzW2ldLT5zZXR1cF9jb21wbGV0ZV9jYl9jdHggPSB3cGFfczsKQEAgLTY1MSwyMSArNjczLDYgQEAKIH0KIAogCi1zdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2FwX3dwc19zdGFfY2FuY2VsKHN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQsCi0JCQkJCSAgICBzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwgdm9pZCAqY3R4KQotewotCWlmIChzdGEgJiYgKHN0YS0+ZmxhZ3MgJiBXTEFOX1NUQV9XUFMpKSB7Ci0JCWFwX3N0YV9kZWF1dGhlbnRpY2F0ZShoYXBkLCBzdGEsCi0JCQkJICAgICAgV0xBTl9SRUFTT05fUFJFVl9BVVRIX05PVF9WQUxJRCk7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiAlczogRGVhdXRoIHN0YT0iIE1BQ1NUUiwKLQkJCSAgIF9fZnVuY19fLCBNQUMyU1RSKHN0YS0+YWRkcikpOwotCQlyZXR1cm4gMTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotCiBpbnQgd3BhX3N1cHBsaWNhbnRfYXBfd3BzX2NhbmNlbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXN0cnVjdCB3cHNfcmVnaXN0cmFyICpyZWc7CkBAIC02NzcsNyArNjg0LDcgQEAKIAlyZWcgPSB3cGFfcy0+YXBfaWZhY2UtPmJzc1swXS0+d3BzLT5yZWdpc3RyYXI7CiAJcmVnX3NlbCA9IHdwc19yZWdpc3RyYXJfd3BzX2NhbmNlbChyZWcpOwogCXdwc19zdGEgPSBhcF9mb3JfZWFjaF9zdGEod3BhX3MtPmFwX2lmYWNlLT5ic3NbMF0sCi0JCQkJICB3cGFfc3VwcGxpY2FudF9hcF93cHNfc3RhX2NhbmNlbCwgTlVMTCk7CisJCQkJICBhcF9zdGFfd3BzX2NhbmNlbCwgTlVMTCk7CiAKIAlpZiAoIXJlZ19zZWwgJiYgIXdwc19zdGEpIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJObyBXUFMgb3BlcmF0aW9uIGluIHByb2dyZXNzIGF0IHRoaXMgIgpAQCAtODcwLDYgKzg3NywyNiBAQAogfQogCiAKK2ludCBhcF9jdHJsX2lmYWNlX3N0YV9kaXNhc3NvY2lhdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICBjb25zdCBjaGFyICp0eHRhZGRyKQoreworCWlmICh3cGFfcy0+YXBfaWZhY2UgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXJldHVybiBob3N0YXBkX2N0cmxfaWZhY2VfZGlzYXNzb2NpYXRlKHdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdLAorCQkJCQkgICAgICAgdHh0YWRkcik7Cit9CisKKworaW50IGFwX2N0cmxfaWZhY2Vfc3RhX2RlYXV0aGVudGljYXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBjb25zdCBjaGFyICp0eHRhZGRyKQoreworCWlmICh3cGFfcy0+YXBfaWZhY2UgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXJldHVybiBob3N0YXBkX2N0cmxfaWZhY2VfZGVhdXRoZW50aWNhdGUod3BhX3MtPmFwX2lmYWNlLT5ic3NbMF0sCisJCQkJCQkgdHh0YWRkcik7Cit9CisKKwogaW50IGFwX2N0cmxfaWZhY2Vfd3BhX2dldF9zdGF0dXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqYnVmLAogCQkJCSBzaXplX3QgYnVmbGVuLCBpbnQgdmVyYm9zZSkKIHsKQEAgLTkzMCw2ICs5NTcsMTcgQEAKIH0KIAogCit2b2lkIHdwYXNfYXBfY2hfc3dpdGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBmcmVxLCBpbnQgaHQsCisJCSAgICAgICBpbnQgb2Zmc2V0KQoreworCWlmICghd3BhX3MtPmFwX2lmYWNlKQorCQlyZXR1cm47CisKKwl3cGFfcy0+YXNzb2NfZnJlcSA9IGZyZXE7CisJaG9zdGFwZF9ldmVudF9jaF9zd2l0Y2god3BhX3MtPmFwX2lmYWNlLT5ic3NbMF0sIGZyZXEsIGh0LCBvZmZzZXQpOworfQorCisKIGludCB3cGFfc3VwcGxpY2FudF9hcF9tYWNfYWRkcl9maWx0ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgICBjb25zdCB1OCAqYWRkcikKIHsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2FwLmggYi93cGFfc3VwcGxpY2FudC9hcC5oCmluZGV4IGYwZWI2N2QuLmJjOTUzZDkgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2FwLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvYXAuaApAQCAtMzEsNiArMzEsMTAgQEAKIAkJICAgICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKTsKIGludCBhcF9jdHJsX2lmYWNlX3N0YV9uZXh0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKnR4dGFkZHIsCiAJCQkgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pOworaW50IGFwX2N0cmxfaWZhY2Vfc3RhX2RlYXV0aGVudGljYXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBjb25zdCBjaGFyICp0eHRhZGRyKTsKK2ludCBhcF9jdHJsX2lmYWNlX3N0YV9kaXNhc3NvY2lhdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICBjb25zdCBjaGFyICp0eHRhZGRyKTsKIGludCBhcF9jdHJsX2lmYWNlX3dwYV9nZXRfc3RhdHVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmJ1ZiwKIAkJCQkgc2l6ZV90IGJ1ZmxlbiwgaW50IHZlcmJvc2UpOwogdm9pZCBhcF90eF9zdGF0dXModm9pZCAqY3R4LCBjb25zdCB1OCAqYWRkciwKQEAgLTQ1LDUgKzQ5LDcgQEAKIGludCB3cGFfc3VwcGxpY2FudF9hcF9tYWNfYWRkcl9maWx0ZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgICBjb25zdCB1OCAqYWRkcik7CiB2b2lkIHdwYV9zdXBwbGljYW50X2FwX3B3ZF9hdXRoX2ZhaWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIHdwYXNfYXBfY2hfc3dpdGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBmcmVxLCBpbnQgaHQsCisJCSAgICAgICBpbnQgb2Zmc2V0KTsKIAogI2VuZGlmIC8qIEFQX0ggKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2F1dG9zY2FuLmMgYi93cGFfc3VwcGxpY2FudC9hdXRvc2Nhbi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQwYzA0MGEKLS0tIC9kZXYvbnVsbAorKysgYi93cGFfc3VwcGxpY2FudC9hdXRvc2Nhbi5jCkBAIC0wLDAgKzEsMTQzIEBACisvKgorICogV1BBIFN1cHBsaWNhbnQgLSBhdXRvIHNjYW4KKyAqIENvcHlyaWdodCAoYykgMjAxMiwgSW50ZWwgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiaW5jbHVkZXMuaCIKKworI2luY2x1ZGUgImNvbW1vbi5oIgorI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKKyNpbmNsdWRlICJic3MuaCIKKyNpbmNsdWRlICJzY2FuLmgiCisjaW5jbHVkZSAiYXV0b3NjYW4uaCIKKworI2lmZGVmIENPTkZJR19BVVRPU0NBTl9FWFBPTkVOVElBTAorZXh0ZXJuIGNvbnN0IHN0cnVjdCBhdXRvc2Nhbl9vcHMgYXV0b3NjYW5fZXhwb25lbnRpYWxfb3BzOworI2VuZGlmIC8qIENPTkZJR19BVVRPU0NBTl9FWFBPTkVOVElBTCAqLworCisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOX1BFUklPRElDCitleHRlcm4gY29uc3Qgc3RydWN0IGF1dG9zY2FuX29wcyBhdXRvc2Nhbl9wZXJpb2RpY19vcHM7CisjZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOX1BFUklPRElDICovCisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXV0b3NjYW5fb3BzICogYXV0b3NjYW5fbW9kdWxlc1tdID0geworI2lmZGVmIENPTkZJR19BVVRPU0NBTl9FWFBPTkVOVElBTAorCSZhdXRvc2Nhbl9leHBvbmVudGlhbF9vcHMsCisjZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOX0VYUE9ORU5USUFMICovCisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOX1BFUklPRElDCisJJmF1dG9zY2FuX3BlcmlvZGljX29wcywKKyNlbmRpZiAvKiBDT05GSUdfQVVUT1NDQU5fUEVSSU9ESUMgKi8KKwlOVUxMCit9OworCisKK3N0YXRpYyB2b2lkIHJlcXVlc3Rfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXdwYV9zLT5zY2FuX3JlcSA9IDI7CisKKwlpZiAod3BhX3N1cHBsaWNhbnRfcmVxX3NjaGVkX3NjYW4od3BhX3MpKQorCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgd3BhX3MtPnNjYW5faW50ZXJ2YWwsIDApOworfQorCisKK2ludCBhdXRvc2Nhbl9pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCByZXFfc2NhbikKK3sKKwljb25zdCBjaGFyICpuYW1lID0gd3BhX3MtPmNvbmYtPmF1dG9zY2FuOworCWNvbnN0IGNoYXIgKnBhcmFtczsKKwlzaXplX3QgbmxlbjsKKwlpbnQgaTsKKwljb25zdCBzdHJ1Y3QgYXV0b3NjYW5fb3BzICpvcHMgPSBOVUxMOworCisJaWYgKHdwYV9zLT5hdXRvc2NhbiAmJiB3cGFfcy0+YXV0b3NjYW5fcHJpdikKKwkJcmV0dXJuIDA7CisKKwlpZiAobmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKworCXBhcmFtcyA9IG9zX3N0cmNocihuYW1lLCAnOicpOworCWlmIChwYXJhbXMgPT0gTlVMTCkgeworCQlwYXJhbXMgPSAiIjsKKwkJbmxlbiA9IG9zX3N0cmxlbihuYW1lKTsKKwl9IGVsc2UgeworCQlubGVuID0gcGFyYW1zIC0gbmFtZTsKKwkJcGFyYW1zKys7CisJfQorCisJZm9yIChpID0gMDsgYXV0b3NjYW5fbW9kdWxlc1tpXTsgaSsrKSB7CisJCWlmIChvc19zdHJuY21wKG5hbWUsIGF1dG9zY2FuX21vZHVsZXNbaV0tPm5hbWUsIG5sZW4pID09IDApIHsKKwkJCW9wcyA9IGF1dG9zY2FuX21vZHVsZXNbaV07CisJCQlicmVhazsKKwkJfQorCX0KKworCWlmIChvcHMgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgImF1dG9zY2FuOiBDb3VsZCBub3QgZmluZCBtb2R1bGUgIgorCQkJICAgIm1hdGNoaW5nIHRoZSBwYXJhbWV0ZXIgJyVzJyIsIG5hbWUpOworCQlyZXR1cm4gLTE7CisJfQorCisJd3BhX3MtPmF1dG9zY2FuX3BhcmFtcyA9IE5VTEw7CisKKwl3cGFfcy0+YXV0b3NjYW5fcHJpdiA9IG9wcy0+aW5pdCh3cGFfcywgcGFyYW1zKTsKKwlpZiAod3BhX3MtPmF1dG9zY2FuX3ByaXYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCXdwYV9zLT5hdXRvc2NhbiA9IG9wczsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiYXV0b3NjYW46IEluaXRpYWxpemVkIG1vZHVsZSAnJXMnIHdpdGggIgorCQkgICAicGFyYW1ldGVycyAnJXMnIiwgb3BzLT5uYW1lLCBwYXJhbXMpOworCWlmICghcmVxX3NjYW4pCisJCXJldHVybiAwOworCisJLyoKKwkgKiBDYW5jZWxsaW5nIGV4aXN0aW5nIHNjYW4gcmVxdWVzdHMsIGlmIGFueS4KKwkgKi8KKwl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CisJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjYW4od3BhX3MpOworCisJLyoKKwkgKiBGaXJpbmcgZmlyc3Qgc2Nhbiwgd2hpY2ggd2lsbCBsZWFkIHRvIGNhbGwgYXV0b3NjYW5fbm90aWZ5X3NjYW4uCisJICovCisJcmVxdWVzdF9zY2FuKHdwYV9zKTsKKworCXJldHVybiAwOworfQorCisKK3ZvaWQgYXV0b3NjYW5fZGVpbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJaWYgKHdwYV9zLT5hdXRvc2NhbiAmJiB3cGFfcy0+YXV0b3NjYW5fcHJpdikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImF1dG9zY2FuOiBEZWluaXRpYWxpemluZyBtb2R1bGUgJyVzJyIsCisJCQkgICB3cGFfcy0+YXV0b3NjYW4tPm5hbWUpOworCQl3cGFfcy0+YXV0b3NjYW4tPmRlaW5pdCh3cGFfcy0+YXV0b3NjYW5fcHJpdik7CisJCXdwYV9zLT5hdXRvc2NhbiA9IE5VTEw7CisJCXdwYV9zLT5hdXRvc2Nhbl9wcml2ID0gTlVMTDsKKworCQl3cGFfcy0+c2Nhbl9pbnRlcnZhbCA9IDU7CisJCXdwYV9zLT5zY2hlZF9zY2FuX2ludGVydmFsID0gMDsKKwl9Cit9CisKKworaW50IGF1dG9zY2FuX25vdGlmeV9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgc3RydWN0IHdwYV9zY2FuX3Jlc3VsdHMgKnNjYW5fcmVzKQoreworCWludCBpbnRlcnZhbDsKKworCWlmICh3cGFfcy0+YXV0b3NjYW4gJiYgd3BhX3MtPmF1dG9zY2FuX3ByaXYpIHsKKwkJaW50ZXJ2YWwgPSB3cGFfcy0+YXV0b3NjYW4tPm5vdGlmeV9zY2FuKHdwYV9zLT5hdXRvc2Nhbl9wcml2LAorCQkJCQkJCXNjYW5fcmVzKTsKKworCQlpZiAoaW50ZXJ2YWwgPD0gMCkKKwkJCXJldHVybiAtMTsKKworCQl3cGFfcy0+c2Nhbl9pbnRlcnZhbCA9IGludGVydmFsOworCQl3cGFfcy0+c2NoZWRfc2Nhbl9pbnRlcnZhbCA9IGludGVydmFsOworCisJCXJlcXVlc3Rfc2Nhbih3cGFfcyk7CisJfQorCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9hdXRvc2Nhbi5oIGIvd3BhX3N1cHBsaWNhbnQvYXV0b3NjYW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMmE3NjUyCi0tLSAvZGV2L251bGwKKysrIGIvd3BhX3N1cHBsaWNhbnQvYXV0b3NjYW4uaApAQCAtMCwwICsxLDQ5IEBACisvKgorICogV1BBIFN1cHBsaWNhbnQgLSBhdXRvIHNjYW4KKyAqIENvcHlyaWdodCAoYykgMjAxMiwgSW50ZWwgQ29ycG9yYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIEFVVE9TQ0FOX0gKKyNkZWZpbmUgQVVUT1NDQU5fSAorCitzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQ7CisKK3N0cnVjdCBhdXRvc2Nhbl9vcHMgeworCWNvbnN0IGNoYXIgKm5hbWU7CisKKwl2b2lkICogKCppbml0KShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCBjaGFyICpwYXJhbXMpOworCXZvaWQgKCpkZWluaXQpKHZvaWQgKnByaXYpOworCisJaW50ICgqbm90aWZ5X3NjYW4pKHZvaWQgKnByaXYsIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3Jlcyk7Cit9OworCisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOCisKK2ludCBhdXRvc2Nhbl9pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCByZXFfc2Nhbik7Cit2b2lkIGF1dG9zY2FuX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK2ludCBhdXRvc2Nhbl9ub3RpZnlfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3Jlcyk7CisKKyNlbHNlIC8qIENPTkZJR19BVVRPU0NBTiAqLworCitzdGF0aWMgaW5saW5lIGludCBhdXRvc2Nhbl9pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCByZXFfc2NhbikKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGF1dG9zY2FuX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworfQorCitzdGF0aWMgaW5saW5lIGludCBhdXRvc2Nhbl9ub3RpZnlfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgICBzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqc2Nhbl9yZXMpCit7CisJcmV0dXJuIDA7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfQVVUT1NDQU4gKi8KKworI2VuZGlmIC8qIEFVVE9TQ0FOX0ggKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2F1dG9zY2FuX2V4cG9uZW50aWFsLmMgYi93cGFfc3VwcGxpY2FudC9hdXRvc2Nhbl9leHBvbmVudGlhbC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQyNDQ3N2IKLS0tIC9kZXYvbnVsbAorKysgYi93cGFfc3VwcGxpY2FudC9hdXRvc2Nhbl9leHBvbmVudGlhbC5jCkBAIC0wLDAgKzEsMTA0IEBACisvKgorICogV1BBIFN1cHBsaWNhbnQgLSBhdXRvIHNjYW4gZXhwb25lbnRpYWwgbW9kdWxlCisgKiBDb3B5cmlnaHQgKGMpIDIwMTIsIEludGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJ3cGFfc3VwcGxpY2FudF9pLmgiCisjaW5jbHVkZSAiYXV0b3NjYW4uaCIKKworc3RydWN0IGF1dG9zY2FuX2V4cG9uZW50aWFsX2RhdGEgeworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3M7CisJaW50IGJhc2U7CisJaW50IGxpbWl0OworCWludCBpbnRlcnZhbDsKK307CisKKworc3RhdGljIGludAorYXV0b3NjYW5fZXhwb25lbnRpYWxfZ2V0X3BhcmFtcyhzdHJ1Y3QgYXV0b3NjYW5fZXhwb25lbnRpYWxfZGF0YSAqZGF0YSwKKwkJCQljb25zdCBjaGFyICpwYXJhbXMpCit7CisJY29uc3QgY2hhciAqcG9zOworCisJaWYgKHBhcmFtcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlkYXRhLT5iYXNlID0gYXRvaShwYXJhbXMpOworCisJcG9zID0gb3Nfc3RyY2hyKHBhcmFtcywgJzonKTsKKwlpZiAocG9zID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXBvcysrOworCWRhdGEtPmxpbWl0ID0gYXRvaShwb3MpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgKiBhdXRvc2Nhbl9leHBvbmVudGlhbF9pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCWNvbnN0IGNoYXIgKnBhcmFtcykKK3sKKwlzdHJ1Y3QgYXV0b3NjYW5fZXhwb25lbnRpYWxfZGF0YSAqZGF0YTsKKworCWRhdGEgPSBvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCBhdXRvc2Nhbl9leHBvbmVudGlhbF9kYXRhKSk7CisJaWYgKGRhdGEgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoYXV0b3NjYW5fZXhwb25lbnRpYWxfZ2V0X3BhcmFtcyhkYXRhLCBwYXJhbXMpIDwgMCkgeworCQlvc19mcmVlKGRhdGEpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgImF1dG9zY2FuIGV4cG9uZW50aWFsOiBiYXNlIGV4cG9uZW50aWFsIGlzICVkICIKKwkJICAgImFuZCBsaW1pdCBpcyAlZCIsIGRhdGEtPmJhc2UsIGRhdGEtPmxpbWl0KTsKKworCWRhdGEtPndwYV9zID0gd3BhX3M7CisKKwlyZXR1cm4gZGF0YTsKK30KKworCitzdGF0aWMgdm9pZCBhdXRvc2Nhbl9leHBvbmVudGlhbF9kZWluaXQodm9pZCAqcHJpdikKK3sKKwlzdHJ1Y3QgYXV0b3NjYW5fZXhwb25lbnRpYWxfZGF0YSAqZGF0YSA9IHByaXY7CisKKwlvc19mcmVlKGRhdGEpOworfQorCisKK3N0YXRpYyBpbnQgYXV0b3NjYW5fZXhwb25lbnRpYWxfbm90aWZ5X3NjYW4odm9pZCAqcHJpdiwKKwkJCQkJICAgIHN0cnVjdCB3cGFfc2Nhbl9yZXN1bHRzICpzY2FuX3JlcykKK3sKKwlzdHJ1Y3QgYXV0b3NjYW5fZXhwb25lbnRpYWxfZGF0YSAqZGF0YSA9IHByaXY7CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgImF1dG9zY2FuIGV4cG9uZW50aWFsOiBzY2FuIHJlc3VsdCAiCisJCSAgICJub3RpZmljYXRpb24iKTsKKworCWlmIChkYXRhLT5pbnRlcnZhbCA+PSBkYXRhLT5saW1pdCkKKwkJcmV0dXJuIGRhdGEtPmxpbWl0OworCisJaWYgKGRhdGEtPmludGVydmFsIDw9IDApCisJCWRhdGEtPmludGVydmFsID0gZGF0YS0+YmFzZTsKKwllbHNlIHsKKwkJZGF0YS0+aW50ZXJ2YWwgPSBkYXRhLT5pbnRlcnZhbCAqIGRhdGEtPmJhc2U7CisJCWlmIChkYXRhLT5pbnRlcnZhbCA+IGRhdGEtPmxpbWl0KQorCQkJcmV0dXJuIGRhdGEtPmxpbWl0OworCX0KKworCXJldHVybiBkYXRhLT5pbnRlcnZhbDsKK30KKworCitjb25zdCBzdHJ1Y3QgYXV0b3NjYW5fb3BzIGF1dG9zY2FuX2V4cG9uZW50aWFsX29wcyA9IHsKKwkubmFtZSA9ICJleHBvbmVudGlhbCIsCisJLmluaXQgPSBhdXRvc2Nhbl9leHBvbmVudGlhbF9pbml0LAorCS5kZWluaXQgPSBhdXRvc2Nhbl9leHBvbmVudGlhbF9kZWluaXQsCisJLm5vdGlmeV9zY2FuID0gYXV0b3NjYW5fZXhwb25lbnRpYWxfbm90aWZ5X3NjYW4sCit9OwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvYXV0b3NjYW5fcGVyaW9kaWMuYyBiL3dwYV9zdXBwbGljYW50L2F1dG9zY2FuX3BlcmlvZGljLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTAyZDcyMwotLS0gL2Rldi9udWxsCisrKyBiL3dwYV9zdXBwbGljYW50L2F1dG9zY2FuX3BlcmlvZGljLmMKQEAgLTAsMCArMSw4NSBAQAorLyoKKyAqIFdQQSBTdXBwbGljYW50IC0gYXV0byBzY2FuIHBlcmlvZGljIG1vZHVsZQorICogQ29weXJpZ2h0IChjKSAyMDEyLCBJbnRlbCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorCisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAid3BhX3N1cHBsaWNhbnRfaS5oIgorI2luY2x1ZGUgImF1dG9zY2FuLmgiCisKKworc3RydWN0IGF1dG9zY2FuX3BlcmlvZGljX2RhdGEgeworCWludCBwZXJpb2RpY19pbnRlcnZhbDsKK307CisKKworc3RhdGljIGludCBhdXRvc2Nhbl9wZXJpb2RpY19nZXRfcGFyYW1zKHN0cnVjdCBhdXRvc2Nhbl9wZXJpb2RpY19kYXRhICpkYXRhLAorCQkJCQljb25zdCBjaGFyICpwYXJhbXMpCit7CisJaW50IGludGVydmFsOworCisJaWYgKHBhcmFtcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpbnRlcnZhbCA9IGF0b2kocGFyYW1zKTsKKworCWlmIChpbnRlcnZhbCA8IDApCisJCXJldHVybiAtMTsKKworCWRhdGEtPnBlcmlvZGljX2ludGVydmFsID0gaW50ZXJ2YWw7CisKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCAqIGF1dG9zY2FuX3BlcmlvZGljX2luaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnBhcmFtcykKK3sKKwlzdHJ1Y3QgYXV0b3NjYW5fcGVyaW9kaWNfZGF0YSAqZGF0YTsKKworCWRhdGEgPSBvc196YWxsb2Moc2l6ZW9mKHN0cnVjdCBhdXRvc2Nhbl9wZXJpb2RpY19kYXRhKSk7CisJaWYgKGRhdGEgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoYXV0b3NjYW5fcGVyaW9kaWNfZ2V0X3BhcmFtcyhkYXRhLCBwYXJhbXMpIDwgMCkgeworCQlvc19mcmVlKGRhdGEpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgImF1dG9zY2FuIHBlcmlvZGljOiBpbnRlcnZhbCBpcyAlZCIsCisJCSAgIGRhdGEtPnBlcmlvZGljX2ludGVydmFsKTsKKworCXJldHVybiBkYXRhOworfQorCisKK3N0YXRpYyB2b2lkIGF1dG9zY2FuX3BlcmlvZGljX2RlaW5pdCh2b2lkICpwcml2KQoreworCXN0cnVjdCBhdXRvc2Nhbl9wZXJpb2RpY19kYXRhICpkYXRhID0gcHJpdjsKKworCW9zX2ZyZWUoZGF0YSk7Cit9CisKKworc3RhdGljIGludCBhdXRvc2Nhbl9wZXJpb2RpY19ub3RpZnlfc2Nhbih2b2lkICpwcml2LAorCQkJCQkgc3RydWN0IHdwYV9zY2FuX3Jlc3VsdHMgKnNjYW5fcmVzKQoreworCXN0cnVjdCBhdXRvc2Nhbl9wZXJpb2RpY19kYXRhICpkYXRhID0gcHJpdjsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiYXV0b3NjYW4gcGVyaW9kaWM6IHNjYW4gcmVzdWx0IG5vdGlmaWNhdGlvbiIpOworCisJcmV0dXJuIGRhdGEtPnBlcmlvZGljX2ludGVydmFsOworfQorCisKK2NvbnN0IHN0cnVjdCBhdXRvc2Nhbl9vcHMgYXV0b3NjYW5fcGVyaW9kaWNfb3BzID0geworCS5uYW1lID0gInBlcmlvZGljIiwKKwkuaW5pdCA9IGF1dG9zY2FuX3BlcmlvZGljX2luaXQsCisJLmRlaW5pdCA9IGF1dG9zY2FuX3BlcmlvZGljX2RlaW5pdCwKKwkubm90aWZ5X3NjYW4gPSBhdXRvc2Nhbl9wZXJpb2RpY19ub3RpZnlfc2NhbiwKK307CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9ic3MuYyBiL3dwYV9zdXBwbGljYW50L2Jzcy5jCmluZGV4IGNiZWQyZTAuLjU4MGE4MmEgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2Jzcy5jCisrKyBiL3dwYV9zdXBwbGljYW50L2Jzcy5jCkBAIC0zNSwxNCArMzUsMTUgQEAKICNkZWZpbmUgV1BBX0JTU19JRVNfQ0hBTkdFRF9GTEFHCUJJVCg4KQogCiAKLXN0YXRpYyB2b2lkIHdwYV9ic3NfcmVtb3ZlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpCitzdGF0aWMgdm9pZCB3cGFfYnNzX3JlbW92ZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLAorCQkJICAgY29uc3QgY2hhciAqcmVhc29uKQogewogCWRsX2xpc3RfZGVsKCZic3MtPmxpc3QpOwogCWRsX2xpc3RfZGVsKCZic3MtPmxpc3RfaWQpOwogCXdwYV9zLT5udW1fYnNzLS07CiAJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQlNTOiBSZW1vdmUgaWQgJXUgQlNTSUQgIiBNQUNTVFIKLQkJIiBTU0lEICclcyciLCBic3MtPmlkLCBNQUMyU1RSKGJzcy0+YnNzaWQpLAotCQl3cGFfc3NpZF90eHQoYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKSk7CisJCSIgU1NJRCAnJXMnIGR1ZSB0byAlcyIsIGJzcy0+aWQsIE1BQzJTVFIoYnNzLT5ic3NpZCksCisJCXdwYV9zc2lkX3R4dChic3MtPnNzaWQsIGJzcy0+c3NpZF9sZW4pLCByZWFzb24pOwogCXdwYXNfbm90aWZ5X2Jzc19yZW1vdmVkKHdwYV9zLCBic3MtPmJzc2lkLCBic3MtPmlkKTsKICNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCiAJd3BhYnVmX2ZyZWUoYnNzLT5hbnFwX3ZlbnVlX25hbWUpOwpAQCAtNTMsNiArNTQsMTIgQEAKIAl3cGFidWZfZnJlZShic3MtPmFucXBfM2dwcCk7CiAJd3BhYnVmX2ZyZWUoYnNzLT5hbnFwX2RvbWFpbl9uYW1lKTsKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCisjaWZkZWYgQ09ORklHX0hTMjAKKwl3cGFidWZfZnJlZShic3MtPmhzMjBfb3BlcmF0b3JfZnJpZW5kbHlfbmFtZSk7CisJd3BhYnVmX2ZyZWUoYnNzLT5oczIwX3dhbl9tZXRyaWNzKTsKKwl3cGFidWZfZnJlZShic3MtPmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5KTsKKwl3cGFidWZfZnJlZShic3MtPmhzMjBfb3BlcmF0aW5nX2NsYXNzKTsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCW9zX2ZyZWUoYnNzKTsKIH0KIApAQCAtNjEsNiArNjgsOCBAQAogCQkJICAgICBjb25zdCB1OCAqc3NpZCwgc2l6ZV90IHNzaWRfbGVuKQogewogCXN0cnVjdCB3cGFfYnNzICpic3M7CisJaWYgKCF3cGFfc3VwcGxpY2FudF9maWx0ZXJfYnNzaWRfbWF0Y2god3BhX3MsIGJzc2lkKSkKKwkJcmV0dXJuIE5VTEw7CiAJZGxfbGlzdF9mb3JfZWFjaChic3MsICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgewogCQlpZiAob3NfbWVtY21wKGJzcy0+YnNzaWQsIGJzc2lkLCBFVEhfQUxFTikgPT0gMCAmJgogCQkgICAgYnNzLT5zc2lkX2xlbiA9PSBzc2lkX2xlbiAmJgpAQCAtMTEyLDEzICsxMjEsMjEgQEAKIH0KIAogCitzdGF0aWMgaW50IHdwYV9ic3NfaW5fdXNlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpCit7CisJcmV0dXJuIGJzcyA9PSB3cGFfcy0+Y3VycmVudF9ic3MgfHwKKwkJb3NfbWVtY21wKGJzcy0+YnNzaWQsIHdwYV9zLT5ic3NpZCwgRVRIX0FMRU4pID09IDAgfHwKKwkJb3NfbWVtY21wKGJzcy0+YnNzaWQsIHdwYV9zLT5wZW5kaW5nX2Jzc2lkLCBFVEhfQUxFTikgPT0gMDsKK30KKworCiBzdGF0aWMgaW50IHdwYV9ic3NfcmVtb3ZlX29sZGVzdF91bmtub3duKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJc3RydWN0IHdwYV9ic3MgKmJzczsKIAogCWRsX2xpc3RfZm9yX2VhY2goYnNzLCAmd3BhX3MtPmJzcywgc3RydWN0IHdwYV9ic3MsIGxpc3QpIHsKIAkJaWYgKCF3cGFfYnNzX2tub3duKHdwYV9zLCBic3MpKSB7Ci0JCQl3cGFfYnNzX3JlbW92ZSh3cGFfcywgYnNzKTsKKwkJCXdwYV9ic3NfcmVtb3ZlKHdwYV9zLCBic3MsIF9fZnVuY19fKTsKIAkJCXJldHVybiAwOwogCQl9CiAJfQpAQCAtMTI3LDIxICsxNDQsMjggQEAKIH0KIAogCi1zdGF0aWMgdm9pZCB3cGFfYnNzX3JlbW92ZV9vbGRlc3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3N0YXRpYyBpbnQgd3BhX2Jzc19yZW1vdmVfb2xkZXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CisJc3RydWN0IHdwYV9ic3MgKmJzczsKKwogCS8qCiAJICogUmVtb3ZlIHRoZSBvbGRlc3QgZW50cnkgdGhhdCBkb2VzIG5vdCBtYXRjaCB3aXRoIGFueSBjb25maWd1cmVkCiAJICogbmV0d29yay4KIAkgKi8KIAlpZiAod3BhX2Jzc19yZW1vdmVfb2xkZXN0X3Vua25vd24od3BhX3MpID09IDApCi0JCXJldHVybjsKKwkJcmV0dXJuIDA7CiAKIAkvKgotCSAqIFJlbW92ZSB0aGUgb2xkZXN0IGVudHJ5IHNpbmNlIG5vIGJldHRlciBjYW5kaWRhdGUgZm9yIHJlbW92YWwgd2FzCi0JICogZm91bmQuCisJICogUmVtb3ZlIHRoZSBvbGRlc3QgZW50cnkgdGhhdCBpc24ndCBjdXJyZW50bHkgaW4gdXNlLgogCSAqLwotCXdwYV9ic3NfcmVtb3ZlKHdwYV9zLCBkbF9saXN0X2ZpcnN0KCZ3cGFfcy0+YnNzLAotCQkJCQkgICAgc3RydWN0IHdwYV9ic3MsIGxpc3QpKTsKKwlkbF9saXN0X2Zvcl9lYWNoKGJzcywgJndwYV9zLT5ic3MsIHN0cnVjdCB3cGFfYnNzLCBsaXN0KSB7CisJCWlmICghd3BhX2Jzc19pbl91c2Uod3BhX3MsIGJzcykpIHsKKwkJCXdwYV9ic3NfcmVtb3ZlKHdwYV9zLCBic3MsIF9fZnVuY19fKTsKKwkJCXJldHVybiAwOworCQl9CisJfQorCisJcmV0dXJuIC0xOwogfQogCiAKQEAgLTE3MCw4ICsxOTQsMTMgQEAKIAkJIiBTU0lEICclcyciLAogCQlic3MtPmlkLCBNQUMyU1RSKGJzcy0+YnNzaWQpLCB3cGFfc3NpZF90eHQoc3NpZCwgc3NpZF9sZW4pKTsKIAl3cGFzX25vdGlmeV9ic3NfYWRkZWQod3BhX3MsIGJzcy0+YnNzaWQsIGJzcy0+aWQpOwotCWlmICh3cGFfcy0+bnVtX2JzcyA+IHdwYV9zLT5jb25mLT5ic3NfbWF4X2NvdW50KQotCQl3cGFfYnNzX3JlbW92ZV9vbGRlc3Qod3BhX3MpOworCWlmICh3cGFfcy0+bnVtX2JzcyA+IHdwYV9zLT5jb25mLT5ic3NfbWF4X2NvdW50ICYmCisJICAgIHdwYV9ic3NfcmVtb3ZlX29sZGVzdCh3cGFfcykgIT0gMCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkluY3JlYXNpbmcgdGhlIE1BWCBCU1MgY291bnQgdG8gJWQgIgorCQkJICAgImJlY2F1c2UgYWxsIEJTU2VzIGFyZSBpbiB1c2UuIFdlIHNob3VsZCBub3JtYWxseSAiCisJCQkgICAibm90IGdldCBoZXJlISIsIChpbnQpIHdwYV9zLT5udW1fYnNzKTsKKwkJd3BhX3MtPmNvbmYtPmJzc19tYXhfY291bnQgPSB3cGFfcy0+bnVtX2JzczsKKwl9CiB9CiAKIApAQCAtMzI2LDYgKzM1NSw4IEBACiAJCW5ic3MgPSBvc19yZWFsbG9jKGJzcywgc2l6ZW9mKCpic3MpICsgcmVzLT5pZV9sZW4gKwogCQkJCSAgcmVzLT5iZWFjb25faWVfbGVuKTsKIAkJaWYgKG5ic3MpIHsKKwkJCWlmICh3cGFfcy0+Y3VycmVudF9ic3MgPT0gYnNzKQorCQkJCXdwYV9zLT5jdXJyZW50X2JzcyA9IG5ic3M7CiAJCQlic3MgPSBuYnNzOwogCQkJb3NfbWVtY3B5KGJzcyArIDEsIHJlcyArIDEsCiAJCQkJICByZXMtPmllX2xlbiArIHJlcy0+YmVhY29uX2llX2xlbik7CkBAIC0zNDAsMTQgKzM3MSw2IEBACiB9CiAKIAotc3RhdGljIGludCB3cGFfYnNzX2luX3VzZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQotewotCXJldHVybiBic3MgPT0gd3BhX3MtPmN1cnJlbnRfYnNzIHx8Ci0JCW9zX21lbWNtcChic3MtPmJzc2lkLCB3cGFfcy0+YnNzaWQsIEVUSF9BTEVOKSA9PSAwIHx8Ci0JCW9zX21lbWNtcChic3MtPmJzc2lkLCB3cGFfcy0+cGVuZGluZ19ic3NpZCwgRVRIX0FMRU4pID09IDA7Ci19Ci0KLQogdm9pZCB3cGFfYnNzX3VwZGF0ZV9zdGFydChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXdwYV9zLT5ic3NfdXBkYXRlX2lkeCsrOwpAQCAtMzc1LDYgKzM5OCwxOCBAQAogCX0KIAogCXAycCA9IHdwYV9zY2FuX2dldF92ZW5kb3JfaWUocmVzLCBQMlBfSUVfVkVORE9SX1RZUEUpOworI2lmZGVmIENPTkZJR19QMlAKKwlpZiAocDJwID09IE5VTEwgJiYKKwkgICAgd3BhX3MtPnAycF9ncm91cF9pbnRlcmZhY2UgIT0gTk9UX1AyUF9HUk9VUF9JTlRFUkZBQ0UpIHsKKwkJLyoKKwkJICogSWYgaXQncyBhIFAyUCBzcGVjaWZpYyBpbnRlcmZhY2UsIHRoZW4gZG9uJ3QgdXBkYXRlCisJCSAqIHRoZSBzY2FuIHJlc3VsdCB3aXRob3V0IGEgUDJQIElFLgorCQkgKi8KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJCU1M6IE5vIFAyUCBJRSAtIHNraXBwaW5nIEJTUyAiIE1BQ1NUUgorCQkJICAgIiB1cGRhdGUgZm9yIFAyUCBpbnRlcmZhY2UiLCBNQUMyU1RSKHJlcy0+YnNzaWQpKTsKKwkJcmV0dXJuOworCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJaWYgKHAycCAmJiBzc2lkWzFdID09IFAyUF9XSUxEQ0FSRF9TU0lEX0xFTiAmJgogCSAgICBvc19tZW1jbXAoc3NpZCArIDIsIFAyUF9XSUxEQ0FSRF9TU0lELCBQMlBfV0lMRENBUkRfU1NJRF9MRU4pID09IDApCiAJCXJldHVybjsgLyogU2tpcCBQMlAgbGlzdGVuIGRpc2NvdmVyeSByZXN1bHRzIGhlcmUgKi8KQEAgLTQ0Nyw5ICs0ODIsNyBAQAogCQkJYnNzLT5zY2FuX21pc3NfY291bnQrKzsKIAkJaWYgKGJzcy0+c2Nhbl9taXNzX2NvdW50ID49CiAJCSAgICB3cGFfcy0+Y29uZi0+YnNzX2V4cGlyYXRpb25fc2Nhbl9jb3VudCkgewotCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQlNTOiBFeHBpcmUgQlNTICV1IGR1ZSB0byAiCi0JCQkJIm5vIG1hdGNoIGluIHNjYW4iLCBic3MtPmlkKTsKLQkJCXdwYV9ic3NfcmVtb3ZlKHdwYV9zLCBic3MpOworCQkJd3BhX2Jzc19yZW1vdmUod3BhX3MsIGJzcywgIm5vIG1hdGNoIGluIHNjYW4iKTsKIAkJfQogCX0KIH0KQEAgLTQ3MSw5ICs1MDQsNyBAQAogCQkJY29udGludWU7CiAKIAkJaWYgKG9zX3RpbWVfYmVmb3JlKCZic3MtPmxhc3RfdXBkYXRlLCAmdCkpIHsKLQkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkJTUzogRXhwaXJlIEJTUyAldSBkdWUgdG8gIgotCQkJCSJhZ2UiLCBic3MtPmlkKTsKLQkJCXdwYV9ic3NfcmVtb3ZlKHdwYV9zLCBic3MpOworCQkJd3BhX2Jzc19yZW1vdmUod3BhX3MsIGJzcywgX19mdW5jX18pOwogCQl9IGVsc2UKIAkJCWJyZWFrOwogCX0KQEAgLTUxMCw3ICs1NDEsNyBAQAogCWRsX2xpc3RfZm9yX2VhY2hfc2FmZShic3MsIG4sICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgewogCQlpZiAod3BhX2Jzc19pbl91c2Uod3BhX3MsIGJzcykpCiAJCQljb250aW51ZTsKLQkJd3BhX2Jzc19yZW1vdmUod3BhX3MsIGJzcyk7CisJCXdwYV9ic3NfcmVtb3ZlKHdwYV9zLCBic3MsIF9fZnVuY19fKTsKIAl9CiB9CiAKQEAgLTUyNiw2ICs1NTcsOCBAQAogCQkJCSAgIGNvbnN0IHU4ICpic3NpZCkKIHsKIAlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOworCWlmICghd3BhX3N1cHBsaWNhbnRfZmlsdGVyX2Jzc2lkX21hdGNoKHdwYV9zLCBic3NpZCkpCisJCXJldHVybiBOVUxMOwogCWRsX2xpc3RfZm9yX2VhY2hfcmV2ZXJzZShic3MsICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgewogCQlpZiAob3NfbWVtY21wKGJzcy0+YnNzaWQsIGJzc2lkLCBFVEhfQUxFTikgPT0gMCkKIAkJCXJldHVybiBic3M7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9ic3MuaCBiL3dwYV9zdXBwbGljYW50L2Jzcy5oCmluZGV4IDJiYzlmODIuLjY1ZTk2MmIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2Jzcy5oCisrKyBiL3dwYV9zdXBwbGljYW50L2Jzcy5oCkBAIC0xOSwyNCArMTksNiBAQAogI2RlZmluZSBXUEFfQlNTX0FTU09DSUFURUQJCUJJVCg1KQogI2RlZmluZSBXUEFfQlNTX0FOUVBfRkVUQ0hfVFJJRUQJQklUKDYpCiAKLSNkZWZpbmUgV1BBX0JTU19NQVNLX0FMTAkJMHhGRkZGRkZGRgotI2RlZmluZSBXUEFfQlNTX01BU0tfSUQJCQlCSVQoMCkKLSNkZWZpbmUgV1BBX0JTU19NQVNLX0JTU0lECQlCSVQoMSkKLSNkZWZpbmUgV1BBX0JTU19NQVNLX0ZSRVEJCUJJVCgyKQotI2RlZmluZSBXUEFfQlNTX01BU0tfQkVBQ09OX0lOVAkJQklUKDMpCi0jZGVmaW5lIFdQQV9CU1NfTUFTS19DQVBBQklMSVRJRVMJQklUKDQpCi0jZGVmaW5lIFdQQV9CU1NfTUFTS19RVUFMCQlCSVQoNSkKLSNkZWZpbmUgV1BBX0JTU19NQVNLX05PSVNFCQlCSVQoNikKLSNkZWZpbmUgV1BBX0JTU19NQVNLX0xFVkVMCQlCSVQoNykKLSNkZWZpbmUgV1BBX0JTU19NQVNLX1RTRgkJQklUKDgpCi0jZGVmaW5lIFdQQV9CU1NfTUFTS19BR0UJCUJJVCg5KQotI2RlZmluZSBXUEFfQlNTX01BU0tfSUUJCQlCSVQoMTApCi0jZGVmaW5lIFdQQV9CU1NfTUFTS19GTEFHUwkJQklUKDExKQotI2RlZmluZSBXUEFfQlNTX01BU0tfU1NJRAkJQklUKDEyKQotI2RlZmluZSBXUEFfQlNTX01BU0tfV1BTX1NDQU4JCUJJVCgxMykKLSNkZWZpbmUgV1BBX0JTU19NQVNLX1AyUF9TQ0FOCQlCSVQoMTQpCi0jZGVmaW5lIFdQQV9CU1NfTUFTS19JTlRFUk5FVFcJCUJJVCgxNSkKLQogLyoqCiAgKiBzdHJ1Y3Qgd3BhX2JzcyAtIEJTUyB0YWJsZQogICogQGxpc3Q6IExpc3QgZW50cnkgZm9yIHN0cnVjdCB3cGFfc3VwcGxpY2FudDo6YnNzCkBAIC04Nyw2ICs2OSwxMiBAQAogCXN0cnVjdCB3cGFidWYgKmFucXBfM2dwcDsKIAlzdHJ1Y3Qgd3BhYnVmICphbnFwX2RvbWFpbl9uYW1lOwogI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KKyNpZmRlZiBDT05GSUdfSFMyMAorCXN0cnVjdCB3cGFidWYgKmhzMjBfb3BlcmF0b3JfZnJpZW5kbHlfbmFtZTsKKwlzdHJ1Y3Qgd3BhYnVmICpoczIwX3dhbl9tZXRyaWNzOworCXN0cnVjdCB3cGFidWYgKmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5OworCXN0cnVjdCB3cGFidWYgKmhzMjBfb3BlcmF0aW5nX2NsYXNzOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJc2l6ZV90IGllX2xlbjsKIAlzaXplX3QgYmVhY29uX2llX2xlbjsKIAkvKiBmb2xsb3dlZCBieSBpZV9sZW4gb2N0ZXRzIG9mIElFcyAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnLmMgYi93cGFfc3VwcGxpY2FudC9jb25maWcuYwppbmRleCBkMzZkMDI3Li5hNzk1YzQxIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jb25maWcuYworKysgYi93cGFfc3VwcGxpY2FudC9jb25maWcuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXUEEgU3VwcGxpY2FudCAvIENvbmZpZ3VyYXRpb24gcGFyc2VyIGFuZCBjb21tb24gZnVuY3Rpb25zCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwOCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwMy0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0xMyw2ICsxMyw3IEBACiAjaW5jbHVkZSAiY3J5cHRvL3NoYTEuaCIKICNpbmNsdWRlICJyc25fc3VwcC93cGEuaCIKICNpbmNsdWRlICJlYXBfcGVlci9lYXAuaCIKKyNpbmNsdWRlICJwMnAvcDJwLmgiCiAjaW5jbHVkZSAiY29uZmlnLmgiCiAKIApAQCAtMTEzMCw2ICsxMTMxLDcgQEAKIAogCXdwYV9oZXhkdW1wKE1TR19NU0dEVU1QLCAiZWFwIG1ldGhvZHMiLAogCQkgICAgKHU4ICopIG1ldGhvZHMsIG51bV9tZXRob2RzICogc2l6ZW9mKCptZXRob2RzKSk7CisJb3NfZnJlZShzc2lkLT5lYXAuZWFwX21ldGhvZHMpOwogCXNzaWQtPmVhcC5lYXBfbWV0aG9kcyA9IG1ldGhvZHM7CiAJcmV0dXJuIGVycm9ycyA/IC0xIDogMDsKIH0KQEAgLTEyNzcsNiArMTI3OSwxMSBAQAogCQlvc19mcmVlKGJ1Zik7CiAJCXJldHVybiAtMTsKIAl9CisJaWYgKCpsZW4gJiYgKmxlbiAhPSA1ICYmICpsZW4gIT0gMTMgJiYgKmxlbiAhPSAxNikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgV0VQIGtleSBsZW5ndGggJXUgLSAiCisJCQkgICAidGhpcyBuZXR3b3JrIGJsb2NrIHdpbGwgYmUgaWdub3JlZCIsCisJCQkgICBsaW5lLCAodW5zaWduZWQgaW50KSAqbGVuKTsKKwl9CiAJb3NfbWVtY3B5KGtleSwgYnVmLCAqbGVuKTsKIAlvc19mcmVlKGJ1Zik7CiAJcmVzID0gb3Nfc25wcmludGYodGl0bGUsIHNpemVvZih0aXRsZSksICJ3ZXBfa2V5JWQiLCBpZHgpOwpAQCAtMTU1Niw2ICsxNTYzLDcgQEAKIAl7IEZVTkNfS0VZKHBzaykgfSwKIAl7IEZVTkMocHJvdG8pIH0sCiAJeyBGVU5DKGtleV9tZ210KSB9LAorCXsgSU5UKGJnX3NjYW5fcGVyaW9kKSB9LAogCXsgRlVOQyhwYWlyd2lzZSkgfSwKIAl7IEZVTkMoZ3JvdXApIH0sCiAJeyBGVU5DKGF1dGhfYWxnKSB9LApAQCAtMTYyMiw2ICsxNjMwLDcgQEAKIAl7IElOVF9SQU5HRShmcmVxdWVuY3ksIDAsIDEwMDAwKSB9LAogCXsgSU5UKHdwYV9wdGtfcmVrZXkpIH0sCiAJeyBTVFIoYmdzY2FuKSB9LAorCXsgSU5UX1JBTkdFKGlnbm9yZV9icm9hZGNhc3Rfc3NpZCwgMCwgMikgfSwKICNpZmRlZiBDT05GSUdfUDJQCiAJeyBGVU5DKHAycF9jbGllbnRfbGlzdCkgfSwKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCkBAIC0xNjMzLDYgKzE2NDIsOCBAQAogCXsgSU5UX1JBTkdFKGFtcGR1X2RlbnNpdHksIC0xLCA3KSB9LAogCXsgU1RSKGh0X21jcykgfSwKICNlbmRpZiAvKiBDT05GSUdfSFRfT1ZFUlJJREVTICovCisJeyBJTlQoYXBfbWF4X2luYWN0aXZpdHkpIH0sCisJeyBJTlQoZHRpbV9wZXJpb2QpIH0sCiB9OwogCiAjaWZkZWYgV1BBX1VOSUNPREVfU1NJRApAQCAtMTcwMSwxMyArMTcxMiwxNCBAQAogCQlyZXR1cm4gLTE7CiAKIAlmb3IgKHByaW8gPSAwOyBwcmlvIDwgY29uZmlnLT5udW1fcHJpbzsgcHJpbysrKSB7Ci0JCWlmIChubGlzdFtwcmlvXS0+cHJpb3JpdHkgPCBzc2lkLT5wcmlvcml0eSkKKwkJaWYgKG5saXN0W3ByaW9dLT5wcmlvcml0eSA8IHNzaWQtPnByaW9yaXR5KSB7CisJCQlvc19tZW1tb3ZlKCZubGlzdFtwcmlvICsgMV0sICZubGlzdFtwcmlvXSwKKwkJCQkgICAoY29uZmlnLT5udW1fcHJpbyAtIHByaW8pICoKKwkJCQkgICBzaXplb2Yoc3RydWN0IHdwYV9zc2lkICopKTsKIAkJCWJyZWFrOworCQl9CiAJfQogCi0Jb3NfbWVtbW92ZSgmbmxpc3RbcHJpbyArIDFdLCAmbmxpc3RbcHJpb10sCi0JCSAgIChjb25maWctPm51bV9wcmlvIC0gcHJpbykgKiBzaXplb2Yoc3RydWN0IHdwYV9zc2lkICopKTsKLQogCW5saXN0W3ByaW9dID0gc3NpZDsKIAljb25maWctPm51bV9wcmlvKys7CiAJY29uZmlnLT5wc3NpZCA9IG5saXN0OwpAQCAtMTgxNiw2ICsxODI4LDIyIEBACiB9CiAKIAordm9pZCB3cGFfY29uZmlnX2ZyZWVfY3JlZChzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQpCit7CisJb3NfZnJlZShjcmVkLT5yZWFsbSk7CisJb3NfZnJlZShjcmVkLT51c2VybmFtZSk7CisJb3NfZnJlZShjcmVkLT5wYXNzd29yZCk7CisJb3NfZnJlZShjcmVkLT5jYV9jZXJ0KTsKKwlvc19mcmVlKGNyZWQtPmNsaWVudF9jZXJ0KTsKKwlvc19mcmVlKGNyZWQtPnByaXZhdGVfa2V5KTsKKwlvc19mcmVlKGNyZWQtPnByaXZhdGVfa2V5X3Bhc3N3ZCk7CisJb3NfZnJlZShjcmVkLT5pbXNpKTsKKwlvc19mcmVlKGNyZWQtPm1pbGVuYWdlKTsKKwlvc19mcmVlKGNyZWQtPmRvbWFpbik7CisJb3NfZnJlZShjcmVkKTsKK30KKworCiAvKioKICAqIHdwYV9jb25maWdfZnJlZSAtIEZyZWUgY29uZmlndXJhdGlvbiBkYXRhCiAgKiBAY29uZmlnOiBDb25maWd1cmF0aW9uIGRhdGEgZnJvbSB3cGFfY29uZmlnX3JlYWQoKQpAQCAtMTgyOSw2ICsxODU3LDcgQEAKIAlzdHJ1Y3Qgd3BhX2NvbmZpZ19ibG9iICpibG9iLCAqcHJldmJsb2I7CiAjZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19CTE9CUyAqLwogCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCwgKnByZXYgPSBOVUxMOworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgKmNwcmV2OwogCiAJc3NpZCA9IGNvbmZpZy0+c3NpZDsKIAl3aGlsZSAoc3NpZCkgewpAQCAtMTgzNyw2ICsxODY2LDEzIEBACiAJCXdwYV9jb25maWdfZnJlZV9zc2lkKHByZXYpOwogCX0KIAorCWNyZWQgPSBjb25maWctPmNyZWQ7CisJd2hpbGUgKGNyZWQpIHsKKwkJY3ByZXYgPSBjcmVkOworCQljcmVkID0gY3JlZC0+bmV4dDsKKwkJd3BhX2NvbmZpZ19mcmVlX2NyZWQoY3ByZXYpOworCX0KKwogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX0JMT0JTCiAJYmxvYiA9IGNvbmZpZy0+YmxvYnM7CiAJcHJldmJsb2IgPSBOVUxMOwpAQCAtMTg0NywxMSArMTg4MywxNCBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX0JMT0JTICovCiAKKwl3cGFidWZfZnJlZShjb25maWctPndwc192ZW5kb3JfZXh0X20xKTsKIAlvc19mcmVlKGNvbmZpZy0+Y3RybF9pbnRlcmZhY2UpOwogCW9zX2ZyZWUoY29uZmlnLT5jdHJsX2ludGVyZmFjZV9ncm91cCk7CiAJb3NfZnJlZShjb25maWctPm9wZW5zY19lbmdpbmVfcGF0aCk7CiAJb3NfZnJlZShjb25maWctPnBrY3MxMV9lbmdpbmVfcGF0aCk7CiAJb3NfZnJlZShjb25maWctPnBrY3MxMV9tb2R1bGVfcGF0aCk7CisJb3NfZnJlZShjb25maWctPnBjc2NfcmVhZGVyKTsKKwlvc19mcmVlKGNvbmZpZy0+cGNzY19waW4pOwogCW9zX2ZyZWUoY29uZmlnLT5kcml2ZXJfcGFyYW0pOwogCW9zX2ZyZWUoY29uZmlnLT5kZXZpY2VfbmFtZSk7CiAJb3NfZnJlZShjb25maWctPm1hbnVmYWN0dXJlcik7CkBAIC0xODYxLDEyICsxOTAwLDExIEBACiAJb3NfZnJlZShjb25maWctPmNvbmZpZ19tZXRob2RzKTsKIAlvc19mcmVlKGNvbmZpZy0+cDJwX3NzaWRfcG9zdGZpeCk7CiAJb3NfZnJlZShjb25maWctPnBzc2lkKTsKLQlvc19mcmVlKGNvbmZpZy0+aG9tZV9yZWFsbSk7Ci0Jb3NfZnJlZShjb25maWctPmhvbWVfdXNlcm5hbWUpOwotCW9zX2ZyZWUoY29uZmlnLT5ob21lX3Bhc3N3b3JkKTsKLQlvc19mcmVlKGNvbmZpZy0+aG9tZV9jYV9jZXJ0KTsKLQlvc19mcmVlKGNvbmZpZy0+aG9tZV9pbXNpKTsKLQlvc19mcmVlKGNvbmZpZy0+aG9tZV9taWxlbmFnZSk7CisJb3NfZnJlZShjb25maWctPnAycF9wcmVmX2NoYW4pOworCW9zX2ZyZWUoY29uZmlnLT5hdXRvc2Nhbik7CisJd3BhYnVmX2ZyZWUoY29uZmlnLT53cHNfbmZjX2RoX3B1YmtleSk7CisJd3BhYnVmX2ZyZWUoY29uZmlnLT53cHNfbmZjX2RoX3ByaXZrZXkpOworCXdwYWJ1Zl9mcmVlKGNvbmZpZy0+d3BzX25mY19kZXZfcHcpOwogI2lmZGVmIEFORFJPSURfUDJQCiAJb3NfZnJlZShjb25maWctPnByaW9yaXRpemUpOwogI2VuZGlmCkBAIC0xOTk3LDYgKzIwMzUsNyBAQAogCXNzaWQtPnBhaXJ3aXNlX2NpcGhlciA9IERFRkFVTFRfUEFJUldJU0U7CiAJc3NpZC0+Z3JvdXBfY2lwaGVyID0gREVGQVVMVF9HUk9VUDsKIAlzc2lkLT5rZXlfbWdtdCA9IERFRkFVTFRfS0VZX01HTVQ7CisJc3NpZC0+Ymdfc2Nhbl9wZXJpb2QgPSBERUZBVUxUX0JHX1NDQU5fUEVSSU9EOwogI2lmZGVmIElFRUU4MDIxWF9FQVBPTAogCXNzaWQtPmVhcG9sX2ZsYWdzID0gREVGQVVMVF9FQVBPTF9GTEFHUzsKIAlzc2lkLT5lYXBfd29ya2Fyb3VuZCA9IERFRkFVTFRfRUFQX1dPUktBUk9VTkQ7CkBAIC0yMjQxLDYgKzIyODAsMTY4IEBACiB9CiAKIAoraW50IHdwYV9jb25maWdfc2V0X2NyZWQoc3RydWN0IHdwYV9jcmVkICpjcmVkLCBjb25zdCBjaGFyICp2YXIsCisJCQljb25zdCBjaGFyICp2YWx1ZSwgaW50IGxpbmUpCit7CisJY2hhciAqdmFsOworCXNpemVfdCBsZW47CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInByaW9yaXR5IikgPT0gMCkgeworCQljcmVkLT5wcmlvcml0eSA9IGF0b2kodmFsdWUpOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInBjc2MiKSA9PSAwKSB7CisJCWNyZWQtPnBjc2MgPSBhdG9pKHZhbHVlKTsKKwkJcmV0dXJuIDA7CisJfQorCisJdmFsID0gd3BhX2NvbmZpZ19wYXJzZV9zdHJpbmcodmFsdWUsICZsZW4pOworCWlmICh2YWwgPT0gTlVMTCkgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IGludmFsaWQgZmllbGQgJyVzJyBzdHJpbmcgIgorCQkJICAgInZhbHVlICclcycuIiwgbGluZSwgdmFyLCB2YWx1ZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInJlYWxtIikgPT0gMCkgeworCQlvc19mcmVlKGNyZWQtPnJlYWxtKTsKKwkJY3JlZC0+cmVhbG0gPSB2YWw7CisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAidXNlcm5hbWUiKSA9PSAwKSB7CisJCW9zX2ZyZWUoY3JlZC0+dXNlcm5hbWUpOworCQljcmVkLT51c2VybmFtZSA9IHZhbDsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJwYXNzd29yZCIpID09IDApIHsKKwkJb3NfZnJlZShjcmVkLT5wYXNzd29yZCk7CisJCWNyZWQtPnBhc3N3b3JkID0gdmFsOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgImNhX2NlcnQiKSA9PSAwKSB7CisJCW9zX2ZyZWUoY3JlZC0+Y2FfY2VydCk7CisJCWNyZWQtPmNhX2NlcnQgPSB2YWw7CisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAiY2xpZW50X2NlcnQiKSA9PSAwKSB7CisJCW9zX2ZyZWUoY3JlZC0+Y2xpZW50X2NlcnQpOworCQljcmVkLT5jbGllbnRfY2VydCA9IHZhbDsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJwcml2YXRlX2tleSIpID09IDApIHsKKwkJb3NfZnJlZShjcmVkLT5wcml2YXRlX2tleSk7CisJCWNyZWQtPnByaXZhdGVfa2V5ID0gdmFsOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgInByaXZhdGVfa2V5X3Bhc3N3ZCIpID09IDApIHsKKwkJb3NfZnJlZShjcmVkLT5wcml2YXRlX2tleV9wYXNzd2QpOworCQljcmVkLT5wcml2YXRlX2tleV9wYXNzd2QgPSB2YWw7CisJCXJldHVybiAwOworCX0KKworCWlmIChvc19zdHJjbXAodmFyLCAiaW1zaSIpID09IDApIHsKKwkJb3NfZnJlZShjcmVkLT5pbXNpKTsKKwkJY3JlZC0+aW1zaSA9IHZhbDsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKG9zX3N0cmNtcCh2YXIsICJtaWxlbmFnZSIpID09IDApIHsKKwkJb3NfZnJlZShjcmVkLT5taWxlbmFnZSk7CisJCWNyZWQtPm1pbGVuYWdlID0gdmFsOworCQlyZXR1cm4gMDsKKwl9CisKKwlpZiAob3Nfc3RyY21wKHZhciwgImRvbWFpbiIpID09IDApIHsKKwkJb3NfZnJlZShjcmVkLT5kb21haW4pOworCQljcmVkLT5kb21haW4gPSB2YWw7CisJCXJldHVybiAwOworCX0KKworCWlmIChsaW5lKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogdW5rbm93biBjcmVkIGZpZWxkICclcycuIiwKKwkJCSAgIGxpbmUsIHZhcik7CisJfQorCisJb3NfZnJlZSh2YWwpOworCisJcmV0dXJuIC0xOworfQorCisKK3N0cnVjdCB3cGFfY3JlZCAqIHdwYV9jb25maWdfZ2V0X2NyZWQoc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZywgaW50IGlkKQoreworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKKworCWNyZWQgPSBjb25maWctPmNyZWQ7CisJd2hpbGUgKGNyZWQpIHsKKwkJaWYgKGlkID09IGNyZWQtPmlkKQorCQkJYnJlYWs7CisJCWNyZWQgPSBjcmVkLT5uZXh0OworCX0KKworCXJldHVybiBjcmVkOworfQorCisKK3N0cnVjdCB3cGFfY3JlZCAqIHdwYV9jb25maWdfYWRkX2NyZWQoc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZykKK3sKKwlpbnQgaWQ7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkLCAqbGFzdCA9IE5VTEw7CisKKwlpZCA9IC0xOworCWNyZWQgPSBjb25maWctPmNyZWQ7CisJd2hpbGUgKGNyZWQpIHsKKwkJaWYgKGNyZWQtPmlkID4gaWQpCisJCQlpZCA9IGNyZWQtPmlkOworCQlsYXN0ID0gY3JlZDsKKwkJY3JlZCA9IGNyZWQtPm5leHQ7CisJfQorCWlkKys7CisKKwljcmVkID0gb3NfemFsbG9jKHNpemVvZigqY3JlZCkpOworCWlmIChjcmVkID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCWNyZWQtPmlkID0gaWQ7CisJaWYgKGxhc3QpCisJCWxhc3QtPm5leHQgPSBjcmVkOworCWVsc2UKKwkJY29uZmlnLT5jcmVkID0gY3JlZDsKKworCXJldHVybiBjcmVkOworfQorCisKK2ludCB3cGFfY29uZmlnX3JlbW92ZV9jcmVkKHN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBpZCkKK3sKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpwcmV2ID0gTlVMTDsKKworCWNyZWQgPSBjb25maWctPmNyZWQ7CisJd2hpbGUgKGNyZWQpIHsKKwkJaWYgKGlkID09IGNyZWQtPmlkKQorCQkJYnJlYWs7CisJCXByZXYgPSBjcmVkOworCQljcmVkID0gY3JlZC0+bmV4dDsKKwl9CisKKwlpZiAoY3JlZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlpZiAocHJldikKKwkJcHJldi0+bmV4dCA9IGNyZWQtPm5leHQ7CisJZWxzZQorCQljb25maWctPmNyZWQgPSBjcmVkLT5uZXh0OworCisJd3BhX2NvbmZpZ19mcmVlX2NyZWQoY3JlZCk7CisJcmV0dXJuIDA7Cit9CisKKwogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX0JMT0JTCiAvKioKICAqIHdwYV9jb25maWdfZ2V0X2Jsb2IgLSBHZXQgYSBuYW1lZCBjb25maWd1cmF0aW9uIGJsb2IKQEAgLTI0NTQsNiArMjY1NSwzNSBAQAogfQogCiAKK3N0YXRpYyBpbnQgd3BhX2dsb2JhbF9jb25maWdfcGFyc2VfYmluKGNvbnN0IHN0cnVjdCBnbG9iYWxfcGFyc2VfZGF0YSAqZGF0YSwKKwkJCQkgICAgICAgc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZywgaW50IGxpbmUsCisJCQkJICAgICAgIGNvbnN0IGNoYXIgKnBvcykKK3sKKwlzaXplX3QgbGVuOworCXN0cnVjdCB3cGFidWYgKipkc3QsICp0bXA7CisKKwlsZW4gPSBvc19zdHJsZW4ocG9zKTsKKwlpZiAobGVuICYgMHgwMSkKKwkJcmV0dXJuIC0xOworCisJdG1wID0gd3BhYnVmX2FsbG9jKGxlbiAvIDIpOworCWlmICh0bXAgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJaWYgKGhleHN0cjJiaW4ocG9zLCB3cGFidWZfcHV0KHRtcCwgbGVuIC8gMiksIGxlbiAvIDIpKSB7CisJCXdwYWJ1Zl9mcmVlKHRtcCk7CisJCXJldHVybiAtMTsKKwl9CisKKwlkc3QgPSAoc3RydWN0IHdwYWJ1ZiAqKikgKCgodTggKikgY29uZmlnKSArIChsb25nKSBkYXRhLT5wYXJhbTEpOworCXdwYWJ1Zl9mcmVlKCpkc3QpOworCSpkc3QgPSB0bXA7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICIlcyIsIGRhdGEtPm5hbWUpOworCisJcmV0dXJuIDA7Cit9CisKKwogc3RhdGljIGludCB3cGFfY29uZmlnX3Byb2Nlc3NfY291bnRyeShjb25zdCBzdHJ1Y3QgZ2xvYmFsX3BhcnNlX2RhdGEgKmRhdGEsCiAJCQkJICAgICAgc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZywgaW50IGxpbmUsCiAJCQkJICAgICAgY29uc3QgY2hhciAqcG9zKQpAQCAtMjUyOCw2ICsyNzU4LDQzIEBACiAJcmV0dXJuIDA7CiB9CiAKKworc3RhdGljIGludCB3cGFfY29uZmlnX3Byb2Nlc3Nfd3BzX3ZlbmRvcl9leHRfbTEoCisJY29uc3Qgc3RydWN0IGdsb2JhbF9wYXJzZV9kYXRhICpkYXRhLAorCXN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBsaW5lLCBjb25zdCBjaGFyICpwb3MpCit7CisJc3RydWN0IHdwYWJ1ZiAqdG1wOworCWludCBsZW4gPSBvc19zdHJsZW4ocG9zKSAvIDI7CisJdTggKnA7CisKKwlpZiAoIWxlbikgeworCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6ICIKKwkJCSAgICJpbnZhbGlkIHdwc192ZW5kb3JfZXh0X20xIiwgbGluZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwl0bXAgPSB3cGFidWZfYWxsb2MobGVuKTsKKwlpZiAodG1wKSB7CisJCXAgPSB3cGFidWZfcHV0KHRtcCwgbGVuKTsKKworCQlpZiAoaGV4c3RyMmJpbihwb3MsIHAsIGxlbikpIHsKKwkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogIgorCQkJCSAgICJpbnZhbGlkIHdwc192ZW5kb3JfZXh0X20xIiwgbGluZSk7CisJCQl3cGFidWZfZnJlZSh0bXApOworCQkJcmV0dXJuIC0xOworCQl9CisKKwkJd3BhYnVmX2ZyZWUoY29uZmlnLT53cHNfdmVuZG9yX2V4dF9tMSk7CisJCWNvbmZpZy0+d3BzX3ZlbmRvcl9leHRfbTEgPSB0bXA7CisJfSBlbHNlIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJDYW4gbm90IGFsbG9jYXRlICIKKwkJCSAgICJtZW1vcnkgZm9yIHdwc192ZW5kb3JfZXh0X20xIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAogI2lmZGVmIENPTkZJR19QMlAKQEAgLTI1NTEsNiArMjgxOCw1NSBAQAogCWNvbmZpZy0+bnVtX3NlY19kZXZpY2VfdHlwZXMrKzsKIAlyZXR1cm4gMDsKIH0KKworCitzdGF0aWMgaW50IHdwYV9jb25maWdfcHJvY2Vzc19wMnBfcHJlZl9jaGFuKAorCWNvbnN0IHN0cnVjdCBnbG9iYWxfcGFyc2VfZGF0YSAqZGF0YSwKKwlzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnLCBpbnQgbGluZSwgY29uc3QgY2hhciAqcG9zKQoreworCXN0cnVjdCBwMnBfY2hhbm5lbCAqcHJlZiA9IE5VTEwsICpuOworCXVuc2lnbmVkIGludCBudW0gPSAwOworCWNvbnN0IGNoYXIgKnBvczI7CisJdTggb3BfY2xhc3MsIGNoYW47CisKKwkvKiBmb3JtYXQ6IGNsYXNzOmNoYW4sY2xhc3M6Y2hhbiwuLi4gKi8KKworCXdoaWxlICgqcG9zKSB7CisJCW9wX2NsYXNzID0gYXRvaShwb3MpOworCQlwb3MyID0gb3Nfc3RyY2hyKHBvcywgJzonKTsKKwkJaWYgKHBvczIgPT0gTlVMTCkKKwkJCWdvdG8gZmFpbDsKKwkJcG9zMisrOworCQljaGFuID0gYXRvaShwb3MyKTsKKworCQluID0gb3NfcmVhbGxvYyhwcmVmLCAobnVtICsgMSkgKiBzaXplb2Yoc3RydWN0IHAycF9jaGFubmVsKSk7CisJCWlmIChuID09IE5VTEwpCisJCQlnb3RvIGZhaWw7CisJCXByZWYgPSBuOworCQlwcmVmW251bV0ub3BfY2xhc3MgPSBvcF9jbGFzczsKKwkJcHJlZltudW1dLmNoYW4gPSBjaGFuOworCQludW0rKzsKKworCQlwb3MgPSBvc19zdHJjaHIocG9zMiwgJywnKTsKKwkJaWYgKHBvcyA9PSBOVUxMKQorCQkJYnJlYWs7CisJCXBvcysrOworCX0KKworCW9zX2ZyZWUoY29uZmlnLT5wMnBfcHJlZl9jaGFuKTsKKwljb25maWctPnAycF9wcmVmX2NoYW4gPSBwcmVmOworCWNvbmZpZy0+bnVtX3AycF9wcmVmX2NoYW4gPSBudW07CisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiUDJQOiBQcmVmZXJyZWQgY2xhc3MvY2hhbm5lbCBwYWlycyIsCisJCSAgICAodTggKikgY29uZmlnLT5wMnBfcHJlZl9jaGFuLAorCQkgICAgY29uZmlnLT5udW1fcDJwX3ByZWZfY2hhbiAqIHNpemVvZihzdHJ1Y3QgcDJwX2NoYW5uZWwpKTsKKworCXJldHVybiAwOworCitmYWlsOgorCW9zX2ZyZWUocHJlZik7CisJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBJbnZhbGlkIHAycF9wcmVmX2NoYW4gbGlzdCIsIGxpbmUpOworCXJldHVybiAtMTsKK30KICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKIApAQCAtMjU4Miw2ICsyODk4LDcgQEAKICNkZWZpbmUgX1NUUihmKSAjZiwgd3BhX2dsb2JhbF9jb25maWdfcGFyc2Vfc3RyLCBPRkZTRVQoZikKICNkZWZpbmUgU1RSKGYpIF9TVFIoZiksIE5VTEwsIE5VTEwKICNkZWZpbmUgU1RSX1JBTkdFKGYsIG1pbiwgbWF4KSBfU1RSKGYpLCAodm9pZCAqKSBtaW4sICh2b2lkICopIG1heAorI2RlZmluZSBCSU4oZikgI2YsIHdwYV9nbG9iYWxfY29uZmlnX3BhcnNlX2JpbiwgT0ZGU0VUKGYpLCBOVUxMLCBOVUxMCiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZ2xvYmFsX3BhcnNlX2RhdGEgZ2xvYmFsX2ZpZWxkc1tdID0gewogI2lmZGVmIENPTkZJR19DVFJMX0lGQUNFCkBAIC0yNTkwLDEwICsyOTA3LDEzIEBACiAjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0UgKi8KIAl7IElOVF9SQU5HRShlYXBvbF92ZXJzaW9uLCAxLCAyKSwgMCB9LAogCXsgSU5UKGFwX3NjYW4pLCAwIH0sCisJeyBJTlQoZGlzYWJsZV9zY2FuX29mZmxvYWQpLCAwIH0sCiAJeyBJTlQoZmFzdF9yZWF1dGgpLCAwIH0sCiAJeyBTVFIob3BlbnNjX2VuZ2luZV9wYXRoKSwgMCB9LAogCXsgU1RSKHBrY3MxMV9lbmdpbmVfcGF0aCksIDAgfSwKIAl7IFNUUihwa2NzMTFfbW9kdWxlX3BhdGgpLCAwIH0sCisJeyBTVFIocGNzY19yZWFkZXIpLCAwIH0sCisJeyBTVFIocGNzY19waW4pLCAwIH0sCiAJeyBTVFIoZHJpdmVyX3BhcmFtKSwgMCB9LAogCXsgSU5UKGRvdDExUlNOQUNvbmZpZ1BNS0xpZmV0aW1lKSwgMCB9LAogCXsgSU5UKGRvdDExUlNOQUNvbmZpZ1BNS1JlYXV0aFRocmVzaG9sZCksIDAgfSwKQEAgLTI2MTMsNiArMjkzMyw3IEBACiAJeyBGVU5DKG9zX3ZlcnNpb24pLCBDRkdfQ0hBTkdFRF9PU19WRVJTSU9OIH0sCiAJeyBTVFIoY29uZmlnX21ldGhvZHMpLCBDRkdfQ0hBTkdFRF9DT05GSUdfTUVUSE9EUyB9LAogCXsgSU5UX1JBTkdFKHdwc19jcmVkX3Byb2Nlc3NpbmcsIDAsIDIpLCAwIH0sCisJeyBGVU5DKHdwc192ZW5kb3JfZXh0X20xKSwgQ0ZHX0NIQU5HRURfVkVORE9SX0VYVEVOU0lPTiB9LAogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KICNpZmRlZiBDT05GSUdfUDJQCiAJeyBGVU5DKHNlY19kZXZpY2VfdHlwZSksIENGR19DSEFOR0VEX1NFQ19ERVZJQ0VfVFlQRSB9LApAQCAtMjYyNSw2ICsyOTQ2LDcgQEAKIAl7IElOVF9SQU5HRShwZXJzaXN0ZW50X3JlY29ubmVjdCwgMCwgMSksIDAgfSwKIAl7IElOVF9SQU5HRShwMnBfaW50cmFfYnNzLCAwLCAxKSwgQ0ZHX0NIQU5HRURfUDJQX0lOVFJBX0JTUyB9LAogCXsgSU5UKHAycF9ncm91cF9pZGxlKSwgMCB9LAorCXsgRlVOQyhwMnBfcHJlZl9jaGFuKSwgQ0ZHX0NIQU5HRURfUDJQX1BSRUZfQ0hBTiB9LAogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KICNpZmRlZiBBTkRST0lEX1AyUAogCXsgU1RSX1JBTkdFKHByaW9yaXRpemUsIDAsIDMyKSwgQ0ZHX0NIQU5HRURfSUZBQ0VfUFJJT1JJVFkgfSwKQEAgLTI2MzYsMTUgKzI5NTgsMTggQEAKIAl7IElOVF9SQU5HRShmaWx0ZXJfc3NpZHMsIDAsIDEpLCAwIH0sCiAJeyBJTlQobWF4X251bV9zdGEpLCAwIH0sCiAJeyBJTlRfUkFOR0UoZGlzYXNzb2NfbG93X2FjaywgMCwgMSksIDAgfSwKLQl7IFNUUihob21lX3JlYWxtKSwgMCB9LAotCXsgU1RSKGhvbWVfdXNlcm5hbWUpLCAwIH0sCi0JeyBTVFIoaG9tZV9wYXNzd29yZCksIDAgfSwKLQl7IFNUUihob21lX2NhX2NlcnQpLCAwIH0sCi0JeyBTVFIoaG9tZV9pbXNpKSwgMCB9LAotCXsgU1RSKGhvbWVfbWlsZW5hZ2UpLCAwIH0sCisjaWZkZWYgQ09ORklHX0hTMjAKKwl7IElOVF9SQU5HRShoczIwLCAwLCAxKSwgMCB9LAorI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJeyBJTlRfUkFOR0UoaW50ZXJ3b3JraW5nLCAwLCAxKSwgMCB9LAogCXsgRlVOQyhoZXNzaWQpLCAwIH0sCi0JeyBJTlRfUkFOR0UoYWNjZXNzX25ldHdvcmtfdHlwZSwgMCwgMTUpLCAwIH0KKwl7IElOVF9SQU5HRShhY2Nlc3NfbmV0d29ya190eXBlLCAwLCAxNSksIDAgfSwKKwl7IElOVF9SQU5HRShwYmNfaW5fbTEsIDAsIDEpLCAwIH0sCisJeyBTVFIoYXV0b3NjYW4pLCAwIH0sCisJeyBJTlRfUkFOR0Uod3BzX25mY19kZXZfcHdfaWQsIDB4MTAsIDB4ZmZmZiksIDAgfSwKKwl7IEJJTih3cHNfbmZjX2RoX3B1YmtleSksIDAgfSwKKwl7IEJJTih3cHNfbmZjX2RoX3ByaXZrZXkpLCAwIH0sCisJeyBCSU4od3BzX25mY19kZXZfcHcpLCAwIH0KIH07CiAKICN1bmRlZiBGVU5DCkBAIC0yNjU0LDYgKzI5NzksNyBAQAogI3VuZGVmIF9TVFIKICN1bmRlZiBTVFIKICN1bmRlZiBTVFJfUkFOR0UKKyN1bmRlZiBCSU4KICNkZWZpbmUgTlVNX0dMT0JBTF9GSUVMRFMgKHNpemVvZihnbG9iYWxfZmllbGRzKSAvIHNpemVvZihnbG9iYWxfZmllbGRzWzBdKSkKIAogCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9jb25maWcuaCBiL3dwYV9zdXBwbGljYW50L2NvbmZpZy5oCmluZGV4IDQzMmE1ZDQuLjA3NGUzODQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2NvbmZpZy5oCisrKyBiL3dwYV9zdXBwbGljYW50L2NvbmZpZy5oCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC8gQ29uZmlndXJhdGlvbiBmaWxlIHN0cnVjdHVyZXMKLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDA1LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTI4LDYgKzI4LDEyOSBAQAogI2luY2x1ZGUgIndwcy93cHMuaCIKIAogCitzdHJ1Y3Qgd3BhX2NyZWQgeworCS8qKgorCSAqIG5leHQgLSBOZXh0IGNyZWRlbnRpYWwgaW4gdGhlIGxpc3QKKwkgKgorCSAqIFRoaXMgcG9pbnRlciBjYW4gYmUgdXNlZCB0byBpdGVyYXRlIG92ZXIgYWxsIGNyZWRlbnRpYWxzLiBUaGUgaGVhZAorCSAqIG9mIHRoaXMgbGlzdCBpcyBzdG9yZWQgaW4gdGhlIGNyZWQgZmllbGQgb2Ygc3RydWN0IHdwYV9jb25maWcuCisJICovCisJc3RydWN0IHdwYV9jcmVkICpuZXh0OworCisJLyoqCisJICogaWQgLSBVbmlxdWUgaWQgZm9yIHRoZSBjcmVkZW50aWFsCisJICoKKwkgKiBUaGlzIGlkZW50aWZpZXIgaXMgdXNlZCBhcyBhIHVuaXF1ZSBpZGVudGlmaWVyIGZvciBlYWNoIGNyZWRlbnRpYWwKKwkgKiBibG9jayB3aGVuIHVzaW5nIHRoZSBjb250cm9sIGludGVyZmFjZS4gRWFjaCBjcmVkZW50aWFsIGlzIGFsbG9jYXRlZAorCSAqIGFuIGlkIHdoZW4gaXQgaXMgYmVpbmcgY3JlYXRlZCwgZWl0aGVyIHdoZW4gcmVhZGluZyB0aGUKKwkgKiBjb25maWd1cmF0aW9uIGZpbGUgb3Igd2hlbiBhIG5ldyBjcmVkZW50aWFsIGlzIGFkZGVkIHRocm91Z2ggdGhlCisJICogY29udHJvbCBpbnRlcmZhY2UuCisJICovCisJaW50IGlkOworCisJLyoqCisJICogcHJpb3JpdHkgLSBQcmlvcml0eSBncm91cAorCSAqCisJICogQnkgZGVmYXVsdCwgYWxsIG5ldHdvcmtzIGFuZCBjcmVkZW50aWFscyBnZXQgdGhlIHNhbWUgcHJpb3JpdHkgZ3JvdXAKKwkgKiAoMCkuIFRoaXMgZmllbGQgY2FuIGJlIHVzZWQgdG8gZ2l2ZSBoaWdoZXIgcHJpb3JpdHkgZm9yIGNyZWRlbnRpYWxzCisJICogKGFuZCBzaW1pbGFybHkgaW4gc3RydWN0IHdwYV9zc2lkIGZvciBuZXR3b3JrIGJsb2NrcykgdG8gY2hhbmdlIHRoZQorCSAqIEludGVyd29ya2luZyBhdXRvbWF0aWMgbmV0d29ya2luZyBzZWxlY3Rpb24gYmVoYXZpb3IuIFRoZSBtYXRjaGluZworCSAqIG5ldHdvcmsgKGJhc2VkIG9uIGVpdGhlciBhbiBlbmFibGVkIG5ldHdvcmsgYmxvY2sgb3IgYSBjcmVkZW50aWFsKQorCSAqIHdpdGggdGhlIGhpZ2hlc3QgcHJpb3JpdHkgdmFsdWUgd2lsbCBiZSBzZWxlY3RlZC4KKwkgKi8KKwlpbnQgcHJpb3JpdHk7CisKKwkvKioKKwkgKiBwY3NjIC0gVXNlIFBDL1NDIGFuZCBTSU0vVVNJTSBjYXJkCisJICovCisJaW50IHBjc2M7CisKKwkvKioKKwkgKiByZWFsbSAtIEhvbWUgUmVhbG0gZm9yIEludGVyd29ya2luZworCSAqLworCWNoYXIgKnJlYWxtOworCisJLyoqCisJICogdXNlcm5hbWUgLSBVc2VybmFtZSBmb3IgSW50ZXJ3b3JraW5nIG5ldHdvcmsgc2VsZWN0aW9uCisJICovCisJY2hhciAqdXNlcm5hbWU7CisKKwkvKioKKwkgKiBwYXNzd29yZCAtIFBhc3N3b3JkIGZvciBJbnRlcndvcmtpbmcgbmV0d29yayBzZWxlY3Rpb24KKwkgKi8KKwljaGFyICpwYXNzd29yZDsKKworCS8qKgorCSAqIGNhX2NlcnQgLSBDQSBjZXJ0aWZpY2F0ZSBmb3IgSW50ZXJ3b3JraW5nIG5ldHdvcmsgc2VsZWN0aW9uCisJICovCisJY2hhciAqY2FfY2VydDsKKworCS8qKgorCSAqIGNsaWVudF9jZXJ0IC0gRmlsZSBwYXRoIHRvIGNsaWVudCBjZXJ0aWZpY2F0ZSBmaWxlIChQRU0vREVSKQorCSAqCisJICogVGhpcyBmaWVsZCBpcyB1c2VkIHdpdGggSW50ZXJ3b3JraW5nIG5ldHdvcmtpbmcgc2VsZWN0aW9uIGZvciBhIGNhc2UKKwkgKiB3aGVyZSBjbGllbnQgY2VydGlmaWNhdGUvcHJpdmF0ZSBrZXkgaXMgdXNlZCBmb3IgYXV0aGVudGljYXRpb24KKwkgKiAoRUFQLVRMUykuIEZ1bGwgcGF0aCB0byB0aGUgZmlsZSBzaG91bGQgYmUgdXNlZCBzaW5jZSB3b3JraW5nCisJICogZGlyZWN0b3J5IG1heSBjaGFuZ2Ugd2hlbiB3cGFfc3VwcGxpY2FudCBpcyBydW4gaW4gdGhlIGJhY2tncm91bmQuCisJICoKKwkgKiBBbHRlcm5hdGl2ZWx5LCBhIG5hbWVkIGNvbmZpZ3VyYXRpb24gYmxvYiBjYW4gYmUgdXNlZCBieSBzZXR0aW5nCisJICogdGhpcyB0byBibG9iOi8vYmxvYl9uYW1lLgorCSAqLworCWNoYXIgKmNsaWVudF9jZXJ0OworCisJLyoqCisJICogcHJpdmF0ZV9rZXkgLSBGaWxlIHBhdGggdG8gY2xpZW50IHByaXZhdGUga2V5IGZpbGUgKFBFTS9ERVIvUEZYKQorCSAqCisJICogV2hlbiBQS0NTIzEyL1BGWCBmaWxlICgucDEyLy5wZngpIGlzIHVzZWQsIGNsaWVudF9jZXJ0IHNob3VsZCBiZQorCSAqIGNvbW1lbnRlZCBvdXQuIEJvdGggdGhlIHByaXZhdGUga2V5IGFuZCBjZXJ0aWZpY2F0ZSB3aWxsIGJlIHJlYWQKKwkgKiBmcm9tIHRoZSBQS0NTIzEyIGZpbGUgaW4gdGhpcyBjYXNlLiBGdWxsIHBhdGggdG8gdGhlIGZpbGUgc2hvdWxkIGJlCisJICogdXNlZCBzaW5jZSB3b3JraW5nIGRpcmVjdG9yeSBtYXkgY2hhbmdlIHdoZW4gd3BhX3N1cHBsaWNhbnQgaXMgcnVuCisJICogaW4gdGhlIGJhY2tncm91bmQuCisJICoKKwkgKiBXaW5kb3dzIGNlcnRpZmljYXRlIHN0b3JlIGNhbiBiZSB1c2VkIGJ5IGxlYXZpbmcgY2xpZW50X2NlcnQgb3V0IGFuZAorCSAqIGNvbmZpZ3VyaW5nIHByaXZhdGVfa2V5IGluIG9uZSBvZiB0aGUgZm9sbG93aW5nIGZvcm1hdHM6CisJICoKKwkgKiBjZXJ0Oi8vc3Vic3RyaW5nX3RvX21hdGNoCisJICoKKwkgKiBoYXNoOi8vY2VydGlmaWNhdGVfdGh1bWJwcmludF9pbl9oZXgKKwkgKgorCSAqIEZvciBleGFtcGxlOiBwcml2YXRlX2tleT0iaGFzaDovLzYzMDkzYWE5YzQ3ZjU2YWU4ODMzNGM3YjY1YTQiCisJICoKKwkgKiBOb3RlIHRoYXQgd2hlbiBydW5uaW5nIHdwYV9zdXBwbGljYW50IGFzIGFuIGFwcGxpY2F0aW9uLCB0aGUgdXNlcgorCSAqIGNlcnRpZmljYXRlIHN0b3JlIChNeSB1c2VyIGFjY291bnQpIGlzIHVzZWQsIHdoZXJlYXMgY29tcHV0ZXIgc3RvcmUKKwkgKiAoQ29tcHV0ZXIgYWNjb3VudCkgaXMgdXNlZCB3aGVuIHJ1bm5pbmcgd3Bhc3ZjIGFzIGEgc2VydmljZS4KKwkgKgorCSAqIEFsdGVybmF0aXZlbHksIGEgbmFtZWQgY29uZmlndXJhdGlvbiBibG9iIGNhbiBiZSB1c2VkIGJ5IHNldHRpbmcKKwkgKiB0aGlzIHRvIGJsb2I6Ly9ibG9iX25hbWUuCisJICovCisJY2hhciAqcHJpdmF0ZV9rZXk7CisKKwkvKioKKwkgKiBwcml2YXRlX2tleV9wYXNzd2QgLSBQYXNzd29yZCBmb3IgcHJpdmF0ZSBrZXkgZmlsZQorCSAqLworCWNoYXIgKnByaXZhdGVfa2V5X3Bhc3N3ZDsKKworCS8qKgorCSAqIGltc2kgLSBJTVNJIGluIDxNQ0M+IHwgPE1OQz4gfCAnLScgfCA8TVNJTj4gZm9ybWF0CisJICovCisJY2hhciAqaW1zaTsKKworCS8qKgorCSAqIG1pbGVuYWdlIC0gTWlsZW5hZ2UgcGFyYW1ldGVycyBmb3IgU0lNL1VTSU0gc2ltdWxhdG9yIGluCisJICoJPEtpPjo8T1BjPjo8U1FOPiBmb3JtYXQKKwkgKi8KKwljaGFyICptaWxlbmFnZTsKKworCS8qKgorCSAqIGRvbWFpbiAtIEhvbWUgc2VydmljZSBwcm92aWRlciBGUUROCisJICoKKwkgKiBUaGlzIGlzIHVzZWQgdG8gY29tcGFyZSBhZ2FpbnN0IHRoZSBEb21haW4gTmFtZSBMaXN0IHRvIGZpZ3VyZSBvdXQKKwkgKiB3aGV0aGVyIHRoZSBBUCBpcyBvcGVyYXRlZCBieSB0aGUgSG9tZSBTUC4KKwkgKi8KKwljaGFyICpkb21haW47Cit9OworCisKICNkZWZpbmUgQ0ZHX0NIQU5HRURfREVWSUNFX05BTUUgQklUKDApCiAjZGVmaW5lIENGR19DSEFOR0VEX0NPTkZJR19NRVRIT0RTIEJJVCgxKQogI2RlZmluZSBDRkdfQ0hBTkdFRF9ERVZJQ0VfVFlQRSBCSVQoMikKQEAgLTQxLDggKzE2NCw5IEBACiAjZGVmaW5lIENGR19DSEFOR0VEX1ZFTkRPUl9FWFRFTlNJT04gQklUKDEwKQogI2RlZmluZSBDRkdfQ0hBTkdFRF9QMlBfTElTVEVOX0NIQU5ORUwgQklUKDExKQogI2RlZmluZSBDRkdfQ0hBTkdFRF9QMlBfT1BFUl9DSEFOTkVMIEJJVCgxMikKKyNkZWZpbmUgQ0ZHX0NIQU5HRURfUDJQX1BSRUZfQ0hBTiBCSVQoMTMpCiAjaWZkZWYgQU5EUk9JRF9QMlAKLSNkZWZpbmUgQ0ZHX0NIQU5HRURfSUZBQ0VfUFJJT1JJVFkgQklUKDEzKQorI2RlZmluZSBDRkdfQ0hBTkdFRF9JRkFDRV9QUklPUklUWSBCSVQoMTQpCiAjZW5kaWYKIAogLyoqCkBAIC03NSw2ICsxOTksMTMgQEAKIAlpbnQgbnVtX3ByaW87CiAKIAkvKioKKwkgKiBjcmVkIC0gSGVhZCBvZiB0aGUgY3JlZGVudGlhbCBsaXN0CisJICoKKwkgKiBUaGlzIGlzIHRoZSBoZWFkIGZvciB0aGUgbGlzdCBvZiBhbGwgdGhlIGNvbmZpZ3VyZWQgY3JlZGVudGlhbHMuCisJICovCisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworCisJLyoqCiAJICogZWFwb2xfdmVyc2lvbiAtIElFRUUgODAyLjFYL0VBUE9MIHZlcnNpb24gbnVtYmVyCiAJICoKIAkgKiB3cGFfc3VwcGxpY2FudCBpcyBpbXBsZW1lbnRlZCBiYXNlZCBvbiBJRUVFIFN0ZCA4MDIuMVgtMjAwNCB3aGljaApAQCAtMTE2LDYgKzI0NywxNSBAQAogCWludCBhcF9zY2FuOwogCiAJLyoqCisJICogZGlzYWJsZV9zY2FuX29mZmxvYWQgLSBEaXNhYmxlIGF1dG9tYXRpYyBvZmZsb2FkaW5nIG9mIHNjYW4gcmVxdWVzdHMKKwkgKgorCSAqIEJ5IGRlZmF1bHQsICV3cGFfc3VwcGxpY2FudCB0cmllcyB0byBvZmZsb2FkIHNjYW5uaW5nIGlmIHRoZSBkcml2ZXIKKwkgKiBpbmRpY2F0ZXMgc3VwcG9ydCBmb3IgdGhpcyAoc2NoZWRfc2NhbikuIFRoaXMgY29uZmlndXJhdGlvbgorCSAqIHBhcmFtZXRlciBjYW4gYmUgdXNlZCB0byBkaXNhYmxlIHRoaXMgb2ZmbG9hZGluZyBtZWNoYW5pc20uCisJICovCisJaW50IGRpc2FibGVfc2Nhbl9vZmZsb2FkOworCisJLyoqCiAJICogY3RybF9pbnRlcmZhY2UgLSBQYXJhbWV0ZXJzIGZvciB0aGUgY29udHJvbCBpbnRlcmZhY2UKIAkgKgogCSAqIElmIHRoaXMgaXMgc3BlY2lmaWVkLCAld3BhX3N1cHBsaWNhbnQgd2lsbCBvcGVuIGEgY29udHJvbCBpbnRlcmZhY2UKQEAgLTIxNCw2ICszNTQsMjMgQEAKIAljaGFyICpwa2NzMTFfbW9kdWxlX3BhdGg7CiAKIAkvKioKKwkgKiBwY3NjX3JlYWRlciAtIFBDL1NDIHJlYWRlciBuYW1lIHByZWZpeAorCSAqCisJICogSWYgbm90ICVOVUxMLCBQQy9TQyByZWFkZXIgd2l0aCBhIG5hbWUgdGhhdCBtYXRjaGVzIHRoaXMgcHJlZml4IGlzCisJICogaW5pdGlhbGl6ZWQgZm9yIFNJTS9VU0lNIGFjY2Vzcy4gRW1wdHkgc3RyaW5nIGNhbiBiZSB1c2VkIHRvIG1hdGNoCisJICogdGhlIGZpcnN0IGF2YWlsYWJsZSByZWFkZXIuCisJICovCisJY2hhciAqcGNzY19yZWFkZXI7CisKKwkvKioKKwkgKiBwY3NjX3BpbiAtIFBJTiBmb3IgVVNJTSwgR1NNIFNJTSwgYW5kIHNtYXJ0Y2FyZHMKKwkgKgorCSAqIFRoaXMgZmllbGQgaXMgdXNlZCB0byBjb25maWd1cmUgUElOIGZvciBTSU0vVVNJTSBmb3IgRUFQLVNJTSBhbmQKKwkgKiBFQVAtQUtBLiBJZiBsZWZ0IG91dCwgdGhpcyB3aWxsIGJlIGFza2VkIHRocm91Z2ggY29udHJvbCBpbnRlcmZhY2UuCisJICovCisJY2hhciAqcGNzY19waW47CisKKwkvKioKIAkgKiBkcml2ZXJfcGFyYW0gLSBEcml2ZXIgaW50ZXJmYWNlIHBhcmFtZXRlcnMKIAkgKgogCSAqIFRoaXMgdGV4dCBzdHJpbmcgaXMgcGFzc2VkIHRvIHRoZSBzZWxlY3RlZCBkcml2ZXIgaW50ZXJmYWNlIHdpdGggdGhlCkBAIC0zNTksNiArNTE2LDEwIEBACiAJY2hhciAqcDJwX3NzaWRfcG9zdGZpeDsKIAlpbnQgcGVyc2lzdGVudF9yZWNvbm5lY3Q7CiAJaW50IHAycF9pbnRyYV9ic3M7CisJdW5zaWduZWQgaW50IG51bV9wMnBfcHJlZl9jaGFuOworCXN0cnVjdCBwMnBfY2hhbm5lbCAqcDJwX3ByZWZfY2hhbjsKKworCXN0cnVjdCB3cGFidWYgKndwc192ZW5kb3JfZXh0X20xOwogCiAjZGVmaW5lIE1BWF9XUFNfVkVORE9SX0VYVCAxMAogCS8qKgpAQCAtMzc3LDkgKzUzOCwxMiBAQAogCSAqIHN0YXRlIGluZGVmaW5pdGVseSB1bnRpbCBleHBsaWNpdGx5IHJlbW92ZWQuIEFzIGEgUDJQIGNsaWVudCwgdGhlCiAJICogbWF4aW11bSBpZGxlIHRpbWUgb2YgUDJQX01BWF9DTElFTlRfSURMRSBzZWNvbmRzIGlzIGVuZm9yY2VkLCBpLmUuLAogCSAqIHRoaXMgcGFyYW1ldGVyIGlzIG1haW5seSBtZWFudCBmb3IgR08gdXNlIGFuZCBmb3IgUDJQIGNsaWVudCwgaXQgY2FuCi0JICogb25seSBiZSB1c2VkIHRvIHJlZHVjZSB0aGUgZGVmYXVsdCB0aW1lb3V0IHRvIHNtYWxsZXIgdmFsdWUuCisJICogb25seSBiZSB1c2VkIHRvIHJlZHVjZSB0aGUgZGVmYXVsdCB0aW1lb3V0IHRvIHNtYWxsZXIgdmFsdWUuIEEKKwkgKiBzcGVjaWFsIHZhbHVlIC0xIGNhbiBiZSB1c2VkIHRvIGNvbmZpZ3VyZSBpbW1lZGlhdGUgcmVtb3ZhbCBvZiB0aGUKKwkgKiBncm91cCBmb3IgUDJQIGNsaWVudCByb2xlIG9uIGFueSBkaXNjb25uZWN0aW9uIGFmdGVyIHRoZSBkYXRhCisJICogY29ubmVjdGlvbiBoYXMgYmVlbiBlc3RhYmxpc2hlZC4KIAkgKi8KLQl1bnNpZ25lZCBpbnQgcDJwX2dyb3VwX2lkbGU7CisJaW50IHAycF9ncm91cF9pZGxlOwogCiAJLyoqCiAJICogYnNzX21heF9jb3VudCAtIE1heGltdW0gbnVtYmVyIG9mIEJTUyBlbnRyaWVzIHRvIGtlZXAgaW4gbWVtb3J5CkBAIC00NTIsMzUgKzYxNiw1NSBAQAogCXU4IGhlc3NpZFtFVEhfQUxFTl07CiAKIAkvKioKLQkgKiBob21lX3JlYWxtIC0gSG9tZSBSZWFsbSBmb3IgSW50ZXJ3b3JraW5nCisJICogaHMyMCAtIEhvdHNwb3QgMi4wCiAJICovCi0JY2hhciAqaG9tZV9yZWFsbTsKKwlpbnQgaHMyMDsKIAogCS8qKgotCSAqIGhvbWVfdXNlcm5hbWUgLSBVc2VybmFtZSBmb3IgSW50ZXJ3b3JraW5nIG5ldHdvcmsgc2VsZWN0aW9uCisJICogcGJjX2luX20xIC0gQVAgbW9kZSBXUFMgcHJvYmluZyB3b3JrYXJvdW5kIGZvciBQQkMgd2l0aCBXaW5kb3dzIDcKKwkgKgorCSAqIFdpbmRvd3MgNyB1c2VzIGluY29ycmVjdCB3YXkgb2YgZmlndXJpbmcgb3V0IEFQJ3MgV1BTIGNhcGFiaWxpdGllcworCSAqIGJ5IGFjdGluZyBhcyBhIFJlZ2lzdHJhciBhbmQgdXNpbmcgTTEgZnJvbSB0aGUgQVAuIFRoZSBjb25maWcKKwkgKiBtZXRob2RzIGF0dHJpYnV0ZSBpbiB0aGF0IG1lc3NhZ2UgaXMgc3VwcG9zZWQgdG8gaW5kaWNhdGUgb25seSB0aGUKKwkgKiBjb25maWd1cmF0aW9uIG1ldGhvZCBzdXBwb3J0ZWQgYnkgdGhlIEFQIGluIEVucm9sbGVlIHJvbGUsIGkuZS4sIHRvCisJICogYWRkIGFuIGV4dGVybmFsIFJlZ2lzdHJhci4gRm9yIHRoYXQgY2FzZSwgUEJDIHNoYWxsIG5vdCBiZSB1c2VkIGFuZAorCSAqIGFzIHN1Y2gsIHRoZSBQdXNoQnV0dG9uIGNvbmZpZyBtZXRob2QgaXMgcmVtb3ZlZCBmcm9tIE0xIGJ5IGRlZmF1bHQuCisJICogSWYgcGJjX2luX20xPTEgaXMgaW5jbHVkZWQgaW4gdGhlIGNvbmZpZ3VyYXRpb24gZmlsZSwgdGhlIFB1c2hCdXR0b24KKwkgKiBjb25maWcgbWV0aG9kIGlzIGxlZnQgaW4gTTEgKGlmIGluY2x1ZGVkIGluIGNvbmZpZ19tZXRob2RzCisJICogcGFyYW1ldGVyKSB0byBhbGxvdyBXaW5kb3dzIDcgdG8gdXNlIFBCQyBpbnN0ZWFkIG9mIFBJTiAoZS5nLiwgZnJvbQorCSAqIGEgbGFiZWwgaW4gdGhlIEFQKS4KIAkgKi8KLQljaGFyICpob21lX3VzZXJuYW1lOworCWludCBwYmNfaW5fbTE7CiAKIAkvKioKLQkgKiBob21lX3Bhc3N3b3JkIC0gUGFzc3dvcmQgZm9yIEludGVyd29ya2luZyBuZXR3b3JrIHNlbGVjdGlvbgorCSAqIGF1dG9zY2FuIC0gQXV0b21hdGljIHNjYW4gcGFyYW1ldGVycyBvciAlTlVMTCBpZiBub25lCisJICoKKwkgKiBUaGlzIGlzIGFuIG9wdGlvbmFsIHNldCBvZiBwYXJhbWV0ZXJzIGZvciBhdXRvbWF0aWMgc2Nhbm5pbmcKKwkgKiB3aXRoaW4gYW4gaW50ZXJmYWNlIGluIGZvbGxvd2luZyBmb3JtYXQ6CisJICogPGF1dG9zY2FuIG1vZHVsZSBuYW1lPjo8bW9kdWxlIHBhcmFtZXRlcnM+CiAJICovCi0JY2hhciAqaG9tZV9wYXNzd29yZDsKKwljaGFyICphdXRvc2NhbjsKIAogCS8qKgotCSAqIGhvbWVfY2FfY2VydCAtIENBIGNlcnRpZmljYXRlIGZvciBJbnRlcndvcmtpbmcgbmV0d29yayBzZWxlY3Rpb24KKwkgKiB3cHNfbmZjX2Rldl9wd19pZCAtIE5GQyBEZXZpY2UgUGFzc3dvcmQgSUQgZm9yIHBhc3N3b3JkIHRva2VuCiAJICovCi0JY2hhciAqaG9tZV9jYV9jZXJ0OworCWludCB3cHNfbmZjX2Rldl9wd19pZDsKIAogCS8qKgotCSAqIGhvbWVfaW1zaSAtIElNU0kgaW4gPE1DQz4gfCA8TU5DPiB8ICctJyB8IDxNU0lOPiBmb3JtYXQKKwkgKiB3cHNfbmZjX2RoX3B1YmtleSAtIE5GQyBESCBQdWJsaWMgS2V5IGZvciBwYXNzd29yZCB0b2tlbgogCSAqLwotCWNoYXIgKmhvbWVfaW1zaTsKKwlzdHJ1Y3Qgd3BhYnVmICp3cHNfbmZjX2RoX3B1YmtleTsKIAogCS8qKgotCSAqIGhvbWVfbWlsZW5hZ2UgLSBNaWxlbmFnZSBwYXJhbWV0ZXJzIGZvciBTSU0vVVNJTSBzaW11bGF0b3IgaW4KLQkgKgk8S2k+OjxPUGM+OjxTUU4+IGZvcm1hdAorCSAqIHdwc19uZmNfZGhfcHVia2V5IC0gTkZDIERIIFByaXZhdGUgS2V5IGZvciBwYXNzd29yZCB0b2tlbgogCSAqLwotCWNoYXIgKmhvbWVfbWlsZW5hZ2U7CisJc3RydWN0IHdwYWJ1ZiAqd3BzX25mY19kaF9wcml2a2V5OworCisJLyoqCisJICogd3BzX25mY19kaF9wdWJrZXkgLSBORkMgRGV2aWNlIFBhc3N3b3JkIGZvciBwYXNzd29yZCB0b2tlbgorCSAqLworCXN0cnVjdCB3cGFidWYgKndwc19uZmNfZGV2X3B3OworCiAjaWZkZWYgQU5EUk9JRF9QMlAKIAkvKioKIAkgKiBwcmlvcml0aXplIC0gUHJpb3JpdGl6ZSBhbiBJbnRlcmZhY2UKQEAgLTUyMiw2ICs3MDYsMTMgQEAKIHZvaWQgd3BhX2NvbmZpZ19mcmVlX2Jsb2Ioc3RydWN0IHdwYV9jb25maWdfYmxvYiAqYmxvYik7CiBpbnQgd3BhX2NvbmZpZ19yZW1vdmVfYmxvYihzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnLCBjb25zdCBjaGFyICpuYW1lKTsKIAorc3RydWN0IHdwYV9jcmVkICogd3BhX2NvbmZpZ19nZXRfY3JlZChzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnLCBpbnQgaWQpOworc3RydWN0IHdwYV9jcmVkICogd3BhX2NvbmZpZ19hZGRfY3JlZChzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZmlnKTsKK2ludCB3cGFfY29uZmlnX3JlbW92ZV9jcmVkKHN0cnVjdCB3cGFfY29uZmlnICpjb25maWcsIGludCBpZCk7Cit2b2lkIHdwYV9jb25maWdfZnJlZV9jcmVkKHN0cnVjdCB3cGFfY3JlZCAqY3JlZCk7CitpbnQgd3BhX2NvbmZpZ19zZXRfY3JlZChzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsIGNvbnN0IGNoYXIgKnZhciwKKwkJCWNvbnN0IGNoYXIgKnZhbHVlLCBpbnQgbGluZSk7CisKIHN0cnVjdCB3cGFfY29uZmlnICogd3BhX2NvbmZpZ19hbGxvY19lbXB0eShjb25zdCBjaGFyICpjdHJsX2ludGVyZmFjZSwKIAkJCQkJICAgY29uc3QgY2hhciAqZHJpdmVyX3BhcmFtKTsKICNpZm5kZWYgQ09ORklHX05PX1NURE9VVF9ERUJVRwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnX2ZpbGUuYyBiL3dwYV9zdXBwbGljYW50L2NvbmZpZ19maWxlLmMKaW5kZXggYTE5NTVkNC4uOGJhZGM3YiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvY29uZmlnX2ZpbGUuYworKysgYi93cGFfc3VwcGxpY2FudC9jb25maWdfZmlsZS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC8gQ29uZmlndXJhdGlvbiBiYWNrZW5kOiB0ZXh0IGZpbGUKLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDA4LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgorICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTIsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTE2LDYgKzE2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJiYXNlNjQuaCIKICNpbmNsdWRlICJ1dWlkLmgiCisjaW5jbHVkZSAicDJwL3AycC5oIgogCiAKIC8qKgpAQCAtMTc4LDYgKzE3OSw2MSBAQAogfQogCiAKK3N0YXRpYyBzdHJ1Y3Qgd3BhX2NyZWQgKiB3cGFfY29uZmlnX3JlYWRfY3JlZChGSUxFICpmLCBpbnQgKmxpbmUsIGludCBpZCkKK3sKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQ7CisJaW50IGVycm9ycyA9IDAsIGVuZCA9IDA7CisJY2hhciBidWZbMjU2XSwgKnBvcywgKnBvczI7CisKKwl3cGFfcHJpbnRmKE1TR19NU0dEVU1QLCAiTGluZTogJWQgLSBzdGFydCBvZiBhIG5ldyBjcmVkIGJsb2NrIiwgKmxpbmUpOworCWNyZWQgPSBvc196YWxsb2Moc2l6ZW9mKCpjcmVkKSk7CisJaWYgKGNyZWQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisJY3JlZC0+aWQgPSBpZDsKKworCXdoaWxlICh3cGFfY29uZmlnX2dldF9saW5lKGJ1Ziwgc2l6ZW9mKGJ1ZiksIGYsIGxpbmUsICZwb3MpKSB7CisJCWlmIChvc19zdHJjbXAocG9zLCAifSIpID09IDApIHsKKwkJCWVuZCA9IDE7CisJCQlicmVhazsKKwkJfQorCisJCXBvczIgPSBvc19zdHJjaHIocG9zLCAnPScpOworCQlpZiAocG9zMiA9PSBOVUxMKSB7CisJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIkxpbmUgJWQ6IEludmFsaWQgY3JlZCBsaW5lICIKKwkJCQkgICAiJyVzJy4iLCAqbGluZSwgcG9zKTsKKwkJCWVycm9ycysrOworCQkJY29udGludWU7CisJCX0KKworCQkqcG9zMisrID0gJ1wwJzsKKwkJaWYgKCpwb3MyID09ICciJykgeworCQkJaWYgKG9zX3N0cmNocihwb3MyICsgMSwgJyInKSA9PSBOVUxMKSB7CisJCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJMaW5lICVkOiBpbnZhbGlkICIKKwkJCQkJICAgInF1b3RhdGlvbiAnJXMnLiIsICpsaW5lLCBwb3MyKTsKKwkJCQllcnJvcnMrKzsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJfQorCisJCWlmICh3cGFfY29uZmlnX3NldF9jcmVkKGNyZWQsIHBvcywgcG9zMiwgKmxpbmUpIDwgMCkKKwkJCWVycm9ycysrOworCX0KKworCWlmICghZW5kKSB7CisJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogY3JlZCBibG9jayB3YXMgbm90ICIKKwkJCSAgICJ0ZXJtaW5hdGVkIHByb3Blcmx5LiIsICpsaW5lKTsKKwkJZXJyb3JzKys7CisJfQorCisJaWYgKGVycm9ycykgeworCQl3cGFfY29uZmlnX2ZyZWVfY3JlZChjcmVkKTsKKwkJY3JlZCA9IE5VTEw7CisJfQorCisJcmV0dXJuIGNyZWQ7Cit9CisKKwogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX0JMT0JTCiBzdGF0aWMgc3RydWN0IHdwYV9jb25maWdfYmxvYiAqIHdwYV9jb25maWdfcmVhZF9ibG9iKEZJTEUgKmYsIGludCAqbGluZSwKIAkJCQkJCSAgICAgY29uc3QgY2hhciAqbmFtZSkKQEAgLTI2NCwxMSArMzIwLDEzIEBACiBzdHJ1Y3Qgd3BhX2NvbmZpZyAqIHdwYV9jb25maWdfcmVhZChjb25zdCBjaGFyICpuYW1lKQogewogCUZJTEUgKmY7Ci0JY2hhciBidWZbMjU2XSwgKnBvczsKKwljaGFyIGJ1Zls1MTJdLCAqcG9zOwogCWludCBlcnJvcnMgPSAwLCBsaW5lID0gMDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsICp0YWlsID0gTlVMTCwgKmhlYWQgPSBOVUxMOworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgKmNyZWRfdGFpbCA9IE5VTEwsICpjcmVkX2hlYWQgPSBOVUxMOwogCXN0cnVjdCB3cGFfY29uZmlnICpjb25maWc7CiAJaW50IGlkID0gMDsKKwlpbnQgY3JlZF9pZCA9IDA7CiAKIAljb25maWcgPSB3cGFfY29uZmlnX2FsbG9jX2VtcHR5KE5VTEwsIE5VTEwpOwogCWlmIChjb25maWcgPT0gTlVMTCkKQEAgLTMwMiw2ICszNjAsMjAgQEAKIAkJCQllcnJvcnMrKzsKIAkJCQljb250aW51ZTsKIAkJCX0KKwkJfSBlbHNlIGlmIChvc19zdHJjbXAocG9zLCAiY3JlZD17IikgPT0gMCkgeworCQkJY3JlZCA9IHdwYV9jb25maWdfcmVhZF9jcmVkKGYsICZsaW5lLCBjcmVkX2lkKyspOworCQkJaWYgKGNyZWQgPT0gTlVMTCkgeworCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiTGluZSAlZDogZmFpbGVkIHRvICIKKwkJCQkJICAgInBhcnNlIGNyZWQgYmxvY2suIiwgbGluZSk7CisJCQkJZXJyb3JzKys7CisJCQkJY29udGludWU7CisJCQl9CisJCQlpZiAoY3JlZF9oZWFkID09IE5VTEwpIHsKKwkJCQljcmVkX2hlYWQgPSBjcmVkX3RhaWwgPSBjcmVkOworCQkJfSBlbHNlIHsKKwkJCQljcmVkX3RhaWwtPm5leHQgPSBjcmVkOworCQkJCWNyZWRfdGFpbCA9IGNyZWQ7CisJCQl9CiAjaWZuZGVmIENPTkZJR19OT19DT05GSUdfQkxPQlMKIAkJfSBlbHNlIGlmIChvc19zdHJuY21wKHBvcywgImJsb2ItYmFzZTY0LSIsIDEyKSA9PSAwKSB7CiAJCQlpZiAod3BhX2NvbmZpZ19wcm9jZXNzX2Jsb2IoY29uZmlnLCBmLCAmbGluZSwgcG9zICsgMTIpCkBAIC0zMjIsNiArMzk0LDcgQEAKIAogCWNvbmZpZy0+c3NpZCA9IGhlYWQ7CiAJd3BhX2NvbmZpZ19kZWJ1Z19kdW1wX25ldHdvcmtzKGNvbmZpZyk7CisJY29uZmlnLT5jcmVkID0gY3JlZF9oZWFkOwogCiAjaWZuZGVmIFdQQV9JR05PUkVfQ09ORklHX0VSUk9SUwogCWlmIChlcnJvcnMpIHsKQEAgLTUxNSw5ICs1ODgsMTIgQEAKIAl3cml0ZV9wc2soZiwgc3NpZCk7CiAJd3JpdGVfcHJvdG8oZiwgc3NpZCk7CiAJd3JpdGVfa2V5X21nbXQoZiwgc3NpZCk7CisJSU5UX0RFRihiZ19zY2FuX3BlcmlvZCwgREVGQVVMVF9CR19TQ0FOX1BFUklPRCk7CiAJd3JpdGVfcGFpcndpc2UoZiwgc3NpZCk7CiAJd3JpdGVfZ3JvdXAoZiwgc3NpZCk7CiAJd3JpdGVfYXV0aF9hbGcoZiwgc3NpZCk7CisJU1RSKGJnc2Nhbik7CisJU1RSKGF1dG9zY2FuKTsKICNpZmRlZiBJRUVFODAyMVhfRUFQT0wKIAl3cml0ZV9lYXAoZiwgc3NpZCk7CiAJU1RSKGlkZW50aXR5KTsKQEAgLTU4Myw2ICs2NTksMjkgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFfY29uZmlnX3dyaXRlX2NyZWQoRklMRSAqZiwgc3RydWN0IHdwYV9jcmVkICpjcmVkKQoreworCWlmIChjcmVkLT5wcmlvcml0eSkKKwkJZnByaW50ZihmLCAiXHRwcmlvcml0eT0lZFxuIiwgY3JlZC0+cHJpb3JpdHkpOworCWlmIChjcmVkLT5wY3NjKQorCQlmcHJpbnRmKGYsICJcdHBjc2M9JWRcbiIsIGNyZWQtPnBjc2MpOworCWlmIChjcmVkLT5yZWFsbSkKKwkJZnByaW50ZihmLCAiXHRyZWFsbT1cIiVzXCJcbiIsIGNyZWQtPnJlYWxtKTsKKwlpZiAoY3JlZC0+dXNlcm5hbWUpCisJCWZwcmludGYoZiwgIlx0dXNlcm5hbWU9XCIlc1wiXG4iLCBjcmVkLT51c2VybmFtZSk7CisJaWYgKGNyZWQtPnBhc3N3b3JkKQorCQlmcHJpbnRmKGYsICJcdHBhc3N3b3JkPVwiJXNcIlxuIiwgY3JlZC0+cGFzc3dvcmQpOworCWlmIChjcmVkLT5jYV9jZXJ0KQorCQlmcHJpbnRmKGYsICJcdGNhX2NlcnQ9XCIlc1wiXG4iLCBjcmVkLT5jYV9jZXJ0KTsKKwlpZiAoY3JlZC0+aW1zaSkKKwkJZnByaW50ZihmLCAiXHRpbXNpPVwiJXNcIlxuIiwgY3JlZC0+aW1zaSk7CisJaWYgKGNyZWQtPm1pbGVuYWdlKQorCQlmcHJpbnRmKGYsICJcdG1pbGVuYWdlPVwiJXNcIlxuIiwgY3JlZC0+bWlsZW5hZ2UpOworCWlmIChjcmVkLT5kb21haW4pCisJCWZwcmludGYoZiwgIlx0ZG9tYWluPVwiJXNcIlxuIiwgY3JlZC0+ZG9tYWluKTsKK30KKworCiAjaWZuZGVmIENPTkZJR19OT19DT05GSUdfQkxPQlMKIHN0YXRpYyBpbnQgd3BhX2NvbmZpZ193cml0ZV9ibG9iKEZJTEUgKmYsIHN0cnVjdCB3cGFfY29uZmlnX2Jsb2IgKmJsb2IpCiB7CkBAIC01OTksNiArNjk4LDIzIEBACiAjZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19CTE9CUyAqLwogCiAKK3N0YXRpYyB2b2lkIHdyaXRlX2dsb2JhbF9iaW4oRklMRSAqZiwgY29uc3QgY2hhciAqZmllbGQsCisJCQkgICAgIGNvbnN0IHN0cnVjdCB3cGFidWYgKnZhbCkKK3sKKwlzaXplX3QgaTsKKwljb25zdCB1OCAqcG9zOworCisJaWYgKHZhbCA9PSBOVUxMKQorCQlyZXR1cm47CisKKwlmcHJpbnRmKGYsICIlcz0iLCBmaWVsZCk7CisJcG9zID0gd3BhYnVmX2hlYWQodmFsKTsKKwlmb3IgKGkgPSAwOyBpIDwgd3BhYnVmX2xlbih2YWwpOyBpKyspCisJCWZwcmludGYoZiwgIiUwMlgiLCAqcG9zKyspOworCWZwcmludGYoZiwgIlxuIik7Cit9CisKKwogc3RhdGljIHZvaWQgd3BhX2NvbmZpZ193cml0ZV9nbG9iYWwoRklMRSAqZiwgc3RydWN0IHdwYV9jb25maWcgKmNvbmZpZykKIHsKICNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRQpAQCAtNjEyLDYgKzcyOCw5IEBACiAJCWZwcmludGYoZiwgImVhcG9sX3ZlcnNpb249JWRcbiIsIGNvbmZpZy0+ZWFwb2xfdmVyc2lvbik7CiAJaWYgKGNvbmZpZy0+YXBfc2NhbiAhPSBERUZBVUxUX0FQX1NDQU4pCiAJCWZwcmludGYoZiwgImFwX3NjYW49JWRcbiIsIGNvbmZpZy0+YXBfc2Nhbik7CisJaWYgKGNvbmZpZy0+ZGlzYWJsZV9zY2FuX29mZmxvYWQpCisJCWZwcmludGYoZiwgImRpc2FibGVfc2Nhbl9vZmZsb2FkPSVkXG4iLAorCQkJY29uZmlnLT5kaXNhYmxlX3NjYW5fb2ZmbG9hZCk7CiAJaWYgKGNvbmZpZy0+ZmFzdF9yZWF1dGggIT0gREVGQVVMVF9GQVNUX1JFQVVUSCkKIAkJZnByaW50ZihmLCAiZmFzdF9yZWF1dGg9JWRcbiIsIGNvbmZpZy0+ZmFzdF9yZWF1dGgpOwogCWlmIChjb25maWctPm9wZW5zY19lbmdpbmVfcGF0aCkKQEAgLTYyMyw2ICs3NDIsMTAgQEAKIAlpZiAoY29uZmlnLT5wa2NzMTFfbW9kdWxlX3BhdGgpCiAJCWZwcmludGYoZiwgInBrY3MxMV9tb2R1bGVfcGF0aD0lc1xuIiwKIAkJCWNvbmZpZy0+cGtjczExX21vZHVsZV9wYXRoKTsKKwlpZiAoY29uZmlnLT5wY3NjX3JlYWRlcikKKwkJZnByaW50ZihmLCAicGNzY19yZWFkZXI9JXNcbiIsIGNvbmZpZy0+cGNzY19yZWFkZXIpOworCWlmIChjb25maWctPnBjc2NfcGluKQorCQlmcHJpbnRmKGYsICJwY3NjX3Bpbj0lc1xuIiwgY29uZmlnLT5wY3NjX3Bpbik7CiAJaWYgKGNvbmZpZy0+ZHJpdmVyX3BhcmFtKQogCQlmcHJpbnRmKGYsICJkcml2ZXJfcGFyYW09JXNcbiIsIGNvbmZpZy0+ZHJpdmVyX3BhcmFtKTsKIAlpZiAoY29uZmlnLT5kb3QxMVJTTkFDb25maWdQTUtMaWZldGltZSkKQEAgLTY2Nyw2ICs3OTAsMTYgQEAKIAlpZiAoY29uZmlnLT53cHNfY3JlZF9wcm9jZXNzaW5nKQogCQlmcHJpbnRmKGYsICJ3cHNfY3JlZF9wcm9jZXNzaW5nPSVkXG4iLAogCQkJY29uZmlnLT53cHNfY3JlZF9wcm9jZXNzaW5nKTsKKwlpZiAoY29uZmlnLT53cHNfdmVuZG9yX2V4dF9tMSkgeworCQlpbnQgaSwgbGVuID0gd3BhYnVmX2xlbihjb25maWctPndwc192ZW5kb3JfZXh0X20xKTsKKwkJY29uc3QgdTggKnAgPSB3cGFidWZfaGVhZF91OChjb25maWctPndwc192ZW5kb3JfZXh0X20xKTsKKwkJaWYgKGxlbiA+IDApIHsKKwkJCWZwcmludGYoZiwgIndwc192ZW5kb3JfZXh0X20xPSIpOworCQkJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQorCQkJCWZwcmludGYoZiwgIiUwMngiLCAqcCsrKTsKKwkJCWZwcmludGYoZiwgIlxuIik7CisJCX0KKwl9CiAjZW5kaWYgLyogQ09ORklHX1dQUyAqLwogI2lmZGVmIENPTkZJR19QMlAKIAlpZiAoY29uZmlnLT5wMnBfbGlzdGVuX3JlZ19jbGFzcykKQEAgLTY5MSw2ICs4MjQsMTYgQEAKIAkJZnByaW50ZihmLCAicDJwX2ludHJhX2Jzcz0ldVxuIiwgY29uZmlnLT5wMnBfaW50cmFfYnNzKTsKIAlpZiAoY29uZmlnLT5wMnBfZ3JvdXBfaWRsZSkKIAkJZnByaW50ZihmLCAicDJwX2dyb3VwX2lkbGU9JXVcbiIsIGNvbmZpZy0+cDJwX2dyb3VwX2lkbGUpOworCWlmIChjb25maWctPnAycF9wcmVmX2NoYW4pIHsKKwkJdW5zaWduZWQgaW50IGk7CisJCWZwcmludGYoZiwgInAycF9wcmVmX2NoYW49Iik7CisJCWZvciAoaSA9IDA7IGkgPCBjb25maWctPm51bV9wMnBfcHJlZl9jaGFuOyBpKyspIHsKKwkJCWZwcmludGYoZiwgIiVzJXU6JXUiLCBpID4gMCA/ICIsIiA6ICIiLAorCQkJCWNvbmZpZy0+cDJwX3ByZWZfY2hhbltpXS5vcF9jbGFzcywKKwkJCQljb25maWctPnAycF9wcmVmX2NoYW5baV0uY2hhbik7CisJCX0KKwkJZnByaW50ZihmLCAiXG4iKTsKKwl9CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCWlmIChjb25maWctPmNvdW50cnlbMF0gJiYgY29uZmlnLT5jb3VudHJ5WzFdKSB7CiAJCWZwcmludGYoZiwgImNvdW50cnk9JWMlY1xuIiwKQEAgLTcxMSwxOSArODU0LDExIEBACiAJCWZwcmludGYoZiwgIm1heF9udW1fc3RhPSV1XG4iLCBjb25maWctPm1heF9udW1fc3RhKTsKIAlpZiAoY29uZmlnLT5kaXNhc3NvY19sb3dfYWNrKQogCQlmcHJpbnRmKGYsICJkaXNhc3NvY19sb3dfYWNrPSV1XG4iLCBjb25maWctPmRpc2Fzc29jX2xvd19hY2spOworI2lmZGVmIENPTkZJR19IUzIwCisJaWYgKGNvbmZpZy0+aHMyMCkKKwkJZnByaW50ZihmLCAiaHMyMD0xXG4iKTsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKLQlpZiAoY29uZmlnLT5ob21lX3JlYWxtKQotCQlmcHJpbnRmKGYsICJob21lX3JlYWxtPSVzXG4iLCBjb25maWctPmhvbWVfcmVhbG0pOwotCWlmIChjb25maWctPmhvbWVfdXNlcm5hbWUpCi0JCWZwcmludGYoZiwgImhvbWVfdXNlcm5hbWU9JXNcbiIsIGNvbmZpZy0+aG9tZV91c2VybmFtZSk7Ci0JaWYgKGNvbmZpZy0+aG9tZV9wYXNzd29yZCkKLQkJZnByaW50ZihmLCAiaG9tZV9wYXNzd29yZD0lc1xuIiwgY29uZmlnLT5ob21lX3Bhc3N3b3JkKTsKLQlpZiAoY29uZmlnLT5ob21lX2NhX2NlcnQpCi0JCWZwcmludGYoZiwgImhvbWVfY2FfY2VydD0lc1xuIiwgY29uZmlnLT5ob21lX2NhX2NlcnQpOwotCWlmIChjb25maWctPmhvbWVfaW1zaSkKLQkJZnByaW50ZihmLCAiaG9tZV9pbXNpPSVzXG4iLCBjb25maWctPmhvbWVfaW1zaSk7Ci0JaWYgKGNvbmZpZy0+aG9tZV9taWxlbmFnZSkKLQkJZnByaW50ZihmLCAiaG9tZV9taWxlbmFnZT0lc1xuIiwgY29uZmlnLT5ob21lX21pbGVuYWdlKTsKIAlpZiAoY29uZmlnLT5pbnRlcndvcmtpbmcpCiAJCWZwcmludGYoZiwgImludGVyd29ya2luZz0ldVxuIiwgY29uZmlnLT5pbnRlcndvcmtpbmcpOwogCWlmICghaXNfemVyb19ldGhlcl9hZGRyKGNvbmZpZy0+aGVzc2lkKSkKQEAgLTczMiw2ICs4NjcsMTQgQEAKIAkJZnByaW50ZihmLCAiYWNjZXNzX25ldHdvcmtfdHlwZT0lZFxuIiwKIAkJCWNvbmZpZy0+YWNjZXNzX25ldHdvcmtfdHlwZSk7CiAjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLworCWlmIChjb25maWctPnBiY19pbl9tMSkKKwkJZnByaW50ZihmLCAicGJjX2luX20xPSV1XG4iLCBjb25maWctPnBiY19pbl9tMSk7CisJaWYgKGNvbmZpZy0+d3BzX25mY19kZXZfcHdfaWQpCisJCWZwcmludGYoZiwgIndwc19uZmNfZGV2X3B3X2lkPSVkXG4iLAorCQkJY29uZmlnLT53cHNfbmZjX2Rldl9wd19pZCk7CisJd3JpdGVfZ2xvYmFsX2JpbihmLCAid3BzX25mY19kaF9wdWJrZXkiLCBjb25maWctPndwc19uZmNfZGhfcHVia2V5KTsKKwl3cml0ZV9nbG9iYWxfYmluKGYsICJ3cHNfbmZjX2RoX3ByaXZrZXkiLCBjb25maWctPndwc19uZmNfZGhfcHJpdmtleSk7CisJd3JpdGVfZ2xvYmFsX2JpbihmLCAid3BzX25mY19kZXZfcHciLCBjb25maWctPndwc19uZmNfZGV2X3B3KTsKIH0KIAogI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfV1JJVEUgKi8KQEAgLTc0Miw2ICs4ODUsNyBAQAogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX1dSSVRFCiAJRklMRSAqZjsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOwogI2lmbmRlZiBDT05GSUdfTk9fQ09ORklHX0JMT0JTCiAJc3RydWN0IHdwYV9jb25maWdfYmxvYiAqYmxvYjsKICNlbmRpZiAvKiBDT05GSUdfTk9fQ09ORklHX0JMT0JTICovCkBAIC03NTcsNiArOTAxLDEyIEBACiAKIAl3cGFfY29uZmlnX3dyaXRlX2dsb2JhbChmLCBjb25maWcpOwogCisJZm9yIChjcmVkID0gY29uZmlnLT5jcmVkOyBjcmVkOyBjcmVkID0gY3JlZC0+bmV4dCkgeworCQlmcHJpbnRmKGYsICJcbmNyZWQ9e1xuIik7CisJCXdwYV9jb25maWdfd3JpdGVfY3JlZChmLCBjcmVkKTsKKwkJZnByaW50ZihmLCAifVxuIik7CisJfQorCiAJZm9yIChzc2lkID0gY29uZmlnLT5zc2lkOyBzc2lkOyBzc2lkID0gc3NpZC0+bmV4dCkgewogCQlpZiAoc3NpZC0+a2V5X21nbXQgPT0gV1BBX0tFWV9NR01UX1dQUyB8fCBzc2lkLT50ZW1wb3JhcnkpCiAJCQljb250aW51ZTsgLyogZG8gbm90IHNhdmUgdGVtcG9yYXJ5IG5ldHdvcmtzICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9jb25maWdfc3NpZC5oIGIvd3BhX3N1cHBsaWNhbnQvY29uZmlnX3NzaWQuaAppbmRleCAzYmU2YzI2Li41OWVjMzA5IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jb25maWdfc3NpZC5oCisrKyBiL3dwYV9zdXBwbGljYW50L2NvbmZpZ19zc2lkLmgKQEAgLTI1LDYgKzI1LDcgQEAKIAkJICAgICAgIFdQQV9DSVBIRVJfV0VQMTA0IHwgV1BBX0NJUEhFUl9XRVA0MCkKICNkZWZpbmUgREVGQVVMVF9GUkFHTUVOVF9TSVpFIDEzOTgKIAorI2RlZmluZSBERUZBVUxUX0JHX1NDQU5fUEVSSU9EIC0xCiAjZGVmaW5lIERFRkFVTFRfRElTQUJMRV9IVCAwCiAjZGVmaW5lIERFRkFVTFRfRElTQUJMRV9IVDQwIDAKICNkZWZpbmUgREVGQVVMVF9ESVNBQkxFX01BWF9BTVNEVSAtMSAvKiBubyBjaGFuZ2UgKi8KQEAgLTE1Nyw2ICsxNTgsMTIgQEAKIAlpbnQga2V5X21nbXQ7CiAKIAkvKioKKwkgKiBiZ19zY2FuX3BlcmlvZCAtIEJhY2tncm91bmQgc2NhbiBwZXJpb2QgaW4gc2Vjb25kcywgMCB0byBkaXNhYmxlLCBvcgorCSAqIC0xIHRvIGluZGljYXRlIG5vIGNoYW5nZSB0byBkZWZhdWx0IGRyaXZlciBjb25maWd1cmF0aW9uCisJICovCisJaW50IGJnX3NjYW5fcGVyaW9kOworCisJLyoqCiAJICogcHJvdG8gLSBCaXRmaWVsZCBvZiBhbGxvd2VkIHByb3RvY29scywgV1BBX1BST1RPXyoKIAkgKi8KIAlpbnQgcHJvdG87CkBAIC0zNzcsNiArMzg0LDIwIEBACiAJY2hhciAqYmdzY2FuOwogCiAJLyoqCisJICogaWdub3JlX2Jyb2FkY2FzdF9zc2lkIC0gSGlkZSBTU0lEIGluIEFQIG1vZGUKKwkgKgorCSAqIFNlbmQgZW1wdHkgU1NJRCBpbiBiZWFjb25zIGFuZCBpZ25vcmUgcHJvYmUgcmVxdWVzdCBmcmFtZXMgdGhhdCBkbworCSAqIG5vdCBzcGVjaWZ5IGZ1bGwgU1NJRCwgaS5lLiwgcmVxdWlyZSBzdGF0aW9ucyB0byBrbm93IFNTSUQuCisJICogZGVmYXVsdDogZGlzYWJsZWQgKDApCisJICogMSA9IHNlbmQgZW1wdHkgKGxlbmd0aD0wKSBTU0lEIGluIGJlYWNvbiBhbmQgaWdub3JlIHByb2JlIHJlcXVlc3QKKwkgKiBmb3IgYnJvYWRjYXN0IFNTSUQKKwkgKiAyID0gY2xlYXIgU1NJRCAoQVNDSUkgMCksIGJ1dCBrZWVwIHRoZSBvcmlnaW5hbCBsZW5ndGggKHRoaXMgbWF5IGJlCisJICogcmVxdWlyZWQgd2l0aCBzb21lIGNsaWVudHMgdGhhdCBkbyBub3Qgc3VwcG9ydCBlbXB0eSBTU0lEKSBhbmQKKwkgKiBpZ25vcmUgcHJvYmUgcmVxdWVzdHMgZm9yIGJyb2FkY2FzdCBTU0lECisJICovCisJaW50IGlnbm9yZV9icm9hZGNhc3Rfc3NpZDsKKworCS8qKgogCSAqIGZyZXFfbGlzdCAtIEFycmF5IG9mIGFsbG93ZWQgZnJlcXVlbmNpZXMgb3IgJU5VTEwgZm9yIGFsbAogCSAqCiAJICogVGhpcyBpcyBhbiBvcHRpb25hbCB6ZXJvLXRlcm1pbmF0ZWQgYXJyYXkgb2YgZnJlcXVlbmNpZXMgaW4KQEAgLTQ3Niw2ICs0OTcsMjAgQEAKIAkgKi8KIAljaGFyICpodF9tY3M7CiAjZW5kaWYgLyogQ09ORklHX0hUX09WRVJSSURFUyAqLworCisJLyoqCisJICogYXBfbWF4X2luYWN0aXZpdHkgLSBUaW1lb3V0IGluIHNlY29uZHMgdG8gZGV0ZWN0IFNUQSdzIGluYWN0aXZpdHkKKwkgKgorCSAqIFRoaXMgdGltZW91dCB2YWx1ZSBpcyB1c2VkIGluIEFQIG1vZGUgdG8gY2xlYW4gdXAgaW5hY3RpdmUgc3RhdGlvbnMuCisJICogQnkgZGVmYXVsdDogMzAwIHNlY29uZHMuCisJICovCisJaW50IGFwX21heF9pbmFjdGl2aXR5OworCisJLyoqCisJICogZHRpbV9wZXJpb2QgLSBEVElNIHBlcmlvZCBpbiBCZWFjb24gaW50ZXJ2YWxzCisJICogQnkgZGVmYXVsdDogMgorCSAqLworCWludCBkdGltX3BlcmlvZDsKIH07CiAKICNlbmRpZiAvKiBDT05GSUdfU1NJRF9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlLmMgYi93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlLmMKaW5kZXggYTIyY2NlNS4uMjIyNDczOCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvY3RybF9pZmFjZS5jCisrKyBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2UuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXUEEgU3VwcGxpY2FudCAvIENvbnRyb2wgaW50ZXJmYWNlIChzaGFyZWQgY29kZSBmb3IgYWxsIGJhY2tlbmRzKQotICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTAsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgImFwLmgiCiAjaW5jbHVkZSAicDJwX3N1cHBsaWNhbnQuaCIKICNpbmNsdWRlICJwMnAvcDJwLmgiCisjaW5jbHVkZSAiaHMyMF9zdXBwbGljYW50LmgiCiAjaW5jbHVkZSAibm90aWZ5LmgiCiAjaW5jbHVkZSAiYnNzLmgiCiAjaW5jbHVkZSAic2Nhbi5oIgpAQCAtMzUsNiArMzYsNyBAQAogI2luY2x1ZGUgImludGVyd29ya2luZy5oIgogI2luY2x1ZGUgImJsYWNrbGlzdC5oIgogI2luY2x1ZGUgIndwYXNfZ2x1ZS5oIgorI2luY2x1ZGUgImF1dG9zY2FuLmgiCiAKIGV4dGVybiBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgKndwYV9kcml2ZXJzW107CiAKQEAgLTU5LDcgKzYxLDcgQEAKIAludW1fc3NpZCA9IDA7CiAJc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwogCXdoaWxlIChzc2lkKSB7Ci0JCWlmICghc3NpZC0+ZGlzYWJsZWQpCisJCWlmICghd3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSkKIAkJCW51bV9zc2lkKys7CiAJCXNzaWQgPSBzc2lkLT5uZXh0OwogCX0KQEAgLTgxLDcgKzgzLDcgQEAKIAlpID0gMDsKIAlzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7CiAJd2hpbGUgKHNzaWQpIHsKLQkJaWYgKCFzc2lkLT5kaXNhYmxlZCkgeworCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkpIHsKIAkJCXBhcmFtcy5zc2lkc1tpXS5zc2lkID0gc3NpZC0+c3NpZDsKIAkJCXBhcmFtcy5zc2lkc1tpXS5zc2lkX2xlbiA9IHNzaWQtPnNzaWRfbGVuOwogCQkJcGFyYW1zLm51bV9zc2lkcysrOwpAQCAtMTE0LDYgKzExNiw0MyBAQAogfQogCiAKK3N0YXRpYyBpbnQgc2V0X2Jzc2lkX2ZpbHRlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICp2YWwpCit7CisJY2hhciAqcG9zOworCXU4IGFkZHJbRVRIX0FMRU5dLCAqZmlsdGVyID0gTlVMTCwgKm47CisJc2l6ZV90IGNvdW50ID0gMDsKKworCXBvcyA9IHZhbDsKKwl3aGlsZSAocG9zKSB7CisJCWlmICgqcG9zID09ICdcMCcpCisJCQlicmVhazsKKwkJaWYgKGh3YWRkcl9hdG9uKHBvcywgYWRkcikpIHsKKwkJCW9zX2ZyZWUoZmlsdGVyKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQluID0gb3NfcmVhbGxvYyhmaWx0ZXIsIChjb3VudCArIDEpICogRVRIX0FMRU4pOworCQlpZiAobiA9PSBOVUxMKSB7CisJCQlvc19mcmVlKGZpbHRlcik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJZmlsdGVyID0gbjsKKwkJb3NfbWVtY3B5KGZpbHRlciArIGNvdW50ICogRVRIX0FMRU4sIGFkZHIsIEVUSF9BTEVOKTsKKwkJY291bnQrKzsKKworCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnICcpOworCQlpZiAocG9zKQorCQkJcG9zKys7CisJfQorCisJd3BhX2hleGR1bXAoTVNHX0RFQlVHLCAiYnNzaWRfZmlsdGVyIiwgZmlsdGVyLCBjb3VudCAqIEVUSF9BTEVOKTsKKwlvc19mcmVlKHdwYV9zLT5ic3NpZF9maWx0ZXIpOworCXdwYV9zLT5ic3NpZF9maWx0ZXIgPSBmaWx0ZXI7CisJd3BhX3MtPmJzc2lkX2ZpbHRlcl9jb3VudCA9IGNvdW50OworCisJcmV0dXJuIDA7Cit9CisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NldChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgY2hhciAqY21kKQogewpAQCAtMTk3LDggKzIzNiw1MiBAQAogCQkJcmV0ID0gcG5vX3N0YXJ0KHdwYV9zKTsKIAkJZWxzZQogCQkJcmV0ID0gcG5vX3N0b3Aod3BhX3MpOworCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJyYWRpb19kaXNhYmxlZCIpID09IDApIHsKKwkJaW50IGRpc2FibGVkID0gYXRvaSh2YWx1ZSk7CisJCWlmICh3cGFfZHJ2X3JhZGlvX2Rpc2FibGUod3BhX3MsIGRpc2FibGVkKSA8IDApCisJCQlyZXQgPSAtMTsKKwkJZWxzZSBpZiAoZGlzYWJsZWQpCisJCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9JTkFDVElWRSk7CisJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgInVhcHNkIikgPT0gMCkgeworCQlpZiAob3Nfc3RyY21wKHZhbHVlLCAiZGlzYWJsZSIpID09IDApCisJCQl3cGFfcy0+c2V0X3N0YV91YXBzZCA9IDA7CisJCWVsc2UgeworCQkJaW50IGJlLCBiaywgdmksIHZvOworCQkJY2hhciAqcG9zOworCQkJLyogZm9ybWF0OiBCRSxCSyxWSSxWTzttYXggU1AgTGVuZ3RoICovCisJCQliZSA9IGF0b2kodmFsdWUpOworCQkJcG9zID0gb3Nfc3RyY2hyKHZhbHVlLCAnLCcpOworCQkJaWYgKHBvcyA9PSBOVUxMKQorCQkJCXJldHVybiAtMTsKKwkJCXBvcysrOworCQkJYmsgPSBhdG9pKHBvcyk7CisJCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOworCQkJaWYgKHBvcyA9PSBOVUxMKQorCQkJCXJldHVybiAtMTsKKwkJCXBvcysrOworCQkJdmkgPSBhdG9pKHBvcyk7CisJCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOworCQkJaWYgKHBvcyA9PSBOVUxMKQorCQkJCXJldHVybiAtMTsKKwkJCXBvcysrOworCQkJdm8gPSBhdG9pKHBvcyk7CisJCQkvKiBpZ25vcmUgbWF4IFNQIExlbmd0aCBmb3Igbm93ICovCisKKwkJCXdwYV9zLT5zZXRfc3RhX3VhcHNkID0gMTsKKwkJCXdwYV9zLT5zdGFfdWFwc2QgPSAwOworCQkJaWYgKGJlKQorCQkJCXdwYV9zLT5zdGFfdWFwc2QgfD0gQklUKDApOworCQkJaWYgKGJrKQorCQkJCXdwYV9zLT5zdGFfdWFwc2QgfD0gQklUKDEpOworCQkJaWYgKHZpKQorCQkJCXdwYV9zLT5zdGFfdWFwc2QgfD0gQklUKDIpOworCQkJaWYgKHZvKQorCQkJCXdwYV9zLT5zdGFfdWFwc2QgfD0gQklUKDMpOworCQl9CiAJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgInBzIikgPT0gMCkgewogCQlyZXQgPSB3cGFfZHJ2X3NldF9wMnBfcG93ZXJzYXZlKHdwYV9zLCBhdG9pKHZhbHVlKSwgLTEsIC0xKTsKKwl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAiYnNzaWRfZmlsdGVyIikgPT0gMCkgeworCQlyZXQgPSBzZXRfYnNzaWRfZmlsdGVyKHdwYV9zLCB2YWx1ZSk7CiAJfSBlbHNlIHsKIAkJdmFsdWVbLTFdID0gJz0nOwogCQlyZXQgPSB3cGFfY29uZmlnX3Byb2Nlc3NfZ2xvYmFsKHdwYV9zLT5jb25mLCBjbWQsIC0xKTsKQEAgLTUzOSw2ICs2MjIsODAgQEAKICNlbmRpZiAvKiBDT05GSUdfV1BTX09PQiAqLwogCiAKKyNpZmRlZiBDT05GSUdfV1BTX05GQworCitzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX25mYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgIGNoYXIgKmNtZCkKK3sKKwl1OCBic3NpZFtFVEhfQUxFTl0sICpfYnNzaWQgPSBic3NpZDsKKworCWlmIChjbWQgPT0gTlVMTCB8fCBjbWRbMF0gPT0gJ1wwJykKKwkJX2Jzc2lkID0gTlVMTDsKKwllbHNlIGlmIChod2FkZHJfYXRvbihjbWQsIGJzc2lkKSkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIHdwYXNfd3BzX3N0YXJ0X25mYyh3cGFfcywgX2Jzc2lkKTsKK30KKworCitzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX25mY190b2tlbigKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQsIGNoYXIgKnJlcGx5LCBzaXplX3QgbWF4X2xlbikKK3sKKwlpbnQgbmRlZjsKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJlczsKKworCWlmIChvc19zdHJjbXAoY21kLCAiV1BTIikgPT0gMCkKKwkJbmRlZiA9IDA7CisJZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIk5ERUYiKSA9PSAwKQorCQluZGVmID0gMTsKKwllbHNlCisJCXJldHVybiAtMTsKKworCWJ1ZiA9IHdwYXNfd3BzX25mY190b2tlbih3cGFfcywgbmRlZik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlyZXMgPSB3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShyZXBseSwgbWF4X2xlbiwgd3BhYnVmX2hlYWQoYnVmKSwKKwkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CisJcmVwbHlbcmVzKytdID0gJ1xuJzsKKwlyZXBseVtyZXNdID0gJ1wwJzsKKworCXdwYWJ1Zl9mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmVzOworfQorCisKK3N0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjX3RhZ19yZWFkKAorCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKnBvcykKK3sKKwlzaXplX3QgbGVuOworCXN0cnVjdCB3cGFidWYgKmJ1ZjsKKwlpbnQgcmV0OworCisJbGVuID0gb3Nfc3RybGVuKHBvcyk7CisJaWYgKGxlbiAmIDB4MDEpCisJCXJldHVybiAtMTsKKwlsZW4gLz0gMjsKKworCWJ1ZiA9IHdwYWJ1Zl9hbGxvYyhsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dChidWYsIGxlbiksIGxlbikgPCAwKSB7CisJCXdwYWJ1Zl9mcmVlKGJ1Zik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXQgPSB3cGFzX3dwc19uZmNfdGFnX3JlYWQod3BhX3MsIGJ1Zik7CisJd3BhYnVmX2ZyZWUoYnVmKTsKKworCXJldHVybiByZXQ7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLworCisKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfcmVnKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgICAgY2hhciAqY21kKQogewpAQCAtNzM1LDYgKzg5Miw0MyBAQAogCWFwLmtleV9oZXggPSBuZXdfa2V5OwogCXJldHVybiB3cGFzX3dwc19lcl9jb25maWcod3BhX3MsIGNtZCwgcGluLCAmYXApOwogfQorCisKKyNpZmRlZiBDT05GSUdfV1BTX05GQworc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19lcl9uZmNfY29uZmlnX3Rva2VuKAorCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCwgY2hhciAqcmVwbHksIHNpemVfdCBtYXhfbGVuKQoreworCWludCBuZGVmOworCXN0cnVjdCB3cGFidWYgKmJ1ZjsKKwlpbnQgcmVzOworCWNoYXIgKnV1aWQ7CisKKwl1dWlkID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKKwlpZiAodXVpZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJKnV1aWQrKyA9ICdcMCc7CisKKwlpZiAob3Nfc3RyY21wKGNtZCwgIldQUyIpID09IDApCisJCW5kZWYgPSAwOworCWVsc2UgaWYgKG9zX3N0cmNtcChjbWQsICJOREVGIikgPT0gMCkKKwkJbmRlZiA9IDE7CisJZWxzZQorCQlyZXR1cm4gLTE7CisKKwlidWYgPSB3cGFzX3dwc19lcl9uZmNfY29uZmlnX3Rva2VuKHdwYV9zLCBuZGVmLCB1dWlkKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXJlcyA9IHdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKHJlcGx5LCBtYXhfbGVuLCB3cGFidWZfaGVhZChidWYpLAorCQkJCQkgd3BhYnVmX2xlbihidWYpKTsKKwlyZXBseVtyZXMrK10gPSAnXG4nOworCXJlcGx5W3Jlc10gPSAnXDAnOworCisJd3BhYnVmX2ZyZWUoYnVmKTsKKworCXJldHVybiByZXM7Cit9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KICNlbmRpZiAvKiBDT05GSUdfV1BTX0VSICovCiAKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCkBAIC03NjAsNzggKzk1NCw2IEBACiAjZW5kaWYgLyogQ09ORklHX0lCU1NfUlNOICovCiAKIAotaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfY3RybF9yc3BfaGFuZGxlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCwKLQkJCQkJICAgICAgY29uc3QgY2hhciAqZmllbGQsCi0JCQkJCSAgICAgIGNvbnN0IGNoYXIgKnZhbHVlKQotewotI2lmZGVmIElFRUU4MDIxWF9FQVBPTAotCXN0cnVjdCBlYXBfcGVlcl9jb25maWcgKmVhcCA9ICZzc2lkLT5lYXA7Ci0KLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IHJlc3BvbnNlIGhhbmRsZSBmaWVsZD0lcyIsIGZpZWxkKTsKLQl3cGFfaGV4ZHVtcF9hc2NpaV9rZXkoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogcmVzcG9uc2UgdmFsdWUiLAotCQkJICAgICAgKGNvbnN0IHU4ICopIHZhbHVlLCBvc19zdHJsZW4odmFsdWUpKTsKLQotCXN3aXRjaCAod3BhX3N1cHBsaWNhbnRfY3RybF9yZXFfZnJvbV9zdHJpbmcoZmllbGQpKSB7Ci0JY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX0lERU5USVRZOgotCQlvc19mcmVlKGVhcC0+aWRlbnRpdHkpOwotCQllYXAtPmlkZW50aXR5ID0gKHU4ICopIG9zX3N0cmR1cCh2YWx1ZSk7Ci0JCWVhcC0+aWRlbnRpdHlfbGVuID0gb3Nfc3RybGVuKHZhbHVlKTsKLQkJZWFwLT5wZW5kaW5nX3JlcV9pZGVudGl0eSA9IDA7Ci0JCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQpCi0JCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwotCQlicmVhazsKLQljYXNlIFdQQV9DVFJMX1JFUV9FQVBfUEFTU1dPUkQ6Ci0JCW9zX2ZyZWUoZWFwLT5wYXNzd29yZCk7Ci0JCWVhcC0+cGFzc3dvcmQgPSAodTggKikgb3Nfc3RyZHVwKHZhbHVlKTsKLQkJZWFwLT5wYXNzd29yZF9sZW4gPSBvc19zdHJsZW4odmFsdWUpOwotCQllYXAtPnBlbmRpbmdfcmVxX3Bhc3N3b3JkID0gMDsKLQkJaWYgKHNzaWQgPT0gd3BhX3MtPmN1cnJlbnRfc3NpZCkKLQkJCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7Ci0JCWJyZWFrOwotCWNhc2UgV1BBX0NUUkxfUkVRX0VBUF9ORVdfUEFTU1dPUkQ6Ci0JCW9zX2ZyZWUoZWFwLT5uZXdfcGFzc3dvcmQpOwotCQllYXAtPm5ld19wYXNzd29yZCA9ICh1OCAqKSBvc19zdHJkdXAodmFsdWUpOwotCQllYXAtPm5ld19wYXNzd29yZF9sZW4gPSBvc19zdHJsZW4odmFsdWUpOwotCQllYXAtPnBlbmRpbmdfcmVxX25ld19wYXNzd29yZCA9IDA7Ci0JCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQpCi0JCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwotCQlicmVhazsKLQljYXNlIFdQQV9DVFJMX1JFUV9FQVBfUElOOgotCQlvc19mcmVlKGVhcC0+cGluKTsKLQkJZWFwLT5waW4gPSBvc19zdHJkdXAodmFsdWUpOwotCQllYXAtPnBlbmRpbmdfcmVxX3BpbiA9IDA7Ci0JCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQpCi0JCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwotCQlicmVhazsKLQljYXNlIFdQQV9DVFJMX1JFUV9FQVBfT1RQOgotCQlvc19mcmVlKGVhcC0+b3RwKTsKLQkJZWFwLT5vdHAgPSAodTggKikgb3Nfc3RyZHVwKHZhbHVlKTsKLQkJZWFwLT5vdHBfbGVuID0gb3Nfc3RybGVuKHZhbHVlKTsKLQkJb3NfZnJlZShlYXAtPnBlbmRpbmdfcmVxX290cCk7Ci0JCWVhcC0+cGVuZGluZ19yZXFfb3RwID0gTlVMTDsKLQkJZWFwLT5wZW5kaW5nX3JlcV9vdHBfbGVuID0gMDsKLQkJYnJlYWs7Ci0JY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX1BBU1NQSFJBU0U6Ci0JCW9zX2ZyZWUoZWFwLT5wcml2YXRlX2tleV9wYXNzd2QpOwotCQllYXAtPnByaXZhdGVfa2V5X3Bhc3N3ZCA9ICh1OCAqKSBvc19zdHJkdXAodmFsdWUpOwotCQllYXAtPnBlbmRpbmdfcmVxX3Bhc3NwaHJhc2UgPSAwOwotCQlpZiAoc3NpZCA9PSB3cGFfcy0+Y3VycmVudF9zc2lkKQotCQkJd3BhX3MtPnJlYXNzb2NpYXRlID0gMTsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBVbmtub3duIGZpZWxkICclcyciLCBmaWVsZCk7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlyZXR1cm4gMDsKLSNlbHNlIC8qIElFRUU4MDIxWF9FQVBPTCAqLwotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogSUVFRSA4MDIuMVggbm90IGluY2x1ZGVkIik7Ci0JcmV0dXJuIC0xOwotI2VuZGlmIC8qIElFRUU4MDIxWF9FQVBPTCAqLwotfQotCi0KIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9jdHJsX3JzcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgICAgICBjaGFyICpyc3ApCiB7CkBAIC05OTcsNiArMTExOSwxNiBAQAogCQlyZXR1cm4gcG9zIC0gYnVmOwogCXBvcyArPSByZXQ7CiAKKyNpZmRlZiBDT05GSUdfSFMyMAorCWlmICh3cGFfcy0+Y3VycmVudF9ic3MgJiYKKwkgICAgd3BhX2Jzc19nZXRfdmVuZG9yX2llKHdwYV9zLT5jdXJyZW50X2JzcywgSFMyMF9JRV9WRU5ET1JfVFlQRSkpIHsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJoczIwPTFcbiIpOworCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKKwkJcG9zICs9IHJldDsKKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWlmICh3cGFfa2V5X21nbXRfd3BhX2llZWU4MDIxeCh3cGFfcy0+a2V5X21nbXQpIHx8CiAJICAgIHdwYV9zLT5rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX05PX1dQQSkgewogCQlyZXMgPSBlYXBvbF9zbV9nZXRfc3RhdHVzKHdwYV9zLT5lYXBvbCwgcG9zLCBlbmQgLSBwb3MsCkBAIC0xNTA3LDYgKzE2MzksMTQgQEAKIAkJCXJldHVybiAtMTsKIAkJcG9zICs9IHJldDsKIAl9CisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAod3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgSFMyMF9JRV9WRU5ET1JfVFlQRSkpIHsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbSFMyMF0iKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCXJldHVybiAtMTsKKwkJcG9zICs9IHJldDsKKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAogCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiXHQlcyIsCiAJCQkgIHdwYV9zc2lkX3R4dChic3MtPnNzaWQsIGJzcy0+c3NpZF9sZW4pKTsKQEAgLTE2MDgsNiArMTc0OCwxMSBAQAogCQkJCSAgICJFTkFCTEVfTkVUV09SSyB3aXRoIHBlcnNpc3RlbnQgUDJQIGdyb3VwIik7CiAJCQlyZXR1cm4gLTE7CiAJCX0KKworCQlpZiAob3Nfc3Ryc3RyKGNtZCwgIiBuby1jb25uZWN0IikpIHsKKwkJCXNzaWQtPmRpc2FibGVkID0gMDsKKwkJCXJldHVybiAwOworCQl9CiAJfQogCXdwYV9zdXBwbGljYW50X2VuYWJsZV9uZXR3b3JrKHdwYV9zLCBzc2lkKTsKIApAQCAtMTY5MSw2ICsxODM2LDkgQEAKIAkJfQogCQllYXBvbF9zbV9pbnZhbGlkYXRlX2NhY2hlZF9zZXNzaW9uKHdwYV9zLT5lYXBvbCk7CiAJCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkKSB7CisjaWZkZWYgQ09ORklHX1NNRQorCQkJd3BhX3MtPnNtZS5wcmV2X2Jzc2lkX3NldCA9IDA7CisjZW5kaWYgLyogQ09ORklHX1NNRSAqLwogCQkJd3BhX3NtX3NldF9jb25maWcod3BhX3MtPndwYSwgTlVMTCk7CiAJCQllYXBvbF9zbV9ub3RpZnlfY29uZmlnKHdwYV9zLT5lYXBvbCwgTlVMTCwgTlVMTCk7CiAJCQl3cGFfc3VwcGxpY2FudF9kaXNhc3NvY2lhdGUod3BhX3MsCkBAIC0xNzEzLDYgKzE4NjEsOSBAQAogCX0KIAogCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQgfHwgd3BhX3MtPmN1cnJlbnRfc3NpZCA9PSBOVUxMKSB7CisjaWZkZWYgQ09ORklHX1NNRQorCQl3cGFfcy0+c21lLnByZXZfYnNzaWRfc2V0ID0gMDsKKyNlbmRpZiAvKiBDT05GSUdfU01FICovCiAJCS8qCiAJCSAqIEludmFsaWRhdGUgdGhlIEVBUCBzZXNzaW9uIGNhY2hlIGlmIHRoZSBjdXJyZW50IG9yCiAJCSAqIHByZXZpb3VzbHkgdXNlZCBuZXR3b3JrIGlzIHJlbW92ZWQuCkBAIC0xODMzLDYgKzE5ODQsMTMyIEBACiB9CiAKIAorc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2xpc3RfY3JlZHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJCWNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKK3sKKwljaGFyICpwb3MsICplbmQ7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworCWludCByZXQ7CisKKwlwb3MgPSBidWY7CisJZW5kID0gYnVmICsgYnVmbGVuOworCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAorCQkJICAiY3JlZCBpZCAvIHJlYWxtIC8gdXNlcm5hbWUgLyBkb21haW4gLyBpbXNpXG4iKTsKKwlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQorCQlyZXR1cm4gcG9zIC0gYnVmOworCXBvcyArPSByZXQ7CisKKwljcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7CisJd2hpbGUgKGNyZWQpIHsKKwkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlZFx0JXNcdCVzXHQlc1x0JXNcbiIsCisJCQkJICBjcmVkLT5pZCwgY3JlZC0+cmVhbG0gPyBjcmVkLT5yZWFsbSA6ICIiLAorCQkJCSAgY3JlZC0+dXNlcm5hbWUgPyBjcmVkLT51c2VybmFtZSA6ICIiLAorCQkJCSAgY3JlZC0+ZG9tYWluID8gY3JlZC0+ZG9tYWluIDogIiIsCisJCQkJICBjcmVkLT5pbXNpID8gY3JlZC0+aW1zaSA6ICIiKTsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCXJldHVybiBwb3MgLSBidWY7CisJCXBvcyArPSByZXQ7CisKKwkJY3JlZCA9IGNyZWQtPm5leHQ7CisJfQorCisJcmV0dXJuIHBvcyAtIGJ1ZjsKK30KKworCitzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYWRkX2NyZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJICAgICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQoreworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKKwlpbnQgcmV0OworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBBRERfQ1JFRCIpOworCisJY3JlZCA9IHdwYV9jb25maWdfYWRkX2NyZWQod3BhX3MtPmNvbmYpOworCWlmIChjcmVkID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJWRcbiIsIGNyZWQtPmlkKTsKKwlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuKQorCQlyZXR1cm4gLTE7CisJcmV0dXJuIHJldDsKK30KKworCitzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcmVtb3ZlX2NyZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJCSBjaGFyICpjbWQpCit7CisJaW50IGlkOworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKKworCS8qIGNtZDogIjxjcmVkIGlkPiIgb3IgImFsbCIgKi8KKwlpZiAob3Nfc3RyY21wKGNtZCwgImFsbCIpID09IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBSRU1PVkVfQ1JFRCBhbGwiKTsKKwkJY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOworCQl3aGlsZSAoY3JlZCkgeworCQkJaWQgPSBjcmVkLT5pZDsKKwkJCWNyZWQgPSBjcmVkLT5uZXh0OworCQkJd3BhX2NvbmZpZ19yZW1vdmVfY3JlZCh3cGFfcy0+Y29uZiwgaWQpOworCQl9CisJCXJldHVybiAwOworCX0KKworCWlkID0gYXRvaShjbWQpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogUkVNT1ZFX0NSRUQgaWQ9JWQiLCBpZCk7CisKKwljcmVkID0gd3BhX2NvbmZpZ19nZXRfY3JlZCh3cGFfcy0+Y29uZiwgaWQpOworCWlmIChjcmVkID09IE5VTEwgfHwKKwkgICAgd3BhX2NvbmZpZ19yZW1vdmVfY3JlZCh3cGFfcy0+Y29uZiwgaWQpIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENvdWxkIG5vdCBmaW5kIGNyZWQgaWQ9JWQiLAorCQkJICAgaWQpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NldF9jcmVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgICAgIGNoYXIgKmNtZCkKK3sKKwlpbnQgaWQ7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworCWNoYXIgKm5hbWUsICp2YWx1ZTsKKworCS8qIGNtZDogIjxjcmVkIGlkPiA8dmFyaWFibGUgbmFtZT4gPHZhbHVlPiIgKi8KKwluYW1lID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKKwlpZiAobmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJKm5hbWUrKyA9ICdcMCc7CisKKwl2YWx1ZSA9IG9zX3N0cmNocihuYW1lLCAnICcpOworCWlmICh2YWx1ZSA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJKnZhbHVlKysgPSAnXDAnOworCisJaWQgPSBhdG9pKGNtZCk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBTRVRfQ1JFRCBpZD0lZCBuYW1lPSclcyciLAorCQkgICBpZCwgbmFtZSk7CisJd3BhX2hleGR1bXBfYXNjaWlfa2V5KE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IHZhbHVlIiwKKwkJCSAgICAgICh1OCAqKSB2YWx1ZSwgb3Nfc3RybGVuKHZhbHVlKSk7CisKKwljcmVkID0gd3BhX2NvbmZpZ19nZXRfY3JlZCh3cGFfcy0+Y29uZiwgaWQpOworCWlmIChjcmVkID09IE5VTEwpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBjcmVkIGlkPSVkIiwKKwkJCSAgIGlkKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmICh3cGFfY29uZmlnX3NldF9jcmVkKGNyZWQsIG5hbWUsIHZhbHVlLCAwKSA8IDApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gc2V0IGNyZWQgIgorCQkJICAgInZhcmlhYmxlICclcyciLCBuYW1lKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisKICNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19XUklURQogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NhdmVfY29uZmlnKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CkBAIC0yMjU0LDkgKzI1MzEsNyBAQAogCWludCByZXQ7CiAJY2hhciAqcG9zLCAqZW5kOwogCWNvbnN0IHU4ICppZSwgKmllMjsKLQlzdHJ1Y3Qgb3NfdGltZSBub3c7CiAKLQlvc19nZXRfdGltZSgmbm93KTsKIAlwb3MgPSBidWY7CiAJZW5kID0gYnVmICsgYnVmbGVuOwogCkBAIC0yMzI4LDYgKzI2MDMsOSBAQAogCX0KIAogCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX0FHRSkgeworCQlzdHJ1Y3Qgb3NfdGltZSBub3c7CisKKwkJb3NfZ2V0X3RpbWUoJm5vdyk7CiAJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiYWdlPSVkXG4iLAogCQkJCSAgKGludCkgKG5vdy5zZWMgLSBic3MtPmxhc3RfdXBkYXRlLnNlYykpOwogCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQpAQCAtMjM5NCw2ICsyNjcyLDE0IEBACiAJCQkJcmV0dXJuIDA7CiAJCQlwb3MgKz0gcmV0OwogCQl9CisjaWZkZWYgQ09ORklHX0hTMjAKKwkJaWYgKHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZShic3MsIEhTMjBfSUVfVkVORE9SX1RZUEUpKSB7CisJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltIUzIwXSIpOworCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKKwkJCQlyZXR1cm4gLTE7CisJCQlwb3MgKz0gcmV0OworCQl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAogCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlxuIik7CiAJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCkBAIC0yNDQ0LDE5ICsyNzMwLDI4IEBACiAJCXBvcyA9IGFucXBfYWRkX2hleChwb3MsIGVuZCwgImFucXBfM2dwcCIsIGJzcy0+YW5xcF8zZ3BwKTsKIAkJcG9zID0gYW5xcF9hZGRfaGV4KHBvcywgZW5kLCAiYW5xcF9kb21haW5fbmFtZSIsCiAJCQkJICAgYnNzLT5hbnFwX2RvbWFpbl9uYW1lKTsKKyNpZmRlZiBDT05GSUdfSFMyMAorCQlwb3MgPSBhbnFwX2FkZF9oZXgocG9zLCBlbmQsICJoczIwX29wZXJhdG9yX2ZyaWVuZGx5X25hbWUiLAorCQkJCSAgIGJzcy0+aHMyMF9vcGVyYXRvcl9mcmllbmRseV9uYW1lKTsKKwkJcG9zID0gYW5xcF9hZGRfaGV4KHBvcywgZW5kLCAiaHMyMF93YW5fbWV0cmljcyIsCisJCQkJICAgYnNzLT5oczIwX3dhbl9tZXRyaWNzKTsKKwkJcG9zID0gYW5xcF9hZGRfaGV4KHBvcywgZW5kLCAiaHMyMF9jb25uZWN0aW9uX2NhcGFiaWxpdHkiLAorCQkJCSAgIGJzcy0+aHMyMF9jb25uZWN0aW9uX2NhcGFiaWxpdHkpOworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCiAJfQogI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KIAogCXJldHVybiBwb3MgLSBidWY7CiB9CiAKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2JzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCQkgY29uc3QgY2hhciAqY21kLCBjaGFyICpidWYsCiAJCQkJCSBzaXplX3QgYnVmbGVuKQogewogCXU4IGJzc2lkW0VUSF9BTEVOXTsKIAlzaXplX3QgaTsKLQlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gTlVMTDsKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzOwogCXN0cnVjdCB3cGFfYnNzICpic3NsYXN0ID0gTlVMTDsKIAlzdHJ1Y3QgZGxfbGlzdCAqbmV4dDsKIAlpbnQgcmV0ID0gMDsKQEAgLTI0NjcsMzMgKzI3NjIsNDUgQEAKIAlpZiAob3Nfc3RybmNtcChjbWQsICJSQU5HRT0iLCA2KSA9PSAwKSB7CiAJCWlmIChvc19zdHJuY21wKGNtZCArIDYsICJBTEwiLCAzKSA9PSAwKSB7CiAJCQlic3MgPSBkbF9saXN0X2ZpcnN0KCZ3cGFfcy0+YnNzX2lkLCBzdHJ1Y3Qgd3BhX2JzcywKLQkJCSAgICAgICAgICAgICAgICAgICAgbGlzdF9pZCk7CisJCQkJCSAgICBsaXN0X2lkKTsKIAkJCWJzc2xhc3QgPSBkbF9saXN0X2xhc3QoJndwYV9zLT5ic3NfaWQsIHN0cnVjdCB3cGFfYnNzLAogCQkJCQkgICAgICAgbGlzdF9pZCk7CiAJCX0gZWxzZSB7IC8qIE4xLU4yICovCi0JCQlpZiAoKGN0bXAgPSBvc19zdHJjaHIoY21kICsgNiwgJy0nKSkgIT0gTlVMTCkgewotCQkJCWludCBpZDEsIGlkMjsKLQkJCQlpZDEgPSBhdG9pKGNtZCArIDYpOwotCQkJCWJzcyA9IHdwYV9ic3NfZ2V0X2lkKHdwYV9zLCBpZDEpOwotCQkJCWlkMiA9IGF0b2koY3RtcCArIDEpOwotCQkJCWlmIChpZDIgPT0gMCkKLQkJCQkJYnNzbGFzdCA9IGRsX2xpc3RfbGFzdCgmd3BhX3MtPmJzc19pZCwKLQkJCQkJCQkgICAgICAgc3RydWN0IHdwYV9ic3MsCi0JCQkJCQkJICAgICAgIGxpc3RfaWQpOwotCQkJCWVsc2UKLQkJCQkJYnNzbGFzdCA9IHdwYV9ic3NfZ2V0X2lkKHdwYV9zLCBpZDIpOwotCQkJfSBlbHNlIHsKLQkJCQl3cGFfcHJpbnRmKE1TR19FUlJPUiwgIldyb25nIHJhbmdlIGZvcm1hdCIpOworCQkJdW5zaWduZWQgaW50IGlkMSwgaWQyOworCisJCQlpZiAoKGN0bXAgPSBvc19zdHJjaHIoY21kICsgNiwgJy0nKSkgPT0gTlVMTCkgeworCQkJCXdwYV9wcmludGYoTVNHX0lORk8sICJXcm9uZyBCU1MgcmFuZ2UgIgorCQkJCQkgICAiZm9ybWF0Iik7CiAJCQkJcmV0dXJuIDA7CiAJCQl9Ci0JCX0KLQkJaWYgKChjdG1wID0gb3Nfc3Ryc3RyKGNtZCwgIk1BU0s9IikpICE9IE5VTEwpIHsKLQkJCW1hc2sgPSBzdHJ0b3VsKGN0bXAgKyA1LCBOVUxMLCAweDEwKTsKLQkJCWlmIChtYXNrID09IDApCi0JCQkJbWFzayA9IFdQQV9CU1NfTUFTS19BTEw7CisKKwkJCWlkMSA9IGF0b2koY21kICsgNik7CisJCQlic3MgPSB3cGFfYnNzX2dldF9pZCh3cGFfcywgaWQxKTsKKwkJCWlkMiA9IGF0b2koY3RtcCArIDEpOworCQkJaWYgKGlkMiA9PSAwKQorCQkJCWJzc2xhc3QgPSBkbF9saXN0X2xhc3QoJndwYV9zLT5ic3NfaWQsCisJCQkJCQkgICAgICAgc3RydWN0IHdwYV9ic3MsCisJCQkJCQkgICAgICAgbGlzdF9pZCk7CisJCQllbHNlIHsKKwkJCQlic3NsYXN0ID0gd3BhX2Jzc19nZXRfaWQod3BhX3MsIGlkMik7CisJCQkJaWYgKGJzc2xhc3QgPT0gTlVMTCAmJiBic3MgJiYgaWQyID4gaWQxKSB7CisJCQkJCXN0cnVjdCB3cGFfYnNzICp0bXAgPSBic3M7CisJCQkJCWZvciAoOzspIHsKKwkJCQkJCW5leHQgPSB0bXAtPmxpc3RfaWQubmV4dDsKKwkJCQkJCWlmIChuZXh0ID09ICZ3cGFfcy0+YnNzX2lkKQorCQkJCQkJCWJyZWFrOworCQkJCQkJdG1wID0gZGxfbGlzdF9lbnRyeSgKKwkJCQkJCQluZXh0LCBzdHJ1Y3Qgd3BhX2JzcywKKwkJCQkJCQlsaXN0X2lkKTsKKwkJCQkJCWlmICh0bXAtPmlkID4gaWQyKQorCQkJCQkJCWJyZWFrOworCQkJCQkJYnNzbGFzdCA9IHRtcDsKKwkJCQkJfQorCQkJCX0KKwkJCX0KIAkJfQogCX0gZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIkZJUlNUIikgPT0gMCkKLQkJYnNzID0gZGxfbGlzdF9maXJzdCgmd3BhX3MtPmJzcywgc3RydWN0IHdwYV9ic3MsIGxpc3QpOworCQlic3MgPSBkbF9saXN0X2ZpcnN0KCZ3cGFfcy0+YnNzX2lkLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdF9pZCk7CiAJZWxzZSBpZiAob3Nfc3RybmNtcChjbWQsICJJRC0iLCAzKSA9PSAwKSB7CiAJCWkgPSBhdG9pKGNtZCArIDMpOwogCQlic3MgPSB3cGFfYnNzX2dldF9pZCh3cGFfcywgaSk7CkBAIC0yNTMwLDYgKzI4MzcsMTIgQEAKIAkJfQogCX0KIAorCWlmICgoY3RtcCA9IG9zX3N0cnN0cihjbWQsICJNQVNLPSIpKSAhPSBOVUxMKSB7CisJCW1hc2sgPSBzdHJ0b3VsKGN0bXAgKyA1LCBOVUxMLCAweDEwKTsKKwkJaWYgKG1hc2sgPT0gMCkKKwkJCW1hc2sgPSBXUEFfQlNTX01BU0tfQUxMOworCX0KKwogCWlmIChic3MgPT0gTlVMTCkKIAkJcmV0dXJuIDA7CiAKQEAgLTI1NjQsMTAgKzI4NzcsNyBAQAogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKIHsKIAlpbnQgc2Nhbl9pbnQgPSBhdG9pKGNtZCk7Ci0JaWYgKHNjYW5faW50IDwgMCkKLQkJcmV0dXJuIC0xOwotCXdwYV9zLT5zY2FuX2ludGVydmFsID0gc2Nhbl9pbnQ7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHdwYV9zdXBwbGljYW50X3NldF9zY2FuX2ludGVydmFsKHdwYV9zLCBzY2FuX2ludCk7CiB9CiAKIApAQCAtMjY4OCwxNCArMjk5OCwxNyBAQAogCWVudW0gcDJwX3dwc19tZXRob2Qgd3BzX21ldGhvZDsKIAlpbnQgbmV3X3BpbjsKIAlpbnQgcmV0OwotCWludCBwZXJzaXN0ZW50X2dyb3VwOworCWludCBwZXJzaXN0ZW50X2dyb3VwLCBwZXJzaXN0ZW50X2lkID0gLTE7CiAJaW50IGpvaW47CiAJaW50IGF1dGg7CisJaW50IGF1dG9tYXRpYzsKIAlpbnQgZ29faW50ZW50ID0gLTE7CiAJaW50IGZyZXEgPSAwOworCWludCBwZDsKIAotCS8qIDxhZGRyPiA8InBiYyIgfCAicGluIiB8IFBJTj4gW2xhYmVsfGRpc3BsYXl8a2V5cGFkXSBbcGVyc2lzdGVudF0KLQkgKiBbam9pbl0gW2F1dGhdIFtnb19pbnRlbnQ9PDAuLjE1Pl0gW2ZyZXE9PGluIE1Iej5dICovCisJLyogPGFkZHI+IDwicGJjIiB8ICJwaW4iIHwgUElOPiBbbGFiZWx8ZGlzcGxheXxrZXlwYWRdCisJICogW3BlcnNpc3RlbnR8cGVyc2lzdGVudD08bmV0d29yayBpZD5dCisJICogW2pvaW5dIFthdXRoXSBbZ29faW50ZW50PTwwLi4xNT5dIFtmcmVxPTxpbiBNSHo+XSBbcHJvdmRpc2NdICovCiAKIAlpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSkKIAkJcmV0dXJuIC0xOwpAQCAtMjcwNiw4ICszMDE5LDIzIEBACiAJcG9zKys7CiAKIAlwZXJzaXN0ZW50X2dyb3VwID0gb3Nfc3Ryc3RyKHBvcywgIiBwZXJzaXN0ZW50IikgIT0gTlVMTDsKKwlwb3MyID0gb3Nfc3Ryc3RyKHBvcywgIiBwZXJzaXN0ZW50PSIpOworCWlmIChwb3MyKSB7CisJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKKwkJcGVyc2lzdGVudF9pZCA9IGF0b2kocG9zMiArIDEyKTsKKwkJc3NpZCA9IHdwYV9jb25maWdfZ2V0X25ldHdvcmsod3BhX3MtPmNvbmYsIHBlcnNpc3RlbnRfaWQpOworCQlpZiAoc3NpZCA9PSBOVUxMIHx8IHNzaWQtPmRpc2FibGVkICE9IDIgfHwKKwkJICAgIHNzaWQtPm1vZGUgIT0gV1BBU19NT0RFX1AyUF9HTykgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCAiCisJCQkJICAgIlNTSUQgaWQ9JWQgZm9yIHBlcnNpc3RlbnQgUDJQIGdyb3VwIChHTykiLAorCQkJCSAgIHBlcnNpc3RlbnRfaWQpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQogCWpvaW4gPSBvc19zdHJzdHIocG9zLCAiIGpvaW4iKSAhPSBOVUxMOwogCWF1dGggPSBvc19zdHJzdHIocG9zLCAiIGF1dGgiKSAhPSBOVUxMOworCWF1dG9tYXRpYyA9IG9zX3N0cnN0cihwb3MsICIgYXV0byIpICE9IE5VTEw7CisJcGQgPSBvc19zdHJzdHIocG9zLCAiIHByb3ZkaXNjIikgIT0gTlVMTDsKIAogCXBvczIgPSBvc19zdHJzdHIocG9zLCAiIGdvX2ludGVudD0iKTsKIAlpZiAocG9zMikgewpAQCAtMjczOSwxMSArMzA2NywxNSBAQAogCQkJaWYgKG9zX3N0cm5jbXAocG9zLCAiZGlzcGxheSIsIDcpID09IDApCiAJCQkJd3BzX21ldGhvZCA9IFdQU19QSU5fRElTUExBWTsKIAkJfQorCQlpZiAoIXdwc19waW5fc3RyX3ZhbGlkKHBpbikpIHsKKwkJCW9zX21lbWNweShidWYsICJGQUlMLUlOVkFMSUQtUElOXG4iLCAxNyk7CisJCQlyZXR1cm4gMTc7CisJCX0KIAl9CiAKIAluZXdfcGluID0gd3Bhc19wMnBfY29ubmVjdCh3cGFfcywgYWRkciwgcGluLCB3cHNfbWV0aG9kLAotCQkJCSAgIHBlcnNpc3RlbnRfZ3JvdXAsIGpvaW4sIGF1dGgsIGdvX2ludGVudCwKLQkJCQkgICBmcmVxKTsKKwkJCQkgICBwZXJzaXN0ZW50X2dyb3VwLCBhdXRvbWF0aWMsIGpvaW4sCisJCQkJICAgYXV0aCwgZ29faW50ZW50LCBmcmVxLCBwZXJzaXN0ZW50X2lkLCBwZCk7CiAJaWYgKG5ld19waW4gPT0gLTIpIHsKIAkJb3NfbWVtY3B5KGJ1ZiwgIkZBSUwtQ0hBTk5FTC1VTkFWQUlMQUJMRVxuIiwgMjUpOwogCQlyZXR1cm4gMjU7CkBAIC0yNzc3LDggKzMxMDksOSBAQAogewogCXU4IGFkZHJbRVRIX0FMRU5dOwogCWNoYXIgKnBvczsKKwllbnVtIHdwYXNfcDJwX3Byb3ZfZGlzY191c2UgdXNlID0gV1BBU19QMlBfUERfRk9SX0dPX05FRzsKIAotCS8qIDxhZGRyPiA8Y29uZmlnIG1ldGhvZD4gW2pvaW5dICovCisJLyogPGFkZHI+IDxjb25maWcgbWV0aG9kPiBbam9pbnxhdXRvXSAqLwogCiAJaWYgKGh3YWRkcl9hdG9uKGNtZCwgYWRkcikpCiAJCXJldHVybiAtMTsKQEAgLTI3ODgsOCArMzEyMSwxMiBAQAogCQlyZXR1cm4gLTE7CiAJcG9zKys7CiAKLQlyZXR1cm4gd3Bhc19wMnBfcHJvdl9kaXNjKHdwYV9zLCBhZGRyLCBwb3MsCi0JCQkJICBvc19zdHJzdHIocG9zLCAiam9pbiIpICE9IE5VTEwpOworCWlmIChvc19zdHJzdHIocG9zLCAiIGpvaW4iKSAhPSBOVUxMKQorCQl1c2UgPSBXUEFTX1AyUF9QRF9GT1JfSk9JTjsKKwllbHNlIGlmIChvc19zdHJzdHIocG9zLCAiIGF1dG8iKSAhPSBOVUxMKQorCQl1c2UgPSBXUEFTX1AyUF9QRF9BVVRPOworCisJcmV0dXJuIHdwYXNfcDJwX3Byb3ZfZGlzYyh3cGFfcywgYWRkciwgcG9zLCB1c2UpOwogfQogCiAKQEAgLTI5MjYsNiArMzI2Myw4IEBACiBzdGF0aWMgaW50IHAycF9jdHJsX3NlcnZfZGlzY19leHRlcm5hbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICAgICBjaGFyICpjbWQpCiB7CisJaWYgKG9zX3N0cmNtcChjbWQsICIwIikgJiYgb3Nfc3RyY21wKGNtZCwgIjEiKSkKKwkJcmV0dXJuIC0xOwogCXdwYV9zLT5wMnBfc2Rfb3Zlcl9jdHJsX2lmYWNlID0gYXRvaShjbWQpOwogCXJldHVybiAwOwogfQpAQCAtMzI3OCw2ICszNjE3LDU2IEBACiB9CiAKIAorc3RhdGljIGludCBwMnBfY3RybF9kaXNhbGxvd19mcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICBjb25zdCBjaGFyICpwYXJhbSkKK3sKKwlzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2UgKmZyZXEgPSBOVUxMLCAqbjsKKwl1bnNpZ25lZCBpbnQgY291bnQgPSAwLCBpOworCWNvbnN0IGNoYXIgKnBvcywgKnBvczIsICpwb3MzOworCisJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwkvKgorCSAqIHBhcmFtIGluY2x1ZGVzIGNvbW1hIHNlcGFyYXRlZCBmcmVxdWVuY3kgcmFuZ2UuCisJICogRm9yIGV4YW1wbGU6IDI0MTItMjQzMiwyNDYyLDUwMDAtNjAwMAorCSAqLworCXBvcyA9IHBhcmFtOworCXdoaWxlIChwb3MgJiYgcG9zWzBdKSB7CisJCW4gPSBvc19yZWFsbG9jKGZyZXEsCisJCQkgICAgICAgKGNvdW50ICsgMSkgKiBzaXplb2Yoc3RydWN0IHdwYV9mcmVxX3JhbmdlKSk7CisJCWlmIChuID09IE5VTEwpIHsKKwkJCW9zX2ZyZWUoZnJlcSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJZnJlcSA9IG47CisJCWZyZXFbY291bnRdLm1pbiA9IGF0b2kocG9zKTsKKwkJcG9zMiA9IG9zX3N0cmNocihwb3MsICctJyk7CisJCXBvczMgPSBvc19zdHJjaHIocG9zLCAnLCcpOworCQlpZiAocG9zMiAmJiAoIXBvczMgfHwgcG9zMiA8IHBvczMpKSB7CisJCQlwb3MyKys7CisJCQlmcmVxW2NvdW50XS5tYXggPSBhdG9pKHBvczIpOworCQl9IGVsc2UKKwkJCWZyZXFbY291bnRdLm1heCA9IGZyZXFbY291bnRdLm1pbjsKKwkJcG9zID0gcG9zMzsKKwkJaWYgKHBvcykKKwkJCXBvcysrOworCQljb3VudCsrOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBEaXNhbGxvd2VkIGZyZXF1ZW5jeSByYW5nZSAldS0ldSIsCisJCQkgICBmcmVxW2ldLm1pbiwgZnJlcVtpXS5tYXgpOworCX0KKworCW9zX2ZyZWUod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXEpOworCXdwYV9zLT5nbG9iYWwtPnAycF9kaXNhbGxvd19mcmVxID0gZnJlcTsKKwl3cGFfcy0+Z2xvYmFsLT5udW1fcDJwX2Rpc2FsbG93X2ZyZXEgPSBjb3VudDsKKwl3cGFzX3AycF91cGRhdGVfY2hhbm5lbF9saXN0KHdwYV9zKTsKKwlyZXR1cm4gMDsKK30KKworCiBzdGF0aWMgaW50IHAycF9jdHJsX3NldChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCiB7CiAJY2hhciAqcGFyYW07CkBAIC0zMzU2LDcgKzM3NDUsNyBAQAogCQl9CiAJCXJldHVybiAwOwogCX0KLSNpZmRlZiBBTkRST0lEX1AyUAorCiAJaWYgKG9zX3N0cmNtcChjbWQsICJjb25jX3ByZWYiKSA9PSAwKSB7CiAJCWlmIChvc19zdHJjbXAocGFyYW0sICJzdGEiKSA9PSAwKQogCQkJd3BhX3MtPmdsb2JhbC0+Y29uY19wcmVmID0gV1BBX0NPTkNfUFJFRl9TVEE7CkBAIC0zMzY3LDEwICszNzU2LDEwIEBACiAJCQlyZXR1cm4gLTE7CiAJCX0KIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTaW5nbGUgY2hhbm5lbCBjb25jdXJyZW5jeSBwcmVmZXJlbmNlOiAiCi0JCQkiJXMiLCBwYXJhbSk7CisJCQkgICAiJXMiLCBwYXJhbSk7CiAJCXJldHVybiAwOwogCX0KLSNlbmRpZgorCiAJaWYgKG9zX3N0cmNtcChjbWQsICJmb3JjZV9sb25nX3NkIikgPT0gMCkgewogCQl3cGFfcy0+Zm9yY2VfbG9uZ19zZCA9IGF0b2kocGFyYW0pOwogCQlyZXR1cm4gMDsKQEAgLTM0MzYsNiArMzgyNSw5IEBACiAJCXJldHVybiAwOwogCX0KIAorCWlmIChvc19zdHJjbXAoY21kLCAiZGlzYWxsb3dfZnJlcSIpID09IDApCisJCXJldHVybiBwMnBfY3RybF9kaXNhbGxvd19mcmVxKHdwYV9zLCBwYXJhbSk7CisKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFVua25vd24gUDJQX1NFVCBmaWVsZCB2YWx1ZSAnJXMnIiwKIAkJICAgY21kKTsKIApAQCAtMzU0OCw2ICszOTQwLDExMSBAQAogI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KIAogCisjaWZkZWYgQ09ORklHX0hTMjAKKworc3RhdGljIGludCBnZXRfaHMyMF9hbnFwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmRzdCkKK3sKKwl1OCBkc3RfYWRkcltFVEhfQUxFTl07CisJaW50IHVzZWQ7CisJY2hhciAqcG9zOworCXUzMiBzdWJ0eXBlcyA9IDA7CisKKwl1c2VkID0gaHdhZGRyX2F0b24yKGRzdCwgZHN0X2FkZHIpOworCWlmICh1c2VkIDwgMCkKKwkJcmV0dXJuIC0xOworCXBvcyA9IGRzdCArIHVzZWQ7CisJZm9yICg7OykgeworCQlpbnQgbnVtID0gYXRvaShwb3MpOworCQlpZiAobnVtIDw9IDAgfHwgbnVtID4gMzEpCisJCQlyZXR1cm4gLTE7CisJCXN1YnR5cGVzIHw9IEJJVChudW0pOworCQlwb3MgPSBvc19zdHJjaHIocG9zICsgMSwgJywnKTsKKwkJaWYgKHBvcyA9PSBOVUxMKQorCQkJYnJlYWs7CisJCXBvcysrOworCX0KKworCWlmIChzdWJ0eXBlcyA9PSAwKQorCQlyZXR1cm4gLTE7CisKKwlyZXR1cm4gaHMyMF9hbnFwX3NlbmRfcmVxKHdwYV9zLCBkc3RfYWRkciwgc3VidHlwZXMsIE5VTEwsIDApOworfQorCisKK3N0YXRpYyBpbnQgaHMyMF9uYWlfaG9tZV9yZWFsbV9saXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgIGNvbnN0IHU4ICphZGRyLCBjb25zdCBjaGFyICpyZWFsbSkKK3sKKwl1OCAqYnVmOworCXNpemVfdCBybGVuLCBsZW47CisJaW50IHJldDsKKworCXJsZW4gPSBvc19zdHJsZW4ocmVhbG0pOworCWxlbiA9IDMgKyBybGVuOworCWJ1ZiA9IG9zX21hbGxvYyhsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWJ1ZlswXSA9IDE7IC8qIE5BSSBIb21lIFJlYWxtIENvdW50ICovCisJYnVmWzFdID0gMDsgLyogRm9ybWF0dGVkIGluIGFjY29yZGFuY2Ugd2l0aCBSRkMgNDI4MiAqLworCWJ1ZlsyXSA9IHJsZW47CisJb3NfbWVtY3B5KGJ1ZiArIDMsIHJlYWxtLCBybGVuKTsKKworCXJldCA9IGhzMjBfYW5xcF9zZW5kX3JlcSh3cGFfcywgYWRkciwKKwkJCQkgQklUKEhTMjBfU1RZUEVfTkFJX0hPTUVfUkVBTE1fUVVFUlkpLAorCQkJCSBidWYsIGxlbik7CisKKwlvc19mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmV0OworfQorCisKK3N0YXRpYyBpbnQgaHMyMF9nZXRfbmFpX2hvbWVfcmVhbG1fbGlzdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQljaGFyICpkc3QpCit7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7CisJdTggZHN0X2FkZHJbRVRIX0FMRU5dOworCWludCB1c2VkOworCXU4ICpidWY7CisJc2l6ZV90IGxlbjsKKwlpbnQgcmV0OworCisJdXNlZCA9IGh3YWRkcl9hdG9uMihkc3QsIGRzdF9hZGRyKTsKKwlpZiAodXNlZCA8IDApCisJCXJldHVybiAtMTsKKworCXdoaWxlIChkc3RbdXNlZF0gPT0gJyAnKQorCQl1c2VkKys7CisJaWYgKG9zX3N0cm5jbXAoZHN0ICsgdXNlZCwgInJlYWxtPSIsIDYpID09IDApCisJCXJldHVybiBoczIwX25haV9ob21lX3JlYWxtX2xpc3Qod3BhX3MsIGRzdF9hZGRyLAorCQkJCQkJZHN0ICsgdXNlZCArIDYpOworCisJbGVuID0gb3Nfc3RybGVuKGRzdCArIHVzZWQpOworCisJaWYgKGxlbiA9PSAwICYmIGNyZWQgJiYgY3JlZC0+cmVhbG0pCisJCXJldHVybiBoczIwX25haV9ob21lX3JlYWxtX2xpc3Qod3BhX3MsIGRzdF9hZGRyLCBjcmVkLT5yZWFsbSk7CisKKwlpZiAobGVuICUgMSkKKwkJcmV0dXJuIC0xOworCWxlbiAvPSAyOworCWJ1ZiA9IG9zX21hbGxvYyhsZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCWlmIChoZXhzdHIyYmluKGRzdCArIHVzZWQsIGJ1ZiwgbGVuKSA8IDApIHsKKwkJb3NfZnJlZShidWYpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0ID0gaHMyMF9hbnFwX3NlbmRfcmVxKHdwYV9zLCBkc3RfYWRkciwKKwkJCQkgQklUKEhTMjBfU1RZUEVfTkFJX0hPTUVfUkVBTE1fUVVFUlkpLAorCQkJCSBidWYsIGxlbik7CisJb3NfZnJlZShidWYpOworCisJcmV0dXJuIHJldDsKK30KKworI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3N0YV9hdXRvY29ubmVjdCgKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCiB7CkBAIC0zNTU2LDYgKzQwNTMsMzYgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOCisKK3N0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9hdXRvc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgICBjaGFyICpjbWQpCit7CisJZW51bSB3cGFfc3RhdGVzIHN0YXRlID0gd3BhX3MtPndwYV9zdGF0ZTsKKwljaGFyICpuZXdfcGFyYW1zID0gTlVMTDsKKworCWlmIChvc19zdHJsZW4oY21kKSA+IDApIHsKKwkJbmV3X3BhcmFtcyA9IG9zX3N0cmR1cChjbWQpOworCQlpZiAobmV3X3BhcmFtcyA9PSBOVUxMKQorCQkJcmV0dXJuIC0xOworCX0KKworCW9zX2ZyZWUod3BhX3MtPmNvbmYtPmF1dG9zY2FuKTsKKwl3cGFfcy0+Y29uZi0+YXV0b3NjYW4gPSBuZXdfcGFyYW1zOworCisJaWYgKHdwYV9zLT5jb25mLT5hdXRvc2NhbiA9PSBOVUxMKQorCQlhdXRvc2Nhbl9kZWluaXQod3BhX3MpOworCWVsc2UgaWYgKHN0YXRlID09IFdQQV9ESVNDT05ORUNURUQgfHwgc3RhdGUgPT0gV1BBX0lOQUNUSVZFKQorCQlhdXRvc2Nhbl9pbml0KHdwYV9zLCAxKTsKKwllbHNlIGlmIChzdGF0ZSA9PSBXUEFfU0NBTk5JTkcpCisJCXdwYV9zdXBwbGljYW50X3JlaW5pdF9hdXRvc2Nhbih3cGFfcyk7CisKKwlyZXR1cm4gMDsKK30KKworI2VuZGlmIC8qIENPTkZJR19BVVRPU0NBTiAqLworCisKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfc2lnbmFsX3BvbGwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqYnVmLAogCQkJCSAgICAgIHNpemVfdCBidWZsZW4pCiB7CkBAIC0zNjU0LDYgKzQxODEsNyBAQAogCQllYXBvbF9zbV9ub3RpZnlfbG9nb2ZmKHdwYV9zLT5lYXBvbCwgVFJVRSk7CiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUkVBU1NPQ0lBVEUiKSA9PSAwKSB7CiAJCXdwYV9zLT5ub3JtYWxfc2NhbnMgPSAwOworCQl3cGFfc3VwcGxpY2FudF9yZWluaXRfYXV0b3NjYW4od3BhX3MpOwogCQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfSU5URVJGQUNFX0RJU0FCTEVEKQogCQkJcmVwbHlfbGVuID0gLTE7CiAJCWVsc2UgewpAQCAtMzY2Myw2ICs0MTkxLDcgQEAKIAkJfQogCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlJFQ09OTkVDVCIpID09IDApIHsKIAkJd3BhX3MtPm5vcm1hbF9zY2FucyA9IDA7CisJCXdwYV9zdXBwbGljYW50X3JlaW5pdF9hdXRvc2Nhbih3cGFfcyk7CiAJCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpCiAJCQlyZXBseV9sZW4gPSAtMTsKIAkJZWxzZSBpZiAod3BhX3MtPmRpc2Nvbm5lY3RlZCkgewpAQCAtMzcxNSw2ICs0MjQ0LDIxIEBACiAJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19vb2Iod3BhX3MsIGJ1ZiArIDgpKQogCQkJcmVwbHlfbGVuID0gLTE7CiAjZW5kaWYgLyogQ09ORklHX1dQU19PT0IgKi8KKyNpZmRlZiBDT05GSUdfV1BTX05GQworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIldQU19ORkMiKSA9PSAwKSB7CisJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19uZmMod3BhX3MsIE5VTEwpKQorCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19ORkMgIiwgOCkgPT0gMCkgeworCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjKHdwYV9zLCBidWYgKyA4KSkKKwkJCXJlcGx5X2xlbiA9IC0xOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX1RPS0VOICIsIDE0KSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX25mY190b2tlbigKKwkJCXdwYV9zLCBidWYgKyAxNCwgcmVwbHksIHJlcGx5X3NpemUpOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX1RBR19SRUFEICIsIDE3KSA9PSAwKSB7CisJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19uZmNfdGFnX3JlYWQod3BhX3MsCisJCQkJCQkJICAgICAgIGJ1ZiArIDE3KSkKKwkJCXJlcGx5X2xlbiA9IC0xOworI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19SRUcgIiwgOCkgPT0gMCkgewogCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfcmVnKHdwYV9zLCBidWYgKyA4KSkKIAkJCXJlcGx5X2xlbiA9IC0xOwpAQCAtMzc1OSw2ICs0MzAzLDExIEBACiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19FUl9DT05GSUcgIiwgMTQpID09IDApIHsKIAkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2VyX2NvbmZpZyh3cGFfcywgYnVmICsgMTQpKQogCQkJcmVwbHlfbGVuID0gLTE7CisjaWZkZWYgQ09ORklHX1dQU19ORkMKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX0VSX05GQ19DT05GSUdfVE9LRU4gIiwgMjQpID09IDApIHsKKwkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfZXJfbmZjX2NvbmZpZ190b2tlbigKKwkJCXdwYV9zLCBidWYgKyAyNCwgcmVwbHksIHJlcGx5X3NpemUpOworI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCiAjZW5kaWYgLyogQ09ORklHX1dQU19FUiAqLwogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KICNpZmRlZiBDT05GSUdfSUJTU19SU04KQEAgLTM4NzMsNiArNDQyMiwxNCBAQAogCQlpZiAoZ2V0X2FucXAod3BhX3MsIGJ1ZiArIDkpIDwgMCkKIAkJCXJlcGx5X2xlbiA9IC0xOwogI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KKyNpZmRlZiBDT05GSUdfSFMyMAorCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJIUzIwX0FOUVBfR0VUICIsIDE0KSA9PSAwKSB7CisJCWlmIChnZXRfaHMyMF9hbnFwKHdwYV9zLCBidWYgKyAxNCkgPCAwKQorCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkhTMjBfR0VUX05BSV9IT01FX1JFQUxNX0xJU1QgIiwgMjkpID09IDApIHsKKwkJaWYgKGhzMjBfZ2V0X25haV9ob21lX3JlYWxtX2xpc3Qod3BhX3MsIGJ1ZiArIDI5KSA8IDApCisJCQlyZXBseV9sZW4gPSAtMTsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsIFdQQV9DVFJMX1JTUCwgb3Nfc3RybGVuKFdQQV9DVFJMX1JTUCkpID09IDApCiAJewogCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9jdHJsX3JzcCgKQEAgLTM4OTgsMTkgKzQ0NTUsMzAgQEAKIAkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9saXN0X25ldHdvcmtzKAogCQkJd3BhX3MsIHJlcGx5LCByZXBseV9zaXplKTsKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJESVNDT05ORUNUIikgPT0gMCkgeworI2lmZGVmIENPTkZJR19TTUUKKwkJd3BhX3MtPnNtZS5wcmV2X2Jzc2lkX3NldCA9IDA7CisjZW5kaWYgLyogQ09ORklHX1NNRSAqLwogCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAwOwogCQl3cGFfcy0+ZGlzY29ubmVjdGVkID0gMTsKIAkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjaGVkX3NjYW4od3BhX3MpOworCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2Nhbih3cGFfcyk7CiAJCXdwYV9zdXBwbGljYW50X2RlYXV0aGVudGljYXRlKHdwYV9zLAogCQkJCQkgICAgICBXTEFOX1JFQVNPTl9ERUFVVEhfTEVBVklORyk7CiAJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0NBTiIpID09IDApIHsKLQkJd3BhX3MtPm5vcm1hbF9zY2FucyA9IDA7CiAJCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpCiAJCQlyZXBseV9sZW4gPSAtMTsKIAkJZWxzZSB7CiAJCQlpZiAoIXdwYV9zLT5zY2FubmluZyAmJgogCQkJICAgICgod3BhX3MtPndwYV9zdGF0ZSA8PSBXUEFfU0NBTk5JTkcpIHx8CiAJCQkgICAgICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9DT01QTEVURUQpKSkgeworCQkJCXdwYV9zLT5ub3JtYWxfc2NhbnMgPSAwOworCQkJCXdwYV9zLT5zY2FuX3JlcSA9IDI7CisJCQkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOworCQkJfSBlbHNlIGlmICh3cGFfcy0+c2NoZWRfc2Nhbm5pbmcpIHsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN0b3Agb25nb2luZyAiCisJCQkJCSAgICJzY2hlZF9zY2FuIHRvIGFsbG93IHJlcXVlc3RlZCAiCisJCQkJCSAgICJmdWxsIHNjYW4gdG8gcHJvY2VlZCIpOworCQkJCXdwYV9zdXBwbGljYW50X2NhbmNlbF9zY2hlZF9zY2FuKHdwYV9zKTsKIAkJCQl3cGFfcy0+c2Nhbl9yZXEgPSAyOwogCQkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKIAkJCX0gZWxzZSB7CkBAIC0zOTQ0LDYgKzQ1MTIsMTggQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiR0VUX05FVFdPUksgIiwgMTIpID09IDApIHsKIAkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9nZXRfbmV0d29yaygKIAkJCXdwYV9zLCBidWYgKyAxMiwgcmVwbHksIHJlcGx5X3NpemUpOworCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIkxJU1RfQ1JFRFMiKSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfbGlzdF9jcmVkcygKKwkJCXdwYV9zLCByZXBseSwgcmVwbHlfc2l6ZSk7CisJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiQUREX0NSRUQiKSA9PSAwKSB7CisJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYWRkX2NyZWQoCisJCQl3cGFfcywgcmVwbHksIHJlcGx5X3NpemUpOworCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJSRU1PVkVfQ1JFRCAiLCAxMikgPT0gMCkgeworCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9yZW1vdmVfY3JlZCh3cGFfcywgYnVmICsgMTIpKQorCQkJcmVwbHlfbGVuID0gLTE7CisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNFVF9DUkVEICIsIDkpID09IDApIHsKKwkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2V0X2NyZWQod3BhX3MsIGJ1ZiArIDkpKQorCQkJcmVwbHlfbGVuID0gLTE7CiAjaWZuZGVmIENPTkZJR19OT19DT05GSUdfV1JJVEUKIAl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTQVZFX0NPTkZJRyIpID09IDApIHsKIAkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2F2ZV9jb25maWcod3BhX3MpKQpAQCAtMzk3Niw2ICs0NTU2LDEyIEBACiAJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNUQS1ORVhUICIsIDkpID09IDApIHsKIAkJcmVwbHlfbGVuID0gYXBfY3RybF9pZmFjZV9zdGFfbmV4dCh3cGFfcywgYnVmICsgOSwgcmVwbHksCiAJCQkJCQkgICByZXBseV9zaXplKTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiREVBVVRIRU5USUNBVEUgIiwgMTUpID09IDApIHsKKwkJaWYgKGFwX2N0cmxfaWZhY2Vfc3RhX2RlYXV0aGVudGljYXRlKHdwYV9zLCBidWYgKyAxNSkpCisJCQlyZXBseV9sZW4gPSAtMTsKKwl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiRElTQVNTT0NJQVRFICIsIDEzKSA9PSAwKSB7CisJCWlmIChhcF9jdHJsX2lmYWNlX3N0YV9kaXNhc3NvY2lhdGUod3BhX3MsIGJ1ZiArIDEzKSkKKwkJCXJlcGx5X2xlbiA9IC0xOwogI2VuZGlmIC8qIENPTkZJR19BUCAqLwogCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlNVU1BFTkQiKSA9PSAwKSB7CiAJCXdwYXNfbm90aWZ5X3N1c3BlbmQod3BhX3MtPmdsb2JhbCk7CkBAIC00MDEwLDYgKzQ1OTYsMTEgQEAKIAl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU0lHTkFMX1BPTEwiLCAxMSkgPT0gMCkgewogCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9zaWduYWxfcG9sbCh3cGFfcywgcmVwbHksCiAJCQkJCQkgICAgICAgcmVwbHlfc2l6ZSk7CisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOCisJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkFVVE9TQ0FOICIsIDkpID09IDApIHsKKwkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYXV0b3NjYW4od3BhX3MsIGJ1ZiArIDkpKQorCQkJcmVwbHlfbGVuID0gLTE7CisjZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOICovCiAjaWZkZWYgQU5EUk9JRAogCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJEUklWRVIgIiwgNykgPT0gMCkgewogCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9kcml2ZXJfY21kKHdwYV9zLCBidWYgKyA3LCByZXBseSwKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2UuaCBiL3dwYV9zdXBwbGljYW50L2N0cmxfaWZhY2UuaAppbmRleCAzZjFjNmEwLi5hMzI5ZWYzIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvY3RybF9pZmFjZS5oCkBAIC04OSwyMSArODksNiBAQAogdm9pZCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dhaXQoc3RydWN0IGN0cmxfaWZhY2VfcHJpdiAqcHJpdik7CiAKIC8qKgotICogd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9jdHJsX3JzcF9oYW5kbGUgLSBIYW5kbGUgYSBjb250cm9sIHJlc3BvbnNlCi0gKiBAd3BhX3M6IFBvaW50ZXIgdG8gd3BhX3N1cHBsaWNhbnQgZGF0YQotICogQHNzaWQ6IFBvaW50ZXIgdG8gdGhlIG5ldHdvcmsgYmxvY2sgdGhlIHJlcGx5IGlzIGZvcgotICogQGZpZWxkOiBmaWVsZCB0aGUgcmVzcG9uc2UgaXMgYSByZXBseSBmb3IKLSAqIEB2YWx1ZTogdmFsdWUgKGllLCBwYXNzd29yZCwgZXRjKSBmb3IgQGZpZWxkCi0gKiBSZXR1cm5zOiAwIG9uIHN1Y2Nlc3MsIG5vbi16ZXJvIG9uIGVycm9yCi0gKgotICogSGVscGVyIGZ1bmN0aW9uIHRvIGhhbmRsZSByZXBsaWVzIHRvIGNvbnRyb2wgaW50ZXJmYWNlIHJlcXVlc3RzLgotICovCi1pbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9jdHJsX3JzcF9oYW5kbGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKLQkJCQkJICAgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkLAotCQkJCQkgICAgICBjb25zdCBjaGFyICpmaWVsZCwKLQkJCQkJICAgICAgY29uc3QgY2hhciAqdmFsdWUpOwotCi0vKioKICAqIHdwYV9zdXBwbGljYW50X2dsb2JhbF9jdHJsX2lmYWNlX2luaXQgLSBJbml0aWFsaXplIGdsb2JhbCBjb250cm9sIGludGVyZmFjZQogICogQGdsb2JhbDogUG9pbnRlciB0byBnbG9iYWwgZGF0YSBmcm9tIHdwYV9zdXBwbGljYW50X2luaXQoKQogICogUmV0dXJuczogUG9pbnRlciB0byBwcml2YXRlIGRhdGEgb24gc3VjY2VzcywgJU5VTEwgb24gZmFpbHVyZQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvY3RybF9pZmFjZV91bml4LmMgYi93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlX3VuaXguYwppbmRleCAzMDExNTZlLi44ZGJhNDZkIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlX3VuaXguYworKysgYi93cGFfc3VwcGxpY2FudC9jdHJsX2lmYWNlX3VuaXguYwpAQCAtMTg0LDYgKzE4NCw3IEBACiAJCQkJd3BhX3MgPSBlbG9vcF9jdHg7CiAJCQl9CiAJCQlvc19tZW1tb3ZlKGlmbmFtZSwgaWZlbmQsIHN0cmxlbihpZmVuZCkgKyAxKTsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAid3BhX3MgJXAgY21kICVzIiwgd3BhX3MsIGJ1Zik7CiAJCX0KICNlbmRpZiAvKiBkZWZpbmVkIENPTkZJR19QMlAgJiYgZGVmaW5lZCBBTkRST0lEX1AyUCAqLwogCQlyZXBseSA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcHJvY2Vzcyh3cGFfcywgYnVmLApAQCAtMzk3LDcgKzM5OCw3IEBACiAJCQl9CiAJCQlpZiAoYmluZChwcml2LT5zb2NrLCAoc3RydWN0IHNvY2thZGRyICopICZhZGRyLAogCQkJCSBzaXplb2YoYWRkcikpIDwgMCkgewotCQkJCXBlcnJvcigiYmluZChQRl9VTklYKSIpOworCQkJCXBlcnJvcigic3VwcC1jdHJsLWlmYWNlLWluaXQ6IGJpbmQoUEZfVU5JWCkiKTsKIAkJCQlnb3RvIGZhaWw7CiAJCQl9CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN1Y2Nlc3NmdWxseSByZXBsYWNlZCBsZWZ0b3ZlciAiCkBAIC02ODksNyArNjkwLDggQEAKIAlvc19zdHJsY3B5KGFkZHIuc3VuX3BhdGgsIGdsb2JhbC0+cGFyYW1zLmN0cmxfaW50ZXJmYWNlLAogCQkgICBzaXplb2YoYWRkci5zdW5fcGF0aCkpOwogCWlmIChiaW5kKHByaXYtPnNvY2ssIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmFkZHIsIHNpemVvZihhZGRyKSkgPCAwKSB7Ci0JCXBlcnJvcigiYmluZChQRl9VTklYKSIpOworCQlwZXJyb3IoInN1cHAtZ2xvYmFsLWN0cmwtaWZhY2UtaW5pdCAod2lsbCB0cnkgZml4dXApOiAiCisJCSAgICAgICAiYmluZChQRl9VTklYKSIpOwogCQlpZiAoY29ubmVjdChwcml2LT5zb2NrLCAoc3RydWN0IHNvY2thZGRyICopICZhZGRyLAogCQkJICAgIHNpemVvZihhZGRyKSkgPCAwKSB7CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgImN0cmxfaWZhY2UgZXhpc3RzLCBidXQgZG9lcyBub3QiCkBAIC03MDQsNyArNzA2LDcgQEAKIAkJCX0KIAkJCWlmIChiaW5kKHByaXYtPnNvY2ssIChzdHJ1Y3Qgc29ja2FkZHIgKikgJmFkZHIsCiAJCQkJIHNpemVvZihhZGRyKSkgPCAwKSB7Ci0JCQkJcGVycm9yKCJiaW5kKFBGX1VOSVgpIik7CisJCQkJcGVycm9yKCJzdXBwLWdsYi1pZmFjZS1pbml0OiBiaW5kKFBGX1VOSVgpIik7CiAJCQkJZ290byBmYWlsOwogCQkJfQogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTdWNjZXNzZnVsbHkgcmVwbGFjZWQgbGVmdG92ZXIgIgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2NvbW1vbi5jIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2NvbW1vbi5jCmluZGV4IDU4NTA2MzYuLjVkMGUzMWUgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19jb21tb24uYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfY29tbW9uLmMKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA5LCBXaXRvbGQgU293YSA8d2l0b2xkLnNvd2FAZ21haWwuY29tPgogICogQ29weXJpZ2h0IChjKSAyMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2NvbW1vbi5oIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2NvbW1vbi5oCmluZGV4IDUwZGEwOWIuLmFlYTdkYjcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19jb21tb24uaAorKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfY29tbW9uLmgKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA5LCBXaXRvbGQgU293YSA8d2l0b2xkLnNvd2FAZ21haWwuY29tPgogICogQ29weXJpZ2h0IChjKSAyMDA5LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpZm5kZWYgREJVU19DT01NT05fSApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2NvbW1vbl9pLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfY29tbW9uX2kuaAppbmRleCA5ZGFiMWVlLi5hNTUxY2NkIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfY29tbW9uX2kuaAorKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfY29tbW9uX2kuaApAQCAtNCwxNCArNCw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDksIFdpdG9sZCBTb3dhIDx3aXRvbGQuc293YUBnbWFpbC5jb20+CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBEQlVTX0NPTU1PTl9JX0gKQEAgLTI1LDYgKzE5LDEwIEBACiAJc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbDsKIAl1MzIgbmV4dF9vYmppZDsKIAlpbnQgZGJ1c19uZXdfaW5pdGlhbGl6ZWQ7CisKKyNpZiBkZWZpbmVkKENPTkZJR19DVFJMX0lGQUNFX0RCVVNfTkVXKSAmJiBkZWZpbmVkKENPTkZJR19BUCkKKwlpbnQgZGJ1c19ub2NfcmVmY250OworI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX0RCVVNfTkVXICYmIENPTkZJR19BUCAqLwogfTsKIAogI2VuZGlmIC8qIERCVVNfQ09NTU9OX0lfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2RpY3RfaGVscGVycy5jIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2RpY3RfaGVscGVycy5jCmluZGV4IDY4YTljMjguLjY3OTI0ZTAgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19kaWN0X2hlbHBlcnMuYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfZGljdF9oZWxwZXJzLmMKQEAgLTIsMTQgKzIsOCBAQAogICogV1BBIFN1cHBsaWNhbnQgLyBkYnVzLWJhc2VkIGNvbnRyb2wgaW50ZXJmYWNlCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDYsIERhbiBXaWxsaWFtcyA8ZGNid0ByZWRoYXQuY29tPiBhbmQgUmVkIEhhdCwgSW5jLgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpAQCAtMTEwNCw1ICsxMDk4LDUgQEAKIAkJYnJlYWs7CiAJfQogCi0JbWVtc2V0KGVudHJ5LCAwLCBzaXplb2Yoc3RydWN0IHdwYV9kYnVzX2RpY3RfZW50cnkpKTsKKwlvc19tZW1zZXQoZW50cnksIDAsIHNpemVvZihzdHJ1Y3Qgd3BhX2RidXNfZGljdF9lbnRyeSkpOwogfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2RpY3RfaGVscGVycy5oIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX2RpY3RfaGVscGVycy5oCmluZGV4IDJmNmViNDUuLjk2NjYzNDkgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19kaWN0X2hlbHBlcnMuaAorKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfZGljdF9oZWxwZXJzLmgKQEAgLTIsMTQgKzIsOCBAQAogICogV1BBIFN1cHBsaWNhbnQgLyBkYnVzLWJhc2VkIGNvbnRyb2wgaW50ZXJmYWNlCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDYsIERhbiBXaWxsaWFtcyA8ZGNid0ByZWRoYXQuY29tPiBhbmQgUmVkIEhhdCwgSW5jLgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpZm5kZWYgREJVU19ESUNUX0hFTFBFUlNfSApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ldy5jIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ldy5jCmluZGV4IGNlN2NmZmIuLmE5OTU3YWIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXcuYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3LmMKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA5LTIwMTAsIFdpdG9sZCBTb3dhIDx3aXRvbGQuc293YUBnbWFpbC5jb20+CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC0zMSw2ICsyNSw5OSBAQAogI2luY2x1ZGUgImRidXNfbmV3X2hhbmRsZXJzX3AycC5oIgogI2luY2x1ZGUgInAycC9wMnAuaCIKIAorI2lmZGVmIENPTkZJR19BUCAvKiB1bnRpbCBuZWVkZWQgYnkgc29tZXRoaW5nIGVsc2UgKi8KKworLyoKKyAqIE5hbWVPd25lckNoYW5nZWQgaGFuZGxpbmcKKyAqCisgKiBTb21lIHNlcnZpY2VzIHdlIHByb3ZpZGUgYWxsb3cgYW4gYXBwbGljYXRpb24gdG8gcmVnaXN0ZXIgZm9yCisgKiBhIHNpZ25hbCB0aGF0IGl0IG5lZWRzLiBXaGlsZSBpdCBjYW4gYWxzbyB1bnJlZ2lzdGVyLCB3ZSBtdXN0CisgKiBiZSBwcmVwYXJlZCBmb3IgdGhlIGNhc2Ugd2hlcmUgdGhlIGFwcGxpY2F0aW9uIHNpbXBseSBjcmFzaGVzCisgKiBhbmQgdGh1cyBkb2Vzbid0IGNsZWFuIHVwIHByb3Blcmx5LiBUaGUgd2F5IHRvIGhhbmRsZSB0aGlzIGluCisgKiBEQnVzIGlzIHRvIHJlZ2lzdGVyIGZvciB0aGUgTmFtZU93bmVyQ2hhbmdlZCBzaWduYWwgd2hpY2ggd2lsbAorICogc2lnbmFsIGFuIG93bmVyIGNoYW5nZSB0byBOVUxMIGlmIHRoZSBwZWVyIGNsb3NlcyB0aGUgc29ja2V0CisgKiBmb3Igd2hhdGV2ZXIgcmVhc29uLgorICoKKyAqIEhhbmRsZSB0aGlzIHNpZ25hbCB2aWEgYSBmaWx0ZXIgZnVuY3Rpb24gd2hlbmV2ZXIgbmVjZXNzYXJ5LgorICogVGhlIGNvZGUgYmVsb3cgYWxzbyBoYW5kbGVzIHJlZmNvdW50aW5nIGluIGNhc2UgaW4gdGhlIGZ1dHVyZQorICogdGhlcmUgd2lsbCBiZSBtdWx0aXBsZSBpbnN0YW5jZXMgb2YgdGhpcyBzdWJzY3JpcHRpb24gc2NoZW1lLgorICovCitzdGF0aWMgY29uc3QgY2hhciB3cGFzX2RidXNfbm9jX2ZpbHRlcl9zdHJbXSA9CisJImludGVyZmFjZT1vcmcuZnJlZWRlc2t0b3AuREJ1cyxtZW1iZXI9TmFtZU93bmVyQ2hhbmdlZCI7CisKKworc3RhdGljIERCdXNIYW5kbGVyUmVzdWx0IG5vY19maWx0ZXIoREJ1c0Nvbm5lY3Rpb24gKmNvbm4sCisJCQkJICAgIERCdXNNZXNzYWdlICptZXNzYWdlLCB2b2lkICpkYXRhKQoreworCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqcHJpdiA9IGRhdGE7CisKKwlpZiAoZGJ1c19tZXNzYWdlX2dldF90eXBlKG1lc3NhZ2UpICE9IERCVVNfTUVTU0FHRV9UWVBFX1NJR05BTCkKKwkJcmV0dXJuIERCVVNfSEFORExFUl9SRVNVTFRfTk9UX1lFVF9IQU5ETEVEOworCisJaWYgKGRidXNfbWVzc2FnZV9pc19zaWduYWwobWVzc2FnZSwgREJVU19JTlRFUkZBQ0VfREJVUywKKwkJCQkgICAiTmFtZU93bmVyQ2hhbmdlZCIpKSB7CisJCWNvbnN0IGNoYXIgKm5hbWU7CisJCWNvbnN0IGNoYXIgKnByZXZfb3duZXI7CisJCWNvbnN0IGNoYXIgKm5ld19vd25lcjsKKwkJREJ1c0Vycm9yIGRlcnI7CisJCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3M7CisKKwkJZGJ1c19lcnJvcl9pbml0KCZkZXJyKTsKKworCQlpZiAoIWRidXNfbWVzc2FnZV9nZXRfYXJncyhtZXNzYWdlLCAmZGVyciwKKwkJCQkJICAgREJVU19UWVBFX1NUUklORywgJm5hbWUsCisJCQkJCSAgIERCVVNfVFlQRV9TVFJJTkcsICZwcmV2X293bmVyLAorCQkJCQkgICBEQlVTX1RZUEVfU1RSSU5HLCAmbmV3X293bmVyLAorCQkJCQkgICBEQlVTX1RZUEVfSU5WQUxJRCkpIHsKKwkJCS8qIElnbm9yZSB0aGlzIGVycm9yICovCisJCQlkYnVzX2Vycm9yX2ZyZWUoJmRlcnIpOworCQkJcmV0dXJuIERCVVNfSEFORExFUl9SRVNVTFRfTk9UX1lFVF9IQU5ETEVEOworCQl9CisKKwkJZm9yICh3cGFfcyA9IHByaXYtPmdsb2JhbC0+aWZhY2VzOyB3cGFfczsgd3BhX3MgPSB3cGFfcy0+bmV4dCkKKwkJeworCQkJaWYgKHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyICE9IE5VTEwgJiYKKwkJCSAgICBvc19zdHJjbXAobmFtZSwgd3BhX3MtPnByZXFfbm90aWZ5X3BlZXIpID09IDAgJiYKKwkJCSAgICAobmV3X293bmVyID09IE5VTEwgfHwgb3Nfc3RybGVuKG5ld19vd25lcikgPT0gMCkpIHsKKwkJCQkvKiBwcm9iZSByZXF1ZXN0IG93bmVyIGRpc2Nvbm5lY3RlZCAqLworCQkJCW9zX2ZyZWUod3BhX3MtPnByZXFfbm90aWZ5X3BlZXIpOworCQkJCXdwYV9zLT5wcmVxX25vdGlmeV9wZWVyID0gTlVMTDsKKwkJCQl3cGFzX2RidXNfdW5zdWJzY3JpYmVfbm9jKHByaXYpOworCQkJfQorCQl9CisJfQorCisJcmV0dXJuIERCVVNfSEFORExFUl9SRVNVTFRfTk9UX1lFVF9IQU5ETEVEOworfQorCisKK3ZvaWQgd3Bhc19kYnVzX3N1YnNjcmliZV9ub2Moc3RydWN0IHdwYXNfZGJ1c19wcml2ICpwcml2KQoreworCXByaXYtPmRidXNfbm9jX3JlZmNudCsrOworCWlmIChwcml2LT5kYnVzX25vY19yZWZjbnQgPiAxKQorCQlyZXR1cm47CisKKwlpZiAoIWRidXNfY29ubmVjdGlvbl9hZGRfZmlsdGVyKHByaXYtPmNvbiwgbm9jX2ZpbHRlciwgcHJpdiwgTlVMTCkpIHsKKwkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJkYnVzOiBmYWlsZWQgdG8gYWRkIGZpbHRlciIpOworCQlyZXR1cm47CisJfQorCisJZGJ1c19idXNfYWRkX21hdGNoKHByaXYtPmNvbiwgd3Bhc19kYnVzX25vY19maWx0ZXJfc3RyLCBOVUxMKTsKK30KKworCit2b2lkIHdwYXNfZGJ1c191bnN1YnNjcmliZV9ub2Moc3RydWN0IHdwYXNfZGJ1c19wcml2ICpwcml2KQoreworCXByaXYtPmRidXNfbm9jX3JlZmNudC0tOworCWlmIChwcml2LT5kYnVzX25vY19yZWZjbnQgPiAwKQorCQlyZXR1cm47CisKKwlkYnVzX2J1c19yZW1vdmVfbWF0Y2gocHJpdi0+Y29uLCB3cGFzX2RidXNfbm9jX2ZpbHRlcl9zdHIsIE5VTEwpOworCWRidXNfY29ubmVjdGlvbl9yZW1vdmVfZmlsdGVyKHByaXYtPmNvbiwgbm9jX2ZpbHRlciwgcHJpdik7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfQVAgKi8KKwogCiAvKioKICAqIHdwYXNfZGJ1c19zaWduYWxfaW50ZXJmYWNlIC0gU2VuZCBhIGludGVyZmFjZSByZWxhdGVkIGV2ZW50IHNpZ25hbApAQCAtNzQ3LDYgKzgzNCw0MSBAQAogCWRidXNfbWVzc2FnZV91bnJlZihtc2cpOwogfQogCisKK3ZvaWQgd3Bhc19kYnVzX3NpZ25hbF9lYXBfc3RhdHVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJIGNvbnN0IGNoYXIgKnN0YXR1cywgY29uc3QgY2hhciAqcGFyYW1ldGVyKQoreworCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqaWZhY2U7CisJREJ1c01lc3NhZ2UgKm1zZzsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlcjsKKworCWlmYWNlID0gd3BhX3MtPmdsb2JhbC0+ZGJ1czsKKworCS8qIERvIG5vdGhpbmcgaWYgdGhlIGNvbnRyb2wgaW50ZXJmYWNlIGlzIG5vdCB0dXJuZWQgb24gKi8KKwlpZiAoaWZhY2UgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJbXNnID0gZGJ1c19tZXNzYWdlX25ld19zaWduYWwod3BhX3MtPmRidXNfbmV3X3BhdGgsCisJCQkJICAgICAgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsCisJCQkJICAgICAgIkVBUCIpOworCWlmIChtc2cgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJZGJ1c19tZXNzYWdlX2l0ZXJfaW5pdF9hcHBlbmQobXNnLCAmaXRlcik7CisKKwlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYygmaXRlciwgREJVU19UWVBFX1NUUklORywgJnN0YXR1cykKKwkgICAgfHwKKwkgICAgIWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9iYXNpYygmaXRlciwgREJVU19UWVBFX1NUUklORywKKwkJCQkJICAgICZwYXJhbWV0ZXIpKQorCQlnb3RvIG5vbWVtOworCisJZGJ1c19jb25uZWN0aW9uX3NlbmQoaWZhY2UtPmNvbiwgbXNnLCBOVUxMKTsKKworbm9tZW06CisJZGJ1c19tZXNzYWdlX3VucmVmKG1zZyk7Cit9CisKKwogI2lmZGVmIENPTkZJR19QMlAKIAogLyoqCkBAIC05NTMsNyArMTA3NSw3IEBACiAJaWYgKG9zX21lbWNtcChzc2lkLT5zc2lkLCBQMlBfV0lMRENBUkRfU1NJRCwgUDJQX1dJTERDQVJEX1NTSURfTEVOKSkKIAkJcmV0dXJuIC0xOwogCi0JbWVtY3B5KGdyb3VwX25hbWUsIHNzaWQtPnNzaWQgKyBQMlBfV0lMRENBUkRfU1NJRF9MRU4sIDIpOworCW9zX21lbWNweShncm91cF9uYW1lLCBzc2lkLT5zc2lkICsgUDJQX1dJTERDQVJEX1NTSURfTEVOLCAyKTsKIAlncm91cF9uYW1lWzJdID0gJ1wwJzsKIAogCW9zX3NucHJpbnRmKGdyb3VwX29ial9wYXRoLCBXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYLApAQCAtMTYwNywxMCArMTcyOSwxMiBAQAogCQkJCSAgIGVudW0gd3Bhc19kYnVzX3Byb3AgcHJvcGVydHkpCiB7CiAJY2hhciAqcHJvcDsKKwlkYnVzX2Jvb2xfdCBmbHVzaDsKIAogCWlmICh3cGFfcy0+ZGJ1c19uZXdfcGF0aCA9PSBOVUxMKQogCQlyZXR1cm47IC8qIFNraXAgc2lnbmFsIHNpbmNlIEQtQnVzIHNldHVwIGlzIG5vdCB5ZXQgcmVhZHkgKi8KIAorCWZsdXNoID0gRkFMU0U7CiAJc3dpdGNoIChwcm9wZXJ0eSkgewogCWNhc2UgV1BBU19EQlVTX1BST1BfQVBfU0NBTjoKIAkJcHJvcCA9ICJBcFNjYW4iOwpAQCAtMTYzMyw2ICsxNzU3LDEwIEBACiAJY2FzZSBXUEFTX0RCVVNfUFJPUF9DVVJSRU5UX0FVVEhfTU9ERToKIAkJcHJvcCA9ICJDdXJyZW50QXV0aE1vZGUiOwogCQlicmVhazsKKwljYXNlIFdQQVNfREJVU19QUk9QX0RJU0NPTk5FQ1RfUkVBU09OOgorCQlwcm9wID0gIkRpc2Nvbm5lY3RSZWFzb24iOworCQlmbHVzaCA9IFRSVUU7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiZGJ1czogJXM6IFVua25vd24gUHJvcGVydHkgdmFsdWUgJWQiLAogCQkJICAgX19mdW5jX18sIHByb3BlcnR5KTsKQEAgLTE2NDIsNiArMTc3MCwxMCBAQAogCXdwYV9kYnVzX21hcmtfcHJvcGVydHlfY2hhbmdlZCh3cGFfcy0+Z2xvYmFsLT5kYnVzLAogCQkJCSAgICAgICB3cGFfcy0+ZGJ1c19uZXdfcGF0aCwKIAkJCQkgICAgICAgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsIHByb3ApOworCWlmIChmbHVzaCkgeworCQl3cGFfZGJ1c19mbHVzaF9vYmplY3RfY2hhbmdlZF9wcm9wZXJ0aWVzKAorCQkJd3BhX3MtPmdsb2JhbC0+ZGJ1cy0+Y29uLCB3cGFfcy0+ZGJ1c19uZXdfcGF0aCk7CisJfQogfQogCiAKQEAgLTE3OTIsNiArMTkyNCwxNSBAQAogCQkgIEVORF9BUkdTCiAJICB9CiAJfSwKKyNpZmRlZiBDT05GSUdfQVVUT1NDQU4KKwl7ICJBdXRvU2NhbiIsIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLAorCSAgKFdQQURCdXNNZXRob2RIYW5kbGVyKSAmd3Bhc19kYnVzX2hhbmRsZXJfYXV0b3NjYW4sCisJICB7CisJCSAgeyAiYXJnIiwgInMiLCBBUkdfSU4gfSwKKwkJICBFTkRfQVJHUworCSAgfQorCX0sCisjZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOICovCiAJeyBOVUxMLCBOVUxMLCBOVUxMLCB7IEVORF9BUkdTIH0gfQogfTsKIApAQCAtMjAyOSwxMSArMjE3MCwxMSBAQAogCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqY3RybF9pZmFjZTsKIAljaGFyIG5ldF9vYmpfcGF0aFtXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYXTsKIAlpbnQgcmV0OworI2lmZGVmIENPTkZJR19QMlAKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CiAKIAlzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgbmlkKTsKIAotI2lmZGVmIENPTkZJR19QMlAKIAkvKiBJZiBpdCBpcyBhIHBlcnNpc3RlbnQgZ3JvdXAgdW5yZWdpc3RlciBpdCBhcyBzdWNoICovCiAJaWYgKHNzaWQgJiYgbmV0d29ya19pc19wZXJzaXN0ZW50X2dyb3VwKHNzaWQpKQogCQlyZXR1cm4gd3Bhc19kYnVzX3VucmVnaXN0ZXJfcGVyc2lzdGVudF9ncm91cCh3cGFfcywgbmlkKTsKQEAgLTI0ODcsNiArMjYyOCwyMCBAQAogCQkgIEVORF9BUkdTCiAJICB9CiAJfSwKKyNpZmRlZiBDT05GSUdfQVAKKwl7ICJTdWJzY3JpYmVQcm9iZVJlcSIsIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLAorCSAgKFdQQURCdXNNZXRob2RIYW5kbGVyKSB3cGFzX2RidXNfaGFuZGxlcl9zdWJzY3JpYmVfcHJlcSwKKwkgIHsKKwkJICBFTkRfQVJHUworCSAgfQorCX0sCisJeyAiVW5zdWJzY3JpYmVQcm9iZVJlcSIsIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLAorCSAgKFdQQURCdXNNZXRob2RIYW5kbGVyKSB3cGFzX2RidXNfaGFuZGxlcl91bnN1YnNjcmliZV9wcmVxLAorCSAgeworCQkgIEVORF9BUkdTCisJICB9CisJfSwKKyNlbmRpZiAvKiBDT05GSUdfQVAgKi8KIAl7IE5VTEwsIE5VTEwsIE5VTEwsIHsgRU5EX0FSR1MgfSB9CiB9OwogCkBAIC0yNTU5LDYgKzI3MTQsMTAgQEAKIAkgIHdwYXNfZGJ1c19nZXR0ZXJfZmFzdF9yZWF1dGgsCiAJICB3cGFzX2RidXNfc2V0dGVyX2Zhc3RfcmVhdXRoCiAJfSwKKwl7ICJTY2FuSW50ZXJ2YWwiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX0lOVEVSRkFDRSwgImkiLAorCSAgd3Bhc19kYnVzX2dldHRlcl9zY2FuX2ludGVydmFsLAorCSAgd3Bhc19kYnVzX3NldHRlcl9zY2FuX2ludGVydmFsCisJfSwKICNpZmRlZiBDT05GSUdfV1BTCiAJeyAiUHJvY2Vzc0NyZWRlbnRpYWxzIiwgV1BBU19EQlVTX05FV19JRkFDRV9XUFMsICJiIiwKIAkgIHdwYXNfZGJ1c19nZXR0ZXJfcHJvY2Vzc19jcmVkZW50aWFscywKQEAgLTI1NjYsOSArMjcyNSw5IEBACiAJfSwKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAjaWZkZWYgQ09ORklHX1AyUAotCXsgIlAyUERldmljZVByb3BlcnRpZXMiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUERFVklDRSwgImF7c3Z9IiwKLQkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2RldmljZV9wcm9wZXJ0aWVzLAotCSAgd3Bhc19kYnVzX3NldHRlcl9wMnBfZGV2aWNlX3Byb3BlcnRpZXMKKwl7ICJQMlBEZXZpY2VDb25maWciLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUERFVklDRSwgImF7c3Z9IiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2RldmljZV9jb25maWcsCisJICB3cGFzX2RidXNfc2V0dGVyX3AycF9kZXZpY2VfY29uZmlnCiAJfSwKIAl7ICJQZWVycyIsIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQREVWSUNFLCAiYW8iLAogCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcnMsCkBAIC0yNTkxLDYgKzI3NTAsMTAgQEAKIAkgIE5VTEwKIAl9LAogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKwl7ICJEaXNjb25uZWN0UmVhc29uIiwgV1BBU19EQlVTX05FV19JRkFDRV9JTlRFUkZBQ0UsICJpIiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfZGlzY29ubmVjdF9yZWFzb24sCisJICBOVUxMCisJfSwKIAl7IE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwgfQogfTsKIApAQCAtMjgwOSwxMiArMjk3MiwyNyBAQAogCSAgfQogCX0sCiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLworI2lmZGVmIENPTkZJR19BUAorCXsgIlByb2JlUmVxdWVzdCIsIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLAorCSAgeworCQkgIHsgImFyZ3MiLCAiYXtzdn0iLCBBUkdfT1VUIH0sCisJCSAgRU5EX0FSR1MKKwkgIH0KKwl9LAorI2VuZGlmIC8qIENPTkZJR19BUCAqLwogCXsgIkNlcnRpZmljYXRpb24iLCBXUEFTX0RCVVNfTkVXX0lGQUNFX0lOVEVSRkFDRSwKIAkgIHsKIAkJICB7ICJjZXJ0aWZpY2F0aW9uIiwgImF7c3Z9IiwgQVJHX09VVCB9LAogCQkgIEVORF9BUkdTCiAJICB9CiAJfSwKKwl7ICJFQVAiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX0lOVEVSRkFDRSwKKwkgIHsKKwkJICB7ICJzdGF0dXMiLCAicyIsIEFSR19PVVQgfSwKKwkJICB7ICJwYXJhbWV0ZXIiLCAicyIsIEFSR19PVVQgfSwKKwkJICBFTkRfQVJHUworCSAgfQorCX0sCiAJeyBOVUxMLCBOVUxMLCB7IEVORF9BUkdTIH0gfQogfTsKIApAQCAtMjg4Miw2ICszMDYwLDE1IEBACiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgImRidXM6IFVucmVnaXN0ZXIgaW50ZXJmYWNlIG9iamVjdCAnJXMnIiwKIAkJICAgd3BhX3MtPmRidXNfbmV3X3BhdGgpOworCisjaWZkZWYgQ09ORklHX0FQCisJaWYgKHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyKSB7CisJCXdwYXNfZGJ1c191bnN1YnNjcmliZV9ub2MoY3RybF9pZmFjZSk7CisJCW9zX2ZyZWUod3BhX3MtPnByZXFfbm90aWZ5X3BlZXIpOworCQl3cGFfcy0+cHJlcV9ub3RpZnlfcGVlciA9IE5VTEw7CisJfQorI2VuZGlmIC8qIENPTkZJR19BUCAqLworCiAJaWYgKHdwYV9kYnVzX3VucmVnaXN0ZXJfb2JqZWN0X3Blcl9pZmFjZShjdHJsX2lmYWNlLAogCQkJCQkJIHdwYV9zLT5kYnVzX25ld19wYXRoKSkKIAkJcmV0dXJuIC0xOwpAQCAtMjkyMSwxMSArMzEwOCwxMSBAQAogCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcl9ncm91cF9jYXBhYmlsaXR5LAogCSAgTlVMTAogCX0sCi0JeyAiU2Vjb25kYXJ5RGV2aWNlVHlwZXMiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9QRUVSLCAiYXkiLAorCXsgIlNlY29uZGFyeURldmljZVR5cGVzIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBfUEVFUiwgImFheSIsCiAJICB3cGFzX2RidXNfZ2V0dGVyX3AycF9wZWVyX3NlY29uZGFyeV9kZXZpY2VfdHlwZXMsCiAJICBOVUxMCiAJfSwKLQl7ICJWZW5kb3JFeHRlbnNpb24iLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9QRUVSLCAiYXMiLAorCXsgIlZlbmRvckV4dGVuc2lvbiIsIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQX1BFRVIsICJhYXkiLAogCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcl92ZW5kb3JfZXh0ZW5zaW9uLAogCSAgTlVMTAogCX0sCkBAIC0zMTI2LDEwICszMzEzLDM3IEBACiAJICB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9tZW1iZXJzLAogCSAgTlVMTAogCX0sCi0JeyAiUHJvcGVydGllcyIsCi0JICBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUCwgImF7c3Z9IiwKLQkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX3Byb3BlcnRpZXMsCi0JICB3cGFzX2RidXNfc2V0dGVyX3AycF9ncm91cF9wcm9wZXJ0aWVzCisJeyAiR3JvdXAiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUCwgIm8iLAorCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXAsCisJICBOVUxMCisJfSwKKwl7ICJSb2xlIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBfR1JPVVAsICJzIiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX3JvbGUsCisJICBOVUxMCisJfSwKKwl7ICJTU0lEIiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBfR1JPVVAsICJheSIsCisJICB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9zc2lkLAorCSAgTlVMTAorCX0sCisJeyAiQlNTSUQiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUCwgImF5IiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX2Jzc2lkLAorCSAgTlVMTAorCX0sCisJeyAiRnJlcXVlbmN5IiwgV1BBU19EQlVTX05FV19JRkFDRV9QMlBfR1JPVVAsICJxIiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX2ZyZXF1ZW5jeSwKKwkgIE5VTEwKKwl9LAorCXsgIlBhc3NwaHJhc2UiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUCwgInMiLAorCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXBfcGFzc3BocmFzZSwKKwkgIE5VTEwKKwl9LAorCXsgIlBTSyIsIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQX0dST1VQLCAiYXkiLAorCSAgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXBfcHNrLAorCSAgTlVMTAorCX0sCisJeyAiV1BTVmVuZG9yRXh0ZW5zaW9ucyIsIFdQQVNfREJVU19ORVdfSUZBQ0VfUDJQX0dST1VQLCAiYWF5IiwKKwkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX3ZlbmRvcl9leHQsCisJICB3cGFzX2RidXNfc2V0dGVyX3AycF9ncm91cF92ZW5kb3JfZXh0CiAJfSwKIAl7IE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwgfQogfTsKQEAgLTMyNTEsMTAgKzM0NjUsNiBAQAogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHdwYV9kYnVzX3Byb3BlcnR5X2Rlc2MKIHdwYXNfZGJ1c19wMnBfZ3JvdXBtZW1iZXJfcHJvcGVydGllc1tdID0gewotCXsgIlByb3BlcnRpZXMiLCBXUEFTX0RCVVNfTkVXX0lGQUNFX1AyUF9HUk9VUE1FTUJFUiwgImF7c3Z9IiwKLQkgIHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX3Byb3BlcnRpZXMsCi0JICBOVUxMCi0JfSwKIAl7IE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwgfQogfTsKIApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ldy5oIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ldy5oCmluZGV4IDkzY2U3MjIuLjQ0Y2RlNDIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXcuaAorKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3LmgKQEAgLTMsMTQgKzMsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA2LCBEYW4gV2lsbGlhbXMgPGRjYndAcmVkaGF0LmNvbT4gYW5kIFJlZCBIYXQsIEluYy4KICAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEwLCBXaXRvbGQgU293YSA8d2l0b2xkLnNvd2FAZ21haWwuY29tPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpZm5kZWYgQ1RSTF9JRkFDRV9EQlVTX05FV19ICkBAIC0zNCw2ICsyOCw3IEBACiAJV1BBU19EQlVTX1BST1BfQ1VSUkVOVF9ORVRXT1JLLAogCVdQQVNfREJVU19QUk9QX0NVUlJFTlRfQVVUSF9NT0RFLAogCVdQQVNfREJVU19QUk9QX0JTU1MsCisJV1BBU19EQlVTX1BST1BfRElTQ09OTkVDVF9SRUFTT04sCiB9OwogCiBlbnVtIHdwYXNfZGJ1c19ic3NfcHJvcCB7CkBAIC0xMTUsNiArMTEwLDE3IEBACiAjZGVmaW5lIFdQQVNfREJVU19FUlJPUl9CTE9CX1VOS05PV04gXAogCVdQQVNfREJVU19ORVdfSU5URVJGQUNFICIuQmxvYlVua25vd24iCiAKKyNkZWZpbmUgV1BBU19EQlVTX0VSUk9SX1NVQlNDUklQVElPTl9JTl9VU0UgXAorCVdQQVNfREJVU19ORVdfSU5URVJGQUNFICIuU3Vic2NyaXB0aW9uSW5Vc2UiCisjZGVmaW5lIFdQQVNfREJVU19FUlJPUl9OT19TVUJTQ1JJUFRJT04gXAorCVdQQVNfREJVU19ORVdfSU5URVJGQUNFICIuTm9TdWJzY3JpcHRpb24iCisjZGVmaW5lIFdQQVNfREJVU19FUlJPUl9TVUJTQ1JJUFRJT05fRVBFUk0gXAorCVdQQVNfREJVU19ORVdfSU5URVJGQUNFICIuU3Vic2NyaXB0aW9uTm90WW91IgorCisKK3ZvaWQgd3Bhc19kYnVzX3N1YnNjcmliZV9ub2Moc3RydWN0IHdwYXNfZGJ1c19wcml2ICpwcml2KTsKK3ZvaWQgd3Bhc19kYnVzX3Vuc3Vic2NyaWJlX25vYyhzdHJ1Y3Qgd3Bhc19kYnVzX3ByaXYgKnByaXYpOworCiAKICNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9EQlVTX05FVwogCkBAIC0yMTAsNiArMjE2LDExIEBACiAJCQkJICAgIGludCBkZXB0aCwgY29uc3QgY2hhciAqc3ViamVjdCwKIAkJCQkgICAgY29uc3QgY2hhciAqY2VydF9oYXNoLAogCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpjZXJ0KTsKK3ZvaWQgd3Bhc19kYnVzX3NpZ25hbF9wcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICBjb25zdCB1OCAqYWRkciwgY29uc3QgdTggKmRzdCwgY29uc3QgdTggKmJzc2lkLAorCQkJICAgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuLCB1MzIgc3NpX3NpZ25hbCk7Cit2b2lkIHdwYXNfZGJ1c19zaWduYWxfZWFwX3N0YXR1cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSBjb25zdCBjaGFyICpzdGF0dXMsIGNvbnN0IGNoYXIgKnBhcmFtZXRlcik7CiAKICNlbHNlIC8qIENPTkZJR19DVFJMX0lGQUNFX0RCVVNfTkVXICovCiAKQEAgLTQ2Nyw2ICs0NzgsMjAgQEAKIHsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIHdwYXNfZGJ1c19zaWduYWxfcHJlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkc3QsCisJCQkJCSBjb25zdCB1OCAqYnNzaWQsCisJCQkJCSBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkJCSB1MzIgc3NpX3NpZ25hbCkKK3sKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdwYXNfZGJ1c19zaWduYWxfZWFwX3N0YXR1cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgICAgY29uc3QgY2hhciAqc3RhdHVzLAorCQkJCQkgICAgICAgY29uc3QgY2hhciAqcGFyYW1ldGVyKQoreworfQorCiAjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfREJVU19ORVcgKi8KIAogI2VuZGlmIC8qIENUUkxfSUZBQ0VfREJVU19IX05FVyAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVycy5jIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVycy5jCmluZGV4IGRhNjdiZWEuLjgxNDVhNzAgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnMuYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmMKQEAgLTQsMTQgKzQsOCBAQAogICogQ29weXJpZ2h0IChjKSAyMDA5LTIwMTAsIFdpdG9sZCBTb3dhIDx3aXRvbGQuc293YUBnbWFpbC5jb20+CiAgKiBDb3B5cmlnaHQgKGMpIDIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC0yOCwxMCArMjIsMTIgQEAKICNpbmNsdWRlICIuLi9ic3MuaCIKICNpbmNsdWRlICIuLi9zY2FuLmgiCiAjaW5jbHVkZSAiLi4vY3RybF9pZmFjZS5oIgorI2luY2x1ZGUgIi4uL2F1dG9zY2FuLmgiCiAjaW5jbHVkZSAiZGJ1c19uZXdfaGVscGVycy5oIgogI2luY2x1ZGUgImRidXNfbmV3LmgiCiAjaW5jbHVkZSAiZGJ1c19uZXdfaGFuZGxlcnMuaCIKICNpbmNsdWRlICJkYnVzX2RpY3RfaGVscGVycy5oIgorI2luY2x1ZGUgImRidXNfY29tbW9uX2kuaCIKIAogZXh0ZXJuIGludCB3cGFfZGVidWdfbGV2ZWw7CiBleHRlcm4gaW50IHdwYV9kZWJ1Z19zaG93X2tleXM7CkBAIC0yNTMsNyArMjQ5LDcgQEAKIAogCQlpZiAoKG9zX3N0cmNtcChlbnRyeS5rZXksICJwc2siKSA9PSAwICYmCiAJCSAgICAgdmFsdWVbMF0gPT0gJyInICYmIHNzaWQtPnNzaWRfbGVuKSB8fAotCQkgICAgKHN0cmNtcChlbnRyeS5rZXksICJzc2lkIikgPT0gMCAmJiBzc2lkLT5wYXNzcGhyYXNlKSkKKwkJICAgIChvc19zdHJjbXAoZW50cnkua2V5LCAic3NpZCIpID09IDAgJiYgc3NpZC0+cGFzc3BocmFzZSkpCiAJCQl3cGFfY29uZmlnX3VwZGF0ZV9wc2soc3NpZCk7CiAJCWVsc2UgaWYgKG9zX3N0cmNtcChlbnRyeS5rZXksICJwcmlvcml0eSIpID09IDApCiAJCQl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOwpAQCAtNDQ4LDYgKzQ0NCw3NiBAQAogCiAKIC8qKgorICogd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIgLSBHZXQgYXJyYXkgYXJyYXkgdHlwZSBwcm9wZXJ0eQorICogQGl0ZXI6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlIGl0ZXJhdG9yCisgKiBAdHlwZTogREJ1cyB0eXBlIG9mIHByb3BlcnR5IGFycmF5IGVsZW1lbnRzIChtdXN0IGJlIGJhc2ljIHR5cGUpCisgKiBAYXJyYXk6IHBvaW50ZXIgdG8gYXJyYXkgb2YgZWxlbWVudHMgdG8gcHV0IGludG8gcmVzcG9uc2UgbWVzc2FnZQorICogQGFycmF5X2xlbjogbGVuZ3RoIG9mIGFib3ZlIGFycmF5CisgKiBAZXJyb3I6IGEgcG9pbnRlciB0byBhbiBlcnJvciB0byBmaWxsIG9uIGZhaWx1cmUKKyAqIFJldHVybnM6IFRSVUUgaWYgdGhlIHJlcXVlc3Qgc3VjY2VlZGVkLCBGQUxTRSBpZiBpdCBmYWlsZWQKKyAqCisgKiBHZW5lcmljIGdldHRlciBmb3IgYXJyYXkgdHlwZSBwcm9wZXJ0aWVzLiBBcnJheSBlbGVtZW50cyB0eXBlIGlzCisgKiByZXF1aXJlZCB0byBiZSBiYXNpYy4KKyAqLworZGJ1c19ib29sX3Qgd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkJCSBjb25zdCBpbnQgdHlwZSwKKwkJCQkJCQkgc3RydWN0IHdwYWJ1ZiAqKmFycmF5LAorCQkJCQkJCSBzaXplX3QgYXJyYXlfbGVuLAorCQkJCQkJCSBEQnVzRXJyb3IgKmVycm9yKQoreworCURCdXNNZXNzYWdlSXRlciB2YXJpYW50X2l0ZXIsIGFycmF5X2l0ZXI7CisJY2hhciB0eXBlX3N0cltdID0gImFhPyI7CisJY2hhciBpbm5lcl90eXBlX3N0cltdID0gImE/IjsKKwljb25zdCBjaGFyICpzdWJfdHlwZV9zdHI7CisJc2l6ZV90IGk7CisKKwlpZiAoIWRidXNfdHlwZV9pc19iYXNpYyh0eXBlKSkgeworCQlkYnVzX3NldF9lcnJvcihlcnJvciwgREJVU19FUlJPUl9GQUlMRUQsCisJCQkgICAgICAgIiVzOiBnaXZlbiB0eXBlIGlzIG5vdCBiYXNpYyIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCXN1Yl90eXBlX3N0ciA9IHdwYV9kYnVzX3R5cGVfYXNfc3RyaW5nKHR5cGUpOworCXR5cGVfc3RyWzJdID0gc3ViX3R5cGVfc3RyWzBdOworCWlubmVyX3R5cGVfc3RyWzFdID0gc3ViX3R5cGVfc3RyWzBdOworCisJaWYgKCFkYnVzX21lc3NhZ2VfaXRlcl9vcGVuX2NvbnRhaW5lcihpdGVyLCBEQlVTX1RZUEVfVkFSSUFOVCwKKwkJCQkJICAgICAgdHlwZV9zdHIsICZ2YXJpYW50X2l0ZXIpKSB7CisJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCSAgICAgICAiJXM6IGZhaWxlZCB0byBjb25zdHJ1Y3QgbWVzc2FnZSAxIiwgX19mdW5jX18pOworCQlyZXR1cm4gRkFMU0U7CisJfQorCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIoJnZhcmlhbnRfaXRlciwgREJVU19UWVBFX0FSUkFZLAorCQkJCQkgICAgICBpbm5lcl90eXBlX3N0ciwgJmFycmF5X2l0ZXIpKSB7CisJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCSAgICAgICAiJXM6IGZhaWxlZCB0byBjb25zdHJ1Y3QgbWVzc2FnZSAyIiwgX19mdW5jX18pOworCQlyZXR1cm4gRkFMU0U7CisJfQorCisJZm9yIChpID0gMDsgaSA8IGFycmF5X2xlbjsgaSsrKSB7CisJCXdwYV9kYnVzX2RpY3RfYmluX2FycmF5X2FkZF9lbGVtZW50KCZhcnJheV9pdGVyLAorCQkJCQkJICAgIHdwYWJ1Zl9oZWFkKGFycmF5W2ldKSwKKwkJCQkJCSAgICB3cGFidWZfbGVuKGFycmF5W2ldKSk7CisKKwl9CisKKwlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcigmdmFyaWFudF9pdGVyLCAmYXJyYXlfaXRlcikpIHsKKwkJZGJ1c19zZXRfZXJyb3IoZXJyb3IsIERCVVNfRVJST1JfRkFJTEVELAorCQkJICAgICAgICIlczogZmFpbGVkIHRvIGNsb3NlIG1lc3NhZ2UgMiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyKGl0ZXIsICZ2YXJpYW50X2l0ZXIpKSB7CisJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCSAgICAgICAiJXM6IGZhaWxlZCB0byBjbG9zZSBtZXNzYWdlIDEiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBGQUxTRTsKKwl9CisKKwlyZXR1cm4gVFJVRTsKK30KKworCisvKioKICAqIHdwYXNfZGJ1c19oYW5kbGVyX2NyZWF0ZV9pbnRlcmZhY2UgLSBSZXF1ZXN0IHJlZ2lzdHJhdGlvbiBvZiBhIG5ldHdvcmsgaWZhY2UKICAqIEBtZXNzYWdlOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZQogICogQGdsb2JhbDogJXdwYV9zdXBwbGljYW50IGdsb2JhbCBkYXRhIHN0cnVjdHVyZQpAQCAtNDc3LDI1ICs1NDMsMjUgQEAKIAl3aGlsZSAod3BhX2RidXNfZGljdF9oYXNfZGljdF9lbnRyeSgmaXRlcl9kaWN0KSkgewogCQlpZiAoIXdwYV9kYnVzX2RpY3RfZ2V0X2VudHJ5KCZpdGVyX2RpY3QsICZlbnRyeSkpCiAJCQlnb3RvIGVycm9yOwotCQlpZiAoIXN0cmNtcChlbnRyeS5rZXksICJEcml2ZXIiKSAmJgorCQlpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJEcml2ZXIiKSAmJgogCQkgICAgKGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX1NUUklORykpIHsKIAkJCWRyaXZlciA9IG9zX3N0cmR1cChlbnRyeS5zdHJfdmFsdWUpOwogCQkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCQkJaWYgKGRyaXZlciA9PSBOVUxMKQogCQkJCWdvdG8gZXJyb3I7Ci0JCX0gZWxzZSBpZiAoIXN0cmNtcChlbnRyeS5rZXksICJJZm5hbWUiKSAmJgorCQl9IGVsc2UgaWYgKCFvc19zdHJjbXAoZW50cnkua2V5LCAiSWZuYW1lIikgJiYKIAkJCSAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CiAJCQlpZm5hbWUgPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIAkJCWlmIChpZm5hbWUgPT0gTlVMTCkKIAkJCQlnb3RvIGVycm9yOwotCQl9IGVsc2UgaWYgKCFzdHJjbXAoZW50cnkua2V5LCAiQ29uZmlnRmlsZSIpICYmCisJCX0gZWxzZSBpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJDb25maWdGaWxlIikgJiYKIAkJCSAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CiAJCQljb25mbmFtZSA9IG9zX3N0cmR1cChlbnRyeS5zdHJfdmFsdWUpOwogCQkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCQkJaWYgKGNvbmZuYW1lID09IE5VTEwpCiAJCQkJZ290byBlcnJvcjsKLQkJfSBlbHNlIGlmICghc3RyY21wKGVudHJ5LmtleSwgIkJyaWRnZUlmbmFtZSIpICYmCisJCX0gZWxzZSBpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJCcmlkZ2VJZm5hbWUiKSAmJgogCQkJICAgKGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX1NUUklORykpIHsKIAkJCWJyaWRnZV9pZm5hbWUgPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKIAkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKQEAgLTEyMTYsNiArMTI4Miw5IEBACiAJCQkvKiBBZGQgd2lsZGNhcmQgc3NpZCAqLwogCQkJcGFyYW1zLm51bV9zc2lkcysrOwogCQl9CisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOCisJCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7CisjZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOICovCiAJCXdwYV9zdXBwbGljYW50X3RyaWdnZXJfc2Nhbih3cGFfcywgJnBhcmFtcyk7CiAJfSBlbHNlIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJ3cGFzX2RidXNfaGFuZGxlcl9zY2FuW2RidXNdOiAiCkBAIC0xNzM2LDYgKzE4MDUsNTQgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOCisvKioKKyAqIHdwYXNfZGJ1c19oYW5kbGVyX2F1dG9zY2FuIC0gU2V0IGF1dG9zY2FuIHBhcmFtZXRlcnMgZm9yIHRoZSBpbnRlcmZhY2UKKyAqIEBtZXNzYWdlOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZQorICogQHdwYV9zOiB3cGFfc3VwcGxpY2FudCBzdHJ1Y3R1cmUgZm9yIGEgbmV0d29yayBpbnRlcmZhY2UKKyAqIFJldHVybnM6IE5VTEwKKyAqCisgKiBIYW5kbGVyIGZ1bmN0aW9uIGZvciAiQXV0b1NjYW4iIG1ldGhvZCBjYWxsIG9mIG5ldHdvcmsgaW50ZXJmYWNlLgorICovCitEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19oYW5kbGVyX2F1dG9zY2FuKERCdXNNZXNzYWdlICptZXNzYWdlLAorCQkJCQkgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlEQnVzTWVzc2FnZSAqcmVwbHkgPSBOVUxMOworCWVudW0gd3BhX3N0YXRlcyBzdGF0ZSA9IHdwYV9zLT53cGFfc3RhdGU7CisJY2hhciAqYXJnOworCisJZGJ1c19tZXNzYWdlX2dldF9hcmdzKG1lc3NhZ2UsIE5VTEwsIERCVVNfVFlQRV9TVFJJTkcsICZhcmcsCisJCQkgICAgICBEQlVTX1RZUEVfSU5WQUxJRCk7CisKKwlpZiAoYXJnICE9IE5VTEwgJiYgb3Nfc3RybGVuKGFyZykgPiAwKSB7CisJCWNoYXIgKnRtcDsKKwkJdG1wID0gb3Nfc3RyZHVwKGFyZyk7CisJCWlmICh0bXAgPT0gTlVMTCkgeworCQkJcmVwbHkgPSBkYnVzX21lc3NhZ2VfbmV3X2Vycm9yKG1lc3NhZ2UsCisJCQkJCQkgICAgICAgREJVU19FUlJPUl9OT19NRU1PUlksCisJCQkJCQkgICAgICAgTlVMTCk7CisJCX0gZWxzZSB7CisJCQlvc19mcmVlKHdwYV9zLT5jb25mLT5hdXRvc2Nhbik7CisJCQl3cGFfcy0+Y29uZi0+YXV0b3NjYW4gPSB0bXA7CisJCQlpZiAoc3RhdGUgPT0gV1BBX0RJU0NPTk5FQ1RFRCB8fCBzdGF0ZSA9PSBXUEFfSU5BQ1RJVkUpCisJCQkJYXV0b3NjYW5faW5pdCh3cGFfcywgMSk7CisJCQllbHNlIGlmIChzdGF0ZSA9PSBXUEFfU0NBTk5JTkcpCisJCQkJd3BhX3N1cHBsaWNhbnRfcmVpbml0X2F1dG9zY2FuKHdwYV9zKTsKKwkJfQorCX0gZWxzZSBpZiAoYXJnICE9IE5VTEwgJiYgb3Nfc3RybGVuKGFyZykgPT0gMCkgeworCQlvc19mcmVlKHdwYV9zLT5jb25mLT5hdXRvc2Nhbik7CisJCXdwYV9zLT5jb25mLT5hdXRvc2NhbiA9IE5VTEw7CisJCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7CisJfSBlbHNlCisJCXJlcGx5ID0gZGJ1c19tZXNzYWdlX25ld19lcnJvcihtZXNzYWdlLAorCQkJCQkgICAgICAgREJVU19FUlJPUl9JTlZBTElEX0FSR1MsCisJCQkJCSAgICAgICBOVUxMKTsKKworCXJldHVybiByZXBseTsKK30KKyNlbmRpZiAvKiBDT05GSUdfQVVUT1NDQU4gKi8KKworCiAvKioKICAqIHdwYXNfZGJ1c19nZXR0ZXJfY2FwYWJpbGl0aWVzIC0gUmV0dXJuIGludGVyZmFjZSBjYXBhYmlsaXRpZXMKICAqIEBpdGVyOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZSBpdGVyCkBAIC0yMjI5LDYgKzIzNDYsMjcgQEAKIAogCiAvKioKKyAqIHdwYXNfZGJ1c19nZXR0ZXJfZGlzY29ubmVjdF9yZWFzb24gLSBHZXQgbW9zdCByZWNlbnQgcmVhc29uIGZvciBkaXNjb25uZWN0CisgKiBAaXRlcjogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgaXRlcgorICogQGVycm9yOiBMb2NhdGlvbiB0byBzdG9yZSBlcnJvciBvbiBmYWlsdXJlCisgKiBAdXNlcl9kYXRhOiBGdW5jdGlvbiBzcGVjaWZpYyBkYXRhCisgKiBSZXR1cm5zOiBUUlVFIG9uIHN1Y2Nlc3MsIEZBTFNFIG9uIGZhaWx1cmUKKyAqCisgKiBHZXR0ZXIgZm9yICJEaXNjb25uZWN0UmVhc29uIiBwcm9wZXJ0eS4gIFRoZSByZWFzb24gaXMgbmVnYXRpdmUgaWYgaXQgaXMKKyAqIGxvY2FsbHkgZ2VuZXJhdGVkLgorICovCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX2Rpc2Nvbm5lY3RfcmVhc29uKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJICAgICAgIERCdXNFcnJvciAqZXJyb3IsCisJCQkJCSAgICAgICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHVzZXJfZGF0YTsKKwlkYnVzX2ludDMyX3QgcmVhc29uID0gd3BhX3MtPmRpc2Nvbm5lY3RfcmVhc29uOworCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX3Byb3BlcnR5X2dldHRlcihpdGVyLCBEQlVTX1RZUEVfSU5UMzIsCisJCQkJCQkmcmVhc29uLCBlcnJvcik7Cit9CisKKworLyoqCiAgKiB3cGFzX2RidXNfZ2V0dGVyX2Jzc19leHBpcmVfYWdlIC0gR2V0IEJTUyBlbnRyeSBleHBpcmF0aW9uIGFnZQogICogQGl0ZXI6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlIGl0ZXIKICAqIEBlcnJvcjogTG9jYXRpb24gdG8gc3RvcmUgZXJyb3Igb24gZmFpbHVyZQpAQCAtMjM5Miw2ICsyNTMwLDU2IEBACiAKIAogLyoqCisgKiB3cGFzX2RidXNfZ2V0dGVyX3NjYW5faW50ZXJ2YWwgLSBHZXQgc2NhbiBpbnRlcnZhbAorICogQGl0ZXI6IFBvaW50ZXIgdG8gaW5jb21pbmcgZGJ1cyBtZXNzYWdlIGl0ZXIKKyAqIEBlcnJvcjogTG9jYXRpb24gdG8gc3RvcmUgZXJyb3Igb24gZmFpbHVyZQorICogQHVzZXJfZGF0YTogRnVuY3Rpb24gc3BlY2lmaWMgZGF0YQorICogUmV0dXJuczogVFJVRSBvbiBzdWNjZXNzLCBGQUxTRSBvbiBmYWlsdXJlCisgKgorICogR2V0dGVyIGZ1bmN0aW9uIGZvciAiU2NhbkludGVydmFsIiBwcm9wZXJ0eS4KKyAqLworZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9zY2FuX2ludGVydmFsKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSB1c2VyX2RhdGE7CisJZGJ1c19pbnQzMl90IHNjYW5faW50ZXJ2YWwgPSB3cGFfcy0+c2Nhbl9pbnRlcnZhbDsKKworCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX3Byb3BlcnR5X2dldHRlcihpdGVyLCBEQlVTX1RZUEVfSU5UMzIsCisJCQkJCQkmc2Nhbl9pbnRlcnZhbCwgZXJyb3IpOworfQorCisKKy8qKgorICogd3Bhc19kYnVzX3NldHRlcl9zY2FuX2ludGVydmFsIC0gQ29udHJvbCBzY2FuIGludGVydmFsCisgKiBAaXRlcjogUG9pbnRlciB0byBpbmNvbWluZyBkYnVzIG1lc3NhZ2UgaXRlcgorICogQGVycm9yOiBMb2NhdGlvbiB0byBzdG9yZSBlcnJvciBvbiBmYWlsdXJlCisgKiBAdXNlcl9kYXRhOiBGdW5jdGlvbiBzcGVjaWZpYyBkYXRhCisgKiBSZXR1cm5zOiBUUlVFIG9uIHN1Y2Nlc3MsIEZBTFNFIG9uIGZhaWx1cmUKKyAqCisgKiBTZXR0ZXIgZnVuY3Rpb24gZm9yICJTY2FuSW50ZXJ2YWwiIHByb3BlcnR5LgorICovCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfc2V0dGVyX3NjYW5faW50ZXJ2YWwoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkgICBEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkgICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHVzZXJfZGF0YTsKKwlkYnVzX2ludDMyX3Qgc2Nhbl9pbnRlcnZhbDsKKworCWlmICghd3Bhc19kYnVzX3NpbXBsZV9wcm9wZXJ0eV9zZXR0ZXIoaXRlciwgZXJyb3IsIERCVVNfVFlQRV9JTlQzMiwKKwkJCQkJICAgICAgJnNjYW5faW50ZXJ2YWwpKQorCQlyZXR1cm4gRkFMU0U7CisKKwlpZiAod3BhX3N1cHBsaWNhbnRfc2V0X3NjYW5faW50ZXJ2YWwod3BhX3MsIHNjYW5faW50ZXJ2YWwpKSB7CisJCWRidXNfc2V0X2Vycm9yX2NvbnN0KGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCQkgICAgICJzY2FuX2ludGVydmFsIG11c3QgYmUgPj0gMCIpOworCQlyZXR1cm4gRkFMU0U7CisJfQorCXJldHVybiBUUlVFOworfQorCisKKy8qKgogICogd3Bhc19kYnVzX2dldHRlcl9pZm5hbWUgLSBHZXQgaW50ZXJmYWNlIG5hbWUKICAqIEBpdGVyOiBQb2ludGVyIHRvIGluY29taW5nIGRidXMgbWVzc2FnZSBpdGVyCiAgKiBAZXJyb3I6IExvY2F0aW9uIHRvIHN0b3JlIGVycm9yIG9uIGZhaWx1cmUKQEAgLTMyOTIsMyArMzQ4MCwxMzkgQEAKIAlkYnVzX21lc3NhZ2VfaXRlcl9yZWN1cnNlKGl0ZXIsICZ2YXJpYW50X2l0ZXIpOwogCXJldHVybiBzZXRfbmV0d29ya19wcm9wZXJ0aWVzKG5ldC0+d3BhX3MsIHNzaWQsICZ2YXJpYW50X2l0ZXIsIGVycm9yKTsKIH0KKworCisjaWZkZWYgQ09ORklHX0FQCisKK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfc3Vic2NyaWJlX3ByZXEoCisJREJ1c01lc3NhZ2UgKm1lc3NhZ2UsIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYXNfZGJ1c19wcml2ICpwcml2ID0gd3BhX3MtPmdsb2JhbC0+ZGJ1czsKKwljaGFyICpuYW1lOworCisJaWYgKHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyICE9IE5VTEwpIHsKKwkJaWYgKG9zX3N0cmNtcChkYnVzX21lc3NhZ2VfZ2V0X3NlbmRlcihtZXNzYWdlKSwKKwkJCSAgICAgIHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyKSA9PSAwKQorCQkJcmV0dXJuIE5VTEw7CisKKwkJcmV0dXJuIGRidXNfbWVzc2FnZV9uZXdfZXJyb3IobWVzc2FnZSwKKwkJCVdQQVNfREJVU19FUlJPUl9TVUJTQ1JJUFRJT05fSU5fVVNFLAorCQkJIkFub3RoZXIgYXBwbGljYXRpb24gaXMgYWxyZWFkeSBzdWJzY3JpYmVkIik7CisJfQorCisJbmFtZSA9IG9zX3N0cmR1cChkYnVzX21lc3NhZ2VfZ2V0X3NlbmRlcihtZXNzYWdlKSk7CisJaWYgKCFuYW1lKQorCQlyZXR1cm4gZGJ1c19tZXNzYWdlX25ld19lcnJvcihtZXNzYWdlLCBEQlVTX0VSUk9SX05PX01FTU9SWSwKKwkJCQkJICAgICAgIm91dCBvZiBtZW1vcnkiKTsKKworCXdwYV9zLT5wcmVxX25vdGlmeV9wZWVyID0gbmFtZTsKKworCS8qIFN1YnNjcmliZSB0byBjbGVhbiB1cCBpZiBhcHBsaWNhdGlvbiBjbG9zZXMgc29ja2V0ICovCisJd3Bhc19kYnVzX3N1YnNjcmliZV9ub2MocHJpdik7CisKKwkvKgorCSAqIERvdWJsZS1jaGVjayBpdCdzIHN0aWxsIGFsaXZlIHRvIG1ha2Ugc3VyZSB0aGF0IHdlIGRpZG4ndAorCSAqIG1pc3MgdGhlIE5hbWVPd25lckNoYW5nZWQgc2lnbmFsLCBlLmcuIHdoaWxlIHN0cmR1cCdpbmcuCisJICovCisJaWYgKCFkYnVzX2J1c19uYW1lX2hhc19vd25lcihwcml2LT5jb24sIG5hbWUsIE5VTEwpKSB7CisJCS8qCisJCSAqIEFwcGxpY2F0aW9uIG5vIGxvbmdlciBleGlzdHMsIGNsZWFuIHVwLgorCQkgKiBUaGUgcmV0dXJuIHZhbHVlIGlzIGlycmVsZXZhbnQgbm93LgorCQkgKgorCQkgKiBOZWVkIHRvIGNoZWNrIGlmIHRoZSBOYW1lT3duZXJDaGFuZ2VkIGhhbmRsaW5nCisJCSAqIGFscmVhZHkgY2xlYW5lZCB1cCBiZWNhdXNlIHdlIGhhdmUgcHJvY2Vzc2VkCisJCSAqIERCdXMgbWVzc2FnZXMgd2hpbGUgY2hlY2tpbmcgaWYgdGhlIG5hbWUgc3RpbGwKKwkJICogaGFzIGFuIG93bmVyLgorCQkgKi8KKwkJaWYgKCF3cGFfcy0+cHJlcV9ub3RpZnlfcGVlcikKKwkJCXJldHVybiBOVUxMOworCQlvc19mcmVlKHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyKTsKKwkJd3BhX3MtPnByZXFfbm90aWZ5X3BlZXIgPSBOVUxMOworCQl3cGFzX2RidXNfdW5zdWJzY3JpYmVfbm9jKHByaXYpOworCX0KKworCXJldHVybiBOVUxMOworfQorCisKK0RCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfdW5zdWJzY3JpYmVfcHJlcSgKKwlEQnVzTWVzc2FnZSAqbWVzc2FnZSwgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlzdHJ1Y3Qgd3Bhc19kYnVzX3ByaXYgKnByaXYgPSB3cGFfcy0+Z2xvYmFsLT5kYnVzOworCisJaWYgKCF3cGFfcy0+cHJlcV9ub3RpZnlfcGVlcikKKwkJcmV0dXJuIGRidXNfbWVzc2FnZV9uZXdfZXJyb3IobWVzc2FnZSwKKwkJCVdQQVNfREJVU19FUlJPUl9OT19TVUJTQ1JJUFRJT04sCisJCQkiTm90IHN1YnNjcmliZWQiKTsKKworCWlmIChvc19zdHJjbXAod3BhX3MtPnByZXFfbm90aWZ5X3BlZXIsCisJCSAgICAgIGRidXNfbWVzc2FnZV9nZXRfc2VuZGVyKG1lc3NhZ2UpKSkKKwkJcmV0dXJuIGRidXNfbWVzc2FnZV9uZXdfZXJyb3IobWVzc2FnZSwKKwkJCVdQQVNfREJVU19FUlJPUl9TVUJTQ1JJUFRJT05fRVBFUk0sCisJCQkiQ2FuJ3QgdW5zdWJzY3JpYmUgb3RoZXJzIik7CisKKwlvc19mcmVlKHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyKTsKKwl3cGFfcy0+cHJlcV9ub3RpZnlfcGVlciA9IE5VTEw7CisJd3Bhc19kYnVzX3Vuc3Vic2NyaWJlX25vYyhwcml2KTsKKwlyZXR1cm4gTlVMTDsKK30KKworCit2b2lkIHdwYXNfZGJ1c19zaWduYWxfcHJlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICAgY29uc3QgdTggKmFkZHIsIGNvbnN0IHU4ICpkc3QsIGNvbnN0IHU4ICpic3NpZCwKKwkJCSAgIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwgdTMyIHNzaV9zaWduYWwpCit7CisJREJ1c01lc3NhZ2UgKm1zZzsKKwlEQnVzTWVzc2FnZUl0ZXIgaXRlciwgZGljdF9pdGVyOworCXN0cnVjdCB3cGFzX2RidXNfcHJpdiAqcHJpdiA9IHdwYV9zLT5nbG9iYWwtPmRidXM7CisKKwkvKiBEbyBub3RoaW5nIGlmIHRoZSBjb250cm9sIGludGVyZmFjZSBpcyBub3QgdHVybmVkIG9uICovCisJaWYgKHByaXYgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKHdwYV9zLT5wcmVxX25vdGlmeV9wZWVyID09IE5VTEwpCisJCXJldHVybjsKKworCW1zZyA9IGRidXNfbWVzc2FnZV9uZXdfc2lnbmFsKHdwYV9zLT5kYnVzX25ld19wYXRoLAorCQkJCSAgICAgIFdQQVNfREJVU19ORVdfSUZBQ0VfSU5URVJGQUNFLAorCQkJCSAgICAgICJQcm9iZVJlcXVlc3QiKTsKKwlpZiAobXNnID09IE5VTEwpCisJCXJldHVybjsKKworCWRidXNfbWVzc2FnZV9zZXRfZGVzdGluYXRpb24obXNnLCB3cGFfcy0+cHJlcV9ub3RpZnlfcGVlcik7CisKKwlkYnVzX21lc3NhZ2VfaXRlcl9pbml0X2FwcGVuZChtc2csICZpdGVyKTsKKworCWlmICghd3BhX2RidXNfZGljdF9vcGVuX3dyaXRlKCZpdGVyLCAmZGljdF9pdGVyKSkKKwkJZ290byBmYWlsOworCWlmIChhZGRyICYmICF3cGFfZGJ1c19kaWN0X2FwcGVuZF9ieXRlX2FycmF5KCZkaWN0X2l0ZXIsICJhZGRyIiwKKwkJCQkJCSAgICAgKGNvbnN0IGNoYXIgKikgYWRkciwKKwkJCQkJCSAgICAgRVRIX0FMRU4pKQorCQlnb3RvIGZhaWw7CisJaWYgKGRzdCAmJiAhd3BhX2RidXNfZGljdF9hcHBlbmRfYnl0ZV9hcnJheSgmZGljdF9pdGVyLCAiZHN0IiwKKwkJCQkJCSAgICAoY29uc3QgY2hhciAqKSBkc3QsCisJCQkJCQkgICAgRVRIX0FMRU4pKQorCQlnb3RvIGZhaWw7CisJaWYgKGJzc2lkICYmICF3cGFfZGJ1c19kaWN0X2FwcGVuZF9ieXRlX2FycmF5KCZkaWN0X2l0ZXIsICJic3NpZCIsCisJCQkJCQkgICAgICAoY29uc3QgY2hhciAqKSBic3NpZCwKKwkJCQkJCSAgICAgIEVUSF9BTEVOKSkKKwkJZ290byBmYWlsOworCWlmIChpZSAmJiBpZV9sZW4gJiYgIXdwYV9kYnVzX2RpY3RfYXBwZW5kX2J5dGVfYXJyYXkoJmRpY3RfaXRlciwgImllcyIsCisJCQkJCQkJICAgICAoY29uc3QgY2hhciAqKSBpZSwKKwkJCQkJCQkgICAgIGllX2xlbikpCisJCWdvdG8gZmFpbDsKKwlpZiAoc3NpX3NpZ25hbCAmJiAhd3BhX2RidXNfZGljdF9hcHBlbmRfaW50MzIoJmRpY3RfaXRlciwgInNpZ25hbCIsCisJCQkJCQkgICAgICBzc2lfc2lnbmFsKSkKKwkJZ290byBmYWlsOworCWlmICghd3BhX2RidXNfZGljdF9jbG9zZV93cml0ZSgmaXRlciwgJmRpY3RfaXRlcikpCisJCWdvdG8gZmFpbDsKKworCWRidXNfY29ubmVjdGlvbl9zZW5kKHByaXYtPmNvbiwgbXNnLCBOVUxMKTsKKwlnb3RvIG91dDsKK2ZhaWw6CisJd3BhX3ByaW50ZihNU0dfRVJST1IsICJkYnVzOiBGYWlsZWQgdG8gY29uc3RydWN0IHNpZ25hbCIpOworb3V0OgorCWRidXNfbWVzc2FnZV91bnJlZihtc2cpOworfQorCisjZW5kaWYgLyogQ09ORklHX0FQICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzLmgKaW5kZXggYzAyNzJkNS4uY2ZmMjE4ZiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVycy5oCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnMuaApAQCAtMywxNCArMyw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDYsIERhbiBXaWxsaWFtcyA8ZGNid0ByZWRoYXQuY29tPiBhbmQgUmVkIEhhdCwgSW5jLgogICogQ29weXJpZ2h0IChjKSAyMDA5LTIwMTAsIFdpdG9sZCBTb3dhIDx3aXRvbGQuc293YUBnbWFpbC5jb20+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBDVFJMX0lGQUNFX0RCVVNfTkVXX0hBTkRMRVJTX0gKQEAgLTQxLDYgKzM1LDEyIEBACiAJCQkJCQkgICBzaXplX3QgYXJyYXlfbGVuLAogCQkJCQkJICAgREJ1c0Vycm9yICplcnJvcik7CiAKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19zaW1wbGVfYXJyYXlfYXJyYXlfcHJvcGVydHlfZ2V0dGVyKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJCQkgY29uc3QgaW50IHR5cGUsCisJCQkJCQkJIHN0cnVjdCB3cGFidWYgKiphcnJheSwKKwkJCQkJCQkgc2l6ZV90IGFycmF5X2xlbiwKKwkJCQkJCQkgREJ1c0Vycm9yICplcnJvcik7CisKIERCdXNNZXNzYWdlICogd3Bhc19kYnVzX2hhbmRsZXJfY3JlYXRlX2ludGVyZmFjZShEQnVzTWVzc2FnZSAqbWVzc2FnZSwKIAkJCQkJCSBzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsKTsKIApAQCAtMTE4LDYgKzExOCw5IEBACiBEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19oYW5kbGVyX2ZsdXNoX2JzcyhEQnVzTWVzc2FnZSAqbWVzc2FnZSwKIAkJCQkJICBzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIAorREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl9hdXRvc2NhbihEQnVzTWVzc2FnZSAqbWVzc2FnZSwKKwkJCQkJIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworCiBkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX2NhcGFiaWxpdGllcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCiAJCQkJCSAgREJ1c0Vycm9yICplcnJvciwgdm9pZCAqdXNlcl9kYXRhKTsKIApAQCAtMTQxLDYgKzE0NCwxMCBAQAogCQkJCQkgREJ1c0Vycm9yICplcnJvciwKIAkJCQkJIHZvaWQgKnVzZXJfZGF0YSk7CiAKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfZGlzY29ubmVjdF9yZWFzb24oREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkgICAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgICAgIHZvaWQgKnVzZXJfZGF0YSk7CisKIGRidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfYnNzX2V4cGlyZV9hZ2UoREJ1c01lc3NhZ2VJdGVyICppdGVyLAogCQkJCQkgICAgREJ1c0Vycm9yICplcnJvciwgdm9pZCAqdXNlcl9kYXRhKTsKIApAQCAtMTYyLDYgKzE2OSwxNCBAQAogZGJ1c19ib29sX3Qgd3Bhc19kYnVzX3NldHRlcl9jb3VudHJ5KERCdXNNZXNzYWdlSXRlciAqaXRlciwgREJ1c0Vycm9yICplcnJvciwKIAkJCQkgICAgIHZvaWQgKnVzZXJfZGF0YSk7CiAKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfc2Nhbl9pbnRlcnZhbChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgIERCdXNFcnJvciAqZXJyb3IsCisJCQkJCSAgIHZvaWQgKnVzZXJfZGF0YSk7CisKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19zZXR0ZXJfc2Nhbl9pbnRlcnZhbChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgIERCdXNFcnJvciAqZXJyb3IsCisJCQkJCSAgIHZvaWQgKnVzZXJfZGF0YSk7CisKIGRidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfaWZuYW1lKERCdXNNZXNzYWdlSXRlciAqaXRlciwgREJ1c0Vycm9yICplcnJvciwKIAkJCQkgICAgdm9pZCAqdXNlcl9kYXRhKTsKIApAQCAtMjUyLDQgKzI2Nyw5IEBACiBEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19lcnJvcl91bmtub3duX2Vycm9yKERCdXNNZXNzYWdlICptZXNzYWdlLAogCQkJCQkgICAgY29uc3QgY2hhciAqYXJnKTsKIAorREJ1c01lc3NhZ2UgKiB3cGFzX2RidXNfaGFuZGxlcl9zdWJzY3JpYmVfcHJlcSgKKwlEQnVzTWVzc2FnZSAqbWVzc2FnZSwgc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitEQnVzTWVzc2FnZSAqIHdwYXNfZGJ1c19oYW5kbGVyX3Vuc3Vic2NyaWJlX3ByZXEoCisJREJ1c01lc3NhZ2UgKm1lc3NhZ2UsIHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOworCiAjZW5kaWYgLyogQ1RSTF9JRkFDRV9EQlVTX0hBTkRMRVJTX05FV19IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3AycC5jIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVyc19wMnAuYwppbmRleCA3OTM3M2I0Li5mNDU0MWY3IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3AycC5jCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfcDJwLmMKQEAgLTEsMTQgKzEsOSBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC8gZGJ1cy1iYXNlZCBjb250cm9sIGludGVyZmFjZSAoUDJQKQorICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTIsIEludGVsIENvcnBvcmF0aW9uCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCkBAIC00NSw3ICs0MCw3IEBACiAKIAlpZiAoIXBlZXJfcGF0aCkKIAkJcmV0dXJuIC0xOwotCXAgPSBzdHJyY2hyKHBlZXJfcGF0aCwgJy8nKTsKKwlwID0gb3Nfc3RycmNocihwZWVyX3BhdGgsICcvJyk7CiAJaWYgKCFwKQogCQlyZXR1cm4gLTE7CiAJcCsrOwpAQCAtNTA4LDggKzUwMyw4IEBACiAJCWdvdG8gaW52X2FyZ3M7CiAKIAluZXdfcGluID0gd3Bhc19wMnBfY29ubmVjdCh3cGFfcywgYWRkciwgcGluLCB3cHNfbWV0aG9kLAotCQkJCSAgIHBlcnNpc3RlbnRfZ3JvdXAsIGpvaW4sIGF1dGhvcml6ZV9vbmx5LAotCQkJCSAgIGdvX2ludGVudCwgZnJlcSk7CisJCQkJICAgcGVyc2lzdGVudF9ncm91cCwgMCwgam9pbiwgYXV0aG9yaXplX29ubHksCisJCQkJICAgZ29faW50ZW50LCBmcmVxLCAtMSwgMCk7CiAKIAlpZiAobmV3X3BpbiA+PSAwKSB7CiAJCWNoYXIgbnBpbls5XTsKQEAgLTY5Miw3ICs2ODcsOCBAQAogCSAgICBvc19zdHJjbXAoY29uZmlnX21ldGhvZCwgInB1c2hidXR0b24iKSkKIAkJcmV0dXJuIHdwYXNfZGJ1c19lcnJvcl9pbnZhbGlkX2FyZ3MobWVzc2FnZSwgTlVMTCk7CiAKLQlpZiAod3Bhc19wMnBfcHJvdl9kaXNjKHdwYV9zLCBwZWVyX2FkZHIsIGNvbmZpZ19tZXRob2QsIDApIDwgMCkKKwlpZiAod3Bhc19wMnBfcHJvdl9kaXNjKHdwYV9zLCBwZWVyX2FkZHIsIGNvbmZpZ19tZXRob2QsCisJCQkgICAgICAgV1BBU19QMlBfUERfRk9SX0dPX05FRykgPCAwKQogCQlyZXR1cm4gd3Bhc19kYnVzX2Vycm9yX3Vua25vd25fZXJyb3IobWVzc2FnZSwKIAkJCQkiRmFpbGVkIHRvIHNlbmQgcHJvdmlzaW9uIGRpc2NvdmVyeSByZXF1ZXN0Iik7CiAKQEAgLTcwNCw5ICs3MDAsOSBAQAogICogUDJQIERldmljZSBwcm9wZXJ0eSBhY2Nlc3NvciBtZXRob2RzLgogICovCiAKLWRidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2RldmljZV9wcm9wZXJ0aWVzKERCdXNNZXNzYWdlSXRlciAqaXRlciwKLQkJCQkJCSAgIERCdXNFcnJvciAqZXJyb3IsCi0JCQkJCQkgICB2b2lkICp1c2VyX2RhdGEpCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9kZXZpY2VfY29uZmlnKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJICAgICAgIERCdXNFcnJvciAqZXJyb3IsCisJCQkJCSAgICAgICB2b2lkICp1c2VyX2RhdGEpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHVzZXJfZGF0YTsKIAlEQnVzTWVzc2FnZUl0ZXIgdmFyaWFudF9pdGVyLCBkaWN0X2l0ZXI7CkBAIC03ODIsNyArNzc4LDcgQEAKIAkJZ290byBlcnJfbm9fbWVtOwogCiAJLyogUGVyc2lzdGVudCBSZWNvbm5lY3QgKi8KLQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX2Jvb2woJmRpY3RfaXRlciwgIlBlcnNpc3RhbnRSZWNvbm5lY3QiLAorCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfYm9vbCgmZGljdF9pdGVyLCAiUGVyc2lzdGVudFJlY29ubmVjdCIsCiAJCQkJICAgICAgIHdwYV9zLT5jb25mLT5wZXJzaXN0ZW50X3JlY29ubmVjdCkpCiAJCWdvdG8gZXJyX25vX21lbTsKIApAQCAtODM5LDkgKzgzNSw5IEBACiB9CiAKIAotZGJ1c19ib29sX3Qgd3Bhc19kYnVzX3NldHRlcl9wMnBfZGV2aWNlX3Byb3BlcnRpZXMoREJ1c01lc3NhZ2VJdGVyICppdGVyLAotCQkJCQkJICAgREJ1c0Vycm9yICplcnJvciwKLQkJCQkJCSAgIHZvaWQgKnVzZXJfZGF0YSkKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19zZXR0ZXJfcDJwX2RldmljZV9jb25maWcoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkgICAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgICAgIHZvaWQgKnVzZXJfZGF0YSkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gdXNlcl9kYXRhOwogCURCdXNNZXNzYWdlSXRlciB2YXJpYW50X2l0ZXIsIGl0ZXJfZGljdDsKQEAgLTkyNyw3ICs5MjMsNyBAQAogCQkJICAgKGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX1VJTlQzMikgJiYKIAkJCSAgIChlbnRyeS51aW50MzJfdmFsdWUgPD0gMTUpKQogCQkJd3BhX3MtPmNvbmYtPnAycF9nb19pbnRlbnQgPSBlbnRyeS51aW50MzJfdmFsdWU7Ci0JCWVsc2UgaWYgKChvc19zdHJjbXAoZW50cnkua2V5LCAiUGVyc2lzdGFudFJlY29ubmVjdCIpID09IDApICYmCisJCWVsc2UgaWYgKChvc19zdHJjbXAoZW50cnkua2V5LCAiUGVyc2lzdGVudFJlY29ubmVjdCIpID09IDApICYmCiAJCQkgKGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX0JPT0xFQU4pKQogCQkJd3BhX3MtPmNvbmYtPnBlcnNpc3RlbnRfcmVjb25uZWN0ID0gZW50cnkuYm9vbF92YWx1ZTsKIAkJZWxzZSBpZiAoKG9zX3N0cmNtcChlbnRyeS5rZXksICJMaXN0ZW5SZWdDbGFzcyIpID09IDApICYmCkBAIC0xMTQwLDEzICsxMTM2LDE4IEBACiAJCQkJICAgICAgIHZvaWQgKnVzZXJfZGF0YSkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gdXNlcl9kYXRhOworCWNoYXIgcGF0aF9idWZbV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWF07CisJY2hhciAqZGJ1c19ncm91cG9ial9wYXRoID0gcGF0aF9idWY7CiAKIAlpZiAod3BhX3MtPmRidXNfZ3JvdXBvYmpfcGF0aCA9PSBOVUxMKQotCQlyZXR1cm4gRkFMU0U7CisJCW9zX3NucHJpbnRmKGRidXNfZ3JvdXBvYmpfcGF0aCwgV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWCwKKwkJCSAgICAiLyIpOworCWVsc2UKKwkJb3Nfc25wcmludGYoZGJ1c19ncm91cG9ial9wYXRoLCBXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYLAorCQkJICAgICIlcyIsIHdwYV9zLT5kYnVzX2dyb3Vwb2JqX3BhdGgpOwogCiAJcmV0dXJuIHdwYXNfZGJ1c19zaW1wbGVfcHJvcGVydHlfZ2V0dGVyKGl0ZXIsIERCVVNfVFlQRV9PQkpFQ1RfUEFUSCwKLQkJCQkJCSZ3cGFfcy0+ZGJ1c19ncm91cG9ial9wYXRoLAotCQkJCQkJZXJyb3IpOworCQkJCQkJJmRidXNfZ3JvdXBvYmpfcGF0aCwgZXJyb3IpOwogfQogCiAKQEAgLTExNTcsMTEgKzExNTgsMTMgQEAKIAljaGFyIGdvX3BlZXJfb2JqX3BhdGhbV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWF0sICpwYXRoOwogCiAJaWYgKHdwYXNfZ2V0X3AycF9yb2xlKHdwYV9zKSAhPSBXUEFTX1AyUF9ST0xFX0NMSUVOVCkKLQkJcmV0dXJuIEZBTFNFOworCQlvc19zbnByaW50Zihnb19wZWVyX29ial9wYXRoLCBXUEFTX0RCVVNfT0JKRUNUX1BBVEhfTUFYLCAiLyIpOworCWVsc2UKKwkJb3Nfc25wcmludGYoZ29fcGVlcl9vYmpfcGF0aCwgV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWCwKKwkJCSAgICAiJXMvIiBXUEFTX0RCVVNfTkVXX1AyUF9QRUVSU19QQVJUICIvIgorCQkJICAgIENPTVBBQ1RfTUFDU1RSLAorCQkJICAgIHdwYV9zLT5kYnVzX25ld19wYXRoLCBNQUMyU1RSKHdwYV9zLT5nb19kZXZfYWRkcikpOwogCi0Jb3Nfc25wcmludGYoZ29fcGVlcl9vYmpfcGF0aCwgV1BBU19EQlVTX09CSkVDVF9QQVRIX01BWCwKLQkJICAgICIlcy8iIFdQQVNfREJVU19ORVdfUDJQX1BFRVJTX1BBUlQgIi8iIENPTVBBQ1RfTUFDU1RSLAotCQkgICAgd3BhX3MtPmRidXNfbmV3X3BhdGgsIE1BQzJTVFIod3BhX3MtPmdvX2Rldl9hZGRyKSk7CiAJcGF0aCA9IGdvX3BlZXJfb2JqX3BhdGg7CiAJcmV0dXJuIHdwYXNfZGJ1c19zaW1wbGVfcHJvcGVydHlfZ2V0dGVyKGl0ZXIsIERCVVNfVFlQRV9PQkpFQ1RfUEFUSCwKIAkJCQkJCSZwYXRoLCBlcnJvcik7CkBAIC0xMzQxLDYgKzEzNDQsNyBAQAogewogCXN0cnVjdCBwZWVyX2hhbmRsZXJfYXJncyAqcGVlcl9hcmdzID0gdXNlcl9kYXRhOwogCWNvbnN0IHN0cnVjdCBwMnBfcGVlcl9pbmZvICppbmZvOworCURCdXNNZXNzYWdlSXRlciB2YXJpYW50X2l0ZXIsIGFycmF5X2l0ZXI7CiAKIAlpbmZvID0gcDJwX2dldF9wZWVyX2ZvdW5kKHBlZXJfYXJncy0+d3BhX3MtPmdsb2JhbC0+cDJwLAogCQkJCSAgcGVlcl9hcmdzLT5wMnBfZGV2aWNlX2FkZHIsIDApOwpAQCAtMTM1MCwyOSArMTM1NCw4MCBAQAogCQlyZXR1cm4gRkFMU0U7CiAJfQogCi0JaWYgKGluZm8tPndwc19zZWNfZGV2X3R5cGVfbGlzdF9sZW4pIHsKLQkJY29uc3QgdTggKnNlY19kZXZfdHlwZV9saXN0ID0gaW5mby0+d3BzX3NlY19kZXZfdHlwZV9saXN0OwotCQlpbnQgbnVtX3NlY19kZXZfdHlwZXMgPSBpbmZvLT53cHNfc2VjX2Rldl90eXBlX2xpc3RfbGVuOwotCi0JCWlmICghd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwKLQkJCQkJCQkgICAgREJVU19UWVBFX0JZVEUsCi0JCQkJCQkJICAgIHNlY19kZXZfdHlwZV9saXN0LAotCQkJCQkJCSAgICBudW1fc2VjX2Rldl90eXBlcywKLQkJCQkJCQkgICAgZXJyb3IpKQotCQkJZ290byBlcnJfbm9fbWVtOwotCQllbHNlCi0JCQlyZXR1cm4gVFJVRTsKKwlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX29wZW5fY29udGFpbmVyKGl0ZXIsIERCVVNfVFlQRV9WQVJJQU5ULAorCQkJCQkgICAgICBEQlVTX1RZUEVfQVJSQVlfQVNfU1RSSU5HCisJCQkJCSAgICAgIERCVVNfVFlQRV9BUlJBWV9BU19TVFJJTkcKKwkJCQkJICAgICAgREJVU19UWVBFX0JZVEVfQVNfU1RSSU5HLAorCQkJCQkgICAgICAmdmFyaWFudF9pdGVyKSkgeworCQlkYnVzX3NldF9lcnJvcihlcnJvciwgREJVU19FUlJPUl9GQUlMRUQsCisJCSAgICAgICAgICAgICAgICIlczogZmFpbGVkIHRvIGNvbnN0cnVjdCBtZXNzYWdlIDEiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBGQUxTRTsKIAl9CiAKLQlpZiAoIXdwYXNfZGJ1c19zaW1wbGVfYXJyYXlfcHJvcGVydHlfZ2V0dGVyKGl0ZXIsIERCVVNfVFlQRV9CWVRFLCBOVUxMLAotCQkJCQkJICAgIDAsIGVycm9yKSkKLQkJZ290byBlcnJfbm9fbWVtOworCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIoJnZhcmlhbnRfaXRlciwgREJVU19UWVBFX0FSUkFZLAorCQkJCQkgICAgICBEQlVTX1RZUEVfQVJSQVlfQVNfU1RSSU5HCisJCQkJCSAgICAgIERCVVNfVFlQRV9CWVRFX0FTX1NUUklORywKKwkJCQkJICAgICAgJmFycmF5X2l0ZXIpKSB7CisJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJICAgICAgICAgICAgICAgIiVzOiBmYWlsZWQgdG8gY29uc3RydWN0IG1lc3NhZ2UgMiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIEZBTFNFOworCX0KKworCWlmIChpbmZvLT53cHNfc2VjX2Rldl90eXBlX2xpc3RfbGVuKSB7CisJCWNvbnN0IHU4ICpzZWNfZGV2X3R5cGVfbGlzdCA9IGluZm8tPndwc19zZWNfZGV2X3R5cGVfbGlzdDsKKwkJaW50IG51bV9zZWNfZGV2aWNlX3R5cGVzID0KKwkJCWluZm8tPndwc19zZWNfZGV2X3R5cGVfbGlzdF9sZW4gLyBXUFNfREVWX1RZUEVfTEVOOworCQlpbnQgaTsKKwkJREJ1c01lc3NhZ2VJdGVyIGlubmVyX2FycmF5X2l0ZXI7CisKKwkJZm9yIChpID0gMDsgaSA8IG51bV9zZWNfZGV2aWNlX3R5cGVzOyBpKyspIHsKKwkJCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfb3Blbl9jb250YWluZXIoCisJCQkJICAgICZhcnJheV9pdGVyLCBEQlVTX1RZUEVfQVJSQVksCisJCQkJICAgIERCVVNfVFlQRV9CWVRFX0FTX1NUUklORywKKwkJCQkgICAgJmlubmVyX2FycmF5X2l0ZXIpKSB7CisJCQkJZGJ1c19zZXRfZXJyb3IoZXJyb3IsIERCVVNfRVJST1JfRkFJTEVELAorCQkJCQkgICAgICAgIiVzOiBmYWlsZWQgdG8gY29uc3RydWN0ICIKKwkJCQkJICAgICAgICJtZXNzYWdlIDMgKCVkKSIsCisJCQkJCSAgICAgICBfX2Z1bmNfXywgaSk7CisJCQkJcmV0dXJuIEZBTFNFOworCQkJfQorCisJCQlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2FwcGVuZF9maXhlZF9hcnJheSgKKwkJCQkgICAgJmlubmVyX2FycmF5X2l0ZXIsIERCVVNfVFlQRV9CWVRFLAorCQkJCSAgICAmc2VjX2Rldl90eXBlX2xpc3QsIFdQU19ERVZfVFlQRV9MRU4pKSB7CisJCQkJZGJ1c19zZXRfZXJyb3IoZXJyb3IsIERCVVNfRVJST1JfRkFJTEVELAorCQkJCQkgICAgICAgIiVzOiBmYWlsZWQgdG8gY29uc3RydWN0ICIKKwkJCQkJICAgICAgICJtZXNzYWdlIDQgKCVkKSIsCisJCQkJCSAgICAgICBfX2Z1bmNfXywgaSk7CisJCQkJcmV0dXJuIEZBTFNFOworCQkJfQorCisJCQlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcigKKwkJCQkgICAgJmFycmF5X2l0ZXIsICZpbm5lcl9hcnJheV9pdGVyKSkgeworCQkJCWRidXNfc2V0X2Vycm9yKGVycm9yLCBEQlVTX0VSUk9SX0ZBSUxFRCwKKwkJCQkJICAgICAgICIlczogZmFpbGVkIHRvIGNvbnN0cnVjdCAiCisJCQkJCSAgICAgICAibWVzc2FnZSA1ICglZCkiLAorCQkJCQkgICAgICAgX19mdW5jX18sIGkpOworCQkJCXJldHVybiBGQUxTRTsKKwkJCX0KKworCQkJc2VjX2Rldl90eXBlX2xpc3QgKz0gV1BTX0RFVl9UWVBFX0xFTjsKKwkJfQorCX0KKworCWlmICghZGJ1c19tZXNzYWdlX2l0ZXJfY2xvc2VfY29udGFpbmVyKCZ2YXJpYW50X2l0ZXIsICZhcnJheV9pdGVyKSkgeworCQlkYnVzX3NldF9lcnJvcihlcnJvciwgREJVU19FUlJPUl9GQUlMRUQsCisJCSAgICAgICAgICAgICAgICIlczogZmFpbGVkIHRvIGNvbnN0cnVjdCBtZXNzYWdlIDYiLCBfX2Z1bmNfXyk7CisJCXJldHVybiBGQUxTRTsKKwl9CisKKwlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcihpdGVyLCAmdmFyaWFudF9pdGVyKSkgeworCQlkYnVzX3NldF9lcnJvcihlcnJvciwgREJVU19FUlJPUl9GQUlMRUQsCisJCSAgICAgICAgICAgICAgICIlczogZmFpbGVkIHRvIGNvbnN0cnVjdCBtZXNzYWdlIDciLCBfX2Z1bmNfXyk7CisJCXJldHVybiBGQUxTRTsKKwl9CiAKIAlyZXR1cm4gVFJVRTsKLQotZXJyX25vX21lbToKLQlkYnVzX3NldF9lcnJvcl9jb25zdChlcnJvciwgREJVU19FUlJPUl9OT19NRU1PUlksICJubyBtZW1vcnkiKTsKLQlyZXR1cm4gRkFMU0U7CiB9CiAKIApAQCAtMTM4MCw3ICsxNDM1LDcgQEAKIAkJCQkJCSAgICAgICBEQnVzRXJyb3IgKmVycm9yLAogCQkJCQkJICAgICAgIHZvaWQgKnVzZXJfZGF0YSkKIHsKLQljb25zdCBzdHJ1Y3Qgd3BhYnVmICp2ZW5kb3JfZXh0ZW5zaW9uW1AyUF9NQVhfV1BTX1ZFTkRPUl9FWFRdOworCXN0cnVjdCB3cGFidWYgKnZlbmRvcl9leHRlbnNpb25bUDJQX01BWF9XUFNfVkVORE9SX0VYVF07CiAJaW50IGksIG51bTsKIAlzdHJ1Y3QgcGVlcl9oYW5kbGVyX2FyZ3MgKnBlZXJfYXJncyA9IHVzZXJfZGF0YTsKIAljb25zdCBzdHJ1Y3QgcDJwX3BlZXJfaW5mbyAqaW5mbzsKQEAgLTE0MDEsMTIgKzE0NTYsMTAgQEAKIAkJbnVtKys7CiAJfQogCi0JaWYgKCF3cGFzX2RidXNfc2ltcGxlX2FycmF5X3Byb3BlcnR5X2dldHRlcihpdGVyLCBEQlVTX1RZUEVfU1RSSU5HLAotCQkJCQkJICAgIHZlbmRvcl9leHRlbnNpb24sIG51bSwKLQkJCQkJCSAgICBlcnJvcikpIHsKLQkJZGJ1c19zZXRfZXJyb3JfY29uc3QoZXJyb3IsIERCVVNfRVJST1JfTk9fTUVNT1JZLCAibm8gbWVtb3J5Iik7CisJaWYgKCF3cGFzX2RidXNfc2ltcGxlX2FycmF5X2FycmF5X3Byb3BlcnR5X2dldHRlcihpdGVyLCBEQlVTX1RZUEVfQllURSwKKwkJCQkJCQkgIHZlbmRvcl9leHRlbnNpb24sCisJCQkJCQkJICBudW0sIGVycm9yKSkKIAkJcmV0dXJuIEZBTFNFOwotCX0KIAogCXJldHVybiBUUlVFOwogfQpAQCAtMTQxNSwxMCArMTQ2OCwxMiBAQAogZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcl9pZXMoREJ1c01lc3NhZ2VJdGVyICppdGVyLAogCQkJCQkgIERCdXNFcnJvciAqZXJyb3IsIHZvaWQgKnVzZXJfZGF0YSkKIHsKKwlkYnVzX2Jvb2xfdCBzdWNjZXNzOwogCS8qIHN0cnVjdCBwZWVyX2hhbmRsZXJfYXJncyAqcGVlcl9hcmdzID0gdXNlcl9kYXRhOyAqLwogCi0JZGJ1c19zZXRfZXJyb3JfY29uc3QoZXJyb3IsIERCVVNfRVJST1JfRkFJTEVELCAibm90IGltcGxlbWVudGVkIik7Ci0JcmV0dXJuIEZBTFNFOworCXN1Y2Nlc3MgPSB3cGFzX2RidXNfc2ltcGxlX2FycmF5X3Byb3BlcnR5X2dldHRlcihpdGVyLCBEQlVTX1RZUEVfQllURSwKKwkJCQkJCQkgTlVMTCwgMCwgZXJyb3IpOworCXJldHVybiBzdWNjZXNzOwogfQogCiAKQEAgLTE3NDYsOSArMTgwMSwxMSBAQAogCWNvbnN0IHU4ICphZGRyOwogCWRidXNfYm9vbF90IHN1Y2Nlc3MgPSBGQUxTRTsKIAotCS8qIEVuc3VyZSB3ZSBhcmUgYSBHTyAqLwotCWlmICh3cGFfcy0+d3BhX3N0YXRlICE9IFdQQV9DT01QTEVURUQpCi0JCXJldHVybiBGQUxTRTsKKwkvKiBWZXJpZnkgY29ycmVjdCByb2xlIGZvciB0aGlzIHByb3BlcnR5ICovCisJaWYgKHdwYXNfZ2V0X3AycF9yb2xlKHdwYV9zKSAhPSBXUEFTX1AyUF9ST0xFX0dPKSB7CisJCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX2FycmF5X3Byb3BlcnR5X2dldHRlcigKKwkJCWl0ZXIsIERCVVNfVFlQRV9PQkpFQ1RfUEFUSCwgTlVMTCwgMCwgZXJyb3IpOworCX0KIAogCXNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKIAkvKiBBdCBwcmVzZW50IFdQQVMgUDJQX0dPIG1vZGUgb25seSBhcHBsaWNhYmxlIGZvciBwMnBfZ28gKi8KQEAgLTE3OTYsMTExICsxODUzLDE0NSBAQAogfQogCiAKLWRidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX3Byb3BlcnRpZXMoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXBfc3NpZChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgICBEQnVzRXJyb3IgKmVycm9yLCB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHVzZXJfZGF0YTsKKwlpZiAod3BhX3MtPmN1cnJlbnRfc3NpZCA9PSBOVUxMKQorCQlyZXR1cm4gRkFMU0U7CisJcmV0dXJuIHdwYXNfZGJ1c19zaW1wbGVfYXJyYXlfcHJvcGVydHlfZ2V0dGVyKAorCQlpdGVyLCBEQlVTX1RZUEVfQllURSwgd3BhX3MtPmN1cnJlbnRfc3NpZC0+c3NpZCwKKwkJd3BhX3MtPmN1cnJlbnRfc3NpZC0+c3NpZF9sZW4sIGVycm9yKTsKK30KKworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9ic3NpZChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgICB2b2lkICp1c2VyX2RhdGEpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IHVzZXJfZGF0YTsKKwl1OCByb2xlID0gd3Bhc19nZXRfcDJwX3JvbGUod3BhX3MpOworCXU4ICpwX2Jzc2lkOworCisJaWYgKHJvbGUgPT0gV1BBU19QMlBfUk9MRV9DTElFTlQpIHsKKwkJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gTlVMTCkKKwkJCXJldHVybiBGQUxTRTsKKwkJcF9ic3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQtPmJzc2lkOworCX0gZWxzZSB7CisJCWlmICh3cGFfcy0+YXBfaWZhY2UgPT0gTlVMTCkKKwkJCXJldHVybiBGQUxTRTsKKwkJcF9ic3NpZCA9IHdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdLT5vd25fYWRkcjsKKwl9CisKKwlyZXR1cm4gd3Bhc19kYnVzX3NpbXBsZV9hcnJheV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwgREJVU19UWVBFX0JZVEUsCisJCQkJCQkgICAgICBwX2Jzc2lkLCBFVEhfQUxFTiwKKwkJCQkJCSAgICAgIGVycm9yKTsKK30KKworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9mcmVxdWVuY3koREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkJIERCdXNFcnJvciAqZXJyb3IsCisJCQkJCQkgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSB1c2VyX2RhdGE7CisJdTE2IG9wX2ZyZXE7CisJdTggcm9sZSA9IHdwYXNfZ2V0X3AycF9yb2xlKHdwYV9zKTsKKworCWlmIChyb2xlID09IFdQQVNfUDJQX1JPTEVfQ0xJRU5UKSB7CisJCWlmICh3cGFfcy0+Z29fcGFyYW1zID09IE5VTEwpCisJCQlyZXR1cm4gRkFMU0U7CisJCW9wX2ZyZXEgPSB3cGFfcy0+Z29fcGFyYW1zLT5mcmVxOworCX0gZWxzZSB7CisJCWlmICh3cGFfcy0+YXBfaWZhY2UgPT0gTlVMTCkKKwkJCXJldHVybiBGQUxTRTsKKwkJb3BfZnJlcSA9IHdwYV9zLT5hcF9pZmFjZS0+ZnJlcTsKKwl9CisKKwlyZXR1cm4gd3Bhc19kYnVzX3NpbXBsZV9wcm9wZXJ0eV9nZXR0ZXIoaXRlciwgREJVU19UWVBFX1VJTlQxNiwKKwkJCQkJCSZvcF9mcmVxLCBlcnJvcik7Cit9CisKKworZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXBfcGFzc3BocmFzZShEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCiAJCQkJCQkgIERCdXNFcnJvciAqZXJyb3IsCiAJCQkJCQkgIHZvaWQgKnVzZXJfZGF0YSkKIHsKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gdXNlcl9kYXRhOwotCURCdXNNZXNzYWdlSXRlciB2YXJpYW50X2l0ZXIsIGRpY3RfaXRlcjsKLQlzdHJ1Y3QgaG9zdGFwZF9kYXRhICpoYXBkID0gTlVMTDsKLQljb25zdCBzdHJ1Y3Qgd3BhYnVmICp2ZW5kb3JfZXh0W01BWF9XUFNfVkVORE9SX0VYVEVOU0lPTlNdOwotCWludCBudW1fdmVuZG9yX2V4dCA9IDA7Ci0JaW50IGk7CiAJdTggcm9sZSA9IHdwYXNfZ2V0X3AycF9yb2xlKHdwYV9zKTsKLQl1MTYgb3BfZnJlcSA9IDA7Ci0JdTggKnBfYnNzaWQgPSBOVUxMOwotCWNoYXIgKnJvbGVfbmFtZSA9IE5VTEw7CisJY2hhciAqcF9wYXNzID0gTlVMTDsKIAotCWlmICghd3BhX3MtPmN1cnJlbnRfc3NpZCkKLQkJcmV0dXJuIEZBTFNFOwotCi0JLyogQ2hlY2sgY3VycmVudCByb2xlIGFuZCBhZGp1c3QgaW5mb3JtYXRpb24gYWNjb3JkaW5nbHkgKi8KLQlzd2l0Y2ggKHJvbGUpIHsKLQljYXNlIFdQQVNfUDJQX1JPTEVfQ0xJRU5UOgotCQkvKiBnb19wYXJhbXMgaXMgb25seSB2YWxpZCBmb3IgYSBjbGllbnQgKi8KLQkJaWYgKHdwYV9zLT5nb19wYXJhbXMpIHsKLQkJCW9wX2ZyZXEgPSB3cGFfcy0+Z29fcGFyYW1zLT5mcmVxOwotCQkJcF9ic3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQtPmJzc2lkOwotCQkJcm9sZV9uYW1lID0gImNsaWVudCI7Ci0JCX0gZWxzZQotCQkJcmV0dXJuIEZBTFNFOwotCQlicmVhazsKLQljYXNlIFdQQVNfUDJQX1JPTEVfR086Ci0JCS8qIGFwX2lmYWNlIGlzIG9ubHkgdmFsaWQgZm9yIGEgR08gKi8KLQkJaWYgKHdwYV9zLT5hcF9pZmFjZSkgewotCQkJaGFwZCA9IHdwYV9zLT5hcF9pZmFjZS0+YnNzWzBdOwotCQkJcF9ic3NpZCA9IGhhcGQtPm93bl9hZGRyOwotCQkJb3BfZnJlcSA9IHdwYV9zLT5hcF9pZmFjZS0+ZnJlcTsKLQkJCXJvbGVfbmFtZSA9ICJHTyI7Ci0JCX0gZWxzZQotCQkJcmV0dXJuIEZBTFNFOwotCQlicmVhazsKLQlkZWZhdWx0OgotCQkvKiBFcnJvciBjb25kaXRpb247IHRoaXMgc2hvdWxkIE5FVkVSIG9jY3VyICovCi0JCXJldHVybiBGQUxTRTsKLQl9Ci0KLQlpZiAoIWRidXNfbWVzc2FnZV9pdGVyX29wZW5fY29udGFpbmVyKGl0ZXIsIERCVVNfVFlQRV9WQVJJQU5ULAotCQkJCQkgICAgICAiYXtzdn0iLCAmdmFyaWFudF9pdGVyKSB8fAotCSAgICAhd3BhX2RidXNfZGljdF9vcGVuX3dyaXRlKCZ2YXJpYW50X2l0ZXIsICZkaWN0X2l0ZXIpKQotCQlnb3RvIGVycl9ub19tZW07Ci0JLyogUHJvdmlkZSB0aGUgU1NJRCAqLwotCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfYnl0ZV9hcnJheSgKLQkJICAgICZkaWN0X2l0ZXIsICJTU0lEIiwKLQkJICAgIChjb25zdCBjaGFyICopIHdwYV9zLT5jdXJyZW50X3NzaWQtPnNzaWQsCi0JCSAgICB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkX2xlbikpCi0JCWdvdG8gZXJyX25vX21lbTsKLQkvKiBQcm92aWRlIHRoZSBCU1NJRCAqLwotCWlmIChwX2Jzc2lkICYmCi0JICAgICF3cGFfZGJ1c19kaWN0X2FwcGVuZF9ieXRlX2FycmF5KCZkaWN0X2l0ZXIsICJCU1NJRCIsCi0JCQkJCSAgICAgKGNvbnN0IGNoYXIgKikgcF9ic3NpZCwgRVRIX0FMRU4pKQotCQlnb3RvIGVycl9ub19tZW07Ci0JLyogUHJvdmlkZSB0aGUgcm9sZSB3aXRoaW4gdGhlIGdyb3VwICovCi0JaWYgKHJvbGVfbmFtZSAmJgotCSAgICAhd3BhX2RidXNfZGljdF9hcHBlbmRfc3RyaW5nKCZkaWN0X2l0ZXIsICJSb2xlIiwgcm9sZV9uYW1lKSkKLQkJZ290byBlcnJfbm9fbWVtOwotCS8qIFByb3ZpZGUgdGhlIG9wZXJhdGlvbmFsIGZyZXF1ZW5jeSAqLwotCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfdWludDE2KCZkaWN0X2l0ZXIsICJGcmVxdWVuY3kiLCBvcF9mcmVxKSkKLQkJZ290byBlcnJfbm9fbWVtOwotCi0JLyogQWRkaXRpb25hbCBpbmZvcm1hdGlvbiBmb3IgZ3JvdXAgb3duZXJzICovCisJLyogVmVyaWZ5IGNvcnJlY3Qgcm9sZSBmb3IgdGhpcyBwcm9wZXJ0eSAqLwogCWlmIChyb2xlID09IFdQQVNfUDJQX1JPTEVfR08pIHsKLQkJLyogUHJvdmlkZSB0aGUgcGFzc3BocmFzZSAqLwotCQlpZiAoIXdwYV9kYnVzX2RpY3RfYXBwZW5kX3N0cmluZygmZGljdF9pdGVyLCAiUGFzc3BocmFzZSIsCi0JCQkJCXdwYV9zLT5jdXJyZW50X3NzaWQtPnBhc3NwaHJhc2UpKQotCQkJZ290byBlcnJfbm9fbWVtOwotCQkvKiBQYXJzZSBXUFMgVmVuZG9yIEV4dGVuc2lvbnMgc2VudCBpbiBCZWFjb24vUHJvYmUgUmVzcG9uc2UgKi8KLQkJZm9yIChpID0gMDsgaGFwZCAmJiBpIDwgTUFYX1dQU19WRU5ET1JfRVhURU5TSU9OUzsgaSsrKSB7Ci0JCQlpZiAoaGFwZC0+Y29uZi0+d3BzX3ZlbmRvcl9leHRbaV0gPT0gTlVMTCkKLQkJCQljb250aW51ZTsKLQkJCXZlbmRvcl9leHRbbnVtX3ZlbmRvcl9leHQrK10gPQotCQkJCWhhcGQtPmNvbmYtPndwc192ZW5kb3JfZXh0W2ldOwotCQl9Ci0JCWlmICghd3BhX2RidXNfZGljdF9hcHBlbmRfd3BhYnVmX2FycmF5KCZkaWN0X2l0ZXIsCi0JCQkJCSJXUFNWZW5kb3JFeHRlbnNpb25zIiwKLQkJCQkJdmVuZG9yX2V4dCwgbnVtX3ZlbmRvcl9leHQpKQotCQkJZ290byBlcnJfbm9fbWVtOwotCX0gZWxzZSB7Ci0JCS8qIElmIG5vdCBhIEdPLCBwcm92aWRlIHRoZSBQU0sgKi8KLQkJaWYgKCF3cGFfZGJ1c19kaWN0X2FwcGVuZF9ieXRlX2FycmF5KAotCQkJICAgICZkaWN0X2l0ZXIsICJQU0siLAotCQkJICAgIChjb25zdCBjaGFyICopIHdwYV9zLT5jdXJyZW50X3NzaWQtPnBzaywgMzIpKQotCQkJZ290byBlcnJfbm9fbWVtOwotCX0KKwkJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gTlVMTCkKKwkJCXJldHVybiBGQUxTRTsKKwkJcF9wYXNzID0gd3BhX3MtPmN1cnJlbnRfc3NpZC0+cGFzc3BocmFzZTsKKwl9IGVsc2UKKwkJcF9wYXNzID0gIiI7CiAKLQlpZiAoIXdwYV9kYnVzX2RpY3RfY2xvc2Vfd3JpdGUoJnZhcmlhbnRfaXRlciwgJmRpY3RfaXRlcikgfHwKLQkgICAgIWRidXNfbWVzc2FnZV9pdGVyX2Nsb3NlX2NvbnRhaW5lcihpdGVyLCAmdmFyaWFudF9pdGVyKSkKLQkJZ290byBlcnJfbm9fbWVtOworCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX3Byb3BlcnR5X2dldHRlcihpdGVyLCBEQlVTX1RZUEVfU1RSSU5HLAorCQkJCQkJJnBfcGFzcywgZXJyb3IpOwogCi0JcmV0dXJuIFRSVUU7Ci0KLWVycl9ub19tZW06Ci0JZGJ1c19zZXRfZXJyb3JfY29uc3QoZXJyb3IsIERCVVNfRVJST1JfTk9fTUVNT1JZLCAibm8gbWVtb3J5Iik7Ci0JcmV0dXJuIEZBTFNFOwogfQogCiAKLWRidXNfYm9vbF90IHdwYXNfZGJ1c19zZXR0ZXJfcDJwX2dyb3VwX3Byb3BlcnRpZXMoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXBfcHNrKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJICAgREJ1c0Vycm9yICplcnJvciwgdm9pZCAqdXNlcl9kYXRhKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSB1c2VyX2RhdGE7CisJdTggcm9sZSA9IHdwYXNfZ2V0X3AycF9yb2xlKHdwYV9zKTsKKwl1OCAqcF9wc2sgPSBOVUxMOworCXU4IHBza19sZW4gPSAwOworCisJLyogVmVyaWZ5IGNvcnJlY3Qgcm9sZSBmb3IgdGhpcyBwcm9wZXJ0eSAqLworCWlmIChyb2xlID09IFdQQVNfUDJQX1JPTEVfQ0xJRU5UKSB7CisJCWlmICh3cGFfcy0+Y3VycmVudF9zc2lkID09IE5VTEwpCisJCQlyZXR1cm4gRkFMU0U7CisJCXBfcHNrID0gd3BhX3MtPmN1cnJlbnRfc3NpZC0+cHNrOworCQlwc2tfbGVuID0gMzI7CisJfQorCisJcmV0dXJuIHdwYXNfZGJ1c19zaW1wbGVfYXJyYXlfcHJvcGVydHlfZ2V0dGVyKGl0ZXIsIERCVVNfVFlQRV9CWVRFLAorCQkJCQkJICAgICAgJnBfcHNrLCBwc2tfbGVuLCBlcnJvcik7Cit9CisKKworZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfZ3JvdXBfdmVuZG9yX2V4dChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCQkgIERCdXNFcnJvciAqZXJyb3IsCisJCQkJCQkgIHZvaWQgKnVzZXJfZGF0YSkKK3sKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zID0gdXNlcl9kYXRhOworCXN0cnVjdCBob3N0YXBkX2RhdGEgKmhhcGQ7CisJc3RydWN0IHdwYWJ1ZiAqdmVuZG9yX2V4dFtNQVhfV1BTX1ZFTkRPUl9FWFRFTlNJT05TXTsKKwlpbnQgbnVtX3ZlbmRvcl9leHQgPSAwOworCWludCBpOworCisJLyogVmVyaWZ5IGNvcnJlY3Qgcm9sZSBmb3IgdGhpcyBwcm9wZXJ0eSAqLworCWlmICh3cGFzX2dldF9wMnBfcm9sZSh3cGFfcykgPT0gV1BBU19QMlBfUk9MRV9HTykgeworCQlpZiAod3BhX3MtPmFwX2lmYWNlID09IE5VTEwpCisJCQlyZXR1cm4gRkFMU0U7CisJCWhhcGQgPSB3cGFfcy0+YXBfaWZhY2UtPmJzc1swXTsKKworCQkvKiBQYXJzZSBXUFMgVmVuZG9yIEV4dGVuc2lvbnMgc2VudCBpbiBCZWFjb24vUHJvYmUgUmVzcG9uc2UgKi8KKwkJZm9yIChpID0gMDsgaSA8IE1BWF9XUFNfVkVORE9SX0VYVEVOU0lPTlM7IGkrKykgeworCQkJaWYgKGhhcGQtPmNvbmYtPndwc192ZW5kb3JfZXh0W2ldID09IE5VTEwpCisJCQkJdmVuZG9yX2V4dFtpXSA9IE5VTEw7CisJCQllbHNlIHsKKwkJCQl2ZW5kb3JfZXh0W251bV92ZW5kb3JfZXh0KytdID0KKwkJCQkJaGFwZC0+Y29uZi0+d3BzX3ZlbmRvcl9leHRbaV07CisJCQl9CisJCX0KKwl9CisKKwkvKiBSZXR1cm4gdmVuZG9yIGV4dGVuc2lvbnMgb3Igbm8gZGF0YSAqLworCXJldHVybiB3cGFzX2RidXNfc2ltcGxlX2FycmF5X2FycmF5X3Byb3BlcnR5X2dldHRlcihpdGVyLAorCQkJCQkJCSAgICBEQlVTX1RZUEVfQllURSwKKwkJCQkJCQkgICAgdmVuZG9yX2V4dCwKKwkJCQkJCQkgICAgbnVtX3ZlbmRvcl9leHQsCisJCQkJCQkgZXJyb3IpOworfQorCisKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19zZXR0ZXJfcDJwX2dyb3VwX3ZlbmRvcl9leHQoREJ1c01lc3NhZ2VJdGVyICppdGVyLAogCQkJCQkJICBEQnVzRXJyb3IgKmVycm9yLAogCQkJCQkJICB2b2lkICp1c2VyX2RhdGEpCiB7CkBAIC0xOTc4LDcgKzIwNjksNyBAQAogCWlmICghd3BhX2RidXNfZGljdF9vcGVuX3JlYWQoJml0ZXIsICZpdGVyX2RpY3QsIE5VTEwpKQogCQlnb3RvIGVycm9yOwogCi0JaWYgKHdwYV9kYnVzX2RpY3RfaGFzX2RpY3RfZW50cnkoJml0ZXJfZGljdCkpIHsKKwl3aGlsZSAod3BhX2RidXNfZGljdF9oYXNfZGljdF9lbnRyeSgmaXRlcl9kaWN0KSkgewogCQlpZiAoIXdwYV9kYnVzX2RpY3RfZ2V0X2VudHJ5KCZpdGVyX2RpY3QsICZlbnRyeSkpCiAJCQlnb3RvIGVycm9yOwogCkBAIC0xOTkwLDIzICsyMDgxLDMwIEBACiAJCQkJYm9uam91ciA9IDE7CiAJCQllbHNlCiAJCQkJZ290byBlcnJvcl9jbGVhcjsKLQkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKKwkJfSBlbHNlIGlmICghb3Nfc3RyY21wKGVudHJ5LmtleSwgInZlcnNpb24iKSAmJgorCQkgICAgICAgICAgIGVudHJ5LnR5cGUgPT0gREJVU19UWVBFX0lOVDMyKSB7CisJCQl2ZXJzaW9uID0gZW50cnkudWludDMyX3ZhbHVlOworCQl9IGVsc2UgaWYgKCFvc19zdHJjbXAoZW50cnkua2V5LCAic2VydmljZSIpICYmCisJCQkgICAgIChlbnRyeS50eXBlID09IERCVVNfVFlQRV9TVFJJTkcpKSB7CisJCQlzZXJ2aWNlID0gb3Nfc3RyZHVwKGVudHJ5LnN0cl92YWx1ZSk7CisJCX0gZWxzZSBpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJxdWVyeSIpKSB7CisJCQlpZiAoKGVudHJ5LnR5cGUgIT0gREJVU19UWVBFX0FSUkFZKSB8fAorCQkJICAgIChlbnRyeS5hcnJheV90eXBlICE9IERCVVNfVFlQRV9CWVRFKSkKKwkJCQlnb3RvIGVycm9yX2NsZWFyOworCQkJcXVlcnkgPSB3cGFidWZfYWxsb2NfY29weSgKKwkJCQllbnRyeS5ieXRlYXJyYXlfdmFsdWUsCisJCQkJZW50cnkuYXJyYXlfbGVuKTsKKwkJfSBlbHNlIGlmICghb3Nfc3RyY21wKGVudHJ5LmtleSwgInJlc3BvbnNlIikpIHsKKwkJCWlmICgoZW50cnkudHlwZSAhPSBEQlVTX1RZUEVfQVJSQVkpIHx8CisJCQkgICAgKGVudHJ5LmFycmF5X3R5cGUgIT0gREJVU19UWVBFX0JZVEUpKQorCQkJCWdvdG8gZXJyb3JfY2xlYXI7CisJCQlyZXNwID0gd3BhYnVmX2FsbG9jX2NvcHkoZW50cnkuYnl0ZWFycmF5X3ZhbHVlLAorCQkJCQkJIGVudHJ5LmFycmF5X2xlbik7CiAJCX0KKwkJd3BhX2RidXNfZGljdF9lbnRyeV9jbGVhcigmZW50cnkpOwogCX0KIAogCWlmICh1cG5wID09IDEpIHsKLQkJd2hpbGUgKHdwYV9kYnVzX2RpY3RfaGFzX2RpY3RfZW50cnkoJml0ZXJfZGljdCkpIHsKLQkJCWlmICghd3BhX2RidXNfZGljdF9nZXRfZW50cnkoJml0ZXJfZGljdCwgJmVudHJ5KSkKLQkJCQlnb3RvIGVycm9yOwotCi0JCQlpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJ2ZXJzaW9uIikgJiYKLQkJCSAgICBlbnRyeS50eXBlID09IERCVVNfVFlQRV9JTlQzMikKLQkJCQl2ZXJzaW9uID0gZW50cnkudWludDMyX3ZhbHVlOwotCQkJZWxzZSBpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJzZXJ2aWNlIikgJiYKLQkJCQkgZW50cnkudHlwZSA9PSBEQlVTX1RZUEVfU1RSSU5HKQotCQkJCXNlcnZpY2UgPSBvc19zdHJkdXAoZW50cnkuc3RyX3ZhbHVlKTsKLQkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKLQkJfQogCQlpZiAodmVyc2lvbiA8PSAwIHx8IHNlcnZpY2UgPT0gTlVMTCkKIAkJCWdvdG8gZXJyb3I7CiAKQEAgLTIwMTQsMzcgKzIxMTIsMTUgQEAKIAkJCWdvdG8gZXJyb3I7CiAKIAkJb3NfZnJlZShzZXJ2aWNlKTsKKwkJc2VydmljZSA9IE5VTEw7CiAJfSBlbHNlIGlmIChib25qb3VyID09IDEpIHsKLQkJd2hpbGUgKHdwYV9kYnVzX2RpY3RfaGFzX2RpY3RfZW50cnkoJml0ZXJfZGljdCkpIHsKLQkJCWlmICghd3BhX2RidXNfZGljdF9nZXRfZW50cnkoJml0ZXJfZGljdCwgJmVudHJ5KSkKLQkJCQlnb3RvIGVycm9yOwotCi0JCQlpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJxdWVyeSIpKSB7Ci0JCQkJaWYgKChlbnRyeS50eXBlICE9IERCVVNfVFlQRV9BUlJBWSkgfHwKLQkJCQkgICAgKGVudHJ5LmFycmF5X3R5cGUgIT0gREJVU19UWVBFX0JZVEUpKQotCQkJCQlnb3RvIGVycm9yX2NsZWFyOwotCQkJCXF1ZXJ5ID0gd3BhYnVmX2FsbG9jX2NvcHkoCi0JCQkJCWVudHJ5LmJ5dGVhcnJheV92YWx1ZSwKLQkJCQkJZW50cnkuYXJyYXlfbGVuKTsKLQkJCX0gZWxzZSBpZiAoIW9zX3N0cmNtcChlbnRyeS5rZXksICJyZXNwb25zZSIpKSB7Ci0JCQkJaWYgKChlbnRyeS50eXBlICE9IERCVVNfVFlQRV9BUlJBWSkgfHwKLQkJCQkgICAgKGVudHJ5LmFycmF5X3R5cGUgIT0gREJVU19UWVBFX0JZVEUpKQotCQkJCQlnb3RvIGVycm9yX2NsZWFyOwotCQkJCXJlc3AgPSB3cGFidWZfYWxsb2NfY29weShlbnRyeS5ieXRlYXJyYXlfdmFsdWUsCi0JCQkJCQkJIGVudHJ5LmFycmF5X2xlbik7Ci0JCQl9Ci0KLQkJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKLQkJfQotCiAJCWlmIChxdWVyeSA9PSBOVUxMIHx8IHJlc3AgPT0gTlVMTCkKIAkJCWdvdG8gZXJyb3I7CiAKLQkJaWYgKHdwYXNfcDJwX3NlcnZpY2VfYWRkX2JvbmpvdXIod3BhX3MsIHF1ZXJ5LCByZXNwKSA8IDApIHsKLQkJCXdwYWJ1Zl9mcmVlKHF1ZXJ5KTsKLQkJCXdwYWJ1Zl9mcmVlKHJlc3ApOworCQlpZiAod3Bhc19wMnBfc2VydmljZV9hZGRfYm9uam91cih3cGFfcywgcXVlcnksIHJlc3ApIDwgMCkKIAkJCWdvdG8gZXJyb3I7Ci0JCX0KKwkJcXVlcnkgPSBOVUxMOworCQlyZXNwID0gTlVMTDsKIAl9IGVsc2UKIAkJZ290byBlcnJvcjsKIApAQCAtMjA1Miw2ICsyMTI4LDkgQEAKIGVycm9yX2NsZWFyOgogCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIGVycm9yOgorCW9zX2ZyZWUoc2VydmljZSk7CisJd3BhYnVmX2ZyZWUocXVlcnkpOworCXdwYWJ1Zl9mcmVlKHJlc3ApOwogCXJldHVybiB3cGFzX2RidXNfZXJyb3JfaW52YWxpZF9hcmdzKG1lc3NhZ2UsIE5VTEwpOwogfQogCkBAIC0yMTcwLDcgKzIyNDksNyBAQAogCXN0cnVjdCB3cGFidWYgKnRsdiA9IE5VTEw7CiAJdTggdmVyc2lvbiA9IDA7CiAJdTY0IHJlZiA9IDA7Ci0JdTggYWRkcltFVEhfQUxFTl07CisJdTggYWRkcl9idWZbRVRIX0FMRU5dLCAqYWRkcjsKIAogCWRidXNfbWVzc2FnZV9pdGVyX2luaXQobWVzc2FnZSwgJml0ZXIpOwogCkBAIC0yMjA3LDEwICsyMjg2LDE1IEBACiAJCXdwYV9kYnVzX2RpY3RfZW50cnlfY2xlYXIoJmVudHJ5KTsKIAl9CiAKLQlpZiAoIXBlZXJfb2JqZWN0X3BhdGggfHwKLQkgICAgKHBhcnNlX3BlZXJfb2JqZWN0X3BhdGgocGVlcl9vYmplY3RfcGF0aCwgYWRkcikgPCAwKSB8fAotCSAgICAhcDJwX3BlZXJfa25vd24od3BhX3MtPmdsb2JhbC0+cDJwLCBhZGRyKSkKLQkJZ290byBlcnJvcjsKKwlpZiAoIXBlZXJfb2JqZWN0X3BhdGgpIHsKKwkJYWRkciA9IE5VTEw7CisJfSBlbHNlIHsKKwkJaWYgKHBhcnNlX3BlZXJfb2JqZWN0X3BhdGgocGVlcl9vYmplY3RfcGF0aCwgYWRkcl9idWYpIDwgMCB8fAorCQkgICAgIXAycF9wZWVyX2tub3duKHdwYV9zLT5nbG9iYWwtPnAycCwgYWRkcl9idWYpKQorCQkJZ290byBlcnJvcjsKKworCQlhZGRyID0gYWRkcl9idWY7CisJfQogCiAJaWYgKHVwbnAgPT0gMSkgewogCQlpZiAodmVyc2lvbiA8PSAwIHx8IHNlcnZpY2UgPT0gTlVMTCkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfcDJwLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3AycC5oCmluZGV4IDI5M2ViNmIuLmExMWIzYzggMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfcDJwLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVyc19wMnAuaApAQCAtMSwxNSArMSw5IEBACi0KIC8qCiAgKiBXUEEgU3VwcGxpY2FudCAvIGRidXMtYmFzZWQgY29udHJvbCBpbnRlcmZhY2UgZm9yIHAycAorICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTIsIEludGVsIENvcnBvcmF0aW9uCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBEQlVTX05FV19IQU5ETEVSU19QMlBfSApAQCAtOTQsMTMgKzg4LDEzIEBACiAvKgogICogUDJQIERldmljZSBwcm9wZXJ0eSBhY2Nlc3NvciBtZXRob2RzLgogICovCi1kYnVzX2Jvb2xfdCB3cGFzX2RidXNfc2V0dGVyX3AycF9kZXZpY2VfcHJvcGVydGllcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCi0JCQkJCQkgICBEQnVzRXJyb3IgKmVycm9yLAotCQkJCQkJICAgdm9pZCAqdXNlcl9kYXRhKTsKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19zZXR0ZXJfcDJwX2RldmljZV9jb25maWcoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkgICAgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgICAgIHZvaWQgKnVzZXJfZGF0YSk7CiAKLWRidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2RldmljZV9wcm9wZXJ0aWVzKERCdXNNZXNzYWdlSXRlciAqaXRlciwKLQkJCQkJCSAgIERCdXNFcnJvciAqZXJyb3IsCi0JCQkJCQkgICB2b2lkICp1c2VyX2RhdGEpOworZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfZGV2aWNlX2NvbmZpZyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCSAgICAgICBEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkgICAgICAgdm9pZCAqdXNlcl9kYXRhKTsKIAogZGJ1c19ib29sX3Qgd3Bhc19kYnVzX2dldHRlcl9wMnBfcGVlcnMoREJ1c01lc3NhZ2VJdGVyICppdGVyLCBEQnVzRXJyb3IgKmVycm9yLAogCQkJCSAgICAgICB2b2lkICp1c2VyX2RhdGEpOwpAQCAtMTYxLDExICsxNTUsMzEgQEAKIAkJCQkJICAgICAgIERCdXNFcnJvciAqZXJyb3IsCiAJCQkJCSAgICAgICB2b2lkICp1c2VyX2RhdGEpOwogCi1kYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9wcm9wZXJ0aWVzKERCdXNNZXNzYWdlSXRlciAqaXRlciwKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX3NzaWQoREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkgICAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJICAgIHZvaWQgKnVzZXJfZGF0YSk7CisKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX2Jzc2lkKERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJICAgICBEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkgICAgIHZvaWQgKnVzZXJfZGF0YSk7CisKK2RidXNfYm9vbF90IHdwYXNfZGJ1c19nZXR0ZXJfcDJwX2dyb3VwX2ZyZXF1ZW5jeShEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCisJCQkJCQkgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJCSB2b2lkICp1c2VyX2RhdGEpOworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9wYXNzcGhyYXNlKERCdXNNZXNzYWdlSXRlciAqaXRlciwKIAkJCQkJCSAgREJ1c0Vycm9yICplcnJvciwKIAkJCQkJCSAgdm9pZCAqdXNlcl9kYXRhKTsKIAotZGJ1c19ib29sX3Qgd3Bhc19kYnVzX3NldHRlcl9wMnBfZ3JvdXBfcHJvcGVydGllcyhEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF9wc2soREJ1c01lc3NhZ2VJdGVyICppdGVyLAorCQkJCQkgICBEQnVzRXJyb3IgKmVycm9yLAorCQkJCQkgICB2b2lkICp1c2VyX2RhdGEpOworCitkYnVzX2Jvb2xfdCB3cGFzX2RidXNfZ2V0dGVyX3AycF9ncm91cF92ZW5kb3JfZXh0KERCdXNNZXNzYWdlSXRlciAqaXRlciwKKwkJCQkJCSAgREJ1c0Vycm9yICplcnJvciwKKwkJCQkJCSAgdm9pZCAqdXNlcl9kYXRhKTsKKworZGJ1c19ib29sX3Qgd3Bhc19kYnVzX3NldHRlcl9wMnBfZ3JvdXBfdmVuZG9yX2V4dChEQnVzTWVzc2FnZUl0ZXIgKml0ZXIsCiAJCQkJCQkgIERCdXNFcnJvciAqZXJyb3IsCiAJCQkJCQkgIHZvaWQgKnVzZXJfZGF0YSk7CiAKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfd3BzLmMgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hhbmRsZXJzX3dwcy5jCmluZGV4IGE3MmNmYjMuLjg0ODljZTcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaGFuZGxlcnNfd3BzLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oYW5kbGVyc193cHMuYwpAQCAtMywxNCArMyw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDYsIERhbiBXaWxsaWFtcyA8ZGNid0ByZWRoYXQuY29tPiBhbmQgUmVkIEhhdCwgSW5jLgogICogQ29weXJpZ2h0IChjKSAyMDA5LCBXaXRvbGQgU293YSA8d2l0b2xkLnNvd2FAZ21haWwuY29tPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJpbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oZWxwZXJzLmMgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuYwppbmRleCBlMjU0MzY1Li5jZmE2YTE1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuYwpAQCAtMywxNCArMyw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDYsIERhbiBXaWxsaWFtcyA8ZGNid0ByZWRoYXQuY29tPiBhbmQgUmVkIEhhdCwgSW5jLgogICogQ29weXJpZ2h0IChjKSAyMDA5LCBXaXRvbGQgU293YSA8d2l0b2xkLnNvd2FAZ21haWwuY29tPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlICJ1dGlscy9pbmNsdWRlcy5oIgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX25ld19oZWxwZXJzLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuaAppbmRleCBkNmU3YjQ4Li42ZDMxYWQ1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuaAorKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2hlbHBlcnMuaApAQCAtMywxNCArMyw4IEBACiAgKiBDb3B5cmlnaHQgKGMpIDIwMDYsIERhbiBXaWxsaWFtcyA8ZGNid0ByZWRoYXQuY29tPiBhbmQgUmVkIEhhdCwgSW5jLgogICogQ29weXJpZ2h0IChjKSAyMDA5LCBXaXRvbGQgU293YSA8d2l0b2xkLnNvd2FAZ21haWwuY29tPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpZm5kZWYgV1BBX0RCVVNfQ1RSTF9ICmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfbmV3X2ludHJvc3BlY3QuYyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaW50cm9zcGVjdC5jCmluZGV4IGQ0NDMyNjkuLjNiMDkwYzAgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaW50cm9zcGVjdC5jCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19uZXdfaW50cm9zcGVjdC5jCkBAIC00LDE0ICs0LDggQEAKICAqIENvcHlyaWdodCAoYykgMjAwOSwgV2l0b2xkIFNvd2EgPHdpdG9sZC5zb3dhQGdtYWlsLmNvbT4KICAqIENvcHlyaWdodCAoYykgMjAxMCwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGQuYyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGQuYwppbmRleCA3MWFiNjFlLi41ZjI5OGU3IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZC5jCkBAIC0yLDE0ICsyLDggQEAKICAqIFdQQSBTdXBwbGljYW50IC8gZGJ1cy1iYXNlZCBjb250cm9sIGludGVyZmFjZQogICogQ29weXJpZ2h0IChjKSAyMDA2LCBEYW4gV2lsbGlhbXMgPGRjYndAcmVkaGF0LmNvbT4gYW5kIFJlZCBIYXQsIEluYy4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaW5jbHVkZSAiaW5jbHVkZXMuaCIKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGQuaCBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGQuaAppbmRleCA5NTIzODY3Li5lNjY4MjMxIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZC5oCkBAIC0yLDE0ICsyLDggQEAKICAqIFdQQSBTdXBwbGljYW50IC8gZGJ1cy1iYXNlZCBjb250cm9sIGludGVyZmFjZQogICogQ29weXJpZ2h0IChjKSAyMDA2LCBEYW4gV2lsbGlhbXMgPGRjYndAcmVkaGF0LmNvbT4gYW5kIFJlZCBIYXQsIEluYy4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaWZuZGVmIENUUkxfSUZBQ0VfREJVU19ICmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzLmMgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzLmMKaW5kZXggODM3MGE5NS4uZTIxN2E3MiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZF9oYW5kbGVycy5jCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGRfaGFuZGxlcnMuYwpAQCAtMiwxNCArMiw4IEBACiAgKiBXUEEgU3VwcGxpY2FudCAvIGRidXMtYmFzZWQgY29udHJvbCBpbnRlcmZhY2UKICAqIENvcHlyaWdodCAoYykgMjAwNiwgRGFuIFdpbGxpYW1zIDxkY2J3QHJlZGhhdC5jb20+IGFuZCBSZWQgSGF0LCBJbmMuCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2luY2x1ZGUgImluY2x1ZGVzLmgiCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzLmggYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzLmgKaW5kZXggMDA5ZTgwNy4uODI1YmM2ZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZF9oYW5kbGVycy5oCisrKyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGRfaGFuZGxlcnMuaApAQCAtMiwxNCArMiw4IEBACiAgKiBXUEEgU3VwcGxpY2FudCAvIGRidXMtYmFzZWQgY29udHJvbCBpbnRlcmZhY2UKICAqIENvcHlyaWdodCAoYykgMjAwNiwgRGFuIFdpbGxpYW1zIDxkY2J3QHJlZGhhdC5jb20+IGFuZCBSZWQgSGF0LCBJbmMuCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBDVFJMX0lGQUNFX0RCVVNfSEFORExFUlNfSApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZF9oYW5kbGVyc193cHMuYyBiL3dwYV9zdXBwbGljYW50L2RidXMvZGJ1c19vbGRfaGFuZGxlcnNfd3BzLmMKaW5kZXggYzA0Yjg0NC4uYmI3OTM4MiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZGJ1cy9kYnVzX29sZF9oYW5kbGVyc193cHMuYworKysgYi93cGFfc3VwcGxpY2FudC9kYnVzL2RidXNfb2xkX2hhbmRsZXJzX3dwcy5jCkBAIC0yLDE0ICsyLDggQEAKICAqIFdQQSBTdXBwbGljYW50IC8gZGJ1cy1iYXNlZCBjb250cm9sIGludGVyZmFjZSAoV1BTKQogICogQ29weXJpZ2h0IChjKSAyMDA2LCBEYW4gV2lsbGlhbXMgPGRjYndAcmVkaGF0LmNvbT4gYW5kIFJlZCBIYXQsIEluYy4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICoKLSAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiBCU0QKLSAqIGxpY2Vuc2UuCi0gKgotICogU2VlIFJFQURNRSBhbmQgQ09QWUlORyBmb3IgbW9yZSBkZXRhaWxzLgorICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KKyAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICAqLwogCiAjaW5jbHVkZSAiaW5jbHVkZXMuaCIKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RlZmNvbmZpZyBiL3dwYV9zdXBwbGljYW50L2RlZmNvbmZpZwppbmRleCA0ODBiYzY0Li5mZTE0MDFmIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kZWZjb25maWcKKysrIGIvd3BhX3N1cHBsaWNhbnQvZGVmY29uZmlnCkBAIC0yMDQsNiArMjA0LDggQEAKICMgRGlzYWJsZSBjcmVkZW50aWFscyBmb3IgYW4gb3BlbiBuZXR3b3JrIGJ5IGRlZmF1bHQgd2hlbiBhY3RpbmcgYXMgYSBXUFMKICMgcmVnaXN0cmFyLgogI0NPTkZJR19XUFNfUkVHX0RJU0FCTEVfT1BFTj15CisjIEVuYWJsZSBXUFMgc3VwcG9ydCB3aXRoIE5GQyBjb25maWcgbWV0aG9kCisjQ09ORklHX1dQU19ORkM9eQogCiAjIEVBUC1JS0V2MgogI0NPTkZJR19FQVBfSUtFVjI9eQpAQCAtMzIxLDkgKzMyMyw3IEBACiAjIFBlZXJLZXkgaGFuZHNoYWtlIGZvciBTdGF0aW9uIHRvIFN0YXRpb24gTGluayAoSUVFRSA4MDIuMTFlIERMUykKIENPTkZJR19QRUVSS0VZPXkKIAotIyBJRUVFIDgwMi4xMXcgKG1hbmFnZW1lbnQgZnJhbWUgcHJvdGVjdGlvbikKLSMgVGhpcyB2ZXJzaW9uIGlzIGFuIGV4cGVyaW1lbnRhbCBpbXBsZW1lbnRhdGlvbiBiYXNlZCBvbiBJRUVFIDgwMi4xMXcvRDEuMAotIyBkcmFmdCBhbmQgaXMgc3ViamVjdCB0byBjaGFuZ2Ugc2luY2UgdGhlIHN0YW5kYXJkIGhhcyBub3QgeWV0IGJlZW4gZmluYWxpemVkLgorIyBJRUVFIDgwMi4xMXcgKG1hbmFnZW1lbnQgZnJhbWUgcHJvdGVjdGlvbiksIGFsc28ga25vd24gYXMgUE1GCiAjIERyaXZlciBzdXBwb3J0IGlzIGFsc28gbmVlZGVkIGZvciBJRUVFIDgwMi4xMXcuCiAjQ09ORklHX0lFRUU4MDIxMVc9eQogCkBAIC00MTMsNiArNDEzLDEyIEBACiAjIFNldCBzeXNsb2cgZmFjaWxpdHkgZm9yIGRlYnVnIG1lc3NhZ2VzCiAjQ09ORklHX0RFQlVHX1NZU0xPR19GQUNJTElUWT1MT0dfREFFTU9OCiAKKyMgQWRkIHN1cHBvcnQgZm9yIHNlbmRpbmcgYWxsIGRlYnVnIG1lc3NhZ2VzIChyZWdhcmRsZXNzIG9mIGRlYnVnIHZlcmJvc2l0eSkKKyMgdG8gdGhlIExpbnV4IGtlcm5lbCB0cmFjaW5nIGZhY2lsaXR5LiBUaGlzIGhlbHBzIGRlYnVnIHRoZSBlbnRpcmUgc3RhY2sgYnkKKyMgbWFraW5nIGl0IGVhc3kgdG8gcmVjb3JkIGV2ZXJ5dGhpbmcgaGFwcGVuaW5nIGZyb20gdGhlIGRyaXZlciB1cCBpbnRvIHRoZQorIyBzYW1lIGZpbGUsIGUuZy4sIHVzaW5nIHRyYWNlLWNtZC4KKyNDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORz15CisKICMgRW5hYmxlIHByaXZpbGVnZSBzZXBhcmF0aW9uIChzZWUgUkVBRE1FICdQcml2aWxlZ2Ugc2VwYXJhdGlvbicgZm9yIGRldGFpbHMpCiAjQ09ORklHX1BSSVZTRVA9eQogCkBAIC00MjQsNyArNDMwLDcgQEAKICMgVGhpcyB0cmFja3MgdXNlIG9mIG1lbW9yeSBhbGxvY2F0aW9ucyBhbmQgb3RoZXIgcmVnaXN0cmF0aW9ucyBhbmQgcmVwb3J0cwogIyBpbmNvcnJlY3QgdXNlIHdpdGggYSBiYWNrdHJhY2Ugb2YgY2FsbCAob3IgYWxsb2NhdGlvbikgbG9jYXRpb24uCiAjQ09ORklHX1dQQV9UUkFDRT15Ci0jIEZvciBCU0QsIGNvbW1lbnQgb3V0IHRoZXNlLgorIyBGb3IgQlNELCB1bmNvbW1lbnQgdGhlc2UuCiAjTElCUyArPSAtbGV4ZWNpbmZvCiAjTElCU19wICs9IC1sZXhlY2luZm8KICNMSUJTX2MgKz0gLWxleGVjaW5mbwpAQCAtNDMzLDcgKzQzOSw3IEBACiAjIFRoaXMgZW5hYmxlcyB1c2Ugb2YgbGliYmZkIHRvIGdldCBtb3JlIGRldGFpbGVkIHN5bWJvbHMgZm9yIHRoZSBiYWNrdHJhY2VzCiAjIGdlbmVyYXRlZCBieSBDT05GSUdfV1BBX1RSQUNFPXkuCiAjQ09ORklHX1dQQV9UUkFDRV9CRkQ9eQotIyBGb3IgQlNELCBjb21tZW50IG91dCB0aGVzZS4KKyMgRm9yIEJTRCwgdW5jb21tZW50IHRoZXNlLgogI0xJQlMgKz0gLWxiZmQgLWxpYmVydHkgLWx6CiAjTElCU19wICs9IC1sYmZkIC1saWJlcnR5IC1segogI0xJQlNfYyArPSAtbGJmZCAtbGliZXJ0eSAtbHoKQEAgLTQ3Miw4ICs0NzgsMzcgQEAKICMgSUVFRSA4MDIuMTFuIChIaWdoIFRocm91Z2hwdXQpIHN1cHBvcnQgKG1haW5seSBmb3IgQVAgbW9kZSkKICNDT05GSUdfSUVFRTgwMjExTj15CiAKKyMgV2lyZWxlc3MgTmV0d29yayBNYW5hZ2VtZW50IChJRUVFIFN0ZCA4MDIuMTF2LTIwMTEpCisjIE5vdGU6IFRoaXMgaXMgZXhwZXJpbWVudGFsIGFuZCBub3QgY29tcGxldGUgaW1wbGVtZW50YXRpb24uCisjQ09ORklHX1dOTT15CisKICMgSW50ZXJ3b3JraW5nIChJRUVFIDgwMi4xMXUpCiAjIFRoaXMgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIGZ1bmN0aW9uYWxpdHkgdG8gaW1wcm92ZSBpbnRlcndvcmtpbmcgd2l0aAogIyBleHRlcm5hbCBuZXR3b3JrcyAoR0FTL0FOUVAgdG8gbGVhcm4gbW9yZSBhYm91dCB0aGUgbmV0d29ya3MgYW5kIG5ldHdvcmsKICMgc2VsZWN0aW9uIGJhc2VkIG9uIGF2YWlsYWJsZSBjcmVkZW50aWFscykuCiAjQ09ORklHX0lOVEVSV09SS0lORz15CisKKyMgSG90c3BvdCAyLjAKKyNDT05GSUdfSFMyMD15CisKKyMgQVAgbW9kZSBvcGVyYXRpb25zIHdpdGggd3BhX3N1cHBsaWNhbnQKKyMgVGhpcyBjYW4gYmUgdXNlZCBmb3IgY29udHJvbGxpbmcgQVAgbW9kZSBvcGVyYXRpb25zIHdpdGggd3BhX3N1cHBsaWNhbnQuIEl0CisjIHNob3VsZCBiZSBub3RlZCB0aGF0IHRoaXMgaXMgbWFpbmx5IGFpbWVkIGF0IHNpbXBsZSBjYXNlcyBsaWtlCisjIFdQQTItUGVyc29uYWwgd2hpbGUgbW9yZSBjb21wbGV4IGNvbmZpZ3VyYXRpb25zIGxpa2UgV1BBMi1FbnRlcnByaXNlIHdpdGggYW4KKyMgZXh0ZXJuYWwgUkFESVVTIHNlcnZlciBjYW4gYmUgc3VwcG9ydGVkIHdpdGggaG9zdGFwZC4KKyNDT05GSUdfQVA9eQorCisjIFAyUCAoV2ktRmkgRGlyZWN0KQorIyBUaGlzIGNhbiBiZSB1c2VkIHRvIGVuYWJsZSBQMlAgc3VwcG9ydCBpbiB3cGFfc3VwcGxpY2FudC4gU2VlIFJFQURNRS1QMlAgZm9yCisjIG1vcmUgaW5mb3JtYXRpb24gb24gUDJQIG9wZXJhdGlvbnMuCisjQ09ORklHX1AyUD15CisKKyMgQXV0b3NjYW4KKyMgVGhpcyBjYW4gYmUgdXNlZCB0byBlbmFibGUgYXV0b21hdGljIHNjYW4gc3VwcG9ydCBpbiB3cGFfc3VwcGxpY2FudC4KKyOgU2VlIHdwYV9zdXBwbGljYW50LmNvbmYgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gYXV0b3NjYW4gdXNhZ2UuCisjCisjIEVuYWJsaW5nIGRpcmVjdGx5IGEgbW9kdWxlIHdpbGwgZW5hYmxlIGF1dG9zY2FuIHN1cHBvcnQuCisjIEZvciBleHBvbmVudGlhbCBtb2R1bGU6CisjQ09ORklHX0FVVE9TQ0FOX0VYUE9ORU5USUFMPXkKKyMgRm9yIHBlcmlvZGljIG1vZHVsZToKKyNDT05GSUdfQVVUT1NDQU5fUEVSSU9ESUM9eQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2JhY2tncm91bmQuc2dtbCBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9iYWNrZ3JvdW5kLnNnbWwKaW5kZXggZjQ3MjM1Yi4uZWIzYTA4OSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2JhY2tncm91bmQuc2dtbAorKysgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfYmFja2dyb3VuZC5zZ21sCkBAIC05MCwxMiArOTAsMTIgQEAKIAogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAwNywKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgogCi0gICAgPHBhcmE+VGhpcyBwcm9ncmFtIGlzIGR1YWwtbGljZW5zZWQgdW5kZXIgYm90aCB0aGUgR1BMIHZlcnNpb24gMgotICAgIGFuZCBCU0QgbGljZW5zZS4gRWl0aGVyIGxpY2Vuc2UgbWF5IGJlIHVzZWQgYXQgeW91ciBvcHRpb24uPC9wYXJhPgorICAgIDxwYXJhPlRoaXMgcHJvZ3JhbSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQlNEIGxpY2Vuc2UgKHRoZSBvbmUgd2l0aAorICAgIGFkdmVydGlzZW1lbnQgY2xhdXNlIHJlbW92ZWQpLjwvcGFyYT4KICAgPC9yZWZzZWN0MT4KIDwvcmVmZW50cnk+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfY2xpLnNnbWwgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfY2xpLnNnbWwKaW5kZXggMWZlOThmNC4uYzA4MGMwNyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2NsaS5zZ21sCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9jbGkuc2dtbApAQCAtMzI4LDEyICszMjgsMTIgQEAKICAgPC9yZWZzZWN0MT4KICAgPHJlZnNlY3QxPgogICAgIDx0aXRsZT5MZWdhbDwvdGl0bGU+Ci0gICAgPHBhcmE+d3BhX3N1cHBsaWNhbnQgaXMgY29weXJpZ2h0IChjKSAyMDAzLTIwMDcsCisgICAgPHBhcmE+d3BhX3N1cHBsaWNhbnQgaXMgY29weXJpZ2h0IChjKSAyMDAzLTIwMTIsCiAgICAgSm91bmkgTWFsaW5lbiA8ZW1haWw+akB3MS5maTwvZW1haWw+IGFuZAogICAgIGNvbnRyaWJ1dG9ycy4KICAgICBBbGwgUmlnaHRzIFJlc2VydmVkLjwvcGFyYT4KIAotICAgIDxwYXJhPlRoaXMgcHJvZ3JhbSBpcyBkdWFsLWxpY2Vuc2VkIHVuZGVyIGJvdGggdGhlIEdQTCB2ZXJzaW9uIDIKLSAgICBhbmQgQlNEIGxpY2Vuc2UuIEVpdGhlciBsaWNlbnNlIG1heSBiZSB1c2VkIGF0IHlvdXIgb3B0aW9uLjwvcGFyYT4KKyAgICA8cGFyYT5UaGlzIHByb2dyYW0gaXMgbGljZW5zZWQgdW5kZXIgdGhlIEJTRCBsaWNlbnNlICh0aGUgb25lIHdpdGgKKyAgICBhZHZlcnRpc2VtZW50IGNsYXVzZSByZW1vdmVkKS48L3BhcmE+CiAgIDwvcmVmc2VjdDE+CiA8L3JlZmVudHJ5PgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2d1aS5zZ21sIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX2d1aS5zZ21sCmluZGV4IDQxYjU4NDkuLjBhYjY0MTkgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9ndWkuc2dtbAorKysgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfZ3VpLnNnbWwKQEAgLTc0LDEyICs3NCwxMiBAQAogICA8L3JlZnNlY3QxPgogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAwNywKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgogCi0gICAgPHBhcmE+VGhpcyBwcm9ncmFtIGlzIGR1YWwtbGljZW5zZWQgdW5kZXIgYm90aCB0aGUgR1BMIHZlcnNpb24gMgotICAgIGFuZCBCU0QgbGljZW5zZS4gRWl0aGVyIGxpY2Vuc2UgbWF5IGJlIHVzZWQgYXQgeW91ciBvcHRpb24uPC9wYXJhPgorICAgIDxwYXJhPlRoaXMgcHJvZ3JhbSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQlNEIGxpY2Vuc2UgKHRoZSBvbmUgd2l0aAorICAgIGFkdmVydGlzZW1lbnQgY2xhdXNlIHJlbW92ZWQpLjwvcGFyYT4KICAgPC9yZWZzZWN0MT4KIDwvcmVmZW50cnk+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcGFzc3BocmFzZS5zZ21sIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3Bhc3NwaHJhc2Uuc2dtbAppbmRleCA0MDJlYTA5Li4zMzZjMDNiIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcGFzc3BocmFzZS5zZ21sCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9wYXNzcGhyYXNlLnNnbWwKQEAgLTYyLDEyICs2MiwxMiBAQAogICA8L3JlZnNlY3QxPgogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAwNywKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgogCi0gICAgPHBhcmE+VGhpcyBwcm9ncmFtIGlzIGR1YWwtbGljZW5zZWQgdW5kZXIgYm90aCB0aGUgR1BMIHZlcnNpb24gMgotICAgIGFuZCBCU0QgbGljZW5zZS4gRWl0aGVyIGxpY2Vuc2UgbWF5IGJlIHVzZWQgYXQgeW91ciBvcHRpb24uPC9wYXJhPgorICAgIDxwYXJhPlRoaXMgcHJvZ3JhbSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQlNEIGxpY2Vuc2UgKHRoZSBvbmUgd2l0aAorICAgIGFkdmVydGlzZW1lbnQgY2xhdXNlIHJlbW92ZWQpLjwvcGFyYT4KICAgPC9yZWZzZWN0MT4KIDwvcmVmZW50cnk+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcHJpdi5zZ21sIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3ByaXYuc2dtbAppbmRleCA4OWI4YTkyLi5lYjkwN2E4IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfcHJpdi5zZ21sCisrKyBiL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9wcml2LnNnbWwKQEAgLTEzNywxMiArMTM3LDEyIEBACiAgIDwvcmVmc2VjdDE+CiAgIDxyZWZzZWN0MT4KICAgICA8dGl0bGU+TGVnYWw8L3RpdGxlPgotICAgIDxwYXJhPndwYV9zdXBwbGljYW50IGlzIGNvcHlyaWdodCAoYykgMjAwMy0yMDA3LAorICAgIDxwYXJhPndwYV9zdXBwbGljYW50IGlzIGNvcHlyaWdodCAoYykgMjAwMy0yMDEyLAogICAgIEpvdW5pIE1hbGluZW4gPGVtYWlsPmpAdzEuZmk8L2VtYWlsPiBhbmQKICAgICBjb250cmlidXRvcnMuCiAgICAgQWxsIFJpZ2h0cyBSZXNlcnZlZC48L3BhcmE+CiAKLSAgICA8cGFyYT5UaGlzIHByb2dyYW0gaXMgZHVhbC1saWNlbnNlZCB1bmRlciBib3RoIHRoZSBHUEwgdmVyc2lvbiAyCi0gICAgYW5kIEJTRCBsaWNlbnNlLiBFaXRoZXIgbGljZW5zZSBtYXkgYmUgdXNlZCBhdCB5b3VyIG9wdGlvbi48L3BhcmE+CisgICAgPHBhcmE+VGhpcyBwcm9ncmFtIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBCU0QgbGljZW5zZSAodGhlIG9uZSB3aXRoCisgICAgYWR2ZXJ0aXNlbWVudCBjbGF1c2UgcmVtb3ZlZCkuPC9wYXJhPgogICA8L3JlZnNlY3QxPgogPC9yZWZlbnRyeT4KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9zdXBwbGljYW50LnNnbWwgYi93cGFfc3VwcGxpY2FudC9kb2MvZG9jYm9vay93cGFfc3VwcGxpY2FudC5zZ21sCmluZGV4IDBhYjRlMTUuLmFhMjBlNTcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2RvYy9kb2Nib29rL3dwYV9zdXBwbGljYW50LnNnbWwKKysrIGIvd3BhX3N1cHBsaWNhbnQvZG9jL2RvY2Jvb2svd3BhX3N1cHBsaWNhbnQuc2dtbApAQCAtMjQ2LDI4ICsyNDYsNiBAQAogCiAgICAgPHZhcmlhYmxlbGlzdD4KICAgICAgIDx2YXJsaXN0ZW50cnk+Ci0JPHRlcm0+aG9zdGFwPC90ZXJtPgotCTxsaXN0aXRlbT4KLQkgIDxwYXJhPihkZWZhdWx0KSBIb3N0IEFQIGRyaXZlciAoSW50ZXJzaWwgUHJpc20yLzIuNS8zKS4KLSAgCSAgKHRoaXMgY2FuIGFsc28gYmUgdXNlZCB3aXRoIExpbnV4YW50IERyaXZlckxvYWRlcikuPC9wYXJhPgotCTwvbGlzdGl0ZW0+Ci0gICAgICA8L3Zhcmxpc3RlbnRyeT4KLQotICAgICAgPHZhcmxpc3RlbnRyeT4KLQk8dGVybT5oZXJtZXM8L3Rlcm0+Ci0JPGxpc3RpdGVtPgotCSAgPHBhcmE+QWdlcmUgU3lzdGVtcyBJbmMuIGRyaXZlciAoSGVybWVzLUkvSGVybWVzLUlJKS48L3BhcmE+Ci0JPC9saXN0aXRlbT4KLSAgICAgIDwvdmFybGlzdGVudHJ5PgotCi0gICAgICA8dmFybGlzdGVudHJ5PgotCTx0ZXJtPm1hZHdpZmk8L3Rlcm0+Ci0JPGxpc3RpdGVtPgotCSAgPHBhcmE+TUFEV0lGSSA4MDIuMTEgc3VwcG9ydCAoQXRoZXJvcywgZXRjLikuPC9wYXJhPgotCTwvbGlzdGl0ZW0+Ci0gICAgICA8L3Zhcmxpc3RlbnRyeT4KLQotICAgICAgPHZhcmxpc3RlbnRyeT4KIAk8dGVybT53ZXh0PC90ZXJtPgogCTxsaXN0aXRlbT4KIAkgIDxwYXJhPkxpbnV4IHdpcmVsZXNzIGV4dGVuc2lvbnMgKGdlbmVyaWMpLjwvcGFyYT4KQEAgLTI3NSwxMyArMjUzLDYgQEAKICAgICAgIDwvdmFybGlzdGVudHJ5PgogCiAgICAgICA8dmFybGlzdGVudHJ5PgotCTx0ZXJtPmJyb2FkY29tPC90ZXJtPgotCTxsaXN0aXRlbT4KLQkgIDxwYXJhPkJyb2FkY29tIHdsLm8gZHJpdmVyLjwvcGFyYT4KLQk8L2xpc3RpdGVtPgotICAgICAgPC92YXJsaXN0ZW50cnk+Ci0KLSAgICAgIDx2YXJsaXN0ZW50cnk+CiAJPHRlcm0+d2lyZWQ8L3Rlcm0+CiAJPGxpc3RpdGVtPgogCSAgPHBhcmE+d3BhX3N1cHBsaWNhbnQgd2lyZWQgRXRoZXJuZXQgZHJpdmVyPC9wYXJhPgpAQCAtNDExLDcgKzM4Miw3IEBACiAgICAgICA8dmFybGlzdGVudHJ5PgogCTx0ZXJtPi1MPC90ZXJtPgogCTxsaXN0aXRlbT4KLQkgIDxwYXJhPlNob3cgbGljZW5zZSAoR1BMIGFuZCBCU0QpLjwvcGFyYT4KKwkgIDxwYXJhPlNob3cgbGljZW5zZSAoQlNEKS48L3BhcmE+CiAJPC9saXN0aXRlbT4KICAgICAgIDwvdmFybGlzdGVudHJ5PgogCkBAIC01MDYsOCArNDc3LDggQEAKIAogPGJsb2NrcXVvdGU+PHByb2dyYW1saXN0aW5nPgogd3BhX3N1cHBsaWNhbnQgXAotCS1jIHdwYTEuY29uZiAtaSB3bGFuMCAtRCBob3N0YXAgLU4gXAotCS1jIHdwYTIuY29uZiAtaSBhdGgwIC1EIG1hZHdpZmkKKwktYyB3cGExLmNvbmYgLWkgd2xhbjAgLUQgbmw4MDIxMSAtTiBcCisJLWMgd3BhMi5jb25mIC1pIGF0aDAgLUQgd2V4dAogPC9wcm9ncmFtbGlzdGluZz48L2Jsb2NrcXVvdGU+CiAgIDwvcmVmc2VjdDE+CiAKQEAgLTUzNyw4NiArNTA4LDYgQEAKICAgICA8dGl0bGU+U3VwcG9ydGVkIERyaXZlcnM8L3RpdGxlPgogICAgIDx2YXJpYWJsZWxpc3Q+CiAgICAgICA8dmFybGlzdGVudHJ5PgotCTx0ZXJtPkhvc3QgQVAgZHJpdmVyIGZvciBQcmlzbTIvMi41LzMgKGRldmVsb3BtZW50Ci0Jc25hcHNob3QvdjAuMi54KTwvdGVybT4KLQk8bGlzdGl0ZW0+Ci0JICA8cGFyYT4gKGh0dHA6Ly9ob3N0YXAuZXBpdGVzdC5maS8pIERyaXZlciBuZWVkcyB0byBiZSBzZXQgaW4KLQkgIE1hbmFnZWQgbW9kZSAoPGVtcGhhc2lzPml3Y29uZmlnIHdsYW4wIG1vZGUgbWFuYWdlZDwvZW1waGFzaXM+KS4KLQkgIFBsZWFzZSBub3RlIHRoYXQgc3RhdGlvbiBmaXJtd2FyZSB2ZXJzaW9uIG5lZWRzIHRvIGJlIDEuNy4wIG9yCi0JICBuZXdlciB0byB3b3JrIGluIFdQQSBtb2RlLjwvcGFyYT4KLQk8L2xpc3RpdGVtPgotICAgICAgPC92YXJsaXN0ZW50cnk+Ci0KLSAgICAgIDx2YXJsaXN0ZW50cnk+Ci0JPHRlcm0+TGludXhhbnQgRHJpdmVyTG9hZGVyPC90ZXJtPgotCTxsaXN0aXRlbT4KLQkgIDxwYXJhPihodHRwOi8vd3d3LmxpbnV4YW50LmNvbS9kcml2ZXJsb2FkZXIvKQotCXdpdGggV2luZG93cyBORElTIGRyaXZlciBmb3IgeW91ciB3bGFuIGNhcmQgc3VwcG9ydGluZyBXUEEuPC9wYXJhPgotCTwvbGlzdGl0ZW0+Ci0gICAgICA8L3Zhcmxpc3RlbnRyeT4KLQotICAgICAgPHZhcmxpc3RlbnRyeT4KLQk8dGVybT5BZ2VyZSBTeXN0ZW1zIEluYy4gTGludXggRHJpdmVyPC90ZXJtPgotCTxsaXN0aXRlbT4KLQkgIDxwYXJhPiAoaHR0cDovL3d3dy5hZ2VyZS5jb20vc3VwcG9ydC9kcml2ZXJzLykgUGxlYXNlIG5vdGUKLQl0aGF0IHRoZSBkcml2ZXIgaW50ZXJmYWNlIGZpbGUgKGRyaXZlcl9oZXJtZXMuYykgYW5kIGhhcmR3YXJlCi0Jc3BlY2lmaWMgaW5jbHVkZSBmaWxlcyBhcmUgbm90IGluY2x1ZGVkIGluIHRoZSB3cGFfc3VwcGxpY2FudAotCWRpc3RyaWJ1dGlvbi4gWW91IHdpbGwgbmVlZCB0byBjb3B5IHRoZXNlIGZyb20gdGhlIHNvdXJjZQotCXBhY2thZ2Ugb2YgdGhlIEFnZXJlIGRyaXZlci48L3BhcmE+Ci0JPC9saXN0aXRlbT4KLSAgICAgIDwvdmFybGlzdGVudHJ5PgotCi0gICAgICA8dmFybGlzdGVudHJ5PgotCTx0ZXJtPm1hZHdpZmkgZHJpdmVyIGZvciBjYXJkcyBiYXNlZCBvbiBBdGhlcm9zIGNoaXAgc2V0IChhcjUyMXgpPC90ZXJtPgotCTxsaXN0aXRlbT4KLQkgIDxwYXJhPiAoaHR0cDovL3NvdXJjZWZvcmdlLm5ldC9wcm9qZWN0cy9tYWR3aWZpLykgUGxlYXNlCi0Jbm90ZSB0aGF0IHlvdSB3aWxsIG5lZWQgdG8gbW9kaWZ5IHRoZSB3cGFfc3VwcGxpY2FudCAuY29uZmlnCi0JZmlsZSB0byB1c2UgdGhlIGNvcnJlY3QgcGF0aCBmb3IgdGhlIG1hZHdpZmkgZHJpdmVyIHJvb3QKLQlkaXJlY3RvcnkgKENGTEFHUyArPSAtSS4uL21hZHdpZmkvd3BhIGxpbmUgaW4gZXhhbXBsZQotCWRlZmNvbmZpZykuPC9wYXJhPgotCTwvbGlzdGl0ZW0+Ci0gICAgICA8L3Zhcmxpc3RlbnRyeT4KLQotICAgICAgPHZhcmxpc3RlbnRyeT4KLQk8dGVybT5MaW51eCBuZGlzd3JhcHBlcjwvdGVybT4KLQk8bGlzdGl0ZW0+Ci0JICA8cGFyYT4gKGh0dHA6Ly9uZGlzd3JhcHBlci5zb3VyY2Vmb3JnZS5uZXQvKSB3aXRoIFdpbmRvd3MKLQlORElTIGRyaXZlci48L3BhcmE+Ci0JPC9saXN0aXRlbT4KLSAgICAgIDwvdmFybGlzdGVudHJ5PgotCi0gICAgICA8dmFybGlzdGVudHJ5PgotCTx0ZXJtPkJyb2FkY29tIHdsLm8gZHJpdmVyPC90ZXJtPgotCTxsaXN0aXRlbT4KLQkgIDxwYXJhPiBUaGlzIGlzIGEgZ2VuZXJpYyBMaW51eCBkcml2ZXIgZm9yIEJyb2FkY29tIElFRUUKLQk4MDIuMTFhL2cgY2FyZHMuICBIb3dldmVyLCBpdCBpcyBwcm9wcmlldGFyeSBkcml2ZXIgdGhhdCBpcwotCW5vdCBwdWJsaWNseSBhdmFpbGFibGUgZXhjZXB0IGZvciBjb3VwbGUgb2YgZXhjZXB0aW9ucywgbWFpbmx5Ci0JQnJvYWRjb20tYmFzZWQgQVBzL3dpcmVsZXNzIHJvdXRlcnMgdGhhdCB1c2UgTGludXguIFRoZSBkcml2ZXIKLQliaW5hcnkgY2FuIGJlIGRvd25sb2FkZWQsIGUuZy4sIGZyb20gTGlua3N5cyBzdXBwb3J0IHNpdGUKLQkoaHR0cDovL3d3dy5saW5rc3lzLmNvbS9zdXBwb3J0L2dwbC5hc3ApIGZvciBMaW5rc3lzCi0JV1JUNTRHLiBUaGUgR1BMIHRhcmJhbGwgaW5jbHVkZXMgY3Jvc3MtY29tcGlsZXIgYW5kIHRoZSBuZWVkZWQKLQloZWFkZXIgZmlsZSwgd2xpb2N0bC5oLCBmb3IgY29tcGlsaW5nIHdwYV9zdXBwbGljYW50LiAgVGhpcwotCWRyaXZlciBzdXBwb3J0IGluIHdwYV9zdXBwbGljYW50IGlzIGV4cGVjdGVkIHRvIHdvcmsgYWxzbyB3aXRoCi0Jb3RoZXIgZGV2aWNlcyBiYXNlZCBvbiBCcm9hZGNvbSBkcml2ZXIgKGFzc3VtaW5nIHRoZSBkcml2ZXIKLQlpbmNsdWRlcyBjbGllbnQgbW9kZSBzdXBwb3J0KS48L3BhcmE+Ci0JPC9saXN0aXRlbT4KLSAgICAgIDwvdmFybGlzdGVudHJ5PgotCi0gICAgICA8dmFybGlzdGVudHJ5PgotCTx0ZXJtPiBJbnRlbCBpcHcyMTAwIGRyaXZlcjwvdGVybT4KLQk8bGlzdGl0ZW0+Ci0JICA8cGFyYT4gKGh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvcHJvamVjdHMvaXB3MjEwMC8pPC9wYXJhPgotCTwvbGlzdGl0ZW0+Ci0gICAgICA8L3Zhcmxpc3RlbnRyeT4KLQotICAgICAgPHZhcmxpc3RlbnRyeT4KLQk8dGVybT5JbnRlbCBpcHcyMjAwIGRyaXZlcjwvdGVybT4KLQk8bGlzdGl0ZW0+Ci0JICA8cGFyYT4gKGh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvcHJvamVjdHMvaXB3MjIwMC8pPC9wYXJhPgotCTwvbGlzdGl0ZW0+Ci0gICAgICA8L3Zhcmxpc3RlbnRyeT4KLQotICAgICAgPHZhcmxpc3RlbnRyeT4KIAk8dGVybT5MaW51eCB3aXJlbGVzcyBleHRlbnNpb25zPC90ZXJtPgogCTxsaXN0aXRlbT4KIAkgIDxwYXJhPkluIHRoZW9yeSwgYW55IGRyaXZlciB0aGF0IHN1cHBvcnRzIExpbnV4IHdpcmVsZXNzCkBAIC03ODgsMTIgKzY3OSwxMiBAQAogICA8L3JlZnNlY3QxPgogICA8cmVmc2VjdDE+CiAgICAgPHRpdGxlPkxlZ2FsPC90aXRsZT4KLSAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAwNywKKyAgICA8cGFyYT53cGFfc3VwcGxpY2FudCBpcyBjb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwKICAgICBKb3VuaSBNYWxpbmVuIDxlbWFpbD5qQHcxLmZpPC9lbWFpbD4gYW5kCiAgICAgY29udHJpYnV0b3JzLgogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuPC9wYXJhPgogCi0gICAgPHBhcmE+VGhpcyBwcm9ncmFtIGlzIGR1YWwtbGljZW5zZWQgdW5kZXIgYm90aCB0aGUgR1BMIHZlcnNpb24gMgotICAgIGFuZCBCU0QgbGljZW5zZS4gRWl0aGVyIGxpY2Vuc2UgbWF5IGJlIHVzZWQgYXQgeW91ciBvcHRpb24uPC9wYXJhPgorICAgIDxwYXJhPlRoaXMgcHJvZ3JhbSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgQlNEIGxpY2Vuc2UgKHRoZSBvbmUgd2l0aAorICAgIGFkdmVydGlzZW1lbnQgY2xhdXNlIHJlbW92ZWQpLjwvcGFyYT4KICAgPC9yZWZzZWN0MT4KIDwvcmVmZW50cnk+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9kcml2ZXJfaS5oIGIvd3BhX3N1cHBsaWNhbnQvZHJpdmVyX2kuaAppbmRleCBiOWVhMjkxLi5mOTY4MjUxIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9kcml2ZXJfaS5oCisrKyBiL3dwYV9zdXBwbGljYW50L2RyaXZlcl9pLmgKQEAgLTQyNyw2ICs0MjcsMTMgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9kZWluaXRfcDJwX2NsaShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWlmICh3cGFfcy0+ZHJpdmVyLT5kZWluaXRfcDJwX2NsaSkKKwkJcmV0dXJuIHdwYV9zLT5kcml2ZXItPmRlaW5pdF9wMnBfY2xpKHdwYV9zLT5kcnZfcHJpdik7CisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCB3cGFfZHJ2X3N1c3BlbmQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKIAlpZiAod3BhX3MtPmRyaXZlci0+c3VzcGVuZCkKQEAgLTY2NywxMyArNjc0LDIwIEBACiAJd3BhX3MtPmRyaXZlci0+c2V0X3Jla2V5X2luZm8od3BhX3MtPmRydl9wcml2LCBrZWssIGtjaywgcmVwbGF5X2N0cik7CiB9CiAKLSNpZmRlZiBBTkRST0lEX1AyUAorc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9yYWRpb19kaXNhYmxlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCWludCBkaXNhYmxlZCkKK3sKKwlpZiAoIXdwYV9zLT5kcml2ZXItPnJhZGlvX2Rpc2FibGUpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gd3BhX3MtPmRyaXZlci0+cmFkaW9fZGlzYWJsZSh3cGFfcy0+ZHJ2X3ByaXYsIGRpc2FibGVkKTsKK30KKwogc3RhdGljIGlubGluZSBpbnQgd3BhX2Rydl9zd2l0Y2hfY2hhbm5lbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCQkgIGludCBmcmVxKQorCQkJCQkgdW5zaWduZWQgaW50IGZyZXEpCiB7CiAJaWYgKCF3cGFfcy0+ZHJpdmVyLT5zd2l0Y2hfY2hhbm5lbCkKIAkJcmV0dXJuIC0xOwogCXJldHVybiB3cGFfcy0+ZHJpdmVyLT5zd2l0Y2hfY2hhbm5lbCh3cGFfcy0+ZHJ2X3ByaXYsIGZyZXEpOwogfQotI2VuZGlmCisKICNlbmRpZiAvKiBEUklWRVJfSV9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9lYXBvbF90ZXN0LmMgYi93cGFfc3VwcGxpY2FudC9lYXBvbF90ZXN0LmMKaW5kZXggNjVlNjc0Mi4uZTUzZTE1NiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvZWFwb2xfdGVzdC5jCisrKyBiL3dwYV9zdXBwbGljYW50L2VhcG9sX3Rlc3QuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBXUEEgU3VwcGxpY2FudCAtIHRlc3QgY29kZQotICogQ29weXJpZ2h0IChjKSAyMDAzLTIwMTEsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMjc4LDcgKzI3OCw5IEBACiAJCX0KIAl9CiAKLQlyYWRpdXNfY2xpZW50X3NlbmQoZS0+cmFkaXVzLCBtc2csIFJBRElVU19BVVRILCBlLT53cGFfcy0+b3duX2FkZHIpOworCWlmIChyYWRpdXNfY2xpZW50X3NlbmQoZS0+cmFkaXVzLCBtc2csIFJBRElVU19BVVRILCBlLT53cGFfcy0+b3duX2FkZHIpCisJICAgIDwgMCkKKwkJZ290byBmYWlsOwogCXJldHVybjsKIAogIGZhaWw6CkBAIC04NTYsNyArODU4LDcgQEAKIAl1bnNpZ25lZCBjaGFyIGFrYV9pa1tJS19MRU5dOwogCXVuc2lnbmVkIGNoYXIgYWthX2NrW0NLX0xFTl07CiAKLQlzY2FyZCA9IHNjYXJkX2luaXQoU0NBUkRfVFJZX0JPVEgpOworCXNjYXJkID0gc2NhcmRfaW5pdChTQ0FSRF9UUllfQk9USCwgTlVMTCk7CiAJaWYgKHNjYXJkID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAlpZiAoc2NhcmRfc2V0X3BpbihzY2FyZCwgIjEyMzQiKSkgewpAQCAtOTU2LDcgKzk1OCw3IEBACiAJCXdwYV9kZWJ1Z19sZXZlbCA9IDk5OwogCX0KIAotCXNjYXJkID0gc2NhcmRfaW5pdChTQ0FSRF9HU01fU0lNX09OTFkpOworCXNjYXJkID0gc2NhcmRfaW5pdChTQ0FSRF9HU01fU0lNX09OTFksIE5VTEwpOwogCWlmIChzY2FyZCA9PSBOVUxMKSB7CiAJCXByaW50ZigiRmFpbGVkIHRvIG9wZW4gc21hcnRjYXJkIGNvbm5lY3Rpb25cbiIpOwogCQlyZXR1cm4gLTE7CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9ldmVudHMuYyBiL3dwYV9zdXBwbGljYW50L2V2ZW50cy5jCmluZGV4IDVjZTViNzIuLmM0YjM4NjIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L2V2ZW50cy5jCisrKyBiL3dwYV9zdXBwbGljYW50L2V2ZW50cy5jCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiZ2FzX3F1ZXJ5LmgiCiAjaW5jbHVkZSAicDJwX3N1cHBsaWNhbnQuaCIKICNpbmNsdWRlICJiZ3NjYW4uaCIKKyNpbmNsdWRlICJhdXRvc2Nhbi5oIgogI2luY2x1ZGUgImFwLmgiCiAjaW5jbHVkZSAiYnNzLmgiCiAjaW5jbHVkZSAic2Nhbi5oIgpAQCAtNTcsNyArNTgsNyBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKHNzaWQtPmRpc2FibGVkKSB7CisJaWYgKHdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkpIHsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU2VsZWN0ZWQgbmV0d29yayBpcyBkaXNhYmxlZCIpOwogCQlyZXR1cm4gLTE7CiAJfQpAQCAtMTAzLDYgKzEwNCw4IEBACiB7CiAJaW50IGJzc2lkX2NoYW5nZWQ7CiAKKwl3bm1fYnNzX2tlZXBfYWxpdmVfZGVpbml0KHdwYV9zKTsKKwogI2lmZGVmIENPTkZJR19JQlNTX1JTTgogCWlic3NfcnNuX2RlaW5pdCh3cGFfcy0+aWJzc19yc24pOwogCXdwYV9zLT5pYnNzX3JzbiA9IE5VTEw7CkBAIC0xMjIsNiArMTI1LDkgQEAKIAlic3NpZF9jaGFuZ2VkID0gIWlzX3plcm9fZXRoZXJfYWRkcih3cGFfcy0+YnNzaWQpOwogCW9zX21lbXNldCh3cGFfcy0+YnNzaWQsIDAsIEVUSF9BTEVOKTsKIAlvc19tZW1zZXQod3BhX3MtPnBlbmRpbmdfYnNzaWQsIDAsIEVUSF9BTEVOKTsKKyNpZmRlZiBDT05GSUdfU01FCisJd3BhX3MtPnNtZS5wcmV2X2Jzc2lkX3NldCA9IDA7CisjZW5kaWYgLyogQ09ORklHX1NNRSAqLwogI2lmZGVmIENPTkZJR19QMlAKIAlvc19tZW1zZXQod3BhX3MtPmdvX2Rldl9hZGRyLCAwLCBFVEhfQUxFTik7CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwpAQCAtMjQxLDcgKzI0Nyw4IEBACiAJCQlpZiAoZWFwLT52ZW5kb3IgPT0gRUFQX1ZFTkRPUl9JRVRGKSB7CiAJCQkJaWYgKGVhcC0+bWV0aG9kID09IEVBUF9UWVBFX1NJTSkKIAkJCQkJc2ltID0gMTsKLQkJCQllbHNlIGlmIChlYXAtPm1ldGhvZCA9PSBFQVBfVFlQRV9BS0EpCisJCQkJZWxzZSBpZiAoZWFwLT5tZXRob2QgPT0gRUFQX1RZUEVfQUtBIHx8CisJCQkJCSBlYXAtPm1ldGhvZCA9PSBFQVBfVFlQRV9BS0FfUFJJTUUpCiAJCQkJCWFrYSA9IDE7CiAJCQl9CiAJCQllYXArKzsKQEAgLTI1MCw3ICsyNTcsOSBAQAogCiAJaWYgKGVhcF9wZWVyX2dldF9lYXBfbWV0aG9kKEVBUF9WRU5ET1JfSUVURiwgRUFQX1RZUEVfU0lNKSA9PSBOVUxMKQogCQlzaW0gPSAwOwotCWlmIChlYXBfcGVlcl9nZXRfZWFwX21ldGhvZChFQVBfVkVORE9SX0lFVEYsIEVBUF9UWVBFX0FLQSkgPT0gTlVMTCkKKwlpZiAoZWFwX3BlZXJfZ2V0X2VhcF9tZXRob2QoRUFQX1ZFTkRPUl9JRVRGLCBFQVBfVFlQRV9BS0EpID09IE5VTEwgJiYKKwkgICAgZWFwX3BlZXJfZ2V0X2VhcF9tZXRob2QoRUFQX1ZFTkRPUl9JRVRGLCBFQVBfVFlQRV9BS0FfUFJJTUUpID09CisJICAgIE5VTEwpCiAJCWFrYSA9IDA7CiAKIAlpZiAoIXNpbSAmJiAhYWthKSB7CkBAIC0yNjksNyArMjc4LDcgQEAKIAllbHNlCiAJCXR5cGUgPSBTQ0FSRF9HU01fU0lNX09OTFk7CiAKLQl3cGFfcy0+c2NhcmQgPSBzY2FyZF9pbml0KHR5cGUpOworCXdwYV9zLT5zY2FyZCA9IHNjYXJkX2luaXQodHlwZSwgTlVMTCk7CiAJaWYgKHdwYV9zLT5zY2FyZCA9PSBOVUxMKSB7CiAJCXdwYV9tc2cod3BhX3MsIE1TR19XQVJOSU5HLCAiRmFpbGVkIHRvIGluaXRpYWxpemUgU0lNICIKIAkJCSIocGNzYy1saXRlKSIpOwpAQCAtNjEyLDcgKzYyMSw3IEBACiAJZSA9IHdwYV9ibGFja2xpc3RfZ2V0KHdwYV9zLCBic3MtPmJzc2lkKTsKIAlpZiAoZSkgewogCQlpbnQgbGltaXQgPSAxOwotCQlpZiAod3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3Jrcyh3cGFfcy0+Y29uZikgPT0gMSkgeworCQlpZiAod3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3Jrcyh3cGFfcykgPT0gMSkgewogCQkJLyoKIAkJCSAqIFdoZW4gb25seSBhIHNpbmdsZSBuZXR3b3JrIGlzIGVuYWJsZWQsIHdlIGNhbgogCQkJICogdHJpZ2dlciBibGFja2xpc3Rpbmcgb24gdGhlIGZpcnN0IGZhaWx1cmUuIFRoaXMKQEAgLTY0MCw3ICs2NDksNyBAQAogCWZvciAoc3NpZCA9IGdyb3VwOyBzc2lkOyBzc2lkID0gc3NpZC0+cG5leHQpIHsKIAkJaW50IGNoZWNrX3NzaWQgPSB3cGEgPyAxIDogKHNzaWQtPnNzaWRfbGVuICE9IDApOwogCi0JCWlmIChzc2lkLT5kaXNhYmxlZCkgeworCQlpZiAod3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSkgewogCQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiICAgc2tpcCAtIGRpc2FibGVkIik7CiAJCQljb250aW51ZTsKIAkJfQpAQCAtODA1LDcgKzgxNCw3IEBACiBzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9yZXFfbmV3X3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJaW50IHRpbWVvdXRfc2VjLCBpbnQgdGltZW91dF91c2VjKQogewotCWlmICghd3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3Jrcyh3cGFfcy0+Y29uZikpIHsKKwlpZiAoIXdwYV9zdXBwbGljYW50X2VuYWJsZWRfbmV0d29ya3Mod3BhX3MpKSB7CiAJCS8qCiAJCSAqIE5vIG5ldHdvcmtzIGFyZSBlbmFibGVkOyBzaG9ydC1jaXJjdWl0IHJlcXVlc3Qgc28KIAkJICogd2UgZG9uJ3Qgd2FpdCB0aW1lb3V0IHNlY29uZHMgYmVmb3JlIHRyYW5zaXRpb25pbmcKQEAgLTg3Niw3ICs4ODUsNyBAQAogCWZvciAocHJpbyA9IDA7IHByaW8gPCB3cGFfcy0+Y29uZi0+bnVtX3ByaW87IHByaW8rKykgewogCQlmb3IgKHNzaWQgPSB3cGFfcy0+Y29uZi0+cHNzaWRbcHJpb107IHNzaWQ7IHNzaWQgPSBzc2lkLT5wbmV4dCkKIAkJewotCQkJaWYgKHNzaWQtPmRpc2FibGVkKQorCQkJaWYgKHdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkpCiAJCQkJY29udGludWU7CiAJCQlpZiAoc3NpZC0+bW9kZSA9PSBJRUVFODAyMTFfTU9ERV9JQlNTIHx8CiAJCQkgICAgc3NpZC0+bW9kZSA9PSBJRUVFODAyMTFfTU9ERV9BUCkKQEAgLTk4OSwxMyArOTk4LDE0IEBACiAJfQogCiAJcmV0dXJuIDE7Ci0jZWxzZQorI2Vsc2UgLyogQ09ORklHX05PX1JPQU1JTkcgKi8KIAlyZXR1cm4gMDsKLSNlbmRpZgorI2VuZGlmIC8qIENPTkZJR19OT19ST0FNSU5HICovCiB9CiAKIAotLyogUmV0dXJuIDwgMCBpZiBubyBzY2FuIHJlc3VsdHMgY291bGQgYmUgZmV0Y2hlZC4gKi8KKy8qIFJldHVybiA8IDAgaWYgbm8gc2NhbiByZXN1bHRzIGNvdWxkIGJlIGZldGNoZWQgb3IgaWYgc2NhbiByZXN1bHRzIHNob3VsZCBub3QKKyAqIGJlIHNoYXJlZCB3aXRoIG90aGVyIHZpcnR1YWwgaW50ZXJmYWNlcy4gKi8KICNpZmRlZiBBTkRST0lEX1AyUAogc3RhdGljIGludCBfd3BhX3N1cHBsaWNhbnRfZXZlbnRfc2Nhbl9yZXN1bHRzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJCSAgICAgIHVuaW9uIHdwYV9ldmVudF9kYXRhICpkYXRhLCBpbnQgc3VwcHJlc3NfZXZlbnQpCkBAIC0xMDcwLDcgKzEwODAsNyBAQAogCQlzY2FuX3Jlc19oYW5kbGVyKHdwYV9zLCBzY2FuX3Jlcyk7CiAKIAkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKLQkJcmV0dXJuIDA7CisJCXJldHVybiAtMjsKIAl9CiAKIAlpZiAoYXApIHsKQEAgLTEwODQsMjAgKzEwOTQsMzQgQEAKIAl9CiAjaWZkZWYgQU5EUk9JRF9QMlAKIAlpZighc3VwcHJlc3NfZXZlbnQpCi0jZW5kaWYKIAl7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIk5ldyBzY2FuIHJlc3VsdHMgYXZhaWxhYmxlIik7CiAJCXdwYV9tc2dfY3RybCh3cGFfcywgTVNHX0lORk8sIFdQQV9FVkVOVF9TQ0FOX1JFU1VMVFMpOwogCQl3cGFzX25vdGlmeV9zY2FuX3Jlc3VsdHMod3BhX3MpOwogCX0KKyNlbHNlCisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiTmV3IHNjYW4gcmVzdWx0cyBhdmFpbGFibGUiKTsKKwl3cGFfbXNnX2N0cmwod3BhX3MsIE1TR19JTkZPLCBXUEFfRVZFTlRfU0NBTl9SRVNVTFRTKTsKKwl3cGFzX25vdGlmeV9zY2FuX3Jlc3VsdHMod3BhX3MpOworI2VuZGlmCiAKIAl3cGFzX25vdGlmeV9zY2FuX2RvbmUod3BhX3MsIDEpOwogCisJaWYgKHNtZV9wcm9jX29ic3Nfc2Nhbih3cGFfcykgPiAwKSB7CisJCXdwYV9zY2FuX3Jlc3VsdHNfZnJlZShzY2FuX3Jlcyk7CisJCXJldHVybiAwOworCX0KKwogCWlmICgod3BhX3MtPmNvbmYtPmFwX3NjYW4gPT0gMiAmJiAhd3Bhc193cHNfc2VhcmNoaW5nKHdwYV9zKSkpIHsKIAkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKIAkJcmV0dXJuIDA7CiAJfQogCisJaWYgKGF1dG9zY2FuX25vdGlmeV9zY2FuKHdwYV9zLCBzY2FuX3JlcykpIHsKKwkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKKwkJcmV0dXJuIDA7CisJfQorCiAJaWYgKHdwYV9zLT5kaXNjb25uZWN0ZWQpIHsKIAkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfRElTQ09OTkVDVEVEKTsKIAkJd3BhX3NjYW5fcmVzdWx0c19mcmVlKHNjYW5fcmVzKTsKQEAgLTExMzksNiArMTE2Myw5IEBACiAJCQlpbnQgdGltZW91dF9zZWMgPSB3cGFfcy0+c2Nhbl9pbnRlcnZhbDsKIAkJCWludCB0aW1lb3V0X3VzZWMgPSAwOwogI2lmZGVmIENPTkZJR19QMlAKKwkJCWlmICh3cGFzX3AycF9zY2FuX25vX2dvX3NlZW4od3BhX3MpID09IDEpCisJCQkJcmV0dXJuIDA7CisKIAkJCWlmICh3cGFfcy0+cDJwX2luX3Byb3Zpc2lvbmluZykgewogCQkJCS8qCiAJCQkJICogVXNlIHNob3J0ZXIgd2FpdCBkdXJpbmcgUDJQIFByb3Zpc2lvbmluZwpAQCAtMTIyOCw2ICsxMjU1LDgyIEBACiAjZW5kaWYgLyogQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORyAqLwogCiAKKyNpZmRlZiBDT05GSUdfV05NCisKK3N0YXRpYyB2b2lkIHdubV9ic3Nfa2VlcF9hbGl2ZSh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnNvY2tfY3R4KQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBlbG9vcF9jdHg7CisKKwlpZiAod3BhX3MtPndwYV9zdGF0ZSA8IFdQQV9BU1NPQ0lBVEVEKQorCQlyZXR1cm47CisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldOTTogU2VuZCBrZWVwLWFsaXZlIHRvIEFQICIgTUFDU1RSLAorCQkgICBNQUMyU1RSKHdwYV9zLT5ic3NpZCkpOworCS8qIFRPRE86IGNvdWxkIHNraXAgdGhpcyBpZiBub3JtYWwgZGF0YSB0cmFmZmljIGhhcyBiZWVuIHNlbnQgKi8KKwkvKiBUT0RPOiBDb25zaWRlciB1c2luZyBzb21lIG1vcmUgYXBwcm9wcmlhdGUgZGF0YSBmcmFtZSBmb3IgdGhpcyAqLworCWlmICh3cGFfcy0+bDIpCisJCWwyX3BhY2tldF9zZW5kKHdwYV9zLT5sMiwgd3BhX3MtPmJzc2lkLCAweDA4MDAsICh1OCAqKSAiIiwgMCk7CisKKyNpZmRlZiBDT05GSUdfU01FCisJaWYgKHdwYV9zLT5zbWUuYnNzX21heF9pZGxlX3BlcmlvZCkgeworCQl1bnNpZ25lZCBpbnQgbXNlYzsKKwkJbXNlYyA9IHdwYV9zLT5zbWUuYnNzX21heF9pZGxlX3BlcmlvZCAqIDEwMjQ7IC8qIHRpbWVzIDEwMDAgKi8KKwkJaWYgKG1zZWMgPiAxMDApCisJCQltc2VjIC09IDEwMDsKKwkJZWxvb3BfcmVnaXN0ZXJfdGltZW91dChtc2VjIC8gMTAwMCwgbXNlYyAlIDEwMDAgKiAxMDAwLAorCQkJCSAgICAgICB3bm1fYnNzX2tlZXBfYWxpdmUsIHdwYV9zLCBOVUxMKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1NNRSAqLworfQorCisKK3N0YXRpYyB2b2lkIHdubV9wcm9jZXNzX2Fzc29jX3Jlc3Aoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICBjb25zdCB1OCAqaWVzLCBzaXplX3QgaWVzX2xlbikKK3sKKwlzdHJ1Y3QgaWVlZTgwMl8xMV9lbGVtcyBlbGVtczsKKworCWlmIChpZXMgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKGllZWU4MDJfMTFfcGFyc2VfZWxlbXMoaWVzLCBpZXNfbGVuLCAmZWxlbXMsIDEpID09IFBhcnNlRmFpbGVkKQorCQlyZXR1cm47CisKKyNpZmRlZiBDT05GSUdfU01FCisJaWYgKGVsZW1zLmJzc19tYXhfaWRsZV9wZXJpb2QpIHsKKwkJdW5zaWduZWQgaW50IG1zZWM7CisJCXdwYV9zLT5zbWUuYnNzX21heF9pZGxlX3BlcmlvZCA9CisJCQlXUEFfR0VUX0xFMTYoZWxlbXMuYnNzX21heF9pZGxlX3BlcmlvZCk7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV05NOiBCU1MgTWF4IElkbGUgUGVyaW9kOiAldSAoKiAxMDAwICIKKwkJCSAgICJUVSklcyIsIHdwYV9zLT5zbWUuYnNzX21heF9pZGxlX3BlcmlvZCwKKwkJCSAgIChlbGVtcy5ic3NfbWF4X2lkbGVfcGVyaW9kWzJdICYgMHgwMSkgPworCQkJICAgIiAocHJvdGVjdGVkIGtlZXAtbGl2ZSByZXF1aXJlZCkiIDogIiIpOworCQlpZiAod3BhX3MtPnNtZS5ic3NfbWF4X2lkbGVfcGVyaW9kID09IDApCisJCQl3cGFfcy0+c21lLmJzc19tYXhfaWRsZV9wZXJpb2QgPSAxOworCQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfU01FKSB7CisJCQllbG9vcF9jYW5jZWxfdGltZW91dCh3bm1fYnNzX2tlZXBfYWxpdmUsIHdwYV9zLCBOVUxMKTsKKwkJCSAvKiBtc2VjIHRpbWVzIDEwMDAgKi8KKwkJCW1zZWMgPSB3cGFfcy0+c21lLmJzc19tYXhfaWRsZV9wZXJpb2QgKiAxMDI0OworCQkJaWYgKG1zZWMgPiAxMDApCisJCQkJbXNlYyAtPSAxMDA7CisJCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KG1zZWMgLyAxMDAwLCBtc2VjICUgMTAwMCAqIDEwMDAsCisJCQkJCSAgICAgICB3bm1fYnNzX2tlZXBfYWxpdmUsIHdwYV9zLAorCQkJCQkgICAgICAgTlVMTCk7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX1NNRSAqLworfQorCisjZW5kaWYgLyogQ09ORklHX1dOTSAqLworCisKK3ZvaWQgd25tX2Jzc19rZWVwX2FsaXZlX2RlaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworI2lmZGVmIENPTkZJR19XTk0KKwllbG9vcF9jYW5jZWxfdGltZW91dCh3bm1fYnNzX2tlZXBfYWxpdmUsIHdwYV9zLCBOVUxMKTsKKyNlbmRpZiAvKiBDT05GSUdfV05NICovCit9CisKKwogc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9ldmVudF9hc3NvY2luZm8oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICB1bmlvbiB3cGFfZXZlbnRfZGF0YSAqZGF0YSkKIHsKQEAgLTEyNDUsNiArMTM0OCwxMCBAQAogCQl3cGFfdGRsc19hc3NvY19yZXNwX2llcyh3cGFfcy0+d3BhLCBkYXRhLT5hc3NvY19pbmZvLnJlc3BfaWVzLAogCQkJCQlkYXRhLT5hc3NvY19pbmZvLnJlc3BfaWVzX2xlbik7CiAjZW5kaWYgLyogQ09ORklHX1RETFMgKi8KKyNpZmRlZiBDT05GSUdfV05NCisJCXdubV9wcm9jZXNzX2Fzc29jX3Jlc3Aod3BhX3MsIGRhdGEtPmFzc29jX2luZm8ucmVzcF9pZXMsCisJCQkJICAgICAgIGRhdGEtPmFzc29jX2luZm8ucmVzcF9pZXNfbGVuKTsKKyNlbmRpZiAvKiBDT05GSUdfV05NICovCiAJfQogCWlmIChkYXRhLT5hc3NvY19pbmZvLmJlYWNvbl9pZXMpCiAJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgImJlYWNvbl9pZXMiLApAQCAtMTcwMiw5ICsxODA5LDE4IEBACiAJaWYgKHdwYV9zLT53cGFfc3RhdGUgPj0gV1BBX0FVVEhFTlRJQ0FUSU5HKQogCQl3cGFzX2Nvbm5lY3Rpb25fZmFpbGVkKHdwYV9zLCBic3NpZCk7CiAJd3BhX3NtX25vdGlmeV9kaXNhc3NvYyh3cGFfcy0+d3BhKTsKLQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX0RJU0NPTk5FQ1RFRCAiYnNzaWQ9IiBNQUNTVFIKLQkJIiByZWFzb249JWQiLAotCQlNQUMyU1RSKGJzc2lkKSwgcmVhc29uX2NvZGUpOworCWlmIChsb2NhbGx5X2dlbmVyYXRlZCkKKwkJd3BhX3MtPmRpc2Nvbm5lY3RfcmVhc29uID0gLXJlYXNvbl9jb2RlOworCWVsc2UKKwkJd3BhX3MtPmRpc2Nvbm5lY3RfcmVhc29uID0gcmVhc29uX2NvZGU7CisJd3Bhc19ub3RpZnlfZGlzY29ubmVjdF9yZWFzb24od3BhX3MpOworCWlmICghaXNfemVyb19ldGhlcl9hZGRyKGJzc2lkKSB8fAorCSAgICB3cGFfcy0+d3BhX3N0YXRlID49IFdQQV9BVVRIRU5USUNBVElORykgeworCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX0RJU0NPTk5FQ1RFRCAiYnNzaWQ9IiBNQUNTVFIKKwkJCSIgcmVhc29uPSVkJXMiLAorCQkJTUFDMlNUUihic3NpZCksIHJlYXNvbl9jb2RlLAorCQkJbG9jYWxseV9nZW5lcmF0ZWQgPyAiIGxvY2FsbHlfZ2VuZXJhdGVkPTEiIDogIiIpOworCX0KIAlpZiAod3BhX3N1cHBsaWNhbnRfZHluYW1pY19rZXlzKHdwYV9zKSkgewogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJEaXNjb25uZWN0IGV2ZW50IC0gcmVtb3ZlIGtleXMiKTsKIAkJd3BhX3MtPmtleXNfY2xlYXJlZCA9IDA7CkBAIC0xODY3LDExICsxOTgzLDEzIEBACiAJCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIkZhaWxlZCB0byBpbml0aWFsaXplIHRoZSAiCiAJCQkJImRyaXZlciBhZnRlciBpbnRlcmZhY2Ugd2FzIGFkZGVkIik7CiAJCX0KKwkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfRElTQ09OTkVDVEVEKTsKIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9JTlRFUkZBQ0VfUkVNT1ZFRDoKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiQ29uZmlndXJlZCBpbnRlcmZhY2Ugd2FzIHJlbW92ZWQiKTsKIAkJd3BhX3MtPmludGVyZmFjZV9yZW1vdmVkID0gMTsKIAkJd3BhX3N1cHBsaWNhbnRfbWFya19kaXNhc3NvYyh3cGFfcyk7CisJCXdwYV9zdXBwbGljYW50X3NldF9zdGF0ZSh3cGFfcywgV1BBX0lOVEVSRkFDRV9ESVNBQkxFRCk7CiAJCWwyX3BhY2tldF9kZWluaXQod3BhX3MtPmwyKTsKIAkJd3BhX3MtPmwyID0gTlVMTDsKICNpZmRlZiBDT05GSUdfSUJTU19SU04KQEAgLTIxMDQsOCArMjIyMiw3IEBACiB7CiAJaW50IGxldmVsID0gTVNHX0RFQlVHOwogCi0JaWYgKGV2ZW50ID09IEVWRU5UX1JYX01HTVQgJiYgZGF0YSAmJiBkYXRhLT5yeF9tZ210LmZyYW1lICYmCi0JICAgIGRhdGEtPnJ4X21nbXQuZnJhbWVfbGVuID49IDI0KSB7CisJaWYgKGV2ZW50ID09IEVWRU5UX1JYX01HTVQgJiYgZGF0YS0+cnhfbWdtdC5mcmFtZV9sZW4gPj0gMjQpIHsKIAkJY29uc3Qgc3RydWN0IGllZWU4MDIxMV9oZHIgKmhkcjsKIAkJdTE2IGZjOwogCQloZHIgPSAoY29uc3Qgc3RydWN0IGllZWU4MDIxMV9oZHIgKikgZGF0YS0+cnhfbWdtdC5mcmFtZTsKQEAgLTIxNjEsNyArMjI3OCw4IEBACiAJCQl3cGFzX3AycF9kaXNhc3NvY19ub3RpZigKIAkJCQl3cGFfcywgZGF0YS0+ZGlzYXNzb2NfaW5mby5hZGRyLCByZWFzb25fY29kZSwKIAkJCQlkYXRhLT5kaXNhc3NvY19pbmZvLmllLAotCQkJCWRhdGEtPmRpc2Fzc29jX2luZm8uaWVfbGVuKTsKKwkJCQlkYXRhLT5kaXNhc3NvY19pbmZvLmllX2xlbiwKKwkJCQlsb2NhbGx5X2dlbmVyYXRlZCk7CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCQl9CiAJCWlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19TTUUpCkBAIC0yMTg5LDEzICsyMzA3LDYgQEAKIAkJCQkJICAgICJEZWF1dGhlbnRpY2F0aW9uIGZyYW1lIElFKHMpIiwKIAkJCQkJICAgIGRhdGEtPmRlYXV0aF9pbmZvLmllLAogCQkJCQkgICAgZGF0YS0+ZGVhdXRoX2luZm8uaWVfbGVuKTsKLSNpZmRlZiBDT05GSUdfUDJQCi0JCQkJd3Bhc19wMnBfZGVhdXRoX25vdGlmKAotCQkJCQl3cGFfcywgZGF0YS0+ZGVhdXRoX2luZm8uYWRkciwKLQkJCQkJcmVhc29uX2NvZGUsCi0JCQkJCWRhdGEtPmRlYXV0aF9pbmZvLmllLAotCQkJCQlkYXRhLT5kZWF1dGhfaW5mby5pZV9sZW4pOwotI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJCX0KIAkJfQogI2lmZGVmIENPTkZJR19BUApAQCAtMjIxMiw2ICsyMzIzLDE1IEBACiAjZW5kaWYgLyogQ09ORklHX0FQICovCiAJCXdwYV9zdXBwbGljYW50X2V2ZW50X2Rpc2Fzc29jKHdwYV9zLCByZWFzb25fY29kZSwKIAkJCQkJICAgICAgbG9jYWxseV9nZW5lcmF0ZWQpOworI2lmZGVmIENPTkZJR19QMlAKKwkJaWYgKGV2ZW50ID09IEVWRU5UX0RFQVVUSCAmJiBkYXRhKSB7CisJCQl3cGFzX3AycF9kZWF1dGhfbm90aWYod3BhX3MsIGRhdGEtPmRlYXV0aF9pbmZvLmFkZHIsCisJCQkJCSAgICAgIHJlYXNvbl9jb2RlLAorCQkJCQkgICAgICBkYXRhLT5kZWF1dGhfaW5mby5pZSwKKwkJCQkJICAgICAgZGF0YS0+ZGVhdXRoX2luZm8uaWVfbGVuLAorCQkJCQkgICAgICBsb2NhbGx5X2dlbmVyYXRlZCk7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAJCWJyZWFrOwogCWNhc2UgRVZFTlRfTUlDSEFFTF9NSUNfRkFJTFVSRToKIAkJd3BhX3N1cHBsaWNhbnRfZXZlbnRfbWljaGFlbF9taWNfZmFpbHVyZSh3cGFfcywgZGF0YSk7CkBAIC0yMjYzLDggKzIzODMsNyBAQAogCQlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfU01FKQogCQkJc21lX2V2ZW50X2Fzc29jX3JlamVjdCh3cGFfcywgZGF0YSk7CiAjaWZkZWYgQU5EUk9JRF9QMlAKLSNpZmRlZiBDT05GSUdfUDJQCi0JCWVsc2UgaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlICE9IE5PVF9QMlBfR1JPVVBfSU5URVJGQUNFKSB7CisJCWVsc2UgewogCiAJCQlpZighd3BhX3MtPmN1cnJlbnRfc3NpZCkgewogCQkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiY3VycmVudF9zc2lkID09IE5VTEwiKTsKQEAgLTIyOTEsMTIgKzI0MTAsMTMgQEAKIAkJCSAJICovCiAJCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJBc3NvYyByZXRyeSB0aHJlc2hvbGQgcmVhY2hlZC4gIgogCQkJCSJEaXNhYmxpbmcgdGhlIG5ldHdvcmsiKTsKLQkJCQl3cGFfcy0+Y3VycmVudF9zc2lkLT5hc3NvY19yZXRyeSA9IDA7CiAJCQkJd3BhX3N1cHBsaWNhbnRfZGlzYWJsZV9uZXR3b3JrKHdwYV9zLCB3cGFfcy0+Y3VycmVudF9zc2lkKTsKLQkJCQl3cGFzX3AycF9ncm91cF9yZW1vdmUod3BhX3MsIHdwYV9zLT5pZm5hbWUpOworI2lmZGVmIENPTkZJR19QMlAKKwkJCQlpZih3cGFfcy0+cDJwX2dyb3VwX2ludGVyZmFjZSAhPSBOT1RfUDJQX0dST1VQX0lOVEVSRkFDRSkKKwkJCQkJd3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHdwYV9zLCB3cGFfcy0+aWZuYW1lKTsKKyNlbmRpZgogCQkJfQogCQl9Ci0jZW5kaWYKICNlbmRpZiAvKiBBTkRST0lEX1AyUCAqLwogCQlicmVhazsKIAljYXNlIEVWRU5UX0FVVEhfVElNRURfT1VUOgpAQCAtMjM4MiwxNSArMjUwMiwzMiBAQAogCQlhcF9yeF9mcm9tX3Vua25vd25fc3RhKHdwYV9zLCBkYXRhLT5yeF9mcm9tX3Vua25vd24uYWRkciwKIAkJCQkgICAgICAgZGF0YS0+cnhfZnJvbV91bmtub3duLndkcyk7CiAJCWJyZWFrOwotCWNhc2UgRVZFTlRfUlhfTUdNVDoKKwljYXNlIEVWRU5UX0NIX1NXSVRDSDoKKwkJaWYgKCFkYXRhKQorCQkJYnJlYWs7CisJCWlmICghd3BhX3MtPmFwX2lmYWNlKSB7CisJCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJBUDogSWdub3JlIGNoYW5uZWwgc3dpdGNoICIKKwkJCQkiZXZlbnQgaW4gbm9uLUFQIG1vZGUiKTsKKwkJCWJyZWFrOworCQl9CisKKyNpZmRlZiBDT05GSUdfQVAKKwkJd3Bhc19hcF9jaF9zd2l0Y2god3BhX3MsIGRhdGEtPmNoX3N3aXRjaC5mcmVxLAorCQkJCSAgZGF0YS0+Y2hfc3dpdGNoLmh0X2VuYWJsZWQsCisJCQkJICBkYXRhLT5jaF9zd2l0Y2guY2hfb2Zmc2V0KTsKKyNlbmRpZiAvKiBDT05GSUdfQVAgKi8KKwkJYnJlYWs7CisJY2FzZSBFVkVOVF9SWF9NR01UOiB7CisJCXUxNiBmYywgc3R5cGU7CisJCWNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqbWdtdDsKKworCQltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKQorCQkJZGF0YS0+cnhfbWdtdC5mcmFtZTsKKwkJZmMgPSBsZV90b19ob3N0MTYobWdtdC0+ZnJhbWVfY29udHJvbCk7CisJCXN0eXBlID0gV0xBTl9GQ19HRVRfU1RZUEUoZmMpOworCiAJCWlmICh3cGFfcy0+YXBfaWZhY2UgPT0gTlVMTCkgewogI2lmZGVmIENPTkZJR19QMlAKLQkJCXUxNiBmYywgc3R5cGU7Ci0JCQljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX21nbXQgKm1nbXQ7Ci0JCQltZ210ID0gKGNvbnN0IHN0cnVjdCBpZWVlODAyMTFfbWdtdCAqKQotCQkJCWRhdGEtPnJ4X21nbXQuZnJhbWU7Ci0JCQlmYyA9IGxlX3RvX2hvc3QxNihtZ210LT5mcmFtZV9jb250cm9sKTsKLQkJCXN0eXBlID0gV0xBTl9GQ19HRVRfU1RZUEUoZmMpOwogCQkJaWYgKHN0eXBlID09IFdMQU5fRkNfU1RZUEVfUFJPQkVfUkVRICYmCiAJCQkgICAgZGF0YS0+cnhfbWdtdC5mcmFtZV9sZW4gPiAyNCkgewogCQkJCWNvbnN0IHU4ICpzcmMgPSBtZ210LT5zYTsKQEAgLTIzOTgsOCArMjUzNSwxMCBAQAogCQkJCXNpemVfdCBpZV9sZW4gPSBkYXRhLT5yeF9tZ210LmZyYW1lX2xlbiAtCiAJCQkJCShtZ210LT51LnByb2JlX3JlcS52YXJpYWJsZSAtCiAJCQkJCSBkYXRhLT5yeF9tZ210LmZyYW1lKTsKLQkJCQl3cGFzX3AycF9wcm9iZV9yZXFfcngod3BhX3MsIHNyYywgbWdtdC0+ZGEsCi0JCQkJCQkgICAgICBtZ210LT5ic3NpZCwgaWUsIGllX2xlbik7CisJCQkJd3Bhc19wMnBfcHJvYmVfcmVxX3J4KAorCQkJCQl3cGFfcywgc3JjLCBtZ210LT5kYSwKKwkJCQkJbWdtdC0+YnNzaWQsIGllLCBpZV9sZW4sCisJCQkJCWRhdGEtPnJ4X21nbXQuc3NpX3NpZ25hbCk7CiAJCQkJYnJlYWs7CiAJCQl9CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwpAQCAtMjQwNyw4ICsyNTQ2LDIyIEBACiAJCQkJIm1hbmFnZW1lbnQgZnJhbWUgaW4gbm9uLUFQIG1vZGUiKTsKIAkJCWJyZWFrOwogCQl9CisKKwkJaWYgKHN0eXBlID09IFdMQU5fRkNfU1RZUEVfUFJPQkVfUkVRICYmCisJCSAgICBkYXRhLT5yeF9tZ210LmZyYW1lX2xlbiA+IDI0KSB7CisJCQljb25zdCB1OCAqaWUgPSBtZ210LT51LnByb2JlX3JlcS52YXJpYWJsZTsKKwkJCXNpemVfdCBpZV9sZW4gPSBkYXRhLT5yeF9tZ210LmZyYW1lX2xlbiAtCisJCQkJKG1nbXQtPnUucHJvYmVfcmVxLnZhcmlhYmxlIC0KKwkJCQkgZGF0YS0+cnhfbWdtdC5mcmFtZSk7CisKKwkJCXdwYXNfbm90aWZ5X3ByZXEod3BhX3MsIG1nbXQtPnNhLCBtZ210LT5kYSwKKwkJCQkJIG1nbXQtPmJzc2lkLCBpZSwgaWVfbGVuLAorCQkJCQkgZGF0YS0+cnhfbWdtdC5zc2lfc2lnbmFsKTsKKwkJfQorCiAJCWFwX21nbXRfcngod3BhX3MsICZkYXRhLT5yeF9tZ210KTsKIAkJYnJlYWs7CisJCX0KICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KIAljYXNlIEVWRU5UX1JYX0FDVElPTjoKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUmVjZWl2ZWQgQWN0aW9uIGZyYW1lOiBTQT0iIE1BQ1NUUgpAQCAtMjQ3NSw3ICsyNjI4LDggQEAKIAkJCQkJICAgICBkYXRhLT5yeF9wcm9iZV9yZXEuZGEsCiAJCQkJCSAgICAgZGF0YS0+cnhfcHJvYmVfcmVxLmJzc2lkLAogCQkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZSwKLQkJCQkJICAgICBkYXRhLT5yeF9wcm9iZV9yZXEuaWVfbGVuKTsKKwkJCQkJICAgICBkYXRhLT5yeF9wcm9iZV9yZXEuaWVfbGVuLAorCQkJCQkgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5zc2lfc2lnbmFsKTsKIAkJCWJyZWFrOwogCQl9CiAjZW5kaWYgLyogQ09ORklHX0FQICovCkBAIC0yNDg0LDcgKzI2MzgsOCBAQAogCQkJCSAgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5kYSwKIAkJCQkgICAgICBkYXRhLT5yeF9wcm9iZV9yZXEuYnNzaWQsCiAJCQkJICAgICAgZGF0YS0+cnhfcHJvYmVfcmVxLmllLAotCQkJCSAgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZV9sZW4pOworCQkJCSAgICAgIGRhdGEtPnJ4X3Byb2JlX3JlcS5pZV9sZW4sCisJCQkJICAgICAgZGF0YS0+cnhfcHJvYmVfcmVxLnNzaV9zaWduYWwpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIAkJYnJlYWs7CiAJY2FzZSBFVkVOVF9SRU1BSU5fT05fQ0hBTk5FTDoKQEAgLTI2MTIsNiArMjc2NywxMSBAQAogCWNhc2UgRVZFTlRfQ0hBTk5FTF9MSVNUX0NIQU5HRUQ6CiAJCWlmICh3cGFfcy0+ZHJ2X3ByaXYgPT0gTlVMTCkKIAkJCWJyZWFrOyAvKiBJZ25vcmUgZXZlbnQgZHVyaW5nIGRydiBpbml0aWFsaXphdGlvbiAqLworCisJCWZyZWVfaHdfZmVhdHVyZXMod3BhX3MpOworCQl3cGFfcy0+aHcubW9kZXMgPSB3cGFfZHJ2X2dldF9od19mZWF0dXJlX2RhdGEoCisJCQl3cGFfcywgJndwYV9zLT5ody5udW1fbW9kZXMsICZ3cGFfcy0+aHcuZmxhZ3MpOworCiAjaWZkZWYgQ09ORklHX1AyUAogCQl3cGFzX3AycF91cGRhdGVfY2hhbm5lbF9saXN0KHdwYV9zKTsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9leGFtcGxlcy9kYnVzLWxpc3Rlbi1wcmVxLnB5IGIvd3BhX3N1cHBsaWNhbnQvZXhhbXBsZXMvZGJ1cy1saXN0ZW4tcHJlcS5weQpuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi41YWM5ODU5Ci0tLSAvZGV2L251bGwKKysrIGIvd3BhX3N1cHBsaWNhbnQvZXhhbXBsZXMvZGJ1cy1saXN0ZW4tcHJlcS5weQpAQCAtMCwwICsxLDYyIEBACisjIS91c3IvYmluL3B5dGhvbgorCitpbXBvcnQgZGJ1cworaW1wb3J0IHN5cworaW1wb3J0IHRpbWUKK2ltcG9ydCBnb2JqZWN0Citmcm9tIGRidXMubWFpbmxvb3AuZ2xpYiBpbXBvcnQgREJ1c0dNYWluTG9vcAorCitXUEFTX0RCVVNfU0VSVklDRSA9ICJmaS53MS53cGFfc3VwcGxpY2FudDEiCitXUEFTX0RCVVNfSU5URVJGQUNFID0gImZpLncxLndwYV9zdXBwbGljYW50MSIKK1dQQVNfREJVU19PUEFUSCA9ICIvZmkvdzEvd3BhX3N1cHBsaWNhbnQxIgorV1BBU19EQlVTX0lOVEVSRkFDRVNfSU5URVJGQUNFID0gImZpLncxLndwYV9zdXBwbGljYW50MS5JbnRlcmZhY2UiCisKK2RlZiB1c2FnZSgpOgorCXByaW50ICJVc2FnZTogJXMgPGlmbmFtZT4iICUgc3lzLmFyZ3ZbMF0KKwlwcmludCAiUHJlc3MgQ3RybC1DIHRvIHN0b3AiCisKK2RlZiBQcm9iZVJlcXVlc3QoYXJncyk6CisJaWYgJ2FkZHInIGluIGFyZ3M6CisJCXByaW50ICclLjJ4OiUuMng6JS4yeDolLjJ4OiUuMng6JS4yeCcgJSB0dXBsZShhcmdzWydhZGRyJ10pLAorCWlmICdkc3QnIGluIGFyZ3M6CisJCXByaW50ICctPiAlLjJ4OiUuMng6JS4yeDolLjJ4OiUuMng6JS4yeCcgJSB0dXBsZShhcmdzWydkc3QnXSksCisJaWYgJ2Jzc2lkJyBpbiBhcmdzOgorCQlwcmludCAnKGJzc2lkICUuMng6JS4yeDolLjJ4OiUuMng6JS4yeDolLjJ4KScgJSB0dXBsZShhcmdzWydkc3QnXSksCisJaWYgJ3NpZ25hbCcgaW4gYXJnczoKKwkJcHJpbnQgJ3NpZ25hbDolZCcgJSBhcmdzWydzaWduYWwnXSwKKwlpZiAnaWVzJyBpbiBhcmdzOgorCQlwcmludCAnaGF2ZSBJRXMgKCVkIGJ5dGVzKScgJSBsZW4oYXJnc1snaWVzJ10pLAorICAgICAgICBwcmludCAnJworCitpZiBfX25hbWVfXyA9PSAiX19tYWluX18iOgorCWdsb2JhbCBidXMKKwlnbG9iYWwgd3Bhc19vYmoKKwlnbG9iYWwgaWZfb2JqCisJZ2xvYmFsIHAycF9pZmFjZQorCisJZGJ1cy5tYWlubG9vcC5nbGliLkRCdXNHTWFpbkxvb3Aoc2V0X2FzX2RlZmF1bHQ9VHJ1ZSkKKworCWJ1cyA9IGRidXMuU3lzdGVtQnVzKCkKKwl3cGFzX29iaiA9IGJ1cy5nZXRfb2JqZWN0KFdQQVNfREJVU19TRVJWSUNFLCBXUEFTX0RCVVNfT1BBVEgpCisKKwkjIFByaW50IGxpc3Qgb2YgaS9mIGlmIG5vIG9uZSBpcyBzcGVjaWZpZWQKKwlpZiAobGVuKHN5cy5hcmd2KSA8IDIpICA6CisJCXVzYWdlKCkKKwkJc3lzLmV4aXQoMCkKKworCXdwYXMgPSBkYnVzLkludGVyZmFjZSh3cGFzX29iaiwgV1BBU19EQlVTX0lOVEVSRkFDRSkKKworCWlmbmFtZSA9IHN5cy5hcmd2WzFdCisKKwlwYXRoID0gd3Bhcy5HZXRJbnRlcmZhY2UoaWZuYW1lKQorCisJaWZfb2JqID0gYnVzLmdldF9vYmplY3QoV1BBU19EQlVTX1NFUlZJQ0UsIHBhdGgpCisJaWZhY2UgPSBkYnVzLkludGVyZmFjZShpZl9vYmosIFdQQVNfREJVU19JTlRFUkZBQ0VTX0lOVEVSRkFDRSkKKworCWJ1cy5hZGRfc2lnbmFsX3JlY2VpdmVyKFByb2JlUmVxdWVzdCwKKwkJCQlkYnVzX2ludGVyZmFjZT1XUEFTX0RCVVNfSU5URVJGQUNFU19JTlRFUkZBQ0UsCisJCQkJc2lnbmFsX25hbWU9IlByb2JlUmVxdWVzdCIpCisKKwlpZmFjZS5TdWJzY3JpYmVQcm9iZVJlcSgpCisKKwlnb2JqZWN0Lk1haW5Mb29wKCkucnVuKCkKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2hzMjBfc3VwcGxpY2FudC5jIGIvd3BhX3N1cHBsaWNhbnQvaHMyMF9zdXBwbGljYW50LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmFmYTE2YwotLS0gL2Rldi9udWxsCisrKyBiL3dwYV9zdXBwbGljYW50L2hzMjBfc3VwcGxpY2FudC5jCkBAIC0wLDAgKzEsMTcyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA5LCBBdGhlcm9zIENvbW11bmljYXRpb25zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEtMjAxMiwgUXVhbGNvbW0gQXRoZXJvcywgSW5jLgorICoKKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgImluY2x1ZGVzLmgiCisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJlbG9vcC5oIgorI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgorI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKKyNpbmNsdWRlICJjb21tb24vZ2FzLmgiCisjaW5jbHVkZSAiY29tbW9uL3dwYV9jdHJsLmgiCisjaW5jbHVkZSAid3BhX3N1cHBsaWNhbnRfaS5oIgorI2luY2x1ZGUgImRyaXZlcl9pLmgiCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiYnNzLmgiCisjaW5jbHVkZSAiZ2FzX3F1ZXJ5LmgiCisjaW5jbHVkZSAiaW50ZXJ3b3JraW5nLmgiCisjaW5jbHVkZSAiaHMyMF9zdXBwbGljYW50LmgiCisKKwordm9pZCB3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCXdwYWJ1Zl9wdXRfdTgoYnVmLCBXTEFOX0VJRF9WRU5ET1JfU1BFQ0lGSUMpOworCXdwYWJ1Zl9wdXRfdTgoYnVmLCA1KTsKKwl3cGFidWZfcHV0X2JlMjQoYnVmLCBPVUlfV0ZBKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgSFMyMF9JTkRJQ0FUSU9OX09VSV9UWVBFKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgMHgwMCk7IC8qIEhvdHNwb3QgQ29uZmlndXJhdGlvbiAqLworfQorCisKK3N0cnVjdCB3cGFidWYgKiBoczIwX2J1aWxkX2FucXBfcmVxKHUzMiBzdHlwZXMsIGNvbnN0IHU4ICpwYXlsb2FkLAorCQkJCSAgICBzaXplX3QgcGF5bG9hZF9sZW4pCit7CisJc3RydWN0IHdwYWJ1ZiAqYnVmOworCXU4ICpsZW5fcG9zOworCisJYnVmID0gZ2FzX2FucXBfYnVpbGRfaW5pdGlhbF9yZXEoMCwgMTAwICsgcGF5bG9hZF9sZW4pOworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CisKKwlsZW5fcG9zID0gZ2FzX2FucXBfYWRkX2VsZW1lbnQoYnVmLCBBTlFQX1ZFTkRPUl9TUEVDSUZJQyk7CisJd3BhYnVmX3B1dF9iZTI0KGJ1ZiwgT1VJX1dGQSk7CisJd3BhYnVmX3B1dF91OChidWYsIEhTMjBfQU5RUF9PVUlfVFlQRSk7CisJaWYgKHN0eXBlcyA9PSBCSVQoSFMyMF9TVFlQRV9OQUlfSE9NRV9SRUFMTV9RVUVSWSkpIHsKKwkJd3BhYnVmX3B1dF91OChidWYsIEhTMjBfU1RZUEVfTkFJX0hPTUVfUkVBTE1fUVVFUlkpOworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgMCk7IC8qIFJlc2VydmVkICovCisJCWlmIChwYXlsb2FkKQorCQkJd3BhYnVmX3B1dF9kYXRhKGJ1ZiwgcGF5bG9hZCwgcGF5bG9hZF9sZW4pOworCX0gZWxzZSB7CisJCXU4IGk7CisJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBIUzIwX1NUWVBFX1FVRVJZX0xJU1QpOworCQl3cGFidWZfcHV0X3U4KGJ1ZiwgMCk7IC8qIFJlc2VydmVkICovCisJCWZvciAoaSA9IDA7IGkgPCAzMjsgaSsrKSB7CisJCQlpZiAoc3R5cGVzICYgQklUKGkpKQorCQkJCXdwYWJ1Zl9wdXRfdTgoYnVmLCBpKTsKKwkJfQorCX0KKwlnYXNfYW5xcF9zZXRfZWxlbWVudF9sZW4oYnVmLCBsZW5fcG9zKTsKKworCWdhc19hbnFwX3NldF9sZW4oYnVmKTsKKworCXJldHVybiBidWY7Cit9CisKKworaW50IGhzMjBfYW5xcF9zZW5kX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqZHN0LCB1MzIgc3R5cGVzLAorCQkgICAgICAgY29uc3QgdTggKnBheWxvYWQsIHNpemVfdCBwYXlsb2FkX2xlbikKK3sKKwlzdHJ1Y3Qgd3BhYnVmICpidWY7CisJaW50IHJldCA9IDA7CisJaW50IGZyZXE7CisJc3RydWN0IHdwYV9ic3MgKmJzczsKKwlpbnQgcmVzOworCisJZnJlcSA9IHdwYV9zLT5hc3NvY19mcmVxOworCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkKHdwYV9zLCBkc3QpOworCWlmIChic3MpCisJCWZyZXEgPSBic3MtPmZyZXE7CisJaWYgKGZyZXEgPD0gMCkKKwkJcmV0dXJuIC0xOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUzIwOiBBTlFQIFF1ZXJ5IFJlcXVlc3QgdG8gIiBNQUNTVFIgIiBmb3IgIgorCQkgICAic3VidHlwZXMgMHgleCIsIE1BQzJTVFIoZHN0KSwgc3R5cGVzKTsKKworCWJ1ZiA9IGhzMjBfYnVpbGRfYW5xcF9yZXEoc3R5cGVzLCBwYXlsb2FkLCBwYXlsb2FkX2xlbik7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwlyZXMgPSBnYXNfcXVlcnlfcmVxKHdwYV9zLT5nYXMsIGRzdCwgZnJlcSwgYnVmLCBhbnFwX3Jlc3BfY2IsIHdwYV9zKTsKKwlpZiAocmVzIDwgMCkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkFOUVA6IEZhaWxlZCB0byBzZW5kIFF1ZXJ5IFJlcXVlc3QiKTsKKwkJcmV0ID0gLTE7CisJfSBlbHNlCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQU5RUDogUXVlcnkgc3RhcnRlZCB3aXRoIGRpYWxvZyB0b2tlbiAiCisJCQkgICAiJXUiLCByZXMpOworCisJd3BhYnVmX2ZyZWUoYnVmKTsKKwlyZXR1cm4gcmV0OworfQorCisKK3ZvaWQgaHMyMF9wYXJzZV9yeF9oczIwX2FucXBfcmVzcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgY29uc3QgdTggKnNhLCBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IHNsZW4pCit7CisJY29uc3QgdTggKnBvcyA9IGRhdGE7CisJdTggc3VidHlwZTsKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gd3BhX2Jzc19nZXRfYnNzaWQod3BhX3MsIHNhKTsKKworCWlmIChzbGVuIDwgMikKKwkJcmV0dXJuOworCisJc3VidHlwZSA9ICpwb3MrKzsKKwlzbGVuLS07CisKKwlwb3MrKzsgLyogUmVzZXJ2ZWQgKi8KKwlzbGVuLS07CisKKwlzd2l0Y2ggKHN1YnR5cGUpIHsKKwljYXNlIEhTMjBfU1RZUEVfQ0FQQUJJTElUWV9MSVNUOgorCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIlJYLUhTMjAtQU5RUCAiIE1BQ1NUUgorCQkJIiBIUyBDYXBhYmlsaXR5IExpc3QiLCBNQUMyU1RSKHNhKSk7CisJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIkhTIENhcGFiaWxpdHkgTGlzdCIsIHBvcywgc2xlbik7CisJCWJyZWFrOworCWNhc2UgSFMyMF9TVFlQRV9PUEVSQVRPUl9GUklFTkRMWV9OQU1FOgorCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgIlJYLUhTMjAtQU5RUCAiIE1BQ1NUUgorCQkJIiBPcGVyYXRvciBGcmllbmRseSBOYW1lIiwgTUFDMlNUUihzYSkpOworCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJvcGVyIGZyaWVuZGx5IG5hbWUiLCBwb3MsIHNsZW4pOworCQlpZiAoYnNzKSB7CisJCQl3cGFidWZfZnJlZShic3MtPmhzMjBfb3BlcmF0b3JfZnJpZW5kbHlfbmFtZSk7CisJCQlic3MtPmhzMjBfb3BlcmF0b3JfZnJpZW5kbHlfbmFtZSA9CisJCQkJd3BhYnVmX2FsbG9jX2NvcHkocG9zLCBzbGVuKTsKKwkJfQorCQlicmVhazsKKwljYXNlIEhTMjBfU1RZUEVfV0FOX01FVFJJQ1M6CisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiUlgtSFMyMC1BTlFQICIgTUFDU1RSCisJCQkiIFdBTiBNZXRyaWNzIiwgTUFDMlNUUihzYSkpOworCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJXQU4gTWV0cmljcyIsIHBvcywgc2xlbik7CisJCWlmIChic3MpIHsKKwkJCXdwYWJ1Zl9mcmVlKGJzcy0+aHMyMF93YW5fbWV0cmljcyk7CisJCQlic3MtPmhzMjBfd2FuX21ldHJpY3MgPSB3cGFidWZfYWxsb2NfY29weShwb3MsIHNsZW4pOworCQl9CisJCWJyZWFrOworCWNhc2UgSFMyMF9TVFlQRV9DT05ORUNUSU9OX0NBUEFCSUxJVFk6CisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiUlgtSFMyMC1BTlFQICIgTUFDU1RSCisJCQkiIENvbm5lY3Rpb24gQ2FwYWJpbGl0eSIsIE1BQzJTVFIoc2EpKTsKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiY29ubiBjYXBhYmlsaXR5IiwgcG9zLCBzbGVuKTsKKwkJaWYgKGJzcykgeworCQkJd3BhYnVmX2ZyZWUoYnNzLT5oczIwX2Nvbm5lY3Rpb25fY2FwYWJpbGl0eSk7CisJCQlic3MtPmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5ID0KKwkJCQl3cGFidWZfYWxsb2NfY29weShwb3MsIHNsZW4pOworCQl9CisJCWJyZWFrOworCWNhc2UgSFMyMF9TVFlQRV9PUEVSQVRJTkdfQ0xBU1M6CisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCAiUlgtSFMyMC1BTlFQICIgTUFDU1RSCisJCQkiIE9wZXJhdGluZyBDbGFzcyIsIE1BQzJTVFIoc2EpKTsKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiT3BlcmF0aW5nIENsYXNzIiwgcG9zLCBzbGVuKTsKKwkJaWYgKGJzcykgeworCQkJd3BhYnVmX2ZyZWUoYnNzLT5oczIwX29wZXJhdGluZ19jbGFzcyk7CisJCQlic3MtPmhzMjBfb3BlcmF0aW5nX2NsYXNzID0KKwkJCQl3cGFidWZfYWxsb2NfY29weShwb3MsIHNsZW4pOworCQl9CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSFMyMDogVW5zdXBwb3J0ZWQgc3VidHlwZSAldSIsIHN1YnR5cGUpOworCQlicmVhazsKKwl9Cit9CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9oczIwX3N1cHBsaWNhbnQuaCBiL3dwYV9zdXBwbGljYW50L2hzMjBfc3VwcGxpY2FudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZlYjM5MjYKLS0tIC9kZXYvbnVsbAorKysgYi93cGFfc3VwcGxpY2FudC9oczIwX3N1cHBsaWNhbnQuaApAQCAtMCwwICsxLDIwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDExLTIwMTIsIFF1YWxjb21tIEF0aGVyb3MsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgSFMyMF9TVVBQTElDQU5UX0gKKyNkZWZpbmUgSFMyMF9TVVBQTElDQU5UX0gKKwordm9pZCB3cGFzX2hzMjBfYWRkX2luZGljYXRpb24oc3RydWN0IHdwYWJ1ZiAqYnVmKTsKKworaW50IGhzMjBfYW5xcF9zZW5kX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqZHN0LCB1MzIgc3R5cGVzLAorCQkgICAgICAgY29uc3QgdTggKnBheWxvYWQsIHNpemVfdCBwYXlsb2FkX2xlbik7CitzdHJ1Y3Qgd3BhYnVmICogaHMyMF9idWlsZF9hbnFwX3JlcSh1MzIgc3R5cGVzLCBjb25zdCB1OCAqcGF5bG9hZCwKKwkJCQkgICAgc2l6ZV90IHBheWxvYWRfbGVuKTsKK3ZvaWQgaHMyMF9wYXJzZV9yeF9oczIwX2FucXBfcmVzcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgY29uc3QgdTggKnNhLCBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IHNsZW4pOworCisjZW5kaWYgLyogSFMyMF9TVVBQTElDQU5UX0ggKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L2ludGVyd29ya2luZy5jIGIvd3BhX3N1cHBsaWNhbnQvaW50ZXJ3b3JraW5nLmMKaW5kZXggYWM4OWZmOC4uNTE1ZDk0YiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvaW50ZXJ3b3JraW5nLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvaW50ZXJ3b3JraW5nLmMKQEAgLTEsNiArMSw2IEBACiAvKgogICogSW50ZXJ3b3JraW5nIChJRUVFIDgwMi4xMXUpCi0gKiBDb3B5cmlnaHQgKGMpIDIwMTEsIFF1YWxjb21tIEF0aGVyb3MKKyAqIENvcHlyaWdodCAoYykgMjAxMS0yMDEyLCBRdWFsY29tbSBBdGhlcm9zLCBJbmMuCiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBCU0QgbGljZW5zZS4KICAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KQEAgLTEyLDE1ICsxMiwxOCBAQAogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpbmNsdWRlICJjb21tb24vZ2FzLmgiCiAjaW5jbHVkZSAiY29tbW9uL3dwYV9jdHJsLmgiCisjaW5jbHVkZSAidXRpbHMvcGNzY19mdW5jcy5oIgogI2luY2x1ZGUgImRyaXZlcnMvZHJpdmVyLmgiCiAjaW5jbHVkZSAiZWFwX2NvbW1vbi9lYXBfZGVmcy5oIgogI2luY2x1ZGUgImVhcF9wZWVyL2VhcF9tZXRob2RzLmgiCiAjaW5jbHVkZSAid3BhX3N1cHBsaWNhbnRfaS5oIgogI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgImNvbmZpZ19zc2lkLmgiCiAjaW5jbHVkZSAiYnNzLmgiCiAjaW5jbHVkZSAic2Nhbi5oIgogI2luY2x1ZGUgIm5vdGlmeS5oIgogI2luY2x1ZGUgImdhc19xdWVyeS5oIgorI2luY2x1ZGUgImhzMjBfc3VwcGxpY2FudC5oIgogI2luY2x1ZGUgImludGVyd29ya2luZy5oIgogCiAKQEAgLTM5LDYgKzQyLDE5IEBACiBzdGF0aWMgdm9pZCBpbnRlcndvcmtpbmdfbmV4dF9hbnFwX2ZldGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogCiAKK3N0YXRpYyB2b2lkIGludGVyd29ya2luZ19yZWNvbm5lY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAod3BhX3MtPndwYV9zdGF0ZSA+PSBXUEFfQVVUSEVOVElDQVRJTkcpIHsKKwkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjaGVkX3NjYW4od3BhX3MpOworCQl3cGFfc3VwcGxpY2FudF9kZWF1dGhlbnRpY2F0ZSh3cGFfcywKKwkJCQkJICAgICAgV0xBTl9SRUFTT05fREVBVVRIX0xFQVZJTkcpOworCX0KKwl3cGFfcy0+ZGlzY29ubmVjdGVkID0gMDsKKwl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOworCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKK30KKworCiBzdGF0aWMgc3RydWN0IHdwYWJ1ZiAqIGFucXBfYnVpbGRfcmVxKHUxNiBpbmZvX2lkc1tdLCBzaXplX3QgbnVtX2lkcywKIAkJCQkgICAgICBzdHJ1Y3Qgd3BhYnVmICpleHRyYSkKIHsKQEAgLTEwMCw2ICsxMTYsMjggQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogQU5RUCBRdWVyeSBSZXF1ZXN0IHRvICIgTUFDU1RSLAogCQkgICBNQUMyU1RSKGJzcy0+YnNzaWQpKTsKIAorI2lmZGVmIENPTkZJR19IUzIwCisJaWYgKHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZShic3MsIEhTMjBfSUVfVkVORE9SX1RZUEUpKSB7CisJCXU4ICpsZW5fcG9zOworCisJCWV4dHJhID0gd3BhYnVmX2FsbG9jKDEwMCk7CisJCWlmICghZXh0cmEpCisJCQlyZXR1cm4gLTE7CisKKwkJbGVuX3BvcyA9IGdhc19hbnFwX2FkZF9lbGVtZW50KGV4dHJhLCBBTlFQX1ZFTkRPUl9TUEVDSUZJQyk7CisJCXdwYWJ1Zl9wdXRfYmUyNChleHRyYSwgT1VJX1dGQSk7CisJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIEhTMjBfQU5RUF9PVUlfVFlQRSk7CisJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIEhTMjBfU1RZUEVfUVVFUllfTElTVCk7CisJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIDApOyAvKiBSZXNlcnZlZCAqLworCQl3cGFidWZfcHV0X3U4KGV4dHJhLCBIUzIwX1NUWVBFX0NBUEFCSUxJVFlfTElTVCk7CisJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIEhTMjBfU1RZUEVfT1BFUkFUT1JfRlJJRU5ETFlfTkFNRSk7CisJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIEhTMjBfU1RZUEVfV0FOX01FVFJJQ1MpOworCQl3cGFidWZfcHV0X3U4KGV4dHJhLCBIUzIwX1NUWVBFX0NPTk5FQ1RJT05fQ0FQQUJJTElUWSk7CisJCXdwYWJ1Zl9wdXRfdTgoZXh0cmEsIEhTMjBfU1RZUEVfT1BFUkFUSU5HX0NMQVNTKTsKKwkJZ2FzX2FucXBfc2V0X2VsZW1lbnRfbGVuKGV4dHJhLCBsZW5fcG9zKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWJ1ZiA9IGFucXBfYnVpbGRfcmVxKGluZm9faWRzLCBzaXplb2YoaW5mb19pZHMpIC8gc2l6ZW9mKGluZm9faWRzWzBdKSwKIAkJCSAgICAgZXh0cmEpOwogCXdwYWJ1Zl9mcmVlKGV4dHJhKTsKQEAgLTQxNiwyMCArNDU0LDQxIEBACiB9CiAKIAotc3RhdGljIHN0cnVjdCBuYWlfcmVhbG1fZWFwICogbmFpX3JlYWxtX2ZpbmRfZWFwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCitzdGF0aWMgaW50IG5haV9yZWFsbV9jcmVkX2NlcnQoc3RydWN0IG5haV9yZWFsbV9lYXAgKmVhcCkKK3sKKwlpZiAoZWFwX2dldF9uYW1lKEVBUF9WRU5ET1JfSUVURiwgZWFwLT5tZXRob2QpID09IE5VTEwpCisJCXJldHVybiAwOyAvKiBtZXRob2Qgbm90IHN1cHBvcnRlZCAqLworCisJaWYgKGVhcC0+bWV0aG9kICE9IEVBUF9UWVBFX1RMUykgeworCQkvKiBPbmx5IEVBUC1UTFMgc3VwcG9ydGVkIGZvciBjcmVkZW50aWFsIGF1dGhlbnRpY2F0aW9uICovCisJCXJldHVybiAwOworCX0KKworCXJldHVybiAxOworfQorCisKK3N0YXRpYyBzdHJ1Y3QgbmFpX3JlYWxtX2VhcCAqIG5haV9yZWFsbV9maW5kX2VhcChzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsCiAJCQkJCQkgc3RydWN0IG5haV9yZWFsbSAqcmVhbG0pCiB7CiAJdTggZTsKIAotCWlmICh3cGFfcy0+Y29uZi0+aG9tZV91c2VybmFtZSA9PSBOVUxMIHx8Ci0JICAgIHdwYV9zLT5jb25mLT5ob21lX3VzZXJuYW1lWzBdID09ICdcMCcgfHwKLQkgICAgd3BhX3MtPmNvbmYtPmhvbWVfcGFzc3dvcmQgPT0gTlVMTCB8fAotCSAgICB3cGFfcy0+Y29uZi0+aG9tZV9wYXNzd29yZFswXSA9PSAnXDAnKQorCWlmIChjcmVkID09IE5VTEwgfHwKKwkgICAgY3JlZC0+dXNlcm5hbWUgPT0gTlVMTCB8fAorCSAgICBjcmVkLT51c2VybmFtZVswXSA9PSAnXDAnIHx8CisJICAgICgoY3JlZC0+cGFzc3dvcmQgPT0gTlVMTCB8fAorCSAgICAgIGNyZWQtPnBhc3N3b3JkWzBdID09ICdcMCcpICYmCisJICAgICAoY3JlZC0+cHJpdmF0ZV9rZXkgPT0gTlVMTCB8fAorCSAgICAgIGNyZWQtPnByaXZhdGVfa2V5WzBdID09ICdcMCcpKSkKIAkJcmV0dXJuIE5VTEw7CiAKIAlmb3IgKGUgPSAwOyBlIDwgcmVhbG0tPmVhcF9jb3VudDsgZSsrKSB7CiAJCXN0cnVjdCBuYWlfcmVhbG1fZWFwICplYXAgPSAmcmVhbG0tPmVhcFtlXTsKLQkJaWYgKG5haV9yZWFsbV9jcmVkX3VzZXJuYW1lKGVhcCkpCisJCWlmIChjcmVkLT5wYXNzd29yZCAmJiBjcmVkLT5wYXNzd29yZFswXSAmJgorCQkgICAgbmFpX3JlYWxtX2NyZWRfdXNlcm5hbWUoZWFwKSkKKwkJCXJldHVybiBlYXA7CisJCWlmIChjcmVkLT5wcml2YXRlX2tleSAmJiBjcmVkLT5wcml2YXRlX2tleVswXSAmJgorCQkgICAgbmFpX3JlYWxtX2NyZWRfY2VydChlYXApKQogCQkJcmV0dXJuIGVhcDsKIAl9CiAKQEAgLTQzOSwyMSArNDk4LDE3IEBACiAKICNpZmRlZiBJTlRFUldPUktJTkdfM0dQUAogCi1zdGF0aWMgaW50IHBsbW5faWRfbWF0Y2goc3RydWN0IHdwYWJ1ZiAqYW5xcCwgY29uc3QgY2hhciAqaW1zaSkKK3N0YXRpYyBpbnQgcGxtbl9pZF9tYXRjaChzdHJ1Y3Qgd3BhYnVmICphbnFwLCBjb25zdCBjaGFyICppbXNpLCBpbnQgbW5jX2xlbikKIHsKLQljb25zdCBjaGFyICpzZXA7CiAJdTggcGxtblszXTsKIAljb25zdCB1OCAqcG9zLCAqZW5kOwogCXU4IHVkaGw7CiAKLQlzZXAgPSBvc19zdHJjaHIoaW1zaSwgJy0nKTsKLQlpZiAoc2VwID09IE5VTEwgfHwgKHNlcCAtIGltc2kgIT0gNSAmJiBzZXAgLSBpbXNpICE9IDYpKQotCQlyZXR1cm4gMDsKLQogCS8qIFNlZSBBbm5leCBBIG9mIDNHUFAgVFMgMjQuMjM0IHY4LjEuMCBmb3IgZGVzY3JpcHRpb24gKi8KIAlwbG1uWzBdID0gKGltc2lbMF0gLSAnMCcpIHwgKChpbXNpWzFdIC0gJzAnKSA8PCA0KTsKIAlwbG1uWzFdID0gaW1zaVsyXSAtICcwJzsKLQlpZiAoc2VwIC0gaW1zaSA9PSA2KQorCS8qIGRlZmF1bHQgdG8gTU5DIGxlbmd0aCAzIGlmIHVua25vd24gKi8KKwlpZiAobW5jX2xlbiAhPSAyKQogCQlwbG1uWzFdIHw9IChpbXNpWzVdIC0gJzAnKSA8PCA0OwogCWVsc2UKIAkJcGxtblsxXSB8PSAweGYwOwpAQCAtNTA1LDEwICs1NjAsMTEgQEAKIH0KIAogCi1zdGF0aWMgaW50IHNldF9yb290X25haShzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsIGNvbnN0IGNoYXIgKmltc2ksIGNoYXIgcHJlZml4KQorc3RhdGljIGludCBidWlsZF9yb290X25haShjaGFyICpuYWksIHNpemVfdCBuYWlfbGVuLCBjb25zdCBjaGFyICppbXNpLAorCQkJICBjaGFyIHByZWZpeCkKIHsKIAljb25zdCBjaGFyICpzZXAsICptc2luOwotCWNoYXIgbmFpWzEwMF0sICplbmQsICpwb3M7CisJY2hhciAqZW5kLCAqcG9zOwogCXNpemVfdCBtc2luX2xlbiwgcGxtbl9sZW47CiAKIAkvKgpAQCAtNTMyLDggKzU4OCw5IEBACiAJbXNpbl9sZW4gPSBvc19zdHJsZW4obXNpbik7CiAKIAlwb3MgPSBuYWk7Ci0JZW5kID0gcG9zICsgc2l6ZW9mKG5haSk7Ci0JKnBvcysrID0gcHJlZml4OworCWVuZCA9IG5haSArIG5haV9sZW47CisJaWYgKHByZWZpeCkKKwkJKnBvcysrID0gcHJlZml4OwogCW9zX21lbWNweShwb3MsIGltc2ksIHBsbW5fbGVuKTsKIAlwb3MgKz0gcGxtbl9sZW47CiAJb3NfbWVtY3B5KHBvcywgbXNpbiwgbXNpbl9sZW4pOwpAQCAtNTUxLDYgKzYwOCwxNSBAQAogCXBvcyArPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIi5tY2MlYyVjJWMuM2dwcG5ldHdvcmsub3JnIiwKIAkJCSAgIGltc2lbMF0sIGltc2lbMV0sIGltc2lbMl0pOwogCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCBzZXRfcm9vdF9uYWkoc3RydWN0IHdwYV9zc2lkICpzc2lkLCBjb25zdCBjaGFyICppbXNpLCBjaGFyIHByZWZpeCkKK3sKKwljaGFyIG5haVsxMDBdOworCWlmIChidWlsZF9yb290X25haShuYWksIHNpemVvZihuYWkpLCBpbXNpLCBwcmVmaXgpIDwgMCkKKwkJcmV0dXJuIC0xOwogCXJldHVybiB3cGFfY29uZmlnX3NldF9xdW90ZWQoc3NpZCwgImlkZW50aXR5IiwgbmFpKTsKIH0KIApAQCAtNTYxLDkgKzYyNyw0NyBAQAogCQkJCSAgICAgc3RydWN0IHdwYV9ic3MgKmJzcykKIHsKICNpZmRlZiBJTlRFUldPUktJTkdfM0dQUAorCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKIAlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CiAJY29uc3QgdTggKmllOwogCisJaWYgKGJzcy0+YW5xcF8zZ3BwID09IE5VTEwpCisJCXJldHVybiAtMTsKKworCWZvciAoY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOyBjcmVkOyBjcmVkID0gY3JlZC0+bmV4dCkgeworCQljaGFyICpzZXA7CisJCWNvbnN0IGNoYXIgKmltc2k7CisJCWludCBtbmNfbGVuOworCisjaWZkZWYgUENTQ19GVU5DUworCQlpZiAoY3JlZC0+cGNzYyAmJiB3cGFfcy0+Y29uZi0+cGNzY19yZWFkZXIgJiYgd3BhX3MtPnNjYXJkICYmCisJCSAgICB3cGFfcy0+aW1zaVswXSkgeworCQkJaW1zaSA9IHdwYV9zLT5pbXNpOworCQkJbW5jX2xlbiA9IHdwYV9zLT5tbmNfbGVuOworCQkJZ290byBjb21wYXJlOworCQl9CisjZW5kaWYgLyogUENTQ19GVU5DUyAqLworCisJCWlmIChjcmVkLT5pbXNpID09IE5VTEwgfHwgIWNyZWQtPmltc2lbMF0gfHwKKwkJICAgIGNyZWQtPm1pbGVuYWdlID09IE5VTEwgfHwgIWNyZWQtPm1pbGVuYWdlWzBdKQorCQkJY29udGludWU7CisKKwkJc2VwID0gb3Nfc3RyY2hyKGNyZWQtPmltc2ksICctJyk7CisJCWlmIChzZXAgPT0gTlVMTCB8fAorCQkgICAgKHNlcCAtIGNyZWQtPmltc2kgIT0gNSAmJiBzZXAgLSBjcmVkLT5pbXNpICE9IDYpKQorCQkJY29udGludWU7CisJCW1uY19sZW4gPSBzZXAgLSBjcmVkLT5pbXNpIC0gMzsKKwkJaW1zaSA9IGNyZWQtPmltc2k7CisKKyNpZmRlZiBQQ1NDX0ZVTkNTCisJY29tcGFyZToKKyNlbmRpZiAvKiBQQ1NDX0ZVTkNTICovCisJCWlmIChwbG1uX2lkX21hdGNoKGJzcy0+YW5xcF8zZ3BwLCBpbXNpLCBtbmNfbGVuKSkKKwkJCWJyZWFrOworCX0KKwlpZiAoY3JlZCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKIAlpZSA9IHdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfU1NJRCk7CiAJaWYgKGllID09IE5VTEwpCiAJCXJldHVybiAtMTsKQEAgLTU3Niw2ICs2ODAsNyBAQAogCiAJd3Bhc19ub3RpZnlfbmV0d29ya19hZGRlZCh3cGFfcywgc3NpZCk7CiAJd3BhX2NvbmZpZ19zZXRfbmV0d29ya19kZWZhdWx0cyhzc2lkKTsKKwlzc2lkLT5wcmlvcml0eSA9IGNyZWQtPnByaW9yaXR5OwogCXNzaWQtPnRlbXBvcmFyeSA9IDE7CiAJc3NpZC0+c3NpZCA9IG9zX3phbGxvYyhpZVsxXSArIDEpOwogCWlmIChzc2lkLT5zc2lkID09IE5VTEwpCkBAIC01ODgsMjcgKzY5MywzMiBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkVBUC1TSU0gbm90IHN1cHBvcnRlZCIpOwogCQlnb3RvIGZhaWw7CiAJfQotCWlmIChzZXRfcm9vdF9uYWkoc3NpZCwgd3BhX3MtPmNvbmYtPmhvbWVfaW1zaSwgJzEnKSA8IDApIHsKKwlpZiAoY3JlZC0+cGNzYyAmJiB3cGFfcy0+c2NhcmQgJiYgc2NhcmRfc3VwcG9ydHNfdW10cyh3cGFfcy0+c2NhcmQpKQorCQl3cGFfY29uZmlnX3NldChzc2lkLCAiZWFwIiwgIkFLQSIsIDApOworCWlmICghY3JlZC0+cGNzYyAmJiBzZXRfcm9vdF9uYWkoc3NpZCwgY3JlZC0+aW1zaSwgJzEnKSA8IDApIHsKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJGYWlsZWQgdG8gc2V0IFJvb3QgTkFJIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKLQlpZiAod3BhX3MtPmNvbmYtPmhvbWVfbWlsZW5hZ2UgJiYgd3BhX3MtPmNvbmYtPmhvbWVfbWlsZW5hZ2VbMF0pIHsKKwlpZiAoY3JlZC0+bWlsZW5hZ2UgJiYgY3JlZC0+bWlsZW5hZ2VbMF0pIHsKIAkJaWYgKHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAicGFzc3dvcmQiLAotCQkJCQkgIHdwYV9zLT5jb25mLT5ob21lX21pbGVuYWdlKSA8IDApCisJCQkJCSAgY3JlZC0+bWlsZW5hZ2UpIDwgMCkKIAkJCWdvdG8gZmFpbDsKLQl9IGVsc2UgewotCQkvKiBUT0RPOiBQSU4gKi8KKwl9IGVsc2UgaWYgKGNyZWQtPnBjc2MpIHsKIAkJaWYgKHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAicGNzYyIsICIiKSA8IDApCiAJCQlnb3RvIGZhaWw7CisJCWlmICh3cGFfcy0+Y29uZi0+cGNzY19waW4gJiYKKwkJICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAicGluIiwgd3BhX3MtPmNvbmYtPnBjc2NfcGluKQorCQkgICAgPCAwKQorCQkJZ290byBmYWlsOwogCX0KIAotCWlmICh3cGFfcy0+Y29uZi0+aG9tZV9wYXNzd29yZCAmJiB3cGFfcy0+Y29uZi0+aG9tZV9wYXNzd29yZFswXSAmJgotCSAgICB3cGFfY29uZmlnX3NldF9xdW90ZWQoc3NpZCwgInBhc3N3b3JkIiwgd3BhX3MtPmNvbmYtPmhvbWVfcGFzc3dvcmQpCi0JICAgIDwgMCkKKwlpZiAoY3JlZC0+cGFzc3dvcmQgJiYgY3JlZC0+cGFzc3dvcmRbMF0gJiYKKwkgICAgd3BhX2NvbmZpZ19zZXRfcXVvdGVkKHNzaWQsICJwYXNzd29yZCIsIGNyZWQtPnBhc3N3b3JkKSA8IDApCiAJCWdvdG8gZmFpbDsKIAotCXdwYV9zdXBwbGljYW50X3NlbGVjdF9uZXR3b3JrKHdwYV9zLCBzc2lkKTsKKwl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOworCWludGVyd29ya2luZ19yZWNvbm5lY3Qod3BhX3MpOwogCiAJcmV0dXJuIDA7CiAKQEAgLTYyMiw2ICs3MzIsNyBAQAogCiBpbnQgaW50ZXJ3b3JraW5nX2Nvbm5lY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9ic3MgKmJzcykKIHsKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQ7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwogCXN0cnVjdCBuYWlfcmVhbG0gKnJlYWxtOwogCXN0cnVjdCBuYWlfcmVhbG1fZWFwICplYXAgPSBOVUxMOwpAQCAtNjI5LDcgKzc0MCw3IEBACiAJY2hhciBidWZbMTAwXTsKIAljb25zdCB1OCAqaWU7CiAKLQlpZiAoYnNzID09IE5VTEwpCisJaWYgKHdwYV9zLT5jb25mLT5jcmVkID09IE5VTEwgfHwgYnNzID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAlpZSA9IHdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfU1NJRCk7CiAJaWYgKGllID09IE5VTEwgfHwgaWVbMV0gPT0gMCkgewpAQCAtNjQ1LDEwICs3NTYsMTQgQEAKIAkJY291bnQgPSAwOwogCX0KIAotCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7Ci0JCWlmICghbmFpX3JlYWxtX21hdGNoKCZyZWFsbVtpXSwgd3BhX3MtPmNvbmYtPmhvbWVfcmVhbG0pKQotCQkJY29udGludWU7Ci0JCWVhcCA9IG5haV9yZWFsbV9maW5kX2VhcCh3cGFfcywgJnJlYWxtW2ldKTsKKwlmb3IgKGNyZWQgPSB3cGFfcy0+Y29uZi0+Y3JlZDsgY3JlZDsgY3JlZCA9IGNyZWQtPm5leHQpIHsKKwkJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKKwkJCWlmICghbmFpX3JlYWxtX21hdGNoKCZyZWFsbVtpXSwgY3JlZC0+cmVhbG0pKQorCQkJCWNvbnRpbnVlOworCQkJZWFwID0gbmFpX3JlYWxtX2ZpbmRfZWFwKGNyZWQsICZyZWFsbVtpXSk7CisJCQlpZiAoZWFwKQorCQkJCWJyZWFrOworCQl9CiAJCWlmIChlYXApCiAJCQlicmVhazsKIAl9CkBAIC02NzcsNiArNzkyLDcgQEAKIAl9CiAJd3Bhc19ub3RpZnlfbmV0d29ya19hZGRlZCh3cGFfcywgc3NpZCk7CiAJd3BhX2NvbmZpZ19zZXRfbmV0d29ya19kZWZhdWx0cyhzc2lkKTsKKwlzc2lkLT5wcmlvcml0eSA9IGNyZWQtPnByaW9yaXR5OwogCXNzaWQtPnRlbXBvcmFyeSA9IDE7CiAJc3NpZC0+c3NpZCA9IG9zX3phbGxvYyhpZVsxXSArIDEpOwogCWlmIChzc2lkLT5zc2lkID09IE5VTEwpCkBAIC02ODgsMTQgKzgwNCw1NiBAQAogCQkJCQkJICAgICBlYXAtPm1ldGhvZCksIDApIDwgMCkKIAkJZ290byBmYWlsOwogCi0JaWYgKHdwYV9zLT5jb25mLT5ob21lX3VzZXJuYW1lICYmIHdwYV9zLT5jb25mLT5ob21lX3VzZXJuYW1lWzBdICYmCi0JICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAiaWRlbnRpdHkiLAotCQkJCSAgd3BhX3MtPmNvbmYtPmhvbWVfdXNlcm5hbWUpIDwgMCkKKwlpZiAoZWFwLT5tZXRob2QgPT0gRUFQX1RZUEVfVFRMUyAmJgorCSAgICBjcmVkLT51c2VybmFtZSAmJiBjcmVkLT51c2VybmFtZVswXSkgeworCQljb25zdCBjaGFyICpwb3M7CisJCWNoYXIgKmFub247CisJCS8qIFVzZSBhbm9ueW1vdXMgTkFJIGluIFBoYXNlIDEgKi8KKwkJcG9zID0gb3Nfc3RyY2hyKGNyZWQtPnVzZXJuYW1lLCAnQCcpOworCQlpZiAocG9zKSB7CisJCQlzaXplX3QgYnVmbGVuID0gOSArIG9zX3N0cmxlbihwb3MpICsgMTsKKwkJCWFub24gPSBvc19tYWxsb2MoYnVmbGVuKTsKKwkJCWlmIChhbm9uID09IE5VTEwpCisJCQkJZ290byBmYWlsOworCQkJb3Nfc25wcmludGYoYW5vbiwgYnVmbGVuLCAiYW5vbnltb3VzJXMiLCBwb3MpOworCQl9IGVsc2UgaWYgKGNyZWQtPnJlYWxtKSB7CisJCQlzaXplX3QgYnVmbGVuID0gMTAgKyBvc19zdHJsZW4oY3JlZC0+cmVhbG0pICsgMTsKKwkJCWFub24gPSBvc19tYWxsb2MoYnVmbGVuKTsKKwkJCWlmIChhbm9uID09IE5VTEwpCisJCQkJZ290byBmYWlsOworCQkJb3Nfc25wcmludGYoYW5vbiwgYnVmbGVuLCAiYW5vbnltb3VzQCVzIiwgY3JlZC0+cmVhbG0pOworCQl9IGVsc2UgeworCQkJYW5vbiA9IG9zX3N0cmR1cCgiYW5vbnltb3VzIik7CisJCQlpZiAoYW5vbiA9PSBOVUxMKQorCQkJCWdvdG8gZmFpbDsKKwkJfQorCQlpZiAod3BhX2NvbmZpZ19zZXRfcXVvdGVkKHNzaWQsICJhbm9ueW1vdXNfaWRlbnRpdHkiLCBhbm9uKSA8CisJCSAgICAwKSB7CisJCQlvc19mcmVlKGFub24pOworCQkJZ290byBmYWlsOworCQl9CisJCW9zX2ZyZWUoYW5vbik7CisJfQorCisJaWYgKGNyZWQtPnVzZXJuYW1lICYmIGNyZWQtPnVzZXJuYW1lWzBdICYmCisJICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAiaWRlbnRpdHkiLCBjcmVkLT51c2VybmFtZSkgPCAwKQogCQlnb3RvIGZhaWw7CiAKLQlpZiAod3BhX3MtPmNvbmYtPmhvbWVfcGFzc3dvcmQgJiYgd3BhX3MtPmNvbmYtPmhvbWVfcGFzc3dvcmRbMF0gJiYKLQkgICAgd3BhX2NvbmZpZ19zZXRfcXVvdGVkKHNzaWQsICJwYXNzd29yZCIsIHdwYV9zLT5jb25mLT5ob21lX3Bhc3N3b3JkKQotCSAgICA8IDApCisJaWYgKGNyZWQtPnBhc3N3b3JkICYmIGNyZWQtPnBhc3N3b3JkWzBdICYmCisJICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAicGFzc3dvcmQiLCBjcmVkLT5wYXNzd29yZCkgPCAwKQorCQlnb3RvIGZhaWw7CisKKwlpZiAoY3JlZC0+Y2xpZW50X2NlcnQgJiYgY3JlZC0+Y2xpZW50X2NlcnRbMF0gJiYKKwkgICAgd3BhX2NvbmZpZ19zZXRfcXVvdGVkKHNzaWQsICJjbGllbnRfY2VydCIsIGNyZWQtPmNsaWVudF9jZXJ0KSA8IDApCisJCWdvdG8gZmFpbDsKKworCWlmIChjcmVkLT5wcml2YXRlX2tleSAmJiBjcmVkLT5wcml2YXRlX2tleVswXSAmJgorCSAgICB3cGFfY29uZmlnX3NldF9xdW90ZWQoc3NpZCwgInByaXZhdGVfa2V5IiwgY3JlZC0+cHJpdmF0ZV9rZXkpIDwgMCkKKwkJZ290byBmYWlsOworCisJaWYgKGNyZWQtPnByaXZhdGVfa2V5X3Bhc3N3ZCAmJiBjcmVkLT5wcml2YXRlX2tleV9wYXNzd2RbMF0gJiYKKwkgICAgd3BhX2NvbmZpZ19zZXRfcXVvdGVkKHNzaWQsICJwcml2YXRlX2tleV9wYXNzd2QiLAorCQkJCSAgY3JlZC0+cHJpdmF0ZV9rZXlfcGFzc3dkKSA8IDApCiAJCWdvdG8gZmFpbDsKIAogCXN3aXRjaCAoZWFwLT5tZXRob2QpIHsKQEAgLTczNywxNiArODk1LDE4IEBACiAJCWlmICh3cGFfY29uZmlnX3NldChzc2lkLCAicGhhc2UyIiwgYnVmLCAwKSA8IDApCiAJCQlnb3RvIGZhaWw7CiAJCWJyZWFrOworCWNhc2UgRUFQX1RZUEVfVExTOgorCQlicmVhazsKIAl9CiAKLQlpZiAod3BhX3MtPmNvbmYtPmhvbWVfY2FfY2VydCAmJiB3cGFfcy0+Y29uZi0+aG9tZV9jYV9jZXJ0WzBdICYmCi0JICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAiY2FfY2VydCIsIHdwYV9zLT5jb25mLT5ob21lX2NhX2NlcnQpIDwKLQkgICAgMCkKKwlpZiAoY3JlZC0+Y2FfY2VydCAmJiBjcmVkLT5jYV9jZXJ0WzBdICYmCisJICAgIHdwYV9jb25maWdfc2V0X3F1b3RlZChzc2lkLCAiY2FfY2VydCIsIGNyZWQtPmNhX2NlcnQpIDwgMCkKIAkJZ290byBmYWlsOwogCiAJbmFpX3JlYWxtX2ZyZWUocmVhbG0sIGNvdW50KTsKIAotCXdwYV9zdXBwbGljYW50X3NlbGVjdF9uZXR3b3JrKHdwYV9zLCBzc2lkKTsKKwl3cGFfY29uZmlnX3VwZGF0ZV9wcmlvX2xpc3Qod3BhX3MtPmNvbmYpOworCWludGVyd29ya2luZ19yZWNvbm5lY3Qod3BhX3MpOwogCiAJcmV0dXJuIDA7CiAKQEAgLTc1OCw0MSArOTE4LDcxIEBACiB9CiAKIAotc3RhdGljIGludCBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlXzNncHAoCitzdGF0aWMgc3RydWN0IHdwYV9jcmVkICogaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV8zZ3BwKAogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHN0cnVjdCB3cGFfYnNzICpic3MpCiB7Ci0JaW50IHJldCA9IDA7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkLCAqc2VsZWN0ZWQgPSBOVUxMOworCWludCByZXQ7CiAKICNpZmRlZiBJTlRFUldPUktJTkdfM0dQUAogCWlmIChic3MtPmFucXBfM2dwcCA9PSBOVUxMKQotCQlyZXR1cm4gcmV0OworCQlyZXR1cm4gTlVMTDsKIAotCWlmICh3cGFfcy0+Y29uZi0+aG9tZV9pbXNpID09IE5VTEwgfHwgIXdwYV9zLT5jb25mLT5ob21lX2ltc2lbMF0gfHwKLQkgICAgd3BhX3MtPmNvbmYtPmhvbWVfbWlsZW5hZ2UgPT0gTlVMTCB8fAotCSAgICAhd3BhX3MtPmNvbmYtPmhvbWVfbWlsZW5hZ2VbMF0pCi0JCXJldHVybiByZXQ7CisJZm9yIChjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7IGNyZWQ7IGNyZWQgPSBjcmVkLT5uZXh0KSB7CisJCWNoYXIgKnNlcDsKKwkJY29uc3QgY2hhciAqaW1zaTsKKwkJaW50IG1uY19sZW47CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogUGFyc2luZyAzR1BQIGluZm8gZnJvbSAiIE1BQ1NUUiwKLQkJICAgTUFDMlNUUihic3MtPmJzc2lkKSk7Ci0JcmV0ID0gcGxtbl9pZF9tYXRjaChic3MtPmFucXBfM2dwcCwgd3BhX3MtPmNvbmYtPmhvbWVfaW1zaSk7Ci0Jd3BhX3ByaW50ZihNU0dfREVCVUcsICJQTE1OIG1hdGNoICVzZm91bmQiLCByZXQgPyAiIiA6ICJub3QgIik7CisjaWZkZWYgUENTQ19GVU5DUworCQlpZiAoY3JlZC0+cGNzYyAmJiB3cGFfcy0+Y29uZi0+cGNzY19yZWFkZXIgJiYgd3BhX3MtPnNjYXJkICYmCisJCSAgICB3cGFfcy0+aW1zaVswXSkgeworCQkJaW1zaSA9IHdwYV9zLT5pbXNpOworCQkJbW5jX2xlbiA9IHdwYV9zLT5tbmNfbGVuOworCQkJZ290byBjb21wYXJlOworCQl9CisjZW5kaWYgLyogUENTQ19GVU5DUyAqLworCisJCWlmIChjcmVkLT5pbXNpID09IE5VTEwgfHwgIWNyZWQtPmltc2lbMF0gfHwKKwkJICAgIGNyZWQtPm1pbGVuYWdlID09IE5VTEwgfHwgIWNyZWQtPm1pbGVuYWdlWzBdKQorCQkJY29udGludWU7CisKKwkJc2VwID0gb3Nfc3RyY2hyKGNyZWQtPmltc2ksICctJyk7CisJCWlmIChzZXAgPT0gTlVMTCB8fAorCQkgICAgKHNlcCAtIGNyZWQtPmltc2kgIT0gNSAmJiBzZXAgLSBjcmVkLT5pbXNpICE9IDYpKQorCQkJY29udGludWU7CisJCW1uY19sZW4gPSBzZXAgLSBjcmVkLT5pbXNpIC0gMzsKKwkJaW1zaSA9IGNyZWQtPmltc2k7CisKKyNpZmRlZiBQQ1NDX0ZVTkNTCisJY29tcGFyZToKKyNlbmRpZiAvKiBQQ1NDX0ZVTkNTICovCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBQYXJzaW5nIDNHUFAgaW5mbyBmcm9tICIKKwkJCSAgIE1BQ1NUUiwgTUFDMlNUUihic3MtPmJzc2lkKSk7CisJCXJldCA9IHBsbW5faWRfbWF0Y2goYnNzLT5hbnFwXzNncHAsIGltc2ksIG1uY19sZW4pOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlBMTU4gbWF0Y2ggJXNmb3VuZCIsIHJldCA/ICIiIDogIm5vdCAiKTsKKwkJaWYgKHJldCkgeworCQkJaWYgKHNlbGVjdGVkID09IE5VTEwgfHwKKwkJCSAgICBzZWxlY3RlZC0+cHJpb3JpdHkgPCBjcmVkLT5wcmlvcml0eSkKKwkJCQlzZWxlY3RlZCA9IGNyZWQ7CisJCX0KKwl9CiAjZW5kaWYgLyogSU5URVJXT1JLSU5HXzNHUFAgKi8KLQlyZXR1cm4gcmV0OworCXJldHVybiBzZWxlY3RlZDsKIH0KIAogCi1zdGF0aWMgaW50IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfcmVhbG0oCitzdGF0aWMgc3RydWN0IHdwYV9jcmVkICogaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV9yZWFsbSgKIAlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQogeworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZCwgKnNlbGVjdGVkID0gTlVMTDsKIAlzdHJ1Y3QgbmFpX3JlYWxtICpyZWFsbTsKIAl1MTYgY291bnQsIGk7Ci0JaW50IGZvdW5kID0gMDsKIAogCWlmIChic3MtPmFucXBfbmFpX3JlYWxtID09IE5VTEwpCi0JCXJldHVybiAwOworCQlyZXR1cm4gTlVMTDsKIAotCWlmICh3cGFfcy0+Y29uZi0+aG9tZV9yZWFsbSA9PSBOVUxMKQotCQlyZXR1cm4gMDsKKwlpZiAod3BhX3MtPmNvbmYtPmNyZWQgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludGVyd29ya2luZzogUGFyc2luZyBOQUkgUmVhbG0gbGlzdCBmcm9tICIKIAkJICAgTUFDU1RSLCBNQUMyU1RSKGJzcy0+YnNzaWQpKTsKQEAgLTgwMCw1MCArOTkwLDE5OCBAQAogCWlmIChyZWFsbSA9PSBOVUxMKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBDb3VsZCBub3QgcGFyc2UgTkFJICIKIAkJCSAgICJSZWFsbSBsaXN0IGZyb20gIiBNQUNTVFIsIE1BQzJTVFIoYnNzLT5ic3NpZCkpOwotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIE5VTEw7CiAJfQogCi0JZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKLQkJaWYgKCFuYWlfcmVhbG1fbWF0Y2goJnJlYWxtW2ldLCB3cGFfcy0+Y29uZi0+aG9tZV9yZWFsbSkpCisJZm9yIChjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7IGNyZWQ7IGNyZWQgPSBjcmVkLT5uZXh0KSB7CisJCWlmIChjcmVkLT5yZWFsbSA9PSBOVUxMKQogCQkJY29udGludWU7Ci0JCWlmIChuYWlfcmVhbG1fZmluZF9lYXAod3BhX3MsICZyZWFsbVtpXSkpIHsKLQkJCWZvdW5kKys7Ci0JCQlicmVhazsKKworCQlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgeworCQkJaWYgKCFuYWlfcmVhbG1fbWF0Y2goJnJlYWxtW2ldLCBjcmVkLT5yZWFsbSkpCisJCQkJY29udGludWU7CisJCQlpZiAobmFpX3JlYWxtX2ZpbmRfZWFwKGNyZWQsICZyZWFsbVtpXSkpIHsKKwkJCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCB8fAorCQkJCSAgICBzZWxlY3RlZC0+cHJpb3JpdHkgPCBjcmVkLT5wcmlvcml0eSkKKwkJCQkJc2VsZWN0ZWQgPSBjcmVkOworCQkJCWJyZWFrOworCQkJfQogCQl9CiAJfQogCiAJbmFpX3JlYWxtX2ZyZWUocmVhbG0sIGNvdW50KTsKIAotCXJldHVybiBmb3VuZDsKKwlyZXR1cm4gc2VsZWN0ZWQ7CiB9CiAKIAotc3RhdGljIGludCBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJCSAgICAgIHN0cnVjdCB3cGFfYnNzICpic3MpCitzdGF0aWMgc3RydWN0IHdwYV9jcmVkICogaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZSgKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzKQogewotCXJldHVybiBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKHdwYV9zLCBic3MpIHx8Ci0JCWludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGVfM2dwcCh3cGFfcywgYnNzKTsKKwlzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpjcmVkMjsKKworCWNyZWQgPSBpbnRlcndvcmtpbmdfY3JlZGVudGlhbHNfYXZhaWxhYmxlX3JlYWxtKHdwYV9zLCBic3MpOworCWNyZWQyID0gaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZV8zZ3BwKHdwYV9zLCBic3MpOworCWlmIChjcmVkICYmIGNyZWQyICYmIGNyZWQyLT5wcmlvcml0eSA+PSBjcmVkLT5wcmlvcml0eSkKKwkJY3JlZCA9IGNyZWQyOworCWlmICghY3JlZCkKKwkJY3JlZCA9IGNyZWQyOworCisJcmV0dXJuIGNyZWQ7Cit9CisKKworc3RhdGljIGludCBkb21haW5fbmFtZV9saXN0X2NvbnRhaW5zKHN0cnVjdCB3cGFidWYgKmRvbWFpbl9uYW1lcywKKwkJCQkgICAgIGNvbnN0IGNoYXIgKmRvbWFpbikKK3sKKwljb25zdCB1OCAqcG9zLCAqZW5kOworCXNpemVfdCBsZW47CisKKwlsZW4gPSBvc19zdHJsZW4oZG9tYWluKTsKKwlwb3MgPSB3cGFidWZfaGVhZChkb21haW5fbmFtZXMpOworCWVuZCA9IHBvcyArIHdwYWJ1Zl9sZW4oZG9tYWluX25hbWVzKTsKKworCXdoaWxlIChwb3MgKyAxIDwgZW5kKSB7CisJCWlmIChwb3MgKyAxICsgcG9zWzBdID4gZW5kKQorCQkJYnJlYWs7CisKKwkJd3BhX2hleGR1bXBfYXNjaWkoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBBUCBkb21haW4gbmFtZSIsCisJCQkJICBwb3MgKyAxLCBwb3NbMF0pOworCQlpZiAocG9zWzBdID09IGxlbiAmJgorCQkgICAgb3Nfc3RybmNhc2VjbXAoZG9tYWluLCAoY29uc3QgY2hhciAqKSAocG9zICsgMSksIGxlbikgPT0gMCkKKwkJCXJldHVybiAxOworCisJCXBvcyArPSAxICsgcG9zWzBdOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaW50ZXJ3b3JraW5nX2hvbWVfc3Aoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQlzdHJ1Y3Qgd3BhYnVmICpkb21haW5fbmFtZXMpCit7CisJc3RydWN0IHdwYV9jcmVkICpjcmVkOworI2lmZGVmIElOVEVSV09SS0lOR18zR1BQCisJY2hhciBuYWlbMTAwXSwgKnJlYWxtOworI2VuZGlmIC8qIElOVEVSV09SS0lOR18zR1BQICovCisKKwlpZiAoZG9tYWluX25hbWVzID09IE5VTEwgfHwgd3BhX3MtPmNvbmYtPmNyZWQgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJZm9yIChjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7IGNyZWQ7IGNyZWQgPSBjcmVkLT5uZXh0KSB7CisjaWZkZWYgSU5URVJXT1JLSU5HXzNHUFAKKwkJaWYgKGNyZWQtPmltc2kgJiYKKwkJICAgIGJ1aWxkX3Jvb3RfbmFpKG5haSwgc2l6ZW9mKG5haSksIGNyZWQtPmltc2ksIDApID09IDApIHsKKwkJCXJlYWxtID0gb3Nfc3RyY2hyKG5haSwgJ0AnKTsKKwkJCWlmIChyZWFsbSkKKwkJCQlyZWFsbSsrOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFNlYXJjaCBmb3IgbWF0Y2ggIgorCQkJCSAgICJ3aXRoIFNJTS9VU0lNIGRvbWFpbiAlcyIsIHJlYWxtKTsKKwkJCWlmIChyZWFsbSAmJgorCQkJICAgIGRvbWFpbl9uYW1lX2xpc3RfY29udGFpbnMoZG9tYWluX25hbWVzLCByZWFsbSkpCisJCQkJcmV0dXJuIDE7CisJCX0KKyNlbmRpZiAvKiBJTlRFUldPUktJTkdfM0dQUCAqLworCisJCWlmIChjcmVkLT5kb21haW4gPT0gTlVMTCkKKwkJCWNvbnRpbnVlOworCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiSW50ZXJ3b3JraW5nOiBTZWFyY2ggZm9yIG1hdGNoIHdpdGggIgorCQkJICAgImhvbWUgU1AgRlFETiAlcyIsIGNyZWQtPmRvbWFpbik7CisJCWlmIChkb21haW5fbmFtZV9saXN0X2NvbnRhaW5zKGRvbWFpbl9uYW1lcywgY3JlZC0+ZG9tYWluKSkKKwkJCXJldHVybiAxOworCX0KKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgaW50ZXJ3b3JraW5nX2ZpbmRfbmV0d29ya19tYXRjaChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXN0cnVjdCB3cGFfYnNzICpic3M7CisJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCisJZGxfbGlzdF9mb3JfZWFjaChic3MsICZ3cGFfcy0+YnNzLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdCkgeworCQlmb3IgKHNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsgc3NpZDsgc3NpZCA9IHNzaWQtPm5leHQpIHsKKwkJCWlmICh3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIHNzaWQpIHx8CisJCQkgICAgc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfSU5GUkEpCisJCQkJY29udGludWU7CisJCQlpZiAoc3NpZC0+c3NpZF9sZW4gIT0gYnNzLT5zc2lkX2xlbiB8fAorCQkJICAgIG9zX21lbWNtcChzc2lkLT5zc2lkLCBic3MtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKSAhPQorCQkJICAgIDApCisJCQkJY29udGludWU7CisJCQkvKgorCQkJICogVE9ETzogQ29uc2lkZXIgbW9yZSBhY2N1cmF0ZSBtYXRjaGluZyBvZiBzZWN1cml0eQorCQkJICogY29uZmlndXJhdGlvbiBzaW1pbGFybHkgdG8gd2hhdCBpcyBkb25lIGluIGV2ZW50cy5jCisJCQkgKi8KKwkJCXJldHVybiAxOworCQl9CisJfQorCisJcmV0dXJuIDA7CiB9CiAKIAogc3RhdGljIHZvaWQgaW50ZXJ3b3JraW5nX3NlbGVjdF9uZXR3b3JrKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7Ci0Jc3RydWN0IHdwYV9ic3MgKmJzcywgKnNlbGVjdGVkID0gTlVMTDsKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzLCAqc2VsZWN0ZWQgPSBOVUxMLCAqc2VsZWN0ZWRfaG9tZSA9IE5VTEw7CisJaW50IHNlbGVjdGVkX3ByaW8gPSAtOTk5OTk5LCBzZWxlY3RlZF9ob21lX3ByaW8gPSAtOTk5OTk5OwogCXVuc2lnbmVkIGludCBjb3VudCA9IDA7CisJY29uc3QgY2hhciAqdHlwZTsKKwlpbnQgcmVzOworCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKIAogCXdwYV9zLT5uZXR3b3JrX3NlbGVjdCA9IDA7CiAKIAlkbF9saXN0X2Zvcl9lYWNoKGJzcywgJndwYV9zLT5ic3MsIHN0cnVjdCB3cGFfYnNzLCBsaXN0KSB7Ci0JCWlmICghaW50ZXJ3b3JraW5nX2NyZWRlbnRpYWxzX2F2YWlsYWJsZSh3cGFfcywgYnNzKSkKKwkJY3JlZCA9IGludGVyd29ya2luZ19jcmVkZW50aWFsc19hdmFpbGFibGUod3BhX3MsIGJzcyk7CisJCWlmICghY3JlZCkKIAkJCWNvbnRpbnVlOwogCQljb3VudCsrOwotCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgSU5URVJXT1JLSU5HX0FQIE1BQ1NUUiwKLQkJCU1BQzJTVFIoYnNzLT5ic3NpZCkpOwotCQlpZiAoc2VsZWN0ZWQgPT0gTlVMTCAmJiB3cGFfcy0+YXV0b19zZWxlY3QpCi0JCQlzZWxlY3RlZCA9IGJzczsKKwkJcmVzID0gaW50ZXJ3b3JraW5nX2hvbWVfc3Aod3BhX3MsIGJzcy0+YW5xcF9kb21haW5fbmFtZSk7CisJCWlmIChyZXMgPiAwKQorCQkJdHlwZSA9ICJob21lIjsKKwkJZWxzZSBpZiAocmVzID09IDApCisJCQl0eXBlID0gInJvYW1pbmciOworCQllbHNlCisJCQl0eXBlID0gInVua25vd24iOworCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgSU5URVJXT1JLSU5HX0FQIE1BQ1NUUiAiIHR5cGU9JXMiLAorCQkJTUFDMlNUUihic3MtPmJzc2lkKSwgdHlwZSk7CisJCWlmICh3cGFfcy0+YXV0b19zZWxlY3QpIHsKKwkJCWlmIChzZWxlY3RlZCA9PSBOVUxMIHx8CisJCQkgICAgY3JlZC0+cHJpb3JpdHkgPiBzZWxlY3RlZF9wcmlvKSB7CisJCQkJc2VsZWN0ZWQgPSBic3M7CisJCQkJc2VsZWN0ZWRfcHJpbyA9IGNyZWQtPnByaW9yaXR5OworCQkJfQorCQkJaWYgKHJlcyA+IDAgJiYKKwkJCSAgICAoc2VsZWN0ZWRfaG9tZSA9PSBOVUxMIHx8CisJCQkgICAgIGNyZWQtPnByaW9yaXR5ID4gc2VsZWN0ZWRfaG9tZV9wcmlvKSkgeworCQkJCXNlbGVjdGVkX2hvbWUgPSBic3M7CisJCQkJc2VsZWN0ZWRfaG9tZV9wcmlvID0gY3JlZC0+cHJpb3JpdHk7CisJCQl9CisJCX0KKwl9CisKKwlpZiAoc2VsZWN0ZWRfaG9tZSAmJiBzZWxlY3RlZF9ob21lICE9IHNlbGVjdGVkICYmCisJICAgIHNlbGVjdGVkX2hvbWVfcHJpbyA+PSBzZWxlY3RlZF9wcmlvKSB7CisJCS8qIFByZWZlciBuZXR3b3JrIG9wZXJhdGVkIGJ5IHRoZSBIb21lIFNQICovCisJCXNlbGVjdGVkID0gc2VsZWN0ZWRfaG9tZTsKIAl9CiAKIAlpZiAoY291bnQgPT0gMCkgeworCQkvKgorCQkgKiBObyBtYXRjaGluZyBuZXR3b3JrIHdhcyBmb3VuZCBiYXNlZCBvbiBjb25maWd1cmVkCisJCSAqIGNyZWRlbnRpYWxzLiBDaGVjayB3aGV0aGVyIGFueSBvZiB0aGUgZW5hYmxlZCBuZXR3b3JrIGJsb2NrcworCQkgKiBoYXZlIG1hdGNoaW5nIEFQcy4KKwkJICovCisJCWlmIChpbnRlcndvcmtpbmdfZmluZF9uZXR3b3JrX21hdGNoKHdwYV9zKSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFBvc3NpYmxlIEJTUyAiCisJCQkJICAgIm1hdGNoIGZvciBlbmFibGVkIG5ldHdvcmsgY29uZmlndXJhdGlvbnMiKTsKKwkJCWludGVyd29ya2luZ19yZWNvbm5lY3Qod3BhX3MpOworCQkJcmV0dXJuOworCQl9CisKIAkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIElOVEVSV09SS0lOR19OT19NQVRDSCAiTm8gbmV0d29yayAiCiAJCQkid2l0aCBtYXRjaGluZyBjcmVkZW50aWFscyBmb3VuZCIpOwogCX0KQEAgLTk2NCw2ICsxMzAyLDkgQEAKIHsKIAljb25zdCB1OCAqcG9zID0gZGF0YTsKIAlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gd3BhX2Jzc19nZXRfYnNzaWQod3BhX3MsIHNhKTsKKyNpZmRlZiBDT05GSUdfSFMyMAorCXU4IHR5cGU7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KIAogCXN3aXRjaCAoaW5mb19pZCkgewogCWNhc2UgQU5RUF9DQVBBQklMSVRZX0xJU1Q6CkBAIC0xMDQ3LDYgKzEzODgsMjggQEAKIAkJCXJldHVybjsKIAogCQlzd2l0Y2ggKFdQQV9HRVRfQkUyNChwb3MpKSB7CisjaWZkZWYgQ09ORklHX0hTMjAKKwkJY2FzZSBPVUlfV0ZBOgorCQkJcG9zICs9IDM7CisJCQlzbGVuIC09IDM7CisKKwkJCWlmIChzbGVuIDwgMSkKKwkJCQlyZXR1cm47CisJCQl0eXBlID0gKnBvcysrOworCQkJc2xlbi0tOworCisJCQlzd2l0Y2ggKHR5cGUpIHsKKwkJCWNhc2UgSFMyMF9BTlFQX09VSV9UWVBFOgorCQkJCWhzMjBfcGFyc2VfcnhfaHMyMF9hbnFwX3Jlc3Aod3BhX3MsIHNhLCBwb3MsCisJCQkJCQkJICAgICBzbGVuKTsKKwkJCQlicmVhazsKKwkJCWRlZmF1bHQ6CisJCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJIUzIwOiBVbnN1cHBvcnRlZCBBTlFQICIKKwkJCQkJICAgInZlbmRvciB0eXBlICV1IiwgdHlwZSk7CisJCQkJYnJlYWs7CisJCQl9CisJCQlicmVhazsKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCQlkZWZhdWx0OgogCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJJbnRlcndvcmtpbmc6IFVuc3VwcG9ydGVkICIKIAkJCQkgICAidmVuZG9yLXNwZWNpZmljIEFOUVAgT1VJICUwNngiLApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvbWFpbi5jIGIvd3BhX3N1cHBsaWNhbnQvbWFpbi5jCmluZGV4IGMxMjRjYTIuLjgwYWFjNzcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L21haW4uYworKysgYi93cGFfc3VwcGxpY2FudC9tYWluLmMKQEAgLTYxLDYgKzYxLDEwIEBACiAjaWZkZWYgQ09ORklHX0RFQlVHX1NZU0xPRwogCXByaW50ZigiICAtcyA9IGxvZyBvdXRwdXQgdG8gc3lzbG9nIGluc3RlYWQgb2Ygc3Rkb3V0XG4iKTsKICNlbmRpZiAvKiBDT05GSUdfREVCVUdfU1lTTE9HICovCisjaWZkZWYgQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcKKwlwcmludGYoIiAgLVQgPSByZWNvcmQgdG8gTGludXggdHJhY2luZyBpbiBhZGRpdGlvbiB0byBsb2dnaW5nXG4iKTsKKwlwcmludGYoIiAgICAgICAocmVjb3JkcyBhbGwgbWVzc2FnZXMgcmVnYXJkbGVzcyBvZiBkZWJ1ZyB2ZXJib3NpdHkpXG4iKTsKKyNlbmRpZiAvKiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORyAqLwogCXByaW50ZigiICAtdCA9IGluY2x1ZGUgdGltZXN0YW1wIGluIGRlYnVnIG1lc3NhZ2VzXG4iCiAJICAgICAgICIgIC1oID0gc2hvdyB0aGlzIGhlbHAgdGV4dFxuIgogCSAgICAgICAiICAtTCA9IHNob3cgbGljZW5zZSAoQlNEKVxuIgpAQCAtMTM5LDcgKzE0Myw4IEBACiAJd3BhX3N1cHBsaWNhbnRfZmRfd29ya2Fyb3VuZCgpOwogCiAJZm9yICg7OykgewotCQljID0gZ2V0b3B0KGFyZ2MsIGFyZ3YsICJiOkJjOkM6RDpkZTpmOmc6aGk6S0xObzpPOnA6UDpxc3R1dlciKTsKKwkJYyA9IGdldG9wdChhcmdjLCBhcmd2LAorCQkJICAgImI6QmM6QzpEOmRlOmY6ZzpoaTpLTE5vOk86cDpQOnFzVHR1dlciKTsKIAkJaWYgKGMgPCAwKQogCQkJYnJlYWs7CiAJCXN3aXRjaCAoYykgewpAQCAtMjE0LDYgKzIxOSwxMSBAQAogCQkJcGFyYW1zLndwYV9kZWJ1Z19zeXNsb2crKzsKIAkJCWJyZWFrOwogI2VuZGlmIC8qIENPTkZJR19ERUJVR19TWVNMT0cgKi8KKyNpZmRlZiBDT05GSUdfREVCVUdfTElOVVhfVFJBQ0lORworCQljYXNlICdUJzoKKwkJCXBhcmFtcy53cGFfZGVidWdfdHJhY2luZysrOworCQkJYnJlYWs7CisjZW5kaWYgLyogQ09ORklHX0RFQlVHX0xJTlVYX1RSQUNJTkcgKi8KIAkJY2FzZSAndCc6CiAJCQlwYXJhbXMud3BhX2RlYnVnX3RpbWVzdGFtcCsrOwogCQkJYnJlYWs7CkBAIC0yNTIsNiArMjYyLDkgQEAKIAkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSB3cGFfc3VwcGxpY2FudCIpOwogCQlleGl0Y29kZSA9IC0xOwogCQlnb3RvIG91dDsKKwl9IGVsc2UgeworCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiU3VjY2Vzc2Z1bGx5IGluaXRpYWxpemVkICIKKwkJCSAgICJ3cGFfc3VwcGxpY2FudCIpOwogCX0KIAogCWZvciAoaSA9IDA7IGV4aXRjb2RlID09IDAgJiYgaSA8IGlmYWNlX2NvdW50OyBpKyspIHsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L21haW5fc3ltYmlhbi5jcHAgYi93cGFfc3VwcGxpY2FudC9tYWluX3N5bWJpYW4uY3BwCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyNTRmZWFkLi4wMDAwMDAwCi0tLSBhL3dwYV9zdXBwbGljYW50L21haW5fc3ltYmlhbi5jcHAKKysrIC9kZXYvbnVsbApAQCAtMSw0MiArMCwwIEBACi0vKgotICogV1BBIFN1cHBsaWNhbnQgLyBQcm9ncmFtIGVudHJ5cG9pbnQgZm9yIFN5bWJpYW4KLSAqIENvcHlyaWdodCAoYykgMjAwMy0yMDA3LCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgotICoKLSAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCi0gKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCi0gKi8KLQotI2luY2x1ZGUgImluY2x1ZGVzLmgiCi0KLWV4dGVybiAiQyIgewotI2luY2x1ZGUgImNvbW1vbi5oIgotI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKLX0KLQotR0xERUZfQyBUSW50IEUzMk1haW4odm9pZCkKLXsKLQlzdHJ1Y3Qgd3BhX2ludGVyZmFjZSBpZmFjZTsKLQlpbnQgZXhpdGNvZGUgPSAwOwotCXN0cnVjdCB3cGFfcGFyYW1zIHBhcmFtczsKLQlzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsOwotCi0JbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKLQlwYXJhbXMud3BhX2RlYnVnX2xldmVsID0gTVNHX0lORk87Ci0KLQlnbG9iYWwgPSB3cGFfc3VwcGxpY2FudF9pbml0KCZwYXJhbXMpOwotCWlmIChnbG9iYWwgPT0gTlVMTCkKLQkJcmV0dXJuIC0xOwotCi0JbWVtc2V0KCZpZmFjZSwgMCwgc2l6ZW9mKGlmYWNlKSk7Ci0JLyogVE9ETzogc2V0IGludGVyZmFjZSBwYXJhbWV0ZXJzICovCi0KLQlpZiAod3BhX3N1cHBsaWNhbnRfYWRkX2lmYWNlKGdsb2JhbCwgJmlmYWNlKSA9PSBOVUxMKQotCQlleGl0Y29kZSA9IC0xOwotCi0JaWYgKGV4aXRjb2RlID09IDApCi0JCWV4aXRjb2RlID0gd3BhX3N1cHBsaWNhbnRfcnVuKGdsb2JhbCk7Ci0KLQl3cGFfc3VwcGxpY2FudF9kZWluaXQoZ2xvYmFsKTsKLQotCXJldHVybiBleGl0Y29kZTsKLX0KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L25mY19wd190b2tlbi5jIGIvd3BhX3N1cHBsaWNhbnQvbmZjX3B3X3Rva2VuLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTFhZmI1YgotLS0gL2Rldi9udWxsCisrKyBiL3dwYV9zdXBwbGljYW50L25mY19wd190b2tlbi5jCkBAIC0wLDAgKzEsODMgQEAKKy8qCisgKiBuZmNfcHdfdG9rZW4gLSBUb29sIGZvciBidWlsZGluZyBORkMgcGFzc3dvcmQgdG9rZW5zIGZvciBXUFMKKyAqIENvcHlyaWdodCAoYykgMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlICJpbmNsdWRlcy5oIgorCisjaW5jbHVkZSAidXRpbHMvY29tbW9uLmgiCisjaW5jbHVkZSAiY3J5cHRvL3JhbmRvbS5oIgorI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJ3cHNfc3VwcGxpY2FudC5oIgorCisKK3N0YXRpYyB2b2lkIHByaW50X2Jpbihjb25zdCBjaGFyICp0aXRsZSwgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqYnVmKQoreworCXNpemVfdCBpLCBsZW47CisJY29uc3QgdTggKnBvczsKKworCWlmIChidWYgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJcHJpbnRmKCIlcz0iLCB0aXRsZSk7CisKKwlwb3MgPSB3cGFidWZfaGVhZChidWYpOworCWxlbiA9IHdwYWJ1Zl9sZW4oYnVmKTsKKwlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspCisJCXByaW50ZigiJTAyWCIsICpwb3MrKyk7CisKKwlwcmludGYoIlxuIik7Cit9CisKKworaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgd3BhX3M7CisJaW50IHJldCA9IC0xOworCXN0cnVjdCB3cGFidWYgKmJ1ZiA9IE5VTEwsICpuZGVmID0gTlVMTDsKKwljaGFyIHR4dFsxMDAwXTsKKworCWlmIChvc19wcm9ncmFtX2luaXQoKSkKKwkJcmV0dXJuIC0xOworCXJhbmRvbV9pbml0KE5VTEwpOworCisJb3NfbWVtc2V0KCZ3cGFfcywgMCwgc2l6ZW9mKHdwYV9zKSk7CisJd3BhX3MuY29uZiA9IG9zX3phbGxvYyhzaXplb2YoKndwYV9zLmNvbmYpKTsKKwlpZiAod3BhX3MuY29uZiA9PSBOVUxMKQorCQlnb3RvIGZhaWw7CisKKwlidWYgPSB3cGFzX3dwc19uZmNfdG9rZW4oJndwYV9zLCAwKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCWdvdG8gZmFpbDsKKworCW5kZWYgPSBuZGVmX2J1aWxkX3dpZmkoYnVmKTsKKwlpZiAobmRlZiA9PSBOVUxMKQorCQlnb3RvIGZhaWw7CisKKwl3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZSh0eHQsIHNpemVvZih0eHQpLCB3cGFidWZfaGVhZChidWYpLAorCQkJCSAgIHdwYWJ1Zl9sZW4oYnVmKSk7CisJcHJpbnRmKCIjV1BTPSVzXG4iLCB0eHQpOworCisJd3BhX3NucHJpbnRmX2hleF91cHBlcmNhc2UodHh0LCBzaXplb2YodHh0KSwgd3BhYnVmX2hlYWQobmRlZiksCisJCQkJICAgd3BhYnVmX2xlbihuZGVmKSk7CisJcHJpbnRmKCIjTkRFRj0lc1xuIiwgdHh0KTsKKworCXByaW50Zigid3BzX25mY19kZXZfcHdfaWQ9JWRcbiIsIHdwYV9zLmNvbmYtPndwc19uZmNfZGV2X3B3X2lkKTsKKwlwcmludF9iaW4oIndwc19uZmNfZGhfcHVia2V5Iiwgd3BhX3MuY29uZi0+d3BzX25mY19kaF9wdWJrZXkpOworCXByaW50X2Jpbigid3BzX25mY19kaF9wcml2a2V5Iiwgd3BhX3MuY29uZi0+d3BzX25mY19kaF9wcml2a2V5KTsKKwlwcmludF9iaW4oIndwc19uZmNfZGV2X3B3Iiwgd3BhX3MuY29uZi0+d3BzX25mY19kZXZfcHcpOworCisJcmV0ID0gMDsKK2ZhaWw6CisJd3BhYnVmX2ZyZWUobmRlZik7CisJd3BhYnVmX2ZyZWUoYnVmKTsKKwl3cGFfY29uZmlnX2ZyZWUod3BhX3MuY29uZik7CisJcmFuZG9tX2RlaW5pdCgpOworCW9zX3Byb2dyYW1fZGVpbml0KCk7CisKKwlyZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvbm90aWZ5LmMgYi93cGFfc3VwcGxpY2FudC9ub3RpZnkuYwppbmRleCBmNjEzODk3Li41OWU2OTc1IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9ub3RpZnkuYworKysgYi93cGFfc3VwcGxpY2FudC9ub3RpZnkuYwpAQCAtODIsNyArODIsNyBAQAogI2lmZGVmIENPTkZJR19QMlAKIAlpZiAobmV3X3N0YXRlID09IFdQQV9DT01QTEVURUQpCiAJCXdwYXNfcDJwX25vdGlmX2Nvbm5lY3RlZCh3cGFfcyk7Ci0JZWxzZSBpZiAobmV3X3N0YXRlIDwgV1BBX0FTU09DSUFURUQpCisJZWxzZSBpZiAob2xkX3N0YXRlID49IFdQQV9BU1NPQ0lBVEVEICYmIG5ld19zdGF0ZSA8IFdQQV9BU1NPQ0lBVEVEKQogCQl3cGFzX3AycF9ub3RpZl9kaXNjb25uZWN0ZWQod3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KIApAQCAtMTAxLDYgKzEwMSwxMiBAQAogfQogCiAKK3ZvaWQgd3Bhc19ub3RpZnlfZGlzY29ubmVjdF9yZWFzb24oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwl3cGFzX2RidXNfc2lnbmFsX3Byb3BfY2hhbmdlZCh3cGFfcywgV1BBU19EQlVTX1BST1BfRElTQ09OTkVDVF9SRUFTT04pOworfQorCisKIHZvaWQgd3Bhc19ub3RpZnlfbmV0d29ya19jaGFuZ2VkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJd3Bhc19kYnVzX3NpZ25hbF9wcm9wX2NoYW5nZWQod3BhX3MsIFdQQVNfREJVU19QUk9QX0NVUlJFTlRfTkVUV09SSyk7CkBAIC02MDYsMyArNjEyLDIwIEBACiAJLyogbm90aWZ5IHRoZSBuZXcgREJ1cyBBUEkgKi8KIAl3cGFzX2RidXNfc2lnbmFsX2NlcnRpZmljYXRpb24od3BhX3MsIGRlcHRoLCBzdWJqZWN0LCBjZXJ0X2hhc2gsIGNlcnQpOwogfQorCisKK3ZvaWQgd3Bhc19ub3RpZnlfcHJlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkgICAgICBjb25zdCB1OCAqYWRkciwgY29uc3QgdTggKmRzdCwgY29uc3QgdTggKmJzc2lkLAorCQkgICAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sIHUzMiBzc2lfc2lnbmFsKQoreworI2lmZGVmIENPTkZJR19BUAorCXdwYXNfZGJ1c19zaWduYWxfcHJlcSh3cGFfcywgYWRkciwgZHN0LCBic3NpZCwgaWUsIGllX2xlbiwgc3NpX3NpZ25hbCk7CisjZW5kaWYgLyogQ09ORklHX0FQICovCit9CisKKwordm9pZCB3cGFzX25vdGlmeV9lYXBfc3RhdHVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKnN0YXR1cywKKwkJCSAgICBjb25zdCBjaGFyICpwYXJhbWV0ZXIpCit7CisJd3Bhc19kYnVzX3NpZ25hbF9lYXBfc3RhdHVzKHdwYV9zLCBzdGF0dXMsIHBhcmFtZXRlcik7Cit9CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9ub3RpZnkuaCBiL3dwYV9zdXBwbGljYW50L25vdGlmeS5oCmluZGV4IGJkOTlhNzYuLjU4Njc1YWMgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L25vdGlmeS5oCisrKyBiL3dwYV9zdXBwbGljYW50L25vdGlmeS5oCkBAIC0yMiw2ICsyMiw3IEBACiB2b2lkIHdwYXNfbm90aWZ5X3N0YXRlX2NoYW5nZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgICBlbnVtIHdwYV9zdGF0ZXMgbmV3X3N0YXRlLAogCQkJICAgICAgIGVudW0gd3BhX3N0YXRlcyBvbGRfc3RhdGUpOwordm9pZCB3cGFzX25vdGlmeV9kaXNjb25uZWN0X3JlYXNvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHZvaWQgd3Bhc19ub3RpZnlfbmV0d29ya19jaGFuZ2VkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogdm9pZCB3cGFzX25vdGlmeV9hcF9zY2FuX2NoYW5nZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYXNfbm90aWZ5X2Jzc2lkX2NoYW5nZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CkBAIC0xMjEsNSArMTIyLDEwIEBACiB2b2lkIHdwYXNfbm90aWZ5X2NlcnRpZmljYXRpb24oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGRlcHRoLAogCQkJICAgICAgIGNvbnN0IGNoYXIgKnN1YmplY3QsIGNvbnN0IGNoYXIgKmNlcnRfaGFzaCwKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpjZXJ0KTsKK3ZvaWQgd3Bhc19ub3RpZnlfcHJlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkgICAgICBjb25zdCB1OCAqYWRkciwgY29uc3QgdTggKmRzdCwgY29uc3QgdTggKmJzc2lkLAorCQkgICAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sIHUzMiBzc2lfc2lnbmFsKTsKK3ZvaWQgd3Bhc19ub3RpZnlfZWFwX3N0YXR1cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCBjaGFyICpzdGF0dXMsCisJCQkgICAgY29uc3QgY2hhciAqcGFyYW1ldGVyKTsKIAogI2VuZGlmIC8qIE5PVElGWV9IICovCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5jIGIvd3BhX3N1cHBsaWNhbnQvcDJwX3N1cHBsaWNhbnQuYwppbmRleCA1ZjEzMjllLi5lMGMzNTgwIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5jCisrKyBiL3dwYV9zdXBwbGljYW50L3AycF9zdXBwbGljYW50LmMKQEAgLTM5LDYgKzM5LDggQEAKICAqLwogI2RlZmluZSBQMlBfTUFYX0pPSU5fU0NBTl9BVFRFTVBUUyAxMAogCisjZGVmaW5lIFAyUF9BVVRPX1BEX1NDQU5fQVRURU1QVFMgNQorCiAjaWZuZGVmIFAyUF9NQVhfQ0xJRU5UX0lETEUKIC8qCiAgKiBIb3cgbWFueSBzZWNvbmRzIHRvIHRyeSB0byByZWNvbm5lY3QgdG8gdGhlIEdPIHdoZW4gY29ubmVjdGlvbiBpbiBQMlAgY2xpZW50CkBAIC01MSw2ICs1MywxNCBAQAogI2VuZGlmIC8qIEFORFJPSURfUDJQICovCiAjZW5kaWYgLyogUDJQX01BWF9DTElFTlRfSURMRSAqLwogCisjaWZuZGVmIFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVQKKy8qCisgKiBIb3cgbWFueSBzZWNvbmRzIHRvIHdhaXQgZm9yIGluaXRpYWwgNC13YXkgaGFuZHNoYWtlIHRvIGdldCBjb21wbGV0ZWQgYWZ0ZXIKKyAqIFdQUyBwcm92aXNpb25pbmcgc3RlcC4KKyAqLworI2RlZmluZSBQMlBfTUFYX0lOSVRJQUxfQ09OTl9XQUlUIDEwCisjZW5kaWYgLyogUDJQX01BWF9JTklUSUFMX0NPTk5fV0FJVCAqLworCiAjaWZkZWYgQU5EUk9JRF9QMlAKIHN0YXRpYyBpbnQgd3Bhc19nbG9iYWxfc2Nhbl9pbl9wcm9ncmVzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKICNlbmRpZgpAQCAtNTksMTUgKzY5LDE5IEBACiB3cGFzX3AycF9nZXRfZ3JvdXBfaWZhY2Uoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGFkZHJfYWxsb2NhdGVkLAogCQkJIGludCBnbyk7CiBzdGF0aWMgaW50IHdwYXNfcDJwX2pvaW5fc3RhcnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitzdGF0aWMgdm9pZCB3cGFzX3AycF9qb2luX3NjYW5fcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBmcmVxKTsKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX2pvaW5fc2Nhbih2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KTsKIHN0YXRpYyBpbnQgd3Bhc19wMnBfam9pbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqaWZhY2VfYWRkciwKLQkJCSBjb25zdCB1OCAqZGV2X2FkZHIsIGVudW0gcDJwX3dwc19tZXRob2Qgd3BzX21ldGhvZCk7CisJCQkgY29uc3QgdTggKmRldl9hZGRyLCBlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCisJCQkgaW50IGF1dG9fam9pbik7CiBzdGF0aWMgdm9pZCB3cGFzX3AycF9wZF9iZWZvcmVfam9pbl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwKIAkJCQkJICAgIHZvaWQgKnRpbWVvdXRfY3R4KTsKIHN0YXRpYyBpbnQgd3Bhc19wMnBfY3JlYXRlX2lmYWNlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogc3RhdGljIHZvaWQgd3Bhc19wMnBfY3Jvc3NfY29ubmVjdF9zZXR1cChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCh2b2lkICplbG9vcF9jdHgsIHZvaWQgKnRpbWVvdXRfY3R4KTsKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX3NldF9ncm91cF9pZGxlX3RpbWVvdXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CitzdGF0aWMgdm9pZCB3cGFzX3AycF9mYWxsYmFja190b19nb19uZWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJaW50IGdyb3VwX2FkZGVkKTsKIAogI2lmZGVmIEFORFJPSURfUDJQCiBzdGF0aWMgaW50IHdwYXNfZ2xvYmFsX3NjYW5faW5fcHJvZ3Jlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKQEAgLTExMiw3ICsxMjYsNyBAQAogCiBzdGF0aWMgaW50IHdwYXNfcDJwX3NjYW4odm9pZCAqY3R4LCBlbnVtIHAycF9zY2FuX3R5cGUgdHlwZSwgaW50IGZyZXEsCiAJCQkgdW5zaWduZWQgaW50IG51bV9yZXFfZGV2X3R5cGVzLAotCQkJIGNvbnN0IHU4ICpyZXFfZGV2X3R5cGVzLCBjb25zdCB1OCAqZGV2X2lkKQorCQkJIGNvbnN0IHU4ICpyZXFfZGV2X3R5cGVzLCBjb25zdCB1OCAqZGV2X2lkLCB1MTYgcHdfaWQpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIAlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CkBAIC0xMjAsNyArMTM0LDYgQEAKIAlzdHJ1Y3Qgd3BhYnVmICp3cHNfaWUsICppZXM7CiAJaW50IHNvY2lhbF9jaGFubmVsc1tdID0geyAyNDEyLCAyNDM3LCAyNDYyLCAwLCAwIH07CiAJc2l6ZV90IGllbGVuOwotCWludCB3YXNfaW5fcDJwX3NjYW47CiAKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gLTE7CkBAIC0xMzMsOCArMTQ2LDggQEAKIAlwYXJhbXMuc3NpZHNbMF0uc3NpZF9sZW4gPSBQMlBfV0lMRENBUkRfU1NJRF9MRU47CiAKIAl3cGFfcy0+d3BzLT5kZXYucDJwID0gMTsKLQl3cHNfaWUgPSB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKDAsICZ3cGFfcy0+d3BzLT5kZXYsIHdwYV9zLT53cHMtPnV1aWQsCi0JCQkJCVdQU19SRVFfRU5ST0xMRUUsCisJd3BzX2llID0gd3BzX2J1aWxkX3Byb2JlX3JlcV9pZShwd19pZCwgJndwYV9zLT53cHMtPmRldiwKKwkJCQkJd3BhX3MtPndwcy0+dXVpZCwgV1BTX1JFUV9FTlJPTExFRSwKIAkJCQkJbnVtX3JlcV9kZXZfdHlwZXMsIHJlcV9kZXZfdHlwZXMpOwogCWlmICh3cHNfaWUgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwpAQCAtMTYwLDM0ICsxNzMsMjQgQEAKIAkJYnJlYWs7CiAJY2FzZSBQMlBfU0NBTl9GVUxMOgogCQlicmVhazsKLQljYXNlIFAyUF9TQ0FOX1NQRUNJRklDOgotCQlzb2NpYWxfY2hhbm5lbHNbMF0gPSBmcmVxOwotCQlzb2NpYWxfY2hhbm5lbHNbMV0gPSAwOwotCQlwYXJhbXMuZnJlcXMgPSBzb2NpYWxfY2hhbm5lbHM7Ci0JCWJyZWFrOwogCWNhc2UgUDJQX1NDQU5fU09DSUFMX1BMVVNfT05FOgogCQlzb2NpYWxfY2hhbm5lbHNbM10gPSBmcmVxOwogCQlwYXJhbXMuZnJlcXMgPSBzb2NpYWxfY2hhbm5lbHM7CiAJCWJyZWFrOwogCX0KIAotCXdhc19pbl9wMnBfc2NhbiA9IHdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyID09IHdwYXNfcDJwX3NjYW5fcmVzX2hhbmRsZXI7Ci0Jd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPSB3cGFzX3AycF9zY2FuX3Jlc19oYW5kbGVyOwogCXJldCA9IHdwYV9kcnZfc2Nhbih3cGFfcywgJnBhcmFtcyk7CiAKIAl3cGFidWZfZnJlZShpZXMpOwogCiAJaWYgKHJldCkgewotCQl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IE5VTEw7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKLQkJaWYgKHdwYV9zLT5zY2FubmluZyB8fCB3YXNfaW5fcDJwX3NjYW4gfHwgd3Bhc19nbG9iYWxfc2Nhbl9pbl9wcm9ncmVzcyh3cGFfcykpIHsKLSNlbHNlCi0JCWlmICh3cGFfcy0+c2Nhbm5pbmcgfHwgd2FzX2luX3AycF9zY2FuKSB7Ci0jZW5kaWYKKwkJaWYgKHdwYV9zLT5zY2FubmluZyB8fAorCQkgICAgd3BhX3MtPnNjYW5fcmVzX2hhbmRsZXIgPT0gd3Bhc19wMnBfc2Nhbl9yZXNfaGFuZGxlcikgewogCQkJd3BhX3MtPnAycF9jYl9vbl9zY2FuX2NvbXBsZXRlID0gMTsKIAkJCXJldCA9IDE7CiAJCX0KLQl9CisJfSBlbHNlCisJCXdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyID0gd3Bhc19wMnBfc2Nhbl9yZXNfaGFuZGxlcjsKIAogCXJldHVybiByZXQ7CiB9CkBAIC0yMzMsMTQgKzIzNiwxMiBAQAogfQogCiAKLXN0YXRpYyB2b2lkIHdwYXNfcDJwX2dyb3VwX2RlbGV0ZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQorc3RhdGljIHZvaWQgd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBzaWxlbnQpCiB7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwogCWNoYXIgKmd0eXBlOwogCWNvbnN0IGNoYXIgKnJlYXNvbjsKIAotCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCwgd3BhX3MsIE5VTEwpOwotCiAJc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CiAJaWYgKHNzaWQgPT0gTlVMTCkgewogCQkvKgpAQCAtMjgzLDYgKzI4NCw5IEBACiAJY2FzZSBQMlBfR1JPVVBfUkVNT1ZBTF9VTkFWQUlMQUJMRToKIAkJcmVhc29uID0gIiByZWFzb249VU5BVkFJTEFCTEUiOwogCQlicmVhazsKKwljYXNlIFAyUF9HUk9VUF9SRU1PVkFMX0dPX0VORElOR19TRVNTSU9OOgorCQlyZWFzb24gPSAiIHJlYXNvbj1HT19FTkRJTkdfU0VTU0lPTiI7CisJCWJyZWFrOwogI2lmZGVmIEFORFJPSURfUDJQCiAJY2FzZSBQMlBfR1JPVVBfUkVNT1ZBTF9GUkVRX0NPTkZMSUNUOgogCQlyZWFzb24gPSAiIHJlYXNvbj1GUkVRX0NPTkZMSUNUIjsKQEAgLTI5MiwxMCArMjk2LDE2IEBACiAJCXJlYXNvbiA9ICIiOwogCQlicmVhazsKIAl9Ci0Jd3BhX21zZyh3cGFfcy0+cGFyZW50LCBNU0dfSU5GTywgUDJQX0VWRU5UX0dST1VQX1JFTU9WRUQgIiVzICVzJXMiLAotCQl3cGFfcy0+aWZuYW1lLCBndHlwZSwgcmVhc29uKTsKKwlpZiAoIXNpbGVudCkgeworCQl3cGFfbXNnKHdwYV9zLT5wYXJlbnQsIE1TR19JTkZPLAorCQkJUDJQX0VWRU5UX0dST1VQX1JFTU9WRUQgIiVzICVzJXMiLAorCQkJd3BhX3MtPmlmbmFtZSwgZ3R5cGUsIHJlYXNvbik7CisJfQogCi0JaWYgKHNzaWQpCisJaWYgKGVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCwgd3BhX3MsIE5VTEwpID4gMCkKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbmNlbGxlZCBQMlAgZ3JvdXAgaWRsZSB0aW1lb3V0Iik7CisKKwlpZiAoIXNpbGVudCAmJiBzc2lkKQogCQl3cGFzX25vdGlmeV9wMnBfZ3JvdXBfcmVtb3ZlZCh3cGFfcywgc3NpZCwgZ3R5cGUpOwogCiAJaWYgKHdwYV9zLT5wMnBfZ3JvdXBfaW50ZXJmYWNlICE9IE5PVF9QMlBfR1JPVVBfSU5URVJGQUNFKSB7CkBAIC0zNDEsNyArMzUxLDEwIEBACiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBUZW1wb3JhcnkgZ3JvdXAgbmV0d29yayBub3QgIgogCQkJICAgImZvdW5kIik7CiAJfQotCXdwYV9zdXBwbGljYW50X2FwX2RlaW5pdCh3cGFfcyk7CisJaWYgKHdwYV9zLT5hcF9pZmFjZSkKKwkJd3BhX3N1cHBsaWNhbnRfYXBfZGVpbml0KHdwYV9zKTsKKwllbHNlCisJCXdwYV9kcnZfZGVpbml0X3AycF9jbGkod3BhX3MpOwogfQogCiAKQEAgLTU2Miw3ICs1NzUsNyBAQAogCWlmICghc3VjY2VzcykgewogCQl3cGFfbXNnKHdwYV9zLT5wYXJlbnQsIE1TR19JTkZPLAogCQkJUDJQX0VWRU5UX0dST1VQX0ZPUk1BVElPTl9GQUlMVVJFKTsKLQkJd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHdwYV9zKTsKKwkJd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHdwYV9zLCAwKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtNjcwLDYgKzY4MywxMyBAQAogCSAgICAob3NfbWVtY21wKGRzdCwgd3BhX3MtPnBlbmRpbmdfam9pbl9kZXZfYWRkciwgRVRIX0FMRU4pID09IDAgfHwKIAkgICAgIG9zX21lbWNtcChkc3QsIHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkciwgRVRIX0FMRU4pID09IDApKSB7CiAJCXdwYV9zLT5wZW5kaW5nX3BkX2JlZm9yZV9qb2luID0gMDsKKwkJaWYgKHdwYV9zLT5wMnBfZmFsbGJhY2tfdG9fZ29fbmVnKSB7CisJCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IE5vIEFDSyBmb3IgUEQgUmVxICIKKwkJCQkiZHVyaW5nIHAycF9jb25uZWN0LWF1dG8iKTsKKwkJCXdwYXNfcDJwX2ZhbGxiYWNrX3RvX2dvX25lZyh3cGFfcywgMCk7CisJCQlyZXR1cm47CisJCX0KKwogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogU3RhcnRpbmcgcGVuZGluZyAiCiAJCQkgICAiam9pbi1leGlzdGluZy1ncm91cCBvcGVyYXRpb24gKG5vIEFDSyBmb3IgUEQgIgogCQkJICAgIlJlcSkiKTsKQEAgLTg1MSw2ICs4NzEsOCBAQAogCWQtPnAycF9ncm91cF9pZGxlID0gcy0+cDJwX2dyb3VwX2lkbGU7CiAJZC0+cDJwX2ludHJhX2JzcyA9IHMtPnAycF9pbnRyYV9ic3M7CiAJZC0+cGVyc2lzdGVudF9yZWNvbm5lY3QgPSBzLT5wZXJzaXN0ZW50X3JlY29ubmVjdDsKKwlkLT5tYXhfbnVtX3N0YSA9IHMtPm1heF9udW1fc3RhOworCWQtPnBiY19pbl9tMSA9IHMtPnBiY19pbl9tMTsKIH0KIAogCkBAIC0xMDAyLDYgKzEwMjQsMjAgQEAKIAl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgUDJQX0VWRU5UX0dPX05FR19TVUNDRVNTKTsKIAl3cGFzX25vdGlmeV9wMnBfZ29fbmVnX2NvbXBsZXRlZCh3cGFfcywgcmVzKTsKIAorCWlmIChyZXMtPnJvbGVfZ28gJiYgd3BhX3MtPnAycF9wZXJzaXN0ZW50X2lkID49IDApIHsKKwkJc3RydWN0IHdwYV9zc2lkICpzc2lkOworCQlzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwKKwkJCQkJICAgICAgd3BhX3MtPnAycF9wZXJzaXN0ZW50X2lkKTsKKwkJaWYgKHNzaWQgJiYgc3NpZC0+ZGlzYWJsZWQgPT0gMiAmJgorCQkgICAgc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPICYmIHNzaWQtPnBhc3NwaHJhc2UpIHsKKwkJCXNpemVfdCBsZW4gPSBvc19zdHJsZW4oc3NpZC0+cGFzc3BocmFzZSk7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogT3ZlcnJpZGUgcGFzc3BocmFzZSBiYXNlZCAiCisJCQkJICAgIm9uIHJlcXVlc3RlZCBwZXJzaXN0ZW50IGdyb3VwIik7CisJCQlvc19tZW1jcHkocmVzLT5wYXNzcGhyYXNlLCBzc2lkLT5wYXNzcGhyYXNlLCBsZW4pOworCQkJcmVzLT5wYXNzcGhyYXNlW2xlbl0gPSAnXDAnOworCQl9CisJfQorCiAJaWYgKHdwYV9zLT5jcmVhdGVfcDJwX2lmYWNlKSB7CiAJCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqZ3JvdXBfd3BhX3MgPQogCQkJd3Bhc19wMnBfaW5pdF9ncm91cF9pbnRlcmZhY2Uod3BhX3MsIHJlcy0+cm9sZV9nbyk7CkBAIC0xODM2LDYgKzE4NzIsNyBAQAogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CiAJdW5zaWduZWQgaW50IGdlbmVyYXRlZF9waW4gPSAwOworCWNoYXIgcGFyYW1zWzIwXTsKIAogCWlmICh3cGFfcy0+cGVuZGluZ19wZF9iZWZvcmVfam9pbiAmJgogCSAgICAob3NfbWVtY21wKHBlZXIsIHdwYV9zLT5wZW5kaW5nX2pvaW5fZGV2X2FkZHIsIEVUSF9BTEVOKSA9PSAwIHx8CkBAIC0xODQ3LDE0ICsxODg0LDIyIEBACiAJCXJldHVybjsKIAl9CiAKKwlpZiAod3BhX3MtPnBlbmRpbmdfcGRfdXNlID09IEFVVE9fUERfSk9JTiB8fAorCSAgICB3cGFfcy0+cGVuZGluZ19wZF91c2UgPT0gQVVUT19QRF9HT19ORUcpCisJCW9zX3NucHJpbnRmKHBhcmFtcywgc2l6ZW9mKHBhcmFtcyksICIgcGVlcl9nbz0lZCIsCisJCQkgICAgd3BhX3MtPnBlbmRpbmdfcGRfdXNlID09IEFVVE9fUERfSk9JTik7CisJZWxzZQorCQlwYXJhbXNbMF0gPSAnXDAnOworCiAJaWYgKGNvbmZpZ19tZXRob2RzICYgV1BTX0NPTkZJR19ESVNQTEFZKQotCQl3cGFzX3Byb3ZfZGlzY19sb2NhbF9rZXlwYWQod3BhX3MsIHBlZXIsICIiKTsKKwkJd3Bhc19wcm92X2Rpc2NfbG9jYWxfa2V5cGFkKHdwYV9zLCBwZWVyLCBwYXJhbXMpOwogCWVsc2UgaWYgKGNvbmZpZ19tZXRob2RzICYgV1BTX0NPTkZJR19LRVlQQUQpIHsKIAkJZ2VuZXJhdGVkX3BpbiA9IHdwc19nZW5lcmF0ZV9waW4oKTsKLQkJd3Bhc19wcm92X2Rpc2NfbG9jYWxfZGlzcGxheSh3cGFfcywgcGVlciwgIiIsIGdlbmVyYXRlZF9waW4pOworCQl3cGFzX3Byb3ZfZGlzY19sb2NhbF9kaXNwbGF5KHdwYV9zLCBwZWVyLCBwYXJhbXMsCisJCQkJCSAgICAgZ2VuZXJhdGVkX3Bpbik7CiAJfSBlbHNlIGlmIChjb25maWdfbWV0aG9kcyAmIFdQU19DT05GSUdfUFVTSEJVVFRPTikKLQkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sIFAyUF9FVkVOVF9QUk9WX0RJU0NfUEJDX1JFU1AgTUFDU1RSLAotCQkJTUFDMlNUUihwZWVyKSk7CisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBQMlBfRVZFTlRfUFJPVl9ESVNDX1BCQ19SRVNQIE1BQ1NUUgorCQkJIiVzIiwgTUFDMlNUUihwZWVyKSwgcGFyYW1zKTsKIAogCXdwYXNfbm90aWZ5X3AycF9wcm92aXNpb25fZGlzY292ZXJ5KHdwYV9zLCBwZWVyLCAwIC8qIHJlc3BvbnNlICovLAogCQkJCQkgICAgUDJQX1BST1ZfRElTQ19TVUNDRVNTLApAQCAtMTg2Nyw2ICsxOTEyLDE3IEBACiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKIAorCWlmICh3cGFfcy0+cDJwX2ZhbGxiYWNrX3RvX2dvX25lZykgeworCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJQMlA6IFBEIGZvciBwMnBfY29ubmVjdC1hdXRvICIKKwkJCSJmYWlsZWQgLSBmYWxsIGJhY2sgdG8gR08gTmVnb3RpYXRpb24iKTsKKwkJd3Bhc19wMnBfZmFsbGJhY2tfdG9fZ29fbmVnKHdwYV9zLCAwKTsKKwkJcmV0dXJuOworCX0KKworCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBQMlBfRVZFTlRfUFJPVl9ESVNDX0ZBSUxVUkUKKwkJIiBwMnBfZGV2X2FkZHI9IiBNQUNTVFIgIiBzdGF0dXM9JWQiLAorCQlNQUMyU1RSKHBlZXIpLCBzdGF0dXMpOworCiAJd3Bhc19ub3RpZnlfcDJwX3Byb3Zpc2lvbl9kaXNjb3Zlcnkod3BhX3MsIHBlZXIsIDAgLyogcmVzcG9uc2UgKi8sCiAJCQkJCSAgICBzdGF0dXMsIDAsIDApOwogfQpAQCAtMTk5Myw3ICsyMDQ5LDcgQEAKIAkJCQl3cGFfcywgcywgcy0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPLCAwKTsKIAkJfSBlbHNlIGlmIChic3NpZCkgewogCQkJd3Bhc19wMnBfam9pbih3cGFfcywgYnNzaWQsIGdvX2Rldl9hZGRyLAotCQkJCSAgICAgIHdwYV9zLT5wMnBfd3BzX21ldGhvZCk7CisJCQkJICAgICAgd3BhX3MtPnAycF93cHNfbWV0aG9kLCAwKTsKIAkJfQogCQlyZXR1cm47CiAJfQpAQCAtMjA2MSw2ICsyMTE3LDMxIEBACiB9CiAKIAorc3RhdGljIGludCB3cGFzX3AycF9kaXNhbGxvd2VkX2ZyZXEoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwKKwkJCQkgICAgdW5zaWduZWQgaW50IGZyZXEpCit7CisJdW5zaWduZWQgaW50IGk7CisKKwlpZiAoZ2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKworCWZvciAoaSA9IDA7IGkgPCBnbG9iYWwtPm51bV9wMnBfZGlzYWxsb3dfZnJlcTsgaSsrKSB7CisJCWlmIChmcmVxID49IGdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXFbaV0ubWluICYmCisJCSAgICBmcmVxIDw9IGdsb2JhbC0+cDJwX2Rpc2FsbG93X2ZyZXFbaV0ubWF4KQorCQkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgd3Bhc19wMnBfYWRkX2NoYW4oc3RydWN0IHAycF9yZWdfY2xhc3MgKnJlZywgdTggY2hhbikKK3sKKwlyZWctPmNoYW5uZWxbcmVnLT5jaGFubmVsc10gPSBjaGFuOworCXJlZy0+Y2hhbm5lbHMrKzsKK30KKworCiBzdGF0aWMgaW50IHdwYXNfcDJwX2RlZmF1bHRfY2hhbm5lbHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgIHN0cnVjdCBwMnBfY2hhbm5lbHMgKmNoYW4pCiB7CkBAIC0yMDcxLDM0ICsyMTUyLDQ3IEBACiAKIAkvKiBPcGVyYXRpbmcgY2xhc3MgODEgLSAyLjQgR0h6IGJhbmQgY2hhbm5lbHMgMS4uMTMgKi8KIAljaGFuLT5yZWdfY2xhc3NbY2xhXS5yZWdfY2xhc3MgPSA4MTsKLQljaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVscyA9IDExOwotCWZvciAoaSA9IDA7IGkgPCAxMTsgaSsrKQotCQljaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVsW2ldID0gaSArIDE7Ci0JY2xhKys7CisJY2hhbi0+cmVnX2NsYXNzW2NsYV0uY2hhbm5lbHMgPSAwOworCWZvciAoaSA9IDA7IGkgPCAxMTsgaSsrKSB7CisJCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIDI0MTIgKyBpICogNSkpCisJCQl3cGFzX3AycF9hZGRfY2hhbigmY2hhbi0+cmVnX2NsYXNzW2NsYV0sIGkgKyAxKTsKKwl9CisJaWYgKGNoYW4tPnJlZ19jbGFzc1tjbGFdLmNoYW5uZWxzKQorCQljbGErKzsKIAogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBFbmFibGUgb3BlcmF0aW5nIGNsYXNzZXMgZm9yIGxvd2VyIDUgR0h6ICIKIAkJICAgImJhbmQiKTsKIAogCS8qIE9wZXJhdGluZyBjbGFzcyAxMTUgLSA1IEdIeiwgY2hhbm5lbHMgMzYtNDggKi8KIAljaGFuLT5yZWdfY2xhc3NbY2xhXS5yZWdfY2xhc3MgPSAxMTU7Ci0JY2hhbi0+cmVnX2NsYXNzW2NsYV0uY2hhbm5lbHMgPSA0OwotCWNoYW4tPnJlZ19jbGFzc1tjbGFdLmNoYW5uZWxbMF0gPSAzNjsKLQljaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVsWzFdID0gNDA7Ci0JY2hhbi0+cmVnX2NsYXNzW2NsYV0uY2hhbm5lbFsyXSA9IDQ0OwotCWNoYW4tPnJlZ19jbGFzc1tjbGFdLmNoYW5uZWxbM10gPSA0ODsKLQljbGErKzsKKwljaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVscyA9IDA7CisJaWYgKCF3cGFzX3AycF9kaXNhbGxvd2VkX2ZyZXEod3BhX3MtPmdsb2JhbCwgNTAwMCArIDM2ICogNSkpCisJCXdwYXNfcDJwX2FkZF9jaGFuKCZjaGFuLT5yZWdfY2xhc3NbY2xhXSwgMzYpOworCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIDUwMDAgKyA0MCAqIDUpKQorCQl3cGFzX3AycF9hZGRfY2hhbigmY2hhbi0+cmVnX2NsYXNzW2NsYV0sIDQwKTsKKwlpZiAoIXdwYXNfcDJwX2Rpc2FsbG93ZWRfZnJlcSh3cGFfcy0+Z2xvYmFsLCA1MDAwICsgNDQgKiA1KSkKKwkJd3Bhc19wMnBfYWRkX2NoYW4oJmNoYW4tPnJlZ19jbGFzc1tjbGFdLCA0NCk7CisJaWYgKCF3cGFzX3AycF9kaXNhbGxvd2VkX2ZyZXEod3BhX3MtPmdsb2JhbCwgNTAwMCArIDQ4ICogNSkpCisJCXdwYXNfcDJwX2FkZF9jaGFuKCZjaGFuLT5yZWdfY2xhc3NbY2xhXSwgNDgpOworCWlmIChjaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVscykKKwkJY2xhKys7CiAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRW5hYmxlIG9wZXJhdGluZyBjbGFzc2VzIGZvciBoaWdoZXIgNSBHSHogIgogCQkgICAiYmFuZCIpOwogCiAJLyogT3BlcmF0aW5nIGNsYXNzIDEyNCAtIDUgR0h6LCBjaGFubmVscyAxNDksMTUzLDE1NywxNjEgKi8KIAljaGFuLT5yZWdfY2xhc3NbY2xhXS5yZWdfY2xhc3MgPSAxMjQ7Ci0JY2hhbi0+cmVnX2NsYXNzW2NsYV0uY2hhbm5lbHMgPSA0OwotCWNoYW4tPnJlZ19jbGFzc1tjbGFdLmNoYW5uZWxbMF0gPSAxNDk7Ci0JY2hhbi0+cmVnX2NsYXNzW2NsYV0uY2hhbm5lbFsxXSA9IDE1MzsKLQljaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVsWzJdID0gMTU3OwotCWNoYW4tPnJlZ19jbGFzc1tjbGFdLmNoYW5uZWxbM10gPSAxNjE7Ci0JY2xhKys7CisJY2hhbi0+cmVnX2NsYXNzW2NsYV0uY2hhbm5lbHMgPSAwOworCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIDUwMDAgKyAxNDkgKiA1KSkKKwkJd3Bhc19wMnBfYWRkX2NoYW4oJmNoYW4tPnJlZ19jbGFzc1tjbGFdLCAxNDkpOworCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIDUwMDAgKyAxNTMgKiA1KSkKKwkJd3Bhc19wMnBfYWRkX2NoYW4oJmNoYW4tPnJlZ19jbGFzc1tjbGFdLCAxNTMpOworCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIDUwMDAgKyAxNTYgKiA1KSkKKwkJd3Bhc19wMnBfYWRkX2NoYW4oJmNoYW4tPnJlZ19jbGFzc1tjbGFdLCAxNTcpOworCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsIDUwMDAgKyAxNjEgKiA1KSkKKwkJd3Bhc19wMnBfYWRkX2NoYW4oJmNoYW4tPnJlZ19jbGFzc1tjbGFdLCAxNjEpOworCWlmIChjaGFuLT5yZWdfY2xhc3NbY2xhXS5jaGFubmVscykKKwkJY2xhKys7CiAKIAljaGFuLT5yZWdfY2xhc3NlcyA9IGNsYTsKIAlyZXR1cm4gMDsKQEAgLTIxMjAsOSArMjIxNCwxNiBAQAogfQogCiAKLXN0YXRpYyBpbnQgaGFzX2NoYW5uZWwoc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGUsIHU4IGNoYW4sIGludCAqZmxhZ3MpCitzdGF0aWMgaW50IGhhc19jaGFubmVsKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCisJCSAgICAgICBzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZSwgdTggY2hhbiwgaW50ICpmbGFncykKIHsKIAlpbnQgaTsKKwl1bnNpZ25lZCBpbnQgZnJlcTsKKworCWZyZXEgPSAobW9kZS0+bW9kZSA9PSBIT1NUQVBEX01PREVfSUVFRTgwMjExQSA/IDUwMDAgOiAyNDA3KSArCisJCWNoYW4gKiA1OworCWlmICh3cGFzX3AycF9kaXNhbGxvd2VkX2ZyZXEoZ2xvYmFsLCBmcmVxKSkKKwkJcmV0dXJuIDA7CiAKIAlmb3IgKGkgPSAwOyBpIDwgbW9kZS0+bnVtX2NoYW5uZWxzOyBpKyspIHsKIAkJaWYgKG1vZGUtPmNoYW5uZWxzW2ldLmNoYW4gPT0gY2hhbikgewpAQCAtMjE4OSwxNSArMjI5MCwxNSBAQAogCQkJY29udGludWU7CiAJCWZvciAoY2ggPSBvLT5taW5fY2hhbjsgY2ggPD0gby0+bWF4X2NoYW47IGNoICs9IG8tPmluYykgewogCQkJaW50IGZsYWc7Ci0JCQlpZiAoIWhhc19jaGFubmVsKG1vZGUsIGNoLCAmZmxhZykpCisJCQlpZiAoIWhhc19jaGFubmVsKHdwYV9zLT5nbG9iYWwsIG1vZGUsIGNoLCAmZmxhZykpCiAJCQkJY29udGludWU7CiAJCQlpZiAoby0+YncgPT0gQlc0ME1JTlVTICYmCiAJCQkgICAgKCEoZmxhZyAmIEhPU1RBUERfQ0hBTl9IVDQwTUlOVVMpIHx8Ci0JCQkgICAgICFoYXNfY2hhbm5lbChtb2RlLCBjaCAtIDQsIE5VTEwpKSkKKwkJCSAgICAgIWhhc19jaGFubmVsKHdwYV9zLT5nbG9iYWwsIG1vZGUsIGNoIC0gNCwgTlVMTCkpKQogCQkJCWNvbnRpbnVlOwogCQkJaWYgKG8tPmJ3ID09IEJXNDBQTFVTICYmCiAJCQkgICAgKCEoZmxhZyAmIEhPU1RBUERfQ0hBTl9IVDQwUExVUykgfHwKLQkJCSAgICAgIWhhc19jaGFubmVsKG1vZGUsIGNoICsgNCwgTlVMTCkpKQorCQkJICAgICAhaGFzX2NoYW5uZWwod3BhX3MtPmdsb2JhbCwgbW9kZSwgY2ggKyA0LCBOVUxMKSkpCiAJCQkJY29udGludWU7CiAJCQlpZiAocmVnID09IE5VTEwpIHsKIAkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQWRkIG9wZXJhdGluZyAiCkBAIC0yNDA0LDYgKzI1MDUsNyBAQAogCWdsb2JhbC0+cDJwID0gcDJwX2luaXQoJnAycCk7CiAJaWYgKGdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybiAtMTsKKwlnbG9iYWwtPnAycF9pbml0X3dwYV9zID0gd3BhX3M7CiAKIAlmb3IgKGkgPSAwOyBpIDwgTUFYX1dQU19WRU5ET1JfRVhUOyBpKyspIHsKIAkJaWYgKHdwYV9zLT5jb25mLT53cHNfdmVuZG9yX2V4dFtpXSA9PSBOVUxMKQpAQCAtMjQzMSw3ICsyNTMzLDcgQEAKIAkJLyogQ2xlYXIgYW55IHN0b3JlZCBwcm92aXNpb25pbmcgaW5mbyAqLwogCQlwMnBfY2xlYXJfcHJvdmlzaW9uaW5nX2luZm8oCiAJCQl3cGFfcy0+Z2xvYmFsLT5wMnAsCi0JCQl3cGFfcy0+Z29fcGFyYW1zLT5wZWVyX2ludGVyZmFjZV9hZGRyKTsKKwkJCXdwYV9zLT5nb19wYXJhbXMtPnBlZXJfZGV2aWNlX2FkZHIpOwogCX0KIAogCW9zX2ZyZWUod3BhX3MtPmdvX3BhcmFtcyk7CkBAIC0yNDU4LDcgKzI1NjAsNiBAQAogdm9pZCB3cGFzX3AycF9kZWluaXRfZ2xvYmFsKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwpCiB7CiAJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgKnRtcDsKLQljaGFyICppZm5hbWU7CiAKIAlpZiAoZ2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuOwpAQCAtMjQ3MCw3ICsyNTcxLDYgQEAKIAl3aGlsZSAod3BhX3MgJiYgd3BhX3MtPnAycF9ncm91cF9pbnRlcmZhY2UgIT0gTk9UX1AyUF9HUk9VUF9JTlRFUkZBQ0UpCiAJCXdwYV9zID0gd3BhX3MtPm5leHQ7CiAJd2hpbGUgKHdwYV9zKSB7Ci0JCWVudW0gd3BhX2RyaXZlcl9pZl90eXBlIHR5cGU7CiAJCXRtcCA9IGdsb2JhbC0+aWZhY2VzOwogCQl3aGlsZSAodG1wICYmCiAJCSAgICAgICAodG1wID09IHdwYV9zIHx8CkBAIC0yNDc5LDEyICsyNTc5LDggQEAKIAkJfQogCQlpZiAodG1wID09IE5VTEwpCiAJCQlicmVhazsKLQkJaWZuYW1lID0gb3Nfc3RyZHVwKHRtcC0+aWZuYW1lKTsKLQkJdHlwZSA9IHdwYXNfcDJwX2lmX3R5cGUodG1wLT5wMnBfZ3JvdXBfaW50ZXJmYWNlKTsKLQkJd3BhX3N1cHBsaWNhbnRfcmVtb3ZlX2lmYWNlKGdsb2JhbCwgdG1wLCAwKTsKLQkJaWYgKGlmbmFtZSkKLQkJCXdwYV9kcnZfaWZfcmVtb3ZlKHdwYV9zLCB0eXBlLCBpZm5hbWUpOwotCQlvc19mcmVlKGlmbmFtZSk7CisJCS8qIERpc2Nvbm5lY3QgZnJvbSB0aGUgUDJQIGdyb3VwIGFuZCBkZWluaXQgdGhlIGludGVyZmFjZSAqLworCQl3cGFzX3AycF9kaXNjb25uZWN0KHRtcCk7CiAJfQogCiAJLyoKQEAgLTI0OTgsNiArMjU5NCw3IEBACiAKIAlwMnBfZGVpbml0KGdsb2JhbC0+cDJwKTsKIAlnbG9iYWwtPnAycCA9IE5VTEw7CisJZ2xvYmFsLT5wMnBfaW5pdF93cGFfcyA9IE5VTEw7CiB9CiAKIApAQCAtMjUyMiw3ICsyNjE5LDggQEAKIAkJCQkgY29uc3QgdTggKnBlZXJfYWRkciwKIAkJCQkgZW51bSBwMnBfd3BzX21ldGhvZCB3cHNfbWV0aG9kLAogCQkJCSBpbnQgZ29faW50ZW50LCBjb25zdCB1OCAqb3duX2ludGVyZmFjZV9hZGRyLAotCQkJCSB1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgaW50IHBlcnNpc3RlbnRfZ3JvdXApCisJCQkJIHVuc2lnbmVkIGludCBmb3JjZV9mcmVxLCBpbnQgcGVyc2lzdGVudF9ncm91cCwKKwkJCQkgc3RydWN0IHdwYV9zc2lkICpzc2lkKQogewogCWlmIChwZXJzaXN0ZW50X2dyb3VwICYmIHdwYV9zLT5jb25mLT5wZXJzaXN0ZW50X3JlY29ubmVjdCkKIAkJcGVyc2lzdGVudF9ncm91cCA9IDI7CkBAIC0yNTM1LDcgKzI2MzMsOSBAQAogCiAJcmV0dXJuIHAycF9jb25uZWN0KHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyLCB3cHNfbWV0aG9kLAogCQkJICAgZ29faW50ZW50LCBvd25faW50ZXJmYWNlX2FkZHIsIGZvcmNlX2ZyZXEsCi0JCQkgICBwZXJzaXN0ZW50X2dyb3VwKTsKKwkJCSAgIHBlcnNpc3RlbnRfZ3JvdXAsIHNzaWQgPyBzc2lkLT5zc2lkIDogTlVMTCwKKwkJCSAgIHNzaWQgPyBzc2lkLT5zc2lkX2xlbiA6IDAsCisJCQkgICB3cGFfcy0+cDJwX3BkX2JlZm9yZV9nb19uZWcpOwogfQogCiAKQEAgLTI1NDMsNyArMjY0Myw4IEBACiAJCQkJY29uc3QgdTggKnBlZXJfYWRkciwKIAkJCQllbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCiAJCQkJaW50IGdvX2ludGVudCwgY29uc3QgdTggKm93bl9pbnRlcmZhY2VfYWRkciwKLQkJCQl1bnNpZ25lZCBpbnQgZm9yY2VfZnJlcSwgaW50IHBlcnNpc3RlbnRfZ3JvdXApCisJCQkJdW5zaWduZWQgaW50IGZvcmNlX2ZyZXEsIGludCBwZXJzaXN0ZW50X2dyb3VwLAorCQkJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKIHsKIAlpZiAocGVyc2lzdGVudF9ncm91cCAmJiB3cGFfcy0+Y29uZi0+cGVyc2lzdGVudF9yZWNvbm5lY3QpCiAJCXBlcnNpc3RlbnRfZ3JvdXAgPSAyOwpAQCAtMjU1Myw3ICsyNjU0LDggQEAKIAogCXJldHVybiBwMnBfYXV0aG9yaXplKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyLCB3cHNfbWV0aG9kLAogCQkJICAgICBnb19pbnRlbnQsIG93bl9pbnRlcmZhY2VfYWRkciwgZm9yY2VfZnJlcSwKLQkJCSAgICAgcGVyc2lzdGVudF9ncm91cCk7CisJCQkgICAgIHBlcnNpc3RlbnRfZ3JvdXAsIHNzaWQgPyBzc2lkLT5zc2lkIDogTlVMTCwKKwkJCSAgICAgc3NpZCA/IHNzaWQtPnNzaWRfbGVuIDogMCk7CiB9CiAKIApAQCAtMjU2Nyw2ICsyNjY5LDEzIEBACiAJCQkgICAiIGZvciBqb2luIG9wZXJhdGlvbmcgLSBzdG9wIGpvaW4gYXR0ZW1wdCIsCiAJCQkgICBNQUMyU1RSKHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkcikpOwogCQllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9qb2luX3NjYW4sIHdwYV9zLCBOVUxMKTsKKwkJaWYgKHdwYV9zLT5wMnBfYXV0b19wZCkgeworCQkJd3BhX3MtPnAycF9hdXRvX3BkID0gMDsKKwkJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLCBQMlBfRVZFTlRfUFJPVl9ESVNDX0ZBSUxVUkUKKwkJCQkiIHAycF9kZXZfYWRkcj0iIE1BQ1NUUiAiIHN0YXR1cz1OL0EiLAorCQkJCU1BQzJTVFIod3BhX3MtPnBlbmRpbmdfam9pbl9kZXZfYWRkcikpOworCQkJcmV0dXJuOworCQl9CiAJCXdwYV9tc2cod3BhX3MtPnBhcmVudCwgTVNHX0lORk8sCiAJCQlQMlBfRVZFTlRfR1JPVVBfRk9STUFUSU9OX0ZBSUxVUkUpOwogCX0KQEAgLTI1ODgsMjYgKzI2OTcsMTU1IEBACiB9CiAKIAorc3RhdGljIGludCB3cGFzX2NoZWNrX2ZyZXFfY29uZmxpY3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICppZmFjZTsKKwlpbnQgc2hhcmVkX2ZyZXE7CisJdTggYnNzaWRbRVRIX0FMRU5dOworCisJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX01VTFRJX0NIQU5ORUxfQ09OQ1VSUkVOVCkKKwkJcmV0dXJuIDA7CisKKwlmb3IgKGlmYWNlID0gd3BhX3MtPmdsb2JhbC0+aWZhY2VzOyBpZmFjZTsgaWZhY2UgPSBpZmFjZS0+bmV4dCkgeworCQlpZiAoIXdwYXNfcDJwX2NyZWF0ZV9pZmFjZSh3cGFfcykgJiYgaWZhY2UgPT0gd3BhX3MpCisJCQljb250aW51ZTsKKwkJaWYgKGlmYWNlLT5jdXJyZW50X3NzaWQgPT0gTlVMTCB8fCBpZmFjZS0+YXNzb2NfZnJlcSA9PSAwKQorCQkJY29udGludWU7CisJCWlmIChpZmFjZS0+Y3VycmVudF9zc2lkLT5tb2RlID09IFdQQVNfTU9ERV9BUCB8fAorCQkgICAgaWZhY2UtPmN1cnJlbnRfc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPKQorCQkJc2hhcmVkX2ZyZXEgPSBpZmFjZS0+Y3VycmVudF9zc2lkLT5mcmVxdWVuY3k7CisJCWVsc2UgaWYgKHdwYV9kcnZfZ2V0X2Jzc2lkKGlmYWNlLCBic3NpZCkgPT0gMCkKKwkJCXNoYXJlZF9mcmVxID0gaWZhY2UtPmFzc29jX2ZyZXE7CisJCWVsc2UKKwkJCXNoYXJlZF9mcmVxID0gMDsKKworCQlpZiAoc2hhcmVkX2ZyZXEgJiYgZnJlcSAhPSBzaGFyZWRfZnJlcSkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEZyZXF1ZW5jeSBjb25mbGljdCAtICVzICIKKwkJCQkgICAiY29ubmVjdGVkIG9uICVkIE1IeiAtIG5ldyBjb25uZWN0aW9uIG9uICIKKwkJCQkgICAiJWQgTUh6IiwgaWZhY2UtPmlmbmFtZSwgc2hhcmVkX2ZyZXEsIGZyZXEpOworCQkJcmV0dXJuIDE7CisJCX0KKwl9CisKKwlzaGFyZWRfZnJlcSA9IHdwYV9kcnZfc2hhcmVkX2ZyZXEod3BhX3MpOworCWlmIChzaGFyZWRfZnJlcSA+IDAgJiYgc2hhcmVkX2ZyZXEgIT0gZnJlcSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogRnJlcXVlbmN5IGNvbmZsaWN0IC0gc2hhcmVkICIKKwkJCSAgICJ2aXJ0dWFsIGludGVyZmFjZSBjb25uZWN0ZWQgb24gJWQgTUh6IC0gbmV3ICIKKwkJCSAgICJjb25uZWN0aW9uIG9uICVkIE1IeiIsIHNoYXJlZF9mcmVxLCBmcmVxKTsKKwkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFzX3AycF9wZWVyX2dvKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICAgY29uc3QgdTggKnBlZXJfZGV2X2FkZHIpCit7CisJc3RydWN0IHdwYV9ic3MgKmJzczsKKwlpbnQgdXBkYXRlZDsKKworCWJzcyA9IHdwYV9ic3NfZ2V0X3AycF9kZXZfYWRkcih3cGFfcywgcGVlcl9kZXZfYWRkcik7CisJaWYgKGJzcyA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisJaWYgKGJzcy0+bGFzdF91cGRhdGVfaWR4IDwgd3BhX3MtPmJzc191cGRhdGVfaWR4KSB7CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBQZWVyIEJTUyBlbnRyeSBub3QgdXBkYXRlZCBpbiB0aGUgIgorCQkJICAgImxhc3Qgc2NhbiIpOworCQlyZXR1cm4gMDsKKwl9CisKKwl1cGRhdGVkID0gb3NfdGltZV9iZWZvcmUoJndwYV9zLT5wMnBfYXV0b19zdGFydGVkLCAmYnNzLT5sYXN0X3VwZGF0ZSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEN1cnJlbnQgQlNTIGVudHJ5IGZvciBwZWVyIHVwZGF0ZWQgYXQgIgorCQkgICAiJWxkLiUwNmxkICglc3VwZGF0ZWQgaW4gbGFzdCBzY2FuKSIsCisJCSAgIGJzcy0+bGFzdF91cGRhdGUuc2VjLCBic3MtPmxhc3RfdXBkYXRlLnVzZWMsCisJCSAgIHVwZGF0ZWQgPyAiIjogIm5vdCAiKTsKKworCXJldHVybiB1cGRhdGVkOworfQorCisKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX3NjYW5fcmVzX2pvaW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICBzdHJ1Y3Qgd3BhX3NjYW5fcmVzdWx0cyAqc2Nhbl9yZXMpCiB7CiAJc3RydWN0IHdwYV9ic3MgKmJzczsKIAlpbnQgZnJlcTsKIAl1OCBpZmFjZV9hZGRyW0VUSF9BTEVOXTsKLSNpZmRlZiBBTkRST0lEX1AyUAkKLQlpbnQgc2hhcmVkX2ZyZXEgPSAwOwotI2VuZGlmCisKIAllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9qb2luX3NjYW4sIHdwYV9zLCBOVUxMKTsKIAogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQpCiAJCXJldHVybjsKIAotCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTY2FuIHJlc3VsdHMgcmVjZWl2ZWQgKCVkIEJTUykgZm9yIGpvaW4iLAotCQkgICBzY2FuX3JlcyA/IChpbnQpIHNjYW5fcmVzLT5udW0gOiAtMSk7CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNjYW4gcmVzdWx0cyByZWNlaXZlZCAoJWQgQlNTKSBmb3IgJXNqb2luIiwKKwkJICAgc2Nhbl9yZXMgPyAoaW50KSBzY2FuX3Jlcy0+bnVtIDogLTEsCisJCSAgIHdwYV9zLT5wMnBfYXV0b19qb2luID8gImF1dG9fIiA6ICIiKTsKIAogCWlmIChzY2FuX3JlcykKIAkJd3Bhc19wMnBfc2Nhbl9yZXNfaGFuZGxlcih3cGFfcywgc2Nhbl9yZXMpOwogCisJaWYgKHdwYV9zLT5wMnBfYXV0b19wZCkgeworCQlpbnQgam9pbiA9IHdwYXNfcDJwX3BlZXJfZ28od3BhX3MsCisJCQkJCSAgICB3cGFfcy0+cGVuZGluZ19qb2luX2Rldl9hZGRyKTsKKwkJaWYgKGpvaW4gPT0gMCAmJgorCQkgICAgd3BhX3MtPmF1dG9fcGRfc2Nhbl9yZXRyeSA8IFAyUF9BVVRPX1BEX1NDQU5fQVRURU1QVFMpIHsKKwkJCXdwYV9zLT5hdXRvX3BkX3NjYW5fcmV0cnkrKzsKKwkJCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkKHdwYV9zLAorCQkJCQkJd3BhX3MtPnBlbmRpbmdfam9pbl9kZXZfYWRkcik7CisJCQlpZiAoYnNzKSB7CisJCQkJZnJlcSA9IGJzcy0+ZnJlcTsKKwkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogU2NhbiByZXRyeSAlZCBmb3IgIgorCQkJCQkgICAidGhlIHBlZXIgIiBNQUNTVFIgIiBhdCAlZCBNSHoiLAorCQkJCQkgICB3cGFfcy0+YXV0b19wZF9zY2FuX3JldHJ5LAorCQkJCQkgICBNQUMyU1RSKHdwYV9zLT4KKwkJCQkJCSAgIHBlbmRpbmdfam9pbl9kZXZfYWRkciksCisJCQkJCSAgIGZyZXEpOworCQkJCXdwYXNfcDJwX2pvaW5fc2Nhbl9yZXEod3BhX3MsIGZyZXEpOworCQkJCXJldHVybjsKKwkJCX0KKwkJfQorCisJCWlmIChqb2luIDwgMCkKKwkJCWpvaW4gPSAwOworCisJCXdwYV9zLT5wMnBfYXV0b19wZCA9IDA7CisJCXdwYV9zLT5wZW5kaW5nX3BkX3VzZSA9IGpvaW4gPyBBVVRPX1BEX0pPSU4gOiBBVVRPX1BEX0dPX05FRzsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEF1dG8gUEQgd2l0aCAiIE1BQ1NUUiAiIGpvaW49JWQiLAorCQkJICAgTUFDMlNUUih3cGFfcy0+cGVuZGluZ19qb2luX2Rldl9hZGRyKSwgam9pbik7CisJCWlmIChwMnBfcHJvdl9kaXNjX3JlcSh3cGFfcy0+Z2xvYmFsLT5wMnAsCisJCQkJICAgICAgd3BhX3MtPnBlbmRpbmdfam9pbl9kZXZfYWRkciwKKwkJCQkgICAgICB3cGFfcy0+cGVuZGluZ19wZF9jb25maWdfbWV0aG9kcywgam9pbiwKKwkJCQkgICAgICAwKSA8IDApIHsKKwkJCXdwYV9zLT5wMnBfYXV0b19wZCA9IDA7CisJCQl3cGFfbXNnKHdwYV9zLCBNU0dfSU5GTywgUDJQX0VWRU5UX1BST1ZfRElTQ19GQUlMVVJFCisJCQkJIiBwMnBfZGV2X2FkZHI9IiBNQUNTVFIgIiBzdGF0dXM9Ti9BIiwKKwkJCQlNQUMyU1RSKHdwYV9zLT5wZW5kaW5nX2pvaW5fZGV2X2FkZHIpKTsKKwkJfQorCQlyZXR1cm47CisJfQorCisJaWYgKHdwYV9zLT5wMnBfYXV0b19qb2luKSB7CisJCWludCBqb2luID0gd3Bhc19wMnBfcGVlcl9nbyh3cGFfcywKKwkJCQkJICAgIHdwYV9zLT5wZW5kaW5nX2pvaW5fZGV2X2FkZHIpOworCQlpZiAoam9pbiA8IDApIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBQZWVyIHdhcyBub3QgZm91bmQgdG8gYmUgIgorCQkJCSAgICJydW5uaW5nIGEgR08gLT4gdXNlIEdPIE5lZ290aWF0aW9uIik7CisJCQl3cGFzX3AycF9jb25uZWN0KHdwYV9zLCB3cGFfcy0+cGVuZGluZ19qb2luX2Rldl9hZGRyLAorCQkJCQkgd3BhX3MtPnAycF9waW4sIHdwYV9zLT5wMnBfd3BzX21ldGhvZCwKKwkJCQkJIHdwYV9zLT5wMnBfcGVyc2lzdGVudF9ncm91cCwgMCwgMCwgMCwKKwkJCQkJIHdwYV9zLT5wMnBfZ29faW50ZW50LAorCQkJCQkgd3BhX3MtPnAycF9jb25uZWN0X2ZyZXEsCisJCQkJCSB3cGFfcy0+cDJwX3BlcnNpc3RlbnRfaWQsCisJCQkJCSB3cGFfcy0+cDJwX3BkX2JlZm9yZV9nb19uZWcpOworCQkJcmV0dXJuOworCQl9CisKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFBlZXIgd2FzIGZvdW5kIHJ1bm5pbmcgR08lcyAtPiAiCisJCQkgICAidHJ5IHRvIGpvaW4gdGhlIGdyb3VwIiwgam9pbiA/ICIiIDoKKwkJCSAgICIgaW4gb2xkZXIgc2NhbiIpOworCQlpZiAoIWpvaW4pCisJCQl3cGFfcy0+cDJwX2ZhbGxiYWNrX3RvX2dvX25lZyA9IDE7CisJfQorCiAJZnJlcSA9IHAycF9nZXRfb3Blcl9mcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwKIAkJCQkgd3BhX3MtPnBlbmRpbmdfam9pbl9pZmFjZV9hZGRyKTsKIAlpZiAoZnJlcSA8IDAgJiYKQEAgLTI2MzEsMTYgKzI4NjksNiBAQAogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogVGFyZ2V0IEdPIG9wZXJhdGluZyBmcmVxdWVuY3kgIgogCQkJICAgImZyb20gUDJQIHBlZXIgdGFibGU6ICVkIE1IeiIsIGZyZXEpOwogCX0KLQotI2lmZGVmIEFORFJPSURfUDJQCi0JaWYgKCEod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfTVVMVElfQ0hBTk5FTF9DT05DVVJSRU5UKSAmJiAKLQkJKChzaGFyZWRfZnJlcSA9IHdwYV9kcnZfc2hhcmVkX2ZyZXEod3BhX3MpKSA+IDApICYmIChzaGFyZWRfZnJlcSAhPSBmcmVxKSkgewotCQl3cGFfbXNnKHdwYV9zLT5wYXJlbnQsIE1TR19JTkZPLAotCQkJCQlQMlBfRVZFTlRfR1JPVVBfRk9STUFUSU9OX0ZBSUxVUkUgInJlYXNvbj1GUkVRX0NPTkZMSUNUIik7Ci0JCXJldHVybjsKLQl9Ci0jZW5kaWYKLQogCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkKHdwYV9zLCB3cGFfcy0+cGVuZGluZ19qb2luX2lmYWNlX2FkZHIpOwogCWlmIChic3MpIHsKIAkJZnJlcSA9IGJzcy0+ZnJlcTsKQEAgLTI2NTAsNiArMjg3OCwxMyBAQAogCWlmIChmcmVxID4gMCkgewogCQl1MTYgbWV0aG9kOwogCisJCWlmICh3cGFzX2NoZWNrX2ZyZXFfY29uZmxpY3Qod3BhX3MsIGZyZXEpID4gMCkgeworCQkJd3BhX21zZyh3cGFfcy0+cGFyZW50LCBNU0dfSU5GTywKKwkJCQlQMlBfRVZFTlRfR1JPVVBfRk9STUFUSU9OX0ZBSUxVUkUKKwkJCQkicmVhc29uPUZSRVFfQ09ORkxJQ1QiKTsKKwkJCXJldHVybjsKKwkJfQorCiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTZW5kIFByb3Zpc2lvbiBEaXNjb3ZlcnkgUmVxdWVzdCAiCiAJCQkgICAicHJpb3IgdG8gam9pbmluZyBhbiBleGlzdGluZyBncm91cCAoR08gIiBNQUNTVFIKIAkJCSAgICIgZnJlcT0ldSBNSHopIiwKQEAgLTI3MjIsMTMgKzI5NTcsMTMgQEAKIH0KIAogCi1zdGF0aWMgdm9pZCB3cGFzX3AycF9qb2luX3NjYW4odm9pZCAqZWxvb3BfY3R4LCB2b2lkICp0aW1lb3V0X2N0eCkKK3N0YXRpYyB2b2lkIHdwYXNfcDJwX2pvaW5fc2Nhbl9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEpCiB7Ci0Jc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKIAlpbnQgcmV0OwogCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zIHBhcmFtczsKIAlzdHJ1Y3Qgd3BhYnVmICp3cHNfaWUsICppZXM7CiAJc2l6ZV90IGllbGVuOworCWludCBmcmVxc1syXSA9IHsgMCwgMCB9OwogCiAJb3NfbWVtc2V0KCZwYXJhbXMsIDAsIHNpemVvZihwYXJhbXMpKTsKIApAQCAtMjczOCw4ICsyOTczLDkgQEAKIAlwYXJhbXMuc3NpZHNbMF0uc3NpZF9sZW4gPSBQMlBfV0lMRENBUkRfU1NJRF9MRU47CiAKIAl3cGFfcy0+d3BzLT5kZXYucDJwID0gMTsKLQl3cHNfaWUgPSB3cHNfYnVpbGRfcHJvYmVfcmVxX2llKDAsICZ3cGFfcy0+d3BzLT5kZXYsIHdwYV9zLT53cHMtPnV1aWQsCi0JCQkJCVdQU19SRVFfRU5ST0xMRUUsIDAsIE5VTEwpOworCXdwc19pZSA9IHdwc19idWlsZF9wcm9iZV9yZXFfaWUoREVWX1BXX0RFRkFVTFQsICZ3cGFfcy0+d3BzLT5kZXYsCisJCQkJCXdwYV9zLT53cHMtPnV1aWQsIFdQU19SRVFfRU5ST0xMRUUsIDAsCisJCQkJCU5VTEwpOwogCWlmICh3cHNfaWUgPT0gTlVMTCkgewogCQl3cGFzX3AycF9zY2FuX3Jlc19qb2luKHdwYV9zLCBOVUxMKTsKIAkJcmV0dXJuOwpAQCAtMjc2MCwxMyArMjk5NiwxOCBAQAogCXBhcmFtcy5wMnBfcHJvYmUgPSAxOwogCXBhcmFtcy5leHRyYV9pZXMgPSB3cGFidWZfaGVhZChpZXMpOwogCXBhcmFtcy5leHRyYV9pZXNfbGVuID0gd3BhYnVmX2xlbihpZXMpOworCWlmIChmcmVxID4gMCkgeworCQlmcmVxc1swXSA9IGZyZXE7CisJCXBhcmFtcy5mcmVxcyA9IGZyZXFzOworCX0KIAogCS8qCiAJICogUnVuIGEgc2NhbiB0byB1cGRhdGUgQlNTIHRhYmxlIGFuZCBzdGFydCBQcm92aXNpb24gRGlzY292ZXJ5IG9uY2UKIAkgKiB0aGUgbmV3IHNjYW4gcmVzdWx0cyBiZWNvbWUgYXZhaWxhYmxlLgogCSAqLwotCXdwYV9zLT5zY2FuX3Jlc19oYW5kbGVyID0gd3Bhc19wMnBfc2Nhbl9yZXNfam9pbjsKIAlyZXQgPSB3cGFfZHJ2X3NjYW4od3BhX3MsICZwYXJhbXMpOworCWlmICghcmV0KQorCQl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IHdwYXNfcDJwX3NjYW5fcmVzX2pvaW47CiAKIAl3cGFidWZfZnJlZShpZXMpOwogCkBAIC0yNzgwLDEzICszMDIxLDI0IEBACiB9CiAKIAorc3RhdGljIHZvaWQgd3Bhc19wMnBfam9pbl9zY2FuKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKKwl3cGFzX3AycF9qb2luX3NjYW5fcmVxKHdwYV9zLCAwKTsKK30KKworCiBzdGF0aWMgaW50IHdwYXNfcDJwX2pvaW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmlmYWNlX2FkZHIsCi0JCQkgY29uc3QgdTggKmRldl9hZGRyLCBlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QpCisJCQkgY29uc3QgdTggKmRldl9hZGRyLCBlbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2QsCisJCQkgaW50IGF1dG9fam9pbikKIHsKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogUmVxdWVzdCB0byBqb2luIGV4aXN0aW5nIGdyb3VwIChpZmFjZSAiCi0JCSAgIE1BQ1NUUiAiIGRldiAiIE1BQ1NUUiAiKSIsCi0JCSAgIE1BQzJTVFIoaWZhY2VfYWRkciksIE1BQzJTVFIoZGV2X2FkZHIpKTsKKwkJICAgTUFDU1RSICIgZGV2ICIgTUFDU1RSICIpJXMiLAorCQkgICBNQUMyU1RSKGlmYWNlX2FkZHIpLCBNQUMyU1RSKGRldl9hZGRyKSwKKwkJICAgYXV0b19qb2luID8gIiAoYXV0b19qb2luKSIgOiAiIik7CiAKKwl3cGFfcy0+cDJwX2F1dG9fcGQgPSAwOworCXdwYV9zLT5wMnBfYXV0b19qb2luID0gISFhdXRvX2pvaW47CiAJb3NfbWVtY3B5KHdwYV9zLT5wZW5kaW5nX2pvaW5faWZhY2VfYWRkciwgaWZhY2VfYWRkciwgRVRIX0FMRU4pOwogCW9zX21lbWNweSh3cGFfcy0+cGVuZGluZ19qb2luX2Rldl9hZGRyLCBkZXZfYWRkciwgRVRIX0FMRU4pOwogCXdwYV9zLT5wZW5kaW5nX2pvaW5fd3BzX21ldGhvZCA9IHdwc19tZXRob2Q7CkBAIC0yODA0LDYgKzMwNTYsNyBAQAogewogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqZ3JvdXA7CiAJc3RydWN0IHAycF9nb19uZWdfcmVzdWx0cyByZXM7CisJc3RydWN0IHdwYV9ic3MgKmJzczsKIAogCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX3BkX2JlZm9yZV9qb2luX3RpbWVvdXQsIHdwYV9zLCBOVUxMKTsKIAlncm91cCA9IHdwYXNfcDJwX2dldF9ncm91cF9pZmFjZSh3cGFfcywgMCwgMCk7CkBAIC0yODE2LDExICszMDY5LDE5IEBACiAJfQogCiAJZ3JvdXAtPnAycF9pbl9wcm92aXNpb25pbmcgPSAxOworCWdyb3VwLT5wMnBfZmFsbGJhY2tfdG9fZ29fbmVnID0gd3BhX3MtPnAycF9mYWxsYmFja190b19nb19uZWc7CiAKIAlvc19tZW1zZXQoJnJlcywgMCwgc2l6ZW9mKHJlcykpOwogCW9zX21lbWNweShyZXMucGVlcl9pbnRlcmZhY2VfYWRkciwgd3BhX3MtPnBlbmRpbmdfam9pbl9pZmFjZV9hZGRyLAogCQkgIEVUSF9BTEVOKTsKIAlyZXMud3BzX21ldGhvZCA9IHdwYV9zLT5wZW5kaW5nX2pvaW5fd3BzX21ldGhvZDsKKwlic3MgPSB3cGFfYnNzX2dldF9ic3NpZCh3cGFfcywgd3BhX3MtPnBlbmRpbmdfam9pbl9pZmFjZV9hZGRyKTsKKwlpZiAoYnNzKSB7CisJCXJlcy5mcmVxID0gYnNzLT5mcmVxOworCQlyZXMuc3NpZF9sZW4gPSBic3MtPnNzaWRfbGVuOworCQlvc19tZW1jcHkocmVzLnNzaWQsIGJzcy0+c3NpZCwgYnNzLT5zc2lkX2xlbik7CisJfQorCiAJaWYgKHdwYV9zLT5vZmZfY2hhbm5lbF9mcmVxIHx8IHdwYV9zLT5yb2Nfd2FpdGluZ19kcnZfZnJlcSkgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ2FuY2VsIHJlbWFpbi1vbi1jaGFubmVsIHByaW9yIHRvICIKIAkJCSAgICJzdGFydGluZyBjbGllbnQiKTsKQEAgLTI4NDksMzAgKzMxMTAsNDMgQEAKICAqIEBwZWVyX2FkZHI6IEFkZHJlc3Mgb2YgdGhlIHBlZXIgUDJQIERldmljZQogICogQHBpbjogUElOIHRvIHVzZSBkdXJpbmcgcHJvdmlzaW9uaW5nIG9yICVOVUxMIHRvIGluZGljYXRlIFBCQyBtb2RlCiAgKiBAcGVyc2lzdGVudF9ncm91cDogV2hldGhlciB0byBjcmVhdGUgYSBwZXJzaXN0ZW50IGdyb3VwCisgKiBAYXV0b19qb2luOiBXaGV0aGVyIHRvIHNlbGVjdCBqb2luIHZzLiBHTyBOZWdvdGlhdGlvbiBhdXRvbWF0aWNhbGx5CiAgKiBAam9pbjogV2hldGhlciB0byBqb2luIGFuIGV4aXN0aW5nIGdyb3VwIChhcyBhIGNsaWVudCkgaW5zdGVhZCBvZiBzdGFydGluZwogICoJR3JvdXAgT3duZXIgbmVnb3RpYXRpb247IEBwZWVyX2FkZHIgaXMgQlNTSUQgaW4gdGhhdCBjYXNlCiAgKiBAYXV0aDogV2hldGhlciB0byBvbmx5IGF1dGhvcml6ZSB0aGUgY29ubmVjdGlvbiBpbnN0ZWFkIG9mIGRvaW5nIHRoYXQgYW5kCiAgKglpbml0aWF0aW5nIEdyb3VwIE93bmVyIG5lZ290aWF0aW9uCiAgKiBAZ29faW50ZW50OiBHTyBJbnRlbnQgb3IgLTEgdG8gdXNlIGRlZmF1bHQKICAqIEBmcmVxOiBGcmVxdWVuY3kgZm9yIHRoZSBncm91cCBvciAwIGZvciBhdXRvLXNlbGVjdGlvbgorICogQHBlcnNpc3RlbnRfaWQ6IFBlcnNpc3RlbnQgZ3JvdXAgY3JlZGVudGlhbHMgdG8gdXNlIGZvciBmb3JjaW5nIEdPCisgKglwYXJhbWV0ZXJzIG9yIC0xIHRvIGdlbmVyYXRlIG5ldyB2YWx1ZXMgKFNTSUQvcGFzc3BocmFzZSkKKyAqIEBwZDogV2hldGhlciB0byBzZW5kIFByb3Zpc2lvbiBEaXNjb3ZlcnkgcHJpb3IgdG8gR08gTmVnb3RpYXRpb24gYXMgYW4KKyAqCWludGVyb3BlcmFiaWxpdHkgd29ya2Fyb3VuZCB3aGVuIGluaXRpYXRpbmcgZ3JvdXAgZm9ybWF0aW9uCiAgKiBSZXR1cm5zOiAwIG9yIG5ldyBQSU4gKGlmIHBpbiB3YXMgJU5VTEwpIG9uIHN1Y2Nlc3MsIC0xIG9uIHVuc3BlY2lmaWVkCiAgKglmYWlsdXJlLCAtMiBvbiBmYWlsdXJlIGR1ZSB0byBjaGFubmVsIG5vdCBjdXJyZW50bHkgYXZhaWxhYmxlLAogICoJLTMgaWYgZm9yY2VkIGNoYW5uZWwgaXMgbm90IHN1cHBvcnRlZAogICovCiBpbnQgd3Bhc19wMnBfY29ubmVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqcGVlcl9hZGRyLAogCQkgICAgIGNvbnN0IGNoYXIgKnBpbiwgZW51bSBwMnBfd3BzX21ldGhvZCB3cHNfbWV0aG9kLAotCQkgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwLCBpbnQgam9pbiwgaW50IGF1dGgsIGludCBnb19pbnRlbnQsCi0JCSAgICAgaW50IGZyZXEpCisJCSAgICAgaW50IHBlcnNpc3RlbnRfZ3JvdXAsIGludCBhdXRvX2pvaW4sIGludCBqb2luLCBpbnQgYXV0aCwKKwkJICAgICBpbnQgZ29faW50ZW50LCBpbnQgZnJlcSwgaW50IHBlcnNpc3RlbnRfaWQsIGludCBwZCkKIHsKIAlpbnQgZm9yY2VfZnJlcSA9IDAsIG9wZXJfZnJlcSA9IDA7CiAJdTggYnNzaWRbRVRIX0FMRU5dOwogCWludCByZXQgPSAwOwogCWVudW0gd3BhX2RyaXZlcl9pZl90eXBlIGlmdHlwZTsKIAljb25zdCB1OCAqaWZfYWRkcjsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSBOVUxMOwogCiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCB8fCB3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOwogCisJaWYgKHBlcnNpc3RlbnRfaWQgPj0gMCkgeworCQlzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgcGVyc2lzdGVudF9pZCk7CisJCWlmIChzc2lkID09IE5VTEwgfHwgc3NpZC0+ZGlzYWJsZWQgIT0gMiB8fAorCQkgICAgc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dPKQorCQkJcmV0dXJuIC0xOworCX0KKwogCWlmIChnb19pbnRlbnQgPCAwKQogCQlnb19pbnRlbnQgPSB3cGFfcy0+Y29uZi0+cDJwX2dvX2ludGVudDsKIApAQCAtMjg4MCw2ICszMTU0LDEyIEBACiAJCXdwYV9zLT5wMnBfbG9uZ19saXN0ZW4gPSAwOwogCiAJd3BhX3MtPnAycF93cHNfbWV0aG9kID0gd3BzX21ldGhvZDsKKwl3cGFfcy0+cDJwX3BlcnNpc3RlbnRfZ3JvdXAgPSAhIXBlcnNpc3RlbnRfZ3JvdXA7CisJd3BhX3MtPnAycF9wZXJzaXN0ZW50X2lkID0gcGVyc2lzdGVudF9pZDsKKwl3cGFfcy0+cDJwX2dvX2ludGVudCA9IGdvX2ludGVudDsKKwl3cGFfcy0+cDJwX2Nvbm5lY3RfZnJlcSA9IGZyZXE7CisJd3BhX3MtPnAycF9mYWxsYmFja190b19nb19uZWcgPSAwOworCXdwYV9zLT5wMnBfcGRfYmVmb3JlX2dvX25lZyA9ICEhcGQ7CiAKIAlpZiAocGluKQogCQlvc19zdHJsY3B5KHdwYV9zLT5wMnBfcGluLCBwaW4sIHNpemVvZih3cGFfcy0+cDJwX3BpbikpOwpAQCAtMjg5Miw3ICszMTcyLDcgQEAKIAl9IGVsc2UKIAkJd3BhX3MtPnAycF9waW5bMF0gPSAnXDAnOwogCi0JaWYgKGpvaW4pIHsKKwlpZiAoam9pbiB8fCBhdXRvX2pvaW4pIHsKIAkJdTggaWZhY2VfYWRkcltFVEhfQUxFTl0sIGRldl9hZGRyW0VUSF9BTEVOXTsKIAkJaWYgKGF1dGgpIHsKIAkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBBdXRob3JpemUgaW52aXRhdGlvbiB0byAiCkBAIC0yOTA4LDggKzMxODgsMTUgQEAKIAkJCXAycF9nZXRfZGV2X2FkZHIod3BhX3MtPmdsb2JhbC0+cDJwLCBwZWVyX2FkZHIsCiAJCQkJCSBkZXZfYWRkcik7CiAJCX0KLQkJaWYgKHdwYXNfcDJwX2pvaW4od3BhX3MsIGlmYWNlX2FkZHIsIGRldl9hZGRyLCB3cHNfbWV0aG9kKSA8Ci0JCSAgICAwKQorCQlpZiAoYXV0b19qb2luKSB7CisJCQlvc19nZXRfdGltZSgmd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQpOworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEF1dG8gam9pbiBzdGFydGVkIGF0ICIKKwkJCQkgICAiJWxkLiUwNmxkIiwKKwkJCQkgICB3cGFfcy0+cDJwX2F1dG9fc3RhcnRlZC5zZWMsCisJCQkJICAgd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQudXNlYyk7CisJCX0KKwkJaWYgKHdwYXNfcDJwX2pvaW4od3BhX3MsIGlmYWNlX2FkZHIsIGRldl9hZGRyLCB3cHNfbWV0aG9kLAorCQkJCSAgYXV0b19qb2luKSA8IDApCiAJCQlyZXR1cm4gLTE7CiAJCXJldHVybiByZXQ7CiAJfQpAQCAtMjk4MiwxNCArMzI2OSwxNSBAQAogCWlmIChhdXRoKSB7CiAJCWlmICh3cGFzX3AycF9hdXRoX2dvX25lZyh3cGFfcywgcGVlcl9hZGRyLCB3cHNfbWV0aG9kLAogCQkJCQkgZ29faW50ZW50LCBpZl9hZGRyLAotCQkJCQkgZm9yY2VfZnJlcSwgcGVyc2lzdGVudF9ncm91cCkgPCAwKQorCQkJCQkgZm9yY2VfZnJlcSwgcGVyc2lzdGVudF9ncm91cCwgc3NpZCkgPAorCQkgICAgMCkKIAkJCXJldHVybiAtMTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKIAlpZiAod3Bhc19wMnBfc3RhcnRfZ29fbmVnKHdwYV9zLCBwZWVyX2FkZHIsIHdwc19tZXRob2QsCiAJCQkJICBnb19pbnRlbnQsIGlmX2FkZHIsIGZvcmNlX2ZyZXEsCi0JCQkJICBwZXJzaXN0ZW50X2dyb3VwKSA8IDApIHsKKwkJCQkgIHBlcnNpc3RlbnRfZ3JvdXAsIHNzaWQpIDwgMCkgewogCQlpZiAod3BhX3MtPmNyZWF0ZV9wMnBfaWZhY2UpCiAJCQl3cGFzX3AycF9yZW1vdmVfcGVuZGluZ19ncm91cF9pbnRlcmZhY2Uod3BhX3MpOwogCQlyZXR1cm4gLTE7CkBAIC0zMTQ3LDcgKzM0MzUsMTggQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNldCBHTyBmcmVxIGJhc2VkIG9uIGJlc3QgNSBHSHogIgogCQkJICAgImNoYW5uZWwgJWQgTUh6IiwgcGFyYW1zLT5mcmVxKTsKIAl9IGVsc2UgewotCQlwYXJhbXMtPmZyZXEgPSAyNDEyOworCQlpbnQgY2hhbjsKKwkJZm9yIChjaGFuID0gMDsgY2hhbiA8IDExOyBjaGFuKyspIHsKKwkJCXBhcmFtcy0+ZnJlcSA9IDI0MTIgKyBjaGFuICogNTsKKwkJCWlmICghd3Bhc19wMnBfZGlzYWxsb3dlZF9mcmVxKHdwYV9zLT5nbG9iYWwsCisJCQkJCQkgICAgICBwYXJhbXMtPmZyZXEpKQorCQkJCWJyZWFrOworCQl9CisJCWlmIChjaGFuID09IDExKSB7CisJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogTm8gMi40IEdIeiBjaGFubmVsICIKKwkJCQkgICAiYWxsb3dlZCIpOworCQkJcmV0dXJuIC0xOworCQl9CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBTZXQgR08gZnJlcSAlZCBNSHogKG5vIHByZWZlcmVuY2UgIgogCQkJICAgImtub3duKSIsIHBhcmFtcy0+ZnJlcSk7CiAJfQpAQCAtMzI3MCw2ICszNTY5LDEzIEBACiAKIAlpZiAod3Bhc19wMnBfaW5pdF9nb19wYXJhbXMod3BhX3MsICZwYXJhbXMsIGZyZXEpKQogCQlyZXR1cm4gLTE7CisJaWYgKHBhcmFtcy5mcmVxICYmCisJICAgICFwMnBfc3VwcG9ydGVkX2ZyZXEod3BhX3MtPmdsb2JhbC0+cDJwLCBwYXJhbXMuZnJlcSkpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFRoZSBzZWxlY3RlZCBjaGFubmVsIGZvciBHTyAiCisJCQkgICAiKCV1IE1IeikgaXMgbm90IHN1cHBvcnRlZCBmb3IgUDJQIHVzZXMiLAorCQkJICAgcGFyYW1zLmZyZXEpOworCQlyZXR1cm4gLTE7CisJfQogCXAycF9nb19wYXJhbXMod3BhX3MtPmdsb2JhbC0+cDJwLCAmcGFyYW1zKTsKIAlwYXJhbXMucGVyc2lzdGVudF9ncm91cCA9IHBlcnNpc3RlbnRfZ3JvdXA7CiAKQEAgLTMzNDYsNiArMzY1Miw4IEBACiAJLyogTWFrZSBzdXJlIHdlIGFyZSBub3QgcnVubmluZyBmaW5kIGR1cmluZyBjb25uZWN0aW9uIGVzdGFibGlzaG1lbnQgKi8KIAl3cGFzX3AycF9zdG9wX2ZpbmQod3BhX3MpOwogCisJd3BhX3MtPnAycF9mYWxsYmFja190b19nb19uZWcgPSAwOworCiAJaWYgKHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX0lORlJBKQogCQlyZXR1cm4gd3Bhc19zdGFydF9wMnBfY2xpZW50KHdwYV9zLCBzc2lkLCBhZGRyX2FsbG9jYXRlZCk7CiAKQEAgLTM0MDksMTggKzM3MTcsMTUgQEAKIAlpZiAoIXdwYV9zLT5hcF9pZmFjZSkKIAkJcmV0dXJuOwogCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBHTyAtIGdyb3VwICVzaWRsZSIsIGlkbGUgPyAiIiA6ICJub3QgIik7Ci0JaWYgKGlkbGUpIHsKLQkJd3BhX3ByaW50ZihNU0dfREVCVUcsIkNhbGxpbmcgc2V0IGdyb3VwIGlkbGUgdGltZSBvdXQgZnJvbSBpZGxlX3VwZGF0ZSIpOworCWlmIChpZGxlKQogCQl3cGFzX3AycF9zZXRfZ3JvdXBfaWRsZV90aW1lb3V0KHdwYV9zKTsKLQl9CiAJZWxzZQogCQllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9pZGxlX3RpbWVvdXQsIHdwYV9zLCBOVUxMKTsKIH0KIAogCiBzdHJ1Y3QgcDJwX2dyb3VwICogd3Bhc19wMnBfZ3JvdXBfaW5pdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAotCQkJCSAgICAgICBpbnQgcGVyc2lzdGVudF9ncm91cCwKLQkJCQkgICAgICAgaW50IGdyb3VwX2Zvcm1hdGlvbikKKwkJCQkgICAgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkKQogewogCXN0cnVjdCBwMnBfZ3JvdXAgKmdyb3VwOwogCXN0cnVjdCBwMnBfZ3JvdXBfY29uZmlnICpjZmc7CkBAIC0zNDM0LDkgKzM3MzksOSBAQAogCWlmIChjZmcgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAKLQlpZiAocGVyc2lzdGVudF9ncm91cCAmJiB3cGFfcy0+Y29uZi0+cGVyc2lzdGVudF9yZWNvbm5lY3QpCisJaWYgKHNzaWQtPnAycF9wZXJzaXN0ZW50X2dyb3VwICYmIHdwYV9zLT5jb25mLT5wZXJzaXN0ZW50X3JlY29ubmVjdCkKIAkJY2ZnLT5wZXJzaXN0ZW50X2dyb3VwID0gMjsKLQllbHNlIGlmIChwZXJzaXN0ZW50X2dyb3VwKQorCWVsc2UgaWYgKHNzaWQtPnAycF9wZXJzaXN0ZW50X2dyb3VwKQogCQljZmctPnBlcnNpc3RlbnRfZ3JvdXAgPSAxOwogCW9zX21lbWNweShjZmctPmludGVyZmFjZV9hZGRyLCB3cGFfcy0+b3duX2FkZHIsIEVUSF9BTEVOKTsKIAlpZiAod3BhX3MtPm1heF9zdGF0aW9ucyAmJgpAQCAtMzQ0NCw2ICszNzQ5LDggQEAKIAkJY2ZnLT5tYXhfY2xpZW50cyA9IHdwYV9zLT5tYXhfc3RhdGlvbnM7CiAJZWxzZQogCQljZmctPm1heF9jbGllbnRzID0gd3BhX3MtPmNvbmYtPm1heF9udW1fc3RhOworCW9zX21lbWNweShjZmctPnNzaWQsIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKKwljZmctPnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CiAJY2ZnLT5jYl9jdHggPSB3cGFfczsKIAljZmctPmllX3VwZGF0ZSA9IHdwYXNfcDJwX2llX3VwZGF0ZTsKIAljZmctPmlkbGVfdXBkYXRlID0gd3Bhc19wMnBfaWRsZV91cGRhdGU7CkBAIC0zNDUxLDcgKzM3NTgsNyBAQAogCWdyb3VwID0gcDJwX2dyb3VwX2luaXQod3BhX3MtPmdsb2JhbC0+cDJwLCBjZmcpOwogCWlmIChncm91cCA9PSBOVUxMKQogCQlvc19mcmVlKGNmZyk7Ci0JaWYgKCFncm91cF9mb3JtYXRpb24pCisJaWYgKHNzaWQtPm1vZGUgIT0gV1BBU19NT0RFX1AyUF9HUk9VUF9GT1JNQVRJT04pCiAJCXAycF9ncm91cF9ub3RpZl9mb3JtYXRpb25fZG9uZShncm91cCk7CiAJd3BhX3MtPnAycF9ncm91cCA9IGdyb3VwOwogCXJldHVybiBncm91cDsKQEAgLTM0NjEsMTcgKzM3NjgsMzYgQEAKIHZvaWQgd3Bhc19wMnBfd3BzX3N1Y2Nlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKnBlZXJfYWRkciwKIAkJCSAgaW50IHJlZ2lzdHJhcikKIHsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOworCiAJaWYgKCF3cGFfcy0+cDJwX2luX3Byb3Zpc2lvbmluZykgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogSWdub3JlIFdQUyBzdWNjZXNzIGV2ZW50IC0gUDJQICIKIAkJCSAgICJwcm92aXNpb25pbmcgbm90IGluIHByb2dyZXNzIik7CiAJCXJldHVybjsKIAl9CiAKLQkvKiBDbGVhciBhbnkgc3RvcmVkIHByb3Zpc2lvbmluZyBpbmZvICovCi0JcDJwX2NsZWFyX3Byb3Zpc2lvbmluZ19pbmZvKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyKTsKKwlpZiAoc3NpZCAmJiBzc2lkLT5tb2RlID09IFdQQVNfTU9ERV9JTkZSQSkgeworCQl1OCBnb19kZXZfYWRkcltFVEhfQUxFTl07CisJCW9zX21lbWNweShnb19kZXZfYWRkciwgd3BhX3MtPmJzc2lkLCBFVEhfQUxFTik7CisJCXdwYXNfcDJwX3BlcnNpc3RlbnRfZ3JvdXAod3BhX3MsIGdvX2Rldl9hZGRyLCBzc2lkLT5zc2lkLAorCQkJCQkgIHNzaWQtPnNzaWRfbGVuKTsKKwkJLyogQ2xlYXIgYW55IHN0b3JlZCBwcm92aXNpb25pbmcgaW5mbyAqLworCQlwMnBfY2xlYXJfcHJvdmlzaW9uaW5nX2luZm8od3BhX3MtPmdsb2JhbC0+cDJwLCBnb19kZXZfYWRkcik7CisJfQogCiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsIHdwYV9zLT5wYXJlbnQsCiAJCQkgICAgIE5VTEwpOworCWlmIChzc2lkICYmIHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX0lORlJBKSB7CisJCS8qCisJCSAqIFVzZSBhIHNlcGFyYXRlIHRpbWVvdXQgZm9yIGluaXRpYWwgZGF0YSBjb25uZWN0aW9uIHRvCisJCSAqIGNvbXBsZXRlIHRvIGFsbG93IHRoZSBncm91cCB0byBiZSByZW1vdmVkIGF1dG9tYXRpY2FsbHkgaWYKKwkJICogc29tZXRoaW5nIGdvZXMgd3JvbmcgaW4gdGhpcyBzdGVwIGJlZm9yZSB0aGUgUDJQIGdyb3VwIGlkbGUKKwkJICogdGltZW91dCBtZWNoYW5pc20gaXMgdGFrZW4gaW50byB1c2UuCisJCSAqLworCQllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KFAyUF9NQVhfSU5JVElBTF9DT05OX1dBSVQsIDAsCisJCQkJICAgICAgIHdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0LAorCQkJCSAgICAgICB3cGFfcy0+cGFyZW50LCBOVUxMKTsKKwl9CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCkKIAkJcDJwX3dwc19zdWNjZXNzX2NiKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyKTsKIAllbHNlIGlmICh3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfTUdNVCkKQEAgLTM0OTIsNyArMzgxOCw3IEBACiAJaWYgKHdwYV9zLT5nb19wYXJhbXMpIHsKIAkJcDJwX2NsZWFyX3Byb3Zpc2lvbmluZ19pbmZvKAogCQkJd3BhX3MtPmdsb2JhbC0+cDJwLAotCQkJd3BhX3MtPmdvX3BhcmFtcy0+cGVlcl9pbnRlcmZhY2VfYWRkcik7CisJCQl3cGFfcy0+Z29fcGFyYW1zLT5wZWVyX2RldmljZV9hZGRyKTsKIAl9CiAKIAl3cGFzX25vdGlmeV9wMnBfd3BzX2ZhaWxlZCh3cGFfcywgZmFpbCk7CkBAIC0zNTAwLDEwICszODI2LDEzIEBACiAKIAogaW50IHdwYXNfcDJwX3Byb3ZfZGlzYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqcGVlcl9hZGRyLAotCQkgICAgICAgY29uc3QgY2hhciAqY29uZmlnX21ldGhvZCwgaW50IGpvaW4pCisJCSAgICAgICBjb25zdCBjaGFyICpjb25maWdfbWV0aG9kLAorCQkgICAgICAgZW51bSB3cGFzX3AycF9wcm92X2Rpc2NfdXNlIHVzZSkKIHsKIAl1MTYgY29uZmlnX21ldGhvZHM7CiAKKwl3cGFfcy0+cDJwX2ZhbGxiYWNrX3RvX2dvX25lZyA9IDA7CisJd3BhX3MtPnBlbmRpbmdfcGRfdXNlID0gTk9STUFMX1BEOwogCWlmIChvc19zdHJuY21wKGNvbmZpZ19tZXRob2QsICJkaXNwbGF5IiwgNykgPT0gMCkKIAkJY29uZmlnX21ldGhvZHMgPSBXUFNfQ09ORklHX0RJU1BMQVk7CiAJZWxzZSBpZiAob3Nfc3RybmNtcChjb25maWdfbWV0aG9kLCAia2V5cGFkIiwgNikgPT0gMCkKQEAgLTM1MTYsMTYgKzM4NDUsMzUgQEAKIAkJcmV0dXJuIC0xOwogCX0KIAorCWlmICh1c2UgPT0gV1BBU19QMlBfUERfQVVUTykgeworCQlvc19tZW1jcHkod3BhX3MtPnBlbmRpbmdfam9pbl9kZXZfYWRkciwgcGVlcl9hZGRyLCBFVEhfQUxFTik7CisJCXdwYV9zLT5wZW5kaW5nX3BkX2NvbmZpZ19tZXRob2RzID0gY29uZmlnX21ldGhvZHM7CisJCXdwYV9zLT5wMnBfYXV0b19wZCA9IDE7CisJCXdwYV9zLT5wMnBfYXV0b19qb2luID0gMDsKKwkJd3BhX3MtPnBlbmRpbmdfcGRfYmVmb3JlX2pvaW4gPSAwOworCQl3cGFfcy0+YXV0b19wZF9zY2FuX3JldHJ5ID0gMDsKKwkJd3Bhc19wMnBfc3RvcF9maW5kKHdwYV9zKTsKKwkJd3BhX3MtPnAycF9qb2luX3NjYW5fY291bnQgPSAwOworCQlvc19nZXRfdGltZSgmd3BhX3MtPnAycF9hdXRvX3N0YXJ0ZWQpOworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQXV0byBQRCBzdGFydGVkIGF0ICVsZC4lMDZsZCIsCisJCQkgICB3cGFfcy0+cDJwX2F1dG9fc3RhcnRlZC5zZWMsCisJCQkgICB3cGFfcy0+cDJwX2F1dG9fc3RhcnRlZC51c2VjKTsKKwkJd3Bhc19wMnBfam9pbl9zY2FuKHdwYV9zLCBOVUxMKTsKKwkJcmV0dXJuIDA7CisJfQorCiAJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKSB7CiAJCXJldHVybiB3cGFfZHJ2X3AycF9wcm92X2Rpc2NfcmVxKHdwYV9zLCBwZWVyX2FkZHIsCi0JCQkJCQkgY29uZmlnX21ldGhvZHMsIGpvaW4pOworCQkJCQkJIGNvbmZpZ19tZXRob2RzLAorCQkJCQkJIHVzZSA9PSBXUEFTX1AyUF9QRF9GT1JfSk9JTik7CiAJfQogCiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMIHx8IHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCkKIAkJcmV0dXJuIC0xOwogCiAJcmV0dXJuIHAycF9wcm92X2Rpc2NfcmVxKHdwYV9zLT5nbG9iYWwtPnAycCwgcGVlcl9hZGRyLAotCQkJCSBjb25maWdfbWV0aG9kcywgam9pbiwgMCk7CisJCQkJIGNvbmZpZ19tZXRob2RzLCB1c2UgPT0gV1BBU19QMlBfUERfRk9SX0pPSU4sCisJCQkJIDApOwogfQogCiAKQEAgLTM1NTksNyArMzkwNyw4IEBACiAJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQogCQlyZXR1cm4gd3BhX2Rydl9wMnBfZmluZCh3cGFfcywgdGltZW91dCwgdHlwZSk7CiAKLQlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQorCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwgfHwKKwkgICAgd3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcpCiAJCXJldHVybiAtMTsKIAogCXdwYV9zdXBwbGljYW50X2NhbmNlbF9zY2hlZF9zY2FuKHdwYV9zKTsKQEAgLTM2NjEsMTUgKzQwMTAsMjcgQEAKIAogaW50IHdwYXNfcDJwX3Byb2JlX3JlcV9yeChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYWRkciwKIAkJCSAgY29uc3QgdTggKmRzdCwgY29uc3QgdTggKmJzc2lkLAotCQkJICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pCisJCQkgIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwgaW50IHNzaV9zaWduYWwpCiB7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCkKIAkJcmV0dXJuIDA7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm4gMDsKIAotCXJldHVybiBwMnBfcHJvYmVfcmVxX3J4KHdwYV9zLT5nbG9iYWwtPnAycCwgYWRkciwgZHN0LCBic3NpZCwKLQkJCQlpZSwgaWVfbGVuKTsKKwlzd2l0Y2ggKHAycF9wcm9iZV9yZXFfcngod3BhX3MtPmdsb2JhbC0+cDJwLCBhZGRyLCBkc3QsIGJzc2lkLAorCQkJCSBpZSwgaWVfbGVuKSkgeworCWNhc2UgUDJQX1BSRVFfTk9UX1AyUDoKKwkJd3Bhc19ub3RpZnlfcHJlcSh3cGFfcywgYWRkciwgZHN0LCBic3NpZCwgaWUsIGllX2xlbiwKKwkJCQkgc3NpX3NpZ25hbCk7CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2UgUDJQX1BSRVFfTUFMRk9STUVEOgorCWNhc2UgUDJQX1BSRVFfTk9UX0xJU1RFTjoKKwljYXNlIFAyUF9QUkVRX05PVF9QUk9DRVNTRUQ6CisJZGVmYXVsdDogLyogbWFrZSBnY2MgaGFwcHkgKi8KKwkJcmV0dXJuIDA7CisJY2FzZSBQMlBfUFJFUV9QUk9DRVNTRUQ6CisJCXJldHVybiAxOworCX0KIH0KIAogCkBAIC0zODQwLDYgKzQyMDEsMTEgQEAKIAlpbnQgcGVyc2lzdGVudDsKIAlpbnQgZnJlcTsKIAorCWlmIChzc2lkID09IE5VTEwgfHwgc3NpZC0+bW9kZSAhPSBXUEFTX01PREVfUDJQX0dST1VQX0ZPUk1BVElPTikgeworCQllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9mb3JtYXRpb25fdGltZW91dCwKKwkJCQkgICAgIHdwYV9zLT5wYXJlbnQsIE5VTEwpOworCX0KKwogCWlmICghd3BhX3MtPnNob3dfZ3JvdXBfc3RhcnRlZCB8fCAhc3NpZCkKIAkJcmV0dXJuOwogCkBAIC0zOTM2LDE4ICs0MzAyLDIwIEBACiAJCXJldHVybjsKIAl9CiAKLQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogR3JvdXAgaWRsZSB0aW1lb3V0IHJlYWNoZWQgLSB0ZXJtaW5hdGUgJWQiCi0JCSAgICJncm91cCIsd3BhX3MtPmNvbmYtPnAycF9ncm91cF9pZGxlKTsKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogR3JvdXAgaWRsZSB0aW1lb3V0IHJlYWNoZWQgLSB0ZXJtaW5hdGUgIgorCQkgICAiZ3JvdXAiKTsKIAl3cGFfcy0+cmVtb3ZhbF9yZWFzb24gPSBQMlBfR1JPVVBfUkVNT1ZBTF9JRExFX1RJTUVPVVQ7Ci0Jd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHdwYV9zKTsKKwl3cGFzX3AycF9ncm91cF9kZWxldGUod3BhX3MsIDApOwogfQogCiAKIHN0YXRpYyB2b2lkIHdwYXNfcDJwX3NldF9ncm91cF9pZGxlX3RpbWVvdXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKIHsKLQl1bnNpZ25lZCBpbnQgdGltZW91dDsKKwlpbnQgdGltZW91dDsKIAotCWVsb29wX2NhbmNlbF90aW1lb3V0KHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCwgd3BhX3MsIE5VTEwpOworCWlmIChlbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9ncm91cF9pZGxlX3RpbWVvdXQsIHdwYV9zLCBOVUxMKSA+IDApCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBDYW5jZWxsZWQgUDJQIGdyb3VwIGlkbGUgdGltZW91dCIpOworCiAJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gTlVMTCB8fCAhd3BhX3MtPmN1cnJlbnRfc3NpZC0+cDJwX2dyb3VwKQogCQlyZXR1cm47CiAKQEAgLTM5NTksNiArNDMyNywzNyBAQAogCWlmICh0aW1lb3V0ID09IDApCiAJCXJldHVybjsKIAorCWlmICh0aW1lb3V0IDwgMCkgeworCQlpZiAod3BhX3MtPmN1cnJlbnRfc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfSU5GUkEpCisJCQl0aW1lb3V0ID0gMDsgLyogc3BlY2lhbCBjbGllbnQgbW9kZSBuby10aW1lb3V0ICovCisJCWVsc2UKKwkJCXJldHVybjsKKwl9CisKKwlpZiAod3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcpIHsKKwkJLyoKKwkJICogVXNlIHRoZSBub3JtYWwgZ3JvdXAgZm9ybWF0aW9uIHRpbWVvdXQgZHVyaW5nIHRoZQorCQkgKiBwcm92aXNpb25pbmcgcGhhc2UgdG8gYXZvaWQgdGVybWluYXRpbmcgdGhpcyBwcm9jZXNzIHRvbworCQkgKiBlYXJseSBkdWUgdG8gZ3JvdXAgaWRsZSB0aW1lb3V0LgorCQkgKi8KKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IERvIG5vdCB1c2UgUDJQIGdyb3VwIGlkbGUgdGltZW91dCAiCisJCQkgICAiZHVyaW5nIHByb3Zpc2lvbmluZyIpOworCQlyZXR1cm47CisJfQorCisJaWYgKHdwYV9zLT5zaG93X2dyb3VwX3N0YXJ0ZWQpIHsKKwkJLyoKKwkJICogVXNlIHRoZSBub3JtYWwgZ3JvdXAgZm9ybWF0aW9uIHRpbWVvdXQgYmV0d2VlbiB0aGUgZW5kIG9mCisJCSAqIHRoZSBwcm92aXNpb25pbmcgcGhhc2UgYW5kIGNvbXBsZXRpb24gb2YgNC13YXkgaGFuZHNoYWtlIHRvCisJCSAqIGF2b2lkIHRlcm1pbmF0aW5nIHRoaXMgcHJvY2VzcyB0b28gZWFybHkgZHVlIHRvIGdyb3VwIGlkbGUKKwkJICogdGltZW91dC4KKwkJICovCisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBEbyBub3QgdXNlIFAyUCBncm91cCBpZGxlIHRpbWVvdXQgIgorCQkJICAgIndoaWxlIHdhaXRpbmcgZm9yIGluaXRpYWwgNC13YXkgaGFuZHNoYWtlIHRvICIKKwkJCSAgICJjb21wbGV0ZSIpOworCQlyZXR1cm47CisJfQorCiAJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFNldCBQMlAgZ3JvdXAgaWRsZSB0aW1lb3V0IHRvICV1IHNlY29uZHMiLAogCQkgICB0aW1lb3V0KTsKIAllbG9vcF9yZWdpc3Rlcl90aW1lb3V0KHRpbWVvdXQsIDAsIHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCwKQEAgLTM5NjcsMjYgKzQzNjYsNDIgQEAKIAogCiB2b2lkIHdwYXNfcDJwX2RlYXV0aF9ub3RpZihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQsCi0JCQkgICB1MTYgcmVhc29uX2NvZGUsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbikKKwkJCSAgIHUxNiByZWFzb25fY29kZSwgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuLAorCQkJICAgaW50IGxvY2FsbHlfZ2VuZXJhdGVkKQogewogCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQgfHwgd3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCiAJCXJldHVybjsKIAlpZiAod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfUDJQX01HTVQpCiAJCXJldHVybjsKIAotCXAycF9kZWF1dGhfbm90aWYod3BhX3MtPmdsb2JhbC0+cDJwLCBic3NpZCwgcmVhc29uX2NvZGUsIGllLCBpZV9sZW4pOworCWlmICghbG9jYWxseV9nZW5lcmF0ZWQpCisJCXAycF9kZWF1dGhfbm90aWYod3BhX3MtPmdsb2JhbC0+cDJwLCBic3NpZCwgcmVhc29uX2NvZGUsIGllLAorCQkJCSBpZV9sZW4pOworCisJaWYgKHJlYXNvbl9jb2RlID09IFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HICYmICFsb2NhbGx5X2dlbmVyYXRlZCAmJgorCSAgICB3cGFfcy0+Y3VycmVudF9zc2lkICYmCisJICAgIHdwYV9zLT5jdXJyZW50X3NzaWQtPnAycF9ncm91cCAmJgorCSAgICB3cGFfcy0+Y3VycmVudF9zc2lkLT5tb2RlID09IFdQQVNfTU9ERV9JTkZSQSkgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogR08gaW5kaWNhdGVkIHRoYXQgdGhlIFAyUCBHcm91cCAiCisJCQkgICAic2Vzc2lvbiBpcyBlbmRpbmciKTsKKwkJd3BhX3MtPnJlbW92YWxfcmVhc29uID0gUDJQX0dST1VQX1JFTU9WQUxfR09fRU5ESU5HX1NFU1NJT047CisJCXdwYXNfcDJwX2dyb3VwX2RlbGV0ZSh3cGFfcywgMCk7CisJfQogfQogCiAKIHZvaWQgd3Bhc19wMnBfZGlzYXNzb2Nfbm90aWYoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmJzc2lkLAotCQkJICAgICB1MTYgcmVhc29uX2NvZGUsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbikKKwkJCSAgICAgdTE2IHJlYXNvbl9jb2RlLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4sCisJCQkgICAgIGludCBsb2NhbGx5X2dlbmVyYXRlZCkKIHsKIAlpZiAod3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkIHx8IHdwYV9zLT5nbG9iYWwtPnAycCA9PSBOVUxMKQogCQlyZXR1cm47CiAJaWYgKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1AyUF9NR01UKQogCQlyZXR1cm47CiAKLQlwMnBfZGlzYXNzb2Nfbm90aWYod3BhX3MtPmdsb2JhbC0+cDJwLCBic3NpZCwgcmVhc29uX2NvZGUsIGllLCBpZV9sZW4pOworCWlmICghbG9jYWxseV9nZW5lcmF0ZWQpCisJCXAycF9kaXNhc3NvY19ub3RpZih3cGFfcy0+Z2xvYmFsLT5wMnAsIGJzc2lkLCByZWFzb25fY29kZSwgaWUsCisJCQkJICAgaWVfbGVuKTsKIH0KIAogCkBAIC00MTAyLDYgKzQ1MTcsMTQgQEAKIAkJCXdwYV9wcmludGYoTVNHX0VSUk9SLCAiUDJQOiBPd24gb3BlciBjaGFubmVsIHVwZGF0ZSAiCiAJCQkJICAgImZhaWxlZDogJWQiLCByZXQpOwogCX0KKworCWlmICh3cGFfcy0+Y29uZi0+Y2hhbmdlZF9wYXJhbWV0ZXJzICYgQ0ZHX0NIQU5HRURfUDJQX1BSRUZfQ0hBTikgeworCQlpZiAocDJwX3NldF9wcmVmX2NoYW4ocDJwLCB3cGFfcy0+Y29uZi0+bnVtX3AycF9wcmVmX2NoYW4sCisJCQkJICAgICAgd3BhX3MtPmNvbmYtPnAycF9wcmVmX2NoYW4pIDwgMCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJQMlA6IFByZWZlcnJlZCBjaGFubmVsIGxpc3QgIgorCQkJCSAgICJ1cGRhdGUgZmFpbGVkIik7CisJCX0KKwl9CiB9CiAKIApAQCAtNDIwMCw4ICs0NjIzLDkgQEAKIAkJd3Bhc19wMnBfZGlzYWJsZV9jcm9zc19jb25uZWN0KHdwYV9zKTsKIAllbHNlCiAJCXdwYXNfcDJwX2VuYWJsZV9jcm9zc19jb25uZWN0KHdwYV9zKTsKLQlpZiAoIXdwYV9zLT5hcF9pZmFjZSkKLQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfaWRsZV90aW1lb3V0LCB3cGFfcywgTlVMTCk7CisJaWYgKCF3cGFfcy0+YXBfaWZhY2UgJiYKKwkgICAgZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfaWRsZV90aW1lb3V0LCB3cGFfcywgTlVMTCkgPiAwKQorCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogQ2FuY2VsbGVkIFAyUCBncm91cCBpZGxlIHRpbWVvdXQiKTsKIH0KIAogCkBAIC00MjExLDEwICs0NjM1LDcgQEAKIAlpZiAoIXdwYV9zLT5hcF9pZmFjZSAmJgogCSAgICAhZWxvb3BfaXNfdGltZW91dF9yZWdpc3RlcmVkKHdwYXNfcDJwX2dyb3VwX2lkbGVfdGltZW91dCwKIAkJCQkJIHdwYV9zLCBOVUxMKSkKLQl7Ci0JCXdwYV9wcmludGYoTVNHX0RFQlVHLCJDYWxsaW5nIHNldCBncm91cGxlIGlkbGVfdGltZW91dCBmcm9tIG5vdGlmX2Rpc2Nvbm5lY3RlZCIpOwogCQl3cGFzX3AycF9zZXRfZ3JvdXBfaWRsZV90aW1lb3V0KHdwYV9zKTsKLQl9CiB9CiAKIApAQCAtNDMxNiw2ICs0NzM3LDcgQEAKIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFVuYXV0aG9yaXplIHBlbmRpbmcgR08gTmVnIHBlZXIgIgogCQkJICAgTUFDU1RSLCBNQUMyU1RSKHBlZXIpKTsKIAkJcDJwX3VuYXV0aG9yaXplKGdsb2JhbC0+cDJwLCBwZWVyKTsKKwkJZm91bmQgPSAxOwogCX0KIAogCXdwYXNfcDJwX3N0b3BfZmluZCh3cGFfcyk7CkBAIC00MzMxLDcgKzQ3NTMsNyBAQAogCQkJZm91bmQgPSAxOwogCQkJZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsCiAJCQkJCSAgICAgd3BhX3MtPnBhcmVudCwgTlVMTCk7Ci0JCQl3cGFzX3AycF9ncm91cF9kZWxldGUod3BhX3MpOworCQkJd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHdwYV9zLCAwKTsKIAkJCWJyZWFrOwogCQl9CiAJfQpAQCAtNDM1Myw3ICs0Nzc1LDcgQEAKIAl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogUmVtb3ZlIGdyb3VwIGR1ZSB0byBkcml2ZXIgcmVzb3VyY2Ugbm90ICIKIAkJICAgImJlaW5nIGF2YWlsYWJsZSBhbnltb3JlIik7CiAJd3BhX3MtPnJlbW92YWxfcmVhc29uID0gUDJQX0dST1VQX1JFTU9WQUxfVU5BVkFJTEFCTEU7Ci0Jd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKHdwYV9zKTsKKwl3cGFzX3AycF9ncm91cF9kZWxldGUod3BhX3MsIDApOwogfQogCiAKQEAgLTQ0MDAsNyArNDgyMiw3IEBACiAJCXJldHVybiAtMTsKIAogCXdwYV9zLT5yZW1vdmFsX3JlYXNvbiA9IFAyUF9HUk9VUF9SRU1PVkFMX1JFUVVFU1RFRDsKLQl3cGFzX3AycF9ncm91cF9kZWxldGUod3BhX3MpOworCXdwYXNfcDJwX2dyb3VwX2RlbGV0ZSh3cGFfcywgMCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTQ0MTcsMjAgKzQ4MzksMjIgQEAKIAogdm9pZCB3cGFzX3AycF9uZXR3b3JrX3JlbW92ZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCSAgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKLQogewogCWlmICh3cGFfcy0+cDJwX2luX3Byb3Zpc2lvbmluZyAmJiBzc2lkLT5wMnBfZ3JvdXAgJiYKIAkgICAgZWxvb3BfY2FuY2VsX3RpbWVvdXQod3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsCiAJCQkJIHdwYV9zLT5wYXJlbnQsIE5VTEwpID4gMCkgeworCQkvKioKKwkJICogUmVtb3ZlIHRoZSBuZXR3b3JrIGJ5IHNjaGVkdWxpbmcgdGhlIGdyb3VwIGZvcm1hdGlvbgorCQkgKiB0aW1lb3V0IHRvIGhhcHBlbiBpbW1lZGlhdGVseS4gVGhlIHRlYXJkb3duIGNvZGUKKwkJICogbmVlZHMgdG8gYmUgc2NoZWR1bGVkIHRvIHJ1biBhc3luY2ggbGF0ZXIgc28gdGhhdCB3ZQorCQkgKiBkb24ndCBkZWxldGUgZGF0YSBmcm9tIHVuZGVyIG91cnNlbHZlcyB1bmV4cGVjdGVkbHkuCisJCSAqIENhbGxpbmcgd3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQgZGlyZWN0bHkKKwkJICogY2F1c2VzIGEgc2VyaWVzIG9mIGNyYXNoZXMgaW4gV1BTIGZhaWx1cmUgc2NlbmFyaW9zLgorCQkgKi8KIAkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IENhbmNlbGVkIGdyb3VwIGZvcm1hdGlvbiBkdWUgdG8gIgogCQkJICAgIlAyUCBncm91cCBuZXR3b3JrIGdldHRpbmcgcmVtb3ZlZCIpOwotI2lmZGVmIEFORFJPSURfUDJQCi0JCS8qIEdpdmUgdGltZSBmb3IgYW55IFBlbmRpbmcgV1BTIEZyYW1lIGV4Y2hhbmdlICovCi0JCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoNSwgMCwgd3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsCi0JCQl3cGFfcy0+cGFyZW50LCBOVUxMKTsKLSNlbHNlCi0JCXdwYXNfcDJwX2dyb3VwX2Zvcm1hdGlvbl90aW1lb3V0KHdwYV9zLT5wYXJlbnQsIE5VTEwpOwotI2VuZGlmCisJCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQoMCwgMCwgd3Bhc19wMnBfZ3JvdXBfZm9ybWF0aW9uX3RpbWVvdXQsCisJCQkJICAgICAgIHdwYV9zLT5wYXJlbnQsIE5VTEwpOwogCX0KIH0KIApAQCAtNDQ3Myw2ICs0ODk3LDQzIEBACiAJd3Bhc19wMnBfYWRkX3BlcnNpc3RlbnRfZ3JvdXBfY2xpZW50KHdwYV9zLCBhZGRyKTsKIH0KIAorCitzdGF0aWMgdm9pZCB3cGFzX3AycF9mYWxsYmFja190b19nb19uZWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJaW50IGdyb3VwX2FkZGVkKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqZ3JvdXAgPSB3cGFfczsKKwllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFzX3AycF9wZF9iZWZvcmVfam9pbl90aW1lb3V0LCB3cGFfcywgTlVMTCk7CisJaWYgKHdwYV9zLT5nbG9iYWwtPnAycF9ncm91cF9mb3JtYXRpb24pCisJCWdyb3VwID0gd3BhX3MtPmdsb2JhbC0+cDJwX2dyb3VwX2Zvcm1hdGlvbjsKKwl3cGFfcyA9IHdwYV9zLT5wYXJlbnQ7CisJb2ZmY2hhbm5lbF9zZW5kX2FjdGlvbl9kb25lKHdwYV9zKTsKKwlpZiAoZ3JvdXBfYWRkZWQpCisJCXdwYXNfcDJwX2dyb3VwX2RlbGV0ZShncm91cCwgMSk7CisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBGYWxsIGJhY2sgdG8gR08gTmVnb3RpYXRpb24iKTsKKwl3cGFzX3AycF9jb25uZWN0KHdwYV9zLCB3cGFfcy0+cGVuZGluZ19qb2luX2Rldl9hZGRyLCB3cGFfcy0+cDJwX3BpbiwKKwkJCSB3cGFfcy0+cDJwX3dwc19tZXRob2QsIHdwYV9zLT5wMnBfcGVyc2lzdGVudF9ncm91cCwgMCwKKwkJCSAwLCAwLCB3cGFfcy0+cDJwX2dvX2ludGVudCwgd3BhX3MtPnAycF9jb25uZWN0X2ZyZXEsCisJCQkgd3BhX3MtPnAycF9wZXJzaXN0ZW50X2lkLAorCQkJIHdwYV9zLT5wMnBfcGRfYmVmb3JlX2dvX25lZyk7Cit9CisKKworaW50IHdwYXNfcDJwX3NjYW5fbm9fZ29fc2VlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWlmICghd3BhX3MtPnAycF9mYWxsYmFja190b19nb19uZWcgfHwKKwkgICAgd3BhX3MtPnAycF9pbl9wcm92aXNpb25pbmcgPD0gNSkKKwkJcmV0dXJuIDA7CisKKwlpZiAod3Bhc19wMnBfcGVlcl9nbyh3cGFfcywgd3BhX3MtPnBlbmRpbmdfam9pbl9kZXZfYWRkcikgPiAwKQorCQlyZXR1cm4gMDsgLyogcGVlciBvcGVyYXRpbmcgYXMgYSBHTyAqLworCisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBHTyBub3QgZm91bmQgZm9yIHAycF9jb25uZWN0LWF1dG8gLSAiCisJCSJmYWxsYmFjayB0byBHTyBOZWdvdGlhdGlvbiIpOworCXdwYXNfcDJwX2ZhbGxiYWNrX3RvX2dvX25lZyh3cGFfcywgMSk7CisKKwlyZXR1cm4gMTsKK30KKwogI2lmZGVmIEFORFJPSURfUDJQCiBpbnQgd3Bhc19wMnBfaGFuZGxlX2ZyZXF1ZW5jeV9jb25mbGljdHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGZyZXEpCiB7CkBAIC00NTAzLDcgKzQ5NjQsNyBAQAogCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBSZW1vdmluZyBQMlAgY29ubmVjdGlvbiBkdWUgdG8gU2luZ2xlIGNoYW5uZWwiCiAJCQkJCQkiY29uY3VycmVudCBtb2RlIGZyZXF1ZW5jeSBjb25mbGljdCIpOwogCQkJCWlmYWNlLT5yZW1vdmFsX3JlYXNvbiA9IFAyUF9HUk9VUF9SRU1PVkFMX0ZSRVFfQ09ORkxJQ1Q7Ci0JCQkJd3Bhc19wMnBfZ3JvdXBfZGVsZXRlKGlmYWNlKTsKKwkJCQl3cGFzX3AycF9ncm91cF9kZWxldGUoaWZhY2UsIDApOwogCQkJfSBlbHNlIHsKIAkJCQkvKiBFeGlzdGluZyBjb25uZWN0aW9uIGhhcyB0aGUgcHJpb3JpdHkuIERpc2FibGUgdGhlIG5ld2x5CiAgICAgICAgICAgICAgICAgICogc2VsZWN0ZWQgbmV0d29yayBhbmQgbGV0IHRoZSBhcHBsaWNhdGlvbiBrbm93IGFib3V0IGl0LgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvcDJwX3N1cHBsaWNhbnQuaCBiL3dwYV9zdXBwbGljYW50L3AycF9zdXBwbGljYW50LmgKaW5kZXggMDVjNjQ4YS4uMjRmYjgxZSAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvcDJwX3N1cHBsaWNhbnQuaAorKysgYi93cGFfc3VwcGxpY2FudC9wMnBfc3VwcGxpY2FudC5oCkBAIC0xOSw4ICsxOSw5IEBACiB2b2lkIHdwYXNfcDJwX2RlaW5pdF9nbG9iYWwoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCk7CiBpbnQgd3Bhc19wMnBfY29ubmVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqcGVlcl9hZGRyLAogCQkgICAgIGNvbnN0IGNoYXIgKnBpbiwgZW51bSBwMnBfd3BzX21ldGhvZCB3cHNfbWV0aG9kLAotCQkgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwLCBpbnQgam9pbiwgaW50IGF1dGgsIGludCBnb19pbnRlbnQsCi0JCSAgICAgaW50IGZyZXEpOworCQkgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwLCBpbnQgYXV0b19qb2luLCBpbnQgam9pbiwKKwkJICAgICBpbnQgYXV0aCwgaW50IGdvX2ludGVudCwgaW50IGZyZXEsIGludCBwZXJzaXN0ZW50X2lkLAorCQkgICAgIGludCBwZCk7CiB2b2lkIHdwYXNfcDJwX3JlbWFpbl9vbl9jaGFubmVsX2NiKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCiAJCQkJICAgdW5zaWduZWQgaW50IGZyZXEsIHVuc2lnbmVkIGludCBkdXJhdGlvbik7CiB2b2lkIHdwYXNfcDJwX2NhbmNlbF9yZW1haW5fb25fY2hhbm5lbF9jYihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLApAQCAtMzYsMTIgKzM3LDE3IEBACiAJCQkJICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsIGludCBhZGRyX2FsbG9jYXRlZCwKIAkJCQkgIGludCBmcmVxKTsKIHN0cnVjdCBwMnBfZ3JvdXAgKiB3cGFzX3AycF9ncm91cF9pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCi0JCQkJICAgICAgIGludCBwZXJzaXN0ZW50X2dyb3VwLAotCQkJCSAgICAgICBpbnQgZ3JvdXBfZm9ybWF0aW9uKTsKKwkJCQkgICAgICAgc3RydWN0IHdwYV9zc2lkICpzc2lkKTsKIHZvaWQgd3Bhc19wMnBfd3BzX3N1Y2Nlc3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKnBlZXJfYWRkciwKIAkJCSAgaW50IHJlZ2lzdHJhcik7CitlbnVtIHdwYXNfcDJwX3Byb3ZfZGlzY191c2UgeworCVdQQVNfUDJQX1BEX0ZPUl9HT19ORUcsCisJV1BBU19QMlBfUERfRk9SX0pPSU4sCisJV1BBU19QMlBfUERfQVVUTworfTsKIGludCB3cGFzX3AycF9wcm92X2Rpc2Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKnBlZXJfYWRkciwKLQkJICAgICAgIGNvbnN0IGNoYXIgKmNvbmZpZ19tZXRob2QsIGludCBqb2luKTsKKwkJICAgICAgIGNvbnN0IGNoYXIgKmNvbmZpZ19tZXRob2QsCisJCSAgICAgICBlbnVtIHdwYXNfcDJwX3Byb3ZfZGlzY191c2UgdXNlKTsKIHZvaWQgd3Bhc19zZW5kX2FjdGlvbl90eF9zdGF0dXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmRzdCwKIAkJCQljb25zdCB1OCAqZGF0YSwgc2l6ZV90IGRhdGFfbGVuLAogCQkJCWVudW0gcDJwX3NlbmRfYWN0aW9uX3Jlc3VsdCByZXN1bHQpOwpAQCAtNTgsNyArNjQsOCBAQAogCQkJICB1OCAqYnVmLCBzaXplX3QgbGVuLCBpbnQgcDJwX2dyb3VwKTsKIGludCB3cGFzX3AycF9wcm9iZV9yZXFfcngoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmFkZHIsCiAJCQkgIGNvbnN0IHU4ICpkc3QsIGNvbnN0IHU4ICpic3NpZCwKLQkJCSAgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuKTsKKwkJCSAgY29uc3QgdTggKmllLCBzaXplX3QgaWVfbGVuLAorCQkJICBpbnQgc3NpX3NpZ25hbCk7CiB2b2lkIHdwYXNfcDJwX3J4X2FjdGlvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqZGEsCiAJCQljb25zdCB1OCAqc2EsIGNvbnN0IHU4ICpic3NpZCwKIAkJCXU4IGNhdGVnb3J5LCBjb25zdCB1OCAqZGF0YSwgc2l6ZV90IGxlbiwgaW50IGZyZXEpOwpAQCAtMTA4LDkgKzExNSwxMSBAQAogaW50IHdwYXNfcDJwX2V4dF9saXN0ZW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgdW5zaWduZWQgaW50IHBlcmlvZCwKIAkJCXVuc2lnbmVkIGludCBpbnRlcnZhbCk7CiB2b2lkIHdwYXNfcDJwX2RlYXV0aF9ub3RpZihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQsCi0JCQkgICB1MTYgcmVhc29uX2NvZGUsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbik7CisJCQkgICB1MTYgcmVhc29uX2NvZGUsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwKKwkJCSAgIGludCBsb2NhbGx5X2dlbmVyYXRlZCk7CiB2b2lkIHdwYXNfcDJwX2Rpc2Fzc29jX25vdGlmKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpic3NpZCwKLQkJCSAgICAgdTE2IHJlYXNvbl9jb2RlLCBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pOworCQkJICAgICB1MTYgcmVhc29uX2NvZGUsIGNvbnN0IHU4ICppZSwgc2l6ZV90IGllX2xlbiwKKwkJCSAgICAgaW50IGxvY2FsbHlfZ2VuZXJhdGVkKTsKIHZvaWQgd3Bhc19wMnBfdXBkYXRlX2NvbmZpZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIGludCB3cGFzX3AycF9zZXRfbm9hKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIHU4IGNvdW50LCBpbnQgc3RhcnQsCiAJCSAgICAgaW50IGR1cmF0aW9uKTsKQEAgLTEzNSw1ICsxNDQsNiBAQAogCQkJCQkgIHNpemVfdCBzc2lkX2xlbik7CiB2b2lkIHdwYXNfcDJwX25vdGlmeV9hcF9zdGFfYXV0aG9yaXplZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICAgICBjb25zdCB1OCAqYWRkcik7CitpbnQgd3Bhc19wMnBfc2Nhbl9ub19nb19zZWVuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogCiAjZW5kaWYgLyogUDJQX1NVUFBMSUNBTlRfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvc2Nhbi5jIGIvd3BhX3N1cHBsaWNhbnQvc2Nhbi5jCmluZGV4IDVhZWU3ZmYuLjhkZjIxZDkgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3NjYW4uYworKysgYi93cGFfc3VwcGxpY2FudC9zY2FuLmMKQEAgLTE3LDYgKzE3LDcgQEAKICNpbmNsdWRlICJ3cHNfc3VwcGxpY2FudC5oIgogI2luY2x1ZGUgInAycF9zdXBwbGljYW50LmgiCiAjaW5jbHVkZSAicDJwL3AycC5oIgorI2luY2x1ZGUgImhzMjBfc3VwcGxpY2FudC5oIgogI2luY2x1ZGUgIm5vdGlmeS5oIgogI2luY2x1ZGUgImJzcy5oIgogI2luY2x1ZGUgInNjYW4uaCIKQEAgLTc5LDEyICs4MCwxMiBAQAogI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KIAogCi1pbnQgd3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3JrcyhzdHJ1Y3Qgd3BhX2NvbmZpZyAqY29uZikKK2ludCB3cGFfc3VwcGxpY2FudF9lbmFibGVkX25ldHdvcmtzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7Ci0Jc3RydWN0IHdwYV9zc2lkICpzc2lkID0gY29uZi0+c3NpZDsKKwlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKIAlpbnQgY291bnQgPSAwOwogCXdoaWxlIChzc2lkKSB7Ci0JCWlmICghc3NpZC0+ZGlzYWJsZWQpCisJCWlmICghd3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSkKIAkJCWNvdW50Kys7CiAJCXNzaWQgPSBzc2lkLT5uZXh0OwogCX0KQEAgLTk2LDcgKzk3LDcgQEAKIAkJCQkgICAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCkKIHsKIAl3aGlsZSAoc3NpZCkgewotCQlpZiAoIXNzaWQtPmRpc2FibGVkKQorCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkpCiAJCQlicmVhazsKIAkJc3NpZCA9IHNzaWQtPm5leHQ7CiAJfQpAQCAtNDA1LDcgKzQwNiw5IEBACiAKIAlpZiAod3BzKSB7CiAJCXN0cnVjdCB3cGFidWYgKndwc19pZTsKLQkJd3BzX2llID0gd3BzX2J1aWxkX3Byb2JlX3JlcV9pZSh3cHMgPT0gMiwgJndwYV9zLT53cHMtPmRldiwKKwkJd3BzX2llID0gd3BzX2J1aWxkX3Byb2JlX3JlcV9pZSh3cHMgPT0gMiA/IERFVl9QV19QVVNIQlVUVE9OIDoKKwkJCQkJCURFVl9QV19ERUZBVUxULAorCQkJCQkJJndwYV9zLT53cHMtPmRldiwKIAkJCQkJCXdwYV9zLT53cHMtPnV1aWQsIHJlcV90eXBlLAogCQkJCQkJMCwgTlVMTCk7CiAJCWlmICh3cHNfaWUpIHsKQEAgLTQzNCw4ICs0MzcsOSBAQAogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBlbG9vcF9jdHg7CiAJc3RydWN0IHdwYV9zc2lkICpzc2lkOwogCWludCBzY2FuX3JlcSA9IDAsIHJldDsKLQlzdHJ1Y3Qgd3BhYnVmICpleHRyYV9pZTsKKwlzdHJ1Y3Qgd3BhYnVmICpleHRyYV9pZSA9IE5VTEw7CiAJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgcGFyYW1zOworCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zICpzY2FuX3BhcmFtczsKIAlzaXplX3QgbWF4X3NzaWRzOwogCWVudW0gd3BhX3N0YXRlcyBwcmV2X3N0YXRlOwogCkBAIC00NDksNyArNDUzLDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmICghd3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3Jrcyh3cGFfcy0+Y29uZikgJiYKKwlpZiAoIXdwYV9zdXBwbGljYW50X2VuYWJsZWRfbmV0d29ya3Mod3BhX3MpICYmCiAJICAgICF3cGFfcy0+c2Nhbl9yZXEpIHsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiTm8gZW5hYmxlZCBuZXR3b3JrcyAtIGRvIG5vdCBzY2FuIik7CiAJCXdwYV9zdXBwbGljYW50X3NldF9zdGF0ZSh3cGFfcywgV1BBX0lOQUNUSVZFKTsKQEAgLTUwMSw2ICs1MDUsMTQgQEAKIAkgICAgd3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfSU5BQ1RJVkUpCiAJCXdwYV9zdXBwbGljYW50X3NldF9zdGF0ZSh3cGFfcywgV1BBX1NDQU5OSU5HKTsKIAorCS8qCisJICogSWYgYXV0b3NjYW4gaGFzIHNldCBpdHMgb3duIHNjYW5uaW5nIHBhcmFtZXRlcnMKKwkgKi8KKwlpZiAod3BhX3MtPmF1dG9zY2FuX3BhcmFtcyAhPSBOVUxMKSB7CisJCXNjYW5fcGFyYW1zID0gd3BhX3MtPmF1dG9zY2FuX3BhcmFtczsKKwkJZ290byBzY2FuOworCX0KKwogCWlmIChzY2FuX3JlcSAhPSAyICYmIHdwYV9zLT5jb25uZWN0X3dpdGhvdXRfc2NhbikgewogCQlmb3IgKHNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsgc3NpZDsgc3NpZCA9IHNzaWQtPm5leHQpIHsKIAkJCWlmIChzc2lkID09IHdwYV9zLT5jb25uZWN0X3dpdGhvdXRfc2NhbikKQEAgLTUxNSw2ICs1MjcsMTggQEAKIAkJfQogCX0KIAorI2lmZGVmIENPTkZJR19QMlAKKwlpZiAoKHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nIHx8IHdwYV9zLT5zaG93X2dyb3VwX3N0YXJ0ZWQpICYmCisJICAgIHdwYV9zLT5nb19wYXJhbXMpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IFVzZSBzcGVjaWZpYyBTU0lEIGZvciBzY2FuIGR1cmluZyAiCisJCQkgICAiUDJQIGdyb3VwIGZvcm1hdGlvbiIpOworCQlwYXJhbXMuc3NpZHNbMF0uc3NpZCA9IHdwYV9zLT5nb19wYXJhbXMtPnNzaWQ7CisJCXBhcmFtcy5zc2lkc1swXS5zc2lkX2xlbiA9IHdwYV9zLT5nb19wYXJhbXMtPnNzaWRfbGVuOworCQlwYXJhbXMubnVtX3NzaWRzID0gMTsKKwkJZ290byBzc2lkX2xpc3Rfc2V0OworCX0KKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCisKIAkvKiBGaW5kIHRoZSBzdGFydGluZyBwb2ludCBmcm9tIHdoaWNoIHRvIGNvbnRpbnVlIHNjYW5uaW5nICovCiAJc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwogCWlmICh3cGFfcy0+cHJldl9zY2FuX3NzaWQgIT0gV0lMRENBUkRfU1NJRF9TQ0FOKSB7CkBAIC01NDYsNyArNTcwLDggQEAKIAkJaWYgKHNzaWQgPT0gTlVMTCAmJiBtYXhfc3NpZHMgPiAxKQogCQkJc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwogCQl3aGlsZSAoc3NpZCkgewotCQkJaWYgKCFzc2lkLT5kaXNhYmxlZCAmJiBzc2lkLT5zY2FuX3NzaWQpIHsKKwkJCWlmICghd3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSAmJgorCQkJICAgIHNzaWQtPnNjYW5fc3NpZCkgewogCQkJCXdwYV9oZXhkdW1wX2FzY2lpKE1TR19ERUJVRywgIlNjYW4gU1NJRCIsCiAJCQkJCQkgIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKIAkJCQlwYXJhbXMuc3NpZHNbcGFyYW1zLm51bV9zc2lkc10uc3NpZCA9CkBAIC01NjYsNyArNTkxLDcgQEAKIAkJfQogCiAJCWZvciAodHNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsgdHNzaWQ7IHRzc2lkID0gdHNzaWQtPm5leHQpIHsKLQkJCWlmICh0c3NpZC0+ZGlzYWJsZWQpCisJCQlpZiAod3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCB0c3NpZCkpCiAJCQkJY29udGludWU7CiAJCQlpZiAoKHBhcmFtcy5mcmVxcyB8fCAhZnJlcXNfc2V0KSAmJiB0c3NpZC0+c2Nhbl9mcmVxKSB7CiAJCQkJaW50X2FycmF5X2NvbmNhdCgmcGFyYW1zLmZyZXFzLApAQCAtNjEyLDEwICs2MzcsMTggQEAKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiU3RhcnRpbmcgQVAgc2NhbiBmb3Igd2lsZGNhcmQgIgogCQkJIlNTSUQiKTsKIAl9CisjaWZkZWYgQ09ORklHX1AyUAorc3NpZF9saXN0X3NldDoKKyNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKIAl3cGFfc3VwcGxpY2FudF9vcHRpbWl6ZV9mcmVxcyh3cGFfcywgJnBhcmFtcyk7CiAJZXh0cmFfaWUgPSB3cGFfc3VwcGxpY2FudF9leHRyYV9pZXMod3BhX3MsICZwYXJhbXMpOwogCisjaWZkZWYgQ09ORklHX0hTMjAKKwlpZiAod3BhX3MtPmNvbmYtPmhzMjAgJiYgd3BhYnVmX3Jlc2l6ZSgmZXh0cmFfaWUsIDYpID09IDApCisJCXdwYXNfaHMyMF9hZGRfaW5kaWNhdGlvbihleHRyYV9pZSk7CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogCWlmIChwYXJhbXMuZnJlcXMgPT0gTlVMTCAmJiB3cGFfcy0+bmV4dF9zY2FuX2ZyZXFzKSB7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIk9wdGltaXplIHNjYW4gYmFzZWQgb24gcHJldmlvdXNseSAiCiAJCQkiZ2VuZXJhdGVkIGZyZXF1ZW5jeSBsaXN0Iik7CkBAIC02MzIsNyArNjY1LDggQEAKIAl9CiAKICNpZmRlZiBDT05GSUdfUDJQCi0JaWYgKHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nKSB7CisJaWYgKHdwYV9zLT5wMnBfaW5fcHJvdmlzaW9uaW5nIHx8CisJICAgICh3cGFfcy0+c2hvd19ncm91cF9zdGFydGVkICYmIHdwYV9zLT5nb19wYXJhbXMpKSB7CiAJCS8qCiAJCSAqIFRoZSBpbnRlcmZhY2UgbWF5IG5vdCB5ZXQgYmUgaW4gUDJQIG1vZGUsIHNvIHdlIGhhdmUgdG8KIAkJICogZXhwbGljaXRseSByZXF1ZXN0IFAyUCBwcm9iZSB0byBkaXNhYmxlIENDSyByYXRlcy4KQEAgLTY0MSw3ICs2NzUsMTAgQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX1AyUCAqLwogCi0JcmV0ID0gd3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCAmcGFyYW1zKTsKKwlzY2FuX3BhcmFtcyA9ICZwYXJhbXM7CisKK3NjYW46CisJcmV0ID0gd3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCBzY2FuX3BhcmFtcyk7CiAKIAl3cGFidWZfZnJlZShleHRyYV9pZSk7CiAJb3NfZnJlZShwYXJhbXMuZnJlcXMpOwpAQCAtNjc5LDcgKzcxNiw4IEBACiAJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwogCiAJCXdoaWxlIChzc2lkKSB7Ci0JCQlpZiAoIXNzaWQtPmRpc2FibGVkICYmIHNzaWQtPnNjYW5fc3NpZCkKKwkJCWlmICghd3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSAmJgorCQkJICAgIHNzaWQtPnNjYW5fc3NpZCkKIAkJCQlicmVhazsKIAkJCXNzaWQgPSBzc2lkLT5uZXh0OwogCQl9CkBAIC03MzAsOCArNzY4LDkgQEAKIGludCB3cGFfc3VwcGxpY2FudF9yZXFfc2NoZWRfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCXN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fcGFyYW1zIHBhcmFtczsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqc2Nhbl9wYXJhbXM7CiAJZW51bSB3cGFfc3RhdGVzIHByZXZfc3RhdGU7Ci0Jc3RydWN0IHdwYV9zc2lkICpzc2lkOworCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IE5VTEw7CiAJc3RydWN0IHdwYWJ1ZiAqd3BzX2llID0gTlVMTDsKIAlpbnQgcmV0OwogCXVuc2lnbmVkIGludCBtYXhfc2NoZWRfc2Nhbl9zc2lkczsKQEAgLTc0NSw3ICs3ODQsNyBAQAogCQltYXhfc2NoZWRfc2Nhbl9zc2lkcyA9IFdQQVNfTUFYX1NDQU5fU1NJRFM7CiAJZWxzZQogCQltYXhfc2NoZWRfc2Nhbl9zc2lkcyA9IHdwYV9zLT5tYXhfc2NoZWRfc2Nhbl9zc2lkczsKLQlpZiAobWF4X3NjaGVkX3NjYW5fc3NpZHMgPCAxKQorCWlmIChtYXhfc2NoZWRfc2Nhbl9zc2lkcyA8IDEgfHwgd3BhX3MtPmNvbmYtPmRpc2FibGVfc2Nhbl9vZmZsb2FkKQogCQlyZXR1cm4gLTE7CiAKIAlpZiAod3BhX3MtPnNjaGVkX3NjYW5uaW5nKSB7CkBAIC03NTUsMTEgKzc5NCwyNyBAQAogCiAJbmVlZF9zc2lkcyA9IDA7CiAJZm9yIChzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7IHNzaWQ7IHNzaWQgPSBzc2lkLT5uZXh0KSB7Ci0JCWlmICghc3NpZC0+ZGlzYWJsZWQgJiYgIXNzaWQtPnNjYW5fc3NpZCkgeworCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkgJiYgIXNzaWQtPnNjYW5fc3NpZCkgewogCQkJLyogVXNlIHdpbGRjYXJkIFNTSUQgdG8gZmluZCB0aGlzIG5ldHdvcmsgKi8KIAkJCXdpbGRjYXJkID0gMTsKLQkJfSBlbHNlIGlmICghc3NpZC0+ZGlzYWJsZWQgJiYgc3NpZC0+c3NpZF9sZW4pCisJCX0gZWxzZSBpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkgJiYKKwkJCSAgIHNzaWQtPnNzaWRfbGVuKQogCQkJbmVlZF9zc2lkcysrOworCisjaWZkZWYgQ09ORklHX1dQUworCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkgJiYKKwkJICAgIHNzaWQtPmtleV9tZ210ID09IFdQQV9LRVlfTUdNVF9XUFMpIHsKKwkJCS8qCisJCQkgKiBOb3JtYWwgc2NhbiBpcyBtb3JlIHJlbGlhYmxlIGFuZCBmYXN0ZXIgZm9yIFdQUworCQkJICogb3BlcmF0aW9ucyBhbmQgc2luY2UgdGhlc2UgYXJlIGZvciBzaG9ydCBwZXJpb2RzIG9mCisJCQkgKiB0aW1lLCB0aGUgYmVuZWZpdCBvZiB0cnlpbmcgdG8gdXNlIHNjaGVkX3NjYW4gd291bGQKKwkJCSAqIGJlIGxpbWl0ZWQuCisJCQkgKi8KKwkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIlVzZSBub3JtYWwgc2NhbiBpbnN0ZWFkIG9mICIKKwkJCQkic2NoZWRfc2NhbiBmb3IgV1BTIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKyNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAJfQogCWlmICh3aWxkY2FyZCkKIAkJbmVlZF9zc2lkcysrOwpAQCAtNzkzLDYgKzg0OCwxMSBAQAogCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9TQ0FOTklORyk7CiAjZW5kaWYKIAorCWlmICh3cGFfcy0+YXV0b3NjYW5fcGFyYW1zICE9IE5VTEwpIHsKKwkJc2Nhbl9wYXJhbXMgPSB3cGFfcy0+YXV0b3NjYW5fcGFyYW1zOworCQlnb3RvIHNjYW47CisJfQorCiAJLyogRmluZCB0aGUgc3RhcnRpbmcgcG9pbnQgZnJvbSB3aGljaCB0byBjb250aW51ZSBzY2FubmluZyAqLwogCXNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKIAlpZiAod3BhX3MtPnByZXZfc2NoZWRfc3NpZCkgewpAQCAtODA4LDcgKzg2OCw4IEBACiAJaWYgKCFzc2lkIHx8ICF3cGFfcy0+cHJldl9zY2hlZF9zc2lkKSB7CiAJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkJlZ2lubmluZyBvZiBTU0lEIGxpc3QiKTsKIAotCQl3cGFfcy0+c2NoZWRfc2Nhbl9pbnRlcnZhbCA9IDEwOworCQlpZiAod3BhX3MtPnNjaGVkX3NjYW5faW50ZXJ2YWwgPT0gMCkKKwkJCXdwYV9zLT5zY2hlZF9zY2FuX2ludGVydmFsID0gMTA7CiAJCXdwYV9zLT5zY2hlZF9zY2FuX3RpbWVvdXQgPSBtYXhfc2NoZWRfc2Nhbl9zc2lkcyAqIDI7CiAJCXdwYV9zLT5maXJzdF9zY2hlZF9zY2FuID0gMTsKIAkJc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwpAQCAtODIxLDcgKzg4Miw3IEBACiAJfQogCiAJd2hpbGUgKHNzaWQpIHsKLQkJaWYgKHNzaWQtPmRpc2FibGVkKQorCQlpZiAod3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSkKIAkJCWdvdG8gbmV4dDsKIAogCQlpZiAocGFyYW1zLm51bV9maWx0ZXJfc3NpZHMgPCB3cGFfcy0+bWF4X21hdGNoX3NldHMgJiYKQEAgLTg1NSw2ICs5MTYsMTEgQEAKIAkJCXBhcmFtcy5udW1fc3NpZHMrKzsKIAkJCWlmIChwYXJhbXMubnVtX3NzaWRzID49IG1heF9zY2hlZF9zY2FuX3NzaWRzKSB7CiAJCQkJd3BhX3MtPnByZXZfc2NoZWRfc3NpZCA9IHNzaWQ7CisJCQkJZG8geworCQkJCQlzc2lkID0gc3NpZC0+bmV4dDsKKwkJCQl9IHdoaWxlIChzc2lkICYmCisJCQkJCSAod3Bhc19uZXR3b3JrX2Rpc2FibGVkKHdwYV9zLCBzc2lkKSB8fAorCQkJCQkgICFzc2lkLT5zY2FuX3NzaWQpKTsKIAkJCQlicmVhazsKIAkJCX0KIAkJfQpAQCAtODcyLDE3ICs5MzgsMjAgQEAKIAlpZiAod3BhX3MtPndwcykKIAkJd3BzX2llID0gd3BhX3N1cHBsaWNhbnRfZXh0cmFfaWVzKHdwYV9zLCAmcGFyYW1zKTsKIAorCXNjYW5fcGFyYW1zID0gJnBhcmFtczsKKworc2NhbjoKIAlpZiAoc3NpZCB8fCAhd3BhX3MtPmZpcnN0X3NjaGVkX3NjYW4pIHsKIAkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAotCQkJIlN0YXJ0aW5nIHNjaGVkIHNjYW46IGludGVydmFsICVkIChubyB0aW1lb3V0KSIsCi0JCQl3cGFfcy0+c2NoZWRfc2Nhbl9pbnRlcnZhbCk7Ci0JfSBlbHNlIHsKLQkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLAogCQkJIlN0YXJ0aW5nIHNjaGVkIHNjYW46IGludGVydmFsICVkIHRpbWVvdXQgJWQiLAogCQkJd3BhX3MtPnNjaGVkX3NjYW5faW50ZXJ2YWwsIHdwYV9zLT5zY2hlZF9zY2FuX3RpbWVvdXQpOworCX0gZWxzZSB7CisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywKKwkJCSJTdGFydGluZyBzY2hlZCBzY2FuOiBpbnRlcnZhbCAlZCAobm8gdGltZW91dCkiLAorCQkJd3BhX3MtPnNjaGVkX3NjYW5faW50ZXJ2YWwpOwogCX0KIAotCXJldCA9IHdwYV9zdXBwbGljYW50X3N0YXJ0X3NjaGVkX3NjYW4od3BhX3MsICZwYXJhbXMsCisJcmV0ID0gd3BhX3N1cHBsaWNhbnRfc3RhcnRfc2NoZWRfc2Nhbih3cGFfcywgc2Nhbl9wYXJhbXMsCiAJCQkJCSAgICAgIHdwYV9zLT5zY2hlZF9zY2FuX2ludGVydmFsKTsKIAl3cGFidWZfZnJlZSh3cHNfaWUpOwogCW9zX2ZyZWUocGFyYW1zLmZpbHRlcl9zc2lkcyk7CkBAIC0xMjIwLDYgKzEyODksNyBAQAogCiAJZm9yIChpID0gMDsgaSA8IHNjYW5fcmVzLT5udW07IGkrKykgewogCQlzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpyID0gc2Nhbl9yZXMtPnJlc1tpXTsKKwkJdTggKnBvczsKIAkJaWYgKChyLT5mbGFncyAmIChXUEFfU0NBTl9MRVZFTF9EQk0gfCBXUEFfU0NBTl9OT0lTRV9JTlZBTElEKSkKIAkJICAgID09IFdQQV9TQ0FOX0xFVkVMX0RCTSkgewogCQkJaW50IHNuciA9IHItPmxldmVsIC0gci0+bm9pc2U7CkBAIC0xMjM0LDExICsxMzA0LDYyIEBACiAJCQkJICAgTUFDMlNUUihyLT5ic3NpZCksIHItPmZyZXEsIHItPnF1YWwsCiAJCQkJICAgci0+bm9pc2UsIHItPmxldmVsLCByLT5mbGFncyk7CiAJCX0KKwkJcG9zID0gKHU4ICopIChyICsgMSk7CisJCWlmIChyLT5pZV9sZW4pCisJCQl3cGFfaGV4ZHVtcChNU0dfRVhDRVNTSVZFLCAiSUVzIiwgcG9zLCByLT5pZV9sZW4pOworCQlwb3MgKz0gci0+aWVfbGVuOworCQlpZiAoci0+YmVhY29uX2llX2xlbikKKwkJCXdwYV9oZXhkdW1wKE1TR19FWENFU1NJVkUsICJCZWFjb24gSUVzIiwKKwkJCQkgICAgcG9zLCByLT5iZWFjb25faWVfbGVuKTsKIAl9CiAjZW5kaWYgLyogQ09ORklHX05PX1NURE9VVF9ERUJVRyAqLwogfQogCiAKK2ludCB3cGFfc3VwcGxpY2FudF9maWx0ZXJfYnNzaWRfbWF0Y2goc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkgICAgICBjb25zdCB1OCAqYnNzaWQpCit7CisJc2l6ZV90IGk7CisKKwlpZiAod3BhX3MtPmJzc2lkX2ZpbHRlciA9PSBOVUxMKQorCQlyZXR1cm4gMTsKKworCWZvciAoaSA9IDA7IGkgPCB3cGFfcy0+YnNzaWRfZmlsdGVyX2NvdW50OyBpKyspIHsKKwkJaWYgKG9zX21lbWNtcCh3cGFfcy0+YnNzaWRfZmlsdGVyICsgaSAqIEVUSF9BTEVOLCBic3NpZCwKKwkJCSAgICAgIEVUSF9BTEVOKSA9PSAwKQorCQkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgZmlsdGVyX3NjYW5fcmVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICAgc3RydWN0IHdwYV9zY2FuX3Jlc3VsdHMgKnJlcykKK3sKKwlzaXplX3QgaSwgajsKKworCWlmICh3cGFfcy0+YnNzaWRfZmlsdGVyID09IE5VTEwpCisJCXJldHVybjsKKworCWZvciAoaSA9IDAsIGogPSAwOyBpIDwgcmVzLT5udW07IGkrKykgeworCQlpZiAod3BhX3N1cHBsaWNhbnRfZmlsdGVyX2Jzc2lkX21hdGNoKHdwYV9zLAorCQkJCQkJICAgICAgcmVzLT5yZXNbaV0tPmJzc2lkKSkgeworCQkJcmVzLT5yZXNbaisrXSA9IHJlcy0+cmVzW2ldOworCQl9IGVsc2UgeworCQkJb3NfZnJlZShyZXMtPnJlc1tpXSk7CisJCQlyZXMtPnJlc1tpXSA9IE5VTEw7CisJCX0KKwl9CisKKwlpZiAocmVzLT5udW0gIT0gaikgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkZpbHRlcmVkIG91dCAlZCBzY2FuIHJlc3VsdHMiLAorCQkJICAgKGludCkgKHJlcy0+bnVtIC0gaikpOworCQlyZXMtPm51bSA9IGo7CisJfQorfQorCisKIC8qKgogICogd3BhX3N1cHBsaWNhbnRfZ2V0X3NjYW5fcmVzdWx0cyAtIEdldCBzY2FuIHJlc3VsdHMKICAqIEB3cGFfczogUG9pbnRlciB0byB3cGFfc3VwcGxpY2FudCBkYXRhCkBAIC0xMjYzLDYgKzEzODQsNyBAQAogCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJGYWlsZWQgdG8gZ2V0IHNjYW4gcmVzdWx0cyIpOwogCQlyZXR1cm4gTlVMTDsKIAl9CisJZmlsdGVyX3NjYW5fcmVzKHdwYV9zLCBzY2FuX3Jlcyk7CiAKICNpZmRlZiBDT05GSUdfV1BTCiAJaWYgKHdwYXNfd3BzX2luX3Byb2dyZXNzKHdwYV9zKSkgewpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvc2Nhbi5oIGIvd3BhX3N1cHBsaWNhbnQvc2Nhbi5oCmluZGV4IGI3OTQxMDUuLmIwZGRmOTcgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3NjYW4uaAorKysgYi93cGFfc3VwcGxpY2FudC9zY2FuLmgKQEAgLTksNyArOSw3IEBACiAjaWZuZGVmIFNDQU5fSAogI2RlZmluZSBTQ0FOX0gKIAotaW50IHdwYV9zdXBwbGljYW50X2VuYWJsZWRfbmV0d29ya3Moc3RydWN0IHdwYV9jb25maWcgKmNvbmYpOworaW50IHdwYV9zdXBwbGljYW50X2VuYWJsZWRfbmV0d29ya3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGludCBzZWMsIGludCB1c2VjKTsKIGludCB3cGFfc3VwcGxpY2FudF9kZWxheWVkX3NjaGVkX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkgICAgICBpbnQgc2VjLCBpbnQgdXNlYyk7CkBAIC0zMiw1ICszMiw3IEBACiAJCQkJCSAgICAgdTMyIHZlbmRvcl90eXBlKTsKIHN0cnVjdCB3cGFidWYgKiB3cGFfc2Nhbl9nZXRfdmVuZG9yX2llX211bHRpX2JlYWNvbigKIAljb25zdCBzdHJ1Y3Qgd3BhX3NjYW5fcmVzICpyZXMsIHUzMiB2ZW5kb3JfdHlwZSk7CitpbnQgd3BhX3N1cHBsaWNhbnRfZmlsdGVyX2Jzc2lkX21hdGNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICAgY29uc3QgdTggKmJzc2lkKTsKIAogI2VuZGlmIC8qIFNDQU5fSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvc21lLmMgYi93cGFfc3VwcGxpY2FudC9zbWUuYwppbmRleCA2OTBmMzk1Li5jNzE4N2U0IDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC9zbWUuYworKysgYi93cGFfc3VwcGxpY2FudC9zbWUuYwpAQCAtMjYsMTIgKzI2LDE0IEBACiAjaW5jbHVkZSAiYnNzLmgiCiAjaW5jbHVkZSAic2Nhbi5oIgogI2luY2x1ZGUgInNtZS5oIgorI2luY2x1ZGUgImhzMjBfc3VwcGxpY2FudC5oIgogCiAjZGVmaW5lIFNNRV9BVVRIX1RJTUVPVVQgNQogI2RlZmluZSBTTUVfQVNTT0NfVElNRU9VVCA1CiAKIHN0YXRpYyB2b2lkIHNtZV9hdXRoX3RpbWVyKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogc3RhdGljIHZvaWQgc21lX2Fzc29jX3RpbWVyKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOworc3RhdGljIHZvaWQgc21lX29ic3Nfc2Nhbl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpOwogI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCiBzdGF0aWMgdm9pZCBzbWVfc3RvcF9zYV9xdWVyeShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKICNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwpAQCAtMjIxLDYgKzIyMywyMSBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKKyNpZmRlZiBDT05GSUdfSFMyMAorCWlmICh3cGFfcy0+Y29uZi0+aHMyMCkgeworCQlzdHJ1Y3Qgd3BhYnVmICpoczIwOworCQloczIwID0gd3BhYnVmX2FsbG9jKDIwKTsKKwkJaWYgKGhzMjApIHsKKwkJCXdwYXNfaHMyMF9hZGRfaW5kaWNhdGlvbihoczIwKTsKKwkJCW9zX21lbWNweSh3cGFfcy0+c21lLmFzc29jX3JlcV9pZSArCisJCQkJICB3cGFfcy0+c21lLmFzc29jX3JlcV9pZV9sZW4sCisJCQkJICB3cGFidWZfaGVhZChoczIwKSwgd3BhYnVmX2xlbihoczIwKSk7CisJCQl3cGFfcy0+c21lLmFzc29jX3JlcV9pZV9sZW4gKz0gd3BhYnVmX2xlbihoczIwKTsKKwkJCXdwYWJ1Zl9mcmVlKGhzMjApOworCQl9CisJfQorI2VuZGlmIC8qIENPTkZJR19IUzIwICovCisKICNpZmRlZiBDT05GSUdfSU5URVJXT1JLSU5HCiAJaWYgKHdwYV9zLT5jb25mLT5pbnRlcndvcmtpbmcpIHsKIAkJdTggKnBvcyA9IHdwYV9zLT5zbWUuYXNzb2NfcmVxX2llOwpAQCAtMzE1LDYgKzMzMiw3IEBACiAJCSAgICB3cGFfcy0+c21lLmF1dGhfYWxnID09IGRhdGEtPmF1dGguYXV0aF90eXBlIHx8CiAJCSAgICB3cGFfcy0+Y3VycmVudF9zc2lkLT5hdXRoX2FsZyA9PSBXUEFfQVVUSF9BTEdfTEVBUCkgewogCQkJd3Bhc19jb25uZWN0aW9uX2ZhaWxlZCh3cGFfcywgd3BhX3MtPnBlbmRpbmdfYnNzaWQpOworCQkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfRElTQ09OTkVDVEVEKTsKIAkJCXJldHVybjsKIAkJfQogCkBAIC0zNzEsNiArMzg5LDggQEAKIAlwYXJhbXMuc3NpZCA9IHdwYV9zLT5zbWUuc3NpZDsKIAlwYXJhbXMuc3NpZF9sZW4gPSB3cGFfcy0+c21lLnNzaWRfbGVuOwogCXBhcmFtcy5mcmVxID0gd3BhX3MtPnNtZS5mcmVxOworCXBhcmFtcy5iZ19zY2FuX3BlcmlvZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQgPworCQl3cGFfcy0+Y3VycmVudF9zc2lkLT5iZ19zY2FuX3BlcmlvZCA6IC0xOwogCXBhcmFtcy53cGFfaWUgPSB3cGFfcy0+c21lLmFzc29jX3JlcV9pZV9sZW4gPwogCQl3cGFfcy0+c21lLmFzc29jX3JlcV9pZSA6IE5VTEw7CiAJcGFyYW1zLndwYV9pZV9sZW4gPSB3cGFfcy0+c21lLmFzc29jX3JlcV9pZV9sZW47CkBAIC00MjksNiArNDQ5LDcgQEAKIAkJd3BhX21zZyh3cGFfcywgTVNHX0lORk8sICJTTUU6IEFzc29jaWF0aW9uIHJlcXVlc3QgdG8gdGhlICIKIAkJCSJkcml2ZXIgZmFpbGVkIik7CiAJCXdwYXNfY29ubmVjdGlvbl9mYWlsZWQod3BhX3MsIHdwYV9zLT5wZW5kaW5nX2Jzc2lkKTsKKwkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfRElTQ09OTkVDVEVEKTsKIAkJb3NfbWVtc2V0KHdwYV9zLT5wZW5kaW5nX2Jzc2lkLCAwLCBFVEhfQUxFTik7CiAJCXJldHVybjsKIAl9CkBAIC02MDQsNiArNjI1LDI2MyBAQAogCiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoc21lX2Fzc29jX3RpbWVyLCB3cGFfcywgTlVMTCk7CiAJZWxvb3BfY2FuY2VsX3RpbWVvdXQoc21lX2F1dGhfdGltZXIsIHdwYV9zLCBOVUxMKTsKKwllbG9vcF9jYW5jZWxfdGltZW91dChzbWVfb2Jzc19zY2FuX3RpbWVvdXQsIHdwYV9zLCBOVUxMKTsKK30KKworCitzdGF0aWMgdm9pZCBzbWVfc2VuZF8yMDQwX2Jzc19jb2V4KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgY29uc3QgdTggKmNoYW5fbGlzdCwgdTggbnVtX2NoYW5uZWxzLAorCQkJCSAgIHU4IG51bV9pbnRvbCkKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExXzIwNDBfYnNzX2NvZXhfaWUgKmJjX2llOworCXN0cnVjdCBpZWVlODAyMTFfMjA0MF9pbnRvbF9jaGFuX3JlcG9ydCAqaWNfcmVwb3J0OworCXN0cnVjdCB3cGFidWYgKmJ1ZjsKKworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU01FOiBTZW5kIDIwLzQwIEJTUyBDb2V4aXN0ZW5jZSB0byAiIE1BQ1NUUiwKKwkJICAgTUFDMlNUUih3cGFfcy0+YnNzaWQpKTsKKworCWJ1ZiA9IHdwYWJ1Zl9hbGxvYygyICsgLyogYWN0aW9uLmNhdGVnb3J5ICsgYWN0aW9uX2NvZGUgKi8KKwkJCSAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExXzIwNDBfYnNzX2NvZXhfaWUpICsKKwkJCSAgIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExXzIwNDBfaW50b2xfY2hhbl9yZXBvcnQpICsKKwkJCSAgIG51bV9jaGFubmVscyk7CisJaWYgKGJ1ZiA9PSBOVUxMKQorCQlyZXR1cm47CisKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9BQ1RJT05fUFVCTElDKTsKKwl3cGFidWZfcHV0X3U4KGJ1ZiwgV0xBTl9QQV8yMF80MF9CU1NfQ09FWCk7CisKKwliY19pZSA9IHdwYWJ1Zl9wdXQoYnVmLCBzaXplb2YoKmJjX2llKSk7CisJYmNfaWUtPmVsZW1lbnRfaWQgPSBXTEFOX0VJRF8yMF80MF9CU1NfQ09FWElTVEVOQ0U7CisJYmNfaWUtPmxlbmd0aCA9IDE7CisJaWYgKG51bV9pbnRvbCkKKwkJYmNfaWUtPmNvZXhfcGFyYW0gfD0gV0xBTl8yMF80MF9CU1NfQ09FWF8yME1IWl9XSURUSF9SRVE7CisKKwlpZiAobnVtX2NoYW5uZWxzID4gMCkgeworCQlpY19yZXBvcnQgPSB3cGFidWZfcHV0KGJ1Ziwgc2l6ZW9mKCppY19yZXBvcnQpKTsKKwkJaWNfcmVwb3J0LT5lbGVtZW50X2lkID0gV0xBTl9FSURfMjBfNDBfQlNTX0lOVE9MRVJBTlQ7CisJCWljX3JlcG9ydC0+bGVuZ3RoID0gbnVtX2NoYW5uZWxzICsgMTsKKwkJaWNfcmVwb3J0LT5vcF9jbGFzcyA9IDA7CisJCW9zX21lbWNweSh3cGFidWZfcHV0KGJ1ZiwgbnVtX2NoYW5uZWxzKSwgY2hhbl9saXN0LAorCQkJICBudW1fY2hhbm5lbHMpOworCX0KKworCWlmICh3cGFfZHJ2X3NlbmRfYWN0aW9uKHdwYV9zLCB3cGFfcy0+YXNzb2NfZnJlcSwgMCwgd3BhX3MtPmJzc2lkLAorCQkJCXdwYV9zLT5vd25fYWRkciwgd3BhX3MtPmJzc2lkLAorCQkJCXdwYWJ1Zl9oZWFkKGJ1ZiksIHdwYWJ1Zl9sZW4oYnVmKSwgMCkgPCAwKSB7CisJCXdwYV9tc2cod3BhX3MsIE1TR19JTkZPLAorCQkJIlNNRTogRmFpbGVkIHRvIHNlbmQgMjAvNDAgQlNTIENvZXhpc3RlbmNlIGZyYW1lIik7CisJfQorCisJd3BhYnVmX2ZyZWUoYnVmKTsKK30KKworCisvKioKKyAqIGVudW0gd3Bhc19iYW5kIC0gRnJlcXVlbmN5IGJhbmQKKyAqIEBXUEFTX0JBTkRfMkdIWjogMi40IEdIeiBJU00gYmFuZAorICogQFdQQVNfQkFORF81R0haOiBhcm91bmQgNSBHSHogYmFuZCAoNC45IC0gNS43IEdIeikKKyAqLworZW51bSB3cGFzX2JhbmQgeworCVdQQVNfQkFORF8yR0haLAorCVdQQVNfQkFORF81R0haLAorCVdQQVNfQkFORF9JTlZBTElECit9OworCisvKioKKyAqIGZyZXFfdG9fY2hhbm5lbCAtIENvbnZlcnQgZnJlcXVlbmN5IGludG8gY2hhbm5lbCBpbmZvCisgKiBAY2hhbm5lbDogQnVmZmVyIGZvciByZXR1cm5pbmcgY2hhbm5lbCBudW1iZXIKKyAqIFJldHVybnM6IEJhbmQgKDIgb3IgNSBHSHopCisgKi8KK3N0YXRpYyBlbnVtIHdwYXNfYmFuZCBmcmVxX3RvX2NoYW5uZWwoaW50IGZyZXEsIHU4ICpjaGFubmVsKQoreworCWVudW0gd3Bhc19iYW5kIGJhbmQgPSAoZnJlcSA8PSAyNDg0KSA/IFdQQVNfQkFORF8yR0haIDogV1BBU19CQU5EXzVHSFo7CisJdTggY2hhbiA9IDA7CisKKwlpZiAoZnJlcSA+PSAyNDEyICYmIGZyZXEgPD0gMjQ3MikKKwkJY2hhbiA9IChmcmVxIC0gMjQwNykgLyA1OworCWVsc2UgaWYgKGZyZXEgPT0gMjQ4NCkKKwkJY2hhbiA9IDE0OworCWVsc2UgaWYgKGZyZXEgPj0gNTE4MCAmJiBmcmVxIDw9IDU4MDUpCisJCWNoYW4gPSAoZnJlcSAtIDUwMDApIC8gNTsKKworCSpjaGFubmVsID0gY2hhbjsKKwlyZXR1cm4gYmFuZDsKK30KKworCitpbnQgc21lX3Byb2Nfb2Jzc19zY2FuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisJc3RydWN0IHdwYV9ic3MgKmJzczsKKwljb25zdCB1OCAqaWU7CisJdTE2IGh0X2NhcDsKKwl1OCBjaGFuX2xpc3RbUDJQX01BWF9DSEFOTkVMU10sIGNoYW5uZWw7CisJdTggbnVtX2NoYW5uZWxzID0gMCwgbnVtX2ludG9sID0gMCwgaTsKKworCWlmICghd3BhX3MtPnNtZS5zY2hlZF9vYnNzX3NjYW4pCisJCXJldHVybiAwOworCisJd3BhX3MtPnNtZS5zY2hlZF9vYnNzX3NjYW4gPSAwOworCWlmICghd3BhX3MtPmN1cnJlbnRfYnNzIHx8IHdwYV9zLT53cGFfc3RhdGUgIT0gV1BBX0NPTVBMRVRFRCkKKwkJcmV0dXJuIDE7CisKKwkvKgorCSAqIENoZWNrIHdoZXRoZXIgQVAgdXNlcyByZWd1bGF0b3J5IHRyaXBsZXQgb3IgY2hhbm5lbCB0cmlwbGV0IGluCisJICogY291bnRyeSBpbmZvLiBSaWdodCBub3cgdGhlIG9wZXJhdGluZyBjbGFzcyBvZiB0aGUgQlNTIGNoYW5uZWwKKwkgKiB3aWR0aCB0cmlnZ2VyIGV2ZW50IGlzICJ1bmtub3duIiAoSUVFRSBTdGQgODAyLjExLTIwMTIgMTAuMTUuMTIpLAorCSAqIGJhc2VkIG9uIHRoZSBhc3N1bXB0aW9uIHRoYXQgb3BlcmF0aW5nIGNsYXNzIHRyaXBsZXQgaXMgbm90IHVzZWQgaW4KKwkgKiBiZWFjb24gZnJhbWUuIElmIHRoZSBGaXJzdCBDaGFubmVsIE51bWJlci9PcGVyYXRpbmcgRXh0ZW5zaW9uCisJICogSWRlbnRpZmllciBvY3RldCBoYXMgYSBwb3NpdGl2ZSBpbnRlZ2VyIHZhbHVlIG9mIDIwMSBvciBncmVhdGVyLAorCSAqIHRoZW4gaXRzIG9wZXJhdGluZyBjbGFzcyB0cmlwbGV0LgorCSAqCisJICogVE9ETzogSWYgU3VwcG9ydGVkIE9wZXJhdGluZyBDbGFzc2VzIGVsZW1lbnQgaXMgcHJlc2VudCBpbiBiZWFjb24KKwkgKiBmcmFtZSwgaGF2ZSB0byBsb29rdXAgb3BlcmF0aW5nIGNsYXNzIGluIEFubmV4IEUgYW5kIGZpbGwgdGhlbSBpbgorCSAqIDIwNDAgY29leCBmcmFtZS4KKwkgKi8KKwlpZSA9IHdwYV9ic3NfZ2V0X2llKHdwYV9zLT5jdXJyZW50X2JzcywgV0xBTl9FSURfQ09VTlRSWSk7CisJaWYgKGllICYmIChpZVsxXSA+PSA2KSAmJiAoaWVbNV0gPj0gMjAxKSkKKwkJcmV0dXJuIDE7CisKKwlvc19tZW1zZXQoY2hhbl9saXN0LCAwLCBzaXplb2YoY2hhbl9saXN0KSk7CisKKwlkbF9saXN0X2Zvcl9lYWNoKGJzcywgJndwYV9zLT5ic3MsIHN0cnVjdCB3cGFfYnNzLCBsaXN0KSB7CisJCS8qIFNraXAgb3RoZXIgYmFuZCBic3MgKi8KKwkJaWYgKGZyZXFfdG9fY2hhbm5lbChic3MtPmZyZXEsICZjaGFubmVsKSAhPSBXUEFTX0JBTkRfMkdIWikKKwkJCWNvbnRpbnVlOworCisJCWllID0gd3BhX2Jzc19nZXRfaWUoYnNzLCBXTEFOX0VJRF9IVF9DQVApOworCQlodF9jYXAgPSAoaWUgJiYgKGllWzFdID09IDI2KSkgPyBXUEFfR0VUX0xFMTYoaWUgKyAyKSA6IDA7CisKKwkJaWYgKCFodF9jYXAgfHwgKGh0X2NhcCAmIEhUX0NBUF9JTkZPXzQwTUhaX0lOVE9MRVJBTlQpKSB7CisJCQkvKiBDaGVjayB3aGV0aGVyIHRoZSBjaGFubmVsIGlzIGFscmVhZHkgY29uc2lkZXJlZCAqLworCQkJZm9yIChpID0gMDsgaSA8IG51bV9jaGFubmVsczsgaSsrKSB7CisJCQkJaWYgKGNoYW5uZWwgPT0gY2hhbl9saXN0W2ldKQorCQkJCQlicmVhazsKKwkJCX0KKwkJCWlmIChpICE9IG51bV9jaGFubmVscykKKwkJCQljb250aW51ZTsKKworCQkJaWYgKGh0X2NhcCAmIEhUX0NBUF9JTkZPXzQwTUhaX0lOVE9MRVJBTlQpCisJCQkJbnVtX2ludG9sKys7CisKKwkJCWNoYW5fbGlzdFtudW1fY2hhbm5lbHMrK10gPSBjaGFubmVsOworCQl9CisJfQorCisJc21lX3NlbmRfMjA0MF9ic3NfY29leCh3cGFfcywgY2hhbl9saXN0LCBudW1fY2hhbm5lbHMsIG51bV9pbnRvbCk7CisJcmV0dXJuIDE7Cit9CisKKworc3RhdGljIHN0cnVjdCBob3N0YXBkX2h3X21vZGVzICogZ2V0X21vZGUoc3RydWN0IGhvc3RhcGRfaHdfbW9kZXMgKm1vZGVzLAorCQkJCQkgIHUxNiBudW1fbW9kZXMsCisJCQkJCSAgZW51bSBob3N0YXBkX2h3X21vZGUgbW9kZSkKK3sKKwl1MTYgaTsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fbW9kZXM7IGkrKykgeworCQlpZiAobW9kZXNbaV0ubW9kZSA9PSBtb2RlKQorCQkJcmV0dXJuICZtb2Rlc1tpXTsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworCitzdGF0aWMgdm9pZCB3cGFfc2V0YmFuZF9zY2FuX2ZyZXFzX2xpc3Qoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCQkJZW51bSBob3N0YXBkX2h3X21vZGUgYmFuZCwKKwkJCQkJc3RydWN0IHdwYV9kcml2ZXJfc2Nhbl9wYXJhbXMgKnBhcmFtcykKK3sKKwkvKiBJbmNsdWRlIG9ubHkgc3VwcG9ydGVkIGNoYW5uZWxzIGZvciB0aGUgc3BlY2lmaWVkIGJhbmQgKi8KKwlzdHJ1Y3QgaG9zdGFwZF9od19tb2RlcyAqbW9kZTsKKwlpbnQgY291bnQsIGk7CisKKwltb2RlID0gZ2V0X21vZGUod3BhX3MtPmh3Lm1vZGVzLCB3cGFfcy0+aHcubnVtX21vZGVzLCBiYW5kKTsKKwlpZiAobW9kZSA9PSBOVUxMKSB7CisJCS8qIE5vIGNoYW5uZWxzIHN1cHBvcnRlZCBpbiB0aGlzIGJhbmQgLSB1c2UgZW1wdHkgbGlzdCAqLworCQlwYXJhbXMtPmZyZXFzID0gb3NfemFsbG9jKHNpemVvZihpbnQpKTsKKwkJcmV0dXJuOworCX0KKworCXBhcmFtcy0+ZnJlcXMgPSBvc196YWxsb2MoKG1vZGUtPm51bV9jaGFubmVscyArIDEpICogc2l6ZW9mKGludCkpOworCWlmIChwYXJhbXMtPmZyZXFzID09IE5VTEwpCisJCXJldHVybjsKKwlmb3IgKGNvdW50ID0gMCwgaSA9IDA7IGkgPCBtb2RlLT5udW1fY2hhbm5lbHM7IGkrKykgeworCQlpZiAobW9kZS0+Y2hhbm5lbHNbaV0uZmxhZyAmIEhPU1RBUERfQ0hBTl9ESVNBQkxFRCkKKwkJCWNvbnRpbnVlOworCQlwYXJhbXMtPmZyZXFzW2NvdW50KytdID0gbW9kZS0+Y2hhbm5lbHNbaV0uZnJlcTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQgc21lX29ic3Nfc2Nhbl90aW1lb3V0KHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqdGltZW91dF9jdHgpCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGVsb29wX2N0eDsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CisKKwlpZiAoIXdwYV9zLT5jdXJyZW50X2JzcykgeworCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlNNRSBPQlNTOiBJZ25vcmUgc2NhbiByZXF1ZXN0Iik7CisJCXJldHVybjsKKwl9CisKKwlvc19tZW1zZXQoJnBhcmFtcywgMCwgc2l6ZW9mKHBhcmFtcykpOworCXdwYV9zZXRiYW5kX3NjYW5fZnJlcXNfbGlzdCh3cGFfcywgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUcsICZwYXJhbXMpOworCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiU01FIE9CU1M6IFJlcXVlc3QgYW4gT0JTUyBzY2FuIik7CisKKwlpZiAod3BhX3N1cHBsaWNhbnRfdHJpZ2dlcl9zY2FuKHdwYV9zLCAmcGFyYW1zKSkKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTTUUgT0JTUzogRmFpbGVkIHRvIHRyaWdnZXIgc2NhbiIpOworCWVsc2UKKwkJd3BhX3MtPnNtZS5zY2hlZF9vYnNzX3NjYW4gPSAxOworCW9zX2ZyZWUocGFyYW1zLmZyZXFzKTsKKworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQod3BhX3MtPnNtZS5vYnNzX3NjYW5faW50LCAwLAorCQkJICAgICAgIHNtZV9vYnNzX3NjYW5fdGltZW91dCwgd3BhX3MsIE5VTEwpOworfQorCisKK3ZvaWQgc21lX3NjaGVkX29ic3Nfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgZW5hYmxlKQoreworCWNvbnN0IHU4ICppZTsKKwlzdHJ1Y3Qgd3BhX2JzcyAqYnNzID0gd3BhX3MtPmN1cnJlbnRfYnNzOworCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CisKKwllbG9vcF9jYW5jZWxfdGltZW91dChzbWVfb2Jzc19zY2FuX3RpbWVvdXQsIHdwYV9zLCBOVUxMKTsKKwl3cGFfcy0+c21lLnNjaGVkX29ic3Nfc2NhbiA9IDA7CisJaWYgKCFlbmFibGUpCisJCXJldHVybjsKKworCWlmICghKHdwYV9zLT5kcnZfZmxhZ3MgJiBXUEFfRFJJVkVSX0ZMQUdTX1NNRSkgfHwgc3NpZCA9PSBOVUxMIHx8CisJICAgIHNzaWQtPm1vZGUgIT0gSUVFRTgwMjExX01PREVfSU5GUkEpCisJCXJldHVybjsgLyogTm90IHVzaW5nIHN0YXRpb24gU01FIGluIHdwYV9zdXBwbGljYW50ICovCisKKwlpZiAoIXdwYV9zLT5ody5tb2RlcyB8fAorCSAgICAhKHdwYV9zLT5ody5tb2Rlcy0+aHRfY2FwYWIgJiBIVF9DQVBfSU5GT19TVVBQX0NIQU5ORUxfV0lEVEhfU0VUKSkKKwkJcmV0dXJuOyAvKiBEcml2ZXIgZG9lcyBub3Qgc3VwcG9ydCBIVDQwICovCisKKwlpZiAoYnNzID09IE5VTEwgfHwgYnNzLT5mcmVxIDwgMjQwMCB8fCBic3MtPmZyZXEgPiAyNTAwKQorCQlyZXR1cm47IC8qIE5vdCBhc3NvY2lhdGVkIG9uIDIuNCBHSHogYmFuZCAqLworCisJLyogQ2hlY2sgd2hldGhlciBBUCBzdXBwb3J0cyBIVDQwICovCisJaWUgPSB3cGFfYnNzX2dldF9pZSh3cGFfcy0+Y3VycmVudF9ic3MsIFdMQU5fRUlEX0hUX0NBUCk7CisJaWYgKCFpZSB8fCBpZVsxXSA8IDIgfHwKKwkgICAgIShXUEFfR0VUX0xFMTYoaWUgKyAyKSAmIEhUX0NBUF9JTkZPX1NVUFBfQ0hBTk5FTF9XSURUSF9TRVQpKQorCQlyZXR1cm47IC8qIEFQIGRvZXMgbm90IHN1cHBvcnQgSFQ0MCAqLworCisJaWUgPSB3cGFfYnNzX2dldF9pZSh3cGFfcy0+Y3VycmVudF9ic3MsCisJCQkgICAgV0xBTl9FSURfT1ZFUkxBUFBJTkdfQlNTX1NDQU5fUEFSQU1TKTsKKwlpZiAoIWllIHx8IGllWzFdIDwgMTQpCisJCXJldHVybjsgLyogQVAgZG9lcyBub3QgcmVxdWVzdCBPQlNTIHNjYW5zICovCisKKwl3cGFfcy0+c21lLm9ic3Nfc2Nhbl9pbnQgPSBXUEFfR0VUX0xFMTYoaWUgKyA2KTsKKwlpZiAod3BhX3MtPnNtZS5vYnNzX3NjYW5faW50IDwgMTApIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTTUU6IEludmFsaWQgT0JTUyBTY2FuIEludGVydmFsICV1ICIKKwkJCSAgICJyZXBsYWNlZCB3aXRoIHRoZSBtaW5pbXVtIDEwIHNlYyIsCisJCQkgICB3cGFfcy0+c21lLm9ic3Nfc2Nhbl9pbnQpOworCQl3cGFfcy0+c21lLm9ic3Nfc2Nhbl9pbnQgPSAxMDsKKwl9CisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTTUU6IE9CU1MgU2NhbiBJbnRlcnZhbCAldSBzZWMiLAorCQkgICB3cGFfcy0+c21lLm9ic3Nfc2Nhbl9pbnQpOworCWVsb29wX3JlZ2lzdGVyX3RpbWVvdXQod3BhX3MtPnNtZS5vYnNzX3NjYW5faW50LCAwLAorCQkJICAgICAgIHNtZV9vYnNzX3NjYW5fdGltZW91dCwgd3BhX3MsIE5VTEwpOwogfQogCiAKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3NtZS5oIGIvd3BhX3N1cHBsaWNhbnQvc21lLmgKaW5kZXggMzM1MzBiYi4uYTdjYzUwNyAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvc21lLmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvc21lLmgKQEAgLTM1LDYgKzM1LDkgQEAKIAkJCQkgICAgICAgY29uc3QgdTggKnByZXZfcGVuZGluZ19ic3NpZCk7CiB2b2lkIHNtZV9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiAKK2ludCBzbWVfcHJvY19vYnNzX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7Cit2b2lkIHNtZV9zY2hlZF9vYnNzX3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IGVuYWJsZSk7CisKICNlbHNlIC8qIENPTkZJR19TTUUgKi8KIAogc3RhdGljIGlubGluZSB2b2lkIHNtZV9hdXRoZW50aWNhdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKQEAgLTk1LDYgKzk4LDE2IEBACiB7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50IHNtZV9wcm9jX29ic3Nfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgc21lX3NjaGVkX29ic3Nfc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgICBpbnQgZW5hYmxlKQoreworfQorCiAjZW5kaWYgLyogQ09ORklHX1NNRSAqLwogCiAjZW5kaWYgLyogU01FX0ggKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYV9jbGkuYyBiL3dwYV9zdXBwbGljYW50L3dwYV9jbGkuYwppbmRleCA4YWJmMmFlLi5jNjMxY2QxIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC93cGFfY2xpLmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BhX2NsaS5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIFdQQSBTdXBwbGljYW50IC0gY29tbWFuZCBsaW5lIGludGVyZmFjZSBmb3Igd3BhX3N1cHBsaWNhbnQgZGFlbW9uCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDQtMjAxMSwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDEyLCBKb3VuaSBNYWxpbmVuIDxqQHcxLmZpPgogICoKICAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSAidXRpbHMvZWRpdC5oIgogI2luY2x1ZGUgInV0aWxzL2xpc3QuaCIKICNpbmNsdWRlICJjb21tb24vdmVyc2lvbi5oIgorI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2RlZnMuaCIKICNpZmRlZiBBTkRST0lECiAjaW5jbHVkZSA8Y3V0aWxzL3Byb3BlcnRpZXMuaD4KICNlbmRpZiAvKiBBTkRST0lEICovCkBAIC04NzMsNiArODc0LDc4IEBACiAjZW5kaWYgLyogQ09ORklHX1dQU19PT0IgKi8KIAogCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKworc3RhdGljIGludCB3cGFfY2xpX2NtZF93cHNfbmZjKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGNtZFsyNTZdOworCWludCByZXM7CisKKwlpZiAoYXJnYyA+PSAxKQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiV1BTX05GQyAlcyIsCisJCQkJICBhcmd2WzBdKTsKKwllbHNlCisJCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksICJXUFNfTkZDIik7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIFdQU19ORkMgY29tbWFuZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGNtZCk7Cit9CisKKworc3RhdGljIGludCB3cGFfY2xpX2NtZF93cHNfbmZjX3Rva2VuKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJICAgICBjaGFyICphcmd2W10pCit7CisJY2hhciBjbWRbMjU2XTsKKwlpbnQgcmVzOworCisJaWYgKGFyZ2MgIT0gMSkgeworCQlwcmludGYoIkludmFsaWQgV1BTX05GQ19UT0tFTiBjb21tYW5kOiBuZWVkIG9uZSBhcmd1bWVudDpcbiIKKwkJICAgICAgICJmb3JtYXQ6IFdQUyBvciBOREVGXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAoYXJnYyA+PSAxKQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiV1BTX05GQ19UT0tFTiAlcyIsCisJCQkJICBhcmd2WzBdKTsKKwllbHNlCisJCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksICJXUFNfTkZDX1RPS0VOIik7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIFdQU19ORkNfVE9LRU4gY29tbWFuZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGNtZCk7Cit9CisKKworc3RhdGljIGludCB3cGFfY2xpX2NtZF93cHNfbmZjX3RhZ19yZWFkKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJCWNoYXIgKmFyZ3ZbXSkKK3sKKwlpbnQgcmV0OworCWNoYXIgKmJ1ZjsKKwlzaXplX3QgYnVmbGVuOworCisJaWYgKGFyZ2MgIT0gMSkgeworCQlwcmludGYoIkludmFsaWQgJ3dwc19uZmNfdGFnX3JlYWQnIGNvbW1hbmQgLSBvbmUgYXJndW1lbnQgIgorCQkgICAgICAgImlzIHJlcXVpcmVkLlxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlidWZsZW4gPSAxOCArIG9zX3N0cmxlbihhcmd2WzBdKTsKKwlidWYgPSBvc19tYWxsb2MoYnVmbGVuKTsKKwlpZiAoYnVmID09IE5VTEwpCisJCXJldHVybiAtMTsKKwlvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIldQU19ORkNfVEFHX1JFQUQgJXMiLCBhcmd2WzBdKTsKKworCXJldCA9IHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgYnVmKTsKKwlvc19mcmVlKGJ1Zik7CisKKwlyZXR1cm4gcmV0OworfQorCisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKworCiBzdGF0aWMgaW50IHdwYV9jbGlfY21kX3dwc19yZWcoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQogewogCWNoYXIgY21kWzI1Nl07CkBAIC0xMTI4LDYgKzEyMDEsMzIgQEAKIH0KIAogCisjaWZkZWYgQ09ORklHX1dQU19ORkMKK3N0YXRpYyBpbnQgd3BhX2NsaV9jbWRfd3BzX2VyX25mY19jb25maWdfdG9rZW4oc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKKwkJCQkJICAgICAgIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGNtZFsyNTZdOworCWludCByZXM7CisKKwlpZiAoYXJnYyAhPSAyKSB7CisJCXByaW50ZigiSW52YWxpZCBXUFNfRVJfTkZDX0NPTkZJR19UT0tFTiBjb21tYW5kOiBuZWVkIHR3byAiCisJCSAgICAgICAiYXJndW1lbnRzOlxuIgorCQkgICAgICAgIi0gV1BTL05ERUY6IHRva2VuIGZvcm1hdFxuIgorCQkgICAgICAgIi0gVVVJRDogc3BlY2lmeSB3aGljaCBBUCB0byB1c2VcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIldQU19FUl9ORkNfQ09ORklHX1RPS0VOICVzICVzIiwKKwkJCSAgYXJndlswXSwgYXJndlsxXSk7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIFdQU19FUl9ORkNfQ09ORklHX1RPS0VOIGNvbW1hbmQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBjbWQpOworfQorI2VuZGlmIC8qIENPTkZJR19XUFNfTkZDICovCisKKwogc3RhdGljIGludCB3cGFfY2xpX2NtZF9pYnNzX3JzbihzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLCBjaGFyICphcmd2W10pCiB7CiAJY2hhciBjbWRbMjU2XTsKQEAgLTE0OTAsNyArMTU4OSwxMiBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIkVOQUJMRV9ORVRXT1JLICVzIiwgYXJndlswXSk7CisJaWYgKGFyZ2MgPiAxKQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiRU5BQkxFX05FVFdPUksgJXMgJXMiLAorCQkJCSAgYXJndlswXSwgYXJndlsxXSk7CisJZWxzZQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiRU5BQkxFX05FVFdPUksgJXMiLAorCQkJCSAgYXJndlswXSk7CiAJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpKQogCQlyZXR1cm4gLTE7CiAJY21kW3NpemVvZihjbWQpIC0gMV0gPSAnXDAnOwpAQCAtMTYyMyw2ICsxNzI3LDYxIEBACiB9CiAKIAorc3RhdGljIGludCB3cGFfY2xpX2NtZF9saXN0X2NyZWRzKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJICBjaGFyICphcmd2W10pCit7CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgIkxJU1RfQ1JFRFMiKTsKK30KKworCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX2FkZF9jcmVkKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkKK3sKKwlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCAiQUREX0NSRUQiKTsKK30KKworCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX3JlbW92ZV9jcmVkKHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCisJCQkJICAgY2hhciAqYXJndltdKQoreworCWNoYXIgY21kWzMyXTsKKwlpbnQgcmVzOworCisJaWYgKGFyZ2MgPCAxKSB7CisJCXByaW50ZigiSW52YWxpZCBSRU1PVkVfQ1JFRCBjb21tYW5kOiBuZWVkcyBvbmUgYXJndW1lbnQgIgorCQkgICAgICAgIihjcmVkIGlkKVxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiUkVNT1ZFX0NSRUQgJXMiLCBhcmd2WzBdKTsKKwlpZiAocmVzIDwgMCB8fCAoc2l6ZV90KSByZXMgPj0gc2l6ZW9mKGNtZCkpCisJCXJldHVybiAtMTsKKwljbWRbc2l6ZW9mKGNtZCkgLSAxXSA9ICdcMCc7CisKKwlyZXR1cm4gd3BhX2N0cmxfY29tbWFuZChjdHJsLCBjbWQpOworfQorCisKK3N0YXRpYyBpbnQgd3BhX2NsaV9jbWRfc2V0X2NyZWQoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQoreworCWNoYXIgY21kWzI1Nl07CisJaW50IHJlczsKKworCWlmIChhcmdjICE9IDMpIHsKKwkJcHJpbnRmKCJJbnZhbGlkIFNFVF9DUkVEIGNvbW1hbmQ6IG5lZWRzIHRocmVlIGFyZ3VtZW50c1xuIgorCQkgICAgICAgIihjcmVkIGlkLCB2YXJpYWJsZSBuYW1lLCBhbmQgdmFsdWUpXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksICJTRVRfQ1JFRCAlcyAlcyAlcyIsCisJCQkgIGFyZ3ZbMF0sIGFyZ3ZbMV0sIGFyZ3ZbMl0pOworCWlmIChyZXMgPCAwIHx8IChzaXplX3QpIHJlcyA+PSBzaXplb2YoY21kKSAtIDEpIHsKKwkJcHJpbnRmKCJUb28gbG9uZyBTRVRfQ1JFRCBjb21tYW5kLlxuIik7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgY21kKTsKK30KKworCiBzdGF0aWMgaW50IHdwYV9jbGlfY21kX2Rpc2Nvbm5lY3Qoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKIAkJCQkgIGNoYXIgKmFyZ3ZbXSkKIHsKQEAgLTE2NjgsOCArMTgyNyw5IEBACiAJCXJldHVybiAtMTsKIAl9CiAKLQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLCAiQlNTICVzXHQlc1x0JXMiLCBhcmd2WzBdLAotCQkJICBhcmdjID4gMSA/IGFyZ3ZbMV0gOiAiIiwgYXJnYyA+IDIgPyBhcmd2WzJdIDogIiIpOworCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksICJCU1MgJXMlcyVzJXMlcyIsIGFyZ3ZbMF0sCisJCQkgIGFyZ2MgPiAxID8gIiAiIDogIiIsIGFyZ2MgPiAxID8gYXJndlsxXSA6ICIiLAorCQkJICBhcmdjID4gMiA/ICIgIiA6ICIiLCBhcmdjID4gMiA/IGFyZ3ZbMl0gOiAiIik7CiAKIAlpZiAocmVzIDwgMCB8fCAoc2l6ZV90KSByZXMgPj0gc2l6ZW9mKGNtZCkpCiAJCXJldHVybiAtMTsKQEAgLTE4NDgsNyArMjAwOCw3IEBACiAJCXJldHVybiAtMTsKIAl9CiAJbGVuID0gc2l6ZW9mKGJ1ZikgLSAxOwotCXJldCA9IHdwYV9jdHJsX3JlcXVlc3QoY3RybCwgY21kLCBzdHJsZW4oY21kKSwgYnVmLCAmbGVuLAorCXJldCA9IHdwYV9jdHJsX3JlcXVlc3QoY3RybCwgY21kLCBvc19zdHJsZW4oY21kKSwgYnVmLCAmbGVuLAogCQkJICAgICAgIHdwYV9jbGlfbXNnX2NiKTsKIAlpZiAocmV0ID09IC0yKSB7CiAJCXByaW50ZigiJyVzJyBjb21tYW5kIHRpbWVkIG91dC5cbiIsIGNtZCk7CkBAIC0xODU5LDcgKzIwMTksNyBAQAogCX0KIAogCWJ1ZltsZW5dID0gJ1wwJzsKLQlpZiAobWVtY21wKGJ1ZiwgIkZBSUwiLCA0KSA9PSAwKQorCWlmIChvc19tZW1jbXAoYnVmLCAiRkFJTCIsIDQpID09IDApCiAJCXJldHVybiAtMTsKIAlwcmludGYoIiVzIiwgYnVmKTsKIApAQCAtMTg4NCw2ICsyMDQ0LDQyIEBACiAKIAlyZXR1cm4gLTE7CiB9CisKKworc3RhdGljIGludCB3cGFfY2xpX2NtZF9kZWF1dGhlbnRpY2F0ZShzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLAorCQkJCSAgICAgIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGJ1Zls2NF07CisJaWYgKGFyZ2MgPCAxKSB7CisJCXByaW50ZigiSW52YWxpZCAnZGVhdXRoZW50aWNhdGUnIGNvbW1hbmQgLSBleGFjdGx5IG9uZSAiCisJCSAgICAgICAiYXJndW1lbnQsIFNUQSBhZGRyZXNzLCBpcyByZXF1aXJlZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChhcmdjID4gMSkKKwkJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIkRFQVVUSEVOVElDQVRFICVzICVzIiwKKwkJCSAgICBhcmd2WzBdLCBhcmd2WzFdKTsKKwllbHNlCisJCW9zX3NucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICJERUFVVEhFTlRJQ0FURSAlcyIsIGFyZ3ZbMF0pOworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGJ1Zik7Cit9CisKKworc3RhdGljIGludCB3cGFfY2xpX2NtZF9kaXNhc3NvY2lhdGUoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKKwkJCQkgICAgY2hhciAqYXJndltdKQoreworCWNoYXIgYnVmWzY0XTsKKwlpZiAoYXJnYyA8IDEpIHsKKwkJcHJpbnRmKCJJbnZhbGlkICdkaXNhc3NvY2lhdGUnIGNvbW1hbmQgLSBleGFjdGx5IG9uZSAiCisJCSAgICAgICAiYXJndW1lbnQsIFNUQSBhZGRyZXNzLCBpcyByZXF1aXJlZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChhcmdjID4gMSkKKwkJb3Nfc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIkRJU0FTU09DSUFURSAlcyAlcyIsCisJCQkgICAgYXJndlswXSwgYXJndlsxXSk7CisJZWxzZQorCQlvc19zbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiRElTQVNTT0NJQVRFICVzIiwgYXJndlswXSk7CisJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgYnVmKTsKK30KICNlbmRpZiAvKiBDT05GSUdfQVAgKi8KIAogCkBAIC0xOTY4LDcgKzIxNjQsMTQgQEAKIAkJICAgICAgICJhcmd1bWVudHMgKGFkZHJlc3MgYW5kIHBiYy9QSU4pXG4iKTsKIAkJcmV0dXJuIC0xOwogCX0KLQorI2lmZGVmIEFORFJPSURfUDJQCisJaWYgKGFyZ2MgPiA1KQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLAorCQkJCSAgIlAyUF9DT05ORUNUICVzICVzICVzICVzICVzICVzIiwKKwkJCQkgIGFyZ3ZbMF0sIGFyZ3ZbMV0sIGFyZ3ZbMl0sIGFyZ3ZbM10sCisJCQkJICBhcmd2WzRdLCBhcmd2WzVdKTsKKwllbHNlCisjZW5kaWYKIAlpZiAoYXJnYyA+IDQpCiAJCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksCiAJCQkJICAiUDJQX0NPTk5FQ1QgJXMgJXMgJXMgJXMgJXMiLApAQCAtMjM1Nyw3ICsyNTYwLDcgQEAKIAlpZiAoY3RybF9jb25uID09IE5VTEwpCiAJCXJldHVybiAtMTsKIAlsZW4gPSBzaXplb2YoYnVmKSAtIDE7Ci0JcmV0ID0gd3BhX2N0cmxfcmVxdWVzdChjdHJsLCBjbWQsIHN0cmxlbihjbWQpLCBidWYsICZsZW4sCisJcmV0ID0gd3BhX2N0cmxfcmVxdWVzdChjdHJsLCBjbWQsIG9zX3N0cmxlbihjbWQpLCBidWYsICZsZW4sCiAJCQkgICAgICAgd3BhX2NsaV9tc2dfY2IpOwogCWlmIChyZXQgPT0gLTIpIHsKIAkJcHJpbnRmKCInJXMnIGNvbW1hbmQgdGltZWQgb3V0LlxuIiwgY21kKTsKQEAgLTIzNjgsNyArMjU3MSw3IEBACiAJfQogCiAJYnVmW2xlbl0gPSAnXDAnOwotCWlmIChtZW1jbXAoYnVmLCAiRkFJTCIsIDQpID09IDApCisJaWYgKG9zX21lbWNtcChidWYsICJGQUlMIiwgNCkgPT0gMCkKIAkJcmV0dXJuIC0xOwogCiAJcG9zID0gYnVmOwpAQCAtMjU4OCw2ICsyNzkxLDYwIEBACiAjZW5kaWYgLyogQ09ORklHX0lOVEVSV09SS0lORyAqLwogCiAKKyNpZmRlZiBDT05GSUdfSFMyMAorCitzdGF0aWMgaW50IHdwYV9jbGlfY21kX2hzMjBfYW5xcF9nZXQoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywKKwkJCQkgICAgIGNoYXIgKmFyZ3ZbXSkKK3sKKwljaGFyIGNtZFsxMDBdOworCWludCByZXM7CisKKwlpZiAoYXJnYyAhPSAyKSB7CisJCXByaW50ZigiSW52YWxpZCBIUzIwX0FOUVBfR0VUIGNvbW1hbmQ6IG5lZWRzIHR3byBhcmd1bWVudHMgIgorCQkgICAgICAgIihhZGRyIGFuZCBzdWJ0eXBlIGxpc3QpXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJlcyA9IG9zX3NucHJpbnRmKGNtZCwgc2l6ZW9mKGNtZCksICJIUzIwX0FOUVBfR0VUICVzICVzIiwKKwkJCSAgYXJndlswXSwgYXJndlsxXSk7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpKQorCQlyZXR1cm4gLTE7CisJY21kW3NpemVvZihjbWQpIC0gMV0gPSAnXDAnOworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGNtZCk7Cit9CisKKworc3RhdGljIGludCB3cGFfY2xpX2NtZF9nZXRfbmFpX2hvbWVfcmVhbG1fbGlzdChzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLAorCQkJCQkgICAgICAgY2hhciAqYXJndltdKQoreworCWNoYXIgY21kWzUxMl07CisJaW50IHJlczsKKworCWlmIChhcmdjID09IDApIHsKKwkJcHJpbnRmKCJDb21tYW5kIG5lZWRzIG9uZSBvciB0d28gYXJndW1lbnRzIChkc3QgbWFjIGFkZHIgYW5kICIKKwkJICAgICAgICJvcHRpb25hbCBob21lIHJlYWxtKVxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoYXJnYyA9PSAxKQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLAorCQkJCSAgIkhTMjBfR0VUX05BSV9IT01FX1JFQUxNX0xJU1QgJXMiLAorCQkJCSAgYXJndlswXSk7CisJZWxzZQorCQlyZXMgPSBvc19zbnByaW50ZihjbWQsIHNpemVvZihjbWQpLAorCQkJCSAgIkhTMjBfR0VUX05BSV9IT01FX1JFQUxNX0xJU1QgJXMgJXMiLAorCQkJCSAgYXJndlswXSwgYXJndlsxXSk7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIGNvbW1hbmQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGNtZCk7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLworCisKIHN0YXRpYyBpbnQgd3BhX2NsaV9jbWRfc3RhX2F1dG9jb25uZWN0KHN0cnVjdCB3cGFfY3RybCAqY3RybCwgaW50IGFyZ2MsCiAJCQkJICAgICAgIGNoYXIgKmFyZ3ZbXSkKIHsKQEAgLTI2ODQsNiArMjk0MSwyOSBAQAogCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsICJSRUFVVEhFTlRJQ0FURSIpOwogfQogCisKKyNpZmRlZiBDT05GSUdfQVVUT1NDQU4KKworc3RhdGljIGludCB3cGFfY2xpX2NtZF9hdXRvc2NhbihzdHJ1Y3Qgd3BhX2N0cmwgKmN0cmwsIGludCBhcmdjLCBjaGFyICphcmd2W10pCit7CisJY2hhciBjbWRbMjU2XTsKKwlpbnQgcmVzOworCisJaWYgKGFyZ2MgPT0gMCkKKwkJcmV0dXJuIHdwYV9jdHJsX2NvbW1hbmQoY3RybCwgIkFVVE9TQ0FOICIpOworCisJcmVzID0gb3Nfc25wcmludGYoY21kLCBzaXplb2YoY21kKSwgIkFVVE9TQ0FOICVzIiwgYXJndlswXSk7CisJaWYgKHJlcyA8IDAgfHwgKHNpemVfdCkgcmVzID49IHNpemVvZihjbWQpIC0gMSkgeworCQlwcmludGYoIlRvbyBsb25nIEFVVE9TQ0FOIGNvbW1hbmQuXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiB3cGFfY3RybF9jb21tYW5kKGN0cmwsIGNtZCk7Cit9CisKKyNlbmRpZiAvKiBDT05GSUdfQVVUT1NDQU4gKi8KKworCiAjaWZkZWYgQU5EUk9JRAogc3RhdGljIGludCB3cGFfY2xpX2NtZF9kcml2ZXIoc3RydWN0IHdwYV9jdHJsICpjdHJsLCBpbnQgYXJnYywgY2hhciAqYXJndltdKQogewpAQCAtMjgyNyw2ICszMTA3LDE4IEBACiAJeyAiZ2V0X25ldHdvcmsiLCB3cGFfY2xpX2NtZF9nZXRfbmV0d29yaywKIAkgIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIjxuZXR3b3JrIGlkPiA8dmFyaWFibGU+ID0gZ2V0IG5ldHdvcmsgdmFyaWFibGVzIiB9LAorCXsgImxpc3RfY3JlZHMiLCB3cGFfY2xpX2NtZF9saXN0X2NyZWRzLAorCSAgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiPSBsaXN0IGNvbmZpZ3VyZWQgY3JlZGVudGlhbHMiIH0sCisJeyAiYWRkX2NyZWQiLCB3cGFfY2xpX2NtZF9hZGRfY3JlZCwKKwkgIGNsaV9jbWRfZmxhZ19ub25lLAorCSAgIj0gYWRkIGEgY3JlZGVudGlhbCIgfSwKKwl7ICJyZW1vdmVfY3JlZCIsIHdwYV9jbGlfY21kX3JlbW92ZV9jcmVkLAorCSAgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiPGNyZWQgaWQ+ID0gcmVtb3ZlIGEgY3JlZGVudGlhbCIgfSwKKwl7ICJzZXRfY3JlZCIsIHdwYV9jbGlfY21kX3NldF9jcmVkLAorCSAgY2xpX2NtZF9mbGFnX3NlbnNpdGl2ZSwKKwkgICI8Y3JlZCBpZD4gPHZhcmlhYmxlPiA8dmFsdWU+ID0gc2V0IGNyZWRlbnRpYWwgdmFyaWFibGVzIiB9LAogCXsgInNhdmVfY29uZmlnIiwgd3BhX2NsaV9jbWRfc2F2ZV9jb25maWcsCiAJICBjbGlfY21kX2ZsYWdfbm9uZSwKIAkgICI9IHNhdmUgdGhlIGN1cnJlbnQgY29uZmlndXJhdGlvbiIgfSwKQEAgLTI5MDMsNiArMzE5NSwxNyBAQAogCSAgY2xpX2NtZF9mbGFnX3NlbnNpdGl2ZSwKIAkgICI8REVWX1RZUEU+IDxQQVRIPiA8TUVUSE9EPiBbREVWX05BTUVdID0gc3RhcnQgV1BTIE9PQiIgfSwKICNlbmRpZiAvKiBDT05GSUdfV1BTX09PQiAqLworI2lmZGVmIENPTkZJR19XUFNfTkZDCisJeyAid3BzX25mYyIsIHdwYV9jbGlfY21kX3dwc19uZmMsCisJICBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICJbQlNTSURdID0gc3RhcnQgV2ktRmkgUHJvdGVjdGVkIFNldHVwOiBORkMiIH0sCisJeyAid3BzX25mY190b2tlbiIsIHdwYV9jbGlfY21kX3dwc19uZmNfdG9rZW4sCisJICBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI8V1BTfE5ERUY+ID0gY3JlYXRlIHBhc3N3b3JkIHRva2VuIiB9LAorCXsgIndwc19uZmNfdGFnX3JlYWQiLCB3cGFfY2xpX2NtZF93cHNfbmZjX3RhZ19yZWFkLAorCSAgY2xpX2NtZF9mbGFnX3NlbnNpdGl2ZSwKKwkgICI8aGV4ZHVtcCBvZiBwYXlsb2FkPiA9IHJlcG9ydCByZWFkIE5GQyB0YWcgd2l0aCBXUFMgZGF0YSIgfSwKKyNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwogCXsgIndwc19yZWciLCB3cGFfY2xpX2NtZF93cHNfcmVnLAogCSAgY2xpX2NtZF9mbGFnX3NlbnNpdGl2ZSwKIAkgICI8QlNTSUQ+IDxBUCBQSU4+ID0gc3RhcnQgV1BTIFJlZ2lzdHJhciB0byBjb25maWd1cmUgYW4gQVAiIH0sCkBAIC0yOTMwLDYgKzMyMzMsMTEgQEAKIAl7ICJ3cHNfZXJfY29uZmlnIiwgd3BhX2NsaV9jbWRfd3BzX2VyX2NvbmZpZywKIAkgIGNsaV9jbWRfZmxhZ19zZW5zaXRpdmUsCiAJICAiPFVVSUQ+IDxQSU4+IDxTU0lEPiA8YXV0aD4gPGVuY3I+IDxrZXk+ID0gY29uZmlndXJlIEFQIiB9LAorI2lmZGVmIENPTkZJR19XUFNfTkZDCisJeyAid3BzX2VyX25mY19jb25maWdfdG9rZW4iLCB3cGFfY2xpX2NtZF93cHNfZXJfbmZjX2NvbmZpZ190b2tlbiwKKwkgIGNsaV9jbWRfZmxhZ19ub25lLAorCSAgIjxXUFMvTkRFRj4gPFVVSUQ+ID0gYnVpbGQgTkZDIGNvbmZpZ3VyYXRpb24gdG9rZW4iIH0sCisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KIAl7ICJpYnNzX3JzbiIsIHdwYV9jbGlfY21kX2lic3NfcnNuLAogCSAgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPGFkZHI+ID0gcmVxdWVzdCBSU04gYXV0aGVudGljYXRpb24gd2l0aCA8YWRkcj4gaW4gSUJTUyIgfSwKQEAgLTI5NDAsNiArMzI0OCwxMiBAQAogCXsgImFsbF9zdGEiLCB3cGFfY2xpX2NtZF9hbGxfc3RhLAogCSAgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPSBnZXQgaW5mb3JtYXRpb24gYWJvdXQgYWxsIGFzc29jaWF0ZWQgc3RhdGlvbnMgKEFQKSIgfSwKKwl7ICJkZWF1dGhlbnRpY2F0ZSIsIHdwYV9jbGlfY21kX2RlYXV0aGVudGljYXRlLAorCSAgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiPGFkZHI+ID0gZGVhdXRoZW50aWNhdGUgYSBzdGF0aW9uIiB9LAorCXsgImRpc2Fzc29jaWF0ZSIsIHdwYV9jbGlfY21kX2Rpc2Fzc29jaWF0ZSwKKwkgIGNsaV9jbWRfZmxhZ19ub25lLAorCSAgIjxhZGRyPiA9IGRpc2Fzc29jaWF0ZSBhIHN0YXRpb24iIH0sCiAjZW5kaWYgLyogQ09ORklHX0FQICovCiAJeyAic3VzcGVuZCIsIHdwYV9jbGlfY21kX3N1c3BlbmQsIGNsaV9jbWRfZmxhZ19ub25lLAogCSAgIj0gbm90aWZpY2F0aW9uIG9mIHN1c3BlbmQvaGliZXJuYXRlIiB9LApAQCAtMzAzNCw2ICszMzQ4LDE0IEBACiAJeyAiYW5xcF9nZXQiLCB3cGFfY2xpX2NtZF9hbnFwX2dldCwgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPGFkZHI+IDxpbmZvIGlkPlssPGluZm8gaWQ+XS4uLiA9IHJlcXVlc3QgQU5RUCBpbmZvcm1hdGlvbiIgfSwKICNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCisjaWZkZWYgQ09ORklHX0hTMjAKKwl7ICJoczIwX2FucXBfZ2V0Iiwgd3BhX2NsaV9jbWRfaHMyMF9hbnFwX2dldCwgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiPGFkZHI+IDxzdWJ0eXBlPlssPHN1YnR5cGU+XS4uLiA9IHJlcXVlc3QgSFMgMi4wIEFOUVAgaW5mb3JtYXRpb24iCisJfSwKKwl7ICJuYWlfaG9tZV9yZWFsbV9saXN0Iiwgd3BhX2NsaV9jbWRfZ2V0X25haV9ob21lX3JlYWxtX2xpc3QsCisJICBjbGlfY21kX2ZsYWdfbm9uZSwKKwkgICI8YWRkcj4gPGhvbWUgcmVhbG0+ID0gZ2V0IEhTMjAgbmFpIGhvbWUgcmVhbG0gbGlzdCIgfSwKKyNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwogCXsgInN0YV9hdXRvY29ubmVjdCIsIHdwYV9jbGlfY21kX3N0YV9hdXRvY29ubmVjdCwgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPDAvMT4gPSBkaXNhYmxlL2VuYWJsZSBhdXRvbWF0aWMgcmVjb25uZWN0aW9uIiB9LAogCXsgInRkbHNfZGlzY292ZXIiLCB3cGFfY2xpX2NtZF90ZGxzX2Rpc2NvdmVyLApAQCAtMzA1MCw2ICszMzcyLDEwIEBACiAJICAiPSBnZXQgc2lnbmFsIHBhcmFtZXRlcnMiIH0sCiAJeyAicmVhdXRoZW50aWNhdGUiLCB3cGFfY2xpX2NtZF9yZWF1dGhlbnRpY2F0ZSwgY2xpX2NtZF9mbGFnX25vbmUsCiAJICAiPSB0cmlnZ2VyIElFRUUgODAyLjFYL0VBUE9MIHJlYXV0aGVudGljYXRpb24iIH0sCisjaWZkZWYgQ09ORklHX0FVVE9TQ0FOCisJeyAiYXV0b3NjYW4iLCB3cGFfY2xpX2NtZF9hdXRvc2NhbiwgY2xpX2NtZF9mbGFnX25vbmUsCisJICAiW3BhcmFtc10gPSBTZXQgb3IgdW5zZXQgKGlmIG5vbmUpIGF1dG9zY2FuIHBhcmFtZXRlcnMiIH0sCisjZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOICovCiAjaWZkZWYgQU5EUk9JRAogCXsgImRyaXZlciIsIHdwYV9jbGlfY21kX2RyaXZlciwKIAkgIGNsaV9jbWRfZmxhZ19ub25lLApAQCAtMzc1OCw4ICs0MDg0LDkgQEAKIAkJY3RybF9jb25uID0gd3BhX2N0cmxfb3BlbihnbG9iYWwpOwogI2VuZGlmIC8qIENPTkZJR19DVFJMX0lGQUNFX05BTUVEX1BJUEUgKi8KIAkJaWYgKGN0cmxfY29ubiA9PSBOVUxMKSB7Ci0JCQlwZXJyb3IoIkZhaWxlZCB0byBjb25uZWN0IHRvIHdwYV9zdXBwbGljYW50IC0gIgotCQkJICAgICAgICJ3cGFfY3RybF9vcGVuIik7CisJCQlmcHJpbnRmKHN0ZGVyciwgIkZhaWxlZCB0byBjb25uZWN0IHRvIHdwYV9zdXBwbGljYW50ICIKKwkJCQkiZ2xvYmFsIGludGVyZmFjZTogJXMgIGVycm9yOiAlc1xuIiwKKwkJCQlnbG9iYWwsIHN0cmVycm9yKGVycm5vKSk7CiAJCQlyZXR1cm4gLTE7CiAJCX0KIAl9CkBAIC0zNzgxLDggKzQxMDgsOCBAQAogCQkJfQogCiAJCQlpZiAoIXdhcm5pbmdfZGlzcGxheWVkKSB7Ci0JCQkJcHJpbnRmKCJDb3VsZCBub3QgY29ubmVjdCB0byB3cGFfc3VwcGxpY2FudCAtICIKLQkJCQkgICAgICAgInJlLXRyeWluZ1xuIik7CisJCQkJcHJpbnRmKCJDb3VsZCBub3QgY29ubmVjdCB0byB3cGFfc3VwcGxpY2FudDogIgorCQkJCSAgICAgICAiJXMgLSByZS10cnlpbmdcbiIsIGN0cmxfaWZuYW1lKTsKIAkJCQl3YXJuaW5nX2Rpc3BsYXllZCA9IDE7CiAJCQl9CiAJCQlvc19zbGVlcCgxLCAwKTsKQEAgLTM3OTEsOCArNDExOCw5IEBACiAJfSBlbHNlIHsKIAkJaWYgKCFnbG9iYWwgJiYKIAkJICAgIHdwYV9jbGlfb3Blbl9jb25uZWN0aW9uKGN0cmxfaWZuYW1lLCAwKSA8IDApIHsKLQkJCXBlcnJvcigiRmFpbGVkIHRvIGNvbm5lY3QgdG8gd3BhX3N1cHBsaWNhbnQgLSAiCi0JCQkgICAgICAgIndwYV9jdHJsX29wZW4iKTsKKwkJCWZwcmludGYoc3RkZXJyLCAiRmFpbGVkIHRvIGNvbm5lY3QgdG8gbm9uLWdsb2JhbCAiCisJCQkJImN0cmxfaWZuYW1lOiAlcyAgZXJyb3I6ICVzXG4iLAorCQkJCWN0cmxfaWZuYW1lLCBzdHJlcnJvcihlcnJubykpOwogCQkJcmV0dXJuIC0xOwogCQl9CiAKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwYV9ndWktcXQ0L3NpZ25hbGJhci5jcHAgYi93cGFfc3VwcGxpY2FudC93cGFfZ3VpLXF0NC9zaWduYWxiYXIuY3BwCmluZGV4IGYyNjg4ZDUuLjJiYmE1ODIgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwYV9ndWktcXQ0L3NpZ25hbGJhci5jcHAKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BhX2d1aS1xdDQvc2lnbmFsYmFyLmNwcApAQCAtMiwxNCArMiw4IEBACiAgKiB3cGFfZ3VpIC0gU2lnbmFsQmFyIGNsYXNzCiAgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIEtlbCBNb2RkZXJtYW4gPGtlbEBvdGFrdTQyLmRlPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCi0gKgotICogQWx0ZXJuYXRpdmVseSwgdGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIEJTRAotICogbGljZW5zZS4KLSAqCi0gKiBTZWUgUkVBRE1FIGFuZCBDT1BZSU5HIGZvciBtb3JlIGRldGFpbHMuCisgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgorICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgogICovCiAKICNpbmNsdWRlIDxjc3RkaW8+CmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93cGFfZ3VpLXF0NC9zaWduYWxiYXIuaCBiL3dwYV9zdXBwbGljYW50L3dwYV9ndWktcXQ0L3NpZ25hbGJhci5oCmluZGV4IDNkNWRlYzEuLjM3ZGE1ZGQgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwYV9ndWktcXQ0L3NpZ25hbGJhci5oCisrKyBiL3dwYV9zdXBwbGljYW50L3dwYV9ndWktcXQ0L3NpZ25hbGJhci5oCkBAIC0yLDE0ICsyLDggQEAKICAqIHdwYV9ndWkgLSBTaWduYWxCYXIgY2xhc3MKICAqIENvcHlyaWdodCAoYykgMjAxMSwgS2VsIE1vZGRlcm1hbiA8a2VsQG90YWt1NDIuZGU+CiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqCi0gKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgQlNECi0gKiBsaWNlbnNlLgotICoKLSAqIFNlZSBSRUFETUUgYW5kIENPUFlJTkcgZm9yIG1vcmUgZGV0YWlscy4KKyAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCisgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAogI2lmbmRlZiBTSUdOQUxCQVJfSApkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd3BhX2d1aS1xdDQvd3BhZ3VpLmNwcCBiL3dwYV9zdXBwbGljYW50L3dwYV9ndWktcXQ0L3dwYWd1aS5jcHAKaW5kZXggOTcyMTFlNC4uNDJlMTRmMCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd3BhX2d1aS1xdDQvd3BhZ3VpLmNwcAorKysgYi93cGFfc3VwcGxpY2FudC93cGFfZ3VpLXF0NC93cGFndWkuY3BwCkBAIC02LDE2ICs2LDEyIEBACiAgKiBTZWUgUkVBRE1FIGZvciBtb3JlIGRldGFpbHMuCiAgKi8KIAotI2lmZGVmIF9fTUlOR1czMl9fCi0vKiBOZWVkIHRvIGdldCBnZXRvcHQoKSAqLwotI2luY2x1ZGUgPHVuaXN0ZC5oPgotI2VuZGlmCi0KICNpZmRlZiBDT05GSUdfTkFUSVZFX1dJTkRPV1MKICNpbmNsdWRlIDx3aW5kb3dzLmg+CiAjZW5kaWYgLyogQ09ORklHX05BVElWRV9XSU5ET1dTICovCiAKICNpbmNsdWRlIDxjc3RkaW8+CisjaW5jbHVkZSA8dW5pc3RkLmg+CiAjaW5jbHVkZSA8UU1lc3NhZ2VCb3g+CiAjaW5jbHVkZSA8UUNsb3NlRXZlbnQ+CiAjaW5jbHVkZSA8UUltYWdlUmVhZGVyPgpAQCAtNzEzLDE3ICs3MDksMTMgQEAKIHZvaWQgV3BhR3VpOjpoZWxwQWJvdXQoKQogewogCVFNZXNzYWdlQm94OjphYm91dCh0aGlzLCAid3BhX2d1aSBmb3Igd3BhX3N1cHBsaWNhbnQiLAotCQkJICAgIkNvcHlyaWdodCAoYykgMjAwMy0yMDExLFxuIgorCQkJICAgIkNvcHlyaWdodCAoYykgMjAwMy0yMDEyLFxuIgogCQkJICAgIkpvdW5pIE1hbGluZW4gPGpAdzEuZmk+XG4iCiAJCQkgICAiYW5kIGNvbnRyaWJ1dG9ycy5cbiIKIAkJCSAgICJcbiIKLQkJCSAgICJUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZS4gWW91IGNhblxuIgotCQkJICAgImRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgIgotCQkJICAgIm9mXG4iCi0JCQkgICAidGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMi5cbiIKLQkJCSAgICJcbiIKLQkJCSAgICJBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZFxuIgotCQkJICAgInVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuXG4iCisJCQkgICAiVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXJcbiIKKwkJCSAgICJ0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLlxuIgorCQkJICAgIlNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy5cbiIKIAkJCSAgICJcbiIKIAkJCSAgICJUaGlzIHByb2R1Y3QgaW5jbHVkZXMgc29mdHdhcmUgZGV2ZWxvcGVkXG4iCiAJCQkgICAiYnkgdGhlIE9wZW5TU0wgUHJvamVjdCBmb3IgdXNlIGluIHRoZVxuIgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd3BhX3ByaXYuYyBiL3dwYV9zdXBwbGljYW50L3dwYV9wcml2LmMKaW5kZXggNzQ0NzZlMi4uYWQ2YTA4MCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd3BhX3ByaXYuYworKysgYi93cGFfc3VwcGxpY2FudC93cGFfcHJpdi5jCkBAIC02NDMsNyArNjQzLDcgQEAKIAkJCX0KIAkJCWlmIChiaW5kKGlmYWNlLT5mZCwgKHN0cnVjdCBzb2NrYWRkciAqKSAmYWRkciwKIAkJCQkgc2l6ZW9mKGFkZHIpKSA8IDApIHsKLQkJCQlwZXJyb3IoImJpbmQoUEZfVU5JWCkiKTsKKwkJCQlwZXJyb3IoIndwYS1wcml2LWlmYWNlLWluaXQ6IGJpbmQoUEZfVU5JWCkiKTsKIAkJCQlnb3RvIGZhaWw7CiAJCQl9CiAJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN1Y2Nlc3NmdWxseSByZXBsYWNlZCBsZWZ0b3ZlciAiCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudC5jIGIvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnQuYwppbmRleCBlMWFkNGQ5Li40N2FiZDlhIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudC5jCisrKyBiL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50LmMKQEAgLTQyLDkgKzQyLDExIEBACiAjaW5jbHVkZSAicDJwX3N1cHBsaWNhbnQuaCIKICNpbmNsdWRlICJub3RpZnkuaCIKICNpbmNsdWRlICJiZ3NjYW4uaCIKKyNpbmNsdWRlICJhdXRvc2Nhbi5oIgogI2luY2x1ZGUgImJzcy5oIgogI2luY2x1ZGUgInNjYW4uaCIKICNpbmNsdWRlICJvZmZjaGFubmVsLmgiCisjaW5jbHVkZSAiaHMyMF9zdXBwbGljYW50LmgiCiAKIGNvbnN0IGNoYXIgKndwYV9zdXBwbGljYW50X3ZlcnNpb24gPQogIndwYV9zdXBwbGljYW50IHYiIFZFUlNJT05fU1RSICJcbiIKQEAgLTM0OCw3ICszNTAsNyBAQAogfQogCiAKLXN0YXRpYyB2b2lkIGZyZWVfaHdfZmVhdHVyZXMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3ZvaWQgZnJlZV9od19mZWF0dXJlcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCWludCBpOwogCWlmICh3cGFfcy0+aHcubW9kZXMgPT0gTlVMTCkKQEAgLTM2Nyw2ICszNjksNyBAQAogc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfY2xlYW51cChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQogewogCWJnc2Nhbl9kZWluaXQod3BhX3MpOworCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7CiAJc2NhcmRfZGVpbml0KHdwYV9zLT5zY2FyZCk7CiAJd3BhX3MtPnNjYXJkID0gTlVMTDsKIAl3cGFfc21fc2V0X3NjYXJkX2N0eCh3cGFfcy0+d3BhLCBOVUxMKTsKQEAgLTQ0NSw2ICs0NDgsMTEgQEAKIAl3cGFfcy0+Z2FzID0gTlVMTDsKIAogCWZyZWVfaHdfZmVhdHVyZXMod3BhX3MpOworCisJb3NfZnJlZSh3cGFfcy0+YnNzaWRfZmlsdGVyKTsKKwl3cGFfcy0+YnNzaWRfZmlsdGVyID0gTlVMTDsKKworCXdubV9ic3Nfa2VlcF9hbGl2ZV9kZWluaXQod3BhX3MpOwogfQogCiAKQEAgLTU2NCw2ICs1NzIsMjkgQEAKICNlbmRpZiAvKiBDT05GSUdfQkdTQ0FOICovCiAKIAorc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfc3RhcnRfYXV0b3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAoYXV0b3NjYW5faW5pdCh3cGFfcywgMCkpCisJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkZhaWxlZCB0byBpbml0aWFsaXplIGF1dG9zY2FuIik7Cit9CisKKworc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfc3RvcF9hdXRvc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQoreworCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7Cit9CisKKwordm9pZCB3cGFfc3VwcGxpY2FudF9yZWluaXRfYXV0b3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKK3sKKwlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfRElTQ09OTkVDVEVEIHx8CisJICAgIHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX1NDQU5OSU5HKSB7CisJCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7CisJCXdwYV9zdXBwbGljYW50X3N0YXJ0X2F1dG9zY2FuKHdwYV9zKTsKKwl9Cit9CisKKwogLyoqCiAgKiB3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUgLSBTZXQgY3VycmVudCBjb25uZWN0aW9uIHN0YXRlCiAgKiBAd3BhX3M6IFBvaW50ZXIgdG8gd3BhX3N1cHBsaWNhbnQgZGF0YQpAQCAtNjEwLDYgKzY0MSw4IEBACiAjaWZkZWYgQ09ORklHX1AyUAogCQl3cGFzX3AycF9jb21wbGV0ZWQod3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KKworCQlzbWVfc2NoZWRfb2Jzc19zY2FuKHdwYV9zLCAxKTsKIAl9IGVsc2UgaWYgKHN0YXRlID09IFdQQV9ESVNDT05ORUNURUQgfHwgc3RhdGUgPT0gV1BBX0FTU09DSUFUSU5HIHx8CiAJCSAgIHN0YXRlID09IFdQQV9BU1NPQ0lBVEVEKSB7CiAJCXdwYV9zLT5uZXdfY29ubmVjdGlvbiA9IDE7CkBAIC02MTcsNiArNjUwLDcgQEAKICNpZm5kZWYgSUVFRTgwMjFYX0VBUE9MCiAJCXdwYV9kcnZfc2V0X3N1cHBfcG9ydCh3cGFfcywgMCk7CiAjZW5kaWYgLyogSUVFRTgwMjFYX0VBUE9MICovCisJCXNtZV9zY2hlZF9vYnNzX3NjYW4od3BhX3MsIDApOwogCX0KIAl3cGFfcy0+d3BhX3N0YXRlID0gc3RhdGU7CiAKQEAgLTYyNyw2ICs2NjEsMTIgQEAKIAkJd3BhX3N1cHBsaWNhbnRfc3RvcF9iZ3NjYW4od3BhX3MpOwogI2VuZGlmIC8qIENPTkZJR19CR1NDQU4gKi8KIAorCWlmIChzdGF0ZSA9PSBXUEFfQVVUSEVOVElDQVRJTkcpCisJCXdwYV9zdXBwbGljYW50X3N0b3BfYXV0b3NjYW4od3BhX3MpOworCisJaWYgKHN0YXRlID09IFdQQV9ESVNDT05ORUNURUQgfHwgc3RhdGUgPT0gV1BBX0lOQUNUSVZFKQorCQl3cGFfc3VwcGxpY2FudF9zdGFydF9hdXRvc2Nhbih3cGFfcyk7CisKIAlpZiAod3BhX3MtPndwYV9zdGF0ZSAhPSBvbGRfc3RhdGUpIHsKIAkJd3Bhc19ub3RpZnlfc3RhdGVfY2hhbmdlZCh3cGFfcywgd3BhX3MtPndwYV9zdGF0ZSwgb2xkX3N0YXRlKTsKIApAQCAtNjcwLDcgKzcxMCw3IEBACiAJd3BhX3MtPm1nbXRfZ3JvdXBfY2lwaGVyID0gMDsKIAl3cGFfcy0+a2V5X21nbXQgPSAwOwogCWlmICh3cGFfcy0+d3BhX3N0YXRlICE9IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpCi0JCXdwYV9zLT53cGFfc3RhdGUgPSBXUEFfRElTQ09OTkVDVEVEOworCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9ESVNDT05ORUNURUQpOwogCiAJaWYgKHdwYV9zLT53cGFfc3RhdGUgIT0gb2xkX3N0YXRlKQogCQl3cGFzX25vdGlmeV9zdGF0ZV9jaGFuZ2VkKHdwYV9zLCB3cGFfcy0+d3BhX3N0YXRlLCBvbGRfc3RhdGUpOwpAQCAtNzQ5LDcgKzc4OSw3IEBACiAJd3BhX3N1cHBsaWNhbnRfdXBkYXRlX2NvbmZpZyh3cGFfcyk7CiAKIAl3cGFfc3VwcGxpY2FudF9jbGVhcl9zdGF0dXMod3BhX3MpOwotCWlmICh3cGFfc3VwcGxpY2FudF9lbmFibGVkX25ldHdvcmtzKHdwYV9zLT5jb25mKSkgeworCWlmICh3cGFfc3VwcGxpY2FudF9lbmFibGVkX25ldHdvcmtzKHdwYV9zKSkgewogCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwogCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7CiAJfQpAQCAtMTI1NCwxMSArMTI5NCwxMCBAQAogCQl1OCAqcG9zOwogCQlzaXplX3QgbGVuOwogCQlpbnQgcmVzOwotCQlpbnQgcDJwX2dyb3VwOwotCQlwMnBfZ3JvdXAgPSB3cGFfcy0+ZHJ2X2ZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19QMlBfQ0FQQUJMRTsKIAkJcG9zID0gd3BhX2llICsgd3BhX2llX2xlbjsKIAkJbGVuID0gc2l6ZW9mKHdwYV9pZSkgLSB3cGFfaWVfbGVuOwotCQlyZXMgPSB3cGFzX3AycF9hc3NvY19yZXFfaWUod3BhX3MsIGJzcywgcG9zLCBsZW4sIHAycF9ncm91cCk7CisJCXJlcyA9IHdwYXNfcDJwX2Fzc29jX3JlcV9pZSh3cGFfcywgYnNzLCBwb3MsIGxlbiwKKwkJCQkJICAgIHNzaWQtPnAycF9ncm91cCk7CiAJCWlmIChyZXMgPj0gMCkKIAkJCXdwYV9pZV9sZW4gKz0gcmVzOwogCX0KQEAgLTEyNzksNiArMTMxOCwyMCBAQAogCX0KICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKKyNpZmRlZiBDT05GSUdfSFMyMAorCWlmICh3cGFfcy0+Y29uZi0+aHMyMCkgeworCQlzdHJ1Y3Qgd3BhYnVmICpoczIwOworCQloczIwID0gd3BhYnVmX2FsbG9jKDIwKTsKKwkJaWYgKGhzMjApIHsKKwkJCXdwYXNfaHMyMF9hZGRfaW5kaWNhdGlvbihoczIwKTsKKwkJCW9zX21lbWNweSh3cGFfaWUgKyB3cGFfaWVfbGVuLCB3cGFidWZfaGVhZChoczIwKSwKKwkJCQkgIHdwYWJ1Zl9sZW4oaHMyMCkpOworCQkJd3BhX2llX2xlbiArPSB3cGFidWZfbGVuKGhzMjApOworCQkJd3BhYnVmX2ZyZWUoaHMyMCk7CisJCX0KKwl9CisjZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KKwogI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKIAlpZiAod3BhX3MtPmNvbmYtPmludGVyd29ya2luZykgewogCQl1OCAqcG9zID0gd3BhX2llOwpAQCAtMTMzNiw3ICsxMzg5LDEyIEBACiAJaWYgKGJzcykgewogCQlwYXJhbXMuc3NpZCA9IGJzcy0+c3NpZDsKIAkJcGFyYW1zLnNzaWRfbGVuID0gYnNzLT5zc2lkX2xlbjsKLQkJaWYgKCF3cGFzX2RyaXZlcl9ic3Nfc2VsZWN0aW9uKHdwYV9zKSkgeworCQlpZiAoIXdwYXNfZHJpdmVyX2Jzc19zZWxlY3Rpb24od3BhX3MpIHx8IHNzaWQtPmJzc2lkX3NldCkgeworCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJMaW1pdCBjb25uZWN0aW9uIHRvIEJTU0lEICIKKwkJCQkgICBNQUNTVFIgIiBmcmVxPSV1IE1IeiBiYXNlZCBvbiBzY2FuIHJlc3VsdHMgIgorCQkJCSAgICIoYnNzaWRfc2V0PSVkKSIsCisJCQkJICAgTUFDMlNUUihic3MtPmJzc2lkKSwgYnNzLT5mcmVxLAorCQkJCSAgIHNzaWQtPmJzc2lkX3NldCk7CiAJCQlwYXJhbXMuYnNzaWQgPSBic3MtPmJzc2lkOwogCQkJcGFyYW1zLmZyZXEgPSBic3MtPmZyZXE7CiAJCX0KQEAgLTEzNjIsNiArMTQyMCw3IEBACiAJcGFyYW1zLndwYV9wcm90byA9IHdwYV9zLT53cGFfcHJvdG87CiAJcGFyYW1zLmF1dGhfYWxnID0gYWxnczsKIAlwYXJhbXMubW9kZSA9IHNzaWQtPm1vZGU7CisJcGFyYW1zLmJnX3NjYW5fcGVyaW9kID0gc3NpZC0+Ymdfc2Nhbl9wZXJpb2Q7CiAJZm9yIChpID0gMDsgaSA8IE5VTV9XRVBfS0VZUzsgaSsrKSB7CiAJCWlmIChzc2lkLT53ZXBfa2V5X2xlbltpXSkKIAkJCXBhcmFtcy53ZXBfa2V5W2ldID0gc3NpZC0+d2VwX2tleVtpXTsKQEAgLTE0NDEsNiArMTUwMCw3IEBACiAJCQkgKiBzdWNjZWVkLgogCQkJICovCiAJCQl3cGFzX2Nvbm5lY3Rpb25fZmFpbGVkKHdwYV9zLCB3cGFfcy0+cGVuZGluZ19ic3NpZCk7CisJCQl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9ESVNDT05ORUNURUQpOwogCQkJb3NfbWVtc2V0KHdwYV9zLT5wZW5kaW5nX2Jzc2lkLCAwLCBFVEhfQUxFTik7CiAJCQlyZXR1cm47CiAJCX0KQEAgLTE1MzQsMTAgKzE1OTQsMTUgQEAKIAkJCQkgaW50IHJlYXNvbl9jb2RlKQogewogCXU4ICphZGRyID0gTlVMTDsKKwl1bmlvbiB3cGFfZXZlbnRfZGF0YSBldmVudDsKIAogCWlmICghaXNfemVyb19ldGhlcl9hZGRyKHdwYV9zLT5ic3NpZCkpIHsKIAkJd3BhX2Rydl9kaXNhc3NvY2lhdGUod3BhX3MsIHdwYV9zLT5ic3NpZCwgcmVhc29uX2NvZGUpOwogCQlhZGRyID0gd3BhX3MtPmJzc2lkOworCQlvc19tZW1zZXQoJmV2ZW50LCAwLCBzaXplb2YoZXZlbnQpKTsKKwkJZXZlbnQuZGlzYXNzb2NfaW5mby5yZWFzb25fY29kZSA9ICh1MTYpIHJlYXNvbl9jb2RlOworCQlldmVudC5kaXNhc3NvY19pbmZvLmxvY2FsbHlfZ2VuZXJhdGVkID0gMTsKKwkJd3BhX3N1cHBsaWNhbnRfZXZlbnQod3BhX3MsIEVWRU5UX0RJU0FTU09DLCAmZXZlbnQpOwogCX0KIAogCXdwYV9zdXBwbGljYW50X2NsZWFyX2Nvbm5lY3Rpb24od3BhX3MsIGFkZHIpOwpAQCAtMTU1NiwxMCArMTYyMSwxNSBAQAogCQkJCSAgIGludCByZWFzb25fY29kZSkKIHsKIAl1OCAqYWRkciA9IE5VTEw7CisJdW5pb24gd3BhX2V2ZW50X2RhdGEgZXZlbnQ7CiAKIAlpZiAoIWlzX3plcm9fZXRoZXJfYWRkcih3cGFfcy0+YnNzaWQpKSB7CiAJCXdwYV9kcnZfZGVhdXRoZW50aWNhdGUod3BhX3MsIHdwYV9zLT5ic3NpZCwgcmVhc29uX2NvZGUpOwogCQlhZGRyID0gd3BhX3MtPmJzc2lkOworCQlvc19tZW1zZXQoJmV2ZW50LCAwLCBzaXplb2YoZXZlbnQpKTsKKwkJZXZlbnQuZGVhdXRoX2luZm8ucmVhc29uX2NvZGUgPSAodTE2KSByZWFzb25fY29kZTsKKwkJZXZlbnQuZGVhdXRoX2luZm8ubG9jYWxseV9nZW5lcmF0ZWQgPSAxOworCQl3cGFfc3VwcGxpY2FudF9ldmVudCh3cGFfcywgRVZFTlRfREVBVVRILCAmZXZlbnQpOwogCX0KIAogCXdwYV9zdXBwbGljYW50X2NsZWFyX2Nvbm5lY3Rpb24od3BhX3MsIGFkZHIpOwpAQCAtMTc5OSw2ICsxODY5LDI5IEBACiAKIAogLyoqCisgKiB3cGFfc3VwcGxpY2FudF9zZXRfc2Nhbl9pbnRlcnZhbCAtIFNldCBzY2FuIGludGVydmFsCisgKiBAd3BhX3M6IHdwYV9zdXBwbGljYW50IHN0cnVjdHVyZSBmb3IgYSBuZXR3b3JrIGludGVyZmFjZQorICogQHNjYW5faW50ZXJ2YWw6IHNjYW4gaW50ZXJ2YWwgaW4gc2Vjb25kcworICogUmV0dXJuczogMCBpZiBzdWNjZWVkIG9yIC0xIGlmIHNjYW5faW50ZXJ2YWwgaGFzIGFuIGludmFsaWQgdmFsdWUKKyAqCisgKi8KK2ludCB3cGFfc3VwcGxpY2FudF9zZXRfc2Nhbl9pbnRlcnZhbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgaW50IHNjYW5faW50ZXJ2YWwpCit7CisJaWYgKHNjYW5faW50ZXJ2YWwgPCAwKSB7CisJCXdwYV9tc2cod3BhX3MsIE1TR19FUlJPUiwgIkludmFsaWQgc2NhbiBpbnRlcnZhbCAlZCIsCisJCQlzY2FuX2ludGVydmFsKTsKKwkJcmV0dXJuIC0xOworCX0KKwl3cGFfbXNnKHdwYV9zLCBNU0dfREVCVUcsICJTZXR0aW5nIHNjYW4gaW50ZXJ2YWw6ICVkIHNlYyIsCisJCXNjYW5faW50ZXJ2YWwpOworCXdwYV9zLT5zY2FuX2ludGVydmFsID0gc2Nhbl9pbnRlcnZhbDsKKworCXJldHVybiAwOworfQorCisKKy8qKgogICogd3BhX3N1cHBsaWNhbnRfc2V0X2RlYnVnX3BhcmFtcyAtIFNldCBnbG9iYWwgZGVidWcgcGFyYW1zCiAgKiBAZ2xvYmFsOiB3cGFfZ2xvYmFsIHN0cnVjdHVyZQogICogQGRlYnVnX2xldmVsOiBkZWJ1ZyBsZXZlbApAQCAtMTg3MywxNCArMTk2NiwxNCBAQAogCiAJZW50cnkgPSB3cGFfcy0+Y29uZi0+c3NpZDsKIAl3aGlsZSAoZW50cnkpIHsKLQkJaWYgKCFlbnRyeS0+ZGlzYWJsZWQgJiYKKwkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIGVudHJ5KSAmJgogCQkgICAgKChzc2lkX2xlbiA9PSBlbnRyeS0+c3NpZF9sZW4gJiYKIAkJICAgICAgb3NfbWVtY21wKHNzaWQsIGVudHJ5LT5zc2lkLCBzc2lkX2xlbikgPT0gMCkgfHwgd2lyZWQpICYmCiAJCSAgICAoIWVudHJ5LT5ic3NpZF9zZXQgfHwKIAkJICAgICBvc19tZW1jbXAoYnNzaWQsIGVudHJ5LT5ic3NpZCwgRVRIX0FMRU4pID09IDApKQogCQkJcmV0dXJuIGVudHJ5OwogI2lmZGVmIENPTkZJR19XUFMKLQkJaWYgKCFlbnRyeS0+ZGlzYWJsZWQgJiYKKwkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIGVudHJ5KSAmJgogCQkgICAgKGVudHJ5LT5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9XUFMpICYmCiAJCSAgICAoZW50cnktPnNzaWQgPT0gTlVMTCB8fCBlbnRyeS0+c3NpZF9sZW4gPT0gMCkgJiYKIAkJICAgICghZW50cnktPmJzc2lkX3NldCB8fApAQCAtMTg4OCw3ICsxOTgxLDcgQEAKIAkJCXJldHVybiBlbnRyeTsKICNlbmRpZiAvKiBDT05GSUdfV1BTICovCiAKLQkJaWYgKCFlbnRyeS0+ZGlzYWJsZWQgJiYgZW50cnktPmJzc2lkX3NldCAmJgorCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgZW50cnkpICYmIGVudHJ5LT5ic3NpZF9zZXQgJiYKIAkJICAgIGVudHJ5LT5zc2lkX2xlbiA9PSAwICYmCiAJCSAgICBvc19tZW1jbXAoYnNzaWQsIGVudHJ5LT5ic3NpZCwgRVRIX0FMRU4pID09IDApCiAJCQlyZXR1cm4gZW50cnk7CkBAIC0yMTExLDYgKzIyMDQsMzEgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFfc3VwcGxpY2FudF9yeF9lYXBvbF9icmlkZ2Uodm9pZCAqY3R4LCBjb25zdCB1OCAqc3JjX2FkZHIsCisJCQkJCSAgIGNvbnN0IHU4ICpidWYsIHNpemVfdCBsZW4pCit7CisJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyA9IGN0eDsKKwljb25zdCBzdHJ1Y3QgbDJfZXRoaGRyICpldGg7CisKKwlpZiAobGVuIDwgc2l6ZW9mKCpldGgpKQorCQlyZXR1cm47CisJZXRoID0gKGNvbnN0IHN0cnVjdCBsMl9ldGhoZHIgKikgYnVmOworCisJaWYgKG9zX21lbWNtcChldGgtPmhfZGVzdCwgd3BhX3MtPm93bl9hZGRyLCBFVEhfQUxFTikgIT0gMCAmJgorCSAgICAhKGV0aC0+aF9kZXN0WzBdICYgMHgwMSkpIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUlggRUFQT0wgZnJvbSAiIE1BQ1NUUiAiIHRvICIgTUFDU1RSCisJCQkiIChicmlkZ2UgLSBub3QgZm9yIHRoaXMgaW50ZXJmYWNlIC0gaWdub3JlKSIsCisJCQlNQUMyU1RSKHNyY19hZGRyKSwgTUFDMlNUUihldGgtPmhfZGVzdCkpOworCQlyZXR1cm47CisJfQorCisJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUlggRUFQT0wgZnJvbSAiIE1BQ1NUUiAiIHRvICIgTUFDU1RSCisJCSIgKGJyaWRnZSkiLCBNQUMyU1RSKHNyY19hZGRyKSwgTUFDMlNUUihldGgtPmhfZGVzdCkpOworCXdwYV9zdXBwbGljYW50X3J4X2VhcG9sKHdwYV9zLCBzcmNfYWRkciwgYnVmICsgc2l6ZW9mKCpldGgpLAorCQkJCWxlbiAtIHNpemVvZigqZXRoKSk7Cit9CisKKwogLyoqCiAgKiB3cGFfc3VwcGxpY2FudF9kcml2ZXJfaW5pdCAtIEluaXRpYWxpemUgZHJpdmVyIGludGVyZmFjZSBwYXJhbWV0ZXJzCiAgKiBAd3BhX3M6IFBvaW50ZXIgdG8gd3BhX3N1cHBsaWNhbnQgZGF0YQpAQCAtMjEzMyw4ICsyMjUxLDggQEAKIAkJd3BhX3MtPmwyX2JyID0gbDJfcGFja2V0X2luaXQod3BhX3MtPmJyaWRnZV9pZm5hbWUsCiAJCQkJCSAgICAgIHdwYV9zLT5vd25fYWRkciwKIAkJCQkJICAgICAgRVRIX1BfRUFQT0wsCi0JCQkJCSAgICAgIHdwYV9zdXBwbGljYW50X3J4X2VhcG9sLCB3cGFfcywKLQkJCQkJICAgICAgMCk7CisJCQkJCSAgICAgIHdwYV9zdXBwbGljYW50X3J4X2VhcG9sX2JyaWRnZSwKKwkJCQkJICAgICAgd3BhX3MsIDEpOwogCQlpZiAod3BhX3MtPmwyX2JyID09IE5VTEwpIHsKIAkJCXdwYV9tc2cod3BhX3MsIE1TR19FUlJPUiwgIkZhaWxlZCB0byBvcGVuIGwyX3BhY2tldCAiCiAJCQkJImNvbm5lY3Rpb24gZm9yIHRoZSBicmlkZ2UgaW50ZXJmYWNlICclcyciLApAQCAtMjE1NSw3ICsyMjczLDcgQEAKIAl3cGFfcy0+cHJldl9zY2FuX3NzaWQgPSBXSUxEQ0FSRF9TU0lEX1NDQU47CiAJd3BhX3MtPnByZXZfc2Nhbl93aWxkY2FyZCA9IDA7CiAKLQlpZiAod3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3Jrcyh3cGFfcy0+Y29uZikpIHsKKwlpZiAod3BhX3N1cHBsaWNhbnRfZW5hYmxlZF9uZXR3b3Jrcyh3cGFfcykpIHsKIAkJaWYgKHdwYV9zdXBwbGljYW50X2RlbGF5ZWRfc2NoZWRfc2Nhbih3cGFfcywgaW50ZXJmYWNlX2NvdW50LAogCQkJCQkJICAgICAgMTAwMDAwKSkKIAkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCBpbnRlcmZhY2VfY291bnQsCkBAIC0yMzY5LDYgKzI0ODcsNDggQEAKICNlbmRpZiAvKiBDT05GSUdfSFRfT1ZFUlJJREVTICovCiAKIAorc3RhdGljIGludCBwY3NjX3JlYWRlcl9pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCit7CisjaWZkZWYgUENTQ19GVU5DUworCXNpemVfdCBsZW47CisKKwlpZiAoIXdwYV9zLT5jb25mLT5wY3NjX3JlYWRlcikKKwkJcmV0dXJuIDA7CisKKwl3cGFfcy0+c2NhcmQgPSBzY2FyZF9pbml0KFNDQVJEX1RSWV9CT1RILCB3cGFfcy0+Y29uZi0+cGNzY19yZWFkZXIpOworCWlmICghd3BhX3MtPnNjYXJkKQorCQlyZXR1cm4gMTsKKworCWlmICh3cGFfcy0+Y29uZi0+cGNzY19waW4gJiYKKwkgICAgc2NhcmRfc2V0X3Bpbih3cGFfcy0+c2NhcmQsIHdwYV9zLT5jb25mLT5wY3NjX3BpbikgPCAwKSB7CisJCXNjYXJkX2RlaW5pdCh3cGFfcy0+c2NhcmQpOworCQl3cGFfcy0+c2NhcmQgPSBOVUxMOworCQl3cGFfbXNnKHdwYV9zLCBNU0dfRVJST1IsICJQQy9TQyBQSU4gdmFsaWRhdGlvbiBmYWlsZWQiKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWxlbiA9IHNpemVvZih3cGFfcy0+aW1zaSkgLSAxOworCWlmIChzY2FyZF9nZXRfaW1zaSh3cGFfcy0+c2NhcmQsIHdwYV9zLT5pbXNpLCAmbGVuKSkgeworCQlzY2FyZF9kZWluaXQod3BhX3MtPnNjYXJkKTsKKwkJd3BhX3MtPnNjYXJkID0gTlVMTDsKKwkJd3BhX21zZyh3cGFfcywgTVNHX0VSUk9SLCAiQ291bGQgbm90IHJlYWQgSU1TSSIpOworCQlyZXR1cm4gLTE7CisJfQorCXdwYV9zLT5pbXNpW2xlbl0gPSAnXDAnOworCisJd3BhX3MtPm1uY19sZW4gPSBzY2FyZF9nZXRfbW5jX2xlbih3cGFfcy0+c2NhcmQpOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTQ0FSRDogSU1TSSAlcyAoTU5DIGxlbmd0aCAlZCkiLAorCQkgICB3cGFfcy0+aW1zaSwgd3BhX3MtPm1uY19sZW4pOworCisJd3BhX3NtX3NldF9zY2FyZF9jdHgod3BhX3MtPndwYSwgd3BhX3MtPnNjYXJkKTsKKwllYXBvbF9zbV9yZWdpc3Rlcl9zY2FyZF9jdHgod3BhX3MtPmVhcG9sLCB3cGFfcy0+c2NhcmQpOworI2VuZGlmIC8qIFBDU0NfRlVOQ1MgKi8KKworCXJldHVybiAwOworfQorCisKIHN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfaW5pdF9pZmFjZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICAgc3RydWN0IHdwYV9pbnRlcmZhY2UgKmlmYWNlKQogewpAQCAtMjUyOCw2ICsyNjg4LDcgQEAKIAlpZiAod3BhX2Rydl9nZXRfY2FwYSh3cGFfcywgJmNhcGEpID09IDApIHsKIAkJd3BhX3MtPmRydl9jYXBhX2tub3duID0gMTsKIAkJd3BhX3MtPmRydl9mbGFncyA9IGNhcGEuZmxhZ3M7CisJCXdwYV9zLT5kcnZfZW5jID0gY2FwYS5lbmM7CiAJCXdwYV9zLT5wcm9iZV9yZXNwX29mZmxvYWRzID0gY2FwYS5wcm9iZV9yZXNwX29mZmxvYWRzOwogCQl3cGFfcy0+bWF4X3NjYW5fc3NpZHMgPSBjYXBhLm1heF9zY2FuX3NzaWRzOwogCQl3cGFfcy0+bWF4X3NjaGVkX3NjYW5fc3NpZHMgPSBjYXBhLm1heF9zY2hlZF9zY2FuX3NzaWRzOwpAQCAtMjU5MCw2ICsyNzUxLDkgQEAKIAlpZiAod3BhX2Jzc19pbml0KHdwYV9zKSA8IDApCiAJCXJldHVybiAtMTsKIAorCWlmIChwY3NjX3JlYWRlcl9pbml0KHdwYV9zKSA8IDApCisJCXJldHVybiAtMTsKKwogCXJldHVybiAwOwogfQogCkBAIC0yNjA3LDYgKzI3NzEsMTQgQEAKIAogCXdwYV9zdXBwbGljYW50X2NsZWFudXAod3BhX3MpOwogCisjaWZkZWYgQ09ORklHX1AyUAorCWlmICh3cGFfcyA9PSB3cGFfcy0+Z2xvYmFsLT5wMnBfaW5pdF93cGFfcyAmJiB3cGFfcy0+Z2xvYmFsLT5wMnApIHsKKwkJd3BhX2RiZyh3cGFfcywgTVNHX0RFQlVHLCAiUDJQOiBEaXNhYmxlIFAyUCBzaW5jZSByZW1vdmluZyAiCisJCQkidGhlIG1hbmFnZW1lbnQgaW50ZXJmYWNlIGlzIGJlaW5nIHJlbW92ZWQiKTsKKwkJd3Bhc19wMnBfZGVpbml0X2dsb2JhbCh3cGFfcy0+Z2xvYmFsKTsKKwl9CisjZW5kaWYgLyogQ09ORklHX1AyUCAqLworCiAJaWYgKHdwYV9zLT5kcnZfcHJpdikKIAkJd3BhX2Rydl9kZWluaXQod3BhX3MpOwogCkBAIC0yNjkzLDYgKzI4NjUsNyBAQAogCWdsb2JhbC0+aWZhY2VzID0gd3BhX3M7CiAKIAl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJBZGRlZCBpbnRlcmZhY2UgJXMiLCB3cGFfcy0+aWZuYW1lKTsKKwl3cGFfc3VwcGxpY2FudF9zZXRfc3RhdGUod3BhX3MsIFdQQV9ESVNDT05ORUNURUQpOwogCiAJcmV0dXJuIHdwYV9zOwogfQpAQCAtMjgyMSw2ICsyOTk0LDE0IEBACiAJd3BhX2RlYnVnX29wZW5fZmlsZShwYXJhbXMtPndwYV9kZWJ1Z19maWxlX3BhdGgpOwogCWlmIChwYXJhbXMtPndwYV9kZWJ1Z19zeXNsb2cpCiAJCXdwYV9kZWJ1Z19vcGVuX3N5c2xvZygpOworCWlmIChwYXJhbXMtPndwYV9kZWJ1Z190cmFjaW5nKSB7CisJCXJldCA9IHdwYV9kZWJ1Z19vcGVuX2xpbnV4X3RyYWNpbmcoKTsKKwkJaWYgKHJldCkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsCisJCQkJICAgIkZhaWxlZCB0byBlbmFibGUgdHJhY2UgbG9nZ2luZyIpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9CiAKIAlyZXQgPSBlYXBfcmVnaXN0ZXJfbWV0aG9kcygpOwogCWlmIChyZXQpIHsKQEAgLTI5NzgsOSArMzE1OSwxMiBAQAogCW9zX2ZyZWUoZ2xvYmFsLT5wYXJhbXMub3ZlcnJpZGVfZHJpdmVyKTsKIAlvc19mcmVlKGdsb2JhbC0+cGFyYW1zLm92ZXJyaWRlX2N0cmxfaW50ZXJmYWNlKTsKIAorCW9zX2ZyZWUoZ2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSk7CisKIAlvc19mcmVlKGdsb2JhbCk7CiAJd3BhX2RlYnVnX2Nsb3NlX3N5c2xvZygpOwogCXdwYV9kZWJ1Z19jbG9zZV9maWxlKCk7CisJd3BhX2RlYnVnX2Nsb3NlX2xpbnV4X3RyYWNpbmcoKTsKIH0KIAogCkBAIC0zMTI5LDE1ICszMzEzLDExOSBAQAogCQkod3BhX3MtPmRydl9mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfQlNTX1NFTEVDVElPTik7CiB9CiAKLSNpZmRlZiBBTkRST0lEX1AyUAorCisjaWYgZGVmaW5lZChDT05GSUdfQ1RSTF9JRkFDRSkgfHwgZGVmaW5lZChDT05GSUdfQ1RSTF9JRkFDRV9EQlVTX05FVykKK2ludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2N0cmxfcnNwX2hhbmRsZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsCisJCQkJCSAgICAgIGNvbnN0IGNoYXIgKmZpZWxkLAorCQkJCQkgICAgICBjb25zdCBjaGFyICp2YWx1ZSkKK3sKKyNpZmRlZiBJRUVFODAyMVhfRUFQT0wKKwlzdHJ1Y3QgZWFwX3BlZXJfY29uZmlnICplYXAgPSAmc3NpZC0+ZWFwOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiByZXNwb25zZSBoYW5kbGUgZmllbGQ9JXMiLCBmaWVsZCk7CisJd3BhX2hleGR1bXBfYXNjaWlfa2V5KE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IHJlc3BvbnNlIHZhbHVlIiwKKwkJCSAgICAgIChjb25zdCB1OCAqKSB2YWx1ZSwgb3Nfc3RybGVuKHZhbHVlKSk7CisKKwlzd2l0Y2ggKHdwYV9zdXBwbGljYW50X2N0cmxfcmVxX2Zyb21fc3RyaW5nKGZpZWxkKSkgeworCWNhc2UgV1BBX0NUUkxfUkVRX0VBUF9JREVOVElUWToKKwkJb3NfZnJlZShlYXAtPmlkZW50aXR5KTsKKwkJZWFwLT5pZGVudGl0eSA9ICh1OCAqKSBvc19zdHJkdXAodmFsdWUpOworCQllYXAtPmlkZW50aXR5X2xlbiA9IG9zX3N0cmxlbih2YWx1ZSk7CisJCWVhcC0+cGVuZGluZ19yZXFfaWRlbnRpdHkgPSAwOworCQlpZiAoc3NpZCA9PSB3cGFfcy0+Y3VycmVudF9zc2lkKQorCQkJd3BhX3MtPnJlYXNzb2NpYXRlID0gMTsKKwkJYnJlYWs7CisJY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX1BBU1NXT1JEOgorCQlvc19mcmVlKGVhcC0+cGFzc3dvcmQpOworCQllYXAtPnBhc3N3b3JkID0gKHU4ICopIG9zX3N0cmR1cCh2YWx1ZSk7CisJCWVhcC0+cGFzc3dvcmRfbGVuID0gb3Nfc3RybGVuKHZhbHVlKTsKKwkJZWFwLT5wZW5kaW5nX3JlcV9wYXNzd29yZCA9IDA7CisJCWlmIChzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQpCisJCQl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOworCQlicmVhazsKKwljYXNlIFdQQV9DVFJMX1JFUV9FQVBfTkVXX1BBU1NXT1JEOgorCQlvc19mcmVlKGVhcC0+bmV3X3Bhc3N3b3JkKTsKKwkJZWFwLT5uZXdfcGFzc3dvcmQgPSAodTggKikgb3Nfc3RyZHVwKHZhbHVlKTsKKwkJZWFwLT5uZXdfcGFzc3dvcmRfbGVuID0gb3Nfc3RybGVuKHZhbHVlKTsKKwkJZWFwLT5wZW5kaW5nX3JlcV9uZXdfcGFzc3dvcmQgPSAwOworCQlpZiAoc3NpZCA9PSB3cGFfcy0+Y3VycmVudF9zc2lkKQorCQkJd3BhX3MtPnJlYXNzb2NpYXRlID0gMTsKKwkJYnJlYWs7CisJY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX1BJTjoKKwkJb3NfZnJlZShlYXAtPnBpbik7CisJCWVhcC0+cGluID0gb3Nfc3RyZHVwKHZhbHVlKTsKKwkJZWFwLT5wZW5kaW5nX3JlcV9waW4gPSAwOworCQlpZiAoc3NpZCA9PSB3cGFfcy0+Y3VycmVudF9zc2lkKQorCQkJd3BhX3MtPnJlYXNzb2NpYXRlID0gMTsKKwkJYnJlYWs7CisJY2FzZSBXUEFfQ1RSTF9SRVFfRUFQX09UUDoKKwkJb3NfZnJlZShlYXAtPm90cCk7CisJCWVhcC0+b3RwID0gKHU4ICopIG9zX3N0cmR1cCh2YWx1ZSk7CisJCWVhcC0+b3RwX2xlbiA9IG9zX3N0cmxlbih2YWx1ZSk7CisJCW9zX2ZyZWUoZWFwLT5wZW5kaW5nX3JlcV9vdHApOworCQllYXAtPnBlbmRpbmdfcmVxX290cCA9IE5VTEw7CisJCWVhcC0+cGVuZGluZ19yZXFfb3RwX2xlbiA9IDA7CisJCWJyZWFrOworCWNhc2UgV1BBX0NUUkxfUkVRX0VBUF9QQVNTUEhSQVNFOgorCQlvc19mcmVlKGVhcC0+cHJpdmF0ZV9rZXlfcGFzc3dkKTsKKwkJZWFwLT5wcml2YXRlX2tleV9wYXNzd2QgPSAodTggKikgb3Nfc3RyZHVwKHZhbHVlKTsKKwkJZWFwLT5wZW5kaW5nX3JlcV9wYXNzcGhyYXNlID0gMDsKKwkJaWYgKHNzaWQgPT0gd3BhX3MtPmN1cnJlbnRfc3NpZCkKKwkJCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogVW5rbm93biBmaWVsZCAnJXMnIiwgZmllbGQpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7CisjZWxzZSAvKiBJRUVFODAyMVhfRUFQT0wgKi8KKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IElFRUUgODAyLjFYIG5vdCBpbmNsdWRlZCIpOworCXJldHVybiAtMTsKKyNlbmRpZiAvKiBJRUVFODAyMVhfRUFQT0wgKi8KK30KKyNlbmRpZiAvKiBDT05GSUdfQ1RSTF9JRkFDRSB8fCBDT05GSUdfQ1RSTF9JRkFDRV9EQlVTX05FVyAqLworCisKK2ludCB3cGFzX25ldHdvcmtfZGlzYWJsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9zc2lkICpzc2lkKQoreworCWludCBpOworCXVuc2lnbmVkIGludCBkcnZfZW5jOworCisJaWYgKHNzaWQgPT0gTlVMTCkKKwkJcmV0dXJuIDE7CisKKwlpZiAoc3NpZC0+ZGlzYWJsZWQpCisJCXJldHVybiAxOworCisJaWYgKHdwYV9zICYmIHdwYV9zLT5kcnZfY2FwYV9rbm93bikKKwkJZHJ2X2VuYyA9IHdwYV9zLT5kcnZfZW5jOworCWVsc2UKKwkJZHJ2X2VuYyA9ICh1bnNpZ25lZCBpbnQpIC0xOworCisJZm9yIChpID0gMDsgaSA8IE5VTV9XRVBfS0VZUzsgaSsrKSB7CisJCXNpemVfdCBsZW4gPSBzc2lkLT53ZXBfa2V5X2xlbltpXTsKKwkJaWYgKGxlbiA9PSAwKQorCQkJY29udGludWU7CisJCWlmIChsZW4gPT0gNSAmJiAoZHJ2X2VuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfV0VQNDApKQorCQkJY29udGludWU7CisJCWlmIChsZW4gPT0gMTMgJiYgKGRydl9lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX1dFUDEwNCkpCisJCQljb250aW51ZTsKKwkJaWYgKGxlbiA9PSAxNiAmJiAoZHJ2X2VuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfV0VQMTI4KSkKKwkJCWNvbnRpbnVlOworCQlyZXR1cm4gMTsgLyogaW52YWxpZCBXRVAga2V5ICovCisJfQorCisJcmV0dXJuIDA7Cit9CisKKwogaW50IHdwYXNfaXNfcDJwX3ByaW9yaXRpemVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPmNvbmNfcHJlZiA9PSBXUEFfQ09OQ19QUkVGX1AyUCkKIAkJcmV0dXJuIDE7CiAJaWYgKHdwYV9zLT5nbG9iYWwtPmNvbmNfcHJlZiA9PSBXUEFfQ09OQ19QUkVGX1NUQSkKIAkJcmV0dXJuIDA7Ci0KLQkvKiBJRiBjb25jX3ByaW9yaXR5IGlzIG5vdCBzZXQsIHJldHVybiAtMSAqLwogCXJldHVybiAtMTsKIH0KLSNlbmRpZgpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnQuY29uZiBiL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50LmNvbmYKaW5kZXggZDM5MzAxNS4uM2ViYmNjMiAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnQuY29uZgorKysgYi93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudC5jb25mCkBAIC0yMTQsNiArMjE0LDIyIEBACiAjCXRvIGV4dGVybmFsIHByb2dyYW0ocykKICN3cHNfY3JlZF9wcm9jZXNzaW5nPTAKIAorIyBWZW5kb3IgYXR0cmlidXRlIGluIFdQUyBNMSwgZS5nLiwgV2luZG93cyA3IFZlcnRpY2FsIFBhaXJpbmcKKyMgVGhlIHZlbmRvciBhdHRyaWJ1dGUgY29udGVudHMgdG8gYmUgYWRkZWQgaW4gTTEgKGhleCBzdHJpbmcpCisjd3BzX3ZlbmRvcl9leHRfbTE9MDAwMTM3MTAwMTAwMDIwMDAxCisKKyMgTkZDIHBhc3N3b3JkIHRva2VuIGZvciBXUFMKKyMgVGhlc2UgcGFyYW1ldGVycyBjYW4gYmUgdXNlZCB0byBjb25maWd1cmUgYSBmaXhlZCBORkMgcGFzc3dvcmQgdG9rZW4gZm9yIHRoZQorIyBzdGF0aW9uLiBUaGlzIGNhbiBiZSBnZW5lcmF0ZWQsIGUuZy4sIHdpdGggbmZjX3B3X3Rva2VuLiBXaGVuIHRoZXNlCisjIHBhcmFtZXRlcnMgYXJlIHVzZWQsIHRoZSBzdGF0aW9uIGlzIGFzc3VtZWQgdG8gYmUgZGVwbG95ZWQgd2l0aCBhIE5GQyB0YWcKKyMgdGhhdCBpbmNsdWRlcyB0aGUgbWF0Y2hpbmcgTkZDIHBhc3N3b3JkIHRva2VuIChlLmcuLCB3cml0dGVuIGJhc2VkIG9uIHRoZQorIyBOREVGIHJlY29yZCBmcm9tIG5mY19wd190b2tlbikuCisjCisjd3BzX25mY19kZXZfcHdfaWQ6IERldmljZSBQYXNzd29yZCBJRCAoMTYuLjY1NTM1KQorI3dwc19uZmNfZGhfcHVia2V5OiBIZXhkdW1wIG9mIERIIFB1YmxpYyBLZXkKKyN3cHNfbmZjX2RoX3ByaXZrZXk6IEhleGR1bXAgb2YgREggUHJpdmF0ZSBLZXkKKyN3cHNfbmZjX2Rldl9wdzogSGV4ZHVtcCBvZiBEZXZpY2UgUGFzc3dvcmQKKwogIyBNYXhpbXVtIG51bWJlciBvZiBCU1MgZW50cmllcyB0byBrZWVwIGluIG1lbW9yeQogIyBEZWZhdWx0OiAyMDAKICMgVGhpcyBjYW4gYmUgdXNlZCB0byBsaW1pdCBtZW1vcnkgdXNlIG9uIHRoZSBCU1MgZW50cmllcyAoY2FjaGVkIHNjYW4KQEAgLTIyMSw2ICsyMzcsMTggQEAKICMgb2YgQVBzIHdoZW4gdXNpbmcgYXBfc2Nhbj0xIG1vZGUuCiAjYnNzX21heF9jb3VudD0yMDAKIAorIyBBdXRvbWF0aWMgc2NhbgorIyBUaGlzIGlzIGFuIG9wdGlvbmFsIHNldCBvZiBwYXJhbWV0ZXJzIGZvciBhdXRvbWF0aWMgc2Nhbm5pbmcKKyMgd2l0aGluIGFuIGludGVyZmFjZSBpbiBmb2xsb3dpbmcgZm9ybWF0OgorI2F1dG9zY2FuPTxhdXRvc2NhbiBtb2R1bGUgbmFtZT46PG1vZHVsZSBwYXJhbWV0ZXJzPgorI6BhdXRvc2NhbiBpcyBsaWtlIGJnc2NhbiBidXQgb24gZGlzY29ubmVjdGVkIG9yIGluYWN0aXZlIHN0YXRlLgorI6BGb3IgaW5zdGFuY2UsIG9uIGV4cG9uZW50aWFsIG1vZHVsZSBwYXJhbWV0ZXJzIHdvdWxkIGJlIDxiYXNlPjo8bGltaXQ+CisjYXV0b3NjYW49ZXhwb25lbnRpYWw6MzozMDAKKyMgV2hpY2ggbWVhbnMgYSBkZWxheSBiZXR3ZWVuIHNjYW5zIG9uIGEgYmFzZSBleHBvbmVudGlhbCBvZiAzLAorI6B1cCB0byB0aGUgbGltaXQgb2YgMzAwIHNlY29uZHMgKDMsIDksIDI3IC4uLiAzMDApCisjoEZvciBwZXJpb2RpYyBtb2R1bGUsIHBhcmFtZXRlcnMgd291bGQgYmUgPGZpeGVkIGludGVydmFsPgorI2F1dG9zY2FuPXBlcmlvZGljOjMwCisjoFNvIGEgZGVsYXkgb2YgMzAgc2Vjb25kcyB3aWxsIGJlIGFwcGxpZWQgYmV0d2VlbiBlYWNoIHNjYW4KIAogIyBmaWx0ZXJfc3NpZHMgLSBTU0lELWJhc2VkIHNjYW4gcmVzdWx0IGZpbHRlcmluZwogIyAwID0gZG8gbm90IGZpbHRlciBzY2FuIHJlc3VsdHMgKGRlZmF1bHQpCkBAIC0yMzksMjMgKzI2Nyw5MiBAQAogIyBpcyBlbmFibGVkLgogIyBoZXNzaWQ9MDA6MTE6MjI6MzM6NDQ6NTUKIAotIyBIb21lIFJlYWxtIGZvciBJbnRlcndvcmtpbmcKLSNob21lX3JlYWxtPWV4YW1wbGUuY29tCisjIGNyZWRlbnRpYWwgYmxvY2sKKyMKKyMgRWFjaCBjcmVkZW50aWFsIHVzZWQgZm9yIGF1dG9tYXRpYyBuZXR3b3JrIHNlbGVjdGlvbiBpcyBjb25maWd1cmVkIGFzIGEgc2V0CisjIG9mIHBhcmFtZXRlcnMgdGhhdCBhcmUgY29tcGFyZWQgdG8gdGhlIGluZm9ybWF0aW9uIGFkdmVydGlzZWQgYnkgdGhlIEFQcyB3aGVuCisjIGludGVyd29ya2luZ19zZWxlY3QgYW5kIGludGVyd29ya2luZ19jb25uZWN0IGNvbW1hbmRzIGFyZSB1c2VkLgorIworIyBjcmVkZW50aWFsIGZpZWxkczoKKyMKKyMgcHJpb3JpdHk6IFByaW9yaXR5IGdyb3VwCisjCUJ5IGRlZmF1bHQsIGFsbCBuZXR3b3JrcyBhbmQgY3JlZGVudGlhbHMgZ2V0IHRoZSBzYW1lIHByaW9yaXR5IGdyb3VwCisjCSgwKS4gVGhpcyBmaWVsZCBjYW4gYmUgdXNlZCB0byBnaXZlIGhpZ2hlciBwcmlvcml0eSBmb3IgY3JlZGVudGlhbHMKKyMJKGFuZCBzaW1pbGFybHkgaW4gc3RydWN0IHdwYV9zc2lkIGZvciBuZXR3b3JrIGJsb2NrcykgdG8gY2hhbmdlIHRoZQorIwlJbnRlcndvcmtpbmcgYXV0b21hdGljIG5ldHdvcmtpbmcgc2VsZWN0aW9uIGJlaGF2aW9yLiBUaGUgbWF0Y2hpbmcKKyMJbmV0d29yayAoYmFzZWQgb24gZWl0aGVyIGFuIGVuYWJsZWQgbmV0d29yayBibG9jayBvciBhIGNyZWRlbnRpYWwpCisjCXdpdGggdGhlIGhpZ2hlc3QgcHJpb3JpdHkgdmFsdWUgd2lsbCBiZSBzZWxlY3RlZC4KKyMKKyMgcGNzYzogVXNlIFBDL1NDIGFuZCBTSU0vVVNJTSBjYXJkCisjCisjIHJlYWxtOiBIb21lIFJlYWxtIGZvciBJbnRlcndvcmtpbmcKKyMKKyMgdXNlcm5hbWU6IFVzZXJuYW1lIGZvciBJbnRlcndvcmtpbmcgbmV0d29yayBzZWxlY3Rpb24KKyMKKyMgcGFzc3dvcmQ6IFBhc3N3b3JkIGZvciBJbnRlcndvcmtpbmcgbmV0d29yayBzZWxlY3Rpb24KKyMKKyMgY2FfY2VydDogQ0EgY2VydGlmaWNhdGUgZm9yIEludGVyd29ya2luZyBuZXR3b3JrIHNlbGVjdGlvbgorIworIyBjbGllbnRfY2VydDogRmlsZSBwYXRoIHRvIGNsaWVudCBjZXJ0aWZpY2F0ZSBmaWxlIChQRU0vREVSKQorIwlUaGlzIGZpZWxkIGlzIHVzZWQgd2l0aCBJbnRlcndvcmtpbmcgbmV0d29ya2luZyBzZWxlY3Rpb24gZm9yIGEgY2FzZQorIwl3aGVyZSBjbGllbnQgY2VydGlmaWNhdGUvcHJpdmF0ZSBrZXkgaXMgdXNlZCBmb3IgYXV0aGVudGljYXRpb24KKyMJKEVBUC1UTFMpLiBGdWxsIHBhdGggdG8gdGhlIGZpbGUgc2hvdWxkIGJlIHVzZWQgc2luY2Ugd29ya2luZworIwlkaXJlY3RvcnkgbWF5IGNoYW5nZSB3aGVuIHdwYV9zdXBwbGljYW50IGlzIHJ1biBpbiB0aGUgYmFja2dyb3VuZC4KKyMKKyMJQWx0ZXJuYXRpdmVseSwgYSBuYW1lZCBjb25maWd1cmF0aW9uIGJsb2IgY2FuIGJlIHVzZWQgYnkgc2V0dGluZworIwl0aGlzIHRvIGJsb2I6Ly9ibG9iX25hbWUuCisjCisjIHByaXZhdGVfa2V5OiBGaWxlIHBhdGggdG8gY2xpZW50IHByaXZhdGUga2V5IGZpbGUgKFBFTS9ERVIvUEZYKQorIwlXaGVuIFBLQ1MjMTIvUEZYIGZpbGUgKC5wMTIvLnBmeCkgaXMgdXNlZCwgY2xpZW50X2NlcnQgc2hvdWxkIGJlCisjCWNvbW1lbnRlZCBvdXQuIEJvdGggdGhlIHByaXZhdGUga2V5IGFuZCBjZXJ0aWZpY2F0ZSB3aWxsIGJlIHJlYWQKKyMJZnJvbSB0aGUgUEtDUyMxMiBmaWxlIGluIHRoaXMgY2FzZS4gRnVsbCBwYXRoIHRvIHRoZSBmaWxlIHNob3VsZCBiZQorIwl1c2VkIHNpbmNlIHdvcmtpbmcgZGlyZWN0b3J5IG1heSBjaGFuZ2Ugd2hlbiB3cGFfc3VwcGxpY2FudCBpcyBydW4KKyMJaW4gdGhlIGJhY2tncm91bmQuCisjCisjCVdpbmRvd3MgY2VydGlmaWNhdGUgc3RvcmUgY2FuIGJlIHVzZWQgYnkgbGVhdmluZyBjbGllbnRfY2VydCBvdXQgYW5kCisjCWNvbmZpZ3VyaW5nIHByaXZhdGVfa2V5IGluIG9uZSBvZiB0aGUgZm9sbG93aW5nIGZvcm1hdHM6CisjCisjCWNlcnQ6Ly9zdWJzdHJpbmdfdG9fbWF0Y2gKKyMKKyMJaGFzaDovL2NlcnRpZmljYXRlX3RodW1icHJpbnRfaW5faGV4CisjCisjCUZvciBleGFtcGxlOiBwcml2YXRlX2tleT0iaGFzaDovLzYzMDkzYWE5YzQ3ZjU2YWU4ODMzNGM3YjY1YTQiCisjCisjCU5vdGUgdGhhdCB3aGVuIHJ1bm5pbmcgd3BhX3N1cHBsaWNhbnQgYXMgYW4gYXBwbGljYXRpb24sIHRoZSB1c2VyCisjCWNlcnRpZmljYXRlIHN0b3JlIChNeSB1c2VyIGFjY291bnQpIGlzIHVzZWQsIHdoZXJlYXMgY29tcHV0ZXIgc3RvcmUKKyMJKENvbXB1dGVyIGFjY291bnQpIGlzIHVzZWQgd2hlbiBydW5uaW5nIHdwYXN2YyBhcyBhIHNlcnZpY2UuCisjCisjCUFsdGVybmF0aXZlbHksIGEgbmFtZWQgY29uZmlndXJhdGlvbiBibG9iIGNhbiBiZSB1c2VkIGJ5IHNldHRpbmcKKyMJdGhpcyB0byBibG9iOi8vYmxvYl9uYW1lLgorIworIyBwcml2YXRlX2tleV9wYXNzd2Q6IFBhc3N3b3JkIGZvciBwcml2YXRlIGtleSBmaWxlCisjCisjIGltc2k6IElNU0kgaW4gPE1DQz4gfCA8TU5DPiB8ICctJyB8IDxNU0lOPiBmb3JtYXQKKyMKKyMgbWlsZW5hZ2U6IE1pbGVuYWdlIHBhcmFtZXRlcnMgZm9yIFNJTS9VU0lNIHNpbXVsYXRvciBpbiA8S2k+OjxPUGM+OjxTUU4+CisjCWZvcm1hdAorIworIyBkb21haW46IEhvbWUgc2VydmljZSBwcm92aWRlciBGUUROCisjCVRoaXMgaXMgdXNlZCB0byBjb21wYXJlIGFnYWluc3QgdGhlIERvbWFpbiBOYW1lIExpc3QgdG8gZmlndXJlIG91dAorIwl3aGV0aGVyIHRoZSBBUCBpcyBvcGVyYXRlZCBieSB0aGUgSG9tZSBTUC4KKyMKKyMgZm9yIGV4YW1wbGU6CisjCisjY3JlZD17CisjCXJlYWxtPSJleGFtcGxlLmNvbSIKKyMJdXNlcm5hbWU9InVzZXJAZXhhbXBsZS5jb20iCisjCXBhc3N3b3JkPSJwYXNzd29yZCIKKyMJY2FfY2VydD0iL2V0Yy93cGFfc3VwcGxpY2FudC9jYS5wZW0iCisjCWRvbWFpbj0iZXhhbXBsZS5jb20iCisjfQorIworI2NyZWQ9eworIwlpbXNpPSIzMTAwMjYtMDAwMDAwMDAwIgorIwltaWxlbmFnZT0iOTBkY2E0ZWRhNDViNTNjZjBmMTJkN2M5YzNiYzZhODk6Y2I5Y2NjYzRiOTI1OGU2ZGNhNDc2MDM3OWZiODIiCisjfQogCi0jIFVzZXJuYW1lIGZvciBJbnRlcndvcmtpbmcgbmV0d29yayBzZWxlY3Rpb24KLSNob21lX3VzZXJuYW1lPXVzZXIKLQotIyBQYXNzd29yZCBmb3IgSW50ZXJ3b3JraW5nIG5ldHdvcmsgc2VsZWN0aW9uCi0jaG9tZV9wYXNzd29yZD1zZWNyZXQKLQotIyBDQSBjZXJ0aWZpY2F0ZSBmb3IgSW50ZXJ3b3JraW5nIG5ldHdvcmsgc2VsZWN0aW9uCi0jaG9tZV9jYV9jZXJ0PS9ldGMvY2VydC9jYS5wZW0KLQotIyBJTVNJIGluIDxNQ0M+IHwgPE1OQz4gfCAnLScgfCA8TVNJTj4gZm9ybWF0Ci0jaG9tZV9pbXNpPTIzMjAxMDAwMDAwMDAwMAotCi0jIE1pbGVuYWdlIHBhcmFtZXRlcnMgZm9yIFNJTS9VU0lNIHNpbXVsYXRvciBpbiA8S2k+OjxPUGM+OjxTUU4+IGZvcm1hdAotI2hvbWVfbWlsZW5hZ2U9OTBkY2E0ZWRhNDViNTNjZjBmMTJkN2M5YzNiYzZhODk6Y2I5Y2NjYzRiOTI1OGU2ZGNhNDc2MDM3OWZiODI1ODE6MDAwMDAwMDAwMTIzCisjIEhvdHNwb3QgMi4wCisjIGhzMjA9MQogCiAjIG5ldHdvcmsgYmxvY2sKICMKQEAgLTM0MSw2ICs0MzgsMTYgQEAKICMgV1BBLUVBUC1TSEEyNTYgPSBMaWtlIFdQQS1FQVAgYnV0IHVzaW5nIHN0cm9uZ2VyIFNIQTI1Ni1iYXNlZCBhbGdvcml0aG1zCiAjIElmIG5vdCBzZXQsIHRoaXMgZGVmYXVsdHMgdG86IFdQQS1QU0sgV1BBLUVBUAogIworIyBpZWVlODAyMTF3OiB3aGV0aGVyIG1hbmFnZW1lbnQgZnJhbWUgcHJvdGVjdGlvbiBpcyBlbmFibGVkCisjIDAgPSBkaXNhYmxlZCAoZGVmYXVsdCkKKyMgMSA9IG9wdGlvbmFsCisjIDIgPSByZXF1aXJlZAorIyBUaGUgbW9zdCBjb21tb24gY29uZmlndXJhdGlvbiBvcHRpb25zIGZvciB0aGlzIGJhc2VkIG9uIHRoZSBQTUYgKHByb3RlY3RlZAorIyBtYW5hZ2VtZW50IGZyYW1lcykgY2VydGlmaWNhdGlvbiBwcm9ncmFtIGFyZToKKyMgUE1GIGVuYWJsZWQ6IGllZWU4MDIxMXc9MSBhbmQga2V5X21nbXQ9V1BBLUVBUCBXUEEtRUFQLVNIQTI1NgorIyBQTUYgcmVxdWlyZWQ6IGllZWU4MDIxMXc9MiBhbmQga2V5X21nbXQ9V1BBLUVBUC1TSEEyNTYKKyMgKGFuZCBzaW1pbGFybHkgZm9yIFdQQS1QU0sgYW5kIFdQQS1XUFNLLVNIQTI1NiBpZiBXUEEyLVBlcnNvbmFsIGlzIHVzZWQpCisjCiAjIGF1dGhfYWxnOiBsaXN0IG9mIGFsbG93ZWQgSUVFRSA4MDIuMTEgYXV0aGVudGljYXRpb24gYWxnb3JpdGhtcwogIyBPUEVOID0gT3BlbiBTeXN0ZW0gYXV0aGVudGljYXRpb24gKHJlcXVpcmVkIGZvciBXUEEvV1BBMikKICMgU0hBUkVEID0gU2hhcmVkIEtleSBhdXRoZW50aWNhdGlvbiAocmVxdWlyZXMgc3RhdGljIFdFUCBrZXlzKQpAQCAtNTg3LDYgKzY5NCwyNiBAQAogIyBudW1iZXIgb2YgYXV0aGVudGljYXRpb24gc2VydmVycy4gU3RyaWN0IEVBUCBjb25mb3JtYW5jZSBtb2RlIGNhbiBiZQogIyBjb25maWd1cmVkIGJ5IGRpc2FibGluZyB3b3JrYXJvdW5kcyB3aXRoIGVhcF93b3JrYXJvdW5kPTAuCiAKKyMgU3RhdGlvbiBpbmFjdGl2aXR5IGxpbWl0CisjCisjIElmIGEgc3RhdGlvbiBkb2VzIG5vdCBzZW5kIGFueXRoaW5nIGluIGFwX21heF9pbmFjdGl2aXR5IHNlY29uZHMsIGFuCisjIGVtcHR5IGRhdGEgZnJhbWUgaXMgc2VudCB0byBpdCBpbiBvcmRlciB0byB2ZXJpZnkgd2hldGhlciBpdCBpcworIyBzdGlsbCBpbiByYW5nZS4gSWYgdGhpcyBmcmFtZSBpcyBub3QgQUNLZWQsIHRoZSBzdGF0aW9uIHdpbGwgYmUKKyMgZGlzYXNzb2NpYXRlZCBhbmQgdGhlbiBkZWF1dGhlbnRpY2F0ZWQuIFRoaXMgZmVhdHVyZSBpcyB1c2VkIHRvCisjIGNsZWFyIHN0YXRpb24gdGFibGUgb2Ygb2xkIGVudHJpZXMgd2hlbiB0aGUgU1RBcyBtb3ZlIG91dCBvZiB0aGUKKyMgcmFuZ2UuCisjCisjIFRoZSBzdGF0aW9uIGNhbiBhc3NvY2lhdGUgYWdhaW4gd2l0aCB0aGUgQVAgaWYgaXQgaXMgc3RpbGwgaW4gcmFuZ2U7CisjIHRoaXMgaW5hY3Rpdml0eSBwb2xsIGlzIGp1c3QgdXNlZCBhcyBhIG5pY2VyIHdheSBvZiB2ZXJpZnlpbmcKKyMgaW5hY3Rpdml0eTsgaS5lLiwgY2xpZW50IHdpbGwgbm90IHJlcG9ydCBicm9rZW4gY29ubmVjdGlvbiBiZWNhdXNlCisjIGRpc2Fzc29jaWF0aW9uIGZyYW1lIGlzIG5vdCBzZW50IGltbWVkaWF0ZWx5IHdpdGhvdXQgZmlyc3QgcG9sbGluZworIyB0aGUgU1RBIHdpdGggYSBkYXRhIGZyYW1lLgorIyBkZWZhdWx0OiAzMDAgKGkuZS4sIDUgbWludXRlcykKKyNhcF9tYXhfaW5hY3Rpdml0eT0zMDAKKworIyBEVElNIHBlcmlvZCBpbiBCZWFjb24gaW50ZXJ2YWxzIGZvciBBUCBtb2RlIChkZWZhdWx0OiAyKQorI2R0aW1fcGVyaW9kPTIKKwogIyBFeGFtcGxlIGJsb2NrczoKIAogIyBTaW1wbGUgY2FzZTogV1BBLVBTSywgUFNLIGFzIGFuIEFTQ0lJIHBhc3NwaHJhc2UsIGFsbG93IGFsbCB2YWxpZCBjaXBoZXJzCmRpZmYgLS1naXQgYS93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudF9pLmggYi93cGFfc3VwcGxpY2FudC93cGFfc3VwcGxpY2FudF9pLmgKaW5kZXggMjFmZTVjYy4uM2Y2NjY5ZCAxMDA2NDQKLS0tIGEvd3BhX3N1cHBsaWNhbnQvd3BhX3N1cHBsaWNhbnRfaS5oCisrKyBiL3dwYV9zdXBwbGljYW50L3dwYV9zdXBwbGljYW50X2kuaApAQCAtMTYxLDYgKzE2MSwxMSBAQAogCWludCB3cGFfZGVidWdfc3lzbG9nOwogCiAJLyoqCisJICogd3BhX2RlYnVnX3RyYWNpbmcgLSBFbmFibGUgbG9nIG91dHB1dCB0aHJvdWdoIExpbnV4IHRyYWNpbmcKKwkgKi8KKwlpbnQgd3BhX2RlYnVnX3RyYWNpbmc7CisKKwkvKioKIAkgKiBvdmVycmlkZV9kcml2ZXIgLSBPcHRpb25hbCBkcml2ZXIgcGFyYW1ldGVyIG92ZXJyaWRlCiAJICoKIAkgKiBUaGlzIHBhcmFtZXRlciBjYW4gYmUgdXNlZCB0byBvdmVycmlkZSB0aGUgZHJpdmVyIHBhcmFtZXRlciBpbgpAQCAtMTk5LDYgKzIwNCwxMiBAQAogCWNoYXIgKnNlcnZpY2U7CiB9OwogCitzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2UgeworCXVuc2lnbmVkIGludCBtaW47CisJdW5zaWduZWQgaW50IG1heDsKK307CisKKwogLyoqCiAgKiBzdHJ1Y3Qgd3BhX2dsb2JhbCAtIEludGVybmFsLCBnbG9iYWwgZGF0YSBmb3IgYWxsICV3cGFfc3VwcGxpY2FudCBpbnRlcmZhY2VzCiAgKgpAQCAtMjE0LDE5ICsyMjUsMjAgQEAKIAlzaXplX3QgZHJ2X2NvdW50OwogCXN0cnVjdCBvc190aW1lIHN1c3BlbmRfdGltZTsKIAlzdHJ1Y3QgcDJwX2RhdGEgKnAycDsKKwlzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKnAycF9pbml0X3dwYV9zOwogCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqcDJwX2dyb3VwX2Zvcm1hdGlvbjsKIAl1OCBwMnBfZGV2X2FkZHJbRVRIX0FMRU5dOwogCXN0cnVjdCBkbF9saXN0IHAycF9zcnZfYm9uam91cjsgLyogc3RydWN0IHAycF9zcnZfYm9uam91ciAqLwogCXN0cnVjdCBkbF9saXN0IHAycF9zcnZfdXBucDsgLyogc3RydWN0IHAycF9zcnZfdXBucCAqLwogCWludCBwMnBfZGlzYWJsZWQ7Ci0jaWZkZWYgQU5EUk9JRF9QMlAKKwlpbnQgY3Jvc3NfY29ubmVjdGlvbjsKKwlzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2UgKnAycF9kaXNhbGxvd19mcmVxOworCXVuc2lnbmVkIGludCBudW1fcDJwX2Rpc2FsbG93X2ZyZXE7CiAJZW51bSB3cGFfY29uY19wcmVmIHsKIAkJV1BBX0NPTkNfUFJFRl9OT1RfU0VULAogCQlXUEFfQ09OQ19QUkVGX1NUQSwKIAkJV1BBX0NPTkNfUFJFRl9QMlAKIAl9IGNvbmNfcHJlZjsKLSNlbmRpZgotCWludCBjcm9zc19jb25uZWN0aW9uOwogfTsKIAogCkBAIC0yNTksNiArMjcxLDkgQEAKICNpZmRlZiBDT05GSUdfQ1RSTF9JRkFDRV9EQlVTX05FVwogCWNoYXIgKmRidXNfbmV3X3BhdGg7CiAJY2hhciAqZGJ1c19ncm91cG9ial9wYXRoOworI2lmZGVmIENPTkZJR19BUAorCWNoYXIgKnByZXFfbm90aWZ5X3BlZXI7CisjZW5kaWYgLyogQ09ORklHX0FQICovCiAjZW5kaWYgLyogQ09ORklHX0NUUkxfSUZBQ0VfREJVU19ORVcgKi8KIAljaGFyIGJyaWRnZV9pZm5hbWVbMTZdOwogCkBAIC0yODcsNiArMzAyLDkgQEAKIAl2b2lkICpkcnZfcHJpdjsgLyogcHJpdmF0ZSBkYXRhIHVzZWQgYnkgZHJpdmVyX29wcyAqLwogCXZvaWQgKmdsb2JhbF9kcnZfcHJpdjsKIAorCXU4ICpic3NpZF9maWx0ZXI7CisJc2l6ZV90IGJzc2lkX2ZpbHRlcl9jb3VudDsKKwogCS8qIHByZXZpb3VzIHNjYW4gd2FzIHdpbGRjYXJkIHdoZW4gaW50ZXJsZWF2aW5nIGJldHdlZW4KIAkgKiB3aWxkY2FyZCBzY2FucyBhbmQgc3BlY2lmaWMgU1NJRCBzY2FuIHdoZW4gbWF4X3NzaWRzPTEgKi8KIAlpbnQgcHJldl9zY2FuX3dpbGRjYXJkOwpAQCAtMzMwLDYgKzM0OCwxMCBAQAogCQkJICAgICAqIHByZXZpb3VzIGFzc29jaWF0aW9uIGV2ZW50ICovCiAKIAlzdHJ1Y3Qgc2NhcmRfZGF0YSAqc2NhcmQ7CisjaWZkZWYgUENTQ19GVU5DUworCWNoYXIgaW1zaVsyMF07CisJaW50IG1uY19sZW47CisjZW5kaWYgLyogUENTQ19GVU5DUyAqLwogCiAJdW5zaWduZWQgY2hhciBsYXN0X2VhcG9sX3NyY1tFVEhfQUxFTl07CiAKQEAgLTM0NSw2ICszNjcsNyBAQAogCWludCBub3JtYWxfc2NhbnM7IC8qIG5vcm1hbCBzY2FucyBydW4gYmVmb3JlIHNjaGVkX3NjYW4gKi8KIAogCXVuc2lnbmVkIGludCBkcnZfZmxhZ3M7CisJdW5zaWduZWQgaW50IGRydl9lbmM7CiAKIAkvKgogCSAqIEEgYml0bWFwIG9mIHN1cHBvcnRlZCBwcm90b2NvbHMgZm9yIHByb2JlIHJlc3BvbnNlIG9mZmxvYWQuIFNlZQpAQCAtNDAzLDYgKzQyNiw5IEBACiAJCQkJCSogc2FfcXVlcnlfY291bnQgb2N0ZXRzIG9mIHBlbmRpbmcKIAkJCQkJKiBTQSBRdWVyeSB0cmFuc2FjdGlvbiBpZGVudGlmaWVycyAqLwogCQlzdHJ1Y3Qgb3NfdGltZSBzYV9xdWVyeV9zdGFydDsKKwkJdTggc2NoZWRfb2Jzc19zY2FuOworCQl1MTYgb2Jzc19zY2FuX2ludDsKKwkJdTE2IGJzc19tYXhfaWRsZV9wZXJpb2Q7CiAJfSBzbWU7CiAjZW5kaWYgLyogQ09ORklHX1NNRSAqLwogCkBAIC00NjAsNyArNDg2LDEyIEBACiAJdTggcGVuZGluZ19qb2luX2Rldl9hZGRyW0VUSF9BTEVOXTsKIAlpbnQgcGVuZGluZ19qb2luX3dwc19tZXRob2Q7CiAJaW50IHAycF9qb2luX3NjYW5fY291bnQ7CisJaW50IGF1dG9fcGRfc2Nhbl9yZXRyeTsKIAlpbnQgZm9yY2VfbG9uZ19zZDsKKwl1MTYgcGVuZGluZ19wZF9jb25maWdfbWV0aG9kczsKKwllbnVtIHsKKwkJTk9STUFMX1BELCBBVVRPX1BEX0dPX05FRywgQVVUT19QRF9KT0lOCisJfSBwZW5kaW5nX3BkX3VzZTsKIAogCS8qCiAJICogV2hldGhlciBjcm9zcyBjb25uZWN0aW9uIGlzIGRpc2FsbG93ZWQgYnkgdGhlIEFQIHRvIHdoaWNoIHRoaXMKQEAgLTQ4OCwxOCArNTE5LDMyIEBACiAJCVAyUF9HUk9VUF9SRU1PVkFMX1JFUVVFU1RFRCwKIAkJUDJQX0dST1VQX1JFTU9WQUxfSURMRV9USU1FT1VULAogCQlQMlBfR1JPVVBfUkVNT1ZBTF9VTkFWQUlMQUJMRSwKKwkJUDJQX0dST1VQX1JFTU9WQUxfR09fRU5ESU5HX1NFU1NJT04sCiAjaWZkZWYgQU5EUk9JRF9QMlAKIAkJUDJQX0dST1VQX1JFTU9WQUxfRlJFUV9DT05GTElDVAogI2VuZGlmCiAJfSByZW1vdmFsX3JlYXNvbjsKIAogCXVuc2lnbmVkIGludCBwMnBfY2Jfb25fc2Nhbl9jb21wbGV0ZToxOworCXVuc2lnbmVkIGludCBwMnBfYXV0b19qb2luOjE7CisJdW5zaWduZWQgaW50IHAycF9hdXRvX3BkOjE7CisJdW5zaWduZWQgaW50IHAycF9wZXJzaXN0ZW50X2dyb3VwOjE7CisJdW5zaWduZWQgaW50IHAycF9mYWxsYmFja190b19nb19uZWc6MTsKKwl1bnNpZ25lZCBpbnQgcDJwX3BkX2JlZm9yZV9nb19uZWc6MTsKKwlpbnQgcDJwX3BlcnNpc3RlbnRfaWQ7CisJaW50IHAycF9nb19pbnRlbnQ7CisJaW50IHAycF9jb25uZWN0X2ZyZXE7CisJc3RydWN0IG9zX3RpbWUgcDJwX2F1dG9fc3RhcnRlZDsKICNlbmRpZiAvKiBDT05GSUdfUDJQICovCiAKIAlzdHJ1Y3Qgd3BhX3NzaWQgKmJnc2Nhbl9zc2lkOwogCWNvbnN0IHN0cnVjdCBiZ3NjYW5fb3BzICpiZ3NjYW47CiAJdm9pZCAqYmdzY2FuX3ByaXY7CiAKKwljb25zdCBzdHJ1Y3QgYXV0b3NjYW5fb3BzICphdXRvc2NhbjsKKwlzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyAqYXV0b3NjYW5fcGFyYW1zOworCXZvaWQgKmF1dG9zY2FuX3ByaXY7CisKIAlzdHJ1Y3Qgd3BhX3NzaWQgKmNvbm5lY3Rfd2l0aG91dF9zY2FuOwogCiAJaW50IGFmdGVyX3dwczsKQEAgLTUyOSw2ICs1NzQsOSBAQAogCX0gaHc7CiAKIAlpbnQgcG5vOworCisJLyogV0xBTl9SRUFTT05fKiByZWFzb24gY29kZXMuIE5lZ2F0aXZlIGlmIGxvY2FsbHkgZ2VuZXJhdGVkLiAqLworCWludCBkaXNjb25uZWN0X3JlYXNvbjsKIH07CiAKIApAQCAtNTU2LDYgKzYwNCw3IEBACiB2b2lkIHdwYV9jbGVhcl9rZXlzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICphZGRyKTsKIHZvaWQgd3BhX3N1cHBsaWNhbnRfcmVxX2F1dGhfdGltZW91dChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJCSAgICAgaW50IHNlYywgaW50IHVzZWMpOwordm9pZCB3cGFfc3VwcGxpY2FudF9yZWluaXRfYXV0b3NjYW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiB2b2lkIHdwYV9zdXBwbGljYW50X3NldF9zdGF0ZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAogCQkJICAgICAgZW51bSB3cGFfc3RhdGVzIHN0YXRlKTsKIHN0cnVjdCB3cGFfc3NpZCAqIHdwYV9zdXBwbGljYW50X2dldF9zc2lkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwpAQCAtNTc4LDkgKzYyNywxMiBAQAogCQkJCQkgIHVuc2lnbmVkIGludCBleHBpcmVfYWdlKTsKIGludCB3cGFfc3VwcGxpY2FudF9zZXRfYnNzX2V4cGlyYXRpb25fY291bnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKIAkJCQkJICAgIHVuc2lnbmVkIGludCBleHBpcmVfY291bnQpOworaW50IHdwYV9zdXBwbGljYW50X3NldF9zY2FuX2ludGVydmFsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJICAgICBpbnQgc2Nhbl9pbnRlcnZhbCk7CiBpbnQgd3BhX3N1cHBsaWNhbnRfc2V0X2RlYnVnX3BhcmFtcyhzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsLAogCQkJCSAgICBpbnQgZGVidWdfbGV2ZWwsIGludCBkZWJ1Z190aW1lc3RhbXAsCiAJCQkJICAgIGludCBkZWJ1Z19zaG93X2tleXMpOwordm9pZCBmcmVlX2h3X2ZlYXR1cmVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogCiB2b2lkIHdwYV9zaG93X2xpY2Vuc2Uodm9pZCk7CiAKQEAgLTYwNiw5ICs2NTgsMjMgQEAKIHZvaWQgd3BhX3N1cHBsaWNhbnRfY2xlYXJfc3RhdHVzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwogdm9pZCB3cGFzX2Nvbm5lY3Rpb25fZmFpbGVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IHU4ICpic3NpZCk7CiBpbnQgd3Bhc19kcml2ZXJfYnNzX3NlbGVjdGlvbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKLSNpZmRlZiBBTkRST0lEX1AyUAogaW50IHdwYXNfaXNfcDJwX3ByaW9yaXRpemVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpOwotI2VuZGlmCit2b2lkIHdwYV9zdXBwbGljYW50X3Byb2NfNDBtaHpfaW50b2xlcmFudChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKKworLyoqCisgKiB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2N0cmxfcnNwX2hhbmRsZSAtIEhhbmRsZSBhIGNvbnRyb2wgcmVzcG9uc2UKKyAqIEB3cGFfczogUG9pbnRlciB0byB3cGFfc3VwcGxpY2FudCBkYXRhCisgKiBAc3NpZDogUG9pbnRlciB0byB0aGUgbmV0d29yayBibG9jayB0aGUgcmVwbHkgaXMgZm9yCisgKiBAZmllbGQ6IGZpZWxkIHRoZSByZXNwb25zZSBpcyBhIHJlcGx5IGZvcgorICogQHZhbHVlOiB2YWx1ZSAoaWUsIHBhc3N3b3JkLCBldGMpIGZvciBAZmllbGQKKyAqIFJldHVybnM6IDAgb24gc3VjY2Vzcywgbm9uLXplcm8gb24gZXJyb3IKKyAqCisgKiBIZWxwZXIgZnVuY3Rpb24gdG8gaGFuZGxlIHJlcGxpZXMgdG8gY29udHJvbCBpbnRlcmZhY2UgcmVxdWVzdHMuCisgKi8KK2ludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2N0cmxfcnNwX2hhbmRsZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQsCisJCQkJCSAgICAgIGNvbnN0IGNoYXIgKmZpZWxkLAorCQkJCQkgICAgICBjb25zdCBjaGFyICp2YWx1ZSk7CiAKIC8qIGV2ZW50cy5jICovCiB2b2lkIHdwYV9zdXBwbGljYW50X21hcmtfZGlzYXNzb2Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CkBAIC02MTcsNiArNjgzLDcgQEAKIAkJCSAgIHN0cnVjdCB3cGFfc3NpZCAqc3NpZCk7CiB2b2lkIHdwYV9zdXBwbGljYW50X3N0b3BfY291bnRlcm1lYXN1cmVzKHZvaWQgKmVsb29wX2N0eCwgdm9pZCAqc29ja19jdHgpOwogdm9pZCB3cGFfc3VwcGxpY2FudF9kZWxheWVkX21pY19lcnJvcl9yZXBvcnQodm9pZCAqZWxvb3BfY3R4LCB2b2lkICpzb2NrX2N0eCk7Cit2b2lkIHdubV9ic3Nfa2VlcF9hbGl2ZV9kZWluaXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcyk7CiAKIC8qIGVhcF9yZWdpc3Rlci5jICovCiBpbnQgZWFwX3JlZ2lzdGVyX21ldGhvZHModm9pZCk7CkBAIC02MzEsNCArNjk4LDYgQEAKIAlyZXR1cm4gKChzc2lkLT5kaXNhYmxlZCA9PSAyKSB8fCBzc2lkLT5wMnBfcGVyc2lzdGVudF9ncm91cCk7CiB9CiAKK2ludCB3cGFzX25ldHdvcmtfZGlzYWJsZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgc3RydWN0IHdwYV9zc2lkICpzc2lkKTsKKwogI2VuZGlmIC8qIFdQQV9TVVBQTElDQU5UX0lfSCAqLwpkaWZmIC0tZ2l0IGEvd3BhX3N1cHBsaWNhbnQvd3Bhc19nbHVlLmMgYi93cGFfc3VwcGxpY2FudC93cGFzX2dsdWUuYwppbmRleCA1YjlkYzllLi5mYjRmYTIyIDEwMDY0NAotLS0gYS93cGFfc3VwcGxpY2FudC93cGFzX2dsdWUuYworKysgYi93cGFfc3VwcGxpY2FudC93cGFzX2dsdWUuYwpAQCAtNzIwLDYgKzcyMCwxNSBAQAogCiAJd3Bhc19ub3RpZnlfY2VydGlmaWNhdGlvbih3cGFfcywgZGVwdGgsIHN1YmplY3QsIGNlcnRfaGFzaCwgY2VydCk7CiB9CisKKworc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfc3RhdHVzX2NiKHZvaWQgKmN0eCwgY29uc3QgY2hhciAqc3RhdHVzLAorCQkJCSAgICAgY29uc3QgY2hhciAqcGFyYW1ldGVyKQoreworCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MgPSBjdHg7CisKKwl3cGFzX25vdGlmeV9lYXBfc3RhdHVzKHdwYV9zLCBzdGF0dXMsIHBhcmFtZXRlcik7Cit9CiAjZW5kaWYgLyogSUVFRTgwMjFYX0VBUE9MICovCiAKIApAQCAtNzUxLDYgKzc2MCw3IEBACiAJY3R4LT5wb3J0X2NiID0gd3BhX3N1cHBsaWNhbnRfcG9ydF9jYjsKIAljdHgtPmNiID0gd3BhX3N1cHBsaWNhbnRfZWFwb2xfY2I7CiAJY3R4LT5jZXJ0X2NiID0gd3BhX3N1cHBsaWNhbnRfY2VydF9jYjsKKwljdHgtPnN0YXR1c19jYiA9IHdwYV9zdXBwbGljYW50X3N0YXR1c19jYjsKIAljdHgtPmNiX2N0eCA9IHdwYV9zOwogCXdwYV9zLT5lYXBvbCA9IGVhcG9sX3NtX2luaXQoY3R4KTsKIAlpZiAod3BhX3MtPmVhcG9sID09IE5VTEwpIHsKZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmMgYi93cGFfc3VwcGxpY2FudC93cHNfc3VwcGxpY2FudC5jCmluZGV4IDQ5NjU0MzkuLjczNTZkMWEgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmMKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BzX3N1cHBsaWNhbnQuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiB3cGFfc3VwcGxpY2FudCAvIFdQUyBpbnRlZ3JhdGlvbgotICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMTAsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtMTEsNiArMTEsNyBAQAogI2luY2x1ZGUgImNvbW1vbi5oIgogI2luY2x1ZGUgImVsb29wLmgiCiAjaW5jbHVkZSAidXVpZC5oIgorI2luY2x1ZGUgImNyeXB0by9yYW5kb20uaCIKICNpbmNsdWRlICJjcnlwdG8vZGhfZ3JvdXA1LmgiCiAjaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgogI2luY2x1ZGUgImNvbW1vbi9pZWVlODAyXzExX2NvbW1vbi5oIgpAQCAtMjAsNiArMjEsNyBAQAogI2luY2x1ZGUgImVhcF9wZWVyL2VhcC5oIgogI2luY2x1ZGUgImVhcG9sX3N1cHAvZWFwb2xfc3VwcF9zbS5oIgogI2luY2x1ZGUgInJzbl9zdXBwL3dwYS5oIgorI2luY2x1ZGUgIndwcy93cHNfYXR0cl9wYXJzZS5oIgogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKICNpbmNsdWRlICJkcml2ZXJfaS5oIgpAQCAtMjYzLDYgKzI2NSw3IEBACiAJCXNzaWQtPmVhcC5lYXBfbWV0aG9kcyA9IE5VTEw7CiAJCWlmICghc3NpZC0+cDJwX2dyb3VwKQogCQkJc3NpZC0+dGVtcG9yYXJ5ID0gMDsKKwkJc3NpZC0+YnNzaWRfc2V0ID0gMDsKIAl9IGVsc2UgewogCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogQ3JlYXRlIGEgbmV3IG5ldHdvcmsgYmFzZWQgb24gdGhlICIKIAkJCSAgICJyZWNlaXZlZCBjcmVkZW50aWFsIik7CkBAIC05MTksNyArOTIyLDggQEAKIAl9CiAjZW5kaWYgLyogQ09ORklHX0FQICovCiAKLQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfU0NBTk5JTkcpIHsKKwlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfU0NBTk5JTkcgfHwKKwkgICAgd3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfRElTQ09OTkVDVEVEKSB7CiAJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBDYW5jZWwgb3BlcmF0aW9uIC0gY2FuY2VsIHNjYW4iKTsKIAkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjYW4od3BhX3MpOwogCQl3cGFzX2NsZWFyX3dwcyh3cGFfcyk7CkBAIC0xMTEzLDggKzExMTcsMTAgQEAKIAkJd2hpbGUgKGZpcnN0ICYmIGZpcnN0LT5uZXh0KQogCQkJZmlyc3QgPSBmaXJzdC0+bmV4dDsKIAkJaWYgKGZpcnN0ICYmIGZpcnN0ICE9IHdwYV9zKSB7Ci0JCQlvc19tZW1jcHkod3BzLT51dWlkLCB3cGFfcy0+Z2xvYmFsLT5pZmFjZXMtPndwcy0+dXVpZCwKLQkJCQkgIFdQU19VVUlEX0xFTik7CisJCQlpZiAod3BzICE9IHdwYV9zLT5nbG9iYWwtPmlmYWNlcy0+d3BzKQorCQkJCW9zX21lbWNweSh3cHMtPnV1aWQsCisJCQkJCSAgd3BhX3MtPmdsb2JhbC0+aWZhY2VzLT53cHMtPnV1aWQsCisJCQkJCSAgV1BTX1VVSURfTEVOKTsKIAkJCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgIldQUzogVVVJRCBmcm9tIHRoZSBmaXJzdCAiCiAJCQkJICAgICJpbnRlcmZhY2UiLCB3cHMtPnV1aWQsIFdQU19VVUlEX0xFTik7CiAJCX0gZWxzZSB7CkBAIC0xMTMwLDYgKzExMzYsMjMgQEAKIH0KIAogCitzdGF0aWMgdm9pZCB3cGFzX3dwc19zZXRfdmVuZG9yX2V4dF9tMShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICAgICBzdHJ1Y3Qgd3BzX2NvbnRleHQgKndwcykKK3sKKwl3cGFidWZfZnJlZSh3cHMtPmRldi52ZW5kb3JfZXh0X20xKTsKKwl3cHMtPmRldi52ZW5kb3JfZXh0X20xID0gTlVMTDsKKworCWlmICh3cGFfcy0+Y29uZi0+d3BzX3ZlbmRvcl9leHRfbTEpIHsKKwkJd3BzLT5kZXYudmVuZG9yX2V4dF9tMSA9CisJCQl3cGFidWZfZHVwKHdwYV9zLT5jb25mLT53cHNfdmVuZG9yX2V4dF9tMSk7CisJCWlmICghd3BzLT5kZXYudmVuZG9yX2V4dF9tMSkgeworCQkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJXUFM6IENhbm5vdCAiCisJCQkJICAgImFsbG9jYXRlIG1lbW9yeSBmb3IgdmVuZG9yX2V4dF9tMSIpOworCQl9CisJfQorfQorCisKIGludCB3cGFzX3dwc19pbml0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCiB7CiAJc3RydWN0IHdwc19jb250ZXh0ICp3cHM7CkBAIC0xMTY4LDYgKzExOTEsOCBAQAogCW9zX21lbWNweSh3cHMtPmRldi5zZWNfZGV2X3R5cGUsIHdwYV9zLT5jb25mLT5zZWNfZGV2aWNlX3R5cGUsCiAJCSAgV1BTX0RFVl9UWVBFX0xFTiAqIHdwcy0+ZGV2Lm51bV9zZWNfZGV2X3R5cGVzKTsKIAorCXdwYXNfd3BzX3NldF92ZW5kb3JfZXh0X20xKHdwYV9zLCB3cHMpOworCiAJd3BzLT5kZXYub3NfdmVyc2lvbiA9IFdQQV9HRVRfQkUzMih3cGFfcy0+Y29uZi0+b3NfdmVyc2lvbik7CiAJbW9kZXMgPSB3cGFfcy0+aHcubW9kZXM7CiAJaWYgKG1vZGVzKSB7CkBAIC0xMjI4LDYgKzEyNTMsNyBAQAogCXdwYWJ1Zl9mcmVlKHdwYV9zLT53cHMtPmRoX3ByaXZrZXkpOwogCXdwYWJ1Zl9mcmVlKHdwYV9zLT53cHMtPm9vYl9jb25mLnB1YmtleV9oYXNoKTsKIAl3cGFidWZfZnJlZSh3cGFfcy0+d3BzLT5vb2JfY29uZi5kZXZfcGFzc3dvcmQpOworCXdwYWJ1Zl9mcmVlKHdwYV9zLT53cHMtPmRldi52ZW5kb3JfZXh0X20xKTsKIAlvc19mcmVlKHdwYV9zLT53cHMtPm5ldHdvcmtfa2V5KTsKIAlvc19mcmVlKHdwYV9zLT53cHMpOwogCXdwYV9zLT53cHMgPSBOVUxMOwpAQCAtMTY0OCw2ICsxNjc0LDM0IEBACiB9CiAKIAorI2lmZGVmIENPTkZJR19XUFNfTkZDCitzdHJ1Y3Qgd3BhYnVmICogd3Bhc193cHNfZXJfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgIGludCBuZGVmLCBjb25zdCBjaGFyICp1dWlkKQoreworCXN0cnVjdCB3cGFidWYgKnJldDsKKwl1OCB1W1VVSURfTEVOXTsKKworCWlmICghd3BhX3MtPndwc19lcikKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAodXVpZF9zdHIyYmluKHV1aWQsIHUpKQorCQlyZXR1cm4gTlVMTDsKKworCXJldCA9IHdwc19lcl9uZmNfY29uZmlnX3Rva2VuKHdwYV9zLT53cHNfZXIsIHUpOworCWlmIChuZGVmICYmIHJldCkgeworCQlzdHJ1Y3Qgd3BhYnVmICp0bXA7CisJCXRtcCA9IG5kZWZfYnVpbGRfd2lmaShyZXQpOworCQl3cGFidWZfZnJlZShyZXQpOworCQlpZiAodG1wID09IE5VTEwpCisJCQlyZXR1cm4gTlVMTDsKKwkJcmV0ID0gdG1wOworCX0KKworCXJldHVybiByZXQ7Cit9CisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KKworCiBzdGF0aWMgaW50IGNhbGxiYWNrc19wZW5kaW5nID0gMDsKIAogc3RhdGljIHZvaWQgd3Bhc193cHNfdGVybWluYXRlX2NiKHZvaWQgKmN0eCkKQEAgLTE3MTcsNiArMTc3MSw5IEBACiAJCQkgIHdwcy0+ZGV2Lm51bV9zZWNfZGV2X3R5cGVzICogV1BTX0RFVl9UWVBFX0xFTik7CiAJfQogCisJaWYgKHdwYV9zLT5jb25mLT5jaGFuZ2VkX3BhcmFtZXRlcnMgJiBDRkdfQ0hBTkdFRF9WRU5ET1JfRVhURU5TSU9OKQorCQl3cGFzX3dwc19zZXRfdmVuZG9yX2V4dF9tMSh3cGFfcywgd3BzKTsKKwogCWlmICh3cGFfcy0+Y29uZi0+Y2hhbmdlZF9wYXJhbWV0ZXJzICYgQ0ZHX0NIQU5HRURfT1NfVkVSU0lPTikKIAkJd3BzLT5kZXYub3NfdmVyc2lvbiA9IFdQQV9HRVRfQkUzMih3cGFfcy0+Y29uZi0+b3NfdmVyc2lvbik7CiAKQEAgLTE3MzMsMyArMTc5MCwxMzIgQEAKIAkJd3BzLT5kZXYuc2VyaWFsX251bWJlciA9IHdwYV9zLT5jb25mLT5zZXJpYWxfbnVtYmVyOwogCX0KIH0KKworCisjaWZkZWYgQ09ORklHX1dQU19ORkMKKworc3RydWN0IHdwYWJ1ZiAqIHdwYXNfd3BzX25mY190b2tlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBpbnQgbmRlZikKK3sKKwlyZXR1cm4gd3BzX25mY190b2tlbl9nZW4obmRlZiwgJndwYV9zLT5jb25mLT53cHNfbmZjX2Rldl9wd19pZCwKKwkJCQkgJndwYV9zLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSwKKwkJCQkgJndwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXksCisJCQkJICZ3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHcpOworfQorCisKK2ludCB3cGFzX3dwc19zdGFydF9uZmMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgdTggKmJzc2lkKQoreworCXN0cnVjdCB3cHNfY29udGV4dCAqd3BzID0gd3BhX3MtPndwczsKKwljaGFyIHB3WzMyICogMiArIDFdOworCisJaWYgKHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSA9PSBOVUxMIHx8CisJICAgIHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3ByaXZrZXkgPT0gTlVMTCB8fAorCSAgICB3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHcgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJZGg1X2ZyZWUod3BzLT5kaF9jdHgpOworCXdwYWJ1Zl9mcmVlKHdwcy0+ZGhfcHVia2V5KTsKKwl3cGFidWZfZnJlZSh3cHMtPmRoX3ByaXZrZXkpOworCXdwcy0+ZGhfcHJpdmtleSA9IHdwYWJ1Zl9kdXAod3BhX3MtPmNvbmYtPndwc19uZmNfZGhfcHJpdmtleSk7CisJd3BzLT5kaF9wdWJrZXkgPSB3cGFidWZfZHVwKHdwYV9zLT5jb25mLT53cHNfbmZjX2RoX3B1YmtleSk7CisJaWYgKHdwcy0+ZGhfcHJpdmtleSA9PSBOVUxMIHx8IHdwcy0+ZGhfcHVia2V5ID09IE5VTEwpIHsKKwkJd3BzLT5kaF9jdHggPSBOVUxMOworCQl3cGFidWZfZnJlZSh3cHMtPmRoX3B1YmtleSk7CisJCXdwcy0+ZGhfcHVia2V5ID0gTlVMTDsKKwkJd3BhYnVmX2ZyZWUod3BzLT5kaF9wcml2a2V5KTsKKwkJd3BzLT5kaF9wcml2a2V5ID0gTlVMTDsKKwkJcmV0dXJuIC0xOworCX0KKwl3cHMtPmRoX2N0eCA9IGRoNV9pbml0X2ZpeGVkKHdwcy0+ZGhfcHJpdmtleSwgd3BzLT5kaF9wdWJrZXkpOworCWlmICh3cHMtPmRoX2N0eCA9PSBOVUxMKQorCQlyZXR1cm4gLTE7CisKKwl3cGFfc25wcmludGZfaGV4X3VwcGVyY2FzZShwdywgc2l6ZW9mKHB3KSwKKwkJCQkgICB3cGFidWZfaGVhZCh3cGFfcy0+Y29uZi0+d3BzX25mY19kZXZfcHcpLAorCQkJCSAgIHdwYWJ1Zl9sZW4od3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3KSk7CisJcmV0dXJuIHdwYXNfd3BzX3N0YXJ0X3Bpbih3cGFfcywgYnNzaWQsIHB3LCAwLAorCQkJCSAgd3BhX3MtPmNvbmYtPndwc19uZmNfZGV2X3B3X2lkKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfd3BzX3VzZV9jcmVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkgICAgIHN0cnVjdCB3cHNfcGFyc2VfYXR0ciAqYXR0cikKK3sKKwlpZiAod3BzX29vYl91c2VfY3JlZCh3cGFfcy0+d3BzLCBhdHRyKSA8IDApCisJCXJldHVybiAtMTsKKworCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpCisJCXJldHVybiAwOworCisJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IFJlcXVlc3QgcmVjb25uZWN0aW9uIHdpdGggbmV3IG5ldHdvcmsgIgorCQkgICAiYmFzZWQgb24gdGhlIHJlY2VpdmVkIGNyZWRlbnRpYWwgYWRkZWQiKTsKKwl3cGFfcy0+bm9ybWFsX3NjYW5zID0gMDsKKwl3cGFfc3VwcGxpY2FudF9yZWluaXRfYXV0b3NjYW4od3BhX3MpOworCXdwYV9zLT5kaXNjb25uZWN0ZWQgPSAwOworCXdwYV9zLT5yZWFzc29jaWF0ZSA9IDE7CisJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludCB3cGFzX3dwc19hZGRfbmZjX3Bhc3N3b3JkX3Rva2VuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCisJCQkJCSAgIHN0cnVjdCB3cHNfcGFyc2VfYXR0ciAqYXR0cikKK3sKKwlyZXR1cm4gd3BzX3JlZ2lzdHJhcl9hZGRfbmZjX3Bhc3N3b3JkX3Rva2VuKAorCQl3cGFfcy0+d3BzLT5yZWdpc3RyYXIsIGF0dHItPm9vYl9kZXZfcGFzc3dvcmQsCisJCWF0dHItPm9vYl9kZXZfcGFzc3dvcmRfbGVuKTsKK30KKworCitzdGF0aWMgaW50IHdwYXNfd3BzX25mY190YWdfcHJvY2VzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCSAgICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICp3cHMpCit7CisJc3RydWN0IHdwc19wYXJzZV9hdHRyIGF0dHI7CisKKwl3cGFfaGV4ZHVtcF9idWYoTVNHX0RFQlVHLCAiV1BTOiBSZWNlaXZlZCBORkMgdGFnIHBheWxvYWQiLCB3cHMpOworCisJaWYgKHdwc19wYXJzZV9tc2cod3BzLCAmYXR0cikpIHsKKwkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJXUFM6IElnbm9yZSBpbnZhbGlkIGRhdGEgZnJvbSBORkMgdGFnIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoYXR0ci5udW1fY3JlZCkKKwkJcmV0dXJuIHdwYXNfd3BzX3VzZV9jcmVkKHdwYV9zLCAmYXR0cik7CisKKyNpZmRlZiBDT05GSUdfV1BTX0VSCisJaWYgKGF0dHIub29iX2Rldl9wYXNzd29yZCkKKwkJcmV0dXJuIHdwYXNfd3BzX2FkZF9uZmNfcGFzc3dvcmRfdG9rZW4od3BhX3MsICZhdHRyKTsKKyNlbmRpZiAvKiBDT05GSUdfV1BTX0VSICovCisKKwl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSWdub3JlIHVucmVjb2duaXplZCBORkMgdGFnIik7CisJcmV0dXJuIC0xOworfQorCisKK2ludCB3cGFzX3dwc19uZmNfdGFnX3JlYWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKKwkJCSAgY29uc3Qgc3RydWN0IHdwYWJ1ZiAqZGF0YSkKK3sKKwljb25zdCBzdHJ1Y3Qgd3BhYnVmICp3cHMgPSBkYXRhOworCXN0cnVjdCB3cGFidWYgKnRtcCA9IE5VTEw7CisJaW50IHJldDsKKworCWlmICh3cGFidWZfbGVuKGRhdGEpIDwgNCkKKwkJcmV0dXJuIC0xOworCisJaWYgKCp3cGFidWZfaGVhZF91OChkYXRhKSAhPSAweDEwKSB7CisJCS8qIEFzc3VtZSB0aGlzIGNvbnRhaW5zIGZ1bGwgTkRFRiByZWNvcmQgKi8KKwkJdG1wID0gbmRlZl9wYXJzZV93aWZpKGRhdGEpOworCQlpZiAodG1wID09IE5VTEwpIHsKKwkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBDb3VsZCBub3QgcGFyc2UgTkRFRiIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCXdwcyA9IHRtcDsKKwl9CisKKwlyZXQgPSB3cGFzX3dwc19uZmNfdGFnX3Byb2Nlc3Mod3BhX3MsIHdwcyk7CisJd3BhYnVmX2ZyZWUodG1wKTsKKwlyZXR1cm4gcmV0OworfQorCisjZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KZGlmZiAtLWdpdCBhL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmggYi93cGFfc3VwcGxpY2FudC93cHNfc3VwcGxpY2FudC5oCmluZGV4IGE1NDcyYTAuLjVhNDlhOGYgMTAwNjQ0Ci0tLSBhL3dwYV9zdXBwbGljYW50L3dwc19zdXBwbGljYW50LmgKKysrIGIvd3BhX3N1cHBsaWNhbnQvd3BzX3N1cHBsaWNhbnQuaApAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiB3cGFfc3VwcGxpY2FudCAvIFdQUyBpbnRlZ3JhdGlvbgotICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMDksIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMiwgSm91bmkgTWFsaW5lbiA8akB3MS5maT4KICAqCiAgKiBUaGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEJTRCBsaWNlbnNlLgogICogU2VlIFJFQURNRSBmb3IgbW9yZSBkZXRhaWxzLgpAQCAtNTksOSArNTksMTUgQEAKIAkJCSAgIGludCBpZCk7CiBpbnQgd3Bhc193cHNfZXJfY29uZmlnKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKnV1aWQsCiAJCSAgICAgICBjb25zdCBjaGFyICpwaW4sIHN0cnVjdCB3cHNfbmV3X2FwX3NldHRpbmdzICpzZXR0aW5ncyk7CitzdHJ1Y3Qgd3BhYnVmICogd3Bhc193cHNfZXJfbmZjX2NvbmZpZ190b2tlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJCQkgICAgIGludCBuZGVmLCBjb25zdCBjaGFyICp1dWlkKTsKIGludCB3cGFzX3dwc190ZXJtaW5hdGVfcGVuZGluZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIGludCB3cGFzX3dwc19pbl9wcm9ncmVzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKIHZvaWQgd3Bhc193cHNfdXBkYXRlX2NvbmZpZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKTsKK3N0cnVjdCB3cGFidWYgKiB3cGFzX3dwc19uZmNfdG9rZW4oc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgaW50IG5kZWYpOworaW50IHdwYXNfd3BzX3N0YXJ0X25mYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjb25zdCB1OCAqYnNzaWQpOworaW50IHdwYXNfd3BzX25mY190YWdfcmVhZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAorCQkJICBjb25zdCBzdHJ1Y3Qgd3BhYnVmICpkYXRhKTsKIAogI2Vsc2UgLyogQ09ORklHX1dQUyAqLwogCg==