ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvS2NvbmZpZyBiL2RyaXZlcnMvbXRkL2RldmljZXMvS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNGE1NmE0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9LY29uZmlnCkBAIC0wLDAgKzEsMjU5IEBACisjIGRyaXZlcnMvbXRkL21hcHMvS2NvbmZpZworIyAkSWQ6IEtjb25maWcsdiAxLjE1IDIwMDQvMTIvMjIgMTc6NTE6MTUgam9lcm4gRXhwICQKKworbWVudSAiU2VsZi1jb250YWluZWQgTVREIGRldmljZSBkcml2ZXJzIgorCWRlcGVuZHMgb24gTVREIT1uCisKK2NvbmZpZyBNVERfUE1DNTUxCisJdHJpc3RhdGUgIlJhbWl4IFBNQzU1MSBQQ0kgTWV6emFuaW5lIFJBTSBjYXJkIHN1cHBvcnQiCisJZGVwZW5kcyBvbiBNVEQgJiYgUENJCisJLS0taGVscC0tLQorCSAgVGhpcyBwcm92aWRlcyBhIE1URCBkZXZpY2UgZHJpdmVyIGZvciB0aGUgUmFtaXggUE1DNTUxIFJBTSBQQ0kgY2FyZAorCSAgZnJvbSBSYW1peCBJbmMuIDxodHRwOi8vd3d3LnJhbWl4LmNvbS9wcm9kdWN0cy9tZW1vcnkvcG1jNTUxLmh0bWw+LgorCSAgVGhlc2UgZGV2aWNlcyBjb21lIGluIG1lbW9yeSBjb25maWd1cmF0aW9ucyBmcm9tIDMyTSAtIDFHLiAgSWYgeW91CisJICBoYXZlIG9uZSwgeW91IHByb2JhYmx5IHdhbnQgdG8gZW5hYmxlIHRoaXMuCisKKwkgIElmIHRoaXMgZHJpdmVyIGlzIGNvbXBpbGVkIGFzIGEgbW9kdWxlIHlvdSBnZXQgdGhlIGFiaWxpdHkgdG8gc2VsZWN0CisJICB0aGUgc2l6ZSBvZiB0aGUgYXBlcnR1cmUgd2luZG93IHBvaW50aW5nIGludG8gdGhlIGRldmljZXMgbWVtb3J5LgorCSAgV2hhdCB0aGlzIG1lYW5zIGlzIHRoYXQgaWYgeW91IGhhdmUgYSAxRyBjYXJkLCBub3JtYWxseSB0aGUga2VybmVsCisJICB3aWxsIHVzZSBhIDFHIG1lbW9yeSBtYXAgYXMgaXRzIHZpZXcgb2YgdGhlIGRldmljZS4gIEFzIGEgbW9kdWxlLAorCSAgeW91IGNhbiBzZWxlY3QgYSAxTSB3aW5kb3cgaW50byB0aGUgbWVtb3J5IGFuZCB0aGUgZHJpdmVyIHdpbGwKKwkgICJzbGlkZSIgdGhlIHdpbmRvdyBhcm91bmQgdGhlIFBNQzU1MSdzIG1lbW9yeS4gIFRoaXMgd2FzCisJICBwYXJ0aWN1bGFybHkgdXNlZnVsIG9uIHRoZSAyLjIga2VybmVscyBvbiBQUEMgYXJjaGl0ZWN0dXJlcyBhcyB0aGVyZQorCSAgd2FzIGxpbWl0ZWQga2VybmVsIHNwYWNlIHRvIGRlYWwgd2l0aC4KKworY29uZmlnIE1URF9QTUM1NTFfQlVHRklYCisJYm9vbCAiUE1DNTUxIDI1Nk0gRFJBTSBCdWdmaXgiCisJZGVwZW5kcyBvbiBNVERfUE1DNTUxCisJaGVscAorCSAgU29tZSBvZiBSYW1peCdzIFBNQzU1MSBib2FyZHMgd2l0aCAyNTZNIGNvbmZpZ3VyYXRpb25zIGhhdmUgaW52YWxpZAorCSAgY29sdW1uIGFuZCByb3cgbXV4IHZhbHVlcy4gIFRoaXMgb3B0aW9uIHdpbGwgZml4IHRoZW0sIGJ1dCB3aWxsCisJICBicmVhayBvdGhlciBtZW1vcnkgY29uZmlndXJhdGlvbnMuICBJZiB1bnN1cmUgc2F5IE4uCisKK2NvbmZpZyBNVERfUE1DNTUxX0RFQlVHCisJYm9vbCAiUE1DNTUxIERlYnVnZ2luZyIKKwlkZXBlbmRzIG9uIE1URF9QTUM1NTEKKwloZWxwCisJICBUaGlzIG9wdGlvbiBtYWtlcyB0aGUgUE1DNTUxIG1vcmUgdmVyYm9zZSBkdXJpbmcgaXRzIG9wZXJhdGlvbiBhbmQKKwkgIGlzIG9ubHkgcmVhbGx5IHVzZWZ1bCBpZiB5b3UgYXJlIGRldmVsb3Bpbmcgb24gdGhpcyBkcml2ZXIgb3IKKwkgIHN1c3BlY3QgYSBwb3NzaWJsZSBoYXJkd2FyZSBvciBkcml2ZXIgYnVnLiAgSWYgdW5zdXJlIHNheSBOLgorCitjb25maWcgTVREX01TMDJOVgorCXRyaXN0YXRlICJERUMgTVMwMi1OViBOVlJBTSBtb2R1bGUgc3VwcG9ydCIKKwlkZXBlbmRzIG9uIE1URCAmJiBNQUNIX0RFQ1NUQVRJT04KKwloZWxwCisJICBUaGlzIGlzIGFuIE1URCBkcml2ZXIgZm9yIHRoZSBERUMncyBNUzAyLU5WICg1NC0yMDk0OC0wMSkgYmF0dGVyeQorCSAgYmFja2VkLXVwIE5WUkFNIG1vZHVsZS4gIFRoZSBtb2R1bGUgd2FzIG9yaWdpbmFsbHkgbWVhbnQgYXMgYW4gTkZTCisJICBhY2NlbGVyYXRvci4gIFNheSBZIGhlcmUgaWYgeW91IGhhdmUgYSBERUNzdGF0aW9uIDUwMDAvMngwIG9yIGEKKwkgIERFQ3N5c3RlbSA1OTAwIGVxdWlwcGVkIHdpdGggc3VjaCBhIG1vZHVsZS4KKworY29uZmlnIE1URF9TTFJBTQorCXRyaXN0YXRlICJVbmNhY2hlZCBzeXN0ZW0gUkFNIgorCWRlcGVuZHMgb24gTVRECisJaGVscAorCSAgSWYgeW91ciBDUFUgY2Fubm90IGNhY2hlIGFsbCBvZiB0aGUgcGh5c2ljYWwgbWVtb3J5IGluIHlvdXIgbWFjaGluZSwKKwkgIHlvdSBjYW4gc3RpbGwgdXNlIGl0IGZvciBzdG9yYWdlIG9yIHN3YXAgYnkgdXNpbmcgdGhpcyBkcml2ZXIgdG8KKwkgIHByZXNlbnQgaXQgdG8gdGhlIHN5c3RlbSBhcyBhIE1lbW9yeSBUZWNobm9sb2d5IERldmljZS4KKworY29uZmlnIE1URF9QSFJBTQorCXRyaXN0YXRlICJQaHlzaWNhbCBzeXN0ZW0gUkFNIgorCWRlcGVuZHMgb24gTVRECisJaGVscAorCSAgVGhpcyBpcyBhIHJlLWltcGxlbWVudGF0aW9uIG9mIHRoZSBzbHJhbSBkcml2ZXIgYWJvdmUuCisKKwkgIFVzZSB0aGlzIGRyaXZlciB0byBhY2Nlc3MgcGh5c2ljYWwgbWVtb3J5IHRoYXQgdGhlIGtlcm5lbCBwcm9wZXIKKwkgIGRvZXNuJ3QgaGF2ZSBhY2Nlc3MgdG8sIG1lbW9yeSBiZXlvbmQgdGhlIG1lbT14eHggbGltaXQsIG52cmFtLAorCSAgbWVtb3J5IG9uIHRoZSB2aWRlbyBjYXJkLCBldGMuLi4KKworY29uZmlnIE1URF9MQVJUCisJdHJpc3RhdGUgIjI4RjE2MHh4IGZsYXNoIGRyaXZlciBmb3IgTEFSVCIKKwlkZXBlbmRzIG9uIFNBMTEwMF9MQVJUICYmIE1URAorCWhlbHAKKwkgIFRoaXMgZW5hYmxlcyB0aGUgZmxhc2ggZHJpdmVyIGZvciBMQVJULiBQbGVhc2Ugbm90ZSB0aGF0IHlvdSBkbworCSAgbm90IG5lZWQgYW55IG1hcHBpbmcvY2hpcCBkcml2ZXIgZm9yIExBUlQuIFRoaXMgb25lIGRvZXMgaXQgYWxsCisJICBmb3IgeW91LCBzbyBnbyBkaXNhYmxlIGFsbCBvZiB0aG9zZSBpZiB5b3UgZW5hYmxlZCBzb21lIG9mIHRoZW0gKDoKKworY29uZmlnIE1URF9NVERSQU0KKwl0cmlzdGF0ZSAiVGVzdCBkcml2ZXIgdXNpbmcgUkFNIgorCWRlcGVuZHMgb24gTVRECisJaGVscAorCSAgVGhpcyBlbmFibGVzIGEgdGVzdCBNVEQgZGV2aWNlIGRyaXZlciB3aGljaCB1c2VzIHZtYWxsb2MoKSB0bworCSAgcHJvdmlkZSBzdG9yYWdlLiAgWW91IHByb2JhYmx5IHdhbnQgdG8gc2F5ICdOJyB1bmxlc3MgeW91J3JlCisJICB0ZXN0aW5nIHN0dWZmLgorCitjb25maWcgTVREUkFNX1RPVEFMX1NJWkUKKwlpbnQgIk1URFJBTSBkZXZpY2Ugc2l6ZSBpbiBLaUIiCisJZGVwZW5kcyBvbiBNVERfTVREUkFNCisJZGVmYXVsdCAiNDA5NiIKKwloZWxwCisJICBUaGlzIGFsbG93cyB5b3UgdG8gY29uZmlndXJlIHRoZSB0b3RhbCBzaXplIG9mIHRoZSBNVEQgZGV2aWNlCisJICBlbXVsYXRlZCBieSB0aGUgTVREUkFNIGRyaXZlci4gIElmIHRoZSBNVERSQU0gZHJpdmVyIGlzIGJ1aWx0CisJICBhcyBhIG1vZHVsZSwgaXQgaXMgYWxzbyBwb3NzaWJsZSB0byBzcGVjaWZ5IHRoaXMgYXMgYSBwYXJhbWV0ZXIgd2hlbgorCSAgbG9hZGluZyB0aGUgbW9kdWxlLgorCitjb25maWcgTVREUkFNX0VSQVNFX1NJWkUKKwlpbnQgIk1URFJBTSBlcmFzZSBibG9jayBzaXplIGluIEtpQiIKKwlkZXBlbmRzIG9uIE1URF9NVERSQU0KKwlkZWZhdWx0ICIxMjgiCisJaGVscAorCSAgVGhpcyBhbGxvd3MgeW91IHRvIGNvbmZpZ3VyZSB0aGUgc2l6ZSBvZiB0aGUgZXJhc2UgYmxvY2tzIGluIHRoZQorCSAgZGV2aWNlIGVtdWxhdGVkIGJ5IHRoZSBNVERSQU0gZHJpdmVyLiAgSWYgdGhlIE1URFJBTSBkcml2ZXIgaXMgYnVpbHQKKwkgIGFzIGEgbW9kdWxlLCBpdCBpcyBhbHNvIHBvc3NpYmxlIHRvIHNwZWNpZnkgdGhpcyBhcyBhIHBhcmFtZXRlciB3aGVuCisJICBsb2FkaW5nIHRoZSBtb2R1bGUuCisKKyNJZiBub3QgYSBtb2R1bGUgKEkgZG9uJ3Qgd2FudCB0byB0ZXN0IGl0IGFzIGEgbW9kdWxlKQorY29uZmlnIE1URFJBTV9BQlNfUE9TCisJaGV4ICJTUkFNIEhleGFkZWNpbWFsIEFic29sdXRlIHBvc2l0aW9uIG9yIDAiCisJZGVwZW5kcyBvbiBNVERfTVREUkFNPXkKKwlkZWZhdWx0ICIwIgorCWhlbHAKKwkgIElmIHlvdSBoYXZlIHN5c3RlbSBSQU0gYWNjZXNzaWJsZSBieSB0aGUgQ1BVIGJ1dCBub3QgdXNlZCBieSBMaW51eAorCSAgaW4gbm9ybWFsIG9wZXJhdGlvbiwgeW91IGNhbiBnaXZlIHRoZSBwaHlzaWNhbCBhZGRyZXNzIGF0IHdoaWNoIHRoZQorCSAgYXZhaWxhYmxlIFJBTSBzdGFydHMsIGFuZCB0aGUgTVREUkFNIGRyaXZlciB3aWxsIHVzZSBpdCBpbnN0ZWFkIG9mCisJICBhbGxvY2F0aW5nIHNwYWNlIGZyb20gTGludXgncyBhdmFpbGFibGUgbWVtb3J5LiBPdGhlcndpc2UsIGxlYXZlIAorCSAgdGhpcyBzZXQgdG8gemVyby4gTW9zdCBwZW9wbGUgd2lsbCB3YW50IHRvIGxlYXZlIHRoaXMgYXMgemVyby4KKworY29uZmlnIE1URF9CTEtNVEQKKwl0cmlzdGF0ZSAiTVREIGVtdWxhdGlvbiB1c2luZyBibG9jayBkZXZpY2UiCisJZGVwZW5kcyBvbiBNVEQKKwloZWxwCisJICBUaGlzIGRyaXZlciBhbGxvd3MgYSBibG9jayBkZXZpY2UgdG8gYXBwZWFyIGFzIGFuIE1URC4gSXQgd291bGQKKwkgIGdlbmVyYWxseSBiZSB1c2VkIGluIHRoZSBmb2xsb3dpbmcgY2FzZXM6CisKKwkgIFVzaW5nIENvbXBhY3QgRmxhc2ggYXMgYW4gTVRELCB0aGVzZSB1c3VhbGx5IHByZXNlbnQgdGhlbXNlbHZlcyB0bworCSAgdGhlIHN5c3RlbSBhcyBhbiBBVEEgZHJpdmUuCisJICBUZXN0aW5nIE1URCB1c2VycyAoZWcgSkZGUzIpIG9uIGxhcmdlIG1lZGlhIGFuZCBtZWRpYSB0aGF0IG1pZ2h0CisJICBiZSByZW1vdmVkIGR1cmluZyBhIHdyaXRlICh1c2luZyB0aGUgZmxvcHB5IGRyaXZlKS4KKworY29uZmlnIE1URF9CTE9DSzJNVEQKKwl0cmlzdGF0ZSAiTVREIHVzaW5nIGJsb2NrIGRldmljZSAocmV3cml0ZSkiCisJZGVwZW5kcyBvbiBNVEQgJiYgRVhQRVJJTUVOVEFMCisJaGVscAorCSAgVGhpcyBkcml2ZXIgaXMgYmFzaWNhbGx5IHRoZSBzYW1lIGF0IE1URF9CTEtNVEQgYWJvdmUsIGJ1dAorCSAgZXhwZXJpZW5jZWQgc29tZSBpbnRlcmZhY2UgY2hhbmdlcyBwbHVzIHNlcmlvdXMgc3BlZWR1cHMuICBJbgorCSAgdGhlIGxvbmcgdGVybSwgaXQgc2hvdWxkIHJlcGxhY2UgTVREX0JMS01URC4gIFJpZ2h0IG5vdywgeW91CisJICBzaG91bGRuJ3QgZW50cnVzdCBpbXBvcnRhbnQgZGF0YSB0byBpdCB5ZXQuCisKK2NvbW1lbnQgIkRpc2stT24tQ2hpcCBEZXZpY2UgRHJpdmVycyIKKworY29uZmlnIE1URF9ET0MyMDAwCisJdHJpc3RhdGUgIk0tU3lzdGVtcyBEaXNrLU9uLUNoaXAgMjAwMCBhbmQgTWlsbGVubml1bSAoREVQUkVDQVRFRCkiCisJZGVwZW5kcyBvbiBNVEQKKwlzZWxlY3QgTVREX0RPQ1BST0JFCisJc2VsZWN0IE1URF9OQU5EX0lEUworCS0tLWhlbHAtLS0KKwkgIFRoaXMgcHJvdmlkZXMgYW4gTVREIGRldmljZSBkcml2ZXIgZm9yIHRoZSBNLVN5c3RlbXMgRGlza09uQ2hpcAorCSAgMjAwMCBhbmQgTWlsbGVubml1bSBkZXZpY2VzLiAgT3JpZ2luYWxseSBkZXNpZ25lZCBmb3IgdGhlIERpc2tPbkNoaXAKKwkgIDIwMDAsIGl0IGFsc28gbm93IGluY2x1ZGVzIHN1cHBvcnQgZm9yIHRoZSBEaXNrT25DaGlwIE1pbGxlbm5pdW0uCisJICBJZiB5b3UgaGF2ZSBwcm9ibGVtcyB3aXRoIHRoaXMgZHJpdmVyIGFuZCB0aGUgRGlza09uQ2hpcCBNaWxsZW5uaXVtLAorCSAgeW91IG1heSB3aXNoIHRvIHRyeSB0aGUgYWx0ZXJuYXRpdmUgTWlsbGVubml1bSBkcml2ZXIgYmVsb3cuIFRvIHVzZQorCSAgdGhlIGFsdGVybmF0aXZlIGRyaXZlciwgeW91IHdpbGwgbmVlZCB0byB1bmRlZmluZSBET0NfU0lOR0xFX0RSSVZFUgorCSAgaW4gdGhlIDxmaWxlOmRyaXZlcnMvbXRkL2RldmljZXMvZG9jcHJvYmUuYz4gc291cmNlIGNvZGUuCisKKwkgIElmIHlvdSB1c2UgdGhpcyBkZXZpY2UsIHlvdSBwcm9iYWJseSBhbHNvIHdhbnQgdG8gZW5hYmxlIHRoZSBORlRMCisJICAnTkFORCBGbGFzaCBUcmFuc2xhdGlvbiBMYXllcicgb3B0aW9uIGJlbG93LCB3aGljaCBpcyB1c2VkIHRvCisJICBlbXVsYXRlIGEgYmxvY2sgZGV2aWNlIGJ5IHVzaW5nIGEga2luZCBvZiBmaWxlIHN5c3RlbSBvbiB0aGUgZmxhc2gKKwkgIGNoaXBzLgorCisJICBOT1RFOiBUaGlzIGRyaXZlciBpcyBkZXByZWNhdGVkIGFuZCB3aWxsIHByb2JhYmx5IGJlIHJlbW92ZWQgc29vbi4KKwkgIFBsZWFzZSB0cnkgdGhlIG5ldyBEaXNrT25DaGlwIGRyaXZlciB1bmRlciAiTkFORCBGbGFzaCBEZXZpY2UKKwkgIERyaXZlcnMiLgorCitjb25maWcgTVREX0RPQzIwMDEKKwl0cmlzdGF0ZSAiTS1TeXN0ZW1zIERpc2stT24tQ2hpcCBNaWxsZW5uaXVtLW9ubHkgYWx0ZXJuYXRpdmUgZHJpdmVyIChERVBSRUNBVEVEKSIKKwlkZXBlbmRzIG9uIE1URAorCXNlbGVjdCBNVERfRE9DUFJPQkUKKwlzZWxlY3QgTVREX05BTkRfSURTCisJLS0taGVscC0tLQorCSAgVGhpcyBwcm92aWRlcyBhbiBhbHRlcm5hdGl2ZSBNVEQgZGV2aWNlIGRyaXZlciBmb3IgdGhlIE0tU3lzdGVtcyAKKwkgIERpc2tPbkNoaXAgTWlsbGVubml1bSBkZXZpY2VzLiAgVXNlIHRoaXMgaWYgeW91IGhhdmUgcHJvYmxlbXMgd2l0aAorCSAgdGhlIGNvbWJpbmVkIERpc2tPbkNoaXAgMjAwMCBhbmQgTWlsbGVubml1bSBkcml2ZXIgYWJvdmUuICBUbyBnZXQKKwkgIHRoZSBEaXNrT25DaGlwIHByb2JlIGNvZGUgdG8gbG9hZCBhbmQgdXNlIHRoaXMgZHJpdmVyIGluc3RlYWQgb2YKKwkgIHRoZSBvdGhlciBvbmUsIHlvdSB3aWxsIG5lZWQgdG8gdW5kZWZpbmUgRE9DX1NJTkdMRV9EUklWRVIgbmVhcgorCSAgdGhlIGJlZ2lubmluZyBvZiA8ZmlsZTpkcml2ZXJzL210ZC9kZXZpY2VzL2RvY3Byb2JlLmM+LgorCisJICBJZiB5b3UgdXNlIHRoaXMgZGV2aWNlLCB5b3UgcHJvYmFibHkgYWxzbyB3YW50IHRvIGVuYWJsZSB0aGUgTkZUTAorCSAgJ05BTkQgRmxhc2ggVHJhbnNsYXRpb24gTGF5ZXInIG9wdGlvbiBiZWxvdywgd2hpY2ggaXMgdXNlZCB0bworCSAgZW11bGF0ZSBhIGJsb2NrIGRldmljZSBieSB1c2luZyBhIGtpbmQgb2YgZmlsZSBzeXN0ZW0gb24gdGhlIGZsYXNoCisJICBjaGlwcy4KKworCSAgTk9URTogVGhpcyBkcml2ZXIgaXMgZGVwcmVjYXRlZCBhbmQgd2lsbCBwcm9iYWJseSBiZSByZW1vdmVkIHNvb24uCisJICBQbGVhc2UgdHJ5IHRoZSBuZXcgRGlza09uQ2hpcCBkcml2ZXIgdW5kZXIgIk5BTkQgRmxhc2ggRGV2aWNlCisJICBEcml2ZXJzIi4KKworY29uZmlnIE1URF9ET0MyMDAxUExVUworCXRyaXN0YXRlICJNLVN5c3RlbXMgRGlzay1Pbi1DaGlwIE1pbGxlbm5pdW0gUGx1cyIKKwlkZXBlbmRzIG9uIE1URAorCXNlbGVjdCBNVERfRE9DUFJPQkUKKwlzZWxlY3QgTVREX05BTkRfSURTCisJLS0taGVscC0tLQorCSAgVGhpcyBwcm92aWRlcyBhbiBNVEQgZGV2aWNlIGRyaXZlciBmb3IgdGhlIE0tU3lzdGVtcyBEaXNrT25DaGlwCisJICBNaWxsZW5uaXVtIFBsdXMgZGV2aWNlcy4KKworCSAgSWYgeW91IHVzZSB0aGlzIGRldmljZSwgeW91IHByb2JhYmx5IGFsc28gd2FudCB0byBlbmFibGUgdGhlIElORlRMCisJICAnSW52ZXJzZSBOQU5EIEZsYXNoIFRyYW5zbGF0aW9uIExheWVyJyBvcHRpb24gYmVsb3csIHdoaWNoIGlzIHVzZWQKKwkgIHRvIGVtdWxhdGUgYSBibG9jayBkZXZpY2UgYnkgdXNpbmcgYSBraW5kIG9mIGZpbGUgc3lzdGVtIG9uIHRoZSAKKwkgIGZsYXNoIGNoaXBzLgorCisJICBOT1RFOiBUaGlzIGRyaXZlciB3aWxsIHNvb24gYmUgcmVwbGFjZWQgYnkgdGhlIG5ldyBEaXNrT25DaGlwIGRyaXZlcgorCSAgdW5kZXIgIk5BTkQgRmxhc2ggRGV2aWNlIERyaXZlcnMiIChjdXJyZW50bHkgdGhhdCBkcml2ZXIgZG9lcyBub3QKKwkgIHN1cHBvcnQgYWxsIE1pbGxlbm5pdW0gUGx1cyBkZXZpY2VzKS4KKworY29uZmlnIE1URF9ET0NQUk9CRQorCXRyaXN0YXRlCisJc2VsZWN0IE1URF9ET0NFQ0MKKworY29uZmlnIE1URF9ET0NFQ0MKKwl0cmlzdGF0ZQorCitjb25maWcgTVREX0RPQ1BST0JFX0FEVkFOQ0VECisJYm9vbCAiQWR2YW5jZWQgZGV0ZWN0aW9uIG9wdGlvbnMgZm9yIERpc2tPbkNoaXAiCisJZGVwZW5kcyBvbiBNVERfRE9DUFJPQkUKKwloZWxwCisJICBUaGlzIG9wdGlvbiBhbGxvd3MgeW91IHRvIHNwZWNpZnkgbm9uc3RhbmRhcmQgYWRkcmVzcyBhdCB3aGljaCB0bworCSAgcHJvYmUgZm9yIGEgRGlza09uQ2hpcCwgb3IgdG8gY2hhbmdlIHRoZSBkZXRlY3Rpb24gb3B0aW9ucy4gIFlvdQorCSAgYXJlIHVubGlrZWx5IHRvIG5lZWQgYW55IG9mIHRoaXMgdW5sZXNzIHlvdSBhcmUgdXNpbmcgTGludXhCSU9TLgorCSAgU2F5ICdOJy4KKworY29uZmlnIE1URF9ET0NQUk9CRV9BRERSRVNTCisJaGV4ICJQaHlzaWNhbCBhZGRyZXNzIG9mIERpc2tPbkNoaXAiIGlmIE1URF9ET0NQUk9CRV9BRFZBTkNFRAorCWRlcGVuZHMgb24gTVREX0RPQ1BST0JFCisJZGVmYXVsdCAiMHgwMDAwIiBpZiBNVERfRE9DUFJPQkVfQURWQU5DRUQKKwlkZWZhdWx0ICIwIiBpZiAhTVREX0RPQ1BST0JFX0FEVkFOQ0VECisJLS0taGVscC0tLQorCSAgQnkgZGVmYXVsdCwgdGhlIHByb2JlIGZvciBEaXNrT25DaGlwIGRldmljZXMgd2lsbCBsb29rIGZvciBhCisJICBEaXNrT25DaGlwIGF0IGV2ZXJ5IG11bHRpcGxlIG9mIDB4MjAwMCBiZXR3ZWVuIDB4QzgwMDAgYW5kIDB4RUUwMDAuCisJICBUaGlzIG9wdGlvbiBhbGxvd3MgeW91IHRvIHNwZWNpZnkgYSBzaW5nbGUgYWRkcmVzcyBhdCB3aGljaCB0byBwcm9iZQorCSAgZm9yIHRoZSBkZXZpY2UsIHdoaWNoIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBvdGhlciBkZXZpY2VzIGluIHRoYXQKKwkgIHJhbmdlIHdoaWNoIGdldCB1cHNldCB3aGVuIHRoZXkgYXJlIHByb2JlZC4KKworCSAgKE5vdGUgdGhhdCBvbiBQb3dlclBDLCB0aGUgbm9ybWFsIHByb2JlIHdpbGwgb25seSBjaGVjayBhdAorCSAgMHhFNDAwMDAwMC4pCisKKwkgIE5vcm1hbGx5LCB5b3Ugc2hvdWxkIGxlYXZlIHRoaXMgc2V0IHRvIHplcm8sIHRvIGFsbG93IHRoZSBwcm9iZSBhdAorCSAgdGhlIG5vcm1hbCBhZGRyZXNzZXMuCisKK2NvbmZpZyBNVERfRE9DUFJPQkVfSElHSAorCWJvb2wgIlByb2JlIGhpZ2ggYWRkcmVzc2VzIgorCWRlcGVuZHMgb24gTVREX0RPQ1BST0JFX0FEVkFOQ0VECisJaGVscAorCSAgQnkgZGVmYXVsdCwgdGhlIHByb2JlIGZvciBEaXNrT25DaGlwIGRldmljZXMgd2lsbCBsb29rIGZvciBhCisJICBEaXNrT25DaGlwIGF0IGV2ZXJ5IG11bHRpcGxlIG9mIDB4MjAwMCBiZXR3ZWVuIDB4QzgwMDAgYW5kIDB4RUUwMDAuCisJICBUaGlzIG9wdGlvbiBjaGFuZ2VzIHRvIG1ha2UgaXQgcHJvYmUgYmV0d2VlbiAweEZGRkM4MDAwIGFuZAorCSAgMHhGRkZFRTAwMC4gIFVubGVzcyB5b3UgYXJlIHVzaW5nIExpbnV4QklPUywgdGhpcyBpcyB1bmxpa2VseSB0byBiZQorCSAgdXNlZnVsIHRvIHlvdS4gIFNheSAnTicuCisKK2NvbmZpZyBNVERfRE9DUFJPQkVfNTVBQQorCWJvb2wgIlByb2JlIGZvciAweDU1IDB4QUEgQklPUyBFeHRlbnNpb24gU2lnbmF0dXJlIgorCWRlcGVuZHMgb24gTVREX0RPQ1BST0JFX0FEVkFOQ0VECisJaGVscAorCSAgQ2hlY2sgZm9yIHRoZSAweDU1IDB4QUEgc2lnbmF0dXJlIG9mIGEgRGlza09uQ2hpcCwgYW5kIGRvIG5vdAorCSAgY29udGludWUgd2l0aCBwcm9iaW5nIGlmIGl0IGlzIGFic2VudC4gIFRoZSBzaWduYXR1cmUgd2lsbCBhbHdheXMgYmUKKwkgIHByZXNlbnQgZm9yIGEgRGlza09uQ2hpcCAyMDAwIG9yIGEgbm9ybWFsIERpc2tPbkNoaXAgTWlsbGVubml1bS4KKwkgIE9ubHkgaWYgeW91IGhhdmUgb3ZlcndyaXR0ZW4gdGhlIGZpcnN0IGJsb2NrIG9mIGEgRGlza09uQ2hpcAorCSAgTWlsbGVubml1bSB3aWxsIGl0IGJlIGFic2VudC4gIEVuYWJsZSB0aGlzIG9wdGlvbiBpZiB5b3UgYXJlIHVzaW5nCisJICBMaW51eEJJT1Mgb3IgaWYgeW91IG5lZWQgdG8gcmVjb3ZlciBhIERpc2tPbkNoaXAgTWlsbGVubml1bSBvbiB3aGljaAorCSAgeW91IGhhdmUgbWFuYWdlZCB0byB3aXBlIHRoZSBmaXJzdCBibG9jay4KKworZW5kbWVudQorCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL01ha2VmaWxlIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9NYWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMzhkYjM0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9NYWtlZmlsZQpAQCAtMCwwICsxLDI1IEBACisjCisjIGxpbnV4L2RyaXZlcnMvZGV2aWNlcy9NYWtlZmlsZQorIworIyAkSWQ6IE1ha2VmaWxlLmNvbW1vbix2IDEuNyAyMDA0LzEyLzIyIDE3OjUxOjE1IGpvZXJuIEV4cCAkCisKKyMgICAgICAgICAgICAgICAgICAgICAgICoqKiBCSUcgVUdMWSBOT1RFICoqKgorIworIyBUaGUgcmVtb3ZhbCBvZiBnZXRfbW9kdWxlX3N5bWJvbCgpIGFuZCByZXBsYWNlbWVudCB3aXRoCisjIGludGVyX21vZHVsZV9yZWdpc3RlcigpIGV0IGFsIGhhcyBpbnRyb2R1Y2VkIGEgbGluayBvcmRlciBkZXBlbmRlbmN5CisjIGhlcmUgd2hlcmUgcHJldmlvdXNseSB0aGVyZSB3YXMgbm9uZS4gIFdlIG5vdyBoYXZlIHRvIGVuc3VyZSB0aGF0CisjIGRvYzIwMFswMV0ubyBhcmUgbGlua2VkIGJlZm9yZSBkb2Nwcm9iZS5vCisKK29iai0kKENPTkZJR19NVERfRE9DMjAwMCkJKz0gZG9jMjAwMC5vCitvYmotJChDT05GSUdfTVREX0RPQzIwMDEpCSs9IGRvYzIwMDEubworb2JqLSQoQ09ORklHX01URF9ET0MyMDAxUExVUykJKz0gZG9jMjAwMXBsdXMubworb2JqLSQoQ09ORklHX01URF9ET0NQUk9CRSkJKz0gZG9jcHJvYmUubworb2JqLSQoQ09ORklHX01URF9ET0NFQ0MpCSs9IGRvY2VjYy5vCitvYmotJChDT05GSUdfTVREX1NMUkFNKQkJKz0gc2xyYW0ubworb2JqLSQoQ09ORklHX01URF9QSFJBTSkJCSs9IHBocmFtLm8KK29iai0kKENPTkZJR19NVERfUE1DNTUxKQkrPSBwbWM1NTEubworb2JqLSQoQ09ORklHX01URF9NUzAyTlYpCSs9IG1zMDItbnYubworb2JqLSQoQ09ORklHX01URF9NVERSQU0pCSs9IG10ZHJhbS5vCitvYmotJChDT05GSUdfTVREX0xBUlQpCQkrPSBsYXJ0Lm8KK29iai0kKENPTkZJR19NVERfQkxLTVREKQkrPSBibGttdGQubworb2JqLSQoQ09ORklHX01URF9CTE9DSzJNVEQpCSs9IGJsb2NrMm10ZC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL2Jsa210ZC5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9ibGttdGQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NjJlODA3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9ibGttdGQuYwpAQCAtMCwwICsxLDgyMyBAQAorLyoKKyAqICRJZDogYmxrbXRkLmMsdiAxLjI0IDIwMDQvMTEvMTYgMTg6Mjk6MDEgZHdtdzIgRXhwICQKKyAqCisgKiBibGttdGQuYyAtIHVzZSBhIGJsb2NrIGRldmljZSBhcyBhIGZha2UgTVRECisgKgorICogQXV0aG9yOiBTaW1vbiBFdmFucyA8c3BzZUBzZWNyZXQub3JnLnVrPgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwMSwyMDAyIFNpbW9uIEV2YW5zCisgKgorICogTGljZW5jZTogR1BMCisgKgorICogSG93IGl0IHdvcmtzOgorICoJVGhlIGRyaXZlciB1c2VzIHJhdy9pbyB0byByZWFkL3dyaXRlIHRoZSBkZXZpY2UgYW5kIHRoZSBwYWdlCisgKgljYWNoZSB0byBjYWNoZSBhY2Nlc3MuIFdyaXRlcyB1cGRhdGUgdGhlIHBhZ2UgY2FjaGUgd2l0aCB0aGUKKyAqCW5ldyBkYXRhIGFuZCBtYXJrIGl0IGRpcnR5IGFuZCBhZGQgdGhlIHBhZ2UgaW50byBhIEJJTyB3aGljaAorICoJaXMgdGhlbiB3cml0dGVuIG91dC4KKyAqCisgKglJdCBjYW4gYmUgbG9hZGVkIFJlYWQtT25seSB0byBwcmV2ZW50IGVyYXNlcyBhbmQgd3JpdGVzIHRvIHRoZQorICoJbWVkaXVtLgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvY29uZmlnLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KKyNpbmNsdWRlIDxsaW51eC9iaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9wYWdlbWFwLmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9tdGQvbXRkLmg+CisKKworI2RlZmluZSBlcnIoZm9ybWF0LCBhcmcuLi4pIHByaW50ayhLRVJOX0VSUiAiYmxrbXRkOiAiIGZvcm1hdCAiXG4iICwgIyMgYXJnKQorI2RlZmluZSBpbmZvKGZvcm1hdCwgYXJnLi4uKSBwcmludGsoS0VSTl9JTkZPICJibGttdGQ6ICIgZm9ybWF0ICJcbiIgLCAjIyBhcmcpCisjZGVmaW5lIHdhcm4oZm9ybWF0LCBhcmcuLi4pIHByaW50ayhLRVJOX1dBUk5JTkcgImJsa210ZDogIiBmb3JtYXQgIlxuIiAsICMjIGFyZykKKyNkZWZpbmUgY3JpdChmb3JtYXQsIGFyZy4uLikgcHJpbnRrKEtFUk5fQ1JJVCAiYmxrbXRkOiAiIGZvcm1hdCAiXG4iICwgIyMgYXJnKQorCisKKy8qIERlZmF1bHQgZXJhc2Ugc2l6ZSBpbiBLLCBhbHdheXMgbWFrZSBpdCBhIG11bHRpcGxlIG9mIFBBR0VfU0laRSAqLworI2RlZmluZSBDT05GSUdfTVREX0JMS0RFVl9FUkFTRVNJWkUgKDEyOCA8PCAxMCkJLyogMTI4S2lCICovCisjZGVmaW5lIFZFUlNJT04gIiRSZXZpc2lvbjogMS4yNCAkIgorCisvKiBJbmZvIGZvciB0aGUgYmxvY2sgZGV2aWNlICovCitzdHJ1Y3QgYmxrbXRkX2RldiB7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCXN0cnVjdCBibG9ja19kZXZpY2UgKmJsa2RldjsKKwlzdHJ1Y3QgbXRkX2luZm8gbXRkX2luZm87CisJc3RydWN0IHNlbWFwaG9yZSB3cmJ1Zl9tdXRleDsKK307CisKKworLyogU3RhdGljIGluZm8gYWJvdXQgdGhlIE1URCwgdXNlZCBpbiBjbGVhbnVwX21vZHVsZSAqLworc3RhdGljIExJU1RfSEVBRChibGttdGRfZGV2aWNlX2xpc3QpOworCisKK3N0YXRpYyB2b2lkIGJsa210ZF9zeW5jKHN0cnVjdCBtdGRfaW5mbyAqbXRkKTsKKworI2RlZmluZSBNQVhfREVWSUNFUyA0CisKKy8qIE1vZHVsZSBwYXJhbWV0ZXJzIHBhc3NlZCBieSBpbnNtb2QvbW9kcHJvYmUgKi8KK3N0YXRpYyBjaGFyICpkZXZpY2VbTUFYX0RFVklDRVNdOyAgICAvKiB0aGUgYmxvY2sgZGV2aWNlIHRvIHVzZSAqLworc3RhdGljIGludCBlcmFzZXN6W01BWF9ERVZJQ0VTXTsgICAgIC8qIG9wdGlvbmFsIGRlZmF1bHQgZXJhc2Ugc2l6ZSAqLworc3RhdGljIGludCByb1tNQVhfREVWSUNFU107ICAgICAgICAgIC8qIG9wdGlvbmFsIHJlYWQgb25seSBmbGFnICovCitzdGF0aWMgaW50IHN5bmM7CisKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiU2ltb24gRXZhbnMgPHNwc2VAc2VjcmV0Lm9yZy51az4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiRW11bGF0ZSBhbiBNVEQgdXNpbmcgYSBibG9jayBkZXZpY2UiKTsKK21vZHVsZV9wYXJhbV9hcnJheShkZXZpY2UsIGNoYXJwLCBOVUxMLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MoZGV2aWNlLCAiYmxvY2sgZGV2aWNlIHRvIHVzZSIpOworbW9kdWxlX3BhcmFtX2FycmF5KGVyYXNlc3osIGludCwgTlVMTCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKGVyYXNlc3osICJvcHRpb25hbCBlcmFzZSBzaXplIHRvIHVzZSBpbiBLaUIuIGVnIDQ9NEtpQi4iKTsKK21vZHVsZV9wYXJhbV9hcnJheShybywgYm9vbCwgTlVMTCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKHJvLCAiMT1SZWFkIG9ubHksIHdyaXRlcyBhbmQgZXJhc2VzIGNhdXNlIGVycm9ycyIpOworbW9kdWxlX3BhcmFtKHN5bmMsIGJvb2wsIDApOworTU9EVUxFX1BBUk1fREVTQyhzeW5jLCAiMT1TeW5jaHJvbm91cyB3cml0ZXMiKTsKKworCisvKiBjb21wbGV0aW9uIGhhbmRsZXIgZm9yIEJJTyByZWFkcyAqLworc3RhdGljIGludCBiaV9yZWFkX2NvbXBsZXRlKHN0cnVjdCBiaW8gKmJpbywgdW5zaWduZWQgaW50IGJ5dGVzX2RvbmUsIGludCBlcnJvcikKK3sKKwlpZiAoYmlvLT5iaV9zaXplKQorCQlyZXR1cm4gMTsKKworCWNvbXBsZXRlKChzdHJ1Y3QgY29tcGxldGlvbiopYmlvLT5iaV9wcml2YXRlKTsKKwlyZXR1cm4gMDsKK30KKworCisvKiBjb21wbGV0aW9uIGhhbmRsZXIgZm9yIEJJTyB3cml0ZXMgKi8KK3N0YXRpYyBpbnQgYmlfd3JpdGVfY29tcGxldGUoc3RydWN0IGJpbyAqYmlvLCB1bnNpZ25lZCBpbnQgYnl0ZXNfZG9uZSwgaW50IGVycm9yKQoreworCWNvbnN0IGludCB1cHRvZGF0ZSA9IHRlc3RfYml0KEJJT19VUFRPREFURSwgJmJpby0+YmlfZmxhZ3MpOworCXN0cnVjdCBiaW9fdmVjICpidmVjID0gYmlvLT5iaV9pb192ZWMgKyBiaW8tPmJpX3ZjbnQgLSAxOworCisJaWYgKGJpby0+Ymlfc2l6ZSkKKwkJcmV0dXJuIDE7CisKKwlpZighdXB0b2RhdGUpCisJCWVycigiYmlfd3JpdGVfY29tcGxldGU6IG5vdCB1cHRvZGF0ZVxuIik7CisKKwlkbyB7CisJCXN0cnVjdCBwYWdlICpwYWdlID0gYnZlYy0+YnZfcGFnZTsKKwkJREVCVUcoMywgIkNsZWFuaW5nIHVwIHBhZ2UgJWxkXG4iLCBwYWdlLT5pbmRleCk7CisJCWlmICgtLWJ2ZWMgPj0gYmlvLT5iaV9pb192ZWMpCisJCQlwcmVmZXRjaHcoJmJ2ZWMtPmJ2X3BhZ2UtPmZsYWdzKTsKKworCQlpZiAodXB0b2RhdGUpIHsKKwkJCVNldFBhZ2VVcHRvZGF0ZShwYWdlKTsKKwkJfSBlbHNlIHsKKwkJCUNsZWFyUGFnZVVwdG9kYXRlKHBhZ2UpOworCQkJU2V0UGFnZUVycm9yKHBhZ2UpOworCQl9CisJCUNsZWFyUGFnZURpcnR5KHBhZ2UpOworCQl1bmxvY2tfcGFnZShwYWdlKTsKKwkJcGFnZV9jYWNoZV9yZWxlYXNlKHBhZ2UpOworCX0gd2hpbGUgKGJ2ZWMgPj0gYmlvLT5iaV9pb192ZWMpOworCQorCWNvbXBsZXRlKChzdHJ1Y3QgY29tcGxldGlvbiopYmlvLT5iaV9wcml2YXRlKTsKKwlyZXR1cm4gMDsKK30KKworCisvKiByZWFkIG9uZSBwYWdlIGZyb20gdGhlIGJsb2NrIGRldmljZSAqLworc3RhdGljIGludCBibGttdGRfcmVhZHBhZ2Uoc3RydWN0IGJsa210ZF9kZXYgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJc3RydWN0IGJpbyAqYmlvOworCXN0cnVjdCBjb21wbGV0aW9uIGV2ZW50OworCWludCBlcnIgPSAtRU5PTUVNOworCisJaWYoUGFnZVVwdG9kYXRlKHBhZ2UpKSB7CisJCURFQlVHKDIsICJibGttdGQ6IHJlYWRwYWdlIHBhZ2UgJWxkIGlzIGFscmVhZHkgdXB0byBkYXRlXG4iLCBwYWdlLT5pbmRleCk7CisJCXVubG9ja19wYWdlKHBhZ2UpOworCQlyZXR1cm4gMDsKKwl9CisJCisJQ2xlYXJQYWdlVXB0b2RhdGUocGFnZSk7CisJQ2xlYXJQYWdlRXJyb3IocGFnZSk7CisKKwliaW8gPSBiaW9fYWxsb2MoR0ZQX0tFUk5FTCwgMSk7CisJaWYoYmlvKSB7CisJCWluaXRfY29tcGxldGlvbigmZXZlbnQpOworCQliaW8tPmJpX2JkZXYgPSBkZXYtPmJsa2RldjsKKwkJYmlvLT5iaV9zZWN0b3IgPSBwYWdlLT5pbmRleCA8PCAoUEFHRV9TSElGVC05KTsKKwkJYmlvLT5iaV9wcml2YXRlID0gJmV2ZW50OworCQliaW8tPmJpX2VuZF9pbyA9IGJpX3JlYWRfY29tcGxldGU7CisJCWlmKGJpb19hZGRfcGFnZShiaW8sIHBhZ2UsIFBBR0VfU0laRSwgMCkgPT0gUEFHRV9TSVpFKSB7CisJCQlzdWJtaXRfYmlvKFJFQURfU1lOQywgYmlvKTsKKwkJCXdhaXRfZm9yX2NvbXBsZXRpb24oJmV2ZW50KTsKKwkJCWVyciA9IHRlc3RfYml0KEJJT19VUFRPREFURSwgJmJpby0+YmlfZmxhZ3MpID8gMCA6IC1FSU87CisJCQliaW9fcHV0KGJpbyk7CisJCX0KKwl9CisKKwlpZihlcnIpCisJCVNldFBhZ2VFcnJvcihwYWdlKTsKKwllbHNlCisJCVNldFBhZ2VVcHRvZGF0ZShwYWdlKTsKKwlmbHVzaF9kY2FjaGVfcGFnZShwYWdlKTsKKwl1bmxvY2tfcGFnZShwYWdlKTsKKwlyZXR1cm4gZXJyOworfQorCisKKy8qIHdyaXRlIG91dCB0aGUgY3VycmVudCBCSU8gYW5kIHdhaXQgZm9yIGl0IHRvIGZpbmlzaCAqLworc3RhdGljIGludCBibGttdGRfd3JpdGVfb3V0KHN0cnVjdCBiaW8gKmJpbykKK3sKKwlzdHJ1Y3QgY29tcGxldGlvbiBldmVudDsKKwlpbnQgZXJyOworCisJaWYoIWJpby0+YmlfdmNudCkgeworCQliaW9fcHV0KGJpbyk7CisJCXJldHVybiAwOworCX0KKworCWluaXRfY29tcGxldGlvbigmZXZlbnQpOworCWJpby0+YmlfcHJpdmF0ZSA9ICZldmVudDsKKwliaW8tPmJpX2VuZF9pbyA9IGJpX3dyaXRlX2NvbXBsZXRlOworCXN1Ym1pdF9iaW8oV1JJVEVfU1lOQywgYmlvKTsKKwl3YWl0X2Zvcl9jb21wbGV0aW9uKCZldmVudCk7CisJREVCVUcoMywgInN1Ym1pdF9iaW8gY29tcGxldGVkLCBiaV92Y250ID0gJWRcbiIsIGJpby0+YmlfdmNudCk7CisJZXJyID0gdGVzdF9iaXQoQklPX1VQVE9EQVRFLCAmYmlvLT5iaV9mbGFncykgPyAwIDogLUVJTzsKKwliaW9fcHV0KGJpbyk7CisJcmV0dXJuIGVycjsKK30KKworCisvKioKKyAqIGJsa210ZF9hZGRfcGFnZSAtIGFkZCBhIHBhZ2UgdG8gdGhlIGN1cnJlbnQgQklPCisgKiBAYmlvOiBiaW8gdG8gYWRkIHRvIChOVUxMIHRvIGFsbG9jIGluaXRpYWwgYmlvKQorICogQGJsa2RldjogYmxvY2sgZGV2aWNlCisgKiBAcGFnZTogcGFnZSB0byBhZGQKKyAqIEBwYWdlY250OiBwYWdlcyBsZWZ0IHRvIGFkZAorICoKKyAqIEFkZHMgYSBwYWdlIHRvIHRoZSBjdXJyZW50IGJpbywgYWxsb2NhdGluZyBpdCBpZiBuZWNlc3NhcnkuIElmIGl0IGNhbm5vdCBiZQorICogYWRkZWQsIHRoZSBjdXJyZW50IGJpbyBpcyB3cml0dGVuIG91dCBhbmQgYSBuZXcgb25lIGlzIGFsbG9jYXRlZC4gUmV0dXJucworICogdGhlIG5ldyBiaW8gdG8gYWRkIG9yIE5VTEwgb24gZXJyb3IKKyAqLworc3RhdGljIHN0cnVjdCBiaW8gKmJsa210ZF9hZGRfcGFnZShzdHJ1Y3QgYmlvICpiaW8sIHN0cnVjdCBibG9ja19kZXZpY2UgKmJsa2RldiwKKwkJCQkgICBzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHBhZ2VjbnQpCit7CisKKyByZXRyeToKKwlpZighYmlvKSB7CisJCWJpbyA9IGJpb19hbGxvYyhHRlBfS0VSTkVMLCBwYWdlY250KTsKKwkJaWYoIWJpbykKKwkJCXJldHVybiBOVUxMOworCQliaW8tPmJpX3NlY3RvciA9IHBhZ2UtPmluZGV4IDw8IChQQUdFX1NISUZULTkpOworCQliaW8tPmJpX2JkZXYgPSBibGtkZXY7CisJfQorCisJaWYoYmlvX2FkZF9wYWdlKGJpbywgcGFnZSwgUEFHRV9TSVpFLCAwKSAhPSBQQUdFX1NJWkUpIHsKKwkJYmxrbXRkX3dyaXRlX291dChiaW8pOworCQliaW8gPSBOVUxMOworCQlnb3RvIHJldHJ5OworCX0KKwlyZXR1cm4gYmlvOworfQorCisKKy8qKgorICogd3JpdGVfcGFnZXMgLSB3cml0ZSBibG9jayBvZiBkYXRhIHRvIGRldmljZSB2aWEgdGhlIHBhZ2UgY2FjaGUKKyAqIEBkZXY6IGRldmljZSB0byB3cml0ZSB0bworICogQGJ1ZjogZGF0YSBzb3VyY2Ugb3IgTlVMTCBpZiBlcmFzZSAob3V0cHV0IGlzIHNldCB0byAweGZmKQorICogQHRvOiBvZmZzZXQgaW50byBvdXRwdXQgZGV2aWNlCisgKiBAbGVuOiBhbW91bnQgdG8gZGF0YSB0byB3cml0ZQorICogQHJldGxlbjogYW1vdW50IG9mIGRhdGEgd3JpdHRlbgorICoKKyAqIEdyYWIgcGFnZXMgZnJvbSB0aGUgcGFnZSBjYWNoZSBhbmQgZmlsbCB0aGVtIHdpdGggdGhlIHNvdXJjZSBkYXRhLgorICogTm9uIHBhZ2UgYWxpZ25lZCBzdGFydCBhbmQgZW5kIHJlc3VsdCBpbiBhIHJlYWRpbiBvZiB0aGUgcGFnZSBhbmQKKyAqIHBhcnQgb2YgdGhlIHBhZ2UgYmVpbmcgbW9kaWZpZWQuIFBhZ2VzIGFyZSBhZGRlZCB0byB0aGUgYmlvIGFuZCB0aGVuIHdyaXR0ZW4KKyAqIG91dC4KKyAqLworc3RhdGljIGludCB3cml0ZV9wYWdlcyhzdHJ1Y3QgYmxrbXRkX2RldiAqZGV2LCBjb25zdCB1X2NoYXIgKmJ1ZiwgbG9mZl90IHRvLAorCQkgICAgc2l6ZV90IGxlbiwgc2l6ZV90ICpyZXRsZW4pCit7CisJaW50IHBhZ2Vuciwgb2Zmc2V0OworCXNpemVfdCBzdGFydF9sZW4gPSAwLCBlbmRfbGVuOworCWludCBwYWdlY250ID0gMDsKKwlpbnQgZXJyID0gMDsKKwlzdHJ1Y3QgYmlvICpiaW8gPSBOVUxMOworCXNpemVfdCB0aGlzbGVuID0gMDsKKworCXBhZ2VuciA9IHRvID4+IFBBR0VfU0hJRlQ7CisJb2Zmc2V0ID0gdG8gJiB+UEFHRV9NQVNLOworCisJREVCVUcoMiwgImJsa210ZDogd3JpdGVfcGFnZXM6IGJ1ZiA9ICVwIHRvID0gJWxkIGxlbiA9ICV6ZCBwYWdlbnIgPSAlZCBvZmZzZXQgPSAlZFxuIiwKKwkgICAgICBidWYsIChsb25nKXRvLCBsZW4sIHBhZ2Vuciwgb2Zmc2V0KTsKKworCS8qIHNlZSBpZiB3ZSBoYXZlIHRvIGRvIGEgcGFydGlhbCB3cml0ZSBhdCB0aGUgc3RhcnQgKi8KKwlpZihvZmZzZXQpIHsKKwkJc3RhcnRfbGVuID0gKChvZmZzZXQgKyBsZW4pID4gUEFHRV9TSVpFKSA/IFBBR0VfU0laRSAtIG9mZnNldCA6IGxlbjsKKwkJbGVuIC09IHN0YXJ0X2xlbjsKKwl9CisKKwkvKiBjYWxjdWxhdGUgdGhlIGxlbmd0aCBvZiB0aGUgb3RoZXIgdHdvIHJlZ2lvbnMgKi8KKwllbmRfbGVuID0gbGVuICYgflBBR0VfTUFTSzsKKwlsZW4gLT0gZW5kX2xlbjsKKworCWlmKHN0YXJ0X2xlbikKKwkJcGFnZWNudCsrOworCisJaWYobGVuKQorCQlwYWdlY250ICs9IGxlbiA+PiBQQUdFX1NISUZUOworCisJaWYoZW5kX2xlbikKKwkJcGFnZWNudCsrOworCisJZG93bigmZGV2LT53cmJ1Zl9tdXRleCk7CisKKwlERUJVRygzLCAiYmxrbXRkOiB3cml0ZTogc3RhcnRfbGVuID0gJXpkIGxlbiA9ICV6ZCBlbmRfbGVuID0gJXpkIHBhZ2VjbnQgPSAlZFxuIiwKKwkgICAgICBzdGFydF9sZW4sIGxlbiwgZW5kX2xlbiwgcGFnZWNudCk7CisKKwlpZihzdGFydF9sZW4pIHsKKwkJLyogZG8gcGFydGlhbCBzdGFydCByZWdpb24gKi8KKwkJc3RydWN0IHBhZ2UgKnBhZ2U7CisKKwkJREVCVUcoMywgImJsa210ZDogd3JpdGU6IGRvaW5nIHBhcnRpYWwgc3RhcnQsIHBhZ2UgPSAlZCBsZW4gPSAlemQgb2Zmc2V0ID0gJWRcbiIsCisJCSAgICAgIHBhZ2Vuciwgc3RhcnRfbGVuLCBvZmZzZXQpOworCisJCUJVR19PTighYnVmKTsKKwkJcGFnZSA9IHJlYWRfY2FjaGVfcGFnZShkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfbWFwcGluZywgcGFnZW5yLCAoZmlsbGVyX3QgKilibGttdGRfcmVhZHBhZ2UsIGRldik7CisJCWxvY2tfcGFnZShwYWdlKTsKKwkJaWYoUGFnZURpcnR5KHBhZ2UpKSB7CisJCQllcnIoInRvID0gJWxsZCBzdGFydF9sZW4gPSAlemQgbGVuID0gJXpkIGVuZF9sZW4gPSAlemQgcGFnZW5yID0gJWRcbiIsCisJCQkgICAgdG8sIHN0YXJ0X2xlbiwgbGVuLCBlbmRfbGVuLCBwYWdlbnIpOworCQkJQlVHKCk7CisJCX0KKwkJbWVtY3B5KHBhZ2VfYWRkcmVzcyhwYWdlKStvZmZzZXQsIGJ1Ziwgc3RhcnRfbGVuKTsKKwkJU2V0UGFnZURpcnR5KHBhZ2UpOworCQlTZXRQYWdlVXB0b2RhdGUocGFnZSk7CisJCWJ1ZiArPSBzdGFydF9sZW47CisJCXRoaXNsZW4gPSBzdGFydF9sZW47CisJCWJpbyA9IGJsa210ZF9hZGRfcGFnZShiaW8sIGRldi0+YmxrZGV2LCBwYWdlLCBwYWdlY250KTsKKwkJaWYoIWJpbykgeworCQkJZXJyID0gLUVOT01FTTsKKwkJCWVycigiYmlvX2FkZF9wYWdlIGZhaWxlZFxuIik7CisJCQlnb3RvIHdyaXRlX2VycjsKKwkJfQorCQlwYWdlY250LS07CisJCXBhZ2VucisrOworCX0KKworCS8qIE5vdyBkbyB0aGUgbWFpbiBsb29wIHRvIGEgcGFnZSBhbGlnbmVkLCBuIHBhZ2Ugc2l6ZWQgb3V0cHV0ICovCisJaWYobGVuKSB7CisJCWludCBwYWdlc2MgPSBsZW4gPj4gUEFHRV9TSElGVDsKKwkJREVCVUcoMywgImJsa210ZDogd3JpdGU6IHdob2xlIHBhZ2VzIHN0YXJ0ID0gJWQsIGNvdW50ID0gJWRcbiIsCisJCSAgICAgIHBhZ2VuciwgcGFnZXNjKTsKKwkJd2hpbGUocGFnZXNjKSB7CisJCQlzdHJ1Y3QgcGFnZSAqcGFnZTsKKworCQkJLyogc2VlIGlmIHBhZ2UgaXMgaW4gdGhlIHBhZ2UgY2FjaGUgKi8KKwkJCURFQlVHKDMsICJibGttdGQ6IHdyaXRlOiBncmFiYmluZyBwYWdlICVkIGZyb20gcGFnZSBjYWNoZVxuIiwgcGFnZW5yKTsKKwkJCXBhZ2UgPSBncmFiX2NhY2hlX3BhZ2UoZGV2LT5ibGtkZXYtPmJkX2lub2RlLT5pX21hcHBpbmcsIHBhZ2Vucik7CisJCQlpZihQYWdlRGlydHkocGFnZSkpIHsKKwkJCQlCVUcoKTsKKwkJCX0KKwkJCWlmKCFwYWdlKSB7CisJCQkJd2Fybigid3JpdGU6IGNhbm5vdCBncmFiIGNhY2hlIHBhZ2UgJWQiLCBwYWdlbnIpOworCQkJCWVyciA9IC1FTk9NRU07CisJCQkJZ290byB3cml0ZV9lcnI7CisJCQl9CisJCQlpZighYnVmKSB7CisJCQkJbWVtc2V0KHBhZ2VfYWRkcmVzcyhwYWdlKSwgMHhmZiwgUEFHRV9TSVpFKTsKKwkJCX0gZWxzZSB7CisJCQkJbWVtY3B5KHBhZ2VfYWRkcmVzcyhwYWdlKSwgYnVmLCBQQUdFX1NJWkUpOworCQkJCWJ1ZiArPSBQQUdFX1NJWkU7CisJCQl9CisJCQliaW8gPSBibGttdGRfYWRkX3BhZ2UoYmlvLCBkZXYtPmJsa2RldiwgcGFnZSwgcGFnZWNudCk7CisJCQlpZighYmlvKSB7CisJCQkJZXJyID0gLUVOT01FTTsKKwkJCQllcnIoImJpb19hZGRfcGFnZSBmYWlsZWRcbiIpOworCQkJCWdvdG8gd3JpdGVfZXJyOworCQkJfQorCQkJcGFnZW5yKys7CisJCQlwYWdlY250LS07CisJCQlTZXRQYWdlRGlydHkocGFnZSk7CisJCQlTZXRQYWdlVXB0b2RhdGUocGFnZSk7CisJCQlwYWdlc2MtLTsKKwkJCXRoaXNsZW4gKz0gUEFHRV9TSVpFOworCQl9CisJfQorCisJaWYoZW5kX2xlbikgeworCQkvKiBkbyB0aGUgdGhpcmQgcmVnaW9uICovCisJCXN0cnVjdCBwYWdlICpwYWdlOworCQlERUJVRygzLCAiYmxrbXRkOiB3cml0ZTogZG9pbmcgcGFydGlhbCBlbmQsIHBhZ2UgPSAlZCBsZW4gPSAlemRcbiIsCisJCSAgICAgIHBhZ2VuciwgZW5kX2xlbik7CisJCUJVR19PTighYnVmKTsKKwkJcGFnZSA9IHJlYWRfY2FjaGVfcGFnZShkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfbWFwcGluZywgcGFnZW5yLCAoZmlsbGVyX3QgKilibGttdGRfcmVhZHBhZ2UsIGRldik7CisJCWxvY2tfcGFnZShwYWdlKTsKKwkJaWYoUGFnZURpcnR5KHBhZ2UpKSB7CisJCQllcnIoInRvID0gJWxsZCBzdGFydF9sZW4gPSAlemQgbGVuID0gJXpkIGVuZF9sZW4gPSAlemQgcGFnZW5yID0gJWRcbiIsCisJCQkgICAgdG8sIHN0YXJ0X2xlbiwgbGVuLCBlbmRfbGVuLCBwYWdlbnIpOworCQkJQlVHKCk7CisJCX0KKwkJbWVtY3B5KHBhZ2VfYWRkcmVzcyhwYWdlKSwgYnVmLCBlbmRfbGVuKTsKKwkJU2V0UGFnZURpcnR5KHBhZ2UpOworCQlTZXRQYWdlVXB0b2RhdGUocGFnZSk7CisJCURFQlVHKDMsICJibGttdGQ6IHdyaXRlOiB3cml0aW5nIG91dCBwYXJ0aWFsIGVuZFxuIik7CisJCXRoaXNsZW4gKz0gZW5kX2xlbjsKKwkJYmlvID0gYmxrbXRkX2FkZF9wYWdlKGJpbywgZGV2LT5ibGtkZXYsIHBhZ2UsIHBhZ2VjbnQpOworCQlpZighYmlvKSB7CisJCQllcnIgPSAtRU5PTUVNOworCQkJZXJyKCJiaW9fYWRkX3BhZ2UgZmFpbGVkXG4iKTsKKwkJCWdvdG8gd3JpdGVfZXJyOworCQl9CisJCXBhZ2VucisrOworCX0KKworCURFQlVHKDMsICJibGttdGQ6IHdyaXRlOiBnb3QgJWQgdmVjdG9ycyB0byB3cml0ZVxuIiwgYmlvLT5iaV92Y250KTsKKyB3cml0ZV9lcnI6CisJaWYoYmlvKQorCQlibGttdGRfd3JpdGVfb3V0KGJpbyk7CisKKwlERUJVRygyLCAiYmxrbXRkOiB3cml0ZTogZW5kLCByZXRsZW4gPSAlemQsIGVyciA9ICVkXG4iLCAqcmV0bGVuLCBlcnIpOworCXVwKCZkZXYtPndyYnVmX211dGV4KTsKKworCWlmKHJldGxlbikKKwkJKnJldGxlbiA9IHRoaXNsZW47CisJcmV0dXJuIGVycjsKK30KKworCisvKiBlcmFzZSBhIHNwZWNpZmllZCBwYXJ0IG9mIHRoZSBkZXZpY2UgKi8KK3N0YXRpYyBpbnQgYmxrbXRkX2VyYXNlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpCit7CisJc3RydWN0IGJsa210ZF9kZXYgKmRldiA9IG10ZC0+cHJpdjsKKwlzdHJ1Y3QgbXRkX2VyYXNlX3JlZ2lvbl9pbmZvICplaW5mbyA9IG10ZC0+ZXJhc2VyZWdpb25zOworCWludCBudW1yZWdpb25zID0gbXRkLT5udW1lcmFzZXJlZ2lvbnM7CisJc2l6ZV90IGZyb207CisJdV9sb25nIGxlbjsKKwlpbnQgZXJyID0gLUVJTzsKKwlzaXplX3QgcmV0bGVuOworCisJaW5zdHItPnN0YXRlID0gTVREX0VSQVNJTkc7CisJZnJvbSA9IGluc3RyLT5hZGRyOworCWxlbiA9IGluc3RyLT5sZW47CisKKwkvKiBjaGVjayBlcmFzZSByZWdpb24gaGFzIHZhbGlkIHN0YXJ0IGFuZCBsZW5ndGggKi8KKwlERUJVRygyLCAiYmxrbXRkOiBlcmFzZTogZGV2ID0gYCVzJyBmcm9tID0gMHglenggbGVuID0gMHglbHhcbiIsCisJICAgICAgbXRkLT5uYW1lKzksIGZyb20sIGxlbik7CisJd2hpbGUobnVtcmVnaW9ucykgeworCQlERUJVRygzLCAiYmxrbXRkOiBjaGVja2luZyBlcmFzZSByZWdpb24gPSAweCUwOFggc2l6ZSA9IDB4JVggbnVtID0gMHgleFxuIiwKKwkJICAgICAgZWluZm8tPm9mZnNldCwgZWluZm8tPmVyYXNlc2l6ZSwgZWluZm8tPm51bWJsb2Nrcyk7CisJCWlmKGZyb20gPj0gZWluZm8tPm9mZnNldAorCQkgICAmJiBmcm9tIDwgZWluZm8tPm9mZnNldCArIChlaW5mby0+ZXJhc2VzaXplICogZWluZm8tPm51bWJsb2NrcykpIHsKKwkJCWlmKGxlbiA9PSBlaW5mby0+ZXJhc2VzaXplCisJCQkgICAmJiAoIChmcm9tIC0gZWluZm8tPm9mZnNldCkgJSBlaW5mby0+ZXJhc2VzaXplID09IDApKQorCQkJCWJyZWFrOworCQl9CisJCW51bXJlZ2lvbnMtLTsKKwkJZWluZm8rKzsKKwl9CisKKwlpZighbnVtcmVnaW9ucykgeworCQkvKiBOb3QgYSB2YWxpZCBlcmFzZSBibG9jayAqLworCQllcnIoImVyYXNlOiBpbnZhbGlkIGVyYXNlIHJlcXVlc3QgMHglbFggQCAweCUwOHpYIiwgbGVuLCBmcm9tKTsKKwkJaW5zdHItPnN0YXRlID0gTVREX0VSQVNFX0ZBSUxFRDsKKwkJZXJyID0gLUVJTzsKKwl9CisKKwlpZihpbnN0ci0+c3RhdGUgIT0gTVREX0VSQVNFX0ZBSUxFRCkgeworCQkvKiBkbyB0aGUgZXJhc2UgKi8KKwkJREVCVUcoMywgIkRvaW5nIGVyYXNlIGZyb20gPSAlemQgbGVuID0gJWxkXG4iLCBmcm9tLCBsZW4pOworCQllcnIgPSB3cml0ZV9wYWdlcyhkZXYsIE5VTEwsIGZyb20sIGxlbiwgJnJldGxlbik7CisJCWlmKGVyciB8fCByZXRsZW4gIT0gbGVuKSB7CisJCQllcnIoImVyYXNlIGZhaWxlZCBlcnIgPSAlZCIsIGVycik7CisJCQlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRkFJTEVEOworCQl9IGVsc2UgeworCQkJaW5zdHItPnN0YXRlID0gTVREX0VSQVNFX0RPTkU7CisJCX0KKwl9CisKKwlERUJVRygzLCAiYmxrbXRkOiBlcmFzZTogY2hlY2tpbmcgY2FsbGJhY2tcbiIpOworCW10ZF9lcmFzZV9jYWxsYmFjayhpbnN0cik7CisJREVCVUcoMiwgImJsa210ZDogZXJhc2U6IGZpbmlzaGVkIChlcnIgPSAlZClcbiIsIGVycik7CisJcmV0dXJuIGVycjsKK30KKworCisvKiByZWFkIGEgcmFuZ2Ugb2YgdGhlIGRhdGEgdmlhIHRoZSBwYWdlIGNhY2hlICovCitzdGF0aWMgaW50IGJsa210ZF9yZWFkKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwKKwkJICAgICAgIHNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgYmxrbXRkX2RldiAqZGV2ID0gbXRkLT5wcml2OworCWludCBlcnIgPSAwOworCWludCBvZmZzZXQ7CisJaW50IHBhZ2VuciwgcGFnZXM7CisJc2l6ZV90IHRoaXNsZW4gPSAwOworCisJREVCVUcoMiwgImJsa210ZDogcmVhZDogZGV2ID0gYCVzJyBmcm9tID0gJWxsZCBsZW4gPSAlemQgYnVmID0gJXBcbiIsCisJICAgICAgbXRkLT5uYW1lKzksIGZyb20sIGxlbiwgYnVmKTsKKworCWlmKGZyb20gPiBtdGQtPnNpemUpCisJCXJldHVybiAtRUlOVkFMOworCWlmKGZyb20gKyBsZW4gPiBtdGQtPnNpemUpCisJCWxlbiA9IG10ZC0+c2l6ZSAtIGZyb207CisKKwlwYWdlbnIgPSBmcm9tID4+IFBBR0VfU0hJRlQ7CisJb2Zmc2V0ID0gZnJvbSAtIChwYWdlbnIgPDwgUEFHRV9TSElGVCk7CisKKwlwYWdlcyA9IChvZmZzZXQrbGVuK1BBR0VfU0laRS0xKSA+PiBQQUdFX1NISUZUOworCURFQlVHKDMsICJibGttdGQ6IHJlYWQ6IHBhZ2VuciA9ICVkIG9mZnNldCA9ICVkLCBwYWdlcyA9ICVkXG4iLAorCSAgICAgIHBhZ2Vuciwgb2Zmc2V0LCBwYWdlcyk7CisKKwl3aGlsZShwYWdlcykgeworCQlzdHJ1Y3QgcGFnZSAqcGFnZTsKKwkJaW50IGNweWxlbjsKKworCQlERUJVRygzLCAiYmxrbXRkOiByZWFkOiBsb29raW5nIGZvciBwYWdlOiAlZFxuIiwgcGFnZW5yKTsKKwkJcGFnZSA9IHJlYWRfY2FjaGVfcGFnZShkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfbWFwcGluZywgcGFnZW5yLCAoZmlsbGVyX3QgKilibGttdGRfcmVhZHBhZ2UsIGRldik7CisJCWlmKElTX0VSUihwYWdlKSkgeworCQkJZXJyID0gLUVJTzsKKwkJCWdvdG8gcmVhZGVycjsKKwkJfQorCisJCWNweWxlbiA9IChQQUdFX1NJWkUgPiBsZW4pID8gbGVuIDogUEFHRV9TSVpFOworCQlpZihvZmZzZXQrY3B5bGVuID4gUEFHRV9TSVpFKQorCQkJY3B5bGVuID0gUEFHRV9TSVpFLW9mZnNldDsKKworCQltZW1jcHkoYnVmICsgdGhpc2xlbiwgcGFnZV9hZGRyZXNzKHBhZ2UpICsgb2Zmc2V0LCBjcHlsZW4pOworCQlvZmZzZXQgPSAwOworCQlsZW4gLT0gY3B5bGVuOworCQl0aGlzbGVuICs9IGNweWxlbjsKKwkJcGFnZW5yKys7CisJCXBhZ2VzLS07CisJCWlmKCFQYWdlRGlydHkocGFnZSkpCisJCQlwYWdlX2NhY2hlX3JlbGVhc2UocGFnZSk7CisJfQorCisgcmVhZGVycjoKKwlpZihyZXRsZW4pCisJCSpyZXRsZW4gPSB0aGlzbGVuOworCURFQlVHKDIsICJibGttdGQ6IGVuZCByZWFkOiByZXRsZW4gPSAlemQsIGVyciA9ICVkXG4iLCB0aGlzbGVuLCBlcnIpOworCXJldHVybiBlcnI7Cit9CisKKworLyogd3JpdGUgZGF0YSB0byB0aGUgdW5kZXJseWluZyBkZXZpY2UgKi8KK3N0YXRpYyBpbnQgYmxrbXRkX3dyaXRlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgdG8sIHNpemVfdCBsZW4sCisJCQlzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpCit7CisJc3RydWN0IGJsa210ZF9kZXYgKmRldiA9IG10ZC0+cHJpdjsKKwlpbnQgZXJyOworCisJaWYoIWxlbikKKwkJcmV0dXJuIDA7CisKKwlERUJVRygyLCAiYmxrbXRkOiB3cml0ZTogZGV2ID0gYCVzJyB0byA9ICVsbGQgbGVuID0gJXpkIGJ1ZiA9ICVwXG4iLAorCSAgICAgIG10ZC0+bmFtZSs5LCB0bywgbGVuLCBidWYpOworCisJaWYodG8gPj0gbXRkLT5zaXplKSB7CisJCXJldHVybiAtRU5PU1BDOworCX0KKworCWlmKHRvICsgbGVuID4gbXRkLT5zaXplKSB7CisJCWxlbiA9IG10ZC0+c2l6ZSAtIHRvOworCX0KKworCWVyciA9IHdyaXRlX3BhZ2VzKGRldiwgYnVmLCB0bywgbGVuLCByZXRsZW4pOworCWlmKGVyciA+IDApCisJCWVyciA9IDA7CisJREVCVUcoMiwgImJsa210ZDogd3JpdGU6IGVuZCwgZXJyID0gJWRcbiIsIGVycik7CisJcmV0dXJuIGVycjsKK30KKworCisvKiBzeW5jIHRoZSBkZXZpY2UgLSB3YWl0IHVudGlsIHRoZSB3cml0ZSBxdWV1ZSBpcyBlbXB0eSAqLworc3RhdGljIHZvaWQgYmxrbXRkX3N5bmMoc3RydWN0IG10ZF9pbmZvICptdGQpCit7CisJLyogQ3VycmVudGx5IGFsbCB3cml0ZXMgYXJlIHN5bmNocm9ub3VzICovCit9CisKKworc3RhdGljIHZvaWQgZnJlZV9kZXZpY2Uoc3RydWN0IGJsa210ZF9kZXYgKmRldikKK3sKKwlERUJVRygyLCAiYmxrbXRkOiBmcmVlX2RldmljZSgpIGRldiA9ICVwXG4iLCBkZXYpOworCWlmKGRldikgeworCQlpZihkZXYtPm10ZF9pbmZvLmVyYXNlcmVnaW9ucykKKwkJCWtmcmVlKGRldi0+bXRkX2luZm8uZXJhc2VyZWdpb25zKTsKKwkJaWYoZGV2LT5tdGRfaW5mby5uYW1lKQorCQkJa2ZyZWUoZGV2LT5tdGRfaW5mby5uYW1lKTsKKworCQlpZihkZXYtPmJsa2RldikgeworCQkJaW52YWxpZGF0ZV9pbm9kZV9wYWdlcyhkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfbWFwcGluZyk7CisJCQljbG9zZV9iZGV2X2V4Y2woZGV2LT5ibGtkZXYpOworCQl9CisJCWtmcmVlKGRldik7CisJfQorfQorCisKKy8qIEZvciBhIGdpdmVuIHNpemUgYW5kIGluaXRpYWwgZXJhc2Ugc2l6ZSwgY2FsY3VsYXRlIHRoZSBudW1iZXIKKyAqIGFuZCBzaXplIG9mIGVhY2ggZXJhc2UgcmVnaW9uLiBHb2VzIHJvdW5kIHRoZSBsb29wIHR3aWNlLAorICogb25jZSB0byBmaW5kIG91dCBob3cgbWFueSByZWdpb25zLCB0aGVuIGFsbG9jYXRlcyBzcGFjZSwKKyAqIHRoZW4gcm91bmQgdGhlIGxvb3AgYWdhaW4gdG8gZmlsbCBpdCBpbi4KKyAqLworc3RhdGljIHN0cnVjdCBtdGRfZXJhc2VfcmVnaW9uX2luZm8gKmNhbGNfZXJhc2VfcmVnaW9ucygKKwlzaXplX3QgZXJhc2Vfc2l6ZSwgc2l6ZV90IHRvdGFsX3NpemUsIGludCAqcmVnaW9ucykKK3sKKwlzdHJ1Y3QgbXRkX2VyYXNlX3JlZ2lvbl9pbmZvICppbmZvID0gTlVMTDsKKworCURFQlVHKDIsICJjYWxjX2VyYXNlX3JlZ2lvbnMsIGVzID0gJXpkIHNpemUgPSAlemQgcmVnaW9ucyA9ICVkXG4iLAorCSAgICAgIGVyYXNlX3NpemUsIHRvdGFsX3NpemUsICpyZWdpb25zKTsKKwkvKiBNYWtlIGFueSB1c2VyIHNwZWNpZmllZCBlcmFzZXNpemUgYmUgYSBwb3dlciBvZiAyCisJICAgYW5kIGF0IGxlYXN0IFBBR0VfU0laRSAqLworCWlmKGVyYXNlX3NpemUpIHsKKwkJaW50IGVzID0gZXJhc2Vfc2l6ZTsKKwkJZXJhc2Vfc2l6ZSA9IDE7CisJCXdoaWxlKGVzICE9IDEpIHsKKwkJCWVzID4+PSAxOworCQkJZXJhc2Vfc2l6ZSA8PD0gMTsKKwkJfQorCQlpZihlcmFzZV9zaXplIDwgUEFHRV9TSVpFKQorCQkJZXJhc2Vfc2l6ZSA9IFBBR0VfU0laRTsKKwl9IGVsc2UgeworCQllcmFzZV9zaXplID0gQ09ORklHX01URF9CTEtERVZfRVJBU0VTSVpFOworCX0KKworCSpyZWdpb25zID0gMDsKKworCWRvIHsKKwkJaW50IHRvdF9zaXplID0gdG90YWxfc2l6ZTsKKwkJaW50IGVyX3NpemUgPSBlcmFzZV9zaXplOworCQlpbnQgY291bnQgPSAwLCBvZmZzZXQgPSAwLCByZWdjbnQgPSAwOworCisJCXdoaWxlKHRvdF9zaXplKSB7CisJCQljb3VudCA9IHRvdF9zaXplIC8gZXJfc2l6ZTsKKwkJCWlmKGNvdW50KSB7CisJCQkJdG90X3NpemUgPSB0b3Rfc2l6ZSAlIGVyX3NpemU7CisJCQkJaWYoaW5mbykgeworCQkJCQlERUJVRygyLCAiYWRkaW5nIHRvIGVyYXNlIGluZm8gb2ZmPSVkIGVyPSVkIGNudD0lZFxuIiwKKwkJCQkJICAgICAgb2Zmc2V0LCBlcl9zaXplLCBjb3VudCk7CisJCQkJCShpbmZvK3JlZ2NudCktPm9mZnNldCA9IG9mZnNldDsKKwkJCQkJKGluZm8rcmVnY250KS0+ZXJhc2VzaXplID0gZXJfc2l6ZTsKKwkJCQkJKGluZm8rcmVnY250KS0+bnVtYmxvY2tzID0gY291bnQ7CisJCQkJCSgqcmVnaW9ucykrKzsKKwkJCQl9CisJCQkJcmVnY250Kys7CisJCQkJb2Zmc2V0ICs9IChjb3VudCAqIGVyX3NpemUpOworCQkJfQorCQkJd2hpbGUoZXJfc2l6ZSA+IHRvdF9zaXplKQorCQkJCWVyX3NpemUgPj49IDE7CisJCX0KKwkJaWYoaW5mbyA9PSBOVUxMKSB7CisJCQlpbmZvID0ga21hbGxvYyhyZWdjbnQgKiBzaXplb2Yoc3RydWN0IG10ZF9lcmFzZV9yZWdpb25faW5mbyksIEdGUF9LRVJORUwpOworCQkJaWYoIWluZm8pCisJCQkJYnJlYWs7CisJCX0KKwl9IHdoaWxlKCEoKnJlZ2lvbnMpKTsKKwlERUJVRygyLCAiY2FsY19lcmFzZV9yZWdpb25zIGRvbmUsIGVzID0gJXpkIHNpemUgPSAlemQgcmVnaW9ucyA9ICVkXG4iLAorCSAgICAgIGVyYXNlX3NpemUsIHRvdGFsX3NpemUsICpyZWdpb25zKTsKKwlyZXR1cm4gaW5mbzsKK30KKworCitleHRlcm4gZGV2X3QgX19pbml0IG5hbWVfdG9fZGV2X3QoY29uc3QgY2hhciAqbGluZSk7CisKK3N0YXRpYyBzdHJ1Y3QgYmxrbXRkX2RldiAqYWRkX2RldmljZShjaGFyICpkZXZuYW1lLCBpbnQgcmVhZG9ubHksIGludCBlcmFzZV9zaXplKQoreworCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXY7CisJaW50IG1vZGU7CisJc3RydWN0IGJsa210ZF9kZXYgKmRldjsKKworCWlmKCFkZXZuYW1lKQorCQlyZXR1cm4gTlVMTDsKKworCS8qIEdldCBhIGhhbmRsZSBvbiB0aGUgZGV2aWNlICovCisKKworI2lmZGVmIE1PRFVMRQorCW1vZGUgPSAocmVhZG9ubHkpID8gT19SRE9OTFkgOiBPX1JEV1I7CisJYmRldiA9IG9wZW5fYmRldl9leGNsKGRldm5hbWUsIG1vZGUsIE5VTEwpOworI2Vsc2UKKwltb2RlID0gKHJlYWRvbmx5KSA/IEZNT0RFX1JFQUQgOiBGTU9ERV9XUklURTsKKwliZGV2ID0gb3Blbl9ieV9kZXZudW0obmFtZV90b19kZXZfdChkZXZuYW1lKSwgbW9kZSk7CisjZW5kaWYKKwlpZihJU19FUlIoYmRldikpIHsKKwkJZXJyKCJlcnJvcjogY2Fubm90IG9wZW4gZGV2aWNlICVzIiwgZGV2bmFtZSk7CisJCURFQlVHKDIsICJibGttdGQ6IG9wZW5pbmcgYmRldiByZXR1cm5lZCAlbGRcbiIsIFBUUl9FUlIoYmRldikpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlERUJVRygxLCAiYmxrbXRkOiBmb3VuZCBhIGJsb2NrIGRldmljZSBtYWpvciA9ICVkLCBtaW5vciA9ICVkXG4iLAorCSAgICAgIE1BSk9SKGJkZXYtPmJkX2RldiksIE1JTk9SKGJkZXYtPmJkX2RldikpOworCisJaWYoTUFKT1IoYmRldi0+YmRfZGV2KSA9PSBNVERfQkxPQ0tfTUFKT1IpIHsKKwkJZXJyKCJhdHRlbXB0aW5nIHRvIHVzZSBhbiBNVEQgZGV2aWNlIGFzIGEgYmxvY2sgZGV2aWNlIik7CisJCWJsa2Rldl9wdXQoYmRldik7CisJCXJldHVybiBOVUxMOworCX0KKworCWRldiA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBibGttdGRfZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYoZGV2ID09IE5VTEwpIHsKKwkJYmxrZGV2X3B1dChiZGV2KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJbWVtc2V0KGRldiwgMCwgc2l6ZW9mKHN0cnVjdCBibGttdGRfZGV2KSk7CisJZGV2LT5ibGtkZXYgPSBiZGV2OworCWlmKCFyZWFkb25seSkgeworCQlpbml0X01VVEVYKCZkZXYtPndyYnVmX211dGV4KTsKKwl9CisKKwlkZXYtPm10ZF9pbmZvLnNpemUgPSBkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfc2l6ZSAmIFBBR0VfTUFTSzsKKworCS8qIFNldHVwIHRoZSBNVEQgc3RydWN0dXJlICovCisJLyogbWFrZSB0aGUgbmFtZSBjb250YWluIHRoZSBibG9jayBkZXZpY2UgaW4gKi8KKwlkZXYtPm10ZF9pbmZvLm5hbWUgPSBrbWFsbG9jKHNpemVvZigiYmxrbXRkOiAiKSArIHN0cmxlbihkZXZuYW1lKSwgR0ZQX0tFUk5FTCk7CisJaWYoZGV2LT5tdGRfaW5mby5uYW1lID09IE5VTEwpCisJCWdvdG8gZGV2aW5pdF9lcnI7CisKKwlzcHJpbnRmKGRldi0+bXRkX2luZm8ubmFtZSwgImJsa210ZDogJXMiLCBkZXZuYW1lKTsKKwlkZXYtPm10ZF9pbmZvLmVyYXNlcmVnaW9ucyA9IGNhbGNfZXJhc2VfcmVnaW9ucyhlcmFzZV9zaXplLCBkZXYtPm10ZF9pbmZvLnNpemUsCisJCQkJCQkJJmRldi0+bXRkX2luZm8ubnVtZXJhc2VyZWdpb25zKTsKKwlpZihkZXYtPm10ZF9pbmZvLmVyYXNlcmVnaW9ucyA9PSBOVUxMKQorCQlnb3RvIGRldmluaXRfZXJyOworCisJZGV2LT5tdGRfaW5mby5lcmFzZXNpemUgPSBkZXYtPm10ZF9pbmZvLmVyYXNlcmVnaW9ucy0+ZXJhc2VzaXplOworCURFQlVHKDEsICJibGttdGQ6IGluaXQ6IGZvdW5kICVkIGVyYXNlIHJlZ2lvbnNcbiIsCisJICAgICAgZGV2LT5tdGRfaW5mby5udW1lcmFzZXJlZ2lvbnMpOworCisJaWYocmVhZG9ubHkpIHsKKwkJZGV2LT5tdGRfaW5mby50eXBlID0gTVREX1JPTTsKKwkJZGV2LT5tdGRfaW5mby5mbGFncyA9IE1URF9DQVBfUk9NOworCX0gZWxzZSB7CisJCWRldi0+bXRkX2luZm8udHlwZSA9IE1URF9SQU07CisJCWRldi0+bXRkX2luZm8uZmxhZ3MgPSBNVERfQ0FQX1JBTTsKKwkJZGV2LT5tdGRfaW5mby5lcmFzZSA9IGJsa210ZF9lcmFzZTsKKwkJZGV2LT5tdGRfaW5mby53cml0ZSA9IGJsa210ZF93cml0ZTsKKwkJZGV2LT5tdGRfaW5mby53cml0ZXYgPSBkZWZhdWx0X210ZF93cml0ZXY7CisJCWRldi0+bXRkX2luZm8uc3luYyA9IGJsa210ZF9zeW5jOworCX0KKwlkZXYtPm10ZF9pbmZvLnJlYWQgPSBibGttdGRfcmVhZDsKKwlkZXYtPm10ZF9pbmZvLnJlYWR2ID0gZGVmYXVsdF9tdGRfcmVhZHY7CisJZGV2LT5tdGRfaW5mby5wcml2ID0gZGV2OworCWRldi0+bXRkX2luZm8ub3duZXIgPSBUSElTX01PRFVMRTsKKworCWxpc3RfYWRkKCZkZXYtPmxpc3QsICZibGttdGRfZGV2aWNlX2xpc3QpOworCWlmIChhZGRfbXRkX2RldmljZSgmZGV2LT5tdGRfaW5mbykpIHsKKwkJLyogRGV2aWNlIGRpZG50IGdldCBhZGRlZCwgc28gZnJlZSB0aGUgZW50cnkgKi8KKwkJbGlzdF9kZWwoJmRldi0+bGlzdCk7CisJCWdvdG8gZGV2aW5pdF9lcnI7CisJfSBlbHNlIHsKKwkJaW5mbygibXRkJWQ6IFslc10gZXJhc2Vfc2l6ZSA9ICVkS2lCICVzIiwKKwkJICAgICBkZXYtPm10ZF9pbmZvLmluZGV4LCBkZXYtPm10ZF9pbmZvLm5hbWUgKyBzdHJsZW4oImJsa210ZDogIiksCisJCSAgICAgZGV2LT5tdGRfaW5mby5lcmFzZXNpemUgPj4gMTAsCisJCSAgICAgcmVhZG9ubHkgPyAiKHJlYWQtb25seSkiIDogIiIpOworCX0KKwkKKwlyZXR1cm4gZGV2OworCisgZGV2aW5pdF9lcnI6CisJZnJlZV9kZXZpY2UoZGV2KTsKKwlyZXR1cm4gTlVMTDsKK30KKworCisvKiBDbGVhbnVwIGFuZCBleGl0IC0gc3luYyB0aGUgZGV2aWNlIGFuZCBraWxsIG9mIHRoZSBrZXJuZWwgdGhyZWFkICovCitzdGF0aWMgdm9pZCBfX2RldmV4aXQgY2xlYW51cF9ibGttdGQodm9pZCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICp0ZW1wMSwgKnRlbXAyOworCisJLyogUmVtb3ZlIHRoZSBNVEQgZGV2aWNlcyAqLworCWxpc3RfZm9yX2VhY2hfc2FmZSh0ZW1wMSwgdGVtcDIsICZibGttdGRfZGV2aWNlX2xpc3QpIHsKKwkJc3RydWN0IGJsa210ZF9kZXYgKmRldiA9IGxpc3RfZW50cnkodGVtcDEsIHN0cnVjdCBibGttdGRfZGV2LAorCQkJCQkJICAgIGxpc3QpOworCQlibGttdGRfc3luYygmZGV2LT5tdGRfaW5mbyk7CisJCWRlbF9tdGRfZGV2aWNlKCZkZXYtPm10ZF9pbmZvKTsKKwkJaW5mbygibXRkJWQ6IFslc10gcmVtb3ZlZCIsIGRldi0+bXRkX2luZm8uaW5kZXgsCisJCSAgICAgZGV2LT5tdGRfaW5mby5uYW1lICsgc3RybGVuKCJibGttdGQ6ICIpKTsKKwkJbGlzdF9kZWwoJmRldi0+bGlzdCk7CisJCWZyZWVfZGV2aWNlKGRldik7CisJfQorfQorCisjaWZuZGVmIE1PRFVMRQorCisvKiBIYW5kbGUga2VybmVsIGJvb3QgcGFyYW1zICovCisKKworc3RhdGljIGludCBfX2luaXQgcGFyYW1fYmxrbXRkX2RldmljZShjaGFyICpzdHIpCit7CisJaW50IGk7CisKKwlmb3IoaSA9IDA7IGkgPCBNQVhfREVWSUNFUzsgaSsrKSB7CisJCWRldmljZVtpXSA9IHN0cjsKKwkJREVCVUcoMiwgImJsa210ZDogZGV2aWNlIHNldHVwOiAlZCA9ICVzXG4iLCBpLCBkZXZpY2VbaV0pOworCQlzdHJzZXAoJnN0ciwgIiwiKTsKKwl9CisJcmV0dXJuIDE7Cit9CisKKworc3RhdGljIGludCBfX2luaXQgcGFyYW1fYmxrbXRkX2VyYXNlc3ooY2hhciAqc3RyKQoreworCWludCBpOworCWZvcihpID0gMDsgaSA8IE1BWF9ERVZJQ0VTOyBpKyspIHsKKwkJY2hhciAqdmFsID0gc3Ryc2VwKCZzdHIsICIsIik7CisJCWlmKHZhbCkKKwkJCWVyYXNlc3pbaV0gPSBzaW1wbGVfc3RydG91bCh2YWwsIE5VTEwsIDApOworCQlERUJVRygyLCAiYmxrbXRkOiBlcmFzZXN6IHNldHVwOiAlZCA9ICVkXG4iLCBpLCBlcmFzZXN6W2ldKTsKKwl9CisKKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgaW50IF9faW5pdCBwYXJhbV9ibGttdGRfcm8oY2hhciAqc3RyKQoreworCWludCBpOworCWZvcihpID0gMDsgaSA8IE1BWF9ERVZJQ0VTOyBpKyspIHsKKwkJY2hhciAqdmFsID0gc3Ryc2VwKCZzdHIsICIsIik7CisJCWlmKHZhbCkKKwkJCXJvW2ldID0gc2ltcGxlX3N0cnRvdWwodmFsLCBOVUxMLCAwKTsKKwkJREVCVUcoMiwgImJsa210ZDogcm8gc2V0dXA6ICVkID0gJWRcbiIsIGksIHJvW2ldKTsKKwl9CisKKwlyZXR1cm4gMTsKK30KKworCitzdGF0aWMgaW50IF9faW5pdCBwYXJhbV9ibGttdGRfc3luYyhjaGFyICpzdHIpCit7CisJaWYoc3RyWzBdID09ICcxJykKKwkJc3luYyA9IDE7CisJcmV0dXJuIDE7Cit9CisKK19fc2V0dXAoImJsa210ZF9kZXZpY2U9IiwgcGFyYW1fYmxrbXRkX2RldmljZSk7CitfX3NldHVwKCJibGttdGRfZXJhc2Vzej0iLCBwYXJhbV9ibGttdGRfZXJhc2Vzeik7CitfX3NldHVwKCJibGttdGRfcm89IiwgcGFyYW1fYmxrbXRkX3JvKTsKK19fc2V0dXAoImJsa210ZF9zeW5jPSIsIHBhcmFtX2Jsa210ZF9zeW5jKTsKKworI2VuZGlmCisKKworLyogU3RhcnR1cCAqLworc3RhdGljIGludCBfX2luaXQgaW5pdF9ibGttdGQodm9pZCkKK3sKKwlpbnQgaTsKKworCWluZm8oInZlcnNpb24gIiBWRVJTSU9OKTsKKwkvKiBDaGVjayBhcmdzIC0gZGV2aWNlWzBdIGlzIHRoZSBiYXJlIG1pbmltdW0qLworCWlmKCFkZXZpY2VbMF0pIHsKKwkJZXJyKCJlcnJvcjogbWlzc2luZyBgZGV2aWNlJyBuYW1lXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJZm9yKGkgPSAwOyBpIDwgTUFYX0RFVklDRVM7IGkrKykKKwkJYWRkX2RldmljZShkZXZpY2VbaV0sIHJvW2ldLCBlcmFzZXN6W2ldIDw8IDEwKTsKKworCWlmKGxpc3RfZW1wdHkoJmJsa210ZF9kZXZpY2VfbGlzdCkpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIDA7Cit9CisKK21vZHVsZV9pbml0KGluaXRfYmxrbXRkKTsKK21vZHVsZV9leGl0KGNsZWFudXBfYmxrbXRkKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvYmxvY2sybXRkLmMgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2Jsb2NrMm10ZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNmZTZjY2YKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2Jsb2NrMm10ZC5jCkBAIC0wLDAgKzEsNDk1IEBACisvKgorICogJElkOiBibG9jazJtdGQuYyx2IDEuMjMgMjAwNS8wMS8wNSAxNzowNTo0NiBkd213MiBFeHAgJAorICoKKyAqIGJsb2NrMm10ZC5jIC0gY3JlYXRlIGFuIG10ZCBmcm9tIGEgYmxvY2sgZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDAxLDIwMDIJU2ltb24gRXZhbnMgPHNwc2VAc2VjcmV0Lm9yZy51az4KKyAqIENvcHlyaWdodCAoQykgMjAwNAkJR2FyZXRoIEJ1bHQgPEdhcmV0aEBFbmNyeXB0ZWMubmV0PgorICogQ29weXJpZ2h0IChDKSAyMDA0LDIwMDUJSvZybiBFbmdlbCA8am9lcm5Ad2guZmgtd2VkZWwuZGU+CisgKgorICogTGljZW5jZTogR1BMCisgKi8KKyNpbmNsdWRlIDxsaW51eC9jb25maWcuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9mcy5oPgorI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgorI2luY2x1ZGUgPGxpbnV4L2Jpby5oPgorI2luY2x1ZGUgPGxpbnV4L3BhZ2VtYXAuaD4KKyNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKyNpbmNsdWRlIDxsaW51eC9idWZmZXJfaGVhZC5oPgorCisjZGVmaW5lIFZFUlNJT04gIiRSZXZpc2lvbjogMS4yMyAkIgorCisKKyNkZWZpbmUgRVJST1IoZm10LCBhcmdzLi4uKSBwcmludGsoS0VSTl9FUlIgImJsb2NrMm10ZDogIiBmbXQgIlxuIiAsICMjIGFyZ3MpCisjZGVmaW5lIElORk8oZm10LCBhcmdzLi4uKSBwcmludGsoS0VSTl9JTkZPICJibG9jazJtdGQ6ICIgZm10ICJcbiIgLCAjIyBhcmdzKQorCisKKy8qIEluZm8gZm9yIHRoZSBibG9jayBkZXZpY2UgKi8KK3N0cnVjdCBibG9jazJtdGRfZGV2IHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CisJc3RydWN0IGJsb2NrX2RldmljZSAqYmxrZGV2OworCXN0cnVjdCBtdGRfaW5mbyBtdGQ7CisJc3RydWN0IHNlbWFwaG9yZSB3cml0ZV9tdXRleDsKK307CisKKworLyogU3RhdGljIGluZm8gYWJvdXQgdGhlIE1URCwgdXNlZCBpbiBjbGVhbnVwX21vZHVsZSAqLworc3RhdGljIExJU1RfSEVBRChibGttdGRfZGV2aWNlX2xpc3QpOworCisKKyNkZWZpbmUgUEFHRV9SRUFEQUhFQUQgNjQKK3ZvaWQgY2FjaGVfcmVhZGFoZWFkKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLCBpbnQgaW5kZXgpCit7CisJZmlsbGVyX3QgKmZpbGxlciA9IChmaWxsZXJfdCopbWFwcGluZy0+YV9vcHMtPnJlYWRwYWdlOworCWludCBpLCBwYWdlaTsKKwl1bnNpZ25lZCByZXQgPSAwOworCXVuc2lnbmVkIGxvbmcgZW5kX2luZGV4OworCXN0cnVjdCBwYWdlICpwYWdlOworCUxJU1RfSEVBRChwYWdlX3Bvb2wpOworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBtYXBwaW5nLT5ob3N0OworCWxvZmZfdCBpc2l6ZSA9IGlfc2l6ZV9yZWFkKGlub2RlKTsKKworCWlmICghaXNpemUpIHsKKwkJSU5GTygiaVNpemU9MCBpbiBjYWNoZV9yZWFkYWhlYWRcbiIpOworCQlyZXR1cm47CisJfQorCisJZW5kX2luZGV4ID0gKChpc2l6ZSAtIDEpID4+IFBBR0VfQ0FDSEVfU0hJRlQpOworCisJcmVhZF9sb2NrX2lycSgmbWFwcGluZy0+dHJlZV9sb2NrKTsKKwlmb3IgKGkgPSAwOyBpIDwgUEFHRV9SRUFEQUhFQUQ7IGkrKykgeworCQlwYWdlaSA9IGluZGV4ICsgaTsKKwkJaWYgKHBhZ2VpID4gZW5kX2luZGV4KSB7CisJCQlJTkZPKCJPdmVycnVuIGVuZCBvZiBkaXNrIGluIGNhY2hlIHJlYWRhaGVhZFxuIik7CisJCQlicmVhazsKKwkJfQorCQlwYWdlID0gcmFkaXhfdHJlZV9sb29rdXAoJm1hcHBpbmctPnBhZ2VfdHJlZSwgcGFnZWkpOworCQlpZiAocGFnZSAmJiAoIWkpKQorCQkJYnJlYWs7CisJCWlmIChwYWdlKQorCQkJY29udGludWU7CisJCXJlYWRfdW5sb2NrX2lycSgmbWFwcGluZy0+dHJlZV9sb2NrKTsKKwkJcGFnZSA9IHBhZ2VfY2FjaGVfYWxsb2NfY29sZChtYXBwaW5nKTsKKwkJcmVhZF9sb2NrX2lycSgmbWFwcGluZy0+dHJlZV9sb2NrKTsKKwkJaWYgKCFwYWdlKQorCQkJYnJlYWs7CisJCXBhZ2UtPmluZGV4ID0gcGFnZWk7CisJCWxpc3RfYWRkKCZwYWdlLT5scnUsICZwYWdlX3Bvb2wpOworCQlyZXQrKzsKKwl9CisJcmVhZF91bmxvY2tfaXJxKCZtYXBwaW5nLT50cmVlX2xvY2spOworCWlmIChyZXQpCisJCXJlYWRfY2FjaGVfcGFnZXMobWFwcGluZywgJnBhZ2VfcG9vbCwgZmlsbGVyLCBOVUxMKTsKK30KKworCitzdGF0aWMgc3RydWN0IHBhZ2UqIHBhZ2VfcmVhZGFoZWFkKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLCBpbnQgaW5kZXgpCit7CisJZmlsbGVyX3QgKmZpbGxlciA9IChmaWxsZXJfdCopbWFwcGluZy0+YV9vcHMtPnJlYWRwYWdlOworCS8vZG9fcGFnZV9jYWNoZV9yZWFkYWhlYWQobWFwcGluZywgaW5kZXgsIFhYWCwgNjQpOworCWNhY2hlX3JlYWRhaGVhZChtYXBwaW5nLCBpbmRleCk7CisJcmV0dXJuIHJlYWRfY2FjaGVfcGFnZShtYXBwaW5nLCBpbmRleCwgZmlsbGVyLCBOVUxMKTsKK30KKworCisvKiBlcmFzZSBhIHNwZWNpZmllZCBwYXJ0IG9mIHRoZSBkZXZpY2UgKi8KK3N0YXRpYyBpbnQgX2Jsb2NrMm10ZF9lcmFzZShzdHJ1Y3QgYmxvY2sybXRkX2RldiAqZGV2LCBsb2ZmX3QgdG8sIHNpemVfdCBsZW4pCit7CisJc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcgPSBkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfbWFwcGluZzsKKwlzdHJ1Y3QgcGFnZSAqcGFnZTsKKwlpbnQgaW5kZXggPSB0byA+PiBQQUdFX1NISUZUOwkvLyBwYWdlIGluZGV4CisJaW50IHBhZ2VzID0gbGVuID4+IFBBR0VfU0hJRlQ7CisJdV9sb25nICpwOworCXVfbG9uZyAqbWF4OworCisJd2hpbGUgKHBhZ2VzKSB7CisJCXBhZ2UgPSBwYWdlX3JlYWRhaGVhZChtYXBwaW5nLCBpbmRleCk7CisJCWlmICghcGFnZSkKKwkJCXJldHVybiAtRU5PTUVNOworCQlpZiAoSVNfRVJSKHBhZ2UpKQorCQkJcmV0dXJuIFBUUl9FUlIocGFnZSk7CisKKwkJbWF4ID0gKHVfbG9uZyopcGFnZV9hZGRyZXNzKHBhZ2UpICsgUEFHRV9TSVpFOworCQlmb3IgKHA9KHVfbG9uZyopcGFnZV9hZGRyZXNzKHBhZ2UpOyBwPG1heDsgcCsrKSAKKwkJCWlmICgqcCAhPSAtMVVMKSB7CisJCQkJbG9ja19wYWdlKHBhZ2UpOworCQkJCW1lbXNldChwYWdlX2FkZHJlc3MocGFnZSksIDB4ZmYsIFBBR0VfU0laRSk7CisJCQkJc2V0X3BhZ2VfZGlydHkocGFnZSk7CisJCQkJdW5sb2NrX3BhZ2UocGFnZSk7CisJCQkJYnJlYWs7CisJCQl9CisKKwkJcGFnZV9jYWNoZV9yZWxlYXNlKHBhZ2UpOworCQlwYWdlcy0tOworCQlpbmRleCsrOworCX0KKwlyZXR1cm4gMDsKK30KK3N0YXRpYyBpbnQgYmxvY2sybXRkX2VyYXNlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpCit7CisJc3RydWN0IGJsb2NrMm10ZF9kZXYgKmRldiA9IG10ZC0+cHJpdjsKKwlzaXplX3QgZnJvbSA9IGluc3RyLT5hZGRyOworCXNpemVfdCBsZW4gPSBpbnN0ci0+bGVuOworCWludCBlcnI7CisKKwlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0lORzsKKwlkb3duKCZkZXYtPndyaXRlX211dGV4KTsKKwllcnIgPSBfYmxvY2sybXRkX2VyYXNlKGRldiwgZnJvbSwgbGVuKTsKKwl1cCgmZGV2LT53cml0ZV9tdXRleCk7CisJaWYgKGVycikgeworCQlFUlJPUigiZXJhc2UgZmFpbGVkIGVyciA9ICVkIiwgZXJyKTsKKwkJaW5zdHItPnN0YXRlID0gTVREX0VSQVNFX0ZBSUxFRDsKKwl9IGVsc2UKKwkJaW5zdHItPnN0YXRlID0gTVREX0VSQVNFX0RPTkU7CisKKwlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRE9ORTsKKwltdGRfZXJhc2VfY2FsbGJhY2soaW5zdHIpOworCXJldHVybiBlcnI7Cit9CisKKworc3RhdGljIGludCBibG9jazJtdGRfcmVhZChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCXNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgYmxvY2sybXRkX2RldiAqZGV2ID0gbXRkLT5wcml2OworCXN0cnVjdCBwYWdlICpwYWdlOworCWludCBpbmRleCA9IGZyb20gPj4gUEFHRV9TSElGVDsKKwlpbnQgb2Zmc2V0ID0gZnJvbSAmIChQQUdFX1NISUZULTEpOworCWludCBjcHlsZW47CisKKwlpZiAoZnJvbSA+IG10ZC0+c2l6ZSkKKwkJcmV0dXJuIC1FSU5WQUw7CisJaWYgKGZyb20gKyBsZW4gPiBtdGQtPnNpemUpCisJCWxlbiA9IG10ZC0+c2l6ZSAtIGZyb207CisKKwlpZiAocmV0bGVuKQorCQkqcmV0bGVuID0gMDsKKworCXdoaWxlIChsZW4pIHsKKwkJaWYgKChvZmZzZXQgKyBsZW4pID4gUEFHRV9TSVpFKQorCQkJY3B5bGVuID0gUEFHRV9TSVpFIC0gb2Zmc2V0OwkvLyBtdWx0aXBsZSBwYWdlcworCQllbHNlCisJCQljcHlsZW4gPSBsZW47CS8vIHRoaXMgcGFnZQorCQlsZW4gPSBsZW4gLSBjcHlsZW47CisKKwkJLy8gICAgICBHZXQgcGFnZQorCQlwYWdlID0gcGFnZV9yZWFkYWhlYWQoZGV2LT5ibGtkZXYtPmJkX2lub2RlLT5pX21hcHBpbmcsIGluZGV4KTsKKwkJaWYgKCFwYWdlKQorCQkJcmV0dXJuIC1FTk9NRU07CisJCWlmIChJU19FUlIocGFnZSkpCisJCQlyZXR1cm4gUFRSX0VSUihwYWdlKTsKKworCQltZW1jcHkoYnVmLCBwYWdlX2FkZHJlc3MocGFnZSkgKyBvZmZzZXQsIGNweWxlbik7CisJCXBhZ2VfY2FjaGVfcmVsZWFzZShwYWdlKTsKKworCQlpZiAocmV0bGVuKQorCQkJKnJldGxlbiArPSBjcHlsZW47CisJCWJ1ZiArPSBjcHlsZW47CisJCW9mZnNldCA9IDA7CisJCWluZGV4Kys7CisJfQorCXJldHVybiAwOworfQorCisKKy8qIHdyaXRlIGRhdGEgdG8gdGhlIHVuZGVybHlpbmcgZGV2aWNlICovCitzdGF0aWMgaW50IF9ibG9jazJtdGRfd3JpdGUoc3RydWN0IGJsb2NrMm10ZF9kZXYgKmRldiwgY29uc3QgdV9jaGFyICpidWYsCisJCWxvZmZfdCB0bywgc2l6ZV90IGxlbiwgc2l6ZV90ICpyZXRsZW4pCit7CisJc3RydWN0IHBhZ2UgKnBhZ2U7CisJc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcgPSBkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfbWFwcGluZzsKKwlpbnQgaW5kZXggPSB0byA+PiBQQUdFX1NISUZUOwkvLyBwYWdlIGluZGV4CisJaW50IG9mZnNldCA9IHRvICYgflBBR0VfTUFTSzsJLy8gcGFnZSBvZmZzZXQKKwlpbnQgY3B5bGVuOworCisJaWYgKHJldGxlbikKKwkJKnJldGxlbiA9IDA7CisJd2hpbGUgKGxlbikgeworCQlpZiAoKG9mZnNldCtsZW4pID4gUEFHRV9TSVpFKSAKKwkJCWNweWxlbiA9IFBBR0VfU0laRSAtIG9mZnNldDsJLy8gbXVsdGlwbGUgcGFnZXMKKwkJZWxzZQorCQkJY3B5bGVuID0gbGVuOwkJCS8vIHRoaXMgcGFnZQorCQlsZW4gPSBsZW4gLSBjcHlsZW47CisKKwkJLy8JR2V0IHBhZ2UKKwkJcGFnZSA9IHBhZ2VfcmVhZGFoZWFkKG1hcHBpbmcsIGluZGV4KTsKKwkJaWYgKCFwYWdlKQorCQkJcmV0dXJuIC1FTk9NRU07CisJCWlmIChJU19FUlIocGFnZSkpCisJCQlyZXR1cm4gUFRSX0VSUihwYWdlKTsKKworCQlpZiAobWVtY21wKHBhZ2VfYWRkcmVzcyhwYWdlKStvZmZzZXQsIGJ1ZiwgY3B5bGVuKSkgeworCQkJbG9ja19wYWdlKHBhZ2UpOworCQkJbWVtY3B5KHBhZ2VfYWRkcmVzcyhwYWdlKSArIG9mZnNldCwgYnVmLCBjcHlsZW4pOworCQkJc2V0X3BhZ2VfZGlydHkocGFnZSk7CisJCQl1bmxvY2tfcGFnZShwYWdlKTsKKwkJfQorCQlwYWdlX2NhY2hlX3JlbGVhc2UocGFnZSk7CisKKwkJaWYgKHJldGxlbikKKwkJCSpyZXRsZW4gKz0gY3B5bGVuOworCisJCWJ1ZiArPSBjcHlsZW47CisJCW9mZnNldCA9IDA7CisJCWluZGV4Kys7CisJfQorCXJldHVybiAwOworfQorc3RhdGljIGludCBibG9jazJtdGRfd3JpdGUoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJc2l6ZV90ICpyZXRsZW4sIGNvbnN0IHVfY2hhciAqYnVmKQoreworCXN0cnVjdCBibG9jazJtdGRfZGV2ICpkZXYgPSBtdGQtPnByaXY7CisJaW50IGVycjsKKworCWlmICghbGVuKQorCQlyZXR1cm4gMDsKKwlpZiAodG8gPj0gbXRkLT5zaXplKQorCQlyZXR1cm4gLUVOT1NQQzsKKwlpZiAodG8gKyBsZW4gPiBtdGQtPnNpemUpCisJCWxlbiA9IG10ZC0+c2l6ZSAtIHRvOworCisJZG93bigmZGV2LT53cml0ZV9tdXRleCk7CisJZXJyID0gX2Jsb2NrMm10ZF93cml0ZShkZXYsIGJ1ZiwgdG8sIGxlbiwgcmV0bGVuKTsKKwl1cCgmZGV2LT53cml0ZV9tdXRleCk7CisJaWYgKGVyciA+IDApCisJCWVyciA9IDA7CisJcmV0dXJuIGVycjsKK30KKworCisvKiBzeW5jIHRoZSBkZXZpY2UgLSB3YWl0IHVudGlsIHRoZSB3cml0ZSBxdWV1ZSBpcyBlbXB0eSAqLworc3RhdGljIHZvaWQgYmxvY2sybXRkX3N5bmMoc3RydWN0IG10ZF9pbmZvICptdGQpCit7CisJc3RydWN0IGJsb2NrMm10ZF9kZXYgKmRldiA9IG10ZC0+cHJpdjsKKwlzeW5jX2Jsb2NrZGV2KGRldi0+YmxrZGV2KTsKKwlyZXR1cm47Cit9CisKKworc3RhdGljIHZvaWQgYmxvY2sybXRkX2ZyZWVfZGV2aWNlKHN0cnVjdCBibG9jazJtdGRfZGV2ICpkZXYpCit7CisJaWYgKCFkZXYpCisJCXJldHVybjsKKworCWtmcmVlKGRldi0+bXRkLm5hbWUpOworCisJaWYgKGRldi0+YmxrZGV2KSB7CisJCWludmFsaWRhdGVfaW5vZGVfcGFnZXMoZGV2LT5ibGtkZXYtPmJkX2lub2RlLT5pX21hcHBpbmcpOworCQljbG9zZV9iZGV2X2V4Y2woZGV2LT5ibGtkZXYpOworCX0KKworCWtmcmVlKGRldik7Cit9CisKKworLyogRklYTUU6IGVuc3VyZSB0aGF0IG10ZC0+c2l6ZSAlIGVyYXNlX3NpemUgPT0gMCAqLworc3RhdGljIHN0cnVjdCBibG9jazJtdGRfZGV2ICphZGRfZGV2aWNlKGNoYXIgKmRldm5hbWUsIGludCBlcmFzZV9zaXplKQoreworCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXY7CisJc3RydWN0IGJsb2NrMm10ZF9kZXYgKmRldjsKKworCWlmICghZGV2bmFtZSkKKwkJcmV0dXJuIE5VTEw7CisKKwlkZXYgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgYmxvY2sybXRkX2RldiksIEdGUF9LRVJORUwpOworCWlmICghZGV2KQorCQlyZXR1cm4gTlVMTDsKKwltZW1zZXQoZGV2LCAwLCBzaXplb2YoKmRldikpOworCisJLyogR2V0IGEgaGFuZGxlIG9uIHRoZSBkZXZpY2UgKi8KKwliZGV2ID0gb3Blbl9iZGV2X2V4Y2woZGV2bmFtZSwgT19SRFdSLCBOVUxMKTsKKwlpZiAoSVNfRVJSKGJkZXYpKSB7CisJCUVSUk9SKCJlcnJvcjogY2Fubm90IG9wZW4gZGV2aWNlICVzIiwgZGV2bmFtZSk7CisJCWdvdG8gZGV2aW5pdF9lcnI7CisJfQorCWRldi0+YmxrZGV2ID0gYmRldjsKKworCWlmIChNQUpPUihiZGV2LT5iZF9kZXYpID09IE1URF9CTE9DS19NQUpPUikgeworCQlFUlJPUigiYXR0ZW1wdGluZyB0byB1c2UgYW4gTVREIGRldmljZSBhcyBhIGJsb2NrIGRldmljZSIpOworCQlnb3RvIGRldmluaXRfZXJyOworCX0KKworCWluaXRfTVVURVgoJmRldi0+d3JpdGVfbXV0ZXgpOworCisJLyogU2V0dXAgdGhlIE1URCBzdHJ1Y3R1cmUgKi8KKwkvKiBtYWtlIHRoZSBuYW1lIGNvbnRhaW4gdGhlIGJsb2NrIGRldmljZSBpbiAqLworCWRldi0+bXRkLm5hbWUgPSBrbWFsbG9jKHNpemVvZigiYmxvY2sybXRkOiAiKSArIHN0cmxlbihkZXZuYW1lKSwKKwkJCUdGUF9LRVJORUwpOworCWlmICghZGV2LT5tdGQubmFtZSkKKwkJZ290byBkZXZpbml0X2VycjsKKworCXNwcmludGYoZGV2LT5tdGQubmFtZSwgImJsb2NrMm10ZDogJXMiLCBkZXZuYW1lKTsKKworCWRldi0+bXRkLnNpemUgPSBkZXYtPmJsa2Rldi0+YmRfaW5vZGUtPmlfc2l6ZSAmIFBBR0VfTUFTSzsKKwlkZXYtPm10ZC5lcmFzZXNpemUgPSBlcmFzZV9zaXplOworCWRldi0+bXRkLnR5cGUgPSBNVERfUkFNOworCWRldi0+bXRkLmZsYWdzID0gTVREX0NBUF9SQU07CisJZGV2LT5tdGQuZXJhc2UgPSBibG9jazJtdGRfZXJhc2U7CisJZGV2LT5tdGQud3JpdGUgPSBibG9jazJtdGRfd3JpdGU7CisJZGV2LT5tdGQud3JpdGV2ID0gZGVmYXVsdF9tdGRfd3JpdGV2OworCWRldi0+bXRkLnN5bmMgPSBibG9jazJtdGRfc3luYzsKKwlkZXYtPm10ZC5yZWFkID0gYmxvY2sybXRkX3JlYWQ7CisJZGV2LT5tdGQucmVhZHYgPSBkZWZhdWx0X210ZF9yZWFkdjsKKwlkZXYtPm10ZC5wcml2ID0gZGV2OworCWRldi0+bXRkLm93bmVyID0gVEhJU19NT0RVTEU7CisKKwlpZiAoYWRkX210ZF9kZXZpY2UoJmRldi0+bXRkKSkgeworCQkvKiBEZXZpY2UgZGlkbnQgZ2V0IGFkZGVkLCBzbyBmcmVlIHRoZSBlbnRyeSAqLworCQlnb3RvIGRldmluaXRfZXJyOworCX0KKwlsaXN0X2FkZCgmZGV2LT5saXN0LCAmYmxrbXRkX2RldmljZV9saXN0KTsKKwlJTkZPKCJtdGQlZDogWyVzXSBlcmFzZV9zaXplID0gJWRLaUIgWyVkXSIsIGRldi0+bXRkLmluZGV4LAorCQkJZGV2LT5tdGQubmFtZSArIHN0cmxlbigiYmxrbXRkOiAiKSwKKwkJCWRldi0+bXRkLmVyYXNlc2l6ZSA+PiAxMCwgZGV2LT5tdGQuZXJhc2VzaXplKTsKKwlyZXR1cm4gZGV2OworCitkZXZpbml0X2VycjoKKwlibG9jazJtdGRfZnJlZV9kZXZpY2UoZGV2KTsKKwlyZXR1cm4gTlVMTDsKK30KKworCitzdGF0aWMgaW50IHVzdHJ0b3VsKGNvbnN0IGNoYXIgKmNwLCBjaGFyICoqZW5kcCwgdW5zaWduZWQgaW50IGJhc2UpCit7CisJdW5zaWduZWQgbG9uZyByZXN1bHQgPSBzaW1wbGVfc3RydG91bChjcCwgZW5kcCwgYmFzZSk7CisJc3dpdGNoICgqKmVuZHApIHsKKwljYXNlICdHJyA6CisJCXJlc3VsdCAqPSAxMDI0OworCWNhc2UgJ00nOgorCQlyZXN1bHQgKj0gMTAyNDsKKwljYXNlICdrJzoKKwkJcmVzdWx0ICo9IDEwMjQ7CisJLyogQnkgZHdtdzIgZWRpdG9yaWFsIGRlY3JlZSwgImtpIiwgIk1pIiBvciAiR2kiIGFyZSB0byBiZSB1c2VkLiAqLworCQlpZiAoKCplbmRwKVsxXSA9PSAnaScpCisJCQkoKmVuZHApICs9IDI7CisJfQorCXJldHVybiByZXN1bHQ7Cit9CisKKworc3RhdGljIGludCBwYXJzZV9udW0zMih1MzIgKm51bTMyLCBjb25zdCBjaGFyICp0b2tlbikKK3sKKwljaGFyICplbmRwOworCXVuc2lnbmVkIGxvbmcgbjsKKworCW4gPSB1c3RydG91bCh0b2tlbiwgJmVuZHAsIDApOworCWlmICgqZW5kcCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkqbnVtMzIgPSBuOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgcGFyc2VfbmFtZShjaGFyICoqcG5hbWUsIGNvbnN0IGNoYXIgKnRva2VuLCBzaXplX3QgbGltaXQpCit7CisJc2l6ZV90IGxlbjsKKwljaGFyICpuYW1lOworCisJbGVuID0gc3RybGVuKHRva2VuKSArIDE7CisJaWYgKGxlbiA+IGxpbWl0KQorCQlyZXR1cm4gLUVOT1NQQzsKKworCW5hbWUgPSBrbWFsbG9jKGxlbiwgR0ZQX0tFUk5FTCk7CisJaWYgKCFuYW1lKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXN0cmNweShuYW1lLCB0b2tlbik7CisKKwkqcG5hbWUgPSBuYW1lOworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBraWxsX2ZpbmFsX25ld2xpbmUoY2hhciAqc3RyKQoreworCWNoYXIgKm5ld2xpbmUgPSBzdHJyY2hyKHN0ciwgJ1xuJyk7CisJaWYgKG5ld2xpbmUgJiYgIW5ld2xpbmVbMV0pCisJCSpuZXdsaW5lID0gMDsKK30KKworCisjZGVmaW5lIHBhcnNlX2VycihmbXQsIGFyZ3MuLi4pIGRvIHsJCVwKKwlFUlJPUigiYmxvY2sybXRkOiAiIGZtdCAiXG4iLCAjIyBhcmdzKTsJXAorCXJldHVybiAwOwkJCQlcCit9IHdoaWxlICgwKQorCitzdGF0aWMgaW50IGJsb2NrMm10ZF9zZXR1cChjb25zdCBjaGFyICp2YWwsIHN0cnVjdCBrZXJuZWxfcGFyYW0gKmtwKQoreworCWNoYXIgYnVmWzgwKzEyXSwgKnN0cj1idWY7IC8qIDgwIGZvciBkZXZpY2UsIDEyIGZvciBlcmFzZSBzaXplICovCisJY2hhciAqdG9rZW5bMl07CisJY2hhciAqbmFtZTsKKwl1MzIgZXJhc2Vfc2l6ZSA9IFBBR0VfU0laRTsKKwlpbnQgaSwgcmV0OworCisJaWYgKHN0cm5sZW4odmFsLCBzaXplb2YoYnVmKSkgPj0gc2l6ZW9mKGJ1ZikpCisJCXBhcnNlX2VycigicGFyYW1ldGVyIHRvbyBsb25nIik7CisKKwlzdHJjcHkoc3RyLCB2YWwpOworCWtpbGxfZmluYWxfbmV3bGluZShzdHIpOworCisJZm9yIChpPTA7IGk8MjsgaSsrKQorCQl0b2tlbltpXSA9IHN0cnNlcCgmc3RyLCAiLCIpOworCisJaWYgKHN0cikKKwkJcGFyc2VfZXJyKCJ0b28gbWFueSBhcmd1bWVudHMiKTsKKworCWlmICghdG9rZW5bMF0pCisJCXBhcnNlX2Vycigibm8gYXJndW1lbnQiKTsKKworCXJldCA9IHBhcnNlX25hbWUoJm5hbWUsIHRva2VuWzBdLCA4MCk7CisJaWYgKHJldCA9PSAtRU5PTUVNKQorCQlwYXJzZV9lcnIoIm91dCBvZiBtZW1vcnkiKTsKKwlpZiAocmV0ID09IC1FTk9TUEMpCisJCXBhcnNlX2VycigibmFtZSB0b28gbG9uZyIpOworCWlmIChyZXQpCisJCXJldHVybiAwOworCisJaWYgKHRva2VuWzFdKSB7CisJCXJldCA9IHBhcnNlX251bTMyKCZlcmFzZV9zaXplLCB0b2tlblsxXSk7CisJCWlmIChyZXQpCisJCQlwYXJzZV9lcnIoImlsbGVnYWwgZXJhc2Ugc2l6ZSIpOworCX0KKworCWFkZF9kZXZpY2UobmFtZSwgZXJhc2Vfc2l6ZSk7CisKKwlyZXR1cm4gMDsKK30KKworCittb2R1bGVfcGFyYW1fY2FsbChibG9jazJtdGQsIGJsb2NrMm10ZF9zZXR1cCwgTlVMTCwgTlVMTCwgMDIwMCk7CitNT0RVTEVfUEFSTV9ERVNDKGJsb2NrMm10ZCwgIkRldmljZSB0byB1c2UuIFwiYmxvY2sybXRkPTxkZXY+Wyw8ZXJhc2VzaXplPl1cIiIpOworCitzdGF0aWMgaW50IF9faW5pdCBibG9jazJtdGRfaW5pdCh2b2lkKQoreworCUlORk8oInZlcnNpb24gIiBWRVJTSU9OKTsKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZCBfX2RldmV4aXQgYmxvY2sybXRkX2V4aXQodm9pZCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpwb3MsICpuZXh0OworCisJLyogUmVtb3ZlIHRoZSBNVEQgZGV2aWNlcyAqLworCWxpc3RfZm9yX2VhY2hfc2FmZShwb3MsIG5leHQsICZibGttdGRfZGV2aWNlX2xpc3QpIHsKKwkJc3RydWN0IGJsb2NrMm10ZF9kZXYgKmRldiA9IGxpc3RfZW50cnkocG9zLCB0eXBlb2YoKmRldiksIGxpc3QpOworCQlibG9jazJtdGRfc3luYygmZGV2LT5tdGQpOworCQlkZWxfbXRkX2RldmljZSgmZGV2LT5tdGQpOworCQlJTkZPKCJtdGQlZDogWyVzXSByZW1vdmVkIiwgZGV2LT5tdGQuaW5kZXgsCisJCQkJZGV2LT5tdGQubmFtZSArIHN0cmxlbigiYmxrbXRkOiAiKSk7CisJCWxpc3RfZGVsKCZkZXYtPmxpc3QpOworCQlibG9jazJtdGRfZnJlZV9kZXZpY2UoZGV2KTsKKwl9Cit9CisKKworbW9kdWxlX2luaXQoYmxvY2sybXRkX2luaXQpOworbW9kdWxlX2V4aXQoYmxvY2sybXRkX2V4aXQpOworCitNT0RVTEVfTElDRU5TRSgiR1BMIik7CitNT0RVTEVfQVVUSE9SKCJTaW1vbiBFdmFucyA8c3BzZUBzZWNyZXQub3JnLnVrPiBhbmQgb3RoZXJzIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkVtdWxhdGUgYW4gTVREIHVzaW5nIGEgYmxvY2sgZGV2aWNlIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL2RvYzIwMDAuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jMjAwMC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVmYzUzMjgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2RvYzIwMDAuYwpAQCAtMCwwICsxLDEzMDkgQEAKKworLyoKKyAqIExpbnV4IGRyaXZlciBmb3IgRGlzay1Pbi1DaGlwIDIwMDAgYW5kIE1pbGxlbm5pdW0KKyAqIChjKSAxOTk5IE1hY2hpbmUgVmlzaW9uIEhvbGRpbmdzLCBJbmMuCisgKiAoYykgMTk5OSwgMjAwMCBEYXZpZCBXb29kaG91c2UgPGR3bXcyQGluZnJhZGVhZC5vcmc+CisgKgorICogJElkOiBkb2MyMDAwLmMsdiAxLjY2IDIwMDUvMDEvMDUgMTg6MDU6MTIgZHdtdzIgRXhwICQKKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8YXNtL2Vycm5vLmg+CisjaW5jbHVkZSA8YXNtL2lvLmg+CisjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9taXNjZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9iaXRvcHMuaD4KKworI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKyNpbmNsdWRlIDxsaW51eC9tdGQvbmFuZC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9kb2MyMDAwLmg+CisKKyNkZWZpbmUgRE9DX1NVUFBPUlRfMjAwMAorI2RlZmluZSBET0NfU1VQUE9SVF8yMDAwVFNPUAorI2RlZmluZSBET0NfU1VQUE9SVF9NSUxMRU5OSVVNCisKKyNpZmRlZiBET0NfU1VQUE9SVF8yMDAwCisjZGVmaW5lIERvQ19pc18yMDAwKGRvYykgKGRvYy0+Q2hpcElEID09IERPQ19DaGlwSURfRG9jMmspCisjZWxzZQorI2RlZmluZSBEb0NfaXNfMjAwMChkb2MpICgwKQorI2VuZGlmCisKKyNpZiBkZWZpbmVkKERPQ19TVVBQT1JUXzIwMDBUU09QKSB8fCBkZWZpbmVkKERPQ19TVVBQT1JUX01JTExFTk5JVU0pCisjZGVmaW5lIERvQ19pc19NaWxsZW5uaXVtKGRvYykgKGRvYy0+Q2hpcElEID09IERPQ19DaGlwSURfRG9jTWlsKQorI2Vsc2UKKyNkZWZpbmUgRG9DX2lzX01pbGxlbm5pdW0oZG9jKSAoMCkKKyNlbmRpZgorCisvKiAjZGVmaW5lIEVDQ19ERUJVRyAqLworCisvKiBJIGhhdmUgbm8gaWRlYSB3aHkgc29tZSBEb0MgY2hpcHMgY2FuIG5vdCB1c2UgbWVtY3B5X2Zyb218dG9faW8oKS4KKyAqIFRoaXMgbWF5IGJlIGR1ZSB0byB0aGUgZGlmZmVyZW50IHJldmlzaW9ucyBvZiB0aGUgQVNJQyBjb250cm9sbGVyIGJ1aWx0LWluIG9yCisgKiBzaW1wbGlseSBhIFFBL0J1ZyBpc3N1ZS4gV2hvIGtub3dzID8/IElmIHlvdSBoYXZlIHRyb3VibGUsIHBsZWFzZSB1bmNvbW1lbnQKKyAqIHRoaXM6CisgI3VuZGVmIFVTRV9NRU1DUFkKKyovCisKK3N0YXRpYyBpbnQgZG9jX3JlYWQoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLAorCQkgICAgc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKTsKK3N0YXRpYyBpbnQgZG9jX3dyaXRlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgdG8sIHNpemVfdCBsZW4sCisJCSAgICAgc2l6ZV90ICpyZXRsZW4sIGNvbnN0IHVfY2hhciAqYnVmKTsKK3N0YXRpYyBpbnQgZG9jX3JlYWRfZWNjKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwKKwkJCXNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZiwgdV9jaGFyICplY2NidWYsIHN0cnVjdCBuYW5kX29vYmluZm8gKm9vYnNlbCk7CitzdGF0aWMgaW50IGRvY193cml0ZV9lY2Moc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJCSBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYsIHVfY2hhciAqZWNjYnVmLCBzdHJ1Y3QgbmFuZF9vb2JpbmZvICpvb2JzZWwpOworc3RhdGljIGludCBkb2Nfd3JpdGV2X2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgY29uc3Qgc3RydWN0IGt2ZWMgKnZlY3MsIAorCQkJICB1bnNpZ25lZCBsb25nIGNvdW50LCBsb2ZmX3QgdG8sIHNpemVfdCAqcmV0bGVuLAorCQkJICB1X2NoYXIgKmVjY2J1Ziwgc3RydWN0IG5hbmRfb29iaW5mbyAqb29ic2VsKTsKK3N0YXRpYyBpbnQgZG9jX3JlYWRfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQkJc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKTsKK3N0YXRpYyBpbnQgZG9jX3dyaXRlX29vYihzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IG9mcywgc2l6ZV90IGxlbiwKKwkJCSBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpOworc3RhdGljIGludCBkb2Nfd3JpdGVfb29iX25vbG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IG9mcywgc2l6ZV90IGxlbiwKKwkJCSBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpOworc3RhdGljIGludCBkb2NfZXJhc2UgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpOworCitzdGF0aWMgc3RydWN0IG10ZF9pbmZvICpkb2Mya2xpc3QgPSBOVUxMOworCisvKiBQZXJmb3JtIHRoZSByZXF1aXJlZCBkZWxheSBjeWNsZXMgYnkgcmVhZGluZyBmcm9tIHRoZSBhcHByb3ByaWF0ZSByZWdpc3RlciAqLworc3RhdGljIHZvaWQgRG9DX0RlbGF5KHN0cnVjdCBEaXNrT25DaGlwICpkb2MsIHVuc2lnbmVkIHNob3J0IGN5Y2xlcykKK3sKKwl2b2xhdGlsZSBjaGFyIGR1bW15OworCWludCBpOworCQorCWZvciAoaSA9IDA7IGkgPCBjeWNsZXM7IGkrKykgeworCQlpZiAoRG9DX2lzX01pbGxlbm5pdW0oZG9jKSkKKwkJCWR1bW15ID0gUmVhZERPQyhkb2MtPnZpcnRhZHIsIE5PUCk7CisJCWVsc2UKKwkJCWR1bW15ID0gUmVhZERPQyhkb2MtPnZpcnRhZHIsIERPQ1N0YXR1cyk7CisJfQorCQorfQorCisvKiBET0NfV2FpdFJlYWR5OiBXYWl0IGZvciBSRFkgbGluZSB0byBiZSBhc3NlcnRlZCBieSB0aGUgZmxhc2ggY2hpcCAqLworc3RhdGljIGludCBfRG9DX1dhaXRSZWFkeShzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jKQoreworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gZG9jLT52aXJ0YWRyOworCXVuc2lnbmVkIGxvbmcgdGltZW8gPSBqaWZmaWVzICsgKEhaICogMTApOworCisJREVCVUcoTVREX0RFQlVHX0xFVkVMMywKKwkgICAgICAiX0RvQ19XYWl0UmVhZHkgY2FsbGVkIGZvciBvdXQtb2YtbGluZSB3YWl0XG4iKTsKKworCS8qIE91dC1vZi1saW5lIHJvdXRpbmUgdG8gd2FpdCBmb3IgY2hpcCByZXNwb25zZSAqLworCXdoaWxlICghKFJlYWRET0MoZG9jcHRyLCBDRFNOQ29udHJvbCkgJiBDRFNOX0NUUkxfRlJfQikpIHsKKwkJLyogaXNzdWUgMiByZWFkIGZyb20gTk9QIHJlZ2lzdGVyIGFmdGVyIHJlYWRpbmcgZnJvbSBDRFNOQ29udHJvbCByZWdpc3RlcgorCSAgIAlzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDIuICovCisJCURvQ19EZWxheShkb2MsIDIpOworCisJCWlmICh0aW1lX2FmdGVyKGppZmZpZXMsIHRpbWVvKSkgeworCQkJREVCVUcoTVREX0RFQlVHX0xFVkVMMiwgIl9Eb0NfV2FpdFJlYWR5IHRpbWVkIG91dC5cbiIpOworCQkJcmV0dXJuIC1FSU87CisJCX0KKwkJdWRlbGF5KDEpOworCQljb25kX3Jlc2NoZWQoKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBpbnQgRG9DX1dhaXRSZWFkeShzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jKQoreworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gZG9jLT52aXJ0YWRyOworCisJLyogVGhpcyBpcyBpbmxpbmUsIHRvIG9wdGltaXNlIHRoZSBjb21tb24gY2FzZSwgd2hlcmUgaXQncyByZWFkeSBpbnN0YW50bHkgKi8KKwlpbnQgcmV0ID0gMDsKKworCS8qIDQgcmVhZCBmb3JtIE5PUCByZWdpc3RlciBzaG91bGQgYmUgaXNzdWVkIGluIHByaW9yIHRvIHRoZSByZWFkIGZyb20gQ0RTTkNvbnRyb2wKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDIuICovCisJRG9DX0RlbGF5KGRvYywgNCk7CisKKwlpZiAoIShSZWFkRE9DKGRvY3B0ciwgQ0RTTkNvbnRyb2wpICYgQ0RTTl9DVFJMX0ZSX0IpKQorCQkvKiBDYWxsIHRoZSBvdXQtb2YtbGluZSByb3V0aW5lIHRvIHdhaXQgKi8KKwkJcmV0ID0gX0RvQ19XYWl0UmVhZHkoZG9jKTsKKworCS8qIGlzc3VlIDIgcmVhZCBmcm9tIE5PUCByZWdpc3RlciBhZnRlciByZWFkaW5nIGZyb20gQ0RTTkNvbnRyb2wgcmVnaXN0ZXIKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDIuICovCisJRG9DX0RlbGF5KGRvYywgMik7CisKKwlyZXR1cm4gcmV0OworfQorCisvKiBEb0NfQ29tbWFuZDogU2VuZCBhIGZsYXNoIGNvbW1hbmQgdG8gdGhlIGZsYXNoIGNoaXAgdGhyb3VnaCB0aGUgQ0RTTiBTbG93IElPIHJlZ2lzdGVyIHRvCisgICBieXBhc3MgdGhlIGludGVybmFsIHBpcGVsaW5lLiBFYWNoIG9mIDQgZGVsYXkgY3ljbGVzIChyZWFkIGZyb20gdGhlIE5PUCByZWdpc3RlcikgaXMKKyAgIHJlcXVpcmVkIGFmdGVyIHdyaXRpbmcgdG8gQ0RTTiBDb250cm9sIHJlZ2lzdGVyLCBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDMuICovCisKK3N0YXRpYyBpbmxpbmUgaW50IERvQ19Db21tYW5kKHN0cnVjdCBEaXNrT25DaGlwICpkb2MsIHVuc2lnbmVkIGNoYXIgY29tbWFuZCwKKwkJCSAgICAgIHVuc2lnbmVkIGNoYXIgeHRyYWZsYWdzKQoreworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gZG9jLT52aXJ0YWRyOworCisJaWYgKERvQ19pc18yMDAwKGRvYykpCisJCXh0cmFmbGFncyB8PSBDRFNOX0NUUkxfRkxBU0hfSU87CisKKwkvKiBBc3NlcnQgdGhlIENMRSAoQ29tbWFuZCBMYXRjaCBFbmFibGUpIGxpbmUgdG8gdGhlIGZsYXNoIGNoaXAgKi8KKwlXcml0ZURPQyh4dHJhZmxhZ3MgfCBDRFNOX0NUUkxfQ0xFIHwgQ0RTTl9DVFJMX0NFLCBkb2NwdHIsIENEU05Db250cm9sKTsKKwlEb0NfRGVsYXkoZG9jLCA0KTsJLyogU29mdHdhcmUgcmVxdWlyZW1lbnQgMTEuNC4zIGZvciBNaWxsZW5uaXVtICovCisKKwlpZiAoRG9DX2lzX01pbGxlbm5pdW0oZG9jKSkKKwkJV3JpdGVET0MoY29tbWFuZCwgZG9jcHRyLCBDRFNOU2xvd0lPKTsKKworCS8qIFNlbmQgdGhlIGNvbW1hbmQgKi8KKwlXcml0ZURPQ18oY29tbWFuZCwgZG9jcHRyLCBkb2MtPmlvcmVnKTsKKwlpZiAoRG9DX2lzX01pbGxlbm5pdW0oZG9jKSkKKwkJV3JpdGVET0MoY29tbWFuZCwgZG9jcHRyLCBXcml0ZVBpcGVUZXJtKTsKKworCS8qIExvd2VyIHRoZSBDTEUgbGluZSAqLworCVdyaXRlRE9DKHh0cmFmbGFncyB8IENEU05fQ1RSTF9DRSwgZG9jcHRyLCBDRFNOQ29udHJvbCk7CisJRG9DX0RlbGF5KGRvYywgNCk7CS8qIFNvZnR3YXJlIHJlcXVpcmVtZW50IDExLjQuMyBmb3IgTWlsbGVubml1bSAqLworCisJLyogV2FpdCBmb3IgdGhlIGNoaXAgdG8gcmVzcG9uZCAtIFNvZnR3YXJlIHJlcXVpcmVtZW50IDExLjQuMSAoZXh0ZW5kZWQgZm9yIGFueSBjb21tYW5kKSAqLworCXJldHVybiBEb0NfV2FpdFJlYWR5KGRvYyk7Cit9CisKKy8qIERvQ19BZGRyZXNzOiBTZXQgdGhlIGN1cnJlbnQgYWRkcmVzcyBmb3IgdGhlIGZsYXNoIGNoaXAgdGhyb3VnaCB0aGUgQ0RTTiBTbG93IElPIHJlZ2lzdGVyIHRvCisgICBieXBhc3MgdGhlIGludGVybmFsIHBpcGVsaW5lLiBFYWNoIG9mIDQgZGVsYXkgY3ljbGVzIChyZWFkIGZyb20gdGhlIE5PUCByZWdpc3RlcikgaXMKKyAgIHJlcXVpcmVkIGFmdGVyIHdyaXRpbmcgdG8gQ0RTTiBDb250cm9sIHJlZ2lzdGVyLCBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDMuICovCisKK3N0YXRpYyBpbnQgRG9DX0FkZHJlc3Moc3RydWN0IERpc2tPbkNoaXAgKmRvYywgaW50IG51bWJ5dGVzLCB1bnNpZ25lZCBsb25nIG9mcywKKwkJICAgICAgIHVuc2lnbmVkIGNoYXIgeHRyYWZsYWdzMSwgdW5zaWduZWQgY2hhciB4dHJhZmxhZ3MyKQoreworCWludCBpOworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gZG9jLT52aXJ0YWRyOworCisJaWYgKERvQ19pc18yMDAwKGRvYykpCisJCXh0cmFmbGFnczEgfD0gQ0RTTl9DVFJMX0ZMQVNIX0lPOworCisJLyogQXNzZXJ0IHRoZSBBTEUgKEFkZHJlc3MgTGF0Y2ggRW5hYmxlKSBsaW5lIHRvIHRoZSBmbGFzaCBjaGlwICovCisJV3JpdGVET0MoeHRyYWZsYWdzMSB8IENEU05fQ1RSTF9BTEUgfCBDRFNOX0NUUkxfQ0UsIGRvY3B0ciwgQ0RTTkNvbnRyb2wpOworCisJRG9DX0RlbGF5KGRvYywgNCk7CS8qIFNvZnR3YXJlIHJlcXVpcmVtZW50IDExLjQuMyBmb3IgTWlsbGVubml1bSAqLworCisJLyogU2VuZCB0aGUgYWRkcmVzcyAqLworCS8qIERldmljZXMgd2l0aCAyNTYtYnl0ZSBwYWdlIGFyZSBhZGRyZXNzZWQgYXM6CisJICAgQ29sdW1uIChiaXRzIDAtNyksIFBhZ2UgKGJpdHMgOC0xNSwgMTYtMjMsIDI0LTMxKQorCSAgICogdGhlcmUgaXMgbm8gZGV2aWNlIG9uIHRoZSBtYXJrZXQgd2l0aCBwYWdlMjU2CisJICAgYW5kIG1vcmUgdGhhbiAyNCBiaXRzLgorCSAgIERldmljZXMgd2l0aCA1MTItYnl0ZSBwYWdlIGFyZSBhZGRyZXNzZWQgYXM6CisJICAgQ29sdW1uIChiaXRzIDAtNyksIFBhZ2UgKGJpdHMgOS0xNiwgMTctMjQsIDI1LTMxKQorCSAgICogMjUtMzEgaXMgc2VudCBvbmx5IGlmIHRoZSBjaGlwIHN1cHBvcnQgaXQuCisJICAgKiBiaXQgOCBjaGFuZ2VzIHRoZSByZWFkIGNvbW1hbmQgdG8gYmUgc2VudAorCSAgIChOQU5EX0NNRF9SRUFEMCBvciBOQU5EX0NNRF9SRUFEMSkuCisJICovCisKKwlpZiAobnVtYnl0ZXMgPT0gQUREUl9DT0xVTU4gfHwgbnVtYnl0ZXMgPT0gQUREUl9DT0xVTU5fUEFHRSkgeworCQlpZiAoRG9DX2lzX01pbGxlbm5pdW0oZG9jKSkKKwkJCVdyaXRlRE9DKG9mcyAmIDB4ZmYsIGRvY3B0ciwgQ0RTTlNsb3dJTyk7CisJCVdyaXRlRE9DXyhvZnMgJiAweGZmLCBkb2NwdHIsIGRvYy0+aW9yZWcpOworCX0KKworCWlmIChkb2MtPnBhZ2UyNTYpIHsKKwkJb2ZzID0gb2ZzID4+IDg7CisJfSBlbHNlIHsKKwkJb2ZzID0gb2ZzID4+IDk7CisJfQorCisJaWYgKG51bWJ5dGVzID09IEFERFJfUEFHRSB8fCBudW1ieXRlcyA9PSBBRERSX0NPTFVNTl9QQUdFKSB7CisJCWZvciAoaSA9IDA7IGkgPCBkb2MtPnBhZ2VhZHJsZW47IGkrKywgb2ZzID0gb2ZzID4+IDgpIHsKKwkJCWlmIChEb0NfaXNfTWlsbGVubml1bShkb2MpKQorCQkJCVdyaXRlRE9DKG9mcyAmIDB4ZmYsIGRvY3B0ciwgQ0RTTlNsb3dJTyk7CisJCQlXcml0ZURPQ18ob2ZzICYgMHhmZiwgZG9jcHRyLCBkb2MtPmlvcmVnKTsKKwkJfQorCX0KKworCWlmIChEb0NfaXNfTWlsbGVubml1bShkb2MpKQorCQlXcml0ZURPQyhvZnMgJiAweGZmLCBkb2NwdHIsIFdyaXRlUGlwZVRlcm0pOworCisJRG9DX0RlbGF5KGRvYywgMik7CS8qIE5lZWRlZCBmb3Igc29tZSBzbG93IGZsYXNoIGNoaXBzLiBtZi4gKi8KKwkKKwkvKiBGSVhNRTogVGhlIFNsb3dJTydzIGZvciBtaWxsZW5uaXVtIGNvdWxkIGJlIHJlcGxhY2VkIGJ5IAorCSAgIGEgc2luZ2xlIFdyaXRlUGlwZVRlcm0gaGVyZS4gbWYuICovCisKKwkvKiBMb3dlciB0aGUgQUxFIGxpbmUgKi8KKwlXcml0ZURPQyh4dHJhZmxhZ3MxIHwgeHRyYWZsYWdzMiB8IENEU05fQ1RSTF9DRSwgZG9jcHRyLAorCQkgQ0RTTkNvbnRyb2wpOworCisJRG9DX0RlbGF5KGRvYywgNCk7CS8qIFNvZnR3YXJlIHJlcXVpcmVtZW50IDExLjQuMyBmb3IgTWlsbGVubml1bSAqLworCisJLyogV2FpdCBmb3IgdGhlIGNoaXAgdG8gcmVzcG9uZCAtIFNvZnR3YXJlIHJlcXVpcmVtZW50IDExLjQuMSAqLworCXJldHVybiBEb0NfV2FpdFJlYWR5KGRvYyk7Cit9CisKKy8qIFJlYWQgYSBidWZmZXIgZnJvbSBEb0MsIHRha2luZyBjYXJlIG9mIE1pbGxlbm5pdW0gb2RkaXR5cyAqLworc3RhdGljIHZvaWQgRG9DX1JlYWRCdWYoc3RydWN0IERpc2tPbkNoaXAgKmRvYywgdV9jaGFyICogYnVmLCBpbnQgbGVuKQoreworCXZvbGF0aWxlIGludCBkdW1teTsKKwlpbnQgbW9kdWx1cyA9IDB4ZmZmZjsKKwl2b2lkIF9faW9tZW0gKmRvY3B0ciA9IGRvYy0+dmlydGFkcjsKKwlpbnQgaTsKKworCWlmIChsZW4gPD0gMCkKKwkJcmV0dXJuOworCisJaWYgKERvQ19pc19NaWxsZW5uaXVtKGRvYykpIHsKKwkJLyogUmVhZCB0aGUgZGF0YSB2aWEgdGhlIGludGVybmFsIHBpcGVsaW5lIHRocm91Z2ggQ0RTTiBJTyByZWdpc3RlciwKKwkJICAgc2VlIFBpcGVsaW5lZCBSZWFkIE9wZXJhdGlvbnMgMTEuMyAqLworCQlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBSZWFkUGlwZUluaXQpOworCisJCS8qIE1pbGxlbm5pdW0gc2hvdWxkIHVzZSB0aGUgTGFzdERhdGFSZWFkIHJlZ2lzdGVyIC0gUGlwZWxpbmUgUmVhZHMgKi8KKwkJbGVuLS07CisKKwkJLyogVGhpcyBpcyBuZWVkZWQgZm9yIGNvcnJlY3RseSBFQ0MgY2FsY3VsYXRpb24gKi8KKwkJbW9kdWx1cyA9IDB4ZmY7CisJfQorCisJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQorCQlidWZbaV0gPSBSZWFkRE9DXyhkb2NwdHIsIGRvYy0+aW9yZWcgKyAoaSAmIG1vZHVsdXMpKTsKKworCWlmIChEb0NfaXNfTWlsbGVubml1bShkb2MpKSB7CisJCWJ1ZltpXSA9IFJlYWRET0MoZG9jcHRyLCBMYXN0RGF0YVJlYWQpOworCX0KK30KKworLyogV3JpdGUgYSBidWZmZXIgdG8gRG9DLCB0YWtpbmcgY2FyZSBvZiBNaWxsZW5uaXVtIG9kZGl0eXMgKi8KK3N0YXRpYyB2b2lkIERvQ19Xcml0ZUJ1ZihzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jLCBjb25zdCB1X2NoYXIgKiBidWYsIGludCBsZW4pCit7CisJdm9pZCBfX2lvbWVtICpkb2NwdHIgPSBkb2MtPnZpcnRhZHI7CisJaW50IGk7CisKKwlpZiAobGVuIDw9IDApCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykKKwkJV3JpdGVET0NfKGJ1ZltpXSwgZG9jcHRyLCBkb2MtPmlvcmVnICsgaSk7CisKKwlpZiAoRG9DX2lzX01pbGxlbm5pdW0oZG9jKSkgeworCQlXcml0ZURPQygweDAwLCBkb2NwdHIsIFdyaXRlUGlwZVRlcm0pOworCX0KK30KKworCisvKiBEb0NfU2VsZWN0Q2hpcDogU2VsZWN0IGEgZ2l2ZW4gZmxhc2ggY2hpcCB3aXRoaW4gdGhlIGN1cnJlbnQgZmxvb3IgKi8KKworc3RhdGljIGlubGluZSBpbnQgRG9DX1NlbGVjdENoaXAoc3RydWN0IERpc2tPbkNoaXAgKmRvYywgaW50IGNoaXApCit7CisJdm9pZCBfX2lvbWVtICpkb2NwdHIgPSBkb2MtPnZpcnRhZHI7CisKKwkvKiBTb2Z0d2FyZSByZXF1aXJlbWVudCAxMS40LjQgYmVmb3JlIHdyaXRpbmcgRGV2aWNlU2VsZWN0ICovCisJLyogRGVhc3NlcnQgdGhlIENFIGxpbmUgdG8gZWxpbWluYXRlIGdsaXRjaGVzIG9uIHRoZSBGQ0UjIG91dHB1dHMgKi8KKwlXcml0ZURPQyhDRFNOX0NUUkxfV1AsIGRvY3B0ciwgQ0RTTkNvbnRyb2wpOworCURvQ19EZWxheShkb2MsIDQpOwkvKiBTb2Z0d2FyZSByZXF1aXJlbWVudCAxMS40LjMgZm9yIE1pbGxlbm5pdW0gKi8KKworCS8qIFNlbGVjdCB0aGUgaW5kaXZpZHVhbCBmbGFzaCBjaGlwIHJlcXVlc3RlZCAqLworCVdyaXRlRE9DKGNoaXAsIGRvY3B0ciwgQ0RTTkRldmljZVNlbGVjdCk7CisJRG9DX0RlbGF5KGRvYywgNCk7CisKKwkvKiBSZWFzc2VydCB0aGUgQ0UgbGluZSAqLworCVdyaXRlRE9DKENEU05fQ1RSTF9DRSB8IENEU05fQ1RSTF9GTEFTSF9JTyB8IENEU05fQ1RSTF9XUCwgZG9jcHRyLAorCQkgQ0RTTkNvbnRyb2wpOworCURvQ19EZWxheShkb2MsIDQpOwkvKiBTb2Z0d2FyZSByZXF1aXJlbWVudCAxMS40LjMgZm9yIE1pbGxlbm5pdW0gKi8KKworCS8qIFdhaXQgZm9yIGl0IHRvIGJlIHJlYWR5ICovCisJcmV0dXJuIERvQ19XYWl0UmVhZHkoZG9jKTsKK30KKworLyogRG9DX1NlbGVjdEZsb29yOiBTZWxlY3QgYSBnaXZlbiBmbG9vciAoYmFuayBvZiBmbGFzaCBjaGlwcykgKi8KKworc3RhdGljIGlubGluZSBpbnQgRG9DX1NlbGVjdEZsb29yKHN0cnVjdCBEaXNrT25DaGlwICpkb2MsIGludCBmbG9vcikKK3sKKwl2b2lkIF9faW9tZW0gKmRvY3B0ciA9IGRvYy0+dmlydGFkcjsKKworCS8qIFNlbGVjdCB0aGUgZmxvb3IgKGJhbmspIG9mIGNoaXBzIHJlcXVpcmVkICovCisJV3JpdGVET0MoZmxvb3IsIGRvY3B0ciwgRmxvb3JTZWxlY3QpOworCisJLyogV2FpdCBmb3IgdGhlIGNoaXAgdG8gYmUgcmVhZHkgKi8KKwlyZXR1cm4gRG9DX1dhaXRSZWFkeShkb2MpOworfQorCisvKiBEb0NfSWRlbnRDaGlwOiBJZGVudGlmeSBhIGdpdmVuIE5BTkQgY2hpcCBnaXZlbiB7Zmxvb3IsY2hpcH0gKi8KKworc3RhdGljIGludCBEb0NfSWRlbnRDaGlwKHN0cnVjdCBEaXNrT25DaGlwICpkb2MsIGludCBmbG9vciwgaW50IGNoaXApCit7CisJaW50IG1mciwgaWQsIGksIGo7CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKworCS8qIFBhZ2UgaW4gdGhlIHJlcXVpcmVkIGZsb29yL2NoaXAgKi8KKwlEb0NfU2VsZWN0Rmxvb3IoZG9jLCBmbG9vcik7CisJRG9DX1NlbGVjdENoaXAoZG9jLCBjaGlwKTsKKworCS8qIFJlc2V0IHRoZSBjaGlwICovCisJaWYgKERvQ19Db21tYW5kKGRvYywgTkFORF9DTURfUkVTRVQsIENEU05fQ1RSTF9XUCkpIHsKKwkJREVCVUcoTVREX0RFQlVHX0xFVkVMMiwKKwkJICAgICAgIkRvQ19Db21tYW5kIChyZXNldCkgZm9yICVkLCVkIHJldHVybmVkIHRydWVcbiIsCisJCSAgICAgIGZsb29yLCBjaGlwKTsKKwkJcmV0dXJuIDA7CisJfQorCisKKwkvKiBSZWFkIHRoZSBOQU5EIGNoaXAgSUQ6IDEuIFNlbmQgUmVhZElEIGNvbW1hbmQgKi8KKwlpZiAoRG9DX0NvbW1hbmQoZG9jLCBOQU5EX0NNRF9SRUFESUQsIENEU05fQ1RSTF9XUCkpIHsKKwkJREVCVUcoTVREX0RFQlVHX0xFVkVMMiwKKwkJICAgICAgIkRvQ19Db21tYW5kIChSZWFkSUQpIGZvciAlZCwlZCByZXR1cm5lZCB0cnVlXG4iLAorCQkgICAgICBmbG9vciwgY2hpcCk7CisJCXJldHVybiAwOworCX0KKworCS8qIFJlYWQgdGhlIE5BTkQgY2hpcCBJRDogMi4gU2VuZCBhZGRyZXNzIGJ5dGUgemVybyAqLworCURvQ19BZGRyZXNzKGRvYywgQUREUl9DT0xVTU4sIDAsIENEU05fQ1RSTF9XUCwgMCk7CisKKwkvKiBSZWFkIHRoZSBtYW51ZmFjdHVyZXIgYW5kIGRldmljZSBpZCBjb2RlcyBmcm9tIHRoZSBkZXZpY2UgKi8KKworCWlmIChEb0NfaXNfTWlsbGVubml1bShkb2MpKSB7CisJCURvQ19EZWxheShkb2MsIDIpOworCQlkdW1teSA9IFJlYWRET0MoZG9jLT52aXJ0YWRyLCBSZWFkUGlwZUluaXQpOworCQltZnIgPSBSZWFkRE9DKGRvYy0+dmlydGFkciwgTGFzdERhdGFSZWFkKTsKKworCQlEb0NfRGVsYXkoZG9jLCAyKTsKKwkJZHVtbXkgPSBSZWFkRE9DKGRvYy0+dmlydGFkciwgUmVhZFBpcGVJbml0KTsKKwkJaWQgPSBSZWFkRE9DKGRvYy0+dmlydGFkciwgTGFzdERhdGFSZWFkKTsKKwl9IGVsc2UgeworCQkvKiBDRFNOIFNsb3cgSU8gcmVnaXN0ZXIgc2VlIFNvZnR3YXJlIFJlcSAxMS40IGl0ZW0gNS4gKi8KKwkJZHVtbXkgPSBSZWFkRE9DKGRvYy0+dmlydGFkciwgQ0RTTlNsb3dJTyk7CisJCURvQ19EZWxheShkb2MsIDIpOworCQltZnIgPSBSZWFkRE9DXyhkb2MtPnZpcnRhZHIsIGRvYy0+aW9yZWcpOworCisJCS8qIENEU04gU2xvdyBJTyByZWdpc3RlciBzZWUgU29mdHdhcmUgUmVxIDExLjQgaXRlbSA1LiAqLworCQlkdW1teSA9IFJlYWRET0MoZG9jLT52aXJ0YWRyLCBDRFNOU2xvd0lPKTsKKwkJRG9DX0RlbGF5KGRvYywgMik7CisJCWlkID0gUmVhZERPQ18oZG9jLT52aXJ0YWRyLCBkb2MtPmlvcmVnKTsKKwl9CisKKwkvKiBObyByZXNwb25zZSAtIHJldHVybiBmYWlsdXJlICovCisJaWYgKG1mciA9PSAweGZmIHx8IG1mciA9PSAwKQorCQlyZXR1cm4gMDsKKworCS8qIENoZWNrIGl0J3MgdGhlIHNhbWUgYXMgdGhlIGZpcnN0IGNoaXAgd2UgaWRlbnRpZmllZC4gCisJICogTS1TeXN0ZW1zIHNheSB0aGF0IGFueSBnaXZlbiBEaXNrT25DaGlwIGRldmljZSBzaG91bGQgb25seQorCSAqIGNvbnRhaW4gX29uZV8gdHlwZSBvZiBmbGFzaCBwYXJ0LCBhbHRob3VnaCB0aGF0J3Mgbm90IGEgCisJICogaGFyZHdhcmUgcmVzdHJpY3Rpb24uICovCisJaWYgKGRvYy0+bWZyKSB7CisJCWlmIChkb2MtPm1mciA9PSBtZnIgJiYgZG9jLT5pZCA9PSBpZCkKKwkJCXJldHVybiAxOwkvKiBUaGlzIGlzIGFub3RoZXIgdGhlIHNhbWUgdGhlIGZpcnN0ICovCisJCWVsc2UKKwkJCXByaW50ayhLRVJOX1dBUk5JTkcKKwkJCSAgICAgICAiRmxhc2ggY2hpcCBhdCBmbG9vciAlZCwgY2hpcCAlZCBpcyBkaWZmZXJlbnQ6XG4iLAorCQkJICAgICAgIGZsb29yLCBjaGlwKTsKKwl9CisKKwkvKiBQcmludCBhbmQgc3RvcmUgdGhlIG1hbnVmYWN0dXJlciBhbmQgSUQgY29kZXMuICovCisJZm9yIChpID0gMDsgbmFuZF9mbGFzaF9pZHNbaV0ubmFtZSAhPSBOVUxMOyBpKyspIHsKKwkJaWYgKGlkID09IG5hbmRfZmxhc2hfaWRzW2ldLmlkKSB7CisJCQkvKiBUcnkgdG8gaWRlbnRpZnkgbWFudWZhY3R1cmVyICovCisJCQlmb3IgKGogPSAwOyBuYW5kX21hbnVmX2lkc1tqXS5pZCAhPSAweDA7IGorKykgeworCQkJCWlmIChuYW5kX21hbnVmX2lkc1tqXS5pZCA9PSBtZnIpCisJCQkJCWJyZWFrOworCQkJfQkKKwkJCXByaW50ayhLRVJOX0lORk8KKwkJCSAgICAgICAiRmxhc2ggY2hpcCBmb3VuZDogTWFudWZhY3R1cmVyIElEOiAlMi4yWCwgIgorCQkJICAgICAgICJDaGlwIElEOiAlMi4yWCAoJXM6JXMpXG4iLCBtZnIsIGlkLAorCQkJICAgICAgIG5hbmRfbWFudWZfaWRzW2pdLm5hbWUsIG5hbmRfZmxhc2hfaWRzW2ldLm5hbWUpOworCQkJaWYgKCFkb2MtPm1mcikgeworCQkJCWRvYy0+bWZyID0gbWZyOworCQkJCWRvYy0+aWQgPSBpZDsKKwkJCQlkb2MtPmNoaXBzaGlmdCA9IAorCQkJCQlmZnMoKG5hbmRfZmxhc2hfaWRzW2ldLmNoaXBzaXplIDw8IDIwKSkgLSAxOworCQkJCWRvYy0+cGFnZTI1NiA9IChuYW5kX2ZsYXNoX2lkc1tpXS5wYWdlc2l6ZSA9PSAyNTYpID8gMSA6IDA7CisJCQkJZG9jLT5wYWdlYWRybGVuID0gZG9jLT5jaGlwc2hpZnQgPiAyNSA/IDMgOiAyOworCQkJCWRvYy0+ZXJhc2VzaXplID0KKwkJCQkgICAgbmFuZF9mbGFzaF9pZHNbaV0uZXJhc2VzaXplOworCQkJCXJldHVybiAxOworCQkJfQorCQkJcmV0dXJuIDA7CisJCX0KKwl9CisKKworCS8qIFdlIGhhdmVuJ3QgZnVsbHkgaWRlbnRpZmllZCB0aGUgY2hpcC4gUHJpbnQgYXMgbXVjaCBhcyB3ZSBrbm93LiAqLworCXByaW50ayhLRVJOX1dBUk5JTkcgIlVua25vd24gZmxhc2ggY2hpcCBmb3VuZDogJTIuMlggJTIuMlhcbiIsCisJICAgICAgIGlkLCBtZnIpOworCisJcHJpbnRrKEtFUk5fV0FSTklORyAiUGxlYXNlIHJlcG9ydCB0byBkd213MkBpbmZyYWRlYWQub3JnXG4iKTsKKwlyZXR1cm4gMDsKK30KKworLyogRG9DX1NjYW5DaGlwczogRmluZCBhbGwgTkFORCBjaGlwcyBwcmVzZW50IGluIGEgRGlza09uQ2hpcCwgYW5kIGlkZW50aWZ5IHRoZW0gKi8KKworc3RhdGljIHZvaWQgRG9DX1NjYW5DaGlwcyhzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcywgaW50IG1heGNoaXBzKQoreworCWludCBmbG9vciwgY2hpcDsKKwlpbnQgbnVtY2hpcHNbTUFYX0ZMT09SU107CisJaW50IHJldCA9IDE7CisKKwl0aGlzLT5udW1jaGlwcyA9IDA7CisJdGhpcy0+bWZyID0gMDsKKwl0aGlzLT5pZCA9IDA7CisKKwkvKiBGb3IgZWFjaCBmbG9vciwgZmluZCB0aGUgbnVtYmVyIG9mIHZhbGlkIGNoaXBzIGl0IGNvbnRhaW5zICovCisJZm9yIChmbG9vciA9IDA7IGZsb29yIDwgTUFYX0ZMT09SUzsgZmxvb3IrKykgeworCQlyZXQgPSAxOworCQludW1jaGlwc1tmbG9vcl0gPSAwOworCQlmb3IgKGNoaXAgPSAwOyBjaGlwIDwgbWF4Y2hpcHMgJiYgcmV0ICE9IDA7IGNoaXArKykgeworCisJCQlyZXQgPSBEb0NfSWRlbnRDaGlwKHRoaXMsIGZsb29yLCBjaGlwKTsKKwkJCWlmIChyZXQpIHsKKwkJCQludW1jaGlwc1tmbG9vcl0rKzsKKwkJCQl0aGlzLT5udW1jaGlwcysrOworCQkJfQorCQl9CisJfQorCisJLyogSWYgdGhlcmUgYXJlIG5vbmUgYXQgYWxsIHRoYXQgd2UgcmVjb2duaXNlLCBiYWlsICovCisJaWYgKCF0aGlzLT5udW1jaGlwcykgeworCQlwcmludGsoS0VSTl9OT1RJQ0UgIk5vIGZsYXNoIGNoaXBzIHJlY29nbmlzZWQuXG4iKTsKKwkJcmV0dXJuOworCX0KKworCS8qIEFsbG9jYXRlIGFuIGFycmF5IHRvIGhvbGQgdGhlIGluZm9ybWF0aW9uIGZvciBlYWNoIGNoaXAgKi8KKwl0aGlzLT5jaGlwcyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBOYW5kKSAqIHRoaXMtPm51bWNoaXBzLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXRoaXMtPmNoaXBzKSB7CisJCXByaW50ayhLRVJOX05PVElDRSAiTm8gbWVtb3J5IGZvciBhbGxvY2F0aW5nIGNoaXAgaW5mbyBzdHJ1Y3R1cmVzXG4iKTsKKwkJcmV0dXJuOworCX0KKworCXJldCA9IDA7CisKKwkvKiBGaWxsIG91dCB0aGUgY2hpcCBhcnJheSB3aXRoIHtmbG9vciwgY2hpcG5vfSBmb3IgZWFjaCAKKwkgKiBkZXRlY3RlZCBjaGlwIGluIHRoZSBkZXZpY2UuICovCisJZm9yIChmbG9vciA9IDA7IGZsb29yIDwgTUFYX0ZMT09SUzsgZmxvb3IrKykgeworCQlmb3IgKGNoaXAgPSAwOyBjaGlwIDwgbnVtY2hpcHNbZmxvb3JdOyBjaGlwKyspIHsKKwkJCXRoaXMtPmNoaXBzW3JldF0uZmxvb3IgPSBmbG9vcjsKKwkJCXRoaXMtPmNoaXBzW3JldF0uY2hpcCA9IGNoaXA7CisJCQl0aGlzLT5jaGlwc1tyZXRdLmN1cmFkciA9IDA7CisJCQl0aGlzLT5jaGlwc1tyZXRdLmN1cm1vZGUgPSAweDUwOworCQkJcmV0Kys7CisJCX0KKwl9CisKKwkvKiBDYWxjdWxhdGUgYW5kIHByaW50IHRoZSB0b3RhbCBzaXplIG9mIHRoZSBkZXZpY2UgKi8KKwl0aGlzLT50b3RsZW4gPSB0aGlzLT5udW1jaGlwcyAqICgxIDw8IHRoaXMtPmNoaXBzaGlmdCk7CisKKwlwcmludGsoS0VSTl9JTkZPICIlZCBmbGFzaCBjaGlwcyBmb3VuZC4gVG90YWwgRGlza09uQ2hpcCBzaXplOiAlbGQgTWlCXG4iLAorCSAgICAgICB0aGlzLT5udW1jaGlwcywgdGhpcy0+dG90bGVuID4+IDIwKTsKK30KKworc3RhdGljIGludCBEb0Mya19pc19hbGlhcyhzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jMSwgc3RydWN0IERpc2tPbkNoaXAgKmRvYzIpCit7CisJaW50IHRtcDEsIHRtcDIsIHJldHZhbDsKKwlpZiAoZG9jMS0+cGh5c2FkciA9PSBkb2MyLT5waHlzYWRyKQorCQlyZXR1cm4gMTsKKworCS8qIFVzZSB0aGUgYWxpYXMgcmVzb2x1dGlvbiByZWdpc3RlciB3aGljaCB3YXMgc2V0IGFzaWRlIGZvciB0aGlzCisJICogcHVycG9zZS4gSWYgaXQncyB2YWx1ZSBpcyB0aGUgc2FtZSBvbiBib3RoIGNoaXBzLCB0aGV5IG1pZ2h0CisJICogYmUgdGhlIHNhbWUgY2hpcCwgYW5kIHdlIHdyaXRlIHRvIG9uZSBhbmQgY2hlY2sgZm9yIGEgY2hhbmdlIGluCisJICogdGhlIG90aGVyLiBJdCdzIHVuY2xlYXIgaWYgdGhpcyByZWdpc3RlciBpcyB1c3VhYmxlIGluIHRoZQorCSAqIERvQyAyMDAwIChpdCdzIGluIHRoZSBNaWxsZW5uaXVtIGRvY3MpLCBidXQgaXQgc2VlbXMgdG8gd29yay4gKi8KKwl0bXAxID0gUmVhZERPQyhkb2MxLT52aXJ0YWRyLCBBbGlhc1Jlc29sdXRpb24pOworCXRtcDIgPSBSZWFkRE9DKGRvYzItPnZpcnRhZHIsIEFsaWFzUmVzb2x1dGlvbik7CisJaWYgKHRtcDEgIT0gdG1wMikKKwkJcmV0dXJuIDA7CisKKwlXcml0ZURPQygodG1wMSArIDEpICUgMHhmZiwgZG9jMS0+dmlydGFkciwgQWxpYXNSZXNvbHV0aW9uKTsKKwl0bXAyID0gUmVhZERPQyhkb2MyLT52aXJ0YWRyLCBBbGlhc1Jlc29sdXRpb24pOworCWlmICh0bXAyID09ICh0bXAxICsgMSkgJSAweGZmKQorCQlyZXR2YWwgPSAxOworCWVsc2UKKwkJcmV0dmFsID0gMDsKKworCS8qIFJlc3RvcmUgcmVnaXN0ZXIgY29udGVudHMuICBNYXkgbm90IGJlIG5lY2Vzc2FyeSwgYnV0IGRvIGl0IGp1c3QgdG8KKwkgKiBiZSBzYWZlLiAqLworCVdyaXRlRE9DKHRtcDEsIGRvYzEtPnZpcnRhZHIsIEFsaWFzUmVzb2x1dGlvbik7CisKKwlyZXR1cm4gcmV0dmFsOworfQorCitzdGF0aWMgY29uc3QgY2hhciBpbV9uYW1lW10gPSAiRG9DMmtfaW5pdCI7CisKKy8qIFRoaXMgcm91dGluZSBpcyBtYWRlIGF2YWlsYWJsZSB0byBvdGhlciBtdGQgY29kZSB2aWEKKyAqIGludGVyX21vZHVsZV9yZWdpc3Rlci4gIEl0IG11c3Qgb25seSBiZSBhY2Nlc3NlZCB0aHJvdWdoCisgKiBpbnRlcl9tb2R1bGVfZ2V0IHdoaWNoIHdpbGwgYnVtcCB0aGUgdXNlIGNvdW50IG9mIHRoaXMgbW9kdWxlLiAgVGhlCisgKiBhZGRyZXNzZXMgcGFzc2VkIGJhY2sgaW4gbXRkIGFyZSB2YWxpZCBhcyBsb25nIGFzIHRoZSB1c2UgY291bnQgb2YKKyAqIHRoaXMgbW9kdWxlIGlzIG5vbi16ZXJvLCBpLmUuIGJldHdlZW4gaW50ZXJfbW9kdWxlX2dldCBhbmQKKyAqIGludGVyX21vZHVsZV9wdXQuICBLZWl0aCBPd2VucyA8a2Fvc0BvY3MuY29tLmF1PiAyOSBPY3QgMjAwMC4KKyAqLworc3RhdGljIHZvaWQgRG9DMmtfaW5pdChzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKK3sKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqb2xkID0gTlVMTDsKKwlpbnQgbWF4Y2hpcHM7CisKKwkvKiBXZSBtdXN0IGF2b2lkIGJlaW5nIGNhbGxlZCB0d2ljZSBmb3IgdGhlIHNhbWUgZGV2aWNlLiAqLworCisJaWYgKGRvYzJrbGlzdCkKKwkJb2xkID0gZG9jMmtsaXN0LT5wcml2OworCisJd2hpbGUgKG9sZCkgeworCQlpZiAoRG9DMmtfaXNfYWxpYXMob2xkLCB0aGlzKSkgeworCQkJcHJpbnRrKEtFUk5fTk9USUNFCisJCQkgICAgICAgIklnbm9yaW5nIERpc2tPbkNoaXAgMjAwMCBhdCAweCVsWCAtIGFscmVhZHkgY29uZmlndXJlZFxuIiwKKwkJCSAgICAgICB0aGlzLT5waHlzYWRyKTsKKwkJCWlvdW5tYXAodGhpcy0+dmlydGFkcik7CisJCQlrZnJlZShtdGQpOworCQkJcmV0dXJuOworCQl9CisJCWlmIChvbGQtPm5leHRkb2MpCisJCQlvbGQgPSBvbGQtPm5leHRkb2MtPnByaXY7CisJCWVsc2UKKwkJCW9sZCA9IE5VTEw7CisJfQorCisKKwlzd2l0Y2ggKHRoaXMtPkNoaXBJRCkgeworCWNhc2UgRE9DX0NoaXBJRF9Eb2Mya1RTT1A6CisJCW10ZC0+bmFtZSA9ICJEaXNrT25DaGlwIDIwMDAgVFNPUCI7CisJCXRoaXMtPmlvcmVnID0gRG9DX01pbF9DRFNOX0lPOworCQkvKiBQcmV0ZW5kIGl0J3MgYSBNaWxsZW5uaXVtICovCisJCXRoaXMtPkNoaXBJRCA9IERPQ19DaGlwSURfRG9jTWlsOworCQltYXhjaGlwcyA9IE1BWF9DSElQUzsKKwkJYnJlYWs7CisJY2FzZSBET0NfQ2hpcElEX0RvYzJrOgorCQltdGQtPm5hbWUgPSAiRGlza09uQ2hpcCAyMDAwIjsKKwkJdGhpcy0+aW9yZWcgPSBEb0NfMmtfQ0RTTl9JTzsKKwkJbWF4Y2hpcHMgPSBNQVhfQ0hJUFM7CisJCWJyZWFrOworCWNhc2UgRE9DX0NoaXBJRF9Eb2NNaWw6CisJCW10ZC0+bmFtZSA9ICJEaXNrT25DaGlwIE1pbGxlbm5pdW0iOworCQl0aGlzLT5pb3JlZyA9IERvQ19NaWxfQ0RTTl9JTzsKKwkJbWF4Y2hpcHMgPSBNQVhfQ0hJUFNfTUlMOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlwcmludGsoIlVua25vd24gQ2hpcElEIDB4JTAyeFxuIiwgdGhpcy0+Q2hpcElEKTsKKwkJa2ZyZWUobXRkKTsKKwkJaW91bm1hcCh0aGlzLT52aXJ0YWRyKTsKKwkJcmV0dXJuOworCX0KKworCXByaW50ayhLRVJOX05PVElDRSAiJXMgZm91bmQgYXQgYWRkcmVzcyAweCVsWFxuIiwgbXRkLT5uYW1lLAorCSAgICAgICB0aGlzLT5waHlzYWRyKTsKKworCW10ZC0+dHlwZSA9IE1URF9OQU5ERkxBU0g7CisJbXRkLT5mbGFncyA9IE1URF9DQVBfTkFOREZMQVNIOworCW10ZC0+ZWNjdHlwZSA9IE1URF9FQ0NfUlNfRGlza09uQ2hpcDsKKwltdGQtPnNpemUgPSAwOworCW10ZC0+ZXJhc2VzaXplID0gMDsKKwltdGQtPm9vYmJsb2NrID0gNTEyOworCW10ZC0+b29ic2l6ZSA9IDE2OworCW10ZC0+b3duZXIgPSBUSElTX01PRFVMRTsKKwltdGQtPmVyYXNlID0gZG9jX2VyYXNlOworCW10ZC0+cG9pbnQgPSBOVUxMOworCW10ZC0+dW5wb2ludCA9IE5VTEw7CisJbXRkLT5yZWFkID0gZG9jX3JlYWQ7CisJbXRkLT53cml0ZSA9IGRvY193cml0ZTsKKwltdGQtPnJlYWRfZWNjID0gZG9jX3JlYWRfZWNjOworCW10ZC0+d3JpdGVfZWNjID0gZG9jX3dyaXRlX2VjYzsKKwltdGQtPndyaXRldl9lY2MgPSBkb2Nfd3JpdGV2X2VjYzsKKwltdGQtPnJlYWRfb29iID0gZG9jX3JlYWRfb29iOworCW10ZC0+d3JpdGVfb29iID0gZG9jX3dyaXRlX29vYjsKKwltdGQtPnN5bmMgPSBOVUxMOworCisJdGhpcy0+dG90bGVuID0gMDsKKwl0aGlzLT5udW1jaGlwcyA9IDA7CisKKwl0aGlzLT5jdXJmbG9vciA9IC0xOworCXRoaXMtPmN1cmNoaXAgPSAtMTsKKwlpbml0X01VVEVYKCZ0aGlzLT5sb2NrKTsKKworCS8qIElkZW50IGFsbCB0aGUgY2hpcHMgcHJlc2VudC4gKi8KKwlEb0NfU2NhbkNoaXBzKHRoaXMsIG1heGNoaXBzKTsKKworCWlmICghdGhpcy0+dG90bGVuKSB7CisJCWtmcmVlKG10ZCk7CisJCWlvdW5tYXAodGhpcy0+dmlydGFkcik7CisJfSBlbHNlIHsKKwkJdGhpcy0+bmV4dGRvYyA9IGRvYzJrbGlzdDsKKwkJZG9jMmtsaXN0ID0gbXRkOworCQltdGQtPnNpemUgPSB0aGlzLT50b3RsZW47CisJCW10ZC0+ZXJhc2VzaXplID0gdGhpcy0+ZXJhc2VzaXplOworCQlhZGRfbXRkX2RldmljZShtdGQpOworCQlyZXR1cm47CisJfQorfQorCitzdGF0aWMgaW50IGRvY19yZWFkKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwKKwkJICAgIHNpemVfdCAqIHJldGxlbiwgdV9jaGFyICogYnVmKQoreworCS8qIEp1c3QgYSBzcGVjaWFsIGNhc2Ugb2YgZG9jX3JlYWRfZWNjICovCisJcmV0dXJuIGRvY19yZWFkX2VjYyhtdGQsIGZyb20sIGxlbiwgcmV0bGVuLCBidWYsIE5VTEwsIE5VTEwpOworfQorCitzdGF0aWMgaW50IGRvY19yZWFkX2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCQlzaXplX3QgKiByZXRsZW4sIHVfY2hhciAqIGJ1ZiwgdV9jaGFyICogZWNjYnVmLCBzdHJ1Y3QgbmFuZF9vb2JpbmZvICpvb2JzZWwpCit7CisJc3RydWN0IERpc2tPbkNoaXAgKnRoaXMgPSBtdGQtPnByaXY7CisJdm9pZCBfX2lvbWVtICpkb2NwdHIgPSB0aGlzLT52aXJ0YWRyOworCXN0cnVjdCBOYW5kICpteWNoaXA7CisJdW5zaWduZWQgY2hhciBzeW5kcm9tZVs2XTsKKwl2b2xhdGlsZSBjaGFyIGR1bW15OworCWludCBpLCBsZW4yNTYgPSAwLCByZXQ9MDsKKwlzaXplX3QgbGVmdCA9IGxlbjsKKworCS8qIERvbid0IGFsbG93IHJlYWQgcGFzdCBlbmQgb2YgZGV2aWNlICovCisJaWYgKGZyb20gPj0gdGhpcy0+dG90bGVuKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWRvd24oJnRoaXMtPmxvY2spOworCisJKnJldGxlbiA9IDA7CisJd2hpbGUgKGxlZnQpIHsKKwkJbGVuID0gbGVmdDsKKworCQkvKiBEb24ndCBhbGxvdyBhIHNpbmdsZSByZWFkIHRvIGNyb3NzIGEgNTEyLWJ5dGUgYmxvY2sgYm91bmRhcnkgKi8KKwkJaWYgKGZyb20gKyBsZW4gPiAoKGZyb20gfCAweDFmZikgKyAxKSkKKwkJCWxlbiA9ICgoZnJvbSB8IDB4MWZmKSArIDEpIC0gZnJvbTsKKworCQkvKiBUaGUgRUNDIHdpbGwgbm90IGJlIGNhbGN1bGF0ZWQgY29ycmVjdGx5IGlmIGxlc3MgdGhhbiA1MTIgaXMgcmVhZCAqLworCQlpZiAobGVuICE9IDB4MjAwICYmIGVjY2J1ZikKKwkJCXByaW50ayhLRVJOX1dBUk5JTkcKKwkJCSAgICAgICAiRUNDIG5lZWRzIGEgZnVsbCBzZWN0b3IgcmVhZCAoYWRyOiAlbHggc2l6ZSAlbHgpXG4iLAorCQkJICAgICAgIChsb25nKSBmcm9tLCAobG9uZykgbGVuKTsKKworCQkvKiBwcmludGsoIkRvQ19SZWFkIChhZHI6ICVseCBzaXplICVseClcbiIsIChsb25nKSBmcm9tLCAobG9uZykgbGVuKTsgKi8KKworCisJCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJCW15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tmcm9tID4+ICh0aGlzLT5jaGlwc2hpZnQpXTsKKworCQlpZiAodGhpcy0+Y3VyZmxvb3IgIT0gbXljaGlwLT5mbG9vcikgeworCQkJRG9DX1NlbGVjdEZsb29yKHRoaXMsIG15Y2hpcC0+Zmxvb3IpOworCQkJRG9DX1NlbGVjdENoaXAodGhpcywgbXljaGlwLT5jaGlwKTsKKwkJfSBlbHNlIGlmICh0aGlzLT5jdXJjaGlwICE9IG15Y2hpcC0+Y2hpcCkgeworCQkJRG9DX1NlbGVjdENoaXAodGhpcywgbXljaGlwLT5jaGlwKTsKKwkJfQorCisJCXRoaXMtPmN1cmZsb29yID0gbXljaGlwLT5mbG9vcjsKKwkJdGhpcy0+Y3VyY2hpcCA9IG15Y2hpcC0+Y2hpcDsKKworCQlEb0NfQ29tbWFuZCh0aGlzLAorCQkJICAgICghdGhpcy0+cGFnZTI1NgorCQkJICAgICAmJiAoZnJvbSAmIDB4MTAwKSkgPyBOQU5EX0NNRF9SRUFEMSA6IE5BTkRfQ01EX1JFQUQwLAorCQkJICAgIENEU05fQ1RSTF9XUCk7CisJCURvQ19BZGRyZXNzKHRoaXMsIEFERFJfQ09MVU1OX1BBR0UsIGZyb20sIENEU05fQ1RSTF9XUCwKKwkJCSAgICBDRFNOX0NUUkxfRUNDX0lPKTsKKworCQlpZiAoZWNjYnVmKSB7CisJCQkvKiBQcmltZSB0aGUgRUNDIGVuZ2luZSAqLworCQkJV3JpdGVET0MoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBFQ0NDb25mKTsKKwkJCVdyaXRlRE9DKERPQ19FQ0NfRU4sIGRvY3B0ciwgRUNDQ29uZik7CisJCX0gZWxzZSB7CisJCQkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJCQlXcml0ZURPQyhET0NfRUNDX1JFU0VULCBkb2NwdHIsIEVDQ0NvbmYpOworCQkJV3JpdGVET0MoRE9DX0VDQ19ESVMsIGRvY3B0ciwgRUNDQ29uZik7CisJCX0KKworCQkvKiB0cmVhdCBjcm9zc2luZyAyNTYtYnl0ZSBzZWN0b3IgZm9yIDJNIHggOGJpdHMgZGV2aWNlcyAqLworCQlpZiAodGhpcy0+cGFnZTI1NiAmJiBmcm9tICsgbGVuID4gKGZyb20gfCAweGZmKSArIDEpIHsKKwkJCWxlbjI1NiA9IChmcm9tIHwgMHhmZikgKyAxIC0gZnJvbTsKKwkJCURvQ19SZWFkQnVmKHRoaXMsIGJ1ZiwgbGVuMjU2KTsKKworCQkJRG9DX0NvbW1hbmQodGhpcywgTkFORF9DTURfUkVBRDAsIENEU05fQ1RSTF9XUCk7CisJCQlEb0NfQWRkcmVzcyh0aGlzLCBBRERSX0NPTFVNTl9QQUdFLCBmcm9tICsgbGVuMjU2LAorCQkJCSAgICBDRFNOX0NUUkxfV1AsIENEU05fQ1RSTF9FQ0NfSU8pOworCQl9CisKKwkJRG9DX1JlYWRCdWYodGhpcywgJmJ1ZltsZW4yNTZdLCBsZW4gLSBsZW4yNTYpOworCisJCS8qIExldCB0aGUgY2FsbGVyIGtub3cgd2UgY29tcGxldGVkIGl0ICovCisJCSpyZXRsZW4gKz0gbGVuOworCisJCWlmIChlY2NidWYpIHsKKwkJCS8qIFJlYWQgdGhlIEVDQyBkYXRhIHRocm91Z2ggdGhlIERpc2tPbkNoaXAgRUNDIGxvZ2ljICovCisJCQkvKiBOb3RlOiB0aGlzIHdpbGwgd29yayBldmVuIHdpdGggMk0geCA4Yml0IGRldmljZXMgYXMgICAqLworCQkJLyogICAgICAgdGhleSBoYXZlIDggYnl0ZXMgb2YgT09CIHBlciAyNTYgcGFnZS4gbWYuICAgICAgKi8KKwkJCURvQ19SZWFkQnVmKHRoaXMsIGVjY2J1ZiwgNik7CisKKwkJCS8qIEZsdXNoIHRoZSBwaXBlbGluZSAqLworCQkJaWYgKERvQ19pc19NaWxsZW5uaXVtKHRoaXMpKSB7CisJCQkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgRUNDQ29uZik7CisJCQkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgRUNDQ29uZik7CisJCQkJaSA9IFJlYWRET0MoZG9jcHRyLCBFQ0NDb25mKTsKKwkJCX0gZWxzZSB7CisJCQkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgMmtfRUNDU3RhdHVzKTsKKwkJCQlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCAya19FQ0NTdGF0dXMpOworCQkJCWkgPSBSZWFkRE9DKGRvY3B0ciwgMmtfRUNDU3RhdHVzKTsKKwkJCX0KKworCQkJLyogQ2hlY2sgdGhlIEVDQyBTdGF0dXMgKi8KKwkJCWlmIChpICYgMHg4MCkgeworCQkJCWludCBuYl9lcnJvcnM7CisJCQkJLyogVGhlcmUgd2FzIGFuIEVDQyBlcnJvciAqLworI2lmZGVmIEVDQ19ERUJVRworCQkJCXByaW50ayhLRVJOX0VSUiAiRGlza09uQ2hpcCBFQ0MgRXJyb3I6IFJlYWQgYXQgJWx4XG4iLCAobG9uZylmcm9tKTsKKyNlbmRpZgorCQkJCS8qIFJlYWQgdGhlIEVDQyBzeW5kcm9tIHRocm91Z2ggdGhlIERpc2tPbkNoaXAgRUNDIGxvZ2ljLgorCQkJCSAgIFRoZXNlIHN5bmRyb21lIHdpbGwgYmUgYWxsIFpFUk8gd2hlbiB0aGVyZSBpcyBubyBlcnJvciAqLworCQkJCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspIHsKKwkJCQkJc3luZHJvbWVbaV0gPQorCQkJCQkgICAgUmVhZERPQyhkb2NwdHIsIEVDQ1N5bmRyb21lMCArIGkpOworCQkJCX0KKwkgICAgICAgICAgICAgICAgICAgICAgICBuYl9lcnJvcnMgPSBkb2NfZGVjb2RlX2VjYyhidWYsIHN5bmRyb21lKTsKKworI2lmZGVmIEVDQ19ERUJVRworCQkJCXByaW50ayhLRVJOX0VSUiAiRXJyb3JzIGNvcnJlY3RlZDogJXhcbiIsIG5iX2Vycm9ycyk7CisjZW5kaWYKKwkgICAgICAgICAgICAgICAgICAgICAgICBpZiAobmJfZXJyb3JzIDwgMCkgeworCQkJCQkvKiBXZSByZXR1cm4gZXJyb3IsIGJ1dCBoYXZlIGFjdHVhbGx5IGRvbmUgdGhlIHJlYWQuIE5vdCB0aGF0CisJCQkJCSAgIHRoaXMgY2FuIGJlIHRvbGQgdG8gdXNlci1zcGFjZSwgdmlhIHN5c19yZWFkKCksIGJ1dCBhdCBsZWFzdAorCQkJCQkgICBNVEQtYXdhcmUgc3R1ZmYgY2FuIGtub3cgYWJvdXQgaXQgYnkgY2hlY2tpbmcgKnJldGxlbiAqLworCQkJCQlyZXQgPSAtRUlPOworCSAgICAgICAgICAgICAgICAgICAgICAgIH0KKwkJCX0KKworI2lmZGVmIFBTWUNIT19ERUJVRworCQkJcHJpbnRrKEtFUk5fREVCVUcgIkVDQyBEQVRBIGF0ICVseEI6ICUyLjJYICUyLjJYICUyLjJYICUyLjJYICUyLjJYICUyLjJYXG4iLAorCQkJCSAgICAgKGxvbmcpZnJvbSwgZWNjYnVmWzBdLCBlY2NidWZbMV0sIGVjY2J1ZlsyXSwKKwkJCQkgICAgIGVjY2J1ZlszXSwgZWNjYnVmWzRdLCBlY2NidWZbNV0pOworI2VuZGlmCisJCQorCQkJLyogZGlzYWJsZSB0aGUgRUNDIGVuZ2luZSAqLworCQkJV3JpdGVET0MoRE9DX0VDQ19ESVMsIGRvY3B0ciAsIEVDQ0NvbmYpOworCQl9CisKKwkJLyogYWNjb3JkaW5nIHRvIDExLjQuMSwgd2UgbmVlZCB0byB3YWl0IGZvciB0aGUgYnVzeSBsaW5lIAorCSAgICAgICAgICogZHJvcCBpZiB3ZSByZWFkIHRvIHRoZSBlbmQgb2YgdGhlIHBhZ2UuICAqLworCQlpZigwID09ICgoZnJvbSArIGxlbikgJiAweDFmZikpCisJCXsKKwkJICAgIERvQ19XYWl0UmVhZHkodGhpcyk7CisJCX0KKworCQlmcm9tICs9IGxlbjsKKwkJbGVmdCAtPSBsZW47CisJCWJ1ZiArPSBsZW47CisJfQorCisJdXAoJnRoaXMtPmxvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBkb2Nfd3JpdGUoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJICAgICBzaXplX3QgKiByZXRsZW4sIGNvbnN0IHVfY2hhciAqIGJ1ZikKK3sKKwljaGFyIGVjY2J1Zls2XTsKKwlyZXR1cm4gZG9jX3dyaXRlX2VjYyhtdGQsIHRvLCBsZW4sIHJldGxlbiwgYnVmLCBlY2NidWYsIE5VTEwpOworfQorCitzdGF0aWMgaW50IGRvY193cml0ZV9lY2Moc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJCSBzaXplX3QgKiByZXRsZW4sIGNvbnN0IHVfY2hhciAqIGJ1ZiwKKwkJCSB1X2NoYXIgKiBlY2NidWYsIHN0cnVjdCBuYW5kX29vYmluZm8gKm9vYnNlbCkKK3sKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwlpbnQgZGk7IC8qIFllcywgREkgaXMgYSBoYW5nb3ZlciBmcm9tIHdoZW4gSSB3YXMgZGlzYXNzZW1ibGluZyB0aGUgYmluYXJ5IGRyaXZlciAqLworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gdGhpcy0+dmlydGFkcjsKKwl2b2xhdGlsZSBjaGFyIGR1bW15OworCWludCBsZW4yNTYgPSAwOworCXN0cnVjdCBOYW5kICpteWNoaXA7CisJc2l6ZV90IGxlZnQgPSBsZW47CisJaW50IHN0YXR1czsKKworCS8qIERvbid0IGFsbG93IHdyaXRlIHBhc3QgZW5kIG9mIGRldmljZSAqLworCWlmICh0byA+PSB0aGlzLT50b3RsZW4pCisJCXJldHVybiAtRUlOVkFMOworCisJZG93bigmdGhpcy0+bG9jayk7CisKKwkqcmV0bGVuID0gMDsKKwl3aGlsZSAobGVmdCkgeworCQlsZW4gPSBsZWZ0OworCisJCS8qIERvbid0IGFsbG93IGEgc2luZ2xlIHdyaXRlIHRvIGNyb3NzIGEgNTEyLWJ5dGUgYmxvY2sgYm91bmRhcnkgKi8KKwkJaWYgKHRvICsgbGVuID4gKCh0byB8IDB4MWZmKSArIDEpKQorCQkJbGVuID0gKCh0byB8IDB4MWZmKSArIDEpIC0gdG87CisKKwkJLyogVGhlIEVDQyB3aWxsIG5vdCBiZSBjYWxjdWxhdGVkIGNvcnJlY3RseSBpZiBsZXNzIHRoYW4gNTEyIGlzIHdyaXR0ZW4gKi8KKy8qIERCQi0KKwkJaWYgKGxlbiAhPSAweDIwMCAmJiBlY2NidWYpCisJCQlwcmludGsoS0VSTl9XQVJOSU5HCisJCQkgICAgICAgIkVDQyBuZWVkcyBhIGZ1bGwgc2VjdG9yIHdyaXRlIChhZHI6ICVseCBzaXplICVseClcbiIsCisJCQkgICAgICAgKGxvbmcpIHRvLCAobG9uZykgbGVuKTsKKyAgIC1EQkIgKi8KKworCQkvKiBwcmludGsoIkRvQ19Xcml0ZSAoYWRyOiAlbHggc2l6ZSAlbHgpXG4iLCAobG9uZykgdG8sIChsb25nKSBsZW4pOyAqLworCisJCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJCW15Y2hpcCA9ICZ0aGlzLT5jaGlwc1t0byA+PiAodGhpcy0+Y2hpcHNoaWZ0KV07CisKKwkJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJCURvQ19TZWxlY3RGbG9vcih0aGlzLCBteWNoaXAtPmZsb29yKTsKKwkJCURvQ19TZWxlY3RDaGlwKHRoaXMsIG15Y2hpcC0+Y2hpcCk7CisJCX0gZWxzZSBpZiAodGhpcy0+Y3VyY2hpcCAhPSBteWNoaXAtPmNoaXApIHsKKwkJCURvQ19TZWxlY3RDaGlwKHRoaXMsIG15Y2hpcC0+Y2hpcCk7CisJCX0KKworCQl0aGlzLT5jdXJmbG9vciA9IG15Y2hpcC0+Zmxvb3I7CisJCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkJLyogU2V0IGRldmljZSB0byBtYWluIHBsYW5lIG9mIGZsYXNoICovCisJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1JFU0VULCBDRFNOX0NUUkxfV1ApOworCQlEb0NfQ29tbWFuZCh0aGlzLAorCQkJICAgICghdGhpcy0+cGFnZTI1NgorCQkJICAgICAmJiAodG8gJiAweDEwMCkpID8gTkFORF9DTURfUkVBRDEgOiBOQU5EX0NNRF9SRUFEMCwKKwkJCSAgICBDRFNOX0NUUkxfV1ApOworCisJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1NFUUlOLCAwKTsKKwkJRG9DX0FkZHJlc3ModGhpcywgQUREUl9DT0xVTU5fUEFHRSwgdG8sIDAsIENEU05fQ1RSTF9FQ0NfSU8pOworCisJCWlmIChlY2NidWYpIHsKKwkJCS8qIFByaW1lIHRoZSBFQ0MgZW5naW5lICovCisJCQlXcml0ZURPQyhET0NfRUNDX1JFU0VULCBkb2NwdHIsIEVDQ0NvbmYpOworCQkJV3JpdGVET0MoRE9DX0VDQ19FTiB8IERPQ19FQ0NfUlcsIGRvY3B0ciwgRUNDQ29uZik7CisJCX0gZWxzZSB7CisJCQkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJCQlXcml0ZURPQyhET0NfRUNDX1JFU0VULCBkb2NwdHIsIEVDQ0NvbmYpOworCQkJV3JpdGVET0MoRE9DX0VDQ19ESVMsIGRvY3B0ciwgRUNDQ29uZik7CisJCX0KKworCQkvKiB0cmVhdCBjcm9zc2luZyAyNTYtYnl0ZSBzZWN0b3IgZm9yIDJNIHggOGJpdHMgZGV2aWNlcyAqLworCQlpZiAodGhpcy0+cGFnZTI1NiAmJiB0byArIGxlbiA+ICh0byB8IDB4ZmYpICsgMSkgeworCQkJbGVuMjU2ID0gKHRvIHwgMHhmZikgKyAxIC0gdG87CisJCQlEb0NfV3JpdGVCdWYodGhpcywgYnVmLCBsZW4yNTYpOworCisJCQlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9QQUdFUFJPRywgMCk7CisKKwkJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1NUQVRVUywgQ0RTTl9DVFJMX1dQKTsKKwkJCS8qIFRoZXJlJ3MgYW4gaW1wbGljaXQgRG9DX1dhaXRSZWFkeSgpIGluIERvQ19Db21tYW5kICovCisKKwkJCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIENEU05TbG93SU8pOworCQkJRG9DX0RlbGF5KHRoaXMsIDIpOworCisJCQlpZiAoUmVhZERPQ18oZG9jcHRyLCB0aGlzLT5pb3JlZykgJiAxKSB7CisJCQkJcHJpbnRrKEtFUk5fRVJSICJFcnJvciBwcm9ncmFtbWluZyBmbGFzaFxuIik7CisJCQkJLyogRXJyb3IgaW4gcHJvZ3JhbW1pbmcgKi8KKwkJCQkqcmV0bGVuID0gMDsKKwkJCQl1cCgmdGhpcy0+bG9jayk7CisJCQkJcmV0dXJuIC1FSU87CisJCQl9CisKKwkJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1NFUUlOLCAwKTsKKwkJCURvQ19BZGRyZXNzKHRoaXMsIEFERFJfQ09MVU1OX1BBR0UsIHRvICsgbGVuMjU2LCAwLAorCQkJCSAgICBDRFNOX0NUUkxfRUNDX0lPKTsKKwkJfQorCisJCURvQ19Xcml0ZUJ1Zih0aGlzLCAmYnVmW2xlbjI1Nl0sIGxlbiAtIGxlbjI1Nik7CisKKwkJaWYgKGVjY2J1ZikgeworCQkJV3JpdGVET0MoQ0RTTl9DVFJMX0VDQ19JTyB8IENEU05fQ1RSTF9DRSwgZG9jcHRyLAorCQkJCSBDRFNOQ29udHJvbCk7CisKKwkJCWlmIChEb0NfaXNfTWlsbGVubml1bSh0aGlzKSkgeworCQkJCVdyaXRlRE9DKDAsIGRvY3B0ciwgTk9QKTsKKwkJCQlXcml0ZURPQygwLCBkb2NwdHIsIE5PUCk7CisJCQkJV3JpdGVET0MoMCwgZG9jcHRyLCBOT1ApOworCQkJfSBlbHNlIHsKKwkJCQlXcml0ZURPQ18oMCwgZG9jcHRyLCB0aGlzLT5pb3JlZyk7CisJCQkJV3JpdGVET0NfKDAsIGRvY3B0ciwgdGhpcy0+aW9yZWcpOworCQkJCVdyaXRlRE9DXygwLCBkb2NwdHIsIHRoaXMtPmlvcmVnKTsKKwkJCX0KKworCQkJV3JpdGVET0MoQ0RTTl9DVFJMX0VDQ19JTyB8IENEU05fQ1RSTF9GTEFTSF9JTyB8IENEU05fQ1RSTF9DRSwgZG9jcHRyLAorCQkJCSBDRFNOQ29udHJvbCk7CisKKwkJCS8qIFJlYWQgdGhlIEVDQyBkYXRhIHRocm91Z2ggdGhlIERpc2tPbkNoaXAgRUNDIGxvZ2ljICovCisJCQlmb3IgKGRpID0gMDsgZGkgPCA2OyBkaSsrKSB7CisJCQkJZWNjYnVmW2RpXSA9IFJlYWRET0MoZG9jcHRyLCBFQ0NTeW5kcm9tZTAgKyBkaSk7CisJCQl9CisKKwkJCS8qIFJlc2V0IHRoZSBFQ0MgZW5naW5lICovCisJCQlXcml0ZURPQyhET0NfRUNDX0RJUywgZG9jcHRyLCBFQ0NDb25mKTsKKworI2lmZGVmIFBTWUNIT19ERUJVRworCQkJcHJpbnRrCisJCQkgICAgKCJPT0IgZGF0YSBhdCAlbHggaXMgJTIuMlggJTIuMlggJTIuMlggJTIuMlggJTIuMlggJTIuMlhcbiIsCisJCQkgICAgIChsb25nKSB0bywgZWNjYnVmWzBdLCBlY2NidWZbMV0sIGVjY2J1ZlsyXSwgZWNjYnVmWzNdLAorCQkJICAgICBlY2NidWZbNF0sIGVjY2J1Zls1XSk7CisjZW5kaWYKKwkJfQorCisJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1BBR0VQUk9HLCAwKTsKKworCQlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9TVEFUVVMsIENEU05fQ1RSTF9XUCk7CisJCS8qIFRoZXJlJ3MgYW4gaW1wbGljaXQgRG9DX1dhaXRSZWFkeSgpIGluIERvQ19Db21tYW5kICovCisKKwkJaWYgKERvQ19pc19NaWxsZW5uaXVtKHRoaXMpKSB7CisJCQlSZWFkRE9DKGRvY3B0ciwgUmVhZFBpcGVJbml0KTsKKwkJCXN0YXR1cyA9IFJlYWRET0MoZG9jcHRyLCBMYXN0RGF0YVJlYWQpOworCQl9IGVsc2UgeworCQkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgQ0RTTlNsb3dJTyk7CisJCQlEb0NfRGVsYXkodGhpcywgMik7CisJCQlzdGF0dXMgPSBSZWFkRE9DXyhkb2NwdHIsIHRoaXMtPmlvcmVnKTsKKwkJfQorCisJCWlmIChzdGF0dXMgJiAxKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIkVycm9yIHByb2dyYW1taW5nIGZsYXNoXG4iKTsKKwkJCS8qIEVycm9yIGluIHByb2dyYW1taW5nICovCisJCQkqcmV0bGVuID0gMDsKKwkJCXVwKCZ0aGlzLT5sb2NrKTsKKwkJCXJldHVybiAtRUlPOworCQl9CisKKwkJLyogTGV0IHRoZSBjYWxsZXIga25vdyB3ZSBjb21wbGV0ZWQgaXQgKi8KKwkJKnJldGxlbiArPSBsZW47CisJCQorCQlpZiAoZWNjYnVmKSB7CisJCQl1bnNpZ25lZCBjaGFyIHhbOF07CisJCQlzaXplX3QgZHVtbXk7CisJCQlpbnQgcmV0OworCisJCQkvKiBXcml0ZSB0aGUgRUNDIGRhdGEgdG8gZmxhc2ggKi8KKwkJCWZvciAoZGk9MDsgZGk8NjsgZGkrKykKKwkJCQl4W2RpXSA9IGVjY2J1ZltkaV07CisJCQorCQkJeFs2XT0weDU1OworCQkJeFs3XT0weDU1OworCQkKKwkJCXJldCA9IGRvY193cml0ZV9vb2Jfbm9sb2NrKG10ZCwgdG8sIDgsICZkdW1teSwgeCk7CisJCQlpZiAocmV0KSB7CisJCQkJdXAoJnRoaXMtPmxvY2spOworCQkJCXJldHVybiByZXQ7CisJCQl9CisJCX0KKworCQl0byArPSBsZW47CisJCWxlZnQgLT0gbGVuOworCQlidWYgKz0gbGVuOworCX0KKworCXVwKCZ0aGlzLT5sb2NrKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBkb2Nfd3JpdGV2X2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgY29uc3Qgc3RydWN0IGt2ZWMgKnZlY3MsIAorCQkJICB1bnNpZ25lZCBsb25nIGNvdW50LCBsb2ZmX3QgdG8sIHNpemVfdCAqcmV0bGVuLAorCQkJICB1X2NoYXIgKmVjY2J1Ziwgc3RydWN0IG5hbmRfb29iaW5mbyAqb29ic2VsKQoreworCXN0YXRpYyBjaGFyIHN0YXRpY19idWZbNTEyXTsKKwlzdGF0aWMgREVDTEFSRV9NVVRFWCh3cml0ZXZfYnVmX3NlbSk7CisKKwlzaXplX3QgdG90cmV0bGVuID0gMDsKKwlzaXplX3QgdGhpc3ZlY29mcyA9IDA7CisJaW50IHJldD0gMDsKKworCWRvd24oJndyaXRldl9idWZfc2VtKTsKKworCXdoaWxlKGNvdW50KSB7CisJCXNpemVfdCB0aGlzbGVuLCB0aGlzcmV0bGVuOworCQl1bnNpZ25lZCBjaGFyICpidWY7CisKKwkJYnVmID0gdmVjcy0+aW92X2Jhc2UgKyB0aGlzdmVjb2ZzOworCQl0aGlzbGVuID0gdmVjcy0+aW92X2xlbiAtIHRoaXN2ZWNvZnM7CisKKworCQlpZiAodGhpc2xlbiA+PSA1MTIpIHsKKwkJCXRoaXNsZW4gPSB0aGlzbGVuICYgfig1MTItMSk7CisJCQl0aGlzdmVjb2ZzICs9IHRoaXNsZW47CisJCX0gZWxzZSB7CisJCQkvKiBOb3QgZW5vdWdoIHRvIGZpbGwgYSBwYWdlLiBDb3B5IGludG8gYnVmICovCisJCQltZW1jcHkoc3RhdGljX2J1ZiwgYnVmLCB0aGlzbGVuKTsKKwkJCWJ1ZiA9ICZzdGF0aWNfYnVmW3RoaXNsZW5dOworCisJCQl3aGlsZShjb3VudCAmJiB0aGlzbGVuIDwgNTEyKSB7CisJCQkJdmVjcysrOworCQkJCWNvdW50LS07CisJCQkJdGhpc3ZlY29mcyA9IG1pbigoNTEyLXRoaXNsZW4pLCB2ZWNzLT5pb3ZfbGVuKTsKKwkJCQltZW1jcHkoYnVmLCB2ZWNzLT5pb3ZfYmFzZSwgdGhpc3ZlY29mcyk7CisJCQkJdGhpc2xlbiArPSB0aGlzdmVjb2ZzOworCQkJCWJ1ZiArPSB0aGlzdmVjb2ZzOworCQkJfQorCQkJYnVmID0gc3RhdGljX2J1ZjsKKwkJfQorCQlpZiAoY291bnQgJiYgdGhpc3ZlY29mcyA9PSB2ZWNzLT5pb3ZfbGVuKSB7CisJCQl0aGlzdmVjb2ZzID0gMDsKKwkJCXZlY3MrKzsKKwkJCWNvdW50LS07CisJCX0KKwkJcmV0ID0gZG9jX3dyaXRlX2VjYyhtdGQsIHRvLCB0aGlzbGVuLCAmdGhpc3JldGxlbiwgYnVmLCBlY2NidWYsIG9vYnNlbCk7CisKKwkJdG90cmV0bGVuICs9IHRoaXNyZXRsZW47CisKKwkJaWYgKHJldCB8fCB0aGlzcmV0bGVuICE9IHRoaXNsZW4pCisJCQlicmVhazsKKworCQl0byArPSB0aGlzbGVuOworCX0JCQorCisJdXAoJndyaXRldl9idWZfc2VtKTsKKwkqcmV0bGVuID0gdG90cmV0bGVuOworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBkb2NfcmVhZF9vb2Ioc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBvZnMsIHNpemVfdCBsZW4sCisJCQlzaXplX3QgKiByZXRsZW4sIHVfY2hhciAqIGJ1ZikKK3sKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwlpbnQgbGVuMjU2ID0gMCwgcmV0OworCXN0cnVjdCBOYW5kICpteWNoaXA7CisKKwlkb3duKCZ0aGlzLT5sb2NrKTsKKworCW15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tvZnMgPj4gdGhpcy0+Y2hpcHNoaWZ0XTsKKworCWlmICh0aGlzLT5jdXJmbG9vciAhPSBteWNoaXAtPmZsb29yKSB7CisJCURvQ19TZWxlY3RGbG9vcih0aGlzLCBteWNoaXAtPmZsb29yKTsKKwkJRG9DX1NlbGVjdENoaXAodGhpcywgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKHRoaXMsIG15Y2hpcC0+Y2hpcCk7CisJfQorCXRoaXMtPmN1cmZsb29yID0gbXljaGlwLT5mbG9vcjsKKwl0aGlzLT5jdXJjaGlwID0gbXljaGlwLT5jaGlwOworCisJLyogdXBkYXRlIGFkZHJlc3MgZm9yIDJNIHggOGJpdCBkZXZpY2VzLiBPT0Igc3RhcnRzIG9uIHRoZSBzZWNvbmQgKi8KKwkvKiBwYWdlIHRvIG1haW50YWluIGNvbXBhdGliaWxpdHkgd2l0aCBkb2NfcmVhZF9lY2MuICovCisJaWYgKHRoaXMtPnBhZ2UyNTYpIHsKKwkJaWYgKCEob2ZzICYgMHg4KSkKKwkJCW9mcyArPSAweDEwMDsKKwkJZWxzZQorCQkJb2ZzIC09IDB4ODsKKwl9CisKKwlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9SRUFET09CLCBDRFNOX0NUUkxfV1ApOworCURvQ19BZGRyZXNzKHRoaXMsIEFERFJfQ09MVU1OX1BBR0UsIG9mcywgQ0RTTl9DVFJMX1dQLCAwKTsKKworCS8qIHRyZWF0IGNyb3NzaW5nIDgtYnl0ZSBPT0IgZGF0YSBmb3IgMk0geCA4Yml0IGRldmljZXMgKi8KKwkvKiBOb3RlOiBkYXRhc2hlZXQgc2F5cyBpdCBzaG91bGQgYXV0b21hdGljYWx5IHdyYXAgdG8gdGhlICovCisJLyogICAgICAgbmV4dCBPT0IgYmxvY2ssIGJ1dCBpdCBkaWRuJ3Qgd29yayBoZXJlLiBtZi4gICAgICAqLworCWlmICh0aGlzLT5wYWdlMjU2ICYmIG9mcyArIGxlbiA+IChvZnMgfCAweDcpICsgMSkgeworCQlsZW4yNTYgPSAob2ZzIHwgMHg3KSArIDEgLSBvZnM7CisJCURvQ19SZWFkQnVmKHRoaXMsIGJ1ZiwgbGVuMjU2KTsKKworCQlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9SRUFET09CLCBDRFNOX0NUUkxfV1ApOworCQlEb0NfQWRkcmVzcyh0aGlzLCBBRERSX0NPTFVNTl9QQUdFLCBvZnMgJiAofjB4MWZmKSwKKwkJCSAgICBDRFNOX0NUUkxfV1AsIDApOworCX0KKworCURvQ19SZWFkQnVmKHRoaXMsICZidWZbbGVuMjU2XSwgbGVuIC0gbGVuMjU2KTsKKworCSpyZXRsZW4gPSBsZW47CisJLyogUmVhZGluZyB0aGUgZnVsbCBPT0IgZGF0YSBkcm9wcyB1cyBvZmYgb2YgdGhlIGVuZCBvZiB0aGUgcGFnZSwKKyAgICAgICAgICogY2F1c2luZyB0aGUgZmxhc2ggZGV2aWNlIHRvIGdvIGludG8gYnVzeSBtb2RlLCBzbyB3ZSBuZWVkCisgICAgICAgICAqIHRvIHdhaXQgdW50aWwgcmVhZHkgMTEuNC4xIGFuZCBUb3NoaWJhIFRDNTgyNTZGVCBkb2NzICovCisJCisJcmV0ID0gRG9DX1dhaXRSZWFkeSh0aGlzKTsKKworCXVwKCZ0aGlzLT5sb2NrKTsKKwlyZXR1cm4gcmV0OworCit9CisKK3N0YXRpYyBpbnQgZG9jX3dyaXRlX29vYl9ub2xvY2soc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBvZnMsIHNpemVfdCBsZW4sCisJCQkJc2l6ZV90ICogcmV0bGVuLCBjb25zdCB1X2NoYXIgKiBidWYpCit7CisJc3RydWN0IERpc2tPbkNoaXAgKnRoaXMgPSBtdGQtPnByaXY7CisJaW50IGxlbjI1NiA9IDA7CisJdm9pZCBfX2lvbWVtICpkb2NwdHIgPSB0aGlzLT52aXJ0YWRyOworCXN0cnVjdCBOYW5kICpteWNoaXAgPSAmdGhpcy0+Y2hpcHNbb2ZzID4+IHRoaXMtPmNoaXBzaGlmdF07CisJdm9sYXRpbGUgaW50IGR1bW15OworCWludCBzdGF0dXM7CisKKwkvLyAgICAgIHByaW50aygiZG9jX3dyaXRlX29vYiglbHgsICVkKTogJTIuMlggJTIuMlggJTIuMlggJTIuMlggLi4uICUyLjJYICUyLjJYIC4uICUyLjJYICUyLjJYXG4iLChsb25nKW9mcywgbGVuLAorCS8vICAgYnVmWzBdLCBidWZbMV0sIGJ1ZlsyXSwgYnVmWzNdLCBidWZbOF0sIGJ1Zls5XSwgYnVmWzE0XSxidWZbMTVdKTsKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKHRoaXMsIG15Y2hpcC0+Zmxvb3IpOworCQlEb0NfU2VsZWN0Q2hpcCh0aGlzLCBteWNoaXAtPmNoaXApOworCX0gZWxzZSBpZiAodGhpcy0+Y3VyY2hpcCAhPSBteWNoaXAtPmNoaXApIHsKKwkJRG9DX1NlbGVjdENoaXAodGhpcywgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJV3JpdGVET0MgKERPQ19FQ0NfUkVTRVQsIGRvY3B0ciwgRUNDQ29uZik7CisJV3JpdGVET0MgKERPQ19FQ0NfRElTLCBkb2NwdHIsIEVDQ0NvbmYpOworCisJLyogUmVzZXQgdGhlIGNoaXAsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4gKi8KKwlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9SRVNFVCwgQ0RTTl9DVFJMX1dQKTsKKworCS8qIGlzc3VlIHRoZSBSZWFkMiBjb21tYW5kIHRvIHNldCB0aGUgcG9pbnRlciB0byB0aGUgU3BhcmUgRGF0YSBBcmVhLiAqLworCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1JFQURPT0IsIENEU05fQ1RSTF9XUCk7CisKKwkvKiB1cGRhdGUgYWRkcmVzcyBmb3IgMk0geCA4Yml0IGRldmljZXMuIE9PQiBzdGFydHMgb24gdGhlIHNlY29uZCAqLworCS8qIHBhZ2UgdG8gbWFpbnRhaW4gY29tcGF0aWJpbGl0eSB3aXRoIGRvY19yZWFkX2VjYy4gKi8KKwlpZiAodGhpcy0+cGFnZTI1NikgeworCQlpZiAoIShvZnMgJiAweDgpKQorCQkJb2ZzICs9IDB4MTAwOworCQllbHNlCisJCQlvZnMgLT0gMHg4OworCX0KKworCS8qIGlzc3VlIHRoZSBTZXJpYWwgRGF0YSBJbiBjb21tYW5kIHRvIGluaXRpYWwgdGhlIFBhZ2UgUHJvZ3JhbSBwcm9jZXNzICovCisJRG9DX0NvbW1hbmQodGhpcywgTkFORF9DTURfU0VRSU4sIDApOworCURvQ19BZGRyZXNzKHRoaXMsIEFERFJfQ09MVU1OX1BBR0UsIG9mcywgMCwgMCk7CisKKwkvKiB0cmVhdCBjcm9zc2luZyA4LWJ5dGUgT09CIGRhdGEgZm9yIDJNIHggOGJpdCBkZXZpY2VzICovCisJLyogTm90ZTogZGF0YXNoZWV0IHNheXMgaXQgc2hvdWxkIGF1dG9tYXRpY2FseSB3cmFwIHRvIHRoZSAqLworCS8qICAgICAgIG5leHQgT09CIGJsb2NrLCBidXQgaXQgZGlkbid0IHdvcmsgaGVyZS4gbWYuICAgICAgKi8KKwlpZiAodGhpcy0+cGFnZTI1NiAmJiBvZnMgKyBsZW4gPiAob2ZzIHwgMHg3KSArIDEpIHsKKwkJbGVuMjU2ID0gKG9mcyB8IDB4NykgKyAxIC0gb2ZzOworCQlEb0NfV3JpdGVCdWYodGhpcywgYnVmLCBsZW4yNTYpOworCisJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1BBR0VQUk9HLCAwKTsKKwkJRG9DX0NvbW1hbmQodGhpcywgTkFORF9DTURfU1RBVFVTLCAwKTsKKwkJLyogRG9DX1dhaXRSZWFkeSgpIGlzIGltcGxpY2l0IGluIERvQ19Db21tYW5kICovCisKKwkJaWYgKERvQ19pc19NaWxsZW5uaXVtKHRoaXMpKSB7CisJCQlSZWFkRE9DKGRvY3B0ciwgUmVhZFBpcGVJbml0KTsKKwkJCXN0YXR1cyA9IFJlYWRET0MoZG9jcHRyLCBMYXN0RGF0YVJlYWQpOworCQl9IGVsc2UgeworCQkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgQ0RTTlNsb3dJTyk7CisJCQlEb0NfRGVsYXkodGhpcywgMik7CisJCQlzdGF0dXMgPSBSZWFkRE9DXyhkb2NwdHIsIHRoaXMtPmlvcmVnKTsKKwkJfQorCisJCWlmIChzdGF0dXMgJiAxKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIkVycm9yIHByb2dyYW1taW5nIG9vYiBkYXRhXG4iKTsKKwkJCS8qIFRoZXJlIHdhcyBhbiBlcnJvciAqLworCQkJKnJldGxlbiA9IDA7CisJCQlyZXR1cm4gLUVJTzsKKwkJfQorCQlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9TRVFJTiwgMCk7CisJCURvQ19BZGRyZXNzKHRoaXMsIEFERFJfQ09MVU1OX1BBR0UsIG9mcyAmICh+MHgxZmYpLCAwLCAwKTsKKwl9CisKKwlEb0NfV3JpdGVCdWYodGhpcywgJmJ1ZltsZW4yNTZdLCBsZW4gLSBsZW4yNTYpOworCisJRG9DX0NvbW1hbmQodGhpcywgTkFORF9DTURfUEFHRVBST0csIDApOworCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX1NUQVRVUywgMCk7CisJLyogRG9DX1dhaXRSZWFkeSgpIGlzIGltcGxpY2l0IGluIERvQ19Db21tYW5kICovCisKKwlpZiAoRG9DX2lzX01pbGxlbm5pdW0odGhpcykpIHsKKwkJUmVhZERPQyhkb2NwdHIsIFJlYWRQaXBlSW5pdCk7CisJCXN0YXR1cyA9IFJlYWRET0MoZG9jcHRyLCBMYXN0RGF0YVJlYWQpOworCX0gZWxzZSB7CisJCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIENEU05TbG93SU8pOworCQlEb0NfRGVsYXkodGhpcywgMik7CisJCXN0YXR1cyA9IFJlYWRET0NfKGRvY3B0ciwgdGhpcy0+aW9yZWcpOworCX0KKworCWlmIChzdGF0dXMgJiAxKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRXJyb3IgcHJvZ3JhbW1pbmcgb29iIGRhdGFcbiIpOworCQkvKiBUaGVyZSB3YXMgYW4gZXJyb3IgKi8KKwkJKnJldGxlbiA9IDA7CisJCXJldHVybiAtRUlPOworCX0KKworCSpyZXRsZW4gPSBsZW47CisJcmV0dXJuIDA7CisKK30KKyAKK3N0YXRpYyBpbnQgZG9jX3dyaXRlX29vYihzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IG9mcywgc2l6ZV90IGxlbiwKKyAJCQkgc2l6ZV90ICogcmV0bGVuLCBjb25zdCB1X2NoYXIgKiBidWYpCit7CisgCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworIAlpbnQgcmV0OworCisgCWRvd24oJnRoaXMtPmxvY2spOworIAlyZXQgPSBkb2Nfd3JpdGVfb29iX25vbG9jayhtdGQsIG9mcywgbGVuLCByZXRsZW4sIGJ1Zik7CisKKyAJdXAoJnRoaXMtPmxvY2spOworIAlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGRvY19lcmFzZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgc3RydWN0IGVyYXNlX2luZm8gKmluc3RyKQoreworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCV9fdTMyIG9mcyA9IGluc3RyLT5hZGRyOworCV9fdTMyIGxlbiA9IGluc3RyLT5sZW47CisJdm9sYXRpbGUgaW50IGR1bW15OworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gdGhpcy0+dmlydGFkcjsKKwlzdHJ1Y3QgTmFuZCAqbXljaGlwOworCWludCBzdGF0dXM7CisKKyAJZG93bigmdGhpcy0+bG9jayk7CisKKwlpZiAob2ZzICYgKG10ZC0+ZXJhc2VzaXplLTEpIHx8IGxlbiAmIChtdGQtPmVyYXNlc2l6ZS0xKSkgeworCQl1cCgmdGhpcy0+bG9jayk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTSU5HOworCQkKKwkvKiBGSVhNRTogRG8gdGhpcyBpbiB0aGUgYmFja2dyb3VuZC4gVXNlIHRpbWVycyBvciBzY2hlZHVsZV90YXNrKCkgKi8KKwl3aGlsZShsZW4pIHsKKwkJbXljaGlwID0gJnRoaXMtPmNoaXBzW29mcyA+PiB0aGlzLT5jaGlwc2hpZnRdOworCisJCWlmICh0aGlzLT5jdXJmbG9vciAhPSBteWNoaXAtPmZsb29yKSB7CisJCQlEb0NfU2VsZWN0Rmxvb3IodGhpcywgbXljaGlwLT5mbG9vcik7CisJCQlEb0NfU2VsZWN0Q2hpcCh0aGlzLCBteWNoaXAtPmNoaXApOworCQl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCQlEb0NfU2VsZWN0Q2hpcCh0aGlzLCBteWNoaXAtPmNoaXApOworCQl9CisJCXRoaXMtPmN1cmZsb29yID0gbXljaGlwLT5mbG9vcjsKKwkJdGhpcy0+Y3VyY2hpcCA9IG15Y2hpcC0+Y2hpcDsKKworCQlEb0NfQ29tbWFuZCh0aGlzLCBOQU5EX0NNRF9FUkFTRTEsIDApOworCQlEb0NfQWRkcmVzcyh0aGlzLCBBRERSX1BBR0UsIG9mcywgMCwgMCk7CisJCURvQ19Db21tYW5kKHRoaXMsIE5BTkRfQ01EX0VSQVNFMiwgMCk7CisKKwkJRG9DX0NvbW1hbmQodGhpcywgTkFORF9DTURfU1RBVFVTLCBDRFNOX0NUUkxfV1ApOworCisJCWlmIChEb0NfaXNfTWlsbGVubml1bSh0aGlzKSkgeworCQkJUmVhZERPQyhkb2NwdHIsIFJlYWRQaXBlSW5pdCk7CisJCQlzdGF0dXMgPSBSZWFkRE9DKGRvY3B0ciwgTGFzdERhdGFSZWFkKTsKKwkJfSBlbHNlIHsKKwkJCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIENEU05TbG93SU8pOworCQkJRG9DX0RlbGF5KHRoaXMsIDIpOworCQkJc3RhdHVzID0gUmVhZERPQ18oZG9jcHRyLCB0aGlzLT5pb3JlZyk7CisJCX0KKworCQlpZiAoc3RhdHVzICYgMSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJFcnJvciBlcmFzaW5nIGF0IDB4JXhcbiIsIG9mcyk7CisJCQkvKiBUaGVyZSB3YXMgYW4gZXJyb3IgKi8KKwkJCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9GQUlMRUQ7CisJCQlnb3RvIGNhbGxiYWNrOworCQl9CisJCW9mcyArPSBtdGQtPmVyYXNlc2l6ZTsKKwkJbGVuIC09IG10ZC0+ZXJhc2VzaXplOworCX0KKwlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRE9ORTsKKworIGNhbGxiYWNrOgorCW10ZF9lcmFzZV9jYWxsYmFjayhpbnN0cik7CisKKwl1cCgmdGhpcy0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqCisgKiBNb2R1bGUgc3R1ZmYKKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworc3RhdGljIGludCBfX2luaXQgaW5pdF9kb2MyMDAwKHZvaWQpCit7CisgICAgICAgaW50ZXJfbW9kdWxlX3JlZ2lzdGVyKGltX25hbWUsIFRISVNfTU9EVUxFLCAmRG9DMmtfaW5pdCk7CisgICAgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBjbGVhbnVwX2RvYzIwMDAodm9pZCkKK3sKKwlzdHJ1Y3QgbXRkX2luZm8gKm10ZDsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpczsKKworCXdoaWxlICgobXRkID0gZG9jMmtsaXN0KSkgeworCQl0aGlzID0gbXRkLT5wcml2OworCQlkb2Mya2xpc3QgPSB0aGlzLT5uZXh0ZG9jOworCisJCWRlbF9tdGRfZGV2aWNlKG10ZCk7CisKKwkJaW91bm1hcCh0aGlzLT52aXJ0YWRyKTsKKwkJa2ZyZWUodGhpcy0+Y2hpcHMpOworCQlrZnJlZShtdGQpOworCX0KKwlpbnRlcl9tb2R1bGVfdW5yZWdpc3RlcihpbV9uYW1lKTsKK30KKworbW9kdWxlX2V4aXQoY2xlYW51cF9kb2MyMDAwKTsKK21vZHVsZV9pbml0KGluaXRfZG9jMjAwMCk7CisKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BVVRIT1IoIkRhdmlkIFdvb2Rob3VzZSA8ZHdtdzJAaW5mcmFkZWFkLm9yZz4gZXQgYWwuIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIk1URCBkcml2ZXIgZm9yIERpc2tPbkNoaXAgMjAwMCBhbmQgTWlsbGVubml1bSIpOworCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL2RvYzIwMDEuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jMjAwMS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjFlNzA0OTEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2RvYzIwMDEuYwpAQCAtMCwwICsxLDg4OCBAQAorCisvKgorICogTGludXggZHJpdmVyIGZvciBEaXNrLU9uLUNoaXAgTWlsbGVubml1bQorICogKGMpIDE5OTkgTWFjaGluZSBWaXNpb24gSG9sZGluZ3MsIEluYy4KKyAqIChjKSAxOTk5LCAyMDAwIERhdmlkIFdvb2Rob3VzZSA8ZHdtdzJAaW5mcmFkZWFkLm9yZz4KKyAqCisgKiAkSWQ6IGRvYzIwMDEuYyx2IDEuNDggMjAwNS8wMS8wNSAxODowNToxMiBkd213MiBFeHAgJAorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxhc20vZXJybm8uaD4KKyNpbmNsdWRlIDxhc20vaW8uaD4KKyNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgorI2luY2x1ZGUgPGxpbnV4L21pc2NkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgorCisjaW5jbHVkZSA8bGludXgvbXRkL210ZC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9uYW5kLmg+CisjaW5jbHVkZSA8bGludXgvbXRkL2RvYzIwMDAuaD4KKworLyogI2RlZmluZSBFQ0NfREVCVUcgKi8KKworLyogSSBoYXZlIG5vIGlkZWEgd2h5IHNvbWUgRG9DIGNoaXBzIGNhbiBub3QgdXNlIG1lbWNvcF9mb3JtfHRvX2lvKCkuCisgKiBUaGlzIG1heSBiZSBkdWUgdG8gdGhlIGRpZmZlcmVudCByZXZpc2lvbnMgb2YgdGhlIEFTSUMgY29udHJvbGxlciBidWlsdC1pbiBvcgorICogc2ltcGxpbHkgYSBRQS9CdWcgaXNzdWUuIFdobyBrbm93cyA/PyBJZiB5b3UgaGF2ZSB0cm91YmxlLCBwbGVhc2UgdW5jb21tZW50CisgKiB0aGlzOiovCisjdW5kZWYgVVNFX01FTUNQWQorCitzdGF0aWMgaW50IGRvY19yZWFkKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwKKwkJICAgIHNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1Zik7CitzdGF0aWMgaW50IGRvY193cml0ZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLCBzaXplX3QgbGVuLAorCQkgICAgIHNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1Zik7CitzdGF0aWMgaW50IGRvY19yZWFkX2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCQlzaXplX3QgKnJldGxlbiwgdV9jaGFyICpidWYsIHVfY2hhciAqZWNjYnVmLAorCQkJc3RydWN0IG5hbmRfb29iaW5mbyAqb29ic2VsKTsKK3N0YXRpYyBpbnQgZG9jX3dyaXRlX2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLCBzaXplX3QgbGVuLAorCQkJIHNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1ZiwgdV9jaGFyICplY2NidWYsCisJCQkgc3RydWN0IG5hbmRfb29iaW5mbyAqb29ic2VsKTsKK3N0YXRpYyBpbnQgZG9jX3JlYWRfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQkJc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKTsKK3N0YXRpYyBpbnQgZG9jX3dyaXRlX29vYihzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IG9mcywgc2l6ZV90IGxlbiwKKwkJCSBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpOworc3RhdGljIGludCBkb2NfZXJhc2UgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpOworCitzdGF0aWMgc3RydWN0IG10ZF9pbmZvICpkb2NtaWxsaXN0ID0gTlVMTDsKKworLyogUGVyZm9ybSB0aGUgcmVxdWlyZWQgZGVsYXkgY3ljbGVzIGJ5IHJlYWRpbmcgZnJvbSB0aGUgTk9QIHJlZ2lzdGVyICovCitzdGF0aWMgdm9pZCBEb0NfRGVsYXkodm9pZCBfX2lvbWVtICogZG9jcHRyLCB1bnNpZ25lZCBzaG9ydCBjeWNsZXMpCit7CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBjeWNsZXM7IGkrKykKKwkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTk9QKTsKK30KKworLyogRE9DX1dhaXRSZWFkeTogV2FpdCBmb3IgUkRZIGxpbmUgdG8gYmUgYXNzZXJ0ZWQgYnkgdGhlIGZsYXNoIGNoaXAgKi8KK3N0YXRpYyBpbnQgX0RvQ19XYWl0UmVhZHkodm9pZCBfX2lvbWVtICogZG9jcHRyKQoreworCXVuc2lnbmVkIHNob3J0IGMgPSAweGZmZmY7CisKKwlERUJVRyhNVERfREVCVUdfTEVWRUwzLAorCSAgICAgICJfRG9DX1dhaXRSZWFkeSBjYWxsZWQgZm9yIG91dC1vZi1saW5lIHdhaXRcbiIpOworCisJLyogT3V0LW9mLWxpbmUgcm91dGluZSB0byB3YWl0IGZvciBjaGlwIHJlc3BvbnNlICovCisJd2hpbGUgKCEoUmVhZERPQyhkb2NwdHIsIENEU05Db250cm9sKSAmIENEU05fQ1RSTF9GUl9CKSAmJiAtLWMpCisJCTsKKworCWlmIChjID09IDApCisJCURFQlVHKE1URF9ERUJVR19MRVZFTDIsICJfRG9DX1dhaXRSZWFkeSB0aW1lZCBvdXQuXG4iKTsKKworCXJldHVybiAoYyA9PSAwKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgRG9DX1dhaXRSZWFkeSh2b2lkIF9faW9tZW0gKiBkb2NwdHIpCit7CisJLyogVGhpcyBpcyBpbmxpbmUsIHRvIG9wdGltaXNlIHRoZSBjb21tb24gY2FzZSwgd2hlcmUgaXQncyByZWFkeSBpbnN0YW50bHkgKi8KKwlpbnQgcmV0ID0gMDsKKworCS8qIDQgcmVhZCBmb3JtIE5PUCByZWdpc3RlciBzaG91bGQgYmUgaXNzdWVkIGluIHByaW9yIHRvIHRoZSByZWFkIGZyb20gQ0RTTkNvbnRyb2wKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDIuICovCisJRG9DX0RlbGF5KGRvY3B0ciwgNCk7CisKKwlpZiAoIShSZWFkRE9DKGRvY3B0ciwgQ0RTTkNvbnRyb2wpICYgQ0RTTl9DVFJMX0ZSX0IpKQorCQkvKiBDYWxsIHRoZSBvdXQtb2YtbGluZSByb3V0aW5lIHRvIHdhaXQgKi8KKwkJcmV0ID0gX0RvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCS8qIGlzc3VlIDIgcmVhZCBmcm9tIE5PUCByZWdpc3RlciBhZnRlciByZWFkaW5nIGZyb20gQ0RTTkNvbnRyb2wgcmVnaXN0ZXIKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDIuICovCisJRG9DX0RlbGF5KGRvY3B0ciwgMik7CisKKwlyZXR1cm4gcmV0OworfQorCisvKiBEb0NfQ29tbWFuZDogU2VuZCBhIGZsYXNoIGNvbW1hbmQgdG8gdGhlIGZsYXNoIGNoaXAgdGhyb3VnaCB0aGUgQ0RTTiBJTyByZWdpc3RlcgorICAgd2l0aCB0aGUgaW50ZXJuYWwgcGlwZWxpbmUuIEVhY2ggb2YgNCBkZWxheSBjeWNsZXMgKHJlYWQgZnJvbSB0aGUgTk9QIHJlZ2lzdGVyKSBpcworICAgcmVxdWlyZWQgYWZ0ZXIgd3JpdGluZyB0byBDRFNOIENvbnRyb2wgcmVnaXN0ZXIsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMy4gKi8KKworc3RhdGljIGlubGluZSB2b2lkIERvQ19Db21tYW5kKHZvaWQgX19pb21lbSAqIGRvY3B0ciwgdW5zaWduZWQgY2hhciBjb21tYW5kLAorCQkJICAgICAgIHVuc2lnbmVkIGNoYXIgeHRyYWZsYWdzKQoreworCS8qIEFzc2VydCB0aGUgQ0xFIChDb21tYW5kIExhdGNoIEVuYWJsZSkgbGluZSB0byB0aGUgZmxhc2ggY2hpcCAqLworCVdyaXRlRE9DKHh0cmFmbGFncyB8IENEU05fQ1RSTF9DTEUgfCBDRFNOX0NUUkxfQ0UsIGRvY3B0ciwgQ0RTTkNvbnRyb2wpOworCURvQ19EZWxheShkb2NwdHIsIDQpOworCisJLyogU2VuZCB0aGUgY29tbWFuZCAqLworCVdyaXRlRE9DKGNvbW1hbmQsIGRvY3B0ciwgTWlsX0NEU05fSU8pOworCVdyaXRlRE9DKDB4MDAsIGRvY3B0ciwgV3JpdGVQaXBlVGVybSk7CisKKwkvKiBMb3dlciB0aGUgQ0xFIGxpbmUgKi8KKwlXcml0ZURPQyh4dHJhZmxhZ3MgfCBDRFNOX0NUUkxfQ0UsIGRvY3B0ciwgQ0RTTkNvbnRyb2wpOworCURvQ19EZWxheShkb2NwdHIsIDQpOworfQorCisvKiBEb0NfQWRkcmVzczogU2V0IHRoZSBjdXJyZW50IGFkZHJlc3MgZm9yIHRoZSBmbGFzaCBjaGlwIHRocm91Z2ggdGhlIENEU04gSU8gcmVnaXN0ZXIKKyAgIHdpdGggdGhlIGludGVybmFsIHBpcGVsaW5lLiBFYWNoIG9mIDQgZGVsYXkgY3ljbGVzIChyZWFkIGZyb20gdGhlIE5PUCByZWdpc3RlcikgaXMKKyAgIHJlcXVpcmVkIGFmdGVyIHdyaXRpbmcgdG8gQ0RTTiBDb250cm9sIHJlZ2lzdGVyLCBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDMuICovCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBEb0NfQWRkcmVzcyh2b2lkIF9faW9tZW0gKiBkb2NwdHIsIGludCBudW1ieXRlcywgdW5zaWduZWQgbG9uZyBvZnMsCisJCQkgICAgICAgdW5zaWduZWQgY2hhciB4dHJhZmxhZ3MxLCB1bnNpZ25lZCBjaGFyIHh0cmFmbGFnczIpCit7CisJLyogQXNzZXJ0IHRoZSBBTEUgKEFkZHJlc3MgTGF0Y2ggRW5hYmxlKSBsaW5lIHRvIHRoZSBmbGFzaCBjaGlwICovCisJV3JpdGVET0MoeHRyYWZsYWdzMSB8IENEU05fQ1RSTF9BTEUgfCBDRFNOX0NUUkxfQ0UsIGRvY3B0ciwgQ0RTTkNvbnRyb2wpOworCURvQ19EZWxheShkb2NwdHIsIDQpOworCisJLyogU2VuZCB0aGUgYWRkcmVzcyAqLworCXN3aXRjaCAobnVtYnl0ZXMpCisJICAgIHsKKwkgICAgY2FzZSAxOgorCQkgICAgLyogU2VuZCBzaW5nbGUgYnl0ZSwgYml0cyAwLTcuICovCisJCSAgICBXcml0ZURPQyhvZnMgJiAweGZmLCBkb2NwdHIsIE1pbF9DRFNOX0lPKTsKKwkJICAgIFdyaXRlRE9DKDB4MDAsIGRvY3B0ciwgV3JpdGVQaXBlVGVybSk7CisJCSAgICBicmVhazsKKwkgICAgY2FzZSAyOgorCQkgICAgLyogU2VuZCBiaXRzIDktMTYgZm9sbG93ZWQgYnkgMTctMjMgKi8KKwkJICAgIFdyaXRlRE9DKChvZnMgPj4gOSkgICYgMHhmZiwgZG9jcHRyLCBNaWxfQ0RTTl9JTyk7CisJCSAgICBXcml0ZURPQygob2ZzID4+IDE3KSAmIDB4ZmYsIGRvY3B0ciwgTWlsX0NEU05fSU8pOworCQkgICAgV3JpdGVET0MoMHgwMCwgZG9jcHRyLCBXcml0ZVBpcGVUZXJtKTsKKwkJYnJlYWs7CisJICAgIGNhc2UgMzoKKwkJICAgIC8qIFNlbmQgMC03LCA5LTE2LCB0aGVuIDE3LTIzICovCisJCSAgICBXcml0ZURPQyhvZnMgJiAweGZmLCBkb2NwdHIsIE1pbF9DRFNOX0lPKTsKKwkJICAgIFdyaXRlRE9DKChvZnMgPj4gOSkgICYgMHhmZiwgZG9jcHRyLCBNaWxfQ0RTTl9JTyk7CisJCSAgICBXcml0ZURPQygob2ZzID4+IDE3KSAmIDB4ZmYsIGRvY3B0ciwgTWlsX0NEU05fSU8pOworCQkgICAgV3JpdGVET0MoMHgwMCwgZG9jcHRyLCBXcml0ZVBpcGVUZXJtKTsKKwkJYnJlYWs7CisJICAgIGRlZmF1bHQ6CisJCXJldHVybjsKKwkgICAgfQorCisJLyogTG93ZXIgdGhlIEFMRSBsaW5lICovCisJV3JpdGVET0MoeHRyYWZsYWdzMSB8IHh0cmFmbGFnczIgfCBDRFNOX0NUUkxfQ0UsIGRvY3B0ciwgQ0RTTkNvbnRyb2wpOworCURvQ19EZWxheShkb2NwdHIsIDQpOworfQorCisvKiBEb0NfU2VsZWN0Q2hpcDogU2VsZWN0IGEgZ2l2ZW4gZmxhc2ggY2hpcCB3aXRoaW4gdGhlIGN1cnJlbnQgZmxvb3IgKi8KK3N0YXRpYyBpbnQgRG9DX1NlbGVjdENoaXAodm9pZCBfX2lvbWVtICogZG9jcHRyLCBpbnQgY2hpcCkKK3sKKwkvKiBTZWxlY3QgdGhlIGluZGl2aWR1YWwgZmxhc2ggY2hpcCByZXF1ZXN0ZWQgKi8KKwlXcml0ZURPQyhjaGlwLCBkb2NwdHIsIENEU05EZXZpY2VTZWxlY3QpOworCURvQ19EZWxheShkb2NwdHIsIDQpOworCisJLyogV2FpdCBmb3IgaXQgdG8gYmUgcmVhZHkgKi8KKwlyZXR1cm4gRG9DX1dhaXRSZWFkeShkb2NwdHIpOworfQorCisvKiBEb0NfU2VsZWN0Rmxvb3I6IFNlbGVjdCBhIGdpdmVuIGZsb29yIChiYW5rIG9mIGZsYXNoIGNoaXBzKSAqLworc3RhdGljIGludCBEb0NfU2VsZWN0Rmxvb3Iodm9pZCBfX2lvbWVtICogZG9jcHRyLCBpbnQgZmxvb3IpCit7CisJLyogU2VsZWN0IHRoZSBmbG9vciAoYmFuaykgb2YgY2hpcHMgcmVxdWlyZWQgKi8KKwlXcml0ZURPQyhmbG9vciwgZG9jcHRyLCBGbG9vclNlbGVjdCk7CisKKwkvKiBXYWl0IGZvciB0aGUgY2hpcCB0byBiZSByZWFkeSAqLworCXJldHVybiBEb0NfV2FpdFJlYWR5KGRvY3B0cik7Cit9CisKKy8qIERvQ19JZGVudENoaXA6IElkZW50aWZ5IGEgZ2l2ZW4gTkFORCBjaGlwIGdpdmVuIHtmbG9vcixjaGlwfSAqLworc3RhdGljIGludCBEb0NfSWRlbnRDaGlwKHN0cnVjdCBEaXNrT25DaGlwICpkb2MsIGludCBmbG9vciwgaW50IGNoaXApCit7CisJaW50IG1mciwgaWQsIGksIGo7CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKworCS8qIFBhZ2UgaW4gdGhlIHJlcXVpcmVkIGZsb29yL2NoaXAKKwkgICBGSVhNRTogaXMgdGhpcyBzdXBwb3J0ZWQgYnkgTWlsbGVubml1bSA/PyAqLworCURvQ19TZWxlY3RGbG9vcihkb2MtPnZpcnRhZHIsIGZsb29yKTsKKwlEb0NfU2VsZWN0Q2hpcChkb2MtPnZpcnRhZHIsIGNoaXApOworCisJLyogUmVzZXQgdGhlIGNoaXAsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4gKi8KKwlEb0NfQ29tbWFuZChkb2MtPnZpcnRhZHIsIE5BTkRfQ01EX1JFU0VULCBDRFNOX0NUUkxfV1ApOworCURvQ19XYWl0UmVhZHkoZG9jLT52aXJ0YWRyKTsKKworCS8qIFJlYWQgdGhlIE5BTkQgY2hpcCBJRDogMS4gU2VuZCBSZWFkSUQgY29tbWFuZCAqLyAKKwlEb0NfQ29tbWFuZChkb2MtPnZpcnRhZHIsIE5BTkRfQ01EX1JFQURJRCwgQ0RTTl9DVFJMX1dQKTsKKworCS8qIFJlYWQgdGhlIE5BTkQgY2hpcCBJRDogMi4gU2VuZCBhZGRyZXNzIGJ5dGUgemVybyAqLyAKKwlEb0NfQWRkcmVzcyhkb2MtPnZpcnRhZHIsIDEsIDB4MDAsIENEU05fQ1RSTF9XUCwgMHgwMCk7CisKKwkvKiBSZWFkIHRoZSBtYW51ZmFjdHVyZXIgYW5kIGRldmljZSBpZCBjb2RlcyBvZiB0aGUgZmxhc2ggZGV2aWNlIHRocm91Z2gKKwkgICBDRFNOIElPIHJlZ2lzdGVyIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gNS4qLworCWR1bW15ID0gUmVhZERPQyhkb2MtPnZpcnRhZHIsIFJlYWRQaXBlSW5pdCk7CisJRG9DX0RlbGF5KGRvYy0+dmlydGFkciwgMik7CisJbWZyID0gUmVhZERPQyhkb2MtPnZpcnRhZHIsIE1pbF9DRFNOX0lPKTsKKworCURvQ19EZWxheShkb2MtPnZpcnRhZHIsIDIpOworCWlkICA9IFJlYWRET0MoZG9jLT52aXJ0YWRyLCBNaWxfQ0RTTl9JTyk7CisJZHVtbXkgPSBSZWFkRE9DKGRvYy0+dmlydGFkciwgTGFzdERhdGFSZWFkKTsKKworCS8qIE5vIHJlc3BvbnNlIC0gcmV0dXJuIGZhaWx1cmUgKi8KKwlpZiAobWZyID09IDB4ZmYgfHwgbWZyID09IDApCisJCXJldHVybiAwOworCisJLyogRklYTUU6IHRvIGRlYWwgd2l0aCBtdWx0aS1mbGFzaCBvbiBtdWx0aS1NaWxsZW5uaXVtIGNhc2UgbW9yZSBjYXJlZnVsbHkgKi8KKwlmb3IgKGkgPSAwOyBuYW5kX2ZsYXNoX2lkc1tpXS5uYW1lICE9IE5VTEw7IGkrKykgeworCQlpZiAoIGlkID09IG5hbmRfZmxhc2hfaWRzW2ldLmlkKSB7CisJCQkvKiBUcnkgdG8gaWRlbnRpZnkgbWFudWZhY3R1cmVyICovCisJCQlmb3IgKGogPSAwOyBuYW5kX21hbnVmX2lkc1tqXS5pZCAhPSAweDA7IGorKykgeworCQkJCWlmIChuYW5kX21hbnVmX2lkc1tqXS5pZCA9PSBtZnIpCisJCQkJCWJyZWFrOworCQkJfQkKKwkJCXByaW50ayhLRVJOX0lORk8gIkZsYXNoIGNoaXAgZm91bmQ6IE1hbnVmYWN0dXJlciBJRDogJTIuMlgsICIKKwkJCSAgICAgICAiQ2hpcCBJRDogJTIuMlggKCVzOiVzKVxuIiwKKwkJCSAgICAgICBtZnIsIGlkLCBuYW5kX21hbnVmX2lkc1tqXS5uYW1lLCBuYW5kX2ZsYXNoX2lkc1tpXS5uYW1lKTsKKwkJCWRvYy0+bWZyID0gbWZyOworCQkJZG9jLT5pZCA9IGlkOworCQkJZG9jLT5jaGlwc2hpZnQgPSBmZnMoKG5hbmRfZmxhc2hfaWRzW2ldLmNoaXBzaXplIDw8IDIwKSkgLSAxOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlpZiAobmFuZF9mbGFzaF9pZHNbaV0ubmFtZSA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKwllbHNlCisJCXJldHVybiAxOworfQorCisvKiBEb0NfU2NhbkNoaXBzOiBGaW5kIGFsbCBOQU5EIGNoaXBzIHByZXNlbnQgaW4gYSBEaXNrT25DaGlwLCBhbmQgaWRlbnRpZnkgdGhlbSAqLworc3RhdGljIHZvaWQgRG9DX1NjYW5DaGlwcyhzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcykKK3sKKwlpbnQgZmxvb3IsIGNoaXA7CisJaW50IG51bWNoaXBzW01BWF9GTE9PUlNfTUlMXTsKKwlpbnQgcmV0OworCisJdGhpcy0+bnVtY2hpcHMgPSAwOworCXRoaXMtPm1mciA9IDA7CisJdGhpcy0+aWQgPSAwOworCisJLyogRm9yIGVhY2ggZmxvb3IsIGZpbmQgdGhlIG51bWJlciBvZiB2YWxpZCBjaGlwcyBpdCBjb250YWlucyAqLworCWZvciAoZmxvb3IgPSAwLHJldCA9IDE7IGZsb29yIDwgTUFYX0ZMT09SU19NSUw7IGZsb29yKyspIHsKKwkJbnVtY2hpcHNbZmxvb3JdID0gMDsKKwkJZm9yIChjaGlwID0gMDsgY2hpcCA8IE1BWF9DSElQU19NSUwgJiYgcmV0ICE9IDA7IGNoaXArKykgeworCQkJcmV0ID0gRG9DX0lkZW50Q2hpcCh0aGlzLCBmbG9vciwgY2hpcCk7CisJCQlpZiAocmV0KSB7CisJCQkJbnVtY2hpcHNbZmxvb3JdKys7CisJCQkJdGhpcy0+bnVtY2hpcHMrKzsKKwkJCX0KKwkJfQorCX0KKwkvKiBJZiB0aGVyZSBhcmUgbm9uZSBhdCBhbGwgdGhhdCB3ZSByZWNvZ25pc2UsIGJhaWwgKi8KKwlpZiAoIXRoaXMtPm51bWNoaXBzKSB7CisJCXByaW50aygiTm8gZmxhc2ggY2hpcHMgcmVjb2duaXNlZC5cbiIpOworCQlyZXR1cm47CisJfQorCisJLyogQWxsb2NhdGUgYW4gYXJyYXkgdG8gaG9sZCB0aGUgaW5mb3JtYXRpb24gZm9yIGVhY2ggY2hpcCAqLworCXRoaXMtPmNoaXBzID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IE5hbmQpICogdGhpcy0+bnVtY2hpcHMsIEdGUF9LRVJORUwpOworCWlmICghdGhpcy0+Y2hpcHMpeworCQlwcmludGsoIk5vIG1lbW9yeSBmb3IgYWxsb2NhdGluZyBjaGlwIGluZm8gc3RydWN0dXJlc1xuIik7CisJCXJldHVybjsKKwl9CisKKwkvKiBGaWxsIG91dCB0aGUgY2hpcCBhcnJheSB3aXRoIHtmbG9vciwgY2hpcG5vfSBmb3IgZWFjaCAKKwkgKiBkZXRlY3RlZCBjaGlwIGluIHRoZSBkZXZpY2UuICovCisJZm9yIChmbG9vciA9IDAsIHJldCA9IDA7IGZsb29yIDwgTUFYX0ZMT09SU19NSUw7IGZsb29yKyspIHsKKwkJZm9yIChjaGlwID0gMCA7IGNoaXAgPCBudW1jaGlwc1tmbG9vcl0gOyBjaGlwKyspIHsKKwkJCXRoaXMtPmNoaXBzW3JldF0uZmxvb3IgPSBmbG9vcjsKKwkJCXRoaXMtPmNoaXBzW3JldF0uY2hpcCA9IGNoaXA7CisJCQl0aGlzLT5jaGlwc1tyZXRdLmN1cmFkciA9IDA7CisJCQl0aGlzLT5jaGlwc1tyZXRdLmN1cm1vZGUgPSAweDUwOworCQkJcmV0Kys7CisJCX0KKwl9CisKKwkvKiBDYWxjdWxhdGUgYW5kIHByaW50IHRoZSB0b3RhbCBzaXplIG9mIHRoZSBkZXZpY2UgKi8KKwl0aGlzLT50b3RsZW4gPSB0aGlzLT5udW1jaGlwcyAqICgxIDw8IHRoaXMtPmNoaXBzaGlmdCk7CisJcHJpbnRrKEtFUk5fSU5GTyAiJWQgZmxhc2ggY2hpcHMgZm91bmQuIFRvdGFsIERpc2tPbkNoaXAgc2l6ZTogJWxkIE1pQlxuIiwKKwkgICAgICAgdGhpcy0+bnVtY2hpcHMgLHRoaXMtPnRvdGxlbiA+PiAyMCk7Cit9CisKK3N0YXRpYyBpbnQgRG9DTWlsX2lzX2FsaWFzKHN0cnVjdCBEaXNrT25DaGlwICpkb2MxLCBzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jMikKK3sKKwlpbnQgdG1wMSwgdG1wMiwgcmV0dmFsOworCisJaWYgKGRvYzEtPnBoeXNhZHIgPT0gZG9jMi0+cGh5c2FkcikKKwkJcmV0dXJuIDE7CisKKwkvKiBVc2UgdGhlIGFsaWFzIHJlc29sdXRpb24gcmVnaXN0ZXIgd2hpY2ggd2FzIHNldCBhc2lkZSBmb3IgdGhpcworCSAqIHB1cnBvc2UuIElmIGl0J3MgdmFsdWUgaXMgdGhlIHNhbWUgb24gYm90aCBjaGlwcywgdGhleSBtaWdodAorCSAqIGJlIHRoZSBzYW1lIGNoaXAsIGFuZCB3ZSB3cml0ZSB0byBvbmUgYW5kIGNoZWNrIGZvciBhIGNoYW5nZSBpbgorCSAqIHRoZSBvdGhlci4gSXQncyB1bmNsZWFyIGlmIHRoaXMgcmVnaXN0ZXIgaXMgdXN1YWJsZSBpbiB0aGUKKwkgKiBEb0MgMjAwMCAoaXQncyBpbiB0aGUgTWlsbGVuaXVtIGRvY3MpLCBidXQgaXQgc2VlbXMgdG8gd29yay4gKi8KKwl0bXAxID0gUmVhZERPQyhkb2MxLT52aXJ0YWRyLCBBbGlhc1Jlc29sdXRpb24pOworCXRtcDIgPSBSZWFkRE9DKGRvYzItPnZpcnRhZHIsIEFsaWFzUmVzb2x1dGlvbik7CisJaWYgKHRtcDEgIT0gdG1wMikKKwkJcmV0dXJuIDA7CisJCisJV3JpdGVET0MoKHRtcDErMSkgJSAweGZmLCBkb2MxLT52aXJ0YWRyLCBBbGlhc1Jlc29sdXRpb24pOworCXRtcDIgPSBSZWFkRE9DKGRvYzItPnZpcnRhZHIsIEFsaWFzUmVzb2x1dGlvbik7CisJaWYgKHRtcDIgPT0gKHRtcDErMSkgJSAweGZmKQorCQlyZXR2YWwgPSAxOworCWVsc2UKKwkJcmV0dmFsID0gMDsKKworCS8qIFJlc3RvcmUgcmVnaXN0ZXIgY29udGVudHMuICBNYXkgbm90IGJlIG5lY2Vzc2FyeSwgYnV0IGRvIGl0IGp1c3QgdG8KKwkgKiBiZSBzYWZlLiAqLworCVdyaXRlRE9DKHRtcDEsIGRvYzEtPnZpcnRhZHIsIEFsaWFzUmVzb2x1dGlvbik7CisKKwlyZXR1cm4gcmV0dmFsOworfQorCitzdGF0aWMgY29uc3QgY2hhciBpbV9uYW1lW10gPSAiRG9DTWlsX2luaXQiOworCisvKiBUaGlzIHJvdXRpbmUgaXMgbWFkZSBhdmFpbGFibGUgdG8gb3RoZXIgbXRkIGNvZGUgdmlhCisgKiBpbnRlcl9tb2R1bGVfcmVnaXN0ZXIuICBJdCBtdXN0IG9ubHkgYmUgYWNjZXNzZWQgdGhyb3VnaAorICogaW50ZXJfbW9kdWxlX2dldCB3aGljaCB3aWxsIGJ1bXAgdGhlIHVzZSBjb3VudCBvZiB0aGlzIG1vZHVsZS4gIFRoZQorICogYWRkcmVzc2VzIHBhc3NlZCBiYWNrIGluIG10ZCBhcmUgdmFsaWQgYXMgbG9uZyBhcyB0aGUgdXNlIGNvdW50IG9mCisgKiB0aGlzIG1vZHVsZSBpcyBub24temVybywgaS5lLiBiZXR3ZWVuIGludGVyX21vZHVsZV9nZXQgYW5kCisgKiBpbnRlcl9tb2R1bGVfcHV0LiAgS2VpdGggT3dlbnMgPGthb3NAb2NzLmNvbS5hdT4gMjkgT2N0IDIwMDAuCisgKi8KK3N0YXRpYyB2b2lkIERvQ01pbF9pbml0KHN0cnVjdCBtdGRfaW5mbyAqbXRkKQoreworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCXN0cnVjdCBEaXNrT25DaGlwICpvbGQgPSBOVUxMOworCisJLyogV2UgbXVzdCBhdm9pZCBiZWluZyBjYWxsZWQgdHdpY2UgZm9yIHRoZSBzYW1lIGRldmljZS4gKi8KKwlpZiAoZG9jbWlsbGlzdCkKKwkJb2xkID0gZG9jbWlsbGlzdC0+cHJpdjsKKworCXdoaWxlIChvbGQpIHsKKwkJaWYgKERvQ01pbF9pc19hbGlhcyh0aGlzLCBvbGQpKSB7CisJCQlwcmludGsoS0VSTl9OT1RJQ0UgIklnbm9yaW5nIERpc2tPbkNoaXAgTWlsbGVubml1bSBhdCAiCisJCQkgICAgICAgIjB4JWxYIC0gYWxyZWFkeSBjb25maWd1cmVkXG4iLCB0aGlzLT5waHlzYWRyKTsKKwkJCWlvdW5tYXAodGhpcy0+dmlydGFkcik7CisJCQlrZnJlZShtdGQpOworCQkJcmV0dXJuOworCQl9CisJCWlmIChvbGQtPm5leHRkb2MpCisJCQlvbGQgPSBvbGQtPm5leHRkb2MtPnByaXY7CisJCWVsc2UKKwkJCW9sZCA9IE5VTEw7CisJfQorCisJbXRkLT5uYW1lID0gIkRpc2tPbkNoaXAgTWlsbGVubml1bSI7CisJcHJpbnRrKEtFUk5fTk9USUNFICJEaXNrT25DaGlwIE1pbGxlbm5pdW0gZm91bmQgYXQgYWRkcmVzcyAweCVsWFxuIiwKKwkgICAgICAgdGhpcy0+cGh5c2Fkcik7CisKKwltdGQtPnR5cGUgPSBNVERfTkFOREZMQVNIOworCW10ZC0+ZmxhZ3MgPSBNVERfQ0FQX05BTkRGTEFTSDsKKwltdGQtPmVjY3R5cGUgPSBNVERfRUNDX1JTX0Rpc2tPbkNoaXA7CisJbXRkLT5zaXplID0gMDsKKworCS8qIEZJWE1FOiBlcmFzZSBzaXplIGlzIG5vdCBhbHdheXMgOEtpQiAqLworCW10ZC0+ZXJhc2VzaXplID0gMHgyMDAwOworCisJbXRkLT5vb2JibG9jayA9IDUxMjsKKwltdGQtPm9vYnNpemUgPSAxNjsKKwltdGQtPm93bmVyID0gVEhJU19NT0RVTEU7CisJbXRkLT5lcmFzZSA9IGRvY19lcmFzZTsKKwltdGQtPnBvaW50ID0gTlVMTDsKKwltdGQtPnVucG9pbnQgPSBOVUxMOworCW10ZC0+cmVhZCA9IGRvY19yZWFkOworCW10ZC0+d3JpdGUgPSBkb2Nfd3JpdGU7CisJbXRkLT5yZWFkX2VjYyA9IGRvY19yZWFkX2VjYzsKKwltdGQtPndyaXRlX2VjYyA9IGRvY193cml0ZV9lY2M7CisJbXRkLT5yZWFkX29vYiA9IGRvY19yZWFkX29vYjsKKwltdGQtPndyaXRlX29vYiA9IGRvY193cml0ZV9vb2I7CisJbXRkLT5zeW5jID0gTlVMTDsKKworCXRoaXMtPnRvdGxlbiA9IDA7CisJdGhpcy0+bnVtY2hpcHMgPSAwOworCXRoaXMtPmN1cmZsb29yID0gLTE7CisJdGhpcy0+Y3VyY2hpcCA9IC0xOworCisJLyogSWRlbnQgYWxsIHRoZSBjaGlwcyBwcmVzZW50LiAqLworCURvQ19TY2FuQ2hpcHModGhpcyk7CisKKwlpZiAoIXRoaXMtPnRvdGxlbikgeworCQlrZnJlZShtdGQpOworCQlpb3VubWFwKHRoaXMtPnZpcnRhZHIpOworCX0gZWxzZSB7CisJCXRoaXMtPm5leHRkb2MgPSBkb2NtaWxsaXN0OworCQlkb2NtaWxsaXN0ID0gbXRkOworCQltdGQtPnNpemUgID0gdGhpcy0+dG90bGVuOworCQlhZGRfbXRkX2RldmljZShtdGQpOworCQlyZXR1cm47CisJfQorfQorCitzdGF0aWMgaW50IGRvY19yZWFkIChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCSAgICAgc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKQoreworCS8qIEp1c3QgYSBzcGVjaWFsIGNhc2Ugb2YgZG9jX3JlYWRfZWNjICovCisJcmV0dXJuIGRvY19yZWFkX2VjYyhtdGQsIGZyb20sIGxlbiwgcmV0bGVuLCBidWYsIE5VTEwsIE5VTEwpOworfQorCitzdGF0aWMgaW50IGRvY19yZWFkX2VjYyAoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLAorCQkJIHNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZiwgdV9jaGFyICplY2NidWYsCisJCQkgc3RydWN0IG5hbmRfb29iaW5mbyAqb29ic2VsKQoreworCWludCBpLCByZXQ7CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwl1bnNpZ25lZCBjaGFyIHN5bmRyb21lWzZdOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gdGhpcy0+dmlydGFkcjsKKwlzdHJ1Y3QgTmFuZCAqbXljaGlwID0gJnRoaXMtPmNoaXBzW2Zyb20gPj4gKHRoaXMtPmNoaXBzaGlmdCldOworCisJLyogRG9uJ3QgYWxsb3cgcmVhZCBwYXN0IGVuZCBvZiBkZXZpY2UgKi8KKwlpZiAoZnJvbSA+PSB0aGlzLT50b3RsZW4pCisJCXJldHVybiAtRUlOVkFMOworCisJLyogRG9uJ3QgYWxsb3cgYSBzaW5nbGUgcmVhZCB0byBjcm9zcyBhIDUxMi1ieXRlIGJsb2NrIGJvdW5kYXJ5ICovCisJaWYgKGZyb20gKyBsZW4gPiAoKGZyb20gfCAweDFmZikgKyAxKSkgCisJCWxlbiA9ICgoZnJvbSB8IDB4MWZmKSArIDEpIC0gZnJvbTsKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKGRvY3B0ciwgbXljaGlwLT5mbG9vcik7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBpc3N1ZSB0aGUgUmVhZDAgb3IgUmVhZDEgY29tbWFuZCBkZXBlbmQgb24gd2hpY2ggaGFsZiBvZiB0aGUgcGFnZQorCSAgIHdlIGFyZSBhY2Nlc3NpbmcuIFBvbGxpbmcgdGhlIEZsYXNoIFJlYWR5IGJpdCBhZnRlciBpc3N1ZSAzIGJ5dGVzCisJICAgYWRkcmVzcyBpbiBTZXF1ZW5jZSBSZWFkIE1vZGUsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4qLworCURvQ19Db21tYW5kKGRvY3B0ciwgKGZyb20gPj4gOCkgJiAxLCBDRFNOX0NUUkxfV1ApOworCURvQ19BZGRyZXNzKGRvY3B0ciwgMywgZnJvbSwgQ0RTTl9DVFJMX1dQLCAweDAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwlpZiAoZWNjYnVmKSB7CisJCS8qIGluaXQgdGhlIEVDQyBlbmdpbmUsIHNlZSBSZWVkLVNvbG9tb24gRURDL0VDQyAxMS4xIC4qLworCQlXcml0ZURPQyAoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBFQ0NDb25mKTsKKwkJV3JpdGVET0MgKERPQ19FQ0NfRU4sIGRvY3B0ciwgRUNDQ29uZik7CisJfSBlbHNlIHsKKwkJLyogZGlzYWJsZSB0aGUgRUNDIGVuZ2luZSAqLworCQlXcml0ZURPQyAoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBFQ0NDb25mKTsKKwkJV3JpdGVET0MgKERPQ19FQ0NfRElTLCBkb2NwdHIsIEVDQ0NvbmYpOworCX0KKworCS8qIFJlYWQgdGhlIGRhdGEgdmlhIHRoZSBpbnRlcm5hbCBwaXBlbGluZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIsCisJICAgc2VlIFBpcGVsaW5lZCBSZWFkIE9wZXJhdGlvbnMgMTEuMyAqLworCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIFJlYWRQaXBlSW5pdCk7CisjaWZuZGVmIFVTRV9NRU1DUFkKKwlmb3IgKGkgPSAwOyBpIDwgbGVuLTE7IGkrKykgeworCQkvKiBOLkIuIHlvdSBoYXZlIHRvIGluY3JlYXNlIHRoZSBzb3VyY2UgYWRkcmVzcyBpbiB0aGlzIHdheSBvciB0aGUKKwkJICAgRUNDIGxvZ2ljIHdpbGwgbm90IHdvcmsgcHJvcGVybHkgKi8KKwkJYnVmW2ldID0gUmVhZERPQyhkb2NwdHIsIE1pbF9DRFNOX0lPICsgKGkgJiAweGZmKSk7CisJfQorI2Vsc2UKKwltZW1jcHlfZnJvbWlvKGJ1ZiwgZG9jcHRyICsgRG9DX01pbF9DRFNOX0lPLCBsZW4gLSAxKTsKKyNlbmRpZgorCWJ1ZltsZW4gLSAxXSA9IFJlYWRET0MoZG9jcHRyLCBMYXN0RGF0YVJlYWQpOworCisJLyogTGV0IHRoZSBjYWxsZXIga25vdyB3ZSBjb21wbGV0ZWQgaXQgKi8KKwkqcmV0bGVuID0gbGVuOworICAgICAgICByZXQgPSAwOworCisJaWYgKGVjY2J1ZikgeworCQkvKiBSZWFkIHRoZSBFQ0MgZGF0YSBmcm9tIFNwYXJlIERhdGEgQXJlYSwKKwkJICAgc2VlIFJlZWQtU29sb21vbiBFREMvRUNDIDExLjEgKi8KKwkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgUmVhZFBpcGVJbml0KTsKKyNpZm5kZWYgVVNFX01FTUNQWQorCQlmb3IgKGkgPSAwOyBpIDwgNTsgaSsrKSB7CisJCQkvKiBOLkIuIHlvdSBoYXZlIHRvIGluY3JlYXNlIHRoZSBzb3VyY2UgYWRkcmVzcyBpbiB0aGlzIHdheSBvciB0aGUKKwkJCSAgIEVDQyBsb2dpYyB3aWxsIG5vdCB3b3JrIHByb3Blcmx5ICovCisJCQllY2NidWZbaV0gPSBSZWFkRE9DKGRvY3B0ciwgTWlsX0NEU05fSU8gKyBpKTsKKwkJfQorI2Vsc2UKKwkJbWVtY3B5X2Zyb21pbyhlY2NidWYsIGRvY3B0ciArIERvQ19NaWxfQ0RTTl9JTywgNSk7CisjZW5kaWYKKwkJZWNjYnVmWzVdID0gUmVhZERPQyhkb2NwdHIsIExhc3REYXRhUmVhZCk7CisKKwkJLyogRmx1c2ggdGhlIHBpcGVsaW5lICovCisJCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIEVDQ0NvbmYpOworCQlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBFQ0NDb25mKTsKKworCQkvKiBDaGVjayB0aGUgRUNDIFN0YXR1cyAqLworCQlpZiAoUmVhZERPQyhkb2NwdHIsIEVDQ0NvbmYpICYgMHg4MCkgeworICAgICAgICAgICAgICAgICAgICAgICAgaW50IG5iX2Vycm9yczsKKwkJCS8qIFRoZXJlIHdhcyBhbiBFQ0MgZXJyb3IgKi8KKyNpZmRlZiBFQ0NfREVCVUcKKwkJCXByaW50aygiRGlza09uQ2hpcCBFQ0MgRXJyb3I6IFJlYWQgYXQgJWx4XG4iLCAobG9uZylmcm9tKTsKKyNlbmRpZgorCQkJLyogUmVhZCB0aGUgRUNDIHN5bmRyb20gdGhyb3VnaCB0aGUgRGlza09uQ2hpcCBFQ0MgbG9naWMuCisJCQkgICBUaGVzZSBzeW5kcm9tZSB3aWxsIGJlIGFsbCBaRVJPIHdoZW4gdGhlcmUgaXMgbm8gZXJyb3IgKi8KKwkJCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspIHsKKwkJCQlzeW5kcm9tZVtpXSA9IFJlYWRET0MoZG9jcHRyLCBFQ0NTeW5kcm9tZTAgKyBpKTsKKwkJCX0KKyAgICAgICAgICAgICAgICAgICAgICAgIG5iX2Vycm9ycyA9IGRvY19kZWNvZGVfZWNjKGJ1Ziwgc3luZHJvbWUpOworI2lmZGVmIEVDQ19ERUJVRworCQkJcHJpbnRrKCJFQ0MgRXJyb3JzIGNvcnJlY3RlZDogJXhcbiIsIG5iX2Vycm9ycyk7CisjZW5kaWYKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChuYl9lcnJvcnMgPCAwKSB7CisJCQkJLyogV2UgcmV0dXJuIGVycm9yLCBidXQgaGF2ZSBhY3R1YWxseSBkb25lIHRoZSByZWFkLiBOb3QgdGhhdAorCQkJCSAgIHRoaXMgY2FuIGJlIHRvbGQgdG8gdXNlci1zcGFjZSwgdmlhIHN5c19yZWFkKCksIGJ1dCBhdCBsZWFzdAorCQkJCSAgIE1URC1hd2FyZSBzdHVmZiBjYW4ga25vdyBhYm91dCBpdCBieSBjaGVja2luZyAqcmV0bGVuICovCisJCQkJcmV0ID0gLUVJTzsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKwkJfQorCisjaWZkZWYgUFNZQ0hPX0RFQlVHCisJCXByaW50aygiRUNDIERBVEEgYXQgJWx4OiAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWFxuIiwKKwkJICAgICAgIChsb25nKWZyb20sIGVjY2J1ZlswXSwgZWNjYnVmWzFdLCBlY2NidWZbMl0sIGVjY2J1ZlszXSwKKwkJICAgICAgIGVjY2J1Zls0XSwgZWNjYnVmWzVdKTsKKyNlbmRpZgorCisJCS8qIGRpc2FibGUgdGhlIEVDQyBlbmdpbmUgKi8KKwkJV3JpdGVET0MoRE9DX0VDQ19ESVMsIGRvY3B0ciAsIEVDQ0NvbmYpOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgZG9jX3dyaXRlIChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLCBzaXplX3QgbGVuLAorCQkgICAgICBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpCit7CisJY2hhciBlY2NidWZbNl07CisJcmV0dXJuIGRvY193cml0ZV9lY2MobXRkLCB0bywgbGVuLCByZXRsZW4sIGJ1ZiwgZWNjYnVmLCBOVUxMKTsKK30KKworc3RhdGljIGludCBkb2Nfd3JpdGVfZWNjIChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLCBzaXplX3QgbGVuLAorCQkJICBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYsIHVfY2hhciAqZWNjYnVmLAorCQkJIHN0cnVjdCBuYW5kX29vYmluZm8gKm9vYnNlbCkKK3sKKwlpbnQgaSxyZXQgPSAwOworCXZvbGF0aWxlIGNoYXIgZHVtbXk7CisJc3RydWN0IERpc2tPbkNoaXAgKnRoaXMgPSBtdGQtPnByaXY7CisJdm9pZCBfX2lvbWVtICpkb2NwdHIgPSB0aGlzLT52aXJ0YWRyOworCXN0cnVjdCBOYW5kICpteWNoaXAgPSAmdGhpcy0+Y2hpcHNbdG8gPj4gKHRoaXMtPmNoaXBzaGlmdCldOworCisJLyogRG9uJ3QgYWxsb3cgd3JpdGUgcGFzdCBlbmQgb2YgZGV2aWNlICovCisJaWYgKHRvID49IHRoaXMtPnRvdGxlbikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKyNpZiAwCisJLyogRG9uJ3QgYWxsb3cgYSBzaW5nbGUgd3JpdGUgdG8gY3Jvc3MgYSA1MTItYnl0ZSBibG9jayBib3VuZGFyeSAqLworCWlmICh0byArIGxlbiA+ICggKHRvIHwgMHgxZmYpICsgMSkpIAorCQlsZW4gPSAoKHRvIHwgMHgxZmYpICsgMSkgLSB0bzsKKyNlbHNlCisJLyogRG9uJ3QgYWxsb3cgd3JpdGVzIHdoaWNoIGFyZW4ndCBleGFjdGx5IG9uZSBibG9jayAqLworCWlmICh0byAmIDB4MWZmIHx8IGxlbiAhPSAweDIwMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisjZW5kaWYKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKGRvY3B0ciwgbXljaGlwLT5mbG9vcik7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBSZXNldCB0aGUgY2hpcCwgc2VlIFNvZnR3YXJlIFJlcXVpcmVtZW50IDExLjQgaXRlbSAxLiAqLworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfUkVTRVQsIDB4MDApOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKwkvKiBTZXQgZGV2aWNlIHRvIG1haW4gcGxhbmUgb2YgZmxhc2ggKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1JFQUQwLCAweDAwKTsKKworCS8qIGlzc3VlIHRoZSBTZXJpYWwgRGF0YSBJbiBjb21tYW5kIHRvIGluaXRpYWwgdGhlIFBhZ2UgUHJvZ3JhbSBwcm9jZXNzICovCisJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9TRVFJTiwgMHgwMCk7CisJRG9DX0FkZHJlc3MoZG9jcHRyLCAzLCB0bywgMHgwMCwgMHgwMCk7CisJRG9DX1dhaXRSZWFkeShkb2NwdHIpOworCisJaWYgKGVjY2J1ZikgeworCQkvKiBpbml0IHRoZSBFQ0MgZW5naW5lLCBzZWUgUmVlZC1Tb2xvbW9uIEVEQy9FQ0MgMTEuMSAuKi8KKwkJV3JpdGVET0MgKERPQ19FQ0NfUkVTRVQsIGRvY3B0ciwgRUNDQ29uZik7CisJCVdyaXRlRE9DIChET0NfRUNDX0VOIHwgRE9DX0VDQ19SVywgZG9jcHRyLCBFQ0NDb25mKTsKKwl9IGVsc2UgeworCQkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJCVdyaXRlRE9DIChET0NfRUNDX1JFU0VULCBkb2NwdHIsIEVDQ0NvbmYpOworCQlXcml0ZURPQyAoRE9DX0VDQ19ESVMsIGRvY3B0ciwgRUNDQ29uZik7CisJfQorCisJLyogV3JpdGUgdGhlIGRhdGEgdmlhIHRoZSBpbnRlcm5hbCBwaXBlbGluZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIsCisJICAgc2VlIFBpcGVsaW5lZCBXcml0ZSBPcGVyYXRpb25zIDExLjIgKi8KKyNpZm5kZWYgVVNFX01FTUNQWQorCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykgeworCQkvKiBOLkIuIHlvdSBoYXZlIHRvIGluY3JlYXNlIHRoZSBzb3VyY2UgYWRkcmVzcyBpbiB0aGlzIHdheSBvciB0aGUKKwkJICAgRUNDIGxvZ2ljIHdpbGwgbm90IHdvcmsgcHJvcGVybHkgKi8KKwkJV3JpdGVET0MoYnVmW2ldLCBkb2NwdHIsIE1pbF9DRFNOX0lPICsgaSk7CisJfQorI2Vsc2UKKwltZW1jcHlfdG9pbyhkb2NwdHIgKyBEb0NfTWlsX0NEU05fSU8sIGJ1ZiwgbGVuKTsKKyNlbmRpZgorCVdyaXRlRE9DKDB4MDAsIGRvY3B0ciwgV3JpdGVQaXBlVGVybSk7CisKKwlpZiAoZWNjYnVmKSB7CisJCS8qIFdyaXRlIEVDQyBkYXRhIHRvIGZsYXNoLCB0aGUgRUNDIGluZm8gaXMgZ2VuZXJhdGVkIGJ5IHRoZSBEaXNrT25DaGlwIEVDQyBsb2dpYworCQkgICBzZWUgUmVlZC1Tb2xvbW9uIEVEQy9FQ0MgMTEuMSAqLworCQlXcml0ZURPQygwLCBkb2NwdHIsIE5PUCk7CisJCVdyaXRlRE9DKDAsIGRvY3B0ciwgTk9QKTsKKwkJV3JpdGVET0MoMCwgZG9jcHRyLCBOT1ApOworCisJCS8qIFJlYWQgdGhlIEVDQyBkYXRhIHRocm91Z2ggdGhlIERpc2tPbkNoaXAgRUNDIGxvZ2ljICovCisJCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspIHsKKwkJCWVjY2J1ZltpXSA9IFJlYWRET0MoZG9jcHRyLCBFQ0NTeW5kcm9tZTAgKyBpKTsKKwkJfQorCisJCS8qIGlnbm9yZSB0aGUgRUNDIGVuZ2luZSAqLworCQlXcml0ZURPQyhET0NfRUNDX0RJUywgZG9jcHRyICwgRUNDQ29uZik7CisKKyNpZm5kZWYgVVNFX01FTUNQWQorCQkvKiBXcml0ZSB0aGUgRUNDIGRhdGEgdG8gZmxhc2ggKi8KKwkJZm9yIChpID0gMDsgaSA8IDY7IGkrKykgeworCQkJLyogTi5CLiB5b3UgaGF2ZSB0byBpbmNyZWFzZSB0aGUgc291cmNlIGFkZHJlc3MgaW4gdGhpcyB3YXkgb3IgdGhlCisJCQkgICBFQ0MgbG9naWMgd2lsbCBub3Qgd29yayBwcm9wZXJseSAqLworCQkJV3JpdGVET0MoZWNjYnVmW2ldLCBkb2NwdHIsIE1pbF9DRFNOX0lPICsgaSk7CisJCX0KKyNlbHNlCisJCW1lbWNweV90b2lvKGRvY3B0ciArIERvQ19NaWxfQ0RTTl9JTywgZWNjYnVmLCA2KTsKKyNlbmRpZgorCisJCS8qIHdyaXRlIHRoZSBibG9jayBzdGF0dXMgQkxPQ0tfVVNFRCAoMHg1NTU1KSBhdCB0aGUgZW5kIG9mIEVDQyBkYXRhCisJCSAgIEZJWE1FOiB0aGlzIGlzIG9ubHkgYSBoYWNrIGZvciBwcm9ncmFtbWluZyB0aGUgSVBMIGFyZWEgZm9yIExpbnV4QklPUworCQkgICBhbmQgc2hvdWxkIGJlIHJlcGxhY2Ugd2l0aCBwcm9wZXIgY29kZXMgaW4gdXNlciBzcGFjZSB1dGlsaXRpZXMgKi8gCisJCVdyaXRlRE9DKDB4NTUsIGRvY3B0ciwgTWlsX0NEU05fSU8pOworCQlXcml0ZURPQygweDU1LCBkb2NwdHIsIE1pbF9DRFNOX0lPICsgMSk7CisKKwkJV3JpdGVET0MoMHgwMCwgZG9jcHRyLCBXcml0ZVBpcGVUZXJtKTsKKworI2lmZGVmIFBTWUNIT19ERUJVRworCQlwcmludGsoIk9PQiBkYXRhIGF0ICVseCBpcyAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWFxuIiwKKwkJICAgICAgIChsb25nKSB0bywgZWNjYnVmWzBdLCBlY2NidWZbMV0sIGVjY2J1ZlsyXSwgZWNjYnVmWzNdLAorCQkgICAgICAgZWNjYnVmWzRdLCBlY2NidWZbNV0pOworI2VuZGlmCisJfQorCisJLyogQ29tbWl0IHRoZSBQYWdlIFByb2dyYW0gY29tbWFuZCBhbmQgd2FpdCBmb3IgcmVhZHkKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDEuKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1BBR0VQUk9HLCAweDAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwkvKiBSZWFkIHRoZSBzdGF0dXMgb2YgdGhlIGZsYXNoIGRldmljZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDUuKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1NUQVRVUywgQ0RTTl9DVFJMX1dQKTsKKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBSZWFkUGlwZUluaXQpOworCURvQ19EZWxheShkb2NwdHIsIDIpOworCWlmIChSZWFkRE9DKGRvY3B0ciwgTWlsX0NEU05fSU8pICYgMSkgeworCQlwcmludGsoIkVycm9yIHByb2dyYW1taW5nIGZsYXNoXG4iKTsKKwkJLyogRXJyb3IgaW4gcHJvZ3JhbW1pbmcKKwkJICAgRklYTUU6IGltcGxlbWVudCBCYWQgQmxvY2sgUmVwbGFjZW1lbnQgKGluIG5mdGwuYyA/PykgKi8KKwkJKnJldGxlbiA9IDA7CisJCXJldCA9IC1FSU87CisJfQorCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIExhc3REYXRhUmVhZCk7CisKKwkvKiBMZXQgdGhlIGNhbGxlciBrbm93IHdlIGNvbXBsZXRlZCBpdCAqLworCSpyZXRsZW4gPSBsZW47CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGRvY19yZWFkX29vYihzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IG9mcywgc2l6ZV90IGxlbiwKKwkJCXNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZikKK3sKKyNpZm5kZWYgVVNFX01FTUNQWQorCWludCBpOworI2VuZGlmCisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwl2b2lkIF9faW9tZW0gKmRvY3B0ciA9IHRoaXMtPnZpcnRhZHI7CisJc3RydWN0IE5hbmQgKm15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tvZnMgPj4gdGhpcy0+Y2hpcHNoaWZ0XTsKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKGRvY3B0ciwgbXljaGlwLT5mbG9vcik7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJV3JpdGVET0MgKERPQ19FQ0NfUkVTRVQsIGRvY3B0ciwgRUNDQ29uZik7CisJV3JpdGVET0MgKERPQ19FQ0NfRElTLCBkb2NwdHIsIEVDQ0NvbmYpOworCisJLyogaXNzdWUgdGhlIFJlYWQyIGNvbW1hbmQgdG8gc2V0IHRoZSBwb2ludGVyIHRvIHRoZSBTcGFyZSBEYXRhIEFyZWEuCisJICAgUG9sbGluZyB0aGUgRmxhc2ggUmVhZHkgYml0IGFmdGVyIGlzc3VlIDMgYnl0ZXMgYWRkcmVzcyBpbgorCSAgIFNlcXVlbmNlIFJlYWQgTW9kZSwgc2VlIFNvZnR3YXJlIFJlcXVpcmVtZW50IDExLjQgaXRlbSAxLiovCisJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9SRUFET09CLCBDRFNOX0NUUkxfV1ApOworCURvQ19BZGRyZXNzKGRvY3B0ciwgMywgb2ZzLCBDRFNOX0NUUkxfV1AsIDB4MDApOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCS8qIFJlYWQgdGhlIGRhdGEgb3V0IHZpYSB0aGUgaW50ZXJuYWwgcGlwZWxpbmUgdGhyb3VnaCBDRFNOIElPIHJlZ2lzdGVyLAorCSAgIHNlZSBQaXBlbGluZWQgUmVhZCBPcGVyYXRpb25zIDExLjMgKi8KKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBSZWFkUGlwZUluaXQpOworI2lmbmRlZiBVU0VfTUVNQ1BZCisJZm9yIChpID0gMDsgaSA8IGxlbi0xOyBpKyspIHsKKwkJLyogTi5CLiB5b3UgaGF2ZSB0byBpbmNyZWFzZSB0aGUgc291cmNlIGFkZHJlc3MgaW4gdGhpcyB3YXkgb3IgdGhlCisJCSAgIEVDQyBsb2dpYyB3aWxsIG5vdCB3b3JrIHByb3Blcmx5ICovCisJCWJ1ZltpXSA9IFJlYWRET0MoZG9jcHRyLCBNaWxfQ0RTTl9JTyArIGkpOworCX0KKyNlbHNlCisJbWVtY3B5X2Zyb21pbyhidWYsIGRvY3B0ciArIERvQ19NaWxfQ0RTTl9JTywgbGVuIC0gMSk7CisjZW5kaWYKKwlidWZbbGVuIC0gMV0gPSBSZWFkRE9DKGRvY3B0ciwgTGFzdERhdGFSZWFkKTsKKworCSpyZXRsZW4gPSBsZW47CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBkb2Nfd3JpdGVfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQkJIHNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1ZikKK3sKKyNpZm5kZWYgVVNFX01FTUNQWQorCWludCBpOworI2VuZGlmCisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwlpbnQgcmV0ID0gMDsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwl2b2lkIF9faW9tZW0gKmRvY3B0ciA9IHRoaXMtPnZpcnRhZHI7CisJc3RydWN0IE5hbmQgKm15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tvZnMgPj4gdGhpcy0+Y2hpcHNoaWZ0XTsKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKGRvY3B0ciwgbXljaGlwLT5mbG9vcik7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJV3JpdGVET0MgKERPQ19FQ0NfUkVTRVQsIGRvY3B0ciwgRUNDQ29uZik7CisJV3JpdGVET0MgKERPQ19FQ0NfRElTLCBkb2NwdHIsIEVDQ0NvbmYpOworCisJLyogUmVzZXQgdGhlIGNoaXAsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4gKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1JFU0VULCBDRFNOX0NUUkxfV1ApOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKwkvKiBpc3N1ZSB0aGUgUmVhZDIgY29tbWFuZCB0byBzZXQgdGhlIHBvaW50ZXIgdG8gdGhlIFNwYXJlIERhdGEgQXJlYS4gKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1JFQURPT0IsIENEU05fQ1RSTF9XUCk7CisKKwkvKiBpc3N1ZSB0aGUgU2VyaWFsIERhdGEgSW4gY29tbWFuZCB0byBpbml0aWFsIHRoZSBQYWdlIFByb2dyYW0gcHJvY2VzcyAqLworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfU0VRSU4sIDB4MDApOworCURvQ19BZGRyZXNzKGRvY3B0ciwgMywgb2ZzLCAweDAwLCAweDAwKTsKKworCS8qIFdyaXRlIHRoZSBkYXRhIHZpYSB0aGUgaW50ZXJuYWwgcGlwZWxpbmUgdGhyb3VnaCBDRFNOIElPIHJlZ2lzdGVyLAorCSAgIHNlZSBQaXBlbGluZWQgV3JpdGUgT3BlcmF0aW9ucyAxMS4yICovCisjaWZuZGVmIFVTRV9NRU1DUFkKKwlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKKwkJLyogTi5CLiB5b3UgaGF2ZSB0byBpbmNyZWFzZSB0aGUgc291cmNlIGFkZHJlc3MgaW4gdGhpcyB3YXkgb3IgdGhlCisJCSAgIEVDQyBsb2dpYyB3aWxsIG5vdCB3b3JrIHByb3Blcmx5ICovCisJCVdyaXRlRE9DKGJ1ZltpXSwgZG9jcHRyLCBNaWxfQ0RTTl9JTyArIGkpOworCX0KKyNlbHNlCisJbWVtY3B5X3RvaW8oZG9jcHRyICsgRG9DX01pbF9DRFNOX0lPLCBidWYsIGxlbik7CisjZW5kaWYKKwlXcml0ZURPQygweDAwLCBkb2NwdHIsIFdyaXRlUGlwZVRlcm0pOworCisJLyogQ29tbWl0IHRoZSBQYWdlIFByb2dyYW0gY29tbWFuZCBhbmQgd2FpdCBmb3IgcmVhZHkKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDEuKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1BBR0VQUk9HLCAweDAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwkvKiBSZWFkIHRoZSBzdGF0dXMgb2YgdGhlIGZsYXNoIGRldmljZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDUuKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1NUQVRVUywgMHgwMCk7CisJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgUmVhZFBpcGVJbml0KTsKKwlEb0NfRGVsYXkoZG9jcHRyLCAyKTsKKwlpZiAoUmVhZERPQyhkb2NwdHIsIE1pbF9DRFNOX0lPKSAmIDEpIHsKKwkJcHJpbnRrKCJFcnJvciBwcm9ncmFtbWluZyBvb2IgZGF0YVxuIik7CisJCS8qIEZJWE1FOiBpbXBsZW1lbnQgQmFkIEJsb2NrIFJlcGxhY2VtZW50IChpbiBuZnRsLmMgPz8pICovCisJCSpyZXRsZW4gPSAwOworCQlyZXQgPSAtRUlPOworCX0KKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBMYXN0RGF0YVJlYWQpOworCisJKnJldGxlbiA9IGxlbjsKKworCXJldHVybiByZXQ7Cit9CisKK2ludCBkb2NfZXJhc2UgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpCit7CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwlfX3UzMiBvZnMgPSBpbnN0ci0+YWRkcjsKKwlfX3UzMiBsZW4gPSBpbnN0ci0+bGVuOworCXZvaWQgX19pb21lbSAqZG9jcHRyID0gdGhpcy0+dmlydGFkcjsKKwlzdHJ1Y3QgTmFuZCAqbXljaGlwID0gJnRoaXMtPmNoaXBzW29mcyA+PiB0aGlzLT5jaGlwc2hpZnRdOworCisJaWYgKGxlbiAhPSBtdGQtPmVyYXNlc2l6ZSkgCisJCXByaW50ayhLRVJOX1dBUk5JTkcgIkVyYXNlIG5vdCByaWdodCBzaXplICgleCAhPSAleCluIiwKKwkJICAgICAgIGxlbiwgbXRkLT5lcmFzZXNpemUpOworCisJLyogRmluZCB0aGUgY2hpcCB3aGljaCBpcyB0byBiZSB1c2VkIGFuZCBzZWxlY3QgaXQgKi8KKwlpZiAodGhpcy0+Y3VyZmxvb3IgIT0gbXljaGlwLT5mbG9vcikgeworCQlEb0NfU2VsZWN0Rmxvb3IoZG9jcHRyLCBteWNoaXAtPmZsb29yKTsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0gZWxzZSBpZiAodGhpcy0+Y3VyY2hpcCAhPSBteWNoaXAtPmNoaXApIHsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0KKwl0aGlzLT5jdXJmbG9vciA9IG15Y2hpcC0+Zmxvb3I7CisJdGhpcy0+Y3VyY2hpcCA9IG15Y2hpcC0+Y2hpcDsKKworCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9QRU5ESU5HOworCisJLyogaXNzdWUgdGhlIEVyYXNlIFNldHVwIGNvbW1hbmQgKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX0VSQVNFMSwgMHgwMCk7CisJRG9DX0FkZHJlc3MoZG9jcHRyLCAyLCBvZnMsIDB4MDAsIDB4MDApOworCisJLyogQ29tbWl0IHRoZSBFcmFzZSBTdGFydCBjb21tYW5kIGFuZCB3YWl0IGZvciByZWFkeQorCSAgIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4qLworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfRVJBU0UyLCAweDAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0lORzsKKworCS8qIFJlYWQgdGhlIHN0YXR1cyBvZiB0aGUgZmxhc2ggZGV2aWNlIHRocm91Z2ggQ0RTTiBJTyByZWdpc3RlcgorCSAgIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gNS4KKwkgICBGSVhNRTogaXQgc2VlbXMgdGhhdCB3ZSBhcmUgbm90IHdhaXQgbG9uZyBlbm91Z2gsIHNvbWUgYmxvY2tzIGFyZSBub3QKKwkgICBlcmFzZWQgZnVsbHkgKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1NUQVRVUywgQ0RTTl9DVFJMX1dQKTsKKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBSZWFkUGlwZUluaXQpOworCURvQ19EZWxheShkb2NwdHIsIDIpOworCWlmIChSZWFkRE9DKGRvY3B0ciwgTWlsX0NEU05fSU8pICYgMSkgeworCQlwcmludGsoIkVycm9yIEVyYXNpbmcgYXQgMHgleFxuIiwgb2ZzKTsKKwkJLyogVGhlcmUgd2FzIGFuIGVycm9yCisJCSAgIEZJWE1FOiBpbXBsZW1lbnQgQmFkIEJsb2NrIFJlcGxhY2VtZW50IChpbiBuZnRsLmMgPz8pICovCisJCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9GQUlMRUQ7CisJfSBlbHNlCisJCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9ET05FOworCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIExhc3REYXRhUmVhZCk7CisKKwltdGRfZXJhc2VfY2FsbGJhY2soaW5zdHIpOworCisJcmV0dXJuIDA7Cit9CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogTW9kdWxlIHN0dWZmCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBpbnQgX19pbml0IGluaXRfZG9jMjAwMSh2b2lkKQoreworCWludGVyX21vZHVsZV9yZWdpc3RlcihpbV9uYW1lLCBUSElTX01PRFVMRSwgJkRvQ01pbF9pbml0KTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGNsZWFudXBfZG9jMjAwMSh2b2lkKQoreworCXN0cnVjdCBtdGRfaW5mbyAqbXRkOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzOworCisJd2hpbGUgKChtdGQ9ZG9jbWlsbGlzdCkpIHsKKwkJdGhpcyA9IG10ZC0+cHJpdjsKKwkJZG9jbWlsbGlzdCA9IHRoaXMtPm5leHRkb2M7CisJCQkKKwkJZGVsX210ZF9kZXZpY2UobXRkKTsKKwkJCQorCQlpb3VubWFwKHRoaXMtPnZpcnRhZHIpOworCQlrZnJlZSh0aGlzLT5jaGlwcyk7CisJCWtmcmVlKG10ZCk7CisJfQorCWludGVyX21vZHVsZV91bnJlZ2lzdGVyKGltX25hbWUpOworfQorCittb2R1bGVfZXhpdChjbGVhbnVwX2RvYzIwMDEpOworbW9kdWxlX2luaXQoaW5pdF9kb2MyMDAxKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiRGF2aWQgV29vZGhvdXNlIDxkd213MkBpbmZyYWRlYWQub3JnPiBldCBhbC4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiQWx0ZXJuYXRpdmUgZHJpdmVyIGZvciBEaXNrT25DaGlwIE1pbGxlbm5pdW0iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jMjAwMXBsdXMuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jMjAwMXBsdXMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZDQ3YmFmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2MyMDAxcGx1cy5jCkBAIC0wLDAgKzEsMTE1NCBAQAorLyoKKyAqIExpbnV4IGRyaXZlciBmb3IgRGlzay1Pbi1DaGlwIE1pbGxlbm5pdW0gUGx1cworICoKKyAqIChjKSAyMDAyLTIwMDMgR3JlZyBVbmdlcmVyIDxnZXJnQHNuYXBnZWFyLmNvbT4KKyAqIChjKSAyMDAyLTIwMDMgU25hcEdlYXIgSW5jCisgKiAoYykgMTk5OSBNYWNoaW5lIFZpc2lvbiBIb2xkaW5ncywgSW5jLgorICogKGMpIDE5OTksIDIwMDAgRGF2aWQgV29vZGhvdXNlIDxkd213MkBpbmZyYWRlYWQub3JnPgorICoKKyAqICRJZDogZG9jMjAwMXBsdXMuYyx2IDEuMTMgMjAwNS8wMS8wNSAxODowNToxMiBkd213MiBFeHAgJAorICoKKyAqIFJlbGVhc2VkIHVuZGVyIEdQTAorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxhc20vZXJybm8uaD4KKyNpbmNsdWRlIDxhc20vaW8uaD4KKyNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgorI2luY2x1ZGUgPGxpbnV4L21pc2NkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgorCisjaW5jbHVkZSA8bGludXgvbXRkL210ZC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9uYW5kLmg+CisjaW5jbHVkZSA8bGludXgvbXRkL2RvYzIwMDAuaD4KKworLyogI2RlZmluZSBFQ0NfREVCVUcgKi8KKworLyogSSBoYXZlIG5vIGlkZWEgd2h5IHNvbWUgRG9DIGNoaXBzIGNhbiBub3QgdXNlIG1lbWNvcF9mb3JtfHRvX2lvKCkuCisgKiBUaGlzIG1heSBiZSBkdWUgdG8gdGhlIGRpZmZlcmVudCByZXZpc2lvbnMgb2YgdGhlIEFTSUMgY29udHJvbGxlciBidWlsdC1pbiBvcgorICogc2ltcGxpbHkgYSBRQS9CdWcgaXNzdWUuIFdobyBrbm93cyA/PyBJZiB5b3UgaGF2ZSB0cm91YmxlLCBwbGVhc2UgdW5jb21tZW50CisgKiB0aGlzOiovCisjdW5kZWYgVVNFX01FTUNQWQorCitzdGF0aWMgaW50IGRvY19yZWFkKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwKKwkJc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKTsKK3N0YXRpYyBpbnQgZG9jX3dyaXRlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgdG8sIHNpemVfdCBsZW4sCisJCXNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1Zik7CitzdGF0aWMgaW50IGRvY19yZWFkX2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCXNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZiwgdV9jaGFyICplY2NidWYsCisJCXN0cnVjdCBuYW5kX29vYmluZm8gKm9vYnNlbCk7CitzdGF0aWMgaW50IGRvY193cml0ZV9lY2Moc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJc2l6ZV90ICpyZXRsZW4sIGNvbnN0IHVfY2hhciAqYnVmLCB1X2NoYXIgKmVjY2J1ZiwKKwkJc3RydWN0IG5hbmRfb29iaW5mbyAqb29ic2VsKTsKK3N0YXRpYyBpbnQgZG9jX3JlYWRfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQlzaXplX3QgKnJldGxlbiwgdV9jaGFyICpidWYpOworc3RhdGljIGludCBkb2Nfd3JpdGVfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQlzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpOworc3RhdGljIGludCBkb2NfZXJhc2UgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpOworCitzdGF0aWMgc3RydWN0IG10ZF9pbmZvICpkb2NtaWxwbHVzbGlzdCA9IE5VTEw7CisKKworLyogUGVyZm9ybSB0aGUgcmVxdWlyZWQgZGVsYXkgY3ljbGVzIGJ5IHdyaXRpbmcgdG8gdGhlIE5PUCByZWdpc3RlciAqLworc3RhdGljIHZvaWQgRG9DX0RlbGF5KHZvaWQgX19pb21lbSAqIGRvY3B0ciwgaW50IGN5Y2xlcykKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IChpIDwgY3ljbGVzKTsgaSsrKQorCQlXcml0ZURPQygwLCBkb2NwdHIsIE1wbHVzX05PUCk7Cit9CisKKyNkZWZpbmUJQ0RTTl9DVFJMX0ZSX0JfTUFTSwkoQ0RTTl9DVFJMX0ZSX0IwIHwgQ0RTTl9DVFJMX0ZSX0IxKQorCisvKiBET0NfV2FpdFJlYWR5OiBXYWl0IGZvciBSRFkgbGluZSB0byBiZSBhc3NlcnRlZCBieSB0aGUgZmxhc2ggY2hpcCAqLworc3RhdGljIGludCBfRG9DX1dhaXRSZWFkeSh2b2lkIF9faW9tZW0gKiBkb2NwdHIpCit7CisJdW5zaWduZWQgaW50IGMgPSAweGZmZmY7CisKKwlERUJVRyhNVERfREVCVUdfTEVWRUwzLAorCSAgICAgICJfRG9DX1dhaXRSZWFkeSBjYWxsZWQgZm9yIG91dC1vZi1saW5lIHdhaXRcbiIpOworCisJLyogT3V0LW9mLWxpbmUgcm91dGluZSB0byB3YWl0IGZvciBjaGlwIHJlc3BvbnNlICovCisJd2hpbGUgKCgoUmVhZERPQyhkb2NwdHIsIE1wbHVzX0ZsYXNoQ29udHJvbCkgJiBDRFNOX0NUUkxfRlJfQl9NQVNLKSAhPSBDRFNOX0NUUkxfRlJfQl9NQVNLKSAmJiAtLWMpCisJCTsKKworCWlmIChjID09IDApCisJCURFQlVHKE1URF9ERUJVR19MRVZFTDIsICJfRG9DX1dhaXRSZWFkeSB0aW1lZCBvdXQuXG4iKTsKKworCXJldHVybiAoYyA9PSAwKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgRG9DX1dhaXRSZWFkeSh2b2lkIF9faW9tZW0gKiBkb2NwdHIpCit7CisJLyogVGhpcyBpcyBpbmxpbmUsIHRvIG9wdGltaXNlIHRoZSBjb21tb24gY2FzZSwgd2hlcmUgaXQncyByZWFkeSBpbnN0YW50bHkgKi8KKwlpbnQgcmV0ID0gMDsKKworCS8qIHJlYWQgZm9ybSBOT1AgcmVnaXN0ZXIgc2hvdWxkIGJlIGlzc3VlZCBwcmlvciB0byB0aGUgcmVhZCBmcm9tIENEU05Db250cm9sCisJICAgc2VlIFNvZnR3YXJlIFJlcXVpcmVtZW50IDExLjQgaXRlbSAyLiAqLworCURvQ19EZWxheShkb2NwdHIsIDQpOworCisJaWYgKChSZWFkRE9DKGRvY3B0ciwgTXBsdXNfRmxhc2hDb250cm9sKSAmIENEU05fQ1RSTF9GUl9CX01BU0spICE9IENEU05fQ1RSTF9GUl9CX01BU0spCisJCS8qIENhbGwgdGhlIG91dC1vZi1saW5lIHJvdXRpbmUgdG8gd2FpdCAqLworCQlyZXQgPSBfRG9DX1dhaXRSZWFkeShkb2NwdHIpOworCisJcmV0dXJuIHJldDsKK30KKworLyogRm9yIHNvbWUgcmVhc29uIHRoZSBNaWxsZW5uaXVtIFBsdXMgc2VlbXMgdG8gb2NjYXNzaW9uYWxseSBwdXQgaXRzZWxmCisgKiBpbnRvIHJlc2V0IG1vZGUuIEZvciBtZSB0aGlzIGhhcHBlbnMgcmFuZG9tbHksIHdpdGggbm8gcGF0dGVybiB0aGF0IEkKKyAqIGNhbiBkZXRlY3QuIE0tc3lzdGVtcyBzdWdnZXN0IGFsd2F5cyBjaGVjayB0aGlzIG9uIGFueSBibG9jayBsZXZlbAorICogb3BlcmF0aW9uIGFuZCBzZXR0aW5nIHRvIG5vcm1hbCBtb2RlIGlmIGluIHJlc2V0IG1vZGUuCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBEb0NfQ2hlY2tBU0lDKHZvaWQgX19pb21lbSAqIGRvY3B0cikKK3sKKwkvKiBNYWtlIHN1cmUgdGhlIERvQyBpcyBpbiBub3JtYWwgbW9kZSAqLworCWlmICgoUmVhZERPQyhkb2NwdHIsIE1wbHVzX0RPQ0NvbnRyb2wpICYgRE9DX01PREVfTk9STUFMKSA9PSAwKSB7CisJCVdyaXRlRE9DKChET0NfTU9ERV9OT1JNQUwgfCBET0NfTU9ERV9NRFdSRU4pLCBkb2NwdHIsIE1wbHVzX0RPQ0NvbnRyb2wpOworCQlXcml0ZURPQyh+KERPQ19NT0RFX05PUk1BTCB8IERPQ19NT0RFX01EV1JFTiksIGRvY3B0ciwgTXBsdXNfQ3RybENvbmZpcm0pOworCX0KK30KKworLyogRG9DX0NvbW1hbmQ6IFNlbmQgYSBmbGFzaCBjb21tYW5kIHRvIHRoZSBmbGFzaCBjaGlwIHRocm91Z2ggdGhlIEZsYXNoCisgKiBjb21tYW5kIHJlZ2lzdGVyLiBOZWVkIDIgV3JpdGUgUGlwZWxpbmUgVGVybWluYXRlcyB0byBjb21wbGV0ZSBzZW5kLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgRG9DX0NvbW1hbmQodm9pZCBfX2lvbWVtICogZG9jcHRyLCB1bnNpZ25lZCBjaGFyIGNvbW1hbmQsCisJCQkgICAgICAgdW5zaWduZWQgY2hhciB4dHJhZmxhZ3MpCit7CisJV3JpdGVET0MoY29tbWFuZCwgZG9jcHRyLCBNcGx1c19GbGFzaENtZCk7CisJV3JpdGVET0MoY29tbWFuZCwgZG9jcHRyLCBNcGx1c19Xcml0ZVBpcGVUZXJtKTsKKwlXcml0ZURPQyhjb21tYW5kLCBkb2NwdHIsIE1wbHVzX1dyaXRlUGlwZVRlcm0pOworfQorCisvKiBEb0NfQWRkcmVzczogU2V0IHRoZSBjdXJyZW50IGFkZHJlc3MgZm9yIHRoZSBmbGFzaCBjaGlwIHRocm91Z2ggdGhlIEZsYXNoCisgKiBBZGRyZXNzIHJlZ2lzdGVyLiBOZWVkIDIgV3JpdGUgUGlwZWxpbmUgVGVybWluYXRlcyB0byBjb21wbGV0ZSBzZW5kLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgRG9DX0FkZHJlc3Moc3RydWN0IERpc2tPbkNoaXAgKmRvYywgaW50IG51bWJ5dGVzLAorCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgb2ZzLCB1bnNpZ25lZCBjaGFyIHh0cmFmbGFnczEsCisJCQkgICAgICAgdW5zaWduZWQgY2hhciB4dHJhZmxhZ3MyKQoreworCXZvaWQgX19pb21lbSAqIGRvY3B0ciA9IGRvYy0+dmlydGFkcjsKKworCS8qIEFsbG93IGZvciBwb3NzaWJsZSBNaWxsIFBsdXMgaW50ZXJuYWwgZmxhc2ggaW50ZXJsZWF2aW5nICovCisJb2ZzID4+PSBkb2MtPmludGVybGVhdmU7CisKKwlzd2l0Y2ggKG51bWJ5dGVzKSB7CisJY2FzZSAxOgorCQkvKiBTZW5kIHNpbmdsZSBieXRlLCBiaXRzIDAtNy4gKi8KKwkJV3JpdGVET0Mob2ZzICYgMHhmZiwgZG9jcHRyLCBNcGx1c19GbGFzaEFkZHJlc3MpOworCQlicmVhazsKKwljYXNlIDI6CisJCS8qIFNlbmQgYml0cyA5LTE2IGZvbGxvd2VkIGJ5IDE3LTIzICovCisJCVdyaXRlRE9DKChvZnMgPj4gOSkgICYgMHhmZiwgZG9jcHRyLCBNcGx1c19GbGFzaEFkZHJlc3MpOworCQlXcml0ZURPQygob2ZzID4+IDE3KSAmIDB4ZmYsIGRvY3B0ciwgTXBsdXNfRmxhc2hBZGRyZXNzKTsKKwkJYnJlYWs7CisJY2FzZSAzOgorCQkvKiBTZW5kIDAtNywgOS0xNiwgdGhlbiAxNy0yMyAqLworCQlXcml0ZURPQyhvZnMgJiAweGZmLCBkb2NwdHIsIE1wbHVzX0ZsYXNoQWRkcmVzcyk7CisJCVdyaXRlRE9DKChvZnMgPj4gOSkgICYgMHhmZiwgZG9jcHRyLCBNcGx1c19GbGFzaEFkZHJlc3MpOworCQlXcml0ZURPQygob2ZzID4+IDE3KSAmIDB4ZmYsIGRvY3B0ciwgTXBsdXNfRmxhc2hBZGRyZXNzKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0dXJuOworCX0KKworCVdyaXRlRE9DKDB4MDAsIGRvY3B0ciwgTXBsdXNfV3JpdGVQaXBlVGVybSk7CisJV3JpdGVET0MoMHgwMCwgZG9jcHRyLCBNcGx1c19Xcml0ZVBpcGVUZXJtKTsKK30KKworLyogRG9DX1NlbGVjdENoaXA6IFNlbGVjdCBhIGdpdmVuIGZsYXNoIGNoaXAgd2l0aGluIHRoZSBjdXJyZW50IGZsb29yICovCitzdGF0aWMgaW50IERvQ19TZWxlY3RDaGlwKHZvaWQgX19pb21lbSAqIGRvY3B0ciwgaW50IGNoaXApCit7CisJLyogTm8gY2hvaWNlIGZvciBmbGFzaCBjaGlwIG9uIE1pbGxlbm5pdW0gUGx1cyAqLworCXJldHVybiAwOworfQorCisvKiBEb0NfU2VsZWN0Rmxvb3I6IFNlbGVjdCBhIGdpdmVuIGZsb29yIChiYW5rIG9mIGZsYXNoIGNoaXBzKSAqLworc3RhdGljIGludCBEb0NfU2VsZWN0Rmxvb3Iodm9pZCBfX2lvbWVtICogZG9jcHRyLCBpbnQgZmxvb3IpCit7CisJV3JpdGVET0MoKGZsb29yICYgMHgzKSwgZG9jcHRyLCBNcGx1c19EZXZpY2VTZWxlY3QpOworCXJldHVybiAwOworfQorCisvKgorICogVHJhbnNsYXRlIHRoZSBnaXZlbiBvZmZzZXQgaW50byB0aGUgYXBwcm9wcmlhdGUgY29tbWFuZCBhbmQgb2Zmc2V0LgorICogVGhpcyBkb2VzIHRoZSBtYXBwaW5nIHVzaW5nIHRoZSAxNmJpdCBpbnRlcmxlYXZlIGxheW91dCBkZWZpbmVkIGJ5CisgKiBNLVN5c3RlbXMsIGFuZCBsb29rcyBsaWtlIHRoaXMgZm9yIGEgc2VjdG9yIHBhaXI6CisgKiAgKy0tLS0tLS0tLS0tKy0tLS0tLS0rLS0tLS0tLSstLS0tLS0tKy0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0tLSsKKyAqICB8IDAgLS0tIDUxMSB8NTEyLTUxN3w1MTgtNTE5fDUyMC01MjF8IDUyMiAtLS0gMTAzMyB8MTAzNC0xMDM5fDEwNDAgLSAxMDU1fAorICogICstLS0tLS0tLS0tLSstLS0tLS0tKy0tLS0tLS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tLS0rCisgKiAgfCBEYXRhIDAgICAgfCBFQ0MgMCB8RmxhZ3MwIHxGbGFnczEgfCBEYXRhIDEgICAgICAgfEVDQyAxICAgIHwgT09CIDEgKyAyIHwKKyAqICArLS0tLS0tLS0tLS0rLS0tLS0tLSstLS0tLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLS0tKworICovCisvKiBGSVhNRTogVGhpcyBsaXZlcyBpbiBJTkZUTCBub3QgaGVyZS4gT3RoZXIgdXNlcnMgb2YgZmxhc2ggZGV2aWNlcworICAgbWF5IG5vdCB3YW50IGl0ICovCitzdGF0aWMgdW5zaWduZWQgaW50IERvQ19HZXREYXRhT2Zmc2V0KHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgKmZyb20pCit7CisJc3RydWN0IERpc2tPbkNoaXAgKnRoaXMgPSBtdGQtPnByaXY7CisKKwlpZiAodGhpcy0+aW50ZXJsZWF2ZSkgeworCQl1bnNpZ25lZCBpbnQgb2ZzID0gKmZyb20gJiAweDNmZjsKKwkJdW5zaWduZWQgaW50IGNtZDsKKworCQlpZiAob2ZzIDwgNTEyKSB7CisJCQljbWQgPSBOQU5EX0NNRF9SRUFEMDsKKwkJCW9mcyAmPSAweDFmZjsKKwkJfSBlbHNlIGlmIChvZnMgPCAxMDE0KSB7CisJCQljbWQgPSBOQU5EX0NNRF9SRUFEMTsKKwkJCW9mcyA9IChvZnMgJiAweDFmZikgKyAxMDsKKwkJfSBlbHNlIHsKKwkJCWNtZCA9IE5BTkRfQ01EX1JFQURPT0I7CisJCQlvZnMgPSBvZnMgLSAxMDE0OworCQl9CisKKwkJKmZyb20gPSAoKmZyb20gJiB+MHgzZmYpIHwgb2ZzOworCQlyZXR1cm4gY21kOworCX0gZWxzZSB7CisJCS8qIE5vIGludGVybGVhdmUgKi8KKwkJaWYgKCgqZnJvbSkgJiAweDEwMCkKKwkJCXJldHVybiBOQU5EX0NNRF9SRUFEMTsKKwkJcmV0dXJuIE5BTkRfQ01EX1JFQUQwOworCX0KK30KKworc3RhdGljIHVuc2lnbmVkIGludCBEb0NfR2V0RUNDT2Zmc2V0KHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgKmZyb20pCit7CisJdW5zaWduZWQgaW50IG9mcywgY21kOworCisJaWYgKCpmcm9tICYgMHgyMDApIHsKKwkJY21kID0gTkFORF9DTURfUkVBRE9PQjsKKwkJb2ZzID0gMTAgKyAoKmZyb20gJiAweGYpOworCX0gZWxzZSB7CisJCWNtZCA9IE5BTkRfQ01EX1JFQUQxOworCQlvZnMgPSAoKmZyb20gJiAweGYpOworCX0KKworCSpmcm9tID0gKCpmcm9tICYgfjB4M2ZmKSB8IG9mczsKKwlyZXR1cm4gY21kOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IERvQ19HZXRGbGFnc09mZnNldChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90ICpmcm9tKQoreworCXVuc2lnbmVkIGludCBvZnMsIGNtZDsKKworCWNtZCA9IE5BTkRfQ01EX1JFQUQxOworCW9mcyA9ICgqZnJvbSAmIDB4MjAwKSA/IDggOiA2OworCSpmcm9tID0gKCpmcm9tICYgfjB4M2ZmKSB8IG9mczsKKwlyZXR1cm4gY21kOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IERvQ19HZXRIZHJPZmZzZXQoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCAqZnJvbSkKK3sKKwl1bnNpZ25lZCBpbnQgb2ZzLCBjbWQ7CisKKwljbWQgPSBOQU5EX0NNRF9SRUFET09COworCW9mcyA9ICgqZnJvbSAmIDB4MjAwKSA/IDI0IDogMTY7CisJKmZyb20gPSAoKmZyb20gJiB+MHgzZmYpIHwgb2ZzOworCXJldHVybiBjbWQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBNZW1SZWFkRE9DKHZvaWQgX19pb21lbSAqIGRvY3B0ciwgdW5zaWduZWQgY2hhciAqYnVmLCBpbnQgbGVuKQoreworI2lmbmRlZiBVU0VfTUVNQ1BZCisJaW50IGk7CisJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQorCQlidWZbaV0gPSBSZWFkRE9DKGRvY3B0ciwgTWlsX0NEU05fSU8gKyBpKTsKKyNlbHNlCisJbWVtY3B5X2Zyb21pbyhidWYsIGRvY3B0ciArIERvQ19NaWxfQ0RTTl9JTywgbGVuKTsKKyNlbmRpZgorfQorCitzdGF0aWMgaW5saW5lIHZvaWQgTWVtV3JpdGVET0Modm9pZCBfX2lvbWVtICogZG9jcHRyLCB1bnNpZ25lZCBjaGFyICpidWYsIGludCBsZW4pCit7CisjaWZuZGVmIFVTRV9NRU1DUFkKKwlpbnQgaTsKKwlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspCisJCVdyaXRlRE9DKGJ1ZltpXSwgZG9jcHRyLCBNaWxfQ0RTTl9JTyArIGkpOworI2Vsc2UKKwltZW1jcHlfdG9pbyhkb2NwdHIgKyBEb0NfTWlsX0NEU05fSU8sIGJ1ZiwgbGVuKTsKKyNlbmRpZgorfQorCisvKiBEb0NfSWRlbnRDaGlwOiBJZGVudGlmeSBhIGdpdmVuIE5BTkQgY2hpcCBnaXZlbiB7Zmxvb3IsY2hpcH0gKi8KK3N0YXRpYyBpbnQgRG9DX0lkZW50Q2hpcChzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jLCBpbnQgZmxvb3IsIGludCBjaGlwKQoreworCWludCBtZnIsIGlkLCBpLCBqOworCXZvbGF0aWxlIGNoYXIgZHVtbXk7CisJdm9pZCBfX2lvbWVtICogZG9jcHRyID0gZG9jLT52aXJ0YWRyOworCisJLyogUGFnZSBpbiB0aGUgcmVxdWlyZWQgZmxvb3IvY2hpcCAqLworCURvQ19TZWxlY3RGbG9vcihkb2NwdHIsIGZsb29yKTsKKwlEb0NfU2VsZWN0Q2hpcChkb2NwdHIsIGNoaXApOworCisJLyogTWlsbGVubml1bSBQbHVzIGJ1cyBjeWNsZSBzZXF1ZW5jZSBhcyBwZXIgZmlndXJlIDIsIHNlY3Rpb24gMi40ICovCisJV3JpdGVET0MoKERPQ19GTEFTSF9DRSB8IERPQ19GTEFTSF9XUCksIGRvY3B0ciwgTXBsdXNfRmxhc2hTZWxlY3QpOworCisJLyogUmVzZXQgdGhlIGNoaXAsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4gKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1JFU0VULCAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwkvKiBSZWFkIHRoZSBOQU5EIGNoaXAgSUQ6IDEuIFNlbmQgUmVhZElEIGNvbW1hbmQgKi8gCisJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9SRUFESUQsIDApOworCisJLyogUmVhZCB0aGUgTkFORCBjaGlwIElEOiAyLiBTZW5kIGFkZHJlc3MgYnl0ZSB6ZXJvICovIAorCURvQ19BZGRyZXNzKGRvYywgMSwgMHgwMCwgMCwgMHgwMCk7CisKKwlXcml0ZURPQygwLCBkb2NwdHIsIE1wbHVzX0ZsYXNoQ29udHJvbCk7CisJRG9DX1dhaXRSZWFkeShkb2NwdHIpOworCisJLyogUmVhZCB0aGUgbWFudWZhY3R1cmVyIGFuZCBkZXZpY2UgaWQgY29kZXMgb2YgdGhlIGZsYXNoIGRldmljZSB0aHJvdWdoCisJICAgQ0RTTiBJTyByZWdpc3RlciBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDUuKi8KKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19SZWFkUGlwZUluaXQpOworCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX1JlYWRQaXBlSW5pdCk7CisKKwltZnIgPSBSZWFkRE9DKGRvY3B0ciwgTWlsX0NEU05fSU8pOworCWlmIChkb2MtPmludGVybGVhdmUpCisJCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIE1pbF9DRFNOX0lPKTsgLyogMiB3YXkgaW50ZXJsZWF2ZSAqLworCisJaWQgID0gUmVhZERPQyhkb2NwdHIsIE1pbF9DRFNOX0lPKTsKKwlpZiAoZG9jLT5pbnRlcmxlYXZlKQorCQlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBNaWxfQ0RTTl9JTyk7IC8qIDIgd2F5IGludGVybGVhdmUgKi8KKworCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCk7CisJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfTGFzdERhdGFSZWFkKTsKKworCS8qIERpc2FibGUgZmxhc2ggaW50ZXJuYWxseSAqLworCVdyaXRlRE9DKDAsIGRvY3B0ciwgTXBsdXNfRmxhc2hTZWxlY3QpOworCisJLyogTm8gcmVzcG9uc2UgLSByZXR1cm4gZmFpbHVyZSAqLworCWlmIChtZnIgPT0gMHhmZiB8fCBtZnIgPT0gMCkKKwkJcmV0dXJuIDA7CisKKwlmb3IgKGkgPSAwOyBuYW5kX2ZsYXNoX2lkc1tpXS5uYW1lICE9IE5VTEw7IGkrKykgeworCQlpZiAoaWQgPT0gbmFuZF9mbGFzaF9pZHNbaV0uaWQpIHsKKwkJCS8qIFRyeSB0byBpZGVudGlmeSBtYW51ZmFjdHVyZXIgKi8KKwkJCWZvciAoaiA9IDA7IG5hbmRfbWFudWZfaWRzW2pdLmlkICE9IDB4MDsgaisrKSB7CisJCQkJaWYgKG5hbmRfbWFudWZfaWRzW2pdLmlkID09IG1mcikKKwkJCQkJYnJlYWs7CisJCQl9CisJCQlwcmludGsoS0VSTl9JTkZPICJGbGFzaCBjaGlwIGZvdW5kOiBNYW51ZmFjdHVyZXIgSUQ6ICUyLjJYLCAiCisJCQkgICAgICAgIkNoaXAgSUQ6ICUyLjJYICglczolcylcbiIsIG1mciwgaWQsCisJCQkgICAgICAgbmFuZF9tYW51Zl9pZHNbal0ubmFtZSwgbmFuZF9mbGFzaF9pZHNbaV0ubmFtZSk7CisJCQlkb2MtPm1mciA9IG1mcjsKKwkJCWRvYy0+aWQgPSBpZDsKKwkJCWRvYy0+Y2hpcHNoaWZ0ID0gZmZzKChuYW5kX2ZsYXNoX2lkc1tpXS5jaGlwc2l6ZSA8PCAyMCkpIC0gMTsKKwkJCWRvYy0+ZXJhc2VzaXplID0gbmFuZF9mbGFzaF9pZHNbaV0uZXJhc2VzaXplIDw8IGRvYy0+aW50ZXJsZWF2ZTsKKwkJCWJyZWFrOworCQl9CisJfQorCisJaWYgKG5hbmRfZmxhc2hfaWRzW2ldLm5hbWUgPT0gTlVMTCkKKwkJcmV0dXJuIDA7CisJcmV0dXJuIDE7Cit9CisKKy8qIERvQ19TY2FuQ2hpcHM6IEZpbmQgYWxsIE5BTkQgY2hpcHMgcHJlc2VudCBpbiBhIERpc2tPbkNoaXAsIGFuZCBpZGVudGlmeSB0aGVtICovCitzdGF0aWMgdm9pZCBEb0NfU2NhbkNoaXBzKHN0cnVjdCBEaXNrT25DaGlwICp0aGlzKQoreworCWludCBmbG9vciwgY2hpcDsKKwlpbnQgbnVtY2hpcHNbTUFYX0ZMT09SU19NUExVU107CisJaW50IHJldDsKKworCXRoaXMtPm51bWNoaXBzID0gMDsKKwl0aGlzLT5tZnIgPSAwOworCXRoaXMtPmlkID0gMDsKKworCS8qIFdvcmsgb3V0IHRoZSBpbnRlbmRlZCBpbnRlcmxlYXZlIHNldHRpbmcgKi8KKwl0aGlzLT5pbnRlcmxlYXZlID0gMDsKKwlpZiAodGhpcy0+Q2hpcElEID09IERPQ19DaGlwSURfRG9jTWlsUGx1czMyKQorCQl0aGlzLT5pbnRlcmxlYXZlID0gMTsKKworCS8qIENoZWNrIHRoZSBBU0lDIGFncmVlcyAqLworCWlmICggKHRoaXMtPmludGVybGVhdmUgPDwgMikgIT0gCisJICAgICAoUmVhZERPQyh0aGlzLT52aXJ0YWRyLCBNcGx1c19Db25maWd1cmF0aW9uKSAmIDQpKSB7CisJCXVfY2hhciBjb25mID0gUmVhZERPQyh0aGlzLT52aXJ0YWRyLCBNcGx1c19Db25maWd1cmF0aW9uKTsKKwkJcHJpbnRrKEtFUk5fTk9USUNFICJTZXR0aW5nIERpc2tPbkNoaXAgTWlsbGVubml1bSBQbHVzIGludGVybGVhdmUgdG8gJXNcbiIsCisJCSAgICAgICB0aGlzLT5pbnRlcmxlYXZlPyJvbiAoMTYtYml0KSI6Im9mZiAoOC1iaXQpIik7CisJCWNvbmYgXj0gNDsKKwkJV3JpdGVET0MoY29uZiwgdGhpcy0+dmlydGFkciwgTXBsdXNfQ29uZmlndXJhdGlvbik7CisJfQorCisJLyogRm9yIGVhY2ggZmxvb3IsIGZpbmQgdGhlIG51bWJlciBvZiB2YWxpZCBjaGlwcyBpdCBjb250YWlucyAqLworCWZvciAoZmxvb3IgPSAwLHJldCA9IDE7IGZsb29yIDwgTUFYX0ZMT09SU19NUExVUzsgZmxvb3IrKykgeworCQludW1jaGlwc1tmbG9vcl0gPSAwOworCQlmb3IgKGNoaXAgPSAwOyBjaGlwIDwgTUFYX0NISVBTX01QTFVTICYmIHJldCAhPSAwOyBjaGlwKyspIHsKKwkJCXJldCA9IERvQ19JZGVudENoaXAodGhpcywgZmxvb3IsIGNoaXApOworCQkJaWYgKHJldCkgeworCQkJCW51bWNoaXBzW2Zsb29yXSsrOworCQkJCXRoaXMtPm51bWNoaXBzKys7CisJCQl9CisJCX0KKwl9CisJLyogSWYgdGhlcmUgYXJlIG5vbmUgYXQgYWxsIHRoYXQgd2UgcmVjb2duaXNlLCBiYWlsICovCisJaWYgKCF0aGlzLT5udW1jaGlwcykgeworCQlwcmludGsoIk5vIGZsYXNoIGNoaXBzIHJlY29nbmlzZWQuXG4iKTsKKwkJcmV0dXJuOworCX0KKworCS8qIEFsbG9jYXRlIGFuIGFycmF5IHRvIGhvbGQgdGhlIGluZm9ybWF0aW9uIGZvciBlYWNoIGNoaXAgKi8KKwl0aGlzLT5jaGlwcyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBOYW5kKSAqIHRoaXMtPm51bWNoaXBzLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXRoaXMtPmNoaXBzKXsKKwkJcHJpbnRrKCJNVEQ6IE5vIG1lbW9yeSBmb3IgYWxsb2NhdGluZyBjaGlwIGluZm8gc3RydWN0dXJlc1xuIik7CisJCXJldHVybjsKKwl9CisKKwkvKiBGaWxsIG91dCB0aGUgY2hpcCBhcnJheSB3aXRoIHtmbG9vciwgY2hpcG5vfSBmb3IgZWFjaCAKKwkgKiBkZXRlY3RlZCBjaGlwIGluIHRoZSBkZXZpY2UuICovCisJZm9yIChmbG9vciA9IDAsIHJldCA9IDA7IGZsb29yIDwgTUFYX0ZMT09SU19NUExVUzsgZmxvb3IrKykgeworCQlmb3IgKGNoaXAgPSAwIDsgY2hpcCA8IG51bWNoaXBzW2Zsb29yXSA7IGNoaXArKykgeworCQkJdGhpcy0+Y2hpcHNbcmV0XS5mbG9vciA9IGZsb29yOworCQkJdGhpcy0+Y2hpcHNbcmV0XS5jaGlwID0gY2hpcDsKKwkJCXRoaXMtPmNoaXBzW3JldF0uY3VyYWRyID0gMDsKKwkJCXRoaXMtPmNoaXBzW3JldF0uY3VybW9kZSA9IDB4NTA7CisJCQlyZXQrKzsKKwkJfQorCX0KKworCS8qIENhbGN1bGF0ZSBhbmQgcHJpbnQgdGhlIHRvdGFsIHNpemUgb2YgdGhlIGRldmljZSAqLworCXRoaXMtPnRvdGxlbiA9IHRoaXMtPm51bWNoaXBzICogKDEgPDwgdGhpcy0+Y2hpcHNoaWZ0KTsKKwlwcmludGsoS0VSTl9JTkZPICIlZCBmbGFzaCBjaGlwcyBmb3VuZC4gVG90YWwgRGlza09uQ2hpcCBzaXplOiAlbGQgTWlCXG4iLAorCSAgICAgICB0aGlzLT5udW1jaGlwcyAsdGhpcy0+dG90bGVuID4+IDIwKTsKK30KKworc3RhdGljIGludCBEb0NNaWxQbHVzX2lzX2FsaWFzKHN0cnVjdCBEaXNrT25DaGlwICpkb2MxLCBzdHJ1Y3QgRGlza09uQ2hpcCAqZG9jMikKK3sKKwlpbnQgdG1wMSwgdG1wMiwgcmV0dmFsOworCisJaWYgKGRvYzEtPnBoeXNhZHIgPT0gZG9jMi0+cGh5c2FkcikKKwkJcmV0dXJuIDE7CisKKwkvKiBVc2UgdGhlIGFsaWFzIHJlc29sdXRpb24gcmVnaXN0ZXIgd2hpY2ggd2FzIHNldCBhc2lkZSBmb3IgdGhpcworCSAqIHB1cnBvc2UuIElmIGl0J3MgdmFsdWUgaXMgdGhlIHNhbWUgb24gYm90aCBjaGlwcywgdGhleSBtaWdodAorCSAqIGJlIHRoZSBzYW1lIGNoaXAsIGFuZCB3ZSB3cml0ZSB0byBvbmUgYW5kIGNoZWNrIGZvciBhIGNoYW5nZSBpbgorCSAqIHRoZSBvdGhlci4gSXQncyB1bmNsZWFyIGlmIHRoaXMgcmVnaXN0ZXIgaXMgdXN1YWJsZSBpbiB0aGUKKwkgKiBEb0MgMjAwMCAoaXQncyBpbiB0aGUgTWlsbGVubml1bSBkb2NzKSwgYnV0IGl0IHNlZW1zIHRvIHdvcmsuICovCisJdG1wMSA9IFJlYWRET0MoZG9jMS0+dmlydGFkciwgTXBsdXNfQWxpYXNSZXNvbHV0aW9uKTsKKwl0bXAyID0gUmVhZERPQyhkb2MyLT52aXJ0YWRyLCBNcGx1c19BbGlhc1Jlc29sdXRpb24pOworCWlmICh0bXAxICE9IHRtcDIpCisJCXJldHVybiAwOworCQorCVdyaXRlRE9DKCh0bXAxKzEpICUgMHhmZiwgZG9jMS0+dmlydGFkciwgTXBsdXNfQWxpYXNSZXNvbHV0aW9uKTsKKwl0bXAyID0gUmVhZERPQyhkb2MyLT52aXJ0YWRyLCBNcGx1c19BbGlhc1Jlc29sdXRpb24pOworCWlmICh0bXAyID09ICh0bXAxKzEpICUgMHhmZikKKwkJcmV0dmFsID0gMTsKKwllbHNlCisJCXJldHZhbCA9IDA7CisKKwkvKiBSZXN0b3JlIHJlZ2lzdGVyIGNvbnRlbnRzLiAgTWF5IG5vdCBiZSBuZWNlc3NhcnksIGJ1dCBkbyBpdCBqdXN0IHRvCisJICogYmUgc2FmZS4gKi8KKwlXcml0ZURPQyh0bXAxLCBkb2MxLT52aXJ0YWRyLCBNcGx1c19BbGlhc1Jlc29sdXRpb24pOworCisJcmV0dXJuIHJldHZhbDsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgaW1fbmFtZVtdID0gIkRvQ01pbFBsdXNfaW5pdCI7CisKKy8qIFRoaXMgcm91dGluZSBpcyBtYWRlIGF2YWlsYWJsZSB0byBvdGhlciBtdGQgY29kZSB2aWEKKyAqIGludGVyX21vZHVsZV9yZWdpc3Rlci4gIEl0IG11c3Qgb25seSBiZSBhY2Nlc3NlZCB0aHJvdWdoCisgKiBpbnRlcl9tb2R1bGVfZ2V0IHdoaWNoIHdpbGwgYnVtcCB0aGUgdXNlIGNvdW50IG9mIHRoaXMgbW9kdWxlLiAgVGhlCisgKiBhZGRyZXNzZXMgcGFzc2VkIGJhY2sgaW4gbXRkIGFyZSB2YWxpZCBhcyBsb25nIGFzIHRoZSB1c2UgY291bnQgb2YKKyAqIHRoaXMgbW9kdWxlIGlzIG5vbi16ZXJvLCBpLmUuIGJldHdlZW4gaW50ZXJfbW9kdWxlX2dldCBhbmQKKyAqIGludGVyX21vZHVsZV9wdXQuICBLZWl0aCBPd2VucyA8a2Fvc0BvY3MuY29tLmF1PiAyOSBPY3QgMjAwMC4KKyAqLworc3RhdGljIHZvaWQgRG9DTWlsUGx1c19pbml0KHN0cnVjdCBtdGRfaW5mbyAqbXRkKQoreworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCXN0cnVjdCBEaXNrT25DaGlwICpvbGQgPSBOVUxMOworCisJLyogV2UgbXVzdCBhdm9pZCBiZWluZyBjYWxsZWQgdHdpY2UgZm9yIHRoZSBzYW1lIGRldmljZS4gKi8KKwlpZiAoZG9jbWlscGx1c2xpc3QpCisJCW9sZCA9IGRvY21pbHBsdXNsaXN0LT5wcml2OworCisJd2hpbGUgKG9sZCkgeworCQlpZiAoRG9DTWlsUGx1c19pc19hbGlhcyh0aGlzLCBvbGQpKSB7CisJCQlwcmludGsoS0VSTl9OT1RJQ0UgIklnbm9yaW5nIERpc2tPbkNoaXAgTWlsbGVubml1bSAiCisJCQkJIlBsdXMgYXQgMHglbFggLSBhbHJlYWR5IGNvbmZpZ3VyZWRcbiIsCisJCQkJdGhpcy0+cGh5c2Fkcik7CisJCQlpb3VubWFwKHRoaXMtPnZpcnRhZHIpOworCQkJa2ZyZWUobXRkKTsKKwkJCXJldHVybjsKKwkJfQorCQlpZiAob2xkLT5uZXh0ZG9jKQorCQkJb2xkID0gb2xkLT5uZXh0ZG9jLT5wcml2OworCQllbHNlCisJCQlvbGQgPSBOVUxMOworCX0KKworCW10ZC0+bmFtZSA9ICJEaXNrT25DaGlwIE1pbGxlbm5pdW0gUGx1cyI7CisJcHJpbnRrKEtFUk5fTk9USUNFICJEaXNrT25DaGlwIE1pbGxlbm5pdW0gUGx1cyBmb3VuZCBhdCAiCisJCSJhZGRyZXNzIDB4JWxYXG4iLCB0aGlzLT5waHlzYWRyKTsKKworCW10ZC0+dHlwZSA9IE1URF9OQU5ERkxBU0g7CisJbXRkLT5mbGFncyA9IE1URF9DQVBfTkFOREZMQVNIOworCW10ZC0+ZWNjdHlwZSA9IE1URF9FQ0NfUlNfRGlza09uQ2hpcDsKKwltdGQtPnNpemUgPSAwOworCisJbXRkLT5lcmFzZXNpemUgPSAwOworCW10ZC0+b29iYmxvY2sgPSA1MTI7CisJbXRkLT5vb2JzaXplID0gMTY7CisJbXRkLT5vd25lciA9IFRISVNfTU9EVUxFOworCW10ZC0+ZXJhc2UgPSBkb2NfZXJhc2U7CisJbXRkLT5wb2ludCA9IE5VTEw7CisJbXRkLT51bnBvaW50ID0gTlVMTDsKKwltdGQtPnJlYWQgPSBkb2NfcmVhZDsKKwltdGQtPndyaXRlID0gZG9jX3dyaXRlOworCW10ZC0+cmVhZF9lY2MgPSBkb2NfcmVhZF9lY2M7CisJbXRkLT53cml0ZV9lY2MgPSBkb2Nfd3JpdGVfZWNjOworCW10ZC0+cmVhZF9vb2IgPSBkb2NfcmVhZF9vb2I7CisJbXRkLT53cml0ZV9vb2IgPSBkb2Nfd3JpdGVfb29iOworCW10ZC0+c3luYyA9IE5VTEw7CisKKwl0aGlzLT50b3RsZW4gPSAwOworCXRoaXMtPm51bWNoaXBzID0gMDsKKwl0aGlzLT5jdXJmbG9vciA9IC0xOworCXRoaXMtPmN1cmNoaXAgPSAtMTsKKworCS8qIElkZW50IGFsbCB0aGUgY2hpcHMgcHJlc2VudC4gKi8KKwlEb0NfU2NhbkNoaXBzKHRoaXMpOworCisJaWYgKCF0aGlzLT50b3RsZW4pIHsKKwkJa2ZyZWUobXRkKTsKKwkJaW91bm1hcCh0aGlzLT52aXJ0YWRyKTsKKwl9IGVsc2UgeworCQl0aGlzLT5uZXh0ZG9jID0gZG9jbWlscGx1c2xpc3Q7CisJCWRvY21pbHBsdXNsaXN0ID0gbXRkOworCQltdGQtPnNpemUgID0gdGhpcy0+dG90bGVuOworCQltdGQtPmVyYXNlc2l6ZSA9IHRoaXMtPmVyYXNlc2l6ZTsKKwkJYWRkX210ZF9kZXZpY2UobXRkKTsKKwkJcmV0dXJuOworCX0KK30KKworI2lmIDAKK3N0YXRpYyBpbnQgZG9jX2R1bXBibGsoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tKQoreworCWludCBpOworCWxvZmZfdCBmb2ZzOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCXZvaWQgX19pb21lbSAqIGRvY3B0ciA9IHRoaXMtPnZpcnRhZHI7CisJc3RydWN0IE5hbmQgKm15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tmcm9tID4+ICh0aGlzLT5jaGlwc2hpZnQpXTsKKwl1bnNpZ25lZCBjaGFyICpicCwgYnVmWzEwNTZdOworCWNoYXIgY1szMl07CisKKwlmcm9tICY9IH4weDNmZjsKKworCS8qIERvbid0IGFsbG93IHJlYWQgcGFzdCBlbmQgb2YgZGV2aWNlICovCisJaWYgKGZyb20gPj0gdGhpcy0+dG90bGVuKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCURvQ19DaGVja0FTSUMoZG9jcHRyKTsKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKGRvY3B0ciwgbXljaGlwLT5mbG9vcik7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBNaWxsZW5uaXVtIFBsdXMgYnVzIGN5Y2xlIHNlcXVlbmNlIGFzIHBlciBmaWd1cmUgMiwgc2VjdGlvbiAyLjQgKi8KKwlXcml0ZURPQygoRE9DX0ZMQVNIX0NFIHwgRE9DX0ZMQVNIX1dQKSwgZG9jcHRyLCBNcGx1c19GbGFzaFNlbGVjdCk7CisKKwkvKiBSZXNldCB0aGUgY2hpcCwgc2VlIFNvZnR3YXJlIFJlcXVpcmVtZW50IDExLjQgaXRlbSAxLiAqLworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfUkVTRVQsIDApOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCWZvZnMgPSBmcm9tOworCURvQ19Db21tYW5kKGRvY3B0ciwgRG9DX0dldERhdGFPZmZzZXQobXRkLCAmZm9mcyksIDApOworCURvQ19BZGRyZXNzKHRoaXMsIDMsIGZvZnMsIDAsIDB4MDApOworCVdyaXRlRE9DKDAsIGRvY3B0ciwgTXBsdXNfRmxhc2hDb250cm9sKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJV3JpdGVET0MoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBNcGx1c19FQ0NDb25mKTsKKworCVJlYWRET0MoZG9jcHRyLCBNcGx1c19SZWFkUGlwZUluaXQpOworCVJlYWRET0MoZG9jcHRyLCBNcGx1c19SZWFkUGlwZUluaXQpOworCisJLyogUmVhZCB0aGUgZGF0YSB2aWEgdGhlIGludGVybmFsIHBpcGVsaW5lIHRocm91Z2ggQ0RTTiBJTworCSAgIHJlZ2lzdGVyLCBzZWUgUGlwZWxpbmVkIFJlYWQgT3BlcmF0aW9ucyAxMS4zICovCisJTWVtUmVhZERPQyhkb2NwdHIsIGJ1ZiwgMTA1NCk7CisJYnVmWzEwNTRdID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCk7CisJYnVmWzEwNTVdID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCk7CisKKwltZW1zZXQoJmNbMF0sIDAsIHNpemVvZihjKSk7CisJcHJpbnRrKCJEVU1QIE9GRlNFVD0leDpcbiIsIChpbnQpZnJvbSk7CisKKyAgICAgICAgZm9yIChpID0gMCwgYnAgPSAmYnVmWzBdOyAoaSA8IDEwNTYpOyBpKyspIHsKKyAgICAgICAgICAgICAgICBpZiAoKGkgJSAxNikgPT0gMCkKKyAgICAgICAgICAgICAgICAgICAgICAgIHByaW50aygiJTA4eDogIiwgaSk7CisgICAgICAgICAgICAgICAgcHJpbnRrKCIgJTAyeCIsICpicCk7CisgICAgICAgICAgICAgICAgY1soaSAmIDB4ZildID0gKCgqYnAgPj0gMHgyMCkgJiYgKCpicCA8PSAweDdmKSkgPyAqYnAgOiAnLic7CisgICAgICAgICAgICAgICAgYnArKzsKKyAgICAgICAgICAgICAgICBpZiAoKChpICsgMSkgJSAxNikgPT0gMCkKKyAgICAgICAgICAgICAgICAgICAgICAgIHByaW50aygiICAgICVzXG4iLCBjKTsKKyAgICAgICAgfQorCXByaW50aygiXG4iKTsKKworCS8qIERpc2FibGUgZmxhc2ggaW50ZXJuYWxseSAqLworCVdyaXRlRE9DKDAsIGRvY3B0ciwgTXBsdXNfRmxhc2hTZWxlY3QpOworCisJcmV0dXJuIDA7Cit9CisjZW5kaWYKKworc3RhdGljIGludCBkb2NfcmVhZChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCSAgICBzaXplX3QgKnJldGxlbiwgdV9jaGFyICpidWYpCit7CisJLyogSnVzdCBhIHNwZWNpYWwgY2FzZSBvZiBkb2NfcmVhZF9lY2MgKi8KKwlyZXR1cm4gZG9jX3JlYWRfZWNjKG10ZCwgZnJvbSwgbGVuLCByZXRsZW4sIGJ1ZiwgTlVMTCwgTlVMTCk7Cit9CisKK3N0YXRpYyBpbnQgZG9jX3JlYWRfZWNjKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwKKwkJCXNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZiwgdV9jaGFyICplY2NidWYsCisJCQlzdHJ1Y3QgbmFuZF9vb2JpbmZvICpvb2JzZWwpCit7CisJaW50IHJldCwgaTsKKwl2b2xhdGlsZSBjaGFyIGR1bW15OworCWxvZmZfdCBmb2ZzOworCXVuc2lnbmVkIGNoYXIgc3luZHJvbWVbNl07CisJc3RydWN0IERpc2tPbkNoaXAgKnRoaXMgPSBtdGQtPnByaXY7CisJdm9pZCBfX2lvbWVtICogZG9jcHRyID0gdGhpcy0+dmlydGFkcjsKKwlzdHJ1Y3QgTmFuZCAqbXljaGlwID0gJnRoaXMtPmNoaXBzW2Zyb20gPj4gKHRoaXMtPmNoaXBzaGlmdCldOworCisJLyogRG9uJ3QgYWxsb3cgcmVhZCBwYXN0IGVuZCBvZiBkZXZpY2UgKi8KKwlpZiAoZnJvbSA+PSB0aGlzLT50b3RsZW4pCisJCXJldHVybiAtRUlOVkFMOworCisJLyogRG9uJ3QgYWxsb3cgYSBzaW5nbGUgcmVhZCB0byBjcm9zcyBhIDUxMi1ieXRlIGJsb2NrIGJvdW5kYXJ5ICovCisJaWYgKGZyb20gKyBsZW4gPiAoKGZyb20gfCAweDFmZikgKyAxKSkgCisJCWxlbiA9ICgoZnJvbSB8IDB4MWZmKSArIDEpIC0gZnJvbTsKKworCURvQ19DaGVja0FTSUMoZG9jcHRyKTsKKworCS8qIEZpbmQgdGhlIGNoaXAgd2hpY2ggaXMgdG8gYmUgdXNlZCBhbmQgc2VsZWN0IGl0ICovCisJaWYgKHRoaXMtPmN1cmZsb29yICE9IG15Y2hpcC0+Zmxvb3IpIHsKKwkJRG9DX1NlbGVjdEZsb29yKGRvY3B0ciwgbXljaGlwLT5mbG9vcik7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9IGVsc2UgaWYgKHRoaXMtPmN1cmNoaXAgIT0gbXljaGlwLT5jaGlwKSB7CisJCURvQ19TZWxlY3RDaGlwKGRvY3B0ciwgbXljaGlwLT5jaGlwKTsKKwl9CisJdGhpcy0+Y3VyZmxvb3IgPSBteWNoaXAtPmZsb29yOworCXRoaXMtPmN1cmNoaXAgPSBteWNoaXAtPmNoaXA7CisKKwkvKiBNaWxsZW5uaXVtIFBsdXMgYnVzIGN5Y2xlIHNlcXVlbmNlIGFzIHBlciBmaWd1cmUgMiwgc2VjdGlvbiAyLjQgKi8KKwlXcml0ZURPQygoRE9DX0ZMQVNIX0NFIHwgRE9DX0ZMQVNIX1dQKSwgZG9jcHRyLCBNcGx1c19GbGFzaFNlbGVjdCk7CisKKwkvKiBSZXNldCB0aGUgY2hpcCwgc2VlIFNvZnR3YXJlIFJlcXVpcmVtZW50IDExLjQgaXRlbSAxLiAqLworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfUkVTRVQsIDApOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCWZvZnMgPSBmcm9tOworCURvQ19Db21tYW5kKGRvY3B0ciwgRG9DX0dldERhdGFPZmZzZXQobXRkLCAmZm9mcyksIDApOworCURvQ19BZGRyZXNzKHRoaXMsIDMsIGZvZnMsIDAsIDB4MDApOworCVdyaXRlRE9DKDAsIGRvY3B0ciwgTXBsdXNfRmxhc2hDb250cm9sKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwlpZiAoZWNjYnVmKSB7CisJCS8qIGluaXQgdGhlIEVDQyBlbmdpbmUsIHNlZSBSZWVkLVNvbG9tb24gRURDL0VDQyAxMS4xIC4qLworCQlXcml0ZURPQyhET0NfRUNDX1JFU0VULCBkb2NwdHIsIE1wbHVzX0VDQ0NvbmYpOworCQlXcml0ZURPQyhET0NfRUNDX0VOLCBkb2NwdHIsIE1wbHVzX0VDQ0NvbmYpOworCX0gZWxzZSB7CisJCS8qIGRpc2FibGUgdGhlIEVDQyBlbmdpbmUgKi8KKwkJV3JpdGVET0MoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBNcGx1c19FQ0NDb25mKTsKKwl9CisKKwkvKiBMZXQgdGhlIGNhbGxlciBrbm93IHdlIGNvbXBsZXRlZCBpdCAqLworCSpyZXRsZW4gPSBsZW47CisgICAgICAgIHJldCA9IDA7CisKKwlSZWFkRE9DKGRvY3B0ciwgTXBsdXNfUmVhZFBpcGVJbml0KTsKKwlSZWFkRE9DKGRvY3B0ciwgTXBsdXNfUmVhZFBpcGVJbml0KTsKKworCWlmIChlY2NidWYpIHsKKwkJLyogUmVhZCB0aGUgZGF0YSB2aWEgdGhlIGludGVybmFsIHBpcGVsaW5lIHRocm91Z2ggQ0RTTiBJTworCQkgICByZWdpc3Rlciwgc2VlIFBpcGVsaW5lZCBSZWFkIE9wZXJhdGlvbnMgMTEuMyAqLworCQlNZW1SZWFkRE9DKGRvY3B0ciwgYnVmLCBsZW4pOworCisJCS8qIFJlYWQgdGhlIEVDQyBkYXRhIGZvbGxvd2luZyByYXcgZGF0YSAqLworCQlNZW1SZWFkRE9DKGRvY3B0ciwgZWNjYnVmLCA0KTsKKwkJZWNjYnVmWzRdID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCk7CisJCWVjY2J1Zls1XSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19MYXN0RGF0YVJlYWQpOworCisJCS8qIEZsdXNoIHRoZSBwaXBlbGluZSAqLworCQlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19FQ0NDb25mKTsKKwkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfRUNDQ29uZik7CisKKwkJLyogQ2hlY2sgdGhlIEVDQyBTdGF0dXMgKi8KKwkJaWYgKFJlYWRET0MoZG9jcHRyLCBNcGx1c19FQ0NDb25mKSAmIDB4ODApIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGludCBuYl9lcnJvcnM7CisJCQkvKiBUaGVyZSB3YXMgYW4gRUNDIGVycm9yICovCisjaWZkZWYgRUNDX0RFQlVHCisJCQlwcmludGsoIkRpc2tPbkNoaXAgRUNDIEVycm9yOiBSZWFkIGF0ICVseFxuIiwgKGxvbmcpZnJvbSk7CisjZW5kaWYKKwkJCS8qIFJlYWQgdGhlIEVDQyBzeW5kcm9tIHRocm91Z2ggdGhlIERpc2tPbkNoaXAgRUNDIGxvZ2ljLgorCQkJICAgVGhlc2Ugc3luZHJvbWUgd2lsbCBiZSBhbGwgWkVSTyB3aGVuIHRoZXJlIGlzIG5vIGVycm9yICovCisJCQlmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKQorCQkJCXN5bmRyb21lW2ldID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0VDQ1N5bmRyb21lMCArIGkpOworCisgICAgICAgICAgICAgICAgICAgICAgICBuYl9lcnJvcnMgPSBkb2NfZGVjb2RlX2VjYyhidWYsIHN5bmRyb21lKTsKKyNpZmRlZiBFQ0NfREVCVUcKKwkJCXByaW50aygiRUNDIEVycm9ycyBjb3JyZWN0ZWQ6ICV4XG4iLCBuYl9lcnJvcnMpOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobmJfZXJyb3JzIDwgMCkgeworCQkJCS8qIFdlIHJldHVybiBlcnJvciwgYnV0IGhhdmUgYWN0dWFsbHkgZG9uZSB0aGUgcmVhZC4gTm90IHRoYXQKKwkJCQkgICB0aGlzIGNhbiBiZSB0b2xkIHRvIHVzZXItc3BhY2UsIHZpYSBzeXNfcmVhZCgpLCBidXQgYXQgbGVhc3QKKwkJCQkgICBNVEQtYXdhcmUgc3R1ZmYgY2FuIGtub3cgYWJvdXQgaXQgYnkgY2hlY2tpbmcgKnJldGxlbiAqLworI2lmZGVmIEVDQ19ERUJVRworCQkJcHJpbnRrKCIlcyglZCk6IE1pbGxlbm5pdW0gUGx1cyBFQ0MgZXJyb3IgKGZyb209MHgleDpcbiIsCisJCQkJX19GSUxFX18sIF9fTElORV9fLCAoaW50KWZyb20pOworCQkJcHJpbnRrKCIgICAgICAgIHN5bmRyb21lPSAlMDJ4OiUwMng6JTAyeDolMDJ4OiUwMng6IgorCQkJCSIlMDJ4XG4iLAorCQkJCXN5bmRyb21lWzBdLCBzeW5kcm9tZVsxXSwgc3luZHJvbWVbMl0sCisJCQkJc3luZHJvbWVbM10sIHN5bmRyb21lWzRdLCBzeW5kcm9tZVs1XSk7CisJCQlwcmludGsoIiAgICAgICAgICBlY2NidWY9ICUwMng6JTAyeDolMDJ4OiUwMng6JTAyeDoiCisJCQkJIiUwMnhcbiIsCisJCQkJZWNjYnVmWzBdLCBlY2NidWZbMV0sIGVjY2J1ZlsyXSwKKwkJCQllY2NidWZbM10sIGVjY2J1Zls0XSwgZWNjYnVmWzVdKTsKKyNlbmRpZgorCQkJCXJldCA9IC1FSU87CisgICAgICAgICAgICAgICAgICAgICAgICB9CisJCX0KKworI2lmZGVmIFBTWUNIT19ERUJVRworCQlwcmludGsoIkVDQyBEQVRBIGF0ICVseDogJTIuMlggJTIuMlggJTIuMlggJTIuMlggJTIuMlggJTIuMlhcbiIsCisJCSAgICAgICAobG9uZylmcm9tLCBlY2NidWZbMF0sIGVjY2J1ZlsxXSwgZWNjYnVmWzJdLCBlY2NidWZbM10sCisJCSAgICAgICBlY2NidWZbNF0sIGVjY2J1Zls1XSk7CisjZW5kaWYKKworCQkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJCVdyaXRlRE9DKERPQ19FQ0NfRElTLCBkb2NwdHIgLCBNcGx1c19FQ0NDb25mKTsKKwl9IGVsc2UgeworCQkvKiBSZWFkIHRoZSBkYXRhIHZpYSB0aGUgaW50ZXJuYWwgcGlwZWxpbmUgdGhyb3VnaCBDRFNOIElPCisJCSAgIHJlZ2lzdGVyLCBzZWUgUGlwZWxpbmVkIFJlYWQgT3BlcmF0aW9ucyAxMS4zICovCisJCU1lbVJlYWRET0MoZG9jcHRyLCBidWYsIGxlbi0yKTsKKwkJYnVmW2xlbi0yXSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19MYXN0RGF0YVJlYWQpOworCQlidWZbbGVuLTFdID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCk7CisJfQorCisJLyogRGlzYWJsZSBmbGFzaCBpbnRlcm5hbGx5ICovCisJV3JpdGVET0MoMCwgZG9jcHRyLCBNcGx1c19GbGFzaFNlbGVjdCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGRvY193cml0ZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLCBzaXplX3QgbGVuLAorCQkgICAgIHNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1ZikKK3sKKwljaGFyIGVjY2J1Zls2XTsKKwlyZXR1cm4gZG9jX3dyaXRlX2VjYyhtdGQsIHRvLCBsZW4sIHJldGxlbiwgYnVmLCBlY2NidWYsIE5VTEwpOworfQorCitzdGF0aWMgaW50IGRvY193cml0ZV9lY2Moc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJCSBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYsIHVfY2hhciAqZWNjYnVmLAorCQkJIHN0cnVjdCBuYW5kX29vYmluZm8gKm9vYnNlbCkKK3sKKwlpbnQgaSwgYmVmb3JlLCByZXQgPSAwOworCWxvZmZfdCBmdG87CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwl2b2lkIF9faW9tZW0gKiBkb2NwdHIgPSB0aGlzLT52aXJ0YWRyOworCXN0cnVjdCBOYW5kICpteWNoaXAgPSAmdGhpcy0+Y2hpcHNbdG8gPj4gKHRoaXMtPmNoaXBzaGlmdCldOworCisJLyogRG9uJ3QgYWxsb3cgd3JpdGUgcGFzdCBlbmQgb2YgZGV2aWNlICovCisJaWYgKHRvID49IHRoaXMtPnRvdGxlbikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBEb24ndCBhbGxvdyB3cml0ZXMgd2hpY2ggYXJlbid0IGV4YWN0bHkgb25lIGJsb2NrICg1MTIgYnl0ZXMpICovCisJaWYgKCh0byAmIDB4MWZmKSB8fCAobGVuICE9IDB4MjAwKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBEZXRlcm1pbmUgcG9zaXRpb24gb2YgT09CIGZsYWdzLCBiZWZvcmUgb3IgYWZ0ZXIgZGF0YSAqLworCWJlZm9yZSA9ICh0aGlzLT5pbnRlcmxlYXZlICYmICh0byAmIDB4MjAwKSk7CisKKwlEb0NfQ2hlY2tBU0lDKGRvY3B0cik7CisKKwkvKiBGaW5kIHRoZSBjaGlwIHdoaWNoIGlzIHRvIGJlIHVzZWQgYW5kIHNlbGVjdCBpdCAqLworCWlmICh0aGlzLT5jdXJmbG9vciAhPSBteWNoaXAtPmZsb29yKSB7CisJCURvQ19TZWxlY3RGbG9vcihkb2NwdHIsIG15Y2hpcC0+Zmxvb3IpOworCQlEb0NfU2VsZWN0Q2hpcChkb2NwdHIsIG15Y2hpcC0+Y2hpcCk7CisJfSBlbHNlIGlmICh0aGlzLT5jdXJjaGlwICE9IG15Y2hpcC0+Y2hpcCkgeworCQlEb0NfU2VsZWN0Q2hpcChkb2NwdHIsIG15Y2hpcC0+Y2hpcCk7CisJfQorCXRoaXMtPmN1cmZsb29yID0gbXljaGlwLT5mbG9vcjsKKwl0aGlzLT5jdXJjaGlwID0gbXljaGlwLT5jaGlwOworCisJLyogTWlsbGVubml1bSBQbHVzIGJ1cyBjeWNsZSBzZXF1ZW5jZSBhcyBwZXIgZmlndXJlIDIsIHNlY3Rpb24gMi40ICovCisJV3JpdGVET0MoRE9DX0ZMQVNIX0NFLCBkb2NwdHIsIE1wbHVzX0ZsYXNoU2VsZWN0KTsKKworCS8qIFJlc2V0IHRoZSBjaGlwLCBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDEuICovCisJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9SRVNFVCwgMCk7CisJRG9DX1dhaXRSZWFkeShkb2NwdHIpOworCisJLyogU2V0IGRldmljZSB0byBhcHByb3ByaWF0ZSBwbGFuZSBvZiBmbGFzaCAqLworCWZ0byA9IHRvOworCVdyaXRlRE9DKERvQ19HZXREYXRhT2Zmc2V0KG10ZCwgJmZ0byksIGRvY3B0ciwgTXBsdXNfRmxhc2hDbWQpOworCisJLyogT24gaW50ZXJsZWF2ZWQgZGV2aWNlcyB0aGUgZmxhZ3MgZm9yIDJuZCBoYWxmIDUxMiBhcmUgYmVmb3JlIGRhdGEgKi8KKwlpZiAoZWNjYnVmICYmIGJlZm9yZSkKKwkJZnRvIC09IDI7CisKKwkvKiBpc3N1ZSB0aGUgU2VyaWFsIERhdGEgSW4gY29tbWFuZCB0byBpbml0aWFsIHRoZSBQYWdlIFByb2dyYW0gcHJvY2VzcyAqLworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfU0VRSU4sIDB4MDApOworCURvQ19BZGRyZXNzKHRoaXMsIDMsIGZ0bywgMHgwMCwgMHgwMCk7CisKKwkvKiBEaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJV3JpdGVET0MoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBNcGx1c19FQ0NDb25mKTsKKworCWlmIChlY2NidWYpIHsKKwkJaWYgKGJlZm9yZSkgeworCQkJLyogV3JpdGUgdGhlIGJsb2NrIHN0YXR1cyBCTE9DS19VU0VEICgweDU1NTUpICovCisJCQlXcml0ZURPQygweDU1LCBkb2NwdHIsIE1pbF9DRFNOX0lPKTsKKwkJCVdyaXRlRE9DKDB4NTUsIGRvY3B0ciwgTWlsX0NEU05fSU8pOworCQl9CisKKwkJLyogaW5pdCB0aGUgRUNDIGVuZ2luZSwgc2VlIFJlZWQtU29sb21vbiBFREMvRUNDIDExLjEgLiovCisJCVdyaXRlRE9DKERPQ19FQ0NfRU4gfCBET0NfRUNDX1JXLCBkb2NwdHIsIE1wbHVzX0VDQ0NvbmYpOworCX0KKworCU1lbVdyaXRlRE9DKGRvY3B0ciwgKHVuc2lnbmVkIGNoYXIgKikgYnVmLCBsZW4pOworCisJaWYgKGVjY2J1ZikgeworCQkvKiBXcml0ZSBFQ0MgZGF0YSB0byBmbGFzaCwgdGhlIEVDQyBpbmZvIGlzIGdlbmVyYXRlZCBieQorCQkgICB0aGUgRGlza09uQ2hpcCBFQ0MgbG9naWMgc2VlIFJlZWQtU29sb21vbiBFREMvRUNDIDExLjEgKi8KKwkJRG9DX0RlbGF5KGRvY3B0ciwgMyk7CisKKwkJLyogUmVhZCB0aGUgRUNDIGRhdGEgdGhyb3VnaCB0aGUgRGlza09uQ2hpcCBFQ0MgbG9naWMgKi8KKwkJZm9yIChpID0gMDsgaSA8IDY7IGkrKykKKwkJCWVjY2J1ZltpXSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19FQ0NTeW5kcm9tZTAgKyBpKTsKKworCQkvKiBkaXNhYmxlIHRoZSBFQ0MgZW5naW5lICovCisJCVdyaXRlRE9DKERPQ19FQ0NfRElTLCBkb2NwdHIsIE1wbHVzX0VDQ0NvbmYpOworCisJCS8qIFdyaXRlIHRoZSBFQ0MgZGF0YSB0byBmbGFzaCAqLworCQlNZW1Xcml0ZURPQyhkb2NwdHIsIGVjY2J1ZiwgNik7CisKKwkJaWYgKCFiZWZvcmUpIHsKKwkJCS8qIFdyaXRlIHRoZSBibG9jayBzdGF0dXMgQkxPQ0tfVVNFRCAoMHg1NTU1KSAqLworCQkJV3JpdGVET0MoMHg1NSwgZG9jcHRyLCBNaWxfQ0RTTl9JTys2KTsKKwkJCVdyaXRlRE9DKDB4NTUsIGRvY3B0ciwgTWlsX0NEU05fSU8rNyk7CisJCX0KKworI2lmZGVmIFBTWUNIT19ERUJVRworCQlwcmludGsoIk9PQiBkYXRhIGF0ICVseCBpcyAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWCAlMi4yWFxuIiwKKwkJICAgICAgIChsb25nKSB0bywgZWNjYnVmWzBdLCBlY2NidWZbMV0sIGVjY2J1ZlsyXSwgZWNjYnVmWzNdLAorCQkgICAgICAgZWNjYnVmWzRdLCBlY2NidWZbNV0pOworI2VuZGlmCisJfQorCisJV3JpdGVET0MoMHgwMCwgZG9jcHRyLCBNcGx1c19Xcml0ZVBpcGVUZXJtKTsKKwlXcml0ZURPQygweDAwLCBkb2NwdHIsIE1wbHVzX1dyaXRlUGlwZVRlcm0pOworCisJLyogQ29tbWl0IHRoZSBQYWdlIFByb2dyYW0gY29tbWFuZCBhbmQgd2FpdCBmb3IgcmVhZHkKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDEuKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1BBR0VQUk9HLCAweDAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwkvKiBSZWFkIHRoZSBzdGF0dXMgb2YgdGhlIGZsYXNoIGRldmljZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDUuKi8KKwlEb0NfQ29tbWFuZChkb2NwdHIsIE5BTkRfQ01EX1NUQVRVUywgMCk7CisJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfUmVhZFBpcGVJbml0KTsKKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19SZWFkUGlwZUluaXQpOworCURvQ19EZWxheShkb2NwdHIsIDIpOworCWlmICgoZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfTGFzdERhdGFSZWFkKSkgJiAxKSB7CisJCXByaW50aygiTVREOiBFcnJvciAweCV4IHByb2dyYW1taW5nIGF0IDB4JXhcbiIsIGR1bW15LCAoaW50KXRvKTsKKwkJLyogRXJyb3IgaW4gcHJvZ3JhbW1pbmcKKwkJICAgRklYTUU6IGltcGxlbWVudCBCYWQgQmxvY2sgUmVwbGFjZW1lbnQgKGluIG5mdGwuYyA/PykgKi8KKwkJKnJldGxlbiA9IDA7CisJCXJldCA9IC1FSU87CisJfQorCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCk7CisKKwkvKiBEaXNhYmxlIGZsYXNoIGludGVybmFsbHkgKi8KKwlXcml0ZURPQygwLCBkb2NwdHIsIE1wbHVzX0ZsYXNoU2VsZWN0KTsKKworCS8qIExldCB0aGUgY2FsbGVyIGtub3cgd2UgY29tcGxldGVkIGl0ICovCisJKnJldGxlbiA9IGxlbjsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgZG9jX3JlYWRfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQkJc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKQoreworCWxvZmZfdCBmb2ZzLCBiYXNlOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCXZvaWQgX19pb21lbSAqIGRvY3B0ciA9IHRoaXMtPnZpcnRhZHI7CisJc3RydWN0IE5hbmQgKm15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tvZnMgPj4gdGhpcy0+Y2hpcHNoaWZ0XTsKKwlzaXplX3QgaSwgc2l6ZSwgZ290LCB3YW50OworCisJRG9DX0NoZWNrQVNJQyhkb2NwdHIpOworCisJLyogRmluZCB0aGUgY2hpcCB3aGljaCBpcyB0byBiZSB1c2VkIGFuZCBzZWxlY3QgaXQgKi8KKwlpZiAodGhpcy0+Y3VyZmxvb3IgIT0gbXljaGlwLT5mbG9vcikgeworCQlEb0NfU2VsZWN0Rmxvb3IoZG9jcHRyLCBteWNoaXAtPmZsb29yKTsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0gZWxzZSBpZiAodGhpcy0+Y3VyY2hpcCAhPSBteWNoaXAtPmNoaXApIHsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0KKwl0aGlzLT5jdXJmbG9vciA9IG15Y2hpcC0+Zmxvb3I7CisJdGhpcy0+Y3VyY2hpcCA9IG15Y2hpcC0+Y2hpcDsKKworCS8qIE1pbGxlbm5pdW0gUGx1cyBidXMgY3ljbGUgc2VxdWVuY2UgYXMgcGVyIGZpZ3VyZSAyLCBzZWN0aW9uIDIuNCAqLworCVdyaXRlRE9DKChET0NfRkxBU0hfQ0UgfCBET0NfRkxBU0hfV1ApLCBkb2NwdHIsIE1wbHVzX0ZsYXNoU2VsZWN0KTsKKworCS8qIGRpc2FibGUgdGhlIEVDQyBlbmdpbmUgKi8KKwlXcml0ZURPQyhET0NfRUNDX1JFU0VULCBkb2NwdHIsIE1wbHVzX0VDQ0NvbmYpOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCS8qIE1heGltdW0gb2YgMTYgYnl0ZXMgaW4gdGhlIE9PQiByZWdpb24sIHNvIGxpbWl0IHJlYWQgdG8gdGhhdCAqLworCWlmIChsZW4gPiAxNikKKwkJbGVuID0gMTY7CisJZ290ID0gMDsKKwl3YW50ID0gbGVuOworCisJZm9yIChpID0gMDsgKChpIDwgMykgJiYgKHdhbnQgPiAwKSk7IGkrKykgeworCQkvKiBGaWd1cmUgb3V0IHdoaWNoIHJlZ2lvbiB3ZSBhcmUgYWNjZXNzaW5nLi4uICovCisJCWZvZnMgPSBvZnM7CisJCWJhc2UgPSBvZnMgJiAweGY7CisJCWlmICghdGhpcy0+aW50ZXJsZWF2ZSkgeworCQkJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9SRUFET09CLCAwKTsKKwkJCXNpemUgPSAxNiAtIGJhc2U7CisJCX0gZWxzZSBpZiAoYmFzZSA8IDYpIHsKKwkJCURvQ19Db21tYW5kKGRvY3B0ciwgRG9DX0dldEVDQ09mZnNldChtdGQsICZmb2ZzKSwgMCk7CisJCQlzaXplID0gNiAtIGJhc2U7CisJCX0gZWxzZSBpZiAoYmFzZSA8IDgpIHsKKwkJCURvQ19Db21tYW5kKGRvY3B0ciwgRG9DX0dldEZsYWdzT2Zmc2V0KG10ZCwgJmZvZnMpLCAwKTsKKwkJCXNpemUgPSA4IC0gYmFzZTsKKwkJfSBlbHNlIHsKKwkJCURvQ19Db21tYW5kKGRvY3B0ciwgRG9DX0dldEhkck9mZnNldChtdGQsICZmb2ZzKSwgMCk7CisJCQlzaXplID0gMTYgLSBiYXNlOworCQl9CisJCWlmIChzaXplID4gd2FudCkKKwkJCXNpemUgPSB3YW50OworCisJCS8qIElzc3VlIHJlYWQgY29tbWFuZCAqLworCQlEb0NfQWRkcmVzcyh0aGlzLCAzLCBmb2ZzLCAwLCAweDAwKTsKKwkJV3JpdGVET0MoMCwgZG9jcHRyLCBNcGx1c19GbGFzaENvbnRyb2wpOworCQlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisKKwkJUmVhZERPQyhkb2NwdHIsIE1wbHVzX1JlYWRQaXBlSW5pdCk7CisJCVJlYWRET0MoZG9jcHRyLCBNcGx1c19SZWFkUGlwZUluaXQpOworCQlNZW1SZWFkRE9DKGRvY3B0ciwgJmJ1Zltnb3RdLCBzaXplIC0gMik7CisJCWJ1Zltnb3QgKyBzaXplIC0gMl0gPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfTGFzdERhdGFSZWFkKTsKKwkJYnVmW2dvdCArIHNpemUgLSAxXSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19MYXN0RGF0YVJlYWQpOworCisJCW9mcyArPSBzaXplOworCQlnb3QgKz0gc2l6ZTsKKwkJd2FudCAtPSBzaXplOworCX0KKworCS8qIERpc2FibGUgZmxhc2ggaW50ZXJuYWxseSAqLworCVdyaXRlRE9DKDAsIGRvY3B0ciwgTXBsdXNfRmxhc2hTZWxlY3QpOworCisJKnJldGxlbiA9IGxlbjsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBkb2Nfd3JpdGVfb29iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzLCBzaXplX3QgbGVuLAorCQkJIHNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1ZikKK3sKKwl2b2xhdGlsZSBjaGFyIGR1bW15OworCWxvZmZfdCBmb2ZzLCBiYXNlOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzID0gbXRkLT5wcml2OworCXZvaWQgX19pb21lbSAqIGRvY3B0ciA9IHRoaXMtPnZpcnRhZHI7CisJc3RydWN0IE5hbmQgKm15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tvZnMgPj4gdGhpcy0+Y2hpcHNoaWZ0XTsKKwlzaXplX3QgaSwgc2l6ZSwgZ290LCB3YW50OworCWludCByZXQgPSAwOworCisJRG9DX0NoZWNrQVNJQyhkb2NwdHIpOworCisJLyogRmluZCB0aGUgY2hpcCB3aGljaCBpcyB0byBiZSB1c2VkIGFuZCBzZWxlY3QgaXQgKi8KKwlpZiAodGhpcy0+Y3VyZmxvb3IgIT0gbXljaGlwLT5mbG9vcikgeworCQlEb0NfU2VsZWN0Rmxvb3IoZG9jcHRyLCBteWNoaXAtPmZsb29yKTsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0gZWxzZSBpZiAodGhpcy0+Y3VyY2hpcCAhPSBteWNoaXAtPmNoaXApIHsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0KKwl0aGlzLT5jdXJmbG9vciA9IG15Y2hpcC0+Zmxvb3I7CisJdGhpcy0+Y3VyY2hpcCA9IG15Y2hpcC0+Y2hpcDsKKworCS8qIE1pbGxlbm5pdW0gUGx1cyBidXMgY3ljbGUgc2VxdWVuY2UgYXMgcGVyIGZpZ3VyZSAyLCBzZWN0aW9uIDIuNCAqLworCVdyaXRlRE9DKERPQ19GTEFTSF9DRSwgZG9jcHRyLCBNcGx1c19GbGFzaFNlbGVjdCk7CisKKworCS8qIE1heGltdW0gb2YgMTYgYnl0ZXMgaW4gdGhlIE9PQiByZWdpb24sIHNvIGxpbWl0IHdyaXRlIHRvIHRoYXQgKi8KKwlpZiAobGVuID4gMTYpCisJCWxlbiA9IDE2OworCWdvdCA9IDA7CisJd2FudCA9IGxlbjsKKworCWZvciAoaSA9IDA7ICgoaSA8IDMpICYmICh3YW50ID4gMCkpOyBpKyspIHsKKwkJLyogUmVzZXQgdGhlIGNoaXAsIHNlZSBTb2Z0d2FyZSBSZXF1aXJlbWVudCAxMS40IGl0ZW0gMS4gKi8KKwkJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9SRVNFVCwgMCk7CisJCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCQkvKiBGaWd1cmUgb3V0IHdoaWNoIHJlZ2lvbiB3ZSBhcmUgYWNjZXNzaW5nLi4uICovCisJCWZvZnMgPSBvZnM7CisJCWJhc2UgPSBvZnMgJiAweDBmOworCQlpZiAoIXRoaXMtPmludGVybGVhdmUpIHsKKwkJCVdyaXRlRE9DKE5BTkRfQ01EX1JFQURPT0IsIGRvY3B0ciwgTXBsdXNfRmxhc2hDbWQpOworCQkJc2l6ZSA9IDE2IC0gYmFzZTsKKwkJfSBlbHNlIGlmIChiYXNlIDwgNikgeworCQkJV3JpdGVET0MoRG9DX0dldEVDQ09mZnNldChtdGQsICZmb2ZzKSwgZG9jcHRyLCBNcGx1c19GbGFzaENtZCk7CisJCQlzaXplID0gNiAtIGJhc2U7CisJCX0gZWxzZSBpZiAoYmFzZSA8IDgpIHsKKwkJCVdyaXRlRE9DKERvQ19HZXRGbGFnc09mZnNldChtdGQsICZmb2ZzKSwgZG9jcHRyLCBNcGx1c19GbGFzaENtZCk7CisJCQlzaXplID0gOCAtIGJhc2U7CisJCX0gZWxzZSB7CisJCQlXcml0ZURPQyhEb0NfR2V0SGRyT2Zmc2V0KG10ZCwgJmZvZnMpLCBkb2NwdHIsIE1wbHVzX0ZsYXNoQ21kKTsKKwkJCXNpemUgPSAxNiAtIGJhc2U7CisJCX0KKwkJaWYgKHNpemUgPiB3YW50KQorCQkJc2l6ZSA9IHdhbnQ7CisKKwkJLyogSXNzdWUgdGhlIFNlcmlhbCBEYXRhIEluIGNvbW1hbmQgdG8gaW5pdGlhbCB0aGUgUGFnZSBQcm9ncmFtIHByb2Nlc3MgKi8KKwkJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9TRVFJTiwgMHgwMCk7CisJCURvQ19BZGRyZXNzKHRoaXMsIDMsIGZvZnMsIDAsIDB4MDApOworCisJCS8qIERpc2FibGUgdGhlIEVDQyBlbmdpbmUgKi8KKwkJV3JpdGVET0MoRE9DX0VDQ19SRVNFVCwgZG9jcHRyLCBNcGx1c19FQ0NDb25mKTsKKworCQkvKiBXcml0ZSB0aGUgZGF0YSB2aWEgdGhlIGludGVybmFsIHBpcGVsaW5lIHRocm91Z2ggQ0RTTiBJTworCQkgICByZWdpc3Rlciwgc2VlIFBpcGVsaW5lZCBXcml0ZSBPcGVyYXRpb25zIDExLjIgKi8KKwkJTWVtV3JpdGVET0MoZG9jcHRyLCAodW5zaWduZWQgY2hhciAqKSAmYnVmW2dvdF0sIHNpemUpOworCQlXcml0ZURPQygweDAwLCBkb2NwdHIsIE1wbHVzX1dyaXRlUGlwZVRlcm0pOworCQlXcml0ZURPQygweDAwLCBkb2NwdHIsIE1wbHVzX1dyaXRlUGlwZVRlcm0pOworCisJCS8qIENvbW1pdCB0aGUgUGFnZSBQcm9ncmFtIGNvbW1hbmQgYW5kIHdhaXQgZm9yIHJlYWR5CisJIAkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDEuKi8KKwkJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9QQUdFUFJPRywgMHgwMCk7CisJCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCQkvKiBSZWFkIHRoZSBzdGF0dXMgb2YgdGhlIGZsYXNoIGRldmljZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIKKwkJICAgc2VlIFNvZnR3YXJlIFJlcXVpcmVtZW50IDExLjQgaXRlbSA1LiovCisJCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfU1RBVFVTLCAweDAwKTsKKwkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfUmVhZFBpcGVJbml0KTsKKwkJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfUmVhZFBpcGVJbml0KTsKKwkJRG9DX0RlbGF5KGRvY3B0ciwgMik7CisJCWlmICgoZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfTGFzdERhdGFSZWFkKSkgJiAxKSB7CisJCQlwcmludGsoIk1URDogRXJyb3IgMHgleCBwcm9ncmFtbWluZyBvb2IgYXQgMHgleFxuIiwKKwkJCQlkdW1teSwgKGludClvZnMpOworCQkJLyogRklYTUU6IGltcGxlbWVudCBCYWQgQmxvY2sgUmVwbGFjZW1lbnQgKi8KKwkJCSpyZXRsZW4gPSAwOworCQkJcmV0ID0gLUVJTzsKKwkJfQorCQlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19MYXN0RGF0YVJlYWQpOworCisJCW9mcyArPSBzaXplOworCQlnb3QgKz0gc2l6ZTsKKwkJd2FudCAtPSBzaXplOworCX0KKworCS8qIERpc2FibGUgZmxhc2ggaW50ZXJuYWxseSAqLworCVdyaXRlRE9DKDAsIGRvY3B0ciwgTXBsdXNfRmxhc2hTZWxlY3QpOworCisJKnJldGxlbiA9IGxlbjsKKwlyZXR1cm4gcmV0OworfQorCitpbnQgZG9jX2VyYXNlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpCit7CisJdm9sYXRpbGUgY2hhciBkdW1teTsKKwlzdHJ1Y3QgRGlza09uQ2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKKwlfX3UzMiBvZnMgPSBpbnN0ci0+YWRkcjsKKwlfX3UzMiBsZW4gPSBpbnN0ci0+bGVuOworCXZvaWQgX19pb21lbSAqIGRvY3B0ciA9IHRoaXMtPnZpcnRhZHI7CisJc3RydWN0IE5hbmQgKm15Y2hpcCA9ICZ0aGlzLT5jaGlwc1tvZnMgPj4gdGhpcy0+Y2hpcHNoaWZ0XTsKKworCURvQ19DaGVja0FTSUMoZG9jcHRyKTsKKworCWlmIChsZW4gIT0gbXRkLT5lcmFzZXNpemUpIAorCQlwcmludGsoS0VSTl9XQVJOSU5HICJNVEQ6IEVyYXNlIG5vdCByaWdodCBzaXplICgleCAhPSAleCluIiwKKwkJICAgICAgIGxlbiwgbXRkLT5lcmFzZXNpemUpOworCisJLyogRmluZCB0aGUgY2hpcCB3aGljaCBpcyB0byBiZSB1c2VkIGFuZCBzZWxlY3QgaXQgKi8KKwlpZiAodGhpcy0+Y3VyZmxvb3IgIT0gbXljaGlwLT5mbG9vcikgeworCQlEb0NfU2VsZWN0Rmxvb3IoZG9jcHRyLCBteWNoaXAtPmZsb29yKTsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0gZWxzZSBpZiAodGhpcy0+Y3VyY2hpcCAhPSBteWNoaXAtPmNoaXApIHsKKwkJRG9DX1NlbGVjdENoaXAoZG9jcHRyLCBteWNoaXAtPmNoaXApOworCX0KKwl0aGlzLT5jdXJmbG9vciA9IG15Y2hpcC0+Zmxvb3I7CisJdGhpcy0+Y3VyY2hpcCA9IG15Y2hpcC0+Y2hpcDsKKworCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9QRU5ESU5HOworCisJLyogTWlsbGVubml1bSBQbHVzIGJ1cyBjeWNsZSBzZXF1ZW5jZSBhcyBwZXIgZmlndXJlIDIsIHNlY3Rpb24gMi40ICovCisJV3JpdGVET0MoRE9DX0ZMQVNIX0NFLCBkb2NwdHIsIE1wbHVzX0ZsYXNoU2VsZWN0KTsKKworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfUkVTRVQsIDB4MDApOworCURvQ19XYWl0UmVhZHkoZG9jcHRyKTsKKworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfRVJBU0UxLCAwKTsKKwlEb0NfQWRkcmVzcyh0aGlzLCAyLCBvZnMsIDAsIDB4MDApOworCURvQ19Db21tYW5kKGRvY3B0ciwgTkFORF9DTURfRVJBU0UyLCAwKTsKKwlEb0NfV2FpdFJlYWR5KGRvY3B0cik7CisJaW5zdHItPnN0YXRlID0gTVREX0VSQVNJTkc7CisKKwkvKiBSZWFkIHRoZSBzdGF0dXMgb2YgdGhlIGZsYXNoIGRldmljZSB0aHJvdWdoIENEU04gSU8gcmVnaXN0ZXIKKwkgICBzZWUgU29mdHdhcmUgUmVxdWlyZW1lbnQgMTEuNCBpdGVtIDUuICovCisJRG9DX0NvbW1hbmQoZG9jcHRyLCBOQU5EX0NNRF9TVEFUVVMsIDApOworCWR1bW15ID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX1JlYWRQaXBlSW5pdCk7CisJZHVtbXkgPSBSZWFkRE9DKGRvY3B0ciwgTXBsdXNfUmVhZFBpcGVJbml0KTsKKwlpZiAoKGR1bW15ID0gUmVhZERPQyhkb2NwdHIsIE1wbHVzX0xhc3REYXRhUmVhZCkpICYgMSkgeworCQlwcmludGsoIk1URDogRXJyb3IgMHgleCBlcmFzaW5nIGF0IDB4JXhcbiIsIGR1bW15LCBvZnMpOworCQkvKiBGSVhNRTogaW1wbGVtZW50IEJhZCBCbG9jayBSZXBsYWNlbWVudCAoaW4gbmZ0bC5jID8/KSAqLworCQlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRkFJTEVEOworCX0gZWxzZSB7CisJCWluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9ET05FOworCX0KKwlkdW1teSA9IFJlYWRET0MoZG9jcHRyLCBNcGx1c19MYXN0RGF0YVJlYWQpOworCisJLyogRGlzYWJsZSBmbGFzaCBpbnRlcm5hbGx5ICovCisJV3JpdGVET0MoMCwgZG9jcHRyLCBNcGx1c19GbGFzaFNlbGVjdCk7CisKKwltdGRfZXJhc2VfY2FsbGJhY2soaW5zdHIpOworCisJcmV0dXJuIDA7Cit9CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogTW9kdWxlIHN0dWZmCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBpbnQgX19pbml0IGluaXRfZG9jMjAwMXBsdXModm9pZCkKK3sKKwlpbnRlcl9tb2R1bGVfcmVnaXN0ZXIoaW1fbmFtZSwgVEhJU19NT0RVTEUsICZEb0NNaWxQbHVzX2luaXQpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgY2xlYW51cF9kb2MyMDAxcGx1cyh2b2lkKQoreworCXN0cnVjdCBtdGRfaW5mbyAqbXRkOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzOworCisJd2hpbGUgKChtdGQ9ZG9jbWlscGx1c2xpc3QpKSB7CisJCXRoaXMgPSBtdGQtPnByaXY7CisJCWRvY21pbHBsdXNsaXN0ID0gdGhpcy0+bmV4dGRvYzsKKwkJCQorCQlkZWxfbXRkX2RldmljZShtdGQpOworCQkJCisJCWlvdW5tYXAodGhpcy0+dmlydGFkcik7CisJCWtmcmVlKHRoaXMtPmNoaXBzKTsKKwkJa2ZyZWUobXRkKTsKKwl9CisJaW50ZXJfbW9kdWxlX3VucmVnaXN0ZXIoaW1fbmFtZSk7Cit9CisKK21vZHVsZV9leGl0KGNsZWFudXBfZG9jMjAwMXBsdXMpOworbW9kdWxlX2luaXQoaW5pdF9kb2MyMDAxcGx1cyk7CisKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BVVRIT1IoIkdyZWcgVW5nZXJlciA8Z2VyZ0BzbmFwZ2Vhci5jb20+IGV0IGFsLiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJEcml2ZXIgZm9yIERpc2tPbkNoaXAgTWlsbGVubml1bSBQbHVzIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL2RvY2VjYy5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2NlY2MuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45MzM4NzdmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2NlY2MuYwpAQCAtMCwwICsxLDUyNiBAQAorLyoKKyAqIEVDQyBhbGdvcml0aG0gZm9yIE0tc3lzdGVtcyBkaXNrIG9uIGNoaXAuIFdlIHVzZSB0aGUgZXhjZWxsZW50IFJlZWQKKyAqIFNvbG1vbiBjb2RlIG9mIFBoaWwgS2FybiAoa2FybkBrYTlxLmFtcHIub3JnKSBhdmFpbGFibGUgdW5kZXIgdGhlCisgKiBHTlUgR1BMIExpY2Vuc2UuIFRoZSByZXN0IGlzIHNpbXBseSB0byBjb252ZXJ0IHRoZSBkaXNrIG9uIGNoaXAKKyAqIHN5bmRyb20gaW50byBhIHN0YW5kYXJkIHN5bmRvbS4KKyAqCisgKiBBdXRob3I6IEZhYnJpY2UgQmVsbGFyZCAoZmFicmljZS5iZWxsYXJkQG5ldGdlbS5jb20pIAorICogQ29weXJpZ2h0IChDKSAyMDAwIE5ldGdlbSBTLkEuCisgKgorICogJElkOiBkb2NlY2MuYyx2IDEuNSAyMDAzLzA1LzIxIDE1OjE1OjA2IGR3bXcyIEV4cCAkCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQorICovCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8YXNtL2Vycm5vLmg+CisjaW5jbHVkZSA8YXNtL2lvLmg+CisjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9taXNjZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2luY2x1ZGUgPGxpbnV4L210ZC9jb21wYXRtYWMuaD4gLyogZm9yIG1pbigpIGluIG9sZGVyIGtlcm5lbHMgKi8KKyNpbmNsdWRlIDxsaW51eC9tdGQvbXRkLmg+CisjaW5jbHVkZSA8bGludXgvbXRkL2RvYzIwMDAuaD4KKworLyogbmVlZCB0byB1bmRlZiBpdCAoZnJvbSBhc20vdGVybWJpdHMuaCkgKi8KKyN1bmRlZiBCMAorCisjZGVmaW5lIE1NIDEwIC8qIFN5bWJvbCBzaXplIGluIGJpdHMgKi8KKyNkZWZpbmUgS0sgKDEwMjMtNCkgLyogTnVtYmVyIG9mIGRhdGEgc3ltYm9scyBwZXIgYmxvY2sgKi8KKyNkZWZpbmUgQjAgNTEwIC8qIEZpcnN0IHJvb3Qgb2YgZ2VuZXJhdG9yIHBvbHlub21pYWwsIGFscGhhIGZvcm0gKi8KKyNkZWZpbmUgUFJJTSAxIC8qIHBvd2VyIG9mIGFscGhhIHVzZWQgdG8gZ2VuZXJhdGUgcm9vdHMgb2YgZ2VuZXJhdG9yIHBvbHkgKi8KKyNkZWZpbmUJTk4gKCgxIDw8IE1NKSAtIDEpCisKK3R5cGVkZWYgdW5zaWduZWQgc2hvcnQgZHR5cGU7CisKKy8qIDEreF4zK3heMTAgKi8KK3N0YXRpYyBjb25zdCBpbnQgUHBbTU0rMV0gPSB7IDEsIDAsIDAsIDEsIDAsIDAsIDAsIDAsIDAsIDAsIDEgfTsKKworLyogVGhpcyBkZWZpbmVzIHRoZSB0eXBlIHVzZWQgdG8gc3RvcmUgYW4gZWxlbWVudCBvZiB0aGUgR2Fsb2lzIEZpZWxkCisgKiB1c2VkIGJ5IHRoZSBjb2RlLiBNYWtlIHN1cmUgdGhpcyBpcyBzb21ldGhpbmcgbGFyZ2VyIHRoYW4gYSBjaGFyIGlmCisgKiBpZiBhbnl0aGluZyBsYXJnZXIgdGhhbiBHRigyNTYpIGlzIHVzZWQuCisgKgorICogTm90ZTogdW5zaWduZWQgY2hhciB3aWxsIHdvcmsgdXAgdG8gR0YoMjU2KSBidXQgaW50IHNlZW1zIHRvIHJ1bgorICogZmFzdGVyIG9uIHRoZSBQZW50aXVtLgorICovCit0eXBlZGVmIGludCBnZjsKKworLyogTm8gbGVnYWwgdmFsdWUgaW4gaW5kZXggZm9ybSByZXByZXNlbnRzIHplcm8sIHNvCisgKiB3ZSBuZWVkIGEgc3BlY2lhbCB2YWx1ZSBmb3IgdGhpcyBwdXJwb3NlCisgKi8KKyNkZWZpbmUgQTAJKE5OKQorCisvKiBDb21wdXRlIHggJSBOTiwgd2hlcmUgTk4gaXMgMioqTU0gLSAxLAorICogd2l0aG91dCBhIHNsb3cgZGl2aWRlCisgKi8KK3N0YXRpYyBpbmxpbmUgZ2YKK21vZG5uKGludCB4KQoreworICB3aGlsZSAoeCA+PSBOTikgeworICAgIHggLT0gTk47CisgICAgeCA9ICh4ID4+IE1NKSArICh4ICYgTk4pOworICB9CisgIHJldHVybiB4OworfQorCisjZGVmaW5lCUNMRUFSKGEsbikge1wKK2ludCBjaTtcCitmb3IoY2k9KG4pLTE7Y2kgPj0wO2NpLS0pXAorKGEpW2NpXSA9IDA7XAorfQorCisjZGVmaW5lCUNPUFkoYSxiLG4pIHtcCitpbnQgY2k7XAorZm9yKGNpPShuKS0xO2NpID49MDtjaS0tKVwKKyhhKVtjaV0gPSAoYilbY2ldO1wKK30KKworI2RlZmluZQlDT1BZRE9XTihhLGIsbikge1wKK2ludCBjaTtcCitmb3IoY2k9KG4pLTE7Y2kgPj0wO2NpLS0pXAorKGEpW2NpXSA9IChiKVtjaV07XAorfQorCisjZGVmaW5lIExkZWMgMQorCisvKiBnZW5lcmF0ZSBHRigyKiptKSBmcm9tIHRoZSBpcnJlZHVjaWJsZSBwb2x5bm9taWFsIHAoWCkgaW4gUHBbMF0uLlBwW21dCisgICBsb29rdXAgdGFibGVzOiAgaW5kZXgtPnBvbHlub21pYWwgZm9ybSAgIGFscGhhX3RvW10gY29udGFpbnMgaj1hbHBoYSoqaTsKKyAgICAgICAgICAgICAgICAgICBwb2x5bm9taWFsIGZvcm0gLT4gaW5kZXggZm9ybSAgaW5kZXhfb2Zbaj1hbHBoYSoqaV0gPSBpCisgICBhbHBoYT0yIGlzIHRoZSBwcmltaXRpdmUgZWxlbWVudCBvZiBHRigyKiptKQorICAgSEFSSSdzIENPTU1FTlQ6ICg0LzEzLzk0KSBhbHBoYV90b1tdIGNhbiBiZSB1c2VkIGFzIGZvbGxvd3M6CisgICAgICAgIExldCBAIHJlcHJlc2VudCB0aGUgcHJpbWl0aXZlIGVsZW1lbnQgY29tbW9ubHkgY2FsbGVkICJhbHBoYSIgdGhhdAorICAgaXMgdGhlIHJvb3Qgb2YgdGhlIHByaW1pdGl2ZSBwb2x5bm9taWFsIHAoeCkuIFRoZW4gaW4gR0YoMl5tKSwgZm9yIGFueQorICAgMCA8PSBpIDw9IDJebS0yLAorICAgICAgICBAXmkgPSBhKDApICsgYSgxKSBAICsgYSgyKSBAXjIgKyAuLi4gKyBhKG0tMSkgQF4obS0xKQorICAgd2hlcmUgdGhlIGJpbmFyeSB2ZWN0b3IgKGEoMCksYSgxKSxhKDIpLC4uLixhKG0tMSkpIGlzIHRoZSByZXByZXNlbnRhdGlvbgorICAgb2YgdGhlIGludGVnZXIgImFscGhhX3RvW2ldIiB3aXRoIGEoMCkgYmVpbmcgdGhlIExTQiBhbmQgYShtLTEpIHRoZSBNU0IuIFRodXMgZm9yCisgICBleGFtcGxlIHRoZSBwb2x5bm9taWFsIHJlcHJlc2VudGF0aW9uIG9mIEBeNSB3b3VsZCBiZSBnaXZlbiBieSB0aGUgYmluYXJ5CisgICByZXByZXNlbnRhdGlvbiBvZiB0aGUgaW50ZWdlciAiYWxwaGFfdG9bNV0iLgorICAgICAgICAgICAgICAgICAgIFNpbWlsYXJpbHksIGluZGV4X29mW10gY2FuIGJlIHVzZWQgYXMgZm9sbG93czoKKyAgICAgICAgQXMgYWJvdmUsIGxldCBAIHJlcHJlc2VudCB0aGUgcHJpbWl0aXZlIGVsZW1lbnQgb2YgR0YoMl5tKSB0aGF0IGlzCisgICB0aGUgcm9vdCBvZiB0aGUgcHJpbWl0aXZlIHBvbHlub21pYWwgcCh4KS4gSW4gb3JkZXIgdG8gZmluZCB0aGUgcG93ZXIKKyAgIG9mIEAgKGFscGhhKSB0aGF0IGhhcyB0aGUgcG9seW5vbWlhbCByZXByZXNlbnRhdGlvbgorICAgICAgICBhKDApICsgYSgxKSBAICsgYSgyKSBAXjIgKyAuLi4gKyBhKG0tMSkgQF4obS0xKQorICAgd2UgY29uc2lkZXIgdGhlIGludGVnZXIgImkiIHdob3NlIGJpbmFyeSByZXByZXNlbnRhdGlvbiB3aXRoIGEoMCkgYmVpbmcgTFNCCisgICBhbmQgYShtLTEpIE1TQiBpcyAoYSgwKSxhKDEpLC4uLixhKG0tMSkpIGFuZCBsb2NhdGUgdGhlIGVudHJ5CisgICAiaW5kZXhfb2ZbaV0iLiBOb3csIEBeaW5kZXhfb2ZbaV0gaXMgdGhhdCBlbGVtZW50IHdob3NlIHBvbHlub21pYWwgCisgICAgcmVwcmVzZW50YXRpb24gaXMgKGEoMCksYSgxKSxhKDIpLC4uLixhKG0tMSkpLgorICAgTk9URToKKyAgICAgICAgVGhlIGVsZW1lbnQgYWxwaGFfdG9bMl5tLTFdID0gMCBhbHdheXMgc2lnbmlmeWluZyB0aGF0IHRoZQorICAgcmVwcmVzZW50YXRpb24gb2YgIkBeaW5maW5pdHkiID0gMCBpcyAoMCwwLDAsLi4uLDApLgorICAgICAgICBTaW1pbGFyaWx5LCB0aGUgZWxlbWVudCBpbmRleF9vZlswXSA9IEEwIGFsd2F5cyBzaWduaWZ5aW5nCisgICB0aGF0IHRoZSBwb3dlciBvZiBhbHBoYSB3aGljaCBoYXMgdGhlIHBvbHlub21pYWwgcmVwcmVzZW50YXRpb24KKyAgICgwLDAsLi4uLDApIGlzICJpbmZpbml0eSIuCisgCisqLworCitzdGF0aWMgdm9pZAorZ2VuZXJhdGVfZ2YoZHR5cGUgQWxwaGFfdG9bTk4gKyAxXSwgZHR5cGUgSW5kZXhfb2ZbTk4gKyAxXSkKK3sKKyAgcmVnaXN0ZXIgaW50IGksIG1hc2s7CisKKyAgbWFzayA9IDE7CisgIEFscGhhX3RvW01NXSA9IDA7CisgIGZvciAoaSA9IDA7IGkgPCBNTTsgaSsrKSB7CisgICAgQWxwaGFfdG9baV0gPSBtYXNrOworICAgIEluZGV4X29mW0FscGhhX3RvW2ldXSA9IGk7CisgICAgLyogSWYgUHBbaV0gPT0gMSB0aGVuLCB0ZXJtIEBeaSBvY2N1cnMgaW4gcG9seS1yZXByIG9mIEBeTU0gKi8KKyAgICBpZiAoUHBbaV0gIT0gMCkKKyAgICAgIEFscGhhX3RvW01NXSBePSBtYXNrOwkvKiBCaXQtd2lzZSBFWE9SIG9wZXJhdGlvbiAqLworICAgIG1hc2sgPDw9IDE7CS8qIHNpbmdsZSBsZWZ0LXNoaWZ0ICovCisgIH0KKyAgSW5kZXhfb2ZbQWxwaGFfdG9bTU1dXSA9IE1NOworICAvKgorICAgKiBIYXZlIG9idGFpbmVkIHBvbHktcmVwciBvZiBAXk1NLiBQb2x5LXJlcHIgb2YgQF4oaSsxKSBpcyBnaXZlbiBieQorICAgKiBwb2x5LXJlcHIgb2YgQF5pIHNoaWZ0ZWQgbGVmdCBvbmUtYml0IGFuZCBhY2NvdW50aW5nIGZvciBhbnkgQF5NTQorICAgKiB0ZXJtIHRoYXQgbWF5IG9jY3VyIHdoZW4gcG9seS1yZXByIG9mIEBeaSBpcyBzaGlmdGVkLgorICAgKi8KKyAgbWFzayA+Pj0gMTsKKyAgZm9yIChpID0gTU0gKyAxOyBpIDwgTk47IGkrKykgeworICAgIGlmIChBbHBoYV90b1tpIC0gMV0gPj0gbWFzaykKKyAgICAgIEFscGhhX3RvW2ldID0gQWxwaGFfdG9bTU1dIF4gKChBbHBoYV90b1tpIC0gMV0gXiBtYXNrKSA8PCAxKTsKKyAgICBlbHNlCisgICAgICBBbHBoYV90b1tpXSA9IEFscGhhX3RvW2kgLSAxXSA8PCAxOworICAgIEluZGV4X29mW0FscGhhX3RvW2ldXSA9IGk7CisgIH0KKyAgSW5kZXhfb2ZbMF0gPSBBMDsKKyAgQWxwaGFfdG9bTk5dID0gMDsKK30KKworLyoKKyAqIFBlcmZvcm1zIEVSUk9SUytFUkFTVVJFUyBkZWNvZGluZyBvZiBSUyBjb2Rlcy4gYmJbXSBpcyB0aGUgY29udGVudAorICogb2YgdGhlIGZlZWRiYWNrIHNoaWZ0IHJlZ2lzdGVyIGFmdGVyIGhhdmluZyBwcm9jZXNzZWQgdGhlIGRhdGEgYW5kCisgKiB0aGUgRUNDLgorICoKKyAqIFJldHVybiBudW1iZXIgb2Ygc3ltYm9scyBjb3JyZWN0ZWQsIG9yIC0xIGlmIGNvZGV3b3JkIGlzIGlsbGVnYWwKKyAqIG9yIHVuY29ycmVjdGFibGUuIElmIGVyYXNfcG9zIGlzIG5vbi1udWxsLCB0aGUgZGV0ZWN0ZWQgZXJyb3IgbG9jYXRpb25zCisgKiBhcmUgd3JpdHRlbiBiYWNrLiBOT1RFISBUaGlzIGFycmF5IG11c3QgYmUgYXQgbGVhc3QgTk4tS0sgZWxlbWVudHMgbG9uZy4KKyAqIFRoZSBjb3JyZWN0ZWQgZGF0YSBhcmUgd3JpdHRlbiBpbiBlcmFzX3ZhbFtdLiBUaGV5IG11c3QgYmUgeG9yIHdpdGggdGhlIGRhdGEKKyAqIHRvIHJldHJpZXZlIHRoZSBjb3JyZWN0IGRhdGEgOiBkYXRhW2VyYXNlX3Bvc1tpXV0gXj0gZXJhc2VfdmFsW2ldIC4KKyAqIAorICogRmlyc3QgIm5vX2VyYXMiIGVyYXN1cmVzIGFyZSBkZWNsYXJlZCBieSB0aGUgY2FsbGluZyBwcm9ncmFtLiBUaGVuLCB0aGUKKyAqIG1heGltdW0gIyBvZiBlcnJvcnMgY29ycmVjdGFibGUgaXMgdF9hZnRlcl9lcmFzID0gZmxvb3IoKE5OLUtLLW5vX2VyYXMpLzIpLgorICogSWYgdGhlIG51bWJlciBvZiBjaGFubmVsIGVycm9ycyBpcyBub3QgZ3JlYXRlciB0aGFuICJ0X2FmdGVyX2VyYXMiIHRoZQorICogdHJhbnNtaXR0ZWQgY29kZXdvcmQgd2lsbCBiZSByZWNvdmVyZWQuIERldGFpbHMgb2YgYWxnb3JpdGhtIGNhbiBiZSBmb3VuZAorICogaW4gUi4gQmxhaHV0J3MgIlRoZW9yeSAuLi4gb2YgRXJyb3ItQ29ycmVjdGluZyBDb2RlcyIuCisKKyAqIFdhcm5pbmc6IHRoZSBlcmFzX3Bvc1tdIGFycmF5IG11c3Qgbm90IGNvbnRhaW4gZHVwbGljYXRlIGVudHJpZXM7IGRlY29kZXIgZmFpbHVyZQorICogd2lsbCByZXN1bHQuIFRoZSBkZWNvZGVyICpjb3VsZCogY2hlY2sgZm9yIHRoaXMgY29uZGl0aW9uLCBidXQgaXQgd291bGQgaW52b2x2ZQorICogZXh0cmEgdGltZSBvbiBldmVyeSBkZWNvZGluZyBvcGVyYXRpb24uCisgKiAqLworc3RhdGljIGludAorZXJhc19kZWNfcnMoZHR5cGUgQWxwaGFfdG9bTk4gKyAxXSwgZHR5cGUgSW5kZXhfb2ZbTk4gKyAxXSwKKyAgICAgICAgICAgIGdmIGJiW05OIC0gS0sgKyAxXSwgZ2YgZXJhc192YWxbTk4tS0tdLCBpbnQgZXJhc19wb3NbTk4tS0tdLCAKKyAgICAgICAgICAgIGludCBub19lcmFzKQoreworICBpbnQgZGVnX2xhbWJkYSwgZWwsIGRlZ19vbWVnYTsKKyAgaW50IGksIGosIHIsazsKKyAgZ2YgdSxxLHRtcCxudW0xLG51bTIsZGVuLGRpc2NyX3I7CisgIGdmIGxhbWJkYVtOTi1LSyArIDFdLCBzW05OLUtLICsgMV07CS8qIEVycitFcmFzIExvY2F0b3IgcG9seQorCQkJCQkgKiBhbmQgc3luZHJvbWUgcG9seSAqLworICBnZiBiW05OLUtLICsgMV0sIHRbTk4tS0sgKyAxXSwgb21lZ2FbTk4tS0sgKyAxXTsKKyAgZ2Ygcm9vdFtOTi1LS10sIHJlZ1tOTi1LSyArIDFdLCBsb2NbTk4tS0tdOworICBpbnQgc3luX2Vycm9yLCBjb3VudDsKKworICBzeW5fZXJyb3IgPSAwOworICBmb3IoaT0wO2k8Tk4tS0s7aSsrKQorICAgICAgc3luX2Vycm9yIHw9IGJiW2ldOworCisgIGlmICghc3luX2Vycm9yKSB7CisgICAgLyogaWYgcmVtYWluZGVyIGlzIHplcm8sIGRhdGFbXSBpcyBhIGNvZGV3b3JkIGFuZCB0aGVyZSBhcmUgbm8KKyAgICAgKiBlcnJvcnMgdG8gY29ycmVjdC4gU28gcmV0dXJuIGRhdGFbXSB1bm1vZGlmaWVkCisgICAgICovCisgICAgY291bnQgPSAwOworICAgIGdvdG8gZmluaXNoOworICB9CisgIAorICBmb3IoaT0xO2k8PU5OLUtLO2krKyl7CisgICAgc1tpXSA9IGJiWzBdOworICB9CisgIGZvcihqPTE7ajxOTi1LSztqKyspeworICAgIGlmKGJiW2pdID09IDApCisgICAgICBjb250aW51ZTsKKyAgICB0bXAgPSBJbmRleF9vZltiYltqXV07CisgICAgCisgICAgZm9yKGk9MTtpPD1OTi1LSztpKyspCisgICAgICBzW2ldIF49IEFscGhhX3RvW21vZG5uKHRtcCArIChCMCtpLTEpKlBSSU0qaildOworICB9CisKKyAgLyogdW5kbyB0aGUgZmVlZGJhY2sgcmVnaXN0ZXIgaW1wbGljaXQgbXVsdGlwbGljYXRpb24gYW5kIGNvbnZlcnQKKyAgICAgc3luZHJvbWVzIHRvIGluZGV4IGZvcm0gKi8KKworICBmb3IoaT0xO2k8PU5OLUtLO2krKykgeworICAgICAgdG1wID0gSW5kZXhfb2Zbc1tpXV07CisgICAgICBpZiAodG1wICE9IEEwKQorICAgICAgICAgIHRtcCA9IG1vZG5uKHRtcCArIDIgKiBLSyAqIChCMCtpLTEpKlBSSU0pOworICAgICAgc1tpXSA9IHRtcDsKKyAgfQorICAKKyAgQ0xFQVIoJmxhbWJkYVsxXSxOTi1LSyk7CisgIGxhbWJkYVswXSA9IDE7CisKKyAgaWYgKG5vX2VyYXMgPiAwKSB7CisgICAgLyogSW5pdCBsYW1iZGEgdG8gYmUgdGhlIGVyYXN1cmUgbG9jYXRvciBwb2x5bm9taWFsICovCisgICAgbGFtYmRhWzFdID0gQWxwaGFfdG9bbW9kbm4oUFJJTSAqIGVyYXNfcG9zWzBdKV07CisgICAgZm9yIChpID0gMTsgaSA8IG5vX2VyYXM7IGkrKykgeworICAgICAgdSA9IG1vZG5uKFBSSU0qZXJhc19wb3NbaV0pOworICAgICAgZm9yIChqID0gaSsxOyBqID4gMDsgai0tKSB7CisJdG1wID0gSW5kZXhfb2ZbbGFtYmRhW2ogLSAxXV07CisJaWYodG1wICE9IEEwKQorCSAgbGFtYmRhW2pdIF49IEFscGhhX3RvW21vZG5uKHUgKyB0bXApXTsKKyAgICAgIH0KKyAgICB9CisjaWYgREVCVUcgPj0gMQorICAgIC8qIFRlc3QgY29kZSB0aGF0IHZlcmlmaWVzIHRoZSBlcmFzdXJlIGxvY2F0b3IgcG9seW5vbWlhbCBqdXN0IGNvbnN0cnVjdGVkCisgICAgICAgTmVlZGVkIG9ubHkgZm9yIGRlY29kZXIgZGVidWdnaW5nLiAqLworICAgIAorICAgIC8qIGZpbmQgcm9vdHMgb2YgdGhlIGVyYXN1cmUgbG9jYXRpb24gcG9seW5vbWlhbCAqLworICAgIGZvcihpPTE7aTw9bm9fZXJhcztpKyspCisgICAgICByZWdbaV0gPSBJbmRleF9vZltsYW1iZGFbaV1dOworICAgIGNvdW50ID0gMDsKKyAgICBmb3IgKGkgPSAxLGs9Tk4tTGRlYzsgaSA8PSBOTjsgaSsrLGsgPSBtb2RubihOTitrLUxkZWMpKSB7CisgICAgICBxID0gMTsKKyAgICAgIGZvciAoaiA9IDE7IGogPD0gbm9fZXJhczsgaisrKQorCWlmIChyZWdbal0gIT0gQTApIHsKKwkgIHJlZ1tqXSA9IG1vZG5uKHJlZ1tqXSArIGopOworCSAgcSBePSBBbHBoYV90b1tyZWdbal1dOworCX0KKyAgICAgIGlmIChxICE9IDApCisJY29udGludWU7CisgICAgICAvKiBzdG9yZSByb290IGFuZCBlcnJvciBsb2NhdGlvbiBudW1iZXIgaW5kaWNlcyAqLworICAgICAgcm9vdFtjb3VudF0gPSBpOworICAgICAgbG9jW2NvdW50XSA9IGs7CisgICAgICBjb3VudCsrOworICAgIH0KKyAgICBpZiAoY291bnQgIT0gbm9fZXJhcykgeworICAgICAgcHJpbnRmKCJcbiBsYW1iZGEoeCkgaXMgV1JPTkdcbiIpOworICAgICAgY291bnQgPSAtMTsKKyAgICAgIGdvdG8gZmluaXNoOworICAgIH0KKyNpZiBERUJVRyA+PSAyCisgICAgcHJpbnRmKCJcbiBFcmFzdXJlIHBvc2l0aW9ucyBhcyBkZXRlcm1pbmVkIGJ5IHJvb3RzIG9mIEVyYXMgTG9jIFBvbHk6XG4iKTsKKyAgICBmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykKKyAgICAgIHByaW50ZigiJWQgIiwgbG9jW2ldKTsKKyAgICBwcmludGYoIlxuIik7CisjZW5kaWYKKyNlbmRpZgorICB9CisgIGZvcihpPTA7aTxOTi1LSysxO2krKykKKyAgICBiW2ldID0gSW5kZXhfb2ZbbGFtYmRhW2ldXTsKKyAgCisgIC8qCisgICAqIEJlZ2luIEJlcmxla2FtcC1NYXNzZXkgYWxnb3JpdGhtIHRvIGRldGVybWluZSBlcnJvcitlcmFzdXJlCisgICAqIGxvY2F0b3IgcG9seW5vbWlhbAorICAgKi8KKyAgciA9IG5vX2VyYXM7CisgIGVsID0gbm9fZXJhczsKKyAgd2hpbGUgKCsrciA8PSBOTi1LSykgewkvKiByIGlzIHRoZSBzdGVwIG51bWJlciAqLworICAgIC8qIENvbXB1dGUgZGlzY3JlcGFuY3kgYXQgdGhlIHItdGggc3RlcCBpbiBwb2x5LWZvcm0gKi8KKyAgICBkaXNjcl9yID0gMDsKKyAgICBmb3IgKGkgPSAwOyBpIDwgcjsgaSsrKXsKKyAgICAgIGlmICgobGFtYmRhW2ldICE9IDApICYmIChzW3IgLSBpXSAhPSBBMCkpIHsKKwlkaXNjcl9yIF49IEFscGhhX3RvW21vZG5uKEluZGV4X29mW2xhbWJkYVtpXV0gKyBzW3IgLSBpXSldOworICAgICAgfQorICAgIH0KKyAgICBkaXNjcl9yID0gSW5kZXhfb2ZbZGlzY3Jfcl07CS8qIEluZGV4IGZvcm0gKi8KKyAgICBpZiAoZGlzY3JfciA9PSBBMCkgeworICAgICAgLyogMiBsaW5lcyBiZWxvdzogQih4KSA8LS0geCpCKHgpICovCisgICAgICBDT1BZRE9XTigmYlsxXSxiLE5OLUtLKTsKKyAgICAgIGJbMF0gPSBBMDsKKyAgICB9IGVsc2UgeworICAgICAgLyogNyBsaW5lcyBiZWxvdzogVCh4KSA8LS0gbGFtYmRhKHgpIC0gZGlzY3Jfcip4KmIoeCkgKi8KKyAgICAgIHRbMF0gPSBsYW1iZGFbMF07CisgICAgICBmb3IgKGkgPSAwIDsgaSA8IE5OLUtLOyBpKyspIHsKKwlpZihiW2ldICE9IEEwKQorCSAgdFtpKzFdID0gbGFtYmRhW2krMV0gXiBBbHBoYV90b1ttb2RubihkaXNjcl9yICsgYltpXSldOworCWVsc2UKKwkgIHRbaSsxXSA9IGxhbWJkYVtpKzFdOworICAgICAgfQorICAgICAgaWYgKDIgKiBlbCA8PSByICsgbm9fZXJhcyAtIDEpIHsKKwllbCA9IHIgKyBub19lcmFzIC0gZWw7CisJLyoKKwkgKiAyIGxpbmVzIGJlbG93OiBCKHgpIDwtLSBpbnYoZGlzY3JfcikgKgorCSAqIGxhbWJkYSh4KQorCSAqLworCWZvciAoaSA9IDA7IGkgPD0gTk4tS0s7IGkrKykKKwkgIGJbaV0gPSAobGFtYmRhW2ldID09IDApID8gQTAgOiBtb2RubihJbmRleF9vZltsYW1iZGFbaV1dIC0gZGlzY3JfciArIE5OKTsKKyAgICAgIH0gZWxzZSB7CisJLyogMiBsaW5lcyBiZWxvdzogQih4KSA8LS0geCpCKHgpICovCisJQ09QWURPV04oJmJbMV0sYixOTi1LSyk7CisJYlswXSA9IEEwOworICAgICAgfQorICAgICAgQ09QWShsYW1iZGEsdCxOTi1LSysxKTsKKyAgICB9CisgIH0KKworICAvKiBDb252ZXJ0IGxhbWJkYSB0byBpbmRleCBmb3JtIGFuZCBjb21wdXRlIGRlZyhsYW1iZGEoeCkpICovCisgIGRlZ19sYW1iZGEgPSAwOworICBmb3IoaT0wO2k8Tk4tS0srMTtpKyspeworICAgIGxhbWJkYVtpXSA9IEluZGV4X29mW2xhbWJkYVtpXV07CisgICAgaWYobGFtYmRhW2ldICE9IEEwKQorICAgICAgZGVnX2xhbWJkYSA9IGk7CisgIH0KKyAgLyoKKyAgICogRmluZCByb290cyBvZiB0aGUgZXJyb3IrZXJhc3VyZSBsb2NhdG9yIHBvbHlub21pYWwgYnkgQ2hpZW4KKyAgICogU2VhcmNoCisgICAqLworICBDT1BZKCZyZWdbMV0sJmxhbWJkYVsxXSxOTi1LSyk7CisgIGNvdW50ID0gMDsJCS8qIE51bWJlciBvZiByb290cyBvZiBsYW1iZGEoeCkgKi8KKyAgZm9yIChpID0gMSxrPU5OLUxkZWM7IGkgPD0gTk47IGkrKyxrID0gbW9kbm4oTk4ray1MZGVjKSkgeworICAgIHEgPSAxOworICAgIGZvciAoaiA9IGRlZ19sYW1iZGE7IGogPiAwOyBqLS0peworICAgICAgaWYgKHJlZ1tqXSAhPSBBMCkgeworCXJlZ1tqXSA9IG1vZG5uKHJlZ1tqXSArIGopOworCXEgXj0gQWxwaGFfdG9bcmVnW2pdXTsKKyAgICAgIH0KKyAgICB9CisgICAgaWYgKHEgIT0gMCkKKyAgICAgIGNvbnRpbnVlOworICAgIC8qIHN0b3JlIHJvb3QgKGluZGV4LWZvcm0pIGFuZCBlcnJvciBsb2NhdGlvbiBudW1iZXIgKi8KKyAgICByb290W2NvdW50XSA9IGk7CisgICAgbG9jW2NvdW50XSA9IGs7CisgICAgLyogSWYgd2UndmUgYWxyZWFkeSBmb3VuZCBtYXggcG9zc2libGUgcm9vdHMsCisgICAgICogYWJvcnQgdGhlIHNlYXJjaCB0byBzYXZlIHRpbWUKKyAgICAgKi8KKyAgICBpZigrK2NvdW50ID09IGRlZ19sYW1iZGEpCisgICAgICBicmVhazsKKyAgfQorICBpZiAoZGVnX2xhbWJkYSAhPSBjb3VudCkgeworICAgIC8qCisgICAgICogZGVnKGxhbWJkYSkgdW5lcXVhbCB0byBudW1iZXIgb2Ygcm9vdHMgPT4gdW5jb3JyZWN0YWJsZQorICAgICAqIGVycm9yIGRldGVjdGVkCisgICAgICovCisgICAgY291bnQgPSAtMTsKKyAgICBnb3RvIGZpbmlzaDsKKyAgfQorICAvKgorICAgKiBDb21wdXRlIGVycitlcmFzIGV2YWx1YXRvciBwb2x5IG9tZWdhKHgpID0gcyh4KSpsYW1iZGEoeCkgKG1vZHVsbworICAgKiB4KiooTk4tS0spKS4gaW4gaW5kZXggZm9ybS4gQWxzbyBmaW5kIGRlZyhvbWVnYSkuCisgICAqLworICBkZWdfb21lZ2EgPSAwOworICBmb3IgKGkgPSAwOyBpIDwgTk4tS0s7aSsrKXsKKyAgICB0bXAgPSAwOworICAgIGogPSAoZGVnX2xhbWJkYSA8IGkpID8gZGVnX2xhbWJkYSA6IGk7CisgICAgZm9yKDtqID49IDA7IGotLSl7CisgICAgICBpZiAoKHNbaSArIDEgLSBqXSAhPSBBMCkgJiYgKGxhbWJkYVtqXSAhPSBBMCkpCisJdG1wIF49IEFscGhhX3RvW21vZG5uKHNbaSArIDEgLSBqXSArIGxhbWJkYVtqXSldOworICAgIH0KKyAgICBpZih0bXAgIT0gMCkKKyAgICAgIGRlZ19vbWVnYSA9IGk7CisgICAgb21lZ2FbaV0gPSBJbmRleF9vZlt0bXBdOworICB9CisgIG9tZWdhW05OLUtLXSA9IEEwOworICAKKyAgLyoKKyAgICogQ29tcHV0ZSBlcnJvciB2YWx1ZXMgaW4gcG9seS1mb3JtLiBudW0xID0gb21lZ2EoaW52KFgobCkpKSwgbnVtMiA9CisgICAqIGludihYKGwpKSoqKEIwLTEpIGFuZCBkZW4gPSBsYW1iZGFfcHIoaW52KFgobCkpKSBhbGwgaW4gcG9seS1mb3JtCisgICAqLworICBmb3IgKGogPSBjb3VudC0xOyBqID49MDsgai0tKSB7CisgICAgbnVtMSA9IDA7CisgICAgZm9yIChpID0gZGVnX29tZWdhOyBpID49IDA7IGktLSkgeworICAgICAgaWYgKG9tZWdhW2ldICE9IEEwKQorCW51bTEgIF49IEFscGhhX3RvW21vZG5uKG9tZWdhW2ldICsgaSAqIHJvb3Rbal0pXTsKKyAgICB9CisgICAgbnVtMiA9IEFscGhhX3RvW21vZG5uKHJvb3Rbal0gKiAoQjAgLSAxKSArIE5OKV07CisgICAgZGVuID0gMDsKKyAgICAKKyAgICAvKiBsYW1iZGFbaSsxXSBmb3IgaSBldmVuIGlzIHRoZSBmb3JtYWwgZGVyaXZhdGl2ZSBsYW1iZGFfcHIgb2YgbGFtYmRhW2ldICovCisgICAgZm9yIChpID0gbWluKGRlZ19sYW1iZGEsTk4tS0stMSkgJiB+MTsgaSA+PSAwOyBpIC09MikgeworICAgICAgaWYobGFtYmRhW2krMV0gIT0gQTApCisJZGVuIF49IEFscGhhX3RvW21vZG5uKGxhbWJkYVtpKzFdICsgaSAqIHJvb3Rbal0pXTsKKyAgICB9CisgICAgaWYgKGRlbiA9PSAwKSB7CisjaWYgREVCVUcgPj0gMQorICAgICAgcHJpbnRmKCJcbiBFUlJPUjogZGVub21pbmF0b3IgPSAwXG4iKTsKKyNlbmRpZgorICAgICAgLyogQ29udmVydCB0byBkdWFsLSBiYXNpcyAqLworICAgICAgY291bnQgPSAtMTsKKyAgICAgIGdvdG8gZmluaXNoOworICAgIH0KKyAgICAvKiBBcHBseSBlcnJvciB0byBkYXRhICovCisgICAgaWYgKG51bTEgIT0gMCkgeworICAgICAgICBlcmFzX3ZhbFtqXSA9IEFscGhhX3RvW21vZG5uKEluZGV4X29mW251bTFdICsgSW5kZXhfb2ZbbnVtMl0gKyBOTiAtIEluZGV4X29mW2Rlbl0pXTsKKyAgICB9IGVsc2UgeworICAgICAgICBlcmFzX3ZhbFtqXSA9IDA7CisgICAgfQorICB9CisgZmluaXNoOgorICBmb3IoaT0wO2k8Y291bnQ7aSsrKQorICAgICAgZXJhc19wb3NbaV0gPSBsb2NbaV07CisgIHJldHVybiBjb3VudDsKK30KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKy8qIFRoZSBET0Mgc3BlY2lmaWMgY29kZSBiZWdpbnMgaGVyZSAqLworCisjZGVmaW5lIFNFQ1RPUl9TSVpFIDUxMgorLyogVGhlIHNlY3RvciBieXRlcyBhcmUgcGFja2VkIGludG8gTkJfREFUQSBNTSBiaXRzIHdvcmRzICovCisjZGVmaW5lIE5CX0RBVEEgKCgoU0VDVE9SX1NJWkUgKyAxKSAqIDggKyA2KSAvIE1NKQorCisvKiAKKyAqIENvcnJlY3QgdGhlIGVycm9ycyBpbiAnc2VjdG9yW10nIGJ5IHVzaW5nICdlY2MxW10nIHdoaWNoIGlzIHRoZQorICogY29udGVudCBvZiB0aGUgZmVlZGJhY2sgc2hpZnQgcmVnaXN0ZXIgYXBwbHlpZWQgdG8gdGhlIHNlY3RvciBhbmQKKyAqIHRoZSBFQ0MuIFJldHVybiB0aGUgbnVtYmVyIG9mIGVycm9ycyBjb3JyZWN0ZWQgKGFuZCBjb3JyZWN0IHRoZW0gaW4KKyAqIHNlY3RvciksIG9yIC0xIGlmIGVycm9yIAorICovCitpbnQgZG9jX2RlY29kZV9lY2ModW5zaWduZWQgY2hhciBzZWN0b3JbU0VDVE9SX1NJWkVdLCB1bnNpZ25lZCBjaGFyIGVjYzFbNl0pCit7CisgICAgaW50IHBhcml0eSwgaSwgbmJfZXJyb3JzOworICAgIGdmIGJiW05OIC0gS0sgKyAxXTsKKyAgICBnZiBlcnJvcl92YWxbTk4tS0tdOworICAgIGludCBlcnJvcl9wb3NbTk4tS0tdLCBwb3MsIGJpdHBvcywgaW5kZXgsIHZhbDsKKyAgICBkdHlwZSAqQWxwaGFfdG8sICpJbmRleF9vZjsKKworICAgIC8qIGluaXQgbG9nIGFuZCBleHAgdGFibGVzIGhlcmUgdG8gc2F2ZSBtZW1vcnkuIEhvd2V2ZXIsIGl0IGlzIHNsb3dlciAqLworICAgIEFscGhhX3RvID0ga21hbGxvYygoTk4gKyAxKSAqIHNpemVvZihkdHlwZSksIEdGUF9LRVJORUwpOworICAgIGlmICghQWxwaGFfdG8pCisgICAgICAgIHJldHVybiAtMTsKKyAgICAKKyAgICBJbmRleF9vZiA9IGttYWxsb2MoKE5OICsgMSkgKiBzaXplb2YoZHR5cGUpLCBHRlBfS0VSTkVMKTsKKyAgICBpZiAoIUluZGV4X29mKSB7CisgICAgICAgIGtmcmVlKEFscGhhX3RvKTsKKyAgICAgICAgcmV0dXJuIC0xOworICAgIH0KKworICAgIGdlbmVyYXRlX2dmKEFscGhhX3RvLCBJbmRleF9vZik7CisKKyAgICBwYXJpdHkgPSBlY2MxWzFdOworCisgICAgYmJbMF0gPSAgKGVjYzFbNF0gJiAweGZmKSB8ICgoZWNjMVs1XSAmIDB4MDMpIDw8IDgpOworICAgIGJiWzFdID0gKChlY2MxWzVdICYgMHhmYykgPj4gMikgfCAoKGVjYzFbMl0gJiAweDBmKSA8PCA2KTsKKyAgICBiYlsyXSA9ICgoZWNjMVsyXSAmIDB4ZjApID4+IDQpIHwgKChlY2MxWzNdICYgMHgzZikgPDwgNCk7CisgICAgYmJbM10gPSAoKGVjYzFbM10gJiAweGMwKSA+PiA2KSB8ICgoZWNjMVswXSAmIDB4ZmYpIDw8IDIpOworCisgICAgbmJfZXJyb3JzID0gZXJhc19kZWNfcnMoQWxwaGFfdG8sIEluZGV4X29mLCBiYiwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJyb3JfdmFsLCBlcnJvcl9wb3MsIDApOworICAgIGlmIChuYl9lcnJvcnMgPD0gMCkKKyAgICAgICAgZ290byB0aGVfZW5kOworCisgICAgLyogY29ycmVjdCB0aGUgZXJyb3JzICovCisgICAgZm9yKGk9MDtpPG5iX2Vycm9ycztpKyspIHsKKyAgICAgICAgcG9zID0gZXJyb3JfcG9zW2ldOworICAgICAgICBpZiAocG9zID49IE5CX0RBVEEgJiYgcG9zIDwgS0spIHsKKyAgICAgICAgICAgIG5iX2Vycm9ycyA9IC0xOworICAgICAgICAgICAgZ290byB0aGVfZW5kOworICAgICAgICB9CisgICAgICAgIGlmIChwb3MgPCBOQl9EQVRBKSB7CisgICAgICAgICAgICAvKiBleHRyYWN0IGJpdCBwb3NpdGlvbiAoTVNCIGZpcnN0KSAqLworICAgICAgICAgICAgcG9zID0gMTAgKiAoTkJfREFUQSAtIDEgLSBwb3MpIC0gNjsKKyAgICAgICAgICAgIC8qIG5vdyBjb3JyZWN0IHRoZSBmb2xsb3dpbmcgMTAgYml0cy4gQXQgbW9zdCB0d28gYnl0ZXMKKyAgICAgICAgICAgICAgIGNhbiBiZSBtb2RpZmllZCBzaW5jZSBwb3MgaXMgZXZlbiAqLworICAgICAgICAgICAgaW5kZXggPSAocG9zID4+IDMpIF4gMTsKKyAgICAgICAgICAgIGJpdHBvcyA9IHBvcyAmIDc7CisgICAgICAgICAgICBpZiAoKGluZGV4ID49IDAgJiYgaW5kZXggPCBTRUNUT1JfU0laRSkgfHwgCisgICAgICAgICAgICAgICAgaW5kZXggPT0gKFNFQ1RPUl9TSVpFICsgMSkpIHsKKyAgICAgICAgICAgICAgICB2YWwgPSBlcnJvcl92YWxbaV0gPj4gKDIgKyBiaXRwb3MpOworICAgICAgICAgICAgICAgIHBhcml0eSBePSB2YWw7CisgICAgICAgICAgICAgICAgaWYgKGluZGV4IDwgU0VDVE9SX1NJWkUpCisgICAgICAgICAgICAgICAgICAgIHNlY3RvcltpbmRleF0gXj0gdmFsOworICAgICAgICAgICAgfQorICAgICAgICAgICAgaW5kZXggPSAoKHBvcyA+PiAzKSArIDEpIF4gMTsKKyAgICAgICAgICAgIGJpdHBvcyA9IChiaXRwb3MgKyAxMCkgJiA3OworICAgICAgICAgICAgaWYgKGJpdHBvcyA9PSAwKQorICAgICAgICAgICAgICAgIGJpdHBvcyA9IDg7CisgICAgICAgICAgICBpZiAoKGluZGV4ID49IDAgJiYgaW5kZXggPCBTRUNUT1JfU0laRSkgfHwgCisgICAgICAgICAgICAgICAgaW5kZXggPT0gKFNFQ1RPUl9TSVpFICsgMSkpIHsKKyAgICAgICAgICAgICAgICB2YWwgPSBlcnJvcl92YWxbaV0gPDwgKDggLSBiaXRwb3MpOworICAgICAgICAgICAgICAgIHBhcml0eSBePSB2YWw7CisgICAgICAgICAgICAgICAgaWYgKGluZGV4IDwgU0VDVE9SX1NJWkUpCisgICAgICAgICAgICAgICAgICAgIHNlY3RvcltpbmRleF0gXj0gdmFsOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorICAgIAorICAgIC8qIHVzZSBwYXJpdHkgdG8gdGVzdCBleHRyYSBlcnJvcnMgKi8KKyAgICBpZiAoKHBhcml0eSAmIDB4ZmYpICE9IDApCisgICAgICAgIG5iX2Vycm9ycyA9IC0xOworCisgdGhlX2VuZDoKKyAgICBrZnJlZShBbHBoYV90byk7CisgICAga2ZyZWUoSW5kZXhfb2YpOworICAgIHJldHVybiBuYl9lcnJvcnM7Cit9CisKK0VYUE9SVF9TWU1CT0xfR1BMKGRvY19kZWNvZGVfZWNjKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiRmFicmljZSBCZWxsYXJkIDxmYWJyaWNlLmJlbGxhcmRAbmV0Z2VtLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiRUNDIGNvZGUgZm9yIGNvcnJlY3RpbmcgZXJyb3JzIGRldGVjdGVkIGJ5IERpc2tPbkNoaXAgMjAwMCBhbmQgTWlsbGVubml1bSBFQ0MgaGFyZHdhcmUiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jcHJvYmUuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvZG9jcHJvYmUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xOTdkNjcwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9kb2Nwcm9iZS5jCkBAIC0wLDAgKzEsMzU1IEBACisKKy8qIExpbnV4IGRyaXZlciBmb3IgRGlzay1Pbi1DaGlwIGRldmljZXMJCQkqLworLyogUHJvYmUgcm91dGluZXMgY29tbW9uIHRvIGFsbCBEb0MgZGV2aWNlcwkJCSovCisvKiAoQykgMTk5OSBNYWNoaW5lIFZpc2lvbiBIb2xkaW5ncywgSW5jLgkJCSovCisvKiAoQykgMTk5OS0yMDAzIERhdmlkIFdvb2Rob3VzZSA8ZHdtdzJAaW5mcmFkZWFkLm9yZz4JCSovCisKKy8qICRJZDogZG9jcHJvYmUuYyx2IDEuNDQgMjAwNS8wMS8wNSAxMjo0MDozNiBkd213MiBFeHAgJAkqLworCisKKworLyogRE9DX1BBU1NJVkVfUFJPQkU6CisgICBJbiBvcmRlciB0byBlbnN1cmUgdGhhdCB0aGUgQklPUyBjaGVja3N1bSBpcyBjb3JyZWN0IGF0IGJvb3QgdGltZSwgYW5kIAorICAgaGVuY2UgdGhhdCB0aGUgb25ib2FyZCBCSU9TIGV4dGVuc2lvbiBnZXRzIGV4ZWN1dGVkLCB0aGUgRGlza09uQ2hpcCAKKyAgIGdvZXMgaW50byByZXNldCBtb2RlIHdoZW4gaXQgaXMgcmVhZCBzZXF1ZW50aWFsbHk6IGFsbCByZWdpc3RlcnMgCisgICByZXR1cm4gMHhmZiB1bnRpbCB0aGUgY2hpcCBpcyB3b2tlbiB1cCBhZ2FpbiBieSB3cml0aW5nIHRvIHRoZSAKKyAgIERPQ0NvbnRyb2wgcmVnaXN0ZXIuIAorCisgICBVbmZvcnR1bmF0ZWx5LCB0aGlzIG1lYW5zIHRoYXQgdGhlIHByb2JlIGZvciB0aGUgRGlza09uQ2hpcCBpcyB1bnNhZmUsIAorICAgYmVjYXVzZSBvbmUgb2YgdGhlIGZpcnN0IHRoaW5ncyBpdCBkb2VzIGlzIHdyaXRlIHRvIHdoZXJlIGl0IHRoaW5rcyAKKyAgIHRoZSBET0NDb250cm9sIHJlZ2lzdGVyIHNob3VsZCBiZSAtIHdoaWNoIG1heSB3ZWxsIGJlIHNoYXJlZCBtZW1vcnkgCisgICBmb3IgYW5vdGhlciBkZXZpY2UuIEkndmUgaGFkIG1hY2hpbmVzIHdoaWNoIGxvY2sgdXAgd2hlbiB0aGlzIGlzIAorICAgYXR0ZW1wdGVkLiBIZW5jZSB0aGUgcG9zc2liaWxpdHkgdG8gZG8gYSBwYXNzaXZlIHByb2JlLCB3aGljaCB3aWxsIGZhaWwgCisgICB0byBkZXRlY3QgYSBjaGlwIGluIHJlc2V0IG1vZGUsIGJ1dCBpcyBhdCBsZWFzdCBndWFyYW50ZWVkIG5vdCB0byBsb2NrCisgICB0aGUgbWFjaGluZS4KKworICAgSWYgeW91IGhhdmUgdGhpcyBwcm9ibGVtLCB1bmNvbW1lbnQgdGhlIGZvbGxvd2luZyBsaW5lOgorI2RlZmluZSBET0NfUEFTU0lWRV9QUk9CRQorKi8KKworCisvKiBET0NfU0lOR0xFX0RSSVZFUjoKKyAgIE1pbGxlbm5pdW0gZHJpdmVyIGhhcyBiZWVuIG1lcmdlZCBpbnRvIERPQzIwMDAgZHJpdmVyLgorCisgICBUaGUgb2xkIE1pbGxlbm5pdW0tb25seSBkcml2ZXIgaGFzIGJlZW4gcmV0YWluZWQganVzdCBpbiBjYXNlIHRoZXJlCisgICBhcmUgcHJvYmxlbXMgd2l0aCB0aGUgbmV3IGNvZGUuIElmIHRoZSBjb21iaW5lZCBkcml2ZXIgZG9lc24ndCB3b3JrCisgICBmb3IgeW91LCB5b3UgY2FuIHRyeSB0aGUgb2xkIG9uZSBieSB1bmRlZmluaW5nIERPQ19TSU5HTEVfRFJJVkVSIAorICAgYmVsb3cgYW5kIGFsc28gZW5hYmxpbmcgaXQgaW4geW91ciBjb25maWd1cmF0aW9uLiBJZiB0aGlzIGZpeGVzIHRoZQorICAgcHJvYmxlbXMsIHBsZWFzZSBzZW5kIGEgcmVwb3J0IHRvIHRoZSBNVEQgbWFpbGluZyBsaXN0IGF0IAorICAgPGxpbnV4LW10ZEBsaXN0cy5pbmZyYWRlYWQub3JnPi4KKyovCisjZGVmaW5lIERPQ19TSU5HTEVfRFJJVkVSCisKKyNpbmNsdWRlIDxsaW51eC9jb25maWcuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxhc20vZXJybm8uaD4KKyNpbmNsdWRlIDxhc20vaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKyNpbmNsdWRlIDxsaW51eC9tdGQvbmFuZC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9kb2MyMDAwLmg+CisjaW5jbHVkZSA8bGludXgvbXRkL2NvbXBhdG1hYy5oPgorCisvKiBXaGVyZSB0byBsb29rIGZvciB0aGUgZGV2aWNlcz8gKi8KKyNpZm5kZWYgQ09ORklHX01URF9ET0NQUk9CRV9BRERSRVNTCisjZGVmaW5lIENPTkZJR19NVERfRE9DUFJPQkVfQUREUkVTUyAwCisjZW5kaWYKKworCitzdGF0aWMgdW5zaWduZWQgbG9uZyBkb2NfY29uZmlnX2xvY2F0aW9uID0gQ09ORklHX01URF9ET0NQUk9CRV9BRERSRVNTOworbW9kdWxlX3BhcmFtKGRvY19jb25maWdfbG9jYXRpb24sIHVsb25nLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MoZG9jX2NvbmZpZ19sb2NhdGlvbiwgIlBoeXNpY2FsIG1lbW9yeSBhZGRyZXNzIGF0IHdoaWNoIHRvIHByb2JlIGZvciBEaXNrT25DaGlwIik7CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIF9faW5pdGRhdGEgZG9jX2xvY2F0aW9uc1tdID0geworI2lmIGRlZmluZWQgKF9fYWxwaGFfXykgfHwgZGVmaW5lZChfX2kzODZfXykgfHwgZGVmaW5lZChfX3g4Nl82NF9fKQorI2lmZGVmIENPTkZJR19NVERfRE9DUFJPQkVfSElHSAorCTB4ZmZmYzgwMDAsIDB4ZmZmY2EwMDAsIDB4ZmZmY2MwMDAsIDB4ZmZmY2UwMDAsIAorCTB4ZmZmZDAwMDAsIDB4ZmZmZDIwMDAsIDB4ZmZmZDQwMDAsIDB4ZmZmZDYwMDAsCisJMHhmZmZkODAwMCwgMHhmZmZkYTAwMCwgMHhmZmZkYzAwMCwgMHhmZmZkZTAwMCwgCisJMHhmZmZlMDAwMCwgMHhmZmZlMjAwMCwgMHhmZmZlNDAwMCwgMHhmZmZlNjAwMCwgCisJMHhmZmZlODAwMCwgMHhmZmZlYTAwMCwgMHhmZmZlYzAwMCwgMHhmZmZlZTAwMCwKKyNlbHNlIC8qICBDT05GSUdfTVREX0RPQ1BST0JFX0hJR0ggKi8KKwkweGM4MDAwLCAweGNhMDAwLCAweGNjMDAwLCAweGNlMDAwLCAKKwkweGQwMDAwLCAweGQyMDAwLCAweGQ0MDAwLCAweGQ2MDAwLAorCTB4ZDgwMDAsIDB4ZGEwMDAsIDB4ZGMwMDAsIDB4ZGUwMDAsIAorCTB4ZTAwMDAsIDB4ZTIwMDAsIDB4ZTQwMDAsIDB4ZTYwMDAsIAorCTB4ZTgwMDAsIDB4ZWEwMDAsIDB4ZWMwMDAsIDB4ZWUwMDAsCisjZW5kaWYgLyogIENPTkZJR19NVERfRE9DUFJPQkVfSElHSCAqLworI2VsaWYgZGVmaW5lZChfX1BQQ19fKQorCTB4ZTQwMDAwMDAsCisjZWxpZiBkZWZpbmVkKENPTkZJR19NT01FTkNPX09DRUxPVCkKKwkweDJmMDAwMDAwLAorICAgICAgICAweGZmMDAwMDAwLAorI2VsaWYgZGVmaW5lZChDT05GSUdfTU9NRU5DT19PQ0VMT1RfRykgfHwgZGVmaW5lZCAoQ09ORklHX01PTUVOQ09fT0NFTE9UX0MpCisgICAgICAgIDB4ZmYwMDAwMDAsCisjI2Vsc2UKKyN3YXJuaW5nIFVua25vd24gYXJjaGl0ZWN0dXJlIGZvciBEaXNrT25DaGlwLiBObyBkZWZhdWx0IHByb2JlIGxvY2F0aW9ucyBkZWZpbmVkCisjZW5kaWYKKwkweGZmZmZmZmZmIH07CisKKy8qIGRvY2NoZWNrOiBQcm9iZSBhIGdpdmVuIG1lbW9yeSB3aW5kb3cgdG8gc2VlIGlmIHRoZXJlJ3MgYSBEaXNrT25DaGlwIHByZXNlbnQgKi8KKworc3RhdGljIGlubGluZSBpbnQgX19pbml0IGRvY2NoZWNrKHZvaWQgX19pb21lbSAqcG90ZW50aWFsLCB1bnNpZ25lZCBsb25nIHBoeXNhZHIpCit7CisJdm9pZCBfX2lvbWVtICp3aW5kb3c9cG90ZW50aWFsOworCXVuc2lnbmVkIGNoYXIgdG1wLCB0bXBiLCB0bXBjLCBDaGlwSUQ7CisjaWZuZGVmIERPQ19QQVNTSVZFX1BST0JFCisJdW5zaWduZWQgY2hhciB0bXAyOworI2VuZGlmCisKKwkvKiBSb3V0aW5lIGNvcGllZCBmcm9tIHRoZSBMaW51eCBET0MgZHJpdmVyICovCisKKyNpZmRlZiBDT05GSUdfTVREX0RPQ1BST0JFXzU1QUEKKwkvKiBDaGVjayBmb3IgMHg1NSAweEFBIHNpZ25hdHVyZSBhdCBiZWdpbm5pbmcgb2Ygd2luZG93LAorCSAgIHRoaXMgaXMgbm8gbG9uZ2VyIHRydWUgb25jZSB3ZSByZW1vdmUgdGhlIElQTCAoZm9yIE1pbGxlbm5pdW0gKi8KKwlpZiAoUmVhZERPQyh3aW5kb3csIFNpZzEpICE9IDB4NTUgfHwgUmVhZERPQyh3aW5kb3csIFNpZzIpICE9IDB4YWEpCisJCXJldHVybiAwOworI2VuZGlmIC8qIENPTkZJR19NVERfRE9DUFJPQkVfNTVBQSAqLworCisjaWZuZGVmIERPQ19QQVNTSVZFX1BST0JFCQorCS8qIEl0J3Mgbm90IHBvc3NpYmxlIHRvIGNsZWFubHkgZGV0ZWN0IHRoZSBEaXNrT25DaGlwIC0gdGhlCisJICogYm9vdHVwIHByb2NlZHVyZSB3aWxsIHB1dCB0aGUgZGV2aWNlIGludG8gcmVzZXQgbW9kZSwgYW5kCisJICogaXQncyBub3QgcG9zc2libGUgdG8gdGFsayB0byBpdCB3aXRob3V0IGFjdHVhbGx5IHdyaXRpbmcKKwkgKiB0byB0aGUgRE9DQ29udHJvbCByZWdpc3Rlci4gU28gd2Ugc3RvcmUgdGhlIGN1cnJlbnQgY29udGVudHMKKwkgKiBvZiB0aGUgRE9DQ29udHJvbCByZWdpc3RlcidzIGxvY2F0aW9uLCBpbiBjYXNlIHdlIGxhdGVyIGRlY2lkZQorCSAqIHRoYXQgaXQncyBub3QgYSBEaXNrT25DaGlwLCBhbmQgd2FudCB0byBwdXQgaXQgYmFjayBob3cgd2UKKwkgKiBmb3VuZCBpdC4gCisJICovCisJdG1wMiA9IFJlYWRET0Mod2luZG93LCBET0NDb250cm9sKTsKKwkKKwkvKiBSZXNldCB0aGUgRGlza09uQ2hpcCBBU0lDICovCisJV3JpdGVET0MoRE9DX01PREVfQ0xSX0VSUiB8IERPQ19NT0RFX01EV1JFTiB8IERPQ19NT0RFX1JFU0VULCAKKwkJIHdpbmRvdywgRE9DQ29udHJvbCk7CisJV3JpdGVET0MoRE9DX01PREVfQ0xSX0VSUiB8IERPQ19NT0RFX01EV1JFTiB8IERPQ19NT0RFX1JFU0VULCAKKwkJIHdpbmRvdywgRE9DQ29udHJvbCk7CisJCisJLyogRW5hYmxlIHRoZSBEaXNrT25DaGlwIEFTSUMgKi8KKwlXcml0ZURPQyhET0NfTU9ERV9DTFJfRVJSIHwgRE9DX01PREVfTURXUkVOIHwgRE9DX01PREVfTk9STUFMLCAKKwkJIHdpbmRvdywgRE9DQ29udHJvbCk7CisJV3JpdGVET0MoRE9DX01PREVfQ0xSX0VSUiB8IERPQ19NT0RFX01EV1JFTiB8IERPQ19NT0RFX05PUk1BTCwgCisJCSB3aW5kb3csIERPQ0NvbnRyb2wpOworI2VuZGlmIC8qICFET0NfUEFTU0lWRV9QUk9CRSAqLwkKKworCS8qIFdlIG5lZWQgdG8gcmVhZCB0aGUgQ2hpcElEIHJlZ2lzdGVyIGZvdXIgdGltZXMuIEZvciBzb21lCisJICAgbmV3ZXIgRGlza09uQ2hpcCAyMDAwIHVuaXRzLCB0aGUgZmlyc3QgdGhyZWUgcmVhZHMgd2lsbAorCSAgIHJldHVybiB0aGUgRGlza09uQ2hpcCBNaWxsZW5uaXVtIGlkZW50LiBEb24ndCBhc2suICovCisJQ2hpcElEID0gUmVhZERPQyh3aW5kb3csIENoaXBJRCk7CisgIAorCXN3aXRjaCAoQ2hpcElEKSB7CisJY2FzZSBET0NfQ2hpcElEX0RvYzJrOgorCQkvKiBDaGVjayB0aGUgVE9HR0xFIGJpdCBpbiB0aGUgRUNDIHJlZ2lzdGVyICovCisJCXRtcCAgPSBSZWFkRE9DKHdpbmRvdywgMmtfRUNDU3RhdHVzKSAmIERPQ19UT0dHTEVfQklUOworCQl0bXBiID0gUmVhZERPQyh3aW5kb3csIDJrX0VDQ1N0YXR1cykgJiBET0NfVE9HR0xFX0JJVDsKKwkJdG1wYyA9IFJlYWRET0Mod2luZG93LCAya19FQ0NTdGF0dXMpICYgRE9DX1RPR0dMRV9CSVQ7CisJCWlmICh0bXAgIT0gdG1wYiAmJiB0bXAgPT0gdG1wYykKKwkJCQlyZXR1cm4gQ2hpcElEOworCQlicmVhazsKKwkJCisJY2FzZSBET0NfQ2hpcElEX0RvY01pbDoKKwkJLyogQ2hlY2sgZm9yIHRoZSBuZXcgMjAwMCB3aXRoIE1pbGxlbm5pdW0gQVNJQyAqLworCQlSZWFkRE9DKHdpbmRvdywgQ2hpcElEKTsKKwkJUmVhZERPQyh3aW5kb3csIENoaXBJRCk7CisJCWlmIChSZWFkRE9DKHdpbmRvdywgQ2hpcElEKSAhPSBET0NfQ2hpcElEX0RvY01pbCkKKwkJCUNoaXBJRCA9IERPQ19DaGlwSURfRG9jMmtUU09QOworCisJCS8qIENoZWNrIHRoZSBUT0dHTEUgYml0IGluIHRoZSBFQ0MgcmVnaXN0ZXIgKi8KKwkJdG1wICA9IFJlYWRET0Mod2luZG93LCBFQ0NDb25mKSAmIERPQ19UT0dHTEVfQklUOworCQl0bXBiID0gUmVhZERPQyh3aW5kb3csIEVDQ0NvbmYpICYgRE9DX1RPR0dMRV9CSVQ7CisJCXRtcGMgPSBSZWFkRE9DKHdpbmRvdywgRUNDQ29uZikgJiBET0NfVE9HR0xFX0JJVDsKKwkJaWYgKHRtcCAhPSB0bXBiICYmIHRtcCA9PSB0bXBjKQorCQkJCXJldHVybiBDaGlwSUQ7CisJCWJyZWFrOworCQkKKwljYXNlIERPQ19DaGlwSURfRG9jTWlsUGx1czE2OgorCWNhc2UgRE9DX0NoaXBJRF9Eb2NNaWxQbHVzMzI6CisJY2FzZSAwOgorCQkvKiBQb3NzaWJsZSBNaWxsZW5uaXVtKywgbmVlZCB0byBkbyBtb3JlIGNoZWNrcyAqLworI2lmbmRlZiBET0NfUEFTU0lWRV9QUk9CRQorCQkvKiBQb3NzaWJseSByZWxlYXNlIGZyb20gcG93ZXIgZG93biBtb2RlICovCisJCWZvciAodG1wID0gMDsgKHRtcCA8IDQpOyB0bXArKykKKwkJCVJlYWRET0Mod2luZG93LCBNcGx1c19Qb3dlcik7CisKKwkJLyogUmVzZXQgdGhlIERpc2tPbkNoaXAgQVNJQyAqLworCQl0bXAgPSBET0NfTU9ERV9SRVNFVCB8IERPQ19NT0RFX01EV1JFTiB8IERPQ19NT0RFX1JTVF9MQVQgfAorCQkJRE9DX01PREVfQkRFQ1Q7CisJCVdyaXRlRE9DKHRtcCwgd2luZG93LCBNcGx1c19ET0NDb250cm9sKTsKKwkJV3JpdGVET0MofnRtcCwgd2luZG93LCBNcGx1c19DdHJsQ29uZmlybSk7CisJCisJCW1kZWxheSgxKTsKKwkJLyogRW5hYmxlIHRoZSBEaXNrT25DaGlwIEFTSUMgKi8KKwkJdG1wID0gRE9DX01PREVfTk9STUFMIHwgRE9DX01PREVfTURXUkVOIHwgRE9DX01PREVfUlNUX0xBVCB8CisJCQlET0NfTU9ERV9CREVDVDsKKwkJV3JpdGVET0ModG1wLCB3aW5kb3csIE1wbHVzX0RPQ0NvbnRyb2wpOworCQlXcml0ZURPQyh+dG1wLCB3aW5kb3csIE1wbHVzX0N0cmxDb25maXJtKTsKKwkJbWRlbGF5KDEpOworI2VuZGlmIC8qICFET0NfUEFTU0lWRV9QUk9CRSAqLwkKKworCQlDaGlwSUQgPSBSZWFkRE9DKHdpbmRvdywgQ2hpcElEKTsKKworCQlzd2l0Y2ggKENoaXBJRCkgeworCQljYXNlIERPQ19DaGlwSURfRG9jTWlsUGx1czE2OgorCQljYXNlIERPQ19DaGlwSURfRG9jTWlsUGx1czMyOgorCQkJLyogQ2hlY2sgdGhlIFRPR0dMRSBiaXQgaW4gdGhlIHRvZ2dsZSByZWdpc3RlciAqLworCQkJdG1wICA9IFJlYWRET0Mod2luZG93LCBNcGx1c19Ub2dnbGUpICYgRE9DX1RPR0dMRV9CSVQ7CisJCQl0bXBiID0gUmVhZERPQyh3aW5kb3csIE1wbHVzX1RvZ2dsZSkgJiBET0NfVE9HR0xFX0JJVDsKKwkJCXRtcGMgPSBSZWFkRE9DKHdpbmRvdywgTXBsdXNfVG9nZ2xlKSAmIERPQ19UT0dHTEVfQklUOworCQkJaWYgKHRtcCAhPSB0bXBiICYmIHRtcCA9PSB0bXBjKQorCQkJCQlyZXR1cm4gQ2hpcElEOworCQlkZWZhdWx0OgorCQkJYnJlYWs7CisJCX0KKwkJLyogRkFMTCBUUkhVICovCisKKwlkZWZhdWx0OgorCisjaWZkZWYgQ09ORklHX01URF9ET0NQUk9CRV81NUFBCisJCXByaW50ayhLRVJOX0RFQlVHICJQb3NzaWJsZSBEaXNrT25DaGlwIHdpdGggdW5rbm93biBDaGlwSUQgJTIuMlggZm91bmQgYXQgMHglbHhcbiIsCisJCSAgICAgICBDaGlwSUQsIHBoeXNhZHIpOworI2VuZGlmCisjaWZuZGVmIERPQ19QQVNTSVZFX1BST0JFCisJCS8qIFB1dCBiYWNrIHRoZSBjb250ZW50cyBvZiB0aGUgRE9DQ29udHJvbCByZWdpc3RlciwgaW4gY2FzZSBpdCdzIG5vdAorCQkgKiBhY3R1YWxseSBhIERpc2tPbkNoaXAuCisJCSAqLworCQlXcml0ZURPQyh0bXAyLCB3aW5kb3csIERPQ0NvbnRyb2wpOworI2VuZGlmCisJCXJldHVybiAwOworCX0KKworCXByaW50ayhLRVJOX1dBUk5JTkcgIkRpc2tPbkNoaXAgZmFpbGVkIFRPR0dMRSB0ZXN0LCBkcm9wcGluZy5cbiIpOworCisjaWZuZGVmIERPQ19QQVNTSVZFX1BST0JFCisJLyogUHV0IGJhY2sgdGhlIGNvbnRlbnRzIG9mIHRoZSBET0NDb250cm9sIHJlZ2lzdGVyOiBpdCdzIG5vdCBhIERpc2tPbkNoaXAgKi8KKwlXcml0ZURPQyh0bXAyLCB3aW5kb3csIERPQ0NvbnRyb2wpOworI2VuZGlmCisJcmV0dXJuIDA7Cit9ICAgCisKK3N0YXRpYyBpbnQgZG9jZm91bmQ7CisKK3N0YXRpYyB2b2lkIF9faW5pdCBEb0NfUHJvYmUodW5zaWduZWQgbG9uZyBwaHlzYWRyKQoreworCXZvaWQgX19pb21lbSAqZG9jcHRyOworCXN0cnVjdCBEaXNrT25DaGlwICp0aGlzOworCXN0cnVjdCBtdGRfaW5mbyAqbXRkOworCWludCBDaGlwSUQ7CisJY2hhciBuYW1lYnVmWzE1XTsKKwljaGFyICpuYW1lID0gbmFtZWJ1ZjsKKwljaGFyICppbV9mdW5jbmFtZSA9IE5VTEw7CisJY2hhciAqaW1fbW9kbmFtZSA9IE5VTEw7CisJdm9pZCAoKmluaXRyb3V0aW5lKShzdHJ1Y3QgbXRkX2luZm8gKikgPSBOVUxMOworCisJZG9jcHRyID0gaW9yZW1hcChwaHlzYWRyLCBET0NfSU9SRU1BUF9MRU4pOworCQorCWlmICghZG9jcHRyKQorCQlyZXR1cm47CisJCisJaWYgKChDaGlwSUQgPSBkb2NjaGVjayhkb2NwdHIsIHBoeXNhZHIpKSkgeworCQlpZiAoQ2hpcElEID09IERPQ19DaGlwSURfRG9jMmtUU09QKSB7CisJCQkvKiBSZW1vdmUgdGhpcyBhdCB5b3VyIG93biBwZXJpbC4gVGhlIGhhcmR3YXJlIGRyaXZlciB3b3JrcyBidXQgbm90aGluZyBwcmV2ZW50cyB5b3UgZnJvbSBlcmFzaW5nIGJhZCBibG9ja3MgKi8KKwkJCXByaW50ayhLRVJOX05PVElDRSAiUmVmdXNpbmcgdG8gZHJpdmUgRGlza09uQ2hpcCAyMDAwIFRTT1AgdW50aWwgQmFkIEJsb2NrIFRhYmxlIGlzIGNvcnJlY3RseSBzdXBwb3J0ZWQgYnkgSU5GVExcbiIpOworCQkJaW91bm1hcChkb2NwdHIpOworCQkJcmV0dXJuOworCQl9CisJCWRvY2ZvdW5kID0gMTsKKwkJbXRkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IERpc2tPbkNoaXApICsgc2l6ZW9mKHN0cnVjdCBtdGRfaW5mbyksIEdGUF9LRVJORUwpOworCisJCWlmICghbXRkKSB7CisJCQlwcmludGsoS0VSTl9XQVJOSU5HICJDYW5ub3QgYWxsb2NhdGUgbWVtb3J5IGZvciBkYXRhIHN0cnVjdHVyZXMuIERyb3BwaW5nLlxuIik7CisJCQlpb3VubWFwKGRvY3B0cik7CisJCQlyZXR1cm47CisJCX0KKwkJCisJCXRoaXMgPSAoc3RydWN0IERpc2tPbkNoaXAgKikoJm10ZFsxXSk7CisJCQorCQltZW1zZXQoKGNoYXIgKiltdGQsMCwgc2l6ZW9mKHN0cnVjdCBtdGRfaW5mbykpOworCQltZW1zZXQoKGNoYXIgKil0aGlzLCAwLCBzaXplb2Yoc3RydWN0IERpc2tPbkNoaXApKTsKKworCQltdGQtPnByaXYgPSB0aGlzOworCQl0aGlzLT52aXJ0YWRyID0gZG9jcHRyOworCQl0aGlzLT5waHlzYWRyID0gcGh5c2FkcjsKKwkJdGhpcy0+Q2hpcElEID0gQ2hpcElEOworCQlzcHJpbnRmKG5hbWVidWYsICJ3aXRoIENoaXBJRCAlMi4yWCIsIENoaXBJRCk7CisKKwkJc3dpdGNoKENoaXBJRCkgeworCQljYXNlIERPQ19DaGlwSURfRG9jMmtUU09QOgorCQkJbmFtZT0iMjAwMCBUU09QIjsKKwkJCWltX2Z1bmNuYW1lID0gIkRvQzJrX2luaXQiOworCQkJaW1fbW9kbmFtZSA9ICJkb2MyMDAwIjsKKwkJCWJyZWFrOworCQkJCisJCWNhc2UgRE9DX0NoaXBJRF9Eb2MyazoKKwkJCW5hbWU9IjIwMDAiOworCQkJaW1fZnVuY25hbWUgPSAiRG9DMmtfaW5pdCI7CisJCQlpbV9tb2RuYW1lID0gImRvYzIwMDAiOworCQkJYnJlYWs7CisJCQkKKwkJY2FzZSBET0NfQ2hpcElEX0RvY01pbDoKKwkJCW5hbWU9Ik1pbGxlbm5pdW0iOworI2lmZGVmIERPQ19TSU5HTEVfRFJJVkVSCisJCQlpbV9mdW5jbmFtZSA9ICJEb0Mya19pbml0IjsKKwkJCWltX21vZG5hbWUgPSAiZG9jMjAwMCI7CisjZWxzZQorCQkJaW1fZnVuY25hbWUgPSAiRG9DTWlsX2luaXQiOworCQkJaW1fbW9kbmFtZSA9ICJkb2MyMDAxIjsKKyNlbmRpZiAvKiBET0NfU0lOR0xFX0RSSVZFUiAqLworCQkJYnJlYWs7CisKKwkJY2FzZSBET0NfQ2hpcElEX0RvY01pbFBsdXMxNjoKKwkJY2FzZSBET0NfQ2hpcElEX0RvY01pbFBsdXMzMjoKKwkJCW5hbWU9Ik1pbGxlbm5pdW1QbHVzIjsKKwkJCWltX2Z1bmNuYW1lID0gIkRvQ01pbFBsdXNfaW5pdCI7CisJCQlpbV9tb2RuYW1lID0gImRvYzIwMDFwbHVzIjsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKGltX2Z1bmNuYW1lKQorCQkJaW5pdHJvdXRpbmUgPSBpbnRlcl9tb2R1bGVfZ2V0X3JlcXVlc3QoaW1fZnVuY25hbWUsIGltX21vZG5hbWUpOworCisJCWlmIChpbml0cm91dGluZSkgeworCQkJKCppbml0cm91dGluZSkobXRkKTsKKwkJCWludGVyX21vZHVsZV9wdXQoaW1fZnVuY25hbWUpOworCQkJcmV0dXJuOworCQl9CisJCXByaW50ayhLRVJOX05PVElDRSAiQ2Fubm90IGZpbmQgZHJpdmVyIGZvciBEaXNrT25DaGlwICVzIGF0IDB4JWxYXG4iLCBuYW1lLCBwaHlzYWRyKTsKKwkJa2ZyZWUobXRkKTsKKwl9CisJaW91bm1hcChkb2NwdHIpOworfQorCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogTW9kdWxlIHN0dWZmCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBpbnQgX19pbml0IGluaXRfZG9jKHZvaWQpCit7CisJaW50IGk7CisJCisJaWYgKGRvY19jb25maWdfbG9jYXRpb24pIHsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiVXNpbmcgY29uZmlndXJlZCBEaXNrT25DaGlwIHByb2JlIGFkZHJlc3MgMHglbHhcbiIsIGRvY19jb25maWdfbG9jYXRpb24pOworCQlEb0NfUHJvYmUoZG9jX2NvbmZpZ19sb2NhdGlvbik7CisJfSBlbHNlIHsKKwkJZm9yIChpPTA7IChkb2NfbG9jYXRpb25zW2ldICE9IDB4ZmZmZmZmZmYpOyBpKyspIHsKKwkJCURvQ19Qcm9iZShkb2NfbG9jYXRpb25zW2ldKTsKKwkJfQorCX0KKwkvKiBObyBiYW5uZXIgbWVzc2FnZSBhbnkgbW9yZS4gUHJpbnQgYSBtZXNzYWdlIGlmIG5vIERpc2tPbkNoaXAKKwkgICBmb3VuZCwgc28gdGhlIHVzZXIga25vd3Mgd2UgYXQgbGVhc3QgdHJpZWQuICovCisJaWYgKCFkb2Nmb3VuZCkKKwkJcHJpbnRrKEtFUk5fSU5GTyAiTm8gcmVjb2duaXNlZCBEaXNrT25DaGlwIGRldmljZXMgZm91bmRcbiIpOworCXJldHVybiAtRUFHQUlOOworfQorCittb2R1bGVfaW5pdChpbml0X2RvYyk7CisKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BVVRIT1IoIkRhdmlkIFdvb2Rob3VzZSA8ZHdtdzJAaW5mcmFkZWFkLm9yZz4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiUHJvYmUgY29kZSBmb3IgRGlza09uQ2hpcCAyMDAwIGFuZCBNaWxsZW5uaXVtIGRldmljZXMiKTsKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvZGV2aWNlcy9sYXJ0LmMgYi9kcml2ZXJzL210ZC9kZXZpY2VzL2xhcnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kZmQzMzVlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9sYXJ0LmMKQEAgLTAsMCArMSw3MTEgQEAKKworLyoKKyAqIE1URCBkcml2ZXIgZm9yIHRoZSAyOEYxNjBGMyBGbGFzaCBNZW1vcnkgKG5vbi1DRkkpIG9uIExBUlQuCisgKgorICogJElkOiBsYXJ0LmMsdiAxLjcgMjAwNC8wOC8wOSAxMzoxOTo0NCBkd213MiBFeHAgJAorICoKKyAqIEF1dGhvcjogQWJyYWhhbSB2ZCBNZXJ3ZSA8YWJyYWhhbUAyZDNkLmNvLnphPgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwMSwgMmQzRCwgSW5jLgorICoKKyAqIFRoaXMgY29kZSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICogUmVmZXJlbmNlczoKKyAqCisgKiAgICBbMV0gMyBWb2x0IEZhc3QgQm9vdCBCbG9jayBGbGFzaCBNZW1vcnkiIEludGVsIERhdGFzaGVldAorICogICAgICAgICAgIC0gT3JkZXIgTnVtYmVyOiAyOTA2NDQtMDA1CisgKiAgICAgICAgICAgLSBKYW51YXJ5IDIwMDAKKyAqCisgKiAgICBbMl0gTVREIGludGVybmFsIEFQSSBkb2N1bWVudGF0aW9uCisgKiAgICAgICAgICAgLSBodHRwOi8vd3d3LmxpbnV4LW10ZC5pbmZyYWRlYWQub3JnL3RlY2gvCisgKgorICogTGltaXRhdGlvbnM6CisgKgorICogICAgRXZlbiB0aG91Z2ggdGhpcyBkcml2ZXIgaXMgd3JpdHRlbiBmb3IgMyBWb2x0IEZhc3QgQm9vdAorICogICAgQmxvY2sgRmxhc2ggTWVtb3J5LCBpdCBpcyByYXRoZXIgc3BlY2lmaWMgdG8gTEFSVC4gV2l0aAorICogICAgTWlub3IgbW9kaWZpY2F0aW9ucywgbm90YWJseSB0aGUgd2l0aG91dCBkYXRhL2FkZHJlc3MgbGluZQorICogICAgbWFuZ2xpbmcgYW5kIGRpZmZlcmVudCBidXMgc2V0dGluZ3MsIGV0Yy4gaXQgc2hvdWxkIGJlCisgKiAgICB0cml2aWFsIHRvIGFkYXB0IHRvIG90aGVyIHBsYXRmb3Jtcy4KKyAqCisgKiAgICBJZiBzb21lYm9keSB3b3VsZCBzcG9uc29yIG1lIGEgZGlmZmVyZW50IGJvYXJkLCBJJ2xsCisgKiAgICBhZGFwdCB0aGUgZHJpdmVyICg6CisgKi8KKworLyogZGVidWdnaW5nICovCisvLyNkZWZpbmUgTEFSVF9ERUJVRworCisvKiBwYXJ0aXRpb24gc3VwcG9ydCAqLworI2RlZmluZSBIQVZFX1BBUlRJVElPTlMKKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvbXRkL210ZC5oPgorI2lmZGVmIEhBVkVfUEFSVElUSU9OUworI2luY2x1ZGUgPGxpbnV4L210ZC9wYXJ0aXRpb25zLmg+CisjZW5kaWYKKworI2lmbmRlZiBDT05GSUdfU0ExMTAwX0xBUlQKKyNlcnJvciBUaGlzIGlzIGZvciBMQVJUIGFyY2hpdGVjdHVyZSBvbmx5CisjZW5kaWYKKworc3RhdGljIGNoYXIgbW9kdWxlX25hbWVbXSA9ICJsYXJ0IjsKKworLyoKKyAqIFRoZXNlIHZhbHVlcyBpcyBzcGVjaWZpYyB0byAyOEZ4eHh4MyBmbGFzaCBtZW1vcnkuCisgKiBTZWUgc2VjdGlvbiAyLjMuMSBpbiAiMyBWb2x0IEZhc3QgQm9vdCBCbG9jayBGbGFzaCBNZW1vcnkiIEludGVsIERhdGFzaGVldAorICovCisjZGVmaW5lIEZMQVNIX0JMT0NLU0laRV9QQVJBTQkJKDQwOTYgKiBCVVNXSURUSCkKKyNkZWZpbmUgRkxBU0hfTlVNQkxPQ0tTXzE2bV9QQVJBTQk4CisjZGVmaW5lIEZMQVNIX05VTUJMT0NLU184bV9QQVJBTQk4CisKKy8qCisgKiBUaGVzZSB2YWx1ZXMgaXMgc3BlY2lmaWMgdG8gMjhGeHh4eDMgZmxhc2ggbWVtb3J5LgorICogU2VlIHNlY3Rpb24gMi4zLjIgaW4gIjMgVm9sdCBGYXN0IEJvb3QgQmxvY2sgRmxhc2ggTWVtb3J5IiBJbnRlbCBEYXRhc2hlZXQKKyAqLworI2RlZmluZSBGTEFTSF9CTE9DS1NJWkVfTUFJTgkJKDMyNzY4ICogQlVTV0lEVEgpCisjZGVmaW5lIEZMQVNIX05VTUJMT0NLU18xNm1fTUFJTgkzMQorI2RlZmluZSBGTEFTSF9OVU1CTE9DS1NfOG1fTUFJTgkJMTUKKworLyoKKyAqIFRoZXNlIHZhbHVlcyBhcmUgc3BlY2lmaWMgdG8gTEFSVAorICovCisKKy8qIGdlbmVyYWwgKi8KKyNkZWZpbmUgQlVTV0lEVEgJCQk0CQkJCS8qIGRvbid0IGNoYW5nZSB0aGlzIC0gYSBsb3Qgb2YgdGhlIGNvZGUgX3dpbGxfIGJyZWFrIGlmIHlvdSBjaGFuZ2UgdGhpcyAqLworI2RlZmluZSBGTEFTSF9PRkZTRVQJCTB4ZTgwMDAwMDAJCS8qIHNlZSBsaW51eC9hcmNoL2FybS9tYWNoLXNhMTEwMC9sYXJ0LmMgKi8KKworLyogYmxvYiAqLworI2RlZmluZSBOVU1fQkxPQl9CTE9DS1MJCUZMQVNIX05VTUJMT0NLU18xNm1fUEFSQU0KKyNkZWZpbmUgQkxPQl9TVEFSVAkJCTB4MDAwMDAwMDAKKyNkZWZpbmUgQkxPQl9MRU4JCQkoTlVNX0JMT0JfQkxPQ0tTICogRkxBU0hfQkxPQ0tTSVpFX1BBUkFNKQorCisvKiBrZXJuZWwgKi8KKyNkZWZpbmUgTlVNX0tFUk5FTF9CTE9DS1MJNworI2RlZmluZSBLRVJORUxfU1RBUlQJCShCTE9CX1NUQVJUICsgQkxPQl9MRU4pCisjZGVmaW5lIEtFUk5FTF9MRU4JCQkoTlVNX0tFUk5FTF9CTE9DS1MgKiBGTEFTSF9CTE9DS1NJWkVfTUFJTikKKworLyogaW5pdGlhbCByYW1kaXNrICovCisjZGVmaW5lIE5VTV9JTklUUkRfQkxPQ0tTCTI0CisjZGVmaW5lIElOSVRSRF9TVEFSVAkJKEtFUk5FTF9TVEFSVCArIEtFUk5FTF9MRU4pCisjZGVmaW5lIElOSVRSRF9MRU4JCQkoTlVNX0lOSVRSRF9CTE9DS1MgKiBGTEFTSF9CTE9DS1NJWkVfTUFJTikKKworLyoKKyAqIFNlZSBzZWN0aW9uIDQuMCBpbiAiMyBWb2x0IEZhc3QgQm9vdCBCbG9jayBGbGFzaCBNZW1vcnkiIEludGVsIERhdGFzaGVldAorICovCisjZGVmaW5lIFJFQURfQVJSQVkJCQkweDAwRkYwMEZGCQkvKiBSZWFkIEFycmF5L1Jlc2V0ICovCisjZGVmaW5lIFJFQURfSURfQ09ERVMJCTB4MDA5MDAwOTAJCS8qIFJlYWQgSWRlbnRpZmllciBDb2RlcyAqLworI2RlZmluZSBFUkFTRV9TRVRVUAkJCTB4MDAyMDAwMjAJCS8qIEJsb2NrIEVyYXNlICovCisjZGVmaW5lIEVSQVNFX0NPTkZJUk0JCTB4MDBEMDAwRDAJCS8qIEJsb2NrIEVyYXNlIGFuZCBQcm9ncmFtIFJlc3VtZSAqLworI2RlZmluZSBQR01fU0VUVVAJCQkweDAwNDAwMDQwCQkvKiBQcm9ncmFtICovCisjZGVmaW5lIFNUQVRVU19SRUFECQkJMHgwMDcwMDA3MAkJLyogUmVhZCBTdGF0dXMgUmVnaXN0ZXIgKi8KKyNkZWZpbmUgU1RBVFVTX0NMRUFSCQkweDAwNTAwMDUwCQkvKiBDbGVhciBTdGF0dXMgUmVnaXN0ZXIgKi8KKyNkZWZpbmUgU1RBVFVTX0JVU1kJCQkweDAwODAwMDgwCQkvKiBXcml0ZSBTdGF0ZSBNYWNoaW5lIFN0YXR1cyAoV1NNUykgKi8KKyNkZWZpbmUgU1RBVFVTX0VSQVNFX0VSUgkweDAwMjAwMDIwCQkvKiBFcmFzZSBTdGF0dXMgKEVTKSAqLworI2RlZmluZSBTVEFUVVNfUEdNX0VSUgkJMHgwMDEwMDAxMAkJLyogUHJvZ3JhbSBTdGF0dXMgKFBTKSAqLworCisvKgorICogU2VlIHNlY3Rpb24gNC4yIGluICIzIFZvbHQgRmFzdCBCb290IEJsb2NrIEZsYXNoIE1lbW9yeSIgSW50ZWwgRGF0YXNoZWV0CisgKi8KKyNkZWZpbmUgRkxBU0hfTUFOVUZBQ1RVUkVSCQkJMHgwMDg5MDA4OQorI2RlZmluZSBGTEFTSF9ERVZJQ0VfOG1iaXRfVE9QCQkweDg4ZjE4OGYxCisjZGVmaW5lIEZMQVNIX0RFVklDRV84bWJpdF9CT1RUT00JMHg4OGYyODhmMgorI2RlZmluZSBGTEFTSF9ERVZJQ0VfMTZtYml0X1RPUAkJMHg4OGYzODhmMworI2RlZmluZSBGTEFTSF9ERVZJQ0VfMTZtYml0X0JPVFRPTQkweDg4ZjQ4OGY0CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKy8qCisgKiBUaGUgZGF0YSBsaW5lIG1hcHBpbmcgb24gTEFSVCBpcyBhcyBmb2xsb3dzOgorICogCisgKiAgIAkgVTIgIENQVSB8ICAgVTMgIENQVQorICogICAJIC0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqICAgCSAgMCAgMjAgIHwgICAwICAgMTIKKyAqICAgCSAgMSAgMjIgIHwgICAxICAgMTQKKyAqICAgCSAgMiAgMTkgIHwgICAyICAgMTEKKyAqICAgCSAgMyAgMTcgIHwgICAzICAgOQorICogICAJICA0ICAyNCAgfCAgIDQgICAwCisgKiAgIAkgIDUgIDI2ICB8ICAgNSAgIDIKKyAqICAgCSAgNiAgMzEgIHwgICA2ICAgNworICogICAJICA3ICAyOSAgfCAgIDcgICA1CisgKiAgIAkgIDggIDIxICB8ICAgOCAgIDEzCisgKiAgIAkgIDkgIDIzICB8ICAgOSAgIDE1CisgKiAgIAkgIDEwIDE4ICB8ICAgMTAgIDEwCisgKiAgIAkgIDExIDE2ICB8ICAgMTEgIDgKKyAqICAgCSAgMTIgMjUgIHwgICAxMiAgMQorICogICAJICAxMyAyNyAgfCAgIDEzICAzCisgKiAgIAkgIDE0IDMwICB8ICAgMTQgIDYKKyAqICAgCSAgMTUgMjggIHwgICAxNSAgNAorICovCisKKy8qIE1hbmdsZSBkYXRhICh4KSAqLworI2RlZmluZSBEQVRBX1RPX0ZMQVNIKHgpCQkJCVwKKwkoCQkJCQkJCQkJXAorCQkoKCh4KSAmIDB4MDgwMDkwMDApID4+IDExKQkrCVwKKwkJKCgoeCkgJiAweDAwMDAyMDAwKSA+PiAxMCkJKwlcCisJCSgoKHgpICYgMHgwNDAwNDAwMCkgPj4gOCkJKwlcCisJCSgoKHgpICYgMHgwMDAwMDAxMCkgPj4gNCkJKwlcCisJCSgoKHgpICYgMHg5MTAwMDgyMCkgPj4gMykJKwlcCisJCSgoKHgpICYgMHgyMjA4MDA4MCkgPj4gMikJKwlcCisJCSgoeCkgJiAweDQwMDAwNDAwKQkJCSsJXAorCQkoKCh4KSAmIDB4MDAwNDAwNDApIDw8IDEpCSsJXAorCQkoKCh4KSAmIDB4MDAxMTAwMDApIDw8IDQpCSsJXAorCQkoKCh4KSAmIDB4MDAyMjAxMDApIDw8IDUpCSsJXAorCQkoKCh4KSAmIDB4MDA4MDAyMDgpIDw8IDYpCSsJXAorCQkoKCh4KSAmIDB4MDA0MDAwMDQpIDw8IDkpCSsJXAorCQkoKCh4KSAmIDB4MDAwMDAwMDEpIDw8IDEyKQkrCVwKKwkJKCgoeCkgJiAweDAwMDAwMDAyKSA8PCAxMykJCVwKKwkpCisKKy8qIFVubWFuZ2xlIGRhdGEgKHgpICovCisjZGVmaW5lIEZMQVNIX1RPX0RBVEEoeCkJCQkJXAorCSgJCQkJCQkJCQlcCisJCSgoKHgpICYgMHgwMDAxMDAxMikgPDwgMTEpCSsJXAorCQkoKCh4KSAmIDB4MDAwMDAwMDgpIDw8IDEwKQkrCVwKKwkJKCgoeCkgJiAweDAwMDQwMDQwKSA8PCA4KQkrCVwKKwkJKCgoeCkgJiAweDAwMDAwMDAxKSA8PCA0KQkrCVwKKwkJKCgoeCkgJiAweDEyMjAwMTA0KSA8PCAzKQkrCVwKKwkJKCgoeCkgJiAweDA4ODIwMDIwKSA8PCAyKQkrCVwKKwkJKCh4KSAmIDB4NDAwMDA0MDApCQkJKwlcCisJCSgoKHgpICYgMHgwMDA4MDA4MCkgPj4gMSkJKwlcCisJCSgoKHgpICYgMHgwMTEwMDAwMCkgPj4gNCkJKwlcCisJCSgoKHgpICYgMHgwNDQwMjAwMCkgPj4gNSkJKwlcCisJCSgoKHgpICYgMHgyMDAwODIwMCkgPj4gNikJKwlcCisJCSgoKHgpICYgMHg4MDAwMDgwMCkgPj4gOSkJKwlcCisJCSgoKHgpICYgMHgwMDAwMTAwMCkgPj4gMTIpCSsJXAorCQkoKCh4KSAmIDB4MDAwMDQwMDApID4+IDEzKQkJXAorCSkKKworLyogCisgKiBUaGUgYWRkcmVzcyBsaW5lIG1hcHBpbmcgb24gTEFSVCBpcyBhcyBmb2xsb3dzOgorICoKKyAqICAgCSBVMyAgQ1BVIHwgICBVMiAgQ1BVCisgKiAgIAkgLS0tLS0tLS0tLS0tLS0tLS0tLQorICogICAJICAwICAyICAgfCAgIDAgICAyCisgKiAgIAkgIDEgIDMgICB8ICAgMSAgIDMKKyAqICAgCSAgMiAgOSAgIHwgICAyICAgOQorICogICAJICAzICAxMyAgfCAgIDMgICA4CisgKiAgIAkgIDQgIDggICB8ICAgNCAgIDcKKyAqICAgCSAgNSAgMTIgIHwgICA1ICAgNgorICogICAJICA2ICAxMSAgfCAgIDYgICA1CisgKiAgIAkgIDcgIDEwICB8ICAgNyAgIDQKKyAqICAgCSAgOCAgNCAgIHwgICA4ICAgMTAKKyAqICAgCSAgOSAgNSAgIHwgICA5ICAgMTEKKyAqICAgCSAxMCAgNiAgIHwgICAxMCAgMTIKKyAqICAgCSAxMSAgNyAgIHwgICAxMSAgMTMKKyAqCisgKiAgIAkgQk9PVCBCTE9DSyBCT1VOREFSWQorICoKKyAqICAgCSAxMiAgMTUgIHwgICAxMiAgMTUKKyAqICAgCSAxMyAgMTQgIHwgICAxMyAgMTQKKyAqICAgCSAxNCAgMTYgIHwgICAxNCAgMTYKKyAqIAorICogICAJIE1BSU4gQkxPQ0sgQk9VTkRBUlkKKyAqCisgKiAgIAkgMTUgIDE3ICB8ICAgMTUgIDE4CisgKiAgIAkgMTYgIDE4ICB8ICAgMTYgIDE3CisgKiAgIAkgMTcgIDIwICB8ICAgMTcgIDIwCisgKiAgIAkgMTggIDE5ICB8ICAgMTggIDE5CisgKiAgIAkgMTkgIDIxICB8ICAgMTkgIDIxCisgKgorICogQXMgd2UgY2FuIHNlZSBmcm9tIGFib3ZlLCB0aGUgYWRkcmVzc2VzIGFyZW4ndCBtYW5nbGVkIGFjcm9zcworICogYmxvY2sgYm91bmRhcmllcywgc28gd2UgZG9uJ3QgbmVlZCB0byB3b3JyeSBhYm91dCBhZGRyZXNzCisgKiB0cmFuc2xhdGlvbnMgZXhjZXB0IGZvciBzZW5kaW5nL3JlYWRpbmcgY29tbWFuZHMgZHVyaW5nCisgKiBpbml0aWFsaXphdGlvbgorICovCisKKy8qIE1hbmdsZSBhZGRyZXNzICh4KSBvbiBjaGlwIFUyICovCisjZGVmaW5lIEFERFJfVE9fRkxBU0hfVTIoeCkJCQkJXAorCSgJCQkJCQkJCQlcCisJCSgoKHgpICYgMHgwMDAwMGYwMCkgPj4gNCkJKwlcCisJCSgoKHgpICYgMHgwMDA0MjAwMCkgPDwgMSkJKwlcCisJCSgoKHgpICYgMHgwMDA5YzAwMykgPDwgMikJKwlcCisJCSgoKHgpICYgMHgwMDAyMTA4MCkgPDwgMykJKwlcCisJCSgoKHgpICYgMHgwMDAwMDAxMCkgPDwgNCkJKwlcCisJCSgoKHgpICYgMHgwMDAwMDA0MCkgPDwgNSkJKwlcCisJCSgoKHgpICYgMHgwMDAwMDAyNCkgPDwgNykJKwlcCisJCSgoKHgpICYgMHgwMDAwMDAwOCkgPDwgMTApCQlcCisJKQorCisvKiBVbm1hbmdsZSBhZGRyZXNzICh4KSBvbiBjaGlwIFUyICovCisjZGVmaW5lIEZMQVNIX1UyX1RPX0FERFIoeCkJCQkJXAorCSgJCQkJCQkJCQlcCisJCSgoKHgpIDw8IDQpICYgMHgwMDAwMGYwMCkJKwlcCisJCSgoKHgpID4+IDEpICYgMHgwMDA0MjAwMCkJKwlcCisJCSgoKHgpID4+IDIpICYgMHgwMDA5YzAwMykJKwlcCisJCSgoKHgpID4+IDMpICYgMHgwMDAyMTA4MCkJKwlcCisJCSgoKHgpID4+IDQpICYgMHgwMDAwMDAxMCkJKwlcCisJCSgoKHgpID4+IDUpICYgMHgwMDAwMDA0MCkJKwlcCisJCSgoKHgpID4+IDcpICYgMHgwMDAwMDAyNCkJKwlcCisJCSgoKHgpID4+IDEwKSAmIDB4MDAwMDAwMDgpCQlcCisJKQorCisvKiBNYW5nbGUgYWRkcmVzcyAoeCkgb24gY2hpcCBVMyAqLworI2RlZmluZSBBRERSX1RPX0ZMQVNIX1UzKHgpCQkJCVwKKwkoCQkJCQkJCQkJXAorCQkoKCh4KSAmIDB4MDAwMDAwODApID4+IDMpCSsJXAorCQkoKCh4KSAmIDB4MDAwMDAwNDApID4+IDEpCSsJXAorCQkoKCh4KSAmIDB4MDAwNTIwMjApIDw8IDEpCSsJXAorCQkoKCh4KSAmIDB4MDAwODRmMDMpIDw8IDIpCSsJXAorCQkoKCh4KSAmIDB4MDAwMjkwMTApIDw8IDMpCSsJXAorCQkoKCh4KSAmIDB4MDAwMDAwMDgpIDw8IDUpCSsJXAorCQkoKCh4KSAmIDB4MDAwMDAwMDQpIDw8IDcpCQlcCisJKQorCisvKiBVbm1hbmdsZSBhZGRyZXNzICh4KSBvbiBjaGlwIFUzICovCisjZGVmaW5lIEZMQVNIX1UzX1RPX0FERFIoeCkJCQkJXAorCSgJCQkJCQkJCQlcCisJCSgoKHgpIDw8IDMpICYgMHgwMDAwMDA4MCkJKwlcCisJCSgoKHgpIDw8IDEpICYgMHgwMDAwMDA0MCkJKwlcCisJCSgoKHgpID4+IDEpICYgMHgwMDA1MjAyMCkJKwlcCisJCSgoKHgpID4+IDIpICYgMHgwMDA4NGYwMykJKwlcCisJCSgoKHgpID4+IDMpICYgMHgwMDAyOTAxMCkJKwlcCisJCSgoKHgpID4+IDUpICYgMHgwMDAwMDAwOCkJKwlcCisJCSgoKHgpID4+IDcpICYgMHgwMDAwMDAwNCkJCVwKKwkpCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBfX3U4IHJlYWQ4IChfX3UzMiBvZmZzZXQpCit7CisgICB2b2xhdGlsZSBfX3U4ICpkYXRhID0gKF9fdTggKikgKEZMQVNIX09GRlNFVCArIG9mZnNldCk7CisjaWZkZWYgTEFSVF9ERUJVRworICAgcHJpbnRrIChLRVJOX0RFQlVHICIlcygpOiAweCUuOHggLT4gMHglLjJ4XG4iLF9fRlVOQ1RJT05fXyxvZmZzZXQsKmRhdGEpOworI2VuZGlmCisgICByZXR1cm4gKCpkYXRhKTsKK30KKworc3RhdGljIF9fdTMyIHJlYWQzMiAoX191MzIgb2Zmc2V0KQoreworICAgdm9sYXRpbGUgX191MzIgKmRhdGEgPSAoX191MzIgKikgKEZMQVNIX09GRlNFVCArIG9mZnNldCk7CisjaWZkZWYgTEFSVF9ERUJVRworICAgcHJpbnRrIChLRVJOX0RFQlVHICIlcygpOiAweCUuOHggLT4gMHglLjh4XG4iLF9fRlVOQ1RJT05fXyxvZmZzZXQsKmRhdGEpOworI2VuZGlmCisgICByZXR1cm4gKCpkYXRhKTsKK30KKworc3RhdGljIHZvaWQgd3JpdGUzMiAoX191MzIgeCxfX3UzMiBvZmZzZXQpCit7CisgICB2b2xhdGlsZSBfX3UzMiAqZGF0YSA9IChfX3UzMiAqKSAoRkxBU0hfT0ZGU0VUICsgb2Zmc2V0KTsKKyAgICpkYXRhID0geDsKKyNpZmRlZiBMQVJUX0RFQlVHCisgICBwcmludGsgKEtFUk5fREVCVUcgIiVzKCk6IDB4JS44eCA8LSAweCUuOHhcbiIsX19GVU5DVElPTl9fLG9mZnNldCwqZGF0YSk7CisjZW5kaWYKK30KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyoKKyAqIFByb2JlIGZvciAxNm1iaXQgZmxhc2ggbWVtb3J5IG9uIGEgTEFSVCBib2FyZCB3aXRob3V0IGRvaW5nCisgKiB0b28gbXVjaCBkYW1hZ2UuIFNpbmNlIHdlIG5lZWQgdG8gd3JpdGUgMSBkd29yZCB0byBtZW1vcnksCisgKiB3ZSdyZSBmKipja2VkIGlmIHRoaXMgaGFwcGVucyB0byBiZSBEUkFNIHNpbmNlIHdlIGNhbid0CisgKiByZXN0b3JlIHRoZSBtZW1vcnkgKG90aGVyd2lzZSB3ZSBtaWdodCBleGl0IFJlYWQgQXJyYXkgbW9kZSkuCisgKgorICogUmV0dXJucyAxIGlmIHdlIGZvdW5kIDE2bWJpdCBmbGFzaCBtZW1vcnkgb24gTEFSVCwgMCBvdGhlcndpc2UuCisgKi8KK3N0YXRpYyBpbnQgZmxhc2hfcHJvYmUgKHZvaWQpCit7CisgICBfX3UzMiBtYW51ZmFjdHVyZXIsZGV2dHlwZTsKKworICAgLyogc2V0dXAgIlJlYWQgSWRlbnRpZmllciBDb2RlcyIgbW9kZSAqLworICAgd3JpdGUzMiAoREFUQV9UT19GTEFTSCAoUkVBRF9JRF9DT0RFUyksMHgwMDAwMDAwMCk7CisKKyAgIC8qIHByb2JlIFUyLiBVMi9VMyByZXR1cm5zIHRoZSBzYW1lIGRhdGEgc2luY2UgdGhlIGZpcnN0IDMKKwkqIGFkZHJlc3MgbGluZXMgaXMgbWFuZ2xlZCBpbiB0aGUgc2FtZSB3YXkgKi8KKyAgIG1hbnVmYWN0dXJlciA9IEZMQVNIX1RPX0RBVEEgKHJlYWQzMiAoQUREUl9UT19GTEFTSF9VMiAoMHgwMDAwMDAwMCkpKTsKKyAgIGRldnR5cGUgPSBGTEFTSF9UT19EQVRBIChyZWFkMzIgKEFERFJfVE9fRkxBU0hfVTIgKDB4MDAwMDAwMDEpKSk7CisKKyAgIC8qIHB1dCB0aGUgZmxhc2ggYmFjayBpbnRvIGNvbW1hbmQgbW9kZSAqLworICAgd3JpdGUzMiAoREFUQV9UT19GTEFTSCAoUkVBRF9BUlJBWSksMHgwMDAwMDAwMCk7CisKKyAgIHJldHVybiAobWFudWZhY3R1cmVyID09IEZMQVNIX01BTlVGQUNUVVJFUiAmJiAoZGV2dHlwZSA9PSBGTEFTSF9ERVZJQ0VfMTZtYml0X1RPUCB8fCBGTEFTSF9ERVZJQ0VfMTZtYml0X0JPVFRPTSkpOworfQorCisvKgorICogRXJhc2Ugb25lIGJsb2NrIG9mIGZsYXNoIG1lbW9yeSBhdCBvZmZzZXQgYGBvZmZzZXQnJyB3aGljaCBpcyBhbnkKKyAqIGFkZHJlc3Mgd2l0aGluIHRoZSBibG9jayB3aGljaCBzaG91bGQgYmUgZXJhc2VkLgorICoKKyAqIFJldHVybnMgMSBpZiBzdWNjZXNzZnVsLCAwIG90aGVyd2lzZS4KKyAqLworc3RhdGljIGlubGluZSBpbnQgZXJhc2VfYmxvY2sgKF9fdTMyIG9mZnNldCkKK3sKKyAgIF9fdTMyIHN0YXR1czsKKworI2lmZGVmIExBUlRfREVCVUcKKyAgIHByaW50ayAoS0VSTl9ERUJVRyAiJXMoKTogMHglLjh4XG4iLF9fRlVOQ1RJT05fXyxvZmZzZXQpOworI2VuZGlmCisKKyAgIC8qIGVyYXNlIGFuZCBjb25maXJtICovCisgICB3cml0ZTMyIChEQVRBX1RPX0ZMQVNIIChFUkFTRV9TRVRVUCksb2Zmc2V0KTsKKyAgIHdyaXRlMzIgKERBVEFfVE9fRkxBU0ggKEVSQVNFX0NPTkZJUk0pLG9mZnNldCk7CisKKyAgIC8qIHdhaXQgZm9yIGJsb2NrIGVyYXNlIHRvIGZpbmlzaCAqLworICAgZG8KKwkgeworCQl3cml0ZTMyIChEQVRBX1RPX0ZMQVNIIChTVEFUVVNfUkVBRCksb2Zmc2V0KTsKKwkJc3RhdHVzID0gRkxBU0hfVE9fREFUQSAocmVhZDMyIChvZmZzZXQpKTsKKwkgfQorICAgd2hpbGUgKCh+c3RhdHVzICYgU1RBVFVTX0JVU1kpICE9IDApOworCisgICAvKiBwdXQgdGhlIGZsYXNoIGJhY2sgaW50byBjb21tYW5kIG1vZGUgKi8KKyAgIHdyaXRlMzIgKERBVEFfVE9fRkxBU0ggKFJFQURfQVJSQVkpLG9mZnNldCk7CisKKyAgIC8qIHdhcyB0aGUgZXJhc2Ugc3VjY2Vzc2Z1bGw/ICovCisgICBpZiAoKHN0YXR1cyAmIFNUQVRVU19FUkFTRV9FUlIpKQorCSB7CisJCXByaW50ayAoS0VSTl9XQVJOSU5HICIlczogZXJhc2UgZXJyb3IgYXQgYWRkcmVzcyAweCUuOHguXG4iLG1vZHVsZV9uYW1lLG9mZnNldCk7CisJCXJldHVybiAoMCk7CisJIH0KKworICAgcmV0dXJuICgxKTsKK30KKworc3RhdGljIGludCBmbGFzaF9lcmFzZSAoc3RydWN0IG10ZF9pbmZvICptdGQsc3RydWN0IGVyYXNlX2luZm8gKmluc3RyKQoreworICAgX191MzIgYWRkcixsZW47CisgICBpbnQgaSxmaXJzdDsKKworI2lmZGVmIExBUlRfREVCVUcKKyAgIHByaW50ayAoS0VSTl9ERUJVRyAiJXMoYWRkciA9IDB4JS44eCwgbGVuID0gJWQpXG4iLF9fRlVOQ1RJT05fXyxpbnN0ci0+YWRkcixpbnN0ci0+bGVuKTsKKyNlbmRpZgorCisgICAvKiBzYW5pdHkgY2hlY2tzICovCisgICBpZiAoaW5zdHItPmFkZHIgKyBpbnN0ci0+bGVuID4gbXRkLT5zaXplKSByZXR1cm4gKC1FSU5WQUwpOworCisgICAvKgorCSogY2hlY2sgdGhhdCBib3RoIHN0YXJ0IGFuZCBlbmQgb2YgdGhlIHJlcXVlc3RlZCBlcmFzZSBhcmUKKwkqIGFsaWduZWQgd2l0aCB0aGUgZXJhc2VzaXplIGF0IHRoZSBhcHByb3ByaWF0ZSBhZGRyZXNzZXMuCisJKgorCSogc2tpcCBhbGwgZXJhc2UgcmVnaW9ucyB3aGljaCBhcmUgZW5kZWQgYmVmb3JlIHRoZSBzdGFydCBvZgorCSogdGhlIHJlcXVlc3RlZCBlcmFzZS4gQWN0dWFsbHksIHRvIHNhdmUgb24gdGhlIGNhbGN1bGF0aW9ucywKKwkqIHdlIHNraXAgdG8gdGhlIGZpcnN0IGVyYXNlIHJlZ2lvbiB3aGljaCBzdGFydHMgYWZ0ZXIgdGhlCisJKiBzdGFydCBvZiB0aGUgcmVxdWVzdGVkIGVyYXNlLCBhbmQgdGhlbiBnbyBiYWNrIG9uZS4KKwkqLworICAgZm9yIChpID0gMDsgaSA8IG10ZC0+bnVtZXJhc2VyZWdpb25zICYmIGluc3RyLT5hZGRyID49IG10ZC0+ZXJhc2VyZWdpb25zW2ldLm9mZnNldDsgaSsrKSA7CisgICBpLS07CisKKyAgIC8qCisJKiBvaywgbm93IGkgaXMgcG9pbnRpbmcgYXQgdGhlIGVyYXNlIHJlZ2lvbiBpbiB3aGljaCB0aGlzCisJKiBlcmFzZSByZXF1ZXN0IHN0YXJ0cy4gQ2hlY2sgdGhlIHN0YXJ0IG9mIHRoZSByZXF1ZXN0ZWQKKwkqIGVyYXNlIHJhbmdlIGlzIGFsaWduZWQgd2l0aCB0aGUgZXJhc2Ugc2l6ZSB3aGljaCBpcyBpbgorCSogZWZmZWN0IGhlcmUuCisJKi8KKyAgIGlmIChpbnN0ci0+YWRkciAmIChtdGQtPmVyYXNlcmVnaW9uc1tpXS5lcmFzZXNpemUgLSAxKSkgcmV0dXJuICgtRUlOVkFMKTsKKworICAgLyogUmVtZW1iZXIgdGhlIGVyYXNlIHJlZ2lvbiB3ZSBzdGFydCBvbiAqLworICAgZmlyc3QgPSBpOworCisgICAvKgorCSogbmV4dCwgY2hlY2sgdGhhdCB0aGUgZW5kIG9mIHRoZSByZXF1ZXN0ZWQgZXJhc2UgaXMgYWxpZ25lZAorCSogd2l0aCB0aGUgZXJhc2UgcmVnaW9uIGF0IHRoYXQgYWRkcmVzcy4KKwkqCisJKiBhcyBiZWZvcmUsIGRyb3AgYmFjayBvbmUgdG8gcG9pbnQgYXQgdGhlIHJlZ2lvbiBpbiB3aGljaAorCSogdGhlIGFkZHJlc3MgYWN0dWFsbHkgZmFsbHMKKwkqLworICAgZm9yICg7IGkgPCBtdGQtPm51bWVyYXNlcmVnaW9ucyAmJiBpbnN0ci0+YWRkciArIGluc3RyLT5sZW4gPj0gbXRkLT5lcmFzZXJlZ2lvbnNbaV0ub2Zmc2V0OyBpKyspIDsKKyAgIGktLTsKKworICAgLyogaXMgdGhlIGVuZCBhbGlnbmVkIG9uIGEgYmxvY2sgYm91bmRhcnk/ICovCisgICBpZiAoKGluc3RyLT5hZGRyICsgaW5zdHItPmxlbikgJiAobXRkLT5lcmFzZXJlZ2lvbnNbaV0uZXJhc2VzaXplIC0gMSkpIHJldHVybiAoLUVJTlZBTCk7CisKKyAgIGFkZHIgPSBpbnN0ci0+YWRkcjsKKyAgIGxlbiA9IGluc3RyLT5sZW47CisKKyAgIGkgPSBmaXJzdDsKKworICAgLyogbm93IGVyYXNlIHRob3NlIGJsb2NrcyAqLworICAgd2hpbGUgKGxlbikKKwkgeworCQlpZiAoIWVyYXNlX2Jsb2NrIChhZGRyKSkKKwkJICB7CisJCQkgaW5zdHItPnN0YXRlID0gTVREX0VSQVNFX0ZBSUxFRDsKKwkJCSByZXR1cm4gKC1FSU8pOworCQkgIH0KKworCQlhZGRyICs9IG10ZC0+ZXJhc2VyZWdpb25zW2ldLmVyYXNlc2l6ZTsKKwkJbGVuIC09IG10ZC0+ZXJhc2VyZWdpb25zW2ldLmVyYXNlc2l6ZTsKKworCQlpZiAoYWRkciA9PSBtdGQtPmVyYXNlcmVnaW9uc1tpXS5vZmZzZXQgKyAobXRkLT5lcmFzZXJlZ2lvbnNbaV0uZXJhc2VzaXplICogbXRkLT5lcmFzZXJlZ2lvbnNbaV0ubnVtYmxvY2tzKSkgaSsrOworCSB9CisKKyAgIGluc3RyLT5zdGF0ZSA9IE1URF9FUkFTRV9ET05FOworICAgbXRkX2VyYXNlX2NhbGxiYWNrKGluc3RyKTsKKworICAgcmV0dXJuICgwKTsKK30KKworc3RhdGljIGludCBmbGFzaF9yZWFkIChzdHJ1Y3QgbXRkX2luZm8gKm10ZCxsb2ZmX3QgZnJvbSxzaXplX3QgbGVuLHNpemVfdCAqcmV0bGVuLHVfY2hhciAqYnVmKQoreworI2lmZGVmIExBUlRfREVCVUcKKyAgIHByaW50ayAoS0VSTl9ERUJVRyAiJXMoZnJvbSA9IDB4JS44eCwgbGVuID0gJWQpXG4iLF9fRlVOQ1RJT05fXywoX191MzIpIGZyb20sbGVuKTsKKyNlbmRpZgorCisgICAvKiBzYW5pdHkgY2hlY2tzICovCisgICBpZiAoIWxlbikgcmV0dXJuICgwKTsKKyAgIGlmIChmcm9tICsgbGVuID4gbXRkLT5zaXplKSByZXR1cm4gKC1FSU5WQUwpOworCisgICAvKiB3ZSBhbHdheXMgcmVhZCBsZW4gYnl0ZXMgKi8KKyAgICpyZXRsZW4gPSBsZW47CisKKyAgIC8qIGZpcnN0LCB3ZSByZWFkIGJ5dGVzIHVudGlsIHdlIHJlYWNoIGEgZHdvcmQgYm91bmRhcnkgKi8KKyAgIGlmIChmcm9tICYgKEJVU1dJRFRIIC0gMSkpCisJIHsKKwkJaW50IGdhcCA9IEJVU1dJRFRIIC0gKGZyb20gJiAoQlVTV0lEVEggLSAxKSk7CisKKwkJd2hpbGUgKGxlbiAmJiBnYXAtLSkgKmJ1ZisrID0gcmVhZDggKGZyb20rKyksIGxlbi0tOworCSB9CisKKyAgIC8qIG5vdyB3ZSByZWFkIGR3b3JkcyB1bnRpbCB3ZSByZWFjaCBhIG5vbi1kd29yZCBib3VuZGFyeSAqLworICAgd2hpbGUgKGxlbiA+PSBCVVNXSURUSCkKKwkgeworCQkqKChfX3UzMiAqKSBidWYpID0gcmVhZDMyIChmcm9tKTsKKworCQlidWYgKz0gQlVTV0lEVEg7CisJCWZyb20gKz0gQlVTV0lEVEg7CisJCWxlbiAtPSBCVVNXSURUSDsKKwkgfQorCisgICAvKiB0b3AgdXAgdGhlIGxhc3QgdW5hbGlnbmVkIGJ5dGVzICovCisgICBpZiAobGVuICYgKEJVU1dJRFRIIC0gMSkpCisJIHdoaWxlIChsZW4tLSkgKmJ1ZisrID0gcmVhZDggKGZyb20rKyk7CisKKyAgIHJldHVybiAoMCk7Cit9CisKKy8qCisgKiBXcml0ZSBvbmUgZHdvcmQgYGB4JycgdG8gZmxhc2ggbWVtb3J5IGF0IG9mZnNldCBgYG9mZnNldCcnLiBgYG9mZnNldCcnCisgKiBtdXN0IGJlIDMyIGJpdHMsIGkuZS4gaXQgbXVzdCBiZSBvbiBhIGR3b3JkIGJvdW5kYXJ5LgorICoKKyAqIFJldHVybnMgMSBpZiBzdWNjZXNzZnVsLCAwIG90aGVyd2lzZS4KKyAqLworc3RhdGljIGlubGluZSBpbnQgd3JpdGVfZHdvcmQgKF9fdTMyIG9mZnNldCxfX3UzMiB4KQoreworICAgX191MzIgc3RhdHVzOworCisjaWZkZWYgTEFSVF9ERUJVRworICAgcHJpbnRrIChLRVJOX0RFQlVHICIlcygpOiAweCUuOHggPC0gMHglLjh4XG4iLF9fRlVOQ1RJT05fXyxvZmZzZXQseCk7CisjZW5kaWYKKworICAgLyogc2V0dXAgd3JpdGluZyAqLworICAgd3JpdGUzMiAoREFUQV9UT19GTEFTSCAoUEdNX1NFVFVQKSxvZmZzZXQpOworCisgICAvKiB3cml0ZSB0aGUgZGF0YSAqLworICAgd3JpdGUzMiAoeCxvZmZzZXQpOworCisgICAvKiB3YWl0IGZvciB0aGUgd3JpdGUgdG8gZmluaXNoICovCisgICBkbworCSB7CisJCXdyaXRlMzIgKERBVEFfVE9fRkxBU0ggKFNUQVRVU19SRUFEKSxvZmZzZXQpOworCQlzdGF0dXMgPSBGTEFTSF9UT19EQVRBIChyZWFkMzIgKG9mZnNldCkpOworCSB9CisgICB3aGlsZSAoKH5zdGF0dXMgJiBTVEFUVVNfQlVTWSkgIT0gMCk7CisKKyAgIC8qIHB1dCB0aGUgZmxhc2ggYmFjayBpbnRvIGNvbW1hbmQgbW9kZSAqLworICAgd3JpdGUzMiAoREFUQV9UT19GTEFTSCAoUkVBRF9BUlJBWSksb2Zmc2V0KTsKKworICAgLyogd2FzIHRoZSB3cml0ZSBzdWNjZXNzZnVsbD8gKi8KKyAgIGlmICgoc3RhdHVzICYgU1RBVFVTX1BHTV9FUlIpIHx8IHJlYWQzMiAob2Zmc2V0KSAhPSB4KQorCSB7CisJCXByaW50ayAoS0VSTl9XQVJOSU5HICIlczogd3JpdGUgZXJyb3IgYXQgYWRkcmVzcyAweCUuOHguXG4iLG1vZHVsZV9uYW1lLG9mZnNldCk7CisJCXJldHVybiAoMCk7CisJIH0KKworICAgcmV0dXJuICgxKTsKK30KKworc3RhdGljIGludCBmbGFzaF93cml0ZSAoc3RydWN0IG10ZF9pbmZvICptdGQsbG9mZl90IHRvLHNpemVfdCBsZW4sc2l6ZV90ICpyZXRsZW4sY29uc3QgdV9jaGFyICpidWYpCit7CisgICBfX3U4IHRtcFs0XTsKKyAgIGludCBpLG47CisKKyNpZmRlZiBMQVJUX0RFQlVHCisgICBwcmludGsgKEtFUk5fREVCVUcgIiVzKHRvID0gMHglLjh4LCBsZW4gPSAlZClcbiIsX19GVU5DVElPTl9fLChfX3UzMikgdG8sbGVuKTsKKyNlbmRpZgorCisgICAqcmV0bGVuID0gMDsKKworICAgLyogc2FuaXR5IGNoZWNrcyAqLworICAgaWYgKCFsZW4pIHJldHVybiAoMCk7CisgICBpZiAodG8gKyBsZW4gPiBtdGQtPnNpemUpIHJldHVybiAoLUVJTlZBTCk7CisKKyAgIC8qIGZpcnN0LCB3ZSB3cml0ZSBhIDB4RkYuLi4uIHBhZGRlZCBieXRlIHVudGlsIHdlIHJlYWNoIGEgZHdvcmQgYm91bmRhcnkgKi8KKyAgIGlmICh0byAmIChCVVNXSURUSCAtIDEpKQorCSB7CisJCV9fdTMyIGFsaWduZWQgPSB0byAmIH4oQlVTV0lEVEggLSAxKTsKKwkJaW50IGdhcCA9IHRvIC0gYWxpZ25lZDsKKworCQlpID0gbiA9IDA7CisKKwkJd2hpbGUgKGdhcC0tKSB0bXBbaSsrXSA9IDB4RkY7CisJCXdoaWxlIChsZW4gJiYgaSA8IEJVU1dJRFRIKSB0bXBbaSsrXSA9IGJ1ZltuKytdLCBsZW4tLTsKKwkJd2hpbGUgKGkgPCBCVVNXSURUSCkgdG1wW2krK10gPSAweEZGOworCisJCWlmICghd3JpdGVfZHdvcmQgKGFsaWduZWQsKigoX191MzIgKikgdG1wKSkpIHJldHVybiAoLUVJTyk7CisKKwkJdG8gKz0gbjsKKwkJYnVmICs9IG47CisJCSpyZXRsZW4gKz0gbjsKKwkgfQorCisgICAvKiBub3cgd2Ugd3JpdGUgZHdvcmRzIHVudGlsIHdlIHJlYWNoIGEgbm9uLWR3b3JkIGJvdW5kYXJ5ICovCisgICB3aGlsZSAobGVuID49IEJVU1dJRFRIKQorCSB7CisJCWlmICghd3JpdGVfZHdvcmQgKHRvLCooKF9fdTMyICopIGJ1ZikpKSByZXR1cm4gKC1FSU8pOworCisJCXRvICs9IEJVU1dJRFRIOworCQlidWYgKz0gQlVTV0lEVEg7CisJCSpyZXRsZW4gKz0gQlVTV0lEVEg7CisJCWxlbiAtPSBCVVNXSURUSDsKKwkgfQorCisgICAvKiB0b3AgdXAgdGhlIGxhc3QgdW5hbGlnbmVkIGJ5dGVzLCBwYWRkZWQgd2l0aCAweEZGLi4uLiAqLworICAgaWYgKGxlbiAmIChCVVNXSURUSCAtIDEpKQorCSB7CisJCWkgPSBuID0gMDsKKworCQl3aGlsZSAobGVuLS0pIHRtcFtpKytdID0gYnVmW24rK107CisJCXdoaWxlIChpIDwgQlVTV0lEVEgpIHRtcFtpKytdID0gMHhGRjsKKworCQlpZiAoIXdyaXRlX2R3b3JkICh0bywqKChfX3UzMiAqKSB0bXApKSkgcmV0dXJuICgtRUlPKTsKKworCQkqcmV0bGVuICs9IG47CisJIH0KKworICAgcmV0dXJuICgwKTsKK30KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2RlZmluZSBOQl9PRih4KSAoc2l6ZW9mICh4KSAvIHNpemVvZiAoeFswXSkpCisKK3N0YXRpYyBzdHJ1Y3QgbXRkX2luZm8gbXRkOworCitzdGF0aWMgc3RydWN0IG10ZF9lcmFzZV9yZWdpb25faW5mbyBlcmFzZV9yZWdpb25zW10gPSB7CisJLyogcGFyYW1ldGVyIGJsb2NrcyAqLworCXsKKwkJLm9mZnNldAkJPSAweDAwMDAwMDAwLAorCQkuZXJhc2VzaXplCT0gRkxBU0hfQkxPQ0tTSVpFX1BBUkFNLAorCQkubnVtYmxvY2tzCT0gRkxBU0hfTlVNQkxPQ0tTXzE2bV9QQVJBTSwKKwl9LAorCS8qIG1haW4gYmxvY2tzICovCisJeworCQkub2Zmc2V0CSA9IEZMQVNIX0JMT0NLU0laRV9QQVJBTSAqIEZMQVNIX05VTUJMT0NLU18xNm1fUEFSQU0sCisJCS5lcmFzZXNpemUJPSBGTEFTSF9CTE9DS1NJWkVfTUFJTiwKKwkJLm51bWJsb2Nrcwk9IEZMQVNIX05VTUJMT0NLU18xNm1fTUFJTiwKKwl9Cit9OworCisjaWZkZWYgSEFWRV9QQVJUSVRJT05TCitzdGF0aWMgc3RydWN0IG10ZF9wYXJ0aXRpb24gbGFydF9wYXJ0aXRpb25zW10gPSB7CisJLyogYmxvYiAqLworCXsKKwkJLm5hbWUJPSAiYmxvYiIsCisJCS5vZmZzZXQJPSBCTE9CX1NUQVJULAorCQkuc2l6ZQk9IEJMT0JfTEVOLAorCX0sCisJLyoga2VybmVsICovCisJeworCQkubmFtZQk9ICJrZXJuZWwiLAorCQkub2Zmc2V0CT0gS0VSTkVMX1NUQVJULAkJLyogTVREUEFSVF9PRlNfQVBQRU5EICovCisJCS5zaXplCT0gS0VSTkVMX0xFTiwKKwl9LAorCS8qIGluaXRpYWwgcmFtZGlzayAvIGZpbGUgc3lzdGVtICovCisJeworCQkubmFtZQk9ICJmaWxlIHN5c3RlbSIsCisJCS5vZmZzZXQJPSBJTklUUkRfU1RBUlQsCQkvKiBNVERQQVJUX09GU19BUFBFTkQgKi8KKwkJLnNpemUJPSBJTklUUkRfTEVOLAkJLyogTVREUEFSVF9TSVpfRlVMTCAqLworCX0KK307CisjZW5kaWYKKworaW50IF9faW5pdCBsYXJ0X2ZsYXNoX2luaXQgKHZvaWQpCit7CisgICBpbnQgcmVzdWx0OworICAgbWVtc2V0ICgmbXRkLDAsc2l6ZW9mIChtdGQpKTsKKyAgIHByaW50ayAoIk1URCBkcml2ZXIgZm9yIExBUlQuIFdyaXR0ZW4gYnkgQWJyYWhhbSB2ZCBNZXJ3ZSA8YWJyYWhhbUAyZDNkLmNvLnphPlxuIik7CisgICBwcmludGsgKCIlczogUHJvYmluZyBmb3IgMjhGMTYweDMgZmxhc2ggb24gTEFSVC4uLlxuIixtb2R1bGVfbmFtZSk7CisgICBpZiAoIWZsYXNoX3Byb2JlICgpKQorCSB7CisJCXByaW50ayAoS0VSTl9XQVJOSU5HICIlczogRm91bmQgbm8gTEFSVCBjb21wYXRpYmxlIGZsYXNoIGRldmljZVxuIixtb2R1bGVfbmFtZSk7CisJCXJldHVybiAoLUVOWElPKTsKKwkgfQorICAgcHJpbnRrICgiJXM6IFRoaXMgbG9va3MgbGlrZSBhIExBUlQgYm9hcmQgdG8gbWUuXG4iLG1vZHVsZV9uYW1lKTsKKyAgIG10ZC5uYW1lID0gbW9kdWxlX25hbWU7CisgICBtdGQudHlwZSA9IE1URF9OT1JGTEFTSDsKKyAgIG10ZC5mbGFncyA9IE1URF9DQVBfTk9SRkxBU0g7CisgICBtdGQuc2l6ZSA9IEZMQVNIX0JMT0NLU0laRV9QQVJBTSAqIEZMQVNIX05VTUJMT0NLU18xNm1fUEFSQU0gKyBGTEFTSF9CTE9DS1NJWkVfTUFJTiAqIEZMQVNIX05VTUJMT0NLU18xNm1fTUFJTjsKKyAgIG10ZC5lcmFzZXNpemUgPSBGTEFTSF9CTE9DS1NJWkVfTUFJTjsKKyAgIG10ZC5udW1lcmFzZXJlZ2lvbnMgPSBOQl9PRiAoZXJhc2VfcmVnaW9ucyk7CisgICBtdGQuZXJhc2VyZWdpb25zID0gZXJhc2VfcmVnaW9uczsKKyAgIG10ZC5lcmFzZSA9IGZsYXNoX2VyYXNlOworICAgbXRkLnJlYWQgPSBmbGFzaF9yZWFkOworICAgbXRkLndyaXRlID0gZmxhc2hfd3JpdGU7CisgICBtdGQub3duZXIgPSBUSElTX01PRFVMRTsKKworI2lmZGVmIExBUlRfREVCVUcKKyAgIHByaW50ayAoS0VSTl9ERUJVRworCQkgICAibXRkLm5hbWUgPSAlc1xuIgorCQkgICAibXRkLnNpemUgPSAweCUuOHggKCV1TSlcbiIKKwkJICAgIm10ZC5lcmFzZXNpemUgPSAweCUuOHggKCV1SylcbiIKKwkJICAgIm10ZC5udW1lcmFzZXJlZ2lvbnMgPSAlZFxuIiwKKwkJICAgbXRkLm5hbWUsCisJCSAgIG10ZC5zaXplLG10ZC5zaXplIC8gKDEwMjQqMTAyNCksCisJCSAgIG10ZC5lcmFzZXNpemUsbXRkLmVyYXNlc2l6ZSAvIDEwMjQsCisJCSAgIG10ZC5udW1lcmFzZXJlZ2lvbnMpOworCisgICBpZiAobXRkLm51bWVyYXNlcmVnaW9ucykKKwkgZm9yIChyZXN1bHQgPSAwOyByZXN1bHQgPCBtdGQubnVtZXJhc2VyZWdpb25zOyByZXN1bHQrKykKKwkgICBwcmludGsgKEtFUk5fREVCVUcKKwkJCSAgICJcblxuIgorCQkJICAgIm10ZC5lcmFzZXJlZ2lvbnNbJWRdLm9mZnNldCA9IDB4JS44eFxuIgorCQkJICAgIm10ZC5lcmFzZXJlZ2lvbnNbJWRdLmVyYXNlc2l6ZSA9IDB4JS44eCAoJXVLKVxuIgorCQkJICAgIm10ZC5lcmFzZXJlZ2lvbnNbJWRdLm51bWJsb2NrcyA9ICVkXG4iLAorCQkJICAgcmVzdWx0LG10ZC5lcmFzZXJlZ2lvbnNbcmVzdWx0XS5vZmZzZXQsCisJCQkgICByZXN1bHQsbXRkLmVyYXNlcmVnaW9uc1tyZXN1bHRdLmVyYXNlc2l6ZSxtdGQuZXJhc2VyZWdpb25zW3Jlc3VsdF0uZXJhc2VzaXplIC8gMTAyNCwKKwkJCSAgIHJlc3VsdCxtdGQuZXJhc2VyZWdpb25zW3Jlc3VsdF0ubnVtYmxvY2tzKTsKKworI2lmZGVmIEhBVkVfUEFSVElUSU9OUworICAgcHJpbnRrICgiXG5wYXJ0aXRpb25zID0gJWRcbiIsTkJfT0YgKGxhcnRfcGFydGl0aW9ucykpOworCisgICBmb3IgKHJlc3VsdCA9IDA7IHJlc3VsdCA8IE5CX09GIChsYXJ0X3BhcnRpdGlvbnMpOyByZXN1bHQrKykKKwkgcHJpbnRrIChLRVJOX0RFQlVHCisJCQkgIlxuXG4iCisJCQkgImxhcnRfcGFydGl0aW9uc1slZF0ubmFtZSA9ICVzXG4iCisJCQkgImxhcnRfcGFydGl0aW9uc1slZF0ub2Zmc2V0ID0gMHglLjh4XG4iCisJCQkgImxhcnRfcGFydGl0aW9uc1slZF0uc2l6ZSA9IDB4JS44eCAoJXVLKVxuIiwKKwkJCSByZXN1bHQsbGFydF9wYXJ0aXRpb25zW3Jlc3VsdF0ubmFtZSwKKwkJCSByZXN1bHQsbGFydF9wYXJ0aXRpb25zW3Jlc3VsdF0ub2Zmc2V0LAorCQkJIHJlc3VsdCxsYXJ0X3BhcnRpdGlvbnNbcmVzdWx0XS5zaXplLGxhcnRfcGFydGl0aW9uc1tyZXN1bHRdLnNpemUgLyAxMDI0KTsKKyNlbmRpZgorI2VuZGlmCisKKyNpZm5kZWYgSEFWRV9QQVJUSVRJT05TCisgICByZXN1bHQgPSBhZGRfbXRkX2RldmljZSAoJm10ZCk7CisjZWxzZQorICAgcmVzdWx0ID0gYWRkX210ZF9wYXJ0aXRpb25zICgmbXRkLGxhcnRfcGFydGl0aW9ucyxOQl9PRiAobGFydF9wYXJ0aXRpb25zKSk7CisjZW5kaWYKKworICAgcmV0dXJuIChyZXN1bHQpOworfQorCit2b2lkIF9fZXhpdCBsYXJ0X2ZsYXNoX2V4aXQgKHZvaWQpCit7CisjaWZuZGVmIEhBVkVfUEFSVElUSU9OUworICAgZGVsX210ZF9kZXZpY2UgKCZtdGQpOworI2Vsc2UKKyAgIGRlbF9tdGRfcGFydGl0aW9ucyAoJm10ZCk7CisjZW5kaWYKK30KKworbW9kdWxlX2luaXQgKGxhcnRfZmxhc2hfaW5pdCk7Cittb2R1bGVfZXhpdCAobGFydF9mbGFzaF9leGl0KTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiQWJyYWhhbSB2ZCBNZXJ3ZSA8YWJyYWhhbUAyZDNkLmNvLnphPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJNVEQgZHJpdmVyIGZvciBJbnRlbCAyOEYxNjBGMyBvbiBMQVJUIGJvYXJkIik7CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvZGV2aWNlcy9tczAyLW52LmMgYi9kcml2ZXJzL210ZC9kZXZpY2VzL21zMDItbnYuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zODBmZjA4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9tczAyLW52LmMKQEAgLTAsMCArMSwzMjYgQEAKKy8qCisgKglDb3B5cmlnaHQgKGMpIDIwMDEgTWFjaWVqIFcuIFJvenlja2kKKyAqCisgKglUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKgltb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICoJYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uCisgKgkyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqCSRJZDogbXMwMi1udi5jLHYgMS44IDIwMDUvMDEvMDUgMTg6MDU6MTIgZHdtdzIgRXhwICQKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2luY2x1ZGUgPGFzbS9hZGRyc3BhY2UuaD4KKyNpbmNsdWRlIDxhc20vYm9vdGluZm8uaD4KKyNpbmNsdWRlIDxhc20vZGVjL2lvYXNpY19hZGRycy5oPgorI2luY2x1ZGUgPGFzbS9kZWMva24wMi5oPgorI2luY2x1ZGUgPGFzbS9kZWMva24wMy5oPgorI2luY2x1ZGUgPGFzbS9pby5oPgorI2luY2x1ZGUgPGFzbS9wYWNjZXNzLmg+CisKKyNpbmNsdWRlICJtczAyLW52LmgiCisKKworc3RhdGljIGNoYXIgdmVyc2lvbltdIF9faW5pdGRhdGEgPQorCSJtczAyLW52LmM6IHYuMS4wLjAgIDEzIEF1ZyAyMDAxICBNYWNpZWogVy4gUm96eWNraS5cbiI7CisKK01PRFVMRV9BVVRIT1IoIk1hY2llaiBXLiBSb3p5Y2tpIDxtYWNyb0BsaW51eC1taXBzLm9yZz4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiREVDIE1TMDItTlYgTlZSQU0gbW9kdWxlIGRyaXZlciIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworCisKKy8qCisgKiBBZGRyZXNzZXMgd2UgcHJvYmUgZm9yIGFuIE1TMDItTlYgYXQuICBNb2R1bGVzIG1heSBiZSBsb2NhdGVkCisgKiBhdCBhbnkgOE1pQiBib3VuZGFyeSB3aXRoaW4gYSAwTWlCIHVwIHRvIDExMk1pQiByYW5nZSBvciBhdCBhbnkgMzJNaUIKKyAqIGJvdW5kYXJ5IHdpdGhpbiBhIDBNaUIgdXAgdG8gNDQ4TWlCIHJhbmdlLiAgV2UgZG9uJ3Qgc3VwcG9ydCBhIG1vZHVsZQorICogYXQgME1pQiwgdGhvdWdoLgorICovCitzdGF0aWMgdWxvbmcgbXMwMm52X2FkZHJzW10gX19pbml0ZGF0YSA9IHsKKwkweDA3MDAwMDAwLCAweDA2ODAwMDAwLCAweDA2MDAwMDAwLCAweDA1ODAwMDAwLCAweDA1MDAwMDAwLAorCTB4MDQ4MDAwMDAsIDB4MDQwMDAwMDAsIDB4MDM4MDAwMDAsIDB4MDMwMDAwMDAsIDB4MDI4MDAwMDAsCisJMHgwMjAwMDAwMCwgMHgwMTgwMDAwMCwgMHgwMTAwMDAwMCwgMHgwMDgwMDAwMAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgbXMwMm52X25hbWVbXSA9ICJERUMgTVMwMi1OViBOVlJBTSI7CitzdGF0aWMgY29uc3QgY2hhciBtczAybnZfcmVzX2RpYWdfcmFtW10gPSAiRGlhZ25vc3RpYyBSQU0iOworc3RhdGljIGNvbnN0IGNoYXIgbXMwMm52X3Jlc191c2VyX3JhbVtdID0gIkdlbmVyYWwtcHVycG9zZSBSQU0iOworc3RhdGljIGNvbnN0IGNoYXIgbXMwMm52X3Jlc19jc3JbXSA9ICJDb250cm9sIGFuZCBzdGF0dXMgcmVnaXN0ZXIiOworCitzdGF0aWMgc3RydWN0IG10ZF9pbmZvICpyb290X21zMDJudl9tdGQ7CisKKworc3RhdGljIGludCBtczAybnZfcmVhZChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sCisJCQlzaXplX3QgbGVuLCBzaXplX3QgKnJldGxlbiwgdV9jaGFyICpidWYpCit7CisJc3RydWN0IG1zMDJudl9wcml2YXRlICptcCA9IG10ZC0+cHJpdjsKKworCWlmIChmcm9tICsgbGVuID4gbXRkLT5zaXplKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCW1lbWNweShidWYsIG1wLT51YWRkciArIGZyb20sIGxlbik7CisJKnJldGxlbiA9IGxlbjsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IG1zMDJudl93cml0ZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLAorCQkJc2l6ZV90IGxlbiwgc2l6ZV90ICpyZXRsZW4sIGNvbnN0IHVfY2hhciAqYnVmKQoreworCXN0cnVjdCBtczAybnZfcHJpdmF0ZSAqbXAgPSBtdGQtPnByaXY7CisKKwlpZiAodG8gKyBsZW4gPiBtdGQtPnNpemUpCisJCXJldHVybiAtRUlOVkFMOworCisJbWVtY3B5KG1wLT51YWRkciArIHRvLCBidWYsIGxlbik7CisJKnJldGxlbiA9IGxlbjsKKworCXJldHVybiAwOworfQorCisKK3N0YXRpYyBpbmxpbmUgdWludCBtczAybnZfcHJvYmVfb25lKHVsb25nIGFkZHIpCit7CisJbXMwMm52X3VpbnQgKm1zMDJudl9kaWFncDsKKwltczAybnZfdWludCAqbXMwMm52X21hZ2ljcDsKKwl1aW50IG1zMDJudl9kaWFnOworCXVpbnQgbXMwMm52X21hZ2ljOworCXNpemVfdCBzaXplOworCisJaW50IGVycjsKKworCS8qCisJICogVGhlIGZpcm13YXJlIHdyaXRlcyBNUzAyTlZfSUQgYXQgTVMwMk5WX01BR0lDIGFuZCBhbHNvCisJICogYSBkaWFnbm9zdGljIHN0YXR1cyBhdCBNUzAyTlZfRElBRy4KKwkgKi8KKwltczAybnZfZGlhZ3AgPSAobXMwMm52X3VpbnQgKikoS1NFRzFBRERSKGFkZHIgKyBNUzAyTlZfRElBRykpOworCW1zMDJudl9tYWdpY3AgPSAobXMwMm52X3VpbnQgKikoS1NFRzFBRERSKGFkZHIgKyBNUzAyTlZfTUFHSUMpKTsKKwllcnIgPSBnZXRfZGJlKG1zMDJudl9tYWdpYywgbXMwMm52X21hZ2ljcCk7CisJaWYgKGVycikKKwkJcmV0dXJuIDA7CisJaWYgKG1zMDJudl9tYWdpYyAhPSBNUzAyTlZfSUQpCisJCXJldHVybiAwOworCisJbXMwMm52X2RpYWcgPSAqbXMwMm52X2RpYWdwOworCXNpemUgPSAobXMwMm52X2RpYWcgJiBNUzAyTlZfRElBR19TSVpFX01BU0spIDw8IE1TMDJOVl9ESUFHX1NJWkVfU0hJRlQ7CisJaWYgKHNpemUgPiBNUzAyTlZfQ1NSKQorCQlzaXplID0gTVMwMk5WX0NTUjsKKworCXJldHVybiBzaXplOworfQorCitzdGF0aWMgaW50IF9faW5pdCBtczAybnZfaW5pdF9vbmUodWxvbmcgYWRkcikKK3sKKwlzdHJ1Y3QgbXRkX2luZm8gKm10ZDsKKwlzdHJ1Y3QgbXMwMm52X3ByaXZhdGUgKm1wOworCXN0cnVjdCByZXNvdXJjZSAqbW9kX3JlczsKKwlzdHJ1Y3QgcmVzb3VyY2UgKmRpYWdfcmVzOworCXN0cnVjdCByZXNvdXJjZSAqdXNlcl9yZXM7CisJc3RydWN0IHJlc291cmNlICpjc3JfcmVzOworCXVsb25nIGZpeGFkZHI7CisJc2l6ZV90IHNpemUsIGZpeHNpemU7CisKKwlzdGF0aWMgaW50IHZlcnNpb25fcHJpbnRlZDsKKworCWludCByZXQgPSAtRU5PREVWOworCisJLyogVGhlIG1vZHVsZSBkZWNvZGVzIDhNaUIgb2YgYWRkcmVzcyBzcGFjZS4gKi8KKwltb2RfcmVzID0ga21hbGxvYyhzaXplb2YoKm1vZF9yZXMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIW1vZF9yZXMpCisJCXJldHVybiAtRU5PTUVNOworCisJbWVtc2V0KG1vZF9yZXMsIDAsIHNpemVvZigqbW9kX3JlcykpOworCW1vZF9yZXMtPm5hbWUgPSBtczAybnZfbmFtZTsKKwltb2RfcmVzLT5zdGFydCA9IGFkZHI7CisJbW9kX3Jlcy0+ZW5kID0gYWRkciArIE1TMDJOVl9TTE9UX1NJWkUgLSAxOworCW1vZF9yZXMtPmZsYWdzID0gSU9SRVNPVVJDRV9NRU0gfCBJT1JFU09VUkNFX0JVU1k7CisJaWYgKHJlcXVlc3RfcmVzb3VyY2UoJmlvbWVtX3Jlc291cmNlLCBtb2RfcmVzKSA8IDApCisJCWdvdG8gZXJyX291dF9tb2RfcmVzOworCisJc2l6ZSA9IG1zMDJudl9wcm9iZV9vbmUoYWRkcik7CisJaWYgKCFzaXplKQorCQlnb3RvIGVycl9vdXRfbW9kX3Jlc19yZWw7CisKKwlpZiAoIXZlcnNpb25fcHJpbnRlZCkgeworCQlwcmludGsoS0VSTl9JTkZPICIlcyIsIHZlcnNpb24pOworCQl2ZXJzaW9uX3ByaW50ZWQgPSAxOworCX0KKworCXJldCA9IC1FTk9NRU07CisJbXRkID0ga21hbGxvYyhzaXplb2YoKm10ZCksIEdGUF9LRVJORUwpOworCWlmICghbXRkKQorCQlnb3RvIGVycl9vdXRfbW9kX3Jlc19yZWw7CisJbWVtc2V0KG10ZCwgMCwgc2l6ZW9mKCptdGQpKTsKKwltcCA9IGttYWxsb2Moc2l6ZW9mKCptcCksIEdGUF9LRVJORUwpOworCWlmICghbXApCisJCWdvdG8gZXJyX291dF9tdGQ7CisJbWVtc2V0KG1wLCAwLCBzaXplb2YoKm1wKSk7CisKKwltdGQtPnByaXYgPSBtcDsKKwltcC0+cmVzb3VyY2UubW9kdWxlID0gbW9kX3JlczsKKworCS8qIEZpcm13YXJlJ3MgZGlhZ25vc3RpYyBOVlJBTSBhcmVhLiAqLworCWRpYWdfcmVzID0ga21hbGxvYyhzaXplb2YoKmRpYWdfcmVzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFkaWFnX3JlcykKKwkJZ290byBlcnJfb3V0X21wOworCisJbWVtc2V0KGRpYWdfcmVzLCAwLCBzaXplb2YoKmRpYWdfcmVzKSk7CisJZGlhZ19yZXMtPm5hbWUgPSBtczAybnZfcmVzX2RpYWdfcmFtOworCWRpYWdfcmVzLT5zdGFydCA9IGFkZHI7CisJZGlhZ19yZXMtPmVuZCA9IGFkZHIgKyBNUzAyTlZfUkFNIC0gMTsKKwlkaWFnX3Jlcy0+ZmxhZ3MgPSBJT1JFU09VUkNFX0JVU1k7CisJcmVxdWVzdF9yZXNvdXJjZShtb2RfcmVzLCBkaWFnX3Jlcyk7CisKKwltcC0+cmVzb3VyY2UuZGlhZ19yYW0gPSBkaWFnX3JlczsKKworCS8qIFVzZXItYXZhaWxhYmxlIGdlbmVyYWwtcHVycG9zZSBOVlJBTSBhcmVhLiAqLworCXVzZXJfcmVzID0ga21hbGxvYyhzaXplb2YoKnVzZXJfcmVzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCF1c2VyX3JlcykKKwkJZ290byBlcnJfb3V0X2RpYWdfcmVzOworCisJbWVtc2V0KHVzZXJfcmVzLCAwLCBzaXplb2YoKnVzZXJfcmVzKSk7CisJdXNlcl9yZXMtPm5hbWUgPSBtczAybnZfcmVzX3VzZXJfcmFtOworCXVzZXJfcmVzLT5zdGFydCA9IGFkZHIgKyBNUzAyTlZfUkFNOworCXVzZXJfcmVzLT5lbmQgPSBhZGRyICsgc2l6ZSAtIDE7CisJdXNlcl9yZXMtPmZsYWdzID0gSU9SRVNPVVJDRV9CVVNZOworCXJlcXVlc3RfcmVzb3VyY2UobW9kX3JlcywgdXNlcl9yZXMpOworCisJbXAtPnJlc291cmNlLnVzZXJfcmFtID0gdXNlcl9yZXM7CisKKwkvKiBDb250cm9sIGFuZCBzdGF0dXMgcmVnaXN0ZXIuICovCisJY3NyX3JlcyA9IGttYWxsb2Moc2l6ZW9mKCpjc3JfcmVzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjc3JfcmVzKQorCQlnb3RvIGVycl9vdXRfdXNlcl9yZXM7CisKKwltZW1zZXQoY3NyX3JlcywgMCwgc2l6ZW9mKCpjc3JfcmVzKSk7CisJY3NyX3Jlcy0+bmFtZSA9IG1zMDJudl9yZXNfY3NyOworCWNzcl9yZXMtPnN0YXJ0ID0gYWRkciArIE1TMDJOVl9DU1I7CisJY3NyX3Jlcy0+ZW5kID0gYWRkciArIE1TMDJOVl9DU1IgKyAzOworCWNzcl9yZXMtPmZsYWdzID0gSU9SRVNPVVJDRV9CVVNZOworCXJlcXVlc3RfcmVzb3VyY2UobW9kX3JlcywgY3NyX3Jlcyk7CisKKwltcC0+cmVzb3VyY2UuY3NyID0gY3NyX3JlczsKKworCW1wLT5hZGRyID0gcGh5c190b192aXJ0KGFkZHIpOworCW1wLT5zaXplID0gc2l6ZTsKKworCS8qCisJICogSGlkZSB0aGUgZmlybXdhcmUncyBkaWFnbm9zdGljIGFyZWEuICBJdCBtYXkgZ2V0IGRlc3Ryb3llZAorCSAqIHVwb24gYSByZWJvb3QuICBUYWtlIHBhZ2luZyBpbnRvIGFjY291bnQgZm9yIG1hcHBpbmcgc3VwcG9ydC4KKwkgKi8KKwlmaXhhZGRyID0gKGFkZHIgKyBNUzAyTlZfUkFNICsgUEFHRV9TSVpFIC0gMSkgJiB+KFBBR0VfU0laRSAtIDEpOworCWZpeHNpemUgPSAoc2l6ZSAtIChmaXhhZGRyIC0gYWRkcikpICYgfihQQUdFX1NJWkUgLSAxKTsKKwltcC0+dWFkZHIgPSBwaHlzX3RvX3ZpcnQoZml4YWRkcik7CisKKwltdGQtPnR5cGUgPSBNVERfUkFNOworCW10ZC0+ZmxhZ3MgPSBNVERfQ0FQX1JBTSB8IE1URF9YSVA7CisJbXRkLT5zaXplID0gZml4c2l6ZTsKKwltdGQtPm5hbWUgPSAoY2hhciAqKW1zMDJudl9uYW1lOworCW10ZC0+b3duZXIgPSBUSElTX01PRFVMRTsKKwltdGQtPnJlYWQgPSBtczAybnZfcmVhZDsKKwltdGQtPndyaXRlID0gbXMwMm52X3dyaXRlOworCisJcmV0ID0gLUVJTzsKKwlpZiAoYWRkX210ZF9kZXZpY2UobXRkKSkgeworCQlwcmludGsoS0VSTl9FUlIKKwkJCSJtczAyLW52OiBVbmFibGUgdG8gcmVnaXN0ZXIgTVREIGRldmljZSwgYWJvcnRpbmchXG4iKTsKKwkJZ290byBlcnJfb3V0X2Nzcl9yZXM7CisJfQorCisJcHJpbnRrKEtFUk5fSU5GTyAibXRkJWQ6ICVzIGF0IDB4JTA4bHgsIHNpemUgJXVNaUIuXG4iLAorCQltdGQtPmluZGV4LCBtczAybnZfbmFtZSwgYWRkciwgc2l6ZSA+PiAyMCk7CisKKwltcC0+bmV4dCA9IHJvb3RfbXMwMm52X210ZDsKKwlyb290X21zMDJudl9tdGQgPSBtdGQ7CisKKwlyZXR1cm4gMDsKKworCitlcnJfb3V0X2Nzcl9yZXM6CisJcmVsZWFzZV9yZXNvdXJjZShjc3JfcmVzKTsKKwlrZnJlZShjc3JfcmVzKTsKK2Vycl9vdXRfdXNlcl9yZXM6CisJcmVsZWFzZV9yZXNvdXJjZSh1c2VyX3Jlcyk7CisJa2ZyZWUodXNlcl9yZXMpOworZXJyX291dF9kaWFnX3JlczoKKwlyZWxlYXNlX3Jlc291cmNlKGRpYWdfcmVzKTsKKwlrZnJlZShkaWFnX3Jlcyk7CitlcnJfb3V0X21wOgorCWtmcmVlKG1wKTsKK2Vycl9vdXRfbXRkOgorCWtmcmVlKG10ZCk7CitlcnJfb3V0X21vZF9yZXNfcmVsOgorCXJlbGVhc2VfcmVzb3VyY2UobW9kX3Jlcyk7CitlcnJfb3V0X21vZF9yZXM6CisJa2ZyZWUobW9kX3Jlcyk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IG1zMDJudl9yZW1vdmVfb25lKHZvaWQpCit7CisJc3RydWN0IG10ZF9pbmZvICptdGQgPSByb290X21zMDJudl9tdGQ7CisJc3RydWN0IG1zMDJudl9wcml2YXRlICptcCA9IG10ZC0+cHJpdjsKKworCXJvb3RfbXMwMm52X210ZCA9IG1wLT5uZXh0OworCisJZGVsX210ZF9kZXZpY2UobXRkKTsKKworCXJlbGVhc2VfcmVzb3VyY2UobXAtPnJlc291cmNlLmNzcik7CisJa2ZyZWUobXAtPnJlc291cmNlLmNzcik7CisJcmVsZWFzZV9yZXNvdXJjZShtcC0+cmVzb3VyY2UudXNlcl9yYW0pOworCWtmcmVlKG1wLT5yZXNvdXJjZS51c2VyX3JhbSk7CisJcmVsZWFzZV9yZXNvdXJjZShtcC0+cmVzb3VyY2UuZGlhZ19yYW0pOworCWtmcmVlKG1wLT5yZXNvdXJjZS5kaWFnX3JhbSk7CisJcmVsZWFzZV9yZXNvdXJjZShtcC0+cmVzb3VyY2UubW9kdWxlKTsKKwlrZnJlZShtcC0+cmVzb3VyY2UubW9kdWxlKTsKKwlrZnJlZShtcCk7CisJa2ZyZWUobXRkKTsKK30KKworCitzdGF0aWMgaW50IF9faW5pdCBtczAybnZfaW5pdCh2b2lkKQoreworCXZvbGF0aWxlIHUzMiAqY3NyOworCXVpbnQgc3RyaWRlID0gMDsKKwlpbnQgY291bnQgPSAwOworCWludCBpOworCisJc3dpdGNoIChtaXBzX21hY2h0eXBlKSB7CisJY2FzZSBNQUNIX0RTNTAwMF8yMDA6CisJCWNzciA9ICh2b2xhdGlsZSB1MzIgKilLTjAyX0NTUl9CQVNFOworCQlpZiAoKmNzciAmIEtOMDJfQ1NSX0JOSzMyTSkKKwkJCXN0cmlkZSA9IDI7CisJCWJyZWFrOworCWNhc2UgTUFDSF9EUzUwMDBfMlgwOgorCWNhc2UgTUFDSF9EUzU5MDA6CisJCWNzciA9ICh2b2xhdGlsZSB1MzIgKilLTjAzX01DUl9CQVNFOworCQlpZiAoKmNzciAmIEtOMDNfTUNSX0JOSzMyTSkKKwkJCXN0cmlkZSA9IDI7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybiAtRU5PREVWOworCQlicmVhazsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgKHNpemVvZihtczAybnZfYWRkcnMpIC8gc2l6ZW9mKCptczAybnZfYWRkcnMpKTsgaSsrKQorCQlpZiAoIW1zMDJudl9pbml0X29uZShtczAybnZfYWRkcnNbaV0gPDwgc3RyaWRlKSkKKwkJCWNvdW50Kys7CisKKwlyZXR1cm4gKGNvdW50ID4gMCkgPyAwIDogLUVOT0RFVjsKK30KKworc3RhdGljIHZvaWQgX19leGl0IG1zMDJudl9jbGVhbnVwKHZvaWQpCit7CisJd2hpbGUgKHJvb3RfbXMwMm52X210ZCkKKwkJbXMwMm52X3JlbW92ZV9vbmUoKTsKK30KKworCittb2R1bGVfaW5pdChtczAybnZfaW5pdCk7Cittb2R1bGVfZXhpdChtczAybnZfY2xlYW51cCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL21zMDItbnYuaCBiL2RyaXZlcnMvbXRkL2RldmljZXMvbXMwMi1udi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhhNmVlZjcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL21zMDItbnYuaApAQCAtMCwwICsxLDEwNyBAQAorLyoKKyAqCUNvcHlyaWdodCAoYykgMjAwMSwgMjAwMyAgTWFjaWVqIFcuIFJvenlja2kKKyAqCisgKglERUMgTVMwMi1OViAoNTQtMjA5NDgtMDEpIGJhdHRlcnkgYmFja2VkLXVwIE5WUkFNIG1vZHVsZSBmb3IKKyAqCURFQ3N0YXRpb24vREVDc3lzdGVtIDUwMDAvMngwIGFuZCBERUNzeXN0ZW0gNTkwMCBhbmQgNTkwMC8yNjAKKyAqCXN5c3RlbXMuCisgKgorICoJVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICoJbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqCWFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbgorICoJMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKgkkSWQ6IG1zMDItbnYuaCx2IDEuMyAyMDAzLzA4LzE5IDA5OjI1OjM2IGR3bXcyIEV4cCAkCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKworLyoKKyAqIEFkZHJlc3NlcyBhcmUgZGVjb2RlZCBhcyBmb2xsb3dzOgorICoKKyAqIDB4MDAwMDAwIC0gMHgzZmZmZmYJU1JBTQorICogMHg0MDAwMDAgLSAweDdmZmZmZglDU1IKKyAqCisgKiBXaXRoaW4gdGhlIFNSQU0gYXJlYSB0aGUgZm9sbG93aW5nIHJhbmdlcyBhcmUgZm9yY2VkIGJ5IHRoZSBzeXN0ZW0KKyAqIGZpcm13YXJlOgorICoKKyAqIDB4MDAwMDAwIC0gMHgwMDAzZmYJZGlhZ25vc3RpYyBhcmVhLCBkZXN0cm95ZWQgdXBvbiBhIHJlYm9vdAorICogMHgwMDA0MDAgLSBFTkRvZlJBTQlzdG9yYWdlIGFyZWEsIGF2YWlsYWJsZSB0byBvcGVyYXRpbmcgc3lzdGVtcworICoKKyAqIGJ1dCB3ZSBjYW4ndCByZWFsbHkgdXNlIHRoZSBhdmFpbGFibGUgYXJlYSByaWdodCBmcm9tIDB4MDAwNDAwIGFzCisgKiB0aGUgZmlyc3Qgd29yZCBpcyB1c2VkIGJ5IHRoZSBmaXJtd2FyZSBhcyBhIHN0YXR1cyBmbGFnIHBhc3NlZAorICogZnJvbSBhbiBvcGVyYXRpbmcgc3lzdGVtLiAgSWYgYW55dGhpbmcgYnV0IHRoZSB2YWxpZCBkYXRhIG1hZ2ljCisgKiBJRCB2YWx1ZSBpcyBmb3VuZCwgdGhlIGZpcm13YXJlIGNvbnNpZGVycyB0aGUgU1JBTSBjbGVhbiwgaS5lLgorICogY29udGFpbmluZyBubyB2YWxpZCBkYXRhLCBhbmQgZGlzYWJsZXMgdGhlIGJhdHRlcnkgcmVzdWx0aW5nIGluCisgKiBkYXRhIGJlaW5nIGVyYXNlZCBhcyBzb29uIGFzIHBvd2VyIGlzIHN3aXRjaGVkIG9mZi4gIFNvIHRoZSBjaG9pY2UKKyAqIGZvciB0aGUgc3RhcnQgYWRkcmVzcyBvZiB0aGUgdXNlci1hdmFpbGFibGUgaXMgMHgwMDEwMDAgd2hpY2ggaXMKKyAqIG5pY2VseSBwYWdlIGFsaWduZWQuICBUaGUgYXJlYSBiZXR3ZWVuIDB4MDAwNDA0IGFuZCAweDAwMGZmZiBtYXkKKyAqIGJlIHVzZWQgYnkgdGhlIGRyaXZlciBmb3Igb3duIG5lZWRzLgorICoKKyAqIFRoZSBkaWFnbm9zdGljIGFyZWEgZGVmaW5lcyB0d28gc3RhdHVzIHdvcmRzIHRvIGJlIHJlYWQgYnkgYW4KKyAqIG9wZXJhdGluZyBzeXN0ZW0sIGEgbWFnaWMgSUQgdG8gZGlzdGluZ3Vpc2ggYSBNUzAyLU5WIGJvYXJkIGZyb20KKyAqIGFueXRoaW5nIGVsc2UgYW5kIGEgc3RhdHVzIGluZm9ybWF0aW9uIHByb3ZpZGluZyByZXN1bHRzIG9mIHRlc3RzCisgKiBhcyB3ZWxsIGFzIHRoZSBzaXplIG9mIFNSQU0gYXZhaWxhYmxlLCB3aGljaCBjYW4gYmUgMU1pQiBvciAyTWlCCisgKiAodGhhdCdzIHdoYXQgdGhlIGZpcm13YXJlIGhhbmRsZXM7IG5vIGlkZWEgaWYgMk1pQiBtb2R1bGVzIGV2ZXIKKyAqIGV4aXN0ZWQpLgorICoKKyAqIFRoZSBmaXJtd2FyZSBvbmx5IGhhbmRsZXMgdGhlIE1TMDItTlYgYm9hcmQgaWYgaW5zdGFsbGVkIGluIHRoZQorICogbGFzdCAoMTV0aCkgc2xvdCwgc28gZm9yIGFueSBvdGhlciBsb2NhdGlvbiB0aGUgc3RhdHVzIGluZm9ybWF0aW9uCisgKiBzdG9yZWQgaW4gdGhlIFNSQU0gY2Fubm90IGJlIHJlbGllZCB1cG9uLiAgQnV0IGZyb20gdGhlIGhhcmR3YXJlCisgKiBwb2ludCBvZiB2aWV3IHRoZXJlIGlzIG5vIHByb2JsZW0gdXNpbmcgdXAgdG8gMTQgc3VjaCBib2FyZHMgaW4gYQorICogc3lzdGVtIC0tIG9ubHkgdGhlIDFzdCBzbG90IG5lZWRzIHRvIGJlIGZpbGxlZCB3aXRoIGEgRFJBTSBtb2R1bGUuCisgKiBUaGUgTVMwMi1OViBib2FyZCBpcyBFQ0MtcHJvdGVjdGVkLCBsaWtlIG90aGVyIE1TMDIgbWVtb3J5IGJvYXJkcy4KKyAqCisgKiBUaGUgc3RhdGUgb2YgdGhlIGJhdHRlcnkgYXMgcHJvdmlkZWQgYnkgdGhlIENTUiBpcyByZWZsZWN0ZWQgb24KKyAqIHRoZSB0d28gb25ib2FyZCBMRURzLiAgV2hlbiBmYWNpbmcgdGhlIGJhdHRlcnkgc2lkZSBvZiB0aGUgYm9hcmQsCisgKiB3aXRoIHRoZSBMRURzIGF0IHRoZSB0b3AgbGVmdCBhbmQgdGhlIGJhdHRlcnkgYXQgdGhlIGJvdHRvbSByaWdodAorICogKGkuZS4gbG9va2luZyBmcm9tIHRoZSBiYWNrIHNpZGUgb2YgdGhlIHN5c3RlbSBib3gpLCB0aGVpciBtZWFuaW5nCisgKiBpcyBhcyBmb2xsb3dzICh0aGUgc3lzdGVtIGhhcyB0byBiZSBwb3dlcmVkIG9uKToKKyAqCisgKiBsZWZ0IExFRAkJYmF0dGVyeSBkaXNhYmxlIHN0YXR1czogbGl0ID0gZW5hYmxlZAorICogcmlnaHQgTEVECQliYXR0ZXJ5IGNvbmRpdGlvbiBzdGF0dXM6IGxpdCA9IE9LCisgKi8KKworLyogTVMwMi1OViBpb21lbSByZWdpc3RlciBvZmZzZXRzLiAqLworI2RlZmluZSBNUzAyTlZfQ1NSCQkweDQwMDAwMAkvKiBjb250cm9sICYgc3RhdHVzIHJlZ2lzdGVyICovCisKKy8qIE1TMDItTlYgQ1NSIHN0YXR1cyBiaXRzLiAqLworI2RlZmluZSBNUzAyTlZfQ1NSX0JBVFRfT0sJMHgwMQkJLyogYmF0dGVyeSBPSyAqLworI2RlZmluZSBNUzAyTlZfQ1NSX0JBVFRfT0ZGCTB4MDIJCS8qIGJhdHRlcnkgZGlzYWJsZWQgKi8KKworCisvKiBNUzAyLU5WIG1lbW9yeSBvZmZzZXRzLiAqLworI2RlZmluZSBNUzAyTlZfRElBRwkJMHgwMDAzZjgJLyogZGlhZ25vc3RpYyBzdGF0dXMgKi8KKyNkZWZpbmUgTVMwMk5WX01BR0lDCQkweDAwMDNmYwkvKiBNUzAyLU5WIG1hZ2ljIElEICovCisjZGVmaW5lIE1TMDJOVl9WQUxJRAkJMHgwMDA0MDAJLyogdmFsaWQgZGF0YSBtYWdpYyBJRCAqLworI2RlZmluZSBNUzAyTlZfUkFNCQkweDAwMTAwMAkvKiB1c2VyLWV4cG9zZWQgUkFNIHN0YXJ0ICovCisKKy8qIE1TMDItTlYgZGlhZ25vc3RpYyBzdGF0dXMgYml0cy4gKi8KKyNkZWZpbmUgTVMwMk5WX0RJQUdfVEVTVAkweDAxCQkvKiBTUkFNIHRlc3QgZG9uZSAoPykgKi8KKyNkZWZpbmUgTVMwMk5WX0RJQUdfUk8JCTB4MDIJCS8qIFNSQU0gci9vIHRlc3QgZG9uZSAqLworI2RlZmluZSBNUzAyTlZfRElBR19SVwkJMHgwNAkJLyogU1JBTSByL3cgdGVzdCBkb25lICovCisjZGVmaW5lIE1TMDJOVl9ESUFHX0ZBSUwJMHgwOAkJLyogU1JBTSB0ZXN0IGZhaWxlZCAqLworI2RlZmluZSBNUzAyTlZfRElBR19TSVpFX01BU0sJMHhmMAkJLyogU1JBTSBzaXplIG1hc2sgKi8KKyNkZWZpbmUgTVMwMk5WX0RJQUdfU0laRV9TSElGVAkweDEwCQkvKiBTUkFNIHNpemUgc2hpZnQgKGxlZnQpICovCisKKy8qIE1TMDItTlYgZ2VuZXJhbCBjb25zdGFudHMuICovCisjZGVmaW5lIE1TMDJOVl9JRAkJMHgwMzAyMTk2NgkvKiBNUzAyLU5WIG1hZ2ljIElEIHZhbHVlICovCisjZGVmaW5lIE1TMDJOVl9WQUxJRF9JRAkJMHhiZDEwMDI0OAkvKiB2YWxpZCBkYXRhIG1hZ2ljIElEIHZhbHVlICovCisjZGVmaW5lIE1TMDJOVl9TTE9UX1NJWkUJMHg4MDAwMDAJLyogc2l6ZSBvZiB0aGUgYWRkcmVzcyBzcGFjZQorCQkJCQkJICAgZGVjb2RlZCBieSB0aGUgbW9kdWxlICovCisKKwordHlwZWRlZiB2b2xhdGlsZSB1MzIgbXMwMm52X3VpbnQ7CisKK3N0cnVjdCBtczAybnZfcHJpdmF0ZSB7CisJc3RydWN0IG10ZF9pbmZvICpuZXh0OworCXN0cnVjdCB7CisJCXN0cnVjdCByZXNvdXJjZSAqbW9kdWxlOworCQlzdHJ1Y3QgcmVzb3VyY2UgKmRpYWdfcmFtOworCQlzdHJ1Y3QgcmVzb3VyY2UgKnVzZXJfcmFtOworCQlzdHJ1Y3QgcmVzb3VyY2UgKmNzcjsKKwl9IHJlc291cmNlOworCXVfY2hhciAqYWRkcjsKKwlzaXplX3Qgc2l6ZTsKKwl1X2NoYXIgKnVhZGRyOworfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvbXRkcmFtLmMgYi9kcml2ZXJzL210ZC9kZXZpY2VzL210ZHJhbS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVkYWM0MTUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL210ZHJhbS5jCkBAIC0wLDAgKzEsMjM1IEBACisvKgorICogbXRkcmFtIC0gYSB0ZXN0IG10ZCBkZXZpY2UKKyAqICRJZDogbXRkcmFtLmMsdiAxLjM1IDIwMDUvMDEvMDUgMTg6MDU6MTIgZHdtdzIgRXhwICQKKyAqIEF1dGhvcjogQWxleGFuZGVyIExhcnNzb24gPGFsZXhAY2VuZGlvLnNlPgorICoKKyAqIENvcHlyaWdodCAoYykgMTk5OSBBbGV4YW5kZXIgTGFyc3NvbiA8YWxleEBjZW5kaW8uc2U+CisgKgorICogVGhpcyBjb2RlIGlzIEdQTAorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvY29uZmlnLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvbXRkL2NvbXBhdG1hYy5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKworI2lmbmRlZiBDT05GSUdfTVREUkFNX0FCU19QT1MKKyAgI2RlZmluZSBDT05GSUdfTVREUkFNX0FCU19QT1MgMAorI2VuZGlmCisKKyNpZiBDT05GSUdfTVREUkFNX0FCU19QT1MgPiAwCisgICNpbmNsdWRlIDxhc20vaW8uaD4KKyNlbmRpZgorCisjaWZkZWYgTU9EVUxFCitzdGF0aWMgdW5zaWduZWQgbG9uZyB0b3RhbF9zaXplID0gQ09ORklHX01URFJBTV9UT1RBTF9TSVpFOworc3RhdGljIHVuc2lnbmVkIGxvbmcgZXJhc2Vfc2l6ZSA9IENPTkZJR19NVERSQU1fRVJBU0VfU0laRTsKK21vZHVsZV9wYXJhbSh0b3RhbF9zaXplLHVsb25nLDApOworTU9EVUxFX1BBUk1fREVTQyh0b3RhbF9zaXplLCAiVG90YWwgZGV2aWNlIHNpemUgaW4gS2lCIik7Cittb2R1bGVfcGFyYW0oZXJhc2Vfc2l6ZSx1bG9uZywwKTsKK01PRFVMRV9QQVJNX0RFU0MoZXJhc2Vfc2l6ZSwgIkRldmljZSBlcmFzZSBibG9jayBzaXplIGluIEtpQiIpOworI2RlZmluZSBNVERSQU1fVE9UQUxfU0laRSAodG90YWxfc2l6ZSAqIDEwMjQpCisjZGVmaW5lIE1URFJBTV9FUkFTRV9TSVpFIChlcmFzZV9zaXplICogMTAyNCkKKyNlbHNlCisjZGVmaW5lIE1URFJBTV9UT1RBTF9TSVpFIChDT05GSUdfTVREUkFNX1RPVEFMX1NJWkUgKiAxMDI0KQorI2RlZmluZSBNVERSQU1fRVJBU0VfU0laRSAoQ09ORklHX01URFJBTV9FUkFTRV9TSVpFICogMTAyNCkKKyNlbmRpZgorCisKKy8vIFdlIGNvdWxkIHN0b3JlIHRoZXNlIGluIHRoZSBtdGQgc3RydWN0dXJlLCBidXQgd2Ugb25seSBzdXBwb3J0IDEgZGV2aWNlLi4KK3N0YXRpYyBzdHJ1Y3QgbXRkX2luZm8gKm10ZF9pbmZvOworCisKK3N0YXRpYyBpbnQKK3JhbV9lcmFzZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgc3RydWN0IGVyYXNlX2luZm8gKmluc3RyKQoreworICBERUJVRyhNVERfREVCVUdfTEVWRUwyLCAicmFtX2VyYXNlKHBvczolbGQsIGxlbjolbGQpXG4iLCAobG9uZylpbnN0ci0+YWRkciwgKGxvbmcpaW5zdHItPmxlbik7CisgIGlmIChpbnN0ci0+YWRkciArIGluc3RyLT5sZW4gPiBtdGQtPnNpemUpIHsKKyAgICBERUJVRyhNVERfREVCVUdfTEVWRUwxLCAicmFtX2VyYXNlKCkgb3V0IG9mIGJvdW5kcyAoJWxkID4gJWxkKVxuIiwgKGxvbmcpKGluc3RyLT5hZGRyICsgaW5zdHItPmxlbiksIChsb25nKW10ZC0+c2l6ZSk7CisgICAgcmV0dXJuIC1FSU5WQUw7CisgIH0KKwkKKyAgbWVtc2V0KChjaGFyICopbXRkLT5wcml2ICsgaW5zdHItPmFkZHIsIDB4ZmYsIGluc3RyLT5sZW4pOworCQorICBpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRE9ORTsKKyAgbXRkX2VyYXNlX2NhbGxiYWNrKGluc3RyKTsKKworICByZXR1cm4gMDsKK30KKworc3RhdGljIGludCByYW1fcG9pbnQgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgZnJvbSwgc2l6ZV90IGxlbiwgc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqKm10ZGJ1ZikKK3sKKyAgaWYgKGZyb20gKyBsZW4gPiBtdGQtPnNpemUpCisgICAgcmV0dXJuIC1FSU5WQUw7CisJCisgICptdGRidWYgPSBtdGQtPnByaXYgKyBmcm9tOworICAqcmV0bGVuID0gbGVuOworICByZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcmFtX3VucG9pbnQgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB1X2NoYXIgKmFkZHIsIGxvZmZfdCBmcm9tLAorCQkJIHNpemVfdCBsZW4pCit7CisgIERFQlVHKE1URF9ERUJVR19MRVZFTDIsICJyYW1fdW5wb2ludFxuIik7Cit9CisKK3N0YXRpYyBpbnQgcmFtX3JlYWQoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLAorCSAgICAgc2l6ZV90ICpyZXRsZW4sIHVfY2hhciAqYnVmKQoreworICBERUJVRyhNVERfREVCVUdfTEVWRUwyLCAicmFtX3JlYWQocG9zOiVsZCwgbGVuOiVsZClcbiIsIChsb25nKWZyb20sIChsb25nKWxlbik7CisgIGlmIChmcm9tICsgbGVuID4gbXRkLT5zaXplKSB7CisgICAgREVCVUcoTVREX0RFQlVHX0xFVkVMMSwgInJhbV9yZWFkKCkgb3V0IG9mIGJvdW5kcyAoJWxkID4gJWxkKVxuIiwgKGxvbmcpKGZyb20gKyBsZW4pLCAobG9uZyltdGQtPnNpemUpOworICAgIHJldHVybiAtRUlOVkFMOworICB9CisKKyAgbWVtY3B5KGJ1ZiwgbXRkLT5wcml2ICsgZnJvbSwgbGVuKTsKKworICAqcmV0bGVuPWxlbjsKKyAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcmFtX3dyaXRlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgdG8sIHNpemVfdCBsZW4sCisJICAgICAgc2l6ZV90ICpyZXRsZW4sIGNvbnN0IHVfY2hhciAqYnVmKQoreworICBERUJVRyhNVERfREVCVUdfTEVWRUwyLCAicmFtX3dyaXRlKHBvczolbGQsIGxlbjolbGQpXG4iLCAobG9uZyl0bywgKGxvbmcpbGVuKTsKKyAgaWYgKHRvICsgbGVuID4gbXRkLT5zaXplKSB7CisgICAgREVCVUcoTVREX0RFQlVHX0xFVkVMMSwgInJhbV93cml0ZSgpIG91dCBvZiBib3VuZHMgKCVsZCA+ICVsZClcbiIsIChsb25nKSh0byArIGxlbiksIChsb25nKW10ZC0+c2l6ZSk7CisgICAgcmV0dXJuIC1FSU5WQUw7CisgIH0KKworICBtZW1jcHkgKChjaGFyICopbXRkLT5wcml2ICsgdG8sIGJ1ZiwgbGVuKTsKKworICAqcmV0bGVuPWxlbjsKKyAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBjbGVhbnVwX210ZHJhbSh2b2lkKQoreworICBpZiAobXRkX2luZm8pIHsKKyAgICBkZWxfbXRkX2RldmljZShtdGRfaW5mbyk7CisjaWYgQ09ORklHX01URFJBTV9UT1RBTF9TSVpFID4gMAorICAgIGlmIChtdGRfaW5mby0+cHJpdikKKyNpZiBDT05GSUdfTVREUkFNX0FCU19QT1MgPiAwCisgICAgICBpb3VubWFwKG10ZF9pbmZvLT5wcml2KTsKKyNlbHNlCisgICAgICB2ZnJlZShtdGRfaW5mby0+cHJpdik7CisjZW5kaWYJCisjZW5kaWYKKyAgICBrZnJlZShtdGRfaW5mbyk7CisgIH0KK30KKworaW50IG10ZHJhbV9pbml0X2RldmljZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgdm9pZCAqbWFwcGVkX2FkZHJlc3MsIAorICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBsb25nIHNpemUsIGNoYXIgKm5hbWUpCit7CisgICBtZW1zZXQobXRkLCAwLCBzaXplb2YoKm10ZCkpOworCisgICAvKiBTZXR1cCB0aGUgTVREIHN0cnVjdHVyZSAqLworICAgbXRkLT5uYW1lID0gbmFtZTsKKyAgIG10ZC0+dHlwZSA9IE1URF9SQU07CisgICBtdGQtPmZsYWdzID0gTVREX0NBUF9SQU07CisgICBtdGQtPnNpemUgPSBzaXplOworICAgbXRkLT5lcmFzZXNpemUgPSBNVERSQU1fRVJBU0VfU0laRTsKKyAgIG10ZC0+cHJpdiA9IG1hcHBlZF9hZGRyZXNzOworCisgICBtdGQtPm93bmVyID0gVEhJU19NT0RVTEU7CisgICBtdGQtPmVyYXNlID0gcmFtX2VyYXNlOworICAgbXRkLT5wb2ludCA9IHJhbV9wb2ludDsKKyAgIG10ZC0+dW5wb2ludCA9IHJhbV91bnBvaW50OworICAgbXRkLT5yZWFkID0gcmFtX3JlYWQ7CisgICBtdGQtPndyaXRlID0gcmFtX3dyaXRlOworCisgICBpZiAoYWRkX210ZF9kZXZpY2UobXRkKSkgeworICAgICByZXR1cm4gLUVJTzsKKyAgIH0KKyAgIAorICAgcmV0dXJuIDA7Cit9CisKKyNpZiBDT05GSUdfTVREUkFNX1RPVEFMX1NJWkUgPiAwCisjaWYgQ09ORklHX01URFJBTV9BQlNfUE9TID4gMAorc3RhdGljIGludCBfX2luaXQgaW5pdF9tdGRyYW0odm9pZCkKK3sKKyAgdm9pZCAqYWRkcjsKKyAgaW50IGVycjsKKyAgLyogQWxsb2NhdGUgc29tZSBtZW1vcnkgKi8KKyAgIG10ZF9pbmZvID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IG10ZF9pbmZvKSwgR0ZQX0tFUk5FTCk7CisgICBpZiAoIW10ZF9pbmZvKQorICAgICByZXR1cm4gLUVOT01FTTsKKyAgIAorICBhZGRyID0gaW9yZW1hcChDT05GSUdfTVREUkFNX0FCU19QT1MsIE1URFJBTV9UT1RBTF9TSVpFKTsKKyAgaWYgKCFhZGRyKSB7CisgICAgREVCVUcoTVREX0RFQlVHX0xFVkVMMSwgCisgICAgICAgICAgIkZhaWxlZCB0byBpb3JlbWFwKSBtZW1vcnkgcmVnaW9uIG9mIHNpemUgJWxkIGF0IEFCU19QT1M6JWxkXG4iLCAKKyAgICAgICAgICAobG9uZylNVERSQU1fVE9UQUxfU0laRSwgKGxvbmcpQ09ORklHX01URFJBTV9BQlNfUE9TKTsKKyAgICBrZnJlZShtdGRfaW5mbyk7CisgICAgbXRkX2luZm8gPSBOVUxMOworICAgIHJldHVybiAtRU5PTUVNOworICB9CisgIGVyciA9IG10ZHJhbV9pbml0X2RldmljZShtdGRfaW5mbywgYWRkciwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICBNVERSQU1fVE9UQUxfU0laRSwgIm10ZHJhbSB0ZXN0IGRldmljZSIpOworICBpZiAoZXJyKSAKKyAgeworICAgIGlvdW5tYXAoYWRkcik7CisgICAga2ZyZWUobXRkX2luZm8pOworICAgIG10ZF9pbmZvID0gTlVMTDsKKyAgICByZXR1cm4gZXJyOworICB9CisgIG1lbXNldChtdGRfaW5mby0+cHJpdiwgMHhmZiwgTVREUkFNX1RPVEFMX1NJWkUpOworICByZXR1cm4gZXJyOworfQorCisjZWxzZSAvKiBDT05GSUdfTVREUkFNX0FCU19QT1MgPiAwICovCisKK3N0YXRpYyBpbnQgX19pbml0IGluaXRfbXRkcmFtKHZvaWQpCit7CisgIHZvaWQgKmFkZHI7CisgIGludCBlcnI7CisgIC8qIEFsbG9jYXRlIHNvbWUgbWVtb3J5ICovCisgICBtdGRfaW5mbyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBtdGRfaW5mbyksIEdGUF9LRVJORUwpOworICAgaWYgKCFtdGRfaW5mbykKKyAgICAgcmV0dXJuIC1FTk9NRU07CisKKyAgYWRkciA9IHZtYWxsb2MoTVREUkFNX1RPVEFMX1NJWkUpOworICBpZiAoIWFkZHIpIHsKKyAgICBERUJVRyhNVERfREVCVUdfTEVWRUwxLCAKKyAgICAgICAgICAiRmFpbGVkIHRvIHZtYWxsb2MgbWVtb3J5IHJlZ2lvbiBvZiBzaXplICVsZFxuIiwgCisgICAgICAgICAgKGxvbmcpTVREUkFNX1RPVEFMX1NJWkUpOworICAgIGtmcmVlKG10ZF9pbmZvKTsKKyAgICBtdGRfaW5mbyA9IE5VTEw7CisgICAgcmV0dXJuIC1FTk9NRU07CisgIH0KKyAgZXJyID0gbXRkcmFtX2luaXRfZGV2aWNlKG10ZF9pbmZvLCBhZGRyLCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIE1URFJBTV9UT1RBTF9TSVpFLCAibXRkcmFtIHRlc3QgZGV2aWNlIik7CisgIGlmIChlcnIpIAorICB7CisgICAgdmZyZWUoYWRkcik7CisgICAga2ZyZWUobXRkX2luZm8pOworICAgIG10ZF9pbmZvID0gTlVMTDsKKyAgICByZXR1cm4gZXJyOworICB9CisgIG1lbXNldChtdGRfaW5mby0+cHJpdiwgMHhmZiwgTVREUkFNX1RPVEFMX1NJWkUpOworICByZXR1cm4gZXJyOworfQorI2VuZGlmIC8qICEoQ09ORklHX01URFJBTV9BQlNfUE9TID4gMCkgKi8KKworI2Vsc2UgLyogQ09ORklHX01URFJBTV9UT1RBTF9TSVpFID4gMCAqLworCitzdGF0aWMgaW50IF9faW5pdCBpbml0X210ZHJhbSh2b2lkKQoreworICByZXR1cm4gMDsKK30KKyNlbmRpZiAvKiAhKENPTkZJR19NVERSQU1fVE9UQUxfU0laRSA+IDApICovCisKK21vZHVsZV9pbml0KGluaXRfbXRkcmFtKTsKK21vZHVsZV9leGl0KGNsZWFudXBfbXRkcmFtKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiQWxleGFuZGVyIExhcnNzb24gPGFsZXhsQHJlZGhhdC5jb20+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04oIlNpbXVsYXRlZCBNVEQgZHJpdmVyIGZvciB0ZXN0aW5nIik7CisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvcGhyYW0uYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvcGhyYW0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41ZjhlMTY0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9waHJhbS5jCkBAIC0wLDAgKzEsMjg1IEBACisvKioKKyAqICRJZDogcGhyYW0uYyx2IDEuMTEgMjAwNS8wMS8wNSAxODowNToxMyBkd213MiBFeHAgJAorICoKKyAqIENvcHlyaWdodCAoYykgPz8/PwkJSm9jaGVuIFNjaOR1YmxlIDxwc2lvbmljQHBzaW9uaWMuZGU+CisgKiBDb3B5cmlnaHQgKGMpIDIwMDMtMjAwNAlK9nJuIEVuZ2VsIDxqb2VybkB3aC5maC13ZWRlbC5kZT4KKyAqCisgKiBVc2FnZToKKyAqCisgKiBvbmUgY29tbWVuZCBsaW5lIHBhcmFtZXRlciBwZXIgZGV2aWNlLCBlYWNoIGluIHRoZSBmb3JtOgorICogICBwaHJhbT08bmFtZT4sPHN0YXJ0Piw8bGVuPgorICogPG5hbWU+IG1heSBiZSB1cCB0byA2MyBjaGFyYWN0ZXJzLgorICogPHN0YXJ0PiBhbmQgPGxlbj4gY2FuIGJlIG9jdGFsLCBkZWNpbWFsIG9yIGhleGFkZWNpbWFsLiAgSWYgZm9sbG93ZWQKKyAqIGJ5ICJraSIsICJNaSIgb3IgIkdpIiwgdGhlIG51bWJlcnMgd2lsbCBiZSBpbnRlcnByZXRlZCBhcyBraWxvLCBtZWdhIG9yCisgKiBnaWdhYnl0ZXMuCisgKgorICogRXhhbXBsZToKKyAqCXBocmFtPXN3YXAsNjRNaSwxMjhNaSBwaHJhbT10ZXN0LDkwME1pLDFNaQorICoKKyAqLworCisjaW5jbHVkZSA8YXNtL2lvLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KKworI2RlZmluZSBFUlJPUihmbXQsIGFyZ3MuLi4pIHByaW50ayhLRVJOX0VSUiAicGhyYW06ICIgZm10ICwgIyMgYXJncykKKworc3RydWN0IHBocmFtX210ZF9saXN0IHsKKwlzdHJ1Y3QgbXRkX2luZm8gbXRkOworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKK307CisKK3N0YXRpYyBMSVNUX0hFQUQocGhyYW1fbGlzdCk7CisKKworCitzdGF0aWMgaW50IHBocmFtX2VyYXNlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqaW5zdHIpCit7CisJdV9jaGFyICpzdGFydCA9IG10ZC0+cHJpdjsKKworCWlmIChpbnN0ci0+YWRkciArIGluc3RyLT5sZW4gPiBtdGQtPnNpemUpCisJCXJldHVybiAtRUlOVkFMOworCQorCW1lbXNldChzdGFydCArIGluc3RyLT5hZGRyLCAweGZmLCBpbnN0ci0+bGVuKTsKKworCS8qIFRoaXMnbGwgY2F0Y2ggYSBmZXcgcmFjZXMuIEZyZWUgdGhlIHRoaW5nIGJlZm9yZSByZXR1cm5pbmcgOikgCisJICogSSBkb24ndCBmZWVsIGF0IGFsbCBhc2hhbWVkLiBUaGlzIGtpbmQgb2YgdGhpbmcgaXMgcG9zc2libGUgYW55d2F5CisJICogd2l0aCBmbGFzaCwgYnV0IHVubGlrZWx5LgorCSAqLworCisJaW5zdHItPnN0YXRlID0gTVREX0VSQVNFX0RPTkU7CisKKwltdGRfZXJhc2VfY2FsbGJhY2soaW5zdHIpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcGhyYW1fcG9pbnQoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLAorCQlzaXplX3QgKnJldGxlbiwgdV9jaGFyICoqbXRkYnVmKQoreworCXVfY2hhciAqc3RhcnQgPSBtdGQtPnByaXY7CisKKwlpZiAoZnJvbSArIGxlbiA+IG10ZC0+c2l6ZSkKKwkJcmV0dXJuIC1FSU5WQUw7CisJCisJKm10ZGJ1ZiA9IHN0YXJ0ICsgZnJvbTsKKwkqcmV0bGVuID0gbGVuOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBwaHJhbV91bnBvaW50KHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB1X2NoYXIgKmFkZHIsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuKQoreworfQorCitzdGF0aWMgaW50IHBocmFtX3JlYWQoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLAorCQlzaXplX3QgKnJldGxlbiwgdV9jaGFyICpidWYpCit7CisJdV9jaGFyICpzdGFydCA9IG10ZC0+cHJpdjsKKworCWlmIChmcm9tICsgbGVuID4gbXRkLT5zaXplKQorCQlyZXR1cm4gLUVJTlZBTDsKKwkKKwltZW1jcHkoYnVmLCBzdGFydCArIGZyb20sIGxlbik7CisKKwkqcmV0bGVuID0gbGVuOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBocmFtX3dyaXRlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3QgdG8sIHNpemVfdCBsZW4sCisJCXNpemVfdCAqcmV0bGVuLCBjb25zdCB1X2NoYXIgKmJ1ZikKK3sKKwl1X2NoYXIgKnN0YXJ0ID0gbXRkLT5wcml2OworCisJaWYgKHRvICsgbGVuID4gbXRkLT5zaXplKQorCQlyZXR1cm4gLUVJTlZBTDsKKwkKKwltZW1jcHkoc3RhcnQgKyB0bywgYnVmLCBsZW4pOworCisJKnJldGxlbiA9IGxlbjsKKwlyZXR1cm4gMDsKK30KKworCisKK3N0YXRpYyB2b2lkIHVucmVnaXN0ZXJfZGV2aWNlcyh2b2lkKQoreworCXN0cnVjdCBwaHJhbV9tdGRfbGlzdCAqdGhpczsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkodGhpcywgJnBocmFtX2xpc3QsIGxpc3QpIHsKKwkJZGVsX210ZF9kZXZpY2UoJnRoaXMtPm10ZCk7CisJCWlvdW5tYXAodGhpcy0+bXRkLnByaXYpOworCQlrZnJlZSh0aGlzKTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgcmVnaXN0ZXJfZGV2aWNlKGNoYXIgKm5hbWUsIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGVuKQoreworCXN0cnVjdCBwaHJhbV9tdGRfbGlzdCAqbmV3OworCWludCByZXQgPSAtRU5PTUVNOworCisJbmV3ID0ga21hbGxvYyhzaXplb2YoKm5ldyksIEdGUF9LRVJORUwpOworCWlmICghbmV3KQorCQlnb3RvIG91dDA7CisKKwltZW1zZXQobmV3LCAwLCBzaXplb2YoKm5ldykpOworCisJcmV0ID0gLUVJTzsKKwluZXctPm10ZC5wcml2ID0gaW9yZW1hcChzdGFydCwgbGVuKTsKKwlpZiAoIW5ldy0+bXRkLnByaXYpIHsKKwkJRVJST1IoImlvcmVtYXAgZmFpbGVkXG4iKTsKKwkJZ290byBvdXQxOworCX0KKworCisJbmV3LT5tdGQubmFtZSA9IG5hbWU7CisJbmV3LT5tdGQuc2l6ZSA9IGxlbjsKKwluZXctPm10ZC5mbGFncyA9IE1URF9DQVBfUkFNIHwgTVREX0VSQVNFQUJMRSB8IE1URF9WT0xBVElMRTsKKyAgICAgICAgbmV3LT5tdGQuZXJhc2UgPSBwaHJhbV9lcmFzZTsKKwluZXctPm10ZC5wb2ludCA9IHBocmFtX3BvaW50OworCW5ldy0+bXRkLnVucG9pbnQgPSBwaHJhbV91bnBvaW50OworCW5ldy0+bXRkLnJlYWQgPSBwaHJhbV9yZWFkOworCW5ldy0+bXRkLndyaXRlID0gcGhyYW1fd3JpdGU7CisJbmV3LT5tdGQub3duZXIgPSBUSElTX01PRFVMRTsKKwluZXctPm10ZC50eXBlID0gTVREX1JBTTsKKwluZXctPm10ZC5lcmFzZXNpemUgPSAwOworCisJcmV0ID0gLUVBR0FJTjsKKwlpZiAoYWRkX210ZF9kZXZpY2UoJm5ldy0+bXRkKSkgeworCQlFUlJPUigiRmFpbGVkIHRvIHJlZ2lzdGVyIG5ldyBkZXZpY2VcbiIpOworCQlnb3RvIG91dDI7CisJfQorCisJbGlzdF9hZGRfdGFpbCgmbmV3LT5saXN0LCAmcGhyYW1fbGlzdCk7CisJcmV0dXJuIDA7CQorCitvdXQyOgorCWlvdW5tYXAobmV3LT5tdGQucHJpdik7CitvdXQxOgorCWtmcmVlKG5ldyk7CitvdXQwOgorCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgdXN0cnRvdWwoY29uc3QgY2hhciAqY3AsIGNoYXIgKiplbmRwLCB1bnNpZ25lZCBpbnQgYmFzZSkKK3sKKwl1bnNpZ25lZCBsb25nIHJlc3VsdCA9IHNpbXBsZV9zdHJ0b3VsKGNwLCBlbmRwLCBiYXNlKTsKKworCXN3aXRjaCAoKiplbmRwKSB7CisJY2FzZSAnRyc6CisJCXJlc3VsdCAqPSAxMDI0OworCWNhc2UgJ00nOgorCQlyZXN1bHQgKj0gMTAyNDsKKwljYXNlICdrJzoKKwkJcmVzdWx0ICo9IDEwMjQ7CisJLyogQnkgZHdtdzIgZWRpdG9yaWFsIGRlY3JlZSwgImtpIiwgIk1pIiBvciAiR2kiIGFyZSB0byBiZSB1c2VkLiAqLworCQlpZiAoKCplbmRwKVsxXSA9PSAnaScpCisJCQkoKmVuZHApICs9IDI7CisJfQorCXJldHVybiByZXN1bHQ7Cit9CisKK3N0YXRpYyBpbnQgcGFyc2VfbnVtMzIodWludDMyX3QgKm51bTMyLCBjb25zdCBjaGFyICp0b2tlbikKK3sKKwljaGFyICplbmRwOworCXVuc2lnbmVkIGxvbmcgbjsKKworCW4gPSB1c3RydG91bCh0b2tlbiwgJmVuZHAsIDApOworCWlmICgqZW5kcCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkqbnVtMzIgPSBuOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBhcnNlX25hbWUoY2hhciAqKnBuYW1lLCBjb25zdCBjaGFyICp0b2tlbikKK3sKKwlzaXplX3QgbGVuOworCWNoYXIgKm5hbWU7CisKKwlsZW4gPSBzdHJsZW4odG9rZW4pICsgMTsKKwlpZiAobGVuID4gNjQpCisJCXJldHVybiAtRU5PU1BDOworCisJbmFtZSA9IGttYWxsb2MobGVuLCBHRlBfS0VSTkVMKTsKKwlpZiAoIW5hbWUpCisJCXJldHVybiAtRU5PTUVNOworCisJc3RyY3B5KG5hbWUsIHRva2VuKTsKKworCSpwbmFtZSA9IG5hbWU7CisJcmV0dXJuIDA7Cit9CisKKyNkZWZpbmUgcGFyc2VfZXJyKGZtdCwgYXJncy4uLikgZG8gewlcCisJRVJST1IoZm10ICwgIyMgYXJncyk7CVwKKwlyZXR1cm4gMDsJCVwKK30gd2hpbGUgKDApCisKK3N0YXRpYyBpbnQgcGhyYW1fc2V0dXAoY29uc3QgY2hhciAqdmFsLCBzdHJ1Y3Qga2VybmVsX3BhcmFtICprcCkKK3sKKwljaGFyIGJ1Zls2NCsxMisxMl0sICpzdHIgPSBidWY7CisJY2hhciAqdG9rZW5bM107CisJY2hhciAqbmFtZTsKKwl1aW50MzJfdCBzdGFydDsKKwl1aW50MzJfdCBsZW47CisJaW50IGksIHJldDsKKworCWlmIChzdHJubGVuKHZhbCwgc2l6ZW9mKGJ1ZikpID49IHNpemVvZihidWYpKQorCQlwYXJzZV9lcnIoInBhcmFtZXRlciB0b28gbG9uZ1xuIik7CisKKwlzdHJjcHkoc3RyLCB2YWwpOworCisJZm9yIChpPTA7IGk8MzsgaSsrKQorCQl0b2tlbltpXSA9IHN0cnNlcCgmc3RyLCAiLCIpOworCisJaWYgKHN0cikKKwkJcGFyc2VfZXJyKCJ0b28gbWFueSBhcmd1bWVudHNcbiIpOworCisJaWYgKCF0b2tlblsyXSkKKwkJcGFyc2VfZXJyKCJub3QgZW5vdWdoIGFyZ3VtZW50c1xuIik7CisKKwlyZXQgPSBwYXJzZV9uYW1lKCZuYW1lLCB0b2tlblswXSk7CisJaWYgKHJldCA9PSAtRU5PTUVNKQorCQlwYXJzZV9lcnIoIm91dCBvZiBtZW1vcnlcbiIpOworCWlmIChyZXQgPT0gLUVOT1NQQykKKwkJcGFyc2VfZXJyKCJuYW1lIHRvbyBsb25nXG4iKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gMDsKKworCXJldCA9IHBhcnNlX251bTMyKCZzdGFydCwgdG9rZW5bMV0pOworCWlmIChyZXQpCisJCXBhcnNlX2VycigiaWxsZWdhbCBzdGFydCBhZGRyZXNzXG4iKTsKKworCXJldCA9IHBhcnNlX251bTMyKCZsZW4sIHRva2VuWzJdKTsKKwlpZiAocmV0KQorCQlwYXJzZV9lcnIoImlsbGVnYWwgZGV2aWNlIGxlbmd0aFxuIik7CisKKwlyZWdpc3Rlcl9kZXZpY2UobmFtZSwgc3RhcnQsIGxlbik7CisKKwlyZXR1cm4gMDsKK30KKworbW9kdWxlX3BhcmFtX2NhbGwocGhyYW0sIHBocmFtX3NldHVwLCBOVUxMLCBOVUxMLCAwMDApOworTU9EVUxFX1BBUk1fREVTQyhwaHJhbSwiTWVtb3J5IHJlZ2lvbiB0byBtYXAuIFwibWFwPTxuYW1lPiw8c3RhcnQ+LDxsZW5ndGg+XCIiKTsKKworCitzdGF0aWMgaW50IF9faW5pdCBpbml0X3BocmFtKHZvaWQpCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBjbGVhbnVwX3BocmFtKHZvaWQpCit7CisJdW5yZWdpc3Rlcl9kZXZpY2VzKCk7Cit9CisKK21vZHVsZV9pbml0KGluaXRfcGhyYW0pOworbW9kdWxlX2V4aXQoY2xlYW51cF9waHJhbSk7CisKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BVVRIT1IoIkr2cm4gRW5nZWwgPGpvZXJuQHdoLmZoLXdlZGVsLmRlPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJNVEQgZHJpdmVyIGZvciBwaHlzaWNhbCBSQU0iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvcG1jNTUxLmMgYi9kcml2ZXJzL210ZC9kZXZpY2VzL3BtYzU1MS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjViM2RlZmEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL3BtYzU1MS5jCkBAIC0wLDAgKzEsODQzIEBACisvKgorICogJElkOiBwbWM1NTEuYyx2IDEuMzAgMjAwNS8wMS8wNSAxODowNToxMyBkd213MiBFeHAgJAorICoKKyAqIFBNQzU1MSBQQ0kgTWV6emFuaW5lIFJhbSBEZXZpY2UKKyAqCisgKiBBdXRob3I6CisgKiAgICAgICBNYXJrIEZlcnJlbGwgPG1mZXJyZWxsQG12aXN0YS5jb20+CisgKiAgICAgICBDb3B5cmlnaHQgMTk5OSwyMDAwIE5vcnRlbCBOZXR3b3JrcworICoKKyAqIExpY2Vuc2U6CisgKgkgQXMgcGFydCBvZiB0aGlzIGRyaXZlciB3YXMgZGVyaXZlZCBmcm9tIHRoZSBzbHJhbS5jIGRyaXZlciBpdAorICoJIGZhbGxzIHVuZGVyIHRoZSBzYW1lIGxpY2Vuc2UsIHdoaWNoIGlzIEdOVSBHZW5lcmFsIFB1YmxpYworICoJIExpY2Vuc2UgdjIKKyAqCisgKiBEZXNjcmlwdGlvbjoKKyAqCSBUaGlzIGRyaXZlciBpcyBpbnRlbmRlZCB0byBzdXBwb3J0IHRoZSBQTUM1NTEgUENJIFJhbSBkZXZpY2UKKyAqCSBmcm9tIFJhbWl4IEluYy4gIFRoZSBQTUM1NTEgaXMgYSBQTUMgTWV6emFuaW5lIG1vZHVsZSBmb3IKKyAqCSBjUENJIGVtYmVkZGVkIHN5c3RlbXMuICBUaGUgZGV2aWNlIGNvbnRhaW5zIGEgc2luZ2xlIFNST00KKyAqCSB0aGF0IGluaXRpYWxseSBwcm9ncmFtcyB0aGUgVjM3MFBEQyBjaGlwc2V0IG9uYm9hcmQgdGhlCisgKgkgZGV2aWNlLCBhbmQgdmFyaW91cyBiYW5rcyBvZiBEUkFNL1NEUkFNIG9uYm9hcmQuICBUaGlzIGRyaXZlcgorICoJIGltcGxlbWVudHMgdGhpcyBQQ0kgUmFtIGRldmljZSBhcyBhbiBNVEQgKE1lbW9yeSBUZWNobm9sb2d5CisgKgkgRGV2aWNlKSBzbyB0aGF0IGl0IGNhbiBiZSB1c2VkIHRvIGhvbGQgYSBmaWxlIHN5c3RlbSwgb3IgZm9yCisgKgkgYWRkZWQgc3dhcCBzcGFjZSBpbiBlbWJlZGRlZCBzeXN0ZW1zLiAgU2luY2UgdGhlIG1lbW9yeSBvbgorICoJIHRoaXMgYm9hcmQgaXNuJ3QgYXMgZmFzdCBhcyBtYWluIG1lbW9yeSB3ZSBkbyBub3QgdHJ5IHRvIGhvb2sKKyAqCSBpdCBpbnRvIG1haW4gbWVtb3J5IGFzIHRoYXQgd291bGQgc2ltcGx5IHJlZHVjZSBwZXJmb3JtYW5jZQorICoJIG9uIHRoZSBzeXN0ZW0uICBVc2luZyBpdCBhcyBhIGJsb2NrIGRldmljZSBhbGxvd3MgdXMgdG8gdXNlCisgKgkgaXQgYXMgaGlnaCBzcGVlZCBzd2FwIG9yIGZvciBhIGhpZ2ggc3BlZWQgZGlzayBkZXZpY2Ugb2Ygc29tZQorICoJIHNvcnQuICBXaGljaCBiZWNvbWVzIHZlcnkgdXNlZnVsIG9uIGRpc2tsZXNzIHN5c3RlbXMgaW4gdGhlCisgKgkgZW1iZWRkZWQgbWFya2V0IEkgbWlnaHQgYWRkLgorICoJIAorICogTm90ZXM6CisgKgkgRHVlIHRvIHdoYXQgSSBhc3N1bWUgaXMgbW9yZSBidWdneSBTUk9NLCB0aGUgNjRNIFBNQzU1MSBJCisgKgkgaGF2ZSBhdmFpbGFibGUgY2xhaW1zIHRoYXQgYWxsIDQgb2YgaXQncyBEUkFNIGJhbmtzIGhhdmUgNjRNCisgKgkgb2YgcmFtIGNvbmZpZ3VyZWQgKG1ha2luZyBhIGdyYW5kIHRvdGFsIG9mIDI1Nk0gb25ib2FyZCkuCisgKgkgVGhpcyBpcyBzbGlnaHRseSBhbm5veWluZyBzaW5jZSB0aGUgQkFSMCBzaXplIHJlZmxlY3RzIHRoZQorICoJIGFwZXJ0dXJlIHNpemUsIG5vdCB0aGUgZHJhbSBzaXplLCBhbmQgdGhlIFYzNzBQREMgc3VwcGxpZXMgbm8KKyAqCSBvdGhlciBtZXRob2QgZm9yIG1lbW9yeSBzaXplIGRpc2NvdmVyeS4gIFRoaXMgcHJvYmxlbSBpcworICoJIG1vc3RseSBvbmx5IHJlbGV2YW50IHdoZW4gY29tcGlsZWQgYXMgYSBtb2R1bGUsIGFzIHRoZQorICoJIHVubG9hZGluZyBvZiB0aGUgbW9kdWxlIHdpdGggYW4gYXBlcnR1cmUgc2l6ZSBzbWFsbGVyIHRoZW4KKyAqCSB0aGUgcmFtIHdpbGwgY2F1c2UgdGhlIGRyaXZlciB0byBkZXRlY3QgdGhlIG9uYm9hcmQgbWVtb3J5CisgKgkgc2l6ZSB0byBiZSBlcXVhbCB0byB0aGUgYXBlcnR1cmUgc2l6ZSB3aGVuIHRoZSBtb2R1bGUgaXMKKyAqCSByZWxvYWRlZC4gIFNvb29vLCB0byBoZWxwLCB0aGUgbW9kdWxlIHN1cHBvcnRzIGFuIG1zaXplCisgKgkgb3B0aW9uIHRvIGFsbG93IHRoZSBzcGVjaWZpY2F0aW9uIG9mIHRoZSBvbmJvYXJkIG1lbW9yeSwgYW5kCisgKgkgYW4gYXNpemUgb3B0aW9uLCB0byBhbGxvdyB0aGUgc3BlY2lmaWNhdGlvbiBvZiB0aGUgYXBlcnR1cmUKKyAqCSBzaXplLiAgVGhlIGFwZXJ0dXJlIG11c3QgYmUgZXF1YWwgdG8gb3IgbGVzcyB0aGVuIHRoZSBtZW1vcnkKKyAqCSBzaXplLCB0aGUgZHJpdmVyIHdpbGwgY29ycmVjdCB0aGlzIGlmIHlvdSBzY3JldyBpdCB1cC4gIFRoaXMKKyAqCSBwcm9ibGVtIGlzIG5vdCByZWxldmFudCBmb3IgY29tcGlsZWQgaW4gZHJpdmVycyBhcyBjb21waWxlZAorICoJIGluIGRyaXZlcnMgb25seSBpbml0IG9uY2UuCisgKgorICogQ3JlZGl0czoKKyAqICAgICAgIFNhZWVkIEthcmFtb296IDxzYWVlZEByYW1peC5jb20+IG9mIFJhbWl4IElOQy4gZm9yIHRoZQorICogICAgICAgaW5pdGlhbCBleGFtcGxlIGNvZGUgb2YgaG93IHRvIGluaXRpYWxpemUgdGhpcyBkZXZpY2UgYW5kIGZvcgorICogICAgICAgaGVscCB3aXRoIHF1ZXN0aW9ucyBJIGhhZCBjb25jZXJuaW5nIG9wZXJhdGlvbiBvZiB0aGUgZGV2aWNlLgorICoKKyAqICAgICAgIE1vc3Qgb2YgdGhlIE1URCBjb2RlIGZvciB0aGlzIGRyaXZlciB3YXMgb3JpZ2luYWxseSB3cml0dGVuCisgKiAgICAgICBmb3IgdGhlIHNscmFtLm8gbW9kdWxlIGluIHRoZSBNVEQgZHJpdmVycyBwYWNrYWdlIHdoaWNoCisgKiAgICAgICBhbGxvd3MgdGhlIG1hcHBpbmcgb2Ygc3lzdGVtIG1lbW9yeSBpbnRvIGFuIE1URCBkZXZpY2UuCisgKiAgICAgICBTaW5jZSB0aGUgUE1DNTUxIG1lbW9yeSBtb2R1bGUgaXMgYWNjZXNzZWQgaW4gdGhlIHNhbWUKKyAqICAgICAgIGZhc2hpb24gYXMgc3lzdGVtIG1lbW9yeSwgdGhlIHNscmFtLmMgY29kZSBiZWNhbWUgYSB2ZXJ5IG5pY2UKKyAqICAgICAgIGZpdCB0byB0aGUgbmVlZHMgb2YgdGhpcyBkcml2ZXIuICBBbGwgd2UgYWRkZWQgd2FzIFBDSQorICogICAgICAgZGV0ZWN0aW9uL2luaXRpYWxpemF0aW9uIHRvIHRoZSBkcml2ZXIgYW5kIGF1dG9tYXRpY2FsbHkgZmlndXJlCisgKiAgICAgICBvdXQgdGhlIHNpemUgdmlhIHRoZSBQQ0kgZGV0ZWN0aW9uLm8sIGxhdGVyIGNoYW5nZXMgYnkgQ29yZXkKKyAqICAgICAgIE1pbnlhcmQgc2V0IHVwIHRoZSBjYXJkIHRvIHV0aWxpemUgYSAxTSBzbGlkaW5nIGFwYXR1cmUuCisgKgorICoJIENvcmV5IE1pbnlhcmQgPG1pbnlhcmRAbm9ydGVsbmV0d29ya3MuY29tPgorICogICAgICAgKiBNb2RpZmllZCBkcml2ZXIgdG8gdXRpbGl6ZSBhIHNsaWRpbmcgYXBlcnR1cmUgaW5zdGVhZCBvZiAKKyAqICAgICAgICAgbWFwcGluZyBhbGwgbWVtb3J5IGludG8ga2VybmVsIHNwYWNlIHdoaWNoIHR1cm5lZCBvdXQgdG8KKyAqICAgICAgICAgYmUgdmVyeSB3YXN0ZWZ1bC4KKyAqICAgICAgICogTG9jYXRlZCBhIGJ1ZyBpbiB0aGUgU1JPTSdzIGluaXRpYWxpemF0aW9uIHNlcXVlbmNlIHRoYXQgCisgKiAgICAgICAgIG1hZGUgdGhlIG1lbW9yeSB1bnVzYWJsZSwgYWRkZWQgYSBmaXggdG8gY29kZSB0byB0b3VjaCB1cAorICogICAgICAgICB0aGUgRFJBTSBzb21lLgorICoKKyAqIEJ1Z3MvRklYTUUnczoKKyAqICAgICAgICogTVVTVCBmaXggdGhlIGluaXQgZnVuY3Rpb24gdG8gbm90IHNwaW4gb24gYSByZWdpc3RlcgorICogICAgICAgd2FpdGluZyBmb3IgaXQgdG8gc2V0IC4uIHRoaXMgZG9lcyBub3Qgc2FmZWx5IGhhbmRsZSBidXN0ZWQKKyAqICAgICAgIGRldmljZXMgdGhhdCBuZXZlciByZXNldCB0aGUgcmVnaXN0ZXIgY29ycmVjdGx5IHdoaWNoIHdpbGwKKyAqICAgICAgIGNhdXNlIHRoZSBzeXN0ZW0gdG8gaGFuZyB3LyBhIHJlYm9vdCBiZWluZyB0aGUgb25seSBjaGFuY2UgYXQKKyAqICAgICAgIHJlY292ZXIuIFtzb3J0IG9mIGZpeGVkLCBjb3VsZCBiZSBiZXR0ZXJdCisgKiAgICAgICAqIEFkZCBJMkMgaGFuZGxpbmcgb2YgdGhlIFNST00gc28gd2UgY2FuIHJlYWQgdGhlIFNST00ncyBpbmZvcm1hdGlvbgorICogICAgICAgYWJvdXQgdGhlIGFwZXJ0dXJlIHNpemUuICBUaGlzIHNob3VsZCBhbHdheXMgYWNjdXJhdGVseSByZWZsZWN0IHRoZQorICogICAgICAgb25ib2FyZCBtZW1vcnkgc2l6ZS4KKyAqICAgICAgICogQ29tYiB0aGUgaW5pdCByb3V0aW5lLiAgSXQncyBzdGlsbCBhIGJpdCBjbHVkZ3kgb24gYSBmZXcgdGhpbmdzLgorICovCisKKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+CisjaW5jbHVkZSA8bGludXgvY29uZmlnLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L21ham9yLmg+CisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9pb2N0bC5oPgorI2luY2x1ZGUgPGFzbS9pby5oPgorI2luY2x1ZGUgPGFzbS9zeXN0ZW0uaD4KKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKworI2lmbmRlZiBDT05GSUdfUENJCisjZXJyb3IgRW5hYmxlIFBDSSBpbiB5b3VyIGtlcm5lbCBjb25maWcKKyNlbmRpZgorCisjaW5jbHVkZSA8bGludXgvbXRkL210ZC5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9wbWM1NTEuaD4KKyNpbmNsdWRlIDxsaW51eC9tdGQvY29tcGF0bWFjLmg+CisKK3N0YXRpYyBzdHJ1Y3QgbXRkX2luZm8gKnBtYzU1MWxpc3Q7CisKK3N0YXRpYyBpbnQgcG1jNTUxX2VyYXNlIChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgc3RydWN0IGVyYXNlX2luZm8gKmluc3RyKQoreworICAgICAgICBzdHJ1Y3QgbXlwcml2ICpwcml2ID0gbXRkLT5wcml2OworICAgICAgICB1MzIgc29mZl9oaSwgc29mZl9sbzsgLyogc3RhcnQgYWRkcmVzcyBvZmZzZXQgaGkvbG8gKi8KKyAgICAgICAgdTMyIGVvZmZfaGksIGVvZmZfbG87IC8qIGVuZCBhZGRyZXNzIG9mZnNldCBoaS9sbyAqLworICAgICAgICB1bnNpZ25lZCBsb25nIGVuZDsKKwl1X2NoYXIgKnB0cjsKKwlzaXplX3QgcmV0bGVuOworCisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwlwcmludGsoS0VSTl9ERUJVRyAicG1jNTUxX2VyYXNlKHBvczolbGQsIGxlbjolbGQpXG4iLCAobG9uZylpbnN0ci0+YWRkciwgKGxvbmcpaW5zdHItPmxlbik7CisjZW5kaWYKKworICAgICAgICBlbmQgPSBpbnN0ci0+YWRkciArIGluc3RyLT5sZW4gLSAxOworCisgICAgICAgIC8qIElzIGl0IHBhc3QgdGhlIGVuZD8gKi8KKyAgICAgICAgaWYgKCBlbmQgPiBtdGQtPnNpemUgKSB7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwlwcmludGsoS0VSTl9ERUJVRyAicG1jNTUxX2VyYXNlKCkgb3V0IG9mIGJvdW5kcyAoJWxkID4gJWxkKVxuIiwgKGxvbmcpZW5kLCAobG9uZyltdGQtPnNpemUpOworI2VuZGlmCisgICAgICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7CisgICAgICAgIH0KKworICAgICAgICBlb2ZmX2hpID0gZW5kICYgfihwcml2LT5hc2l6ZSAtIDEpOworICAgICAgICBzb2ZmX2hpID0gaW5zdHItPmFkZHIgJiB+KHByaXYtPmFzaXplIC0gMSk7CisgICAgICAgIGVvZmZfbG8gPSBlbmQgJiAocHJpdi0+YXNpemUgLSAxKTsKKyAgICAgICAgc29mZl9sbyA9IGluc3RyLT5hZGRyICYgKHByaXYtPmFzaXplIC0gMSk7CisKKwlwbWM1NTFfcG9pbnQgKG10ZCwgaW5zdHItPmFkZHIsIGluc3RyLT5sZW4sICZyZXRsZW4sICZwdHIpOworCisgICAgICAgIGlmICggc29mZl9oaSA9PSBlb2ZmX2hpIHx8IG10ZC0+c2l6ZSA9PSBwcml2LT5hc2l6ZSkgeworICAgICAgICAgICAgICAgIC8qIFRoZSB3aG9sZSB0aGluZyBmaXRzIHdpdGhpbiBvbmUgYWNjZXNzLCBzbyBqdXN0IG9uZSBzaG90CisgICAgICAgICAgICAgICAgICAgd2lsbCBkbyBpdC4gKi8KKyAgICAgICAgICAgICAgICBtZW1zZXQocHRyLCAweGZmLCBpbnN0ci0+bGVuKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvKiBXZSBoYXZlIHRvIGRvIG11bHRpcGxlIHdyaXRlcyB0byBnZXQgYWxsIHRoZSBkYXRhCisgICAgICAgICAgICAgICAgICAgd3JpdHRlbi4gKi8KKyAgICAgICAgICAgICAgICB3aGlsZSAoc29mZl9oaSAhPSBlb2ZmX2hpKSB7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwkJCXByaW50ayggS0VSTl9ERUJVRyAicG1jNTUxX2VyYXNlKCkgc29mZl9oaTogJWxkLCBlb2ZmX2hpOiAlbGRcbiIsIChsb25nKXNvZmZfaGksIChsb25nKWVvZmZfaGkpOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgICAgICBtZW1zZXQocHRyLCAweGZmLCBwcml2LT5hc2l6ZSk7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoc29mZl9oaSArIHByaXYtPmFzaXplID49IG10ZC0+c2l6ZSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnb3RvIG91dDsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgICAgIHNvZmZfaGkgKz0gcHJpdi0+YXNpemU7CisJCQlwbWM1NTFfcG9pbnQgKG10ZCwocHJpdi0+YmFzZV9tYXAwfHNvZmZfaGkpLAorCQkJCSAgICAgIHByaXYtPmFzaXplLCAmcmV0bGVuLCAmcHRyKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgbWVtc2V0IChwdHIsIDB4ZmYsIGVvZmZfbG8pOworICAgICAgICB9CisKK291dDoKKwlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRE9ORTsKKyNpZmRlZiBDT05GSUdfTVREX1BNQzU1MV9ERUJVRworCXByaW50ayhLRVJOX0RFQlVHICJwbWM1NTFfZXJhc2UoKSBkb25lXG4iKTsKKyNlbmRpZgorCisgICAgICAgIG10ZF9lcmFzZV9jYWxsYmFjayhpbnN0cik7CisgICAgICAgIHJldHVybiAwOworfQorCisKK3N0YXRpYyBpbnQgcG1jNTUxX3BvaW50IChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sIHNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKiptdGRidWYpCit7CisgICAgICAgIHN0cnVjdCBteXByaXYgKnByaXYgPSBtdGQtPnByaXY7CisgICAgICAgIHUzMiBzb2ZmX2hpOworICAgICAgICB1MzIgc29mZl9sbzsKKworI2lmZGVmIENPTkZJR19NVERfUE1DNTUxX0RFQlVHCisJcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MV9wb2ludCglbGQsICVsZClcbiIsIChsb25nKWZyb20sIChsb25nKWxlbik7CisjZW5kaWYKKworCWlmIChmcm9tICsgbGVuID4gbXRkLT5zaXplKSB7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwkJcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MV9wb2ludCgpIG91dCBvZiBib3VuZHMgKCVsZCA+ICVsZClcbiIsIChsb25nKWZyb20rbGVuLCAobG9uZyltdGQtPnNpemUpOworI2VuZGlmCisJCXJldHVybiAtRUlOVkFMOworCX0KKworICAgICAgICBzb2ZmX2hpID0gZnJvbSAmIH4ocHJpdi0+YXNpemUgLSAxKTsKKyAgICAgICAgc29mZl9sbyA9IGZyb20gJiAocHJpdi0+YXNpemUgLSAxKTsKKworCS8qIENoZWFwIGhhY2sgb3B0aW1pemF0aW9uICovCisJaWYoIHByaXYtPmN1cnJfbWFwMCAhPSBmcm9tICkgeworICAgICAgICAJcGNpX3dyaXRlX2NvbmZpZ19kd29yZCAoIHByaXYtPmRldiwgUE1DNTUxX1BDSV9NRU1fTUFQMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAkocHJpdi0+YmFzZV9tYXAwIHwgc29mZl9oaSkgKTsKKwkJcHJpdi0+Y3Vycl9tYXAwID0gc29mZl9oaTsKKwl9CisKKwkqbXRkYnVmID0gcHJpdi0+c3RhcnQgKyBzb2ZmX2xvOworCSpyZXRsZW4gPSBsZW47CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQgcG1jNTUxX3VucG9pbnQgKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB1X2NoYXIgKmFkZHIsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuKQoreworI2lmZGVmIENPTkZJR19NVERfUE1DNTUxX0RFQlVHCisJcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MV91bnBvaW50KClcbiIpOworI2VuZGlmCit9CisKKworc3RhdGljIGludCBwbWM1NTFfcmVhZCAoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLCBzaXplX3QgKnJldGxlbiwgdV9jaGFyICpidWYpCit7CisgICAgICAgIHN0cnVjdCBteXByaXYgKnByaXYgPSBtdGQtPnByaXY7CisgICAgICAgIHUzMiBzb2ZmX2hpLCBzb2ZmX2xvOyAvKiBzdGFydCBhZGRyZXNzIG9mZnNldCBoaS9sbyAqLworICAgICAgICB1MzIgZW9mZl9oaSwgZW9mZl9sbzsgLyogZW5kIGFkZHJlc3Mgb2Zmc2V0IGhpL2xvICovCisgICAgICAgIHVuc2lnbmVkIGxvbmcgZW5kOworCXVfY2hhciAqcHRyOworICAgICAgICB1X2NoYXIgKmNvcHl0byA9IGJ1ZjsKKworI2lmZGVmIENPTkZJR19NVERfUE1DNTUxX0RFQlVHCisJcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MV9yZWFkKHBvczolbGQsIGxlbjolbGQpIGFzaXplOiAlbGRcbiIsIChsb25nKWZyb20sIChsb25nKWxlbiwgKGxvbmcpcHJpdi0+YXNpemUpOworI2VuZGlmCisKKyAgICAgICAgZW5kID0gZnJvbSArIGxlbiAtIDE7CisKKyAgICAgICAgLyogSXMgaXQgcGFzdCB0aGUgZW5kPyAqLworICAgICAgICBpZiAoZW5kID4gbXRkLT5zaXplKSB7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwlwcmludGsoS0VSTl9ERUJVRyAicG1jNTUxX3JlYWQoKSBvdXQgb2YgYm91bmRzICglbGQgPiAlbGQpXG4iLCAobG9uZykgZW5kLCAobG9uZyltdGQtPnNpemUpOworI2VuZGlmCisgICAgICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7CisgICAgICAgIH0KKworICAgICAgICBzb2ZmX2hpID0gZnJvbSAmIH4ocHJpdi0+YXNpemUgLSAxKTsKKyAgICAgICAgZW9mZl9oaSA9IGVuZCAmIH4ocHJpdi0+YXNpemUgLSAxKTsKKyAgICAgICAgc29mZl9sbyA9IGZyb20gJiAocHJpdi0+YXNpemUgLSAxKTsKKyAgICAgICAgZW9mZl9sbyA9IGVuZCAmIChwcml2LT5hc2l6ZSAtIDEpOworCisJcG1jNTUxX3BvaW50IChtdGQsIGZyb20sIGxlbiwgcmV0bGVuLCAmcHRyKTsKKworICAgICAgICBpZiAoc29mZl9oaSA9PSBlb2ZmX2hpKSB7CisgICAgICAgICAgICAgICAgLyogVGhlIHdob2xlIHRoaW5nIGZpdHMgd2l0aGluIG9uZSBhY2Nlc3MsIHNvIGp1c3Qgb25lIHNob3QKKyAgICAgICAgICAgICAgICAgICB3aWxsIGRvIGl0LiAqLworICAgICAgICAgICAgICAgIG1lbWNweShjb3B5dG8sIHB0ciwgbGVuKTsKKyAgICAgICAgICAgICAgICBjb3B5dG8gKz0gbGVuOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIC8qIFdlIGhhdmUgdG8gZG8gbXVsdGlwbGUgd3JpdGVzIHRvIGdldCBhbGwgdGhlIGRhdGEKKyAgICAgICAgICAgICAgICAgICB3cml0dGVuLiAqLworICAgICAgICAgICAgICAgIHdoaWxlIChzb2ZmX2hpICE9IGVvZmZfaGkpIHsKKyNpZmRlZiBDT05GSUdfTVREX1BNQzU1MV9ERUJVRworCQkJcHJpbnRrKCBLRVJOX0RFQlVHICJwbWM1NTFfcmVhZCgpIHNvZmZfaGk6ICVsZCwgZW9mZl9oaTogJWxkXG4iLCAobG9uZylzb2ZmX2hpLCAobG9uZyllb2ZmX2hpKTsKKyNlbmRpZgorICAgICAgICAgICAgICAgICAgICAgICAgbWVtY3B5KGNvcHl0bywgcHRyLCBwcml2LT5hc2l6ZSk7CisgICAgICAgICAgICAgICAgICAgICAgICBjb3B5dG8gKz0gcHJpdi0+YXNpemU7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoc29mZl9oaSArIHByaXYtPmFzaXplID49IG10ZC0+c2l6ZSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnb3RvIG91dDsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgICAgIHNvZmZfaGkgKz0gcHJpdi0+YXNpemU7CisJCQlwbWM1NTFfcG9pbnQgKG10ZCwgc29mZl9oaSwgcHJpdi0+YXNpemUsIHJldGxlbiwgJnB0cik7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIG1lbWNweShjb3B5dG8sIHB0ciwgZW9mZl9sbyk7CisgICAgICAgICAgICAgICAgY29weXRvICs9IGVvZmZfbG87CisgICAgICAgIH0KKworb3V0OgorI2lmZGVmIENPTkZJR19NVERfUE1DNTUxX0RFQlVHCisJcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MV9yZWFkKCkgZG9uZVxuIik7CisjZW5kaWYKKyAgICAgICAgKnJldGxlbiA9IGNvcHl0byAtIGJ1ZjsKKyAgICAgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcG1jNTUxX3dyaXRlIChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IHRvLCBzaXplX3QgbGVuLCBzaXplX3QgKnJldGxlbiwgY29uc3QgdV9jaGFyICpidWYpCit7CisgICAgICAgIHN0cnVjdCBteXByaXYgKnByaXYgPSBtdGQtPnByaXY7CisgICAgICAgIHUzMiBzb2ZmX2hpLCBzb2ZmX2xvOyAvKiBzdGFydCBhZGRyZXNzIG9mZnNldCBoaS9sbyAqLworICAgICAgICB1MzIgZW9mZl9oaSwgZW9mZl9sbzsgLyogZW5kIGFkZHJlc3Mgb2Zmc2V0IGhpL2xvICovCisgICAgICAgIHVuc2lnbmVkIGxvbmcgZW5kOworCXVfY2hhciAqcHRyOworICAgICAgICBjb25zdCB1X2NoYXIgKmNvcHlmcm9tID0gYnVmOworCisKKyNpZmRlZiBDT05GSUdfTVREX1BNQzU1MV9ERUJVRworCXByaW50ayhLRVJOX0RFQlVHICJwbWM1NTFfd3JpdGUocG9zOiVsZCwgbGVuOiVsZCkgYXNpemU6JWxkXG4iLCAobG9uZyl0bywgKGxvbmcpbGVuLCAobG9uZylwcml2LT5hc2l6ZSk7CisjZW5kaWYKKworICAgICAgICBlbmQgPSB0byArIGxlbiAtIDE7CisgICAgICAgIC8qIElzIGl0IHBhc3QgdGhlIGVuZD8gIG9yIGRpZCB0aGUgdTMyIHdyYXA/ICovCisgICAgICAgIGlmIChlbmQgPiBtdGQtPnNpemUgKSB7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwlwcmludGsoS0VSTl9ERUJVRyAicG1jNTUxX3dyaXRlKCkgb3V0IG9mIGJvdW5kcyAoZW5kOiAlbGQsIHNpemU6ICVsZCwgdG86ICVsZClcbiIsIChsb25nKSBlbmQsIChsb25nKW10ZC0+c2l6ZSwgKGxvbmcpdG8pOworI2VuZGlmCisgICAgICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7CisgICAgICAgIH0KKworICAgICAgICBzb2ZmX2hpID0gdG8gJiB+KHByaXYtPmFzaXplIC0gMSk7CisgICAgICAgIGVvZmZfaGkgPSBlbmQgJiB+KHByaXYtPmFzaXplIC0gMSk7CisgICAgICAgIHNvZmZfbG8gPSB0byAmIChwcml2LT5hc2l6ZSAtIDEpOworICAgICAgICBlb2ZmX2xvID0gZW5kICYgKHByaXYtPmFzaXplIC0gMSk7CisKKwlwbWM1NTFfcG9pbnQgKG10ZCwgdG8sIGxlbiwgcmV0bGVuLCAmcHRyKTsKKworICAgICAgICBpZiAoc29mZl9oaSA9PSBlb2ZmX2hpKSB7CisgICAgICAgICAgICAgICAgLyogVGhlIHdob2xlIHRoaW5nIGZpdHMgd2l0aGluIG9uZSBhY2Nlc3MsIHNvIGp1c3Qgb25lIHNob3QKKyAgICAgICAgICAgICAgICAgICB3aWxsIGRvIGl0LiAqLworICAgICAgICAgICAgICAgIG1lbWNweShwdHIsIGNvcHlmcm9tLCBsZW4pOworICAgICAgICAgICAgICAgIGNvcHlmcm9tICs9IGxlbjsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvKiBXZSBoYXZlIHRvIGRvIG11bHRpcGxlIHdyaXRlcyB0byBnZXQgYWxsIHRoZSBkYXRhCisgICAgICAgICAgICAgICAgICAgd3JpdHRlbi4gKi8KKyAgICAgICAgICAgICAgICB3aGlsZSAoc29mZl9oaSAhPSBlb2ZmX2hpKSB7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfREVCVUcKKwkJCXByaW50ayggS0VSTl9ERUJVRyAicG1jNTUxX3dyaXRlKCkgc29mZl9oaTogJWxkLCBlb2ZmX2hpOiAlbGRcbiIsIChsb25nKXNvZmZfaGksIChsb25nKWVvZmZfaGkpOworI2VuZGlmCisgICAgICAgICAgICAgICAgCW1lbWNweShwdHIsIGNvcHlmcm9tLCBwcml2LT5hc2l6ZSk7CisgICAgICAgICAgICAgICAgCWNvcHlmcm9tICs9IHByaXYtPmFzaXplOworICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHNvZmZfaGkgPj0gbXRkLT5zaXplKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdvdG8gb3V0OworICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgc29mZl9oaSArPSBwcml2LT5hc2l6ZTsKKwkJCXBtYzU1MV9wb2ludCAobXRkLCBzb2ZmX2hpLCBwcml2LT5hc2l6ZSwgcmV0bGVuLCAmcHRyKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgbWVtY3B5KHB0ciwgY29weWZyb20sIGVvZmZfbG8pOworICAgICAgICAgICAgICAgIGNvcHlmcm9tICs9IGVvZmZfbG87CisgICAgICAgIH0KKworb3V0OgorI2lmZGVmIENPTkZJR19NVERfUE1DNTUxX0RFQlVHCisJcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MV93cml0ZSgpIGRvbmVcbiIpOworI2VuZGlmCisgICAgICAgICpyZXRsZW4gPSBjb3B5ZnJvbSAtIGJ1ZjsKKyAgICAgICAgcmV0dXJuIDA7Cit9CisKKy8qCisgKiBGaXh1cCByb3V0aW5lcyBmb3IgdGhlIFYzNzBQREMKKyAqIFBDSSBkZXZpY2UgSUQgMHgwMjAwMTFiMAorICoKKyAqIFRoaXMgZnVuY3Rpb24gYmFzaWNseSBraWNrIHN0YXJ0cyB0aGUgRFJBTSBvYm9hcmQgdGhlIGNhcmQgYW5kIGdldHMgaXQKKyAqIHJlYWR5IHRvIGJlIHVzZWQuICBCZWZvcmUgdGhpcyBpcyBkb25lIHRoZSBkZXZpY2UgcmVhZHMgVkVSWSBlcnJhdGljLCBzbworICogbXVjaCB0aGF0IGl0IGNhbiBjcmFzaCB0aGUgTGludXggMi4yLnggc2VyaWVzIGtlcm5lbHMgd2hlbiBhIHVzZXIgY2F0J3MKKyAqIC9wcm9jL3BjaSAuLiB0aG91Z2ggdGhhdCBpcyBtYWlubHkgYSBrZXJuZWwgYnVnIGluIGhhbmRsaW5nIHRoZSBQQ0kgREVWU0VMCisgKiByZWdpc3Rlci4gIEZJWE1FOiBzdG9wIHNwaW5uaW5nIG9uIHJlZ2lzdGVycyAuLiBtdXN0IGltcGxlbWVudCBhIHRpbWVvdXQKKyAqIG1lY2hhbmlzbQorICogcmV0dXJucyB0aGUgc2l6ZSBvZiB0aGUgbWVtb3J5IHJlZ2lvbiBmb3VuZC4KKyAqLworc3RhdGljIHUzMiBmaXh1cF9wbWM1NTEgKHN0cnVjdCBwY2lfZGV2ICpkZXYpCit7CisjaWZkZWYgQ09ORklHX01URF9QTUM1NTFfQlVHRklYCisgICAgICAgIHUzMiBkcmFtX2RhdGE7CisjZW5kaWYKKyAgICAgICAgdTMyIHNpemUsIGRjbWQsIGNmZywgZHRtcDsKKyAgICAgICAgdTE2IGNtZCwgdG1wLCBpOworCXU4IGJjbWQsIGNvdW50ZXI7CisKKyAgICAgICAgLyogU2FuaXR5IENoZWNrICovCisgICAgICAgIGlmKCFkZXYpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gLUVOT0RFVjsKKyAgICAgICAgfQorCisJLyoKKwkgKiBBdHRlbXB0IHRvIHJlc2V0IHRoZSBjYXJkCisJICogRklYTUU6IFN0b3AgU3Bpbm5pbmcgcmVnaXN0ZXJzCisJICovCisJY291bnRlcj0wOworCS8qIHVubG9jayByZWdpc3RlcnMgKi8KKwlwY2lfd3JpdGVfY29uZmlnX2J5dGUoZGV2LCBQTUM1NTFfU1lTX0NUUkxfUkVHLCAweEE1ICk7CisJLyogcmVhZCBpbiBvbGQgZGF0YSAqLworCXBjaV9yZWFkX2NvbmZpZ19ieXRlKGRldiwgUE1DNTUxX1NZU19DVFJMX1JFRywgJmJjbWQgKTsKKwkvKiBiYW5nIHRoZSByZXNldCBsaW5lIHVwIGFuZCBkb3duIGZvciBhIGZldyAqLworCWZvcihpPTA7aTwxMDtpKyspIHsKKwkJY291bnRlcj0wOworCQliY21kICY9IH4weDgwOworCQl3aGlsZShjb3VudGVyKysgPCAxMDApIHsKKwkJCXBjaV93cml0ZV9jb25maWdfYnl0ZShkZXYsIFBNQzU1MV9TWVNfQ1RSTF9SRUcsIGJjbWQpOworCQl9CisJCWNvdW50ZXI9MDsKKwkJYmNtZCB8PSAweDgwOworCQl3aGlsZShjb3VudGVyKysgPCAxMDApIHsKKwkJCXBjaV93cml0ZV9jb25maWdfYnl0ZShkZXYsIFBNQzU1MV9TWVNfQ1RSTF9SRUcsIGJjbWQpOworCQl9CisJfQorCWJjbWQgfD0gKDB4NDB8MHgyMCk7CisJcGNpX3dyaXRlX2NvbmZpZ19ieXRlKGRldiwgUE1DNTUxX1NZU19DVFJMX1JFRywgYmNtZCk7CisKKyAgICAgICAgLyogCisJICogVGFrZSBjYXJlIGFuZCB0dXJuIG9mZiB0aGUgbWVtb3J5IG9uIHRoZSBkZXZpY2Ugd2hpbGUgd2UKKwkgKiB0d2VhayB0aGUgY29uZmlndXJhdGlvbnMKKwkgKi8KKyAgICAgICAgcGNpX3JlYWRfY29uZmlnX3dvcmQoZGV2LCBQQ0lfQ09NTUFORCwgJmNtZCk7CisgICAgICAgIHRtcCA9IGNtZCAmIH4oUENJX0NPTU1BTkRfSU98UENJX0NPTU1BTkRfTUVNT1JZKTsKKyAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ193b3JkKGRldiwgUENJX0NPTU1BTkQsIHRtcCk7CisKKwkvKgorCSAqIERpc2FibGUgZXhpc3RpbmcgYXBlcnR1cmUgYmVmb3JlIHByb2JpbmcgbWVtb3J5IHNpemUKKwkgKi8KKwlwY2lfcmVhZF9jb25maWdfZHdvcmQoZGV2LCBQTUM1NTFfUENJX01FTV9NQVAwLCAmZGNtZCk7CisgICAgICAgIGR0bXA9KGRjbWR8UE1DNTUxX1BDSV9NRU1fTUFQX0VOQUJMRXxQTUM1NTFfUENJX01FTV9NQVBfUkVHX0VOKTsKKwlwY2lfd3JpdGVfY29uZmlnX2R3b3JkKGRldiwgUE1DNTUxX1BDSV9NRU1fTUFQMCwgZHRtcCk7CisJLyoKKwkgKiBHcmFiIG9sZCBCQVIwIGNvbmZpZyBzbyB0aGF0IHdlIGNhbiBmaWd1cmUgb3V0IG1lbW9yeSBzaXplCisJICogVGhpcyBpcyBhbm90aGVyIGJpdCBvZiBrbHVkZ2UgZ29pbmcgb24uICBUaGUgcmVhc29uIGZvciB0aGUKKwkgKiByZWR1bmRhbmN5IGlzIEkgYW0gaG9waW5nIHRvIHJldGFpbiB0aGUgb3JpZ2luYWwgY29uZmlndXJhdGlvbgorCSAqIHByZXZpb3VzbHkgYXNzaWduZWQgdG8gdGhlIGNhcmQgYnkgdGhlIEJJT1Mgb3Igc29tZSBwcmV2aW91cyAKKwkgKiBmaXh1cCByb3V0aW5lIGluIHRoZSBrZXJuZWwuICBTbyB3ZSByZWFkIHRoZSBvbGQgY29uZmlnIGludG8gY2ZnLAorCSAqIHRoZW4gd3JpdGUgYWxsIDEncyB0byB0aGUgbWVtb3J5IHNwYWNlLCByZWFkIGJhY2sgdGhlIHJlc3VsdCBpbnRvCisJICogInNpemUiLCBhbmQgdGhlbiB3cml0ZSBiYWNrIGFsbCB0aGUgb2xkIGNvbmZpZy4KKwkgKi8KKwlwY2lfcmVhZF9jb25maWdfZHdvcmQoIGRldiwgUENJX0JBU0VfQUREUkVTU18wLCAmY2ZnICk7CisjaWZuZGVmIENPTkZJR19NVERfUE1DNTUxX0JVR0ZJWAorCXBjaV93cml0ZV9jb25maWdfZHdvcmQoIGRldiwgUENJX0JBU0VfQUREUkVTU18wLCB+MCApOworCXBjaV9yZWFkX2NvbmZpZ19kd29yZCggZGV2LCBQQ0lfQkFTRV9BRERSRVNTXzAsICZzaXplICk7CisJc2l6ZSA9IChzaXplJlBDSV9CQVNFX0FERFJFU1NfTUVNX01BU0spOworCXNpemUgJj0gfihzaXplLTEpOworCXBjaV93cml0ZV9jb25maWdfZHdvcmQoIGRldiwgUENJX0JBU0VfQUREUkVTU18wLCBjZmcgKTsKKyNlbHNlCisgICAgICAgIC8qCisgICAgICAgICAqIEdldCB0aGUgc2l6ZSBvZiB0aGUgbWVtb3J5IGJ5IHJlYWRpbmcgYWxsIHRoZSBEUkFNIHNpemUgdmFsdWVzCisgICAgICAgICAqIGFuZCBhZGRpbmcgdGhlbSB1cC4KKyAgICAgICAgICoKKyAgICAgICAgICogS0xVREdFIEFMRVJUOiB0aGUgYm9hcmRzIHdlIGFyZSB1c2luZyBoYXZlIGludmFsaWQgY29sdW1uIGFuZAorICAgICAgICAgKiByb3cgbXV4IHZhbHVlcy4gIFdlIGZpeCB0aGVtIGhlcmUsIGJ1dCB0aGlzIHdpbGwgYnJlYWsgb3RoZXIKKyAgICAgICAgICogbWVtb3J5IGNvbmZpZ3VyYXRpb25zLgorICAgICAgICAgKi8KKyAgICAgICAgcGNpX3JlYWRfY29uZmlnX2R3b3JkKGRldiwgUE1DNTUxX0RSQU1fQkxLMCwgJmRyYW1fZGF0YSk7CisgICAgICAgIHNpemUgPSBQTUM1NTFfRFJBTV9CTEtfR0VUX1NJWkUoZHJhbV9kYXRhKTsKKyAgICAgICAgZHJhbV9kYXRhID0gUE1DNTUxX0RSQU1fQkxLX1NFVF9DT0xfTVVYKGRyYW1fZGF0YSwgMHg1KTsKKyAgICAgICAgZHJhbV9kYXRhID0gUE1DNTUxX0RSQU1fQkxLX1NFVF9ST1dfTVVYKGRyYW1fZGF0YSwgMHg5KTsKKyAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ19kd29yZChkZXYsIFBNQzU1MV9EUkFNX0JMSzAsIGRyYW1fZGF0YSk7CisKKyAgICAgICAgcGNpX3JlYWRfY29uZmlnX2R3b3JkKGRldiwgUE1DNTUxX0RSQU1fQkxLMSwgJmRyYW1fZGF0YSk7CisgICAgICAgIHNpemUgKz0gUE1DNTUxX0RSQU1fQkxLX0dFVF9TSVpFKGRyYW1fZGF0YSk7CisgICAgICAgIGRyYW1fZGF0YSA9IFBNQzU1MV9EUkFNX0JMS19TRVRfQ09MX01VWChkcmFtX2RhdGEsIDB4NSk7CisgICAgICAgIGRyYW1fZGF0YSA9IFBNQzU1MV9EUkFNX0JMS19TRVRfUk9XX01VWChkcmFtX2RhdGEsIDB4OSk7CisgICAgICAgIHBjaV93cml0ZV9jb25maWdfZHdvcmQoZGV2LCBQTUM1NTFfRFJBTV9CTEsxLCBkcmFtX2RhdGEpOworCisgICAgICAgIHBjaV9yZWFkX2NvbmZpZ19kd29yZChkZXYsIFBNQzU1MV9EUkFNX0JMSzIsICZkcmFtX2RhdGEpOworICAgICAgICBzaXplICs9IFBNQzU1MV9EUkFNX0JMS19HRVRfU0laRShkcmFtX2RhdGEpOworICAgICAgICBkcmFtX2RhdGEgPSBQTUM1NTFfRFJBTV9CTEtfU0VUX0NPTF9NVVgoZHJhbV9kYXRhLCAweDUpOworICAgICAgICBkcmFtX2RhdGEgPSBQTUM1NTFfRFJBTV9CTEtfU0VUX1JPV19NVVgoZHJhbV9kYXRhLCAweDkpOworICAgICAgICBwY2lfd3JpdGVfY29uZmlnX2R3b3JkKGRldiwgUE1DNTUxX0RSQU1fQkxLMiwgZHJhbV9kYXRhKTsKKworICAgICAgICBwY2lfcmVhZF9jb25maWdfZHdvcmQoZGV2LCBQTUM1NTFfRFJBTV9CTEszLCAmZHJhbV9kYXRhKTsKKyAgICAgICAgc2l6ZSArPSBQTUM1NTFfRFJBTV9CTEtfR0VUX1NJWkUoZHJhbV9kYXRhKTsKKyAgICAgICAgZHJhbV9kYXRhID0gUE1DNTUxX0RSQU1fQkxLX1NFVF9DT0xfTVVYKGRyYW1fZGF0YSwgMHg1KTsKKyAgICAgICAgZHJhbV9kYXRhID0gUE1DNTUxX0RSQU1fQkxLX1NFVF9ST1dfTVVYKGRyYW1fZGF0YSwgMHg5KTsKKyAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ19kd29yZChkZXYsIFBNQzU1MV9EUkFNX0JMSzMsIGRyYW1fZGF0YSk7CisKKyAgICAgICAgLyoKKyAgICAgICAgICogT29wcyAuLiBzb21ldGhpbmcgd2VudCB3cm9uZworICAgICAgICAgKi8KKyAgICAgICAgaWYoIChzaXplICY9IFBDSV9CQVNFX0FERFJFU1NfTUVNX01BU0spID09IDApIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gLUVOT0RFVjsKKyAgICAgICAgfQorI2VuZGlmIC8qIENPTkZJR19NVERfUE1DNTUxX0JVR0ZJWCAqLworCisJaWYgKChjZmcmUENJX0JBU0VfQUREUkVTU19TUEFDRSkgIT0gUENJX0JBU0VfQUREUkVTU19TUEFDRV9NRU1PUlkpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gLUVOT0RFVjsKKwl9CisKKyAgICAgICAgLyoKKyAgICAgICAgICogUHJlY2hhcmdlIERyYW0KKyAgICAgICAgICovCisgICAgICAgIHBjaV93cml0ZV9jb25maWdfd29yZCggZGV2LCBQTUM1NTFfU0RSQU1fTUEsIDB4MDQwMCApOworICAgICAgICBwY2lfd3JpdGVfY29uZmlnX3dvcmQoIGRldiwgUE1DNTUxX1NEUkFNX0NNRCwgMHgwMGJmICk7CisKKyAgICAgICAgLyoKKyAgICAgICAgICogV2FpdCB1bnRpbCBjb21tYW5kIGhhcyBnb25lIHRocm91Z2gKKyAgICAgICAgICogRklYTUU6IHJlZ2lzdGVyIHNwaW5uaW5nIGlzc3VlCisgICAgICAgICAqLworICAgICAgICBkbyB7CXBjaV9yZWFkX2NvbmZpZ193b3JkKCBkZXYsIFBNQzU1MV9TRFJBTV9DTUQsICZjbWQgKTsKKwkJaWYoY291bnRlcisrID4gMTAwKWJyZWFrOworICAgICAgICB9IHdoaWxlICggKFBDSV9DT01NQU5EX0lPKSAmIGNtZCApOworCisgICAgICAgIC8qCisJICogVHVybiBvbiBhdXRvIHJlZnJlc2ggCisJICogVGhlIGxvb3AgaXMgdGFrZW4gZGlyZWN0bHkgZnJvbSBSYW1peCdzIGV4YW1wbGUgY29kZS4gIEkgYXNzdW1lIHRoYXQKKwkgKiB0aGlzIG11c3QgYmUgaGVsZCBoaWdoIGZvciBzb21lIGR1cmF0aW9uIG9mIHRpbWUsIGJ1dCBJIGNhbiBmaW5kIG5vCisJICogZG9jdW1lbnRhdGlvbiByZWZyZW5jaW5nIHRoZSByZWFzb25zIHdoeS4KKyAgICAgICAgICovCisgICAgICAgIGZvciAoIGkgPSAxOyBpPD04IDsgaSsrKSB7CisgICAgICAgICAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ193b3JkIChkZXYsIFBNQzU1MV9TRFJBTV9DTUQsIDB4MGRmKTsKKworICAgICAgICAgICAgICAgIC8qCisgICAgICAgICAgICAgICAgICogTWFrZSBjZXJ0YWluIGNvbW1hbmQgaGFzIGdvbmUgdGhyb3VnaAorICAgICAgICAgICAgICAgICAqIEZJWE1FOiByZWdpc3RlciBzcGlubmluZyBpc3N1ZQorICAgICAgICAgICAgICAgICAqLworCQljb3VudGVyPTA7CisgICAgICAgICAgICAgICAgZG8gewlwY2lfcmVhZF9jb25maWdfd29yZChkZXYsIFBNQzU1MV9TRFJBTV9DTUQsICZjbWQpOworCQkJaWYoY291bnRlcisrID4gMTAwKWJyZWFrOworICAgICAgICAgICAgICAgIH0gd2hpbGUgKCAoUENJX0NPTU1BTkRfSU8pICYgY21kICk7CisgICAgICAgIH0KKworICAgICAgICBwY2lfd3JpdGVfY29uZmlnX3dvcmQgKCBkZXYsIFBNQzU1MV9TRFJBTV9NQSwgMHgwMDIwKTsKKyAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ193b3JkICggZGV2LCBQTUM1NTFfU0RSQU1fQ01ELCAweDBmZik7CisKKyAgICAgICAgLyoKKyAgICAgICAgICogV2FpdCB1bnRpbCBjb21tYW5kIGNvbXBsZXRlcworICAgICAgICAgKiBGSVhNRTogcmVnaXN0ZXIgc3Bpbm5pbmcgaXNzdWUKKyAgICAgICAgICovCisJY291bnRlcj0wOworICAgICAgICBkbyB7CXBjaV9yZWFkX2NvbmZpZ193b3JkICggZGV2LCBQTUM1NTFfU0RSQU1fQ01ELCAmY21kKTsKKwkJaWYoY291bnRlcisrID4gMTAwKWJyZWFrOworICAgICAgICB9IHdoaWxlICggKFBDSV9DT01NQU5EX0lPKSAmIGNtZCApOworCisgICAgICAgIHBjaV9yZWFkX2NvbmZpZ19kd29yZCAoIGRldiwgUE1DNTUxX0RSQU1fQ0ZHLCAmZGNtZCk7CisgICAgICAgIGRjbWQgfD0gMHgwMjAwMDAwMDsKKyAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ19kd29yZCAoIGRldiwgUE1DNTUxX0RSQU1fQ0ZHLCBkY21kKTsKKworICAgICAgICAvKgorICAgICAgICAgKiBDaGVjayB0byBtYWtlIGNlcnRhaW4gZmFzdCBiYWNrLXRvLWJhY2ssIGlmIG5vdAorICAgICAgICAgKiB0aGVuIHNldCBpdCBzbworICAgICAgICAgKi8KKyAgICAgICAgcGNpX3JlYWRfY29uZmlnX3dvcmQoIGRldiwgUENJX1NUQVRVUywgJmNtZCk7CisgICAgICAgIGlmKChjbWQmUENJX0NPTU1BTkRfRkFTVF9CQUNLKSA9PSAwKSB7CisgICAgICAgICAgICAgICAgY21kIHw9IFBDSV9DT01NQU5EX0ZBU1RfQkFDSzsKKyAgICAgICAgICAgICAgICBwY2lfd3JpdGVfY29uZmlnX3dvcmQoIGRldiwgUENJX1NUQVRVUywgY21kKTsKKyAgICAgICAgfQorCisgICAgICAgIC8qCisgICAgICAgICAqIENoZWNrIHRvIG1ha2UgY2VydGFpbiB0aGUgREVWU0VMIGlzIHNldCBjb3JyZWN0bHksIHRoaXMgZGV2aWNlCisgICAgICAgICAqIGhhcyBhIHRlbmRhbmN5IHRvIGFzc2VydCBERVZTRUwgYW5kIFRSRFkgd2hlbiBhIHdyaXRlIGlzIHBlcmZvcm1lZAorICAgICAgICAgKiB0byB0aGUgbWVtb3J5IHdoZW4gbWVtb3J5IGlzIHJlYWQtb25seQorICAgICAgICAgKi8KKyAgICAgICAgaWYoKGNtZCZQQ0lfU1RBVFVTX0RFVlNFTF9NQVNLKSAhPSAweDApIHsKKyAgICAgICAgICAgICAgICBjbWQgJj0gflBDSV9TVEFUVVNfREVWU0VMX01BU0s7CisgICAgICAgICAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ193b3JkKCBkZXYsIFBDSV9TVEFUVVMsIGNtZCApOworICAgICAgICB9CisgICAgICAgIC8qCisgICAgICAgICAqIFNldCB0byBiZSBwcmVmZXRjaGFibGUgYW5kIHB1dCBldmVyeXRoaW5nIGJhY2sgYmFzZWQgb24gb2xkIGNmZy4KKwkgKiBpdCdzIHBvc3NpYmxlIHRoYXQgdGhlIHJlc2V0IG9mIHRoZSBWMzcwUERDIG51a2VkIHRoZSBvcmlnaW5hbAorCSAqIHNldHVwCisgICAgICAgICAqLworCS8qCisgICAgICAgIGNmZyB8PSBQQ0lfQkFTRV9BRERSRVNTX01FTV9QUkVGRVRDSDsKKwlwY2lfd3JpdGVfY29uZmlnX2R3b3JkKCBkZXYsIFBDSV9CQVNFX0FERFJFU1NfMCwgY2ZnICk7CisJKi8KKworICAgICAgICAvKgorICAgICAgICAgKiBUdXJuIFBDSSBtZW1vcnkgYW5kIEkvTyBidXMgYWNjZXNzIGJhY2sgb24KKyAgICAgICAgICovCisgICAgICAgIHBjaV93cml0ZV9jb25maWdfd29yZCggZGV2LCBQQ0lfQ09NTUFORCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQQ0lfQ09NTUFORF9NRU1PUlkgfCBQQ0lfQ09NTUFORF9JTyApOworI2lmZGVmIENPTkZJR19NVERfUE1DNTUxX0RFQlVHCisgICAgICAgIC8qCisgICAgICAgICAqIFNvbWUgc2NyZWVuIGZ1bgorICAgICAgICAgKi8KKyAgICAgICAgcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MTogJWQlYyAoMHgleCkgb2YgJXNwcmVmZXRjaGFibGUgbWVtb3J5IGF0IDB4JWx4XG4iLAorCSAgICAgICAoc2l6ZTwxMDI0KT9zaXplOihzaXplPDEwNDg1NzYpP3NpemU+PjEwOnNpemU+PjIwLAorICAgICAgICAgICAgICAgKHNpemU8MTAyNCk/J0InOihzaXplPDEwNDg1NzYpPydLJzonTScsCisJICAgICAgIHNpemUsICgoZGNtZCYoMHgxPDwzKSkgPT0gMCk/Im5vbi0iOiIiLAorICAgICAgICAgICAgICAgKGRldi0+cmVzb3VyY2VbMF0uc3RhcnQpJlBDSV9CQVNFX0FERFJFU1NfTUVNX01BU0sgKTsKKworICAgICAgICAvKgorICAgICAgICAgKiBDaGVjayB0byBzZWUgdGhlIHN0YXRlIG9mIHRoZSBtZW1vcnkKKyAgICAgICAgICovCisgICAgICAgIHBjaV9yZWFkX2NvbmZpZ19kd29yZCggZGV2LCBQTUM1NTFfRFJBTV9CTEswLCAmZGNtZCApOworICAgICAgICBwcmludGsoS0VSTl9ERUJVRyAicG1jNTUxOiBEUkFNX0JMSzAgRmxhZ3M6ICVzLCVzXG4iCisJCQkgICJwbWM1NTE6IERSQU1fQkxLMCBTaXplOiAlZCBhdCAlZFxuIgorCQkJICAicG1jNTUxOiBEUkFNX0JMSzAgUm93IE1VWDogJWQsIENvbCBNVVg6ICVkXG4iLAorICAgICAgICAgICAgICAgKCgoMHgxPDwxKSZkY21kKSA9PSAwKT8iUlciOiJSTyIsCisgICAgICAgICAgICAgICAoKCgweDE8PDApJmRjbWQpID09IDApPyJPZmYiOiJPbiIsCisJICAgICAgIFBNQzU1MV9EUkFNX0JMS19HRVRfU0laRShkY21kKSwKKwkgICAgICAgKChkY21kPj4yMCkmMHg3RkYpLCAoKGRjbWQ+PjEzKSYweDcpLCAoKGRjbWQ+PjkpJjB4RikgKTsKKworICAgICAgICBwY2lfcmVhZF9jb25maWdfZHdvcmQoIGRldiwgUE1DNTUxX0RSQU1fQkxLMSwgJmRjbWQgKTsKKyAgICAgICAgcHJpbnRrKEtFUk5fREVCVUcgInBtYzU1MTogRFJBTV9CTEsxIEZsYWdzOiAlcywlc1xuIgorCQkJICAicG1jNTUxOiBEUkFNX0JMSzEgU2l6ZTogJWQgYXQgJWRcbiIKKwkJCSAgInBtYzU1MTogRFJBTV9CTEsxIFJvdyBNVVg6ICVkLCBDb2wgTVVYOiAlZFxuIiwKKyAgICAgICAgICAgICAgICgoKDB4MTw8MSkmZGNtZCkgPT0gMCk/IlJXIjoiUk8iLAorICAgICAgICAgICAgICAgKCgoMHgxPDwwKSZkY21kKSA9PSAwKT8iT2ZmIjoiT24iLAorCSAgICAgICBQTUM1NTFfRFJBTV9CTEtfR0VUX1NJWkUoZGNtZCksCisJICAgICAgICgoZGNtZD4+MjApJjB4N0ZGKSwgKChkY21kPj4xMykmMHg3KSwgKChkY21kPj45KSYweEYpICk7CisKKyAgICAgICAgcGNpX3JlYWRfY29uZmlnX2R3b3JkKCBkZXYsIFBNQzU1MV9EUkFNX0JMSzIsICZkY21kICk7CisgICAgICAgIHByaW50ayhLRVJOX0RFQlVHICJwbWM1NTE6IERSQU1fQkxLMiBGbGFnczogJXMsJXNcbiIKKwkJCSAgInBtYzU1MTogRFJBTV9CTEsyIFNpemU6ICVkIGF0ICVkXG4iCisJCQkgICJwbWM1NTE6IERSQU1fQkxLMiBSb3cgTVVYOiAlZCwgQ29sIE1VWDogJWRcbiIsCisgICAgICAgICAgICAgICAoKCgweDE8PDEpJmRjbWQpID09IDApPyJSVyI6IlJPIiwKKyAgICAgICAgICAgICAgICgoKDB4MTw8MCkmZGNtZCkgPT0gMCk/Ik9mZiI6Ik9uIiwKKwkgICAgICAgUE1DNTUxX0RSQU1fQkxLX0dFVF9TSVpFKGRjbWQpLAorCSAgICAgICAoKGRjbWQ+PjIwKSYweDdGRiksICgoZGNtZD4+MTMpJjB4NyksICgoZGNtZD4+OSkmMHhGKSApOworCisgICAgICAgIHBjaV9yZWFkX2NvbmZpZ19kd29yZCggZGV2LCBQTUM1NTFfRFJBTV9CTEszLCAmZGNtZCApOworICAgICAgICBwcmludGsoS0VSTl9ERUJVRyAicG1jNTUxOiBEUkFNX0JMSzMgRmxhZ3M6ICVzLCVzXG4iCisJCQkgICJwbWM1NTE6IERSQU1fQkxLMyBTaXplOiAlZCBhdCAlZFxuIgorCQkJICAicG1jNTUxOiBEUkFNX0JMSzMgUm93IE1VWDogJWQsIENvbCBNVVg6ICVkXG4iLAorICAgICAgICAgICAgICAgKCgoMHgxPDwxKSZkY21kKSA9PSAwKT8iUlciOiJSTyIsCisgICAgICAgICAgICAgICAoKCgweDE8PDApJmRjbWQpID09IDApPyJPZmYiOiJPbiIsCisJICAgICAgIFBNQzU1MV9EUkFNX0JMS19HRVRfU0laRShkY21kKSwKKwkgICAgICAgKChkY21kPj4yMCkmMHg3RkYpLCAoKGRjbWQ+PjEzKSYweDcpLCAoKGRjbWQ+PjkpJjB4RikgKTsKKworICAgICAgICBwY2lfcmVhZF9jb25maWdfd29yZCggZGV2LCBQQ0lfQ09NTUFORCwgJmNtZCApOworICAgICAgICBwcmludGsoIEtFUk5fREVCVUcgInBtYzU1MTogTWVtb3J5IEFjY2VzcyAlc1xuIiwKKyAgICAgICAgICAgICAgICAoKCgweDE8PDEpJmNtZCkgPT0gMCk/Im9mZiI6Im9uIiApOworICAgICAgICBwcmludGsoIEtFUk5fREVCVUcgInBtYzU1MTogSS9PIEFjY2VzcyAlc1xuIiwKKyAgICAgICAgICAgICAgICAoKCgweDE8PDApJmNtZCkgPT0gMCk/Im9mZiI6Im9uIiApOworCisgICAgICAgIHBjaV9yZWFkX2NvbmZpZ193b3JkKCBkZXYsIFBDSV9TVEFUVVMsICZjbWQgKTsKKyAgICAgICAgcHJpbnRrKCBLRVJOX0RFQlVHICJwbWM1NTE6IERldnNlbCAlc1xuIiwKKyAgICAgICAgICAgICAgICAoKFBDSV9TVEFUVVNfREVWU0VMX01BU0smY21kKT09MHgwMDApPyJGYXN0IjoKKyAgICAgICAgICAgICAgICAoKFBDSV9TVEFUVVNfREVWU0VMX01BU0smY21kKT09MHgyMDApPyJNZWRpdW0iOgorICAgICAgICAgICAgICAgICgoUENJX1NUQVRVU19ERVZTRUxfTUFTSyZjbWQpPT0weDQwMCk/IlNsb3ciOiJJbnZhbGlkIiApOworCisgICAgICAgIHByaW50ayggS0VSTl9ERUJVRyAicG1jNTUxOiAlc0Zhc3QgQmFjay10by1CYWNrXG4iLAorICAgICAgICAgICAgICAgICgoUENJX0NPTU1BTkRfRkFTVF9CQUNLJmNtZCkgPT0gMCk/Ik5vdCAiOiIiICk7CisKKwlwY2lfcmVhZF9jb25maWdfYnl0ZShkZXYsIFBNQzU1MV9TWVNfQ1RSTF9SRUcsICZiY21kICk7CisJcHJpbnRrKCBLRVJOX0RFQlVHICJwbWM1NTE6IEVFUFJPTSBpcyB1bmRlciAlcyBjb250cm9sXG4iCisJCQkgICAicG1jNTUxOiBTeXN0ZW0gQ29udHJvbCBSZWdpc3RlciBpcyAlc2xvY2tlZCB0byBQQ0kgYWNjZXNzXG4iCisJCQkgICAicG1jNTUxOiBTeXN0ZW0gQ29udHJvbCBSZWdpc3RlciBpcyAlc2xvY2tlZCB0byBFRVBST00gYWNjZXNzXG4iLCAKKwkJKGJjbWQmMHgxKT8ic29mdHdhcmUiOiJoYXJkd2FyZSIsCisJCShiY21kJjB4MjApPyIiOiJ1biIsIChiY21kJjB4NDApPyIiOiJ1biIpOworI2VuZGlmCisgICAgICAgIHJldHVybiBzaXplOworfQorCisvKgorICogS2VybmVsIHZlcnNpb24gc3BlY2lmaWMgbW9kdWxlIHN0dWZmYWdlcworICovCisKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiTWFyayBGZXJyZWxsIDxtZmVycmVsbEBtdmlzdGEuY29tPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKFBNQzU1MV9WRVJTSU9OKTsKKworLyoKKyAqIFN0dWZmIHRoZXNlIG91dHNpZGUgdGhlIGlmZGVmIHNvIGFzIHRvIG5vdCBidXN0IGNvbXBpbGVkIGluIGRyaXZlciBzdXBwb3J0CisgKi8KK3N0YXRpYyBpbnQgbXNpemU9MDsKKyNpZiBkZWZpbmVkKENPTkZJR19NVERfUE1DNTUxX0FQRVJUVVJFX1NJWkUpCitzdGF0aWMgaW50IGFzaXplPUNPTkZJR19NVERfUE1DNTUxX0FQRVJUVVJFX1NJWkUKKyNlbHNlCitzdGF0aWMgaW50IGFzaXplPTA7CisjZW5kaWYKKworbW9kdWxlX3BhcmFtKG1zaXplLCBpbnQsIDApOworTU9EVUxFX1BBUk1fREVTQyhtc2l6ZSwgIm1lbW9yeSBzaXplIGluIE1lZ2FieXRlcyBbMSAtIDEwMjRdIik7Cittb2R1bGVfcGFyYW0oYXNpemUsIGludCwgMCk7CitNT0RVTEVfUEFSTV9ERVNDKGFzaXplLCAiYXBlcnR1cmUgc2l6ZSwgbXVzdCBiZSA8PSBtZW1zaXplIFsxLTEwMjRdIik7CisKKy8qCisgKiBQTUM1NTEgQ2FyZCBJbml0aWFsaXphdGlvbgorICovCitzdGF0aWMgaW50IF9faW5pdCBpbml0X3BtYzU1MSh2b2lkKQoreworICAgICAgICBzdHJ1Y3QgcGNpX2RldiAqUENJX0RldmljZSA9IE5VTEw7CisgICAgICAgIHN0cnVjdCBteXByaXYgKnByaXY7CisgICAgICAgIGludCBjb3VudCwgZm91bmQ9MDsKKyAgICAgICAgc3RydWN0IG10ZF9pbmZvICptdGQ7CisgICAgICAgIHUzMiBsZW5ndGggPSAwOworCisJaWYobXNpemUpIHsKKwkJbXNpemUgPSAoMSA8PCAoZmZzKG1zaXplKSAtIDEpKTw8MjA7CisJCWlmIChtc2l6ZSA+ICgxPDwzMCkpIHsKKwkJCXByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiBJbnZhbGlkIG1lbW9yeSBzaXplIFslZF1cbiIsIG1zaXplKTsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CisJfQorCisJaWYoYXNpemUpIHsKKwkJYXNpemUgPSAoMSA8PCAoZmZzKGFzaXplKSAtIDEpKTw8MjA7CisJCWlmIChhc2l6ZSA+ICgxPDwzMCkgKSB7CisJCQlwcmludGsoS0VSTl9OT1RJQ0UgInBtYzU1MTogSW52YWxpZCBhcGVydHVyZSBzaXplIFslZF1cbiIsIGFzaXplKTsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CisJfQorCisgICAgICAgIHByaW50ayhLRVJOX0lORk8gUE1DNTUxX1ZFUlNJT04pOworCisgICAgICAgIC8qCisgICAgICAgICAqIFBDVS1idXMgY2hpcHNldCBwcm9iZS4KKyAgICAgICAgICovCisgICAgICAgIGZvciggY291bnQgPSAwOyBjb3VudCA8IE1BWF9NVERfREVWSUNFUzsgY291bnQrKyApIHsKKworICAgICAgICAgICAgICAgIGlmICgoUENJX0RldmljZSA9IHBjaV9maW5kX2RldmljZShQQ0lfVkVORE9SX0lEX1YzX1NFTUksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBDSV9ERVZJQ0VfSURfVjNfU0VNSV9WMzcwUERDLAorCQkJCQkJICBQQ0lfRGV2aWNlICkgKSA9PSBOVUxMKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICBwcmludGsoS0VSTl9OT1RJQ0UgInBtYzU1MTogRm91bmQgUENJIFYzNzBQREMgYXQgMHglbFhcbiIsCisJCQkJICAgIFBDSV9EZXZpY2UtPnJlc291cmNlWzBdLnN0YXJ0KTsKKworICAgICAgICAgICAgICAgIC8qCisgICAgICAgICAgICAgICAgICogVGhlIFBNQzU1MSBkZXZpY2UgYWN0cyBWRVJZIHdlaXJkIGlmIHlvdSBkb24ndCBpbml0IGl0CisgICAgICAgICAgICAgICAgICogZmlyc3QuICBpLmUuIGl0IHdpbGwgbm90IGNvcnJlY3RseSByZXBvcnQgZGV2c2VsLiAgSWYgZm9yCisgICAgICAgICAgICAgICAgICogc29tZSByZWFzb24gdGhlIHNkcmFtIGlzIGluIGEgd3JvdGUtcHJvdGVjdGVkIHN0YXRlIHRoZQorICAgICAgICAgICAgICAgICAqIGRldmljZSB3aWxsIERFVlNFTCB3aGVuIGl0IGlzIHdyaXR0ZW4gdG8gY2F1c2luZyBwcm9ibGVtcworICAgICAgICAgICAgICAgICAqIHdpdGggdGhlIG9sZHByb2MuYyBkcml2ZXIgaW4KKyAgICAgICAgICAgICAgICAgKiBzb21lIGtlcm5lbHMgKDIuMi4qKQorICAgICAgICAgICAgICAgICAqLworICAgICAgICAgICAgICAgIGlmKChsZW5ndGggPSBmaXh1cF9wbWM1NTEoUENJX0RldmljZSkpIDw9IDApIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiBDYW5ub3QgaW5pdCBTRFJBTVxuIik7CisgICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICB9CisKKwkJLyoKKwkJICogVGhpcyBpcyBuZWVkZWQgdW50aWwgdGhlIGRyaXZlciBpcyBjYXBhYmxlIG9mIHJlYWRpbmcgdGhlCisJCSAqIG9uYm9hcmQgSTJDIFNST00gdG8gZGlzY292ZXIgdGhlICJyZWFsIiBtZW1vcnkgc2l6ZS4KKwkJICovCisJCWlmKG1zaXplKSB7CisJCQlsZW5ndGggPSBtc2l6ZTsKKwkJCXByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiBVc2luZyBzcGVjaWZpZWQgbWVtb3J5IHNpemUgMHgleFxuIiwgbGVuZ3RoKTsKKwkJfSBlbHNlIHsKKwkJCW1zaXplID0gbGVuZ3RoOworCQl9CisKKyAgICAgICAgICAgICAgICBtdGQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgbXRkX2luZm8pLCBHRlBfS0VSTkVMKTsKKyAgICAgICAgICAgICAgICBpZiAoIW10ZCkgeworICAgICAgICAgICAgICAgICAgICAgICAgcHJpbnRrKEtFUk5fTk9USUNFICJwbWM1NTE6IENhbm5vdCBhbGxvY2F0ZSBuZXcgTVREIGRldmljZS5cbiIpOworICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAgICAgbWVtc2V0KG10ZCwgMCwgc2l6ZW9mKHN0cnVjdCBtdGRfaW5mbykpOworCisgICAgICAgICAgICAgICAgcHJpdiA9IGttYWxsb2MgKHNpemVvZihzdHJ1Y3QgbXlwcml2KSwgR0ZQX0tFUk5FTCk7CisgICAgICAgICAgICAgICAgaWYgKCFwcml2KSB7CisgICAgICAgICAgICAgICAgICAgICAgICBwcmludGsoS0VSTl9OT1RJQ0UgInBtYzU1MTogQ2Fubm90IGFsbG9jYXRlIG5ldyBNVEQgZGV2aWNlLlxuIik7CisgICAgICAgICAgICAgICAgICAgICAgICBrZnJlZShtdGQpOworICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIG1lbXNldChwcml2LCAwLCBzaXplb2YoKnByaXYpKTsKKyAgICAgICAgICAgICAgICBtdGQtPnByaXYgPSBwcml2OworICAgICAgICAgICAgICAgIHByaXYtPmRldiA9IFBDSV9EZXZpY2U7CisKKwkJaWYoYXNpemUgPiBsZW5ndGgpIHsKKwkJCXByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiByZWR1Y2luZyBhcGVydHVyZSBzaXplIHRvIGZpdCAlZE1cbiIsbGVuZ3RoPj4yMCk7CisJCQlwcml2LT5hc2l6ZSA9IGFzaXplID0gbGVuZ3RoOworCQl9IGVsc2UgaWYgKGFzaXplID09IDAgfHwgYXNpemUgPT0gbGVuZ3RoKSB7CisJCQlwcmludGsoS0VSTl9OT1RJQ0UgInBtYzU1MTogVXNpbmcgZXhpc3RpbmcgYXBlcnR1cmUgc2l6ZSAlZE1cbiIsIGxlbmd0aD4+MjApOworCQkJcHJpdi0+YXNpemUgPSBhc2l6ZSA9IGxlbmd0aDsKKwkJfSBlbHNlIHsKKwkJCXByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiBVc2luZyBzcGVjaWZpZWQgYXBlcnR1cmUgc2l6ZSAlZE1cbiIsIGFzaXplPj4yMCk7CisJCQlwcml2LT5hc2l6ZSA9IGFzaXplOworCQl9CisgICAgICAgICAgICAgICAgcHJpdi0+c3RhcnQgPSBpb3JlbWFwKCgoUENJX0RldmljZS0+cmVzb3VyY2VbMF0uc3RhcnQpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmIFBDSV9CQVNFX0FERFJFU1NfTUVNX01BU0spLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcml2LT5hc2l6ZSk7CisJCQorCQlpZiAoIXByaXYtPnN0YXJ0KSB7CisJCQlwcmludGsoS0VSTl9OT1RJQ0UgInBtYzU1MTogVW5hYmxlIHRvIG1hcCBJTyBzcGFjZVxuIik7CisgICAgICAgICAgICAgICAgICAgICAgICBrZnJlZShtdGQtPnByaXYpOworICAgICAgICAgICAgICAgICAgICAgICAga2ZyZWUobXRkKTsKKwkJCWJyZWFrOworCQl9CisKKyNpZmRlZiBDT05GSUdfTVREX1BNQzU1MV9ERUJVRworCQlwcmludGsoIEtFUk5fREVCVUcgInBtYzU1MTogc2V0dGluZyBhcGVydHVyZSB0byAlZFxuIiwKKwkJCWZmcyhwcml2LT5hc2l6ZT4+MjApLTEpOworI2VuZGlmCisKKyAgICAgICAgICAgICAgICBwcml2LT5iYXNlX21hcDAgPSAoIFBNQzU1MV9QQ0lfTUVNX01BUF9SRUdfRU4KKwkJCQkgIHwgUE1DNTUxX1BDSV9NRU1fTUFQX0VOQUJMRQorCQkJCSAgfCAoZmZzKHByaXYtPmFzaXplPj4yMCktMSk8PDQgKTsKKyAgICAgICAgICAgICAgICBwcml2LT5jdXJyX21hcDAgPSBwcml2LT5iYXNlX21hcDA7CisgICAgICAgICAgICAgICAgcGNpX3dyaXRlX2NvbmZpZ19kd29yZCAoIHByaXYtPmRldiwgUE1DNTUxX1BDSV9NRU1fTUFQMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJpdi0+Y3Vycl9tYXAwICk7CisKKyNpZmRlZiBDT05GSUdfTVREX1BNQzU1MV9ERUJVRworCQlwcmludGsoIEtFUk5fREVCVUcgInBtYzU1MTogYXBlcnR1cmUgc2V0IHRvICVkXG4iLCAKKwkJCShwcml2LT5iYXNlX21hcDAgJiAweEYwKT4+NCApOworI2VuZGlmCisKKyAgICAgICAgICAgICAgICBtdGQtPnNpemUgCT0gbXNpemU7CisgICAgICAgICAgICAgICAgbXRkLT5mbGFncyAJPSBNVERfQ0FQX1JBTTsKKyAgICAgICAgICAgICAgICBtdGQtPmVyYXNlIAk9IHBtYzU1MV9lcmFzZTsKKyAgICAgICAgICAgICAgICBtdGQtPnJlYWQgCT0gcG1jNTUxX3JlYWQ7CisgICAgICAgICAgICAgICAgbXRkLT53cml0ZSAJPSBwbWM1NTFfd3JpdGU7CisgICAgICAgICAgICAgICAgbXRkLT5wb2ludCAJPSBwbWM1NTFfcG9pbnQ7CisgICAgICAgICAgICAgICAgbXRkLT51bnBvaW50IAk9IHBtYzU1MV91bnBvaW50OworICAgICAgICAgICAgICAgIG10ZC0+dHlwZSAJPSBNVERfUkFNOworICAgICAgICAgICAgICAgIG10ZC0+bmFtZSAJPSAiUE1DNTUxIFJBTSBib2FyZCI7CisgICAgICAgICAgICAgICAgbXRkLT5lcmFzZXNpemUgCT0gMHgxMDAwMDsKKwkJbXRkLT5vd25lciA9IFRISVNfTU9EVUxFOworCisgICAgICAgICAgICAgICAgaWYgKGFkZF9tdGRfZGV2aWNlKG10ZCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiBGYWlsZWQgdG8gcmVnaXN0ZXIgbmV3IGRldmljZVxuIik7CisJCQlpb3VubWFwKHByaXYtPnN0YXJ0KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGtmcmVlKG10ZC0+cHJpdik7CisgICAgICAgICAgICAgICAgICAgICAgICBrZnJlZShtdGQpOworICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIHByaW50ayhLRVJOX05PVElDRSAiUmVnaXN0ZXJlZCBwbWM1NTEgbWVtb3J5IGRldmljZS5cbiIpOworICAgICAgICAgICAgICAgIHByaW50ayhLRVJOX05PVElDRSAiTWFwcGVkICVkTSBvZiBtZW1vcnkgZnJvbSAweCVwIHRvIDB4JXBcbiIsCisgICAgICAgICAgICAgICAgICAgICAgIHByaXYtPmFzaXplPj4yMCwKKyAgICAgICAgICAgICAgICAgICAgICAgcHJpdi0+c3RhcnQsCisgICAgICAgICAgICAgICAgICAgICAgIHByaXYtPnN0YXJ0ICsgcHJpdi0+YXNpemUpOworICAgICAgICAgICAgICAgIHByaW50ayhLRVJOX05PVElDRSAiVG90YWwgbWVtb3J5IGlzICVkJWNcbiIsCisJICAgICAgIAkJKGxlbmd0aDwxMDI0KT9sZW5ndGg6CisJCQkJKGxlbmd0aDwxMDQ4NTc2KT9sZW5ndGg+PjEwOmxlbmd0aD4+MjAsCisgICAgICAgICAgICAgICAJCShsZW5ndGg8MTAyNCk/J0InOihsZW5ndGg8MTA0ODU3Nik/J0snOidNJyk7CisJCXByaXYtPm5leHRwbWM1NTEgPSBwbWM1NTFsaXN0OworCQlwbWM1NTFsaXN0ID0gbXRkOworCQlmb3VuZCsrOworICAgICAgICB9CisKKyAgICAgICAgaWYoICFwbWM1NTFsaXN0ICkgeworICAgICAgICAgICAgICAgIHByaW50ayhLRVJOX05PVElDRSAicG1jNTUxOiBub3QgZGV0ZWN0ZWRcbiIpOworICAgICAgICAgICAgICAgIHJldHVybiAtRU5PREVWOworICAgICAgICB9IGVsc2UgeworCQlwcmludGsoS0VSTl9OT1RJQ0UgInBtYzU1MTogJWQgcG1jNTUxIGRldmljZXMgbG9hZGVkXG4iLCBmb3VuZCk7CisgICAgICAgICAgICAgICAgcmV0dXJuIDA7CisJfQorfQorCisvKgorICogUE1DNTUxIENhcmQgQ2xlYW51cAorICovCitzdGF0aWMgdm9pZCBfX2V4aXQgY2xlYW51cF9wbWM1NTEodm9pZCkKK3sKKyAgICAgICAgaW50IGZvdW5kPTA7CisgICAgICAgIHN0cnVjdCBtdGRfaW5mbyAqbXRkOworCXN0cnVjdCBteXByaXYgKnByaXY7CisKKwl3aGlsZSgobXRkPXBtYzU1MWxpc3QpKSB7CisJCXByaXYgPSBtdGQtPnByaXY7CisJCXBtYzU1MWxpc3QgPSBwcml2LT5uZXh0cG1jNTUxOworCQkKKwkJaWYocHJpdi0+c3RhcnQpIHsKKwkJCXByaW50ayAoS0VSTl9ERUJVRyAicG1jNTUxOiB1bm1hcHBpbmcgJWRNIHN0YXJ0aW5nIGF0IDB4JXBcbiIsCisJCQkJcHJpdi0+YXNpemU+PjIwLCBwcml2LT5zdGFydCk7CisJCQlpb3VubWFwIChwcml2LT5zdGFydCk7CisJCX0KKwkJCisJCWtmcmVlIChtdGQtPnByaXYpOworCQlkZWxfbXRkX2RldmljZSAobXRkKTsKKwkJa2ZyZWUgKG10ZCk7CisJCWZvdW5kKys7CisJfQorCisJcHJpbnRrKEtFUk5fTk9USUNFICJwbWM1NTE6ICVkIHBtYzU1MSBkZXZpY2VzIHVubG9hZGVkXG4iLCBmb3VuZCk7Cit9CisKK21vZHVsZV9pbml0KGluaXRfcG1jNTUxKTsKK21vZHVsZV9leGl0KGNsZWFudXBfcG1jNTUxKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvc2xyYW0uYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvc2xyYW0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41YWIxNWU2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9zbHJhbS5jCkBAIC0wLDAgKzEsMzU3IEBACisvKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKworICAkSWQ6IHNscmFtLmMsdiAxLjMzIDIwMDUvMDEvMDUgMTg6MDU6MTMgZHdtdzIgRXhwICQKKworICBUaGlzIGRyaXZlciBwcm92aWRlcyBhIG1ldGhvZCB0byBhY2Nlc3MgbWVtb3J5IG5vdCB1c2VkIGJ5IHRoZSBrZXJuZWwKKyAgaXRzZWxmIChpLmUuIGlmIHRoZSBrZXJuZWwgY29tbWFuZGxpbmUgbWVtPXh4eCBpcyB1c2VkKS4gVG8gYWN0dWFsbHkKKyAgdXNlIHNscmFtIGF0IGxlYXN0IG10ZGJsb2NrIG9yIG10ZGNoYXIgaXMgcmVxdWlyZWQgKGZvciBibG9jayBvcgorICBjaGFyYWN0ZXIgZGV2aWNlIGFjY2VzcykuCisKKyAgVXNhZ2U6CisKKyAgaWYgY29tcGlsZWQgYXMgbG9hZGFibGUgbW9kdWxlOgorICAgIG1vZHByb2JlIHNscmFtIG1hcD08bmFtZT4sPHN0YXJ0Piw8ZW5kL29mZnNldD4KKyAgaWYgc3RhdGljYWxseSBsaW5rZWQgaW50byB0aGUga2VybmVsIHVzZSB0aGUgZm9sbG93aW5nIGtlcm5lbCBjbWQubGluZQorICAgIHNscmFtPTxuYW1lPiw8c3RhcnQ+LDxlbmQvb2Zmc2V0PgorCisgIDxuYW1lPjogbmFtZSBvZiB0aGUgZGV2aWNlIHRoYXQgd2lsbCBiZSBsaXN0ZWQgaW4gL3Byb2MvbXRkCisgIDxzdGFydD46IHN0YXJ0IG9mIHRoZSBtZW1vcnkgcmVnaW9uLCBkZWNpbWFsIG9yIGhleCAoMHhhYmNkZWYpCisgIDxlbmQvb2Zmc2V0PjogZW5kIG9mIHRoZSBtZW1vcnkgcmVnaW9uLiBJdCdzIHBvc3NpYmxlIHRvIHVzZSArMHgxMjM0CisgICAgICAgICAgICAgICAgdG8gc3BlY2lmeSB0aGUgb2Zmc2V0IGluc3RlYWQgb2YgdGhlIGFic29sdXRlIGFkZHJlc3MKKyAgICAKKyAgTk9URToKKyAgV2l0aCBzbHJhbSBpdCdzIG9ubHkgcG9zc2libGUgdG8gbWFwIGEgY29udGlnb3VzIG1lbW9yeSByZWdpb24uIFRoZXJmb3JlCisgIGlmIHRoZXJlJ3MgYSBkZXZpY2UgbWFwcGVkIHNvbWV3aGVyZSBpbiB0aGUgcmVnaW9uIHNwZWNpZmllZCBzbHJhbSB3aWxsCisgIGZhaWwgdG8gbG9hZCAoc2VlIGtlcm5lbCBsb2cgaWYgbW9kcHJvYmUgZmFpbHMpLgorCisgIC0KKyAgCisgIEpvY2hlbiBTY2hhZXVibGUgPHBzaW9uaWNAcHNpb25pYy5kZT4KKworPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCisKKworI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L21ham9yLmg+CisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9pb2N0bC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxhc20vaW8uaD4KKyNpbmNsdWRlIDxhc20vc3lzdGVtLmg+CisKKyNpbmNsdWRlIDxsaW51eC9tdGQvbXRkLmg+CisKKyNkZWZpbmUgU0xSQU1fTUFYX0RFVklDRVNfUEFSQU1TIDYJCS8qIDMgcGFyYW1ldGVycyAvIGRldmljZSAqLworCisjZGVmaW5lIFQoZm10LCBhcmdzLi4uKSBwcmludGsoS0VSTl9ERUJVRyBmbXQsICMjIGFyZ3MpCisjZGVmaW5lIEUoZm10LCBhcmdzLi4uKSBwcmludGsoS0VSTl9OT1RJQ0UgZm10LCAjIyBhcmdzKQorCit0eXBlZGVmIHN0cnVjdCBzbHJhbV9wcml2IHsKKwl1X2NoYXIgKnN0YXJ0OworCXVfY2hhciAqZW5kOworfSBzbHJhbV9wcml2X3Q7CisKK3R5cGVkZWYgc3RydWN0IHNscmFtX210ZF9saXN0IHsKKwlzdHJ1Y3QgbXRkX2luZm8gKm10ZGluZm87CisJc3RydWN0IHNscmFtX210ZF9saXN0ICpuZXh0OworfSBzbHJhbV9tdGRfbGlzdF90OworCisjaWZkZWYgTU9EVUxFCitzdGF0aWMgY2hhciAqbWFwW1NMUkFNX01BWF9ERVZJQ0VTX1BBUkFNU107CisKK21vZHVsZV9wYXJhbV9hcnJheShtYXAsIGNoYXJwLCBOVUxMLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MobWFwLCAiTGlzdCBvZiBtZW1vcnkgcmVnaW9ucyB0byBtYXAuIFwibWFwPTxuYW1lPiwgPHN0YXJ0PiwgPGxlbmd0aCAvIGVuZD5cIiIpOworI2Vsc2UKK3N0YXRpYyBjaGFyICptYXA7CisjZW5kaWYKKworc3RhdGljIHNscmFtX210ZF9saXN0X3QgKnNscmFtX210ZGxpc3QgPSBOVUxMOworCitzdGF0aWMgaW50IHNscmFtX2VyYXNlKHN0cnVjdCBtdGRfaW5mbyAqLCBzdHJ1Y3QgZXJhc2VfaW5mbyAqKTsKK3N0YXRpYyBpbnQgc2xyYW1fcG9pbnQoc3RydWN0IG10ZF9pbmZvICosIGxvZmZfdCwgc2l6ZV90LCBzaXplX3QgKiwgdV9jaGFyICoqKTsKK3N0YXRpYyB2b2lkIHNscmFtX3VucG9pbnQoc3RydWN0IG10ZF9pbmZvICosIHVfY2hhciAqLCBsb2ZmX3QsCXNpemVfdCk7CitzdGF0aWMgaW50IHNscmFtX3JlYWQoc3RydWN0IG10ZF9pbmZvICosIGxvZmZfdCwgc2l6ZV90LCBzaXplX3QgKiwgdV9jaGFyICopOworc3RhdGljIGludCBzbHJhbV93cml0ZShzdHJ1Y3QgbXRkX2luZm8gKiwgbG9mZl90LCBzaXplX3QsIHNpemVfdCAqLCBjb25zdCB1X2NoYXIgKik7CisKK3N0YXRpYyBpbnQgc2xyYW1fZXJhc2Uoc3RydWN0IG10ZF9pbmZvICptdGQsIHN0cnVjdCBlcmFzZV9pbmZvICppbnN0cikKK3sKKwlzbHJhbV9wcml2X3QgKnByaXYgPSBtdGQtPnByaXY7CisKKwlpZiAoaW5zdHItPmFkZHIgKyBpbnN0ci0+bGVuID4gbXRkLT5zaXplKSB7CisJCXJldHVybigtRUlOVkFMKTsKKwl9CisJCisJbWVtc2V0KHByaXYtPnN0YXJ0ICsgaW5zdHItPmFkZHIsIDB4ZmYsIGluc3RyLT5sZW4pOworCisJLyogVGhpcydsbCBjYXRjaCBhIGZldyByYWNlcy4gRnJlZSB0aGUgdGhpbmcgYmVmb3JlIHJldHVybmluZyA6KSAKKwkgKiBJIGRvbid0IGZlZWwgYXQgYWxsIGFzaGFtZWQuIFRoaXMga2luZCBvZiB0aGluZyBpcyBwb3NzaWJsZSBhbnl3YXkKKwkgKiB3aXRoIGZsYXNoLCBidXQgdW5saWtlbHkuCisJICovCisKKwlpbnN0ci0+c3RhdGUgPSBNVERfRVJBU0VfRE9ORTsKKworCW10ZF9lcmFzZV9jYWxsYmFjayhpbnN0cik7CisKKwlyZXR1cm4oMCk7Cit9CisKK3N0YXRpYyBpbnQgc2xyYW1fcG9pbnQoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCBmcm9tLCBzaXplX3QgbGVuLAorCQlzaXplX3QgKnJldGxlbiwgdV9jaGFyICoqbXRkYnVmKQoreworCXNscmFtX3ByaXZfdCAqcHJpdiA9IG10ZC0+cHJpdjsKKworCSptdGRidWYgPSBwcml2LT5zdGFydCArIGZyb207CisJKnJldGxlbiA9IGxlbjsKKwlyZXR1cm4oMCk7Cit9CisKK3N0YXRpYyB2b2lkIHNscmFtX3VucG9pbnQoc3RydWN0IG10ZF9pbmZvICptdGQsIHVfY2hhciAqYWRkciwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4pCit7Cit9CisKK3N0YXRpYyBpbnQgc2xyYW1fcmVhZChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgbG9mZl90IGZyb20sIHNpemVfdCBsZW4sCisJCXNpemVfdCAqcmV0bGVuLCB1X2NoYXIgKmJ1ZikKK3sKKwlzbHJhbV9wcml2X3QgKnByaXYgPSBtdGQtPnByaXY7CisJCisJbWVtY3B5KGJ1ZiwgcHJpdi0+c3RhcnQgKyBmcm9tLCBsZW4pOworCisJKnJldGxlbiA9IGxlbjsKKwlyZXR1cm4oMCk7Cit9CisKK3N0YXRpYyBpbnQgc2xyYW1fd3JpdGUoc3RydWN0IG10ZF9pbmZvICptdGQsIGxvZmZfdCB0bywgc2l6ZV90IGxlbiwKKwkJc2l6ZV90ICpyZXRsZW4sIGNvbnN0IHVfY2hhciAqYnVmKQoreworCXNscmFtX3ByaXZfdCAqcHJpdiA9IG10ZC0+cHJpdjsKKworCW1lbWNweShwcml2LT5zdGFydCArIHRvLCBidWYsIGxlbik7CisKKwkqcmV0bGVuID0gbGVuOworCXJldHVybigwKTsKK30KKworLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCisKK3N0YXRpYyBpbnQgcmVnaXN0ZXJfZGV2aWNlKGNoYXIgKm5hbWUsIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGVuZ3RoKQoreworCXNscmFtX210ZF9saXN0X3QgKipjdXJtdGQ7CisKKwljdXJtdGQgPSAmc2xyYW1fbXRkbGlzdDsKKwl3aGlsZSAoKmN1cm10ZCkgeworCQljdXJtdGQgPSAmKCpjdXJtdGQpLT5uZXh0OworCX0KKworCSpjdXJtdGQgPSBrbWFsbG9jKHNpemVvZihzbHJhbV9tdGRfbGlzdF90KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEoKmN1cm10ZCkpIHsKKwkJRSgic2xyYW06IENhbm5vdCBhbGxvY2F0ZSBuZXcgTVREIGRldmljZS5cbiIpOworCQlyZXR1cm4oLUVOT01FTSk7CisJfQorCSgqY3VybXRkKS0+bXRkaW5mbyA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBtdGRfaW5mbyksIEdGUF9LRVJORUwpOworCSgqY3VybXRkKS0+bmV4dCA9IE5VTEw7CisJCisJaWYgKCgqY3VybXRkKS0+bXRkaW5mbykJeworCQltZW1zZXQoKGNoYXIgKikoKmN1cm10ZCktPm10ZGluZm8sIDAsIHNpemVvZihzdHJ1Y3QgbXRkX2luZm8pKTsKKwkJKCpjdXJtdGQpLT5tdGRpbmZvLT5wcml2ID0KKwkJCWttYWxsb2Moc2l6ZW9mKHNscmFtX3ByaXZfdCksIEdGUF9LRVJORUwpOworCQkKKwkJaWYgKCEoKmN1cm10ZCktPm10ZGluZm8tPnByaXYpIHsKKwkJCWtmcmVlKCgqY3VybXRkKS0+bXRkaW5mbyk7CisJCQkoKmN1cm10ZCktPm10ZGluZm8gPSBOVUxMOworCQl9IGVsc2UgeworCQkJbWVtc2V0KCgqY3VybXRkKS0+bXRkaW5mby0+cHJpdiwwLHNpemVvZihzbHJhbV9wcml2X3QpKTsKKwkJfQorCX0KKworCWlmICghKCpjdXJtdGQpLT5tdGRpbmZvKSB7CisJCUUoInNscmFtOiBDYW5ub3QgYWxsb2NhdGUgbmV3IE1URCBkZXZpY2UuXG4iKTsKKwkJcmV0dXJuKC1FTk9NRU0pOworCX0KKwkKKwlpZiAoISgoKHNscmFtX3ByaXZfdCAqKSgqY3VybXRkKS0+bXRkaW5mby0+cHJpdiktPnN0YXJ0ID0KKwkJCQlpb3JlbWFwKHN0YXJ0LCBsZW5ndGgpKSkgeworCQlFKCJzbHJhbTogaW9yZW1hcCBmYWlsZWRcbiIpOworCQlyZXR1cm4gLUVJTzsKKwl9CisJKChzbHJhbV9wcml2X3QgKikoKmN1cm10ZCktPm10ZGluZm8tPnByaXYpLT5lbmQgPQorCQkoKHNscmFtX3ByaXZfdCAqKSgqY3VybXRkKS0+bXRkaW5mby0+cHJpdiktPnN0YXJ0ICsgbGVuZ3RoOworCisKKwkoKmN1cm10ZCktPm10ZGluZm8tPm5hbWUgPSBuYW1lOworCSgqY3VybXRkKS0+bXRkaW5mby0+c2l6ZSA9IGxlbmd0aDsKKwkoKmN1cm10ZCktPm10ZGluZm8tPmZsYWdzID0gTVREX0NMRUFSX0JJVFMgfCBNVERfU0VUX0JJVFMgfAorCQkJCQlNVERfV1JJVEVCX1dSSVRFQUJMRSB8IE1URF9WT0xBVElMRTsKKyAgICAgICAgKCpjdXJtdGQpLT5tdGRpbmZvLT5lcmFzZSA9IHNscmFtX2VyYXNlOworCSgqY3VybXRkKS0+bXRkaW5mby0+cG9pbnQgPSBzbHJhbV9wb2ludDsKKwkoKmN1cm10ZCktPm10ZGluZm8tPnVucG9pbnQgPSBzbHJhbV91bnBvaW50OworCSgqY3VybXRkKS0+bXRkaW5mby0+cmVhZCA9IHNscmFtX3JlYWQ7CisJKCpjdXJtdGQpLT5tdGRpbmZvLT53cml0ZSA9IHNscmFtX3dyaXRlOworCSgqY3VybXRkKS0+bXRkaW5mby0+b3duZXIgPSBUSElTX01PRFVMRTsKKwkoKmN1cm10ZCktPm10ZGluZm8tPnR5cGUgPSBNVERfUkFNOworCSgqY3VybXRkKS0+bXRkaW5mby0+ZXJhc2VzaXplID0gMHgwOworCisJaWYgKGFkZF9tdGRfZGV2aWNlKCgqY3VybXRkKS0+bXRkaW5mbykpCXsKKwkJRSgic2xyYW06IEZhaWxlZCB0byByZWdpc3RlciBuZXcgZGV2aWNlXG4iKTsKKwkJaW91bm1hcCgoKHNscmFtX3ByaXZfdCAqKSgqY3VybXRkKS0+bXRkaW5mby0+cHJpdiktPnN0YXJ0KTsKKwkJa2ZyZWUoKCpjdXJtdGQpLT5tdGRpbmZvLT5wcml2KTsKKwkJa2ZyZWUoKCpjdXJtdGQpLT5tdGRpbmZvKTsKKwkJcmV0dXJuKC1FQUdBSU4pOworCX0KKwlUKCJzbHJhbTogUmVnaXN0ZXJlZCBkZXZpY2UgJXMgZnJvbSAlbHVLaUIgdG8gJWx1S2lCXG4iLCBuYW1lLAorCQkJKHN0YXJ0IC8gMTAyNCksICgoc3RhcnQgKyBsZW5ndGgpIC8gMTAyNCkpOworCVQoInNscmFtOiBNYXBwZWQgZnJvbSAweCVwIHRvIDB4JXBcbiIsCisJCQkoKHNscmFtX3ByaXZfdCAqKSgqY3VybXRkKS0+bXRkaW5mby0+cHJpdiktPnN0YXJ0LAorCQkJKChzbHJhbV9wcml2X3QgKikoKmN1cm10ZCktPm10ZGluZm8tPnByaXYpLT5lbmQpOworCXJldHVybigwKTsJCit9CisKK3N0YXRpYyB2b2lkIHVucmVnaXN0ZXJfZGV2aWNlcyh2b2lkKQoreworCXNscmFtX210ZF9saXN0X3QgKm5leHRpdGVtOworCisJd2hpbGUgKHNscmFtX210ZGxpc3QpIHsKKwkJbmV4dGl0ZW0gPSBzbHJhbV9tdGRsaXN0LT5uZXh0OworCQlkZWxfbXRkX2RldmljZShzbHJhbV9tdGRsaXN0LT5tdGRpbmZvKTsKKwkJaW91bm1hcCgoKHNscmFtX3ByaXZfdCAqKXNscmFtX210ZGxpc3QtPm10ZGluZm8tPnByaXYpLT5zdGFydCk7CisJCWtmcmVlKHNscmFtX210ZGxpc3QtPm10ZGluZm8tPnByaXYpOworCQlrZnJlZShzbHJhbV9tdGRsaXN0LT5tdGRpbmZvKTsKKwkJa2ZyZWUoc2xyYW1fbXRkbGlzdCk7CisJCXNscmFtX210ZGxpc3QgPSBuZXh0aXRlbTsKKwl9Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIGhhbmRsZV91bml0KHVuc2lnbmVkIGxvbmcgdmFsdWUsIGNoYXIgKnVuaXQpCit7CisJaWYgKCgqdW5pdCA9PSAnTScpIHx8ICgqdW5pdCA9PSAnbScpKSB7CisJCXJldHVybih2YWx1ZSAqIDEwMjQgKiAxMDI0KTsKKwl9IGVsc2UgaWYgKCgqdW5pdCA9PSAnSycpIHx8ICgqdW5pdCA9PSAnaycpKSB7CisJCXJldHVybih2YWx1ZSAqIDEwMjQpOworCX0KKwlyZXR1cm4odmFsdWUpOworfQorCitzdGF0aWMgaW50IHBhcnNlX2NtZGxpbmUoY2hhciAqZGV2bmFtZSwgY2hhciAqc3pzdGFydCwgY2hhciAqc3psZW5ndGgpCit7CisJY2hhciAqYnVmZmVyOworCXVuc2lnbmVkIGxvbmcgZGV2c3RhcnQ7CisJdW5zaWduZWQgbG9uZyBkZXZsZW5ndGg7CisJCisJaWYgKCghZGV2bmFtZSkgfHwgKCFzenN0YXJ0KSB8fCAoIXN6bGVuZ3RoKSkgeworCQl1bnJlZ2lzdGVyX2RldmljZXMoKTsKKwkJcmV0dXJuKC1FSU5WQUwpOworCX0KKworCWRldnN0YXJ0ID0gc2ltcGxlX3N0cnRvdWwoc3pzdGFydCwgJmJ1ZmZlciwgMCk7CisJZGV2c3RhcnQgPSBoYW5kbGVfdW5pdChkZXZzdGFydCwgYnVmZmVyKTsKKwkKKwlpZiAoKihzemxlbmd0aCkgIT0gJysnKSB7CisJCWRldmxlbmd0aCA9IHNpbXBsZV9zdHJ0b3VsKHN6bGVuZ3RoLCAmYnVmZmVyLCAwKTsKKwkJZGV2bGVuZ3RoID0gaGFuZGxlX3VuaXQoZGV2bGVuZ3RoLCBidWZmZXIpIC0gZGV2c3RhcnQ7CisJfSBlbHNlIHsKKwkJZGV2bGVuZ3RoID0gc2ltcGxlX3N0cnRvdWwoc3psZW5ndGggKyAxLCAmYnVmZmVyLCAwKTsKKwkJZGV2bGVuZ3RoID0gaGFuZGxlX3VuaXQoZGV2bGVuZ3RoLCBidWZmZXIpOworCX0KKwlUKCJzbHJhbTogZGV2bmFtZT0lcywgZGV2c3RhcnQ9MHglbHgsIGRldmxlbmd0aD0weCVseFxuIiwKKwkJCWRldm5hbWUsIGRldnN0YXJ0LCBkZXZsZW5ndGgpOworCWlmICgoZGV2c3RhcnQgPCAwKSB8fCAoZGV2bGVuZ3RoIDwgMCkpIHsKKwkJRSgic2xyYW06IElsbGVnYWwgc3RhcnQgLyBsZW5ndGggcGFyYW1ldGVyLlxuIik7CisJCXJldHVybigtRUlOVkFMKTsKKwl9CisJCisJaWYgKChkZXZzdGFydCA9IHJlZ2lzdGVyX2RldmljZShkZXZuYW1lLCBkZXZzdGFydCwgZGV2bGVuZ3RoKSkpeworCQl1bnJlZ2lzdGVyX2RldmljZXMoKTsKKwkJcmV0dXJuKChpbnQpZGV2c3RhcnQpOworCX0KKwlyZXR1cm4oMCk7Cit9CisKKyNpZm5kZWYgTU9EVUxFCisKK3N0YXRpYyBpbnQgX19pbml0IG10ZF9zbHJhbV9zZXR1cChjaGFyICpzdHIpCit7CisJbWFwID0gc3RyOworCXJldHVybigxKTsKK30KKworX19zZXR1cCgic2xyYW09IiwgbXRkX3NscmFtX3NldHVwKTsKKworI2VuZGlmCisKK3N0YXRpYyBpbnQgaW5pdF9zbHJhbSh2b2lkKQoreworCWNoYXIgKmRldm5hbWU7CisJaW50IGk7CisKKyNpZm5kZWYgTU9EVUxFCisJY2hhciAqZGV2c3RhcnQ7CisJY2hhciAqZGV2bGVuZ3RoOworCisJaSA9IDA7CisKKwlpZiAoIW1hcCkgeworCQlFKCJzbHJhbTogbm90IGVub3VnaCBwYXJhbWV0ZXJzLlxuIik7CisJCXJldHVybigtRUlOVkFMKTsKKwl9CisJd2hpbGUgKG1hcCkgeworCQlkZXZuYW1lID0gZGV2c3RhcnQgPSBkZXZsZW5ndGggPSBOVUxMOworCisJCWlmICghKGRldm5hbWUgPSBzdHJzZXAoJm1hcCwgIiwiKSkpIHsKKwkJCUUoInNscmFtOiBObyBkZXZpY2VuYW1lIHNwZWNpZmllZC5cbiIpOworCQkJYnJlYWs7CisJCX0KKwkJVCgic2xyYW06IGRldm5hbWUgPSAlc1xuIiwgZGV2bmFtZSk7CisJCWlmICgoIW1hcCkgfHwgKCEoZGV2c3RhcnQgPSBzdHJzZXAoJm1hcCwgIiwiKSkpKSB7CisJCQlFKCJzbHJhbTogTm8gZGV2aWNlc3RhcnQgc3BlY2lmaWVkLlxuIik7CisJCX0KKwkJVCgic2xyYW06IGRldnN0YXJ0ID0gJXNcbiIsIGRldnN0YXJ0KTsKKwkJaWYgKCghbWFwKSB8fCAoIShkZXZsZW5ndGggPSBzdHJzZXAoJm1hcCwgIiwiKSkpKSB7CisJCQlFKCJzbHJhbTogTm8gZGV2aWNlbGVuZ3RoIC8gLWVuZCBzcGVjaWZpZWQuXG4iKTsKKwkJfQorCQlUKCJzbHJhbTogZGV2bGVuZ3RoID0gJXNcbiIsIGRldmxlbmd0aCk7CisJCWlmIChwYXJzZV9jbWRsaW5lKGRldm5hbWUsIGRldnN0YXJ0LCBkZXZsZW5ndGgpICE9IDApIHsKKwkJCXJldHVybigtRUlOVkFMKTsKKwkJfQorCX0KKyNlbHNlCisJaW50IGNvdW50OworCQorCWZvciAoY291bnQgPSAwOyAobWFwW2NvdW50XSkgJiYgKGNvdW50IDwgU0xSQU1fTUFYX0RFVklDRVNfUEFSQU1TKTsKKwkJCWNvdW50KyspIHsKKwl9CisKKwlpZiAoKGNvdW50ICUgMyAhPSAwKSB8fCAoY291bnQgPT0gMCkpIHsKKwkJRSgic2xyYW06IG5vdCBlbm91Z2ggcGFyYW1ldGVycy5cbiIpOworCQlyZXR1cm4oLUVJTlZBTCk7CisJfQorCWZvciAoaSA9IDA7IGkgPCAoY291bnQgLyAzKTsgaSsrKSB7CisJCWRldm5hbWUgPSBtYXBbaSAqIDNdOworCisJCWlmIChwYXJzZV9jbWRsaW5lKGRldm5hbWUsIG1hcFtpICogMyArIDFdLCBtYXBbaSAqIDMgKyAyXSkhPTApIHsKKwkJCXJldHVybigtRUlOVkFMKTsKKwkJfQorCQkKKwl9CisjZW5kaWYgLyogIU1PRFVMRSAqLworCQorCXJldHVybigwKTsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGNsZWFudXBfc2xyYW0odm9pZCkKK3sKKwl1bnJlZ2lzdGVyX2RldmljZXMoKTsKK30KKworbW9kdWxlX2luaXQoaW5pdF9zbHJhbSk7Cittb2R1bGVfZXhpdChjbGVhbnVwX3NscmFtKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiSm9jaGVuIFNjaGFldWJsZSA8cHNpb25pY0Bwc2lvbmljLmRlPiIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJNVEQgZHJpdmVyIGZvciB1bmNhY2hlZCBzeXN0ZW0gUkFNIik7Cg==