ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvS2NvbmZpZyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNTVkZWUzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9LY29uZmlnCkBAIC0wLDAgKzEsMTg1IEBACisjCisjIElucHV0IGNvcmUgY29uZmlndXJhdGlvbgorIworbWVudWNvbmZpZyBJTlBVVF9LRVlCT0FSRAorCWJvb2wgIktleWJvYXJkcyIgaWYgRU1CRURERUQgfHwgIVg4NgorCWRlZmF1bHQgeQorCWhlbHAKKwkgIFNheSBZIGhlcmUsIGFuZCBhIGxpc3Qgb2Ygc3VwcG9ydGVkIGtleWJvYXJkcyB3aWxsIGJlIGRpc3BsYXllZC4KKwkgIFRoaXMgb3B0aW9uIGRvZXNuJ3QgYWZmZWN0IHRoZSBrZXJuZWwuCisKKwkgIElmIHVuc3VyZSwgc2F5IFkuCisKK2lmIElOUFVUX0tFWUJPQVJECisKK2NvbmZpZyBLRVlCT0FSRF9BVEtCRAorCXRyaXN0YXRlICJBVCBrZXlib2FyZCIgaWYgIVBDCisJZGVmYXVsdCB5CisJc2VsZWN0IFNFUklPCisJc2VsZWN0IFNFUklPX0xJQlBTMgorCXNlbGVjdCBTRVJJT19JODA0MiBpZiBQQworCXNlbGVjdCBTRVJJT19HU0NQUzIgaWYgR1NDCisJaGVscAorCSAgU2F5IFkgaGVyZSBpZiB5b3Ugd2FudCB0byB1c2UgYSBzdGFuZGFyZCBBVCBvciBQUy8yIGtleWJvYXJkLiBVc3VhbGx5CisJICB5b3UnbGwgbmVlZCB0aGlzLCB1bmxlc3MgeW91IGhhdmUgYSBkaWZmZXJlbnQgdHlwZSBrZXlib2FyZCAoVVNCLCBBREIKKwkgIG9yIG90aGVyKS4gVGhpcyBhbHNvIHdvcmtzIGZvciBBVCBhbmQgUFMvMiBrZXlib2FyZHMgY29ubmVjdGVkIG92ZXIgYQorCSAgUFMvMiB0byBzZXJpYWwgY29udmVydGVyLgorCisJICBJZiB1bnN1cmUsIHNheSBZLgorCisJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUKKwkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBhdGtiZC4KKworY29uZmlnIEtFWUJPQVJEX0FUS0JEX0hQX0tFWUNPREVTCisJYm9vbCAiVXNlIEhQIGtleWJvYXJkIHNjYW5jb2RlcyIKKwlkZXBlbmRzIG9uIFBBUklTQyAmJiBLRVlCT0FSRF9BVEtCRAorCWRlZmF1bHQgeQorCWhlbHAKKwkgIFNheSBZIGhlcmUgaWYgeW91IGhhdmUgYSBQQS1SSVNDIG1hY2hpbmUgYW5kIHdhbnQgdG8gdXNlIGFuIEFUIG9yCisJICBQUy8yIGtleWJvYXJkLCBhbmQgeW91ciBrZXlib2FyZCB1c2VzIGtleWNvZGVzIHRoYXQgYXJlIHNwZWNpZmljIHRvCisJICBQQS1SSVNDIGtleWJvYXJkcy4KKworCSAgU2F5IE4gaWYgeW91IHVzZSBhIHN0YW5kYXJkIGtleWJvYXJkLgorCitjb25maWcgS0VZQk9BUkRfQVRLQkRfUkRJX0tFWUNPREVTCisJYm9vbCAiVXNlIFByZWNpc2lvbkJvb2sga2V5Ym9hcmQgc2NhbmNvZGVzIgorCWRlcGVuZHMgb24gS0VZQk9BUkRfQVRLQkRfSFBfS0VZQ09ERVMKKwlkZWZhdWx0IG4KKwloZWxwCisJICBJZiB5b3UgaGF2ZSBhbiBSREkgUHJlY2lzaW9uQm9vaywgc2F5IFkgaGVyZSBpZiB5b3Ugd2FudCB0byB1c2UgaXRzCisJICBidWlsdC1pbiBrZXlib2FyZCAoYXMgb3Bwb3NlZCB0byBhbiBleHRlcm5hbCBrZXlib2FyZCkuCisKKwkgIFRoZSBQcmVjaXNpb25Cb29rIGhhcyBmaXZlIGtleXMgdGhhdCBjb25mbGljdCB3aXRoIHRob3NlIHVzZWQgYnkgbW9zdAorCSAgQVQgYW5kIFBTLzIga2V5Ym9hcmRzLiBUaGVzZSBhcmUgYXMgZm9sbG93czoKKworCSAgICBQcmVjaXNpb25Cb29rICAgIFN0YW5kYXJkIEFUIG9yIFBTLzIKKworCSAgICBGMSAgICAgICAgICAgICAgIEYxMgorCSAgICBMZWZ0IEN0cmwgICAgICAgIExlZnQgQWx0CisJICAgIENhcHMgTG9jayAgICAgICAgTGVmdCBDdHJsCisJICAgIFJpZ2h0IEN0cmwgICAgICAgQ2FwcyBMb2NrCisJICAgIExlZnQgICAgICAgICAgICAgMTAybmQga2V5ICh0aGUga2V5IHRvIHRoZSByaWdodCBvZiBMZWZ0IFNoaWZ0KQorCisJICBJZiB5b3Ugc2F5IE4gaGVyZSwgYW5kIHVzZSB0aGUgUHJlY2lzaW9uQm9vayBrZXlib2FyZCwgdGhlbiBlYWNoIGtleQorCSAgaW4gdGhlIGxlZnQtaGFuZCBjb2x1bW4gd2lsbCBiZSBpbnRlcnByZXRlZCBhcyB0aGUgY29ycmVzcG9uZGluZyBrZXkKKwkgIGluIHRoZSByaWdodC1oYW5kIGNvbHVtbi4KKworCSAgSWYgeW91IHNheSBZIGhlcmUsIGFuZCB1c2UgYW4gZXh0ZXJuYWwga2V5Ym9hcmQsIHRoZW4gZWFjaCBrZXkgaW4gdGhlCisJICByaWdodC1oYW5kIGNvbHVtbiB3aWxsIGJlIGludGVycHJldGVkIGFzIHRoZSBrZXkgc2hvd24gaW4gdGhlCisJICBsZWZ0LWhhbmQgY29sdW1uLgorCitjb25maWcgS0VZQk9BUkRfU1VOS0JECisJdHJpc3RhdGUgIlN1biBUeXBlIDQgYW5kIFR5cGUgNSBrZXlib2FyZCIKKwlzZWxlY3QgU0VSSU8KKwloZWxwCisJICBTYXkgWSBoZXJlIGlmIHlvdSB3YW50IHRvIHVzZSBhIFN1biBUeXBlIDQgb3IgVHlwZSA1IGtleWJvYXJkLAorCSAgY29ubmVjdGVkIGVpdGhlciB0byB0aGUgU3VuIGtleWJvYXJkIGNvbm5lY3RvciBvciB0byBhbiBzZXJpYWwKKwkgIChSUy0yMzIpIHBvcnQgdmlhIGEgc2ltcGxlIGFkYXB0ZXIuCisKKwkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQorCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIHN1bmtiZC4KKworY29uZmlnIEtFWUJPQVJEX0xLS0JECisJdHJpc3RhdGUgIkRFQ3N0YXRpb24vVkFYc3RhdGlvbiBMSzIwMS9MSzQwMSBrZXlib2FyZCIKKwlzZWxlY3QgU0VSSU8KKwloZWxwCisJICBTYXkgWSBoZXJlIGlmIHlvdSB3YW50IHRvIHVzZSBhIExLMjAxIG9yIExLNDAxIHN0eWxlIHNlcmlhbAorCSAga2V5Ym9hcmQuIFRoaXMga2V5Ym9hcmQgaXMgYWxzbyB1c2VhYmxlIG9uIFBDcyBpZiB5b3UgYXR0YWNoCisJICBpdCB3aXRoIHRoZSBpbnB1dGF0dGFjaCBwcm9ncmFtLiBUaGUgY29ubmVjdG9yIHBpbm91dCBpcworCSAgZGVzY3JpYmVkIHdpdGhpbiBsa2tiZC5jLgorCisJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUKKwkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBsa2tiZC4KKworY29uZmlnIEtFWUJPQVJEX0xPQ09NTworCXRyaXN0YXRlICJMb0NvTW8gS2V5Ym9hcmQgU3VwcG9ydCIKKwlkZXBlbmRzIG9uIFNIQVJQX0xPQ09NTworCWhlbHAKKwkgIFNheSBZIGhlcmUgaWYgeW91IGFyZSBydW5uaW5nIExpbnV4IG9uIGEgU2hhcnAgWmF1cnVzIENvbGxpZSBvciBQb29kbGUgYmFzZWQgUERBCisKKwkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQorCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGxvY29tb2tiZC4KKworY29uZmlnIEtFWUJPQVJEX1hUS0JECisJdHJpc3RhdGUgIlhUIGtleWJvYXJkIgorCXNlbGVjdCBTRVJJTworCWhlbHAKKwkgIFNheSBZIGhlcmUgaWYgeW91IHdhbnQgdG8gdXNlIHRoZSBvbGQgSUJNIFBDL1hUIGtleWJvYXJkIChvcgorCSAgY29tcGF0aWJsZSkgb24geW91ciBzeXN0ZW0uIFRoaXMgaXMgb25seSBwb3NzaWJsZSB3aXRoIGEKKwkgIHBhcmFsbGVsIHBvcnQga2V5Ym9hcmQgYWRhcHRlciwgeW91IGNhbm5vdCBjb25uZWN0IGl0IHRvIHRoZQorCSAga2V5Ym9hcmQgcG9ydCBvbiBhIFBDIHRoYXQgcnVucyBMaW51eC4KKworCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlCisJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgeHRrYmQuCisKK2NvbmZpZyBLRVlCT0FSRF9ORVdUT04KKwl0cmlzdGF0ZSAiTmV3dG9uIGtleWJvYXJkIgorCXNlbGVjdCBTRVJJTworCWhlbHAKKwkgIFNheSBZIGhlcmUgaWYgeW91IGhhdmUgYSBOZXd0b24ga2V5Ym9hcmQgb24gYSBzZXJpYWwgcG9ydC4KKworCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlCisJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgbmV3dG9ua2JkLgorCitjb25maWcgS0VZQk9BUkRfQ09SR0kKKwl0cmlzdGF0ZSAiQ29yZ2kga2V5Ym9hcmQiCisJZGVwZW5kcyBvbiBQWEFfU0hBUlBTTAorCWRlZmF1bHQgeQkKKwloZWxwCisJICBTYXkgWSBoZXJlIHRvIGVuYWJsZSB0aGUga2V5Ym9hcmQgb24gdGhlIFNoYXJwIFphdXJ1cyBTTC1DN3h4IAorCSAgc2VyaWVzIG9mIFBEQXMuCisKKwkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZSAKKwkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBjb3JnaWtiZC4KKworY29uZmlnIEtFWUJPQVJEX01BUExFCisJdHJpc3RhdGUgIk1hcGxlIGJ1cyBrZXlib2FyZCIKKwlkZXBlbmRzIG9uIFNIX0RSRUFNQ0FTVCAmJiBNQVBMRQorCWhlbHAKKwkgIFNheSBZIGhlcmUgaWYgeW91IGhhdmUgYSBEcmVhbUNhc3QgY29uc29sZSBydW5uaW5nIExpbnV4IGFuZCBoYXZlCisJICBhIGtleWJvYXJkIGF0dGFjaGVkIHRvIGl0cyBNYXBsZSBidXMuCisKKwkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQorCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIG1hcGxlX2tleWIuCisKK2NvbmZpZyBLRVlCT0FSRF9BTUlHQQorCXRyaXN0YXRlICJBbWlnYSBrZXlib2FyZCIKKwlkZXBlbmRzIG9uIEFNSUdBCisJaGVscAorCSAgU2F5IFkgaGVyZSBpZiB5b3UgYXJlIHJ1bm5pbmcgTGludXggb24gYW55IEFNSUdBIGFuZCBoYXZlIGEga2V5Ym9hcmQKKwkgIGF0dGFjaGVkLgorCisJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUKKwkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBhbWlrYmQuCisKK2NvbmZpZyBLRVlCT0FSRF9ISUxfT0xECisJdHJpc3RhdGUgIkhQIEhJTCBrZXlib2FyZCBzdXBwb3J0IChzaW1wbGUgZHJpdmVyKSIKKwlkZXBlbmRzIG9uIEdTQworCWRlZmF1bHQgeQorCWhlbHAKKwkgIFRoZSAiSHVtYW4gSW50ZXJmYWNlIExvb3AiIGlzIGEgb2xkZXIsIDgtY2hhbm5lbCBVU0ItbGlrZQorCSAgY29udHJvbGxlciB1c2VkIGluIHNldmVyYWwgSGV3bGV0dCBQYWNrYXJkIG1vZGVscy4gVGhpcyBkcml2ZXIKKwkgIHdhcyBhZGFwdGVkIGZyb20gdGhlIG9uZSB3cml0dGVuIGZvciBtNjhrL2hwMzAwLCBhbmQgaW1wbGVtZW50cworCSAgc3VwcG9ydCBmb3IgYSBrZXlib2FyZCBhdHRhY2hlZCB0byB0aGUgSElMIHBvcnQsIGJ1dCBub3QgZm9yCisJICBhbnkgb3RoZXIgdHlwZXMgb2YgSElMIGlucHV0IGRldmljZXMgbGlrZSBtaWNlIG9yIHRhYmxldHMuCisJICBIb3dldmVyLCBpdCBoYXMgYmVlbiB0aG9yb3VnaGx5IHRlc3RlZCBhbmQgaXMgc3RhYmxlLgorCisJICBJZiB5b3Ugd2FudCBmdWxsIEhJTCBzdXBwb3J0IGluY2x1ZGluZyBzdXBwb3J0IGZvciBtdWx0aXBsZQorCSAga2V5Ym9hcmRzLCBtaWNlcyBhbmQgdGFibGV0cywgeW91IGhhdmUgdG8gZW5hYmxlIHRoZQorCSAgIkhQIFN5c3RlbSBEZXZpY2UgQ29udHJvbGxlciBpODA0MiBTdXBwb3J0IiBpbiB0aGUgaW5wdXQvc2VyaW8KKwkgIHN1Ym1lbnUuCisKK2NvbmZpZyBLRVlCT0FSRF9ISUwKKwl0cmlzdGF0ZSAiSFAgSElMIGtleWJvYXJkIHN1cHBvcnQiCisJZGVwZW5kcyBvbiBHU0MKKwlkZWZhdWx0IHkKKwlzZWxlY3QgSFBfU0RDCisJc2VsZWN0IEhJTF9NTEMKKwlzZWxlY3QgU0VSSU8KKwloZWxwCisJICBUaGUgIkh1bWFuIEludGVyZmFjZSBMb29wIiBpcyBhIG9sZGVyLCA4LWNoYW5uZWwgVVNCLWxpa2UKKwkgIGNvbnRyb2xsZXIgdXNlZCBpbiBzZXZlcmFsIEhld2xldHQgUGFja2FyZCBtb2RlbHMuCisJICBUaGlzIGRyaXZlciBpbXBsZW1lbnRzIHN1cHBvcnQgZm9yIEhJTC1rZXlib2FyZHMgYXR0YWNoZWQKKwkgIHRvIHlvdXIgbWFjaGluZSwgc28gbm9ybWFsbHkgeW91IHNob3VsZCBzYXkgWSBoZXJlLgorCitlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9NYWtlZmlsZSBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjAyZWVjZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvTWFrZWZpbGUKQEAgLTAsMCArMSwxOSBAQAorIworIyBNYWtlZmlsZSBmb3IgdGhlIGlucHV0IGNvcmUgZHJpdmVycy4KKyMKKworIyBFYWNoIGNvbmZpZ3VyYXRpb24gb3B0aW9uIGVuYWJsZXMgYSBsaXN0IG9mIGZpbGVzLgorCitvYmotJChDT05GSUdfS0VZQk9BUkRfQVRLQkQpCQkrPSBhdGtiZC5vCitvYmotJChDT05GSUdfS0VZQk9BUkRfTUFQTEUpCQkrPSBtYXBsZV9rZXliLm8KK29iai0kKENPTkZJR19LRVlCT0FSRF9TVU5LQkQpCQkrPSBzdW5rYmQubworb2JqLSQoQ09ORklHX0tFWUJPQVJEX0xLS0JEKQkJKz0gbGtrYmQubworb2JqLSQoQ09ORklHX0tFWUJPQVJEX1hUS0JEKQkJKz0geHRrYmQubworb2JqLSQoQ09ORklHX0tFWUJPQVJEX0FNSUdBKQkJKz0gYW1pa2JkLm8KK29iai0kKENPTkZJR19LRVlCT0FSRF9MT0NPTU8pCQkrPSBsb2NvbW9rYmQubworb2JqLSQoQ09ORklHX0tFWUJPQVJEX05FV1RPTikJCSs9IG5ld3RvbmtiZC5vCitvYmotJChDT05GSUdfS0VZQk9BUkRfOThLQkQpCQkrPSA5OGtiZC5vCitvYmotJChDT05GSUdfS0VZQk9BUkRfQ09SR0kpCQkrPSBjb3JnaWtiZC5vCitvYmotJChDT05GSUdfS0VZQk9BUkRfSElMKQkJKz0gaGlsX2tiZC5vCitvYmotJChDT05GSUdfS0VZQk9BUkRfSElMX09MRCkJCSs9IGhpbGtiZC5vCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvYW1pa2JkLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2FtaWtiZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRlOGU4ZWEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2FtaWtiZC5jCkBAIC0wLDAgKzEsMjQxIEBACisvKgorICogJElkOiBhbWlrYmQuYyx2IDEuMTMgMjAwMi8wMi8wMSAxNjowMjoyNCB2b2p0ZWNoIEV4cCAkCisgKgorICogIENvcHlyaWdodCAoYykgMjAwMC0yMDAxIFZvanRlY2ggUGF2bGlrCisgKgorICogIEJhc2VkIG9uIHRoZSB3b3JrIG9mOgorICoJSGFtaXNoIE1hY2RvbmFsZAorICovCisKKy8qCisgKiBBbWlnYSBrZXlib2FyZCBkcml2ZXIgZm9yIExpbnV4L202OGsKKyAqLworCisvKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKiBTaG91bGQgeW91IG5lZWQgdG8gY29udGFjdCBtZSwgdGhlIGF1dGhvciwgeW91IGNhbiBkbyBzbyBlaXRoZXIgYnkKKyAqIGUtbWFpbCAtIG1haWwgeW91ciBtZXNzYWdlIHRvIDx2b2p0ZWNoQHVjdy5jej4sIG9yIGJ5IHBhcGVyIG1haWw6CisgKiBWb2p0ZWNoIFBhdmxpaywgU2ltdW5rb3ZhIDE1OTQsIFByYWd1ZSA4LCAxODIgMDAgQ3plY2ggUmVwdWJsaWMKKyAqLworCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKworI2luY2x1ZGUgPGFzbS9hbWlnYWludHMuaD4KKyNpbmNsdWRlIDxhc20vYW1pZ2Fody5oPgorI2luY2x1ZGUgPGFzbS9pcnEuaD4KKworTU9EVUxFX0FVVEhPUigiVm9qdGVjaCBQYXZsaWsgPHZvanRlY2hAdWN3LmN6PiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJBbWlnYSBrZXlib2FyZCBkcml2ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKKworc3RhdGljIHVuc2lnbmVkIGNoYXIgYW1pa2JkX2tleWNvZGVbMHg3OF0gPSB7CisJWzBdCSA9IEtFWV9HUkFWRSwKKwlbMV0JID0gS0VZXzEsCisJWzJdCSA9IEtFWV8yLAorCVszXQkgPSBLRVlfMywKKwlbNF0JID0gS0VZXzQsCisJWzVdCSA9IEtFWV81LAorCVs2XQkgPSBLRVlfNiwKKwlbN10JID0gS0VZXzcsCisJWzhdCSA9IEtFWV84LAorCVs5XQkgPSBLRVlfOSwKKwlbMTBdCSA9IEtFWV8wLAorCVsxMV0JID0gS0VZX01JTlVTLAorCVsxMl0JID0gS0VZX0VRVUFMLAorCVsxM10JID0gS0VZX0JBQ0tTTEFTSCwKKwlbMTVdCSA9IEtFWV9LUDAsCisJWzE2XQkgPSBLRVlfUSwKKwlbMTddCSA9IEtFWV9XLAorCVsxOF0JID0gS0VZX0UsCisJWzE5XQkgPSBLRVlfUiwKKwlbMjBdCSA9IEtFWV9ULAorCVsyMV0JID0gS0VZX1ksCisJWzIyXQkgPSBLRVlfVSwKKwlbMjNdCSA9IEtFWV9JLAorCVsyNF0JID0gS0VZX08sCisJWzI1XQkgPSBLRVlfUCwKKwlbMjZdCSA9IEtFWV9MRUZUQlJBQ0UsCisJWzI3XQkgPSBLRVlfUklHSFRCUkFDRSwKKwlbMjldCSA9IEtFWV9LUDEsCisJWzMwXQkgPSBLRVlfS1AyLAorCVszMV0JID0gS0VZX0tQMywKKwlbMzJdCSA9IEtFWV9BLAorCVszM10JID0gS0VZX1MsCisJWzM0XQkgPSBLRVlfRCwKKwlbMzVdCSA9IEtFWV9GLAorCVszNl0JID0gS0VZX0csCisJWzM3XQkgPSBLRVlfSCwKKwlbMzhdCSA9IEtFWV9KLAorCVszOV0JID0gS0VZX0ssCisJWzQwXQkgPSBLRVlfTCwKKwlbNDFdCSA9IEtFWV9TRU1JQ09MT04sCisJWzQyXQkgPSBLRVlfQVBPU1RST1BIRSwKKwlbNDNdCSA9IEtFWV9CQUNLU0xBU0gsCisJWzQ1XQkgPSBLRVlfS1A0LAorCVs0Nl0JID0gS0VZX0tQNSwKKwlbNDddCSA9IEtFWV9LUDYsCisJWzQ4XQkgPSBLRVlfMTAyTkQsCisJWzQ5XQkgPSBLRVlfWiwKKwlbNTBdCSA9IEtFWV9YLAorCVs1MV0JID0gS0VZX0MsCisJWzUyXQkgPSBLRVlfViwKKwlbNTNdCSA9IEtFWV9CLAorCVs1NF0JID0gS0VZX04sCisJWzU1XQkgPSBLRVlfTSwKKwlbNTZdCSA9IEtFWV9DT01NQSwKKwlbNTddCSA9IEtFWV9ET1QsCisJWzU4XQkgPSBLRVlfU0xBU0gsCisJWzYwXQkgPSBLRVlfS1BET1QsCisJWzYxXQkgPSBLRVlfS1A3LAorCVs2Ml0JID0gS0VZX0tQOCwKKwlbNjNdCSA9IEtFWV9LUDksCisJWzY0XQkgPSBLRVlfU1BBQ0UsCisJWzY1XQkgPSBLRVlfQkFDS1NQQUNFLAorCVs2Nl0JID0gS0VZX1RBQiwKKwlbNjddCSA9IEtFWV9LUEVOVEVSLAorCVs2OF0JID0gS0VZX0VOVEVSLAorCVs2OV0JID0gS0VZX0VTQywKKwlbNzBdCSA9IEtFWV9ERUxFVEUsCisJWzc0XQkgPSBLRVlfS1BNSU5VUywKKwlbNzZdCSA9IEtFWV9VUCwKKwlbNzddCSA9IEtFWV9ET1dOLAorCVs3OF0JID0gS0VZX1JJR0hULAorCVs3OV0JID0gS0VZX0xFRlQsCisJWzgwXQkgPSBLRVlfRjEsCisJWzgxXQkgPSBLRVlfRjIsCisJWzgyXQkgPSBLRVlfRjMsCisJWzgzXQkgPSBLRVlfRjQsCisJWzg0XQkgPSBLRVlfRjUsCisJWzg1XQkgPSBLRVlfRjYsCisJWzg2XQkgPSBLRVlfRjcsCisJWzg3XQkgPSBLRVlfRjgsCisJWzg4XQkgPSBLRVlfRjksCisJWzg5XQkgPSBLRVlfRjEwLAorCVs5MF0JID0gS0VZX0tQTEVGVFBBUkVOLAorCVs5MV0JID0gS0VZX0tQUklHSFRQQVJFTiwKKwlbOTJdCSA9IEtFWV9LUFNMQVNILAorCVs5M10JID0gS0VZX0tQQVNURVJJU0ssCisJWzk0XQkgPSBLRVlfS1BQTFVTLAorCVs5NV0JID0gS0VZX0hFTFAsCisJWzk2XQkgPSBLRVlfTEVGVFNISUZULAorCVs5N10JID0gS0VZX1JJR0hUU0hJRlQsCisJWzk4XQkgPSBLRVlfQ0FQU0xPQ0ssCisJWzk5XQkgPSBLRVlfTEVGVENUUkwsCisJWzEwMF0JID0gS0VZX0xFRlRBTFQsCisJWzEwMV0JID0gS0VZX1JJR0hUQUxULAorCVsxMDJdCSA9IEtFWV9MRUZUTUVUQSwKKwlbMTAzXQkgPSBLRVlfUklHSFRNRVRBCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqYW1pa2JkX21lc3NhZ2VzWzhdID0geworCVswXSA9IEtFUk5fQUxFUlQgImFtaWtiZDogQ3RybC1BbWlnYS1BbWlnYSByZXNldCB3YXJuaW5nISFcbiIsCisJWzFdID0gS0VSTl9XQVJOSU5HICJhbWlrYmQ6IGtleWJvYXJkIGxvc3Qgc3luY1xuIiwKKwlbMl0gPSBLRVJOX1dBUk5JTkcgImFtaWtiZDoga2V5Ym9hcmQgYnVmZmVyIG92ZXJmbG93XG4iLAorCVszXSA9IEtFUk5fV0FSTklORyAiYW1pa2JkOiBrZXlib2FyZCBjb250cm9sbGVyIGZhaWx1cmVcbiIsCisJWzRdID0gS0VSTl9FUlIgImFtaWtiZDoga2V5Ym9hcmQgc2VsZnRlc3QgZmFpbHVyZVxuIiwKKwlbNV0gPSBLRVJOX0lORk8gImFtaWtiZDogaW5pdGlhdGUgcG93ZXItdXAga2V5IHN0cmVhbVxuIiwKKwlbNl0gPSBLRVJOX0lORk8gImFtaWtiZDogdGVybWluYXRlIHBvd2VyLXVwIGtleSBzdHJlYW1cbiIsCisJWzddID0gS0VSTl9XQVJOSU5HICJhbWlrYmQ6IGtleWJvYXJkIGludGVycnVwdFxuIgorfTsKKworc3RhdGljIHN0cnVjdCBpbnB1dF9kZXYgYW1pa2JkX2RldjsKKworc3RhdGljIGNoYXIgKmFtaWtiZF9uYW1lID0gIkFtaWdhIGtleWJvYXJkIjsKK3N0YXRpYyBjaGFyICphbWlrYmRfcGh5cyA9ICJhbWlrYmQvaW5wdXQwIjsKKworc3RhdGljIGlycXJldHVybl90IGFtaWtiZF9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZHVtbXksIHN0cnVjdCBwdF9yZWdzICpmcCkKK3sKKwl1bnNpZ25lZCBjaGFyIHNjYW5jb2RlLCBkb3duOworCisJc2NhbmNvZGUgPSB+Y2lhYS5zZHI7CQkvKiBnZXQgYW5kIGludmVydCBzY2FuY29kZSAoa2V5Ym9hcmQgaXMgYWN0aXZlIGxvdykgKi8KKwljaWFhLmNyYSB8PSAweDQwOwkJLyogc3dpdGNoIFNQIHBpbiB0byBvdXRwdXQgZm9yIGhhbmRzaGFrZSAqLworCXVkZWxheSg4NSk7CQkJLyogd2FpdCB1bnRpbCA4NSB1cyBoYXZlIGV4cGlyZWQgKi8KKwljaWFhLmNyYSAmPSB+MHg0MDsJCS8qIHN3aXRjaCBDSUEgc2VyaWFsIHBvcnQgdG8gaW5wdXQgbW9kZSAqLworCisJZG93biA9ICEoc2NhbmNvZGUgJiAxKTsJCS8qIGxvd2VzdCBiaXQgaXMgcmVsZWFzZSBiaXQgKi8KKwlzY2FuY29kZSA+Pj0gMTsKKworCWlmIChzY2FuY29kZSA8IDB4NzgpIHsJCS8qIHNjYW5jb2RlcyA8IDB4NzggYXJlIGtleXMgKi8KKworCQlzY2FuY29kZSA9IGFtaWtiZF9rZXljb2RlW3NjYW5jb2RlXTsKKworCQlpbnB1dF9yZWdzKCZhbWlrYmRfZGV2LCBmcCk7CisKKwkJaWYgKHNjYW5jb2RlID09IEtFWV9DQVBTTE9DSykgewkvKiBDYXBzTG9jayBpcyBhIHRvZ2dsZSBzd2l0Y2gga2V5IG9uIEFtaWdhICovCisJCQlpbnB1dF9yZXBvcnRfa2V5KCZhbWlrYmRfZGV2LCBzY2FuY29kZSwgMSk7CisJCQlpbnB1dF9yZXBvcnRfa2V5KCZhbWlrYmRfZGV2LCBzY2FuY29kZSwgMCk7CisJCQlpbnB1dF9zeW5jKCZhbWlrYmRfZGV2KTsKKwkJfSBlbHNlIHsKKwkJCWlucHV0X3JlcG9ydF9rZXkoJmFtaWtiZF9kZXYsIHNjYW5jb2RlLCBkb3duKTsKKwkJCWlucHV0X3N5bmMoJmFtaWtiZF9kZXYpOworCQl9CisJfSBlbHNlCQkJCS8qIHNjYW5jb2RlcyA+PSAweDc4IGFyZSBlcnJvciBjb2RlcyAqLworCQlwcmludGsoYW1pa2JkX21lc3NhZ2VzW3NjYW5jb2RlIC0gMHg3OF0pOworCisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitzdGF0aWMgaW50IF9faW5pdCBhbWlrYmRfaW5pdCh2b2lkKQoreworCWludCBpOworCisJaWYgKCFBTUlHQUhXX1BSRVNFTlQoQU1JX0tFWUJPQVJEKSkKKwkJcmV0dXJuIC1FSU87CisKKwlpZiAoIXJlcXVlc3RfbWVtX3JlZ2lvbihDSUFBX1BIWVNBRERSLTErMHhiMDAsIDB4MTAwLCAiYW1pa2V5YiIpKQorCQlyZXR1cm4gLUVCVVNZOworCisJaW5pdF9pbnB1dF9kZXYoJmFtaWtiZF9kZXYpOworCisJYW1pa2JkX2Rldi5ldmJpdFswXSA9IEJJVChFVl9LRVkpIHwgQklUKEVWX1JFUCk7CisJYW1pa2JkX2Rldi5rZXljb2RlID0gYW1pa2JkX2tleWNvZGU7CisJYW1pa2JkX2Rldi5rZXljb2Rlc2l6ZSA9IHNpemVvZih1bnNpZ25lZCBjaGFyKTsKKwlhbWlrYmRfZGV2LmtleWNvZGVtYXggPSBBUlJBWV9TSVpFKGFtaWtiZF9rZXljb2RlKTsKKworCWZvciAoaSA9IDA7IGkgPCAweDc4OyBpKyspCisJCWlmIChhbWlrYmRfa2V5Y29kZVtpXSkKKwkJCXNldF9iaXQoYW1pa2JkX2tleWNvZGVbaV0sIGFtaWtiZF9kZXYua2V5Yml0KTsKKworCWNpYWEuY3JhICY9IH4weDQxOwkgLyogc2VyaWFsIGRhdGEgaW4sIHR1cm4gb2ZmIFRBICovCisJcmVxdWVzdF9pcnEoSVJRX0FNSUdBX0NJQUFfU1AsIGFtaWtiZF9pbnRlcnJ1cHQsIDAsICJhbWlrYmQiLCBhbWlrYmRfaW50ZXJydXB0KTsKKworCWFtaWtiZF9kZXYubmFtZSA9IGFtaWtiZF9uYW1lOworCWFtaWtiZF9kZXYucGh5cyA9IGFtaWtiZF9waHlzOworCWFtaWtiZF9kZXYuaWQuYnVzdHlwZSA9IEJVU19BTUlHQTsKKwlhbWlrYmRfZGV2LmlkLnZlbmRvciA9IDB4MDAwMTsKKwlhbWlrYmRfZGV2LmlkLnByb2R1Y3QgPSAweDAwMDE7CisJYW1pa2JkX2Rldi5pZC52ZXJzaW9uID0gMHgwMTAwOworCisJaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKCZhbWlrYmRfZGV2KTsKKworCXByaW50ayhLRVJOX0lORk8gImlucHV0OiAlc1xuIiwgYW1pa2JkX25hbWUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBhbWlrYmRfZXhpdCh2b2lkKQoreworCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKCZhbWlrYmRfZGV2KTsKKwlmcmVlX2lycShJUlFfQU1JR0FfQ0lBQV9TUCwgYW1pa2JkX2ludGVycnVwdCk7CisJcmVsZWFzZV9tZW1fcmVnaW9uKENJQUFfUEhZU0FERFItMSsweGIwMCwgMHgxMDApOworfQorCittb2R1bGVfaW5pdChhbWlrYmRfaW5pdCk7Cittb2R1bGVfZXhpdChhbWlrYmRfZXhpdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2F0a2JkLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2F0a2JkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjczMDRmMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvYXRrYmQuYwpAQCAtMCwwICsxLDExNDggQEAKKy8qCisgKiBBVCBhbmQgUFMvMiBrZXlib2FyZCBkcml2ZXIKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDE5OTktMjAwMiBWb2p0ZWNoIFBhdmxpaworICovCisKKy8qCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKy8qCisgKiBUaGlzIGRyaXZlciBjYW4gaGFuZGxlIHN0YW5kYXJkIEFUIGtleWJvYXJkcyBhbmQgUFMvMiBrZXlib2FyZHMgaW4KKyAqIFRyYW5zbGF0ZWQgYW5kIFJhdyBTZXQgMiBhbmQgU2V0IDMsIGFzIHdlbGwgYXMgQVQga2V5Ym9hcmRzIG9uIGR1bWIKKyAqIGlucHV0LW9ubHkgY29udHJvbGxlcnMgYW5kIEFUIGtleWJvYXJkcyBjb25uZWN0ZWQgb3ZlciBhIG9uZSB3YXkgUlMyMzIKKyAqIGNvbnZlcnRlci4KKyAqLworCisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zZXJpby5oPgorI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgorI2luY2x1ZGUgPGxpbnV4L2xpYnBzMi5oPgorCisjZGVmaW5lIERSSVZFUl9ERVNDCSJBVCBhbmQgUFMvMiBrZXlib2FyZCBkcml2ZXIiCisKK01PRFVMRV9BVVRIT1IoIlZvanRlY2ggUGF2bGlrIDx2b2p0ZWNoQHN1c2UuY3o+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04oRFJJVkVSX0RFU0MpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworCitzdGF0aWMgaW50IGF0a2JkX3NldCA9IDI7Cittb2R1bGVfcGFyYW1fbmFtZWQoc2V0LCBhdGtiZF9zZXQsIGludCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKHNldCwgIlNlbGVjdCBrZXlib2FyZCBjb2RlIHNldCAoMiA9IGRlZmF1bHQsIDMgPSBQUy8yIG5hdGl2ZSkiKTsKKworI2lmIGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX194ODZfNjRfXykgfHwgZGVmaW5lZChfX2hwcGFfXykKK3N0YXRpYyBpbnQgYXRrYmRfcmVzZXQ7CisjZWxzZQorc3RhdGljIGludCBhdGtiZF9yZXNldCA9IDE7CisjZW5kaWYKK21vZHVsZV9wYXJhbV9uYW1lZChyZXNldCwgYXRrYmRfcmVzZXQsIGJvb2wsIDApOworTU9EVUxFX1BBUk1fREVTQyhyZXNldCwgIlJlc2V0IGtleWJvYXJkIGR1cmluZyBpbml0aWFsaXphdGlvbiIpOworCitzdGF0aWMgaW50IGF0a2JkX3NvZnRyZXBlYXQ7Cittb2R1bGVfcGFyYW1fbmFtZWQoc29mdHJlcGVhdCwgYXRrYmRfc29mdHJlcGVhdCwgYm9vbCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKHNvZnRyZXBlYXQsICJVc2Ugc29mdHdhcmUga2V5Ym9hcmQgcmVwZWF0Iik7CisKK3N0YXRpYyBpbnQgYXRrYmRfc29mdHJhdyA9IDE7Cittb2R1bGVfcGFyYW1fbmFtZWQoc29mdHJhdywgYXRrYmRfc29mdHJhdywgYm9vbCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKHNvZnRyYXcsICJVc2Ugc29mdHdhcmUgZ2VuZXJhdGVkIHJhd21vZGUiKTsKKworc3RhdGljIGludCBhdGtiZF9zY3JvbGwgPSAxOworbW9kdWxlX3BhcmFtX25hbWVkKHNjcm9sbCwgYXRrYmRfc2Nyb2xsLCBib29sLCAwKTsKK01PRFVMRV9QQVJNX0RFU0Moc2Nyb2xsLCAiRW5hYmxlIHNjcm9sbC13aGVlbCBvbiBNUyBPZmZpY2UgYW5kIHNpbWlsYXIga2V5Ym9hcmRzIik7CisKK3N0YXRpYyBpbnQgYXRrYmRfZXh0cmE7Cittb2R1bGVfcGFyYW1fbmFtZWQoZXh0cmEsIGF0a2JkX2V4dHJhLCBib29sLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MoZXh0cmEsICJFbmFibGUgZXh0cmEgTEVEcyBhbmQga2V5cyBvbiBJQk0gUmFwaWRBY2NlcywgRXpLZXkgYW5kIHNpbWlsYXIga2V5Ym9hcmRzIik7CisKK19fb2Jzb2xldGVfc2V0dXAoImF0a2JkX3NldD0iKTsKK19fb2Jzb2xldGVfc2V0dXAoImF0a2JkX3Jlc2V0Iik7CitfX29ic29sZXRlX3NldHVwKCJhdGtiZF9zb2Z0cmVwZWF0PSIpOworCisvKgorICogU2NhbmNvZGUgdG8ga2V5Y29kZSB0YWJsZXMuIFRoZXNlIGFyZSBqdXN0IHRoZSBkZWZhdWx0IHNldHRpbmcsIGFuZAorICogYXJlIGxvYWRhYmxlIHZpYSBhbiB1c2VybGFuZCB1dGlsaXR5LgorICovCisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGF0a2JkX3NldDJfa2V5Y29kZVs1MTJdID0geworCisjaWZkZWYgQ09ORklHX0tFWUJPQVJEX0FUS0JEX0hQX0tFWUNPREVTCisKKy8qIFhYWDogbmVlZCBhIG1vcmUgZ2VuZXJhbCBhcHByb2FjaCAqLworCisjaW5jbHVkZSAiaHBwczJhdGtiZC5oIgkvKiBpbmNsdWRlIHRoZSBrZXlib2FyZCBzY2FuY29kZXMgKi8KKworI2Vsc2UKKwkgIDAsIDY3LCA2NSwgNjMsIDYxLCA1OSwgNjAsIDg4LCAgMCwgNjgsIDY2LCA2NCwgNjIsIDE1LCA0MSwxMTcsCisJICAwLCA1NiwgNDIsIDkzLCAyOSwgMTYsICAyLCAgMCwgIDAsICAwLCA0NCwgMzEsIDMwLCAxNywgIDMsICAwLAorCSAgMCwgNDYsIDQ1LCAzMiwgMTgsICA1LCAgNCwgOTUsICAwLCA1NywgNDcsIDMzLCAyMCwgMTksICA2LDE4MywKKwkgIDAsIDQ5LCA0OCwgMzUsIDM0LCAyMSwgIDcsMTg0LCAgMCwgIDAsIDUwLCAzNiwgMjIsICA4LCAgOSwxODUsCisJICAwLCA1MSwgMzcsIDIzLCAyNCwgMTEsIDEwLCAgMCwgIDAsIDUyLCA1MywgMzgsIDM5LCAyNSwgMTIsICAwLAorCSAgMCwgODksIDQwLCAgMCwgMjYsIDEzLCAgMCwgIDAsIDU4LCA1NCwgMjgsIDI3LCAgMCwgNDMsICAwLCA4NSwKKwkgIDAsIDg2LCA5MSwgOTAsIDkyLCAgMCwgMTQsIDk0LCAgMCwgNzksMTI0LCA3NSwgNzEsMTIxLCAgMCwgIDAsCisJIDgyLCA4MywgODAsIDc2LCA3NywgNzIsICAxLCA2OSwgODcsIDc4LCA4MSwgNzQsIDU1LCA3MywgNzAsIDk5LAorCisJICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLAorCTIxNywxMDAsMjU1LCAgMCwgOTcsMTY1LCAgMCwgIDAsMTU2LCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLDEyNSwKKwkxNzMsMTE0LCAgMCwxMTMsICAwLCAgMCwgIDAsMTI2LDEyOCwgIDAsICAwLDE0MCwgIDAsICAwLCAgMCwxMjcsCisJMTU5LCAgMCwxMTUsICAwLDE2NCwgIDAsICAwLDExNiwxNTgsICAwLDE1MCwxNjYsICAwLCAgMCwgIDAsMTQyLAorCTE1NywgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsMTU1LCAgMCwgOTgsICAwLCAgMCwxNjMsICAwLCAgMCwKKwkyMjYsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwyNTUsIDk2LCAgMCwgIDAsICAwLDE0MywgIDAsCisJICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsMTA3LCAgMCwxMDUsMTAyLCAgMCwgIDAsMTEyLAorCTExMCwxMTEsMTA4LDExMiwxMDYsMTAzLCAgMCwxMTksICAwLDExOCwxMDksICAwLCA5OSwxMDQsMTE5LCAgMCwKKworCSAgMCwgIDAsICAwLCA2NSwgOTksCisjZW5kaWYKK307CisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGF0a2JkX3NldDNfa2V5Y29kZVs1MTJdID0geworCisJICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCA1OSwgIDEsMTM4LDEyOCwxMjksMTMwLCAxNSwgNDEsIDYwLAorCTEzMSwgMjksIDQyLCA4NiwgNTgsIDE2LCAgMiwgNjEsMTMzLCA1NiwgNDQsIDMxLCAzMCwgMTcsICAzLCA2MiwKKwkxMzQsIDQ2LCA0NSwgMzIsIDE4LCAgNSwgIDQsIDYzLDEzNSwgNTcsIDQ3LCAzMywgMjAsIDE5LCAgNiwgNjQsCisJMTM2LCA0OSwgNDgsIDM1LCAzNCwgMjEsICA3LCA2NSwxMzcsMTAwLCA1MCwgMzYsIDIyLCAgOCwgIDksIDY2LAorCTEyNSwgNTEsIDM3LCAyMywgMjQsIDExLCAxMCwgNjcsMTI2LCA1MiwgNTMsIDM4LCAzOSwgMjUsIDEyLCA2OCwKKwkxMTMsMTE0LCA0MCwgNDMsIDI2LCAxMywgODcsIDk5LCA5NywgNTQsIDI4LCAyNywgNDMsIDQzLCA4OCwgNzAsCisJMTA4LDEwNSwxMTksMTAzLDExMSwxMDcsIDE0LDExMCwgIDAsIDc5LDEwNiwgNzUsIDcxLDEwOSwxMDIsMTA0LAorCSA4MiwgODMsIDgwLCA3NiwgNzcsIDcyLCA2OSwgOTgsICAwLCA5NiwgODEsICAwLCA3OCwgNzMsIDU1LDE4MywKKworCTE4NCwxODUsMTg2LDE4NywgNzQsIDk0LCA5MiwgOTMsICAwLCAgMCwgIDAsMTI1LDEyNiwxMjcsMTEyLCAgMCwKKwkgIDAsMTM5LDE1MCwxNjMsMTY1LDExNSwxNTIsMTUwLDE2NiwxNDAsMTYwLDE1NCwxMTMsMTE0LDE2NywxNjgsCisJMTQ4LDE0OSwxNDcsMTQwCit9OworCitzdGF0aWMgdW5zaWduZWQgY2hhciBhdGtiZF91bnhsYXRlX3RhYmxlWzEyOF0gPSB7CisgICAgICAgICAgMCwxMTgsIDIyLCAzMCwgMzgsIDM3LCA0NiwgNTQsIDYxLCA2MiwgNzAsIDY5LCA3OCwgODUsMTAyLCAxMywKKyAgICAgICAgIDIxLCAyOSwgMzYsIDQ1LCA0NCwgNTMsIDYwLCA2NywgNjgsIDc3LCA4NCwgOTEsIDkwLCAyMCwgMjgsIDI3LAorICAgICAgICAgMzUsIDQzLCA1MiwgNTEsIDU5LCA2NiwgNzUsIDc2LCA4MiwgMTQsIDE4LCA5MywgMjYsIDM0LCAzMywgNDIsCisgICAgICAgICA1MCwgNDksIDU4LCA2NSwgNzMsIDc0LCA4OSwxMjQsIDE3LCA0MSwgODgsICA1LCAgNiwgIDQsIDEyLCAgMywKKyAgICAgICAgIDExLCAgMiwgMTAsICAxLCAgOSwxMTksMTI2LDEwOCwxMTcsMTI1LDEyMywxMDcsMTE1LDExNiwxMjEsMTA1LAorICAgICAgICAxMTQsMTIyLDExMiwxMTMsMTI3LCA5NiwgOTcsMTIwLCAgNywgMTUsIDIzLCAzMSwgMzksIDQ3LCA1NSwgNjMsCisgICAgICAgICA3MSwgNzksIDg2LCA5NCwgIDgsIDE2LCAyNCwgMzIsIDQwLCA0OCwgNTYsIDY0LCA3MiwgODAsIDg3LDExMSwKKyAgICAgICAgIDE5LCAyNSwgNTcsIDgxLCA4MywgOTIsIDk1LCA5OCwgOTksMTAwLDEwMSwxMDMsMTA0LDEwNiwxMDksMTEwCit9OworCisjZGVmaW5lIEFUS0JEX0NNRF9TRVRMRURTCTB4MTBlZAorI2RlZmluZSBBVEtCRF9DTURfR1NDQU5TRVQJMHgxMWYwCisjZGVmaW5lIEFUS0JEX0NNRF9TU0NBTlNFVAkweDEwZjAKKyNkZWZpbmUgQVRLQkRfQ01EX0dFVElECQkweDAyZjIKKyNkZWZpbmUgQVRLQkRfQ01EX1NFVFJFUAkweDEwZjMKKyNkZWZpbmUgQVRLQkRfQ01EX0VOQUJMRQkweDAwZjQKKyNkZWZpbmUgQVRLQkRfQ01EX1JFU0VUX0RJUwkweDAwZjUKKyNkZWZpbmUgQVRLQkRfQ01EX1NFVEFMTF9NQlIJMHgwMGZhCisjZGVmaW5lIEFUS0JEX0NNRF9SRVNFVF9CQVQJMHgwMmZmCisjZGVmaW5lIEFUS0JEX0NNRF9SRVNFTkQJMHgwMGZlCisjZGVmaW5lIEFUS0JEX0NNRF9FWF9FTkFCTEUJMHgxMGVhCisjZGVmaW5lIEFUS0JEX0NNRF9FWF9TRVRMRURTCTB4MjBlYgorI2RlZmluZSBBVEtCRF9DTURfT0tfR0VUSUQJMHgwMmU4CisKKyNkZWZpbmUgQVRLQkRfUkVUX0FDSwkJMHhmYQorI2RlZmluZSBBVEtCRF9SRVRfTkFLCQkweGZlCisjZGVmaW5lIEFUS0JEX1JFVF9CQVQJCTB4YWEKKyNkZWZpbmUgQVRLQkRfUkVUX0VNVUwwCQkweGUwCisjZGVmaW5lIEFUS0JEX1JFVF9FTVVMMQkJMHhlMQorI2RlZmluZSBBVEtCRF9SRVRfUkVMRUFTRQkweGYwCisjZGVmaW5lIEFUS0JEX1JFVF9IQU5HVUVMCTB4ZjEKKyNkZWZpbmUgQVRLQkRfUkVUX0hBTkpBCQkweGYyCisjZGVmaW5lIEFUS0JEX1JFVF9FUlIJCTB4ZmYKKworI2RlZmluZSBBVEtCRF9LRVlfVU5LTk9XTgkgIDAKKyNkZWZpbmUgQVRLQkRfS0VZX05VTEwJCTI1NQorCisjZGVmaW5lIEFUS0JEX1NDUl8xCQkyNTQKKyNkZWZpbmUgQVRLQkRfU0NSXzIJCTI1MworI2RlZmluZSBBVEtCRF9TQ1JfNAkJMjUyCisjZGVmaW5lIEFUS0JEX1NDUl84CQkyNTEKKyNkZWZpbmUgQVRLQkRfU0NSX0NMSUNLCQkyNTAKKyNkZWZpbmUgQVRLQkRfU0NSX0xFRlQJCTI0OQorI2RlZmluZSBBVEtCRF9TQ1JfUklHSFQJCTI0OAorCisjZGVmaW5lIEFUS0JEX1NQRUNJQUwJCTI0OAorCitzdGF0aWMgc3RydWN0IHsKKwl1bnNpZ25lZCBjaGFyIGtleWNvZGU7CisJdW5zaWduZWQgY2hhciBzZXQyOworfSBhdGtiZF9zY3JvbGxfa2V5c1tdID0geworCXsgQVRLQkRfU0NSXzEsICAgICAweGM1IH0sCisJeyBBVEtCRF9TQ1JfMiwgICAgIDB4YTkgfSwKKwl7IEFUS0JEX1NDUl80LCAgICAgMHhiNiB9LAorCXsgQVRLQkRfU0NSXzgsICAgICAweGE3IH0sCisJeyBBVEtCRF9TQ1JfQ0xJQ0ssIDB4ZTAgfSwKKwl7IEFUS0JEX1NDUl9MRUZULCAgMHhjYiB9LAorCXsgQVRLQkRfU0NSX1JJR0hULCAweGQyIH0sCit9OworCisvKgorICogVGhlIGF0a2JkIGNvbnRyb2wgc3RydWN0dXJlCisgKi8KKworc3RydWN0IGF0a2JkIHsKKworCXN0cnVjdCBwczJkZXYJcHMyZGV2OworCisJLyogV3JpdHRlbiBvbmx5IGR1cmluZyBpbml0ICovCisJY2hhciBuYW1lWzY0XTsKKwljaGFyIHBoeXNbMzJdOworCXN0cnVjdCBpbnB1dF9kZXYgZGV2OworCisJdW5zaWduZWQgc2hvcnQgaWQ7CisJdW5zaWduZWQgY2hhciBrZXljb2RlWzUxMl07CisJdW5zaWduZWQgY2hhciBzZXQ7CisJdW5zaWduZWQgY2hhciB0cmFuc2xhdGVkOworCXVuc2lnbmVkIGNoYXIgZXh0cmE7CisJdW5zaWduZWQgY2hhciB3cml0ZTsKKwl1bnNpZ25lZCBjaGFyIHNvZnRyZXBlYXQ7CisJdW5zaWduZWQgY2hhciBzb2Z0cmF3OworCXVuc2lnbmVkIGNoYXIgc2Nyb2xsOworCXVuc2lnbmVkIGNoYXIgZW5hYmxlZDsKKworCS8qIEFjY2Vzc2VkIG9ubHkgZnJvbSBpbnRlcnJ1cHQgKi8KKwl1bnNpZ25lZCBjaGFyIGVtdWw7CisJdW5zaWduZWQgY2hhciByZXNlbmQ7CisJdW5zaWduZWQgY2hhciByZWxlYXNlOworCXVuc2lnbmVkIGNoYXIgYmF0X3hsOworCXVuc2lnbmVkIGludCBsYXN0OworCXVuc2lnbmVkIGxvbmcgdGltZTsKK307CisKK3N0YXRpYyBzc2l6ZV90IGF0a2JkX2F0dHJfc2hvd19oZWxwZXIoc3RydWN0IGRldmljZSAqZGV2LCBjaGFyICpidWYsCisJCQkJc3NpemVfdCAoKmhhbmRsZXIpKHN0cnVjdCBhdGtiZCAqLCBjaGFyICopKTsKK3N0YXRpYyBzc2l6ZV90IGF0a2JkX2F0dHJfc2V0X2hlbHBlcihzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50LAorCQkJCXNzaXplX3QgKCpoYW5kbGVyKShzdHJ1Y3QgYXRrYmQgKiwgY29uc3QgY2hhciAqLCBzaXplX3QpKTsKKyNkZWZpbmUgQVRLQkRfREVGSU5FX0FUVFIoX25hbWUpCQkJCQkJXAorc3RhdGljIHNzaXplX3QgYXRrYmRfc2hvd18jI19uYW1lKHN0cnVjdCBhdGtiZCAqLCBjaGFyICopOwkJCVwKK3N0YXRpYyBzc2l6ZV90IGF0a2JkX3NldF8jI19uYW1lKHN0cnVjdCBhdGtiZCAqLCBjb25zdCBjaGFyICosIHNpemVfdCk7CQlcCitzdGF0aWMgc3NpemVfdCBhdGtiZF9kb19zaG93XyMjX25hbWUoc3RydWN0IGRldmljZSAqZCwgY2hhciAqYikJCQlcCit7CQkJCQkJCQkJCVwKKwlyZXR1cm4gYXRrYmRfYXR0cl9zaG93X2hlbHBlcihkLCBiLCBhdGtiZF9zaG93XyMjX25hbWUpOwkJXAorfQkJCQkJCQkJCQlcCitzdGF0aWMgc3NpemVfdCBhdGtiZF9kb19zZXRfIyNfbmFtZShzdHJ1Y3QgZGV2aWNlICpkLCBjb25zdCBjaGFyICpiLCBzaXplX3QgcykJXAorewkJCQkJCQkJCQlcCisJcmV0dXJuIGF0a2JkX2F0dHJfc2V0X2hlbHBlcihkLCBiLCBzLCBhdGtiZF9zZXRfIyNfbmFtZSk7CQlcCit9CQkJCQkJCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSBhdGtiZF9hdHRyXyMjX25hbWUgPSAJCQkJXAorCV9fQVRUUihfbmFtZSwgU19JV1VTUiB8IFNfSVJVR08sIGF0a2JkX2RvX3Nob3dfIyNfbmFtZSwgYXRrYmRfZG9fc2V0XyMjX25hbWUpOworCitBVEtCRF9ERUZJTkVfQVRUUihleHRyYSk7CitBVEtCRF9ERUZJTkVfQVRUUihzY3JvbGwpOworQVRLQkRfREVGSU5FX0FUVFIoc2V0KTsKK0FUS0JEX0RFRklORV9BVFRSKHNvZnRyZXBlYXQpOworQVRLQkRfREVGSU5FX0FUVFIoc29mdHJhdyk7CisKKworc3RhdGljIHZvaWQgYXRrYmRfcmVwb3J0X2tleShzdHJ1Y3QgaW5wdXRfZGV2ICpkZXYsIHN0cnVjdCBwdF9yZWdzICpyZWdzLCBpbnQgY29kZSwgaW50IHZhbHVlKQoreworCWlucHV0X3JlZ3MoZGV2LCByZWdzKTsKKwlpZiAodmFsdWUgPT0gMykgeworCQlpbnB1dF9yZXBvcnRfa2V5KGRldiwgY29kZSwgMSk7CisJCWlucHV0X3N5bmMoZGV2KTsKKwkJaW5wdXRfcmVwb3J0X2tleShkZXYsIGNvZGUsIDApOworCX0gZWxzZQorCQlpbnB1dF9ldmVudChkZXYsIEVWX0tFWSwgY29kZSwgdmFsdWUpOworCWlucHV0X3N5bmMoZGV2KTsKK30KKworLyoKKyAqIGF0a2JkX2ludGVycnVwdCgpLiBIZXJlIHRha2VzIHBsYWNlIHByb2Nlc3Npbmcgb2YgZGF0YSByZWNlaXZlZCBmcm9tCisgKiB0aGUga2V5Ym9hcmQgaW50byBldmVudHMuCisgKi8KKworc3RhdGljIGlycXJldHVybl90IGF0a2JkX2ludGVycnVwdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvLCB1bnNpZ25lZCBjaGFyIGRhdGEsCisJCQl1bnNpZ25lZCBpbnQgZmxhZ3MsIHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXN0cnVjdCBhdGtiZCAqYXRrYmQgPSBzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyk7CisJdW5zaWduZWQgaW50IGNvZGUgPSBkYXRhOworCWludCBzY3JvbGwgPSAwLCBoc2Nyb2xsID0gMCwgY2xpY2sgPSAtMTsKKwlpbnQgdmFsdWU7CisKKyNpZmRlZiBBVEtCRF9ERUJVRworCXByaW50ayhLRVJOX0RFQlVHICJhdGtiZC5jOiBSZWNlaXZlZCAlMDJ4IGZsYWdzICUwMnhcbiIsIGRhdGEsIGZsYWdzKTsKKyNlbmRpZgorCisjaWYgIWRlZmluZWQoX19pMzg2X18pICYmICFkZWZpbmVkIChfX3g4Nl82NF9fKQorCWlmICgoZmxhZ3MgJiAoU0VSSU9fRlJBTUUgfCBTRVJJT19QQVJJVFkpKSAmJiAofmZsYWdzICYgU0VSSU9fVElNRU9VVCkgJiYgIWF0a2JkLT5yZXNlbmQgJiYgYXRrYmQtPndyaXRlKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgImF0a2JkLmM6IGZyYW1lL3Bhcml0eSBlcnJvcjogJTAyeFxuIiwgZmxhZ3MpOworCQlzZXJpb193cml0ZShzZXJpbywgQVRLQkRfQ01EX1JFU0VORCk7CisJCWF0a2JkLT5yZXNlbmQgPSAxOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAoIWZsYWdzICYmIGRhdGEgPT0gQVRLQkRfUkVUX0FDSykKKwkJYXRrYmQtPnJlc2VuZCA9IDA7CisjZW5kaWYKKworCWlmICh1bmxpa2VseShhdGtiZC0+cHMyZGV2LmZsYWdzICYgUFMyX0ZMQUdfQUNLKSkKKwkJaWYgIChwczJfaGFuZGxlX2FjaygmYXRrYmQtPnBzMmRldiwgZGF0YSkpCisJCQlnb3RvIG91dDsKKworCWlmICh1bmxpa2VseShhdGtiZC0+cHMyZGV2LmZsYWdzICYgUFMyX0ZMQUdfQ01EKSkKKwkJaWYgIChwczJfaGFuZGxlX3Jlc3BvbnNlKCZhdGtiZC0+cHMyZGV2LCBkYXRhKSkKKwkJCWdvdG8gb3V0OworCisJaWYgKCFhdGtiZC0+ZW5hYmxlZCkKKwkJZ290byBvdXQ7CisKKwlpbnB1dF9ldmVudCgmYXRrYmQtPmRldiwgRVZfTVNDLCBNU0NfUkFXLCBjb2RlKTsKKworCWlmIChhdGtiZC0+dHJhbnNsYXRlZCkgeworCisJCWlmIChhdGtiZC0+ZW11bCB8fAorCQkgICAgIShjb2RlID09IEFUS0JEX1JFVF9FTVVMMCB8fCBjb2RlID09IEFUS0JEX1JFVF9FTVVMMSB8fAorCQkgICAgICBjb2RlID09IEFUS0JEX1JFVF9IQU5HVUVMIHx8IGNvZGUgPT0gQVRLQkRfUkVUX0hBTkpBIHx8CisJCSAgICAgIGNvZGUgPT0gQVRLQkRfUkVUX0VSUiB8fAorCSAgICAgICAgICAgICAoY29kZSA9PSBBVEtCRF9SRVRfQkFUICYmICFhdGtiZC0+YmF0X3hsKSkpIHsKKwkJCWF0a2JkLT5yZWxlYXNlID0gY29kZSA+PiA3OworCQkJY29kZSAmPSAweDdmOworCQl9CisKKwkJaWYgKCFhdGtiZC0+ZW11bCAmJgorCQkgICAgIChjb2RlICYgMHg3ZikgPT0gKEFUS0JEX1JFVF9CQVQgJiAweDdmKSkKKwkJCWF0a2JkLT5iYXRfeGwgPSAhYXRrYmQtPnJlbGVhc2U7CisJfQorCisJc3dpdGNoIChjb2RlKSB7CisJCWNhc2UgQVRLQkRfUkVUX0JBVDoKKwkJCWF0a2JkLT5lbmFibGVkID0gMDsKKwkJCXNlcmlvX3Jlc2NhbihhdGtiZC0+cHMyZGV2LnNlcmlvKTsKKwkJCWdvdG8gb3V0OworCQljYXNlIEFUS0JEX1JFVF9FTVVMMDoKKwkJCWF0a2JkLT5lbXVsID0gMTsKKwkJCWdvdG8gb3V0OworCQljYXNlIEFUS0JEX1JFVF9FTVVMMToKKwkJCWF0a2JkLT5lbXVsID0gMjsKKwkJCWdvdG8gb3V0OworCQljYXNlIEFUS0JEX1JFVF9SRUxFQVNFOgorCQkJYXRrYmQtPnJlbGVhc2UgPSAxOworCQkJZ290byBvdXQ7CisJCWNhc2UgQVRLQkRfUkVUX0hBTkdVRUw6CisJCQlhdGtiZF9yZXBvcnRfa2V5KCZhdGtiZC0+ZGV2LCByZWdzLCBLRVlfSEFOR1VFTCwgMyk7CisJCQlnb3RvIG91dDsKKwkJY2FzZSBBVEtCRF9SRVRfSEFOSkE6CisJCQlhdGtiZF9yZXBvcnRfa2V5KCZhdGtiZC0+ZGV2LCByZWdzLCBLRVlfSEFOSkEsIDMpOworCQkJZ290byBvdXQ7CisJCWNhc2UgQVRLQkRfUkVUX0VSUjoKKwkJCXByaW50ayhLRVJOX0RFQlVHICJhdGtiZC5jOiBLZXlib2FyZCBvbiAlcyByZXBvcnRzIHRvbyBtYW55IGtleXMgcHJlc3NlZC5cbiIsIHNlcmlvLT5waHlzKTsKKwkJCWdvdG8gb3V0OworCX0KKworCWlmIChhdGtiZC0+c2V0ICE9IDMpCisJCWNvZGUgPSAoY29kZSAmIDB4N2YpIHwgKChjb2RlICYgMHg4MCkgPDwgMSk7CisJaWYgKGF0a2JkLT5lbXVsKSB7CisJCWlmICgtLWF0a2JkLT5lbXVsKQorCQkJZ290byBvdXQ7CisJCWNvZGUgfD0gKGF0a2JkLT5zZXQgIT0gMykgPyAweDgwIDogMHgxMDA7CisJfQorCisJaWYgKGF0a2JkLT5rZXljb2RlW2NvZGVdICE9IEFUS0JEX0tFWV9OVUxMKQorCQlpbnB1dF9ldmVudCgmYXRrYmQtPmRldiwgRVZfTVNDLCBNU0NfU0NBTiwgY29kZSk7CisKKwlzd2l0Y2ggKGF0a2JkLT5rZXljb2RlW2NvZGVdKSB7CisJCWNhc2UgQVRLQkRfS0VZX05VTEw6CisJCQlicmVhazsKKwkJY2FzZSBBVEtCRF9LRVlfVU5LTk9XTjoKKwkJCWlmIChkYXRhID09IEFUS0JEX1JFVF9BQ0sgfHwgZGF0YSA9PSBBVEtCRF9SRVRfTkFLKSB7CisJCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiYXRrYmQuYzogU3B1cmlvdXMgJXMgb24gJXMuIFNvbWUgcHJvZ3JhbSwgIgorCQkJCSAgICAgICAibGlrZSBYRnJlZTg2LCBtaWdodCBiZSB0cnlpbmcgYWNjZXNzIGhhcmR3YXJlIGRpcmVjdGx5LlxuIiwKKwkJCQkgICAgICAgZGF0YSA9PSBBVEtCRF9SRVRfQUNLID8gIkFDSyIgOiAiTkFLIiwgc2VyaW8tPnBoeXMpOworCQkJfSBlbHNlIHsKKwkJCQlwcmludGsoS0VSTl9XQVJOSU5HICJhdGtiZC5jOiBVbmtub3duIGtleSAlcyAiCisJCQkJICAgICAgICIoJXMgc2V0ICVkLCBjb2RlICUjeCBvbiAlcykuXG4iLAorCQkJCSAgICAgICBhdGtiZC0+cmVsZWFzZSA/ICJyZWxlYXNlZCIgOiAicHJlc3NlZCIsCisJCQkJICAgICAgIGF0a2JkLT50cmFuc2xhdGVkID8gInRyYW5zbGF0ZWQiIDogInJhdyIsCisJCQkJICAgICAgIGF0a2JkLT5zZXQsIGNvZGUsIHNlcmlvLT5waHlzKTsKKwkJCQlwcmludGsoS0VSTl9XQVJOSU5HICJhdGtiZC5jOiBVc2UgJ3NldGtleWNvZGVzICVzJTAyeCA8a2V5Y29kZT4nICIKKwkJCQkgICAgICAgInRvIG1ha2UgaXQga25vd24uXG4iLAorCQkJCSAgICAgICBjb2RlICYgMHg4MCA/ICJlMCIgOiAiIiwgY29kZSAmIDB4N2YpOworCQkJfQorCQkJaW5wdXRfc3luYygmYXRrYmQtPmRldik7CisJCQlicmVhazsKKwkJY2FzZSBBVEtCRF9TQ1JfMToKKwkJCXNjcm9sbCA9IDEgLSBhdGtiZC0+cmVsZWFzZSAqIDI7CisJCQlicmVhazsKKwkJY2FzZSBBVEtCRF9TQ1JfMjoKKwkJCXNjcm9sbCA9IDIgLSBhdGtiZC0+cmVsZWFzZSAqIDQ7CisJCQlicmVhazsKKwkJY2FzZSBBVEtCRF9TQ1JfNDoKKwkJCXNjcm9sbCA9IDQgLSBhdGtiZC0+cmVsZWFzZSAqIDg7CisJCQlicmVhazsKKwkJY2FzZSBBVEtCRF9TQ1JfODoKKwkJCXNjcm9sbCA9IDggLSBhdGtiZC0+cmVsZWFzZSAqIDE2OworCQkJYnJlYWs7CisJCWNhc2UgQVRLQkRfU0NSX0NMSUNLOgorCQkJY2xpY2sgPSAhYXRrYmQtPnJlbGVhc2U7CisJCQlicmVhazsKKwkJY2FzZSBBVEtCRF9TQ1JfTEVGVDoKKwkJCWhzY3JvbGwgPSAtMTsKKwkJCWJyZWFrOworCQljYXNlIEFUS0JEX1NDUl9SSUdIVDoKKwkJCWhzY3JvbGwgPSAxOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQl2YWx1ZSA9IGF0a2JkLT5yZWxlYXNlID8gMCA6CisJCQkJKDEgKyAoIWF0a2JkLT5zb2Z0cmVwZWF0ICYmIHRlc3RfYml0KGF0a2JkLT5rZXljb2RlW2NvZGVdLCBhdGtiZC0+ZGV2LmtleSkpKTsKKworCQkJc3dpdGNoICh2YWx1ZSkgeyAJLyogV29ya2Fyb3VuZCBUb3NoaWJhIGxhcHRvcCBtdWx0aXBsZSBrZXlwcmVzcyAqLworCQkJCWNhc2UgMDoKKwkJCQkJYXRrYmQtPmxhc3QgPSAwOworCQkJCQlicmVhazsKKwkJCQljYXNlIDE6CisJCQkJCWF0a2JkLT5sYXN0ID0gY29kZTsKKwkJCQkJYXRrYmQtPnRpbWUgPSBqaWZmaWVzICsgbXNlY3NfdG9famlmZmllcyhhdGtiZC0+ZGV2LnJlcFtSRVBfREVMQVldKSAvIDI7CisJCQkJCWJyZWFrOworCQkJCWNhc2UgMjoKKwkJCQkJaWYgKCF0aW1lX2FmdGVyKGppZmZpZXMsIGF0a2JkLT50aW1lKSAmJiBhdGtiZC0+bGFzdCA9PSBjb2RlKQorCQkJCQkJdmFsdWUgPSAxOworCQkJCQlicmVhazsKKwkJCX0KKworCQkJYXRrYmRfcmVwb3J0X2tleSgmYXRrYmQtPmRldiwgcmVncywgYXRrYmQtPmtleWNvZGVbY29kZV0sIHZhbHVlKTsKKwl9CisKKwlpZiAoYXRrYmQtPnNjcm9sbCkgeworCQlpbnB1dF9yZWdzKCZhdGtiZC0+ZGV2LCByZWdzKTsKKwkJaWYgKGNsaWNrICE9IC0xKQorCQkJaW5wdXRfcmVwb3J0X2tleSgmYXRrYmQtPmRldiwgQlROX01JRERMRSwgY2xpY2spOworCQlpbnB1dF9yZXBvcnRfcmVsKCZhdGtiZC0+ZGV2LCBSRUxfV0hFRUwsIHNjcm9sbCk7CisJCWlucHV0X3JlcG9ydF9yZWwoJmF0a2JkLT5kZXYsIFJFTF9IV0hFRUwsIGhzY3JvbGwpOworCQlpbnB1dF9zeW5jKCZhdGtiZC0+ZGV2KTsKKwl9CisKKwlhdGtiZC0+cmVsZWFzZSA9IDA7CitvdXQ6CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCisvKgorICogRXZlbnQgY2FsbGJhY2sgZnJvbSB0aGUgaW5wdXQgbW9kdWxlLiBFdmVudHMgdGhhdCBjaGFuZ2UgdGhlIHN0YXRlIG9mCisgKiB0aGUgaGFyZHdhcmUgYXJlIHByb2Nlc3NlZCBoZXJlLgorICovCisKK3N0YXRpYyBpbnQgYXRrYmRfZXZlbnQoc3RydWN0IGlucHV0X2RldiAqZGV2LCB1bnNpZ25lZCBpbnQgdHlwZSwgdW5zaWduZWQgaW50IGNvZGUsIGludCB2YWx1ZSkKK3sKKwlzdHJ1Y3QgYXRrYmQgKmF0a2JkID0gZGV2LT5wcml2YXRlOworCWNvbnN0IHNob3J0IHBlcmlvZFszMl0gPQorCQl7IDMzLCAgMzcsICA0MiwgIDQ2LCAgNTAsICA1NCwgIDU4LCAgNjMsICA2NywgIDc1LCAgODMsICA5MiwgMTAwLCAxMDksIDExNiwgMTI1LAorCQkgMTMzLCAxNDksIDE2NywgMTgyLCAyMDAsIDIxNywgMjMyLCAyNTAsIDI3MCwgMzAzLCAzMzMsIDM3MCwgNDAwLCA0MzUsIDQ3MCwgNTAwIH07CisJY29uc3Qgc2hvcnQgZGVsYXlbNF0gPQorCQl7IDI1MCwgNTAwLCA3NTAsIDEwMDAgfTsKKwl1bnNpZ25lZCBjaGFyIHBhcmFtWzJdOworCWludCBpLCBqOworCisJaWYgKCFhdGtiZC0+d3JpdGUpCisJCXJldHVybiAtMTsKKworCXN3aXRjaCAodHlwZSkgeworCisJCWNhc2UgRVZfTEVEOgorCisJCQlwYXJhbVswXSA9ICh0ZXN0X2JpdChMRURfU0NST0xMTCwgZGV2LT5sZWQpID8gMSA6IDApCisJCQkgICAgICAgICB8ICh0ZXN0X2JpdChMRURfTlVNTCwgICAgZGV2LT5sZWQpID8gMiA6IDApCisJCQkgICAgICAgICB8ICh0ZXN0X2JpdChMRURfQ0FQU0wsICAgZGV2LT5sZWQpID8gNCA6IDApOworCQkgICAgICAgIHBzMl9zY2hlZHVsZV9jb21tYW5kKCZhdGtiZC0+cHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX1NFVExFRFMpOworCisJCQlpZiAoYXRrYmQtPmV4dHJhKSB7CisJCQkJcGFyYW1bMF0gPSAwOworCQkJCXBhcmFtWzFdID0gKHRlc3RfYml0KExFRF9DT01QT1NFLCBkZXYtPmxlZCkgPyAweDAxIDogMCkKKwkJCQkJIHwgKHRlc3RfYml0KExFRF9TTEVFUCwgICBkZXYtPmxlZCkgPyAweDAyIDogMCkKKwkJCQkJIHwgKHRlc3RfYml0KExFRF9TVVNQRU5ELCBkZXYtPmxlZCkgPyAweDA0IDogMCkKKwkJCQkgICAgICAgICB8ICh0ZXN0X2JpdChMRURfTUlTQywgICAgZGV2LT5sZWQpID8gMHgxMCA6IDApCisJCQkJICAgICAgICAgfCAodGVzdF9iaXQoTEVEX01VVEUsICAgIGRldi0+bGVkKSA/IDB4MjAgOiAwKTsKKwkJCQlwczJfc2NoZWR1bGVfY29tbWFuZCgmYXRrYmQtPnBzMmRldiwgcGFyYW0sIEFUS0JEX0NNRF9FWF9TRVRMRURTKTsKKwkJCX0KKworCQkJcmV0dXJuIDA7CisKKworCQljYXNlIEVWX1JFUDoKKworCQkJaWYgKGF0a2JkLT5zb2Z0cmVwZWF0KSByZXR1cm4gMDsKKworCQkJaSA9IGogPSAwOworCQkJd2hpbGUgKGkgPCAzMiAmJiBwZXJpb2RbaV0gPCBkZXYtPnJlcFtSRVBfUEVSSU9EXSkgaSsrOworCQkJd2hpbGUgKGogPCA0ICYmIGRlbGF5W2pdIDwgZGV2LT5yZXBbUkVQX0RFTEFZXSkgaisrOworCQkJZGV2LT5yZXBbUkVQX1BFUklPRF0gPSBwZXJpb2RbaV07CisJCQlkZXYtPnJlcFtSRVBfREVMQVldID0gZGVsYXlbal07CisJCQlwYXJhbVswXSA9IGkgfCAoaiA8PCA1KTsKKwkJCXBzMl9zY2hlZHVsZV9jb21tYW5kKCZhdGtiZC0+cHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX1NFVFJFUCk7CisKKwkJCXJldHVybiAwOworCX0KKworCXJldHVybiAtMTsKK30KKworLyoKKyAqIGF0a2JkX2VuYWJsZSgpIHNpZ25hbHMgdGhhdCBpbnRlcnJ1cHQgaGFuZGxlciBpcyBhbGxvd2VkIHRvCisgKiBnZW5lcmF0ZSBpbnB1dCBldmVudHMuCisgKi8KKworc3RhdGljIGlubGluZSB2b2lkIGF0a2JkX2VuYWJsZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworCXNlcmlvX3BhdXNlX3J4KGF0a2JkLT5wczJkZXYuc2VyaW8pOworCWF0a2JkLT5lbmFibGVkID0gMTsKKwlzZXJpb19jb250aW51ZV9yeChhdGtiZC0+cHMyZGV2LnNlcmlvKTsKK30KKworLyoKKyAqIGF0a2JkX2Rpc2FibGUoKSB0ZWxscyBpbnB1dCBoYW5kbGVyIHRoYXQgYWxsIGluY29taW5nIGRhdGEgZXhjZXB0CisgKiBmb3IgQUNLcyBhbmQgY29tbWFuZCByZXNwb25zZSBzaG91bGQgYmUgZHJvcHBlZC4KKyAqLworCitzdGF0aWMgaW5saW5lIHZvaWQgYXRrYmRfZGlzYWJsZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworCXNlcmlvX3BhdXNlX3J4KGF0a2JkLT5wczJkZXYuc2VyaW8pOworCWF0a2JkLT5lbmFibGVkID0gMDsKKwlzZXJpb19jb250aW51ZV9yeChhdGtiZC0+cHMyZGV2LnNlcmlvKTsKK30KKworLyoKKyAqIGF0a2JkX3Byb2JlKCkgcHJvYmVzIGZvciBhbiBBVCBrZXlib2FyZCBvbiBhIHNlcmlvIHBvcnQuCisgKi8KKworc3RhdGljIGludCBhdGtiZF9wcm9iZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworCXN0cnVjdCBwczJkZXYgKnBzMmRldiA9ICZhdGtiZC0+cHMyZGV2OworCXVuc2lnbmVkIGNoYXIgcGFyYW1bMl07CisKKy8qCisgKiBTb21lIHN5c3RlbXMsIHdoZXJlIHRoZSBiaXQtdHdpZGRsaW5nIHdoZW4gdGVzdGluZyB0aGUgaW8tbGluZXMgb2YgdGhlCisgKiBjb250cm9sbGVyIG1heSBjb25mdXNlIHRoZSBrZXlib2FyZCBuZWVkIGEgZnVsbCByZXNldCBvZiB0aGUga2V5Ym9hcmQuIE9uCisgKiB0aGVzZSBzeXN0ZW1zIHRoZSBCSU9TIGFsc28gdXN1YWxseSBkb2Vzbid0IGRvIGl0IGZvciB1cy4KKyAqLworCisJaWYgKGF0a2JkX3Jlc2V0KQorCQlpZiAocHMyX2NvbW1hbmQocHMyZGV2LCBOVUxMLCBBVEtCRF9DTURfUkVTRVRfQkFUKSkKKwkJCXByaW50ayhLRVJOX1dBUk5JTkcgImF0a2JkLmM6IGtleWJvYXJkIHJlc2V0IGZhaWxlZCBvbiAlc1xuIiwgcHMyZGV2LT5zZXJpby0+cGh5cyk7CisKKy8qCisgKiBUaGVuIHdlIGNoZWNrIHRoZSBrZXlib2FyZCBJRC4gV2Ugc2hvdWxkIGdldCAweGFiODMgdW5kZXIgbm9ybWFsIGNvbmRpdGlvbnMuCisgKiBTb21lIGtleWJvYXJkcyByZXBvcnQgZGlmZmVyZW50IHZhbHVlcywgYnV0IHRoZSBmaXJzdCBieXRlIGlzIGFsd2F5cyAweGFiIG9yCisgKiAweGFjLiBTb21lIG9sZCBBVCBrZXlib2FyZHMgZG9uJ3QgcmVwb3J0IGFueXRoaW5nLiBJZiBhIG1vdXNlIGlzIGNvbm5lY3RlZCwgdGhpcworICogc2hvdWxkIG1ha2Ugc3VyZSB3ZSBkb24ndCB0cnkgdG8gc2V0IHRoZSBMRURzIG9uIGl0LgorICovCisKKwlwYXJhbVswXSA9IHBhcmFtWzFdID0gMHhhNTsJLyogaW5pdGlhbGl6ZSB3aXRoIGludmFsaWQgdmFsdWVzICovCisJaWYgKHBzMl9jb21tYW5kKHBzMmRldiwgcGFyYW0sIEFUS0JEX0NNRF9HRVRJRCkpIHsKKworLyoKKyAqIElmIHRoZSBnZXQgSUQgY29tbWFuZCBmYWlsZWQsIHdlIGNoZWNrIGlmIHdlIGNhbiBhdCBsZWFzdCBzZXQgdGhlIExFRHMgb24KKyAqIHRoZSBrZXlib2FyZC4gVGhpcyBzaG91bGQgd29yayBvbiBldmVyeSBrZXlib2FyZCBvdXQgdGhlcmUuIEl0IGFsc28gdHVybnMKKyAqIHRoZSBMRURzIG9mZiwgd2hpY2ggd2Ugd2FudCBhbnl3YXkuCisgKi8KKwkJcGFyYW1bMF0gPSAwOworCQlpZiAocHMyX2NvbW1hbmQocHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX1NFVExFRFMpKQorCQkJcmV0dXJuIC0xOworCQlhdGtiZC0+aWQgPSAweGFiYmE7CisJCXJldHVybiAwOworCX0KKworCWlmIChwYXJhbVswXSAhPSAweGFiICYmIHBhcmFtWzBdICE9IDB4YWMgJiYJLyogUmVndWxhciBhbmQgTkNEIFN1biBrZXlib2FyZHMgKi8KKwkgICAgcGFyYW1bMF0gIT0gMHgyYiAmJiBwYXJhbVswXSAhPSAweDVkICYmCS8qIFRydXN0IGtleWJvYXJkLCByYXcgYW5kIHRyYW5zbGF0ZWQgKi8KKwkgICAgcGFyYW1bMF0gIT0gMHg2MCAmJiBwYXJhbVswXSAhPSAweDQ3KQkvKiBOTUIgU0dJIGtleWJvYXJkLCByYXcgYW5kIHRyYW5zbGF0ZWQgKi8KKwkJcmV0dXJuIC0xOworCisJYXRrYmQtPmlkID0gKHBhcmFtWzBdIDw8IDgpIHwgcGFyYW1bMV07CisKKwlpZiAoYXRrYmQtPmlkID09IDB4YWNhMSAmJiBhdGtiZC0+dHJhbnNsYXRlZCkgeworCQlwcmludGsoS0VSTl9FUlIgImF0a2JkLmM6IE5DRCB0ZXJtaW5hbCBrZXlib2FyZHMgYXJlIG9ubHkgc3VwcG9ydGVkIG9uIG5vbi10cmFuc2xhdGluZ1xuIik7CisJCXByaW50ayhLRVJOX0VSUiAiYXRrYmQuYzogY29udHJvbGxlcnMuIFVzZSBpODA0Mi5kaXJlY3Q9MSB0byBkaXNhYmxlIHRyYW5zbGF0aW9uLlxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIGF0a2JkX3NlbGVjdF9zZXQgY2hlY2tzIGlmIGEga2V5Ym9hcmQgaGFzIGEgd29ya2luZyBTZXQgMyBzdXBwb3J0LCBhbmQKKyAqIHNldHMgaXQgaW50byB0aGF0LiBVbmZvcnR1bmF0ZWx5IHRoZXJlIGFyZSBrZXlib2FyZHMgdGhhdCBjYW4gYmUgc3dpdGNoZWQKKyAqIHRvIFNldCAzLCBidXQgZG9uJ3Qgd29yayB3ZWxsIGluIHRoYXQgKEJUQyBNdWx0aW1lZGlhIC4uLikKKyAqLworCitzdGF0aWMgaW50IGF0a2JkX3NlbGVjdF9zZXQoc3RydWN0IGF0a2JkICphdGtiZCwgaW50IHRhcmdldF9zZXQsIGludCBhbGxvd19leHRyYSkKK3sKKwlzdHJ1Y3QgcHMyZGV2ICpwczJkZXYgPSAmYXRrYmQtPnBzMmRldjsKKwl1bnNpZ25lZCBjaGFyIHBhcmFtWzJdOworCisJYXRrYmQtPmV4dHJhID0gMDsKKy8qCisgKiBGb3Iga25vd24gc3BlY2lhbCBrZXlib2FyZHMgd2UgY2FuIGdvIGFoZWFkIGFuZCBzZXQgdGhlIGNvcnJlY3Qgc2V0LgorICogV2UgY2hlY2sgZm9yIE5DRCBQUy8yIFN1biwgTm9ydGhHYXRlIE9tbmlLZXkgMTAxIGFuZAorICogSUJNIFJhcGlkQWNjZXNzIC8gSUJNIEV6QnV0dG9uIC8gQ2hpY29ueSBLQlAtODk5MyBrZXlib2FyZHMuCisgKi8KKworCWlmIChhdGtiZC0+dHJhbnNsYXRlZCkKKwkJcmV0dXJuIDI7CisKKwlpZiAoYXRrYmQtPmlkID09IDB4YWNhMSkgeworCQlwYXJhbVswXSA9IDM7CisJCXBzMl9jb21tYW5kKHBzMmRldiwgcGFyYW0sIEFUS0JEX0NNRF9TU0NBTlNFVCk7CisJCXJldHVybiAzOworCX0KKworCWlmIChhbGxvd19leHRyYSkgeworCQlwYXJhbVswXSA9IDB4NzE7CisJCWlmICghcHMyX2NvbW1hbmQocHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX0VYX0VOQUJMRSkpIHsKKwkJCWF0a2JkLT5leHRyYSA9IDE7CisJCQlyZXR1cm4gMjsKKwkJfQorCX0KKworCWlmICh0YXJnZXRfc2V0ICE9IDMpCisJCXJldHVybiAyOworCisJaWYgKCFwczJfY29tbWFuZChwczJkZXYsIHBhcmFtLCBBVEtCRF9DTURfT0tfR0VUSUQpKSB7CisJCWF0a2JkLT5pZCA9IHBhcmFtWzBdIDw8IDggfCBwYXJhbVsxXTsKKwkJcmV0dXJuIDI7CisJfQorCisJcGFyYW1bMF0gPSAzOworCWlmIChwczJfY29tbWFuZChwczJkZXYsIHBhcmFtLCBBVEtCRF9DTURfU1NDQU5TRVQpKQorCQlyZXR1cm4gMjsKKworCXBhcmFtWzBdID0gMDsKKwlpZiAocHMyX2NvbW1hbmQocHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX0dTQ0FOU0VUKSkKKwkJcmV0dXJuIDI7CisKKwlpZiAocGFyYW1bMF0gIT0gMykgeworCQlwYXJhbVswXSA9IDI7CisJCWlmIChwczJfY29tbWFuZChwczJkZXYsIHBhcmFtLCBBVEtCRF9DTURfU1NDQU5TRVQpKQorCQlyZXR1cm4gMjsKKwl9CisKKwlwczJfY29tbWFuZChwczJkZXYsIHBhcmFtLCBBVEtCRF9DTURfU0VUQUxMX01CUik7CisKKwlyZXR1cm4gMzsKK30KKworc3RhdGljIGludCBhdGtiZF9hY3RpdmF0ZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworCXN0cnVjdCBwczJkZXYgKnBzMmRldiA9ICZhdGtiZC0+cHMyZGV2OworCXVuc2lnbmVkIGNoYXIgcGFyYW1bMV07CisKKy8qCisgKiBTZXQgdGhlIExFRHMgdG8gYSBkZWZpbmVkIHN0YXRlLgorICovCisKKwlwYXJhbVswXSA9IDA7CisJaWYgKHBzMl9jb21tYW5kKHBzMmRldiwgcGFyYW0sIEFUS0JEX0NNRF9TRVRMRURTKSkKKwkJcmV0dXJuIC0xOworCisvKgorICogU2V0IGF1dG9yZXBlYXQgdG8gZmFzdGVzdCBwb3NzaWJsZS4KKyAqLworCisJcGFyYW1bMF0gPSAwOworCWlmIChwczJfY29tbWFuZChwczJkZXYsIHBhcmFtLCBBVEtCRF9DTURfU0VUUkVQKSkKKwkJcmV0dXJuIC0xOworCisvKgorICogRW5hYmxlIHRoZSBrZXlib2FyZCB0byByZWNlaXZlIGtleXN0cm9rZXMuCisgKi8KKworCWlmIChwczJfY29tbWFuZChwczJkZXYsIE5VTEwsIEFUS0JEX0NNRF9FTkFCTEUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiYXRrYmQuYzogRmFpbGVkIHRvIGVuYWJsZSBrZXlib2FyZCBvbiAlc1xuIiwKKwkJCXBzMmRldi0+c2VyaW8tPnBoeXMpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBhdGtiZF9jbGVhbnVwKCkgcmVzdG9yZXMgdGhlIGtleWJvYXJkIHN0YXRlIHNvIHRoYXQgQklPUyBpcyBoYXBweSBhZnRlciBhCisgKiByZWJvb3QuCisgKi8KKworc3RhdGljIHZvaWQgYXRrYmRfY2xlYW51cChzdHJ1Y3Qgc2VyaW8gKnNlcmlvKQoreworCXN0cnVjdCBhdGtiZCAqYXRrYmQgPSBzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyk7CisJcHMyX2NvbW1hbmQoJmF0a2JkLT5wczJkZXYsIE5VTEwsIEFUS0JEX0NNRF9SRVNFVF9CQVQpOworfQorCisKKy8qCisgKiBhdGtiZF9kaXNjb25uZWN0KCkgY2xvc2VzIGFuZCBmcmVlcy4KKyAqLworCitzdGF0aWMgdm9pZCBhdGtiZF9kaXNjb25uZWN0KHN0cnVjdCBzZXJpbyAqc2VyaW8pCit7CisJc3RydWN0IGF0a2JkICphdGtiZCA9IHNlcmlvX2dldF9kcnZkYXRhKHNlcmlvKTsKKworCWF0a2JkX2Rpc2FibGUoYXRrYmQpOworCisJLyogbWFrZSBzdXJlIHdlIGRvbid0IGhhdmUgYSBjb21tYW5kIGluIGZsaWdodCAqLworCXN5bmNocm9uaXplX2tlcm5lbCgpOworCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisKKwlkZXZpY2VfcmVtb3ZlX2ZpbGUoJnNlcmlvLT5kZXYsICZhdGtiZF9hdHRyX2V4dHJhKTsKKwlkZXZpY2VfcmVtb3ZlX2ZpbGUoJnNlcmlvLT5kZXYsICZhdGtiZF9hdHRyX3Njcm9sbCk7CisJZGV2aWNlX3JlbW92ZV9maWxlKCZzZXJpby0+ZGV2LCAmYXRrYmRfYXR0cl9zZXQpOworCWRldmljZV9yZW1vdmVfZmlsZSgmc2VyaW8tPmRldiwgJmF0a2JkX2F0dHJfc29mdHJlcGVhdCk7CisJZGV2aWNlX3JlbW92ZV9maWxlKCZzZXJpby0+ZGV2LCAmYXRrYmRfYXR0cl9zb2Z0cmF3KTsKKworCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKCZhdGtiZC0+ZGV2KTsKKwlzZXJpb19jbG9zZShzZXJpbyk7CisJc2VyaW9fc2V0X2RydmRhdGEoc2VyaW8sIE5VTEwpOworCWtmcmVlKGF0a2JkKTsKK30KKworCisvKgorICogYXRrYmRfc2V0X2RldmljZV9hdHRycygpIGluaXRpYWxpemVzIGtleWJvYXJkJ3Mga2V5Y29kZSB0YWJsZQorICogYWNjb3JkaW5nIHRvIHRoZSBzZWxlY3RlZCBzY2FuY29kZSBzZXQKKyAqLworCitzdGF0aWMgdm9pZCBhdGtiZF9zZXRfa2V5Y29kZV90YWJsZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworCWludCBpLCBqOworCisJbWVtc2V0KGF0a2JkLT5rZXljb2RlLCAwLCBzaXplb2YoYXRrYmQtPmtleWNvZGUpKTsKKworCWlmIChhdGtiZC0+dHJhbnNsYXRlZCkgeworCQlmb3IgKGkgPSAwOyBpIDwgMTI4OyBpKyspIHsKKwkJCWF0a2JkLT5rZXljb2RlW2ldID0gYXRrYmRfc2V0Ml9rZXljb2RlW2F0a2JkX3VueGxhdGVfdGFibGVbaV1dOworCQkJYXRrYmQtPmtleWNvZGVbaSB8IDB4ODBdID0gYXRrYmRfc2V0Ml9rZXljb2RlW2F0a2JkX3VueGxhdGVfdGFibGVbaV0gfCAweDgwXTsKKwkJCWlmIChhdGtiZC0+c2Nyb2xsKQorCQkJCWZvciAoaiA9IDA7IGogPCBBUlJBWV9TSVpFKGF0a2JkX3Njcm9sbF9rZXlzKTsgaisrKQorCQkJCQlpZiAoKGF0a2JkX3VueGxhdGVfdGFibGVbaV0gfCAweDgwKSA9PSBhdGtiZF9zY3JvbGxfa2V5c1tqXS5zZXQyKQorCQkJCQkJYXRrYmQtPmtleWNvZGVbaSB8IDB4ODBdID0gYXRrYmRfc2Nyb2xsX2tleXNbal0ua2V5Y29kZTsKKwkJfQorCX0gZWxzZSBpZiAoYXRrYmQtPnNldCA9PSAzKSB7CisJCW1lbWNweShhdGtiZC0+a2V5Y29kZSwgYXRrYmRfc2V0M19rZXljb2RlLCBzaXplb2YoYXRrYmQtPmtleWNvZGUpKTsKKwl9IGVsc2UgeworCQltZW1jcHkoYXRrYmQtPmtleWNvZGUsIGF0a2JkX3NldDJfa2V5Y29kZSwgc2l6ZW9mKGF0a2JkLT5rZXljb2RlKSk7CisKKwkJaWYgKGF0a2JkLT5zY3JvbGwpCisJCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShhdGtiZF9zY3JvbGxfa2V5cyk7IGkrKykKKwkJCQlhdGtiZC0+a2V5Y29kZVthdGtiZF9zY3JvbGxfa2V5c1tpXS5zZXQyXSA9IGF0a2JkX3Njcm9sbF9rZXlzW2ldLmtleWNvZGU7CisJfQorfQorCisvKgorICogYXRrYmRfc2V0X2RldmljZV9hdHRycygpIHNldHMgdXAga2V5Ym9hcmQncyBpbnB1dCBkZXZpY2Ugc3RydWN0dXJlCisgKi8KKworc3RhdGljIHZvaWQgYXRrYmRfc2V0X2RldmljZV9hdHRycyhzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworCWludCBpOworCisJbWVtc2V0KCZhdGtiZC0+ZGV2LCAwLCBzaXplb2Yoc3RydWN0IGlucHV0X2RldikpOworCisJaW5pdF9pbnB1dF9kZXYoJmF0a2JkLT5kZXYpOworCisJYXRrYmQtPmRldi5uYW1lID0gYXRrYmQtPm5hbWU7CisJYXRrYmQtPmRldi5waHlzID0gYXRrYmQtPnBoeXM7CisJYXRrYmQtPmRldi5pZC5idXN0eXBlID0gQlVTX0k4MDQyOworCWF0a2JkLT5kZXYuaWQudmVuZG9yID0gMHgwMDAxOworCWF0a2JkLT5kZXYuaWQucHJvZHVjdCA9IGF0a2JkLT50cmFuc2xhdGVkID8gMSA6IGF0a2JkLT5zZXQ7CisJYXRrYmQtPmRldi5pZC52ZXJzaW9uID0gYXRrYmQtPmlkOworCWF0a2JkLT5kZXYuZXZlbnQgPSBhdGtiZF9ldmVudDsKKwlhdGtiZC0+ZGV2LnByaXZhdGUgPSBhdGtiZDsKKwlhdGtiZC0+ZGV2LmRldiA9ICZhdGtiZC0+cHMyZGV2LnNlcmlvLT5kZXY7CisKKwlhdGtiZC0+ZGV2LmV2Yml0WzBdID0gQklUKEVWX0tFWSkgfCBCSVQoRVZfUkVQKSB8IEJJVChFVl9NU0MpOworCisJaWYgKGF0a2JkLT53cml0ZSkgeworCQlhdGtiZC0+ZGV2LmV2Yml0WzBdIHw9IEJJVChFVl9MRUQpOworCQlhdGtiZC0+ZGV2LmxlZGJpdFswXSA9IEJJVChMRURfTlVNTCkgfCBCSVQoTEVEX0NBUFNMKSB8IEJJVChMRURfU0NST0xMTCk7CisJfQorCisJaWYgKGF0a2JkLT5leHRyYSkKKwkJYXRrYmQtPmRldi5sZWRiaXRbMF0gfD0gQklUKExFRF9DT01QT1NFKSB8IEJJVChMRURfU1VTUEVORCkgfAorCQkJCQlCSVQoTEVEX1NMRUVQKSB8IEJJVChMRURfTVVURSkgfCBCSVQoTEVEX01JU0MpOworCisJaWYgKCFhdGtiZC0+c29mdHJlcGVhdCkgeworCQlhdGtiZC0+ZGV2LnJlcFtSRVBfREVMQVldID0gMjUwOworCQlhdGtiZC0+ZGV2LnJlcFtSRVBfUEVSSU9EXSA9IDMzOworCX0KKworCWF0a2JkLT5kZXYubXNjYml0WzBdID0gYXRrYmQtPnNvZnRyYXcgPyBCSVQoTVNDX1NDQU4pIDogQklUKE1TQ19SQVcpIHwgQklUKE1TQ19TQ0FOKTsKKworCWlmIChhdGtiZC0+c2Nyb2xsKSB7CisJCWF0a2JkLT5kZXYuZXZiaXRbMF0gfD0gQklUKEVWX1JFTCk7CisJCWF0a2JkLT5kZXYucmVsYml0WzBdID0gQklUKFJFTF9XSEVFTCkgfCBCSVQoUkVMX0hXSEVFTCk7CisJCXNldF9iaXQoQlROX01JRERMRSwgYXRrYmQtPmRldi5rZXliaXQpOworCX0KKworCWF0a2JkLT5kZXYua2V5Y29kZSA9IGF0a2JkLT5rZXljb2RlOworCWF0a2JkLT5kZXYua2V5Y29kZXNpemUgPSBzaXplb2YodW5zaWduZWQgY2hhcik7CisJYXRrYmQtPmRldi5rZXljb2RlbWF4ID0gQVJSQVlfU0laRShhdGtiZF9zZXQyX2tleWNvZGUpOworCisJZm9yIChpID0gMDsgaSA8IDUxMjsgaSsrKQorCQlpZiAoYXRrYmQtPmtleWNvZGVbaV0gJiYgYXRrYmQtPmtleWNvZGVbaV0gPCBBVEtCRF9TUEVDSUFMKQorCQkJc2V0X2JpdChhdGtiZC0+a2V5Y29kZVtpXSwgYXRrYmQtPmRldi5rZXliaXQpOworfQorCisvKgorICogYXRrYmRfY29ubmVjdCgpIGlzIGNhbGxlZCB3aGVuIHRoZSBzZXJpbyBtb2R1bGUgZmluZHMgYW4gaW50ZXJmYWNlCisgKiB0aGF0IGlzbid0IGhhbmRsZWQgeWV0IGJ5IGFuIGFwcHJvcHJpYXRlIGRldmljZSBkcml2ZXIuIFdlIGNoZWNrIGlmCisgKiB0aGVyZSBpcyBhbiBBVCBrZXlib2FyZCBvdXQgdGhlcmUgYW5kIGlmIHllcywgd2UgcmVnaXN0ZXIgb3Vyc2VsdmVzCisgKiB0byB0aGUgaW5wdXQgbW9kdWxlLgorICovCisKK3N0YXRpYyBpbnQgYXRrYmRfY29ubmVjdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvLCBzdHJ1Y3Qgc2VyaW9fZHJpdmVyICpkcnYpCit7CisJc3RydWN0IGF0a2JkICphdGtiZDsKKwlpbnQgZXJyOworCisJaWYgKCEoYXRrYmQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgYXRrYmQpLCBHRlBfS0VSTkVMKSkpCisJCXJldHVybiAtIEVOT01FTTsKKworCW1lbXNldChhdGtiZCwgMCwgc2l6ZW9mKHN0cnVjdCBhdGtiZCkpOworCisJcHMyX2luaXQoJmF0a2JkLT5wczJkZXYsIHNlcmlvKTsKKworCXN3aXRjaCAoc2VyaW8tPmlkLnR5cGUpIHsKKworCQljYXNlIFNFUklPXzgwNDJfWEw6CisJCQlhdGtiZC0+dHJhbnNsYXRlZCA9IDE7CisJCWNhc2UgU0VSSU9fODA0MjoKKwkJCWlmIChzZXJpby0+d3JpdGUpCisJCQkJYXRrYmQtPndyaXRlID0gMTsKKwkJCWJyZWFrOworCX0KKworCWF0a2JkLT5zb2Z0cmF3ID0gYXRrYmRfc29mdHJhdzsKKwlhdGtiZC0+c29mdHJlcGVhdCA9IGF0a2JkX3NvZnRyZXBlYXQ7CisJYXRrYmQtPnNjcm9sbCA9IGF0a2JkX3Njcm9sbDsKKworCWlmICghYXRrYmQtPndyaXRlKQorCQlhdGtiZC0+c29mdHJlcGVhdCA9IDE7CisKKwlpZiAoYXRrYmQtPnNvZnRyZXBlYXQpCisJCWF0a2JkLT5zb2Z0cmF3ID0gMTsKKworCXNlcmlvX3NldF9kcnZkYXRhKHNlcmlvLCBhdGtiZCk7CisKKwllcnIgPSBzZXJpb19vcGVuKHNlcmlvLCBkcnYpOworCWlmIChlcnIpIHsKKwkJc2VyaW9fc2V0X2RydmRhdGEoc2VyaW8sIE5VTEwpOworCQlrZnJlZShhdGtiZCk7CisJCXJldHVybiBlcnI7CisJfQorCisJaWYgKGF0a2JkLT53cml0ZSkgeworCisJCWlmIChhdGtiZF9wcm9iZShhdGtiZCkpIHsKKwkJCXNlcmlvX2Nsb3NlKHNlcmlvKTsKKwkJCXNlcmlvX3NldF9kcnZkYXRhKHNlcmlvLCBOVUxMKTsKKwkJCWtmcmVlKGF0a2JkKTsKKwkJCXJldHVybiAtRU5PREVWOworCQl9CisKKwkJYXRrYmQtPnNldCA9IGF0a2JkX3NlbGVjdF9zZXQoYXRrYmQsIGF0a2JkX3NldCwgYXRrYmRfZXh0cmEpOworCQlhdGtiZF9hY3RpdmF0ZShhdGtiZCk7CisKKwl9IGVsc2UgeworCQlhdGtiZC0+c2V0ID0gMjsKKwkJYXRrYmQtPmlkID0gMHhhYjAwOworCX0KKworCWlmIChhdGtiZC0+ZXh0cmEpCisJCXNwcmludGYoYXRrYmQtPm5hbWUsICJBVCBTZXQgMiBFeHRyYSBrZXlib2FyZCIpOworCWVsc2UKKwkJc3ByaW50ZihhdGtiZC0+bmFtZSwgIkFUICVzIFNldCAlZCBrZXlib2FyZCIsCisJCQlhdGtiZC0+dHJhbnNsYXRlZCA/ICJUcmFuc2xhdGVkIiA6ICJSYXciLCBhdGtiZC0+c2V0KTsKKworCXNwcmludGYoYXRrYmQtPnBoeXMsICIlcy9pbnB1dDAiLCBzZXJpby0+cGh5cyk7CisKKwlhdGtiZF9zZXRfa2V5Y29kZV90YWJsZShhdGtiZCk7CisJYXRrYmRfc2V0X2RldmljZV9hdHRycyhhdGtiZCk7CisKKwlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJmF0a2JkLT5kZXYpOworCisJZGV2aWNlX2NyZWF0ZV9maWxlKCZzZXJpby0+ZGV2LCAmYXRrYmRfYXR0cl9leHRyYSk7CisJZGV2aWNlX2NyZWF0ZV9maWxlKCZzZXJpby0+ZGV2LCAmYXRrYmRfYXR0cl9zY3JvbGwpOworCWRldmljZV9jcmVhdGVfZmlsZSgmc2VyaW8tPmRldiwgJmF0a2JkX2F0dHJfc2V0KTsKKwlkZXZpY2VfY3JlYXRlX2ZpbGUoJnNlcmlvLT5kZXYsICZhdGtiZF9hdHRyX3NvZnRyZXBlYXQpOworCWRldmljZV9jcmVhdGVfZmlsZSgmc2VyaW8tPmRldiwgJmF0a2JkX2F0dHJfc29mdHJhdyk7CisKKwlhdGtiZF9lbmFibGUoYXRrYmQpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6ICVzIG9uICVzXG4iLCBhdGtiZC0+bmFtZSwgc2VyaW8tPnBoeXMpOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBhdGtiZF9yZWNvbm5lY3QoKSB0cmllcyB0byByZXN0b3JlIGtleWJvYXJkIGludG8gYSBzYW5lIHN0YXRlIGFuZCBpcworICogbW9zdCBsaWtlbHkgY2FsbGVkIG9uIHJlc3VtZS4KKyAqLworCitzdGF0aWMgaW50IGF0a2JkX3JlY29ubmVjdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvKQoreworCXN0cnVjdCBhdGtiZCAqYXRrYmQgPSBzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyk7CisJc3RydWN0IHNlcmlvX2RyaXZlciAqZHJ2ID0gc2VyaW8tPmRydjsKKwl1bnNpZ25lZCBjaGFyIHBhcmFtWzFdOworCisJaWYgKCFhdGtiZCB8fCAhZHJ2KSB7CisJCXByaW50ayhLRVJOX0RFQlVHICJhdGtiZDogcmVjb25uZWN0IHJlcXVlc3QsIGJ1dCBzZXJpbyBpcyBkaXNjb25uZWN0ZWQsIGlnbm9yaW5nLi4uXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWF0a2JkX2Rpc2FibGUoYXRrYmQpOworCisJaWYgKGF0a2JkLT53cml0ZSkgeworCQlwYXJhbVswXSA9ICh0ZXN0X2JpdChMRURfU0NST0xMTCwgYXRrYmQtPmRldi5sZWQpID8gMSA6IDApCisJCSAgICAgICAgIHwgKHRlc3RfYml0KExFRF9OVU1MLCAgICBhdGtiZC0+ZGV2LmxlZCkgPyAyIDogMCkKKyAJCSAgICAgICAgIHwgKHRlc3RfYml0KExFRF9DQVBTTCwgICBhdGtiZC0+ZGV2LmxlZCkgPyA0IDogMCk7CisKKwkJaWYgKGF0a2JkX3Byb2JlKGF0a2JkKSkKKwkJCXJldHVybiAtMTsKKwkJaWYgKGF0a2JkLT5zZXQgIT0gYXRrYmRfc2VsZWN0X3NldChhdGtiZCwgYXRrYmQtPnNldCwgYXRrYmQtPmV4dHJhKSkKKwkJCXJldHVybiAtMTsKKworCQlhdGtiZF9hY3RpdmF0ZShhdGtiZCk7CisKKwkJaWYgKHBzMl9jb21tYW5kKCZhdGtiZC0+cHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX1NFVExFRFMpKQorCQkJcmV0dXJuIC0xOworCX0KKworCWF0a2JkX2VuYWJsZShhdGtiZCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBzZXJpb19kZXZpY2VfaWQgYXRrYmRfc2VyaW9faWRzW10gPSB7CisJeworCQkudHlwZQk9IFNFUklPXzgwNDIsCisJCS5wcm90bwk9IFNFUklPX0FOWSwKKwkJLmlkCT0gU0VSSU9fQU5ZLAorCQkuZXh0cmEJPSBTRVJJT19BTlksCisJfSwKKwl7CisJCS50eXBlCT0gU0VSSU9fODA0Ml9YTCwKKwkJLnByb3RvCT0gU0VSSU9fQU5ZLAorCQkuaWQJPSBTRVJJT19BTlksCisJCS5leHRyYQk9IFNFUklPX0FOWSwKKwl9LAorCXsKKwkJLnR5cGUJPSBTRVJJT19SUzIzMiwKKwkJLnByb3RvCT0gU0VSSU9fUFMyU0VSLAorCQkuaWQJPSBTRVJJT19BTlksCisJCS5leHRyYQk9IFNFUklPX0FOWSwKKwl9LAorCXsgMCB9Cit9OworCitNT0RVTEVfREVWSUNFX1RBQkxFKHNlcmlvLCBhdGtiZF9zZXJpb19pZHMpOworCitzdGF0aWMgc3RydWN0IHNlcmlvX2RyaXZlciBhdGtiZF9kcnYgPSB7CisJLmRyaXZlcgkJPSB7CisJCS5uYW1lCT0gImF0a2JkIiwKKwl9LAorCS5kZXNjcmlwdGlvbgk9IERSSVZFUl9ERVNDLAorCS5pZF90YWJsZQk9IGF0a2JkX3NlcmlvX2lkcywKKwkuaW50ZXJydXB0CT0gYXRrYmRfaW50ZXJydXB0LAorCS5jb25uZWN0CT0gYXRrYmRfY29ubmVjdCwKKwkucmVjb25uZWN0CT0gYXRrYmRfcmVjb25uZWN0LAorCS5kaXNjb25uZWN0CT0gYXRrYmRfZGlzY29ubmVjdCwKKwkuY2xlYW51cAk9IGF0a2JkX2NsZWFudXAsCit9OworCitzdGF0aWMgc3NpemVfdCBhdGtiZF9hdHRyX3Nob3dfaGVscGVyKHN0cnVjdCBkZXZpY2UgKmRldiwgY2hhciAqYnVmLAorCQkJCXNzaXplX3QgKCpoYW5kbGVyKShzdHJ1Y3QgYXRrYmQgKiwgY2hhciAqKSkKK3sKKwlzdHJ1Y3Qgc2VyaW8gKnNlcmlvID0gdG9fc2VyaW9fcG9ydChkZXYpOworCWludCByZXR2YWw7CisKKwlyZXR2YWwgPSBzZXJpb19waW5fZHJpdmVyKHNlcmlvKTsKKwlpZiAocmV0dmFsKQorCQlyZXR1cm4gcmV0dmFsOworCisJaWYgKHNlcmlvLT5kcnYgIT0gJmF0a2JkX2RydikgeworCQlyZXR2YWwgPSAtRU5PREVWOworCQlnb3RvIG91dDsKKwl9CisKKwlyZXR2YWwgPSBoYW5kbGVyKChzdHJ1Y3QgYXRrYmQgKilzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyksIGJ1Zik7CisKK291dDoKKwlzZXJpb191bnBpbl9kcml2ZXIoc2VyaW8pOworCXJldHVybiByZXR2YWw7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGF0a2JkX2F0dHJfc2V0X2hlbHBlcihzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50LAorCQkJCXNzaXplX3QgKCpoYW5kbGVyKShzdHJ1Y3QgYXRrYmQgKiwgY29uc3QgY2hhciAqLCBzaXplX3QpKQoreworCXN0cnVjdCBzZXJpbyAqc2VyaW8gPSB0b19zZXJpb19wb3J0KGRldik7CisJc3RydWN0IGF0a2JkICphdGtiZDsKKwlpbnQgcmV0dmFsOworCisJcmV0dmFsID0gc2VyaW9fcGluX2RyaXZlcihzZXJpbyk7CisJaWYgKHJldHZhbCkKKwkJcmV0dXJuIHJldHZhbDsKKworCWlmIChzZXJpby0+ZHJ2ICE9ICZhdGtiZF9kcnYpIHsKKwkJcmV0dmFsID0gLUVOT0RFVjsKKwkJZ290byBvdXQ7CisJfQorCisJYXRrYmQgPSBzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyk7CisJYXRrYmRfZGlzYWJsZShhdGtiZCk7CisJcmV0dmFsID0gaGFuZGxlcihhdGtiZCwgYnVmLCBjb3VudCk7CisJYXRrYmRfZW5hYmxlKGF0a2JkKTsKKworb3V0OgorCXNlcmlvX3VucGluX2RyaXZlcihzZXJpbyk7CisJcmV0dXJuIHJldHZhbDsKK30KKworc3RhdGljIHNzaXplX3QgYXRrYmRfc2hvd19leHRyYShzdHJ1Y3QgYXRrYmQgKmF0a2JkLCBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGF0a2JkLT5leHRyYSA/IDEgOiAwKTsKK30KKworc3RhdGljIHNzaXplX3QgYXRrYmRfc2V0X2V4dHJhKHN0cnVjdCBhdGtiZCAqYXRrYmQsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXVuc2lnbmVkIGxvbmcgdmFsdWU7CisJY2hhciAqcmVzdDsKKworCWlmICghYXRrYmQtPndyaXRlKQorCQlyZXR1cm4gLUVJTzsKKworCXZhbHVlID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAmcmVzdCwgMTApOworCWlmICgqcmVzdCB8fCB2YWx1ZSA+IDEpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGF0a2JkLT5leHRyYSAhPSB2YWx1ZSkgeworCQkvKiB1bnJlZ2lzdGVyIGRldmljZSBhcyBpdCdzIHByb3BlcnRpZXMgd2lsbCBjaGFuZ2UgKi8KKwkJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2UoJmF0a2JkLT5kZXYpOworCQlhdGtiZC0+c2V0ID0gYXRrYmRfc2VsZWN0X3NldChhdGtiZCwgYXRrYmQtPnNldCwgdmFsdWUpOworCQlhdGtiZF9hY3RpdmF0ZShhdGtiZCk7CisJCWF0a2JkX3NldF9kZXZpY2VfYXR0cnMoYXRrYmQpOworCQlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJmF0a2JkLT5kZXYpOworCX0KKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGF0a2JkX3Nob3dfc2Nyb2xsKHN0cnVjdCBhdGtiZCAqYXRrYmQsIGNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgYXRrYmQtPnNjcm9sbCA/IDEgOiAwKTsKK30KKworc3RhdGljIHNzaXplX3QgYXRrYmRfc2V0X3Njcm9sbChzdHJ1Y3QgYXRrYmQgKmF0a2JkLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwl1bnNpZ25lZCBsb25nIHZhbHVlOworCWNoYXIgKnJlc3Q7CisKKwl2YWx1ZSA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgJnJlc3QsIDEwKTsKKwlpZiAoKnJlc3QgfHwgdmFsdWUgPiAxKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChhdGtiZC0+c2Nyb2xsICE9IHZhbHVlKSB7CisJCS8qIHVucmVnaXN0ZXIgZGV2aWNlIGFzIGl0J3MgcHJvcGVydGllcyB3aWxsIGNoYW5nZSAqLworCQlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgmYXRrYmQtPmRldik7CisJCWF0a2JkLT5zY3JvbGwgPSB2YWx1ZTsKKwkJYXRrYmRfc2V0X2tleWNvZGVfdGFibGUoYXRrYmQpOworCQlhdGtiZF9zZXRfZGV2aWNlX2F0dHJzKGF0a2JkKTsKKwkJaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKCZhdGtiZC0+ZGV2KTsKKwl9CisJcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgc3NpemVfdCBhdGtiZF9zaG93X3NldChzdHJ1Y3QgYXRrYmQgKmF0a2JkLCBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGF0a2JkLT5zZXQpOworfQorCitzdGF0aWMgc3NpemVfdCBhdGtiZF9zZXRfc2V0KHN0cnVjdCBhdGtiZCAqYXRrYmQsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXVuc2lnbmVkIGxvbmcgdmFsdWU7CisJY2hhciAqcmVzdDsKKworCWlmICghYXRrYmQtPndyaXRlKQorCQlyZXR1cm4gLUVJTzsKKworCXZhbHVlID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAmcmVzdCwgMTApOworCWlmICgqcmVzdCB8fCAodmFsdWUgIT0gMiAmJiB2YWx1ZSAhPSAzKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoYXRrYmQtPnNldCAhPSB2YWx1ZSkgeworCQkvKiB1bnJlZ2lzdGVyIGRldmljZSBhcyBpdCdzIHByb3BlcnRpZXMgd2lsbCBjaGFuZ2UgKi8KKwkJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2UoJmF0a2JkLT5kZXYpOworCQlhdGtiZC0+c2V0ID0gYXRrYmRfc2VsZWN0X3NldChhdGtiZCwgdmFsdWUsIGF0a2JkLT5leHRyYSk7CisJCWF0a2JkX2FjdGl2YXRlKGF0a2JkKTsKKwkJYXRrYmRfc2V0X2tleWNvZGVfdGFibGUoYXRrYmQpOworCQlhdGtiZF9zZXRfZGV2aWNlX2F0dHJzKGF0a2JkKTsKKwkJaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKCZhdGtiZC0+ZGV2KTsKKwl9CisJcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgc3NpemVfdCBhdGtiZF9zaG93X3NvZnRyZXBlYXQoc3RydWN0IGF0a2JkICphdGtiZCwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBhdGtiZC0+c29mdHJlcGVhdCA/IDEgOiAwKTsKK30KKworc3RhdGljIHNzaXplX3QgYXRrYmRfc2V0X3NvZnRyZXBlYXQoc3RydWN0IGF0a2JkICphdGtiZCwgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyB2YWx1ZTsKKwljaGFyICpyZXN0OworCisJaWYgKCFhdGtiZC0+d3JpdGUpCisJCXJldHVybiAtRUlPOworCisJdmFsdWUgPSBzaW1wbGVfc3RydG91bChidWYsICZyZXN0LCAxMCk7CisJaWYgKCpyZXN0IHx8IHZhbHVlID4gMSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoYXRrYmQtPnNvZnRyZXBlYXQgIT0gdmFsdWUpIHsKKwkJLyogdW5yZWdpc3RlciBkZXZpY2UgYXMgaXQncyBwcm9wZXJ0aWVzIHdpbGwgY2hhbmdlICovCisJCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKCZhdGtiZC0+ZGV2KTsKKwkJYXRrYmQtPnNvZnRyZXBlYXQgPSB2YWx1ZTsKKwkJaWYgKGF0a2JkLT5zb2Z0cmVwZWF0KQorCQkJYXRrYmQtPnNvZnRyYXcgPSAxOworCQlhdGtiZF9zZXRfZGV2aWNlX2F0dHJzKGF0a2JkKTsKKwkJaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKCZhdGtiZC0+ZGV2KTsKKwl9CisKKwlyZXR1cm4gY291bnQ7Cit9CisKKworc3RhdGljIHNzaXplX3QgYXRrYmRfc2hvd19zb2Z0cmF3KHN0cnVjdCBhdGtiZCAqYXRrYmQsIGNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgYXRrYmQtPnNvZnRyYXcgPyAxIDogMCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGF0a2JkX3NldF9zb2Z0cmF3KHN0cnVjdCBhdGtiZCAqYXRrYmQsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXVuc2lnbmVkIGxvbmcgdmFsdWU7CisJY2hhciAqcmVzdDsKKworCXZhbHVlID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAmcmVzdCwgMTApOworCWlmICgqcmVzdCB8fCB2YWx1ZSA+IDEpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGF0a2JkLT5zb2Z0cmF3ICE9IHZhbHVlKSB7CisJCS8qIHVucmVnaXN0ZXIgZGV2aWNlIGFzIGl0J3MgcHJvcGVydGllcyB3aWxsIGNoYW5nZSAqLworCQlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgmYXRrYmQtPmRldik7CisJCWF0a2JkLT5zb2Z0cmF3ID0gdmFsdWU7CisJCWF0a2JkX3NldF9kZXZpY2VfYXR0cnMoYXRrYmQpOworCQlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJmF0a2JkLT5kZXYpOworCX0KKwlyZXR1cm4gY291bnQ7Cit9CisKKworc3RhdGljIGludCBfX2luaXQgYXRrYmRfaW5pdCh2b2lkKQoreworCXNlcmlvX3JlZ2lzdGVyX2RyaXZlcigmYXRrYmRfZHJ2KTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGF0a2JkX2V4aXQodm9pZCkKK3sKKwlzZXJpb191bnJlZ2lzdGVyX2RyaXZlcigmYXRrYmRfZHJ2KTsKK30KKworbW9kdWxlX2luaXQoYXRrYmRfaW5pdCk7Cittb2R1bGVfZXhpdChhdGtiZF9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvY29yZ2lrYmQuYyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvY29yZ2lrYmQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wZjEyMjBhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9jb3JnaWtiZC5jCkBAIC0wLDAgKzEsMzYxIEBACisvKgorICogIEtleWJvYXJkIGRyaXZlciBmb3IgU2hhcnAgQ29yZ2kgbW9kZWxzIChTTC1DN3h4KQorICoKKyAqICBDb3B5cmlnaHQgKGMpIDIwMDQtMjAwNSBSaWNoYXJkIFB1cmRpZQorICoKKyAqICBCYXNlZCBvbiB4dGtiZC5jL2xvY29ta2JkLmMKKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8YXNtL2lycS5oPgorCisjaW5jbHVkZSA8YXNtL2FyY2gvY29yZ2kuaD4KKyNpbmNsdWRlIDxhc20vYXJjaC9oYXJkd2FyZS5oPgorI2luY2x1ZGUgPGFzbS9hcmNoL3B4YS1yZWdzLmg+CisjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL3Njb29wLmg+CisKKyNkZWZpbmUgS0JfUk9XUwkJCQk4CisjZGVmaW5lIEtCX0NPTFMJCQkJMTIKKyNkZWZpbmUgS0JfUk9XTUFTSyhyKQkJKDEgPDwgKHIpKQorI2RlZmluZSBTQ0FOQ09ERShyLGMpCQkoICgocik8PDQpICsgKGMpICsgMSApCisvKiB6ZXJvIGNvZGUsIDEyNCBzY2FuY29kZXMgKyAzIGhpbmdlIGNvbWJpbmF0aW9ucyAqLworI2RlZmluZQlOUl9TQ0FOQ09ERVMJCSggU0NBTkNPREUoS0JfUk9XUy0xLEtCX0NPTFMtMSkgKzEgKzEgKzMgKQorI2RlZmluZSBTQ0FOX0lOVEVSVkFMCQkoSFovMTApCisjZGVmaW5lIENPUkdJS0JEX1BSRVNTRUQJMQorCisjZGVmaW5lIEhJTkdFX1NDQU5fSU5URVJWQUwJCShIWi80KQorCisjZGVmaW5lIENPUkdJX0tFWV9DQUxFTkRFUglLRVlfRjEKKyNkZWZpbmUgQ09SR0lfS0VZX0FERFJFU1MJS0VZX0YyCisjZGVmaW5lIENPUkdJX0tFWV9GTgkJS0VZX0YzCisjZGVmaW5lIENPUkdJX0tFWV9PRkYJCUtFWV9TVVNQRU5ECisjZGVmaW5lIENPUkdJX0tFWV9FWE9LCQlLRVlfRjUKKyNkZWZpbmUgQ09SR0lfS0VZX0VYQ0FOQ0VMCUtFWV9GNgorI2RlZmluZSBDT1JHSV9LRVlfRVhKT0dET1dOCUtFWV9GNworI2RlZmluZSBDT1JHSV9LRVlfRVhKT0dVUAlLRVlfRjgKKyNkZWZpbmUgQ09SR0lfS0VZX0pBUDEJCUtFWV9MRUZUQ1RSTAorI2RlZmluZSBDT1JHSV9LRVlfSkFQMgkJS0VZX0xFRlRBTFQKKyNkZWZpbmUgQ09SR0lfS0VZX09LCQlLRVlfRjExCisjZGVmaW5lIENPUkdJX0tFWV9NRU5VCQlLRVlfRjEyCisjZGVmaW5lIENPUkdJX0hJTkdFXzAJCUtFWV9LUDAKKyNkZWZpbmUgQ09SR0lfSElOR0VfMQkJS0VZX0tQMQorI2RlZmluZSBDT1JHSV9ISU5HRV8yCQlLRVlfS1AyCisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGNvcmdpa2JkX2tleWNvZGVbTlJfU0NBTkNPREVTXSA9IHsKKwkwLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiAwICovCisJMCwgS0VZXzEsIEtFWV8zLCBLRVlfNSwgS0VZXzYsIEtFWV83LCBLRVlfOSwgS0VZXzAsIEtFWV9CQUNLU1BBQ0UsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIAkgICAgICAgICAgICAgICAgICAgICAgLyogMS0xNiAqLworCTAsIEtFWV8yLCBLRVlfNCwgS0VZX1IsIEtFWV9ZLCBLRVlfOCwgS0VZX0ksIEtFWV9PLCBLRVlfUCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIDE3LTMyICovCisJS0VZX1RBQiwgS0VZX1EsIEtFWV9FLCBLRVlfVCwgS0VZX0csIEtFWV9VLCBLRVlfSiwgS0VZX0ssIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogMzMtNDggKi8KKwlDT1JHSV9LRVlfQ0FMRU5ERVIsIEtFWV9XLCBLRVlfUywgS0VZX0YsIEtFWV9WLCBLRVlfSCwgS0VZX00sIEtFWV9MLCAwLCBLRVlfUklHSFRTSElGVCwgMCwgMCwgMCwgMCwgMCwgMCwgICAgICAgICAvKiA0OS02NCAqLworCUNPUkdJX0tFWV9BRERSRVNTLCBLRVlfQSwgS0VZX0QsIEtFWV9DLCBLRVlfQiwgS0VZX04sIEtFWV9ET1QsIDAsIEtFWV9FTlRFUiwgMCwgS0VZX0xFRlRTSElGVCwgMCwgMCwgMCwgMCwgMCwgCSAgLyogNjUtODAgKi8KKwlLRVlfTUFJTCwgS0VZX1osIEtFWV9YLCBLRVlfTUlOVVMsIEtFWV9TUEFDRSwgS0VZX0NPTU1BLCAwLCBLRVlfVVAsIDAsIDAsIDAsIENPUkdJX0tFWV9GTiwgMCwgMCwgMCwgMCwgICAgICAgICAgICAvKiA4MS05NiAqLworCUtFWV9TWVNSUSwgQ09SR0lfS0VZX0pBUDEsIENPUkdJX0tFWV9KQVAyLCBLRVlfQ0FOQ0VMLCBDT1JHSV9LRVlfT0ssIENPUkdJX0tFWV9NRU5VLCBLRVlfTEVGVCwgS0VZX0RPV04sIEtFWV9SSUdIVCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgIC8qIDk3LTExMiAqLworCUNPUkdJX0tFWV9PRkYsIENPUkdJX0tFWV9FWE9LLCBDT1JHSV9LRVlfRVhDQU5DRUwsIENPUkdJX0tFWV9FWEpPR0RPV04sIENPUkdJX0tFWV9FWEpPR1VQLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAgIC8qIDExMy0xMjQgKi8KKwlDT1JHSV9ISU5HRV8wLCBDT1JHSV9ISU5HRV8xLCBDT1JHSV9ISU5HRV8yCSAgLyogMTI1LTEyNyAqLworfTsKKworCitzdHJ1Y3QgY29yZ2lrYmQgeworCXVuc2lnbmVkIGNoYXIga2V5Y29kZVtBUlJBWV9TSVpFKGNvcmdpa2JkX2tleWNvZGUpXTsKKwlzdHJ1Y3QgaW5wdXRfZGV2IGlucHV0OworCWNoYXIgcGh5c1szMl07CisKKwl1bnNpZ25lZCBjaGFyIHN0YXRlW0FSUkFZX1NJWkUoY29yZ2lrYmRfa2V5Y29kZSldOworCXNwaW5sb2NrX3QgbG9jazsKKworCXN0cnVjdCB0aW1lcl9saXN0IHRpbWVyOworCXN0cnVjdCB0aW1lcl9saXN0IGh0aW1lcjsKK307CisKK3N0YXRpYyB2b2lkIGhhbmRsZV9zY2FuY29kZSh1bnNpZ25lZCBpbnQgcHJlc3NlZCx1bnNpZ25lZCBpbnQgc2NhbmNvZGUsIHN0cnVjdCBjb3JnaWtiZCAqY29yZ2lrYmRfZGF0YSkKK3sKKwlpZiAocHJlc3NlZCAmJiAhKGNvcmdpa2JkX2RhdGEtPnN0YXRlW3NjYW5jb2RlXSAmIENPUkdJS0JEX1BSRVNTRUQpKSB7CisJCWNvcmdpa2JkX2RhdGEtPnN0YXRlW3NjYW5jb2RlXSB8PSBDT1JHSUtCRF9QUkVTU0VEOworCQlpbnB1dF9yZXBvcnRfa2V5KCZjb3JnaWtiZF9kYXRhLT5pbnB1dCwgY29yZ2lrYmRfZGF0YS0+a2V5Y29kZVtzY2FuY29kZV0sIDEpOworCQlpZiAoY29yZ2lrYmRfZGF0YS0+a2V5Y29kZVtzY2FuY29kZV0gPT0gQ09SR0lfS0VZX09GRikKKwkJCWlucHV0X2V2ZW50KCZjb3JnaWtiZF9kYXRhLT5pbnB1dCwgRVZfUFdSLCBDT1JHSV9LRVlfT0ZGLCAxKTsKKwl9IGVsc2UgaWYgKCFwcmVzc2VkICYmIGNvcmdpa2JkX2RhdGEtPnN0YXRlW3NjYW5jb2RlXSAmIENPUkdJS0JEX1BSRVNTRUQpIHsKKwkJY29yZ2lrYmRfZGF0YS0+c3RhdGVbc2NhbmNvZGVdICY9IH5DT1JHSUtCRF9QUkVTU0VEOworCQlpbnB1dF9yZXBvcnRfa2V5KCZjb3JnaWtiZF9kYXRhLT5pbnB1dCwgY29yZ2lrYmRfZGF0YS0+a2V5Y29kZVtzY2FuY29kZV0sIDApOworCX0KK30KKworI2RlZmluZSBLQl9ESVNDSEFSR0VfREVMQVkJMTAKKyNkZWZpbmUgS0JfQUNUSVZBVEVfREVMQVkJMTAKKworLyogSGVscGVyIGZ1bmN0aW9ucyBmb3IgcmVhZGluZyB0aGUga2V5Ym9hcmQgbWF0cml4CisgKiBOb3RlOiBXZSBzaG91bGQgcmVhbGx5IGJlIHVzaW5nIHB4YV9ncGlvX21vZGUgdG8gYWx0ZXIgR1BEUiBidXQgaXQKKyAqICAgICAgIHJlcXVpcmVzIGEgZnVuY3Rpb24gY2FsbCBwZXIgR1BJTyBiaXQgd2hpY2ggaXMgZXhjZXNzaXZlCisgKiAgICAgICB3aGVuIHdlIG5lZWQgdG8gYWNjZXNzIDEyIGJpdHMgYXQgb25jZSBtdWx0aXBsZSB0aW1lcy4KKyAqIFRoZXNlIGZ1bmN0aW9ucyBtdXN0IGJlIGNhbGxlZCB3aXRoaW4gbG9jYWxfaXJxX3NhdmUoKS9sb2NhbF9pcnFfcmVzdG9yZSgpCisgKiBvciBzaW1pbGFyLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgY29yZ2lrYmRfZGlzY2hhcmdlX2FsbCh2b2lkKQoreworCS8vIFNUUk9CRSBBbGwgSGlaCisJR1BDUjIgID0gQ09SR0lfR1BJT19BTExfU1RST0JFX0JJVDsKKwlHUERSMiAmPSB+Q09SR0lfR1BJT19BTExfU1RST0JFX0JJVDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNvcmdpa2JkX2FjdGl2YXRlX2FsbCh2b2lkKQoreworCS8vIFNUUk9CRSBBTEwgLT4gSGlnaAorCUdQU1IyICA9IENPUkdJX0dQSU9fQUxMX1NUUk9CRV9CSVQ7CisJR1BEUjIgfD0gQ09SR0lfR1BJT19BTExfU1RST0JFX0JJVDsKKworCXVkZWxheShLQl9ESVNDSEFSR0VfREVMQVkpOworCisJLy8gQ2xlYXIgYW55IGludGVycnVwdHMgd2UgbWF5IGhhdmUgdHJpZ2dlcmVkIHdoZW4gYWx0ZXJpbmcgdGhlIEdQSU8gbGluZXMKKwlHRURSMSA9IENPUkdJX0dQSU9fSElHSF9TRU5TRV9CSVQ7CisJR0VEUjIgPSBDT1JHSV9HUElPX0xPV19TRU5TRV9CSVQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBjb3JnaWtiZF9hY3RpdmF0ZV9jb2woaW50IGNvbCkKK3sKKwkvLyBTVFJPQkUgY29sIC0+IEhpZ2gsIG5vdCBjb2wgLT4gSGlaCisJR1BTUjIgPSBDT1JHSV9HUElPX1NUUk9CRV9CSVQoY29sKTsKKwlHUERSMiA9IChHUERSMiAmIH5DT1JHSV9HUElPX0FMTF9TVFJPQkVfQklUKSB8IENPUkdJX0dQSU9fU1RST0JFX0JJVChjb2wpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgY29yZ2lrYmRfcmVzZXRfY29sKGludCBjb2wpCit7CisJLy8gU1RST0JFIGNvbCAtPiBMb3cKKwlHUENSMiA9IENPUkdJX0dQSU9fU1RST0JFX0JJVChjb2wpOworCS8vIFNUUk9CRSBjb2wgLT4gb3V0LCBub3QgY29sIC0+IEhpWgorCUdQRFIyID0gKEdQRFIyICYgfkNPUkdJX0dQSU9fQUxMX1NUUk9CRV9CSVQpIHwgQ09SR0lfR1BJT19TVFJPQkVfQklUKGNvbCk7Cit9CisKKyNkZWZpbmUgR0VUX1JPV1NfU1RBVFVTKGMpCSgoKEdQTFIxICYgQ09SR0lfR1BJT19ISUdIX1NFTlNFX0JJVCkgPj4gQ09SR0lfR1BJT19ISUdIX1NFTlNFX1JTSElGVCkgfCAoKEdQTFIyICYgQ09SR0lfR1BJT19MT1dfU0VOU0VfQklUKSA8PCBDT1JHSV9HUElPX0xPV19TRU5TRV9MU0hJRlQpKQorCisvKgorICogVGhlIGNvcmdpIGtleWJvYXJkIG9ubHkgZ2VuZXJhdGVzIGludGVycnVwdHMgd2hlbiBhIGtleSBpcyBwcmVzc2VkLgorICogV2hlbiBhIGtleSBpcyBwcmVzc2VkLCB3ZSBlbmFibGUgYSB0aW1lciB3aGljaCB0aGVuIHNjYW5zIHRoZQorICoga2V5Ym9hcmQgdG8gZGV0ZWN0IHdoZW4gdGhlIGtleSBpcyByZWxlYXNlZC4KKyAqLworCisvKiBTY2FuIHRoZSBoYXJkd2FyZSBrZXlib2FyZCBhbmQgcHVzaCBhbnkgY2hhbmdlcyB1cCB0aHJvdWdoIHRoZSBpbnB1dCBsYXllciAqLworc3RhdGljIHZvaWQgY29yZ2lrYmRfc2NhbmtleWJvYXJkKHN0cnVjdCBjb3JnaWtiZCAqY29yZ2lrYmRfZGF0YSwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJdW5zaWduZWQgaW50IHJvdywgY29sLCByb3dkLCBzY2FuY29kZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIGludCBudW1fcHJlc3NlZDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZjb3JnaWtiZF9kYXRhLT5sb2NrLCBmbGFncyk7CisKKwlpZiAocmVncykKKwkJaW5wdXRfcmVncygmY29yZ2lrYmRfZGF0YS0+aW5wdXQsIHJlZ3MpOworCisJbnVtX3ByZXNzZWQgPSAwOworCWZvciAoY29sID0gMDsgY29sIDwgS0JfQ09MUzsgY29sKyspIHsKKwkJLyoKKwkJICogRGlzY2hhcmdlIHRoZSBvdXRwdXQgZHJpdmVyIGNhcGFjaXRhdGFuY2UKKwkJICogaW4gdGhlIGtleWJvYXJkIG1hdHJpeC4gKFllcyBpdCBpcyBzaWduaWZpY2FudC4uKQorCQkgKi8KKworCQljb3JnaWtiZF9kaXNjaGFyZ2VfYWxsKCk7CisJCXVkZWxheShLQl9ESVNDSEFSR0VfREVMQVkpOworCisJCWNvcmdpa2JkX2FjdGl2YXRlX2NvbChjb2wpOworCQl1ZGVsYXkoS0JfQUNUSVZBVEVfREVMQVkpOworCisJCXJvd2QgPSBHRVRfUk9XU19TVEFUVVMoY29sKTsKKwkJZm9yIChyb3cgPSAwOyByb3cgPCBLQl9ST1dTOyByb3crKykgeworCQkJc2NhbmNvZGUgPSBTQ0FOQ09ERShyb3csIGNvbCk7CisJCQloYW5kbGVfc2NhbmNvZGUoKHJvd2QgJiBLQl9ST1dNQVNLKHJvdykpLCBzY2FuY29kZSwgY29yZ2lrYmRfZGF0YSk7CisJCQlpZiAocm93ZCAmIEtCX1JPV01BU0socm93KSkKKwkJCQludW1fcHJlc3NlZCsrOworCQl9CisJCWNvcmdpa2JkX3Jlc2V0X2NvbChjb2wpOworCX0KKworCWNvcmdpa2JkX2FjdGl2YXRlX2FsbCgpOworCisJaW5wdXRfc3luYygmY29yZ2lrYmRfZGF0YS0+aW5wdXQpOworCisJLyogaWYgYW55IGtleXMgYXJlIHByZXNzZWQsIGVuYWJsZSB0aGUgdGltZXIgKi8KKwlpZiAobnVtX3ByZXNzZWQpCisJCW1vZF90aW1lcigmY29yZ2lrYmRfZGF0YS0+dGltZXIsIGppZmZpZXMgKyBTQ0FOX0lOVEVSVkFMKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNvcmdpa2JkX2RhdGEtPmxvY2ssIGZsYWdzKTsKK30KKworLyoKKyAqIGNvcmdpIGtleWJvYXJkIGludGVycnVwdCBoYW5kbGVyLgorICovCitzdGF0aWMgaXJxcmV0dXJuX3QgY29yZ2lrYmRfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IGNvcmdpa2JkICpjb3JnaWtiZF9kYXRhID0gZGV2X2lkOworCisJaWYgKCF0aW1lcl9wZW5kaW5nKCZjb3JnaWtiZF9kYXRhLT50aW1lcikpIHsKKwkJLyoqIHdhaXQgY2hhdHRlcmluZyBkZWxheSAqKi8KKwkJdWRlbGF5KDIwKTsKKwkJY29yZ2lrYmRfc2NhbmtleWJvYXJkKGNvcmdpa2JkX2RhdGEsIHJlZ3MpOworCX0KKworCXJldHVybiBJUlFfSEFORExFRDsKK30KKworLyoKKyAqIGNvcmdpIHRpbWVyIGNoZWNraW5nIGZvciByZWxlYXNlZCBrZXlzCisgKi8KK3N0YXRpYyB2b2lkIGNvcmdpa2JkX3RpbWVyX2NhbGxiYWNrKHVuc2lnbmVkIGxvbmcgZGF0YSkKK3sKKwlzdHJ1Y3QgY29yZ2lrYmQgKmNvcmdpa2JkX2RhdGEgPSAoc3RydWN0IGNvcmdpa2JkICopIGRhdGE7CisJY29yZ2lrYmRfc2NhbmtleWJvYXJkKGNvcmdpa2JkX2RhdGEsIE5VTEwpOworfQorCisvKgorICogVGhlIGhpbmdlIHN3aXRjaGVzIGdlbmVyYXRlIG5vIGludGVycnVwdCBzbyB0aGV5IG5lZWQgdG8gYmUKKyAqIG1vbml0b3JlZCBieSBhIHRpbWVyLgorICoKKyAqIFdoZW4gd2UgZGV0ZWN0IGNoYW5nZXMsIHdlIGRlYm91bmNlIGl0IGFuZCB0aGVuIHBhc3MgdGhlIHRocmVlCisgKiBwb3NpdGlvbnMgdGhlIHN5c3RlbSBjYW4gdGFrZSBhcyBrZXlwcmVzc2VzIHRvIHRoZSBpbnB1dCBzeXN0ZW0uCisgKi8KKworI2RlZmluZSBISU5HRV9TVEFCTEVfQ09VTlQgMgorc3RhdGljIGludCBzaGFycHNsX2hpbmdlX3N0YXRlOworc3RhdGljIGludCBoaW5nZV9jb3VudDsKKworc3RhdGljIHZvaWQgY29yZ2lrYmRfaGluZ2VfdGltZXIodW5zaWduZWQgbG9uZyBkYXRhKQoreworCXN0cnVjdCBjb3JnaWtiZCAqY29yZ2lrYmRfZGF0YSA9IChzdHJ1Y3QgY29yZ2lrYmQgKikgZGF0YTsKKwl1bnNpZ25lZCBsb25nIGdwcnI7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWdwcnIgPSByZWFkX3Njb29wX3JlZyhTQ09PUF9HUFJSKSAmIChDT1JHSV9TQ1BfU1dBIHwgQ09SR0lfU0NQX1NXQik7CisJaWYgKGdwcnIgIT0gc2hhcnBzbF9oaW5nZV9zdGF0ZSkgeworCQloaW5nZV9jb3VudCA9IDA7CisJCXNoYXJwc2xfaGluZ2Vfc3RhdGUgPSBncHJyOworCX0gZWxzZSBpZiAoaGluZ2VfY291bnQgPCBISU5HRV9TVEFCTEVfQ09VTlQpIHsKKwkJaGluZ2VfY291bnQrKzsKKwkJaWYgKGhpbmdlX2NvdW50ID49IEhJTkdFX1NUQUJMRV9DT1VOVCkgeworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmNvcmdpa2JkX2RhdGEtPmxvY2ssIGZsYWdzKTsKKworCQkJaGFuZGxlX3NjYW5jb2RlKChzaGFycHNsX2hpbmdlX3N0YXRlID09IDB4MDApLCAxMjUsIGNvcmdpa2JkX2RhdGEpOyAvKiBLZXlib2FyZCB3aXRoIExhbmRzY2FwZSBTY3JlZW4gKi8KKwkJCWhhbmRsZV9zY2FuY29kZSgoc2hhcnBzbF9oaW5nZV9zdGF0ZSA9PSAweDA4KSwgMTI2LCBjb3JnaWtiZF9kYXRhKTsgLyogTm8gS2V5Ym9hcmQgd2l0aCBQb3J0cmFpdCBTY3JlZW4gKi8KKwkJCWhhbmRsZV9zY2FuY29kZSgoc2hhcnBzbF9oaW5nZV9zdGF0ZSA9PSAweDBjKSwgMTI3LCBjb3JnaWtiZF9kYXRhKTsgLyogS2V5Ym9hcmQgYW5kIFNjcmVlbiBDbG9zZWQgICovCisJCQlpbnB1dF9zeW5jKCZjb3JnaWtiZF9kYXRhLT5pbnB1dCk7CisKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNvcmdpa2JkX2RhdGEtPmxvY2ssIGZsYWdzKTsKKwkJfQorCX0KKwltb2RfdGltZXIoJmNvcmdpa2JkX2RhdGEtPmh0aW1lciwgamlmZmllcyArIEhJTkdFX1NDQU5fSU5URVJWQUwpOworfQorCitzdGF0aWMgaW50IF9faW5pdCBjb3JnaWtiZF9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJaW50IGk7CisJc3RydWN0IGNvcmdpa2JkICpjb3JnaWtiZDsKKworCWNvcmdpa2JkID0ga2NhbGxvYygxLCBzaXplb2Yoc3RydWN0IGNvcmdpa2JkKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjb3JnaWtiZCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlkZXZfc2V0X2RydmRhdGEoZGV2LGNvcmdpa2JkKTsKKwlzdHJjcHkoY29yZ2lrYmQtPnBoeXMsICJjb3JnaWtiZC9pbnB1dDAiKTsKKworCXNwaW5fbG9ja19pbml0KGNvcmdpa2JkLT5sb2NrKTsKKworCS8qIEluaXQgS2V5Ym9hcmQgcmVzY2FuIHRpbWVyICovCisJaW5pdF90aW1lcigmY29yZ2lrYmQtPnRpbWVyKTsKKwljb3JnaWtiZC0+dGltZXIuZnVuY3Rpb24gPSBjb3JnaWtiZF90aW1lcl9jYWxsYmFjazsKKwljb3JnaWtiZC0+dGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBjb3JnaWtiZDsKKworCS8qIEluaXQgSGluZ2UgVGltZXIgKi8KKwlpbml0X3RpbWVyKCZjb3JnaWtiZC0+aHRpbWVyKTsKKwljb3JnaWtiZC0+aHRpbWVyLmZ1bmN0aW9uID0gY29yZ2lrYmRfaGluZ2VfdGltZXI7CisJY29yZ2lrYmQtPmh0aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIGNvcmdpa2JkOworCisJaW5pdF9pbnB1dF9kZXYoJmNvcmdpa2JkLT5pbnB1dCk7CisJY29yZ2lrYmQtPmlucHV0LnByaXZhdGUgPSBjb3JnaWtiZDsKKwljb3JnaWtiZC0+aW5wdXQubmFtZSA9ICJDb3JnaSBLZXlib2FyZCI7CisJY29yZ2lrYmQtPmlucHV0LmRldiA9IGRldjsKKwljb3JnaWtiZC0+aW5wdXQucGh5cyA9IGNvcmdpa2JkLT5waHlzOworCWNvcmdpa2JkLT5pbnB1dC5pZC5idXN0eXBlID0gQlVTX0hPU1Q7CisJY29yZ2lrYmQtPmlucHV0LmlkLnZlbmRvciA9IDB4MDAwMTsKKwljb3JnaWtiZC0+aW5wdXQuaWQucHJvZHVjdCA9IDB4MDAwMTsKKwljb3JnaWtiZC0+aW5wdXQuaWQudmVyc2lvbiA9IDB4MDEwMDsKKwljb3JnaWtiZC0+aW5wdXQuZXZiaXRbMF0gPSBCSVQoRVZfS0VZKSB8IEJJVChFVl9SRVApIHwgQklUKEVWX1BXUik7CisJY29yZ2lrYmQtPmlucHV0LmtleWNvZGUgPSBjb3JnaWtiZC0+a2V5Y29kZTsKKwljb3JnaWtiZC0+aW5wdXQua2V5Y29kZXNpemUgPSBzaXplb2YodW5zaWduZWQgY2hhcik7CisJY29yZ2lrYmQtPmlucHV0LmtleWNvZGVtYXggPSBBUlJBWV9TSVpFKGNvcmdpa2JkX2tleWNvZGUpOworCisJbWVtY3B5KGNvcmdpa2JkLT5rZXljb2RlLCBjb3JnaWtiZF9rZXljb2RlLCBzaXplb2YoY29yZ2lrYmQtPmtleWNvZGUpKTsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjb3JnaWtiZF9rZXljb2RlKTsgaSsrKQorCQlzZXRfYml0KGNvcmdpa2JkLT5rZXljb2RlW2ldLCBjb3JnaWtiZC0+aW5wdXQua2V5Yml0KTsKKwljbGVhcl9iaXQoMCwgY29yZ2lrYmQtPmlucHV0LmtleWJpdCk7CisKKwlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJmNvcmdpa2JkLT5pbnB1dCk7CisJbW9kX3RpbWVyKCZjb3JnaWtiZC0+aHRpbWVyLCBqaWZmaWVzICsgSElOR0VfU0NBTl9JTlRFUlZBTCk7CisKKwkvKiBTZXR1cCBzZW5zZSBpbnRlcnJ1cHRzIC0gUmlzaW5nRWRnZSBEZXRlY3QsIHNlbnNlIGxpbmVzIGFzIGlucHV0cyAqLworCWZvciAoaSA9IDA7IGkgPCBDT1JHSV9LRVlfU0VOU0VfTlVNOyBpKyspIHsKKwkJcHhhX2dwaW9fbW9kZShDT1JHSV9HUElPX0tFWV9TRU5TRShpKSB8IEdQSU9fSU4pOworCQlpZiAocmVxdWVzdF9pcnEoQ09SR0lfSVJRX0dQSU9fS0VZX1NFTlNFKGkpLCBjb3JnaWtiZF9pbnRlcnJ1cHQsCisJCQkJCQlTQV9JTlRFUlJVUFQsICJjb3JnaWtiZCIsIGNvcmdpa2JkKSkKKwkJCXByaW50ayhLRVJOX1dBUk5JTkcgImNvcmdpa2JkOiBDYW4ndCBnZXQgSVJROiAlZCFcbiIsIGkpOworCQllbHNlCisJCQlzZXRfaXJxX3R5cGUoQ09SR0lfSVJRX0dQSU9fS0VZX1NFTlNFKGkpLElSUVRfUklTSU5HKTsKKwl9CisKKwkvKiBTZXQgU3Ryb2JlIGxpbmVzIGFzIG91dHB1dHMgLSBzZXQgaGlnaCAqLworCWZvciAoaSA9IDA7IGkgPCBDT1JHSV9LRVlfU1RST0JFX05VTTsgaSsrKQorCQlweGFfZ3Bpb19tb2RlKENPUkdJX0dQSU9fS0VZX1NUUk9CRShpKSB8IEdQSU9fT1VUIHwgR1BJT19ERkxUX0hJR0gpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6IENvcmdpIEtleWJvYXJkIFJlZ2lzdGVyZWRcbiIpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY29yZ2lrYmRfcmVtb3ZlKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlpbnQgaTsKKwlzdHJ1Y3QgY29yZ2lrYmQgKmNvcmdpa2JkID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisKKwlmb3IgKGkgPSAwOyBpIDwgQ09SR0lfS0VZX1NFTlNFX05VTTsgaSsrKQorCQlmcmVlX2lycShDT1JHSV9JUlFfR1BJT19LRVlfU0VOU0UoaSksIGNvcmdpa2JkKTsKKworCWRlbF90aW1lcl9zeW5jKCZjb3JnaWtiZC0+aHRpbWVyKTsKKwlkZWxfdGltZXJfc3luYygmY29yZ2lrYmQtPnRpbWVyKTsKKworCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKCZjb3JnaWtiZC0+aW5wdXQpOworCisJa2ZyZWUoY29yZ2lrYmQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX2RyaXZlciBjb3JnaWtiZF9kcml2ZXIgPSB7CisJLm5hbWUJCT0gImNvcmdpLWtleWJvYXJkIiwKKwkuYnVzCQk9ICZwbGF0Zm9ybV9idXNfdHlwZSwKKwkucHJvYmUJCT0gY29yZ2lrYmRfcHJvYmUsCisJLnJlbW92ZQkJPSBjb3JnaWtiZF9yZW1vdmUsCit9OworCitzdGF0aWMgaW50IF9fZGV2aW5pdCBjb3JnaWtiZF9pbml0KHZvaWQpCit7CisJcmV0dXJuIGRyaXZlcl9yZWdpc3RlcigmY29yZ2lrYmRfZHJpdmVyKTsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGNvcmdpa2JkX2V4aXQodm9pZCkKK3sKKwlkcml2ZXJfdW5yZWdpc3RlcigmY29yZ2lrYmRfZHJpdmVyKTsKK30KKworbW9kdWxlX2luaXQoY29yZ2lrYmRfaW5pdCk7Cittb2R1bGVfZXhpdChjb3JnaWtiZF9leGl0KTsKKworTU9EVUxFX0FVVEhPUigiUmljaGFyZCBQdXJkaWUgPHJwdXJkaWVAcnBzeXMubmV0PiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJDb3JnaSBLZXlib2FyZCBEcml2ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEx2MiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9oaWxfa2JkLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2hpbF9rYmQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZjc4YmZmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9oaWxfa2JkLmMKQEAgLTAsMCArMSwzNzUgQEAKKy8qCisgKiBHZW5lcmljIGxpbnV4LWlucHV0IGRldmljZSBkcml2ZXIgZm9yIGtleWJvYXJkIGRldmljZXMKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDEgQnJpYW4gUy4gSnVsaW4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucywgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciwKKyAqICAgIHdpdGhvdXQgbW9kaWZpY2F0aW9uLgorICogMi4gVGhlIG5hbWUgb2YgdGhlIGF1dGhvciBtYXkgbm90IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzCisgKiAgICBkZXJpdmVkIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBBbHRlcm5hdGl2ZWx5LCB0aGlzIHNvZnR3YXJlIG1heSBiZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoIkdQTCIpLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIEFVVEhPUiBBTkQgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQKKyAqIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UKKyAqIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQVVUSE9SIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SCisgKiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisgKiBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUworICogT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pCisgKiBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVAorICogTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWQorICoKKyAqIFJlZmVyZW5jZXM6CisgKiBIUC1ISUwgVGVjaG5pY2FsIFJlZmVyZW5jZSBNYW51YWwuICBIZXdsZXR0IFBhY2thcmQgUHJvZHVjdCBOby4gNDU5MThBCisgKgorICovCisKKyNpbmNsdWRlIDxsaW51eC9oaWwuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L3NlcmlvLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9wY2lfaWRzLmg+CisKKyNkZWZpbmUgUFJFRklYICJISUwgS0VZQjogIgorI2RlZmluZSBISUxfR0VORVJJQ19OQU1FICJISUwga2V5Ym9hcmQiCisKK01PRFVMRV9BVVRIT1IoIkJyaWFuIFMuIEp1bGluIDxicmlAY2FseXguY29tPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKEhJTF9HRU5FUklDX05BTUUgIiBkcml2ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJEdWFsIEJTRC9HUEwiKTsKKworI2RlZmluZSBISUxfS0JEX01BWF9MRU5HVEggMTYKKworI2RlZmluZSBISUxfS0JEX1NFVDFfVVBCSVQgMHgwMQorI2RlZmluZSBISUxfS0JEX1NFVDFfU0hJRlQgMQorc3RhdGljIHVuc2lnbmVkIGludCBoaWxfa2JkX3NldDFbSElMX0tFWUNPREVTX1NFVDFfVEJMU0laRV0gPSAKKwl7IEhJTF9LRVlDT0RFU19TRVQxIH07CisKKyNkZWZpbmUgSElMX0tCRF9TRVQyX1VQQklUIDB4MDEKKyNkZWZpbmUgSElMX0tCRF9TRVQyX1NISUZUIDEKKy8qIFNldDIgaXMgdXNlciBkZWZpbmVkICovCisKKyNkZWZpbmUgSElMX0tCRF9TRVQzX1VQQklUIDB4ODAKKyNkZWZpbmUgSElMX0tCRF9TRVQzX1NISUZUIDAKK3N0YXRpYyB1bnNpZ25lZCBpbnQgaGlsX2tiZF9zZXQzW0hJTF9LRVlDT0RFU19TRVQzX1RCTFNJWkVdID0KKwl7IEhJTF9LRVlDT0RFU19TRVQzIH07CisKK3N0YXRpYyBjaGFyIGhpbF9sYW5ndWFnZVtdWzE2XSA9IHsgSElMX0xPQ0FMRV9NQVAgfTsKKworc3RydWN0IGhpbF9rYmQgeworCXN0cnVjdCBpbnB1dF9kZXYgZGV2OworCXN0cnVjdCBzZXJpbyAqc2VyaW87CisKKwkvKiBJbnB1dCBidWZmZXIgYW5kIGluZGV4IGZvciBwYWNrZXRzIGZyb20gSElMIGJ1cy4gKi8KKwloaWxfcGFja2V0IGRhdGFbSElMX0tCRF9NQVhfTEVOR1RIXTsKKwlpbnQgaWR4NDsgLyogZm91ciBjb3VudHMgcGVyIHBhY2tldCAqLworCisJLyogUmF3IGRldmljZSBpbmZvIHJlY29yZHMgZnJvbSBISUwgYnVzLCBzZWUgaGlsLmggZm9yIGZpZWxkcy4gKi8KKwljaGFyCWlkZFtISUxfS0JEX01BWF9MRU5HVEhdOwkvKiBESUQgYnl0ZSBhbmQgSUREIHJlY29yZCAqLworCWNoYXIJcnNjW0hJTF9LQkRfTUFYX0xFTkdUSF07CS8qIFJTQyByZWNvcmQgKi8KKwljaGFyCWV4ZFtISUxfS0JEX01BWF9MRU5HVEhdOwkvKiBFWEQgcmVjb3JkICovCisJY2hhcglybm1bSElMX0tCRF9NQVhfTEVOR1RIICsgMV07CS8qIFJOTSByZWNvcmQgKyBOVUxMIHRlcm0uICovCisKKwkvKiBTb21ldGhpbmcgdG8gc2xlZXAgYXJvdW5kIHdpdGguICovCisJc3RydWN0IHNlbWFwaG9yZSBzZW07Cit9OworCisvKiBQcm9jZXNzIGEgY29tcGxldGUgcGFja2V0IGFmdGVyIHRyYW5zZmVyIGZyb20gdGhlIEhJTCAqLworc3RhdGljIHZvaWQgaGlsX2tiZF9wcm9jZXNzX3JlY29yZChzdHJ1Y3QgaGlsX2tiZCAqa2JkKQoreworCXN0cnVjdCBpbnB1dF9kZXYgKmRldiA9ICZrYmQtPmRldjsKKwloaWxfcGFja2V0ICpkYXRhID0ga2JkLT5kYXRhOworCWhpbF9wYWNrZXQgcDsKKwlpbnQgaWR4LCBpLCBjbnQ7CisKKwlpZHggPSBrYmQtPmlkeDQvNDsKKwlwID0gZGF0YVtpZHggLSAxXTsKKworCWlmICgocCAmIH5ISUxfQ01EQ1RfUE9MKSA9PSAKKwkgICAgKEhJTF9FUlJfSU5UIHwgSElMX1BLVF9DTUQgfCBISUxfQ01EX1BPTCkpIGdvdG8gcmVwb3J0OworCWlmICgocCAmIH5ISUxfQ01EQ1RfUlBMKSA9PSAKKwkgICAgKEhJTF9FUlJfSU5UIHwgSElMX1BLVF9DTUQgfCBISUxfQ01EX1JQTCkpIGdvdG8gcmVwb3J0OworCisJLyogTm90IGEgcG9sbCByZXNwb25zZS4gIFNlZSBpZiB3ZSBhcmUgbG9hZGluZyBjb25maWcgcmVjb3Jkcy4gKi8KKwlzd2l0Y2ggKHAgJiBISUxfUEtUX0RBVEFfTUFTSykgeworCWNhc2UgSElMX0NNRF9JREQ6CisJCWZvciAoaSA9IDA7IGkgPCBpZHg7IGkrKykKKwkJCWtiZC0+aWRkW2ldID0ga2JkLT5kYXRhW2ldICYgSElMX1BLVF9EQVRBX01BU0s7CisJCWZvciAoOyBpIDwgSElMX0tCRF9NQVhfTEVOR1RIOyBpKyspCisJCQlrYmQtPmlkZFtpXSA9IDA7CisJCWJyZWFrOworCWNhc2UgSElMX0NNRF9SU0M6CisJCWZvciAoaSA9IDA7IGkgPCBpZHg7IGkrKykKKwkJCWtiZC0+cnNjW2ldID0ga2JkLT5kYXRhW2ldICYgSElMX1BLVF9EQVRBX01BU0s7CisJCWZvciAoOyBpIDwgSElMX0tCRF9NQVhfTEVOR1RIOyBpKyspCisJCQlrYmQtPnJzY1tpXSA9IDA7CisJCWJyZWFrOworCWNhc2UgSElMX0NNRF9FWEQ6CisJCWZvciAoaSA9IDA7IGkgPCBpZHg7IGkrKykKKwkJCWtiZC0+ZXhkW2ldID0ga2JkLT5kYXRhW2ldICYgSElMX1BLVF9EQVRBX01BU0s7CisJCWZvciAoOyBpIDwgSElMX0tCRF9NQVhfTEVOR1RIOyBpKyspCisJCQlrYmQtPmV4ZFtpXSA9IDA7CisJCWJyZWFrOworCWNhc2UgSElMX0NNRF9STk06CisJCWZvciAoaSA9IDA7IGkgPCBpZHg7IGkrKykKKwkJCWtiZC0+cm5tW2ldID0ga2JkLT5kYXRhW2ldICYgSElMX1BLVF9EQVRBX01BU0s7CisJCWZvciAoOyBpIDwgSElMX0tCRF9NQVhfTEVOR1RIICsgMTsgaSsrKQorCQkJa2JkLT5ybm1baV0gPSAnXDAnOworCQlicmVhazsKKwlkZWZhdWx0OgorCQkvKiBUaGVzZSBvY2N1ciB3aGVuIGRldmljZSBpc24ndCBwcmVzZW50ICovCisJCWlmIChwID09IChISUxfRVJSX0lOVCB8IEhJTF9QS1RfQ01EKSkgYnJlYWs7IAorCQkvKiBBbnl0aGluZyBlbHNlIHdlJ2QgbGlrZSB0byBrbm93IGFib3V0LiAqLworCQlwcmludGsoS0VSTl9XQVJOSU5HIFBSRUZJWCAiRGV2aWNlIHNlbnQgdW5rbm93biByZWNvcmQgJXhcbiIsIHApOworCQlicmVhazsKKwl9CisJZ290byBvdXQ7CisKKyByZXBvcnQ6CisJY250ID0gMTsKKwlzd2l0Y2ggKGtiZC0+ZGF0YVswXSAmIEhJTF9QT0xfQ0hBUlRZUEVfTUFTSykgeworCWNhc2UgSElMX1BPTF9DSEFSVFlQRV9OT05FOgorCQlicmVhazsKKwljYXNlIEhJTF9QT0xfQ0hBUlRZUEVfQVNDSUk6CisJCXdoaWxlIChjbnQgPCBpZHggLSAxKQorCQkJaW5wdXRfcmVwb3J0X2tleShkZXYsIGtiZC0+ZGF0YVtjbnQrK10gJiAweDdmLCAxKTsKKwkJYnJlYWs7CisJY2FzZSBISUxfUE9MX0NIQVJUWVBFX1JTVkQxOgorCWNhc2UgSElMX1BPTF9DSEFSVFlQRV9SU1ZEMjoKKwljYXNlIEhJTF9QT0xfQ0hBUlRZUEVfQklOQVJZOgorCQl3aGlsZSAoY250IDwgaWR4IC0gMSkKKwkJCWlucHV0X3JlcG9ydF9rZXkoZGV2LCBrYmQtPmRhdGFbY250KytdLCAxKTsKKwkJYnJlYWs7CisJY2FzZSBISUxfUE9MX0NIQVJUWVBFX1NFVDE6CisJCXdoaWxlIChjbnQgPCBpZHggLSAxKSB7CisJCQl1bnNpZ25lZCBpbnQga2V5OworCQkJaW50IHVwOworCQkJa2V5ID0ga2JkLT5kYXRhW2NudCsrXTsKKwkJCXVwID0ga2V5ICYgSElMX0tCRF9TRVQxX1VQQklUOworCQkJa2V5ICY9ICh+SElMX0tCRF9TRVQxX1VQQklUICYgMHhmZik7CisJCQlrZXkgPSBoaWxfa2JkX3NldDFba2V5ID4+IEhJTF9LQkRfU0VUMV9TSElGVF07CisJCQlpZiAoa2V5ICE9IEtFWV9SRVNFUlZFRCkKKwkJCQlpbnB1dF9yZXBvcnRfa2V5KGRldiwga2V5LCAhdXApOworCQl9CisJCWJyZWFrOworCWNhc2UgSElMX1BPTF9DSEFSVFlQRV9TRVQyOgorCQl3aGlsZSAoY250IDwgaWR4IC0gMSkgeworCQkJdW5zaWduZWQgaW50IGtleTsKKwkJCWludCB1cDsKKwkJCWtleSA9IGtiZC0+ZGF0YVtjbnQrK107CisJCQl1cCA9IGtleSAmIEhJTF9LQkRfU0VUMl9VUEJJVDsKKwkJCWtleSAmPSAofkhJTF9LQkRfU0VUMV9VUEJJVCAmIDB4ZmYpOworCQkJa2V5ID0ga2V5ID4+IEhJTF9LQkRfU0VUMl9TSElGVDsKKwkJCWlmIChrZXkgIT0gS0VZX1JFU0VSVkVEKQorCQkJCWlucHV0X3JlcG9ydF9rZXkoZGV2LCBrZXksICF1cCk7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBISUxfUE9MX0NIQVJUWVBFX1NFVDM6CisJCXdoaWxlIChjbnQgPCBpZHggLSAxKSB7CisJCQl1bnNpZ25lZCBpbnQga2V5OworCQkJaW50IHVwOworCQkJa2V5ID0ga2JkLT5kYXRhW2NudCsrXTsKKwkJCXVwID0ga2V5ICYgSElMX0tCRF9TRVQzX1VQQklUOworCQkJa2V5ICY9ICh+SElMX0tCRF9TRVQxX1VQQklUICYgMHhmZik7CisJCQlrZXkgPSBoaWxfa2JkX3NldDNba2V5ID4+IEhJTF9LQkRfU0VUM19TSElGVF07CisJCQlpZiAoa2V5ICE9IEtFWV9SRVNFUlZFRCkKKwkJCQlpbnB1dF9yZXBvcnRfa2V5KGRldiwga2V5LCAhdXApOworCQl9CisJCWJyZWFrOworCX0KKyBvdXQ6CisJa2JkLT5pZHg0ID0gMDsKKwl1cCgma2JkLT5zZW0pOworfQorCitzdGF0aWMgdm9pZCBoaWxfa2JkX3Byb2Nlc3NfZXJyKHN0cnVjdCBoaWxfa2JkICprYmQpIHsKKwlwcmludGsoS0VSTl9XQVJOSU5HIFBSRUZJWCAiZXJyb3JlZCBISUwgcGFja2V0XG4iKTsKKwlrYmQtPmlkeDQgPSAwOworCXVwKCZrYmQtPnNlbSk7Cit9CisKK3N0YXRpYyBpcnFyZXR1cm5fdCBoaWxfa2JkX2ludGVycnVwdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvLCAKKwkgICAgICB1bnNpZ25lZCBjaGFyIGRhdGEsIHVuc2lnbmVkIGludCBmbGFncywgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IGhpbF9rYmQgKmtiZDsKKwloaWxfcGFja2V0IHBhY2tldDsKKwlpbnQgaWR4OworCisJa2JkID0gKHN0cnVjdCBoaWxfa2JkICopc2VyaW8tPnByaXZhdGU7CisJaWYgKGtiZCA9PSBOVUxMKSB7CisJCUJVRygpOworCQlyZXR1cm4gSVJRX0hBTkRMRUQ7CisJfQorCisJaWYgKGtiZC0+aWR4NCA+PSAoSElMX0tCRF9NQVhfTEVOR1RIICogc2l6ZW9mKGhpbF9wYWNrZXQpKSkgeworCQloaWxfa2JkX3Byb2Nlc3NfZXJyKGtiZCk7CisJCXJldHVybiBJUlFfSEFORExFRDsKKwl9CisJaWR4ID0ga2JkLT5pZHg0LzQ7CisJaWYgKCEoa2JkLT5pZHg0ICUgNCkpIGtiZC0+ZGF0YVtpZHhdID0gMDsKKwlwYWNrZXQgPSBrYmQtPmRhdGFbaWR4XTsKKwlwYWNrZXQgfD0gKChoaWxfcGFja2V0KWRhdGEpIDw8ICgoMyAtIChrYmQtPmlkeDQgJSA0KSkgKiA4KTsKKwlrYmQtPmRhdGFbaWR4XSA9IHBhY2tldDsKKworCS8qIFJlY29yZHMgb2YgTiA0LWJ5dGUgaGlsX3BhY2tldHMgbXVzdCB0ZXJtaW5hdGUgd2l0aCBhIGNvbW1hbmQuICovCisJaWYgKCgrKyhrYmQtPmlkeDQpKSAlIDQpIHJldHVybiBJUlFfSEFORExFRDsKKwlpZiAoKHBhY2tldCAmIDB4ZmZmZjAwMDApICE9IEhJTF9FUlJfSU5UKSB7CisJCWhpbF9rYmRfcHJvY2Vzc19lcnIoa2JkKTsKKwkJcmV0dXJuIElSUV9IQU5ETEVEOworCX0KKwlpZiAocGFja2V0ICYgSElMX1BLVF9DTUQpIGhpbF9rYmRfcHJvY2Vzc19yZWNvcmQoa2JkKTsKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKK3N0YXRpYyB2b2lkIGhpbF9rYmRfZGlzY29ubmVjdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvKQoreworCXN0cnVjdCBoaWxfa2JkICprYmQ7CisKKwlrYmQgPSAoc3RydWN0IGhpbF9rYmQgKilzZXJpby0+cHJpdmF0ZTsKKwlpZiAoa2JkID09IE5VTEwpIHsKKwkJQlVHKCk7CisJCXJldHVybjsKKwl9CisKKwlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgma2JkLT5kZXYpOworCXNlcmlvX2Nsb3NlKHNlcmlvKTsKKwlrZnJlZShrYmQpOworfQorCitzdGF0aWMgdm9pZCBoaWxfa2JkX2Nvbm5lY3Qoc3RydWN0IHNlcmlvICpzZXJpbywgc3RydWN0IHNlcmlvX2RyaXZlciAqZHJ2KQoreworCXN0cnVjdCBoaWxfa2JkCSprYmQ7CisJdWludDhfdAkJZGlkLCAqaWRkOworCWludAkJaTsKKwkKKwlpZiAoc2VyaW8tPnR5cGUgIT0gKFNFUklPX0hJTF9NTEMgfCBTRVJJT19ISUwpKSByZXR1cm47CisKKwlpZiAoIShrYmQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgaGlsX2tiZCksIEdGUF9LRVJORUwpKSkgcmV0dXJuOworCW1lbXNldChrYmQsIDAsIHNpemVvZihzdHJ1Y3QgaGlsX2tiZCkpOworCisJaWYgKHNlcmlvX29wZW4oc2VyaW8sIGRydikpIGdvdG8gYmFpbDA7CisKKwlzZXJpby0+cHJpdmF0ZSA9IGtiZDsKKwlrYmQtPnNlcmlvID0gc2VyaW87CisJa2JkLT5kZXYucHJpdmF0ZSA9IGtiZDsKKworCWluaXRfTVVURVhfTE9DS0VEKCYoa2JkLT5zZW0pKTsKKworCS8qIEdldCBkZXZpY2UgaW5mby4gIE1MQyBkcml2ZXIgc3VwcGxpZXMgZGV2aWQvc3RhdHVzL2V0Yy4gKi8KKwlzZXJpby0+d3JpdGUoc2VyaW8sIDApOworCXNlcmlvLT53cml0ZShzZXJpbywgMCk7CisJc2VyaW8tPndyaXRlKHNlcmlvLCBISUxfUEtUX0NNRCA+PiA4KTsKKwlzZXJpby0+d3JpdGUoc2VyaW8sIEhJTF9DTURfSUREKTsKKwlkb3duKCYoa2JkLT5zZW0pKTsKKworCXNlcmlvLT53cml0ZShzZXJpbywgMCk7CisJc2VyaW8tPndyaXRlKHNlcmlvLCAwKTsKKwlzZXJpby0+d3JpdGUoc2VyaW8sIEhJTF9QS1RfQ01EID4+IDgpOworCXNlcmlvLT53cml0ZShzZXJpbywgSElMX0NNRF9SU0MpOworCWRvd24oJihrYmQtPnNlbSkpOworCisJc2VyaW8tPndyaXRlKHNlcmlvLCAwKTsKKwlzZXJpby0+d3JpdGUoc2VyaW8sIDApOworCXNlcmlvLT53cml0ZShzZXJpbywgSElMX1BLVF9DTUQgPj4gOCk7CisJc2VyaW8tPndyaXRlKHNlcmlvLCBISUxfQ01EX1JOTSk7CisJZG93bigmKGtiZC0+c2VtKSk7CisKKwlzZXJpby0+d3JpdGUoc2VyaW8sIDApOworCXNlcmlvLT53cml0ZShzZXJpbywgMCk7CisJc2VyaW8tPndyaXRlKHNlcmlvLCBISUxfUEtUX0NNRCA+PiA4KTsKKwlzZXJpby0+d3JpdGUoc2VyaW8sIEhJTF9DTURfRVhEKTsKKwlkb3duKCYoa2JkLT5zZW0pKTsKKworCXVwKCYoa2JkLT5zZW0pKTsKKworCWRpZCA9IGtiZC0+aWRkWzBdOworCWlkZCA9IGtiZC0+aWRkICsgMTsKKwlzd2l0Y2ggKGRpZCAmIEhJTF9JRERfRElEX1RZUEVfTUFTSykgeworCWNhc2UgSElMX0lERF9ESURfVFlQRV9LQl9JTlRFR1JBTDoKKwljYXNlIEhJTF9JRERfRElEX1RZUEVfS0JfSVRGOgorCWNhc2UgSElMX0lERF9ESURfVFlQRV9LQl9SU1ZEOgorCWNhc2UgSElMX0lERF9ESURfVFlQRV9DSEFSOgorCQlwcmludGsoS0VSTl9JTkZPIFBSRUZJWCAiSElMIGtleWJvYXJkIGZvdW5kIChkaWQgPSAweCUwMngsIGxhbmcgPSAlcylcbiIsCisJCQlkaWQsIGhpbF9sYW5ndWFnZVtkaWQgJiBISUxfSUREX0RJRF9UWVBFX0tCX0xBTkdfTUFTS10pOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlnb3RvIGJhaWwxOworCX0KKworCWlmKEhJTF9JRERfTlVNX0JVVFRPTlMoaWRkKSB8fCBISUxfSUREX05VTV9BWEVTX1BFUl9TRVQoKmlkZCkpIHsKKwkJcHJpbnRrKEtFUk5fSU5GTyBQUkVGSVggImtleWJvYXJkcyBvbmx5LCBubyBjb21ibyBkZXZpY2VzIHN1cHBvcnRlZC5cbiIpOworCQlnb3RvIGJhaWwxOworCX0KKworCisJa2JkLT5kZXYuZXZiaXRbMF0JPSBCSVQoRVZfS0VZKSB8IEJJVChFVl9SRVApOworCWtiZC0+ZGV2LmxlZGJpdFswXQk9IEJJVChMRURfTlVNTCkgfCBCSVQoTEVEX0NBUFNMKSB8IEJJVChMRURfU0NST0xMTCk7CisJa2JkLT5kZXYua2V5Y29kZW1heAk9IEhJTF9LRVlDT0RFU19TRVQxX1RCTFNJWkU7CisJa2JkLT5kZXYua2V5Y29kZXNpemUJPSBzaXplb2YoaGlsX2tiZF9zZXQxWzBdKTsKKwlrYmQtPmRldi5rZXljb2RlCT0gaGlsX2tiZF9zZXQxOworCWtiZC0+ZGV2Lm5hbWUJCT0gc3RybGVuKGtiZC0+cm5tKSA/IGtiZC0+cm5tIDogSElMX0dFTkVSSUNfTkFNRTsKKwlrYmQtPmRldi5waHlzCQk9ICJocGtiZC9pbnB1dDAiOwkvKiBYWFggKi8KKworCWtiZC0+ZGV2LmlkLmJ1c3R5cGUJPSBCVVNfSElMOworCWtiZC0+ZGV2LmlkLnZlbmRvcgk9IFBDSV9WRU5ET1JfSURfSFA7CisJa2JkLT5kZXYuaWQucHJvZHVjdAk9IDB4MDAwMTsgLyogVE9ETzogZ2V0IGZyb20ga2JkLT5yc2MgKi8KKwlrYmQtPmRldi5pZC52ZXJzaW9uCT0gMHgwMTAwOyAvKiBUT0RPOiBnZXQgZnJvbSBrYmQtPnJzYyAqLworCWtiZC0+ZGV2LmRldgkJPSAmc2VyaW8tPmRldjsKKworCWZvciAoaSA9IDA7IGkgPCAxMjg7IGkrKykgeworCQlzZXRfYml0KGhpbF9rYmRfc2V0MVtpXSwga2JkLT5kZXYua2V5Yml0KTsKKwkJc2V0X2JpdChoaWxfa2JkX3NldDNbaV0sIGtiZC0+ZGV2LmtleWJpdCk7CisJfQorCWNsZWFyX2JpdCgwLCBrYmQtPmRldi5rZXliaXQpOworCisJaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKCZrYmQtPmRldik7CisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6ICVzLCBJRDogJWRcbiIsCisJCWtiZC0+ZGV2Lm5hbWUsIGRpZCk7CisKKwlzZXJpby0+d3JpdGUoc2VyaW8sIDApOworCXNlcmlvLT53cml0ZShzZXJpbywgMCk7CisJc2VyaW8tPndyaXRlKHNlcmlvLCBISUxfUEtUX0NNRCA+PiA4KTsKKwlzZXJpby0+d3JpdGUoc2VyaW8sIEhJTF9DTURfRUsxKTsgLyogRW5hYmxlIEtleXN3aXRjaCBBdXRvcmVwZWF0IDEgKi8KKwlkb3duKCYoa2JkLT5zZW0pKTsKKwl1cCgmKGtiZC0+c2VtKSk7CisKKwlyZXR1cm47CisgYmFpbDE6CisJc2VyaW9fY2xvc2Uoc2VyaW8pOworIGJhaWwwOgorCWtmcmVlKGtiZCk7Cit9CisKKworc3RydWN0IHNlcmlvX2RyaXZlciBoaWxfa2JkX3NlcmlvX2RydiA9IHsKKwkuZHJpdmVyCQk9IHsKKwkJLm5hbWUJPSAiaGlsX2tiZCIsCisJfSwKKwkuZGVzY3JpcHRpb24JPSAiSFAgSElMIGtleWJvYXJkIGRyaXZlciIsCisJLmNvbm5lY3QgCT0gaGlsX2tiZF9jb25uZWN0LAorCS5kaXNjb25uZWN0IAk9IGhpbF9rYmRfZGlzY29ubmVjdCwKKwkuaW50ZXJydXB0IAk9IGhpbF9rYmRfaW50ZXJydXB0Cit9OworCitzdGF0aWMgaW50IF9faW5pdCBoaWxfa2JkX2luaXQodm9pZCkKK3sKKwlzZXJpb19yZWdpc3Rlcl9kcml2ZXIoJmhpbF9rYmRfc2VyaW9fZHJ2KTsKKyAgICAgICAgcmV0dXJuIDA7Cit9CisgICAgICAgICAgICAgICAgCitzdGF0aWMgdm9pZCBfX2V4aXQgaGlsX2tiZF9leGl0KHZvaWQpCit7CisJc2VyaW9fdW5yZWdpc3Rlcl9kcml2ZXIoJmhpbF9rYmRfc2VyaW9fZHJ2KTsKK30KKyAgICAgICAgICAgICAgICAgICAgICAgIAorbW9kdWxlX2luaXQoaGlsX2tiZF9pbml0KTsKK21vZHVsZV9leGl0KGhpbF9rYmRfZXhpdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2hpbGtiZC5jIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9oaWxrYmQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZWNiNzdkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9oaWxrYmQuYwpAQCAtMCwwICsxLDM0MyBAQAorLyoKKyAqICBsaW51eC9kcml2ZXJzL2hpbC9oaWxrYmQuYworICoKKyAqICBDb3B5cmlnaHQgKEMpIDE5OTggUGhpbGlwIEJsdW5kZWxsIDxwaGlsYkBnbnUub3JnPgorICogIENvcHlyaWdodCAoQykgMTk5OSBNYXR0aGV3IFdpbGNveCA8d2lsbHlAYm9maC5haT4KKyAqICBDb3B5cmlnaHQgKEMpIDE5OTktMjAwMyBIZWxnZSBEZWxsZXIgPGRlbGxlckBnbXguZGU+CisgKgorICogIFZlcnkgYmFzaWMgSFAgSHVtYW4gSW50ZXJmYWNlIExvb3AgKEhJTCkgZHJpdmVyLgorICogIFRoaXMgZHJpdmVyIGhhbmRsZXMgdGhlIGtleWJvYXJkIG9uIEhQMzAwIChtNjhrKSBhbmQgb24gc29tZSAKKyAqICBIUDcwMCAocGFyaXNjKSBzZXJpZXMgbWFjaGluZXMuCisgKgorICogCisgKiBUaGlzIGZpbGUgaXMgc3ViamVjdCB0byB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSB2ZXJzaW9uIDIuICBTZWUgdGhlIGZpbGUgQ09QWUlORyBpbiB0aGUgbWFpbiBkaXJlY3Rvcnkgb2YgdGhpcworICogYXJjaGl2ZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9wY2lfaWRzLmg+CisjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvY29uZmlnLmg+CisjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KKyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9pcnEuaD4KKyNpbmNsdWRlIDxsaW51eC9oaWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorCisKK01PRFVMRV9BVVRIT1IoIlBoaWxpcCBCbHVuZGVsbCwgTWF0dGhldyBXaWxjb3gsIEhlbGdlIERlbGxlciIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJISUwga2V5Ym9hcmQgZHJpdmVyIChiYXNpYyBmdW5jdGlvbmFsaXR5KSIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOworCisKKyNpZiBkZWZpbmVkKENPTkZJR19QQVJJU0MpCisKKyAjaW5jbHVkZSA8YXNtL2lvLmg+CisgI2luY2x1ZGUgPGFzbS9oYXJkd2FyZS5oPgorICNpbmNsdWRlIDxhc20vcGFyaXNjLWRldmljZS5oPgorIHN0YXRpYyB1bnNpZ25lZCBsb25nIGhpbF9iYXNlOwkvKiBIUEEgZm9yIHRoZSBISUwgZGV2aWNlICovCisgc3RhdGljIHVuc2lnbmVkIGludCBoaWxfaXJxOworICNkZWZpbmUgSElMQkFTRQkJaGlsX2Jhc2UgLyogSFBQQSAocGFyaXNjKSBwb3J0IGFkZHJlc3MgKi8KKyAjZGVmaW5lIEhJTF9EQVRBCQkweDgwMAorICNkZWZpbmUgSElMX0NNRAkJMHg4MDEKKyAjZGVmaW5lIEhJTF9JUlEJCWhpbF9pcnEKKyAjZGVmaW5lIGhpbF9yZWFkYihwKQkJZ3NjX3JlYWRiKHApCisgI2RlZmluZSBoaWxfd3JpdGViKHYscCkJZ3NjX3dyaXRlYigodiksKHApKQorCisjZWxpZiBkZWZpbmVkKENPTkZJR19IUDMwMCkKKworICNkZWZpbmUgSElMQkFTRQkJMHhmMDQyODAwMCAvKiBIUDMwMCAobTg2aykgcG9ydCBhZGRyZXNzICovCisgI2RlZmluZSBISUxfREFUQQkJMHgxCisgI2RlZmluZSBISUxfQ01ECQkweDMKKyAjZGVmaW5lIEhJTF9JUlEJCTIKKyAjZGVmaW5lIGhpbF9yZWFkYihwKQkJcmVhZGIocCkKKyAjZGVmaW5lIGhpbF93cml0ZWIodixwKQl3cml0ZWIoKHYpLChwKSkKKworI2Vsc2UKKyNlcnJvciAiSElMIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBwbGF0Zm9ybSIKKyNlbmRpZgorCisKKyAKKy8qIEhJTCBoZWxwZXIgZnVuY3Rpb25zICovCisgCisjZGVmaW5lIGhpbF9idXN5KCkgICAgICAgICAgICAgIChoaWxfcmVhZGIoSElMQkFTRSArIEhJTF9DTUQpICYgSElMX0JVU1kpCisjZGVmaW5lIGhpbF9kYXRhX2F2YWlsYWJsZSgpICAgIChoaWxfcmVhZGIoSElMQkFTRSArIEhJTF9DTUQpICYgSElMX0RBVEFfUkRZKQorI2RlZmluZSBoaWxfc3RhdHVzKCkgICAgICAgICAgICAoaGlsX3JlYWRiKEhJTEJBU0UgKyBISUxfQ01EKSkKKyNkZWZpbmUgaGlsX2NvbW1hbmQoeCkgICAgICAgICAgZG8geyBoaWxfd3JpdGViKCh4KSwgSElMQkFTRSArIEhJTF9DTUQpOyB9IHdoaWxlICgwKQorI2RlZmluZSBoaWxfcmVhZF9kYXRhKCkgICAgICAgICAoaGlsX3JlYWRiKEhJTEJBU0UgKyBISUxfREFUQSkpCisjZGVmaW5lIGhpbF93cml0ZV9kYXRhKHgpICAgICAgIGRvIHsgaGlsX3dyaXRlYigoeCksIEhJTEJBU0UgKyBISUxfREFUQSk7IH0gd2hpbGUgKDApCisKKy8qIEhJTCBjb25zdGFudHMgKi8KKyAKKyNkZWZpbmUJSElMX0JVU1kJCTB4MDIKKyNkZWZpbmUJSElMX0RBVEFfUkRZCQkweDAxCisKKyNkZWZpbmUJSElMX1NFVEFSRAkJMHhBMAkJLyogc2V0IGF1dG8tcmVwZWF0IGRlbGF5ICovCisjZGVmaW5lCUhJTF9TRVRBUlIJCTB4QTIJCS8qIHNldCBhdXRvLXJlcGVhdCByYXRlICovCisjZGVmaW5lCUhJTF9TRVRUT05FCQkweEEzCQkvKiBzZXQgdG9uZSBnZW5lcmF0b3IgKi8KKyNkZWZpbmUJSElMX0NOTVQJCTB4QjIJCS8qIGNsZWFyIG5taSAqLworI2RlZmluZQlISUxfSU5UT04JCTB4NUMJCS8qIFR1cm4gb24gaW50ZXJydXB0cy4gKi8KKyNkZWZpbmUJSElMX0lOVE9GRgkJMHg1RAkJLyogVHVybiBvZmYgaW50ZXJydXB0cy4gKi8KKworI2RlZmluZQlISUxfUkVBREtCRFNBRFIJIAkweEY5CisjZGVmaW5lCUhJTF9XUklURUtCRFNBRFIgCTB4RTkKKworc3RhdGljIHVuc2lnbmVkIGludCBocGhpbGtleWJfa2V5Y29kZVtISUxfS0VZQ09ERVNfU0VUMV9UQkxTSVpFXSA9IAorCXsgSElMX0tFWUNPREVTX1NFVDEgfTsKKworLyogSElMIHN0cnVjdHVyZSAqLworc3RhdGljIHN0cnVjdCB7CisJc3RydWN0IGlucHV0X2RldiBkZXY7CisKKwl1bnNpZ25lZCBpbnQgY3VyZGV2OworCQorCXVuc2lnbmVkIGNoYXIgczsKKwl1bnNpZ25lZCBjaGFyIGM7CisJaW50IHZhbGlkOworCQorCXVuc2lnbmVkIGNoYXIgZGF0YVsxNl07CisJdW5zaWduZWQgaW50IHB0cjsKKwlzcGlubG9ja190IGxvY2s7CisKKwl2b2lkICpkZXZfaWQ7CS8qIG5hdGl2ZSBidXMgZGV2aWNlICovCit9IGhpbF9kZXY7CisKKworc3RhdGljIHZvaWQgcG9sbF9maW5pc2hlZCh2b2lkKQoreworCWludCBkb3duOworCWludCBrZXk7CisJdW5zaWduZWQgY2hhciBzY29kZTsKKwkKKwlzd2l0Y2ggKGhpbF9kZXYuZGF0YVswXSkgeworCWNhc2UgMHg0MDoKKwkJZG93biA9IChoaWxfZGV2LmRhdGFbMV0gJiAxKSA9PSAwOworCQlzY29kZSA9IGhpbF9kZXYuZGF0YVsxXSA+PiAxOworCQlrZXkgPSBocGhpbGtleWJfa2V5Y29kZVtzY29kZV07CisJCWlucHV0X3JlcG9ydF9rZXkoJmhpbF9kZXYuZGV2LCBrZXksIGRvd24pOworCQlicmVhazsKKwl9CisJaGlsX2Rldi5jdXJkZXYgPSAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgaGFuZGxlX3N0YXR1cyh1bnNpZ25lZCBjaGFyIHMsIHVuc2lnbmVkIGNoYXIgYykKK3sKKwlpZiAoYyAmIDB4OCkgeworCQkvKiBFbmQgb2YgYmxvY2sgKi8KKwkJaWYgKGMgJiAweDEwKQorCQkJcG9sbF9maW5pc2hlZCgpOworCX0gZWxzZSB7CisJCWlmIChjICYgMHgxMCkgeworCQkJaWYgKGhpbF9kZXYuY3VyZGV2KQorCQkJCXBvbGxfZmluaXNoZWQoKTsgIC8qIGp1c3QgaW4gY2FzZSAqLworCQkJaGlsX2Rldi5jdXJkZXYgPSBjICYgNzsKKwkJCWhpbF9kZXYucHRyID0gMDsKKwkJfQorCX0KK30KKworc3RhdGljIGlubGluZSB2b2lkIGhhbmRsZV9kYXRhKHVuc2lnbmVkIGNoYXIgcywgdW5zaWduZWQgY2hhciBjKQoreworCWlmIChoaWxfZGV2LmN1cmRldikgeworCQloaWxfZGV2LmRhdGFbaGlsX2Rldi5wdHIrK10gPSBjOworCQloaWxfZGV2LnB0ciAmPSAxNTsKKwl9Cit9CisKKworLyogCisgKiBIYW5kbGUgSElMIGludGVycnVwdHMuCisgKi8KK3N0YXRpYyBpcnFyZXR1cm5fdCBoaWxfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmhhbmRsZSwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJdW5zaWduZWQgY2hhciBzLCBjOworCQorCXMgPSBoaWxfc3RhdHVzKCk7CisJYyA9IGhpbF9yZWFkX2RhdGEoKTsKKworCXN3aXRjaCAocyA+PiA0KSB7CisJY2FzZSAweDU6CisJCWhhbmRsZV9zdGF0dXMocywgYyk7CisJCWJyZWFrOworCWNhc2UgMHg2OgorCQloYW5kbGVfZGF0YShzLCBjKTsKKwkJYnJlYWs7CisJY2FzZSAweDQ6CisJCWhpbF9kZXYucyA9IHM7CisJCWhpbF9kZXYuYyA9IGM7CisJCW1iKCk7CisJCWhpbF9kZXYudmFsaWQgPSAxOworCQlicmVhazsKKwl9CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCisvKgorICogU2VuZCBhIGNvbW1hbmQgdG8gdGhlIEhJTAorICovCisKK3N0YXRpYyB2b2lkIGhpbF9kbyh1bnNpZ25lZCBjaGFyIGNtZCwgdW5zaWduZWQgY2hhciAqZGF0YSwgdW5zaWduZWQgaW50IGxlbikKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmhpbF9kZXYubG9jaywgZmxhZ3MpOworCXdoaWxlIChoaWxfYnVzeSgpKQorCQkvKiB3YWl0ICovOworCWhpbF9jb21tYW5kKGNtZCk7CisJd2hpbGUgKGxlbi0tKSB7CisJCXdoaWxlIChoaWxfYnVzeSgpKQorCQkJLyogd2FpdCAqLzsKKwkJaGlsX3dyaXRlX2RhdGEoKihkYXRhKyspKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaGlsX2Rldi5sb2NrLCBmbGFncyk7Cit9CisKKworLyoKKyAqIEluaXRpYWxpc2UgSElMLiAKKyAqLworCitzdGF0aWMgaW50IF9faW5pdAoraGlsX2tleWJfaW5pdCh2b2lkKQoreworCXVuc2lnbmVkIGNoYXIgYzsKKwl1bnNpZ25lZCBpbnQgaSwga2JpZDsKKwl3YWl0X3F1ZXVlX2hlYWRfdCBoaWxfd2FpdDsKKworCWlmIChoaWxfZGV2LmRldi5pZC5idXN0eXBlKSB7CisJCXJldHVybiAtRU5PREVWOyAvKiBhbHJlYWR5IGluaXRpYWxpemVkICovCisJfQorCQorI2lmIGRlZmluZWQoQ09ORklHX0hQMzAwKQorCWlmICghaHdyZWdfcHJlc2VudCgodm9pZCAqKShISUxCQVNFICsgSElMX0RBVEEpKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisJCisJcmVxdWVzdF9yZWdpb24oSElMQkFTRStISUxfREFUQSwgMiwgImhpbCIpOworI2VuZGlmCisJCisJcmVxdWVzdF9pcnEoSElMX0lSUSwgaGlsX2ludGVycnVwdCwgMCwgImhpbCIsIGhpbF9kZXYuZGV2X2lkKTsKKworCS8qIFR1cm4gb24gaW50ZXJydXB0cyAqLworCWhpbF9kbyhISUxfSU5UT04sIE5VTEwsIDApOworCisJLyogTG9vayBmb3Iga2V5Ym9hcmRzICovCisJaGlsX2Rldi52YWxpZCA9IDA7CS8qIGNsZWFyIGFueSBwZW5kaW5nIGRhdGEgKi8KKwloaWxfZG8oSElMX1JFQURLQkRTQURSLCBOVUxMLCAwKTsKKworCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmhpbF93YWl0KTsKKwl3YWl0X2V2ZW50X2ludGVycnVwdGlibGVfdGltZW91dChoaWxfd2FpdCwgaGlsX2Rldi52YWxpZCwgMypIWik7CisJaWYgKCFoaWxfZGV2LnZhbGlkKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIkhJTDogdGltZWQgb3V0LCBhc3N1bWluZyBubyBrZXlib2FyZCBwcmVzZW50LlxuIik7CisJfQorCisJYyA9IGhpbF9kZXYuYzsgCisJaGlsX2Rldi52YWxpZCA9IDA7CisJaWYgKGMgPT0gMCkgeworCQlrYmlkID0gLTE7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIkhJTDogbm8ga2V5Ym9hcmQgcHJlc2VudC5cbiIpOworCX0gZWxzZSB7CisJCWtiaWQgPSBmZnoofmMpOworCQkvKiBwcmludGsoS0VSTl9JTkZPICJISUw6IGtleWJvYXJkIGZvdW5kIGF0IGlkICVkXG4iLCBrYmlkKTsgKi8KKwl9CisKKwkvKiBzZXQgaXQgdG8gcmF3IG1vZGUgKi8KKwljID0gMDsKKwloaWxfZG8oSElMX1dSSVRFS0JEU0FEUiwgJmMsIDEpOworCQorCWluaXRfaW5wdXRfZGV2KCZoaWxfZGV2LmRldik7CisKKwlmb3IgKGkgPSAwOyBpIDwgSElMX0tFWUNPREVTX1NFVDFfVEJMU0laRTsgaSsrKQorCQlpZiAoaHBoaWxrZXliX2tleWNvZGVbaV0gIT0gS0VZX1JFU0VSVkVEKQorCQkJc2V0X2JpdChocGhpbGtleWJfa2V5Y29kZVtpXSwgaGlsX2Rldi5kZXYua2V5Yml0KTsKKworCWhpbF9kZXYuZGV2LmV2Yml0WzBdICAgID0gQklUKEVWX0tFWSkgfCBCSVQoRVZfUkVQKTsKKwloaWxfZGV2LmRldi5sZWRiaXRbMF0gICA9IEJJVChMRURfTlVNTCkgfCBCSVQoTEVEX0NBUFNMKSB8IEJJVChMRURfU0NST0xMTCk7CisJaGlsX2Rldi5kZXYua2V5Y29kZW1heCAgPSBISUxfS0VZQ09ERVNfU0VUMV9UQkxTSVpFOworICAgICAgICBoaWxfZGV2LmRldi5rZXljb2Rlc2l6ZSA9IHNpemVvZihocGhpbGtleWJfa2V5Y29kZVswXSk7CisJaGlsX2Rldi5kZXYua2V5Y29kZSAgICAgPSBocGhpbGtleWJfa2V5Y29kZTsKKwloaWxfZGV2LmRldi5uYW1lIAk9ICJISUwga2V5Ym9hcmQiOworCWhpbF9kZXYuZGV2LnBoeXMgCT0gImhwa2JkL2lucHV0MCI7CisKKwloaWxfZGV2LmRldi5pZC5idXN0eXBlCT0gQlVTX0hJTDsKKwloaWxfZGV2LmRldi5pZC52ZW5kb3IJPSBQQ0lfVkVORE9SX0lEX0hQOworCWhpbF9kZXYuZGV2LmlkLnByb2R1Y3QJPSAweDAwMDE7CisJaGlsX2Rldi5kZXYuaWQudmVyc2lvbgk9IDB4MDAxMDsKKworCWlucHV0X3JlZ2lzdGVyX2RldmljZSgmaGlsX2Rldi5kZXYpOworCXByaW50ayhLRVJOX0lORk8gImlucHV0OiAlcywgSUQgJWQgYXQgMHglMDhseCAoaXJxICVkKSBmb3VuZCBhbmQgYXR0YWNoZWRcbiIsCisJCWhpbF9kZXYuZGV2Lm5hbWUsIGtiaWQsIEhJTEJBU0UsIEhJTF9JUlEpOworCisJcmV0dXJuIDA7Cit9CisKKyNpZiBkZWZpbmVkKENPTkZJR19QQVJJU0MpCitzdGF0aWMgaW50IF9faW5pdAoraGlsX2luaXRfY2hpcChzdHJ1Y3QgcGFyaXNjX2RldmljZSAqZGV2KQoreworCWlmICghZGV2LT5pcnEpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiSElMOiBJUlEgbm90IGZvdW5kIGZvciBISUwgYnVzIGF0IDB4JTA4bHhcbiIsIGRldi0+aHBhKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJaGlsX2Jhc2UgPSBkZXYtPmhwYTsKKwloaWxfaXJxICA9IGRldi0+aXJxOworCWhpbF9kZXYuZGV2X2lkID0gZGV2OworCQorCXByaW50ayhLRVJOX0lORk8gIkZvdW5kIEhJTCBidXMgYXQgMHglMDhseCwgSVJRICVkXG4iLCBoaWxfYmFzZSwgaGlsX2lycSk7CisKKwlyZXR1cm4gaGlsX2tleWJfaW5pdCgpOworfQorCitzdGF0aWMgc3RydWN0IHBhcmlzY19kZXZpY2VfaWQgaGlsX3RibFtdID0geworCXsgSFBIV19GSU8sIEhWRVJTSU9OX1JFVl9BTllfSUQsIEhWRVJTSU9OX0FOWV9JRCwgMHgwMDA3MyB9LAorCXsgMCwgfQorfTsKKworTU9EVUxFX0RFVklDRV9UQUJMRShwYXJpc2MsIGhpbF90YmwpOworCitzdGF0aWMgc3RydWN0IHBhcmlzY19kcml2ZXIgaGlsX2RyaXZlciA9IHsKKwkubmFtZSA9CQkiSElMIiwKKwkuaWRfdGFibGUgPQloaWxfdGJsLAorCS5wcm9iZSA9CWhpbF9pbml0X2NoaXAsCit9OworI2VuZGlmIC8qIENPTkZJR19QQVJJU0MgKi8KKworCisKKworCitzdGF0aWMgaW50IF9faW5pdCBoaWxfaW5pdCh2b2lkKQoreworI2lmIGRlZmluZWQoQ09ORklHX1BBUklTQykKKwlyZXR1cm4gcmVnaXN0ZXJfcGFyaXNjX2RyaXZlcigmaGlsX2RyaXZlcik7CisjZWxzZQorCXJldHVybiBoaWxfa2V5Yl9pbml0KCk7CisjZW5kaWYKK30KKworCitzdGF0aWMgdm9pZCBfX2V4aXQgaGlsX2V4aXQodm9pZCkKK3sKKwlpZiAoSElMX0lSUSkgeworCQlkaXNhYmxlX2lycShISUxfSVJRKTsKKwkJZnJlZV9pcnEoSElMX0lSUSwgaGlsX2Rldi5kZXZfaWQpOworCX0KKworCS8qIFR1cm4gb2ZmIGludGVycnVwdHMgKi8KKwloaWxfZG8oSElMX0lOVE9GRiwgTlVMTCwgMCk7CisKKwlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgmaGlsX2Rldi5kZXYpOworCisjaWYgZGVmaW5lZChDT05GSUdfUEFSSVNDKQorCXVucmVnaXN0ZXJfcGFyaXNjX2RyaXZlcigmaGlsX2RyaXZlcik7CisjZWxzZQorCXJlbGVhc2VfcmVnaW9uKEhJTEJBU0UrSElMX0RBVEEsIDIpOworI2VuZGlmCit9CisKK21vZHVsZV9pbml0KGhpbF9pbml0KTsKK21vZHVsZV9leGl0KGhpbF9leGl0KTsKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9ocHBzMmF0a2JkLmggYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2hwcHMyYXRrYmQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kYzMzZjY5Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9ocHBzMmF0a2JkLmgKQEAgLTAsMCArMSwxMTAgQEAKKy8qCisgKiBkcml2ZXJzL2lucHV0L2tleWJvYXJkL2hwcHMyYXRrYmQuaAorICoKKyAqIENvcHlyaWdodCAoYykgMjAwNCBIZWxnZSBEZWxsZXIgPGRlbGxlckBnbXguZGU+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDIgTGF1cmVudCBDYW5ldCA8Y2FuZXRsQGVzaWVlLmZyPgorICogQ29weXJpZ2h0IChjKSAyMDAyIFRoaWJhdXQgVmFyZW5lIDx2YXJlbmV0QHBhcmlzYy1saW51eC5vcmc+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDAgWGF2aWVyIERlYmFja2VyIDxkZWJhY2tleEBlc2llZS5mcj4KKyAqCisgKiBIUCBQUy8yIEFULWNvbXBhdGlibGUgS2V5Ym9hcmQsIGZvdW5kIGluIFBBL1JJU0MgV29ya3N0YXRpb25zICYgTGFwdG9wcworICoKKyAqIFRoaXMgZmlsZSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlLiAgU2VlIHRoZSBmaWxlICJDT1BZSU5HIiBpbiB0aGUgbWFpbiBkaXJlY3Rvcnkgb2YgdGhpcyBhcmNoaXZlCisgKiBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKworLyogSXMgdGhlIGtleWJvYXJkIGFuIFJESSBQcmVjaXNpb25Cb29rPyAqLworI2lmbmRlZiBDT05GSUdfS0VZQk9BUkRfQVRLQkRfUkRJX0tFWUNPREVTCisjIGRlZmluZSBDT05GTElDVCh4LHkpIHgKKyNlbHNlCisjIGRlZmluZSBDT05GTElDVCh4LHkpIHkKKyNlbmRpZgorCisvKiBzYWRseSBSREkgKFRhZHBvbGUpIGRlY2lkZWQgdG8gc2hpcCBhIGRpZmZlcmVudCBrZXlib2FyZCBsYXlvdXQKKyAgIHRoYW4gSFAgZm9yIHRoZWlyIFBTLzIgbGFwdG9wIGtleWJvYXJkIHdoaWNoIGxlYWRzIHRvIGNvbmZsaWN0aW5nCisgICBrZXljb2RlcyBiZXR3ZWVuIGEgbm9ybWFsIEhQIFBTLzIga2V5Ym9hcmQgYW5kIGEgUkRJIFByZWNpc2lvbmJvb2suCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEhQOgkJUkRJOiAgICAgICAgICAgICovCisjZGVmaW5lIENfMDcJQ09ORkxJQ1QoCUtFWV9GMTIsCUtFWV9GMQkJKQorI2RlZmluZSBDXzExCUNPTkZMSUNUKAlLRVlfTEVGVEFMVCwJS0VZX0xFRlRDVFJMCSkKKyNkZWZpbmUgQ18xNAlDT05GTElDVCgJS0VZX0xFRlRDVFJMLAlLRVlfQ0FQU0xPQ0sJKQorI2RlZmluZSBDXzU4CUNPTkZMSUNUKAlLRVlfQ0FQU0xPQ0ssCUtFWV9SSUdIVENUUkwJKQorI2RlZmluZSBDXzYxCUNPTkZMSUNUKAlLRVlfMTAyTkQsCUtFWV9MRUZUCSkKKworLyogUmF3IFNFVCAyIHNjYW5jb2RlIHRhYmxlICovCisKKy8qIDAwICovICBLRVlfUkVTRVJWRUQsIEtFWV9GOSwgICAgICAgIEtFWV9SRVNFUlZFRCwgIEtFWV9GNSwgICAgICAgIEtFWV9GMywgICAgICAgIEtFWV9GMSwgICAgICAgS0VZX0YyLCAgICAgICAgQ18wNywKKy8qIDA4ICovICBLRVlfRVNDLCAgICAgIEtFWV9GMTAsICAgICAgIEtFWV9GOCwgICAgICAgIEtFWV9GNiwgICAgICAgIEtFWV9GNCwgICAgICAgIEtFWV9UQUIsICAgICAgS0VZX0dSQVZFLCAgICAgS0VZX0YyLAorLyogMTAgKi8gIEtFWV9SRVNFUlZFRCwgQ18xMSwgICAgICAgICAgS0VZX0xFRlRTSElGVCwgS0VZX1JFU0VSVkVELCAgQ18xNCwgICAgICAgICAgS0VZX1EsICAgICAgICBLRVlfMSwgICAgICAgICBLRVlfRjMsCisvKiAxOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfTEVGVEFMVCwgICBLRVlfWiwgICAgICAgICBLRVlfUywgICAgICAgICBLRVlfQSwgICAgICAgICBLRVlfVywgICAgICAgIEtFWV8yLCAgICAgICAgIEtFWV9GNCwKKy8qIDIwICovICBLRVlfUkVTRVJWRUQsIEtFWV9DLCAgICAgICAgIEtFWV9YLCAgICAgICAgIEtFWV9ELCAgICAgICAgIEtFWV9FLCAgICAgICAgIEtFWV80LCAgICAgICAgS0VZXzMsICAgICAgICAgS0VZX0Y1LAorLyogMjggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1NQQUNFLCAgICAgS0VZX1YsICAgICAgICAgS0VZX0YsICAgICAgICAgS0VZX1QsICAgICAgICAgS0VZX1IsICAgICAgICBLRVlfNSwgICAgICAgICBLRVlfRjYsCisvKiAzMCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfTiwgICAgICAgICBLRVlfQiwgICAgICAgICBLRVlfSCwgICAgICAgICBLRVlfRywgICAgICAgICBLRVlfWSwgICAgICAgIEtFWV82LCAgICAgICAgIEtFWV9GNywKKy8qIDM4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SSUdIVEFMVCwgIEtFWV9NLCAgICAgICAgIEtFWV9KLCAgICAgICAgIEtFWV9VLCAgICAgICAgIEtFWV83LCAgICAgICAgS0VZXzgsICAgICAgICAgS0VZX0Y4LAorLyogNDAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX0NPTU1BLCAgICAgS0VZX0ssICAgICAgICAgS0VZX0ksICAgICAgICAgS0VZX08sICAgICAgICAgS0VZXzAsICAgICAgICBLRVlfOSwgICAgICAgICBLRVlfRjksCisvKiA0OCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfRE9ULCAgICAgICBLRVlfU0xBU0gsICAgICBLRVlfTCwgICAgICAgICBLRVlfU0VNSUNPTE9OLCBLRVlfUCwgICAgICAgIEtFWV9NSU5VUywgICAgIEtFWV9GMTAsCisvKiA1MCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfQVBPU1RST1BIRSxLRVlfUkVTRVJWRUQsICBLRVlfTEVGVEJSQUNFLCBLRVlfRVFVQUwsICAgIEtFWV9GMTEsICAgICAgIEtFWV9TWVNSUSwKKy8qIDU4ICovICBDXzU4LCAgICAgICAgIEtFWV9SSUdIVFNISUZULEtFWV9FTlRFUiwgICAgIEtFWV9SSUdIVEJSQUNFLEtFWV9CQUNLU0xBU0gsIEtFWV9CQUNLU0xBU0gsS0VZX0YxMiwgICAgICAgS0VZX1NDUk9MTExPQ0ssCisvKiA2MCAqLyAgS0VZX0RPV04sICAgICBDXzYxLCAgICAgICAgICBLRVlfUEFVU0UsICAgICBLRVlfVVAsICAgICAgICBLRVlfREVMRVRFLCAgICBLRVlfRU5ELCAgICAgIEtFWV9CQUNLU1BBQ0UsIEtFWV9JTlNFUlQsCisvKiA2OCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfS1AxLCAgICAgICBLRVlfUklHSFQsICAgICBLRVlfS1A0LCAgICAgICBLRVlfS1A3LCAgICAgICBLRVlfUEFHRURPV04sIEtFWV9IT01FLCAgICAgIEtFWV9QQUdFVVAsCisvKiA3MCAqLyAgS0VZX0tQMCwgICAgICBLRVlfS1BET1QsICAgICBLRVlfS1AyLCAgICAgICBLRVlfS1A1LCAgICAgICBLRVlfS1A2LCAgICAgICBLRVlfS1A4LCAgICAgIEtFWV9FU0MsICAgICAgIEtFWV9OVU1MT0NLLAorLyogNzggKi8gIEtFWV9GMTEsICAgICAgS0VZX0tQUExVUywgICAgS0VZX0tQMywgICAgICAgS0VZX0tQTUlOVVMsICAgS0VZX0tQQVNURVJJU0ssS0VZX0tQOSwgICAgICBLRVlfU0NST0xMTE9DSyxLRVlfMTAyTkQsCisvKiA4MCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDg4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogOTAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JJR0hUQUxULCAgMjU1LCAgICAgICAgICAgS0VZX1JFU0VSVkVELCAgS0VZX1JJR0hUQ1RSTCwgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiA5OCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfQ0FQU0xPQ0ssIEtFWV9SRVNFUlZFRCwgIEtFWV9MRUZUTUVUQSwKKy8qIGEwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JJR0hUTUVUQSwKKy8qIGE4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX0NPTVBPU0UsCisvKiBiMCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGI4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogYzAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiBjOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfS1BTTEFTSCwgICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGQwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogZDggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX0tQRU5URVIsICAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiBlMCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGU4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9FTkQsICAgICAgIEtFWV9SRVNFUlZFRCwgIEtFWV9MRUZULCAgICAgIEtFWV9IT01FLCAgICAgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogZjAgKi8gIEtFWV9JTlNFUlQsICAgS0VZX0RFTEVURSwgICAgS0VZX0RPV04sICAgICAgS0VZX1JFU0VSVkVELCAgS0VZX1JJR0hULCAgICAgS0VZX1VQLCAgICAgICBLRVlfUkVTRVJWRUQsICBLRVlfUEFVU0UsCisvKiBmOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUEFHRURPV04sICBLRVlfUkVTRVJWRUQsICBLRVlfU1lTUlEsICAgICBLRVlfUEFHRVVQLCAgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKworLyogVGhlc2UgYXJlIG9mZnNldCBmb3IgZXNjYXBlZCBrZXljb2RlczogKi8KKworLyogMDAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX0Y3LCAgICAgICAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiAwOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfTEVGVE1FVEEsICBLRVlfUklHSFRNRVRBLCBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDEwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SSUdIVEFMVCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SSUdIVENUUkwsIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogMTggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiAyMCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDI4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogMzAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiAzOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDQwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogNDggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiA1MCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDU4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogNjAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiA2OCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDcwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogNzggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiA4MCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIDg4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogOTAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiA5OCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGEwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogYTggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiBiMCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGI4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogYzAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiBjOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGQwICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogZDggKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiBlMCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwKKy8qIGU4ICovICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELAorLyogZjAgKi8gIEtFWV9SRVNFUlZFRCwgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsCisvKiBmOCAqLyAgS0VZX1JFU0VSVkVELCBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsICBLRVlfUkVTRVJWRUQsIEtFWV9SRVNFUlZFRCwgIEtFWV9SRVNFUlZFRAorCisjdW5kZWYgQ09ORkxJQ1QKKyN1bmRlZiBDXzA3CisjdW5kZWYgQ18xMQorI3VuZGVmIENfMTQKKyN1bmRlZiBDXzU4CisjdW5kZWYgQ182MQorCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2xra2JkLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2xra2JkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjY5NGZmMgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvbGtrYmQuYwpAQCAtMCwwICsxLDc1MiBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDQgYnkgSmFuLUJlbmVkaWN0IEdsYXcgPGpiZ2xhd0BsdWctb3dsLmRlPgorICovCisKKy8qCisgKiBMSyBrZXlib2FyZCBkcml2ZXIgZm9yIExpbnV4LCBiYXNlZCBvbiBzdW5rYmQuYyAoQykgYnkgVm9qdGVjaCBQYXZsaWsKKyAqLworCisvKgorICogREVDIExLMjAxIGFuZCBMSzQwMSBrZXlib2FyZCBkcml2ZXIgZm9yIExpbnV4IChwcmltYXJ5IGZvciBERUNzdGF0aW9ucworICogYW5kIFZBWHN0YXRpb25zLCBidXQgY2FuIGFsc28gYmUgdXNlZCBvbiBhbnkgc3RhbmRhcmQgUlMyMzIgd2l0aCBhbgorICogYWRhcHRvcikuCisgKgorICogRElTQ0xBSU1FUjogVGhpcyB3b3JrcyBmb3IgX21lXy4gSWYgeW91IGJyZWFrIGFueXRoaW5nIGJ5IHVzaW5nIHRoZQorICogaW5mb3JtYXRpb24gZ2l2ZW4gYmVsb3csIEkgd2lsbCBfbm90XyBiZSBsaWFibGUhCisgKgorICogUkoxMCBwaW5vdXQ6CQlUbyBERTk6CQlPciBEQjI1OgorICogCTEgLSBSeEQgPC0tLS0+CVBpbiAzIChUeEQpIDwtPglQaW4gMiAoVHhEKQorICogCTIgLSBHTkQgPC0tLS0+CVBpbiA1IChHTkQpIDwtPglQaW4gNyAoR05EKQorICogCTQgLSBUeEQgPC0tLS0+CVBpbiAyIChSeEQpIDwtPglQaW4gMyAoUnhEKQorICogCTMgLSArMTJWIChmcm9tIEhERCBkcml2ZSBjb25uZWN0b3IpLCBET04nVCBjb25uZWN0IHRvIERFOSBvciBEQjI1ISEhCisgKgorICogUGluIG51bWJlcnMgZm9yIERFOSBhbmQgREIyNSBhcmUgbm90ZWQgb24gdGhlIHBsdWcgKHF1aXRlIHNtYWxsOikuIEZvcgorICogUkoxMCwgaXQncyBsaWtlIHRoaXM6CisgKgorICogICAgICBfXz1fXwlIb2xkIHRoZSBwbHVnIGluIGZyb250IG9mIHlvdSwgY2FibGUgZG93bndhcmRzLAorICogICAgIC9fX18vfAlub3NlIGlzIGhpZGRlbiBiZWhpbmQgdGhlIHBsdWcuIE5vdywgcGluIDEgaXMgYXQKKyAqICAgIHwxMjM0fHwJdGhlIGxlZnQgc2lkZSwgcGluIDQgYXQgdGhlIHJpZ2h0IGFuZCAyIGFuZCAzIGFyZQorICogICAgfElJSUl8fAlpbiBiZXR3ZWVuLCBvZiBjb3Vyc2U6KQorICogICAgfCAgICB8fAorICogICAgfF9fX198LworICogICAgICB8fAlTbyB0aGUgYWRhcHRvciBjb25zaXN0cyBvZiB0aHJlZSBjb25uZWN0ZWQgY2FibGVzCisgKiAgICAgIHx8CWZvciBkYXRhIHRyYW5zbWlzc2lvbiAoUnhEIGFuZCBUeEQpIGFuZCBzaWduYWwgZ3JvdW5kLgorICoJCUFkZGl0aW9uYWxseSwgeW91IGhhdmUgdG8gZ2V0ICsxMlYgZnJvbSBzb21ld2hlcmUuCisgKiBNb3N0IGVhc2lseSwgeW91J2xsIGdldCB0aGF0IGZyb20gYSBmbG9wcHkgb3IgSEREIHBvd2VyIGNvbm5lY3Rvci4KKyAqIEl0J3MgdGhlIHllbGxvdyBjYWJsZSB0aGVyZSAoYmxhY2sgaXMgZ3JvdW5kIGFuZCByZWQgaXMgKzVWKS4KKyAqCisgKiBUaGUga2V5Ym9hcmQgYW5kIGFsbCB0aGUgY29tbWFuZHMgaXQgdW5kZXJzdGFuZHMgYXJlIGRvY3VtZW50ZWQgaW4KKyAqICJWQ0IwMiBWaWRlbyBTdWJzeXN0ZW0gLSBUZWNobmljYWwgTWFudWFsIiwgRUstMTA0QUEtVE0tMDAxLiBUaGlzCisgKiBkb2N1bWVudCBpcyBMSzIwMSBzcGVjaWZpYywgYnV0IExLNDAxIGlzIG1vc3RseSBjb21wYXRpYmxlLiBJdCBjb21lcworICogdXAgaW4gTEsyMDEgbW9kZSBhbmQgZG9lc24ndCByZXBvcnQgYW55IG9mIHRoZSBhZGRpdGlvbmFsIGtleXMgaXQKKyAqIGhhcy4gVGhlc2UgbmVlZCB0byBiZSBzd2l0Y2hlZCBvbiB3aXRoIHRoZSBMS19DTURfRU5BQkxFX0xLNDAxCisgKiBjb21tYW5kLiBZb3UnbGwgZmluZCB0aGlzIGRvY3VtZW50IChzY2FubmVkIC5wZGYgZmlsZSkgb24gTUFOWCwKKyAqIGEgc2VhcmNoIGVuZ2luZSBzcGVjaWZpYyB0byBERUMgZG9jdW1lbnRhdGlvbi4gVHJ5CisgKiBodHRwOi8vd3d3LnZ0MTAwLm5ldC9tYW54L2RldGFpbHM/cG49RUstMTA0QUEtVE0tMDAxO2lkPTIxO2NwPTEKKyAqLworCisvKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKiBTaG91bGQgeW91IG5lZWQgdG8gY29udGFjdCBtZSwgdGhlIGF1dGhvciwgeW91IGNhbiBkbyBzbyBlaXRoZXIgYnkKKyAqIGVtYWlsIG9yIGJ5IHBhcGVyIG1haWw6CisgKiBKYW4tQmVuZWRpY3QgR2xhdywgTGlsaWVuc3RyYd9lIDE2LCAzMzc5MCBI9nJzdGUgKG5lYXIgSGFsbGUvV2VzdGYuKSwKKyAqIEdlcm1hbnkuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+CisjaW5jbHVkZSA8bGludXgvc2VyaW8uaD4KKyNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KKworI2RlZmluZSBEUklWRVJfREVTQwkiTEsga2V5Ym9hcmQgZHJpdmVyIgorCitNT0RVTEVfQVVUSE9SICgiSmFuLUJlbmVkaWN0IEdsYXcgPGpiZ2xhd0BsdWctb3dsLmRlPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OIChEUklWRVJfREVTQyk7CitNT0RVTEVfTElDRU5TRSAoIkdQTCIpOworCisvKgorICogS25vd24gcGFyYW1ldGVyczoKKyAqCWJlbGxfdm9sdW1lCisgKglrZXljbGlja192b2x1bWUKKyAqCWN0cmxjbGlja192b2x1bWUKKyAqCisgKiBQbGVhc2Ugbm90aWNlIHRoYXQgdGhlcmUncyBub3QgeWV0IGFuIEFQSSB0byBzZXQgdGhlc2UgYXQgcnVudGltZS4KKyAqLworc3RhdGljIGludCBiZWxsX3ZvbHVtZSA9IDEwMDsgLyogJSAqLworbW9kdWxlX3BhcmFtIChiZWxsX3ZvbHVtZSwgaW50LCAwKTsKK01PRFVMRV9QQVJNX0RFU0MgKGJlbGxfdm9sdW1lLCAiQmVsbCB2b2x1bWUgKGluICUpLiBkZWZhdWx0IGlzIDEwMCUiKTsKKworc3RhdGljIGludCBrZXljbGlja192b2x1bWUgPSAxMDA7IC8qICUgKi8KK21vZHVsZV9wYXJhbSAoa2V5Y2xpY2tfdm9sdW1lLCBpbnQsIDApOworTU9EVUxFX1BBUk1fREVTQyAoa2V5Y2xpY2tfdm9sdW1lLCAiS2V5Y2xpY2sgdm9sdW1lIChpbiAlKSwgZGVmYXVsdCBpcyAxMDAlIik7CisKK3N0YXRpYyBpbnQgY3RybGNsaWNrX3ZvbHVtZSA9IDEwMDsgLyogJSAqLworbW9kdWxlX3BhcmFtIChjdHJsY2xpY2tfdm9sdW1lLCBpbnQsIDApOworTU9EVUxFX1BBUk1fREVTQyAoY3RybGNsaWNrX3ZvbHVtZSwgIkN0cmxjbGljayB2b2x1bWUgKGluICUpLCBkZWZhdWx0IGlzIDEwMCUiKTsKKworc3RhdGljIGludCBsazIwMV9jb21wb3NlX2lzX2FsdCA9IDA7Cittb2R1bGVfcGFyYW0gKGxrMjAxX2NvbXBvc2VfaXNfYWx0LCBpbnQsIDApOworTU9EVUxFX1BBUk1fREVTQyAobGsyMDFfY29tcG9zZV9pc19hbHQsICJJZiBzZXQgbm9uLXplcm8sIExLMjAxJyBDb21wb3NlIGtleSAiCisJCSJ3aWxsIGFjdCBhcyBhbiBBbHQga2V5Iik7CisKKworCisjdW5kZWYgTEtLQkRfREVCVUcKKyNpZmRlZiBMS0tCRF9ERUJVRworI2RlZmluZSBEQkcoeC4uLikgcHJpbnRrICh4KQorI2Vsc2UKKyNkZWZpbmUgREJHKHguLi4pIGRvIHt9IHdoaWxlICgwKQorI2VuZGlmCisKKy8qIExFRCBjb250cm9sICovCisjZGVmaW5lIExLX0xFRF9XQUlUCQkweDgxCisjZGVmaW5lIExLX0xFRF9DT01QT1NFCQkweDgyCisjZGVmaW5lIExLX0xFRF9TSElGVExPQ0sJMHg4NAorI2RlZmluZSBMS19MRURfU0NST0xMTE9DSwkweDg4CisjZGVmaW5lIExLX0NNRF9MRURfT04JCTB4MTMKKyNkZWZpbmUgTEtfQ01EX0xFRF9PRkYJCTB4MTEKKworLyogTW9kZSBjb250cm9sICovCisjZGVmaW5lIExLX01PREVfRE9XTgkJMHg4MAorI2RlZmluZSBMS19NT0RFX0FVVE9ET1dOCTB4ODIKKyNkZWZpbmUgTEtfTU9ERV9VUERPV04JCTB4ODYKKyNkZWZpbmUgTEtfQ01EX1NFVF9NT0RFKG1vZGUsZGl2KQkoKG1vZGUpIHwgKChkaXYpIDw8IDMpKQorCisvKiBNaXNjIGNvbW1hbmRzICovCisjZGVmaW5lIExLX0NNRF9FTkFCTEVfS0VZQ0xJQ0sJMHgxYgorI2RlZmluZSBMS19DTURfRElTQUJMRV9LRVlDTElDSwkweDk5CisjZGVmaW5lIExLX0NNRF9ESVNBQkxFX0JFTEwJMHhhMQorI2RlZmluZSBMS19DTURfU09VTkRfQkVMTAkweGE3CisjZGVmaW5lIExLX0NNRF9FTkFCTEVfQkVMTAkweDIzCisjZGVmaW5lIExLX0NNRF9ESVNBQkxFX0NUUkNMSUNLCTB4YjkKKyNkZWZpbmUgTEtfQ01EX0VOQUJMRV9DVFJDTElDSwkweGJiCisjZGVmaW5lIExLX0NNRF9TRVRfREVGQVVMVFMJMHhkMworI2RlZmluZSBMS19DTURfUE9XRVJDWUNMRV9SRVNFVAkweGZkCisjZGVmaW5lIExLX0NNRF9FTkFCTEVfTEs0MDEJMHhlOQorI2RlZmluZSBMS19DTURfUkVRVUVTVF9JRAkweGFiCisKKy8qIE1pc2MgcmVzcG9uc2VzIGZyb20ga2V5Ym9hcmQgKi8KKyNkZWZpbmUgTEtfU1RVQ0tfS0VZCQkweDNkCisjZGVmaW5lIExLX1NFTEZURVNUX0ZBSUxFRAkweDNlCisjZGVmaW5lIExLX0FMTF9LRVlTX1VQCQkweGIzCisjZGVmaW5lIExLX01FVFJPTk9NRQkJMHhiNAorI2RlZmluZSBMS19PVVRQVVRfRVJST1IJCTB4YjUKKyNkZWZpbmUgTEtfSU5QVVRfRVJST1IJCTB4YjYKKyNkZWZpbmUgTEtfS0JEX0xPQ0tFRAkJMHhiNworI2RlZmluZSBMS19LQkRfVEVTVF9NT0RFX0FDSwkweGI4CisjZGVmaW5lIExLX1BSRUZJWF9LRVlfRE9XTgkweGI5CisjZGVmaW5lIExLX01PREVfQ0hBTkdFX0FDSwkweGJhCisjZGVmaW5lIExLX1JFU1BPTlNFX1JFU0VSVkVECTB4YmIKKworI2RlZmluZSBMS19OVU1fS0VZQ09ERVMJCTI1NgorI2RlZmluZSBMS19OVU1fSUdOT1JFX0JZVEVTCTYKK3R5cGVkZWYgdV9pbnQxNl90IGxrX2tleWNvZGVfdDsKKworCisKK3N0YXRpYyBsa19rZXljb2RlX3QgbGtrYmRfa2V5Y29kZVtMS19OVU1fS0VZQ09ERVNdID0geworCVsweDU2XSA9IEtFWV9GMSwKKwlbMHg1N10gPSBLRVlfRjIsCisJWzB4NThdID0gS0VZX0YzLAorCVsweDU5XSA9IEtFWV9GNCwKKwlbMHg1YV0gPSBLRVlfRjUsCisJWzB4NjRdID0gS0VZX0Y2LAorCVsweDY1XSA9IEtFWV9GNywKKwlbMHg2Nl0gPSBLRVlfRjgsCisJWzB4NjddID0gS0VZX0Y5LAorCVsweDY4XSA9IEtFWV9GMTAsCisJWzB4NzFdID0gS0VZX0YxMSwKKwlbMHg3Ml0gPSBLRVlfRjEyLAorCVsweDczXSA9IEtFWV9GMTMsCisJWzB4NzRdID0gS0VZX0YxNCwKKwlbMHg3Y10gPSBLRVlfRjE1LAorCVsweDdkXSA9IEtFWV9GMTYsCisJWzB4ODBdID0gS0VZX0YxNywKKwlbMHg4MV0gPSBLRVlfRjE4LAorCVsweDgyXSA9IEtFWV9GMTksCisJWzB4ODNdID0gS0VZX0YyMCwKKwlbMHg4YV0gPSBLRVlfRklORCwKKwlbMHg4Yl0gPSBLRVlfSU5TRVJULAorCVsweDhjXSA9IEtFWV9ERUxFVEUsCisJWzB4OGRdID0gS0VZX1NFTEVDVCwKKwlbMHg4ZV0gPSBLRVlfUEFHRVVQLAorCVsweDhmXSA9IEtFWV9QQUdFRE9XTiwKKwlbMHg5Ml0gPSBLRVlfS1AwLAorCVsweDk0XSA9IEtFWV9LUERPVCwKKwlbMHg5NV0gPSBLRVlfS1BFTlRFUiwKKwlbMHg5Nl0gPSBLRVlfS1AxLAorCVsweDk3XSA9IEtFWV9LUDIsCisJWzB4OThdID0gS0VZX0tQMywKKwlbMHg5OV0gPSBLRVlfS1A0LAorCVsweDlhXSA9IEtFWV9LUDUsCisJWzB4OWJdID0gS0VZX0tQNiwKKwlbMHg5Y10gPSBLRVlfS1BDT01NQSwKKwlbMHg5ZF0gPSBLRVlfS1A3LAorCVsweDllXSA9IEtFWV9LUDgsCisJWzB4OWZdID0gS0VZX0tQOSwKKwlbMHhhMF0gPSBLRVlfS1BNSU5VUywKKwlbMHhhMV0gPSBLRVlfUFJPRzEsCisJWzB4YTJdID0gS0VZX1BST0cyLAorCVsweGEzXSA9IEtFWV9QUk9HMywKKwlbMHhhNF0gPSBLRVlfUFJPRzQsCisJWzB4YTddID0gS0VZX0xFRlQsCisJWzB4YThdID0gS0VZX1JJR0hULAorCVsweGE5XSA9IEtFWV9ET1dOLAorCVsweGFhXSA9IEtFWV9VUCwKKwlbMHhhYl0gPSBLRVlfUklHSFRTSElGVCwKKwlbMHhhY10gPSBLRVlfTEVGVEFMVCwKKwlbMHhhZF0gPSBLRVlfQ09NUE9TRSwgLyogUmlnaHQgQ29tcG9zZSwgdGhhdCBpcy4gKi8KKwlbMHhhZV0gPSBLRVlfTEVGVFNISUZULCAvKiBTYW1lIGFzIEtFWV9SSUdIVFNISUZUIG9uIExLMjAxICovCisJWzB4YWZdID0gS0VZX0xFRlRDVFJMLAorCVsweGIwXSA9IEtFWV9DQVBTTE9DSywKKwlbMHhiMV0gPSBLRVlfQ09NUE9TRSwgLyogTGVmdCBDb21wb3NlLCB0aGF0IGlzLiAqLworCVsweGIyXSA9IEtFWV9SSUdIVEFMVCwKKwlbMHhiY10gPSBLRVlfQkFDS1NQQUNFLAorCVsweGJkXSA9IEtFWV9FTlRFUiwKKwlbMHhiZV0gPSBLRVlfVEFCLAorCVsweGJmXSA9IEtFWV9FU0MsCisJWzB4YzBdID0gS0VZXzEsCisJWzB4YzFdID0gS0VZX1EsCisJWzB4YzJdID0gS0VZX0EsCisJWzB4YzNdID0gS0VZX1osCisJWzB4YzVdID0gS0VZXzIsCisJWzB4YzZdID0gS0VZX1csCisJWzB4YzddID0gS0VZX1MsCisJWzB4YzhdID0gS0VZX1gsCisJWzB4YzldID0gS0VZXzEwMk5ELAorCVsweGNiXSA9IEtFWV8zLAorCVsweGNjXSA9IEtFWV9FLAorCVsweGNkXSA9IEtFWV9ELAorCVsweGNlXSA9IEtFWV9DLAorCVsweGQwXSA9IEtFWV80LAorCVsweGQxXSA9IEtFWV9SLAorCVsweGQyXSA9IEtFWV9GLAorCVsweGQzXSA9IEtFWV9WLAorCVsweGQ0XSA9IEtFWV9TUEFDRSwKKwlbMHhkNl0gPSBLRVlfNSwKKwlbMHhkN10gPSBLRVlfVCwKKwlbMHhkOF0gPSBLRVlfRywKKwlbMHhkOV0gPSBLRVlfQiwKKwlbMHhkYl0gPSBLRVlfNiwKKwlbMHhkY10gPSBLRVlfWSwKKwlbMHhkZF0gPSBLRVlfSCwKKwlbMHhkZV0gPSBLRVlfTiwKKwlbMHhlMF0gPSBLRVlfNywKKwlbMHhlMV0gPSBLRVlfVSwKKwlbMHhlMl0gPSBLRVlfSiwKKwlbMHhlM10gPSBLRVlfTSwKKwlbMHhlNV0gPSBLRVlfOCwKKwlbMHhlNl0gPSBLRVlfSSwKKwlbMHhlN10gPSBLRVlfSywKKwlbMHhlOF0gPSBLRVlfQ09NTUEsCisJWzB4ZWFdID0gS0VZXzksCisJWzB4ZWJdID0gS0VZX08sCisJWzB4ZWNdID0gS0VZX0wsCisJWzB4ZWRdID0gS0VZX0RPVCwKKwlbMHhlZl0gPSBLRVlfMCwKKwlbMHhmMF0gPSBLRVlfUCwKKwlbMHhmMl0gPSBLRVlfU0VNSUNPTE9OLAorCVsweGYzXSA9IEtFWV9TTEFTSCwKKwlbMHhmNV0gPSBLRVlfRVFVQUwsCisJWzB4ZjZdID0gS0VZX1JJR0hUQlJBQ0UsCisJWzB4ZjddID0gS0VZX0JBQ0tTTEFTSCwKKwlbMHhmOV0gPSBLRVlfTUlOVVMsCisJWzB4ZmFdID0gS0VZX0xFRlRCUkFDRSwKKwlbMHhmYl0gPSBLRVlfQVBPU1RST1BIRSwKK307CisKKyNkZWZpbmUgQ0hFQ0tfTEVEKExFRCwgQklUUykgZG8gewkJXAorCWlmICh0ZXN0X2JpdCAoTEVELCBsay0+ZGV2LmxlZCkpCVwKKwkJbGVkc19vbiB8PSBCSVRTOwkJXAorCWVsc2UJCQkJCVwKKwkJbGVkc19vZmYgfD0gQklUUzsJCVwKKwl9IHdoaWxlICgwKQorCisvKgorICogUGVyLWtleWJvYXJkIGRhdGEKKyAqLworc3RydWN0IGxra2JkIHsKKwlsa19rZXljb2RlX3Qga2V5Y29kZVtMS19OVU1fS0VZQ09ERVNdOworCWludCBpZ25vcmVfYnl0ZXM7CisJdW5zaWduZWQgY2hhciBpZFtMS19OVU1fSUdOT1JFX0JZVEVTXTsKKwlzdHJ1Y3QgaW5wdXRfZGV2IGRldjsKKwlzdHJ1Y3Qgc2VyaW8gKnNlcmlvOworCXN0cnVjdCB3b3JrX3N0cnVjdCB0cTsKKwljaGFyIG5hbWVbNjRdOworCWNoYXIgcGh5c1szMl07CisJY2hhciB0eXBlOworCWludCBiZWxsX3ZvbHVtZTsKKwlpbnQga2V5Y2xpY2tfdm9sdW1lOworCWludCBjdHJsY2xpY2tfdm9sdW1lOworfTsKKworLyoKKyAqIENhbGN1bGF0ZSB2b2x1bWUgcGFyYW1ldGVyIGJ5dGUgZm9yIGEgZ2l2ZW4gdm9sdW1lLgorICovCitzdGF0aWMgdW5zaWduZWQgY2hhcgordm9sdW1lX3RvX2h3IChpbnQgdm9sdW1lX3BlcmNlbnQpCit7CisJdW5zaWduZWQgY2hhciByZXQgPSAwOworCisJaWYgKHZvbHVtZV9wZXJjZW50IDwgMCkKKwkJdm9sdW1lX3BlcmNlbnQgPSAwOworCWlmICh2b2x1bWVfcGVyY2VudCA+IDEwMCkKKwkJdm9sdW1lX3BlcmNlbnQgPSAxMDA7CisKKwlpZiAodm9sdW1lX3BlcmNlbnQgPj0gMCkKKwkJcmV0ID0gNzsKKwlpZiAodm9sdW1lX3BlcmNlbnQgPj0gMTMpCS8qIDEyLjUgKi8KKwkJcmV0ID0gNjsKKwlpZiAodm9sdW1lX3BlcmNlbnQgPj0gMjUpCisJCXJldCA9IDU7CisJaWYgKHZvbHVtZV9wZXJjZW50ID49IDM4KQkvKiAzNy41ICovCisJCXJldCA9IDQ7CisJaWYgKHZvbHVtZV9wZXJjZW50ID49IDUwKQorCQlyZXQgPSAzOworCWlmICh2b2x1bWVfcGVyY2VudCA+PSA2MykJLyogNjIuNSAqLworCQlyZXQgPSAyOwkJLyogVGhpcyBpcyB0aGUgZGVmYXVsdCB2b2x1bWUgKi8KKwlpZiAodm9sdW1lX3BlcmNlbnQgPj0gNzUpCisJCXJldCA9IDE7CisJaWYgKHZvbHVtZV9wZXJjZW50ID49IDg4KQkvKiA4Ny41ICovCisJCXJldCA9IDA7CisKKwlyZXQgfD0gMHg4MDsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkCitsa2tiZF9kZXRlY3Rpb25fZG9uZSAoc3RydWN0IGxra2JkICpsaykKK3sKKwlpbnQgaTsKKworCS8qCisJICogUmVzZXQgc2V0dGluZyBmb3IgQ29tcG9zZSBrZXkuIExldCBDb21wb3NlIGJlIEtFWV9DT01QT1NFLgorCSAqLworCWxrLT5rZXljb2RlWzB4YjFdID0gS0VZX0NPTVBPU0U7CisKKwkvKgorCSAqIFByaW50IGtleWJvYXJkIG5hbWUgYW5kIG1vZGlmeSBDb21wb3NlPUFsdCBvbiB1c2VyJ3MgcmVxdWVzdC4KKwkgKi8KKwlzd2l0Y2ggKGxrLT5pZFs0XSkgeworCQljYXNlIDE6CisJCQlzcHJpbnRmIChsay0+bmFtZSwgIkRFQyBMSzIwMSBrZXlib2FyZCIpOworCisJCQlpZiAobGsyMDFfY29tcG9zZV9pc19hbHQpCisJCQkJbGstPmtleWNvZGVbMHhiMV0gPSBLRVlfTEVGVEFMVDsKKwkJCWJyZWFrOworCisJCWNhc2UgMjoKKwkJCXNwcmludGYgKGxrLT5uYW1lLCAiREVDIExLNDAxIGtleWJvYXJkIik7CisJCQlicmVhazsKKworCQlkZWZhdWx0OgorCQkJc3ByaW50ZiAobGstPm5hbWUsICJVbmtub3duIERFQyBrZXlib2FyZCIpOworCQkJcHJpbnRrIChLRVJOX0VSUiAibGtrYmQ6IGtleWJvYXJkIG9uICVzIGlzIHVua25vd24sICIKKwkJCQkJInBsZWFzZSByZXBvcnQgdG8gSmFuLUJlbmVkaWN0IEdsYXcgIgorCQkJCQkiPGpiZ2xhd0BsdWctb3dsLmRlPlxuIiwgbGstPnBoeXMpOworCQkJcHJpbnRrIChLRVJOX0VSUiAibGtrYmQ6IGtleWJvYXJkIElEJ2VkIGFzOiIpOworCQkJZm9yIChpID0gMDsgaSA8IExLX05VTV9JR05PUkVfQllURVM7IGkrKykKKwkJCQlwcmludGsgKCIgMHglMDJ4IiwgbGstPmlkW2ldKTsKKwkJCXByaW50ayAoIlxuIik7CisJCQlicmVhazsKKwl9CisJcHJpbnRrIChLRVJOX0lORk8gImxra2JkOiBrZXlib2FyZCBvbiAlcyBpZGVudGlmaWVkIGFzOiAlc1xuIiwKKwkJCWxrLT5waHlzLCBsay0+bmFtZSk7CisKKwkvKgorCSAqIFJlcG9ydCBlcnJvcnMgZHVyaW5nIGtleWJvYXJkIGJvb3QtdXAuCisJICovCisJc3dpdGNoIChsay0+aWRbMl0pIHsKKwkJY2FzZSAweDAwOgorCQkJLyogQWxsIG9rYXkgKi8KKwkJCWJyZWFrOworCisJCWNhc2UgTEtfU1RVQ0tfS0VZOgorCQkJcHJpbnRrIChLRVJOX0VSUiAibGtrYmQ6IFN0dWNrIGtleSBvbiBrZXlib2FyZCBhdCAiCisJCQkJCSIlc1xuIiwgbGstPnBoeXMpOworCQkJYnJlYWs7CisKKwkJY2FzZSBMS19TRUxGVEVTVF9GQUlMRUQ6CisJCQlwcmludGsgKEtFUk5fRVJSICJsa2tiZDogU2VsZnRlc3QgZmFpbGVkIG9uIGtleWJvYXJkICIKKwkJCQkJImF0ICVzLCBrZXlib2FyZCBtYXkgbm90IHdvcmsgIgorCQkJCQkicHJvcGVybHlcbiIsIGxrLT5waHlzKTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQlwcmludGsgKEtFUk5fRVJSICJsa2tiZDogVW5rbm93biBlcnJvciAlMDJ4IG9uICIKKwkJCQkJImtleWJvYXJkIGF0ICVzXG4iLCBsay0+aWRbMl0sCisJCQkJCWxrLT5waHlzKTsKKwkJCWJyZWFrOworCX0KKworCS8qCisJICogVHJ5IHRvIGhpbnQgdXNlciBpZiB0aGVyZSdzIGEgc3R1Y2sga2V5LgorCSAqLworCWlmIChsay0+aWRbMl0gPT0gTEtfU1RVQ0tfS0VZICYmIGxrLT5pZFszXSAhPSAwKQorCQlwcmludGsgKEtFUk5fRVJSICJTY2FuY29kZSBvZiBzdHVjayBrZXkgaXMgMHglMDJ4LCBrZXljb2RlICIKKwkJCQkiaXMgMHglMDR4XG4iLCBsay0+aWRbM10sCisJCQkJbGstPmtleWNvZGVbbGstPmlkWzNdXSk7CisKKwlyZXR1cm47Cit9CisKKy8qCisgKiBsa2tiZF9pbnRlcnJ1cHQoKSBpcyBjYWxsZWQgYnkgdGhlIGxvdyBsZXZlbCBkcml2ZXIgd2hlbiBhIGNoYXJhY3RlcgorICogaXMgcmVjZWl2ZWQuCisgKi8KK3N0YXRpYyBpcnFyZXR1cm5fdAorbGtrYmRfaW50ZXJydXB0IChzdHJ1Y3Qgc2VyaW8gKnNlcmlvLCB1bnNpZ25lZCBjaGFyIGRhdGEsIHVuc2lnbmVkIGludCBmbGFncywKKwkJc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IGxra2JkICpsayA9IHNlcmlvX2dldF9kcnZkYXRhIChzZXJpbyk7CisJaW50IGk7CisKKwlEQkcgKEtFUk5fSU5GTyAiR290IGJ5dGUgMHglMDJ4XG4iLCBkYXRhKTsKKworCWlmIChsay0+aWdub3JlX2J5dGVzID4gMCkgeworCQlEQkcgKEtFUk5fSU5GTyAiSWdub3JpbmcgYSBieXRlIG9uICVzXG4iLAorCQkJCWxrLT5uYW1lKTsKKwkJbGstPmlkW0xLX05VTV9JR05PUkVfQllURVMgLSBsay0+aWdub3JlX2J5dGVzLS1dID0gZGF0YTsKKworCQlpZiAobGstPmlnbm9yZV9ieXRlcyA9PSAwKQorCQkJbGtrYmRfZGV0ZWN0aW9uX2RvbmUgKGxrKTsKKworCQlyZXR1cm4gSVJRX0hBTkRMRUQ7CisJfQorCisJc3dpdGNoIChkYXRhKSB7CisJCWNhc2UgTEtfQUxMX0tFWVNfVVA6CisJCQlpbnB1dF9yZWdzICgmbGstPmRldiwgcmVncyk7CisJCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSAobGtrYmRfa2V5Y29kZSk7IGkrKykKKwkJCQlpZiAobGstPmtleWNvZGVbaV0gIT0gS0VZX1JFU0VSVkVEKQorCQkJCQlpbnB1dF9yZXBvcnRfa2V5ICgmbGstPmRldiwgbGstPmtleWNvZGVbaV0sIDApOworCQkJaW5wdXRfc3luYyAoJmxrLT5kZXYpOworCQkJYnJlYWs7CisJCWNhc2UgTEtfTUVUUk9OT01FOgorCQkJREJHIChLRVJOX0lORk8gIkdvdCBMS19NRVRST05PTUUgYW5kIGRvbid0ICIKKwkJCQkJImtub3cgaG93IHRvIGhhbmRsZS4uLlxuIik7CisJCQlicmVhazsKKwkJY2FzZSBMS19PVVRQVVRfRVJST1I6CisJCQlEQkcgKEtFUk5fSU5GTyAiR290IExLX09VVFBVVF9FUlJPUiBhbmQgZG9uJ3QgIgorCQkJCQkia25vdyBob3cgdG8gaGFuZGxlLi4uXG4iKTsKKwkJCWJyZWFrOworCQljYXNlIExLX0lOUFVUX0VSUk9SOgorCQkJREJHIChLRVJOX0lORk8gIkdvdCBMS19JTlBVVF9FUlJPUiBhbmQgZG9uJ3QgIgorCQkJCQkia25vdyBob3cgdG8gaGFuZGxlLi4uXG4iKTsKKwkJCWJyZWFrOworCQljYXNlIExLX0tCRF9MT0NLRUQ6CisJCQlEQkcgKEtFUk5fSU5GTyAiR290IExLX0tCRF9MT0NLRUQgYW5kIGRvbid0ICIKKwkJCQkJImtub3cgaG93IHRvIGhhbmRsZS4uLlxuIik7CisJCQlicmVhazsKKwkJY2FzZSBMS19LQkRfVEVTVF9NT0RFX0FDSzoKKwkJCURCRyAoS0VSTl9JTkZPICJHb3QgTEtfS0JEX1RFU1RfTU9ERV9BQ0sgYW5kIGRvbid0ICIKKwkJCQkJImtub3cgaG93IHRvIGhhbmRsZS4uLlxuIik7CisJCQlicmVhazsKKwkJY2FzZSBMS19QUkVGSVhfS0VZX0RPV046CisJCQlEQkcgKEtFUk5fSU5GTyAiR290IExLX1BSRUZJWF9LRVlfRE9XTiBhbmQgZG9uJ3QgIgorCQkJCQkia25vdyBob3cgdG8gaGFuZGxlLi4uXG4iKTsKKwkJCWJyZWFrOworCQljYXNlIExLX01PREVfQ0hBTkdFX0FDSzoKKwkJCURCRyAoS0VSTl9JTkZPICJHb3QgTEtfTU9ERV9DSEFOR0VfQUNLIGFuZCBpZ25vcmVkICIKKwkJCQkJIml0IHByb3Blcmx5Li4uXG4iKTsKKwkJCWJyZWFrOworCQljYXNlIExLX1JFU1BPTlNFX1JFU0VSVkVEOgorCQkJREJHIChLRVJOX0lORk8gIkdvdCBMS19SRVNQT05TRV9SRVNFUlZFRCBhbmQgZG9uJ3QgIgorCQkJCQkia25vdyBob3cgdG8gaGFuZGxlLi4uXG4iKTsKKwkJCWJyZWFrOworCQljYXNlIDB4MDE6CisJCQlEQkcgKEtFUk5fSU5GTyAiR290IDB4MDEsIHNjaGVkdWxpbmcgcmUtaW5pdGlhbGl6YXRpb25cbiIpOworCQkJbGstPmlnbm9yZV9ieXRlcyA9IExLX05VTV9JR05PUkVfQllURVM7CisJCQlsay0+aWRbTEtfTlVNX0lHTk9SRV9CWVRFUyAtIGxrLT5pZ25vcmVfYnl0ZXMtLV0gPSBkYXRhOworCQkJc2NoZWR1bGVfd29yayAoJmxrLT50cSk7CisJCQlicmVhazsKKworCQlkZWZhdWx0OgorCQkJaWYgKGxrLT5rZXljb2RlW2RhdGFdICE9IEtFWV9SRVNFUlZFRCkgeworCQkJCWlucHV0X3JlZ3MgKCZsay0+ZGV2LCByZWdzKTsKKwkJCQlpZiAoIXRlc3RfYml0IChsay0+a2V5Y29kZVtkYXRhXSwgbGstPmRldi5rZXkpKQorCQkJCQlpbnB1dF9yZXBvcnRfa2V5ICgmbGstPmRldiwgbGstPmtleWNvZGVbZGF0YV0sIDEpOworCQkJCWVsc2UKKwkJCQkJaW5wdXRfcmVwb3J0X2tleSAoJmxrLT5kZXYsIGxrLT5rZXljb2RlW2RhdGFdLCAwKTsKKwkJCQlpbnB1dF9zeW5jICgmbGstPmRldik7CisgICAgICAgICAgICAgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJpbnRrIChLRVJOX1dBUk5JTkcgIiVzOiBVbmtub3duIGtleSB3aXRoICIKKwkJCQkJCSJzY2FuY29kZSAweCUwMnggb24gJXMuXG4iLAorCQkJCQkJX19GSUxFX18sIGRhdGEsIGxrLT5uYW1lKTsKKwl9CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKKy8qCisgKiBsa2tiZF9ldmVudCgpIGhhbmRsZXMgZXZlbnRzIGZyb20gdGhlIGlucHV0IG1vZHVsZS4KKyAqLworc3RhdGljIGludAorbGtrYmRfZXZlbnQgKHN0cnVjdCBpbnB1dF9kZXYgKmRldiwgdW5zaWduZWQgaW50IHR5cGUsIHVuc2lnbmVkIGludCBjb2RlLAorCQlpbnQgdmFsdWUpCit7CisJc3RydWN0IGxra2JkICpsayA9IGRldi0+cHJpdmF0ZTsKKwl1bnNpZ25lZCBjaGFyIGxlZHNfb24gPSAwOworCXVuc2lnbmVkIGNoYXIgbGVkc19vZmYgPSAwOworCisJc3dpdGNoICh0eXBlKSB7CisJCWNhc2UgRVZfTEVEOgorCQkJQ0hFQ0tfTEVEIChMRURfQ0FQU0wsIExLX0xFRF9TSElGVExPQ0spOworCQkJQ0hFQ0tfTEVEIChMRURfQ09NUE9TRSwgTEtfTEVEX0NPTVBPU0UpOworCQkJQ0hFQ0tfTEVEIChMRURfU0NST0xMTCwgTEtfTEVEX1NDUk9MTExPQ0spOworCQkJQ0hFQ0tfTEVEIChMRURfU0xFRVAsIExLX0xFRF9XQUlUKTsKKwkJCWlmIChsZWRzX29uICE9IDApIHsKKwkJCQlsay0+c2VyaW8tPndyaXRlIChsay0+c2VyaW8sIExLX0NNRF9MRURfT04pOworCQkJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgbGVkc19vbik7CisJCQl9CisJCQlpZiAobGVkc19vZmYgIT0gMCkgeworCQkJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgTEtfQ01EX0xFRF9PRkYpOworCQkJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgbGVkc19vZmYpOworCQkJfQorCQkJcmV0dXJuIDA7CisKKwkJY2FzZSBFVl9TTkQ6CisJCQlzd2l0Y2ggKGNvZGUpIHsKKwkJCQljYXNlIFNORF9DTElDSzoKKwkJCQkJaWYgKHZhbHVlID09IDApIHsKKwkJCQkJCURCRyAoIiVzOiBEZWFjdGl2YXRpbmcga2V5IGNsaWNrc1xuIiwgX19GVU5DVElPTl9fKTsKKwkJCQkJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgTEtfQ01EX0RJU0FCTEVfS0VZQ0xJQ0spOworCQkJCQkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfRElTQUJMRV9DVFJDTElDSyk7CisJCQkJCX0gZWxzZSB7CisJCQkJCQlEQkcgKCIlczogQWN0aXZhdGluZyBrZXkgY2xpY2tzXG4iLCBfX0ZVTkNUSU9OX18pOworCQkJCQkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfRU5BQkxFX0tFWUNMSUNLKTsKKwkJCQkJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgdm9sdW1lX3RvX2h3IChsay0+a2V5Y2xpY2tfdm9sdW1lKSk7CisJCQkJCQlsay0+c2VyaW8tPndyaXRlIChsay0+c2VyaW8sIExLX0NNRF9FTkFCTEVfQ1RSQ0xJQ0spOworCQkJCQkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCB2b2x1bWVfdG9faHcgKGxrLT5jdHJsY2xpY2tfdm9sdW1lKSk7CisJCQkJCX0KKwkJCQkJcmV0dXJuIDA7CisKKwkJCQljYXNlIFNORF9CRUxMOgorCQkJCQlpZiAodmFsdWUgIT0gMCkKKwkJCQkJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgTEtfQ01EX1NPVU5EX0JFTEwpOworCisJCQkJCXJldHVybiAwOworCQkJfQorCQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJCXByaW50ayAoS0VSTl9FUlIgIiVzICgpOiBHb3QgdW5rbm93biB0eXBlICVkLCBjb2RlICVkLCB2YWx1ZSAlZFxuIiwKKwkJCQkJX19GVU5DVElPTl9fLCB0eXBlLCBjb2RlLCB2YWx1ZSk7CisJfQorCisJcmV0dXJuIC0xOworfQorCisvKgorICogbGtrYmRfcmVpbml0KCkgc2V0cyBsZWRzIGFuZCBiZWVwcyB0byBhIHN0YXRlIHRoZSBjb21wdXRlciByZW1lbWJlcnMgdGhleQorICogd2VyZSBpbi4KKyAqLworc3RhdGljIHZvaWQKK2xra2JkX3JlaW5pdCAodm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgbGtrYmQgKmxrID0gZGF0YTsKKwlpbnQgZGl2aXNpb247CisJdW5zaWduZWQgY2hhciBsZWRzX29uID0gMDsKKwl1bnNpZ25lZCBjaGFyIGxlZHNfb2ZmID0gMDsKKworCS8qIEFzayBmb3IgSUQgKi8KKwlsay0+c2VyaW8tPndyaXRlIChsay0+c2VyaW8sIExLX0NNRF9SRVFVRVNUX0lEKTsKKworCS8qIFJlc2V0IHBhcmFtZXRlcnMgKi8KKwlsay0+c2VyaW8tPndyaXRlIChsay0+c2VyaW8sIExLX0NNRF9TRVRfREVGQVVMVFMpOworCisJLyogU2V0IExFRHMgKi8KKwlDSEVDS19MRUQgKExFRF9DQVBTTCwgTEtfTEVEX1NISUZUTE9DSyk7CisJQ0hFQ0tfTEVEIChMRURfQ09NUE9TRSwgTEtfTEVEX0NPTVBPU0UpOworCUNIRUNLX0xFRCAoTEVEX1NDUk9MTEwsIExLX0xFRF9TQ1JPTExMT0NLKTsKKwlDSEVDS19MRUQgKExFRF9TTEVFUCwgTEtfTEVEX1dBSVQpOworCWlmIChsZWRzX29uICE9IDApIHsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfTEVEX09OKTsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBsZWRzX29uKTsKKwl9CisJaWYgKGxlZHNfb2ZmICE9IDApIHsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfTEVEX09GRik7CisJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgbGVkc19vZmYpOworCX0KKworCS8qCisJICogVHJ5IHRvIGFjdGl2YXRlIGV4dGVuZGVkIExLNDAxIG1vZGUuIFRoaXMgY29tbWFuZCB3aWxsCisJICogb25seSB3b3JrIHdpdGggYSBMSzQwMSBrZXlib2FyZCBhbmQgZ3JhbnRzIGFjY2VzcyB0bworCSAqIExBbHQsIFJBbHQsIFJDb21wb3NlIGFuZCBSU2hpZnQuCisJICovCisJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfRU5BQkxFX0xLNDAxKTsKKworCS8qIFNldCBhbGwga2V5cyB0byBVUERPV04gbW9kZSAqLworCWZvciAoZGl2aXNpb24gPSAxOyBkaXZpc2lvbiA8PSAxNDsgZGl2aXNpb24rKykKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfU0VUX01PREUgKExLX01PREVfVVBET1dOLAorCQkJCQlkaXZpc2lvbikpOworCisJLyogRW5hYmxlIGJlbGwgYW5kIHNldCB2b2x1bWUgKi8KKwlsay0+c2VyaW8tPndyaXRlIChsay0+c2VyaW8sIExLX0NNRF9FTkFCTEVfQkVMTCk7CisJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCB2b2x1bWVfdG9faHcgKGxrLT5iZWxsX3ZvbHVtZSkpOworCisJLyogRW5hYmxlL2Rpc2FibGUga2V5Y2xpY2sgKGFuZCBwb3NzaWJseSBzZXQgdm9sdW1lKSAqLworCWlmICh0ZXN0X2JpdCAoU05EX0NMSUNLLCBsay0+ZGV2LnNuZCkpIHsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfRU5BQkxFX0tFWUNMSUNLKTsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCB2b2x1bWVfdG9faHcgKGxrLT5rZXljbGlja192b2x1bWUpKTsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfRU5BQkxFX0NUUkNMSUNLKTsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCB2b2x1bWVfdG9faHcgKGxrLT5jdHJsY2xpY2tfdm9sdW1lKSk7CisJfSBlbHNlIHsKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfRElTQUJMRV9LRVlDTElDSyk7CisJCWxrLT5zZXJpby0+d3JpdGUgKGxrLT5zZXJpbywgTEtfQ01EX0RJU0FCTEVfQ1RSQ0xJQ0spOworCX0KKworCS8qIFNvdW5kIHRoZSBiZWxsIGlmIG5lZWRlZCAqLworCWlmICh0ZXN0X2JpdCAoU05EX0JFTEwsIGxrLT5kZXYuc25kKSkKKwkJbGstPnNlcmlvLT53cml0ZSAobGstPnNlcmlvLCBMS19DTURfU09VTkRfQkVMTCk7Cit9CisKKy8qCisgKiBsa2tiZF9jb25uZWN0KCkgcHJvYmVzIGZvciBhIExLIGtleWJvYXJkIGFuZCBmaWxscyB0aGUgbmVjZXNzYXJ5IHN0cnVjdHVyZXMuCisgKi8KK3N0YXRpYyBpbnQKK2xra2JkX2Nvbm5lY3QgKHN0cnVjdCBzZXJpbyAqc2VyaW8sIHN0cnVjdCBzZXJpb19kcml2ZXIgKmRydikKK3sKKwlzdHJ1Y3QgbGtrYmQgKmxrOworCWludCBpOworCWludCBlcnI7CisKKwlpZiAoIShsayA9IGttYWxsb2MgKHNpemVvZiAoc3RydWN0IGxra2JkKSwgR0ZQX0tFUk5FTCkpKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW1lbXNldCAobGssIDAsIHNpemVvZiAoc3RydWN0IGxra2JkKSk7CisKKwlpbml0X2lucHV0X2RldiAoJmxrLT5kZXYpOworCXNldF9iaXQgKEVWX0tFWSwgbGstPmRldi5ldmJpdCk7CisJc2V0X2JpdCAoRVZfTEVELCBsay0+ZGV2LmV2Yml0KTsKKwlzZXRfYml0IChFVl9TTkQsIGxrLT5kZXYuZXZiaXQpOworCXNldF9iaXQgKEVWX1JFUCwgbGstPmRldi5ldmJpdCk7CisJc2V0X2JpdCAoTEVEX0NBUFNMLCBsay0+ZGV2LmxlZGJpdCk7CisJc2V0X2JpdCAoTEVEX1NMRUVQLCBsay0+ZGV2LmxlZGJpdCk7CisJc2V0X2JpdCAoTEVEX0NPTVBPU0UsIGxrLT5kZXYubGVkYml0KTsKKwlzZXRfYml0IChMRURfU0NST0xMTCwgbGstPmRldi5sZWRiaXQpOworCXNldF9iaXQgKFNORF9CRUxMLCBsay0+ZGV2LnNuZGJpdCk7CisJc2V0X2JpdCAoU05EX0NMSUNLLCBsay0+ZGV2LnNuZGJpdCk7CisKKwlsay0+c2VyaW8gPSBzZXJpbzsKKworCUlOSVRfV09SSyAoJmxrLT50cSwgbGtrYmRfcmVpbml0LCBsayk7CisKKwlsay0+YmVsbF92b2x1bWUgPSBiZWxsX3ZvbHVtZTsKKwlsay0+a2V5Y2xpY2tfdm9sdW1lID0ga2V5Y2xpY2tfdm9sdW1lOworCWxrLT5jdHJsY2xpY2tfdm9sdW1lID0gY3RybGNsaWNrX3ZvbHVtZTsKKworCWxrLT5kZXYua2V5Y29kZSA9IGxrLT5rZXljb2RlOworCWxrLT5kZXYua2V5Y29kZXNpemUgPSBzaXplb2YgKGxrX2tleWNvZGVfdCk7CisJbGstPmRldi5rZXljb2RlbWF4ID0gTEtfTlVNX0tFWUNPREVTOworCisJbGstPmRldi5ldmVudCA9IGxra2JkX2V2ZW50OworCWxrLT5kZXYucHJpdmF0ZSA9IGxrOworCisJc2VyaW9fc2V0X2RydmRhdGEgKHNlcmlvLCBsayk7CisKKwllcnIgPSBzZXJpb19vcGVuIChzZXJpbywgZHJ2KTsKKwlpZiAoZXJyKSB7CisJCXNlcmlvX3NldF9kcnZkYXRhIChzZXJpbywgTlVMTCk7CisJCWtmcmVlIChsayk7CisJCXJldHVybiBlcnI7CisJfQorCisJc3ByaW50ZiAobGstPm5hbWUsICJERUMgTEsga2V5Ym9hcmQiKTsKKwlzcHJpbnRmIChsay0+cGh5cywgIiVzL2lucHV0MCIsIHNlcmlvLT5waHlzKTsKKworCW1lbWNweSAobGstPmtleWNvZGUsIGxra2JkX2tleWNvZGUsIHNpemVvZiAobGtfa2V5Y29kZV90KSAqIExLX05VTV9LRVlDT0RFUyk7CisJZm9yIChpID0gMDsgaSA8IExLX05VTV9LRVlDT0RFUzsgaSsrKQorCQlzZXRfYml0IChsay0+a2V5Y29kZVtpXSwgbGstPmRldi5rZXliaXQpOworCisJbGstPmRldi5uYW1lID0gbGstPm5hbWU7CisJbGstPmRldi5waHlzID0gbGstPnBoeXM7CisJbGstPmRldi5pZC5idXN0eXBlID0gQlVTX1JTMjMyOworCWxrLT5kZXYuaWQudmVuZG9yID0gU0VSSU9fTEtLQkQ7CisJbGstPmRldi5pZC5wcm9kdWN0ID0gMDsKKwlsay0+ZGV2LmlkLnZlcnNpb24gPSAweDAxMDA7CisJbGstPmRldi5kZXYgPSAmc2VyaW8tPmRldjsKKworCWlucHV0X3JlZ2lzdGVyX2RldmljZSAoJmxrLT5kZXYpOworCisJcHJpbnRrIChLRVJOX0lORk8gImlucHV0OiAlcyBvbiAlcywgaW5pdGlhdGluZyByZXNldFxuIiwgbGstPm5hbWUsIHNlcmlvLT5waHlzKTsKKwlsay0+c2VyaW8tPndyaXRlIChsay0+c2VyaW8sIExLX0NNRF9QT1dFUkNZQ0xFX1JFU0VUKTsKKworCXJldHVybiAwOworfQorCisvKgorICogbGtrYmRfZGlzY29ubmVjdCgpIHVucmVnaXN0ZXJzIGFuZCBjbG9zZXMgYmVoaW5kIHVzLgorICovCitzdGF0aWMgdm9pZAorbGtrYmRfZGlzY29ubmVjdCAoc3RydWN0IHNlcmlvICpzZXJpbykKK3sKKwlzdHJ1Y3QgbGtrYmQgKmxrID0gc2VyaW9fZ2V0X2RydmRhdGEgKHNlcmlvKTsKKworCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlICgmbGstPmRldik7CisJc2VyaW9fY2xvc2UgKHNlcmlvKTsKKwlzZXJpb19zZXRfZHJ2ZGF0YSAoc2VyaW8sIE5VTEwpOworCWtmcmVlIChsayk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2VyaW9fZGV2aWNlX2lkIGxra2JkX3NlcmlvX2lkc1tdID0geworCXsKKwkJLnR5cGUJPSBTRVJJT19SUzIzMiwKKwkJLnByb3RvCT0gU0VSSU9fTEtLQkQsCisJCS5pZAk9IFNFUklPX0FOWSwKKwkJLmV4dHJhCT0gU0VSSU9fQU5ZLAorCX0sCisJeyAwIH0KK307CisKK01PRFVMRV9ERVZJQ0VfVEFCTEUoc2VyaW8sIGxra2JkX3NlcmlvX2lkcyk7CisKK3N0YXRpYyBzdHJ1Y3Qgc2VyaW9fZHJpdmVyIGxra2JkX2RydiA9IHsKKwkuZHJpdmVyCQk9IHsKKwkJLm5hbWUJPSAibGtrYmQiLAorCX0sCisJLmRlc2NyaXB0aW9uCT0gRFJJVkVSX0RFU0MsCisJLmlkX3RhYmxlCT0gbGtrYmRfc2VyaW9faWRzLAorCS5jb25uZWN0CT0gbGtrYmRfY29ubmVjdCwKKwkuZGlzY29ubmVjdAk9IGxra2JkX2Rpc2Nvbm5lY3QsCisJLmludGVycnVwdAk9IGxra2JkX2ludGVycnVwdCwKK307CisKKy8qCisgKiBUaGUgZnVuY3Rpb25zIGZvciBpbnNlcmluZy9yZW1vdmluZyB1cyBhcyBhIG1vZHVsZS4KKyAqLworc3RhdGljIGludCBfX2luaXQKK2xra2JkX2luaXQgKHZvaWQpCit7CisJc2VyaW9fcmVnaXN0ZXJfZHJpdmVyKCZsa2tiZF9kcnYpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQKK2xra2JkX2V4aXQgKHZvaWQpCit7CisJc2VyaW9fdW5yZWdpc3Rlcl9kcml2ZXIoJmxra2JkX2Rydik7Cit9CisKK21vZHVsZV9pbml0IChsa2tiZF9pbml0KTsKK21vZHVsZV9leGl0IChsa2tiZF9leGl0KTsKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9sb2NvbW9rYmQuYyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvbG9jb21va2JkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDNlOWRkNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvbG9jb21va2JkLmMKQEAgLTAsMCArMSwzMDkgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChjKSAyMDA1IEpvaG4gTGVuegorICoKKyAqIEJhc2VkIG9uIGZyb20geHRrYmQuYworICovCisKKy8qCisgKiBMb0NvTW8ga2V5Ym9hcmQgZHJpdmVyIGZvciBMaW51eC9BUk0KKyAqLworCisvKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2NvbmZpZy5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorCisjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL2xvY29tby5oPgorI2luY2x1ZGUgPGFzbS9pcnEuaD4KKworTU9EVUxFX0FVVEhPUigiSm9obiBMZW56IDxsZW56QGNzLndpc2MuZWR1PiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJMb0NvTW8ga2V5Ym9hcmQgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKKyNkZWZpbmUgTE9DT01PS0JEX05VTUtFWVMgCTEyOAorCisjZGVmaW5lIEtFWV9BQ1RJVklUWQkJS0VZX0YxNgorI2RlZmluZSBLRVlfQ09OVEFDVAkJS0VZX0YxOAorI2RlZmluZSBLRVlfQ0VOVEVSCQlLRVlfRjE1CisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGxvY29tb2tiZF9rZXljb2RlW0xPQ09NT0tCRF9OVU1LRVlTXSA9IHsKKwkwLCBLRVlfRVNDLCBLRVlfQUNUSVZJVFksIDAsIDAsIDAsIDAsIDAsIDAsIDAsCQkJCS8qIDAgLSA5ICovCisJMCwgMCwgMCwgMCwgMCwgMCwgMCwgS0VZX01FTlUsIEtFWV9IT01FLCBLRVlfQ09OVEFDVCwJCQkvKiAxMCAtIDE5ICovCisJMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwJCQkJCQkvKiAyMCAtIDI5ICovCisJMCwgMCwgMCwgS0VZX0NFTlRFUiwgMCwgS0VZX01BSUwsIDAsIDAsIDAsIDAsCQkJCS8qIDMwIC0gMzkgKi8KKwkwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBLRVlfUklHSFQsCQkJCQkvKiA0MCAtIDQ5ICovCisJS0VZX1VQLCBLRVlfTEVGVCwgMCwgMCwgS0VZX1AsIDAsIEtFWV9PLCBLRVlfSSwgS0VZX1ksIEtFWV9ULAkJLyogNTAgLSA1OSAqLworCUtFWV9FLCBLRVlfVywgMCwgMCwgMCwgMCwgS0VZX0RPV04sIEtFWV9FTlRFUiwgMCwgMCwJCQkvKiA2MCAtIDY5ICovCisJS0VZX0JBQ0tTUEFDRSwgMCwgS0VZX0wsIEtFWV9VLCBLRVlfSCwgS0VZX1IsIEtFWV9ELCBLRVlfUSwgMCwgMCwJLyogNzAgLSA3OSAqLworCTAsIDAsIDAsIDAsIDAsIDAsIEtFWV9FTlRFUiwgS0VZX1JJR0hUU0hJRlQsIEtFWV9LLCBLRVlfSiwJCS8qIDgwIC0gODkgKi8KKwlLRVlfRywgS0VZX0YsIEtFWV9YLCBLRVlfUywgMCwgMCwgMCwgMCwgMCwgMCwJCQkJLyogOTAgLSA5OSAqLworCTAsIDAsIEtFWV9ET1QsIDAsIEtFWV9DT01NQSwgS0VZX04sIEtFWV9CLCBLRVlfQywgS0VZX1osIEtFWV9BLAkJLyogMTAwIC0gMTA5ICovCisJS0VZX0xFRlRTSElGVCwgS0VZX1RBQiwgS0VZX0xFRlRDVFJMLCAwLCAwLCAwLCAwLCAwLCAwLCAwLAkJLyogMTEwIC0gMTE5ICovCisJS0VZX00sIEtFWV9TUEFDRSwgS0VZX1YsIEtFWV9BUE9TVFJPUEhFLCBLRVlfU0xBU0gsIDAsIDAsIDAgCQkvKiAxMjAgLSAxMjggKi8KK307CisKKyNkZWZpbmUgS0JfUk9XUwkJCTE2CisjZGVmaW5lIEtCX0NPTFMJCQk4CisjZGVmaW5lIEtCX1JPV01BU0socikJCSgxIDw8IChyKSkKKyNkZWZpbmUgU0NBTkNPREUoYyxyKQkJKCAoKGMpPDw0KSArIChyKSArIDEgKQorI2RlZmluZQlOUl9TQ0FOQ09ERVMJCTEyOAorCisjZGVmaW5lIEtCX0RFTEFZCQk4CisjZGVmaW5lIFNDQU5fSU5URVJWQUwJCShIWi8xMCkKKyNkZWZpbmUgTE9DT01PS0JEX1BSRVNTRUQJMQorCitzdHJ1Y3QgbG9jb21va2JkIHsKKwl1bnNpZ25lZCBjaGFyIGtleWNvZGVbTE9DT01PS0JEX05VTUtFWVNdOworCXN0cnVjdCBpbnB1dF9kZXYgaW5wdXQ7CisJY2hhciBwaHlzWzMyXTsKKworCXN0cnVjdCBsb2NvbW9fZGV2ICpsZGV2OworCXVuc2lnbmVkIGxvbmcgYmFzZTsKKwlzcGlubG9ja190IGxvY2s7CisJCisJc3RydWN0IHRpbWVyX2xpc3QgdGltZXI7Cit9OworCisvKiBoZWxwZXIgZnVuY3Rpb25zIGZvciByZWFkaW5nIHRoZSBrZXlib2FyZCBtYXRyaXggKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBsb2NvbW9rYmRfY2hhcmdlX2FsbCh1bnNpZ25lZCBsb25nIG1lbWJhc2UpCit7CisJbG9jb21vX3dyaXRlbCgweDAwRkYsIG1lbWJhc2UgKyBMT0NPTU9fS1NDKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGxvY29tb2tiZF9hY3RpdmF0ZV9hbGwodW5zaWduZWQgbG9uZyBtZW1iYXNlKQoreworCXVuc2lnbmVkIGxvbmcgcjsKKwkKKwlsb2NvbW9fd3JpdGVsKDAsIG1lbWJhc2UgKyBMT0NPTU9fS1NDKTsKKwlyID0gbG9jb21vX3JlYWRsKG1lbWJhc2UgKyBMT0NPTU9fS0lDKTsKKwlyICY9IDB4RkVGRjsKKwlsb2NvbW9fd3JpdGVsKHIsIG1lbWJhc2UgKyBMT0NPTU9fS0lDKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGxvY29tb2tiZF9hY3RpdmF0ZV9jb2wodW5zaWduZWQgbG9uZyBtZW1iYXNlLCBpbnQgY29sKQoreworCXVuc2lnbmVkIHNob3J0IG5zZXQ7CisJdW5zaWduZWQgc2hvcnQgbmJzZXQ7CisKKwluc2V0ID0gMHhGRiAmIH4oMSA8PCBjb2wpOworCW5ic2V0ID0gKG5zZXQgPDwgOCkgKyBuc2V0OworCWxvY29tb193cml0ZWwobmJzZXQsIG1lbWJhc2UgKyBMT0NPTU9fS1NDKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGxvY29tb2tiZF9yZXNldF9jb2wodW5zaWduZWQgbG9uZyBtZW1iYXNlLCBpbnQgY29sKQoreworCXVuc2lnbmVkIHNob3J0IG5ic2V0OworCisJbmJzZXQgPSAoKDB4RkYgJiB+KDEgPDwgY29sKSkgPDwgOCkgKyAweEZGOworCWxvY29tb193cml0ZWwobmJzZXQsIG1lbWJhc2UgKyBMT0NPTU9fS1NDKTsKK30KKworLyoKKyAqIFRoZSBMb0NvTW8ga2V5Ym9hcmQgb25seSBnZW5lcmF0ZXMgaW50ZXJydXB0cyB3aGVuIGEga2V5IGlzIHByZXNzZWQuCisgKiBTbyB3aGVuIGEga2V5IGlzIHByZXNzZWQsIHdlIGVuYWJsZSBhIHRpbWVyLiAgVGhpcyB0aW1lciBzY2FucyB0aGUKKyAqIGtleWJvYXJkLCBhbmQgdGhpcyBpcyBob3cgd2UgZGV0ZWN0IHdoZW4gdGhlIGtleSBpcyByZWxlYXNlZC4KKyAqLworCisvKiBTY2FuIHRoZSBoYXJkd2FyZSBrZXlib2FyZCBhbmQgcHVzaCBhbnkgY2hhbmdlcyB1cCB0aHJvdWdoIHRoZSBpbnB1dCBsYXllciAqLworc3RhdGljIHZvaWQgbG9jb21va2JkX3NjYW5rZXlib2FyZChzdHJ1Y3QgbG9jb21va2JkICpsb2NvbW9rYmQsIHN0cnVjdCBwdF9yZWdzICpyZWdzKSAKK3sKKwl1bnNpZ25lZCBpbnQgcm93LCBjb2wsIHJvd2QsIHNjYW5jb2RlOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdW5zaWduZWQgaW50IG51bV9wcmVzc2VkOworCXVuc2lnbmVkIGxvbmcgbWVtYmFzZSA9IGxvY29tb2tiZC0+YmFzZTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZsb2NvbW9rYmQtPmxvY2ssIGZsYWdzKTsKKworCWlmIChyZWdzKQorCQlpbnB1dF9yZWdzKCZsb2NvbW9rYmQtPmlucHV0LCByZWdzKTsKKwkKKwlsb2NvbW9rYmRfY2hhcmdlX2FsbChtZW1iYXNlKTsKKworCW51bV9wcmVzc2VkID0gMDsKKwlmb3IgKGNvbCA9IDA7IGNvbCA8IEtCX0NPTFM7IGNvbCsrKSB7CisKKwkJbG9jb21va2JkX2FjdGl2YXRlX2NvbChtZW1iYXNlLCBjb2wpOworCQl1ZGVsYXkoS0JfREVMQVkpOworCQkgCisJCXJvd2QgPSB+bG9jb21vX3JlYWRsKG1lbWJhc2UgKyBMT0NPTU9fS0lCKTsKKwkJZm9yIChyb3cgPSAwOyByb3cgPCBLQl9ST1dTOyByb3crKyApIHsKKwkJCXNjYW5jb2RlID0gU0NBTkNPREUoY29sLCByb3cpOworCQkJaWYgKHJvd2QgJiBLQl9ST1dNQVNLKHJvdykpIHsKKwkJCQludW1fcHJlc3NlZCArPSAxOworCQkJCWlucHV0X3JlcG9ydF9rZXkoJmxvY29tb2tiZC0+aW5wdXQsIGxvY29tb2tiZC0+a2V5Y29kZVtzY2FuY29kZV0sIDEpOworCQkJfSBlbHNlIHsKKwkJCQlpbnB1dF9yZXBvcnRfa2V5KCZsb2NvbW9rYmQtPmlucHV0LCBsb2NvbW9rYmQtPmtleWNvZGVbc2NhbmNvZGVdLCAwKTsKKwkJCX0KKwkJfQorCQlsb2NvbW9rYmRfcmVzZXRfY29sKG1lbWJhc2UsIGNvbCk7CisJfQorCWxvY29tb2tiZF9hY3RpdmF0ZV9hbGwobWVtYmFzZSk7CisKKwlpbnB1dF9zeW5jKCZsb2NvbW9rYmQtPmlucHV0KTsKKworCS8qIGlmIGFueSBrZXlzIGFyZSBwcmVzc2VkLCBlbmFibGUgdGhlIHRpbWVyICovCisJaWYgKG51bV9wcmVzc2VkKQorCQltb2RfdGltZXIoJmxvY29tb2tiZC0+dGltZXIsIGppZmZpZXMgKyBTQ0FOX0lOVEVSVkFMKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmxvY29tb2tiZC0+bG9jaywgZmxhZ3MpOworfQorCisvKiAKKyAqIExvQ29NbyBrZXlib2FyZCBpbnRlcnJ1cHQgaGFuZGxlci4KKyAqLworc3RhdGljIGlycXJldHVybl90IGxvY29tb2tiZF9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlzdHJ1Y3QgbG9jb21va2JkICpsb2NvbW9rYmQgPSBkZXZfaWQ7CisJLyoqIHdhaXQgY2hhdHRlcmluZyBkZWxheSAqKi8KKwl1ZGVsYXkoMTAwKTsKKworCWxvY29tb2tiZF9zY2Fua2V5Ym9hcmQobG9jb21va2JkLCByZWdzKTsKKworCXJldHVybiBJUlFfSEFORExFRDsKK30KKworLyoKKyAqIExvQ29NbyB0aW1lciBjaGVja2luZyBmb3IgcmVsZWFzZWQga2V5cworICovCitzdGF0aWMgdm9pZCBsb2NvbW9rYmRfdGltZXJfY2FsbGJhY2sodW5zaWduZWQgbG9uZyBkYXRhKQoreworCXN0cnVjdCBsb2NvbW9rYmQgKmxvY29tb2tiZCA9IChzdHJ1Y3QgbG9jb21va2JkICopIGRhdGE7CisJbG9jb21va2JkX3NjYW5rZXlib2FyZChsb2NvbW9rYmQsIE5VTEwpOworfQorCitzdGF0aWMgaW50IGxvY29tb2tiZF9wcm9iZShzdHJ1Y3QgbG9jb21vX2RldiAqZGV2KQoreworCXN0cnVjdCBsb2NvbW9rYmQgKmxvY29tb2tiZDsKKwlpbnQgaSwgcmV0OworCisJbG9jb21va2JkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IGxvY29tb2tiZCksIEdGUF9LRVJORUwpOworCWlmICghbG9jb21va2JkKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW1lbXNldChsb2NvbW9rYmQsIDAsIHNpemVvZihzdHJ1Y3QgbG9jb21va2JkKSk7CisKKwkvKiB0cnkgYW5kIGNsYWltIG1lbW9yeSByZWdpb24gKi8KKwlpZiAoIXJlcXVlc3RfbWVtX3JlZ2lvbigodW5zaWduZWQgbG9uZykgZGV2LT5tYXBiYXNlLCAKKwkJCQlkZXYtPmxlbmd0aCwgCisJCQkJTE9DT01PX0RSSVZFUl9OQU1FKGRldikpKSB7CisJCXJldCA9IC1FQlVTWTsKKwkJcHJpbnRrKEtFUk5fRVJSICJsb2NvbW9rYmQ6IENhbid0IGFjcXVpcmUgYWNjZXNzIHRvIGlvIG1lbW9yeSBmb3Iga2V5Ym9hcmRcbiIpOworCQlnb3RvIGZyZWU7CisJfQorCisJbG9jb21va2JkLT5sZGV2ID0gZGV2OworCWxvY29tb19zZXRfZHJ2ZGF0YShkZXYsIGxvY29tb2tiZCk7CisKKwlsb2NvbW9rYmQtPmJhc2UgPSAodW5zaWduZWQgbG9uZykgZGV2LT5tYXBiYXNlOworCisJc3Bpbl9sb2NrX2luaXQoJmxvY29tb2tiZC0+bG9jayk7CisKKwlpbml0X3RpbWVyKCZsb2NvbW9rYmQtPnRpbWVyKTsKKwlsb2NvbW9rYmQtPnRpbWVyLmZ1bmN0aW9uID0gbG9jb21va2JkX3RpbWVyX2NhbGxiYWNrOworCWxvY29tb2tiZC0+dGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBsb2NvbW9rYmQ7CisKKwlsb2NvbW9rYmQtPmlucHV0LmV2Yml0WzBdID0gQklUKEVWX0tFWSkgfCBCSVQoRVZfUkVQKTsKKwkKKwlpbml0X2lucHV0X2RldigmbG9jb21va2JkLT5pbnB1dCk7CisJbG9jb21va2JkLT5pbnB1dC5rZXljb2RlID0gbG9jb21va2JkLT5rZXljb2RlOworCWxvY29tb2tiZC0+aW5wdXQua2V5Y29kZXNpemUgPSBzaXplb2YodW5zaWduZWQgY2hhcik7CisJbG9jb21va2JkLT5pbnB1dC5rZXljb2RlbWF4ID0gQVJSQVlfU0laRShsb2NvbW9rYmRfa2V5Y29kZSk7CisJbG9jb21va2JkLT5pbnB1dC5wcml2YXRlID0gbG9jb21va2JkOworCisJbWVtY3B5KGxvY29tb2tiZC0+a2V5Y29kZSwgbG9jb21va2JkX2tleWNvZGUsIHNpemVvZihsb2NvbW9rYmQtPmtleWNvZGUpKTsKKwlmb3IgKGkgPSAwOyBpIDwgTE9DT01PS0JEX05VTUtFWVM7IGkrKykKKwkJc2V0X2JpdChsb2NvbW9rYmQtPmtleWNvZGVbaV0sIGxvY29tb2tiZC0+aW5wdXQua2V5Yml0KTsKKwljbGVhcl9iaXQoMCwgbG9jb21va2JkLT5pbnB1dC5rZXliaXQpOworCisJc3RyY3B5KGxvY29tb2tiZC0+cGh5cywgImxvY29tb2tiZC9pbnB1dDAiKTsKKworCWxvY29tb2tiZC0+aW5wdXQubmFtZSA9ICJMb0NvTW8ga2V5Ym9hcmQiOworCWxvY29tb2tiZC0+aW5wdXQucGh5cyA9IGxvY29tb2tiZC0+cGh5czsKKwlsb2NvbW9rYmQtPmlucHV0LmlkLmJ1c3R5cGUgPSBCVVNfWFRLQkQ7CisJbG9jb21va2JkLT5pbnB1dC5pZC52ZW5kb3IgPSAweDAwMDE7CisJbG9jb21va2JkLT5pbnB1dC5pZC5wcm9kdWN0ID0gMHgwMDAxOworCWxvY29tb2tiZC0+aW5wdXQuaWQudmVyc2lvbiA9IDB4MDEwMDsKKworCS8qIGF0dGVtcHQgdG8gZ2V0IHRoZSBpbnRlcnJ1cHQgKi8KKwlyZXQgPSByZXF1ZXN0X2lycShkZXYtPmlycVswXSwgbG9jb21va2JkX2ludGVycnVwdCwgMCwgImxvY29tb2tiZCIsIGxvY29tb2tiZCk7CisJaWYgKHJldCkgeworCQlwcmludGsoS0VSTl9FUlIgImxvY29tb2tiZDogQ2FuJ3QgZ2V0IGlycSBmb3Iga2V5Ym9hcmRcbiIpOworCQlnb3RvIG91dDsKKwl9CisKKwlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJmxvY29tb2tiZC0+aW5wdXQpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6IExvQ29NbyBrZXlib2FyZCBvbiBsb2NvbW9rYmRcbiIpOworCisJcmV0dXJuIDA7CisKK291dDoKKwlyZWxlYXNlX21lbV9yZWdpb24oKHVuc2lnbmVkIGxvbmcpIGRldi0+bWFwYmFzZSwgZGV2LT5sZW5ndGgpOworCWxvY29tb19zZXRfZHJ2ZGF0YShkZXYsIE5VTEwpOworZnJlZToKKwlrZnJlZShsb2NvbW9rYmQpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBsb2NvbW9rYmRfcmVtb3ZlKHN0cnVjdCBsb2NvbW9fZGV2ICpkZXYpCit7CisJc3RydWN0IGxvY29tb2tiZCAqbG9jb21va2JkID0gbG9jb21vX2dldF9kcnZkYXRhKGRldik7CisJCisJZnJlZV9pcnEoZGV2LT5pcnFbMF0sIGxvY29tb2tiZCk7CisKKwlkZWxfdGltZXJfc3luYygmbG9jb21va2JkLT50aW1lcik7CisJCisJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2UoJmxvY29tb2tiZC0+aW5wdXQpOworCWxvY29tb19zZXRfZHJ2ZGF0YShkZXYsIE5VTEwpOworCisJcmVsZWFzZV9tZW1fcmVnaW9uKCh1bnNpZ25lZCBsb25nKSBkZXYtPm1hcGJhc2UsIGRldi0+bGVuZ3RoKTsKKworCWtmcmVlKGxvY29tb2tiZCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBsb2NvbW9fZHJpdmVyIGtleWJvYXJkX2RyaXZlciA9IHsKKwkuZHJ2ID0geworCQkubmFtZSA9ICJsb2NvbW9rYmQiCisJfSwKKwkuZGV2aWQJPSBMT0NPTU9fREVWSURfS0VZQk9BUkQsCisJLnByb2JlCT0gbG9jb21va2JkX3Byb2JlLAorCS5yZW1vdmUJPSBsb2NvbW9rYmRfcmVtb3ZlLAorfTsKKworc3RhdGljIGludCBfX2luaXQgbG9jb21va2JkX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gbG9jb21vX2RyaXZlcl9yZWdpc3Rlcigma2V5Ym9hcmRfZHJpdmVyKTsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGxvY29tb2tiZF9leGl0KHZvaWQpCit7CisJbG9jb21vX2RyaXZlcl91bnJlZ2lzdGVyKCZrZXlib2FyZF9kcml2ZXIpOworfQorCittb2R1bGVfaW5pdChsb2NvbW9rYmRfaW5pdCk7Cittb2R1bGVfZXhpdChsb2NvbW9rYmRfZXhpdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL21hcGxlX2tleWIuYyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvbWFwbGVfa2V5Yi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg1OWVkNzcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL21hcGxlX2tleWIuYwpAQCAtMCwwICsxLDE5MCBAQAorLyoKKyAqCSRJZDogbWFwbGVfa2V5Yi5jLHYgMS40IDIwMDQvMDMvMjIgMDE6MTg6MTUgbGV0aGFsIEV4cCAkCisgKiAJU0VHQSBEcmVhbWNhc3Qga2V5Ym9hcmQgZHJpdmVyCisgKglCYXNlZCBvbiBkcml2ZXJzL3VzYi91c2JrYmQuYworICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9tYXBsZS5oPgorCitNT0RVTEVfQVVUSE9SKCJZQUVHQVNISSBUYWtlc2hpIDx0QGtlc2hpLm9yZz4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiU0VHQSBEcmVhbWNhc3Qga2V5Ym9hcmQgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGRjX2tiZF9rZXljb2RlWzI1Nl0gPSB7CisJICAwLCAgMCwgIDAsICAwLCAzMCwgNDgsIDQ2LCAzMiwgMTgsIDMzLCAzNCwgMzUsIDIzLCAzNiwgMzcsIDM4LAorCSA1MCwgNDksIDI0LCAyNSwgMTYsIDE5LCAzMSwgMjAsIDIyLCA0NywgMTcsIDQ1LCAyMSwgNDQsICAyLCAgMywKKwkgIDQsICA1LCAgNiwgIDcsICA4LCAgOSwgMTAsIDExLCAyOCwgIDEsIDE0LCAxNSwgNTcsIDEyLCAxMywgMjYsCisJIDI3LCA0MywgNDMsIDM5LCA0MCwgNDEsIDUxLCA1MiwgNTMsIDU4LCA1OSwgNjAsIDYxLCA2MiwgNjMsIDY0LAorCSA2NSwgNjYsIDY3LCA2OCwgODcsIDg4LCA5OSwgNzAsMTE5LDExMCwxMDIsMTA0LDExMSwxMDcsMTA5LDEwNiwKKwkxMDUsMTA4LDEwMywgNjksIDk4LCA1NSwgNzQsIDc4LCA5NiwgNzksIDgwLCA4MSwgNzUsIDc2LCA3NywgNzEsCisJIDcyLCA3MywgODIsIDgzLCA4NiwxMjcsMTE2LDExNywxODMsMTg0LDE4NSwxODYsMTg3LDE4OCwxODksMTkwLAorCTE5MSwxOTIsMTkzLDE5NCwxMzQsMTM4LDEzMCwxMzIsMTI4LDEyOSwxMzEsMTM3LDEzMywxMzUsMTM2LDExMywKKwkxMTUsMTE0LCAgMCwgIDAsICAwLDEyMSwgIDAsIDg5LCA5MywxMjQsIDkyLCA5NCwgOTUsICAwLCAgMCwgIDAsCisJMTIyLDEyMywgOTAsIDkxLCA4NSwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLAorCSAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwKKwkgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsCisJICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLAorCSAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwKKwkgMjksIDQyLCA1NiwxMjUsIDk3LCA1NCwxMDAsMTI2LDE2NCwxNjYsMTY1LDE2MywxNjEsMTE1LDExNCwxMTMsCisJMTUwLDE1OCwxNTksMTI4LDEzNiwxNzcsMTc4LDE3NiwxNDIsMTUyLDE3MywxNDAKK307CisKKworc3RydWN0IGRjX2tiZCB7CisJc3RydWN0IGlucHV0X2RldiBkZXY7CisJdW5zaWduZWQgY2hhciBuZXdbOF07CisJdW5zaWduZWQgY2hhciBvbGRbOF07CisJaW50IG9wZW47Cit9OworCisKK3N0YXRpYyB2b2lkIGRjX3NjYW5fa2JkKHN0cnVjdCBkY19rYmQgKmtiZCkKK3sKKwlpbnQgaTsKKwlzdHJ1Y3QgaW5wdXRfZGV2ICpkZXYgPSAma2JkLT5kZXY7CisKKwlmb3IoaT0wOyBpPDg7IGkrKykKKwkJaW5wdXRfcmVwb3J0X2tleShkZXYsCisJCQkJIGRjX2tiZF9rZXljb2RlW2krMjI0XSwKKwkJCQkgKGtiZC0+bmV3WzBdPj5pKSYxKTsKKworCWZvcihpPTI7IGk8ODsgaSsrKSB7CisKKwkJaWYoa2JkLT5vbGRbaV0+MyYmbWVtc2NhbihrYmQtPm5ldysyLCBrYmQtPm9sZFtpXSwgNik9PU5VTEwpIHsKKwkJCWlmKGRjX2tiZF9rZXljb2RlW2tiZC0+b2xkW2ldXSkKKwkJCQlpbnB1dF9yZXBvcnRfa2V5KGRldiwKKwkJCQkJCSBkY19rYmRfa2V5Y29kZVtrYmQtPm9sZFtpXV0sCisJCQkJCQkgMCk7CisJCQllbHNlCisJCQkJcHJpbnRrKCJVbmtub3duIGtleSAoc2NhbmNvZGUgJSN4KSByZWxlYXNlZC4iLAorCQkJCSAgICAgICBrYmQtPm9sZFtpXSk7CisJCX0KKworCQlpZihrYmQtPm5ld1tpXT4zJiZtZW1zY2FuKGtiZC0+b2xkKzIsIGtiZC0+bmV3W2ldLCA2KSE9TlVMTCkgeworCQkJaWYoZGNfa2JkX2tleWNvZGVba2JkLT5uZXdbaV1dKQorCQkJCWlucHV0X3JlcG9ydF9rZXkoZGV2LAorCQkJCQkJIGRjX2tiZF9rZXljb2RlW2tiZC0+bmV3W2ldXSwKKwkJCQkJCSAxKTsKKwkJCWVsc2UKKwkJCQlwcmludGsoIlVua25vd24ga2V5IChzY2FuY29kZSAlI3gpIHByZXNzZWQuIiwKKwkJCQkgICAgICAga2JkLT5uZXdbaV0pOworCQl9CisJfQorCisJaW5wdXRfc3luYyhkZXYpOworCisJbWVtY3B5KGtiZC0+b2xkLCBrYmQtPm5ldywgOCk7Cit9CisKKworc3RhdGljIHZvaWQgZGNfa2JkX2NhbGxiYWNrKHN0cnVjdCBtYXBsZXEgKm1xKQoreworCXN0cnVjdCBtYXBsZV9kZXZpY2UgKm1hcGxlZGV2ID0gbXEtPmRldjsKKwlzdHJ1Y3QgZGNfa2JkICprYmQgPSBtYXBsZWRldi0+cHJpdmF0ZV9kYXRhOworCXVuc2lnbmVkIGxvbmcgKmJ1ZiA9IG1xLT5yZWN2YnVmOworCisJaWYgKGJ1ZlsxXSA9PSBtYXBsZWRldi0+ZnVuY3Rpb24pIHsKKwkJbWVtY3B5KGtiZC0+bmV3LCBidWYrMiwgOCk7CisJCWRjX3NjYW5fa2JkKGtiZCk7CisJfQorfQorCisKK3N0YXRpYyBpbnQgZGNfa2JkX29wZW4oc3RydWN0IGlucHV0X2RldiAqZGV2KQoreworCXN0cnVjdCBkY19rYmQgKmtiZCA9IGRldi0+cHJpdmF0ZTsKKwlrYmQtPm9wZW4rKzsKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCBkY19rYmRfY2xvc2Uoc3RydWN0IGlucHV0X2RldiAqZGV2KQoreworCXN0cnVjdCBkY19rYmQgKmtiZCA9IGRldi0+cHJpdmF0ZTsKKwlrYmQtPm9wZW4tLTsKK30KKworCitzdGF0aWMgaW50IGRjX2tiZF9jb25uZWN0KHN0cnVjdCBtYXBsZV9kZXZpY2UgKmRldikKK3sKKwlpbnQgaTsKKwl1bnNpZ25lZCBsb25nIGRhdGEgPSBiZTMyX3RvX2NwdShkZXYtPmRldmluZm8uZnVuY3Rpb25fZGF0YVswXSk7CisJc3RydWN0IGRjX2tiZCAqa2JkOworCisJaWYgKCEoa2JkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IGRjX2tiZCksIEdGUF9LRVJORUwpKSkKKwkJcmV0dXJuIC0xOworCW1lbXNldChrYmQsIDAsIHNpemVvZihzdHJ1Y3QgZGNfa2JkKSk7CisKKwlkZXYtPnByaXZhdGVfZGF0YSA9IGtiZDsKKworCWtiZC0+ZGV2LmV2Yml0WzBdID0gQklUKEVWX0tFWSkgfCBCSVQoRVZfUkVQKTsKKworCWluaXRfaW5wdXRfZGV2KCZrYmQtPmRldik7CisKKwlmb3IgKGk9MDsgaTwyNTU7IGkrKykKKwkJc2V0X2JpdChkY19rYmRfa2V5Y29kZVtpXSwga2JkLT5kZXYua2V5Yml0KTsKKworCWNsZWFyX2JpdCgwLCBrYmQtPmRldi5rZXliaXQpOworCisJa2JkLT5kZXYucHJpdmF0ZSA9IGtiZDsKKwlrYmQtPmRldi5vcGVuID0gZGNfa2JkX29wZW47CisJa2JkLT5kZXYuY2xvc2UgPSBkY19rYmRfY2xvc2U7CisJa2JkLT5kZXYuZXZlbnQgPSBOVUxMOworCisJa2JkLT5kZXYubmFtZSA9IGRldi0+cHJvZHVjdF9uYW1lOworCWtiZC0+ZGV2LmlkLmJ1c3R5cGUgPSBCVVNfTUFQTEU7CisKKwlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJmtiZC0+ZGV2KTsKKworCW1hcGxlX2dldGNvbmRfY2FsbGJhY2soZGV2LCBkY19rYmRfY2FsbGJhY2ssIDEsIE1BUExFX0ZVTkNfS0VZQk9BUkQpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6IGtleWJvYXJkKDB4JWx4KTogJXNcbiIsIGRhdGEsIGtiZC0+ZGV2Lm5hbWUpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgZGNfa2JkX2Rpc2Nvbm5lY3Qoc3RydWN0IG1hcGxlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBkY19rYmQgKmtiZCA9IGRldi0+cHJpdmF0ZV9kYXRhOworCisJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2UoJmtiZC0+ZGV2KTsKKwlrZnJlZShrYmQpOworfQorCisKK3N0YXRpYyBzdHJ1Y3QgbWFwbGVfZHJpdmVyIGRjX2tiZF9kcml2ZXIgPSB7CisJLmZ1bmN0aW9uID0JTUFQTEVfRlVOQ19LRVlCT0FSRCwKKwkubmFtZSA9CQkiRHJlYW1jYXN0IGtleWJvYXJkIiwKKwkuY29ubmVjdCA9CWRjX2tiZF9jb25uZWN0LAorCS5kaXNjb25uZWN0ID0JZGNfa2JkX2Rpc2Nvbm5lY3QsCit9OworCisKK3N0YXRpYyBpbnQgX19pbml0IGRjX2tiZF9pbml0KHZvaWQpCit7CisJbWFwbGVfcmVnaXN0ZXJfZHJpdmVyKCZkY19rYmRfZHJpdmVyKTsKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCBfX2V4aXQgZGNfa2JkX2V4aXQodm9pZCkKK3sKKwltYXBsZV91bnJlZ2lzdGVyX2RyaXZlcigmZGNfa2JkX2RyaXZlcik7Cit9CisKKworbW9kdWxlX2luaXQoZGNfa2JkX2luaXQpOworbW9kdWxlX2V4aXQoZGNfa2JkX2V4aXQpOworCisvKgorICogTG9jYWwgdmFyaWFibGVzOgorICogYy1iYXNpYy1vZmZzZXQ6IDgKKyAqIEVuZDoKKyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9uZXd0b25rYmQuYyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvbmV3dG9ua2JkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmU4Y2UxNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvbmV3dG9ua2JkLmMKQEAgLTAsMCArMSwxODQgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChjKSAyMDAwIEp1c3RpbiBDb3JtYWNrCisgKi8KKworLyoKKyAqIE5ld3RvbiBrZXlib2FyZCBkcml2ZXIgZm9yIExpbnV4CisgKi8KKworLyoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKKyAqCisgKiBTaG91bGQgeW91IG5lZWQgdG8gY29udGFjdCBtZSwgdGhlIGF1dGhvciwgeW91IGNhbiBkbyBzbyBlaXRoZXIgYnkKKyAqIGUtbWFpbCAtIG1haWwgeW91ciBtZXNzYWdlIHRvIDxqLmNvcm1hY2tAZG9jLmljLmFjLnVrPiwgb3IgYnkgcGFwZXIgbWFpbDoKKyAqIEp1c3RpbiBDb3JtYWNrLCA2OCBEYXJ0bW91dGggUGFyayBSb2FkLCBMb25kb24gTlc1IDFTTiwgVUsuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zZXJpby5oPgorCisjZGVmaW5lIERSSVZFUl9ERVNDCSJOZXd0b24ga2V5Ym9hcmQgZHJpdmVyIgorCitNT0RVTEVfQVVUSE9SKCJKdXN0aW4gQ29ybWFjayA8ai5jb3JtYWNrQGRvYy5pYy5hYy51az4iKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKKyNkZWZpbmUgTktCRF9LRVkJMHg3ZgorI2RlZmluZSBOS0JEX1BSRVNTCTB4ODAKKworc3RhdGljIHVuc2lnbmVkIGNoYXIgbmtiZF9rZXljb2RlWzEyOF0gPSB7CisJS0VZX0EsIEtFWV9TLCBLRVlfRCwgS0VZX0YsIEtFWV9ILCBLRVlfRywgS0VZX1osIEtFWV9YLAorCUtFWV9DLCBLRVlfViwgMCwgS0VZX0IsIEtFWV9RLCBLRVlfVywgS0VZX0UsIEtFWV9SLAorCUtFWV9ZLCBLRVlfVCwgS0VZXzEsIEtFWV8yLCBLRVlfMywgS0VZXzQsIEtFWV82LCBLRVlfNSwKKwlLRVlfRVFVQUwsIEtFWV85LCBLRVlfNywgS0VZX01JTlVTLCBLRVlfOCwgS0VZXzAsIEtFWV9SSUdIVEJSQUNFLCBLRVlfTywKKwlLRVlfVSwgS0VZX0xFRlRCUkFDRSwgS0VZX0ksIEtFWV9QLCBLRVlfRU5URVIsIEtFWV9MLCBLRVlfSiwgS0VZX0FQT1NUUk9QSEUsCisJS0VZX0ssIEtFWV9TRU1JQ09MT04sIEtFWV9CQUNLU0xBU0gsIEtFWV9DT01NQSwgS0VZX1NMQVNILCBLRVlfTiwgS0VZX00sIEtFWV9ET1QsCisJS0VZX1RBQiwgS0VZX1NQQUNFLCBLRVlfR1JBVkUsIEtFWV9ERUxFVEUsIDAsIDAsIDAsIEtFWV9MRUZUTUVUQSwKKwlLRVlfTEVGVFNISUZULCBLRVlfQ0FQU0xPQ0ssIEtFWV9MRUZUQUxULCBLRVlfTEVGVENUUkwsIEtFWV9SSUdIVFNISUZULCAwLCAwLCAwLAorCTAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsCisJMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwKKwkwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLAorCTAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsCisJS0VZX0xFRlQsIEtFWV9SSUdIVCwgS0VZX0RPV04sIEtFWV9VUCwgMAorfTsKKworc3RhdGljIGNoYXIgKm5rYmRfbmFtZSA9ICJOZXd0b24gS2V5Ym9hcmQiOworCitzdHJ1Y3QgbmtiZCB7CisJdW5zaWduZWQgY2hhciBrZXljb2RlWzEyOF07CisJc3RydWN0IGlucHV0X2RldiBkZXY7CisJc3RydWN0IHNlcmlvICpzZXJpbzsKKwljaGFyIHBoeXNbMzJdOworfTsKKworc3RhdGljIGlycXJldHVybl90IG5rYmRfaW50ZXJydXB0KHN0cnVjdCBzZXJpbyAqc2VyaW8sCisJCXVuc2lnbmVkIGNoYXIgZGF0YSwgdW5zaWduZWQgaW50IGZsYWdzLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlzdHJ1Y3QgbmtiZCAqbmtiZCA9IHNlcmlvX2dldF9kcnZkYXRhKHNlcmlvKTsKKworCS8qIGludmFsaWQgc2NhbiBjb2RlcyBhcmUgcHJvYmFibHkgdGhlIGluaXQgc2VxdWVuY2UsIHNvIHdlIGlnbm9yZSB0aGVtICovCisJaWYgKG5rYmQtPmtleWNvZGVbZGF0YSAmIE5LQkRfS0VZXSkgeworCQlpbnB1dF9yZWdzKCZua2JkLT5kZXYsIHJlZ3MpOworCQlpbnB1dF9yZXBvcnRfa2V5KCZua2JkLT5kZXYsIG5rYmQtPmtleWNvZGVbZGF0YSAmIE5LQkRfS0VZXSwgZGF0YSAmIE5LQkRfUFJFU1MpOworCQlpbnB1dF9zeW5jKCZua2JkLT5kZXYpOworCX0KKworCWVsc2UgaWYgKGRhdGEgPT0gMHhlNykgLyogZW5kIG9mIGluaXQgc2VxdWVuY2UgKi8KKwkJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6ICVzIG9uICVzXG4iLCBua2JkX25hbWUsIHNlcmlvLT5waHlzKTsKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7CisKK30KKworc3RhdGljIGludCBua2JkX2Nvbm5lY3Qoc3RydWN0IHNlcmlvICpzZXJpbywgc3RydWN0IHNlcmlvX2RyaXZlciAqZHJ2KQoreworCXN0cnVjdCBua2JkICpua2JkOworCWludCBpOworCWludCBlcnI7CisKKwlpZiAoIShua2JkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IG5rYmQpLCBHRlBfS0VSTkVMKSkpCisJCXJldHVybiAtRU5PTUVNOworCisJbWVtc2V0KG5rYmQsIDAsIHNpemVvZihzdHJ1Y3QgbmtiZCkpOworCisJbmtiZC0+ZGV2LmV2Yml0WzBdID0gQklUKEVWX0tFWSkgfCBCSVQoRVZfUkVQKTsKKworCW5rYmQtPnNlcmlvID0gc2VyaW87CisKKwlpbml0X2lucHV0X2RldigmbmtiZC0+ZGV2KTsKKwlua2JkLT5kZXYua2V5Y29kZSA9IG5rYmQtPmtleWNvZGU7CisJbmtiZC0+ZGV2LmtleWNvZGVzaXplID0gc2l6ZW9mKHVuc2lnbmVkIGNoYXIpOworCW5rYmQtPmRldi5rZXljb2RlbWF4ID0gQVJSQVlfU0laRShua2JkX2tleWNvZGUpOworCW5rYmQtPmRldi5wcml2YXRlID0gbmtiZDsKKworCXNlcmlvX3NldF9kcnZkYXRhKHNlcmlvLCBua2JkKTsKKworCWVyciA9IHNlcmlvX29wZW4oc2VyaW8sIGRydik7CisJaWYgKGVycikgeworCQlzZXJpb19zZXRfZHJ2ZGF0YShzZXJpbywgTlVMTCk7CisJCWtmcmVlKG5rYmQpOworCQlyZXR1cm4gZXJyOworCX0KKworCW1lbWNweShua2JkLT5rZXljb2RlLCBua2JkX2tleWNvZGUsIHNpemVvZihua2JkLT5rZXljb2RlKSk7CisJZm9yIChpID0gMDsgaSA8IDEyODsgaSsrKQorCQlzZXRfYml0KG5rYmQtPmtleWNvZGVbaV0sIG5rYmQtPmRldi5rZXliaXQpOworCWNsZWFyX2JpdCgwLCBua2JkLT5kZXYua2V5Yml0KTsKKworCXNwcmludGYobmtiZC0+cGh5cywgIiVzL2lucHV0MCIsIHNlcmlvLT5waHlzKTsKKworCW5rYmQtPmRldi5uYW1lID0gbmtiZF9uYW1lOworCW5rYmQtPmRldi5waHlzID0gbmtiZC0+cGh5czsKKwlua2JkLT5kZXYuaWQuYnVzdHlwZSA9IEJVU19SUzIzMjsKKwlua2JkLT5kZXYuaWQudmVuZG9yID0gU0VSSU9fTkVXVE9OOworCW5rYmQtPmRldi5pZC5wcm9kdWN0ID0gMHgwMDAxOworCW5rYmQtPmRldi5pZC52ZXJzaW9uID0gMHgwMTAwOworCW5rYmQtPmRldi5kZXYgPSAmc2VyaW8tPmRldjsKKworCWlucHV0X3JlZ2lzdGVyX2RldmljZSgmbmtiZC0+ZGV2KTsKKworCXByaW50ayhLRVJOX0lORk8gImlucHV0OiAlcyBvbiAlc1xuIiwgbmtiZF9uYW1lLCBzZXJpby0+cGh5cyk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgbmtiZF9kaXNjb25uZWN0KHN0cnVjdCBzZXJpbyAqc2VyaW8pCit7CisJc3RydWN0IG5rYmQgKm5rYmQgPSBzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyk7CisKKwlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgmbmtiZC0+ZGV2KTsKKwlzZXJpb19jbG9zZShzZXJpbyk7CisJc2VyaW9fc2V0X2RydmRhdGEoc2VyaW8sIE5VTEwpOworCWtmcmVlKG5rYmQpOworfQorCitzdGF0aWMgc3RydWN0IHNlcmlvX2RldmljZV9pZCBua2JkX3NlcmlvX2lkc1tdID0geworCXsKKwkJLnR5cGUJPSBTRVJJT19SUzIzMiwKKwkJLnByb3RvCT0gU0VSSU9fTkVXVE9OLAorCQkuaWQJPSBTRVJJT19BTlksCisJCS5leHRyYQk9IFNFUklPX0FOWSwKKwl9LAorCXsgMCB9Cit9OworCitNT0RVTEVfREVWSUNFX1RBQkxFKHNlcmlvLCBua2JkX3NlcmlvX2lkcyk7CisKK3N0YXRpYyBzdHJ1Y3Qgc2VyaW9fZHJpdmVyIG5rYmRfZHJ2ID0geworCS5kcml2ZXIJCT0geworCQkubmFtZQk9ICJuZXd0b25rYmQiLAorCX0sCisJLmRlc2NyaXB0aW9uCT0gRFJJVkVSX0RFU0MsCisJLmlkX3RhYmxlCT0gbmtiZF9zZXJpb19pZHMsCisJLmludGVycnVwdAk9IG5rYmRfaW50ZXJydXB0LAorCS5jb25uZWN0CT0gbmtiZF9jb25uZWN0LAorCS5kaXNjb25uZWN0CT0gbmtiZF9kaXNjb25uZWN0LAorfTsKKworc3RhdGljIGludCBfX2luaXQgbmtiZF9pbml0KHZvaWQpCit7CisJc2VyaW9fcmVnaXN0ZXJfZHJpdmVyKCZua2JkX2Rydik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBua2JkX2V4aXQodm9pZCkKK3sKKwlzZXJpb191bnJlZ2lzdGVyX2RyaXZlcigmbmtiZF9kcnYpOworfQorCittb2R1bGVfaW5pdChua2JkX2luaXQpOworbW9kdWxlX2V4aXQobmtiZF9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvc3Vua2JkLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL3N1bmtiZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU5Njk2NGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL3N1bmtiZC5jCkBAIC0wLDAgKzEsMzUzIEBACisvKgorICogJElkOiBzdW5rYmQuYyx2IDEuMTQgMjAwMS8wOS8yNSAxMDoxMjowNyB2b2p0ZWNoIEV4cCAkCisgKgorICogIENvcHlyaWdodCAoYykgMTk5OS0yMDAxIFZvanRlY2ggUGF2bGlrCisgKi8KKworLyoKKyAqIFN1biBrZXlib2FyZCBkcml2ZXIgZm9yIExpbnV4CisgKi8KKworLyoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcgVVNBCisgKgorICogU2hvdWxkIHlvdSBuZWVkIHRvIGNvbnRhY3QgbWUsIHRoZSBhdXRob3IsIHlvdSBjYW4gZG8gc28gZWl0aGVyIGJ5CisgKiBlLW1haWwgLSBtYWlsIHlvdXIgbWVzc2FnZSB0byA8dm9qdGVjaEB1Y3cuY3o+LCBvciBieSBwYXBlciBtYWlsOgorICogVm9qdGVjaCBQYXZsaWssIFNpbXVua292YSAxNTk0LCBQcmFndWUgOCwgMTgyIDAwIEN6ZWNoIFJlcHVibGljCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L3NlcmlvLmg+CisjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CisKKyNkZWZpbmUgRFJJVkVSX0RFU0MJIlN1biBrZXlib2FyZCBkcml2ZXIiCisKK01PRFVMRV9BVVRIT1IoIlZvanRlY2ggUGF2bGlrIDx2b2p0ZWNoQHVjdy5jej4iKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIHN1bmtiZF9rZXljb2RlWzEyOF0gPSB7CisJICAwLDEyOCwxMTQsMTI5LDExNSwgNTksIDYwLCA2OCwgNjEsIDg3LCA2MiwgODgsIDYzLDEwMCwgNjQsICAwLAorCSA2NSwgNjYsIDY3LCA1NiwxMDMsMTE5LCA5OSwgNzAsMTA1LDEzMCwxMzEsMTA4LDEwNiwgIDEsICAyLCAgMywKKwkgIDQsICA1LCAgNiwgIDcsICA4LCAgOSwgMTAsIDExLCAxMiwgMTMsIDQxLCAxNCwxMTAsMTEzLCA5OCwgNTUsCisJMTE2LDEzMiwgODMsMTMzLDEwMiwgMTUsIDE2LCAxNywgMTgsIDE5LCAyMCwgMjEsIDIyLCAyMywgMjQsIDI1LAorCSAyNiwgMjcsMTExLDEyNywgNzEsIDcyLCA3MywgNzQsMTM0LDEzNSwxMDcsICAwLCAyOSwgMzAsIDMxLCAzMiwKKwkgMzMsIDM0LCAzNSwgMzYsIDM3LCAzOCwgMzksIDQwLCA0MywgMjgsIDk2LCA3NSwgNzYsIDc3LCA4MiwxMzYsCisJMTA0LDEzNywgNjksIDQyLCA0NCwgNDUsIDQ2LCA0NywgNDgsIDQ5LCA1MCwgNTEsIDUyLCA1MywgNTQsMTAxLAorCSA3OSwgODAsIDgxLCAgMCwgIDAsICAwLDEzOCwgNTgsMTI1LCA1NywxMjYsMTA5LCA4NiwgNzgKK307CisKKyNkZWZpbmUgU1VOS0JEX0NNRF9SRVNFVAkweDEKKyNkZWZpbmUgU1VOS0JEX0NNRF9CRUxMT04JMHgyCisjZGVmaW5lIFNVTktCRF9DTURfQkVMTE9GRgkweDMKKyNkZWZpbmUgU1VOS0JEX0NNRF9DTElDSwkweGEKKyNkZWZpbmUgU1VOS0JEX0NNRF9OT0NMSUNLCTB4YgorI2RlZmluZSBTVU5LQkRfQ01EX1NFVExFRAkweGUKKyNkZWZpbmUgU1VOS0JEX0NNRF9MQVlPVVQJMHhmCisKKyNkZWZpbmUgU1VOS0JEX1JFVF9SRVNFVAkweGZmCisjZGVmaW5lIFNVTktCRF9SRVRfQUxMVVAJMHg3ZgorI2RlZmluZSBTVU5LQkRfUkVUX0xBWU9VVAkweGZlCisKKyNkZWZpbmUgU1VOS0JEX0xBWU9VVF81X01BU0sJMHgyMAorI2RlZmluZSBTVU5LQkRfUkVMRUFTRQkJMHg4MAorI2RlZmluZSBTVU5LQkRfS0VZCQkweDdmCisKKy8qCisgKiBQZXIta2V5Ym9hcmQgZGF0YS4KKyAqLworCitzdHJ1Y3Qgc3Vua2JkIHsKKwl1bnNpZ25lZCBjaGFyIGtleWNvZGVbMTI4XTsKKwlzdHJ1Y3QgaW5wdXRfZGV2IGRldjsKKwlzdHJ1Y3Qgc2VyaW8gKnNlcmlvOworCXN0cnVjdCB3b3JrX3N0cnVjdCB0cTsKKwl3YWl0X3F1ZXVlX2hlYWRfdCB3YWl0OworCWNoYXIgbmFtZVs2NF07CisJY2hhciBwaHlzWzMyXTsKKwljaGFyIHR5cGU7CisJdm9sYXRpbGUgczggcmVzZXQ7CisJdm9sYXRpbGUgczggbGF5b3V0OworfTsKKworLyoKKyAqIHN1bmtiZF9pbnRlcnJ1cHQoKSBpcyBjYWxsZWQgYnkgdGhlIGxvdyBsZXZlbCBkcml2ZXIgd2hlbiBhIGNoYXJhY3RlcgorICogaXMgcmVjZWl2ZWQuCisgKi8KKworc3RhdGljIGlycXJldHVybl90IHN1bmtiZF9pbnRlcnJ1cHQoc3RydWN0IHNlcmlvICpzZXJpbywKKwkJdW5zaWduZWQgY2hhciBkYXRhLCB1bnNpZ25lZCBpbnQgZmxhZ3MsIHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXN0cnVjdCBzdW5rYmQqIHN1bmtiZCA9IHNlcmlvX2dldF9kcnZkYXRhKHNlcmlvKTsKKworCWlmIChzdW5rYmQtPnJlc2V0IDw9IC0xKSB7CQkvKiBJZiBjcFtpXSBpcyAweGZmLCBzdW5rYmQtPnJlc2V0IHdpbGwgc3RheSAtMS4gKi8KKwkJc3Vua2JkLT5yZXNldCA9IGRhdGE7CQkvKiBUaGUga2V5Ym9hcmQgc2VuZHMgMHhmZiAweGZmIDB4SUQgb24gcG93ZXJ1cCAqLworCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJnN1bmtiZC0+d2FpdCk7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChzdW5rYmQtPmxheW91dCA9PSAtMSkgeworCQlzdW5rYmQtPmxheW91dCA9IGRhdGE7CisJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmc3Vua2JkLT53YWl0KTsKKwkJZ290byBvdXQ7CisJfQorCisJc3dpdGNoIChkYXRhKSB7CisKKwkJY2FzZSBTVU5LQkRfUkVUX1JFU0VUOgorCQkJc2NoZWR1bGVfd29yaygmc3Vua2JkLT50cSk7CisJCQlzdW5rYmQtPnJlc2V0ID0gLTE7CisJCQlicmVhazsKKworCQljYXNlIFNVTktCRF9SRVRfTEFZT1VUOgorCQkJc3Vua2JkLT5sYXlvdXQgPSAtMTsKKwkJCWJyZWFrOworCisJCWNhc2UgU1VOS0JEX1JFVF9BTExVUDogLyogQWxsIGtleXMgcmVsZWFzZWQgKi8KKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6CisJCQlpZiAoc3Vua2JkLT5rZXljb2RlW2RhdGEgJiBTVU5LQkRfS0VZXSkgeworCQkJCWlucHV0X3JlZ3MoJnN1bmtiZC0+ZGV2LCByZWdzKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5wdXRfcmVwb3J0X2tleSgmc3Vua2JkLT5kZXYsIHN1bmtiZC0+a2V5Y29kZVtkYXRhICYgU1VOS0JEX0tFWV0sICEoZGF0YSAmIFNVTktCRF9SRUxFQVNFKSk7CisJCQkJaW5wdXRfc3luYygmc3Vua2JkLT5kZXYpOworICAgICAgICAgICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJpbnRrKEtFUk5fV0FSTklORyAic3Vua2JkLmM6IFVua25vd24ga2V5IChzY2FuY29kZSAlI3gpICVzLlxuIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkYXRhICYgU1VOS0JEX0tFWSwgZGF0YSAmIFNVTktCRF9SRUxFQVNFID8gInJlbGVhc2VkIiA6ICJwcmVzc2VkIik7CisgICAgICAgICAgICAgICAgICAgICAgICB9CisJfQorb3V0OgorCXJldHVybiBJUlFfSEFORExFRDsKK30KKworLyoKKyAqIHN1bmtiZF9ldmVudCgpIGhhbmRsZXMgZXZlbnRzIGZyb20gdGhlIGlucHV0IG1vZHVsZS4KKyAqLworCitzdGF0aWMgaW50IHN1bmtiZF9ldmVudChzdHJ1Y3QgaW5wdXRfZGV2ICpkZXYsIHVuc2lnbmVkIGludCB0eXBlLCB1bnNpZ25lZCBpbnQgY29kZSwgaW50IHZhbHVlKQoreworCXN0cnVjdCBzdW5rYmQgKnN1bmtiZCA9IGRldi0+cHJpdmF0ZTsKKworCXN3aXRjaCAodHlwZSkgeworCisJCWNhc2UgRVZfTEVEOgorCisJCQlzdW5rYmQtPnNlcmlvLT53cml0ZShzdW5rYmQtPnNlcmlvLCBTVU5LQkRfQ01EX1NFVExFRCk7CisJCQlzdW5rYmQtPnNlcmlvLT53cml0ZShzdW5rYmQtPnNlcmlvLAorCQkJCSghIXRlc3RfYml0KExFRF9DQVBTTCwgZGV2LT5sZWQpIDw8IDMpIHwgKCEhdGVzdF9iaXQoTEVEX1NDUk9MTEwsIGRldi0+bGVkKSA8PCAyKSB8CisJCQkJKCEhdGVzdF9iaXQoTEVEX0NPTVBPU0UsIGRldi0+bGVkKSA8PCAxKSB8ICEhdGVzdF9iaXQoTEVEX05VTUwsIGRldi0+bGVkKSk7CisJCQlyZXR1cm4gMDsKKworCQljYXNlIEVWX1NORDoKKworCQkJc3dpdGNoIChjb2RlKSB7CisKKwkJCQljYXNlIFNORF9DTElDSzoKKwkJCQkJc3Vua2JkLT5zZXJpby0+d3JpdGUoc3Vua2JkLT5zZXJpbywgU1VOS0JEX0NNRF9OT0NMSUNLIC0gdmFsdWUpOworCQkJCQlyZXR1cm4gMDsKKworCQkJCWNhc2UgU05EX0JFTEw6CisJCQkJCXN1bmtiZC0+c2VyaW8tPndyaXRlKHN1bmtiZC0+c2VyaW8sIFNVTktCRF9DTURfQkVMTE9GRiAtIHZhbHVlKTsKKwkJCQkJcmV0dXJuIDA7CisJCQl9CisKKwkJCWJyZWFrOworCX0KKworCXJldHVybiAtMTsKK30KKworLyoKKyAqIHN1bmtiZF9pbml0aWFsaXplKCkgY2hlY2tzIGZvciBhIFN1biBrZXlib2FyZCBhdHRhY2hlZCwgYW5kIGRldGVybWluZXMKKyAqIGl0cyB0eXBlLgorICovCisKK3N0YXRpYyBpbnQgc3Vua2JkX2luaXRpYWxpemUoc3RydWN0IHN1bmtiZCAqc3Vua2JkKQoreworCXN1bmtiZC0+cmVzZXQgPSAtMjsKKwlzdW5rYmQtPnNlcmlvLT53cml0ZShzdW5rYmQtPnNlcmlvLCBTVU5LQkRfQ01EX1JFU0VUKTsKKwl3YWl0X2V2ZW50X2ludGVycnVwdGlibGVfdGltZW91dChzdW5rYmQtPndhaXQsIHN1bmtiZC0+cmVzZXQgPj0gMCwgSFopOworCWlmIChzdW5rYmQtPnJlc2V0IDwwKQorCQlyZXR1cm4gLTE7CisKKwlzdW5rYmQtPnR5cGUgPSBzdW5rYmQtPnJlc2V0OworCisJaWYgKHN1bmtiZC0+dHlwZSA9PSA0KSB7CS8qIFR5cGUgNCBrZXlib2FyZCAqLworCQlzdW5rYmQtPmxheW91dCA9IC0yOworCQlzdW5rYmQtPnNlcmlvLT53cml0ZShzdW5rYmQtPnNlcmlvLCBTVU5LQkRfQ01EX0xBWU9VVCk7CisJCXdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV90aW1lb3V0KHN1bmtiZC0+d2FpdCwgc3Vua2JkLT5sYXlvdXQgPj0gMCwgSFovNCk7CisJCWlmIChzdW5rYmQtPmxheW91dCA8IDApIHJldHVybiAtMTsKKwkJaWYgKHN1bmtiZC0+bGF5b3V0ICYgU1VOS0JEX0xBWU9VVF81X01BU0spIHN1bmtiZC0+dHlwZSA9IDU7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBzdW5rYmRfcmVpbml0KCkgc2V0cyBsZWRzIGFuZCBiZWVwcyB0byBhIHN0YXRlIHRoZSBjb21wdXRlciByZW1lbWJlcnMgdGhleQorICogd2VyZSBpbi4KKyAqLworCitzdGF0aWMgdm9pZCBzdW5rYmRfcmVpbml0KHZvaWQgKmRhdGEpCit7CisJc3RydWN0IHN1bmtiZCAqc3Vua2JkID0gZGF0YTsKKworCXdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV90aW1lb3V0KHN1bmtiZC0+d2FpdCwgc3Vua2JkLT5yZXNldCA+PSAwLCBIWik7CisKKwlzdW5rYmQtPnNlcmlvLT53cml0ZShzdW5rYmQtPnNlcmlvLCBTVU5LQkRfQ01EX1NFVExFRCk7CisJc3Vua2JkLT5zZXJpby0+d3JpdGUoc3Vua2JkLT5zZXJpbywKKwkJKCEhdGVzdF9iaXQoTEVEX0NBUFNMLCBzdW5rYmQtPmRldi5sZWQpIDw8IDMpIHwgKCEhdGVzdF9iaXQoTEVEX1NDUk9MTEwsIHN1bmtiZC0+ZGV2LmxlZCkgPDwgMikgfAorCQkoISF0ZXN0X2JpdChMRURfQ09NUE9TRSwgc3Vua2JkLT5kZXYubGVkKSA8PCAxKSB8ICEhdGVzdF9iaXQoTEVEX05VTUwsIHN1bmtiZC0+ZGV2LmxlZCkpOworCXN1bmtiZC0+c2VyaW8tPndyaXRlKHN1bmtiZC0+c2VyaW8sIFNVTktCRF9DTURfTk9DTElDSyAtICEhdGVzdF9iaXQoU05EX0NMSUNLLCBzdW5rYmQtPmRldi5zbmQpKTsKKwlzdW5rYmQtPnNlcmlvLT53cml0ZShzdW5rYmQtPnNlcmlvLCBTVU5LQkRfQ01EX0JFTExPRkYgLSAhIXRlc3RfYml0KFNORF9CRUxMLCBzdW5rYmQtPmRldi5zbmQpKTsKK30KKworLyoKKyAqIHN1bmtiZF9jb25uZWN0KCkgcHJvYmVzIGZvciBhIFN1biBrZXlib2FyZCBhbmQgZmlsbHMgdGhlIG5lY2Vzc2FyeSBzdHJ1Y3R1cmVzLgorICovCisKK3N0YXRpYyBpbnQgc3Vua2JkX2Nvbm5lY3Qoc3RydWN0IHNlcmlvICpzZXJpbywgc3RydWN0IHNlcmlvX2RyaXZlciAqZHJ2KQoreworCXN0cnVjdCBzdW5rYmQgKnN1bmtiZDsKKwlpbnQgaTsKKwlpbnQgZXJyOworCisJaWYgKCEoc3Vua2JkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHN1bmtiZCksIEdGUF9LRVJORUwpKSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwltZW1zZXQoc3Vua2JkLCAwLCBzaXplb2Yoc3RydWN0IHN1bmtiZCkpOworCisJaW5pdF9pbnB1dF9kZXYoJnN1bmtiZC0+ZGV2KTsKKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZzdW5rYmQtPndhaXQpOworCisJc3Vua2JkLT5kZXYuZXZiaXRbMF0gPSBCSVQoRVZfS0VZKSB8IEJJVChFVl9MRUQpIHwgQklUKEVWX1NORCkgfCBCSVQoRVZfUkVQKTsKKwlzdW5rYmQtPmRldi5sZWRiaXRbMF0gPSBCSVQoTEVEX0NBUFNMKSB8IEJJVChMRURfQ09NUE9TRSkgfCBCSVQoTEVEX1NDUk9MTEwpIHwgQklUKExFRF9OVU1MKTsKKwlzdW5rYmQtPmRldi5zbmRiaXRbMF0gPSBCSVQoU05EX0NMSUNLKSB8IEJJVChTTkRfQkVMTCk7CisKKwlzdW5rYmQtPnNlcmlvID0gc2VyaW87CisKKwlJTklUX1dPUksoJnN1bmtiZC0+dHEsIHN1bmtiZF9yZWluaXQsIHN1bmtiZCk7CisKKwlzdW5rYmQtPmRldi5rZXljb2RlID0gc3Vua2JkLT5rZXljb2RlOworCXN1bmtiZC0+ZGV2LmtleWNvZGVzaXplID0gc2l6ZW9mKHVuc2lnbmVkIGNoYXIpOworCXN1bmtiZC0+ZGV2LmtleWNvZGVtYXggPSBBUlJBWV9TSVpFKHN1bmtiZF9rZXljb2RlKTsKKworCXN1bmtiZC0+ZGV2LmV2ZW50ID0gc3Vua2JkX2V2ZW50OworCXN1bmtiZC0+ZGV2LnByaXZhdGUgPSBzdW5rYmQ7CisKKwlzZXJpb19zZXRfZHJ2ZGF0YShzZXJpbywgc3Vua2JkKTsKKworCWVyciA9IHNlcmlvX29wZW4oc2VyaW8sIGRydik7CisJaWYgKGVycikgeworCQlzZXJpb19zZXRfZHJ2ZGF0YShzZXJpbywgTlVMTCk7CisJCWtmcmVlKHN1bmtiZCk7CisJCXJldHVybiBlcnI7CisJfQorCisJaWYgKHN1bmtiZF9pbml0aWFsaXplKHN1bmtiZCkgPCAwKSB7CisJCXNlcmlvX2Nsb3NlKHNlcmlvKTsKKwkJc2VyaW9fc2V0X2RydmRhdGEoc2VyaW8sIE5VTEwpOworCQlrZnJlZShzdW5rYmQpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlzcHJpbnRmKHN1bmtiZC0+bmFtZSwgIlN1biBUeXBlICVkIGtleWJvYXJkIiwgc3Vua2JkLT50eXBlKTsKKworCW1lbWNweShzdW5rYmQtPmtleWNvZGUsIHN1bmtiZF9rZXljb2RlLCBzaXplb2Yoc3Vua2JkLT5rZXljb2RlKSk7CisJZm9yIChpID0gMDsgaSA8IDEyODsgaSsrKQorCQlzZXRfYml0KHN1bmtiZC0+a2V5Y29kZVtpXSwgc3Vua2JkLT5kZXYua2V5Yml0KTsKKwljbGVhcl9iaXQoMCwgc3Vua2JkLT5kZXYua2V5Yml0KTsKKworCXNwcmludGYoc3Vua2JkLT5waHlzLCAiJXMvaW5wdXQwIiwgc2VyaW8tPnBoeXMpOworCisJc3Vua2JkLT5kZXYubmFtZSA9IHN1bmtiZC0+bmFtZTsKKwlzdW5rYmQtPmRldi5waHlzID0gc3Vua2JkLT5waHlzOworCXN1bmtiZC0+ZGV2LmlkLmJ1c3R5cGUgPSBCVVNfUlMyMzI7CisJc3Vua2JkLT5kZXYuaWQudmVuZG9yID0gU0VSSU9fU1VOS0JEOworCXN1bmtiZC0+ZGV2LmlkLnByb2R1Y3QgPSBzdW5rYmQtPnR5cGU7CisJc3Vua2JkLT5kZXYuaWQudmVyc2lvbiA9IDB4MDEwMDsKKwlzdW5rYmQtPmRldi5kZXYgPSAmc2VyaW8tPmRldjsKKworCWlucHV0X3JlZ2lzdGVyX2RldmljZSgmc3Vua2JkLT5kZXYpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6ICVzIG9uICVzXG4iLCBzdW5rYmQtPm5hbWUsIHNlcmlvLT5waHlzKTsKKworCXJldHVybiAwOworfQorCisvKgorICogc3Vua2JkX2Rpc2Nvbm5lY3QoKSB1bnJlZ2lzdGVycyBhbmQgY2xvc2VzIGJlaGluZCB1cy4KKyAqLworCitzdGF0aWMgdm9pZCBzdW5rYmRfZGlzY29ubmVjdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvKQoreworCXN0cnVjdCBzdW5rYmQgKnN1bmtiZCA9IHNlcmlvX2dldF9kcnZkYXRhKHNlcmlvKTsKKwlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgmc3Vua2JkLT5kZXYpOworCXNlcmlvX2Nsb3NlKHNlcmlvKTsKKwlzZXJpb19zZXRfZHJ2ZGF0YShzZXJpbywgTlVMTCk7CisJa2ZyZWUoc3Vua2JkKTsKK30KKworc3RhdGljIHN0cnVjdCBzZXJpb19kZXZpY2VfaWQgc3Vua2JkX3NlcmlvX2lkc1tdID0geworCXsKKwkJLnR5cGUJPSBTRVJJT19SUzIzMiwKKwkJLnByb3RvCT0gU0VSSU9fU1VOS0JELAorCQkuaWQJPSBTRVJJT19BTlksCisJCS5leHRyYQk9IFNFUklPX0FOWSwKKwl9LAorCXsKKwkJLnR5cGUJPSBTRVJJT19SUzIzMiwKKwkJLnByb3RvCT0gU0VSSU9fVU5LTk9XTiwgLyogc3Vua2JkIGRvZXMgcHJvYmUgKi8KKwkJLmlkCT0gU0VSSU9fQU5ZLAorCQkuZXh0cmEJPSBTRVJJT19BTlksCisJfSwKKwl7IDAgfQorfTsKKworTU9EVUxFX0RFVklDRV9UQUJMRShzZXJpbywgc3Vua2JkX3NlcmlvX2lkcyk7CisKK3N0YXRpYyBzdHJ1Y3Qgc2VyaW9fZHJpdmVyIHN1bmtiZF9kcnYgPSB7CisJLmRyaXZlcgkJPSB7CisJCS5uYW1lCT0gInN1bmtiZCIsCisJfSwKKwkuZGVzY3JpcHRpb24JPSBEUklWRVJfREVTQywKKwkuaWRfdGFibGUJPSBzdW5rYmRfc2VyaW9faWRzLAorCS5pbnRlcnJ1cHQJPSBzdW5rYmRfaW50ZXJydXB0LAorCS5jb25uZWN0CT0gc3Vua2JkX2Nvbm5lY3QsCisJLmRpc2Nvbm5lY3QJPSBzdW5rYmRfZGlzY29ubmVjdCwKK307CisKKy8qCisgKiBUaGUgZnVuY3Rpb25zIGZvciBpbnNlcmluZy9yZW1vdmluZyB1cyBhcyBhIG1vZHVsZS4KKyAqLworCitzdGF0aWMgaW50IF9faW5pdCBzdW5rYmRfaW5pdCh2b2lkKQoreworCXNlcmlvX3JlZ2lzdGVyX2RyaXZlcigmc3Vua2JkX2Rydik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBzdW5rYmRfZXhpdCh2b2lkKQoreworCXNlcmlvX3VucmVnaXN0ZXJfZHJpdmVyKCZzdW5rYmRfZHJ2KTsKK30KKworbW9kdWxlX2luaXQoc3Vua2JkX2luaXQpOworbW9kdWxlX2V4aXQoc3Vua2JkX2V4aXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC94dGtiZC5jIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC94dGtiZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE5ZWFlYzcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL3h0a2JkLmMKQEAgLTAsMCArMSwxODggQEAKKy8qCisgKiAkSWQ6IHh0a2JkLmMsdiAxLjExIDIwMDEvMDkvMjUgMTA6MTI6MDcgdm9qdGVjaCBFeHAgJAorICoKKyAqICBDb3B5cmlnaHQgKGMpIDE5OTktMjAwMSBWb2p0ZWNoIFBhdmxpaworICovCisKKy8qCisgKiBYVCBrZXlib2FyZCBkcml2ZXIgZm9yIExpbnV4CisgKi8KKworLyoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcgVVNBCisgKgorICogU2hvdWxkIHlvdSBuZWVkIHRvIGNvbnRhY3QgbWUsIHRoZSBhdXRob3IsIHlvdSBjYW4gZG8gc28gZWl0aGVyIGJ5CisgKiBlLW1haWwgLSBtYWlsIHlvdXIgbWVzc2FnZSB0byA8dm9qdGVjaEB1Y3cuY3o+LCBvciBieSBwYXBlciBtYWlsOgorICogVm9qdGVjaCBQYXZsaWssIFNpbXVua292YSAxNTk0LCBQcmFndWUgOCwgMTgyIDAwIEN6ZWNoIFJlcHVibGljCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zZXJpby5oPgorCisjZGVmaW5lIERSSVZFUl9ERVNDCSJYVCBrZXlib2FyZCBkcml2ZXIiCisKK01PRFVMRV9BVVRIT1IoIlZvanRlY2ggUGF2bGlrIDx2b2p0ZWNoQHVjdy5jej4iKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKKyNkZWZpbmUgWFRLQkRfRU1VTDAJMHhlMAorI2RlZmluZSBYVEtCRF9FTVVMMQkweGUxCisjZGVmaW5lIFhUS0JEX0tFWQkweDdmCisjZGVmaW5lIFhUS0JEX1JFTEVBU0UJMHg4MAorCitzdGF0aWMgdW5zaWduZWQgY2hhciB4dGtiZF9rZXljb2RlWzI1Nl0gPSB7CisJICAwLCAgMSwgIDIsICAzLCAgNCwgIDUsICA2LCAgNywgIDgsICA5LCAxMCwgMTEsIDEyLCAxMywgMTQsIDE1LAorCSAxNiwgMTcsIDE4LCAxOSwgMjAsIDIxLCAyMiwgMjMsIDI0LCAyNSwgMjYsIDI3LCAyOCwgMjksIDMwLCAzMSwKKwkgMzIsIDMzLCAzNCwgMzUsIDM2LCAzNywgMzgsIDM5LCA0MCwgNDEsIDQyLCA0MywgNDQsIDQ1LCA0NiwgNDcsCisJIDQ4LCA0OSwgNTAsIDUxLCA1MiwgNTMsIDU0LCA1NSwgNTYsIDU3LCA1OCwgNTksIDYwLCA2MSwgNjIsIDYzLAorCSA2NCwgNjUsIDY2LCA2NywgNjgsIDY5LCA3MCwgNzEsIDcyLCA3MywgNzQsIDc1LCA3NiwgNzcsIDc4LCA3OSwKKwkgODAsIDgxLCA4MiwgODMsICAwLCAgMCwgIDAsIDg3LCA4OCwgIDAsICAwLCAgMCwgIDAsICAwLCAgMCwgIDAsCisJICAwLCAgMCwgIDAsICAwLCAgMCwgODcsIDg4LCAgMCwgIDAsICAwLCAgMCwxMTAsMTExLDEwMywxMDgsMTA1LAorCTEwNgorfTsKKworc3RhdGljIGNoYXIgKnh0a2JkX25hbWUgPSAiWFQgS2V5Ym9hcmQiOworCitzdHJ1Y3QgeHRrYmQgeworCXVuc2lnbmVkIGNoYXIga2V5Y29kZVsyNTZdOworCXN0cnVjdCBpbnB1dF9kZXYgZGV2OworCXN0cnVjdCBzZXJpbyAqc2VyaW87CisJY2hhciBwaHlzWzMyXTsKK307CisKK3N0YXRpYyBpcnFyZXR1cm5fdCB4dGtiZF9pbnRlcnJ1cHQoc3RydWN0IHNlcmlvICpzZXJpbywKKwl1bnNpZ25lZCBjaGFyIGRhdGEsIHVuc2lnbmVkIGludCBmbGFncywgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IHh0a2JkICp4dGtiZCA9IHNlcmlvX2dldF9kcnZkYXRhKHNlcmlvKTsKKworCXN3aXRjaCAoZGF0YSkgeworCQljYXNlIFhUS0JEX0VNVUwwOgorCQljYXNlIFhUS0JEX0VNVUwxOgorCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisKKwkJCWlmICh4dGtiZC0+a2V5Y29kZVtkYXRhICYgWFRLQkRfS0VZXSkgeworCQkJCWlucHV0X3JlZ3MoJnh0a2JkLT5kZXYsIHJlZ3MpOworCQkJCWlucHV0X3JlcG9ydF9rZXkoJnh0a2JkLT5kZXYsIHh0a2JkLT5rZXljb2RlW2RhdGEgJiBYVEtCRF9LRVldLCAhKGRhdGEgJiBYVEtCRF9SRUxFQVNFKSk7CisJCQkJaW5wdXRfc3luYygmeHRrYmQtPmRldik7CisJCQl9IGVsc2UgeworCQkJCXByaW50ayhLRVJOX1dBUk5JTkcgInh0a2JkLmM6IFVua25vd24ga2V5IChzY2FuY29kZSAlI3gpICVzLlxuIiwKKwkJCQkJZGF0YSAmIFhUS0JEX0tFWSwgZGF0YSAmIFhUS0JEX1JFTEVBU0UgPyAicmVsZWFzZWQiIDogInByZXNzZWQiKTsKKwkJCX0KKwl9CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitzdGF0aWMgaW50IHh0a2JkX2Nvbm5lY3Qoc3RydWN0IHNlcmlvICpzZXJpbywgc3RydWN0IHNlcmlvX2RyaXZlciAqZHJ2KQoreworCXN0cnVjdCB4dGtiZCAqeHRrYmQ7CisJaW50IGk7CisJaW50IGVycjsKKworCWlmICghKHh0a2JkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHh0a2JkKSwgR0ZQX0tFUk5FTCkpKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW1lbXNldCh4dGtiZCwgMCwgc2l6ZW9mKHN0cnVjdCB4dGtiZCkpOworCisJeHRrYmQtPmRldi5ldmJpdFswXSA9IEJJVChFVl9LRVkpIHwgQklUKEVWX1JFUCk7CisKKwl4dGtiZC0+c2VyaW8gPSBzZXJpbzsKKworCWluaXRfaW5wdXRfZGV2KCZ4dGtiZC0+ZGV2KTsKKwl4dGtiZC0+ZGV2LmtleWNvZGUgPSB4dGtiZC0+a2V5Y29kZTsKKwl4dGtiZC0+ZGV2LmtleWNvZGVzaXplID0gc2l6ZW9mKHVuc2lnbmVkIGNoYXIpOworCXh0a2JkLT5kZXYua2V5Y29kZW1heCA9IEFSUkFZX1NJWkUoeHRrYmRfa2V5Y29kZSk7CisJeHRrYmQtPmRldi5wcml2YXRlID0geHRrYmQ7CisKKwlzZXJpb19zZXRfZHJ2ZGF0YShzZXJpbywgeHRrYmQpOworCisJZXJyID0gc2VyaW9fb3BlbihzZXJpbywgZHJ2KTsKKwlpZiAoZXJyKSB7CisJCXNlcmlvX3NldF9kcnZkYXRhKHNlcmlvLCBOVUxMKTsKKwkJa2ZyZWUoeHRrYmQpOworCQlyZXR1cm4gZXJyOworCX0KKworCW1lbWNweSh4dGtiZC0+a2V5Y29kZSwgeHRrYmRfa2V5Y29kZSwgc2l6ZW9mKHh0a2JkLT5rZXljb2RlKSk7CisJZm9yIChpID0gMDsgaSA8IDI1NTsgaSsrKQorCQlzZXRfYml0KHh0a2JkLT5rZXljb2RlW2ldLCB4dGtiZC0+ZGV2LmtleWJpdCk7CisJY2xlYXJfYml0KDAsIHh0a2JkLT5kZXYua2V5Yml0KTsKKworCXNwcmludGYoeHRrYmQtPnBoeXMsICIlcy9pbnB1dDAiLCBzZXJpby0+cGh5cyk7CisKKwl4dGtiZC0+ZGV2Lm5hbWUgPSB4dGtiZF9uYW1lOworCXh0a2JkLT5kZXYucGh5cyA9IHh0a2JkLT5waHlzOworCXh0a2JkLT5kZXYuaWQuYnVzdHlwZSA9IEJVU19YVEtCRDsKKwl4dGtiZC0+ZGV2LmlkLnZlbmRvciA9IDB4MDAwMTsKKwl4dGtiZC0+ZGV2LmlkLnByb2R1Y3QgPSAweDAwMDE7CisJeHRrYmQtPmRldi5pZC52ZXJzaW9uID0gMHgwMTAwOworCXh0a2JkLT5kZXYuZGV2ID0gJnNlcmlvLT5kZXY7CisKKwlpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoJnh0a2JkLT5kZXYpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiaW5wdXQ6ICVzIG9uICVzXG4iLCB4dGtiZF9uYW1lLCBzZXJpby0+cGh5cyk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgeHRrYmRfZGlzY29ubmVjdChzdHJ1Y3Qgc2VyaW8gKnNlcmlvKQoreworCXN0cnVjdCB4dGtiZCAqeHRrYmQgPSBzZXJpb19nZXRfZHJ2ZGF0YShzZXJpbyk7CisKKwlpbnB1dF91bnJlZ2lzdGVyX2RldmljZSgmeHRrYmQtPmRldik7CisJc2VyaW9fY2xvc2Uoc2VyaW8pOworCXNlcmlvX3NldF9kcnZkYXRhKHNlcmlvLCBOVUxMKTsKKwlrZnJlZSh4dGtiZCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2VyaW9fZGV2aWNlX2lkIHh0a2JkX3NlcmlvX2lkc1tdID0geworCXsKKwkJLnR5cGUJPSBTRVJJT19YVCwKKwkJLnByb3RvCT0gU0VSSU9fQU5ZLAorCQkuaWQJPSBTRVJJT19BTlksCisJCS5leHRyYQk9IFNFUklPX0FOWSwKKwl9LAorCXsgMCB9Cit9OworCitNT0RVTEVfREVWSUNFX1RBQkxFKHNlcmlvLCB4dGtiZF9zZXJpb19pZHMpOworCitzdGF0aWMgc3RydWN0IHNlcmlvX2RyaXZlciB4dGtiZF9kcnYgPSB7CisJLmRyaXZlcgkJPSB7CisJCS5uYW1lCT0gInh0a2JkIiwKKwl9LAorCS5kZXNjcmlwdGlvbgk9IERSSVZFUl9ERVNDLAorCS5pZF90YWJsZQk9IHh0a2JkX3NlcmlvX2lkcywKKwkuaW50ZXJydXB0CT0geHRrYmRfaW50ZXJydXB0LAorCS5jb25uZWN0CT0geHRrYmRfY29ubmVjdCwKKwkuZGlzY29ubmVjdAk9IHh0a2JkX2Rpc2Nvbm5lY3QsCit9OworCitzdGF0aWMgaW50IF9faW5pdCB4dGtiZF9pbml0KHZvaWQpCit7CisJc2VyaW9fcmVnaXN0ZXJfZHJpdmVyKCZ4dGtiZF9kcnYpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgeHRrYmRfZXhpdCh2b2lkKQoreworCXNlcmlvX3VucmVnaXN0ZXJfZHJpdmVyKCZ4dGtiZF9kcnYpOworfQorCittb2R1bGVfaW5pdCh4dGtiZF9pbml0KTsKK21vZHVsZV9leGl0KHh0a2JkX2V4aXQpOwo=